diff --git a/.config/dotnet-tools.json b/.config/dotnet-tools.json index 2f4ce2358e0..5dc9bb8d5f5 100644 --- a/.config/dotnet-tools.json +++ b/.config/dotnet-tools.json @@ -15,7 +15,7 @@ ] }, "microsoft.dotnet.xharness.cli": { - "version": "9.0.0-prerelease.24405.1", + "version": "10.0.0-prerelease.24466.1", "commands": [ "xharness" ] diff --git a/.github/workflows/inter-branch-merge-flow.yml b/.github/workflows/inter-branch-merge-flow.yml new file mode 100644 index 00000000000..20246c14fc5 --- /dev/null +++ b/.github/workflows/inter-branch-merge-flow.yml @@ -0,0 +1,13 @@ +name: Inter-branch merge workflow +on: + push: + branches: + - release/** + +permissions: + contents: write + pull-requests: write + +jobs: + Merge: + uses: dotnet/arcade/.github/workflows/inter-branch-merge-base.yml@main \ No newline at end of file diff --git a/.github/workflows/jit-format.yml b/.github/workflows/jit-format.yml index be0a5d854a9..18fb209c628 100644 --- a/.github/workflows/jit-format.yml +++ b/.github/workflows/jit-format.yml @@ -15,7 +15,7 @@ jobs: os: - name: linux image: ubuntu-latest - container: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-cross-amd64-net9.0 + container: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-amd64 extension: '.sh' cross: '--cross' rootfs: '/crossrootfs/x64' diff --git a/Directory.Build.props b/Directory.Build.props index 726c8923b88..d483fa49709 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -485,6 +485,8 @@ true + + false $(NoWarn);SYSLIB0011;SYSLIB0050;SYSLIB0051 diff --git a/Directory.Build.targets b/Directory.Build.targets index bc5b847efc6..279184d1eb0 100644 --- a/Directory.Build.targets +++ b/Directory.Build.targets @@ -162,7 +162,7 @@ AfterTargets="ResolveTargetingPackAssets"> <_targetingPackReferenceExclusion Include="$(TargetName)" /> - <_targetingPackReferenceExclusion Include="@(_ResolvedProjectReferencePaths->Metadata('Filename'))" /> + <_targetingPackReferenceExclusionProjects Include="@(_ResolvedProjectReferencePaths->Metadata('Filename'))" /> <_targetingPackReferenceExclusion Include="@(DefaultReferenceExclusion)" /> @@ -177,7 +177,7 @@ <_targetingPackReferenceWithProjectName Include="@(Reference->WithMetadataValue('ExternallyResolved', 'true')->Metadata('Filename'))" OriginalIdentity="%(Identity)" /> <_targetingPackIncludedReferenceWithProjectName Include="@(_targetingPackReferenceWithProjectName)" - Exclude="@(_targetingPackReferenceExclusion)" /> + Exclude="@(_targetingPackReferenceExclusion);@(_targetingPackReferenceExclusionProjects->WithMetadataValue('ReferenceOutputAssembly', 'true'))" /> <_targetingPackExcludedReferenceWithProjectName Include="@(_targetingPackReferenceWithProjectName)" Exclude="@(_targetingPackIncludedReferenceWithProjectName)" /> @@ -187,7 +187,7 @@ <_targetingPackAnalyzerReferenceWithProjectName Include="@(Analyzer->WithMetadataValue('ExternallyResolved', 'true')->Metadata('Filename'))" OriginalIdentity="%(Identity)" /> <_targetingPackIncludedAnalyzerReferenceWithProjectName Include="@(_targetingPackAnalyzerReferenceWithProjectName)" - Exclude="@(_targetingPackReferenceExclusion)" /> + Exclude="@(_targetingPackReferenceExclusion);@(_targetingPackReferenceExclusionProjects->WithMetadataValue('OutputItemType', 'Analyzer'))" /> <_targetingPackExcludedAnalyzerReferenceWithProjectName Include="@(_targetingPackAnalyzerReferenceWithProjectName)" Exclude="@(_targetingPackIncludedAnalyzerReferenceWithProjectName)" /> diff --git a/NuGet.config b/NuGet.config index c9f91b53273..3a61ca31799 100644 --- a/NuGet.config +++ b/NuGet.config @@ -20,6 +20,8 @@ + + diff --git a/THIRD-PARTY-NOTICES.TXT b/THIRD-PARTY-NOTICES.TXT index 18e149ccfd1..3dc0d7aa859 100644 --- a/THIRD-PARTY-NOTICES.TXT +++ b/THIRD-PARTY-NOTICES.TXT @@ -69,19 +69,27 @@ written authorization of the copyright holder. License notice for zlib-ng ----------------------- -https://github.com/zlib-ng/zlib-ng/blob/develop/LICENSE.md +https://github.com/zlib-ng/zlib-ng/blob/d54e3769be0c522015b784eca2af258b1c026107/LICENSE.md (C) 1995-2024 Jean-loup Gailly and Mark Adler -This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any damages +arising from the use of this software. -Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: +Permission is granted to anyone to use this software for any purpose, +including commercial applications, and to alter it and redistribute it +freely, subject to the following restrictions: -The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. +1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. -Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. +2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. -This notice may not be removed or altered from any source distribution. +3. This notice may not be removed or altered from any source distribution. License notice for LinuxTracepoints ----------------------------------- diff --git a/docs/area-owners.md b/docs/area-owners.md index 59c7e97da44..9aa33a8a52f 100644 --- a/docs/area-owners.md +++ b/docs/area-owners.md @@ -65,6 +65,7 @@ Note: Editing this file doesn't update the mapping used by `@msftbot` for area-s | area-Single-File | @agocke | @vitek-karas @vsadov | | | area-Snap | @MichaelSimons | @NikolaMilosavljevic @leecow @MichaelSimons | | | area-System.Buffers | @jeffhandley | @dotnet/area-system-buffers | | +| area-System.ClientModel | @terrajobst | @dotnet/fxdc | Bugs and feature requests should go to https://github.com/Azure/azure-sdk-for-net/issues. We don't own the code, but FXDC reviews changes to determine overlap with other `System` concepts. The Azure SDK team will post API updates in this repo for us to review. | | area-System.CodeDom | @ericstj | @dotnet/area-system-codedom | | | area-System.Collections | @jeffhandley | @dotnet/area-system-collections | Excluded:
  • System.Array -> System.Runtime
| | area-System.ComponentModel | @ericstj | @dotnet/area-system-componentmodel | Consultants: @dotnet/dotnet-winforms | diff --git a/docs/coding-guidelines/libraries-packaging.md b/docs/coding-guidelines/libraries-packaging.md index 61829fe5459..0ae462bc713 100644 --- a/docs/coding-guidelines/libraries-packaging.md +++ b/docs/coding-guidelines/libraries-packaging.md @@ -18,6 +18,14 @@ Source generators and analyzers can be included in the shared framework by addin Removing a library from the shared framework is a breaking change and should be avoided. +### References to libraries in the shared framework that produce packages + +It's beneficial to avoid project references to libraries that are in the shared framework because it makes the package graph smaller which reduces the number of packages that require servicing and the number of libraries that end up being copied into the application directory. + +If a dependency is part of the shared framework a project/package reference is never required on the latest version (`NetCoreAppCurrent`). A reference is required for previous .NET versions even if the dependency is part of the shared framework if the project you are building targets .NETStandard and references the project there. You may completely avoid a package dependency on .NETStandard and .NET if it's not needed for .NETStandard (for example - if it is an implementation only dependency and you're building a PNSE assembly for .NETStandard). + +Warning NETPKG0001 is emitted when you have an unnecessary reference to a library that is part of the shared framework. To avoid this warning, make sure your ProjectReference is conditioned so that it doesn't apply on `NetCoreAppCurrent`. + ## Transport package Transport packages are non-shipping packages that dotnet/runtime produces in order to share binaries with other repositories. diff --git a/docs/deep-dive-blog-posts.md b/docs/deep-dive-blog-posts.md index 56e29a1f587..367cd30b264 100644 --- a/docs/deep-dive-blog-posts.md +++ b/docs/deep-dive-blog-posts.md @@ -10,6 +10,7 @@ - [Performance Improvements in .NET 6](https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-6/) - [Performance Improvements in .NET 7](https://devblogs.microsoft.com/dotnet/performance_improvements_in_net_7/) - [Performance Improvements in .NET 8](https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-8/) +- [Performance Improvements in .NET 9](https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-9/) ### Posts that take a high-level look at the entire source: diff --git a/docs/design/coreclr/botr/clr-abi.md b/docs/design/coreclr/botr/clr-abi.md index 1347b2c0c6b..7da3805324e 100644 --- a/docs/design/coreclr/botr/clr-abi.md +++ b/docs/design/coreclr/botr/clr-abi.md @@ -23,11 +23,14 @@ ARM64: See [Overview of ARM64 ABI conventions](https://learn.microsoft.com/cpp/b ## Non-Windows ABI documentation Arm corporation ABI documentation (for ARM32 and ARM64) is [here](https://developer.arm.com/architectures/system-architectures/software-standards/abi) and [here](https://github.com/ARM-software/abi-aa). +Apple's ARM64 calling convention differences can be found [here](https://developer.apple.com/documentation/xcode/writing-arm64-code-for-apple-platforms). The Linux System V x86_64 ABI is documented in [System V Application Binary Interface / AMD64 Architecture Processor Supplement](https://github.com/hjl-tools/x86-psABI/wiki/x86-64-psABI-1.0.pdf), with document source material [here](https://gitlab.com/x86-psABIs/x86-64-ABI). The LoongArch64 ABI documentation is [here](https://github.com/loongson/LoongArch-Documentation/blob/main/docs/LoongArch-ELF-ABI-EN.adoc) +The RISC-V ABIs Specification: [latest release](https://github.com/riscv-non-isa/riscv-elf-psabi-doc/releases/latest), [latest draft](https://github.com/riscv-non-isa/riscv-elf-psabi-doc/releases), [document source repo](https://github.com/riscv-non-isa/riscv-elf-psabi-doc). + # General Unwind/Frame Layout For all non-x86 platforms, all methods must have unwind information so the garbage collector (GC) can unwind them (unlike native code in which a leaf method may be omitted). @@ -76,7 +79,9 @@ On ARM and ARM64, just like native, nothing is put in the floating point registe However, unlike native varargs, all floating point arguments are not promoted to double (`R8`), and instead retain their original type (`R4` or `R8`) (although this does not preclude an IL generator like managed C++ from explicitly injecting an upcast at the call-site and adjusting the call-site-sig appropriately). This leads to unexpected behavior when native C++ is ported to C# or even just managed via the different flavors of managed C++. -Managed varargs are not supported in .NET Core. +Managed varargs are supported on Windows only. + +Managed/native varargs are supported on Windows only. Support for managed/native varargs on non-Windows platforms is tracked by [this issue](https://github.com/dotnet/runtime/issues/82081). ## Generics @@ -97,6 +102,10 @@ Just like native, AMD64 has implicit-byrefs. Any structure (value type in IL par The AMD64 native calling conventions (Windows 64 and System V) require return buffer address to be returned by callee in RAX. JIT also follows this rule. +## RISC-V only: structs passed/returned according to hardware floating-point calling convention + +Passing/returning structs according to hardware floating-point calling convention like native is currently [supported only up to 16 bytes](https://github.com/dotnet/runtime/issues/107386), ones larger than that differ from the standard ABI and are passed/returned according to integer calling convention (by implicit reference). + ## Return buffers The same applies to some return buffers. See `MethodTable::IsStructRequiringStackAllocRetBuf()`. When that returns `false`, the return buffer might be on the heap, either due to reflection/remoting code paths mentioned previously or due to a JIT optimization where a call with a return buffer that then assigns to a field (on the GC heap) are changed into passing the field reference as the return buffer. Conversely, when it returns true, the JIT does not need to use a write barrier when storing to the return buffer, but it is still not guaranteed to be a compiler temp, and as such the JIT should not introduce spurious writes to the return buffer. @@ -117,6 +126,12 @@ ARM64-only: When a method returns a structure that is larger than 16 bytes the c Primitive value types smaller than 32-bits are widened to 32-bits: signed small types are sign extended and unsigned small types are zero extended. This can be different from the standard calling conventions that may leave the state of unused bits in the return register undefined. +## Small primitive arguments + +Small primitive arguments have undefined upper bits. This can be different from the standard calling conventions that may require normalization (e.g. on ARM32 and Apple ARM64). + +On RISC-V small primitive arguments are extended according to standard calling conventions. + # PInvokes The convention is that any method with an InlinedCallFrame (either an IL stub or a normal method with an inlined PInvoke) saves/restores all non-volatile integer registers in its prolog/epilog respectively. This is done so that the InlinedCallFrame can just contain a return address, a stack pointer and a frame pointer. Then using just those three it can start a full stack walk using the normal RtlVirtualUnwind. diff --git a/docs/design/datacontracts/EcmaMetadata.md b/docs/design/datacontracts/EcmaMetadata.md new file mode 100644 index 00000000000..a5b445f10dc --- /dev/null +++ b/docs/design/datacontracts/EcmaMetadata.md @@ -0,0 +1,340 @@ +# Contract EcmaMetadata + +This contract provides methods to get a view of the ECMA-335 metadata for a given module. + +## APIs of contract + +```csharp +TargetSpan GetReadOnlyMetadataAddress(ModuleHandle handle); +System.Reflection.Metadata.MetadataReader? GetMetadata(ModuleHandle handle); +``` + +Types from other contracts: + +| Type | Contract | +|------|----------| +| ModuleHandle | [Loader](./Loader.md#apis-of-contract) | + +## Version 1 + + +Data descriptors used: +| Data Descriptor Name | Field | Meaning | +| --- | --- | --- | +| `Module` | `Base` | Pointer to start of PE file in memory | +| `Module` | `DynamicMetadata` | Pointer to saved metadata for reflection emit modules | +| `Module` | `FieldDefToDescMap` | Mapping table | +| `DynamicMetadata` | `Size` | Size of the dynamic metadata blob (as a 32bit uint) | +| `DynamicMetadata` | `Data` | Start of dynamic metadata data array | + + +```csharp +using System.IO; +using System.Reflection.Metadata; +using System.Runtime.InteropServices; + +TargetSpan GetReadOnlyMetadataAddress(ModuleHandle handle) +{ + TargetPointer baseAddress = Target.ReadPointer(handle.Address + /* Module::Base offset */); + if (baseAddress == TargetPointer.Null) + { + return default; + } + + // Read CLR header per https://learn.microsoft.com/windows/win32/debug/pe-format + ulong clrHeaderRVA = ... + + // Read Metadata per ECMA-335 II.25.3.3 CLI Header + ulong metadataDirectoryAddress = baseAddress + clrHeaderRva + /* offset to Metadata */ + int rva = Target.Read(metadataDirectoryAddress); + ulong size = Target.Read(metadataDirectoryAddress + sizeof(int)); + return new(baseAddress + rva, size); +} + +MetadataReader? GetMetadata(ModuleHandle handle) +{ + AvailableMetadataType type = GetAvailableMetadataType(handle); + + switch (type) + { + case AvailableMetadataType.None: + return null; + case AvailableMetadataType.ReadOnly: + { + TargetSpan address = GetReadOnlyMetadataAddress(handle); + byte[] data = new byte[address.Size]; + _target.ReadBuffer(address.Address, data); + return MetadataReaderProvider.FromMetadataImage(ImmutableCollectionsMarshal.AsImmutableArray(data)).GetMetadataReader(); + } + case AvailableMetadataType.ReadWriteSavedCopy: + { + TargetSpan address = GetReadWriteSavedMetadataAddress(handle); + byte[] data = new byte[address.Size]; + _target.ReadBuffer(address.Address, data); + return MetadataReaderProvider.FromMetadataImage(ImmutableCollectionsMarshal.AsImmutableArray(data)).GetMetadataReader(); + } + case AvailableMetadataType.ReadWrite: + { + var targetEcmaMetadata = GetReadWriteMetadata(handle); + + // From the multiple different target spans, we need to build a single + // contiguous ECMA-335 metadata blob. + BlobBuilder builder = new BlobBuilder(); + builder.WriteUInt32(0x424A5342); + + // major version + builder.WriteUInt16(1); + + // minor version + builder.WriteUInt16(1); + + // reserved + builder.WriteUInt32(0); + + string version = targetEcmaMetadata.Schema.MetadataVersion; + builder.WriteInt32(AlignUp(version.Length, 4)); + Write4ByteAlignedString(builder, version); + + // reserved + builder.WriteUInt16(0); + + // number of streams + ushort numStreams = 5; // #Strings, #US, #Blob, #GUID, #~ (metadata) + if (targetEcmaMetadata.Schema.VariableSizedColumnsAreAll4BytesLong) + { + // We direct MetadataReader to use 4-byte encoding for all variable-sized columns + // by providing the marker stream for a "minimal delta" image. + numStreams++; + } + builder.WriteUInt16(numStreams); + + // Write Stream headers + if (targetEcmaMetadata.Schema.VariableSizedColumnsAreAll4BytesLong) + { + // Write the #JTD stream to indicate that all variable-sized columns are 4 bytes long. + WriteStreamHeader(builder, "#JTD", 0).WriteInt32(builder.Count); + } + + BlobWriter stringsOffset = WriteStreamHeader(builder, "#Strings", (int)AlignUp(targetEcmaMetadata.StringHeap.Size, 4ul)); + BlobWriter blobOffset = WriteStreamHeader(builder, "#Blob", (int)targetEcmaMetadata.BlobHeap.Size); + BlobWriter guidOffset = WriteStreamHeader(builder, "#GUID", (int)targetEcmaMetadata.GuidHeap.Size); + BlobWriter userStringOffset = WriteStreamHeader(builder, "#US", (int)targetEcmaMetadata.UserStringHeap.Size); + + // We'll use the "uncompressed" tables stream name as the runtime may have created the *Ptr tables + // that are only present in the uncompressed tables stream. + BlobWriter tablesOffset = WriteStreamHeader(builder, "#-", 0); + + // Write the heap-style Streams + + stringsOffset.WriteInt32(builder.Count); + WriteTargetSpan(builder, targetEcmaMetadata.StringHeap); + for (ulong i = targetEcmaMetadata.StringHeap.Size; i < AlignUp(targetEcmaMetadata.StringHeap.Size, 4ul); i++) + { + builder.WriteByte(0); + } + + blobOffset.WriteInt32(builder.Count); + WriteTargetSpan(builder, targetEcmaMetadata.BlobHeap); + + guidOffset.WriteInt32(builder.Count); + WriteTargetSpan(builder, targetEcmaMetadata.GuidHeap); + + userStringOffset.WriteInt32(builder.Count); + WriteTargetSpan(builder, targetEcmaMetadata.UserStringHeap); + + // Write tables stream + tablesOffset.WriteInt32(builder.Count); + + // Write tables stream header + builder.WriteInt32(0); // reserved + builder.WriteByte(2); // major version + builder.WriteByte(0); // minor version + uint heapSizes = + (targetEcmaMetadata.Schema.LargeStringHeap ? 1u << 0 : 0) | + (targetEcmaMetadata.Schema.LargeBlobHeap ? 1u << 1 : 0) | + (targetEcmaMetadata.Schema.LargeGuidHeap ? 1u << 2 : 0); + + builder.WriteByte((byte)heapSizes); + builder.WriteByte(1); // reserved + + ulong validTables = 0; + for (int i = 0; i < targetEcmaMetadata.Schema.RowCount.Length; i++) + { + if (targetEcmaMetadata.Schema.RowCount[i] != 0) + { + validTables |= 1ul << i; + } + } + + ulong sortedTables = 0; + for (int i = 0; i < targetEcmaMetadata.Schema.IsSorted.Length; i++) + { + if (targetEcmaMetadata.Schema.IsSorted[i]) + { + sortedTables |= 1ul << i; + } + } + + builder.WriteUInt64(validTables); + builder.WriteUInt64(sortedTables); + + foreach (int rowCount in targetEcmaMetadata.Schema.RowCount) + { + if (rowCount > 0) + { + builder.WriteInt32(rowCount); + } + } + + // Write the tables + foreach (TargetSpan span in targetEcmaMetadata.Tables) + { + WriteTargetSpan(builder, span); + } + + MemoryStream metadataStream = new MemoryStream(); + builder.WriteContentTo(metadataStream); + return MetadataReaderProvider.FromMetadataStream(metadataStream).GetMetadataReader(); + + void WriteTargetSpan(BlobBuilder builder, TargetSpan span) + { + Blob blob = builder.ReserveBytes(checked((int)span.Size)); + _target.ReadBuffer(span.Address, blob.GetBytes().AsSpan()); + } + + static BlobWriter WriteStreamHeader(BlobBuilder builder, string name, int size) + { + BlobWriter offset = new(builder.ReserveBytes(4)); + builder.WriteInt32(size); + Write4ByteAlignedString(builder, name); + return offset; + } + + static void Write4ByteAlignedString(BlobBuilder builder, string value) + { + int bufferStart = builder.Count; + builder.WriteUTF8(value); + builder.WriteByte(0); + int stringEnd = builder.Count; + for (int i = stringEnd; i < bufferStart + AlignUp(value.Length, 4); i++) + { + builder.WriteByte(0); + } + } + } + } +} +``` + +### Helper Methods + +``` csharp +using System; +using System.Numerics; + +struct EcmaMetadataSchema +{ + public EcmaMetadataSchema(string metadataVersion, bool largeStringHeap, bool largeBlobHeap, bool largeGuidHeap, int[] rowCount, bool[] isSorted, bool variableSizedColumnsAre4BytesLong) + { + MetadataVersion = metadataVersion; + LargeStringHeap = largeStringHeap; + LargeBlobHeap = largeBlobHeap; + LargeGuidHeap = largeGuidHeap; + + _rowCount = rowCount; + _isSorted = isSorted; + + VariableSizedColumnsAreAll4BytesLong = variableSizedColumnsAre4BytesLong; + } + + public readonly string MetadataVersion; + + public readonly bool LargeStringHeap; + public readonly bool LargeBlobHeap; + public readonly bool LargeGuidHeap; + + // Table data, these structures hold MetadataTable.Count entries + private readonly int[] _rowCount; + public readonly ReadOnlySpan RowCount => _rowCount; + + private readonly bool[] _isSorted; + public readonly ReadOnlySpan IsSorted => _isSorted; + + // In certain scenarios the size of the tables is forced to be the maximum size + // Otherwise the size of columns should be computed based on RowSize/the various heap flags + public readonly bool VariableSizedColumnsAreAll4BytesLong; +} + +class TargetEcmaMetadata +{ + public TargetEcmaMetadata(EcmaMetadataSchema schema, + TargetSpan[] tables, + TargetSpan stringHeap, + TargetSpan userStringHeap, + TargetSpan blobHeap, + TargetSpan guidHeap) + { + Schema = schema; + _tables = tables; + StringHeap = stringHeap; + UserStringHeap = userStringHeap; + BlobHeap = blobHeap; + GuidHeap = guidHeap; + } + + public EcmaMetadataSchema Schema { get; init; } + + private TargetSpan[] _tables; + public ReadOnlySpan Tables => _tables; + public TargetSpan StringHeap { get; init; } + public TargetSpan UserStringHeap { get; init; } + public TargetSpan BlobHeap { get; init; } + public TargetSpan GuidHeap { get; init; } +} + +[Flags] +enum AvailableMetadataType +{ + None = 0, + ReadOnly = 1, + ReadWriteSavedCopy = 2, + ReadWrite = 4 +} + +AvailableMetadataType GetAvailableMetadataType(ModuleHandle handle) +{ + Data.Module module = new Data.Module(Target, handle.Address); + + AvailableMetadataType flags = AvailableMetadataType.None; + + TargetPointer dynamicMetadata = Target.ReadPointer(handle.Address + /* Module::DynamicMetadata offset */); + + if (dynamicMetadata != TargetPointer.Null) + flags |= AvailableMetadataType.ReadWriteSavedCopy; + else + flags |= AvailableMetadataType.ReadOnly; + + return flags; +} + +TargetSpan GetReadWriteSavedMetadataAddress(ModuleHandle handle) +{ + Data.Module module = new Data.Module(Target, handle.Address); + TargetPointer dynamicMetadata = Target.ReadPointer(handle.Address + /* Module::DynamicMetadata offset */); + + ulong size = Target.Read(handle.Address + /* DynamicMetadata::Size offset */); + TargetPointer result = handle.Address + /* DynamicMetadata::Data offset */; + return new(result, size); +} + +TargetEcmaMetadata GetReadWriteMetadata(ModuleHandle handle) +{ + // [cdac] TODO. +} + +T AlignUp(T input, T alignment) + where T : IBinaryInteger +{ + return input + (alignment - T.One) & ~(alignment - T.One); +} +``` diff --git a/docs/design/datacontracts/Loader.md b/docs/design/datacontracts/Loader.md index bc45eaee7a6..d0fe390b5ad 100644 --- a/docs/design/datacontracts/Loader.md +++ b/docs/design/datacontracts/Loader.md @@ -25,89 +25,18 @@ record struct ModuleLookupTables( TargetPointer MemberRefToDesc, TargetPointer MethodDefToDesc, TargetPointer TypeDefToMethodTable, - TargetPointer TypeRefToMethodTable); - -internal struct EcmaMetadataSchema -{ - public EcmaMetadataSchema(string metadataVersion, bool largeStringHeap, bool largeBlobHeap, bool largeGuidHeap, int[] rowCount, bool[] isSorted, bool variableSizedColumnsAre4BytesLong) - { - MetadataVersion = metadataVersion; - LargeStringHeap = largeStringHeap; - LargeBlobHeap = largeBlobHeap; - LargeGuidHeap = largeGuidHeap; - - _rowCount = rowCount; - _isSorted = isSorted; - - VariableSizedColumnsAreAll4BytesLong = variableSizedColumnsAre4BytesLong; - } - - public readonly string MetadataVersion; - - public readonly bool LargeStringHeap; - public readonly bool LargeBlobHeap; - public readonly bool LargeGuidHeap; - - // Table data, these structures hold MetadataTable.Count entries - private readonly int[] _rowCount; - public readonly ReadOnlySpan RowCount => _rowCount; - - private readonly bool[] _isSorted; - public readonly ReadOnlySpan IsSorted => _isSorted; - - // In certain scenarios the size of the tables is forced to be the maximum size - // Otherwise the size of columns should be computed based on RowSize/the various heap flags - public readonly bool VariableSizedColumnsAreAll4BytesLong; -} - -internal class TargetEcmaMetadata -{ - public TargetEcmaMetadata(EcmaMetadataSchema schema, - TargetSpan[] tables, - TargetSpan stringHeap, - TargetSpan userStringHeap, - TargetSpan blobHeap, - TargetSpan guidHeap) - { - Schema = schema; - _tables = tables; - StringHeap = stringHeap; - UserStringHeap = userStringHeap; - BlobHeap = blobHeap; - GuidHeap = guidHeap; - } - - public EcmaMetadataSchema Schema { get; init; } - - private TargetSpan[] _tables; - public ReadOnlySpan Tables => _tables; - public TargetSpan StringHeap { get; init; } - public TargetSpan UserStringHeap { get; init; } - public TargetSpan BlobHeap { get; init; } - public TargetSpan GuidHeap { get; init; } -} - -[Flags] -internal enum AvailableMetadataType -{ - None = 0, - ReadOnly = 1, - ReadWriteSavedCopy = 2, - ReadWrite = 4 -} + TargetPointer TypeRefToMethodTable, + TargetPointer MethodDefToILCodeVersioningState); ``` ``` csharp -ModuleHandle GetModuleHandle(TargetPointer); +ModuleHandle GetModuleHandle(TargetPointer module); TargetPointer GetAssembly(ModuleHandle handle); ModuleFlags GetFlags(ModuleHandle handle); +string GetPath(ModuleHandle handle); TargetPointer GetLoaderAllocator(ModuleHandle handle); TargetPointer GetThunkHeap(ModuleHandle handle); TargetPointer GetILBase(ModuleHandle handle); -TargetPointer GetMetadataAddress(ModuleHandle handle, out ulong size); -AvailableMetadataType GetAvailableMetadataType(ModuleHandle handle); -TargetPointer GetReadWriteSavedMetadataAddress(ModuleHandle handle, out ulong size); -TargetEcmaMetadata GetReadWriteMetadata(ModuleHandle handle); ModuleLookupTables GetLookupTables(ModuleHandle handle); ``` @@ -121,15 +50,14 @@ Data descriptors used: | `Module` | `Flags` | Assembly of the Module | | `Module` | `LoaderAllocator` | LoaderAllocator of the Module | | `Module` | `ThunkHeap` | Pointer to the thunk heap | -| `Module` | `DynamicMetadata` | Pointer to saved metadata for reflection emit modules | +| `Module` | `Path` | Path of the Module (UTF-16, null-terminated) | | `Module` | `FieldDefToDescMap` | Mapping table | | `Module` | `ManifestModuleReferencesMap` | Mapping table | | `Module` | `MemberRefToDescMap` | Mapping table | | `Module` | `MethodDefToDescMap` | Mapping table | | `Module` | `TypeDefToMethodTableMap` | Mapping table | | `Module` | `TypeRefToMethodTableMap` | Mapping table | -| `DynamicMetadata` | `Size` | Size of the dynamic metadata blob (as a 32bit uint) | -| `DynamicMetadata` | `Data` | Start of dynamic metadata data array | +| `ModuleLookupMap` | `TableData` | Start of the mapping table's data | ``` csharp ModuleHandle GetModuleHandle(TargetPointer modulePointer) @@ -147,6 +75,13 @@ ModuleFlags GetFlags(ModuleHandle handle) return target.Read(handle.Address + /* Module::Flags offset */); } +string GetPath(ModuleHandle handle) +{ + TargetPointer pathStart = target.ReadPointer(handle.Address + /* Module::Path offset */); + char[] path = // Read from target starting at pathStart until null terminator + return new string(path); +} + TargetPointer GetLoaderAllocator(ModuleHandle handle) { return target.ReadPointer(handle.Address + /* Module::LoaderAllocator offset */); @@ -162,51 +97,6 @@ TargetPointer GetILBase(ModuleHandle handle) return target.ReadPointer(handle.Address + /* Module::Base offset */); } -TargetPointer GetMetadataAddress(ModuleHandle handle, out ulong size) -{ - TargetPointer baseAddress = GetILBase(handle); - if (baseAddress == TargetPointer.Null) - { - size = 0; - return TargetPointer.Null; - } - - // Read CLR header per https://learn.microsoft.com/windows/win32/debug/pe-format - ulong clrHeaderRVA = ... - - // Read Metadata per ECMA-335 II.25.3.3 CLI Header - ulong metadataDirectoryAddress = baseAddress + clrHeaderRva + /* offset to Metadata */ - int rva = target.Read(metadataDirectoryAddress); - size = target.Read(metadataDirectoryAddress + sizeof(int)); - return baseAddress + rva; -} - -AvailableMetadataType ILoader.GetAvailableMetadataType(ModuleHandle handle) -{ - Data.Module module = _target.ProcessedData.GetOrAdd(handle.Address); - - AvailableMetadataType flags = AvailableMetadataType.None; - - TargetPointer dynamicMetadata = target.ReadPointer(handle.Address + /* Module::DynamicMetadata offset */); - - if (dynamicMetadata != TargetPointer.Null) - flags |= AvailableMetadataType.ReadWriteSavedCopy; - else - flags |= AvailableMetadataType.ReadOnly; - - return flags; -} - -TargetPointer ILoader.GetReadWriteSavedMetadataAddress(ModuleHandle handle, out ulong size) -{ - Data.Module module = _target.ProcessedData.GetOrAdd(handle.Address); - TargetPointer dynamicMetadata = target.ReadPointer(handle.Address + /* Module::DynamicMetadata offset */); - - size = target.Read(handle.Address + /* DynamicMetadata::Size offset */); - TargetPointer result = handle.Address + /* DynamicMetadata::Data offset */; - return result; -} - ModuleLookupTables GetLookupTables(ModuleHandle handle) { return new ModuleLookupTables( @@ -215,6 +105,8 @@ ModuleLookupTables GetLookupTables(ModuleHandle handle) MemberRefToDescMap: target.ReadPointer(handle.Address + /* Module::MemberRefToDescMap */), MethodDefToDescMap: target.ReadPointer(handle.Address + /* Module::MethodDefToDescMap */), TypeDefToMethodTableMap: target.ReadPointer(handle.Address + /* Module::TypeDefToMethodTableMap */), - TypeRefToMethodTableMap: target.ReadPointer(handle.Address + /* Module::TypeRefToMethodTableMap */)); + TypeRefToMethodTableMap: target.ReadPointer(handle.Address + /* Module::TypeRefToMethodTableMap */), + MethodDefToILCodeVersioningState: target.ReadPointer(handle.Address + /* + Module::MethodDefToILCodeVersioningState */)); } ``` diff --git a/docs/design/datacontracts/RuntimeTypeSystem.md b/docs/design/datacontracts/RuntimeTypeSystem.md index 5693ab205ce..8accd2e6dc6 100644 --- a/docs/design/datacontracts/RuntimeTypeSystem.md +++ b/docs/design/datacontracts/RuntimeTypeSystem.md @@ -23,6 +23,7 @@ internal enum CorElementType // Values defined in ECMA-335 - II.23.1.16 Element types used in signatures // + Internal = 0x21, // Indicates that the next pointer sized number of bytes is the address of a TypeHandle. Signatures that contain the Internal CorElementType cannot exist in metadata that is saved into a serialized format. + CModInternal = 0x22, // Indicates that the next byte specifies if the modifier is required and the next pointer sized number of bytes after that is the address of a TypeHandle. Signatures that contain the CModInternal CorElementType cannot exist in metadata that is saved into a seralized format. } ``` @@ -92,12 +93,51 @@ struct MethodDescHandle } ``` +```csharp +public enum ArrayFunctionType +{ + Get = 0, + Set = 1, + Address = 2, + Constructor = 3 +} +``` + ```csharp partial interface IRuntimeTypeSystem : IContract { public virtual MethodDescHandle GetMethodDescHandle(TargetPointer methodDescPointer); public virtual TargetPointer GetMethodTable(MethodDescHandle methodDesc); + + // Return true for an uninstantiated generic method + public virtual bool IsGenericMethodDefinition(MethodDescHandle methodDesc); + + public virtual ReadOnlySpan GetGenericMethodInstantiation(MethodDescHandle methodDesc); + + // Return mdTokenNil (0x06000000) if the method doesn't have a token, otherwise return the token of the method + public virtual uint GetMethodToken(MethodDescHandle methodDesc); + + // Return true if a MethodDesc represents an array method + // An array method is also a StoredSigMethodDesc + public virtual bool IsArrayMethod(MethodDescHandle methodDesc, out ArrayFunctionType functionType); + + // Return true if a MethodDesc represents a method without metadata method, either an IL Stub dynamically + // generated by the runtime, or a MethodDesc that describes a method represented by the System.Reflection.Emit.DynamicMethod class + // Or something else similar. + // A no metadata method is also a StoredSigMethodDesc + public virtual bool IsNoMetadataMethod(MethodDescHandle methodDesc, out string methodName); + + // A StoredSigMethodDesc is a MethodDesc for which the signature isn't found in metadata. + public virtual bool IsStoredSigMethodDesc(MethodDescHandle methodDesc, out ReadOnlySpan signature); + + // Return true for a MethodDesc that describes a method represented by the System.Reflection.Emit.DynamicMethod class + // A DynamicMethod is also a StoredSigMethodDesc, and a NoMetadataMethod + public virtual bool IsDynamicMethod(MethodDescHandle methodDesc); + + // Return true if a MethodDesc represents an IL Stub dynamically generated by the runtime + // A IL Stub method is also a StoredSigMethodDesc, and a NoMetadataMethod + public virtual bool IsILStub(MethodDescHandle methodDesc); } ``` @@ -293,6 +333,7 @@ The contract additionally depends on these data descriptors | `FnPtrTypeDesc` | `NumArgs` | Number of arguments to the function described by the `TypeDesc` | | `FnPtrTypeDesc` | `CallConv` | Lower 8 bits is the calling convention bit as extracted by the signature that defines this `TypeDesc` | | `FnPtrTypeDesc` | `RetAndArgTypes` | Pointer to an array of TypeHandle addresses. This length of this is 1 more than `NumArgs` | +| `GenericsDictInfo` | `NumDicts` | Number of instantiation dictionaries, including inherited ones, in this `GenericsDictInfo` | | `GenericsDictInfo` | `NumTypeArgs` | Number of type arguments in the type or method instantiation described by this `GenericsDictInfo` | @@ -563,7 +604,8 @@ The version 1 `MethodDesc` APIs depend on the `MethodDescAlignment` global and t | Global name | Meaning | | --- | --- | -| `MethodDescAlignment` | `MethodDescChunk` trailing data is allocated in multiples of this constant. The size (in bytes) of each `MethodDesc` (or subclass) instance is a multiple of this constant. +| `MethodDescAlignment` | `MethodDescChunk` trailing data is allocated in multiples of this constant. The size (in bytes) of each `MethodDesc` (or subclass) instance is a multiple of this constant. | +| `MethodDescTokenRemainderBitCount` | Number of bits in the token remainder in `MethodDesc` | In the runtime a `MethodDesc` implicitly belongs to a single `MethodDescChunk` and some common data is shared between method descriptors that belong to the same chunk. A single method table @@ -572,12 +614,211 @@ will typically have multiple chunks. There are subkinds of MethodDescs at runti We depend on the following data descriptors: | Data Descriptor Name | Field | Meaning | | --- | --- | --- | -| `MethodDesc` | `ChunkIndex` | Offset of this `MethodDesc` relative to the end of its containing `MethodDescChunk` - in multiples of `MethodDescAlignment` -| `MethodDesc` | `Slot` | The method's slot -| `MethodDesc` | `Flags` | The method's flags -| `MethodDescChunk` | `MethodTable` | The method table set of methods belongs to -| `MethodDescChunk` | `Next` | The next chunk of methods -| `MethodDescChunk` | `Size` | The size of this `MethodDescChunk` following this `MethodDescChunk` header, minus 1. In multiples of `MethodDescAlignment` -| `MethodDescChunk` | `Count` | The number of `MethodDesc` entries in this chunk, minus 1. +| `MethodDesc` | `ChunkIndex` | Offset of this `MethodDesc` relative to the end of its containing `MethodDescChunk` - in multiples of `MethodDescAlignment` | +| `MethodDesc` | `Slot` | The method's slot | +| `MethodDesc` | `Flags` | The method's flags | +| `MethodDesc` | `Flags3AndTokenRemainder` | More flags for the method, and the low bits of the method's token's RID | +| `MethodDescChunk` | `MethodTable` | The method table set of methods belongs to | +| `MethodDescChunk` | `Next` | The next chunk of methods | +| `MethodDescChunk` | `Size` | The size of this `MethodDescChunk` following this `MethodDescChunk` header, minus 1. In multiples of `MethodDescAlignment` | +| `MethodDescChunk` | `Count` | The number of `MethodDesc` entries in this chunk, minus 1. | +| `MethodDescChunk` | `FlagsAndTokenRange` | `MethodDescChunk` flags, and the upper bits of the method token's RID | +| `InstantiatedMethodDesc` | `PerInstInfo` | The pointer to the method's type arguments | +| `InstantiatedMethodDesc` | `Flags2` | Flags for the `InstantiatedMethodDesc` | +| `InstantiatedMethodDesc` | `NumGenericArgs` | How many generic args the method has | +| `StoredSigMethodDesc` | `Sig` | Pointer to a metadata signature | +| `StoredSigMethodDesc` | `cSig` | Count of bytes in the metadata signature | +| `StoredSigMethodDesc` | `ExtendedFlags` | Flags field for the `StoredSigMethodDesc` | +| `DynamicMethodDesc` | `MethodName` | Pointer to Null-terminated UTF8 string describing the Method desc | + + +And the following enumeration definitions + +```csharp + internal enum MethodDescClassification + { + IL = 0, // IL + FCall = 1, // FCall (also includes tlbimped ctor, Delegate ctor) + PInvoke = 2, // PInvoke method + EEImpl = 3, // special method; implementation provided by EE (like Delegate Invoke) + Array = 4, // Array ECall + Instantiated = 5, // Instantiated generic methods, including descriptors + // for both shared and unshared code (see InstantiatedMethodDesc) + ComInterop = 6, + Dynamic = 7, // for method desc with no metadata behind + } + + [Flags] + internal enum MethodDescFlags : ushort + { + ClassificationMask = 0x7, + HasNonVtableSlot = 0x0008, + } + + internal enum InstantiatedMethodDescFlags2 : ushort + { + KindMask = 0x07, + GenericMethodDefinition = 0x01, + UnsharedMethodInstantiation = 0x02, + SharedMethodInstantiation = 0x03, + WrapperStubWithInstantiations = 0x04, + } + + [Flags] + internal enum DynamicMethodDescExtendedFlags : uint + { + IsLCGMethod = 0x00004000, + IsILStub = 0x00008000, + } +``` + + +And the various apis are implemented with the following algorithms + +```csharp + public bool IsGenericMethodDefinition(MethodDescHandle methodDescHandle) + { + MethodDesc methodDesc = _methodDescs[methodDescHandle.Address]; + + if (methodDesc.Classification != MethodDescClassification.Instantiated) + return false; + + ushort Flags2 = // Read Flags2 field from InstantiatedMethodDesc contract using address methodDescHandle.Address + + return ((int)Flags2 & (int)InstantiatedMethodDescFlags2.KindMask) == (int)InstantiatedMethodDescFlags2.GenericMethodDefinition; + } + + public ReadOnlySpan GetGenericMethodInstantiation(MethodDescHandle methodDescHandle) + { + MethodDesc methodDesc = _methodDescs[methodDescHandle.Address]; + + if (methodDesc.Classification != MethodDescClassification.Instantiated) + return default; + + TargetPointer dictionaryPointer = // Read PerInstInfo field from InstantiatedMethodDesc contract using address methodDescHandle.Address + if (dictionaryPointer == 0) + return default; + + int NumTypeArgs = // Read NumGenericArgs from methodDescHandle.Address using InstantiatedMethodDesc contract + TypeHandle[] instantiation = new TypeHandle[NumTypeArgs]; + for (int i = 0; i < NumTypeArgs; i++) + instantiation[i] = GetTypeHandle(_target.ReadPointer(dictionaryPointer + _target.PointerSize * i)); + + return instantiation; + } + + public uint GetMethodToken(MethodDescHandle methodDescHandle) + { + MethodDesc methodDesc = _methodDescs[methodDescHandle.Address]; + + TargetPointer methodDescChunk = // Using ChunkIndex from methodDesc, compute the wrapping MethodDescChunk + + ushort Flags3AndTokenRemainder = // Read Flags3AndTokenRemainder field from MethodDesc contract using address methodDescHandle.Address + ushort FlagsAndTokenRange = // Read FlagsAndTokenRange field from MethodDescChunk contract using address methodDescChunk + + int tokenRemainderBitCount = _target.ReadGlobal(Constants.Globals.MethodDescTokenRemainderBitCount); + int tokenRangeBitCount = 24 - tokenRemainderBitCount; + uint allRidBitsSet = 0xFFFFFF; + uint tokenRemainderMask = allRidBitsSet >> tokenRangeBitCount; + uint tokenRangeMask = allRidBitsSet >> tokenRemainderBitCount; + + uint tokenRemainder = (uint)(_desc.Flags3AndTokenRemainder & tokenRemainderMask); + uint tokenRange = ((uint)(_chunk.FlagsAndTokenRange & tokenRangeMask)) << tokenRemainderBitCount; + + return 0x06000000 | tokenRange | tokenRemainder; + } + + public bool IsArrayMethod(MethodDescHandle methodDescHandle, out ArrayFunctionType functionType) + { + MethodDesc methodDesc = _methodDescs[methodDescHandle.Address]; + + if (methodDesc.Classification != MethodDescClassification.Array) + { + functionType = default; + return false; + } + + int arrayMethodIndex = methodDesc.Slot - GetNumVtableSlots(GetTypeHandle(methodDesc.MethodTable)); + + functionType = arrayMethodIndex switch + { + 0 => ArrayFunctionType.Get, + 1 => ArrayFunctionType.Set, + 2 => ArrayFunctionType.Address, + > 3 => ArrayFunctionType.Constructor, + _ => throw new InvalidOperationException() + }; + + return true; + } + + public bool IsNoMetadataMethod(MethodDescHandle methodDescHandle, out ReadOnlySpan methodName) + { + MethodDesc methodDesc = _methodDescs[methodDescHandle.Address]; + + if (methodDesc.Classification != MethodDescClassification.Dynamic) + { + methodName = default; + return false; + } + + TargetPointer methodNamePointer = // Read MethodName field from DynamicMethodDesc contract using address methodDescHandle.Address + + methodName = // ReadBuffer from target of a utf8 null terminated string, starting at address methodNamePointer + return true; + } + + public bool IsStoredSigMethodDesc(MethodDescHandle methodDescHandle, out ReadOnlySpan signature) + { + MethodDesc methodDesc = _methodDescs[methodDescHandle.Address]; + + switch (methodDesc.Classification) + { + case MethodDescClassification.Dynamic: + case MethodDescClassification.EEImpl: + case MethodDescClassification.Array: + break; // These have stored sigs + + default: + signature = default; + return false; + } + + TargetPointer Sig = // Read Sig field from StoredSigMethodDesc contract using address methodDescHandle.Address + uint cSig = // Read cSig field from StoredSigMethodDesc contract using address methodDescHandle.Address + + TargetPointer methodNamePointer = // Read S field from DynamicMethodDesc contract using address methodDescHandle.Address + signature = // Read buffer from target memory starting at address Sig, with cSig bytes in it. + return true; + } + + public bool IsDynamicMethod(MethodDescHandle methodDescHandle) + { + MethodDesc methodDesc = _methodDescs[methodDescHandle.Address]; + + if (methodDesc.Classification != MethodDescClassification.Dynamic) + { + return false; + } + + uint ExtendedFlags = // Read ExtendedFlags field from StoredSigMethodDesc contract using address methodDescHandle.Address + + return ((DynamicMethodDescExtendedFlags)ExtendedFlags).HasFlag(DynamicMethodDescExtendedFlags.IsLCGMethod); + } + + public bool IsILStub(MethodDescHandle methodDescHandle) + { + MethodDesc methodDesc = _methodDescs[methodDescHandle.Address]; + + if (methodDesc.Classification != MethodDescClassification.Dynamic) + { + return false; + } + + uint ExtendedFlags = // Read ExtendedFlags field from StoredSigMethodDesc contract using address methodDescHandle.Address + + return ((DynamicMethodDescExtendedFlags)ExtendedFlags).HasFlag(DynamicMethodDescExtendedFlags.IsILStub); + } +``` **TODO(cdac)** diff --git a/docs/design/datacontracts/contract_csharp_api_design.cs b/docs/design/datacontracts/contract_csharp_api_design.cs index a770c1f4576..272645ec482 100644 --- a/docs/design/datacontracts/contract_csharp_api_design.cs +++ b/docs/design/datacontracts/contract_csharp_api_design.cs @@ -37,6 +37,18 @@ struct TargetPointer // Add a full set of operators to support pointer arithmetic } + public readonly struct TargetSpan + { + public TargetSpan(TargetPointer address, ulong size) + { + Address = address; + Size = size; + } + + public TargetPointer Address { get; } + public ulong Size { get; } + } + struct TargetNInt { public long Value; diff --git a/docs/design/features/globalization-hybrid-mode.md b/docs/design/features/globalization-hybrid-mode.md index 2270fe897c1..bdbdb27b09e 100644 --- a/docs/design/features/globalization-hybrid-mode.md +++ b/docs/design/features/globalization-hybrid-mode.md @@ -270,13 +270,12 @@ Dependencies: Web API does not expose locale-sensitive endsWith/startsWith function. As a workaround, both strings get normalized and weightless characters are removed. Resulting strings are cut to the same length and comparison is performed. This approach, beyond having the same compare option limitations as described under **String comparison**, has additional limitations connected with the workaround used. Because we are normalizing strings to be able to cut them, we cannot calculate the match length on the original strings. Methods that calculate this information throw PlatformNotSupported exception: -- [CompareInfo.IsPrefix](https://learn.microsoft.com/dotnet/api/system.globalization.compareinfo.isprefix?view=net-8.0#system-globalization-compareinfo-isprefix(system-readonlyspan((system-char))-system-readonlyspan((system-char))-system-globalization-compareoptions-system-int32@)) -- [CompareInfo.IsSuffix](https://learn.microsoft.com/dotnet/api/system.globalization.compareinfo.issuffix?view=net-8.0#system-globalization-compareinfo-issuffix(system-readonlyspan((system-char))-system-readonlyspan((system-char))-system-globalization-compareoptions-system-int32@)) +- [CompareInfo.IsPrefix](https://learn.microsoft.com/dotnet/api/system.globalization.compareinfo.isprefix?view=#system-globalization-compareinfo-isprefix(system-readonlyspan((system-char))-system-readonlyspan((system-char))-system-globalization-compareoptions-system-int32@)) +- [CompareInfo.IsSuffix](https://learn.microsoft.com/dotnet/api/system.globalization.compareinfo.issuffix?view=system-globalization-compareinfo-issuffix(system-readonlyspan((system-char))-system-readonlyspan((system-char))-system-globalization-compareoptions-system-int32@)) - `IgnoreSymbols` Only comparisons that do not skip character types are allowed. E.g. `IgnoreSymbols` skips symbol-chars in comparison/indexing. All `CompareOptions` combinations that include `IgnoreSymbols` throw `PlatformNotSupportedException`. - **String indexing** Affected public APIs: @@ -287,6 +286,15 @@ Affected public APIs: Web API does not expose locale-sensitive indexing function. There is a discussion on adding it: https://github.com/tc39/ecma402/issues/506. In the current state, as a workaround, locale-sensitive string segmenter combined with locale-sensitive comparison is used. This approach, beyond having the same compare option limitations as described under **String comparison**, has additional limitations connected with the workaround used. Information about additional limitations: +- Methods that calculate `matchLength` always return throw PlatformNotSupported exception: + +[CompareInfo.IndexOf](https://learn.microsoft.com/en-us/dotnet/api/system.globalization.compareinfo.indexof?view=system-globalization-compareinfo-indexof(system-readonlyspan((system-char))-system-readonlyspan((system-char))-system-globalization-compareoptions-system-int32@)) + +[CompareInfo.LastIndexOf](https://learn.microsoft.com/en-us/dotnet/api/system.globalization.compareinfo.lastindexof?view=system-globalization-compareinfo-lastindexof(system-readonlyspan((system-char))-system-readonlyspan((system-char))-system-globalization-compareoptions-system-int32@)) + +- String.Replace that uses `StringComparison` argument relies internally on IndexOf with `matchLength` argument. From this reason, it throws PlatformNotSupportedException: +[String.Replace](https://learn.microsoft.com/en-us/dotnet/api/system.string.replace?view=system-string-replace(system-string-system-string-system-stringcomparison)) + - Support depends on [`Intl.segmenter's support`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter#browser_compatibility). - `IgnoreSymbols` @@ -463,6 +471,11 @@ Affected public APIs: - String.IndexOf - String.LastIndexOf +Methods that calculate `matchLength` throw PlatformNotSupported exception: +[CompareInfo.IndexOf](https://learn.microsoft.com/en-us/dotnet/api/system.globalization.compareinfo.indexof?view=system-globalization-compareinfo-indexof(system-readonlyspan((system-char))-system-readonlyspan((system-char))-system-globalization-compareoptions-system-int32@)) + +[CompareInfo.LastIndexOf](https://learn.microsoft.com/en-us/dotnet/api/system.globalization.compareinfo.lastindexof?view=system-globalization-compareinfo-lastindexof(system-readonlyspan((system-char))-system-readonlyspan((system-char))-system-globalization-compareoptions-system-int32@)) + Mapped to Apple Native API `rangeOfString:options:range:locale:`(https://developer.apple.com/documentation/foundation/nsstring/1417348-rangeofstring?language=objc) In `rangeOfString:options:range:locale:` objects are compared by checking the Unicode canonical equivalence of their code point sequences. diff --git a/docs/project/list-of-diagnostics.md b/docs/project/list-of-diagnostics.md index da1639e0d11..a9dee40efdc 100644 --- a/docs/project/list-of-diagnostics.md +++ b/docs/project/list-of-diagnostics.md @@ -263,7 +263,7 @@ The diagnostic id values reserved for .NET Libraries analyzer warnings are `SYSL | __`SYSLIB1222`__ | Constructor annotated with JsonConstructorAttribute is inaccessible. | | __`SYSLIB1223`__ | Attributes deriving from JsonConverterAttribute are not supported by the source generator. | | __`SYSLIB1224`__ | Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. | -| __`SYSLIB1225`__ | *`SYSLIB1220`-`SYSLIB1229` reserved for System.Text.Json.SourceGeneration.* | +| __`SYSLIB1225`__ | Type includes ref like property, field or constructor parameter. | | __`SYSLIB1226`__ | *`SYSLIB1220`-`SYSLIB1229` reserved for System.Text.Json.SourceGeneration.* | | __`SYSLIB1227`__ | *`SYSLIB1220`-`SYSLIB1229` reserved for System.Text.Json.SourceGeneration.* | | __`SYSLIB1228`__ | *`SYSLIB1220`-`SYSLIB1229` reserved for System.Text.Json.SourceGeneration.* | @@ -310,3 +310,4 @@ Diagnostic id values for experimental APIs must not be recycled, as that could s | __`SYSLIB5002`__ | .NET 9 | TBD | `SystemColors` alternate colors are experimental in .NET 9 | | __`SYSLIB5003`__ | .NET 9 | TBD | `System.Runtime.Intrinsics.Arm.Sve` is experimental in .NET 9 | | __`SYSLIB5004`__ | .NET 9 | TBD | `X86Base.DivRem` is experimental in .NET 9 since performance is not as optimized as `T.DivRem` | +| __`SYSLIB5005`__ | .NET 9 | TBD | `System.Formats.Nrbf` is experimental in .NET 9 | diff --git a/docs/tools/illink/data-formats.md b/docs/tools/illink/data-formats.md index e360a914b14..5c0dc0ac478 100644 --- a/docs/tools/illink/data-formats.md +++ b/docs/tools/illink/data-formats.md @@ -382,7 +382,7 @@ This allows to add a custom attribute to a class, interface, delegate, struct or - DefaultConstructor + DefaultConstructor @@ -398,7 +398,7 @@ This allows to add a custom attribute to a class, interface, delegate, struct or - DefaultConstructor + DefaultConstructor @@ -414,7 +414,7 @@ This allows to add a custom attribute to a class, interface, delegate, struct or - DefaultConstructor + ArgumentValue @@ -431,21 +431,21 @@ This allows to add a custom attribute to a class, interface, delegate, struct or - DefaultConstructor + DefaultConstructor - PublicConstructors + PublicConstructors - DefaultConstructor + DefaultConstructor @@ -463,17 +463,17 @@ This allows to add a custom attribute to a class, interface, delegate, struct or - DefaultConstructor + DefaultConstructor - DefaultConstructor + DefaultConstructor - PublicConstructors + PublicConstructors @@ -491,7 +491,7 @@ This allows to add a custom attribute to a class, interface, delegate, struct or - DefaultConstructor + DefaultConstructor @@ -507,7 +507,7 @@ This allows to add a custom attribute to a class, interface, delegate, struct or - DefaultConstructor + DefaultConstructor @@ -528,7 +528,7 @@ attributes are applied. - PublicConstructors + PublicConstructors diff --git a/docs/workflow/README.md b/docs/workflow/README.md index 74bbc892f3e..78b4fd3f19b 100644 --- a/docs/workflow/README.md +++ b/docs/workflow/README.md @@ -1,104 +1,162 @@ # Workflow Guide -- [Build Requirements](#build-requirements) -- [Getting Yourself Started](#getting-yourself-started) -- [Configurations and Subsets](#configurations-and-subsets) - - [What does this mean for me?](#what-does-this-mean-for-me) -- [Full Instructions on Building and Testing the Runtime Repo](#full-instructions-on-building-and-testing-the-runtime-repo) +- [Introduction](#introduction) +- [Important Concepts to Understand](#important-concepts-to-understand) + - [Build Configurations](#build-configurations) +- [Building the Repo](#building-the-repo) + - [General Overview](#general-overview) + - [Get Started on your Platform and Components](#get-started-on-your-platform-and-components) + - [General Recommendations](#general-recommendations) +- [Testing the Repo](#testing-the-repo) + - [Performance Analysis](#performance-analysis) - [Warnings as Errors](#warnings-as-errors) - [Submitting a PR](#submitting-a-pr) -- [Triaging errors in CI](#triaging-errors-in-ci) +- [Triaging Errors in CI](#triaging-errors-in-ci) -The repo can be built for the following platforms, using the provided setup and the following instructions. Before attempting to clone or build, please check the requirements that match your machine, and ensure you install and prepare all as necessary. +## Introduction -## Build Requirements +The runtime repo can be worked with on Windows, Linux, macOS, and FreeBSD. Each platform has its own specific requirements to work properly, and not all architectures are supported for dev work. That said, the builds can target a wider range of platforms beyond the ones mentioned earlier. You can see it as there are always two platforms at play whenever you are working with builds in the runtime repo: + +- **The Build Platform:** This is the platform of the machine where you cloned the runtime repo and therefore where all your build tools are running on. The following table shows the OS and architecture combinations that we currently support, as well as links to each OS's requirements doc. If you are using WSL directly (i.e. not Docker), then follow the Linux requirements doc. | Chip | Windows | Linux | macOS | FreeBSD | -| :---- | :------: | :------: | :------: | :------: | +| :---: | :------: | :------: | :------: | :------: | | x64 | ✔ | ✔ | ✔ | ✔ | | x86 | ✔ | | | | | Arm32 | | ✔ | | | | Arm64 | ✔ | ✔ | ✔ | | | | [Requirements](requirements/windows-requirements.md) | [Requirements](requirements/linux-requirements.md) | [Requirements](requirements/macos-requirements.md) | [Requirements](requirements/freebsd-requirements.md) +- **The Target Platform:** This is the platform you are building the artifacts for, i.e. the platform you intend to run your builds on. + +The *Build Platform* and the *Target Platform* can be either the same as or different from each other. The former scenario is straightforward, as you will likely be doing all the work on the same machine. In the latter scenario, the process is called *cross-compiling*. There are certain workflows that require you to follow this process, as it is not possible to build the repo directly on those platforms (e.g., Web Assembly (WASM), Browser, Mobiles). The full instructions on how to work with this are detailed in the building docs later on. + Additionally, keep in mind that cloning the full history of this repo takes roughly 400-500 MB of network transfer, inflating to a repository that can consume somewhere between 1 to 1.5 GB. A build of the repo can take somewhere between 10 and 20 GB of space for a single OS and Platform configuration depending on the portions of the product built. This might increase over time, so consider this to be a minimum bar for working with this codebase. -## Getting Yourself Started +The runtime repo consists of three major components: + +- The Runtimes (CoreCLR and Mono) +- The Libraries +- The Hosts and Installers + +You can run your builds from a regular terminal, from the root of the repository. Sudo and administrator privileges are not needed for this. + +- For instructions on how to edit code and make changes, see [Editing and Debugging](/docs/workflow/editing-and-debugging.md). +- For instructions on how to debug CoreCLR, see [Debugging CoreCLR](/docs/workflow/debugging/coreclr/debugging-runtime.md). +- For instructions on using GitHub Codespaces, see [Codespaces](/docs/workflow/Codespaces.md). + +## Important Concepts to Understand + +The following sections describe some important terminology to keep in mind while working with runtime repo builds. For more information, and a complete list of acronyms and their meanings, check out the glossary [over here](/docs/project/glossary.md). + +### Build Configurations + +To work with the runtime repo, there are three supported configurations (one is *CoreCLR* exclusive) that define how your build will behave: + +- **Debug**: Non-optimized code. Asserts are enabled. This configuration runs the slowest. As its name suggests, it provides the best experience for debugging the product. +- **Checked** *(CoreCLR runtime exclusive)*: Optimized code. Asserts are enabled. +- **Release**: Optimized code. Asserts are disabled. Runs at the best speed, and is most suitable for performance profiling. This will impact the debugging experience however, due to compiler optimizations that make understanding what the debugger shows difficult, relative to the source code. + +### Build Components + +- **Runtime**: The execution engine for managed code. There are two different implementations, both written in C or C++: + - *CoreCLR*: The comprehensive execution engine originally born from .NET Framework. Its source code lives under the [src/coreclr](/src/coreclr) subtree. + - *Mono*: A slimmer runtime than CoreCLR, originally born open-source to bring .NET and C# support to non-Windows platforms. Due to its lightweight nature, it is less affected in terms of speed when working with the *Debug* configuration. Its source code lives under the [src/mono](/src/mono) subtree. + +- **CoreLib** *(also known as System.Private.CoreLib)*: The lowest level managed library. It is directly related to the runtime, which means it must be built in the matching configuration (e.g. Building a *Debug* runtime means *CoreLib* must also be in *Debug*). The `clr` subset includes both, the *Runtime* and the *CoreLib* components, so you usually don't have to worry about that. There are, however, some special cases where you might need to build the components separately. The runtime agnostic code for this library can be found at [src/libraries/System.Private.CoreLib/src](/src/libraries/System.Private.CoreLib/src/README.md). + +- **Libraries**: The bulk of dll's providing the rest of the functionality to the runtime. The libraries can be built in their own configuration, regardless of which one the runtime is using. Their source code lives under the [src/libraries](/src/libraries) subtree. + +## Building the Repo + +The main script that will be in charge of most of the building you might want to do is the `build.sh`, or `build.cmd` on Windows, located at the root of the repo. This script receives as arguments the subset(s) you might want to build, as well as multiple parameters to configure your build, such as the configuration, target operating system, target architecture, and so on. + +**NOTE:** If you plan on using Docker to work on the runtime repo, read [this doc](/docs/workflow/using-docker.md) first. It explains how to set up, as well as the images and containers to prepare you to follow the building and testing instructions in the next sections. + +### General Overview + +Running the script (`build.sh`/`build.cmd`) with no arguments will build the whole repo in *Debug* configuration, for the OS and architecture of your machine. A typical dev workflow only one or two components at a time, so it is more efficient to just build those. This is done by means of the `-subset` flag. For example, for CoreCLR, it would be: + +```bash +./build.sh -subset clr +``` + +The main subset values are: + +- `Clr`: The full CoreCLR runtime, which consists of the runtime itself and the CoreLib components. +- `Libs`: All the libraries components, excluding their tests. This includes the libraries' native parts, refs, source assemblies, and their packages and test infrastructure. +- `Packs`: The shared framework packs, archives, bundles, installers, and the framework pack tests. +- `Host`: The .NET hosts, packages, hosting libraries, and their tests. +- `Mono`: The Mono runtime and its CoreLib. -The runtime repo can be built from a regular, non-administrator command prompt, from the root of the repo. +Some subsets are subsequently divided into smaller pieces, giving you more flexibility as to what to build/rebuild depending on what you're working on. For a full list of all the supported subsets, run the build script, passing `help` as the argument to the `subset` flag. -The repository currently consists of three different major parts: +It is also possible to build more than one subset under the same command-line. In order to do this, you have to link them together with a `+` sign in the value you're passing to `-subset`. For example, to build both, CoreCLR and Libraries in Release configuration, the command-line would look like this: -* The Runtimes -* The Libraries -* The Installer +```bash +./build.sh -subset clr+libs -configuration Release +``` -More info on this, as well as the different build configurations in the [Configurations and Subsets section](#configurations-and-subsets). +If you require to use different configurations for different subsets, there are some specific flags you can use: -This was a concise introduction and now it's time to show the specifics of building specific subsets in any given supported platform, since most likely you will want to customize your builds according to what component(s) you're working on, as well as how you configured your build environment. We have links to instructions depending on your needs [in this section](#full-instructions-on-building-and-testing-the-runtime-repo). +- `-runtimeConfiguration (-rc)`: The CoreCLR build configuration +- `-librariesConfiguration (-lc)`: The Libraries build configuration +- `-hostConfiguration (-hc)`: The Host build configuration -* For instructions on how to edit code and make changes, see [Editing and Debugging](editing-and-debugging.md). -* For instructions on how to debug CoreCLR, see [Debugging CoreCLR](/docs/workflow/debugging/coreclr/debugging-runtime.md). -* For instructions on using GitHub Codespaces, see [Codespaces](/docs/workflow/Codespaces.md). +The behavior of the script is that the general configuration flag `-c` affects all subsets that have not been qualified with a more specific flag, as well as the subsets that don't have a specific flag supported, like `packs`. For example, the following command-line would build the libraries in *Release* mode and the runtime in *Debug* mode: -## Configurations and Subsets +```bash +./build.sh -subset clr+libs -configuration Release -runtimeConfiguration Debug +``` -You may need to build the tree in a combination of configurations. This section explains why. +In this example, the `-lc` flag was not specified, so `-c` qualifies `libs`. In the first example, only `-c` was passed, so it qualifies both, `clr` and `libs`. - -A quick reminder of some concepts -- see the [glossary](/docs/project/glossary.md) for more on these: +As an extra note here, if your first argument to the build script are the subsets, you can omit the `-subset` flag altogether. Additionally, several of the supported flags also include a shorthand version (e.g. `-c` for `-configuration`). Run the script with `-h` or `-help` to get an extensive overview on all the supported flags to customize your build, including their shorthand forms, as well as a wider variety of examples. -* **Debug Configuration** -- Non-optimized code. Asserts are enabled. -* **Checked Configuration** -- Optimized code. Asserts are enabled. _Only relevant to CoreCLR runtime._ -* **Release Configuration** -- Optimized code. Asserts are disabled. Runs at the best speed, and suitable for performance profiling. This will impact the debugging experience due to compiler optimizations that make understanding what the debugging is showing difficult to reason about, relative to the source code. +**NOTE:** On non-Windows systems, the longhand versions of the flags can be passed with either single `-` or double `--` dashes. -When we talk about mixing configurations, we're discussing the following sub-components: +### Get Started on your Platform and Components - -* **Runtime** is the execution engine for managed code and there are two different implementations available. Both are written in C/C++, therefore, easier to debug when built in a Debug configuration. - * CoreCLR is the comprehensive execution engine which, if built in Debug Configuration, executes managed code very slowly. For example, it will take a long time to run the managed code unit tests. The code lives under [src/coreclr](/src/coreclr). - * Mono is a portable and also slimmer runtime and it's not that sensitive to Debug Configuration for running managed code. You will still need to build it without optimizations to have good runtime debugging experience though. The code lives under [src/mono](/src/mono). -* **CoreLib** (also known as System.Private.CoreLib) is the lowest level managed library. It has a special relationship to the runtimes and therefore it must be built in the matching configuration, e.g., if the runtime you are using was built in a Debug configuration, this must be in a Debug configuration. The runtime agnostic code for this library can be found at [src/libraries/System.Private.CoreLib/src](/src/libraries/System.Private.CoreLib/src/README.md). -* **Libraries** is the bulk of the dlls that are oblivious to the configuration that runtimes and CoreLib were built in. They are most debuggable when built in a Debug configuration, and happily, they still run sufficiently fast in that configuration that it's acceptable for development work. The code lives under [src/libraries](/src/libraries). +Now that you've got the general idea on how to get started, it is important to mention that, while the procedure is very similar among platforms and subsets, each component has its own technicalities and details, as explained in their own specific docs: - -To build just one part of the repo, you add the `-subset` flag with the subset you wish to build to the root build script _(build.cmd/sh)_. You can specify more than one by linking them with the `+` operator (e.g. `-subset clr+libs` would build CoreCLR and the libraries). Note that if the subset is the first argument you pass to the script, you can omit the `--subset` flag altogether. +**Component Specifics:** -### What does this mean for me? +- [CoreCLR](/docs/workflow/building/coreclr/README.md) +- [Libraries](/docs/workflow/building/libraries/README.md) +- [Mono](/docs/workflow/building/mono/README.md) -At this point you probably know what you are planning to work on primarily: the runtimes or libraries. As general suggestions on how to proceed, here are some ideas: +**NOTE:** *NativeAOT* is part of CoreCLR, but it has its own specifics when it comes to building. We have a separate doc dedicated to it [over here](/docs/workflow/building/coreclr/nativeaot.md). -* If you're working in runtimes, you may want to build everything in the Debug configuration, depending on how comfortable you are debugging optimized native code. -* If you're working in libraries, you will want to use debug libraries with a release version of runtime and CoreLib, because the tests will run faster. -* If you're working in CoreLib - you probably want to try to get the job done with release runtime and CoreLib, and fall back to debug if you need to. The [Building Libraries](/docs/workflow/building/libraries/README.md) document explains how you'll do this. +### General Recommendations -## Full Instructions on Building and Testing the Runtime Repo +- If you're working with the runtimes, then the usual recommendation is to build everything in *Debug* mode. That said, if you know you won't be debugging the libraries source code but will need them (e.g. for a *Core_Root* build), then building the libraries on *Release* instead will provide a more productive experience. +- The counterpart to the previous point: When you are working in libraries. In this case, it is recommended to build the runtime on *Release* and the libraries on *Debug*. +- If you're working on *CoreLib*, then you probably want to try to get the job done with a *Release* runtime, and fall back to *Debug* if you need to. -Now you know about configurations and how we use them, so now you will want to read how to build what you plan to work on. Each of these will have further specific instructions or links for whichever platform you are developing on. +## Testing the Repo -* [Building CoreCLR runtime](/docs/workflow/building/coreclr/README.md) -* [Building Mono runtime](/docs/workflow/building/mono/README.md) -* [Building Libraries](/docs/workflow/building/libraries/README.md) +Building the components of the repo is just part of the experience. The runtime repo also includes vast test suites you can run to ensure your changes work properly as expected and don't inadvertently break something else. Each component has its own methodologies to run their tests, which are explained in their own specific docs: -After that, here's information about how to run tests: +- [CoreCLR](/docs/workflow/testing/coreclr/testing.md) + - [NativeAOT](/docs/workflow/building/coreclr/nativeaot.md#running-tests) +- [Libraries](/docs/workflow/testing/libraries/testing.md) +- [Mono](/docs/workflow/testing/mono/testing.md) -* [Testing CoreCLR runtime](/docs/workflow/testing/coreclr/testing.md) -* [Testing Mono runtime](/docs/workflow/testing/mono/testing.md) -* [Testing Libraries](/docs/workflow/testing/libraries/testing.md) +### Performance Analysis -And how to measure performance: +Fixing bugs and adding new features aren't the only things to work on in the runtime repo. We also have to ensure performance is kept as optimal as can be, and that is done through benchmarking and profiling. If you're interested in conducting these kinds of analysis, the following links will show you the usual workflow you can follow: -* [Benchmarking workflow for dotnet/runtime repository](https://github.com/dotnet/performance/blob/master/docs/benchmarking-workflow-dotnet-runtime.md) -* [Profiling workflow for dotnet/runtime repository](https://github.com/dotnet/performance/blob/master/docs/profiling-workflow-dotnet-runtime.md) +* [Benchmarking Workflow for dotnet/runtime repository](https://github.com/dotnet/performance/blob/master/docs/benchmarking-workflow-dotnet-runtime.md) +* [Profiling Workflow for dotnet/runtime repository](https://github.com/dotnet/performance/blob/master/docs/profiling-workflow-dotnet-runtime.md) ## Warnings as Errors -The repo build treats warnings as errors. Dealing with warnings when you're in the middle of making changes can be annoying (e.g. unused variable that you plan to use later). To disable treating warnings as errors, set the `TreatWarningsAsErrors` environment variable to `false` before building. This variable will be respected by both the `build.sh`/`build.cmd` root build scripts and builds done with `dotnet build` or Visual Studio. Some people may prefer setting this environment variable globally in their machine settings. +The repo build treats warnings as errors, including many code-style warnings. Dealing with warnings when you're in the middle of making changes can be annoying (e.g. unused variable that you plan to use later). To disable treating warnings as errors, set the `TreatWarningsAsErrors` environment variable to `false` before building. This variable will be respected by both the `build.sh`/`build.cmd` root build scripts and builds done with `dotnet build` or Visual Studio. Some people may prefer setting this environment variable globally in their machine settings. ## Submitting a PR -Before submitting a PR, make sure to review the [contribution guidelines](../../CONTRIBUTING.md). After you get familiarized with them, please read the [PR guide](ci/pr-guide.md) to find more information about tips and conventions around creating a PR, getting it reviewed, and understanding the CI results. +Before submitting a PR, make sure to review the [contribution guidelines](/CONTRIBUTING.md). After you get familiarized with them, please read the [PR guide](/docs/workflow/ci/pr-guide.md) to find more information about tips and conventions around creating a PR, getting it reviewed, and understanding the CI results. -## Triaging errors in CI +## Triaging Errors in CI -Given the size of the runtime repository, flaky tests are expected to some degree. There are a few mechanisms we use to help with the discoverability of widely impacting issues. We also have a regular procedure that ensures issues get properly tracked and prioritized. You can find more information on [triaging failures in CI](ci/failure-analysis.md). +Given the size of the runtime repository, flaky tests are expected to some degree. There are a few mechanisms we use to help with the discoverability of widely impacting issues. We also have a regular procedure that ensures issues get properly tracked and prioritized. You can find more information on [triaging failures in CI](/docs/workflow/ci/failure-analysis.md). diff --git a/docs/workflow/building/coreclr/README.md b/docs/workflow/building/coreclr/README.md index fbc1eab77c7..fc1b7aec225 100644 --- a/docs/workflow/building/coreclr/README.md +++ b/docs/workflow/building/coreclr/README.md @@ -1,100 +1,156 @@ -# Building CoreCLR +# Building CoreCLR Guide -* [Introduction](#introduction) -* [Common Building Options](#common-building-options) - * [Build Drivers](#build-drivers) - * [Extra Flags](#extra-flags) - * [Build Results Layout](#build-results-layout) -* [Platform-Specific Instructions](#platform-specific-instructions) -* [Testing CoreCLR](#testing-coreclr) +- [The Basics](#the-basics) + - [Build Results](#build-results) + - [What to do with the Build](#what-to-do-with-the-build) + - [The Core_Root for Testing Your Build](#the-core-root-for-testing-your-build) + - [The Dev Shipping Packs](#the-dev-shipping-packs) + - [Cross Compilation](#cross-compilation) +- [Other Features](#other-features) + - [Build Drivers](#build-drivers) + - [Extra Flags](#extra-flags) + - [Native ARM64 Building on Windows](#native-arm64-building-on-windows) + - [Debugging Information for macOS](#debugging-information-for-macos) + - [Native Sanitizers](#native-sanitizers) -## Introduction +Firstly, make sure you've prepared your environment and installed all the requirements for your platform. If not, follow this [link](/docs/workflow/README.md#introduction) for the corresponding instructions. -Here is a brief overview on how to build the common form of CoreCLR in general. For further specific instructions on each platform, we have links to instructions later on in [Platform-Specific Instructions](#platform-specific-instructions). +## The Basics -To build just CoreCLR, use the `subset` flag to the `build.sh` or `build.cmd` script at the repo root. Note that specifying `-subset` explicitly is not necessary if it is the first argument (i.e. `./build.sh --subset clr` and `./build.sh clr` are equivalent). However, if you specify any other argument beforehand, then you must specify the `-subset` flag. - -For Linux and macOS: +As explained in the main workflow [*README*](/docs/workflow/README.md), you can build the CoreCLR runtime by passing `-subset clr` as argument to the repo's main `build.sh`/`build.cmd` script: ```bash -./build.sh --subset clr +./build.sh -subset clr ``` -For Windows: +By default, the script builds the _clr_ in *Debug* configuration, which doesn't have any optimizations and has all assertions enabled. If you're aiming to run performance benchmarks, make sure you select the *Release* version with `-configuration Release`, as that one generates the most optimized code. On the other hand, if your goal is to run tests, then you can take the most advantage from CoreCLR's exclusive *Checked* configuration. This one retains the assertions but has the native compiler optimizations enabled, thus making it run faster than *Debug*. This is the usual mode used for running tests in the CI pipelines. -```cmd -.\build.cmd -subset clr -``` +### Build Results -## Common Building Options +Once the `clr` build completes, the main generated artifacts are placed in `artifacts/bin/coreclr/..`. For example, for a Linux x64 Release build, the output path would be `artifacts/bin/coreclr/linux.x64.Release`. Here, you will find a number of different binaries, of which the most important are the following: -By default, the script generates a _Debug_ build type, which is not optimized code and includes asserts. As its name suggests, this makes it easier and friendlier to debug the code. If you want to make performance measurements, you ought to build the _Release_ version instead, which doesn't have any asserts and has all code optimizations enabled. Likewise, if you plan on running tests, the _Release_ configuration is more suitable since it's considerably faster than the _Debug_ one. For this, you add the flag `-configuration release` (or `-c release`). For example: +- `corerun`: The command-line host executable. This program loads and starts the CoreCLR runtime and receives the managed program you want to run as argument (e.g. `./corerun program.dll`). On Windows, it is called `corerun.exe`. +- `coreclr`: The CoreCLR runtime itself. On Windows, it's called `coreclr.dll`, on macOS it is `libcoreclr.dylib`, and on Linux it is `libcoreclr.so`. +- `System.Private.CoreLib.dll`: The core managed library, containing the definitions of `Object` and the base functionality. -```bash -./build.sh --subset clr --configuration release -``` +All the generated logs are placed in under `artifacts/log`, and all the intermediate output the build uses is placed in the `artifacts/obj/coreclr` directory. -As mentioned before in the [general building document](/docs/workflow/README.md#configurations-and-subsets), CoreCLR also supports a _Checked_ build type which has asserts enabled like _Debug_, but is built with the native compiler optimizer enabled, so it runs much faster. This is the usual mode used for running tests in the CI system. +### What to do with the Build -Now, it is also possible to select a different configuration for each subset when building them together. The `--configuration` flag applies universally to all subsets, but it can be overridden with any one or more of the following ones: +*CoreCLR* is one of the most important components of the runtime repo, as it is one of the main engines of the .NET product. That said, while you can test and use it on its own, it is easiest to do this when used in conjunction with the *Libraries* subset. When you build both subsets, you can get access to the *Core_Root*. This includes all the libraries and the Clr, alongside other tools like *Crossgen2*, *R2RDump*, and the *ILC* compiler, and the main command-line host executable `corerun`, all bundled together. The *Core_Root* is one of the most reliable ways of testing changes to the runtime, running external apps with your build, and it is the way Clr tests are run in the CI pipelines. -* `--runtimeConfiguration (-rc)`: Flag for the CLR build configuration. -* `--librariesConfiguration (-lc)`: Flag for the libraries build configuration. -* `--hostConfiguration (-hc)`: Flag for the host build configuration. +#### The Core_Root for Testing Your Build -For example, a very common scenario used by developers and the repo's test scripts with default options, is to build the _clr_ in _Debug_ mode, and the _libraries_ in _Release_ mode. To achieve this, the command-line would look like the following: +As described in the [workflow README](/docs/workflow/README.md#building-the-repo), you can build multiple subsets by concatenating them with a `+` sign in the `-subset` argument. To prepare to build the *Core_Root*, we need to build the libraries and CoreCLR. Thus, the `-subset` argument would be `clr+libs`. Usually, the recommended workflow is to build the clr in *Debug* configuration and the libraries in *Release*: ```bash -./build.sh --subset clr+libs --configuration Release --runtimeConfiguration Debug +./build.sh -subset clr+libs -runtimeConfiguration Debug -librariesConfiguration Release ``` -Or alternatively: +Once you have both subsets built, you can generate the *Core_Root*, which as mentioned above, is the most flexible way of testing your changes. You can generate the *Core_Root* by running the following command, assuming a *Checked* clr build on an x64 machine: ```bash -./build.sh --subset clr+libs --librariesConfiguration Release --runtimeConfiguration Debug +./src/tests/build.sh -x64 -checked -generatelayoutonly ``` -For more information about all the different options available, supply the argument `-help|-h` when invoking the build script. On Unix-like systems, non-abbreviated arguments can be passed in with a single `-` or double hyphen `--`. +Since this is more related to testing, you can find the full details and instructions in the CoreCLR testing doc [over here](/docs/workflow/testing/coreclr/testing.md). -### Build Drivers +#### The Dev Shipping Packs -If you want to use _Ninja_ to drive the native build instead of _Make_ on non-Windows platforms, you can pass the `-ninja` flag to the build script as follows: +It is also possible to generate the full runtime NuGet packages and installer that you can use to test in a more production-esque scenario. To generate these shipping artifacts, you have to build the `clr`, `libs`, `host`, and `packs` subsets: ```bash -./build.sh --subset clr --ninja +./build.sh -subset clr+libs+host+packs -configuration Release ``` -If you want to use Visual Studio's _MSBuild_ to drive the native build on Windows, you can pass the `-msbuild` flag to the build script similarly to the `-ninja` flag. +The shipping artifacts are placed in the `artifacts/packages//Shipping` directory. Here, you will find several NuGet packages, as well as their respective symbols packages, generated from your build. More importantly, you will find a zipped archive with the full contents of the runtime, organized in the same layout as they are in the official dotnet installations. This archive includes the following files: + +- `host/fxr/-dev/hostfxr` (`hostfxr` is named differently depending on the platform: `hostfxr.dll` on Windows, `libhostfxr.dylib` on macOS, and `libhostfxr.so` on Linux) +- `shared/Microsoft.NETCore.App/-dev/*` (The `*` here refers to all the libraries dll's, as well as all the binaries necessary for the runtime to function) +- `dotnet (dotnet.exe on Windows)` (The main `dotnet` executable you usually use to run your apps) + +Note that this package only includes the runtime, therefore you will only be able to run apps but not build them. For that, you would need the full SDK. + +**NOTE:** On Windows, this will also include `.exe` and `.msi` installers, which you can use in case you want to test your build machine-wide. This is the closest you can get to an official build installation. + +For a full guide on using the shipping packages for testing checkout the doc we have dedicated to it [over here](/docs/workflow/testing/using-dev-shipping-packages.md). -We recommend using _Ninja_ for building the project on Windows since it more efficiently uses the build machine's resources for the native runtime build in comparison to Visual Studio's _MSBuild_. +### Cross Compilation + +Using an x64 machine, it is possible to generate builds for other architectures. Not all architectures are supported for cross-compilation however, and it's also dependent on the OS you are using to build and target. Refer to the table below for the compatibility matrix. + +| Operating System | To x86 | To Arm32 | To Arm64 | +| :--------------: | :------: | :------: | :------: | +| Windows | ✔ | | ✔ | +| macOS | | | ✔ | +| Linux | | ✔ | ✔ | + +**NOTE:** On macOS, it is also possible to cross-compile from ARM64 to x64 using an Apple Silicon Mac. + +Detailed instructions on how to do cross-compilation can be found in the cross-building doc [over here](/docs/workflow/building/coreclr/cross-building.md). + +## Other Features + +### Build Drivers + +By default, the CoreCLR build uses *Ninja* as the native build driver on Windows, and *Make* on non-Windows platforms. You can override this behavior by passing the appropriate flags to the build script: + +To use Visual Studio's *MSBuild* instead of *Ninja* on Windows: + +```cmd +./build.cmd -subset clr -msbuild +``` + +It is recommended to use *Ninja* on Windows, as it uses the build machine's resources more efficiently in comparison to Visual Studio's *MSBuild*. + +To use *Ninja* instead of *Make* on non-Windows: + +```bash +./build.sh -subset clr -ninja +``` ### Extra Flags -To pass extra compiler/linker flags to the coreclr build, set the environment variables `EXTRA_CFLAGS`, `EXTRA_CXXFLAGS` and `EXTRA_LDFLAGS` as needed. Don't set `CFLAGS`/`CXXFLAGS`/`LDFLAGS` directly as that might lead to configure-time tests failing. +You can also pass some extra compiler/linker flags to the CoreCLR build. Set the `EXTRA_CFLAGS`, `EXTRA_CXXFLAGS`, and `EXTRA_LDFLAGS` as you see fit for this purpose. The build script will consume them and then set the environment variables that will ultimately affect your build (i.e. those same ones without the `EXTRA_` prefix). Don't set the final ones directly yourself, as that is known to lead to potential failures in configure-time tests. -### Build Results Layout +### Native ARM64 Building on Windows -Once the build has concluded, it will have produced its output artifacts in the following structure: +Currently, the runtime repo supports building CoreCLR directly on Windows ARM64 without the need to cross-compile, albeit it is still in an experimental phase. To do this, you need to install the ARM64 build tools and Windows SDK for Visual Studio, in addition to all the requirements outlined in the [Windows Requirements doc](/docs/workflow/requirements/windows-requirements.md). -* Product binaries will be dropped in `artifacts\bin\coreclr\..` folder. -* A NuGet package, _Microsoft.Dotnet.CoreCLR_, will be created under `artifacts\bin\coreclr\..\.nuget` folder. -* Test binaries (if built) will be dropped under `artifacts\tests\coreclr\..` folder. However, remember the root build script will not build the tests. The instructions for working with tests (building and running) are [in the testing doc](/docs/workflow/testing/coreclr/testing.md). -* The build places logs in `artifacts\log` and these are useful when the build fails. -* The build places all of its intermediate output in the `artifacts\obj\coreclr` directory. +Once those requirements are fulfilled, you have to tell the build script to compile for Arm64 using *MSBuild*. *Ninja* is not yet supported on Arm64 platforms: -If you want to force a full rebuild of the subsets you specified when calling the build script, pass the `-rebuild` flag to it, in addition to any other arguments you might require. +```cmd +./build.cmd -subset clr -arch arm64 -msbuild +``` -## Platform-Specific Instructions +While this is functional at the time of writing this doc, it is still recommended to cross-compile from an x64 machine, as that's the most stable and tested method. -Now that you've got the general idea on how the _CoreCLR_ builds work, here are some further documentation links on platform-specific caveats and features. +### Debugging Information for macOS -* [Build CoreCLR on Windows](windows-instructions.md) -* [Build CoreCLR on macOS](macos-instructions.md) -* [Build CoreCLR on Linux](linux-instructions.md) -* [Build CoreCLR on FreeBSD](freebsd-instructions.md) +When building on macOS, the build process puts native component symbol and debugging information into `.dwarf` files, one for each built binary. This is not the native format used by macOS, and debuggers like LLDB can't automatically find them. The format macOS uses is `.dSYM` bundles. To generate them and get a better inner-loop developer experience (e.g. have the LLDB debugger automatically find program symbols and display source code lines, etc.), make sure to enable the `DCLR_CMAKE_APPLE_DYSM` flag when calling the build script: -We also have specific instructions for building _NativeAOT_ [here](/docs/workflow/building/coreclr/nativeaot.md). +```bash +./build.sh -subset clr -cmakeargs "-DCLR_CMAKE_APPLE_DYSM=TRUE" +``` + +**NOTE:** Converting the entire build process to build and package `.dSYM` bundles on macOS by default is on the table and tracked by issue #92911 [over here](https://github.com/dotnet/runtime/issues/92911). + +### Native Sanitizers + +CoreCLR is also in the process of supporting the use of native sanitizers during the build to help catch memory safety issues. To apply them, add the `-fsanitize` flag followed by the name of the sanitizer as argument. As of now, these are the supported sanitizers with plans of adding more in the future: + +- Sanitizer Name: `AddressSanitizer` -## Testing CoreCLR + Argument to `-fsanitize`: `address` -For testing your build, the [testing docs](/docs/workflow/testing/coreclr/testing.md) have detailed instructions on how to do it. +| Platform | Support Status | +| :------: | :---------------------: | +| Windows | Regularly Tested on x64 | +| macOS | Regularly Tested on x64 | +| Linux | Regularly Tested on x64 | + +And to use it, the command would look as follows: + +```bash +./build.sh -subset clr -fsanitize address +``` diff --git a/docs/workflow/building/coreclr/linux-instructions.md b/docs/workflow/building/coreclr/linux-instructions.md deleted file mode 100644 index f19bcfbd1e7..00000000000 --- a/docs/workflow/building/coreclr/linux-instructions.md +++ /dev/null @@ -1,118 +0,0 @@ -# Build CoreCLR on Linux - -* [Build using Docker](#build-using-docker) - * [Docker Images](#docker-images) -* [Build using your own Environment](#build-using-your-own-environment) - * [Set the maximum number of file-handles](#set-the-maximum-number-of-file-handles) -* [Build the Runtime](#build-the-runtime) - * [Cross-Compilation](#cross-compilation) -* [Create the Core_Root](#create-the-core_root) - -This guide will walk you through building CoreCLR on Linux. - -As mentioned in the [Linux requirements doc](/docs/workflow/requirements/linux-requirements.md), there are two options to build CoreCLR on Linux: - -* Build using Docker. -* Build using your own environment. - -## Build using Docker - -Building using Docker will require that you choose the correct image for your environment. - -Note that the OS is strictly speaking not important. For example if you are on Ubuntu 20.04 and build using the Ubuntu 18.04 x64 image there should be no issues. You can even use Linux images on a Windows OS if you have [WSL](https://learn.microsoft.com/windows/wsl/about) enabled. However, note that you can't run multiple OS's on the same _Docker Daemon_, as it takes resources from the underlying kernel as needed. In other words, you can run either Linux on WSL, or Windows containers. You have to switch between them if you need both, and restart Docker. - -The target architecture is more important, as building arm32 using the x64 image will not work. There will be missing _rootfs_ components required by the build. See [Docker Images](#docker-images) below, for more information on choosing an image to build with. - -**NOTE**: The image's architecture has to match your machine's supported platforms. For example, you can't run arm32 images on an x64 machine. But you could run x64 and arm64 images on an M1 Mac, for example. This is thanks to the _Rosetta_ emulator that Apple Silicon provides. Same case applies to running x86 on an x64 Windows machine thanks to Windows' _SYSWOW64_. Likewise, you can run Linux arm32 images on a Linux arm64 host. - -Please note that choosing the same image as the host OS you are running on will allow you to run the product/tests outside of the docker container you built in. - -Once you have chosen an image, the build is one command run from the root of the runtime repository: - -```bash -docker run --rm \ - -v :/runtime \ - -w /runtime \ - mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-22.04 \ - ./build.sh --subset clr -``` - -Dissecting the command: - -* `--rm`: Erase the created container after use. -* `-v :/runtime`: Mount the runtime repository under `/runtime`. Replace `` with the full path to your `runtime` repo clone, e.g., `-v /home/user/runtime:/runtime`. -* `-w: /runtime`: Set /runtime as working directory for the container. -* `mcr.microsoft.com/dotnet-buildtools/prereqs:centos-7-20210714125435-9b5bbc2`: Docker image name. -* `./build.sh`: Command to be run in the container: run the root build command. -* `-subset clr`: Build the clr subset (excluding libraries and installers). - -To do cross-building using Docker, you need to use either specific images designated for this purpose, or configure your own. Detailed information on this can be found in the [cross-building doc](/docs/workflow/building/coreclr/cross-building.md#cross-building-using-docker). Note that the official build images are all cross-build images, even when targeting the same architecture as the host image. This is because they target versions of glibc or musl libc that are included in the cross-build rootfs, and not the host OS. - -### Docker Images - -This table of images might often become stale as we change our images as our requirements change. The images used for our official builds can be found in [the pipeline resources](/eng/pipelines/common/templates/pipeline-with-resources.yml) of our Azure DevOps builds under the `container` key of the platform you plan to build. These image tags don't include version numbers, and our build infrastructure will automatically use the latest version of the image. You can ensure you are using the latest version by using `docker pull`, for example: - -``` -docker pull mcr.microsoft.com/dotnet-buildtools/prereqs:cbl-mariner-2.0-cross-arm64 -``` - -All official builds are cross-builds with a rootfs for the target OS, and will use the clang version available on the container. - -| Host OS | Target OS | Target Arch | Image location | crossrootfs location | -| --------------------- | ------------ | --------------- | -------------------------------------------------------------------------------------- | -------------------- | -| Azure Linux (x64) | Alpine 3.13 | x64 | `mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-cross-amd64-alpine-net9.0` | `/crossrootfs/x64` | -| Azure Linux (x64) | Ubuntu 16.04 | x64 | `mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-cross-amd64-net9.0` | `/crossrootfs/x64` | -| Azure Linux (x64) | Alpine | arm32 (armhf) | `mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-cross-arm-alpine-net9.0` | `/crossrootfs/arm` | -| Azure Linux (x64) | Ubuntu 16.04 | arm32 (armhf) | `mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-cross-arm-net9.0` | `/crossrootfs/arm` | -| Azure Linux (x64) | Alpine | arm64 (arm64v8) | `mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-cross-arm64-alpine-net9.0` | `/crossrootfs/arm64` | -| Azure Linux (x64) | Ubuntu 16.04 | arm64 (arm64v8) | `mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-cross-arm64-net9.0` | `/crossrootfs/arm64` | -| Azure Linux (x64) | Ubuntu 16.04 | x86 | `mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-cross-x86-net9.0` | `/crossrootfs/x86` | -| CBL-mariner 2.0 (x64) | FreeBSD 13 | x64 | `mcr.microsoft.com/dotnet-buildtools/prereqs:cbl-mariner-2.0-cross-amd64-freebsd-13` | `/crossrootfs/x64` | - -These Docker images are built using the Dockerfiles maintained in the [dotnet-buildtools-prereqs-docker repo](https://github.com/dotnet/dotnet-buildtools-prereqs-docker). - -## Build using your own Environment - -Ensure you have all of the prerequisites installed from the [Linux Requirements](/docs/workflow/requirements/linux-requirements.md). - -### Set the maximum number of file-handles - -To ensure that your system can allocate enough file-handles for the libraries build, run the command in your terminal `sysctl fs.file-max`. If it is less than 100000, add `fs.file-max = 100000` to `/etc/sysctl.conf`, and then run `sudo sysctl -p`. - -## Build the Runtime - -To build CoreCLR on Linux, run `build.sh` while specifying the `clr` subset: - -```bash -./build.sh --subset clr -``` - -After the build is completed, there should be some files placed in `artifacts/bin/coreclr/linux..` (for example `artifacts/bin/coreclr/linux.x64.Release`). The most important binaries are the following: - -* `corerun`: The command line host. This program loads and starts the CoreCLR runtime and passes the managed program (e.g. `program.dll`) you want to run with it. -* `libcoreclr.so`: The CoreCLR runtime itself. -* `System.Private.CoreLib.dll`: The core managed library, containing definitions of `Object` and base functionality. - -### Cross-Compilation - -Just like you can use specialized Docker images, you can also do any of the supported cross-builds for ARM32 or ARM64 on your own Linux environment. Detailed instructions are found in the [cross-building doc](/docs/workflow/building/coreclr/cross-building.md#linux-cross-building). - -## Create the Core_Root - -The Core_Root provides one of the main ways to test your build. Full instructions on how to build it in the [CoreCLR testing doc](/docs/workflow/testing/coreclr/testing.md), and we also have a detailed guide on how to use it for your own testing in [its own dedicated doc](/docs/workflow/testing/using-corerun-and-coreroot.md). - -## Native Sanitizers - -CoreCLR can be built with native sanitizers like AddressSanitizer to help catch memory safety issues. To build the project with native sanitizers, add the `-fsanitize address` argument to the build script like the following: - -```bash -build.sh -s clr -fsanitize address -``` - -When building the repo with any native sanitizers, you should build all native components in the repo with the same set of sanitizers. - -The following sanitizers are supported for CoreCLR on Linux: - -| Sanitizer Name | `-fsanitize` argument | Support Status | -|-----------------|-----------------------|----------------| -| AddressSanitize | `address` | regularly tested on x64 | diff --git a/docs/workflow/building/coreclr/macos-instructions.md b/docs/workflow/building/coreclr/macos-instructions.md deleted file mode 100644 index 7ac0d0c6e0f..00000000000 --- a/docs/workflow/building/coreclr/macos-instructions.md +++ /dev/null @@ -1,60 +0,0 @@ -# Build CoreCLR on macOS - -* [Environment](#environment) -* [Build the Runtime](#build-the-runtime) - * [Cross-Compilation](#cross-compilation) -* [Create the Core_Root](#create-the-core_root) - -This guide will walk you through building CoreCLR on macOS. - -## Environment - -Ensure you have all of the prerequisites installed from the [macOS Requirements](/docs/workflow/requirements/macos-requirements.md). - -## Build the Runtime - -To build CoreCLR on macOS, run `build.sh` while specifying the `clr` subset: - -```bash -./build.sh --subset clr -``` - -After the build has completed, there should be some files placed in `artifacts/bin/coreclr/osx..` (for example `artifacts/bin/coreclr/osx.x64.Release`). The most important binaries are the following: - -* `corerun`: The command line host. This program loads and starts the CoreCLR runtime and passes the managed program (e.g. `program.dll`) you want to run with it. -* `libcoreclr.dylib`: The CoreCLR runtime itself. -* `System.Private.CoreLib.dll`: The core managed library, containing definitions of `Object` and base functionality. - -### Cross-Compilation - -It is possible to get a macOS ARM64 build using an Intel x64 Mac and vice versa, an x64 one using an M1 Mac. Instructions on how to do this are in the [cross-building doc](/docs/workflow/building/coreclr/cross-building.md#macos-cross-building). - -## Create the Core_Root - -The Core_Root provides one of the main ways to test your build. Full instructions on how to build it in the [CoreCLR testing doc](/docs/workflow/testing/coreclr/testing.md), and we also have a detailed guide on how to use it for your own testing in [its own dedicated doc](/docs/workflow/testing/using-corerun-and-coreroot.md). - -## Debugging information - -The build process puts native component symbol and debugging information into `.dwarf` files, one for each built binary. This is not the native format used by macOS, and debuggers like LLDB can't automatically find them. The native format used by macOS is `.dSYM` bundles. To build `.dSYM` bundles and get a better inner-loop developer experience on macOS (e.g., have the LLDB debugger automatically find program symbols and display source code lines, etc.), build as follows: - -```bash -./build.sh --subset clr --cmakeargs "-DCLR_CMAKE_APPLE_DSYM=TRUE" -``` - -(Note: converting the entire build process to build and package `.dSYM` bundles on macOS by default is tracked by [this](https://github.com/dotnet/runtime/issues/92911) issue.) - -## Native Sanitizers - -CoreCLR can be built with native sanitizers like AddressSanitizer to help catch memory safety issues. To build the project with native sanitizers, add the `-fsanitize address` argument to the build script like the following: - -```bash -build.sh -s clr -fsanitize address -``` - -When building the repo with any native sanitizers, you should build all native components in the repo with the same set of sanitizers. - -The following sanitizers are supported for CoreCLR on macOS: - -| Sanitizer Name | `-fsanitize` argument | Support Status | -|-----------------|-----------------------|----------------| -| AddressSanitize | `address` | regularly tested on x64 | diff --git a/docs/workflow/building/coreclr/nativeaot.md b/docs/workflow/building/coreclr/nativeaot.md index ebc636fccf6..586a29ccf7e 100644 --- a/docs/workflow/building/coreclr/nativeaot.md +++ b/docs/workflow/building/coreclr/nativeaot.md @@ -145,6 +145,8 @@ Note that to run WASM tests targeting Browser, NodeJS that supports the exceptio To run all the tests that got built, run `src\tests\run.cmd runnativeaottests [Debug|Release] [wasm]` on Windows, or `src/tests/run.sh --runnativeaottests [Debug|Release] [wasm]` on Linux. The `Debug`/`Release` flag should match the flag that was passed to `build.cmd` in the previous step. +To build an individual test, follow the instructions for compiling a individual test project located in [Building an Individual Test](/docs/workflow/testing/coreclr/testing.md#building-an-individual-test), but add `/t:BuildNativeAot /p:TestBuildMode=nativeaot` to the build command. + To run an individual test (after it was built), navigate to the `artifacts\tests\coreclr\[windows|linux|osx[.x64.[Debug|Release]\$path_to_test` directory. `$path_to_test` matches the subtree of `src\tests`. You should see a `[.cmd|.sh]` file there. This file is a script that will compile and launch the individual test for you. Before invoking the script, set the following environment variables: * CORE_ROOT=$repo_root\artifacts\tests\coreclr\[windows|linux|osx].x64.[Debug|Release]\Tests\Core_Root diff --git a/docs/workflow/building/coreclr/windows-instructions.md b/docs/workflow/building/coreclr/windows-instructions.md deleted file mode 100644 index 3ab6b33bc04..00000000000 --- a/docs/workflow/building/coreclr/windows-instructions.md +++ /dev/null @@ -1,67 +0,0 @@ -# Build CoreCLR on Windows - -* [Environment](#environment) -* [Build the Runtime](#build-the-runtime) - * [Cross-Compilation](#cross-compilation) -* [Core_Root](#core_root) -* [Native ARM64 (Experimental)](#native-arm64-experimental) - -This guide will walk you through building CoreCLR on Windows. - -## Environment - -Ensure you have all of the prerequisites installed from the [Windows Requirements](/docs/workflow/requirements/windows-requirements.md). - -## Build the Runtime - -To build CoreCLR on Windows, run `build.cmd` while specifying the `clr` subset: - -```cmd -.\build.cmd -subset clr -``` - -After the build has completed, there should be some files placed in `artifacts/bin/coreclr/windows..` (for example `artifacts/bin/coreclr/windows.x64.Release`). The most important binaries are the following: - -* `corerun.exe`: The command line host. This program loads and starts the CoreCLR runtime and passes the managed program (e.g. `program.dll`) you want to run with it. -* `coreclr.dll`: The CoreCLR runtime itself. -* `System.Private.CoreLib.dll`: The core managed library, containing definitions of `Object` and base functionality. - -### Cross-Compilation - -It is possible to get Windows x86, ARM32, and ARM64 builds using an x64 machine. Instructions on how to do this are in the [cross-building doc](/docs/workflow/building/coreclr/cross-building.md#windows-cross-building). - -## Core_Root - -The Core_Root provides one of the main ways to test your build. Full instructions on how to build it in the [CoreCLR testing doc](/docs/workflow/testing/coreclr/testing.md), and we also have a detailed guide on how to use it for your own testing in [its own dedicated doc](/docs/workflow/testing/using-corerun-and-coreroot.md). - -## Native ARM64 (Experimental) - -Building natively on ARM64 requires you to have installed the appropriate ARM64 build tools and Windows SDK, as specified in the [Windows requirements doc](/docs/workflow/requirements/windows-requirements.md). - -Once those requirements are satisfied, you have to specify you are doing an Arm64 build, and explicitly tell the build script you want to use `MSBuild`. `Ninja` is not yet supported on Arm64 platforms. - -```cmd -build.cmd -s clr -c Release -arch arm64 -msbuild -``` - -Since this is still in an experimental phase, the recommended way for building ARM64 is cross-compiling from an x64 machine. Instructions on how to do this can be found at the [cross-building doc](/docs/workflow/building/coreclr/cross-building.md#cross-compiling-for-arm32-and-arm64). - -## Native Sanitizers - -CoreCLR can be built with native sanitizers like AddressSanitizer to help catch memory safety issues. To build the project with native sanitizers, add the `-fsanitize address` argument to the build script like the following: - -```cmd -build.cmd -s clr -fsanitize address -``` - -When building the repo with any native sanitizers, you should build all native components in the repo with the same set of sanitizers. - -The following sanitizers are supported for CoreCLR on Windows: - -| Sanitizer Name | Minimum VS Version | `-fsanitize` argument | Support Status | -|----------------|--------------------|-----------------------|----------------| -| AddressSanitizer | not yet released | `address` | experimental | - -## Using a custom compiler environment - -If you ever need to use a custom compiler environment for the native builds on Windows, you can set the `SkipVCEnvInit` environment variable to `1`. The build system will skip discovering Visual Studio and initializing its development environment when this flag is used. This is only required for very advanced scenarios and should be used rarely. diff --git a/docs/workflow/ci/disabling-tests.md b/docs/workflow/ci/disabling-tests.md index 2b4253c85a6..5bb2c3ceabc 100644 --- a/docs/workflow/ci/disabling-tests.md +++ b/docs/workflow/ci/disabling-tests.md @@ -63,6 +63,8 @@ in the [issues.targets](../../../src/tests/issues.targets) file. Additionally, t link to a GitHub issue in the `` element. Disabling a test here can be conditioned on processor architecture, runtime, and operating system. +### Disabling runtime tests (src/tests) with test configuration properties + However, some test configurations must be disabled by editing the `.csproj` or `.ilproj` file for the test, and inserting a property in a ``, as follows: diff --git a/docs/workflow/debugging/coreclr/debugging-runtime.md b/docs/workflow/debugging/coreclr/debugging-runtime.md index e1e5d499bd3..0714c7da709 100644 --- a/docs/workflow/debugging/coreclr/debugging-runtime.md +++ b/docs/workflow/debugging/coreclr/debugging-runtime.md @@ -223,15 +223,19 @@ Native C++ code is not everything in our runtime. Nowadays, there are lots of st #### Resolving Signature Validation Errors in Visual Studio -Starting with Visual Studio 2022 version 17.5, Visual Studio will validate that the debugging libraries that shipped with the .NET Runtime are correctly signed before loading them. If they are unsigned, Visual Studio will show an error like: +Visual Studio 2022 version 17.5 and later validates that the debugging libraries shipped with the .NET Runtime are signed before loading them. If they are unsigned, Visual Studio shows an error similar to the following: > Unable to attach to CoreCLR. Signature validation failed for a .NET Runtime Debugger library because the file is unsigned. > > This error is expected if you are working with non-official releases of .NET (example: daily builds from https://github.com/dotnet/sdk). See https://aka.ms/vs/unsigned-dotnet-debugger-lib for more information. -If the target process is using a .NET Runtime that is either from a daily build, or one that you built on your own computer, this error will show up. **NOTE**: This error should never happen for official builds of the .NET Runtime from Microsoft. So don’t disable the validation if you expect to be using a .NET Runtime supported by Microsoft. +This error occurs if the target process is using a daily build .NET Runtime or one that you built. **NOTE**: This error never happens with [released builds of the .NET Runtime from Microsoft](https://dotnet.microsoft.com/en-us/download/dotnet). ***Don’t*** disable the validation if you are using an official release of the .NET Runtime. -There are three ways to configure Visual Studio to disable signature validation: -1. The [`DOTNET_ROOT` environment variable](https://learn.microsoft.com/dotnet/core/tools/dotnet-environment-variables#dotnet_root-dotnet_rootx86): if Visual Studio is started from a command prompt where `DOTNET_ROOT` is set, it will ignore unsigned .NET runtime debugger libraries which are under the `DOTNET_ROOT` directory. -2. The `VSDebugger_ValidateDotnetDebugLibSignatures` environment variable: If you want to temporarily disable signature validation, run `set VSDebugger_ValidateDotnetDebugLibSignatures=0` in a command prompt, and start Visual Studio (devenv.exe) from this command prompt. -3. Set the `ValidateDotnetDebugLibSignatures` registry key: To disable signature validation on a more permanent basis, you can set the VS registry key to turn it off. To do so, open a Developer Command Prompt, and run `Common7\IDE\VsRegEdit.exe set local HKCU Debugger\EngineSwitches ValidateDotnetDebugLibSignatures dword 0` +The following approaches configure Visual Studio to disable signature validation: + +1. The `VSDebugger_ValidateDotnetDebugLibSignatures` environment variable: + * This is the easiest and recommended approach to temporarily disable signature validation. + * At the command line, run `set VSDebugger_ValidateDotnetDebugLibSignatures=0` and then start Visual Studio (`devenv.exe`) from the same command prompt. + * This setting is only valid for the Visual Studio instance that is started from the command prompt where the environment variable is set. +1. The [`DOTNET_ROOT` environment variable](https://learn.microsoft.com/dotnet/core/tools/dotnet-environment-variables#dotnet_root-dotnet_rootx86): if Visual Studio is started from a command prompt where `DOTNET_ROOT` is set, it ignores unsigned .NET runtime debugger libraries which are under the `DOTNET_ROOT` directory. +1. ***NOT RECOMMENDED*** Set the `ValidateDotnetDebugLibSignatures` registry key: To disable signature validation on a more permanent basis, set the `Common7\IDE\VsRegEdit.exe set local HKCU Debugger\EngineSwitches ValidateDotnetDebugLibSignatures dword 0` VS registry key. For example, open a Developer Command Prompt and run `Common7\IDE\VsRegEdit.exe set local HKCU Debugger\EngineSwitches ValidateDotnetDebugLibSignatures dword 0` diff --git a/docs/workflow/requirements/linux-requirements.md b/docs/workflow/requirements/linux-requirements.md index 2aa1794ef1a..9eb52936d26 100644 --- a/docs/workflow/requirements/linux-requirements.md +++ b/docs/workflow/requirements/linux-requirements.md @@ -1,111 +1,117 @@ -# Requirements to build dotnet/runtime on Linux +# Requirements to Set Up the Build Environment on Linux -* [Docker](#docker) -* [Environment](#environment) - * [Debian-based / Ubuntu](#debian-based--ubuntu) - * [Additional Requirements for Cross-Building](#additional-requirements-for-cross-building) - * [Fedora](#fedora) - * [Gentoo](#gentoo) +- [Using your Linux Environment](#using-your-linux-environment) + - [Debian/Ubuntu](#debian/ubuntu) + - [CMake on Older Versions of Ubuntu and Debian](#cmake-on-older-versions-of-ubuntu-and-debian) + - [Clang for WASM](#clang-for-wasm) + - [Additional Tools for Cross Building](#additional-tools-for-cross-building) + - [Fedora](#fedora) + - [Gentoo](#gentoo) +- [Using Docker](#using-docker) -This guide will walk you through the requirements to build _dotnet/runtime_ on Linux. Before building there is environment setup that needs to happen to pull in all the dependencies required by the build. +There are two ways to build the runtime repo on *Linux*: Set up your environment in your Linux machine, or use the Docker images that are used in the official builds. This guide will cover both of these approaches. Using Docker allows you to leverage our existing images which already have an environment set up, while using your own environment grants you better flexibility on having other tools at hand you might need. -There are two suggested ways to go about doing this. You can use the Docker images used in the official builds, or you can set up the environment yourself. The documentation will go over both ways. Using Docker allows you to leverage our existing images which already have an environment set up, while using your own environment grants you better flexibility on having other tools at hand you might need. +**NOTE:** If you're using WSL, then follow the instructions for the distro you have installed there. -## Docker +## Using your Linux Environment -Install Docker. For further installation instructions, see [here](https://docs.docker.com/install/). Details on the images used by the official builds can be found in the [Linux building instructions doc](/docs/workflow/building/coreclr/linux-instructions.md#docker-images). All the required build tools are included in the Docker images used to do the build, so no additional setup is required. +The following sections describe the requirements for different kinds of Linux distros. Pull Requests are welcome to add documentation regarding environments and distros currently not described here. -## Environment +The minimum required RAM is 1GB (builds are known to fail on 512MB VM's (https://github.com/dotnet/runtime/issues/4069), although more is recommended, as the builds can take a long time otherwise. -Below are the requirements for toolchain setup, depending on your environment. Pull Requests are welcome to address other environments. - -Minimum RAM required to build is 1GB. The build is known to fail on 512 MB VMs ([dotnet/runtime#4069](https://github.com/dotnet/runtime/issues/4069)). - -You can use this helper script to install dependencies on some platforms: +To get started, you can use this helper script to install dependencies on some platforms, or you can install them yourself following the instructions in the next sections. If you opt to try this script, make sure to run it as `sudo` if you don't have root privileges: ```bash sudo eng/install-native-dependencies.sh -# or without 'sudo' if you are root ``` -### Debian-based / Ubuntu +Note that it is always a good idea to manually double check that all the dependencies were installed correctly if you opt to use the script. -These instructions are written assuming the current Ubuntu LTS. +### Debian/Ubuntu -Install the following packages for the toolchain: +These instructions are written assuming the current *Ubuntu LTS*. + +The packages you need to install are shown in the following list: -* CMake 3.20 or newer -* llvm -* lld -* clang (for WASM 16 or newer) -* build-essential -* python-is-python3 -* curl -* git -* lldb -* libicu-dev -* liblttng-ust-dev -* libssl-dev -* libkrb5-dev -* zlib1g-dev -* ninja-build (optional, enables building native code with ninja instead of make) - -**NOTE**: If you have an Ubuntu version older than 22.04 LTS, or Debian version older than 12, don't install `cmake` using `apt` directly. Follow the note written down below. +- `CMake` (version 3.20 or newer) +- `llvm` +- `lld` +- `Clang` (see the [Clang for WASM](#clang-for-wasm) section if you plan on doing work on *Web Assembly (Wasm)*) +- `build-essential` +- `python-is-python3` +- `curl` +- `git` +- `lldb` +- `libicu-dev` +- `liblttng-ust-dev` +- `libssl-dev` +- `libkrb5-dev` +- `ninja-build` (Optional. Enables building native code using `ninja` instead of `make`) + +**NOTE:** If you are running on *Ubuntu* older than version *22.04 LTS*, or *Debian* older than version 12, then don't install `cmake` using `apt` directly. Follow the instructions in the [CMake on Older Versions of Ubuntu and Debian section](#cmake-on-older-versions-of-ubuntu-and-debian) later down in this doc. ```bash sudo apt install -y cmake llvm lld clang build-essential \ python-is-python3 curl git lldb libicu-dev liblttng-ust-dev \ - libssl-dev libkrb5-dev zlib1g-dev ninja-build + libssl-dev libkrb5-dev ninja-build ``` -**NOTE**: As of now, Ubuntu's `apt` only has until CMake version 3.16.3 if you're using Ubuntu 20.04 LTS (less in older Ubuntu versions), and version 3.18.4 in Debian 11 (less in older Debian versions). This is lower than the required 3.20, which in turn makes it incompatible with the repo. For this case, we can use the `snap` package manager or the _Kitware APT feed_ to get a new enough version of CMake. -**NOTE**: If you have Ubuntu 22.04 LTS and older and your `apt` does not have clang version 16, you can add `"deb http://apt.llvm.org/$(lsb_release -s -c)/ llvm-toolchain-$(lsb_release -s -c)-18 main"` repository to your `apt`. See how we do it for linux-based containers [here](./../../../.devcontainer/Dockerfile). +#### CMake on Older Versions of Ubuntu and Debian + +As of now, Ubuntu's `apt` only has until *CMake* version 3.16.3 if you're using *Ubuntu 20.04 LTS* (less in older Ubuntu versions), and version 3.18.4 in *Debian 11* (less in older Debian versions). This is lower than the required 3.20, which in turn makes it incompatible with the runtime repo. To get around this, there are two options you can choose: Use the `snap` package manager, which has a more recent version of *CMake*, or directly use the *Kitware APT Feed*. -For snap: +To use `snap`, run the following command: ```bash sudo snap install cmake ``` -For the _Kitware APT feed_, follow its [instructions here](https://apt.kitware.com/). +To use the *Kitware APT feed*, follow their official instructions [in this link](https://apt.kitware.com/). -You now have all the required components. +#### Clang for WASM -#### Additional Requirements for Cross-Building +As of now, *WASM* builds have a minimum requirement of `Clang` version 16 or later (version 18 is the latest at the time of writing this doc). If you're using *Ubuntu 22.04 LTS* or older, then you will have to add an additional repository to `apt` to be able to get said version. Run the following commands on your terminal to do this: -If you are planning to use your Linux environment to do cross-building for other architectures (e.g. Arm32, Arm64) and/or other operating systems (e.g. Alpine, FreeBSD), you need to install these additional dependencies: +```bash +sudo add-apt-repository -y "deb http://apt.llvm.org/$(lsb_release -s -c)/ llvm-toolchain-$(lsb_release -s -c)-18 main" +sudo apt update -y +sudo apt install -y clang-18 +``` + +You can also take a look at the Linux-based *Dockerfile* [over here](/.devcontainer/Dockerfile) for another example. + +#### Additional Tools for Cross Building -* qemu -* qemu-user-static -* binfmt-support -* debootstrap +If you're planning to use your environment to do Linux cross-building to other architectures (e.g. Arm32, Arm64), and/or other operating systems (e.g. Alpine, FreeBSD), you'll need to install a few additional dependencies. It is worth mentioning these other packages are required to build the `crossrootfs`, which is used to effectively do the cross-compilation, not to build the runtime itself. -**NOTE**: These dependencies are used to build the `crossrootfs`, not the runtime itself. +- `qemu` +- `qemu-user-static` +- `binfmt-support` +- `debootstrap` ### Fedora -These instructions are written assuming Fedora 40. +These instructions are written assuming *Fedora 40*. Install the following packages for the toolchain: -* cmake -* llvm -* lld -* lldb -* clang -* python -* curl -* git -* libicu-devel -* openssl-devel -* krb5-devel -* zlib-devel -* lttng-ust-devel -* ninja-build (optional, enables building native code with ninja instead of make) +- `cmake` +- `llvm` +- `lld` +- `lldb` +- `clang` +- `python` +- `curl` +- `git` +- `libicu-devel` +- `openssl-devel` +- `krb5-devel` +- `lttng-ust-devel` +- `ninja-build` (Optional. Enables building native code using `ninja` instead of `make`) ```bash -sudo dnf install -y cmake llvm lld lldb clang python curl git libicu-devel openssl-devel \ - krb5-devel zlib-devel lttng-ust-devel ninja-build +sudo dnf install -y cmake llvm lld lldb clang python curl git \ + libicu-devel openssl-devel krb5-devel lttng-ust-devel ninja-build ``` ### Gentoo @@ -115,3 +121,9 @@ In case you have Gentoo you can run following command: ```bash emerge --ask clang dev-util/lttng-ust app-crypt/mit-krb5 ``` + +## Using Docker + +As mentioned at the beginning of this doc, the other method to build the runtime repo for Linux is to use the prebuilt Docker images that our official builds use. In order to be able to run them, you first need to download and install the Docker Engine. The binaries needed and installation instructions can be found at the Docker official site [in this link](https://docs.docker.com/get-started/get-docker). + +Once you have the Docker Engine up and running, you can follow our docker building instructions [over here](/docs/workflow/using-docker.md). diff --git a/docs/workflow/requirements/macos-requirements.md b/docs/workflow/requirements/macos-requirements.md index 0eae7f1d621..e9606b12569 100644 --- a/docs/workflow/requirements/macos-requirements.md +++ b/docs/workflow/requirements/macos-requirements.md @@ -1,36 +1,29 @@ -# Requirements to build dotnet/runtime on macOS +# Requirements to Set Up the Build Environment on macOS -* [Environment](#environment) - * [Xcode](#xcode) - * [Toolchain Setup](#toolchain-setup) +- [Xcode Developer Tools](#xcode-developer-tools) +- [Toolchain Additional Dependencies](#toolchain-additional-dependencies) -This guide will walk you through the requirements needed to build _dotnet/runtime_ on macOS. We'll start by showing how to set up your environment from scratch. +To build the runtime repo on *macOS*, you will need to install the *Xcode* developer tools and a few other dependencies, described in the sections below. -## Environment +## Xcode Developer Tools -Here are the components you will need to install and setup to work with the repo. +- Install *Apple Xcode* developer tools from the [Mac App Store](https://apps.apple.com/app/xcode/id497799835). +- Configure the *Xcode* command line tools. You can do this via one of these two methods: + - Run Xcode, open Preferences, and on the Locations tab, change `Command Line Tools` to point to this installation of _Xcode.app_. This usually comes already done by default, but it's always good to ensure. + - Alternately, you can run `sudo xcode-select --switch /Applications/Xcode.app/Contents/Developer` in a terminal. This command assumes your Xcode app is named `Xcode.app` as it comes by default. If you've renamed it to something else, adjust the path accordingly, then run the command. -### Xcode +## Toolchain Additional Dependencies -* Install Apple Xcode developer tools from the [Mac App Store](https://apps.apple.com/us/app/xcode/id497799835). -* Configure the Xcode command line tools: - * Run Xcode, open Preferences, and on the Locations tab, change "Command Line Tools" to point to this installation of _Xcode.app_. This usually comes already done by default, but it's always good to ensure. - * Alternately, you can run `sudo xcode-select --switch /Applications/Xcode.app/Contents/Developer` in a terminal (Adjust the path if you renamed _Xcode.app_). +To build the runtime repo, you will also need to install the following dependencies: -### Toolchain Setup +- `CMake` 3.20 or newer +- `icu4c` +- `openssl@1.1` or `openssl@3` +- `pkg-config` +- `python3` +- `ninja` (This one is optional. It is an alternative tool to `make` for building native code) -Building _dotnet/runtime_ depends on several tools to be installed. You can download them individually or use [Homebrew](https://brew.sh) for easier toolchain setup. - -Install the following packages: - -* CMake 3.20 or newer -* icu4c -* openssl@1.1 or openssl@3 -* pkg-config -* python3 -* ninja (optional, enables building native code with ninja instead of make) - -You can install all the required packages above using _Homebrew_ by running this command in the repository root: +You can install them separately, or you can alternatively opt to install *[Homebrew](https://brew.sh/)* and use the `Brewfile` provided by the repo, which takes care of everything for you. If you go by this route, once you have *Homebrew* up and running on your machine, run the following command from the root of the repo to download and install all the necessary dependencies at once: ```bash brew bundle --no-lock --file eng/Brewfile diff --git a/docs/workflow/requirements/windows-requirements.md b/docs/workflow/requirements/windows-requirements.md index ff875e7b9c5..26ba9aa187e 100644 --- a/docs/workflow/requirements/windows-requirements.md +++ b/docs/workflow/requirements/windows-requirements.md @@ -1,140 +1,109 @@ -# Requirements to build dotnet/runtime on Windows +# Requirements to Set Up the Build Environment on Windows -* [Environment](#environment) - * [Enable Long Paths](#enable-long-paths) - * [Visual Studio](#visual-studio) - * [Build Tools](#build-tools) - * [CMake](#cmake) - * [Ninja](#ninja) - * [Python](#python) - * [Git](#git) - * [PowerShell](#powershell) - * [.NET SDK](#net-sdk) - * [Adding to the default PATH variable](#adding-to-the-default-path-variable) +- [Tools and Configuration](#tools-and-configuration) + - [Git for Windows](#git-for-windows) + - [Enable Long Paths](#enable-long-paths) + - [Visual Studio](#visual-studio) + - [Workloads](#workloads) + - [Individual Development Tools](#individual-development-tools) + - [Powershell](#powershell) + - [The .NET SDK](#the-net-sdk) +- [Setting Environment Variables on Windows](#setting-environment-variables-on-windows) -These instructions will lead you through the requirements to build _dotnet/runtime_ on Windows. +To build the runtime repo on *Windows*, you will need to install *Visual Studio*, as well as certain development tools that go with it, independently of the IDE, which are described in the following sections. -## Environment +## Tools and Configuration -Here are the components you will need to install and setup to work with the repo. +### Git for Windows -### Enable Long Paths +- First of all, download and install [Git for Windows](https://git-scm.com/download/win) (minimum required version is 2.22.0). +- The installer by default should add `Git` to your `PATH` environment variable, or at least have a checkbox where you can instruct it to do so. If it doesn't, or you'd prefer to set it later yourself, you can follow the instructions in the [Setting Environment Variables on Windows](#setting-environment-variables-on-windows) section of this doc. -The runtime repository requires long paths to be enabled. Follow [the instructions provided here](https://learn.microsoft.com/windows/win32/fileio/maximum-file-path-limitation#enable-long-paths-in-windows-10-version-1607-and-later) to enable that feature. +### Enable Long Paths -If using Git for Windows you might need to also configure long paths there. Using an administrator terminal simply type: +The runtime repo requires long paths to be enabled both, on Windows itself and on *Git*. To configure them on *Git*, open a terminal with administrator privileges and enter the following command: -```cmd +```powershell git config --system core.longpaths true ``` -### Visual Studio - -Install [Visual Studio 2022](https://visualstudio.microsoft.com/downloads/). The Community edition is available free of charge. Visual Studio 2022 17.8 or later is required. Note that as we ramp up on a given release the libraries code may start using preview language features. While an older IDE may still succeed in building the projects, the IDE may report mismatched diagnostics in the Errors and Warnings window. Using the latest public preview of Visual Studio is required to ensure the IDE experience is well behaved in such scenarios. +The reason this has to be done is that *Git for Windows* is compiled with **MSYS**, which uses a version of the Windows API that has a filepath limit of 260 characters total, as opposed to the usual limit of 4096 on macOS and Linux. -Note that Visual Studio and the development tools described below are required, regardless of whether you plan to use the IDE or not. The installation process goes as follows: +Next, to configure the long paths for Windows itself, follow the instructions provided [in this link](https://learn.microsoft.com/windows/win32/fileio/maximum-file-path-limitation?tabs=registry#enable-long-paths-in-windows-10-version-1607-and-later). -* It's recommended to use **Workloads** installation approach. The following are the minimum requirements: - * **.NET Desktop Development** with all default components, - * **Desktop Development with C++** with all default components. -* To build for Arm64, make sure that you have the right architecture-specific compilers installed. In the **Individual components** window, in the **Compilers, build tools, and runtimes** section: - * For Arm64, check the box for _MSVC v143* VS 2022 C++ ARM64 build tools (Latest)_. -* To build the tests, you will need some additional components: - * **C++/CLI support for v143 build tools (Latest)**. +If long paths are not enabled, you might start running into issues since trying to clone the repo. Especially with libraries that have very long filenames, you might get errors like `Unable to create file: Filename too long` during the cloning process. -A `.vsconfig` file is included in the root of the _dotnet/runtime_ repository that includes all components needed to build the _dotnet/runtime_ repository. You can [import `.vsconfig` in your Visual Studio installer](https://learn.microsoft.com/visualstudio/install/import-export-installation-configurations?view=vs-2022#import-a-configuration) to install all necessary components. +### Visual Studio -### Build Tools +Download and install the [latest version of Visual Studio](https://visualstudio.microsoft.com/downloads/) (minimum version required is VS 2022 17.8). The **Community Edition** is available free of charge. Note that as we ramp up on a given release, the libraries code may start using preview language features. While older versions of the IDE may still succeed in building the projects, the IDE may report mismatched diagnostics in the *Errors and Warnings* window. Using the latest public preview of Visual Studio fixes these cases and helps ensure the IDE experience is well behaved and displays what we would expect it to properly. -These steps are required only in case the tools have not been installed as Visual Studio **Individual Components** (described above). +Note that Visual Studio and its development tools are required, regardless of whether you plan to use the IDE or not. -#### CMake +#### Workloads -* Install [CMake](https://cmake.org/download) for Windows. -* Add its location (e.g. C:\Program Files (x86)\CMake\bin) to the PATH environment variable. The installation script has a check box to do this, but you can do it yourself after the fact following the instructions at [Adding to the Default PATH variable](#adding-to-the-default-path-variable). +It is highly recommended to use the *Workloads* approach, as that installs the full bundles, which include all the necessary tools for the repo to work properly. Open up *Visual Studio Installer*, and click on *Modify* on the Visual Studio installation you plan to use. There, click on the *Workloads* tab (usually selected by default), and install the following bundles: -The _dotnet/runtime_ repository requires using CMake 3.20 or newer. +- .NET desktop development +- Desktop development with C++ -**NOTE**: If you plan on using the `-msbuild` flag for building the repo, you will need version 3.21 at least. This is because the VS2022 generator doesn't exist in CMake until said version. +To build the tests and do ARM32/ARM64 development, you'll need some additional components. You can find them by clicking on the *Individual components* tab in the *Visual Studio Installer*: -#### Ninja +- For ARM stuff: *MSVC v143 - VS 2022 C++ ARM64/ARM64EC build tools (Latest)* for Arm64, and *MSVC v143 - VS 2022 C++ ARM build tools (Latest)* for Arm32. +- For building tests: *C++/CLI support for v143 build tools (Latest)* -* Install Ninja in one of the three following ways - * Ninja is included with Visual Studio. ARM64 Windows should use this method as other options are currently not available for ARM64. - * [Download the executable](https://github.com/ninja-build/ninja/releases) and add its location to [the Default PATH variable](#adding-to-the-default-path-variable). - * [Install via a package manager](https://github.com/ninja-build/ninja/wiki/Pre-built-Ninja-packages), which should automatically add it to the PATH environment variable. +Alternatively, there is also a `.vsconfig` file included at the root of the runtime repo. It includes all the necessary components required, outlined in a JSON format that Visual Studio can read and parse. You can boot up Visual Studio directly and [import this `.vsconfig` file](https://learn.microsoft.com/visualstudio/install/import-export-installation-configurations?view=vs-2022#import-a-configuration) instead of installing the workloads yourself. It is worth mentioning however, that while we are very careful in maintaining this file up-to-date, sometimes it might get a tad obsolete and miss important components. So, it is always a good idea to double check that the full workloads are installed. -#### Python +#### Individual Development Tools -* Install [Python](https://www.python.org/downloads/) for Windows. -* Add its location (e.g. C:\Python*\\) to the PATH environment variable. - The installation script has a check box to do this, but you can do it yourself after the fact following the instructions at [Adding to the Default PATH variable](#adding-to-the-default-path-variable). +All the tools you need should've been installed by Visual Studio at this point. Some of those tools, however, may not have been installed or you might prefer installing them yourself from their own sources. The main process for this is to download their installers and follow their setup. Said installers usually also prompt you to add them automatically to your `PATH` environment variable. If you miss this option, or prefer to set them yourself later on, you can follow the instructions in the [Setting Environment Variables on Windows](#setting-environment-variables-on-windows) section of this doc. -The _dotnet/runtime_ repository requires at least Python 3.7.4. +Here are the links where you can download these tools: -### Git +- *CMake*: https://cmake.org/download (minimum required version is 3.20) +- *Ninja*: https://github.com/ninja-build/ninja/releases (latest version is most recommended) +- *Python*: https://www.python.org/downloads/windows (minimum required version is 3.7.4) -* Install [Git](https://git-for-windows.github.io/) for Windows. -* Add its location (e.g. C:\Program Files\Git\cmd) to the PATH environment variable. - The installation script has a check box to do this, but you can do it yourself after the fact following the instructions at [Adding to the Default PATH variable](#adding-to-the-default-path-variable). +**NOTE:** If you plan on using *MSBuild* instead of *Ninja* to build the native components, then the minimum required CMake version is 3.21 instead. This is because the VS2022 generator doesn't exist in CMake until said version. -The _dotnet/runtime_ repository requires at least Git 2.22.0. +### Powershell -### PowerShell +The runtime repo also uses some `powershell` scripts as part of the Windows builds, so ensure it is accessible via your `PATH` environment variable. It is located in `%SYSTEMROOT%\System32\WindowsPowerShell\v1.0` and should be all set since you first installed Windows, but it never hurts to double check. -* Ensure that `powershell.exe` is accessible via the PATH environment variable. Typically this is `%SYSTEMROOT%\System32\WindowsPowerShell\v1.0\` and its automatically set upon Windows installation. -* Powershell version must be 3.0 or higher. Use `$PSVersionTable.PSVersion` to determine the engine version. + +The minimum required version is 3.0, and your Windows installation should have it. You can verify this by checking the `$PSVersionTable.PSVersion` variable in a Powershell terminal. -### .NET SDK +### The .NET SDK -While not strictly needed to build or test this repository, having the .NET SDK installed lets you browse solution files in this repository with Visual Studio and use the `dotnet.exe` command to run .NET applications in the 'normal' way. +While not strictly needed to build or test this repository, having the .NET SDK installed lets you browse solution files in the codebase with Visual Studio and use the `dotnet.exe` command to build and run .NET applications in the 'normal' way. -We use this in the [build testing with the installed SDK](/docs/workflow/testing/using-your-build-with-installed-sdk.md), and [build testing with dev shipping packages](/docs/workflow/testing/using-dev-shipping-packages.md) instructions. The minimum required version of the SDK is specified in the [global.json file](https://github.com/dotnet/runtime/blob/main/global.json#L3). You can find the installers and binaries for latest development builds of .NET SDK in the [sdk repo](https://github.com/dotnet/sdk#installing-the-sdk). +We use this in the [build testing with the installed SDK](/docs/workflow/testing/using-your-build-with-installed-sdk.md), and [build testing with dev shipping packages](/docs/workflow/testing/using-dev-shipping-packages.md) instructions. The minimum required version of the SDK is specified in the [global.json file](https://github.com/dotnet/runtime/blob/main/global.json#L3). You can find the nightly installers and binaries for the latest development builds over in the [SDK repo](https://github.com/dotnet/sdk#installing-the-sdk). -Alternatively, to avoid modifying your machine state, you can use the repository's locally acquired SDK by passing in the solution to load via the `-vs` switch. For example: +Alternatively, if you would rather avoid modifying your machine state, you can use the repository's locally acquired SDK by passing in the solution to load via the `-vs` switch. For example: ```cmd .\build.cmd -vs System.Text.RegularExpressions ``` -This will set the `DOTNET_ROOT` and `PATH` environment variables to point to the locally acquired SDK under `runtime\.dotnet` and will launch the Visual Studio instance that is registered for the `sln` extension. +This will set the `DOTNET_ROOT` and `PATH` environment variables to point to the locally acquired SDK under the `.dotnet` directory found at the root of the repo for the duration of this terminal session. Then, it will launch the Visual Studio instance that is registered for the `.sln` extension, and open the solution you passed as argument to the command-line. -### Adding to the default PATH variable +## Setting Environment Variables on Windows -The commands above need to be on your command lookup path. Some installers will automatically add them to the path as part of the installation, but if not, here is how you can do it. +As mentioned in the sections above, the commands that run the development tools have to be in your `PATH` environment variable. Their installers usually have the option to do it automatically for you enabled by the default, but if for any reason you need to set them yourself, here is how you can do it. There are two options. You can make them last only for that terminal instance, or you can set them directly to the system to make them permanent. -You can also temporarily add a directory to the PATH environment variable with the command-prompt syntax `set PATH=%PATH%;DIRECTORY_TO_ADD_TO_PATH`. If you're working with Powershell, then the syntax would be `$Env:PATH += ";DIRECTORY_TO_ADD_TO_PATH"`. However, this change will only last until the command windows close. +**Temporary for the Duration of the Terminal Session** -You can make your change to the PATH variable persistent by going to _Control Panel -> System And Security -> System -> Advanced system settings -> Environment Variables_, and select the `Path` variable under `System Variables` (if you want to change it for all users) or `User Variables` (if you only want to change it for the current user). +If you're on *Command Prompt*, issue the following command: -Simply edit the PATH variable's value and add the directory (with a semicolon separator). - -### Windows on Arm64 - -The Windows on Arm64 development experience has improved substantially over the last few years, however there are still a few steps you should take to improve performance when developing dotnet/runtime on an ARM device. - -During preview releases, the repo sources its compilers from the [Microsoft.NET.Compilers.Toolset](https://www.nuget.org/packages/Microsoft.Net.Compilers.Toolset/) package whose bits aren't configured for the ARM64 build of .NET framework. This can result in [suboptimal performance](https://github.com/dotnet/runtime/issues/104548) when working on libraries in Visual Studio. The issue can be worked around by [configuring the registry](https://github.com/dotnet/runtime/issues/104548#issuecomment-2214581797) to run the compiler as Arm64 processes. The proper fix that will make this workaround unnecessary is being worked on in [this PR](https://github.com/dotnet/roslyn/pull/74285). +```cmd +set PATH=%PATH%; +``` -Using an Administrator Powershell prompt run the script: +If you're on *Powershell*, then the command looks like this: ```powershell -function SetPreferredMachineToArm64($imageName) -{ - $RegistryPath = "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\${imageName}" - $Name = "PreferredMachine" - $Value = [convert]::ToInt32("aa64", 16) - - # Create the key if it does not exist - If (-NOT (Test-Path $RegistryPath)) { - New-Item -Path $RegistryPath -Force | Out-Null - } - - # Now set the value - New-ItemProperty -Path $RegistryPath -Name $Name -Value $Value -PropertyType DWORD -Force -} - -SetPreferredMachineToArm64('csc.exe') -SetPreferredMachineToArm64('VBCSCompiler.exe') +$Env:PATH += ";" ``` -Then restart any open Visual Studio applications. +**Permanently on the System** + +To make your environment variables changes persistent, open *Control Panel*. There, click on *System and Security* -> *System* -> *Advanced System Settings* -> *Environment Variables*. Then, there you'll notice there are two `PATH` environment variables: One under `User Variables`, and one under `System Variables`. If you want to make the changes persistent only for your current user, then edit the former one, and if you want them to spread across all accounts in that machine, then edit the latter one. diff --git a/docs/workflow/testing/coreclr/testing.md b/docs/workflow/testing/coreclr/testing.md index 46de9e02231..fe8d69d7a86 100644 --- a/docs/workflow/testing/coreclr/testing.md +++ b/docs/workflow/testing/coreclr/testing.md @@ -136,7 +136,7 @@ On macOS and Linux: We have multiple different mechanisms of executing tests. -Our test entrypoints are generally what we call "merged test runners", as they provide an executable runner project for multiple different test assemblies. These projects can be identified by the `` line in their .csproj file. These projects provide a simple experience for running tests. When executing a merged runner project, it will run each test sequentially and record if it passes or fails in an xunit results file. The merged test runner support runtime test filtering. If specified, the first argument to the test runner is treated as a `dotnet test --filter` argument following the xUnit rules in their documentation. Today, the runner only supports the simple form, a substring of a test's fully-qualified name, in the format `Namespace.ContainingTypeName.TypeName.Method`. If support for further filtering options is desired, please open an issue requesting it. +Our test entrypoints are generally what we call "merged test runners", as they provide an executable runner project for multiple different test assemblies. These projects can be identified by the `` line in their .csproj file. These projects provide a simple experience for running tests. When executing a merged runner project, it will run each test sequentially and record if it passes or fails in an xunit results file. The merged test runner support runtime test filtering. If specified, the first argument to the test runner is treated as a `dotnet test --filter` argument following the xUnit rules in their documentation. Today, the runner only supports the simple form, a substring of a test's fully-qualified name, in the format `Namespace.ContainingTypeName.TypeName.Method`. Additionally, tests can be filtered using the `FullyQualifiedName=Namespace.ContainingTypeName.TypeName.Method` syntax or the `DisplayName=TestDisplayName` syntax. The display name of a test is the name printed out on the console when the test runs. Additionally, a `~` can be used instead of an `=` to specify a substring search. If support for further filtering options is desired, please open an issue requesting it. Some tests need to be run in their own process as they interact with global process state, they have a custom test entrypoint, or they interact poorly with other tests in the same process. These tests are generally marked with `true` in their project files. These tests can be run directly, but they can also be invoked through their corresponding merged test runner. The merged test runner will invoke them as a subprocess in the same manner as if they were run individually. @@ -150,6 +150,35 @@ To filter tests on a merged test runner built as standalone, you can set the `Te If you wish to use the Standalone runner described in the [previous section](#the-standalone-test-runner-and-build-time-test-filtering), you can set the `BuildAllTestsAsStandalone` environment variable to `true` when invoking the `./src/tests/build.sh` or `./src/tests/build.cmd` scripts (for example, `export BuildAllTestsAsStandalone=true` or `set BuildAllTestsAsStandalone=true`). This will build all tests that are not directly in a merged test runner's project as separate executable tests and build only the tests that are compiled into the runner directly. If a runner has no tests that are built directly into the runner, then it will be excluded. +### I added a test, which project do I run to run it? + +Now that we run multiple tests in a single process, determining which project corresponds to the test to run can be a bit tricky. Here's some basic steps to determine which project to run to execute a test: + +1. Look at the project file. + +If the project file has `true` or ``, then to run the test, you should build this project and run the `.cmd` or `.sh` script that corresponds to this project file. + +2. Look at .csproj files in parent directories. + +In a parent directory, you will find a `.csproj` file marked with ``. In that project file, you'll see one or more `MergedTestProjectReference` items. If one of the glob patterns in the `Include` attribute matches and the `Exclude` attribute on the same item, then the test is included in this merged test runner. To run the test, you should build this merged runner project and run the `.cmd` or `.sh` script that corresponds to this project file. You can filter the tests in this runner using the instructions in the [Test Executors section](#test-executors). + +### When to make a test RequiresProcessIsolation + +The following are common reasons to mark a test as requiring process isolation: + +- The test manipulates process-wide state, such as setting environment variables or changing the current directory. +- The test requires the ability to parse command line arguments. +- The test needs a custom main method. +- The test requires special information, such as an app manifest, in its executable. +- The test launches through a native executable. +- The test sets one of the configuration properties that are checked in the test run scripts, such as those in [test-configuration.md](test-configuration.md#adding-test-guidelines). + +When a test is marked as `true`, it will be run in its own process and have its own `.cmd` and `.sh` scripts generated as test entrypoints. In CI, it will be executed as out of process by whichever merged test runner it is referenced by. + +#### Main methods in RequiresProcessIsolation tests + +If a custom main is not provided, the test can use `[Fact]` and `[Theory]` attributes internally. The test will use the "standalone" generator to create the test entrypoint. If you want to provide your own `Main` method for your test, set the `false` property in the test project file. + ### Building C++/CLI Native Test Components Against the Live Ref Assemblies By default, the _C++/CLI_ native test components build against the _ref pack_ from the SDK specified in the `global.json` file in the root of the repository. To build these components against the _ref assemblies_ produced in the build, pass the `-cmakeargs -DCPP_CLI_LIVE_REF_ASSEMBLIES=1` parameters to the test build. For example: diff --git a/docs/workflow/trimming/feature-switches.md b/docs/workflow/trimming/feature-switches.md index 92d04e897a2..76714d95f2c 100644 --- a/docs/workflow/trimming/feature-switches.md +++ b/docs/workflow/trimming/feature-switches.md @@ -14,6 +14,7 @@ configurations but their defaults might vary as any SDK can set the defaults dif | VerifyDependencyInjectionOpenGenericServiceTrimmability | Microsoft.Extensions.DependencyInjection.VerifyOpenGenericServiceTrimmability | When set to true, DependencyInjection will verify trimming annotations applied to open generic services are correct. | | _AggressiveAttributeTrimming | System.AggressiveAttributeTrimming | When set to true, aggressively trims attributes to allow for the most size savings possible, even if it could result in runtime behavior changes | | _ComObjectDescriptorSupport | System.ComponentModel.TypeDescriptor.IsComObjectDescriptorSupported | When set to true, supports creating a TypeDescriptor based view of COM objects. | +| _DataSetXmlSerializationSupport | System.Data.DataSet.XmlSerializationIsSupported | When set to false, DataSet implementation of IXmlSerializable will throw instead of using trim-incompatible XML serialization. | | _DefaultValueAttributeSupport | System.ComponentModel.DefaultValueAttribute.IsSupported | When set to true, supports creating a DefaultValueAttribute at runtime. | | _DesignerHostSupport | System.ComponentModel.Design.IDesignerHost.IsSupported | When set to true, supports creating design components at runtime. | | _EnableConsumingManagedCodeFromNativeHosting | System.Runtime.InteropServices.EnableConsumingManagedCodeFromNativeHosting | Getting a managed function from native hosting is disabled when set to false and related functionality can be trimmed. | diff --git a/docs/workflow/using-docker.md b/docs/workflow/using-docker.md new file mode 100644 index 00000000000..6f3ca0912d4 --- /dev/null +++ b/docs/workflow/using-docker.md @@ -0,0 +1,79 @@ +# Using Docker for your Workflow + +- [Docker Basics](#docker-basics) +- [The Official Runtime Docker Images](#the-official-runtime-docker-images) +- [Build the Repo](#build-the-repo) + +This doc will cover the usage of Docker images and containers for your builds. + +## Docker Basics + +First, you have to enable and install the Docker Engine. Follow the instructions in their official site in [this link](https://docs.docker.com/get-started/get-docker) if you haven't done so. + +When using Docker, your machine's OS is strictly speaking not terribly important. For example, if you are on *Ubuntu 22.04*, you can use the *Ubuntu 18.04* image without any issues whatsoever. Likewise, you can run Linux images on Windows if you have WSL enabled. If you followed the instructions from the Docker official website when installing the engine, you most likely have it already up and running. If not, you can follow the instructions in [this link](https://learn.microsoft.com/windows/wsl/install) to enable it. However, note that you can't run multiple OS's on the same *Docker Daemon*, as it takes resources from the underlying kernel as needed. In other words, you can run either Linux on WSL, or Windows containers. You have to switch between them if you need both, and restart Docker. + +The target architecture is more important to consider when using Docker containers. The image's architecture has to match your machine's supported platforms. For instance, you can run both, x64 and Arm64 images on an *Apple Silicon Mac*, thanks to the *Rosetta* x64 emulator it provides. Likewise, you can run Linux Arm32 images on a Linux Arm64 host. + +Note that while Docker uses WSL to run the Linux containers on Windows, you don't have to boot up a WSL terminal to run them. Any `cmd` or `powershell` terminal with the `docker` command available will suffice to run all the commands. Docker takes care of the rest. + +## The Official Runtime Docker Images + +In the following tables, you will find the full names with tags of the images used for the official builds. + +**Main Docker Images** + +The main Docker images are the most commonly used ones, and the ones you will probably need for your builds. If you are working with more specific scenarios (e.g. Android, Risc-V), then you will find the images you need in the *Extended Docker Images* table right below this one. + +| Host OS | Target OS | Target Arch | Image | crossrootfs dir | +| ----------------- | ------------ | --------------- | -------------------------------------------------------------------------------------- | -------------------- | +| Azure Linux (x64) | Alpine 3.13 | x64 | `mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-amd64-alpine` | `/crossrootfs/x64` | +| Azure Linux (x64) | Ubuntu 16.04 | x64 | `mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-amd64` | `/crossrootfs/x64` | +| Azure Linux (x64) | Alpine 3.13 | Arm32 (armhf) | `mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-arm-alpine` | `/crossrootfs/arm` | +| Azure Linux (x64) | Ubuntu 22.04 | Arm32 (armhf) | `mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-arm` | `/crossrootfs/arm` | +| Azure Linux (x64) | Alpine 3.13 | Arm64 (arm64v8) | `mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-arm64-alpine` | `/crossrootfs/arm64` | +| Azure Linux (x64) | Ubuntu 16.04 | Arm64 (arm64v8) | `mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-arm64` | `/crossrootfs/arm64` | +| Azure Linux (x64) | Ubuntu 16.04 | x86 | `mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-x86` | `/crossrootfs/x86` | + +**Extended Docker Images** + +| Host OS | Target OS | Target Arch | Image | crossrootfs dir | +| ----------------- | -------------------------- | ------------- | --------------------------------------------------------------------------------------- | ---------------------- | +| Azure Linux (x64) | Android Bionic | x64 | `mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-android-amd64` | *N/A* | +| Azure Linux (x64) | Android Bionic (w/OpenSSL) | x64 | `mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-android-openssl` | *N/A* | +| Azure Linux (x64) | Android Bionic (w/Docker) | x64 | `mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-android-docker` | *N/A* | +| Azure Linux (x64) | Azure Linux 3.0 | x64 | `mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-fpm` | *N/A* | +| Azure Linux (x64) | FreeBSD 13 | x64 | `mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-freebsd-13` | `/crossrootfs/x64` | +| Azure Linux (x64) | Ubuntu 18.04 | PPC64le | `mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-ppc64le` | `/crossrootfs/ppc64le` | +| Azure Linux (x64) | Ubuntu 24.04 | RISC-V | `mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-riscv64` | `/crossrootfs/riscv64` | +| Azure Linux (x64) | Ubuntu 18.04 | S390x | `mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-s390x` | `/crossrootfs/s390x` | +| Azure Linux (x64) | Ubuntu 16.04 (Wasm) | x64 | `mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-webassembly-amd64` | `/crossrootfs/x64` | +| Debian (x64) | Debian 12 | x64 | `mcr.microsoft.com/dotnet-buildtools/prereqs:debian-12-gcc14-amd64` | *N/A* | +| Ubuntu (x64)* | Ubuntu 22.04 | x64 | `mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-22.04-debpkg` | *N/A* | +| Ubuntu (x64) | Tizen 9.0 | Arm32 (armel) | `mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-22.04-cross-armel-tizen` | `/crossrootfs/armel` | +| Ubuntu (x64) | Ubuntu 20.04 | Arm32 (v6) | `mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-20.04-cross-armv6-raspbian-10` | `/crossrootfs/armv6` | + +**NOTE:** The Ubuntu image marked with an * in the table above is only used for producing *deb* packages, but not for building any product code. + +## Build the Repo + +Once you've chosen the image that suits your needs, you can issue `docker run` with the necessary arguments to use your clone of the runtime repo, and call the build scripts as you need. Down below, we have a small command-line example, explaining each of the flags you might need to use: + +```bash +docker run --rm \ + -v :/runtime \ + -w /runtime \ + mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-amd64 \ + ./build.sh --subset clr --configuration Checked +``` + +Now, dissecting the command: + +- `--rm`: Erase the created container after it finishes running. +- `-v :/runtime`: Mount the runtime repo clone located in `` to the container path `/runtime`. +- `-w /runtime`: Start the container in the `/runtime` directory. +- `mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-amd64`: The fully qualified name of the Docker image to download. In this case, we want to use an *Azure Linux* image to target the *x64* architecture. +- `./build.sh --subset clr --configuration Checked`: The build command to run in the repo. In this case, we want to build the *Clr* subset in the *Checked* configuration. + +You might also want to interact with the container directly for a myriad of reasons, like running multiple builds in different paths for example. In this case, instead of passing the build script command to the `docker` command-line, pass the flag `-it`. When you do this, you will get access to a small shell within the container, which allows you to explore it, run builds manually, and so on, like you would on a regular terminal in your machine. Note that the containers' shell's built-in tools are very limited in comparison to the ones you probably have on your machine, so don't expect to be able to do full work there. + +To do cross-building using Docker, make sure to select the appropriate image that targets the platform you want to build for. As for the commands to run, follow the same instructions from the cross-building doc [over here](/docs/workflow/building/coreclr/cross-building.md), with the difference that you don't need to generate the *ROOTFS*, as the cross-building images already include it. diff --git a/eng/DotNetBuild.props b/eng/DotNetBuild.props index 3569781b9af..ce13d6ca5b0 100644 --- a/eng/DotNetBuild.props +++ b/eng/DotNetBuild.props @@ -88,7 +88,7 @@ +$(UseSystemLibs)+ - $(InnerBuildArgs) --cmakeargs -DCLR_CMAKE_USE_SYSTEM_BROTLI=true + $(InnerBuildArgs) --cmakeargs -DCLR_CMAKE_USE_SYSTEM_BROTLI=true $(InnerBuildArgs) --cmakeargs -DCLR_CMAKE_USE_SYSTEM_LIBUNWIND=true diff --git a/eng/SourceBuildPrebuiltBaseline.xml b/eng/SourceBuildPrebuiltBaseline.xml index 4e366ddb469..4185d755fa6 100644 --- a/eng/SourceBuildPrebuiltBaseline.xml +++ b/eng/SourceBuildPrebuiltBaseline.xml @@ -6,6 +6,7 @@ + diff --git a/eng/Subsets.props b/eng/Subsets.props index fa12195a7b5..d36d18894d9 100644 --- a/eng/Subsets.props +++ b/eng/Subsets.props @@ -204,8 +204,6 @@ - - @@ -498,20 +496,16 @@ - + - %(AdditionalProperties);RefOnly=true - + '$(BuildAllConfigurations)' == 'true'" /> - - - %(AdditionalProperties);RefOnly=true - + + @@ -614,6 +608,7 @@ %(AdditionalProperties);Configuration=$(ToolsConfiguration) + %(AdditionalProperties);RuntimeConfiguration=$(RuntimeConfiguration) %(AdditionalProperties);LibrariesConfiguration=$(LibrariesConfiguration) %(AdditionalProperties);HostConfiguration=$(HostConfiguration) %(AdditionalProperties);TasksConfiguration=$(TasksConfiguration) diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml index c11cd27877a..7ba1021c032 100644 --- a/eng/Version.Details.xml +++ b/eng/Version.Details.xml @@ -1,8 +1,8 @@ - + https://github.com/dotnet/icu - 99e6c98ad1faf55e6335ab768dab5917b456a87f + 02ededbbc13185818d31bdae9777a12710a80d23 https://github.com/dotnet/msquic @@ -12,37 +12,37 @@ https://github.com/dotnet/wcf 7f504aabb1988e9a093c1e74d8040bd52feb2f01 - + https://github.com/dotnet/llvm-project - 3358dfd351b424698f3f2cd67432dc62c333a64d + b9b4464b3b10c1961ed0ff39b5f33b3b3bbf62d1 - + https://github.com/dotnet/llvm-project - 3358dfd351b424698f3f2cd67432dc62c333a64d + b9b4464b3b10c1961ed0ff39b5f33b3b3bbf62d1 - + https://github.com/dotnet/llvm-project - 3358dfd351b424698f3f2cd67432dc62c333a64d + b9b4464b3b10c1961ed0ff39b5f33b3b3bbf62d1 - + https://github.com/dotnet/llvm-project - 3358dfd351b424698f3f2cd67432dc62c333a64d + b9b4464b3b10c1961ed0ff39b5f33b3b3bbf62d1 - + https://github.com/dotnet/llvm-project - 3358dfd351b424698f3f2cd67432dc62c333a64d + b9b4464b3b10c1961ed0ff39b5f33b3b3bbf62d1 - + https://github.com/dotnet/llvm-project - 3358dfd351b424698f3f2cd67432dc62c333a64d + b9b4464b3b10c1961ed0ff39b5f33b3b3bbf62d1 - + https://github.com/dotnet/llvm-project - 3358dfd351b424698f3f2cd67432dc62c333a64d + b9b4464b3b10c1961ed0ff39b5f33b3b3bbf62d1 - + https://github.com/dotnet/llvm-project - 3358dfd351b424698f3f2cd67432dc62c333a64d + b9b4464b3b10c1961ed0ff39b5f33b3b3bbf62d1 https://github.com/dotnet/command-line-api @@ -54,319 +54,315 @@ 803d8598f98fb4efd94604b32627ee9407f246db - + https://github.com/dotnet/cecil - b9d928a9d65ed39b9257846e1b8e853cea609c00 + 1541df9c44ff8da964b2946e18655c2e37e4a198 - + https://github.com/dotnet/cecil - b9d928a9d65ed39b9257846e1b8e853cea609c00 + 1541df9c44ff8da964b2946e18655c2e37e4a198 - + https://github.com/dotnet/emsdk - edf3e90fa25b1fc4f7f63ceb45ef70f49c6b121a + 530feeca3813957c21b096ac371a1cf98ac11b76 - + https://github.com/dotnet/emsdk - edf3e90fa25b1fc4f7f63ceb45ef70f49c6b121a + 530feeca3813957c21b096ac371a1cf98ac11b76 - + https://github.com/dotnet/source-build-reference-packages - 26ae006620fb4518276b494efac55dbcd8f80224 + bdd698774daa248301c236f09b97015610ca2842 - + https://github.com/dotnet/source-build-externals - 51b029e3272f35af0af337823cd122725f316c69 + 2a2ecbfbee3f87786d9de50e886a72773f0ba449 - + https://github.com/dotnet/arcade - 60ae233c3d77f11c5fdb53e570b64d503b13ba59 + 34138f08e2c9c3c41a0ac8af583a57ea953e3821 - + https://github.com/dotnet/arcade - 60ae233c3d77f11c5fdb53e570b64d503b13ba59 + 34138f08e2c9c3c41a0ac8af583a57ea953e3821 - + https://github.com/dotnet/arcade - 60ae233c3d77f11c5fdb53e570b64d503b13ba59 + 34138f08e2c9c3c41a0ac8af583a57ea953e3821 - + https://github.com/dotnet/arcade - 60ae233c3d77f11c5fdb53e570b64d503b13ba59 + 34138f08e2c9c3c41a0ac8af583a57ea953e3821 - + https://github.com/dotnet/arcade - 60ae233c3d77f11c5fdb53e570b64d503b13ba59 + 34138f08e2c9c3c41a0ac8af583a57ea953e3821 - + https://github.com/dotnet/arcade - 60ae233c3d77f11c5fdb53e570b64d503b13ba59 + 34138f08e2c9c3c41a0ac8af583a57ea953e3821 - + https://github.com/dotnet/arcade - 60ae233c3d77f11c5fdb53e570b64d503b13ba59 + 34138f08e2c9c3c41a0ac8af583a57ea953e3821 - + https://github.com/dotnet/arcade - 60ae233c3d77f11c5fdb53e570b64d503b13ba59 + 34138f08e2c9c3c41a0ac8af583a57ea953e3821 - + https://github.com/dotnet/arcade - 60ae233c3d77f11c5fdb53e570b64d503b13ba59 + 34138f08e2c9c3c41a0ac8af583a57ea953e3821 - + https://github.com/dotnet/arcade - 60ae233c3d77f11c5fdb53e570b64d503b13ba59 + 34138f08e2c9c3c41a0ac8af583a57ea953e3821 - + https://github.com/dotnet/arcade - 60ae233c3d77f11c5fdb53e570b64d503b13ba59 + 34138f08e2c9c3c41a0ac8af583a57ea953e3821 - + https://github.com/dotnet/arcade - 60ae233c3d77f11c5fdb53e570b64d503b13ba59 + 34138f08e2c9c3c41a0ac8af583a57ea953e3821 - + https://github.com/dotnet/arcade - 60ae233c3d77f11c5fdb53e570b64d503b13ba59 + 34138f08e2c9c3c41a0ac8af583a57ea953e3821 - + https://github.com/dotnet/arcade - 60ae233c3d77f11c5fdb53e570b64d503b13ba59 + 34138f08e2c9c3c41a0ac8af583a57ea953e3821 - + https://github.com/dotnet/arcade - 60ae233c3d77f11c5fdb53e570b64d503b13ba59 + 34138f08e2c9c3c41a0ac8af583a57ea953e3821 - + https://github.com/dotnet/arcade - 60ae233c3d77f11c5fdb53e570b64d503b13ba59 + 34138f08e2c9c3c41a0ac8af583a57ea953e3821 - + https://github.com/dotnet/arcade - 60ae233c3d77f11c5fdb53e570b64d503b13ba59 + 34138f08e2c9c3c41a0ac8af583a57ea953e3821 - + https://github.com/dotnet/arcade - 60ae233c3d77f11c5fdb53e570b64d503b13ba59 + 34138f08e2c9c3c41a0ac8af583a57ea953e3821 - + https://github.com/dotnet/arcade - 60ae233c3d77f11c5fdb53e570b64d503b13ba59 + 34138f08e2c9c3c41a0ac8af583a57ea953e3821 - + https://github.com/dotnet/arcade - 60ae233c3d77f11c5fdb53e570b64d503b13ba59 + 34138f08e2c9c3c41a0ac8af583a57ea953e3821 - + https://github.com/dotnet/runtime-assets - 3ed40d4f2335532ee7b04f8449468c52b4e2a643 + 928df39794e0f6677b50d6d8f690c52880c58d13 - + https://github.com/dotnet/runtime-assets - 3ed40d4f2335532ee7b04f8449468c52b4e2a643 + 928df39794e0f6677b50d6d8f690c52880c58d13 - + https://github.com/dotnet/runtime-assets - 3ed40d4f2335532ee7b04f8449468c52b4e2a643 + 928df39794e0f6677b50d6d8f690c52880c58d13 - + https://github.com/dotnet/runtime-assets - 3ed40d4f2335532ee7b04f8449468c52b4e2a643 + 928df39794e0f6677b50d6d8f690c52880c58d13 - + https://github.com/dotnet/runtime-assets - 3ed40d4f2335532ee7b04f8449468c52b4e2a643 + 928df39794e0f6677b50d6d8f690c52880c58d13 - + https://github.com/dotnet/runtime-assets - 3ed40d4f2335532ee7b04f8449468c52b4e2a643 + 928df39794e0f6677b50d6d8f690c52880c58d13 - + https://github.com/dotnet/runtime-assets - 3ed40d4f2335532ee7b04f8449468c52b4e2a643 + 928df39794e0f6677b50d6d8f690c52880c58d13 - + https://github.com/dotnet/runtime-assets - 3ed40d4f2335532ee7b04f8449468c52b4e2a643 + 928df39794e0f6677b50d6d8f690c52880c58d13 - + https://github.com/dotnet/runtime-assets - 3ed40d4f2335532ee7b04f8449468c52b4e2a643 + 928df39794e0f6677b50d6d8f690c52880c58d13 - + https://github.com/dotnet/runtime-assets - 3ed40d4f2335532ee7b04f8449468c52b4e2a643 + 928df39794e0f6677b50d6d8f690c52880c58d13 - + https://github.com/dotnet/runtime-assets - 3ed40d4f2335532ee7b04f8449468c52b4e2a643 + 928df39794e0f6677b50d6d8f690c52880c58d13 - + https://github.com/dotnet/runtime-assets - 3ed40d4f2335532ee7b04f8449468c52b4e2a643 + 928df39794e0f6677b50d6d8f690c52880c58d13 - + https://github.com/dotnet/runtime-assets - 3ed40d4f2335532ee7b04f8449468c52b4e2a643 + 928df39794e0f6677b50d6d8f690c52880c58d13 - + https://github.com/dotnet/llvm-project - 3358dfd351b424698f3f2cd67432dc62c333a64d + b9b4464b3b10c1961ed0ff39b5f33b3b3bbf62d1 - + https://github.com/dotnet/llvm-project - 3358dfd351b424698f3f2cd67432dc62c333a64d + b9b4464b3b10c1961ed0ff39b5f33b3b3bbf62d1 - + https://github.com/dotnet/llvm-project - 3358dfd351b424698f3f2cd67432dc62c333a64d + b9b4464b3b10c1961ed0ff39b5f33b3b3bbf62d1 - + https://github.com/dotnet/llvm-project - 3358dfd351b424698f3f2cd67432dc62c333a64d + b9b4464b3b10c1961ed0ff39b5f33b3b3bbf62d1 - + https://github.com/dotnet/llvm-project - 3358dfd351b424698f3f2cd67432dc62c333a64d + b9b4464b3b10c1961ed0ff39b5f33b3b3bbf62d1 - + https://github.com/dotnet/llvm-project - 3358dfd351b424698f3f2cd67432dc62c333a64d + b9b4464b3b10c1961ed0ff39b5f33b3b3bbf62d1 - + https://github.com/dotnet/llvm-project - 3358dfd351b424698f3f2cd67432dc62c333a64d + b9b4464b3b10c1961ed0ff39b5f33b3b3bbf62d1 - + https://github.com/dotnet/llvm-project - 3358dfd351b424698f3f2cd67432dc62c333a64d + b9b4464b3b10c1961ed0ff39b5f33b3b3bbf62d1 - + https://github.com/dotnet/llvm-project - 3358dfd351b424698f3f2cd67432dc62c333a64d + b9b4464b3b10c1961ed0ff39b5f33b3b3bbf62d1 - + https://github.com/dotnet/llvm-project - 3358dfd351b424698f3f2cd67432dc62c333a64d + b9b4464b3b10c1961ed0ff39b5f33b3b3bbf62d1 - + https://github.com/dotnet/llvm-project - 3358dfd351b424698f3f2cd67432dc62c333a64d + b9b4464b3b10c1961ed0ff39b5f33b3b3bbf62d1 - + https://github.com/dotnet/llvm-project - 3358dfd351b424698f3f2cd67432dc62c333a64d + b9b4464b3b10c1961ed0ff39b5f33b3b3bbf62d1 - + https://github.com/dotnet/llvm-project - 3358dfd351b424698f3f2cd67432dc62c333a64d + b9b4464b3b10c1961ed0ff39b5f33b3b3bbf62d1 - + https://github.com/dotnet/llvm-project - 3358dfd351b424698f3f2cd67432dc62c333a64d + b9b4464b3b10c1961ed0ff39b5f33b3b3bbf62d1 - + https://github.com/dotnet/runtime - 1cc0186c3e120ee4ed0494cf74fef0a3ef0118d6 + 7cb32e193a55a95c74fc3bd56501b951b48b700f - + https://github.com/dotnet/runtime - 1cc0186c3e120ee4ed0494cf74fef0a3ef0118d6 + 7cb32e193a55a95c74fc3bd56501b951b48b700f - + https://github.com/dotnet/runtime - 1cc0186c3e120ee4ed0494cf74fef0a3ef0118d6 + 7cb32e193a55a95c74fc3bd56501b951b48b700f - + https://github.com/dotnet/runtime - 1cc0186c3e120ee4ed0494cf74fef0a3ef0118d6 + 7cb32e193a55a95c74fc3bd56501b951b48b700f - + https://github.com/dotnet/runtime - 1cc0186c3e120ee4ed0494cf74fef0a3ef0118d6 + 7cb32e193a55a95c74fc3bd56501b951b48b700f - + https://github.com/dotnet/runtime - 1cc0186c3e120ee4ed0494cf74fef0a3ef0118d6 + 7cb32e193a55a95c74fc3bd56501b951b48b700f - + https://github.com/dotnet/runtime - 1cc0186c3e120ee4ed0494cf74fef0a3ef0118d6 + 7cb32e193a55a95c74fc3bd56501b951b48b700f - + https://github.com/dotnet/runtime - 1cc0186c3e120ee4ed0494cf74fef0a3ef0118d6 + 7cb32e193a55a95c74fc3bd56501b951b48b700f - - https://github.com/dotnet/runtime - 1cc0186c3e120ee4ed0494cf74fef0a3ef0118d6 - - + https://github.com/dotnet/xharness - 9794254fa909ff5adc46326e9b54009793f61dcd + f20e52f7731da99588dd6b4f4bd60119f03220a3 - + https://github.com/dotnet/xharness - 9794254fa909ff5adc46326e9b54009793f61dcd + f20e52f7731da99588dd6b4f4bd60119f03220a3 - + https://github.com/dotnet/xharness - 9794254fa909ff5adc46326e9b54009793f61dcd + f20e52f7731da99588dd6b4f4bd60119f03220a3 - + https://github.com/dotnet/arcade - 60ae233c3d77f11c5fdb53e570b64d503b13ba59 + 34138f08e2c9c3c41a0ac8af583a57ea953e3821 - + https://dev.azure.com/dnceng/internal/_git/dotnet-optimization - 1b39aa819a38d504f7f828c28ff173acca7f99e2 + 8674aaa459d33551d419fece377f5512a1d93689 - + https://dev.azure.com/dnceng/internal/_git/dotnet-optimization - 1b39aa819a38d504f7f828c28ff173acca7f99e2 + 8674aaa459d33551d419fece377f5512a1d93689 - + https://dev.azure.com/dnceng/internal/_git/dotnet-optimization - 1b39aa819a38d504f7f828c28ff173acca7f99e2 + 8674aaa459d33551d419fece377f5512a1d93689 - + https://dev.azure.com/dnceng/internal/_git/dotnet-optimization - 1b39aa819a38d504f7f828c28ff173acca7f99e2 + 8674aaa459d33551d419fece377f5512a1d93689 - + https://github.com/dotnet/hotreload-utils - b97425c36aae0f46a22f2893309771383bfa9b30 + 2bf22c4e7b7036e87d29d2f2d76e99ddf57dab52 - + https://github.com/dotnet/runtime-assets - 3ed40d4f2335532ee7b04f8449468c52b4e2a643 + 928df39794e0f6677b50d6d8f690c52880c58d13 - + https://github.com/dotnet/roslyn - c098e96e5470fccc9c8e9f32189f408d086c984e + 08a167c19e5e04742b0922bdb1ea8046e9364f4b - + https://github.com/dotnet/roslyn - c098e96e5470fccc9c8e9f32189f408d086c984e + 08a167c19e5e04742b0922bdb1ea8046e9364f4b - + https://github.com/dotnet/roslyn - c098e96e5470fccc9c8e9f32189f408d086c984e + 08a167c19e5e04742b0922bdb1ea8046e9364f4b https://github.com/dotnet/roslyn-analyzers @@ -377,28 +373,28 @@ 3211f48253bc18560156d90dc5e710d35f7d03fa - + https://github.com/dotnet/roslyn - c098e96e5470fccc9c8e9f32189f408d086c984e + 08a167c19e5e04742b0922bdb1ea8046e9364f4b - + https://github.com/dotnet/sdk - e028762ceb5ccaa05a8c93c29ce5bbcae926533a + 8d10b56a313f40d3575133805ce4cff8f41e0ac6 - + https://github.com/dotnet/sdk - e028762ceb5ccaa05a8c93c29ce5bbcae926533a + 8d10b56a313f40d3575133805ce4cff8f41e0ac6 - + https://dev.azure.com/dnceng/internal/_git/dotnet-optimization - 1b39aa819a38d504f7f828c28ff173acca7f99e2 + 8674aaa459d33551d419fece377f5512a1d93689 - + https://dev.azure.com/dnceng/internal/_git/dotnet-optimization - 1b39aa819a38d504f7f828c28ff173acca7f99e2 + 8674aaa459d33551d419fece377f5512a1d93689 diff --git a/eng/Versions.props b/eng/Versions.props index 2aa1a4fa295..dfa31e0d2e1 100644 --- a/eng/Versions.props +++ b/eng/Versions.props @@ -1,16 +1,16 @@ - 9.0.0 + 10.0.0 - 9 + 10 0 0 9.0.100 - 8.0.7 + 8.0.8 7.0.20 6.0.$([MSBuild]::Add($([System.Version]::Parse('$(PackageVersionNet8)').Build),25)) - rc + alpha 1 false @@ -19,7 +19,8 @@ $(SdkBandVersion)$(WorkloadVersionSuffix) - $(MajorVersion).$(MinorVersion).0.0 + + 9.0.0.0 false false @@ -42,9 +43,9 @@ Any tools that contribute to the design-time experience should use the MicrosoftCodeAnalysisVersion_LatestVS property above to ensure they do not break the local dev experience. --> - 4.12.0-2.24408.4 - 4.12.0-2.24408.4 - 4.12.0-2.24408.4 + 4.12.0-2.24421.9 + 4.12.0-2.24421.9 + 4.12.0-2.24421.9 - 9.0.100-rc.1.24378.3 + 10.0.100-alpha.2.24459.4 - 9.0.0-beta.24408.2 - 9.0.0-beta.24408.2 - 9.0.0-beta.24408.2 - 9.0.0-beta.24408.2 - 2.9.0-beta.24408.2 - 9.0.0-beta.24408.2 - 2.9.0-beta.24408.2 - 9.0.0-beta.24408.2 - 9.0.0-beta.24408.2 - 9.0.0-beta.24408.2 - 9.0.0-beta.24408.2 - 9.0.0-beta.24408.2 - 9.0.0-beta.24408.2 - 9.0.0-beta.24408.2 - 9.0.0-beta.24408.2 - 9.0.0-beta.24408.2 + 10.0.0-beta.24467.1 + 10.0.0-beta.24467.1 + 10.0.0-beta.24467.1 + 10.0.0-beta.24467.1 + 2.9.0-beta.24467.1 + 10.0.0-beta.24467.1 + 2.9.0-beta.24467.1 + 10.0.0-beta.24467.1 + 10.0.0-beta.24467.1 + 10.0.0-beta.24467.1 + 10.0.0-beta.24467.1 + 10.0.0-beta.24467.1 + 10.0.0-beta.24467.1 + 10.0.0-beta.24467.1 + 10.0.0-beta.24467.1 + 10.0.0-beta.24467.1 1.4.0 6.0.0-preview.1.102 - 9.0.0-rc.1.24403.1 + 9.0.0-rc.1.24410.5 6.0.0 - 9.0.0-rc.1.24403.1 + 9.0.0-rc.1.24410.5 6.0.0 1.1.1 @@ -119,52 +120,50 @@ 8.0.0 5.0.0 4.5.5 - 9.0.0-rc.1.24403.1 - 9.0.0-rc.1.24403.1 + 9.0.0-rc.1.24410.5 + 9.0.0-rc.1.24410.5 6.0.0 5.0.0 5.0.0 5.0.0 7.0.0 - 9.0.0-rc.1.24403.1 + 9.0.0-rc.1.24410.5 6.0.0 7.0.0 4.5.4 4.5.0 - 9.0.0-rc.1.24403.1 + 9.0.0-rc.1.24410.5 8.0.0 8.0.0 8.0.0 8.0.0 - 9.0.0-beta.24407.1 - 9.0.0-beta.24407.1 - 9.0.0-beta.24407.1 - 9.0.0-beta.24407.1 - 9.0.0-beta.24407.1 - 9.0.0-beta.24407.1 - 9.0.0-beta.24407.1 - 9.0.0-beta.24407.1 - 9.0.0-beta.24407.1 - 9.0.0-beta.24407.1 - 9.0.0-beta.24407.1 - 9.0.0-beta.24407.1 - 9.0.0-beta.24407.1 - 9.0.0-beta.24407.1 + 10.0.0-beta.24459.1 + 10.0.0-beta.24459.1 + 10.0.0-beta.24459.1 + 10.0.0-beta.24459.1 + 10.0.0-beta.24459.1 + 10.0.0-beta.24459.1 + 10.0.0-beta.24459.1 + 10.0.0-beta.24459.1 + 10.0.0-beta.24459.1 + 10.0.0-beta.24459.1 + 10.0.0-beta.24459.1 + 10.0.0-beta.24459.1 + 10.0.0-beta.24459.1 + 10.0.0-beta.24459.1 - 1.0.0-prerelease.24376.4 - 1.0.0-prerelease.24376.4 - 1.0.0-prerelease.24376.4 - 1.0.0-prerelease.24376.4 - 1.0.0-prerelease.24376.4 - 1.0.0-prerelease.24376.4 + 1.0.0-prerelease.24409.2 + 1.0.0-prerelease.24409.2 + 1.0.0-prerelease.24409.2 + 1.0.0-prerelease.24409.2 + 1.0.0-prerelease.24409.2 + 1.0.0-prerelease.24409.2 2.0.0 17.10.0-beta1.24272.1 2.0.0-beta4.24324.3 - - 9.0.0-preview.7.24327.2 3.1.7 2.1.0 2.0.3 @@ -181,10 +180,10 @@ 1.4.0 17.4.0-preview-20220707-01 - 9.0.0-prerelease.24405.1 - 9.0.0-prerelease.24405.1 - 9.0.0-prerelease.24405.1 - 9.0.0-alpha.0.24405.1 + 10.0.0-prerelease.24466.1 + 10.0.0-prerelease.24466.1 + 10.0.0-prerelease.24466.1 + 9.0.0-alpha.0.24419.1 3.12.0 4.5.0 6.0.0 @@ -212,52 +211,51 @@ 8.0.0-preview-20230918.1 - 0.11.5-alpha.24379.1 - - 9.0.0-rc.1.24403.1 + 0.11.5-alpha.24460.1 - 9.0.0-rc.1.24373.1 + 10.0.0-alpha.1.24459.2 - 2.3.6 + 2.4.3 9.0.0-alpha.1.24167.3 - 19.0.0-alpha.1.24370.2 - 19.0.0-alpha.1.24370.2 - 19.0.0-alpha.1.24370.2 - 19.0.0-alpha.1.24370.2 - 19.0.0-alpha.1.24370.2 - 19.0.0-alpha.1.24370.2 - 19.0.0-alpha.1.24370.2 - 19.0.0-alpha.1.24370.2 - 19.0.0-alpha.1.24370.2 - 19.0.0-alpha.1.24370.2 - 19.0.0-alpha.1.24370.2 - 19.0.0-alpha.1.24370.2 - 19.0.0-alpha.1.24370.2 - 19.0.0-alpha.1.24370.2 + 19.0.0-alpha.1.24401.1 + 19.0.0-alpha.1.24401.1 + 19.0.0-alpha.1.24401.1 + 19.0.0-alpha.1.24401.1 + 19.0.0-alpha.1.24401.1 + 19.0.0-alpha.1.24401.1 + 19.0.0-alpha.1.24401.1 + 19.0.0-alpha.1.24401.1 + 19.0.0-alpha.1.24401.1 + 19.0.0-alpha.1.24401.1 + 19.0.0-alpha.1.24401.1 + 19.0.0-alpha.1.24401.1 + 19.0.0-alpha.1.24401.1 + 19.0.0-alpha.1.24401.1 - 9.0.0-rc.1.24402.2 + 10.0.0-alpha.1.24461.1 $(MicrosoftNETWorkloadEmscriptenCurrentManifest90100TransportVersion) 1.1.87-gba258badda 1.0.0-v3.14.0.5722 - 19.0.0-alpha.1.24370.2 - 19.0.0-alpha.1.24370.2 - 19.0.0-alpha.1.24370.2 - 19.0.0-alpha.1.24370.2 - 19.0.0-alpha.1.24370.2 - 19.0.0-alpha.1.24370.2 - 19.0.0-alpha.1.24370.2 - 19.0.0-alpha.1.24370.2 + 19.0.0-alpha.1.24401.1 + 19.0.0-alpha.1.24401.1 + 19.0.0-alpha.1.24401.1 + 19.0.0-alpha.1.24401.1 + 19.0.0-alpha.1.24401.1 + 19.0.0-alpha.1.24401.1 + 19.0.0-alpha.1.24401.1 + 19.0.0-alpha.1.24401.1 3.1.7 1.0.406601 - $(MicrosoftDotNetApiCompatTaskVersion) + + 9.0.100-rc.1.24452.12 9.0.0-alpha.1.24175.1 $(MicrosoftNETRuntimeEmscriptenVersion) $(runtimewinx64MicrosoftNETCoreRuntimeWasmNodeTransportPackageVersion) diff --git a/eng/build.ps1 b/eng/build.ps1 index 4a31c90180b..2356e83f95b 100644 --- a/eng/build.ps1 +++ b/eng/build.ps1 @@ -329,7 +329,7 @@ foreach ($argument in $PSBoundParameters.Keys) } if ($env:TreatWarningsAsErrors -eq 'false') { - $arguments += " -warnAsError 0" + $arguments += " -warnAsError `$false" } # disable terminal logger for now: https://github.com/dotnet/runtime/issues/97211 diff --git a/eng/build.sh b/eng/build.sh index df632614667..99c9228a1fa 100755 --- a/eng/build.sh +++ b/eng/build.sh @@ -550,7 +550,7 @@ if [[ "$os" == "wasi" ]]; then fi if [[ "${TreatWarningsAsErrors:-}" == "false" ]]; then - arguments="$arguments -warnAsError 0" + arguments="$arguments -warnAsError false" fi # disable terminal logger for now: https://github.com/dotnet/runtime/issues/97211 diff --git a/eng/common/SetupNugetSources.ps1 b/eng/common/SetupNugetSources.ps1 index 2b0a5c9e665..5db4ad71ee2 100644 --- a/eng/common/SetupNugetSources.ps1 +++ b/eng/common/SetupNugetSources.ps1 @@ -157,7 +157,7 @@ if ($dotnet31Source -ne $null) { AddPackageSource -Sources $sources -SourceName "dotnet3.1-internal-transport" -SourceEndPoint "https://pkgs.dev.azure.com/dnceng/_packaging/dotnet3.1-internal-transport/nuget/v2" -Creds $creds -Username $userName -pwd $Password } -$dotnetVersions = @('5','6','7','8') +$dotnetVersions = @('5','6','7','8','9') foreach ($dotnetVersion in $dotnetVersions) { $feedPrefix = "dotnet" + $dotnetVersion; diff --git a/eng/common/SetupNugetSources.sh b/eng/common/SetupNugetSources.sh index b493479a1da..4604b61b032 100644 --- a/eng/common/SetupNugetSources.sh +++ b/eng/common/SetupNugetSources.sh @@ -99,7 +99,7 @@ if [ "$?" == "0" ]; then PackageSources+=('dotnet3.1-internal-transport') fi -DotNetVersions=('5' '6' '7' '8') +DotNetVersions=('5' '6' '7' '8' '9') for DotNetVersion in ${DotNetVersions[@]} ; do FeedPrefix="dotnet${DotNetVersion}"; diff --git a/eng/common/core-templates/job/job.yml b/eng/common/core-templates/job/job.yml index c732bee9f4a..ba53ebfbd51 100644 --- a/eng/common/core-templates/job/job.yml +++ b/eng/common/core-templates/job/job.yml @@ -33,11 +33,6 @@ parameters: artifactPublishSteps: [] runAsPublic: false -# Sbom related params - enableSbom: true - PackageVersion: 9.0.0 - BuildDropPath: '$(Build.SourcesDirectory)/artifacts' - # 1es specific parameters is1ESPipeline: '' diff --git a/eng/common/core-templates/job/source-index-stage1.yml b/eng/common/core-templates/job/source-index-stage1.yml index 205fb5b3a39..30530359a5d 100644 --- a/eng/common/core-templates/job/source-index-stage1.yml +++ b/eng/common/core-templates/job/source-index-stage1.yml @@ -1,8 +1,5 @@ parameters: runAsPublic: false - sourceIndexUploadPackageVersion: 2.0.0-20240522.1 - sourceIndexProcessBinlogPackageVersion: 1.0.1-20240522.1 - sourceIndexPackageSource: https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools/nuget/v3/index.json sourceIndexBuildCommand: powershell -NoLogo -NoProfile -ExecutionPolicy Bypass -Command "eng/common/build.ps1 -restore -build -binarylog -ci" preSteps: [] binlogPath: artifacts/log/Debug/Build.binlog @@ -16,12 +13,6 @@ jobs: dependsOn: ${{ parameters.dependsOn }} condition: ${{ parameters.condition }} variables: - - name: SourceIndexUploadPackageVersion - value: ${{ parameters.sourceIndexUploadPackageVersion }} - - name: SourceIndexProcessBinlogPackageVersion - value: ${{ parameters.sourceIndexProcessBinlogPackageVersion }} - - name: SourceIndexPackageSource - value: ${{ parameters.sourceIndexPackageSource }} - name: BinlogPath value: ${{ parameters.binlogPath }} - template: /eng/common/core-templates/variables/pool-providers.yml @@ -34,12 +25,10 @@ jobs: pool: ${{ if eq(variables['System.TeamProject'], 'public') }}: name: $(DncEngPublicBuildPool) - image: 1es-windows-2022-open - os: windows + image: windows.vs2022.amd64.open ${{ if eq(variables['System.TeamProject'], 'internal') }}: name: $(DncEngInternalBuildPool) - image: 1es-windows-2022 - os: windows + image: windows.vs2022.amd64 steps: - ${{ if eq(parameters.is1ESPipeline, '') }}: @@ -47,35 +36,9 @@ jobs: - ${{ each preStep in parameters.preSteps }}: - ${{ preStep }} - - - task: UseDotNet@2 - displayName: Use .NET 8 SDK - inputs: - packageType: sdk - version: 8.0.x - installationPath: $(Agent.TempDirectory)/dotnet - workingDirectory: $(Agent.TempDirectory) - - - script: | - $(Agent.TempDirectory)/dotnet/dotnet tool install BinLogToSln --version $(sourceIndexProcessBinlogPackageVersion) --add-source $(SourceIndexPackageSource) --tool-path $(Agent.TempDirectory)/.source-index/tools - $(Agent.TempDirectory)/dotnet/dotnet tool install UploadIndexStage1 --version $(sourceIndexUploadPackageVersion) --add-source $(SourceIndexPackageSource) --tool-path $(Agent.TempDirectory)/.source-index/tools - displayName: Download Tools - # Set working directory to temp directory so 'dotnet' doesn't try to use global.json and use the repo's sdk. - workingDirectory: $(Agent.TempDirectory) - - script: ${{ parameters.sourceIndexBuildCommand }} displayName: Build Repository - - script: $(Agent.TempDirectory)/.source-index/tools/BinLogToSln -i $(BinlogPath) -r $(Build.SourcesDirectory) -n $(Build.Repository.Name) -o .source-index/stage1output - displayName: Process Binlog into indexable sln - - - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}: - - task: AzureCLI@2 - displayName: Log in to Azure and upload stage1 artifacts to source index - inputs: - azureSubscription: 'SourceDotNet Stage1 Publish' - addSpnToEnvironment: true - scriptType: 'ps' - scriptLocation: 'inlineScript' - inlineScript: | - $(Agent.TempDirectory)/.source-index/tools/UploadIndexStage1 -i .source-index/stage1output -n $(Build.Repository.Name) -s netsourceindexstage1 -b stage1 + - template: /eng/common/core-templates/steps/source-index-stage1-publish.yml + parameters: + binLogPath: ${{ parameters.binLogPath }} \ No newline at end of file diff --git a/eng/common/core-templates/steps/publish-logs.yml b/eng/common/core-templates/steps/publish-logs.yml index 80788c52319..de24d0087c5 100644 --- a/eng/common/core-templates/steps/publish-logs.yml +++ b/eng/common/core-templates/steps/publish-logs.yml @@ -34,7 +34,9 @@ steps: '$(akams-client-id)' '$(microsoft-symbol-server-pat)' '$(symweb-symbol-server-pat)' + '$(dnceng-symbol-server-pat)' '$(dn-bot-all-orgs-build-rw-code-rw)' + '$(System.AccessToken)' ${{parameters.CustomSensitiveDataList}} continueOnError: true condition: always() @@ -45,6 +47,7 @@ steps: SourceFolder: '$(Build.SourcesDirectory)/PostBuildLogs' Contents: '**' TargetFolder: '$(Build.ArtifactStagingDirectory)/PostBuildLogs' + condition: always() - template: /eng/common/core-templates/steps/publish-build-artifacts.yml parameters: diff --git a/eng/common/core-templates/steps/source-index-stage1-publish.yml b/eng/common/core-templates/steps/source-index-stage1-publish.yml new file mode 100644 index 00000000000..473a22c4719 --- /dev/null +++ b/eng/common/core-templates/steps/source-index-stage1-publish.yml @@ -0,0 +1,35 @@ +parameters: + sourceIndexUploadPackageVersion: 2.0.0-20240522.1 + sourceIndexProcessBinlogPackageVersion: 1.0.1-20240522.1 + sourceIndexPackageSource: https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-tools/nuget/v3/index.json + binlogPath: artifacts/log/Debug/Build.binlog + +steps: +- task: UseDotNet@2 + displayName: "Source Index: Use .NET 8 SDK" + inputs: + packageType: sdk + version: 8.0.x + installationPath: $(Agent.TempDirectory)/dotnet + workingDirectory: $(Agent.TempDirectory) + +- script: | + $(Agent.TempDirectory)/dotnet/dotnet tool install BinLogToSln --version ${{parameters.sourceIndexProcessBinlogPackageVersion}} --add-source ${{parameters.SourceIndexPackageSource}} --tool-path $(Agent.TempDirectory)/.source-index/tools + $(Agent.TempDirectory)/dotnet/dotnet tool install UploadIndexStage1 --version ${{parameters.sourceIndexUploadPackageVersion}} --add-source ${{parameters.SourceIndexPackageSource}} --tool-path $(Agent.TempDirectory)/.source-index/tools + displayName: "Source Index: Download netsourceindex Tools" + # Set working directory to temp directory so 'dotnet' doesn't try to use global.json and use the repo's sdk. + workingDirectory: $(Agent.TempDirectory) + +- script: $(Agent.TempDirectory)/.source-index/tools/BinLogToSln -i ${{parameters.BinlogPath}} -r $(Build.SourcesDirectory) -n $(Build.Repository.Name) -o .source-index/stage1output + displayName: "Source Index: Process Binlog into indexable sln" + +- ${{ if and(ne(parameters.runAsPublic, 'true'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}: + - task: AzureCLI@2 + displayName: "Source Index: Upload Source Index stage1 artifacts to Azure" + inputs: + azureSubscription: 'SourceDotNet Stage1 Publish' + addSpnToEnvironment: true + scriptType: 'ps' + scriptLocation: 'inlineScript' + inlineScript: | + $(Agent.TempDirectory)/.source-index/tools/UploadIndexStage1 -i .source-index/stage1output -n $(Build.Repository.Name) -s netsourceindexstage1 -b stage1 diff --git a/eng/common/internal/Tools.csproj b/eng/common/internal/Tools.csproj index e925952d566..32f79dfb340 100644 --- a/eng/common/internal/Tools.csproj +++ b/eng/common/internal/Tools.csproj @@ -4,6 +4,7 @@ net472 false + false diff --git a/eng/common/template-guidance.md b/eng/common/template-guidance.md index 5ef6c30ba92..98bbc1ded0b 100644 --- a/eng/common/template-guidance.md +++ b/eng/common/template-guidance.md @@ -57,7 +57,7 @@ extends: Note: Multiple outputs are ONLY applicable to 1ES PT publishing (only usable when referencing `templates-official`). -# Development notes +## Development notes **Folder / file structure** diff --git a/eng/common/templates-official/job/job.yml b/eng/common/templates-official/job/job.yml index 0c2928d5c79..3d16b41c78c 100644 --- a/eng/common/templates-official/job/job.yml +++ b/eng/common/templates-official/job/job.yml @@ -1,8 +1,22 @@ +parameters: +# Sbom related params + enableSbom: true + PackageVersion: 9.0.0 + BuildDropPath: '$(Build.SourcesDirectory)/artifacts' + jobs: - template: /eng/common/core-templates/job/job.yml parameters: is1ESPipeline: true + componentGovernanceSteps: + - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest'), eq(parameters.enableSbom, 'true')) }}: + - template: /eng/common/templates/steps/generate-sbom.yml + parameters: + PackageVersion: ${{ parameters.packageVersion }} + BuildDropPath: ${{ parameters.buildDropPath }} + publishArtifacts: false + # publish artifacts # for 1ES managed templates, use the templateContext.output to handle multiple outputs. templateContext: diff --git a/eng/common/templates-official/steps/source-index-stage1-publish.yml b/eng/common/templates-official/steps/source-index-stage1-publish.yml new file mode 100644 index 00000000000..9b8b80942b5 --- /dev/null +++ b/eng/common/templates-official/steps/source-index-stage1-publish.yml @@ -0,0 +1,7 @@ +steps: +- template: /eng/common/core-templates/steps/source-index-stage1-publish.yml + parameters: + is1ESPipeline: true + + ${{ each parameter in parameters }}: + ${{ parameter.key }}: ${{ parameter.value }} diff --git a/eng/common/templates/job/job.yml b/eng/common/templates/job/job.yml index 8da477dd69f..07d317bf8f9 100644 --- a/eng/common/templates/job/job.yml +++ b/eng/common/templates/job/job.yml @@ -19,71 +19,63 @@ jobs: steps: - ${{ each step in parameters.steps }}: - ${{ step }} - + componentGovernanceSteps: - - template: /eng/common/templates/steps/component-governance.yml - parameters: - ${{ if eq(parameters.disableComponentGovernance, '') }}: - ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest'), eq(parameters.runAsPublic, 'false'), or(startsWith(variables['Build.SourceBranch'], 'refs/heads/release/'), startsWith(variables['Build.SourceBranch'], 'refs/heads/dotnet/'), startsWith(variables['Build.SourceBranch'], 'refs/heads/microsoft/'), eq(variables['Build.SourceBranch'], 'refs/heads/main'))) }}: - disableComponentGovernance: false - ${{ else }}: - disableComponentGovernance: true + - template: /eng/common/templates/steps/component-governance.yml + parameters: + ${{ if eq(parameters.disableComponentGovernance, '') }}: + ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest'), eq(parameters.runAsPublic, 'false'), or(startsWith(variables['Build.SourceBranch'], 'refs/heads/release/'), startsWith(variables['Build.SourceBranch'], 'refs/heads/dotnet/'), startsWith(variables['Build.SourceBranch'], 'refs/heads/microsoft/'), eq(variables['Build.SourceBranch'], 'refs/heads/main'))) }}: + disableComponentGovernance: false ${{ else }}: - disableComponentGovernance: ${{ parameters.disableComponentGovernance }} - componentGovernanceIgnoreDirectories: ${{ parameters.componentGovernanceIgnoreDirectories }} - - - ${{ if and(eq(parameters.runAsPublic, 'false'), ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest'), eq(parameters.enableSbom, 'true')) }}: - - template: /eng/common/templates/steps/generate-sbom.yml - parameters: - PackageVersion: ${{ parameters.packageVersion }} - BuildDropPath: ${{ parameters.buildDropPath }} - publishArtifacts: false - + disableComponentGovernance: true + ${{ else }}: + disableComponentGovernance: ${{ parameters.disableComponentGovernance }} + componentGovernanceIgnoreDirectories: ${{ parameters.componentGovernanceIgnoreDirectories }} artifactPublishSteps: - - ${{ if ne(parameters.artifacts.publish, '') }}: - - ${{ if and(ne(parameters.artifacts.publish.artifacts, 'false'), ne(parameters.artifacts.publish.artifacts, '')) }}: - - template: /eng/common/core-templates/steps/publish-build-artifacts.yml - parameters: - is1ESPipeline: false - args: - displayName: Publish pipeline artifacts - pathToPublish: '$(Build.ArtifactStagingDirectory)/artifacts' - publishLocation: Container - artifactName: ${{ coalesce(parameters.artifacts.publish.artifacts.name , 'Artifacts_$(Agent.Os)_$(_BuildConfig)') }} - continueOnError: true - condition: always() - - ${{ if and(ne(parameters.artifacts.publish.logs, 'false'), ne(parameters.artifacts.publish.logs, '')) }}: - - template: /eng/common/core-templates/steps/publish-pipeline-artifacts.yml - parameters: - is1ESPipeline: false - args: - targetPath: '$(Build.ArtifactStagingDirectory)/artifacts/log' - artifactName: ${{ coalesce(parameters.artifacts.publish.logs.name, 'Logs_Build_$(Agent.Os)_$(_BuildConfig)') }} - displayName: 'Publish logs' - continueOnError: true - condition: always() - sbomEnabled: false # we don't need SBOM for logs - - - ${{ if ne(parameters.enablePublishBuildArtifacts, 'false') }}: + - ${{ if ne(parameters.artifacts.publish, '') }}: + - ${{ if and(ne(parameters.artifacts.publish.artifacts, 'false'), ne(parameters.artifacts.publish.artifacts, '')) }}: - template: /eng/common/core-templates/steps/publish-build-artifacts.yml parameters: is1ESPipeline: false args: - displayName: Publish Logs - pathToPublish: '$(Build.ArtifactStagingDirectory)/artifacts/log/$(_BuildConfig)' + displayName: Publish pipeline artifacts + pathToPublish: '$(Build.ArtifactStagingDirectory)/artifacts' publishLocation: Container - artifactName: ${{ coalesce(parameters.enablePublishBuildArtifacts.artifactName, '$(Agent.Os)_$(Agent.JobName)' ) }} + artifactName: ${{ coalesce(parameters.artifacts.publish.artifacts.name , 'Artifacts_$(Agent.Os)_$(_BuildConfig)') }} continueOnError: true condition: always() - - - ${{ if eq(parameters.enableBuildRetry, 'true') }}: + - ${{ if and(ne(parameters.artifacts.publish.logs, 'false'), ne(parameters.artifacts.publish.logs, '')) }}: - template: /eng/common/core-templates/steps/publish-pipeline-artifacts.yml parameters: is1ESPipeline: false args: - targetPath: '$(Build.SourcesDirectory)\eng\common\BuildConfiguration' - artifactName: 'BuildConfiguration' - displayName: 'Publish build retry configuration' + targetPath: '$(Build.ArtifactStagingDirectory)/artifacts/log' + artifactName: ${{ coalesce(parameters.artifacts.publish.logs.name, 'Logs_Build_$(Agent.Os)_$(_BuildConfig)') }} + displayName: 'Publish logs' continueOnError: true - sbomEnabled: false # we don't need SBOM for BuildConfiguration + condition: always() + sbomEnabled: false # we don't need SBOM for logs + + - ${{ if ne(parameters.enablePublishBuildArtifacts, 'false') }}: + - template: /eng/common/core-templates/steps/publish-build-artifacts.yml + parameters: + is1ESPipeline: false + args: + displayName: Publish Logs + pathToPublish: '$(Build.ArtifactStagingDirectory)/artifacts/log/$(_BuildConfig)' + publishLocation: Container + artifactName: ${{ coalesce(parameters.enablePublishBuildArtifacts.artifactName, '$(Agent.Os)_$(Agent.JobName)' ) }} + continueOnError: true + condition: always() + + - ${{ if eq(parameters.enableBuildRetry, 'true') }}: + - template: /eng/common/core-templates/steps/publish-pipeline-artifacts.yml + parameters: + is1ESPipeline: false + args: + targetPath: '$(Build.SourcesDirectory)\eng\common\BuildConfiguration' + artifactName: 'BuildConfiguration' + displayName: 'Publish build retry configuration' + continueOnError: true + sbomEnabled: false # we don't need SBOM for BuildConfiguration diff --git a/eng/common/templates/steps/source-index-stage1-publish.yml b/eng/common/templates/steps/source-index-stage1-publish.yml new file mode 100644 index 00000000000..182cec33a7b --- /dev/null +++ b/eng/common/templates/steps/source-index-stage1-publish.yml @@ -0,0 +1,7 @@ +steps: +- template: /eng/common/core-templates/steps/source-index-stage1-publish.yml + parameters: + is1ESPipeline: false + + ${{ each parameter in parameters }}: + ${{ parameter.key }}: ${{ parameter.value }} diff --git a/eng/generators.targets b/eng/generators.targets index b5ca3ca89ee..b5c8b54a107 100644 --- a/eng/generators.targets +++ b/eng/generators.targets @@ -1,19 +1,10 @@ - - - true - - - - + + + + + + '$(MSBuildProjectExtension)' == '.csproj' and + ( + '$(DisableImplicitFrameworkReferences)' == 'true' and + '@(Reference->AnyHaveMetadataValue('Identity', 'System.Runtime.InteropServices'))' == 'true' + )" /> + @(EnabledGenerators->AnyHaveMetadataValue('Identity', 'DownlevelLibraryImportGenerator'))"> @@ -57,6 +55,11 @@ ReferenceOutputAssembly="false" OutputItemType="Analyzer" SetConfiguration="Configuration=$(LibrariesConfiguration)" /> + + DependsOnTargets="GetTargetPathWithTargetPlatformMoniker" + BeforeTargets="GetTargetPath"> diff --git a/eng/install-native-dependencies.sh b/eng/install-native-dependencies.sh index 41895e0b925..57ab7848f8e 100755 --- a/eng/install-native-dependencies.sh +++ b/eng/install-native-dependencies.sh @@ -23,14 +23,14 @@ case "$os" in if [ "$ID" = "debian" ] || [ "$ID_LIKE" = "debian" ]; then apt update - apt install -y build-essential gettext locales cmake llvm clang lldb liblldb-dev libunwind8-dev libicu-dev liblttng-ust-dev \ + apt install -y build-essential gettext locales cmake llvm clang lld lldb liblldb-dev libunwind8-dev libicu-dev liblttng-ust-dev \ libssl-dev libkrb5-dev zlib1g-dev localedef -i en_US -c -f UTF-8 -A /usr/share/locale/locale.alias en_US.UTF-8 elif [ "$ID" = "fedora" ]; then dnf install -y cmake llvm lld lldb clang python curl libicu-devel openssl-devel krb5-devel zlib-devel lttng-ust-devel elif [ "$ID" = "alpine" ]; then - apk add build-base cmake bash curl clang llvm-dev krb5-dev lttng-ust-dev icu-dev zlib-dev openssl-dev + apk add build-base cmake bash curl clang llvm-dev lld lldb krb5-dev lttng-ust-dev icu-dev zlib-dev openssl-dev else echo "Unsupported distro. distro: $ID" exit 1 diff --git a/eng/intellisense.targets b/eng/intellisense.targets index 7e1cb0054d3..53614511d96 100644 --- a/eng/intellisense.targets +++ b/eng/intellisense.targets @@ -11,7 +11,7 @@ $(IntellisensePackageXmlFilePathFromNetFolder) $(IntellisensePackageXmlFilePathFromDotNetPlatExtFolder) - $(IntermediateOutputPath)$(TargetName).intellisense-package.xml + $([MSBuild]::NormalizePath('$(IntermediateOutputPath)', 'intellisense-package', '$(TargetName).xml')) $(NoWarn);CS1591 @@ -66,8 +66,8 @@ + DependsOnTargets="ChangeDocumentationFileForPackaging;GetTargetPathWithTargetPlatformMoniker" + BeforeTargets="GetTargetPath"> diff --git a/eng/liveBuilds.targets b/eng/liveBuilds.targets index cb216d6c3ad..3446081a627 100644 --- a/eng/liveBuilds.targets +++ b/eng/liveBuilds.targets @@ -64,6 +64,15 @@ $([MSBuild]::NormalizePath('$(CoreCLRArtifactsPath)', 'corehost', 'singlefilehost$(ExeSuffix)')) + + + true + + + + + + diff --git a/eng/native/configurecompiler.cmake b/eng/native/configurecompiler.cmake index d6ab391eb62..ffc3abd2871 100644 --- a/eng/native/configurecompiler.cmake +++ b/eng/native/configurecompiler.cmake @@ -304,7 +304,7 @@ elseif(CLR_CMAKE_HOST_SUNOS) add_compile_options($<$:-Wa,--noexecstack>) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fstack-protector") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-protector") - add_definitions(-D__EXTENSIONS__ -D_XPG4_2 -D_POSIX_PTHREAD_SEMANTICS) + add_definitions(-D__EXTENSIONS__ -D_XPG4_2 -D_POSIX_PTHREAD_SEMANTICS -D_REENTRANT) elseif(CLR_CMAKE_HOST_OSX AND NOT CLR_CMAKE_HOST_MACCATALYST AND NOT CLR_CMAKE_HOST_IOS AND NOT CLR_CMAKE_HOST_TVOS) add_definitions(-D_XOPEN_SOURCE) diff --git a/eng/packaging.targets b/eng/packaging.targets index 207821cf95c..99912459fe0 100644 --- a/eng/packaging.targets +++ b/eng/packaging.targets @@ -22,6 +22,7 @@ $(MSBuildThisFileDirectory)useSharedDesignerContext.txt + true PACKAGE.md PACKAGE.md $(BeforePack);ValidatePackageReadmeExists @@ -202,6 +203,21 @@ + + + + + diff --git a/eng/pipelines/common/global-build-job.yml b/eng/pipelines/common/global-build-job.yml index b068861190c..e370a42f47d 100644 --- a/eng/pipelines/common/global-build-job.yml +++ b/eng/pipelines/common/global-build-job.yml @@ -35,6 +35,7 @@ parameters: preBuildSteps: [] templatePath: 'templates' templateContext: '' + disableComponentGovernance: '' jobs: - template: /eng/common/${{ parameters.templatePath }}/job/job.yml diff --git a/eng/pipelines/common/perf-variables.yml b/eng/pipelines/common/perf-variables.yml deleted file mode 100644 index 9b14ab5067a..00000000000 --- a/eng/pipelines/common/perf-variables.yml +++ /dev/null @@ -1,16 +0,0 @@ -variables: - - name: _wasmCollectHelixLogsScript - value: >- - test -d "$HELIX_WORKITEM_UPLOAD_ROOT" && ( - export _PERF_DIR=$HELIX_WORKITEM_ROOT/performance; - mkdir -p $HELIX_WORKITEM_UPLOAD_ROOT/log; - find $_PERF_DIR -name '*.binlog' | xargs -I{} cp {} $HELIX_WORKITEM_UPLOAD_ROOT/log; - test "$_commandExitCode" -eq 0 || ( - mkdir -p $HELIX_WORKITEM_UPLOAD_ROOT/log/MicroBenchmarks/obj; - mkdir -p $HELIX_WORKITEM_UPLOAD_ROOT/log/MicroBenchmarks/bin; - mkdir -p $HELIX_WORKITEM_UPLOAD_ROOT/log/BenchmarkDotNet.Autogenerated/obj; - mkdir -p $HELIX_WORKITEM_UPLOAD_ROOT/log/for-running; - cp -R $_PERF_DIR/artifacts/obj/MicroBenchmarks $HELIX_WORKITEM_UPLOAD_ROOT/log/MicroBenchmarks/obj; - cp -R $_PERF_DIR/artifacts/bin/MicroBenchmarks $HELIX_WORKITEM_UPLOAD_ROOT/log/MicroBenchmarks/bin; - cp -R $_PERF_DIR/artifacts/obj/BenchmarkDotNet.Autogenerated $HELIX_WORKITEM_UPLOAD_ROOT/log/BenchmarkDotNet.Autogenerated/obj; - cp -R $_PERF_DIR/artifacts/bin/for-running $HELIX_WORKITEM_UPLOAD_ROOT/log/for-running)) diff --git a/eng/pipelines/common/templates/pipeline-with-resources.yml b/eng/pipelines/common/templates/pipeline-with-resources.yml index cf2b9f53e52..90851b8d725 100644 --- a/eng/pipelines/common/templates/pipeline-with-resources.yml +++ b/eng/pipelines/common/templates/pipeline-with-resources.yml @@ -17,7 +17,7 @@ extends: containers: linux_arm: - image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-cross-arm-net9.0 + image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-arm env: ROOTFS_DIR: /crossrootfs/arm @@ -27,44 +27,44 @@ extends: ROOTFS_DIR: /crossrootfs/armv6 linux_arm64: - image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-cross-arm64-net9.0 + image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-arm64 env: ROOTFS_DIR: /crossrootfs/arm64 linux_musl_x64: - image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-cross-amd64-alpine-net9.0 + image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-amd64-alpine env: ROOTFS_DIR: /crossrootfs/x64 linux_musl_arm: - image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-cross-arm-alpine-net9.0 + image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-arm-alpine env: ROOTFS_DIR: /crossrootfs/arm linux_musl_arm64: - image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-cross-arm64-alpine-net9.0 + image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-arm64-alpine env: ROOTFS_DIR: /crossrootfs/arm64 # This container contains all required toolsets to build for Android and for Linux with bionic libc. android: - image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-cross-android-amd64-net9.0 + image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-android-amd64 # This container contains all required toolsets to build for Android and for Linux with bionic libc and a special layout of OpenSSL. linux_bionic: - image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-android-openssl-net9.0 + image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-android-openssl # This container contains all required toolsets to build for Android as well as tooling to build docker images. android_docker: - image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-android-docker-net9.0 + image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-android-docker linux_x64: - image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-cross-amd64-net9.0 + image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-amd64 env: ROOTFS_DIR: /crossrootfs/x64 linux_x86: - image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-cross-x86-net9.0 + image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-x86 env: ROOTFS_DIR: /crossrootfs/x86 @@ -75,7 +75,7 @@ extends: image: mcr.microsoft.com/dotnet-buildtools/prereqs:alpine-3.19-WithNode linux_x64_sanitizer: - image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-cross-amd64-net9.0-sanitizer + image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-amd64-sanitizer env: ROOTFS_DIR: /crossrootfs/x64 @@ -88,17 +88,17 @@ extends: image: mcr.microsoft.com/dotnet-buildtools/prereqs:almalinux-8-source-build linux_s390x: - image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-cross-s390x-net9.0 + image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-s390x env: ROOTFS_DIR: /crossrootfs/s390x linux_ppc64le: - image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-cross-ppc64le-net9.0 + image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-ppc64le env: ROOTFS_DIR: /crossrootfs/ppc64le linux_riscv64: - image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-cross-riscv64-net9.0 + image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-riscv64 env: ROOTFS_DIR: /crossrootfs/riscv64 @@ -109,17 +109,17 @@ extends: image: mcr.microsoft.com/dotnet-buildtools/prereqs:centos-stream8 browser_wasm: - image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-webassembly-amd64-net9.0 + image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-webassembly-amd64 env: ROOTFS_DIR: /crossrootfs/x64 wasi_wasm: - image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-webassembly-amd64-net9.0 + image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-webassembly-amd64 env: ROOTFS_DIR: /crossrootfs/x64 freebsd_x64: - image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-cross-freebsd-13-net9.0 + image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-cross-freebsd-13 env: ROOTFS_DIR: /crossrootfs/x64 @@ -132,4 +132,4 @@ extends: image: mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-22.04-debpkg rpmpkg: - image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-fpm-net9.0 + image: mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-net9.0-fpm diff --git a/eng/pipelines/common/templates/runtimes/build-runtime-tests-and-send-to-helix.yml b/eng/pipelines/common/templates/runtimes/build-runtime-tests-and-send-to-helix.yml index b0a2043bbd5..2ac52ca77eb 100644 --- a/eng/pipelines/common/templates/runtimes/build-runtime-tests-and-send-to-helix.yml +++ b/eng/pipelines/common/templates/runtimes/build-runtime-tests-and-send-to-helix.yml @@ -19,6 +19,9 @@ parameters: variables: {} pool: '' dependsOn: [] + compileOnHelix: false + interpreter: false + buildAllTestsAsStandalone: false #arcade-specific parameters condition: always() continueOnError: false @@ -27,8 +30,6 @@ parameters: enableMicrobuild: '' gatherAssetManifests: false shouldContinueOnError: false - compileOnHelix: false - interpreter: false steps: - template: /eng/pipelines/common/templates/runtimes/build-runtime-tests.yml @@ -38,6 +39,7 @@ steps: archType: ${{ parameters.archType }} buildConfig: ${{ parameters.buildConfig }} testBuildArgs: ${{ parameters.testBuildArgs }} + buildAllTestsAsStandalone: ${{ parameters.buildAllTestsAsStandalone }} # Build a Mono AOT cross-compiler for non-amd64 targets (in this case, just arm64) - ${{ if and(eq(parameters.runtimeFlavor, 'mono'), in(parameters.runtimeVariant, 'llvmaot', 'llvmfullaot', 'minifullaot')) }}: - ${{ if eq(parameters.archType, 'arm64') }}: diff --git a/eng/pipelines/common/templates/runtimes/build-runtime-tests.yml b/eng/pipelines/common/templates/runtimes/build-runtime-tests.yml index f9ef84a49c1..a822ccf28fd 100644 --- a/eng/pipelines/common/templates/runtimes/build-runtime-tests.yml +++ b/eng/pipelines/common/templates/runtimes/build-runtime-tests.yml @@ -4,6 +4,7 @@ parameters: archType: '' buildConfig: '' testBuildArgs: '' + buildAllTestsAsStandalone: false #arcade-specific parameters condition: always() continueOnError: false @@ -18,6 +19,13 @@ steps: - ${{ if eq(parameters.osGroup, 'windows') }}: - script: $(Build.SourcesDirectory)/src/tests/build$(scriptExt) $(crossArg) ci ${{ parameters.archType }} $(buildConfigUpper) $(_nativeSanitizersArg) $(priorityArg) $(runtimeFlavorArgs) ${{ parameters.testBuildArgs }} $(runtimeVariantArg) $(librariesConfigurationArg) displayName: Build Tests + env: + ${{ if eq(parameters.buildAllTestsAsStandalone, true) }}: + BuildAllTestsAsStandalone: true + - ${{ if ne(parameters.osGroup, 'windows') }}: - script: $(Build.SourcesDirectory)/src/tests/build$(scriptExt) $(crossArg) ci os ${{ parameters.osGroup }} ${{ parameters.archType }} $(buildConfigUpper) $(_nativeSanitizersArg) $(priorityArg) $(runtimeFlavorArgs) ${{ parameters.testBuildArgs }} $(runtimeVariantArg) $(librariesConfigurationArg) displayName: Build Tests + env: + ${{ if eq(parameters.buildAllTestsAsStandalone, true) }}: + BuildAllTestsAsStandalone: true diff --git a/eng/pipelines/common/templates/runtimes/build-test-job.yml b/eng/pipelines/common/templates/runtimes/build-test-job.yml index bbc9f854801..4af04c54612 100644 --- a/eng/pipelines/common/templates/runtimes/build-test-job.yml +++ b/eng/pipelines/common/templates/runtimes/build-test-job.yml @@ -78,13 +78,13 @@ jobs: - name: runtimeFlavorArgs value: '-nativeaot' - - name: testTreeFilterArg + - name: testFilterArg value: '' # Only build GCSimulator tests when the gc-simulator group is specified. - ${{ if eq(parameters.testGroup, 'gc-simulator') }}: - - name: testTreeFilterArg - value: 'tree GC/Scenarios/GCSimulator' + - name: testFilterArg + value: 'test GC/Scenarios/GC-simulator.csproj' - template: /eng/pipelines/common/templates/runtimes/native-test-assets-variables.yml parameters: @@ -110,7 +110,7 @@ jobs: displayName: Disk Usage before Build # Build managed test components - - script: $(Build.SourcesDirectory)/src/tests/build$(scriptExt) $(logRootNameArg)Managed allTargets skipnative skipgeneratelayout skiptestwrappers $(buildConfig) $(archType) $(runtimeFlavorArgs) $(crossArg) $(priorityArg) $(testTreeFilterArg) ci /p:TargetOS=AnyOS + - script: $(Build.SourcesDirectory)/src/tests/build$(scriptExt) $(logRootNameArg)Managed allTargets skipnative skipgeneratelayout skiptestwrappers $(buildConfig) $(archType) $(runtimeFlavorArgs) $(crossArg) $(priorityArg) $(testFilterArg) ci /p:TargetOS=AnyOS displayName: Build managed test components - ${{ if in(parameters.osGroup, 'osx', 'ios', 'tvos') }}: diff --git a/eng/pipelines/common/templates/runtimes/run-test-job.yml b/eng/pipelines/common/templates/runtimes/run-test-job.yml index 1b1bf6a0481..d31c473908d 100644 --- a/eng/pipelines/common/templates/runtimes/run-test-job.yml +++ b/eng/pipelines/common/templates/runtimes/run-test-job.yml @@ -119,13 +119,13 @@ jobs: - name: LogNamePrefix value: TestRunLogs_R2R_CG2_HotColdSplitting - - name: testTreeFilterArg + - name: testFilterArg value: '' # Only build GCSimulator tests when the gc-simulator group is specified. - ${{ if eq(parameters.testGroup, 'gc-simulator') }}: - - name: testTreeFilterArg - value: 'tree GC/Scenarios/GCSimulator' + - name: testFilterArg + value: 'test GC/Scenarios/GC-simulator.csproj' - template: /eng/pipelines/common/templates/runtimes/native-test-assets-variables.yml parameters: @@ -232,7 +232,7 @@ jobs: # and directly unzip them there after download). Unfortunately the logic to copy # the native artifacts to the final test folders is dependent on availability of the # managed test artifacts. This step also generates the final test execution scripts. - - script: $(Build.SourcesDirectory)/src/tests/build$(scriptExt) copynativeonly $(logRootNameArg)Native $(testTreeFilterArg) $(runtimeFlavorArgs) $(crossgenArg) $(buildConfig) $(archType) $(priorityArg) $(librariesOverrideArg) $(codeFlowEnforcementArg) + - script: $(Build.SourcesDirectory)/src/tests/build$(scriptExt) copynativeonly $(logRootNameArg)Native $(testFilterArg) $(runtimeFlavorArgs) $(crossgenArg) $(buildConfig) $(archType) $(priorityArg) $(librariesOverrideArg) $(codeFlowEnforcementArg) displayName: Copy native test components to test output folder @@ -244,7 +244,7 @@ jobs: # Compose the Core_Root folder containing all artifacts needed for running # CoreCLR tests. This step also compiles the framework using Crossgen2 # in ReadyToRun jobs. - - script: $(Build.SourcesDirectory)/src/tests/build$(scriptExt) generatelayoutonly $(logRootNameArg)Layout $(runtimeFlavorArgs) $(crossgenArg) $(buildConfig) $(archType) $(crossArg) $(priorityArg) $(librariesOverrideArg) $(runtimeVariantArg) + - script: $(Build.SourcesDirectory)/src/tests/build$(scriptExt) generatelayoutonly $(logRootNameArg)Layout $(runtimeFlavorArgs) $(crossgenArg) $(buildConfig) $(archType) $(crossArg) $(priorityArg) $(librariesOverrideArg) $(runtimeVariantArg) -ci displayName: Generate CORE_ROOT # Build a Mono LLVM AOT cross-compiler for non-amd64 targets (in this case, just arm64) @@ -539,6 +539,7 @@ jobs: scenarios: - jitosr_stress - jitpartialcompilation_pgo + - jitpartialcompilation_pgo_stress_random - jitoptrepeat - jitoldlayout ${{ else }}: @@ -548,6 +549,7 @@ jobs: - jit_stress_splitting - jitpartialcompilation - jitpartialcompilation_pgo + - jitpartialcompilation_pgo_stress_random - jitobjectstackallocation - jitphysicalpromotion_only - jitphysicalpromotion_full @@ -593,6 +595,7 @@ jobs: - script: $(PythonSetupScript) displayName: Enable python venv + condition: always() - script: $(PythonScript) $(Build.SourcesDirectory)/src/coreclr/scripts/superpmi.py merge-mch -log_level DEBUG -pattern $(MchFilesLocation)$(CollectionName).$(CollectionType)*.mch -output_mch_path $(MergedMchFileLocation)$(CollectionName).$(CollectionType).$(MchFileTag).mch displayName: 'Merge $(CollectionName)-$(CollectionType) SuperPMI collections' @@ -609,28 +612,29 @@ jobs: displayName: 'Upload artifacts SuperPMI $(CollectionName)-$(CollectionType) collection' condition: always() - # Add authenticated pip feed - - task: PipAuthenticate@1 - displayName: 'Pip Authenticate' - inputs: - artifactFeeds: public/dotnet-public-pypi - onlyAddExtraIndex: false - condition: always() + - ${{ if eq(variables['System.TeamProject'], 'internal') }}: + # Add authenticated pip feed + - task: PipAuthenticate@1 + displayName: 'Pip Authenticate' + inputs: + artifactFeeds: public/dotnet-public-pypi + onlyAddExtraIndex: false + condition: always() - # Ensure the Python azure-storage-blob package is installed before doing the upload. - - script: $(PipScript) install --upgrade pip && $(PipScript) install azure.storage.blob==12.5.0 --force-reinstall && $(PipScript) install azure.identity==1.16.1 --force-reinstall - displayName: Upgrade Pip to latest and install azure-storage-blob and azure-identity Python packages - condition: always() + # Ensure the Python azure-storage-blob package is installed before doing the upload. + - script: $(PipScript) install --upgrade pip && $(PipScript) install azure.storage.blob==12.5.0 --force-reinstall && $(PipScript) install azure.identity==1.16.1 --force-reinstall + displayName: Upgrade Pip to latest and install azure-storage-blob and azure-identity Python packages + condition: always() - - task: AzureCLI@2 - displayName: 'Upload SuperPMI $(CollectionName)-$(CollectionType) collection to Azure Storage' - inputs: - azureSubscription: 'superpmi-collect-rw' - scriptType: 'pscore' - scriptLocation: 'inlineScript' - inlineScript: | - $(PythonScript) $(Build.SourcesDirectory)/src/coreclr/scripts/superpmi.py upload -log_level DEBUG -arch $(archType) -build_type $(buildConfig) -mch_files $(MergedMchFileLocation)$(CollectionName).$(CollectionType).$(MchFileTag).mch -core_root $(Build.SourcesDirectory)/artifacts/bin/coreclr/$(osGroup).x64.$(buildConfigUpper) - condition: always() + - task: AzureCLI@2 + displayName: 'Upload SuperPMI $(CollectionName)-$(CollectionType) collection to Azure Storage' + inputs: + azureSubscription: 'superpmi-collect-rw' + scriptType: 'pscore' + scriptLocation: 'inlineScript' + inlineScript: | + $(PythonScript) $(Build.SourcesDirectory)/src/coreclr/scripts/superpmi.py upload -log_level DEBUG -arch $(archType) -build_type $(buildConfig) -mch_files $(MergedMchFileLocation)$(CollectionName).$(CollectionType).$(MchFileTag).mch -core_root $(Build.SourcesDirectory)/artifacts/bin/coreclr/$(osGroup).x64.$(buildConfigUpper) + condition: always() - task: CopyFiles@2 displayName: Copying superpmi.log of all partitions diff --git a/eng/pipelines/common/variables.yml b/eng/pipelines/common/variables.yml index 793b66bb660..d51d565362e 100644 --- a/eng/pipelines/common/variables.yml +++ b/eng/pipelines/common/variables.yml @@ -58,6 +58,4 @@ variables: ne(variables['isExtraPlatformsBuild'], true), eq(variables['isRollingBuild'], true))) ] -- template: /eng/pipelines/common/perf-variables.yml - -- template: /eng/common/${{ parameters.templatePath }}/variables/pool-providers.yml \ No newline at end of file +- template: /eng/common/${{ parameters.templatePath }}/variables/pool-providers.yml diff --git a/eng/pipelines/common/xplat-setup.yml b/eng/pipelines/common/xplat-setup.yml index f50a2db9e81..6b1804c9afc 100644 --- a/eng/pipelines/common/xplat-setup.yml +++ b/eng/pipelines/common/xplat-setup.yml @@ -172,10 +172,10 @@ jobs: ${{ if and(in(parameters.osGroup, 'osx', 'maccatalyst', 'ios', 'iossimulator', 'tvos', 'tvossimulator'), eq(variables['System.TeamProject'], 'public')) }}: vmImage: 'macos-12' - # OSX Internal Pool + # Official build OSX pool ${{ if and(in(parameters.osGroup, 'osx', 'maccatalyst', 'ios', 'iossimulator', 'tvos', 'tvossimulator'), ne(variables['System.TeamProject'], 'public')) }}: name: "Azure Pipelines" - vmImage: 'macOS-12' + vmImage: 'macos-latest-internal' os: macOS # Official Build Windows Pool diff --git a/eng/pipelines/coreclr/exploratory.yml b/eng/pipelines/coreclr/exploratory.yml index 2ba84590f5e..7b094398a0f 100644 --- a/eng/pipelines/coreclr/exploratory.yml +++ b/eng/pipelines/coreclr/exploratory.yml @@ -40,7 +40,7 @@ extends: buildArgs: -s clr+libs -c $(_BuildConfig) -lc Release timeoutInMinutes: 360 postBuildSteps: - - script: $(Build.SourcesDirectory)/src/tests/build$(scriptExt) $(_BuildConfig) $(archType) generatelayoutonly + - script: $(Build.SourcesDirectory)/src/tests/build$(scriptExt) $(_BuildConfig) $(archType) $(crossArg) generatelayoutonly /p:UsePublishedCrossgen2=false displayName: Create Core_Root condition: succeeded() - template: /eng/pipelines/coreclr/templates/jit-exploratory-steps.yml diff --git a/eng/pipelines/coreclr/perf-non-wasm-jobs.yml b/eng/pipelines/coreclr/perf-non-wasm-jobs.yml index 8419e99f7ba..f750bda72f9 100644 --- a/eng/pipelines/coreclr/perf-non-wasm-jobs.yml +++ b/eng/pipelines/coreclr/perf-non-wasm-jobs.yml @@ -1,3 +1,6 @@ +parameters: + perfBranch: 'main' + jobs: - ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'Schedule')) }}: @@ -100,6 +103,7 @@ jobs: - template: /eng/pipelines/coreclr/templates/build-and-run-perf-ios-scenarios.yml parameters: hybridGlobalization: True + perfBranch: ${{ parameters.perfBranch }} # run android scenarios - template: /eng/pipelines/common/platform-matrix.yml @@ -112,10 +116,11 @@ jobs: jobParameters: testGroup: perf runtimeType: AndroidMono - projectFile: android_scenarios.proj + projectFile: $(Build.SourcesDirectory)/eng/testing/performance/android_scenarios.proj runKind: android_scenarios runJobTemplate: /eng/pipelines/coreclr/templates/run-scenarios-job.yml logicalmachine: 'perfpixel4a' + perfBranch: ${{ parameters.perfBranch }} # run mono microbenchmarks perf job - template: /eng/pipelines/common/platform-matrix.yml @@ -129,10 +134,11 @@ jobs: testGroup: perf liveLibrariesBuildConfig: Release runtimeType: mono - projectFile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runKind: micro_mono runJobTemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'perftiger' + perfBranch: ${{ parameters.perfBranch }} # run mono interpreter perf job - template: /eng/pipelines/common/platform-matrix.yml @@ -147,10 +153,11 @@ jobs: liveLibrariesBuildConfig: Release runtimeType: mono codeGenType: 'Interpreter' - projectFile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runKind: micro_mono runJobTemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'perftiger' + perfBranch: ${{ parameters.perfBranch }} # run mono aot microbenchmarks perf job - template: /eng/pipelines/common/platform-matrix.yml @@ -165,10 +172,11 @@ jobs: liveLibrariesBuildConfig: Release runtimeType: mono codeGenType: 'AOT' - projectFile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runKind: micro_mono runJobTemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'perftiger' + perfBranch: ${{ parameters.perfBranch }} # run coreclr perftiger microbenchmarks perf job - template: /eng/pipelines/common/platform-matrix.yml @@ -184,10 +192,11 @@ jobs: jobParameters: testGroup: perf liveLibrariesBuildConfig: Release - projectFile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runKind: micro runJobTemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'perftiger' + perfBranch: ${{ parameters.perfBranch }} # run coreclr perftiger microbenchmarks no dynamic pgo perf jobs - template: /eng/pipelines/common/platform-matrix.yml @@ -200,11 +209,12 @@ jobs: jobParameters: testGroup: perf liveLibrariesBuildConfig: Release - projectFile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runKind: micro runJobTemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'perftiger' pgoRunType: -NoDynamicPGO + perfBranch: ${{ parameters.perfBranch }} - template: /eng/pipelines/common/platform-matrix.yml parameters: @@ -216,11 +226,12 @@ jobs: jobParameters: testGroup: perf liveLibrariesBuildConfig: Release - projectFile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runKind: micro runJobTemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'perftiger' pgoRunType: --nodynamicpgo + perfBranch: ${{ parameters.perfBranch }} # run coreclr perftiger microbenchmarks no R2R perf jobs - template: /eng/pipelines/common/platform-matrix.yml @@ -233,11 +244,12 @@ jobs: jobParameters: testGroup: perf liveLibrariesBuildConfig: Release - projectFile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runKind: micro runJobTemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'perftiger' r2rRunType: -NoR2R + perfBranch: ${{ parameters.perfBranch }} - template: /eng/pipelines/common/platform-matrix.yml parameters: @@ -249,11 +261,12 @@ jobs: jobParameters: testGroup: perf liveLibrariesBuildConfig: Release - projectFile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runKind: micro runJobTemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'perftiger' r2rRunType: --nor2r + perfBranch: ${{ parameters.perfBranch }} # run coreclr perfowl microbenchmarks perf job - template: /eng/pipelines/common/platform-matrix.yml @@ -267,10 +280,11 @@ jobs: jobParameters: testGroup: perf liveLibrariesBuildConfig: Release - projectFile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runKind: micro runJobTemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'perfowl' + perfBranch: ${{ parameters.perfBranch }} # run coreclr perfviper microbenchmarks perf job - template: /eng/pipelines/common/platform-matrix.yml @@ -284,10 +298,11 @@ jobs: jobParameters: testGroup: perf liveLibrariesBuildConfig: Release - projectFile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runKind: micro runJobTemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'perfviper' + perfBranch: ${{ parameters.perfBranch }} # run coreclr perfviper microbenchmarks perf jitoptrepeat jobs - template: /eng/pipelines/common/platform-matrix.yml @@ -301,11 +316,12 @@ jobs: jobParameters: testGroup: perf liveLibrariesBuildConfig: Release - projectFile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runKind: micro runJobTemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'perfviper' experimentName: 'jitoptrepeat' + perfBranch: ${{ parameters.perfBranch }} # run coreclr crossgen perf job - template: /eng/pipelines/common/platform-matrix.yml @@ -319,10 +335,11 @@ jobs: jobParameters: testGroup: perf liveLibrariesBuildConfig: Release - projectFile: crossgen_perf.proj + projectFile: $(Build.SourcesDirectory)/eng/testing/performance/crossgen_perf.proj runKind: crossgen_scenarios runJobTemplate: /eng/pipelines/coreclr/templates/run-scenarios-job.yml logicalmachine: 'perftiger_crossgen' + perfBranch: ${{ parameters.perfBranch }} # build mono runtime packs - template: /eng/pipelines/common/platform-matrix.yml @@ -368,3 +385,4 @@ jobs: archiveExtension: '.tar.gz' archiveType: tar tarCompression: gz + perfBranch: ${{ parameters.perfBranch }} diff --git a/eng/pipelines/coreclr/perf-wasm-jobs.yml b/eng/pipelines/coreclr/perf-wasm-jobs.yml index 3f33e90cbc8..93ffdfc5283 100644 --- a/eng/pipelines/coreclr/perf-wasm-jobs.yml +++ b/eng/pipelines/coreclr/perf-wasm-jobs.yml @@ -7,7 +7,7 @@ parameters: onlySanityCheck: false downloadSpecificBuild: null # { buildId, pipeline, branchName, project } collectHelixLogsScript: '' - perfForkToUse: {} # url, branch + perfBranch: 'main' jobs: @@ -43,14 +43,14 @@ jobs: liveLibrariesBuildConfig: Release runtimeType: wasm codeGenType: 'wasm' - projectFile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runKind: micro runJobTemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'perftiger' javascriptEngine: 'javascriptcore' collectHelixLogsScript: ${{ parameters.collectHelixLogsScript }} downloadSpecificBuild: ${{ parameters.downloadSpecificBuild }} - perfForkToUse: ${{ parameters.perfForkToUse }} + perfBranch: ${{ parameters.perfBranch }} #downloadSpecificBuild: #buildId: '1693181' #pipeline: 'perf-wasm' @@ -69,14 +69,14 @@ jobs: livelibrariesbuildconfig: Release runtimetype: wasm codegentype: 'aot' - projectfile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runkind: micro runjobtemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'perftiger' javascriptengine: 'javascriptcore' collectHelixLogsScript: ${{ parameters.collectHelixLogsScript }} downloadSpecificBuild: ${{ parameters.downloadSpecificBuild }} - perfForkToUse: ${{ parameters.perfForkToUse }} + perfBranch: ${{ parameters.perfBranch }} - ${{ if eq(parameters.runProfile, 'v8') }}: - ${{ if eq(parameters.downloadSpecificBuild.buildId, '') }}: @@ -110,7 +110,7 @@ jobs: liveLibrariesBuildConfig: Release runtimeType: wasm codeGenType: 'wasm' - projectFile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runKind: micro runJobTemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'perftiger' @@ -121,7 +121,7 @@ jobs: compare: ${{ parameters.compare }} onlySanityCheck: ${{ parameters.onlySanityCheck }} downloadSpecificBuild: ${{ parameters.downloadSpecificBuild }} - perfForkToUse: ${{ parameters.perfForkToUse }} + perfBranch: ${{ parameters.perfBranch }} #run mono wasm aot microbenchmarks perf job # Disabled for runtime-wasm-perf on PRs due to https://github.com/dotnet/runtime/issues/95101 @@ -138,7 +138,7 @@ jobs: livelibrariesbuildconfig: Release runtimetype: wasm codegentype: 'aot' - projectfile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runkind: micro runjobtemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'perftiger' @@ -149,7 +149,7 @@ jobs: compare: ${{ parameters.compare }} onlySanityCheck: ${{ parameters.onlySanityCheck }} downloadSpecificBuild: ${{ parameters.downloadSpecificBuild }} - perfForkToUse: ${{ parameters.perfForkToUse }} + perfBranch: ${{ parameters.perfBranch }} # run mono wasm blazor perf job - template: /eng/pipelines/common/platform-matrix.yml @@ -163,14 +163,14 @@ jobs: testGroup: perf liveLibrariesBuildConfig: Release runtimeType: wasm - projectFile: blazor_perf.proj + projectFile: $(Build.SourcesDirectory)/eng/testing/performance/blazor_perf.proj runKind: blazor_scenarios runJobTemplate: /eng/pipelines/coreclr/templates/run-scenarios-job.yml # For working with a newer sdk, and previous tfm (eg. 9.0 sdk, and net8.0 tfm) - #additionalSetupParameters: '--dotnetversions 8.0.0' # passed to performance-setup.sh + #additionalSetupParameters: '--dotnetversions 8.0.0' # passed to run-performance-job.py logicalmachine: 'perftiger' downloadSpecificBuild: ${{ parameters.downloadSpecificBuild }} - perfForkToUse: ${{ parameters.perfForkToUse }} + perfBranch: ${{ parameters.perfBranch }} - ${{if or(and(ne(variables['System.TeamProject'], 'public'), in(variables['Build.Reason'], 'Schedule')), in(variables['Build.DefinitionName'], 'runtime-wasm-perf')) }}: # run mono wasm blazor perf job @@ -185,12 +185,12 @@ jobs: testGroup: perf liveLibrariesBuildConfig: Release runtimeType: wasm - projectFile: blazor_perf.proj + projectFile: $(Build.SourcesDirectory)/eng/testing/performance/blazor_perf.proj runKind: blazor_scenarios runJobTemplate: /eng/pipelines/coreclr/templates/run-scenarios-job.yml # For working with a newer sdk, and previous tfm (eg. 9.0 sdk, and net8.0 tfm) - #additionalSetupParameters: '--dotnetversions 8.0.0' # passed to performance-setup.sh + #additionalSetupParameters: '--dotnetversions 8.0.0' # passed to run-performance-job.py logicalmachine: 'perftiger' downloadSpecificBuild: ${{ parameters.downloadSpecificBuild }} - perfForkToUse: ${{ parameters.perfForkToUse }} hybridGlobalization: True + perfBranch: ${{ parameters.perfBranch }} diff --git a/eng/pipelines/coreclr/perf.yml b/eng/pipelines/coreclr/perf.yml index 3d7ee810670..9b595f3dd8c 100644 --- a/eng/pipelines/coreclr/perf.yml +++ b/eng/pipelines/coreclr/perf.yml @@ -1,3 +1,9 @@ +parameters: +- name: perfBranch + displayName: Performance Repo Branch + type: string + default: 'main' + trigger: batch: true branches: @@ -19,7 +25,7 @@ trigger: - THIRD-PARTY-NOTICES.TXT variables: - - template: /eng/pipelines/common/variables.yml +- template: /eng/pipelines/common/variables.yml # # For the 'schedule' case, only wasm/jsc perf jobs are run. @@ -46,9 +52,12 @@ extends: - template: /eng/pipelines/coreclr/perf-wasm-jobs.yml parameters: collectHelixLogsScript: ${{ variables._wasmCollectHelixLogsScript }} + perfBranch: ${{ parameters.perfBranch }} #${{ and(ne(variables['System.TeamProject'], 'public'), in(variables['Build.Reason'], 'Schedule')) }}: # runProfile: 'non-v8' ${{ if ne(variables['System.TeamProject'], 'public') }}: runProfile: 'v8' - template: /eng/pipelines/coreclr/perf-non-wasm-jobs.yml + parameters: + perfBranch: ${{ parameters.perfBranch }} diff --git a/eng/pipelines/coreclr/perf_slow.yml b/eng/pipelines/coreclr/perf_slow.yml index 6bdeb08b1e3..e7d073534a7 100644 --- a/eng/pipelines/coreclr/perf_slow.yml +++ b/eng/pipelines/coreclr/perf_slow.yml @@ -5,6 +5,10 @@ parameters: - name: runScheduledJobs type: boolean default: false +- name: perfBranch + displayName: Performance Repo Branch + type: string + default: 'main' trigger: batch: true @@ -80,11 +84,31 @@ extends: liveLibrariesBuildConfig: Release runtimeType: mono codeGenType: 'Interpreter' - projectFile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runKind: micro_mono runJobTemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'perfampere' timeoutInMinutes: 720 + perfBranch: ${{ parameters.perfBranch }} + + # run arm64 jit jobs for mono + - template: /eng/pipelines/common/platform-matrix.yml + parameters: + jobTemplate: /eng/pipelines/coreclr/templates/perf-job.yml + buildConfig: release + runtimeFlavor: mono + platforms: + - linux_arm64 + jobParameters: + testGroup: perf + liveLibrariesBuildConfig: Release + runtimeType: mono + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj + runKind: micro_mono + runJobTemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml + logicalmachine: 'perfampere' + timeoutInMinutes: 720 + perfBranch: ${{ parameters.perfBranch }} - ${{ if and(ne(variables['System.TeamProject'], 'public'), or(notin(variables['Build.Reason'], 'Schedule', 'Manual'), parameters.runPrivateJobs)) }}: @@ -149,11 +173,12 @@ extends: liveLibrariesBuildConfig: Release runtimeType: mono codeGenType: 'AOT' - projectFile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runKind: micro_mono runJobTemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'perfampere' timeoutInMinutes: 780 + perfBranch: ${{ parameters.perfBranch }} # run coreclr Linux arm64 ampere microbenchmarks perf job - template: /eng/pipelines/common/platform-matrix.yml @@ -166,11 +191,12 @@ extends: jobParameters: testGroup: perf liveLibrariesBuildConfig: Release - projectFile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runKind: micro runJobTemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'perfampere' timeoutInMinutes: 780 + perfBranch: ${{ parameters.perfBranch }} #run coreclr Linux arm64 ampere no dynamic pgo microbenchmarks perf job - template: /eng/pipelines/common/platform-matrix.yml @@ -183,12 +209,13 @@ extends: jobParameters: testGroup: perf liveLibrariesBuildConfig: Release - projectFile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runKind: micro runJobTemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'perfampere' timeoutInMinutes: 780 pgoRunType: --nodynamicpgo + perfBranch: ${{ parameters.perfBranch }} #run coreclr Linux arm64 ampere no R2R microbenchmarks perf job - template: /eng/pipelines/common/platform-matrix.yml @@ -201,12 +228,13 @@ extends: jobParameters: testGroup: perf liveLibrariesBuildConfig: Release - projectFile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runKind: micro runJobTemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'perfampere' timeoutInMinutes: 780 r2rRunType: --nor2r + perfBranch: ${{ parameters.perfBranch }} # run coreclr Windows arm64 microbenchmarks perf job - template: /eng/pipelines/common/platform-matrix.yml @@ -219,10 +247,11 @@ extends: jobParameters: testGroup: perf liveLibrariesBuildConfig: Release - projectFile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runKind: micro runJobTemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'perfsurf' + perfBranch: ${{ parameters.perfBranch }} # run coreclr Windows arm64 ampere microbenchmarks perf job - template: /eng/pipelines/common/platform-matrix.yml @@ -235,11 +264,12 @@ extends: jobParameters: testGroup: perf liveLibrariesBuildConfig: Release - projectFile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runKind: micro runJobTemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'perfampere' timeoutInMinutes: 780 + perfBranch: ${{ parameters.perfBranch }} # run coreclr Windows arm64 ampere no dynamic pgo microbenchmarks perf job - template: /eng/pipelines/common/platform-matrix.yml @@ -252,12 +282,13 @@ extends: jobParameters: testGroup: perf liveLibrariesBuildConfig: Release - projectFile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runKind: micro runJobTemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'perfampere' pgoRunType: -NoDynamicPGO timeoutInMinutes: 780 + perfBranch: ${{ parameters.perfBranch }} # run coreclr Windows arm64 ampere no R2R microbenchmarks perf job - template: /eng/pipelines/common/platform-matrix.yml @@ -270,12 +301,13 @@ extends: jobParameters: testGroup: perf liveLibrariesBuildConfig: Release - projectFile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runKind: micro runJobTemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'perfampere' r2rRunType: -NoR2R timeoutInMinutes: 780 + perfBranch: ${{ parameters.perfBranch }} # run coreclr cloudvm microbenchmarks perf job # this run is added temporarily for measuring AVX-512 performance @@ -290,10 +322,11 @@ extends: jobParameters: testGroup: perf liveLibrariesBuildConfig: Release - projectFile: microbenchmarks.proj + projectFile: $(Agent.BuildDirectory)/performance/eng/performance/helix.proj runKind: micro runJobTemplate: /eng/pipelines/coreclr/templates/run-performance-job.yml logicalmachine: 'cloudvm' + perfBranch: ${{ parameters.perfBranch }} # Uncomment once we fix https://github.com/dotnet/performance/issues/1950 # # run coreclr linux crossgen perf job @@ -307,10 +340,11 @@ extends: # jobParameters: # testGroup: perf # liveLibrariesBuildConfig: Release - # projectFile: crossgen_perf.proj + # projectFile: $(Build.SourcesDirectory)/eng/testing/performance/crossgen_perf.proj # runKind: crossgen_scenarios # runJobTemplate: /eng/pipelines/coreclr/templates/run-scenarios-job.yml # logicalmachine: 'perfa64' + # perfBranch: ${{ parameters.perfBranch }} # # run coreclr windows crossgen perf job # - template: /eng/pipelines/common/platform-matrix.yml @@ -323,7 +357,8 @@ extends: # jobParameters: # testGroup: perf # liveLibrariesBuildConfig: Release - # projectFile: crossgen_perf.proj + # projectFile: $(Build.SourcesDirectory)/eng/testing/performance/crossgen_perf.proj # runKind: crossgen_scenarios # runJobTemplate: /eng/pipelines/coreclr/templates/run-scenarios-job.yml # logicalmachine: 'perfsurf' + # perfBranch: ${{ parameters.perfBranch }} diff --git a/eng/pipelines/coreclr/runtime-nativeaot-outerloop.yml b/eng/pipelines/coreclr/runtime-nativeaot-outerloop.yml index 494601a890d..c39c6d81a45 100644 --- a/eng/pipelines/coreclr/runtime-nativeaot-outerloop.yml +++ b/eng/pipelines/coreclr/runtime-nativeaot-outerloop.yml @@ -156,7 +156,6 @@ extends: # # CoreCLR NativeAOT checked build and Pri0 tests - # Only when CoreCLR is changed # - template: /eng/pipelines/common/platform-matrix.yml parameters: @@ -189,3 +188,37 @@ extends: parameters: testGroup: innerloop liveLibrariesBuildConfig: Release + + # + # CoreCLR NativeAOT checked build and Pri0 tests + # Test windows_x64 with CET and CFG + # + - template: /eng/pipelines/common/platform-matrix.yml + parameters: + jobTemplate: /eng/pipelines/common/global-build-job.yml + helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml + helixQueueGroup: cet + buildConfig: Checked + platforms: + - windows_x64 + variables: + - name: timeoutPerTestInMinutes + value: 60 + - name: timeoutPerTestCollectionInMinutes + value: 180 + jobParameters: + timeoutInMinutes: 300 # doesn't normally take this long, but we have had Helix queues backed up for over an hour + nameSuffix: NativeAOT_Pri0_CET_CFG + buildArgs: -s clr.aot+libs -rc $(_BuildConfig) -lc Release /p:RunAnalyzers=false + postBuildSteps: + - template: /eng/pipelines/coreclr/nativeaot-post-build-steps.yml + parameters: + creator: dotnet-bot + testBuildArgs: 'nativeaot /p:IlcUseServerGc=false /p:ControlFlowGuard=Guard' + liveLibrariesBuildConfig: Release + testRunNamePrefixSuffix: NativeAOT_Pri0_CET_CFG_$(_BuildConfig) + extraVariablesTemplates: + - template: /eng/pipelines/common/templates/runtimes/test-variables.yml + parameters: + testGroup: innerloop + liveLibrariesBuildConfig: Release \ No newline at end of file diff --git a/eng/pipelines/coreclr/superpmi-collect-test.yml b/eng/pipelines/coreclr/superpmi-collect-test.yml new file mode 100644 index 00000000000..863a79c1b31 --- /dev/null +++ b/eng/pipelines/coreclr/superpmi-collect-test.yml @@ -0,0 +1,373 @@ +# This job definition automates the SuperPMI collection process. + +trigger: none + +variables: + - template: /eng/pipelines/common/variables.yml + +extends: + template: /eng/pipelines/common/templates/pipeline-with-resources.yml + parameters: + stages: + - stage: Build + jobs: + + - template: /eng/pipelines/common/platform-matrix.yml + parameters: + jobTemplate: /eng/pipelines/common/global-build-job.yml + buildConfig: checked + platforms: + - windows_x64 + - linux_x64 + jobParameters: + testGroup: outerloop + buildArgs: -s clr+libs+libs.tests -rc $(_BuildConfig) -c Release /p:ArchiveTests=true + timeoutInMinutes: 120 + postBuildSteps: + - template: /eng/pipelines/coreclr/templates/build-native-test-assets-step.yml + - template: /eng/pipelines/common/upload-artifact-step.yml + parameters: + rootFolder: $(Build.SourcesDirectory)/artifacts/bin + includeRootFolder: false + archiveType: $(archiveType) + archiveExtension: $(archiveExtension) + tarCompression: $(tarCompression) + artifactName: BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig) + - template: /eng/pipelines/common/upload-artifact-step.yml + parameters: + rootFolder: $(Build.SourcesDirectory)/artifacts/helix + includeRootFolder: false + archiveType: $(archiveType) + archiveExtension: $(archiveExtension) + tarCompression: $(tarCompression) + artifactName: LibrariesTestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig) + extraVariablesTemplates: + - template: /eng/pipelines/common/templates/runtimes/native-test-assets-variables.yml + parameters: + testGroup: outerloop + disableComponentGovernance: true # No shipping artifacts produced by this pipeline + + - template: /eng/pipelines/common/platform-matrix.yml + parameters: + jobTemplate: /eng/pipelines/common/global-build-job.yml + buildConfig: checked + platforms: + - windows_x86 + - windows_arm64 + - osx_arm64 + jobParameters: + testGroup: outerloop + buildArgs: -s clr+libs+libs.tests -rc $(_BuildConfig) -c Release /p:ArchiveTests=true + timeoutInMinutes: 120 + postBuildSteps: + # Build CLR assets for x64 as well as the target as we need an x64 mcs + - template: /eng/pipelines/common/templates/global-build-step.yml + parameters: + buildArgs: -s clr.spmi -c $(_BuildConfig) + archParameter: -arch x64 + displayName: Build SuperPMI + - template: /eng/pipelines/coreclr/templates/build-native-test-assets-step.yml + - template: /eng/pipelines/common/upload-artifact-step.yml + parameters: + rootFolder: $(Build.SourcesDirectory)/artifacts/bin + includeRootFolder: false + archiveType: $(archiveType) + archiveExtension: $(archiveExtension) + tarCompression: $(tarCompression) + artifactName: BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig) + - template: /eng/pipelines/common/upload-artifact-step.yml + parameters: + rootFolder: $(Build.SourcesDirectory)/artifacts/helix + includeRootFolder: false + archiveType: $(archiveType) + archiveExtension: $(archiveExtension) + tarCompression: $(tarCompression) + artifactName: LibrariesTestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig) + extraVariablesTemplates: + - template: /eng/pipelines/common/templates/runtimes/native-test-assets-variables.yml + parameters: + testGroup: outerloop + disableComponentGovernance: true # No shipping artifacts produced by this pipeline + + - template: /eng/pipelines/common/platform-matrix.yml + parameters: + jobTemplate: /eng/pipelines/common/global-build-job.yml + buildConfig: checked + platforms: + - linux_arm + - linux_arm64 + jobParameters: + testGroup: outerloop + buildArgs: -s clr+libs+libs.tests -rc $(_BuildConfig) -c Release /p:ArchiveTests=true + timeoutInMinutes: 120 + postBuildSteps: + # Build CLR assets for x64 as well as the target as we need an x64 mcs + - template: /eng/pipelines/common/templates/global-build-step.yml + parameters: + buildArgs: -s clr.spmi -c $(_BuildConfig) + archParameter: -arch x64 + container: linux_x64 + displayName: Build SuperPMI + - template: /eng/pipelines/coreclr/templates/build-native-test-assets-step.yml + - template: /eng/pipelines/common/upload-artifact-step.yml + parameters: + rootFolder: $(Build.SourcesDirectory)/artifacts/bin + includeRootFolder: false + archiveType: $(archiveType) + archiveExtension: $(archiveExtension) + tarCompression: $(tarCompression) + artifactName: BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig) + - template: /eng/pipelines/common/upload-artifact-step.yml + parameters: + rootFolder: $(Build.SourcesDirectory)/artifacts/helix + includeRootFolder: false + archiveType: $(archiveType) + archiveExtension: $(archiveExtension) + tarCompression: $(tarCompression) + artifactName: LibrariesTestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig) + extraVariablesTemplates: + - template: /eng/pipelines/common/templates/runtimes/native-test-assets-variables.yml + parameters: + testGroup: outerloop + disableComponentGovernance: true # No shipping artifacts produced by this pipeline + + - template: /eng/pipelines/common/platform-matrix.yml + parameters: + jobTemplate: /eng/pipelines/common/templates/runtimes/build-test-job.yml + buildConfig: checked + platforms: + - CoreClrTestBuildHost # Either osx_x64 or linux_x64 + jobParameters: + testGroup: outerloop + + - template: /eng/pipelines/common/platform-matrix.yml + parameters: + jobTemplate: /eng/pipelines/coreclr/templates/superpmi-collect-job.yml + buildConfig: checked + platforms: + - osx_arm64 + - linux_arm + - linux_arm64 + - linux_x64 + - windows_x64 + - windows_x86 + - windows_arm64 + helixQueueGroup: ci + helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml + jobParameters: + testGroup: outerloop + liveLibrariesBuildConfig: Release + collectionType: pmi + collectionName: libraries + collectionUpload: false + + - template: /eng/pipelines/common/platform-matrix.yml + parameters: + jobTemplate: /eng/pipelines/coreclr/templates/superpmi-collect-job.yml + buildConfig: checked + platforms: + - osx_arm64 + - linux_arm + - linux_arm64 + - linux_x64 + - windows_x64 + - windows_x86 + - windows_arm64 + helixQueueGroup: ci + helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml + jobParameters: + testGroup: outerloop + liveLibrariesBuildConfig: Release + collectionType: crossgen2 + collectionName: libraries + collectionUpload: false + + - template: /eng/pipelines/common/platform-matrix.yml + parameters: + jobTemplate: /eng/pipelines/coreclr/templates/superpmi-collect-job.yml + buildConfig: checked + platforms: + - osx_arm64 + - linux_arm + - linux_arm64 + - linux_x64 + - windows_x64 + - windows_x86 + - windows_arm64 + helixQueueGroup: ci + helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml + jobParameters: + testGroup: outerloop + liveLibrariesBuildConfig: Release + collectionType: run + collectionName: realworld + collectionUpload: false + + - template: /eng/pipelines/common/platform-matrix.yml + parameters: + jobTemplate: /eng/pipelines/coreclr/templates/superpmi-collect-job.yml + buildConfig: checked + platforms: + - osx_arm64 + - linux_arm + - linux_arm64 + - linux_x64 + - windows_x64 + - windows_x86 + - windows_arm64 + helixQueueGroup: ci + helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml + jobParameters: + testGroup: outerloop + liveLibrariesBuildConfig: Release + collectionType: run + collectionName: benchmarks + collectionUpload: false + + - template: /eng/pipelines/common/platform-matrix.yml + parameters: + jobTemplate: /eng/pipelines/coreclr/templates/superpmi-collect-job.yml + buildConfig: checked + platforms: + - osx_arm64 + - linux_arm + - linux_arm64 + - linux_x64 + - windows_x64 + - windows_x86 + - windows_arm64 + helixQueueGroup: ci + helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml + jobParameters: + testGroup: outerloop + liveLibrariesBuildConfig: Release + collectionType: run_tiered + collectionName: benchmarks + collectionUpload: false + + - template: /eng/pipelines/common/platform-matrix.yml + parameters: + jobTemplate: /eng/pipelines/coreclr/templates/superpmi-collect-job.yml + buildConfig: checked + platforms: + - osx_arm64 + - linux_arm + - linux_arm64 + - linux_x64 + - windows_x64 + - windows_x86 + - windows_arm64 + helixQueueGroup: ci + helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml + jobParameters: + testGroup: outerloop + liveLibrariesBuildConfig: Release + collectionType: run_pgo + collectionName: benchmarks + collectionUpload: false + + # + # Collection of coreclr test run + # + - template: /eng/pipelines/common/platform-matrix.yml + parameters: + jobTemplate: /eng/pipelines/common/templates/runtimes/run-test-job.yml + buildConfig: checked + platforms: + - osx_arm64 + - linux_arm + - linux_arm64 + - linux_x64 + - windows_x64 + - windows_x86 + - windows_arm64 + helixQueueGroup: superpmi + helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml + jobParameters: + testGroup: outerloop + liveLibrariesBuildConfig: Release + SuperPmiCollect: true + SuperPmiCollectionUpload: false + unifiedArtifactsName: BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_$(_BuildConfig) + + - template: /eng/pipelines/common/platform-matrix.yml + parameters: + jobTemplate: /eng/pipelines/coreclr/templates/superpmi-collect-job.yml + buildConfig: checked + platforms: + - linux_arm64 + - linux_x64 + - windows_x64 + - windows_arm64 + helixQueueGroup: ci + helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml + jobParameters: + testGroup: outerloop + liveLibrariesBuildConfig: Release + collectionType: nativeaot + collectionName: smoke_tests + collectionUpload: false + + # + # Collection of libraries test run: normal + # Libraries Test Run using Release libraries, and Checked CoreCLR + # + - template: /eng/pipelines/common/platform-matrix.yml + parameters: + jobTemplate: /eng/pipelines/libraries/run-test-job.yml + buildConfig: Release + platforms: + - osx_arm64 + - linux_arm + - linux_arm64 + - linux_x64 + - windows_x64 + - windows_x86 + - windows_arm64 + helixQueueGroup: superpmi + helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml + jobParameters: + testScope: innerloop + liveRuntimeBuildConfig: Checked + dependsOnTestBuildConfiguration: Release + dependsOnTestArchitecture: x64 + scenarios: + - normal + SuperPmiCollect: true + SuperPmiCollectionName: libraries_tests + SuperPmiCollectionUpload: false + unifiedArtifactsName: BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_Checked + helixArtifactsName: LibrariesTestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_Checked + unifiedBuildConfigOverride: checked + + # + # Collection of libraries test run: no_tiered_compilation + # Libraries Test Run using Release libraries, and Checked CoreCLR + # + - template: /eng/pipelines/common/platform-matrix.yml + parameters: + jobTemplate: /eng/pipelines/libraries/run-test-job.yml + buildConfig: Release + platforms: + - osx_arm64 + - linux_arm + - linux_arm64 + - linux_x64 + - windows_x64 + - windows_x86 + - windows_arm64 + helixQueueGroup: superpmi + helixQueuesTemplate: /eng/pipelines/coreclr/templates/helix-queues-setup.yml + jobParameters: + testScope: innerloop + liveRuntimeBuildConfig: Checked + dependsOnTestBuildConfiguration: Release + dependsOnTestArchitecture: x64 + scenarios: + - no_tiered_compilation + SuperPmiCollect: true + SuperPmiCollectionName: libraries_tests_no_tiered_compilation + SuperPmiCollectionUpload: false + unifiedArtifactsName: BuildArtifacts_$(osGroup)$(osSubgroup)_$(archType)_Checked + helixArtifactsName: LibrariesTestArtifacts_$(osGroup)$(osSubgroup)_$(archType)_Checked + unifiedBuildConfigOverride: checked diff --git a/eng/pipelines/coreclr/superpmi-collect.yml b/eng/pipelines/coreclr/superpmi-collect.yml index ea5b57d5f51..3530ff5a958 100644 --- a/eng/pipelines/coreclr/superpmi-collect.yml +++ b/eng/pipelines/coreclr/superpmi-collect.yml @@ -86,6 +86,7 @@ extends: parameters: buildArgs: -s clr.spmi -c $(_BuildConfig) archParameter: -arch x64 + displayName: Build SuperPMI - template: /eng/pipelines/coreclr/templates/build-native-test-assets-step.yml - template: /eng/pipelines/common/upload-artifact-step.yml parameters: @@ -127,6 +128,7 @@ extends: buildArgs: -s clr.spmi -c $(_BuildConfig) archParameter: -arch x64 container: linux_x64 + displayName: Build SuperPMI - template: /eng/pipelines/coreclr/templates/build-native-test-assets-step.yml - template: /eng/pipelines/common/upload-artifact-step.yml parameters: diff --git a/eng/pipelines/coreclr/templates/build-and-run-perf-ios-scenarios.yml b/eng/pipelines/coreclr/templates/build-and-run-perf-ios-scenarios.yml index 2d484c8e15e..f9513e556f8 100644 --- a/eng/pipelines/coreclr/templates/build-and-run-perf-ios-scenarios.yml +++ b/eng/pipelines/coreclr/templates/build-and-run-perf-ios-scenarios.yml @@ -1,5 +1,6 @@ parameters: hybridGlobalization: True + perfBranch: 'main' jobs: # build mono iOS scenarios HybridGlobalization @@ -61,13 +62,14 @@ jobs: jobParameters: testGroup: perf runtimeType: iOSMono - projectFile: ios_scenarios.proj + projectFile: $(Build.SourcesDirectory)/eng/testing/performance/ios_scenarios.proj runKind: ios_scenarios runJobTemplate: /eng/pipelines/coreclr/templates/run-scenarios-job.yml logicalmachine: 'perfiphone12mini' iOSLlvmBuild: False iOSStripSymbols: False hybridGlobalization: ${{ parameters.hybridGlobalization }} + perfBranch: ${{ parameters.perfBranch }} - template: /eng/pipelines/common/platform-matrix.yml parameters: @@ -79,13 +81,14 @@ jobs: jobParameters: testGroup: perf runtimeType: iOSMono - projectFile: ios_scenarios.proj + projectFile: $(Build.SourcesDirectory)/eng/testing/performance/ios_scenarios.proj runKind: ios_scenarios runJobTemplate: /eng/pipelines/coreclr/templates/run-scenarios-job.yml logicalmachine: 'perfiphone12mini' iOSLlvmBuild: False iOSStripSymbols: True hybridGlobalization: ${{ parameters.hybridGlobalization }} + perfBranch: ${{ parameters.perfBranch }} - template: /eng/pipelines/common/platform-matrix.yml parameters: @@ -97,13 +100,14 @@ jobs: jobParameters: testGroup: perf runtimeType: iOSMono - projectFile: ios_scenarios.proj + projectFile: $(Build.SourcesDirectory)/eng/testing/performance/ios_scenarios.proj runKind: ios_scenarios runJobTemplate: /eng/pipelines/coreclr/templates/run-scenarios-job.yml logicalmachine: 'perfiphone12mini' iOSLlvmBuild: True iOSStripSymbols: False hybridGlobalization: ${{ parameters.hybridGlobalization }} + perfBranch: ${{ parameters.perfBranch }} - template: /eng/pipelines/common/platform-matrix.yml parameters: @@ -115,13 +119,14 @@ jobs: jobParameters: testGroup: perf runtimeType: iOSMono - projectFile: ios_scenarios.proj + projectFile: $(Build.SourcesDirectory)/eng/testing/performance/ios_scenarios.proj runKind: ios_scenarios runJobTemplate: /eng/pipelines/coreclr/templates/run-scenarios-job.yml logicalmachine: 'perfiphone12mini' iOSLlvmBuild: True iOSStripSymbols: True hybridGlobalization: ${{ parameters.hybridGlobalization }} + perfBranch: ${{ parameters.perfBranch }} # run NativeAOT iOS scenarios HybridGlobalization - template: /eng/pipelines/common/platform-matrix.yml @@ -134,12 +139,13 @@ jobs: jobParameters: testGroup: perf runtimeType: iOSNativeAOT - projectFile: ios_scenarios.proj + projectFile: $(Build.SourcesDirectory)/eng/testing/performance/ios_scenarios.proj runKind: ios_scenarios runJobTemplate: /eng/pipelines/coreclr/templates/run-scenarios-job.yml logicalmachine: 'perfiphone12mini' iOSStripSymbols: False hybridGlobalization: ${{ parameters.hybridGlobalization }} + perfBranch: ${{ parameters.perfBranch }} - template: /eng/pipelines/common/platform-matrix.yml parameters: @@ -151,9 +157,10 @@ jobs: jobParameters: testGroup: perf runtimeType: iOSNativeAOT - projectFile: ios_scenarios.proj + projectFile: $(Build.SourcesDirectory)/eng/testing/performance/ios_scenarios.proj runKind: ios_scenarios runJobTemplate: /eng/pipelines/coreclr/templates/run-scenarios-job.yml logicalmachine: 'perfiphone12mini' iOSStripSymbols: True hybridGlobalization: ${{ parameters.hybridGlobalization }} + perfBranch: ${{ parameters.perfBranch }} diff --git a/eng/pipelines/coreclr/templates/build-perf-bdn-app.yml b/eng/pipelines/coreclr/templates/build-perf-bdn-app.yml index 8b02b739faf..e50bf8963b5 100644 --- a/eng/pipelines/coreclr/templates/build-perf-bdn-app.yml +++ b/eng/pipelines/coreclr/templates/build-perf-bdn-app.yml @@ -87,7 +87,7 @@ steps: curl -o NuGet.config 'https://raw.githubusercontent.com/dotnet/maui/${{parameters.framework}}/NuGet.config' curl -o dotnet-install.sh 'https://dotnet.microsoft.com/download/dotnet/scripts/v1/dotnet-install.sh' curl -Lo performance-version-details.xml 'https://raw.githubusercontent.com/dotnet/performance/${{parameters.perfBranch}}/eng/Version.Details.xml' - version=$(sed -nr 's/[[:space:]]*- - export RestoreAdditionalProjectSources=$HELIX_CORRELATION_PAYLOAD/built-nugets && - sudo apt-get -y remove nodejs && - sudo apt-get update && - sudo apt-get install -y ca-certificates curl gnupg && - sudo mkdir -p /etc/apt/keyrings && - sudo rm -f /etc/apt/keyrings/nodesource.gpg && - curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | sudo gpg --dearmor --batch -o /etc/apt/keyrings/nodesource.gpg && - export NODE_MAJOR=18 && - echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_$NODE_MAJOR.x nodistro main" | sudo tee /etc/apt/sources.list.d/nodesource.list && - sudo apt-get update && - sudo apt-get install nodejs -y && - test -n "$(V8Version)" && - npm install --prefix $HELIX_WORKITEM_PAYLOAD jsvu -g && - $HELIX_WORKITEM_PAYLOAD/bin/jsvu --os=linux64 v8@$(V8Version) && - export V8_ENGINE_PATH=~/.jsvu/bin/v8-$(V8Version) && - ${V8_ENGINE_PATH} -e 'console.log(`V8 version: ${this.version()}`)' - - ${{ if ne(parameters.runtimeType, 'wasm') }}: - - HelixPreCommandsWasmOnLinux: echo - - HelixPreCommandStemWindows: 'set ORIGPYPATH=%PYTHONPATH%;py -m pip install -U pip;py -3 -m venv %HELIX_WORKITEM_PAYLOAD%\.venv;call %HELIX_WORKITEM_PAYLOAD%\.venv\Scripts\activate.bat;echo on;set PYTHONPATH=;python -m pip install -U pip;python -m pip install urllib3==1.26.15;python -m pip install azure.storage.blob==12.13.0;python -m pip install azure.storage.queue==12.4.0;python -m pip install azure.identity==1.16.1;set "PERFLAB_UPLOAD_TOKEN=$(HelixPerfUploadTokenValue)"' - - HelixPreCommandStemLinux: >- - export ORIGPYPATH=$PYTHONPATH - export CRYPTOGRAPHY_ALLOW_OPENSSL_102=true; - echo "** Installing prerequistes **"; - echo "** Waiting for dpkg to unlock (up to 2 minutes) **" && - timeout 2m bash -c 'while sudo fuser /var/lib/dpkg/lock-frontend >/dev/null 2>&1; do if [ -z "$printed" ]; then echo "Waiting for dpkg lock to be released... Lock is held by: $(ps -o cmd= -p $(sudo fuser /var/lib/dpkg/lock-frontend))"; printed=1; fi; echo "Waiting 5 seconds to check again"; sleep 5; done;' && - sudo apt-get remove -y lttng-modules-dkms && - sudo apt-get -y install python3-pip && - python3 -m pip install --user -U pip && - sudo apt-get -y install python3-venv && - python3 -m venv $HELIX_WORKITEM_PAYLOAD/.venv && - ls -l $HELIX_WORKITEM_PAYLOAD/.venv/bin/activate && - export PYTHONPATH= && - python3 -m pip install --user -U pip && - pip3 install urllib3==1.26.15 && - pip3 install --user azure.storage.blob==12.13.0 && - pip3 install --user azure.storage.queue==12.4.0 && - pip3 install --user azure.identity==1.16.1 && - sudo apt-get update && - sudo apt -y install curl dirmngr apt-transport-https lsb-release ca-certificates && - $(HelixPreCommandsWasmOnLinux) && - export PERFLAB_UPLOAD_TOKEN="$(HelixPerfUploadTokenValue)" - || export PERF_PREREQS_INSTALL_FAILED=1; - test "x$PERF_PREREQS_INSTALL_FAILED" = "x1" && echo "** Error: Failed to install prerequites **" - - HelixPreCommandStemMusl: 'ulimit -n 4096;export ORIGPYPATH=$PYTHONPATH;sudo apk add icu-libs krb5-libs libgcc libintl libssl1.1 libstdc++ zlib cargo;sudo apk add libgdiplus --repository http://dl-cdn.alpinelinux.org/alpine/edge/testing; python3 -m venv $HELIX_WORKITEM_PAYLOAD/.venv;source $HELIX_WORKITEM_PAYLOAD/.venv/bin/activate;export PYTHONPATH=;python3 -m pip install -U pip;pip3 install urllib3==1.26.15;pip3 install azure.storage.blob==12.13.0;pip3 install azure.storage.queue==12.4.0;pip3 install azure.identity==1.16.1;export PERFLAB_UPLOAD_TOKEN="$(HelixPerfUploadTokenValue)"' - - ExtraMSBuildLogsWindows: 'set MSBUILDDEBUGCOMM=1;set "MSBUILDDEBUGPATH=%HELIX_WORKITEM_UPLOAD_ROOT%"' - - ExtraMSBuildLogsLinux: 'export MSBUILDDEBUGCOMM=1;export "MSBUILDDEBUGPATH=$HELIX_WORKITEM_UPLOAD_ROOT"' - - HelixPreCommand: '' - - HelixPostCommand: '' - - Interpreter: '' + - name: internalParam + value: '' - ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}: - - ${{ if eq( parameters.osGroup, 'windows') }}: - - HelixPreCommand: $(HelixPreCommandStemWindows);$(ExtraMSBuildLogsWindows) - - HelixPostCommand: 'set PYTHONPATH=%ORIGPYPATH%' - - IsInternal: -Internal - - ${{ if ne(parameters.osGroup, 'windows') }}: - - ${{ if eq(parameters.osSubGroup, '_musl') }}: - - HelixPreCommand: $(HelixPreCommandStemMusl);$(ExtraMSBuildLogsLinux) - - HelixPostCommand: 'export PYTHONPATH=$ORIGPYPATH' - - IsInternal: --internal - - ${{ if ne(parameters.osSubGroup, '_musl') }}: - - HelixPreCommand: $(HelixPreCommandStemLinux);$(ExtraMSBuildLogsLinux) - - HelixPostCommand: 'export PYTHONPATH=$ORIGPYPATH;${{ parameters.collectHelixLogsScript }}' - - IsInternal: --internal + - name: internalParam + value: --internal - group: DotNet-HelixApi-Access - group: dotnet-benchview - - ${{ if not(and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest'))) }}: - - ${{ if eq( parameters.osGroup, 'windows') }}: - - HelixPreCommand: $(HelixPreCommandStemWindows);$(ExtraMSBuildLogsWindows) - - HelixPostCommand: 'export PYTHONPATH=$ORIGPYPATH;${{ parameters.collectHelixLogsScript }}' - - ${{ if ne(parameters.osGroup, 'windows') }}: - - HelixPreCommand: $(HelixPreCommandStemLinux);$(ExtraMSBuildLogsLinux); - - HelixPostCommand: 'export PYTHONPATH=$ORIGPYPATH;${{ parameters.collectHelixLogsScript }}' - - - ${{ if and(eq(parameters.codeGenType, 'Interpreter'), eq(parameters.runtimeType, 'mono')) }}: - - ${{ if eq( parameters.osGroup, 'windows') }}: - - ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}: - - HelixPreCommand: '$(HelixPreCommandStemWindows);set MONO_ENV_OPTIONS="--interpreter";$(ExtraMSBuildLogsWindows)' - - Interpreter: ' -MonoInterpreter' - - ${{ if not(and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest'))) }}: - - HelixPreCommand: 'set MONO_ENV_OPTIONS="--interpreter";$(ExtraMSBuildLogsWindows)' - - Interpreter: ' -MonoInterpreter' - - ${{ if ne(parameters.osGroup, 'windows') }}: - - ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}: - - HelixPreCommand: '$(HelixPreCommandStemLinux);export MONO_ENV_OPTIONS="--interpreter";$(ExtraMSBuildLogsLinux)' - - Interpreter: ' --monointerpreter' - - ${{ if not(and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest'))) }}: - - HelixPreCommand: 'export MONO_ENV_OPTIONS="--interpreter";$(ExtraMSBuildLogsLinux)' - - Interpreter: ' --monointerpreter' - workspace: clean: all pool: @@ -172,28 +78,14 @@ jobs: _Framework: ${{ framework }} steps: - ${{ parameters.steps }} - - powershell: $(Build.SourcesDirectory)\eng\testing\performance\performance-setup.ps1 $(IsInternal)$(Interpreter) -Framework $(_Framework) -Kind ${{ parameters.runKind }} -LogicalMachine ${{ parameters.logicalMachine }} ${{ parameters.pgoRunType }} ${{ parameters.physicalPromotionRunType }} ${{ parameters.r2rRunType }} -ExperimentName '${{ parameters.experimentName }}' -UseLocalCommitTime ${{ parameters.extraSetupParameters }} - displayName: Performance Setup (Windows) - condition: and(succeeded(), eq(variables['Agent.Os'], 'Windows_NT')) - continueOnError: ${{ parameters.continueOnError }} - - script: $(Build.SourcesDirectory)/eng/testing/performance/performance-setup.sh $(IsInternal)$(Interpreter) --framework $(_Framework) --kind ${{ parameters.runKind }} --logicalmachine ${{ parameters.logicalMachine }} ${{ parameters.pgoRunType }} ${{ parameters.physicalPromotionRunType }} ${{ parameters.r2rRunType }} --experimentname '${{ parameters.experimentName }}' --uselocalcommittime ${{ parameters.extraSetupParameters }} - displayName: Performance Setup (Unix) - condition: and(succeeded(), ne(variables['Agent.Os'], 'Windows_NT')) - continueOnError: ${{ parameters.continueOnError }} - - script: $(Python) $(PerformanceDirectory)/scripts/ci_setup.py $(SetupArguments) ${{ parameters.additionalSetupParameters }} - displayName: Run ci setup script + - script: $(Python) $(Agent.BuildDirectory)/performance/scripts/run_performance_job.py --framework $(_Framework) $(internalParam) ${{ parameters.extraSetupParameters }} ${{ parameters.additionalSetupParameters }} + displayName: Run performance job script + env: + HelixAccessToken: '$(HelixApiAccessToken)' + PerfCommandUploadToken: '$(PerfCommandUploadToken)' + PerfCommandUploadTokenLinux: '$(PerfCommandUploadTokenLinux)' # Run perf testing in helix - template: /eng/pipelines/coreclr/templates/perf-send-to-helix.yml parameters: - HelixSource: '$(HelixSourcePrefix)/$(Build.Repository.Name)/$(Build.SourceBranch)' # sources must start with pr/, official/, prodcon/, or agent/ - HelixType: 'test/performance/$(Kind)/$(_Framework)/$(Architecture)${{ parameters.helixTypeSuffix }}' - HelixAccessToken: $(HelixApiAccessToken) - HelixTargetQueues: $(Queue) - HelixPreCommands: $(HelixPreCommand) - HelixPostCommands: $(HelixPostCommand) - Creator: $(Creator) - WorkItemTimeout: 4:00 # 4 hours - WorkItemDirectory: '$(WorkItemDirectory)' # WorkItemDirectory can not be empty, so we send it some docs to keep it happy - CorrelationPayloadDirectory: '$(PayloadDirectory)' # it gets checked out to a folder with shorter path than WorkItemDirectory so we can avoid file name too long exceptions ProjectFile: ${{ parameters.projectFile }} osGroup: ${{ parameters.osGroup }} diff --git a/eng/pipelines/coreclr/templates/run-scenarios-job.yml b/eng/pipelines/coreclr/templates/run-scenarios-job.yml index e58dd3586e7..2bb05f14835 100644 --- a/eng/pipelines/coreclr/templates/run-scenarios-job.yml +++ b/eng/pipelines/coreclr/templates/run-scenarios-job.yml @@ -48,62 +48,15 @@ jobs: - ${{ each variable in parameters.variables }}: - ${{insert}}: ${{ variable }} - - IsInternal: '' - - HelixApiAccessToken: '' - - SharedHelixPreCommands: '' - - AdditionalHelixPreCommands: '' - - AdditionalHelixPostCommands: '' - # run machine-setup and set PYTHONPATH for both public and private jobs - - ${{ if eq(parameters.osGroup, 'windows') }}: - - SharedHelixPreCommands: 'call %HELIX_WORKITEM_PAYLOAD%\machine-setup.cmd;set PYTHONPATH=%HELIX_WORKITEM_PAYLOAD%\scripts%3B%HELIX_WORKITEM_PAYLOAD%' - - ${{ if ne(parameters.osGroup, 'windows') }}: - - SharedHelixPreCommands: 'chmod +x $HELIX_WORKITEM_PAYLOAD/machine-setup.sh;. $HELIX_WORKITEM_PAYLOAD/machine-setup.sh;export PYTHONPATH=$HELIX_WORKITEM_PAYLOAD/scripts:$HELIX_WORKITEM_PAYLOAD' + - name: internalParam + value: '' - - ${{ if eq(parameters.osGroup, 'windows') }}: - - HelixPreCommandWindows: 'set ORIGPYPATH=%PYTHONPATH%;py -3 -m venv %HELIX_WORKITEM_PAYLOAD%\.venv;call %HELIX_WORKITEM_PAYLOAD%\.venv\Scripts\activate.bat;echo on;set PYTHONPATH=;python -m pip install -U pip;python -m pip install azure.storage.blob==12.13.0;python -m pip install azure.storage.queue==12.4.0;python -m pip install urllib3==1.26.15;python -m pip install azure.identity==1.16.1;set "PERFLAB_UPLOAD_TOKEN=$(PerfCommandUploadToken)"' - - HelixPostCommandsWindows: 'set PYTHONPATH=%ORIGPYPATH%' - - ${{ if and(ne(parameters.osGroup, 'windows'), ne(parameters.osGroup, 'osx'), ne(parameters.osSubGroup, '_musl')) }}: - - HelixPreCommandLinux: 'export ORIGPYPATH=$PYTHONPATH;export CRYPTOGRAPHY_ALLOW_OPENSSL_102=true;sudo apt-get -y install python3-venv;python3 -m venv $HELIX_WORKITEM_PAYLOAD/.venv;source $HELIX_WORKITEM_PAYLOAD/.venv/bin/activate;export PYTHONPATH=;python3 -m pip install -U pip;pip3 install azure.storage.blob==12.13.0;pip3 install azure.storage.queue==12.4.0;pip3 install azure.identity==1.16.1;pip3 install urllib3==1.26.15;export PERFLAB_UPLOAD_TOKEN="$(PerfCommandUploadTokenLinux)"' - - HelixPostCommandsLinux: 'export PYTHONPATH=$ORIGPYPATH' - - ${{ if and(ne(parameters.osGroup, 'windows'), ne(parameters.osGroup, 'osx'), eq(parameters.osSubGroup, '_musl')) }}: - - HelixPreCommandMusl: 'ulimit -n 4096;export ORIGPYPATH=$PYTHONPATH;sudo apk add py3-virtualenv;python3 -m venv $HELIX_WORKITEM_PAYLOAD/.venv;source $HELIX_WORKITEM_PAYLOAD/.venv/bin/activate;export PYTHONPATH=;python3 -m pip install -U pip;pip3 install azure.storage.blob==12.13.0;pip3 install azure.storage.queue==12.4.0;pip3 install azure.identity==1.16.1;pip3 install urllib3==1.26.15;export PERFLAB_UPLOAD_TOKEN="$(PerfCommandUploadTokenLinux)"' - - HelixPostCommandsMusl: 'export PYTHONPATH=$ORIGPYPATH' - - ${{ if eq(parameters.osGroup, 'osx') }}: - - HelixPreCommandOSX: 'export ORIGPYPATH=$PYTHONPATH;export CRYPTOGRAPHY_ALLOW_OPENSSL_102=true;python3 -m venv $HELIX_WORKITEM_PAYLOAD/.venv;source $HELIX_WORKITEM_PAYLOAD/.venv/bin/activate;export PYTHONPATH=;python3 -m pip install -U pip;pip3 install azure.storage.blob==12.13.0;pip3 install azure.storage.queue==12.4.0;pip3 install azure.identity==1.16.1;pip3 install urllib3==1.26.15;export PERFLAB_UPLOAD_TOKEN="$(PerfCommandUploadTokenLinux)"' - - HelixPostCommandOSX: 'export PYTHONPATH=$ORIGPYPATH' - - # extra private job settings - ${{ if and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest')) }}: - - ${{ if eq(parameters.osGroup, 'windows') }}: - - AdditionalHelixPreCommands: $(HelixPreCommandWindows) - - AdditionalHelixPostCommands: $(HelixPostCommandsWindows) - - IsInternal: -Internal - - ${{ if and(ne(parameters.osGroup, 'windows'), ne(parameters.osGroup, 'osx'), ne(parameters.osSubGroup, '_musl')) }}: - - AdditionalHelixPreCommands: $(HelixPreCommandLinux) - - AdditionalHelixPostCommands: $(HelixPostCommandsLinux) - - IsInternal: --internal - - ${{ if and(ne(parameters.osGroup, 'windows'), ne(parameters.osGroup, 'osx'), eq(parameters.osSubGroup, '_musl')) }}: - - AdditionalHelixPreCommands: $(HelixPreCommandMusl) - - AdditionalHelixPostCommands: $(HelixPostCommandsMusl) - - IsInternal: --internal - - ${{ if eq(parameters.osGroup, 'osx') }}: - - AdditionalHelixPreCommands: $(HelixPreCommandOSX) - - AdditionalHelixPostCommands: $(HelixPostCommandOSX) - - IsInternal: --internal + - name: internalParam + value: --internal - group: DotNet-HelixApi-Access - group: dotnet-benchview - - ${{ if not(and(ne(variables['System.TeamProject'], 'public'), notin(variables['Build.Reason'], 'PullRequest'))) }}: - - ${{ if eq(parameters.osGroup, 'windows') }}: - - AdditionalHelixPreCommands: $(HelixPreCommandWindows) - - AdditionalHelixPostCommands: $(HelixPostCommandsWindows) - - ${{ if and(ne(parameters.osGroup, 'windows'), ne(parameters.osGroup, 'osx')) }}: - - AdditionalHelixPreCommands: $(HelixPreCommandLinux) - - AdditionalHelixPostCommands: $(HelixPostCommandsLinux) - - ${{ if eq(parameters.osGroup, 'osx') }}: - - AdditionalHelixPreCommands: $(HelixPreCommandOSX) - - AdditionalHelixPostCommands: $(HelixPostCommandOSX) - - ExtraSetupArguments: '' - name: ExtraSetupArguments ${{ if ne(parameters.runtimeType, 'wasm') }}: @@ -125,23 +78,7 @@ jobs: _Framework: ${{ framework }} steps: - ${{ parameters.steps }} - # run performance-setup - - powershell: $(Build.SourcesDirectory)\eng\testing\performance\performance-setup.ps1 $(IsInternal) -Framework $(_Framework) -Kind ${{ parameters.runKind }} -LogicalMachine ${{ parameters.logicalMachine }} -UseLocalCommitTime ${{ parameters.extraSetupParameters }} ${{ parameters.additionalSetupParameters }} - displayName: Performance Setup (Windows) - condition: and(succeeded(), eq(variables['Agent.Os'], 'Windows_NT')) - continueOnError: ${{ parameters.continueOnError }} - - script: $(Build.SourcesDirectory)/eng/testing/performance/performance-setup.sh $(IsInternal) --framework $(_Framework) --kind ${{ parameters.runKind }} --logicalmachine ${{ parameters.logicalMachine }} --uselocalcommittime ${{ parameters.extraSetupParameters }} ${{ parameters.additionalSetupParameters }} - displayName: Performance Setup (Linux/MAC) - condition: and(succeeded(), ne(variables['Agent.Os'], 'Windows_NT')) - continueOnError: ${{ parameters.continueOnError }} - # run ci-setup - - script: $(Python) $(PerformanceDirectory)\scripts\ci_setup.py $(SetupArguments) $(ExtraSetupArguments) --output-file $(WorkItemDirectory)\machine-setup.cmd - displayName: Run ci setup script (Windows) - condition: and(succeeded(), eq(variables['Agent.Os'], 'Windows_NT')) - - script: $(Python) $(PerformanceDirectory)/scripts/ci_setup.py $(SetupArguments) $(ExtraSetupArguments) --output-file $(WorkItemDirectory)/machine-setup.sh - displayName: Run ci setup script (Linux/MAC) - condition: and(succeeded(), ne(variables['Agent.Os'], 'Windows_NT')) - # copy wasm packs if running on wasm + # copy wasm packs if running on wasm (TODO: move to run-performance-job.py) - script: >- mkdir -p $(librariesDownloadDir)/bin/wasm/data && cp -r $(librariesDownloadDir)/BrowserWasm/staging/dotnet-latest $(librariesDownloadDir)/bin/wasm && @@ -150,67 +87,16 @@ jobs: find $(librariesDownloadDir)/bin/wasm -type f -exec chmod 664 {} \; displayName: "Create wasm directory (Linux)" condition: and(succeeded(), eq('${{ parameters.runtimeType }}', 'wasm')) - # copy scenario support files - - script: xcopy $(PerformanceDirectory)\scripts $(WorkItemDirectory)\scripts\/e && xcopy $(PerformanceDirectory)\src\scenarios\shared $(WorkItemDirectory)\shared\/e && xcopy $(PerformanceDirectory)\src\scenarios\staticdeps $(WorkItemDirectory)\staticdeps\/e - displayName: Copy scenario support files (Windows) - condition: and(succeeded(), eq(variables['Agent.Os'], 'Windows_NT')) - - script: cp -r $(PerformanceDirectory)/scripts $(WorkItemDirectory)/scripts/ && cp -r $(PerformanceDirectory)/src/scenarios/shared $(WorkItemDirectory)/shared/ && cp -r $(PerformanceDirectory)/src/scenarios/staticdeps/ $(WorkItemDirectory)/staticdeps/ - displayName: Copy scenario support files (Linux/MAC) - condition: and(succeeded(), ne(variables['Agent.Os'], 'Windows_NT')) - # build Startup - - script: $(PayloadDirectory)\dotnet\dotnet.exe publish -c Release -o $(WorkItemDirectory)\Startup -f net8.0 -r win-$(Architecture) --self-contained $(PerformanceDirectory)\src\tools\ScenarioMeasurement\Startup\Startup.csproj -p:DisableTransitiveFrameworkReferenceDownloads=true - displayName: Build Startup tool (Windows) - env: - PERFLAB_TARGET_FRAMEWORKS: net8.0 - condition: and(succeeded(), eq(variables['Agent.Os'], 'Windows_NT')) - - script: $(PayloadDirectory)/dotnet/dotnet publish -c Release -o $(WorkItemDirectory)/startup -f net8.0 -r linux-$(Architecture) --self-contained $(PerformanceDirectory)/src/tools/ScenarioMeasurement/Startup/Startup.csproj -p:DisableTransitiveFrameworkReferenceDownloads=true - displayName: Build Startup tool (Linux) - env: - PERFLAB_TARGET_FRAMEWORKS: net8.0 - condition: and(succeeded(), eq(variables['Agent.Os'], 'Linux')) - - script: $(PayloadDirectory)/dotnet/dotnet publish -c Release -o $(WorkItemDirectory)/startup -f net8.0 -r osx-$(Architecture) --self-contained $(PerformanceDirectory)/src/tools/ScenarioMeasurement/Startup/Startup.csproj -p:DisableTransitiveFrameworkReferenceDownloads=true - displayName: Build Startup tool (MAC) + # run run-performance-job.py + - script: $(Python) $(Agent.BuildDirectory)/performance/scripts/run_performance_job.py --is-scenario --framework $(_Framework) $(internalParam) ${{ parameters.extraSetupParameters }} ${{ parameters.additionalSetupParameters }} + displayName: Run performance job script env: - PERFLAB_TARGET_FRAMEWORKS: net8.0 - condition: and(succeeded(), eq(variables['Agent.Os'], 'Darwin')) - # build SizeOnDisk - - script: $(PayloadDirectory)\dotnet\dotnet.exe publish -c Release -o $(WorkItemDirectory)\SOD -f net8.0 -r win-$(Architecture) --self-contained $(PerformanceDirectory)\src\tools\ScenarioMeasurement\SizeOnDisk\SizeOnDisk.csproj -p:DisableTransitiveFrameworkReferenceDownloads=true - displayName: Build SizeOnDisk tool (Windows) - env: - PERFLAB_TARGET_FRAMEWORKS: net8.0 - condition: and(succeeded(), eq(variables['Agent.Os'], 'Windows_NT')) - - script: $(PayloadDirectory)/dotnet/dotnet publish -c Release -o $(WorkItemDirectory)/SOD -f net8.0 -r linux-$(Architecture) --self-contained $(PerformanceDirectory)/src/tools/ScenarioMeasurement/SizeOnDisk/SizeOnDisk.csproj -p:DisableTransitiveFrameworkReferenceDownloads=true - displayName: Build SizeOnDisk tool (Linux) - env: - PERFLAB_TARGET_FRAMEWORKS: net8.0 - condition: and(succeeded(), eq(variables['Agent.Os'], 'Linux')) - - script: $(PayloadDirectory)/dotnet/dotnet publish -c Release -o $(WorkItemDirectory)/SOD -f net8.0 -r osx-$(Architecture) --self-contained $(PerformanceDirectory)/src/tools/ScenarioMeasurement/SizeOnDisk/SizeOnDisk.csproj -p:DisableTransitiveFrameworkReferenceDownloads=true - displayName: Build SizeOnDisk tool (MAC) - env: - PERFLAB_TARGET_FRAMEWORKS: net8.0 - condition: and(succeeded(), eq(variables['Agent.Os'], 'Darwin')) - - # Zip the workitem directory (for xharness (mobile) based workitems) - - ${{ if or(eq(parameters.runKind, 'android_scenarios'), eq(parameters.runKind, 'ios_scenarios')) }}: - - task: ArchiveFiles@2 - inputs: - rootFolderOrFile: '$(WorkItemDirectory)' - includeRootFolder: false - archiveFile: '$(WorkItemDirectory).zip' - verbose: True + HelixAccessToken: '$(HelixApiAccessToken)' + PerfCommandUploadToken: '$(PerfCommandUploadToken)' + PerfCommandUploadTokenLinux: '$(PerfCommandUploadTokenLinux)' # run perf testing in helix - template: /eng/pipelines/coreclr/templates/perf-send-to-helix.yml parameters: - HelixSource: '$(HelixSourcePrefix)/$(Build.Repository.Name)/$(Build.SourceBranch)' # sources must start with pr/, official/, prodcon/, or agent/ - HelixType: 'test/performance/$(Kind)/$(_Framework)/$(Architecture)' - HelixAccessToken: $(HelixApiAccessToken) - HelixTargetQueues: $(Queue) - HelixPreCommands: '$(AdditionalHelixPreCommands);$(SharedHelixPreCommands)' # $(HelixPreCommands) should follow $(AdditionalHelixPreCommands) because PYTHONPATH is cleared by the former - HelixPostCommands: $(AdditionalHelixPostCommands) - Creator: $(Creator) - WorkItemTimeout: 4:00 # 4 hours - WorkItemDirectory: '$(WorkItemDirectory)' # contains scenario tools, shared python scripts, dotnet tool - CorrelationPayloadDirectory: '$(PayloadDirectory)' # contains performance repo and built product ProjectFile: ${{ parameters.projectFile }} osGroup: ${{ parameters.osGroup }} diff --git a/eng/pipelines/coreclr/templates/run-superpmi-asmdiffs-checked-release-job.yml b/eng/pipelines/coreclr/templates/run-superpmi-asmdiffs-checked-release-job.yml index 6284c6fd689..b5c7996da95 100644 --- a/eng/pipelines/coreclr/templates/run-superpmi-asmdiffs-checked-release-job.yml +++ b/eng/pipelines/coreclr/templates/run-superpmi-asmdiffs-checked-release-job.yml @@ -9,6 +9,7 @@ parameters: archType: '' # required -- targeting CPU architecture osGroup: '' # required -- operating system for the job osSubgroup: '' # optional -- operating system subgroup + crossBuild: '' # optional -- 'true' if this is a cross-build continueOnError: 'false' # optional -- determines whether to continue the build if the step errors dependsOn: '' # optional -- dependencies of the job timeoutInMinutes: 320 # optional -- timeout for the job @@ -24,6 +25,7 @@ jobs: archType: ${{ parameters.archType }} osGroup: ${{ parameters.osGroup }} osSubgroup: ${{ parameters.osSubgroup }} + crossBuild: ${{ parameters.crossBuild }} liveLibrariesBuildConfig: ${{ parameters.liveLibrariesBuildConfig }} enableTelemetry: ${{ parameters.enableTelemetry }} enablePublishBuildArtifacts: true diff --git a/eng/pipelines/coreclr/templates/run-superpmi-collect-job.yml b/eng/pipelines/coreclr/templates/run-superpmi-collect-job.yml index 3ef32f30b2d..78ebc0a8089 100644 --- a/eng/pipelines/coreclr/templates/run-superpmi-collect-job.yml +++ b/eng/pipelines/coreclr/templates/run-superpmi-collect-job.yml @@ -9,6 +9,7 @@ parameters: archType: '' # required -- targeting CPU architecture osGroup: '' # required -- operating system for the job osSubgroup: '' # optional -- operating system subgroup + crossBuild: '' # optional -- 'true' if this is a cross-build continueOnError: 'false' # optional -- determines whether to continue the build if the step errors dependsOn: '' # optional -- dependencies of the job timeoutInMinutes: 320 # optional -- timeout for the job @@ -25,6 +26,8 @@ jobs: archType: ${{ parameters.archType }} osGroup: ${{ parameters.osGroup }} osSubgroup: ${{ parameters.osSubgroup }} + container: ${{ parameters.container }} + crossBuild: ${{ parameters.crossBuild }} liveLibrariesBuildConfig: ${{ parameters.liveLibrariesBuildConfig }} enableTelemetry: ${{ parameters.enableTelemetry }} enablePublishBuildArtifacts: true @@ -104,11 +107,16 @@ jobs: - name: InputDirectory value: '$(Build.SourcesDirectory)/artifacts/tests/coreclr/obj/${{ parameters.osGroup }}.${{ parameters.archType }}.$(buildConfigUpper)/Managed/nativeaot/SmokeTests' + - name: PublicQueuesCLIArg + ${{ if ne(variables['System.TeamProject'], 'internal') }}: + value: '-public_queues' + ${{ else }}: + value: '' + workspace: clean: all pool: ${{ parameters.pool }} - container: ${{ parameters.container }} steps: - ${{ parameters.steps }} @@ -116,7 +124,7 @@ jobs: displayName: Enable python venv condition: always() - - script: $(PythonScript) $(Build.SourcesDirectory)/src/coreclr/scripts/superpmi_collect_setup.py -payload_directory $(PayloadLocation) -source_directory $(Build.SourcesDirectory) -core_root_directory $(Core_Root_Dir) -arch $(archType) -platform $(osGroup) -mch_file_tag $(MchFileTag) -input_directory $(InputDirectory) -collection_name $(CollectionName) -collection_type $(CollectionType) -max_size 25 # size in MB + - script: $(PythonScript) $(Build.SourcesDirectory)/src/coreclr/scripts/superpmi_collect_setup.py -payload_directory $(PayloadLocation) -source_directory $(Build.SourcesDirectory) -core_root_directory $(Core_Root_Dir) -arch $(archType) -platform $(osGroup) -mch_file_tag $(MchFileTag) -input_directory $(InputDirectory) -collection_name $(CollectionName) -collection_type $(CollectionType) $(PublicQueuesCLIArg) -max_size 25 # size in MB displayName: ${{ format('SuperPMI setup ({0})', parameters.osGroup) }} # Create required directories for merged mch collection and superpmi logs @@ -139,7 +147,10 @@ jobs: HelixAccessToken: $(HelixApiAccessToken) HelixTargetQueues: $(Queue) HelixPreCommands: $(HelixPreCommand) - Creator: $(Creator) + + ${{ if ne(variables['System.TeamProject'], 'internal') }}: + Creator: $(Build.DefinitionName) + WorkItemTimeout: 4:00 # 4 hours WorkItemDirectory: '$(WorkItemDirectory)' CorrelationPayloadDirectory: '$(CorrelationPayloadDirectory)' @@ -170,25 +181,26 @@ jobs: artifactName: 'SuperPMI_Collection_$(CollectionName)_$(CollectionType)_$(osGroup)$(osSubgroup)_$(archType)_$(buildConfig)' displayName: ${{ format('Upload artifacts SuperPMI {0}-{1} collection', parameters.collectionName, parameters.collectionType) }} - # Add authenticated pip feed - - task: PipAuthenticate@1 - displayName: 'Pip Authenticate' - inputs: - artifactFeeds: public/dotnet-public-pypi - onlyAddExtraIndex: false - - # Ensure the Python azure-storage-blob package is installed before doing the upload. - - script: $(PipScript) install --upgrade pip && $(PipScript) install azure.storage.blob==12.5.0 --force-reinstall && $(PipScript) install azure.identity==1.16.1 --force-reinstall - displayName: Upgrade Pip to latest and install azure-storage-blob and azure-identity Python packages - - - task: AzureCLI@2 - displayName: ${{ format('Upload SuperPMI {0}-{1} collection to Azure Storage', parameters.collectionName, parameters.collectionType) }} - inputs: - azureSubscription: 'superpmi-collect-rw' - scriptType: 'pscore' - scriptLocation: 'inlineScript' - inlineScript: | - $(PythonScript) $(Build.SourcesDirectory)/src/coreclr/scripts/superpmi.py upload -log_level DEBUG -arch $(archType) -build_type $(buildConfig) -mch_files $(MergedMchFileLocation)$(CollectionName).$(CollectionType).$(MchFileTag).mch -core_root $(Build.SourcesDirectory)/artifacts/bin/coreclr/$(osGroup).x64.$(buildConfigUpper) + - ${{ if eq(variables['System.TeamProject'], 'internal') }}: + # Add authenticated pip feed + - task: PipAuthenticate@1 + displayName: 'Pip Authenticate' + inputs: + artifactFeeds: public/dotnet-public-pypi + onlyAddExtraIndex: false + + # Ensure the Python azure-storage-blob package is installed before doing the upload. + - script: $(PipScript) install --upgrade pip && $(PipScript) install azure.storage.blob==12.5.0 --force-reinstall && $(PipScript) install azure.identity==1.16.1 --force-reinstall + displayName: Upgrade Pip to latest and install azure-storage-blob and azure-identity Python packages + + - task: AzureCLI@2 + displayName: ${{ format('Upload SuperPMI {0}-{1} collection to Azure Storage', parameters.collectionName, parameters.collectionType) }} + inputs: + azureSubscription: 'superpmi-collect-rw' + scriptType: 'pscore' + scriptLocation: 'inlineScript' + inlineScript: | + $(PythonScript) $(Build.SourcesDirectory)/src/coreclr/scripts/superpmi.py upload -log_level DEBUG -arch $(archType) -build_type $(buildConfig) -mch_files $(MergedMchFileLocation)$(CollectionName).$(CollectionType).$(MchFileTag).mch -core_root $(Build.SourcesDirectory)/artifacts/bin/coreclr/$(osGroup).x64.$(buildConfigUpper) # Always upload the available logs for diagnostics - task: CopyFiles@2 diff --git a/eng/pipelines/coreclr/templates/run-superpmi-diffs-job.yml b/eng/pipelines/coreclr/templates/run-superpmi-diffs-job.yml index 2bca38b20b0..19a6f777804 100644 --- a/eng/pipelines/coreclr/templates/run-superpmi-diffs-job.yml +++ b/eng/pipelines/coreclr/templates/run-superpmi-diffs-job.yml @@ -9,6 +9,7 @@ parameters: archType: '' # required -- targeting CPU architecture osGroup: '' # required -- operating system for the job osSubgroup: '' # optional -- operating system subgroup + crossBuild: '' # optional -- 'true' if this is a cross-build continueOnError: 'false' # optional -- determines whether to continue the build if the step errors dependsOn: '' # optional -- dependencies of the job timeoutInMinutes: 180 # optional -- timeout for the job @@ -27,6 +28,7 @@ jobs: archType: ${{ parameters.archType }} osGroup: ${{ parameters.osGroup }} osSubgroup: ${{ parameters.osSubgroup }} + crossBuild: ${{ parameters.crossBuild }} liveLibrariesBuildConfig: ${{ parameters.liveLibrariesBuildConfig }} enableTelemetry: ${{ parameters.enableTelemetry }} enablePublishBuildArtifacts: true @@ -144,10 +146,10 @@ jobs: condition: always() - task: CopyFiles@2 - displayName: Copying superpmi.md of all partitions + displayName: Copying superpmi.json of all partitions inputs: sourceFolder: '$(HelixResultLocation)' - contents: '**/superpmi_*.md' + contents: '**/superpmi_*.json' targetFolder: '$(SpmiDiffsLocation)' condition: always() @@ -160,7 +162,7 @@ jobs: targetFolder: '$(SpmiDiffsLocation)' condition: always() - - script: $(PythonScript) $(Build.SourcesDirectory)/src/coreclr/scripts/superpmi_diffs_summarize.py -diff_summary_dir $(SpmiDiffsLocation) -type $(diffType) -platform $(osGroup) -arch $(archType) + - script: $(PythonScript) $(Build.SourcesDirectory)/src/coreclr/scripts/superpmi_diffs_summarize.py -source_directory $(Build.SourcesDirectory) -diff_summary_dir $(SpmiDiffsLocation) -type $(diffType) -platform $(osGroup) -arch $(archType) displayName: ${{ format('Summarize ({0} {1}{2} {3})', parameters.diffType, parameters.osGroup, parameters.osSubgroup, parameters.archType) }} condition: always() diff --git a/eng/pipelines/coreclr/templates/run-superpmi-replay-job.yml b/eng/pipelines/coreclr/templates/run-superpmi-replay-job.yml index b8907cfc560..4047a8cb2f7 100644 --- a/eng/pipelines/coreclr/templates/run-superpmi-replay-job.yml +++ b/eng/pipelines/coreclr/templates/run-superpmi-replay-job.yml @@ -9,6 +9,7 @@ parameters: archType: '' # required -- targeting CPU architecture osGroup: '' # required -- operating system for the job osSubgroup: '' # optional -- operating system subgroup + crossBuild: '' # optional -- 'true' if this is a cross-build continueOnError: 'false' # optional -- determines whether to continue the build if the step errors dependsOn: '' # optional -- dependencies of the job timeoutInMinutes: 320 # optional -- timeout for the job @@ -24,6 +25,7 @@ jobs: archType: ${{ parameters.archType }} osGroup: ${{ parameters.osGroup }} osSubgroup: ${{ parameters.osSubgroup }} + crossBuild: ${{ parameters.crossBuild }} liveLibrariesBuildConfig: ${{ parameters.liveLibrariesBuildConfig }} enableTelemetry: ${{ parameters.enableTelemetry }} enablePublishBuildArtifacts: true diff --git a/eng/pipelines/coreclr/templates/superpmi-collect-job.yml b/eng/pipelines/coreclr/templates/superpmi-collect-job.yml index 6af16c3db87..0f33e1d29b3 100644 --- a/eng/pipelines/coreclr/templates/superpmi-collect-job.yml +++ b/eng/pipelines/coreclr/templates/superpmi-collect-job.yml @@ -3,7 +3,9 @@ parameters: archType: '' osGroup: '' osSubgroup: '' + container: '' liveLibrariesBuildConfig: '' + crossBuild: '' variables: {} pool: '' runJobTemplate: '/eng/pipelines/coreclr/templates/run-superpmi-collect-job.yml' @@ -24,6 +26,8 @@ jobs: archType: ${{ parameters.archType }} osGroup: ${{ parameters.osGroup }} osSubgroup: ${{ parameters.osSubgroup }} + container: ${{ parameters.container }} + crossBuild: ${{ parameters.crossBuild }} liveLibrariesBuildConfig: ${{ parameters.liveLibrariesBuildConfig }} collectionType: ${{ parameters.collectionType }} collectionName: ${{ parameters.collectionName }} @@ -33,7 +37,16 @@ jobs: - ${{ if eq(parameters.collectionName, 'coreclr_tests') }}: - 'coreclr_common_test_build_p1_AnyOS_AnyCPU_${{parameters.buildConfig }}' - variables: ${{ parameters.variables }} + variables: + + - name: crossArg + value: '' + - ${{ if eq(parameters.crossBuild, true) }}: + - name: crossArg + value: '-cross' + + - ${{ each variable in parameters.variables }}: + - ${{insert}}: ${{ variable }} steps: # Extra steps that will be passed to the superpmi template and run before sending the job to helix (all of which is done in the template) @@ -72,6 +85,6 @@ jobs: displayName: 'generic managed test artifacts' # Create Core_Root - - script: $(Build.SourcesDirectory)/src/tests/build$(scriptExt) $(buildConfig) $(archType) generatelayoutonly $(librariesOverrideArg) + - script: $(Build.SourcesDirectory)/src/tests/build$(scriptExt) $(buildConfig) $(archType) $(crossArg) generatelayoutonly $(librariesOverrideArg) /p:UsePublishedCrossgen2=false displayName: Create Core_Root condition: succeeded() diff --git a/eng/pipelines/coreclr/templates/superpmi-send-to-helix.yml b/eng/pipelines/coreclr/templates/superpmi-send-to-helix.yml index 2a85d76c078..daed124df41 100644 --- a/eng/pipelines/coreclr/templates/superpmi-send-to-helix.yml +++ b/eng/pipelines/coreclr/templates/superpmi-send-to-helix.yml @@ -35,6 +35,7 @@ steps: condition: ${{ parameters.condition }} shouldContinueOnError: ${{ parameters.continueOnError }} environment: + _Creator: ${{ parameters.Creator }} TargetOS: ${{ parameters.osGroup }} TargetArchitecture: ${{ parameters.archType }} MchFileTag: $(MchFileTag) @@ -56,5 +57,4 @@ steps: DotNetCliVersion: ${{ parameters.DotNetCliVersion }} EnableXUnitReporter: ${{ parameters.EnableXUnitReporter }} WaitForWorkItemCompletion: ${{ parameters.WaitForWorkItemCompletion }} - Creator: ${{ parameters.Creator }} SYSTEM_ACCESSTOKEN: $(System.AccessToken) diff --git a/eng/pipelines/extra-platforms/runtime-extra-platforms-ioslike.yml b/eng/pipelines/extra-platforms/runtime-extra-platforms-ioslike.yml index 9794c736e2e..ab081b2c3c4 100644 --- a/eng/pipelines/extra-platforms/runtime-extra-platforms-ioslike.yml +++ b/eng/pipelines/extra-platforms/runtime-extra-platforms-ioslike.yml @@ -165,3 +165,4 @@ jobs: creator: dotnet-bot testBuildArgs: tree nativeaot/SmokeTests /p:BuildNativeAOTRuntimePack=true testRunNamePrefixSuffix: NativeAOT_$(_BuildConfig) + buildAllTestsAsStandalone: true diff --git a/eng/pipelines/extra-platforms/runtime-extra-platforms-ioslikesimulator.yml b/eng/pipelines/extra-platforms/runtime-extra-platforms-ioslikesimulator.yml index 7ce0a0c3568..714acd5b9c1 100644 --- a/eng/pipelines/extra-platforms/runtime-extra-platforms-ioslikesimulator.yml +++ b/eng/pipelines/extra-platforms/runtime-extra-platforms-ioslikesimulator.yml @@ -139,3 +139,4 @@ jobs: creator: dotnet-bot testBuildArgs: tree nativeaot/SmokeTests /p:BuildNativeAOTRuntimePack=true testRunNamePrefixSuffix: NativeAOT_$(_BuildConfig) + buildAllTestsAsStandalone: true diff --git a/eng/pipelines/extra-platforms/runtime-extra-platforms-maccatalyst.yml b/eng/pipelines/extra-platforms/runtime-extra-platforms-maccatalyst.yml index 8c9d16d9701..3eac90bcf95 100644 --- a/eng/pipelines/extra-platforms/runtime-extra-platforms-maccatalyst.yml +++ b/eng/pipelines/extra-platforms/runtime-extra-platforms-maccatalyst.yml @@ -112,6 +112,7 @@ jobs: - template: /eng/pipelines/common/templates/runtimes/build-runtime-tests-and-send-to-helix.yml parameters: creator: dotnet-bot + buildAllTestsAsStandalone: true testBuildArgs: tree nativeaot/SmokeTests /p:BuildNativeAOTRuntimePack=true testRunNamePrefixSuffix: NativeAOT_$(_BuildConfig) @@ -149,5 +150,6 @@ jobs: - template: /eng/pipelines/common/templates/runtimes/build-runtime-tests-and-send-to-helix.yml parameters: creator: dotnet-bot + buildAllTestsAsStandalone: true testBuildArgs: tree nativeaot/SmokeTests /p:BuildNativeAOTRuntimePack=true /p:DevTeamProvisioning=adhoc /p:EnableAppSandbox=true testRunNamePrefixSuffix: NativeAOT_$(_BuildConfig) diff --git a/eng/pipelines/global-build.yml b/eng/pipelines/global-build.yml index 24962a6b65f..d86d5727e73 100644 --- a/eng/pipelines/global-build.yml +++ b/eng/pipelines/global-build.yml @@ -82,7 +82,7 @@ extends: eq(variables['isRollingBuild'], true)) # - # Build Libraries AllConfigurations. This exercises the code path where we build libraries for all + # Build Libraries AllConfigurations. This exercises the code path where we build libraries and tests for all # configurations on a non Windows operating system. # - template: /eng/pipelines/common/platform-matrix.yml @@ -93,7 +93,7 @@ extends: - linux_x64_dev_innerloop jobParameters: nameSuffix: Libraries_AllConfigurations - buildArgs: -subset libs -allconfigurations + buildArgs: -subset libs+libs.tests -allconfigurations timeoutInMinutes: 120 condition: or( @@ -126,5 +126,5 @@ extends: parameters: platforms: - name: Linux_x64 - targetRid: linux-x64 + targetRID: linux-x64 container: SourceBuild_linux_x64 diff --git a/eng/pipelines/libraries/fuzzing/deploy-to-onefuzz.yml b/eng/pipelines/libraries/fuzzing/deploy-to-onefuzz.yml index 276cc50f97d..49e7e517d9c 100644 --- a/eng/pipelines/libraries/fuzzing/deploy-to-onefuzz.yml +++ b/eng/pipelines/libraries/fuzzing/deploy-to-onefuzz.yml @@ -65,6 +65,14 @@ extends: # displayName: Send to OneFuzz # ONEFUZZ_TASK_WORKAROUND_START + - task: onefuzz-task@0 + inputs: + onefuzzOSes: 'Windows' + env: + onefuzzDropDirectory: $(fuzzerProject)/deployment/AssemblyNameInfoFuzzer + SYSTEM_ACCESSTOKEN: $(System.AccessToken) + displayName: Send AssemblyNameInfoFuzzer to OneFuzz + - task: onefuzz-task@0 inputs: onefuzzOSes: 'Windows' @@ -73,6 +81,14 @@ extends: SYSTEM_ACCESSTOKEN: $(System.AccessToken) displayName: Send Base64Fuzzer to OneFuzz + - task: onefuzz-task@0 + inputs: + onefuzzOSes: 'Windows' + env: + onefuzzDropDirectory: $(fuzzerProject)/deployment/Base64UrlFuzzer + SYSTEM_ACCESSTOKEN: $(System.AccessToken) + displayName: Send Base64UrlFuzzer to OneFuzz + - task: onefuzz-task@0 inputs: onefuzzOSes: 'Windows' @@ -89,6 +105,14 @@ extends: SYSTEM_ACCESSTOKEN: $(System.AccessToken) displayName: Send JsonDocumentFuzzer to OneFuzz + - task: onefuzz-task@0 + inputs: + onefuzzOSes: 'Windows' + env: + onefuzzDropDirectory: $(fuzzerProject)/deployment/NrbfDecoderFuzzer + SYSTEM_ACCESSTOKEN: $(System.AccessToken) + displayName: Send NrbfDecoderFuzzer to OneFuzz + - task: onefuzz-task@0 inputs: onefuzzOSes: 'Windows' @@ -113,6 +137,14 @@ extends: SYSTEM_ACCESSTOKEN: $(System.AccessToken) displayName: Send TextEncodingFuzzer to OneFuzz + - task: onefuzz-task@0 + inputs: + onefuzzOSes: 'Windows' + env: + onefuzzDropDirectory: $(fuzzerProject)/deployment/TypeNameFuzzer + SYSTEM_ACCESSTOKEN: $(System.AccessToken) + displayName: Send TypeNameFuzzer to OneFuzz + - task: onefuzz-task@0 inputs: onefuzzOSes: 'Windows' diff --git a/eng/pipelines/libraries/helix-queues-setup.yml b/eng/pipelines/libraries/helix-queues-setup.yml index 3d4185b9338..5b660a70bf7 100644 --- a/eng/pipelines/libraries/helix-queues-setup.yml +++ b/eng/pipelines/libraries/helix-queues-setup.yml @@ -68,6 +68,7 @@ jobs: - Ubuntu.2204.Amd64.Open - (Debian.11.Amd64.Open)Ubuntu.2204.Amd64.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:debian-11-helix-amd64 - (Mariner.2.0.Amd64.Open)Ubuntu.2204.Amd64.open@mcr.microsoft.com/dotnet-buildtools/prereqs:cbl-mariner-2.0-helix-amd64 + - (AzureLinux.3.0.Amd64.Open)Ubuntu.2204.Amd64.open@mcr.microsoft.com/dotnet-buildtools/prereqs:azurelinux-3.0-helix-amd64 - (openSUSE.15.2.Amd64.Open)Ubuntu.2204.Amd64.open@mcr.microsoft.com/dotnet-buildtools/prereqs:opensuse-15.2-helix-amd64 - ${{ if or(ne(parameters.jobParameters.isExtraPlatformsBuild, true), eq(parameters.jobParameters.includeAllPlatforms, true)) }}: - (Centos.8.Amd64.Open)Ubuntu.2204.Amd64.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:centos-stream8-helix diff --git a/eng/pipelines/libraries/stress/http.yml b/eng/pipelines/libraries/stress/http.yml index ee772d0da0e..3290eda51ae 100644 --- a/eng/pipelines/libraries/stress/http.yml +++ b/eng/pipelines/libraries/stress/http.yml @@ -12,6 +12,7 @@ schedules: include: - main - release/8.0 + - release/9.0 variables: - template: ../variables.yml @@ -99,7 +100,10 @@ extends: displayName: Docker NanoServer timeoutInMinutes: 150 variables: - DUMPS_SHARE_MOUNT_ROOT: "C:/dumps-share" + # This will get assigned to the DUMPS_SHARE_MOUNT_ROOT environment + # variable in the stress test script. We need to keep the + # DUMPS_SHARE_MOUNT_ROOT variable empty during the build step. + DUMPS_SHARE_MOUNT_ROOT_PATH: "C:/dumps-share" # The 1es-windows-2022-open image has an issue where the Chocolatey-installed V1 docker-compose takes precendence over the # V2 docker-compose required by the stress tests, see: https://github.com/actions/runner-images/issues/7080 @@ -140,6 +144,7 @@ extends: - powershell: | cd '$(httpStressProject)' + $env:DUMPS_SHARE_MOUNT_ROOT = $env:DUMPS_SHARE_MOUNT_ROOT_PATH $env:CLIENT_DUMPS_SHARE="$(Build.ArtifactStagingDirectory)/dumps/client/3.0" $env:SERVER_DUMPS_SHARE="$(Build.ArtifactStagingDirectory)/dumps/server/3.0" New-Item -Force $env:CLIENT_DUMPS_SHARE -ItemType Directory @@ -152,6 +157,7 @@ extends: - powershell: | cd '$(httpStressProject)' + $env:DUMPS_SHARE_MOUNT_ROOT = $env:DUMPS_SHARE_MOUNT_ROOT_PATH $env:CLIENT_DUMPS_SHARE="$(Build.ArtifactStagingDirectory)/dumps/client/2.0" $env:SERVER_DUMPS_SHARE="$(Build.ArtifactStagingDirectory)/dumps/server/2.0" New-Item -Force $env:CLIENT_DUMPS_SHARE -ItemType Directory @@ -164,6 +170,7 @@ extends: - powershell: | cd '$(httpStressProject)' + $env:DUMPS_SHARE_MOUNT_ROOT = $env:DUMPS_SHARE_MOUNT_ROOT_PATH $env:CLIENT_DUMPS_SHARE="$(Build.ArtifactStagingDirectory)/dumps/client/1.1" $env:SERVER_DUMPS_SHARE="$(Build.ArtifactStagingDirectory)/dumps/server/1.1" New-Item -Force $env:CLIENT_DUMPS_SHARE -ItemType Directory diff --git a/eng/pipelines/libraries/stress/ssl.yml b/eng/pipelines/libraries/stress/ssl.yml index 602e5bcf73d..230a2bef377 100644 --- a/eng/pipelines/libraries/stress/ssl.yml +++ b/eng/pipelines/libraries/stress/ssl.yml @@ -12,6 +12,7 @@ schedules: include: - main - release/8.0 + - release/9.0 variables: - template: ../variables.yml diff --git a/eng/pipelines/libraries/superpmi-postprocess-step.yml b/eng/pipelines/libraries/superpmi-postprocess-step.yml index 343cb1ee58c..5ee73194e46 100644 --- a/eng/pipelines/libraries/superpmi-postprocess-step.yml +++ b/eng/pipelines/libraries/superpmi-postprocess-step.yml @@ -57,28 +57,29 @@ steps: displayName: 'Upload artifacts SuperPMI ${{ parameters.SuperPmiCollectionName }}-${{ parameters.SuperPmiCollectionType }} collection' condition: always() - # Add authenticated pip feed - - task: PipAuthenticate@1 - displayName: 'Pip Authenticate' - inputs: - artifactFeeds: public/dotnet-public-pypi - onlyAddExtraIndex: false - condition: always() + - ${{ if eq(variables['System.TeamProject'], 'internal') }}: + # Add authenticated pip feed + - task: PipAuthenticate@1 + displayName: 'Pip Authenticate' + inputs: + artifactFeeds: public/dotnet-public-pypi + onlyAddExtraIndex: false + condition: always() - # Ensure the Python azure-storage-blob package is installed before doing the upload. - - script: ${{ parameters.PipScript }} install --upgrade pip && ${{ parameters.PipScript }} install azure.storage.blob==12.5.0 --force-reinstall && ${{ parameters.PipScript }} install azure.identity==1.16.1 --force-reinstall - displayName: Upgrade Pip to latest and install azure-storage-blob and azure-identity Python packages - condition: always() + # Ensure the Python azure-storage-blob package is installed before doing the upload. + - script: ${{ parameters.PipScript }} install --upgrade pip && ${{ parameters.PipScript }} install azure.storage.blob==12.5.0 --force-reinstall && ${{ parameters.PipScript }} install azure.identity==1.16.1 --force-reinstall + displayName: Upgrade Pip to latest and install azure-storage-blob and azure-identity Python packages + condition: always() - - task: AzureCLI@2 - displayName: 'Upload SuperPMI ${{ parameters.SuperPmiCollectionName }}-${{ parameters.SuperPmiCollectionType }} collection to Azure Storage' - inputs: - azureSubscription: 'superpmi-collect-rw' - scriptType: 'pscore' - scriptLocation: 'inlineScript' - inlineScript: | - ${{ parameters.PythonScript }} $(Build.SourcesDirectory)/src/coreclr/scripts/superpmi.py upload -log_level DEBUG -arch ${{ parameters.archType }} -build_type ${{ parameters.buildConfig }} -mch_files ${{ parameters.MergedMchFileLocation }}${{ parameters.SuperPmiCollectionName }}.${{ parameters.SuperPmiCollectionType }}.${{ parameters.osGroup }}.${{ parameters.archType }}.${{ parameters.buildConfig }}.mch -core_root $(Build.SourcesDirectory)/artifacts/bin/coreclr/${{ parameters.osGroup }}.x64.${{ parameters.buildConfigUpper }} - condition: always() + - task: AzureCLI@2 + displayName: 'Upload SuperPMI ${{ parameters.SuperPmiCollectionName }}-${{ parameters.SuperPmiCollectionType }} collection to Azure Storage' + inputs: + azureSubscription: 'superpmi-collect-rw' + scriptType: 'pscore' + scriptLocation: 'inlineScript' + inlineScript: | + ${{ parameters.PythonScript }} $(Build.SourcesDirectory)/src/coreclr/scripts/superpmi.py upload -log_level DEBUG -arch ${{ parameters.archType }} -build_type ${{ parameters.buildConfig }} -mch_files ${{ parameters.MergedMchFileLocation }}${{ parameters.SuperPmiCollectionName }}.${{ parameters.SuperPmiCollectionType }}.${{ parameters.osGroup }}.${{ parameters.archType }}.${{ parameters.buildConfig }}.mch -core_root $(Build.SourcesDirectory)/artifacts/bin/coreclr/${{ parameters.osGroup }}.x64.${{ parameters.buildConfigUpper }} + condition: always() - task: CopyFiles@2 displayName: Copying superpmi.log of all partitions diff --git a/eng/pipelines/runtime-llvm.yml b/eng/pipelines/runtime-llvm.yml index 5be2a5b063a..16c337b406d 100644 --- a/eng/pipelines/runtime-llvm.yml +++ b/eng/pipelines/runtime-llvm.yml @@ -144,7 +144,7 @@ extends: nameSuffix: AllSubsets_Mono_LLVMFULLAOT_RuntimeTests runtimeVariant: llvmfullaot buildArgs: -s mono+libs+clr.hosts+clr.iltools -c $(_BuildConfig) /p:MonoEnableLLVM=true - timeoutInMinutes: 360 + timeoutInMinutes: 400 condition: >- or( eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true), @@ -191,7 +191,7 @@ extends: nameSuffix: AllSubsets_Mono_LLVMFULLAOT_RuntimeIntrinsicsTests runtimeVariant: llvmfullaot buildArgs: -s mono+libs+clr.hosts+clr.iltools -c $(_BuildConfig) /p:MonoEnableLLVM=true - timeoutInMinutes: 360 + timeoutInMinutes: 400 condition: >- or( eq(stageDependencies.EvaluatePaths.evaluate_paths.outputs['SetPathVars_libraries.containsChange'], true), diff --git a/eng/pipelines/runtime-official.yml b/eng/pipelines/runtime-official.yml index 4cac3562967..55021be6e29 100644 --- a/eng/pipelines/runtime-official.yml +++ b/eng/pipelines/runtime-official.yml @@ -41,12 +41,13 @@ extends: # Localization build # - - template: /eng/common/templates-official/job/onelocbuild.yml - parameters: - MirrorRepo: runtime - MirrorBranch: main - LclSource: lclFilesfromPackage - LclPackageId: 'LCL-JUNO-PROD-RUNTIME' + - ${{ if eq(variables['Build.SourceBranch'], 'refs/heads/release/9.0') }}: + - template: /eng/common/templates-official/job/onelocbuild.yml + parameters: + MirrorRepo: runtime + MirrorBranch: release/9.0 + LclSource: lclFilesfromPackage + LclPackageId: 'LCL-JUNO-PROD-RUNTIME' # # Source Index Build @@ -574,7 +575,7 @@ extends: parameters: platforms: - name: Linux_x64 - targetRid: linux-x64 + targetRID: linux-x64 container: SourceBuild_linux_x64 # diff --git a/eng/pipelines/runtime-wasm-perf.yml b/eng/pipelines/runtime-wasm-perf.yml index 39645a501ec..b07b6197733 100644 --- a/eng/pipelines/runtime-wasm-perf.yml +++ b/eng/pipelines/runtime-wasm-perf.yml @@ -2,6 +2,12 @@ # wasm jobs. This file is essentially so we can point the pipeline in azdo # UI to this, and thus avoid any scheduled triggers +parameters: +- name: perfBranch + displayName: Performance Repo Branch + type: string + default: 'main' + trigger: none pr: @@ -32,9 +38,7 @@ extends: runProfile: 'v8' collectHelixLogsScript: ${{ variables._wasmCollectHelixLogsScript }} onlySanityCheck: true - #perfForkToUse: # dummy change - #url: https://github.com/radical/performance - #branch: fix-build + perfBranch: ${{ parameters.perfBranch }} #downloadSpecificBuild: #buildId: '1878694' #pipeline: 'perf-wasm' diff --git a/eng/pipelines/runtime.yml b/eng/pipelines/runtime.yml index 7b4cfdb92cd..8426c37b206 100644 --- a/eng/pipelines/runtime.yml +++ b/eng/pipelines/runtime.yml @@ -870,6 +870,7 @@ extends: - browser_wasm - browser_wasm_win - wasi_wasm + - wasi_wasm_win nameSuffix: _Smoke_AOT runAOT: true shouldRunSmokeOnly: true @@ -1857,11 +1858,11 @@ extends: parameters: platforms: - name: CentOS8 - targetRid: centos.8-x64 + targetRID: centos.8-x64 nonPortable: true container: SourceBuild_centos_x64 - name: NonexistentRID baseOS: linux - targetRid: banana.24-x64 + targetRID: banana.24-x64 nonPortable: true container: SourceBuild_centos_x64 diff --git a/eng/pipelines/runtimelab/runtimelab-post-build-steps.yml b/eng/pipelines/runtimelab/runtimelab-post-build-steps.yml index e84634cd006..5b1887c9aff 100644 --- a/eng/pipelines/runtimelab/runtimelab-post-build-steps.yml +++ b/eng/pipelines/runtimelab/runtimelab-post-build-steps.yml @@ -31,27 +31,27 @@ steps: - ${{ if eq(parameters.platform, 'browser_wasm_win') }}: - script: | call $(Build.SourcesDirectory)\wasm-tools\emsdk\emsdk_env - $(Build.SourcesDirectory)/src/tests/build$(scriptExt) nativeaot $(buildConfigUpper) ${{ parameters.archType }} tree nativeaot /p:LibrariesConfiguration=${{ parameters.librariesConfiguration }} + $(Build.SourcesDirectory)/src/tests/build$(scriptExt) nativeaot $(buildConfigUpper) ${{ parameters.archType }} $(crossArg) tree nativeaot /p:LibrariesConfiguration=${{ parameters.librariesConfiguration }} displayName: Build WebAssembly tests - ${{ elseif eq(parameters.platform, 'wasi_wasm_win') }}: - script: | - $(Build.SourcesDirectory)/src/tests/build$(scriptExt) nativeaot $(buildConfigUpper) ${{ parameters.archType }} wasi tree nativeaot /p:LibrariesConfiguration=${{ parameters.librariesConfiguration }} + $(Build.SourcesDirectory)/src/tests/build$(scriptExt) nativeaot $(buildConfigUpper) ${{ parameters.archType }} $(crossArg) wasi tree nativeaot /p:LibrariesConfiguration=${{ parameters.librariesConfiguration }} displayName: Build WebAssembly tests - ${{ elseif eq(parameters.platform, 'Browser_wasm_linux_x64_naot_llvm') }}: - script: | source $(Build.SourcesDirectory)/wasm-tools/emsdk/emsdk_env.sh - $(Build.SourcesDirectory)/src/tests/build$(scriptExt) nativeaot $(buildConfigUpper) -browser tree nativeaot /p:LibrariesConfiguration=${{ parameters.librariesConfiguration }} + $(Build.SourcesDirectory)/src/tests/build$(scriptExt) nativeaot $(buildConfigUpper) $(crossArg) -browser tree nativeaot /p:LibrariesConfiguration=${{ parameters.librariesConfiguration }} displayName: Build WebAssembly tests - ${{ elseif eq(parameters.platform, 'wasi_wasm_linux_x64_naot_llvm') }}: - script: | - $(Build.SourcesDirectory)/src/tests/build$(scriptExt) nativeaot $(buildConfigUpper) -wasi tree nativeaot /p:LibrariesConfiguration=${{ parameters.librariesConfiguration }} + $(Build.SourcesDirectory)/src/tests/build$(scriptExt) nativeaot $(buildConfigUpper) $(crossArg) -wasi tree nativeaot /p:LibrariesConfiguration=${{ parameters.librariesConfiguration }} displayName: Build WebAssembly tests - ${{ elseif eq(parameters.osGroup, 'windows') }}: - - script: $(Build.SourcesDirectory)/src/tests/build$(scriptExt) nativeaot $(buildConfigUpper) ${{ parameters.archType }} ${{ parameters.testFilter }} /p:NativeAotMultimodule=true /p:LibrariesConfiguration=${{ parameters.librariesConfiguration }} + - script: $(Build.SourcesDirectory)/src/tests/build$(scriptExt) nativeaot $(buildConfigUpper) ${{ parameters.archType }} $(crossArg) ${{ parameters.testFilter }} /p:NativeAotMultimodule=true /p:LibrariesConfiguration=${{ parameters.librariesConfiguration }} displayName: Build tests - ${{ else }}: - - script: $(Build.SourcesDirectory)/src/tests/build$(scriptExt) nativeaot $(buildConfigUpper) ${{ parameters.archType }} 'tree nativeaot' /p:LibrariesConfiguration=${{ parameters.librariesConfiguration }} + - script: $(Build.SourcesDirectory)/src/tests/build$(scriptExt) nativeaot $(buildConfigUpper) ${{ parameters.archType }} $(crossArg) 'tree nativeaot' /p:LibrariesConfiguration=${{ parameters.librariesConfiguration }} displayName: Build tests - ${{ if in(parameters.platform, 'browser_wasm_win', 'wasi_wasm_win') }}: diff --git a/eng/references.targets b/eng/references.targets index d54606f17ab..2b0035d3054 100644 --- a/eng/references.targets +++ b/eng/references.targets @@ -39,7 +39,7 @@ + Condition="$(NetCoreAppLibrary.Contains('%(Filename);')) and '%(ProjectReferenceWithConfiguration.Private)' == ''" /> diff --git a/eng/resolveContract.targets b/eng/resolveContract.targets index fb93fcd09e9..9e5189a7572 100644 --- a/eng/resolveContract.targets +++ b/eng/resolveContract.targets @@ -39,8 +39,8 @@ + DependsOnTargets="ResolveProjectReferences;GetTargetPathWithTargetPlatformMoniker" + BeforeTargets="GetTargetPath"> diff --git a/eng/targetingpacks.targets b/eng/targetingpacks.targets index 837ec7601fd..c61a849d87a 100644 --- a/eng/targetingpacks.targets +++ b/eng/targetingpacks.targets @@ -109,19 +109,6 @@ - - - - - - - - 0 ]]; then echo "Total dumps found in $dump_folder: $total_dumps" - xunitlogchecker_file_name="$HELIX_CORRELATION_PAYLOAD/XUnitLogChecker.dll" - dotnet_file_name="$RUNTIME_PATH/dotnet" - - if [[ ! -f $dotnet_file_name ]]; then - echo "'$dotnet_file_name' was not found. Unable to run XUnitLogChecker." - xunitlogchecker_exit_code=1 - elif [[ ! -f $xunitlogchecker_file_name ]]; then - echo "'$xunitlogchecker_file_name' was not found. Unable to print dump file contents." + xunitlogchecker_file_name="$HELIX_CORRELATION_PAYLOAD/XUnitLogChecker" + + if [[ ! -f $xunitlogchecker_file_name ]]; then + echo "XUnitLogChecker does not exist in the expected location: $xunitlogchecker_file_name" xunitlogchecker_exit_code=2 elif [[ ! -d $dump_folder ]]; then echo "The dump directory '$dump_folder' does not exist." else echo "Executing XUnitLogChecker in $dump_folder..." - cmd="$dotnet_file_name --roll-forward Major $xunitlogchecker_file_name --dumps-path $dump_folder" + cmd="$xunitlogchecker_file_name --dumps-path $dump_folder" echo "$cmd" $cmd xunitlogchecker_exit_code=$? @@ -207,7 +203,7 @@ if [[ $system_name == "Linux" && $test_exitcode -ne 0 ]]; then if [[ -e /proc/sys/kernel/core_uses_pid && "1" == $(cat /proc/sys/kernel/core_uses_pid) ]]; then core_name_uses_pid=1 fi - + # The osx dumps are too large to egress the machine echo Looking around for any Linux dumps... @@ -240,8 +236,9 @@ elif [[ -z "$__IsXUnitLogCheckerSupported" ]]; then elif [[ "$__IsXUnitLogCheckerSupported" != "1" ]]; then echo "XUnitLogChecker not supported for this test case. Skipping." else + echo "XUnitLogChecker status: $__IsXUnitLogCheckerSupported" echo ----- start =============== XUnitLogChecker Output ===================================================== - + invoke_xunitlogchecker "$HELIX_DUMP_FOLDER" if [[ $xunitlogchecker_exit_code -ne 0 ]]; then diff --git a/eng/testing/performance/android_scenarios.proj b/eng/testing/performance/android_scenarios.proj index 4d0aad300cd..fb18ea62bbb 100644 --- a/eng/testing/performance/android_scenarios.proj +++ b/eng/testing/performance/android_scenarios.proj @@ -16,40 +16,40 @@ - %HELIX_CORRELATION_PAYLOAD%\performance\src\scenarios\ + %HELIX_WORKITEM_ROOT%\performance\src\scenarios\ - $HELIX_CORRELATION_PAYLOAD/performance/src/scenarios/ + $HELIX_WORKITEM_ROOT/performance/src/scenarios/ $(WorkItemDirectory) - cd $(ScenarioDirectory)helloandroid;copy %HELIX_CORRELATION_PAYLOAD%\HelloAndroid.apk .;$(Python) pre.py --apk-name HelloAndroid.apk + cd $(ScenarioDirectory)helloandroid;copy %HELIX_WORKITEM_ROOT%\HelloAndroid.apk .;$(Python) pre.py --apk-name HelloAndroid.apk $(Python) test.py sod --scenario-name "%(Identity)" $(Python) post.py $(WorkItemDirectory) - cd $(ScenarioDirectory)helloandroid;copy %HELIX_CORRELATION_PAYLOAD%\HelloAndroid.apk .;$(Python) pre.py --unzip --apk-name HelloAndroid.apk + cd $(ScenarioDirectory)helloandroid;copy %HELIX_WORKITEM_ROOT%\HelloAndroid.apk .;$(Python) pre.py --unzip --apk-name HelloAndroid.apk $(Python) test.py sod --scenario-name "%(Identity)" $(Python) post.py $(WorkItemDirectory) - cd $(ScenarioDirectory)bdnandroid;copy %HELIX_CORRELATION_PAYLOAD%\MonoBenchmarksDroid.apk .;$(Python) pre.py --apk-name MonoBenchmarksDroid.apk + cd $(ScenarioDirectory)bdnandroid;copy %HELIX_WORKITEM_ROOT%\MonoBenchmarksDroid.apk .;$(Python) pre.py --apk-name MonoBenchmarksDroid.apk $(Python) test.py sod --scenario-name "%(Identity)" $(Python) post.py $(WorkItemDirectory) - cd $(ScenarioDirectory)bdnandroid;copy %HELIX_CORRELATION_PAYLOAD%\MonoBenchmarksDroid.apk .;$(Python) pre.py --unzip --apk-name MonoBenchmarksDroid.apk + cd $(ScenarioDirectory)bdnandroid;copy %HELIX_WORKITEM_ROOT%\MonoBenchmarksDroid.apk .;$(Python) pre.py --unzip --apk-name MonoBenchmarksDroid.apk $(Python) test.py sod --scenario-name "%(Identity)" $(Python) post.py $(WorkItemDirectory) - echo on;set XHARNESSPATH=$(XharnessPath);cd $(ScenarioDirectory)bdnandroid;copy %HELIX_CORRELATION_PAYLOAD%\MonoBenchmarksDroid.apk .;$(Python) pre.py --restart-device --apk-name MonoBenchmarksDroid.apk + echo on;set XHARNESSPATH=$(XharnessPath);cd $(ScenarioDirectory)bdnandroid;copy %HELIX_WORKITEM_ROOT%\MonoBenchmarksDroid.apk .;$(Python) pre.py --restart-device --apk-name MonoBenchmarksDroid.apk $(Python) test.py androidinstrumentation --package-path .\pub\MonoBenchmarksDroid.apk --package-name com.microsoft.maui.benchmarks --instrumentation-name com.microsoft.maui.MainInstrumentation --scenario-name "%(Identity)" $(Python) post.py 00:30:00 diff --git a/eng/testing/performance/blazor_perf.proj b/eng/testing/performance/blazor_perf.proj index bacb52650c1..45ad650dc1d 100644 --- a/eng/testing/performance/blazor_perf.proj +++ b/eng/testing/performance/blazor_perf.proj @@ -20,7 +20,7 @@ - %HELIX_CORRELATION_PAYLOAD%\performance\src\scenarios\ + %HELIX_WORKITEM_ROOT%\performance\src\scenarios\ $(ScenarioDirectory)blazorminapp\ $(ScenarioDirectory)blazor\ $(ScenarioDirectory)blazorpizza\ @@ -32,7 +32,7 @@ pub\wwwroot - $HELIX_CORRELATION_PAYLOAD/performance/src/scenarios/ + $HELIX_WORKITEM_ROOT/performance/src/scenarios/ $(ScenarioDirectory)blazorminapp/ $(ScenarioDirectory)blazor/ $(ScenarioDirectory)blazorpizza/ diff --git a/eng/testing/performance/crossgen_perf.proj b/eng/testing/performance/crossgen_perf.proj index 252ec7eaedb..4b7d163eaa2 100644 --- a/eng/testing/performance/crossgen_perf.proj +++ b/eng/testing/performance/crossgen_perf.proj @@ -13,7 +13,7 @@ python $(HelixPreCommands) %HELIX_CORRELATION_PAYLOAD%\Core_Root - %HELIX_CORRELATION_PAYLOAD%\performance\src\scenarios\ + %HELIX_WORKITEM_ROOT%\performance\src\scenarios\ $(ScenarioDirectory)crossgen\ $(ScenarioDirectory)crossgen2\ @@ -21,7 +21,7 @@ python3 $(HelixPreCommands);chmod +x $HELIX_WORKITEM_PAYLOAD/startup/Startup;chmod +x $HELIX_WORKITEM_PAYLOAD/startup/perfcollect;sudo apt update;chmod +x $HELIX_WORKITEM_PAYLOAD/SOD/SizeOnDisk $HELIX_CORRELATION_PAYLOAD/Core_Root - $HELIX_CORRELATION_PAYLOAD/performance/src/scenarios/ + $HELIX_WORKITEM_ROOT/performance/src/scenarios/ $(ScenarioDirectory)crossgen/ $(ScenarioDirectory)crossgen2/ diff --git a/eng/testing/performance/ios_scenarios.proj b/eng/testing/performance/ios_scenarios.proj index 1e4c59acd2b..1bc2a4ef5f9 100644 --- a/eng/testing/performance/ios_scenarios.proj +++ b/eng/testing/performance/ios_scenarios.proj @@ -25,11 +25,11 @@ - %HELIX_CORRELATION_PAYLOAD%\performance\src\scenarios\ + %HELIX_WORKITEM_ROOT%\performance\src\scenarios\ - $HELIX_CORRELATION_PAYLOAD/performance/src/scenarios/ + $HELIX_WORKITEM_ROOT/performance/src/scenarios/ diff --git a/eng/testing/performance/microbenchmarks.proj b/eng/testing/performance/microbenchmarks.proj deleted file mode 100644 index 8453f469cd0..00000000000 --- a/eng/testing/performance/microbenchmarks.proj +++ /dev/null @@ -1,170 +0,0 @@ - - - - %HELIX_WORKITEM_ROOT%\performance - $(HelixPreCommands) && robocopy /np /nfl /e %HELIX_CORRELATION_PAYLOAD%\performance $(PerformanceDirectory) /XD %HELIX_CORRELATION_PAYLOAD%\performance\.git - $(PerformanceDirectory)\scripts\benchmarks_ci.py --csproj $(PerformanceDirectory)\$(TargetCsproj) - --dotnet-versions %DOTNET_VERSION% --cli-source-info args --cli-branch %PERFLAB_BRANCH% --cli-commit-sha %PERFLAB_HASH% --cli-repository https://github.com/%PERFLAB_REPO% --cli-source-timestamp %PERFLAB_BUILDTIMESTAMP% - python - %HELIX_CORRELATION_PAYLOAD%\Core_Root\CoreRun.exe - %HELIX_CORRELATION_PAYLOAD%\Baseline_Core_Root\CoreRun.exe - $(HelixPreCommands);call $(PerformanceDirectory)\tools\machine-setup.cmd;set PYTHONPATH=%HELIX_WORKITEM_PAYLOAD%\scripts%3B%HELIX_WORKITEM_PAYLOAD% - %HELIX_WORKITEM_ROOT%\artifacts\BenchmarkDotNet.Artifacts - %HELIX_WORKITEM_ROOT%\artifacts\BenchmarkDotNet.Artifacts_Baseline - $(PerformanceDirectory)\src\tools\ResultsComparer\ResultsComparer.csproj - $(PerformanceDirectory)\tools\dotnet\$(Architecture)\dotnet.exe - %25%25 - %HELIX_WORKITEM_ROOT%\testResults.xml - - - - $HELIX_CORRELATION_PAYLOAD - $HELIX_WORKITEM_ROOT/performance - $(HelixPreCommands);cp -R $(BaseDirectory)/performance $(PerformanceDirectory) - - - - $HELIX_WORKITEM_PAYLOAD - $(BaseDirectory) - - - - $(PerformanceDirectory)/scripts/benchmarks_ci.py --csproj $(PerformanceDirectory)/$(TargetCsproj) - --dotnet-versions $DOTNET_VERSION --cli-source-info args --cli-branch $PERFLAB_BRANCH --cli-commit-sha $PERFLAB_HASH --cli-repository https://github.com/$PERFLAB_REPO --cli-source-timestamp $PERFLAB_BUILDTIMESTAMP - python3 - $(BaseDirectory)/Core_Root/corerun - $(BaseDirectory)/Baseline_Core_Root/corerun - $(HelixPreCommands);chmod +x $(PerformanceDirectory)/tools/machine-setup.sh;. $(PerformanceDirectory)/tools/machine-setup.sh - $HELIX_WORKITEM_ROOT/artifacts/BenchmarkDotNet.Artifacts - $HELIX_WORKITEM_ROOT/artifacts/BenchmarkDotNet.Artifacts_Baseline - $(PerformanceDirectory)/src/tools/ResultsComparer/ResultsComparer.csproj - $(PerformanceDirectory)/tools/dotnet/$(Architecture)/dotnet - %25 - $HELIX_WORKITEM_ROOT/testResults.xml - - - - $(CliArguments) --run-isolated --wasm --dotnet-path %24HELIX_CORRELATION_PAYLOAD/dotnet/ - - - - --corerun %HELIX_CORRELATION_PAYLOAD%\dotnet-mono\shared\Microsoft.NETCore.App\$(ProductVersion)\corerun.exe - - - --corerun $(BaseDirectory)/dotnet-mono/shared/Microsoft.NETCore.App/$(ProductVersion)/corerun - - - - $(HelixPreCommands);%HELIX_CORRELATION_PAYLOAD%\monoaot\mono-aot-cross --llvm --version - - - $(HelixPreCommands);$HELIX_CORRELATION_PAYLOAD/monoaot/mono-aot-cross --llvm --version - - - - --corerun $(CoreRun) - - - - --corerun $(BaselineCoreRun) - - - - $(Python) $(WorkItemCommand) --incremental no --architecture $(Architecture) -f $(PERFLAB_Framework) $(PerfLabArguments) - - - - $(WorkItemCommand) $(CliArguments) - - - - 6:00 - 1:30 - - $(ExtraBenchmarkDotNetArguments) --filter System.Tests.Perf_* - - - - - %(Identity) - - - - - 30 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - false - - - - - - $(WorkItemDirectory) - $(WorkItemCommand) --bdn-artifacts $(BaselineArtifactsDirectory) --bdn-arguments="--anyCategories $(BDNCategories) $(ExtraBenchmarkDotNetArguments) $(BaselineCoreRunArgument) --partition-count $(PartitionCount) --partition-index %(HelixWorkItem.Index)" - - if [ "x$PERF_PREREQS_INSTALL_FAILED" = "x1" ]; then - echo "\n\n** Error: Failed to install prerequisites **\n\n"; (exit 1); - else - $(WorkItemCommand) --bdn-artifacts $(ArtifactsDirectory) --bdn-arguments="--anyCategories $(BDNCategories) $(ExtraBenchmarkDotNetArguments) $(CoreRunArgument) --partition-count $(PartitionCount) --partition-index %(HelixWorkItem.Index)"; - fi - $(WorkItemCommand) --bdn-artifacts $(ArtifactsDirectory) --bdn-arguments="--anyCategories $(BDNCategories) $(ExtraBenchmarkDotNetArguments) $(CoreRunArgument) --partition-count $(PartitionCount) --partition-index %(HelixWorkItem.Index)" - $(DotnetExe) run -f $(PERFLAB_Framework) -p $(ResultsComparer) --base $(BaselineArtifactsDirectory) --diff $(ArtifactsDirectory) --threshold 2$(Percent) --xml $(XMLResults);$(FinalCommand) - $(WorkItemTimeout) - - - - - - $(WorkItemDirectory) - $(WorkItemCommand) --bdn-artifacts $(BaselineArtifactsDirectory) --bdn-arguments="--anyCategories $(BDNCategories) $(ExtraBenchmarkDotNetArguments) $(BaselineCoreRunArgument)" - - if [ "x$PERF_PREREQS_INSTALL_FAILED" = "x1" ]; then - echo "\n\n** Error: Failed to install prerequisites **\n\n"; (exit 1); - else - $(WorkItemCommand) --bdn-artifacts $(ArtifactsDirectory) --bdn-arguments="--anyCategories $(BDNCategories) $(ExtraBenchmarkDotNetArguments) $(CoreRunArgument)"; - fi - $(WorkItemCommand) --bdn-artifacts $(ArtifactsDirectory) --bdn-arguments="--anyCategories $(BDNCategories) $(ExtraBenchmarkDotNetArguments) $(CoreRunArgument)" - $(DotnetExe) run -f $(PERFLAB_Framework) -p $(ResultsComparer) --base $(BaselineArtifactsDirectory) --diff $(ArtifactsDirectory) --threshold 2$(Percent) --xml $(XMLResults) - 4:00 - - - diff --git a/eng/testing/performance/performance-setup.ps1 b/eng/testing/performance/performance-setup.ps1 deleted file mode 100644 index 8e9ff873646..00000000000 --- a/eng/testing/performance/performance-setup.ps1 +++ /dev/null @@ -1,228 +0,0 @@ -Param( - [string] $SourceDirectory=$env:BUILD_SOURCESDIRECTORY, - [string] $CoreRootDirectory, - [string] $BaselineCoreRootDirectory, - [string] $Architecture="x64", - [string] $Framework, - [string] $CompilationMode="Tiered", - [string] $Repository=$env:BUILD_REPOSITORY_NAME, - [string] $Branch=$env:BUILD_SOURCEBRANCH, - [string] $CommitSha=$env:BUILD_SOURCEVERSION, - [string] $BuildNumber=$env:BUILD_BUILDNUMBER, - [string] $RunCategories="Libraries Runtime", - [string] $Csproj="src\benchmarks\micro\MicroBenchmarks.csproj", - [string] $Kind="micro", - [switch] $LLVM, - [switch] $MonoInterpreter, - [switch] $MonoAOT, - [switch] $Internal, - [switch] $Compare, - [string] $MonoDotnet="", - [string] $Configurations="CompilationMode=$CompilationMode RunKind=$Kind", - [string] $LogicalMachine="", - [switch] $AndroidMono, - [switch] $iOSMono, - [switch] $iOSNativeAOT, - [switch] $NoDynamicPGO, - [switch] $PhysicalPromotion, - [switch] $NoR2R, - [string] $ExperimentName, - [switch] $iOSLlvmBuild, - [switch] $iOSStripSymbols, - [switch] $HybridGlobalization, - [string] $MauiVersion, - [switch] $UseLocalCommitTime -) - -$RunFromPerformanceRepo = ($Repository -eq "dotnet/performance") -or ($Repository -eq "dotnet-performance") -$UseCoreRun = ($CoreRootDirectory -ne [string]::Empty) -$UseBaselineCoreRun = ($BaselineCoreRootDirectory -ne [string]::Empty) - -$PayloadDirectory = (Join-Path $SourceDirectory "Payload") -$PerformanceDirectory = (Join-Path $PayloadDirectory "performance") -$WorkItemDirectory = (Join-Path $SourceDirectory "workitem") -$ExtraBenchmarkDotNetArguments = "--iterationCount 1 --warmupCount 0 --invocationCount 1 --unrollFactor 1 --strategy ColdStart --stopOnFirstError true" -$Creator = $env:BUILD_DEFINITIONNAME -$PerfLabArguments = "" -$HelixSourcePrefix = "pr" - -$Queue = "" - -if ($Internal) { - switch ($LogicalMachine) { - "perftiger" { $Queue = "Windows.11.Amd64.Tiger.Perf" } - "perftiger_crossgen" { $Queue = "Windows.11.Amd64.Tiger.Perf" } - "perfowl" { $Queue = "Windows.11.Amd64.Owl.Perf" } - "perfsurf" { $Queue = "Windows.11.Arm64.Surf.Perf" } - "perfpixel4a" { $Queue = "Windows.11.Amd64.Pixel.Perf" } - "perfampere" { $Queue = "Windows.Server.Arm64.Perf" } - "perfviper" { $Queue = "Windows.11.Amd64.Viper.Perf" } - "cloudvm" { $Queue = "Windows.10.Amd64" } - Default { $Queue = "Windows.11.Amd64.Tiger.Perf" } - } - $PerfLabArguments = "--upload-to-perflab-container" - $ExtraBenchmarkDotNetArguments = "" - $Creator = "" - $HelixSourcePrefix = "official" -} -else { - $Queue = "Windows.10.Amd64.ClientRS4.DevEx.15.8.Open" -} - -if ($MonoInterpreter) { - $ExtraBenchmarkDotNetArguments = "--category-exclusion-filter NoInterpreter" -} - -if ($MonoDotnet -ne "") { - $Configurations += " LLVM=$LLVM MonoInterpreter=$MonoInterpreter MonoAOT=$MonoAOT" - if($ExtraBenchmarkDotNetArguments -eq "") - { - #FIX ME: We need to block these tests as they don't run on mono for now - $ExtraBenchmarkDotNetArguments = "--exclusion-filter *Perf_Image* *Perf_NamedPipeStream*" - } - else - { - #FIX ME: We need to block these tests as they don't run on mono for now - $ExtraBenchmarkDotNetArguments += " --exclusion-filter *Perf_Image* *Perf_NamedPipeStream*" - } -} - -if ($NoDynamicPGO) { - $Configurations += " PGOType=nodynamicpgo" -} - -if ($PhysicalPromotion) { - $Configurations += " PhysicalPromotionType=physicalpromotion" -} - -if ($NoR2R) { - $Configurations += " R2RType=nor2r" -} - -if ($ExperimentName) { - $Configurations += " ExperimentName=$ExperimentName" - if ($ExperimentName -eq "memoryRandomization") { - $ExtraBenchmarkDotNetArguments += " --memoryRandomization true" - } -} - -if ($iOSMono) { - $Configurations += " iOSLlvmBuild=$iOSLlvmBuild" - $Configurations += " iOSStripSymbols=$iOSStripSymbols" -} - -if ($iOSNativeAOT) { - $Configurations += " iOSStripSymbols=$iOSStripSymbols" -} - -if ($HybridGlobalization -eq "True") { - $Configurations += " HybridGlobalization=True" -} - -# FIX ME: This is a workaround until we get this from the actual pipeline -$CleanedBranchName = "main" -if($Branch.Contains("refs/heads/release")) -{ - $CleanedBranchName = $Branch.replace('refs/heads/', '') -} -$CommonSetupArguments="--channel $CleanedBranchName --queue $Queue --build-number $BuildNumber --build-configs $Configurations --architecture $Architecture" -$SetupArguments = "--repository https://github.com/$Repository --branch $Branch --get-perf-hash --commit-sha $CommitSha $CommonSetupArguments" - -if ($NoDynamicPGO) { - $SetupArguments = "$SetupArguments --no-dynamic-pgo" -} - -if ($PhysicalPromotion) { - $SetupArguments = "$SetupArguments --physical-promotion" -} - -if ($NoR2R) { - $SetupArguments = "$SetupArguments --no-r2r" -} - -if ($ExperimentName) { - $SetupArguments = "$SetupArguments --experiment-name $ExperimentName" -} - -if ($UseLocalCommitTime) { - $LocalCommitTime = (git show -s --format=%ci $CommitSha) - $SetupArguments = "$SetupArguments --commit-time `"$LocalCommitTime`"" -} - -if ($RunFromPerformanceRepo) { - $SetupArguments = "--perf-hash $CommitSha $CommonSetupArguments" - - robocopy $SourceDirectory $PerformanceDirectory /E /XD $PayloadDirectory $SourceDirectory\artifacts $SourceDirectory\.git -} -else { - git clone --branch main --depth 1 --quiet https://github.com/dotnet/performance $PerformanceDirectory -} - -if ($MonoDotnet -ne "") { - $UsingMono = "true" - $MonoDotnetPath = (Join-Path $PayloadDirectory "dotnet-mono") - Move-Item -Path $MonoDotnet -Destination $MonoDotnetPath -} - -if ($UseCoreRun) { - $NewCoreRoot = (Join-Path $PayloadDirectory "Core_Root") - Move-Item -Path $CoreRootDirectory -Destination $NewCoreRoot -} -if ($UseBaselineCoreRun) { - $NewBaselineCoreRoot = (Join-Path $PayloadDirectory "Baseline_Core_Root") - Move-Item -Path $BaselineCoreRootDirectory -Destination $NewBaselineCoreRoot -} - -if ($MauiVersion -ne "") { - $SetupArguments = "$SetupArguments --maui-version $MauiVersion" -} - -if ($AndroidMono) { - if(!(Test-Path $WorkItemDirectory)) - { - mkdir $WorkItemDirectory - } - Copy-Item -path "$SourceDirectory\MonoBenchmarksDroid.apk" $PayloadDirectory -Verbose - Copy-Item -path "$SourceDirectory\androidHelloWorld\HelloAndroid.apk" $PayloadDirectory -Verbose - $SetupArguments = $SetupArguments -replace $Architecture, 'arm64' -} - -$DocsDir = (Join-Path $PerformanceDirectory "docs") -robocopy $DocsDir $WorkItemDirectory - -# Set variables that we will need to have in future steps -$ci = $true - -. "$PSScriptRoot\..\..\common\pipeline-logging-functions.ps1" - -# Directories -Write-PipelineSetVariable -Name 'PayloadDirectory' -Value "$PayloadDirectory" -IsMultiJobVariable $false -Write-PipelineSetVariable -Name 'PerformanceDirectory' -Value "$PerformanceDirectory" -IsMultiJobVariable $false -Write-PipelineSetVariable -Name 'WorkItemDirectory' -Value "$WorkItemDirectory" -IsMultiJobVariable $false - -# Script Arguments -Write-PipelineSetVariable -Name 'Python' -Value "py -3" -IsMultiJobVariable $false -Write-PipelineSetVariable -Name 'ExtraBenchmarkDotNetArguments' -Value "$ExtraBenchmarkDotNetArguments" -IsMultiJobVariable $false -Write-PipelineSetVariable -Name 'SetupArguments' -Value "$SetupArguments" -IsMultiJobVariable $false -Write-PipelineSetVariable -Name 'PerfLabArguments' -Value "$PerfLabArguments" -IsMultiJobVariable $false -Write-PipelineSetVariable -Name 'BDNCategories' -Value "$RunCategories" -IsMultiJobVariable $false -Write-PipelineSetVariable -Name 'TargetCsproj' -Value "$Csproj" -IsMultiJobVariable $false -Write-PipelineSetVariable -Name 'Kind' -Value "$Kind" -IsMultiJobVariable $false -Write-PipelineSetVariable -Name 'Architecture' -Value "$Architecture" -IsMultiJobVariable $false -Write-PipelineSetVariable -Name 'UseCoreRun' -Value "$UseCoreRun" -IsMultiJobVariable $false -Write-PipelineSetVariable -Name 'UseBaselineCoreRun' -Value "$UseBaselineCoreRun" -IsMultiJobVariable $false -Write-PipelineSetVariable -Name 'RunFromPerfRepo' -Value "$RunFromPerformanceRepo" -IsMultiJobVariable $false -Write-PipelineSetVariable -Name 'Compare' -Value "$Compare" -IsMultiJobVariable $false -Write-PipelineSetVariable -Name 'MonoDotnet' -Value "$UsingMono" -IsMultiJobVariable $false -Write-PipelineSetVariable -Name 'MonoAOT' -Value "$MonoAOT" -IsMultiJobVariable $false -Write-PipelineSetVariable -Name 'iOSLlvmBuild' -Value "$iOSLlvmBuild" -IsMultiJobVariable $false -Write-PipelineSetVariable -Name 'iOSStripSymbols' -Value "$iOSStripSymbols" -IsMultiJobVariable $false -Write-PipelineSetVariable -Name 'hybridGlobalization' -Value "$HybridGlobalization" -IsMultiJobVariable $false - -# Helix Arguments -Write-PipelineSetVariable -Name 'Creator' -Value "$Creator" -IsMultiJobVariable $false -Write-PipelineSetVariable -Name 'Queue' -Value "$Queue" -IsMultiJobVariable $false -Write-PipelineSetVariable -Name 'HelixSourcePrefix' -Value "$HelixSourcePrefix" -IsMultiJobVariable $false -Write-PipelineSetVariable -Name '_BuildConfig' -Value "$Architecture.$Kind.$Framework" -IsMultiJobVariable $false - -exit 0 diff --git a/eng/testing/performance/performance-setup.sh b/eng/testing/performance/performance-setup.sh deleted file mode 100755 index 489b3a22ccc..00000000000 --- a/eng/testing/performance/performance-setup.sh +++ /dev/null @@ -1,564 +0,0 @@ -#!/usr/bin/env bash - -# Also reset/set below -set -x - -source_directory=$BUILD_SOURCESDIRECTORY -core_root_directory= -baseline_core_root_directory= -architecture=x64 -framework= -compilation_mode=tiered -repository=$BUILD_REPOSITORY_NAME -branch=$BUILD_SOURCEBRANCH -commit_sha=$BUILD_SOURCEVERSION -build_number=$BUILD_BUILDNUMBER -internal=false -compare=false -mono_dotnet= -kind="micro" -llvm=false -monointerpreter=false -monoaot=false -monoaot_path= -run_categories="Libraries Runtime" -csproj="src\benchmarks\micro\MicroBenchmarks.csproj" -configurations="CompilationMode=$compilation_mode RunKind=$kind" -perf_fork="" -perf_fork_branch="main" -run_from_perf_repo=false -use_core_run=true -use_baseline_core_run=true -using_mono=false -wasm_bundle_directory= -using_wasm=false -use_latest_dotnet=false -logical_machine= -javascript_engine="v8" -javascript_engine_path="" -iosmono=false -iosnativeaot=false -runtimetype="" -iosllvmbuild="" -iosstripsymbols="" -hybridglobalization="" -maui_version="" -use_local_commit_time=false -only_sanity=false -dotnet_versions="" -v8_version="" - -while (($# > 0)); do - lowerI="$(echo $1 | tr "[:upper:]" "[:lower:]")" - case $lowerI in - --sourcedirectory) - source_directory=$2 - shift 2 - ;; - --corerootdirectory) - core_root_directory=$2 - shift 2 - ;; - --baselinecorerootdirectory) - baseline_core_root_directory=$2 - shift 2 - ;; - --architecture) - architecture=$2 - shift 2 - ;; - --framework) - framework=$2 - shift 2 - ;; - --compilationmode) - compilation_mode=$2 - shift 2 - ;; - --logicalmachine) - logical_machine=$2 - shift 2 - ;; - --repository) - repository=$2 - shift 2 - ;; - --branch) - branch=$2 - shift 2 - ;; - --commitsha) - commit_sha=$2 - shift 2 - ;; - --buildnumber) - build_number=$2 - shift 2 - ;; - --javascriptengine) - javascript_engine=$2 - shift 2 - ;; - --javascriptenginepath) - javascript_engine_path=$2 - shift 2 - ;; - --kind) - kind=$2 - configurations="CompilationMode=$compilation_mode RunKind=$kind" - shift 2 - ;; - --runcategories) - run_categories=$2 - shift 2 - ;; - --csproj) - csproj=$2 - shift 2 - ;; - --internal) - internal=true - shift 1 - ;; - --alpine) - alpine=true - shift 1 - ;; - --llvm) - llvm=true - shift 1 - ;; - --monointerpreter) - monointerpreter=true - shift 1 - ;; - --monoaot) - monoaot=true - monoaot_path=$2 - shift 2 - ;; - --monodotnet) - mono_dotnet=$2 - shift 2 - ;; - --wasmbundle) - wasm_bundle_directory=$2 - shift 2 - ;; - --wasmaot) - wasmaot=true - shift 1 - ;; - --nodynamicpgo) - nodynamicpgo=true - shift 1 - ;; - --physicalpromotion) - physicalpromotion=true - shift 1 - ;; - --nor2r) - nor2r=true - shift 1 - ;; - --experimentname) - experimentname=$2 - shift 2 - ;; - --compare) - compare=true - shift 1 - ;; - --configurations) - configurations=$2 - shift 2 - ;; - --latestdotnet) - use_latest_dotnet=true - shift 1 - ;; - --dotnetversions) - dotnet_versions="$2" - shift 2 - ;; - --iosmono) - iosmono=true - shift 1 - ;; - --iosnativeaot) - iosnativeaot=true - shift 1 - ;; - --iosllvmbuild) - iosllvmbuild=$2 - shift 2 - ;; - --iosstripsymbols) - iosstripsymbols=$2 - shift 2 - ;; - --hybridglobalization) - hybridglobalization=$2 - shift 2 - ;; - --mauiversion) - maui_version=$2 - shift 2 - ;; - --uselocalcommittime) - use_local_commit_time=true - shift 1 - ;; - --perffork) - perf_fork=$2 - shift 2 - ;; - --perfforkbranch) - perf_fork_branch=$2 - shift 2 - ;; - --only-sanity) - only_sanity=true - shift 1 - ;; - *) - echo "Common settings:" - echo " --corerootdirectory Directory where Core_Root exists, if running perf testing with --corerun" - echo " --architecture Architecture of the testing being run" - echo " --configurations List of key=value pairs that will be passed to perf testing infrastructure." - echo " ex: --configurations \"CompilationMode=Tiered OptimzationLevel=PGO\"" - echo " --help Print help and exit" - echo "" - echo "Advanced settings:" - echo " --framework The framework to run, if not running in master" - echo " --compilationmode The compilation mode if not passing --configurations" - echo " --sourcedirectory The directory of the sources. Defaults to env:BUILD_SOURCESDIRECTORY" - echo " --repository The name of the repository in the / format. Defaults to env:BUILD_REPOSITORY_NAME" - echo " --branch The name of the branch. Defaults to env:BUILD_SOURCEBRANCH" - echo " --commitsha The commit sha1 to run against. Defaults to env:BUILD_SOURCEVERSION" - echo " --buildnumber The build number currently running. Defaults to env:BUILD_BUILDNUMBER" - echo " --csproj The relative path to the benchmark csproj whose tests should be run. Defaults to src\benchmarks\micro\MicroBenchmarks.csproj" - echo " --kind Related to csproj. The kind of benchmarks that should be run. Defaults to micro" - echo " --runcategories Related to csproj. Categories of benchmarks to run. Defaults to \"coreclr corefx\"" - echo " --internal If the benchmarks are running as an official job." - echo " --monodotnet Pass the path to the mono dotnet for mono performance testing." - echo " --wasmbundle Path to the wasm bundle containing the dotnet, and data needed for helix payload" - echo " --wasmaot Indicate wasm aot" - echo " --latestdotnet --dotnet-versions will not be specified. --dotnet-versions defaults to LKG version in global.json " - echo " --dotnetversions Passed as '--dotnet-versions ' to the setup script" - echo " --alpine Set for runs on Alpine" - echo " --llvm Set LLVM for Mono runs" - echo " --iosmono Set for ios Mono/Maui runs" - echo " --iosnativeaot Set for ios Native AOT runs" - echo " --iosllvmbuild Set LLVM for iOS Mono/Maui runs" - echo " --iosstripsymbols Set STRIP_DEBUG_SYMBOLS for iOS Mono/Maui runs" - echo " --hybridglobalization Set hybrid globalization for iOS Mono/Maui/Wasm runs" - echo " --mauiversion Set the maui version for Mono/Maui runs" - echo " --uselocalcommittime Pass local runtime commit time to the setup script" - echo " --nodynamicpgo Set for No dynamic PGO runs" - echo " --physicalpromotion Set for runs with physical promotion" - echo " --nor2r Set for No R2R runs" - echo " --experimentname Set Experiment Name" - echo "" - exit 1 - ;; - esac -done - -if [[ "$repository" == "dotnet/performance" || "$repository" == "dotnet-performance" ]]; then - run_from_perf_repo=true -fi - -if [ -z "$configurations" ]; then - configurations="CompilationMode=$compilation_mode" -fi - -if [ -z "$core_root_directory" ]; then - use_core_run=false -fi - -if [ -z "$baseline_core_root_directory" ]; then - use_baseline_core_run=false -fi - -payload_directory=$source_directory/Payload -performance_directory=$payload_directory/performance -benchmark_directory=$payload_directory/BenchmarkDotNet -workitem_directory=$source_directory/workitem -extra_benchmark_dotnet_arguments="--iterationCount 1 --warmupCount 0 --invocationCount 1 --unrollFactor 1 --strategy ColdStart --stopOnFirstError true" -perflab_arguments= -queue=Ubuntu.2204.Amd64.Open -creator=$BUILD_DEFINITIONNAME -helix_source_prefix="pr" - -if [[ "$internal" == true ]]; then - perflab_arguments="--upload-to-perflab-container" - helix_source_prefix="official" - creator= - extra_benchmark_dotnet_arguments= - - if [[ "$logical_machine" == "perfiphone12mini" ]]; then - queue=OSX.13.Amd64.Iphone.Perf - elif [[ "$logical_machine" == "perfampere" ]]; then - queue=Ubuntu.2204.Arm64.Perf - elif [[ "$logical_machine" == "perfviper" ]]; then - queue=Ubuntu.2204.Amd64.Viper.Perf - elif [[ "$logical_machine" == "cloudvm" ]]; then - queue=Ubuntu.2204.Amd64 - elif [[ "$architecture" == "arm64" ]]; then - queue=Ubuntu.1804.Arm64.Perf - else - if [[ "$logical_machine" == "perfowl" ]]; then - queue=Ubuntu.2204.Amd64.Owl.Perf - elif [[ "$logical_machine" == "perftiger_crossgen" ]]; then - queue=Ubuntu.1804.Amd64.Tiger.Perf - else - queue=Ubuntu.2204.Amd64.Tiger.Perf - fi - fi - - if [[ "$alpine" == "true" ]]; then - queue=alpine.amd64.tiger.perf - fi -else - if [[ "$architecture" == "arm64" ]]; then - queue=ubuntu.1804.armarch.open - else - queue=Ubuntu.2204.Amd64.Open - fi - - if [[ "$alpine" == "true" ]]; then - queue=alpine.amd64.tiger.perf - fi -fi - -if [[ -n "$mono_dotnet" && "$monointerpreter" == "false" ]]; then - configurations="$configurations LLVM=$llvm MonoInterpreter=$monointerpreter MonoAOT=$monoaot" - extra_benchmark_dotnet_arguments="$extra_benchmark_dotnet_arguments --category-exclusion-filter NoMono" -fi - -_BuildConfig="$architecture.$kind.$framework" - -if [[ -n "$wasm_bundle_directory" ]]; then - if [[ "$wasmaot" == "true" ]]; then - configurations="CompilationMode=wasm AOT=true RunKind=$kind" - _BuildConfig="wasmaot.$_BuildConfig" - else - configurations="CompilationMode=wasm RunKind=$kind" - _BuildConfig="wasm.$_BuildConfig" - fi - if [[ "$javascript_engine" == "javascriptcore" ]]; then - configurations="$configurations JSEngine=javascriptcore" - fi - extra_benchmark_dotnet_arguments="$extra_benchmark_dotnet_arguments --category-exclusion-filter NoInterpreter NoWASM NoMono" -fi - -if [[ -n "$mono_dotnet" && "$monointerpreter" == "true" ]]; then - configurations="$configurations LLVM=$llvm MonoInterpreter=$monointerpreter MonoAOT=$monoaot" - extra_benchmark_dotnet_arguments="$extra_benchmark_dotnet_arguments --category-exclusion-filter NoInterpreter NoMono" -fi - -if [[ "$monoaot" == "true" ]]; then - configurations="$configurations LLVM=$llvm MonoInterpreter=$monointerpreter MonoAOT=$monoaot" - extra_benchmark_dotnet_arguments="$extra_benchmark_dotnet_arguments --category-exclusion-filter NoAOT NoWASM" -fi - -if [[ "$iosmono" == "true" ]]; then - runtimetype="Mono" - configurations="$configurations iOSLlvmBuild=$iosllvmbuild iOSStripSymbols=$iosstripsymbols RuntimeType=$runtimetype" - extra_benchmark_dotnet_arguments="$extra_benchmark_dotnet_arguments" -fi - -if [[ "$iosnativeaot" == "true" ]]; then - runtimetype="NativeAOT" - configurations="$configurations iOSStripSymbols=$iosstripsymbols RuntimeType=$runtimetype" - extra_benchmark_dotnet_arguments="$extra_benchmark_dotnet_arguments" -fi - -if [[ "$nodynamicpgo" == "true" ]]; then - configurations="$configurations PGOType=nodynamicpgo" -fi - -if [[ "$physicalpromotion" == "true" ]]; then - configurations="$configurations PhysicalPromotionType=physicalpromotion" -fi - -if [[ "$nor2r" == "true" ]]; then - configurations="$configurations R2RType=nor2r" -fi - -if [[ ! -z "$experimentname" ]]; then - configurations="$configurations ExperimentName=$experimentname" - if [[ "$experimentname" == "memoryRandomization" ]]; then - extra_benchmark_dotnet_arguments="$extra_benchmark_dotnet_arguments --memoryRandomization true" - fi -fi - -if [[ "$(echo "$hybridglobalization" | tr '[:upper:]' '[:lower:]')" == "true" ]]; then # convert to lowercase to test - configurations="$configurations HybridGlobalization=True" # Force True for consistency -fi - - - -cleaned_branch_name="main" -if [[ $branch == *"refs/heads/release"* ]]; then - cleaned_branch_name=${branch/refs\/heads\//} -fi -common_setup_arguments="--channel $cleaned_branch_name --queue $queue --build-number $build_number --build-configs $configurations --architecture $architecture" -setup_arguments="--repository https://github.com/$repository --branch $branch --get-perf-hash --commit-sha $commit_sha $common_setup_arguments" - -if [[ "$internal" != true ]]; then - setup_arguments="$setup_arguments --not-in-lab" -fi - -if [[ "$use_local_commit_time" == true ]]; then - local_commit_time=$(git show -s --format=%ci $commit_sha) - setup_arguments="$setup_arguments --commit-time \"$local_commit_time\"" -fi - -if [[ "$run_from_perf_repo" == true ]]; then - payload_directory= - workitem_directory=$source_directory - performance_directory=$workitem_directory - setup_arguments="--perf-hash $commit_sha $common_setup_arguments" -else - if [[ -n "$perf_fork" ]]; then - git clone --branch $perf_fork_branch --depth 1 --quiet $perf_fork $performance_directory - else - git clone --branch main --depth 1 --quiet https://github.com/dotnet/performance.git $performance_directory - fi - # uncomment to use BenchmarkDotNet sources instead of nuget packages - # git clone https://github.com/dotnet/BenchmarkDotNet.git $benchmark_directory - - (cd $performance_directory; git show -s HEAD) - - docs_directory=$performance_directory/docs - mv $docs_directory $workitem_directory -fi - -if [[ -n "$maui_version" ]]; then - setup_arguments="$setup_arguments --maui-version $maui_version" -fi - -if [[ -n "$wasm_bundle_directory" ]]; then - using_wasm=true - wasm_bundle_directory_path=$payload_directory - mv $wasm_bundle_directory/* $wasm_bundle_directory_path - wasm_args="--expose_wasm" - if [ "$javascript_engine" == "v8" ]; then - # for es6 module support - wasm_args="$wasm_args --module" - - # get required version - if [[ -z "$v8_version" ]]; then - v8_version=`grep linux_V8Version $source_directory/eng/testing/BrowserVersions.props | sed -e 's,.*>\([^\<]*\)<.*,\1,g' | cut -d. -f 1-3` - echo "V8 version: $v8_version" - fi - if [[ -z "$javascript_engine_path" ]]; then - javascript_engine_path="/home/helixbot/.jsvu/bin/v8-${v8_version}" - fi - fi - - if [[ -z "$javascript_engine_path" ]]; then - javascript_engine_path="/home/helixbot/.jsvu/bin/$javascript_engine" - fi - - # Workaround: escaping the quotes around `--wasmArgs=..` so they get retained for the actual command line - extra_benchmark_dotnet_arguments="$extra_benchmark_dotnet_arguments --wasmEngine $javascript_engine_path \\\"--wasmArgs=$wasm_args\\\" --cli \$HELIX_CORRELATION_PAYLOAD/dotnet/dotnet --wasmDataDir \$HELIX_CORRELATION_PAYLOAD/wasm-data" - if [[ "$wasmaot" == "true" ]]; then - extra_benchmark_dotnet_arguments="$extra_benchmark_dotnet_arguments --aotcompilermode wasm --buildTimeout 3600" - fi - setup_arguments="$setup_arguments --dotnet-path $wasm_bundle_directory_path/dotnet" -fi - -if [[ -n "$mono_dotnet" && "$monoaot" == "false" ]]; then - using_mono=true - mono_dotnet_path=$payload_directory/dotnet-mono - mv $mono_dotnet $mono_dotnet_path -fi - -if [[ -n "$dotnet_versions" ]]; then - setup_arguments="$setup_arguments --dotnet-versions $dotnet_versions" -fi - -if [[ "$nodynamicpgo" == "true" ]]; then - setup_arguments="$setup_arguments --no-dynamic-pgo" -fi - -if [[ "$physicalpromotion" == "true" ]]; then - setup_arguments="$setup_arguments --physical-promotion" -fi - -if [[ "$nor2r" == "true" ]]; then - setup_arguments="$setup_arguments --no-r2r" -fi - -if [[ ! -z "$experimentname" ]]; then - setup_arguments="$setup_arguments --experiment-name $experimentname" -fi - -if [[ "$monoaot" == "true" ]]; then - monoaot_dotnet_path=$payload_directory/monoaot - mv $monoaot_path $monoaot_dotnet_path - extra_benchmark_dotnet_arguments="$extra_benchmark_dotnet_arguments --runtimes monoaotllvm --aotcompilerpath \$HELIX_CORRELATION_PAYLOAD/monoaot/mono-aot-cross --customruntimepack \$HELIX_CORRELATION_PAYLOAD/monoaot/pack --aotcompilermode llvm" -fi - -extra_benchmark_dotnet_arguments="$extra_benchmark_dotnet_arguments --logBuildOutput --generateBinLog" - -if [[ "$use_core_run" == true ]]; then - new_core_root=$payload_directory/Core_Root - mv $core_root_directory $new_core_root -fi - -if [[ "$use_baseline_core_run" == true ]]; then - new_baseline_core_root=$payload_directory/Baseline_Core_Root - mv $baseline_core_root_directory $new_baseline_core_root -fi - -if [[ "$iosmono" == "true" || "$iosnativeaot" == "true" ]]; then - mkdir -p $payload_directory/iosHelloWorld && cp -rv $source_directory/iosHelloWorld $payload_directory/iosHelloWorld - mkdir -p $payload_directory/iosHelloWorldZip && cp -rv $source_directory/iosHelloWorldZip $payload_directory/iosHelloWorldZip - - find "$payload_directory/iosHelloWorldZip/" -type f -name "*.zip" -execdir mv {} "$payload_directory/iosHelloWorldZip/iOSSampleApp.zip" \; -fi - -ci=true - -_script_dir=$(pwd)/eng/common -. "$_script_dir/pipeline-logging-functions.sh" - -# Prevent vso[task.setvariable to be erroneously processed -set +x - -# Make sure all of our variables are available for future steps -Write-PipelineSetVariable -name "UseCoreRun" -value "$use_core_run" -is_multi_job_variable false -Write-PipelineSetVariable -name "UseBaselineCoreRun" -value "$use_baseline_core_run" -is_multi_job_variable false -Write-PipelineSetVariable -name "Architecture" -value "$architecture" -is_multi_job_variable false -Write-PipelineSetVariable -name "PayloadDirectory" -value "$payload_directory" -is_multi_job_variable false -Write-PipelineSetVariable -name "PerformanceDirectory" -value "$performance_directory" -is_multi_job_variable false -Write-PipelineSetVariable -name "WorkItemDirectory" -value "$workitem_directory" -is_multi_job_variable false -Write-PipelineSetVariable -name "Queue" -value "$queue" -is_multi_job_variable false -Write-PipelineSetVariable -name "SetupArguments" -value "$setup_arguments" -is_multi_job_variable false -Write-PipelineSetVariable -name "Python" -value "python3" -is_multi_job_variable false -Write-PipelineSetVariable -name "PerfLabArguments" -value "$perflab_arguments" -is_multi_job_variable false -Write-PipelineSetVariable -name "ExtraBenchmarkDotNetArguments" -value "$extra_benchmark_dotnet_arguments" -is_multi_job_variable false -Write-PipelineSetVariable -name "BDNCategories" -value "$run_categories" -is_multi_job_variable false -Write-PipelineSetVariable -name "TargetCsproj" -value "$csproj" -is_multi_job_variable false -Write-PipelineSetVariable -name "RunFromPerfRepo" -value "$run_from_perf_repo" -is_multi_job_variable false -Write-PipelineSetVariable -name "Creator" -value "$creator" -is_multi_job_variable false -Write-PipelineSetVariable -name "HelixSourcePrefix" -value "$helix_source_prefix" -is_multi_job_variable false -Write-PipelineSetVariable -name "Kind" -value "$kind" -is_multi_job_variable false -Write-PipelineSetVariable -name "_BuildConfig" -value "$_BuildConfig" -is_multi_job_variable false -Write-PipelineSetVariable -name "Compare" -value "$compare" -is_multi_job_variable false -Write-PipelineSetVariable -name "MonoDotnet" -value "$using_mono" -is_multi_job_variable false -Write-PipelineSetVariable -name "MonoAOT" -value "$monoaot" -is_multi_job_variable false -Write-PipelineSetVariable -name "WasmDotnet" -value "$using_wasm" -is_multi_job_variable false -Write-PipelineSetVariable -Name 'iOSLlvmBuild' -Value "$iosllvmbuild" -is_multi_job_variable false -Write-PipelineSetVariable -Name 'iOSStripSymbols' -Value "$iosstripsymbols" -is_multi_job_variable false -Write-PipelineSetVariable -Name 'hybridGlobalization' -Value "$hybridglobalization" -is_multi_job_variable false -Write-PipelineSetVariable -Name 'RuntimeType' -Value "$runtimetype" -is_multi_job_variable false -Write-PipelineSetVariable -name "OnlySanityCheck" -value "$only_sanity" -is_multi_job_variable false -Write-PipelineSetVariable -name "V8Version" -value "$v8_version" -is_multi_job_variable false - -# Put it back to what was set on top of this script -set -x diff --git a/eng/testing/tests.ioslike.targets b/eng/testing/tests.ioslike.targets index dde49575d7a..a59cce6c49a 100644 --- a/eng/testing/tests.ioslike.targets +++ b/eng/testing/tests.ioslike.targets @@ -71,6 +71,7 @@ + @@ -93,8 +94,7 @@ - <_BundlePdbFiles Include="$([System.IO.Path]::ChangeExtension('%(AppleAssembliesToBundle.Identity)', '.pdb'))" /> - + @@ -213,7 +213,10 @@ <_IsNative>false - + + + + diff --git a/eng/testing/tests.props b/eng/testing/tests.props index 2c555d1abaf..9cc17e209ae 100644 --- a/eng/testing/tests.props +++ b/eng/testing/tests.props @@ -15,7 +15,11 @@ $([MSBuild]::NormalizeDirectory('$(ArtifactsBinDir)', 'AppleTestRunner', '$(Configuration)', '$(NetCoreAppCurrent)')) $([MSBuild]::NormalizeDirectory('$(ArtifactsBinDir)', 'AndroidTestRunner', '$(Configuration)', '$(NetCoreAppCurrent)')) - $([MSBuild]::NormalizeDirectory('$(ArtifactsBinDir)', 'WasmTestRunner', '$(Configuration)', '$(NetCoreAppCurrent)')) + + <_WasmTestRunnerTFM>$(NetCoreAppCurrent) + <_WasmTestRunnerTFM Condition="'$(TargetsWasi)' == 'true'">$(NetCoreAppCurrent)-wasi + <_WasmTestRunnerTFM Condition="'$(TargetsBrowser)' == 'true'">$(NetCoreAppCurrent)-browser + $([MSBuild]::NormalizeDirectory('$(ArtifactsBinDir)', 'WasmTestRunner', '$(Configuration)', '$(_WasmTestRunnerTFM)')) $(OutputRID) true diff --git a/eng/testing/tests.targets b/eng/testing/tests.targets index 4883ed549ea..5eb33b12baa 100644 --- a/eng/testing/tests.targets +++ b/eng/testing/tests.targets @@ -195,7 +195,7 @@ TEST_ARCH=$(_AndroidArchitecture) - + diff --git a/eng/testing/tests.wasi.targets b/eng/testing/tests.wasi.targets index 148026015be..e076ac18c4b 100644 --- a/eng/testing/tests.wasi.targets +++ b/eng/testing/tests.wasi.targets @@ -29,7 +29,7 @@ <_AppArgs Condition="'$(IsFunctionalTest)' != 'true' and '$(WasmSingleFileBundle)' != 'true'">$(_AppArgs) managed/$(AssemblyName).dll <_AppArgs Condition="'$(IsFunctionalTest)' != 'true' and '$(WasmSingleFileBundle)' == 'true'">$(_AppArgs) $(AssemblyName).dll - <_AppArgs Condition="'$(WasmTestAppArgs)' != ''">$(_AppArgs) -- $(WasmTestAppArgs) + <_AppArgs Condition="'$(WasmTestAppArgs)' != ''">$(_AppArgs) $(WasmTestAppArgs) $(WasmXHarnessMonoArgs) --env=XHARNESS_LOG_TEST_START=true @@ -49,6 +49,8 @@ <_XHarnessArgs Condition="'$(WasmXHarnessTestsTimeout)' != ''" >$(_XHarnessArgs) "--timeout=$(WasmXHarnessTestsTimeout)" <_XHarnessArgs >$(_XHarnessArgs) --engine-arg=--wasm --engine-arg=max-wasm-stack=134217728 <_XHarnessArgs >$(_XHarnessArgs) --engine-arg=--wasi --engine-arg=http + <_XHarnessArgs >$(_XHarnessArgs) --engine-arg=--wasi --engine-arg=inherit-network + <_XHarnessArgs >$(_XHarnessArgs) --engine-arg=--wasi --engine-arg=allow-ip-name-lookup <_XHarnessArgs >$(_XHarnessArgs) --engine-arg=--env --engine-arg=DOTNET_WASI_PRINT_EXIT_CODE=1 <_XHarnessArgs Condition="'$(WasmXHarnessArgsCli)' != ''" >$(_XHarnessArgs) $(WasmXHarnessArgsCli) diff --git a/eng/testing/xunit/xunit.console.targets b/eng/testing/xunit/xunit.console.targets index dda953aafbe..abbf879cd5e 100644 --- a/eng/testing/xunit/xunit.console.targets +++ b/eng/testing/xunit/xunit.console.targets @@ -4,6 +4,11 @@ true testResults.xml true + + $(XunitConsoleNetCore21AppPath) + $(XunitConsole472Path) + + true @@ -12,10 +17,15 @@ + + xunit.console.dll + xunit.console.exe + + <_depsFileArgument Condition="'$(GenerateDependencyFile)' == 'true'">--depsfile $(AssemblyName).deps.json - "$(RunScriptHost)" exec --runtimeconfig $(AssemblyName).runtimeconfig.json $(_depsFileArgument) xunit.console.dll - xunit.console.exe + "$(RunScriptHost)" exec --runtimeconfig $(AssemblyName).runtimeconfig.json $(_depsFileArgument) $(XunitConsolePath) + $(XunitConsolePath) $(RunScriptCommand) $(TargetFileName) $(RunScriptCommand) -xml $(TestResultsName) @@ -74,9 +84,8 @@ - + - true IL verification library. + + 9.0.0 - In the ILVerify.IResolver interface, the type of the first parameter of each method is now System.Reflection.Metadata.AssemblyNameInfo rather than System.Reflection.AssemblyName. + diff --git a/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj b/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj index 115e29762b4..e027d8d7d75 100644 --- a/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj +++ b/src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj @@ -25,7 +25,6 @@ - @@ -111,6 +110,7 @@ + @@ -140,6 +140,7 @@ + @@ -195,7 +196,6 @@ - @@ -207,8 +207,6 @@ - - @@ -231,7 +229,6 @@ - @@ -269,8 +266,6 @@ - - @@ -291,6 +286,9 @@ Common\Interop\Windows\OleAut32\Interop.VariantClear.cs + + Common\Interop\Windows\OleAut32\Interop.VariantChangeTypeEx.cs + @@ -302,11 +300,6 @@ - - - - - @@ -317,15 +310,15 @@ - - src\System\Diagnostics\Eventing\Generated\NativeRuntimeEventSource.CoreCLR.cs + + src\System\Diagnostics\Eventing\NativeRuntimeEventSource.Generated.cs - + <_PythonWarningParameter>-Wall <_PythonWarningParameter Condition="'$(MSBuildTreatWarningsAsErrors)' == 'true'">$(_PythonWarningParameter) -Werror diff --git a/src/coreclr/System.Private.CoreLib/src/ILLink/ILLink.Descriptors.Shared.xml b/src/coreclr/System.Private.CoreLib/src/ILLink/ILLink.Descriptors.Shared.xml index 5bf4d422a76..0c7a6d7e625 100644 --- a/src/coreclr/System.Private.CoreLib/src/ILLink/ILLink.Descriptors.Shared.xml +++ b/src/coreclr/System.Private.CoreLib/src/ILLink/ILLink.Descriptors.Shared.xml @@ -7,8 +7,6 @@ - - diff --git a/src/coreclr/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.Windows.xml b/src/coreclr/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.Windows.xml deleted file mode 100644 index 28a6da5f793..00000000000 --- a/src/coreclr/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.Windows.xml +++ /dev/null @@ -1,10 +0,0 @@ - - - - - - - - - - diff --git a/src/coreclr/System.Private.CoreLib/src/System/ThrowHelper.cs b/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs similarity index 90% rename from src/coreclr/System.Private.CoreLib/src/System/ThrowHelper.cs rename to src/coreclr/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs index 254cc0df8a2..fd01c28423e 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/ThrowHelper.cs +++ b/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs @@ -1,19 +1,21 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System.Diagnostics; using System.Diagnostics.CodeAnalysis; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; -namespace System +namespace Internal.Runtime.CompilerHelpers { - internal static unsafe partial class ThrowHelper + internal static unsafe partial class ThrowHelpers { [DoesNotReturn] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_ThrowAmbiguousResolutionException")] private static partial void ThrowAmbiguousResolutionException(MethodTable* targetType, MethodTable* interfaceType, void* methodDesc); [DoesNotReturn] + [DebuggerHidden] internal static void ThrowAmbiguousResolutionException( void* method, // MethodDesc* void* interfaceType, // MethodTable* @@ -27,6 +29,7 @@ internal static void ThrowAmbiguousResolutionException( private static partial void ThrowEntryPointNotFoundException(MethodTable* targetType, MethodTable* interfaceType, void* methodDesc); [DoesNotReturn] + [DebuggerHidden] internal static void ThrowEntryPointNotFoundException( void* method, // MethodDesc* void* interfaceType, // MethodTable* diff --git a/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/InteropServices/InMemoryAssemblyLoader.cs b/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/InteropServices/InMemoryAssemblyLoader.cs index 4a7d0a88c19..6929c4752ed 100644 --- a/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/InteropServices/InMemoryAssemblyLoader.cs +++ b/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/InteropServices/InMemoryAssemblyLoader.cs @@ -15,6 +15,7 @@ namespace Internal.Runtime.InteropServices [SupportedOSPlatform("windows")] internal static class InMemoryAssemblyLoader { + [FeatureSwitchDefinition("System.Runtime.InteropServices.EnableCppCLIHostActivation")] private static bool IsSupported { get; } = InitializeIsSupported(); private static bool InitializeIsSupported() => AppContext.TryGetSwitch("System.Runtime.InteropServices.EnableCppCLIHostActivation", out bool isSupported) ? isSupported : true; diff --git a/src/coreclr/System.Private.CoreLib/src/Microsoft/Win32/OAVariantLib.cs b/src/coreclr/System.Private.CoreLib/src/Microsoft/Win32/OAVariantLib.cs index a51ec6f0132..bf6952f333e 100644 --- a/src/coreclr/System.Private.CoreLib/src/Microsoft/Win32/OAVariantLib.cs +++ b/src/coreclr/System.Private.CoreLib/src/Microsoft/Win32/OAVariantLib.cs @@ -20,6 +20,7 @@ using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.InteropServices.Marshalling; +using System.StubHelpers; namespace Microsoft.Win32 { @@ -73,8 +74,7 @@ internal static unsafe partial class OAVariantLib if (source is int || source is uint) { uint sourceData = source is int ? (uint)(int)source : (uint)source; - // Int32/UInt32 can be converted to System.Drawing.Color - Variant.ConvertOleColorToSystemColor(ObjectHandleOnStack.Create(ref result), sourceData, targetClass.TypeHandle.Value); + result = ColorMarshaler.ConvertToManaged((int)sourceData); Debug.Assert(result != null); return result; } @@ -151,19 +151,10 @@ private static ComVariant ToOAVariant(object input) null => default, Missing => throw new NotSupportedException(SR.NotSupported_ChangeType), DBNull => ComVariant.Null, - _ => GetComIPFromObjectRef(input) // Convert the object to an IDispatch/IUnknown pointer. + _ => Variant.GetIUnknownOrIDispatchFromObject(input) // Convert the object to an IDispatch/IUnknown pointer. }; } - private static ComVariant GetComIPFromObjectRef(object? obj) - { - IntPtr pUnk = GetIUnknownOrIDispatchForObject(ObjectHandleOnStack.Create(ref obj), out bool isIDispatch); - return ComVariant.CreateRaw(isIDispatch ? VarEnum.VT_DISPATCH : VarEnum.VT_UNKNOWN, pUnk); - } - - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetIUnknownOrIDispatchForObject")] - private static partial IntPtr GetIUnknownOrIDispatchForObject(ObjectHandleOnStack o, [MarshalAs(UnmanagedType.Bool)] out bool isIDispatch); - private static object? FromOAVariant(ComVariant input) => input.VarType switch { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs index 9a51c47cb02..576c1fe696b 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/Debugger.cs @@ -11,15 +11,15 @@ namespace System.Diagnostics { public static partial class Debugger { + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DebugDebugger_Break")] + private static partial void BreakInternal(); + // Break causes a breakpoint to be signalled to an attached debugger. If no debugger // is attached, the user is asked if they want to attach a debugger. If yes, then the // debugger is launched. [MethodImpl(MethodImplOptions.NoInlining)] public static void Break() => BreakInternal(); - [MethodImpl(MethodImplOptions.InternalCall)] - private static extern void BreakInternal(); - // Launch launches & attaches a debugger to the process. If a debugger is already attached, // nothing happens. // @@ -30,11 +30,6 @@ public static partial class Debugger // See code:NotifyOfCrossThreadDependency for more details. private sealed class CrossThreadDependencyNotification : ICustomDebuggerNotification { } - // Do not inline the slow path - [MethodImpl(MethodImplOptions.NoInlining)] - private static void NotifyOfCrossThreadDependencySlow() => - CustomNotification(new CrossThreadDependencyNotification()); - // Sends a notification to the debugger to indicate that execution is about to enter a path // involving a cross thread dependency. A debugger that has opted into this type of notification // can take appropriate action on receipt. For example, performing a funceval normally requires @@ -49,6 +44,14 @@ public static void NotifyOfCrossThreadDependency() { NotifyOfCrossThreadDependencySlow(); } + + // Do not inline the slow path + [MethodImpl(MethodImplOptions.NoInlining)] + static void NotifyOfCrossThreadDependencySlow() + { + var notify = new CrossThreadDependencyNotification(); + CustomNotification(ObjectHandleOnStack.Create(ref notify)); + } } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DebugDebugger_Launch")] @@ -89,7 +92,7 @@ public static extern bool IsAttached // Posts a custom notification for the attached debugger. If there is no // debugger attached, has no effect. The debugger may or may not // report the notification depending on its settings. - [MethodImpl(MethodImplOptions.InternalCall)] - private static extern void CustomNotification(ICustomDebuggerNotification data); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "DebugDebugger_CustomNotification")] + private static partial void CustomNotification(ObjectHandleOnStack data); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrame.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrame.CoreCLR.cs index b68e4f2884b..8c1850d31e8 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrame.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrame.CoreCLR.cs @@ -30,9 +30,9 @@ internal StackFrame(StackFrameHelper stackFrameHelper, int skipFrames, bool need private void BuildStackFrame(int skipFrames, bool needFileInfo) { - StackFrameHelper StackF = new StackFrameHelper(null); + StackFrameHelper StackF = new StackFrameHelper(); - StackF.InitializeSourceInfo(0, needFileInfo, null); + StackF.InitializeSourceInfo(needFileInfo, null); int iNumOfFrames = StackF.GetNumberOfFrames(); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrameHelper.cs b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrameHelper.cs index 8e90b6a2eec..f10af9c2347 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrameHelper.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackFrameHelper.cs @@ -13,7 +13,6 @@ namespace System.Diagnostics // VM\DebugDebugger.h. The binder will catch some of these layout problems. internal sealed class StackFrameHelper { - private Thread? targetThread; private int[]? rgiOffset; private int[]? rgiILOffset; @@ -48,9 +47,8 @@ private delegate void GetSourceLineInfoDelegate(Assembly? assembly, string assem [ThreadStatic] private static int t_reentrancy; - public StackFrameHelper(Thread? target) + public StackFrameHelper() { - targetThread = target; rgMethodHandle = null; rgiMethodToken = null; rgiOffset = null; @@ -85,9 +83,9 @@ public StackFrameHelper(Thread? target) // done by GetStackFramesInternal (on Windows for old PDB format). // - internal void InitializeSourceInfo(int iSkip, bool fNeedFileInfo, Exception? exception) + internal void InitializeSourceInfo(bool fNeedFileInfo, Exception? exception) { - StackTrace.GetStackFramesInternal(this, iSkip, fNeedFileInfo, exception); + StackTrace.GetStackFramesInternal(this, fNeedFileInfo, exception); if (!fNeedFileInfo) return; diff --git a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackTrace.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackTrace.CoreCLR.cs index 26e002f9901..5d4bc6008e6 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackTrace.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Diagnostics/StackTrace.CoreCLR.cs @@ -3,13 +3,17 @@ using System.Reflection; using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; namespace System.Diagnostics { public partial class StackTrace { - [MethodImpl(MethodImplOptions.InternalCall)] - internal static extern void GetStackFramesInternal(StackFrameHelper sfh, int iSkip, bool fNeedFileInfo, Exception? e); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StackTrace_GetStackFramesInternal")] + private static partial void GetStackFramesInternal(ObjectHandleOnStack sfh, [MarshalAs(UnmanagedType.Bool)] bool fNeedFileInfo, ObjectHandleOnStack e); + + internal static void GetStackFramesInternal(StackFrameHelper sfh, bool fNeedFileInfo, Exception? e) + => GetStackFramesInternal(ObjectHandleOnStack.Create(ref sfh), fNeedFileInfo, ObjectHandleOnStack.Create(ref e)); internal static int CalculateFramesToSkip(StackFrameHelper StackF, int iNumFrames) { @@ -57,9 +61,9 @@ private void CaptureStackTrace(int skipFrames, bool fNeedFileInfo, Exception? e) { _methodsToSkip = skipFrames; - StackFrameHelper StackF = new StackFrameHelper(null); + StackFrameHelper StackF = new StackFrameHelper(); - StackF.InitializeSourceInfo(0, fNeedFileInfo, e); + StackF.InitializeSourceInfo(fNeedFileInfo, e); _numOfFrames = StackF.GetNumberOfFrames(); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Exception.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Exception.CoreCLR.cs index 79944b1cca8..1029f3e570e 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Exception.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Exception.CoreCLR.cs @@ -117,9 +117,6 @@ internal void InternalPreserveStackTrace() [MethodImpl(MethodImplOptions.InternalCall)] private static extern void PrepareForForeignExceptionRaise(); - [MethodImpl(MethodImplOptions.InternalCall)] - private static extern object? GetFrozenStackTrace(Exception exception); - [MethodImpl(MethodImplOptions.InternalCall)] internal static extern uint GetExceptionCount(); @@ -226,9 +223,14 @@ public DispatchState( } } + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ExceptionNative_GetFrozenStackTrace")] + private static partial void GetFrozenStackTrace(ObjectHandleOnStack exception, ObjectHandleOnStack stackTrace); + internal DispatchState CaptureDispatchState() { - object? stackTrace = GetFrozenStackTrace(this); + Exception _this = this; + object? stackTrace = null; + GetFrozenStackTrace(ObjectHandleOnStack.Create(ref _this), ObjectHandleOnStack.Create(ref stackTrace)); return new DispatchState(stackTrace, _remoteStackTraceString, _ipForWatsonBuckets, _watsonBuckets); diff --git a/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs index 1bd94635a26..f8246642b9e 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs @@ -103,8 +103,8 @@ internal enum GC_ALLOC_FLAGS GC_ALLOC_PINNED_OBJECT_HEAP = 64, }; - [MethodImpl(MethodImplOptions.InternalCall)] - internal static extern Array AllocateNewArray(IntPtr typeHandle, int length, GC_ALLOC_FLAGS flags); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_AllocateNewArray")] + private static partial void AllocateNewArray(IntPtr typeHandlePtr, int length, GC_ALLOC_FLAGS flags, ObjectHandleOnStack ret); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_GetTotalMemory")] private static partial long GetTotalMemory(); @@ -791,16 +791,25 @@ public static unsafe T[] AllocateUninitializedArray(int length, bool pinned = { return new T[length]; } - #endif } - // Runtime overrides GC_ALLOC_ZEROING_OPTIONAL if the type contains references, so we don't need to worry about that. - GC_ALLOC_FLAGS flags = GC_ALLOC_FLAGS.GC_ALLOC_ZEROING_OPTIONAL; - if (pinned) - flags |= GC_ALLOC_FLAGS.GC_ALLOC_PINNED_OBJECT_HEAP; + return AllocateNewArrayWorker(length, pinned); + + [MethodImpl(MethodImplOptions.NoInlining)] + static T[] AllocateNewArrayWorker(int length, bool pinned) + { + // Runtime overrides GC_ALLOC_ZEROING_OPTIONAL if the type contains references, so we don't need to worry about that. + GC_ALLOC_FLAGS flags = GC_ALLOC_FLAGS.GC_ALLOC_ZEROING_OPTIONAL; + if (pinned) + { + flags |= GC_ALLOC_FLAGS.GC_ALLOC_PINNED_OBJECT_HEAP; + } - return Unsafe.As(AllocateNewArray(RuntimeTypeHandle.ToIntPtr(typeof(T[]).TypeHandle), length, flags)); + T[]? result = null; + AllocateNewArray(RuntimeTypeHandle.ToIntPtr(typeof(T[]).TypeHandle), length, flags, ObjectHandleOnStack.Create(ref result)); + return result!; + } } /// @@ -818,7 +827,9 @@ public static T[] AllocateArray(int length, bool pinned = false) // T[] rathe flags = GC_ALLOC_FLAGS.GC_ALLOC_PINNED_OBJECT_HEAP; } - return Unsafe.As(AllocateNewArray(RuntimeTypeHandle.ToIntPtr(typeof(T[]).TypeHandle), length, flags)); + T[]? result = null; + AllocateNewArray(RuntimeTypeHandle.ToIntPtr(typeof(T[]).TypeHandle), length, flags, ObjectHandleOnStack.Create(ref result)); + return result!; } [MethodImpl(MethodImplOptions.InternalCall)] diff --git a/src/coreclr/System.Private.CoreLib/src/System/IO/Stream.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/IO/Stream.CoreCLR.cs new file mode 100644 index 00000000000..18e9ca018f4 --- /dev/null +++ b/src/coreclr/System.Private.CoreLib/src/System/IO/Stream.CoreCLR.cs @@ -0,0 +1,43 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace System.IO +{ + public abstract unsafe partial class Stream + { + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Stream_HasOverriddenSlow")] + [return: MarshalAs(UnmanagedType.Bool)] + private static partial bool HasOverriddenSlow(MethodTable* pMT, [MarshalAs(UnmanagedType.Bool)] bool isRead); + + private bool HasOverriddenBeginEndRead() + { + MethodTable* pMT = RuntimeHelpers.GetMethodTable(this); + bool res = pMT->AuxiliaryData->HasCheckedStreamOverride + ? pMT->AuxiliaryData->IsStreamOverriddenRead + : HasOverriddenReadSlow(pMT); + GC.KeepAlive(this); + return res; + + [MethodImpl(MethodImplOptions.NoInlining)] + static bool HasOverriddenReadSlow(MethodTable* pMT) + => HasOverriddenSlow(pMT, isRead: true); + } + + private bool HasOverriddenBeginEndWrite() + { + MethodTable* pMT = RuntimeHelpers.GetMethodTable(this); + bool res = pMT->AuxiliaryData->HasCheckedStreamOverride + ? pMT->AuxiliaryData->IsStreamOverriddenWrite + : HasOverriddenWriteSlow(pMT); + GC.KeepAlive(this); + return res; + + [MethodImpl(MethodImplOptions.NoInlining)] + static bool HasOverriddenWriteSlow(MethodTable* pMT) + => HasOverriddenSlow(pMT, isRead: false); + } + } +} diff --git a/src/coreclr/System.Private.CoreLib/src/System/Object.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Object.CoreCLR.cs index 940d1622bad..ce1c810d8bc 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Object.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Object.CoreCLR.cs @@ -3,15 +3,32 @@ using System.Diagnostics; using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; namespace System { public partial class Object { + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ObjectNative_GetTypeSlow")] + private static unsafe partial void GetTypeSlow(MethodTable* methodTable, ObjectHandleOnStack ret); + // Returns a Type object which represent this object instance. [Intrinsic] - [MethodImpl(MethodImplOptions.InternalCall)] - public extern Type GetType(); + public unsafe Type GetType() + { + MethodTable* pMT = RuntimeHelpers.GetMethodTable(this); + Type type = pMT->AuxiliaryData->ExposedClassObject ?? GetTypeWorker(pMT); + GC.KeepAlive(this); + return type; + + [MethodImpl(MethodImplOptions.NoInlining)] + static Type GetTypeWorker(MethodTable* pMT) + { + Type? type = null; + GetTypeSlow(pMT, ObjectHandleOnStack.Create(ref type)); + return type!; + } + } // Returns a new object instance that is a memberwise copy of this // object. This is always a shallow copy of the instance. The method is protected diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs index ff1c5b85503..413a970afcf 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs @@ -2,6 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; @@ -59,6 +60,7 @@ public static void ApplyUpdate(Assembly assembly, ReadOnlySpan metadataDel /// /// Returns true if the apply assembly update is enabled and available. /// + [FeatureSwitchDefinition("System.Reflection.Metadata.MetadataUpdater.IsSupported")] public static bool IsSupported { get; } = IsApplyUpdateSupported(); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs index ccd3d9aa9ef..95bcf065264 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs @@ -115,8 +115,6 @@ public override string? CodeBase } } - internal RuntimeAssembly GetNativeHandle() => this; - // If the assembly is copied before it is loaded, the codebase will be set to the // actual file loaded if copiedName is true. If it is false, then the original code base // is returned. @@ -263,7 +261,7 @@ public override Type[] GetExportedTypes() public override IEnumerable DefinedTypes { [RequiresUnreferencedCode("Types might be removed")] - get => GetManifestModule(GetNativeHandle()).GetDefinedTypes(); + get => GetManifestModule().GetDefinedTypes(); } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetIsCollectible")] @@ -324,7 +322,7 @@ public override void GetObjectData(SerializationInfo info, StreamingContext cont public override Module ManifestModule => // We don't need to return the "external" ModuleBuilder because // it is meant to be read-only - GetManifestModule(GetNativeHandle()); + GetManifestModule(); public override object[] GetCustomAttributes(bool inherit) { @@ -586,9 +584,17 @@ private CultureInfo GetLocale() } [MethodImpl(MethodImplOptions.InternalCall)] - private static extern bool FCallIsDynamic(RuntimeAssembly assembly); + private static extern bool GetIsDynamic(IntPtr assembly); - public override bool IsDynamic => FCallIsDynamic(GetNativeHandle()); + public override bool IsDynamic + { + get + { + bool isDynamic = GetIsDynamic(GetUnderlyingNativeHandle()); + GC.KeepAlive(this); // We directly pass the native handle above - make sure this object stays alive for the call + return isDynamic; + } + } [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetSimpleName")] private static partial void GetSimpleName(QCallAssembly assembly, StringHandleOnStack retSimpleName); @@ -701,8 +707,24 @@ public override Module[] GetLoadedModules(bool getResourceModules) return GetModulesInternal(false, getResourceModules); } + private RuntimeModule GetManifestModule() + { + return GetManifestModule(this) ?? GetManifestModuleWorker(this); + + [MethodImpl(MethodImplOptions.NoInlining)] + static RuntimeModule GetManifestModuleWorker(RuntimeAssembly assembly) + { + RuntimeModule? module = null; + GetManifestModuleSlow(ObjectHandleOnStack.Create(ref assembly), ObjectHandleOnStack.Create(ref module)); + return module!; + } + } + [MethodImpl(MethodImplOptions.InternalCall)] - internal static extern RuntimeModule GetManifestModule(RuntimeAssembly assembly); + private static extern RuntimeModule? GetManifestModule(RuntimeAssembly assembly); + + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyHandle_GetManifestModuleSlow")] + private static partial void GetManifestModuleSlow(ObjectHandleOnStack assembly, ObjectHandleOnStack module); [MethodImpl(MethodImplOptions.InternalCall)] internal static extern int GetToken(RuntimeAssembly assembly); @@ -713,7 +735,7 @@ public sealed override Type[] GetForwardedTypes() List types = new List(); List exceptions = new List(); - MetadataImport scope = GetManifestModule(GetNativeHandle()).MetadataImport; + MetadataImport scope = GetManifestModule().MetadataImport; scope.Enum(MetadataTokenType.ExportedType, 0, out MetadataEnumResult enumResult); RuntimeAssembly runtimeAssembly = this; QCallAssembly pAssembly = new QCallAssembly(ref runtimeAssembly); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeCustomAttributeData.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeCustomAttributeData.cs index a610a5cbe3e..2ac866f246f 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeCustomAttributeData.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeCustomAttributeData.cs @@ -82,7 +82,7 @@ internal static IList GetCustomAttributesInternal(RuntimeAs // No pseudo attributes for RuntimeAssembly - return GetCustomAttributes((RuntimeModule)target.ManifestModule, RuntimeAssembly.GetToken(target.GetNativeHandle())); + return GetCustomAttributes((RuntimeModule)target.ManifestModule, RuntimeAssembly.GetToken(target)); } internal static IList GetCustomAttributesInternal(RuntimeParameterInfo target) @@ -1227,7 +1227,7 @@ internal static bool IsDefined(RuntimeAssembly assembly, RuntimeType caType) Debug.Assert(caType is not null); // No pseudo attributes for RuntimeAssembly - return IsCustomAttributeDefined((assembly.ManifestModule as RuntimeModule)!, RuntimeAssembly.GetToken(assembly.GetNativeHandle()), caType); + return IsCustomAttributeDefined((assembly.ManifestModule as RuntimeModule)!, RuntimeAssembly.GetToken(assembly), caType); } internal static bool IsDefined(RuntimeModule module, RuntimeType caType) @@ -1388,7 +1388,7 @@ internal static object[] GetCustomAttributes(RuntimeAssembly assembly, RuntimeTy // No pseudo attributes for RuntimeAssembly - int assemblyToken = RuntimeAssembly.GetToken(assembly.GetNativeHandle()); + int assemblyToken = RuntimeAssembly.GetToken(assembly); return GetCustomAttributes((assembly.ManifestModule as RuntimeModule)!, assemblyToken, 0, caType); } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/ICastableHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/ICastableHelpers.cs deleted file mode 100644 index ca9f73a5c66..00000000000 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/ICastableHelpers.cs +++ /dev/null @@ -1,25 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Diagnostics.CodeAnalysis; - -namespace System.Runtime.CompilerServices -{ - /// - /// Helpers that allows VM to call into ICastable methods without having to deal with RuntimeTypeHandle. - /// RuntimeTypeHandle is a struct and is always passed in stack in x86, which our VM call helpers don't - /// particularly like. - /// - internal static class ICastableHelpers - { - internal static bool IsInstanceOfInterface(ICastable castable, RuntimeType type, [NotNullWhen(true)] out Exception? castError) - { - return castable.IsInstanceOfInterface(new RuntimeTypeHandle(type), out castError); - } - - internal static RuntimeType GetImplType(ICastable castable, RuntimeType interfaceType) - { - return castable.GetImplType(new RuntimeTypeHandle(interfaceType)).GetRuntimeType(); - } - } -} diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs index e155b109886..77311a02421 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs @@ -220,19 +220,35 @@ public static unsafe void PrepareMethod(RuntimeMethodHandle method, RuntimeTypeH [MethodImpl(MethodImplOptions.InternalCall)] public static extern void PrepareDelegate(Delegate d); - [MethodImpl(MethodImplOptions.InternalCall)] - public static extern int GetHashCode(object? o); - /// /// If a hash code has been assigned to the object, it is returned. Otherwise zero is /// returned. /// - /// - /// The advantage of this over is that it avoids assigning a hash - /// code to the object if it does not already have one. - /// [MethodImpl(MethodImplOptions.InternalCall)] - internal static extern int TryGetHashCode(object o); + internal static extern int TryGetHashCode(object? o); + + [LibraryImport(QCall, EntryPoint = "ObjectNative_GetHashCodeSlow")] + private static partial int GetHashCodeSlow(ObjectHandleOnStack o); + + public static int GetHashCode(object? o) + { + int hashCode = TryGetHashCode(o); + if (hashCode == 0) + { + return GetHashCodeWorker(o); + } + return hashCode; + + [MethodImpl(MethodImplOptions.NoInlining)] + static int GetHashCodeWorker(object? o) + { + if (o is null) + { + return 0; + } + return GetHashCodeSlow(ObjectHandleOnStack.Create(ref o)); + } + } public static new unsafe bool Equals(object? o1, object? o2) { @@ -344,6 +360,11 @@ internal static int EnumCompareTo(T x, T y) where T : struct, Enum return x.CompareTo(y); } + // The body of this function will be created by the EE for the specific type. + // See getILIntrinsicImplementation for how this happens. + [Intrinsic] + internal static extern unsafe void CopyConstruct(T* dest, T* src) where T : unmanaged; + internal static ref byte GetRawData(this object obj) => ref Unsafe.As(obj).Data; @@ -420,16 +441,8 @@ internal static unsafe bool ObjectHasComponentSize(object obj) // // GC.KeepAlive(o); // - [MethodImpl(MethodImplOptions.AggressiveInlining)] [Intrinsic] - internal static unsafe MethodTable* GetMethodTable(object obj) - { - // The body of this function will be replaced by the EE with unsafe code - // See getILIntrinsicImplementationForRuntimeHelpers for how this happens. - - return (MethodTable*)Unsafe.Add(ref Unsafe.As(ref obj.GetRawData()), -1); - } - + internal static unsafe MethodTable* GetMethodTable(object obj) => GetMethodTable(obj); [LibraryImport(QCall, EntryPoint = "MethodTable_AreTypesEquivalent")] [return: MarshalAs(UnmanagedType.Bool)] @@ -666,7 +679,6 @@ internal unsafe struct MethodTable // Types that require non-trivial interface cast have this bit set in the category private const uint enum_flag_NonTrivialInterfaceCast = 0x00080000 // enum_flag_Category_Array | 0x40000000 // enum_flag_ComObject - | 0x00400000 // enum_flag_ICastable; | 0x10000000 // enum_flag_IDynamicInterfaceCastable; | 0x00040000; // enum_flag_Category_ValueType @@ -791,15 +803,20 @@ public TypeHandle GetArrayElementTypeHandle() } // Subset of src\vm\methodtable.h - [StructLayout(LayoutKind.Explicit)] + [StructLayout(LayoutKind.Sequential)] internal unsafe struct MethodTableAuxiliaryData { - [FieldOffset(0)] private uint Flags; + private void* LoaderModule; + private nint ExposedClassObjectRaw; private const uint enum_flag_HasCheckedCanCompareBitsOrUseFastGetHashCode = 0x0002; // Whether we have checked the overridden Equals or GetHashCode private const uint enum_flag_CanCompareBitsOrUseFastGetHashCode = 0x0004; // Is any field type or sub field type overridden Equals or GetHashCode + private const uint enum_flag_HasCheckedStreamOverride = 0x0400; + private const uint enum_flag_StreamOverriddenRead = 0x0800; + private const uint enum_flag_StreamOverriddenWrite = 0x1000; + public bool HasCheckedCanCompareBitsOrUseFastGetHashCode => (Flags & enum_flag_HasCheckedCanCompareBitsOrUseFastGetHashCode) != 0; public bool CanCompareBitsOrUseFastGetHashCode @@ -810,6 +827,34 @@ public bool CanCompareBitsOrUseFastGetHashCode return (Flags & enum_flag_CanCompareBitsOrUseFastGetHashCode) != 0; } } + + public bool HasCheckedStreamOverride => (Flags & enum_flag_HasCheckedStreamOverride) != 0; + + public bool IsStreamOverriddenRead + { + get + { + Debug.Assert(HasCheckedStreamOverride); + return (Flags & enum_flag_StreamOverriddenRead) != 0; + } + } + + public bool IsStreamOverriddenWrite + { + get + { + Debug.Assert(HasCheckedStreamOverride); + return (Flags & enum_flag_StreamOverriddenWrite) != 0; + } + } + + public RuntimeType? ExposedClassObject + { + get + { + return *(RuntimeType*)Unsafe.AsPointer(ref ExposedClassObjectRaw); + } + } } /// diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComTypes/IEnumerable.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComTypes/IEnumerable.cs deleted file mode 100644 index b3ab4f4056b..00000000000 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComTypes/IEnumerable.cs +++ /dev/null @@ -1,20 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -namespace System.Runtime.InteropServices.ComTypes -{ - /*========================================================================== - ** Interface: IEnumerable - ** Purpose: - ** This interface is redefined here since the original IEnumerable interface - ** has all its methods marked as ecall's since it is a managed standard - ** interface. This interface is used from within the runtime to make a call - ** on the COM server directly when it implements the IEnumerable interface. - ==========================================================================*/ - [Guid("496B0ABE-CDEE-11d3-88E8-00902754C43A")] - internal interface IEnumerable - { - [DispId(-4)] - Collections.IEnumerator GetEnumerator(); - } -} diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComTypes/IEnumerator.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComTypes/IEnumerator.cs deleted file mode 100644 index 1e07dcc6ded..00000000000 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComTypes/IEnumerator.cs +++ /dev/null @@ -1,13 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -namespace System.Runtime.InteropServices.ComTypes -{ - [Guid("496B0ABF-CDEE-11d3-88E8-00902754C43A")] - internal interface IEnumerator - { - bool MoveNext(); - object Current { get; } - void Reset(); - } -} diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/CustomMarshalers/EnumerableToDispatchMarshaler.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/CustomMarshalers/EnumerableToDispatchMarshaler.cs deleted file mode 100644 index 354e4b66545..00000000000 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/CustomMarshalers/EnumerableToDispatchMarshaler.cs +++ /dev/null @@ -1,51 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Collections; -using System.Runtime.Versioning; - -namespace System.Runtime.InteropServices.CustomMarshalers -{ - [SupportedOSPlatform("windows")] - internal sealed class EnumerableToDispatchMarshaler : ICustomMarshaler - { - private static readonly EnumerableToDispatchMarshaler s_enumerableToDispatchMarshaler = new EnumerableToDispatchMarshaler(); - - public static ICustomMarshaler GetInstance(string? cookie) => s_enumerableToDispatchMarshaler; - - private EnumerableToDispatchMarshaler() - { - } - - public void CleanUpManagedData(object ManagedObj) - { - } - - public void CleanUpNativeData(IntPtr pNativeData) - { - Marshal.Release(pNativeData); - } - - public int GetNativeDataSize() - { - // Return -1 to indicate the managed type this marshaler handles is not a value type. - return -1; - } - - public IntPtr MarshalManagedToNative(object ManagedObj) - { - ArgumentNullException.ThrowIfNull(ManagedObj); - - return Marshal.GetComInterfaceForObject(ManagedObj); - } - - public object MarshalNativeToManaged(IntPtr pNativeData) - { - ArgumentNullException.ThrowIfNull(pNativeData); - - object comObject = Marshal.GetObjectForIUnknown(pNativeData); - - return ComDataHelpers.GetOrCreateManagedViewFromComData(comObject, obj => new EnumerableViewOfDispatch(obj)); - } - } -} diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/CustomMarshalers/EnumerableViewOfDispatch.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/CustomMarshalers/EnumerableViewOfDispatch.cs deleted file mode 100644 index 4c23a4e3207..00000000000 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/CustomMarshalers/EnumerableViewOfDispatch.cs +++ /dev/null @@ -1,70 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Diagnostics; -using System.Runtime.InteropServices.ComTypes; -using System.Runtime.InteropServices.Marshalling; - -namespace System.Runtime.InteropServices.CustomMarshalers -{ - internal sealed class EnumerableViewOfDispatch : ICustomAdapter, Collections.IEnumerable - { - // Reserved DISPID slot for getting an enumerator from an IDispatch-implementing COM interface. - private const int DISPID_NEWENUM = -4; - private const int LCID_DEFAULT = 1; - private readonly object _dispatch; - - public EnumerableViewOfDispatch(object dispatch) - { - _dispatch = dispatch; - } - - private IDispatch Dispatch => (IDispatch)_dispatch; - - public Collections.IEnumerator GetEnumerator() - { - ComVariant result; - unsafe - { - void* resultLocal = &result; - DISPPARAMS dispParams = default; - Guid guid = Guid.Empty; - Dispatch.Invoke( - DISPID_NEWENUM, - ref guid, - LCID_DEFAULT, - InvokeFlags.DISPATCH_METHOD | InvokeFlags.DISPATCH_PROPERTYGET, - ref dispParams, - new IntPtr(resultLocal), - IntPtr.Zero, - IntPtr.Zero); - } - - Debug.Assert(OperatingSystem.IsWindows()); - IntPtr enumVariantPtr = IntPtr.Zero; - try - { - object? resultAsObject = result.ToObject(); - if (resultAsObject is not IEnumVARIANT enumVariant) - { - throw new InvalidOperationException(SR.InvalidOp_InvalidNewEnumVariant); - } - - enumVariantPtr = Marshal.GetIUnknownForObject(enumVariant); - return (Collections.IEnumerator)EnumeratorToEnumVariantMarshaler.GetInstance(null).MarshalNativeToManaged(enumVariantPtr); - } - finally - { - result.Dispose(); - - if (enumVariantPtr != IntPtr.Zero) - Marshal.Release(enumVariantPtr); - } - } - - public object GetUnderlyingObject() - { - return _dispatch; - } - } -} diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/CustomMarshalers/EnumeratorToEnumVariantMarshaler.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/CustomMarshalers/EnumeratorToEnumVariantMarshaler.cs index c6e31e1d053..05d1d810804 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/CustomMarshalers/EnumeratorToEnumVariantMarshaler.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/CustomMarshalers/EnumeratorToEnumVariantMarshaler.cs @@ -47,6 +47,9 @@ public IntPtr MarshalManagedToNative(object ManagedObj) return Marshal.GetComInterfaceForObject(nativeView); } + internal static object InternalMarshalNativeToManaged(IntPtr pNativeData) + => GetInstance(null).MarshalNativeToManaged(pNativeData); + public object MarshalNativeToManaged(IntPtr pNativeData) { ArgumentNullException.ThrowIfNull(pNativeData); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.CoreCLR.cs index d9913b6b6d9..1dde789a5ca 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.CoreCLR.cs @@ -330,6 +330,7 @@ internal static unsafe bool IsPinnable(object? obj) => (obj == null) || !RuntimeHelpers.GetMethodTable(obj)->ContainsGCPointers; #if TARGET_WINDOWS + [FeatureSwitchDefinition("System.Runtime.InteropServices.BuiltInComInterop.IsSupported")] internal static bool IsBuiltInComSupported { get; } = IsBuiltInComSupportedInternal(); [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_IsBuiltInComSupported")] diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs index 3d230536519..d78cc1ea86b 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs @@ -306,11 +306,43 @@ internal RuntimeType GetRuntimeType() [MethodImpl(MethodImplOptions.InternalCall)] internal static extern CorElementType GetCorElementType(RuntimeType type); + internal static RuntimeAssembly GetAssembly(RuntimeType type) + { + return GetAssemblyIfExists(type) ?? GetAssemblyWorker(type); + + [MethodImpl(MethodImplOptions.NoInlining)] + static RuntimeAssembly GetAssemblyWorker(RuntimeType type) + { + RuntimeAssembly? assembly = null; + GetAssemblySlow(ObjectHandleOnStack.Create(ref type), ObjectHandleOnStack.Create(ref assembly)); + return assembly!; + } + } + [MethodImpl(MethodImplOptions.InternalCall)] - internal static extern RuntimeAssembly GetAssembly(RuntimeType type); + private static extern RuntimeAssembly? GetAssemblyIfExists(RuntimeType type); + + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetAssemblySlow")] + private static partial void GetAssemblySlow(ObjectHandleOnStack type, ObjectHandleOnStack assembly); + + internal static RuntimeModule GetModule(RuntimeType type) + { + return GetModuleIfExists(type) ?? GetModuleWorker(type); + + [MethodImpl(MethodImplOptions.NoInlining)] + static RuntimeModule GetModuleWorker(RuntimeType type) + { + RuntimeModule? module = null; + GetModuleSlow(ObjectHandleOnStack.Create(ref type), ObjectHandleOnStack.Create(ref module)); + return module!; + } + } [MethodImpl(MethodImplOptions.InternalCall)] - internal static extern RuntimeModule GetModule(RuntimeType type); + private static extern RuntimeModule? GetModuleIfExists(RuntimeType type); + + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetModuleSlow")] + private static partial void GetModuleSlow(ObjectHandleOnStack type, ObjectHandleOnStack module); public ModuleHandle GetModuleHandle() { diff --git a/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs index 4d04557565c..33d9c6ef287 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs @@ -2,9 +2,14 @@ // The .NET Foundation licenses this file to you under the MIT license. using System.Diagnostics; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; +#if FEATURE_COMINTEROP +using System.Runtime.InteropServices.CustomMarshalers; +#endif using System.Runtime.InteropServices.Marshalling; +using System.Runtime.Versioning; using System.Text; namespace System.StubHelpers @@ -792,16 +797,6 @@ internal static void ClearNative(IntPtr pMarshalState, in object pManagedHome, I internal static unsafe partial class MngdRefCustomMarshaler { - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "CustomMarshaler_GetMarshalerObject")] - private static partial void GetMarshaler(IntPtr pCMHelper, ObjectHandleOnStack retMarshaler); - - internal static ICustomMarshaler GetMarshaler(IntPtr pCMHelper) - { - ICustomMarshaler? marshaler = null; - GetMarshaler(pCMHelper, ObjectHandleOnStack.Create(ref marshaler)); - return marshaler!; - } - internal static unsafe void ConvertContentsToNative(ICustomMarshaler marshaler, in object pManagedHome, IntPtr* pNativeHome) { // COMPAT: We never pass null to MarshalManagedToNative. @@ -1315,75 +1310,6 @@ public IntPtr AddRef() } } // class CleanupWorkListElement - internal unsafe struct CopyConstructorCookie - { - private void* m_source; - - private nuint m_destinationOffset; - - public delegate* m_copyConstructor; - - public delegate* m_destructor; - - public CopyConstructorCookie* m_next; - - [StackTraceHidden] - public void ExecuteCopy(void* destinationBase) - { - if (m_copyConstructor != null) - { - m_copyConstructor((byte*)destinationBase + m_destinationOffset, m_source); - } - - if (m_destructor != null) - { - m_destructor(m_source); - } - } - } - - internal unsafe struct CopyConstructorChain - { - public void* m_realTarget; - public CopyConstructorCookie* m_head; - - public void Add(CopyConstructorCookie* cookie) - { - cookie->m_next = m_head; - m_head = cookie; - } - - [ThreadStatic] - private static CopyConstructorChain s_copyConstructorChain; - - public void Install(void* realTarget) - { - m_realTarget = realTarget; - s_copyConstructorChain = this; - } - - [StackTraceHidden] - private void ExecuteCopies(void* destinationBase) - { - for (CopyConstructorCookie* current = m_head; current != null; current = current->m_next) - { - current->ExecuteCopy(destinationBase); - } - } - - [UnmanagedCallersOnly] - [StackTraceHidden] - public static void* ExecuteCurrentCopiesAndGetTarget(void* destinationBase) - { - void* target = s_copyConstructorChain.m_realTarget; - s_copyConstructorChain.ExecuteCopies(destinationBase); - // Reset this instance to ensure we don't accidentally execute the copies again. - // All of the pointers point to the stack, so we don't need to free any memory. - s_copyConstructorChain = default; - return target; - } - } - internal static partial class StubHelpers { [MethodImpl(MethodImplOptions.InternalCall)] @@ -1422,25 +1348,26 @@ internal static void DestroyCleanupList(ref CleanupWorkListElement? pCleanupWork internal static Exception GetHRExceptionObject(int hr) { - Exception ex = InternalGetHRExceptionObject(hr); - ex.InternalPreserveStackTrace(); - return ex; + Exception? ex = null; + GetHRExceptionObject(hr, ObjectHandleOnStack.Create(ref ex)); + ex!.InternalPreserveStackTrace(); + return ex!; } - [MethodImpl(MethodImplOptions.InternalCall)] - internal static extern Exception InternalGetHRExceptionObject(int hr); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_GetHRExceptionObject")] + private static partial void GetHRExceptionObject(int hr, ObjectHandleOnStack throwable); #if FEATURE_COMINTEROP internal static Exception GetCOMHRExceptionObject(int hr, IntPtr pCPCMD, object pThis) { - Exception ex = InternalGetCOMHRExceptionObject(hr, pCPCMD, pThis); - ex.InternalPreserveStackTrace(); - return ex; + Exception? ex = null; + GetCOMHRExceptionObject(hr, pCPCMD, ObjectHandleOnStack.Create(ref pThis), ObjectHandleOnStack.Create(ref ex)); + ex!.InternalPreserveStackTrace(); + return ex!; } - [MethodImpl(MethodImplOptions.InternalCall)] - internal static extern Exception InternalGetCOMHRExceptionObject(int hr, IntPtr pCPCMD, object? pThis); - + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_GetCOMHRExceptionObject")] + private static partial void GetCOMHRExceptionObject(int hr, IntPtr pCPCMD, ObjectHandleOnStack pThis, ObjectHandleOnStack throwable); #endif // FEATURE_COMINTEROP [ThreadStatic] @@ -1463,8 +1390,28 @@ internal static void SetPendingExceptionObject(Exception? exception) s_pendingExceptionObject = exception; } - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_CreateCustomMarshalerHelper")] - internal static partial IntPtr CreateCustomMarshalerHelper(IntPtr pMD, int paramToken, IntPtr hndManagedType); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_CreateCustomMarshaler")] + internal static partial void CreateCustomMarshaler(IntPtr pMD, int paramToken, IntPtr hndManagedType, ObjectHandleOnStack customMarshaler); + +#if FEATURE_COMINTEROP + [SupportedOSPlatform("windows")] + internal static object GetIEnumeratorToEnumVariantMarshaler() => EnumeratorToEnumVariantMarshaler.GetInstance(string.Empty); +#endif + + internal static object CreateCustomMarshaler(IntPtr pMD, int paramToken, IntPtr hndManagedType) + { +#if FEATURE_COMINTEROP + if (OperatingSystem.IsWindows() + && hndManagedType == typeof(System.Collections.IEnumerator).TypeHandle.Value) + { + return GetIEnumeratorToEnumVariantMarshaler(); + } +#endif + + object? retVal = null; + CreateCustomMarshaler(pMD, paramToken, hndManagedType, ObjectHandleOnStack.Create(ref retVal)); + return retVal!; + } //------------------------------------------------------- // SafeHandle Helpers @@ -1495,18 +1442,38 @@ internal static void SafeHandleRelease(SafeHandle pHandle) #if FEATURE_COMINTEROP [MethodImpl(MethodImplOptions.InternalCall)] - internal static extern IntPtr GetCOMIPFromRCW(object objSrc, IntPtr pCPCMD, out IntPtr ppTarget, out bool pfNeedsRelease); + private static extern IntPtr GetCOMIPFromRCW(object objSrc, IntPtr pCPCMD, out IntPtr ppTarget); + + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_GetCOMIPFromRCWSlow")] + private static partial IntPtr GetCOMIPFromRCWSlow(ObjectHandleOnStack objSrc, IntPtr pCPCMD, out IntPtr ppTarget); + + internal static IntPtr GetCOMIPFromRCW(object objSrc, IntPtr pCPCMD, out IntPtr ppTarget, out bool pfNeedsRelease) + { + IntPtr rcw = GetCOMIPFromRCW(objSrc, pCPCMD, out ppTarget); + if (rcw == IntPtr.Zero) + { + // If we didn't find the COM interface pointer in the cache we need to release the pointer. + pfNeedsRelease = true; + return GetCOMIPFromRCWWorker(objSrc, pCPCMD, out ppTarget); + } + pfNeedsRelease = false; + return rcw; + + [MethodImpl(MethodImplOptions.NoInlining)] + static IntPtr GetCOMIPFromRCWWorker(object objSrc, IntPtr pCPCMD, out IntPtr ppTarget) + => GetCOMIPFromRCWSlow(ObjectHandleOnStack.Create(ref objSrc), pCPCMD, out ppTarget); + } #endif // FEATURE_COMINTEROP +#if PROFILING_SUPPORTED //------------------------------------------------------- // Profiler helpers //------------------------------------------------------- -#if PROFILING_SUPPORTED - [MethodImpl(MethodImplOptions.InternalCall)] - internal static extern IntPtr ProfilerBeginTransitionCallback(IntPtr pSecretParam, IntPtr pThread, object pThis); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_ProfilerBeginTransitionCallback")] + internal static unsafe partial void* ProfilerBeginTransitionCallback(void* pTargetMD); - [MethodImpl(MethodImplOptions.InternalCall)] - internal static extern void ProfilerEndTransitionCallback(IntPtr pMD, IntPtr pThread); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "StubHelpers_ProfilerEndTransitionCallback")] + internal static unsafe partial void ProfilerEndTransitionCallback(void* pTargetMD); #endif // PROFILING_SUPPORTED //------------------------------------------------------ @@ -1591,26 +1558,26 @@ internal static unsafe void LayoutDestroyNativeInternal(object obj, byte* pNativ } } - [MethodImpl(MethodImplOptions.InternalCall)] - internal static extern object AllocateInternal(IntPtr typeHandle); - - [MethodImpl(MethodImplOptions.InternalCall)] - internal static extern void MarshalToUnmanagedVaListInternal(IntPtr va_list, uint vaListSize, IntPtr pArgIterator); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_MarshalToManagedVaList")] + internal static partial void MarshalToManagedVaList(IntPtr va_list, IntPtr pArgIterator); - [MethodImpl(MethodImplOptions.InternalCall)] - internal static extern void MarshalToManagedVaListInternal(IntPtr va_list, IntPtr pArgIterator); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_MarshalToUnmanagedVaList")] + internal static partial void MarshalToUnmanagedVaList(IntPtr va_list, uint vaListSize, IntPtr pArgIterator); [MethodImpl(MethodImplOptions.InternalCall)] internal static extern uint CalcVaListSize(IntPtr va_list); - [MethodImpl(MethodImplOptions.InternalCall)] - internal static extern void ValidateObject(object obj, IntPtr pMD, object pThis); - [MethodImpl(MethodImplOptions.InternalCall)] internal static extern void LogPinnedArgument(IntPtr localDesc, IntPtr nativeArg); - [MethodImpl(MethodImplOptions.InternalCall)] - internal static extern void ValidateByref(IntPtr byref, IntPtr pMD, object pThis); // the byref is pinned so we can safely "cast" it to IntPtr + [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_ValidateObject")] + private static partial void ValidateObject(ObjectHandleOnStack obj, IntPtr pMD); + + internal static void ValidateObject(object obj, IntPtr pMD) + => ValidateObject(ObjectHandleOnStack.Create(ref obj), pMD); + + [LibraryImport(RuntimeHelpers.QCall, EntryPoint="StubHelpers_ValidateByref")] + internal static partial void ValidateByref(IntPtr byref, IntPtr pMD); // the byref is pinned so we can safely "cast" it to IntPtr [Intrinsic] [MethodImpl(MethodImplOptions.InternalCall)] @@ -1623,4 +1590,37 @@ internal static unsafe void LayoutDestroyNativeInternal(object obj, byte* pNativ [MethodImpl(MethodImplOptions.InternalCall)] internal static extern IntPtr NextCallReturnAddress(); } // class StubHelpers + +#if FEATURE_COMINTEROP + internal static class ColorMarshaler + { + private static readonly MethodInvoker s_oleColorToDrawingColorMethod; + private static readonly MethodInvoker s_drawingColorToOleColorMethod; + + internal static readonly IntPtr s_colorType; + +#pragma warning disable CA1810 // explicit static cctor + static ColorMarshaler() + { + Type colorTranslatorType = Type.GetType("System.Drawing.ColorTranslator, System.Drawing.Primitives", throwOnError: true)!; + Type colorType = Type.GetType("System.Drawing.Color, System.Drawing.Primitives", throwOnError: true)!; + + s_colorType = colorType.TypeHandle.Value; + + s_oleColorToDrawingColorMethod = MethodInvoker.Create(colorTranslatorType.GetMethod("FromOle", [typeof(int)])!); + s_drawingColorToOleColorMethod = MethodInvoker.Create(colorTranslatorType.GetMethod("ToOle", [colorType])!); + } +#pragma warning restore CA1810 // explicit static cctor + + internal static object ConvertToManaged(int managedColor) + { + return s_oleColorToDrawingColorMethod.Invoke(null, managedColor)!; + } + + internal static int ConvertToNative(object? managedColor) + { + return (int)s_drawingColorToOleColorMethod.Invoke(null, managedColor)!; + } + } +#endif } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Threading/LowLevelLifoSemaphore.Unix.cs b/src/coreclr/System.Private.CoreLib/src/System/Threading/LowLevelLifoSemaphore.Unix.cs index 8fe80e72868..25fc6ff09ad 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Threading/LowLevelLifoSemaphore.Unix.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Threading/LowLevelLifoSemaphore.Unix.cs @@ -31,7 +31,7 @@ public bool WaitCore(int timeoutMs) return waitResult == WaitHandle.WaitSuccess; } - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "WaitHandle_CorWaitOnePrioritizedNative")] + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "WaitHandle_WaitOnePrioritized")] private static partial int WaitNative(SafeWaitHandle handle, int timeoutMs); private void ReleaseCore(int count) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs index 45a24e61b28..08b3ae8944d 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs @@ -58,6 +58,9 @@ public sealed partial class Thread // but those types of changes may race with the reset anyway, so this field doesn't need to be synchronized. private bool _mayNeedResetForThreadPool; + // Set in unmanaged and read in managed code. + private bool _isDead; + private Thread() { } public int ManagedThreadId @@ -74,7 +77,7 @@ internal ThreadHandle GetNativeHandle() // This should never happen under normal circumstances. if (thread == IntPtr.Zero) { - throw new ArgumentException(null, SR.Argument_InvalidHandle); + throw new ThreadStateException(SR.Argument_InvalidHandle); } return new ThreadHandle(thread); @@ -104,12 +107,6 @@ private void StartCallback() startHelper.Run(); } - // Invoked by VM. Helper method to get a logical thread ID for StringBuilder (for - // correctness) and for FileStream's async code path (for perf, to avoid creating - // a Thread instance). - [MethodImpl(MethodImplOptions.InternalCall)] - private static extern IntPtr InternalGetCurrentThread(); - /// /// Suspends the current thread for timeout milliseconds. If timeout == 0, /// forces the thread to give up the remainder of its timeslice. If timeout @@ -154,13 +151,24 @@ public static void SpinWait(int iterations) public static bool Yield() => YieldInternal() != Interop.BOOL.FALSE; [MethodImpl(MethodImplOptions.NoInlining)] - private static Thread InitializeCurrentThread() => t_currentThread = GetCurrentThreadNative(); + private static Thread InitializeCurrentThread() + { + Thread? thread = null; + GetCurrentThread(ObjectHandleOnStack.Create(ref thread)); + return t_currentThread = thread!; + } - [MethodImpl(MethodImplOptions.InternalCall)] - private static extern Thread GetCurrentThreadNative(); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_GetCurrentThread")] + private static partial void GetCurrentThread(ObjectHandleOnStack thread); - [MethodImpl(MethodImplOptions.InternalCall)] - private extern void Initialize(); + private void Initialize() + { + Thread _this = this; + Initialize(ObjectHandleOnStack.Create(ref _this)); + } + + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_Initialize")] + private static partial void Initialize(ObjectHandleOnStack thread); /// Clean up the thread when it goes away. ~Thread() => InternalFinalize(); // Delegate to the unmanaged portion. @@ -178,11 +186,7 @@ partial void ThreadNameChanged(string? value) private static partial void InformThreadNameChange(ThreadHandle t, string? name, int len); /// Returns true if the thread has been started and is not dead. - public extern bool IsAlive - { - [MethodImpl(MethodImplOptions.InternalCall)] - get; - } + public bool IsAlive => (ThreadState & (ThreadState.Unstarted | ThreadState.Stopped | ThreadState.Aborted)) == 0; /// /// Return whether or not this thread is a background thread. Background @@ -217,13 +221,25 @@ public extern bool IsThreadPoolThread internal set; } + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_SetPriority")] + [return: MarshalAs(UnmanagedType.Bool)] + private static partial void SetPriority(ObjectHandleOnStack thread, int priority); + /// Returns the priority of the thread. public ThreadPriority Priority { - get => (ThreadPriority)GetPriorityNative(); + get + { + if (_isDead) + { + throw new ThreadStateException(SR.ThreadState_Dead_Priority); + } + return (ThreadPriority)_priority; + } set { - SetPriorityNative((int)value); + Thread _this = this; + SetPriority(ObjectHandleOnStack.Create(ref _this), (int)value); if (value != ThreadPriority.Normal) { _mayNeedResetForThreadPool = true; @@ -231,12 +247,6 @@ public ThreadPriority Priority } } - [MethodImpl(MethodImplOptions.InternalCall)] - private extern int GetPriorityNative(); - - [MethodImpl(MethodImplOptions.InternalCall)] - private extern void SetPriorityNative(int priority); - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_GetCurrentOSThreadId")] private static partial ulong GetCurrentOSThreadId(); @@ -244,26 +254,45 @@ public ThreadPriority Priority /// Return the thread state as a consistent set of bits. This is more /// general then IsAlive or IsBackground. /// - public ThreadState ThreadState => (ThreadState)GetThreadStateNative(); - - [MethodImpl(MethodImplOptions.InternalCall)] - private extern int GetThreadStateNative(); + public ThreadState ThreadState + { + get + { + var state = (ThreadState)GetThreadState(GetNativeHandle()); + GC.KeepAlive(this); + return state; + } + } - public ApartmentState GetApartmentState() => -#if FEATURE_COMINTEROP_APARTMENT_SUPPORT - (ApartmentState)GetApartmentStateNative(); -#else // !FEATURE_COMINTEROP_APARTMENT_SUPPORT - ApartmentState.Unknown; -#endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT + [SuppressGCTransition] + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_GetThreadState")] + private static partial int GetThreadState(ThreadHandle t); /// /// An unstarted thread can be marked to indicate that it will host a /// single-threaded or multi-threaded apartment. /// #if FEATURE_COMINTEROP_APARTMENT_SUPPORT + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_GetApartmentState")] + private static partial int GetApartmentState(ObjectHandleOnStack t); + + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_SetApartmentState")] + private static partial int SetApartmentState(ObjectHandleOnStack t, int state); + + public ApartmentState GetApartmentState() + { + Thread _this = this; + return (ApartmentState)GetApartmentState(ObjectHandleOnStack.Create(ref _this)); + } + private bool SetApartmentStateUnchecked(ApartmentState state, bool throwOnError) { - ApartmentState retState = (ApartmentState)SetApartmentStateNative((int)state); + ApartmentState retState; + lock (this) // This lock is only needed when the this is not the current thread. + { + Thread _this = this; + retState = (ApartmentState)SetApartmentState(ObjectHandleOnStack.Create(ref _this), (int)state); + } // Special case where we pass in Unknown and get back MTA. // Once we CoUninitialize the thread, the OS will still @@ -288,12 +317,9 @@ private bool SetApartmentStateUnchecked(ApartmentState state, bool throwOnError) return true; } - [MethodImpl(MethodImplOptions.InternalCall)] - internal extern int GetApartmentStateNative(); - - [MethodImpl(MethodImplOptions.InternalCall)] - internal extern int SetApartmentStateNative(int state); #else // FEATURE_COMINTEROP_APARTMENT_SUPPORT + public ApartmentState GetApartmentState() => ApartmentState.Unknown; + private static bool SetApartmentStateUnchecked(ApartmentState state, bool throwOnError) { if (state != ApartmentState.Unknown) @@ -317,6 +343,7 @@ public void DisableComObjectEagerCleanup() GC.KeepAlive(this); } + [SuppressGCTransition] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_DisableComObjectEagerCleanup")] private static partial void DisableComObjectEagerCleanup(ThreadHandle t); #else // !FEATURE_COMINTEROP @@ -337,6 +364,10 @@ public void Interrupt() [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_Interrupt")] private static partial void Interrupt(ThreadHandle t); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_Join")] + [return: MarshalAs(UnmanagedType.Bool)] + private static partial bool Join(ObjectHandleOnStack thread, int millisecondsTimeout); + /// /// Waits for the thread to die or for timeout milliseconds to elapse. /// @@ -344,11 +375,20 @@ public void Interrupt() /// Returns true if the thread died, or false if the wait timed out. If /// -1 is given as the parameter, no timeout will occur. /// - /// if timeout < -1 (Timeout.Infinite) + /// if timeout < -1 (Timeout.Infinite) /// if the thread is interrupted while waiting /// if the thread has not been started yet - [MethodImpl(MethodImplOptions.InternalCall)] - public extern bool Join(int millisecondsTimeout); + public bool Join(int millisecondsTimeout) + { + // Validate the timeout + if (millisecondsTimeout < 0 && millisecondsTimeout != Timeout.Infinite) + { + throw new ArgumentOutOfRangeException(nameof(millisecondsTimeout), SR.ArgumentOutOfRange_NeedNonNegOrNegative1); + } + + Thread _this = this; + return Join(ObjectHandleOnStack.Create(ref _this), millisecondsTimeout); + } /// /// Max value to be passed into for optimal delaying. This value is normalized to be diff --git a/src/coreclr/System.Private.CoreLib/src/System/Threading/WaitHandle.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Threading/WaitHandle.CoreCLR.cs index f1bfe33e8c8..a9fc4d8b2a0 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Threading/WaitHandle.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Threading/WaitHandle.CoreCLR.cs @@ -8,23 +8,18 @@ namespace System.Threading { public abstract partial class WaitHandle { - [MethodImpl(MethodImplOptions.InternalCall)] - private static extern int WaitOneCore(IntPtr waitHandle, int millisecondsTimeout, bool useTrivialWaits); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "WaitHandle_WaitOneCore")] + private static partial int WaitOneCore(IntPtr waitHandle, int millisecondsTimeout, [MarshalAs(UnmanagedType.Bool)] bool useTrivialWaits); private static unsafe int WaitMultipleIgnoringSyncContextCore(ReadOnlySpan waitHandles, bool waitAll, int millisecondsTimeout) - { - fixed (IntPtr* pWaitHandles = &MemoryMarshal.GetReference(waitHandles)) - { - return WaitMultipleIgnoringSyncContext(pWaitHandles, waitHandles.Length, waitAll, millisecondsTimeout); - } - } + => WaitMultipleIgnoringSyncContext(waitHandles, waitHandles.Length, waitAll, millisecondsTimeout); - [MethodImpl(MethodImplOptions.InternalCall)] - private static extern unsafe int WaitMultipleIgnoringSyncContext(IntPtr* waitHandles, int numHandles, bool waitAll, int millisecondsTimeout); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "WaitHandle_WaitMultipleIgnoringSyncContext")] + private static partial int WaitMultipleIgnoringSyncContext(ReadOnlySpan waitHandles, int numHandles, [MarshalAs(UnmanagedType.Bool)] bool waitAll, int millisecondsTimeout); private static int SignalAndWaitCore(IntPtr waitHandleToSignal, IntPtr waitHandleToWaitOn, int millisecondsTimeout) { - int ret = SignalAndWaitNative(waitHandleToSignal, waitHandleToWaitOn, millisecondsTimeout); + int ret = SignalAndWait(waitHandleToSignal, waitHandleToWaitOn, millisecondsTimeout); if (ret == Interop.Errors.ERROR_TOO_MANY_POSTS) { @@ -34,7 +29,7 @@ private static int SignalAndWaitCore(IntPtr waitHandleToSignal, IntPtr waitHandl return ret; } - [MethodImpl(MethodImplOptions.InternalCall)] - private static extern int SignalAndWaitNative(IntPtr waitHandleToSignal, IntPtr waitHandleToWaitOn, int millisecondsTimeout); + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "WaitHandle_SignalAndWait")] + private static partial int SignalAndWait(IntPtr waitHandleToSignal, IntPtr waitHandleToWaitOn, int millisecondsTimeout); } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Variant.cs b/src/coreclr/System.Private.CoreLib/src/System/Variant.cs index 1ee6acc5be1..3e8d4f66204 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Variant.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Variant.cs @@ -1,400 +1,363 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -/*============================================================ -** -** -** -** Purpose: The CLR implementation of Variant. -** -** -===========================================================*/ - using System.Diagnostics; using System.Globalization; +using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; +using System.Runtime.InteropServices.Marshalling; +using System.StubHelpers; + +#pragma warning disable CA1416 // COM interop is only supported on Windows namespace System { - internal partial struct Variant + // Contains code for built-in marshalling of OLE VARIANT. + internal static partial class Variant { - // Do Not change the order of these fields. - // They are mapped to the native VariantData * data structure. - private object? _objref; - private long _data; - private int _flags; - - // The following bits have been taken up as follows - // bits 0-15 - Type code - // bit 16 - Array - // bits 19-23 - Enums - // bits 24-31 - Optional VT code (for roundtrip VT preservation) - - // What are the consequences of making this an enum? - /////////////////////////////////////////////////////////////////////// - // If you update this, update the corresponding stuff in OAVariantLib.cs, - // OAVariant.cpp (2 tables, forwards and reverse), and perhaps OleVariant.h - /////////////////////////////////////////////////////////////////////// - internal const int CV_EMPTY = 0x0; - internal const int CV_VOID = 0x1; - internal const int CV_BOOLEAN = 0x2; - internal const int CV_CHAR = 0x3; - internal const int CV_I1 = 0x4; - internal const int CV_U1 = 0x5; - internal const int CV_I2 = 0x6; - internal const int CV_U2 = 0x7; - internal const int CV_I4 = 0x8; - internal const int CV_U4 = 0x9; - internal const int CV_I8 = 0xa; - internal const int CV_U8 = 0xb; - internal const int CV_R4 = 0xc; - internal const int CV_R8 = 0xd; - internal const int CV_STRING = 0xe; - internal const int CV_PTR = 0xf; - internal const int CV_DATETIME = 0x10; - internal const int CV_TIMESPAN = 0x11; - internal const int CV_OBJECT = 0x12; - internal const int CV_DECIMAL = 0x13; - internal const int CV_ENUM = 0x15; - internal const int CV_MISSING = 0x16; - internal const int CV_NULL = 0x17; - internal const int CV_LAST = 0x18; - - internal const int TypeCodeBitMask = 0xffff; - internal const int VTBitMask = unchecked((int)0xff000000); - internal const int VTBitShift = 24; - internal const int ArrayBitMask = 0x10000; - - internal static Variant Empty => default; - internal static Variant Missing => new Variant(CV_MISSING, Type.Missing, 0); - internal static Variant DBNull => new Variant(CV_NULL, System.DBNull.Value, 0); - internal static bool IsSystemDrawingColor(Type type) => type.FullName == "System.Drawing.Color"; // Matches the behavior of IsTypeRefOrDef - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Variant_ConvertSystemColorToOleColor")] - internal static partial uint ConvertSystemColorToOleColor(ObjectHandleOnStack obj); - - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Variant_ConvertOleColorToSystemColor")] - internal static partial void ConvertOleColorToSystemColor(ObjectHandleOnStack objret, uint value, IntPtr pMT); - - // - // Native Methods - // - [MethodImpl(MethodImplOptions.InternalCall)] - internal extern void SetFieldsObject(object val); - - // - // Constructors - // + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Variant_ConvertValueTypeToRecord")] + private static partial void ConvertValueTypeToRecord(ObjectHandleOnStack obj, out ComVariant pOle); - internal Variant(int flags, object or, long data) + internal static ComVariant GetIUnknownOrIDispatchFromObject(object? obj) { - _flags = flags; - _objref = or; - _data = data; + IntPtr pUnk = GetIUnknownOrIDispatchForObject(ObjectHandleOnStack.Create(ref obj), out bool isIDispatch); + return ComVariant.CreateRaw(isIDispatch ? VarEnum.VT_DISPATCH : VarEnum.VT_UNKNOWN, pUnk); } - public Variant(bool val) - { - _objref = null; - _flags = CV_BOOLEAN; - _data = (val) ? bool.True : bool.False; - } - - public Variant(sbyte val) - { - _objref = null; - _flags = CV_I1; - _data = val; - } + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "MarshalNative_GetIUnknownOrIDispatchForObject")] + private static partial IntPtr GetIUnknownOrIDispatchForObject(ObjectHandleOnStack o, [MarshalAs(UnmanagedType.Bool)] out bool isIDispatch); - public Variant(byte val) + private static object? GetObjectFromIUnknown(IntPtr pUnk) { - _objref = null; - _flags = CV_U1; - _data = val; + return pUnk == IntPtr.Zero ? null : Marshal.GetObjectForIUnknown(pUnk); } - public Variant(short val) + private static unsafe object? ConvertWrappedObject(object? wrapped) { - _objref = null; - _flags = CV_I2; - _data = val; - } + // Historically, for UnknownWrapper and DispatchWrapper, the wrapped object is passed + // into Variant.SetFieldsObject, and the result set in objRef field is used for + // IUnknown/IDispatch marshalling. Here the behavior is simulated. - public Variant(ushort val) - { - _objref = null; - _flags = CV_U2; - _data = val; - } - - public Variant(char val) - { - _objref = null; - _flags = CV_CHAR; - _data = val; - } - - public Variant(int val) - { - _objref = null; - _flags = CV_I4; - _data = val; - } - - public Variant(uint val) - { - _objref = null; - _flags = CV_U4; - _data = val; - } + if (wrapped is ValueType) + { + // Enums are stored with underlying value in number bits, and type in objRef field. + if (wrapped is Enum) + return wrapped.GetType(); - public Variant(long val) - { - _objref = null; - _flags = CV_I8; - _data = val; - } + // Primitive types (ELEMENT_TYPE_BOOLEAN through ELEMENT_TYPE_STRING, IntPtr/UIntPtr + // not included) don't have objRef set and become null. + if (wrapped is IntPtr or UIntPtr) + return wrapped; - public Variant(ulong val) - { - _objref = null; - _flags = CV_U8; - _data = (long)val; - } + if (wrapped.GetType().IsPrimitive) + return null; - public Variant(float val) - { - _objref = null; - _flags = CV_R4; - _data = BitConverter.SingleToUInt32Bits(val); - } + // System.Drawing.Color is converted to UInt32. + if (IsSystemDrawingColor(wrapped.GetType())) + return null; - public Variant(double val) - { - _objref = null; - _flags = CV_R8; - _data = BitConverter.DoubleToInt64Bits(val); - } + // DateTime, TimeSpan and Currency are stored with corresponding types with + // objectRef unset. + if (wrapped is DateTime or TimeSpan or Currency) + return null; - public Variant(DateTime val) - { - _objref = null; - _flags = CV_DATETIME; - _data = val.Ticks; - } + // Other value types are boxed as-is. + return wrapped; + } + else + { + // Empty is stored with null objRef. + // DBNull and Missing are stored with corresponding types, with objRef also set. + if (wrapped is Empty) + return null; - public Variant(decimal val) - { - _objref = (object)val; - _flags = CV_DECIMAL; - _data = 0; + return wrapped; + } } - public Variant(object? obj) + // Helper code for marshaling managed objects to VARIANT's + internal static void MarshalHelperConvertObjectToVariant(object? o, out ComVariant pOle) { - _data = 0; - - VarEnum vt = VarEnum.VT_EMPTY; + // Cases handled at native side: string, bool, primitives including (U)IntPtr excluding U(Int)64, array - if (obj is DateTime) + switch (o) { - _objref = null; - _flags = CV_DATETIME; - _data = ((DateTime)obj).Ticks; - return; - } + case null: + pOle = default; + break; - if (obj is string) - { - _flags = CV_STRING; - _objref = obj; - return; - } + case IConvertible ic when ic.GetTypeCode() != TypeCode.Object: + { + IFormatProvider provider = CultureInfo.InvariantCulture; + pOle = ic.GetTypeCode() switch + { + TypeCode.Empty => default, + TypeCode.DBNull => ComVariant.Create(DBNull.Value), + TypeCode.Boolean => ComVariant.Create(ic.ToBoolean(provider)), + TypeCode.Char => ComVariant.Create((ushort)ic.ToChar(provider)), + TypeCode.SByte => ComVariant.Create(ic.ToSByte(provider)), + TypeCode.Byte => ComVariant.Create(ic.ToByte(provider)), + TypeCode.Int16 => ComVariant.Create(ic.ToInt16(provider)), + TypeCode.UInt16 => ComVariant.Create(ic.ToUInt16(provider)), + TypeCode.Int32 => ComVariant.Create(ic.ToInt32(provider)), + TypeCode.UInt32 => ComVariant.Create(ic.ToUInt32(provider)), + TypeCode.Int64 => ComVariant.Create(ic.ToInt64(provider)), + TypeCode.UInt64 => ComVariant.Create(ic.ToUInt64(provider)), + TypeCode.Single => ComVariant.Create(ic.ToSingle(provider)), + TypeCode.Double => ComVariant.Create(ic.ToDouble(provider)), + TypeCode.Decimal => ComVariant.Create(ic.ToDecimal(provider)), + TypeCode.DateTime => ComVariant.Create(ic.ToDateTime(provider)), + TypeCode.String => ComVariant.Create(ic.ToString(provider)), + _ => throw new NotSupportedException(SR.Format(SR.NotSupported_UnknownTypeCode, ic.GetTypeCode())), + }; + break; + } - if (obj == null) - { - this = Empty; - return; - } - if (obj == System.DBNull.Value) - { - this = DBNull; - return; - } - if (obj == Type.Missing) - { - this = Missing; - return; - } + case Missing: + pOle = ComVariant.CreateRaw(VarEnum.VT_ERROR, HResults.DISP_E_PARAMNOTFOUND); + break; - if (obj is Array) - { - _flags = CV_OBJECT | ArrayBitMask; - _objref = obj; - return; - } + // Array handled by native side - // Compiler appeasement - _flags = CV_EMPTY; - _objref = null; + case UnknownWrapper wrapper: + { + object? wrapped = ConvertWrappedObject(wrapper.WrappedObject); + pOle = ComVariant.CreateRaw(VarEnum.VT_UNKNOWN, + wrapped is null ? IntPtr.Zero : Marshal.GetIUnknownForObject(wrapped)); + break; + } + case DispatchWrapper wrapper: + { + object? wrapped = ConvertWrappedObject(wrapper.WrappedObject); + pOle = ComVariant.CreateRaw(VarEnum.VT_DISPATCH, + wrapped is null ? IntPtr.Zero : Marshal.GetIDispatchForObject(wrapped)); + break; + } - // Check to see if the object passed in is a wrapper object. - if (obj is UnknownWrapper) - { - vt = VarEnum.VT_UNKNOWN; - obj = ((UnknownWrapper)obj).WrappedObject; - } - else if (obj is DispatchWrapper) - { - vt = VarEnum.VT_DISPATCH; - Debug.Assert(OperatingSystem.IsWindows()); - obj = ((DispatchWrapper)obj).WrappedObject; - } - else if (obj is ErrorWrapper) - { - vt = VarEnum.VT_ERROR; - obj = (object)(((ErrorWrapper)obj).ErrorCode); - Debug.Assert(obj != null); - } + case ErrorWrapper wrapper: + pOle = ComVariant.Create(wrapper); + break; #pragma warning disable 0618 // CurrencyWrapper is obsolete - else if (obj is CurrencyWrapper) - { - vt = VarEnum.VT_CY; - obj = (object)(((CurrencyWrapper)obj).WrappedObject); - Debug.Assert(obj != null); - } + case CurrencyWrapper wrapper: + pOle = ComVariant.Create(wrapper); + break; #pragma warning restore 0618 - else if (obj is BStrWrapper) - { - vt = VarEnum.VT_BSTR; - obj = (object?)(((BStrWrapper)obj).WrappedObject); - } - - if (obj != null) - { - SetFieldsObject(obj); + case BStrWrapper wrapper: + pOle = ComVariant.Create(wrapper); + break; + + case Empty: + pOle = default; + break; + case DBNull: + pOle = ComVariant.Create(DBNull.Value); + break; + + case { } when IsSystemDrawingColor(o.GetType()): + // System.Drawing.Color is converted to UInt32 + pOle = ComVariant.Create((uint)ColorMarshaler.ConvertToNative(o)); + break; + + // DateTime, decimal handled by IConvertible case + + case TimeSpan: + throw new ArgumentException(SR.ComVariant_UnsupportedSignature); + case Currency c: + pOle = ComVariant.CreateRaw(VarEnum.VT_CY, c.m_value); + break; + + // Enums handled by IConvertible case + + case ValueType: + ConvertValueTypeToRecord(ObjectHandleOnStack.Create(ref o), out pOle); + break; + + // SafeHandle's or CriticalHandle's cannot be stored in VARIANT's. + case SafeHandle: + throw new ArgumentException(SR.ComVariant_SafeHandle_In_Variant); + case CriticalHandle: + throw new ArgumentException(SR.ComVariant_CriticalHandle_In_Variant); + + // VariantWrappers cannot be stored in VARIANT's. + case VariantWrapper: + throw new ArgumentException(SR.ComVariant_VariantWrapper_In_Variant); + + default: + // We are dealing with a normal object (not a wrapper) so we will + // leave the VT as VT_DISPATCH for now and we will determine the actual + // VT when we convert the object to a COM IP. + pOle = GetIUnknownOrIDispatchFromObject(o); + break; } - - // If the object passed in is one of the wrappers then set the VARIANT type. - if (vt != VarEnum.VT_EMPTY) - _flags |= ((int)vt << VTBitShift); } - // This is a family-only accessor for the CVType. - // This is never to be exposed externally. - internal int CVType => _flags & TypeCodeBitMask; - - public object? ToObject() => - CVType switch - { - CV_EMPTY => null, - CV_BOOLEAN => (int)_data != 0, - CV_I1 => (sbyte)_data, - CV_U1 => (byte)_data, - CV_CHAR => (char)_data, - CV_I2 => (short)_data, - CV_U2 => (ushort)_data, - CV_I4 => (int)_data, - CV_U4 => (uint)_data, - CV_I8 => _data, - CV_U8 => (ulong)_data, - CV_R4 => BitConverter.UInt32BitsToSingle((uint)_data), - CV_R8 => BitConverter.Int64BitsToDouble(_data), - CV_DATETIME => new DateTime(_data), - CV_TIMESPAN => new TimeSpan(_data), - CV_ENUM => BoxEnum(), - CV_MISSING => Type.Missing, - CV_NULL => System.DBNull.Value, - _ => _objref, // CV_DECIMAL, CV_STRING, CV_OBJECT - }; - - // This routine will return an boxed enum. - [MethodImpl(MethodImplOptions.InternalCall)] - private extern object BoxEnum(); - - // Helper code for marshaling managed objects to VARIANT's (we use - // managed variants as an intermediate type. - internal static void MarshalHelperConvertObjectToVariant(object o, ref Variant v) + // Helper code for marshaling VARIANTS to managed objects + internal static unsafe object? MarshalHelperConvertVariantToObject(ref readonly ComVariant pOle) { - if (o == null) - { - v = Empty; - } - else if (o is IConvertible ic) - { - IFormatProvider provider = CultureInfo.InvariantCulture; - v = ic.GetTypeCode() switch - { - TypeCode.Empty => Empty, - TypeCode.Object => new Variant((object)o), - TypeCode.DBNull => DBNull, - TypeCode.Boolean => new Variant(ic.ToBoolean(provider)), - TypeCode.Char => new Variant(ic.ToChar(provider)), - TypeCode.SByte => new Variant(ic.ToSByte(provider)), - TypeCode.Byte => new Variant(ic.ToByte(provider)), - TypeCode.Int16 => new Variant(ic.ToInt16(provider)), - TypeCode.UInt16 => new Variant(ic.ToUInt16(provider)), - TypeCode.Int32 => new Variant(ic.ToInt32(provider)), - TypeCode.UInt32 => new Variant(ic.ToUInt32(provider)), - TypeCode.Int64 => new Variant(ic.ToInt64(provider)), - TypeCode.UInt64 => new Variant(ic.ToUInt64(provider)), - TypeCode.Single => new Variant(ic.ToSingle(provider)), - TypeCode.Double => new Variant(ic.ToDouble(provider)), - TypeCode.Decimal => new Variant(ic.ToDecimal(provider)), - TypeCode.DateTime => new Variant(ic.ToDateTime(provider)), - TypeCode.String => new Variant(ic.ToString(provider)), - _ => throw new NotSupportedException(SR.Format(SR.NotSupported_UnknownTypeCode, ic.GetTypeCode())), - }; - } - else + // Invalid and common types are handled at native side + Debug.Assert((pOle.VarType & VarEnum.VT_ARRAY) == 0, "Array should be handled at native side."); + Debug.Assert((pOle.VarType & ~VarEnum.VT_BYREF) != VarEnum.VT_RECORD, "Records should be handled at native side."); + + switch (pOle.VarType) { - // This path should eventually go away. But until - // the work is done to have all of our wrapper types implement - // IConvertible, this is a cheapo way to get the work done. - v = new Variant(o); + case VarEnum.VT_I4: + case VarEnum.VT_INT: + return pOle.As(); + case VarEnum.VT_BYREF | VarEnum.VT_I4: + case VarEnum.VT_BYREF | VarEnum.VT_INT: + return *(int*)pOle.GetRawDataRef(); + + case VarEnum.VT_UI4: + case VarEnum.VT_UINT: + return pOle.As(); + case VarEnum.VT_BYREF | VarEnum.VT_UI4: + case VarEnum.VT_BYREF | VarEnum.VT_UINT: + return *(uint*)pOle.GetRawDataRef(); + + case VarEnum.VT_I1: + return pOle.As(); + case VarEnum.VT_BYREF | VarEnum.VT_I1: + return *(sbyte*)pOle.GetRawDataRef(); + + case VarEnum.VT_UI1: + return pOle.As(); + case VarEnum.VT_BYREF | VarEnum.VT_UI1: + return *(byte*)pOle.GetRawDataRef(); + + case VarEnum.VT_I2: + return pOle.As(); + case VarEnum.VT_BYREF | VarEnum.VT_I2: + return *(short*)pOle.GetRawDataRef(); + + case VarEnum.VT_UI2: + return pOle.As(); + case VarEnum.VT_BYREF | VarEnum.VT_UI2: + return *(ushort*)pOle.GetRawDataRef(); + + case VarEnum.VT_I8: + return pOle.As(); + case VarEnum.VT_BYREF | VarEnum.VT_I8: + return *(long*)pOle.GetRawDataRef(); + + case VarEnum.VT_UI8: + return pOle.As(); + case VarEnum.VT_BYREF | VarEnum.VT_UI8: + return *(ulong*)pOle.GetRawDataRef(); + + case VarEnum.VT_R4: + return pOle.As(); + case VarEnum.VT_BYREF | VarEnum.VT_R4: + return *(float*)pOle.GetRawDataRef(); + + case VarEnum.VT_R8: + return pOle.As(); + case VarEnum.VT_BYREF | VarEnum.VT_R8: + return *(double*)pOle.GetRawDataRef(); + + case VarEnum.VT_BOOL: + return pOle.As(); + case VarEnum.VT_BYREF | VarEnum.VT_BOOL: + // VARIANT_BOOL is 2 bytes + return *(short*)pOle.GetRawDataRef() != 0; + + case VarEnum.VT_BSTR: + return pOle.As(); + + case VarEnum.VT_BYREF | VarEnum.VT_BSTR: + IntPtr bstr = *(IntPtr*)pOle.GetRawDataRef(); + return bstr == IntPtr.Zero ? null : Marshal.PtrToStringBSTR(bstr); + + case VarEnum.VT_EMPTY: + return null; + + case VarEnum.VT_BYREF | VarEnum.VT_EMPTY: +#if TARGET_64BIT + return (ulong)pOle.GetRawDataRef(); +#else + return (uint)pOle.GetRawDataRef(); +#endif + + case VarEnum.VT_NULL: + case VarEnum.VT_BYREF | VarEnum.VT_NULL: + return DBNull.Value; + + case VarEnum.VT_DATE: + return pOle.As(); + case VarEnum.VT_BYREF | VarEnum.VT_DATE: + return DateTime.FromOADate(*(double*)pOle.GetRawDataRef()); + + case VarEnum.VT_DECIMAL: + return pOle.As(); + case VarEnum.VT_BYREF | VarEnum.VT_DECIMAL: + return *(decimal*)pOle.GetRawDataRef(); + + case VarEnum.VT_CY: + return decimal.FromOACurrency(pOle.GetRawDataRef()); + case VarEnum.VT_BYREF | VarEnum.VT_CY: + return decimal.FromOACurrency(*(long*)pOle.GetRawDataRef()); + + case VarEnum.VT_UNKNOWN: + case VarEnum.VT_DISPATCH: + return GetObjectFromIUnknown(pOle.GetRawDataRef()); + case VarEnum.VT_BYREF | VarEnum.VT_UNKNOWN: + case VarEnum.VT_BYREF | VarEnum.VT_DISPATCH: + return GetObjectFromIUnknown(*(IntPtr*)pOle.GetRawDataRef()); + + case VarEnum.VT_ERROR: + int error = pOle.GetRawDataRef(); + return error == HResults.DISP_E_PARAMNOTFOUND ? Missing.Value : error; + case VarEnum.VT_BYREF | VarEnum.VT_ERROR: + int refError = *(int*)pOle.GetRawDataRef(); + return refError == HResults.DISP_E_PARAMNOTFOUND ? Missing.Value : refError; + + case VarEnum.VT_VOID: + case VarEnum.VT_BYREF | VarEnum.VT_VOID: + return null; // CV_VOID + + default: + throw new ArgumentException(SR.ComVariant_UnsupportedType); } } - // Helper code for marshaling VARIANTS to managed objects (we use - // managed variants as an intermediate type. - internal static object? MarshalHelperConvertVariantToObject(ref Variant v) - { - return v.ToObject(); - } - // Helper code: on the back propagation path where a VT_BYREF VARIANT* // is marshaled to a "ref Object", we use this helper to force the // updated object back to the original type. - internal static void MarshalHelperCastVariant(object pValue, int vt, ref Variant v) + internal static void MarshalHelperCastVariant(object pValue, int vt, out ComVariant v) { + Debug.Assert((VarEnum)vt != VarEnum.VT_VARIANT, "Should be handled at native side."); + if (pValue is not IConvertible iv) { - switch (vt) + switch ((VarEnum)vt) { - case 9: /*VT_DISPATCH*/ + case VarEnum.VT_DISPATCH: Debug.Assert(OperatingSystem.IsWindows()); - v = new Variant(new DispatchWrapper(pValue)); + v = ComVariant.CreateRaw(VarEnum.VT_DISPATCH, + pValue is null ? IntPtr.Zero : Marshal.GetIDispatchForObject(pValue)); break; - case 12: /*VT_VARIANT*/ - v = new Variant(pValue); + case VarEnum.VT_UNKNOWN: + v = ComVariant.CreateRaw(VarEnum.VT_UNKNOWN, + pValue is null ? IntPtr.Zero : Marshal.GetIUnknownForObject(pValue)); break; - case 13: /*VT_UNKNOWN*/ - v = new Variant(new UnknownWrapper(pValue)); - break; - - case 36: /*VT_RECORD*/ - v = new Variant(pValue); + case VarEnum.VT_RECORD: + MarshalHelperConvertObjectToVariant(pValue, out v); + if (v.VarType != VarEnum.VT_RECORD) + { + // v can hold disposable content like BSTR + v.Dispose(); + throw new InvalidCastException(SR.InvalidCast_CannotCoerceByRefVariant); + } break; - case 8: /*VT_BSTR*/ + case VarEnum.VT_BSTR: /*VT_BSTR*/ if (pValue == null) { - v = new Variant(null) { _flags = CV_STRING }; + v = ComVariant.CreateRaw(VarEnum.VT_BSTR, IntPtr.Zero); break; } goto default; @@ -406,36 +369,31 @@ internal static void MarshalHelperCastVariant(object pValue, int vt, ref Variant else { IFormatProvider provider = CultureInfo.InvariantCulture; - v = vt switch + v = (VarEnum)vt switch { - 0 => /*VT_EMPTY*/ Empty, - 1 => /*VT_NULL*/ DBNull, - 2 => /*VT_I2*/ new Variant(iv.ToInt16(provider)), - 3 => /*VT_I4*/ new Variant(iv.ToInt32(provider)), - 4 => /*VT_R4*/ new Variant(iv.ToSingle(provider)), - 5 => /*VT_R8*/ new Variant(iv.ToDouble(provider)), -#pragma warning disable 0618 // CurrencyWrapper is obsolete - 6 => /*VT_CY*/ new Variant(new CurrencyWrapper(iv.ToDecimal(provider))), -#pragma warning restore 0618 - 7 => /*VT_DATE*/ new Variant(iv.ToDateTime(provider)), - 8 => /*VT_BSTR*/ new Variant(iv.ToString(provider)), -#pragma warning disable CA1416 // Validate platform compatibility - 9 => /*VT_DISPATCH*/ new Variant(new DispatchWrapper((object)iv)), -#pragma warning restore CA1416 - 10 => /*VT_ERROR*/ new Variant(new ErrorWrapper(iv.ToInt32(provider))), - 11 => /*VT_BOOL*/ new Variant(iv.ToBoolean(provider)), - 12 => /*VT_VARIANT*/ new Variant((object)iv), - 13 => /*VT_UNKNOWN*/ new Variant(new UnknownWrapper((object)iv)), - 14 => /*VT_DECIMAL*/ new Variant(iv.ToDecimal(provider)), + VarEnum.VT_EMPTY => default, + VarEnum.VT_NULL => ComVariant.Create(DBNull.Value), + VarEnum.VT_I2 => ComVariant.Create(iv.ToInt16(provider)), + VarEnum.VT_I4 => ComVariant.Create(iv.ToInt32(provider)), + VarEnum.VT_R4 => ComVariant.Create(iv.ToSingle(provider)), + VarEnum.VT_R8 => ComVariant.Create(iv.ToDouble(provider)), + VarEnum.VT_CY => ComVariant.CreateRaw(VarEnum.VT_CY, decimal.ToOACurrency(iv.ToDecimal(provider))), + VarEnum.VT_DATE => ComVariant.Create(iv.ToDateTime(provider)), + VarEnum.VT_BSTR => ComVariant.Create(iv.ToString(provider)), + VarEnum.VT_DISPATCH => ComVariant.CreateRaw(VarEnum.VT_DISPATCH, Marshal.GetIDispatchForObject(iv)), + VarEnum.VT_ERROR => ComVariant.CreateRaw(VarEnum.VT_ERROR, iv.ToInt32(provider)), + VarEnum.VT_BOOL => ComVariant.Create(iv.ToBoolean(provider)), + VarEnum.VT_UNKNOWN => ComVariant.CreateRaw(VarEnum.VT_UNKNOWN, Marshal.GetIUnknownForObject(iv)), + VarEnum.VT_DECIMAL => ComVariant.Create(iv.ToDecimal(provider)), // 15 => : /*unused*/ NOT SUPPORTED - 16 => /*VT_I1*/ new Variant(iv.ToSByte(provider)), - 17 => /*VT_UI1*/ new Variant(iv.ToByte(provider)), - 18 => /*VT_UI2*/ new Variant(iv.ToUInt16(provider)), - 19 => /*VT_UI4*/ new Variant(iv.ToUInt32(provider)), - 20 => /*VT_I8*/ new Variant(iv.ToInt64(provider)), - 21 => /*VT_UI8*/ new Variant(iv.ToUInt64(provider)), - 22 => /*VT_INT*/ new Variant(iv.ToInt32(provider)), - 23 => /*VT_UINT*/ new Variant(iv.ToUInt32(provider)), + VarEnum.VT_I1 => ComVariant.Create(iv.ToSByte(provider)), + VarEnum.VT_UI1 => ComVariant.Create(iv.ToByte(provider)), + VarEnum.VT_UI2 => ComVariant.Create(iv.ToUInt16(provider)), + VarEnum.VT_UI4 => ComVariant.Create(iv.ToUInt32(provider)), + VarEnum.VT_I8 => ComVariant.Create(iv.ToInt64(provider)), + VarEnum.VT_UI8 => ComVariant.Create(iv.ToUInt64(provider)), + VarEnum.VT_INT => ComVariant.Create(iv.ToInt32(provider)), + VarEnum.VT_UINT => ComVariant.Create(iv.ToUInt32(provider)), _ => throw new InvalidCastException(SR.InvalidCast_CannotCoerceByRefVariant), }; } diff --git a/src/coreclr/System.Private.CoreLib/src/System/__ComObject.cs b/src/coreclr/System.Private.CoreLib/src/System/__ComObject.cs index 77a88b59bff..a520097018d 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/__ComObject.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/__ComObject.cs @@ -4,11 +4,17 @@ #pragma warning disable CA1852 // __ComObject should not be sealed using System.Collections; +using System.Diagnostics; using System.Diagnostics.CodeAnalysis; using System.Reflection; using System.Runtime.InteropServices; +using System.Runtime.InteropServices.CustomMarshalers; +using System.Runtime.InteropServices.Marshalling; using System.Runtime.Versioning; +using IEnumVARIANT = System.Runtime.InteropServices.ComTypes.IEnumVARIANT; +using DISPPARAMS = System.Runtime.InteropServices.ComTypes.DISPPARAMS; + namespace System { /// @@ -16,7 +22,7 @@ namespace System /// the basics. This class is used for wrapping COM objects accessed from managed. /// [SupportedOSPlatform("windows")] - internal class __ComObject : MarshalByRefObject + internal class __ComObject : MarshalByRefObject, IDynamicInterfaceCastable { private Hashtable? m_ObjectToDataMap; // Do not rename (runtime relies on this name). @@ -135,11 +141,185 @@ private object CreateEventProvider( DisposableEvProv.Dispose(); } - // Another thead already cached the wrapper so use that one instead. + // Another thread already cached the wrapper so use that one instead. EvProvider = GetData(t)!; } return EvProvider; } + + bool IDynamicInterfaceCastable.IsInterfaceImplemented(RuntimeTypeHandle interfaceType, bool throwIfNotImplemented) + { + if (interfaceType.Equals(typeof(IEnumerable).TypeHandle)) + { + return IsIEnumerable(this); + } + else if (interfaceType.Equals(typeof(IEnumerator).TypeHandle)) + { + return IsIEnumerator(this); + } + else if (interfaceType.Equals(typeof(ICustomAdapter).TypeHandle)) + { + // This is for backwards compatibility purposes. + return IsIEnumerator(this) || IsIEnumerable(this); + } + else + { + return false; + } + + static bool IsIEnumerable(__ComObject co) + { + try + { + // We just need to know the query was successful. + _ = IEnumerableOverDispatchImpl.QueryForNewEnum(co); + return true; + } + catch + { + // Exception was thrown. There are few options, but all imply "not supported". + // - Not IDispatch. + // - IDispatch doesn't support DISPID_NEWENUM operation. + // - The returned instance isn't IEnumVARIANT. + return false; + } + } + + static bool IsIEnumerator(__ComObject co) + { + return co is IEnumVARIANT; + } + } + + RuntimeTypeHandle IDynamicInterfaceCastable.GetInterfaceImplementation(RuntimeTypeHandle interfaceType) + { + if (interfaceType.Equals(typeof(IEnumerable).TypeHandle)) + { + return typeof(IEnumerableOverDispatchImpl).TypeHandle; + } + else if (interfaceType.Equals(typeof(ICustomAdapter).TypeHandle)) + { + return typeof(ICustomAdapterOverDispatchImpl).TypeHandle; + } + else if (interfaceType.Equals(typeof(IEnumerator).TypeHandle)) + { + object? enumVariantImpl = GetData(typeof(IEnumeratorOverEnumVARIANTImpl)); + if (enumVariantImpl is null) + { + IntPtr enumVariantPtr = IntPtr.Zero; + try + { IEnumVARIANT enumVariant = (IEnumVARIANT)this; + enumVariantPtr = Marshal.GetIUnknownForObject(enumVariant); + enumVariantImpl = (IEnumerator)EnumeratorToEnumVariantMarshaler.GetInstance(null).MarshalNativeToManaged(enumVariantPtr); + } + finally + { + if (enumVariantPtr != IntPtr.Zero) + { + Marshal.Release(enumVariantPtr); + } + } + SetData(typeof(IEnumeratorOverEnumVARIANTImpl), enumVariantImpl); + } + return typeof(IEnumeratorOverEnumVARIANTImpl).TypeHandle; + } + + return default; + } + + [DynamicInterfaceCastableImplementation] + private interface IEnumerableOverDispatchImpl : IEnumerable + { + public static IEnumVARIANT QueryForNewEnum(__ComObject obj) + { + // Reserved DISPID slot for getting an enumerator from an IDispatch-implementing COM interface. + const int DISPID_NEWENUM = -4; + const int LCID_DEFAULT = 1; + + IDispatch dispatch = (IDispatch)obj; + ComVariant result = default; + object? resultAsObject = null; + try + { + unsafe + { + void* resultLocal = &result; + DISPPARAMS dispParams = default; + Guid guid = Guid.Empty; + dispatch.Invoke( + DISPID_NEWENUM, + ref guid, + LCID_DEFAULT, + InvokeFlags.DISPATCH_METHOD | InvokeFlags.DISPATCH_PROPERTYGET, + ref dispParams, + new IntPtr(resultLocal), + IntPtr.Zero, + IntPtr.Zero); + } + resultAsObject = result.ToObject(); + } + finally + { + result.Dispose(); + } + + if (resultAsObject is not IEnumVARIANT enumVariant) + { + throw new InvalidOperationException(SR.InvalidOp_InvalidNewEnumVariant); + } + + return enumVariant; + } + + IEnumerator IEnumerable.GetEnumerator() + { + IEnumVARIANT enumVariant = QueryForNewEnum((__ComObject)this); + IntPtr enumVariantPtr = IntPtr.Zero; + try + { + enumVariantPtr = Marshal.GetIUnknownForObject(enumVariant); + return (IEnumerator)EnumeratorToEnumVariantMarshaler.GetInstance(null).MarshalNativeToManaged(enumVariantPtr); + } + finally + { + if (enumVariantPtr != IntPtr.Zero) + { + Marshal.Release(enumVariantPtr); + } + } + } + } + + [DynamicInterfaceCastableImplementation] + private interface ICustomAdapterOverDispatchImpl : ICustomAdapter + { + object ICustomAdapter.GetUnderlyingObject() => this; + } + + [DynamicInterfaceCastableImplementation] + private interface IEnumeratorOverEnumVARIANTImpl : IEnumerator + { + bool IEnumerator.MoveNext() + { + __ComObject co = (__ComObject)this; + return ((IEnumerator)co.GetData(typeof(IEnumeratorOverEnumVARIANTImpl))!).MoveNext(); + } + + void IEnumerator.Reset() + { + __ComObject co = (__ComObject)this; + ((IEnumerator)co.GetData(typeof(IEnumeratorOverEnumVARIANTImpl))!).Reset(); + } + + object IEnumerator.Current + { + get + { + __ComObject co = (__ComObject)this; + return ((IEnumerator)co.GetData(typeof(IEnumeratorOverEnumVARIANTImpl))!).Current; + } + } + } } } diff --git a/src/coreclr/binder/assembly.cpp b/src/coreclr/binder/assembly.cpp index 9348c7b67e4..3309c0d17f9 100644 --- a/src/coreclr/binder/assembly.cpp +++ b/src/coreclr/binder/assembly.cpp @@ -24,7 +24,7 @@ namespace BINDER_SPACE m_pAssemblyName = NULL; m_isInTPA = false; m_pBinder = NULL; - m_domainAssembly = NULL; + m_runtimeAssembly = NULL; } Assembly::~Assembly() diff --git a/src/coreclr/binder/inc/assembly.hpp b/src/coreclr/binder/inc/assembly.hpp index 908e9387932..650877cafd8 100644 --- a/src/coreclr/binder/inc/assembly.hpp +++ b/src/coreclr/binder/inc/assembly.hpp @@ -28,8 +28,6 @@ #include "bundle.h" #include -class DomainAssembly; - namespace BINDER_SPACE { // BINDER_SPACE::Assembly represents a result of binding to an actual assembly (PEImage) @@ -56,15 +54,15 @@ namespace BINDER_SPACE return m_pBinder; } - DomainAssembly* GetDomainAssembly() + ::Assembly* GetRuntimeAssembly() { - return m_domainAssembly; + return m_runtimeAssembly; } - void SetDomainAssembly(DomainAssembly* value) + void SetRuntimeAssembly(::Assembly* value) { - _ASSERTE(value == NULL || m_domainAssembly == NULL); - m_domainAssembly = value; + _ASSERTE(value == NULL || m_runtimeAssembly == NULL); + m_runtimeAssembly = value; } private: @@ -73,7 +71,7 @@ namespace BINDER_SPACE AssemblyName *m_pAssemblyName; PTR_AssemblyBinder m_pBinder; bool m_isInTPA; - DomainAssembly *m_domainAssembly; + ::Assembly *m_runtimeAssembly; #if !defined(DACCESS_COMPILE) inline void SetBinder(AssemblyBinder *pBinder) diff --git a/src/coreclr/classlibnative/bcltype/objectnative.cpp b/src/coreclr/classlibnative/bcltype/objectnative.cpp index afbda5fad99..0ac42cc084d 100644 --- a/src/coreclr/classlibnative/bcltype/objectnative.cpp +++ b/src/coreclr/classlibnative/bcltype/objectnative.cpp @@ -19,106 +19,49 @@ #include "comsynchronizable.h" #include "eeconfig.h" - -NOINLINE static INT32 GetHashCodeHelper(OBJECTREF objRef) +extern "C" INT32 QCALLTYPE ObjectNative_GetHashCodeSlow(QCall::ObjectHandleOnStack objHandle) { - DWORD idx = 0; + QCALL_CONTRACT; - FC_INNER_PROLOG(ObjectNative::GetHashCode); + INT32 idx = 0; - HELPER_METHOD_FRAME_BEGIN_RET_ATTRIB_1(Frame::FRAME_ATTR_EXACT_DEPTH|Frame::FRAME_ATTR_CAPTURE_DEPTH_2, objRef); + BEGIN_QCALL; - idx = objRef->GetHashCodeEx(); + GCX_COOP(); - HELPER_METHOD_FRAME_END(); - FC_INNER_EPILOG(); - return idx; -} + _ASSERTE(objHandle.Get() != NULL); + idx = objHandle.Get()->GetHashCodeEx(); -// Note that we obtain a sync block index without actually building a sync block. -// That's because a lot of objects are hashed, without requiring support for -FCIMPL1(INT32, ObjectNative::GetHashCode, Object* obj) { + END_QCALL; - CONTRACTL - { - FCALL_CHECK; - INJECT_FAULT(FCThrow(kOutOfMemoryException);); - } - CONTRACTL_END; + return idx; +} - VALIDATEOBJECT(obj); +FCIMPL1(INT32, ObjectNative::TryGetHashCode, Object* obj) +{ + FCALL_CONTRACT; - if (obj == 0) + if (obj == NULL) return 0; - OBJECTREF objRef(obj); - + OBJECTREF objRef = ObjectToOBJECTREF(obj); + DWORD bits = objRef->GetHeader()->GetBits(); + if (bits & BIT_SBLK_IS_HASH_OR_SYNCBLKINDEX) { - DWORD bits = objRef->GetHeader()->GetBits(); - - if (bits & BIT_SBLK_IS_HASH_OR_SYNCBLKINDEX) + if (bits & BIT_SBLK_IS_HASHCODE) { - if (bits & BIT_SBLK_IS_HASHCODE) - { - // Common case: the object already has a hash code - return bits & MASK_HASHCODE; - } - else - { - // We have a sync block index. This means if we already have a hash code, - // it is in the sync block, otherwise we generate a new one and store it there - SyncBlock *psb = objRef->PassiveGetSyncBlock(); - if (psb != NULL) - { - DWORD hashCode = psb->GetHashCode(); - if (hashCode != 0) - return hashCode; - } - } + // Common case: the object already has a hash code + return bits & MASK_HASHCODE; } - } - - FC_INNER_RETURN(INT32, GetHashCodeHelper(objRef)); -} -FCIMPLEND - -FCIMPL1(INT32, ObjectNative::TryGetHashCode, Object* obj) { - - CONTRACTL - { - FCALL_CHECK; - } - CONTRACTL_END; - - VALIDATEOBJECT(obj); - - if (obj == 0) - return 0; - - OBJECTREF objRef(obj); - - { - DWORD bits = objRef->GetHeader()->GetBits(); - - if (bits & BIT_SBLK_IS_HASH_OR_SYNCBLKINDEX) + else { - if (bits & BIT_SBLK_IS_HASHCODE) - { - // Common case: the object already has a hash code - return bits & MASK_HASHCODE; - } - else - { - // We have a sync block index. There may be a hash code stored within the sync block. - SyncBlock *psb = objRef->PassiveGetSyncBlock(); - if (psb != NULL) - { - return psb->GetHashCode(); - } - } + // We have a sync block index. This means if we already have a hash code, + // it is in the sync block, otherwise we will return 0, which means "not set". + SyncBlock *psb = objRef->PassiveGetSyncBlock(); + if (psb != NULL) + return psb->GetHashCode(); } } - return 0; } FCIMPLEND @@ -146,48 +89,19 @@ FCIMPL2(FC_BOOL_RET, ObjectNative::ContentEquals, Object *pThisRef, Object *pCom } FCIMPLEND -NOINLINE static Object* GetClassHelper(OBJECTREF objRef) +extern "C" void QCALLTYPE ObjectNative_GetTypeSlow(MethodTable* pMT, QCall::ObjectHandleOnStack ret) { - FC_INNER_PROLOG(ObjectNative::GetClass); - _ASSERTE(objRef != NULL); - TypeHandle typeHandle = objRef->GetTypeHandle(); - OBJECTREF refType = NULL; - - HELPER_METHOD_FRAME_BEGIN_RET_ATTRIB_1(Frame::FRAME_ATTR_EXACT_DEPTH|Frame::FRAME_ATTR_CAPTURE_DEPTH_2, refType); - - refType = typeHandle.GetManagedClassObject(); + QCALL_CONTRACT; + _ASSERTE(pMT != NULL); - HELPER_METHOD_FRAME_END(); - FC_INNER_EPILOG(); - return OBJECTREFToObject(refType); -} + BEGIN_QCALL; -// This routine is called by the Object.GetType() routine. It is a major way to get the System.Type -FCIMPL1(Object*, ObjectNative::GetClass, Object* pThis) -{ - CONTRACTL - { - FCALL_CHECK; - INJECT_FAULT(FCThrow(kOutOfMemoryException);); - } - CONTRACTL_END; + GCX_COOP(); - OBJECTREF objRef = ObjectToOBJECTREF(pThis); - if (objRef != NULL) - { - MethodTable* pMT = objRef->GetMethodTable(); - OBJECTREF typePtr = pMT->GetManagedClassObjectIfExists(); - if (typePtr != NULL) - { - return OBJECTREFToObject(typePtr); - } - } - else - FCThrow(kNullReferenceException); + ret.Set(pMT->GetManagedClassObject()); - FC_INNER_RETURN(Object*, GetClassHelper(objRef)); + END_QCALL; } -FCIMPLEND extern "C" void QCALLTYPE ObjectNative_AllocateUninitializedClone(QCall::ObjectHandleOnStack objHandle) { @@ -200,10 +114,10 @@ extern "C" void QCALLTYPE ObjectNative_AllocateUninitializedClone(QCall::ObjectH OBJECTREF refClone = objHandle.Get(); _ASSERTE(refClone != NULL); // Should be handled at managed side MethodTable* pMT = refClone->GetMethodTable(); - + // assert that String has overloaded the Clone() method _ASSERTE(pMT != g_pStringClass); - + if (pMT->IsArray()) { objHandle.Set(DupArrayForCloning((BASEARRAYREF)refClone)); diff --git a/src/coreclr/classlibnative/bcltype/objectnative.h b/src/coreclr/classlibnative/bcltype/objectnative.h index 418fd2561d7..374991cef98 100644 --- a/src/coreclr/classlibnative/bcltype/objectnative.h +++ b/src/coreclr/classlibnative/bcltype/objectnative.h @@ -24,14 +24,13 @@ class ObjectNative { public: - - static FCDECL1(INT32, GetHashCode, Object* vThisRef); static FCDECL1(INT32, TryGetHashCode, Object* vThisRef); static FCDECL2(FC_BOOL_RET, ContentEquals, Object *pThisRef, Object *pCompareRef); - static FCDECL1(Object*, GetClass, Object* pThis); static FCDECL1(FC_BOOL_RET, IsLockHeld, Object* pThisUNSAFE); }; +extern "C" INT32 QCALLTYPE ObjectNative_GetHashCodeSlow(QCall::ObjectHandleOnStack objHandle); +extern "C" void QCALLTYPE ObjectNative_GetTypeSlow(MethodTable* pMT, QCall::ObjectHandleOnStack ret); extern "C" void QCALLTYPE ObjectNative_AllocateUninitializedClone(QCall::ObjectHandleOnStack objHandle); extern "C" BOOL QCALLTYPE Monitor_Wait(QCall::ObjectHandleOnStack pThis, INT32 Timeout); extern "C" void QCALLTYPE Monitor_Pulse(QCall::ObjectHandleOnStack pThis); diff --git a/src/coreclr/classlibnative/bcltype/variant.cpp b/src/coreclr/classlibnative/bcltype/variant.cpp index 1a3cf7e75bb..2b7202854f6 100644 --- a/src/coreclr/classlibnative/bcltype/variant.cpp +++ b/src/coreclr/classlibnative/bcltype/variant.cpp @@ -15,307 +15,22 @@ #ifdef FEATURE_COMINTEROP #include "object.h" -#include "excep.h" -#include "frames.h" #include "vars.hpp" #include "variant.h" -#include "string.h" -#include "field.h" - -// The following values are used to represent underlying -// type of the Enum.. -#define EnumI1 0x100000 -#define EnumU1 0x200000 -#define EnumI2 0x300000 -#define EnumU2 0x400000 -#define EnumI4 0x500000 -#define EnumU4 0x600000 -#define EnumI8 0x700000 -#define EnumU8 0x800000 -#define EnumMask 0xF00000 - - -/*===============================SetFieldsObject================================ -** -==============================================================================*/ -FCIMPL2(void, COMVariant::SetFieldsObject, VariantData* var, Object* vVal) -{ - CONTRACTL - { - FCALL_CHECK; - PRECONDITION(CheckPointer(var)); - PRECONDITION(CheckPointer(vVal)); - } - CONTRACTL_END; - - OBJECTREF val = ObjectToOBJECTREF(vVal); - - HELPER_METHOD_FRAME_BEGIN_1(val); - GCPROTECT_BEGININTERIOR(var) - - CVTypes cvt = CV_EMPTY; - TypeHandle typeHandle; - - MethodTable *valMT = val->GetMethodTable(); - - //If this isn't a value class, we should just skip out because we're not going - //to do anything special with it. - if (!valMT->IsValueType()) - { - var->SetObjRef(val); - typeHandle = TypeHandle(valMT); - - if (typeHandle==GetTypeHandleForCVType(CV_MISSING)) - { - var->SetType(CV_MISSING); - } - else if (typeHandle==GetTypeHandleForCVType(CV_NULL)) - { - var->SetType(CV_NULL); - } - else if (typeHandle==GetTypeHandleForCVType(CV_EMPTY)) - { - var->SetType(CV_EMPTY); - var->SetObjRef(NULL); - } - else - { - var->SetType(CV_OBJECT); - } - } - else if (IsTypeRefOrDef(g_ColorClassName, valMT->GetModule(), valMT->GetCl())) - { - // System.Drawing.Color is converted to UInt32 - var->SetDataAsUInt32(ConvertSystemColorToOleColor(&val)); - var->SetType(CV_U4); - } - else - { - //If this is a primitive type, we need to unbox it, get the value and create a variant - //with just those values. - void *UnboxData = val->UnBox(); - - ClearObjectReference(var->GetObjRefPtr()); - typeHandle = TypeHandle(valMT); - CorElementType cet = typeHandle.GetSignatureCorElementType(); - - if (cet>=ELEMENT_TYPE_BOOLEAN && cet<=ELEMENT_TYPE_STRING) - { - cvt = (CVTypes)cet; - } - else - { - cvt = GetCVTypeFromClass(valMT); - } - var->SetType(cvt); - - - //copy all of the data. - // Copies must be done based on the exact number of bytes to copy. - // We don't want to read garbage from other blocks of memory. - //CV_I8 --> CV_R8, CV_DATETIME, CV_TIMESPAN, & CV_CURRENCY are all of the 8 byte quantities - //If we don't find one of those ranges, we've found a value class - //of which we don't have inherent knowledge, so just slam that into an - //ObjectRef. - if (cvt>=CV_BOOLEAN && cvt<=CV_U1 && cvt != CV_CHAR) - { - var->SetDataAsInt64(*((UINT8 *)UnboxData)); - } - else if (cvt==CV_CHAR || cvt>=CV_I2 && cvt<=CV_U2) - { - var->SetDataAsInt64(*((UINT16 *)UnboxData)); - } - else if (cvt>=CV_I4 && cvt<=CV_U4 || cvt==CV_R4) - { - var->SetDataAsInt64(*((UINT32 *)UnboxData)); - } - else if ((cvt>=CV_I8 && cvt<=CV_R8) || (cvt==CV_DATETIME) || (cvt==CV_TIMESPAN) || (cvt==CV_CURRENCY)) - { - var->SetDataAsInt64(*((INT64 *)UnboxData)); - } - else if (cvt==CV_EMPTY || cvt==CV_NULL || cvt==CV_MISSING) - { - var->SetType(cvt); - } - else if (cvt==CV_ENUM) - { - var->SetDataAsInt64(*((INT32 *)UnboxData)); - var->SetObjRef(typeHandle.GetManagedClassObject()); - var->SetType(GetEnumFlags(typeHandle)); - } - else - { - // Decimals and other boxed value classes get handled here. - var->SetObjRef(val); - } - } - - GCPROTECT_END(); - HELPER_METHOD_FRAME_END(); -} -FCIMPLEND - - -FCIMPL1(Object*, COMVariant::BoxEnum, VariantData* var) -{ - CONTRACTL - { - FCALL_CHECK; - PRECONDITION(CheckPointer(var)); - PRECONDITION(var->GetObjRef() != NULL); - } - CONTRACTL_END; - - OBJECTREF retO = NULL; - - HELPER_METHOD_FRAME_BEGIN_RET_1(retO); - -#ifdef _DEBUG - CVTypes vType = (CVTypes) var->GetType(); -#endif - - _ASSERTE(vType == CV_ENUM); - - MethodTable* mt = ((REFLECTCLASSBASEREF) var->GetObjRef())->GetType().GetMethodTable(); - _ASSERTE(mt); - - retO = mt->Box(var->GetData()); - - HELPER_METHOD_FRAME_END(); - return OBJECTREFToObject(retO); -} -FCIMPLEND - - -/*===============================GetTypeFromClass=============================== -**Action: Takes an MethodTable * and returns the associated CVType. -**Arguments: MethodTable * -- a pointer to the class for which we want the CVType. -**Returns: The CVType associated with the MethodTable or CV_OBJECT if this can't be -** determined. -**Exceptions: None -==============================================================================*/ - -CVTypes COMVariant::GetCVTypeFromClass(TypeHandle th) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_ANY; - } - CONTRACTL_END; - - if (th.IsNull()) - return CV_EMPTY; - - //We'll start looking from Variant. Empty and Void are handled below. - for (int i=CV_EMPTY; i check this approximation - we may be losing exact type information - ApproxFieldDescIterator fdIterator(th.GetMethodTable(), ApproxFieldDescIterator::INSTANCE_FIELDS); - FieldDesc* p = fdIterator.Next(); - if (NULL == p) - { - _ASSERTE(!"NULL FieldDesc returned"); - return 0; - } - -#ifdef _DEBUG - WORD fldCnt = th.GetMethodTable()->GetNumInstanceFields(); -#endif - - _ASSERTE(fldCnt == 1); - - CorElementType cet = p[0].GetFieldType(); - switch (cet) - { - case ELEMENT_TYPE_I1: - return (CV_ENUM | EnumI1); - - case ELEMENT_TYPE_U1: - return (CV_ENUM | EnumU1); - - case ELEMENT_TYPE_I2: - return (CV_ENUM | EnumI2); - - case ELEMENT_TYPE_U2: - return (CV_ENUM | EnumU2); - - IN_TARGET_32BIT(case ELEMENT_TYPE_I:) - case ELEMENT_TYPE_I4: - return (CV_ENUM | EnumI4); - - IN_TARGET_32BIT(case ELEMENT_TYPE_U:) - case ELEMENT_TYPE_U4: - return (CV_ENUM | EnumU4); - - IN_TARGET_64BIT(case ELEMENT_TYPE_I:) - case ELEMENT_TYPE_I8: - return (CV_ENUM | EnumI8); - - IN_TARGET_64BIT(case ELEMENT_TYPE_U:) - case ELEMENT_TYPE_U8: - return (CV_ENUM | EnumU8); - - default: - _ASSERTE(!"UNknown Type"); - return 0; - } -} - -extern "C" uint32_t QCALLTYPE Variant_ConvertSystemColorToOleColor(QCall::ObjectHandleOnStack obj) +extern "C" void QCALLTYPE Variant_ConvertValueTypeToRecord(QCall::ObjectHandleOnStack obj, VARIANT * pOle) { QCALL_CONTRACT; - uint32_t ret = 0; - BEGIN_QCALL; - GCX_COOP(); - OBJECTREF srcObj = obj.Get(); - ret = ConvertSystemColorToOleColor(&srcObj); - - END_QCALL; - - return ret; -} -extern "C" void QCALLTYPE Variant_ConvertOleColorToSystemColor(QCall::ObjectHandleOnStack objRet, uint32_t oleColor, MethodTable* pMT) -{ - QCALL_CONTRACT; - - BEGIN_QCALL; - - GCX_COOP(); - SYSTEMCOLOR systemColor{}; - ConvertOleColorToSystemColor(oleColor, &systemColor); - objRet.Set(pMT->Box(&systemColor)); + OBJECTREF objRef = obj.Get(); + GCPROTECT_BEGIN(objRef); + V_VT(pOle) = VT_RECORD; + OleVariant::ConvertValueClassToVariant(&objRef, pOle); + GCPROTECT_END(); END_QCALL; } - #endif // FEATURE_COMINTEROP diff --git a/src/coreclr/classlibnative/bcltype/variant.h b/src/coreclr/classlibnative/bcltype/variant.h index 12c5a3d36d5..fc4c7f5771a 100644 --- a/src/coreclr/classlibnative/bcltype/variant.h +++ b/src/coreclr/classlibnative/bcltype/variant.h @@ -18,30 +18,9 @@ #endif // FEATURE_COMINTEROP #include -#include "fcall.h" #include "olevariant.h" -class COMVariant -{ - friend class OleVariant; - -public: - // - // Helper Routines - // - - static FCDECL2(void, SetFieldsObject, VariantData* vThisRef, Object* vVal); - static FCDECL1(Object*, BoxEnum, VariantData* var); - -private: - // GetCVTypeFromClass - // This method will return the CVTypes from the Variant instance - static CVTypes GetCVTypeFromClass(TypeHandle th); - static int GetEnumFlags(TypeHandle th); -}; - -extern "C" uint32_t QCALLTYPE Variant_ConvertSystemColorToOleColor(QCall::ObjectHandleOnStack obj); -extern "C" void QCALLTYPE Variant_ConvertOleColorToSystemColor(QCall::ObjectHandleOnStack objRet, uint32_t oleColor, MethodTable* pMT); +extern "C" void QCALLTYPE Variant_ConvertValueTypeToRecord(QCall::ObjectHandleOnStack obj, VARIANT* pOle); #endif // _VARIANT_H_ diff --git a/src/coreclr/clr.featuredefines.props b/src/coreclr/clr.featuredefines.props index 1f513b1354d..565cf03ee77 100644 --- a/src/coreclr/clr.featuredefines.props +++ b/src/coreclr/clr.featuredefines.props @@ -2,7 +2,6 @@ true true - true true true true @@ -35,7 +34,6 @@ $(DefineConstants);FEATURE_PERFTRACING $(DefineConstants);FEATURE_EVENTSOURCE_XPLAT $(DefineConstants);FEATURE_TYPEEQUIVALENCE - $(DefineConstants);FEATURE_ICASTABLE $(DefineConstants);FEATURE_EH_FUNCLETS $(DefineConstants);PROFILING_SUPPORTED diff --git a/src/coreclr/clrdefinitions.cmake b/src/coreclr/clrdefinitions.cmake index 1f403092f3d..8d788cc1e1d 100644 --- a/src/coreclr/clrdefinitions.cmake +++ b/src/coreclr/clrdefinitions.cmake @@ -122,7 +122,6 @@ endif(CLR_CMAKE_TARGET_LINUX) if(NOT CLR_CMAKE_TARGET_NETBSD) add_definitions(-DFEATURE_HIJACK) endif(NOT CLR_CMAKE_TARGET_NETBSD) -add_definitions(-DFEATURE_ICASTABLE) if (CLR_CMAKE_TARGET_WIN32 AND (CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_I386 OR CLR_CMAKE_TARGET_ARCH_ARM64)) add_definitions(-DFEATURE_INTEROP_DEBUGGING) endif (CLR_CMAKE_TARGET_WIN32 AND (CLR_CMAKE_TARGET_ARCH_AMD64 OR CLR_CMAKE_TARGET_ARCH_I386 OR CLR_CMAKE_TARGET_ARCH_ARM64)) diff --git a/src/coreclr/debug/daccess/cdac.cpp b/src/coreclr/debug/daccess/cdac.cpp index b7bb7585e6b..47631fab178 100644 --- a/src/coreclr/debug/daccess/cdac.cpp +++ b/src/coreclr/debug/daccess/cdac.cpp @@ -13,11 +13,17 @@ namespace { bool TryLoadCDACLibrary(HMODULE *phCDAC) { - // Load cdacreader from next to DAC binary + // Load cdacreader from next to current module (DAC binary) PathString path; - if (FAILED(GetClrModuleDirectory(path))) + if (WszGetModuleFileName((HMODULE)GetCurrentModuleBase(), path) == 0) return false; + SString::Iterator iter = path.End(); + if (!path.FindBack(iter, DIRECTORY_SEPARATOR_CHAR_W)) + return false; + + iter++; + path.Truncate(iter); path.Append(CDAC_LIB_NAME); *phCDAC = CLRLoadLibrary(path.GetUnicode()); if (*phCDAC == NULL) diff --git a/src/coreclr/debug/daccess/daccess.cpp b/src/coreclr/debug/daccess/daccess.cpp index bd3b25ca4fc..466041074a1 100644 --- a/src/coreclr/debug/daccess/daccess.cpp +++ b/src/coreclr/debug/daccess/daccess.cpp @@ -5994,7 +5994,7 @@ ClrDataAccess::GetMethodVarInfo(MethodDesc* methodDesc, { SUPPORTS_DAC; COUNT_T countNativeVarInfo; - NewHolder nativeVars(NULL); + NewArrayHolder nativeVars(NULL); TADDR nativeCodeStartAddr; if (address != (TADDR)NULL) { diff --git a/src/coreclr/debug/daccess/dacdbiimpl.cpp b/src/coreclr/debug/daccess/dacdbiimpl.cpp index 8dbd2cf2ca0..0c9750c0282 100644 --- a/src/coreclr/debug/daccess/dacdbiimpl.cpp +++ b/src/coreclr/debug/daccess/dacdbiimpl.cpp @@ -649,39 +649,7 @@ void DacDbiInterfaceImpl::GetAppDomainFullName( AppDomain * pAppDomain = vmAppDomain.GetDacPtr(); // Get the AppDomain name from the VM without changing anything - // We might be able to simplify this, eg. by returning an SString. - bool fIsUtf8; - PVOID pRawName = pAppDomain->GetFriendlyNameNoSet(&fIsUtf8); - - if (!pRawName) - { - ThrowHR(E_NOINTERFACE); - } - - HRESULT hrStatus = S_OK; - if (fIsUtf8) - { - // we have to allocate a temporary string - // we could avoid this by adding a version of IStringHolder::AssignCopy that takes a UTF8 string - // We should also probably check to see when fIsUtf8 is ever true (it looks like it should normally be false). - ULONG32 dwNameLen = 0; - hrStatus = ConvertUtf8((LPCUTF8)pRawName, 0, &dwNameLen, NULL); - if (SUCCEEDED( hrStatus )) - { - NewArrayHolder pwszName(new WCHAR[dwNameLen]); - hrStatus = ConvertUtf8((LPCUTF8)pRawName, dwNameLen, &dwNameLen, pwszName ); - IfFailThrow(hrStatus); - - hrStatus = pStrName->AssignCopy(pwszName); - } - } - else - { - hrStatus = pStrName->AssignCopy(static_cast(pRawName)); - } - - // Very important that this either sets pStrName or Throws. - IfFailThrow(hrStatus); + IfFailThrow(pStrName->AssignCopy(pAppDomain->GetFriendlyName())); } //- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -3672,7 +3640,7 @@ HRESULT DacDbiInterfaceImpl::GetLoaderHeapMemoryRanges(DacDbiArrayListGetLoaderAllocator(); + PTR_LoaderAllocator pGlobalAllocator = SystemDomain::GetGlobalLoaderAllocator(); _ASSERTE(pGlobalAllocator); EnumerateMemRangesForLoaderAllocator(pGlobalAllocator, &memoryRanges); @@ -3707,7 +3675,6 @@ void DacDbiInterfaceImpl::GetStackFramesFromException(VMPTR_Object vmObject, Dac DebugStackTrace::GetStackFramesData stackFramesData; stackFramesData.pDomain = NULL; - stackFramesData.skip = 0; stackFramesData.NumFramesRequested = 0; DebugStackTrace::GetStackFramesFromException(&objRef, &stackFramesData); @@ -3720,7 +3687,7 @@ void DacDbiInterfaceImpl::GetStackFramesFromException(VMPTR_Object vmObject, Dac for (INT32 index = 0; index < dacStackFramesLength; ++index) { - DebugStackTrace::DebugStackTraceElement const& currentElement = stackFramesData.pElements[index]; + DebugStackTrace::Element const& currentElement = stackFramesData.pElements[index]; DacExceptionCallStackData& currentFrame = dacStackFrames[index]; AppDomain* pDomain = AppDomain::GetCurrentDomain(); @@ -4454,17 +4421,12 @@ void DacDbiInterfaceImpl::EnumerateAssembliesInAppDomain( // Pass the magical flags to the loader enumerator to get all Execution-only assemblies. iterator = pAppDomain->IterateAssembliesEx((AssemblyIterationFlags)(kIncludeLoading | kIncludeLoaded | kIncludeExecution)); - CollectibleAssemblyHolder pDomainAssembly; + CollectibleAssemblyHolder pAssembly; - while (iterator.Next(pDomainAssembly.This())) + while (iterator.Next(pAssembly.This())) { - if (!pDomainAssembly->IsVisibleToDebugger()) - { - continue; - } - VMPTR_DomainAssembly vmDomainAssembly = VMPTR_DomainAssembly::NullPtr(); - vmDomainAssembly.SetHostPtr(pDomainAssembly); + vmDomainAssembly.SetHostPtr(pAssembly->GetDomainAssembly()); fpCallback(vmDomainAssembly, pUserData); } @@ -4487,7 +4449,7 @@ void DacDbiInterfaceImpl::EnumerateModulesInAssembly( if (pDomainAssembly->GetModule()->IsVisibleToDebugger()) { // If domain assembly isn't yet loaded, just return - if (!pDomainAssembly->IsLoaded()) + if (!pDomainAssembly->GetAssembly()->IsLoaded()) return; VMPTR_DomainAssembly vmDomainAssembly = VMPTR_DomainAssembly::NullPtr(); @@ -5558,6 +5520,8 @@ CorDebugUserState DacDbiInterfaceImpl::GetPartialUserState(VMPTR_Thread vmThread result |= USER_STOPPED; } + // Don't report Thread::TS_AbortRequested + // The interruptible flag is unreliable (see issue 699245) // The Debugger_SleepWaitJoin is always accurate when it is present, but it is still // just a band-aid fix to cover some of the race conditions interruptible has. @@ -7588,9 +7552,6 @@ UINT32 DacRefWalker::GetHandleWalkerMask() if (mHandleMask & CorHandleStrongDependent) result |= (1 << HNDTYPE_DEPENDENT); - if (mHandleMask & CorHandleStrongSizedByref) - result |= (1 << HNDTYPE_SIZEDREF); - return result; } @@ -7726,10 +7687,6 @@ HRESULT DacHandleWalker::Next(ULONG count, DacGcReference roots[], ULONG *pFetch roots[i].dwType = (DWORD)CorHandleStrongDependent; roots[i].i64ExtraData = GetDependentHandleSecondary(CLRDATA_ADDRESS_TO_TADDR(handle.Handle)).GetAddr(); break; - - case HNDTYPE_SIZEDREF: - roots[i].dwType = (DWORD)CorHandleStrongSizedByref; - break; } } diff --git a/src/coreclr/debug/daccess/dacfn.cpp b/src/coreclr/debug/daccess/dacfn.cpp index 2c9f28481d2..8077463c8e2 100644 --- a/src/coreclr/debug/daccess/dacfn.cpp +++ b/src/coreclr/debug/daccess/dacfn.cpp @@ -616,9 +616,10 @@ DacInstantiateClassByVTable(TADDR addr, ULONG32 minSize, bool throwEx) // Sanity check that the object we're returning is big enough to fill the PTR type it's being // accessed with. // If this is not true, it means the type being marshalled isn't a sub-type (or the same type) - // as the PTR type it's being used as. For example, trying to marshal an instance of a SystemDomain - // object into a PTR_AppDomain will cause this ASSERT to fire (because both SystemDomain and AppDomain - // derived from BaseDomain, and SystemDomain is smaller than AppDomain). + // as the PTR type it's being used as. For example, trying to marshal an AssemblyLoaderAllocator + // into a PTR_GlobalLoaderAllocator will cause this ASSERT to fire (because AssemblyLoaderAllocator + // and GlobalLoaderAllocator derived from LoaderAllocator and AssemblyLoaderAllocator is smaller + // than GlobalLoaderAllocator). _ASSERTE_MSG(size >= minSize, "DAC coding error: Attempt to instantiate a VPTR from an object that is too small"); inst = g_dacImpl->m_instances.Alloc(addr, size, DAC_VPTR); @@ -1386,6 +1387,15 @@ DacAllocHostOnlyInstance(ULONG32 size, bool throwEx) return inst + 1; } +thread_local bool t_DacAssertsUnconditionally = false; + +bool DacSetEnableDacAssertsUnconditionally(bool enable) +{ + bool oldValue = t_DacAssertsUnconditionally; + t_DacAssertsUnconditionally = enable; + return oldValue; +} + // // Queries whether ASSERTs should be raised when inconsistencies in the target are detected // @@ -1404,6 +1414,10 @@ bool DacTargetConsistencyAssertsEnabled() return true; } + // If asserts are unconditionally enabled via the thread local, simply return true. + if (t_DacAssertsUnconditionally) + return true; + return g_dacImpl->TargetConsistencyAssertsEnabled(); } diff --git a/src/coreclr/debug/daccess/dacimpl.h b/src/coreclr/debug/daccess/dacimpl.h index 70e8845f6b9..0fc5a780e6f 100644 --- a/src/coreclr/debug/daccess/dacimpl.h +++ b/src/coreclr/debug/daccess/dacimpl.h @@ -528,14 +528,12 @@ struct ProcessModIter kIncludeLoaded | kIncludeExecution)); } - CollectibleAssemblyHolder pDomainAssembly; - if (!m_assemIter.Next(pDomainAssembly.This())) + CollectibleAssemblyHolder pAssembly; + if (!m_assemIter.Next(pAssembly.This())) { return NULL; } - // Note: DAC doesn't need to keep the assembly alive - see code:CollectibleAssemblyHolder#CAH_DAC - CollectibleAssemblyHolder pAssembly = pDomainAssembly->GetAssembly(); return pAssembly; } @@ -1061,7 +1059,7 @@ class ClrDataAccess virtual HRESULT STDMETHODCALLTYPE GetAppDomainData(CLRDATA_ADDRESS addr, struct DacpAppDomainData *data); virtual HRESULT STDMETHODCALLTYPE GetAppDomainName(CLRDATA_ADDRESS addr, unsigned int count, _Inout_updates_z_(count) WCHAR *name, unsigned int *pNeeded); virtual HRESULT STDMETHODCALLTYPE GetAssemblyList(CLRDATA_ADDRESS appDomain, int count, CLRDATA_ADDRESS values[], int *fetched); - virtual HRESULT STDMETHODCALLTYPE GetAssemblyData(CLRDATA_ADDRESS baseDomainPtr, CLRDATA_ADDRESS assembly, struct DacpAssemblyData *data); + virtual HRESULT STDMETHODCALLTYPE GetAssemblyData(CLRDATA_ADDRESS domainPtr, CLRDATA_ADDRESS assembly, struct DacpAssemblyData *data); virtual HRESULT STDMETHODCALLTYPE GetAssemblyName(CLRDATA_ADDRESS assembly, unsigned int count, _Inout_updates_z_(count) WCHAR *name, unsigned int *pNeeded); virtual HRESULT STDMETHODCALLTYPE GetThreadData(CLRDATA_ADDRESS thread, struct DacpThreadData *data); virtual HRESULT STDMETHODCALLTYPE GetThreadFromThinlockID(UINT thinLockId, CLRDATA_ADDRESS *pThread); @@ -1243,8 +1241,10 @@ class ClrDataAccess HRESULT GetObjectDataImpl(CLRDATA_ADDRESS addr, struct DacpObjectData *objectData); HRESULT GetObjectExceptionDataImpl(CLRDATA_ADDRESS objAddr, struct DacpExceptionObjectData *data); HRESULT GetObjectStringDataImpl(CLRDATA_ADDRESS obj, unsigned int count, _Inout_updates_z_(count) WCHAR *stringData, unsigned int *pNeeded); + HRESULT GetPEFileNameImpl(CLRDATA_ADDRESS moduleAddr, unsigned int count, _Inout_updates_z_(count) WCHAR *fileName, unsigned int *pNeeded); HRESULT GetUsefulGlobalsImpl(struct DacpUsefulGlobalsData *globalsData); HRESULT GetMethodDescDataImpl(CLRDATA_ADDRESS methodDesc, CLRDATA_ADDRESS ip, struct DacpMethodDescData *data, ULONG cRevertedRejitVersions, DacpReJitData * rgRevertedRejitData, ULONG * pcNeededRevertedRejitData); + HRESULT GetMethodDescNameImpl(CLRDATA_ADDRESS methodDesc, unsigned int count, _Inout_updates_z_(count) WCHAR *name, unsigned int *pNeeded); BOOL IsExceptionFromManagedCode(EXCEPTION_RECORD * pExceptionRecord); #ifndef TARGET_UNIX @@ -2169,7 +2169,7 @@ class DacHandleWalker : public DefaultCOMImplGetLoaderAllocator()->EnumMemoryRegions(flags); + SystemDomain::GetGlobalLoaderAllocator()->EnumMemoryRegions(flags); } AppDomain* appDomain = AppDomain::GetCurrentDomain(); diff --git a/src/coreclr/debug/daccess/request.cpp b/src/coreclr/debug/daccess/request.cpp index 50a45522968..800db3a2a09 100644 --- a/src/coreclr/debug/daccess/request.cpp +++ b/src/coreclr/debug/daccess/request.cpp @@ -317,6 +317,7 @@ HRESULT ClrDataAccess::GetThreadStoreData(struct DacpThreadStoreData *threadStor // Assert that the data is the same as what we get from the DAC. DacpThreadStoreData threadStoreDataLocal; HRESULT hrLocal = GetThreadStoreDataImpl(&threadStoreDataLocal); + DacAssertsEnabledHolder assertsEnabled; _ASSERTE(hr == hrLocal); _ASSERTE(threadStoreData->threadCount == threadStoreDataLocal.threadCount); _ASSERTE(threadStoreData->unstartedThreadCount == threadStoreDataLocal.unstartedThreadCount); @@ -895,6 +896,7 @@ HRESULT ClrDataAccess::GetThreadData(CLRDATA_ADDRESS threadAddr, struct DacpThre { DacpThreadData threadDataLocal; HRESULT hrLocal = GetThreadDataImpl(threadAddr, &threadDataLocal); + DacAssertsEnabledHolder assertsEnabled; _ASSERTE(hr == hrLocal); _ASSERTE(threadData->corThreadId == threadDataLocal.corThreadId); _ASSERTE(threadData->osThreadId == threadDataLocal.osThreadId); @@ -1080,6 +1082,7 @@ HRESULT ClrDataAccess::GetMethodDescData( pcNeededRevertedRejitDataLocal = &cNeededRevertedRejitDataLocal; } HRESULT hrLocal = GetMethodDescDataImpl(methodDesc, ip,&mdDataLocal, cRevertedRejitVersions, rgRevertedRejitDataLocal, pcNeededRevertedRejitDataLocal); + DacAssertsEnabledHolder assertsEnabled; _ASSERTE(hr == hrLocal); _ASSERTE(methodDescData->bHasNativeCode == mdDataLocal.bHasNativeCode); _ASSERTE(methodDescData->bIsDynamic == mdDataLocal.bIsDynamic); @@ -1581,6 +1584,51 @@ ClrDataAccess::GetMethodDescName(CLRDATA_ADDRESS methodDesc, unsigned int count, SOSDacEnter(); + if (m_cdacSos != NULL) + { + hr = m_cdacSos->GetMethodDescName(methodDesc, count, name, pNeeded); + if (FAILED(hr)) + { + hr = GetMethodDescNameImpl(methodDesc, count, name, pNeeded); + } +#ifdef _DEBUG + else + { + NewArrayHolder nameLocal = new WCHAR[count]; + unsigned int neededLocal = 0; + HRESULT hrLocal = GetMethodDescNameImpl(methodDesc, count, nameLocal, &neededLocal); + + DacAssertsEnabledHolder assertsEnabled; + _ASSERTE(hr == hrLocal); + + if (name != NULL) + { + _ASSERTE(0 == u16_strncmp(name, (WCHAR *)nameLocal, count)); + } + if (pNeeded != NULL) + { + _ASSERTE(*pNeeded == neededLocal); + } + } +#endif + } + else + { + hr = GetMethodDescNameImpl(methodDesc, count, name, pNeeded); + } + + SOSDacLeave(); + return hr; +} + +HRESULT +ClrDataAccess::GetMethodDescNameImpl(CLRDATA_ADDRESS methodDesc, unsigned int count, _Inout_updates_z_(count) WCHAR *name, unsigned int *pNeeded) +{ + if (methodDesc == 0) + return E_INVALIDARG; + + SOSDacEnter(); + MethodDesc* pMD = PTR_MethodDesc(TO_TADDR(methodDesc)); StackSString str; @@ -1701,6 +1749,7 @@ ClrDataAccess::GetObjectStringData(CLRDATA_ADDRESS obj, unsigned int count, _Ino unsigned int neededLocal; SString stringDataLocal; HRESULT hrLocal = GetObjectStringDataImpl(obj, count, stringDataLocal.OpenUnicodeBuffer(count), &neededLocal); + DacAssertsEnabledHolder assertsEnabled; _ASSERTE(hr == hrLocal); _ASSERTE(pNeeded == NULL || *pNeeded == neededLocal); _ASSERTE(u16_strncmp(stringData, stringDataLocal, count) == 0); @@ -1930,6 +1979,7 @@ ClrDataAccess::GetModuleData(CLRDATA_ADDRESS addr, struct DacpModuleData* module { DacpModuleData moduleDataLocal; HRESULT hrLocal = GetModuleDataImpl(addr, &moduleDataLocal); + DacAssertsEnabledHolder assertsEnabled; _ASSERTE(hr == hrLocal); _ASSERTE(moduleData->Address == moduleDataLocal.Address); _ASSERTE(moduleData->PEAssembly == moduleDataLocal.PEAssembly); @@ -2047,6 +2097,7 @@ ClrDataAccess::GetMethodTableData(CLRDATA_ADDRESS mt, struct DacpMethodTableData // Assert that the data is the same as what we get from the DAC. DacpMethodTableData mtDataLocal; HRESULT hrLocal = GetMethodTableDataImpl(mt, &mtDataLocal); + DacAssertsEnabledHolder assertsEnabled; _ASSERTE(hr == hrLocal); _ASSERTE(MTData->BaseSize == mtDataLocal.BaseSize); _ASSERTE(MTData->ComponentSize == mtDataLocal.ComponentSize); @@ -2059,7 +2110,7 @@ ClrDataAccess::GetMethodTableData(CLRDATA_ADDRESS mt, struct DacpMethodTableData _ASSERTE(MTData->wNumVtableSlots == mtDataLocal.wNumVtableSlots); _ASSERTE(MTData->wNumVirtuals == mtDataLocal.wNumVirtuals); _ASSERTE(MTData->cl == mtDataLocal.cl); - _ASSERTE(MTData->dwAttrClass = mtDataLocal.dwAttrClass); + _ASSERTE(MTData->dwAttrClass == mtDataLocal.dwAttrClass); _ASSERTE(MTData->bContainsPointers == mtDataLocal.bContainsPointers); _ASSERTE(MTData->bIsShared == mtDataLocal.bIsShared); _ASSERTE(MTData->bIsDynamic == mtDataLocal.bIsDynamic); @@ -2109,7 +2160,7 @@ ClrDataAccess::GetMethodTableDataImpl(CLRDATA_ADDRESS mt, struct DacpMethodTable MTData->dwAttrClass = pMT->GetAttrClass(); MTData->bContainsPointers = pMT->ContainsGCPointers(); MTData->bIsShared = FALSE; - MTData->bIsDynamic = pMT->IsDynamicStatics(); + MTData->bIsDynamic = pMT->IsDynamicStatics() ? TRUE : FALSE; } return S_OK; } @@ -2136,6 +2187,7 @@ ClrDataAccess::GetMethodTableName(CLRDATA_ADDRESS mt, unsigned int count, _Inout NewArrayHolder pwszNameLocal(new WCHAR[count]); unsigned int neededLocal = 0; HRESULT hrLocal = GetMethodTableNameImpl(mt, count, mtName != NULL ? (WCHAR *)pwszNameLocal : NULL, pNeeded != NULL ? &neededLocal : NULL); + DacAssertsEnabledHolder assertsEnabled; _ASSERTE(hr == hrLocal); if (mtName != NULL) @@ -2415,6 +2467,7 @@ ClrDataAccess::GetMethodTableForEEClass(CLRDATA_ADDRESS eeClassReallyCanonMT, CL // Assert that the data is the same as what we get from the DAC. CLRDATA_ADDRESS valueLocal; HRESULT hrLocal = GetMethodTableForEEClassImpl(eeClassReallyCanonMT, &valueLocal); + DacAssertsEnabledHolder assertsEnabled; _ASSERTE(hr == hrLocal); _ASSERTE(*value == valueLocal); } @@ -2489,6 +2542,41 @@ ClrDataAccess::GetPEFileName(CLRDATA_ADDRESS moduleAddr, unsigned int count, _In return E_INVALIDARG; SOSDacEnter(); + + if (m_cdacSos != NULL) + { + hr = m_cdacSos->GetPEFileName(moduleAddr, count, fileName, pNeeded); + if (FAILED(hr)) + { + hr = GetPEFileNameImpl(moduleAddr, count, fileName, pNeeded); + } +#ifdef _DEBUG + else + { + NewArrayHolder fileNameLocal(new WCHAR[count]); + unsigned int neededLocal = 0; + HRESULT hrLocal = GetPEFileNameImpl(moduleAddr, count, fileNameLocal, &neededLocal); + + DacAssertsEnabledHolder assertsEnabled; + _ASSERTE(hr == hrLocal); + _ASSERTE(pNeeded == NULL || *pNeeded == neededLocal); + _ASSERTE(fileName == NULL || u16_strncmp(fileName, fileNameLocal, count) == 0); + } +#endif + } + else + { + hr = GetPEFileNameImpl(moduleAddr, count, fileName, pNeeded);; + } + + + SOSDacLeave(); + return hr; +} + +HRESULT +ClrDataAccess::GetPEFileNameImpl(CLRDATA_ADDRESS moduleAddr, unsigned int count, _Inout_updates_z_(count) WCHAR *fileName, unsigned int *pNeeded) +{ PTR_Module pModule = PTR_Module(TO_TADDR(moduleAddr)); PEAssembly* pPEAssembly = pModule->GetPEAssembly(); @@ -2496,11 +2584,11 @@ ClrDataAccess::GetPEFileName(CLRDATA_ADDRESS moduleAddr, unsigned int count, _In if (!pPEAssembly->GetPath().IsEmpty()) { if (!pPEAssembly->GetPath().DacGetUnicode(count, fileName, pNeeded)) - hr = E_FAIL; + return E_FAIL; } else if (!pPEAssembly->IsReflectionEmit()) { - hr = E_NOTIMPL; + return E_NOTIMPL; } else { @@ -2511,8 +2599,7 @@ ClrDataAccess::GetPEFileName(CLRDATA_ADDRESS moduleAddr, unsigned int count, _In *pNeeded = 1; } - SOSDacLeave(); - return hr; + return S_OK; } HRESULT @@ -2545,6 +2632,7 @@ DWORD DACGetNumComponents(TADDR addr, ICorDebugDataTarget* target) // This expects that the first member after the MethodTable pointer (from Object) // is a 32-bit integer representing the number of components. // This holds for ArrayBase and StringObject - see coreclr/vm/object.h + // Free objects also have a component count set at this offset- see SetFree in coreclr/gc/gc.cpp addr += sizeof(size_t); // Method table pointer ULONG32 returned = 0; DWORD Value = 0; @@ -2578,6 +2666,7 @@ ClrDataAccess::GetObjectData(CLRDATA_ADDRESS addr, struct DacpObjectData* object { DacpObjectData objectDataLocal; HRESULT hrLocal = GetObjectDataImpl(addr, &objectDataLocal); + DacAssertsEnabledHolder assertsEnabled; _ASSERTE(hr == hrLocal); _ASSERTE(objectData->MethodTable == objectDataLocal.MethodTable); _ASSERTE(objectData->ObjectType == objectDataLocal.ObjectType); @@ -2745,19 +2834,17 @@ ClrDataAccess::GetAppDomainData(CLRDATA_ADDRESS addr, struct DacpAppDomainData * } else { - PTR_BaseDomain pBaseDomain = PTR_BaseDomain(TO_TADDR(addr)); - ZeroMemory(appdomainData, sizeof(DacpAppDomainData)); - appdomainData->AppDomainPtr = PTR_CDADDR(pBaseDomain); - PTR_LoaderAllocator pLoaderAllocator = pBaseDomain->GetLoaderAllocator(); + appdomainData->AppDomainPtr = addr; + PTR_LoaderAllocator pLoaderAllocator = SystemDomain::GetGlobalLoaderAllocator(); appdomainData->pHighFrequencyHeap = HOST_CDADDR(pLoaderAllocator->GetHighFrequencyHeap()); appdomainData->pLowFrequencyHeap = HOST_CDADDR(pLoaderAllocator->GetLowFrequencyHeap()); appdomainData->pStubHeap = HOST_CDADDR(pLoaderAllocator->GetStubHeap()); appdomainData->appDomainStage = STAGE_OPEN; - if (pBaseDomain->IsAppDomain()) + if (addr != HOST_CDADDR(SystemDomain::System())) { - AppDomain * pAppDomain = pBaseDomain->AsAppDomain(); + PTR_AppDomain pAppDomain = PTR_AppDomain(TO_TADDR(addr)); appdomainData->DomainLocalBlock = 0; appdomainData->pDomainLocalModules = 0; @@ -2768,11 +2855,11 @@ ClrDataAccess::GetAppDomainData(CLRDATA_ADDRESS addr, struct DacpAppDomainData * // The assembly list is not valid in a closed appdomain. AppDomain::AssemblyIterator i = pAppDomain->IterateAssembliesEx((AssemblyIterationFlags)( kIncludeLoading | kIncludeLoaded | kIncludeExecution)); - CollectibleAssemblyHolder pDomainAssembly; + CollectibleAssemblyHolder pAssembly; - while (i.Next(pDomainAssembly.This())) + while (i.Next(pAssembly.This())) { - if (pDomainAssembly->IsLoaded()) + if (pAssembly->IsLoaded()) { appdomainData->AssemblyCount++; } @@ -2874,22 +2961,25 @@ ClrDataAccess::GetAssemblyList(CLRDATA_ADDRESS addr, int count, CLRDATA_ADDRESS SOSDacEnter(); - BaseDomain* pBaseDomain = PTR_BaseDomain(TO_TADDR(addr)); - - int n=0; - if (pBaseDomain->IsAppDomain()) + if (addr == HOST_CDADDR(SystemDomain::System())) { - AppDomain::AssemblyIterator i = pBaseDomain->AsAppDomain()->IterateAssembliesEx( + // We shouldn't be asking for the assemblies in SystemDomain + hr = E_INVALIDARG; + } + else + { + PTR_AppDomain pAppDomain = PTR_AppDomain(TO_TADDR(addr)); + AppDomain::AssemblyIterator i = pAppDomain->IterateAssembliesEx( (AssemblyIterationFlags)(kIncludeLoading | kIncludeLoaded | kIncludeExecution)); - CollectibleAssemblyHolder pDomainAssembly; + CollectibleAssemblyHolder pAssembly; + int n = 0; if (values) { - while (i.Next(pDomainAssembly.This()) && (n < count)) + while (i.Next(pAssembly.This()) && (n < count)) { - if (pDomainAssembly->IsLoaded()) + if (pAssembly->IsLoaded()) { - CollectibleAssemblyHolder pAssembly = pDomainAssembly->GetAssembly(); // Note: DAC doesn't need to keep the assembly alive - see code:CollectibleAssemblyHolder#CAH_DAC values[n++] = HOST_CDADDR(pAssembly.Extract()); } @@ -2897,21 +2987,14 @@ ClrDataAccess::GetAssemblyList(CLRDATA_ADDRESS addr, int count, CLRDATA_ADDRESS } else { - while (i.Next(pDomainAssembly.This())) - if (pDomainAssembly->IsLoaded()) + while (i.Next(pAssembly.This())) + if (pAssembly->IsLoaded()) n++; } if (pNeeded) *pNeeded = n; } - else - { - // The only other type of BaseDomain is the SystemDomain, and we shouldn't be asking - // for the assemblies in it. - _ASSERTE(false); - hr = E_INVALIDARG; - } SOSDacLeave(); return hr; @@ -2951,31 +3034,44 @@ ClrDataAccess::GetAppDomainName(CLRDATA_ADDRESS addr, unsigned int count, _Inout { SOSDacEnter(); - PTR_BaseDomain pBaseDomain = PTR_BaseDomain(TO_TADDR(addr)); - if (!pBaseDomain->IsAppDomain()) + if (addr == HOST_CDADDR(SystemDomain::System())) { - // Shared domain and SystemDomain don't have this field. + // SystemDomain doesn't have this field. if (pNeeded) *pNeeded = 1; - if (name) + if (name && count > 0) name[0] = 0; } else { - AppDomain* pAppDomain = pBaseDomain->AsAppDomain(); + PTR_AppDomain pAppDomain = PTR_AppDomain(TO_TADDR(addr)); - if (!pAppDomain->m_friendlyName.IsEmpty()) + size_t countAsSizeT = count; + if (pAppDomain->m_friendlyName.IsValid()) { - if (!pAppDomain->m_friendlyName.DacGetUnicode(count, name, pNeeded)) + LPCWSTR friendlyName = (LPCWSTR)pAppDomain->m_friendlyName; + size_t friendlyNameLen = u16_strlen(friendlyName); + + if (pNeeded) { - hr = E_FAIL; + *pNeeded = (unsigned int)(friendlyNameLen + 1); + } + + if (name && count > 0) + { + if (countAsSizeT > (friendlyNameLen + 1)) + { + countAsSizeT = friendlyNameLen + 1; + } + memcpy(name, friendlyName, countAsSizeT * sizeof(WCHAR)); + name[countAsSizeT - 1] = 0; } } else { if (pNeeded) *pNeeded = 1; - if (name) + if (name && count > 0) name[0] = 0; hr = S_OK; @@ -3014,9 +3110,9 @@ ClrDataAccess::GetAppDomainConfigFile(CLRDATA_ADDRESS appDomain, int count, } HRESULT -ClrDataAccess::GetAssemblyData(CLRDATA_ADDRESS cdBaseDomainPtr, CLRDATA_ADDRESS assembly, struct DacpAssemblyData *assemblyData) +ClrDataAccess::GetAssemblyData(CLRDATA_ADDRESS domain, CLRDATA_ADDRESS assembly, struct DacpAssemblyData *assemblyData) { - if (assembly == (CLRDATA_ADDRESS)NULL && cdBaseDomainPtr == (CLRDATA_ADDRESS)NULL) + if (assembly == (CLRDATA_ADDRESS)NULL && domain == (CLRDATA_ADDRESS)NULL) { return E_INVALIDARG; } @@ -3028,14 +3124,9 @@ ClrDataAccess::GetAssemblyData(CLRDATA_ADDRESS cdBaseDomainPtr, CLRDATA_ADDRESS // Make sure conditionally-assigned fields like AssemblySecDesc, LoadContext, etc. are zeroed ZeroMemory(assemblyData, sizeof(DacpAssemblyData)); - // If the specified BaseDomain is an AppDomain, get a pointer to it - AppDomain * pDomain = NULL; - if (cdBaseDomainPtr != (CLRDATA_ADDRESS)NULL) + if (domain != (CLRDATA_ADDRESS)NULL) { - assemblyData->BaseDomainPtr = cdBaseDomainPtr; - PTR_BaseDomain baseDomain = PTR_BaseDomain(TO_TADDR(cdBaseDomainPtr)); - if( baseDomain->IsAppDomain() ) - pDomain = baseDomain->AsAppDomain(); + assemblyData->DomainPtr = domain; } assemblyData->AssemblyPtr = HOST_CDADDR(pAssembly); @@ -3586,6 +3677,7 @@ ClrDataAccess::GetUsefulGlobals(struct DacpUsefulGlobalsData* globalsData) // Assert that the data is the same as what we get from the DAC. DacpUsefulGlobalsData globalsDataLocal; HRESULT hrLocal = GetUsefulGlobalsImpl(&globalsDataLocal); + DacAssertsEnabledHolder assertsEnabled; _ASSERTE(hr == hrLocal); _ASSERTE(globalsData->ArrayMethodTable == globalsDataLocal.ArrayMethodTable); _ASSERTE(globalsData->StringMethodTable == globalsDataLocal.StringMethodTable); @@ -3644,6 +3736,7 @@ ClrDataAccess::GetNestedExceptionData(CLRDATA_ADDRESS exception, CLRDATA_ADDRESS CLRDATA_ADDRESS exceptionObjectLocal; CLRDATA_ADDRESS nextNestedExceptionLocal; HRESULT hrLocal = GetNestedExceptionDataImpl(exception, &exceptionObjectLocal, &nextNestedExceptionLocal); + DacAssertsEnabledHolder assertsEnabled; _ASSERTE(hr == hrLocal); _ASSERTE(*exceptionObject == exceptionObjectLocal); _ASSERTE(*nextNestedException == nextNestedExceptionLocal); @@ -3709,7 +3802,7 @@ ClrDataAccess::GetThreadLocalModuleData(CLRDATA_ADDRESS thread, unsigned int ind HRESULT ClrDataAccess::GetHandleEnum(ISOSHandleEnum **ppHandleEnum) { unsigned int types[] = {HNDTYPE_WEAK_SHORT, HNDTYPE_WEAK_LONG, HNDTYPE_STRONG, HNDTYPE_PINNED, HNDTYPE_DEPENDENT, - HNDTYPE_SIZEDREF, HNDTYPE_WEAK_INTERIOR_POINTER, + HNDTYPE_WEAK_INTERIOR_POINTER, #if defined(FEATURE_COMINTEROP) || defined(FEATURE_COMWRAPPERS) || defined(FEATURE_OBJCMARSHAL) HNDTYPE_REFCOUNTED, #endif // FEATURE_COMINTEROP || FEATURE_COMWRAPPERS || FEATURE_OBJCMARSHAL @@ -3747,7 +3840,6 @@ HRESULT ClrDataAccess::GetHandleEnumForGC(unsigned int gen, ISOSHandleEnum **ppH SOSDacEnter(); unsigned int types[] = {HNDTYPE_WEAK_SHORT, HNDTYPE_WEAK_LONG, HNDTYPE_STRONG, HNDTYPE_PINNED, HNDTYPE_DEPENDENT, - HNDTYPE_SIZEDREF, #if defined(FEATURE_COMINTEROP) || defined(FEATURE_COMWRAPPERS) || defined(FEATURE_OBJCMARSHAL) HNDTYPE_REFCOUNTED, #endif // FEATURE_COMINTEROP || FEATURE_COMWRAPPERS || FEATURE_OBJCMARSHAL @@ -3975,8 +4067,7 @@ ClrDataAccess::TraverseVirtCallStubHeap(CLRDATA_ADDRESS pAppDomain, VCSHeapType SOSDacEnter(); - BaseDomain* pBaseDomain = PTR_BaseDomain(TO_TADDR(pAppDomain)); - VirtualCallStubManager *pVcsMgr = pBaseDomain->GetLoaderAllocator()->GetVirtualCallStubManager(); + VirtualCallStubManager *pVcsMgr = SystemDomain::GetGlobalLoaderAllocator()->GetVirtualCallStubManager(); if (!pVcsMgr) { hr = E_POINTER; @@ -4021,8 +4112,8 @@ HRESULT ClrDataAccess::GetDomainLoaderAllocator(CLRDATA_ADDRESS domainAddress, C SOSDacEnter(); - PTR_BaseDomain pDomain = PTR_BaseDomain(TO_TADDR(domainAddress)); - *pLoaderAllocator = pDomain != nullptr ? HOST_CDADDR(pDomain->GetLoaderAllocator()) : 0; + // The one and only app domain uses the global loader allocator + *pLoaderAllocator = HOST_CDADDR(SystemDomain::GetGlobalLoaderAllocator()); SOSDacLeave(); return hr; @@ -4965,6 +5056,7 @@ HRESULT ClrDataAccess::GetObjectExceptionData(CLRDATA_ADDRESS objAddr, struct Da { DacpExceptionObjectData dataLocal; HRESULT hrLocal = GetObjectExceptionDataImpl(objAddr, &dataLocal); + DacAssertsEnabledHolder assertsEnabled; _ASSERTE(hr == hrLocal); _ASSERTE(data->Message == dataLocal.Message); _ASSERTE(data->InnerException == dataLocal.InnerException); diff --git a/src/coreclr/debug/daccess/stack.cpp b/src/coreclr/debug/daccess/stack.cpp index 6b9f1a491c2..a0dc074ae1f 100644 --- a/src/coreclr/debug/daccess/stack.cpp +++ b/src/coreclr/debug/daccess/stack.cpp @@ -1309,7 +1309,7 @@ ClrDataFrame::ValueFromDebugInfo(MetaSig* sig, { HRESULT status; ULONG32 numVarInfo; - NewHolder varInfo(NULL); + NewArrayHolder varInfo(NULL); ULONG32 codeOffset; ULONG32 valueFlags; ULONG32 i; diff --git a/src/coreclr/debug/daccess/task.cpp b/src/coreclr/debug/daccess/task.cpp index ca597485584..65f14dedd18 100644 --- a/src/coreclr/debug/daccess/task.cpp +++ b/src/coreclr/debug/daccess/task.cpp @@ -713,30 +713,21 @@ ClrDataAppDomain::GetName( EX_TRY { - bool isUtf8; - PVOID rawName = m_appDomain->GetFriendlyNameNoSet(&isUtf8); + LPCWSTR rawName = m_appDomain->GetFriendlyName(); if (rawName) { - if (isUtf8) - { - status = ConvertUtf8((LPCUTF8)rawName, - bufLen, nameLen, name); - } - else + status = StringCchCopy(name, bufLen, rawName) == S_OK ? + S_OK : S_FALSE; + if (nameLen) { - status = StringCchCopy(name, bufLen, (PCWSTR)rawName) == S_OK ? - S_OK : S_FALSE; - if (nameLen) + size_t cchName = u16_strlen(rawName) + 1; + if (FitsIn(cchName)) { - size_t cchName = u16_strlen((PCWSTR)rawName) + 1; - if (FitsIn(cchName)) - { - *nameLen = (ULONG32) cchName; - } - else - { - status = COR_E_OVERFLOW; - } + *nameLen = (ULONG32) cchName; + } + else + { + status = COR_E_OVERFLOW; } } } @@ -5205,8 +5196,8 @@ EnumMethodInstances::Next(ClrDataAccess* dac, NextMethod: { // Note: DAC doesn't need to keep the assembly alive - see code:CollectibleAssemblyHolder#CAH_DAC - CollectibleAssemblyHolder pDomainAssembly; - if (!m_methodIter.Next(pDomainAssembly.This())) + CollectibleAssemblyHolder pAssembly; + if (!m_methodIter.Next(pAssembly.This())) { return S_FALSE; } diff --git a/src/coreclr/debug/di/process.cpp b/src/coreclr/debug/di/process.cpp index aae787486ad..fffd6df4848 100644 --- a/src/coreclr/debug/di/process.cpp +++ b/src/coreclr/debug/di/process.cpp @@ -11157,17 +11157,49 @@ void CordbProcess::HandleSetThreadContextNeeded(DWORD dwThreadId) LOG((LF_CORDB, LL_INFO10000, "RS HandleSetThreadContextNeeded\n")); #if defined(TARGET_WINDOWS) && defined(TARGET_AMD64) - HandleHolder hThread = OpenThread( - THREAD_GET_CONTEXT | THREAD_SET_CONTEXT | THREAD_QUERY_INFORMATION | THREAD_SUSPEND_RESUME, - FALSE, // thread handle is not inheritable. - dwThreadId); + // Before we can read the left side context information, we must: + // 1. obtain the thread handle + // 2. suspened the thread + // 3. read the thread context, and from that read the pointer to the left-side context and the size of the context + // 4. then we can perform the actual SetThreadContext operation + // 5. lastly, we must resume the thread + // For the first step of obtaining the thread handle, + // we have previously attempted to use ::OpenThread to get a handle to the thread. + // However, there are situations where OpenThread can fail with an Access Denied error. + // From https://github.com/dotnet/runtime/issues/107263, the control-c handler in + // Windows causes the process to have higher privileges. + // We are now using the following approach to access the thread handle, which is the same + // approach used by CordbThread::RefreshHandle: + // 1. Get the thread handle from the DAC + // 2. Duplicate the handle to the current process + + // lookup the CordbThread by thread ID, so that we can access the left-side thread handle + CordbThread * pThread = TryLookupOrCreateThreadByVolatileOSId(dwThreadId); + + IDacDbiInterface* pDAC = GetDAC(); + if (pDAC == NULL) + { + LOG((LF_CORDB, LL_INFO10000, "RS HandleSetThreadContextNeeded - DAC not initialized\n")); + ThrowHR(E_UNEXPECTED); + } - if (hThread == NULL) + HANDLE hOutOfProcThread = pDAC->GetThreadHandle(pThread->m_vmThreadToken); + if (hOutOfProcThread == NULL) { - LOG((LF_CORDB, LL_INFO10000, "RS HandleSetThreadContextNeeded - Unexpected result from OpenThread\n")); + LOG((LF_CORDB, LL_INFO10000, "RS HandleSetThreadContextNeeded - Failed to get thread handle\n")); ThrowHR(E_UNEXPECTED); } + // Duplicate the thread handle to the current process + HandleHolder hThread; + BOOL fSuccess = DuplicateHandle(UnsafeGetProcessHandle(), hOutOfProcThread, ::GetCurrentProcess(), &hThread, 0, FALSE, DUPLICATE_SAME_ACCESS); + if (!fSuccess) + { + LOG((LF_CORDB, LL_INFO10000, "RS HandleSetThreadContextNeeded - Unexpected result from DuplicateHandle\n")); + ThrowHR(HRESULT_FROM_GetLastError()); + } + + // Suspend the thread and so that we can read the thread context. DWORD previousSuspendCount = ::SuspendThread(hThread); if (previousSuspendCount == (DWORD)-1) { @@ -11178,12 +11210,22 @@ void CordbProcess::HandleSetThreadContextNeeded(DWORD dwThreadId) DT_CONTEXT context = { 0 }; context.ContextFlags = CONTEXT_FULL; - HRESULT hr = GetDataTarget()->GetThreadContext(dwThreadId, CONTEXT_FULL, sizeof(DT_CONTEXT), reinterpret_cast (&context)); - IfFailThrow(hr); + // we originally used GetDataTarget()->GetThreadContext, but + // the implementation uses ShimLocalDataTarget::GetThreadContext which + // depends on OpenThread which might fail with an Access Denied error (see note above) + BOOL success = ::GetThreadContext(hThread, (CONTEXT*)(&context)); + if (!success) + { + LOG((LF_CORDB, LL_INFO10000, "RS HandleSetThreadContextNeeded - Unexpected result from GetThreadContext\n")); + ThrowHR(HRESULT_FROM_GetLastError()); + } + // Read the pointer to the left-side context and the size of the context from the thread context. TADDR lsContextAddr = (TADDR)context.Rcx; DWORD contextSize = (DWORD)context.Rdx; + // Read the expected Rip and Rsp from the thread context. This is used to + // validate the context read from the left-side. TADDR expectedRip = (TADDR)context.R8; TADDR expectedRsp = (TADDR)context.R9; @@ -11198,7 +11240,7 @@ void CordbProcess::HandleSetThreadContextNeeded(DWORD dwThreadId) PCONTEXT pContext = (PCONTEXT)_alloca(contextSize); ULONG32 cbRead; - hr = GetDataTarget()->ReadVirtual(lsContextAddr, reinterpret_cast(pContext), contextSize, &cbRead); + HRESULT hr = GetDataTarget()->ReadVirtual(lsContextAddr, reinterpret_cast(pContext), contextSize, &cbRead); if (FAILED(hr)) { _ASSERTE(!"ReadVirtual failed"); @@ -11232,7 +11274,7 @@ void CordbProcess::HandleSetThreadContextNeeded(DWORD dwThreadId) // The initialize call should fail but return contextSize contextSize = 0; DWORD contextFlags = pContext->ContextFlags; - BOOL success = InitializeContext(NULL, contextFlags, NULL, &contextSize); + success = InitializeContext(NULL, contextFlags, NULL, &contextSize); if(success || GetLastError() != ERROR_INSUFFICIENT_BUFFER) { @@ -11276,6 +11318,7 @@ void CordbProcess::HandleSetThreadContextNeeded(DWORD dwThreadId) DWORD lastError = 0; + // Perform the actual SetThreadContext operation. success = ::SetThreadContext(hThread, pFrameContext); if (!success) { @@ -11285,6 +11328,7 @@ void CordbProcess::HandleSetThreadContextNeeded(DWORD dwThreadId) LOG((LF_CORDB, LL_INFO10000, "RS HandleSetThreadContextNeeded - Set Thread Context Completed: Success=%d GetLastError=%d hr=0x%X\n", success, lastError, HRESULT_FROM_WIN32(lastError))); _ASSERTE(success); + // Now that we have completed the SetThreadContext, resume the thread DWORD suspendCount = ::ResumeThread(hThread); if (suspendCount == (DWORD)-1) { diff --git a/src/coreclr/debug/ee/controller.cpp b/src/coreclr/debug/ee/controller.cpp index e929aa8bd3f..8b7d0d88cc4 100644 --- a/src/coreclr/debug/ee/controller.cpp +++ b/src/coreclr/debug/ee/controller.cpp @@ -7278,6 +7278,9 @@ void DebuggerStepper::TriggerMethodEnter(Thread * thread, // the assert if we end up in the method we started in (which could happen if we trace call // instructions before the JMC probe). // m_StepInStartMethod may be null (if this step-in didn't start from managed code). +#if defined(TARGET_ARM64) && defined(__APPLE__) + LOG((LF_CORDB, LL_INFO10000, "DebuggerStepper::TriggerMethodEnter: Consistency_check_MSGF not needed because we skip setting breakpoints in certain patches on arm64-macOS\n")); +#else if ((m_StepInStartMethod != pDesc) && (!m_StepInStartMethod->IsLCGMethod())) { @@ -7288,27 +7291,27 @@ void DebuggerStepper::TriggerMethodEnter(Thread * thread, SString sLog; StubManager::DbgGetLog(&sLog); - - // Assert b/c the Stub-manager should have caught us first. - // We don't want people relying on TriggerMethodEnter as the real implementation for Traditional Step-in - // (see above for reasons why). However, using TME will provide a bandage for the final retail product - // in cases where we are missing a stub-manager. - CONSISTENCY_CHECK_MSGF(false, ( - "\nThe Stubmanagers failed to identify and trace a stub on step-in. The stub-managers for this code-path path need to be fixed.\n" - "See http://team/sites/clrdev/Devdocs/StubManagers.rtf for more information on StubManagers.\n" - "Stepper this=0x%p, startMethod='%s::%s'\n" - "---------------------------------\n" - "Stub manager log:\n%s" - "\n" - "The thread is now in managed method '%s::%s'.\n" - "---------------------------------\n", - this, - ((m_StepInStartMethod == NULL) ? "unknown" : m_StepInStartMethod->m_pszDebugClassName), - ((m_StepInStartMethod == NULL) ? "unknown" : m_StepInStartMethod->m_pszDebugMethodName), - sLog.GetUTF8(), - pDesc->m_pszDebugClassName, pDesc->m_pszDebugMethodName - )); - } + // Assert b/c the Stub-manager should have caught us first. + // We don't want people relying on TriggerMethodEnter as the real implementation for Traditional Step-in + // (see above for reasons why). However, using TME will provide a bandage for the final retail product + // in cases where we are missing a stub-manager. + CONSISTENCY_CHECK_MSGF(false, ( + "\nThe Stubmanagers failed to identify and trace a stub on step-in. The stub-managers for this code-path path need to be fixed.\n" + "See http://team/sites/clrdev/Devdocs/StubManagers.rtf for more information on StubManagers.\n" + "Stepper this=0x%p, startMethod='%s::%s'\n" + "---------------------------------\n" + "Stub manager log:\n%s" + "\n" + "The thread is now in managed method '%s::%s'.\n" + "---------------------------------\n", + this, + ((m_StepInStartMethod == NULL) ? "unknown" : m_StepInStartMethod->m_pszDebugClassName), + ((m_StepInStartMethod == NULL) ? "unknown" : m_StepInStartMethod->m_pszDebugMethodName), + sLog.GetUTF8(), + pDesc->m_pszDebugClassName, pDesc->m_pszDebugMethodName + )); + } +#endif //defined(TARGET_ARM64) && defined(__APPLE__) #endif // Place a patch to stop us. diff --git a/src/coreclr/debug/ee/controller.h b/src/coreclr/debug/ee/controller.h index 2f264876217..16e702e5cd3 100644 --- a/src/coreclr/debug/ee/controller.h +++ b/src/coreclr/debug/ee/controller.h @@ -1039,7 +1039,7 @@ class DebuggerController //right side needs to read friend class Debugger; // So Debugger can lock, use, unlock the patch // table in MapAndBindFunctionBreakpoints - friend void Debugger::UnloadModule(Module* pRuntimeModule, AppDomain *pAppDomain); + friend void Debugger::UnloadModule(Module* pRuntimeModule); // // Static functionality diff --git a/src/coreclr/debug/ee/debugger.cpp b/src/coreclr/debug/ee/debugger.cpp index 8ed914cf310..70f0c306e11 100644 --- a/src/coreclr/debug/ee/debugger.cpp +++ b/src/coreclr/debug/ee/debugger.cpp @@ -2832,7 +2832,7 @@ HRESULT Debugger::GetILToNativeMapping(PCODE pNativeCodeStartAddress, ULONG32 cM CONTRACTL { THROWS; - GC_TRIGGERS_FROM_GETJITINFO; + GC_NOTRIGGER; } CONTRACTL_END; @@ -5134,7 +5134,7 @@ DebuggerModule * Debugger::LookupOrCreateModule(DomainAssembly * pDomainAssembly { _ASSERTE(pDomainAssembly != NULL); LOG((LF_CORDB, LL_INFO1000, "D::LOCM df=%p\n", pDomainAssembly)); - DebuggerModule * pDModule = LookupOrCreateModule(pDomainAssembly->GetModule(), AppDomain::GetCurrentDomain()); + DebuggerModule * pDModule = LookupOrCreateModule(pDomainAssembly->GetModule()); LOG((LF_CORDB, LL_INFO1000, "D::LOCM m=%p ad=%p -> dm=%p\n", pDomainAssembly->GetModule(), AppDomain::GetCurrentDomain(), pDModule)); _ASSERTE(pDModule != NULL); _ASSERTE(pDModule->GetDomainAssembly() == pDomainAssembly); @@ -5166,12 +5166,11 @@ DebuggerModule * Debugger::LookupOrCreateModule(VMPTR_DomainAssembly vmDomainAss // // Arguments: // pModule - required runtime module. May be domain netural. -// pAppDomain - required appdomain that the module is in. // // Returns: // Debugger Module isntance for the given domain file. May be lazily created. // -DebuggerModule* Debugger::LookupOrCreateModule(Module* pModule, AppDomain *pAppDomain) +DebuggerModule* Debugger::LookupOrCreateModule(Module* pModule) { CONTRACTL { @@ -5180,12 +5179,8 @@ DebuggerModule* Debugger::LookupOrCreateModule(Module* pModule, AppDomain *pAppD } CONTRACTL_END; - LOG((LF_CORDB, LL_INFO1000, "D::LOCM m=%p ad=%p\n", pModule, pAppDomain)); - - // DebuggerModules are relative to a specific AppDomain so we should always be looking up a module / - // AppDomain pair. _ASSERTE( pModule != NULL ); - _ASSERTE( pAppDomain != NULL ); + LOG((LF_CORDB, LL_INFO1000, "D::LOCM m=%p\n", pModule)); // This is called from all over. We just need to lock in order to lookup. We don't need // the lock when actually using the DebuggerModule (since it won't be unloaded as long as there is a thread @@ -5193,11 +5188,6 @@ DebuggerModule* Debugger::LookupOrCreateModule(Module* pModule, AppDomain *pAppD // We can take the lock anyways because it's reentrant. DebuggerDataLockHolder ch(g_pDebugger); // need to traverse module list - // if this is a module belonging to the system assembly, then scan - // the complete list of DebuggerModules looking for the one - // with a matching appdomain id - // it. - DebuggerModule* dmod = NULL; if (m_pModules != NULL) @@ -5208,7 +5198,7 @@ DebuggerModule* Debugger::LookupOrCreateModule(Module* pModule, AppDomain *pAppD // If it doesn't exist, create it. if (dmod == NULL) { - LOG((LF_CORDB, LL_INFO1000, "D::LOCM dmod for m=%p ad=%p not found, creating.\n", pModule, pAppDomain)); + LOG((LF_CORDB, LL_INFO1000, "D::LOCM dmod for m=%p not found, creating.\n", pModule)); HRESULT hr = S_OK; EX_TRY { @@ -5220,11 +5210,8 @@ DebuggerModule* Debugger::LookupOrCreateModule(Module* pModule, AppDomain *pAppD SIMPLIFYING_ASSUMPTION(dmod != NULL); // may not be true in OOM cases; but LS doesn't handle OOM. } - // The module must be in the AppDomain that was requested - _ASSERTE( (dmod == NULL) || (dmod->GetAppDomain() == pAppDomain) ); - - LOG((LF_CORDB, LL_INFO1000, "D::LOCM m=%p ad=%p -> dm=%p(Mod=%p, DomFile=%p, AD=%p)\n", - pModule, pAppDomain, dmod, dmod->GetRuntimeModule(), dmod->GetDomainAssembly(), dmod->GetAppDomain())); + LOG((LF_CORDB, LL_INFO1000, "D::LOCM m=%p -> dm=%p(Mod=%p, DomFile=%p)\n", + pModule, dmod, dmod->GetRuntimeModule(), dmod->GetDomainAssembly())); return dmod; } @@ -5249,12 +5236,11 @@ DebuggerModule* Debugger::AddDebuggerModule(DomainAssembly * pDomainAssembly) DebuggerDataLockHolder chInfo(this); Module * pRuntimeModule = pDomainAssembly->GetModule(); - AppDomain * pAppDomain = AppDomain::GetCurrentDomain(); HRESULT hr = CheckInitModuleTable(); IfFailThrow(hr); - DebuggerModule* pModule = new (interopsafe) DebuggerModule(pRuntimeModule, pDomainAssembly, pAppDomain); + DebuggerModule* pModule = new (interopsafe) DebuggerModule(pRuntimeModule, pDomainAssembly); _ASSERTE(pModule != NULL); // throws on oom TRACE_ALLOC(pModule); @@ -6161,7 +6147,7 @@ void Debugger::LockAndSendEnCRemapEvent(DebuggerJitInfo * dji, SIZE_T currentIP, Module *pRuntimeModule = pMD->GetModule(); - DebuggerModule * pDModule = LookupOrCreateModule(pRuntimeModule, AppDomain::GetCurrentDomain()); + DebuggerModule * pDModule = LookupOrCreateModule(pRuntimeModule); ipce->EnCRemap.vmDomainAssembly.SetRawPtr((pDModule ? pDModule->GetDomainAssembly() : NULL)); LOG((LF_CORDB, LL_INFO10000, "D::LASEnCRE: %s::%s dmod:%p\n", @@ -6206,7 +6192,7 @@ void Debugger::LockAndSendEnCRemapCompleteEvent(MethodDesc *pMD) Module *pRuntimeModule = pMD->GetModule(); - DebuggerModule * pDModule = LookupOrCreateModule(pRuntimeModule, AppDomain::GetCurrentDomain()); + DebuggerModule * pDModule = LookupOrCreateModule(pRuntimeModule); ipce->EnCRemapComplete.vmDomainAssembly.SetRawPtr((pDModule ? pDModule->GetDomainAssembly() : NULL)); LOG((LF_CORDB, LL_INFO10000, "D::LASEnCRE: %s::%s dmod:%p, methodDef:0x%08x \n", @@ -6269,7 +6255,7 @@ void Debugger::SendEnCUpdateEvent(DebuggerIPCEventType eventType, _ASSERTE(pModule); - DebuggerModule * pDModule = LookupOrCreateModule(pModule, AppDomain::GetCurrentDomain()); + DebuggerModule * pDModule = LookupOrCreateModule(pModule); event->EnCUpdate.vmDomainAssembly.SetRawPtr((pDModule ? pDModule->GetDomainAssembly() : NULL)); m_pRCThread->SendIPCEvent(); @@ -8849,7 +8835,7 @@ void Debugger::SendUserBreakpoint(Thread * thread) { THROWS; GC_TRIGGERS; - MODE_ANY; + MODE_PREEMPTIVE; PRECONDITION(thread != NULL); PRECONDITION(thread == ::GetThreadNULLOk()); @@ -9364,15 +9350,13 @@ void Debugger::UnloadAssembly(DomainAssembly * pDomainAssembly) // // LoadModule is called when a Runtime thread loads a new module and a debugger -// is attached. This also includes when a domain-neutral module is "loaded" into -// a new domain. +// is attached. // // TODO: remove pszModuleName and perhaps other args. void Debugger::LoadModule(Module* pRuntimeModule, LPCWSTR pszModuleName, // module file name. DWORD dwModuleName, // length of pszModuleName in chars, not including null. Assembly *pAssembly, - AppDomain *pAppDomain, DomainAssembly * pDomainAssembly, BOOL fAttaching) { @@ -9418,12 +9402,11 @@ void Debugger::LoadModule(Module* pRuntimeModule, // We should simply things when we actually get rid of DebuggerModule, possibly by just passing the // DomainAssembly around. _ASSERTE(module->GetDomainAssembly() == pDomainAssembly); - _ASSERTE(module->GetAppDomain() == AppDomain::GetCurrentDomain()); _ASSERTE(module->GetRuntimeModule() == pDomainAssembly->GetModule()); // Send a load module event to the Right Side. ipce = m_pRCThread->GetIPCEventSendBuffer(); - InitIPCEvent(ipce,DB_IPCE_LOAD_MODULE, pThread, pAppDomain); + InitIPCEvent(ipce,DB_IPCE_LOAD_MODULE, pThread, AppDomain::GetCurrentDomain()); ipce->LoadModuleData.vmDomainAssembly.SetRawPtr(pDomainAssembly); @@ -9484,7 +9467,7 @@ void Debugger::SendRawUpdateModuleSymsEvent(Module *pRuntimeModule, AppDomain *p if (pRuntimeModule->GetInMemorySymbolStream() == NULL) return; // Non-PDB symbols - DebuggerModule* module = LookupOrCreateModule(pRuntimeModule, pAppDomain); + DebuggerModule* module = LookupOrCreateModule(pRuntimeModule); PREFIX_ASSUME(module != NULL); DebuggerIPCEvent* ipce = NULL; @@ -9551,16 +9534,9 @@ void Debugger::SendUpdateModuleSymsEventAndBlock(Module* pRuntimeModule, AppDoma // -// UnloadModule is called by the Runtime for each module (including shared ones) -// in an AppDomain that is being unloaded, when a debugger is attached. -// In the EE, a module may be domain-neutral and therefore shared across all AppDomains. -// We abstract this detail away in the Debugger and consider each such EE module to correspond -// to multiple "Debugger Module" instances (one per AppDomain). -// Therefore, this doesn't necessarily mean the runtime is unloading the module, just -// that the Debugger should consider it's (per-AppDomain) DebuggerModule to be unloaded. +// UnloadModule is called by the Runtime for each module that is being unloaded, when a debugger is attached. // -void Debugger::UnloadModule(Module* pRuntimeModule, - AppDomain *pAppDomain) +void Debugger::UnloadModule(Module* pRuntimeModule) { CONTRACTL { @@ -9577,23 +9553,19 @@ void Debugger::UnloadModule(Module* pRuntimeModule, if (CORDBUnrecoverableError(this)) return; - - - LOG((LF_CORDB, LL_INFO100, "D::UM: unload module Mod:%#08x AD:%#08x runtimeMod:%#08x modName:%s\n", - LookupOrCreateModule(pRuntimeModule, pAppDomain), pAppDomain, pRuntimeModule, pRuntimeModule->GetDebugName())); - + LOG((LF_CORDB, LL_INFO100, "D::UM: unload module Mod:%#08x runtimeMod:%#08x modName:%s\n", + LookupOrCreateModule(pRuntimeModule), pRuntimeModule, pRuntimeModule->GetDebugName())); Thread *thread = g_pEEInterface->GetThread(); SENDIPCEVENT_BEGIN(this, thread); if (CORDebuggerAttached()) { - - DebuggerModule* module = LookupOrCreateModule(pRuntimeModule, pAppDomain); + DebuggerModule* module = LookupOrCreateModule(pRuntimeModule); if (module == NULL) { - LOG((LF_CORDB, LL_INFO100, "D::UM: module already unloaded AD:%#08x runtimeMod:%#08x modName:%s\n", - pAppDomain, pRuntimeModule, pRuntimeModule->GetDebugName())); + LOG((LF_CORDB, LL_INFO100, "D::UM: module already unloaded runtimeMod:%#08x modName:%s\n", + pRuntimeModule, pRuntimeModule->GetDebugName())); goto LExit; } _ASSERTE(module != NULL); @@ -9603,13 +9575,9 @@ void Debugger::UnloadModule(Module* pRuntimeModule, pRuntimeModule, pRuntimeModule->GetDomainAssembly(), false, module, module->GetRuntimeModule(), module->GetDomainAssembly()); - // Note: the appdomain the module was loaded in must match the appdomain we're unloading it from. If it doesn't, - // then we've either found the wrong DebuggerModule in LookupModule or we were passed bad data. - _ASSERTE(module->GetAppDomain() == pAppDomain); - // Send the unload module event to the Right Side. DebuggerIPCEvent* ipce = m_pRCThread->GetIPCEventSendBuffer(); - InitIPCEvent(ipce, DB_IPCE_UNLOAD_MODULE, thread, pAppDomain); + InitIPCEvent(ipce, DB_IPCE_UNLOAD_MODULE, thread, AppDomain::GetCurrentDomain()); ipce->UnloadModuleData.vmDomainAssembly.SetRawPtr((module ? module->GetDomainAssembly() : NULL)); ipce->UnloadModuleData.debuggerAssemblyToken.Set(pRuntimeModule->GetClassLoader()->GetAssembly()); m_pRCThread->SendIPCEvent(); @@ -9651,7 +9619,7 @@ void Debugger::UnloadModule(Module* pRuntimeModule, if (m_pModules != NULL) { DebuggerDataLockHolder chInfo(this); - m_pModules->RemoveModule(pRuntimeModule, pAppDomain); + m_pModules->RemoveModule(pRuntimeModule); } // Stop all Runtime threads @@ -9851,7 +9819,7 @@ BOOL Debugger::SendSystemClassLoadUnloadEvent(mdTypeDef classMetadataToken, if (classModule->GetDomainAssembly() != NULL ) { // Find the Left Side module that this class belongs in. - DebuggerModule* pModule = LookupOrCreateModule(classModule, pAppDomain); + DebuggerModule* pModule = LookupOrCreateModule(classModule); _ASSERTE(pModule != NULL); // Only send a class load event if they're enabled for this module. @@ -9906,7 +9874,7 @@ BOOL Debugger::LoadClass(TypeHandle th, // events for each that contain this assembly. LOG((LF_CORDB, LL_INFO10000, "D::LC: load class Tok:%#08x Mod:%#08x AD:%#08x classMod:%#08x modName:%s\n", - classMetadataToken, (pAppDomain == NULL) ? NULL : LookupOrCreateModule(classModule, pAppDomain), + classMetadataToken, (pAppDomain == NULL) ? NULL : LookupOrCreateModule(classModule), pAppDomain, classModule, classModule->GetDebugName())); // @@ -9961,10 +9929,10 @@ void Debugger::UnloadClass(mdTypeDef classMetadataToken, } LOG((LF_CORDB, LL_INFO10000, "D::UC: unload class Tok:0x%08x Mod:%#08x AD:%#08x runtimeMod:%#08x modName:%s\n", - classMetadataToken, LookupOrCreateModule(classModule, pAppDomain), pAppDomain, classModule, classModule->GetDebugName())); + classMetadataToken, LookupOrCreateModule(classModule), pAppDomain, classModule, classModule->GetDebugName())); Assembly *pAssembly = classModule->GetClassLoader()->GetAssembly(); - DebuggerModule *pModule = LookupOrCreateModule(classModule, pAppDomain); + DebuggerModule *pModule = LookupOrCreateModule(classModule); if ((pModule == NULL) || !pModule->ClassLoadCallbacksEnabled()) { @@ -10025,7 +9993,6 @@ void Debugger::FuncEvalComplete(Thread* pThread, DebuggerEval *pDE) // because we can't prove that the AppDomain* would be valid (not unloaded). // AppDomain *pDomain = AppDomain::GetCurrentDomain(); - AppDomain *pResultDomain = ((pDE->m_debuggerModule == NULL) ? pDomain : pDE->m_debuggerModule->GetAppDomain()); // Send a func eval complete event to the Right Side. DebuggerIPCEvent* ipce = m_pRCThread->GetIPCEventSendBuffer(); @@ -10035,13 +10002,13 @@ void Debugger::FuncEvalComplete(Thread* pThread, DebuggerEval *pDE) ipce->FuncEvalComplete.successful = pDE->m_successful; ipce->FuncEvalComplete.aborted = pDE->m_aborted; ipce->FuncEvalComplete.resultAddr = pDE->m_result; - ipce->FuncEvalComplete.vmAppDomain.SetRawPtr(pResultDomain); + ipce->FuncEvalComplete.vmAppDomain.SetRawPtr(pDomain); ipce->FuncEvalComplete.vmObjectHandle = pDE->m_vmObjectHandle; LOG((LF_CORDB, LL_INFO1000, "D::FEC: TypeHandle is %p\n", pDE->m_resultType.AsPtr())); Debugger::TypeHandleToExpandedTypeInfo(pDE->m_retValueBoxing, // whether return values get boxed or not depends on the particular FuncEval we're doing... - pResultDomain, + pDomain, pDE->m_resultType, &ipce->FuncEvalComplete.resultType); @@ -11799,7 +11766,7 @@ void Debugger::TypeHandleToBasicTypeInfo(AppDomain *pAppDomain, TypeHandle th, D res->vmTypeHandle = th.HasInstantiation() ? WrapTypeHandle(th) : VMPTR_TypeHandle::NullPtr(); // only set if instantiated res->metadataToken = th.GetCl(); - DebuggerModule * pDModule = LookupOrCreateModule(th.GetModule(), pAppDomain); + DebuggerModule * pDModule = LookupOrCreateModule(th.GetModule()); res->vmDomainAssembly.SetRawPtr((pDModule ? pDModule->GetDomainAssembly() : NULL)); break; } @@ -11878,7 +11845,7 @@ void Debugger::TypeHandleToExpandedTypeInfo(AreValueTypesBoxed boxed, treatAllValuesAsBoxed: res->ClassTypeData.typeHandle = th.HasInstantiation() ? WrapTypeHandle(th) : VMPTR_TypeHandle::NullPtr(); // only set if instantiated res->ClassTypeData.metadataToken = th.GetCl(); - DebuggerModule * pModule = LookupOrCreateModule(th.GetModule(), pAppDomain); + DebuggerModule * pModule = LookupOrCreateModule(th.GetModule()); res->ClassTypeData.vmDomainAssembly.SetRawPtr((pModule ? pModule->GetDomainAssembly() : NULL)); _ASSERTE(!res->ClassTypeData.vmDomainAssembly.IsNull()); break; @@ -12322,12 +12289,12 @@ HRESULT Debugger::DeoptimizeMethod(Module* pModule, mdMethodDef methodDef) } // Now deoptimize anything that has inlined it in a R2R method - AppDomain::AssemblyIterator domainAssemblyIterator = SystemDomain::System()->DefaultDomain()->IterateAssembliesEx((AssemblyIterationFlags) (kIncludeLoaded | kIncludeExecution)); - CollectibleAssemblyHolder pDomainAssembly; + AppDomain::AssemblyIterator assemblyIterator = SystemDomain::System()->DefaultDomain()->IterateAssembliesEx((AssemblyIterationFlags) (kIncludeLoaded | kIncludeExecution)); + CollectibleAssemblyHolder pAssembly; NativeImageInliningIterator inlinerIter; - while (domainAssemblyIterator.Next(pDomainAssembly.This())) + while (assemblyIterator.Next(pAssembly.This())) { - Module *pCandidateModule = pDomainAssembly->GetModule(); + Module *pCandidateModule = pAssembly->GetModule(); if (pCandidateModule->HasReadyToRunInlineTrackingMap()) { inlinerIter.Reset(pCandidateModule, MethodInModule(pModule, methodDef)); diff --git a/src/coreclr/debug/ee/debugger.h b/src/coreclr/debug/ee/debugger.h index 48f0e23e622..cd911f7a377 100644 --- a/src/coreclr/debug/ee/debugger.h +++ b/src/coreclr/debug/ee/debugger.h @@ -451,7 +451,7 @@ typedef DPTR(class DebuggerModule) PTR_DebuggerModule; class DebuggerModule { public: - DebuggerModule(Module * pRuntimeModule, DomainAssembly * pDomainAssembly, AppDomain * pAppDomain); + DebuggerModule(Module * pRuntimeModule, DomainAssembly * pDomainAssembly); // Do we have any optimized code in the module? // JMC-probes aren't emitted in optimized code, @@ -465,61 +465,27 @@ class DebuggerModule BOOL ClassLoadCallbacksEnabled(void); void EnableClassLoadCallbacks(BOOL f); - AppDomain* GetAppDomain(); - Module * GetRuntimeModule(); - - // (8/12/2002) - // Currently we create a new DebuggerModules for each appdomain a shared - // module lives in. We then pretend there aren't any shared modules. - // This is bad. We need to move away from this. - // Once we stop lying, then every module will be it's own PrimaryModule. :) - // - // Currently, Module* is 1:n w/ DebuggerModule. - // We add a notion of PrimaryModule so that: - // Module* is 1:1 w/ DebuggerModule::GetPrimaryModule(); - // This should help transition towards exposing shared modules. - // If the Runtime module is shared, then this gives a common DM. - // If the runtime module is not shared, then this is an identity function. - // - // The runtime has the notion of "DomainAssembly", which is 1:1 with DebuggerModule - // and thus 1:1 with CordbModule. The CordbModule hash table on the RS now uses - // the DomainAssembly as the key instead of DebuggerModule. This is a temporary - // workaround to facilitate the removal of DebuggerModule. - // - DebuggerModule * GetPrimaryModule(); DomainAssembly * GetDomainAssembly() { LIMITED_METHOD_DAC_CONTRACT; return m_pRuntimeDomainAssembly; } - // Called by DebuggerModuleTable to set our primary module - void SetPrimaryModule(DebuggerModule * pPrimary); - void SetCanChangeJitFlags(bool fCanChangeJitFlags); private: BOOL m_enableClassLoadCallbacks; - // First step in moving away from hiding shared modules. - DebuggerModule* m_pPrimaryModule; - PTR_Module m_pRuntimeModule; PTR_DomainAssembly m_pRuntimeDomainAssembly; - AppDomain* m_pAppDomain; - bool m_fHasOptimizedCode; - void PickPrimaryModule(); - // Can we change jit flags on the module? // This is true during the Module creation bool m_fCanChangeJitFlags; - - }; /* ------------------------------------------------------------------------ * @@ -1109,12 +1075,13 @@ class DebuggerMethodInfo // correct IL offset if this code happens to be instrumented ULONG32 TranslateToInstIL(const InstrumentedILOffsetMapping * pMapping, ULONG32 offOrig, bool fOrigToInst); - +private: // We don't always have a debugger module. (Ex: we're tracking debug info, // but no debugger's attached). So this may return NULL alot. // If we can, we should use the RuntimeModule when ever possible. - DebuggerModule* GetPrimaryModule(); + DebuggerModule* GetModule(); +public: // We always have a runtime module. Module * GetRuntimeModule(); @@ -2016,14 +1983,11 @@ class Debugger : public DebugInterface LPCWSTR pszModuleName, DWORD dwModuleName, Assembly *pAssembly, - AppDomain *pAppDomain, DomainAssembly * pDomainAssembly, BOOL fAttaching); DebuggerModule * AddDebuggerModule(DomainAssembly * pDomainAssembly); - - void UnloadModule(Module* pRuntimeModule, - AppDomain *pAppDomain); + void UnloadModule(Module* pRuntimeModule); void DestructModule(Module *pModule); void RemoveModuleReferences(Module * pModule); @@ -2197,7 +2161,7 @@ class Debugger : public DebugInterface DebuggerModule * LookupOrCreateModule(VMPTR_DomainAssembly vmDomainAssembly); DebuggerModule * LookupOrCreateModule(DomainAssembly * pDomainAssembly); - DebuggerModule * LookupOrCreateModule(Module * pModule, AppDomain * pAppDomain); + DebuggerModule * LookupOrCreateModule(Module * pModule); HRESULT GetAndSendInterceptCommand(DebuggerIPCEvent *event); @@ -3366,24 +3330,15 @@ class DebuggerModuleTable : private CHashTableAndData void AddModule(DebuggerModule *module); - void RemoveModule(Module* module, AppDomain *pAppDomain); - + void RemoveModule(Module* module); void Clear(); - // - // RemoveModules removes any module loaded into the given appdomain from the hash. This is used when we send an - // ExitAppdomain event to ensure that there are no leftover modules in the hash. This can happen when we have shared - // modules that aren't properly accounted for in the CLR. We miss sending UnloadModule events for those modules, so - // we clean them up with this method. - // - void RemoveModules(AppDomain *pAppDomain); #endif // #ifndef DACCESS_COMPILE DebuggerModule *GetModule(Module* module); // We should never look for a NULL Module * - DebuggerModule *GetModule(Module* module, AppDomain* pAppDomain); DebuggerModule *GetFirstModule(HASHFIND *info); DebuggerModule *GetNextModule(HASHFIND *info); }; diff --git a/src/coreclr/debug/ee/debugger.inl b/src/coreclr/debug/ee/debugger.inl index fa613cc625e..7d1ad99c518 100644 --- a/src/coreclr/debug/ee/debugger.inl +++ b/src/coreclr/debug/ee/debugger.inl @@ -52,21 +52,13 @@ inline DebuggerModuleTable * Debugger::GetModuleTable() // @dbgtodo inspection - get rid of this entire class as we move things out-of-proc. //----------------------------------------------------------------------------- inline DebuggerModule::DebuggerModule(Module * pRuntimeModule, - DomainAssembly * pDomainAssembly, - AppDomain * pAppDomain) : + DomainAssembly * pDomainAssembly) : m_enableClassLoadCallbacks(FALSE), - m_pPrimaryModule(NULL), m_pRuntimeModule(pRuntimeModule), - m_pRuntimeDomainAssembly(pDomainAssembly), - m_pAppDomain(pAppDomain) + m_pRuntimeDomainAssembly(pDomainAssembly) { - LOG((LF_CORDB,LL_INFO10000, "DM::DM this:0x%x Module:0x%x DF:0x%x AD:0x%x\n", - this, pRuntimeModule, pDomainAssembly, pAppDomain)); - - // Pick a primary module. - // Arguably, this could be in DebuggerModuleTable::AddModule - PickPrimaryModule(); - + LOG((LF_CORDB,LL_INFO10000, "DM::DM this:0x%x Module:0x%x DF:0x%x\n", + this, pRuntimeModule, pDomainAssembly)); // Do we have any optimized code? DWORD dwDebugBits = pRuntimeModule->GetDebuggerInfoBits(); @@ -90,7 +82,7 @@ inline DebuggerModule::DebuggerModule(Module * pRuntimeModule, inline bool DebuggerModule::HasAnyOptimizedCode() { LIMITED_METHOD_CONTRACT; - Module * pModule = this->GetPrimaryModule()->GetRuntimeModule(); + Module * pModule = GetRuntimeModule(); DWORD dwDebugBits = pModule->GetDebuggerInfoBits(); return CORDebuggerAllowJITOpts(dwDebugBits); } @@ -125,14 +117,6 @@ inline void DebuggerModule::EnableClassLoadCallbacks(BOOL f) } } -//----------------------------------------------------------------------------- -// Return the appdomain that this module exists in. -//----------------------------------------------------------------------------- -inline AppDomain* DebuggerModule::GetAppDomain() -{ - return m_pAppDomain; -} - //----------------------------------------------------------------------------- // Return the EE module that this module corresponds to. //----------------------------------------------------------------------------- @@ -142,40 +126,6 @@ inline Module * DebuggerModule::GetRuntimeModule() return m_pRuntimeModule; } -//----------------------------------------------------------------------------- -// (8/12/2002) -// Currently we create a new DebuggerModules for each appdomain a shared -// module lives in. We then pretend there aren't any shared modules. -// This is bad. We need to move away from this. -// Once we stop lying, then every module will be it's own PrimaryModule. :) -// -// Currently, Module* is 1:n w/ DebuggerModule. -// We add a notion of PrimaryModule so that: -// Module* is 1:1 w/ DebuggerModule::GetPrimaryModule(); -// This should help transition towards exposing shared modules. -// If the Runtime module is shared, then this gives a common DM. -// If the runtime module is not shared, then this is an identity function. -// -//----------------------------------------------------------------------------- -inline DebuggerModule * DebuggerModule::GetPrimaryModule() -{ - _ASSERTE(m_pPrimaryModule != NULL); - return m_pPrimaryModule; -} - -//----------------------------------------------------------------------------- -// This is called by DebuggerModuleTable to set our primary module. -//----------------------------------------------------------------------------- -inline void DebuggerModule::SetPrimaryModule(DebuggerModule * pPrimary) -{ - _ASSERTE(pPrimary != NULL); - // Our primary module must by definition refer to the same runtime module as us - _ASSERTE(pPrimary->GetRuntimeModule() == this->GetRuntimeModule()); - - LOG((LF_CORDB, LL_EVERYTHING, "DM::SetPrimaryModule - this=%p, pPrimary=%p\n", this, pPrimary)); - m_pPrimaryModule = pPrimary; -} - inline DebuggerEval * FuncEvalFrame::GetDebuggerEval() { LIMITED_METHOD_DAC_CONTRACT; diff --git a/src/coreclr/debug/ee/debuggermodule.cpp b/src/coreclr/debug/ee/debuggermodule.cpp index 06b7c7b7f14..688174b806f 100644 --- a/src/coreclr/debug/ee/debuggermodule.cpp +++ b/src/coreclr/debug/ee/debuggermodule.cpp @@ -22,69 +22,6 @@ * Debugger Module routines * ------------------------------------------------------------------------ */ -// (8/12/2002) -// We need to stop lying to the debugger about not sharing Modules. -// Primary Modules allow a transition to that. Once we stop lying, -// then all modules will be their own Primary. -// -// Select the primary module. -// Primary Modules are selected DebuggerModules that map 1:1 w/ Module*. -// If the runtime module is not shared, then we're our own Primary Module. -// If the Runtime module is shared, the primary module is some specific instance. -// Note that a domain-neutral module can be loaded into multiple domains without -// being loaded into the default domain, and so there is no "primary module" as far -// as the CLR is concerned - we just pick any one and call it primary. -void DebuggerModule::PickPrimaryModule() -{ - CONTRACTL - { - NOTHROW; - GC_NOTRIGGER; - } - CONTRACTL_END; - - Debugger::DebuggerDataLockHolder ch(g_pDebugger); - - LOG((LF_CORDB, LL_INFO100000, "DM::PickPrimaryModule, this=0x%p\n", this)); - - // We're our own primary module, unless something else proves otherwise. - // Note that we should be able to skip all of this if this module is not domain neutral - m_pPrimaryModule = this; - - // This should be thread safe because our creation for the DebuggerModules - // are serialized. - - // Lookup our Runtime Module. If it's already in there, - // then - DebuggerModuleTable * pTable = g_pDebugger->GetModuleTable(); - - // If the table doesn't exist yet, then we must be a primary module. - if (pTable == NULL) - { - LOG((LF_CORDB, LL_INFO100000, "DM::PickPrimaryModule, this=0x%p, table not created yet\n", this)); - return; - } - - // Look through existing module list to find a common primary DebuggerModule - // for the given EE Module. We don't know what order we'll traverse in. - - HASHFIND f; - for (DebuggerModule * m = pTable->GetFirstModule(&f); - m != NULL; - m = pTable->GetNextModule(&f)) - { - - if (m->GetRuntimeModule() == this->GetRuntimeModule()) - { - // Make sure we're picking another primary module. - _ASSERTE(m->GetPrimaryModule() != m); - } - } // end for - - // If we got here, then this instance is a Primary Module. - LOG((LF_CORDB, LL_INFO100000, "DM::PickPrimaryModule, this=%p is first, primary.\n", this)); -} - void DebuggerModule::SetCanChangeJitFlags(bool fCanChangeJitFlags) { m_fCanChangeJitFlags = fCanChangeJitFlags; @@ -118,52 +55,6 @@ bool DebuggerModuleTable::ThreadHoldsLock() } #endif -// -// RemoveModules removes any module loaded into the given appdomain from the hash. This is used when we send an -// ExitAppdomain event to ensure that there are no leftover modules in the hash. This can happen when we have shared -// modules that aren't properly accounted for in the CLR. We miss sending UnloadModule events for those modules, so -// we clean them up with this method. -// -void DebuggerModuleTable::RemoveModules(AppDomain *pAppDomain) -{ - CONTRACTL - { - NOTHROW; - GC_NOTRIGGER; - } - CONTRACTL_END; - - LOG((LF_CORDB, LL_INFO1000, "DMT::RM removing all modules from AD 0x%08x\n", pAppDomain)); - - _ASSERTE(ThreadHoldsLock()); - - HASHFIND hf; - DebuggerModuleEntry *pDME = (DebuggerModuleEntry *) FindFirstEntry(&hf); - - while (pDME != NULL) - { - DebuggerModule *pDM = pDME->module; - - if (pDM->GetAppDomain() == pAppDomain) - { - LOG((LF_CORDB, LL_INFO1000, "DMT::RM removing DebuggerModule 0x%08x\n", pDM)); - - // Defer to the normal logic in RemoveModule for the actual removal. This accurately simulates what - // happens when we process an UnloadModule event. - RemoveModule(pDM->GetRuntimeModule(), pAppDomain); - - // Start back at the first entry since we just modified the hash. - pDME = (DebuggerModuleEntry *) FindFirstEntry(&hf); - } - else - { - pDME = (DebuggerModuleEntry *) FindNextEntry(&hf); - } - } - - LOG((LF_CORDB, LL_INFO1000, "DMT::RM done removing all modules from AD 0x%08x\n", pAppDomain)); -} - void DebuggerModuleTable::Clear() { CONTRACTL @@ -208,8 +99,8 @@ void DebuggerModuleTable::AddModule(DebuggerModule *pModule) _ASSERTE(pModule != NULL); - LOG((LF_CORDB, LL_EVERYTHING, "DMT::AM: DebuggerMod:0x%x Module:0x%x AD:0x%x\n", - pModule, pModule->GetRuntimeModule(), pModule->GetAppDomain())); + LOG((LF_CORDB, LL_EVERYTHING, "DMT::AM: DebuggerMod:0x%x Module:0x%x\n", + pModule, pModule->GetRuntimeModule())); DebuggerModuleEntry * pEntry = (DebuggerModuleEntry *) Add(HASH(pModule->GetRuntimeModule())); if (pEntry == NULL) @@ -218,16 +109,13 @@ void DebuggerModuleTable::AddModule(DebuggerModule *pModule) } pEntry->module = pModule; - - // Don't need to update the primary module since it was set when we created the module. - _ASSERTE(pModule->GetPrimaryModule() != NULL); } //----------------------------------------------------------------------------- // Remove a DebuggerModule from the module table when it gets notified. // This occurs in response to the finalization of an unloaded AssemblyLoadContext. //----------------------------------------------------------------------------- -void DebuggerModuleTable::RemoveModule(Module* pModule, AppDomain *pAppDomain) +void DebuggerModuleTable::RemoveModule(Module* pModule) { CONTRACTL { @@ -236,7 +124,7 @@ void DebuggerModuleTable::RemoveModule(Module* pModule, AppDomain *pAppDomain) } CONTRACTL_END; - LOG((LF_CORDB, LL_INFO1000, "DMT::RM Attempting to remove Module:0x%x AD:0x%x\n", pModule, pAppDomain)); + LOG((LF_CORDB, LL_INFO1000, "DMT::RM Attempting to remove Module:0x%x\n", pModule)); _ASSERTE(ThreadHoldsLock()); _ASSERTE(pModule != NULL); @@ -250,19 +138,19 @@ void DebuggerModuleTable::RemoveModule(Module* pModule, AppDomain *pAppDomain) DebuggerModule *pDM = pDME->module; Module* pRuntimeModule = pDM->GetRuntimeModule(); - if ((pRuntimeModule == pModule) && (pDM->GetAppDomain() == pAppDomain)) + if (pRuntimeModule == pModule) { - LOG((LF_CORDB, LL_INFO1000, "DMT::RM Removing DebuggerMod:0x%x - Module:0x%x DF:0x%x AD:0x%x\n", - pDM, pModule, pDM->GetDomainAssembly(), pAppDomain)); + LOG((LF_CORDB, LL_INFO1000, "DMT::RM Removing DebuggerMod:0x%x - Module:0x%x DF:0x%x\n", + pDM, pModule, pDM->GetDomainAssembly())); TRACE_FREE(pDM); DeleteInteropSafe(pDM); Delete(HASH(pRuntimeModule), (HASHENTRY *) pDME); - _ASSERTE(GetModule(pModule, pAppDomain) == NULL); + _ASSERTE(GetModule(pModule) == NULL); return; } } - LOG((LF_CORDB, LL_INFO1000, "DMT::RM No debugger module found for Module:0x%x AD:0x%x\n", pModule, pAppDomain)); + LOG((LF_CORDB, LL_INFO1000, "DMT::RM No debugger module found for Module:0x%x\n", pModule)); } @@ -288,38 +176,6 @@ DebuggerModule *DebuggerModuleTable::GetModule(Module* module) return entry->module; } -// We should never look for a NULL Module * -DebuggerModule *DebuggerModuleTable::GetModule(Module* module, AppDomain* pAppDomain) -{ - CONTRACTL - { - NOTHROW; - GC_NOTRIGGER; - } - CONTRACTL_END; - - _ASSERTE(module != NULL); - _ASSERTE(ThreadHoldsLock()); - - - HASHFIND findmodule; - DebuggerModuleEntry *moduleentry; - - for (moduleentry = (DebuggerModuleEntry*) FindFirstEntry(&findmodule); - moduleentry != NULL; - moduleentry = (DebuggerModuleEntry*) FindNextEntry(&findmodule)) - { - DebuggerModule *pModule = moduleentry->module; - - if ((pModule->GetRuntimeModule() == module) && - (pModule->GetAppDomain() == pAppDomain)) - return pModule; - } - - // didn't find any match! So return a matching module for any app domain - return NULL; -} - DebuggerModule *DebuggerModuleTable::GetFirstModule(HASHFIND *info) { CONTRACTL diff --git a/src/coreclr/debug/ee/funceval.cpp b/src/coreclr/debug/ee/funceval.cpp index c0ed54095ce..287f6f11e51 100644 --- a/src/coreclr/debug/ee/funceval.cpp +++ b/src/coreclr/debug/ee/funceval.cpp @@ -1690,9 +1690,6 @@ void ResolveFuncEvalGenericArgInfo(DebuggerEval *pDE) } // Find the proper MethodDesc that we need to call. - // Since we're already in the target domain, it can't be unloaded so it's safe to - // use domain specific structures like the Module*. - _ASSERTE( GetAppDomain() == pDE->m_debuggerModule->GetAppDomain() ); pDE->m_md = g_pEEInterface->LoadMethodDef(pDE->m_debuggerModule->GetRuntimeModule(), pDE->m_methodToken, nGenericArgs, diff --git a/src/coreclr/debug/ee/functioninfo.cpp b/src/coreclr/debug/ee/functioninfo.cpp index 96c50bfa84a..cd74c4f1f8b 100644 --- a/src/coreclr/debug/ee/functioninfo.cpp +++ b/src/coreclr/debug/ee/functioninfo.cpp @@ -926,8 +926,6 @@ void DebuggerJitInfo::LazyInitBounds() LOG((LF_CORDB,LL_EVERYTHING, "DJI::LazyInitBounds: this=%p GetBoundariesAndVars success=%s\n", this, (fSuccess ? "true" : "false"))); - // SetBoundaries uses the CodeVersionManager, need to take it now for lock ordering reasons - CodeVersionManager::LockHolder codeVersioningLockHolder; Debugger::DebuggerDataLockHolder debuggerDataLockHolder(g_pDebugger); if (!m_fAttemptInit) @@ -1053,15 +1051,22 @@ void DebuggerJitInfo::SetBoundaries(ULONG32 cMap, ICorDebugInfo::OffsetMapping * // Pick a unique initial value (-10) so that the 1st doesn't accidentally match. int ilPrevOld = -10; - _ASSERTE(CodeVersionManager::IsLockOwnedByCurrentThread()); - InstrumentedILOffsetMapping mapping; ILCodeVersion ilVersion = m_nativeCodeVersion.GetILCodeVersion(); if (!ilVersion.IsDefaultVersion()) { // Did the current rejit provide a map? - const InstrumentedILOffsetMapping *pReJitMap = ilVersion.GetInstrumentedILMap(); + const InstrumentedILOffsetMapping *pReJitMap = NULL; + if (ilVersion.GetRejitState() == ILCodeVersion::kStateActive) + { + pReJitMap = ilVersion.GetInstrumentedILMap(); + } + else + { + _ASSERTE(!"Unexpected rejit state, should be active as there exists a native code version for this IL code version"); + } + if (pReJitMap != NULL) { mapping = *pReJitMap; @@ -1427,7 +1432,7 @@ DebuggerMethodInfo::DebuggerMethodInfo(Module *module, mdMethodDef token) : _ASSERTE(g_pDebugger->HasDebuggerDataLock()); - DebuggerModule * pModule = GetPrimaryModule(); + DebuggerModule * pModule = GetModule(); m_fJMCStatus = false; @@ -1443,9 +1448,9 @@ DebuggerMethodInfo::DebuggerMethodInfo(Module *module, mdMethodDef token) : /****************************************************************************** - * Get the primary debugger module for this DMI. This is 1:1 w/ an EE Module. + * Get the debugger module for this DMI. This is 1:1 w/ an EE Module. ******************************************************************************/ -DebuggerModule* DebuggerMethodInfo::GetPrimaryModule() +DebuggerModule* DebuggerMethodInfo::GetModule() { CONTRACTL { @@ -1473,11 +1478,7 @@ DebuggerModule* DebuggerMethodInfo::GetPrimaryModule() return NULL; } - // Only give back primary modules... - DebuggerModule * p2 = pModule->GetPrimaryModule(); - _ASSERTE(p2 != NULL); - - return p2; + return pModule; } /****************************************************************************** @@ -1607,7 +1608,6 @@ DebuggerJitInfo *DebuggerMethodInfo::FindOrCreateInitAndAddJitInfo(MethodDesc* f if (fd->IsVersionable()) { CodeVersionManager *pCodeVersionManager = fd->GetCodeVersionManager(); - CodeVersionManager::LockHolder codeVersioningLockHolder; nativeCodeVersion = pCodeVersionManager->GetNativeCodeVersion(fd, startAddr); if (nativeCodeVersion.IsNull()) { @@ -2023,8 +2023,8 @@ void DebuggerMethodInfo::CreateDJIsForNativeBlobs(AppDomain * pAppDomain, Method // This also handles the possibility of getting the same methoddesc back from the iterator. // It also lets EnC + generics play nice together (including if an generic method was EnC-ed) LoadedMethodDescIterator it(pAppDomain, m_module, m_token); - CollectibleAssemblyHolder pDomainAssembly; - while (it.Next(pDomainAssembly.This())) + CollectibleAssemblyHolder pAssembly; + while (it.Next(pAssembly.This())) { MethodDesc * pDesc = it.Current(); if (!pDesc->HasNativeCode()) diff --git a/src/coreclr/debug/inc/loongarch64/primitives.h b/src/coreclr/debug/inc/loongarch64/primitives.h index 22c9247589f..cfe46955fe7 100644 --- a/src/coreclr/debug/inc/loongarch64/primitives.h +++ b/src/coreclr/debug/inc/loongarch64/primitives.h @@ -48,6 +48,7 @@ inline CORDB_ADDRESS GetPatchEndAddr(CORDB_ADDRESS patchAddr) constexpr CorDebugRegister g_JITToCorDbgReg[] = { + (CorDebugRegister)(255), REGISTER_LOONGARCH64_RA, REGISTER_LOONGARCH64_TP, REGISTER_LOONGARCH64_SP, diff --git a/src/coreclr/debug/runtimeinfo/contracts.jsonc b/src/coreclr/debug/runtimeinfo/contracts.jsonc index 7ccabcb41dc..499a284cbcd 100644 --- a/src/coreclr/debug/runtimeinfo/contracts.jsonc +++ b/src/coreclr/debug/runtimeinfo/contracts.jsonc @@ -10,6 +10,7 @@ // so to conditionally include contracts, put additional contracts in a separate file { "DacStreams": 1, + "EcmaMetadata" : 1, "Exception": 1, "Loader": 1, "Object": 1, diff --git a/src/coreclr/debug/runtimeinfo/datadescriptor.h b/src/coreclr/debug/runtimeinfo/datadescriptor.h index e301dc57ee2..cb7bb726270 100644 --- a/src/coreclr/debug/runtimeinfo/datadescriptor.h +++ b/src/coreclr/debug/runtimeinfo/datadescriptor.h @@ -220,6 +220,7 @@ CDAC_TYPE_FIELD(Module, /*pointer*/, Flags, cdac_data::Flags) CDAC_TYPE_FIELD(Module, /*pointer*/, LoaderAllocator, cdac_data::LoaderAllocator) CDAC_TYPE_FIELD(Module, /*pointer*/, ThunkHeap, cdac_data::ThunkHeap) CDAC_TYPE_FIELD(Module, /*pointer*/, DynamicMetadata, cdac_data::DynamicMetadata) +CDAC_TYPE_FIELD(Module, /*pointer*/, Path, cdac_data::Path) CDAC_TYPE_FIELD(Module, /*pointer*/, FieldDefToDescMap, cdac_data::FieldDefToDescMap) CDAC_TYPE_FIELD(Module, /*pointer*/, ManifestModuleReferencesMap, cdac_data::ManifestModuleReferencesMap) @@ -227,8 +228,13 @@ CDAC_TYPE_FIELD(Module, /*pointer*/, MemberRefToDescMap, cdac_data::Memb CDAC_TYPE_FIELD(Module, /*pointer*/, MethodDefToDescMap, cdac_data::MethodDefToDescMap) CDAC_TYPE_FIELD(Module, /*pointer*/, TypeDefToMethodTableMap, cdac_data::TypeDefToMethodTableMap) CDAC_TYPE_FIELD(Module, /*pointer*/, TypeRefToMethodTableMap, cdac_data::TypeRefToMethodTableMap) +CDAC_TYPE_FIELD(Module, /*pointer*/, MethodDefToILCodeVersioningStateMap, cdac_data::MethodDefToILCodeVersioningStateMap) CDAC_TYPE_END(Module) +CDAC_TYPE_BEGIN(ModuleLookupMap) +CDAC_TYPE_FIELD(ModuleLookupMap, /*pointer*/, TableData, offsetof(LookupMapBase, pTable)) +CDAC_TYPE_END(ModuleLookupMap) + // RuntimeTypeSystem CDAC_TYPE_BEGIN(MethodTable) @@ -260,7 +266,8 @@ CDAC_TYPE_END(ArrayClass) CDAC_TYPE_BEGIN(GenericsDictInfo) CDAC_TYPE_INDETERMINATE(GenericsDictInfo) -CDAC_TYPE_FIELD(GenericsDictInfo, /*uint16*/, NumTypeArgs, cdac_data::NumTypeArgs) +CDAC_TYPE_FIELD(GenericsDictInfo, /*uint16*/, NumDicts, offsetof(GenericsDictInfo, m_wNumDicts)) +CDAC_TYPE_FIELD(GenericsDictInfo, /*uint16*/, NumTypeArgs, offsetof(GenericsDictInfo, m_wNumTyPars)) CDAC_TYPE_END(GenericsDictInfo) CDAC_TYPE_BEGIN(TypeDesc) @@ -284,6 +291,7 @@ CDAC_TYPE_INDETERMINATE(FnPtrTypeDesc) CDAC_TYPE_FIELD(FnPtrTypeDesc, /*uint32*/, NumArgs, cdac_data::NumArgs) CDAC_TYPE_FIELD(FnPtrTypeDesc, /*uint32*/, CallConv, cdac_data::CallConv) CDAC_TYPE_FIELD(FnPtrTypeDesc, /*uint32*/, RetAndArgTypes, cdac_data::RetAndArgTypes) +CDAC_TYPE_FIELD(FnPtrTypeDesc, /*pointer*/, LoaderModule, cdac_data::LoaderModule) CDAC_TYPE_END(FnPtrTypeDesc) CDAC_TYPE_BEGIN(DynamicMetadata) @@ -296,6 +304,7 @@ CDAC_TYPE_INDETERMINATE(MethodDesc) CDAC_TYPE_FIELD(MethodDesc, /*uint8*/, ChunkIndex, cdac_data::ChunkIndex) CDAC_TYPE_FIELD(MethodDesc, /*uint16*/, Slot, cdac_data::Slot) CDAC_TYPE_FIELD(MethodDesc, /*uint16*/, Flags, cdac_data::Flags) +CDAC_TYPE_FIELD(MethodDesc, /*uint16*/, Flags3AndTokenRemainder, cdac_data::Flags3AndTokenRemainder) CDAC_TYPE_END(MethodDesc) CDAC_TYPE_BEGIN(MethodDescChunk) @@ -304,8 +313,28 @@ CDAC_TYPE_FIELD(MethodDescChunk, /*pointer*/, MethodTable, cdac_data::Next) CDAC_TYPE_FIELD(MethodDescChunk, /*uint8*/, Size, cdac_data::Size) CDAC_TYPE_FIELD(MethodDescChunk, /*uint8*/, Count, cdac_data::Count) +CDAC_TYPE_FIELD(MethodDescChunk, /*uint16*/, FlagsAndTokenRange, cdac_data::FlagsAndTokenRange) CDAC_TYPE_END(MethodDescChunk) +CDAC_TYPE_BEGIN(InstantiatedMethodDesc) +CDAC_TYPE_INDETERMINATE(InstantiatedMethodDesc) +CDAC_TYPE_FIELD(InstantiatedMethodDesc, /*pointer*/, PerInstInfo, cdac_data::PerInstInfo) +CDAC_TYPE_FIELD(InstantiatedMethodDesc, /*uint16*/, Flags2, cdac_data::Flags2) +CDAC_TYPE_FIELD(InstantiatedMethodDesc, /*uint16*/, NumGenericArgs, cdac_data::NumGenericArgs) +CDAC_TYPE_END(InstantiatedMethodDesc) + +CDAC_TYPE_BEGIN(StoredSigMethodDesc) +CDAC_TYPE_INDETERMINATE(StoredSigMethodDesc) +CDAC_TYPE_FIELD(StoredSigMethodDesc, /*pointer*/, Sig, cdac_data::Sig) +CDAC_TYPE_FIELD(StoredSigMethodDesc, /*uint32*/, cSig, cdac_data::cSig) +CDAC_TYPE_FIELD(StoredSigMethodDesc, /*uint32*/, ExtendedFlags, cdac_data::ExtendedFlags) +CDAC_TYPE_END(StoredSigMethodDesc) + +CDAC_TYPE_BEGIN(DynamicMethodDesc) +CDAC_TYPE_INDETERMINATE(DynamicMethodDesc) +CDAC_TYPE_FIELD(DynamicMethodDesc, /*pointer*/, MethodName, cdac_data::MethodName) +CDAC_TYPE_END(DynamicMethodDesc) + CDAC_TYPES_END() CDAC_GLOBALS_BEGIN() @@ -313,6 +342,7 @@ CDAC_GLOBAL_POINTER(AppDomain, &AppDomain::m_pTheAppDomain) CDAC_GLOBAL_POINTER(ThreadStore, &ThreadStore::s_pThreadStore) CDAC_GLOBAL_POINTER(FinalizerThread, &::g_pFinalizerThread) CDAC_GLOBAL_POINTER(GCThread, &::g_pSuspensionThread) +CDAC_GLOBAL(MethodDescTokenRemainderBitCount, uint8, METHOD_TOKEN_REMAINDER_BIT_COUNT) #if FEATURE_EH_FUNCLETS CDAC_GLOBAL(FeatureEHFunclets, uint8, 1) #else @@ -330,6 +360,7 @@ CDAC_GLOBAL(ObjectToMethodTableUnmask, uint8, 1 | 1 << 1 | 1 << 2) CDAC_GLOBAL(ObjectToMethodTableUnmask, uint8, 1 | 1 << 1) #endif //TARGET_64BIT CDAC_GLOBAL(SOSBreakingChangeVersion, uint8, SOS_BREAKING_CHANGE_VERSION) +CDAC_GLOBAL(DirectorySeparator, uint8, (uint8_t)DIRECTORY_SEPARATOR_CHAR_A) CDAC_GLOBAL(MethodDescAlignment, uint64, MethodDesc::ALIGNMENT) CDAC_GLOBAL(ObjectHeaderSize, uint64, OBJHEADER_SIZE) CDAC_GLOBAL(SyncBlockValueToObjectOffset, uint16, OBJHEADER_SIZE - cdac_data::SyncBlockValue) diff --git a/src/coreclr/dlls/mscorrc/mscorrc.rc b/src/coreclr/dlls/mscorrc/mscorrc.rc index 2f6d8aae590..1d58a0681b5 100644 --- a/src/coreclr/dlls/mscorrc/mscorrc.rc +++ b/src/coreclr/dlls/mscorrc/mscorrc.rc @@ -431,7 +431,6 @@ BEGIN IDS_EE_RCW_INVALIDCAST_ITF "Unable to cast COM object of type '%2' to interface type '%3'. This operation failed because the QueryInterface call on the COM component for the interface with IID '%4' failed due to the following error: %1." IDS_EE_RCW_INVALIDCAST_EVENTITF "Unable to cast COM object of type '%2' to event interface type '%3'. This operation failed because the QueryInterface call on the COM component for the interface with IID '%4' failed due to the following error: '%1' and the COM component does not support the source interface with IID '%5'." IDS_EE_RCW_INVALIDCAST_IENUMERABLE "Unable to cast COM object of type '%2' to interface type '%3'. This operation failed because the QueryInterface call on the COM component for the interface with IID '%4' failed due to the following error: '%1' and the COM component does not support IDispatch::Invoke calls for DISPID_NEWENUM." - IDS_EE_RCW_INVALIDCAST_MNGSTDITF "Unable to cast COM object of type '%2' to standard managed interface type '%3'. This operation failed because the QueryInterface call on the COM component for the managed interface with IID '%4' failed due to the following error: '%1' and the QueryInterface call for the native interface with IID '%5' that corresponds to this managed interface failed due to the following error: %6." IDS_EE_RCW_INVALIDCAST_COMOBJ_TO_MD "Unable to cast COM object of type '%1' to class type '%2'. COM components that enter the CLR and do not support IProvideClassInfo or that do not have any interop assembly registered will be wrapped in the __ComObject type. Instances of this type cannot be cast to any other class; however they can be cast to interfaces as long as the underlying COM component supports QueryInterface calls for the IID of the interface." IDS_EE_RCW_INVALIDCAST_TO_NON_COMOBJTYPE "Unable to cast COM object of type '%1' to class type '%2'. Instances of types that represent COM components cannot be cast to types that do not represent COM components; however they can be cast to interfaces as long as the underlying COM component supports QueryInterface calls for the IID of the interface." IDS_EE_RCW_INVALIDCAST_MD_TO_MD "Unable to cast COM object of type '%1' to class type '%2'. Instances of types that represent COM components cannot be cast to different types that represent COM components; however they can be cast to interfaces as long as the underlying COM component supports QueryInterface calls for the IID of the interface." @@ -468,8 +467,6 @@ BEGIN IDS_EE_INVALID_CA "Invalid custom attribute provided." - IDS_EE_THREAD_CANNOT_GET "Unable to retrieve thread information." - IDS_EE_THREAD_BAD_STATE "Thread in invalid state." IDS_EE_THREAD_ABORT_WHILE_SUSPEND "Thread is suspended; attempting to abort." IDS_EE_NOVARIANTRETURN "PInvoke restriction: cannot return variants." @@ -488,11 +485,6 @@ BEGIN IDS_EE_CLASS_TO_VARIANT_TLB_NOT_REG "Type '%1' cannot be marshalled to a Variant. Type library is not registered." IDS_EE_CANNOT_MAP_TO_MANAGED_VC "The specified record cannot be mapped to a managed value class." - IDS_EE_SH_IN_VARIANT_NOT_SUPPORTED "SafeHandle derived types cannot be stored in Variants." - - IDS_EE_CH_IN_VARIANT_NOT_SUPPORTED "CriticalHandle derived types cannot be stored in Variants." - - IDS_EE_VAR_WRAP_IN_VAR_NOT_SUPPORTED "VariantWrappers cannot be stored in Variants." IDS_EE_RECORD_NON_SUPPORTED_FIELDS "The structure contains fields that are not supported in unmanaged records." IDS_CLASSLOAD_NSTRUCT_NEGATIVE_OFFSET "Could not load type '%1' from assembly '%2' because field '%3' was given a negative offset." diff --git a/src/coreclr/dlls/mscorrc/resource.h b/src/coreclr/dlls/mscorrc/resource.h index 24e82ff5afb..964cb712832 100644 --- a/src/coreclr/dlls/mscorrc/resource.h +++ b/src/coreclr/dlls/mscorrc/resource.h @@ -232,8 +232,6 @@ #define IDS_EE_INVALID_CA 0x1a10 -#define IDS_EE_THREAD_CANNOT_GET 0x1a15 -#define IDS_EE_THREAD_BAD_STATE 0x1a1b #define IDS_EE_THREAD_ABORT_WHILE_SUSPEND 0x1a1c #define IDS_EE_NOVARIANTRETURN 0x1a1d @@ -261,10 +259,8 @@ #define IDS_EE_BADMARSHAL_SAFEHANDLE 0x1a3d #define IDS_EE_BADMARSHAL_ABSTRACTRETSAFEHANDLE 0x1a44 -#define IDS_EE_SH_IN_VARIANT_NOT_SUPPORTED 0x1a47 #define IDS_EE_BADMARSHAL_SYSARRAY 0x1a48 -#define IDS_EE_VAR_WRAP_IN_VAR_NOT_SUPPORTED 0x1a49 #define IDS_EE_RECORD_NON_SUPPORTED_FIELDS 0x1a4a #define IDS_CLASSLOAD_TYPEWRONGNUMGENERICARGS 0x1a4b @@ -282,7 +278,6 @@ #define IDS_EE_BADMARSHAL_INT128_RESTRICTION 0x1a66 #define IDS_EE_BADMARSHAL_ABSTRACTRETCRITICALHANDLE 0x1a6a -#define IDS_EE_CH_IN_VARIANT_NOT_SUPPORTED 0x1a6b #define IDS_CLASSLOAD_CONSTRAINT_MISMATCH_ON_IMPLICIT_OVERRIDE 0x1a6f #define IDS_CLASSLOAD_CONSTRAINT_MISMATCH_ON_IMPLICIT_IMPLEMENTATION 0x1a70 @@ -325,7 +320,7 @@ #define IDS_EE_RCW_INVALIDCAST_ITF 0x1a9b #define IDS_EE_RCW_INVALIDCAST_EVENTITF 0x1a9c #define IDS_EE_RCW_INVALIDCAST_IENUMERABLE 0x1a9d -#define IDS_EE_RCW_INVALIDCAST_MNGSTDITF 0x1a9e + #define IDS_EE_RCW_INVALIDCAST_COMOBJ_TO_MD 0x1a9f #define IDS_EE_RCW_INVALIDCAST_TO_NON_COMOBJTYPE 0x1aa0 #define IDS_EE_RCW_INVALIDCAST_MD_TO_MD 0x1aa1 diff --git a/src/coreclr/gc/gc.cpp b/src/coreclr/gc/gc.cpp index 1a316a9b9cf..68f543f47f5 100644 --- a/src/coreclr/gc/gc.cpp +++ b/src/coreclr/gc/gc.cpp @@ -16,6 +16,43 @@ // allocation helpers in gcscan.cpp // +#include "common.h" +#include "gcenv.h" + +#include "gc.h" +#include "gcscan.h" +#include "gcdesc.h" +#include "softwarewritewatch.h" +#include "handletable.h" +#include "handletable.inl" +#include "gcenv.inl" +#include "gceventstatus.h" + +#ifdef __INTELLISENSE__ +#if defined(FEATURE_SVR_GC) + +#define SERVER_GC 1 + +#else // defined(FEATURE_SVR_GC) + +#ifdef SERVER_GC +#undef SERVER_GC +#endif + +#endif // defined(FEATURE_SVR_GC) +#endif // __INTELLISENSE__ + +#ifdef TARGET_AMD64 +#include "vxsort/do_vxsort.h" +#endif + +#ifdef SERVER_GC +namespace SVR { +#else // SERVER_GC +namespace WKS { +#endif // SERVER_GC + +#include "gcimpl.h" #include "gcpriv.h" #ifdef TARGET_AMD64 @@ -746,6 +783,12 @@ class t_join return join_struct.n_threads; } + // This is for instrumentation only. + int get_join_lock() + { + return VolatileLoadWithoutBarrier (&join_struct.join_lock); + } + void destroy () { dprintf (JOIN_LOG, ("Destroying join structure")); @@ -2375,19 +2418,36 @@ int gc_heap::conserve_mem_setting = 0; bool gc_heap::spin_count_unit_config_p = false; uint64_t gc_heap::suspended_start_time = 0; -uint64_t gc_heap::change_heap_count_time = 0; uint64_t gc_heap::end_gc_time = 0; uint64_t gc_heap::total_suspended_time = 0; uint64_t gc_heap::process_start_time = 0; last_recorded_gc_info gc_heap::last_ephemeral_gc_info; last_recorded_gc_info gc_heap::last_full_blocking_gc_info; +uint64_t gc_heap::last_alloc_reset_suspended_end_time = 0; +size_t gc_heap::max_peak_heap_size = 0; +VOLATILE(size_t) gc_heap::llc_size = 0; + #ifdef BACKGROUND_GC last_recorded_gc_info gc_heap::last_bgc_info[2]; VOLATILE(bool) gc_heap::is_last_recorded_bgc = false; VOLATILE(int) gc_heap::last_bgc_info_index = 0; #endif //BACKGROUND_GC +#ifdef DYNAMIC_HEAP_COUNT +size_t gc_heap::hc_change_cancelled_count_prep = 0; +#ifdef BACKGROUND_GC +int gc_heap::bgc_th_creation_hist_index = 0; +gc_heap::bgc_thread_creation_history gc_heap::bgc_th_creation_hist[max_bgc_thread_creation_count]; +size_t gc_heap::bgc_th_count_created = 0; +size_t gc_heap::bgc_th_count_created_th_existed = 0; +size_t gc_heap::bgc_th_count_creation_failed = 0; +size_t gc_heap::bgc_init_gc_index = 0; +VOLATILE(short) gc_heap::bgc_init_n_heaps = 0; +size_t gc_heap::hc_change_cancelled_count_bgc = 0; +#endif //BACKGROUND_GC +#endif //DYNAMIC_HEAP_COUNT + #if defined(HOST_64BIT) #define MAX_ALLOWED_MEM_LOAD 85 @@ -2858,7 +2918,16 @@ int gc_heap::dynamic_adaptation_mode = dynamic_adaptation_default; gc_heap::dynamic_heap_count_data_t SVR::gc_heap::dynamic_heap_count_data; size_t gc_heap::current_total_soh_stable_size = 0; uint64_t gc_heap::last_suspended_end_time = 0; +uint64_t gc_heap::change_heap_count_time = 0; +uint64_t gc_heap::total_change_heap_count = 0; +uint64_t gc_heap::total_change_heap_count_time = 0; size_t gc_heap::gc_index_full_gc_end = 0; +uint64_t gc_heap::before_distribute_free_regions_time = 0; +bool gc_heap::trigger_initial_gen2_p = false; + +#ifdef BACKGROUND_GC +bool gc_heap::trigger_bgc_for_rethreading_p = false; +#endif //BACKGROUND_GC #ifdef STRESS_DYNAMIC_HEAP_COUNT int gc_heap::heaps_in_this_gc = 0; @@ -3220,7 +3289,7 @@ void gc_heap::fire_pevents() // because EE is not suspended then. On entry it's fired after the GCStart event, on exit it's fire before the GCStop event. void gc_heap::fire_committed_usage_event() { -#if defined(FEATURE_EVENT_TRACE) && defined(USE_REGIONS) +#ifdef FEATURE_EVENT_TRACE if (!EVENT_ENABLED (GCMarkWithType)) return; size_t total_committed = 0; @@ -3235,9 +3304,18 @@ void gc_heap::fire_committed_usage_event() new_committed_by_oh); size_t total_committed_in_use = new_committed_by_oh[soh] + new_committed_by_oh[loh] + new_committed_by_oh[poh]; +#ifdef USE_REGIONS size_t total_committed_in_global_decommit = committed_decommit; size_t total_committed_in_free = committed_free; size_t total_committed_in_global_free = new_committed_by_oh[recorded_committed_free_bucket] - total_committed_in_free - total_committed_in_global_decommit; +#else + assert (committed_decommit == 0); + assert (committed_free == 0); + size_t total_committed_in_global_decommit = 0; + size_t total_committed_in_free = 0; + size_t total_committed_in_global_free = 0; + // For segments, bookkeeping committed does not include mark array +#endif //USE_REGIONS size_t total_bookkeeping_committed = committed_bookkeeping; GCEventFireCommittedUsage_V1 ( @@ -3247,7 +3325,7 @@ void gc_heap::fire_committed_usage_event() (uint64_t)total_committed_in_global_free, (uint64_t)total_bookkeeping_committed ); -#endif //FEATURE_EVENT_TRACE && USE_REGIONS +#endif //FEATURE_EVENT_TRACE } inline BOOL @@ -3309,8 +3387,11 @@ gc_heap::dt_high_frag_p (gc_tuning_point tp, if (elevate_p) { ret = (dd_fragmentation (dynamic_data_of (max_generation)) >= dd_max_size(dd)); - dprintf (GTC_LOG, ("h%d: frag is %zd, max size is %zd", - heap_number, dd_fragmentation (dd), dd_max_size(dd))); + if (ret) + { + dprintf (6666, ("h%d: frag is %zd, max size is %zd", + heap_number, dd_fragmentation (dd), dd_max_size(dd))); + } } else { @@ -3326,7 +3407,7 @@ gc_heap::dt_high_frag_p (gc_tuning_point tp, } } #endif //!MULTIPLE_HEAPS - size_t fr = generation_unusable_fragmentation (generation_of (gen_number)); + size_t fr = generation_unusable_fragmentation (generation_of (gen_number), heap_number); ret = (fr > dd_fragmentation_limit(dd)); if (ret) { @@ -3334,10 +3415,13 @@ gc_heap::dt_high_frag_p (gc_tuning_point tp, fragmentation_burden = (gen_size ? ((float)fr / (float)gen_size) : 0.0f); ret = (fragmentation_burden > dd_v_fragmentation_burden_limit (dd)); } - dprintf (GTC_LOG, ("h%d: gen%d, frag is %zd, alloc effi: %zu%%, unusable frag is %zd, ratio is %d", - heap_number, gen_number, dd_fragmentation (dd), - generation_allocator_efficiency_percent (generation_of (gen_number)), - fr, (int)(fragmentation_burden*100))); + if (ret) + { + dprintf (6666, ("h%d: gen%d, frag is %zd, alloc effi: %zu%%, unusable frag is %zd, ratio is %d", + heap_number, gen_number, dd_fragmentation (dd), + generation_allocator_efficiency_percent (generation_of (gen_number)), + fr, (int)(fragmentation_burden * 100))); + } } break; } @@ -3419,7 +3503,7 @@ gc_heap::dt_estimate_high_frag_p (gc_tuning_point tp, int gen_number, uint64_t a gen_number, dd_current_size (dd), dd_fragmentation (dd), - (int)(est_frag_ratio*100), + (int)(est_frag_ratio * 100), est_frag)); uint32_t num_heaps = 1; @@ -6984,8 +7068,21 @@ void gc_heap::gc_thread_function () while (1) { - // inactive GC threads may observe gc_t_join.joined() being true here - assert ((n_heaps <= heap_number) || !gc_t_join.joined()); +#ifdef DYNAMIC_HEAP_COUNT + if (gc_heap::dynamic_adaptation_mode == dynamic_adaptation_to_application_sizes) + { + // Inactive GC threads may observe gc_t_join.joined() being true here. + // Before the 1st GC happens, h0's GC thread can also observe gc_t_join.joined() being true because it's + // also inactive as the main thread (that inits the GC) will act as h0 (to call change_heap_count). + assert (((heap_number == 0) && (VolatileLoadWithoutBarrier (&settings.gc_index) == 0)) || + (n_heaps <= heap_number) || + !gc_t_join.joined()); + } + else +#endif //DYNAMIC_HEAP_COUNT + { + assert (!gc_t_join.joined()); + } if (heap_number == 0) { @@ -7025,6 +7122,7 @@ void gc_heap::gc_thread_function () #endif //BACKGROUND_GC { dprintf (6666, ("changing heap count due to timeout")); + add_to_hc_history (hc_record_before_check_timeout); check_heap_count(); } } @@ -7053,6 +7151,7 @@ void gc_heap::gc_thread_function () { // this was a request to do a GC so make sure we follow through with one. dprintf (6666, ("changing heap count at a GC start")); + add_to_hc_history (hc_record_before_check_gc_start); check_heap_count (); } } @@ -7072,6 +7171,8 @@ void gc_heap::gc_thread_function () VolatileLoadWithoutBarrier (&dynamic_heap_count_data.idle_thread_count))); } + add_to_hc_history (hc_record_set_last_heaps); + dynamic_heap_count_data.last_n_heaps = n_heaps; } #endif //DYNAMIC_HEAP_COUNT @@ -7135,11 +7236,14 @@ void gc_heap::gc_thread_function () // only that many threads will participate in the following GCs. if (heap_number < new_n_heaps) { + add_to_hc_history (hc_record_still_active); dprintf (9999, ("h%d < %d participating (dec)", heap_number, new_n_heaps)); } else { Interlocked::Increment (&dynamic_heap_count_data.idle_thread_count); + add_to_hc_history (hc_record_became_inactive); + dprintf (9999, ("GC thread %d wait_on_idle(%d < %d)(gc%Id), total idle %d", heap_number, old_n_heaps, new_n_heaps, VolatileLoadWithoutBarrier (&settings.gc_index), VolatileLoadWithoutBarrier (&dynamic_heap_count_data.idle_thread_count))); gc_idle_thread_event.Wait (INFINITE, FALSE); @@ -7148,12 +7252,14 @@ void gc_heap::gc_thread_function () } else { + add_to_hc_history ((heap_number < old_n_heaps) ? hc_record_still_active : hc_record_became_active); dprintf (9999, ("h%d < %d participating (inc)", heap_number, new_n_heaps)); } } else { Interlocked::Increment (&dynamic_heap_count_data.idle_thread_count); + add_to_hc_history (hc_record_inactive_waiting); dprintf (9999, ("GC thread %d wait_on_idle(< max %d)(gc%Id), total idle %d", heap_number, num_threads_to_wake, VolatileLoadWithoutBarrier (&settings.gc_index), VolatileLoadWithoutBarrier (&dynamic_heap_count_data.idle_thread_count))); gc_idle_thread_event.Wait (INFINITE, FALSE); @@ -9579,6 +9685,7 @@ int gc_heap::grow_brick_card_tables (uint8_t* start, #endif //CARD_BUNDLE size_t alloc_size = card_table_element_layout[total_bookkeeping_elements]; + size_t commit_size = 0; uint8_t* mem = (uint8_t*)GCToOSInterface::VirtualReserve (alloc_size, 0, virtual_reserve_flags); if (!mem) @@ -9592,14 +9699,16 @@ int gc_heap::grow_brick_card_tables (uint8_t* start, { // in case of background gc, the mark array will be committed separately (per segment). - size_t commit_size = card_table_element_layout[seg_mapping_table_element + 1]; + commit_size = card_table_element_layout[seg_mapping_table_element + 1]; if (!virtual_commit (mem, commit_size, recorded_committed_bookkeeping_bucket)) { + commit_size = 0; dprintf (GC_TABLE_LOG, ("Table commit failed")); set_fgm_result (fgm_commit_table, commit_size, uoh_p); goto fail; } + } ct = (uint32_t*)(mem + card_table_element_layout[card_table_element]); @@ -9771,6 +9880,7 @@ int gc_heap::grow_brick_card_tables (uint8_t* start, dprintf (GC_TABLE_LOG, ("GCToOSInterface::VirtualRelease failed")); assert (!"release failed"); } + reduce_committed_bytes (mem, commit_size, recorded_committed_bookkeeping_bucket, -1, true); } return -1; @@ -12321,7 +12431,9 @@ void gc_heap::init_heap_segment (heap_segment* seg, gc_heap* hp heap_segment_plan_allocated (seg) = heap_segment_mem (seg); heap_segment_allocated (seg) = heap_segment_mem (seg); heap_segment_saved_allocated (seg) = heap_segment_mem (seg); +#if !defined(USE_REGIONS) || defined(MULTIPLE_HEAPS) heap_segment_decommit_target (seg) = heap_segment_reserved (seg); +#endif //!USE_REGIONS || MULTIPLE_HEAPS #ifdef BACKGROUND_GC heap_segment_background_allocated (seg) = 0; heap_segment_saved_bg_allocated (seg) = 0; @@ -13209,11 +13321,44 @@ void region_free_list::sort_by_committed_and_age() } tail_free_region = prev; } -#endif //USE_REGIONS + +void gc_heap::age_free_regions (const char* msg) +{ + // If we are doing an ephemeral GC as a precursor to a BGC, then we will age all of the region + // kinds during the ephemeral GC and skip the call to age_free_regions during the BGC itself. + bool age_all_region_kinds = (settings.condemned_generation == max_generation) || is_bgc_in_progress(); + if (age_all_region_kinds) + { + global_free_huge_regions.age_free_regions(); + } + +#ifdef MULTIPLE_HEAPS + for (int i = 0; i < n_heaps; i++) + { + gc_heap* hp = g_heaps[i]; +#else //MULTIPLE_HEAPS + { + gc_heap* hp = pGenGCHeap; + const int i = 0; +#endif //MULTIPLE_HEAPS + + if (age_all_region_kinds) + { + // age and print all kinds of free regions + region_free_list::age_free_regions (hp->free_regions); + region_free_list::print (hp->free_regions, i, msg); + } + else + { + // age and print only basic free regions + hp->free_regions[basic_free_region].age_free_regions(); + hp->free_regions[basic_free_region].print (i, msg); + } + } +} void gc_heap::distribute_free_regions() { -#ifdef USE_REGIONS const int kind_count = large_free_region + 1; #ifdef MULTIPLE_HEAPS @@ -13414,86 +13559,25 @@ void gc_heap::distribute_free_regions() num_huge_region_units_to_consider[kind])); // check if the free regions exceed the budget - // if so, put the highest free regions on the decommit list + // if so, consider putting the highest free regions on the decommit list total_num_free_regions[kind] += num_regions_to_decommit[kind]; ptrdiff_t balance = total_num_free_regions[kind] + num_huge_region_units_to_consider[kind] - total_budget_in_region_units[kind]; - // Ignore young huge regions if they are contributing to a surplus. - if (balance > 0) - { - if (balance > static_cast(num_young_huge_region_units_to_consider[kind])) - { - balance -= num_young_huge_region_units_to_consider[kind]; - } - else - { - balance = 0; - } - } - - if ( + // first check if we should decommit any regions + if ((balance > 0) #ifdef BACKGROUND_GC - (background_running_p() && (settings.condemned_generation != max_generation)) || + && (!background_running_p() || (settings.condemned_generation == max_generation)) #endif - (balance < 0)) + ) { - dprintf (REGIONS_LOG, ("distributing the %zd %s regions deficit", -balance, kind_name[kind])); + // ignore young huge regions when determining how much to decommit + num_regions_to_decommit[kind] = + max(static_cast(0), + (balance - static_cast(num_young_huge_region_units_to_consider[kind]))); + + balance -= num_regions_to_decommit[kind]; -#ifdef MULTIPLE_HEAPS - // we may have a deficit or - if background GC is going on - a surplus. - // adjust the budget per heap accordingly - if (balance != 0) - { - ptrdiff_t curr_balance = 0; - ptrdiff_t rem_balance = 0; - for (int i = 0; i < n_heaps; i++) - { - curr_balance += balance; - ptrdiff_t adjustment_per_heap = curr_balance / n_heaps; - curr_balance -= adjustment_per_heap * n_heaps; - ptrdiff_t new_budget = (ptrdiff_t)heap_budget_in_region_units[i][kind] + adjustment_per_heap; - ptrdiff_t min_budget = (kind == basic_free_region) ? (ptrdiff_t)min_heap_budget_in_region_units[i] : 0; - dprintf (REGIONS_LOG, ("adjusting the budget for heap %d from %zd %s regions by %zd to %zd", - i, - heap_budget_in_region_units[i][kind], - kind_name[kind], - adjustment_per_heap, - max (min_budget, new_budget))); - heap_budget_in_region_units[i][kind] = max (min_budget, new_budget); - rem_balance += new_budget - heap_budget_in_region_units[i][kind]; - } - assert (rem_balance <= 0); - dprintf (REGIONS_LOG, ("remaining balance: %zd %s regions", rem_balance, kind_name[kind])); - - // if we have a left over deficit, distribute that to the heaps that still have more than the minimum - while (rem_balance < 0) - { - for (int i = 0; i < n_heaps; i++) - { - size_t min_budget = (kind == basic_free_region) ? min_heap_budget_in_region_units[i] : 0; - if (heap_budget_in_region_units[i][kind] > min_budget) - { - dprintf (REGIONS_LOG, ("adjusting the budget for heap %d from %zd %s regions by %d to %zd", - i, - heap_budget_in_region_units[i][kind], - kind_name[kind], - -1, - heap_budget_in_region_units[i][kind] - 1)); - - heap_budget_in_region_units[i][kind] -= 1; - rem_balance += 1; - if (rem_balance == 0) - break; - } - } - } - } -#endif //MULTIPLE_HEAPS - } - else - { - num_regions_to_decommit[kind] = balance; dprintf(REGIONS_LOG, ("distributing the %zd %s regions, removing %zd regions", total_budget_in_region_units[kind], kind_name[kind], @@ -13527,6 +13611,60 @@ void gc_heap::distribute_free_regions() } } } + +#ifdef MULTIPLE_HEAPS + if (balance != 0) + { + dprintf (REGIONS_LOG, ("distributing the %zd %s regions deficit", -balance, kind_name[kind])); + + // we may have a deficit or - if background GC is going on - a surplus. + // adjust the budget per heap accordingly + + ptrdiff_t curr_balance = 0; + ptrdiff_t rem_balance = 0; + for (int i = 0; i < n_heaps; i++) + { + curr_balance += balance; + ptrdiff_t adjustment_per_heap = curr_balance / n_heaps; + curr_balance -= adjustment_per_heap * n_heaps; + ptrdiff_t new_budget = (ptrdiff_t)heap_budget_in_region_units[i][kind] + adjustment_per_heap; + ptrdiff_t min_budget = (kind == basic_free_region) ? (ptrdiff_t)min_heap_budget_in_region_units[i] : 0; + dprintf (REGIONS_LOG, ("adjusting the budget for heap %d from %zd %s regions by %zd to %zd", + i, + heap_budget_in_region_units[i][kind], + kind_name[kind], + adjustment_per_heap, + max (min_budget, new_budget))); + heap_budget_in_region_units[i][kind] = max (min_budget, new_budget); + rem_balance += new_budget - heap_budget_in_region_units[i][kind]; + } + assert (rem_balance <= 0); + dprintf (REGIONS_LOG, ("remaining balance: %zd %s regions", rem_balance, kind_name[kind])); + + // if we have a left over deficit, distribute that to the heaps that still have more than the minimum + while (rem_balance < 0) + { + for (int i = 0; i < n_heaps; i++) + { + size_t min_budget = (kind == basic_free_region) ? min_heap_budget_in_region_units[i] : 0; + if (heap_budget_in_region_units[i][kind] > min_budget) + { + dprintf (REGIONS_LOG, ("adjusting the budget for heap %d from %zd %s regions by %d to %zd", + i, + heap_budget_in_region_units[i][kind], + kind_name[kind], + -1, + heap_budget_in_region_units[i][kind] - 1)); + + heap_budget_in_region_units[i][kind] -= 1; + rem_balance += 1; + if (rem_balance == 0) + break; + } + } + } + } +#endif } for (int kind = basic_free_region; kind < kind_count; kind++) @@ -13615,45 +13753,8 @@ void gc_heap::distribute_free_regions() } } #endif //MULTIPLE_HEAPS -#endif //USE_REGIONS } - -void gc_heap::age_free_regions(const char* label) -{ -#ifdef USE_REGIONS - // If we are doing an ephemeral GC as a precursor to a BGC, then we will age all of the region - // kinds during the ephemeral GC and skip the call to age_free_regions during the BGC itself. - bool age_all_region_kinds = (settings.condemned_generation == max_generation) || is_bgc_in_progress(); - if (age_all_region_kinds) - { - global_free_huge_regions.age_free_regions(); - } - -#ifdef MULTIPLE_HEAPS - for (int i = 0; i < gc_heap::n_heaps; i++) - { - gc_heap* hp = gc_heap::g_heaps[i]; -#else //MULTIPLE_HEAPS - { - gc_heap* hp = pGenGCHeap; - const int i = 0; -#endif //MULTIPLE_HEAPS - - if (age_all_region_kinds) - { - // age and print all kinds of free regions - region_free_list::age_free_regions (hp->free_regions); - region_free_list::print (hp->free_regions, i, label); - } - else - { - // age and print only basic free regions - hp->free_regions[basic_free_region].age_free_regions(); - hp->free_regions[basic_free_region].print (i, label); - } - } #endif //USE_REGIONS -} #ifdef WRITE_WATCH uint8_t* g_addresses [array_size+2]; // to get around the bug in GetWriteWatch @@ -14718,7 +14819,7 @@ gc_heap::wait_for_gc_done(int32_t timeOut) while (gc_heap::gc_started) { #ifdef MULTIPLE_HEAPS - wait_heap = GCHeap::GetHeap(heap_select::select_heap(NULL))->pGenGCHeap; + wait_heap = g_heaps[heap_select::select_heap(NULL)]; dprintf(2, ("waiting for the gc_done_event on heap %d", wait_heap->heap_number)); #endif // MULTIPLE_HEAPS @@ -14977,6 +15078,14 @@ gc_heap::init_gc_heap (int h_number) gc_done_event_set = false; #ifdef DYNAMIC_HEAP_COUNT + hchist_index_per_heap = 0; + memset (hchist_per_heap, 0, sizeof (hchist_per_heap)); + +#ifdef BACKGROUND_GC + bgc_hchist_index_per_heap = 0; + memset (bgc_hchist_per_heap, 0, sizeof (bgc_hchist_per_heap)); +#endif //BACKGROUND_GC + if (h_number != 0) { if (!gc_idle_thread_event.CreateAutoEventNoThrow (FALSE)) @@ -21031,6 +21140,34 @@ int gc_heap::joined_generation_to_condemn (BOOL should_evaluate_elevation, #endif //STRESS_HEAP #ifdef BACKGROUND_GC +#ifdef DYNAMIC_HEAP_COUNT + if (trigger_bgc_for_rethreading_p) + { + if (background_running_p()) + { + // trigger_bgc_for_rethreading_p being true indicates we did not change gen2 FL items when we changed HC. + // So some heaps could have no FL at all which means if we did a gen1 GC during this BGC we would increase + // gen2 size. We chose to prioritize not increasing gen2 size so we disallow gen1 GCs. + if (n != 0) + { + n = 0; + } + } + else + { + dprintf (6666, ("was going to be g%d %s GC, HC change request this GC to be a BGC unless it's an NGC2", + n, (*blocking_collection_p ? "blocking" : "non blocking"))); + + // If we already decided to do a blocking gen2 which would also achieve the purpose of building up a new + // gen2 FL, let it happen; otherwise we want to trigger a BGC. + if (!((n == max_generation) && *blocking_collection_p)) + { + n = max_generation; + } + } + } + else +#endif //DYNAMIC_HEAP_COUNT if ((n == max_generation) && background_running_p()) { n = max_generation - 1; @@ -21038,6 +21175,26 @@ int gc_heap::joined_generation_to_condemn (BOOL should_evaluate_elevation, } #endif //BACKGROUND_GC +#ifdef DYNAMIC_HEAP_COUNT + if (trigger_initial_gen2_p) + { +#ifdef BACKGROUND_GC + assert (!trigger_bgc_for_rethreading_p); + assert (!background_running_p()); +#endif //BACKGROUND_GC + + if (n != max_generation) + { + n = max_generation; + *blocking_collection_p = FALSE; + + dprintf (6666, ("doing the 1st gen2 GC requested by DATAS")); + } + + trigger_initial_gen2_p = false; + } +#endif //DYNAMIC_HEAP_COUNT + return n; } @@ -21075,9 +21232,11 @@ size_t gc_heap::get_total_survived_size() return total_surv_size; } -size_t gc_heap::get_total_allocated_since_last_gc() +void gc_heap::get_total_allocated_since_last_gc (size_t* oh_allocated) { + memset (oh_allocated, 0, (total_oh_count * sizeof (size_t))); size_t total_allocated_size = 0; + #ifdef MULTIPLE_HEAPS for (int i = 0; i < gc_heap::n_heaps; i++) { @@ -21086,11 +21245,12 @@ size_t gc_heap::get_total_allocated_since_last_gc() { gc_heap* hp = pGenGCHeap; #endif //MULTIPLE_HEAPS - total_allocated_size += hp->allocated_since_last_gc[0] + hp->allocated_since_last_gc[1]; - hp->allocated_since_last_gc[0] = 0; - hp->allocated_since_last_gc[1] = 0; + for (int oh_idx = 0; oh_idx < total_oh_count; oh_idx++) + { + oh_allocated[oh_idx] += hp->allocated_since_last_gc[oh_idx]; + hp->allocated_since_last_gc[oh_idx] = 0; + } } - return total_allocated_size; } // Gets what's allocated on both SOH, LOH, etc that hasn't been collected. @@ -21338,6 +21498,68 @@ bool gc_heap::init_table_for_region (int gen_number, heap_segment* region) } #endif //USE_REGIONS +// The following 2 methods Use integer division to prevent potential floating point exception. +// FPE may occur if we use floating point division because of speculative execution. +// +// Return the percentage of efficiency (between 0 and 100) of the allocator. +inline +size_t gc_heap::generation_allocator_efficiency_percent (generation* inst) +{ +#ifdef DYNAMIC_HEAP_COUNT + if (dynamic_adaptation_mode == dynamic_adaptation_to_application_sizes) + { + uint64_t total_plan_allocated = generation_total_plan_allocated (inst); + uint64_t condemned_allocated = generation_condemned_allocated (inst); + return ((total_plan_allocated == 0) ? 0 : (100 * (total_plan_allocated - condemned_allocated) / total_plan_allocated)); + } + else +#endif //DYNAMIC_HEAP_COUNT + { + uint64_t free_obj_space = generation_free_obj_space (inst); + uint64_t free_list_allocated = generation_free_list_allocated (inst); + if ((free_list_allocated + free_obj_space) == 0) + return 0; + return (size_t)((100 * free_list_allocated) / (free_list_allocated + free_obj_space)); + } +} + +inline +size_t gc_heap::generation_unusable_fragmentation (generation* inst, int hn) +{ +#ifdef DYNAMIC_HEAP_COUNT + if (dynamic_adaptation_mode == dynamic_adaptation_to_application_sizes) + { + uint64_t total_plan_allocated = generation_total_plan_allocated (inst); + uint64_t condemned_allocated = generation_condemned_allocated (inst); + uint64_t unusable_frag = 0; + size_t fo_space = (((ptrdiff_t)generation_free_obj_space (inst) < 0) ? 0 : generation_free_obj_space (inst)); + + if (total_plan_allocated != 0) + { + unusable_frag = fo_space + (condemned_allocated * generation_free_list_space (inst) / total_plan_allocated); + } + + dprintf (3, ("h%d g%d FLa: %Id, ESa: %Id, Ca: %Id | FO: %Id, FL %Id, fl effi %.3f, unusable fl is %Id", + hn, inst->gen_num, + generation_free_list_allocated (inst), generation_end_seg_allocated (inst), (size_t)condemned_allocated, + fo_space, generation_free_list_space (inst), + ((total_plan_allocated == 0) ? 1.0 : ((float)(total_plan_allocated - condemned_allocated) / (float)total_plan_allocated)), + (size_t)unusable_frag)); + + return (size_t)unusable_frag; + } + else +#endif //DYNAMIC_HEAP_COUNT + { + uint64_t free_obj_space = generation_free_obj_space (inst); + uint64_t free_list_allocated = generation_free_list_allocated (inst); + uint64_t free_list_space = generation_free_list_space (inst); + if ((free_list_allocated + free_obj_space) == 0) + return 0; + return (size_t)(free_obj_space + (free_obj_space * free_list_space) / (free_list_allocated + free_obj_space)); + } +} + #ifdef _PREFAST_ #pragma warning(push) #pragma warning(disable:6326) // "Potential comparison of a constant with another constant" is intentional in this function. @@ -21378,7 +21600,7 @@ int gc_heap::generation_to_condemn (int n_initial, int n_alloc = n; if (heap_number == 0) { - dprintf (GTC_LOG, ("init: %d(%d)", n_initial, settings.reason)); + dprintf (6666, ("init: %d(%d)", n_initial, settings.reason)); } int i = 0; int temp_gen = 0; @@ -21418,10 +21640,13 @@ int gc_heap::generation_to_condemn (int n_initial, for (i = 0; i < total_generation_count; i++) { dynamic_data* dd = dynamic_data_of (i); - dprintf (GTC_LOG, ("h%d: g%d: l: %zd (%zd)", - heap_number, i, - dd_new_allocation (dd), - dd_desired_allocation (dd))); + if ((dd_new_allocation (dd) < 0) && (i >= 2)) + { + dprintf (6666, ("h%d: g%d: l: %zd (%zd)", + heap_number, i, + dd_new_allocation (dd), + dd_desired_allocation (dd))); + } dd_gc_new_allocation (dd) = dd_new_allocation (dd); } @@ -21479,7 +21704,10 @@ int gc_heap::generation_to_condemn (int n_initial, local_condemn_reasons->set_gen (gen_alloc_budget, n); } - dprintf (GTC_LOG, ("h%d: g%d budget", heap_number, ((get_new_allocation (loh_generation) <= 0) ? 3 : n))); + if (n > 0) + { + dprintf (6666, ("h%d: g%d budget", heap_number, ((get_new_allocation (loh_generation) <= 0) ? 3 : n))); + } n_alloc = n; @@ -21533,11 +21761,13 @@ int gc_heap::generation_to_condemn (int n_initial, if (n < (max_generation - 1)) { + dprintf (6666, ("h%d: skip %d", heap_number, generation_skip_ratio)); + if (dt_low_card_table_efficiency_p (tuning_deciding_condemned_gen)) { n = max (n, max_generation - 1); local_settings->promotion = TRUE; - dprintf (GTC_LOG, ("h%d: skip %d, c %d", + dprintf (2, ("h%d: skip %d, c %d", heap_number, generation_skip_ratio, n)); local_condemn_reasons->set_condition (gen_low_card_p); } @@ -21574,7 +21804,7 @@ int gc_heap::generation_to_condemn (int n_initial, { high_fragmentation = TRUE; local_condemn_reasons->set_condition (gen_max_high_frag_e_p); - dprintf (GTC_LOG, ("heap%d: gen1 frag", heap_number)); + dprintf (6666, ("heap%d: gen1 frag", heap_number)); } } } @@ -21597,7 +21827,7 @@ int gc_heap::generation_to_condemn (int n_initial, { if (dt_high_frag_p (tuning_deciding_condemned_gen, i)) { - dprintf (GTC_LOG, ("h%d g%d too frag", heap_number, i)); + dprintf (6666, ("h%d g%d too frag", heap_number, i)); n = i; } else @@ -21692,6 +21922,8 @@ int gc_heap::generation_to_condemn (int n_initial, if (high_fragmentation) { + dprintf (6666, ("h%d high frag true!! mem load %d", heap_number, memory_load)); + if (high_memory_load) { local_condemn_reasons->set_condition (gen_max_high_frag_m_p); @@ -21836,7 +22068,7 @@ int gc_heap::generation_to_condemn (int n_initial, { if (dt_high_frag_p (tuning_deciding_condemned_gen, n)) { - dprintf (GTC_LOG, ("h%d: g%d too frag", heap_number, n)); + dprintf (6666, ("h%d: g%d too frag", heap_number, n)); local_condemn_reasons->set_condition (gen_max_high_frag_p); if (local_settings->pause_mode != pause_sustained_low_latency) { @@ -22125,15 +22357,6 @@ BOOL gc_heap::should_proceed_with_gc() void gc_heap::update_end_gc_time_per_heap() { -#ifdef DYNAMIC_HEAP_COUNT - size_t prev_gen2_end_time = 0; - if ((heap_number == 0) && (dynamic_adaptation_mode == dynamic_adaptation_to_application_sizes) && (settings.condemned_generation == max_generation)) - { - dynamic_data* dd = dynamic_data_of (max_generation); - prev_gen2_end_time = dd_previous_time_clock (dd) + dd_gc_elapsed_time (dd);; - } -#endif //DYNAMIC_HEAP_COUNT - for (int gen_number = 0; gen_number <= settings.condemned_generation; gen_number++) { dynamic_data* dd = dynamic_data_of (gen_number); @@ -22151,94 +22374,13 @@ void gc_heap::update_end_gc_time_per_heap() dprintf (3, ("updated NGC%d %Id elapsed time to %I64d - %I64d = %I64d", gen_number, dd_gc_clock (dd), end_gc_time, dd_time_clock (dd), dd_gc_elapsed_time (dd))); } } - -#ifdef DYNAMIC_HEAP_COUNT - if ((heap_number == 0) && (dynamic_adaptation_mode == dynamic_adaptation_to_application_sizes)) - { - size_t desired_per_heap = dd_desired_allocation (dynamic_data_of (0)); - if (settings.gc_index > 1) - { - size_t gc_index = VolatileLoadWithoutBarrier (&settings.gc_index); - dynamic_heap_count_data_t::sample& sample = dynamic_heap_count_data.samples[dynamic_heap_count_data.sample_index]; - sample.elapsed_between_gcs = end_gc_time - last_suspended_end_time; - sample.gc_pause_time = dd_gc_elapsed_time (dynamic_data_of (0)); - size_t soh_msl_wait_time, uoh_msl_wait_time; - get_msl_wait_time (&soh_msl_wait_time, &uoh_msl_wait_time); - sample.msl_wait_time = soh_msl_wait_time + uoh_msl_wait_time; - sample.gc_index = gc_index; - // could cache this - we will get it again soon in do_post_gc - sample.gc_survived_size = get_total_promoted (); - - // We check to see if we want to adjust the budget here for DATAS. - size_t desired_per_heap_datas = desired_per_heap; - float tcp = (sample.elapsed_between_gcs ? - (((float)sample.msl_wait_time / n_heaps + sample.gc_pause_time) * 100.0f / (float)sample.elapsed_between_gcs) : 0.0f); - size_t total_soh_stable_size = get_total_soh_stable_size(); - desired_per_heap_datas = dynamic_heap_count_data.compute_gen0_budget_per_heap (total_soh_stable_size, tcp, desired_per_heap); - dprintf (6666, ("gen0 new_alloc %Id (%.3fmb), from datas: %Id (%.3fmb)", - desired_per_heap, mb (desired_per_heap), desired_per_heap_datas, mb (desired_per_heap_datas))); - dprintf (6666, ("budget DATAS %Id, previous %Id", desired_per_heap_datas, desired_per_heap)); - - sample.gen0_budget_per_heap = (int)desired_per_heap_datas; - if (desired_per_heap_datas != desired_per_heap) - { - dprintf (6666, ("adjusted budget for DATAS, assigning to all heaps")); - assign_new_budget (0, desired_per_heap_datas); - } - - dprintf (6666, ("sample#%d: %d heaps, this GC end %I64d - last sus end %I64d = %I64d, this GC pause %.3fms, msl wait %I64dus, tcp %.3f, surv %zd, gc speed %.3fmb/ms (%.3fkb/ms/heap)", - dynamic_heap_count_data.sample_index, n_heaps, end_gc_time, last_suspended_end_time, sample.elapsed_between_gcs, - (sample.gc_pause_time / 1000.0), sample.msl_wait_time, tcp, sample.gc_survived_size, - (sample.gc_pause_time ? (sample.gc_survived_size / 1000.0 / sample.gc_pause_time) : 0), - (sample.gc_pause_time ? ((float)sample.gc_survived_size / sample.gc_pause_time / n_heaps) : 0))); - - GCEventFireSizeAdaptationSample_V1 ( - (uint64_t)gc_index, - (uint32_t)sample.elapsed_between_gcs, - (uint32_t)sample.gc_pause_time, - (uint32_t)soh_msl_wait_time, (uint32_t)uoh_msl_wait_time, - (uint64_t)total_soh_stable_size, (uint32_t)sample.gen0_budget_per_heap); - - dynamic_heap_count_data.sample_index = (dynamic_heap_count_data.sample_index + 1) % dynamic_heap_count_data_t::sample_size; - (dynamic_heap_count_data.current_samples_count)++; - - if (settings.condemned_generation == max_generation) - { - gc_index_full_gc_end = dd_gc_clock (dynamic_data_of (0)); - size_t elapsed_between_gen2_gcs = end_gc_time - prev_gen2_end_time; - size_t gen2_elapsed_time = sample.gc_pause_time; - dynamic_heap_count_data_t::gen2_sample& g2_sample = dynamic_heap_count_data.gen2_samples[dynamic_heap_count_data.gen2_sample_index]; - g2_sample.gc_index = VolatileLoadWithoutBarrier (&(settings.gc_index)); - g2_sample.gc_percent = (float)gen2_elapsed_time * 100.0f / elapsed_between_gen2_gcs; - (dynamic_heap_count_data.current_gen2_samples_count)++; - - dprintf (6666, ("gen2 sample#%d: this GC end %I64d - last gen2 end %I64d = %I64d, GC elapsed %I64d, percent %.3f", - dynamic_heap_count_data.gen2_sample_index, end_gc_time, prev_gen2_end_time, elapsed_between_gen2_gcs, gen2_elapsed_time, g2_sample.gc_percent)); - dynamic_heap_count_data.gen2_sample_index = (dynamic_heap_count_data.gen2_sample_index + 1) % dynamic_heap_count_data_t::sample_size; - } - - calculate_new_heap_count (); - } - else - { - // For DATAS we can't just take the BCS because it's likely very large and that could totally make the max heap size larger. We just take the - // min budget. - size_t min_desired = dd_min_size (dynamic_data_of (0)); - if (min_desired != desired_per_heap) - { - dprintf (6666, ("use the min budget for DATAS, assigning to all heaps")); - assign_new_budget (0, min_desired); - } - } - - last_suspended_end_time = end_gc_time; - } -#endif //DYNAMIC_HEAP_COUNT } void gc_heap::update_end_ngc_time() { end_gc_time = GetHighPrecisionTimeStamp(); + last_alloc_reset_suspended_end_time = end_gc_time; + #ifdef HEAP_BALANCE_INSTRUMENTATION last_gc_end_time_us = end_gc_time; dprintf (HEAP_BALANCE_LOG, ("[GC#%zd-%zd-%zd]", settings.gc_index, @@ -22400,6 +22542,7 @@ void gc_heap::gc1() float bgc_percent = (float)dd_gc_elapsed_time (dd) * 100.0f / (float)time_since_last_gen2; dynamic_heap_count_data_t::gen2_sample& g2_sample = dynamic_heap_count_data.gen2_samples[dynamic_heap_count_data.gen2_sample_index]; g2_sample.gc_index = VolatileLoadWithoutBarrier (&(settings.gc_index)); + g2_sample.gc_duration = dd_gc_elapsed_time (dd); g2_sample.gc_percent = bgc_percent; dprintf (6666, ("gen2 sample %d elapsed %Id * 100 / time inbetween gen2 %Id = %.3f", dynamic_heap_count_data.gen2_sample_index, dd_gc_elapsed_time (dd), time_since_last_gen2, bgc_percent)); @@ -22474,7 +22617,7 @@ void gc_heap::gc1() generation_free_obj_space (generation_of (older_gen_idx)); #ifdef BACKGROUND_GC - if (current_c_gc_state != c_gc_state_planning) + if ((older_gen_idx != max_generation) || (current_c_gc_state != c_gc_state_planning)) #endif //BACKGROUND_GC { if (settings.promotion) @@ -22802,7 +22945,6 @@ void gc_heap::gc1() for (int i = 0; i < gc_heap::n_heaps; i++) { gc_heap* hp = gc_heap::g_heaps[i]; - hp->decommit_ephemeral_segment_pages(); hp->rearrange_uoh_segments(); #ifdef FEATURE_LOH_COMPACTION all_heaps_compacted_p &= hp->loh_compacted_p; @@ -22811,9 +22953,9 @@ void gc_heap::gc1() max_gen0_must_clear_bricks = max(max_gen0_must_clear_bricks, hp->gen0_must_clear_bricks); } verify_committed_bytes_per_heap (); + #ifdef USE_REGIONS initGCShadow(); - distribute_free_regions(); verify_region_to_generation_map (); compute_gc_and_ephemeral_range (settings.condemned_generation, true); stomp_write_barrier_ephemeral (ephemeral_low, ephemeral_high, @@ -22836,17 +22978,34 @@ void gc_heap::gc1() } } - for (int i = 0; i < gc_heap::n_heaps; i++) +#ifdef DYNAMIC_HEAP_COUNT + if (dynamic_adaptation_mode == dynamic_adaptation_to_application_sizes) { - g_heaps[i]->descr_generations ("END"); - } - age_free_regions ("END"); + update_total_soh_stable_size(); -#ifdef DYNAMIC_HEAP_COUNT - update_total_soh_stable_size(); + if ((settings.condemned_generation == max_generation) && trigger_bgc_for_rethreading_p) + { + trigger_bgc_for_rethreading_p = false; + } + + process_datas_sample(); + } #endif //DYNAMIC_HEAP_COUNT + for (int i = 0; i < gc_heap::n_heaps; i++) + { + gc_heap* hp = gc_heap::g_heaps[i]; + hp->decommit_ephemeral_segment_pages(); + hp->descr_generations ("END"); + } + fire_pevents(); + +#ifdef USE_REGIONS + distribute_free_regions(); + age_free_regions ("END"); +#endif //USE_REGIONS + update_end_ngc_time(); pm_full_gc_init_or_clear(); @@ -22866,7 +23025,10 @@ void gc_heap::gc1() check_loh_compact_mode (loh_compacted_p); #endif //FEATURE_LOH_COMPACTION +#ifndef USE_REGIONS decommit_ephemeral_segment_pages(); +#endif + fire_pevents(); if (!(settings.concurrent)) @@ -22875,11 +23037,11 @@ void gc_heap::gc1() verify_committed_bytes_per_heap (); #ifdef USE_REGIONS initGCShadow(); - distribute_free_regions(); verify_region_to_generation_map (); compute_gc_and_ephemeral_range (settings.condemned_generation, true); stomp_write_barrier_ephemeral (ephemeral_low, ephemeral_high, map_region_to_generation_skewed, (uint8_t)min_segment_size_shr); + distribute_free_regions(); age_free_regions ("END"); #endif //USE_REGIONS @@ -22940,7 +23102,7 @@ void gc_heap::update_total_soh_stable_size() dynamic_data* dd = hp->dynamic_data_of (max_generation); current_total_soh_stable_size += dd_current_size (dd) + dd_desired_allocation (dd); - dprintf (6666, ("current size is %.3fmb, budget %.3fmb, total -> %.3fmb", mb (dd_current_size (dd)), mb (dd_desired_allocation (dd)), mb (current_total_soh_stable_size))); + dprintf (2, ("current size is %.3fmb, budget %.3fmb, total -> %.3fmb", mb (dd_current_size (dd)), mb (dd_desired_allocation (dd)), mb (current_total_soh_stable_size))); } } } @@ -24249,10 +24411,31 @@ void gc_heap::garbage_collect (int n) #ifdef MULTIPLE_HEAPS if (heap_number == 0) { +#ifdef DYNAMIC_HEAP_COUNT + size_t current_gc_index = VolatileLoadWithoutBarrier (&settings.gc_index); + if (!bgc_init_gc_index) + { + assert (!bgc_init_n_heaps); + bgc_init_gc_index = current_gc_index; + bgc_init_n_heaps = (short)n_heaps; + } + size_t saved_bgc_th_count_created = bgc_th_count_created; + size_t saved_bgc_th_count_created_th_existed = bgc_th_count_created_th_existed; + size_t saved_bgc_th_count_creation_failed = bgc_th_count_creation_failed; +#endif //DYNAMIC_HEAP_COUNT + for (int i = 0; i < n_heaps; i++) { prepare_bgc_thread (g_heaps[i]); } + +#ifdef DYNAMIC_HEAP_COUNT + add_to_bgc_th_creation_history (current_gc_index, + (bgc_th_count_created - saved_bgc_th_count_created), + (bgc_th_count_created_th_existed - saved_bgc_th_count_created_th_existed), + (bgc_th_count_creation_failed - saved_bgc_th_count_creation_failed)); +#endif //DYNAMIC_HEAP_COUNT + dprintf (2, ("setting bgc_threads_sync_event")); bgc_threads_sync_event.Set(); } @@ -24335,6 +24518,14 @@ void gc_heap::garbage_collect (int n) settings.init_mechanisms(); settings.condemned_generation = gen; + +#ifdef DYNAMIC_HEAP_COUNT + if (trigger_bgc_for_rethreading_p) + { + settings.condemned_generation = 0; + } +#endif //DYNAMIC_HEAP_COUNT + settings.gc_index = (size_t)dd_collection_count (dynamic_data_of (0)) + 2; do_pre_gc(); @@ -25192,7 +25383,7 @@ void gc_heap::recommission_heap() // mark_stack_array_length = 0; // mark_stack_array = nullptr; - generation_skip_ratio = 0; + generation_skip_ratio = 100; gen0_must_clear_bricks = 0; freeable_uoh_segment = nullptr; @@ -25591,6 +25782,21 @@ void gc_heap::calculate_new_heap_count () if (change_int > 0) { + // If we do want to grow but the max HC allowed by DATAS is 0, and we haven't done any gen2 GCs yet, we do want to + // trigger a gen2 right away. + if (!max_heap_count_growth_datas && !(dynamic_heap_count_data.current_gen2_samples_count)) + { + trigger_initial_gen2_p = true; + + dprintf (6666, ("we want to grow but DATAS is limiting, trigger a gen2 right away")); +#ifdef BACKGROUND_GC + if (background_running_p()) + { + trigger_initial_gen2_p = false; + } +#endif //BACKGROUND_GC + } + agg_factor = dynamic_heap_count_data.get_aggressiveness (change_int); if (agg_factor > 1) { @@ -25718,7 +25924,6 @@ void gc_heap::calculate_new_heap_count () dprintf (6666, ("processed gen2 samples, updating processed %Id -> %Id", dynamic_heap_count_data.processed_gen2_samples_count, dynamic_heap_count_data.current_gen2_samples_count)); dynamic_heap_count_data.processed_gen2_samples_count = dynamic_heap_count_data.current_gen2_samples_count; } - #endif //STRESS_DYNAMIC_HEAP_COUNT if (new_n_heaps != n_heaps) @@ -25747,6 +25952,8 @@ void gc_heap::check_heap_count () if (gc_heap::background_running_p()) { // background GC is running - reset the new heap count + add_to_hc_history (hc_record_check_cancelled_bgc); + hc_change_cancelled_count_bgc++; dynamic_heap_count_data.new_n_heaps = n_heaps; dprintf (6666, ("can't change heap count! BGC in progress")); } @@ -25759,6 +25966,8 @@ void gc_heap::check_heap_count () if (!prepare_to_change_heap_count (dynamic_heap_count_data.new_n_heaps)) { // we don't have sufficient resources - reset the new heap count + add_to_hc_history (hc_record_check_cancelled_prep); + hc_change_cancelled_count_prep++; dynamic_heap_count_data.new_n_heaps = n_heaps; } } @@ -26184,25 +26393,44 @@ bool gc_heap::change_heap_count (int new_n_heaps) gc_t_join.join (this, gc_join_merge_temp_fl); if (gc_t_join.joined ()) { +#ifdef BACKGROUND_GC + // For now I'm always setting it to true. This should be set based on heuristics like the number of + // FL items. I'm currently rethreading all generations' FL except gen2's. When the next GC happens, + // it will be a BGC (unless it's a blocking gen2 which also works). And when BGC sweep starts we will + // build the gen2 FL from scratch. + trigger_bgc_for_rethreading_p = true; +#endif //BACKGROUND_GC gc_t_join.restart (); } // rethread the free lists for (int gen_idx = 0; gen_idx < total_generation_count; gen_idx++) { - if (heap_number < old_n_heaps) + bool do_rethreading = true; + +#ifdef BACKGROUND_GC + if (trigger_bgc_for_rethreading_p && (gen_idx == max_generation)) { - dprintf (3, ("h%d calling per heap work!", heap_number)); - rethread_fl_items (gen_idx); + do_rethreading = false; } +#endif //BACKGROUND_GC - // join for merging the free lists - gc_t_join.join (this, gc_join_merge_temp_fl); - if (gc_t_join.joined ()) + if (do_rethreading) { - merge_fl_from_other_heaps (gen_idx, new_n_heaps, old_n_heaps); + if (heap_number < old_n_heaps) + { + dprintf (3, ("h%d calling per heap work!", heap_number)); + rethread_fl_items (gen_idx); + } - gc_t_join.restart (); + // join for merging the free lists + gc_t_join.join (this, gc_join_merge_temp_fl); + if (gc_t_join.joined ()) + { + merge_fl_from_other_heaps (gen_idx, new_n_heaps, old_n_heaps); + + gc_t_join.restart (); + } } } @@ -26260,8 +26488,17 @@ bool gc_heap::change_heap_count (int new_n_heaps) generation* gen = hp->generation_of (gen_idx); size_t gen_size = hp->generation_size (gen_idx); dd_fragmentation (dd) = generation_free_list_space (gen); - assert (gen_size >= dd_fragmentation (dd)); - dd_current_size (dd) = gen_size - dd_fragmentation (dd); + if (gen_idx == max_generation) + { + // Just set it to 0 so it doesn't cause any problems. The next GC which will be a gen2 will update it to the correct value. + dd_current_size (dd) = 0; + } + else + { + // We cannot assert this for gen2 because we didn't actually rethread gen2 FL. + assert (gen_size >= dd_fragmentation (dd)); + dd_current_size (dd) = gen_size - dd_fragmentation (dd); + } dprintf (3, ("h%d g%d: budget: %zd, left in budget: %zd, generation_size: %zd fragmentation: %zd current_size: %zd", i, @@ -26306,7 +26543,10 @@ bool gc_heap::change_heap_count (int new_n_heaps) if (heap_number == 0) { + add_to_hc_history (hc_record_change_done); change_heap_count_time = GetHighPrecisionTimeStamp() - start_time; + total_change_heap_count_time += change_heap_count_time; + total_change_heap_count++; dprintf (6666, ("changing HC took %I64dus", change_heap_count_time)); } @@ -26331,6 +26571,144 @@ void gc_heap::get_msl_wait_time (size_t* soh_msl_wait_time, size_t* uoh_msl_wait hp->more_space_lock_uoh.msl_wait_time = 0; } } + +void gc_heap::process_datas_sample() +{ + // We get the time here instead of waiting till we assign end_gc_time because end_gc_time includes distribute_free_regions + // but we need to get the budget from DATAS before we call distribute_free_regions. distribute_free_regions takes < 1% of + // the GC pause so it's ok to not count it. The GC elapsed time DATAS records uses this timestamp instead of end_gc_time. + before_distribute_free_regions_time = GetHighPrecisionTimeStamp(); + dynamic_data* dd0 = g_heaps[0]->dynamic_data_of (0); + uint64_t gc_pause_time = before_distribute_free_regions_time - dd_time_clock (dd0); + + size_t desired_per_heap = dd_desired_allocation (dd0); + if (settings.gc_index > 1) + { + size_t gc_index = VolatileLoadWithoutBarrier (&settings.gc_index); + dynamic_heap_count_data_t::sample& sample = dynamic_heap_count_data.samples[dynamic_heap_count_data.sample_index]; + sample.elapsed_between_gcs = before_distribute_free_regions_time - last_suspended_end_time; + sample.gc_pause_time = gc_pause_time; + size_t soh_msl_wait_time, uoh_msl_wait_time; + get_msl_wait_time (&soh_msl_wait_time, &uoh_msl_wait_time); + sample.msl_wait_time = soh_msl_wait_time + uoh_msl_wait_time; + sample.gc_index = gc_index; + // could cache this - we will get it again soon in do_post_gc + sample.gc_survived_size = get_total_promoted(); + + // We check to see if we want to adjust the budget here for DATAS. + size_t desired_per_heap_datas = desired_per_heap; + float tcp = (sample.elapsed_between_gcs ? + (((float)sample.msl_wait_time / n_heaps + sample.gc_pause_time) * 100.0f / (float)sample.elapsed_between_gcs) : 0.0f); + size_t total_soh_stable_size = get_total_soh_stable_size(); + desired_per_heap_datas = dynamic_heap_count_data.compute_gen0_budget_per_heap (total_soh_stable_size, tcp, desired_per_heap); + dprintf (6666, ("gen0 new_alloc %Id (%.3fmb), from datas: %Id (%.3fmb)", + desired_per_heap, mb (desired_per_heap), desired_per_heap_datas, mb (desired_per_heap_datas))); + dprintf (6666, ("budget DATAS %Id, previous %Id", desired_per_heap_datas, desired_per_heap)); + + sample.gen0_budget_per_heap = (int)desired_per_heap_datas; + if (desired_per_heap_datas != desired_per_heap) + { + dprintf (6666, ("adjusted budget for DATAS, assigning to all heaps")); + assign_new_budget (0, desired_per_heap_datas); + } + + dprintf (6666, ("sample#%d: %d heaps, this GC end %I64d - last sus end %I64d = %I64d, this GC pause %.3fms, msl wait %I64dus, tcp %.3f, surv %zd, gc speed %.3fmb/ms (%.3fkb/ms/heap)", + dynamic_heap_count_data.sample_index, n_heaps, before_distribute_free_regions_time, last_suspended_end_time, sample.elapsed_between_gcs, + (sample.gc_pause_time / 1000.0), sample.msl_wait_time, tcp, sample.gc_survived_size, + (sample.gc_pause_time ? (sample.gc_survived_size / 1000.0 / sample.gc_pause_time) : 0), + (sample.gc_pause_time ? ((float)sample.gc_survived_size / sample.gc_pause_time / n_heaps) : 0))); + + GCEventFireSizeAdaptationSample_V1 ( + (uint64_t)gc_index, + (uint32_t)sample.elapsed_between_gcs, + (uint32_t)sample.gc_pause_time, + (uint32_t)soh_msl_wait_time, (uint32_t)uoh_msl_wait_time, + (uint64_t)total_soh_stable_size, (uint32_t)sample.gen0_budget_per_heap); + + dynamic_heap_count_data.sample_index = (dynamic_heap_count_data.sample_index + 1) % dynamic_heap_count_data_t::sample_size; + (dynamic_heap_count_data.current_samples_count)++; + + if (settings.condemned_generation == max_generation) + { + gc_index_full_gc_end = dd_gc_clock (dd0); + dynamic_heap_count_data_t::gen2_sample& last_g2_sample = dynamic_heap_count_data.get_last_gen2_sample(); + uint64_t prev_gen2_end_time = dd_previous_time_clock (g_heaps[0]->dynamic_data_of (max_generation)) + last_g2_sample.gc_duration; + size_t elapsed_between_gen2_gcs = before_distribute_free_regions_time - prev_gen2_end_time; + size_t gen2_elapsed_time = sample.gc_pause_time; + dynamic_heap_count_data_t::gen2_sample& g2_sample = dynamic_heap_count_data.get_current_gen2_sample(); + g2_sample.gc_index = VolatileLoadWithoutBarrier (&(settings.gc_index)); + g2_sample.gc_duration = gen2_elapsed_time; + g2_sample.gc_percent = (float)gen2_elapsed_time * 100.0f / elapsed_between_gen2_gcs; + (dynamic_heap_count_data.current_gen2_samples_count)++; + + dprintf (6666, ("gen2 sample#%d: this GC end %I64d - last gen2 end %I64d = %I64d, GC elapsed %I64d, percent %.3f", + dynamic_heap_count_data.gen2_sample_index, before_distribute_free_regions_time, prev_gen2_end_time, elapsed_between_gen2_gcs, gen2_elapsed_time, g2_sample.gc_percent)); + dynamic_heap_count_data.gen2_sample_index = (dynamic_heap_count_data.gen2_sample_index + 1) % dynamic_heap_count_data_t::sample_size; + } + + calculate_new_heap_count (); + } + else + { + // For DATAS we can't just take the BCS because it's likely very large and that could totally make the max heap size larger. We just take the + // min budget. + size_t min_desired = dd_min_size (dd0); + if (min_desired != desired_per_heap) + { + dprintf (6666, ("use the min budget for DATAS, assigning to all heaps")); + assign_new_budget (0, min_desired); + } + } + + last_suspended_end_time = before_distribute_free_regions_time; +} + +void gc_heap::add_to_hc_history_worker (hc_history* hist, int* current_index, hc_record_stage stage, const char* msg) +{ + dprintf (6666, ("h%d ADDING %s HC hist to entry #%d, stage %d, gc index %Id, last %d, n %d, new %d", + heap_number, msg, *current_index, (int)stage, VolatileLoadWithoutBarrier (&settings.gc_index), + dynamic_heap_count_data.last_n_heaps, n_heaps, dynamic_heap_count_data.new_n_heaps)); + hc_history* current_hist = &hist[*current_index]; + current_hist->gc_index = VolatileLoadWithoutBarrier (&settings.gc_index); + current_hist->stage = (short)stage; + current_hist->last_n_heaps = (short)dynamic_heap_count_data.last_n_heaps; + current_hist->n_heaps = (short)n_heaps; + current_hist->new_n_heaps = (short)dynamic_heap_count_data.new_n_heaps; + current_hist->idle_thread_count = (short)dynamic_heap_count_data.idle_thread_count; + current_hist->gc_t_join_n_threads = (short)gc_t_join.get_num_threads(); + current_hist->gc_t_join_join_lock = (short)gc_t_join.get_join_lock(); + current_hist->gc_t_join_joined_p = (bool)gc_t_join.joined(); +#ifdef BACKGROUND_GC + current_hist->bgc_t_join_n_threads = (short)bgc_t_join.get_num_threads(); + current_hist->bgc_t_join_join_lock = (short)bgc_t_join.get_join_lock(); + current_hist->bgc_t_join_joined_p = (bool)bgc_t_join.joined(); + current_hist->concurrent_p = (bool)settings.concurrent; + current_hist->bgc_thread_running = (bool)bgc_thread_running; + +#if defined(TARGET_AMD64) && defined(TARGET_WINDOWS) && !defined(_DEBUG) + int bgc_thread_os_id = 0; + + if (bgc_thread) + { + bgc_thread_os_id = (int)(*(size_t*)((uint8_t*)bgc_thread + 0x130)); + } + + current_hist->bgc_thread_os_id = bgc_thread_os_id; +#endif //TARGET_AMD64 && TARGET_WINDOWS && !_DEBUG +#endif //BACKGROUND_GC + + *current_index = (*current_index + 1) % max_hc_history_count; +} + +void gc_heap::add_to_hc_history (hc_record_stage stage) +{ + add_to_hc_history_worker (hchist_per_heap, &hchist_index_per_heap, stage, "GC"); +} + +void gc_heap::add_to_bgc_hc_history (hc_record_stage stage) +{ + add_to_hc_history_worker (bgc_hchist_per_heap, &bgc_hchist_index_per_heap, stage, "BGC"); +} #endif //DYNAMIC_HEAP_COUNT #endif //USE_REGIONS @@ -29179,13 +29557,16 @@ BOOL gc_heap::decide_on_promotion_surv (size_t threshold) #else //MULTIPLE_HEAPS { gc_heap* hp = pGenGCHeap; + int i = 0; #endif //MULTIPLE_HEAPS dynamic_data* dd = hp->dynamic_data_of (min ((int)(settings.condemned_generation + 1), (int)max_generation)); size_t older_gen_size = dd_current_size (dd) + (dd_desired_allocation (dd) - dd_new_allocation (dd)); size_t promoted = hp->total_promoted_bytes; - dprintf (2, ("promotion threshold: %zd, promoted bytes: %zd size n+1: %zd", - threshold, promoted, older_gen_size)); + + dprintf (6666, ("h%d promotion threshold: %zd, promoted bytes: %zd size n+1: %zd -> %s", + i, threshold, promoted, older_gen_size, + (((threshold > (older_gen_size)) || (promoted > threshold)) ? "promote" : "don't promote"))); if ((threshold > (older_gen_size)) || (promoted > threshold)) { @@ -29484,7 +29865,10 @@ void gc_heap::mark_phase (int condemned_gen_number) #endif //USE_REGIONS GCToEEInterface::BeforeGcScanRoots(condemned_gen_number, /* is_bgc */ false, /* is_concurrent */ false); + +#ifdef FEATURE_SIZED_REF_HANDLES num_sizedrefs = GCToEEInterface::GetTotalNumSizedRefHandles(); +#endif // FEATURE_SIZED_REF_HANDLES #ifdef FEATURE_EVENT_TRACE informational_event_enabled_p = EVENT_ENABLED (GCMarkWithType); @@ -29571,6 +29955,7 @@ void gc_heap::mark_phase (int condemned_gen_number) slow = MAX_PTR; #endif //MULTIPLE_HEAPS +#ifdef FEATURE_SIZED_REF_HANDLES if ((condemned_gen_number == max_generation) && (num_sizedrefs > 0)) { GCScan::GcScanSizedRefs(GCHeap::Promote, condemned_gen_number, max_generation, &sc); @@ -29592,6 +29977,7 @@ void gc_heap::mark_phase (int condemned_gen_number) #endif //MULTIPLE_HEAPS } } +#endif // FEATURE_SIZED_REF_HANDLES #if defined(FEATURE_BASICFREEZE) && !defined(USE_REGIONS) if (ro_segments_in_range) @@ -29819,8 +30205,16 @@ void gc_heap::mark_phase (int condemned_gen_number) (int)(((float)n_gen_loh / (float)n_eph_loh) * 100) : 100); generation_skip_ratio = min (generation_skip_ratio_soh, generation_skip_ratio_loh); - dprintf (2, ("h%d skip ratio soh: %d, loh: %d", heap_number, - generation_skip_ratio_soh, generation_skip_ratio_loh)); +#ifdef SIMPLE_DPRINTF + dprintf (6666, ("h%d skip ratio soh: %d (n_gen_soh: %Id, n_eph_soh: %Id), loh: %d (n_gen_loh: %Id, n_eph_loh: %Id), size 0: %Id-%Id, 1: %Id-%Id, 2: %Id-%Id, 3: %Id-%Id", + heap_number, + generation_skip_ratio_soh, VolatileLoadWithoutBarrier (&n_gen_soh), VolatileLoadWithoutBarrier (&n_eph_soh), + generation_skip_ratio_loh, VolatileLoadWithoutBarrier (&n_gen_loh), VolatileLoadWithoutBarrier (&n_eph_loh), + generation_size (0), dd_fragmentation (dynamic_data_of (0)), + generation_size (1), dd_fragmentation (dynamic_data_of (1)), + generation_size (2), dd_fragmentation (dynamic_data_of (2)), + generation_size (3), dd_fragmentation (dynamic_data_of (3)))); +#endif //SIMPLE_DPRINTF } #endif // FEATURE_CARD_MARKING_STEALING @@ -37561,7 +37955,7 @@ BOOL gc_heap::is_bgc_in_progress() #ifdef MULTIPLE_HEAPS // All heaps are changed to/from the bgc_initialized state during the VM suspension at the start of BGC, // so checking any heap will work. - gc_heap* hp = gc_heap::g_heaps[0]; + gc_heap* hp = g_heaps[0]; #else gc_heap* hp = pGenGCHeap; #endif //MULTIPLE_HEAPS @@ -38081,6 +38475,7 @@ void gc_heap::background_mark_phase () if (bgc_t_join.joined()) #endif //MULTIPLE_HEAPS { +#ifdef USE_REGIONS // There's no need to distribute a second time if we just did an ephemeral GC, and we don't want to // age the free regions twice. if (!do_ephemeral_gc_p) @@ -38088,6 +38483,7 @@ void gc_heap::background_mark_phase () distribute_free_regions (); age_free_regions ("BGC"); } +#endif //USE_REGIONS #ifdef FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP // Resetting write watch for software write watch is pretty fast, much faster than for hardware write watch. Reset @@ -38107,7 +38503,9 @@ void gc_heap::background_mark_phase () concurrent_print_time_delta ("CRWW"); #endif // FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP +#ifdef FEATURE_SIZED_REF_HANDLES num_sizedrefs = GCToEEInterface::GetTotalNumSizedRefHandles(); +#endif // FEATURE_SIZED_REF_HANDLES // this c_write is not really necessary because restart_vm // has an instruction that will flush the cpu cache (interlocked @@ -38117,6 +38515,7 @@ void gc_heap::background_mark_phase () assert (dont_restart_ee_p); dont_restart_ee_p = FALSE; + last_alloc_reset_suspended_end_time = GetHighPrecisionTimeStamp(); restart_vm(); GCToOSInterface::YieldThread (0); @@ -38185,6 +38584,7 @@ void gc_heap::background_mark_phase () disable_preemptive (true); +#ifdef FEATURE_SIZED_REF_HANDLES if (num_sizedrefs > 0) { GCScan::GcScanSizedRefs(background_promote, max_generation, max_generation, &sc); @@ -38202,6 +38602,7 @@ void gc_heap::background_mark_phase () disable_preemptive (true); } +#endif // FEATURE_SIZED_REF_HANDLES dprintf (3,("BGC: handle table marking")); GCScan::GcScanHandles(background_promote, @@ -39116,6 +39517,27 @@ void gc_heap::mark_absorb_new_alloc() clear_gen0_bricks(); } +#ifdef DYNAMIC_HEAP_COUNT +void gc_heap::add_to_bgc_th_creation_history (size_t gc_index, size_t count_created, + size_t count_created_th_existed, size_t count_creation_failed) +{ + if ((count_created != 0) || (count_created_th_existed != 0) || (count_creation_failed != 0)) + { + dprintf (6666, ("ADDING to BGC th hist entry%d gc index %Id, created %d, %d th existed, %d failed", + bgc_th_creation_hist_index, gc_index, count_created, count_created_th_existed, count_creation_failed)); + + bgc_thread_creation_history* current_hist = &bgc_th_creation_hist[bgc_th_creation_hist_index]; + current_hist->gc_index = gc_index; + current_hist->n_heaps = (short)n_heaps; + current_hist->count_created = (short)count_created; + current_hist->count_created_th_existed = (short)count_created_th_existed; + current_hist->count_creation_failed = (short)count_creation_failed; + + bgc_th_creation_hist_index = (bgc_th_creation_hist_index + 1) % max_bgc_thread_creation_count; + } +} +#endif //DYNAMIC_HEAP_COUNT + BOOL gc_heap::prepare_bgc_thread(gc_heap* gh) { BOOL success = FALSE; @@ -39125,10 +39547,28 @@ BOOL gc_heap::prepare_bgc_thread(gc_heap* gh) if (!(gh->bgc_thread_running)) { dprintf (2, ("GC thread not running")); - if ((gh->bgc_thread == 0) && create_bgc_thread(gh)) + if (gh->bgc_thread == 0) { - success = TRUE; - thread_created = TRUE; + if (create_bgc_thread(gh)) + { + success = TRUE; + thread_created = TRUE; +#ifdef DYNAMIC_HEAP_COUNT + bgc_th_count_created++; +#endif //DYNAMIC_HEAP_COUNT + } + else + { +#ifdef DYNAMIC_HEAP_COUNT + bgc_th_count_creation_failed++; +#endif //DYNAMIC_HEAP_COUNT + } + } + else + { +#ifdef DYNAMIC_HEAP_COUNT + bgc_th_count_created_th_existed++; +#endif //DYNAMIC_HEAP_COUNT } } else @@ -39390,6 +39830,8 @@ void gc_heap::bgc_thread_function() #ifdef DYNAMIC_HEAP_COUNT if (n_heaps <= heap_number) { + add_to_bgc_hc_history (hc_record_bgc_inactive); + // this is the case where we have more background GC threads than heaps // - wait until we're told to continue... dprintf (9999, ("BGC thread %d idle (%d heaps) (gc%Id)", heap_number, n_heaps, VolatileLoadWithoutBarrier (&settings.gc_index))); @@ -39397,6 +39839,10 @@ void gc_heap::bgc_thread_function() dprintf (9999, ("BGC thread %d waking from idle (%d heaps) (gc%Id)", heap_number, n_heaps, VolatileLoadWithoutBarrier (&settings.gc_index))); continue; } + else + { + add_to_bgc_hc_history (hc_record_bgc_active); + } #endif //DYNAMIC_HEAP_COUNT gc1(); @@ -39457,6 +39903,13 @@ void gc_heap::bgc_thread_function() fire_pevents(); #endif //MULTIPLE_HEAPS +#ifdef DYNAMIC_HEAP_COUNT + if (trigger_bgc_for_rethreading_p) + { + trigger_bgc_for_rethreading_p = false; + } +#endif //DYNAMIC_HEAP_COUNT + c_write (settings.concurrent, FALSE); gc_background_running = FALSE; keep_bgc_threads_p = FALSE; @@ -43813,6 +44266,24 @@ void gc_heap::compute_new_dynamic_data (int gen_number) //keep track of fragmentation dd_fragmentation (dd) = generation_free_list_space (gen) + generation_free_obj_space (gen); + // We need to reset the condemned alloc for the condemned generation because it will participate in the free list efficiency + // calculation. And if a generation is condemned, it means all the allocations into this generation during that GC will be + // condemned and it wouldn't make sense to use this value to calculate the FL efficiency since at this point the FL hasn't + // been built. + generation_condemned_allocated (gen) = 0; + + if (settings.concurrent) + { + // For BGC we could have non zero values due to gen1 FGCs. We reset all 3 allocs to start anew. + generation_free_list_allocated (gen) = 0; + generation_end_seg_allocated (gen) = 0; + } + else + { + assert (generation_free_list_allocated (gen) == 0); + assert (generation_end_seg_allocated (gen) == 0); + } + // make sure the subtraction below doesn't overflow if (dd_fragmentation (dd) <= total_gen_size) dd_current_size (dd) = total_gen_size - dd_fragmentation (dd); @@ -43989,6 +44460,49 @@ ptrdiff_t gc_heap::estimate_gen_growth (int gen_number) return budget_gen; } +#if !defined(USE_REGIONS) || defined(MULTIPLE_HEAPS) +uint8_t* gc_heap::get_smoothed_decommit_target (uint8_t* previous_decommit_target, uint8_t* new_decommit_target, heap_segment* seg) +{ + uint8_t* decommit_target = new_decommit_target; + if (decommit_target < previous_decommit_target) + { + // we used to have a higher target - do exponential smoothing by computing + // essentially decommit_target = 1/3*decommit_target + 2/3*previous_decommit_target + // computation below is slightly different to avoid overflow + ptrdiff_t target_decrease = previous_decommit_target - decommit_target; + decommit_target += target_decrease * 2 / 3; + } + +#ifdef STRESS_DECOMMIT + // our decommit logic should work for a random decommit target within tail_region - make sure it does + decommit_target = heap_segment_mem (seg) + gc_rand::get_rand (heap_segment_reserved (seg) - heap_segment_mem (seg)); +#endif //STRESS_DECOMMIT + +#ifdef MULTIPLE_HEAPS + if (decommit_target < heap_segment_committed (seg)) + { + gradual_decommit_in_progress_p = TRUE; + } +#endif //MULTIPLE_HEAPS + + int gen_num = +#ifdef USE_REGIONS + seg->gen_num; +#else + 0; +#endif + dprintf (3, ("h%2d gen %d allocated: %zdkb committed: %zdkb target: %zdkb", + heap_number, + gen_num, + ((heap_segment_allocated (seg) - heap_segment_mem (seg)) / 1024), + ((heap_segment_committed (seg) - heap_segment_mem (seg)) / 1024), + (heap_segment_decommit_target (seg) - heap_segment_mem (seg)) / 1024)); + + return decommit_target; +} + +// For regions this really just sets the decommit target for ephemeral tail regions so this should really be done in +// distribute_free_regions where we are calling estimate_gen_growth. void gc_heap::decommit_ephemeral_segment_pages() { if (settings.concurrent || use_large_pages_p || (settings.pause_mode == pause_no_gc)) @@ -44023,44 +44537,9 @@ void gc_heap::decommit_ephemeral_segment_pages() uint8_t *decommit_target = heap_segment_reserved (tail_region) - unneeded_tail_size; decommit_target = max (decommit_target, heap_segment_allocated (tail_region)); - if (decommit_target < previous_decommit_target) - { - // we used to have a higher target - do exponential smoothing by computing - // essentially decommit_target = 1/3*decommit_target + 2/3*previous_decommit_target - // computation below is slightly different to avoid overflow - ptrdiff_t target_decrease = previous_decommit_target - decommit_target; - decommit_target += target_decrease * 2 / 3; - } - -//#define STRESS_DECOMMIT 1 -#ifdef STRESS_DECOMMIT - // our decommit logic should work for a random decommit target within tail_region - make sure it does - decommit_target = heap_segment_mem (tail_region) + gc_rand::get_rand (heap_segment_reserved (tail_region) - heap_segment_mem (tail_region)); -#endif //STRESS_DECOMMIT - - heap_segment_decommit_target (tail_region) = decommit_target; - - if (decommit_target < heap_segment_committed (tail_region)) - { - gradual_decommit_in_progress_p = TRUE; - - dprintf (REGIONS_LOG, ("h%2d gen %d region %p allocated %zdkB committed %zdkB reduce_commit by %zdkB", - heap_number, - gen_number, - get_region_start (tail_region), - (heap_segment_allocated (tail_region) - get_region_start (tail_region))/1024, - (heap_segment_committed (tail_region) - get_region_start (tail_region))/1024, - (heap_segment_committed (tail_region) - decommit_target)/1024)); - } - dprintf(3, ("h%2d gen %d allocated: %zdkB committed: %zdkB target: %zdkB", - heap_number, - gen_number, - (heap_segment_allocated (tail_region) - heap_segment_mem (tail_region))/1024, - (heap_segment_committed (tail_region) - heap_segment_mem (tail_region))/1024, - (decommit_target - heap_segment_mem (tail_region))/1024)); + heap_segment_decommit_target (tail_region) = get_smoothed_decommit_target (previous_decommit_target, decommit_target, tail_region); } #elif !defined(USE_REGIONS) - dynamic_data* dd0 = dynamic_data_of (0); ptrdiff_t desired_allocation = dd_new_allocation (dd0) + @@ -44074,29 +44553,15 @@ void gc_heap::decommit_ephemeral_segment_pages() desired_allocation; #endif // HOST_64BIT - uint8_t *decommit_target = heap_segment_allocated (ephemeral_heap_segment) + slack_space; - if (decommit_target < heap_segment_decommit_target (ephemeral_heap_segment)) - { - // we used to have a higher target - do exponential smoothing by computing - // essentially decommit_target = 1/3*decommit_target + 2/3*previous_decommit_target - // computation below is slightly different to avoid overflow - ptrdiff_t target_decrease = heap_segment_decommit_target (ephemeral_heap_segment) - decommit_target; - decommit_target += target_decrease * 2 / 3; - } + uint8_t* decommit_target = heap_segment_allocated (ephemeral_heap_segment) + slack_space; + uint8_t* previous_decommit_target = heap_segment_decommit_target (ephemeral_heap_segment); + heap_segment_decommit_target (ephemeral_heap_segment) = get_smoothed_decommit_target (previous_decommit_target, decommit_target, ephemeral_heap_segment); - heap_segment_decommit_target (ephemeral_heap_segment) = decommit_target; - -#ifdef MULTIPLE_HEAPS - if (decommit_target < heap_segment_committed (ephemeral_heap_segment)) - { - gradual_decommit_in_progress_p = TRUE; - } -#ifdef _DEBUG +#if defined(MULTIPLE_HEAPS) && defined(_DEBUG) // these are only for checking against logic errors ephemeral_heap_segment->saved_committed = heap_segment_committed (ephemeral_heap_segment); ephemeral_heap_segment->saved_desired_allocation = dd_desired_allocation (dd0); -#endif // _DEBUG -#endif // MULTIPLE_HEAPS +#endif //MULTIPLE_HEAPS && _DEBUG #ifndef MULTIPLE_HEAPS // we want to limit the amount of decommit we do per time to indirectly @@ -44120,7 +44585,9 @@ void gc_heap::decommit_ephemeral_segment_pages() current_gc_data_per_heap->extra_gen0_committed = heap_segment_committed (ephemeral_heap_segment) - heap_segment_allocated (ephemeral_heap_segment); #endif //MULTIPLE_HEAPS && USE_REGIONS } +#endif //!USE_REGIONS || MULTIPLE_HEAPS +#if defined(MULTIPLE_HEAPS) || defined(USE_REGIONS) // return true if we actually decommitted anything bool gc_heap::decommit_step (uint64_t step_milliseconds) { @@ -44167,6 +44634,7 @@ bool gc_heap::decommit_step (uint64_t step_milliseconds) #endif //MULTIPLE_HEAPS return (decommit_size != 0); } +#endif //MULTIPLE_HEAPS || USE_REGIONS #ifdef USE_REGIONS size_t gc_heap::decommit_region (heap_segment* region, int bucket, int h_number) @@ -44255,11 +44723,6 @@ size_t gc_heap::decommit_ephemeral_segment_pages_step () uint8_t* decommit_target = heap_segment_decommit_target (seg); size_t EXTRA_SPACE = 2 * OS_PAGE_SIZE; decommit_target += EXTRA_SPACE; -#ifdef STRESS_DECOMMIT - // our decommit logic should work for a random decommit target within tail_region - make sure it does - // tail region now may be different from what decommit_ephemeral_segment_pages saw - decommit_target = heap_segment_mem (seg) + gc_rand::get_rand (heap_segment_reserved (seg) - heap_segment_mem (seg)); -#endif //STRESS_DECOMMIT uint8_t* committed = heap_segment_committed (seg); uint8_t* allocated = (seg == ephemeral_heap_segment) ? alloc_allocated : heap_segment_allocated (seg); if ((allocated <= decommit_target) && (decommit_target < committed)) @@ -44303,9 +44766,9 @@ size_t gc_heap::decommit_ephemeral_segment_pages_step () uint8_t* new_committed = (committed - decommit_size); size += decommit_heap_segment_pages_worker (seg, new_committed); -#ifdef _DEBUG +#if defined(_DEBUG) && !defined(USE_REGIONS) seg->saved_committed = committed - size; -#endif // _DEBUG +#endif //_DEBUG && !USE_REGIONS } #ifdef USE_REGIONS if (gen_number == soh_gen0) @@ -45725,20 +46188,41 @@ void gc_heap::background_sweep() concurrent_print_time_delta ("Sw"); dprintf (2, ("---- (GC%zu)Background Sweep Phase ----", VolatileLoad(&settings.gc_index))); + bool rebuild_maxgen_fl_p = true; + +#ifdef DOUBLY_LINKED_FL +#ifdef DYNAMIC_HEAP_COUNT + rebuild_maxgen_fl_p = trigger_bgc_for_rethreading_p; +#else + rebuild_maxgen_fl_p = false; +#endif //DYNAMIC_HEAP_COUNT +#endif //DOUBLY_LINKED_FL + for (int i = 0; i <= max_generation; i++) { generation* gen_to_reset = generation_of (i); + + bool clear_fl_p = true; + #ifdef DOUBLY_LINKED_FL if (i == max_generation) { - dprintf (2, ("h%d: gen2 still has FL: %zd, FO: %zd", + clear_fl_p = rebuild_maxgen_fl_p; + + dprintf (6666, ("h%d: gen2 still has FL: %zd, FO: %zd, clear gen2 FL %s", heap_number, generation_free_list_space (gen_to_reset), - generation_free_obj_space (gen_to_reset))); + generation_free_obj_space (gen_to_reset), + (clear_fl_p ? "yes" : "no"))); } - else #endif //DOUBLY_LINKED_FL + + if (clear_fl_p) { + if (i == max_generation) + { + dprintf (6666, ("clearing g2 FL for h%d!", heap_number)); + } generation_allocator (gen_to_reset)->clear(); generation_free_list_space (gen_to_reset) = 0; generation_free_obj_space (gen_to_reset) = 0; @@ -45999,7 +46483,7 @@ void gc_heap::background_sweep() next_sweep_obj = o + size_o; #ifdef DOUBLY_LINKED_FL - if (gen != large_object_generation) + if ((i == max_generation) && !rebuild_maxgen_fl_p) { if (method_table (o) == g_gc_pFreeObjectMethodTable) { @@ -47503,10 +47987,6 @@ void gc_heap::verify_committed_bytes_per_heap() void gc_heap::verify_committed_bytes() { -#ifndef USE_REGIONS - // TODO, https://github.com/dotnet/runtime/issues/102706, re-enable the testing after fixing this bug - return; -#endif //!USE_REGIONS size_t total_committed = 0; size_t committed_decommit; // unused size_t committed_free; // unused @@ -48706,6 +49186,12 @@ HRESULT GCHeap::Initialize() #endif //USE_REGIONS if (hr == S_OK) { +#ifdef MULTIPLE_HEAPS + dprintf (6666, ("conserve mem %d, concurent %d, max heap %d", gc_heap::conserve_mem_setting, gc_heap::gc_can_use_concurrent, gc_heap::n_heaps)); +#else + dprintf (6666, ("conserve mem %d, concurent %d, WKS", gc_heap::conserve_mem_setting, gc_heap::gc_can_use_concurrent)); +#endif + #ifdef DYNAMIC_HEAP_COUNT // if no heap count was specified, and we are told to adjust heap count dynamically ... if (gc_heap::dynamic_adaptation_mode == dynamic_adaptation_to_application_sizes) @@ -49929,22 +50415,39 @@ void gc_heap::do_pre_gc() #endif //BACKGROUND_GC #ifdef TRACE_GC - size_t total_allocated_since_last_gc = get_total_allocated_since_last_gc(); + size_t total_allocated_since_last_gc[total_oh_count]; + get_total_allocated_since_last_gc (total_allocated_since_last_gc); + #ifdef BACKGROUND_GC - dprintf (1, (ThreadStressLog::gcDetailedStartMsg(), + size_t heap_size_before = get_total_heap_size(); + uint64_t start_gc_time = GetHighPrecisionTimeStamp(); + uint64_t elapsed_since_last_gc_us = start_gc_time - last_alloc_reset_suspended_end_time; + max_peak_heap_size = max (max_peak_heap_size, heap_size_before); + + dprintf (6666, (ThreadStressLog::gcDetailedStartMsg(), VolatileLoad(&settings.gc_index), dd_collection_count (hp->dynamic_data_of (0)), settings.condemned_generation, - total_allocated_since_last_gc, + (elapsed_since_last_gc_us / 1000.0), + total_allocated_since_last_gc[gc_oh_num::soh], + (dd_desired_allocation (hp->dynamic_data_of (0)) * n_heaps), + dd_desired_allocation (hp->dynamic_data_of (0)), + (elapsed_since_last_gc_us ? (total_allocated_since_last_gc[gc_oh_num::soh] / 1000.0 / elapsed_since_last_gc_us) : 0), + total_allocated_since_last_gc[gc_oh_num::loh], + (elapsed_since_last_gc_us ? (total_allocated_since_last_gc[gc_oh_num::loh] / 1000.0 / elapsed_since_last_gc_us) : 0), + total_allocated_since_last_gc[gc_oh_num::poh], + (elapsed_since_last_gc_us ? (total_allocated_since_last_gc[gc_oh_num::poh] / 1000.0 / elapsed_since_last_gc_us) : 0), (settings.concurrent ? "BGC" : (gc_heap::background_running_p() ? "FGC" : "NGC")), settings.b_state, - n_heaps)); + n_heaps, + (heap_size_before / 1000.0 / 1000.0), + (max_peak_heap_size / 1000.0 / 1000.0))); #else dprintf (1, ("*GC* %d(gen0:%d)(%d)(alloc: %zd)", VolatileLoad(&settings.gc_index), dd_collection_count(hp->dynamic_data_of(0)), settings.condemned_generation, - total_allocated_since_last_gc)); + (total_allocated_since_last_gc[0] + total_allocated_since_last_gc[1] + total_allocated_since_last_gc[2]))); #endif //BACKGROUND_GC if (heap_hard_limit) @@ -50370,10 +50873,10 @@ void gc_heap::do_post_gc() const char* str_gc_type = "NGC"; #endif //BACKGROUND_GC - dprintf (1, (ThreadStressLog::gcDetailedEndMsg(), + dprintf (6666, (ThreadStressLog::gcDetailedEndMsg(), VolatileLoad (&settings.gc_index), dd_collection_count (hp->dynamic_data_of (0)), - (size_t)(GetHighPrecisionTimeStamp () / 1000), + (get_total_heap_size() / 1000.0 / 1000.0), settings.condemned_generation, str_gc_type, (settings.compaction ? "C" : "S"), @@ -51215,6 +51718,8 @@ size_t gc_heap::get_gen0_min_size() int n_heaps = 1; #endif //SERVER_GC + llc_size = trueSize; + #ifdef DYNAMIC_HEAP_COUNT if (dynamic_adaptation_mode == dynamic_adaptation_to_application_sizes) { @@ -53103,3 +53608,5 @@ size_t gc_heap::get_mark_array_size (heap_segment* seg) return 0; } #endif //USE_REGIONS + +} diff --git a/src/coreclr/gc/gcdesc.h b/src/coreclr/gc/gcdesc.h index 8d91e776ac4..6c3b86af8bb 100644 --- a/src/coreclr/gc/gcdesc.h +++ b/src/coreclr/gc/gcdesc.h @@ -160,9 +160,9 @@ class CGCDesc { // If it doesn't contain pointers, there isn't a GCDesc PTR_MethodTable mt(pMT); - +#ifndef SOS_INCLUDE _ASSERTE(mt->ContainsGCPointers()); - +#endif return PTR_CGCDesc(mt); } diff --git a/src/coreclr/gc/gcee.cpp b/src/coreclr/gc/gcee.cpp index b48632cf069..283c9055d6b 100644 --- a/src/coreclr/gc/gcee.cpp +++ b/src/coreclr/gc/gcee.cpp @@ -7,6 +7,35 @@ // sets up vars for GC +#include "common.h" +#include "gcenv.h" + +#include "gc.h" +#include "gcscan.h" +#include "gchandletableimpl.h" +#include "gceventstatus.h" + +#ifdef __INTELLISENSE__ +#if defined(FEATURE_SVR_GC) + +#define SERVER_GC 1 + +#else // defined(FEATURE_SVR_GC) + +#ifdef SERVER_GC +#undef SERVER_GC +#endif + +#endif // defined(FEATURE_SVR_GC) +#endif // __INTELLISENSE__ + +#ifdef SERVER_GC +namespace SVR { +#else // SERVER_GC +namespace WKS { +#endif // SERVER_GC + +#include "gcimpl.h" #include "gcpriv.h" #ifndef DACCESS_COMPILE @@ -540,4 +569,4 @@ uint64_t GCHeap::GetGenerationBudget(int generation) #endif // !DACCESS_COMPILE - +} diff --git a/src/coreclr/gc/gceesvr.cpp b/src/coreclr/gc/gceesvr.cpp index be7c129cc3f..9b37a77b0ae 100644 --- a/src/coreclr/gc/gceesvr.cpp +++ b/src/coreclr/gc/gceesvr.cpp @@ -1,25 +1,7 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. - - -#include "common.h" - #if defined(FEATURE_SVR_GC) - -#include "gcenv.h" - -#include "gc.h" -#include "gcscan.h" -#include "gchandletableimpl.h" -#include "gceventstatus.h" - #define SERVER_GC 1 - - -namespace SVR { -#include "gcimpl.h" #include "gcee.cpp" -} - #endif // FEATURE_SVR_GC diff --git a/src/coreclr/gc/gceewks.cpp b/src/coreclr/gc/gceewks.cpp index 203464ab6b5..d0e275be2bb 100644 --- a/src/coreclr/gc/gceewks.cpp +++ b/src/coreclr/gc/gceewks.cpp @@ -1,23 +1,8 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. - - -#include "common.h" - -#include "gcenv.h" - -#include "gc.h" -#include "gcscan.h" -#include "gchandletableimpl.h" -#include "gceventstatus.h" - #ifdef SERVER_GC #undef SERVER_GC #endif -namespace WKS { -#include "gcimpl.h" #include "gcee.cpp" -} - diff --git a/src/coreclr/gc/gcevent_serializers.h b/src/coreclr/gc/gcevent_serializers.h index a5cfe34f42e..707df8ec8d6 100644 --- a/src/coreclr/gc/gcevent_serializers.h +++ b/src/coreclr/gc/gcevent_serializers.h @@ -101,9 +101,10 @@ struct EventSerializationTraits static void Serialize(const uint16_t& value, uint8_t** buffer) { #if defined(BIGENDIAN) - **((uint16_t**)buffer) = ByteSwap16(value); + uint16_t swapped = ByteSwap16(value); + memcpy(*buffer, &swapped, sizeof(uint16_t)); #else - **((uint16_t**)buffer) = value; + memcpy(*buffer, &value, sizeof(uint16_t)); #endif // BIGENDIAN *buffer += sizeof(uint16_t); } @@ -120,9 +121,10 @@ struct EventSerializationTraits static void Serialize(const uint32_t& value, uint8_t** buffer) { #if defined(BIGENDIAN) - **((uint32_t**)buffer) = ByteSwap32(value); + uint32_t swapped = ByteSwap32(value); + memcpy(*buffer, &swapped, sizeof(uint32_t)); #else - **((uint32_t**)buffer) = value; + memcpy(*buffer, &value, sizeof(uint32_t)); #endif // BIGENDIAN *buffer += sizeof(uint32_t); } @@ -139,9 +141,10 @@ struct EventSerializationTraits static void Serialize(const uint64_t& value, uint8_t** buffer) { #if defined(BIGENDIAN) - **((uint32_t**)buffer) = ByteSwap64(value); + uint64_t swapped = ByteSwap64(value); + memcpy(*buffer, &swapped, sizeof(uint64_t)); #else - **((uint64_t**)buffer) = value; + memcpy(*buffer, &value, sizeof(uint64_t)); #endif // BIGENDIAN *buffer += sizeof(uint64_t); } @@ -157,7 +160,7 @@ struct EventSerializationTraits { static void Serialize(const float& value, uint8_t** buffer) { - **((float**)buffer) = value; + memcpy(*buffer, &value, sizeof(float)); *buffer += sizeof(float); } diff --git a/src/coreclr/gc/gcinterface.h b/src/coreclr/gc/gcinterface.h index 64fcb5048e8..6014845e1d8 100644 --- a/src/coreclr/gc/gcinterface.h +++ b/src/coreclr/gc/gcinterface.h @@ -483,6 +483,8 @@ typedef enum * are scanned as strong roots during each GC but only during full GCs would the size * be calculated. * + * NOTE: HNDTYPE_SIZEDREF is no longer used in the VM starting .NET 9 + * but we are keeping it here for backward compatibility purposes" */ HNDTYPE_SIZEDREF = 8, diff --git a/src/coreclr/gc/gcpriv.h b/src/coreclr/gc/gcpriv.h index f50ee1655a8..c70186b8a27 100644 --- a/src/coreclr/gc/gcpriv.h +++ b/src/coreclr/gc/gcpriv.h @@ -585,6 +585,53 @@ enum gc_dynamic_adaptation_mode dynamic_adaptation_default = 0, dynamic_adaptation_to_application_sizes = 1, }; + +enum hc_record_stage +{ + hc_record_set_last_heaps = 0, + hc_record_before_check_timeout = 1, + hc_record_before_check_gc_start = 2, + hc_record_change_done = 3, + hc_record_still_active = 4, + hc_record_became_active = 5, + hc_record_became_inactive = 6, + hc_record_inactive_waiting = 7, + hc_record_check_cancelled_prep = 8, +#ifdef BACKGROUND_GC + hc_record_check_cancelled_bgc = 9, + hc_record_bgc_active = 10, + hc_record_bgc_inactive = 11, +#endif //BACKGROUND_GC +}; + +struct hc_history +{ + size_t gc_index; + short stage; + short last_n_heaps; + short n_heaps; + short new_n_heaps; + short idle_thread_count; + short gc_t_join_n_threads; + short gc_t_join_join_lock; +#ifdef BACKGROUND_GC + short bgc_t_join_n_threads; + // We have observed a problem on Windows in production where GC indicates a BGC thread was created successfully yet we have + // invalid fields on the Thread object such as m_OSThreadId. This is to help with debugging that problem so I + // only enable it for retail builds on Windows. We can extend this with a GCToEEInterface interface method to get the offset + // of that particular field on the Thread object. +#if defined(TARGET_AMD64) && defined(TARGET_WINDOWS) && !defined(_DEBUG) + int bgc_thread_os_id; +#endif + short bgc_t_join_join_lock; +#endif //BACKGROUND_GC + bool gc_t_join_joined_p; +#ifdef BACKGROUND_GC + bool bgc_t_join_joined_p; + bool concurrent_p; + bool bgc_thread_running; +#endif //BACKGROUND_GC +}; #endif //DYNAMIC_HEAP_COUNT //encapsulates the mechanism for the current gc @@ -1686,6 +1733,11 @@ class gc_heap PER_HEAP_ISOLATED_METHOD void verify_region_to_generation_map(); PER_HEAP_ISOLATED_METHOD void compute_gc_and_ephemeral_range (int condemned_gen_number, bool end_of_gc_p); + + PER_HEAP_ISOLATED_METHOD void distribute_free_regions(); + + PER_HEAP_ISOLATED_METHOD void age_free_regions (const char* msg); + #ifdef STRESS_REGIONS PER_HEAP_METHOD void pin_by_gc (uint8_t* object); #endif //STRESS_REGIONS @@ -2112,6 +2164,9 @@ class gc_heap PER_HEAP_METHOD void walk_survivors_relocation (void* profiling_context, record_surv_fn fn); PER_HEAP_METHOD void walk_survivors_for_uoh (void* profiling_context, record_surv_fn fn, int gen_number); + PER_HEAP_ISOLATED_METHOD size_t generation_allocator_efficiency_percent (generation* inst); + PER_HEAP_ISOLATED_METHOD size_t generation_unusable_fragmentation (generation* inst, int hn); + PER_HEAP_METHOD int generation_to_condemn (int n, BOOL* blocking_collection_p, BOOL* elevation_requested_p, @@ -2385,11 +2440,23 @@ class gc_heap ); PER_HEAP_METHOD void reset_heap_segment_pages (heap_segment* seg); PER_HEAP_METHOD void decommit_heap_segment_pages (heap_segment* seg, size_t extra_space); + #if defined(MULTIPLE_HEAPS) PER_HEAP_METHOD size_t decommit_ephemeral_segment_pages_step (); #endif //MULTIPLE_HEAPS PER_HEAP_METHOD size_t decommit_heap_segment_pages_worker (heap_segment* seg, uint8_t *new_committed); + +#if !defined(USE_REGIONS) || defined(MULTIPLE_HEAPS) + PER_HEAP_METHOD uint8_t* get_smoothed_decommit_target (uint8_t* previous_decommit_target, + uint8_t* new_decommit_target, heap_segment* seg); + + PER_HEAP_METHOD void decommit_ephemeral_segment_pages(); +#endif //!USE_REGIONS || MULTIPLE_HEAPS + +#if defined(MULTIPLE_HEAPS) || defined(USE_REGIONS) PER_HEAP_ISOLATED_METHOD bool decommit_step (uint64_t step_milliseconds); +#endif //MULTIPLE_HEAPS || USE_REGIONS + #ifdef USE_REGIONS PER_HEAP_ISOLATED_METHOD size_t decommit_region (heap_segment* region, int bucket, int h_number); #endif //USE_REGIONS @@ -2412,8 +2479,6 @@ class gc_heap PER_HEAP_METHOD void rearrange_heap_segments(BOOL compacting); #endif //!USE_REGIONS PER_HEAP_METHOD void delay_free_segments(); - PER_HEAP_ISOLATED_METHOD void distribute_free_regions(); - PER_HEAP_ISOLATED_METHOD void age_free_regions(const char* label); #ifdef BACKGROUND_GC PER_HEAP_ISOLATED_METHOD void reset_write_watch_for_gc_heap(void* base_address, size_t region_size); PER_HEAP_ISOLATED_METHOD void get_write_watch_for_gc_heap(bool reset, void *base_address, size_t region_size, void** dirty_pages, uintptr_t* dirty_page_count_ref, bool is_runtime_suspended); @@ -2593,6 +2658,21 @@ class gc_heap PER_HEAP_METHOD bool change_heap_count (int new_n_heaps); PER_HEAP_ISOLATED_METHOD void get_msl_wait_time (size_t* soh_msl_wait_time, size_t* uoh_msl_wait_time); + + PER_HEAP_ISOLATED_METHOD void process_datas_sample(); + + PER_HEAP_METHOD void add_to_hc_history_worker (hc_history* hist, int* current_index, hc_record_stage stage, const char* msg); + + PER_HEAP_METHOD void add_to_hc_history (hc_record_stage stage); + +#ifdef BACKGROUND_GC + PER_HEAP_METHOD void add_to_bgc_hc_history (hc_record_stage stage); + + PER_HEAP_ISOLATED_METHOD void add_to_bgc_th_creation_history (size_t gc_index, + size_t count_created, + size_t count_created_th_existed, + size_t count_creation_failed); +#endif //BACKGROUND_GC #endif //DYNAMIC_HEAP_COUNT #endif //USE_REGIONS @@ -3076,8 +3156,6 @@ class gc_heap PER_HEAP_METHOD ptrdiff_t estimate_gen_growth (int gen); - PER_HEAP_METHOD void decommit_ephemeral_segment_pages(); - #ifdef HOST_64BIT PER_HEAP_ISOLATED_METHOD size_t trim_youngest_desired (uint32_t memory_load, size_t total_new_allocation, @@ -3106,7 +3184,7 @@ class gc_heap size_t allocated_size, size_t* etw_allocation_amount); // this also resets allocated_since_last_gc - PER_HEAP_ISOLATED_METHOD size_t get_total_allocated_since_last_gc(); + PER_HEAP_ISOLATED_METHOD void get_total_allocated_since_last_gc (size_t oh_allocated[total_oh_count]); PER_HEAP_METHOD size_t get_current_allocated(); PER_HEAP_ISOLATED_METHOD size_t get_total_allocated(); PER_HEAP_ISOLATED_METHOD size_t get_total_promoted(); @@ -3676,7 +3754,6 @@ class gc_heap PER_HEAP_FIELD_SINGLE_GC_ALLOC size_t bgc_loh_size_increased; PER_HEAP_FIELD_SINGLE_GC_ALLOC size_t bgc_poh_size_increased; - // Updated by the allocator and reinit-ed in each BGC PER_HEAP_FIELD_SINGLE_GC_ALLOC size_t background_soh_alloc_count; PER_HEAP_FIELD_SINGLE_GC_ALLOC size_t background_uoh_alloc_count; @@ -3684,6 +3761,10 @@ class gc_heap PER_HEAP_FIELD_SINGLE_GC_ALLOC VOLATILE(int32_t) uoh_alloc_thread_count; #endif //BACKGROUND_GC +#ifdef STRESS_DYNAMIC_HEAP_COUNT + PER_HEAP_FIELD_SINGLE_GC_ALLOC bool uoh_msl_before_gc_p; +#endif //STRESS_DYNAMIC_HEAP_COUNT + /************************************/ // PER_HEAP_FIELD_MAINTAINED fields // /************************************/ @@ -3953,6 +4034,17 @@ class gc_heap #endif //STRESS_REGIONS #endif //USE_REGIONS +#ifdef DYNAMIC_HEAP_COUNT +#define max_hc_history_count 16 + PER_HEAP_FIELD_DIAG_ONLY int hchist_index_per_heap; + PER_HEAP_FIELD_DIAG_ONLY hc_history hchist_per_heap[max_hc_history_count]; + +#ifdef BACKGROUND_GC + PER_HEAP_FIELD_DIAG_ONLY int bgc_hchist_index_per_heap; + PER_HEAP_FIELD_DIAG_ONLY hc_history bgc_hchist_per_heap[max_hc_history_count]; +#endif //BACKGROUND_GC +#endif //DYNAMIC_HEAP_COUNT + #ifdef FEATURE_EVENT_TRACE #define max_etw_item_count 2000 @@ -4148,9 +4240,13 @@ class gc_heap PER_HEAP_ISOLATED_FIELD_SINGLE_GC uint8_t* gc_high; // high end of the highest region being condemned #endif //USE_REGIONS +#ifdef DYNAMIC_HEAP_COUNT + PER_HEAP_ISOLATED_FIELD_SINGLE_GC uint64_t before_distribute_free_regions_time; + #ifdef STRESS_DYNAMIC_HEAP_COUNT PER_HEAP_ISOLATED_FIELD_SINGLE_GC int heaps_in_this_gc; #endif //STRESS_DYNAMIC_HEAP_COUNT +#endif //DYNAMIC_HEAP_COUNT /**************************************************/ // PER_HEAP_ISOLATED_FIELD_SINGLE_GC_ALLOC fields // @@ -4367,7 +4463,8 @@ class gc_heap { int adjustment_idx = (current_adjustment_index + recorded_adjustment_size + distance_to_current) % recorded_adjustment_size; adjustment* adj = &adjustment_history[adjustment_idx]; - dprintf (6666, ("adj->metric %d, metric %d, adj#%d: hc_change > 0 = %d, change_int > 0 = %d", + dprintf (6666, ("adj->metric %s, metric %s, adj#%d: hc_change > 0 = %d, change_int > 0 = %d", + str_adjust_metrics[adj->metric], str_adjust_metrics[metric], adjustment_idx, (adj->hc_change > 0), (change_int > 0))); if ((adj->metric == metric) && ((change_int > 0) == (adj->hc_change > 0))) { @@ -4973,13 +5070,16 @@ class gc_heap size_t total_budget_old_gen = compute_total_gen0_budget (total_soh_stable_size); size_t budget_old_gen_per_heap = total_budget_old_gen / n_heaps; budget_old_gen_per_heap = Align (budget_old_gen_per_heap, get_alignment_constant (TRUE)); - - dprintf (6666, ("-> %Id / heap (% .3fmb)", - budget_old_gen_per_heap, ((double)budget_old_gen_per_heap / 1000.0 / 1000.0))); + size_t saved_budget_old_gen_per_heap = budget_old_gen_per_heap; budget_old_gen_per_heap = min (max_gen0_new_allocation, budget_old_gen_per_heap); budget_old_gen_per_heap = max (min_gen0_new_allocation, budget_old_gen_per_heap); + dprintf (6666, ("BCD: %Id/heap (%.3fmb) -> %.3fmb, BCS %Id/heap (%.3fmb)", + saved_budget_old_gen_per_heap, ((double)saved_budget_old_gen_per_heap / 1000.0 / 1000.0), + ((double)budget_old_gen_per_heap / 1000.0 / 1000.0), + bcs_per_heap, ((double)bcs_per_heap / 1000.0 / 1000.0))); + // We want to return a number between bcs and bcd if (bcs_per_heap < budget_old_gen_per_heap) { @@ -5048,6 +5148,7 @@ class gc_heap // Recording the gen2 GC indices so we know how far apart they are. Currently unused // but we should consider how much value there is if they are very far apart. size_t gc_index; + uint64_t gc_duration; // This is (gc_elapsed_time / time inbetween this and the last gen2 GC) float gc_percent; }; @@ -5059,6 +5160,19 @@ class gc_heap size_t processed_gen2_samples_count; size_t gen2_last_changed_sample_count; + gen2_sample& get_last_gen2_sample() + { + int last_sample_index = (gen2_sample_index + sample_size - 1) % sample_size; + gen2_sample& s = gen2_samples[last_sample_index]; + return s; + } + + gen2_sample& get_current_gen2_sample() + { + gen2_sample& s = gen2_samples[gen2_sample_index]; + return s; + } + int new_n_heaps; // the heap count we changed from int last_n_heaps; @@ -5080,9 +5194,18 @@ class gc_heap PER_HEAP_ISOLATED_FIELD_MAINTAINED dynamic_heap_count_data_t dynamic_heap_count_data; PER_HEAP_ISOLATED_FIELD_MAINTAINED size_t current_total_soh_stable_size; PER_HEAP_ISOLATED_FIELD_MAINTAINED uint64_t last_suspended_end_time; + PER_HEAP_ISOLATED_FIELD_MAINTAINED uint64_t change_heap_count_time; + // If the last full GC is blocking, this is that GC's index; for BGC, this is the settings.gc_index // when the BGC ended. PER_HEAP_ISOLATED_FIELD_MAINTAINED size_t gc_index_full_gc_end; + + PER_HEAP_ISOLATED_FIELD_MAINTAINED bool trigger_initial_gen2_p; +#ifdef BACKGROUND_GC + // This is set when change_heap_count wants the next GC to be a BGC for rethreading gen2 FL + // and reset during that BGC. + PER_HEAP_ISOLATED_FIELD_MAINTAINED bool trigger_bgc_for_rethreading_p; +#endif //BACKGROUND_GC #endif //DYNAMIC_HEAP_COUNT /****************************************************/ @@ -5274,15 +5397,20 @@ class gc_heap // at the beginning of a BGC and the PM triggered full GCs // fall into this case. PER_HEAP_ISOLATED_FIELD_DIAG_ONLY uint64_t suspended_start_time; - // Right now this is diag only but may be used functionally later. - PER_HEAP_ISOLATED_FIELD_DIAG_ONLY uint64_t change_heap_count_time; - // TEMP END PER_HEAP_ISOLATED_FIELD_DIAG_ONLY uint64_t end_gc_time; PER_HEAP_ISOLATED_FIELD_DIAG_ONLY uint64_t total_suspended_time; PER_HEAP_ISOLATED_FIELD_DIAG_ONLY uint64_t process_start_time; PER_HEAP_ISOLATED_FIELD_DIAG_ONLY last_recorded_gc_info last_ephemeral_gc_info; PER_HEAP_ISOLATED_FIELD_DIAG_ONLY last_recorded_gc_info last_full_blocking_gc_info; + // The following fields are for the dprintf in do_pre_gc. + PER_HEAP_ISOLATED_FIELD_DIAG_ONLY uint64_t last_alloc_reset_suspended_end_time; + PER_HEAP_ISOLATED_FIELD_DIAG_ONLY size_t max_peak_heap_size; + + // Sometimes it's difficult to figure out why we get the gen0 min/max budget. + // These fields help figure those out. Making it volatile so it doesn't get optimized out. + PER_HEAP_ISOLATED_FIELD_DIAG_ONLY VOLATILE(size_t) llc_size; + #ifdef BACKGROUND_GC PER_HEAP_ISOLATED_FIELD_DIAG_ONLY gc_history_global bgc_data_global; @@ -5311,6 +5439,43 @@ class gc_heap PER_HEAP_ISOLATED_FIELD_DIAG_ONLY VOLATILE(bool) is_last_recorded_bgc; #endif //BACKGROUND_GC +#ifdef DYNAMIC_HEAP_COUNT + // Number of times we bailed from check_heap_count because we didn't have enough memory for the preparation + PER_HEAP_ISOLATED_FIELD_DIAG_ONLY size_t hc_change_cancelled_count_prep; + PER_HEAP_ISOLATED_FIELD_DIAG_ONLY uint64_t total_change_heap_count; + PER_HEAP_ISOLATED_FIELD_DIAG_ONLY uint64_t total_change_heap_count_time; + +#ifdef BACKGROUND_GC + // We log an entry whenever we needed to create new BGC threads. + struct bgc_thread_creation_history + { + size_t gc_index; + short n_heaps; + short count_created; + // bgc_thread_running was false but bgc_thread was true. + short count_created_th_existed; + short count_creation_failed; + }; + +#define max_bgc_thread_creation_count 16 + PER_HEAP_ISOLATED_FIELD_DIAG_ONLY int bgc_th_creation_hist_index; + PER_HEAP_ISOLATED_FIELD_DIAG_ONLY bgc_thread_creation_history bgc_th_creation_hist[max_bgc_thread_creation_count]; + + PER_HEAP_ISOLATED_FIELD_DIAG_ONLY size_t bgc_th_count_created; + PER_HEAP_ISOLATED_FIELD_DIAG_ONLY size_t bgc_th_count_created_th_existed; + PER_HEAP_ISOLATED_FIELD_DIAG_ONLY size_t bgc_th_count_creation_failed; + + // The gc index of the very first BGC that happened. + PER_HEAP_ISOLATED_FIELD_DIAG_ONLY size_t bgc_init_gc_index; + // The number of heaps during that first BGC. Making it volatile so it doesn't get optimized out. + PER_HEAP_ISOLATED_FIELD_DIAG_ONLY VOLATILE(short) bgc_init_n_heaps; + + // Number of times we bailed from check_heap_count because we noticed BGC is in progress even + // though it was not in progress when we check before calling it. + PER_HEAP_ISOLATED_FIELD_DIAG_ONLY size_t hc_change_cancelled_count_bgc; +#endif //BACKGROUND_GC +#endif //DYNAMIC_HEAP_COUNT + #ifdef FEATURE_EVENT_TRACE // Initialized each time in mark_phase and background_mark_phase (during the 2nd non concurrent stage) PER_HEAP_ISOLATED_FIELD_DIAG_ONLY bool informational_event_enabled_p; @@ -5387,10 +5552,6 @@ class gc_heap PER_HEAP_ISOLATED_FIELD_DIAG_ONLY BOOL heap_analyze_enabled; #endif //HEAP_ANALYZE -#if defined(MULTIPLE_HEAPS) && defined(STRESS_DYNAMIC_HEAP_COUNT) - PER_HEAP_FIELD bool uoh_msl_before_gc_p; -#endif //MULTIPLE_HEAPS && STRESS_DYNAMIC_HEAP_COUNT - /***************************************************/ // Fields that don't fit into the above categories // /***************************************************/ @@ -5827,6 +5988,12 @@ size_t& generation_sweep_allocated (generation* inst) { return inst->sweep_allocated; } +// These are allocations we did while doing planning, we use this to calculate free list efficiency. +inline +size_t generation_total_plan_allocated (generation* inst) +{ + return (inst->free_list_allocated + inst->end_seg_allocated + inst->condemned_allocated); +} #ifdef DOUBLY_LINKED_FL inline BOOL& generation_set_bgc_mark_bit_p (generation* inst) @@ -5857,32 +6024,6 @@ size_t& generation_allocated_since_last_pin (generation* inst) } #endif //FREE_USAGE_STATS -// Return the percentage of efficiency (between 0 and 100) of the allocator. -inline -size_t generation_allocator_efficiency_percent (generation* inst) -{ - // Use integer division to prevent potential floating point exception. - // FPE may occur if we use floating point division because of speculative execution. - uint64_t free_obj_space = generation_free_obj_space (inst); - uint64_t free_list_allocated = generation_free_list_allocated (inst); - if ((free_list_allocated + free_obj_space) == 0) - return 0; - return (size_t)((100 * free_list_allocated) / (free_list_allocated + free_obj_space)); -} - -inline -size_t generation_unusable_fragmentation (generation* inst) -{ - // Use integer division to prevent potential floating point exception. - // FPE may occur if we use floating point division because of speculative execution. - uint64_t free_obj_space = generation_free_obj_space (inst); - uint64_t free_list_allocated = generation_free_list_allocated (inst); - uint64_t free_list_space = generation_free_list_space (inst); - if ((free_list_allocated + free_obj_space) == 0) - return 0; - return (size_t)(free_obj_space + (free_obj_space * free_list_space) / (free_list_allocated + free_obj_space)); -} - #define plug_skew sizeof(ObjHeader) // We always use USE_PADDING_TAIL when fitting so items on the free list should be // twice the min_obj_size. @@ -6012,12 +6153,15 @@ class heap_segment uint8_t* background_allocated; #ifdef MULTIPLE_HEAPS gc_heap* heap; -#ifdef _DEBUG +#if defined(_DEBUG) && !defined(USE_REGIONS) uint8_t* saved_committed; size_t saved_desired_allocation; -#endif // _DEBUG +#endif //_DEBUG && ! USE_REGIONS #endif //MULTIPLE_HEAPS + +#if !defined(USE_REGIONS) || defined(MULTIPLE_HEAPS) uint8_t* decommit_target; +#endif //!USE_REGIONS || MULTIPLE_HEAPS uint8_t* plan_allocated; // In the plan phase we change the allocated for a seg but we need this // value to correctly calculate how much space we can reclaim in @@ -6321,11 +6465,13 @@ uint8_t*& heap_segment_committed (heap_segment* inst) { return inst->committed; } +#if !defined(USE_REGIONS) || defined(MULTIPLE_HEAPS) inline uint8_t*& heap_segment_decommit_target (heap_segment* inst) { return inst->decommit_target; } +#endif //!USE_REGIONS || MULTIPLE_HEAPS inline uint8_t*& heap_segment_used (heap_segment* inst) { diff --git a/src/coreclr/gc/gcscan.cpp b/src/coreclr/gc/gcscan.cpp index 314857130f4..95dab9e11c5 100644 --- a/src/coreclr/gc/gcscan.cpp +++ b/src/coreclr/gc/gcscan.cpp @@ -132,10 +132,12 @@ void GCScan::GcWeakPtrScanBySingleThread( int condemned, int max_gen, ScanContex GCToEEInterface::SyncBlockCacheWeakPtrScan(&CheckPromoted, (uintptr_t)sc, 0); } +#ifdef FEATURE_SIZED_REF_HANDLES void GCScan::GcScanSizedRefs(promote_func* fn, int condemned, int max_gen, ScanContext* sc) { Ref_ScanSizedRefHandles(condemned, max_gen, sc, fn); } +#endif // FEATURE_SIZED_REF_HANDLES void GCScan::GcShortWeakPtrScan(int condemned, int max_gen, ScanContext* sc) { diff --git a/src/coreclr/gc/gcscan.h b/src/coreclr/gc/gcscan.h index 82c687b0c2d..f569d9ff2a8 100644 --- a/src/coreclr/gc/gcscan.h +++ b/src/coreclr/gc/gcscan.h @@ -33,8 +33,9 @@ struct DhContext class GCScan { public: - +#ifdef FEATURE_SIZED_REF_HANDLES static void GcScanSizedRefs(promote_func* fn, int condemned, int max_gen, ScanContext* sc); +#endif // FEATURE_SIZED_REF_HANDLES // Regular stack Roots static void GcScanRoots (promote_func* fn, int condemned, int max_gen, ScanContext* sc); diff --git a/src/coreclr/gc/gcsvr.cpp b/src/coreclr/gc/gcsvr.cpp index 5dc848f40c3..4d54ca2db58 100644 --- a/src/coreclr/gc/gcsvr.cpp +++ b/src/coreclr/gc/gcsvr.cpp @@ -1,32 +1,7 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. - - -#include "common.h" - -#if defined(FEATURE_SVR_GC) - -#include "gcenv.h" - -#include "gc.h" -#include "gcscan.h" -#include "gcdesc.h" -#include "softwarewritewatch.h" -#include "handletable.h" -#include "handletable.inl" -#include "gcenv.inl" -#include "gceventstatus.h" - +#ifdef FEATURE_SVR_GC #define SERVER_GC 1 - -#ifdef TARGET_AMD64 -#include "vxsort/do_vxsort.h" -#endif - -namespace SVR { -#include "gcimpl.h" #include "gc.cpp" -} - -#endif // defined(FEATURE_SVR_GC) +#endif // FEATURE_SVR_GC diff --git a/src/coreclr/gc/gcwks.cpp b/src/coreclr/gc/gcwks.cpp index 6b4cfe16814..886e199a29e 100644 --- a/src/coreclr/gc/gcwks.cpp +++ b/src/coreclr/gc/gcwks.cpp @@ -1,31 +1,8 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. - - -#include "common.h" - -#include "gcenv.h" - -#include "gc.h" -#include "gcscan.h" -#include "gcdesc.h" -#include "softwarewritewatch.h" -#include "handletable.h" -#include "handletable.inl" -#include "gcenv.inl" -#include "gceventstatus.h" - #ifdef SERVER_GC #undef SERVER_GC #endif -#ifdef TARGET_AMD64 -#include "vxsort/do_vxsort.h" -#endif - -namespace WKS { -#include "gcimpl.h" #include "gc.cpp" -} - diff --git a/src/coreclr/gc/handletableconstants.h b/src/coreclr/gc/handletableconstants.h index 0f64c3112d9..a334cc7d564 100644 --- a/src/coreclr/gc/handletableconstants.h +++ b/src/coreclr/gc/handletableconstants.h @@ -10,6 +10,7 @@ #ifdef BUILD_AS_STANDALONE #define FEATURE_ASYNC_PINNED_HANDLES // No longer used in .NET 8+ #define FEATURE_WEAK_NATIVE_COM_HANDLES // No longer used in .NET 8+ +#define FEATURE_SIZED_REF_HANDLES // No longer used in .NET 9+ #endif #define INITIAL_HANDLE_TABLE_ARRAY_SIZE 10 diff --git a/src/coreclr/gc/handletablescan.cpp b/src/coreclr/gc/handletablescan.cpp index e5b27da8e62..276e865518b 100644 --- a/src/coreclr/gc/handletablescan.cpp +++ b/src/coreclr/gc/handletablescan.cpp @@ -1427,7 +1427,14 @@ PTR_TableSegment CALLBACK StandardSegmentIterator(PTR_HandleTable pTable, PTR_Ta #ifndef DACCESS_COMPILE // re-sort the block chains if necessary if (pNextSegment && pNextSegment->fResortChains) + { + // Since this operation can rewrite segment state, it needs to synchronize with any racing + // threads that might be concurrently allocating null handle table slots while running in + // preemptive mode (which happens, e.g., during Thread construction when a native thread + // first enters the runtime). + CrstHolder ch(&pTable->Lock); SegmentResortChains(pNextSegment); + } #endif // return the segment we found diff --git a/src/coreclr/gc/objecthandle.cpp b/src/coreclr/gc/objecthandle.cpp index 0da8c8bb259..6f3bb7a52fa 100644 --- a/src/coreclr/gc/objecthandle.cpp +++ b/src/coreclr/gc/objecthandle.cpp @@ -471,18 +471,20 @@ void CALLBACK ScanPointerForProfilerAndETW(_UNCHECKED_OBJECTREF *pObjRef, uintpt case HNDTYPE_WEAK_INTERIOR_POINTER: #ifdef FEATURE_WEAK_NATIVE_COM_HANDLES case HNDTYPE_WEAK_NATIVE_COM: -#endif // FEATURE_WEAK_NATIVE_COM_HANDLES +#endif rootFlags |= kEtwGCRootFlagsWeakRef; break; case HNDTYPE_STRONG: +#ifdef FEATURE_SIZED_REF_HANDLES case HNDTYPE_SIZEDREF: +#endif break; case HNDTYPE_PINNED: #ifdef FEATURE_ASYNC_PINNED_HANDLES case HNDTYPE_ASYNCPINNED: -#endif // FEATURE_ASYNC_PINNED_HANDLES +#endif rootFlags |= kEtwGCRootFlagsPinning; break; @@ -1103,7 +1105,12 @@ void Ref_TraceNormalRoots(uint32_t condemned, uint32_t maxgen, ScanContext* sc, // promote objects pointed to by strong handles // during ephemeral GCs we also want to promote the ones pointed to by sizedref handles. - uint32_t types[2] = {HNDTYPE_STRONG, HNDTYPE_SIZEDREF}; + uint32_t types[] = { + HNDTYPE_STRONG, +#ifdef FEATURE_SIZED_REF_HANDLES + HNDTYPE_SIZEDREF +#endif + }; uint32_t uTypeCount = (((condemned >= maxgen) && !g_theGCHeap->IsConcurrentGCInProgress()) ? 1 : ARRAY_SIZE(types)); uint32_t flags = (sc->concurrent) ? HNDGCF_ASYNC : HNDGCF_NORMAL; @@ -1480,6 +1487,7 @@ void TraceDependentHandlesBySingleThread(HANDLESCANPROC pfnTrace, uintptr_t lp1, } } +#ifdef FEATURE_SIZED_REF_HANDLES void ScanSizedRefByCPU(uint32_t maxgen, HANDLESCANPROC scanProc, ScanContext* sc, Ref_promote_func* fn, uint32_t flags) { HandleTableMap *walk = &g_HandleTableMap; @@ -1519,6 +1527,7 @@ void Ref_ScanSizedRefHandles(uint32_t condemned, uint32_t maxgen, ScanContext* s ScanSizedRefByCPU(maxgen, CalculateSizedRefSize, sc, fn, flags); } +#endif // FEATURE_SIZED_REF_HANDLES void Ref_CheckAlive(uint32_t condemned, uint32_t maxgen, ScanContext *sc) { @@ -1602,7 +1611,9 @@ void Ref_UpdatePointers(uint32_t condemned, uint32_t maxgen, ScanContext* sc, Re #ifdef FEATURE_WEAK_NATIVE_COM_HANDLES HNDTYPE_WEAK_NATIVE_COM, #endif +#ifdef FEATURE_SIZED_REF_HANDLES HNDTYPE_SIZEDREF, +#endif }; // perform a multi-type scan that updates pointers @@ -1665,7 +1676,9 @@ void Ref_ScanHandlesForProfilerAndETW(uint32_t maxgen, uintptr_t lp1, handle_sca #ifdef FEATURE_ASYNC_PINNED_HANDLES HNDTYPE_ASYNCPINNED, #endif +#ifdef FEATURE_SIZED_REF_HANDLES HNDTYPE_SIZEDREF, +#endif HNDTYPE_WEAK_INTERIOR_POINTER }; @@ -1788,7 +1801,9 @@ void Ref_AgeHandles(uint32_t condemned, uint32_t maxgen, ScanContext* sc) #ifdef FEATURE_ASYNC_PINNED_HANDLES HNDTYPE_ASYNCPINNED, #endif +#ifdef FEATURE_SIZED_REF_HANDLES HNDTYPE_SIZEDREF, +#endif HNDTYPE_WEAK_INTERIOR_POINTER }; @@ -1843,7 +1858,9 @@ void Ref_RejuvenateHandles(uint32_t condemned, uint32_t maxgen, ScanContext* sc) #ifdef FEATURE_ASYNC_PINNED_HANDLES HNDTYPE_ASYNCPINNED, #endif +#ifdef FEATURE_SIZED_REF_HANDLES HNDTYPE_SIZEDREF, +#endif HNDTYPE_WEAK_INTERIOR_POINTER }; @@ -1896,7 +1913,9 @@ void Ref_VerifyHandleTable(uint32_t condemned, uint32_t maxgen, ScanContext* sc) #ifdef FEATURE_ASYNC_PINNED_HANDLES HNDTYPE_ASYNCPINNED, #endif +#ifdef FEATURE_SIZED_REF_HANDLES HNDTYPE_SIZEDREF, +#endif HNDTYPE_DEPENDENT, HNDTYPE_WEAK_INTERIOR_POINTER }; diff --git a/src/coreclr/gcdump/gcdump.cpp b/src/coreclr/gcdump/gcdump.cpp index 84cb0beed9c..8575619db95 100644 --- a/src/coreclr/gcdump/gcdump.cpp +++ b/src/coreclr/gcdump/gcdump.cpp @@ -10,9 +10,9 @@ * to the standard code-manager spec. */ -#ifndef TARGET_UNIX +#if !defined(TARGET_UNIX) && !defined(SOS_INCLUDE) #include "utilcode.h" // For _ASSERTE() -#endif //!TARGET_UNIX +#endif #include "gcdump.h" /*****************************************************************************/ diff --git a/src/coreclr/gcdump/gcdumpnonx86.cpp b/src/coreclr/gcdump/gcdumpnonx86.cpp index 5971da55141..919bf60d886 100644 --- a/src/coreclr/gcdump/gcdumpnonx86.cpp +++ b/src/coreclr/gcdump/gcdumpnonx86.cpp @@ -104,6 +104,7 @@ PCSTR GetRegName (UINT32 regnum) case 29: return "s6"; case 30: return "s7"; case 31: return "s8"; + case 32: return "pc"; } return "???"; @@ -142,6 +143,7 @@ PCSTR GetRegName (UINT32 regnum) case 29: return "t4"; case 30: return "t5"; case 31: return "t6"; + case 32: return "pc"; } return "???"; diff --git a/src/coreclr/gcdump/i386/gcdumpx86.cpp b/src/coreclr/gcdump/i386/gcdumpx86.cpp index ba267bd3470..680504db6f0 100644 --- a/src/coreclr/gcdump/i386/gcdumpx86.cpp +++ b/src/coreclr/gcdump/i386/gcdumpx86.cpp @@ -8,9 +8,9 @@ #ifdef TARGET_X86 /*****************************************************************************/ -#ifndef TARGET_UNIX +#if !defined(TARGET_UNIX) && !defined(SOS_INCLUDE) #include "utilcode.h" // For _ASSERTE() -#endif //!TARGET_UNIX +#endif #include "gcdump.h" @@ -834,10 +834,7 @@ size_t GCDump::DumpGCTable(PTR_CBYTE table, if (callPndTab) { -#if defined(_DEBUG) && !defined(STRIKE) - // note: _ASSERTE is a no-op for strike PTR_CBYTE offsStart = table; -#endif gcPrintf(" argOffs(%d) =", callPndTabCnt); for (unsigned i=0; i < callPndTabCnt; i++) { diff --git a/src/coreclr/gcinfo/gcinfodumper.cpp b/src/coreclr/gcinfo/gcinfodumper.cpp index 681dafd020b..99ef186d38a 100644 --- a/src/coreclr/gcinfo/gcinfodumper.cpp +++ b/src/coreclr/gcinfo/gcinfodumper.cpp @@ -1,7 +1,9 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +#ifndef SOS_INCLUDE #include "common.h" +#endif #include "gcinfodumper.h" #include "gcinfodecoder.h" diff --git a/src/coreclr/hosts/corerun/corerun.hpp b/src/coreclr/hosts/corerun/corerun.hpp index 5ce0f0b2852..0adcdce2348 100644 --- a/src/coreclr/hosts/corerun/corerun.hpp +++ b/src/coreclr/hosts/corerun/corerun.hpp @@ -455,7 +455,7 @@ namespace pal #else // !__APPLE__ // Use procfs to detect if there is a tracer process. // See https://www.kernel.org/doc/html/latest/filesystems/proc.html - char status[2048] = { 0 }; + char status[2048]; int fd = ::open("/proc/self/status", O_RDONLY); if (fd == -1) { @@ -471,6 +471,8 @@ namespace pal { // We have data. At this point we can likely make a strong decision. const char tracer_pid_name[] = "TracerPid:"; + // null terminate status + status[bytes_read] = '\0'; const char* tracer_pid_ptr = ::strstr(status, tracer_pid_name); if (tracer_pid_ptr == nullptr) return debugger_state_t::not_attached; diff --git a/src/coreclr/ildasm/dasm.cpp b/src/coreclr/ildasm/dasm.cpp index f94a5846672..f514e90cca6 100644 --- a/src/coreclr/ildasm/dasm.cpp +++ b/src/coreclr/ildasm/dasm.cpp @@ -2088,6 +2088,9 @@ BYTE* PrettyPrintCABlobValue(PCCOR_SIGNATURE &typePtr, #ifdef LOGGING case ELEMENT_TYPE_INTERNAL : + case ELEMENT_TYPE_CMOD_INTERNAL : + typePtr += 1; + Reiterate = TRUE; #endif // LOGGING return NULL; diff --git a/src/coreclr/inc/CrstTypes.def b/src/coreclr/inc/CrstTypes.def index eeccd6f6c4e..ccf226105e9 100644 --- a/src/coreclr/inc/CrstTypes.def +++ b/src/coreclr/inc/CrstTypes.def @@ -82,9 +82,6 @@ Crst PinnedHeapHandleTable SystemDomain End -Crst ArgBasedStubCache -End - Crst AssemblyLoader AcquiredBefore DeadlockDetection UniqueStack DebuggerMutex End @@ -97,10 +94,6 @@ Crst AvailableParamTypes AcquiredBefore ModuleLookupTable IbcProfile LoaderHeap End -Crst BaseDomain - AcquiredBefore LoaderHeap UniqueStack -End - Crst CCompRC Unordered End @@ -203,11 +196,7 @@ Crst Exception End Crst ExecutableAllocatorLock - AcquiredAfter LoaderHeap ArgBasedStubCache UMEntryThunkFreeListLock COMCallWrapper -End - -Crst ExecuteManRangeLock - AcquiredAfter NativeImageEagerFixups + AcquiredAfter LoaderHeap UMEntryThunkFreeListLock COMCallWrapper End Crst FCall @@ -294,15 +283,11 @@ Crst JitPatchpoint AcquiredBefore LoaderHeap End -Crst JitPerf - Unordered -End - Crst JumpStubCache - AcquiredBefore ExecuteManRangeLock LoaderHeap SingleUseLock + AcquiredBefore LoaderHeap SingleUseLock AcquiredAfter AppDomainCache ILStubGen - TypeIDMap BaseDomain AssemblyLoader + TypeIDMap AssemblyLoader End Crst ListLock @@ -342,29 +327,18 @@ Crst Module AcquiredBefore LoaderHeap UniqueStack End -Crst ModuleFixup - AcquiredBefore PinnedHeapHandleTable GlobalStrLiteralMap IbcProfile SyncBlockCache -End - Crst ModuleLookupTable AcquiredBefore LoaderHeap End -Crst Nls -End - -Crst ObjectList - SameLevelAs ObjectList -End - Crst PEImage AcquiredBefore UniqueStack End Crst PendingTypeLoadEntry AcquiredBefore AppDomainCache PinnedHeapHandleTable AssemblyLoader AvailableClass AvailableParamTypes - BaseDomain ClassInit DeadlockDetection DebuggerController DebuggerJitInfo DebuggerMutex - GenericDictionaryExpansion Exception ExecuteManRangeLock FuncPtrStubs + ClassInit DeadlockDetection DebuggerController DebuggerJitInfo DebuggerMutex + GenericDictionaryExpansion Exception FuncPtrStubs FusionAppCtx GlobalStrLiteralMap HandleTable IbcProfile IJWFixupData IJWHash ISymUnmanagedReader Jit JumpStubCache LoaderHeap Module ModuleLookupTable PEImage @@ -419,19 +393,12 @@ Crst EtwTypeLogHash AcquiredAfter SingleUseLock End -Crst SavedExceptionInfo - AcquiredBefore DebuggerController -End - -Crst SaveModuleProfileData -End - Crst SigConvert AcquiredBefore LoaderHeap End Crst SingleUseLock - AcquiredBefore ExecuteManRangeLock LoaderHeap UniqueStack DebuggerJitInfo + AcquiredBefore LoaderHeap UniqueStack DebuggerJitInfo End Crst UnwindInfoTableLock @@ -439,9 +406,6 @@ Crst UnwindInfoTableLock AcquiredBefore StressLog End -Crst SpecialStatics -End - Crst StressLog Unordered End @@ -464,12 +428,8 @@ End Crst SyncHashLock End -Crst SystemBaseDomain - AcquiredBefore LoaderHeap UniqueStack -End - Crst SystemDomain - AcquiredBefore DebuggerMutex HandleTable IbcProfile SaveModuleProfileData + AcquiredBefore DebuggerMutex HandleTable IbcProfile ThreadIdDispenser ThreadStore End @@ -485,7 +445,7 @@ End Crst ThreadStore AcquiredBefore AvailableParamTypes DeadlockDetection DebuggerController - DebuggerHeapLock DebuggerJitInfo DynamicIL ExecuteManRangeLock HandleTable IbcProfile + DebuggerHeapLock DebuggerJitInfo DynamicIL HandleTable IbcProfile JitGenericHandleCache JumpStubCache LoaderHeap ModuleLookupTable ProfilerGCRefDataFreeList SingleUseLock SyncBlockCache SystemDomainDelayedUnloadList ThreadIdDispenser DebuggerMutex JitInlineTrackingMap @@ -532,9 +492,6 @@ Crst MulticoreJitManager AcquiredBefore MulticoreJitHash ThreadStore End -Crst StackSampler -End - Crst InlineTrackingMap AcquiredBefore IbcProfile End @@ -552,7 +509,7 @@ Crst NotifyGdb End Crst ReadyToRunEntryPointToMethodDescMap - AcquiredBefore ExecuteManRangeLock UniqueStack + AcquiredBefore UniqueStack End Crst TieredCompilation @@ -569,6 +526,7 @@ Crst MethodDescBackpatchInfoTracker End Crst NativeImageEagerFixups + AcquiredBefore UnresolvedClassLock End Crst NativeImageLoad diff --git a/src/coreclr/inc/arrayholder.h b/src/coreclr/inc/arrayholder.h index 1795ec56ab9..3a172a1121f 100644 --- a/src/coreclr/inc/arrayholder.h +++ b/src/coreclr/inc/arrayholder.h @@ -1,6 +1,8 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +#pragma once + template class ArrayHolder { diff --git a/src/coreclr/inc/clrnt.h b/src/coreclr/inc/clrnt.h index e555f5ead23..2d935a95317 100644 --- a/src/coreclr/inc/clrnt.h +++ b/src/coreclr/inc/clrnt.h @@ -369,6 +369,24 @@ RtlVirtualUnwind( IN OUT PKNONVOLATILE_CONTEXT_POINTERS ContextPointers OPTIONAL ); +// Mirror the XSTATE_ARM64_SVE flags from winnt.h + +#ifndef XSTATE_ARM64_SVE +#define XSTATE_ARM64_SVE (2) +#endif // XSTATE_ARM64_SVE + +#ifndef XSTATE_MASK_ARM64_SVE +#define XSTATE_MASK_ARM64_SVE (1ui64 << (XSTATE_ARM64_SVE)) +#endif // XSTATE_MASK_ARM64_SVE + +#ifndef CONTEXT_ARM64_XSTATE +#define CONTEXT_ARM64_XSTATE (CONTEXT_ARM64 | 0x20L) +#endif // CONTEXT_ARM64_XSTATE + +#ifndef CONTEXT_XSTATE +#define CONTEXT_XSTATE CONTEXT_ARM64_XSTATE +#endif // CONTEXT_XSTATE + #endif #ifdef TARGET_LOONGARCH64 diff --git a/src/coreclr/inc/complex.h b/src/coreclr/inc/complex.h deleted file mode 100644 index eb208242662..00000000000 --- a/src/coreclr/inc/complex.h +++ /dev/null @@ -1,79 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. -// -// complex.h -// - -// -// Defines a basic complex number data type. We cannot use the standard C++ library's -// complex implementation, because the CLR links to the wrong CRT. -// - -#ifndef _COMPLEX_H_ -#define _COMPLEX_H_ - -#include - -// -// Default compilation mode is /fp:precise, which disables fp intrinsics. This causes us to pull in FP stuff (sqrt,etc.) from -// The CRT, and increases our download size. We don't need the extra precision this gets us, so let's switch to -// the intrinsic versions. -// -#ifdef _MSC_VER -#pragma float_control(precise, off, push) -#endif - - -class Complex -{ -public: - double r; - double i; - - Complex() : r(0), i(0) {} - Complex(double real) : r(real), i(0) {} - Complex(double real, double imag) : r(real), i(imag) {} - Complex(const Complex& other) : r(other.r), i(other.i) {} -}; - -inline Complex operator+(Complex left, Complex right) -{ - LIMITED_METHOD_CONTRACT; - return Complex(left.r + right.r, left.i + right.i); -} - -inline Complex operator-(Complex left, Complex right) -{ - LIMITED_METHOD_CONTRACT; - return Complex(left.r - right.r, left.i - right.i); -} - -inline Complex operator*(Complex left, Complex right) -{ - LIMITED_METHOD_CONTRACT; - return Complex( - left.r * right.r - left.i * right.i, - left.r * right.i + left.i * right.r); -} - -inline Complex operator/(Complex left, Complex right) -{ - LIMITED_METHOD_CONTRACT; - double denom = right.r * right.r + right.i * right.i; - return Complex( - (left.r * right.r + left.i * right.i) / denom, - (-left.r * right.i + left.i * right.r) / denom); -} - -inline double abs(Complex c) -{ - LIMITED_METHOD_CONTRACT; - return sqrt(c.r * c.r + c.i * c.i); -} - -#ifdef _MSC_VER -#pragma float_control(pop) -#endif - - -#endif //_COMPLEX_H_ diff --git a/src/coreclr/inc/corhdr.h b/src/coreclr/inc/corhdr.h index c12c1cfdd4f..b0e257a8469 100644 --- a/src/coreclr/inc/corhdr.h +++ b/src/coreclr/inc/corhdr.h @@ -911,9 +911,10 @@ typedef enum CorElementType // This is for signatures generated internally (which will not be persisted in any way). ELEMENT_TYPE_INTERNAL = 0x21, // INTERNAL + ELEMENT_TYPE_CMOD_INTERNAL = 0x22, // CMOD_INTERNAL // Note that this is the max of base type excluding modifiers - ELEMENT_TYPE_MAX = 0x22, // first invalid element type + ELEMENT_TYPE_MAX = 0x23, // first invalid element type ELEMENT_TYPE_MODIFIER = 0x40, diff --git a/src/coreclr/inc/corinfo.h b/src/coreclr/inc/corinfo.h index b1b958cabaa..e61110d42e5 100644 --- a/src/coreclr/inc/corinfo.h +++ b/src/coreclr/inc/corinfo.h @@ -496,8 +496,6 @@ enum CorInfoHelpFunc /* Miscellaneous */ - CORINFO_HELP_BBT_FCN_ENTER, // record the entry to a method for collecting Tuning data - CORINFO_HELP_PINVOKE_CALLI, // Indirect pinvoke call CORINFO_HELP_TAILCALL, // Perform a tail call @@ -512,9 +510,7 @@ enum CorInfoHelpFunc // not safe for unbounded size, does not trigger GC) CORINFO_HELP_RUNTIMEHANDLE_METHOD, // determine a type/field/method handle at run-time - CORINFO_HELP_RUNTIMEHANDLE_METHOD_LOG, // determine a type/field/method handle at run-time, with IBC logging CORINFO_HELP_RUNTIMEHANDLE_CLASS, // determine a type/field/method handle at run-time - CORINFO_HELP_RUNTIMEHANDLE_CLASS_LOG, // determine a type/field/method handle at run-time, with IBC logging CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE, // Convert from a TypeHandle (native structure pointer) to RuntimeType at run-time CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE_MAYBENULL, // Convert from a TypeHandle (native structure pointer) to RuntimeType at run-time, the type may be null @@ -654,6 +650,7 @@ enum CorInfoTypeWithMod { CORINFO_TYPE_MASK = 0x3F, // lower 6 bits are type mask CORINFO_TYPE_MOD_PINNED = 0x40, // can be applied to CLASS, or BYREF to indicate pinned + CORINFO_TYPE_MOD_COPY_WITH_HELPER = 0x80 // can be applied to VALUECLASS to indicate 'needs helper to copy' }; inline CorInfoType strip(CorInfoTypeWithMod val) { @@ -943,7 +940,6 @@ struct PatchpointInfo; // Cookie types consumed by the code generator (these are opaque values // not inspected by the code generator): -typedef struct CORINFO_ASSEMBLY_STRUCT_* CORINFO_ASSEMBLY_HANDLE; typedef struct CORINFO_MODULE_STRUCT_* CORINFO_MODULE_HANDLE; typedef struct CORINFO_DEPENDENCY_STRUCT_* CORINFO_DEPENDENCY_HANDLE; typedef struct CORINFO_CLASS_STRUCT_* CORINFO_CLASS_HANDLE; @@ -2334,18 +2330,9 @@ class ICorStaticInfo CORINFO_CLASS_HANDLE cls ) = 0; - virtual CORINFO_MODULE_HANDLE getClassModule ( - CORINFO_CLASS_HANDLE cls - ) = 0; - - // Returns the assembly that contains the module "mod". - virtual CORINFO_ASSEMBLY_HANDLE getModuleAssembly ( - CORINFO_MODULE_HANDLE mod - ) = 0; - - // Returns the name of the assembly "assem". - virtual const char* getAssemblyName ( - CORINFO_ASSEMBLY_HANDLE assem + // Returns the assembly name of the class "cls", or nullptr if there is none. + virtual const char* getClassAssemblyName ( + CORINFO_CLASS_HANDLE cls ) = 0; // Allocate and delete process-lifetime objects. Should only be @@ -2763,12 +2750,12 @@ class ICorStaticInfo // the field's value class (if 'structType' == 0, then don't bother // the structure info). // - // 'memberParent' is typically only set when verifying. It should be the - // result of calling getMemberParent. + // 'fieldOwnerHint' is, potentially, a more exact owner of the field. + // it's fine for it to be non-precise, it's just a hint. virtual CorInfoType getFieldType( CORINFO_FIELD_HANDLE field, CORINFO_CLASS_HANDLE * structType = NULL, - CORINFO_CLASS_HANDLE memberParent = NULL /* IN */ + CORINFO_CLASS_HANDLE fieldOwnerHint = NULL /* IN */ ) = 0; // return the data member's instance offset @@ -3335,6 +3322,8 @@ class ICorDynamicInfo : public ICorStaticInfo // but for tailcalls, the contract is that JIT leaves the indirection cell in // a register during tailcall. virtual void updateEntryPointForTailCall(CORINFO_CONST_LOOKUP* entryPoint) = 0; + + virtual CORINFO_METHOD_HANDLE getSpecialCopyHelper(CORINFO_CLASS_HANDLE type) = 0; }; /**********************************************************************************/ diff --git a/src/coreclr/inc/cortypeinfo.h b/src/coreclr/inc/cortypeinfo.h index 87d960301b6..d051c352127 100644 --- a/src/coreclr/inc/cortypeinfo.h +++ b/src/coreclr/inc/cortypeinfo.h @@ -54,3 +54,4 @@ TYPEINFO(ELEMENT_TYPE_MVAR, NULL, NULL, TARGET_POINTER_SI TYPEINFO(ELEMENT_TYPE_CMOD_REQD, NULL, NULL, 0, TYPE_GC_NONE, false, false, false, false, false) // 0x1f TYPEINFO(ELEMENT_TYPE_CMOD_OPT, NULL, NULL, 0, TYPE_GC_NONE, false, false, false, false, false) // 0x20 TYPEINFO(ELEMENT_TYPE_INTERNAL, NULL, NULL, 0, TYPE_GC_OTHER, false, false, false, false, false) // 0x21 +TYPEINFO(ELEMENT_TYPE_CMOD_INTERNAL,NULL, NULL, 0, TYPE_GC_NONE, false, false, false, false, false) // 0x22 diff --git a/src/coreclr/inc/crsttypes_generated.h b/src/coreclr/inc/crsttypes_generated.h index ccbb4070ea7..9db4f694103 100644 --- a/src/coreclr/inc/crsttypes_generated.h +++ b/src/coreclr/inc/crsttypes_generated.h @@ -16,124 +16,112 @@ enum CrstType { CrstAppDomainCache = 0, - CrstArgBasedStubCache = 1, - CrstAssemblyList = 2, - CrstAssemblyLoader = 3, - CrstAvailableClass = 4, - CrstAvailableParamTypes = 5, - CrstBaseDomain = 6, - CrstCCompRC = 7, - CrstClassFactInfoHash = 8, - CrstClassInit = 9, - CrstClrNotification = 10, - CrstCodeFragmentHeap = 11, - CrstCodeVersioning = 12, - CrstCOMCallWrapper = 13, - CrstCOMWrapperCache = 14, - CrstDataTest1 = 15, - CrstDataTest2 = 16, - CrstDbgTransport = 17, - CrstDeadlockDetection = 18, - CrstDebuggerController = 19, - CrstDebuggerFavorLock = 20, - CrstDebuggerHeapExecMemLock = 21, - CrstDebuggerHeapLock = 22, - CrstDebuggerJitInfo = 23, - CrstDebuggerMutex = 24, - CrstDelegateToFPtrHash = 25, - CrstDynamicIL = 26, - CrstDynamicMT = 27, - CrstEtwTypeLogHash = 28, - CrstEventPipe = 29, - CrstEventStore = 30, - CrstException = 31, - CrstExecutableAllocatorLock = 32, - CrstExecuteManRangeLock = 33, - CrstFCall = 34, - CrstFrozenObjectHeap = 35, - CrstFuncPtrStubs = 36, - CrstFusionAppCtx = 37, - CrstGCCover = 38, - CrstGenericDictionaryExpansion = 39, - CrstGlobalStrLiteralMap = 40, - CrstHandleTable = 41, - CrstIbcProfile = 42, - CrstIJWFixupData = 43, - CrstIJWHash = 44, - CrstILStubGen = 45, - CrstInlineTrackingMap = 46, - CrstInstMethodHashTable = 47, - CrstInterop = 48, - CrstInteropData = 49, - CrstIsJMCMethod = 50, - CrstISymUnmanagedReader = 51, - CrstJit = 52, - CrstJitGenericHandleCache = 53, - CrstJitInlineTrackingMap = 54, - CrstJitPatchpoint = 55, - CrstJitPerf = 56, - CrstJumpStubCache = 57, - CrstLeafLock = 58, - CrstListLock = 59, - CrstLoaderAllocator = 60, - CrstLoaderAllocatorReferences = 61, - CrstLoaderHeap = 62, - CrstManagedObjectWrapperMap = 63, - CrstMethodDescBackpatchInfoTracker = 64, - CrstMethodTableExposedObject = 65, - CrstModule = 66, - CrstModuleFixup = 67, - CrstModuleLookupTable = 68, - CrstMulticoreJitHash = 69, - CrstMulticoreJitManager = 70, - CrstNativeImageEagerFixups = 71, - CrstNativeImageLoad = 72, - CrstNls = 73, - CrstNotifyGdb = 74, - CrstObjectList = 75, - CrstPEImage = 76, - CrstPendingTypeLoadEntry = 77, - CrstPerfMap = 78, - CrstPgoData = 79, - CrstPinnedByrefValidation = 80, - CrstPinnedHeapHandleTable = 81, - CrstProfilerGCRefDataFreeList = 82, - CrstProfilingAPIStatus = 83, - CrstRCWCache = 84, - CrstRCWCleanupList = 85, - CrstReadyToRunEntryPointToMethodDescMap = 86, - CrstReflection = 87, - CrstReJITGlobalRequest = 88, - CrstRetThunkCache = 89, - CrstSavedExceptionInfo = 90, - CrstSaveModuleProfileData = 91, - CrstSigConvert = 92, - CrstSingleUseLock = 93, - CrstSpecialStatics = 94, - CrstStackSampler = 95, - CrstStressLog = 96, - CrstStubCache = 97, - CrstStubDispatchCache = 98, - CrstStubUnwindInfoHeapSegments = 99, - CrstSyncBlockCache = 100, - CrstSyncHashLock = 101, - CrstSystemBaseDomain = 102, - CrstSystemDomain = 103, - CrstSystemDomainDelayedUnloadList = 104, - CrstThreadIdDispenser = 105, - CrstThreadLocalStorageLock = 106, - CrstThreadStore = 107, - CrstTieredCompilation = 108, - CrstTypeEquivalenceMap = 109, - CrstTypeIDMap = 110, - CrstUMEntryThunkCache = 111, - CrstUMEntryThunkFreeListLock = 112, - CrstUniqueStack = 113, - CrstUnresolvedClassLock = 114, - CrstUnwindInfoTableLock = 115, - CrstVSDIndirectionCellLock = 116, - CrstWrapperTemplate = 117, - kNumberOfCrstTypes = 118 + CrstAssemblyList = 1, + CrstAssemblyLoader = 2, + CrstAvailableClass = 3, + CrstAvailableParamTypes = 4, + CrstCCompRC = 5, + CrstClassFactInfoHash = 6, + CrstClassInit = 7, + CrstClrNotification = 8, + CrstCodeFragmentHeap = 9, + CrstCodeVersioning = 10, + CrstCOMCallWrapper = 11, + CrstCOMWrapperCache = 12, + CrstDataTest1 = 13, + CrstDataTest2 = 14, + CrstDbgTransport = 15, + CrstDeadlockDetection = 16, + CrstDebuggerController = 17, + CrstDebuggerFavorLock = 18, + CrstDebuggerHeapExecMemLock = 19, + CrstDebuggerHeapLock = 20, + CrstDebuggerJitInfo = 21, + CrstDebuggerMutex = 22, + CrstDelegateToFPtrHash = 23, + CrstDynamicIL = 24, + CrstDynamicMT = 25, + CrstEtwTypeLogHash = 26, + CrstEventPipe = 27, + CrstEventStore = 28, + CrstException = 29, + CrstExecutableAllocatorLock = 30, + CrstFCall = 31, + CrstFrozenObjectHeap = 32, + CrstFuncPtrStubs = 33, + CrstFusionAppCtx = 34, + CrstGCCover = 35, + CrstGenericDictionaryExpansion = 36, + CrstGlobalStrLiteralMap = 37, + CrstHandleTable = 38, + CrstIbcProfile = 39, + CrstIJWFixupData = 40, + CrstIJWHash = 41, + CrstILStubGen = 42, + CrstInlineTrackingMap = 43, + CrstInstMethodHashTable = 44, + CrstInterop = 45, + CrstInteropData = 46, + CrstIsJMCMethod = 47, + CrstISymUnmanagedReader = 48, + CrstJit = 49, + CrstJitGenericHandleCache = 50, + CrstJitInlineTrackingMap = 51, + CrstJitPatchpoint = 52, + CrstJumpStubCache = 53, + CrstLeafLock = 54, + CrstListLock = 55, + CrstLoaderAllocator = 56, + CrstLoaderAllocatorReferences = 57, + CrstLoaderHeap = 58, + CrstManagedObjectWrapperMap = 59, + CrstMethodDescBackpatchInfoTracker = 60, + CrstMethodTableExposedObject = 61, + CrstModule = 62, + CrstModuleLookupTable = 63, + CrstMulticoreJitHash = 64, + CrstMulticoreJitManager = 65, + CrstNativeImageEagerFixups = 66, + CrstNativeImageLoad = 67, + CrstNotifyGdb = 68, + CrstPEImage = 69, + CrstPendingTypeLoadEntry = 70, + CrstPerfMap = 71, + CrstPgoData = 72, + CrstPinnedByrefValidation = 73, + CrstPinnedHeapHandleTable = 74, + CrstProfilerGCRefDataFreeList = 75, + CrstProfilingAPIStatus = 76, + CrstRCWCache = 77, + CrstRCWCleanupList = 78, + CrstReadyToRunEntryPointToMethodDescMap = 79, + CrstReflection = 80, + CrstReJITGlobalRequest = 81, + CrstRetThunkCache = 82, + CrstSigConvert = 83, + CrstSingleUseLock = 84, + CrstStressLog = 85, + CrstStubCache = 86, + CrstStubDispatchCache = 87, + CrstStubUnwindInfoHeapSegments = 88, + CrstSyncBlockCache = 89, + CrstSyncHashLock = 90, + CrstSystemDomain = 91, + CrstSystemDomainDelayedUnloadList = 92, + CrstThreadIdDispenser = 93, + CrstThreadLocalStorageLock = 94, + CrstThreadStore = 95, + CrstTieredCompilation = 96, + CrstTypeEquivalenceMap = 97, + CrstTypeIDMap = 98, + CrstUMEntryThunkCache = 99, + CrstUMEntryThunkFreeListLock = 100, + CrstUniqueStack = 101, + CrstUnresolvedClassLock = 102, + CrstUnwindInfoTableLock = 103, + CrstVSDIndirectionCellLock = 104, + CrstWrapperTemplate = 105, + kNumberOfCrstTypes = 106 }; #endif // __CRST_TYPES_INCLUDED @@ -144,136 +132,122 @@ enum CrstType // An array mapping CrstType to level. int g_rgCrstLevelMap[] = { - 10, // CrstAppDomainCache - 3, // CrstArgBasedStubCache - 3, // CrstAssemblyList - 14, // CrstAssemblyLoader - 4, // CrstAvailableClass - 5, // CrstAvailableParamTypes - 7, // CrstBaseDomain + 9, // CrstAppDomainCache + 2, // CrstAssemblyList + 13, // CrstAssemblyLoader + 3, // CrstAvailableClass + 4, // CrstAvailableParamTypes -1, // CrstCCompRC - 15, // CrstClassFactInfoHash - 11, // CrstClassInit + 14, // CrstClassFactInfoHash + 10, // CrstClassInit -1, // CrstClrNotification - 6, // CrstCodeFragmentHeap - 9, // CrstCodeVersioning - 3, // CrstCOMCallWrapper - 10, // CrstCOMWrapperCache - 3, // CrstDataTest1 + 5, // CrstCodeFragmentHeap + 8, // CrstCodeVersioning + 2, // CrstCOMCallWrapper + 9, // CrstCOMWrapperCache + 2, // CrstDataTest1 0, // CrstDataTest2 0, // CrstDbgTransport 0, // CrstDeadlockDetection -1, // CrstDebuggerController - 3, // CrstDebuggerFavorLock + 2, // CrstDebuggerFavorLock 0, // CrstDebuggerHeapExecMemLock 0, // CrstDebuggerHeapLock - 4, // CrstDebuggerJitInfo - 13, // CrstDebuggerMutex + 3, // CrstDebuggerJitInfo + 12, // CrstDebuggerMutex 0, // CrstDelegateToFPtrHash 0, // CrstDynamicIL - 10, // CrstDynamicMT + 9, // CrstDynamicMT 0, // CrstEtwTypeLogHash - 20, // CrstEventPipe + 19, // CrstEventPipe 0, // CrstEventStore 0, // CrstException 0, // CrstExecutableAllocatorLock - 0, // CrstExecuteManRangeLock - 4, // CrstFCall + 3, // CrstFCall -1, // CrstFrozenObjectHeap - 7, // CrstFuncPtrStubs - 10, // CrstFusionAppCtx - 10, // CrstGCCover - 18, // CrstGenericDictionaryExpansion - 17, // CrstGlobalStrLiteralMap + 6, // CrstFuncPtrStubs + 9, // CrstFusionAppCtx + 9, // CrstGCCover + 17, // CrstGenericDictionaryExpansion + 16, // CrstGlobalStrLiteralMap 1, // CrstHandleTable 0, // CrstIbcProfile - 8, // CrstIJWFixupData + 7, // CrstIJWFixupData 0, // CrstIJWHash - 7, // CrstILStubGen - 3, // CrstInlineTrackingMap - 19, // CrstInstMethodHashTable - 22, // CrstInterop - 10, // CrstInteropData + 6, // CrstILStubGen + 2, // CrstInlineTrackingMap + 18, // CrstInstMethodHashTable + 21, // CrstInterop + 9, // CrstInteropData 0, // CrstIsJMCMethod - 7, // CrstISymUnmanagedReader - 11, // CrstJit + 6, // CrstISymUnmanagedReader + 10, // CrstJit 0, // CrstJitGenericHandleCache - 12, // CrstJitInlineTrackingMap - 4, // CrstJitPatchpoint - -1, // CrstJitPerf - 6, // CrstJumpStubCache + 11, // CrstJitInlineTrackingMap + 3, // CrstJitPatchpoint + 5, // CrstJumpStubCache 0, // CrstLeafLock -1, // CrstListLock - 17, // CrstLoaderAllocator - 18, // CrstLoaderAllocatorReferences - 3, // CrstLoaderHeap - 3, // CrstManagedObjectWrapperMap - 10, // CrstMethodDescBackpatchInfoTracker + 16, // CrstLoaderAllocator + 17, // CrstLoaderAllocatorReferences + 2, // CrstLoaderHeap + 2, // CrstManagedObjectWrapperMap + 9, // CrstMethodDescBackpatchInfoTracker -1, // CrstMethodTableExposedObject - 5, // CrstModule - 18, // CrstModuleFixup - 4, // CrstModuleLookupTable + 4, // CrstModule + 3, // CrstModuleLookupTable 0, // CrstMulticoreJitHash - 15, // CrstMulticoreJitManager - 3, // CrstNativeImageEagerFixups + 14, // CrstMulticoreJitManager + 7, // CrstNativeImageEagerFixups 0, // CrstNativeImageLoad - 0, // CrstNls 0, // CrstNotifyGdb - 2, // CrstObjectList - 5, // CrstPEImage - 21, // CrstPendingTypeLoadEntry + 4, // CrstPEImage + 20, // CrstPendingTypeLoadEntry 0, // CrstPerfMap - 4, // CrstPgoData + 3, // CrstPgoData 0, // CrstPinnedByrefValidation - 16, // CrstPinnedHeapHandleTable + 15, // CrstPinnedHeapHandleTable 0, // CrstProfilerGCRefDataFreeList - 15, // CrstProfilingAPIStatus - 4, // CrstRCWCache + 14, // CrstProfilingAPIStatus + 3, // CrstRCWCache 0, // CrstRCWCleanupList - 10, // CrstReadyToRunEntryPointToMethodDescMap - 8, // CrstReflection - 16, // CrstReJITGlobalRequest - 4, // CrstRetThunkCache - 3, // CrstSavedExceptionInfo - 0, // CrstSaveModuleProfileData - 4, // CrstSigConvert - 5, // CrstSingleUseLock - 0, // CrstSpecialStatics - 0, // CrstStackSampler + 9, // CrstReadyToRunEntryPointToMethodDescMap + 7, // CrstReflection + 15, // CrstReJITGlobalRequest + 3, // CrstRetThunkCache + 3, // CrstSigConvert + 4, // CrstSingleUseLock -1, // CrstStressLog - 5, // CrstStubCache + 4, // CrstStubCache 0, // CrstStubDispatchCache - 4, // CrstStubUnwindInfoHeapSegments - 3, // CrstSyncBlockCache + 3, // CrstStubUnwindInfoHeapSegments + 2, // CrstSyncBlockCache 0, // CrstSyncHashLock - 5, // CrstSystemBaseDomain - 15, // CrstSystemDomain + 14, // CrstSystemDomain 0, // CrstSystemDomainDelayedUnloadList 0, // CrstThreadIdDispenser - 5, // CrstThreadLocalStorageLock - 14, // CrstThreadStore - 8, // CrstTieredCompilation - 4, // CrstTypeEquivalenceMap - 10, // CrstTypeIDMap - 4, // CrstUMEntryThunkCache - 3, // CrstUMEntryThunkFreeListLock - 4, // CrstUniqueStack - 7, // CrstUnresolvedClassLock - 3, // CrstUnwindInfoTableLock - 4, // CrstVSDIndirectionCellLock - 3, // CrstWrapperTemplate + 4, // CrstThreadLocalStorageLock + 13, // CrstThreadStore + 7, // CrstTieredCompilation + 3, // CrstTypeEquivalenceMap + 9, // CrstTypeIDMap + 3, // CrstUMEntryThunkCache + 2, // CrstUMEntryThunkFreeListLock + 3, // CrstUniqueStack + 6, // CrstUnresolvedClassLock + 2, // CrstUnwindInfoTableLock + 3, // CrstVSDIndirectionCellLock + 2, // CrstWrapperTemplate }; // An array mapping CrstType to a stringized name. LPCSTR g_rgCrstNameMap[] = { "CrstAppDomainCache", - "CrstArgBasedStubCache", "CrstAssemblyList", "CrstAssemblyLoader", "CrstAvailableClass", "CrstAvailableParamTypes", - "CrstBaseDomain", "CrstCCompRC", "CrstClassFactInfoHash", "CrstClassInit", @@ -300,7 +274,6 @@ LPCSTR g_rgCrstNameMap[] = "CrstEventStore", "CrstException", "CrstExecutableAllocatorLock", - "CrstExecuteManRangeLock", "CrstFCall", "CrstFrozenObjectHeap", "CrstFuncPtrStubs", @@ -323,7 +296,6 @@ LPCSTR g_rgCrstNameMap[] = "CrstJitGenericHandleCache", "CrstJitInlineTrackingMap", "CrstJitPatchpoint", - "CrstJitPerf", "CrstJumpStubCache", "CrstLeafLock", "CrstListLock", @@ -334,15 +306,12 @@ LPCSTR g_rgCrstNameMap[] = "CrstMethodDescBackpatchInfoTracker", "CrstMethodTableExposedObject", "CrstModule", - "CrstModuleFixup", "CrstModuleLookupTable", "CrstMulticoreJitHash", "CrstMulticoreJitManager", "CrstNativeImageEagerFixups", "CrstNativeImageLoad", - "CrstNls", "CrstNotifyGdb", - "CrstObjectList", "CrstPEImage", "CrstPendingTypeLoadEntry", "CrstPerfMap", @@ -357,19 +326,14 @@ LPCSTR g_rgCrstNameMap[] = "CrstReflection", "CrstReJITGlobalRequest", "CrstRetThunkCache", - "CrstSavedExceptionInfo", - "CrstSaveModuleProfileData", "CrstSigConvert", "CrstSingleUseLock", - "CrstSpecialStatics", - "CrstStackSampler", "CrstStressLog", "CrstStubCache", "CrstStubDispatchCache", "CrstStubUnwindInfoHeapSegments", "CrstSyncBlockCache", "CrstSyncHashLock", - "CrstSystemBaseDomain", "CrstSystemDomain", "CrstSystemDomainDelayedUnloadList", "CrstThreadIdDispenser", diff --git a/src/coreclr/inc/cvconst.h b/src/coreclr/inc/cvconst.h deleted file mode 100644 index 3fbbfdd011a..00000000000 --- a/src/coreclr/inc/cvconst.h +++ /dev/null @@ -1,3729 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -// cvconst.h - codeview constant definitions -//----------------------------------------------------------------- -// -// Copyright Microsoft Corporation. All Rights Reserved. -// -//--------------------------------------------------------------- -#ifndef _CVCONST_H_ -#define _CVCONST_H_ - - - -// Enumeration for function call type - - -typedef enum CV_call_e { - CV_CALL_NEAR_C = 0x00, // near right to left push, caller pops stack - CV_CALL_FAR_C = 0x01, // far right to left push, caller pops stack - CV_CALL_NEAR_PASCAL = 0x02, // near left to right push, callee pops stack - CV_CALL_FAR_PASCAL = 0x03, // far left to right push, callee pops stack - CV_CALL_NEAR_FAST = 0x04, // near left to right push with regs, callee pops stack - CV_CALL_FAR_FAST = 0x05, // far left to right push with regs, callee pops stack - CV_CALL_SKIPPED = 0x06, // skipped (unused) call index - CV_CALL_NEAR_STD = 0x07, // near standard call - CV_CALL_FAR_STD = 0x08, // far standard call - CV_CALL_NEAR_SYS = 0x09, // near sys call - CV_CALL_FAR_SYS = 0x0a, // far sys call - CV_CALL_THISCALL = 0x0b, // this call (this passed in register) - CV_CALL_MIPSCALL = 0x0c, // Mips call - CV_CALL_GENERIC = 0x0d, // Generic call sequence - CV_CALL_ALPHACALL = 0x0e, // Alpha call - CV_CALL_PPCCALL = 0x0f, // PPC call - CV_CALL_SHCALL = 0x10, // Hitachi SuperH call - CV_CALL_ARMCALL = 0x11, // ARM call - CV_CALL_AM33CALL = 0x12, // AM33 call - CV_CALL_TRICALL = 0x13, // TriCore Call - CV_CALL_SH5CALL = 0x14, // Hitachi SuperH-5 call - CV_CALL_M32RCALL = 0x15, // M32R Call - CV_CALL_CLRCALL = 0x16, // clr call - CV_CALL_INLINE = 0x17, // Marker for routines always inlined and thus lacking a convention - CV_CALL_NEAR_VECTOR = 0x18, // near left to right push with regs, callee pops stack - CV_CALL_RESERVED = 0x19 // first unused call enumeration - - // Do NOT add any more machine specific conventions. This is to be used for - // calling conventions in the source only (e.g. __cdecl, __stdcall). -} CV_call_e; - - -// Values for the access protection of class attributes - - -typedef enum CV_access_e { - CV_private = 1, - CV_protected = 2, - CV_public = 3 -} CV_access_e; - -typedef enum THUNK_ORDINAL { - THUNK_ORDINAL_NOTYPE, // standard thunk - THUNK_ORDINAL_ADJUSTOR, // "this" adjustor thunk - THUNK_ORDINAL_VCALL, // virtual call thunk - THUNK_ORDINAL_PCODE, // pcode thunk - THUNK_ORDINAL_LOAD, // thunk which loads the address to jump to - // via unknown means... - - // trampoline thunk ordinals - only for use in Trampoline thunk symbols - THUNK_ORDINAL_TRAMP_INCREMENTAL, - THUNK_ORDINAL_TRAMP_BRANCHISLAND, - -} THUNK_ORDINAL; - - -enum CV_SourceChksum_t { - CHKSUM_TYPE_NONE = 0, // indicates no checksum is available - CHKSUM_TYPE_MD5, - CHKSUM_TYPE_SHA1, - CHKSUM_TYPE_SHA_256, -}; - -// -// DIA enums -// - -enum SymTagEnum -{ - SymTagNull, - SymTagExe, - SymTagCompiland, - SymTagCompilandDetails, - SymTagCompilandEnv, - SymTagFunction, - SymTagBlock, - SymTagData, - SymTagAnnotation, - SymTagLabel, - SymTagPublicSymbol, - SymTagUDT, - SymTagEnum, - SymTagFunctionType, - SymTagPointerType, - SymTagArrayType, - SymTagBaseType, - SymTagTypedef, - SymTagBaseClass, - SymTagFriend, - SymTagFunctionArgType, - SymTagFuncDebugStart, - SymTagFuncDebugEnd, - SymTagUsingNamespace, - SymTagVTableShape, - SymTagVTable, - SymTagCustom, - SymTagThunk, - SymTagCustomType, - SymTagManagedType, - SymTagDimension, - SymTagCallSite, - SymTagInlineSite, - SymTagBaseInterface, - SymTagVectorType, - SymTagMatrixType, - SymTagHLSLType, - SymTagCaller, - SymTagCallee, - SymTagExport, - SymTagHeapAllocationSite, - SymTagCoffGroup, - SymTagMax -}; - -enum LocationType -{ - LocIsNull, - LocIsStatic, - LocIsTLS, - LocIsRegRel, - LocIsThisRel, - LocIsEnregistered, - LocIsBitField, - LocIsSlot, - LocIsIlRel, - LocInMetaData, - LocIsConstant, - LocTypeMax -}; - -enum DataKind -{ - DataIsUnknown, - DataIsLocal, - DataIsStaticLocal, - DataIsParam, - DataIsObjectPtr, - DataIsFileStatic, - DataIsGlobal, - DataIsMember, - DataIsStaticMember, - DataIsConstant -}; - -enum UdtKind -{ - UdtStruct, - UdtClass, - UdtUnion, - UdtInterface -}; - -enum BasicType -{ - btNoType = 0, - btVoid = 1, - btChar = 2, - btWChar = 3, - btInt = 6, - btUInt = 7, - btFloat = 8, - btBCD = 9, - btBool = 10, - btLong = 13, - btULong = 14, - btCurrency = 25, - btDate = 26, - btVariant = 27, - btComplex = 28, - btBit = 29, - btBSTR = 30, - btHresult = 31, - btChar16 = 32, // char16_t - btChar32 = 33, // char32_t -}; - - -// enumeration for type modifier values - -typedef enum CV_modifier_e { - // 0x0000 - 0x01ff - Reserved. - - CV_MOD_INVALID = 0x0000, - - // Standard modifiers. - - CV_MOD_CONST = 0x0001, - CV_MOD_VOLATILE = 0x0002, - CV_MOD_UNALIGNED = 0x0003, - - // 0x0200 - 0x03ff - HLSL modifiers. - - CV_MOD_HLSL_UNIFORM = 0x0200, - CV_MOD_HLSL_LINE = 0x0201, - CV_MOD_HLSL_TRIANGLE = 0x0202, - CV_MOD_HLSL_LINEADJ = 0x0203, - CV_MOD_HLSL_TRIANGLEADJ = 0x0204, - CV_MOD_HLSL_LINEAR = 0x0205, - CV_MOD_HLSL_CENTROID = 0x0206, - CV_MOD_HLSL_CONSTINTERP = 0x0207, - CV_MOD_HLSL_NOPERSPECTIVE = 0x0208, - CV_MOD_HLSL_SAMPLE = 0x0209, - CV_MOD_HLSL_CENTER = 0x020a, - CV_MOD_HLSL_SNORM = 0x020b, - CV_MOD_HLSL_UNORM = 0x020c, - CV_MOD_HLSL_PRECISE = 0x020d, - CV_MOD_HLSL_UAV_GLOBALLY_COHERENT = 0x020e, - - // 0x0400 - 0xffff - Unused. - -} CV_modifier_e; - - -// built-in type kinds - - -typedef enum CV_builtin_e { - - // 0x0000 - 0x01ff - Reserved. - CV_BI_INVALID = 0x0000, - - // 0x0200 - 0x03ff - HLSL types. - - CV_BI_HLSL_INTERFACE_POINTER = 0x0200, - CV_BI_HLSL_TEXTURE1D = 0x0201, - CV_BI_HLSL_TEXTURE1D_ARRAY = 0x0202, - CV_BI_HLSL_TEXTURE2D = 0x0203, - CV_BI_HLSL_TEXTURE2D_ARRAY = 0x0204, - CV_BI_HLSL_TEXTURE3D = 0x0205, - CV_BI_HLSL_TEXTURECUBE = 0x0206, - CV_BI_HLSL_TEXTURECUBE_ARRAY = 0x0207, - CV_BI_HLSL_TEXTURE2DMS = 0x0208, - CV_BI_HLSL_TEXTURE2DMS_ARRAY = 0x0209, - CV_BI_HLSL_SAMPLER = 0x020a, - CV_BI_HLSL_SAMPLERCOMPARISON = 0x020b, - CV_BI_HLSL_BUFFER = 0x020c, - CV_BI_HLSL_POINTSTREAM = 0x020d, - CV_BI_HLSL_LINESTREAM = 0x020e, - CV_BI_HLSL_TRIANGLESTREAM = 0x020f, - CV_BI_HLSL_INPUTPATCH = 0x0210, - CV_BI_HLSL_OUTPUTPATCH = 0x0211, - CV_BI_HLSL_RWTEXTURE1D = 0x0212, - CV_BI_HLSL_RWTEXTURE1D_ARRAY = 0x0213, - CV_BI_HLSL_RWTEXTURE2D = 0x0214, - CV_BI_HLSL_RWTEXTURE2D_ARRAY = 0x0215, - CV_BI_HLSL_RWTEXTURE3D = 0x0216, - CV_BI_HLSL_RWBUFFER = 0x0217, - CV_BI_HLSL_BYTEADDRESS_BUFFER = 0x0218, - CV_BI_HLSL_RWBYTEADDRESS_BUFFER = 0x0219, - CV_BI_HLSL_STRUCTURED_BUFFER = 0x021a, - CV_BI_HLSL_RWSTRUCTURED_BUFFER = 0x021b, - CV_BI_HLSL_APPEND_STRUCTURED_BUFFER = 0x021c, - CV_BI_HLSL_CONSUME_STRUCTURED_BUFFER= 0x021d, - CV_BI_HLSL_MIN8FLOAT = 0x021e, - CV_BI_HLSL_MIN10FLOAT = 0x021f, - CV_BI_HLSL_MIN16FLOAT = 0x0220, - CV_BI_HLSL_MIN12INT = 0x0221, - CV_BI_HLSL_MIN16INT = 0x0222, - CV_BI_HLSL_MIN16UINT = 0x0223, - - // 0x0400 - 0xffff - Unused. - -} CV_builtin_e; - - -// enum describing the compile flag source language - - -typedef enum CV_CFL_LANG { - CV_CFL_C = 0x00, - CV_CFL_CXX = 0x01, - CV_CFL_FORTRAN = 0x02, - CV_CFL_MASM = 0x03, - CV_CFL_PASCAL = 0x04, - CV_CFL_BASIC = 0x05, - CV_CFL_COBOL = 0x06, - CV_CFL_LINK = 0x07, - CV_CFL_CVTRES = 0x08, - CV_CFL_CVTPGD = 0x09, - CV_CFL_CSHARP = 0x0A, // C# - CV_CFL_VB = 0x0B, // Visual Basic - CV_CFL_ILASM = 0x0C, // IL (as in CLR) ASM - CV_CFL_JAVA = 0x0D, - CV_CFL_JSCRIPT = 0x0E, - CV_CFL_MSIL = 0x0F, // Unknown MSIL (LTCG of .NETMODULE) - CV_CFL_HLSL = 0x10, // High Level Shader Language -} CV_CFL_LANG; - - -// enum describing target processor - - -typedef enum CV_CPU_TYPE_e { - CV_CFL_8080 = 0x00, - CV_CFL_8086 = 0x01, - CV_CFL_80286 = 0x02, - CV_CFL_80386 = 0x03, - CV_CFL_80486 = 0x04, - CV_CFL_PENTIUM = 0x05, - CV_CFL_PENTIUMII = 0x06, - CV_CFL_PENTIUMPRO = CV_CFL_PENTIUMII, - CV_CFL_PENTIUMIII = 0x07, - CV_CFL_MIPS = 0x10, - CV_CFL_MIPSR4000 = CV_CFL_MIPS, // don't break current code - CV_CFL_MIPS16 = 0x11, - CV_CFL_MIPS32 = 0x12, - CV_CFL_MIPS64 = 0x13, - CV_CFL_MIPSI = 0x14, - CV_CFL_MIPSII = 0x15, - CV_CFL_MIPSIII = 0x16, - CV_CFL_MIPSIV = 0x17, - CV_CFL_MIPSV = 0x18, - CV_CFL_M68000 = 0x20, - CV_CFL_M68010 = 0x21, - CV_CFL_M68020 = 0x22, - CV_CFL_M68030 = 0x23, - CV_CFL_M68040 = 0x24, - CV_CFL_ALPHA = 0x30, - CV_CFL_ALPHA_21064 = 0x30, - CV_CFL_ALPHA_21164 = 0x31, - CV_CFL_ALPHA_21164A = 0x32, - CV_CFL_ALPHA_21264 = 0x33, - CV_CFL_ALPHA_21364 = 0x34, - CV_CFL_PPC601 = 0x40, - CV_CFL_PPC603 = 0x41, - CV_CFL_PPC604 = 0x42, - CV_CFL_PPC620 = 0x43, - CV_CFL_PPCFP = 0x44, - CV_CFL_PPCBE = 0x45, - CV_CFL_SH3 = 0x50, - CV_CFL_SH3E = 0x51, - CV_CFL_SH3DSP = 0x52, - CV_CFL_SH4 = 0x53, - CV_CFL_SHMEDIA = 0x54, - CV_CFL_ARM3 = 0x60, - CV_CFL_ARM4 = 0x61, - CV_CFL_ARM4T = 0x62, - CV_CFL_ARM5 = 0x63, - CV_CFL_ARM5T = 0x64, - CV_CFL_ARM6 = 0x65, - CV_CFL_ARM_XMAC = 0x66, - CV_CFL_ARM_WMMX = 0x67, - CV_CFL_ARM7 = 0x68, - CV_CFL_OMNI = 0x70, - CV_CFL_IA64 = 0x80, - CV_CFL_IA64_1 = 0x80, - CV_CFL_IA64_2 = 0x81, - CV_CFL_CEE = 0x90, - CV_CFL_AM33 = 0xA0, - CV_CFL_M32R = 0xB0, - CV_CFL_TRICORE = 0xC0, - CV_CFL_X64 = 0xD0, - CV_CFL_AMD64 = CV_CFL_X64, - CV_CFL_EBC = 0xE0, - CV_CFL_THUMB = 0xF0, - CV_CFL_ARMNT = 0xF4, - CV_CFL_ARM64 = 0xF6, - CV_CFL_D3D11_SHADER = 0x100, -} CV_CPU_TYPE_e; - -typedef enum CV_HREG_e { - // Register subset shared by all processor types, - // must not overlap with any of the ranges below, hence the high values - - CV_ALLREG_ERR = 30000, - CV_ALLREG_TEB = 30001, - CV_ALLREG_TIMER = 30002, - CV_ALLREG_EFAD1 = 30003, - CV_ALLREG_EFAD2 = 30004, - CV_ALLREG_EFAD3 = 30005, - CV_ALLREG_VFRAME= 30006, - CV_ALLREG_HANDLE= 30007, - CV_ALLREG_PARAMS= 30008, - CV_ALLREG_LOCALS= 30009, - CV_ALLREG_TID = 30010, - CV_ALLREG_ENV = 30011, - CV_ALLREG_CMDLN = 30012, - - - // Register set for the Intel 80x86 and ix86 processor series - // (plus PCODE registers) - - CV_REG_NONE = 0, - CV_REG_AL = 1, - CV_REG_CL = 2, - CV_REG_DL = 3, - CV_REG_BL = 4, - CV_REG_AH = 5, - CV_REG_CH = 6, - CV_REG_DH = 7, - CV_REG_BH = 8, - CV_REG_AX = 9, - CV_REG_CX = 10, - CV_REG_DX = 11, - CV_REG_BX = 12, - CV_REG_SP = 13, - CV_REG_BP = 14, - CV_REG_SI = 15, - CV_REG_DI = 16, - CV_REG_EAX = 17, - CV_REG_ECX = 18, - CV_REG_EDX = 19, - CV_REG_EBX = 20, - CV_REG_ESP = 21, - CV_REG_EBP = 22, - CV_REG_ESI = 23, - CV_REG_EDI = 24, - CV_REG_ES = 25, - CV_REG_CS = 26, - CV_REG_SS = 27, - CV_REG_DS = 28, - CV_REG_FS = 29, - CV_REG_GS = 30, - CV_REG_IP = 31, - CV_REG_FLAGS = 32, - CV_REG_EIP = 33, - CV_REG_EFLAGS = 34, - CV_REG_TEMP = 40, // PCODE Temp - CV_REG_TEMPH = 41, // PCODE TempH - CV_REG_QUOTE = 42, // PCODE Quote - CV_REG_PCDR3 = 43, // PCODE reserved - CV_REG_PCDR4 = 44, // PCODE reserved - CV_REG_PCDR5 = 45, // PCODE reserved - CV_REG_PCDR6 = 46, // PCODE reserved - CV_REG_PCDR7 = 47, // PCODE reserved - CV_REG_CR0 = 80, // CR0 -- control registers - CV_REG_CR1 = 81, - CV_REG_CR2 = 82, - CV_REG_CR3 = 83, - CV_REG_CR4 = 84, // Pentium - CV_REG_DR0 = 90, // Debug register - CV_REG_DR1 = 91, - CV_REG_DR2 = 92, - CV_REG_DR3 = 93, - CV_REG_DR4 = 94, - CV_REG_DR5 = 95, - CV_REG_DR6 = 96, - CV_REG_DR7 = 97, - CV_REG_GDTR = 110, - CV_REG_GDTL = 111, - CV_REG_IDTR = 112, - CV_REG_IDTL = 113, - CV_REG_LDTR = 114, - CV_REG_TR = 115, - - CV_REG_PSEUDO1 = 116, - CV_REG_PSEUDO2 = 117, - CV_REG_PSEUDO3 = 118, - CV_REG_PSEUDO4 = 119, - CV_REG_PSEUDO5 = 120, - CV_REG_PSEUDO6 = 121, - CV_REG_PSEUDO7 = 122, - CV_REG_PSEUDO8 = 123, - CV_REG_PSEUDO9 = 124, - - CV_REG_ST0 = 128, - CV_REG_ST1 = 129, - CV_REG_ST2 = 130, - CV_REG_ST3 = 131, - CV_REG_ST4 = 132, - CV_REG_ST5 = 133, - CV_REG_ST6 = 134, - CV_REG_ST7 = 135, - CV_REG_CTRL = 136, - CV_REG_STAT = 137, - CV_REG_TAG = 138, - CV_REG_FPIP = 139, - CV_REG_FPCS = 140, - CV_REG_FPDO = 141, - CV_REG_FPDS = 142, - CV_REG_ISEM = 143, - CV_REG_FPEIP = 144, - CV_REG_FPEDO = 145, - - CV_REG_MM0 = 146, - CV_REG_MM1 = 147, - CV_REG_MM2 = 148, - CV_REG_MM3 = 149, - CV_REG_MM4 = 150, - CV_REG_MM5 = 151, - CV_REG_MM6 = 152, - CV_REG_MM7 = 153, - - CV_REG_XMM0 = 154, // KATMAI registers - CV_REG_XMM1 = 155, - CV_REG_XMM2 = 156, - CV_REG_XMM3 = 157, - CV_REG_XMM4 = 158, - CV_REG_XMM5 = 159, - CV_REG_XMM6 = 160, - CV_REG_XMM7 = 161, - - CV_REG_XMM00 = 162, // KATMAI sub-registers - CV_REG_XMM01 = 163, - CV_REG_XMM02 = 164, - CV_REG_XMM03 = 165, - CV_REG_XMM10 = 166, - CV_REG_XMM11 = 167, - CV_REG_XMM12 = 168, - CV_REG_XMM13 = 169, - CV_REG_XMM20 = 170, - CV_REG_XMM21 = 171, - CV_REG_XMM22 = 172, - CV_REG_XMM23 = 173, - CV_REG_XMM30 = 174, - CV_REG_XMM31 = 175, - CV_REG_XMM32 = 176, - CV_REG_XMM33 = 177, - CV_REG_XMM40 = 178, - CV_REG_XMM41 = 179, - CV_REG_XMM42 = 180, - CV_REG_XMM43 = 181, - CV_REG_XMM50 = 182, - CV_REG_XMM51 = 183, - CV_REG_XMM52 = 184, - CV_REG_XMM53 = 185, - CV_REG_XMM60 = 186, - CV_REG_XMM61 = 187, - CV_REG_XMM62 = 188, - CV_REG_XMM63 = 189, - CV_REG_XMM70 = 190, - CV_REG_XMM71 = 191, - CV_REG_XMM72 = 192, - CV_REG_XMM73 = 193, - - CV_REG_XMM0L = 194, - CV_REG_XMM1L = 195, - CV_REG_XMM2L = 196, - CV_REG_XMM3L = 197, - CV_REG_XMM4L = 198, - CV_REG_XMM5L = 199, - CV_REG_XMM6L = 200, - CV_REG_XMM7L = 201, - - CV_REG_XMM0H = 202, - CV_REG_XMM1H = 203, - CV_REG_XMM2H = 204, - CV_REG_XMM3H = 205, - CV_REG_XMM4H = 206, - CV_REG_XMM5H = 207, - CV_REG_XMM6H = 208, - CV_REG_XMM7H = 209, - - CV_REG_MXCSR = 211, // XMM status register - - CV_REG_EDXEAX = 212, // EDX:EAX pair - - CV_REG_EMM0L = 220, // XMM sub-registers (WNI integer) - CV_REG_EMM1L = 221, - CV_REG_EMM2L = 222, - CV_REG_EMM3L = 223, - CV_REG_EMM4L = 224, - CV_REG_EMM5L = 225, - CV_REG_EMM6L = 226, - CV_REG_EMM7L = 227, - - CV_REG_EMM0H = 228, - CV_REG_EMM1H = 229, - CV_REG_EMM2H = 230, - CV_REG_EMM3H = 231, - CV_REG_EMM4H = 232, - CV_REG_EMM5H = 233, - CV_REG_EMM6H = 234, - CV_REG_EMM7H = 235, - - // do not change the order of these regs, first one must be even too - CV_REG_MM00 = 236, - CV_REG_MM01 = 237, - CV_REG_MM10 = 238, - CV_REG_MM11 = 239, - CV_REG_MM20 = 240, - CV_REG_MM21 = 241, - CV_REG_MM30 = 242, - CV_REG_MM31 = 243, - CV_REG_MM40 = 244, - CV_REG_MM41 = 245, - CV_REG_MM50 = 246, - CV_REG_MM51 = 247, - CV_REG_MM60 = 248, - CV_REG_MM61 = 249, - CV_REG_MM70 = 250, - CV_REG_MM71 = 251, - - CV_REG_YMM0 = 252, // AVX registers - CV_REG_YMM1 = 253, - CV_REG_YMM2 = 254, - CV_REG_YMM3 = 255, - CV_REG_YMM4 = 256, - CV_REG_YMM5 = 257, - CV_REG_YMM6 = 258, - CV_REG_YMM7 = 259, - - CV_REG_YMM0H = 260, - CV_REG_YMM1H = 261, - CV_REG_YMM2H = 262, - CV_REG_YMM3H = 263, - CV_REG_YMM4H = 264, - CV_REG_YMM5H = 265, - CV_REG_YMM6H = 266, - CV_REG_YMM7H = 267, - - CV_REG_YMM0I0 = 268, // AVX integer registers - CV_REG_YMM0I1 = 269, - CV_REG_YMM0I2 = 270, - CV_REG_YMM0I3 = 271, - CV_REG_YMM1I0 = 272, - CV_REG_YMM1I1 = 273, - CV_REG_YMM1I2 = 274, - CV_REG_YMM1I3 = 275, - CV_REG_YMM2I0 = 276, - CV_REG_YMM2I1 = 277, - CV_REG_YMM2I2 = 278, - CV_REG_YMM2I3 = 279, - CV_REG_YMM3I0 = 280, - CV_REG_YMM3I1 = 281, - CV_REG_YMM3I2 = 282, - CV_REG_YMM3I3 = 283, - CV_REG_YMM4I0 = 284, - CV_REG_YMM4I1 = 285, - CV_REG_YMM4I2 = 286, - CV_REG_YMM4I3 = 287, - CV_REG_YMM5I0 = 288, - CV_REG_YMM5I1 = 289, - CV_REG_YMM5I2 = 290, - CV_REG_YMM5I3 = 291, - CV_REG_YMM6I0 = 292, - CV_REG_YMM6I1 = 293, - CV_REG_YMM6I2 = 294, - CV_REG_YMM6I3 = 295, - CV_REG_YMM7I0 = 296, - CV_REG_YMM7I1 = 297, - CV_REG_YMM7I2 = 298, - CV_REG_YMM7I3 = 299, - - CV_REG_YMM0F0 = 300, // AVX floating-point single precise registers - CV_REG_YMM0F1 = 301, - CV_REG_YMM0F2 = 302, - CV_REG_YMM0F3 = 303, - CV_REG_YMM0F4 = 304, - CV_REG_YMM0F5 = 305, - CV_REG_YMM0F6 = 306, - CV_REG_YMM0F7 = 307, - CV_REG_YMM1F0 = 308, - CV_REG_YMM1F1 = 309, - CV_REG_YMM1F2 = 310, - CV_REG_YMM1F3 = 311, - CV_REG_YMM1F4 = 312, - CV_REG_YMM1F5 = 313, - CV_REG_YMM1F6 = 314, - CV_REG_YMM1F7 = 315, - CV_REG_YMM2F0 = 316, - CV_REG_YMM2F1 = 317, - CV_REG_YMM2F2 = 318, - CV_REG_YMM2F3 = 319, - CV_REG_YMM2F4 = 320, - CV_REG_YMM2F5 = 321, - CV_REG_YMM2F6 = 322, - CV_REG_YMM2F7 = 323, - CV_REG_YMM3F0 = 324, - CV_REG_YMM3F1 = 325, - CV_REG_YMM3F2 = 326, - CV_REG_YMM3F3 = 327, - CV_REG_YMM3F4 = 328, - CV_REG_YMM3F5 = 329, - CV_REG_YMM3F6 = 330, - CV_REG_YMM3F7 = 331, - CV_REG_YMM4F0 = 332, - CV_REG_YMM4F1 = 333, - CV_REG_YMM4F2 = 334, - CV_REG_YMM4F3 = 335, - CV_REG_YMM4F4 = 336, - CV_REG_YMM4F5 = 337, - CV_REG_YMM4F6 = 338, - CV_REG_YMM4F7 = 339, - CV_REG_YMM5F0 = 340, - CV_REG_YMM5F1 = 341, - CV_REG_YMM5F2 = 342, - CV_REG_YMM5F3 = 343, - CV_REG_YMM5F4 = 344, - CV_REG_YMM5F5 = 345, - CV_REG_YMM5F6 = 346, - CV_REG_YMM5F7 = 347, - CV_REG_YMM6F0 = 348, - CV_REG_YMM6F1 = 349, - CV_REG_YMM6F2 = 350, - CV_REG_YMM6F3 = 351, - CV_REG_YMM6F4 = 352, - CV_REG_YMM6F5 = 353, - CV_REG_YMM6F6 = 354, - CV_REG_YMM6F7 = 355, - CV_REG_YMM7F0 = 356, - CV_REG_YMM7F1 = 357, - CV_REG_YMM7F2 = 358, - CV_REG_YMM7F3 = 359, - CV_REG_YMM7F4 = 360, - CV_REG_YMM7F5 = 361, - CV_REG_YMM7F6 = 362, - CV_REG_YMM7F7 = 363, - - CV_REG_YMM0D0 = 364, // AVX floating-point double precise registers - CV_REG_YMM0D1 = 365, - CV_REG_YMM0D2 = 366, - CV_REG_YMM0D3 = 367, - CV_REG_YMM1D0 = 368, - CV_REG_YMM1D1 = 369, - CV_REG_YMM1D2 = 370, - CV_REG_YMM1D3 = 371, - CV_REG_YMM2D0 = 372, - CV_REG_YMM2D1 = 373, - CV_REG_YMM2D2 = 374, - CV_REG_YMM2D3 = 375, - CV_REG_YMM3D0 = 376, - CV_REG_YMM3D1 = 377, - CV_REG_YMM3D2 = 378, - CV_REG_YMM3D3 = 379, - CV_REG_YMM4D0 = 380, - CV_REG_YMM4D1 = 381, - CV_REG_YMM4D2 = 382, - CV_REG_YMM4D3 = 383, - CV_REG_YMM5D0 = 384, - CV_REG_YMM5D1 = 385, - CV_REG_YMM5D2 = 386, - CV_REG_YMM5D3 = 387, - CV_REG_YMM6D0 = 388, - CV_REG_YMM6D1 = 389, - CV_REG_YMM6D2 = 390, - CV_REG_YMM6D3 = 391, - CV_REG_YMM7D0 = 392, - CV_REG_YMM7D1 = 393, - CV_REG_YMM7D2 = 394, - CV_REG_YMM7D3 = 395, - - CV_REG_BND0 = 396, - CV_REG_BND1 = 397, - CV_REG_BND2 = 398, - CV_REG_BND3 = 399, - - // registers for the 68K processors - - CV_R68_D0 = 0, - CV_R68_D1 = 1, - CV_R68_D2 = 2, - CV_R68_D3 = 3, - CV_R68_D4 = 4, - CV_R68_D5 = 5, - CV_R68_D6 = 6, - CV_R68_D7 = 7, - CV_R68_A0 = 8, - CV_R68_A1 = 9, - CV_R68_A2 = 10, - CV_R68_A3 = 11, - CV_R68_A4 = 12, - CV_R68_A5 = 13, - CV_R68_A6 = 14, - CV_R68_A7 = 15, - CV_R68_CCR = 16, - CV_R68_SR = 17, - CV_R68_USP = 18, - CV_R68_MSP = 19, - CV_R68_SFC = 20, - CV_R68_DFC = 21, - CV_R68_CACR = 22, - CV_R68_VBR = 23, - CV_R68_CAAR = 24, - CV_R68_ISP = 25, - CV_R68_PC = 26, - //reserved 27 - CV_R68_FPCR = 28, - CV_R68_FPSR = 29, - CV_R68_FPIAR = 30, - //reserved 31 - CV_R68_FP0 = 32, - CV_R68_FP1 = 33, - CV_R68_FP2 = 34, - CV_R68_FP3 = 35, - CV_R68_FP4 = 36, - CV_R68_FP5 = 37, - CV_R68_FP6 = 38, - CV_R68_FP7 = 39, - //reserved 40 - CV_R68_MMUSR030 = 41, - CV_R68_MMUSR = 42, - CV_R68_URP = 43, - CV_R68_DTT0 = 44, - CV_R68_DTT1 = 45, - CV_R68_ITT0 = 46, - CV_R68_ITT1 = 47, - //reserved 50 - CV_R68_PSR = 51, - CV_R68_PCSR = 52, - CV_R68_VAL = 53, - CV_R68_CRP = 54, - CV_R68_SRP = 55, - CV_R68_DRP = 56, - CV_R68_TC = 57, - CV_R68_AC = 58, - CV_R68_SCC = 59, - CV_R68_CAL = 60, - CV_R68_TT0 = 61, - CV_R68_TT1 = 62, - //reserved 63 - CV_R68_BAD0 = 64, - CV_R68_BAD1 = 65, - CV_R68_BAD2 = 66, - CV_R68_BAD3 = 67, - CV_R68_BAD4 = 68, - CV_R68_BAD5 = 69, - CV_R68_BAD6 = 70, - CV_R68_BAD7 = 71, - CV_R68_BAC0 = 72, - CV_R68_BAC1 = 73, - CV_R68_BAC2 = 74, - CV_R68_BAC3 = 75, - CV_R68_BAC4 = 76, - CV_R68_BAC5 = 77, - CV_R68_BAC6 = 78, - CV_R68_BAC7 = 79, - - // Register set for the MIPS 4000 - - CV_M4_NOREG = CV_REG_NONE, - - CV_M4_IntZERO = 10, /* CPU REGISTER */ - CV_M4_IntAT = 11, - CV_M4_IntV0 = 12, - CV_M4_IntV1 = 13, - CV_M4_IntA0 = 14, - CV_M4_IntA1 = 15, - CV_M4_IntA2 = 16, - CV_M4_IntA3 = 17, - CV_M4_IntT0 = 18, - CV_M4_IntT1 = 19, - CV_M4_IntT2 = 20, - CV_M4_IntT3 = 21, - CV_M4_IntT4 = 22, - CV_M4_IntT5 = 23, - CV_M4_IntT6 = 24, - CV_M4_IntT7 = 25, - CV_M4_IntS0 = 26, - CV_M4_IntS1 = 27, - CV_M4_IntS2 = 28, - CV_M4_IntS3 = 29, - CV_M4_IntS4 = 30, - CV_M4_IntS5 = 31, - CV_M4_IntS6 = 32, - CV_M4_IntS7 = 33, - CV_M4_IntT8 = 34, - CV_M4_IntT9 = 35, - CV_M4_IntKT0 = 36, - CV_M4_IntKT1 = 37, - CV_M4_IntGP = 38, - CV_M4_IntSP = 39, - CV_M4_IntS8 = 40, - CV_M4_IntRA = 41, - CV_M4_IntLO = 42, - CV_M4_IntHI = 43, - - CV_M4_Fir = 50, - CV_M4_Psr = 51, - - CV_M4_FltF0 = 60, /* Floating point registers */ - CV_M4_FltF1 = 61, - CV_M4_FltF2 = 62, - CV_M4_FltF3 = 63, - CV_M4_FltF4 = 64, - CV_M4_FltF5 = 65, - CV_M4_FltF6 = 66, - CV_M4_FltF7 = 67, - CV_M4_FltF8 = 68, - CV_M4_FltF9 = 69, - CV_M4_FltF10 = 70, - CV_M4_FltF11 = 71, - CV_M4_FltF12 = 72, - CV_M4_FltF13 = 73, - CV_M4_FltF14 = 74, - CV_M4_FltF15 = 75, - CV_M4_FltF16 = 76, - CV_M4_FltF17 = 77, - CV_M4_FltF18 = 78, - CV_M4_FltF19 = 79, - CV_M4_FltF20 = 80, - CV_M4_FltF21 = 81, - CV_M4_FltF22 = 82, - CV_M4_FltF23 = 83, - CV_M4_FltF24 = 84, - CV_M4_FltF25 = 85, - CV_M4_FltF26 = 86, - CV_M4_FltF27 = 87, - CV_M4_FltF28 = 88, - CV_M4_FltF29 = 89, - CV_M4_FltF30 = 90, - CV_M4_FltF31 = 91, - CV_M4_FltFsr = 92, - - - // Register set for the ALPHA AXP - - CV_ALPHA_NOREG = CV_REG_NONE, - - CV_ALPHA_FltF0 = 10, // Floating point registers - CV_ALPHA_FltF1 = 11, - CV_ALPHA_FltF2 = 12, - CV_ALPHA_FltF3 = 13, - CV_ALPHA_FltF4 = 14, - CV_ALPHA_FltF5 = 15, - CV_ALPHA_FltF6 = 16, - CV_ALPHA_FltF7 = 17, - CV_ALPHA_FltF8 = 18, - CV_ALPHA_FltF9 = 19, - CV_ALPHA_FltF10 = 20, - CV_ALPHA_FltF11 = 21, - CV_ALPHA_FltF12 = 22, - CV_ALPHA_FltF13 = 23, - CV_ALPHA_FltF14 = 24, - CV_ALPHA_FltF15 = 25, - CV_ALPHA_FltF16 = 26, - CV_ALPHA_FltF17 = 27, - CV_ALPHA_FltF18 = 28, - CV_ALPHA_FltF19 = 29, - CV_ALPHA_FltF20 = 30, - CV_ALPHA_FltF21 = 31, - CV_ALPHA_FltF22 = 32, - CV_ALPHA_FltF23 = 33, - CV_ALPHA_FltF24 = 34, - CV_ALPHA_FltF25 = 35, - CV_ALPHA_FltF26 = 36, - CV_ALPHA_FltF27 = 37, - CV_ALPHA_FltF28 = 38, - CV_ALPHA_FltF29 = 39, - CV_ALPHA_FltF30 = 40, - CV_ALPHA_FltF31 = 41, - - CV_ALPHA_IntV0 = 42, // Integer registers - CV_ALPHA_IntT0 = 43, - CV_ALPHA_IntT1 = 44, - CV_ALPHA_IntT2 = 45, - CV_ALPHA_IntT3 = 46, - CV_ALPHA_IntT4 = 47, - CV_ALPHA_IntT5 = 48, - CV_ALPHA_IntT6 = 49, - CV_ALPHA_IntT7 = 50, - CV_ALPHA_IntS0 = 51, - CV_ALPHA_IntS1 = 52, - CV_ALPHA_IntS2 = 53, - CV_ALPHA_IntS3 = 54, - CV_ALPHA_IntS4 = 55, - CV_ALPHA_IntS5 = 56, - CV_ALPHA_IntFP = 57, - CV_ALPHA_IntA0 = 58, - CV_ALPHA_IntA1 = 59, - CV_ALPHA_IntA2 = 60, - CV_ALPHA_IntA3 = 61, - CV_ALPHA_IntA4 = 62, - CV_ALPHA_IntA5 = 63, - CV_ALPHA_IntT8 = 64, - CV_ALPHA_IntT9 = 65, - CV_ALPHA_IntT10 = 66, - CV_ALPHA_IntT11 = 67, - CV_ALPHA_IntRA = 68, - CV_ALPHA_IntT12 = 69, - CV_ALPHA_IntAT = 70, - CV_ALPHA_IntGP = 71, - CV_ALPHA_IntSP = 72, - CV_ALPHA_IntZERO = 73, - - - CV_ALPHA_Fpcr = 74, // Control registers - CV_ALPHA_Fir = 75, - CV_ALPHA_Psr = 76, - CV_ALPHA_FltFsr = 77, - CV_ALPHA_SoftFpcr = 78, - - // Register Set for Motorola/IBM PowerPC - - /* - ** PowerPC General Registers ( User Level ) - */ - CV_PPC_GPR0 = 1, - CV_PPC_GPR1 = 2, - CV_PPC_GPR2 = 3, - CV_PPC_GPR3 = 4, - CV_PPC_GPR4 = 5, - CV_PPC_GPR5 = 6, - CV_PPC_GPR6 = 7, - CV_PPC_GPR7 = 8, - CV_PPC_GPR8 = 9, - CV_PPC_GPR9 = 10, - CV_PPC_GPR10 = 11, - CV_PPC_GPR11 = 12, - CV_PPC_GPR12 = 13, - CV_PPC_GPR13 = 14, - CV_PPC_GPR14 = 15, - CV_PPC_GPR15 = 16, - CV_PPC_GPR16 = 17, - CV_PPC_GPR17 = 18, - CV_PPC_GPR18 = 19, - CV_PPC_GPR19 = 20, - CV_PPC_GPR20 = 21, - CV_PPC_GPR21 = 22, - CV_PPC_GPR22 = 23, - CV_PPC_GPR23 = 24, - CV_PPC_GPR24 = 25, - CV_PPC_GPR25 = 26, - CV_PPC_GPR26 = 27, - CV_PPC_GPR27 = 28, - CV_PPC_GPR28 = 29, - CV_PPC_GPR29 = 30, - CV_PPC_GPR30 = 31, - CV_PPC_GPR31 = 32, - - /* - ** PowerPC Condition Register ( User Level ) - */ - CV_PPC_CR = 33, - CV_PPC_CR0 = 34, - CV_PPC_CR1 = 35, - CV_PPC_CR2 = 36, - CV_PPC_CR3 = 37, - CV_PPC_CR4 = 38, - CV_PPC_CR5 = 39, - CV_PPC_CR6 = 40, - CV_PPC_CR7 = 41, - - /* - ** PowerPC Floating Point Registers ( User Level ) - */ - CV_PPC_FPR0 = 42, - CV_PPC_FPR1 = 43, - CV_PPC_FPR2 = 44, - CV_PPC_FPR3 = 45, - CV_PPC_FPR4 = 46, - CV_PPC_FPR5 = 47, - CV_PPC_FPR6 = 48, - CV_PPC_FPR7 = 49, - CV_PPC_FPR8 = 50, - CV_PPC_FPR9 = 51, - CV_PPC_FPR10 = 52, - CV_PPC_FPR11 = 53, - CV_PPC_FPR12 = 54, - CV_PPC_FPR13 = 55, - CV_PPC_FPR14 = 56, - CV_PPC_FPR15 = 57, - CV_PPC_FPR16 = 58, - CV_PPC_FPR17 = 59, - CV_PPC_FPR18 = 60, - CV_PPC_FPR19 = 61, - CV_PPC_FPR20 = 62, - CV_PPC_FPR21 = 63, - CV_PPC_FPR22 = 64, - CV_PPC_FPR23 = 65, - CV_PPC_FPR24 = 66, - CV_PPC_FPR25 = 67, - CV_PPC_FPR26 = 68, - CV_PPC_FPR27 = 69, - CV_PPC_FPR28 = 70, - CV_PPC_FPR29 = 71, - CV_PPC_FPR30 = 72, - CV_PPC_FPR31 = 73, - - /* - ** PowerPC Floating Point Status and Control Register ( User Level ) - */ - CV_PPC_FPSCR = 74, - - /* - ** PowerPC Machine State Register ( Supervisor Level ) - */ - CV_PPC_MSR = 75, - - /* - ** PowerPC Segment Registers ( Supervisor Level ) - */ - CV_PPC_SR0 = 76, - CV_PPC_SR1 = 77, - CV_PPC_SR2 = 78, - CV_PPC_SR3 = 79, - CV_PPC_SR4 = 80, - CV_PPC_SR5 = 81, - CV_PPC_SR6 = 82, - CV_PPC_SR7 = 83, - CV_PPC_SR8 = 84, - CV_PPC_SR9 = 85, - CV_PPC_SR10 = 86, - CV_PPC_SR11 = 87, - CV_PPC_SR12 = 88, - CV_PPC_SR13 = 89, - CV_PPC_SR14 = 90, - CV_PPC_SR15 = 91, - - /* - ** For all of the special purpose registers add 100 to the SPR# that the - ** Motorola/IBM documentation gives with the exception of any imaginary - ** registers. - */ - - /* - ** PowerPC Special Purpose Registers ( User Level ) - */ - CV_PPC_PC = 99, // PC (imaginary register) - - CV_PPC_MQ = 100, // MPC601 - CV_PPC_XER = 101, - CV_PPC_RTCU = 104, // MPC601 - CV_PPC_RTCL = 105, // MPC601 - CV_PPC_LR = 108, - CV_PPC_CTR = 109, - - CV_PPC_COMPARE = 110, // part of XER (internal to the debugger only) - CV_PPC_COUNT = 111, // part of XER (internal to the debugger only) - - /* - ** PowerPC Special Purpose Registers ( Supervisor Level ) - */ - CV_PPC_DSISR = 118, - CV_PPC_DAR = 119, - CV_PPC_DEC = 122, - CV_PPC_SDR1 = 125, - CV_PPC_SRR0 = 126, - CV_PPC_SRR1 = 127, - CV_PPC_SPRG0 = 372, - CV_PPC_SPRG1 = 373, - CV_PPC_SPRG2 = 374, - CV_PPC_SPRG3 = 375, - CV_PPC_ASR = 280, // 64-bit implementations only - CV_PPC_EAR = 382, - CV_PPC_PVR = 287, - CV_PPC_BAT0U = 628, - CV_PPC_BAT0L = 629, - CV_PPC_BAT1U = 630, - CV_PPC_BAT1L = 631, - CV_PPC_BAT2U = 632, - CV_PPC_BAT2L = 633, - CV_PPC_BAT3U = 634, - CV_PPC_BAT3L = 635, - CV_PPC_DBAT0U = 636, - CV_PPC_DBAT0L = 637, - CV_PPC_DBAT1U = 638, - CV_PPC_DBAT1L = 639, - CV_PPC_DBAT2U = 640, - CV_PPC_DBAT2L = 641, - CV_PPC_DBAT3U = 642, - CV_PPC_DBAT3L = 643, - - /* - ** PowerPC Special Purpose Registers Implementation Dependent ( Supervisor Level ) - */ - - /* - ** Doesn't appear that IBM/Motorola has finished defining these. - */ - - CV_PPC_PMR0 = 1044, // MPC620, - CV_PPC_PMR1 = 1045, // MPC620, - CV_PPC_PMR2 = 1046, // MPC620, - CV_PPC_PMR3 = 1047, // MPC620, - CV_PPC_PMR4 = 1048, // MPC620, - CV_PPC_PMR5 = 1049, // MPC620, - CV_PPC_PMR6 = 1050, // MPC620, - CV_PPC_PMR7 = 1051, // MPC620, - CV_PPC_PMR8 = 1052, // MPC620, - CV_PPC_PMR9 = 1053, // MPC620, - CV_PPC_PMR10 = 1054, // MPC620, - CV_PPC_PMR11 = 1055, // MPC620, - CV_PPC_PMR12 = 1056, // MPC620, - CV_PPC_PMR13 = 1057, // MPC620, - CV_PPC_PMR14 = 1058, // MPC620, - CV_PPC_PMR15 = 1059, // MPC620, - - CV_PPC_DMISS = 1076, // MPC603 - CV_PPC_DCMP = 1077, // MPC603 - CV_PPC_HASH1 = 1078, // MPC603 - CV_PPC_HASH2 = 1079, // MPC603 - CV_PPC_IMISS = 1080, // MPC603 - CV_PPC_ICMP = 1081, // MPC603 - CV_PPC_RPA = 1082, // MPC603 - - CV_PPC_HID0 = 1108, // MPC601, MPC603, MPC620 - CV_PPC_HID1 = 1109, // MPC601 - CV_PPC_HID2 = 1110, // MPC601, MPC603, MPC620 ( IABR ) - CV_PPC_HID3 = 1111, // Not Defined - CV_PPC_HID4 = 1112, // Not Defined - CV_PPC_HID5 = 1113, // MPC601, MPC604, MPC620 ( DABR ) - CV_PPC_HID6 = 1114, // Not Defined - CV_PPC_HID7 = 1115, // Not Defined - CV_PPC_HID8 = 1116, // MPC620 ( BUSCSR ) - CV_PPC_HID9 = 1117, // MPC620 ( L2CSR ) - CV_PPC_HID10 = 1118, // Not Defined - CV_PPC_HID11 = 1119, // Not Defined - CV_PPC_HID12 = 1120, // Not Defined - CV_PPC_HID13 = 1121, // MPC604 ( HCR ) - CV_PPC_HID14 = 1122, // Not Defined - CV_PPC_HID15 = 1123, // MPC601, MPC604, MPC620 ( PIR ) - - // - // JAVA VM registers - // - - CV_JAVA_PC = 1, - - // - // Register set for the Hitachi SH3 - // - - CV_SH3_NOREG = CV_REG_NONE, - - CV_SH3_IntR0 = 10, // CPU REGISTER - CV_SH3_IntR1 = 11, - CV_SH3_IntR2 = 12, - CV_SH3_IntR3 = 13, - CV_SH3_IntR4 = 14, - CV_SH3_IntR5 = 15, - CV_SH3_IntR6 = 16, - CV_SH3_IntR7 = 17, - CV_SH3_IntR8 = 18, - CV_SH3_IntR9 = 19, - CV_SH3_IntR10 = 20, - CV_SH3_IntR11 = 21, - CV_SH3_IntR12 = 22, - CV_SH3_IntR13 = 23, - CV_SH3_IntFp = 24, - CV_SH3_IntSp = 25, - CV_SH3_Gbr = 38, - CV_SH3_Pr = 39, - CV_SH3_Mach = 40, - CV_SH3_Macl = 41, - - CV_SH3_Pc = 50, - CV_SH3_Sr = 51, - - CV_SH3_BarA = 60, - CV_SH3_BasrA = 61, - CV_SH3_BamrA = 62, - CV_SH3_BbrA = 63, - CV_SH3_BarB = 64, - CV_SH3_BasrB = 65, - CV_SH3_BamrB = 66, - CV_SH3_BbrB = 67, - CV_SH3_BdrB = 68, - CV_SH3_BdmrB = 69, - CV_SH3_Brcr = 70, - - // - // Additional registers for Hitachi SH processors - // - - CV_SH_Fpscr = 75, // floating point status/control register - CV_SH_Fpul = 76, // floating point communication register - - CV_SH_FpR0 = 80, // Floating point registers - CV_SH_FpR1 = 81, - CV_SH_FpR2 = 82, - CV_SH_FpR3 = 83, - CV_SH_FpR4 = 84, - CV_SH_FpR5 = 85, - CV_SH_FpR6 = 86, - CV_SH_FpR7 = 87, - CV_SH_FpR8 = 88, - CV_SH_FpR9 = 89, - CV_SH_FpR10 = 90, - CV_SH_FpR11 = 91, - CV_SH_FpR12 = 92, - CV_SH_FpR13 = 93, - CV_SH_FpR14 = 94, - CV_SH_FpR15 = 95, - - CV_SH_XFpR0 = 96, - CV_SH_XFpR1 = 97, - CV_SH_XFpR2 = 98, - CV_SH_XFpR3 = 99, - CV_SH_XFpR4 = 100, - CV_SH_XFpR5 = 101, - CV_SH_XFpR6 = 102, - CV_SH_XFpR7 = 103, - CV_SH_XFpR8 = 104, - CV_SH_XFpR9 = 105, - CV_SH_XFpR10 = 106, - CV_SH_XFpR11 = 107, - CV_SH_XFpR12 = 108, - CV_SH_XFpR13 = 109, - CV_SH_XFpR14 = 110, - CV_SH_XFpR15 = 111, - - // - // Register set for the ARM processor. - // - - CV_ARM_NOREG = CV_REG_NONE, - - CV_ARM_R0 = 10, - CV_ARM_R1 = 11, - CV_ARM_R2 = 12, - CV_ARM_R3 = 13, - CV_ARM_R4 = 14, - CV_ARM_R5 = 15, - CV_ARM_R6 = 16, - CV_ARM_R7 = 17, - CV_ARM_R8 = 18, - CV_ARM_R9 = 19, - CV_ARM_R10 = 20, - CV_ARM_R11 = 21, // Frame pointer, if allocated - CV_ARM_R12 = 22, - CV_ARM_SP = 23, // Stack pointer - CV_ARM_LR = 24, // Link Register - CV_ARM_PC = 25, // Program counter - CV_ARM_CPSR = 26, // Current program status register - - CV_ARM_ACC0 = 27, // DSP co-processor 0 40 bit accumulator - - // - // Registers for ARM VFP10 support - // - - CV_ARM_FPSCR = 40, - CV_ARM_FPEXC = 41, - - CV_ARM_FS0 = 50, - CV_ARM_FS1 = 51, - CV_ARM_FS2 = 52, - CV_ARM_FS3 = 53, - CV_ARM_FS4 = 54, - CV_ARM_FS5 = 55, - CV_ARM_FS6 = 56, - CV_ARM_FS7 = 57, - CV_ARM_FS8 = 58, - CV_ARM_FS9 = 59, - CV_ARM_FS10 = 60, - CV_ARM_FS11 = 61, - CV_ARM_FS12 = 62, - CV_ARM_FS13 = 63, - CV_ARM_FS14 = 64, - CV_ARM_FS15 = 65, - CV_ARM_FS16 = 66, - CV_ARM_FS17 = 67, - CV_ARM_FS18 = 68, - CV_ARM_FS19 = 69, - CV_ARM_FS20 = 70, - CV_ARM_FS21 = 71, - CV_ARM_FS22 = 72, - CV_ARM_FS23 = 73, - CV_ARM_FS24 = 74, - CV_ARM_FS25 = 75, - CV_ARM_FS26 = 76, - CV_ARM_FS27 = 77, - CV_ARM_FS28 = 78, - CV_ARM_FS29 = 79, - CV_ARM_FS30 = 80, - CV_ARM_FS31 = 81, - - // - // ARM VFP Floating Point Extra control registers - // - - CV_ARM_FPEXTRA0 = 90, - CV_ARM_FPEXTRA1 = 91, - CV_ARM_FPEXTRA2 = 92, - CV_ARM_FPEXTRA3 = 93, - CV_ARM_FPEXTRA4 = 94, - CV_ARM_FPEXTRA5 = 95, - CV_ARM_FPEXTRA6 = 96, - CV_ARM_FPEXTRA7 = 97, - - // XSCALE Concan co-processor registers - CV_ARM_WR0 = 128, - CV_ARM_WR1 = 129, - CV_ARM_WR2 = 130, - CV_ARM_WR3 = 131, - CV_ARM_WR4 = 132, - CV_ARM_WR5 = 133, - CV_ARM_WR6 = 134, - CV_ARM_WR7 = 135, - CV_ARM_WR8 = 136, - CV_ARM_WR9 = 137, - CV_ARM_WR10 = 138, - CV_ARM_WR11 = 139, - CV_ARM_WR12 = 140, - CV_ARM_WR13 = 141, - CV_ARM_WR14 = 142, - CV_ARM_WR15 = 143, - - // XSCALE Concan co-processor control registers - CV_ARM_WCID = 144, - CV_ARM_WCON = 145, - CV_ARM_WCSSF = 146, - CV_ARM_WCASF = 147, - CV_ARM_WC4 = 148, - CV_ARM_WC5 = 149, - CV_ARM_WC6 = 150, - CV_ARM_WC7 = 151, - CV_ARM_WCGR0 = 152, - CV_ARM_WCGR1 = 153, - CV_ARM_WCGR2 = 154, - CV_ARM_WCGR3 = 155, - CV_ARM_WC12 = 156, - CV_ARM_WC13 = 157, - CV_ARM_WC14 = 158, - CV_ARM_WC15 = 159, - - // - // ARM VFPv3/Neon extended floating Point - // - - CV_ARM_FS32 = 200, - CV_ARM_FS33 = 201, - CV_ARM_FS34 = 202, - CV_ARM_FS35 = 203, - CV_ARM_FS36 = 204, - CV_ARM_FS37 = 205, - CV_ARM_FS38 = 206, - CV_ARM_FS39 = 207, - CV_ARM_FS40 = 208, - CV_ARM_FS41 = 209, - CV_ARM_FS42 = 210, - CV_ARM_FS43 = 211, - CV_ARM_FS44 = 212, - CV_ARM_FS45 = 213, - CV_ARM_FS46 = 214, - CV_ARM_FS47 = 215, - CV_ARM_FS48 = 216, - CV_ARM_FS49 = 217, - CV_ARM_FS50 = 218, - CV_ARM_FS51 = 219, - CV_ARM_FS52 = 220, - CV_ARM_FS53 = 221, - CV_ARM_FS54 = 222, - CV_ARM_FS55 = 223, - CV_ARM_FS56 = 224, - CV_ARM_FS57 = 225, - CV_ARM_FS58 = 226, - CV_ARM_FS59 = 227, - CV_ARM_FS60 = 228, - CV_ARM_FS61 = 229, - CV_ARM_FS62 = 230, - CV_ARM_FS63 = 231, - - // ARM double-precision floating point - - CV_ARM_ND0 = 300, - CV_ARM_ND1 = 301, - CV_ARM_ND2 = 302, - CV_ARM_ND3 = 303, - CV_ARM_ND4 = 304, - CV_ARM_ND5 = 305, - CV_ARM_ND6 = 306, - CV_ARM_ND7 = 307, - CV_ARM_ND8 = 308, - CV_ARM_ND9 = 309, - CV_ARM_ND10 = 310, - CV_ARM_ND11 = 311, - CV_ARM_ND12 = 312, - CV_ARM_ND13 = 313, - CV_ARM_ND14 = 314, - CV_ARM_ND15 = 315, - CV_ARM_ND16 = 316, - CV_ARM_ND17 = 317, - CV_ARM_ND18 = 318, - CV_ARM_ND19 = 319, - CV_ARM_ND20 = 320, - CV_ARM_ND21 = 321, - CV_ARM_ND22 = 322, - CV_ARM_ND23 = 323, - CV_ARM_ND24 = 324, - CV_ARM_ND25 = 325, - CV_ARM_ND26 = 326, - CV_ARM_ND27 = 327, - CV_ARM_ND28 = 328, - CV_ARM_ND29 = 329, - CV_ARM_ND30 = 330, - CV_ARM_ND31 = 331, - - // ARM extended precision floating point - - CV_ARM_NQ0 = 400, - CV_ARM_NQ1 = 401, - CV_ARM_NQ2 = 402, - CV_ARM_NQ3 = 403, - CV_ARM_NQ4 = 404, - CV_ARM_NQ5 = 405, - CV_ARM_NQ6 = 406, - CV_ARM_NQ7 = 407, - CV_ARM_NQ8 = 408, - CV_ARM_NQ9 = 409, - CV_ARM_NQ10 = 410, - CV_ARM_NQ11 = 411, - CV_ARM_NQ12 = 412, - CV_ARM_NQ13 = 413, - CV_ARM_NQ14 = 414, - CV_ARM_NQ15 = 415, - - // - // Register set for ARM64 - // - - CV_ARM64_NOREG = CV_REG_NONE, - - // General purpose 32-bit integer registers - - CV_ARM64_W0 = 10, - CV_ARM64_W1 = 11, - CV_ARM64_W2 = 12, - CV_ARM64_W3 = 13, - CV_ARM64_W4 = 14, - CV_ARM64_W5 = 15, - CV_ARM64_W6 = 16, - CV_ARM64_W7 = 17, - CV_ARM64_W8 = 18, - CV_ARM64_W9 = 19, - CV_ARM64_W10 = 20, - CV_ARM64_W11 = 21, - CV_ARM64_W12 = 22, - CV_ARM64_W13 = 23, - CV_ARM64_W14 = 24, - CV_ARM64_W15 = 25, - CV_ARM64_W16 = 26, - CV_ARM64_W17 = 27, - CV_ARM64_W18 = 28, - CV_ARM64_W19 = 29, - CV_ARM64_W20 = 30, - CV_ARM64_W21 = 31, - CV_ARM64_W22 = 32, - CV_ARM64_W23 = 33, - CV_ARM64_W24 = 34, - CV_ARM64_W25 = 35, - CV_ARM64_W26 = 36, - CV_ARM64_W27 = 37, - CV_ARM64_W28 = 38, - CV_ARM64_W29 = 39, - CV_ARM64_W30 = 40, - CV_ARM64_WZR = 41, - - // General purpose 64-bit integer registers - - CV_ARM64_X0 = 50, - CV_ARM64_X1 = 51, - CV_ARM64_X2 = 52, - CV_ARM64_X3 = 53, - CV_ARM64_X4 = 54, - CV_ARM64_X5 = 55, - CV_ARM64_X6 = 56, - CV_ARM64_X7 = 57, - CV_ARM64_X8 = 58, - CV_ARM64_X9 = 59, - CV_ARM64_X10 = 60, - CV_ARM64_X11 = 61, - CV_ARM64_X12 = 62, - CV_ARM64_X13 = 63, - CV_ARM64_X14 = 64, - CV_ARM64_X15 = 65, - CV_ARM64_IP0 = 66, - CV_ARM64_IP1 = 67, - CV_ARM64_X18 = 68, - CV_ARM64_X19 = 69, - CV_ARM64_X20 = 70, - CV_ARM64_X21 = 71, - CV_ARM64_X22 = 72, - CV_ARM64_X23 = 73, - CV_ARM64_X24 = 74, - CV_ARM64_X25 = 75, - CV_ARM64_X26 = 76, - CV_ARM64_X27 = 77, - CV_ARM64_X28 = 78, - CV_ARM64_FP = 79, - CV_ARM64_LR = 80, - CV_ARM64_SP = 81, - CV_ARM64_ZR = 82, - CV_ARM64_PC = 83, - - // status registers - - CV_ARM64_NZCV = 90, - CV_ARM64_CPSR = 91, - - // 32-bit floating point registers - - CV_ARM64_S0 = 100, - CV_ARM64_S1 = 101, - CV_ARM64_S2 = 102, - CV_ARM64_S3 = 103, - CV_ARM64_S4 = 104, - CV_ARM64_S5 = 105, - CV_ARM64_S6 = 106, - CV_ARM64_S7 = 107, - CV_ARM64_S8 = 108, - CV_ARM64_S9 = 109, - CV_ARM64_S10 = 110, - CV_ARM64_S11 = 111, - CV_ARM64_S12 = 112, - CV_ARM64_S13 = 113, - CV_ARM64_S14 = 114, - CV_ARM64_S15 = 115, - CV_ARM64_S16 = 116, - CV_ARM64_S17 = 117, - CV_ARM64_S18 = 118, - CV_ARM64_S19 = 119, - CV_ARM64_S20 = 120, - CV_ARM64_S21 = 121, - CV_ARM64_S22 = 122, - CV_ARM64_S23 = 123, - CV_ARM64_S24 = 124, - CV_ARM64_S25 = 125, - CV_ARM64_S26 = 126, - CV_ARM64_S27 = 127, - CV_ARM64_S28 = 128, - CV_ARM64_S29 = 129, - CV_ARM64_S30 = 130, - CV_ARM64_S31 = 131, - - // 64-bit floating point registers - - CV_ARM64_D0 = 140, - CV_ARM64_D1 = 141, - CV_ARM64_D2 = 142, - CV_ARM64_D3 = 143, - CV_ARM64_D4 = 144, - CV_ARM64_D5 = 145, - CV_ARM64_D6 = 146, - CV_ARM64_D7 = 147, - CV_ARM64_D8 = 148, - CV_ARM64_D9 = 149, - CV_ARM64_D10 = 150, - CV_ARM64_D11 = 151, - CV_ARM64_D12 = 152, - CV_ARM64_D13 = 153, - CV_ARM64_D14 = 154, - CV_ARM64_D15 = 155, - CV_ARM64_D16 = 156, - CV_ARM64_D17 = 157, - CV_ARM64_D18 = 158, - CV_ARM64_D19 = 159, - CV_ARM64_D20 = 160, - CV_ARM64_D21 = 161, - CV_ARM64_D22 = 162, - CV_ARM64_D23 = 163, - CV_ARM64_D24 = 164, - CV_ARM64_D25 = 165, - CV_ARM64_D26 = 166, - CV_ARM64_D27 = 167, - CV_ARM64_D28 = 168, - CV_ARM64_D29 = 169, - CV_ARM64_D30 = 170, - CV_ARM64_D31 = 171, - - // 128-bit SIMD registers - - CV_ARM64_Q0 = 180, - CV_ARM64_Q1 = 181, - CV_ARM64_Q2 = 182, - CV_ARM64_Q3 = 183, - CV_ARM64_Q4 = 184, - CV_ARM64_Q5 = 185, - CV_ARM64_Q6 = 186, - CV_ARM64_Q7 = 187, - CV_ARM64_Q8 = 188, - CV_ARM64_Q9 = 189, - CV_ARM64_Q10 = 190, - CV_ARM64_Q11 = 191, - CV_ARM64_Q12 = 192, - CV_ARM64_Q13 = 193, - CV_ARM64_Q14 = 194, - CV_ARM64_Q15 = 195, - CV_ARM64_Q16 = 196, - CV_ARM64_Q17 = 197, - CV_ARM64_Q18 = 198, - CV_ARM64_Q19 = 199, - CV_ARM64_Q20 = 200, - CV_ARM64_Q21 = 201, - CV_ARM64_Q22 = 202, - CV_ARM64_Q23 = 203, - CV_ARM64_Q24 = 204, - CV_ARM64_Q25 = 205, - CV_ARM64_Q26 = 206, - CV_ARM64_Q27 = 207, - CV_ARM64_Q28 = 208, - CV_ARM64_Q29 = 209, - CV_ARM64_Q30 = 210, - CV_ARM64_Q31 = 211, - - // Floating point status register - - CV_ARM64_FPSR = 220, - - // - // Register set for Intel IA64 - // - - CV_IA64_NOREG = CV_REG_NONE, - - // Branch Registers - - CV_IA64_Br0 = 512, - CV_IA64_Br1 = 513, - CV_IA64_Br2 = 514, - CV_IA64_Br3 = 515, - CV_IA64_Br4 = 516, - CV_IA64_Br5 = 517, - CV_IA64_Br6 = 518, - CV_IA64_Br7 = 519, - - // Predicate Registers - - CV_IA64_P0 = 704, - CV_IA64_P1 = 705, - CV_IA64_P2 = 706, - CV_IA64_P3 = 707, - CV_IA64_P4 = 708, - CV_IA64_P5 = 709, - CV_IA64_P6 = 710, - CV_IA64_P7 = 711, - CV_IA64_P8 = 712, - CV_IA64_P9 = 713, - CV_IA64_P10 = 714, - CV_IA64_P11 = 715, - CV_IA64_P12 = 716, - CV_IA64_P13 = 717, - CV_IA64_P14 = 718, - CV_IA64_P15 = 719, - CV_IA64_P16 = 720, - CV_IA64_P17 = 721, - CV_IA64_P18 = 722, - CV_IA64_P19 = 723, - CV_IA64_P20 = 724, - CV_IA64_P21 = 725, - CV_IA64_P22 = 726, - CV_IA64_P23 = 727, - CV_IA64_P24 = 728, - CV_IA64_P25 = 729, - CV_IA64_P26 = 730, - CV_IA64_P27 = 731, - CV_IA64_P28 = 732, - CV_IA64_P29 = 733, - CV_IA64_P30 = 734, - CV_IA64_P31 = 735, - CV_IA64_P32 = 736, - CV_IA64_P33 = 737, - CV_IA64_P34 = 738, - CV_IA64_P35 = 739, - CV_IA64_P36 = 740, - CV_IA64_P37 = 741, - CV_IA64_P38 = 742, - CV_IA64_P39 = 743, - CV_IA64_P40 = 744, - CV_IA64_P41 = 745, - CV_IA64_P42 = 746, - CV_IA64_P43 = 747, - CV_IA64_P44 = 748, - CV_IA64_P45 = 749, - CV_IA64_P46 = 750, - CV_IA64_P47 = 751, - CV_IA64_P48 = 752, - CV_IA64_P49 = 753, - CV_IA64_P50 = 754, - CV_IA64_P51 = 755, - CV_IA64_P52 = 756, - CV_IA64_P53 = 757, - CV_IA64_P54 = 758, - CV_IA64_P55 = 759, - CV_IA64_P56 = 760, - CV_IA64_P57 = 761, - CV_IA64_P58 = 762, - CV_IA64_P59 = 763, - CV_IA64_P60 = 764, - CV_IA64_P61 = 765, - CV_IA64_P62 = 766, - CV_IA64_P63 = 767, - - CV_IA64_Preds = 768, - - // Banked General Registers - - CV_IA64_IntH0 = 832, - CV_IA64_IntH1 = 833, - CV_IA64_IntH2 = 834, - CV_IA64_IntH3 = 835, - CV_IA64_IntH4 = 836, - CV_IA64_IntH5 = 837, - CV_IA64_IntH6 = 838, - CV_IA64_IntH7 = 839, - CV_IA64_IntH8 = 840, - CV_IA64_IntH9 = 841, - CV_IA64_IntH10 = 842, - CV_IA64_IntH11 = 843, - CV_IA64_IntH12 = 844, - CV_IA64_IntH13 = 845, - CV_IA64_IntH14 = 846, - CV_IA64_IntH15 = 847, - - // Special Registers - - CV_IA64_Ip = 1016, - CV_IA64_Umask = 1017, - CV_IA64_Cfm = 1018, - CV_IA64_Psr = 1019, - - // Banked General Registers - - CV_IA64_Nats = 1020, - CV_IA64_Nats2 = 1021, - CV_IA64_Nats3 = 1022, - - // General-Purpose Registers - - // Integer registers - CV_IA64_IntR0 = 1024, - CV_IA64_IntR1 = 1025, - CV_IA64_IntR2 = 1026, - CV_IA64_IntR3 = 1027, - CV_IA64_IntR4 = 1028, - CV_IA64_IntR5 = 1029, - CV_IA64_IntR6 = 1030, - CV_IA64_IntR7 = 1031, - CV_IA64_IntR8 = 1032, - CV_IA64_IntR9 = 1033, - CV_IA64_IntR10 = 1034, - CV_IA64_IntR11 = 1035, - CV_IA64_IntR12 = 1036, - CV_IA64_IntR13 = 1037, - CV_IA64_IntR14 = 1038, - CV_IA64_IntR15 = 1039, - CV_IA64_IntR16 = 1040, - CV_IA64_IntR17 = 1041, - CV_IA64_IntR18 = 1042, - CV_IA64_IntR19 = 1043, - CV_IA64_IntR20 = 1044, - CV_IA64_IntR21 = 1045, - CV_IA64_IntR22 = 1046, - CV_IA64_IntR23 = 1047, - CV_IA64_IntR24 = 1048, - CV_IA64_IntR25 = 1049, - CV_IA64_IntR26 = 1050, - CV_IA64_IntR27 = 1051, - CV_IA64_IntR28 = 1052, - CV_IA64_IntR29 = 1053, - CV_IA64_IntR30 = 1054, - CV_IA64_IntR31 = 1055, - - // Register Stack - CV_IA64_IntR32 = 1056, - CV_IA64_IntR33 = 1057, - CV_IA64_IntR34 = 1058, - CV_IA64_IntR35 = 1059, - CV_IA64_IntR36 = 1060, - CV_IA64_IntR37 = 1061, - CV_IA64_IntR38 = 1062, - CV_IA64_IntR39 = 1063, - CV_IA64_IntR40 = 1064, - CV_IA64_IntR41 = 1065, - CV_IA64_IntR42 = 1066, - CV_IA64_IntR43 = 1067, - CV_IA64_IntR44 = 1068, - CV_IA64_IntR45 = 1069, - CV_IA64_IntR46 = 1070, - CV_IA64_IntR47 = 1071, - CV_IA64_IntR48 = 1072, - CV_IA64_IntR49 = 1073, - CV_IA64_IntR50 = 1074, - CV_IA64_IntR51 = 1075, - CV_IA64_IntR52 = 1076, - CV_IA64_IntR53 = 1077, - CV_IA64_IntR54 = 1078, - CV_IA64_IntR55 = 1079, - CV_IA64_IntR56 = 1080, - CV_IA64_IntR57 = 1081, - CV_IA64_IntR58 = 1082, - CV_IA64_IntR59 = 1083, - CV_IA64_IntR60 = 1084, - CV_IA64_IntR61 = 1085, - CV_IA64_IntR62 = 1086, - CV_IA64_IntR63 = 1087, - CV_IA64_IntR64 = 1088, - CV_IA64_IntR65 = 1089, - CV_IA64_IntR66 = 1090, - CV_IA64_IntR67 = 1091, - CV_IA64_IntR68 = 1092, - CV_IA64_IntR69 = 1093, - CV_IA64_IntR70 = 1094, - CV_IA64_IntR71 = 1095, - CV_IA64_IntR72 = 1096, - CV_IA64_IntR73 = 1097, - CV_IA64_IntR74 = 1098, - CV_IA64_IntR75 = 1099, - CV_IA64_IntR76 = 1100, - CV_IA64_IntR77 = 1101, - CV_IA64_IntR78 = 1102, - CV_IA64_IntR79 = 1103, - CV_IA64_IntR80 = 1104, - CV_IA64_IntR81 = 1105, - CV_IA64_IntR82 = 1106, - CV_IA64_IntR83 = 1107, - CV_IA64_IntR84 = 1108, - CV_IA64_IntR85 = 1109, - CV_IA64_IntR86 = 1110, - CV_IA64_IntR87 = 1111, - CV_IA64_IntR88 = 1112, - CV_IA64_IntR89 = 1113, - CV_IA64_IntR90 = 1114, - CV_IA64_IntR91 = 1115, - CV_IA64_IntR92 = 1116, - CV_IA64_IntR93 = 1117, - CV_IA64_IntR94 = 1118, - CV_IA64_IntR95 = 1119, - CV_IA64_IntR96 = 1120, - CV_IA64_IntR97 = 1121, - CV_IA64_IntR98 = 1122, - CV_IA64_IntR99 = 1123, - CV_IA64_IntR100 = 1124, - CV_IA64_IntR101 = 1125, - CV_IA64_IntR102 = 1126, - CV_IA64_IntR103 = 1127, - CV_IA64_IntR104 = 1128, - CV_IA64_IntR105 = 1129, - CV_IA64_IntR106 = 1130, - CV_IA64_IntR107 = 1131, - CV_IA64_IntR108 = 1132, - CV_IA64_IntR109 = 1133, - CV_IA64_IntR110 = 1134, - CV_IA64_IntR111 = 1135, - CV_IA64_IntR112 = 1136, - CV_IA64_IntR113 = 1137, - CV_IA64_IntR114 = 1138, - CV_IA64_IntR115 = 1139, - CV_IA64_IntR116 = 1140, - CV_IA64_IntR117 = 1141, - CV_IA64_IntR118 = 1142, - CV_IA64_IntR119 = 1143, - CV_IA64_IntR120 = 1144, - CV_IA64_IntR121 = 1145, - CV_IA64_IntR122 = 1146, - CV_IA64_IntR123 = 1147, - CV_IA64_IntR124 = 1148, - CV_IA64_IntR125 = 1149, - CV_IA64_IntR126 = 1150, - CV_IA64_IntR127 = 1151, - - // Floating-Point Registers - - // Low Floating Point Registers - CV_IA64_FltF0 = 2048, - CV_IA64_FltF1 = 2049, - CV_IA64_FltF2 = 2050, - CV_IA64_FltF3 = 2051, - CV_IA64_FltF4 = 2052, - CV_IA64_FltF5 = 2053, - CV_IA64_FltF6 = 2054, - CV_IA64_FltF7 = 2055, - CV_IA64_FltF8 = 2056, - CV_IA64_FltF9 = 2057, - CV_IA64_FltF10 = 2058, - CV_IA64_FltF11 = 2059, - CV_IA64_FltF12 = 2060, - CV_IA64_FltF13 = 2061, - CV_IA64_FltF14 = 2062, - CV_IA64_FltF15 = 2063, - CV_IA64_FltF16 = 2064, - CV_IA64_FltF17 = 2065, - CV_IA64_FltF18 = 2066, - CV_IA64_FltF19 = 2067, - CV_IA64_FltF20 = 2068, - CV_IA64_FltF21 = 2069, - CV_IA64_FltF22 = 2070, - CV_IA64_FltF23 = 2071, - CV_IA64_FltF24 = 2072, - CV_IA64_FltF25 = 2073, - CV_IA64_FltF26 = 2074, - CV_IA64_FltF27 = 2075, - CV_IA64_FltF28 = 2076, - CV_IA64_FltF29 = 2077, - CV_IA64_FltF30 = 2078, - CV_IA64_FltF31 = 2079, - - // High Floating Point Registers - CV_IA64_FltF32 = 2080, - CV_IA64_FltF33 = 2081, - CV_IA64_FltF34 = 2082, - CV_IA64_FltF35 = 2083, - CV_IA64_FltF36 = 2084, - CV_IA64_FltF37 = 2085, - CV_IA64_FltF38 = 2086, - CV_IA64_FltF39 = 2087, - CV_IA64_FltF40 = 2088, - CV_IA64_FltF41 = 2089, - CV_IA64_FltF42 = 2090, - CV_IA64_FltF43 = 2091, - CV_IA64_FltF44 = 2092, - CV_IA64_FltF45 = 2093, - CV_IA64_FltF46 = 2094, - CV_IA64_FltF47 = 2095, - CV_IA64_FltF48 = 2096, - CV_IA64_FltF49 = 2097, - CV_IA64_FltF50 = 2098, - CV_IA64_FltF51 = 2099, - CV_IA64_FltF52 = 2100, - CV_IA64_FltF53 = 2101, - CV_IA64_FltF54 = 2102, - CV_IA64_FltF55 = 2103, - CV_IA64_FltF56 = 2104, - CV_IA64_FltF57 = 2105, - CV_IA64_FltF58 = 2106, - CV_IA64_FltF59 = 2107, - CV_IA64_FltF60 = 2108, - CV_IA64_FltF61 = 2109, - CV_IA64_FltF62 = 2110, - CV_IA64_FltF63 = 2111, - CV_IA64_FltF64 = 2112, - CV_IA64_FltF65 = 2113, - CV_IA64_FltF66 = 2114, - CV_IA64_FltF67 = 2115, - CV_IA64_FltF68 = 2116, - CV_IA64_FltF69 = 2117, - CV_IA64_FltF70 = 2118, - CV_IA64_FltF71 = 2119, - CV_IA64_FltF72 = 2120, - CV_IA64_FltF73 = 2121, - CV_IA64_FltF74 = 2122, - CV_IA64_FltF75 = 2123, - CV_IA64_FltF76 = 2124, - CV_IA64_FltF77 = 2125, - CV_IA64_FltF78 = 2126, - CV_IA64_FltF79 = 2127, - CV_IA64_FltF80 = 2128, - CV_IA64_FltF81 = 2129, - CV_IA64_FltF82 = 2130, - CV_IA64_FltF83 = 2131, - CV_IA64_FltF84 = 2132, - CV_IA64_FltF85 = 2133, - CV_IA64_FltF86 = 2134, - CV_IA64_FltF87 = 2135, - CV_IA64_FltF88 = 2136, - CV_IA64_FltF89 = 2137, - CV_IA64_FltF90 = 2138, - CV_IA64_FltF91 = 2139, - CV_IA64_FltF92 = 2140, - CV_IA64_FltF93 = 2141, - CV_IA64_FltF94 = 2142, - CV_IA64_FltF95 = 2143, - CV_IA64_FltF96 = 2144, - CV_IA64_FltF97 = 2145, - CV_IA64_FltF98 = 2146, - CV_IA64_FltF99 = 2147, - CV_IA64_FltF100 = 2148, - CV_IA64_FltF101 = 2149, - CV_IA64_FltF102 = 2150, - CV_IA64_FltF103 = 2151, - CV_IA64_FltF104 = 2152, - CV_IA64_FltF105 = 2153, - CV_IA64_FltF106 = 2154, - CV_IA64_FltF107 = 2155, - CV_IA64_FltF108 = 2156, - CV_IA64_FltF109 = 2157, - CV_IA64_FltF110 = 2158, - CV_IA64_FltF111 = 2159, - CV_IA64_FltF112 = 2160, - CV_IA64_FltF113 = 2161, - CV_IA64_FltF114 = 2162, - CV_IA64_FltF115 = 2163, - CV_IA64_FltF116 = 2164, - CV_IA64_FltF117 = 2165, - CV_IA64_FltF118 = 2166, - CV_IA64_FltF119 = 2167, - CV_IA64_FltF120 = 2168, - CV_IA64_FltF121 = 2169, - CV_IA64_FltF122 = 2170, - CV_IA64_FltF123 = 2171, - CV_IA64_FltF124 = 2172, - CV_IA64_FltF125 = 2173, - CV_IA64_FltF126 = 2174, - CV_IA64_FltF127 = 2175, - - // Application Registers - - CV_IA64_ApKR0 = 3072, - CV_IA64_ApKR1 = 3073, - CV_IA64_ApKR2 = 3074, - CV_IA64_ApKR3 = 3075, - CV_IA64_ApKR4 = 3076, - CV_IA64_ApKR5 = 3077, - CV_IA64_ApKR6 = 3078, - CV_IA64_ApKR7 = 3079, - CV_IA64_AR8 = 3080, - CV_IA64_AR9 = 3081, - CV_IA64_AR10 = 3082, - CV_IA64_AR11 = 3083, - CV_IA64_AR12 = 3084, - CV_IA64_AR13 = 3085, - CV_IA64_AR14 = 3086, - CV_IA64_AR15 = 3087, - CV_IA64_RsRSC = 3088, - CV_IA64_RsBSP = 3089, - CV_IA64_RsBSPSTORE = 3090, - CV_IA64_RsRNAT = 3091, - CV_IA64_AR20 = 3092, - CV_IA64_StFCR = 3093, - CV_IA64_AR22 = 3094, - CV_IA64_AR23 = 3095, - CV_IA64_EFLAG = 3096, - CV_IA64_CSD = 3097, - CV_IA64_SSD = 3098, - CV_IA64_CFLG = 3099, - CV_IA64_StFSR = 3100, - CV_IA64_StFIR = 3101, - CV_IA64_StFDR = 3102, - CV_IA64_AR31 = 3103, - CV_IA64_ApCCV = 3104, - CV_IA64_AR33 = 3105, - CV_IA64_AR34 = 3106, - CV_IA64_AR35 = 3107, - CV_IA64_ApUNAT = 3108, - CV_IA64_AR37 = 3109, - CV_IA64_AR38 = 3110, - CV_IA64_AR39 = 3111, - CV_IA64_StFPSR = 3112, - CV_IA64_AR41 = 3113, - CV_IA64_AR42 = 3114, - CV_IA64_AR43 = 3115, - CV_IA64_ApITC = 3116, - CV_IA64_AR45 = 3117, - CV_IA64_AR46 = 3118, - CV_IA64_AR47 = 3119, - CV_IA64_AR48 = 3120, - CV_IA64_AR49 = 3121, - CV_IA64_AR50 = 3122, - CV_IA64_AR51 = 3123, - CV_IA64_AR52 = 3124, - CV_IA64_AR53 = 3125, - CV_IA64_AR54 = 3126, - CV_IA64_AR55 = 3127, - CV_IA64_AR56 = 3128, - CV_IA64_AR57 = 3129, - CV_IA64_AR58 = 3130, - CV_IA64_AR59 = 3131, - CV_IA64_AR60 = 3132, - CV_IA64_AR61 = 3133, - CV_IA64_AR62 = 3134, - CV_IA64_AR63 = 3135, - CV_IA64_RsPFS = 3136, - CV_IA64_ApLC = 3137, - CV_IA64_ApEC = 3138, - CV_IA64_AR67 = 3139, - CV_IA64_AR68 = 3140, - CV_IA64_AR69 = 3141, - CV_IA64_AR70 = 3142, - CV_IA64_AR71 = 3143, - CV_IA64_AR72 = 3144, - CV_IA64_AR73 = 3145, - CV_IA64_AR74 = 3146, - CV_IA64_AR75 = 3147, - CV_IA64_AR76 = 3148, - CV_IA64_AR77 = 3149, - CV_IA64_AR78 = 3150, - CV_IA64_AR79 = 3151, - CV_IA64_AR80 = 3152, - CV_IA64_AR81 = 3153, - CV_IA64_AR82 = 3154, - CV_IA64_AR83 = 3155, - CV_IA64_AR84 = 3156, - CV_IA64_AR85 = 3157, - CV_IA64_AR86 = 3158, - CV_IA64_AR87 = 3159, - CV_IA64_AR88 = 3160, - CV_IA64_AR89 = 3161, - CV_IA64_AR90 = 3162, - CV_IA64_AR91 = 3163, - CV_IA64_AR92 = 3164, - CV_IA64_AR93 = 3165, - CV_IA64_AR94 = 3166, - CV_IA64_AR95 = 3167, - CV_IA64_AR96 = 3168, - CV_IA64_AR97 = 3169, - CV_IA64_AR98 = 3170, - CV_IA64_AR99 = 3171, - CV_IA64_AR100 = 3172, - CV_IA64_AR101 = 3173, - CV_IA64_AR102 = 3174, - CV_IA64_AR103 = 3175, - CV_IA64_AR104 = 3176, - CV_IA64_AR105 = 3177, - CV_IA64_AR106 = 3178, - CV_IA64_AR107 = 3179, - CV_IA64_AR108 = 3180, - CV_IA64_AR109 = 3181, - CV_IA64_AR110 = 3182, - CV_IA64_AR111 = 3183, - CV_IA64_AR112 = 3184, - CV_IA64_AR113 = 3185, - CV_IA64_AR114 = 3186, - CV_IA64_AR115 = 3187, - CV_IA64_AR116 = 3188, - CV_IA64_AR117 = 3189, - CV_IA64_AR118 = 3190, - CV_IA64_AR119 = 3191, - CV_IA64_AR120 = 3192, - CV_IA64_AR121 = 3193, - CV_IA64_AR122 = 3194, - CV_IA64_AR123 = 3195, - CV_IA64_AR124 = 3196, - CV_IA64_AR125 = 3197, - CV_IA64_AR126 = 3198, - CV_IA64_AR127 = 3199, - - // CPUID Registers - - CV_IA64_CPUID0 = 3328, - CV_IA64_CPUID1 = 3329, - CV_IA64_CPUID2 = 3330, - CV_IA64_CPUID3 = 3331, - CV_IA64_CPUID4 = 3332, - - // Control Registers - - CV_IA64_ApDCR = 4096, - CV_IA64_ApITM = 4097, - CV_IA64_ApIVA = 4098, - CV_IA64_CR3 = 4099, - CV_IA64_CR4 = 4100, - CV_IA64_CR5 = 4101, - CV_IA64_CR6 = 4102, - CV_IA64_CR7 = 4103, - CV_IA64_ApPTA = 4104, - CV_IA64_ApGPTA = 4105, - CV_IA64_CR10 = 4106, - CV_IA64_CR11 = 4107, - CV_IA64_CR12 = 4108, - CV_IA64_CR13 = 4109, - CV_IA64_CR14 = 4110, - CV_IA64_CR15 = 4111, - CV_IA64_StIPSR = 4112, - CV_IA64_StISR = 4113, - CV_IA64_CR18 = 4114, - CV_IA64_StIIP = 4115, - CV_IA64_StIFA = 4116, - CV_IA64_StITIR = 4117, - CV_IA64_StIIPA = 4118, - CV_IA64_StIFS = 4119, - CV_IA64_StIIM = 4120, - CV_IA64_StIHA = 4121, - CV_IA64_CR26 = 4122, - CV_IA64_CR27 = 4123, - CV_IA64_CR28 = 4124, - CV_IA64_CR29 = 4125, - CV_IA64_CR30 = 4126, - CV_IA64_CR31 = 4127, - CV_IA64_CR32 = 4128, - CV_IA64_CR33 = 4129, - CV_IA64_CR34 = 4130, - CV_IA64_CR35 = 4131, - CV_IA64_CR36 = 4132, - CV_IA64_CR37 = 4133, - CV_IA64_CR38 = 4134, - CV_IA64_CR39 = 4135, - CV_IA64_CR40 = 4136, - CV_IA64_CR41 = 4137, - CV_IA64_CR42 = 4138, - CV_IA64_CR43 = 4139, - CV_IA64_CR44 = 4140, - CV_IA64_CR45 = 4141, - CV_IA64_CR46 = 4142, - CV_IA64_CR47 = 4143, - CV_IA64_CR48 = 4144, - CV_IA64_CR49 = 4145, - CV_IA64_CR50 = 4146, - CV_IA64_CR51 = 4147, - CV_IA64_CR52 = 4148, - CV_IA64_CR53 = 4149, - CV_IA64_CR54 = 4150, - CV_IA64_CR55 = 4151, - CV_IA64_CR56 = 4152, - CV_IA64_CR57 = 4153, - CV_IA64_CR58 = 4154, - CV_IA64_CR59 = 4155, - CV_IA64_CR60 = 4156, - CV_IA64_CR61 = 4157, - CV_IA64_CR62 = 4158, - CV_IA64_CR63 = 4159, - CV_IA64_SaLID = 4160, - CV_IA64_SaIVR = 4161, - CV_IA64_SaTPR = 4162, - CV_IA64_SaEOI = 4163, - CV_IA64_SaIRR0 = 4164, - CV_IA64_SaIRR1 = 4165, - CV_IA64_SaIRR2 = 4166, - CV_IA64_SaIRR3 = 4167, - CV_IA64_SaITV = 4168, - CV_IA64_SaPMV = 4169, - CV_IA64_SaCMCV = 4170, - CV_IA64_CR75 = 4171, - CV_IA64_CR76 = 4172, - CV_IA64_CR77 = 4173, - CV_IA64_CR78 = 4174, - CV_IA64_CR79 = 4175, - CV_IA64_SaLRR0 = 4176, - CV_IA64_SaLRR1 = 4177, - CV_IA64_CR82 = 4178, - CV_IA64_CR83 = 4179, - CV_IA64_CR84 = 4180, - CV_IA64_CR85 = 4181, - CV_IA64_CR86 = 4182, - CV_IA64_CR87 = 4183, - CV_IA64_CR88 = 4184, - CV_IA64_CR89 = 4185, - CV_IA64_CR90 = 4186, - CV_IA64_CR91 = 4187, - CV_IA64_CR92 = 4188, - CV_IA64_CR93 = 4189, - CV_IA64_CR94 = 4190, - CV_IA64_CR95 = 4191, - CV_IA64_CR96 = 4192, - CV_IA64_CR97 = 4193, - CV_IA64_CR98 = 4194, - CV_IA64_CR99 = 4195, - CV_IA64_CR100 = 4196, - CV_IA64_CR101 = 4197, - CV_IA64_CR102 = 4198, - CV_IA64_CR103 = 4199, - CV_IA64_CR104 = 4200, - CV_IA64_CR105 = 4201, - CV_IA64_CR106 = 4202, - CV_IA64_CR107 = 4203, - CV_IA64_CR108 = 4204, - CV_IA64_CR109 = 4205, - CV_IA64_CR110 = 4206, - CV_IA64_CR111 = 4207, - CV_IA64_CR112 = 4208, - CV_IA64_CR113 = 4209, - CV_IA64_CR114 = 4210, - CV_IA64_CR115 = 4211, - CV_IA64_CR116 = 4212, - CV_IA64_CR117 = 4213, - CV_IA64_CR118 = 4214, - CV_IA64_CR119 = 4215, - CV_IA64_CR120 = 4216, - CV_IA64_CR121 = 4217, - CV_IA64_CR122 = 4218, - CV_IA64_CR123 = 4219, - CV_IA64_CR124 = 4220, - CV_IA64_CR125 = 4221, - CV_IA64_CR126 = 4222, - CV_IA64_CR127 = 4223, - - // Protection Key Registers - - CV_IA64_Pkr0 = 5120, - CV_IA64_Pkr1 = 5121, - CV_IA64_Pkr2 = 5122, - CV_IA64_Pkr3 = 5123, - CV_IA64_Pkr4 = 5124, - CV_IA64_Pkr5 = 5125, - CV_IA64_Pkr6 = 5126, - CV_IA64_Pkr7 = 5127, - CV_IA64_Pkr8 = 5128, - CV_IA64_Pkr9 = 5129, - CV_IA64_Pkr10 = 5130, - CV_IA64_Pkr11 = 5131, - CV_IA64_Pkr12 = 5132, - CV_IA64_Pkr13 = 5133, - CV_IA64_Pkr14 = 5134, - CV_IA64_Pkr15 = 5135, - - // Region Registers - - CV_IA64_Rr0 = 6144, - CV_IA64_Rr1 = 6145, - CV_IA64_Rr2 = 6146, - CV_IA64_Rr3 = 6147, - CV_IA64_Rr4 = 6148, - CV_IA64_Rr5 = 6149, - CV_IA64_Rr6 = 6150, - CV_IA64_Rr7 = 6151, - - // Performance Monitor Data Registers - - CV_IA64_PFD0 = 7168, - CV_IA64_PFD1 = 7169, - CV_IA64_PFD2 = 7170, - CV_IA64_PFD3 = 7171, - CV_IA64_PFD4 = 7172, - CV_IA64_PFD5 = 7173, - CV_IA64_PFD6 = 7174, - CV_IA64_PFD7 = 7175, - CV_IA64_PFD8 = 7176, - CV_IA64_PFD9 = 7177, - CV_IA64_PFD10 = 7178, - CV_IA64_PFD11 = 7179, - CV_IA64_PFD12 = 7180, - CV_IA64_PFD13 = 7181, - CV_IA64_PFD14 = 7182, - CV_IA64_PFD15 = 7183, - CV_IA64_PFD16 = 7184, - CV_IA64_PFD17 = 7185, - - // Performance Monitor Config Registers - - CV_IA64_PFC0 = 7424, - CV_IA64_PFC1 = 7425, - CV_IA64_PFC2 = 7426, - CV_IA64_PFC3 = 7427, - CV_IA64_PFC4 = 7428, - CV_IA64_PFC5 = 7429, - CV_IA64_PFC6 = 7430, - CV_IA64_PFC7 = 7431, - CV_IA64_PFC8 = 7432, - CV_IA64_PFC9 = 7433, - CV_IA64_PFC10 = 7434, - CV_IA64_PFC11 = 7435, - CV_IA64_PFC12 = 7436, - CV_IA64_PFC13 = 7437, - CV_IA64_PFC14 = 7438, - CV_IA64_PFC15 = 7439, - - // Instruction Translation Registers - - CV_IA64_TrI0 = 8192, - CV_IA64_TrI1 = 8193, - CV_IA64_TrI2 = 8194, - CV_IA64_TrI3 = 8195, - CV_IA64_TrI4 = 8196, - CV_IA64_TrI5 = 8197, - CV_IA64_TrI6 = 8198, - CV_IA64_TrI7 = 8199, - - // Data Translation Registers - - CV_IA64_TrD0 = 8320, - CV_IA64_TrD1 = 8321, - CV_IA64_TrD2 = 8322, - CV_IA64_TrD3 = 8323, - CV_IA64_TrD4 = 8324, - CV_IA64_TrD5 = 8325, - CV_IA64_TrD6 = 8326, - CV_IA64_TrD7 = 8327, - - // Instruction Breakpoint Registers - - CV_IA64_DbI0 = 8448, - CV_IA64_DbI1 = 8449, - CV_IA64_DbI2 = 8450, - CV_IA64_DbI3 = 8451, - CV_IA64_DbI4 = 8452, - CV_IA64_DbI5 = 8453, - CV_IA64_DbI6 = 8454, - CV_IA64_DbI7 = 8455, - - // Data Breakpoint Registers - - CV_IA64_DbD0 = 8576, - CV_IA64_DbD1 = 8577, - CV_IA64_DbD2 = 8578, - CV_IA64_DbD3 = 8579, - CV_IA64_DbD4 = 8580, - CV_IA64_DbD5 = 8581, - CV_IA64_DbD6 = 8582, - CV_IA64_DbD7 = 8583, - - // - // Register set for the TriCore processor. - // - - CV_TRI_NOREG = CV_REG_NONE, - - // General Purpose Data Registers - - CV_TRI_D0 = 10, - CV_TRI_D1 = 11, - CV_TRI_D2 = 12, - CV_TRI_D3 = 13, - CV_TRI_D4 = 14, - CV_TRI_D5 = 15, - CV_TRI_D6 = 16, - CV_TRI_D7 = 17, - CV_TRI_D8 = 18, - CV_TRI_D9 = 19, - CV_TRI_D10 = 20, - CV_TRI_D11 = 21, - CV_TRI_D12 = 22, - CV_TRI_D13 = 23, - CV_TRI_D14 = 24, - CV_TRI_D15 = 25, - - // General Purpose Address Registers - - CV_TRI_A0 = 26, - CV_TRI_A1 = 27, - CV_TRI_A2 = 28, - CV_TRI_A3 = 29, - CV_TRI_A4 = 30, - CV_TRI_A5 = 31, - CV_TRI_A6 = 32, - CV_TRI_A7 = 33, - CV_TRI_A8 = 34, - CV_TRI_A9 = 35, - CV_TRI_A10 = 36, - CV_TRI_A11 = 37, - CV_TRI_A12 = 38, - CV_TRI_A13 = 39, - CV_TRI_A14 = 40, - CV_TRI_A15 = 41, - - // Extended (64-bit) data registers - - CV_TRI_E0 = 42, - CV_TRI_E2 = 43, - CV_TRI_E4 = 44, - CV_TRI_E6 = 45, - CV_TRI_E8 = 46, - CV_TRI_E10 = 47, - CV_TRI_E12 = 48, - CV_TRI_E14 = 49, - - // Extended (64-bit) address registers - - CV_TRI_EA0 = 50, - CV_TRI_EA2 = 51, - CV_TRI_EA4 = 52, - CV_TRI_EA6 = 53, - CV_TRI_EA8 = 54, - CV_TRI_EA10 = 55, - CV_TRI_EA12 = 56, - CV_TRI_EA14 = 57, - - CV_TRI_PSW = 58, - CV_TRI_PCXI = 59, - CV_TRI_PC = 60, - CV_TRI_FCX = 61, - CV_TRI_LCX = 62, - CV_TRI_ISP = 63, - CV_TRI_ICR = 64, - CV_TRI_BIV = 65, - CV_TRI_BTV = 66, - CV_TRI_SYSCON = 67, - CV_TRI_DPRx_0 = 68, - CV_TRI_DPRx_1 = 69, - CV_TRI_DPRx_2 = 70, - CV_TRI_DPRx_3 = 71, - CV_TRI_CPRx_0 = 68, - CV_TRI_CPRx_1 = 69, - CV_TRI_CPRx_2 = 70, - CV_TRI_CPRx_3 = 71, - CV_TRI_DPMx_0 = 68, - CV_TRI_DPMx_1 = 69, - CV_TRI_DPMx_2 = 70, - CV_TRI_DPMx_3 = 71, - CV_TRI_CPMx_0 = 68, - CV_TRI_CPMx_1 = 69, - CV_TRI_CPMx_2 = 70, - CV_TRI_CPMx_3 = 71, - CV_TRI_DBGSSR = 72, - CV_TRI_EXEVT = 73, - CV_TRI_SWEVT = 74, - CV_TRI_CREVT = 75, - CV_TRI_TRnEVT = 76, - CV_TRI_MMUCON = 77, - CV_TRI_ASI = 78, - CV_TRI_TVA = 79, - CV_TRI_TPA = 80, - CV_TRI_TPX = 81, - CV_TRI_TFA = 82, - - // - // Register set for the AM33 and related processors. - // - - CV_AM33_NOREG = CV_REG_NONE, - - // "Extended" (general purpose integer) registers - CV_AM33_E0 = 10, - CV_AM33_E1 = 11, - CV_AM33_E2 = 12, - CV_AM33_E3 = 13, - CV_AM33_E4 = 14, - CV_AM33_E5 = 15, - CV_AM33_E6 = 16, - CV_AM33_E7 = 17, - - // Address registers - CV_AM33_A0 = 20, - CV_AM33_A1 = 21, - CV_AM33_A2 = 22, - CV_AM33_A3 = 23, - - // Integer data registers - CV_AM33_D0 = 30, - CV_AM33_D1 = 31, - CV_AM33_D2 = 32, - CV_AM33_D3 = 33, - - // (Single-precision) floating-point registers - CV_AM33_FS0 = 40, - CV_AM33_FS1 = 41, - CV_AM33_FS2 = 42, - CV_AM33_FS3 = 43, - CV_AM33_FS4 = 44, - CV_AM33_FS5 = 45, - CV_AM33_FS6 = 46, - CV_AM33_FS7 = 47, - CV_AM33_FS8 = 48, - CV_AM33_FS9 = 49, - CV_AM33_FS10 = 50, - CV_AM33_FS11 = 51, - CV_AM33_FS12 = 52, - CV_AM33_FS13 = 53, - CV_AM33_FS14 = 54, - CV_AM33_FS15 = 55, - CV_AM33_FS16 = 56, - CV_AM33_FS17 = 57, - CV_AM33_FS18 = 58, - CV_AM33_FS19 = 59, - CV_AM33_FS20 = 60, - CV_AM33_FS21 = 61, - CV_AM33_FS22 = 62, - CV_AM33_FS23 = 63, - CV_AM33_FS24 = 64, - CV_AM33_FS25 = 65, - CV_AM33_FS26 = 66, - CV_AM33_FS27 = 67, - CV_AM33_FS28 = 68, - CV_AM33_FS29 = 69, - CV_AM33_FS30 = 70, - CV_AM33_FS31 = 71, - - // Special purpose registers - - // Stack pointer - CV_AM33_SP = 80, - - // Program counter - CV_AM33_PC = 81, - - // Multiply-divide/accumulate registers - CV_AM33_MDR = 82, - CV_AM33_MDRQ = 83, - CV_AM33_MCRH = 84, - CV_AM33_MCRL = 85, - CV_AM33_MCVF = 86, - - // CPU status words - CV_AM33_EPSW = 87, - CV_AM33_FPCR = 88, - - // Loop buffer registers - CV_AM33_LIR = 89, - CV_AM33_LAR = 90, - - // - // Register set for the Mitsubishi M32R - // - - CV_M32R_NOREG = CV_REG_NONE, - - CV_M32R_R0 = 10, - CV_M32R_R1 = 11, - CV_M32R_R2 = 12, - CV_M32R_R3 = 13, - CV_M32R_R4 = 14, - CV_M32R_R5 = 15, - CV_M32R_R6 = 16, - CV_M32R_R7 = 17, - CV_M32R_R8 = 18, - CV_M32R_R9 = 19, - CV_M32R_R10 = 20, - CV_M32R_R11 = 21, - CV_M32R_R12 = 22, // Gloabal Pointer, if used - CV_M32R_R13 = 23, // Frame Pointer, if allocated - CV_M32R_R14 = 24, // Link Register - CV_M32R_R15 = 25, // Stack Pointer - CV_M32R_PSW = 26, // Preocessor Status Register - CV_M32R_CBR = 27, // Condition Bit Register - CV_M32R_SPI = 28, // Interrupt Stack Pointer - CV_M32R_SPU = 29, // User Stack Pointer - CV_M32R_SPO = 30, // OS Stack Pointer - CV_M32R_BPC = 31, // Backup Program Counter - CV_M32R_ACHI = 32, // Accumulator High - CV_M32R_ACLO = 33, // Accumulator Low - CV_M32R_PC = 34, // Program Counter - - // - // Register set for the SuperH SHMedia processor including compact - // mode - // - - // Integer - 64 bit general registers - CV_SHMEDIA_NOREG = CV_REG_NONE, - CV_SHMEDIA_R0 = 10, - CV_SHMEDIA_R1 = 11, - CV_SHMEDIA_R2 = 12, - CV_SHMEDIA_R3 = 13, - CV_SHMEDIA_R4 = 14, - CV_SHMEDIA_R5 = 15, - CV_SHMEDIA_R6 = 16, - CV_SHMEDIA_R7 = 17, - CV_SHMEDIA_R8 = 18, - CV_SHMEDIA_R9 = 19, - CV_SHMEDIA_R10 = 20, - CV_SHMEDIA_R11 = 21, - CV_SHMEDIA_R12 = 22, - CV_SHMEDIA_R13 = 23, - CV_SHMEDIA_R14 = 24, - CV_SHMEDIA_R15 = 25, - CV_SHMEDIA_R16 = 26, - CV_SHMEDIA_R17 = 27, - CV_SHMEDIA_R18 = 28, - CV_SHMEDIA_R19 = 29, - CV_SHMEDIA_R20 = 30, - CV_SHMEDIA_R21 = 31, - CV_SHMEDIA_R22 = 32, - CV_SHMEDIA_R23 = 33, - CV_SHMEDIA_R24 = 34, - CV_SHMEDIA_R25 = 35, - CV_SHMEDIA_R26 = 36, - CV_SHMEDIA_R27 = 37, - CV_SHMEDIA_R28 = 38, - CV_SHMEDIA_R29 = 39, - CV_SHMEDIA_R30 = 40, - CV_SHMEDIA_R31 = 41, - CV_SHMEDIA_R32 = 42, - CV_SHMEDIA_R33 = 43, - CV_SHMEDIA_R34 = 44, - CV_SHMEDIA_R35 = 45, - CV_SHMEDIA_R36 = 46, - CV_SHMEDIA_R37 = 47, - CV_SHMEDIA_R38 = 48, - CV_SHMEDIA_R39 = 49, - CV_SHMEDIA_R40 = 50, - CV_SHMEDIA_R41 = 51, - CV_SHMEDIA_R42 = 52, - CV_SHMEDIA_R43 = 53, - CV_SHMEDIA_R44 = 54, - CV_SHMEDIA_R45 = 55, - CV_SHMEDIA_R46 = 56, - CV_SHMEDIA_R47 = 57, - CV_SHMEDIA_R48 = 58, - CV_SHMEDIA_R49 = 59, - CV_SHMEDIA_R50 = 60, - CV_SHMEDIA_R51 = 61, - CV_SHMEDIA_R52 = 62, - CV_SHMEDIA_R53 = 63, - CV_SHMEDIA_R54 = 64, - CV_SHMEDIA_R55 = 65, - CV_SHMEDIA_R56 = 66, - CV_SHMEDIA_R57 = 67, - CV_SHMEDIA_R58 = 68, - CV_SHMEDIA_R59 = 69, - CV_SHMEDIA_R60 = 70, - CV_SHMEDIA_R61 = 71, - CV_SHMEDIA_R62 = 72, - CV_SHMEDIA_R63 = 73, - - // Target Registers - 32 bit - CV_SHMEDIA_TR0 = 74, - CV_SHMEDIA_TR1 = 75, - CV_SHMEDIA_TR2 = 76, - CV_SHMEDIA_TR3 = 77, - CV_SHMEDIA_TR4 = 78, - CV_SHMEDIA_TR5 = 79, - CV_SHMEDIA_TR6 = 80, - CV_SHMEDIA_TR7 = 81, - CV_SHMEDIA_TR8 = 82, // future-proof - CV_SHMEDIA_TR9 = 83, // future-proof - CV_SHMEDIA_TR10 = 84, // future-proof - CV_SHMEDIA_TR11 = 85, // future-proof - CV_SHMEDIA_TR12 = 86, // future-proof - CV_SHMEDIA_TR13 = 87, // future-proof - CV_SHMEDIA_TR14 = 88, // future-proof - CV_SHMEDIA_TR15 = 89, // future-proof - - // Single - 32 bit fp registers - CV_SHMEDIA_FR0 = 128, - CV_SHMEDIA_FR1 = 129, - CV_SHMEDIA_FR2 = 130, - CV_SHMEDIA_FR3 = 131, - CV_SHMEDIA_FR4 = 132, - CV_SHMEDIA_FR5 = 133, - CV_SHMEDIA_FR6 = 134, - CV_SHMEDIA_FR7 = 135, - CV_SHMEDIA_FR8 = 136, - CV_SHMEDIA_FR9 = 137, - CV_SHMEDIA_FR10 = 138, - CV_SHMEDIA_FR11 = 139, - CV_SHMEDIA_FR12 = 140, - CV_SHMEDIA_FR13 = 141, - CV_SHMEDIA_FR14 = 142, - CV_SHMEDIA_FR15 = 143, - CV_SHMEDIA_FR16 = 144, - CV_SHMEDIA_FR17 = 145, - CV_SHMEDIA_FR18 = 146, - CV_SHMEDIA_FR19 = 147, - CV_SHMEDIA_FR20 = 148, - CV_SHMEDIA_FR21 = 149, - CV_SHMEDIA_FR22 = 150, - CV_SHMEDIA_FR23 = 151, - CV_SHMEDIA_FR24 = 152, - CV_SHMEDIA_FR25 = 153, - CV_SHMEDIA_FR26 = 154, - CV_SHMEDIA_FR27 = 155, - CV_SHMEDIA_FR28 = 156, - CV_SHMEDIA_FR29 = 157, - CV_SHMEDIA_FR30 = 158, - CV_SHMEDIA_FR31 = 159, - CV_SHMEDIA_FR32 = 160, - CV_SHMEDIA_FR33 = 161, - CV_SHMEDIA_FR34 = 162, - CV_SHMEDIA_FR35 = 163, - CV_SHMEDIA_FR36 = 164, - CV_SHMEDIA_FR37 = 165, - CV_SHMEDIA_FR38 = 166, - CV_SHMEDIA_FR39 = 167, - CV_SHMEDIA_FR40 = 168, - CV_SHMEDIA_FR41 = 169, - CV_SHMEDIA_FR42 = 170, - CV_SHMEDIA_FR43 = 171, - CV_SHMEDIA_FR44 = 172, - CV_SHMEDIA_FR45 = 173, - CV_SHMEDIA_FR46 = 174, - CV_SHMEDIA_FR47 = 175, - CV_SHMEDIA_FR48 = 176, - CV_SHMEDIA_FR49 = 177, - CV_SHMEDIA_FR50 = 178, - CV_SHMEDIA_FR51 = 179, - CV_SHMEDIA_FR52 = 180, - CV_SHMEDIA_FR53 = 181, - CV_SHMEDIA_FR54 = 182, - CV_SHMEDIA_FR55 = 183, - CV_SHMEDIA_FR56 = 184, - CV_SHMEDIA_FR57 = 185, - CV_SHMEDIA_FR58 = 186, - CV_SHMEDIA_FR59 = 187, - CV_SHMEDIA_FR60 = 188, - CV_SHMEDIA_FR61 = 189, - CV_SHMEDIA_FR62 = 190, - CV_SHMEDIA_FR63 = 191, - - // Double - 64 bit synonyms for 32bit fp register pairs - // subtract 128 to find first base single register - CV_SHMEDIA_DR0 = 256, - CV_SHMEDIA_DR2 = 258, - CV_SHMEDIA_DR4 = 260, - CV_SHMEDIA_DR6 = 262, - CV_SHMEDIA_DR8 = 264, - CV_SHMEDIA_DR10 = 266, - CV_SHMEDIA_DR12 = 268, - CV_SHMEDIA_DR14 = 270, - CV_SHMEDIA_DR16 = 272, - CV_SHMEDIA_DR18 = 274, - CV_SHMEDIA_DR20 = 276, - CV_SHMEDIA_DR22 = 278, - CV_SHMEDIA_DR24 = 280, - CV_SHMEDIA_DR26 = 282, - CV_SHMEDIA_DR28 = 284, - CV_SHMEDIA_DR30 = 286, - CV_SHMEDIA_DR32 = 288, - CV_SHMEDIA_DR34 = 290, - CV_SHMEDIA_DR36 = 292, - CV_SHMEDIA_DR38 = 294, - CV_SHMEDIA_DR40 = 296, - CV_SHMEDIA_DR42 = 298, - CV_SHMEDIA_DR44 = 300, - CV_SHMEDIA_DR46 = 302, - CV_SHMEDIA_DR48 = 304, - CV_SHMEDIA_DR50 = 306, - CV_SHMEDIA_DR52 = 308, - CV_SHMEDIA_DR54 = 310, - CV_SHMEDIA_DR56 = 312, - CV_SHMEDIA_DR58 = 314, - CV_SHMEDIA_DR60 = 316, - CV_SHMEDIA_DR62 = 318, - - // Vector - 128 bit synonyms for 32bit fp register quads - // subtract 384 to find first base single register - CV_SHMEDIA_FV0 = 512, - CV_SHMEDIA_FV4 = 516, - CV_SHMEDIA_FV8 = 520, - CV_SHMEDIA_FV12 = 524, - CV_SHMEDIA_FV16 = 528, - CV_SHMEDIA_FV20 = 532, - CV_SHMEDIA_FV24 = 536, - CV_SHMEDIA_FV28 = 540, - CV_SHMEDIA_FV32 = 544, - CV_SHMEDIA_FV36 = 548, - CV_SHMEDIA_FV40 = 552, - CV_SHMEDIA_FV44 = 556, - CV_SHMEDIA_FV48 = 560, - CV_SHMEDIA_FV52 = 564, - CV_SHMEDIA_FV56 = 568, - CV_SHMEDIA_FV60 = 572, - - // Matrix - 512 bit synonyms for 16 adjacent 32bit fp registers - // subtract 896 to find first base single register - CV_SHMEDIA_MTRX0 = 1024, - CV_SHMEDIA_MTRX16 = 1040, - CV_SHMEDIA_MTRX32 = 1056, - CV_SHMEDIA_MTRX48 = 1072, - - // Control - Implementation defined 64bit control registers - CV_SHMEDIA_CR0 = 2000, - CV_SHMEDIA_CR1 = 2001, - CV_SHMEDIA_CR2 = 2002, - CV_SHMEDIA_CR3 = 2003, - CV_SHMEDIA_CR4 = 2004, - CV_SHMEDIA_CR5 = 2005, - CV_SHMEDIA_CR6 = 2006, - CV_SHMEDIA_CR7 = 2007, - CV_SHMEDIA_CR8 = 2008, - CV_SHMEDIA_CR9 = 2009, - CV_SHMEDIA_CR10 = 2010, - CV_SHMEDIA_CR11 = 2011, - CV_SHMEDIA_CR12 = 2012, - CV_SHMEDIA_CR13 = 2013, - CV_SHMEDIA_CR14 = 2014, - CV_SHMEDIA_CR15 = 2015, - CV_SHMEDIA_CR16 = 2016, - CV_SHMEDIA_CR17 = 2017, - CV_SHMEDIA_CR18 = 2018, - CV_SHMEDIA_CR19 = 2019, - CV_SHMEDIA_CR20 = 2020, - CV_SHMEDIA_CR21 = 2021, - CV_SHMEDIA_CR22 = 2022, - CV_SHMEDIA_CR23 = 2023, - CV_SHMEDIA_CR24 = 2024, - CV_SHMEDIA_CR25 = 2025, - CV_SHMEDIA_CR26 = 2026, - CV_SHMEDIA_CR27 = 2027, - CV_SHMEDIA_CR28 = 2028, - CV_SHMEDIA_CR29 = 2029, - CV_SHMEDIA_CR30 = 2030, - CV_SHMEDIA_CR31 = 2031, - CV_SHMEDIA_CR32 = 2032, - CV_SHMEDIA_CR33 = 2033, - CV_SHMEDIA_CR34 = 2034, - CV_SHMEDIA_CR35 = 2035, - CV_SHMEDIA_CR36 = 2036, - CV_SHMEDIA_CR37 = 2037, - CV_SHMEDIA_CR38 = 2038, - CV_SHMEDIA_CR39 = 2039, - CV_SHMEDIA_CR40 = 2040, - CV_SHMEDIA_CR41 = 2041, - CV_SHMEDIA_CR42 = 2042, - CV_SHMEDIA_CR43 = 2043, - CV_SHMEDIA_CR44 = 2044, - CV_SHMEDIA_CR45 = 2045, - CV_SHMEDIA_CR46 = 2046, - CV_SHMEDIA_CR47 = 2047, - CV_SHMEDIA_CR48 = 2048, - CV_SHMEDIA_CR49 = 2049, - CV_SHMEDIA_CR50 = 2050, - CV_SHMEDIA_CR51 = 2051, - CV_SHMEDIA_CR52 = 2052, - CV_SHMEDIA_CR53 = 2053, - CV_SHMEDIA_CR54 = 2054, - CV_SHMEDIA_CR55 = 2055, - CV_SHMEDIA_CR56 = 2056, - CV_SHMEDIA_CR57 = 2057, - CV_SHMEDIA_CR58 = 2058, - CV_SHMEDIA_CR59 = 2059, - CV_SHMEDIA_CR60 = 2060, - CV_SHMEDIA_CR61 = 2061, - CV_SHMEDIA_CR62 = 2062, - CV_SHMEDIA_CR63 = 2063, - - CV_SHMEDIA_FPSCR = 2064, - - // Compact mode synonyms - CV_SHMEDIA_GBR = CV_SHMEDIA_R16, - CV_SHMEDIA_MACL = 90, // synonym for lower 32bits of media R17 - CV_SHMEDIA_MACH = 91, // synonym for upper 32bits of media R17 - CV_SHMEDIA_PR = CV_SHMEDIA_R18, - CV_SHMEDIA_T = 92, // synonym for lowest bit of media R19 - CV_SHMEDIA_FPUL = CV_SHMEDIA_FR32, - CV_SHMEDIA_PC = 93, - CV_SHMEDIA_SR = CV_SHMEDIA_CR0, - - // - // AMD64 registers - // - - CV_AMD64_AL = 1, - CV_AMD64_CL = 2, - CV_AMD64_DL = 3, - CV_AMD64_BL = 4, - CV_AMD64_AH = 5, - CV_AMD64_CH = 6, - CV_AMD64_DH = 7, - CV_AMD64_BH = 8, - CV_AMD64_AX = 9, - CV_AMD64_CX = 10, - CV_AMD64_DX = 11, - CV_AMD64_BX = 12, - CV_AMD64_SP = 13, - CV_AMD64_BP = 14, - CV_AMD64_SI = 15, - CV_AMD64_DI = 16, - CV_AMD64_EAX = 17, - CV_AMD64_ECX = 18, - CV_AMD64_EDX = 19, - CV_AMD64_EBX = 20, - CV_AMD64_ESP = 21, - CV_AMD64_EBP = 22, - CV_AMD64_ESI = 23, - CV_AMD64_EDI = 24, - CV_AMD64_ES = 25, - CV_AMD64_CS = 26, - CV_AMD64_SS = 27, - CV_AMD64_DS = 28, - CV_AMD64_FS = 29, - CV_AMD64_GS = 30, - CV_AMD64_FLAGS = 32, - CV_AMD64_RIP = 33, - CV_AMD64_EFLAGS = 34, - - // Control registers - CV_AMD64_CR0 = 80, - CV_AMD64_CR1 = 81, - CV_AMD64_CR2 = 82, - CV_AMD64_CR3 = 83, - CV_AMD64_CR4 = 84, - CV_AMD64_CR8 = 88, - - // Debug registers - CV_AMD64_DR0 = 90, - CV_AMD64_DR1 = 91, - CV_AMD64_DR2 = 92, - CV_AMD64_DR3 = 93, - CV_AMD64_DR4 = 94, - CV_AMD64_DR5 = 95, - CV_AMD64_DR6 = 96, - CV_AMD64_DR7 = 97, - CV_AMD64_DR8 = 98, - CV_AMD64_DR9 = 99, - CV_AMD64_DR10 = 100, - CV_AMD64_DR11 = 101, - CV_AMD64_DR12 = 102, - CV_AMD64_DR13 = 103, - CV_AMD64_DR14 = 104, - CV_AMD64_DR15 = 105, - - CV_AMD64_GDTR = 110, - CV_AMD64_GDTL = 111, - CV_AMD64_IDTR = 112, - CV_AMD64_IDTL = 113, - CV_AMD64_LDTR = 114, - CV_AMD64_TR = 115, - - CV_AMD64_ST0 = 128, - CV_AMD64_ST1 = 129, - CV_AMD64_ST2 = 130, - CV_AMD64_ST3 = 131, - CV_AMD64_ST4 = 132, - CV_AMD64_ST5 = 133, - CV_AMD64_ST6 = 134, - CV_AMD64_ST7 = 135, - CV_AMD64_CTRL = 136, - CV_AMD64_STAT = 137, - CV_AMD64_TAG = 138, - CV_AMD64_FPIP = 139, - CV_AMD64_FPCS = 140, - CV_AMD64_FPDO = 141, - CV_AMD64_FPDS = 142, - CV_AMD64_ISEM = 143, - CV_AMD64_FPEIP = 144, - CV_AMD64_FPEDO = 145, - - CV_AMD64_MM0 = 146, - CV_AMD64_MM1 = 147, - CV_AMD64_MM2 = 148, - CV_AMD64_MM3 = 149, - CV_AMD64_MM4 = 150, - CV_AMD64_MM5 = 151, - CV_AMD64_MM6 = 152, - CV_AMD64_MM7 = 153, - - CV_AMD64_XMM0 = 154, // KATMAI registers - CV_AMD64_XMM1 = 155, - CV_AMD64_XMM2 = 156, - CV_AMD64_XMM3 = 157, - CV_AMD64_XMM4 = 158, - CV_AMD64_XMM5 = 159, - CV_AMD64_XMM6 = 160, - CV_AMD64_XMM7 = 161, - - CV_AMD64_XMM0_0 = 162, // KATMAI sub-registers - CV_AMD64_XMM0_1 = 163, - CV_AMD64_XMM0_2 = 164, - CV_AMD64_XMM0_3 = 165, - CV_AMD64_XMM1_0 = 166, - CV_AMD64_XMM1_1 = 167, - CV_AMD64_XMM1_2 = 168, - CV_AMD64_XMM1_3 = 169, - CV_AMD64_XMM2_0 = 170, - CV_AMD64_XMM2_1 = 171, - CV_AMD64_XMM2_2 = 172, - CV_AMD64_XMM2_3 = 173, - CV_AMD64_XMM3_0 = 174, - CV_AMD64_XMM3_1 = 175, - CV_AMD64_XMM3_2 = 176, - CV_AMD64_XMM3_3 = 177, - CV_AMD64_XMM4_0 = 178, - CV_AMD64_XMM4_1 = 179, - CV_AMD64_XMM4_2 = 180, - CV_AMD64_XMM4_3 = 181, - CV_AMD64_XMM5_0 = 182, - CV_AMD64_XMM5_1 = 183, - CV_AMD64_XMM5_2 = 184, - CV_AMD64_XMM5_3 = 185, - CV_AMD64_XMM6_0 = 186, - CV_AMD64_XMM6_1 = 187, - CV_AMD64_XMM6_2 = 188, - CV_AMD64_XMM6_3 = 189, - CV_AMD64_XMM7_0 = 190, - CV_AMD64_XMM7_1 = 191, - CV_AMD64_XMM7_2 = 192, - CV_AMD64_XMM7_3 = 193, - - CV_AMD64_XMM0L = 194, - CV_AMD64_XMM1L = 195, - CV_AMD64_XMM2L = 196, - CV_AMD64_XMM3L = 197, - CV_AMD64_XMM4L = 198, - CV_AMD64_XMM5L = 199, - CV_AMD64_XMM6L = 200, - CV_AMD64_XMM7L = 201, - - CV_AMD64_XMM0H = 202, - CV_AMD64_XMM1H = 203, - CV_AMD64_XMM2H = 204, - CV_AMD64_XMM3H = 205, - CV_AMD64_XMM4H = 206, - CV_AMD64_XMM5H = 207, - CV_AMD64_XMM6H = 208, - CV_AMD64_XMM7H = 209, - - CV_AMD64_MXCSR = 211, // XMM status register - - CV_AMD64_EMM0L = 220, // XMM sub-registers (WNI integer) - CV_AMD64_EMM1L = 221, - CV_AMD64_EMM2L = 222, - CV_AMD64_EMM3L = 223, - CV_AMD64_EMM4L = 224, - CV_AMD64_EMM5L = 225, - CV_AMD64_EMM6L = 226, - CV_AMD64_EMM7L = 227, - - CV_AMD64_EMM0H = 228, - CV_AMD64_EMM1H = 229, - CV_AMD64_EMM2H = 230, - CV_AMD64_EMM3H = 231, - CV_AMD64_EMM4H = 232, - CV_AMD64_EMM5H = 233, - CV_AMD64_EMM6H = 234, - CV_AMD64_EMM7H = 235, - - // do not change the order of these regs, first one must be even too - CV_AMD64_MM00 = 236, - CV_AMD64_MM01 = 237, - CV_AMD64_MM10 = 238, - CV_AMD64_MM11 = 239, - CV_AMD64_MM20 = 240, - CV_AMD64_MM21 = 241, - CV_AMD64_MM30 = 242, - CV_AMD64_MM31 = 243, - CV_AMD64_MM40 = 244, - CV_AMD64_MM41 = 245, - CV_AMD64_MM50 = 246, - CV_AMD64_MM51 = 247, - CV_AMD64_MM60 = 248, - CV_AMD64_MM61 = 249, - CV_AMD64_MM70 = 250, - CV_AMD64_MM71 = 251, - - // Extended KATMAI registers - CV_AMD64_XMM8 = 252, // KATMAI registers - CV_AMD64_XMM9 = 253, - CV_AMD64_XMM10 = 254, - CV_AMD64_XMM11 = 255, - CV_AMD64_XMM12 = 256, - CV_AMD64_XMM13 = 257, - CV_AMD64_XMM14 = 258, - CV_AMD64_XMM15 = 259, - - CV_AMD64_XMM8_0 = 260, // KATMAI sub-registers - CV_AMD64_XMM8_1 = 261, - CV_AMD64_XMM8_2 = 262, - CV_AMD64_XMM8_3 = 263, - CV_AMD64_XMM9_0 = 264, - CV_AMD64_XMM9_1 = 265, - CV_AMD64_XMM9_2 = 266, - CV_AMD64_XMM9_3 = 267, - CV_AMD64_XMM10_0 = 268, - CV_AMD64_XMM10_1 = 269, - CV_AMD64_XMM10_2 = 270, - CV_AMD64_XMM10_3 = 271, - CV_AMD64_XMM11_0 = 272, - CV_AMD64_XMM11_1 = 273, - CV_AMD64_XMM11_2 = 274, - CV_AMD64_XMM11_3 = 275, - CV_AMD64_XMM12_0 = 276, - CV_AMD64_XMM12_1 = 277, - CV_AMD64_XMM12_2 = 278, - CV_AMD64_XMM12_3 = 279, - CV_AMD64_XMM13_0 = 280, - CV_AMD64_XMM13_1 = 281, - CV_AMD64_XMM13_2 = 282, - CV_AMD64_XMM13_3 = 283, - CV_AMD64_XMM14_0 = 284, - CV_AMD64_XMM14_1 = 285, - CV_AMD64_XMM14_2 = 286, - CV_AMD64_XMM14_3 = 287, - CV_AMD64_XMM15_0 = 288, - CV_AMD64_XMM15_1 = 289, - CV_AMD64_XMM15_2 = 290, - CV_AMD64_XMM15_3 = 291, - - CV_AMD64_XMM8L = 292, - CV_AMD64_XMM9L = 293, - CV_AMD64_XMM10L = 294, - CV_AMD64_XMM11L = 295, - CV_AMD64_XMM12L = 296, - CV_AMD64_XMM13L = 297, - CV_AMD64_XMM14L = 298, - CV_AMD64_XMM15L = 299, - - CV_AMD64_XMM8H = 300, - CV_AMD64_XMM9H = 301, - CV_AMD64_XMM10H = 302, - CV_AMD64_XMM11H = 303, - CV_AMD64_XMM12H = 304, - CV_AMD64_XMM13H = 305, - CV_AMD64_XMM14H = 306, - CV_AMD64_XMM15H = 307, - - CV_AMD64_EMM8L = 308, // XMM sub-registers (WNI integer) - CV_AMD64_EMM9L = 309, - CV_AMD64_EMM10L = 310, - CV_AMD64_EMM11L = 311, - CV_AMD64_EMM12L = 312, - CV_AMD64_EMM13L = 313, - CV_AMD64_EMM14L = 314, - CV_AMD64_EMM15L = 315, - - CV_AMD64_EMM8H = 316, - CV_AMD64_EMM9H = 317, - CV_AMD64_EMM10H = 318, - CV_AMD64_EMM11H = 319, - CV_AMD64_EMM12H = 320, - CV_AMD64_EMM13H = 321, - CV_AMD64_EMM14H = 322, - CV_AMD64_EMM15H = 323, - - // Low byte forms of some standard registers - CV_AMD64_SIL = 324, - CV_AMD64_DIL = 325, - CV_AMD64_BPL = 326, - CV_AMD64_SPL = 327, - - // 64-bit regular registers - CV_AMD64_RAX = 328, - CV_AMD64_RBX = 329, - CV_AMD64_RCX = 330, - CV_AMD64_RDX = 331, - CV_AMD64_RSI = 332, - CV_AMD64_RDI = 333, - CV_AMD64_RBP = 334, - CV_AMD64_RSP = 335, - - // 64-bit integer registers with 8-, 16-, and 32-bit forms (B, W, and D) - CV_AMD64_R8 = 336, - CV_AMD64_R9 = 337, - CV_AMD64_R10 = 338, - CV_AMD64_R11 = 339, - CV_AMD64_R12 = 340, - CV_AMD64_R13 = 341, - CV_AMD64_R14 = 342, - CV_AMD64_R15 = 343, - - CV_AMD64_R8B = 344, - CV_AMD64_R9B = 345, - CV_AMD64_R10B = 346, - CV_AMD64_R11B = 347, - CV_AMD64_R12B = 348, - CV_AMD64_R13B = 349, - CV_AMD64_R14B = 350, - CV_AMD64_R15B = 351, - - CV_AMD64_R8W = 352, - CV_AMD64_R9W = 353, - CV_AMD64_R10W = 354, - CV_AMD64_R11W = 355, - CV_AMD64_R12W = 356, - CV_AMD64_R13W = 357, - CV_AMD64_R14W = 358, - CV_AMD64_R15W = 359, - - CV_AMD64_R8D = 360, - CV_AMD64_R9D = 361, - CV_AMD64_R10D = 362, - CV_AMD64_R11D = 363, - CV_AMD64_R12D = 364, - CV_AMD64_R13D = 365, - CV_AMD64_R14D = 366, - CV_AMD64_R15D = 367, - - // AVX registers 256 bits - CV_AMD64_YMM0 = 368, - CV_AMD64_YMM1 = 369, - CV_AMD64_YMM2 = 370, - CV_AMD64_YMM3 = 371, - CV_AMD64_YMM4 = 372, - CV_AMD64_YMM5 = 373, - CV_AMD64_YMM6 = 374, - CV_AMD64_YMM7 = 375, - CV_AMD64_YMM8 = 376, - CV_AMD64_YMM9 = 377, - CV_AMD64_YMM10 = 378, - CV_AMD64_YMM11 = 379, - CV_AMD64_YMM12 = 380, - CV_AMD64_YMM13 = 381, - CV_AMD64_YMM14 = 382, - CV_AMD64_YMM15 = 383, - - // AVX registers upper 128 bits - CV_AMD64_YMM0H = 384, - CV_AMD64_YMM1H = 385, - CV_AMD64_YMM2H = 386, - CV_AMD64_YMM3H = 387, - CV_AMD64_YMM4H = 388, - CV_AMD64_YMM5H = 389, - CV_AMD64_YMM6H = 390, - CV_AMD64_YMM7H = 391, - CV_AMD64_YMM8H = 392, - CV_AMD64_YMM9H = 393, - CV_AMD64_YMM10H = 394, - CV_AMD64_YMM11H = 395, - CV_AMD64_YMM12H = 396, - CV_AMD64_YMM13H = 397, - CV_AMD64_YMM14H = 398, - CV_AMD64_YMM15H = 399, - - //Lower/upper 8 bytes of XMM registers. Unlike CV_AMD64_XMM, these - //values reprsesent the bit patterns of the registers as 64-bit integers, not - //the representation of these registers as a double. - CV_AMD64_XMM0IL = 400, - CV_AMD64_XMM1IL = 401, - CV_AMD64_XMM2IL = 402, - CV_AMD64_XMM3IL = 403, - CV_AMD64_XMM4IL = 404, - CV_AMD64_XMM5IL = 405, - CV_AMD64_XMM6IL = 406, - CV_AMD64_XMM7IL = 407, - CV_AMD64_XMM8IL = 408, - CV_AMD64_XMM9IL = 409, - CV_AMD64_XMM10IL = 410, - CV_AMD64_XMM11IL = 411, - CV_AMD64_XMM12IL = 412, - CV_AMD64_XMM13IL = 413, - CV_AMD64_XMM14IL = 414, - CV_AMD64_XMM15IL = 415, - - CV_AMD64_XMM0IH = 416, - CV_AMD64_XMM1IH = 417, - CV_AMD64_XMM2IH = 418, - CV_AMD64_XMM3IH = 419, - CV_AMD64_XMM4IH = 420, - CV_AMD64_XMM5IH = 421, - CV_AMD64_XMM6IH = 422, - CV_AMD64_XMM7IH = 423, - CV_AMD64_XMM8IH = 424, - CV_AMD64_XMM9IH = 425, - CV_AMD64_XMM10IH = 426, - CV_AMD64_XMM11IH = 427, - CV_AMD64_XMM12IH = 428, - CV_AMD64_XMM13IH = 429, - CV_AMD64_XMM14IH = 430, - CV_AMD64_XMM15IH = 431, - - CV_AMD64_YMM0I0 = 432, // AVX integer registers - CV_AMD64_YMM0I1 = 433, - CV_AMD64_YMM0I2 = 434, - CV_AMD64_YMM0I3 = 435, - CV_AMD64_YMM1I0 = 436, - CV_AMD64_YMM1I1 = 437, - CV_AMD64_YMM1I2 = 438, - CV_AMD64_YMM1I3 = 439, - CV_AMD64_YMM2I0 = 440, - CV_AMD64_YMM2I1 = 441, - CV_AMD64_YMM2I2 = 442, - CV_AMD64_YMM2I3 = 443, - CV_AMD64_YMM3I0 = 444, - CV_AMD64_YMM3I1 = 445, - CV_AMD64_YMM3I2 = 446, - CV_AMD64_YMM3I3 = 447, - CV_AMD64_YMM4I0 = 448, - CV_AMD64_YMM4I1 = 449, - CV_AMD64_YMM4I2 = 450, - CV_AMD64_YMM4I3 = 451, - CV_AMD64_YMM5I0 = 452, - CV_AMD64_YMM5I1 = 453, - CV_AMD64_YMM5I2 = 454, - CV_AMD64_YMM5I3 = 455, - CV_AMD64_YMM6I0 = 456, - CV_AMD64_YMM6I1 = 457, - CV_AMD64_YMM6I2 = 458, - CV_AMD64_YMM6I3 = 459, - CV_AMD64_YMM7I0 = 460, - CV_AMD64_YMM7I1 = 461, - CV_AMD64_YMM7I2 = 462, - CV_AMD64_YMM7I3 = 463, - CV_AMD64_YMM8I0 = 464, - CV_AMD64_YMM8I1 = 465, - CV_AMD64_YMM8I2 = 466, - CV_AMD64_YMM8I3 = 467, - CV_AMD64_YMM9I0 = 468, - CV_AMD64_YMM9I1 = 469, - CV_AMD64_YMM9I2 = 470, - CV_AMD64_YMM9I3 = 471, - CV_AMD64_YMM10I0 = 472, - CV_AMD64_YMM10I1 = 473, - CV_AMD64_YMM10I2 = 474, - CV_AMD64_YMM10I3 = 475, - CV_AMD64_YMM11I0 = 476, - CV_AMD64_YMM11I1 = 477, - CV_AMD64_YMM11I2 = 478, - CV_AMD64_YMM11I3 = 479, - CV_AMD64_YMM12I0 = 480, - CV_AMD64_YMM12I1 = 481, - CV_AMD64_YMM12I2 = 482, - CV_AMD64_YMM12I3 = 483, - CV_AMD64_YMM13I0 = 484, - CV_AMD64_YMM13I1 = 485, - CV_AMD64_YMM13I2 = 486, - CV_AMD64_YMM13I3 = 487, - CV_AMD64_YMM14I0 = 488, - CV_AMD64_YMM14I1 = 489, - CV_AMD64_YMM14I2 = 490, - CV_AMD64_YMM14I3 = 491, - CV_AMD64_YMM15I0 = 492, - CV_AMD64_YMM15I1 = 493, - CV_AMD64_YMM15I2 = 494, - CV_AMD64_YMM15I3 = 495, - - CV_AMD64_YMM0F0 = 496, // AVX floating-point single precise registers - CV_AMD64_YMM0F1 = 497, - CV_AMD64_YMM0F2 = 498, - CV_AMD64_YMM0F3 = 499, - CV_AMD64_YMM0F4 = 500, - CV_AMD64_YMM0F5 = 501, - CV_AMD64_YMM0F6 = 502, - CV_AMD64_YMM0F7 = 503, - CV_AMD64_YMM1F0 = 504, - CV_AMD64_YMM1F1 = 505, - CV_AMD64_YMM1F2 = 506, - CV_AMD64_YMM1F3 = 507, - CV_AMD64_YMM1F4 = 508, - CV_AMD64_YMM1F5 = 509, - CV_AMD64_YMM1F6 = 510, - CV_AMD64_YMM1F7 = 511, - CV_AMD64_YMM2F0 = 512, - CV_AMD64_YMM2F1 = 513, - CV_AMD64_YMM2F2 = 514, - CV_AMD64_YMM2F3 = 515, - CV_AMD64_YMM2F4 = 516, - CV_AMD64_YMM2F5 = 517, - CV_AMD64_YMM2F6 = 518, - CV_AMD64_YMM2F7 = 519, - CV_AMD64_YMM3F0 = 520, - CV_AMD64_YMM3F1 = 521, - CV_AMD64_YMM3F2 = 522, - CV_AMD64_YMM3F3 = 523, - CV_AMD64_YMM3F4 = 524, - CV_AMD64_YMM3F5 = 525, - CV_AMD64_YMM3F6 = 526, - CV_AMD64_YMM3F7 = 527, - CV_AMD64_YMM4F0 = 528, - CV_AMD64_YMM4F1 = 529, - CV_AMD64_YMM4F2 = 530, - CV_AMD64_YMM4F3 = 531, - CV_AMD64_YMM4F4 = 532, - CV_AMD64_YMM4F5 = 533, - CV_AMD64_YMM4F6 = 534, - CV_AMD64_YMM4F7 = 535, - CV_AMD64_YMM5F0 = 536, - CV_AMD64_YMM5F1 = 537, - CV_AMD64_YMM5F2 = 538, - CV_AMD64_YMM5F3 = 539, - CV_AMD64_YMM5F4 = 540, - CV_AMD64_YMM5F5 = 541, - CV_AMD64_YMM5F6 = 542, - CV_AMD64_YMM5F7 = 543, - CV_AMD64_YMM6F0 = 544, - CV_AMD64_YMM6F1 = 545, - CV_AMD64_YMM6F2 = 546, - CV_AMD64_YMM6F3 = 547, - CV_AMD64_YMM6F4 = 548, - CV_AMD64_YMM6F5 = 549, - CV_AMD64_YMM6F6 = 550, - CV_AMD64_YMM6F7 = 551, - CV_AMD64_YMM7F0 = 552, - CV_AMD64_YMM7F1 = 553, - CV_AMD64_YMM7F2 = 554, - CV_AMD64_YMM7F3 = 555, - CV_AMD64_YMM7F4 = 556, - CV_AMD64_YMM7F5 = 557, - CV_AMD64_YMM7F6 = 558, - CV_AMD64_YMM7F7 = 559, - CV_AMD64_YMM8F0 = 560, - CV_AMD64_YMM8F1 = 561, - CV_AMD64_YMM8F2 = 562, - CV_AMD64_YMM8F3 = 563, - CV_AMD64_YMM8F4 = 564, - CV_AMD64_YMM8F5 = 565, - CV_AMD64_YMM8F6 = 566, - CV_AMD64_YMM8F7 = 567, - CV_AMD64_YMM9F0 = 568, - CV_AMD64_YMM9F1 = 569, - CV_AMD64_YMM9F2 = 570, - CV_AMD64_YMM9F3 = 571, - CV_AMD64_YMM9F4 = 572, - CV_AMD64_YMM9F5 = 573, - CV_AMD64_YMM9F6 = 574, - CV_AMD64_YMM9F7 = 575, - CV_AMD64_YMM10F0 = 576, - CV_AMD64_YMM10F1 = 577, - CV_AMD64_YMM10F2 = 578, - CV_AMD64_YMM10F3 = 579, - CV_AMD64_YMM10F4 = 580, - CV_AMD64_YMM10F5 = 581, - CV_AMD64_YMM10F6 = 582, - CV_AMD64_YMM10F7 = 583, - CV_AMD64_YMM11F0 = 584, - CV_AMD64_YMM11F1 = 585, - CV_AMD64_YMM11F2 = 586, - CV_AMD64_YMM11F3 = 587, - CV_AMD64_YMM11F4 = 588, - CV_AMD64_YMM11F5 = 589, - CV_AMD64_YMM11F6 = 590, - CV_AMD64_YMM11F7 = 591, - CV_AMD64_YMM12F0 = 592, - CV_AMD64_YMM12F1 = 593, - CV_AMD64_YMM12F2 = 594, - CV_AMD64_YMM12F3 = 595, - CV_AMD64_YMM12F4 = 596, - CV_AMD64_YMM12F5 = 597, - CV_AMD64_YMM12F6 = 598, - CV_AMD64_YMM12F7 = 599, - CV_AMD64_YMM13F0 = 600, - CV_AMD64_YMM13F1 = 601, - CV_AMD64_YMM13F2 = 602, - CV_AMD64_YMM13F3 = 603, - CV_AMD64_YMM13F4 = 604, - CV_AMD64_YMM13F5 = 605, - CV_AMD64_YMM13F6 = 606, - CV_AMD64_YMM13F7 = 607, - CV_AMD64_YMM14F0 = 608, - CV_AMD64_YMM14F1 = 609, - CV_AMD64_YMM14F2 = 610, - CV_AMD64_YMM14F3 = 611, - CV_AMD64_YMM14F4 = 612, - CV_AMD64_YMM14F5 = 613, - CV_AMD64_YMM14F6 = 614, - CV_AMD64_YMM14F7 = 615, - CV_AMD64_YMM15F0 = 616, - CV_AMD64_YMM15F1 = 617, - CV_AMD64_YMM15F2 = 618, - CV_AMD64_YMM15F3 = 619, - CV_AMD64_YMM15F4 = 620, - CV_AMD64_YMM15F5 = 621, - CV_AMD64_YMM15F6 = 622, - CV_AMD64_YMM15F7 = 623, - - CV_AMD64_YMM0D0 = 624, // AVX floating-point double precise registers - CV_AMD64_YMM0D1 = 625, - CV_AMD64_YMM0D2 = 626, - CV_AMD64_YMM0D3 = 627, - CV_AMD64_YMM1D0 = 628, - CV_AMD64_YMM1D1 = 629, - CV_AMD64_YMM1D2 = 630, - CV_AMD64_YMM1D3 = 631, - CV_AMD64_YMM2D0 = 632, - CV_AMD64_YMM2D1 = 633, - CV_AMD64_YMM2D2 = 634, - CV_AMD64_YMM2D3 = 635, - CV_AMD64_YMM3D0 = 636, - CV_AMD64_YMM3D1 = 637, - CV_AMD64_YMM3D2 = 638, - CV_AMD64_YMM3D3 = 639, - CV_AMD64_YMM4D0 = 640, - CV_AMD64_YMM4D1 = 641, - CV_AMD64_YMM4D2 = 642, - CV_AMD64_YMM4D3 = 643, - CV_AMD64_YMM5D0 = 644, - CV_AMD64_YMM5D1 = 645, - CV_AMD64_YMM5D2 = 646, - CV_AMD64_YMM5D3 = 647, - CV_AMD64_YMM6D0 = 648, - CV_AMD64_YMM6D1 = 649, - CV_AMD64_YMM6D2 = 650, - CV_AMD64_YMM6D3 = 651, - CV_AMD64_YMM7D0 = 652, - CV_AMD64_YMM7D1 = 653, - CV_AMD64_YMM7D2 = 654, - CV_AMD64_YMM7D3 = 655, - CV_AMD64_YMM8D0 = 656, - CV_AMD64_YMM8D1 = 657, - CV_AMD64_YMM8D2 = 658, - CV_AMD64_YMM8D3 = 659, - CV_AMD64_YMM9D0 = 660, - CV_AMD64_YMM9D1 = 661, - CV_AMD64_YMM9D2 = 662, - CV_AMD64_YMM9D3 = 663, - CV_AMD64_YMM10D0 = 664, - CV_AMD64_YMM10D1 = 665, - CV_AMD64_YMM10D2 = 666, - CV_AMD64_YMM10D3 = 667, - CV_AMD64_YMM11D0 = 668, - CV_AMD64_YMM11D1 = 669, - CV_AMD64_YMM11D2 = 670, - CV_AMD64_YMM11D3 = 671, - CV_AMD64_YMM12D0 = 672, - CV_AMD64_YMM12D1 = 673, - CV_AMD64_YMM12D2 = 674, - CV_AMD64_YMM12D3 = 675, - CV_AMD64_YMM13D0 = 676, - CV_AMD64_YMM13D1 = 677, - CV_AMD64_YMM13D2 = 678, - CV_AMD64_YMM13D3 = 679, - CV_AMD64_YMM14D0 = 680, - CV_AMD64_YMM14D1 = 681, - CV_AMD64_YMM14D2 = 682, - CV_AMD64_YMM14D3 = 683, - CV_AMD64_YMM15D0 = 684, - CV_AMD64_YMM15D1 = 685, - CV_AMD64_YMM15D2 = 686, - CV_AMD64_YMM15D3 = 687 - - - // Note: Next set of platform registers need to go into a new enum... - // this one is above 44K now. - -} CV_HREG_e; - -typedef enum CV_HLSLREG_e { - CV_HLSLREG_TEMP = 0, - CV_HLSLREG_INPUT = 1, - CV_HLSLREG_OUTPUT = 2, - CV_HLSLREG_INDEXABLE_TEMP = 3, - CV_HLSLREG_IMMEDIATE32 = 4, - CV_HLSLREG_IMMEDIATE64 = 5, - CV_HLSLREG_SAMPLER = 6, - CV_HLSLREG_RESOURCE = 7, - CV_HLSLREG_CONSTANT_BUFFER = 8, - CV_HLSLREG_IMMEDIATE_CONSTANT_BUFFER = 9, - CV_HLSLREG_LABEL = 10, - CV_HLSLREG_INPUT_PRIMITIVEID = 11, - CV_HLSLREG_OUTPUT_DEPTH = 12, - CV_HLSLREG_NULL = 13, - CV_HLSLREG_RASTERIZER = 14, - CV_HLSLREG_OUTPUT_COVERAGE_MASK = 15, - CV_HLSLREG_STREAM = 16, - CV_HLSLREG_FUNCTION_BODY = 17, - CV_HLSLREG_FUNCTION_TABLE = 18, - CV_HLSLREG_INTERFACE = 19, - CV_HLSLREG_FUNCTION_INPUT = 20, - CV_HLSLREG_FUNCTION_OUTPUT = 21, - CV_HLSLREG_OUTPUT_CONTROL_POINT_ID = 22, - CV_HLSLREG_INPUT_FORK_INSTANCE_ID = 23, - CV_HLSLREG_INPUT_JOIN_INSTANCE_ID = 24, - CV_HLSLREG_INPUT_CONTROL_POINT = 25, - CV_HLSLREG_OUTPUT_CONTROL_POINT = 26, - CV_HLSLREG_INPUT_PATCH_CONSTANT = 27, - CV_HLSLREG_INPUT_DOMAIN_POINT = 28, - CV_HLSLREG_THIS_POINTER = 29, - CV_HLSLREG_UNORDERED_ACCESS_VIEW = 30, - CV_HLSLREG_THREAD_GROUP_SHARED_MEMORY = 31, - CV_HLSLREG_INPUT_THREAD_ID = 32, - CV_HLSLREG_INPUT_THREAD_GROUP_ID = 33, - CV_HLSLREG_INPUT_THREAD_ID_IN_GROUP = 34, - CV_HLSLREG_INPUT_COVERAGE_MASK = 35, - CV_HLSLREG_INPUT_THREAD_ID_IN_GROUP_FLATTENED = 36, - CV_HLSLREG_INPUT_GS_INSTANCE_ID = 37, - CV_HLSLREG_OUTPUT_DEPTH_GREATER_EQUAL = 38, - CV_HLSLREG_OUTPUT_DEPTH_LESS_EQUAL = 39, - CV_HLSLREG_CYCLE_COUNTER = 40, -} CV_HLSLREG_e; - -enum StackFrameTypeEnum -{ - FrameTypeFPO, // Frame pointer omitted, FPO info available - FrameTypeTrap, // Kernel Trap frame - FrameTypeTSS, // Kernel Trap frame - FrameTypeStandard, // Standard EBP stackframe - FrameTypeFrameData, // Frame pointer omitted, FrameData info available - - FrameTypeUnknown = -1, // Frame which does not have any debug info -}; - -enum MemoryTypeEnum -{ - MemTypeCode, // Read only code memory - MemTypeData, // Read only data/stack memory - MemTypeStack, // Read only stack memory - MemTypeCodeOnHeap, // Read only memory for code generated on heap by runtime - - MemTypeAny = -1, -}; - -typedef enum CV_HLSLMemorySpace_e -{ - // HLSL specific memory spaces - - CV_HLSL_MEMSPACE_DATA = 0x00, - CV_HLSL_MEMSPACE_SAMPLER = 0x01, - CV_HLSL_MEMSPACE_RESOURCE = 0x02, - CV_HLSL_MEMSPACE_RWRESOURCE = 0x03, - - CV_HLSL_MEMSPACE_MAX = 0x0F, -} CV_HLSLMemorySpace_e; - -#endif diff --git a/src/coreclr/inc/cvinfo.h b/src/coreclr/inc/cvinfo.h deleted file mode 100644 index ca62171fabd..00000000000 --- a/src/coreclr/inc/cvinfo.h +++ /dev/null @@ -1,4988 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -/*** cvinfo.h - Generic CodeView information definitions - * - * Structures, constants, etc. for accessing and interpreting - * CodeView information. - * - */ - - -/*** The master copy of this file resides in the langapi project. - * All Microsoft projects are required to use the master copy without - * modification. Modification of the master version or a copy - * without consultation with all parties concerned is extremely - * risky. - * - */ - -#pragma once - -#include "cvconst.h" - -#ifndef _CV_INFO_INCLUDED -#define _CV_INFO_INCLUDED - -#ifdef __cplusplus -#pragma warning ( disable: 4200 ) -#endif - -#ifndef __INLINE -#ifdef __cplusplus -#define __INLINE inline -#else -#define __INLINE __inline -#endif -#endif - -#pragma pack ( push, 1 ) -typedef unsigned long CV_uoff32_t; -typedef long CV_off32_t; -typedef unsigned short CV_uoff16_t; -typedef short CV_off16_t; -typedef unsigned short CV_typ16_t; -typedef unsigned long CV_typ_t; -typedef unsigned long CV_pubsymflag_t; // must be same as CV_typ_t. -typedef unsigned short _2BYTEPAD; -typedef unsigned long CV_tkn_t; - -#if !defined (CV_ZEROLEN) -#define CV_ZEROLEN -#endif - -#if !defined (FLOAT10) -#if defined(_M_I86) // 16 bit x86 supporting long double -typedef long double FLOAT10; -#else // 32 bit w/o long double support -typedef struct FLOAT10 -{ - char b[10]; -} FLOAT10; -#endif -#endif - - -#define CV_SIGNATURE_C6 0L // Actual signature is >64K -#define CV_SIGNATURE_C7 1L // First explicit signature -#define CV_SIGNATURE_C11 2L // C11 (vc5.x) 32-bit types -#define CV_SIGNATURE_C13 4L // C13 (vc7.x) zero terminated names -#define CV_SIGNATURE_RESERVED 5L // All signatures from 5 to 64K are reserved - -#define CV_MAXOFFSET 0xffffffff - -#ifndef GUID_DEFINED -#define GUID_DEFINED - -typedef struct _GUID { // size is 16 - unsigned long Data1; - unsigned short Data2; - unsigned short Data3; - unsigned char Data4[8]; -} GUID; - -#endif // !GUID_DEFINED - -typedef GUID SIG70; // new to 7.0 are 16-byte guid-like signatures -typedef SIG70 * PSIG70; -typedef const SIG70 * PCSIG70; - - - -/** CodeView Symbol and Type OMF type information is broken up into two - * ranges. Type indices less than 0x1000 describe type information - * that is frequently used. Type indices above 0x1000 are used to - * describe more complex features such as functions, arrays and - * structures. - */ - - - - -/** Primitive types have predefined meaning that is encoded in the - * values of the various bit fields in the value. - * - * A CodeView primitive type is defined as: - * - * 1 1 - * 1 089 7654 3 210 - * r mode type r sub - * - * Where - * mode is the pointer mode - * type is a type indicator - * sub is a subtype enumeration - * r is a reserved field - * - * See Microsoft Symbol and Type OMF (Version 4.0) for more - * information. - */ - - -#define CV_MMASK 0x700 // mode mask -#define CV_TMASK 0x0f0 // type mask - -// can we use the reserved bit ?? -#define CV_SMASK 0x00f // subtype mask - -#define CV_MSHIFT 8 // primitive mode right shift count -#define CV_TSHIFT 4 // primitive type right shift count -#define CV_SSHIFT 0 // primitive subtype right shift count - -// macros to extract primitive mode, type and size - -#define CV_MODE(typ) (((typ) & CV_MMASK) >> CV_MSHIFT) -#define CV_TYPE(typ) (((typ) & CV_TMASK) >> CV_TSHIFT) -#define CV_SUBT(typ) (((typ) & CV_SMASK) >> CV_SSHIFT) - -// macros to insert new primitive mode, type and size - -#define CV_NEWMODE(typ, nm) ((CV_typ_t)(((typ) & ~CV_MMASK) | ((nm) << CV_MSHIFT))) -#define CV_NEWTYPE(typ, nt) (((typ) & ~CV_TMASK) | ((nt) << CV_TSHIFT)) -#define CV_NEWSUBT(typ, ns) (((typ) & ~CV_SMASK) | ((ns) << CV_SSHIFT)) - - - -// pointer mode enumeration values - -typedef enum CV_prmode_e { - CV_TM_DIRECT = 0, // mode is not a pointer - CV_TM_NPTR = 1, // mode is a near pointer - CV_TM_FPTR = 2, // mode is a far pointer - CV_TM_HPTR = 3, // mode is a huge pointer - CV_TM_NPTR32 = 4, // mode is a 32 bit near pointer - CV_TM_FPTR32 = 5, // mode is a 32 bit far pointer - CV_TM_NPTR64 = 6, // mode is a 64 bit near pointer - CV_TM_NPTR128 = 7, // mode is a 128 bit near pointer -} CV_prmode_e; - - - - -// type enumeration values - - -typedef enum CV_type_e { - CV_SPECIAL = 0x00, // special type size values - CV_SIGNED = 0x01, // signed integral size values - CV_UNSIGNED = 0x02, // unsigned integral size values - CV_BOOLEAN = 0x03, // Boolean size values - CV_REAL = 0x04, // real number size values - CV_COMPLEX = 0x05, // complex number size values - CV_SPECIAL2 = 0x06, // second set of special types - CV_INT = 0x07, // integral (int) values - CV_CVRESERVED = 0x0f, -} CV_type_e; - - - - -// subtype enumeration values for CV_SPECIAL - - -typedef enum CV_special_e { - CV_SP_NOTYPE = 0x00, - CV_SP_ABS = 0x01, - CV_SP_SEGMENT = 0x02, - CV_SP_VOID = 0x03, - CV_SP_CURRENCY = 0x04, - CV_SP_NBASICSTR = 0x05, - CV_SP_FBASICSTR = 0x06, - CV_SP_NOTTRANS = 0x07, - CV_SP_HRESULT = 0x08, -} CV_special_e; - - - - -// subtype enumeration values for CV_SPECIAL2 - - -typedef enum CV_special2_e { - CV_S2_BIT = 0x00, - CV_S2_PASCHAR = 0x01, // Pascal CHAR - CV_S2_BOOL32FF = 0x02, // 32-bit BOOL where true is 0xffffffff -} CV_special2_e; - - - - - -// subtype enumeration values for CV_SIGNED, CV_UNSIGNED and CV_BOOLEAN - - -typedef enum CV_integral_e { - CV_IN_1BYTE = 0x00, - CV_IN_2BYTE = 0x01, - CV_IN_4BYTE = 0x02, - CV_IN_8BYTE = 0x03, - CV_IN_16BYTE = 0x04 -} CV_integral_e; - - - - - -// subtype enumeration values for CV_REAL and CV_COMPLEX - - -typedef enum CV_real_e { - CV_RC_REAL32 = 0x00, - CV_RC_REAL64 = 0x01, - CV_RC_REAL80 = 0x02, - CV_RC_REAL128 = 0x03, - CV_RC_REAL48 = 0x04, - CV_RC_REAL32PP = 0x05, // 32-bit partial precision real - CV_RC_REAL16 = 0x06, -} CV_real_e; - - - - -// subtype enumeration values for CV_INT (really int) - - -typedef enum CV_int_e { - CV_RI_CHAR = 0x00, - CV_RI_INT1 = 0x00, - CV_RI_WCHAR = 0x01, - CV_RI_UINT1 = 0x01, - CV_RI_INT2 = 0x02, - CV_RI_UINT2 = 0x03, - CV_RI_INT4 = 0x04, - CV_RI_UINT4 = 0x05, - CV_RI_INT8 = 0x06, - CV_RI_UINT8 = 0x07, - CV_RI_INT16 = 0x08, - CV_RI_UINT16 = 0x09, - CV_RI_CHAR16 = 0x0a, // char16_t - CV_RI_CHAR32 = 0x0b, // char32_t -} CV_int_e; - - - -// macros to check the type of a primitive - -#define CV_TYP_IS_DIRECT(typ) (CV_MODE(typ) == CV_TM_DIRECT) -#define CV_TYP_IS_PTR(typ) (CV_MODE(typ) != CV_TM_DIRECT) -#define CV_TYP_IS_NPTR(typ) (CV_MODE(typ) == CV_TM_NPTR) -#define CV_TYP_IS_FPTR(typ) (CV_MODE(typ) == CV_TM_FPTR) -#define CV_TYP_IS_HPTR(typ) (CV_MODE(typ) == CV_TM_HPTR) -#define CV_TYP_IS_NPTR32(typ) (CV_MODE(typ) == CV_TM_NPTR32) -#define CV_TYP_IS_FPTR32(typ) (CV_MODE(typ) == CV_TM_FPTR32) - -#define CV_TYP_IS_SIGNED(typ) (((CV_TYPE(typ) == CV_SIGNED) && CV_TYP_IS_DIRECT(typ)) || \ - (typ == T_INT1) || \ - (typ == T_INT2) || \ - (typ == T_INT4) || \ - (typ == T_INT8) || \ - (typ == T_INT16) || \ - (typ == T_RCHAR)) - -#define CV_TYP_IS_UNSIGNED(typ) (((CV_TYPE(typ) == CV_UNSIGNED) && CV_TYP_IS_DIRECT(typ)) || \ - (typ == T_UINT1) || \ - (typ == T_UINT2) || \ - (typ == T_UINT4) || \ - (typ == T_UINT8) || \ - (typ == T_UINT16)) - -#define CV_TYP_IS_REAL(typ) ((CV_TYPE(typ) == CV_REAL) && CV_TYP_IS_DIRECT(typ)) - -#define CV_FIRST_NONPRIM 0x1000 -#define CV_IS_PRIMITIVE(typ) ((typ) < CV_FIRST_NONPRIM) -#define CV_TYP_IS_COMPLEX(typ) ((CV_TYPE(typ) == CV_COMPLEX) && CV_TYP_IS_DIRECT(typ)) -#define CV_IS_INTERNAL_PTR(typ) (CV_IS_PRIMITIVE(typ) && \ - CV_TYPE(typ) == CV_CVRESERVED && \ - CV_TYP_IS_PTR(typ)) - - - - - - -// selected values for type_index - for a more complete definition, see -// Microsoft Symbol and Type OMF document - - - - -// Special Types - -typedef enum TYPE_ENUM_e { -// Special Types - - T_NOTYPE = 0x0000, // uncharacterized type (no type) - T_ABS = 0x0001, // absolute symbol - T_SEGMENT = 0x0002, // segment type - T_VOID = 0x0003, // void - T_HRESULT = 0x0008, // OLE/COM HRESULT - T_32PHRESULT = 0x0408, // OLE/COM HRESULT __ptr32 * - T_64PHRESULT = 0x0608, // OLE/COM HRESULT __ptr64 * - - T_PVOID = 0x0103, // near pointer to void - T_PFVOID = 0x0203, // far pointer to void - T_PHVOID = 0x0303, // huge pointer to void - T_32PVOID = 0x0403, // 32 bit pointer to void - T_32PFVOID = 0x0503, // 16:32 pointer to void - T_64PVOID = 0x0603, // 64 bit pointer to void - T_CURRENCY = 0x0004, // BASIC 8 byte currency value - T_NBASICSTR = 0x0005, // Near BASIC string - T_FBASICSTR = 0x0006, // Far BASIC string - T_NOTTRANS = 0x0007, // type not translated by cvpack - T_BIT = 0x0060, // bit - T_PASCHAR = 0x0061, // Pascal CHAR - T_BOOL32FF = 0x0062, // 32-bit BOOL where true is 0xffffffff - - -// Character types - - T_CHAR = 0x0010, // 8 bit signed - T_PCHAR = 0x0110, // 16 bit pointer to 8 bit signed - T_PFCHAR = 0x0210, // 16:16 far pointer to 8 bit signed - T_PHCHAR = 0x0310, // 16:16 huge pointer to 8 bit signed - T_32PCHAR = 0x0410, // 32 bit pointer to 8 bit signed - T_32PFCHAR = 0x0510, // 16:32 pointer to 8 bit signed - T_64PCHAR = 0x0610, // 64 bit pointer to 8 bit signed - - T_UCHAR = 0x0020, // 8 bit unsigned - T_PUCHAR = 0x0120, // 16 bit pointer to 8 bit unsigned - T_PFUCHAR = 0x0220, // 16:16 far pointer to 8 bit unsigned - T_PHUCHAR = 0x0320, // 16:16 huge pointer to 8 bit unsigned - T_32PUCHAR = 0x0420, // 32 bit pointer to 8 bit unsigned - T_32PFUCHAR = 0x0520, // 16:32 pointer to 8 bit unsigned - T_64PUCHAR = 0x0620, // 64 bit pointer to 8 bit unsigned - - -// really a character types - - T_RCHAR = 0x0070, // really a char - T_PRCHAR = 0x0170, // 16 bit pointer to a real char - T_PFRCHAR = 0x0270, // 16:16 far pointer to a real char - T_PHRCHAR = 0x0370, // 16:16 huge pointer to a real char - T_32PRCHAR = 0x0470, // 32 bit pointer to a real char - T_32PFRCHAR = 0x0570, // 16:32 pointer to a real char - T_64PRCHAR = 0x0670, // 64 bit pointer to a real char - - -// really a wide character types - - T_WCHAR = 0x0071, // wide char - T_PWCHAR = 0x0171, // 16 bit pointer to a wide char - T_PFWCHAR = 0x0271, // 16:16 far pointer to a wide char - T_PHWCHAR = 0x0371, // 16:16 huge pointer to a wide char - T_32PWCHAR = 0x0471, // 32 bit pointer to a wide char - T_32PFWCHAR = 0x0571, // 16:32 pointer to a wide char - T_64PWCHAR = 0x0671, // 64 bit pointer to a wide char - -// really a 16-bit unicode char - - T_CHAR16 = 0x007a, // 16-bit unicode char - T_PCHAR16 = 0x017a, // 16 bit pointer to a 16-bit unicode char - T_PFCHAR16 = 0x027a, // 16:16 far pointer to a 16-bit unicode char - T_PHCHAR16 = 0x037a, // 16:16 huge pointer to a 16-bit unicode char - T_32PCHAR16 = 0x047a, // 32 bit pointer to a 16-bit unicode char - T_32PFCHAR16 = 0x057a, // 16:32 pointer to a 16-bit unicode char - T_64PCHAR16 = 0x067a, // 64 bit pointer to a 16-bit unicode char - -// really a 32-bit unicode char - - T_CHAR32 = 0x007b, // 32-bit unicode char - T_PCHAR32 = 0x017b, // 16 bit pointer to a 32-bit unicode char - T_PFCHAR32 = 0x027b, // 16:16 far pointer to a 32-bit unicode char - T_PHCHAR32 = 0x037b, // 16:16 huge pointer to a 32-bit unicode char - T_32PCHAR32 = 0x047b, // 32 bit pointer to a 32-bit unicode char - T_32PFCHAR32 = 0x057b, // 16:32 pointer to a 32-bit unicode char - T_64PCHAR32 = 0x067b, // 64 bit pointer to a 32-bit unicode char - -// 8 bit int types - - T_INT1 = 0x0068, // 8 bit signed int - T_PINT1 = 0x0168, // 16 bit pointer to 8 bit signed int - T_PFINT1 = 0x0268, // 16:16 far pointer to 8 bit signed int - T_PHINT1 = 0x0368, // 16:16 huge pointer to 8 bit signed int - T_32PINT1 = 0x0468, // 32 bit pointer to 8 bit signed int - T_32PFINT1 = 0x0568, // 16:32 pointer to 8 bit signed int - T_64PINT1 = 0x0668, // 64 bit pointer to 8 bit signed int - - T_UINT1 = 0x0069, // 8 bit unsigned int - T_PUINT1 = 0x0169, // 16 bit pointer to 8 bit unsigned int - T_PFUINT1 = 0x0269, // 16:16 far pointer to 8 bit unsigned int - T_PHUINT1 = 0x0369, // 16:16 huge pointer to 8 bit unsigned int - T_32PUINT1 = 0x0469, // 32 bit pointer to 8 bit unsigned int - T_32PFUINT1 = 0x0569, // 16:32 pointer to 8 bit unsigned int - T_64PUINT1 = 0x0669, // 64 bit pointer to 8 bit unsigned int - - -// 16 bit short types - - T_SHORT = 0x0011, // 16 bit signed - T_PSHORT = 0x0111, // 16 bit pointer to 16 bit signed - T_PFSHORT = 0x0211, // 16:16 far pointer to 16 bit signed - T_PHSHORT = 0x0311, // 16:16 huge pointer to 16 bit signed - T_32PSHORT = 0x0411, // 32 bit pointer to 16 bit signed - T_32PFSHORT = 0x0511, // 16:32 pointer to 16 bit signed - T_64PSHORT = 0x0611, // 64 bit pointer to 16 bit signed - - T_USHORT = 0x0021, // 16 bit unsigned - T_PUSHORT = 0x0121, // 16 bit pointer to 16 bit unsigned - T_PFUSHORT = 0x0221, // 16:16 far pointer to 16 bit unsigned - T_PHUSHORT = 0x0321, // 16:16 huge pointer to 16 bit unsigned - T_32PUSHORT = 0x0421, // 32 bit pointer to 16 bit unsigned - T_32PFUSHORT = 0x0521, // 16:32 pointer to 16 bit unsigned - T_64PUSHORT = 0x0621, // 64 bit pointer to 16 bit unsigned - - -// 16 bit int types - - T_INT2 = 0x0072, // 16 bit signed int - T_PINT2 = 0x0172, // 16 bit pointer to 16 bit signed int - T_PFINT2 = 0x0272, // 16:16 far pointer to 16 bit signed int - T_PHINT2 = 0x0372, // 16:16 huge pointer to 16 bit signed int - T_32PINT2 = 0x0472, // 32 bit pointer to 16 bit signed int - T_32PFINT2 = 0x0572, // 16:32 pointer to 16 bit signed int - T_64PINT2 = 0x0672, // 64 bit pointer to 16 bit signed int - - T_UINT2 = 0x0073, // 16 bit unsigned int - T_PUINT2 = 0x0173, // 16 bit pointer to 16 bit unsigned int - T_PFUINT2 = 0x0273, // 16:16 far pointer to 16 bit unsigned int - T_PHUINT2 = 0x0373, // 16:16 huge pointer to 16 bit unsigned int - T_32PUINT2 = 0x0473, // 32 bit pointer to 16 bit unsigned int - T_32PFUINT2 = 0x0573, // 16:32 pointer to 16 bit unsigned int - T_64PUINT2 = 0x0673, // 64 bit pointer to 16 bit unsigned int - - -// 32 bit long types - - T_LONG = 0x0012, // 32 bit signed - T_ULONG = 0x0022, // 32 bit unsigned - T_PLONG = 0x0112, // 16 bit pointer to 32 bit signed - T_PULONG = 0x0122, // 16 bit pointer to 32 bit unsigned - T_PFLONG = 0x0212, // 16:16 far pointer to 32 bit signed - T_PFULONG = 0x0222, // 16:16 far pointer to 32 bit unsigned - T_PHLONG = 0x0312, // 16:16 huge pointer to 32 bit signed - T_PHULONG = 0x0322, // 16:16 huge pointer to 32 bit unsigned - - T_32PLONG = 0x0412, // 32 bit pointer to 32 bit signed - T_32PULONG = 0x0422, // 32 bit pointer to 32 bit unsigned - T_32PFLONG = 0x0512, // 16:32 pointer to 32 bit signed - T_32PFULONG = 0x0522, // 16:32 pointer to 32 bit unsigned - T_64PLONG = 0x0612, // 64 bit pointer to 32 bit signed - T_64PULONG = 0x0622, // 64 bit pointer to 32 bit unsigned - - -// 32 bit int types - - T_INT4 = 0x0074, // 32 bit signed int - T_PINT4 = 0x0174, // 16 bit pointer to 32 bit signed int - T_PFINT4 = 0x0274, // 16:16 far pointer to 32 bit signed int - T_PHINT4 = 0x0374, // 16:16 huge pointer to 32 bit signed int - T_32PINT4 = 0x0474, // 32 bit pointer to 32 bit signed int - T_32PFINT4 = 0x0574, // 16:32 pointer to 32 bit signed int - T_64PINT4 = 0x0674, // 64 bit pointer to 32 bit signed int - - T_UINT4 = 0x0075, // 32 bit unsigned int - T_PUINT4 = 0x0175, // 16 bit pointer to 32 bit unsigned int - T_PFUINT4 = 0x0275, // 16:16 far pointer to 32 bit unsigned int - T_PHUINT4 = 0x0375, // 16:16 huge pointer to 32 bit unsigned int - T_32PUINT4 = 0x0475, // 32 bit pointer to 32 bit unsigned int - T_32PFUINT4 = 0x0575, // 16:32 pointer to 32 bit unsigned int - T_64PUINT4 = 0x0675, // 64 bit pointer to 32 bit unsigned int - - -// 64 bit quad types - - T_QUAD = 0x0013, // 64 bit signed - T_PQUAD = 0x0113, // 16 bit pointer to 64 bit signed - T_PFQUAD = 0x0213, // 16:16 far pointer to 64 bit signed - T_PHQUAD = 0x0313, // 16:16 huge pointer to 64 bit signed - T_32PQUAD = 0x0413, // 32 bit pointer to 64 bit signed - T_32PFQUAD = 0x0513, // 16:32 pointer to 64 bit signed - T_64PQUAD = 0x0613, // 64 bit pointer to 64 bit signed - - T_UQUAD = 0x0023, // 64 bit unsigned - T_PUQUAD = 0x0123, // 16 bit pointer to 64 bit unsigned - T_PFUQUAD = 0x0223, // 16:16 far pointer to 64 bit unsigned - T_PHUQUAD = 0x0323, // 16:16 huge pointer to 64 bit unsigned - T_32PUQUAD = 0x0423, // 32 bit pointer to 64 bit unsigned - T_32PFUQUAD = 0x0523, // 16:32 pointer to 64 bit unsigned - T_64PUQUAD = 0x0623, // 64 bit pointer to 64 bit unsigned - - -// 64 bit int types - - T_INT8 = 0x0076, // 64 bit signed int - T_PINT8 = 0x0176, // 16 bit pointer to 64 bit signed int - T_PFINT8 = 0x0276, // 16:16 far pointer to 64 bit signed int - T_PHINT8 = 0x0376, // 16:16 huge pointer to 64 bit signed int - T_32PINT8 = 0x0476, // 32 bit pointer to 64 bit signed int - T_32PFINT8 = 0x0576, // 16:32 pointer to 64 bit signed int - T_64PINT8 = 0x0676, // 64 bit pointer to 64 bit signed int - - T_UINT8 = 0x0077, // 64 bit unsigned int - T_PUINT8 = 0x0177, // 16 bit pointer to 64 bit unsigned int - T_PFUINT8 = 0x0277, // 16:16 far pointer to 64 bit unsigned int - T_PHUINT8 = 0x0377, // 16:16 huge pointer to 64 bit unsigned int - T_32PUINT8 = 0x0477, // 32 bit pointer to 64 bit unsigned int - T_32PFUINT8 = 0x0577, // 16:32 pointer to 64 bit unsigned int - T_64PUINT8 = 0x0677, // 64 bit pointer to 64 bit unsigned int - - -// 128 bit octet types - - T_OCT = 0x0014, // 128 bit signed - T_POCT = 0x0114, // 16 bit pointer to 128 bit signed - T_PFOCT = 0x0214, // 16:16 far pointer to 128 bit signed - T_PHOCT = 0x0314, // 16:16 huge pointer to 128 bit signed - T_32POCT = 0x0414, // 32 bit pointer to 128 bit signed - T_32PFOCT = 0x0514, // 16:32 pointer to 128 bit signed - T_64POCT = 0x0614, // 64 bit pointer to 128 bit signed - - T_UOCT = 0x0024, // 128 bit unsigned - T_PUOCT = 0x0124, // 16 bit pointer to 128 bit unsigned - T_PFUOCT = 0x0224, // 16:16 far pointer to 128 bit unsigned - T_PHUOCT = 0x0324, // 16:16 huge pointer to 128 bit unsigned - T_32PUOCT = 0x0424, // 32 bit pointer to 128 bit unsigned - T_32PFUOCT = 0x0524, // 16:32 pointer to 128 bit unsigned - T_64PUOCT = 0x0624, // 64 bit pointer to 128 bit unsigned - - -// 128 bit int types - - T_INT16 = 0x0078, // 128 bit signed int - T_PINT16 = 0x0178, // 16 bit pointer to 128 bit signed int - T_PFINT16 = 0x0278, // 16:16 far pointer to 128 bit signed int - T_PHINT16 = 0x0378, // 16:16 huge pointer to 128 bit signed int - T_32PINT16 = 0x0478, // 32 bit pointer to 128 bit signed int - T_32PFINT16 = 0x0578, // 16:32 pointer to 128 bit signed int - T_64PINT16 = 0x0678, // 64 bit pointer to 128 bit signed int - - T_UINT16 = 0x0079, // 128 bit unsigned int - T_PUINT16 = 0x0179, // 16 bit pointer to 128 bit unsigned int - T_PFUINT16 = 0x0279, // 16:16 far pointer to 128 bit unsigned int - T_PHUINT16 = 0x0379, // 16:16 huge pointer to 128 bit unsigned int - T_32PUINT16 = 0x0479, // 32 bit pointer to 128 bit unsigned int - T_32PFUINT16 = 0x0579, // 16:32 pointer to 128 bit unsigned int - T_64PUINT16 = 0x0679, // 64 bit pointer to 128 bit unsigned int - - -// 16 bit real types - - T_REAL16 = 0x0046, // 16 bit real - T_PREAL16 = 0x0146, // 16 bit pointer to 16 bit real - T_PFREAL16 = 0x0246, // 16:16 far pointer to 16 bit real - T_PHREAL16 = 0x0346, // 16:16 huge pointer to 16 bit real - T_32PREAL16 = 0x0446, // 32 bit pointer to 16 bit real - T_32PFREAL16 = 0x0546, // 16:32 pointer to 16 bit real - T_64PREAL16 = 0x0646, // 64 bit pointer to 16 bit real - - -// 32 bit real types - - T_REAL32 = 0x0040, // 32 bit real - T_PREAL32 = 0x0140, // 16 bit pointer to 32 bit real - T_PFREAL32 = 0x0240, // 16:16 far pointer to 32 bit real - T_PHREAL32 = 0x0340, // 16:16 huge pointer to 32 bit real - T_32PREAL32 = 0x0440, // 32 bit pointer to 32 bit real - T_32PFREAL32 = 0x0540, // 16:32 pointer to 32 bit real - T_64PREAL32 = 0x0640, // 64 bit pointer to 32 bit real - - -// 32 bit partial-precision real types - - T_REAL32PP = 0x0045, // 32 bit PP real - T_PREAL32PP = 0x0145, // 16 bit pointer to 32 bit PP real - T_PFREAL32PP = 0x0245, // 16:16 far pointer to 32 bit PP real - T_PHREAL32PP = 0x0345, // 16:16 huge pointer to 32 bit PP real - T_32PREAL32PP = 0x0445, // 32 bit pointer to 32 bit PP real - T_32PFREAL32PP = 0x0545, // 16:32 pointer to 32 bit PP real - T_64PREAL32PP = 0x0645, // 64 bit pointer to 32 bit PP real - - -// 48 bit real types - - T_REAL48 = 0x0044, // 48 bit real - T_PREAL48 = 0x0144, // 16 bit pointer to 48 bit real - T_PFREAL48 = 0x0244, // 16:16 far pointer to 48 bit real - T_PHREAL48 = 0x0344, // 16:16 huge pointer to 48 bit real - T_32PREAL48 = 0x0444, // 32 bit pointer to 48 bit real - T_32PFREAL48 = 0x0544, // 16:32 pointer to 48 bit real - T_64PREAL48 = 0x0644, // 64 bit pointer to 48 bit real - - -// 64 bit real types - - T_REAL64 = 0x0041, // 64 bit real - T_PREAL64 = 0x0141, // 16 bit pointer to 64 bit real - T_PFREAL64 = 0x0241, // 16:16 far pointer to 64 bit real - T_PHREAL64 = 0x0341, // 16:16 huge pointer to 64 bit real - T_32PREAL64 = 0x0441, // 32 bit pointer to 64 bit real - T_32PFREAL64 = 0x0541, // 16:32 pointer to 64 bit real - T_64PREAL64 = 0x0641, // 64 bit pointer to 64 bit real - - -// 80 bit real types - - T_REAL80 = 0x0042, // 80 bit real - T_PREAL80 = 0x0142, // 16 bit pointer to 80 bit real - T_PFREAL80 = 0x0242, // 16:16 far pointer to 80 bit real - T_PHREAL80 = 0x0342, // 16:16 huge pointer to 80 bit real - T_32PREAL80 = 0x0442, // 32 bit pointer to 80 bit real - T_32PFREAL80 = 0x0542, // 16:32 pointer to 80 bit real - T_64PREAL80 = 0x0642, // 64 bit pointer to 80 bit real - - -// 128 bit real types - - T_REAL128 = 0x0043, // 128 bit real - T_PREAL128 = 0x0143, // 16 bit pointer to 128 bit real - T_PFREAL128 = 0x0243, // 16:16 far pointer to 128 bit real - T_PHREAL128 = 0x0343, // 16:16 huge pointer to 128 bit real - T_32PREAL128 = 0x0443, // 32 bit pointer to 128 bit real - T_32PFREAL128 = 0x0543, // 16:32 pointer to 128 bit real - T_64PREAL128 = 0x0643, // 64 bit pointer to 128 bit real - - -// 32 bit complex types - - T_CPLX32 = 0x0050, // 32 bit complex - T_PCPLX32 = 0x0150, // 16 bit pointer to 32 bit complex - T_PFCPLX32 = 0x0250, // 16:16 far pointer to 32 bit complex - T_PHCPLX32 = 0x0350, // 16:16 huge pointer to 32 bit complex - T_32PCPLX32 = 0x0450, // 32 bit pointer to 32 bit complex - T_32PFCPLX32 = 0x0550, // 16:32 pointer to 32 bit complex - T_64PCPLX32 = 0x0650, // 64 bit pointer to 32 bit complex - - -// 64 bit complex types - - T_CPLX64 = 0x0051, // 64 bit complex - T_PCPLX64 = 0x0151, // 16 bit pointer to 64 bit complex - T_PFCPLX64 = 0x0251, // 16:16 far pointer to 64 bit complex - T_PHCPLX64 = 0x0351, // 16:16 huge pointer to 64 bit complex - T_32PCPLX64 = 0x0451, // 32 bit pointer to 64 bit complex - T_32PFCPLX64 = 0x0551, // 16:32 pointer to 64 bit complex - T_64PCPLX64 = 0x0651, // 64 bit pointer to 64 bit complex - - -// 80 bit complex types - - T_CPLX80 = 0x0052, // 80 bit complex - T_PCPLX80 = 0x0152, // 16 bit pointer to 80 bit complex - T_PFCPLX80 = 0x0252, // 16:16 far pointer to 80 bit complex - T_PHCPLX80 = 0x0352, // 16:16 huge pointer to 80 bit complex - T_32PCPLX80 = 0x0452, // 32 bit pointer to 80 bit complex - T_32PFCPLX80 = 0x0552, // 16:32 pointer to 80 bit complex - T_64PCPLX80 = 0x0652, // 64 bit pointer to 80 bit complex - - -// 128 bit complex types - - T_CPLX128 = 0x0053, // 128 bit complex - T_PCPLX128 = 0x0153, // 16 bit pointer to 128 bit complex - T_PFCPLX128 = 0x0253, // 16:16 far pointer to 128 bit complex - T_PHCPLX128 = 0x0353, // 16:16 huge pointer to 128 bit real - T_32PCPLX128 = 0x0453, // 32 bit pointer to 128 bit complex - T_32PFCPLX128 = 0x0553, // 16:32 pointer to 128 bit complex - T_64PCPLX128 = 0x0653, // 64 bit pointer to 128 bit complex - - -// boolean types - - T_BOOL08 = 0x0030, // 8 bit boolean - T_PBOOL08 = 0x0130, // 16 bit pointer to 8 bit boolean - T_PFBOOL08 = 0x0230, // 16:16 far pointer to 8 bit boolean - T_PHBOOL08 = 0x0330, // 16:16 huge pointer to 8 bit boolean - T_32PBOOL08 = 0x0430, // 32 bit pointer to 8 bit boolean - T_32PFBOOL08 = 0x0530, // 16:32 pointer to 8 bit boolean - T_64PBOOL08 = 0x0630, // 64 bit pointer to 8 bit boolean - - T_BOOL16 = 0x0031, // 16 bit boolean - T_PBOOL16 = 0x0131, // 16 bit pointer to 16 bit boolean - T_PFBOOL16 = 0x0231, // 16:16 far pointer to 16 bit boolean - T_PHBOOL16 = 0x0331, // 16:16 huge pointer to 16 bit boolean - T_32PBOOL16 = 0x0431, // 32 bit pointer to 18 bit boolean - T_32PFBOOL16 = 0x0531, // 16:32 pointer to 16 bit boolean - T_64PBOOL16 = 0x0631, // 64 bit pointer to 18 bit boolean - - T_BOOL32 = 0x0032, // 32 bit boolean - T_PBOOL32 = 0x0132, // 16 bit pointer to 32 bit boolean - T_PFBOOL32 = 0x0232, // 16:16 far pointer to 32 bit boolean - T_PHBOOL32 = 0x0332, // 16:16 huge pointer to 32 bit boolean - T_32PBOOL32 = 0x0432, // 32 bit pointer to 32 bit boolean - T_32PFBOOL32 = 0x0532, // 16:32 pointer to 32 bit boolean - T_64PBOOL32 = 0x0632, // 64 bit pointer to 32 bit boolean - - T_BOOL64 = 0x0033, // 64 bit boolean - T_PBOOL64 = 0x0133, // 16 bit pointer to 64 bit boolean - T_PFBOOL64 = 0x0233, // 16:16 far pointer to 64 bit boolean - T_PHBOOL64 = 0x0333, // 16:16 huge pointer to 64 bit boolean - T_32PBOOL64 = 0x0433, // 32 bit pointer to 64 bit boolean - T_32PFBOOL64 = 0x0533, // 16:32 pointer to 64 bit boolean - T_64PBOOL64 = 0x0633, // 64 bit pointer to 64 bit boolean - - -// ??? - - T_NCVPTR = 0x01f0, // CV Internal type for created near pointers - T_FCVPTR = 0x02f0, // CV Internal type for created far pointers - T_HCVPTR = 0x03f0, // CV Internal type for created huge pointers - T_32NCVPTR = 0x04f0, // CV Internal type for created near 32-bit pointers - T_32FCVPTR = 0x05f0, // CV Internal type for created far 32-bit pointers - T_64NCVPTR = 0x06f0, // CV Internal type for created near 64-bit pointers - -} TYPE_ENUM_e; - -/** No leaf index can have a value of 0x0000. The leaf indices are - * separated into ranges depending upon the use of the type record. - * The second range is for the type records that are directly referenced - * in symbols. The first range is for type records that are not - * referenced by symbols but instead are referenced by other type - * records. All type records must have a starting leaf index in these - * first two ranges. The third range of leaf indices are used to build - * up complex lists such as the field list of a class type record. No - * type record can begin with one of the leaf indices. The fourth ranges - * of type indices are used to represent numeric data in a symbol or - * type record. These leaf indices are greater than 0x8000. At the - * point that type or symbol processor is expecting a numeric field, the - * next two bytes in the type record are examined. If the value is less - * than 0x8000, then the two bytes contain the numeric value. If the - * value is greater than 0x8000, then the data follows the leaf index in - * a format specified by the leaf index. The final range of leaf indices - * are used to force alignment of subfields within a complex type record.. - */ - - -typedef enum LEAF_ENUM_e { - // leaf indices starting records but referenced from symbol records - - LF_MODIFIER_16t = 0x0001, - LF_POINTER_16t = 0x0002, - LF_ARRAY_16t = 0x0003, - LF_CLASS_16t = 0x0004, - LF_STRUCTURE_16t = 0x0005, - LF_UNION_16t = 0x0006, - LF_ENUM_16t = 0x0007, - LF_PROCEDURE_16t = 0x0008, - LF_MFUNCTION_16t = 0x0009, - LF_VTSHAPE = 0x000a, - LF_COBOL0_16t = 0x000b, - LF_COBOL1 = 0x000c, - LF_BARRAY_16t = 0x000d, - LF_LABEL = 0x000e, - LF_NULL = 0x000f, - LF_NOTTRAN = 0x0010, - LF_DIMARRAY_16t = 0x0011, - LF_VFTPATH_16t = 0x0012, - LF_PRECOMP_16t = 0x0013, // not referenced from symbol - LF_ENDPRECOMP = 0x0014, // not referenced from symbol - LF_OEM_16t = 0x0015, // oem definable type string - LF_TYPESERVER_ST = 0x0016, // not referenced from symbol - - // leaf indices starting records but referenced only from type records - - LF_SKIP_16t = 0x0200, - LF_ARGLIST_16t = 0x0201, - LF_DEFARG_16t = 0x0202, - LF_LIST = 0x0203, - LF_FIELDLIST_16t = 0x0204, - LF_DERIVED_16t = 0x0205, - LF_BITFIELD_16t = 0x0206, - LF_METHODLIST_16t = 0x0207, - LF_DIMCONU_16t = 0x0208, - LF_DIMCONLU_16t = 0x0209, - LF_DIMVARU_16t = 0x020a, - LF_DIMVARLU_16t = 0x020b, - LF_REFSYM = 0x020c, - - LF_BCLASS_16t = 0x0400, - LF_VBCLASS_16t = 0x0401, - LF_IVBCLASS_16t = 0x0402, - LF_ENUMERATE_ST = 0x0403, - LF_FRIENDFCN_16t = 0x0404, - LF_INDEX_16t = 0x0405, - LF_MEMBER_16t = 0x0406, - LF_STMEMBER_16t = 0x0407, - LF_METHOD_16t = 0x0408, - LF_NESTTYPE_16t = 0x0409, - LF_VFUNCTAB_16t = 0x040a, - LF_FRIENDCLS_16t = 0x040b, - LF_ONEMETHOD_16t = 0x040c, - LF_VFUNCOFF_16t = 0x040d, - -// 32-bit type index versions of leaves, all have the 0x1000 bit set -// - LF_TI16_MAX = 0x1000, - - LF_MODIFIER = 0x1001, - LF_POINTER = 0x1002, - LF_ARRAY_ST = 0x1003, - LF_CLASS_ST = 0x1004, - LF_STRUCTURE_ST = 0x1005, - LF_UNION_ST = 0x1006, - LF_ENUM_ST = 0x1007, - LF_PROCEDURE = 0x1008, - LF_MFUNCTION = 0x1009, - LF_COBOL0 = 0x100a, - LF_BARRAY = 0x100b, - LF_DIMARRAY_ST = 0x100c, - LF_VFTPATH = 0x100d, - LF_PRECOMP_ST = 0x100e, // not referenced from symbol - LF_OEM = 0x100f, // oem definable type string - LF_ALIAS_ST = 0x1010, // alias (typedef) type - LF_OEM2 = 0x1011, // oem definable type string - - // leaf indices starting records but referenced only from type records - - LF_SKIP = 0x1200, - LF_ARGLIST = 0x1201, - LF_DEFARG_ST = 0x1202, - LF_FIELDLIST = 0x1203, - LF_DERIVED = 0x1204, - LF_BITFIELD = 0x1205, - LF_METHODLIST = 0x1206, - LF_DIMCONU = 0x1207, - LF_DIMCONLU = 0x1208, - LF_DIMVARU = 0x1209, - LF_DIMVARLU = 0x120a, - - LF_BCLASS = 0x1400, - LF_VBCLASS = 0x1401, - LF_IVBCLASS = 0x1402, - LF_FRIENDFCN_ST = 0x1403, - LF_INDEX = 0x1404, - LF_MEMBER_ST = 0x1405, - LF_STMEMBER_ST = 0x1406, - LF_METHOD_ST = 0x1407, - LF_NESTTYPE_ST = 0x1408, - LF_VFUNCTAB = 0x1409, - LF_FRIENDCLS = 0x140a, - LF_ONEMETHOD_ST = 0x140b, - LF_VFUNCOFF = 0x140c, - LF_NESTTYPEEX_ST = 0x140d, - LF_MEMBERMODIFY_ST = 0x140e, - LF_MANAGED_ST = 0x140f, - - // Types w/ SZ names - - LF_ST_MAX = 0x1500, - - LF_TYPESERVER = 0x1501, // not referenced from symbol - LF_ENUMERATE = 0x1502, - LF_ARRAY = 0x1503, - LF_CLASS = 0x1504, - LF_STRUCTURE = 0x1505, - LF_UNION = 0x1506, - LF_ENUM = 0x1507, - LF_DIMARRAY = 0x1508, - LF_PRECOMP = 0x1509, // not referenced from symbol - LF_ALIAS = 0x150a, // alias (typedef) type - LF_DEFARG = 0x150b, - LF_FRIENDFCN = 0x150c, - LF_MEMBER = 0x150d, - LF_STMEMBER = 0x150e, - LF_METHOD = 0x150f, - LF_NESTTYPE = 0x1510, - LF_ONEMETHOD = 0x1511, - LF_NESTTYPEEX = 0x1512, - LF_MEMBERMODIFY = 0x1513, - LF_MANAGED = 0x1514, - LF_TYPESERVER2 = 0x1515, - - LF_STRIDED_ARRAY = 0x1516, // same as LF_ARRAY, but with stride between adjacent elements - LF_HLSL = 0x1517, - LF_MODIFIER_EX = 0x1518, - LF_INTERFACE = 0x1519, - LF_BINTERFACE = 0x151a, - LF_VECTOR = 0x151b, - LF_MATRIX = 0x151c, - - LF_VFTABLE = 0x151d, // a virtual function table - LF_ENDOFLEAFRECORD = LF_VFTABLE, - - LF_TYPE_LAST, // one greater than the last type record - LF_TYPE_MAX = LF_TYPE_LAST - 1, - - LF_FUNC_ID = 0x1601, // global func ID - LF_MFUNC_ID = 0x1602, // member func ID - LF_BUILDINFO = 0x1603, // build info: tool, version, command line, src/pdb file - LF_SUBSTR_LIST = 0x1604, // similar to LF_ARGLIST, for list of sub strings - LF_STRING_ID = 0x1605, // string ID - - LF_UDT_SRC_LINE = 0x1606, // source and line on where an UDT is defined - // only generated by compiler - - LF_UDT_MOD_SRC_LINE = 0x1607, // module, source and line on where an UDT is defined - // only generated by linker - - LF_ID_LAST, // one greater than the last ID record - LF_ID_MAX = LF_ID_LAST - 1, - - LF_NUMERIC = 0x8000, - LF_CHAR = 0x8000, - LF_SHORT = 0x8001, - LF_USHORT = 0x8002, - LF_LONG = 0x8003, - LF_ULONG = 0x8004, - LF_REAL32 = 0x8005, - LF_REAL64 = 0x8006, - LF_REAL80 = 0x8007, - LF_REAL128 = 0x8008, - LF_QUADWORD = 0x8009, - LF_UQUADWORD = 0x800a, - LF_REAL48 = 0x800b, - LF_COMPLEX32 = 0x800c, - LF_COMPLEX64 = 0x800d, - LF_COMPLEX80 = 0x800e, - LF_COMPLEX128 = 0x800f, - LF_VARSTRING = 0x8010, - - LF_OCTWORD = 0x8017, - LF_UOCTWORD = 0x8018, - - LF_DECIMAL = 0x8019, - LF_DATE = 0x801a, - LF_UTF8STRING = 0x801b, - - LF_REAL16 = 0x801c, - - LF_PAD0 = 0xf0, - LF_PAD1 = 0xf1, - LF_PAD2 = 0xf2, - LF_PAD3 = 0xf3, - LF_PAD4 = 0xf4, - LF_PAD5 = 0xf5, - LF_PAD6 = 0xf6, - LF_PAD7 = 0xf7, - LF_PAD8 = 0xf8, - LF_PAD9 = 0xf9, - LF_PAD10 = 0xfa, - LF_PAD11 = 0xfb, - LF_PAD12 = 0xfc, - LF_PAD13 = 0xfd, - LF_PAD14 = 0xfe, - LF_PAD15 = 0xff, - -} LEAF_ENUM_e; - -// end of leaf indices - - - - -// Type enum for pointer records -// Pointers can be one of the following types - - -typedef enum CV_ptrtype_e { - CV_PTR_NEAR = 0x00, // 16 bit pointer - CV_PTR_FAR = 0x01, // 16:16 far pointer - CV_PTR_HUGE = 0x02, // 16:16 huge pointer - CV_PTR_BASE_SEG = 0x03, // based on segment - CV_PTR_BASE_VAL = 0x04, // based on value of base - CV_PTR_BASE_SEGVAL = 0x05, // based on segment value of base - CV_PTR_BASE_ADDR = 0x06, // based on address of base - CV_PTR_BASE_SEGADDR = 0x07, // based on segment address of base - CV_PTR_BASE_TYPE = 0x08, // based on type - CV_PTR_BASE_SELF = 0x09, // based on self - CV_PTR_NEAR32 = 0x0a, // 32 bit pointer - CV_PTR_FAR32 = 0x0b, // 16:32 pointer - CV_PTR_64 = 0x0c, // 64 bit pointer - CV_PTR_UNUSEDPTR = 0x0d // first unused pointer type -} CV_ptrtype_e; - - - - - -// Mode enum for pointers -// Pointers can have one of the following modes -// -// To support for l-value and r-value reference, we added CV_PTR_MODE_LVREF -// and CV_PTR_MODE_RVREF. CV_PTR_MODE_REF should be removed at some point. -// We keep it now so that old code that uses it won't be broken. -// - -typedef enum CV_ptrmode_e { - CV_PTR_MODE_PTR = 0x00, // "normal" pointer - CV_PTR_MODE_REF = 0x01, // "old" reference - CV_PTR_MODE_LVREF = 0x01, // l-value reference - CV_PTR_MODE_PMEM = 0x02, // pointer to data member - CV_PTR_MODE_PMFUNC = 0x03, // pointer to member function - CV_PTR_MODE_RVREF = 0x04, // r-value reference - CV_PTR_MODE_RESERVED= 0x05 // first unused pointer mode -} CV_ptrmode_e; - - -// enumeration for pointer-to-member types - -typedef enum CV_pmtype_e { - CV_PMTYPE_Undef = 0x00, // not specified (pre VC8) - CV_PMTYPE_D_Single = 0x01, // member data, single inheritance - CV_PMTYPE_D_Multiple= 0x02, // member data, multiple inheritance - CV_PMTYPE_D_Virtual = 0x03, // member data, virtual inheritance - CV_PMTYPE_D_General = 0x04, // member data, most general - CV_PMTYPE_F_Single = 0x05, // member function, single inheritance - CV_PMTYPE_F_Multiple= 0x06, // member function, multiple inheritance - CV_PMTYPE_F_Virtual = 0x07, // member function, virtual inheritance - CV_PMTYPE_F_General = 0x08, // member function, most general -} CV_pmtype_e; - -// enumeration for method properties - -typedef enum CV_methodprop_e { - CV_MTvanilla = 0x00, - CV_MTvirtual = 0x01, - CV_MTstatic = 0x02, - CV_MTfriend = 0x03, - CV_MTintro = 0x04, - CV_MTpurevirt = 0x05, - CV_MTpureintro = 0x06 -} CV_methodprop_e; - - - - -// enumeration for virtual shape table entries - -typedef enum CV_VTS_desc_e { - CV_VTS_near = 0x00, - CV_VTS_far = 0x01, - CV_VTS_thin = 0x02, - CV_VTS_outer = 0x03, - CV_VTS_meta = 0x04, - CV_VTS_near32 = 0x05, - CV_VTS_far32 = 0x06, - CV_VTS_unused = 0x07 -} CV_VTS_desc_e; - - - - -// enumeration for LF_LABEL address modes - -typedef enum CV_LABEL_TYPE_e { - CV_LABEL_NEAR = 0, // near return - CV_LABEL_FAR = 4 // far return -} CV_LABEL_TYPE_e; - - - -// enumeration for LF_MODIFIER values - - -typedef struct CV_modifier_t { - unsigned short MOD_const :1; - unsigned short MOD_volatile :1; - unsigned short MOD_unaligned :1; - unsigned short MOD_unused :13; -} CV_modifier_t; - - - - -// enumeration for HFA kinds - -typedef enum CV_HFA_e { - CV_HFA_none = 0, - CV_HFA_float = 1, - CV_HFA_double = 2, - CV_HFA_other = 3 -} CV_HFA_e; - -// enumeration for MoCOM UDT kinds - -typedef enum CV_MOCOM_UDT_e { - CV_MOCOM_UDT_none = 0, - CV_MOCOM_UDT_ref = 1, - CV_MOCOM_UDT_value = 2, - CV_MOCOM_UDT_interface = 3 -} CV_MOCOM_UDT_e; - -// bit field structure describing class/struct/union/enum properties - -typedef struct CV_prop_t { - unsigned short packed :1; // true if structure is packed - unsigned short ctor :1; // true if constructors or destructors present - unsigned short ovlops :1; // true if overloaded operators present - unsigned short isnested :1; // true if this is a nested class - unsigned short cnested :1; // true if this class contains nested types - unsigned short opassign :1; // true if overloaded assignment (=) - unsigned short opcast :1; // true if casting methods - unsigned short fwdref :1; // true if forward reference (incomplete defn) - unsigned short scoped :1; // scoped definition - unsigned short hasuniquename :1; // true if there is a decorated name following the regular name - unsigned short sealed :1; // true if class cannot be used as a base class - unsigned short hfa :2; // CV_HFA_e - unsigned short intrinsic :1; // true if class is an intrinsic type (e.g. __m128d) - unsigned short mocom :2; // CV_MOCOM_UDT_e -} CV_prop_t; - - - - -// class field attribute - -typedef struct CV_fldattr_t { - unsigned short access :2; // access protection CV_access_t - unsigned short mprop :3; // method properties CV_methodprop_t - unsigned short pseudo :1; // compiler generated fcn and does not exist - unsigned short noinherit :1; // true if class cannot be inherited - unsigned short noconstruct :1; // true if class cannot be constructed - unsigned short compgenx :1; // compiler generated fcn and does exist - unsigned short sealed :1; // true if method cannot be overridden - unsigned short unused :6; // unused -} CV_fldattr_t; - - -// function flags - -typedef struct CV_funcattr_t { - unsigned char cxxreturnudt :1; // true if C++ style ReturnUDT - unsigned char ctor :1; // true if func is an instance constructor - unsigned char ctorvbase :1; // true if func is an instance constructor of a class with virtual bases - unsigned char unused :5; // unused -} CV_funcattr_t; - - -// matrix flags - -typedef struct CV_matrixattr_t { - unsigned char row_major :1; // true if matrix has row-major layout (column-major is default) - unsigned char unused :7; // unused -} CV_matrixattr_t; - - -// Structures to access to the type records - - -typedef struct TYPTYPE { - unsigned short len; - unsigned short leaf; - unsigned char data[CV_ZEROLEN]; -} TYPTYPE; // general types record - -__INLINE char *NextType ( _In_ char * pType) { - return (pType + ((TYPTYPE *)pType)->len + sizeof(unsigned short)); -} - -typedef enum CV_PMEMBER { - CV_PDM16_NONVIRT = 0x00, // 16:16 data no virtual fcn or base - CV_PDM16_VFCN = 0x01, // 16:16 data with virtual functions - CV_PDM16_VBASE = 0x02, // 16:16 data with virtual bases - CV_PDM32_NVVFCN = 0x03, // 16:32 data w/wo virtual functions - CV_PDM32_VBASE = 0x04, // 16:32 data with virtual bases - - CV_PMF16_NEARNVSA = 0x05, // 16:16 near method nonvirtual single address point - CV_PMF16_NEARNVMA = 0x06, // 16:16 near method nonvirtual multiple address points - CV_PMF16_NEARVBASE = 0x07, // 16:16 near method virtual bases - CV_PMF16_FARNVSA = 0x08, // 16:16 far method nonvirtual single address point - CV_PMF16_FARNVMA = 0x09, // 16:16 far method nonvirtual multiple address points - CV_PMF16_FARVBASE = 0x0a, // 16:16 far method virtual bases - - CV_PMF32_NVSA = 0x0b, // 16:32 method nonvirtual single address point - CV_PMF32_NVMA = 0x0c, // 16:32 method nonvirtual multiple address point - CV_PMF32_VBASE = 0x0d // 16:32 method virtual bases -} CV_PMEMBER; - - - -// memory representation of pointer to member. These representations are -// indexed by the enumeration above in the LF_POINTER record - - - - -// representation of a 16:16 pointer to data for a class with no -// virtual functions or virtual bases - - -struct CV_PDMR16_NONVIRT { - CV_off16_t mdisp; // displacement to data (NULL = -1) -}; - - - - -// representation of a 16:16 pointer to data for a class with virtual -// functions - - -struct CV_PMDR16_VFCN { - CV_off16_t mdisp; // displacement to data ( NULL = 0) -}; - - - - -// representation of a 16:16 pointer to data for a class with -// virtual bases - - -struct CV_PDMR16_VBASE { - CV_off16_t mdisp; // displacement to data - CV_off16_t pdisp; // this pointer displacement to vbptr - CV_off16_t vdisp; // displacement within vbase table - // NULL = (,,0xffff) -}; - - - - -// representation of a 32 bit pointer to data for a class with -// or without virtual functions and no virtual bases - - -struct CV_PDMR32_NVVFCN { - CV_off32_t mdisp; // displacement to data (NULL = 0x80000000) -}; - - - - -// representation of a 32 bit pointer to data for a class -// with virtual bases - - -struct CV_PDMR32_VBASE { - CV_off32_t mdisp; // displacement to data - CV_off32_t pdisp; // this pointer displacement - CV_off32_t vdisp; // vbase table displacement - // NULL = (,,0xffffffff) -}; - - - - -// representation of a 16:16 pointer to near member function for a -// class with no virtual functions or bases and a single address point - - -struct CV_PMFR16_NEARNVSA { - CV_uoff16_t off; // near address of function (NULL = 0) -}; - - - -// representation of a 16 bit pointer to member functions of a -// class with no virtual bases and multiple address points - - -struct CV_PMFR16_NEARNVMA { - CV_uoff16_t off; // offset of function (NULL = 0,x) - signed short disp; -}; - - - - -// representation of a 16 bit pointer to member function of a -// class with virtual bases - - -struct CV_PMFR16_NEARVBASE { - CV_uoff16_t off; // offset of function (NULL = 0,x,x,x) - CV_off16_t mdisp; // displacement to data - CV_off16_t pdisp; // this pointer displacement - CV_off16_t vdisp; // vbase table displacement -}; - - - - -// representation of a 16:16 pointer to far member function for a -// class with no virtual bases and a single address point - - -struct CV_PMFR16_FARNVSA { - CV_uoff16_t off; // offset of function (NULL = 0:0) - unsigned short seg; // segment of function -}; - - - - -// representation of a 16:16 far pointer to member functions of a -// class with no virtual bases and multiple address points - - -struct CV_PMFR16_FARNVMA { - CV_uoff16_t off; // offset of function (NULL = 0:0,x) - unsigned short seg; - signed short disp; -}; - - - - -// representation of a 16:16 far pointer to member function of a -// class with virtual bases - - -struct CV_PMFR16_FARVBASE { - CV_uoff16_t off; // offset of function (NULL = 0:0,x,x,x) - unsigned short seg; - CV_off16_t mdisp; // displacement to data - CV_off16_t pdisp; // this pointer displacement - CV_off16_t vdisp; // vbase table displacement - -}; - - - - -// representation of a 32 bit pointer to member function for a -// class with no virtual bases and a single address point - - -struct CV_PMFR32_NVSA { - CV_uoff32_t off; // near address of function (NULL = 0L) -}; - - - - -// representation of a 32 bit pointer to member function for a -// class with no virtual bases and multiple address points - - -struct CV_PMFR32_NVMA { - CV_uoff32_t off; // near address of function (NULL = 0L,x) - CV_off32_t disp; -}; - - - - -// representation of a 32 bit pointer to member function for a -// class with virtual bases - - -struct CV_PMFR32_VBASE { - CV_uoff32_t off; // near address of function (NULL = 0L,x,x,x) - CV_off32_t mdisp; // displacement to data - CV_off32_t pdisp; // this pointer displacement - CV_off32_t vdisp; // vbase table displacement -}; - - - - - -// Easy leaf - used for generic casting to reference leaf field -// of a subfield of a complex list - -typedef struct lfEasy { - unsigned short leaf; // LF_... -} lfEasy; - - -/** The following type records are basically variant records of the - * above structure. The "unsigned short leaf" of the above structure and - * the "unsigned short leaf" of the following type definitions are the same - * symbol. When the OMF record is locked via the MHOMFLock API - * call, the address of the "unsigned short leaf" is returned - */ - -/** Notes on alignment - * Alignment of the fields in most of the type records is done on the - * basis of the TYPTYPE record base. That is why in most of the lf* - * records that the CV_typ_t (32-bit types) is located on what appears to - * be a offset mod 4 == 2 boundary. The exception to this rule are those - * records that are in a list (lfFieldList, lfMethodList), which are - * aligned to their own bases since they don't have the length field - */ - -/**** Change log for 16-bit to 32-bit type and symbol records - - Record type Change (f == field arrangement, p = padding added) - ---------------------------------------------------------------------- - lfModifier f - lfPointer fp - lfClass f - lfStructure f - lfUnion f - lfEnum f - lfVFTPath p - lfPreComp p - lfOEM p - lfArgList p - lfDerived p - mlMethod p (method list member) - lfBitField f - lfDimCon f - lfDimVar p - lfIndex p (field list member) - lfBClass f (field list member) - lfVBClass f (field list member) - lfFriendCls p (field list member) - lfFriendFcn p (field list member) - lfMember f (field list member) - lfSTMember f (field list member) - lfVFuncTab p (field list member) - lfVFuncOff p (field list member) - lfNestType p (field list member) - - DATASYM32 f - PROCSYM32 f - VPATHSYM32 f - REGREL32 f - THREADSYM32 f - PROCSYMMIPS f - - -*/ - -// Type record for LF_MODIFIER - -typedef struct lfModifier_16t { - unsigned short leaf; // LF_MODIFIER_16t - CV_modifier_t attr; // modifier attribute modifier_t - CV_typ16_t type; // modified type -} lfModifier_16t; - -typedef struct lfModifier { - unsigned short leaf; // LF_MODIFIER - CV_typ_t type; // modified type - CV_modifier_t attr; // modifier attribute modifier_t -} lfModifier; - - - - -// type record for LF_POINTER - -#ifndef __cplusplus -typedef struct lfPointer_16t { -#endif - struct lfPointerBody_16t { - unsigned short leaf; // LF_POINTER_16t - struct lfPointerAttr_16t { - unsigned char ptrtype :5; // ordinal specifying pointer type (CV_ptrtype_e) - unsigned char ptrmode :3; // ordinal specifying pointer mode (CV_ptrmode_e) - unsigned char isflat32 :1; // true if 0:32 pointer - unsigned char isvolatile :1; // TRUE if volatile pointer - unsigned char isconst :1; // TRUE if const pointer - unsigned char isunaligned :1; // TRUE if unaligned pointer - unsigned char unused :4; - } attr; - CV_typ16_t utype; // type index of the underlying type -#if (defined(__cplusplus) || defined(_MSC_VER)) // for C++ and MS compilers that support unnamed unions - }; -#else - } u; -#endif -#ifdef __cplusplus -typedef struct lfPointer_16t : public lfPointerBody_16t { -#endif - union { - struct { - CV_typ16_t pmclass; // index of containing class for pointer to member - unsigned short pmenum; // enumeration specifying pm format (CV_pmtype_e) - } pm; - unsigned short bseg; // base segment if PTR_BASE_SEG - unsigned char Sym[1]; // copy of base symbol record (including length) - struct { - CV_typ16_t index; // type index if CV_PTR_BASE_TYPE - unsigned char name[1]; // name of base type - } btype; - } pbase; -} lfPointer_16t; - -#ifndef __cplusplus -typedef struct lfPointer { -#endif - struct lfPointerBody { - unsigned short leaf; // LF_POINTER - CV_typ_t utype; // type index of the underlying type - struct lfPointerAttr { - unsigned long ptrtype :5; // ordinal specifying pointer type (CV_ptrtype_e) - unsigned long ptrmode :3; // ordinal specifying pointer mode (CV_ptrmode_e) - unsigned long isflat32 :1; // true if 0:32 pointer - unsigned long isvolatile :1; // TRUE if volatile pointer - unsigned long isconst :1; // TRUE if const pointer - unsigned long isunaligned :1; // TRUE if unaligned pointer - unsigned long isrestrict :1; // TRUE if restricted pointer (allow agressive opts) - unsigned long size :6; // size of pointer (in bytes) - unsigned long ismocom :1; // TRUE if it is a MoCOM pointer (^ or %) - unsigned long islref :1; // TRUE if it is this pointer of member function with & ref-qualifier - unsigned long isrref :1; // TRUE if it is this pointer of member function with && ref-qualifier - unsigned long unused :10;// pad out to 32-bits for following cv_typ_t's - } attr; -#if (defined(__cplusplus) || defined(_MSC_VER)) // for C++ and MS compilers that support unnamed unions - }; -#else - } u; -#endif -#ifdef __cplusplus -typedef struct lfPointer : public lfPointerBody { -#endif - union { - struct { - CV_typ_t pmclass; // index of containing class for pointer to member - unsigned short pmenum; // enumeration specifying pm format (CV_pmtype_e) - } pm; - unsigned short bseg; // base segment if PTR_BASE_SEG - unsigned char Sym[1]; // copy of base symbol record (including length) - struct { - CV_typ_t index; // type index if CV_PTR_BASE_TYPE - unsigned char name[1]; // name of base type - } btype; - } pbase; -} lfPointer; - - - - -// type record for LF_ARRAY - - -typedef struct lfArray_16t { - unsigned short leaf; // LF_ARRAY_16t - CV_typ16_t elemtype; // type index of element type - CV_typ16_t idxtype; // type index of indexing type - unsigned char data[CV_ZEROLEN]; // variable length data specifying - // size in bytes and name -} lfArray_16t; - -typedef struct lfArray { - unsigned short leaf; // LF_ARRAY - CV_typ_t elemtype; // type index of element type - CV_typ_t idxtype; // type index of indexing type - unsigned char data[CV_ZEROLEN]; // variable length data specifying - // size in bytes and name -} lfArray; - -typedef struct lfStridedArray { - unsigned short leaf; // LF_STRIDED_ARRAY - CV_typ_t elemtype; // type index of element type - CV_typ_t idxtype; // type index of indexing type - unsigned long stride; - unsigned char data[CV_ZEROLEN]; // variable length data specifying - // size in bytes and name -} lfStridedArray; - - - - -// type record for LF_VECTOR - - -typedef struct lfVector { - unsigned short leaf; // LF_VECTOR - CV_typ_t elemtype; // type index of element type - unsigned long count; // number of elements in the vector - unsigned char data[CV_ZEROLEN]; // variable length data specifying - // size in bytes and name -} lfVector; - - - - -// type record for LF_MATRIX - - -typedef struct lfMatrix { - unsigned short leaf; // LF_MATRIX - CV_typ_t elemtype; // type index of element type - unsigned long rows; // number of rows - unsigned long cols; // number of columns - unsigned long majorStride; - CV_matrixattr_t matattr; // attributes - unsigned char data[CV_ZEROLEN]; // variable length data specifying - // size in bytes and name -} lfMatrix; - - - - -// type record for LF_CLASS, LF_STRUCTURE - - -typedef struct lfClass_16t { - unsigned short leaf; // LF_CLASS_16t, LF_STRUCT_16t - unsigned short count; // count of number of elements in class - CV_typ16_t field; // type index of LF_FIELD descriptor list - CV_prop_t property; // property attribute field (prop_t) - CV_typ16_t derived; // type index of derived from list if not zero - CV_typ16_t vshape; // type index of vshape table for this class - unsigned char data[CV_ZEROLEN]; // data describing length of structure in - // bytes and name -} lfClass_16t; -typedef lfClass_16t lfStructure_16t; - - -typedef struct lfClass { - unsigned short leaf; // LF_CLASS, LF_STRUCT, LF_INTERFACE - unsigned short count; // count of number of elements in class - CV_prop_t property; // property attribute field (prop_t) - CV_typ_t field; // type index of LF_FIELD descriptor list - CV_typ_t derived; // type index of derived from list if not zero - CV_typ_t vshape; // type index of vshape table for this class - unsigned char data[CV_ZEROLEN]; // data describing length of structure in - // bytes and name -} lfClass; -typedef lfClass lfStructure; -typedef lfClass lfInterface; - -// type record for LF_UNION - - -typedef struct lfUnion_16t { - unsigned short leaf; // LF_UNION_16t - unsigned short count; // count of number of elements in class - CV_typ16_t field; // type index of LF_FIELD descriptor list - CV_prop_t property; // property attribute field - unsigned char data[CV_ZEROLEN]; // variable length data describing length of - // structure and name -} lfUnion_16t; - - -typedef struct lfUnion { - unsigned short leaf; // LF_UNION - unsigned short count; // count of number of elements in class - CV_prop_t property; // property attribute field - CV_typ_t field; // type index of LF_FIELD descriptor list - unsigned char data[CV_ZEROLEN]; // variable length data describing length of - // structure and name -} lfUnion; - - -// type record for LF_ALIAS - -typedef struct lfAlias { - unsigned short leaf; // LF_ALIAS - CV_typ_t utype; // underlying type - unsigned char Name[1]; // alias name -} lfAlias; - -// Item Id is a stricter typeindex which may referenced from symbol stream. -// The code item always had a name. - -typedef CV_typ_t CV_ItemId; - -typedef struct lfFuncId { - unsigned short leaf; // LF_FUNC_ID - CV_ItemId scopeId; // parent scope of the ID, 0 if global - CV_typ_t type; // function type - unsigned char name[CV_ZEROLEN]; -} lfFuncId; - -typedef struct lfMFuncId { - unsigned short leaf; // LF_MFUNC_ID - CV_typ_t parentType; // type index of parent - CV_typ_t type; // function type - unsigned char name[CV_ZEROLEN]; -} lfMFuncId; - -typedef struct lfStringId { - unsigned short leaf; // LF_STRING_ID - CV_ItemId id; // ID to list of sub string IDs - unsigned char name[CV_ZEROLEN]; -} lfStringId; - -typedef struct lfUdtSrcLine { - unsigned short leaf; // LF_UDT_SRC_LINE - CV_typ_t type; // UDT's type index - CV_ItemId src; // index to LF_STRING_ID record where source file name is saved - unsigned long line; // line number -} lfUdtSrcLine; - -typedef struct lfUdtModSrcLine { - unsigned short leaf; // LF_UDT_MOD_SRC_LINE - CV_typ_t type; // UDT's type index - CV_ItemId src; // index into string table where source file name is saved - unsigned long line; // line number - unsigned short imod; // module that contributes this UDT definition -} lfUdtModSrcLine; - -typedef enum CV_BuildInfo_e { - CV_BuildInfo_CurrentDirectory = 0, - CV_BuildInfo_BuildTool = 1, // Cl.exe - CV_BuildInfo_SourceFile = 2, // foo.cpp - CV_BuildInfo_ProgramDatabaseFile = 3, // foo.pdb - CV_BuildInfo_CommandArguments = 4, // -I etc - CV_BUILDINFO_KNOWN -} CV_BuildInfo_e; - -// type record for build information - -typedef struct lfBuildInfo { - unsigned short leaf; // LF_BUILDINFO - unsigned short count; // number of arguments - CV_ItemId arg[CV_BUILDINFO_KNOWN]; // arguments as CodeItemId -} lfBuildInfo; - -// type record for LF_MANAGED - -typedef struct lfManaged { - unsigned short leaf; // LF_MANAGED - unsigned char Name[1]; // utf8, zero terminated managed type name -} lfManaged; - - -// type record for LF_ENUM - - -typedef struct lfEnum_16t { - unsigned short leaf; // LF_ENUM_16t - unsigned short count; // count of number of elements in class - CV_typ16_t utype; // underlying type of the enum - CV_typ16_t field; // type index of LF_FIELD descriptor list - CV_prop_t property; // property attribute field - unsigned char Name[1]; // length prefixed name of enum -} lfEnum_16t; - -typedef struct lfEnum { - unsigned short leaf; // LF_ENUM - unsigned short count; // count of number of elements in class - CV_prop_t property; // property attribute field - CV_typ_t utype; // underlying type of the enum - CV_typ_t field; // type index of LF_FIELD descriptor list - unsigned char Name[1]; // length prefixed name of enum -} lfEnum; - - - -// Type record for LF_PROCEDURE - - -typedef struct lfProc_16t { - unsigned short leaf; // LF_PROCEDURE_16t - CV_typ16_t rvtype; // type index of return value - unsigned char calltype; // calling convention (CV_call_t) - CV_funcattr_t funcattr; // attributes - unsigned short parmcount; // number of parameters - CV_typ16_t arglist; // type index of argument list -} lfProc_16t; - -typedef struct lfProc { - unsigned short leaf; // LF_PROCEDURE - CV_typ_t rvtype; // type index of return value - unsigned char calltype; // calling convention (CV_call_t) - CV_funcattr_t funcattr; // attributes - unsigned short parmcount; // number of parameters - CV_typ_t arglist; // type index of argument list -} lfProc; - - - -// Type record for member function - - -typedef struct lfMFunc_16t { - unsigned short leaf; // LF_MFUNCTION_16t - CV_typ16_t rvtype; // type index of return value - CV_typ16_t classtype; // type index of containing class - CV_typ16_t thistype; // type index of this pointer (model specific) - unsigned char calltype; // calling convention (call_t) - CV_funcattr_t funcattr; // attributes - unsigned short parmcount; // number of parameters - CV_typ16_t arglist; // type index of argument list - long thisadjust; // this adjuster (long because pad required anyway) -} lfMFunc_16t; - -typedef struct lfMFunc { - unsigned short leaf; // LF_MFUNCTION - CV_typ_t rvtype; // type index of return value - CV_typ_t classtype; // type index of containing class - CV_typ_t thistype; // type index of this pointer (model specific) - unsigned char calltype; // calling convention (call_t) - CV_funcattr_t funcattr; // attributes - unsigned short parmcount; // number of parameters - CV_typ_t arglist; // type index of argument list - long thisadjust; // this adjuster (long because pad required anyway) -} lfMFunc; - - - - -// type record for virtual function table shape - - -typedef struct lfVTShape { - unsigned short leaf; // LF_VTSHAPE - unsigned short count; // number of entries in vfunctable - unsigned char desc[CV_ZEROLEN]; // 4 bit (CV_VTS_desc) descriptors -} lfVTShape; - -// type record for a virtual function table -typedef struct lfVftable { - unsigned short leaf; // LF_VFTABLE - CV_typ_t type; // class/structure that owns the vftable - CV_typ_t baseVftable; // vftable from which this vftable is derived - unsigned long offsetInObjectLayout; // offset of the vfptr to this table, relative to the start of the object layout. - unsigned long len; // length of the Names array below in bytes. - unsigned char Names[1]; // array of names. - // The first is the name of the vtable. - // The others are the names of the methods. - // TS-TODO: replace a name with a NamedCodeItem once Weiping is done, to - // avoid duplication of method names. -} lfVftable; - -// type record for cobol0 - - -typedef struct lfCobol0_16t { - unsigned short leaf; // LF_COBOL0_16t - CV_typ16_t type; // parent type record index - unsigned char data[CV_ZEROLEN]; -} lfCobol0_16t; - -typedef struct lfCobol0 { - unsigned short leaf; // LF_COBOL0 - CV_typ_t type; // parent type record index - unsigned char data[CV_ZEROLEN]; -} lfCobol0; - - - - -// type record for cobol1 - - -typedef struct lfCobol1 { - unsigned short leaf; // LF_COBOL1 - unsigned char data[CV_ZEROLEN]; -} lfCobol1; - - - - -// type record for basic array - - -typedef struct lfBArray_16t { - unsigned short leaf; // LF_BARRAY_16t - CV_typ16_t utype; // type index of underlying type -} lfBArray_16t; - -typedef struct lfBArray { - unsigned short leaf; // LF_BARRAY - CV_typ_t utype; // type index of underlying type -} lfBArray; - -// type record for assembler labels - - -typedef struct lfLabel { - unsigned short leaf; // LF_LABEL - unsigned short mode; // addressing mode of label -} lfLabel; - - - -// type record for dimensioned arrays - - -typedef struct lfDimArray_16t { - unsigned short leaf; // LF_DIMARRAY_16t - CV_typ16_t utype; // underlying type of the array - CV_typ16_t diminfo; // dimension information - unsigned char name[1]; // length prefixed name -} lfDimArray_16t; - -typedef struct lfDimArray { - unsigned short leaf; // LF_DIMARRAY - CV_typ_t utype; // underlying type of the array - CV_typ_t diminfo; // dimension information - unsigned char name[1]; // length prefixed name -} lfDimArray; - - - -// type record describing path to virtual function table - - -typedef struct lfVFTPath_16t { - unsigned short leaf; // LF_VFTPATH_16t - unsigned short count; // count of number of bases in path - CV_typ16_t base[1]; // bases from root to leaf -} lfVFTPath_16t; - -typedef struct lfVFTPath { - unsigned short leaf; // LF_VFTPATH - unsigned long count; // count of number of bases in path - CV_typ_t base[1]; // bases from root to leaf -} lfVFTPath; - - -// type record describing inclusion of precompiled types - - -typedef struct lfPreComp_16t { - unsigned short leaf; // LF_PRECOMP_16t - unsigned short start; // starting type index included - unsigned short count; // number of types in inclusion - unsigned long signature; // signature - unsigned char name[CV_ZEROLEN]; // length prefixed name of included type file -} lfPreComp_16t; - -typedef struct lfPreComp { - unsigned short leaf; // LF_PRECOMP - unsigned long start; // starting type index included - unsigned long count; // number of types in inclusion - unsigned long signature; // signature - unsigned char name[CV_ZEROLEN]; // length prefixed name of included type file -} lfPreComp; - - - -// type record describing end of precompiled types that can be -// included by another file - - -typedef struct lfEndPreComp { - unsigned short leaf; // LF_ENDPRECOMP - unsigned long signature; // signature -} lfEndPreComp; - - - - - -// type record for OEM definable type strings - - -typedef struct lfOEM_16t { - unsigned short leaf; // LF_OEM_16t - unsigned short cvOEM; // MS assigned OEM identified - unsigned short recOEM; // OEM assigned type identifier - unsigned short count; // count of type indices to follow - CV_typ16_t index[CV_ZEROLEN]; // array of type indices followed - // by OEM defined data -} lfOEM_16t; - -typedef struct lfOEM { - unsigned short leaf; // LF_OEM - unsigned short cvOEM; // MS assigned OEM identified - unsigned short recOEM; // OEM assigned type identifier - unsigned long count; // count of type indices to follow - CV_typ_t index[CV_ZEROLEN]; // array of type indices followed - // by OEM defined data -} lfOEM; - -#define OEM_MS_FORTRAN90 0xF090 -#define OEM_ODI 0x0010 -#define OEM_THOMSON_SOFTWARE 0x5453 -#define OEM_ODI_REC_BASELIST 0x0000 - -typedef struct lfOEM2 { - unsigned short leaf; // LF_OEM2 - unsigned char idOem[16]; // an oem ID (GUID) - unsigned long count; // count of type indices to follow - CV_typ_t index[CV_ZEROLEN]; // array of type indices followed - // by OEM defined data -} lfOEM2; - -// type record describing using of a type server - -typedef struct lfTypeServer { - unsigned short leaf; // LF_TYPESERVER - unsigned long signature; // signature - unsigned long age; // age of database used by this module - unsigned char name[CV_ZEROLEN]; // length prefixed name of PDB -} lfTypeServer; - -// type record describing using of a type server with v7 (GUID) signatures - -typedef struct lfTypeServer2 { - unsigned short leaf; // LF_TYPESERVER2 - SIG70 sig70; // guid signature - unsigned long age; // age of database used by this module - unsigned char name[CV_ZEROLEN]; // length prefixed name of PDB -} lfTypeServer2; - -// description of type records that can be referenced from -// type records referenced by symbols - - - -// type record for skip record - - -typedef struct lfSkip_16t { - unsigned short leaf; // LF_SKIP_16t - CV_typ16_t type; // next valid index - unsigned char data[CV_ZEROLEN]; // pad data -} lfSkip_16t; - -typedef struct lfSkip { - unsigned short leaf; // LF_SKIP - CV_typ_t type; // next valid index - unsigned char data[CV_ZEROLEN]; // pad data -} lfSkip; - - - -// argument list leaf - - -typedef struct lfArgList_16t { - unsigned short leaf; // LF_ARGLIST_16t - unsigned short count; // number of arguments - CV_typ16_t arg[CV_ZEROLEN]; // number of arguments -} lfArgList_16t; - -typedef struct lfArgList { - unsigned short leaf; // LF_ARGLIST, LF_SUBSTR_LIST - unsigned long count; // number of arguments - CV_typ_t arg[CV_ZEROLEN]; // number of arguments -} lfArgList; - - - - -// derived class list leaf - - -typedef struct lfDerived_16t { - unsigned short leaf; // LF_DERIVED_16t - unsigned short count; // number of arguments - CV_typ16_t drvdcls[CV_ZEROLEN]; // type indices of derived classes -} lfDerived_16t; - -typedef struct lfDerived { - unsigned short leaf; // LF_DERIVED - unsigned long count; // number of arguments - CV_typ_t drvdcls[CV_ZEROLEN]; // type indices of derived classes -} lfDerived; - - - - -// leaf for default arguments - - -typedef struct lfDefArg_16t { - unsigned short leaf; // LF_DEFARG_16t - CV_typ16_t type; // type of resulting expression - unsigned char expr[CV_ZEROLEN]; // length prefixed expression string -} lfDefArg_16t; - -typedef struct lfDefArg { - unsigned short leaf; // LF_DEFARG - CV_typ_t type; // type of resulting expression - unsigned char expr[CV_ZEROLEN]; // length prefixed expression string -} lfDefArg; - - - -// list leaf -// This list should no longer be used because the utilities cannot -// verify the contents of the list without knowing what type of list -// it is. New specific leaf indices should be used instead. - - -typedef struct lfList { - unsigned short leaf; // LF_LIST - char data[CV_ZEROLEN]; // data format specified by indexing type -} lfList; - - - - -// field list leaf -// This is the header leaf for a complex list of class and structure -// subfields. - - -typedef struct lfFieldList_16t { - unsigned short leaf; // LF_FIELDLIST_16t - char data[CV_ZEROLEN]; // field list sub lists -} lfFieldList_16t; - - -typedef struct lfFieldList { - unsigned short leaf; // LF_FIELDLIST - char data[CV_ZEROLEN]; // field list sub lists -} lfFieldList; - - - - - - - -// type record for non-static methods and friends in overloaded method list - -typedef struct mlMethod_16t { - CV_fldattr_t attr; // method attribute - CV_typ16_t index; // index to type record for procedure - unsigned long vbaseoff[CV_ZEROLEN]; // offset in vfunctable if intro virtual -} mlMethod_16t; - -typedef struct mlMethod { - CV_fldattr_t attr; // method attribute - _2BYTEPAD pad0; // internal padding, must be 0 - CV_typ_t index; // index to type record for procedure - unsigned long vbaseoff[CV_ZEROLEN]; // offset in vfunctable if intro virtual -} mlMethod; - - -typedef struct lfMethodList_16t { - unsigned short leaf; - unsigned char mList[CV_ZEROLEN]; // really a mlMethod_16t type -} lfMethodList_16t; - -typedef struct lfMethodList { - unsigned short leaf; - unsigned char mList[CV_ZEROLEN]; // really a mlMethod type -} lfMethodList; - - - - - -// type record for LF_BITFIELD - - -typedef struct lfBitfield_16t { - unsigned short leaf; // LF_BITFIELD_16t - unsigned char length; - unsigned char position; - CV_typ16_t type; // type of bitfield - -} lfBitfield_16t; - -typedef struct lfBitfield { - unsigned short leaf; // LF_BITFIELD - CV_typ_t type; // type of bitfield - unsigned char length; - unsigned char position; - -} lfBitfield; - - - - -// type record for dimensioned array with constant bounds - - -typedef struct lfDimCon_16t { - unsigned short leaf; // LF_DIMCONU_16t or LF_DIMCONLU_16t - unsigned short rank; // number of dimensions - CV_typ16_t typ; // type of index - unsigned char dim[CV_ZEROLEN]; // array of dimension information with - // either upper bounds or lower/upper bound -} lfDimCon_16t; - -typedef struct lfDimCon { - unsigned short leaf; // LF_DIMCONU or LF_DIMCONLU - CV_typ_t typ; // type of index - unsigned short rank; // number of dimensions - unsigned char dim[CV_ZEROLEN]; // array of dimension information with - // either upper bounds or lower/upper bound -} lfDimCon; - - - - -// type record for dimensioned array with variable bounds - - -typedef struct lfDimVar_16t { - unsigned short leaf; // LF_DIMVARU_16t or LF_DIMVARLU_16t - unsigned short rank; // number of dimensions - CV_typ16_t typ; // type of index - CV_typ16_t dim[CV_ZEROLEN]; // array of type indices for either - // variable upper bound or variable - // lower/upper bound. The referenced - // types must be LF_REFSYM or T_VOID -} lfDimVar_16t; - -typedef struct lfDimVar { - unsigned short leaf; // LF_DIMVARU or LF_DIMVARLU - unsigned long rank; // number of dimensions - CV_typ_t typ; // type of index - CV_typ_t dim[CV_ZEROLEN]; // array of type indices for either - // variable upper bound or variable - // lower/upper bound. The count of type - // indices is rank or rank*2 depending on - // whether it is LFDIMVARU or LF_DIMVARLU. - // The referenced types must be - // LF_REFSYM or T_VOID -} lfDimVar; - - - - -// type record for referenced symbol - - -typedef struct lfRefSym { - unsigned short leaf; // LF_REFSYM - unsigned char Sym[1]; // copy of referenced symbol record - // (including length) -} lfRefSym; - - - -// type record for generic HLSL type - - -typedef struct lfHLSL { - unsigned short leaf; // LF_HLSL - CV_typ_t subtype; // sub-type index, if any - unsigned short kind; // kind of built-in type from CV_builtin_e - unsigned short numprops : 4; // number of numeric properties - unsigned short unused : 12; // padding, must be 0 - unsigned char data[CV_ZEROLEN]; // variable-length array of numeric properties - // followed by byte size -} lfHLSL; - - - - -// type record for a generalized built-in type modifier - - -typedef struct lfModifierEx { - unsigned short leaf; // LF_MODIFIER_EX - CV_typ_t type; // type being modified - unsigned short count; // count of modifier values - unsigned short mods[CV_ZEROLEN]; // modifiers from CV_modifier_e -} lfModifierEx; - - - - -/** the following are numeric leaves. They are used to indicate the - * size of the following variable length data. When the numeric - * data is a single byte less than 0x8000, then the data is output - * directly. If the data is more the 0x8000 or is a negative value, - * then the data is preceded by the proper index. - */ - - - -// signed character leaf - -typedef struct lfChar { - unsigned short leaf; // LF_CHAR - signed char val; // signed 8-bit value -} lfChar; - - - - -// signed short leaf - -typedef struct lfShort { - unsigned short leaf; // LF_SHORT - short val; // signed 16-bit value -} lfShort; - - - - -// unsigned short leaf - -typedef struct lfUShort { - unsigned short leaf; // LF_unsigned short - unsigned short val; // unsigned 16-bit value -} lfUShort; - - - - -// signed long leaf - -typedef struct lfLong { - unsigned short leaf; // LF_LONG - long val; // signed 32-bit value -} lfLong; - - - - -// unsigned long leaf - -typedef struct lfULong { - unsigned short leaf; // LF_ULONG - unsigned long val; // unsigned 32-bit value -} lfULong; - - - - -// signed quad leaf - -typedef struct lfQuad { - unsigned short leaf; // LF_QUAD - unsigned char val[8]; // signed 64-bit value -} lfQuad; - - - - -// unsigned quad leaf - -typedef struct lfUQuad { - unsigned short leaf; // LF_UQUAD - unsigned char val[8]; // unsigned 64-bit value -} lfUQuad; - - -// signed int128 leaf - -typedef struct lfOct { - unsigned short leaf; // LF_OCT - unsigned char val[16]; // signed 128-bit value -} lfOct; - -// unsigned int128 leaf - -typedef struct lfUOct { - unsigned short leaf; // LF_UOCT - unsigned char val[16]; // unsigned 128-bit value -} lfUOct; - - - - -// real 16-bit leaf - -typedef struct lfReal16 { - unsigned short leaf; // LF_REAL16 - unsigned short val; // 16-bit real value -} lfReal16; - - - - -// real 32-bit leaf - -typedef struct lfReal32 { - unsigned short leaf; // LF_REAL32 - float val; // 32-bit real value -} lfReal32; - - - - -// real 48-bit leaf - -typedef struct lfReal48 { - unsigned short leaf; // LF_REAL48 - unsigned char val[6]; // 48-bit real value -} lfReal48; - - - - -// real 64-bit leaf - -typedef struct lfReal64 { - unsigned short leaf; // LF_REAL64 - double val; // 64-bit real value -} lfReal64; - - - - -// real 80-bit leaf - -typedef struct lfReal80 { - unsigned short leaf; // LF_REAL80 - FLOAT10 val; // real 80-bit value -} lfReal80; - - - - -// real 128-bit leaf - -typedef struct lfReal128 { - unsigned short leaf; // LF_REAL128 - char val[16]; // real 128-bit value -} lfReal128; - - - - -// complex 32-bit leaf - -typedef struct lfCmplx32 { - unsigned short leaf; // LF_COMPLEX32 - float val_real; // real component - float val_imag; // imaginary component -} lfCmplx32; - - - - -// complex 64-bit leaf - -typedef struct lfCmplx64 { - unsigned short leaf; // LF_COMPLEX64 - double val_real; // real component - double val_imag; // imaginary component -} flCmplx64; - - - - -// complex 80-bit leaf - -typedef struct lfCmplx80 { - unsigned short leaf; // LF_COMPLEX80 - FLOAT10 val_real; // real component - FLOAT10 val_imag; // imaginary component -} lfCmplx80; - - - - -// complex 128-bit leaf - -typedef struct lfCmplx128 { - unsigned short leaf; // LF_COMPLEX128 - char val_real[16]; // real component - char val_imag[16]; // imaginary component -} lfCmplx128; - - - -// variable length numeric field - -typedef struct lfVarString { - unsigned short leaf; // LF_VARSTRING - unsigned short len; // length of value in bytes - unsigned char value[CV_ZEROLEN]; // value -} lfVarString; - -//*********************************************************************** - - -// index leaf - contains type index of another leaf -// a major use of this leaf is to allow the compilers to emit a -// long complex list (LF_FIELD) in smaller pieces. - -typedef struct lfIndex_16t { - unsigned short leaf; // LF_INDEX_16t - CV_typ16_t index; // type index of referenced leaf -} lfIndex_16t; - -typedef struct lfIndex { - unsigned short leaf; // LF_INDEX - _2BYTEPAD pad0; // internal padding, must be 0 - CV_typ_t index; // type index of referenced leaf -} lfIndex; - - -// subfield record for base class field - -typedef struct lfBClass_16t { - unsigned short leaf; // LF_BCLASS_16t - CV_typ16_t index; // type index of base class - CV_fldattr_t attr; // attribute - unsigned char offset[CV_ZEROLEN]; // variable length offset of base within class -} lfBClass_16t; - -typedef struct lfBClass { - unsigned short leaf; // LF_BCLASS, LF_BINTERFACE - CV_fldattr_t attr; // attribute - CV_typ_t index; // type index of base class - unsigned char offset[CV_ZEROLEN]; // variable length offset of base within class -} lfBClass; -typedef lfBClass lfBInterface; - - - - -// subfield record for direct and indirect virtual base class field - -typedef struct lfVBClass_16t { - unsigned short leaf; // LF_VBCLASS_16t | LV_IVBCLASS_16t - CV_typ16_t index; // type index of direct virtual base class - CV_typ16_t vbptr; // type index of virtual base pointer - CV_fldattr_t attr; // attribute - unsigned char vbpoff[CV_ZEROLEN]; // virtual base pointer offset from address point - // followed by virtual base offset from vbtable -} lfVBClass_16t; - -typedef struct lfVBClass { - unsigned short leaf; // LF_VBCLASS | LV_IVBCLASS - CV_fldattr_t attr; // attribute - CV_typ_t index; // type index of direct virtual base class - CV_typ_t vbptr; // type index of virtual base pointer - unsigned char vbpoff[CV_ZEROLEN]; // virtual base pointer offset from address point - // followed by virtual base offset from vbtable -} lfVBClass; - - - - - -// subfield record for friend class - - -typedef struct lfFriendCls_16t { - unsigned short leaf; // LF_FRIENDCLS_16t - CV_typ16_t index; // index to type record of friend class -} lfFriendCls_16t; - -typedef struct lfFriendCls { - unsigned short leaf; // LF_FRIENDCLS - _2BYTEPAD pad0; // internal padding, must be 0 - CV_typ_t index; // index to type record of friend class -} lfFriendCls; - - - - - -// subfield record for friend function - - -typedef struct lfFriendFcn_16t { - unsigned short leaf; // LF_FRIENDFCN_16t - CV_typ16_t index; // index to type record of friend function - unsigned char Name[1]; // name of friend function -} lfFriendFcn_16t; - -typedef struct lfFriendFcn { - unsigned short leaf; // LF_FRIENDFCN - _2BYTEPAD pad0; // internal padding, must be 0 - CV_typ_t index; // index to type record of friend function - unsigned char Name[1]; // name of friend function -} lfFriendFcn; - - - -// subfield record for non-static data members - -typedef struct lfMember_16t { - unsigned short leaf; // LF_MEMBER_16t - CV_typ16_t index; // index of type record for field - CV_fldattr_t attr; // attribute mask - unsigned char offset[CV_ZEROLEN]; // variable length offset of field followed - // by length prefixed name of field -} lfMember_16t; - -typedef struct lfMember { - unsigned short leaf; // LF_MEMBER - CV_fldattr_t attr; // attribute mask - CV_typ_t index; // index of type record for field - unsigned char offset[CV_ZEROLEN]; // variable length offset of field followed - // by length prefixed name of field -} lfMember; - - - -// type record for static data members - -typedef struct lfSTMember_16t { - unsigned short leaf; // LF_STMEMBER_16t - CV_typ16_t index; // index of type record for field - CV_fldattr_t attr; // attribute mask - unsigned char Name[1]; // length prefixed name of field -} lfSTMember_16t; - -typedef struct lfSTMember { - unsigned short leaf; // LF_STMEMBER - CV_fldattr_t attr; // attribute mask - CV_typ_t index; // index of type record for field - unsigned char Name[1]; // length prefixed name of field -} lfSTMember; - - - -// subfield record for virtual function table pointer - -typedef struct lfVFuncTab_16t { - unsigned short leaf; // LF_VFUNCTAB_16t - CV_typ16_t type; // type index of pointer -} lfVFuncTab_16t; - -typedef struct lfVFuncTab { - unsigned short leaf; // LF_VFUNCTAB - _2BYTEPAD pad0; // internal padding, must be 0 - CV_typ_t type; // type index of pointer -} lfVFuncTab; - - - -// subfield record for virtual function table pointer with offset - -typedef struct lfVFuncOff_16t { - unsigned short leaf; // LF_VFUNCOFF_16t - CV_typ16_t type; // type index of pointer - CV_off32_t offset; // offset of virtual function table pointer -} lfVFuncOff_16t; - -typedef struct lfVFuncOff { - unsigned short leaf; // LF_VFUNCOFF - _2BYTEPAD pad0; // internal padding, must be 0. - CV_typ_t type; // type index of pointer - CV_off32_t offset; // offset of virtual function table pointer -} lfVFuncOff; - - - -// subfield record for overloaded method list - - -typedef struct lfMethod_16t { - unsigned short leaf; // LF_METHOD_16t - unsigned short count; // number of occurrences of function - CV_typ16_t mList; // index to LF_METHODLIST record - unsigned char Name[1]; // length prefixed name of method -} lfMethod_16t; - -typedef struct lfMethod { - unsigned short leaf; // LF_METHOD - unsigned short count; // number of occurrences of function - CV_typ_t mList; // index to LF_METHODLIST record - unsigned char Name[1]; // length prefixed name of method -} lfMethod; - - - -// subfield record for nonoverloaded method - - -typedef struct lfOneMethod_16t { - unsigned short leaf; // LF_ONEMETHOD_16t - CV_fldattr_t attr; // method attribute - CV_typ16_t index; // index to type record for procedure - unsigned long vbaseoff[CV_ZEROLEN]; // offset in vfunctable if - // intro virtual followed by - // length prefixed name of method -} lfOneMethod_16t; - -typedef struct lfOneMethod { - unsigned short leaf; // LF_ONEMETHOD - CV_fldattr_t attr; // method attribute - CV_typ_t index; // index to type record for procedure - unsigned long vbaseoff[CV_ZEROLEN]; // offset in vfunctable if - // intro virtual followed by - // length prefixed name of method -} lfOneMethod; - - -// subfield record for enumerate - -typedef struct lfEnumerate { - unsigned short leaf; // LF_ENUMERATE - CV_fldattr_t attr; // access - unsigned char value[CV_ZEROLEN]; // variable length value field followed - // by length prefixed name -} lfEnumerate; - - -// type record for nested (scoped) type definition - -typedef struct lfNestType_16t { - unsigned short leaf; // LF_NESTTYPE_16t - CV_typ16_t index; // index of nested type definition - unsigned char Name[1]; // length prefixed type name -} lfNestType_16t; - -typedef struct lfNestType { - unsigned short leaf; // LF_NESTTYPE - _2BYTEPAD pad0; // internal padding, must be 0 - CV_typ_t index; // index of nested type definition - unsigned char Name[1]; // length prefixed type name -} lfNestType; - -// type record for nested (scoped) type definition, with attributes -// new records for vC v5.0, no need to have 16-bit ti versions. - -typedef struct lfNestTypeEx { - unsigned short leaf; // LF_NESTTYPEEX - CV_fldattr_t attr; // member access - CV_typ_t index; // index of nested type definition - unsigned char Name[1]; // length prefixed type name -} lfNestTypeEx; - -// type record for modifications to members - -typedef struct lfMemberModify { - unsigned short leaf; // LF_MEMBERMODIFY - CV_fldattr_t attr; // the new attributes - CV_typ_t index; // index of base class type definition - unsigned char Name[1]; // length prefixed member name -} lfMemberModify; - -// type record for pad leaf - -typedef struct lfPad { - unsigned char leaf; -} SYM_PAD; - - - -// Symbol definitions - -typedef enum SYM_ENUM_e { - S_COMPILE = 0x0001, // Compile flags symbol - S_REGISTER_16t = 0x0002, // Register variable - S_CONSTANT_16t = 0x0003, // constant symbol - S_UDT_16t = 0x0004, // User defined type - S_SSEARCH = 0x0005, // Start Search - S_END = 0x0006, // Block, procedure, "with" or thunk end - S_SKIP = 0x0007, // Reserve symbol space in $$Symbols table - S_CVRESERVE = 0x0008, // Reserved symbol for CV internal use - S_OBJNAME_ST = 0x0009, // path to object file name - S_ENDARG = 0x000a, // end of argument/return list - S_COBOLUDT_16t = 0x000b, // special UDT for cobol that does not symbol pack - S_MANYREG_16t = 0x000c, // multiple register variable - S_RETURN = 0x000d, // return description symbol - S_ENTRYTHIS = 0x000e, // description of this pointer on entry - - S_BPREL16 = 0x0100, // BP-relative - S_LDATA16 = 0x0101, // Module-local symbol - S_GDATA16 = 0x0102, // Global data symbol - S_PUB16 = 0x0103, // a public symbol - S_LPROC16 = 0x0104, // Local procedure start - S_GPROC16 = 0x0105, // Global procedure start - S_THUNK16 = 0x0106, // Thunk Start - S_BLOCK16 = 0x0107, // block start - S_WITH16 = 0x0108, // with start - S_LABEL16 = 0x0109, // code label - S_CEXMODEL16 = 0x010a, // change execution model - S_VFTABLE16 = 0x010b, // address of virtual function table - S_REGREL16 = 0x010c, // register relative address - - S_BPREL32_16t = 0x0200, // BP-relative - S_LDATA32_16t = 0x0201, // Module-local symbol - S_GDATA32_16t = 0x0202, // Global data symbol - S_PUB32_16t = 0x0203, // a public symbol (CV internal reserved) - S_LPROC32_16t = 0x0204, // Local procedure start - S_GPROC32_16t = 0x0205, // Global procedure start - S_THUNK32_ST = 0x0206, // Thunk Start - S_BLOCK32_ST = 0x0207, // block start - S_WITH32_ST = 0x0208, // with start - S_LABEL32_ST = 0x0209, // code label - S_CEXMODEL32 = 0x020a, // change execution model - S_VFTABLE32_16t = 0x020b, // address of virtual function table - S_REGREL32_16t = 0x020c, // register relative address - S_LTHREAD32_16t = 0x020d, // local thread storage - S_GTHREAD32_16t = 0x020e, // global thread storage - S_SLINK32 = 0x020f, // static link for MIPS EH implementation - - S_LPROCMIPS_16t = 0x0300, // Local procedure start - S_GPROCMIPS_16t = 0x0301, // Global procedure start - - // if these ref symbols have names following then the names are in ST format - S_PROCREF_ST = 0x0400, // Reference to a procedure - S_DATAREF_ST = 0x0401, // Reference to data - S_ALIGN = 0x0402, // Used for page alignment of symbols - - S_LPROCREF_ST = 0x0403, // Local Reference to a procedure - S_OEM = 0x0404, // OEM defined symbol - - // sym records with 32-bit types embedded instead of 16-bit - // all have 0x1000 bit set for easy identification - // only do the 32-bit target versions since we don't really - // care about 16-bit ones anymore. - S_TI16_MAX = 0x1000, - - S_REGISTER_ST = 0x1001, // Register variable - S_CONSTANT_ST = 0x1002, // constant symbol - S_UDT_ST = 0x1003, // User defined type - S_COBOLUDT_ST = 0x1004, // special UDT for cobol that does not symbol pack - S_MANYREG_ST = 0x1005, // multiple register variable - S_BPREL32_ST = 0x1006, // BP-relative - S_LDATA32_ST = 0x1007, // Module-local symbol - S_GDATA32_ST = 0x1008, // Global data symbol - S_PUB32_ST = 0x1009, // a public symbol (CV internal reserved) - S_LPROC32_ST = 0x100a, // Local procedure start - S_GPROC32_ST = 0x100b, // Global procedure start - S_VFTABLE32 = 0x100c, // address of virtual function table - S_REGREL32_ST = 0x100d, // register relative address - S_LTHREAD32_ST = 0x100e, // local thread storage - S_GTHREAD32_ST = 0x100f, // global thread storage - - S_LPROCMIPS_ST = 0x1010, // Local procedure start - S_GPROCMIPS_ST = 0x1011, // Global procedure start - - S_FRAMEPROC = 0x1012, // extra frame and proc information - S_COMPILE2_ST = 0x1013, // extended compile flags and info - - // new symbols necessary for 16-bit enumerates of IA64 registers - // and IA64 specific symbols - - S_MANYREG2_ST = 0x1014, // multiple register variable - S_LPROCIA64_ST = 0x1015, // Local procedure start (IA64) - S_GPROCIA64_ST = 0x1016, // Global procedure start (IA64) - - // Local symbols for IL - S_LOCALSLOT_ST = 0x1017, // local IL sym with field for local slot index - S_PARAMSLOT_ST = 0x1018, // local IL sym with field for parameter slot index - - S_ANNOTATION = 0x1019, // Annotation string literals - - // symbols to support managed code debugging - S_GMANPROC_ST = 0x101a, // Global proc - S_LMANPROC_ST = 0x101b, // Local proc - S_RESERVED1 = 0x101c, // reserved - S_RESERVED2 = 0x101d, // reserved - S_RESERVED3 = 0x101e, // reserved - S_RESERVED4 = 0x101f, // reserved - S_LMANDATA_ST = 0x1020, - S_GMANDATA_ST = 0x1021, - S_MANFRAMEREL_ST= 0x1022, - S_MANREGISTER_ST= 0x1023, - S_MANSLOT_ST = 0x1024, - S_MANMANYREG_ST = 0x1025, - S_MANREGREL_ST = 0x1026, - S_MANMANYREG2_ST= 0x1027, - S_MANTYPREF = 0x1028, // Index for type referenced by name from metadata - S_UNAMESPACE_ST = 0x1029, // Using namespace - - // Symbols w/ SZ name fields. All name fields contain utf8 encoded strings. - S_ST_MAX = 0x1100, // starting point for SZ name symbols - - S_OBJNAME = 0x1101, // path to object file name - S_THUNK32 = 0x1102, // Thunk Start - S_BLOCK32 = 0x1103, // block start - S_WITH32 = 0x1104, // with start - S_LABEL32 = 0x1105, // code label - S_REGISTER = 0x1106, // Register variable - S_CONSTANT = 0x1107, // constant symbol - S_UDT = 0x1108, // User defined type - S_COBOLUDT = 0x1109, // special UDT for cobol that does not symbol pack - S_MANYREG = 0x110a, // multiple register variable - S_BPREL32 = 0x110b, // BP-relative - S_LDATA32 = 0x110c, // Module-local symbol - S_GDATA32 = 0x110d, // Global data symbol - S_PUB32 = 0x110e, // a public symbol (CV internal reserved) - S_LPROC32 = 0x110f, // Local procedure start - S_GPROC32 = 0x1110, // Global procedure start - S_REGREL32 = 0x1111, // register relative address - S_LTHREAD32 = 0x1112, // local thread storage - S_GTHREAD32 = 0x1113, // global thread storage - - S_LPROCMIPS = 0x1114, // Local procedure start - S_GPROCMIPS = 0x1115, // Global procedure start - S_COMPILE2 = 0x1116, // extended compile flags and info - S_MANYREG2 = 0x1117, // multiple register variable - S_LPROCIA64 = 0x1118, // Local procedure start (IA64) - S_GPROCIA64 = 0x1119, // Global procedure start (IA64) - S_LOCALSLOT = 0x111a, // local IL sym with field for local slot index - S_SLOT = S_LOCALSLOT, // alias for LOCALSLOT - S_PARAMSLOT = 0x111b, // local IL sym with field for parameter slot index - - // symbols to support managed code debugging - S_LMANDATA = 0x111c, - S_GMANDATA = 0x111d, - S_MANFRAMEREL = 0x111e, - S_MANREGISTER = 0x111f, - S_MANSLOT = 0x1120, - S_MANMANYREG = 0x1121, - S_MANREGREL = 0x1122, - S_MANMANYREG2 = 0x1123, - S_UNAMESPACE = 0x1124, // Using namespace - - // ref symbols with name fields - S_PROCREF = 0x1125, // Reference to a procedure - S_DATAREF = 0x1126, // Reference to data - S_LPROCREF = 0x1127, // Local Reference to a procedure - S_ANNOTATIONREF = 0x1128, // Reference to an S_ANNOTATION symbol - S_TOKENREF = 0x1129, // Reference to one of the many MANPROCSYM's - - // continuation of managed symbols - S_GMANPROC = 0x112a, // Global proc - S_LMANPROC = 0x112b, // Local proc - - // short, light-weight thunks - S_TRAMPOLINE = 0x112c, // trampoline thunks - S_MANCONSTANT = 0x112d, // constants with metadata type info - - // native attributed local/parms - S_ATTR_FRAMEREL = 0x112e, // relative to virtual frame ptr - S_ATTR_REGISTER = 0x112f, // stored in a register - S_ATTR_REGREL = 0x1130, // relative to register (alternate frame ptr) - S_ATTR_MANYREG = 0x1131, // stored in >1 register - - // Separated code (from the compiler) support - S_SEPCODE = 0x1132, - - S_LOCAL_2005 = 0x1133, // defines a local symbol in optimized code - S_DEFRANGE_2005 = 0x1134, // defines a single range of addresses in which symbol can be evaluated - S_DEFRANGE2_2005 = 0x1135, // defines ranges of addresses in which symbol can be evaluated - - S_SECTION = 0x1136, // A COFF section in a PE executable - S_COFFGROUP = 0x1137, // A COFF group - S_EXPORT = 0x1138, // A export - - S_CALLSITEINFO = 0x1139, // Indirect call site information - S_FRAMECOOKIE = 0x113a, // Security cookie information - - S_DISCARDED = 0x113b, // Discarded by LINK /OPT:REF (experimental, see richards) - - S_COMPILE3 = 0x113c, // Replacement for S_COMPILE2 - S_ENVBLOCK = 0x113d, // Environment block split off from S_COMPILE2 - - S_LOCAL = 0x113e, // defines a local symbol in optimized code - S_DEFRANGE = 0x113f, // defines a single range of addresses in which symbol can be evaluated - S_DEFRANGE_SUBFIELD = 0x1140, // ranges for a subfield - - S_DEFRANGE_REGISTER = 0x1141, // ranges for en-registered symbol - S_DEFRANGE_FRAMEPOINTER_REL = 0x1142, // range for stack symbol. - S_DEFRANGE_SUBFIELD_REGISTER = 0x1143, // ranges for en-registered field of symbol - S_DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE = 0x1144, // range for stack symbol span valid full scope of function body, gap might apply. - S_DEFRANGE_REGISTER_REL = 0x1145, // range for symbol address as register + offset. - - // S_PROC symbols that reference ID instead of type - S_LPROC32_ID = 0x1146, - S_GPROC32_ID = 0x1147, - S_LPROCMIPS_ID = 0x1148, - S_GPROCMIPS_ID = 0x1149, - S_LPROCIA64_ID = 0x114a, - S_GPROCIA64_ID = 0x114b, - - S_BUILDINFO = 0x114c, // build information. - S_INLINESITE = 0x114d, // inlined function callsite. - S_INLINESITE_END = 0x114e, - S_PROC_ID_END = 0x114f, - - S_DEFRANGE_HLSL = 0x1150, - S_GDATA_HLSL = 0x1151, - S_LDATA_HLSL = 0x1152, - - S_FILESTATIC = 0x1153, - -#if defined(CC_DP_CXX) && CC_DP_CXX - - S_LOCAL_DPC_GROUPSHARED = 0x1154, // DPC groupshared variable - S_LPROC32_DPC = 0x1155, // DPC local procedure start - S_LPROC32_DPC_ID = 0x1156, - S_DEFRANGE_DPC_PTR_TAG = 0x1157, // DPC pointer tag definition range - S_DPC_SYM_TAG_MAP = 0x1158, // DPC pointer tag value to symbol record map - -#endif // CC_DP_CXX - - S_ARMSWITCHTABLE = 0x1159, - S_CALLEES = 0x115a, - S_CALLERS = 0x115b, - S_POGODATA = 0x115c, - S_INLINESITE2 = 0x115d, // extended inline site information - - S_HEAPALLOCSITE = 0x115e, // heap allocation site - - S_MOD_TYPEREF = 0x115f, // only generated at link time - - S_REF_MINIPDB = 0x1160, // only generated at link time for mini PDB - S_PDBMAP = 0x1161, // only generated at link time for mini PDB - - S_GDATA_HLSL32 = 0x1162, - S_LDATA_HLSL32 = 0x1163, - - S_GDATA_HLSL32_EX = 0x1164, - S_LDATA_HLSL32_EX = 0x1165, - - S_RECTYPE_MAX, // one greater than last - S_RECTYPE_LAST = S_RECTYPE_MAX - 1, - S_RECTYPE_PAD = S_RECTYPE_MAX + 0x100 // Used *only* to verify symbol record types so that current PDB code can potentially read - // future PDBs (assuming no format change, etc). - -} SYM_ENUM_e; - - -// enum describing compile flag ambient data model - - -typedef enum CV_CFL_DATA { - CV_CFL_DNEAR = 0x00, - CV_CFL_DFAR = 0x01, - CV_CFL_DHUGE = 0x02 -} CV_CFL_DATA; - - - - -// enum describing compile flag ambiant code model - - -typedef enum CV_CFL_CODE_e { - CV_CFL_CNEAR = 0x00, - CV_CFL_CFAR = 0x01, - CV_CFL_CHUGE = 0x02 -} CV_CFL_CODE_e; - - - - -// enum describing compile flag target floating point package - -typedef enum CV_CFL_FPKG_e { - CV_CFL_NDP = 0x00, - CV_CFL_EMU = 0x01, - CV_CFL_ALT = 0x02 -} CV_CFL_FPKG_e; - - -// enum describing function return method - - -typedef struct CV_PROCFLAGS { - union { - unsigned char bAll; - unsigned char grfAll; - struct { - unsigned char CV_PFLAG_NOFPO :1; // frame pointer present - unsigned char CV_PFLAG_INT :1; // interrupt return - unsigned char CV_PFLAG_FAR :1; // far return - unsigned char CV_PFLAG_NEVER :1; // function does not return - unsigned char CV_PFLAG_NOTREACHED:1; // label isn't fallen into - unsigned char CV_PFLAG_CUST_CALL :1; // custom calling convention - unsigned char CV_PFLAG_NOINLINE :1; // function marked as noinline - unsigned char CV_PFLAG_OPTDBGINFO:1; // function has debug information for optimized code - }; - }; -} CV_PROCFLAGS; - -// Extended proc flags -// -typedef struct CV_EXPROCFLAGS { - CV_PROCFLAGS cvpf; - union { - unsigned char grfAll; - struct { - unsigned char __reserved_byte :8; // must be zero - }; - }; -} CV_EXPROCFLAGS; - -// local variable flags -typedef struct CV_LVARFLAGS { - unsigned short fIsParam :1; // variable is a parameter - unsigned short fAddrTaken :1; // address is taken - unsigned short fCompGenx :1; // variable is compiler generated - unsigned short fIsAggregate :1; // the symbol is split in temporaries, - // which are treated by compiler as - // independent entities - unsigned short fIsAggregated :1; // Counterpart of fIsAggregate - tells - // that it is a part of a fIsAggregate symbol - unsigned short fIsAliased :1; // variable has multiple simultaneous lifetimes - unsigned short fIsAlias :1; // represents one of the multiple simultaneous lifetimes - unsigned short fIsRetValue :1; // represents a function return value - unsigned short fIsOptimizedOut :1; // variable has no lifetimes - unsigned short fIsEnregGlob :1; // variable is an enregistered global - unsigned short fIsEnregStat :1; // variable is an enregistered static - - unsigned short unused :5; // must be zero - -} CV_LVARFLAGS; - -// extended attributes common to all local variables -typedef struct CV_lvar_attr { - CV_uoff32_t off; // first code address where var is live - unsigned short seg; - CV_LVARFLAGS flags; // local var flags -} CV_lvar_attr; - -// This is max length of a lexical linear IP range. -// The upper number are reserved for seeded and flow based range - -#define CV_LEXICAL_RANGE_MAX 0xF000 - -// represents an address range, used for optimized code debug info - -typedef struct CV_LVAR_ADDR_RANGE { // defines a range of addresses - CV_uoff32_t offStart; - unsigned short isectStart; - unsigned short cbRange; -} CV_LVAR_ADDR_RANGE; - -// Represents the holes in overall address range, all address is pre-bbt. -// it is for compress and reduce the amount of relocations need. - -typedef struct CV_LVAR_ADDR_GAP { - unsigned short gapStartOffset; // relative offset from the beginning of the live range. - unsigned short cbRange; // length of this gap. -} CV_LVAR_ADDR_GAP; - -#if defined(CC_DP_CXX) && CC_DP_CXX - -// Represents a mapping from a DPC pointer tag value to the corresponding symbol record -typedef struct CV_DPC_SYM_TAG_MAP_ENTRY { - unsigned int tagValue; // address taken symbol's pointer tag value. - CV_off32_t symRecordOffset; // offset of the symbol record from the S_LPROC32_DPC record it is nested within -} CV_DPC_SYM_TAG_MAP_ENTRY; - -#endif // CC_DP_CXX - -// enum describing function data return method - -typedef enum CV_GENERIC_STYLE_e { - CV_GENERIC_VOID = 0x00, // void return type - CV_GENERIC_REG = 0x01, // return data is in registers - CV_GENERIC_ICAN = 0x02, // indirect caller allocated near - CV_GENERIC_ICAF = 0x03, // indirect caller allocated far - CV_GENERIC_IRAN = 0x04, // indirect returnee allocated near - CV_GENERIC_IRAF = 0x05, // indirect returnee allocated far - CV_GENERIC_UNUSED = 0x06 // first unused -} CV_GENERIC_STYLE_e; - - -typedef struct CV_GENERIC_FLAG { - unsigned short cstyle :1; // true push varargs right to left - unsigned short rsclean :1; // true if returnee stack cleanup - unsigned short unused :14; // unused -} CV_GENERIC_FLAG; - - -// flag bitfields for separated code attributes - -typedef struct CV_SEPCODEFLAGS { - unsigned long fIsLexicalScope : 1; // S_SEPCODE doubles as lexical scope - unsigned long fReturnsToParent : 1; // code frag returns to parent - unsigned long pad : 30; // must be zero -} CV_SEPCODEFLAGS; - -// Generic layout for symbol records - -typedef struct SYMTYPE { - unsigned short reclen; // Record length - unsigned short rectyp; // Record type - char data[CV_ZEROLEN]; -} SYMTYPE; - -__INLINE SYMTYPE *NextSym (SYMTYPE * pSym) { - return (SYMTYPE *) ((char *)pSym + pSym->reclen + sizeof(unsigned short)); -} - -// non-model specific symbol types - - - -typedef struct REGSYM_16t { - unsigned short reclen; // Record length - unsigned short rectyp; // S_REGISTER_16t - CV_typ16_t typind; // Type index - unsigned short reg; // register enumerate - unsigned char name[1]; // Length-prefixed name -} REGSYM_16t; - -typedef struct REGSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_REGISTER - CV_typ_t typind; // Type index or Metadata token - unsigned short reg; // register enumerate - unsigned char name[1]; // Length-prefixed name -} REGSYM; - -typedef struct ATTRREGSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_MANREGISTER | S_ATTR_REGISTER - CV_typ_t typind; // Type index or Metadata token - CV_lvar_attr attr; // local var attributes - unsigned short reg; // register enumerate - unsigned char name[1]; // Length-prefixed name -} ATTRREGSYM; - -typedef struct MANYREGSYM_16t { - unsigned short reclen; // Record length - unsigned short rectyp; // S_MANYREG_16t - CV_typ16_t typind; // Type index - unsigned char count; // count of number of registers - unsigned char reg[1]; // count register enumerates followed by - // length-prefixed name. Registers are - // most significant first. -} MANYREGSYM_16t; - -typedef struct MANYREGSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_MANYREG - CV_typ_t typind; // Type index or metadata token - unsigned char count; // count of number of registers - unsigned char reg[1]; // count register enumerates followed by - // length-prefixed name. Registers are - // most significant first. -} MANYREGSYM; - -typedef struct MANYREGSYM2 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_MANYREG2 - CV_typ_t typind; // Type index or metadata token - unsigned short count; // count of number of registers - unsigned short reg[1]; // count register enumerates followed by - // length-prefixed name. Registers are - // most significant first. -} MANYREGSYM2; - -typedef struct ATTRMANYREGSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_MANMANYREG - CV_typ_t typind; // Type index or metadata token - CV_lvar_attr attr; // local var attributes - unsigned char count; // count of number of registers - unsigned char reg[1]; // count register enumerates followed by - // length-prefixed name. Registers are - // most significant first. - unsigned char name[CV_ZEROLEN]; // utf-8 encoded zero terminate name -} ATTRMANYREGSYM; - -typedef struct ATTRMANYREGSYM2 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_MANMANYREG2 | S_ATTR_MANYREG - CV_typ_t typind; // Type index or metadata token - CV_lvar_attr attr; // local var attributes - unsigned short count; // count of number of registers - unsigned short reg[1]; // count register enumerates followed by - // length-prefixed name. Registers are - // most significant first. - unsigned char name[CV_ZEROLEN]; // utf-8 encoded zero terminate name -} ATTRMANYREGSYM2; - -typedef struct CONSTSYM_16t { - unsigned short reclen; // Record length - unsigned short rectyp; // S_CONSTANT_16t - CV_typ16_t typind; // Type index (containing enum if enumerate) - unsigned short value; // numeric leaf containing value - unsigned char name[CV_ZEROLEN]; // Length-prefixed name -} CONSTSYM_16t; - -typedef struct CONSTSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_CONSTANT or S_MANCONSTANT - CV_typ_t typind; // Type index (containing enum if enumerate) or metadata token - unsigned short value; // numeric leaf containing value - unsigned char name[CV_ZEROLEN]; // Length-prefixed name -} CONSTSYM; - - -typedef struct UDTSYM_16t { - unsigned short reclen; // Record length - unsigned short rectyp; // S_UDT_16t | S_COBOLUDT_16t - CV_typ16_t typind; // Type index - unsigned char name[1]; // Length-prefixed name -} UDTSYM_16t; - - -typedef struct UDTSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_UDT | S_COBOLUDT - CV_typ_t typind; // Type index - unsigned char name[1]; // Length-prefixed name -} UDTSYM; - -typedef struct MANTYPREF { - unsigned short reclen; // Record length - unsigned short rectyp; // S_MANTYPREF - CV_typ_t typind; // Type index -} MANTYPREF; - -typedef struct SEARCHSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_SSEARCH - unsigned long startsym; // offset of the procedure - unsigned short seg; // segment of symbol -} SEARCHSYM; - - -typedef struct CFLAGSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_COMPILE - unsigned char machine; // target processor - struct { - unsigned char language :8; // language index - unsigned char pcode :1; // true if pcode present - unsigned char floatprec :2; // floating precision - unsigned char floatpkg :2; // float package - unsigned char ambdata :3; // ambient data model - unsigned char ambcode :3; // ambient code model - unsigned char mode32 :1; // true if compiled 32 bit mode - unsigned char pad :4; // reserved - } flags; - unsigned char ver[1]; // Length-prefixed compiler version string -} CFLAGSYM; - - -typedef struct COMPILESYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_COMPILE2 - struct { - unsigned long iLanguage : 8; // language index - unsigned long fEC : 1; // compiled for E/C - unsigned long fNoDbgInfo : 1; // not compiled with debug info - unsigned long fLTCG : 1; // compiled with LTCG - unsigned long fNoDataAlign : 1; // compiled with -Bzalign - unsigned long fManagedPresent : 1; // managed code/data present - unsigned long fSecurityChecks : 1; // compiled with /GS - unsigned long fHotPatch : 1; // compiled with /hotpatch - unsigned long fCVTCIL : 1; // converted with CVTCIL - unsigned long fMSILModule : 1; // MSIL netmodule - unsigned long pad : 15; // reserved, must be 0 - } flags; - unsigned short machine; // target processor - unsigned short verFEMajor; // front end major version # - unsigned short verFEMinor; // front end minor version # - unsigned short verFEBuild; // front end build version # - unsigned short verMajor; // back end major version # - unsigned short verMinor; // back end minor version # - unsigned short verBuild; // back end build version # - unsigned char verSt[1]; // Length-prefixed compiler version string, followed - // by an optional block of zero terminated strings - // terminated with a double zero. -} COMPILESYM; - -typedef struct COMPILESYM3 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_COMPILE3 - struct { - unsigned long iLanguage : 8; // language index - unsigned long fEC : 1; // compiled for E/C - unsigned long fNoDbgInfo : 1; // not compiled with debug info - unsigned long fLTCG : 1; // compiled with LTCG - unsigned long fNoDataAlign : 1; // compiled with -Bzalign - unsigned long fManagedPresent : 1; // managed code/data present - unsigned long fSecurityChecks : 1; // compiled with /GS - unsigned long fHotPatch : 1; // compiled with /hotpatch - unsigned long fCVTCIL : 1; // converted with CVTCIL - unsigned long fMSILModule : 1; // MSIL netmodule - unsigned long fSdl : 1; // compiled with /sdl - unsigned long fPGO : 1; // compiled with /ltcg:pgo or pgu - unsigned long fExp : 1; // .exp module - unsigned long pad : 12; // reserved, must be 0 - } flags; - unsigned short machine; // target processor - unsigned short verFEMajor; // front end major version # - unsigned short verFEMinor; // front end minor version # - unsigned short verFEBuild; // front end build version # - unsigned short verFEQFE; // front end QFE version # - unsigned short verMajor; // back end major version # - unsigned short verMinor; // back end minor version # - unsigned short verBuild; // back end build version # - unsigned short verQFE; // back end QFE version # - char verSz[1]; // Zero terminated compiler version string -} COMPILESYM3; - -typedef struct ENVBLOCKSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_ENVBLOCK - struct { - unsigned char rev : 1; // reserved - unsigned char pad : 7; // reserved, must be 0 - } flags; - unsigned char rgsz[1]; // Sequence of zero-terminated strings -} ENVBLOCKSYM; - -typedef struct OBJNAMESYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_OBJNAME - unsigned long signature; // signature - unsigned char name[1]; // Length-prefixed name -} OBJNAMESYM; - - -typedef struct ENDARGSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_ENDARG -} ENDARGSYM; - - -typedef struct RETURNSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_RETURN - CV_GENERIC_FLAG flags; // flags - unsigned char style; // CV_GENERIC_STYLE_e return style - // followed by return method data -} RETURNSYM; - - -typedef struct ENTRYTHISSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_ENTRYTHIS - unsigned char thissym; // symbol describing this pointer on entry -} ENTRYTHISSYM; - - -// symbol types for 16:16 memory model - - -typedef struct BPRELSYM16 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_BPREL16 - CV_off16_t off; // BP-relative offset - CV_typ16_t typind; // Type index - unsigned char name[1]; // Length-prefixed name -} BPRELSYM16; - - -typedef struct DATASYM16 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_LDATA or S_GDATA - CV_uoff16_t off; // offset of symbol - unsigned short seg; // segment of symbol - CV_typ16_t typind; // Type index - unsigned char name[1]; // Length-prefixed name -} DATASYM16; -typedef DATASYM16 PUBSYM16; - - -typedef struct PROCSYM16 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_GPROC16 or S_LPROC16 - unsigned long pParent; // pointer to the parent - unsigned long pEnd; // pointer to this blocks end - unsigned long pNext; // pointer to next symbol - unsigned short len; // Proc length - unsigned short DbgStart; // Debug start offset - unsigned short DbgEnd; // Debug end offset - CV_uoff16_t off; // offset of symbol - unsigned short seg; // segment of symbol - CV_typ16_t typind; // Type index - CV_PROCFLAGS flags; // Proc flags - unsigned char name[1]; // Length-prefixed name -} PROCSYM16; - - -typedef struct THUNKSYM16 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_THUNK - unsigned long pParent; // pointer to the parent - unsigned long pEnd; // pointer to this blocks end - unsigned long pNext; // pointer to next symbol - CV_uoff16_t off; // offset of symbol - unsigned short seg; // segment of symbol - unsigned short len; // length of thunk - unsigned char ord; // THUNK_ORDINAL specifying type of thunk - unsigned char name[1]; // name of thunk - unsigned char variant[CV_ZEROLEN]; // variant portion of thunk -} THUNKSYM16; - -typedef struct LABELSYM16 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_LABEL16 - CV_uoff16_t off; // offset of symbol - unsigned short seg; // segment of symbol - CV_PROCFLAGS flags; // flags - unsigned char name[1]; // Length-prefixed name -} LABELSYM16; - - -typedef struct BLOCKSYM16 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_BLOCK16 - unsigned long pParent; // pointer to the parent - unsigned long pEnd; // pointer to this blocks end - unsigned short len; // Block length - CV_uoff16_t off; // offset of symbol - unsigned short seg; // segment of symbol - unsigned char name[1]; // Length-prefixed name -} BLOCKSYM16; - - -typedef struct WITHSYM16 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_WITH16 - unsigned long pParent; // pointer to the parent - unsigned long pEnd; // pointer to this blocks end - unsigned short len; // Block length - CV_uoff16_t off; // offset of symbol - unsigned short seg; // segment of symbol - unsigned char expr[1]; // Length-prefixed expression -} WITHSYM16; - - -typedef enum CEXM_MODEL_e { - CEXM_MDL_table = 0x00, // not executable - CEXM_MDL_jumptable = 0x01, // Compiler generated jump table - CEXM_MDL_datapad = 0x02, // Data padding for alignment - CEXM_MDL_native = 0x20, // native (actually not-pcode) - CEXM_MDL_cobol = 0x21, // cobol - CEXM_MDL_codepad = 0x22, // Code padding for alignment - CEXM_MDL_code = 0x23, // code - CEXM_MDL_sql = 0x30, // sql - CEXM_MDL_pcode = 0x40, // pcode - CEXM_MDL_pcode32Mac = 0x41, // macintosh 32 bit pcode - CEXM_MDL_pcode32MacNep = 0x42, // macintosh 32 bit pcode native entry point - CEXM_MDL_javaInt = 0x50, - CEXM_MDL_unknown = 0xff -} CEXM_MODEL_e; - -// use the correct enumerate name -#define CEXM_MDL_SQL CEXM_MDL_sql - -typedef enum CV_COBOL_e { - CV_COBOL_dontstop, - CV_COBOL_pfm, - CV_COBOL_false, - CV_COBOL_extcall -} CV_COBOL_e; - -typedef struct CEXMSYM16 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_CEXMODEL16 - CV_uoff16_t off; // offset of symbol - unsigned short seg; // segment of symbol - unsigned short model; // execution model - union { - struct { - CV_uoff16_t pcdtable; // offset to pcode function table - CV_uoff16_t pcdspi; // offset to segment pcode information - } pcode; - struct { - unsigned short subtype; // see CV_COBOL_e above - unsigned short flag; - } cobol; - }; -} CEXMSYM16; - - -typedef struct VPATHSYM16 { - unsigned short reclen; // record length - unsigned short rectyp; // S_VFTPATH16 - CV_uoff16_t off; // offset of virtual function table - unsigned short seg; // segment of virtual function table - CV_typ16_t root; // type index of the root of path - CV_typ16_t path; // type index of the path record -} VPATHSYM16; - - -typedef struct REGREL16 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_REGREL16 - CV_uoff16_t off; // offset of symbol - unsigned short reg; // register index - CV_typ16_t typind; // Type index - unsigned char name[1]; // Length-prefixed name -} REGREL16; - - -typedef struct BPRELSYM32_16t { - unsigned short reclen; // Record length - unsigned short rectyp; // S_BPREL32_16t - CV_off32_t off; // BP-relative offset - CV_typ16_t typind; // Type index - unsigned char name[1]; // Length-prefixed name -} BPRELSYM32_16t; - -typedef struct BPRELSYM32 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_BPREL32 - CV_off32_t off; // BP-relative offset - CV_typ_t typind; // Type index or Metadata token - unsigned char name[1]; // Length-prefixed name -} BPRELSYM32; - -typedef struct FRAMERELSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_MANFRAMEREL | S_ATTR_FRAMEREL - CV_off32_t off; // Frame relative offset - CV_typ_t typind; // Type index or Metadata token - CV_lvar_attr attr; // local var attributes - unsigned char name[1]; // Length-prefixed name -} FRAMERELSYM; - -typedef FRAMERELSYM ATTRFRAMERELSYM; - - -typedef struct SLOTSYM32 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_LOCALSLOT or S_PARAMSLOT - unsigned long iSlot; // slot index - CV_typ_t typind; // Type index or Metadata token - unsigned char name[1]; // Length-prefixed name -} SLOTSYM32; - -typedef struct ATTRSLOTSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_MANSLOT - unsigned long iSlot; // slot index - CV_typ_t typind; // Type index or Metadata token - CV_lvar_attr attr; // local var attributes - unsigned char name[1]; // Length-prefixed name -} ATTRSLOTSYM; - -typedef struct ANNOTATIONSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_ANNOTATION - CV_uoff32_t off; - unsigned short seg; - unsigned short csz; // Count of zero terminated annotation strings - unsigned char rgsz[1]; // Sequence of zero terminated annotation strings -} ANNOTATIONSYM; - -typedef struct DATASYM32_16t { - unsigned short reclen; // Record length - unsigned short rectyp; // S_LDATA32_16t, S_GDATA32_16t or S_PUB32_16t - CV_uoff32_t off; - unsigned short seg; - CV_typ16_t typind; // Type index - unsigned char name[1]; // Length-prefixed name -} DATASYM32_16t; -typedef DATASYM32_16t PUBSYM32_16t; - -typedef struct DATASYM32 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_LDATA32, S_GDATA32, S_LMANDATA, S_GMANDATA - CV_typ_t typind; // Type index, or Metadata token if a managed symbol - CV_uoff32_t off; - unsigned short seg; - unsigned char name[1]; // Length-prefixed name -} DATASYM32; - -typedef struct DATASYMHLSL { - unsigned short reclen; // Record length - unsigned short rectyp; // S_GDATA_HLSL, S_LDATA_HLSL - CV_typ_t typind; // Type index - unsigned short regType; // register type from CV_HLSLREG_e - unsigned short dataslot; // Base data (cbuffer, groupshared, etc.) slot - unsigned short dataoff; // Base data byte offset start - unsigned short texslot; // Texture slot start - unsigned short sampslot; // Sampler slot start - unsigned short uavslot; // UAV slot start - unsigned char name[1]; // name -} DATASYMHLSL; - -typedef struct DATASYMHLSL32 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_GDATA_HLSL32, S_LDATA_HLSL32 - CV_typ_t typind; // Type index - unsigned long dataslot; // Base data (cbuffer, groupshared, etc.) slot - unsigned long dataoff; // Base data byte offset start - unsigned long texslot; // Texture slot start - unsigned long sampslot; // Sampler slot start - unsigned long uavslot; // UAV slot start - unsigned short regType; // register type from CV_HLSLREG_e - unsigned char name[1]; // name -} DATASYMHLSL32; - -typedef struct DATASYMHLSL32_EX { - unsigned short reclen; // Record length - unsigned short rectyp; // S_GDATA_HLSL32_EX, S_LDATA_HLSL32_EX - CV_typ_t typind; // Type index - unsigned long regID; // Register index - unsigned long dataoff; // Base data byte offset start - unsigned long bindSpace; // Binding space - unsigned long bindSlot; // Lower bound in binding space - unsigned short regType; // register type from CV_HLSLREG_e - unsigned char name[1]; // name -} DATASYMHLSL32_EX; - -typedef enum CV_PUBSYMFLAGS_e - { - cvpsfNone = 0, - cvpsfCode = 0x00000001, - cvpsfFunction = 0x00000002, - cvpsfManaged = 0x00000004, - cvpsfMSIL = 0x00000008, -} CV_PUBSYMFLAGS_e; - -typedef union CV_PUBSYMFLAGS { - CV_pubsymflag_t grfFlags; - struct { - CV_pubsymflag_t fCode : 1; // set if public symbol refers to a code address - CV_pubsymflag_t fFunction : 1; // set if public symbol is a function - CV_pubsymflag_t fManaged : 1; // set if managed code (native or IL) - CV_pubsymflag_t fMSIL : 1; // set if managed IL code - CV_pubsymflag_t __unused : 28; // must be zero - }; -} CV_PUBSYMFLAGS; - -typedef struct PUBSYM32 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_PUB32 - CV_PUBSYMFLAGS pubsymflags; - CV_uoff32_t off; - unsigned short seg; - unsigned char name[1]; // Length-prefixed name -} PUBSYM32; - - -typedef struct PROCSYM32_16t { - unsigned short reclen; // Record length - unsigned short rectyp; // S_GPROC32_16t or S_LPROC32_16t - unsigned long pParent; // pointer to the parent - unsigned long pEnd; // pointer to this blocks end - unsigned long pNext; // pointer to next symbol - unsigned long len; // Proc length - unsigned long DbgStart; // Debug start offset - unsigned long DbgEnd; // Debug end offset - CV_uoff32_t off; - unsigned short seg; - CV_typ16_t typind; // Type index - CV_PROCFLAGS flags; // Proc flags - unsigned char name[1]; // Length-prefixed name -} PROCSYM32_16t; - -typedef struct PROCSYM32 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_GPROC32, S_LPROC32, S_GPROC32_ID, S_LPROC32_ID, S_LPROC32_DPC or S_LPROC32_DPC_ID - unsigned long pParent; // pointer to the parent - unsigned long pEnd; // pointer to this blocks end - unsigned long pNext; // pointer to next symbol - unsigned long len; // Proc length - unsigned long DbgStart; // Debug start offset - unsigned long DbgEnd; // Debug end offset - CV_typ_t typind; // Type index or ID - CV_uoff32_t off; - unsigned short seg; - CV_PROCFLAGS flags; // Proc flags - unsigned char name[1]; // Length-prefixed name -} PROCSYM32; - -typedef struct MANPROCSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_GMANPROC, S_LMANPROC, S_GMANPROCIA64 or S_LMANPROCIA64 - unsigned long pParent; // pointer to the parent - unsigned long pEnd; // pointer to this blocks end - unsigned long pNext; // pointer to next symbol - unsigned long len; // Proc length - unsigned long DbgStart; // Debug start offset - unsigned long DbgEnd; // Debug end offset - CV_tkn_t token; // COM+ metadata token for method - CV_uoff32_t off; - unsigned short seg; - CV_PROCFLAGS flags; // Proc flags - unsigned short retReg; // Register return value is in (may not be used for all archs) - unsigned char name[1]; // optional name field -} MANPROCSYM; - -typedef struct MANPROCSYMMIPS { - unsigned short reclen; // Record length - unsigned short rectyp; // S_GMANPROCMIPS or S_LMANPROCMIPS - unsigned long pParent; // pointer to the parent - unsigned long pEnd; // pointer to this blocks end - unsigned long pNext; // pointer to next symbol - unsigned long len; // Proc length - unsigned long DbgStart; // Debug start offset - unsigned long DbgEnd; // Debug end offset - unsigned long regSave; // int register save mask - unsigned long fpSave; // fp register save mask - CV_uoff32_t intOff; // int register save offset - CV_uoff32_t fpOff; // fp register save offset - CV_tkn_t token; // COM+ token type - CV_uoff32_t off; - unsigned short seg; - unsigned char retReg; // Register return value is in - unsigned char frameReg; // Frame pointer register - unsigned char name[1]; // optional name field -} MANPROCSYMMIPS; - -typedef struct THUNKSYM32 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_THUNK32 - unsigned long pParent; // pointer to the parent - unsigned long pEnd; // pointer to this blocks end - unsigned long pNext; // pointer to next symbol - CV_uoff32_t off; - unsigned short seg; - unsigned short len; // length of thunk - unsigned char ord; // THUNK_ORDINAL specifying type of thunk - unsigned char name[1]; // Length-prefixed name - unsigned char variant[CV_ZEROLEN]; // variant portion of thunk -} THUNKSYM32; - -typedef enum TRAMP_e { // Trampoline subtype - trampIncremental, // incremental thunks - trampBranchIsland, // Branch island thunks -} TRAMP_e; - -typedef struct TRAMPOLINESYM { // Trampoline thunk symbol - unsigned short reclen; // Record length - unsigned short rectyp; // S_TRAMPOLINE - unsigned short trampType; // trampoline sym subtype - unsigned short cbThunk; // size of the thunk - CV_uoff32_t offThunk; // offset of the thunk - CV_uoff32_t offTarget; // offset of the target of the thunk - unsigned short sectThunk; // section index of the thunk - unsigned short sectTarget; // section index of the target of the thunk -} TRAMPOLINE; - -typedef struct LABELSYM32 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_LABEL32 - CV_uoff32_t off; - unsigned short seg; - CV_PROCFLAGS flags; // flags - unsigned char name[1]; // Length-prefixed name -} LABELSYM32; - - -typedef struct BLOCKSYM32 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_BLOCK32 - unsigned long pParent; // pointer to the parent - unsigned long pEnd; // pointer to this blocks end - unsigned long len; // Block length - CV_uoff32_t off; // Offset in code segment - unsigned short seg; // segment of label - unsigned char name[1]; // Length-prefixed name -} BLOCKSYM32; - - -typedef struct WITHSYM32 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_WITH32 - unsigned long pParent; // pointer to the parent - unsigned long pEnd; // pointer to this blocks end - unsigned long len; // Block length - CV_uoff32_t off; // Offset in code segment - unsigned short seg; // segment of label - unsigned char expr[1]; // Length-prefixed expression string -} WITHSYM32; - - - -typedef struct CEXMSYM32 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_CEXMODEL32 - CV_uoff32_t off; // offset of symbol - unsigned short seg; // segment of symbol - unsigned short model; // execution model - union { - struct { - CV_uoff32_t pcdtable; // offset to pcode function table - CV_uoff32_t pcdspi; // offset to segment pcode information - } pcode; - struct { - unsigned short subtype; // see CV_COBOL_e above - unsigned short flag; - } cobol; - struct { - CV_uoff32_t calltableOff; // offset to function table - unsigned short calltableSeg; // segment of function table - } pcode32Mac; - }; -} CEXMSYM32; - - - -typedef struct VPATHSYM32_16t { - unsigned short reclen; // record length - unsigned short rectyp; // S_VFTABLE32_16t - CV_uoff32_t off; // offset of virtual function table - unsigned short seg; // segment of virtual function table - CV_typ16_t root; // type index of the root of path - CV_typ16_t path; // type index of the path record -} VPATHSYM32_16t; - -typedef struct VPATHSYM32 { - unsigned short reclen; // record length - unsigned short rectyp; // S_VFTABLE32 - CV_typ_t root; // type index of the root of path - CV_typ_t path; // type index of the path record - CV_uoff32_t off; // offset of virtual function table - unsigned short seg; // segment of virtual function table -} VPATHSYM32; - - - - - -typedef struct REGREL32_16t { - unsigned short reclen; // Record length - unsigned short rectyp; // S_REGREL32_16t - CV_uoff32_t off; // offset of symbol - unsigned short reg; // register index for symbol - CV_typ16_t typind; // Type index - unsigned char name[1]; // Length-prefixed name -} REGREL32_16t; - -typedef struct REGREL32 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_REGREL32 - CV_uoff32_t off; // offset of symbol - CV_typ_t typind; // Type index or metadata token - unsigned short reg; // register index for symbol - unsigned char name[1]; // Length-prefixed name -} REGREL32; - -typedef struct ATTRREGREL { - unsigned short reclen; // Record length - unsigned short rectyp; // S_MANREGREL | S_ATTR_REGREL - CV_uoff32_t off; // offset of symbol - CV_typ_t typind; // Type index or metadata token - unsigned short reg; // register index for symbol - CV_lvar_attr attr; // local var attributes - unsigned char name[1]; // Length-prefixed name -} ATTRREGREL; - -typedef ATTRREGREL ATTRREGRELSYM; - -typedef struct THREADSYM32_16t { - unsigned short reclen; // record length - unsigned short rectyp; // S_LTHREAD32_16t | S_GTHREAD32_16t - CV_uoff32_t off; // offset into thread storage - unsigned short seg; // segment of thread storage - CV_typ16_t typind; // type index - unsigned char name[1]; // length prefixed name -} THREADSYM32_16t; - -typedef struct THREADSYM32 { - unsigned short reclen; // record length - unsigned short rectyp; // S_LTHREAD32 | S_GTHREAD32 - CV_typ_t typind; // type index - CV_uoff32_t off; // offset into thread storage - unsigned short seg; // segment of thread storage - unsigned char name[1]; // length prefixed name -} THREADSYM32; - -typedef struct SLINK32 { - unsigned short reclen; // record length - unsigned short rectyp; // S_SLINK32 - unsigned long framesize; // frame size of parent procedure - CV_off32_t off; // signed offset where the static link was saved relative to the value of reg - unsigned short reg; -} SLINK32; - -typedef struct PROCSYMMIPS_16t { - unsigned short reclen; // Record length - unsigned short rectyp; // S_GPROCMIPS_16t or S_LPROCMIPS_16t - unsigned long pParent; // pointer to the parent - unsigned long pEnd; // pointer to this blocks end - unsigned long pNext; // pointer to next symbol - unsigned long len; // Proc length - unsigned long DbgStart; // Debug start offset - unsigned long DbgEnd; // Debug end offset - unsigned long regSave; // int register save mask - unsigned long fpSave; // fp register save mask - CV_uoff32_t intOff; // int register save offset - CV_uoff32_t fpOff; // fp register save offset - CV_uoff32_t off; // Symbol offset - unsigned short seg; // Symbol segment - CV_typ16_t typind; // Type index - unsigned char retReg; // Register return value is in - unsigned char frameReg; // Frame pointer register - unsigned char name[1]; // Length-prefixed name -} PROCSYMMIPS_16t; - -typedef struct PROCSYMMIPS { - unsigned short reclen; // Record length - unsigned short rectyp; // S_GPROCMIPS or S_LPROCMIPS - unsigned long pParent; // pointer to the parent - unsigned long pEnd; // pointer to this blocks end - unsigned long pNext; // pointer to next symbol - unsigned long len; // Proc length - unsigned long DbgStart; // Debug start offset - unsigned long DbgEnd; // Debug end offset - unsigned long regSave; // int register save mask - unsigned long fpSave; // fp register save mask - CV_uoff32_t intOff; // int register save offset - CV_uoff32_t fpOff; // fp register save offset - CV_typ_t typind; // Type index - CV_uoff32_t off; // Symbol offset - unsigned short seg; // Symbol segment - unsigned char retReg; // Register return value is in - unsigned char frameReg; // Frame pointer register - unsigned char name[1]; // Length-prefixed name -} PROCSYMMIPS; - -typedef struct PROCSYMIA64 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_GPROCIA64 or S_LPROCIA64 - unsigned long pParent; // pointer to the parent - unsigned long pEnd; // pointer to this blocks end - unsigned long pNext; // pointer to next symbol - unsigned long len; // Proc length - unsigned long DbgStart; // Debug start offset - unsigned long DbgEnd; // Debug end offset - CV_typ_t typind; // Type index - CV_uoff32_t off; // Symbol offset - unsigned short seg; // Symbol segment - unsigned short retReg; // Register return value is in - CV_PROCFLAGS flags; // Proc flags - unsigned char name[1]; // Length-prefixed name -} PROCSYMIA64; - -typedef struct REFSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_PROCREF_ST, S_DATAREF_ST, or S_LPROCREF_ST - unsigned long sumName; // SUC of the name - unsigned long ibSym; // Offset of actual symbol in $$Symbols - unsigned short imod; // Module containing the actual symbol - unsigned short usFill; // align this record -} REFSYM; - -typedef struct REFSYM2 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_PROCREF, S_DATAREF, or S_LPROCREF - unsigned long sumName; // SUC of the name - unsigned long ibSym; // Offset of actual symbol in $$Symbols - unsigned short imod; // Module containing the actual symbol - unsigned char name[1]; // hidden name made a first class member -} REFSYM2; - -typedef struct ALIGNSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_ALIGN -} ALIGNSYM; - -typedef struct OEMSYMBOL { - unsigned short reclen; // Record length - unsigned short rectyp; // S_OEM - unsigned char idOem[16]; // an oem ID (GUID) - CV_typ_t typind; // Type index - unsigned long rgl[]; // user data, force 4-byte alignment -} OEMSYMBOL; - -// generic block definition symbols -// these are similar to the equivalent 16:16 or 16:32 symbols but -// only define the length, type and linkage fields - -typedef struct PROCSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_GPROC16 or S_LPROC16 - unsigned long pParent; // pointer to the parent - unsigned long pEnd; // pointer to this blocks end - unsigned long pNext; // pointer to next symbol -} PROCSYM; - - -typedef struct THUNKSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_THUNK - unsigned long pParent; // pointer to the parent - unsigned long pEnd; // pointer to this blocks end - unsigned long pNext; // pointer to next symbol -} THUNKSYM; - -typedef struct BLOCKSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_BLOCK16 - unsigned long pParent; // pointer to the parent - unsigned long pEnd; // pointer to this blocks end -} BLOCKSYM; - - -typedef struct WITHSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_WITH16 - unsigned long pParent; // pointer to the parent - unsigned long pEnd; // pointer to this blocks end -} WITHSYM; - -typedef struct FRAMEPROCSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_FRAMEPROC - unsigned long cbFrame; // count of bytes of total frame of procedure - unsigned long cbPad; // count of bytes of padding in the frame - CV_uoff32_t offPad; // offset (relative to frame poniter) to where - // padding starts - unsigned long cbSaveRegs; // count of bytes of callee save registers - CV_uoff32_t offExHdlr; // offset of exception handler - unsigned short sectExHdlr; // section id of exception handler - - struct { - unsigned long fHasAlloca : 1; // function uses _alloca() - unsigned long fHasSetJmp : 1; // function uses setjmp() - unsigned long fHasLongJmp : 1; // function uses longjmp() - unsigned long fHasInlAsm : 1; // function uses inline asm - unsigned long fHasEH : 1; // function has EH states - unsigned long fInlSpec : 1; // function was speced as inline - unsigned long fHasSEH : 1; // function has SEH - unsigned long fNaked : 1; // function is __declspec(naked) - unsigned long fSecurityChecks : 1; // function has buffer security check introduced by /GS. - unsigned long fAsyncEH : 1; // function compiled with /EHa - unsigned long fGSNoStackOrdering : 1; // function has /GS buffer checks, but stack ordering couldn't be done - unsigned long fWasInlined : 1; // function was inlined within another function - unsigned long fGSCheck : 1; // function is __declspec(strict_gs_check) - unsigned long fSafeBuffers : 1; // function is __declspec(safebuffers) - unsigned long encodedLocalBasePointer : 2; // record function's local pointer explicitly. - unsigned long encodedParamBasePointer : 2; // record function's parameter pointer explicitly. - unsigned long fPogoOn : 1; // function was compiled with PGO/PGU - unsigned long fValidCounts : 1; // Do we have valid Pogo counts? - unsigned long fOptSpeed : 1; // Did we optimize for speed? - unsigned long fGuardCF : 1; // function contains CFG checks (and no write checks) - unsigned long fGuardCFW : 1; // function contains CFW checks and/or instrumentation - unsigned long pad : 9; // must be zero - } flags; -} FRAMEPROCSYM; - -#ifdef __cplusplus -namespace CodeViewInfo -{ -__inline unsigned short ExpandEncodedBasePointerReg(unsigned machineType, unsigned encodedFrameReg) -{ - static const unsigned short rgFramePointerRegX86[] = { - CV_REG_NONE, CV_ALLREG_VFRAME, CV_REG_EBP, CV_REG_EBX}; - static const unsigned short rgFramePointerRegX64[] = { - CV_REG_NONE, CV_AMD64_RSP, CV_AMD64_RBP, CV_AMD64_R13}; - static const unsigned short rgFramePointerRegArm[] = { - CV_REG_NONE, CV_ARM_SP, CV_ARM_R7, CV_REG_NONE}; - - if (encodedFrameReg >= 4) { - return CV_REG_NONE; - } - switch (machineType) { - case CV_CFL_8080 : - case CV_CFL_8086 : - case CV_CFL_80286 : - case CV_CFL_80386 : - case CV_CFL_80486 : - case CV_CFL_PENTIUM : - case CV_CFL_PENTIUMII : - case CV_CFL_PENTIUMIII : - return rgFramePointerRegX86[encodedFrameReg]; - case CV_CFL_AMD64 : - return rgFramePointerRegX64[encodedFrameReg]; - case CV_CFL_ARMNT : - return rgFramePointerRegArm[encodedFrameReg]; - default: - return CV_REG_NONE; - } -} -} -#endif - -typedef struct UNAMESPACE { - unsigned short reclen; // Record length - unsigned short rectyp; // S_UNAMESPACE - unsigned char name[1]; // name -} UNAMESPACE; - -typedef struct SEPCODESYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_SEPCODE - unsigned long pParent; // pointer to the parent - unsigned long pEnd; // pointer to this block's end - unsigned long length; // count of bytes of this block - CV_SEPCODEFLAGS scf; // flags - CV_uoff32_t off; // sect:off of the separated code - CV_uoff32_t offParent; // sectParent:offParent of the enclosing scope - unsigned short sect; // (proc, block, or sepcode) - unsigned short sectParent; -} SEPCODESYM; - -typedef struct BUILDINFOSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_BUILDINFO - CV_ItemId id; // CV_ItemId of Build Info. -} BUILDINFOSYM; - -typedef struct INLINESITESYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_INLINESITE - unsigned long pParent; // pointer to the inliner - unsigned long pEnd; // pointer to this block's end - CV_ItemId inlinee; // CV_ItemId of inlinee - unsigned char binaryAnnotations[CV_ZEROLEN]; // an array of compressed binary annotations. -} INLINESITESYM; - -typedef struct INLINESITESYM2 { - unsigned short reclen; // Record length - unsigned short rectyp; // S_INLINESITE2 - unsigned long pParent; // pointer to the inliner - unsigned long pEnd; // pointer to this block's end - CV_ItemId inlinee; // CV_ItemId of inlinee - unsigned long invocations; // entry count - unsigned char binaryAnnotations[CV_ZEROLEN]; // an array of compressed binary annotations. -} INLINESITESYM2; - - -// Defines a locals and it is live range, how to evaluate. -// S_DEFRANGE modifies previous local S_LOCAL, it has to consecutive. - -typedef struct LOCALSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_LOCAL - CV_typ_t typind; // type index - CV_LVARFLAGS flags; // local var flags - - unsigned char name[CV_ZEROLEN]; // Name of this symbol, a null terminated array of UTF8 characters. -} LOCALSYM; - -typedef struct FILESTATICSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_FILESTATIC - CV_typ_t typind; // type index - CV_uoff32_t modOffset; // index of mod filename in stringtable - CV_LVARFLAGS flags; // local var flags - - unsigned char name[CV_ZEROLEN]; // Name of this symbol, a null terminated array of UTF8 characters -} FILESTATICSYM; - -typedef struct DEFRANGESYM { // A live range of sub field of variable - unsigned short reclen; // Record length - unsigned short rectyp; // S_DEFRANGE - - CV_uoff32_t program; // DIA program to evaluate the value of the symbol - - CV_LVAR_ADDR_RANGE range; // Range of addresses where this program is valid - CV_LVAR_ADDR_GAP gaps[CV_ZEROLEN]; // The value is not available in following gaps. -} DEFRANGESYM; - -typedef struct DEFRANGESYMSUBFIELD { // A live range of sub field of variable. like locala.i - unsigned short reclen; // Record length - unsigned short rectyp; // S_DEFRANGE_SUBFIELD - - CV_uoff32_t program; // DIA program to evaluate the value of the symbol - - CV_uoff32_t offParent; // Offset in parent variable. - - CV_LVAR_ADDR_RANGE range; // Range of addresses where this program is valid - CV_LVAR_ADDR_GAP gaps[CV_ZEROLEN]; // The value is not available in following gaps. -} DEFRANGESYMSUBFIELD; - -typedef struct CV_RANGEATTR { - unsigned short maybe : 1; // May have no user name on one of control flow path. - unsigned short padding : 15; // Padding for future use. -} CV_RANGEATTR; - -typedef struct DEFRANGESYMREGISTER { // A live range of en-registed variable - unsigned short reclen; // Record length - unsigned short rectyp; // S_DEFRANGE_REGISTER - unsigned short reg; // Register to hold the value of the symbol - CV_RANGEATTR attr; // Attribute of the register range. - CV_LVAR_ADDR_RANGE range; // Range of addresses where this program is valid - CV_LVAR_ADDR_GAP gaps[CV_ZEROLEN]; // The value is not available in following gaps. -} DEFRANGESYMREGISTER; - -typedef struct DEFRANGESYMFRAMEPOINTERREL { // A live range of frame variable - unsigned short reclen; // Record length - unsigned short rectyp; // S_DEFRANGE_FRAMEPOINTER_REL - - CV_off32_t offFramePointer; // offset to frame pointer - - CV_LVAR_ADDR_RANGE range; // Range of addresses where this program is valid - CV_LVAR_ADDR_GAP gaps[CV_ZEROLEN]; // The value is not available in following gaps. -} DEFRANGESYMFRAMEPOINTERREL; - -typedef struct DEFRANGESYMFRAMEPOINTERREL_FULL_SCOPE { // A frame variable valid in all function scope - unsigned short reclen; // Record length - unsigned short rectyp; // S_DEFRANGE_FRAMEPOINTER_REL - - CV_off32_t offFramePointer; // offset to frame pointer -} DEFRANGESYMFRAMEPOINTERREL_FULL_SCOPE; - -#define CV_OFFSET_PARENT_LENGTH_LIMIT 12 - -// Note DEFRANGESYMREGISTERREL and DEFRANGESYMSUBFIELDREGISTER had same layout. -typedef struct DEFRANGESYMSUBFIELDREGISTER { // A live range of sub field of variable. like locala.i - unsigned short reclen; // Record length - unsigned short rectyp; // S_DEFRANGE_SUBFIELD_REGISTER - - unsigned short reg; // Register to hold the value of the symbol - CV_RANGEATTR attr; // Attribute of the register range. - CV_uoff32_t offParent : CV_OFFSET_PARENT_LENGTH_LIMIT; // Offset in parent variable. - CV_uoff32_t padding : 20; // Padding for future use. - CV_LVAR_ADDR_RANGE range; // Range of addresses where this program is valid - CV_LVAR_ADDR_GAP gaps[CV_ZEROLEN]; // The value is not available in following gaps. -} DEFRANGESYMSUBFIELDREGISTER; - -// Note DEFRANGESYMREGISTERREL and DEFRANGESYMSUBFIELDREGISTER had same layout. -// Used when /GS Copy parameter as local variable or other variable don't cover by FRAMERELATIVE. -typedef struct DEFRANGESYMREGISTERREL { // A live range of variable related to a register. - unsigned short reclen; // Record length - unsigned short rectyp; // S_DEFRANGE_REGISTER_REL - - unsigned short baseReg; // Register to hold the base pointer of the symbol - unsigned short spilledUdtMember : 1; // Spilled member for s.i. - unsigned short padding : 3; // Padding for future use. - unsigned short offsetParent : CV_OFFSET_PARENT_LENGTH_LIMIT; // Offset in parent variable. - CV_off32_t offBasePointer; // offset to register - - CV_LVAR_ADDR_RANGE range; // Range of addresses where this program is valid - CV_LVAR_ADDR_GAP gaps[CV_ZEROLEN]; // The value is not available in following gaps. -} DEFRANGESYMREGISTERREL; - -typedef struct DEFRANGESYMHLSL { // A live range of variable related to a symbol in HLSL code. - unsigned short reclen; // Record length - unsigned short rectyp; // S_DEFRANGE_HLSL or S_DEFRANGE_DPC_PTR_TAG - - unsigned short regType; // register type from CV_HLSLREG_e - - unsigned short regIndices : 2; // 0, 1 or 2, dimensionality of register space - unsigned short spilledUdtMember : 1; // this is a spilled member - unsigned short memorySpace : 4; // memory space - unsigned short padding : 9; // for future use - - unsigned short offsetParent; // Offset in parent variable. - unsigned short sizeInParent; // Size of enregistered portion - - CV_LVAR_ADDR_RANGE range; // Range of addresses where this program is valid - unsigned char data[CV_ZEROLEN]; // variable length data specifying gaps where the value is not available - // followed by multi-dimensional offset of variable location in register - // space (see CV_DEFRANGESYMHLSL_* macros below) -} DEFRANGESYMHLSL; - -#define CV_DEFRANGESYM_GAPS_COUNT(x) \ - (((x)->reclen + sizeof((x)->reclen) - sizeof(DEFRANGESYM)) / sizeof(CV_LVAR_ADDR_GAP)) - -#define CV_DEFRANGESYMSUBFIELD_GAPS_COUNT(x) \ - (((x)->reclen + sizeof((x)->reclen) - sizeof(DEFRANGESYMSUBFIELD)) / sizeof(CV_LVAR_ADDR_GAP)) - -#define CV_DEFRANGESYMHLSL_GAPS_COUNT(x) \ - (((x)->reclen + sizeof((x)->reclen) - sizeof(DEFRANGESYMHLSL) - (x)->regIndices * sizeof(CV_uoff32_t)) / sizeof(CV_LVAR_ADDR_GAP)) - -#define CV_DEFRANGESYMHLSL_GAPS_PTR_BASE(x, t) reinterpret_cast((x)->data) - -#define CV_DEFRANGESYMHLSL_GAPS_CONST_PTR(x) \ - CV_DEFRANGESYMHLSL_GAPS_PTR_BASE(x, const CV_LVAR_ADDR_GAP*) - -#define CV_DEFRANGESYMHLSL_GAPS_PTR(x) \ - CV_DEFRANGESYMHLSL_GAPS_PTR_BASE(x, CV_LVAR_ADDR_GAP*) - -#define CV_DEFRANGESYMHLSL_OFFSET_PTR_BASE(x, t) \ - reinterpret_cast(((CV_LVAR_ADDR_GAP*)(x)->data) + CV_DEFRANGESYMHLSL_GAPS_COUNT(x)) - -#define CV_DEFRANGESYMHLSL_OFFSET_CONST_PTR(x) \ - CV_DEFRANGESYMHLSL_OFFSET_PTR_BASE(x, const CV_uoff32_t*) - -#define CV_DEFRANGESYMHLSL_OFFSET_PTR(x) \ - CV_DEFRANGESYMHLSL_OFFSET_PTR_BASE(x, CV_uoff32_t*) - -#if defined(CC_DP_CXX) && CC_DP_CXX - -// Defines a local DPC group shared variable and its location. -typedef struct LOCALDPCGROUPSHAREDSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_LOCAL_DPC_GROUPSHARED - CV_typ_t typind; // type index - CV_LVARFLAGS flags; // local var flags - - unsigned short dataslot; // Base data (cbuffer, groupshared, etc.) slot - unsigned short dataoff; // Base data byte offset start - - unsigned char name[CV_ZEROLEN]; // Name of this symbol, a null terminated array of UTF8 characters. -} LOCALDPCGROUPSHAREDSYM; - -typedef struct DPCSYMTAGMAP { // A map for DPC pointer tag values to symbol records. - unsigned short reclen; // Record length - unsigned short rectyp; // S_DPC_SYM_TAG_MAP - - CV_DPC_SYM_TAG_MAP_ENTRY mapEntries[CV_ZEROLEN]; // Array of mappings from DPC pointer tag values to symbol record offsets -} DPCSYMTAGMAP; - -#define CV_DPCSYMTAGMAP_COUNT(x) \ - (((x)->reclen + sizeof((x)->reclen) - sizeof(DPCSYMTAGMAP)) / sizeof(CV_DPC_SYM_TAG_MAP_ENTRY)) - -#endif // CC_DP_CXX - -typedef enum CV_armswitchtype { - CV_SWT_INT1 = 0, - CV_SWT_UINT1 = 1, - CV_SWT_INT2 = 2, - CV_SWT_UINT2 = 3, - CV_SWT_INT4 = 4, - CV_SWT_UINT4 = 5, - CV_SWT_POINTER = 6, - CV_SWT_UINT1SHL1 = 7, - CV_SWT_UINT2SHL1 = 8, - CV_SWT_INT1SHL1 = 9, - CV_SWT_INT2SHL1 = 10, - CV_SWT_TBB = CV_SWT_UINT1SHL1, - CV_SWT_TBH = CV_SWT_UINT2SHL1, -} CV_armswitchtype; - -typedef struct FUNCTIONLIST { - unsigned short reclen; // Record length - unsigned short rectyp; // S_CALLERS or S_CALLEES - - unsigned long count; // Number of functions - CV_typ_t funcs[CV_ZEROLEN]; // List of functions, dim == count - // unsigned long invocations[CV_ZEROLEN]; Followed by a parallel array of - // invocation counts. Counts > reclen are assumed to be zero -} FUNCTIONLIST; - -typedef struct POGOINFO { - unsigned short reclen; // Record length - unsigned short rectyp; // S_POGODATA - - unsigned long invocations; // Number of times function was called - __int64 dynCount; // Dynamic instruction count - unsigned long numInstrs; // Static instruction count - unsigned long staInstLive; // Final static instruction count (post inlining) -} POGOINFO; - -typedef struct ARMSWITCHTABLE { - unsigned short reclen; // Record length - unsigned short rectyp; // S_ARMSWITCHTABLE - - CV_uoff32_t offsetBase; // Section-relative offset to the base for switch offsets - unsigned short sectBase; // Section index of the base for switch offsets - unsigned short switchType; // type of each entry - CV_uoff32_t offsetBranch; // Section-relative offset to the table branch instruction - CV_uoff32_t offsetTable; // Section-relative offset to the start of the table - unsigned short sectBranch; // Section index of the table branch instruction - unsigned short sectTable; // Section index of the table - unsigned long cEntries; // number of switch table entries -} ARMSWITCHTABLE; - -typedef struct MODTYPEREF { - unsigned short reclen; // Record length - unsigned short rectyp; // S_MOD_TYPEREF - - unsigned long fNone : 1; // module doesn't reference any type - unsigned long fRefTMPCT : 1; // reference /Z7 PCH types - unsigned long fOwnTMPCT : 1; // module contains /Z7 PCH types - unsigned long fOwnTMR : 1; // module contains type info (/Z7) - unsigned long fOwnTM : 1; // module contains type info (/Zi or /ZI) - unsigned long fRefTM : 1; // module references type info owned by other module - unsigned long reserved : 9; - - unsigned short word0; // these two words contain SN or module index depending - unsigned short word1; // on above flags -} MODTYPEREF; - -typedef struct SECTIONSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_SECTION - - unsigned short isec; // Section number - unsigned char align; // Alignment of this section (power of 2) - unsigned char bReserved; // Reserved. Must be zero. - unsigned long rva; - unsigned long cb; - unsigned long characteristics; - unsigned char name[1]; // name -} SECTIONSYM; - -typedef struct COFFGROUPSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_COFFGROUP - - unsigned long cb; - unsigned long characteristics; - CV_uoff32_t off; // Symbol offset - unsigned short seg; // Symbol segment - unsigned char name[1]; // name -} COFFGROUPSYM; - -typedef struct EXPORTSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_EXPORT - - unsigned short ordinal; - unsigned short fConstant : 1; // CONSTANT - unsigned short fData : 1; // DATA - unsigned short fPrivate : 1; // PRIVATE - unsigned short fNoName : 1; // NONAME - unsigned short fOrdinal : 1; // Ordinal was explicitly assigned - unsigned short fForwarder : 1; // This is a forwarder - unsigned short reserved : 10; // Reserved. Must be zero. - unsigned char name[1]; // name of -} EXPORTSYM; - -// -// Symbol for describing indirect calls when they are using -// a function pointer cast on some other type or temporary. -// Typical content will be an LF_POINTER to an LF_PROCEDURE -// type record that should mimic an actual variable with the -// function pointer type in question. -// -// Since the compiler can sometimes tail-merge a function call -// through a function pointer, there may be more than one -// S_CALLSITEINFO record at an address. This is similar to what -// you could do in your own code by: -// -// if (expr) -// pfn = &function1; -// else -// pfn = &function2; -// -// (*pfn)(arg list); -// - -typedef struct CALLSITEINFO { - unsigned short reclen; // Record length - unsigned short rectyp; // S_CALLSITEINFO - CV_off32_t off; // offset of call site - unsigned short sect; // section index of call site - unsigned short __reserved_0; // alignment padding field, must be zero - CV_typ_t typind; // type index describing function signature -} CALLSITEINFO; - -typedef struct HEAPALLOCSITE { - unsigned short reclen; // Record length - unsigned short rectyp; // S_HEAPALLOCSITE - CV_off32_t off; // offset of call site - unsigned short sect; // section index of call site - unsigned short cbInstr; // length of heap allocation call instruction - CV_typ_t typind; // type index describing function signature -} HEAPALLOCSITE; - -// Frame cookie information - -typedef enum CV_cookietype_e -{ - CV_COOKIETYPE_COPY = 0, - CV_COOKIETYPE_XOR_SP, - CV_COOKIETYPE_XOR_BP, - CV_COOKIETYPE_XOR_R13, -} CV_cookietype_e; - -// Symbol for describing security cookie's position and type -// (raw, xor'd with esp, xor'd with ebp). - -typedef struct FRAMECOOKIE { - unsigned short reclen; // Record length - unsigned short rectyp; // S_FRAMECOOKIE - CV_off32_t off; // Frame relative offset - unsigned short reg; // Register index - CV_cookietype_e cookietype; // Type of the cookie - unsigned char flags; // Flags describing this cookie -} FRAMECOOKIE; - -typedef enum CV_DISCARDED_e -{ - CV_DISCARDED_UNKNOWN, - CV_DISCARDED_NOT_SELECTED, - CV_DISCARDED_NOT_REFERENCED, -} CV_DISCARDED_e; - -typedef struct DISCARDEDSYM { - unsigned short reclen; // Record length - unsigned short rectyp; // S_DISCARDED - unsigned long discarded : 8; // CV_DISCARDED_e - unsigned long reserved : 24; // Unused - unsigned long fileid; // First FILEID if line number info present - unsigned long linenum; // First line number - char data[CV_ZEROLEN]; // Original record(s) with invalid type indices -} DISCARDEDSYM; - -typedef struct REFMINIPDB { - unsigned short reclen; // Record length - unsigned short rectyp; // S_REF_MINIPDB - union { - unsigned long isectCoff; // coff section - CV_typ_t typind; // type index - }; - unsigned short imod; // mod index - unsigned short fLocal : 1; // reference to local (vs. global) func or data - unsigned short fData : 1; // reference to data (vs. func) - unsigned short fUDT : 1; // reference to UDT - unsigned short fLabel : 1; // reference to label - unsigned short fConst : 1; // reference to const - unsigned short reserved : 11; // reserved, must be zero - unsigned char name[1]; // zero terminated name string -} REFMINIPDB; - -typedef struct PDBMAP { - unsigned short reclen; // Record length - unsigned short rectyp; // S_PDBMAP - unsigned char name[CV_ZEROLEN]; // zero terminated source PDB filename followed by zero - // terminated destination PDB filename, both in wchar_t -} PDBMAP; - -// -// V7 line number data types -// - -enum DEBUG_S_SUBSECTION_TYPE { - DEBUG_S_IGNORE = 0x80000000, // if this bit is set in a subsection type then ignore the subsection contents - - DEBUG_S_SYMBOLS = 0xf1, - DEBUG_S_LINES, - DEBUG_S_STRINGTABLE, - DEBUG_S_FILECHKSMS, - DEBUG_S_FRAMEDATA, - DEBUG_S_INLINEELINES, - DEBUG_S_CROSSSCOPEIMPORTS, - DEBUG_S_CROSSSCOPEEXPORTS, - - DEBUG_S_IL_LINES, - DEBUG_S_FUNC_MDTOKEN_MAP, - DEBUG_S_TYPE_MDTOKEN_MAP, - DEBUG_S_MERGED_ASSEMBLYINPUT, - - DEBUG_S_COFF_SYMBOL_RVA, -}; - -struct CV_DebugSSubsectionHeader_t { - enum DEBUG_S_SUBSECTION_TYPE type; - CV_off32_t cbLen; -}; - -struct CV_DebugSLinesHeader_t { - CV_off32_t offCon; - unsigned short segCon; - unsigned short flags; - CV_off32_t cbCon; -}; - -struct CV_DebugSLinesFileBlockHeader_t { - CV_off32_t offFile; - CV_off32_t nLines; - CV_off32_t cbBlock; - // CV_Line_t lines[nLines]; - // CV_Column_t columns[nColumns]; -}; - -// -// Line flags (data present) -// -#define CV_LINES_HAVE_COLUMNS 0x0001 - -struct CV_Line_t { - unsigned long offset; // Offset to start of code bytes for line number - unsigned long linenumStart:24; // line where statement/expression starts - unsigned long deltaLineEnd:7; // delta to line where statement ends (optional) - unsigned long fStatement:1; // true if a statement linenumber, else an expression line num -}; - -typedef unsigned short CV_columnpos_t; // byte offset in a source line - -struct CV_Column_t { - CV_columnpos_t offColumnStart; - CV_columnpos_t offColumnEnd; -}; - -struct tagFRAMEDATA { - unsigned long ulRvaStart; - unsigned long cbBlock; - unsigned long cbLocals; - unsigned long cbParams; - unsigned long cbStkMax; - unsigned long frameFunc; - unsigned short cbProlog; - unsigned short cbSavedRegs; - unsigned long fHasSEH:1; - unsigned long fHasEH:1; - unsigned long fIsFunctionStart:1; - unsigned long reserved:29; -}; - -typedef struct tagFRAMEDATA FRAMEDATA, * PFRAMEDATA; - -typedef struct tagXFIXUP_DATA { - unsigned short wType; - unsigned short wExtra; - unsigned long rva; - unsigned long rvaTarget; -} XFIXUP_DATA; - -// Those cross scope IDs are private convention, -// it used to delay the ID merging for frontend and backend even linker. -// It is transparent for DIA client. -// Use those ID will let DIA run a litter slower and but -// avoid the copy type tree in some scenarios. - -#ifdef __cplusplus -namespace CodeViewInfo -{ - -typedef struct ComboID -{ - static const unsigned int IndexBitWidth = 20; - static const unsigned int ImodBitWidth = 12; - - ComboID(unsigned short imod, unsigned int index) - { - m_comboID = (((unsigned int) imod) << IndexBitWidth) | index; - } - - ComboID(unsigned int comboID) - { - m_comboID = comboID; - } - - operator unsigned int() - { - return m_comboID; - } - - unsigned short GetModIndex() - { - return (unsigned short) (m_comboID >> IndexBitWidth); - } - - unsigned int GetIndex() - { - return (m_comboID & ((1 << IndexBitWidth) - 1)); - } - -private: - - unsigned int m_comboID; -} ComboID; - - -typedef struct CrossScopeId -{ - static const unsigned int LocalIdBitWidth = 20; - static const unsigned int IdScopeBitWidth = 11; - static const unsigned int StartCrossScopeId = - (unsigned int) (1 << (LocalIdBitWidth + IdScopeBitWidth)); - static const unsigned int LocalIdMask = (1 << LocalIdBitWidth) - 1; - static const unsigned int ScopeIdMask = StartCrossScopeId - (1 << LocalIdBitWidth); - - // Compilation unit at most reference 1M constructed type. - static const unsigned int MaxLocalId = (1 << LocalIdBitWidth) - 1; - - // Compilation unit at most reference to another 2K compilation units. - static const unsigned int MaxScopeId = (1 << IdScopeBitWidth) - 1; - - CrossScopeId(unsigned short aIdScopeId, unsigned int aLocalId) - { - crossScopeId = StartCrossScopeId - | (aIdScopeId << LocalIdBitWidth) - | aLocalId; - } - - operator unsigned int() { - return crossScopeId; - } - - unsigned int GetLocalId() { - return crossScopeId & LocalIdMask; - } - - unsigned int GetIdScopeId() { - return (crossScopeId & ScopeIdMask) >> LocalIdBitWidth; - } - - static bool IsCrossScopeId(unsigned int i) - { - return (StartCrossScopeId & i) != 0; - } - - static CrossScopeId Decode(unsigned int i) - { - CrossScopeId retval; - retval.crossScopeId = i; - return retval; - } - -private: - - CrossScopeId() {} - - unsigned int crossScopeId; - -} CrossScopeId; - -// Combined encoding of TI or FuncId, In compiler implementation -// Id prefixed by 1 if it is function ID. - -typedef struct DecoratedItemId -{ - DecoratedItemId(bool isFuncId, CV_ItemId inputId) { - if (isFuncId) { - decoratedItemId = 0x80000000 | inputId; - } else { - decoratedItemId = inputId; - } - } - - DecoratedItemId(CV_ItemId encodedId) { - decoratedItemId = encodedId; - } - - operator unsigned int() { - return decoratedItemId; - } - - bool IsFuncId() - { - return (decoratedItemId & 0x80000000) == 0x80000000; - } - - CV_ItemId GetItemId() - { - return decoratedItemId & 0x7fffffff; - } - -private: - - unsigned int decoratedItemId; - -} DecoratedItemId; - -// Compilation Unit object file path include library name -// Or compile time PDB full path - -typedef struct tagPdbIdScope { - CV_off32_t offObjectFilePath; -} PdbIdScope; - -// An array of all imports by import module. -// List all cross reference for a specific ID scope. -// Format of DEBUG_S_CROSSSCOPEIMPORTS subsection is -typedef struct tagCrossScopeReferences { - PdbIdScope externalScope; // Module of definition Scope. - unsigned int countOfCrossReferences; // Count of following array. - CV_ItemId referenceIds[CV_ZEROLEN]; // CV_ItemId in another compilation unit. -} CrossScopeReferences; - -// An array of all exports in this module. -// Format of DEBUG_S_CROSSSCOPEEXPORTS subsection is -typedef struct tagLocalIdAndGlobalIdPair { - CV_ItemId localId; // local id inside the compile time PDB scope. 0 based - CV_ItemId globalId; // global id inside the link time PDB scope, if scope are different. -} LocalIdAndGlobalIdPair; - -// Format of DEBUG_S_INLINEELINEINFO subsection -// List start source file information for an inlined function. - -#define CV_INLINEE_SOURCE_LINE_SIGNATURE 0x0 -#define CV_INLINEE_SOURCE_LINE_SIGNATURE_EX 0x1 - -typedef struct tagInlineeSourceLine { - CV_ItemId inlinee; // function id. - CV_off32_t fileId; // offset into file table DEBUG_S_FILECHKSMS - CV_off32_t sourceLineNum; // definition start line number. -} InlineeSourceLine; - -typedef struct tagInlineeSourceLineEx { - CV_ItemId inlinee; // function id - CV_off32_t fileId; // offset into file table DEBUG_S_FILECHKSMS - CV_off32_t sourceLineNum; // definition start line number - unsigned int countOfExtraFiles; - CV_off32_t extraFileId[CV_ZEROLEN]; -} InlineeSourceLineEx; - -// BinaryAnnotations ::= BinaryAnnotationInstruction+ -// BinaryAnnotationInstruction ::= BinaryAnnotationOpcode Operand+ -// -// The binary annotation mechanism supports recording a list of annotations -// in an instruction stream. The X64 unwind code and the DWARF standard have -// similar design. -// -// One annotation contains opcode and a number of 32bits operands. -// -// The initial set of annotation instructions are for line number table -// encoding only. These annotations append to S_INLINESITE record, and -// operands are unsigned except for BA_OP_ChangeLineOffset. - -enum BinaryAnnotationOpcode -{ - BA_OP_Invalid, // link time pdb contains PADDINGs - BA_OP_CodeOffset, // param : start offset - BA_OP_ChangeCodeOffsetBase, // param : nth separated code chunk (main code chunk == 0) - BA_OP_ChangeCodeOffset, // param : delta of offset - BA_OP_ChangeCodeLength, // param : length of code, default next start - BA_OP_ChangeFile, // param : fileId - BA_OP_ChangeLineOffset, // param : line offset (signed) - BA_OP_ChangeLineEndDelta, // param : how many lines, default 1 - BA_OP_ChangeRangeKind, // param : either 1 (default, for statement) - // or 0 (for expression) - - BA_OP_ChangeColumnStart, // param : start column number, 0 means no column info - BA_OP_ChangeColumnEndDelta, // param : end column number delta (signed) - - // Combo opcodes for smaller encoding size. - - BA_OP_ChangeCodeOffsetAndLineOffset, // param : ((sourceDelta << 4) | CodeDelta) - BA_OP_ChangeCodeLengthAndCodeOffset, // param : codeLength, codeOffset - - BA_OP_ChangeColumnEnd, // param : end column number -}; - -inline int BinaryAnnotationInstructionOperandCount(BinaryAnnotationOpcode op) -{ - return (op == BA_OP_ChangeCodeLengthAndCodeOffset) ? 2 : 1; -} - -/////////////////////////////////////////////////////////////////////////////// -// -// This routine a simplified variant from cor.h. -// -// Compress an unsigned integer (iLen) and store the result into pDataOut. -// -// Return value is the number of bytes that the compressed data occupies. It -// is caller's responsibilityt to ensure *pDataOut has at least 4 bytes to be -// written to. -// -// Note that this function returns -1 if iLen is too big to be compressed. -// We currently can only encode numbers no larger than 0x1FFFFFFF. -// -/////////////////////////////////////////////////////////////////////////////// - -typedef unsigned __int8 UInt8; -typedef unsigned __int32 UInt32; - -typedef UInt8 CompressedAnnotation; -typedef CompressedAnnotation* PCompressedAnnotation; - -inline UInt32 CVCompressData( - UInt32 iLen, // [IN] given uncompressed data - void * pDataOut) // [OUT] buffer for the compressed data -{ - UInt8 *pBytes = reinterpret_cast(pDataOut); - - if (iLen <= 0x7F) { - *pBytes = UInt8(iLen); - return 1; - } - - if (iLen <= 0x3FFF) { - *pBytes = UInt8((iLen >> 8) | 0x80); - *(pBytes+1) = UInt8(iLen & 0xff); - return 2; - } - - if (iLen <= 0x1FFFFFFF) { - *pBytes = UInt8((iLen >> 24) | 0xC0); - *(pBytes+1) = UInt8((iLen >> 16) & 0xff); - *(pBytes+2) = UInt8((iLen >> 8) & 0xff); - *(pBytes+3) = UInt8(iLen & 0xff); - return 4; - } - - return (UInt32) -1; -} - -/////////////////////////////////////////////////////////////////////////////// -// -// Uncompress the data in pData and store the result into pDataOut. -// -// Return value is the uncompressed unsigned integer. pData is incremented to -// point to the next piece of uncompressed data. -// -// Returns -1 if what is passed in is incorrectly compressed data, such as -// (*pBytes & 0xE0) == 0xE0. -// -/////////////////////////////////////////////////////////////////////////////// - -inline UInt32 CVUncompressData( - PCompressedAnnotation & pData) // [IN,OUT] compressed data -{ - UInt32 res = (UInt32)(-1); - - if ((*pData & 0x80) == 0x00) { - // 0??? ???? - - res = (UInt32)(*pData++); - } - else if ((*pData & 0xC0) == 0x80) { - // 10?? ???? - - res = (UInt32)((*pData++ & 0x3f) << 8); - res |= *pData++; - } - else if ((*pData & 0xE0) == 0xC0) { - // 110? ???? - - res = (*pData++ & 0x1f) << 24; - res |= *pData++ << 16; - res |= *pData++ << 8; - res |= *pData++; - } - - return res; -} - -// Encode smaller absolute numbers with smaller buffer. -// -// General compression only work for input < 0x1FFFFFFF -// algorithm will not work on 0x80000000 - -inline unsigned __int32 EncodeSignedInt32(__int32 input) -{ - unsigned __int32 rotatedInput; - - if (input >= 0) { - rotatedInput = input << 1; - } else { - rotatedInput = ((-input) << 1) | 1; - } - - return rotatedInput; -} - -inline __int32 DecodeSignedInt32(unsigned __int32 input) -{ - __int32 rotatedInput; - - if (input & 1) { - rotatedInput = - (int)(input >> 1); - } else { - rotatedInput = input >> 1; - } - - return rotatedInput; -} - -} -#endif -#pragma pack ( pop ) - -#endif /* CV_INFO_INCLUDED */ diff --git a/src/coreclr/inc/daccess.h b/src/coreclr/inc/daccess.h index 936a3195024..f61df8db9a1 100644 --- a/src/coreclr/inc/daccess.h +++ b/src/coreclr/inc/daccess.h @@ -282,9 +282,9 @@ // // extern ThreadStore* g_pThreadStore; // ThreadStore* g_pThreadStore = &StaticStore; -// class SystemDomain : public BaseDomain { +// class CodeVersionManager { // ... -// ArrayListStatic m_appDomainIndexList; +// static BOOL s_HasNonDefaultILVersions; // ... // } // @@ -304,9 +304,9 @@ // GPTR_DECL(ThreadStore, g_pThreadStore); // GPTR_IMPL_INIT(ThreadStore, g_pThreadStore, &StaticStore); // -// class SystemDomain : public BaseDomain { +// class CodeVersionManager { // ... -// SVAL_DECL(ArrayListStatic; m_appDomainIndexList); +// SVAL_DECL(BOOL, s_HasNonDefaultILVersions); // ... // } // @@ -733,6 +733,27 @@ PVOID DacAllocHostOnlyInstance(ULONG32 size, bool throwEx); // Determines whether ASSERTs should be raised when inconsistencies in the target are detected bool DacTargetConsistencyAssertsEnabled(); +// Sets whether ASSERTs should be raised when then fail. +// Returns the previous value +bool DacSetEnableDacAssertsUnconditionally(bool enable); + +class DacAssertsEnabledHolder +{ +#ifdef _DEBUG + bool m_fOldValue; +public: + DacAssertsEnabledHolder() + { + m_fOldValue = DacSetEnableDacAssertsUnconditionally(true); + } + + ~DacAssertsEnabledHolder() + { + DacSetEnableDacAssertsUnconditionally(m_fOldValue); + } +#endif // _DEBUG +}; + // Host instances can be marked as they are enumerated in // order to break cycles. This function returns true if // the instance is already marked, otherwise it marks the @@ -973,7 +994,7 @@ class __DPtrBase : public __TPtrBase __DPtrBase() = default; explicit __DPtrBase(__TPtrBase ptr) : __TPtrBase(ptr.GetAddr()) {} - + // construct const from non-const __DPtrBase(__DPtrBase::type, DPtrTemplate> const & rhs) : __DPtrBase(rhs.GetAddr()) {} @@ -2184,9 +2205,7 @@ public: name(int dummy) : base(dummy) {} // helper macro to make the vtables unique for DAC #define VPTR_UNIQUE(unique) virtual int MakeVTableUniqueForDAC() { return unique; } -#define VPTR_UNIQUE_BaseDomain (100000) -#define VPTR_UNIQUE_SystemDomain (VPTR_UNIQUE_BaseDomain + 1) -#define VPTR_UNIQUE_ComMethodFrame (VPTR_UNIQUE_SystemDomain + 1) +#define VPTR_UNIQUE_ComMethodFrame (100000) #define VPTR_UNIQUE_RedirectedThreadFrame (VPTR_UNIQUE_ComMethodFrame + 1) #define VPTR_UNIQUE_HijackFrame (VPTR_UNIQUE_RedirectedThreadFrame + 1) @@ -2298,10 +2317,10 @@ public: name(int dummy) : base(dummy) {} // pMD = dac_cast(pInstMD) // // - (D|V)PTR of one encapsulated pointer type to a (D|V)PTR of -// another type, i.e., PTR_AppDomain <-> PTR_BaseDomain -// Syntax: with PTR_AppDomain pAD, PTR_BaseDomain pBD -// dac_cast(pBD) -// dac_cast(pAD) +// another type, i.e., PTR_Module <-> PTR_ModuleBase +// Syntax: with PTR_Module pModule, PTR_Module pModuleBase +// dac_cast(pModuleBase) +// dac_cast(pModule) // // Example comparisons of some old and new syntax, where // h is a host pointer, such as "Foo *h;" @@ -2453,6 +2472,12 @@ typedef DPTR(T_RUNTIME_FUNCTION) PTR_RUNTIME_FUNCTION; #endif #endif +#ifdef DACCESS_COMPILE +#define DAC_IGNORE(x) +#else +#define DAC_IGNORE(x) x +#endif // DACCESS_COMPILE + //---------------------------------------------------------------------------- // // A PCODE is a valid PC/IP value -- a pointer to an instruction, possibly including some processor mode bits. diff --git a/src/coreclr/inc/dacprivate.h b/src/coreclr/inc/dacprivate.h index 30502963440..62821f71395 100644 --- a/src/coreclr/inc/dacprivate.h +++ b/src/coreclr/inc/dacprivate.h @@ -425,11 +425,11 @@ enum DacpAppDomainDataStage { STAGE_CLOSED }; -// Information about a BaseDomain (AppDomain, SharedDomain or SystemDomain). +// Information about an AppDomain or SystemDomain. // For types other than AppDomain, some fields (like dwID, DomainLocalBlock, etc.) will be 0/null. struct MSLAYOUT DacpAppDomainData { - // The pointer to the BaseDomain (not necessarily an AppDomain). + // The pointer to the AppDomain or SystemDomain. // It's useful to keep this around in the structure CLRDATA_ADDRESS AppDomainPtr = 0; CLRDATA_ADDRESS AppSecDesc = 0; @@ -455,7 +455,7 @@ struct MSLAYOUT DacpAssemblyData CLRDATA_ADDRESS AssemblyPtr = 0; //useful to have CLRDATA_ADDRESS ClassLoader = 0; CLRDATA_ADDRESS ParentDomain = 0; - CLRDATA_ADDRESS BaseDomainPtr = 0; + CLRDATA_ADDRESS DomainPtr = 0; CLRDATA_ADDRESS AssemblySecDesc = 0; BOOL isDynamic = FALSE; UINT ModuleCount = FALSE; @@ -463,9 +463,9 @@ struct MSLAYOUT DacpAssemblyData BOOL isDomainNeutral = FALSE; // Always false, preserved for backward compatibility DWORD dwLocationFlags = 0; - HRESULT Request(ISOSDacInterface *sos, CLRDATA_ADDRESS addr, CLRDATA_ADDRESS baseDomainPtr) + HRESULT Request(ISOSDacInterface *sos, CLRDATA_ADDRESS addr, CLRDATA_ADDRESS domainPtr) { - return sos->GetAssemblyData(baseDomainPtr, addr, this); + return sos->GetAssemblyData(domainPtr, addr, this); } HRESULT Request(ISOSDacInterface *sos, CLRDATA_ADDRESS addr) diff --git a/src/coreclr/inc/dacvars.h b/src/coreclr/inc/dacvars.h index 03995176313..b2b983f1078 100644 --- a/src/coreclr/inc/dacvars.h +++ b/src/coreclr/inc/dacvars.h @@ -175,10 +175,6 @@ DEFINE_DACVAR(UNKNOWN_POINTER_TYPE, dac__g_pBaseCOMObject, ::g_pBaseCOMObject) DEFINE_DACVAR(UNKNOWN_POINTER_TYPE, dac__g_pIDynamicInterfaceCastableInterface, ::g_pIDynamicInterfaceCastableInterface) -#ifdef FEATURE_ICASTABLE -DEFINE_DACVAR(UNKNOWN_POINTER_TYPE, dac__g_pICastableInterface, ::g_pICastableInterface) -#endif // FEATURE_ICASTABLE - DEFINE_DACVAR(UNKNOWN_POINTER_TYPE, dac__g_pObjectFinalizerMD, ::g_pObjectFinalizerMD) DEFINE_DACVAR(bool, dac__g_fProcessDetach, ::g_fProcessDetach) diff --git a/src/coreclr/inc/eventtracebase.h b/src/coreclr/inc/eventtracebase.h index 316104f649a..38868fe528f 100644 --- a/src/coreclr/inc/eventtracebase.h +++ b/src/coreclr/inc/eventtracebase.h @@ -689,7 +689,6 @@ class Module; class Assembly; class MethodDesc; class MethodTable; -class BaseDomain; class AppDomain; class SString; class CrawlFrame; @@ -750,12 +749,11 @@ namespace ETW #ifdef FEATURE_EVENT_TRACE static VOID SendThreadRundownEvent(); static VOID SendGCRundownEvent(); - static VOID IterateDomain(BaseDomain *pDomain, DWORD enumerationOptions); - static VOID IterateAppDomain(AppDomain * pAppDomain, DWORD enumerationOptions); + static VOID IterateAppDomain(DWORD enumerationOptions); static VOID IterateCollectibleLoaderAllocator(AssemblyLoaderAllocator *pLoaderAllocator, DWORD enumerationOptions); static VOID IterateAssembly(Assembly *pAssembly, DWORD enumerationOptions); static VOID IterateModule(Module *pModule, DWORD enumerationOptions); - static VOID EnumerationHelper(Module *moduleFilter, BaseDomain *domainFilter, DWORD enumerationOptions); + static VOID EnumerationHelper(Module *moduleFilter, DWORD enumerationOptions); static DWORD GetEnumerationOptionsFromRuntimeKeywords(); public: typedef union _EnumerationStructs @@ -839,7 +837,7 @@ namespace ETW static VOID SendModuleEvent(Module *pModule, DWORD dwEventOptions, BOOL bFireDomainModuleEvents=FALSE); static ULONG SendModuleRange(_In_ Module *pModule, _In_ DWORD dwEventOptions); static VOID SendAssemblyEvent(Assembly *pAssembly, DWORD dwEventOptions); - static VOID SendDomainEvent(BaseDomain *pBaseDomain, DWORD dwEventOptions, LPCWSTR wszFriendlyName=NULL); + static VOID SendDomainEvent(DWORD dwEventOptions, LPCWSTR wszFriendlyName=NULL); public: typedef union _LoaderStructs { @@ -877,23 +875,23 @@ namespace ETW }LoaderStructs; - static VOID DomainLoadReal(BaseDomain *pDomain, _In_opt_ LPWSTR wszFriendlyName=NULL); + static VOID DomainLoadReal(_In_opt_ LPWSTR wszFriendlyName=NULL); - static VOID DomainLoad(BaseDomain *pDomain, _In_opt_ LPWSTR wszFriendlyName = NULL) + static VOID DomainLoad(_In_opt_ LPWSTR wszFriendlyName = NULL) { if (ETW_PROVIDER_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER)) { - DomainLoadReal(pDomain, wszFriendlyName); + DomainLoadReal(wszFriendlyName); } } - static VOID DomainUnload(AppDomain *pDomain); + static VOID DomainUnload(); static VOID CollectibleLoaderAllocatorUnload(AssemblyLoaderAllocator *pLoaderAllocator); static VOID ModuleLoad(Module *pModule, LONG liReportedSharedModule); #else public: - static VOID DomainLoad(BaseDomain *pDomain, _In_opt_ LPWSTR wszFriendlyName=NULL) {}; - static VOID DomainUnload(AppDomain *pDomain) {}; + static VOID DomainLoad(_In_opt_ LPWSTR wszFriendlyName=NULL) {}; + static VOID DomainUnload() {}; static VOID CollectibleLoaderAllocatorUnload(AssemblyLoaderAllocator *pLoaderAllocator) {}; static VOID ModuleLoad(Module *pModule, LONG liReportedSharedModule) {}; #endif // FEATURE_EVENT_TRACE @@ -904,7 +902,7 @@ namespace ETW { friend class ETW::EnumerationLog; #ifdef FEATURE_EVENT_TRACE - static VOID SendEventsForJitMethods(BaseDomain *pDomainFilter, LoaderAllocator *pLoaderAllocatorFilter, DWORD dwEventOptions); + static VOID SendEventsForJitMethods(BOOL getCodeVersionIds, LoaderAllocator *pLoaderAllocatorFilter, DWORD dwEventOptions); static VOID SendEventsForJitMethodsHelper( LoaderAllocator *pLoaderAllocatorFilter, DWORD dwEventOptions, diff --git a/src/coreclr/inc/formattype.cpp b/src/coreclr/inc/formattype.cpp index 64d401ffb4d..af30955047a 100644 --- a/src/coreclr/inc/formattype.cpp +++ b/src/coreclr/inc/formattype.cpp @@ -694,6 +694,44 @@ PCCOR_SIGNATURE PrettyPrintType( appendStr(out, sz); break; } + case ELEMENT_TYPE_CMOD_INTERNAL : + { + // ELEMENT_TYPE_CMOD_INTERNAL + bool required = *typePtr++ != 0; + _ASSERTE(sizeof(TypeHandle) == sizeof(void *)); + TypeHandle typeHandle; + typePtr += CorSigUncompressPointer(typePtr, (void **)&typeHandle); + + MethodTable *pMT = NULL; + if (typeHandle.IsTypeDesc()) + { + pMT = typeHandle.AsTypeDesc()->GetMethodTable(); + if (pMT) + { + PrettyPrintClass(out, pMT->GetCl(), pMT->GetMDImport()); + + // It could be a "native version" of the managed type used in interop + if (typeHandle.AsTypeDesc()->IsNativeValueType()) + appendStr(out, "_NativeValueType"); + } + else + appendStr(out, "(null)"); + } + else + { + pMT = typeHandle.AsMethodTable(); + if (pMT) + PrettyPrintClass(out, pMT->GetCl(), pMT->GetMDImport()); + else + appendStr(out, "(null)"); + } + + const char fmt[] = " mod%s(/* MT: %p */)"; + char sz[Max64BitHexString + ARRAY_SIZE(fmt) + ARRAY_SIZE("req")]; + sprintf_s(sz, ARRAY_SIZE(sz), fmt, required ? "req" : "opt", pMT); + appendStr(out, sz); + break; + } #endif diff --git a/src/coreclr/inc/gcinfodumper.h b/src/coreclr/inc/gcinfodumper.h index 7b29edc1048..7802ccc3744 100644 --- a/src/coreclr/inc/gcinfodumper.h +++ b/src/coreclr/inc/gcinfodumper.h @@ -8,9 +8,10 @@ #include "gcinfodecoder.h" // ***************************************************************************** -// WARNING!!!: These values and code are also used by SOS in the diagnostics -// repo. Should updated in a backwards and forwards compatible way. +// WARNING!!!: These values and code are used in the runtime repo and SOS in the +// diagnostics repo. Should updated in a backwards and forwards compatible way. // See: https://github.com/dotnet/diagnostics/blob/main/src/shared/inc/gcinfodumper.h +// https://github.com/dotnet/runtime/blob/main/src/coreclr/inc/gcinfodumper.h // ***************************************************************************** // diff --git a/src/coreclr/inc/gcinfotypes.h b/src/coreclr/inc/gcinfotypes.h index 7457063d47e..b770bb1bbcf 100644 --- a/src/coreclr/inc/gcinfotypes.h +++ b/src/coreclr/inc/gcinfotypes.h @@ -14,9 +14,10 @@ #endif // _MSC_VER // ***************************************************************************** -// WARNING!!!: These values and code are also used by SOS in the diagnostics -// repo. Should updated in a backwards and forwards compatible way. +// WARNING!!!: These values and code are used in the runtime repo and SOS in the +// diagnostics repo. Should updated in a backwards and forwards compatible way. // See: https://github.com/dotnet/diagnostics/blob/main/src/shared/inc/gcinfotypes.h +// https://github.com/dotnet/runtime/blob/main/src/coreclr/inc/gcinfotypes.h // ***************************************************************************** #define PARTIALLY_INTERRUPTIBLE_GC_SUPPORTED diff --git a/src/coreclr/inc/gcmsg.inl b/src/coreclr/inc/gcmsg.inl index 4171b7e8fa9..d2461a3cdbf 100644 --- a/src/coreclr/inc/gcmsg.inl +++ b/src/coreclr/inc/gcmsg.inl @@ -44,13 +44,13 @@ static const char* gcDetailedStartMsg() { STATIC_CONTRACT_LEAF; - return "*GC* %d(gen0:%d)(%d)(alloc: %zd)(%s)(%d)(%d)"; + return "*GC* %d(gen0:%d)(%d)(alloced for %.3fms, g0 %zd (b: %zd, %zd/h) (%.3fmb/ms), g3 %zd (%.3fmb/ms), g4 %zd (%.3fmb/ms))(%s)(%d)(%d)(heap size: %.3fmb max: %.3fmb)"; } static const char* gcDetailedEndMsg() { STATIC_CONTRACT_LEAF; - return "*EGC* %zd(gen0:%zd)(%zd)(%d)(%s)(%s)(%s)(ml: %d->%d)\n"; + return "*EGC* %zd(gen0:%zd)(heap size: %.3fmb)(%d)(%s)(%s)(%s)(ml: %d->%d)\n"; } static const char* gcStartMarkMsg() diff --git a/src/coreclr/inc/holder.h b/src/coreclr/inc/holder.h index 6e5532a67de..353d7f39d50 100644 --- a/src/coreclr/inc/holder.h +++ b/src/coreclr/inc/holder.h @@ -909,8 +909,10 @@ FORCEINLINE void DoTheRelease(TYPE *value) template using DoNothingHolder = SpecializedWrapper<_TYPE, DoNothing<_TYPE*>>; +#ifndef SOS_INCLUDE template using ReleaseHolder = SpecializedWrapper<_TYPE, DoTheRelease<_TYPE>>; +#endif // SOS_INCLUDE template using NonVMComHolder = SpecializedWrapper<_TYPE, DoTheRelease<_TYPE>>; diff --git a/src/coreclr/inc/icorjitinfoimpl_generated.h b/src/coreclr/inc/icorjitinfoimpl_generated.h index d652f262ab8..ffc4659cb9f 100644 --- a/src/coreclr/inc/icorjitinfoimpl_generated.h +++ b/src/coreclr/inc/icorjitinfoimpl_generated.h @@ -193,15 +193,9 @@ bool isValueClass( uint32_t getClassAttribs( CORINFO_CLASS_HANDLE cls) override; -CORINFO_MODULE_HANDLE getClassModule( +const char* getClassAssemblyName( CORINFO_CLASS_HANDLE cls) override; -CORINFO_ASSEMBLY_HANDLE getModuleAssembly( - CORINFO_MODULE_HANDLE mod) override; - -const char* getAssemblyName( - CORINFO_ASSEMBLY_HANDLE assem) override; - void* LongLifetimeMalloc( size_t sz) override; @@ -395,7 +389,7 @@ CORINFO_CLASS_HANDLE getFieldClass( CorInfoType getFieldType( CORINFO_FIELD_HANDLE field, CORINFO_CLASS_HANDLE* structType, - CORINFO_CLASS_HANDLE memberParent) override; + CORINFO_CLASS_HANDLE fieldOwnerHint) override; unsigned getFieldOffset( CORINFO_FIELD_HANDLE field) override; @@ -742,6 +736,9 @@ uint32_t getJitFlags( CORJIT_FLAGS* flags, uint32_t sizeInBytes) override; +CORINFO_METHOD_HANDLE getSpecialCopyHelper( + CORINFO_CLASS_HANDLE type) override; + /**********************************************************************************/ // clang-format on /**********************************************************************************/ diff --git a/src/coreclr/inc/jiteeversionguid.h b/src/coreclr/inc/jiteeversionguid.h index 4af8e1a8052..bce13e8aabc 100644 --- a/src/coreclr/inc/jiteeversionguid.h +++ b/src/coreclr/inc/jiteeversionguid.h @@ -43,11 +43,11 @@ typedef const GUID *LPCGUID; #define GUID_DEFINED #endif // !GUID_DEFINED -constexpr GUID JITEEVersionIdentifier = { /* f43f9022-8795-4791-ba55-c450d76cfeb9 */ - 0xf43f9022, - 0x8795, - 0x4791, - {0xba, 0x55, 0xc4, 0x50, 0xd7, 0x6c, 0xfe, 0xb9} +constexpr GUID JITEEVersionIdentifier = { /* b75a5475-ff22-4078-9551-2024ce03d383 */ + 0xb75a5475, + 0xff22, + 0x4078, + {0x95, 0x51, 0x20, 0x24, 0xce, 0x03, 0xd3, 0x83} }; ////////////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/coreclr/inc/jithelpers.h b/src/coreclr/inc/jithelpers.h index d9be15c66d4..c23b0807e68 100644 --- a/src/coreclr/inc/jithelpers.h +++ b/src/coreclr/inc/jithelpers.h @@ -119,12 +119,12 @@ DYNAMICJITHELPER(CORINFO_HELP_THROW, IL_Throw, METHOD__NIL) DYNAMICJITHELPER(CORINFO_HELP_RETHROW, IL_Rethrow, METHOD__NIL) JITHELPER(CORINFO_HELP_USER_BREAKPOINT, JIT_UserBreakpoint, METHOD__NIL) - DYNAMICJITHELPER(CORINFO_HELP_RNGCHKFAIL, NULL, METHOD__THROWHELPER__THROWINDEXOUTOFRANGEEXCEPTION) - DYNAMICJITHELPER(CORINFO_HELP_OVERFLOW, NULL, METHOD__THROWHELPER__THROWOVERFLOWEXCEPTION) - DYNAMICJITHELPER(CORINFO_HELP_THROWDIVZERO, NULL, METHOD__THROWHELPER__THROWDIVIDEBYZEROEXCEPTION) - DYNAMICJITHELPER(CORINFO_HELP_THROWNULLREF, NULL, METHOD__THROWHELPER__THROWNULLREFEXCEPTION) + DYNAMICJITHELPER(CORINFO_HELP_RNGCHKFAIL, NULL, METHOD__THROWHELPERS__THROWINDEXOUTOFRANGEEXCEPTION) + DYNAMICJITHELPER(CORINFO_HELP_OVERFLOW, NULL, METHOD__THROWHELPERS__THROWOVERFLOWEXCEPTION) + DYNAMICJITHELPER(CORINFO_HELP_THROWDIVZERO, NULL, METHOD__THROWHELPERS__THROWDIVIDEBYZEROEXCEPTION) + DYNAMICJITHELPER(CORINFO_HELP_THROWNULLREF, NULL, METHOD__THROWHELPERS__THROWNULLREFEXCEPTION) JITHELPER(CORINFO_HELP_THROWMISALIGN, NULL, METHOD__NIL) - DYNAMICJITHELPER(CORINFO_HELP_VERIFICATION, NULL, METHOD__THROWHELPER__THROWVERIFICATIONEXCEPTION) + DYNAMICJITHELPER(CORINFO_HELP_VERIFICATION, NULL, METHOD__THROWHELPERS__THROWVERIFICATIONEXCEPTION) JITHELPER(CORINFO_HELP_FAIL_FAST, JIT_FailFast, METHOD__NIL) JITHELPER(CORINFO_HELP_METHOD_ACCESS_EXCEPTION,JIT_ThrowMethodAccessException, METHOD__NIL) JITHELPER(CORINFO_HELP_FIELD_ACCESS_EXCEPTION,JIT_ThrowFieldAccessException, METHOD__NIL) @@ -200,8 +200,6 @@ DYNAMICJITHELPER(CORINFO_HELP_PROF_FCN_TAILCALL, JIT_ProfilerEnterLeaveTailcallStub, METHOD__NIL) // Miscellaneous - JITHELPER(CORINFO_HELP_BBT_FCN_ENTER, JIT_LogMethodEnter,METHOD__NIL) - JITHELPER(CORINFO_HELP_PINVOKE_CALLI, GenericPInvokeCalliHelper, METHOD__NIL) #if defined(TARGET_X86) && !defined(UNIX_X86_ABI) @@ -225,9 +223,7 @@ // Generics JITHELPER(CORINFO_HELP_RUNTIMEHANDLE_METHOD, JIT_GenericHandleMethod, METHOD__NIL) - JITHELPER(CORINFO_HELP_RUNTIMEHANDLE_METHOD_LOG,JIT_GenericHandleMethodLogging, METHOD__NIL) JITHELPER(CORINFO_HELP_RUNTIMEHANDLE_CLASS, JIT_GenericHandleClass, METHOD__NIL) - JITHELPER(CORINFO_HELP_RUNTIMEHANDLE_CLASS_LOG, JIT_GenericHandleClassLogging, METHOD__NIL) JITHELPER(CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE, JIT_GetRuntimeType, METHOD__NIL) JITHELPER(CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE_MAYBENULL, JIT_GetRuntimeType_MaybeNull, METHOD__NIL) JITHELPER(CORINFO_HELP_METHODDESC_TO_STUBRUNTIMEMETHOD, JIT_GetRuntimeMethodStub,METHOD__NIL) @@ -292,13 +288,13 @@ JITHELPER(CORINFO_HELP_LOOP_CLONE_CHOICE_ADDR, JIT_LoopCloneChoiceAddr, METHOD__NIL) JITHELPER(CORINFO_HELP_DEBUG_LOG_LOOP_CLONING, JIT_DebugLogLoopCloning, METHOD__NIL) - DYNAMICJITHELPER(CORINFO_HELP_THROW_ARGUMENTEXCEPTION, NULL, METHOD__THROWHELPER__THROWARGUMENTEXCEPTION) - DYNAMICJITHELPER(CORINFO_HELP_THROW_ARGUMENTOUTOFRANGEEXCEPTION, NULL, METHOD__THROWHELPER__THROWARGUMENTOUTOFRANGEEXCEPTION) - DYNAMICJITHELPER(CORINFO_HELP_THROW_NOT_IMPLEMENTED, NULL, METHOD__THROWHELPER__THROWNOTIMPLEMENTEDEXCEPTION) - DYNAMICJITHELPER(CORINFO_HELP_THROW_PLATFORM_NOT_SUPPORTED, NULL, METHOD__THROWHELPER__THROWPLATFORMNOTSUPPORTEDEXCEPTION) - DYNAMICJITHELPER(CORINFO_HELP_THROW_TYPE_NOT_SUPPORTED, NULL, METHOD__THROWHELPER__THROWTYPENOTSUPPORTED) - DYNAMICJITHELPER(CORINFO_HELP_THROW_AMBIGUOUS_RESOLUTION_EXCEPTION, NULL, METHOD__THROWHELPER__THROWAMBIGUOUSRESOLUTIONEXCEPTION) - DYNAMICJITHELPER(CORINFO_HELP_THROW_ENTRYPOINT_NOT_FOUND_EXCEPTION, NULL, METHOD__THROWHELPER__THROWENTRYPOINTNOTFOUNDEXCEPTION) + DYNAMICJITHELPER(CORINFO_HELP_THROW_ARGUMENTEXCEPTION, NULL, METHOD__THROWHELPERS__THROWARGUMENTEXCEPTION) + DYNAMICJITHELPER(CORINFO_HELP_THROW_ARGUMENTOUTOFRANGEEXCEPTION, NULL, METHOD__THROWHELPERS__THROWARGUMENTOUTOFRANGEEXCEPTION) + DYNAMICJITHELPER(CORINFO_HELP_THROW_NOT_IMPLEMENTED, NULL, METHOD__THROWHELPERS__THROWNOTIMPLEMENTEDEXCEPTION) + DYNAMICJITHELPER(CORINFO_HELP_THROW_PLATFORM_NOT_SUPPORTED, NULL, METHOD__THROWHELPERS__THROWPLATFORMNOTSUPPORTEDEXCEPTION) + DYNAMICJITHELPER(CORINFO_HELP_THROW_TYPE_NOT_SUPPORTED, NULL, METHOD__THROWHELPERS__THROWTYPENOTSUPPORTED) + DYNAMICJITHELPER(CORINFO_HELP_THROW_AMBIGUOUS_RESOLUTION_EXCEPTION, NULL, METHOD__THROWHELPERS__THROWAMBIGUOUSRESOLUTIONEXCEPTION) + DYNAMICJITHELPER(CORINFO_HELP_THROW_ENTRYPOINT_NOT_FOUND_EXCEPTION, NULL, METHOD__THROWHELPERS__THROWENTRYPOINTNOTFOUNDEXCEPTION) JITHELPER(CORINFO_HELP_JIT_PINVOKE_BEGIN, JIT_PInvokeBegin, METHOD__NIL) JITHELPER(CORINFO_HELP_JIT_PINVOKE_END, JIT_PInvokeEnd, METHOD__NIL) diff --git a/src/coreclr/inc/metahost.idl b/src/coreclr/inc/metahost.idl index 5bc51f6d133..27c6e9a5cda 100644 --- a/src/coreclr/inc/metahost.idl +++ b/src/coreclr/inc/metahost.idl @@ -60,6 +60,9 @@ cpp_quote("EXTERN_GUID(IID_ICLRDebuggingLibraryProvider, 0x3151c08d, 0x4d09, 0x4 // IID ICLRDebuggingLibraryProvider2 interface : uuid{E04E2FF1-DCFD-45D5-BCD1-16FFF2FAF7BA} cpp_quote("EXTERN_GUID(IID_ICLRDebuggingLibraryProvider2, 0xE04E2FF1, 0xDCFD, 0x45D5, 0xBC, 0xD1, 0x16, 0xFF, 0xF2, 0xFA, 0xF7, 0xBA);") +// IID ICLRDebuggingLibraryProvider3 interface : uuid{DE3AAB18-46A0-48B4-BF0D-2C336E69EA1B} +cpp_quote("EXTERN_GUID(IID_ICLRDebuggingLibraryProvider3, 0xde3aab18, 0x46a0, 0x48b4, 0xbf, 0xd, 0x2c, 0x33, 0x6e, 0x69, 0xea, 0x1b);") + // For use in ICLRMetaHost::RequestRuntimeLoadedNotification interface ICLRRuntimeInfo; @@ -71,6 +74,13 @@ typedef void (__stdcall *RuntimeLoadedCallbackFnPtr)( CallbackThreadSetFnPtr pfnCallbackThreadSet, CallbackThreadUnsetFnPtr pfnCallbackThreadUnset); +typedef enum +{ + UnknownIndex = 0, + Identity = 1, + Runtime = 2, +} LIBRARY_PROVIDER_INDEX_TYPE; + /************************************************************************************** ** ICLRMetaHost ** ** Activated using mscoree!CLRCreateInstance. Does not do any policy decisions, get ** @@ -290,6 +300,104 @@ interface ICLRDebuggingLibraryProvider2 : IUnknown [out] LPWSTR* ppResolvedModulePath); } + /************************************************************************************** + ** ICLRDebuggingLibraryProvider3 ** + ** Implemented by API user ** + ** This interface allows the debugger to provide module paths which are needed for ** + ** debugging a particular CLR such as mscordbi and mscordacwks. ** + **************************************************************************************/ +[ + uuid(DE3AAB18-46A0-48B4-BF0D-2C336E69EA1B), + version(1.0), + helpstring("CLR debugging LibraryProvider callback interface"), + local +] +interface ICLRDebuggingLibraryProvider3 : IUnknown +{ + /********************************************************************************** + ** The goal of this method is to allow the debugger to provide a module path ** + ** which is needed for debugging. The debugger may use any available means to ** + ** locate and/or procure the module. See the security note below for important ** + ** information about implementing this method securely. ** + ** Arguments: ** + ** pwzFileName - The name of the module being requested ** + ** ** + ** pwszRuntimeModule - The runtime module path or the module path of the ** + ** single-file app. NULL when called from the ** + ** OpenVirtualProcess API. ** + ** ** + ** indexType - The type of time stamp/file size is either the identity of the ** + ** requested module or the runtime (coreclr) module's. ** + ** ** + ** dwTimeStamp - The date time stamp stored in the COFF file header of PE files ** + ** ** + ** dwSizeOfImage - The SizeOfImage field stored in the COFF optional file header ** + ** of PE files ** + ** ** + ** ppResolvedModulePath - Where *ppResolvedModulePath is a null terminated ** + ** path to the module dll. On Windows it should be ** + ** allocated with CoTaskMemAlloc. On Unix it should be ** + ** allocated with malloc. Failure leave it untouched. See ** + ** security note below! ** + ** ** + ** Return value - S_OK if the module was provided, or any other convenient ** + ** error HRESULT if the module could not be provided ** + ** ** + ** !!!!!!!!!!!!!! ** + ** SECURITY NOTE: Anything the caller would not be willing to execute itself, it ** + ** should not provide to the this API call ** + ***********************************************************************************/ + HRESULT ProvideWindowsLibrary( + [in] const WCHAR* pwszFileName, + [in] const WCHAR* pwszRuntimeModule, + [in] LIBRARY_PROVIDER_INDEX_TYPE indexType, + [in] DWORD dwTimestamp, + [in] DWORD dwSizeOfImage, + [out] LPWSTR* ppResolvedModulePath); + + /********************************************************************************** + ** The goal of this method is to allow the debugger to provide a module path ** + ** which is needed for debugging. The debugger may use any available means to ** + ** locate and/or procure the module. See the security note below for important ** + ** information about implementing this method securely. ** + ** Arguments: ** + ** pwszFileName - The name of the module being requested ** + ** ** + ** pwszRuntimeModule - The runtime module path or the module path of the ** + ** single-file app. NULL when called from the ** + ** OpenVirtualProcess API. ** + ** ** + ** indexType - The type of the build id either the identity of the requested ** + ** module or the runtime (coreclr) module's. Normally it will ** + ** be the identity index type and the runtime index for Linux ** + ** cross-DAC on Windows or for non-singlefile apps on Linux/MacOS. ** + ** ** + ** pbBuildId - The Linux or MacOS module build id ** + ** ** + ** iBuildIdSize - The number of bytes in the build id ** + ** ** + ** ppResolvedModulePath - Where *ppResolvedModulePath is a null terminated ** + ** path to the module dll. On Windows it should be ** + ** allocated with CoTaskMemAlloc. On Unix it should be ** + ** allocated with malloc. Failure leave it untouched. See ** + ** security note below! ** + ** ** + ** Return value - S_OK if the module was provided, or any other convenient ** + ** error HRESULT if the module could not be provided ** + ** ** + ** !!!!!!!!!!!!!! ** + ** SECURITY NOTE: Anything the caller would not be willing to execute itself, it ** + ** should not provide to the this API call ** + ***********************************************************************************/ + HRESULT ProvideUnixLibrary( + [in] const WCHAR* pwszFileName, + [in] const WCHAR* pwszRuntimeModule, + [in] LIBRARY_PROVIDER_INDEX_TYPE indexType, + [in] BYTE* pbBuildId, + [in] int iBuildIdSize, + [out] LPWSTR* ppResolvedModulePath); +} + /************************************************************************************** ** ICLRDebugging ** ** Activated using mscoree!CLRCreateInstance. ** diff --git a/src/coreclr/inc/readytorun.h b/src/coreclr/inc/readytorun.h index d13c660993a..f5737ab0de9 100644 --- a/src/coreclr/inc/readytorun.h +++ b/src/coreclr/inc/readytorun.h @@ -36,7 +36,7 @@ // R2R Version 9.2 adds MemZero and NativeMemSet helpers // R2R Version 9.3 adds BulkWriteBarrier helper // uses GCInfo v3, which makes safe points in partially interruptible code interruptible. -// R2R Version 10.0 adds support for the statics being allocated on a per type basis instead of on a per module basis +// R2R Version 10.0 adds support for the statics being allocated on a per type basis instead of on a per module basis, disable support for LogMethodEnter helper // R2R Version 10.1 adds Unbox_TypeTest helper struct READYTORUN_CORE_HEADER @@ -346,7 +346,7 @@ enum ReadyToRunHelper READYTORUN_HELPER_GetString = 0x50, // Used by /Tuning for Profile optimizations - READYTORUN_HELPER_LogMethodEnter = 0x51, + READYTORUN_HELPER_LogMethodEnter = 0x51, // No longer supported as of READYTORUN_MAJOR_VERSION 10.0 // Reflection helpers READYTORUN_HELPER_GetRuntimeTypeHandle = 0x54, diff --git a/src/coreclr/inc/readytorunhelpers.h b/src/coreclr/inc/readytorunhelpers.h index 58ad7f38414..b8f2fd366d3 100644 --- a/src/coreclr/inc/readytorunhelpers.h +++ b/src/coreclr/inc/readytorunhelpers.h @@ -34,8 +34,6 @@ HELPER(READYTORUN_HELPER_MemZero, CORINFO_HELP_MEMZERO, HELPER(READYTORUN_HELPER_NativeMemSet, CORINFO_HELP_NATIVE_MEMSET, ) HELPER(READYTORUN_HELPER_MemCpy, CORINFO_HELP_MEMCPY, ) -HELPER(READYTORUN_HELPER_LogMethodEnter, CORINFO_HELP_BBT_FCN_ENTER, ) - HELPER(READYTORUN_HELPER_GetRuntimeTypeHandle, CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE, ) HELPER(READYTORUN_HELPER_GetRuntimeMethodHandle, CORINFO_HELP_METHODDESC_TO_STUBRUNTIMEMETHOD, ) HELPER(READYTORUN_HELPER_GetRuntimeFieldHandle, CORINFO_HELP_FIELDDESC_TO_STUBRUNTIMEFIELD, ) diff --git a/src/coreclr/inc/sigparser.h b/src/coreclr/inc/sigparser.h index 4446a37e372..6aad0669d94 100644 --- a/src/coreclr/inc/sigparser.h +++ b/src/coreclr/inc/sigparser.h @@ -582,19 +582,32 @@ class SigParser return hr; while ((ELEMENT_TYPE_CMOD_REQD == bElementType) || - (ELEMENT_TYPE_CMOD_OPT == bElementType)) + (ELEMENT_TYPE_CMOD_OPT == bElementType) || + (ELEMENT_TYPE_CMOD_INTERNAL == bElementType)) { sigTemp.SkipBytes(1); + if (ELEMENT_TYPE_CMOD_INTERNAL == bElementType) + { + void * pMT; + // If this custom modifier is required or optional + uint8_t required; + if (FAILED(hr = sigTemp.GetByte(&required))) + return hr; + + if (FAILED(hr = sigTemp.GetPointer(&pMT))) + return hr; + } + else + { + mdToken token; - mdToken token; - - hr = sigTemp.GetToken(&token); + hr = sigTemp.GetToken(&token); - if (FAILED(hr)) - return hr; + if (FAILED(hr)) + return hr; + } - hr = sigTemp.PeekByte(&bElementType); - if (FAILED(hr)) + if (FAILED(hr = sigTemp.PeekByte(&bElementType))) return hr; } @@ -643,19 +656,31 @@ class SigParser while (ELEMENT_TYPE_CMOD_REQD == bElementType || ELEMENT_TYPE_CMOD_OPT == bElementType || ELEMENT_TYPE_MODIFIER == bElementType || - ELEMENT_TYPE_PINNED == bElementType) + ELEMENT_TYPE_PINNED == bElementType || + ELEMENT_TYPE_CMOD_INTERNAL == bElementType) { sigTemp.SkipBytes(1); + if (ELEMENT_TYPE_CMOD_INTERNAL == bElementType) + { + void * pMT; + uint8_t required; + if (FAILED(hr = sigTemp.GetByte(&required))) + return hr; + + if (FAILED(hr = sigTemp.GetPointer(&pMT))) + return hr; + } + else + { + mdToken token; - mdToken token; - - hr = sigTemp.GetToken(&token); + hr = sigTemp.GetToken(&token); - if (FAILED(hr)) - return hr; + if (FAILED(hr)) + return hr; + } - hr = sigTemp.PeekByte(&bElementType); - if (FAILED(hr)) + if (FAILED(hr = sigTemp.PeekByte(&bElementType))) return hr; } diff --git a/src/coreclr/inc/stresslog.h b/src/coreclr/inc/stresslog.h index 39a0d6c5be3..58fbfdba97e 100644 --- a/src/coreclr/inc/stresslog.h +++ b/src/coreclr/inc/stresslog.h @@ -17,9 +17,10 @@ extension (eg. strike). There is no memory allocation system calls etc to purtub things */ // ****************************************************************************** -// WARNING!!!: These classes are used by SOS in the diagnostics repo. Values should -// added or removed in a backwards and forwards compatible way. +// WARNING!!!: These classes are used by the runtime and SOS in the diagnostics +// repo. Values should added or removed in a backwards and forwards compatible way. // See: https://github.com/dotnet/diagnostics/blob/main/src/shared/inc/stresslog.h +// https://github.com/dotnet/runtime/blob/main/src/coreclr/inc/stresslog.h // Parser: https://github.com/dotnet/diagnostics/blob/main/src/SOS/Strike/stressLogDump.cpp // ****************************************************************************** diff --git a/src/coreclr/inc/utilcode.h b/src/coreclr/inc/utilcode.h index 7a577ccd88c..9eefb47875f 100644 --- a/src/coreclr/inc/utilcode.h +++ b/src/coreclr/inc/utilcode.h @@ -3241,7 +3241,7 @@ BOOL GetRegistryLongValue(HKEY hKeyParent, // Parent key. long *pValue, // Put value here, if found. BOOL fReadNonVirtualizedKey); // Whether to read 64-bit hive on WOW64 -HRESULT GetCurrentModuleFileName(SString& pBuffer); +HRESULT GetCurrentExecutableFileName(SString& pBuffer); //***************************************************************************** // Retrieve information regarding what registered default debugger @@ -3867,6 +3867,7 @@ inline T* InterlockedCompareExchangeT( // Returns the directory for clr module. So, if path was for "C:\Dir1\Dir2\Filename.DLL", // then this would return "C:\Dir1\Dir2\" (note the trailing backslash). HRESULT GetClrModuleDirectory(SString& wszPath); +void* GetCurrentModuleBase(); namespace Clr { namespace Util { diff --git a/src/coreclr/inc/vptr_list.h b/src/coreclr/inc/vptr_list.h index de8b5bfc9d1..8150147bfa2 100644 --- a/src/coreclr/inc/vptr_list.h +++ b/src/coreclr/inc/vptr_list.h @@ -21,9 +21,6 @@ VPTR_CLASS(EditAndContinueModule) VPTR_CLASS(Module) VPTR_CLASS(ReflectionModule) -VPTR_CLASS(AppDomain) -VPTR_CLASS(SystemDomain) - VPTR_CLASS(PrecodeStubManager) VPTR_CLASS(StubLinkStubManager) VPTR_CLASS(ThePreStubManager) diff --git a/src/coreclr/jit/ICorJitInfo_names_generated.h b/src/coreclr/jit/ICorJitInfo_names_generated.h index 4779f13a029..15665a14b69 100644 --- a/src/coreclr/jit/ICorJitInfo_names_generated.h +++ b/src/coreclr/jit/ICorJitInfo_names_generated.h @@ -45,9 +45,7 @@ DEF_CLR_API(getTypeInstantiationArgument) DEF_CLR_API(printClassName) DEF_CLR_API(isValueClass) DEF_CLR_API(getClassAttribs) -DEF_CLR_API(getClassModule) -DEF_CLR_API(getModuleAssembly) -DEF_CLR_API(getAssemblyName) +DEF_CLR_API(getClassAssemblyName) DEF_CLR_API(LongLifetimeMalloc) DEF_CLR_API(LongLifetimeFree) DEF_CLR_API(getIsClassInitedFlagAddress) @@ -180,5 +178,6 @@ DEF_CLR_API(recordRelocation) DEF_CLR_API(getRelocTypeHint) DEF_CLR_API(getExpectedTargetArchitecture) DEF_CLR_API(getJitFlags) +DEF_CLR_API(getSpecialCopyHelper) #undef DEF_CLR_API diff --git a/src/coreclr/jit/ICorJitInfo_wrapper_generated.hpp b/src/coreclr/jit/ICorJitInfo_wrapper_generated.hpp index 4db7f026f9d..f45110fe0ca 100644 --- a/src/coreclr/jit/ICorJitInfo_wrapper_generated.hpp +++ b/src/coreclr/jit/ICorJitInfo_wrapper_generated.hpp @@ -416,30 +416,12 @@ uint32_t WrapICorJitInfo::getClassAttribs( return temp; } -CORINFO_MODULE_HANDLE WrapICorJitInfo::getClassModule( +const char* WrapICorJitInfo::getClassAssemblyName( CORINFO_CLASS_HANDLE cls) { - API_ENTER(getClassModule); - CORINFO_MODULE_HANDLE temp = wrapHnd->getClassModule(cls); - API_LEAVE(getClassModule); - return temp; -} - -CORINFO_ASSEMBLY_HANDLE WrapICorJitInfo::getModuleAssembly( - CORINFO_MODULE_HANDLE mod) -{ - API_ENTER(getModuleAssembly); - CORINFO_ASSEMBLY_HANDLE temp = wrapHnd->getModuleAssembly(mod); - API_LEAVE(getModuleAssembly); - return temp; -} - -const char* WrapICorJitInfo::getAssemblyName( - CORINFO_ASSEMBLY_HANDLE assem) -{ - API_ENTER(getAssemblyName); - const char* temp = wrapHnd->getAssemblyName(assem); - API_LEAVE(getAssemblyName); + API_ENTER(getClassAssemblyName); + const char* temp = wrapHnd->getClassAssemblyName(cls); + API_LEAVE(getClassAssemblyName); return temp; } @@ -939,10 +921,10 @@ CORINFO_CLASS_HANDLE WrapICorJitInfo::getFieldClass( CorInfoType WrapICorJitInfo::getFieldType( CORINFO_FIELD_HANDLE field, CORINFO_CLASS_HANDLE* structType, - CORINFO_CLASS_HANDLE memberParent) + CORINFO_CLASS_HANDLE fieldOwnerHint) { API_ENTER(getFieldType); - CorInfoType temp = wrapHnd->getFieldType(field, structType, memberParent); + CorInfoType temp = wrapHnd->getFieldType(field, structType, fieldOwnerHint); API_LEAVE(getFieldType); return temp; } @@ -1742,6 +1724,15 @@ uint32_t WrapICorJitInfo::getJitFlags( return temp; } +CORINFO_METHOD_HANDLE WrapICorJitInfo::getSpecialCopyHelper( + CORINFO_CLASS_HANDLE type) +{ + API_ENTER(getSpecialCopyHelper); + CORINFO_METHOD_HANDLE temp = wrapHnd->getSpecialCopyHelper(type); + API_LEAVE(getSpecialCopyHelper); + return temp; +} + /**********************************************************************************/ // clang-format on /**********************************************************************************/ diff --git a/src/coreclr/jit/assertionprop.cpp b/src/coreclr/jit/assertionprop.cpp index db1ea448067..b5ee976e868 100644 --- a/src/coreclr/jit/assertionprop.cpp +++ b/src/coreclr/jit/assertionprop.cpp @@ -291,7 +291,8 @@ bool IntegralRange::Contains(int64_t value) const case NI_LZCNT_X64_LeadingZeroCount: case NI_POPCNT_PopCount: case NI_POPCNT_X64_PopCount: - // TODO-Casts: specify more precise ranges once "IntegralRange" supports them. + // Note: No advantage in using a precise range for IntegralRange. + // Example: IntCns = 42 gives [0..127] with a non -precise range, [42,42] with a precise range. return {SymbolicIntegerValue::Zero, SymbolicIntegerValue::ByteMax}; #elif defined(TARGET_ARM64) case NI_Vector64_op_Equality: @@ -317,7 +318,8 @@ bool IntegralRange::Contains(int64_t value) const case NI_ArmBase_LeadingZeroCount: case NI_ArmBase_Arm64_LeadingZeroCount: case NI_ArmBase_Arm64_LeadingSignCount: - // TODO-Casts: specify more precise ranges once "IntegralRange" supports them. + // Note: No advantage in using a precise range for IntegralRange. + // Example: IntCns = 42 gives [0..127] with a non -precise range, [42,42] with a precise range. return {SymbolicIntegerValue::Zero, SymbolicIntegerValue::ByteMax}; #else #error Unsupported platform @@ -6254,13 +6256,7 @@ GenTree* Compiler::optExtractSideEffListFromConst(GenTree* tree) // Do a sanity check to ensure persistent side effects aren't discarded and // tell gtExtractSideEffList to ignore the root of the tree. // We are relying here on an invariant that VN will only fold non-throwing expressions. - const bool ignoreExceptions = true; - const bool ignoreCctors = false; - // We have to check "AsCall()->HasSideEffects()" here separately because "gtNodeHasSideEffects" - // also checks for side effects that arguments introduce (incosistently so, it otherwise only - // checks for the side effects the node itself has). TODO-Cleanup: change it to not do that? - assert(!gtNodeHasSideEffects(tree, GTF_PERSISTENT_SIDE_EFFECTS) || - (tree->IsCall() && !tree->AsCall()->HasSideEffects(this, ignoreExceptions, ignoreCctors))); + assert(!gtNodeHasSideEffects(tree, GTF_PERSISTENT_SIDE_EFFECTS)); // Exception side effects may be ignored because the root is known to be a constant // (e.g. VN may evaluate a DIV/MOD node to a constant and the node may still @@ -6488,9 +6484,6 @@ Compiler::fgWalkResult Compiler::optVNBasedFoldCurStmt(BasicBlock* block, return WALK_CONTINUE; } - // TODO https://github.com/dotnet/runtime/issues/10450: - // at that moment stmt could be already removed from the stmt list. - optAssertionProp_Update(newTree, tree, stmt); JITDUMP("After VN-based fold of [%06u]:\n", tree->gtTreeID); diff --git a/src/coreclr/jit/codegen.h b/src/coreclr/jit/codegen.h index 73b3de1c4d3..681b9f1f2f8 100644 --- a/src/coreclr/jit/codegen.h +++ b/src/coreclr/jit/codegen.h @@ -1010,10 +1010,14 @@ class CodeGen final : public CodeGenInterface class HWIntrinsicImmOpHelper final { public: - HWIntrinsicImmOpHelper(CodeGen* codeGen, GenTree* immOp, GenTreeHWIntrinsic* intrin); + HWIntrinsicImmOpHelper(CodeGen* codeGen, GenTree* immOp, GenTreeHWIntrinsic* intrin, int numInstrs = 1); - HWIntrinsicImmOpHelper( - CodeGen* codeGen, regNumber immReg, int immLowerBound, int immUpperBound, GenTreeHWIntrinsic* intrin); + HWIntrinsicImmOpHelper(CodeGen* codeGen, + regNumber immReg, + int immLowerBound, + int immUpperBound, + GenTreeHWIntrinsic* intrin, + int numInstrs = 1); void EmitBegin(); void EmitCaseEnd(); @@ -1058,6 +1062,7 @@ class CodeGen final : public CodeGenInterface int immUpperBound; regNumber nonConstImmReg; regNumber branchTargetReg; + int numInstrs; }; #endif // TARGET_ARM64 diff --git a/src/coreclr/jit/codegenarm64test.cpp b/src/coreclr/jit/codegenarm64test.cpp index 3d09f1023ff..ba80eaa7fa9 100644 --- a/src/coreclr/jit/codegenarm64test.cpp +++ b/src/coreclr/jit/codegenarm64test.cpp @@ -1900,6 +1900,16 @@ void CodeGen::genArm64EmitterUnitTestsAdvSimd() theEmitter->emitIns_R_R_I(INS_stur, EA_8BYTE, REG_V7, REG_R10, 9); theEmitter->emitIns_R_R_I(INS_stur, EA_16BYTE, REG_V7, REG_R10, 17); + theEmitter->emitIns_R_R_I(INS_stlurb, EA_1BYTE, REG_V7, REG_R10, 0); + theEmitter->emitIns_R_R_I(INS_stlurh, EA_2BYTE, REG_V7, REG_R10, 0); + theEmitter->emitIns_R_R_I(INS_stlur, EA_4BYTE, REG_V7, REG_R10, 0); + theEmitter->emitIns_R_R_I(INS_stlur, EA_8BYTE, REG_V7, REG_R10, 0); + + theEmitter->emitIns_R_R_I(INS_ldapurb, EA_1BYTE, REG_V8, REG_R9, 0); + theEmitter->emitIns_R_R_I(INS_ldapurh, EA_2BYTE, REG_V8, REG_R9, 0); + theEmitter->emitIns_R_R_I(INS_ldapur, EA_4BYTE, REG_V8, REG_R9, 0); + theEmitter->emitIns_R_R_I(INS_ldapur, EA_8BYTE, REG_V8, REG_R9, 0); + // load/store pair theEmitter->emitIns_R_R_R(INS_ldnp, EA_8BYTE, REG_V0, REG_V1, REG_R10); theEmitter->emitIns_R_R_R_I(INS_stnp, EA_8BYTE, REG_V1, REG_V2, REG_R10, 0); diff --git a/src/coreclr/jit/codegencommon.cpp b/src/coreclr/jit/codegencommon.cpp index 0598d968e73..9920f9846d2 100644 --- a/src/coreclr/jit/codegencommon.cpp +++ b/src/coreclr/jit/codegencommon.cpp @@ -1365,9 +1365,8 @@ bool CodeGen::genCreateAddrMode(GenTree* addr, { cns += addConst->IconValue(); op2 = op2->AsOp()->gtOp1; + goto AGAIN; } - - goto AGAIN; } break; #endif // TARGET_XARCH diff --git a/src/coreclr/jit/compiler.cpp b/src/coreclr/jit/compiler.cpp index 516b774f362..e0fd55ff3c0 100644 --- a/src/coreclr/jit/compiler.cpp +++ b/src/coreclr/jit/compiler.cpp @@ -330,6 +330,186 @@ Histogram loopExitCountTable(loopExitCountBuckets); #endif // COUNT_LOOPS +Compiler::Compiler(ArenaAllocator* arena, + CORINFO_METHOD_HANDLE methodHnd, + COMP_HANDLE compHnd, + CORINFO_METHOD_INFO* methodInfo, + InlineInfo* inlineInfo) + : compArenaAllocator(arena) + , impInlineInfo(inlineInfo) + , impPendingBlockMembers(CompAllocator(arena, CMK_Generic)) + , impSpillCliquePredMembers(CompAllocator(arena, CMK_Generic)) + , impSpillCliqueSuccMembers(CompAllocator(arena, CMK_Generic)) +#ifndef TARGET_WASM + , genIPmappings(CompAllocator(arena, CMK_DebugInfo)) + , genRichIPmappings(CompAllocator(arena, CMK_DebugInfo)) +#endif // !TARGET_WASM +{ + info.compCompHnd = compHnd; + info.compMethodHnd = methodHnd; + info.compMethodInfo = methodInfo; + info.compClassHnd = compHnd->getMethodClass(methodHnd); + +#ifdef DEBUG + verbose = compIsForInlining() ? impInlineInfo->InlinerCompiler->verbose : false; +#endif + +#if defined(DEBUG) || defined(LATE_DISASM) || DUMP_FLOWGRAPHS || DUMP_GC_TABLES + info.compMethodName = eeGetMethodName(methodHnd); + info.compClassName = eeGetClassName(info.compClassHnd); + info.compFullName = eeGetMethodFullName(methodHnd); + + info.compMethodSuperPMIIndex = g_jitHost->getIntConfigValue(W("SuperPMIMethodContextNumber"), -1); + + if (!compIsForInlining()) + { + JitMetadata::report(this, JitMetadata::MethodFullName, info.compFullName, strlen(info.compFullName)); + } +#endif // defined(DEBUG) || defined(LATE_DISASM) || DUMP_FLOWGRAPHS + +#ifdef DEBUG + // Opt-in to jit stress based on method hash ranges. + // + // Note the default (with JitStressRange not set) is that all + // methods will be subject to stress. + static ConfigMethodRange fJitStressRange; + fJitStressRange.EnsureInit(JitConfig.JitStressRange()); + assert(!fJitStressRange.Error()); + compAllowStress = + fJitStressRange.Contains(info.compMethodHash()) && + (JitConfig.JitStressOnly().isEmpty() || + JitConfig.JitStressOnly().contains(info.compMethodHnd, info.compClassHnd, &info.compMethodInfo->args)); + +#endif // DEBUG + +#if defined(FEATURE_EH_WINDOWS_X86) + eeIsNativeAotAbi = IsTargetAbi(CORINFO_NATIVEAOT_ABI); +#endif + + if (compIsForInlining()) + { + m_inlineStrategy = nullptr; + compInlineResult = inlineInfo->inlineResult; + } + else + { + m_inlineStrategy = new (this, CMK_Inlining) InlineStrategy(this); + compInlineResult = nullptr; + } + +#ifdef TARGET_WASM + m_llvm = new (getAllocator(CMK_Codegen)) Llvm(this); +#endif // TARGET_WASM + + for (int i = 0; i < TYP_COUNT; i++) + { + fgBigOffsetMorphingTemps[i] = BAD_VAR_NUM; + } + +#ifdef DEBUG + if (!compIsForInlining()) + { + const int noStructPromotionValue = JitConfig.JitNoStructPromotion(); + assert(0 <= noStructPromotionValue && noStructPromotionValue <= 2); + if (noStructPromotionValue == 1) + { + fgNoStructPromotion = true; + } + if (noStructPromotionValue == 2) + { + fgNoStructParamPromotion = true; + } + } +#endif // DEBUG + + structPromotionHelper = new (this, CMK_Promotion) StructPromotionHelper(this); + + if (!compIsForInlining()) + { +#ifndef TARGET_WASM + codeGen = getCodeGenerator(this); +#endif // !TARGET_WASM + hashBv::Init(this); + + // + // Initialize all the per-method statistics gathering data structures. + // +#if MEASURE_NODE_SIZE + genNodeSizeStatsPerFunc.Init(); +#endif // MEASURE_NODE_SIZE + } + else + { +#ifndef TARGET_WASM + codeGen = nullptr; +#endif // !TARGET_WASM + } + + for (MemoryKind memoryKind : allMemoryKinds()) + { + m_memorySsaMap[memoryKind] = nullptr; + } + +#ifdef DEBUG + if (!compIsForInlining()) + { + compDoComponentUnitTestsOnce(); + } +#endif // DEBUG + + // check that HelperCallProperties are initialized + assert(s_helperCallProperties.IsPure(CORINFO_HELP_GET_GCSTATIC_BASE)); + + virtualStubParamInfo = new (this, CMK_Unknown) VirtualStubParamInfo(IsTargetAbi(CORINFO_NATIVEAOT_ABI)); + + // compMatchedVM is set to true if both CPU/ABI and OS are matching the execution engine requirements + // + // Do we have a matched VM? Or are we "abusing" the VM to help us do JIT work (such as using an x86 native VM + // with an ARM-targeting "altjit"). + // Match CPU/ABI for compMatchedVM + info.compMatchedVM = IMAGE_FILE_MACHINE_TARGET == info.compCompHnd->getExpectedTargetArchitecture(); + + // Match OS for compMatchedVM + CORINFO_EE_INFO* eeInfo = eeGetEEInfo(); + +#ifdef TARGET_OS_RUNTIMEDETERMINED + noway_assert(TargetOS::OSSettingConfigured); +#endif + + if (TargetOS::IsApplePlatform) + { + info.compMatchedVM = info.compMatchedVM && (eeInfo->osType == CORINFO_APPLE); + } + else if (TargetOS::IsUnix) + { + if (TargetArchitecture::IsX64) + { + // Apple x64 uses the Unix jit variant in crossgen2, not a special jit + info.compMatchedVM = + info.compMatchedVM && ((eeInfo->osType == CORINFO_UNIX) || (eeInfo->osType == CORINFO_APPLE)); + } + else + { + info.compMatchedVM = info.compMatchedVM && (eeInfo->osType == CORINFO_UNIX); + } + } + else if (TargetOS::IsWindows) + { + info.compMatchedVM = info.compMatchedVM && (eeInfo->osType == CORINFO_WINNT); + } + + compMaxUncheckedOffsetForNullObject = eeInfo->maxUncheckedOffsetForNullObject; + + info.compProfilerCallback = false; // Assume false until we are told to hook this method. + + info.compCode = methodInfo->ILCode; + info.compILCodeSize = methodInfo->ILCodeSize; + info.compILImportSize = 0; + + info.compHasNextCallRetAddr = false; + info.compIsVarArgs = false; +} + //------------------------------------------------------------------------ // getJitGCType: Given the VM's CorInfoGCType convert it to the JIT's var_types // @@ -1797,252 +1977,6 @@ void Compiler::compDisplayStaticSizes() #endif } -/***************************************************************************** - * - * Constructor - */ -void Compiler::compInit(ArenaAllocator* pAlloc, - CORINFO_METHOD_HANDLE methodHnd, - COMP_HANDLE compHnd, - CORINFO_METHOD_INFO* methodInfo, - InlineInfo* inlineInfo) -{ - assert(pAlloc); - compArenaAllocator = pAlloc; - - // Inlinee Compile object will only be allocated when needed for the 1st time. - InlineeCompiler = nullptr; - - // Set the inline info. - impInlineInfo = inlineInfo; - info.compCompHnd = compHnd; - info.compMethodHnd = methodHnd; - info.compMethodInfo = methodInfo; - info.compClassHnd = compHnd->getMethodClass(methodHnd); - -#ifdef DEBUG - compAllowStress = true; - - // set this early so we can use it without relying on random memory values - verbose = compIsForInlining() ? impInlineInfo->InlinerCompiler->verbose : false; - - compNumStatementLinksTraversed = 0; - compPoisoningAnyImplicitByrefs = false; -#endif - -#if defined(DEBUG) || defined(LATE_DISASM) || DUMP_FLOWGRAPHS || DUMP_GC_TABLES - // Initialize the method name and related info, as it is used early in determining whether to - // apply stress modes, and which ones to apply. - // Note that even allocating memory can invoke the stress mechanism, so ensure that both - // 'compMethodName' and 'compFullName' are either null or valid before we allocate. - // (The stress mode checks references these prior to checking bRangeAllowStress.) - // - info.compMethodName = nullptr; - info.compClassName = nullptr; - info.compFullName = nullptr; - - info.compMethodName = eeGetMethodName(methodHnd); - info.compClassName = eeGetClassName(info.compClassHnd); - info.compFullName = eeGetMethodFullName(methodHnd); - - info.compMethodSuperPMIIndex = g_jitHost->getIntConfigValue(W("SuperPMIMethodContextNumber"), -1); - - if (!compIsForInlining()) - { - JitMetadata::report(this, JitMetadata::MethodFullName, info.compFullName, strlen(info.compFullName)); - } -#endif // defined(DEBUG) || defined(LATE_DISASM) || DUMP_FLOWGRAPHS - -#if defined(DEBUG) - info.compMethodHashPrivate = 0; -#endif // defined(DEBUG) - -#ifdef DEBUG - // Opt-in to jit stress based on method hash ranges. - // - // Note the default (with JitStressRange not set) is that all - // methods will be subject to stress. - static ConfigMethodRange fJitStressRange; - fJitStressRange.EnsureInit(JitConfig.JitStressRange()); - assert(!fJitStressRange.Error()); - compAllowStress = - fJitStressRange.Contains(info.compMethodHash()) && - (JitConfig.JitStressOnly().isEmpty() || - JitConfig.JitStressOnly().contains(info.compMethodHnd, info.compClassHnd, &info.compMethodInfo->args)); - -#endif // DEBUG - - eeInfoInitialized = false; - -#if defined(FEATURE_EH_WINDOWS_X86) - // Cache Native AOT ABI check. This must happen *after* eeInfoInitialized is initialized, above. - eeIsNativeAotAbi = IsTargetAbi(CORINFO_NATIVEAOT_ABI); -#endif - - compDoAggressiveInlining = false; - - if (compIsForInlining()) - { - m_inlineStrategy = nullptr; - compInlineResult = inlineInfo->inlineResult; - } - else - { - m_inlineStrategy = new (this, CMK_Inlining) InlineStrategy(this); - compInlineResult = nullptr; - } - - // Initialize this to the first phase to run. - mostRecentlyActivePhase = PHASE_PRE_IMPORT; - - // Initially, no phase checks are active, and all dumps are enabled. - activePhaseChecks = PhaseChecks::CHECK_NONE; - activePhaseDumps = PhaseDumps::DUMP_ALL; - - fgInit(); - lvaInit(); - optInit(); - -#ifdef TARGET_WASM - m_llvm = new (getAllocator(CMK_Codegen)) Llvm(this); -#endif // TARGET_WASM - - if (!compIsForInlining()) - { -#ifndef TARGET_WASM - codeGen = getCodeGenerator(this); -#endif // !TARGET_WASM - hashBv::Init(this); - compVarScopeMap = nullptr; - - // If this method were a real constructor for Compiler, these would - // become method initializations. - impPendingBlockMembers = JitExpandArray(getAllocator()); - impSpillCliquePredMembers = JitExpandArray(getAllocator()); - impSpillCliqueSuccMembers = JitExpandArray(getAllocator()); - -#ifndef TARGET_WASM - new (&genIPmappings, jitstd::placement_t()) jitstd::list(getAllocator(CMK_DebugInfo)); - new (&genRichIPmappings, jitstd::placement_t()) jitstd::list(getAllocator(CMK_DebugOnly)); -#endif // !TARGET_WASM - - lvMemoryPerSsaData = SsaDefArray(); - - // - // Initialize all the per-method statistics gathering data structures. - // -#if LOOP_HOIST_STATS - m_loopsConsidered = 0; - m_curLoopHasHoistedExpression = false; - m_loopsWithHoistedExpressions = 0; - m_totalHoistedExpressions = 0; -#endif // LOOP_HOIST_STATS -#if MEASURE_NODE_SIZE - genNodeSizeStatsPerFunc.Init(); -#endif // MEASURE_NODE_SIZE - } - else - { -#ifndef TARGET_WASM - codeGen = nullptr; -#endif // !TARGET_WASM - } - - compJmpOpUsed = false; - compLongUsed = false; - compTailCallUsed = false; - compTailPrefixSeen = false; - compLocallocSeen = false; - compLocallocUsed = false; - compLocallocOptimized = false; - compQmarkRationalized = false; - compQmarkUsed = false; - compFloatingPointUsed = false; - - compSuppressedZeroInit = false; - - compNeedsGSSecurityCookie = false; - compGSReorderStackLayout = false; - - compGeneratingProlog = false; - compGeneratingEpilog = false; - compGeneratingUnwindProlog = false; - compGeneratingUnwindEpilog = false; - - compPostImportationCleanupDone = false; - compLSRADone = false; - compRationalIRForm = false; - -#ifdef DEBUG - compCodeGenDone = false; - opts.compMinOptsIsUsed = false; -#endif - opts.compMinOptsIsSet = false; - - // Used by fgFindJumpTargets for inlining heuristics. - opts.instrCount = 0; - - // Used to track when we should consider running EarlyProp - optMethodFlags = 0; - optNoReturnCallCount = 0; - -#ifdef DEBUG - m_nodeTestData = nullptr; - m_loopHoistCSEClass = FIRST_LOOP_HOIST_CSE_CLASS; -#endif - m_switchDescMap = nullptr; - m_blockToEHPreds = nullptr; - m_dominancePreds = nullptr; - m_fieldSeqStore = nullptr; - m_refAnyClass = nullptr; - for (MemoryKind memoryKind : allMemoryKinds()) - { - m_memorySsaMap[memoryKind] = nullptr; - } - -#ifdef DEBUG - if (!compIsForInlining()) - { - compDoComponentUnitTestsOnce(); - } -#endif // DEBUG - - vnStore = nullptr; - m_outlinedCompositeSsaNums = nullptr; - m_nodeToLoopMemoryBlockMap = nullptr; - m_signatureToLookupInfoMap = nullptr; - m_significantSegmentsMap = nullptr; - fgSsaPassesCompleted = 0; - fgSsaValid = false; - fgVNPassesCompleted = 0; - -#ifdef SWIFT_SUPPORT - m_swiftLoweringCache = nullptr; -#endif -#if defined(TARGET_RISCV64) || defined(TARGET_LOONGARCH64) - m_fpStructLoweringCache = nullptr; -#endif - - // check that HelperCallProperties are initialized - - assert(s_helperCallProperties.IsPure(CORINFO_HELP_GET_GCSTATIC_BASE)); - - // We start with the flow graph in tree-order - fgOrder = FGOrderTree; - - m_classLayoutTable = nullptr; - -#ifdef FEATURE_SIMD - m_simdHandleCache = nullptr; -#endif // FEATURE_SIMD - - compUsesThrowHelper = false; - - m_preferredInitCctor = CORINFO_HELP_UNDEF; - - new (&Metrics, jitstd::placement_t()) JitMetrics(); -} - /***************************************************************************** * * Destructor @@ -2692,8 +2626,7 @@ void Compiler::compInitOptions(JitFlags* jitFlags) // We have an exclusion list. See if this method is in an assembly that is on the list. // Note that we check this for every method, since we might inline across modules, and // if the inlinee module is on the list, we don't want to use the altjit for it. - const char* methodAssemblyName = info.compCompHnd->getAssemblyName( - info.compCompHnd->getModuleAssembly(info.compCompHnd->getClassModule(info.compClassHnd))); + const char* methodAssemblyName = eeGetClassAssemblyName(info.compClassHnd); if (s_pAltJitExcludeAssembliesList->IsInList(methodAssemblyName)) { opts.altJit = false; @@ -2720,8 +2653,7 @@ void Compiler::compInitOptions(JitFlags* jitFlags) bool assemblyInIncludeList = true; // assume we'll dump, if there's not an include list (or it's empty). if (s_pJitDisasmIncludeAssembliesList != nullptr && !s_pJitDisasmIncludeAssembliesList->IsEmpty()) { - const char* assemblyName = info.compCompHnd->getAssemblyName( - info.compCompHnd->getModuleAssembly(info.compCompHnd->getClassModule(info.compClassHnd))); + const char* assemblyName = eeGetClassAssemblyName(info.compClassHnd); if (!s_pJitDisasmIncludeAssembliesList->IsInList(assemblyName)) { // We have a list, and the current assembly is not in it, so we won't dump. @@ -4151,16 +4083,6 @@ void Compiler::compSetOptimizationLevel() opts.jitFlags->Clear(JitFlags::JIT_FLAG_TIER1); opts.jitFlags->Clear(JitFlags::JIT_FLAG_BBOPT); compSwitchedToMinOpts = true; - - // We may have read PGO data. Clear it out because we won't be using it. - // - fgPgoFailReason = "method switched to min-opts"; - fgPgoQueryResult = E_FAIL; - fgPgoHaveWeights = false; - fgPgoData = nullptr; - fgPgoSchema = nullptr; - fgPgoDisabled = true; - fgPgoDynamic = false; } #ifdef DEBUG @@ -4179,6 +4101,10 @@ void Compiler::compSetOptimizationLevel() lvaEnregEHVars &= compEnregLocals(); lvaEnregMultiRegVars &= compEnregLocals(); + + // Scrub any profile data we might have fetched + // + fgRemoveProfileData("compiling with minopt"); } #ifndef TARGET_WASM @@ -5097,10 +5023,10 @@ void Compiler::compCompile(void** methodCodePtr, uint32_t* methodCodeSize, JitFl doBranchOpt = doValueNum && (JitConfig.JitDoRedundantBranchOpts() != 0); doCse = doValueNum; doAssertionProp = doValueNum && (JitConfig.JitDoAssertionProp() != 0); - doVNBasedIntrinExpansion = doValueNum; doRangeAnalysis = doAssertionProp && (JitConfig.JitDoRangeAnalysis() != 0); doOptimizeIVs = doAssertionProp && (JitConfig.JitDoOptimizeIVs() != 0); doVNBasedDeadStoreRemoval = doValueNum && (JitConfig.JitDoVNBasedDeadStoreRemoval() != 0); + doVNBasedIntrinExpansion = doValueNum; #endif // defined(OPT_CONFIG) if (opts.optRepeat) @@ -5187,13 +5113,6 @@ void Compiler::compCompile(void** methodCodePtr, uint32_t* methodCodeSize, JitFl DoPhase(this, PHASE_ASSERTION_PROP_MAIN, &Compiler::optAssertionPropMain); } - if (doVNBasedIntrinExpansion) - { - // Expand some intrinsics based on VN data - // - DoPhase(this, PHASE_VN_BASED_INTRINSIC_EXPAND, &Compiler::fgVNBasedIntrinsicExpansion); - } - if (doRangeAnalysis) { // Bounds check elimination via range analysis @@ -5215,6 +5134,13 @@ void Compiler::compCompile(void** methodCodePtr, uint32_t* methodCodeSize, JitFl DoPhase(this, PHASE_VN_BASED_DEAD_STORE_REMOVAL, &Compiler::optVNBasedDeadStoreRemoval); } + if (doVNBasedIntrinExpansion) + { + // Expand some intrinsics based on VN data + // + DoPhase(this, PHASE_VN_BASED_INTRINSIC_EXPAND, &Compiler::fgVNBasedIntrinsicExpansion); + } + // Conservatively mark all VNs as stale vnStore = nullptr; @@ -5301,11 +5227,11 @@ void Compiler::compCompile(void** methodCodePtr, uint32_t* methodCodeSize, JitFl // Conditional to Switch conversion // DoPhase(this, PHASE_SWITCH_RECOGNITION, &Compiler::optSwitchRecognition); - } - // Determine start of cold region if we are hot/cold splitting - // - DoPhase(this, PHASE_DETERMINE_FIRST_COLD_BLOCK, &Compiler::fgDetermineFirstColdBlock); + // Determine start of cold region if we are hot/cold splitting + // + DoPhase(this, PHASE_DETERMINE_FIRST_COLD_BLOCK, &Compiler::fgDetermineFirstColdBlock); + } #ifdef DEBUG // Stash the current estimate of the function's size if necessary. @@ -5395,11 +5321,12 @@ void Compiler::compCompile(void** methodCodePtr, uint32_t* methodCodeSize, JitFl m_pLowering->FinalizeOutgoingArgSpace(); // We can not add any new tracked variables after this point. - lvaTrackedFixed = true; + lvaTrackedFixed = true; + const unsigned numBlocksBeforeLSRA = fgBBcount; // Now that lowering is completed we can proceed to perform register allocation // - auto linearScanPhase = [this]() { + auto linearScanPhase = [this] { m_pLinearScan->doLinearScan(); }; DoPhase(this, PHASE_LINEAR_SCAN, linearScanPhase); @@ -5409,8 +5336,25 @@ void Compiler::compCompile(void** methodCodePtr, uint32_t* methodCodeSize, JitFl if (opts.OptimizationEnabled()) { - // LSRA and stack level setting can modify the flowgraph. - // Now that it won't change, run post-layout optimizations. + // LSRA may introduce new blocks. If it does, rerun layout. + if ((fgBBcount != numBlocksBeforeLSRA) && JitConfig.JitDoReversePostOrderLayout()) + { + auto lateLayoutPhase = [this] { + fgDoReversePostOrderLayout(); + fgMoveColdBlocks(); + return PhaseStatus::MODIFIED_EVERYTHING; + }; + + DoPhase(this, PHASE_OPTIMIZE_LAYOUT, lateLayoutPhase); + + if (fgFirstColdBlock != nullptr) + { + fgFirstColdBlock = nullptr; + DoPhase(this, PHASE_DETERMINE_FIRST_COLD_BLOCK, &Compiler::fgDetermineFirstColdBlock); + } + } + + // Now that the flowgraph is finalized, run post-layout optimizations. DoPhase(this, PHASE_OPTIMIZE_POST_LAYOUT, &Compiler::optOptimizePostLayout); } @@ -6189,8 +6133,6 @@ int Compiler::compCompile(CORINFO_MODULE_HANDLE classPtr, #ifdef FEATURE_JIT_METHOD_PERF static bool checkedForJitTimeLog = false; - pCompJitTimer = nullptr; - if (!checkedForJitTimeLog) { // Call into VM to get the config strings. FEATURE_JIT_METHOD_PERF is enabled for @@ -6251,48 +6193,6 @@ int Compiler::compCompile(CORINFO_MODULE_HANDLE classPtr, assert(info.compPatchpointInfo != nullptr); } -#if defined(TARGET_ARM64) - compFrameInfo = {0}; -#endif - - virtualStubParamInfo = new (this, CMK_Unknown) VirtualStubParamInfo(IsTargetAbi(CORINFO_NATIVEAOT_ABI)); - - // compMatchedVM is set to true if both CPU/ABI and OS are matching the execution engine requirements - // - // Do we have a matched VM? Or are we "abusing" the VM to help us do JIT work (such as using an x86 native VM - // with an ARM-targeting "altjit"). - // Match CPU/ABI for compMatchedVM - info.compMatchedVM = IMAGE_FILE_MACHINE_TARGET == info.compCompHnd->getExpectedTargetArchitecture(); - - // Match OS for compMatchedVM - CORINFO_EE_INFO* eeInfo = eeGetEEInfo(); - -#ifdef TARGET_OS_RUNTIMEDETERMINED - noway_assert(TargetOS::OSSettingConfigured); -#endif - - if (TargetOS::IsApplePlatform) - { - info.compMatchedVM = info.compMatchedVM && (eeInfo->osType == CORINFO_APPLE); - } - else if (TargetOS::IsUnix) - { - if (TargetArchitecture::IsX64) - { - // Apple x64 uses the Unix jit variant in crossgen2, not a special jit - info.compMatchedVM = - info.compMatchedVM && ((eeInfo->osType == CORINFO_UNIX) || (eeInfo->osType == CORINFO_APPLE)); - } - else - { - info.compMatchedVM = info.compMatchedVM && (eeInfo->osType == CORINFO_UNIX); - } - } - else if (TargetOS::IsWindows) - { - info.compMatchedVM = info.compMatchedVM && (eeInfo->osType == CORINFO_WINNT); - } - // If we are not compiling for a matched VM, then we are getting JIT flags that don't match our target // architecture. The two main examples here are an ARM targeting altjit hosted on x86 and an ARM64 // targeting altjit hosted on x64. (Though with cross-bitness work, the host doesn't necessarily need @@ -6518,8 +6418,6 @@ int Compiler::compCompile(CORINFO_MODULE_HANDLE classPtr, compileFlags->SetInstructionSetFlags(instructionSetFlags); } - compMaxUncheckedOffsetForNullObject = eeGetEEInfo()->maxUncheckedOffsetForNullObject; - // Set the context for token lookup. if (compIsForInlining()) { @@ -6541,46 +6439,34 @@ int Compiler::compCompile(CORINFO_MODULE_HANDLE classPtr, #ifdef DEBUG if (JitConfig.EnableExtraSuperPmiQueries()) { - // This call to getClassModule/getModuleAssembly/getAssemblyName fails in crossgen2 due to these - // APIs being unimplemented. So disable this extra info for pre-jit mode. See - // https://github.com/dotnet/runtime/issues/48888. - // - // Ditto for some of the class name queries for generic params. - // - if (!compileFlags->IsSet(JitFlags::JIT_FLAG_PREJIT)) - { - // Get the assembly name, to aid finding any particular SuperPMI method context function - (void)info.compCompHnd->getAssemblyName( - info.compCompHnd->getModuleAssembly(info.compCompHnd->getClassModule(info.compClassHnd))); + // Get the assembly name, to aid finding any particular SuperPMI method context function + (void)eeGetClassAssemblyName(info.compClassHnd); - // Fetch class names for the method's generic parameters. - // - CORINFO_SIG_INFO sig; - info.compCompHnd->getMethodSig(info.compMethodHnd, &sig, nullptr); + // Fetch class names for the method's generic parameters. + // + CORINFO_SIG_INFO sig; + info.compCompHnd->getMethodSig(info.compMethodHnd, &sig, nullptr); - const unsigned classInst = sig.sigInst.classInstCount; - if (classInst > 0) + const unsigned classInst = sig.sigInst.classInstCount; + if (classInst > 0) + { + for (unsigned i = 0; i < classInst; i++) { - for (unsigned i = 0; i < classInst; i++) - { - eeGetClassName(sig.sigInst.classInst[i]); - } + eeGetClassName(sig.sigInst.classInst[i]); } + } - const unsigned methodInst = sig.sigInst.methInstCount; - if (methodInst > 0) + const unsigned methodInst = sig.sigInst.methInstCount; + if (methodInst > 0) + { + for (unsigned i = 0; i < methodInst; i++) { - for (unsigned i = 0; i < methodInst; i++) - { - eeGetClassName(sig.sigInst.methInst[i]); - } + eeGetClassName(sig.sigInst.methInst[i]); } } } #endif // DEBUG - info.compProfilerCallback = false; // Assume false until we are told to hook this method. - #ifdef DEBUG if (!compIsForInlining()) { @@ -7057,12 +6943,6 @@ int Compiler::compCompileHelper(CORINFO_MODULE_HANDLE classPtr, uint32_t* methodCodeSize, JitFlags* compileFlags) { - CORINFO_METHOD_HANDLE methodHnd = info.compMethodHnd; - - info.compCode = methodInfo->ILCode; - info.compILCodeSize = methodInfo->ILCodeSize; - info.compILImportSize = 0; - if (info.compILCodeSize == 0) { BADCODE("code size is zero"); @@ -7089,9 +6969,6 @@ int Compiler::compCompileHelper(CORINFO_MODULE_HANDLE classPtr, compInlineContext = m_inlineStrategy->GetRootContext(); } - compSwitchedToOptimized = false; - compSwitchedToMinOpts = false; - // compInitOptions will set the correct verbose flag. compInitOptions(compileFlags); @@ -7144,34 +7021,9 @@ int Compiler::compCompileHelper(CORINFO_MODULE_HANDLE classPtr, /* Initialize set a bunch of global values */ - info.compScopeHnd = classPtr; - info.compXcptnsCount = methodInfo->EHcount; - info.compMaxStack = methodInfo->maxStack; - compHndBBtab = nullptr; - compHndBBtabCount = 0; - compHndBBtabAllocCount = 0; - - info.compNativeCodeSize = 0; - info.compTotalHotCodeSize = 0; - info.compTotalColdCodeSize = 0; - info.compHandleHistogramProbeCount = 0; - - compHasBackwardJump = false; - compHasBackwardJumpInHandler = false; - -#ifdef DEBUG - compCurBB = nullptr; - lvaTable = nullptr; - - // Reset node and block ID counter - compGenTreeID = 0; - compStatementID = 0; - compBasicBlockID = 0; -#endif - -#ifdef TARGET_ARM64 - info.compNeedsConsecutiveRegisters = false; -#endif + info.compScopeHnd = classPtr; + info.compXcptnsCount = methodInfo->EHcount; + info.compMaxStack = methodInfo->maxStack; #ifndef TARGET_WASM /* Initialize emitter */ @@ -7186,8 +7038,6 @@ int Compiler::compCompileHelper(CORINFO_MODULE_HANDLE classPtr, info.compPublishStubParam = opts.jitFlags->IsSet(JitFlags::JIT_FLAG_PUBLISH_SECRET_PARAM); - info.compHasNextCallRetAddr = false; - if (opts.IsReversePInvoke()) { bool unused; @@ -7200,8 +7050,6 @@ int Compiler::compCompileHelper(CORINFO_MODULE_HANDLE classPtr, info.compArgOrder = Target::g_tgtArgOrder; } - info.compIsVarArgs = false; - switch (methodInfo->args.getCallConv()) { case CORINFO_CALLCONV_NATIVEVARARG: @@ -7218,9 +7066,6 @@ int Compiler::compCompileHelper(CORINFO_MODULE_HANDLE classPtr, info.compRetType = impNormStructType(methodInfo->args.retTypeClass); } - info.compUnmanagedCallCountWithGCTransition = 0; - info.compLvFrameListRoot = BAD_VAR_NUM; - info.compInitMem = ((methodInfo->options & CORINFO_OPT_INIT_LOCALS) != 0); /* Allocate the local variable table */ @@ -7283,13 +7128,13 @@ int Compiler::compCompileHelper(CORINFO_MODULE_HANDLE classPtr, { // We're prejitting the root method. We also will analyze it as // a potential inline candidate. - InlineResult prejitResult(this, methodHnd, "prejit"); + InlineResult prejitResult(this, info.compMethodHnd, "prejit"); // Profile data allows us to avoid early "too many IL bytes" outs. prejitResult.NoteBool(InlineObservation::CALLSITE_HAS_PROFILE_WEIGHTS, fgHaveSufficientProfileWeights()); // Do the initial inline screen. - impCanInlineIL(methodHnd, methodInfo, forceInline, &prejitResult); + impCanInlineIL(info.compMethodHnd, methodInfo, forceInline, &prejitResult); // Temporarily install the prejitResult as the // compInlineResult so it's available to fgFindJumpTargets @@ -7466,7 +7311,6 @@ int Compiler::compCompileHelper(CORINFO_MODULE_HANDLE classPtr, } #endif - compMethodID = 0; #ifdef DEBUG /* Give the function a unique number */ @@ -8063,6 +7907,7 @@ int jitNativeCode(CORINFO_METHOD_HANDLE methodHnd, struct Param { Compiler* pComp; + Compiler* pPrevComp; ArenaAllocator* pAlloc; bool jitFallbackCompile; @@ -8081,6 +7926,7 @@ int jitNativeCode(CORINFO_METHOD_HANDLE methodHnd, int result; } param; param.pComp = nullptr; + param.pPrevComp = nullptr; param.pAlloc = pAlloc; param.jitFallbackCompile = jitFallbackCompile; param.methodHnd = methodHnd; @@ -8096,86 +7942,92 @@ int jitNativeCode(CORINFO_METHOD_HANDLE methodHnd, #endif param.result = result; - setErrorTrap(compHnd, Param*, pParamOuter, ¶m){setErrorTrap(nullptr, Param*, pParam, pParamOuter){ - if (pParam->inlineInfo){// Lazily create the inlinee compiler object - if (pParam->inlineInfo->InlinerCompiler->InlineeCompiler == nullptr){ - pParam->inlineInfo->InlinerCompiler->InlineeCompiler = - (Compiler*)pParam->pAlloc->allocateMemory(roundUp(sizeof(*pParam->pComp))); -} + // clang-format off + setErrorTrap(compHnd, Param*, pParamOuter, ¶m) + { + setErrorTrap(nullptr, Param*, pParam, pParamOuter) + { + void* compilerMem; + if (pParam->inlineInfo) + { + // Lazily create the inlinee compiler object + if (pParam->inlineInfo->InlinerCompiler->InlineeCompiler == nullptr) + { + compilerMem = pParam->pAlloc->allocateMemory(sizeof(Compiler)); + pParam->inlineInfo->InlinerCompiler->InlineeCompiler = static_cast(compilerMem); + } + else + { + compilerMem = pParam->inlineInfo->InlinerCompiler->InlineeCompiler; + } + } + else + { + compilerMem = pParam->pAlloc->allocateMemory(sizeof(Compiler)); + } -// Use the inlinee compiler object -pParam->pComp = pParam->inlineInfo->InlinerCompiler->InlineeCompiler; -#ifdef DEBUG -// memset(pParam->pComp, 0xEE, sizeof(Compiler)); -#endif -} -else -{ - // Allocate create the inliner compiler object - pParam->pComp = (Compiler*)pParam->pAlloc->allocateMemory(roundUp(sizeof(*pParam->pComp))); -} + pParam->pComp = new (compilerMem, jitstd::placement_t()) Compiler(pParam->pAlloc, pParam->methodHnd, pParam->compHnd, pParam->methodInfo, pParam->inlineInfo); #if MEASURE_CLRAPI_CALLS -pParam->wrapCLR = WrapICorJitInfo::makeOne(pParam->pAlloc, pParam->pComp, pParam->compHnd); + pParam->wrapCLR = WrapICorJitInfo::makeOne(pParam->pAlloc, pParam->pComp, pParam->compHnd); #endif -// push this compiler on the stack (TLS) -pParam->pComp->prevCompiler = JitTls::GetCompiler(); -JitTls::SetCompiler(pParam->pComp); + // push this compiler on the stack (TLS) + pParam->pPrevComp = JitTls::GetCompiler(); + JitTls::SetCompiler(pParam->pComp); -// PREFIX_ASSUME gets turned into ASSERT_CHECK and we cannot have it here + // PREFIX_ASSUME gets turned into ASSERT_CHECK and we cannot have it here #if defined(_PREFAST_) || defined(_PREFIX_) -PREFIX_ASSUME(pParam->pComp != NULL); + PREFIX_ASSUME(pParam->pComp != NULL); #else -assert(pParam->pComp != nullptr); + assert(pParam->pComp != nullptr); #endif -pParam->pComp->compInit(pParam->pAlloc, pParam->methodHnd, pParam->compHnd, pParam->methodInfo, pParam->inlineInfo); - #ifdef DEBUG -pParam->pComp->jitFallbackCompile = pParam->jitFallbackCompile; + pParam->pComp->jitFallbackCompile = pParam->jitFallbackCompile; #endif -// Now generate the code -pParam->result = - pParam->pComp->compCompile(pParam->classPtr, pParam->methodCodePtr, pParam->methodCodeSize, pParam->compileFlags); -} -finallyErrorTrap() -{ - Compiler* pCompiler = pParamOuter->pComp; + // Now generate the code + pParam->result = + pParam->pComp->compCompile(pParam->classPtr, pParam->methodCodePtr, pParam->methodCodeSize, pParam->compileFlags); + } + finallyErrorTrap() + { + Compiler* pCompiler = pParamOuter->pComp; - // If OOM is thrown when allocating memory for a pComp, we will end up here. - // For this case, pComp and also pCompiler will be a nullptr - // - if (pCompiler != nullptr) - { - pCompiler->info.compCode = nullptr; + // If OOM is thrown when allocating memory for a pComp, we will end up here. + // For this case, pComp and also pCompiler will be a nullptr + // + if (pCompiler != nullptr) + { + pCompiler->info.compCode = nullptr; - // pop the compiler off the TLS stack only if it was linked above - assert(JitTls::GetCompiler() == pCompiler); - JitTls::SetCompiler(pCompiler->prevCompiler); - } + // pop the compiler off the TLS stack only if it was linked above + assert(JitTls::GetCompiler() == pCompiler); + JitTls::SetCompiler(pParamOuter->pPrevComp); + } - if (pParamOuter->inlineInfo == nullptr) - { - // Free up the allocator we were using - pParamOuter->pAlloc->destroy(); + if (pParamOuter->inlineInfo == nullptr) + { + // Free up the allocator we were using + pParamOuter->pAlloc->destroy(); + } + } + endErrorTrap() } -} -endErrorTrap() -} -impJitErrorTrap() -{ - // If we were looking at an inlinee.... - if (inlineInfo != nullptr) + impJitErrorTrap() { - // Note that we failed to compile the inlinee, and that - // there's no point trying to inline it again anywhere else. - inlineInfo->inlineResult->NoteFatal(InlineObservation::CALLEE_COMPILATION_ERROR); + // If we were looking at an inlinee.... + if (inlineInfo != nullptr) + { + // Note that we failed to compile the inlinee, and that + // there's no point trying to inline it again anywhere else. + inlineInfo->inlineResult->NoteFatal(InlineObservation::CALLEE_COMPILATION_ERROR); + } + param.result = __errc; } - param.result = __errc; -} -endErrorTrap() + endErrorTrap() + // clang-format on result = param.result; @@ -9472,8 +9324,7 @@ void JitTimer::PrintCsvMethodStats(Compiler* comp) } else { - const char* methodAssemblyName = comp->info.compCompHnd->getAssemblyName( - comp->info.compCompHnd->getModuleAssembly(comp->info.compCompHnd->getClassModule(comp->info.compClassHnd))); + const char* methodAssemblyName = comp->eeGetClassAssemblyName(comp->info.compClassHnd); fprintf(s_csvFile, "\"%s\",", methodAssemblyName); } fprintf(s_csvFile, "%u,", comp->info.compILCodeSize); diff --git a/src/coreclr/jit/compiler.h b/src/coreclr/jit/compiler.h index 54178141f8c..837240ab0ba 100644 --- a/src/coreclr/jit/compiler.h +++ b/src/coreclr/jit/compiler.h @@ -2635,10 +2635,13 @@ class Compiler */ public: + Compiler(ArenaAllocator* arena, CORINFO_METHOD_HANDLE methodHnd, COMP_HANDLE compHnd, CORINFO_METHOD_INFO* methodInfo, InlineInfo* inlineInfo); + + ArenaAllocator* compArenaAllocator; hashBvGlobalData hbvGlobalData; // Used by the hashBv bitvector package. #ifdef DEBUG - bool verbose; + bool verbose = false; bool verboseTrees; bool shouldUseVerboseTrees(); bool asciiTrees; // If true, dump trees using only ASCII characters @@ -2793,7 +2796,7 @@ class Compiler // 1 for methods with non-nested EH, or where only the try blocks are nested // 2 for a method with a catch within a catch // etc. - unsigned ehMaxHndNestingCount; + unsigned ehMaxHndNestingCount = 0; #endif // FEATURE_EH_WINDOWS_X86 @@ -2920,7 +2923,7 @@ class Compiler // This table is useful for memoization of the method above. typedef JitHashTable, FlowEdge*> BlockToFlowEdgeMap; - BlockToFlowEdgeMap* m_blockToEHPreds; + BlockToFlowEdgeMap* m_blockToEHPreds = nullptr; BlockToFlowEdgeMap* GetBlockToEHPreds() { if (m_blockToEHPreds == nullptr) @@ -2930,7 +2933,7 @@ class Compiler return m_blockToEHPreds; } - BlockToFlowEdgeMap* m_dominancePreds; + BlockToFlowEdgeMap* m_dominancePreds = nullptr; BlockToFlowEdgeMap* GetDominancePreds() { if (m_dominancePreds == nullptr) @@ -3467,7 +3470,6 @@ class Compiler GenTreeHWIntrinsic* gtNewScalarHWIntrinsicNode( var_types type, GenTree* op1, GenTree* op2, GenTree* op3, NamedIntrinsic hwIntrinsicID); CorInfoType getBaseJitTypeFromArgIfNeeded(NamedIntrinsic intrinsic, - CORINFO_CLASS_HANDLE clsHnd, CORINFO_SIG_INFO* sig, CorInfoType simdBaseJitType); @@ -3714,6 +3716,8 @@ class Compiler return callMethodHandle == info.compMethodHnd; } + bool gtCanSkipCovariantStoreCheck(GenTree* value, GenTree* array); + //------------------------------------------------------------------------- GenTree* gtFoldExpr(GenTree* tree); @@ -3854,10 +3858,10 @@ class Compiler // BasicBlock functions #ifdef DEBUG // When false, assert when creating a new basic block. - bool fgSafeBasicBlockCreation; + bool fgSafeBasicBlockCreation = true; // When false, assert when creating a new flow edge - bool fgSafeFlowEdgeCreation; + bool fgSafeFlowEdgeCreation = true; #endif /* @@ -3902,22 +3906,25 @@ class Compiler }; public: - RefCountState lvaRefCountState; // Current local ref count state + RefCountState lvaRefCountState = RCS_INVALID; // Current local ref count state bool lvaLocalVarRefCounted() const { return lvaRefCountState == RCS_NORMAL; } - bool lvaTrackedFixed; // true: We cannot add new 'tracked' variable + // false: we can add new tracked variables. + // true: We cannot add new 'tracked' variable + bool lvaTrackedFixed = false; + unsigned lvaCount; // total number of locals, which includes function arguments, // special arguments, IL local variables, and JIT temporary variables - LclVarDsc* lvaTable; // variable descriptor table + LclVarDsc* lvaTable = nullptr; // variable descriptor table unsigned lvaTableCnt; // lvaTable size (>= lvaCount) - ABIPassingInformation* lvaParameterPassingInfo; - unsigned lvaParameterStackSize; + ABIPassingInformation* lvaParameterPassingInfo = nullptr; + unsigned lvaParameterStackSize = 0; unsigned lvaTrackedCount; // actual # of locals being tracked unsigned lvaTrackedCountInSizeTUnits; // min # of size_t's sufficient to hold a bit for all the locals being tracked @@ -3933,7 +3940,7 @@ class Compiler VARSET_TP lvaMaskVars; // set of mask variables #endif // FEATURE_MASKED_HW_INTRINSICS - unsigned lvaCurEpoch; // VarSets are relative to a specific set of tracked var indices. + unsigned lvaCurEpoch = 0; // VarSets are relative to a specific set of tracked var indices. // It that changes, this changes. VarSets from different epochs // cannot be meaningfully combined. @@ -3943,8 +3950,8 @@ class Compiler } // reverse map of tracked number to var number - unsigned lvaTrackedToVarNumSize; - unsigned* lvaTrackedToVarNum; + unsigned lvaTrackedToVarNumSize = 0; + unsigned* lvaTrackedToVarNum = nullptr; #if DOUBLE_ALIGN #ifdef DEBUG @@ -3967,27 +3974,27 @@ class Compiler void lvaSetVarDoNotEnregister(unsigned varNum DEBUGARG(DoNotEnregisterReason reason)); - unsigned lvaVarargsHandleArg; + unsigned lvaVarargsHandleArg = BAD_VAR_NUM; #ifdef TARGET_X86 - unsigned lvaVarargsBaseOfStkArgs; // Pointer (computed based on incoming varargs handle) to the start of the stack + unsigned lvaVarargsBaseOfStkArgs = BAD_VAR_NUM; // Pointer (computed based on incoming varargs handle) to the start of the stack // arguments #endif // TARGET_X86 - unsigned lvaInlinedPInvokeFrameVar; // variable representing the InlinedCallFrame - unsigned lvaReversePInvokeFrameVar; // variable representing the reverse PInvoke frame - unsigned lvaMonAcquired; // boolean variable introduced into in synchronized methods + unsigned lvaInlinedPInvokeFrameVar = BAD_VAR_NUM; // variable representing the InlinedCallFrame + unsigned lvaReversePInvokeFrameVar = BAD_VAR_NUM; // variable representing the reverse PInvoke frame + unsigned lvaMonAcquired = BAD_VAR_NUM; // boolean variable introduced into in synchronized methods // that tracks whether the lock has been taken - unsigned lvaArg0Var; // The lclNum of arg0. Normally this will be info.compThisArg. + unsigned lvaArg0Var = BAD_VAR_NUM; // The lclNum of arg0. Normally this will be info.compThisArg. // However, if there is a "ldarga 0" or "starg 0" in the IL, // we will redirect all "ldarg(a) 0" and "starg 0" to this temp. - unsigned lvaInlineeReturnSpillTemp; // The temp to spill the non-VOID return expression + unsigned lvaInlineeReturnSpillTemp = BAD_VAR_NUM; // The temp to spill the non-VOID return expression // in case there are multiple BBJ_RETURN blocks in the inlinee // or if the inlinee has GC ref locals. #if FEATURE_FIXED_OUT_ARGS - unsigned lvaOutgoingArgSpaceVar; // var that represents outgoing argument space + unsigned lvaOutgoingArgSpaceVar = BAD_VAR_NUM; // var that represents outgoing argument space PhasedVar lvaOutgoingArgSpaceSize; // size of fixed outgoing argument space #endif // FEATURE_FIXED_OUT_ARGS @@ -3999,28 +4006,28 @@ class Compiler // Variable representing the return address. The helper-based tailcall // mechanism passes the address of the return address to a runtime helper // where it is used to detect tail-call chains. - unsigned lvaRetAddrVar; + unsigned lvaRetAddrVar = BAD_VAR_NUM; #ifdef SWIFT_SUPPORT - unsigned lvaSwiftSelfArg; - unsigned lvaSwiftIndirectResultArg; - unsigned lvaSwiftErrorArg; + unsigned lvaSwiftSelfArg = BAD_VAR_NUM; + unsigned lvaSwiftIndirectResultArg = BAD_VAR_NUM; + unsigned lvaSwiftErrorArg = BAD_VAR_NUM; unsigned lvaSwiftErrorLocal; #endif #if defined(DEBUG) && defined(TARGET_XARCH) - unsigned lvaReturnSpCheck; // Stores SP to confirm it is not corrupted on return. + unsigned lvaReturnSpCheck = BAD_VAR_NUM; // Stores SP to confirm it is not corrupted on return. #endif // defined(DEBUG) && defined(TARGET_XARCH) #if defined(DEBUG) && defined(TARGET_X86) - unsigned lvaCallSpCheck; // Stores SP to confirm it is not corrupted after every call. + unsigned lvaCallSpCheck = BAD_VAR_NUM; // Stores SP to confirm it is not corrupted after every call. #endif // defined(DEBUG) && defined(TARGET_X86) - bool lvaGenericsContextInUse; + bool lvaGenericsContextInUse = false; bool lvaKeepAliveAndReportThis(); // Synchronized instance method of a reference type, or // CORINFO_GENERICS_CTXT_FROM_THIS? @@ -4031,7 +4038,7 @@ class Compiler #if defined(FEATURE_EH_WINDOWS_X86) // This is used for the callable handlers - unsigned lvaShadowSPslotsVar; // Block-layout TYP_STRUCT variable for all the shadow SP slots + unsigned lvaShadowSPslotsVar = BAD_VAR_NUM; // Block-layout TYP_STRUCT variable for all the shadow SP slots #endif // FEATURE_EH_WINDOWS_X86 int lvaCachedGenericContextArgOffs; @@ -4040,11 +4047,11 @@ class Compiler #ifdef JIT32_GCENCODER - unsigned lvaLocAllocSPvar; // variable which stores the value of ESP after the last alloca/localloc + unsigned lvaLocAllocSPvar = BAD_VAR_NUM; // variable which stores the value of ESP after the last alloca/localloc #endif // JIT32_GCENCODER - unsigned lvaNewObjArrayArgs; // variable with arguments for new MD array helper + unsigned lvaNewObjArrayArgs = BAD_VAR_NUM; // variable with arguments for new MD array helper // TODO-Review: Prior to reg predict we reserve 24 bytes for Spill temps. // after the reg predict we will use a computed maxTmpSize @@ -4140,8 +4147,6 @@ class Compiler //------------------------------------------------------------------------- - void lvaInit(); - LclVarDsc* lvaGetDesc(unsigned lclNum) { assert(lclNum < lvaCount); @@ -4357,9 +4362,9 @@ class Compiler } #endif // defined(FEATURE_SIMD) - unsigned lvaGSSecurityCookie; // LclVar number + unsigned lvaGSSecurityCookie = BAD_VAR_NUM; // LclVar number #ifdef TARGET_ARM64 - unsigned lvaFfrRegister; // LclVar number + unsigned lvaFfrRegister = BAD_VAR_NUM; // LclVar number unsigned getFFRegisterVarNum(); #endif bool lvaTempsHaveLargerOffsetThanVars(); @@ -4370,9 +4375,9 @@ class Compiler return lvaGetDesc(lclNum)->lvInSsa; } - unsigned lvaStubArgumentVar; // variable representing the secret stub argument + unsigned lvaStubArgumentVar = BAD_VAR_NUM; // variable representing the secret stub argument - unsigned lvaPSPSym; // variable representing the PSPSym + unsigned lvaPSPSym = BAD_VAR_NUM; // variable representing the PSPSym InlineInfo* impInlineInfo; // Only present for inlinees InlineStrategy* m_inlineStrategy; @@ -4389,8 +4394,8 @@ class Compiler } #endif // defined(DEBUG) - bool fgNoStructPromotion; // Set to TRUE to turn off struct promotion for this method. - bool fgNoStructParamPromotion; // Set to TRUE to turn off struct promotion for parameters this method. + bool fgNoStructPromotion = false; // Set to TRUE to turn off struct promotion for this method. + bool fgNoStructParamPromotion = false; // Set to TRUE to turn off struct promotion for parameters this method. //========================================================================= // PROTECTED @@ -4451,7 +4456,6 @@ class Compiler static bool impOpcodeIsCallOpcode(OPCODE opcode); public: - void impInit(); void impImport(); void impFixPredLists(); @@ -4738,7 +4742,7 @@ class Compiler GenTree* getArgForHWIntrinsic(var_types argType, CORINFO_CLASS_HANDLE argClass); GenTree* impNonConstFallback(NamedIntrinsic intrinsic, var_types simdType, CorInfoType simdBaseJitType); GenTree* addRangeCheckIfNeeded( - NamedIntrinsic intrinsic, GenTree* immOp, bool mustExpand, int immLowerBound, int immUpperBound); + NamedIntrinsic intrinsic, GenTree* immOp, int immLowerBound, int immUpperBound); GenTree* addRangeCheckForHWIntrinsic(GenTree* immOp, int immLowerBound, int immUpperBound); void getHWIntrinsicImmOps(NamedIntrinsic intrinsic, @@ -4789,8 +4793,8 @@ class Compiler //----------------- Manipulating the trees and stmts ---------------------- - Statement* impStmtList; // Statements for the BB being imported. - Statement* impLastStmt; // The last statement for the current BB. + Statement* impStmtList = nullptr; // Statements for the BB being imported. + Statement* impLastStmt = nullptr; // The last statement for the current BB. public: static const unsigned CHECK_SPILL_ALL = static_cast(-1); @@ -5171,8 +5175,6 @@ class Compiler bool impIsImplicitTailCallCandidate( OPCODE curOpcode, const BYTE* codeAddrOfNextOpcode, const BYTE* codeEnd, int prefixFlags, bool isRecursive); - bool impCanSkipCovariantStoreCheck(GenTree* value, GenTree* array); - methodPointerInfo* impAllocateMethodPointerInfo(const CORINFO_RESOLVED_TOKEN& token, mdToken tokenConstrained); /* @@ -5188,51 +5190,51 @@ class Compiler */ public: - BasicBlock* fgFirstBB; // Beginning of the basic block list - BasicBlock* fgLastBB; // End of the basic block list - BasicBlock* fgFirstColdBlock; // First block to be placed in the cold section - BasicBlock* fgEntryBB; // For OSR, the original method's entry point - BasicBlock* fgOSREntryBB; // For OSR, the logical entry point (~ patchpoint) - BasicBlock* fgFirstFuncletBB; // First block of outlined funclets (to allow block insertion before the funclets) - BasicBlock* fgFirstBBScratch; // Block inserted for initialization stuff. Is nullptr if no such block has been + BasicBlock* fgFirstBB = nullptr; // Beginning of the basic block list + BasicBlock* fgLastBB = nullptr; // End of the basic block list + BasicBlock* fgFirstColdBlock = nullptr; // First block to be placed in the cold section + BasicBlock* fgEntryBB = nullptr; // For OSR, the original method's entry point + BasicBlock* fgOSREntryBB = nullptr; // For OSR, the logical entry point (~ patchpoint) + BasicBlock* fgFirstFuncletBB = nullptr; // First block of outlined funclets (to allow block insertion before the funclets) + BasicBlock* fgFirstBBScratch = nullptr; // Block inserted for initialization stuff. Is nullptr if no such block has been // created. - BasicBlockList* fgReturnBlocks; // list of BBJ_RETURN blocks - unsigned fgEdgeCount; // # of control flow edges between the BBs - unsigned fgBBcount; // # of BBs in the method (in the linked list that starts with fgFirstBB) + BasicBlockList* fgReturnBlocks = nullptr; // list of BBJ_RETURN blocks + unsigned fgEdgeCount = 0; // # of control flow edges between the BBs + unsigned fgBBcount = 0; // # of BBs in the method (in the linked list that starts with fgFirstBB) #ifdef DEBUG - jitstd::vector* fgBBOrder; // ordered vector of BBs + jitstd::vector* fgBBOrder = nullptr; // ordered vector of BBs #endif // Used as a quick check for whether phases downstream of loop finding should look for natural loops. // If true: there may or may not be any natural loops in the flow graph, so try to find them // If false: there's definitely not any natural loops in the flow graph - bool fgMightHaveNaturalLoops; + bool fgMightHaveNaturalLoops = false; - unsigned fgBBNumMax; // The max bbNum that has been assigned to basic blocks - unsigned fgDomBBcount; // # of BBs for which we have dominator and reachability information + unsigned fgBBNumMax = 0; // The max bbNum that has been assigned to basic blocks + unsigned fgDomBBcount = 0; // # of BBs for which we have dominator and reachability information BasicBlock** fgBBReversePostorder; // Blocks in reverse postorder - FlowGraphDfsTree* m_dfsTree; + FlowGraphDfsTree* m_dfsTree = nullptr; // The next members are annotations on the flow graph used during the // optimization phases. They are invalidated once RBO runs and modifies the // flow graph. - FlowGraphNaturalLoops* m_loops; - LoopSideEffects* m_loopSideEffects; - BlockToNaturalLoopMap* m_blockToLoop; + FlowGraphNaturalLoops* m_loops = nullptr; + LoopSideEffects* m_loopSideEffects = nullptr; + BlockToNaturalLoopMap* m_blockToLoop = nullptr; // Dominator tree used by SSA construction and copy propagation (the two are expected to use the same tree // in order to avoid the need for SSA reconstruction and an "out of SSA" phase). - FlowGraphDominatorTree* m_domTree; - BlockReachabilitySets* m_reachabilitySets; + FlowGraphDominatorTree* m_domTree = nullptr; + BlockReachabilitySets* m_reachabilitySets = nullptr; // Do we require loops to be in canonical form? The canonical form ensures that: // 1. All loops have preheaders (single entry blocks that always enter the loop) // 2. All loop exits where bbIsHandlerBeg(exit) is false have only loop predecessors. // - bool optLoopsCanonical; + bool optLoopsCanonical = false; - bool fgBBVarSetsInited; + bool fgBBVarSetsInited = false; // Track how many artificial ref counts we've added to fgEntryBB (for OSR) - unsigned fgEntryBBExtraRefs; + unsigned fgEntryBBExtraRefs = 0; // Allocate array like T* a = new T[fgBBNumMax + 1]; // Using helper so we don't keep forgetting +1. @@ -5249,7 +5251,7 @@ class Compiler // participate in a block set until the blocks are all renumbered, causing the epoch // to change. This is useful if continuing to use previous block sets is valuable. // If the epoch is zero, then it is uninitialized, and block sets can't be used. - unsigned fgCurBBEpoch; + unsigned fgCurBBEpoch = 0; unsigned GetCurBasicBlockEpoch() { @@ -5259,11 +5261,11 @@ class Compiler // The number of basic blocks in the current epoch. When the blocks are renumbered, // this is fgBBcount. As blocks are added, fgBBcount increases, fgCurBBEpochSize remains // the same, until a new BasicBlock epoch is created, such as when the blocks are all renumbered. - unsigned fgCurBBEpochSize; + unsigned fgCurBBEpochSize = 0; // The number of "size_t" elements required to hold a bitset large enough for fgCurBBEpochSize // bits. This is precomputed to avoid doing math every time BasicBlockBitSetTraits::GetArrSize() is called. - unsigned fgBBSetCountInSizeTUnits; + unsigned fgBBSetCountInSizeTUnits = 0; void NewBasicBlockEpoch() { @@ -5334,6 +5336,8 @@ class Compiler unsigned xcptnIndex, bool putInTryRegion); + BasicBlock* fgNewBBatTryRegionEnd(BBKinds jumpKind, unsigned tryIndex); + void fgInsertBBbefore(BasicBlock* insertBeforeBlk, BasicBlock* newBlk); void fgInsertBBafter(BasicBlock* insertAfterBlk, BasicBlock* newBlk); void fgUnlinkBlock(BasicBlock* block); @@ -5343,15 +5347,15 @@ class Compiler unsigned fgMeasureIR(); #endif // FEATURE_JIT_METHOD_PERF - bool fgModified; // True if the flow graph has been modified recently - bool fgPredsComputed; // Have we computed the bbPreds list - bool fgOptimizedFinally; // Did we optimize any try-finallys? + bool fgModified = false; // True if the flow graph has been modified recently + bool fgPredsComputed = false; // Have we computed the bbPreds list + bool fgOptimizedFinally = false; // Did we optimize any try-finallys? - bool fgHasSwitch; // any BBJ_SWITCH jumps? + bool fgHasSwitch = false; // any BBJ_SWITCH jumps? - bool fgRemoveRestOfBlock; // true if we know that we will throw - bool fgHasNoReturnCall; // true if statement we morphed had a no-return call - bool fgStmtRemoved; // true if we remove statements -> need new DFA + bool fgRemoveRestOfBlock = false; // true if we know that we will throw + bool fgHasNoReturnCall = false; // true if statement we morphed had a no-return call + bool fgStmtRemoved = false; // true if we remove statements -> need new DFA enum FlowGraphOrder { @@ -5363,7 +5367,7 @@ class Compiler // each tree and sub-tree are contiguous, and can be traversed (in gtNext/gtPrev order) // by traversing the tree according to the order of the operands. // - In FGOrderLinear, the dominant ordering is the linear order. - FlowGraphOrder fgOrder; + FlowGraphOrder fgOrder = FGOrderTree; // The following are flags that keep track of the state of internal data structures @@ -5385,18 +5389,18 @@ class Compiler // // - Rationalization links all nodes into linear form which is kept until // the end of compilation. The first and last nodes are stored in the block. - NodeThreading fgNodeThreading; + NodeThreading fgNodeThreading = NodeThreading::None; bool fgCanRelocateEHRegions; // true if we are allowed to relocate the EH regions - weight_t fgCalledCount; // count of the number of times this method was called + weight_t fgCalledCount = BB_ZERO_WEIGHT; // count of the number of times this method was called // This is derived from the profile data // or is BB_UNITY_WEIGHT when we don't have profile data - bool fgFuncletsCreated; // true if the funclet creation phase has been run + bool fgFuncletsCreated = false; // true if the funclet creation phase has been run - bool fgGlobalMorph; // indicates if we are during the global morphing phase + bool fgGlobalMorph = false; // indicates if we are during the global morphing phase // since fgMorphTree can be called from several places - bool fgGlobalMorphDone; + bool fgGlobalMorphDone = false; bool impBoxTempInUse; // the temp below is valid and available unsigned impBoxTemp; // a temporary that is used for boxing @@ -5407,16 +5411,14 @@ class Compiler #endif #if defined(DEBUG) - unsigned impInlinedCodeSize; - bool fgPrintInlinedMethods; + unsigned impInlinedCodeSize = 0; + bool fgPrintInlinedMethods = false; #endif - jitstd::vector* fgPredListSortVector; + jitstd::vector* fgPredListSortVector = nullptr; //------------------------------------------------------------------------- - void fgInit(); - PhaseStatus fgImport(); PhaseStatus fgTransformIndirectCalls(); @@ -5456,8 +5458,8 @@ class Compiler bool fgMoreThanOneReturnBlock(); // The number of separate return points in the method. - unsigned fgReturnCount; - unsigned fgThrowCount; + unsigned fgReturnCount = 0; + unsigned fgThrowCount = 0; PhaseStatus fgAddInternal(); @@ -5584,7 +5586,7 @@ class Compiler // This field keep the R2R helper call that would be inserted to trigger the constructor // of the static class. It is set as nongc or gc static base if they are imported, so // CSE can eliminate the repeated call, or the chepeast helper function that triggers it. - CorInfoHelpFunc m_preferredInitCctor; + CorInfoHelpFunc m_preferredInitCctor = CORINFO_HELP_UNDEF; void fgSetPreferredInitCctor(); GenTree* fgInitThisClass(); @@ -5675,7 +5677,7 @@ class Compiler // This array, managed by the SSA numbering infrastructure, keeps "outlined composite SSA numbers". // See "SsaNumInfo::GetNum" for more details on when this is needed. - JitExpandArrayStack* m_outlinedCompositeSsaNums; + JitExpandArrayStack* m_outlinedCompositeSsaNums = nullptr; // This map tracks nodes whose value numbers explicitly or implicitly depend on memory states. // The map provides the entry block of the most closely enclosing loop that @@ -5691,7 +5693,7 @@ class Compiler // and so memory does not constrain hoisting. // typedef JitHashTable, BasicBlock*> NodeToLoopMemoryBlockMap; - NodeToLoopMemoryBlockMap* m_nodeToLoopMemoryBlockMap; + NodeToLoopMemoryBlockMap* m_nodeToLoopMemoryBlockMap = nullptr; NodeToLoopMemoryBlockMap* GetNodeToLoopMemoryBlockMap() { if (m_nodeToLoopMemoryBlockMap == nullptr) @@ -5702,7 +5704,7 @@ class Compiler } typedef JitHashTable, CORINFO_RUNTIME_LOOKUP> SignatureToLookupInfoMap; - SignatureToLookupInfoMap* m_signatureToLookupInfoMap; + SignatureToLookupInfoMap* m_signatureToLookupInfoMap = nullptr; SignatureToLookupInfoMap* GetSignatureToLookupInfoMap() { if (m_signatureToLookupInfoMap == nullptr) @@ -5715,14 +5717,44 @@ class Compiler const StructSegments& GetSignificantSegments(ClassLayout* layout); typedef JitHashTable, class StructSegments*> ClassLayoutStructSegmentsMap; - ClassLayoutStructSegmentsMap* m_significantSegmentsMap; + ClassLayoutStructSegmentsMap* m_significantSegmentsMap = nullptr; #ifdef SWIFT_SUPPORT typedef JitHashTable, CORINFO_SWIFT_LOWERING*> SwiftLoweringMap; - SwiftLoweringMap* m_swiftLoweringCache; + SwiftLoweringMap* m_swiftLoweringCache = nullptr; const CORINFO_SWIFT_LOWERING* GetSwiftLowering(CORINFO_CLASS_HANDLE clsHnd); #endif +#if defined(TARGET_X86) && defined(FEATURE_IJW) + bool* m_specialCopyArgs = nullptr; + bool recordArgRequiresSpecialCopy(unsigned argNum) + { + if (argNum >= info.compArgsCount) + { + return false; + } + + if (m_specialCopyArgs == nullptr) + { + m_specialCopyArgs = new (getAllocator()) bool[info.compArgsCount]; + memset(m_specialCopyArgs, 0, info.compArgsCount * sizeof(bool)); + } + + m_specialCopyArgs[argNum] = true; + return true; + } + + bool argRequiresSpecialCopy(unsigned argNum) + { + return argNum < info.compArgsCount && m_specialCopyArgs != nullptr && m_specialCopyArgs[argNum]; + } + + bool compHasSpecialCopyArgs() + { + return m_specialCopyArgs != nullptr; + } +#endif + void optRecordLoopMemoryDependence(GenTree* tree, BasicBlock* block, ValueNum memoryVN); void optCopyLoopMemoryDependence(GenTree* fromTree, GenTree* toTree); @@ -5734,8 +5766,8 @@ class Compiler // Reset any data structures to the state expected by "fgSsaBuild", so it can be run again. void fgResetForSsa(); - unsigned fgSsaPassesCompleted; // Number of times fgSsaBuild has been run. - bool fgSsaValid; // True if SSA info is valid and can be cross-checked versus IR + unsigned fgSsaPassesCompleted = 0; // Number of times fgSsaBuild has been run. + bool fgSsaValid = false; // True if SSA info is valid and can be cross-checked versus IR #ifdef DEBUG void DumpSsaSummary(); @@ -5748,7 +5780,7 @@ class Compiler inline bool fgVarNeedsExplicitZeroInit(unsigned varNum, bool bbInALoop, bool bbIsReturn); // The value numbers for this compilation. - ValueNumStore* vnStore; + ValueNumStore* vnStore = nullptr; class ValueNumberState* vnState; public: @@ -5784,7 +5816,7 @@ class Compiler // Compute the value number for a byref-exposed load of the given type via the given pointerVN. ValueNum fgValueNumberByrefExposedLoad(var_types type, ValueNum pointerVN); - unsigned fgVNPassesCompleted; // Number of times fgValueNumber has been run. + unsigned fgVNPassesCompleted = 0; // Number of times fgValueNumber has been run. // Utility functions for fgValueNumber. @@ -6075,7 +6107,7 @@ class Compiler private: // Maps BasicBlock*'s that end in switch statements to SwitchUniqueSuccSets that allow // iteration over only the distinct successors. - BlockToSwitchDescMap* m_switchDescMap; + BlockToSwitchDescMap* m_switchDescMap = nullptr; public: BlockToSwitchDescMap* GetSwitchDescMap(bool createIfNull = true) @@ -6104,8 +6136,6 @@ class Compiler BasicBlock* fgFirstBlockOfHandler(BasicBlock* block); - bool fgIsFirstBlockOfFilterOrHandler(BasicBlock* block); - FlowEdge* fgGetPredForBlock(BasicBlock* block, BasicBlock* blockPred); FlowEdge* fgGetPredForBlock(BasicBlock* block, BasicBlock* blockPred, FlowEdge*** ptrToPred); @@ -6456,9 +6486,9 @@ class Compiler bool fgHaveProfileWeights(); bool fgGetProfileWeightForBasicBlock(IL_OFFSET offset, weight_t* weight); - Instrumentor* fgCountInstrumentor; - Instrumentor* fgHistogramInstrumentor; - Instrumentor* fgValueInstrumentor; + Instrumentor* fgCountInstrumentor = nullptr; + Instrumentor* fgHistogramInstrumentor = nullptr; + Instrumentor* fgValueInstrumentor = nullptr; PhaseStatus fgPrepareToInstrumentMethod(); PhaseStatus fgInstrumentMethod(); @@ -6468,20 +6498,20 @@ class Compiler public: const char* fgPgoFailReason; - bool fgPgoDisabled; + bool fgPgoDisabled = false; ICorJitInfo::PgoSource fgPgoSource; - ICorJitInfo::PgoInstrumentationSchema* fgPgoSchema; - BYTE* fgPgoData; - UINT32 fgPgoSchemaCount; + ICorJitInfo::PgoInstrumentationSchema* fgPgoSchema = nullptr; + BYTE* fgPgoData = nullptr; + UINT32 fgPgoSchemaCount = 0; HRESULT fgPgoQueryResult; - UINT32 fgNumProfileRuns; - UINT32 fgPgoBlockCounts; - UINT32 fgPgoEdgeCounts; - UINT32 fgPgoClassProfiles; - UINT32 fgPgoMethodProfiles; - unsigned fgPgoInlineePgo; - unsigned fgPgoInlineeNoPgo; - unsigned fgPgoInlineeNoPgoSingleBlock; + UINT32 fgNumProfileRuns = 0; + UINT32 fgPgoBlockCounts = 0; + UINT32 fgPgoEdgeCounts = 0; + UINT32 fgPgoClassProfiles = 0; + UINT32 fgPgoMethodProfiles = 0; + unsigned fgPgoInlineePgo = 0; + unsigned fgPgoInlineeNoPgo = 0; + unsigned fgPgoInlineeNoPgoSingleBlock = 0; bool fgPgoHaveWeights; bool fgPgoSynthesized; bool fgPgoDynamic; @@ -6512,6 +6542,8 @@ class Compiler return fgIsUsingProfileWeights() ? fgNumProfileRuns : BB_UNITY_WEIGHT_UNSIGNED; } + void fgRemoveProfileData(const char* reason); + //-------- Insert a statement at the start or end of a basic block -------- #ifdef DEBUG @@ -6560,7 +6592,7 @@ class Compiler //------------------------- Morphing -------------------------------------- - unsigned fgPtrArgCntMax; + unsigned fgPtrArgCntMax = 0; public: //------------------------------------------------------------------------ @@ -6589,7 +6621,7 @@ class Compiler private: hashBv* fgAvailableOutgoingArgTemps; - ArrayStack* fgUsedSharedTemps; + ArrayStack* fgUsedSharedTemps = nullptr; void fgSetRngChkTarget(GenTree* tree, bool delay = true); @@ -6635,7 +6667,7 @@ class Compiler // fgPreviousCandidateSIMDFieldStoreStmt is only used for tracking previous simd field store // in function: Compiler::impMarkContiguousSIMDFieldStores. - Statement* fgPreviousCandidateSIMDFieldStoreStmt; + Statement* fgPreviousCandidateSIMDFieldStoreStmt = nullptr; #endif // FEATURE_SIMD GenTree* fgMorphIndexAddr(GenTreeIndexAddr* tree); @@ -6824,16 +6856,22 @@ class Compiler AddCodeDscMap* fgGetAddCodeDscMap(); private: - AddCodeDsc* fgAddCodeList; - bool fgRngChkThrowAdded; - AddCodeDscMap* fgAddCodeDscMap; +#if !defined(TARGET_WASM) + static unsigned acdHelper(SpecialCodeKind codeKind); +#endif + + AddCodeDsc* fgAddCodeList = nullptr; + bool fgRngChkThrowAdded = false; + AddCodeDscMap* fgAddCodeDscMap = nullptr; void fgAddCodeRef(BasicBlock* srcBlk, SpecialCodeKind kind); PhaseStatus fgCreateThrowHelperBlocks(); public: +#if defined(TARGET_WASM) // Accessed in llvmcodegen.cpp static unsigned acdHelper(SpecialCodeKind codeKind); +#endif AddCodeDsc* fgFindExcptnTarget(SpecialCodeKind kind, unsigned refData); @@ -6937,8 +6975,6 @@ class Compiler */ public: - void optInit(); - PhaseStatus rangeCheckPhase(); GenTree* optRemoveRangeCheck(GenTreeBoundsChk* check, GenTree* comma, Statement* stmt); GenTree* optRemoveStandaloneRangeCheck(GenTreeBoundsChk* check, Statement* stmt); @@ -7055,8 +7091,6 @@ class Compiler void optCompactLoops(); void optCompactLoop(FlowGraphNaturalLoop* loop); - BasicBlock* optFindLoopCompactionInsertionPoint(FlowGraphNaturalLoop* loop, BasicBlock* top); - BasicBlock* optTryAdvanceLoopCompactionInsertionPoint(FlowGraphNaturalLoop* loop, BasicBlock* insertionPoint, BasicBlock* top, BasicBlock* bottom); bool optCreatePreheader(FlowGraphNaturalLoop* loop); void optSetWeightForPreheaderOrExit(FlowGraphNaturalLoop* loop, BasicBlock* block); @@ -7073,12 +7107,12 @@ class Compiler PhaseStatus optIfConversion(); // If conversion public: - bool fgHasLoops; + bool fgHasLoops = false; protected: - unsigned optCallCount; // number of calls made in the method - unsigned optIndirectCallCount; // number of virtual, interface and indirect calls made in the method - unsigned optNativeCallCount; // number of Pinvoke/Native calls made in the method + unsigned optCallCount = 0; // number of calls made in the method + unsigned optIndirectCallCount = 0; // number of virtual, interface and indirect calls made in the method + unsigned optNativeCallCount = 0; // number of Pinvoke/Native calls made in the method #ifdef DEBUG void optCheckPreds(); @@ -7299,14 +7333,14 @@ class Compiler GenTree* optExtractSideEffectsForCSE(GenTree* tree); bool optDoCSE; // True when we have found a duplicate CSE tree - bool optValnumCSE_phase; // True when we are executing the optOptimizeValnumCSEs() phase - unsigned optCSECandidateCount; // Count of CSE candidates - unsigned optCSEstart; // The first local variable number that is a CSE - unsigned optCSEattempt; // The number of CSEs attempted so far. - unsigned optCSEcount; // The total count of CSEs introduced. - unsigned optCSEunmarks; // Number of CSE trees unmarked + bool optValnumCSE_phase = false; // True when we are executing the optOptimizeValnumCSEs() phase + unsigned optCSECandidateCount = 0; // Count of CSE candidates + unsigned optCSEstart = BAD_VAR_NUM; // The first local variable number that is a CSE + unsigned optCSEattempt = 0; // The number of CSEs attempted so far. + unsigned optCSEcount = 0; // The total count of CSEs introduced. + unsigned optCSEunmarks = 0; // Number of CSE trees unmarked weight_t optCSEweight; // The weight of the current block when we are doing PerformCSE - CSE_HeuristicCommon* optCSEheuristic; // CSE Heuristic to use for this method + CSE_HeuristicCommon* optCSEheuristic = nullptr; // CSE Heuristic to use for this method bool optIsCSEcandidate(GenTree* tree, bool isReturn = false); @@ -7596,7 +7630,7 @@ class Compiler optMethodFlags |= OMF_HAS_PARTIAL_COMPILATION_PATCHPOINT; } - unsigned optMethodFlags; + unsigned optMethodFlags = 0; bool doesMethodHaveNoReturnCalls() { @@ -7616,7 +7650,7 @@ class Compiler setMethodHasNoReturnCalls(); } - unsigned optNoReturnCallCount; + unsigned optNoReturnCallCount = 0; // Recursion bound controls how far we can go backwards tracking for a SSA value. // No throughput diff was found with backward walk bound between 3-8. @@ -7997,10 +8031,10 @@ class Compiler GenTree* optAssertionPropCurrentTree; #endif AssertionIndex* optComplementaryAssertionMap; - JitExpandArray* optAssertionDep; // table that holds dependent assertions (assertions - // using the value of a local var) for each local var - AssertionDsc* optAssertionTabPrivate; // table that holds info about assertions - AssertionIndex optAssertionCount; // total number of assertions in the assertion table + JitExpandArray* optAssertionDep = nullptr; // table that holds dependent assertions (assertions + // using the value of a local var) for each local var + AssertionDsc* optAssertionTabPrivate; // table that holds info about assertions + AssertionIndex optAssertionCount = 0; // total number of assertions in the assertion table AssertionIndex optMaxAssertionCount; bool optCrossBlockLocalAssertionProp; unsigned optAssertionOverflow; @@ -8286,7 +8320,9 @@ class Compiler bool eeIsIntrinsic(CORINFO_METHOD_HANDLE ftn); bool eeIsFieldStatic(CORINFO_FIELD_HANDLE fldHnd); - var_types eeGetFieldType(CORINFO_FIELD_HANDLE fldHnd, CORINFO_CLASS_HANDLE* pStructHnd = nullptr); + var_types eeGetFieldType(CORINFO_FIELD_HANDLE fldHnd, + CORINFO_CLASS_HANDLE* pStructHnd = nullptr, + CORINFO_CLASS_HANDLE memberParent = NO_CLASS_HANDLE); template void eeAppendPrint(class StringPrinter* printer, TPrint print); @@ -8327,6 +8363,8 @@ class Compiler void eePrintObjectDescription(const char* prefix, CORINFO_OBJECT_HANDLE handle); const char* eeGetShortClassName(CORINFO_CLASS_HANDLE clsHnd); + const char* eeGetClassAssemblyName(CORINFO_CLASS_HANDLE clsHnd); + #if defined(DEBUG) unsigned eeTryGetClassSize(CORINFO_CLASS_HANDLE clsHnd); #endif @@ -8355,7 +8393,7 @@ class Compiler void eeGetMethodSig(CORINFO_METHOD_HANDLE methHnd, CORINFO_SIG_INFO* retSig, CORINFO_CLASS_HANDLE owner = nullptr); CORINFO_EE_INFO eeInfo; - bool eeInfoInitialized; + bool eeInfoInitialized = false; CORINFO_EE_INFO* eeGetEEInfo(); @@ -8446,7 +8484,7 @@ class Compiler regMaskTP regMask; }; - VirtualStubParamInfo* virtualStubParamInfo; + VirtualStubParamInfo* virtualStubParamInfo = nullptr; bool IsTargetAbi(CORINFO_RUNTIME_ABI abi) { @@ -8470,7 +8508,7 @@ class Compiler } #if defined(FEATURE_EH_WINDOWS_X86) - bool eeIsNativeAotAbi; + bool eeIsNativeAotAbi = false; bool UsesFunclets() const { return eeIsNativeAotAbi; @@ -8646,7 +8684,7 @@ class Compiler #endif // TARGET_WASM #ifndef TARGET_WASM - CodeGenInterface* codeGen; + CodeGenInterface* codeGen = nullptr; // Record the instr offset mapping to the generated code @@ -8668,12 +8706,12 @@ class Compiler typedef JitHashTable, DebugInfo> CallSiteDebugInfoTable; CallSiteDebugInfoTable* genCallSite2DebugInfoMap; - unsigned genReturnLocal; // Local number for the return value when applicable. - BasicBlock* genReturnBB; // jumped to when not optimizing for speed. + unsigned genReturnLocal = BAD_VAR_NUM; // Local number for the return value when applicable. + BasicBlock* genReturnBB = nullptr; // jumped to when not optimizing for speed. #ifdef SWIFT_SUPPORT - unsigned genReturnErrorLocal; // Local number for the Swift error value when applicable. -#endif // SWIFT_SUPPORT + unsigned genReturnErrorLocal = BAD_VAR_NUM; // Local number for the Swift error value when applicable. +#endif // SWIFT_SUPPORT // The following properties are part of CodeGenContext. Getters are provided here for // convenience and backward compatibility, but the properties can only be set by invoking @@ -9032,7 +9070,7 @@ class Compiler // This is a temp lclVar allocated on the stack as TYP_SIMD. It is used to implement intrinsics // that require indexed access to the individual fields of the vector, which is not well supported // by the hardware. It is allocated when/if such situations are encountered during Lowering. - unsigned lvaSIMDInitTempVarNum; + unsigned lvaSIMDInitTempVarNum = BAD_VAR_NUM; struct SIMDHandlesCache { @@ -9049,7 +9087,7 @@ class Compiler } }; - SIMDHandlesCache* m_simdHandleCache; + SIMDHandlesCache* m_simdHandleCache = nullptr; // Returns true if this is a SIMD type that should be considered an opaque // vector type (i.e. do not analyze or promote its fields). @@ -9907,26 +9945,26 @@ class Compiler */ public: - Compiler* InlineeCompiler; // The Compiler instance for the inlinee + Compiler* InlineeCompiler = nullptr; // The Compiler instance for the inlinee InlineResult* compInlineResult; // The result of importing the inlinee method. - bool compDoAggressiveInlining; // If true, mark every method as CORINFO_FLG_FORCEINLINE - bool compJmpOpUsed; // Does the method do a JMP - bool compLongUsed; // Does the method use TYP_LONG - bool compFloatingPointUsed; // Does the method use TYP_FLOAT or TYP_DOUBLE - bool compTailCallUsed; // Does the method do a tailcall - bool compTailPrefixSeen; // Does the method IL have tail. prefix - bool compLocallocSeen; // Does the method IL have localloc opcode - bool compLocallocUsed; // Does the method use localloc. - bool compLocallocOptimized; // Does the method have an optimized localloc - bool compQmarkUsed; // Does the method use GT_QMARK/GT_COLON - bool compQmarkRationalized; // Is it allowed to use a GT_QMARK/GT_COLON node. - bool compHasBackwardJump; // Does the method (or some inlinee) have a lexically backwards jump? - bool compHasBackwardJumpInHandler; // Does the method have a lexically backwards jump in a handler? - bool compSwitchedToOptimized; // Codegen initially was Tier0 but jit switched to FullOpts - bool compSwitchedToMinOpts; // Codegen initially was Tier1/FullOpts but jit switched to MinOpts - bool compSuppressedZeroInit; // There are vars with lvSuppressedZeroInit set + bool compDoAggressiveInlining = false; // If true, mark every method as CORINFO_FLG_FORCEINLINE + bool compJmpOpUsed = false; // Does the method do a JMP + bool compLongUsed = false; // Does the method use TYP_LONG + bool compFloatingPointUsed = false; // Does the method use TYP_FLOAT or TYP_DOUBLE + bool compTailCallUsed = false; // Does the method do a tailcall + bool compTailPrefixSeen = false; // Does the method IL have tail. prefix + bool compLocallocSeen = false; // Does the method IL have localloc opcode + bool compLocallocUsed = false; // Does the method use localloc. + bool compLocallocOptimized = false; // Does the method have an optimized localloc + bool compQmarkUsed = false; // Does the method use GT_QMARK/GT_COLON + bool compQmarkRationalized = false; // Is it allowed to use a GT_QMARK/GT_COLON node. + bool compHasBackwardJump = false; // Does the method (or some inlinee) have a lexically backwards jump? + bool compHasBackwardJumpInHandler = false; // Does the method have a lexically backwards jump in a handler? + bool compSwitchedToOptimized = false; // Codegen initially was Tier0 but jit switched to FullOpts + bool compSwitchedToMinOpts = false; // Codegen initially was Tier1/FullOpts but jit switched to MinOpts + bool compSuppressedZeroInit = false; // There are vars with lvSuppressedZeroInit set // NOTE: These values are only reliable after // the importing is completely finished. @@ -9935,33 +9973,33 @@ class Compiler // State information - which phases have completed? // These are kept together for easy discoverability - bool compAllowStress; - bool compCodeGenDone; - int64_t compNumStatementLinksTraversed; // # of links traversed while doing debug checks - bool fgNormalizeEHDone; // Has the flowgraph EH normalization phase been done? - size_t compSizeEstimate; // The estimated size of the method as per `gtSetEvalOrder`. - size_t compCycleEstimate; // The estimated cycle count of the method as per `gtSetEvalOrder` - bool compPoisoningAnyImplicitByrefs; // Importer inserted IR before returns to poison implicit byrefs + bool compAllowStress = true; + bool compCodeGenDone = false; + int64_t compNumStatementLinksTraversed = 0; // # of links traversed while doing debug checks + bool fgNormalizeEHDone = false; // Has the flowgraph EH normalization phase been done? + size_t compSizeEstimate; // The estimated size of the method as per `gtSetEvalOrder`. + size_t compCycleEstimate; // The estimated cycle count of the method as per `gtSetEvalOrder` + bool compPoisoningAnyImplicitByrefs = false; // Importer inserted IR before returns to poison implicit byrefs #endif // DEBUG - bool fgLocalVarLivenessDone; // Note that this one is used outside of debug. + bool fgLocalVarLivenessDone = false; // Note that this one is used outside of debug. bool fgLocalVarLivenessChanged; - bool fgIsDoingEarlyLiveness; - bool fgDidEarlyLiveness; - bool compPostImportationCleanupDone; - bool compLSRADone; - bool compRationalIRForm; - - bool compUsesThrowHelper; // There is a call to a THROW_HELPER for the compiled method. - - bool compGeneratingProlog; - bool compGeneratingEpilog; - bool compGeneratingUnwindProlog; - bool compGeneratingUnwindEpilog; - bool compNeedsGSSecurityCookie; // There is an unsafe buffer (or localloc) on the stack. - // Insert cookie on frame and code to check the cookie, like VC++ -GS. - bool compGSReorderStackLayout; // There is an unsafe buffer on the stack, reorder locals and make local + bool fgIsDoingEarlyLiveness = false; + bool fgDidEarlyLiveness = false; + bool compPostImportationCleanupDone = false; + bool compLSRADone = false; + bool compRationalIRForm = false; + + bool compUsesThrowHelper = false; // There is a call to a THROW_HELPER for the compiled method. + + bool compGeneratingProlog = false; + bool compGeneratingEpilog = false; + bool compGeneratingUnwindProlog = false; + bool compGeneratingUnwindEpilog = false; + bool compNeedsGSSecurityCookie = false; // There is an unsafe buffer (or localloc) on the stack. + // Insert cookie on frame and code to check the cookie, like VC++ -GS. + bool compGSReorderStackLayout = false; // There is an unsafe buffer on the stack, reorder locals and make local // copies of susceptible parameters to avoid buffer overrun attacks through locals/params bool getNeedsGSSecurityCookie() const { @@ -9976,9 +10014,9 @@ class Compiler compNeedsGSSecurityCookie = true; } - FrameLayoutState lvaDoneFrameLayout; // The highest frame layout state that we've completed. During - // frame layout calculations, this is the level we are currently - // computing. + FrameLayoutState lvaDoneFrameLayout = NO_FRAME_LAYOUT; // The highest frame layout state that we've completed. + // During frame layout calculations, this is the level we are + // currently computing. //---------------------------- JITing options ----------------------------- @@ -10012,7 +10050,7 @@ class Compiler } unsigned compFlags; // method attributes - unsigned instrCount; + unsigned instrCount = 0; unsigned lvRefCount; codeOptimize compCodeOpt; // what type of code optimizations @@ -10035,9 +10073,9 @@ class Compiler bool canUseTier0Opts; bool canUseAllOpts; bool compMinOpts; - bool compMinOptsIsSet; + bool compMinOptsIsSet = false; #ifdef DEBUG - mutable bool compMinOptsIsUsed; + mutable bool compMinOptsIsUsed = false; bool MinOpts() const { @@ -10613,17 +10651,17 @@ class Compiler #if defined(DEBUG) || defined(LATE_DISASM) || DUMP_FLOWGRAPHS || DUMP_GC_TABLES - const char* compMethodName; - const char* compClassName; - const char* compFullName; - int compMethodSuperPMIIndex; // useful when debugging under SuperPMI + const char* compMethodName = nullptr; + const char* compClassName = nullptr; + const char* compFullName = nullptr; + int compMethodSuperPMIIndex = -1; // useful when debugging under SuperPMI #endif // defined(DEBUG) || defined(LATE_DISASM) || DUMP_FLOWGRAPHS #if defined(DEBUG) // Method hash is logically const, but computed // on first demand. - mutable unsigned compMethodHashPrivate; + mutable unsigned compMethodHashPrivate = 0; unsigned compMethodHash() const; #endif // defined(DEBUG) @@ -10640,11 +10678,11 @@ class Compiler unsigned compClassAttr; const BYTE* compCode; - IL_OFFSET compILCodeSize; // The IL code size - IL_OFFSET compILImportSize; // Estimated amount of IL actually imported - IL_OFFSET compILEntry; // The IL entry point (normally 0) - PatchpointInfo* compPatchpointInfo; // Patchpoint data for OSR (normally nullptr) - UNATIVE_OFFSET compNativeCodeSize; // The native code size, after instructions are issued. This + IL_OFFSET compILCodeSize; // The IL code size + IL_OFFSET compILImportSize; // Estimated amount of IL actually imported + IL_OFFSET compILEntry; // The IL entry point (normally 0) + PatchpointInfo* compPatchpointInfo; // Patchpoint data for OSR (normally nullptr) + UNATIVE_OFFSET compNativeCodeSize = 0; // The native code size, after instructions are issued. This // is less than (compTotalHotCodeSize + compTotalColdCodeSize) only if: // (1) the code is not hot/cold split, and we issued less code than we expected, or // (2) the code is hot/cold split, and we issued less code than we expected @@ -10673,24 +10711,24 @@ class Compiler unsigned compILlocalsCount; // Number of vars : args + locals (incl. implicit but not hidden) unsigned compLocalsCount; // Number of vars : args + locals (incl. implicit and hidden) unsigned compMaxStack; - UNATIVE_OFFSET compTotalHotCodeSize; // Total number of bytes of Hot Code in the method - UNATIVE_OFFSET compTotalColdCodeSize; // Total number of bytes of Cold Code in the method + UNATIVE_OFFSET compTotalHotCodeSize = 0; // Total number of bytes of Hot Code in the method + UNATIVE_OFFSET compTotalColdCodeSize = 0; // Total number of bytes of Cold Code in the method - unsigned compUnmanagedCallCountWithGCTransition; // count of unmanaged calls with GC transition. + unsigned compUnmanagedCallCountWithGCTransition = 0; // count of unmanaged calls with GC transition. CorInfoCallConvExtension compCallConv; // The entry-point calling convention for this method. - unsigned compLvFrameListRoot; // lclNum for the Frame root - unsigned compXcptnsCount; // Number of exception-handling clauses read in the method's IL. - // You should generally use compHndBBtabCount instead: it is the - // current number of EH clauses (after additions like synchronized + unsigned compLvFrameListRoot = BAD_VAR_NUM; // lclNum for the Frame root + unsigned compXcptnsCount; // Number of exception-handling clauses read in the method's IL. + // You should generally use compHndBBtabCount instead: it is the + // current number of EH clauses (after additions like synchronized // methods and funclets, and removals like unreachable code deletion). Target::ArgOrder compArgOrder; - bool compMatchedVM; // true if the VM is "matched": either the JIT is a cross-compiler - // and the VM expects that, or the JIT is a "self-host" compiler - // (e.g., x86 hosted targeting x86) and the VM expects that. + bool compMatchedVM = true; // true if the VM is "matched": either the JIT is a cross-compiler + // and the VM expects that, or the JIT is a "self-host" compiler + // (e.g., x86 hosted targeting x86) and the VM expects that. /* The following holds IL scope information about local variables. */ @@ -10707,10 +10745,10 @@ class Compiler ICorDebugInfo::BoundaryTypes compStmtOffsetsImplicit; // Number of class profile probes in this method - unsigned compHandleHistogramProbeCount; + unsigned compHandleHistogramProbeCount = 0; #ifdef TARGET_ARM64 - bool compNeedsConsecutiveRegisters; + bool compNeedsConsecutiveRegisters = false; #endif } info; @@ -10838,7 +10876,7 @@ class Compiler #endif // DEBUG private: - class ClassLayoutTable* m_classLayoutTable; + class ClassLayoutTable* m_classLayoutTable = nullptr; class ClassLayoutTable* typCreateClassLayoutTable(); class ClassLayoutTable* typGetClassLayoutTable(); @@ -10869,23 +10907,23 @@ class Compiler public: #ifdef DEBUG - unsigned compGenTreeID; - unsigned compStatementID; - unsigned compBasicBlockID; + unsigned compGenTreeID = 0; + unsigned compStatementID = 0; + unsigned compBasicBlockID = 0; #endif - LONG compMethodID; + LONG compMethodID = 0; - BasicBlock* compCurBB; // the current basic block in process - Statement* compCurStmt; // the current statement in process - GenTree* compCurTree; // the current tree in process + BasicBlock* compCurBB = nullptr; // the current basic block in process + Statement* compCurStmt; // the current statement in process + GenTree* compCurTree; // the current tree in process // The following is used to create the 'method JIT info' block. size_t compInfoBlkSize; BYTE* compInfoBlkAddr; - EHblkDsc* compHndBBtab; // array of EH data - unsigned compHndBBtabCount; // element count of used elements in EH data array - unsigned compHndBBtabAllocCount; // element count of allocated elements in EH data array + EHblkDsc* compHndBBtab = nullptr; // array of EH data + unsigned compHndBBtabCount = 0; // element count of used elements in EH data array + unsigned compHndBBtabAllocCount = 0; // element count of allocated elements in EH data array #if defined(FEATURE_EH_WINDOWS_X86) @@ -10896,9 +10934,9 @@ class Compiler #endif // FEATURE_EH_WINDOWS_X86 - Phases mostRecentlyActivePhase; // the most recently active phase - PhaseChecks activePhaseChecks; // the currently active phase checks - PhaseDumps activePhaseDumps; // the currently active phase dumps + Phases mostRecentlyActivePhase = PHASE_PRE_IMPORT; // the most recently active phase + PhaseChecks activePhaseChecks = PhaseChecks::CHECK_NONE; // the currently active phase checks + PhaseDumps activePhaseDumps = PhaseDumps::DUMP_ALL; // the currently active phase dumps //------------------------------------------------------------------------- // The following keeps track of how many bytes of local frame space we've @@ -10938,17 +10976,17 @@ class Compiler struct FrameInfo { // Frame type (1-5) - int frameType; + int frameType = 0; // Distance from established (method body) SP to base of callee save area - int calleeSaveSpOffset; + int calleeSaveSpOffset = 0; // Amount to subtract from SP before saving (prolog) OR // to add to SP after restoring (epilog) callee saves - int calleeSaveSpDelta; + int calleeSaveSpDelta = 0; // Distance from established SP to where caller's FP was saved - int offsetSpToSavedFp; + int offsetSpToSavedFp = 0; } compFrameInfo; #endif @@ -10957,11 +10995,6 @@ class Compiler static void compStartup(); // One-time initialization static void compShutdown(); // One-time finalization - void compInit(ArenaAllocator* pAlloc, - CORINFO_METHOD_HANDLE methodHnd, - COMP_HANDLE compHnd, - CORINFO_METHOD_INFO* methodInfo, - InlineInfo* inlineInfo); void compDone(); static void compDisplayStaticSizes(); @@ -11005,10 +11038,10 @@ class Compiler #endif // MEASURE_MEM_ALLOC #if LOOP_HOIST_STATS - unsigned m_loopsConsidered; - bool m_curLoopHasHoistedExpression; - unsigned m_loopsWithHoistedExpressions; - unsigned m_totalHoistedExpressions; + unsigned m_loopsConsidered = 0; + bool m_curLoopHasHoistedExpression = false; + unsigned m_loopsWithHoistedExpressions = 0; + unsigned m_totalHoistedExpressions = 0; void AddLoopHoistStats(); void PrintPerMethodLoopHoistStats(); @@ -11125,7 +11158,7 @@ class Compiler typedef JitHashTable, VarScopeMapInfo*> VarNumToScopeDscMap; // Map to keep variables' scope indexed by varNum containing it's scope dscs at the index. - VarNumToScopeDscMap* compVarScopeMap; + VarNumToScopeDscMap* compVarScopeMap = nullptr; VarScopeDsc* compFindLocalVar(unsigned varNum, unsigned lifeBeg, unsigned lifeEnd); @@ -11180,8 +11213,6 @@ class Compiler bool skipMethod(); #endif - ArenaAllocator* compArenaAllocator; - public: void compFunctionTraceStart(); void compFunctionTraceEnd(void* methodCodePtr, ULONG methodCodeSize, bool isNYI); @@ -11346,7 +11377,7 @@ class Compiler GSCookie* gsGlobalSecurityCookieAddr; // Address of global cookie for unsafe buffer checks GSCookie gsGlobalSecurityCookieVal; // Value of global cookie if addr is NULL - ShadowParamVarInfo* gsShadowVarInfo; // Table used by shadow param analysis code + ShadowParamVarInfo* gsShadowVarInfo = nullptr; // Table used by shadow param analysis code PhaseStatus gsPhase(); void gsGSChecksInitCookie(); // Grabs cookie variable @@ -11369,8 +11400,8 @@ class Compiler private: #ifdef FEATURE_JIT_METHOD_PERF - JitTimer* pCompJitTimer; // Timer data structure (by phases) for current compilation. - static CompTimeSummaryInfo s_compJitTimerSummary; // Summary of the Timer information for the whole run. + JitTimer* pCompJitTimer = nullptr; // Timer data structure (by phases) for current compilation. + static CompTimeSummaryInfo s_compJitTimerSummary; // Summary of the Timer information for the whole run. static LPCWSTR JitTimeLogCsv(); // Retrieve the file name for CSV from ConfigDWORD. static LPCWSTR compJitTimeLogFilename; // If a log file for JIT time is desired, filename to write it to. @@ -11413,8 +11444,6 @@ class Compiler static FILE* compJitFuncInfoFile; // And this is the actual FILE* to write to. #endif // FUNC_INFO_LOGGING - Compiler* prevCompiler; // Previous compiler on stack for TLS Compiler* linked list for reentrant compilers. - #if MEASURE_NOWAY void RecordNowayAssert(const char* filename, unsigned line, const char* condStr); #endif // MEASURE_NOWAY @@ -11424,12 +11453,12 @@ class Compiler #ifdef DEBUG private: - NodeToTestDataMap* m_nodeTestData; + NodeToTestDataMap* m_nodeTestData = nullptr; static const unsigned FIRST_LOOP_HOIST_CSE_CLASS = 1000; - unsigned m_loopHoistCSEClass; // LoopHoist test annotations turn into CSE requirements; we - // label them with CSE Class #'s starting at FIRST_LOOP_HOIST_CSE_CLASS. - // Current kept in this. + unsigned m_loopHoistCSEClass = FIRST_LOOP_HOIST_CSE_CLASS; // LoopHoist test annotations turn into CSE requirements; + // we label them with CSE Class #'s starting at + // FIRST_LOOP_HOIST_CSE_CLASS. Current kept in this. public: NodeToTestDataMap* GetNodeTestData() { @@ -11457,7 +11486,7 @@ class Compiler void JitTestCheckVN(); // Value numbering tests. #endif // DEBUG - FieldSeqStore* m_fieldSeqStore; + FieldSeqStore* m_fieldSeqStore = nullptr; FieldSeqStore* GetFieldSeqStore() { @@ -11497,7 +11526,7 @@ class Compiler } // The Refany type is the only struct type whose structure is implicitly assumed by IL. We need its fields. - CORINFO_CLASS_HANDLE m_refAnyClass; + CORINFO_CLASS_HANDLE m_refAnyClass = NO_CLASS_HANDLE; CORINFO_FIELD_HANDLE GetRefanyDataField() { if (m_refAnyClass == nullptr) @@ -11541,7 +11570,7 @@ class Compiler #elif defined(TARGET_RISCV64) || defined(TARGET_LOONGARCH64) typedef JitHashTable, CORINFO_FPSTRUCT_LOWERING*> FpStructLoweringMap; - FpStructLoweringMap* m_fpStructLoweringCache; + FpStructLoweringMap* m_fpStructLoweringCache = nullptr; const CORINFO_FPSTRUCT_LOWERING* GetFpStructLowering(CORINFO_CLASS_HANDLE structHandle); #endif // defined(UNIX_AMD64_ABI) diff --git a/src/coreclr/jit/ee_il_dll.hpp b/src/coreclr/jit/ee_il_dll.hpp index 5ee1c7510d2..32289aff62d 100644 --- a/src/coreclr/jit/ee_il_dll.hpp +++ b/src/coreclr/jit/ee_il_dll.hpp @@ -78,9 +78,11 @@ bool Compiler::eeIsFieldStatic(CORINFO_FIELD_HANDLE fldHnd) } FORCEINLINE -var_types Compiler::eeGetFieldType(CORINFO_FIELD_HANDLE fldHnd, CORINFO_CLASS_HANDLE* pStructHnd) +var_types Compiler::eeGetFieldType(CORINFO_FIELD_HANDLE fldHnd, + CORINFO_CLASS_HANDLE* pStructHnd, + CORINFO_CLASS_HANDLE fieldOwnerHint) { - return JITtype2varType(info.compCompHnd->getFieldType(fldHnd, pStructHnd)); + return JITtype2varType(info.compCompHnd->getFieldType(fldHnd, pStructHnd, fieldOwnerHint)); } FORCEINLINE diff --git a/src/coreclr/jit/eeinterface.cpp b/src/coreclr/jit/eeinterface.cpp index fb07912ebf7..7ac73a22d27 100644 --- a/src/coreclr/jit/eeinterface.cpp +++ b/src/coreclr/jit/eeinterface.cpp @@ -596,6 +596,27 @@ const char* Compiler::eeGetShortClassName(CORINFO_CLASS_HANDLE clsHnd) return printer.GetBuffer(); } +//------------------------------------------------------------------------ +// eeGetClassAssemblyName: +// Get the assembly name of a type. +// If missing information (in SPMI), then return a placeholder string. +// +// Parameters: +// clsHnd - the handle of the class +// +// Return value: +// The name string. +// +const char* Compiler::eeGetClassAssemblyName(CORINFO_CLASS_HANDLE clsHnd) +{ + const char* assemblyName = ""; + eeRunFunctorWithSPMIErrorTrap([&]() { + assemblyName = info.compCompHnd->getClassAssemblyName(clsHnd); + }); + + return assemblyName != nullptr ? assemblyName : ""; +} + void Compiler::eePrintObjectDescription(const char* prefix, CORINFO_OBJECT_HANDLE handle) { const size_t maxStrSize = 64; diff --git a/src/coreclr/jit/emit.cpp b/src/coreclr/jit/emit.cpp index 6331adf3b42..33ac26acfd1 100644 --- a/src/coreclr/jit/emit.cpp +++ b/src/coreclr/jit/emit.cpp @@ -6773,12 +6773,10 @@ unsigned emitter::emitEndCodeGen(Compiler* comp, #endif #if defined(TARGET_XARCH) || defined(TARGET_ARM64) - // For x64/x86/arm64, align methods that are "optimizations enabled" to 32 byte boundaries if - // they are larger than 16 bytes and contain a loop. + // For x64/x86/arm64, align methods that contain a loop to 32 byte boundaries if + // they are larger than 16 bytes and loop alignment is enabled. // - if (emitComp->opts.OptimizationEnabled() && - (!emitComp->opts.jitFlags->IsSet(JitFlags::JIT_FLAG_PREJIT) || comp->IsTargetAbi(CORINFO_NATIVEAOT_ABI)) && - (emitTotalHotCodeSize > 16) && emitComp->fgHasLoops) + if (codeGen->ShouldAlignLoops() && (emitTotalHotCodeSize > 16) && emitComp->fgHasLoops) { codeAlignment = 32; } @@ -7095,8 +7093,28 @@ unsigned emitter::emitEndCodeGen(Compiler* comp, *instrCount = 0; jitstd::list::iterator nextMapping = emitComp->genRichIPmappings.begin(); #endif +#if defined(DEBUG) && defined(TARGET_ARM64) + instrDesc* prevId = nullptr; +#endif // defined(DEBUG) && defined(TARGET_ARM64) + for (insGroup* ig = emitIGlist; ig != nullptr; ig = ig->igNext) { + +#if defined(DEBUG) && defined(TARGET_ARM64) + instrDesc* currId = emitFirstInstrDesc(ig->igData); + for (unsigned cnt = ig->igInsCnt; cnt > 0; cnt--) + { + emitInsPairSanityCheck(prevId, currId); + prevId = currId; + emitAdvanceInstrDesc(&currId, emitSizeOfInsDsc(currId)); + } + // Final instruction can't be a movprfx + if (ig->igNext == nullptr) + { + assert(prevId->idIns() != INS_sve_movprfx); + } +#endif // defined(DEBUG) && defined(TARGET_ARM64) + assert(!(ig->igFlags & IGF_PLACEHOLDER)); // There better not be any placeholder groups left /* Is this the first cold block? */ @@ -8341,7 +8359,7 @@ void emitter::emitDispDataSec(dataSecDsc* section, BYTE* dst) bool isRelative = (data->dsType == dataSection::blockRelative32); size_t blockCount = data->dsSize / (isRelative ? 4 : TARGET_POINTER_SIZE); - for (unsigned i = 0; i < blockCount; i++) + for (size_t i = 0; i < blockCount; i++) { if (i > 0) { diff --git a/src/coreclr/jit/emit.h b/src/coreclr/jit/emit.h index 2863ab623bc..3db7a20e0a2 100644 --- a/src/coreclr/jit/emit.h +++ b/src/coreclr/jit/emit.h @@ -2250,8 +2250,7 @@ class emitter ssize_t emitGetInsCIdisp(instrDesc* id); unsigned emitGetInsCIargs(instrDesc* id); - inline emitAttr emitGetMemOpSize(instrDesc* id) const; - inline emitAttr emitGetBaseMemOpSize(instrDesc*) const; + inline emitAttr emitGetMemOpSize(instrDesc* id, bool ignoreEmbeddedBroadcast = false) const; // Return the argument count for a direct call "id". int emitGetInsCDinfo(instrDesc* id); @@ -3129,6 +3128,10 @@ class emitter #ifndef TARGET_LOONGARCH64 void emitInsSanityCheck(instrDesc* id); #endif // TARGET_LOONGARCH64 + +#ifdef TARGET_ARM64 + void emitInsPairSanityCheck(instrDesc* prevId, instrDesc* id); +#endif #endif // DEBUG #ifdef TARGET_ARMARCH @@ -3959,51 +3962,11 @@ inline unsigned emitter::emitGetInsCIargs(instrDesc* id) //----------------------------------------------------------------------------- // emitGetMemOpSize: Get the memory operand size of instrDesc. // -// Note: there are cases when embedded broadcast is enabled, so the memory operand -// size is different from the intrinsic simd size, we will check here if emitter is -// emiting a embedded broadcast enabled instruction. - -// Arguments: -// id - Instruction descriptor -// -emitAttr emitter::emitGetMemOpSize(instrDesc* id) const -{ - if (id->idIsEvexbContextSet()) - { - // should have the assumption that Evex.b now stands for the embedded broadcast context. - // reference: Section 2.7.5 in Intel 64 and ia-32 architectures software developer's manual volume 2. - ssize_t inputSize = GetInputSizeInBytes(id); - switch (inputSize) - { - case 4: - return EA_4BYTE; - case 8: - return EA_8BYTE; - - default: - unreached(); - } - } - else - { - return emitGetBaseMemOpSize(id); - } -} - -//----------------------------------------------------------------------------- -// emitGetMemOpSize: Get the memory operand size of instrDesc. -// -// Note: vextractf128 has a 128-bit output (register or memory) but a 256-bit input (register). -// vinsertf128 is the inverse with a 256-bit output (register), a 256-bit input(register), -// and a 128-bit input (register or memory). -// Similarly, vextractf64x4 has a 256-bit output and 128-bit input and vinsertf64x4 the inverse -// This method is mainly used for such instructions to return the appropriate memory operand -// size, otherwise returns the regular operand size of the instruction. - // Arguments: -// id - Instruction descriptor +// id - Instruction descriptor +// ignoreEmbeddedBroadcast - true to get the non-embedded operand size; otherwise false // -emitAttr emitter::emitGetBaseMemOpSize(instrDesc* id) const +emitAttr emitter::emitGetMemOpSize(instrDesc* id, bool ignoreEmbeddedBroadcast) const { ssize_t memSize = 0; @@ -4019,7 +3982,7 @@ emitAttr emitter::emitGetBaseMemOpSize(instrDesc* id) const else if (tupleType == INS_TT_FULL) { // Embedded broadcast supported, so either loading scalar or full vector - if (id->idIsEvexbContextSet()) + if (id->idIsEvexbContextSet() && !ignoreEmbeddedBroadcast) { memSize = GetInputSizeInBytes(id); } @@ -4041,7 +4004,7 @@ emitAttr emitter::emitGetBaseMemOpSize(instrDesc* id) const { memSize = 16; } - else if (id->idIsEvexbContextSet()) + else if (id->idIsEvexbContextSet() && !ignoreEmbeddedBroadcast) { memSize = GetInputSizeInBytes(id); } @@ -4053,7 +4016,7 @@ emitAttr emitter::emitGetBaseMemOpSize(instrDesc* id) const else if (tupleType == INS_TT_HALF) { // Embedded broadcast supported, so either loading scalar or half vector - if (id->idIsEvexbContextSet()) + if (id->idIsEvexbContextSet() && !ignoreEmbeddedBroadcast) { memSize = GetInputSizeInBytes(id); } diff --git a/src/coreclr/jit/emitarm.cpp b/src/coreclr/jit/emitarm.cpp index fd0a27f6181..902399f58e4 100644 --- a/src/coreclr/jit/emitarm.cpp +++ b/src/coreclr/jit/emitarm.cpp @@ -3914,10 +3914,7 @@ void emitter::emitIns_S_R(instruction ins, emitAttr attr, regNumber reg1, int va { regNumber rsvdReg = codeGen->rsGetRsvdReg(); emitIns_genStackOffset(rsvdReg, varx, offs, /* isFloatUsage */ true, &baseRegUsed); - - // Ensure the baseReg calculated is correct. - assert(baseRegUsed == reg2); - emitIns_R_R(INS_add, EA_4BYTE, rsvdReg, reg2); + emitIns_R_R(INS_add, EA_4BYTE, rsvdReg, baseRegUsed); emitIns_R_R_I(ins, attr, reg1, rsvdReg, 0); return; } diff --git a/src/coreclr/jit/emitarm64.cpp b/src/coreclr/jit/emitarm64.cpp index d98270cd308..7b862a704cc 100644 --- a/src/coreclr/jit/emitarm64.cpp +++ b/src/coreclr/jit/emitarm64.cpp @@ -5614,16 +5614,6 @@ void emitter::emitIns_R_R_I(instruction ins, isLdSt = true; break; - case INS_ldapurb: - case INS_stlurb: - case INS_ldurb: - case INS_sturb: - // size is ignored - unscaledOp = true; - scale = 0; - isLdSt = true; - break; - case INS_ldrh: case INS_strh: // size is ignored @@ -5632,16 +5622,6 @@ void emitter::emitIns_R_R_I(instruction ins, isLdSt = true; break; - case INS_ldurh: - case INS_ldapurh: - case INS_sturh: - case INS_stlurh: - // size is ignored - unscaledOp = true; - scale = 0; - isLdSt = true; - break; - case INS_ldr: case INS_str: // Is the target a vector register? @@ -5661,24 +5641,19 @@ void emitter::emitIns_R_R_I(instruction ins, isLdrStr = true; break; + case INS_ldurb: + case INS_ldurh: case INS_ldur: + case INS_sturb: + case INS_sturh: case INS_stur: + case INS_ldapurb: + case INS_ldapurh: case INS_ldapur: + case INS_stlurb: + case INS_stlurh: case INS_stlur: - // Is the target a vector register? - if (isVectorRegister(reg1)) - { - assert(isValidVectorLSDatasize(size)); - assert(isGeneralRegisterOrSP(reg2)); - isSIMD = true; - } - else - { - assert(isValidGeneralDatasize(size)); - } - unscaledOp = true; - scale = 0; - isLdSt = true; + fmt = IF_LS_2C; break; case INS_ld2: @@ -7894,6 +7869,8 @@ void emitter::emitIns_R_S(instruction ins, emitAttr attr, regNumber reg1, int va { emitAttr size = EA_SIZE(attr); insFormat fmt = IF_NONE; + insOpts opt = INS_OPTS_NONE; + regNumber reg3 = REG_NA; unsigned scale = 0; bool isLdrStr = false; bool isSimple = true; @@ -7959,7 +7936,17 @@ void emitter::emitIns_R_S(instruction ins, emitAttr attr, regNumber reg1, int va { regNumber rsvdReg = codeGen->rsGetRsvdReg(); codeGen->instGen_Set_Reg_To_Imm(EA_PTRSIZE, rsvdReg, imm); - fmt = IF_DR_3A; // add reg1,reg2,rsvdReg + imm = 0; + if (encodingZRtoSP(reg2) == REG_SP) + { + fmt = IF_DR_3C; // add reg1,sp,rsvdReg + opt = INS_OPTS_LSL; + reg3 = rsvdReg; + } + else + { + fmt = IF_DR_3A; // add reg1,reg2,rsvdReg + } } break; @@ -8068,10 +8055,11 @@ void emitter::emitIns_R_S(instruction ins, emitAttr attr, regNumber reg1, int va id->idIns(ins); id->idInsFmt(fmt); - id->idInsOpt(INS_OPTS_NONE); + id->idInsOpt(opt); id->idReg1(reg1); id->idReg2(reg2); + id->idReg3(reg3); id->idAddr()->iiaLclVar.initLclVarAddr(varx, offs); id->idSetIsLclVar(); @@ -8110,7 +8098,6 @@ void emitter::emitIns_R_R_S_S( // TODO-ARM64-CQ: with compLocallocUsed, should we use REG_SAVED_LOCALLOC_SP instead? regNumber reg3 = FPbased ? REG_FPBASE : REG_SPBASE; - reg3 = encodingSPtoZR(reg3); bool useRegForAdr = true; ssize_t imm = disp; @@ -8142,6 +8129,8 @@ void emitter::emitIns_R_R_S_S( imm = 0; } + reg3 = encodingSPtoZR(reg3); + assert(fmt != IF_NONE); instrDesc* id = emitNewInstrCns(attr1, imm); @@ -12273,7 +12262,7 @@ size_t emitter::emitOutputInstr(insGroup* ig, instrDesc* id, BYTE** dp) } else { - assert(id->idReg3() == REG_SP); + assert(encodingZRtoSP(id->idReg3()) == REG_SP); } assert(varNum2 != -1); #endif // DEBUG @@ -14817,6 +14806,10 @@ void emitter::getMemoryOperation(instrDesc* id, unsigned* pMemAccessKind, bool* case IF_LS_3A: case IF_LS_3F: case IF_LS_3G: + case IF_SVE_ID_2A: + case IF_SVE_IE_2A: + case IF_SVE_JG_2A: + case IF_SVE_JH_2A: if (isStackRegister(id->idReg2())) { isLocalAccess = true; @@ -14827,11 +14820,98 @@ void emitter::getMemoryOperation(instrDesc* id, unsigned* pMemAccessKind, bool* case IF_LS_3C: case IF_LS_3D: case IF_LS_3E: + case IF_SVE_HW_4A: + case IF_SVE_HW_4A_A: + case IF_SVE_HW_4A_B: + case IF_SVE_HW_4A_C: + case IF_SVE_HW_4B: + case IF_SVE_HW_4B_D: + case IF_SVE_IC_3A: + case IF_SVE_IC_3A_A: + case IF_SVE_IC_3A_B: + case IF_SVE_IC_3A_C: + case IF_SVE_IG_4A: + case IF_SVE_IG_4A_D: + case IF_SVE_IG_4A_E: + case IF_SVE_IG_4A_F: + case IF_SVE_IG_4A_G: + case IF_SVE_IH_3A: + case IF_SVE_IH_3A_A: + case IF_SVE_IH_3A_F: + case IF_SVE_II_4A: + case IF_SVE_II_4A_B: + case IF_SVE_II_4A_H: + case IF_SVE_IJ_3A: + case IF_SVE_IJ_3A_D: + case IF_SVE_IJ_3A_E: + case IF_SVE_IJ_3A_F: + case IF_SVE_IJ_3A_G: + case IF_SVE_IK_4A: + case IF_SVE_IK_4A_F: + case IF_SVE_IK_4A_G: + case IF_SVE_IK_4A_H: + case IF_SVE_IK_4A_I: + case IF_SVE_IL_3A: + case IF_SVE_IL_3A_A: + case IF_SVE_IL_3A_B: + case IF_SVE_IL_3A_C: + case IF_SVE_IM_3A: + case IF_SVE_IN_4A: + case IF_SVE_IO_3A: + case IF_SVE_IP_4A: + case IF_SVE_IQ_3A: + case IF_SVE_IR_4A: + case IF_SVE_IS_3A: + case IF_SVE_IT_4A: + case IF_SVE_IU_4A: + case IF_SVE_IU_4A_A: + case IF_SVE_IU_4A_C: + case IF_SVE_IU_4B: + case IF_SVE_IU_4B_B: + case IF_SVE_IU_4B_D: + case IF_SVE_JB_4A: + case IF_SVE_JC_4A: + case IF_SVE_JD_4A: + case IF_SVE_JD_4B: + case IF_SVE_JD_4C: + case IF_SVE_JD_4C_A: + case IF_SVE_JE_3A: + case IF_SVE_JF_4A: + case IF_SVE_JJ_4A: + case IF_SVE_JJ_4A_B: + case IF_SVE_JJ_4A_C: + case IF_SVE_JJ_4A_D: + case IF_SVE_JJ_4B: + case IF_SVE_JJ_4B_C: + case IF_SVE_JJ_4B_E: + case IF_SVE_JK_4A: + case IF_SVE_JK_4A_B: + case IF_SVE_JK_4B: + case IF_SVE_JM_3A: + case IF_SVE_JN_3A: + case IF_SVE_JN_3B: + case IF_SVE_JN_3C: + case IF_SVE_JN_3C_D: + case IF_SVE_JO_3A: if (isStackRegister(id->idReg3())) { isLocalAccess = true; } break; + + case IF_SVE_HX_3A_B: + case IF_SVE_HX_3A_E: + case IF_SVE_IF_4A: + case IF_SVE_IF_4A_A: + case IF_SVE_IV_3A: + case IF_SVE_IW_4A: + case IF_SVE_IX_4A: + case IF_SVE_IY_4A: + case IF_SVE_IZ_4A: + case IF_SVE_IZ_4A_A: + case IF_SVE_JA_4A: + case IF_SVE_JI_3A_A: + case IF_SVE_JL_3A: case IF_LARGELDC: isLocalAccess = false; break; @@ -17016,7 +17096,7 @@ emitter::RegisterOrder emitter::IsOptimizableLdrStrWithPair( } regNumber prevReg1 = emitLastIns->idReg1(); - regNumber prevReg2 = emitLastIns->idReg2(); + regNumber prevReg2 = encodingZRtoSP(emitLastIns->idReg2()); insFormat lastInsFmt = emitLastIns->idInsFmt(); emitAttr prevSize = emitLastIns->idOpSize(); ssize_t prevImm = emitGetInsSC(emitLastIns); diff --git a/src/coreclr/jit/emitarm64sve.cpp b/src/coreclr/jit/emitarm64sve.cpp index 714c5716e1c..72045b32e87 100644 --- a/src/coreclr/jit/emitarm64sve.cpp +++ b/src/coreclr/jit/emitarm64sve.cpp @@ -14823,27 +14823,38 @@ void emitter::emitDispInsSveHelp(instrDesc* id) emitDispSveReg(id->idReg3(), id->idInsOpt(), false); // mmmmm break; - // , , , . // , , , . case IF_SVE_CN_3A: // ........xx...... ...gggmmmmmddddd -- SVE conditionally extract element to SIMD&FP scalar case IF_SVE_CO_3A: // ........xx...... ...gggmmmmmddddd -- SVE conditionally extract element to general register - case IF_SVE_HJ_3A: // ........xx...... ...gggmmmmmddddd -- SVE floating-point serial reduction (predicated) emitDispReg(id->idReg1(), size, true); // ddddd emitDispLowPredicateReg(id->idReg2(), insGetPredicateType(fmt), id->idInsOpt(), true); // ggg emitDispReg(id->idReg1(), size, true); // ddddd emitDispSveReg(id->idReg3(), id->idInsOpt(), false); // mmmmm break; + // , , , . + case IF_SVE_HJ_3A: // ........xx...... ...gggmmmmmddddd -- SVE floating-point serial reduction (predicated) + emitDispVectorReg(id->idReg1(), id->idInsOpt(), true); // ddddd + emitDispLowPredicateReg(id->idReg2(), insGetPredicateType(fmt), id->idInsOpt(), true); // ggg + emitDispVectorReg(id->idReg1(), id->idInsOpt(), true); // ddddd + emitDispSveReg(id->idReg3(), id->idInsOpt(), false); // mmmmm + break; + // , , . - // , , . case IF_SVE_AF_3A: // ........xx...... ...gggnnnnnddddd -- SVE bitwise logical reduction (predicated) case IF_SVE_AK_3A: // ........xx...... ...gggnnnnnddddd -- SVE integer min/max reduction (predicated) case IF_SVE_CR_3A: // ........xx...... ...gggnnnnnddddd -- SVE extract element to SIMD&FP scalar register - case IF_SVE_CS_3A: // ........xx...... ...gggnnnnnddddd -- SVE extract element to general register case IF_SVE_HE_3A: // ........xx...... ...gggnnnnnddddd -- SVE floating-point recursive reduction - emitDispReg(id->idReg1(), size, true); // ddddd - emitDispPredicateReg(id->idReg2(), insGetPredicateType(fmt), id->idInsOpt(), true); // ggg - emitDispSveReg(id->idReg3(), id->idInsOpt(), false); // mmmmm + emitDispVectorReg(id->idReg1(), id->idInsOpt(), true); // ddddd + emitDispLowPredicateReg(id->idReg2(), insGetPredicateType(fmt), id->idInsOpt(), true); // ggg + emitDispSveReg(id->idReg3(), id->idInsOpt(), false); // mmmmm + break; + + // , , . + case IF_SVE_CS_3A: // ........xx...... ...gggnnnnnddddd -- SVE extract element to general register + emitDispReg(id->idReg1(), size, true); // ddddd + emitDispLowPredicateReg(id->idReg2(), insGetPredicateType(fmt), id->idInsOpt(), true); // ggg + emitDispSveReg(id->idReg3(), id->idInsOpt(), false); // mmmmm break; // ., , . @@ -18421,4 +18432,212 @@ void emitter::getInsSveExecutionCharacteristics(instrDesc* id, insExecutionChara } #endif // defined(DEBUG) || defined(LATE_DISASM) +#ifdef DEBUG +/***************************************************************************** + * + * Sanity check two instructions are valid when placed next to each other + */ + +void emitter::emitInsPairSanityCheck(instrDesc* firstId, instrDesc* secondId) +{ + if (firstId == nullptr || secondId == nullptr) + { + return; + } + + // Currently only concerned with instructions that follow movprfx + if (firstId->idIns() != INS_sve_movprfx) + { + return; + } + + bool movprefxIsPredicated = false; + if (firstId->idInsFmt() == IF_SVE_AH_3A) + { + movprefxIsPredicated = true; + } + else + { + // Unpredicated version + assert(firstId->idInsFmt() == IF_SVE_BI_2A); + } + + // Quoted sections are taken from the Arm manual. + + // "It is required that the prefixed instruction at PC+4 must be an SVE destructive binary or ternary + // instruction encoding, or a unary operation with merging predication, but excluding other MOVPRFX instructions." + // "The prefixed instruction must not use the destination register in any other operand position, even if + // they have different names but refer to the same architectural register state." + // "A predicated MOVPRFX cannot be used with an unpredicated instruction." + switch (secondId->idInsFmt()) + { + case IF_SVE_BN_1A: // .D{, {, MUL #}} + case IF_SVE_BP_1A: // .D{, {, MUL #}} + case IF_SVE_CC_2A: // ., + case IF_SVE_CD_2A: // ., + case IF_SVE_DN_2A: // ., . + case IF_SVE_DP_2A: // ., . + // Tied registers + case IF_SVE_BS_1A: // ., ., # + case IF_SVE_EC_1A: // ., ., #{, } + case IF_SVE_ED_1A: // ., ., # + case IF_SVE_EE_1A: // ., ., # + assert(!movprefxIsPredicated); + break; + + case IF_SVE_BU_2A: // ., /M, # + case IF_SVE_BV_2A_A: // ., /M, #{, } + case IF_SVE_BV_2A_J: // ., /M, #{, } + case IF_SVE_BV_2B: // ., /M, #0.0 + case IF_SVE_CQ_3A: // ., /M, + // Tied registers + case IF_SVE_AM_2A: // ., /M, ., # + case IF_SVE_HM_2A: // ., /M, ., + break; + + case IF_SVE_FU_2A: // ., ., # + // Tied registers + case IF_SVE_AW_2A: // ., ., ., # + case IF_SVE_BY_2A: // .B, .B, .B, # + case IF_SVE_FV_2A: // ., ., ., + case IF_SVE_HN_2A: // ., ., ., # + assert(!movprefxIsPredicated); + assert(secondId->idReg1() != secondId->idReg2()); + break; + + case IF_SVE_AP_3A: // ., /M, . + case IF_SVE_AQ_3A: // ., /M, . + case IF_SVE_CP_3A: // ., /M, + case IF_SVE_CT_3A: // .Q, /M, .Q + case IF_SVE_CU_3A: // ., /M, . + case IF_SVE_ES_3A: // ., /M, . + case IF_SVE_EQ_3A: // ., /M, . + case IF_SVE_HO_3A: // .H, /M, .S + case IF_SVE_HO_3B: // .D, /M, .S + case IF_SVE_HO_3C: // .S, /M, .D + case IF_SVE_HP_3A: // ., /M, . + case IF_SVE_HQ_3A: // ., /M, . + case IF_SVE_HR_3A: // ., /M, . + case IF_SVE_HS_3A: // ., /M, . + case IF_SVE_HP_3B: // ., /M, . + // Tied registers + case IF_SVE_AA_3A: // ., /M, ., . + case IF_SVE_AB_3B: // .D, /M, .D, .D + case IF_SVE_AC_3A: // ., /M, ., . + case IF_SVE_AO_3A: // ., /M, ., .D + case IF_SVE_CM_3A: // ., , ., . + case IF_SVE_GP_3A: // ., /M, ., ., + case IF_SVE_GR_3A: // ., /M, ., . + case IF_SVE_HL_3A: // ., /M, ., . + case IF_SVE_HL_3B: // .H, /M, .H, .H + assert(secondId->idReg1() != secondId->idReg3()); + break; + + case IF_SVE_EF_3A: // .S, .H, .H + case IF_SVE_EG_3A: // .S, .H, .H[] + case IF_SVE_EH_3A: // ., ., . + case IF_SVE_EI_3A: // .S, .B, .B + case IF_SVE_EJ_3A: // ., ., ., + case IF_SVE_EK_3A: // ., ., ., + case IF_SVE_EL_3A: // ., ., . + case IF_SVE_EM_3A: // ., ., . + case IF_SVE_EW_3A: // .D, .D, .D + case IF_SVE_EW_3B: // .D, .D, .D + case IF_SVE_EY_3A: // .S, .B, .B[] + case IF_SVE_EY_3B: // .D, .H, .H[] + case IF_SVE_EZ_3A: // .S, .B, .B[] + case IF_SVE_FA_3A: // .S, .B, .B[], + case IF_SVE_FA_3B: // .D, .H, .H[], + case IF_SVE_FB_3A: // .H, .H, .H[], + case IF_SVE_FB_3B: // .S, .S, .S[], + case IF_SVE_FC_3A: // .H, .H, .H[], + case IF_SVE_FC_3B: // .S, .S, .S[], + case IF_SVE_FF_3A: // .H, .H, .H[] + case IF_SVE_FF_3B: // .S, .S, .S[] + case IF_SVE_FF_3C: // .D, .D, .D[] + case IF_SVE_FG_3A: // .S, .H, .H[] + case IF_SVE_FG_3B: // .D, .S, .S[] + case IF_SVE_FJ_3A: // .S, .H, .H[] + case IF_SVE_FJ_3B: // .D, .S, .S[] + case IF_SVE_FK_3A: // .H, .H, .H[] + case IF_SVE_FK_3B: // .S, .S, .S[] + case IF_SVE_FK_3C: // .D, .D, .D[] + case IF_SVE_FO_3A: // .S, .B, .B + case IF_SVE_FW_3A: // ., ., . + case IF_SVE_FY_3A: // ., ., . + case IF_SVE_GM_3A: // .H, .B, .B[] + case IF_SVE_GN_3A: // .H, .B, .B + case IF_SVE_GO_3A: // .S, .B, .B + case IF_SVE_GU_3A: // .S, .S, .S[] + case IF_SVE_GU_3B: // .D, .D, .D[] + case IF_SVE_GU_3C: // .H, .H, .H[] + case IF_SVE_GV_3A: // .S, .S, .S[], + case IF_SVE_GW_3B: // .H, .H, .H + case IF_SVE_GY_3A: // .H, .B, .B[] + case IF_SVE_GY_3B: // .S, .H, .H[] + case IF_SVE_GY_3B_D: // .S, .B, .B[] + case IF_SVE_GZ_3A: // .S, .H, .H[] + case IF_SVE_HA_3A: // .S, .H, .H + case IF_SVE_HA_3A_E: // .H, .B, .B + case IF_SVE_HA_3A_F: // .S, .B, .B + case IF_SVE_HB_3A: // .S, .H, .H + case IF_SVE_HC_3A: // .S, .B, .B[] + case IF_SVE_HD_3A: // .S, .H, .H + case IF_SVE_HD_3A_A: // .D, .D, .D + // Tied registers + case IF_SVE_AV_3A: // .D, .D, .D, .D + assert(!movprefxIsPredicated); + assert(secondId->idReg1() != secondId->idReg2()); + assert(secondId->idReg1() != secondId->idReg3()); + break; + + case IF_SVE_AR_4A: // ., /M, ., . + case IF_SVE_AS_4A: // ., /M, ., . + case IF_SVE_GT_4A: // ., /M, ., ., + case IF_SVE_HU_4A: // ., /M, ., . + case IF_SVE_HU_4B: // .H, /M, .H, .H + case IF_SVE_HV_4A: // ., /M, ., . + assert(secondId->idReg1() != secondId->idReg3()); + assert(secondId->idReg1() != secondId->idReg4()); + break; + + case IF_SVE_AT_3A: // ., ., . + // Only a subset of this group is valid + switch (secondId->idIns()) + { + case INS_sve_sclamp: + case INS_sve_uclamp: + case INS_sve_eorbt: + case INS_sve_eortb: + case INS_sve_fclamp: + break; + default: + assert(!"Got unexpected instruction format within group after MOVPRFX"); + } + assert(!movprefxIsPredicated); + assert(secondId->idReg1() != secondId->idReg2()); + assert(secondId->idReg1() != secondId->idReg3()); + break; + + default: + assert(!"Got unexpected instruction format after MOVPRFX"); + break; + } + + // "The prefixed instruction must specify the same destination vector as the MOVPRFX instruction." + assert(firstId->idReg1() == secondId->idReg1()); + + if (movprefxIsPredicated) + { + // "The prefixed instruction must specify the same predicate register" + assert(isPredicateRegister(firstId->idReg2())); + assert(isPredicateRegister(secondId->idReg2())); + assert(firstId->idReg2() == secondId->idReg2()); + + // "predicated using the same governing predicate register and source element size as this instruction." + assert(firstId->idInsOpt() == secondId->idInsOpt()); + } +} +#endif // DEBUG + #endif // TARGET_ARM64 diff --git a/src/coreclr/jit/emitriscv64.cpp b/src/coreclr/jit/emitriscv64.cpp index e72777a296e..7d207bcb127 100644 --- a/src/coreclr/jit/emitriscv64.cpp +++ b/src/coreclr/jit/emitriscv64.cpp @@ -3331,6 +3331,13 @@ size_t emitter::emitOutputInstr(insGroup* ig, instrDesc* id, BYTE** dp) assert(!"JitBreakEmitOutputInstr reached"); } } + + // Output any delta in GC info. + if (EMIT_GC_VERBOSE || emitComp->opts.disasmWithGC) + { + emitDispGCInfoDelta(); + } + #else // !DEBUG if (emitComp->opts.disAsm) { diff --git a/src/coreclr/jit/emitxarch.cpp b/src/coreclr/jit/emitxarch.cpp index 808fa136033..500d827ab29 100644 --- a/src/coreclr/jit/emitxarch.cpp +++ b/src/coreclr/jit/emitxarch.cpp @@ -49,6 +49,23 @@ bool emitter::IsKInstruction(instruction ins) return (flags & KInstruction) != 0; } +//------------------------------------------------------------------------ +// IsKInstructionWithLBit: Does this instruction require K register and +// LBIT_IN_3BYTE_VEX_PREFIX bit. +// +// Arguments: +// ins - The instruction to check. +// +// Returns: +// `true` if this instruction requires K register and +// LBIT_IN_3BYTE_VEX_PREFIX bit. +// +bool emitter::IsKInstructionWithLBit(instruction ins) +{ + insFlags flags = CodeGenInterface::instInfo[ins]; + return (flags & KInstructionWithLBit) != 0; +} + bool emitter::IsAVXOnlyInstruction(instruction ins) { return (ins >= INS_FIRST_AVX_INSTRUCTION) && (ins <= INS_LAST_AVX_INSTRUCTION); @@ -355,6 +372,22 @@ bool emitter::DoesWriteZeroFlag(instruction ins) return (flags & Writes_ZF) != 0; } +//------------------------------------------------------------------------ +// DoesWriteParityFlag: check if the instruction write the +// PF flag. +// +// Arguments: +// ins - instruction to test +// +// Return Value: +// true if instruction writes the PF flag, false otherwise. +// +bool emitter::DoesWriteParityFlag(instruction ins) +{ + insFlags flags = CodeGenInterface::instInfo[ins]; + return (flags & Writes_PF) != 0; +} + //------------------------------------------------------------------------ // DoesWriteSignFlag: check if the instruction writes the // SF flag. @@ -979,7 +1012,8 @@ bool emitter::AreFlagsSetToZeroCmp(regNumber reg, emitAttr opSize, GenCondition // Certain instruction like and, or and xor modifies exactly same flags // as "test" instruction. // They reset OF and CF to 0 and modifies SF, ZF and PF. - if (DoesResetOverflowAndCarryFlags(lastIns)) + if (DoesResetOverflowAndCarryFlags(lastIns) && DoesWriteSignFlag(lastIns) && DoesWriteZeroFlag(lastIns) && + DoesWriteParityFlag(lastIns)) { return id->idOpSize() == opSize; } @@ -1478,7 +1512,7 @@ emitter::code_t emitter::AddVexPrefix(instruction ins, code_t code, emitAttr att code |= DEFAULT_3BYTE_VEX_PREFIX; - if (attr == EA_32BYTE) + if ((attr == EA_32BYTE) || IsKInstructionWithLBit(ins)) { // Set L bit to 1 in case of instructions that operate on 256-bits. code |= LBIT_IN_3BYTE_VEX_PREFIX; @@ -2755,7 +2789,14 @@ bool emitter::emitInsCanOnlyWriteSSE2OrAVXReg(instrDesc* id) // These SSE instructions write to a general purpose integer register. return false; } - + case INS_kmovb_gpr: + case INS_kmovw_gpr: + case INS_kmovd_gpr: + case INS_kmovq_gpr: + { + // These kmov writes to a general purpose integer register + return !isGeneralRegister(id->idReg1()); + } default: { return true; @@ -10987,7 +11028,7 @@ void emitter::emitDispEmbBroadcastCount(instrDesc* id) const return; } ssize_t baseSize = GetInputSizeInBytes(id); - ssize_t vectorSize = (ssize_t)emitGetBaseMemOpSize(id); + ssize_t vectorSize = (ssize_t)emitGetMemOpSize(id, /* ignoreEmbeddedBroadcast */ true); printf(" {1to%d}", vectorSize / baseSize); } diff --git a/src/coreclr/jit/emitxarch.h b/src/coreclr/jit/emitxarch.h index d24a697d93c..cc70f02ed36 100644 --- a/src/coreclr/jit/emitxarch.h +++ b/src/coreclr/jit/emitxarch.h @@ -113,6 +113,7 @@ static bool IsPermuteVar2xInstruction(instruction ins); static bool IsAVXVNNIInstruction(instruction ins); static bool IsBMIInstruction(instruction ins); static bool IsKInstruction(instruction ins); +static bool IsKInstructionWithLBit(instruction ins); static regNumber getBmiRegNumber(instruction ins); static regNumber getSseShiftRegNumber(instruction ins); @@ -484,6 +485,7 @@ bool IsThreeOperandAVXInstruction(instruction ins) const; static bool HasRegularWideForm(instruction ins); static bool HasRegularWideImmediateForm(instruction ins); static bool DoesWriteZeroFlag(instruction ins); +static bool DoesWriteParityFlag(instruction ins); static bool DoesWriteSignFlag(instruction ins); static bool DoesResetOverflowAndCarryFlags(instruction ins); bool IsFlagsAlwaysModified(instrDesc* id); diff --git a/src/coreclr/jit/fgbasic.cpp b/src/coreclr/jit/fgbasic.cpp index b7ac17ad851..00b9de5c2fb 100644 --- a/src/coreclr/jit/fgbasic.cpp +++ b/src/coreclr/jit/fgbasic.cpp @@ -8,170 +8,6 @@ // Flowgraph Construction and Maintenance -void Compiler::fgInit() -{ - impInit(); - - /* Initialization for fgWalkTreePre() and fgWalkTreePost() */ - - fgFirstBBScratch = nullptr; - -#ifdef DEBUG - fgPrintInlinedMethods = false; -#endif // DEBUG - - /* We haven't yet computed the bbPreds lists */ - fgPredsComputed = false; - - /* We haven't yet computed block weights */ - fgCalledCount = BB_ZERO_WEIGHT; - - /* Initialize the basic block list */ - - fgFirstBB = nullptr; - fgLastBB = nullptr; - fgFirstColdBlock = nullptr; - fgEntryBB = nullptr; - fgOSREntryBB = nullptr; - fgEntryBBExtraRefs = 0; - - fgFirstFuncletBB = nullptr; - fgFuncletsCreated = false; - - fgBBcount = 0; - -#ifdef DEBUG - fgBBOrder = nullptr; -#endif // DEBUG - - fgMightHaveNaturalLoops = false; - fgBBNumMax = 0; - fgEdgeCount = 0; - fgDomBBcount = 0; - fgBBVarSetsInited = false; - fgReturnCount = 0; - fgThrowCount = 0; - - m_dfsTree = nullptr; - m_loops = nullptr; - m_loopSideEffects = nullptr; - m_blockToLoop = nullptr; - m_domTree = nullptr; - m_reachabilitySets = nullptr; - - // Initialize BlockSet data. - fgCurBBEpoch = 0; - fgCurBBEpochSize = 0; - fgBBSetCountInSizeTUnits = 0; - - genReturnBB = nullptr; - genReturnLocal = BAD_VAR_NUM; - -#ifdef SWIFT_SUPPORT - genReturnErrorLocal = BAD_VAR_NUM; -#endif // SWIFT_SUPPORT - - /* We haven't reached the global morphing phase */ - fgGlobalMorph = false; - fgGlobalMorphDone = false; - fgRemoveRestOfBlock = false; - fgHasNoReturnCall = false; - - fgModified = false; - -#ifdef DEBUG - fgSafeBasicBlockCreation = true; - fgSafeFlowEdgeCreation = true; -#endif // DEBUG - - fgLocalVarLivenessDone = false; - fgIsDoingEarlyLiveness = false; - fgDidEarlyLiveness = false; - - /* Statement list is not threaded yet */ - - fgNodeThreading = NodeThreading::None; - - // Initialize the logic for adding code. This is used to insert code such - // as the code that raises an exception when an array range check fails. - fgAddCodeList = nullptr; - fgAddCodeDscMap = nullptr; - - /* Keep track of the max count of pointer arguments */ - fgPtrArgCntMax = 0; - - /* This global flag is set whenever we remove a statement */ - fgStmtRemoved = false; - - // This global flag is set when we create throw helper blocks - fgRngChkThrowAdded = false; - - /* Keep track of whether or not EH statements have been optimized */ - fgOptimizedFinally = false; - - /* We will record a list of all BBJ_RETURN blocks here */ - fgReturnBlocks = nullptr; - - fgUsedSharedTemps = nullptr; - -#if defined(FEATURE_EH_WINDOWS_X86) - ehMaxHndNestingCount = 0; -#endif // FEATURE_EH_WINDOWS_X86 - - /* Init the fgBigOffsetMorphingTemps to be BAD_VAR_NUM. */ - for (int i = 0; i < TYP_COUNT; i++) - { - fgBigOffsetMorphingTemps[i] = BAD_VAR_NUM; - } - - fgNoStructPromotion = false; - fgNoStructParamPromotion = false; - - optValnumCSE_phase = false; // referenced in fgMorphSmpOp() - -#ifdef DEBUG - fgNormalizeEHDone = false; -#endif // DEBUG - -#ifdef DEBUG - if (!compIsForInlining()) - { - const int noStructPromotionValue = JitConfig.JitNoStructPromotion(); - assert(0 <= noStructPromotionValue && noStructPromotionValue <= 2); - if (noStructPromotionValue == 1) - { - fgNoStructPromotion = true; - } - if (noStructPromotionValue == 2) - { - fgNoStructParamPromotion = true; - } - } -#endif // DEBUG - -#ifdef FEATURE_SIMD - fgPreviousCandidateSIMDFieldStoreStmt = nullptr; -#endif - - fgHasSwitch = false; - fgPgoDisabled = false; - fgPgoSchema = nullptr; - fgPgoData = nullptr; - fgPgoSchemaCount = 0; - fgNumProfileRuns = 0; - fgPgoBlockCounts = 0; - fgPgoEdgeCounts = 0; - fgPgoClassProfiles = 0; - fgPgoMethodProfiles = 0; - fgPgoInlineePgo = 0; - fgPgoInlineeNoPgo = 0; - fgPgoInlineeNoPgoSingleBlock = 0; - fgCountInstrumentor = nullptr; - fgHistogramInstrumentor = nullptr; - fgValueInstrumentor = nullptr; - fgPredListSortVector = nullptr; -} - //------------------------------------------------------------------------ // fgEnsureFirstBBisScratch: Ensure that fgFirstBB is a scratch BasicBlock // @@ -5102,23 +4938,13 @@ BasicBlock* Compiler::fgSplitEdge(BasicBlock* curr, BasicBlock* succ) // Set weight for newBlock // - if (curr->KindIs(BBJ_ALWAYS)) - { - newBlock->inheritWeight(curr); - } - else + FlowEdge* const currNewEdge = fgGetPredForBlock(newBlock, curr); + newBlock->bbWeight = currNewEdge->getLikelyWeight(); + newBlock->CopyFlags(curr, BBF_PROF_WEIGHT); + + if (newBlock->bbWeight == BB_ZERO_WEIGHT) { - if (curr->hasProfileWeight()) - { - FlowEdge* const currNewEdge = fgGetPredForBlock(newBlock, curr); - newBlock->setBBProfileWeight(currNewEdge->getLikelyWeight()); - } - else - { - // Todo: use likelihood even w/o profile? - // - newBlock->inheritWeightPercentage(curr, 50); - } + newBlock->bbSetRunRarely(); } // The bbLiveIn and bbLiveOut are both equal to the bbLiveIn of 'succ' @@ -6887,6 +6713,57 @@ BasicBlock* Compiler::fgNewBBinRegionWorker(BBKinds jumpKind, return newBlk; } +//----------------------------------------------------------------------------- +// fgNewBBatTryRegionEnd: Creates and inserts a new block at the end of the specified +// try region, updating the end pointers in the EH table as necessary. +// +// Arguments: +// jumpKind - The jump kind of the new block +// tryIndex - The index of the try region to insert the new block in +// +// Returns: +// The new block +// +// Notes: +// newBlock will be in the try region specified by tryIndex, which may not necessarily +// be the same as oldTryLast->getTryIndex() if the latter is a child region. +// However, newBlock and oldTryLast will be in the same handler region. +// +BasicBlock* Compiler::fgNewBBatTryRegionEnd(BBKinds jumpKind, unsigned tryIndex) +{ + EHblkDsc* HBtab = ehGetDsc(tryIndex); + BasicBlock* const oldTryLast = HBtab->ebdTryLast; + BasicBlock* const newBlock = fgNewBBafter(jumpKind, oldTryLast, /* extendRegion */ false); + newBlock->setTryIndex(tryIndex); + newBlock->copyHndIndex(oldTryLast); + + // Update this try region's (and all parent try regions') last block pointer + // + for (unsigned XTnum = tryIndex; (XTnum < compHndBBtabCount) && (HBtab->ebdTryLast == oldTryLast); XTnum++, HBtab++) + { + assert((XTnum == tryIndex) || (XTnum == ehGetEnclosingTryIndex(XTnum - 1))); + fgSetTryEnd(HBtab, newBlock); + } + + // If we inserted newBlock at the end of a handler region, repeat the above pass for handler regions + // + if (newBlock->hasHndIndex()) + { + const unsigned hndIndex = newBlock->getHndIndex(); + HBtab = ehGetDsc(hndIndex); + for (unsigned XTnum = hndIndex; (XTnum < compHndBBtabCount) && (HBtab->ebdHndLast == oldTryLast); + XTnum++, HBtab++) + { + assert((XTnum == hndIndex) || (XTnum == ehGetEnclosingHndIndex(XTnum - 1))); + fgSetHndEnd(HBtab, newBlock); + } + } + + assert(newBlock->getTryIndex() == tryIndex); + assert(BasicBlock::sameHndRegion(newBlock, oldTryLast)); + return newBlock; +} + //------------------------------------------------------------------------ // fgUseThrowHelperBlocks: Determinate does compiler use throw helper blocks. // diff --git a/src/coreclr/jit/fgopt.cpp b/src/coreclr/jit/fgopt.cpp index d0c6de25368..c97ea5840f5 100644 --- a/src/coreclr/jit/fgopt.cpp +++ b/src/coreclr/jit/fgopt.cpp @@ -3130,7 +3130,7 @@ bool Compiler::fgExpandRarelyRunBlocks() break; case BBJ_COND: - if (block->isRunRarely() && bPrev->GetTrueTarget()->isRunRarely()) + if (bPrev->GetTrueTarget()->isRunRarely() && bPrev->GetFalseTarget()->isRunRarely()) { INDEBUG(reason = "Both sides of a conditional jump are rarely run"); setRarelyRun = true; @@ -3234,21 +3234,13 @@ bool Compiler::fgExpandRarelyRunBlocks() } } - /* COMPACT blocks if possible */ - if (fgCanCompactBlock(bPrev)) - { - fgCompactBlock(bPrev); - - block = bPrev; - continue; - } // // if bPrev->bbWeight is not based upon profile data we can adjust // the weights of bPrev and block // - else if (bPrev->isBBCallFinallyPair() && // we must have a BBJ_CALLFINALLY and BBJ_CALLFINALLYRET pair - (bPrev->bbWeight != block->bbWeight) && // the weights are currently different - !bPrev->hasProfileWeight()) // and the BBJ_CALLFINALLY block is not using profiled weights + if (bPrev->isBBCallFinallyPair() && // we must have a BBJ_CALLFINALLY and BBJ_CALLFINALLYRET pair + (bPrev->bbWeight != block->bbWeight) && // the weights are currently different + !bPrev->hasProfileWeight()) // and the BBJ_CALLFINALLY block is not using profiled weights { if (block->isRunRarely()) { @@ -5311,17 +5303,16 @@ bool Compiler::fgUpdateFlowGraph(bool doTailDuplication /* = false */, { fgCompactBlock(otherPred); fgFoldSimpleCondByForwardSub(otherPred); + + // Since compaction removes blocks, update lexical pointers + bPrev = block->Prev(); + bNext = block->Next(); } } assert(block->KindIs(BBJ_ALWAYS)); bDest = block->GetTarget(); } - else - { - bDest = block->GetTrueTarget(); - bFalseDest = block->GetFalseTarget(); - } } } diff --git a/src/coreclr/jit/fgprofile.cpp b/src/coreclr/jit/fgprofile.cpp index 4fcf748416d..7c32cc66f10 100644 --- a/src/coreclr/jit/fgprofile.cpp +++ b/src/coreclr/jit/fgprofile.cpp @@ -44,6 +44,27 @@ bool Compiler::fgHaveProfileWeights() return fgPgoHaveWeights; } +//------------------------------------------------------------------------ +// fgRemoveProfileData: Remove all traces of profile info +// +// Notes: +// Needed if the jit initially thought it was going to optimize +// the method, but then decided not to. +// +// Does not modify any block fields, so should be called before +// we start to incorporate profile data. +// +void Compiler::fgRemoveProfileData(const char* reason) +{ + fgPgoFailReason = reason; + fgPgoQueryResult = E_FAIL; + fgPgoHaveWeights = false; + fgPgoData = nullptr; + fgPgoSchema = nullptr; + fgPgoDisabled = true; + fgPgoDynamic = false; +} + //------------------------------------------------------------------------ // fgHaveSufficientProfileWeights: check if profile data is available // and is sufficient enough to be trustful. @@ -344,9 +365,6 @@ class Instrumentor virtual void Instrument(BasicBlock* block, Schema& schema, uint8_t* profileMemory) { } - virtual void InstrumentMethodEntry(Schema& schema, uint8_t* profileMemory) - { - } unsigned SchemaCount() const { return m_schemaCount; @@ -402,7 +420,6 @@ class BlockCountInstrumentor : public Instrumentor void Prepare(bool isPreImport) override; void BuildSchemaElements(BasicBlock* block, Schema& schema) override; void Instrument(BasicBlock* block, Schema& schema, uint8_t* profileMemory) override; - void InstrumentMethodEntry(Schema& schema, uint8_t* profileMemory) override; static GenTree* CreateCounterIncrement(Compiler* comp, uint8_t* counterAddr, var_types countType); }; @@ -672,89 +689,6 @@ void BlockCountInstrumentor::Instrument(BasicBlock* block, Schema& schema, uint8 m_instrCount++; } -//------------------------------------------------------------------------ -// BlockCountInstrumentor::InstrumentMethodEntry: add any special method entry instrumentation -// -// Arguments: -// schema -- instrumentation schema -// profileMemory -- profile data slab -// -// Notes: -// When prejitting, add the method entry callback node -// -void BlockCountInstrumentor::InstrumentMethodEntry(Schema& schema, uint8_t* profileMemory) -{ - Compiler::Options& opts = m_comp->opts; - Compiler::Info& info = m_comp->info; - - // Nothing to do, if not prejitting. - // - if (!opts.jitFlags->IsSet(JitFlags::JIT_FLAG_PREJIT)) - { - return; - } - - // Find the address of the entry block's counter. - // - assert(m_entryBlock != nullptr); - assert(m_entryBlock->bbCodeOffs == 0); - - const ICorJitInfo::PgoInstrumentationSchema& entry = schema[m_entryBlock->bbCountSchemaIndex]; - assert((IL_OFFSET)entry.ILOffset == 0); - assert((entry.InstrumentationKind == ICorJitInfo::PgoInstrumentationKind::BasicBlockIntCount) || - (entry.InstrumentationKind == ICorJitInfo::PgoInstrumentationKind::BasicBlockLongCount)); - - const size_t addrOfFirstExecutionCount = (size_t)(entry.Offset + profileMemory); - - GenTree* arg; - -#ifdef FEATURE_READYTORUN - if (opts.IsReadyToRun()) - { - mdMethodDef currentMethodToken = info.compCompHnd->getMethodDefFromMethod(info.compMethodHnd); - - CORINFO_RESOLVED_TOKEN resolvedToken; - resolvedToken.tokenContext = MAKE_METHODCONTEXT(info.compMethodHnd); - resolvedToken.tokenScope = info.compScopeHnd; - resolvedToken.token = currentMethodToken; - resolvedToken.tokenType = CORINFO_TOKENKIND_Method; - - info.compCompHnd->resolveToken(&resolvedToken); - - arg = m_comp->impTokenToHandle(&resolvedToken); - } - else -#endif - { - arg = m_comp->gtNewIconEmbMethHndNode(info.compMethodHnd); - } - - // We want to call CORINFO_HELP_BBT_FCN_ENTER just one time, - // the first time this method is called. So make the call conditional - // on the entry block's profile count. - // - GenTreeCall* call = m_comp->gtNewHelperCallNode(CORINFO_HELP_BBT_FCN_ENTER, TYP_VOID, arg); - - var_types typ = - entry.InstrumentationKind == ICorJitInfo::PgoInstrumentationKind::BasicBlockIntCount ? TYP_INT : TYP_LONG; - // Read Basic-Block count value - // - GenTree* valueNode = m_comp->gtNewIndOfIconHandleNode(typ, addrOfFirstExecutionCount, GTF_ICON_BBC_PTR, false); - - // Compare Basic-Block count value against zero - // - GenTree* relop = m_comp->gtNewOperNode(GT_NE, typ, valueNode, m_comp->gtNewIconNode(0, typ)); - GenTreeColon* colon = new (m_comp, GT_COLON) GenTreeColon(TYP_VOID, m_comp->gtNewNothingNode(), call); - GenTreeQmark* cond = m_comp->gtNewQmarkNode(TYP_VOID, relop, colon); - Statement* stmt = m_comp->gtNewStmt(cond); - - // Add this check into the scratch block entry so we only do the check once per call. - // If we put it in block we may be putting it inside a loop. - // - m_comp->fgEnsureFirstBBisScratch(); - m_comp->fgInsertStmtAtEnd(m_comp->fgFirstBB, stmt); -} - //------------------------------------------------------------------------ // BlockCountInstrumentor::CreateCounterIncrement: create a tree that increments a profile counter. // @@ -2827,13 +2761,6 @@ PhaseStatus Compiler::fgInstrumentMethod() // assert(fgHistogramInstrumentor->InstrCount() == info.compHandleHistogramProbeCount); - // Add any special entry instrumentation. This does not - // use the schema mechanism. - // - fgCountInstrumentor->InstrumentMethodEntry(schema, profileMemory); - fgHistogramInstrumentor->InstrumentMethodEntry(schema, profileMemory); - fgValueInstrumentor->InstrumentMethodEntry(schema, profileMemory); - return PhaseStatus::MODIFIED_EVERYTHING; } @@ -3562,15 +3489,6 @@ void EfficientEdgeCountReconstructor::Prepare() // void EfficientEdgeCountReconstructor::Solve() { - // If we have dynamic PGO data, we don't expect to see any mismatches, - // since the schema we got from the runtime should have come from the - // exact same JIT and IL, created in an earlier tier. - // - if (m_comp->fgPgoSource == ICorJitInfo::PgoSource::Dynamic) - { - assert(!m_mismatch); - } - // If issues arose earlier, then don't try solving. // if (m_badcode || m_mismatch || m_allWeightsZero) diff --git a/src/coreclr/jit/flowgraph.cpp b/src/coreclr/jit/flowgraph.cpp index 339ac1e4400..2c21e3d66b8 100644 --- a/src/coreclr/jit/flowgraph.cpp +++ b/src/coreclr/jit/flowgraph.cpp @@ -384,7 +384,6 @@ BasicBlock* Compiler::fgCreateGCPoll(GCPollType pollType, BasicBlock* block) case BBJ_COND: // replace predecessor in true/false successors. - noway_assert(!bottom->IsLast()); fgReplacePred(top->GetFalseEdge(), bottom); fgReplacePred(top->GetTrueEdge(), bottom); break; diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp index 59753bb6c10..782e5dfde07 100644 --- a/src/coreclr/jit/gentree.cpp +++ b/src/coreclr/jit/gentree.cpp @@ -2022,9 +2022,14 @@ void CallArgs::MoveLateToEarly() // bool GenTreeCall::NeedsVzeroupper(Compiler* comp) { + if (!comp->canUseVexEncoding()) + { + return false; + } + bool needsVzeroupper = false; - if (IsPInvoke() && comp->canUseVexEncoding()) + if (IsPInvoke()) { // The Intel optimization manual guidance in `3.11.5.3 Fixing Instruction Slowdowns` states: // Insert a VZEROUPPER to tell the hardware that the state of the higher registers is clean @@ -2053,6 +2058,7 @@ bool GenTreeCall::NeedsVzeroupper(Compiler* comp) if (varTypeUsesFloatReg(this)) { needsVzeroupper = true; + break; } else { @@ -2075,6 +2081,13 @@ bool GenTreeCall::NeedsVzeroupper(Compiler* comp) } } + // Other special cases + // + if (!needsVzeroupper && IsHelperCall(comp, CORINFO_HELP_BULK_WRITEBARRIER)) + { + needsVzeroupper = true; + } + return needsVzeroupper; } #endif // TARGET_XARCH @@ -2457,8 +2470,6 @@ bool GenTreeCall::IsRuntimeLookupHelperCall(Compiler* compiler) const { case CORINFO_HELP_RUNTIMEHANDLE_METHOD: case CORINFO_HELP_RUNTIMEHANDLE_CLASS: - case CORINFO_HELP_RUNTIMEHANDLE_METHOD_LOG: - case CORINFO_HELP_RUNTIMEHANDLE_CLASS_LOG: return true; default: return false; @@ -5373,11 +5384,6 @@ unsigned Compiler::gtSetEvalOrder(GenTree* tree) return gtSetEvalOrderMinOpts(tree); } -#ifdef DEBUG - /* Clear the GTF_DEBUG_NODE_MORPHED flag as well */ - tree->gtDebugFlags &= ~GTF_DEBUG_NODE_MORPHED; -#endif - /* Is this a FP value? */ bool isflt = varTypeIsFloating(tree->TypeGet()); @@ -16099,7 +16105,7 @@ GenTree* Compiler::gtFoldExprConst(GenTree* tree) case TYP_FLOAT: { -#if defined(TARGET_64BIT) +#ifdef TARGET_64BIT if (tree->IsUnsigned() && (lval1 < 0)) { f1 = FloatingPointUtils::convertUInt64ToFloat((uint64_t)lval1); @@ -17091,6 +17097,7 @@ GenTree* Compiler::gtNewTempStore( valTyp = lvaGetRealType(val->AsLclVar()->GetLclNum()); val->gtType = valTyp; } + var_types dstTyp = varDsc->TypeGet(); /* If the variable's lvType is not yet set then set it here */ @@ -17315,31 +17322,7 @@ bool Compiler::gtNodeHasSideEffects(GenTree* tree, GenTreeFlags flags, bool igno { GenTreeCall* const call = potentialCall->AsCall(); const bool ignoreExceptions = (flags & GTF_EXCEPT) == 0; - if (!call->HasSideEffects(this, ignoreExceptions, ignoreCctors)) - { - // If this call is otherwise side effect free, check its arguments. - for (CallArg& arg : call->gtArgs.Args()) - { - // I'm a little worried that args that assign to temps that are late args will look like - // side effects...but better to be conservative for now. - if ((arg.GetEarlyNode() != nullptr) && - gtTreeHasSideEffects(arg.GetEarlyNode(), flags, ignoreCctors)) - { - return true; - } - - if ((arg.GetLateNode() != nullptr) && gtTreeHasSideEffects(arg.GetLateNode(), flags, ignoreCctors)) - { - return true; - } - } - - // Otherwise: - return false; - } - - // Otherwise the GT_CALL is considered to have side-effects. - return true; + return call->HasSideEffects(this, ignoreExceptions, ignoreCctors); } } @@ -17377,39 +17360,28 @@ bool Compiler::gtTreeHasSideEffects(GenTree* tree, GenTreeFlags flags /* = GTF_S return false; } - if (sideEffectFlags == GTF_CALL) + if ((sideEffectFlags == GTF_CALL) && tree->IsHelperCall()) { - if (tree->OperGet() == GT_CALL) + // Generally all trees that contain GT_CALL nodes are considered to have side-effects. + // However, for some pure helper calls we lie about this. + if (gtNodeHasSideEffects(tree, flags, ignoreCctors)) { - // Generally all trees that contain GT_CALL nodes are considered to have side-effects. - // - if (tree->AsCall()->IsHelperCall()) - { - // If this node is a helper call we may not care about the side-effects. - // Note that gtNodeHasSideEffects checks the side effects of the helper itself - // as well as the side effects of its arguments. - return gtNodeHasSideEffects(tree, flags, ignoreCctors); - } + return true; } - else if (tree->OperGet() == GT_INTRINSIC) - { - if (gtNodeHasSideEffects(tree, flags, ignoreCctors)) - { - return true; - } - if (gtNodeHasSideEffects(tree->AsOp()->gtOp1, flags, ignoreCctors)) + // The GTF_CALL may be contributed by an operand, so check for + // that. + bool hasCallInOperand = false; + tree->VisitOperands([=, &hasCallInOperand](GenTree* op) { + if (gtTreeHasSideEffects(op, GTF_CALL, ignoreCctors)) { - return true; + hasCallInOperand = true; + return GenTree::VisitResult::Abort; } + return GenTree::VisitResult::Continue; + }); - if ((tree->AsOp()->gtOp2 != nullptr) && gtNodeHasSideEffects(tree->AsOp()->gtOp2, flags, ignoreCctors)) - { - return true; - } - - return false; - } + return hasCallInOperand; } return true; @@ -19683,10 +19655,17 @@ CORINFO_CLASS_HANDLE Compiler::gtGetClassHandle(GenTree* tree, bool* pIsExact, b // No benefit to calling gtGetFieldClassHandle here, as // the exact field being accessed can vary. CORINFO_FIELD_HANDLE fieldHnd = fieldSeq->GetFieldHandle(); + CORINFO_CLASS_HANDLE fieldOwner = NO_CLASS_HANDLE; CORINFO_CLASS_HANDLE fieldClass = NO_CLASS_HANDLE; - var_types fieldType = eeGetFieldType(fieldHnd, &fieldClass); - if (fieldType == TYP_REF) + // fieldOwner helps us to get a more exact field class for instance fields + if (!fieldSeq->IsStaticField()) + { + bool objIsExact, objIsNonNull; + fieldOwner = gtGetClassHandle(op1, &objIsExact, &objIsNonNull); + } + + if (eeGetFieldType(fieldHnd, &fieldClass, fieldOwner) == TYP_REF) { objClass = fieldClass; } @@ -20714,6 +20693,8 @@ bool GenTree::isCommutativeHWIntrinsic() const case NI_AVX512F_Add: case NI_AVX512F_Multiply: + case NI_BMI2_MultiplyNoFlags: + case NI_BMI2_X64_MultiplyNoFlags: { return node->GetOperandCount() == 2; } @@ -21330,6 +21311,16 @@ GenTree* Compiler::gtNewSimdBinOpNode( if (op2->IsCnsIntOrI()) { op2->AsIntCon()->gtIconVal &= shiftCountMask; +#ifdef TARGET_ARM64 + // On ARM64, ShiftRight* intrinsics cannot encode a shift value of zero, + // so use the generic Shift* fallback intrinsic. + // GenTreeHWIntrinsic::GetHWIntrinsicIdForBinOp will see that the immediate node is not const, + // and return the correct fallback intrinsic. + if ((op != GT_LSH) && (op2->AsIntCon()->IconValue() == 0)) + { + op2 = gtNewZeroConNode(type); + } +#endif // TARGET_ARM64 } else { @@ -21354,13 +21345,6 @@ GenTree* Compiler::gtNewSimdBinOpNode( { GenTree** broadcastOp = nullptr; -#if defined(TARGET_ARM64) - if (varTypeIsLong(simdBaseType)) - { - break; - } -#endif // TARGET_ARM64 - if (varTypeIsArithmetic(op1)) { broadcastOp = &op1; @@ -21368,7 +21352,7 @@ GenTree* Compiler::gtNewSimdBinOpNode( #if defined(TARGET_ARM64) if (!varTypeIsByte(simdBaseType)) { - // MultiplyByScalar requires the scalar op to be op2fGetHWIntrinsicIdForBinOp + // MultiplyByScalar requires the scalar op to be op2 for GetHWIntrinsicIdForBinOp needsReverseOps = true; } #endif // TARGET_ARM64 @@ -21381,7 +21365,12 @@ GenTree* Compiler::gtNewSimdBinOpNode( if (broadcastOp != nullptr) { #if defined(TARGET_ARM64) - if (!varTypeIsByte(simdBaseType)) + if (varTypeIsLong(simdBaseType)) + { + // This is handled via emulation and the scalar is consumed directly + break; + } + else if (!varTypeIsByte(simdBaseType)) { op2ForLookup = *broadcastOp; *broadcastOp = gtNewSimdCreateScalarUnsafeNode(TYP_SIMD8, *broadcastOp, simdBaseJitType, 8); @@ -21458,6 +21447,13 @@ GenTree* Compiler::gtNewSimdBinOpNode( std::swap(op1, op2); #endif // TARGET_XARCH } +#ifdef TARGET_XARCH + if (HWIntrinsicInfo::NeedsNormalizeSmallTypeToInt(intrinsic) && varTypeIsSmall(simdBaseType)) + { + simdBaseJitType = varTypeIsUnsigned(simdBaseType) ? CORINFO_TYPE_UINT : CORINFO_TYPE_INT; + simdBaseType = JitType2PreciseVarType(simdBaseJitType); + } +#endif // TARGET_XARCH return gtNewSimdHWIntrinsicNode(type, op1, op2, intrinsic, simdBaseJitType, simdSize); } @@ -21778,16 +21774,13 @@ GenTree* Compiler::gtNewSimdBinOpNode( #elif defined(TARGET_ARM64) if (varTypeIsLong(simdBaseType)) { - GenTree** op1ToDup = &op1; - GenTree** op2ToDup = &op2; + GenTree** op2ToDup = nullptr; - if (!varTypeIsArithmetic(op1)) - { - op1 = gtNewSimdToScalarNode(TYP_LONG, op1, simdBaseJitType, simdSize); - op1ToDup = &op1->AsHWIntrinsic()->Op(1); - } + assert(varTypeIsSIMD(op1)); + op1 = gtNewSimdToScalarNode(TYP_LONG, op1, simdBaseJitType, simdSize); + GenTree** op1ToDup = &op1->AsHWIntrinsic()->Op(1); - if (!varTypeIsArithmetic(op2)) + if (varTypeIsSIMD(op2)) { op2 = gtNewSimdToScalarNode(TYP_LONG, op2, simdBaseJitType, simdSize); op2ToDup = &op2->AsHWIntrinsic()->Op(1); @@ -21795,7 +21788,12 @@ GenTree* Compiler::gtNewSimdBinOpNode( // lower = op1.GetElement(0) * op2.GetElement(0) GenTree* lower = gtNewOperNode(GT_MUL, TYP_LONG, op1, op2); - lower = gtNewSimdCreateScalarUnsafeNode(type, lower, simdBaseJitType, simdSize); + + if (op2ToDup == nullptr) + { + op2ToDup = &lower->AsOp()->gtOp2; + } + lower = gtNewSimdCreateScalarUnsafeNode(type, lower, simdBaseJitType, simdSize); if (simdSize == 8) { @@ -21807,10 +21805,8 @@ GenTree* Compiler::gtNewSimdBinOpNode( GenTree* op1Dup = fgMakeMultiUse(op1ToDup); GenTree* op2Dup = fgMakeMultiUse(op2ToDup); - if (!varTypeIsArithmetic(op1Dup)) - { - op1Dup = gtNewSimdGetElementNode(TYP_LONG, op1Dup, gtNewIconNode(1), simdBaseJitType, simdSize); - } + assert(!varTypeIsArithmetic(op1Dup)); + op1Dup = gtNewSimdGetElementNode(TYP_LONG, op1Dup, gtNewIconNode(1), simdBaseJitType, simdSize); if (!varTypeIsArithmetic(op2Dup)) { @@ -26216,6 +26212,15 @@ GenTree* Compiler::gtNewSimdTernaryLogicNode(var_types type, intrinsic = NI_AVX512F_VL_TernaryLogic; } +#ifdef TARGET_XARCH + assert(HWIntrinsicInfo::NeedsNormalizeSmallTypeToInt(intrinsic)); + if (varTypeIsSmall(simdBaseType)) + { + simdBaseJitType = varTypeIsUnsigned(simdBaseType) ? CORINFO_TYPE_UINT : CORINFO_TYPE_INT; + simdBaseType = JitType2PreciseVarType(simdBaseJitType); + } +#endif // TARGET_XARCH + return gtNewSimdHWIntrinsicNode(type, op1, op2, op3, op4, intrinsic, simdBaseJitType, simdSize); } #endif // TARGET_XARCH @@ -27202,16 +27207,27 @@ bool GenTreeHWIntrinsic::OperIsMemoryLoad(GenTree** pAddr) const case NI_Sve_GatherVector: case NI_Sve_GatherVectorByteZeroExtend: + case NI_Sve_GatherVectorByteZeroExtendFirstFaulting: case NI_Sve_GatherVectorFirstFaulting: case NI_Sve_GatherVectorInt16SignExtend: + case NI_Sve_GatherVectorInt16SignExtendFirstFaulting: case NI_Sve_GatherVectorInt16WithByteOffsetsSignExtend: + case NI_Sve_GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting: case NI_Sve_GatherVectorInt32SignExtend: + case NI_Sve_GatherVectorInt32SignExtendFirstFaulting: case NI_Sve_GatherVectorInt32WithByteOffsetsSignExtend: + case NI_Sve_GatherVectorInt32WithByteOffsetsSignExtendFirstFaulting: case NI_Sve_GatherVectorSByteSignExtend: + case NI_Sve_GatherVectorSByteSignExtendFirstFaulting: case NI_Sve_GatherVectorUInt16WithByteOffsetsZeroExtend: + case NI_Sve_GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting: case NI_Sve_GatherVectorUInt16ZeroExtend: + case NI_Sve_GatherVectorUInt16ZeroExtendFirstFaulting: case NI_Sve_GatherVectorUInt32WithByteOffsetsZeroExtend: + case NI_Sve_GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting: case NI_Sve_GatherVectorUInt32ZeroExtend: + case NI_Sve_GatherVectorUInt32ZeroExtendFirstFaulting: + case NI_Sve_GatherVectorWithByteOffsetFirstFaulting: case NI_Sve_GatherVectorWithByteOffsets: case NI_Sve_LoadVector: case NI_Sve_LoadVectorNonTemporal: @@ -27332,14 +27348,24 @@ bool GenTreeHWIntrinsic::OperIsMemoryLoad(GenTree** pAddr) const { #ifdef TARGET_ARM64 static_assert_no_msg( - AreContiguous(NI_Sve_GatherVector, NI_Sve_GatherVectorByteZeroExtend, NI_Sve_GatherVectorFirstFaulting, - NI_Sve_GatherVectorInt16SignExtend, NI_Sve_GatherVectorInt16WithByteOffsetsSignExtend, - NI_Sve_GatherVectorInt32SignExtend, NI_Sve_GatherVectorInt32WithByteOffsetsSignExtend, - NI_Sve_GatherVectorSByteSignExtend, NI_Sve_GatherVectorUInt16WithByteOffsetsZeroExtend, - NI_Sve_GatherVectorUInt16ZeroExtend, NI_Sve_GatherVectorUInt32WithByteOffsetsZeroExtend, - NI_Sve_GatherVectorUInt32ZeroExtend)); - assert(varTypeIsI(addr) || (varTypeIsSIMD(addr) && ((intrinsicId >= NI_Sve_GatherVector) && - (intrinsicId <= NI_Sve_GatherVectorUInt32ZeroExtend)))); + AreContiguous(NI_Sve_GatherVector, NI_Sve_GatherVectorByteZeroExtend, + NI_Sve_GatherVectorByteZeroExtendFirstFaulting, NI_Sve_GatherVectorFirstFaulting, + NI_Sve_GatherVectorInt16SignExtend, NI_Sve_GatherVectorInt16SignExtendFirstFaulting, + NI_Sve_GatherVectorInt16WithByteOffsetsSignExtend, + NI_Sve_GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting, + NI_Sve_GatherVectorInt32SignExtend, NI_Sve_GatherVectorInt32SignExtendFirstFaulting, + NI_Sve_GatherVectorInt32WithByteOffsetsSignExtend, + NI_Sve_GatherVectorInt32WithByteOffsetsSignExtendFirstFaulting, + NI_Sve_GatherVectorSByteSignExtend, NI_Sve_GatherVectorSByteSignExtendFirstFaulting, + NI_Sve_GatherVectorUInt16WithByteOffsetsZeroExtend, + NI_Sve_GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting, + NI_Sve_GatherVectorUInt16ZeroExtend, NI_Sve_GatherVectorUInt16ZeroExtendFirstFaulting, + NI_Sve_GatherVectorUInt32WithByteOffsetsZeroExtend, + NI_Sve_GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting, + NI_Sve_GatherVectorUInt32ZeroExtend, NI_Sve_GatherVectorUInt32ZeroExtendFirstFaulting)); + assert(varTypeIsI(addr) || + (varTypeIsSIMD(addr) && ((intrinsicId >= NI_Sve_GatherVector) && + (intrinsicId <= NI_Sve_GatherVectorUInt32ZeroExtendFirstFaulting)))); #else assert(varTypeIsI(addr)); #endif @@ -27496,6 +27522,13 @@ bool GenTreeHWIntrinsic::OperIsEmbBroadcastCompatible() const NamedIntrinsic intrinsicId = GetHWIntrinsicId(); var_types simdBaseType = GetSimdBaseType(); + // MaybeImm intrinsics support embedded broadcasts only for their IMM variants (e.g. PSLLQ) + if (HWIntrinsicInfo::MaybeImm(intrinsicId) && + !HWIntrinsicInfo::isImmOp(intrinsicId, GetOperandArray()[GetOperandCount() - 1])) + { + return false; + } + switch (intrinsicId) { case NI_AVX512F_ConvertToVector256Int32: @@ -32311,3 +32344,116 @@ GenTree* Compiler::gtFoldExprHWIntrinsic(GenTreeHWIntrinsic* tree) return resultNode; } #endif // FEATURE_HW_INTRINSICS + +//------------------------------------------------------------------------ +// gtCanSkipCovariantStoreCheck: see if storing a ref type value to an array +// can skip the array store covariance check. +// +// Arguments: +// value -- tree producing the value to store +// array -- tree representing the array to store to +// +// Returns: +// true if the store does not require a covariance check. +// +bool Compiler::gtCanSkipCovariantStoreCheck(GenTree* value, GenTree* array) +{ + // We should only call this when optimizing. + assert(opts.OptimizationEnabled()); + + // Check for store to same array, ie. arrLcl[i] = arrLcl[j] + if (value->OperIs(GT_IND) && value->AsIndir()->Addr()->OperIs(GT_INDEX_ADDR) && array->OperIs(GT_LCL_VAR)) + { + GenTree* valueArray = value->AsIndir()->Addr()->AsIndexAddr()->Arr(); + if (valueArray->OperIs(GT_LCL_VAR)) + { + unsigned valueArrayLcl = valueArray->AsLclVar()->GetLclNum(); + unsigned arrayLcl = array->AsLclVar()->GetLclNum(); + if ((valueArrayLcl == arrayLcl) && !lvaGetDesc(arrayLcl)->IsAddressExposed()) + { + JITDUMP("\nstelem of ref from same array: skipping covariant store check\n"); + return true; + } + } + } + + // Check for store of NULL. + if (value->OperIs(GT_CNS_INT)) + { + assert(value->gtType == TYP_REF); + if (value->AsIntCon()->gtIconVal == 0) + { + JITDUMP("\nstelem of null: skipping covariant store check\n"); + return true; + } + // Non-0 const refs can only occur with frozen objects + assert(value->IsIconHandle(GTF_ICON_OBJ_HDL)); + assert(doesMethodHaveFrozenObjects() || + (compIsForInlining() && impInlineInfo->InlinerCompiler->doesMethodHaveFrozenObjects())); + } + + // Try and get a class handle for the array + if (!value->TypeIs(TYP_REF)) + { + return false; + } + + bool arrayIsExact = false; + bool arrayIsNonNull = false; + CORINFO_CLASS_HANDLE arrayHandle = gtGetClassHandle(array, &arrayIsExact, &arrayIsNonNull); + + if (arrayHandle == NO_CLASS_HANDLE) + { + return false; + } + + // There are some methods in corelib where we're storing to an array but the IL + // doesn't reflect this (see SZArrayHelper). Avoid. + DWORD attribs = info.compCompHnd->getClassAttribs(arrayHandle); + if ((attribs & CORINFO_FLG_ARRAY) == 0) + { + return false; + } + + CORINFO_CLASS_HANDLE arrayElementHandle = nullptr; + CorInfoType arrayElemType = info.compCompHnd->getChildType(arrayHandle, &arrayElementHandle); + + // Verify array type handle is really an array of ref type + assert(arrayElemType == CORINFO_TYPE_CLASS); + + // Check for exactly object[] + if (arrayIsExact && (arrayElementHandle == impGetObjectClass())) + { + JITDUMP("\nstelem to (exact) object[]: skipping covariant store check\n"); + return true; + } + + const bool arrayTypeIsSealed = info.compCompHnd->isExactType(arrayElementHandle); + + if ((!arrayIsExact && !arrayTypeIsSealed) || (arrayElementHandle == NO_CLASS_HANDLE)) + { + // Bail out if we don't know array's exact type + return false; + } + + bool valueIsExact = false; + bool valueIsNonNull = false; + CORINFO_CLASS_HANDLE valueHandle = gtGetClassHandle(value, &valueIsExact, &valueIsNonNull); + + // Array's type is sealed and equals to value's type + if (arrayTypeIsSealed && (valueHandle == arrayElementHandle)) + { + JITDUMP("\nstelem to T[] with T exact: skipping covariant store check\n"); + return true; + } + + // Array's type is not sealed but we know its exact type + if (arrayIsExact && (valueHandle != NO_CLASS_HANDLE) && + (info.compCompHnd->compareTypesForCast(valueHandle, arrayElementHandle) == TypeCompareState::Must)) + { + JITDUMP("\nstelem to T[] with T exact: skipping covariant store check\n"); + return true; + } + + return false; +} diff --git a/src/coreclr/jit/gentree.h b/src/coreclr/jit/gentree.h index a33377ec5dc..9f1add493fa 100644 --- a/src/coreclr/jit/gentree.h +++ b/src/coreclr/jit/gentree.h @@ -6712,6 +6712,20 @@ struct GenTreeHWIntrinsic : public GenTreeJitIntrinsic bool ShouldConstantProp(GenTree* operand, GenTreeVecCon* vecCon); + void NormalizeJitBaseTypeToInt(NamedIntrinsic id, var_types simdBaseType) + { + assert(varTypeIsSmall(simdBaseType)); + + if (varTypeIsUnsigned(simdBaseType)) + { + SetSimdBaseJitType(CORINFO_TYPE_UINT); + } + else + { + SetSimdBaseJitType(CORINFO_TYPE_UINT); + } + } + private: void SetHWIntrinsicId(NamedIntrinsic intrinsicId); diff --git a/src/coreclr/jit/gschecks.cpp b/src/coreclr/jit/gschecks.cpp index 0baa5ad289c..06802181eea 100644 --- a/src/coreclr/jit/gschecks.cpp +++ b/src/coreclr/jit/gschecks.cpp @@ -516,13 +516,59 @@ void Compiler::gsParamsToShadows() continue; } - GenTree* src = gtNewLclvNode(lclNum, varDsc->TypeGet()); - src->gtFlags |= GTF_DONT_CSE; - GenTree* store = gtNewStoreLclVarNode(shadowVarNum, src); +#if defined(TARGET_X86) && defined(FEATURE_IJW) + if (lclNum < info.compArgsCount && argRequiresSpecialCopy(lclNum) && (varDsc->TypeGet() == TYP_STRUCT)) + { + JITDUMP("arg%02u requires special copy, using special copy helper to copy to shadow var V%02u\n", lclNum, + shadowVarNum); + CORINFO_METHOD_HANDLE copyHelper = + info.compCompHnd->getSpecialCopyHelper(varDsc->GetLayout()->GetClassHandle()); + GenTreeCall* call = gtNewCallNode(CT_USER_FUNC, copyHelper, TYP_VOID); + + GenTree* src = gtNewLclVarAddrNode(lclNum); + GenTree* dst = gtNewLclVarAddrNode(shadowVarNum); + + call->gtArgs.PushBack(this, NewCallArg::Primitive(dst)); + call->gtArgs.PushBack(this, NewCallArg::Primitive(src)); + + fgEnsureFirstBBisScratch(); + compCurBB = fgFirstBB; // Needed by some morphing + if (opts.IsReversePInvoke()) + { + JITDUMP( + "Inserting special copy helper call at the end of the first block after Reverse P/Invoke transition\n"); + +#ifdef DEBUG + // assert that we don't have any uses of the local variable in the first block + // before we insert the shadow copy statement. + for (Statement* const stmt : fgFirstBB->Statements()) + { + assert(!gtHasRef(stmt->GetRootNode(), lclNum)); + } +#endif + // If we are in a reverse P/Invoke, then we need to insert + // the call at the end of the first block as we need to do the GC transition + // before we can call the helper. + (void)fgNewStmtAtEnd(fgFirstBB, fgMorphTree(call)); + } + else + { + JITDUMP("Inserting special copy helper call at the beginning of the first block\n"); + (void)fgNewStmtAtBeg(fgFirstBB, fgMorphTree(call)); + } + } + else +#endif // TARGET_X86 && FEATURE_IJW + { + GenTree* src = gtNewLclvNode(lclNum, varDsc->TypeGet()); + src->gtFlags |= GTF_DONT_CSE; - fgEnsureFirstBBisScratch(); - compCurBB = fgFirstBB; // Needed by some morphing - (void)fgNewStmtAtBeg(fgFirstBB, fgMorphTree(store)); + GenTree* store = gtNewStoreLclVarNode(shadowVarNum, src); + + fgEnsureFirstBBisScratch(); + compCurBB = fgFirstBB; // Needed by some morphing + (void)fgNewStmtAtBeg(fgFirstBB, fgMorphTree(store)); + } } compCurBB = nullptr; diff --git a/src/coreclr/jit/hwintrinsic.cpp b/src/coreclr/jit/hwintrinsic.cpp index dbadcb8fb22..72b0550b7d8 100644 --- a/src/coreclr/jit/hwintrinsic.cpp +++ b/src/coreclr/jit/hwintrinsic.cpp @@ -718,7 +718,6 @@ uint8_t TernaryLogicInfo::GetTernaryControlByte(const TernaryLogicInfo& info, ui // // Arguments: // intrinsic -- id of the intrinsic function. -// clsHnd -- class handle containing the intrinsic function. // method -- method handle of the intrinsic function. // sig -- signature of the intrinsic call. // simdBaseJitType -- Predetermined simdBaseJitType, could be CORINFO_TYPE_UNDEF @@ -726,10 +725,9 @@ uint8_t TernaryLogicInfo::GetTernaryControlByte(const TernaryLogicInfo& info, ui // Return Value: // The basetype of intrinsic of it can be fetched from 1st or 2nd argument, else return baseType unmodified. // -CorInfoType Compiler::getBaseJitTypeFromArgIfNeeded(NamedIntrinsic intrinsic, - CORINFO_CLASS_HANDLE clsHnd, - CORINFO_SIG_INFO* sig, - CorInfoType simdBaseJitType) +CorInfoType Compiler::getBaseJitTypeFromArgIfNeeded(NamedIntrinsic intrinsic, + CORINFO_SIG_INFO* sig, + CorInfoType simdBaseJitType) { if (HWIntrinsicInfo::BaseTypeFromSecondArg(intrinsic) || HWIntrinsicInfo::BaseTypeFromFirstArg(intrinsic)) { @@ -1332,7 +1330,6 @@ GenTree* Compiler::getArgForHWIntrinsic(var_types argType, CORINFO_CLASS_HANDLE // Arguments: // intrinsic -- intrinsic ID // immOp -- the immediate operand of the intrinsic -// mustExpand -- true if the compiler is compiling the fallback(GT_CALL) of this intrinsics // immLowerBound -- lower incl. bound for a value of the immediate operand (for a non-full-range imm-intrinsic) // immUpperBound -- upper incl. bound for a value of the immediate operand (for a non-full-range imm-intrinsic) // @@ -1340,21 +1337,19 @@ GenTree* Compiler::getArgForHWIntrinsic(var_types argType, CORINFO_CLASS_HANDLE // add a GT_BOUNDS_CHECK node for non-full-range imm-intrinsic, which would throw ArgumentOutOfRangeException // when the imm-argument is not in the valid range // -GenTree* Compiler::addRangeCheckIfNeeded( - NamedIntrinsic intrinsic, GenTree* immOp, bool mustExpand, int immLowerBound, int immUpperBound) +GenTree* Compiler::addRangeCheckIfNeeded(NamedIntrinsic intrinsic, GenTree* immOp, int immLowerBound, int immUpperBound) { assert(immOp != nullptr); // Full-range imm-intrinsics do not need the range-check // because the imm-parameter of the intrinsic method is a byte. // AVX2 Gather intrinsics no not need the range-check // because their imm-parameter have discrete valid values that are handle by managed code - if (mustExpand && HWIntrinsicInfo::isImmOp(intrinsic, immOp) + if (!immOp->IsCnsIntOrI() && HWIntrinsicInfo::isImmOp(intrinsic, immOp) #ifdef TARGET_XARCH && !HWIntrinsicInfo::isAVX2GatherIntrinsic(intrinsic) && !HWIntrinsicInfo::HasFullRangeImm(intrinsic) #endif ) { - assert(!immOp->IsCnsIntOrI()); assert(varTypeIsIntegral(immOp)); return addRangeCheckForHWIntrinsic(immOp, immLowerBound, immUpperBound); @@ -1596,7 +1591,6 @@ bool Compiler::CheckHWIntrinsicImmRange(NamedIntrinsic intrinsic, if (immOutOfRange) { - assert(!mustExpand); // The imm-HWintrinsics that do not accept all imm8 values may throw // ArgumentOutOfRangeException when the imm argument is not in the valid range, // unless the intrinsic can be transformed into one that does accept all imm8 values @@ -1764,7 +1758,8 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic intrinsic, } } - simdBaseJitType = getBaseJitTypeFromArgIfNeeded(intrinsic, clsHnd, sig, simdBaseJitType); + simdBaseJitType = getBaseJitTypeFromArgIfNeeded(intrinsic, sig, simdBaseJitType); + unsigned simdSize = 0; if (simdBaseJitType == CORINFO_TYPE_UNDEF) { @@ -1783,7 +1778,7 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic intrinsic, simdBaseJitType = getBaseJitTypeAndSizeOfSIMDType(clsHnd, &sizeBytes); -#if defined(TARGET_ARM64) +#ifdef TARGET_ARM64 if (simdBaseJitType == CORINFO_TYPE_UNDEF && HWIntrinsicInfo::HasScalarInputVariant(intrinsic)) { // Did not find a valid vector type. The intrinsic has alternate scalar version. Switch to that. @@ -1799,12 +1794,38 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic intrinsic, assert(simdBaseJitType != CORINFO_TYPE_VALUECLASS); } else -#endif +#endif // TARGET_ARM64 { assert((category == HW_Category_Special) || (category == HW_Category_Helper) || (sizeBytes != 0)); } } } +#ifdef TARGET_ARM64 + else if ((simdBaseJitType == CORINFO_TYPE_VALUECLASS) && (HWIntrinsicInfo::BaseTypeFromValueTupleArg(intrinsic))) + { + // If HW_Flag_BaseTypeFromValueTupleArg is set, one of the base type position flags must be set. + assert(HWIntrinsicInfo::BaseTypeFromFirstArg(intrinsic) || HWIntrinsicInfo::BaseTypeFromSecondArg(intrinsic)); + + CORINFO_ARG_LIST_HANDLE arg = sig->args; + + if (HWIntrinsicInfo::BaseTypeFromSecondArg(intrinsic)) + { + arg = info.compCompHnd->getArgNext(arg); + } + + CORINFO_CLASS_HANDLE argClass = info.compCompHnd->getArgClass(sig, arg); + INDEBUG(unsigned fieldCount = info.compCompHnd->getClassNumInstanceFields(argClass)); + assert(fieldCount > 1); + + CORINFO_CLASS_HANDLE classHnd; + CORINFO_FIELD_HANDLE fieldHandle = info.compCompHnd->getFieldInClass(argClass, 0); + CorInfoType fieldType = info.compCompHnd->getFieldType(fieldHandle, &classHnd); + assert(isIntrinsicType(classHnd)); + + simdBaseJitType = getBaseJitTypeAndSizeOfSIMDType(classHnd, &simdSize); + assert(simdSize > 0); + } +#endif // TARGET_ARM64 // Immediately return if the category is other than scalar/special and this is not a supported base type. if ((category != HW_Category_Special) && (category != HW_Category_Scalar) && !HWIntrinsicInfo::isScalarIsa(isa) && @@ -1818,9 +1839,18 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic intrinsic, if (simdBaseJitType != CORINFO_TYPE_UNDEF) { simdBaseType = JitType2PreciseVarType(simdBaseJitType); +#ifdef TARGET_XARCH + if (HWIntrinsicInfo::NeedsNormalizeSmallTypeToInt(intrinsic) && varTypeIsSmall(simdBaseType)) + { + simdBaseJitType = varTypeIsUnsigned(simdBaseType) ? CORINFO_TYPE_UINT : CORINFO_TYPE_INT; + simdBaseType = JitType2PreciseVarType(simdBaseJitType); + } +#endif // TARGET_XARCH } - const unsigned simdSize = HWIntrinsicInfo::lookupSimdSize(this, intrinsic, sig); + // We may have already determined simdSize for intrinsics that require special handling. + // If so, skip the lookup. + simdSize = (simdSize == 0) ? HWIntrinsicInfo::lookupSimdSize(this, intrinsic, sig) : simdSize; HWIntrinsicSignatureReader sigReader; sigReader.Read(info.compCompHnd, sig); @@ -1852,15 +1882,30 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic intrinsic, { return impNonConstFallback(intrinsic, retType, simdBaseJitType); } - else if (!opts.OptimizationEnabled()) + else if (immOp2->IsCnsIntOrI()) { - // Only enable late stage rewriting if optimizations are enabled - // as we won't otherwise encounter a constant at the later point - return nullptr; + // If we know the immediate is out-of-range, + // convert the intrinsic into a user call (or throw if we must expand) + return impUnsupportedNamedIntrinsic(CORINFO_HELP_THROW_ARGUMENTOUTOFRANGEEXCEPTION, method, sig, + mustExpand); } else { - setMethodHandle = true; + // The immediate is unknown, and we aren't using a fallback intrinsic. + // In this case, CheckHWIntrinsicImmRange should not return false for intrinsics that must expand. + assert(!mustExpand); + + if (opts.OptimizationEnabled()) + { + // Only enable late stage rewriting if optimizations are enabled + // as we won't otherwise encounter a constant at the later point + setMethodHandle = true; + } + else + { + // Just convert to a user call + return nullptr; + } } } } @@ -1889,15 +1934,30 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic intrinsic, { return impNonConstFallback(intrinsic, retType, simdBaseJitType); } - else if (!opts.OptimizationEnabled()) + else if (immOp1->IsCnsIntOrI()) { - // Only enable late stage rewriting if optimizations are enabled - // as we won't otherwise encounter a constant at the later point - return nullptr; + // If we know the immediate is out-of-range, + // convert the intrinsic into a user call (or throw if we must expand) + return impUnsupportedNamedIntrinsic(CORINFO_HELP_THROW_ARGUMENTOUTOFRANGEEXCEPTION, method, sig, + mustExpand); } else { - setMethodHandle = true; + // The immediate is unknown, and we aren't using a fallback intrinsic. + // In this case, CheckHWIntrinsicImmRange should not return false for intrinsics that must expand. + assert(!mustExpand); + + if (opts.OptimizationEnabled()) + { + // Only enable late stage rewriting if optimizations are enabled + // as we won't otherwise encounter a constant at the later point + setMethodHandle = true; + } + else + { + // Just convert to a user call + return nullptr; + } } } } @@ -1953,7 +2013,7 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic intrinsic, { case 4: op4 = getArgForHWIntrinsic(sigReader.GetOp4Type(), sigReader.op4ClsHnd); - op4 = addRangeCheckIfNeeded(intrinsic, op4, mustExpand, immLowerBound, immUpperBound); + op4 = addRangeCheckIfNeeded(intrinsic, op4, immLowerBound, immUpperBound); op3 = getArgForHWIntrinsic(sigReader.GetOp3Type(), sigReader.op3ClsHnd); op2 = getArgForHWIntrinsic(sigReader.GetOp2Type(), sigReader.op2ClsHnd); op1 = getArgForHWIntrinsic(sigReader.GetOp1Type(), sigReader.op1ClsHnd); @@ -1967,7 +2027,7 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic intrinsic, case 2: op2 = getArgForHWIntrinsic(sigReader.GetOp2Type(), sigReader.op2ClsHnd); - op2 = addRangeCheckIfNeeded(intrinsic, op2, mustExpand, immLowerBound, immUpperBound); + op2 = addRangeCheckIfNeeded(intrinsic, op2, immLowerBound, immUpperBound); op1 = getArgForHWIntrinsic(sigReader.GetOp1Type(), sigReader.op1ClsHnd); break; @@ -2137,7 +2197,7 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic intrinsic, #ifdef TARGET_ARM64 if (intrinsic == NI_AdvSimd_LoadAndInsertScalar) { - op2 = addRangeCheckIfNeeded(intrinsic, op2, mustExpand, immLowerBound, immUpperBound); + op2 = addRangeCheckIfNeeded(intrinsic, op2, immLowerBound, immUpperBound); if (op1->OperIs(GT_CAST)) { @@ -2151,12 +2211,12 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic intrinsic, } else if ((intrinsic == NI_AdvSimd_Insert) || (intrinsic == NI_AdvSimd_InsertScalar)) { - op2 = addRangeCheckIfNeeded(intrinsic, op2, mustExpand, immLowerBound, immUpperBound); + op2 = addRangeCheckIfNeeded(intrinsic, op2, immLowerBound, immUpperBound); } else #endif { - op3 = addRangeCheckIfNeeded(intrinsic, op3, mustExpand, immLowerBound, immUpperBound); + op3 = addRangeCheckIfNeeded(intrinsic, op3, immLowerBound, immUpperBound); } retNode = isScalar ? gtNewScalarHWIntrinsicNode(nodeRetType, op1, op2, op3, intrinsic) @@ -2175,17 +2235,28 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic intrinsic, #elif defined(TARGET_ARM64) case NI_Sve_GatherVector: case NI_Sve_GatherVectorByteZeroExtend: + case NI_Sve_GatherVectorByteZeroExtendFirstFaulting: case NI_Sve_GatherVectorFirstFaulting: case NI_Sve_GatherVectorInt16SignExtend: + case NI_Sve_GatherVectorInt16SignExtendFirstFaulting: case NI_Sve_GatherVectorInt16WithByteOffsetsSignExtend: + case NI_Sve_GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting: case NI_Sve_GatherVectorInt32SignExtend: + case NI_Sve_GatherVectorInt32SignExtendFirstFaulting: case NI_Sve_GatherVectorInt32WithByteOffsetsSignExtend: + case NI_Sve_GatherVectorInt32WithByteOffsetsSignExtendFirstFaulting: case NI_Sve_GatherVectorSByteSignExtend: + case NI_Sve_GatherVectorSByteSignExtendFirstFaulting: case NI_Sve_GatherVectorUInt16WithByteOffsetsZeroExtend: + case NI_Sve_GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting: case NI_Sve_GatherVectorUInt16ZeroExtend: + case NI_Sve_GatherVectorUInt16ZeroExtendFirstFaulting: case NI_Sve_GatherVectorUInt32WithByteOffsetsZeroExtend: + case NI_Sve_GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting: case NI_Sve_GatherVectorUInt32ZeroExtend: + case NI_Sve_GatherVectorWithByteOffsetFirstFaulting: case NI_Sve_GatherVectorWithByteOffsets: + case NI_Sve_GatherVectorUInt32ZeroExtendFirstFaulting: assert(varTypeIsSIMD(op3->TypeGet())); if (numArgs == 3) { @@ -2243,13 +2314,6 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic intrinsic, } #if defined(FEATURE_MASKED_HW_INTRINSICS) && defined(TARGET_ARM64) - auto convertToMaskIfNeeded = [&](GenTree*& op) { - if (!varTypeIsMask(op)) - { - op = gtNewSimdCvtVectorToMaskNode(TYP_MASK, op, simdBaseJitType, simdSize); - } - }; - if (HWIntrinsicInfo::IsExplicitMaskedOperation(intrinsic)) { assert(numArgs > 0); @@ -2260,7 +2324,8 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic intrinsic, case NI_Sve_CreateBreakBeforePropagateMask: { // HWInstrinsic requires a mask for op3 - convertToMaskIfNeeded(retNode->AsHWIntrinsic()->Op(3)); + GenTree*& op = retNode->AsHWIntrinsic()->Op(3); + op = gtNewSimdCvtVectorToMaskNode(TYP_MASK, op, simdBaseJitType, simdSize); FALLTHROUGH; } case NI_Sve_CreateBreakAfterMask: @@ -2273,13 +2338,15 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic intrinsic, case NI_Sve_TestLastTrue: { // HWInstrinsic requires a mask for op2 - convertToMaskIfNeeded(retNode->AsHWIntrinsic()->Op(2)); + GenTree*& op = retNode->AsHWIntrinsic()->Op(2); + op = gtNewSimdCvtVectorToMaskNode(TYP_MASK, op, simdBaseJitType, simdSize); FALLTHROUGH; } default: { // HWInstrinsic requires a mask for op1 - convertToMaskIfNeeded(retNode->AsHWIntrinsic()->Op(1)); + GenTree*& op = retNode->AsHWIntrinsic()->Op(1); + op = gtNewSimdCvtVectorToMaskNode(TYP_MASK, op, simdBaseJitType, simdSize); break; } } @@ -2299,8 +2366,10 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic intrinsic, { case NI_Sve_CreateBreakPropagateMask: { - convertToMaskIfNeeded(retNode->AsHWIntrinsic()->Op(1)); - convertToMaskIfNeeded(retNode->AsHWIntrinsic()->Op(2)); + GenTree*& op1 = retNode->AsHWIntrinsic()->Op(1); + GenTree*& op2 = retNode->AsHWIntrinsic()->Op(2); + op1 = gtNewSimdCvtVectorToMaskNode(TYP_MASK, op1, simdBaseJitType, simdSize); + op2 = gtNewSimdCvtVectorToMaskNode(TYP_MASK, op2, simdBaseJitType, simdSize); break; } diff --git a/src/coreclr/jit/hwintrinsic.h b/src/coreclr/jit/hwintrinsic.h index a334942c2fd..c907fd95d03 100644 --- a/src/coreclr/jit/hwintrinsic.h +++ b/src/coreclr/jit/hwintrinsic.h @@ -156,6 +156,24 @@ enum HWIntrinsicFlag : unsigned int // The intrinsic has no EVEX compatible form HW_Flag_NoEvexSemantics = 0x100000, + // The intrinsic is an RMW intrinsic + HW_Flag_RmwIntrinsic = 0x200000, + + // The intrinsic is a PermuteVar2x intrinsic + HW_Flag_PermuteVar2x = 0x400000, + + // The intrinsic is an embedded broadcast compatible intrinsic + HW_Flag_EmbBroadcastCompatible = 0x800000, + + // The intrinsic is an embedded rounding compatible intrinsic + HW_Flag_EmbRoundingCompatible = 0x1000000, + + // The intrinsic is an embedded masking compatible intrinsic + HW_Flag_EmbMaskingCompatible = 0x2000000, + + // The base type of this intrinsic needs to be normalized to int/uint unless it is long/ulong. + HW_Flag_NormalizeSmallTypeToInt = 0x4000000, + #elif defined(TARGET_ARM64) // The intrinsic has an immediate operand // - the value can be (and should be) encoded in a corresponding instruction when the operand value is constant @@ -186,7 +204,8 @@ enum HWIntrinsicFlag : unsigned int // The intrinsic uses a mask in arg1 to select elements present in the result HW_Flag_ExplicitMaskedOperation = 0x20000, - // The intrinsic uses a mask in arg1 to select elements present in the result, and must use a low register. + // The intrinsic uses a mask in arg1 (either explicitly, embdedd or optionally embedded) to select elements present + // in the result, and must use a low register. HW_Flag_LowMaskedOperation = 0x40000, // The intrinsic can optionally use a mask in arg1 to select elements present in the result, which is not present in @@ -196,56 +215,43 @@ enum HWIntrinsicFlag : unsigned int // The intrinsic uses a mask in arg1 to select elements present in the result, which is not present in the API call HW_Flag_EmbeddedMaskedOperation = 0x100000, + // The intrinsic comes in both vector and scalar variants. During the import stage if the basetype is scalar, + // then the intrinsic should be switched to a scalar only version. + HW_Flag_HasScalarInputVariant = 0x200000, + + // The intrinsic uses a mask in arg1 to select elements present in the result, and must use a low vector register. + HW_Flag_LowVectorOperation = 0x400000, + + // The intrinsic uses a mask in arg1 to select elements present in the result, which zeros inactive elements + // (instead of merging). + HW_Flag_ZeroingMaskedOperation = 0x800000, + + // The intrinsic has an overload where the base type is extracted from a ValueTuple of SIMD types + // (HW_Flag_BaseTypeFrom{First, Second}Arg must also be set to denote the position of the ValueTuple) + HW_Flag_BaseTypeFromValueTupleArg = 0x1000000, + + // The intrinsic is a reduce operation. + HW_Flag_ReduceOperation = 0x2000000, + #else #error Unsupported platform #endif // The intrinsic has some barrier special side effect that should be tracked - HW_Flag_SpecialSideEffect_Barrier = 0x200000, + HW_Flag_SpecialSideEffect_Barrier = 0x8000000, // The intrinsic has some other special side effect that should be tracked - HW_Flag_SpecialSideEffect_Other = 0x400000, + HW_Flag_SpecialSideEffect_Other = 0x10000000, HW_Flag_SpecialSideEffectMask = (HW_Flag_SpecialSideEffect_Barrier | HW_Flag_SpecialSideEffect_Other), // MaybeNoJmpTable IMM // the imm intrinsic may not need jumptable fallback when it gets non-const argument - HW_Flag_MaybeNoJmpTableIMM = 0x800000, - -#if defined(TARGET_XARCH) - // The intrinsic is an RMW intrinsic - HW_Flag_RmwIntrinsic = 0x1000000, - - // The intrinsic is a PermuteVar2x intrinsic - HW_Flag_PermuteVar2x = 0x2000000, - - // The intrinsic is an embedded broadcast compatible intrinsic - HW_Flag_EmbBroadcastCompatible = 0x4000000, - - // The intrinsic is an embedded rounding compatible intrinsic - HW_Flag_EmbRoundingCompatible = 0x8000000, - - // The intrinsic is an embedded masking compatible intrinsic - HW_Flag_EmbMaskingCompatible = 0x10000000, -#elif defined(TARGET_ARM64) - - // The intrinsic has an enum operand. Using this implies HW_Flag_HasImmediateOperand. - HW_Flag_HasEnumOperand = 0x1000000, - - // The intrinsic comes in both vector and scalar variants. During the import stage if the basetype is scalar, - // then the intrinsic should be switched to a scalar only version. - HW_Flag_HasScalarInputVariant = 0x2000000, - -#endif // TARGET_XARCH + HW_Flag_MaybeNoJmpTableIMM = 0x20000000, // The intrinsic is a FusedMultiplyAdd intrinsic HW_Flag_FmaIntrinsic = 0x40000000, -#if defined(TARGET_ARM64) - // The intrinsic uses a mask in arg1 to select elements present in the result, and must use a low vector register. - HW_Flag_LowVectorOperation = 0x4000000, -#endif - HW_Flag_CanBenefitFromConstantProp = 0x80000000, }; @@ -753,6 +759,12 @@ struct HWIntrinsicInfo HWIntrinsicFlag flags = lookupFlags(id); return (flags & HW_Flag_MaybeMemoryStore) != 0; } + + static bool NeedsNormalizeSmallTypeToInt(NamedIntrinsic id) + { + HWIntrinsicFlag flags = lookupFlags(id); + return (flags & HW_Flag_NormalizeSmallTypeToInt) != 0; + } #endif static bool NoJmpTableImm(NamedIntrinsic id) @@ -915,7 +927,7 @@ struct HWIntrinsicInfo { #if defined(TARGET_ARM64) const HWIntrinsicFlag flags = lookupFlags(id); - return ((flags & HW_Flag_HasImmediateOperand) != 0) || HasEnumOperand(id); + return ((flags & HW_Flag_HasImmediateOperand) != 0); #elif defined(TARGET_XARCH) return lookupCategory(id) == HW_Category_IMM; #else @@ -944,8 +956,14 @@ struct HWIntrinsicInfo static bool IsLowMaskedOperation(NamedIntrinsic id) { - const HWIntrinsicFlag flags = lookupFlags(id); - return (flags & HW_Flag_LowMaskedOperation) != 0; + const HWIntrinsicFlag flags = lookupFlags(id); + const bool isLowMaskedOperation = (flags & HW_Flag_LowMaskedOperation) != 0; + if (isLowMaskedOperation) + { + assert(IsExplicitMaskedOperation(id) || IsEmbeddedMaskedOperation(id) || + IsOptionalEmbeddedMaskedOperation(id)); + } + return isLowMaskedOperation; } static bool IsLowVectorOperation(NamedIntrinsic id) @@ -972,16 +990,28 @@ struct HWIntrinsicInfo return (flags & HW_Flag_ExplicitMaskedOperation) != 0; } - static bool HasEnumOperand(NamedIntrinsic id) + static bool HasScalarInputVariant(NamedIntrinsic id) { const HWIntrinsicFlag flags = lookupFlags(id); - return (flags & HW_Flag_HasEnumOperand) != 0; + return (flags & HW_Flag_HasScalarInputVariant) != 0; } - static bool HasScalarInputVariant(NamedIntrinsic id) + static bool IsZeroingMaskedOperation(NamedIntrinsic id) { const HWIntrinsicFlag flags = lookupFlags(id); - return (flags & HW_Flag_HasScalarInputVariant) != 0; + return (flags & HW_Flag_ZeroingMaskedOperation) != 0; + } + + static bool BaseTypeFromValueTupleArg(NamedIntrinsic id) + { + const HWIntrinsicFlag flags = lookupFlags(id); + return (flags & HW_Flag_BaseTypeFromValueTupleArg) != 0; + } + + static bool IsReduceOperation(NamedIntrinsic id) + { + const HWIntrinsicFlag flags = lookupFlags(id); + return (flags & HW_Flag_ReduceOperation) != 0; } static NamedIntrinsic GetScalarInputVariant(NamedIntrinsic id) diff --git a/src/coreclr/jit/hwintrinsicarm64.cpp b/src/coreclr/jit/hwintrinsicarm64.cpp index b159e767a3d..afe933da87c 100644 --- a/src/coreclr/jit/hwintrinsicarm64.cpp +++ b/src/coreclr/jit/hwintrinsicarm64.cpp @@ -2466,7 +2466,7 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, assert(HWIntrinsicInfo::isImmOp(intrinsic, op3)); HWIntrinsicInfo::lookupImmBounds(intrinsic, simdSize, simdBaseType, 1, &immLowerBound, &immUpperBound); - op3 = addRangeCheckIfNeeded(intrinsic, op3, (!op3->IsCnsIntOrI()), immLowerBound, immUpperBound); + op3 = addRangeCheckIfNeeded(intrinsic, op3, immLowerBound, immUpperBound); argType = JITtype2varType(strip(info.compCompHnd->getArgType(sig, arg1, &argClass))); op1 = getArgForHWIntrinsic(argType, argClass); @@ -2939,11 +2939,11 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, assert(HWIntrinsicInfo::isImmOp(intrinsic, op2)); HWIntrinsicInfo::lookupImmBounds(intrinsic, simdSize, simdBaseType, 1, &immLowerBound, &immUpperBound); - op2 = addRangeCheckIfNeeded(intrinsic, op2, (!op2->IsCnsIntOrI()), immLowerBound, immUpperBound); + op2 = addRangeCheckIfNeeded(intrinsic, op2, immLowerBound, immUpperBound); assert(HWIntrinsicInfo::isImmOp(intrinsic, op3)); HWIntrinsicInfo::lookupImmBounds(intrinsic, simdSize, simdBaseType, 2, &immLowerBound, &immUpperBound); - op3 = addRangeCheckIfNeeded(intrinsic, op3, (!op3->IsCnsIntOrI()), immLowerBound, immUpperBound); + op3 = addRangeCheckIfNeeded(intrinsic, op3, immLowerBound, immUpperBound); retNode = isScalar ? gtNewScalarHWIntrinsicNode(retType, op1, op2, op3, intrinsic) : gtNewSimdHWIntrinsicNode(retType, op1, op2, op3, intrinsic, simdBaseJitType, simdSize); @@ -3010,7 +3010,7 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, op3 = getArgForHWIntrinsic(argType, argClass); assert(HWIntrinsicInfo::isImmOp(intrinsic, op3)); - op3 = addRangeCheckIfNeeded(intrinsic, op3, mustExpand, immLowerBound, immUpperBound); + op3 = addRangeCheckIfNeeded(intrinsic, op3, immLowerBound, immUpperBound); argType = JITtype2varType(strip(info.compCompHnd->getArgType(sig, arg2, &argClass))); op2 = getArgForHWIntrinsic(argType, argClass); @@ -3040,7 +3040,7 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, op4 = getArgForHWIntrinsic(argType, argClass); assert(HWIntrinsicInfo::isImmOp(intrinsic, op4)); - op4 = addRangeCheckIfNeeded(intrinsic, op4, mustExpand, immLowerBound, immUpperBound); + op4 = addRangeCheckIfNeeded(intrinsic, op4, immLowerBound, immUpperBound); argType = JITtype2varType(strip(info.compCompHnd->getArgType(sig, arg3, &argClass))); op3 = getArgForHWIntrinsic(argType, argClass); @@ -3108,12 +3108,12 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, argType = JITtype2varType(strip(info.compCompHnd->getArgType(sig, arg5, &argClass))); GenTree* op5 = getArgForHWIntrinsic(argType, argClass); assert(HWIntrinsicInfo::isImmOp(intrinsic, op5)); - op5 = addRangeCheckIfNeeded(intrinsic, op5, mustExpand, imm1LowerBound, imm1UpperBound); + op5 = addRangeCheckIfNeeded(intrinsic, op5, imm1LowerBound, imm1UpperBound); argType = JITtype2varType(strip(info.compCompHnd->getArgType(sig, arg4, &argClass))); op4 = getArgForHWIntrinsic(argType, argClass); assert(HWIntrinsicInfo::isImmOp(intrinsic, op4)); - op4 = addRangeCheckIfNeeded(intrinsic, op4, mustExpand, imm2LowerBound, imm2UpperBound); + op4 = addRangeCheckIfNeeded(intrinsic, op4, imm2LowerBound, imm2UpperBound); argType = JITtype2varType(strip(info.compCompHnd->getArgType(sig, arg3, &argClass))); op3 = getArgForHWIntrinsic(argType, argClass); diff --git a/src/coreclr/jit/hwintrinsiccodegenarm64.cpp b/src/coreclr/jit/hwintrinsiccodegenarm64.cpp index b57cda42c2f..6e447757c8c 100644 --- a/src/coreclr/jit/hwintrinsiccodegenarm64.cpp +++ b/src/coreclr/jit/hwintrinsiccodegenarm64.cpp @@ -23,6 +23,7 @@ // codeGen -- an instance of CodeGen class. // immOp -- an immediate operand of the intrinsic. // intrin -- a hardware intrinsic tree node. +// numInstrs -- number of instructions that will be in each switch entry. Default 1. // // Note: This class is designed to be used in the following way // HWIntrinsicImmOpHelper helper(this, immOp, intrin); @@ -35,11 +36,15 @@ // This allows to combine logic for cases when immOp->isContainedIntOrIImmed() is either true or false in a form // of a for-loop. // -CodeGen::HWIntrinsicImmOpHelper::HWIntrinsicImmOpHelper(CodeGen* codeGen, GenTree* immOp, GenTreeHWIntrinsic* intrin) +CodeGen::HWIntrinsicImmOpHelper::HWIntrinsicImmOpHelper(CodeGen* codeGen, + GenTree* immOp, + GenTreeHWIntrinsic* intrin, + int numInstrs) : codeGen(codeGen) , endLabel(nullptr) , nonZeroLabel(nullptr) , branchTargetReg(REG_NA) + , numInstrs(numInstrs) { assert(codeGen != nullptr); assert(varTypeIsIntegral(immOp)); @@ -123,7 +128,7 @@ CodeGen::HWIntrinsicImmOpHelper::HWIntrinsicImmOpHelper(CodeGen* codeGen, GenTre // Note: This instance is designed to be used via the same for loop as the standard constructor. // CodeGen::HWIntrinsicImmOpHelper::HWIntrinsicImmOpHelper( - CodeGen* codeGen, regNumber immReg, int immLowerBound, int immUpperBound, GenTreeHWIntrinsic* intrin) + CodeGen* codeGen, regNumber immReg, int immLowerBound, int immUpperBound, GenTreeHWIntrinsic* intrin, int numInstrs) : codeGen(codeGen) , endLabel(nullptr) , nonZeroLabel(nullptr) @@ -132,6 +137,7 @@ CodeGen::HWIntrinsicImmOpHelper::HWIntrinsicImmOpHelper( , immUpperBound(immUpperBound) , nonConstImmReg(immReg) , branchTargetReg(REG_NA) + , numInstrs(numInstrs) { assert(codeGen != nullptr); @@ -181,18 +187,32 @@ void CodeGen::HWIntrinsicImmOpHelper::EmitBegin() } else { - // Here we assume that each case consists of one arm64 instruction followed by "b endLabel". + assert(numInstrs == 1 || numInstrs == 2); + + // Here we assume that each case consists of numInstrs arm64 instructions followed by "b endLabel". // Since an arm64 instruction is 4 bytes, we branch to AddressOf(beginLabel) + (nonConstImmReg << 3). GetEmitter()->emitIns_R_L(INS_adr, EA_8BYTE, beginLabel, branchTargetReg); GetEmitter()->emitIns_R_R_R_I(INS_add, EA_8BYTE, branchTargetReg, branchTargetReg, nonConstImmReg, 3, INS_OPTS_LSL); + // For two instructions, add the extra one. + if (numInstrs == 2) + { + GetEmitter()->emitIns_R_R_R_I(INS_add, EA_8BYTE, branchTargetReg, branchTargetReg, nonConstImmReg, 2, + INS_OPTS_LSL); + } + // If the lower bound is non zero we need to adjust the branch target value by subtracting - // (immLowerBound << 3). + // the lower bound if (immLowerBound != 0) { - GetEmitter()->emitIns_R_R_I(INS_sub, EA_8BYTE, branchTargetReg, branchTargetReg, - ((ssize_t)immLowerBound << 3)); + ssize_t lowerReduce = ((ssize_t)immLowerBound << 3); + if (numInstrs == 2) + { + lowerReduce += ((ssize_t)immLowerBound << 2); + } + + GetEmitter()->emitIns_R_R_I(INS_sub, EA_8BYTE, branchTargetReg, branchTargetReg, lowerReduce); } GetEmitter()->emitIns_R(INS_br, EA_8BYTE, branchTargetReg); @@ -348,13 +368,9 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) { if (isRMW) { - if (targetReg != op1Reg) - { - assert(targetReg != op2Reg); - assert(targetReg != op3Reg); - - GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op1Reg, /* canSkip */ true); - } + assert((targetReg == op1Reg) || (targetReg != op2Reg)); + assert((targetReg == op1Reg) || (targetReg != op3Reg)); + GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op1Reg, /* canSkip */ true); HWIntrinsicImmOpHelper helper(this, intrin.op4, node); @@ -396,14 +412,9 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) { if (isRMW) { - if (targetReg != op1Reg) - { - assert(targetReg != op2Reg); - assert(targetReg != op3Reg); - - GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op1Reg, /* canSkip */ true); - } - + assert((targetReg == op1Reg) || (targetReg != op2Reg)); + assert((targetReg == op1Reg) || (targetReg != op3Reg)); + GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op1Reg, /* canSkip */ true); GetEmitter()->emitIns_R_R_R_I(ins, emitSize, targetReg, op2Reg, op3Reg, 0, opt); } else @@ -423,18 +434,8 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) for (helper.EmitBegin(); !helper.Done(); helper.EmitCaseEnd()) { const int shiftAmount = helper.ImmValue(); - - if (shiftAmount == 0) - { - // TODO: Use emitIns_Mov instead. - // We do not use it currently because it will still elide the 'mov' - // even if 'canSkip' is false. We cannot elide the 'mov' here. - GetEmitter()->emitIns_R_R_R(INS_mov, emitTypeSize(node), targetReg, reg, reg); - } - else - { - GetEmitter()->emitIns_R_R_I(ins, emitSize, targetReg, reg, shiftAmount, opt); - } + assert((shiftAmount != 0) || (intrin.category == HW_Category_ShiftLeftByImmediate)); + GetEmitter()->emitIns_R_R_I(ins, emitSize, targetReg, reg, shiftAmount, opt); } }; @@ -448,27 +449,6 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) emitShift(intrin.op2, op1Reg); } } - else if (HWIntrinsicInfo::HasEnumOperand(intrin.id)) - { - assert(hasImmediateOperand); - - switch (intrin.numOperands) - { - case 1: - { - HWIntrinsicImmOpHelper helper(this, intrin.op1, node); - for (helper.EmitBegin(); !helper.Done(); helper.EmitCaseEnd()) - { - const insSvePattern pattern = (insSvePattern)helper.ImmValue(); - GetEmitter()->emitIns_R_PATTERN(ins, emitSize, targetReg, opt, pattern); - } - }; - break; - - default: - unreached(); - } - } else if (intrin.numOperands >= 2 && intrin.op2->IsEmbMaskOp()) { // Handle case where op2 is operation that needs embedded mask @@ -516,13 +496,22 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) } // Shared code for setting up embedded mask arg for intrinsics with 3+ operands + + auto emitEmbeddedMaskSetupInstrs = [&] { + if (intrin.op3->IsVectorZero() || (targetReg != falseReg) || (targetReg != embMaskOp1Reg)) + { + return 1; + } + return 0; + }; + auto emitEmbeddedMaskSetup = [&] { if (intrin.op3->IsVectorZero()) { // If `falseReg` is zero, then move the first operand of `intrinEmbMask` in the // destination using /Z. - assert(targetReg != embMaskOp2Reg); + assert((targetReg != embMaskOp2Reg) || (embMaskOp1Reg == embMaskOp2Reg)); assert(intrin.op3->isContained() || !intrin.op1->IsMaskAllBitsSet()); GetEmitter()->emitInsSve_R_R_R(INS_sve_movprfx, emitSize, targetReg, maskReg, embMaskOp1Reg, opt); } @@ -620,6 +609,7 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) if (intrin.op3->isContained()) { assert(intrin.op3->IsVectorZero()); + if (intrin.op1->isContained() || intrin.op1->IsMaskAllBitsSet()) { // We already skip importing ConditionalSelect if op1 == trueAll, however @@ -630,6 +620,8 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) } else { + assert(!HWIntrinsicInfo::IsZeroingMaskedOperation(intrinEmbMask.id)); + // If falseValue is zero, just zero out those lanes of targetReg using `movprfx` // and /Z GetEmitter()->emitIns_R_R_R(INS_sve_movprfx, emitSize, targetReg, maskReg, targetReg, @@ -651,6 +643,14 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) falseReg, opt); break; } + else if (HWIntrinsicInfo::IsZeroingMaskedOperation(intrinEmbMask.id)) + { + // At this point, target != embMaskOp1Reg != falseReg, so just go ahead + // and move the falseReg unpredicated into targetReg. + // Cannot use movprfx for zeroing mask operations. + GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, falseReg, + /* canSkip */ true); + } else { // At this point, target != embMaskOp1Reg != falseReg, so just go ahead @@ -667,10 +667,47 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) { if (!instrIsRMW) { - // Perform the actual "predicated" operation so that `embMaskOp1Reg` is the first operand - // and `embMaskOp2Reg` is the second operand. - GetEmitter()->emitIns_R_R_R_R(insEmbMask, emitSize, targetReg, maskReg, embMaskOp1Reg, - embMaskOp2Reg, opt); + // Perform the actual "predicated" operation so that `embMaskOp1Reg` is the first operand.. + switch (intrinEmbMask.id) + { + case NI_Sve_LoadVectorByteNonFaultingZeroExtendToInt16: + case NI_Sve_LoadVectorByteNonFaultingZeroExtendToInt32: + case NI_Sve_LoadVectorByteNonFaultingZeroExtendToInt64: + case NI_Sve_LoadVectorByteNonFaultingZeroExtendToUInt16: + case NI_Sve_LoadVectorByteNonFaultingZeroExtendToUInt32: + case NI_Sve_LoadVectorByteNonFaultingZeroExtendToUInt64: + case NI_Sve_LoadVectorInt16NonFaultingSignExtendToInt32: + case NI_Sve_LoadVectorInt16NonFaultingSignExtendToInt64: + case NI_Sve_LoadVectorInt16NonFaultingSignExtendToUInt32: + case NI_Sve_LoadVectorInt16NonFaultingSignExtendToUInt64: + case NI_Sve_LoadVectorInt32NonFaultingSignExtendToInt64: + case NI_Sve_LoadVectorInt32NonFaultingSignExtendToUInt64: + case NI_Sve_LoadVectorNonFaulting: + case NI_Sve_LoadVectorSByteNonFaultingSignExtendToInt16: + case NI_Sve_LoadVectorSByteNonFaultingSignExtendToInt32: + case NI_Sve_LoadVectorSByteNonFaultingSignExtendToInt64: + case NI_Sve_LoadVectorSByteNonFaultingSignExtendToUInt16: + case NI_Sve_LoadVectorSByteNonFaultingSignExtendToUInt32: + case NI_Sve_LoadVectorSByteNonFaultingSignExtendToUInt64: + case NI_Sve_LoadVectorUInt16NonFaultingZeroExtendToInt32: + case NI_Sve_LoadVectorUInt16NonFaultingZeroExtendToInt64: + case NI_Sve_LoadVectorUInt16NonFaultingZeroExtendToUInt32: + case NI_Sve_LoadVectorUInt16NonFaultingZeroExtendToUInt64: + case NI_Sve_LoadVectorUInt32NonFaultingZeroExtendToInt64: + case NI_Sve_LoadVectorUInt32NonFaultingZeroExtendToUInt64: + { + + GetEmitter()->emitIns_R_R_R(insEmbMask, emitSize, targetReg, maskReg, embMaskOp1Reg, + opt); + break; + } + + default: + { + GetEmitter()->emitIns_R_R_R_R(insEmbMask, emitSize, targetReg, maskReg, embMaskOp1Reg, + embMaskOp2Reg, opt); + } + } break; } @@ -701,6 +738,13 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) embOpt = INS_OPTS_SCALABLE_B; break; + case NI_Sve_AddSequentialAcross: + // Predicate functionality is currently not exposed for this API, + // but the FADDA instruction only has a predicated variant. + // Thus, we expect the JIT to wrap this with CndSel. + assert(intrin.op3->IsVectorZero()); + break; + default: break; } @@ -721,6 +765,24 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) } }; + auto emitInsMovPrfxHelper = [&](regNumber reg1, regNumber reg2, regNumber reg3, regNumber reg4) { + if (hasShift) + { + HWIntrinsicImmOpHelper helper(this, intrinEmbMask.op2, op2->AsHWIntrinsic(), 2); + for (helper.EmitBegin(); !helper.Done(); helper.EmitCaseEnd()) + { + GetEmitter()->emitIns_R_R(INS_sve_movprfx, EA_SCALABLE, reg1, reg3); + GetEmitter()->emitInsSve_R_R_I(insEmbMask, emitSize, reg1, reg2, helper.ImmValue(), + embOpt, sopt); + } + } + else + { + GetEmitter()->emitIns_R_R(INS_sve_movprfx, EA_SCALABLE, reg1, reg3); + GetEmitter()->emitIns_R_R_R(insEmbMask, emitSize, reg1, reg2, reg4, embOpt, sopt); + } + }; + if (intrin.op3->IsVectorZero()) { // If `falseReg` is zero, then move the first operand of `intrinEmbMask` in the @@ -729,22 +791,43 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) switch (intrinEmbMask.id) { case NI_Sve_CreateBreakPropagateMask: - if (targetReg != embMaskOp1Reg) - { - GetEmitter()->emitIns_Mov(INS_sve_mov, emitSize, targetReg, embMaskOp2Reg, - /* canSkip */ true); - } + assert((targetReg == embMaskOp2Reg) || (targetReg != embMaskOp1Reg)); + GetEmitter()->emitIns_Mov(INS_sve_mov, emitSize, targetReg, embMaskOp2Reg, + /* canSkip */ true); emitInsHelper(targetReg, maskReg, embMaskOp1Reg); break; + case NI_Sve_AddSequentialAcross: + assert((targetReg == op1Reg) || (targetReg != embMaskOp2Reg)); + GetEmitter()->emitIns_Mov(INS_fmov, GetEmitter()->optGetSveElemsize(embOpt), targetReg, + embMaskOp1Reg, /* canSkip */ true); + emitInsHelper(targetReg, maskReg, embMaskOp2Reg); + break; + default: assert(targetReg != embMaskOp2Reg); - GetEmitter()->emitIns_R_R_R(INS_sve_movprfx, emitSize, targetReg, maskReg, - embMaskOp1Reg, opt); // Finally, perform the actual "predicated" operation so that `targetReg` is the first // operand and `embMaskOp2Reg` is the second operand. - emitInsHelper(targetReg, maskReg, embMaskOp2Reg); + + if (hasShift) + { + HWIntrinsicImmOpHelper helper(this, intrinEmbMask.op2, op2->AsHWIntrinsic(), 2); + for (helper.EmitBegin(); !helper.Done(); helper.EmitCaseEnd()) + { + GetEmitter()->emitIns_R_R_R(INS_sve_movprfx, EA_SCALABLE, targetReg, maskReg, + embMaskOp1Reg, opt); + GetEmitter()->emitInsSve_R_R_I(insEmbMask, emitSize, targetReg, maskReg, + helper.ImmValue(), embOpt, sopt); + } + } + else + { + GetEmitter()->emitIns_R_R_R(INS_sve_movprfx, EA_SCALABLE, targetReg, maskReg, + embMaskOp1Reg, opt); + GetEmitter()->emitIns_R_R_R(insEmbMask, emitSize, targetReg, maskReg, embMaskOp2Reg, + embOpt, sopt); + } break; } } @@ -768,30 +851,29 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) // into targetReg. Next, do the predicated operation on the targetReg and last, // use "sel" to select the active lanes based on mask, and set inactive lanes // to falseReg. - assert(targetReg != embMaskOp2Reg); assert(HWIntrinsicInfo::IsEmbeddedMaskedOperation(intrinEmbMask.id)); - GetEmitter()->emitIns_R_R(INS_sve_movprfx, EA_SCALABLE, targetReg, embMaskOp1Reg); - - emitInsHelper(targetReg, maskReg, embMaskOp2Reg); + emitInsMovPrfxHelper(targetReg, maskReg, embMaskOp1Reg, embMaskOp2Reg); } GetEmitter()->emitIns_R_R_R_R(INS_sve_sel, emitSize, targetReg, maskReg, targetReg, falseReg, opt); - break; } else if (targetReg != embMaskOp1Reg) { // embMaskOp1Reg is same as `falseReg`, but not same as `targetReg`. Move the // `embMaskOp1Reg` i.e. `falseReg` in `targetReg`, using "unpredicated movprfx", so the // subsequent `insEmbMask` operation can be merged on top of it. - GetEmitter()->emitIns_R_R(INS_sve_movprfx, EA_SCALABLE, targetReg, falseReg); - } - // Finally, perform the actual "predicated" operation so that `targetReg` is the first operand - // and `embMaskOp2Reg` is the second operand. - emitInsHelper(targetReg, maskReg, embMaskOp2Reg); + emitInsMovPrfxHelper(targetReg, maskReg, falseReg, embMaskOp2Reg); + } + else + { + // Finally, perform the actual "predicated" operation so that `targetReg` is the first + // operand and `embMaskOp2Reg` is the second operand. + emitInsHelper(targetReg, maskReg, embMaskOp2Reg); + } } else { @@ -809,7 +891,6 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) if (HWIntrinsicInfo::IsFmaIntrinsic(intrinEmbMask.id)) { - assert(falseReg != embMaskOp3Reg); // For FMA, the operation we are trying to perform is: // result = op1 + (op2 * op3) // @@ -907,14 +988,14 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) } } - emitEmbeddedMaskSetup(); - // Finally, perform the desired operation. if (HWIntrinsicInfo::HasImmediateOperand(intrinEmbMask.id)) { - HWIntrinsicImmOpHelper helper(this, intrinEmbMask.op3, op2->AsHWIntrinsic()); + HWIntrinsicImmOpHelper helper(this, intrinEmbMask.op3, op2->AsHWIntrinsic(), + emitEmbeddedMaskSetupInstrs() + 1); for (helper.EmitBegin(); !helper.Done(); helper.EmitCaseEnd()) { + emitEmbeddedMaskSetup(); GetEmitter()->emitInsSve_R_R_R_I(insEmbMask, emitSize, targetReg, maskReg, embMaskOp2Reg, helper.ImmValue(), opt); } @@ -922,6 +1003,7 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) else { assert(HWIntrinsicInfo::IsFmaIntrinsic(intrinEmbMask.id)); + emitEmbeddedMaskSetup(); GetEmitter()->emitInsSve_R_R_R_R(insEmbMask, emitSize, targetReg, maskReg, embMaskOp2Reg, embMaskOp3Reg, opt); } @@ -935,11 +1017,11 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) assert(intrinEmbMask.op4->isContained() == (embMaskOp4Reg == REG_NA)); assert(HWIntrinsicInfo::HasImmediateOperand(intrinEmbMask.id)); - emitEmbeddedMaskSetup(); - - HWIntrinsicImmOpHelper helper(this, intrinEmbMask.op4, op2->AsHWIntrinsic()); + HWIntrinsicImmOpHelper helper(this, intrinEmbMask.op4, op2->AsHWIntrinsic(), + emitEmbeddedMaskSetupInstrs() + 1); for (helper.EmitBegin(); !helper.Done(); helper.EmitCaseEnd()) { + emitEmbeddedMaskSetup(); GetEmitter()->emitInsSve_R_R_R_R_I(insEmbMask, emitSize, targetReg, maskReg, embMaskOp2Reg, embMaskOp3Reg, helper.ImmValue(), opt); } @@ -953,18 +1035,33 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) } else { - assert(!hasImmediateOperand); - switch (intrin.numOperands) { case 0: + assert(!hasImmediateOperand); GetEmitter()->emitIns_R(ins, emitSize, targetReg, opt); break; + case 1: - GetEmitter()->emitIns_R_R(ins, emitSize, targetReg, op1Reg, opt); + if (hasImmediateOperand) + { + assert(HWIntrinsicInfo::IsScalable(intrin.id)); + HWIntrinsicImmOpHelper helper(this, intrin.op1, node); + for (helper.EmitBegin(); !helper.Done(); helper.EmitCaseEnd()) + { + const insSvePattern pattern = (insSvePattern)helper.ImmValue(); + GetEmitter()->emitIns_R_PATTERN(ins, emitSize, targetReg, opt, pattern); + } + } + else + { + GetEmitter()->emitIns_R_R(ins, emitSize, targetReg, op1Reg, opt); + } break; case 2: + assert(!hasImmediateOperand); + // This handles optimizations for instructions that have // an implicit 'zero' vector of what would be the second operand. if (HWIntrinsicInfo::SupportsContainment(intrin.id) && intrin.op2->isContained() && @@ -979,15 +1076,10 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) { if (isRMW) { - if (targetReg != op2Reg) - { - assert(targetReg != op1Reg); - - GetEmitter()->emitIns_Mov(ins_Move_Extend(intrin.op2->TypeGet(), false), - emitTypeSize(node), targetReg, op2Reg, - /* canSkip */ true); - } - + assert((targetReg == op2Reg) || (targetReg != op1Reg)); + GetEmitter()->emitIns_Mov(ins_Move_Extend(intrin.op2->TypeGet(), false), + emitTypeSize(node), targetReg, op2Reg, + /* canSkip */ true); GetEmitter()->emitIns_R_R(ins, emitSize, targetReg, op1Reg, opt); } else @@ -1004,13 +1096,9 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) } else if (isRMW) { - if (targetReg != op1Reg) - { - assert(targetReg != op2Reg); - - GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op1Reg, - /* canSkip */ true); - } + assert((targetReg == op1Reg) || (targetReg != op2Reg)); + GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op1Reg, + /* canSkip */ true); GetEmitter()->emitIns_R_R(ins, emitSize, targetReg, op2Reg, opt); } else @@ -1020,31 +1108,24 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) break; case 3: + assert(!hasImmediateOperand); + if (isRMW) { if (HWIntrinsicInfo::IsExplicitMaskedOperation(intrin.id)) { - if (targetReg != op2Reg) - { - assert(targetReg != op1Reg); - assert(targetReg != op3Reg); - - GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op2Reg, - /* canSkip */ true); - } + assert((targetReg == op2Reg) || ((targetReg != op1Reg) && (targetReg != op3Reg))); + GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op2Reg, + /* canSkip */ true); GetEmitter()->emitIns_R_R_R(ins, emitSize, targetReg, op1Reg, op3Reg, opt); } else { - if (targetReg != op1Reg) - { - assert(targetReg != op2Reg); - assert(targetReg != op3Reg); + assert((targetReg == op1Reg) || ((targetReg != op2Reg) && (targetReg != op3Reg))); - GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op1Reg, - /* canSkip */ true); - } + GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op1Reg, + /* canSkip */ true); GetEmitter()->emitIns_R_R_R(ins, emitSize, targetReg, op2Reg, op3Reg, opt); } } @@ -1256,54 +1337,44 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) break; case NI_AdvSimd_Insert: + { assert(isRMW); GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op1Reg, /* canSkip */ true); - if (intrin.op3->isContainedFltOrDblImmed()) - { - assert(intrin.op2->isContainedIntOrIImmed()); - assert(intrin.op2->AsIntCon()->gtIconVal == 0); + // fmov (scalar) zeros the upper bits and is not safe to use + assert(!intrin.op3->isContainedFltOrDblImmed()); - const double dataValue = intrin.op3->AsDblCon()->DconValue(); - GetEmitter()->emitIns_R_F(INS_fmov, emitSize, targetReg, dataValue, opt); - } - else - { - assert(targetReg != op3Reg); + assert(targetReg != op3Reg); - HWIntrinsicImmOpHelper helper(this, intrin.op2, node); + HWIntrinsicImmOpHelper helper(this, intrin.op2, node); - if (varTypeIsFloating(intrin.baseType)) + if (varTypeIsFloating(intrin.baseType)) + { + for (helper.EmitBegin(); !helper.Done(); helper.EmitCaseEnd()) { - for (helper.EmitBegin(); !helper.Done(); helper.EmitCaseEnd()) - { - const int elementIndex = helper.ImmValue(); + const int elementIndex = helper.ImmValue(); - GetEmitter()->emitIns_R_R_I_I(ins, emitSize, targetReg, op3Reg, elementIndex, 0, opt); - } + GetEmitter()->emitIns_R_R_I_I(ins, emitSize, targetReg, op3Reg, elementIndex, 0, opt); } - else + } + else + { + for (helper.EmitBegin(); !helper.Done(); helper.EmitCaseEnd()) { - for (helper.EmitBegin(); !helper.Done(); helper.EmitCaseEnd()) - { - const int elementIndex = helper.ImmValue(); + const int elementIndex = helper.ImmValue(); - GetEmitter()->emitIns_R_R_I(ins, emitSize, targetReg, op3Reg, elementIndex, opt); - } + GetEmitter()->emitIns_R_R_I(ins, emitSize, targetReg, op3Reg, elementIndex, opt); } } break; + } case NI_AdvSimd_InsertScalar: { assert(isRMW); - if (targetReg != op1Reg) - { - assert(targetReg != op3Reg); - - GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op1Reg, /* canSkip */ true); - } + assert((targetReg == op1Reg) || (targetReg != op3Reg)); + GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op1Reg, /* canSkip */ true); HWIntrinsicImmOpHelper helper(this, intrin.op2, node); @@ -1319,12 +1390,8 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) case NI_AdvSimd_Arm64_InsertSelectedScalar: { assert(isRMW); - if (targetReg != op1Reg) - { - assert(targetReg != op3Reg); - - GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op1Reg, /* canSkip */ true); - } + assert((targetReg == op1Reg) || (targetReg != op3Reg)); + GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op1Reg, /* canSkip */ true); const int resultIndex = (int)intrin.op2->AsIntCon()->gtIconVal; const int valueIndex = (int)intrin.op4->AsIntCon()->gtIconVal; @@ -1335,12 +1402,8 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) case NI_AdvSimd_LoadAndInsertScalar: { assert(isRMW); - if (targetReg != op1Reg) - { - assert(targetReg != op3Reg); - - GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op1Reg, /* canSkip */ true); - } + assert((targetReg == op1Reg) || (targetReg != op3Reg)); + GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op1Reg, /* canSkip */ true); HWIntrinsicImmOpHelper helper(this, intrin.op2, node); @@ -1380,11 +1443,8 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) targetFieldReg = node->GetRegByIndex(fieldIdx); op1FieldReg = fieldNode->GetRegNum(); - if (targetFieldReg != op1FieldReg) - { - GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(fieldNode), targetFieldReg, op1FieldReg, - /* canSkip */ true); - } + GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(fieldNode), targetFieldReg, op1FieldReg, + /* canSkip */ true); fieldIdx++; } @@ -1713,7 +1773,6 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) case NI_Sve_PrefetchInt64: { assert(hasImmediateOperand); - assert(HWIntrinsicInfo::HasEnumOperand(intrin.id)); HWIntrinsicImmOpHelper helper(this, intrin.op3, node); for (helper.EmitBegin(); !helper.Done(); helper.EmitCaseEnd()) { @@ -1915,11 +1974,8 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) break; } - if (targetReg != op1Reg) - { - assert(targetReg != op3Reg); - GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op1Reg, /* canSkip */ true); - } + assert((targetReg == op1Reg) || (targetReg != op3Reg)); + GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op1Reg, /* canSkip */ true); GetEmitter()->emitIns_R_R_R(ins, emitSize, targetReg, op2Reg, op3Reg, opt); break; } @@ -2052,7 +2108,54 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) break; } + case NI_Sve_LoadVectorByteNonFaultingZeroExtendToInt16: + case NI_Sve_LoadVectorByteNonFaultingZeroExtendToInt32: + case NI_Sve_LoadVectorByteNonFaultingZeroExtendToInt64: + case NI_Sve_LoadVectorByteNonFaultingZeroExtendToUInt16: + case NI_Sve_LoadVectorByteNonFaultingZeroExtendToUInt32: + case NI_Sve_LoadVectorByteNonFaultingZeroExtendToUInt64: + case NI_Sve_LoadVectorInt16NonFaultingSignExtendToInt32: + case NI_Sve_LoadVectorInt16NonFaultingSignExtendToInt64: + case NI_Sve_LoadVectorInt16NonFaultingSignExtendToUInt32: + case NI_Sve_LoadVectorInt16NonFaultingSignExtendToUInt64: + case NI_Sve_LoadVectorInt32NonFaultingSignExtendToInt64: + case NI_Sve_LoadVectorInt32NonFaultingSignExtendToUInt64: + case NI_Sve_LoadVectorNonFaulting: + case NI_Sve_LoadVectorSByteNonFaultingSignExtendToInt16: + case NI_Sve_LoadVectorSByteNonFaultingSignExtendToInt32: + case NI_Sve_LoadVectorSByteNonFaultingSignExtendToInt64: + case NI_Sve_LoadVectorSByteNonFaultingSignExtendToUInt16: + case NI_Sve_LoadVectorSByteNonFaultingSignExtendToUInt32: + case NI_Sve_LoadVectorSByteNonFaultingSignExtendToUInt64: + case NI_Sve_LoadVectorUInt16NonFaultingZeroExtendToInt32: + case NI_Sve_LoadVectorUInt16NonFaultingZeroExtendToInt64: + case NI_Sve_LoadVectorUInt16NonFaultingZeroExtendToUInt32: + case NI_Sve_LoadVectorUInt16NonFaultingZeroExtendToUInt64: + case NI_Sve_LoadVectorUInt32NonFaultingZeroExtendToInt64: + case NI_Sve_LoadVectorUInt32NonFaultingZeroExtendToUInt64: + { + if (intrin.numOperands == 2) + { + // We have extra argument which means there is a "use" of FFR here. Restore it back in FFR + // register. + assert(op2Reg != REG_NA); + GetEmitter()->emitIns_R(INS_sve_wrffr, emitSize, op2Reg, opt); + } + GetEmitter()->emitIns_R_R(ins, emitSize, targetReg, op1Reg); + break; + } + + case NI_Sve_GatherVectorByteZeroExtendFirstFaulting: case NI_Sve_GatherVectorFirstFaulting: + case NI_Sve_GatherVectorInt16SignExtendFirstFaulting: + case NI_Sve_GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting: + case NI_Sve_GatherVectorInt32SignExtendFirstFaulting: + case NI_Sve_GatherVectorInt32WithByteOffsetsSignExtendFirstFaulting: + case NI_Sve_GatherVectorSByteSignExtendFirstFaulting: + case NI_Sve_GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting: + case NI_Sve_GatherVectorUInt16ZeroExtendFirstFaulting: + case NI_Sve_GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting: + case NI_Sve_GatherVectorUInt32ZeroExtendFirstFaulting: { if (node->GetAuxiliaryType() == TYP_UNKNOWN) { @@ -2077,6 +2180,7 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) GetEmitter()->emitIns_R(INS_sve_wrffr, emitSize, op4Reg, opt); } } + FALLTHROUGH; } case NI_Sve_GatherVector: @@ -2090,14 +2194,18 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) case NI_Sve_GatherVectorUInt16ZeroExtend: case NI_Sve_GatherVectorUInt32WithByteOffsetsZeroExtend: case NI_Sve_GatherVectorUInt32ZeroExtend: + case NI_Sve_GatherVectorWithByteOffsetFirstFaulting: { if (!varTypeIsSIMD(intrin.op2->gtType)) { // GatherVector...(Vector mask, T* address, Vector indices) - emitAttr baseSize = emitActualTypeSize(intrin.baseType); - bool isLoadingBytes = ((ins == INS_sve_ld1b) || (ins == INS_sve_ld1sb) || (ins == INS_sve_ldff1b) || - (ins == INS_sve_ldff1sb)); + emitAttr baseSize = emitActualTypeSize(intrin.baseType); + bool isLoadingBytes = + ((ins == INS_sve_ld1b) || (ins == INS_sve_ld1sb) || (ins == INS_sve_ldff1b) || + (ins == INS_sve_ldff1sb) || (intrin.id == NI_Sve_GatherVectorWithByteOffsetFirstFaulting) || + (intrin.id == NI_Sve_GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting) || + (intrin.id == NI_Sve_GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting)); insScalableOpts sopt = INS_SCALABLE_OPTS_NONE; if (baseSize == EA_4BYTE) @@ -2230,12 +2338,9 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) case NI_Sve_SaturatingIncrementBy8BitElementCount: { assert(isRMW); - if (targetReg != op1Reg) - { - assert(targetReg != op2Reg); - assert(targetReg != op3Reg); - GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op1Reg, /* canSkip */ true); - } + assert((targetReg == op1Reg) || (targetReg != op2Reg)); + assert((targetReg == op1Reg) || (targetReg != op3Reg)); + GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op1Reg, /* canSkip */ true); if (intrin.op2->IsCnsIntOrI() && intrin.op3->IsCnsIntOrI()) { @@ -2287,11 +2392,8 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) case NI_Sve_SaturatingIncrementByActiveElementCount: { // RMW semantics - if (targetReg != op1Reg) - { - assert(targetReg != op2Reg); - GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op1Reg, /* canSkip */ true); - } + assert((targetReg == op1Reg) || (targetReg != op2Reg)); + GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op1Reg, /* canSkip */ true); // Switch instruction if arg1 is unsigned. if (varTypeIsUnsigned(node->GetAuxiliaryType())) @@ -2330,13 +2432,8 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) case NI_Sve_ExtractVector: { assert(isRMW); - - if (targetReg != op1Reg) - { - assert(targetReg != op2Reg); - - GetEmitter()->emitIns_R_R(INS_sve_movprfx, EA_SCALABLE, targetReg, op1Reg); - } + assert((targetReg == op1Reg) || (targetReg != op2Reg)); + GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op1Reg, /* canSkip */ true); HWIntrinsicImmOpHelper helper(this, intrin.op3, node); @@ -2354,13 +2451,9 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) { assert(isRMW); assert(emitter::isFloatReg(op2Reg) == varTypeIsFloating(intrin.baseType)); - if (targetReg != op1Reg) - { - assert(targetReg != op2Reg); - GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op1Reg, - /* canSkip */ true); - } - + assert((targetReg == op1Reg) || (targetReg != op2Reg)); + GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op1Reg, + /* canSkip */ true); GetEmitter()->emitInsSve_R_R(ins, emitSize, targetReg, op2Reg, opt); break; } @@ -2383,13 +2476,8 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) { assert(isRMW); assert(HWIntrinsicInfo::IsExplicitMaskedOperation(intrin.id)); - - if (targetReg != op2Reg) - { - assert(targetReg != op1Reg); - GetEmitter()->emitIns_Mov(INS_sve_mov, emitTypeSize(node), targetReg, op2Reg, /* canSkip */ true); - } - + assert((targetReg == op2Reg) || (targetReg != op1Reg)); + GetEmitter()->emitIns_Mov(INS_sve_mov, emitTypeSize(node), targetReg, op2Reg, /* canSkip */ true); GetEmitter()->emitIns_R_R(ins, emitSize, targetReg, op1Reg, INS_OPTS_SCALABLE_B); break; } @@ -2443,14 +2531,10 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) emitSize = emitTypeSize(node); - if (targetReg != op2Reg) - { - assert(targetReg != op1Reg); - assert(targetReg != op3Reg); - GetEmitter()->emitIns_Mov(INS_mov, emitSize, targetReg, op2Reg, - /* canSkip */ true); - } - + assert((targetReg == op2Reg) || (targetReg != op1Reg)); + assert((targetReg == op2Reg) || (targetReg != op3Reg)); + GetEmitter()->emitIns_Mov(INS_mov, emitSize, targetReg, op2Reg, + /* canSkip */ true); GetEmitter()->emitInsSve_R_R_R(ins, emitSize, targetReg, op1Reg, op3Reg, opt, INS_SCALABLE_OPTS_NONE); break; @@ -2464,14 +2548,10 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) { assert(emitter::isFloatReg(targetReg)); assert(varTypeIsFloating(node->gtType) || varTypeIsSIMD(node->gtType)); - - if (targetReg != op2Reg) - { - assert(targetReg != op1Reg); - assert(targetReg != op3Reg); - GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op2Reg, - /* canSkip */ true); - } + assert((targetReg == op2Reg) || (targetReg != op1Reg)); + assert((targetReg == op2Reg) || (targetReg != op3Reg)); + GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op2Reg, + /* canSkip */ true); GetEmitter()->emitInsSve_R_R_R(ins, EA_SCALABLE, targetReg, op1Reg, op3Reg, opt, INS_SCALABLE_OPTS_WITH_SIMD_SCALAR); break; @@ -2481,17 +2561,17 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) { assert(isRMW); - if (targetReg != op1Reg) - { - assert(targetReg != op2Reg); - - GetEmitter()->emitInsSve_R_R(INS_sve_movprfx, EA_SCALABLE, targetReg, op1Reg); - } - - HWIntrinsicImmOpHelper helper(this, intrin.op3, node); + HWIntrinsicImmOpHelper helper(this, intrin.op3, node, (targetReg != op1Reg) ? 2 : 1); for (helper.EmitBegin(); !helper.Done(); helper.EmitCaseEnd()) { + if (targetReg != op1Reg) + { + assert(targetReg != op2Reg); + + GetEmitter()->emitInsSve_R_R(INS_sve_movprfx, EA_SCALABLE, targetReg, op1Reg); + } + GetEmitter()->emitInsSve_R_R_I(ins, emitSize, targetReg, op2Reg, helper.ImmValue(), opt); } break; @@ -2502,16 +2582,16 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) assert(isRMW); assert(hasImmediateOperand); - if (targetReg != op1Reg) - { - assert(targetReg != op2Reg); - assert(targetReg != op3Reg); - GetEmitter()->emitInsSve_R_R(INS_sve_movprfx, EA_SCALABLE, targetReg, op1Reg); - } - // If both immediates are constant, we don't need a jump table if (intrin.op4->IsCnsIntOrI() && intrin.op5->IsCnsIntOrI()) { + if (targetReg != op1Reg) + { + assert(targetReg != op2Reg); + assert(targetReg != op3Reg); + GetEmitter()->emitInsSve_R_R(INS_sve_movprfx, EA_SCALABLE, targetReg, op1Reg); + } + assert(intrin.op4->isContainedIntOrIImmed() && intrin.op5->isContainedIntOrIImmed()); GetEmitter()->emitInsSve_R_R_R_I_I(ins, emitSize, targetReg, op2Reg, op3Reg, intrin.op4->AsIntCon()->gtIconVal, @@ -2532,9 +2612,16 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) GetEmitter()->emitIns_R_R_R(INS_orr, scalarSize, op4Reg, op4Reg, op5Reg); // Generate the table using the combined immediate - HWIntrinsicImmOpHelper helper(this, op4Reg, 0, 7, node); + HWIntrinsicImmOpHelper helper(this, op4Reg, 0, 7, node, (targetReg != op1Reg) ? 2 : 1); for (helper.EmitBegin(); !helper.Done(); helper.EmitCaseEnd()) { + if (targetReg != op1Reg) + { + assert(targetReg != op2Reg); + assert(targetReg != op3Reg); + GetEmitter()->emitInsSve_R_R(INS_sve_movprfx, EA_SCALABLE, targetReg, op1Reg); + } + // Extract index and rotation from the immediate const int value = helper.ImmValue(); const ssize_t index = value & 1; diff --git a/src/coreclr/jit/hwintrinsiccodegenxarch.cpp b/src/coreclr/jit/hwintrinsiccodegenxarch.cpp index cb6d1821e3f..c5b875a9630 100644 --- a/src/coreclr/jit/hwintrinsiccodegenxarch.cpp +++ b/src/coreclr/jit/hwintrinsiccodegenxarch.cpp @@ -186,6 +186,7 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) // We need to validate that other phases of the compiler haven't introduced unsupported intrinsics assert(compiler->compIsaSupportedDebugOnly(isa)); assert(HWIntrinsicInfo::RequiresCodegen(intrinsicId)); + assert(!HWIntrinsicInfo::NeedsNormalizeSmallTypeToInt(intrinsicId) || !varTypeIsSmall(node->GetSimdBaseType())); bool isTableDriven = genIsTableDrivenHWIntrinsic(intrinsicId, category); insOpts instOptions = INS_OPTS_NONE; diff --git a/src/coreclr/jit/hwintrinsiclistarm64.h b/src/coreclr/jit/hwintrinsiclistarm64.h index c3649cb64be..3f8c9ebf40d 100644 --- a/src/coreclr/jit/hwintrinsiclistarm64.h +++ b/src/coreclr/jit/hwintrinsiclistarm64.h @@ -486,9 +486,9 @@ HARDWARE_INTRINSIC(AdvSimd, ShiftRightLogicalScalar, HARDWARE_INTRINSIC(AdvSimd, SignExtendWideningLower, 8, 1, {INS_sxtl, INS_invalid, INS_sxtl, INS_invalid, INS_sxtl, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_BaseTypeFromFirstArg) HARDWARE_INTRINSIC(AdvSimd, SignExtendWideningUpper, 16, 1, {INS_sxtl2, INS_invalid, INS_sxtl2, INS_invalid, INS_sxtl2, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_BaseTypeFromFirstArg) HARDWARE_INTRINSIC(AdvSimd, SqrtScalar, 8, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_fsqrt, INS_fsqrt}, HW_Category_SIMD, HW_Flag_SIMDScalar) -HARDWARE_INTRINSIC(AdvSimd, Store, 8, 2, {INS_st1_2regs, INS_st1_2regs, INS_st1_2regs, INS_st1_2regs, INS_st1_2regs, INS_st1_2regs, INS_invalid, INS_invalid, INS_st1_2regs, INS_invalid}, HW_Category_MemoryStore, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_NeedsConsecutiveRegisters) -HARDWARE_INTRINSIC(AdvSimd, StoreSelectedScalar, 8, 3, {INS_st1, INS_st1, INS_st1, INS_st1, INS_st1, INS_st1, INS_st1, INS_st1, INS_st1, INS_st1}, HW_Category_MemoryStore, HW_Flag_BaseTypeFromFirstArg|HW_Flag_HasImmediateOperand|HW_Flag_SIMDScalar|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_NeedsConsecutiveRegisters) -HARDWARE_INTRINSIC(AdvSimd, StoreVectorAndZip, 8, 2, {INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2}, HW_Category_MemoryStore, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_NeedsConsecutiveRegisters) +HARDWARE_INTRINSIC(AdvSimd, Store, -1, 2, {INS_st1_2regs, INS_st1_2regs, INS_st1_2regs, INS_st1_2regs, INS_st1_2regs, INS_st1_2regs, INS_invalid, INS_invalid, INS_st1_2regs, INS_invalid}, HW_Category_MemoryStore, HW_Flag_BaseTypeFromSecondArg|HW_Flag_BaseTypeFromValueTupleArg|HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_NeedsConsecutiveRegisters) +HARDWARE_INTRINSIC(AdvSimd, StoreSelectedScalar, -1, 3, {INS_st1, INS_st1, INS_st1, INS_st1, INS_st1, INS_st1, INS_st1, INS_st1, INS_st1, INS_st1}, HW_Category_MemoryStore, HW_Flag_BaseTypeFromSecondArg|HW_Flag_BaseTypeFromValueTupleArg|HW_Flag_HasImmediateOperand|HW_Flag_SIMDScalar|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_NeedsConsecutiveRegisters) +HARDWARE_INTRINSIC(AdvSimd, StoreVectorAndZip, 8, 2, {INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2}, HW_Category_MemoryStore, HW_Flag_BaseTypeFromSecondArg|HW_Flag_BaseTypeFromValueTupleArg|HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_NeedsConsecutiveRegisters) HARDWARE_INTRINSIC(AdvSimd, Subtract, -1, 2, {INS_sub, INS_sub, INS_sub, INS_sub, INS_sub, INS_sub, INS_sub, INS_sub, INS_fsub, INS_invalid}, HW_Category_SIMD, HW_Flag_NoFlag) HARDWARE_INTRINSIC(AdvSimd, SubtractHighNarrowingLower, 8, 2, {INS_subhn, INS_subhn, INS_subhn, INS_subhn, INS_subhn, INS_subhn, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_NoFlag) HARDWARE_INTRINSIC(AdvSimd, SubtractHighNarrowingUpper, 16, 3, {INS_subhn2, INS_subhn2, INS_subhn2, INS_subhn2, INS_subhn2, INS_subhn2, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_HasRMWSemantics) @@ -678,13 +678,13 @@ HARDWARE_INTRINSIC(AdvSimd_Arm64, ShiftRightArithmeticRoundedNarrowingSaturateUn HARDWARE_INTRINSIC(AdvSimd_Arm64, ShiftRightLogicalNarrowingSaturateScalar, 8, 2, {INS_uqshrn, INS_uqshrn, INS_uqshrn, INS_uqshrn, INS_uqshrn, INS_uqshrn, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_ShiftRightByImmediate, HW_Flag_HasImmediateOperand|HW_Flag_SIMDScalar) HARDWARE_INTRINSIC(AdvSimd_Arm64, ShiftRightLogicalRoundedNarrowingSaturateScalar, 8, 2, {INS_uqrshrn, INS_uqrshrn, INS_uqrshrn, INS_uqrshrn, INS_uqrshrn, INS_uqrshrn, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_ShiftRightByImmediate, HW_Flag_HasImmediateOperand|HW_Flag_SIMDScalar) HARDWARE_INTRINSIC(AdvSimd_Arm64, Sqrt, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_fsqrt, INS_fsqrt}, HW_Category_SIMD, HW_Flag_NoFlag) -HARDWARE_INTRINSIC(AdvSimd_Arm64, Store, 16, 2, {INS_st1_2regs, INS_st1_2regs, INS_st1_2regs, INS_st1_2regs, INS_st1_2regs, INS_st1_2regs, INS_st1_2regs, INS_st1_2regs, INS_st1_2regs, INS_st1_2regs}, HW_Category_MemoryStore, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_NeedsConsecutiveRegisters) +HARDWARE_INTRINSIC(AdvSimd_Arm64, Store, 16, 2, {INS_st1_2regs, INS_st1_2regs, INS_st1_2regs, INS_st1_2regs, INS_st1_2regs, INS_st1_2regs, INS_st1_2regs, INS_st1_2regs, INS_st1_2regs, INS_st1_2regs}, HW_Category_MemoryStore, HW_Flag_BaseTypeFromSecondArg|HW_Flag_BaseTypeFromValueTupleArg|HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_NeedsConsecutiveRegisters) HARDWARE_INTRINSIC(AdvSimd_Arm64, StorePair, -1, 3, {INS_stp, INS_stp, INS_stp, INS_stp, INS_stp, INS_stp, INS_stp, INS_stp, INS_stp, INS_stp}, HW_Category_MemoryStore, HW_Flag_BaseTypeFromSecondArg|HW_Flag_SpecialCodeGen) HARDWARE_INTRINSIC(AdvSimd_Arm64, StorePairNonTemporal, -1, 3, {INS_stnp, INS_stnp, INS_stnp, INS_stnp, INS_stnp, INS_stnp, INS_stnp, INS_stnp, INS_stnp, INS_stp}, HW_Category_MemoryStore, HW_Flag_BaseTypeFromSecondArg|HW_Flag_SpecialCodeGen) HARDWARE_INTRINSIC(AdvSimd_Arm64, StorePairScalar, 8, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_stp, INS_stp, INS_invalid, INS_invalid, INS_stp, INS_invalid}, HW_Category_MemoryStore, HW_Flag_BaseTypeFromSecondArg|HW_Flag_SpecialCodeGen) HARDWARE_INTRINSIC(AdvSimd_Arm64, StorePairScalarNonTemporal, 8, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_stnp, INS_stnp, INS_invalid, INS_invalid, INS_stnp, INS_invalid}, HW_Category_MemoryStore, HW_Flag_BaseTypeFromSecondArg|HW_Flag_SpecialCodeGen) -HARDWARE_INTRINSIC(AdvSimd_Arm64, StoreSelectedScalar, 16, 3, {INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2}, HW_Category_MemoryStore, HW_Flag_BaseTypeFromFirstArg|HW_Flag_HasImmediateOperand|HW_Flag_SIMDScalar|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_NeedsConsecutiveRegisters) -HARDWARE_INTRINSIC(AdvSimd_Arm64, StoreVectorAndZip, 16, 2, {INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2}, HW_Category_MemoryStore, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_NeedsConsecutiveRegisters) +HARDWARE_INTRINSIC(AdvSimd_Arm64, StoreSelectedScalar, 16, 3, {INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2}, HW_Category_MemoryStore, HW_Flag_BaseTypeFromSecondArg|HW_Flag_BaseTypeFromValueTupleArg|HW_Flag_HasImmediateOperand|HW_Flag_SIMDScalar|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_NeedsConsecutiveRegisters) +HARDWARE_INTRINSIC(AdvSimd_Arm64, StoreVectorAndZip, 16, 2, {INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2, INS_st2}, HW_Category_MemoryStore, HW_Flag_BaseTypeFromSecondArg|HW_Flag_BaseTypeFromValueTupleArg|HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_NeedsConsecutiveRegisters) HARDWARE_INTRINSIC(AdvSimd_Arm64, Subtract, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_fsub}, HW_Category_SIMD, HW_Flag_NoFlag) HARDWARE_INTRINSIC(AdvSimd_Arm64, SubtractSaturateScalar, 8, 2, {INS_sqsub, INS_uqsub, INS_sqsub, INS_uqsub, INS_sqsub, INS_uqsub, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_SIMDScalar) HARDWARE_INTRINSIC(AdvSimd_Arm64, TransposeEven, -1, 2, {INS_trn1, INS_trn1, INS_trn1, INS_trn1, INS_trn1, INS_trn1, INS_trn1, INS_trn1, INS_trn1, INS_trn1}, HW_Category_SIMD, HW_Flag_NoFlag) diff --git a/src/coreclr/jit/hwintrinsiclistarm64sve.h b/src/coreclr/jit/hwintrinsiclistarm64sve.h index 41a82b2fdae..9bb76b0ad03 100644 --- a/src/coreclr/jit/hwintrinsiclistarm64sve.h +++ b/src/coreclr/jit/hwintrinsiclistarm64sve.h @@ -17,28 +17,28 @@ // SVE Intrinsics #define FIRST_NI_Sve NI_Sve_Abs HARDWARE_INTRINSIC(Sve, Abs, -1, -1, {INS_sve_abs, INS_invalid, INS_sve_abs, INS_invalid, INS_sve_abs, INS_invalid, INS_sve_abs, INS_invalid, INS_sve_fabs, INS_sve_fabs}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, AbsoluteCompareGreaterThan, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_facgt, INS_sve_facgt}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReturnsPerElementMask) -HARDWARE_INTRINSIC(Sve, AbsoluteCompareGreaterThanOrEqual, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_facge, INS_sve_facge}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReturnsPerElementMask) -HARDWARE_INTRINSIC(Sve, AbsoluteCompareLessThan, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_faclt, INS_sve_faclt}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReturnsPerElementMask) -HARDWARE_INTRINSIC(Sve, AbsoluteCompareLessThanOrEqual, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_facle, INS_sve_facle}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve, AbsoluteCompareGreaterThan, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_facgt, INS_sve_facgt}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReturnsPerElementMask|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, AbsoluteCompareGreaterThanOrEqual, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_facge, INS_sve_facge}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReturnsPerElementMask|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, AbsoluteCompareLessThan, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_faclt, INS_sve_faclt}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReturnsPerElementMask|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, AbsoluteCompareLessThanOrEqual, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_facle, INS_sve_facle}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReturnsPerElementMask|HW_Flag_ZeroingMaskedOperation) HARDWARE_INTRINSIC(Sve, AbsoluteDifference, -1, -1, {INS_sve_sabd, INS_sve_uabd, INS_sve_sabd, INS_sve_uabd, INS_sve_sabd, INS_sve_uabd, INS_sve_sabd, INS_sve_uabd, INS_sve_fabd, INS_sve_fabd}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_HasRMWSemantics|HW_Flag_LowMaskedOperation) HARDWARE_INTRINSIC(Sve, Add, -1, -1, {INS_sve_add, INS_sve_add, INS_sve_add, INS_sve_add, INS_sve_add, INS_sve_add, INS_sve_add, INS_sve_add, INS_sve_fadd, INS_sve_fadd}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_OptionalEmbeddedMaskedOperation|HW_Flag_HasRMWSemantics|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, AddAcross, -1, 1, {INS_sve_saddv, INS_sve_uaddv, INS_sve_saddv, INS_sve_uaddv, INS_sve_saddv, INS_sve_uaddv, INS_sve_uaddv, INS_sve_uaddv, INS_sve_faddv, INS_sve_faddv}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) +HARDWARE_INTRINSIC(Sve, AddAcross, -1, 1, {INS_sve_saddv, INS_sve_uaddv, INS_sve_saddv, INS_sve_uaddv, INS_sve_saddv, INS_sve_uaddv, INS_sve_uaddv, INS_sve_uaddv, INS_sve_faddv, INS_sve_faddv}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReduceOperation) HARDWARE_INTRINSIC(Sve, AddRotateComplex, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_fcadd, INS_sve_fcadd}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_HasRMWSemantics|HW_Flag_HasImmediateOperand) -HARDWARE_INTRINSIC(Sve, AddSaturate, -1, 2, {INS_sve_sqadd, INS_sve_uqadd, INS_sve_sqadd, INS_sve_uqadd, INS_sve_sqadd, INS_sve_uqadd, INS_sve_sqadd, INS_sve_uqadd, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasRMWSemantics|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, AddSequentialAcross, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_fadda, INS_sve_fadda}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_HasRMWSemantics) +HARDWARE_INTRINSIC(Sve, AddSaturate, -1, 2, {INS_sve_sqadd, INS_sve_uqadd, INS_sve_sqadd, INS_sve_uqadd, INS_sve_sqadd, INS_sve_uqadd, INS_sve_sqadd, INS_sve_uqadd, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable) +HARDWARE_INTRINSIC(Sve, AddSequentialAcross, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_fadda, INS_sve_fadda}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_HasRMWSemantics|HW_Flag_ReduceOperation) HARDWARE_INTRINSIC(Sve, And, -1, -1, {INS_sve_and, INS_sve_and, INS_sve_and, INS_sve_and, INS_sve_and, INS_sve_and, INS_sve_and, INS_sve_and, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_OptionalEmbeddedMaskedOperation|HW_Flag_HasRMWSemantics|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, AndAcross, -1, -1, {INS_sve_andv, INS_sve_andv, INS_sve_andv, INS_sve_andv, INS_sve_andv, INS_sve_andv, INS_sve_andv, INS_sve_andv, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) +HARDWARE_INTRINSIC(Sve, AndAcross, -1, -1, {INS_sve_andv, INS_sve_andv, INS_sve_andv, INS_sve_andv, INS_sve_andv, INS_sve_andv, INS_sve_andv, INS_sve_andv, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReduceOperation) HARDWARE_INTRINSIC(Sve, BitwiseClear, -1, -1, {INS_sve_bic, INS_sve_bic, INS_sve_bic, INS_sve_bic, INS_sve_bic, INS_sve_bic, INS_sve_bic, INS_sve_bic, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_OptionalEmbeddedMaskedOperation|HW_Flag_HasRMWSemantics|HW_Flag_LowMaskedOperation) HARDWARE_INTRINSIC(Sve, BooleanNot, -1, -1, {INS_sve_cnot, INS_sve_cnot, INS_sve_cnot, INS_sve_cnot, INS_sve_cnot, INS_sve_cnot, INS_sve_cnot, INS_sve_cnot, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) HARDWARE_INTRINSIC(Sve, Compact, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_compact, INS_sve_compact, INS_sve_compact, INS_sve_compact, INS_sve_compact, INS_sve_compact}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, CompareEqual, -1, -1, {INS_sve_cmpeq, INS_sve_cmpeq, INS_sve_cmpeq, INS_sve_cmpeq, INS_sve_cmpeq, INS_sve_cmpeq, INS_sve_cmpeq, INS_sve_cmpeq, INS_sve_fcmeq, INS_sve_fcmeq}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReturnsPerElementMask) -HARDWARE_INTRINSIC(Sve, CompareGreaterThan, -1, -1, {INS_sve_cmpgt, INS_sve_cmphi, INS_sve_cmpgt, INS_sve_cmphi, INS_sve_cmpgt, INS_sve_cmphi, INS_sve_cmpgt, INS_sve_cmphi, INS_sve_fcmgt, INS_sve_fcmgt}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReturnsPerElementMask) -HARDWARE_INTRINSIC(Sve, CompareGreaterThanOrEqual, -1, -1, {INS_sve_cmpge, INS_sve_cmphs, INS_sve_cmpge, INS_sve_cmphs, INS_sve_cmpge, INS_sve_cmphs, INS_sve_cmpge, INS_sve_cmphs, INS_sve_fcmge, INS_sve_fcmge}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReturnsPerElementMask) -HARDWARE_INTRINSIC(Sve, CompareLessThan, -1, -1, {INS_sve_cmplt, INS_sve_cmplo, INS_sve_cmplt, INS_sve_cmplo, INS_sve_cmplt, INS_sve_cmplo, INS_sve_cmplt, INS_sve_cmplo, INS_sve_fcmlt, INS_sve_fcmlt}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReturnsPerElementMask) -HARDWARE_INTRINSIC(Sve, CompareLessThanOrEqual, -1, -1, {INS_sve_cmple, INS_sve_cmpls, INS_sve_cmple, INS_sve_cmpls, INS_sve_cmple, INS_sve_cmpls, INS_sve_cmple, INS_sve_cmpls, INS_sve_fcmle, INS_sve_fcmle}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReturnsPerElementMask) -HARDWARE_INTRINSIC(Sve, CompareNotEqualTo, -1, -1, {INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_fcmne, INS_sve_fcmne}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReturnsPerElementMask) -HARDWARE_INTRINSIC(Sve, CompareUnordered, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_fcmuo, INS_sve_fcmuo}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve, CompareEqual, -1, -1, {INS_sve_cmpeq, INS_sve_cmpeq, INS_sve_cmpeq, INS_sve_cmpeq, INS_sve_cmpeq, INS_sve_cmpeq, INS_sve_cmpeq, INS_sve_cmpeq, INS_sve_fcmeq, INS_sve_fcmeq}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReturnsPerElementMask|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, CompareGreaterThan, -1, -1, {INS_sve_cmpgt, INS_sve_cmphi, INS_sve_cmpgt, INS_sve_cmphi, INS_sve_cmpgt, INS_sve_cmphi, INS_sve_cmpgt, INS_sve_cmphi, INS_sve_fcmgt, INS_sve_fcmgt}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReturnsPerElementMask|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, CompareGreaterThanOrEqual, -1, -1, {INS_sve_cmpge, INS_sve_cmphs, INS_sve_cmpge, INS_sve_cmphs, INS_sve_cmpge, INS_sve_cmphs, INS_sve_cmpge, INS_sve_cmphs, INS_sve_fcmge, INS_sve_fcmge}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReturnsPerElementMask|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, CompareLessThan, -1, -1, {INS_sve_cmplt, INS_sve_cmplo, INS_sve_cmplt, INS_sve_cmplo, INS_sve_cmplt, INS_sve_cmplo, INS_sve_cmplt, INS_sve_cmplo, INS_sve_fcmlt, INS_sve_fcmlt}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReturnsPerElementMask|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, CompareLessThanOrEqual, -1, -1, {INS_sve_cmple, INS_sve_cmpls, INS_sve_cmple, INS_sve_cmpls, INS_sve_cmple, INS_sve_cmpls, INS_sve_cmple, INS_sve_cmpls, INS_sve_fcmle, INS_sve_fcmle}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReturnsPerElementMask|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, CompareNotEqualTo, -1, -1, {INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_fcmne, INS_sve_fcmne}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReturnsPerElementMask|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, CompareUnordered, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_fcmuo, INS_sve_fcmuo}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReturnsPerElementMask|HW_Flag_ZeroingMaskedOperation) HARDWARE_INTRINSIC(Sve, Compute16BitAddresses, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_adr, INS_invalid, INS_sve_adr, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen) HARDWARE_INTRINSIC(Sve, Compute32BitAddresses, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_adr, INS_invalid, INS_sve_adr, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen) HARDWARE_INTRINSIC(Sve, Compute64BitAddresses, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_adr, INS_invalid, INS_sve_adr, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen) @@ -54,15 +54,15 @@ HARDWARE_INTRINSIC(Sve, ConvertToInt64, HARDWARE_INTRINSIC(Sve, ConvertToSingle, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_scvtf, INS_sve_ucvtf, INS_sve_scvtf, INS_sve_ucvtf, INS_invalid, INS_sve_fcvt}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) HARDWARE_INTRINSIC(Sve, ConvertToUInt32, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_fcvtzu, INS_sve_fcvtzu}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) HARDWARE_INTRINSIC(Sve, ConvertToUInt64, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_fcvtzu, INS_sve_fcvtzu}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, Count16BitElements, 0, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_cnth, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasEnumOperand|HW_Flag_SpecialCodeGen|HW_Flag_NoFloatingPointUsed) -HARDWARE_INTRINSIC(Sve, Count32BitElements, 0, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_cntw, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasEnumOperand|HW_Flag_SpecialCodeGen|HW_Flag_NoFloatingPointUsed) -HARDWARE_INTRINSIC(Sve, Count64BitElements, 0, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_cntd, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasEnumOperand|HW_Flag_SpecialCodeGen|HW_Flag_NoFloatingPointUsed) -HARDWARE_INTRINSIC(Sve, Count8BitElements, 0, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_cntb, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasEnumOperand|HW_Flag_SpecialCodeGen|HW_Flag_NoFloatingPointUsed) +HARDWARE_INTRINSIC(Sve, Count16BitElements, 0, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_cnth, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_SpecialCodeGen|HW_Flag_NoFloatingPointUsed) +HARDWARE_INTRINSIC(Sve, Count32BitElements, 0, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_cntw, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_SpecialCodeGen|HW_Flag_NoFloatingPointUsed) +HARDWARE_INTRINSIC(Sve, Count64BitElements, 0, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_cntd, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_SpecialCodeGen|HW_Flag_NoFloatingPointUsed) +HARDWARE_INTRINSIC(Sve, Count8BitElements, 0, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_cntb, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_SpecialCodeGen|HW_Flag_NoFloatingPointUsed) HARDWARE_INTRINSIC(Sve, CreateBreakAfterMask, -1, 2, {INS_sve_brka, INS_sve_brka, INS_sve_brka, INS_sve_brka, INS_sve_brka, INS_sve_brka, INS_sve_brka, INS_sve_brka, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_ReturnsPerElementMask|HW_Flag_SpecialCodeGen) -HARDWARE_INTRINSIC(Sve, CreateBreakAfterPropagateMask, -1, 3, {INS_sve_brkpa, INS_sve_brkpa, INS_sve_brkpa, INS_sve_brkpa, INS_sve_brkpa, INS_sve_brkpa, INS_sve_brkpa, INS_sve_brkpa, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_ReturnsPerElementMask|HW_Flag_SpecialCodeGen) +HARDWARE_INTRINSIC(Sve, CreateBreakAfterPropagateMask, -1, 3, {INS_sve_brkpa, INS_sve_brkpa, INS_sve_brkpa, INS_sve_brkpa, INS_sve_brkpa, INS_sve_brkpa, INS_sve_brkpa, INS_sve_brkpa, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_ReturnsPerElementMask|HW_Flag_SpecialCodeGen|HW_Flag_ZeroingMaskedOperation) HARDWARE_INTRINSIC(Sve, CreateBreakBeforeMask, -1, 2, {INS_sve_brkb, INS_sve_brkb, INS_sve_brkb, INS_sve_brkb, INS_sve_brkb, INS_sve_brkb, INS_sve_brkb, INS_sve_brkb, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_ReturnsPerElementMask|HW_Flag_SpecialCodeGen) -HARDWARE_INTRINSIC(Sve, CreateBreakBeforePropagateMask, -1, 3, {INS_sve_brkpb, INS_sve_brkpb, INS_sve_brkpb, INS_sve_brkpb, INS_sve_brkpb, INS_sve_brkpb, INS_sve_brkpb, INS_sve_brkpb, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_ReturnsPerElementMask|HW_Flag_SpecialCodeGen) -HARDWARE_INTRINSIC(Sve, CreateBreakPropagateMask, -1, -1, {INS_sve_brkn, INS_sve_brkn, INS_sve_brkn, INS_sve_brkn, INS_sve_brkn, INS_sve_brkn, INS_sve_brkn, INS_sve_brkn, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_ReturnsPerElementMask|HW_Flag_HasRMWSemantics) +HARDWARE_INTRINSIC(Sve, CreateBreakBeforePropagateMask, -1, 3, {INS_sve_brkpb, INS_sve_brkpb, INS_sve_brkpb, INS_sve_brkpb, INS_sve_brkpb, INS_sve_brkpb, INS_sve_brkpb, INS_sve_brkpb, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_ReturnsPerElementMask|HW_Flag_SpecialCodeGen|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, CreateBreakPropagateMask, -1, -1, {INS_sve_brkn, INS_sve_brkn, INS_sve_brkn, INS_sve_brkn, INS_sve_brkn, INS_sve_brkn, INS_sve_brkn, INS_sve_brkn, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_ReturnsPerElementMask|HW_Flag_HasRMWSemantics|HW_Flag_ZeroingMaskedOperation) HARDWARE_INTRINSIC(Sve, CreateFalseMaskByte, -1, 0, {INS_invalid, INS_sve_pfalse, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_ReturnsPerElementMask) HARDWARE_INTRINSIC(Sve, CreateFalseMaskDouble, -1, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_pfalse}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_ReturnsPerElementMask) HARDWARE_INTRINSIC(Sve, CreateFalseMaskInt16, -1, 0, {INS_invalid, INS_invalid, INS_sve_pfalse, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_ReturnsPerElementMask) @@ -75,16 +75,16 @@ HARDWARE_INTRINSIC(Sve, CreateFalseMaskUInt32, HARDWARE_INTRINSIC(Sve, CreateFalseMaskUInt64, -1, 0, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_pfalse, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_ReturnsPerElementMask) HARDWARE_INTRINSIC(Sve, CreateMaskForFirstActiveElement, -1, 2, {INS_sve_pfirst, INS_sve_pfirst, INS_sve_pfirst, INS_sve_pfirst, INS_sve_pfirst, INS_sve_pfirst, INS_sve_pfirst, INS_sve_pfirst, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_ReturnsPerElementMask|HW_Flag_SpecialCodeGen|HW_Flag_HasRMWSemantics) HARDWARE_INTRINSIC(Sve, CreateMaskForNextActiveElement, -1, 2, {INS_invalid, INS_sve_pnext, INS_invalid, INS_sve_pnext, INS_invalid, INS_sve_pnext, INS_invalid, INS_sve_pnext, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_ReturnsPerElementMask|HW_Flag_HasRMWSemantics) -HARDWARE_INTRINSIC(Sve, CreateTrueMaskByte, -1, 1, {INS_invalid, INS_sve_ptrue, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasEnumOperand|HW_Flag_ReturnsPerElementMask) -HARDWARE_INTRINSIC(Sve, CreateTrueMaskDouble, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ptrue}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasEnumOperand|HW_Flag_ReturnsPerElementMask) -HARDWARE_INTRINSIC(Sve, CreateTrueMaskInt16, -1, 1, {INS_invalid, INS_invalid, INS_sve_ptrue, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasEnumOperand|HW_Flag_ReturnsPerElementMask) -HARDWARE_INTRINSIC(Sve, CreateTrueMaskInt32, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ptrue, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasEnumOperand|HW_Flag_ReturnsPerElementMask) -HARDWARE_INTRINSIC(Sve, CreateTrueMaskInt64, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ptrue, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasEnumOperand|HW_Flag_ReturnsPerElementMask) -HARDWARE_INTRINSIC(Sve, CreateTrueMaskSByte, -1, 1, {INS_sve_ptrue, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasEnumOperand|HW_Flag_ReturnsPerElementMask) -HARDWARE_INTRINSIC(Sve, CreateTrueMaskSingle, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ptrue, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasEnumOperand|HW_Flag_ReturnsPerElementMask) -HARDWARE_INTRINSIC(Sve, CreateTrueMaskUInt16, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_sve_ptrue, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasEnumOperand|HW_Flag_ReturnsPerElementMask) -HARDWARE_INTRINSIC(Sve, CreateTrueMaskUInt32, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ptrue, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasEnumOperand|HW_Flag_ReturnsPerElementMask) -HARDWARE_INTRINSIC(Sve, CreateTrueMaskUInt64, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ptrue, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasEnumOperand|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve, CreateTrueMaskByte, -1, 1, {INS_invalid, INS_sve_ptrue, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve, CreateTrueMaskDouble, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ptrue}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve, CreateTrueMaskInt16, -1, 1, {INS_invalid, INS_invalid, INS_sve_ptrue, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve, CreateTrueMaskInt32, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ptrue, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve, CreateTrueMaskInt64, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ptrue, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve, CreateTrueMaskSByte, -1, 1, {INS_sve_ptrue, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve, CreateTrueMaskSingle, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ptrue, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve, CreateTrueMaskUInt16, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_sve_ptrue, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve, CreateTrueMaskUInt32, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ptrue, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve, CreateTrueMaskUInt64, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ptrue, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_ReturnsPerElementMask) HARDWARE_INTRINSIC(Sve, CreateWhileLessThanMask16Bit, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_sve_whilelt, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) HARDWARE_INTRINSIC(Sve, CreateWhileLessThanMask32Bit, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilelt, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) HARDWARE_INTRINSIC(Sve, CreateWhileLessThanMask64Bit, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilelt, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) @@ -105,23 +105,34 @@ HARDWARE_INTRINSIC(Sve, FusedMultiplyAddNegated, HARDWARE_INTRINSIC(Sve, FusedMultiplySubtract, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_fmls, INS_sve_fmls}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_HasRMWSemantics|HW_Flag_LowMaskedOperation|HW_Flag_FmaIntrinsic|HW_Flag_SpecialCodeGen) HARDWARE_INTRINSIC(Sve, FusedMultiplySubtractBySelectedScalar, -1, 4, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_fmls, INS_sve_fmls}, HW_Category_SIMDByIndexedElement, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_HasRMWSemantics|HW_Flag_FmaIntrinsic|HW_Flag_LowVectorOperation) HARDWARE_INTRINSIC(Sve, FusedMultiplySubtractNegated, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_fnmls, INS_sve_fnmls}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_HasRMWSemantics|HW_Flag_LowMaskedOperation|HW_Flag_FmaIntrinsic|HW_Flag_SpecialCodeGen) -HARDWARE_INTRINSIC(Sve, GatherPrefetch16Bit, -1, -1, {INS_invalid, INS_invalid, INS_sve_prfh, INS_sve_prfh, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialSideEffect_Other) -HARDWARE_INTRINSIC(Sve, GatherPrefetch32Bit, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_prfw, INS_sve_prfw, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialSideEffect_Other) -HARDWARE_INTRINSIC(Sve, GatherPrefetch64Bit, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_prfd, INS_sve_prfd, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialSideEffect_Other) -HARDWARE_INTRINSIC(Sve, GatherPrefetch8Bit, -1, -1, {INS_sve_prfb, INS_sve_prfb, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialSideEffect_Other) -HARDWARE_INTRINSIC(Sve, GatherVector, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1w, INS_sve_ld1w, INS_sve_ld1d, INS_sve_ld1d, INS_sve_ld1w, INS_sve_ld1d}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, GatherVectorByteZeroExtend, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1b, INS_sve_ld1b, INS_sve_ld1b, INS_sve_ld1b, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, GatherVectorFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldff1w, INS_sve_ldff1w, INS_sve_ldff1d, INS_sve_ldff1d, INS_sve_ldff1w, INS_sve_ldff1d}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_SpecialSideEffect_Other) -HARDWARE_INTRINSIC(Sve, GatherVectorInt16SignExtend, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sh, INS_sve_ld1sh, INS_sve_ld1sh, INS_sve_ld1sh, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, GatherVectorInt16WithByteOffsetsSignExtend, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sh, INS_sve_ld1sh, INS_sve_ld1sh, INS_sve_ld1sh, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, GatherVectorInt32SignExtend, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sw, INS_sve_ld1sw, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, GatherVectorInt32WithByteOffsetsSignExtend, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sw, INS_sve_ld1sw, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, GatherVectorSByteSignExtend, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sb, INS_sve_ld1sb, INS_sve_ld1sb, INS_sve_ld1sb, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, GatherVectorUInt16WithByteOffsetsZeroExtend, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1h, INS_sve_ld1h, INS_sve_ld1h, INS_sve_ld1h, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, GatherVectorUInt16ZeroExtend, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1h, INS_sve_ld1h, INS_sve_ld1h, INS_sve_ld1h, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, GatherVectorUInt32WithByteOffsetsZeroExtend, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1w, INS_sve_ld1w, INS_sve_ld1w, INS_sve_ld1w, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, GatherVectorUInt32ZeroExtend, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1w, INS_sve_ld1w, INS_sve_ld1w, INS_sve_ld1w, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, GatherVectorWithByteOffsets, -1, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1w, INS_sve_ld1w, INS_sve_ld1d, INS_sve_ld1d, INS_sve_ld1w, INS_sve_ld1d}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) +HARDWARE_INTRINSIC(Sve, GatherPrefetch16Bit, -1, -1, {INS_invalid, INS_invalid, INS_sve_prfh, INS_sve_prfh, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_HasImmediateOperand|HW_Flag_SpecialSideEffect_Other) +HARDWARE_INTRINSIC(Sve, GatherPrefetch32Bit, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_prfw, INS_sve_prfw, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_HasImmediateOperand|HW_Flag_SpecialSideEffect_Other) +HARDWARE_INTRINSIC(Sve, GatherPrefetch64Bit, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_prfd, INS_sve_prfd, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_HasImmediateOperand|HW_Flag_SpecialSideEffect_Other) +HARDWARE_INTRINSIC(Sve, GatherPrefetch8Bit, -1, -1, {INS_sve_prfb, INS_sve_prfb, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_HasImmediateOperand|HW_Flag_SpecialSideEffect_Other) +HARDWARE_INTRINSIC(Sve, GatherVector, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1w, INS_sve_ld1w, INS_sve_ld1d, INS_sve_ld1d, INS_sve_ld1w, INS_sve_ld1d}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, GatherVectorByteZeroExtend, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1b, INS_sve_ld1b, INS_sve_ld1b, INS_sve_ld1b, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, GatherVectorByteZeroExtendFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldff1b, INS_sve_ldff1b, INS_sve_ldff1b, INS_sve_ldff1b, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffect_Other) +HARDWARE_INTRINSIC(Sve, GatherVectorFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldff1w, INS_sve_ldff1w, INS_sve_ldff1d, INS_sve_ldff1d, INS_sve_ldff1w, INS_sve_ldff1d}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffect_Other) +HARDWARE_INTRINSIC(Sve, GatherVectorInt16SignExtend, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sh, INS_sve_ld1sh, INS_sve_ld1sh, INS_sve_ld1sh, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, GatherVectorInt16SignExtendFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldff1sh, INS_sve_ldff1sh, INS_sve_ldff1sh, INS_sve_ldff1sh, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffect_Other) +HARDWARE_INTRINSIC(Sve, GatherVectorInt16WithByteOffsetsSignExtend, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sh, INS_sve_ld1sh, INS_sve_ld1sh, INS_sve_ld1sh, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldff1sh, INS_sve_ldff1sh, INS_sve_ldff1sh, INS_sve_ldff1sh, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffect_Other) +HARDWARE_INTRINSIC(Sve, GatherVectorInt32SignExtend, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sw, INS_sve_ld1sw, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, GatherVectorInt32SignExtendFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldff1sw, INS_sve_ldff1sw, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffect_Other) +HARDWARE_INTRINSIC(Sve, GatherVectorInt32WithByteOffsetsSignExtend, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sw, INS_sve_ld1sw, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, GatherVectorInt32WithByteOffsetsSignExtendFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldff1sw, INS_sve_ldff1sw, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffect_Other) +HARDWARE_INTRINSIC(Sve, GatherVectorSByteSignExtend, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sb, INS_sve_ld1sb, INS_sve_ld1sb, INS_sve_ld1sb, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, GatherVectorSByteSignExtendFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldff1sb, INS_sve_ldff1sb, INS_sve_ldff1sb, INS_sve_ldff1sb, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffect_Other) +HARDWARE_INTRINSIC(Sve, GatherVectorUInt16WithByteOffsetsZeroExtend, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1h, INS_sve_ld1h, INS_sve_ld1h, INS_sve_ld1h, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldff1h, INS_sve_ldff1h, INS_sve_ldff1h, INS_sve_ldff1h, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffect_Other) +HARDWARE_INTRINSIC(Sve, GatherVectorUInt16ZeroExtend, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1h, INS_sve_ld1h, INS_sve_ld1h, INS_sve_ld1h, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, GatherVectorUInt16ZeroExtendFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldff1h, INS_sve_ldff1h, INS_sve_ldff1h, INS_sve_ldff1h, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffect_Other) +HARDWARE_INTRINSIC(Sve, GatherVectorUInt32WithByteOffsetsZeroExtend, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1w, INS_sve_ld1w, INS_sve_ld1w, INS_sve_ld1w, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldff1w, INS_sve_ldff1w, INS_sve_ldff1w, INS_sve_ldff1w, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffect_Other) +HARDWARE_INTRINSIC(Sve, GatherVectorUInt32ZeroExtend, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1w, INS_sve_ld1w, INS_sve_ld1w, INS_sve_ld1w, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, GatherVectorUInt32ZeroExtendFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldff1w, INS_sve_ldff1w, INS_sve_ldff1w, INS_sve_ldff1w, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffect_Other) +HARDWARE_INTRINSIC(Sve, GatherVectorWithByteOffsetFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldff1w, INS_sve_ldff1w, INS_sve_ldff1d, INS_sve_ldff1d, INS_sve_ldff1w, INS_sve_ldff1d}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffect_Other) +HARDWARE_INTRINSIC(Sve, GatherVectorWithByteOffsets, -1, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1w, INS_sve_ld1w, INS_sve_ld1d, INS_sve_ld1d, INS_sve_ld1w, INS_sve_ld1d}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) HARDWARE_INTRINSIC(Sve, GetActiveElementCount, -1, 2, {INS_sve_cntp, INS_sve_cntp, INS_sve_cntp, INS_sve_cntp, INS_sve_cntp, INS_sve_cntp, INS_sve_cntp, INS_sve_cntp, INS_sve_cntp, INS_sve_cntp}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg|HW_Flag_ExplicitMaskedOperation) HARDWARE_INTRINSIC(Sve, GetFfrByte, -1, 0, {INS_invalid, INS_sve_rdffr, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask|HW_Flag_SpecialSideEffect_Other) HARDWARE_INTRINSIC(Sve, GetFfrInt16, -1, 0, {INS_invalid, INS_invalid, INS_sve_rdffr, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask|HW_Flag_SpecialSideEffect_Other) @@ -137,73 +148,73 @@ HARDWARE_INTRINSIC(Sve, LeadingZeroCount, HARDWARE_INTRINSIC(Sve, Load2xVectorAndUnzip, -1, 2, {INS_sve_ld2b, INS_sve_ld2b, INS_sve_ld2h, INS_sve_ld2h, INS_sve_ld2w, INS_sve_ld2w, INS_sve_ld2d, INS_sve_ld2d, INS_sve_ld2w, INS_sve_ld2d}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_MultiReg|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_NeedsConsecutiveRegisters|HW_Flag_BaseTypeFromFirstArg) HARDWARE_INTRINSIC(Sve, Load3xVectorAndUnzip, -1, 2, {INS_sve_ld3b, INS_sve_ld3b, INS_sve_ld3h, INS_sve_ld3h, INS_sve_ld3w, INS_sve_ld3w, INS_sve_ld3d, INS_sve_ld3d, INS_sve_ld3w, INS_sve_ld3d}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_MultiReg|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_NeedsConsecutiveRegisters|HW_Flag_BaseTypeFromFirstArg) HARDWARE_INTRINSIC(Sve, Load4xVectorAndUnzip, -1, 2, {INS_sve_ld4b, INS_sve_ld4b, INS_sve_ld4h, INS_sve_ld4h, INS_sve_ld4w, INS_sve_ld4w, INS_sve_ld4d, INS_sve_ld4d, INS_sve_ld4w, INS_sve_ld4d}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_MultiReg|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_NeedsConsecutiveRegisters|HW_Flag_BaseTypeFromFirstArg) -HARDWARE_INTRINSIC(Sve, LoadVector, -1, 2, {INS_sve_ld1b, INS_sve_ld1b, INS_sve_ld1h, INS_sve_ld1h, INS_sve_ld1w, INS_sve_ld1w, INS_sve_ld1d, INS_sve_ld1d, INS_sve_ld1w, INS_sve_ld1d}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVector128AndReplicateToVector, -1, 2, {INS_sve_ld1rqb, INS_sve_ld1rqb, INS_sve_ld1rqh, INS_sve_ld1rqh, INS_sve_ld1rqw, INS_sve_ld1rqw, INS_sve_ld1rqd, INS_sve_ld1rqd, INS_sve_ld1rqw, INS_sve_ld1rqd}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorByteNonFaultingZeroExtendToInt16, -1, 1, {INS_invalid, INS_invalid, INS_sve_ldnf1b, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorByteNonFaultingZeroExtendToInt32, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1b, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorByteNonFaultingZeroExtendToInt64, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1b, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorByteNonFaultingZeroExtendToUInt16, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1b, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorByteNonFaultingZeroExtendToUInt32, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1b, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorByteNonFaultingZeroExtendToUInt64, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1b, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorByteZeroExtendFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_sve_ldff1b, INS_sve_ldff1b, INS_sve_ldff1b, INS_sve_ldff1b, INS_sve_ldff1b, INS_sve_ldff1b, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_SpecialCodeGen|HW_Flag_SpecialSideEffectMask) -HARDWARE_INTRINSIC(Sve, LoadVectorByteZeroExtendToInt16, -1, 2, {INS_invalid, INS_invalid, INS_sve_ld1b, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorByteZeroExtendToInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1b, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorByteZeroExtendToInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1b, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorByteZeroExtendToUInt16, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1b, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorByteZeroExtendToUInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1b, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorByteZeroExtendToUInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1b, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorFirstFaulting, -1, -1, {INS_sve_ldff1b, INS_sve_ldff1b, INS_sve_ldff1h, INS_sve_ldff1h, INS_sve_ldff1w, INS_sve_ldff1w, INS_sve_ldff1d, INS_sve_ldff1d, INS_sve_ldff1w, INS_sve_ldff1d}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_SpecialSideEffect_Other) -HARDWARE_INTRINSIC(Sve, LoadVectorInt16NonFaultingSignExtendToInt32, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1sh, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorInt16NonFaultingSignExtendToInt64, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1sh, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorInt16NonFaultingSignExtendToUInt32, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1sh, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorInt16NonFaultingSignExtendToUInt64, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1sh, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorInt16SignExtendFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldff1sh, INS_sve_ldff1sh, INS_sve_ldff1sh, INS_sve_ldff1sh, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_SpecialCodeGen|HW_Flag_SpecialSideEffectMask) -HARDWARE_INTRINSIC(Sve, LoadVectorInt16SignExtendToInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sh, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorInt16SignExtendToInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sh, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorInt16SignExtendToUInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sh, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorInt16SignExtendToUInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sh, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorInt32NonFaultingSignExtendToInt64, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1sw, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorInt32NonFaultingSignExtendToUInt64, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1sw, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorInt32SignExtendFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldff1sw, INS_sve_ldff1sw, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_SpecialCodeGen|HW_Flag_SpecialSideEffectMask) -HARDWARE_INTRINSIC(Sve, LoadVectorInt32SignExtendToInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sw, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorInt32SignExtendToUInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sw, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorNonFaulting, -1, 1, {INS_sve_ldnf1b, INS_sve_ldnf1b, INS_sve_ldnf1h, INS_sve_ldnf1h, INS_sve_ldnf1w, INS_sve_ldnf1w, INS_sve_ldnf1d, INS_sve_ldnf1d, INS_sve_ldnf1w, INS_sve_ldnf1d}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorNonTemporal, -1, 2, {INS_sve_ldnt1b, INS_sve_ldnt1b, INS_sve_ldnt1h, INS_sve_ldnt1h, INS_sve_ldnt1w, INS_sve_ldnt1w, INS_sve_ldnt1d, INS_sve_ldnt1d, INS_sve_ldnt1w, INS_sve_ldnt1d}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorSByteNonFaultingSignExtendToInt16, -1, -1, {INS_invalid, INS_invalid, INS_sve_ldnf1sb, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorSByteNonFaultingSignExtendToInt32, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1sb, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorSByteNonFaultingSignExtendToInt64, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1sb, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorSByteNonFaultingSignExtendToUInt16, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1sb, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorSByteNonFaultingSignExtendToUInt32, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1sb, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorSByteNonFaultingSignExtendToUInt64, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1sb, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorSByteSignExtendFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_sve_ldff1sb, INS_sve_ldff1sb, INS_sve_ldff1sb, INS_sve_ldff1sb, INS_sve_ldff1sb, INS_sve_ldff1sb, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_SpecialCodeGen|HW_Flag_SpecialSideEffectMask) -HARDWARE_INTRINSIC(Sve, LoadVectorSByteSignExtendToInt16, -1, 2, {INS_invalid, INS_invalid, INS_sve_ld1sb, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorSByteSignExtendToInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sb, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorSByteSignExtendToInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sb, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorSByteSignExtendToUInt16, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sb, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorSByteSignExtendToUInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sb, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorSByteSignExtendToUInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sb, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorUInt16NonFaultingZeroExtendToInt32, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1h, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorUInt16NonFaultingZeroExtendToInt64, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1h, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorUInt16NonFaultingZeroExtendToUInt32, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1h, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorUInt16NonFaultingZeroExtendToUInt64, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1h, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorUInt16ZeroExtendFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldff1h, INS_sve_ldff1h, INS_sve_ldff1h, INS_sve_ldff1h, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_SpecialCodeGen|HW_Flag_SpecialSideEffectMask) -HARDWARE_INTRINSIC(Sve, LoadVectorUInt16ZeroExtendToInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1h, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorUInt16ZeroExtendToInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1h, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorUInt16ZeroExtendToUInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1h, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorUInt16ZeroExtendToUInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1h, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorUInt32NonFaultingZeroExtendToInt64, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1w, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorUInt32NonFaultingZeroExtendToUInt64, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1w, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorUInt32ZeroExtendFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldff1w, INS_sve_ldff1w, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_SpecialCodeGen|HW_Flag_SpecialSideEffectMask) -HARDWARE_INTRINSIC(Sve, LoadVectorUInt32ZeroExtendToInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1w, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, LoadVectorUInt32ZeroExtendToUInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1w, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVector, -1, 2, {INS_sve_ld1b, INS_sve_ld1b, INS_sve_ld1h, INS_sve_ld1h, INS_sve_ld1w, INS_sve_ld1w, INS_sve_ld1d, INS_sve_ld1d, INS_sve_ld1w, INS_sve_ld1d}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVector128AndReplicateToVector, -1, 2, {INS_sve_ld1rqb, INS_sve_ld1rqb, INS_sve_ld1rqh, INS_sve_ld1rqh, INS_sve_ld1rqw, INS_sve_ld1rqw, INS_sve_ld1rqd, INS_sve_ld1rqd, INS_sve_ld1rqw, INS_sve_ld1rqd}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorByteNonFaultingZeroExtendToInt16, -1, -1, {INS_invalid, INS_invalid, INS_sve_ldnf1b, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorByteNonFaultingZeroExtendToInt32, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1b, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorByteNonFaultingZeroExtendToInt64, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1b, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorByteNonFaultingZeroExtendToUInt16, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1b, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorByteNonFaultingZeroExtendToUInt32, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1b, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorByteNonFaultingZeroExtendToUInt64, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1b, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorByteZeroExtendFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_sve_ldff1b, INS_sve_ldff1b, INS_sve_ldff1b, INS_sve_ldff1b, INS_sve_ldff1b, INS_sve_ldff1b, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialCodeGen|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorByteZeroExtendToInt16, -1, 2, {INS_invalid, INS_invalid, INS_sve_ld1b, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorByteZeroExtendToInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1b, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorByteZeroExtendToInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1b, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorByteZeroExtendToUInt16, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1b, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorByteZeroExtendToUInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1b, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorByteZeroExtendToUInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1b, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorFirstFaulting, -1, -1, {INS_sve_ldff1b, INS_sve_ldff1b, INS_sve_ldff1h, INS_sve_ldff1h, INS_sve_ldff1w, INS_sve_ldff1w, INS_sve_ldff1d, INS_sve_ldff1d, INS_sve_ldff1w, INS_sve_ldff1d}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffect_Other) +HARDWARE_INTRINSIC(Sve, LoadVectorInt16NonFaultingSignExtendToInt32, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1sh, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorInt16NonFaultingSignExtendToInt64, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1sh, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorInt16NonFaultingSignExtendToUInt32, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1sh, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorInt16NonFaultingSignExtendToUInt64, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1sh, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorInt16SignExtendFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldff1sh, INS_sve_ldff1sh, INS_sve_ldff1sh, INS_sve_ldff1sh, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialCodeGen|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorInt16SignExtendToInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sh, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorInt16SignExtendToInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sh, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorInt16SignExtendToUInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sh, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorInt16SignExtendToUInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sh, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorInt32NonFaultingSignExtendToInt64, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1sw, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorInt32NonFaultingSignExtendToUInt64, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1sw, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorInt32SignExtendFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldff1sw, INS_sve_ldff1sw, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialCodeGen|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorInt32SignExtendToInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sw, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorInt32SignExtendToUInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sw, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorNonFaulting, -1, -1, {INS_sve_ldnf1b, INS_sve_ldnf1b, INS_sve_ldnf1h, INS_sve_ldnf1h, INS_sve_ldnf1w, INS_sve_ldnf1w, INS_sve_ldnf1d, INS_sve_ldnf1d, INS_sve_ldnf1w, INS_sve_ldnf1d}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorNonTemporal, -1, 2, {INS_sve_ldnt1b, INS_sve_ldnt1b, INS_sve_ldnt1h, INS_sve_ldnt1h, INS_sve_ldnt1w, INS_sve_ldnt1w, INS_sve_ldnt1d, INS_sve_ldnt1d, INS_sve_ldnt1w, INS_sve_ldnt1d}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorSByteNonFaultingSignExtendToInt16, -1, -1, {INS_invalid, INS_invalid, INS_sve_ldnf1sb, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorSByteNonFaultingSignExtendToInt32, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1sb, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorSByteNonFaultingSignExtendToInt64, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1sb, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorSByteNonFaultingSignExtendToUInt16, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1sb, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorSByteNonFaultingSignExtendToUInt32, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1sb, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorSByteNonFaultingSignExtendToUInt64, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1sb, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorSByteSignExtendFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_sve_ldff1sb, INS_sve_ldff1sb, INS_sve_ldff1sb, INS_sve_ldff1sb, INS_sve_ldff1sb, INS_sve_ldff1sb, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialCodeGen|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorSByteSignExtendToInt16, -1, 2, {INS_invalid, INS_invalid, INS_sve_ld1sb, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorSByteSignExtendToInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sb, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorSByteSignExtendToInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sb, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorSByteSignExtendToUInt16, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sb, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorSByteSignExtendToUInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sb, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorSByteSignExtendToUInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1sb, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorUInt16NonFaultingZeroExtendToInt32, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1h, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorUInt16NonFaultingZeroExtendToInt64, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1h, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorUInt16NonFaultingZeroExtendToUInt32, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1h, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorUInt16NonFaultingZeroExtendToUInt64, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1h, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorUInt16ZeroExtendFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldff1h, INS_sve_ldff1h, INS_sve_ldff1h, INS_sve_ldff1h, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialCodeGen|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorUInt16ZeroExtendToInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1h, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorUInt16ZeroExtendToInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1h, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorUInt16ZeroExtendToUInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1h, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorUInt16ZeroExtendToUInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1h, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorUInt32NonFaultingZeroExtendToInt64, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1w, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorUInt32NonFaultingZeroExtendToUInt64, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldnf1w, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorUInt32ZeroExtendFirstFaulting, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ldff1w, INS_sve_ldff1w, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation|HW_Flag_SpecialCodeGen|HW_Flag_SpecialSideEffectMask) +HARDWARE_INTRINSIC(Sve, LoadVectorUInt32ZeroExtendToInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1w, INS_invalid, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) +HARDWARE_INTRINSIC(Sve, LoadVectorUInt32ZeroExtendToUInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ld1w, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) HARDWARE_INTRINSIC(Sve, Max, -1, -1, {INS_sve_smax, INS_sve_umax, INS_sve_smax, INS_sve_umax, INS_sve_smax, INS_sve_umax, INS_sve_smax, INS_sve_umax, INS_sve_fmax, INS_sve_fmax}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_HasRMWSemantics|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, MaxAcross, -1, -1, {INS_sve_smaxv, INS_sve_umaxv, INS_sve_smaxv, INS_sve_umaxv, INS_sve_smaxv, INS_sve_umaxv, INS_sve_smaxv, INS_sve_umaxv, INS_sve_fmaxv, INS_sve_fmaxv}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) +HARDWARE_INTRINSIC(Sve, MaxAcross, -1, -1, {INS_sve_smaxv, INS_sve_umaxv, INS_sve_smaxv, INS_sve_umaxv, INS_sve_smaxv, INS_sve_umaxv, INS_sve_smaxv, INS_sve_umaxv, INS_sve_fmaxv, INS_sve_fmaxv}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReduceOperation) HARDWARE_INTRINSIC(Sve, MaxNumber, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_fmaxnm, INS_sve_fmaxnm}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_HasRMWSemantics|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, MaxNumberAcross, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_fmaxnmv, INS_sve_fmaxnmv}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) +HARDWARE_INTRINSIC(Sve, MaxNumberAcross, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_fmaxnmv, INS_sve_fmaxnmv}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReduceOperation) HARDWARE_INTRINSIC(Sve, Min, -1, -1, {INS_sve_smin, INS_sve_umin, INS_sve_smin, INS_sve_umin, INS_sve_smin, INS_sve_umin, INS_sve_smin, INS_sve_umin, INS_sve_fmin, INS_sve_fmin}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_HasRMWSemantics|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, MinAcross, -1, -1, {INS_sve_sminv, INS_sve_uminv, INS_sve_sminv, INS_sve_uminv, INS_sve_sminv, INS_sve_uminv, INS_sve_sminv, INS_sve_uminv, INS_sve_fminv, INS_sve_fminv}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) +HARDWARE_INTRINSIC(Sve, MinAcross, -1, -1, {INS_sve_sminv, INS_sve_uminv, INS_sve_sminv, INS_sve_uminv, INS_sve_sminv, INS_sve_uminv, INS_sve_sminv, INS_sve_uminv, INS_sve_fminv, INS_sve_fminv}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReduceOperation) HARDWARE_INTRINSIC(Sve, MinNumber, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_fminnm, INS_sve_fminnm}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_HasRMWSemantics|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, MinNumberAcross, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_fminnmv, INS_sve_fminnmv}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) +HARDWARE_INTRINSIC(Sve, MinNumberAcross, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_fminnmv, INS_sve_fminnmv}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReduceOperation) HARDWARE_INTRINSIC(Sve, Multiply, -1, 2, {INS_sve_mul, INS_sve_mul, INS_sve_mul, INS_sve_mul, INS_sve_mul, INS_sve_mul, INS_sve_mul, INS_sve_mul, INS_sve_fmul, INS_sve_fmul}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_HasRMWSemantics|HW_Flag_LowMaskedOperation) HARDWARE_INTRINSIC(Sve, MultiplyAdd, -1, -1, {INS_sve_mla, INS_sve_mla, INS_sve_mla, INS_sve_mla, INS_sve_mla, INS_sve_mla, INS_sve_mla, INS_sve_mla, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_HasRMWSemantics|HW_Flag_LowMaskedOperation|HW_Flag_FmaIntrinsic|HW_Flag_SpecialCodeGen) HARDWARE_INTRINSIC(Sve, MultiplyAddRotateComplex, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_fcmla, INS_sve_fcmla}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_HasRMWSemantics|HW_Flag_HasImmediateOperand) @@ -214,12 +225,12 @@ HARDWARE_INTRINSIC(Sve, MultiplySubtract, HARDWARE_INTRINSIC(Sve, Negate, -1, -1, {INS_sve_neg, INS_invalid, INS_sve_neg, INS_invalid, INS_sve_neg, INS_invalid, INS_sve_neg, INS_invalid, INS_sve_fneg, INS_sve_fneg}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) HARDWARE_INTRINSIC(Sve, Not, -1, -1, {INS_sve_not, INS_sve_not, INS_sve_not, INS_sve_not, INS_sve_not, INS_sve_not, INS_sve_not, INS_sve_not, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation) HARDWARE_INTRINSIC(Sve, Or, -1, -1, {INS_sve_orr, INS_sve_orr, INS_sve_orr, INS_sve_orr, INS_sve_orr, INS_sve_orr, INS_sve_orr, INS_sve_orr, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_OptionalEmbeddedMaskedOperation|HW_Flag_HasRMWSemantics|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, OrAcross, -1, -1, {INS_sve_orv, INS_sve_orv, INS_sve_orv, INS_sve_orv, INS_sve_orv, INS_sve_orv, INS_sve_orv, INS_sve_orv, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) +HARDWARE_INTRINSIC(Sve, OrAcross, -1, -1, {INS_sve_orv, INS_sve_orv, INS_sve_orv, INS_sve_orv, INS_sve_orv, INS_sve_orv, INS_sve_orv, INS_sve_orv, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReduceOperation) HARDWARE_INTRINSIC(Sve, PopCount, -1, -1, {INS_sve_cnt, INS_sve_cnt, INS_sve_cnt, INS_sve_cnt, INS_sve_cnt, INS_sve_cnt, INS_sve_cnt, INS_sve_cnt, INS_sve_cnt, INS_sve_cnt}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, PrefetchBytes, -1, 3, {INS_invalid, INS_sve_prfb, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_BaseTypeFromFirstArg|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialSideEffect_Other) -HARDWARE_INTRINSIC(Sve, PrefetchInt16, -1, 3, {INS_invalid, INS_invalid, INS_invalid, INS_sve_prfh, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_BaseTypeFromFirstArg|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialSideEffect_Other) -HARDWARE_INTRINSIC(Sve, PrefetchInt32, -1, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_prfw, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_BaseTypeFromFirstArg|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialSideEffect_Other) -HARDWARE_INTRINSIC(Sve, PrefetchInt64, -1, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_prfd, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_BaseTypeFromFirstArg|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialSideEffect_Other) +HARDWARE_INTRINSIC(Sve, PrefetchBytes, -1, 3, {INS_invalid, INS_sve_prfb, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_BaseTypeFromFirstArg|HW_Flag_HasImmediateOperand|HW_Flag_SpecialSideEffect_Other) +HARDWARE_INTRINSIC(Sve, PrefetchInt16, -1, 3, {INS_invalid, INS_invalid, INS_invalid, INS_sve_prfh, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_BaseTypeFromFirstArg|HW_Flag_HasImmediateOperand|HW_Flag_SpecialSideEffect_Other) +HARDWARE_INTRINSIC(Sve, PrefetchInt32, -1, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_prfw, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_BaseTypeFromFirstArg|HW_Flag_HasImmediateOperand|HW_Flag_SpecialSideEffect_Other) +HARDWARE_INTRINSIC(Sve, PrefetchInt64, -1, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_prfd, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_BaseTypeFromFirstArg|HW_Flag_HasImmediateOperand|HW_Flag_SpecialSideEffect_Other) HARDWARE_INTRINSIC(Sve, ReciprocalEstimate, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_frecpe, INS_sve_frecpe}, HW_Category_SIMD, HW_Flag_Scalable) HARDWARE_INTRINSIC(Sve, ReciprocalExponent, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_frecpx, INS_sve_frecpx}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) HARDWARE_INTRINSIC(Sve, ReciprocalSqrtEstimate, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_frsqrte, INS_sve_frsqrte}, HW_Category_SIMD, HW_Flag_Scalable) @@ -235,15 +246,15 @@ HARDWARE_INTRINSIC(Sve, RoundToNearest, HARDWARE_INTRINSIC(Sve, RoundToNegativeInfinity, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_frintm, INS_sve_frintm}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) HARDWARE_INTRINSIC(Sve, RoundToPositiveInfinity, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_frintp, INS_sve_frintp}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) HARDWARE_INTRINSIC(Sve, RoundToZero, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_frintz, INS_sve_frintz}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, SaturatingDecrementBy16BitElementCount, -1, 3, {INS_invalid, INS_invalid, INS_sve_sqdech, INS_sve_uqdech, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialCodeGen|HW_Flag_HasScalarInputVariant|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) -HARDWARE_INTRINSIC(Sve, SaturatingDecrementBy32BitElementCount, -1, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqdecw, INS_sve_uqdecw, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialCodeGen|HW_Flag_HasScalarInputVariant|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) -HARDWARE_INTRINSIC(Sve, SaturatingDecrementBy64BitElementCount, -1, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqdecd, INS_sve_uqdecd, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialCodeGen|HW_Flag_HasScalarInputVariant|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) -HARDWARE_INTRINSIC(Sve, SaturatingDecrementBy8BitElementCount, 0, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqdecb, INS_sve_uqdecb, INS_sve_sqdecb, INS_sve_uqdecb, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) +HARDWARE_INTRINSIC(Sve, SaturatingDecrementBy16BitElementCount, -1, 3, {INS_invalid, INS_invalid, INS_sve_sqdech, INS_sve_uqdech, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_SpecialCodeGen|HW_Flag_HasScalarInputVariant|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) +HARDWARE_INTRINSIC(Sve, SaturatingDecrementBy32BitElementCount, -1, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqdecw, INS_sve_uqdecw, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_SpecialCodeGen|HW_Flag_HasScalarInputVariant|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) +HARDWARE_INTRINSIC(Sve, SaturatingDecrementBy64BitElementCount, -1, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqdecd, INS_sve_uqdecd, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_SpecialCodeGen|HW_Flag_HasScalarInputVariant|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) +HARDWARE_INTRINSIC(Sve, SaturatingDecrementBy8BitElementCount, 0, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqdecb, INS_sve_uqdecb, INS_sve_sqdecb, INS_sve_uqdecb, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) HARDWARE_INTRINSIC(Sve, SaturatingDecrementByActiveElementCount, -1, 2, {INS_invalid, INS_sve_sqdecp, INS_sve_sqdecp, INS_sve_sqdecp, INS_sve_sqdecp, INS_sve_sqdecp, INS_sve_sqdecp, INS_sve_sqdecp, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_BaseTypeFromSecondArg|HW_Flag_HasRMWSemantics) -HARDWARE_INTRINSIC(Sve, SaturatingIncrementBy16BitElementCount, -1, 3, {INS_invalid, INS_invalid, INS_sve_sqinch, INS_sve_uqinch, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialCodeGen|HW_Flag_HasScalarInputVariant|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) -HARDWARE_INTRINSIC(Sve, SaturatingIncrementBy32BitElementCount, -1, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqincw, INS_sve_uqincw, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialCodeGen|HW_Flag_HasScalarInputVariant|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) -HARDWARE_INTRINSIC(Sve, SaturatingIncrementBy64BitElementCount, -1, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqincd, INS_sve_uqincd, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialCodeGen|HW_Flag_HasScalarInputVariant|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) -HARDWARE_INTRINSIC(Sve, SaturatingIncrementBy8BitElementCount, 0, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqincb, INS_sve_uqincb, INS_sve_sqincb, INS_sve_uqincb, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) +HARDWARE_INTRINSIC(Sve, SaturatingIncrementBy16BitElementCount, -1, 3, {INS_invalid, INS_invalid, INS_sve_sqinch, INS_sve_uqinch, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_SpecialCodeGen|HW_Flag_HasScalarInputVariant|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) +HARDWARE_INTRINSIC(Sve, SaturatingIncrementBy32BitElementCount, -1, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqincw, INS_sve_uqincw, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_SpecialCodeGen|HW_Flag_HasScalarInputVariant|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) +HARDWARE_INTRINSIC(Sve, SaturatingIncrementBy64BitElementCount, -1, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqincd, INS_sve_uqincd, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_SpecialCodeGen|HW_Flag_HasScalarInputVariant|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) +HARDWARE_INTRINSIC(Sve, SaturatingIncrementBy8BitElementCount, 0, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqincb, INS_sve_uqincb, INS_sve_sqincb, INS_sve_uqincb, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) HARDWARE_INTRINSIC(Sve, SaturatingIncrementByActiveElementCount, -1, 2, {INS_invalid, INS_sve_sqincp, INS_sve_sqincp, INS_sve_sqincp, INS_sve_sqincp, INS_sve_sqincp, INS_sve_sqincp, INS_sve_sqincp, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_BaseTypeFromSecondArg|HW_Flag_HasRMWSemantics) HARDWARE_INTRINSIC(Sve, Scale, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_fscale, INS_sve_fscale}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_HasRMWSemantics) HARDWARE_INTRINSIC(Sve, Scatter, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_st1w, INS_sve_st1w, INS_sve_st1d, INS_sve_st1d, INS_sve_st1w, INS_sve_st1d}, HW_Category_MemoryStore, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) @@ -269,7 +280,7 @@ HARDWARE_INTRINSIC(Sve, StoreAndZip, HARDWARE_INTRINSIC(Sve, StoreNarrowing, -1, 3, {INS_sve_st1b, INS_sve_st1b, INS_sve_st1h, INS_sve_st1h, INS_sve_st1w, INS_sve_st1w, INS_sve_st1d, INS_sve_st1d, INS_invalid, INS_invalid}, HW_Category_MemoryStore, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg|HW_Flag_ExplicitMaskedOperation|HW_Flag_SpecialImport|HW_Flag_SpecialCodeGen|HW_Flag_LowMaskedOperation) HARDWARE_INTRINSIC(Sve, StoreNonTemporal, -1, 3, {INS_sve_stnt1b, INS_sve_stnt1b, INS_sve_stnt1h, INS_sve_stnt1h, INS_sve_stnt1w, INS_sve_stnt1w, INS_sve_stnt1d, INS_sve_stnt1d, INS_sve_stnt1w, INS_sve_stnt1d}, HW_Category_MemoryStore, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg|HW_Flag_ExplicitMaskedOperation|HW_Flag_SpecialCodeGen|HW_Flag_LowMaskedOperation) HARDWARE_INTRINSIC(Sve, Subtract, -1, 2, {INS_sve_sub, INS_sve_sub, INS_sve_sub, INS_sve_sub, INS_sve_sub, INS_sve_sub, INS_sve_sub, INS_sve_sub, INS_sve_fsub, INS_sve_fsub}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_OptionalEmbeddedMaskedOperation|HW_Flag_HasRMWSemantics|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, SubtractSaturate, -1, 2, {INS_sve_sqsub, INS_sve_uqsub, INS_sve_sqsub, INS_sve_uqsub, INS_sve_sqsub, INS_sve_uqsub, INS_sve_sqsub, INS_sve_uqsub, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasRMWSemantics|HW_Flag_LowMaskedOperation) +HARDWARE_INTRINSIC(Sve, SubtractSaturate, -1, 2, {INS_sve_sqsub, INS_sve_uqsub, INS_sve_sqsub, INS_sve_uqsub, INS_sve_sqsub, INS_sve_uqsub, INS_sve_sqsub, INS_sve_uqsub, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable) HARDWARE_INTRINSIC(Sve, TestAnyTrue, -1, 2, {INS_sve_ptest, INS_sve_ptest, INS_sve_ptest, INS_sve_ptest, INS_sve_ptest, INS_sve_ptest, INS_sve_ptest, INS_sve_ptest, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialCodeGen) HARDWARE_INTRINSIC(Sve, TestFirstTrue, -1, 2, {INS_sve_ptest, INS_sve_ptest, INS_sve_ptest, INS_sve_ptest, INS_sve_ptest, INS_sve_ptest, INS_sve_ptest, INS_sve_ptest, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialCodeGen) HARDWARE_INTRINSIC(Sve, TestLastTrue, -1, 2, {INS_sve_ptest, INS_sve_ptest, INS_sve_ptest, INS_sve_ptest, INS_sve_ptest, INS_sve_ptest, INS_sve_ptest, INS_sve_ptest, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialCodeGen) @@ -282,7 +293,7 @@ HARDWARE_INTRINSIC(Sve, UnzipEven, HARDWARE_INTRINSIC(Sve, UnzipOdd, -1, 2, {INS_sve_uzp2, INS_sve_uzp2, INS_sve_uzp2, INS_sve_uzp2, INS_sve_uzp2, INS_sve_uzp2, INS_sve_uzp2, INS_sve_uzp2, INS_sve_uzp2, INS_sve_uzp2}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen) HARDWARE_INTRINSIC(Sve, VectorTableLookup, -1, 2, {INS_sve_tbl, INS_sve_tbl, INS_sve_tbl, INS_sve_tbl, INS_sve_tbl, INS_sve_tbl, INS_sve_tbl, INS_sve_tbl, INS_sve_tbl, INS_sve_tbl}, HW_Category_SIMD, HW_Flag_Scalable) HARDWARE_INTRINSIC(Sve, Xor, -1, -1, {INS_sve_eor, INS_sve_eor, INS_sve_eor, INS_sve_eor, INS_sve_eor, INS_sve_eor, INS_sve_eor, INS_sve_eor, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_OptionalEmbeddedMaskedOperation|HW_Flag_HasRMWSemantics|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, XorAcross, -1, -1, {INS_sve_eorv, INS_sve_eorv, INS_sve_eorv, INS_sve_eorv, INS_sve_eorv, INS_sve_eorv, INS_sve_eorv, INS_sve_eorv, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) +HARDWARE_INTRINSIC(Sve, XorAcross, -1, -1, {INS_sve_eorv, INS_sve_eorv, INS_sve_eorv, INS_sve_eorv, INS_sve_eorv, INS_sve_eorv, INS_sve_eorv, INS_sve_eorv, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ReduceOperation) HARDWARE_INTRINSIC(Sve, ZeroExtend16, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_uxth, INS_invalid, INS_sve_uxth, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) HARDWARE_INTRINSIC(Sve, ZeroExtend32, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_uxtw, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) HARDWARE_INTRINSIC(Sve, ZeroExtend8, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_sve_uxtb, INS_invalid, INS_sve_uxtb, INS_invalid, INS_sve_uxtb, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) @@ -301,16 +312,16 @@ HARDWARE_INTRINSIC(Sve, ZipLow, #define SPECIAL_NI_Sve NI_Sve_ConditionalExtractAfterLastActiveElementScalar HARDWARE_INTRINSIC(Sve, ConditionalExtractAfterLastActiveElementScalar, 0, 3, {INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) HARDWARE_INTRINSIC(Sve, ConditionalExtractLastActiveElementScalar, 0, 3, {INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) -HARDWARE_INTRINSIC(Sve, ConvertMaskToVector, -1, 1, {INS_sve_mov, INS_sve_mov, INS_sve_mov, INS_sve_mov, INS_sve_mov, INS_sve_mov, INS_sve_mov, INS_sve_mov, INS_sve_mov, INS_sve_mov}, HW_Category_Helper, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation) -HARDWARE_INTRINSIC(Sve, ConvertVectorToMask, -1, 2, {INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne}, HW_Category_Helper, HW_Flag_Scalable|HW_Flag_ReturnsPerElementMask|HW_Flag_LowMaskedOperation) +HARDWARE_INTRINSIC(Sve, ConvertMaskToVector, -1, 1, {INS_sve_mov, INS_sve_mov, INS_sve_mov, INS_sve_mov, INS_sve_mov, INS_sve_mov, INS_sve_mov, INS_sve_mov, INS_sve_mov, INS_sve_mov}, HW_Category_Helper, HW_Flag_Scalable) +HARDWARE_INTRINSIC(Sve, ConvertVectorToMask, -1, 2, {INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne}, HW_Category_Helper, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_ReturnsPerElementMask|HW_Flag_LowMaskedOperation) HARDWARE_INTRINSIC(Sve, CreateTrueMaskAll, -1, 0, {INS_sve_ptrue, INS_sve_ptrue, INS_sve_ptrue, INS_sve_ptrue, INS_sve_ptrue, INS_sve_ptrue, INS_sve_ptrue, INS_sve_ptrue, INS_sve_ptrue, INS_sve_ptrue}, HW_Category_Helper, HW_Flag_Scalable|HW_Flag_ReturnsPerElementMask) // Scalar variants of Saturating*By*BitElementCount. There is 8bit versions as the generic version is scalar only. -HARDWARE_INTRINSIC(Sve, SaturatingDecrementBy16BitElementCountScalar, 0, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqdech, INS_sve_uqdech, INS_sve_sqdech, INS_sve_uqdech, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) -HARDWARE_INTRINSIC(Sve, SaturatingDecrementBy32BitElementCountScalar, 0, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqdecw, INS_sve_uqdecw, INS_sve_sqdecw, INS_sve_uqdecw, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) -HARDWARE_INTRINSIC(Sve, SaturatingDecrementBy64BitElementCountScalar, 0, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqdecd, INS_sve_uqdecd, INS_sve_sqdecd, INS_sve_uqdecd, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) -HARDWARE_INTRINSIC(Sve, SaturatingIncrementBy16BitElementCountScalar, 0, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqinch, INS_sve_uqinch, INS_sve_sqinch, INS_sve_uqinch, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) -HARDWARE_INTRINSIC(Sve, SaturatingIncrementBy32BitElementCountScalar, 0, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqincw, INS_sve_uqincw, INS_sve_sqincw, INS_sve_uqincw, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) -HARDWARE_INTRINSIC(Sve, SaturatingIncrementBy64BitElementCountScalar, 0, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqincd, INS_sve_uqincd, INS_sve_sqincd, INS_sve_uqincd, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) +HARDWARE_INTRINSIC(Sve, SaturatingDecrementBy16BitElementCountScalar, 0, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqdech, INS_sve_uqdech, INS_sve_sqdech, INS_sve_uqdech, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) +HARDWARE_INTRINSIC(Sve, SaturatingDecrementBy32BitElementCountScalar, 0, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqdecw, INS_sve_uqdecw, INS_sve_sqdecw, INS_sve_uqdecw, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) +HARDWARE_INTRINSIC(Sve, SaturatingDecrementBy64BitElementCountScalar, 0, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqdecd, INS_sve_uqdecd, INS_sve_sqdecd, INS_sve_uqdecd, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) +HARDWARE_INTRINSIC(Sve, SaturatingIncrementBy16BitElementCountScalar, 0, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqinch, INS_sve_uqinch, INS_sve_sqinch, INS_sve_uqinch, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) +HARDWARE_INTRINSIC(Sve, SaturatingIncrementBy32BitElementCountScalar, 0, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqincw, INS_sve_uqincw, INS_sve_sqincw, INS_sve_uqincw, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) +HARDWARE_INTRINSIC(Sve, SaturatingIncrementBy64BitElementCountScalar, 0, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqincd, INS_sve_uqincd, INS_sve_sqincd, INS_sve_uqincd, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) HARDWARE_INTRINSIC(Sve, StoreAndZipx2, -1, 3, {INS_sve_st2b, INS_sve_st2b, INS_sve_st2h, INS_sve_st2h, INS_sve_st2w, INS_sve_st2w, INS_sve_st2d, INS_sve_st2d, INS_sve_st2w, INS_sve_st2d}, HW_Category_MemoryStore, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_NeedsConsecutiveRegisters) HARDWARE_INTRINSIC(Sve, StoreAndZipx3, -1, 3, {INS_sve_st3b, INS_sve_st3b, INS_sve_st3h, INS_sve_st3h, INS_sve_st3w, INS_sve_st3w, INS_sve_st3d, INS_sve_st3d, INS_sve_st3w, INS_sve_st3d}, HW_Category_MemoryStore, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_NeedsConsecutiveRegisters) HARDWARE_INTRINSIC(Sve, StoreAndZipx4, -1, 3, {INS_sve_st4b, INS_sve_st4b, INS_sve_st4h, INS_sve_st4h, INS_sve_st4w, INS_sve_st4w, INS_sve_st4d, INS_sve_st4d, INS_sve_st4w, INS_sve_st4d}, HW_Category_MemoryStore, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_NeedsConsecutiveRegisters) diff --git a/src/coreclr/jit/hwintrinsiclistxarch.h b/src/coreclr/jit/hwintrinsiclistxarch.h index 691b8f6bd45..d44457c727c 100644 --- a/src/coreclr/jit/hwintrinsiclistxarch.h +++ b/src/coreclr/jit/hwintrinsiclistxarch.h @@ -489,8 +489,8 @@ HARDWARE_INTRINSIC(SSE_X64, ConvertToInt64WithTruncation, HARDWARE_INTRINSIC(SSE2, Add, 16, 2, {INS_paddb, INS_paddb, INS_paddw, INS_paddw, INS_paddd, INS_paddd, INS_paddq, INS_paddq, INS_invalid, INS_addpd}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(SSE2, AddSaturate, 16, 2, {INS_paddsb, INS_paddusb, INS_paddsw, INS_paddusw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(SSE2, AddScalar, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_addsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits) -HARDWARE_INTRINSIC(SSE2, And, 16, 2, {INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_invalid, INS_andpd}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) -HARDWARE_INTRINSIC(SSE2, AndNot, 16, 2, {INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_invalid, INS_andnpd}, HW_Category_SimpleSIMD, HW_Flag_SpecialImport|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) +HARDWARE_INTRINSIC(SSE2, And, 16, 2, {INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_invalid, INS_andpd}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible|HW_Flag_NormalizeSmallTypeToInt) +HARDWARE_INTRINSIC(SSE2, AndNot, 16, 2, {INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_invalid, INS_andnpd}, HW_Category_SimpleSIMD, HW_Flag_SpecialImport|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible|HW_Flag_NormalizeSmallTypeToInt) HARDWARE_INTRINSIC(SSE2, Average, 16, 2, {INS_invalid, INS_pavgb, INS_invalid, INS_pavgw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(SSE2, CompareEqual, 16, 2, {INS_pcmpeqb, INS_pcmpeqb, INS_pcmpeqw, INS_pcmpeqw, INS_pcmpeqd, INS_pcmpeqd, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_ReturnsPerElementMask|HW_Flag_NoEvexSemantics) HARDWARE_INTRINSIC(SSE2, CompareGreaterThan, 16, 2, {INS_pcmpgtb, INS_invalid, INS_pcmpgtw, INS_invalid, INS_pcmpgtd, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmppd}, HW_Category_SimpleSIMD, HW_Flag_ReturnsPerElementMask|HW_Flag_NoEvexSemantics) @@ -562,7 +562,7 @@ HARDWARE_INTRINSIC(SSE2, MultiplyAddAdjacent, HARDWARE_INTRINSIC(SSE2, MultiplyHigh, 16, 2, {INS_invalid, INS_invalid, INS_pmulhw, INS_pmulhuw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(SSE2, MultiplyLow, 16, 2, {INS_invalid, INS_invalid, INS_pmullw, INS_pmullw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(SSE2, MultiplyScalar, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_mulsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits) -HARDWARE_INTRINSIC(SSE2, Or, 16, 2, {INS_por, INS_por, INS_por, INS_por, INS_por, INS_por, INS_por, INS_por, INS_invalid, INS_orpd}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) +HARDWARE_INTRINSIC(SSE2, Or, 16, 2, {INS_por, INS_por, INS_por, INS_por, INS_por, INS_por, INS_por, INS_por, INS_invalid, INS_orpd}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible|HW_Flag_NormalizeSmallTypeToInt) HARDWARE_INTRINSIC(SSE2, PackSignedSaturate, 16, 2, {INS_packsswb, INS_invalid, INS_packssdw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(SSE2, PackUnsignedSaturate, 16, 2, {INS_invalid, INS_packuswb, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(SSE2, ShiftLeftLogical, 16, 2, {INS_invalid, INS_invalid, INS_psllw, INS_psllw, INS_pslld, INS_pslld, INS_psllq, INS_psllq, INS_invalid, INS_invalid}, HW_Category_IMM, HW_Flag_MaybeIMM|HW_Flag_NoJmpTableIMM|HW_Flag_FullRangeIMM|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) @@ -588,7 +588,7 @@ HARDWARE_INTRINSIC(SSE2, SubtractScalar, HARDWARE_INTRINSIC(SSE2, SumAbsoluteDifferences, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_psadbw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag) HARDWARE_INTRINSIC(SSE2, UnpackHigh, 16, 2, {INS_punpckhbw, INS_punpckhbw, INS_punpckhwd, INS_punpckhwd, INS_punpckhdq, INS_punpckhdq, INS_punpckhqdq, INS_punpckhqdq, INS_invalid, INS_unpckhpd}, HW_Category_SimpleSIMD, HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(SSE2, UnpackLow, 16, 2, {INS_punpcklbw, INS_punpcklbw, INS_punpcklwd, INS_punpcklwd, INS_punpckldq, INS_punpckldq, INS_punpcklqdq, INS_punpcklqdq, INS_invalid, INS_unpcklpd}, HW_Category_SimpleSIMD, HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) -HARDWARE_INTRINSIC(SSE2, Xor, 16, 2, {INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_invalid, INS_xorpd}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible|HW_Flag_CanBenefitFromConstantProp) +HARDWARE_INTRINSIC(SSE2, Xor, 16, 2, {INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_invalid, INS_xorpd}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible|HW_Flag_CanBenefitFromConstantProp|HW_Flag_NormalizeSmallTypeToInt) #define LAST_NI_SSE2 NI_SSE2_Xor // *************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************** @@ -802,8 +802,8 @@ HARDWARE_INTRINSIC(AVX2, Abs, HARDWARE_INTRINSIC(AVX2, Add, 32, 2, {INS_paddb, INS_paddb, INS_paddw, INS_paddw, INS_paddd, INS_paddd, INS_paddq, INS_paddq, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(AVX2, AddSaturate, 32, 2, {INS_paddsb, INS_paddusb, INS_paddsw, INS_paddusw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(AVX2, AlignRight, 32, 3, {INS_palignr, INS_palignr, INS_palignr, INS_palignr, INS_palignr, INS_palignr, INS_palignr, INS_palignr, INS_invalid, INS_invalid}, HW_Category_IMM, HW_Flag_FullRangeIMM|HW_Flag_EmbMaskingCompatible) -HARDWARE_INTRINSIC(AVX2, And, 32, 2, {INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) -HARDWARE_INTRINSIC(AVX2, AndNot, 32, 2, {INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_SpecialImport|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) +HARDWARE_INTRINSIC(AVX2, And, 32, 2, {INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible|HW_Flag_NormalizeSmallTypeToInt) +HARDWARE_INTRINSIC(AVX2, AndNot, 32, 2, {INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_SpecialImport|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible|HW_Flag_NormalizeSmallTypeToInt) HARDWARE_INTRINSIC(AVX2, Average, 32, 2, {INS_invalid, INS_pavgb, INS_invalid, INS_pavgw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(AVX2, Blend, -1, 3, {INS_invalid, INS_invalid, INS_pblendw, INS_pblendw, INS_vpblendd, INS_vpblendd, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_IMM, HW_Flag_FullRangeIMM|HW_Flag_NoEvexSemantics) HARDWARE_INTRINSIC(AVX2, BlendVariable, 32, 3, {INS_vpblendvb, INS_vpblendvb, INS_vpblendvb, INS_vpblendvb, INS_vpblendvb, INS_vpblendvb, INS_vpblendvb, INS_vpblendvb, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoEvexSemantics) @@ -840,7 +840,7 @@ HARDWARE_INTRINSIC(AVX2, MultiplyAddAdjacent, HARDWARE_INTRINSIC(AVX2, MultiplyHigh, 32, 2, {INS_invalid, INS_invalid, INS_pmulhw, INS_pmulhuw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(AVX2, MultiplyHighRoundScale, 32, 2, {INS_invalid, INS_invalid, INS_pmulhrsw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(AVX2, MultiplyLow, 32, 2, {INS_invalid, INS_invalid, INS_pmullw, INS_pmullw, INS_pmulld, INS_pmulld, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) -HARDWARE_INTRINSIC(AVX2, Or, 32, 2, {INS_por, INS_por, INS_por, INS_por, INS_por, INS_por, INS_por, INS_por, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) +HARDWARE_INTRINSIC(AVX2, Or, 32, 2, {INS_por, INS_por, INS_por, INS_por, INS_por, INS_por, INS_por, INS_por, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible|HW_Flag_NormalizeSmallTypeToInt) HARDWARE_INTRINSIC(AVX2, PackSignedSaturate, 32, 2, {INS_packsswb, INS_invalid, INS_packssdw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(AVX2, PackUnsignedSaturate, 32, 2, {INS_invalid, INS_packuswb, INS_invalid, INS_packusdw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(AVX2, Permute2x128, 32, 3, {INS_vperm2i128, INS_vperm2i128, INS_vperm2i128, INS_vperm2i128, INS_vperm2i128, INS_vperm2i128, INS_vperm2i128, INS_vperm2i128, INS_invalid, INS_invalid}, HW_Category_IMM, HW_Flag_FullRangeIMM|HW_Flag_NoEvexSemantics) @@ -863,7 +863,7 @@ HARDWARE_INTRINSIC(AVX2, SubtractSaturate, HARDWARE_INTRINSIC(AVX2, SumAbsoluteDifferences, 32, 2, {INS_invalid, INS_invalid, INS_invalid, INS_psadbw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag) HARDWARE_INTRINSIC(AVX2, UnpackHigh, 32, 2, {INS_punpckhbw, INS_punpckhbw, INS_punpckhwd, INS_punpckhwd, INS_punpckhdq, INS_punpckhdq, INS_punpckhqdq, INS_punpckhqdq, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(AVX2, UnpackLow, 32, 2, {INS_punpcklbw, INS_punpcklbw, INS_punpcklwd, INS_punpcklwd, INS_punpckldq, INS_punpckldq, INS_punpcklqdq, INS_punpcklqdq, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) -HARDWARE_INTRINSIC(AVX2, Xor, 32, 2, {INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible|HW_Flag_CanBenefitFromConstantProp) +HARDWARE_INTRINSIC(AVX2, Xor, 32, 2, {INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible|HW_Flag_CanBenefitFromConstantProp|HW_Flag_NormalizeSmallTypeToInt) #define LAST_NI_AVX2 NI_AVX2_Xor // *************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************** @@ -877,8 +877,8 @@ HARDWARE_INTRINSIC(AVX512F, Add, HARDWARE_INTRINSIC(AVX512F, AddScalar, 16, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_addss, INS_addsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits|HW_Flag_EmbRoundingCompatible) HARDWARE_INTRINSIC(AVX512F, AlignRight32, 64, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_valignd, INS_valignd, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_IMM, HW_Flag_FullRangeIMM|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(AVX512F, AlignRight64, 64, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_valignq, INS_valignq, INS_invalid, INS_invalid}, HW_Category_IMM, HW_Flag_FullRangeIMM|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) -HARDWARE_INTRINSIC(AVX512F, And, 64, 2, {INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_vpandq, INS_vpandq, INS_andps, INS_andpd}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) -HARDWARE_INTRINSIC(AVX512F, AndNot, 64, 2, {INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_vpandnq, INS_vpandnq, INS_andnps, INS_andnpd}, HW_Category_SimpleSIMD, HW_Flag_SpecialImport|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) +HARDWARE_INTRINSIC(AVX512F, And, 64, 2, {INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_pand, INS_vpandq, INS_vpandq, INS_andps, INS_andpd}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible|HW_Flag_NormalizeSmallTypeToInt) +HARDWARE_INTRINSIC(AVX512F, AndNot, 64, 2, {INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_pandn, INS_vpandnq, INS_vpandnq, INS_andnps, INS_andnpd}, HW_Category_SimpleSIMD, HW_Flag_SpecialImport|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible|HW_Flag_NormalizeSmallTypeToInt) HARDWARE_INTRINSIC(AVX512F, BlendVariable, 64, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_InvalidNodeId) HARDWARE_INTRINSIC(AVX512F, BroadcastScalarToVector512, 64, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vpbroadcastd, INS_vpbroadcastd, INS_vpbroadcastq, INS_vpbroadcastq, INS_vbroadcastss, INS_vbroadcastsd}, HW_Category_SIMDScalar, HW_Flag_NoFlag) HARDWARE_INTRINSIC(AVX512F, BroadcastVector128ToVector512, 64, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vbroadcasti128, INS_vbroadcasti128, INS_invalid, INS_invalid, INS_vbroadcastf128, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_MaybeMemoryLoad) @@ -933,7 +933,7 @@ HARDWARE_INTRINSIC(AVX512F, DivideScalar, HARDWARE_INTRINSIC(AVX512F, DuplicateEvenIndexed, 64, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_movsldup, INS_movddup}, HW_Category_SimpleSIMD, HW_Flag_NoFlag) HARDWARE_INTRINSIC(AVX512F, DuplicateOddIndexed, 64, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_movshdup, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_NoFlag) HARDWARE_INTRINSIC(AVX512F, ExtractVector128, 64, 2, {INS_vextracti128, INS_vextracti128, INS_vextracti128, INS_vextracti128, INS_vextracti128, INS_vextracti128, INS_vextracti128, INS_vextracti128, INS_vextractf128, INS_vextractf128}, HW_Category_IMM, HW_Flag_FullRangeIMM|HW_Flag_EmbMaskingCompatible) -HARDWARE_INTRINSIC(AVX512F, ExtractVector256, 64, 2, {INS_vextracti64x4, INS_vextracti64x4, INS_vextracti64x4, INS_vextracti64x4, INS_vextracti64x4, INS_vextracti64x4, INS_vextracti64x4, INS_vextracti64x4, INS_vextractf64x4, INS_vextractf64x4}, HW_Category_IMM, HW_Flag_FullRangeIMM|HW_Flag_EmbMaskingCompatible) +HARDWARE_INTRINSIC(AVX512F, ExtractVector256, 64, 2, {INS_vextracti32x8, INS_vextracti32x8, INS_vextracti32x8, INS_vextracti32x8, INS_vextracti32x8, INS_vextracti32x8, INS_vextracti64x4, INS_vextracti64x4, INS_vextractf64x4, INS_vextractf64x4}, HW_Category_IMM, HW_Flag_FullRangeIMM|HW_Flag_EmbMaskingCompatible|HW_Flag_NormalizeSmallTypeToInt) HARDWARE_INTRINSIC(AVX512F, Fixup, 64, 4, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vfixupimmps, INS_vfixupimmpd}, HW_Category_IMM, HW_Flag_SpecialImport|HW_Flag_FullRangeIMM|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(AVX512F, FixupScalar, 16, 4, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vfixupimmss, INS_vfixupimmsd}, HW_Category_IMM, HW_Flag_SpecialImport|HW_Flag_FullRangeIMM|HW_Flag_CopyUpperBits) HARDWARE_INTRINSIC(AVX512F, FusedMultiplyAdd, 64, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vfmadd213ps, INS_vfmadd213pd}, HW_Category_SimpleSIMD, HW_Flag_SpecialCodeGen|HW_Flag_FmaIntrinsic|HW_Flag_RmwIntrinsic|HW_Flag_EmbRoundingCompatible|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) @@ -951,7 +951,7 @@ HARDWARE_INTRINSIC(AVX512F, GetExponentScalar, HARDWARE_INTRINSIC(AVX512F, GetMantissa, 64, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vgetmantps, INS_vgetmantpd}, HW_Category_IMM, HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(AVX512F, GetMantissaScalar, 16, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vgetmantss, INS_vgetmantsd}, HW_Category_IMM, HW_Flag_CopyUpperBits) HARDWARE_INTRINSIC(AVX512F, InsertVector128, 64, 3, {INS_vinserti128, INS_vinserti128, INS_vinserti128, INS_vinserti128, INS_vinserti128, INS_vinserti128, INS_vinserti128, INS_vinserti128, INS_vinsertf128, INS_vinsertf128}, HW_Category_IMM, HW_Flag_FullRangeIMM|HW_Flag_EmbMaskingCompatible) -HARDWARE_INTRINSIC(AVX512F, InsertVector256, 64, 3, {INS_vinserti64x4, INS_vinserti64x4, INS_vinserti64x4, INS_vinserti64x4, INS_vinserti64x4, INS_vinserti64x4, INS_vinserti64x4, INS_vinserti64x4, INS_vinsertf64x4, INS_vinsertf64x4}, HW_Category_IMM, HW_Flag_FullRangeIMM|HW_Flag_EmbMaskingCompatible) +HARDWARE_INTRINSIC(AVX512F, InsertVector256, 64, 3, {INS_vinserti32x8, INS_vinserti32x8, INS_vinserti32x8, INS_vinserti32x8, INS_vinserti32x8, INS_vinserti32x8, INS_vinserti64x4, INS_vinserti64x4, INS_vinsertf64x4, INS_vinsertf64x4}, HW_Category_IMM, HW_Flag_FullRangeIMM|HW_Flag_EmbMaskingCompatible|HW_Flag_NormalizeSmallTypeToInt) HARDWARE_INTRINSIC(AVX512F, LoadAlignedVector512, 64, 1, {INS_movdqa, INS_movdqa, INS_movdqa, INS_movdqa, INS_movdqa, INS_movdqa, INS_vmovdqa64, INS_vmovdqa64, INS_movaps, INS_movapd}, HW_Category_MemoryLoad, HW_Flag_NoFlag) HARDWARE_INTRINSIC(AVX512F, LoadAlignedVector512NonTemporal, 64, 1, {INS_movntdqa, INS_movntdqa, INS_movntdqa, INS_movntdqa, INS_movntdqa, INS_movntdqa, INS_movntdqa, INS_movntdqa, INS_invalid, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_NoFlag) HARDWARE_INTRINSIC(AVX512F, LoadVector512, 64, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Helper, HW_Flag_InvalidNodeId) @@ -960,7 +960,7 @@ HARDWARE_INTRINSIC(AVX512F, Min, HARDWARE_INTRINSIC(AVX512F, Multiply, 64, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_pmuldq, INS_pmuludq, INS_mulps, INS_mulpd}, HW_Category_SimpleSIMD, HW_Flag_MaybeCommutative|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible|HW_Flag_EmbRoundingCompatible) HARDWARE_INTRINSIC(AVX512F, MultiplyLow, 64, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_pmulld, INS_pmulld, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(AVX512F, MultiplyScalar, 16, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_mulss, INS_mulsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits|HW_Flag_EmbRoundingCompatible) -HARDWARE_INTRINSIC(AVX512F, Or, 64, 2, {INS_por, INS_por, INS_por, INS_por, INS_por, INS_por, INS_vporq, INS_vporq, INS_orps, INS_orpd}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) +HARDWARE_INTRINSIC(AVX512F, Or, 64, 2, {INS_por, INS_por, INS_por, INS_por, INS_por, INS_por, INS_vporq, INS_vporq, INS_orps, INS_orpd}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible|HW_Flag_NormalizeSmallTypeToInt) HARDWARE_INTRINSIC(AVX512F, Permute2x64, 64, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vpermilpd}, HW_Category_IMM, HW_Flag_FullRangeIMM|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(AVX512F, Permute4x32, 64, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vpermilps, INS_invalid}, HW_Category_IMM, HW_Flag_FullRangeIMM|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(AVX512F, Permute4x64, 64, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vpermq, INS_vpermq, INS_invalid, INS_vpermpd}, HW_Category_IMM, HW_Flag_FullRangeIMM|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) @@ -997,10 +997,10 @@ HARDWARE_INTRINSIC(AVX512F, StoreAligned, HARDWARE_INTRINSIC(AVX512F, StoreAlignedNonTemporal, 64, 2, {INS_movntdq, INS_movntdq, INS_movntdq, INS_movntdq, INS_movntdq, INS_movntdq, INS_movntdq, INS_movntdq, INS_movntps, INS_movntpd}, HW_Category_MemoryStore, HW_Flag_BaseTypeFromSecondArg) HARDWARE_INTRINSIC(AVX512F, Subtract, 64, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_psubd, INS_psubd, INS_psubq, INS_psubq, INS_subps, INS_subpd}, HW_Category_SimpleSIMD, HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible|HW_Flag_EmbRoundingCompatible) HARDWARE_INTRINSIC(AVX512F, SubtractScalar, 16, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_subss, INS_subsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits|HW_Flag_EmbRoundingCompatible) -HARDWARE_INTRINSIC(AVX512F, TernaryLogic, 64, 4, {INS_vpternlogd, INS_vpternlogd, INS_vpternlogd, INS_vpternlogd, INS_vpternlogd, INS_vpternlogd, INS_vpternlogq, INS_vpternlogq, INS_vpternlogd, INS_vpternlogq}, HW_Category_IMM, HW_Flag_SpecialImport|HW_Flag_FullRangeIMM|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) +HARDWARE_INTRINSIC(AVX512F, TernaryLogic, 64, 4, {INS_vpternlogd, INS_vpternlogd, INS_vpternlogd, INS_vpternlogd, INS_vpternlogd, INS_vpternlogd, INS_vpternlogq, INS_vpternlogq, INS_vpternlogd, INS_vpternlogq}, HW_Category_IMM, HW_Flag_SpecialImport|HW_Flag_FullRangeIMM|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible|HW_Flag_NormalizeSmallTypeToInt) HARDWARE_INTRINSIC(AVX512F, UnpackHigh, 64, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_punpckhdq, INS_punpckhdq, INS_punpckhqdq, INS_punpckhqdq, INS_unpckhps, INS_unpckhpd}, HW_Category_SimpleSIMD, HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(AVX512F, UnpackLow, 64, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_punpckldq, INS_punpckldq, INS_punpcklqdq, INS_punpcklqdq, INS_unpcklps, INS_unpcklpd}, HW_Category_SimpleSIMD, HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) -HARDWARE_INTRINSIC(AVX512F, Xor, 64, 2, {INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_vpxorq, INS_vpxorq, INS_xorps, INS_xorpd}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible|HW_Flag_CanBenefitFromConstantProp) +HARDWARE_INTRINSIC(AVX512F, Xor, 64, 2, {INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_pxor, INS_vpxorq, INS_vpxorq, INS_xorps, INS_xorpd}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible|HW_Flag_CanBenefitFromConstantProp|HW_Flag_NormalizeSmallTypeToInt) #define LAST_NI_AVX512F NI_AVX512F_Xor // *************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************** @@ -1057,7 +1057,7 @@ HARDWARE_INTRINSIC(AVX512F_VL, Scale, HARDWARE_INTRINSIC(AVX512F_VL, ShiftRightArithmetic, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vpsraq, INS_invalid, INS_invalid, INS_invalid}, HW_Category_IMM, HW_Flag_MaybeIMM|HW_Flag_NoJmpTableIMM|HW_Flag_FullRangeIMM|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(AVX512F_VL, ShiftRightArithmeticVariable, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vpsravq, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) HARDWARE_INTRINSIC(AVX512F_VL, Shuffle2x128, 32, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vshufi32x4, INS_vshufi32x4, INS_vshufi64x2, INS_vshufi64x2, INS_vshuff32x4, INS_vshuff64x2}, HW_Category_IMM, HW_Flag_FullRangeIMM|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) -HARDWARE_INTRINSIC(AVX512F_VL, TernaryLogic, -1, 4, {INS_vpternlogd, INS_vpternlogd, INS_vpternlogd, INS_vpternlogd, INS_vpternlogd, INS_vpternlogd, INS_vpternlogq, INS_vpternlogq, INS_vpternlogd, INS_vpternlogq}, HW_Category_IMM, HW_Flag_SpecialImport|HW_Flag_FullRangeIMM|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) +HARDWARE_INTRINSIC(AVX512F_VL, TernaryLogic, -1, 4, {INS_vpternlogd, INS_vpternlogd, INS_vpternlogd, INS_vpternlogd, INS_vpternlogd, INS_vpternlogd, INS_vpternlogq, INS_vpternlogq, INS_vpternlogd, INS_vpternlogq}, HW_Category_IMM, HW_Flag_SpecialImport|HW_Flag_FullRangeIMM|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible|HW_Flag_NormalizeSmallTypeToInt) #define LAST_NI_AVX512F_VL NI_AVX512F_VL_TernaryLogic // *************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************** @@ -1356,7 +1356,7 @@ HARDWARE_INTRINSIC(AVX10v1, Shuffle2x128, HARDWARE_INTRINSIC(AVX10v1, SqrtScalar, 16, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sqrtss, INS_sqrtsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits|HW_Flag_EmbRoundingCompatible) HARDWARE_INTRINSIC(AVX10v1, SubtractScalar, 16, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_subss, INS_subsd}, HW_Category_SIMDScalar, HW_Flag_CopyUpperBits|HW_Flag_EmbRoundingCompatible) HARDWARE_INTRINSIC(AVX10v1, SumAbsoluteDifferencesInBlock32, -1, 3, {INS_invalid, INS_invalid, INS_invalid, INS_vdbpsadbw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_IMM, HW_Flag_FullRangeIMM|HW_Flag_EmbMaskingCompatible) -HARDWARE_INTRINSIC(AVX10v1, TernaryLogic, -1, 4, {INS_vpternlogd, INS_vpternlogd, INS_vpternlogd, INS_vpternlogd, INS_vpternlogd, INS_vpternlogd, INS_vpternlogq, INS_vpternlogq, INS_vpternlogd, INS_vpternlogq}, HW_Category_IMM, HW_Flag_SpecialImport|HW_Flag_FullRangeIMM|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible) +HARDWARE_INTRINSIC(AVX10v1, TernaryLogic, -1, 4, {INS_vpternlogd, INS_vpternlogd, INS_vpternlogd, INS_vpternlogd, INS_vpternlogd, INS_vpternlogd, INS_vpternlogq, INS_vpternlogq, INS_vpternlogd, INS_vpternlogq}, HW_Category_IMM, HW_Flag_SpecialImport|HW_Flag_FullRangeIMM|HW_Flag_EmbBroadcastCompatible|HW_Flag_EmbMaskingCompatible|HW_Flag_NormalizeSmallTypeToInt) #define LAST_NI_AVX10v1 NI_AVX10v1_TernaryLogic // *************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************** @@ -1464,7 +1464,7 @@ HARDWARE_INTRINSIC(BMI1_X64, TrailingZeroCount, // *************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************** // BMI2 Intrinsics #define FIRST_NI_BMI2 NI_BMI2_MultiplyNoFlags -HARDWARE_INTRINSIC(BMI2, MultiplyNoFlags, 0, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_mulx, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_NoContainment|HW_Flag_MaybeMemoryStore|HW_Flag_SpecialCodeGen|HW_Flag_NoFloatingPointUsed|HW_Flag_NoEvexSemantics) +HARDWARE_INTRINSIC(BMI2, MultiplyNoFlags, 0, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_mulx, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_NoContainment|HW_Flag_MaybeMemoryStore|HW_Flag_SpecialCodeGen|HW_Flag_NoFloatingPointUsed|HW_Flag_NoEvexSemantics|HW_Flag_MaybeCommutative) HARDWARE_INTRINSIC(BMI2, ParallelBitDeposit, 0, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_pdep, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_NoFloatingPointUsed|HW_Flag_NoEvexSemantics) HARDWARE_INTRINSIC(BMI2, ParallelBitExtract, 0, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_pext, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_NoFloatingPointUsed|HW_Flag_NoEvexSemantics) HARDWARE_INTRINSIC(BMI2, ZeroHighBits, 0, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_bzhi, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_NoFloatingPointUsed|HW_Flag_SpecialImport|HW_Flag_NoEvexSemantics) @@ -1476,7 +1476,7 @@ HARDWARE_INTRINSIC(BMI2, ZeroHighBits, // *************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************** // BMI2 Intrinsics #define FIRST_NI_BMI2_X64 NI_BMI2_X64_MultiplyNoFlags -HARDWARE_INTRINSIC(BMI2_X64, MultiplyNoFlags, 0, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_mulx, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_NoContainment|HW_Flag_MaybeMemoryStore|HW_Flag_SpecialCodeGen|HW_Flag_NoFloatingPointUsed|HW_Flag_NoEvexSemantics) +HARDWARE_INTRINSIC(BMI2_X64, MultiplyNoFlags, 0, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_mulx, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_NoContainment|HW_Flag_MaybeMemoryStore|HW_Flag_SpecialCodeGen|HW_Flag_NoFloatingPointUsed|HW_Flag_NoEvexSemantics|HW_Flag_MaybeCommutative) HARDWARE_INTRINSIC(BMI2_X64, ParallelBitDeposit, 0, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_pdep, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_NoFloatingPointUsed|HW_Flag_NoEvexSemantics) HARDWARE_INTRINSIC(BMI2_X64, ParallelBitExtract, 0, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_pext, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_NoFloatingPointUsed|HW_Flag_NoEvexSemantics) HARDWARE_INTRINSIC(BMI2_X64, ZeroHighBits, 0, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_bzhi, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_NoFloatingPointUsed|HW_Flag_SpecialImport|HW_Flag_NoEvexSemantics) @@ -1567,12 +1567,12 @@ HARDWARE_INTRINSIC(SSE41, PTEST, HARDWARE_INTRINSIC(AVX, PTEST, 0, 2, {INS_ptest, INS_ptest, INS_ptest, INS_ptest, INS_ptest, INS_ptest, INS_ptest, INS_ptest, INS_vtestps, INS_vtestpd}, HW_Category_SimpleSIMD, HW_Flag_NoEvexSemantics) HARDWARE_INTRINSIC(EVEX, KORTEST, 0, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_NoContainment) HARDWARE_INTRINSIC(EVEX, KTEST, 0, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_NoContainment) -HARDWARE_INTRINSIC(EVEX, PTESTM, 0, 2, {INS_vptestmb, INS_vptestmb, INS_vptestmw, INS_vptestmw, INS_vptestmd, INS_vptestmd, INS_vptestmq, INS_vptestmq, INS_vptestmd, INS_vptestmq}, HW_Category_SimpleSIMD, HW_Flag_EmbBroadcastCompatible) -HARDWARE_INTRINSIC(EVEX, PTESTNM, 0, 2, {INS_vptestnmb, INS_vptestnmb, INS_vptestnmw, INS_vptestnmw, INS_vptestnmd, INS_vptestnmd, INS_vptestnmq, INS_vptestnmq, INS_vptestnmd, INS_vptestnmq}, HW_Category_SimpleSIMD, HW_Flag_EmbBroadcastCompatible) +HARDWARE_INTRINSIC(EVEX, PTESTM, 0, 2, {INS_vptestmb, INS_vptestmb, INS_vptestmw, INS_vptestmw, INS_vptestmd, INS_vptestmd, INS_vptestmq, INS_vptestmq, INS_vptestmd, INS_vptestmq}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbBroadcastCompatible) +HARDWARE_INTRINSIC(EVEX, PTESTNM, 0, 2, {INS_vptestnmb, INS_vptestnmb, INS_vptestnmw, INS_vptestnmw, INS_vptestnmd, INS_vptestnmd, INS_vptestnmq, INS_vptestnmq, INS_vptestnmd, INS_vptestnmq}, HW_Category_SimpleSIMD, HW_Flag_Commutative|HW_Flag_EmbBroadcastCompatible) HARDWARE_INTRINSIC(EVEX, AddMask, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_NoContainment|HW_Flag_Commutative|HW_Flag_ReturnsPerElementMask) HARDWARE_INTRINSIC(EVEX, AndMask, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_NoContainment|HW_Flag_Commutative|HW_Flag_ReturnsPerElementMask) -HARDWARE_INTRINSIC(EVEX, AndNotMask, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_NoContainment|HW_Flag_Commutative|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(EVEX, AndNotMask, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_Special, HW_Flag_NoContainment|HW_Flag_ReturnsPerElementMask) HARDWARE_INTRINSIC(EVEX, BlendVariableMask, -1, 3, {INS_vpblendmb, INS_vpblendmb, INS_vpblendmw, INS_vpblendmw, INS_vpblendmd, INS_vpblendmd, INS_vpblendmq, INS_vpblendmq, INS_vblendmps, INS_vblendmpd}, HW_Category_SimpleSIMD, HW_Flag_EmbBroadcastCompatible) HARDWARE_INTRINSIC(EVEX, CompareMask, -1, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vcmpps, INS_vcmppd}, HW_Category_IMM, HW_Flag_ReturnsPerElementMask|HW_Flag_EmbBroadcastCompatible) HARDWARE_INTRINSIC(EVEX, CompareEqualMask, -1, 2, {INS_vpcmpeqb, INS_vpcmpeqb, INS_vpcmpeqw, INS_vpcmpeqw, INS_vpcmpeqd, INS_vpcmpeqd, INS_vpcmpeqq, INS_vpcmpeqq, INS_vcmpps, INS_vcmppd}, HW_Category_SimpleSIMD, HW_Flag_ReturnsPerElementMask|HW_Flag_EmbBroadcastCompatible|HW_Flag_Commutative|HW_Flag_CanBenefitFromConstantProp) diff --git a/src/coreclr/jit/hwintrinsicxarch.cpp b/src/coreclr/jit/hwintrinsicxarch.cpp index 1a016f60fbe..07cdba3ae64 100644 --- a/src/coreclr/jit/hwintrinsicxarch.cpp +++ b/src/coreclr/jit/hwintrinsicxarch.cpp @@ -2338,16 +2338,19 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, } } - if (varTypeIsLong(simdBaseType) && !impStackTop(0).val->OperIsConst()) + if (varTypeIsLong(simdBaseType)) { - // When op2 is a constant, we can skip the multiplication allowing us to always - // generate better code. However, if it isn't then we need to fallback in the - // cases where multiplication isn't supported. - - if ((simdSize != 64) && !canUseEvexEncoding()) + if (!impStackTop(0).val->OperIsConst()) { - // TODO-XARCH-CQ: We should support long/ulong multiplication - break; + // When op2 is a constant, we can skip the multiplication allowing us to always + // generate better code. However, if it isn't then we need to fallback in the + // cases where multiplication isn't supported. + + if ((simdSize != 64) && !canUseEvexEncoding()) + { + // TODO-XARCH-CQ: We should support long/ulong multiplication + break; + } } #if defined(TARGET_X86) @@ -4800,7 +4803,7 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, int immUpperBound = HWIntrinsicInfo::lookupImmUpperBound(intrinsic); op3 = impPopStack().val; - op3 = addRangeCheckIfNeeded(intrinsic, op3, mustExpand, immLowerBound, immUpperBound); + op3 = addRangeCheckIfNeeded(intrinsic, op3, immLowerBound, immUpperBound); op2 = impSIMDPopStack(); op1 = impSIMDPopStack(); diff --git a/src/coreclr/jit/importer.cpp b/src/coreclr/jit/importer.cpp index 8614acef082..cb26c978a24 100644 --- a/src/coreclr/jit/importer.cpp +++ b/src/coreclr/jit/importer.cpp @@ -20,16 +20,6 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX #include "corexcep.h" -/*****************************************************************************/ - -void Compiler::impInit() -{ - impStmtList = impLastStmt = nullptr; -#ifdef DEBUG - impInlinedCodeSize = 0; -#endif // DEBUG -} - /***************************************************************************** * * Pushes the given tree on the stack. @@ -6249,17 +6239,36 @@ void Compiler::impImportBlockCode(BasicBlock* block) // // Note unlike OSR, it's ok to forgo these. // - // Todo: stress mode... - // if (opts.jitFlags->IsSet(JitFlags::JIT_FLAG_TIER0) && (JitConfig.TC_PartialCompilation() > 0) && - compCanHavePatchpoints() && !compTailPrefixSeen) + compCanHavePatchpoints() && !compTailPrefixSeen && (verCurrentState.esStackDepth == 0) && + !block->HasFlag(BBF_PATCHPOINT) && !block->hasHndIndex()) { // Is this block a good place for partial compilation? // - if ((block != fgFirstBB) && block->isRunRarely() && (verCurrentState.esStackDepth == 0) && - !block->HasFlag(BBF_PATCHPOINT) && !block->hasHndIndex()) + bool addPartialCompilationPatchpoint = (block != fgFirstBB) && block->isRunRarely(); + +#ifdef DEBUG + // Stress mode + // + const char* reason = "rarely run"; + const int randomPartialCompilation = JitConfig.JitRandomPartialCompilation(); + if (randomPartialCompilation > 0) { - JITDUMP("\nBlock " FMT_BB " will be a partial compilation patchpoint -- not importing\n", block->bbNum); + // Reuse the random inliner's random state. + // Note m_inlineStrategy is always created, even if we're not inlining. + // + CLRRandom* const random = impInlineRoot()->m_inlineStrategy->GetRandom(randomPartialCompilation); + const int randomValue = (int)random->Next(100); + + addPartialCompilationPatchpoint = (randomValue < randomPartialCompilation); + reason = "randomly chosen"; + } +#endif + + if (addPartialCompilationPatchpoint) + { + JITDUMP("\nBlock " FMT_BB " (%s) will be a partial compilation patchpoint -- not importing\n", block->bbNum, + reason); block->SetFlags(BBF_PARTIAL_COMPILATION_PATCHPOINT); setMethodHasPartialCompilationPatchpoint(); @@ -7080,7 +7089,7 @@ void Compiler::impImportBlockCode(BasicBlock* block) lclTyp = JITtype2varType(info.compCompHnd->asCorInfoType(ldelemClsHnd)); // If it's a value class / pointer array, or a readonly access, we don't need a type check. - // TODO-CQ: adapt "impCanSkipCovariantStoreCheck" to handle "ldelema"s and call it here to + // TODO-CQ: adapt "gtCanSkipCovariantStoreCheck" to handle "ldelema"s and call it here to // skip using the helper in more cases. if ((lclTyp != TYP_REF) || ((prefixFlags & PREFIX_READONLY) != 0)) { @@ -7219,7 +7228,7 @@ void Compiler::impImportBlockCode(BasicBlock* block) if (opts.OptimizationEnabled()) { // Is this a case where we can skip the covariant store check? - if (impCanSkipCovariantStoreCheck(value, array)) + if (gtCanSkipCovariantStoreCheck(value, array)) { lclTyp = TYP_REF; goto ARR_ST; @@ -13914,116 +13923,3 @@ methodPointerInfo* Compiler::impAllocateMethodPointerInfo(const CORINFO_RESOLVED memory->m_tokenConstraint = tokenConstrained; return memory; } - -//------------------------------------------------------------------------ -// impCanSkipCovariantStoreCheck: see if storing a ref type value to an array -// can skip the array store covariance check. -// -// Arguments: -// value -- tree producing the value to store -// array -- tree representing the array to store to -// -// Returns: -// true if the store does not require a covariance check. -// -bool Compiler::impCanSkipCovariantStoreCheck(GenTree* value, GenTree* array) -{ - // We should only call this when optimizing. - assert(opts.OptimizationEnabled()); - - // Check for store to same array, ie. arrLcl[i] = arrLcl[j] - if (value->OperIs(GT_IND) && value->AsIndir()->Addr()->OperIs(GT_INDEX_ADDR) && array->OperIs(GT_LCL_VAR)) - { - GenTree* valueArray = value->AsIndir()->Addr()->AsIndexAddr()->Arr(); - if (valueArray->OperIs(GT_LCL_VAR)) - { - unsigned valueArrayLcl = valueArray->AsLclVar()->GetLclNum(); - unsigned arrayLcl = array->AsLclVar()->GetLclNum(); - if ((valueArrayLcl == arrayLcl) && !lvaGetDesc(arrayLcl)->IsAddressExposed()) - { - JITDUMP("\nstelem of ref from same array: skipping covariant store check\n"); - return true; - } - } - } - - // Check for store of NULL. - if (value->OperIs(GT_CNS_INT)) - { - assert(value->gtType == TYP_REF); - if (value->AsIntCon()->gtIconVal == 0) - { - JITDUMP("\nstelem of null: skipping covariant store check\n"); - return true; - } - // Non-0 const refs can only occur with frozen objects - assert(value->IsIconHandle(GTF_ICON_OBJ_HDL)); - assert(doesMethodHaveFrozenObjects() || - (compIsForInlining() && impInlineInfo->InlinerCompiler->doesMethodHaveFrozenObjects())); - } - - // Try and get a class handle for the array - if (value->gtType != TYP_REF) - { - return false; - } - - bool arrayIsExact = false; - bool arrayIsNonNull = false; - CORINFO_CLASS_HANDLE arrayHandle = gtGetClassHandle(array, &arrayIsExact, &arrayIsNonNull); - - if (arrayHandle == NO_CLASS_HANDLE) - { - return false; - } - - // There are some methods in corelib where we're storing to an array but the IL - // doesn't reflect this (see SZArrayHelper). Avoid. - DWORD attribs = info.compCompHnd->getClassAttribs(arrayHandle); - if ((attribs & CORINFO_FLG_ARRAY) == 0) - { - return false; - } - - CORINFO_CLASS_HANDLE arrayElementHandle = nullptr; - CorInfoType arrayElemType = info.compCompHnd->getChildType(arrayHandle, &arrayElementHandle); - - // Verify array type handle is really an array of ref type - assert(arrayElemType == CORINFO_TYPE_CLASS); - - // Check for exactly object[] - if (arrayIsExact && (arrayElementHandle == impGetObjectClass())) - { - JITDUMP("\nstelem to (exact) object[]: skipping covariant store check\n"); - return true; - } - - const bool arrayTypeIsSealed = info.compCompHnd->isExactType(arrayElementHandle); - - if ((!arrayIsExact && !arrayTypeIsSealed) || (arrayElementHandle == NO_CLASS_HANDLE)) - { - // Bail out if we don't know array's exact type - return false; - } - - bool valueIsExact = false; - bool valueIsNonNull = false; - CORINFO_CLASS_HANDLE valueHandle = gtGetClassHandle(value, &valueIsExact, &valueIsNonNull); - - // Array's type is sealed and equals to value's type - if (arrayTypeIsSealed && (valueHandle == arrayElementHandle)) - { - JITDUMP("\nstelem to T[] with T exact: skipping covariant store check\n"); - return true; - } - - // Array's type is not sealed but we know its exact type - if (arrayIsExact && (valueHandle != NO_CLASS_HANDLE) && - (info.compCompHnd->compareTypesForCast(valueHandle, arrayElementHandle) == TypeCompareState::Must)) - { - JITDUMP("\nstelem to T[] with T exact: skipping covariant store check\n"); - return true; - } - - return false; -} diff --git a/src/coreclr/jit/importercalls.cpp b/src/coreclr/jit/importercalls.cpp index c95084bf1d4..324a9ce1f93 100644 --- a/src/coreclr/jit/importercalls.cpp +++ b/src/coreclr/jit/importercalls.cpp @@ -2054,9 +2054,7 @@ void Compiler::impPopArgsForUnmanagedCall(GenTreeCall* call, CORINFO_SIG_INFO* s // call - The call // // Remarks: -// This makes use of the fact that TYP_I_IMPL <-> TYP_BYREF casts are -// implicit in JIT IR, allowing us to change the types directly without -// inserting a cast node. +// Make the "casting away" of GC explicit here instead of retyping. // void Compiler::impRetypeUnmanagedCallArgs(GenTreeCall* call) { @@ -2067,7 +2065,7 @@ void Compiler::impRetypeUnmanagedCallArgs(GenTreeCall* call) // We should not be passing gc typed args to an unmanaged call. if (varTypeIsGC(argNode->TypeGet())) { - // Tolerate byrefs by retyping to native int. + // Tolerate byrefs by casting to native int. // // This is needed or we'll generate inconsistent GC info // for this arg at the call site (gc info says byref, @@ -2075,7 +2073,8 @@ void Compiler::impRetypeUnmanagedCallArgs(GenTreeCall* call) // if (argNode->TypeGet() == TYP_BYREF) { - argNode->ChangeType(TYP_I_IMPL); + GenTree* cast = gtNewCastNode(TYP_I_IMPL, argNode, false, TYP_I_IMPL); + arg.SetEarlyNode(cast); } else { @@ -2916,12 +2915,9 @@ GenTree* Compiler::impCreateSpanIntrinsic(CORINFO_SIG_INFO* sig) return nullptr; } - CORINFO_CLASS_HANDLE fieldOwnerHnd = info.compCompHnd->getFieldClass(fieldToken); - CORINFO_CLASS_HANDLE fieldClsHnd; - var_types fieldElementType = - JITtype2varType(info.compCompHnd->getFieldType(fieldToken, &fieldClsHnd, fieldOwnerHnd)); - unsigned totalFieldSize; + var_types fieldElementType = JITtype2varType(info.compCompHnd->getFieldType(fieldToken, &fieldClsHnd)); + unsigned totalFieldSize; // Most static initialization data fields are of some structure, but it is possible for them to be of various // primitive types as well @@ -3569,6 +3565,12 @@ GenTree* Compiler::impIntrinsic(CORINFO_CLASS_HANDLE clsHnd, break; } + case NI_System_Runtime_CompilerServices_RuntimeHelpers_GetMethodTable: + { + retNode = gtNewMethodTableLookup(impPopStack().val); + break; + } + case NI_System_Runtime_InteropService_MemoryMarshal_GetArrayDataReference: { assert(sig->numArgs == 1); @@ -6195,6 +6197,18 @@ void Compiler::impPopCallArgs(CORINFO_SIG_INFO* sig, GenTreeCall* call) argNode = impImplicitR4orR8Cast(argNode, jitSigType); // insert any widening or narrowing casts for backwards compatibility argNode = impImplicitIorI4Cast(argNode, jitSigType); + + if ((compAppleArm64Abi() || TargetArchitecture::IsArm32) && call->IsUnmanaged() && + varTypeIsSmall(jitSigType)) + { + // Apple arm64 and arm32 ABIs require arguments to be zero/sign + // extended up to 32 bit. The managed ABI does not require + // this. + if (fgCastNeeded(argNode, jitSigType)) + { + argNode = gtNewCastNode(TYP_INT, argNode, false, jitSigType); + } + } } NewCallArg arg; @@ -10421,6 +10435,10 @@ NamedIntrinsic Compiler::lookupNamedIntrinsic(CORINFO_METHOD_HANDLE method) result = NI_System_Runtime_CompilerServices_RuntimeHelpers_IsReferenceOrContainsReferences; } + else if (strcmp(methodName, "GetMethodTable") == 0) + { + result = NI_System_Runtime_CompilerServices_RuntimeHelpers_GetMethodTable; + } } else if (strcmp(className, "Unsafe") == 0) { diff --git a/src/coreclr/jit/indirectcalltransformer.cpp b/src/coreclr/jit/indirectcalltransformer.cpp index 7719319ba22..1f6ad5e5e90 100644 --- a/src/coreclr/jit/indirectcalltransformer.cpp +++ b/src/coreclr/jit/indirectcalltransformer.cpp @@ -223,15 +223,20 @@ class IndirectCallTransformer // and insert in into the basic block list. // // Arguments: - // jumpKind - jump kind for the new basic block + // jumpKind - jump kind for the new basic block // insertAfter - basic block, after which compiler has to insert the new one. + // flagsSource - basic block to copy BBF_SPLIT_GAINED flags from // // Return Value: // new basic block. - BasicBlock* CreateAndInsertBasicBlock(BBKinds jumpKind, BasicBlock* insertAfter) + BasicBlock* CreateAndInsertBasicBlock(BBKinds jumpKind, BasicBlock* insertAfter, BasicBlock* flagsSource) { BasicBlock* block = compiler->fgNewBBafter(jumpKind, insertAfter, true); block->SetFlags(BBF_IMPORTED); + if (flagsSource != nullptr) + { + block->CopyFlags(flagsSource, BBF_SPLIT_GAINED); + } return block; } @@ -380,7 +385,7 @@ class IndirectCallTransformer { assert(checkIdx == 0); - checkBlock = CreateAndInsertBasicBlock(BBJ_ALWAYS, currBlock); + checkBlock = CreateAndInsertBasicBlock(BBJ_ALWAYS, currBlock, currBlock); GenTree* fatPointerMask = new (compiler, GT_CNS_INT) GenTreeIntCon(TYP_I_IMPL, FAT_POINTER_MASK); GenTree* fptrAddressCopy = compiler->gtCloneExpr(fptrAddress); GenTree* fatPointerAnd = compiler->gtNewOperNode(GT_AND, TYP_I_IMPL, fptrAddressCopy, fatPointerMask); @@ -398,7 +403,7 @@ class IndirectCallTransformer virtual void CreateThen(uint8_t checkIdx) { assert(remainderBlock != nullptr); - thenBlock = CreateAndInsertBasicBlock(BBJ_ALWAYS, checkBlock); + thenBlock = CreateAndInsertBasicBlock(BBJ_ALWAYS, checkBlock, currBlock); Statement* copyOfOriginalStmt = compiler->gtCloneStmt(stmt); compiler->fgInsertStmtAtEnd(thenBlock, copyOfOriginalStmt); } @@ -408,7 +413,7 @@ class IndirectCallTransformer // virtual void CreateElse() { - elseBlock = CreateAndInsertBasicBlock(BBJ_ALWAYS, thenBlock); + elseBlock = CreateAndInsertBasicBlock(BBJ_ALWAYS, thenBlock, currBlock); GenTree* fixedFptrAddress = GetFixedFptrAddress(); GenTree* actualCallAddress = compiler->gtNewIndir(pointerType, fixedFptrAddress); @@ -612,7 +617,7 @@ class IndirectCallTransformer // In case of multiple checks, append to the previous thenBlock block // (Set jump target of new checkBlock in CreateThen()) BasicBlock* prevCheckBlock = checkBlock; - checkBlock = CreateAndInsertBasicBlock(BBJ_ALWAYS, thenBlock); + checkBlock = CreateAndInsertBasicBlock(BBJ_ALWAYS, thenBlock, currBlock); checkFallsThrough = false; // We computed the "then" likelihood in CreateThen, so we @@ -1066,8 +1071,7 @@ class IndirectCallTransformer // thenBlock always jumps to remainderBlock // - thenBlock = CreateAndInsertBasicBlock(BBJ_ALWAYS, checkBlock); - thenBlock->CopyFlags(currBlock, BBF_SPLIT_GAINED); + thenBlock = CreateAndInsertBasicBlock(BBJ_ALWAYS, checkBlock, currBlock); thenBlock->inheritWeight(checkBlock); thenBlock->scaleBBWeight(adjustedThenLikelihood); FlowEdge* const thenRemainderEdge = compiler->fgAddRefPred(remainderBlock, thenBlock); @@ -1098,8 +1102,7 @@ class IndirectCallTransformer // virtual void CreateElse() { - elseBlock = CreateAndInsertBasicBlock(BBJ_ALWAYS, thenBlock); - elseBlock->CopyFlags(currBlock, BBF_SPLIT_GAINED); + elseBlock = CreateAndInsertBasicBlock(BBJ_ALWAYS, thenBlock, currBlock); // We computed the "then" likelihood in CreateThen, so we // just use that to figure out the "else" likelihood. diff --git a/src/coreclr/jit/inductionvariableopts.cpp b/src/coreclr/jit/inductionvariableopts.cpp index 990100ec8e3..2ea9cee6b9f 100644 --- a/src/coreclr/jit/inductionvariableopts.cpp +++ b/src/coreclr/jit/inductionvariableopts.cpp @@ -2405,6 +2405,12 @@ PhaseStatus Compiler::optInductionVariables() return PhaseStatus::MODIFIED_NOTHING; } + if (JitConfig.JitEnableInductionVariableOpts() == 0) + { + JITDUMP(" Skipping since it is disabled due to JitEnableInductionVariableOpts\n"); + return PhaseStatus::MODIFIED_NOTHING; + } + bool changed = false; optReachableBitVecTraits = nullptr; diff --git a/src/coreclr/jit/instr.h b/src/coreclr/jit/instr.h index c11bae1a6e8..79d6431585b 100644 --- a/src/coreclr/jit/instr.h +++ b/src/coreclr/jit/instr.h @@ -214,9 +214,10 @@ enum insFlags : uint64_t Encoding_EVEX = 1ULL << 40, KInstruction = 1ULL << 41, + KInstructionWithLBit = 1ULL << 42, // EVEX feature: embedded broadcast - INS_Flags_EmbeddedBroadcastSupported = 1ULL << 42, + INS_Flags_EmbeddedBroadcastSupported = 1ULL << 43, // TODO-Cleanup: Remove this flag and its usage from TARGET_XARCH INS_FLAGS_DONT_CARE = 0x00ULL, diff --git a/src/coreclr/jit/instrsarm64sve.h b/src/coreclr/jit/instrsarm64sve.h index 52a01668ae5..c2bdb6e3cb9 100644 --- a/src/coreclr/jit/instrsarm64sve.h +++ b/src/coreclr/jit/instrsarm64sve.h @@ -91,7 +91,7 @@ INST13(mov, "mov", 0, IF_SV // enum name info SVE_JD_4B SVE_JD_4C SVE_JI_3A_A SVE_JJ_4A SVE_JJ_4A_B SVE_JJ_4A_C SVE_JJ_4A_D SVE_JJ_4B SVE_JJ_4B_E SVE_JN_3B SVE_JN_3C -INST11(st1w, "st1w", 0, IF_SVE_11A, 0xE5404000, 0xE5004000, 0xE540A000, 0xE5608000, 0xE5208000, 0xE5008000, 0xE5408000, 0xE520A000, 0xE500A000, 0xE540E000, 0xE500E000 ) +INST11(st1w, "st1w", ST, IF_SVE_11A, 0xE5404000, 0xE5004000, 0xE540A000, 0xE5608000, 0xE5208000, 0xE5008000, 0xE5408000, 0xE520A000, 0xE500A000, 0xE540E000, 0xE500E000 ) // ST1W {.}, , [, , LSL #2] SVE_JD_4B 1110010101xmmmmm 010gggnnnnnttttt E540 4000 // ST1W {.Q }, , [, , LSL #2] SVE_JD_4C 11100101000mmmmm 010gggnnnnnttttt E500 4000 // ST1W {.D }, , [.D{, #}] SVE_JI_3A_A 11100101010iiiii 101gggnnnnnttttt E540 A000 @@ -106,7 +106,7 @@ INST11(st1w, "st1w", 0, IF_SV // enum name info SVE_HW_4A SVE_HW_4A_A SVE_HW_4A_B SVE_HW_4A_C SVE_HW_4B SVE_HW_4B_D SVE_HX_3A_E SVE_IJ_3A_F SVE_IK_4A_G -INST9(ld1sh, "ld1sh", 0, IF_SVE_9A, 0x84A00000, 0xC4A00000, 0xC4800000, 0x84800000, 0xC4E08000, 0xC4C08000, 0x84A08000, 0xA500A000, 0xA5004000 ) +INST9(ld1sh, "ld1sh", LD, IF_SVE_9A, 0x84A00000, 0xC4A00000, 0xC4800000, 0x84800000, 0xC4E08000, 0xC4C08000, 0x84A08000, 0xA500A000, 0xA5004000 ) // LD1SH {.S }, /Z, [, .S, #1] SVE_HW_4A 100001001h1mmmmm 000gggnnnnnttttt 84A0 0000 // LD1SH {.D }, /Z, [, .D, #1] SVE_HW_4A_A 110001001h1mmmmm 000gggnnnnnttttt C4A0 0000 // LD1SH {.D }, /Z, [, .D, ] SVE_HW_4A_B 110001001h0mmmmm 000gggnnnnnttttt C480 0000 @@ -119,7 +119,7 @@ INST9(ld1sh, "ld1sh", 0, IF_SV // enum name info SVE_HW_4A SVE_HW_4A_A SVE_HW_4A_B SVE_HW_4A_C SVE_HW_4B SVE_HW_4B_D SVE_HX_3A_E SVE_IJ_3A_G SVE_IK_4A_I -INST9(ld1h, "ld1h", 0, IF_SVE_9B, 0x84A04000, 0xC4A04000, 0xC4804000, 0x84804000, 0xC4E0C000, 0xC4C0C000, 0x84A0C000, 0xA480A000, 0xA4804000 ) +INST9(ld1h, "ld1h", LD, IF_SVE_9B, 0x84A04000, 0xC4A04000, 0xC4804000, 0x84804000, 0xC4E0C000, 0xC4C0C000, 0x84A0C000, 0xA480A000, 0xA4804000 ) // LD1H {.S }, /Z, [, .S, #1] SVE_HW_4A 100001001h1mmmmm 010gggnnnnnttttt 84A0 4000 // LD1H {.D }, /Z, [, .D, #1] SVE_HW_4A_A 110001001h1mmmmm 010gggnnnnnttttt C4A0 4000 // LD1H {.D }, /Z, [, .D, ] SVE_HW_4A_B 110001001h0mmmmm 010gggnnnnnttttt C480 4000 @@ -132,7 +132,7 @@ INST9(ld1h, "ld1h", 0, IF_SV // enum name info SVE_HW_4A SVE_HW_4A_A SVE_HW_4A_B SVE_HW_4A_C SVE_HW_4B SVE_HW_4B_D SVE_HX_3A_E SVE_IH_3A_F SVE_II_4A_H -INST9(ld1w, "ld1w", 0, IF_SVE_9C, 0x85204000, 0xC5204000, 0xC5004000, 0x85004000, 0xC560C000, 0xC540C000, 0x8520C000, 0xA5002000, 0xA5000000 ) +INST9(ld1w, "ld1w", LD, IF_SVE_9C, 0x85204000, 0xC5204000, 0xC5004000, 0x85004000, 0xC560C000, 0xC540C000, 0x8520C000, 0xA5002000, 0xA5000000 ) // LD1W {.S }, /Z, [, .S, #2] SVE_HW_4A 100001010h1mmmmm 010gggnnnnnttttt 8520 4000 // LD1W {.D }, /Z, [, .D, #2] SVE_HW_4A_A 110001010h1mmmmm 010gggnnnnnttttt C520 4000 // LD1W {.D }, /Z, [, .D, ] SVE_HW_4A_B 110001010h0mmmmm 010gggnnnnnttttt C500 4000 @@ -145,7 +145,7 @@ INST9(ld1w, "ld1w", 0, IF_SV // enum name info SVE_IH_3A SVE_IH_3A_A SVE_II_4A SVE_II_4A_B SVE_IU_4A SVE_IU_4A_C SVE_IU_4B SVE_IU_4B_D SVE_IV_3A -INST9(ld1d, "ld1d", 0, IF_SVE_9D, 0xA5E0A000, 0xA5902000, 0xA5E04000, 0xA5808000, 0xC5A04000, 0xC5804000, 0xC5E0C000, 0xC5C0C000, 0xC5A0C000 ) +INST9(ld1d, "ld1d", LD, IF_SVE_9D, 0xA5E0A000, 0xA5902000, 0xA5E04000, 0xA5808000, 0xC5A04000, 0xC5804000, 0xC5E0C000, 0xC5C0C000, 0xC5A0C000 ) // LD1D {.D }, /Z, [{, #, MUL VL}] SVE_IH_3A 101001011110iiii 101gggnnnnnttttt A5E0 A000 // LD1D {.Q }, /Z, [{, #, MUL VL}] SVE_IH_3A_A 101001011001iiii 001gggnnnnnttttt A590 2000 // LD1D {.D }, /Z, [, , LSL #3] SVE_II_4A 10100101111mmmmm 010gggnnnnnttttt A5E0 4000 @@ -158,7 +158,7 @@ INST9(ld1d, "ld1d", 0, IF_SV // enum name info SVE_JD_4A SVE_JI_3A_A SVE_JJ_4A SVE_JJ_4A_B SVE_JJ_4A_C SVE_JJ_4A_D SVE_JJ_4B SVE_JJ_4B_E SVE_JN_3A -INST9(st1h, "st1h", 0, IF_SVE_9E, 0xE4804000, 0xE4C0A000, 0xE4E08000, 0xE4A08000, 0xE4808000, 0xE4C08000, 0xE4A0A000, 0xE480A000, 0xE480E000 ) +INST9(st1h, "st1h", ST, IF_SVE_9E, 0xE4804000, 0xE4C0A000, 0xE4E08000, 0xE4A08000, 0xE4808000, 0xE4C08000, 0xE4A0A000, 0xE480A000, 0xE480E000 ) // ST1H {.}, , [, , LSL #1] SVE_JD_4A 111001001xxmmmmm 010gggnnnnnttttt E480 4000 // ST1H {.D }, , [.D{, #}] SVE_JI_3A_A 11100100110iiiii 101gggnnnnnttttt E4C0 A000 // ST1H {.S }, , [, .S, #1] SVE_JJ_4A 11100100111mmmmm 1h0gggnnnnnttttt E4E0 8000 @@ -171,7 +171,7 @@ INST9(st1h, "st1h", 0, IF_SV // enum name info SVE_JD_4C SVE_JD_4C_A SVE_JJ_4A SVE_JJ_4A_B SVE_JJ_4B SVE_JJ_4B_C SVE_JL_3A SVE_JN_3C SVE_JN_3C_D -INST9(st1d, "st1d", 0, IF_SVE_9F, 0xE5E04000, 0xE5C04000, 0xE5A08000, 0xE5808000, 0xE5A0A000, 0xE580A000, 0xE5C0A000, 0xE5E0E000, 0xE5C0E000 ) +INST9(st1d, "st1d", ST, IF_SVE_9F, 0xE5E04000, 0xE5C04000, 0xE5A08000, 0xE5808000, 0xE5A0A000, 0xE580A000, 0xE5C0A000, 0xE5E0E000, 0xE5C0E000 ) // ST1D {.D }, , [, , LSL #3] SVE_JD_4C 11100101111mmmmm 010gggnnnnnttttt E5E0 4000 // ST1D {.Q }, , [, , LSL #3] SVE_JD_4C_A 11100101110mmmmm 010gggnnnnnttttt E5C0 4000 // ST1D {.D }, , [, .D, #3] SVE_JJ_4A 11100101101mmmmm 1h0gggnnnnnttttt E5A0 8000 @@ -196,7 +196,7 @@ INST8(pmov, "pmov", 0, IF_SV // enum name info SVE_HW_4A SVE_HW_4A_A SVE_HW_4A_B SVE_HW_4A_C SVE_HW_4B SVE_HW_4B_D SVE_HX_3A_E SVE_IG_4A_F -INST8(ldff1sh, "ldff1sh", 0, IF_SVE_8B, 0x84A02000, 0xC4A02000, 0xC4802000, 0x84802000, 0xC4E0A000, 0xC4C0A000, 0x84A0A000, 0xA5006000 ) +INST8(ldff1sh, "ldff1sh", LD, IF_SVE_8B, 0x84A02000, 0xC4A02000, 0xC4802000, 0x84802000, 0xC4E0A000, 0xC4C0A000, 0x84A0A000, 0xA5006000 ) // LDFF1SH {.S }, /Z, [, .S, #1] SVE_HW_4A 100001001h1mmmmm 001gggnnnnnttttt 84A0 2000 // LDFF1SH {.D }, /Z, [, .D, #1] SVE_HW_4A_A 110001001h1mmmmm 001gggnnnnnttttt C4A0 2000 // LDFF1SH {.D }, /Z, [, .D, ] SVE_HW_4A_B 110001001h0mmmmm 001gggnnnnnttttt C480 2000 @@ -206,7 +206,7 @@ INST8(ldff1sh, "ldff1sh", 0, IF_SV // LDFF1SH {.D }, /Z, [.D{, #}] SVE_HX_3A_E 10000100101iiiii 101gggnnnnnttttt 84A0 A000 // LDFF1SH {.D }, /Z, [{, , LSL #1}] SVE_IG_4A_F 10100101000mmmmm 011gggnnnnnttttt A500 6000 -INST8(ldff1w, "ldff1w", 0, IF_SVE_8B, 0x85206000, 0xC5206000, 0xC5006000, 0x85006000, 0xC560E000, 0xC540E000, 0x8520E000, 0xA5406000 ) +INST8(ldff1w, "ldff1w", LD, IF_SVE_8B, 0x85206000, 0xC5206000, 0xC5006000, 0x85006000, 0xC560E000, 0xC540E000, 0x8520E000, 0xA5406000 ) // LDFF1W {.S }, /Z, [, .S, #2] SVE_HW_4A 100001010h1mmmmm 011gggnnnnnttttt 8520 6000 // LDFF1W {.D }, /Z, [, .D, #2] SVE_HW_4A_A 110001010h1mmmmm 011gggnnnnnttttt C520 6000 // LDFF1W {.D }, /Z, [, .D, ] SVE_HW_4A_B 110001010h0mmmmm 011gggnnnnnttttt C500 6000 @@ -218,7 +218,7 @@ INST8(ldff1w, "ldff1w", 0, IF_SV // enum name info SVE_HW_4A SVE_HW_4A_A SVE_HW_4A_B SVE_HW_4A_C SVE_HW_4B SVE_HW_4B_D SVE_HX_3A_E SVE_IG_4A_G -INST8(ldff1h, "ldff1h", 0, IF_SVE_8C, 0x84A06000, 0xC4A06000, 0xC4806000, 0x84806000, 0xC4E0E000, 0xC4C0E000, 0x84A0E000, 0xA4806000 ) +INST8(ldff1h, "ldff1h", LD, IF_SVE_8C, 0x84A06000, 0xC4A06000, 0xC4806000, 0x84806000, 0xC4E0E000, 0xC4C0E000, 0x84A0E000, 0xA4806000 ) // LDFF1H {.S }, /Z, [, .S, #1] SVE_HW_4A 100001001h1mmmmm 011gggnnnnnttttt 84A0 6000 // LDFF1H {.D }, /Z, [, .D, #1] SVE_HW_4A_A 110001001h1mmmmm 011gggnnnnnttttt C4A0 6000 // LDFF1H {.D }, /Z, [, .D, ] SVE_HW_4A_B 110001001h0mmmmm 011gggnnnnnttttt C480 6000 @@ -230,7 +230,7 @@ INST8(ldff1h, "ldff1h", 0, IF_SV // enum name info SVE_IJ_3A SVE_IK_4A SVE_IU_4A SVE_IU_4A_A SVE_IU_4B SVE_IU_4B_B SVE_IV_3A -INST7(ld1sw, "ld1sw", 0, IF_SVE_7A, 0xA480A000, 0xA4804000, 0xC5200000, 0xC5000000, 0xC5608000, 0xC5408000, 0xC5208000 ) +INST7(ld1sw, "ld1sw", LD, IF_SVE_7A, 0xA480A000, 0xA4804000, 0xC5200000, 0xC5000000, 0xC5608000, 0xC5408000, 0xC5208000 ) // LD1SW {.D }, /Z, [{, #, MUL VL}] SVE_IJ_3A 101001001000iiii 101gggnnnnnttttt A480 A000 // LD1SW {.D }, /Z, [, , LSL #2] SVE_IK_4A 10100100100mmmmm 010gggnnnnnttttt A480 4000 // LD1SW {.D }, /Z, [, .D, #2] SVE_IU_4A 110001010h1mmmmm 000gggnnnnnttttt C520 0000 @@ -260,7 +260,7 @@ INST6(fdot, "fdot", 0, IF_SV // enum name info SVE_HW_4A SVE_HW_4A_A SVE_HW_4B SVE_HX_3A_B SVE_IJ_3A_D SVE_IK_4A_F -INST6(ld1sb, "ld1sb", 0, IF_SVE_6C, 0xC4000000, 0x84000000, 0xC4408000, 0x84208000, 0xA580A000, 0xA5804000 ) +INST6(ld1sb, "ld1sb", LD, IF_SVE_6C, 0xC4000000, 0x84000000, 0xC4408000, 0x84208000, 0xA580A000, 0xA5804000 ) // LD1SB {.D }, /Z, [, .D, ] SVE_HW_4A 110001000h0mmmmm 000gggnnnnnttttt C400 0000 // LD1SB {.S }, /Z, [, .S, ] SVE_HW_4A_A 100001000h0mmmmm 000gggnnnnnttttt 8400 0000 // LD1SB {.D }, /Z, [, .D] SVE_HW_4B 11000100010mmmmm 100gggnnnnnttttt C440 8000 @@ -270,7 +270,7 @@ INST6(ld1sb, "ld1sb", 0, IF_SV // enum name info SVE_HW_4A SVE_HW_4A_A SVE_HW_4B SVE_HX_3A_B SVE_IJ_3A_E SVE_IK_4A_H -INST6(ld1b, "ld1b", 0, IF_SVE_6D, 0xC4004000, 0x84004000, 0xC440C000, 0x8420C000, 0xA400A000, 0xA4004000 ) +INST6(ld1b, "ld1b", LD, IF_SVE_6D, 0xC4004000, 0x84004000, 0xC440C000, 0x8420C000, 0xA400A000, 0xA4004000 ) // LD1B {.D }, /Z, [, .D, ] SVE_HW_4A 110001000h0mmmmm 010gggnnnnnttttt C400 4000 // LD1B {.S }, /Z, [, .S, ] SVE_HW_4A_A 100001000h0mmmmm 010gggnnnnnttttt 8400 4000 // LD1B {.D }, /Z, [, .D] SVE_HW_4B 11000100010mmmmm 110gggnnnnnttttt C440 C000 @@ -314,7 +314,7 @@ INST6(prfw, "prfw", 0, IF_SV // enum name info SVE_IG_4A SVE_IU_4A SVE_IU_4A_A SVE_IU_4B SVE_IU_4B_B SVE_IV_3A -INST6(ldff1d, "ldff1d", 0, IF_SVE_6F, 0xA5E06000, 0xC5A06000, 0xC5806000, 0xC5E0E000, 0xC5C0E000, 0xC5A0E000 ) +INST6(ldff1d, "ldff1d", LD, IF_SVE_6F, 0xA5E06000, 0xC5A06000, 0xC5806000, 0xC5E0E000, 0xC5C0E000, 0xC5A0E000 ) // LDFF1D {.D }, /Z, [{, , LSL #3}] SVE_IG_4A 10100101111mmmmm 011gggnnnnnttttt A5E0 6000 // LDFF1D {.D }, /Z, [, .D, #3] SVE_IU_4A 110001011h1mmmmm 011gggnnnnnttttt C5A0 6000 // LDFF1D {.D }, /Z, [, .D, ] SVE_IU_4A_A 110001011h0mmmmm 011gggnnnnnttttt C580 6000 @@ -322,7 +322,7 @@ INST6(ldff1d, "ldff1d", 0, IF_SV // LDFF1D {.D }, /Z, [, .D] SVE_IU_4B_B 11000101110mmmmm 111gggnnnnnttttt C5C0 E000 // LDFF1D {.D }, /Z, [.D{, #}] SVE_IV_3A 11000101101iiiii 111gggnnnnnttttt C5A0 E000 -INST6(ldff1sw, "ldff1sw", 0, IF_SVE_6F, 0xA4806000, 0xC5202000, 0xC5002000, 0xC560A000, 0xC540A000, 0xC520A000 ) +INST6(ldff1sw, "ldff1sw", LD, IF_SVE_6F, 0xA4806000, 0xC5202000, 0xC5002000, 0xC560A000, 0xC540A000, 0xC520A000 ) // LDFF1SW {.D }, /Z, [{, , LSL #2}] SVE_IG_4A 10100100100mmmmm 011gggnnnnnttttt A480 6000 // LDFF1SW {.D }, /Z, [, .D, #2] SVE_IU_4A 110001010h1mmmmm 001gggnnnnnttttt C520 2000 // LDFF1SW {.D }, /Z, [, .D, ] SVE_IU_4A_A 110001010h0mmmmm 001gggnnnnnttttt C500 2000 @@ -332,7 +332,7 @@ INST6(ldff1sw, "ldff1sw", 0, IF_SV // enum name info SVE_JD_4A SVE_JI_3A_A SVE_JK_4A SVE_JK_4A_B SVE_JK_4B SVE_JN_3A -INST6(st1b, "st1b", 0, IF_SVE_6G, 0xE4004000, 0xE440A000, 0xE4008000, 0xE4408000, 0xE400A000, 0xE400E000 ) +INST6(st1b, "st1b", ST, IF_SVE_6G, 0xE4004000, 0xE440A000, 0xE4008000, 0xE4408000, 0xE400A000, 0xE400E000 ) // ST1B {.}, , [, ] SVE_JD_4A 111001000xxmmmmm 010gggnnnnnttttt E400 4000 // ST1B {.D }, , [.D{, #}] SVE_JI_3A_A 11100100010iiiii 101gggnnnnnttttt E440 A000 // ST1B {.D }, , [, .D, ] SVE_JK_4A 11100100000mmmmm 1h0gggnnnnnttttt E400 8000 @@ -390,7 +390,7 @@ INST5(udot, "udot", 0, IF_SV // enum name info SVE_HW_4A SVE_HW_4A_A SVE_HW_4B SVE_HX_3A_B SVE_IG_4A_D -INST5(ldff1sb, "ldff1sb", 0, IF_SVE_5D, 0xC4002000, 0x84002000, 0xC440A000, 0x8420A000, 0xA5806000 ) +INST5(ldff1sb, "ldff1sb", LD, IF_SVE_5D, 0xC4002000, 0x84002000, 0xC440A000, 0x8420A000, 0xA5806000 ) // LDFF1SB {.D }, /Z, [, .D, ] SVE_HW_4A 110001000h0mmmmm 001gggnnnnnttttt C400 2000 // LDFF1SB {.S }, /Z, [, .S, ] SVE_HW_4A_A 100001000h0mmmmm 001gggnnnnnttttt 8400 2000 // LDFF1SB {.D }, /Z, [, .D] SVE_HW_4B 11000100010mmmmm 101gggnnnnnttttt C440 A000 @@ -399,7 +399,7 @@ INST5(ldff1sb, "ldff1sb", 0, IF_SV // enum name info SVE_HW_4A SVE_HW_4A_A SVE_HW_4B SVE_HX_3A_B SVE_IG_4A_E -INST5(ldff1b, "ldff1b", 0, IF_SVE_5E, 0xC4006000, 0x84006000, 0xC440E000, 0x8420E000, 0xA4006000 ) +INST5(ldff1b, "ldff1b", LD, IF_SVE_5E, 0xC4006000, 0x84006000, 0xC440E000, 0x8420E000, 0xA4006000 ) // LDFF1B {.D }, /Z, [, .D, ] SVE_HW_4A 110001000h0mmmmm 011gggnnnnnttttt C400 6000 // LDFF1B {.S }, /Z, [, .S, ] SVE_HW_4A_A 100001000h0mmmmm 011gggnnnnnttttt 8400 6000 // LDFF1B {.D }, /Z, [, .D] SVE_HW_4B 11000100010mmmmm 111gggnnnnnttttt C440 E000 @@ -516,19 +516,19 @@ INST4(cpy, "cpy", 0, IF_SV // enum name info SVE_IF_4A SVE_IF_4A_A SVE_IM_3A SVE_IN_4A -INST4(ldnt1b, "ldnt1b", 0, IF_SVE_4K, 0x8400A000, 0xC400C000, 0xA400E000, 0xA400C000 ) +INST4(ldnt1b, "ldnt1b", LD, IF_SVE_4K, 0x8400A000, 0xC400C000, 0xA400E000, 0xA400C000 ) // LDNT1B {.S }, /Z, [.S{, }] SVE_IF_4A 10000100000mmmmm 101gggnnnnnttttt 8400 A000 // LDNT1B {.D }, /Z, [.D{, }] SVE_IF_4A_A 11000100000mmmmm 110gggnnnnnttttt C400 C000 // LDNT1B {.B }, /Z, [{, #, MUL VL}] SVE_IM_3A 101001000000iiii 111gggnnnnnttttt A400 E000 // LDNT1B {.B }, /Z, [, ] SVE_IN_4A 10100100000mmmmm 110gggnnnnnttttt A400 C000 -INST4(ldnt1h, "ldnt1h", 0, IF_SVE_4K, 0x8480A000, 0xC480C000, 0xA480E000, 0xA480C000 ) +INST4(ldnt1h, "ldnt1h", LD, IF_SVE_4K, 0x8480A000, 0xC480C000, 0xA480E000, 0xA480C000 ) // LDNT1H {.S }, /Z, [.S{, }] SVE_IF_4A 10000100100mmmmm 101gggnnnnnttttt 8480 A000 // LDNT1H {.D }, /Z, [.D{, }] SVE_IF_4A_A 11000100100mmmmm 110gggnnnnnttttt C480 C000 // LDNT1H {.H }, /Z, [{, #, MUL VL}] SVE_IM_3A 101001001000iiii 111gggnnnnnttttt A480 E000 // LDNT1H {.H }, /Z, [, , LSL #1] SVE_IN_4A 10100100100mmmmm 110gggnnnnnttttt A480 C000 -INST4(ldnt1w, "ldnt1w", 0, IF_SVE_4K, 0x8500A000, 0xC500C000, 0xA500E000, 0xA500C000 ) +INST4(ldnt1w, "ldnt1w", LD, IF_SVE_4K, 0x8500A000, 0xC500C000, 0xA500E000, 0xA500C000 ) // LDNT1W {.S }, /Z, [.S{, }] SVE_IF_4A 10000101000mmmmm 101gggnnnnnttttt 8500 A000 // LDNT1W {.D }, /Z, [.D{, }] SVE_IF_4A_A 11000101000mmmmm 110gggnnnnnttttt C500 C000 // LDNT1W {.S }, /Z, [{, #, MUL VL}] SVE_IM_3A 101001010000iiii 111gggnnnnnttttt A500 E000 @@ -536,19 +536,19 @@ INST4(ldnt1w, "ldnt1w", 0, IF_SV // enum name info SVE_IZ_4A SVE_IZ_4A_A SVE_JB_4A SVE_JM_3A -INST4(stnt1b, "stnt1b", 0, IF_SVE_4L, 0xE4402000, 0xE4002000, 0xE4006000, 0xE410E000 ) +INST4(stnt1b, "stnt1b", ST, IF_SVE_4L, 0xE4402000, 0xE4002000, 0xE4006000, 0xE410E000 ) // STNT1B {.S }, , [.S{, }] SVE_IZ_4A 11100100010mmmmm 001gggnnnnnttttt E440 2000 // STNT1B {.D }, , [.D{, }] SVE_IZ_4A_A 11100100000mmmmm 001gggnnnnnttttt E400 2000 // STNT1B {.B }, , [, ] SVE_JB_4A 11100100000mmmmm 011gggnnnnnttttt E400 6000 // STNT1B {.B }, , [{, #, MUL VL}] SVE_JM_3A 111001000001iiii 111gggnnnnnttttt E410 E000 -INST4(stnt1h, "stnt1h", 0, IF_SVE_4L, 0xE4C02000, 0xE4802000, 0xE4806000, 0xE490E000 ) +INST4(stnt1h, "stnt1h", ST, IF_SVE_4L, 0xE4C02000, 0xE4802000, 0xE4806000, 0xE490E000 ) // STNT1H {.S }, , [.S{, }] SVE_IZ_4A 11100100110mmmmm 001gggnnnnnttttt E4C0 2000 // STNT1H {.D }, , [.D{, }] SVE_IZ_4A_A 11100100100mmmmm 001gggnnnnnttttt E480 2000 // STNT1H {.H }, , [, , LSL #1] SVE_JB_4A 11100100100mmmmm 011gggnnnnnttttt E480 6000 // STNT1H {.H }, , [{, #, MUL VL}] SVE_JM_3A 111001001001iiii 111gggnnnnnttttt E490 E000 -INST4(stnt1w, "stnt1w", 0, IF_SVE_4L, 0xE5402000, 0xE5002000, 0xE5006000, 0xE510E000 ) +INST4(stnt1w, "stnt1w", ST, IF_SVE_4L, 0xE5402000, 0xE5002000, 0xE5006000, 0xE510E000 ) // STNT1W {.S }, , [.S{, }] SVE_IZ_4A 11100101010mmmmm 001gggnnnnnttttt E540 2000 // STNT1W {.D }, , [.D{, }] SVE_IZ_4A_A 11100101000mmmmm 001gggnnnnnttttt E500 2000 // STNT1W {.S }, , [, , LSL #2] SVE_JB_4A 11100101000mmmmm 011gggnnnnnttttt E500 6000 @@ -679,54 +679,54 @@ INST3(clastb, "clastb", 0, IF_SV // enum name info SVE_CX_4A SVE_CX_4A_A SVE_CY_3A -INST3(cmpeq, "cmpeq", 0, IF_SVE_3J, 0x2400A000, 0x24002000, 0x25008000 ) +INST3(cmpeq, "cmpeq", CMP, IF_SVE_3J, 0x2400A000, 0x24002000, 0x25008000 ) // CMPEQ ., /Z, ., . SVE_CX_4A 00100100xx0mmmmm 101gggnnnnn0DDDD 2400 A000 // CMPEQ ., /Z, ., .D SVE_CX_4A_A 00100100xx0mmmmm 001gggnnnnn0DDDD 2400 2000 // CMPEQ ., /Z, ., # SVE_CY_3A 00100101xx0iiiii 100gggnnnnn0DDDD 2500 8000 -INST3(cmpge, "cmpge", 0, IF_SVE_3J, 0x24008000, 0x24004000, 0x25000000 ) +INST3(cmpge, "cmpge", CMP, IF_SVE_3J, 0x24008000, 0x24004000, 0x25000000 ) // CMPGE ., /Z, ., . SVE_CX_4A 00100100xx0mmmmm 100gggnnnnn0DDDD 2400 8000 // CMPGE ., /Z, ., .D SVE_CX_4A_A 00100100xx0mmmmm 010gggnnnnn0DDDD 2400 4000 // CMPGE ., /Z, ., # SVE_CY_3A 00100101xx0iiiii 000gggnnnnn0DDDD 2500 0000 -INST3(cmpgt, "cmpgt", 0, IF_SVE_3J, 0x24008010, 0x24004010, 0x25000010 ) +INST3(cmpgt, "cmpgt", CMP, IF_SVE_3J, 0x24008010, 0x24004010, 0x25000010 ) // CMPGT ., /Z, ., . SVE_CX_4A 00100100xx0mmmmm 100gggnnnnn1DDDD 2400 8010 // CMPGT ., /Z, ., .D SVE_CX_4A_A 00100100xx0mmmmm 010gggnnnnn1DDDD 2400 4010 // CMPGT ., /Z, ., # SVE_CY_3A 00100101xx0iiiii 000gggnnnnn1DDDD 2500 0010 -INST3(cmple, "cmple", 0, IF_SVE_3J, 0x24008000, 0x24006010, 0x25002010 ) +INST3(cmple, "cmple", CMP, IF_SVE_3J, 0x24008000, 0x24006010, 0x25002010 ) // CMPLE ., /Z, ., . SVE_CX_4A 00100100xx0mmmmm 100gggnnnnn0DDDD 2400 8000 // CMPLE ., /Z, ., .D SVE_CX_4A_A 00100100xx0mmmmm 011gggnnnnn1DDDD 2400 6010 // CMPLE ., /Z, ., # SVE_CY_3A 00100101xx0iiiii 001gggnnnnn1DDDD 2500 2010 -INST3(cmplt, "cmplt", 0, IF_SVE_3J, 0x24008010, 0x24006000, 0x25002000 ) +INST3(cmplt, "cmplt", CMP, IF_SVE_3J, 0x24008010, 0x24006000, 0x25002000 ) // CMPLT ., /Z, ., . SVE_CX_4A 00100100xx0mmmmm 100gggnnnnn1DDDD 2400 8010 // CMPLT ., /Z, ., .D SVE_CX_4A_A 00100100xx0mmmmm 011gggnnnnn0DDDD 2400 6000 // CMPLT ., /Z, ., # SVE_CY_3A 00100101xx0iiiii 001gggnnnnn0DDDD 2500 2000 -INST3(cmpne, "cmpne", 0, IF_SVE_3J, 0x2400A010, 0x24002010, 0x25008010 ) +INST3(cmpne, "cmpne", CMP, IF_SVE_3J, 0x2400A010, 0x24002010, 0x25008010 ) // CMPNE ., /Z, ., . SVE_CX_4A 00100100xx0mmmmm 101gggnnnnn1DDDD 2400 A010 // CMPNE ., /Z, ., .D SVE_CX_4A_A 00100100xx0mmmmm 001gggnnnnn1DDDD 2400 2010 // CMPNE ., /Z, ., # SVE_CY_3A 00100101xx0iiiii 100gggnnnnn1DDDD 2500 8010 // enum name info SVE_CX_4A SVE_CX_4A_A SVE_CY_3B -INST3(cmphi, "cmphi", 0, IF_SVE_3K, 0x24000010, 0x2400C010, 0x24200010 ) +INST3(cmphi, "cmphi", CMP, IF_SVE_3K, 0x24000010, 0x2400C010, 0x24200010 ) // CMPHI ., /Z, ., . SVE_CX_4A 00100100xx0mmmmm 000gggnnnnn1DDDD 2400 0010 // CMPHI ., /Z, ., .D SVE_CX_4A_A 00100100xx0mmmmm 110gggnnnnn1DDDD 2400 C010 // CMPHI ., /Z, ., # SVE_CY_3B 00100100xx1iiiii ii0gggnnnnn1DDDD 2420 0010 -INST3(cmphs, "cmphs", 0, IF_SVE_3K, 0x24000000, 0x2400C000, 0x24200000 ) +INST3(cmphs, "cmphs", CMP, IF_SVE_3K, 0x24000000, 0x2400C000, 0x24200000 ) // CMPHS ., /Z, ., . SVE_CX_4A 00100100xx0mmmmm 000gggnnnnn0DDDD 2400 0000 // CMPHS ., /Z, ., .D SVE_CX_4A_A 00100100xx0mmmmm 110gggnnnnn0DDDD 2400 C000 // CMPHS ., /Z, ., # SVE_CY_3B 00100100xx1iiiii ii0gggnnnnn0DDDD 2420 0000 -INST3(cmplo, "cmplo", 0, IF_SVE_3K, 0x24000010, 0x2400E000, 0x24202000 ) +INST3(cmplo, "cmplo", CMP, IF_SVE_3K, 0x24000010, 0x2400E000, 0x24202000 ) // CMPLO ., /Z, ., . SVE_CX_4A 00100100xx0mmmmm 000gggnnnnn1DDDD 2400 0010 // CMPLO ., /Z, ., .D SVE_CX_4A_A 00100100xx0mmmmm 111gggnnnnn0DDDD 2400 E000 // CMPLO ., /Z, ., # SVE_CY_3B 00100100xx1iiiii ii1gggnnnnn0DDDD 2420 2000 -INST3(cmpls, "cmpls", 0, IF_SVE_3K, 0x24000000, 0x2400E010, 0x24202010 ) +INST3(cmpls, "cmpls", CMP, IF_SVE_3K, 0x24000000, 0x2400E010, 0x24202010 ) // CMPLS ., /Z, ., . SVE_CX_4A 00100100xx0mmmmm 000gggnnnnn0DDDD 2400 0000 // CMPLS ., /Z, ., .D SVE_CX_4A_A 00100100xx0mmmmm 111gggnnnnn1DDDD 2400 E010 // CMPLS ., /Z, ., # SVE_CY_3B 00100100xx1iiiii ii1gggnnnnn1DDDD 2420 2010 @@ -901,27 +901,27 @@ INST3(bfmul, "bfmul", 0, IF_SV // enum name info SVE_IM_3A SVE_IN_4A SVE_IX_4A -INST3(ldnt1d, "ldnt1d", 0, IF_SVE_3U, 0xA580E000, 0xA580C000, 0xC580C000 ) +INST3(ldnt1d, "ldnt1d", LD, IF_SVE_3U, 0xA580E000, 0xA580C000, 0xC580C000 ) // LDNT1D {.D }, /Z, [{, #, MUL VL}] SVE_IM_3A 101001011000iiii 111gggnnnnnttttt A580 E000 // LDNT1D {.D }, /Z, [, , LSL #3] SVE_IN_4A 10100101100mmmmm 110gggnnnnnttttt A580 C000 // LDNT1D {.D }, /Z, [.D{, }] SVE_IX_4A 11000101100mmmmm 110gggnnnnnttttt C580 C000 // enum name info SVE_JA_4A SVE_JB_4A SVE_JM_3A -INST3(stnt1d, "stnt1d", 0, IF_SVE_3V, 0xE5802000, 0xE5806000, 0xE590E000 ) +INST3(stnt1d, "stnt1d", ST, IF_SVE_3V, 0xE5802000, 0xE5806000, 0xE590E000 ) // STNT1D {.D }, , [.D{, }] SVE_JA_4A 11100101100mmmmm 001gggnnnnnttttt E580 2000 // STNT1D {.D }, , [, , LSL #3] SVE_JB_4A 11100101100mmmmm 011gggnnnnnttttt E580 6000 // STNT1D {.D }, , [{, #, MUL VL}] SVE_JM_3A 111001011001iiii 111gggnnnnnttttt E590 E000 // enum name info SVE_ID_2A SVE_IE_2A -INST2(ldr, "ldr", 0, IF_SVE_2AA, 0x85800000, 0x85804000 ) +INST2(ldr, "ldr", LD, IF_SVE_2AA, 0x85800000, 0x85804000 ) // LDR , [{, #, MUL VL}] SVE_ID_2A 1000010110iiiiii 000iiinnnnn0TTTT 8580 0000 // LDR , [{, #, MUL VL}] SVE_IE_2A 1000010110iiiiii 010iiinnnnnttttt 8580 4000 // enum name info SVE_JG_2A SVE_JH_2A -INST2(str, "str", 0, IF_SVE_2AB, 0xE5800000, 0xE5804000 ) +INST2(str, "str", ST, IF_SVE_2AB, 0xE5800000, 0xE5804000 ) // STR , [{, #, MUL VL}] SVE_JG_2A 1110010110iiiiii 000iiinnnnn0TTTT E580 0000 // STR , [{, #, MUL VL}] SVE_JH_2A 1110010110iiiiii 010iiinnnnnttttt E580 4000 @@ -993,27 +993,27 @@ INST2(uqshl, "uqshl", 0, IF_SV // enum name info SVE_HI_3A SVE_HT_4A -INST2(fcmeq, "fcmeq", 0, IF_SVE_2AJ, 0x65122000, 0x65006000 ) +INST2(fcmeq, "fcmeq", CMP, IF_SVE_2AJ, 0x65122000, 0x65006000 ) // FCMEQ ., /Z, ., #0.0 SVE_HI_3A 01100101xx010010 001gggnnnnn0DDDD 6512 2000 // FCMEQ ., /Z, ., . SVE_HT_4A 01100101xx0mmmmm 011gggnnnnn0DDDD 6500 6000 -INST2(fcmge, "fcmge", 0, IF_SVE_2AJ, 0x65102000, 0x65004000 ) +INST2(fcmge, "fcmge", CMP, IF_SVE_2AJ, 0x65102000, 0x65004000 ) // FCMGE ., /Z, ., #0.0 SVE_HI_3A 01100101xx010000 001gggnnnnn0DDDD 6510 2000 // FCMGE ., /Z, ., . SVE_HT_4A 01100101xx0mmmmm 010gggnnnnn0DDDD 6500 4000 -INST2(fcmgt, "fcmgt", 0, IF_SVE_2AJ, 0x65102010, 0x65004010 ) +INST2(fcmgt, "fcmgt", CMP, IF_SVE_2AJ, 0x65102010, 0x65004010 ) // FCMGT ., /Z, ., #0.0 SVE_HI_3A 01100101xx010000 001gggnnnnn1DDDD 6510 2010 // FCMGT ., /Z, ., . SVE_HT_4A 01100101xx0mmmmm 010gggnnnnn1DDDD 6500 4010 -INST2(fcmle, "fcmle", 0, IF_SVE_2AJ, 0x65112010, 0x65004000 ) +INST2(fcmle, "fcmle", CMP, IF_SVE_2AJ, 0x65112010, 0x65004000 ) // FCMLE ., /Z, ., #0.0 SVE_HI_3A 01100101xx010001 001gggnnnnn1DDDD 6511 2010 // FCMLE ., /Z, ., . SVE_HT_4A 01100101xx0mmmmm 010gggnnnnn0DDDD 6500 4000 -INST2(fcmlt, "fcmlt", 0, IF_SVE_2AJ, 0x65112000, 0x65004010 ) +INST2(fcmlt, "fcmlt", CMP, IF_SVE_2AJ, 0x65112000, 0x65004010 ) // FCMLT ., /Z, ., #0.0 SVE_HI_3A 01100101xx010001 001gggnnnnn0DDDD 6511 2000 // FCMLT ., /Z, ., . SVE_HT_4A 01100101xx0mmmmm 010gggnnnnn1DDDD 6500 4010 -INST2(fcmne, "fcmne", 0, IF_SVE_2AJ, 0x65132000, 0x65006010 ) +INST2(fcmne, "fcmne", CMP, IF_SVE_2AJ, 0x65132000, 0x65006010 ) // FCMNE ., /Z, ., #0.0 SVE_HI_3A 01100101xx010011 001gggnnnnn0DDDD 6513 2000 // FCMNE ., /Z, ., . SVE_HT_4A 01100101xx0mmmmm 011gggnnnnn1DDDD 6500 6010 @@ -1331,173 +1331,173 @@ INST2(bfsub, "bfsub", 0, IF_SV // enum name info SVE_IF_4A SVE_IF_4A_A -INST2(ldnt1sb, "ldnt1sb", 0, IF_SVE_2BN, 0x84008000, 0xC4008000 ) +INST2(ldnt1sb, "ldnt1sb", LD, IF_SVE_2BN, 0x84008000, 0xC4008000 ) // LDNT1SB {.S }, /Z, [.S{, }] SVE_IF_4A 10000100000mmmmm 100gggnnnnnttttt 8400 8000 // LDNT1SB {.D }, /Z, [.D{, }] SVE_IF_4A_A 11000100000mmmmm 100gggnnnnnttttt C400 8000 -INST2(ldnt1sh, "ldnt1sh", 0, IF_SVE_2BN, 0x84808000, 0xC4808000 ) +INST2(ldnt1sh, "ldnt1sh", LD, IF_SVE_2BN, 0x84808000, 0xC4808000 ) // LDNT1SH {.S }, /Z, [.S{, }] SVE_IF_4A 10000100100mmmmm 100gggnnnnnttttt 8480 8000 // LDNT1SH {.D }, /Z, [.D{, }] SVE_IF_4A_A 11000100100mmmmm 100gggnnnnnttttt C480 8000 // enum name info SVE_IO_3A SVE_IP_4A -INST2(ld1rob, "ld1rob", 0, IF_SVE_2BO, 0xA4202000, 0xA4200000 ) +INST2(ld1rob, "ld1rob", LD, IF_SVE_2BO, 0xA4202000, 0xA4200000 ) // LD1ROB {.B }, /Z, [{, #}] SVE_IO_3A 101001000010iiii 001gggnnnnnttttt A420 2000 // LD1ROB {.B }, /Z, [, ] SVE_IP_4A 10100100001mmmmm 000gggnnnnnttttt A420 0000 -INST2(ld1rod, "ld1rod", 0, IF_SVE_2BO, 0xA5A02000, 0xA5A00000 ) +INST2(ld1rod, "ld1rod", LD, IF_SVE_2BO, 0xA5A02000, 0xA5A00000 ) // LD1ROD {.D }, /Z, [{, #}] SVE_IO_3A 101001011010iiii 001gggnnnnnttttt A5A0 2000 // LD1ROD {.D }, /Z, [, , LSL #3] SVE_IP_4A 10100101101mmmmm 000gggnnnnnttttt A5A0 0000 -INST2(ld1roh, "ld1roh", 0, IF_SVE_2BO, 0xA4A02000, 0xA4A00000 ) +INST2(ld1roh, "ld1roh", LD, IF_SVE_2BO, 0xA4A02000, 0xA4A00000 ) // LD1ROH {.H }, /Z, [{, #}] SVE_IO_3A 101001001010iiii 001gggnnnnnttttt A4A0 2000 // LD1ROH {.H }, /Z, [, , LSL #1] SVE_IP_4A 10100100101mmmmm 000gggnnnnnttttt A4A0 0000 -INST2(ld1row, "ld1row", 0, IF_SVE_2BO, 0xA5202000, 0xA5200000 ) +INST2(ld1row, "ld1row", LD, IF_SVE_2BO, 0xA5202000, 0xA5200000 ) // LD1ROW {.S }, /Z, [{, #}] SVE_IO_3A 101001010010iiii 001gggnnnnnttttt A520 2000 // LD1ROW {.S }, /Z, [, , LSL #2] SVE_IP_4A 10100101001mmmmm 000gggnnnnnttttt A520 0000 -INST2(ld1rqb, "ld1rqb", 0, IF_SVE_2BO, 0xA4002000, 0xA4000000 ) +INST2(ld1rqb, "ld1rqb", LD, IF_SVE_2BO, 0xA4002000, 0xA4000000 ) // LD1RQB {.B }, /Z, [{, #}] SVE_IO_3A 101001000000iiii 001gggnnnnnttttt A400 2000 // LD1RQB {.B }, /Z, [, ] SVE_IP_4A 10100100000mmmmm 000gggnnnnnttttt A400 0000 -INST2(ld1rqd, "ld1rqd", 0, IF_SVE_2BO, 0xA5802000, 0xA5800000 ) +INST2(ld1rqd, "ld1rqd", LD, IF_SVE_2BO, 0xA5802000, 0xA5800000 ) // LD1RQD {.D }, /Z, [{, #}] SVE_IO_3A 101001011000iiii 001gggnnnnnttttt A580 2000 // LD1RQD {.D }, /Z, [, , LSL #3] SVE_IP_4A 10100101100mmmmm 000gggnnnnnttttt A580 0000 -INST2(ld1rqh, "ld1rqh", 0, IF_SVE_2BO, 0xA4802000, 0xA4800000 ) +INST2(ld1rqh, "ld1rqh", LD, IF_SVE_2BO, 0xA4802000, 0xA4800000 ) // LD1RQH {.H }, /Z, [{, #}] SVE_IO_3A 101001001000iiii 001gggnnnnnttttt A480 2000 // LD1RQH {.H }, /Z, [, , LSL #1] SVE_IP_4A 10100100100mmmmm 000gggnnnnnttttt A480 0000 -INST2(ld1rqw, "ld1rqw", 0, IF_SVE_2BO, 0xA5002000, 0xA5000000 ) +INST2(ld1rqw, "ld1rqw", LD, IF_SVE_2BO, 0xA5002000, 0xA5000000 ) // LD1RQW {.S }, /Z, [{, #}] SVE_IO_3A 101001010000iiii 001gggnnnnnttttt A500 2000 // LD1RQW {.S }, /Z, [, , LSL #2] SVE_IP_4A 10100101000mmmmm 000gggnnnnnttttt A500 0000 // enum name info SVE_IQ_3A SVE_IR_4A -INST2(ld2q, "ld2q", 0, IF_SVE_2BP, 0xA490E000, 0xA4A08000 ) +INST2(ld2q, "ld2q", LD, IF_SVE_2BP, 0xA490E000, 0xA4A08000 ) // LD2Q {.Q, .Q }, /Z, [{, #, MUL VL}] SVE_IQ_3A 101001001001iiii 111gggnnnnnttttt A490 E000 // LD2Q {.Q, .Q }, /Z, [, , LSL #4] SVE_IR_4A 10100100101mmmmm 100gggnnnnnttttt A4A0 8000 -INST2(ld3q, "ld3q", 0, IF_SVE_2BP, 0xA510E000, 0xA5208000 ) +INST2(ld3q, "ld3q", LD, IF_SVE_2BP, 0xA510E000, 0xA5208000 ) // LD3Q {.Q, .Q, .Q }, /Z, [{, #, MUL VL}] SVE_IQ_3A 101001010001iiii 111gggnnnnnttttt A510 E000 // LD3Q {.Q, .Q, .Q }, /Z, [, , LSL #4] SVE_IR_4A 10100101001mmmmm 100gggnnnnnttttt A520 8000 -INST2(ld4q, "ld4q", 0, IF_SVE_2BP, 0xA590E000, 0xA5A08000 ) +INST2(ld4q, "ld4q", LD, IF_SVE_2BP, 0xA590E000, 0xA5A08000 ) // LD4Q {.Q, .Q, .Q, .Q }, /Z, [{, #, MUL VL}]SVE_IQ_3A 101001011001iiii 111gggnnnnnttttt A590 E000 // LD4Q {.Q, .Q, .Q, .Q }, /Z, [, , LSL #4] SVE_IR_4A 10100101101mmmmm 100gggnnnnnttttt A5A0 8000 // enum name info SVE_IS_3A SVE_IT_4A -INST2(ld2b, "ld2b", 0, IF_SVE_2BQ, 0xA420E000, 0xA420C000 ) +INST2(ld2b, "ld2b", LD, IF_SVE_2BQ, 0xA420E000, 0xA420C000 ) // LD2B {.B, .B }, /Z, [{, #, MUL VL}] SVE_IS_3A 101001000010iiii 111gggnnnnnttttt A420 E000 // LD2B {.B, .B }, /Z, [, ] SVE_IT_4A 10100100001mmmmm 110gggnnnnnttttt A420 C000 -INST2(ld2d, "ld2d", 0, IF_SVE_2BQ, 0xA5A0E000, 0xA5A0C000 ) +INST2(ld2d, "ld2d", LD, IF_SVE_2BQ, 0xA5A0E000, 0xA5A0C000 ) // LD2D {.D, .D }, /Z, [{, #, MUL VL}] SVE_IS_3A 101001011010iiii 111gggnnnnnttttt A5A0 E000 // LD2D {.D, .D }, /Z, [, , LSL #3] SVE_IT_4A 10100101101mmmmm 110gggnnnnnttttt A5A0 C000 -INST2(ld2h, "ld2h", 0, IF_SVE_2BQ, 0xA4A0E000, 0xA4A0C000 ) +INST2(ld2h, "ld2h", LD, IF_SVE_2BQ, 0xA4A0E000, 0xA4A0C000 ) // LD2H {.H, .H }, /Z, [{, #, MUL VL}] SVE_IS_3A 101001001010iiii 111gggnnnnnttttt A4A0 E000 // LD2H {.H, .H }, /Z, [, , LSL #1] SVE_IT_4A 10100100101mmmmm 110gggnnnnnttttt A4A0 C000 -INST2(ld2w, "ld2w", 0, IF_SVE_2BQ, 0xA520E000, 0xA520C000 ) +INST2(ld2w, "ld2w", LD, IF_SVE_2BQ, 0xA520E000, 0xA520C000 ) // LD2W {.S, .S }, /Z, [{, #, MUL VL}] SVE_IS_3A 101001010010iiii 111gggnnnnnttttt A520 E000 // LD2W {.S, .S }, /Z, [, , LSL #2] SVE_IT_4A 10100101001mmmmm 110gggnnnnnttttt A520 C000 -INST2(ld3b, "ld3b", 0, IF_SVE_2BQ, 0xA440E000, 0xA440C000 ) +INST2(ld3b, "ld3b", LD, IF_SVE_2BQ, 0xA440E000, 0xA440C000 ) // LD3B {.B, .B, .B }, /Z, [{, #, MUL VL}] SVE_IS_3A 101001000100iiii 111gggnnnnnttttt A440 E000 // LD3B {.B, .B, .B }, /Z, [, ] SVE_IT_4A 10100100010mmmmm 110gggnnnnnttttt A440 C000 -INST2(ld3d, "ld3d", 0, IF_SVE_2BQ, 0xA5C0E000, 0xA5C0C000 ) +INST2(ld3d, "ld3d", LD, IF_SVE_2BQ, 0xA5C0E000, 0xA5C0C000 ) // LD3D {.D, .D, .D }, /Z, [{, #, MUL VL}] SVE_IS_3A 101001011100iiii 111gggnnnnnttttt A5C0 E000 // LD3D {.D, .D, .D }, /Z, [, , LSL #3] SVE_IT_4A 10100101110mmmmm 110gggnnnnnttttt A5C0 C000 -INST2(ld3h, "ld3h", 0, IF_SVE_2BQ, 0xA4C0E000, 0xA4C0C000 ) +INST2(ld3h, "ld3h", LD, IF_SVE_2BQ, 0xA4C0E000, 0xA4C0C000 ) // LD3H {.H, .H, .H }, /Z, [{, #, MUL VL}] SVE_IS_3A 101001001100iiii 111gggnnnnnttttt A4C0 E000 // LD3H {.H, .H, .H }, /Z, [, , LSL #1] SVE_IT_4A 10100100110mmmmm 110gggnnnnnttttt A4C0 C000 -INST2(ld3w, "ld3w", 0, IF_SVE_2BQ, 0xA540E000, 0xA540C000 ) +INST2(ld3w, "ld3w", LD, IF_SVE_2BQ, 0xA540E000, 0xA540C000 ) // LD3W {.S, .S, .S }, /Z, [{, #, MUL VL}] SVE_IS_3A 101001010100iiii 111gggnnnnnttttt A540 E000 // LD3W {.S, .S, .S }, /Z, [, , LSL #2] SVE_IT_4A 10100101010mmmmm 110gggnnnnnttttt A540 C000 -INST2(ld4b, "ld4b", 0, IF_SVE_2BQ, 0xA460E000, 0xA460C000 ) +INST2(ld4b, "ld4b", LD, IF_SVE_2BQ, 0xA460E000, 0xA460C000 ) // LD4B {.B, .B, .B, .B }, /Z, [{, #, MUL VL}]SVE_IS_3A 101001000110iiii 111gggnnnnnttttt A460 E000 // LD4B {.B, .B, .B, .B }, /Z, [, ] SVE_IT_4A 10100100011mmmmm 110gggnnnnnttttt A460 C000 -INST2(ld4d, "ld4d", 0, IF_SVE_2BQ, 0xA5E0E000, 0xA5E0C000 ) +INST2(ld4d, "ld4d", LD, IF_SVE_2BQ, 0xA5E0E000, 0xA5E0C000 ) // LD4D {.D, .D, .D, .D }, /Z, [{, #, MUL VL}]SVE_IS_3A 101001011110iiii 111gggnnnnnttttt A5E0 E000 // LD4D {.D, .D, .D, .D }, /Z, [, , LSL #3] SVE_IT_4A 10100101111mmmmm 110gggnnnnnttttt A5E0 C000 -INST2(ld4h, "ld4h", 0, IF_SVE_2BQ, 0xA4E0E000, 0xA4E0C000 ) +INST2(ld4h, "ld4h", LD, IF_SVE_2BQ, 0xA4E0E000, 0xA4E0C000 ) // LD4H {.H, .H, .H, .H }, /Z, [{, #, MUL VL}]SVE_IS_3A 101001001110iiii 111gggnnnnnttttt A4E0 E000 // LD4H {.H, .H, .H, .H }, /Z, [, , LSL #1] SVE_IT_4A 10100100111mmmmm 110gggnnnnnttttt A4E0 C000 -INST2(ld4w, "ld4w", 0, IF_SVE_2BQ, 0xA560E000, 0xA560C000 ) +INST2(ld4w, "ld4w", LD, IF_SVE_2BQ, 0xA560E000, 0xA560C000 ) // LD4W {.S, .S, .S, .S }, /Z, [{, #, MUL VL}]SVE_IS_3A 101001010110iiii 111gggnnnnnttttt A560 E000 // LD4W {.S, .S, .S, .S }, /Z, [, , LSL #2] SVE_IT_4A 10100101011mmmmm 110gggnnnnnttttt A560 C000 // enum name info SVE_JC_4A SVE_JO_3A -INST2(st2b, "st2b", 0, IF_SVE_2BR, 0xE4206000, 0xE430E000 ) +INST2(st2b, "st2b", ST, IF_SVE_2BR, 0xE4206000, 0xE430E000 ) // ST2B {.B, .B }, , [, ] SVE_JC_4A 11100100001mmmmm 011gggnnnnnttttt E420 6000 // ST2B {.B, .B }, , [{, #, MUL VL}] SVE_JO_3A 111001000011iiii 111gggnnnnnttttt E430 E000 -INST2(st2d, "st2d", 0, IF_SVE_2BR, 0xE5A06000, 0xE5B0E000 ) +INST2(st2d, "st2d", ST, IF_SVE_2BR, 0xE5A06000, 0xE5B0E000 ) // ST2D {.D, .D }, , [, , LSL #3] SVE_JC_4A 11100101101mmmmm 011gggnnnnnttttt E5A0 6000 // ST2D {.D, .D }, , [{, #, MUL VL}] SVE_JO_3A 111001011011iiii 111gggnnnnnttttt E5B0 E000 -INST2(st2h, "st2h", 0, IF_SVE_2BR, 0xE4A06000, 0xE4B0E000 ) +INST2(st2h, "st2h", ST, IF_SVE_2BR, 0xE4A06000, 0xE4B0E000 ) // ST2H {.H, .H }, , [, , LSL #1] SVE_JC_4A 11100100101mmmmm 011gggnnnnnttttt E4A0 6000 // ST2H {.H, .H }, , [{, #, MUL VL}] SVE_JO_3A 111001001011iiii 111gggnnnnnttttt E4B0 E000 -INST2(st2w, "st2w", 0, IF_SVE_2BR, 0xE5206000, 0xE530E000 ) +INST2(st2w, "st2w", ST, IF_SVE_2BR, 0xE5206000, 0xE530E000 ) // ST2W {.S, .S }, , [, , LSL #2] SVE_JC_4A 11100101001mmmmm 011gggnnnnnttttt E520 6000 // ST2W {.S, .S }, , [{, #, MUL VL}] SVE_JO_3A 111001010011iiii 111gggnnnnnttttt E530 E000 -INST2(st3b, "st3b", 0, IF_SVE_2BR, 0xE4406000, 0xE450E000 ) +INST2(st3b, "st3b", ST, IF_SVE_2BR, 0xE4406000, 0xE450E000 ) // ST3B {.B, .B, .B }, , [, ] SVE_JC_4A 11100100010mmmmm 011gggnnnnnttttt E440 6000 // ST3B {.B, .B, .B }, , [{, #, MUL VL}] SVE_JO_3A 111001000101iiii 111gggnnnnnttttt E450 E000 -INST2(st3d, "st3d", 0, IF_SVE_2BR, 0xE5C06000, 0xE5D0E000 ) +INST2(st3d, "st3d", ST, IF_SVE_2BR, 0xE5C06000, 0xE5D0E000 ) // ST3D {.D, .D, .D }, , [, , LSL #3] SVE_JC_4A 11100101110mmmmm 011gggnnnnnttttt E5C0 6000 // ST3D {.D, .D, .D }, , [{, #, MUL VL}] SVE_JO_3A 111001011101iiii 111gggnnnnnttttt E5D0 E000 -INST2(st3h, "st3h", 0, IF_SVE_2BR, 0xE4C06000, 0xE4D0E000 ) +INST2(st3h, "st3h", ST, IF_SVE_2BR, 0xE4C06000, 0xE4D0E000 ) // ST3H {.H, .H, .H }, , [, , LSL #1] SVE_JC_4A 11100100110mmmmm 011gggnnnnnttttt E4C0 6000 // ST3H {.H, .H, .H }, , [{, #, MUL VL}] SVE_JO_3A 111001001101iiii 111gggnnnnnttttt E4D0 E000 -INST2(st3w, "st3w", 0, IF_SVE_2BR, 0xE5406000, 0xE550E000 ) +INST2(st3w, "st3w", ST, IF_SVE_2BR, 0xE5406000, 0xE550E000 ) // ST3W {.S, .S, .S }, , [, , LSL #2] SVE_JC_4A 11100101010mmmmm 011gggnnnnnttttt E540 6000 // ST3W {.S, .S, .S }, , [{, #, MUL VL}] SVE_JO_3A 111001010101iiii 111gggnnnnnttttt E550 E000 -INST2(st4b, "st4b", 0, IF_SVE_2BR, 0xE4606000, 0xE470E000 ) +INST2(st4b, "st4b", ST, IF_SVE_2BR, 0xE4606000, 0xE470E000 ) // ST4B {.B, .B, .B, .B }, , [, ] SVE_JC_4A 11100100011mmmmm 011gggnnnnnttttt E460 6000 // ST4B {.B, .B, .B, .B }, , [{, #, MUL VL}] SVE_JO_3A 111001000111iiii 111gggnnnnnttttt E470 E000 -INST2(st4d, "st4d", 0, IF_SVE_2BR, 0xE5E06000, 0xE5F0E000 ) +INST2(st4d, "st4d", ST, IF_SVE_2BR, 0xE5E06000, 0xE5F0E000 ) // ST4D {.D, .D, .D, .D }, , [, , LSL #3] SVE_JC_4A 11100101111mmmmm 011gggnnnnnttttt E5E0 6000 // ST4D {.D, .D, .D, .D }, , [{, #, MUL VL}] SVE_JO_3A 111001011111iiii 111gggnnnnnttttt E5F0 E000 -INST2(st4h, "st4h", 0, IF_SVE_2BR, 0xE4E06000, 0xE4F0E000 ) +INST2(st4h, "st4h", ST, IF_SVE_2BR, 0xE4E06000, 0xE4F0E000 ) // ST4H {.H, .H, .H, .H }, , [, , LSL #1] SVE_JC_4A 11100100111mmmmm 011gggnnnnnttttt E4E0 6000 // ST4H {.H, .H, .H, .H }, , [{, #, MUL VL}] SVE_JO_3A 111001001111iiii 111gggnnnnnttttt E4F0 E000 -INST2(st4w, "st4w", 0, IF_SVE_2BR, 0xE5606000, 0xE570E000 ) +INST2(st4w, "st4w", ST, IF_SVE_2BR, 0xE5606000, 0xE570E000 ) // ST4W {.S, .S, .S, .S }, , [, , LSL #2] SVE_JC_4A 11100101011mmmmm 011gggnnnnnttttt E560 6000 // ST4W {.S, .S, .S, .S }, , [{, #, MUL VL}] SVE_JO_3A 111001010111iiii 111gggnnnnnttttt E570 E000 // enum name info SVE_JE_3A SVE_JF_4A -INST2(st2q, "st2q", 0, IF_SVE_2BS, 0xE4400000, 0xE4600000 ) +INST2(st2q, "st2q", ST, IF_SVE_2BS, 0xE4400000, 0xE4600000 ) // ST2Q {.Q, .Q }, , [{, #, MUL VL}] SVE_JE_3A 111001000100iiii 000gggnnnnnttttt E440 0000 // ST2Q {.Q, .Q }, , [, , LSL #4] SVE_JF_4A 11100100011mmmmm 000gggnnnnnttttt E460 0000 -INST2(st3q, "st3q", 0, IF_SVE_2BS, 0xE4800000, 0xE4A00000 ) +INST2(st3q, "st3q", ST, IF_SVE_2BS, 0xE4800000, 0xE4A00000 ) // ST3Q {.Q, .Q, .Q }, , [{, #, MUL VL}] SVE_JE_3A 111001001000iiii 000gggnnnnnttttt E480 0000 // ST3Q {.Q, .Q, .Q }, , [, , LSL #4] SVE_JF_4A 11100100101mmmmm 000gggnnnnnttttt E4A0 0000 -INST2(st4q, "st4q", 0, IF_SVE_2BS, 0xE4C00000, 0xE4E00000 ) +INST2(st4q, "st4q", ST, IF_SVE_2BS, 0xE4C00000, 0xE4E00000 ) // ST4Q {.Q, .Q, .Q, .Q }, , [{, #, MUL VL}] SVE_JE_3A 111001001100iiii 000gggnnnnnttttt E4C0 0000 // ST4Q {.Q, .Q, .Q, .Q }, , [, , LSL #4] SVE_JF_4A 11100100111mmmmm 000gggnnnnnttttt E4E0 0000 @@ -1791,19 +1791,19 @@ INST1(ftsmul, "ftsmul", 0, IF_SV // FTSMUL ., ., . SVE_AT_3A 01100101xx0mmmmm 000011nnnnnddddd 6500 0C00 // enum name info SVE_HT_4A -INST1(facge, "facge", 0, IF_SVE_HT_4A, 0x6500C010 ) +INST1(facge, "facge", CMP, IF_SVE_HT_4A, 0x6500C010 ) // FACGE ., /Z, ., . SVE_HT_4A 01100101xx0mmmmm 110gggnnnnn1DDDD 6500 C010 -INST1(facgt, "facgt", 0, IF_SVE_HT_4A, 0x6500E010 ) +INST1(facgt, "facgt", CMP, IF_SVE_HT_4A, 0x6500E010 ) // FACGT ., /Z, ., . SVE_HT_4A 01100101xx0mmmmm 111gggnnnnn1DDDD 6500 E010 -INST1(facle, "facle", 0, IF_SVE_HT_4A, 0x6500C010 ) +INST1(facle, "facle", CMP, IF_SVE_HT_4A, 0x6500C010 ) // FACLE ., /Z, ., . SVE_HT_4A 01100101xx0mmmmm 110gggnnnnn1DDDD 6500 C010 -INST1(faclt, "faclt", 0, IF_SVE_HT_4A, 0x6500E010 ) +INST1(faclt, "faclt", CMP, IF_SVE_HT_4A, 0x6500E010 ) // FACLT ., /Z, ., . SVE_HT_4A 01100101xx0mmmmm 111gggnnnnn1DDDD 6500 E010 -INST1(fcmuo, "fcmuo", 0, IF_SVE_HT_4A, 0x6500C000 ) +INST1(fcmuo, "fcmuo", CMP, IF_SVE_HT_4A, 0x6500C000 ) // FCMUO ., /Z, ., . SVE_HT_4A 01100101xx0mmmmm 110gggnnnnn0DDDD 6500 C000 @@ -2769,75 +2769,75 @@ INST1(fnmsb, "fnmsb", 0, IF_SV // enum name info SVE_IC_3A_C -INST1(ld1rb, "ld1rb", 0, IF_SVE_IC_3A_C, 0x84408000 ) +INST1(ld1rb, "ld1rb", LD, IF_SVE_IC_3A_C, 0x84408000 ) // LD1RB {.D }, /Z, [{, #}] SVE_IC_3A_C 1000010001iiiiii 100gggnnnnnttttt 8440 8000 // enum name info SVE_IC_3A -INST1(ld1rd, "ld1rd", 0, IF_SVE_IC_3A, 0x85C0E000 ) +INST1(ld1rd, "ld1rd", LD, IF_SVE_IC_3A, 0x85C0E000 ) // LD1RD {.D }, /Z, [{, #}] SVE_IC_3A 1000010111iiiiii 111gggnnnnnttttt 85C0 E000 -INST1(ld1rsw, "ld1rsw", 0, IF_SVE_IC_3A, 0x84C08000 ) +INST1(ld1rsw, "ld1rsw", LD, IF_SVE_IC_3A, 0x84C08000 ) // LD1RSW {.D }, /Z, [{, #}] SVE_IC_3A 1000010011iiiiii 100gggnnnnnttttt 84C0 8000 // enum name info SVE_IC_3A_B -INST1(ld1rh, "ld1rh", 0, IF_SVE_IC_3A_B, 0x84C08000 ) +INST1(ld1rh, "ld1rh", LD, IF_SVE_IC_3A_B, 0x84C08000 ) // LD1RH {.D }, /Z, [{, #}] SVE_IC_3A_B 1000010011iiiiii 100gggnnnnnttttt 84C0 8000 -INST1(ld1rsb, "ld1rsb", 0, IF_SVE_IC_3A_B, 0x85C08000 ) +INST1(ld1rsb, "ld1rsb", LD, IF_SVE_IC_3A_B, 0x85C08000 ) // LD1RSB {.D }, /Z, [{, #}] SVE_IC_3A_B 1000010111iiiiii 100gggnnnnnttttt 85C0 8000 // enum name info SVE_IC_3A_A -INST1(ld1rsh, "ld1rsh", 0, IF_SVE_IC_3A_A, 0x85408000 ) +INST1(ld1rsh, "ld1rsh", LD, IF_SVE_IC_3A_A, 0x85408000 ) // LD1RSH {.D }, /Z, [{, #}] SVE_IC_3A_A 1000010101iiiiii 100gggnnnnnttttt 8540 8000 -INST1(ld1rw, "ld1rw", 0, IF_SVE_IC_3A_A, 0x8540C000 ) +INST1(ld1rw, "ld1rw", LD, IF_SVE_IC_3A_A, 0x8540C000 ) // LD1RW {.D }, /Z, [{, #}] SVE_IC_3A_A 1000010101iiiiii 110gggnnnnnttttt 8540 C000 // enum name info SVE_IL_3A_C -INST1(ldnf1b, "ldnf1b", 0, IF_SVE_IL_3A_C, 0xA410A000 ) +INST1(ldnf1b, "ldnf1b", LD, IF_SVE_IL_3A_C, 0xA410A000 ) // LDNF1B {.B }, /Z, [{, #, MUL VL}] SVE_IL_3A_C 101001000001iiii 101gggnnnnnttttt A410 A000 // enum name info SVE_IL_3A -INST1(ldnf1d, "ldnf1d", 0, IF_SVE_IL_3A, 0xA5F0A000 ) +INST1(ldnf1d, "ldnf1d", LD, IF_SVE_IL_3A, 0xA5F0A000 ) // LDNF1D {.D }, /Z, [{, #, MUL VL}] SVE_IL_3A 101001011111iiii 101gggnnnnnttttt A5F0 A000 -INST1(ldnf1sw, "ldnf1sw", 0, IF_SVE_IL_3A, 0xA490A000 ) +INST1(ldnf1sw, "ldnf1sw", LD, IF_SVE_IL_3A, 0xA490A000 ) // LDNF1SW {.D }, /Z, [{, #, MUL VL}] SVE_IL_3A 101001001001iiii 101gggnnnnnttttt A490 A000 // enum name info SVE_IL_3A_B -INST1(ldnf1h, "ldnf1h", 0, IF_SVE_IL_3A_B, 0xA490A000 ) +INST1(ldnf1h, "ldnf1h", LD, IF_SVE_IL_3A_B, 0xA490A000 ) // LDNF1H {.X }, /Z, [{, #, MUL VL}] SVE_IL_3A_B 101001001001iiii 101gggnnnnnttttt A490 A000 -INST1(ldnf1sb, "ldnf1sb", 0, IF_SVE_IL_3A_B, 0xA590A000 ) +INST1(ldnf1sb, "ldnf1sb", LD, IF_SVE_IL_3A_B, 0xA590A000 ) // LDNF1SB {.D }, /Z, [{, #, MUL VL}] SVE_IL_3A_B 101001011001iiii 101gggnnnnnttttt A590 A000 // enum name info SVE_IL_3A_A -INST1(ldnf1sh, "ldnf1sh", 0, IF_SVE_IL_3A_A, 0xA510A000 ) +INST1(ldnf1sh, "ldnf1sh", LD, IF_SVE_IL_3A_A, 0xA510A000 ) // LDNF1SH {.D }, /Z, [{, #, MUL VL}] SVE_IL_3A_A 101001010001iiii 101gggnnnnnttttt A510 A000 -INST1(ldnf1w, "ldnf1w", 0, IF_SVE_IL_3A_A, 0xA550A000 ) +INST1(ldnf1w, "ldnf1w", LD, IF_SVE_IL_3A_A, 0xA550A000 ) // LDNF1W {.S }, /Z, [{, #, MUL VL}] SVE_IL_3A_A 101001010101iiii 101gggnnnnnttttt A550 A000 // enum name info SVE_IW_4A -INST1(ld1q, "ld1q", 0, IF_SVE_IW_4A, 0xC400A000 ) +INST1(ld1q, "ld1q", LD, IF_SVE_IW_4A, 0xC400A000 ) // LD1Q {.Q }, /Z, [.D{, }] SVE_IW_4A 11000100000mmmmm 101gggnnnnnttttt C400 A000 // enum name info SVE_IX_4A -INST1(ldnt1sw, "ldnt1sw", 0, IF_SVE_IX_4A, 0xC5008000 ) +INST1(ldnt1sw, "ldnt1sw", LD, IF_SVE_IX_4A, 0xC5008000 ) // LDNT1SW {.D }, /Z, [.D{, }] SVE_IX_4A 11000101000mmmmm 100gggnnnnnttttt C500 8000 // enum name info SVE_IY_4A -INST1(st1q, "st1q", 0, IF_SVE_IY_4A, 0xE4202000 ) +INST1(st1q, "st1q", ST, IF_SVE_IY_4A, 0xE4202000 ) // ST1Q {.Q }, , [.D{, }] SVE_IY_4A 11100100001mmmmm 001gggnnnnnttttt E420 2000 // clang-format on diff --git a/src/coreclr/jit/instrsxarch.h b/src/coreclr/jit/instrsxarch.h index 9d835239ba3..f365880bcbf 100644 --- a/src/coreclr/jit/instrsxarch.h +++ b/src/coreclr/jit/instrsxarch.h @@ -610,18 +610,18 @@ INST3(LAST_AVX_INSTRUCTION, "LAST_AVX_INSTRUCTION", IUM_WR, BAD_CODE, BAD_CODE, INST3(FIRST_AVX512_INSTRUCTION, "FIRST_AVX512_INSTRUCTION", IUM_WR, BAD_CODE, BAD_CODE, BAD_CODE, INS_TT_NONE, INS_FLAGS_None) // AVX512F -INST3(kandw, "kandw", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x41), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction) // Bitwise logical AND masks -INST3(kandnw, "kandnw", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x42), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction) // Bitwise logical AND NOT masks +INST3(kandw, "kandw", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x41), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Bitwise logical AND masks +INST3(kandnw, "kandnw", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x42), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Bitwise logical AND NOT masks INST3(kmovw_gpr, "kmovw", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x92), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction) // Move from and to mask registers INST3(kmovw_msk, "kmovw", IUM_WR, PCKFLT(0x91), BAD_CODE, PCKFLT(0x90), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction) // Move from and to mask registers INST3(knotw, "knotw", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x44), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction) // NOT mask register -INST3(korw, "korw", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x45), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction) // Bitwise logical OR masks +INST3(korw, "korw", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x45), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Bitwise logical OR masks INST3(kortestw, "kortestw", IUM_RD, BAD_CODE, BAD_CODE, PCKFLT(0x98), INS_TT_NONE, REX_W0 | Encoding_VEX | Resets_OF | Resets_SF | Writes_ZF | Resets_AF | Resets_PF | Writes_CF | KInstruction) // OR masks and set flags INST3(kshiftlw, "kshiftlw", IUM_WR, BAD_CODE, BAD_CODE, SSE3A(0x32), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction) // Shift left mask registers INST3(kshiftrw, "kshiftrw", IUM_WR, BAD_CODE, BAD_CODE, SSE3A(0x30), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction) // Shift right mask registers -INST3(kunpckbw, "kunpckbw", IUM_RD, BAD_CODE, BAD_CODE, PCKDBL(0x4B), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction) // Unpack for mask registers -INST3(kxnorw, "kxnorw", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x46), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction) // Bitwise logical XNOR masks -INST3(kxorw, "kxorw", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x47), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction) // Bitwise logical XOR masks +INST3(kunpckbw, "kunpckbw", IUM_RD, BAD_CODE, BAD_CODE, PCKDBL(0x4B), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Unpack for mask registers +INST3(kxnorw, "kxnorw", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x46), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Bitwise logical XNOR masks +INST3(kxorw, "kxorw", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x47), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Bitwise logical XOR masks INST3(valignd, "alignd", IUM_WR, BAD_CODE, BAD_CODE, SSE3A(0x03), INS_TT_FULL, Input_32Bit | REX_W0 | Encoding_EVEX | INS_Flags_IsDstDstSrcAVXInstruction | INS_Flags_EmbeddedBroadcastSupported) // Align doubleword vectors INST3(valignq, "alignq", IUM_WR, BAD_CODE, BAD_CODE, SSE3A(0x03), INS_TT_FULL, Input_64Bit | REX_W1 | Encoding_EVEX | INS_Flags_IsDstDstSrcAVXInstruction | INS_Flags_EmbeddedBroadcastSupported) // Align quadword vectors INST3(vblendmpd, "blendmpd", IUM_WR, BAD_CODE, BAD_CODE, SSE38(0x65), INS_TT_FULL, Input_64Bit | REX_W1 | Encoding_EVEX | INS_Flags_IsDstDstSrcAVXInstruction | INS_Flags_EmbeddedBroadcastSupported) // Blend Float64 vectors using an OpMask control @@ -756,20 +756,20 @@ INST3(vshufi32x4, "shufi32x4", IUM_WR, BAD_CODE, BAD_ INST3(vshufi64x2, "shufi64x2", IUM_WR, BAD_CODE, BAD_CODE, SSE3A(0x43), INS_TT_FULL, Input_64Bit | REX_W1 | Encoding_EVEX | INS_Flags_IsDstDstSrcAVXInstruction | INS_Flags_EmbeddedBroadcastSupported) // Shuffle packed values at 128-bit granularity // AVX512BW -INST3(kaddd, "kaddd", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x4A), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction) // Add two masks -INST3(kaddq, "kaddq", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x4A), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction) // Add two masks -INST3(kandd, "kandd", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x41), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction) // Bitwise logical AND masks -INST3(kandq, "kandq", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x41), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction) // Bitwise logical AND masks -INST3(kandnd, "kandnd", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x42), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction) // Bitwise logical AND NOT masks -INST3(kandnq, "kandnq", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x42), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction) // Bitwise logical AND NOT masks +INST3(kaddd, "kaddd", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x4A), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Add two masks +INST3(kaddq, "kaddq", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x4A), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Add two masks +INST3(kandd, "kandd", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x41), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Bitwise logical AND masks +INST3(kandq, "kandq", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x41), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Bitwise logical AND masks +INST3(kandnd, "kandnd", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x42), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Bitwise logical AND NOT masks +INST3(kandnq, "kandnq", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x42), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Bitwise logical AND NOT masks INST3(kmovd_gpr, "kmovd", IUM_WR, BAD_CODE, BAD_CODE, SSEDBL(0x92), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction) // Move from and to mask registers INST3(kmovd_msk, "kmovd", IUM_WR, PCKDBL(0x91), BAD_CODE, PCKDBL(0x90), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction) // Move from and to mask registers INST3(kmovq_gpr, "kmovq", IUM_WR, BAD_CODE, BAD_CODE, SSEDBL(0x92), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction) // Move from and to mask registers INST3(kmovq_msk, "kmovq", IUM_WR, PCKFLT(0x91), BAD_CODE, PCKFLT(0x90), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction) // Move from and to mask registers INST3(knotd, "knotd", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x44), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction) // NOT mask register INST3(knotq, "knotq", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x44), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction) // NOT mask register -INST3(kord, "kord", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x45), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction) // Bitwise logical OR masks -INST3(korq, "korq", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x45), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction) // Bitwise logical OR masks +INST3(kord, "kord", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x45), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Bitwise logical OR masks +INST3(korq, "korq", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x45), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Bitwise logical OR masks INST3(kortestd, "kortestd", IUM_RD, BAD_CODE, BAD_CODE, PCKDBL(0x98), INS_TT_NONE, REX_W1 | Encoding_VEX | Resets_OF | Resets_SF | Writes_ZF | Resets_AF | Resets_PF | Writes_CF | KInstruction) // OR masks and set flags INST3(kortestq, "kortestq", IUM_RD, BAD_CODE, BAD_CODE, PCKFLT(0x98), INS_TT_NONE, REX_W1 | Encoding_VEX | Resets_OF | Resets_SF | Writes_ZF | Resets_AF | Resets_PF | Writes_CF | KInstruction) // OR masks and set flags INST3(kshiftld, "kshiftld", IUM_WR, BAD_CODE, BAD_CODE, SSE3A(0x33), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction) // Shift left mask registers @@ -778,12 +778,12 @@ INST3(kshiftrd, "kshiftrd", IUM_WR, BAD_CODE, BAD_ INST3(kshiftrq, "kshiftrq", IUM_WR, BAD_CODE, BAD_CODE, SSE3A(0x31), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction) // Shift right mask registers INST3(ktestd, "ktestd", IUM_RD, BAD_CODE, BAD_CODE, PCKDBL(0x99), INS_TT_NONE, REX_W1 | Encoding_VEX | Resets_OF | Resets_SF | Writes_ZF | Resets_AF | Resets_PF | Writes_CF | KInstruction) // Packed bit test masks and set flags INST3(ktestq, "ktestq", IUM_RD, BAD_CODE, BAD_CODE, PCKFLT(0x99), INS_TT_NONE, REX_W1 | Encoding_VEX | Resets_OF | Resets_SF | Writes_ZF | Resets_AF | Resets_PF | Writes_CF | KInstruction) // Packed bit test masks and set flags -INST3(kunpckdq, "kunpckdq", IUM_RD, BAD_CODE, BAD_CODE, PCKFLT(0x4B), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction) // Unpack for mask registers -INST3(kunpckwd, "kunpckwd", IUM_RD, BAD_CODE, BAD_CODE, PCKFLT(0x4B), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction) // Unpack for mask registers -INST3(kxnord, "kxnord", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x46), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction) // Bitwise logical XNOR masks -INST3(kxnorq, "kxnorq", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x46), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction) // Bitwise logical XNOR masks -INST3(kxord, "kxord", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x47), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction) // Bitwise logical XOR masks -INST3(kxorq, "kxorq", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x47), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction) // Bitwise logical XOR masks +INST3(kunpckdq, "kunpckdq", IUM_RD, BAD_CODE, BAD_CODE, PCKFLT(0x4B), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Unpack for mask registers +INST3(kunpckwd, "kunpckwd", IUM_RD, BAD_CODE, BAD_CODE, PCKFLT(0x4B), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Unpack for mask registers +INST3(kxnord, "kxnord", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x46), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Bitwise logical XNOR masks +INST3(kxnorq, "kxnorq", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x46), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Bitwise logical XNOR masks +INST3(kxord, "kxord", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x47), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Bitwise logical XOR masks +INST3(kxorq, "kxorq", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x47), INS_TT_NONE, REX_W1 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Bitwise logical XOR masks INST3(vpblendmd, "pblendmd", IUM_WR, BAD_CODE, BAD_CODE, SSE38(0x64), INS_TT_FULL, Input_32Bit | REX_W0 | Encoding_EVEX | INS_Flags_IsDstDstSrcAVXInstruction | INS_Flags_EmbeddedBroadcastSupported) // Blend Byte vectors using an OpMask control INST3(vpblendmw, "pblendmw", IUM_WR, BAD_CODE, BAD_CODE, SSE38(0x66), INS_TT_FULL_MEM, Input_16Bit | REX_W1 | Encoding_EVEX | INS_Flags_IsDstDstSrcAVXInstruction) // Blend Word vectors using an OpMask control INST3(vdbpsadbw, "dbpsadbw", IUM_WR, BAD_CODE, BAD_CODE, SSE3A(0x42), INS_TT_FULL_MEM, Input_8Bit | REX_W0 | Encoding_EVEX | INS_Flags_IsDstDstSrcAVXInstruction) // Double block packed Sum-Absolute-Differences (SAD) on unsigned bytes @@ -824,21 +824,21 @@ INST3(vplzcntd, "plzcntd", IUM_WR, BAD_CODE, BAD_ INST3(vplzcntq, "plzcntq", IUM_WR, BAD_CODE, BAD_CODE, SSE38(0x44), INS_TT_FULL, Input_64Bit | REX_W1 | Encoding_EVEX | INS_Flags_EmbeddedBroadcastSupported) // Count the number of leading zero bits for packed qword values // AVX512DQ -INST3(kaddb, "kaddb", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x4A), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction) // Add two masks -INST3(kaddw, "kaddw", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x4A), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction) // Add two masks -INST3(kandb, "kandb", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x41), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction) // Bitwise logical AND masks -INST3(kandnb, "kandnb", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x42), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction) // Bitwise logical AND NOT masks +INST3(kaddb, "kaddb", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x4A), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Add two masks +INST3(kaddw, "kaddw", IUM_WR, BAD_CODE, BAD_CODE, PCKFLT(0x4A), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Add two masks +INST3(kandb, "kandb", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x41), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Bitwise logical AND masks +INST3(kandnb, "kandnb", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x42), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Bitwise logical AND NOT masks INST3(kmovb_gpr, "kmovb", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x92), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction) // Move from and to mask registers INST3(kmovb_msk, "kmovb", IUM_WR, PCKDBL(0x91), BAD_CODE, PCKDBL(0x90), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction) // Move from and to mask registers INST3(knotb, "knotb", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x44), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction) // NOT mask register -INST3(korb, "korb", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x45), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction) // Bitwise logical OR masks +INST3(korb, "korb", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x45), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Bitwise logical OR masks INST3(kortestb, "kortestb", IUM_RD, BAD_CODE, BAD_CODE, PCKDBL(0x98), INS_TT_NONE, REX_W0 | Encoding_VEX | Resets_OF | Resets_SF | Writes_ZF | Resets_AF | Resets_PF | Writes_CF | KInstruction) // OR masks and set flags INST3(kshiftlb, "kshiftlb", IUM_WR, BAD_CODE, BAD_CODE, SSE3A(0x32), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction) // Shift left mask registers INST3(kshiftrb, "kshiftrb", IUM_WR, BAD_CODE, BAD_CODE, SSE3A(0x30), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction) // Shift right mask registers INST3(ktestb, "ktestb", IUM_RD, BAD_CODE, BAD_CODE, PCKDBL(0x99), INS_TT_NONE, REX_W0 | Encoding_VEX | Resets_OF | Resets_SF | Writes_ZF | Resets_AF | Resets_PF | Writes_CF | KInstruction) // Packed bit test masks and set flags INST3(ktestw, "ktestw", IUM_RD, BAD_CODE, BAD_CODE, PCKFLT(0x99), INS_TT_NONE, REX_W0 | Encoding_VEX | Resets_OF | Resets_SF | Writes_ZF | Resets_AF | Resets_PF | Writes_CF | KInstruction) // Packed bit test masks and set flags -INST3(kxnorb, "kxnorb", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x46), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction) // Bitwise logical XNOR masks -INST3(kxorb, "kxorb", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x47), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction) // Bitwise logical XOR masks +INST3(kxnorb, "kxnorb", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x46), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Bitwise logical XNOR masks +INST3(kxorb, "kxorb", IUM_WR, BAD_CODE, BAD_CODE, PCKDBL(0x47), INS_TT_NONE, REX_W0 | Encoding_VEX | KInstruction | KInstructionWithLBit) // Bitwise logical XOR masks INST3(vbroadcastf32x2, "broadcastf32x2", IUM_WR, BAD_CODE, BAD_CODE, SSE38(0x19), INS_TT_TUPLE2, Input_32Bit | REX_W0 | Encoding_EVEX) // Broadcast packed float values read from memory to entire register INST3(vbroadcasti32x2, "broadcasti32x2", IUM_WR, BAD_CODE, BAD_CODE, SSE38(0x59), INS_TT_TUPLE2, Input_32Bit | REX_W0 | Encoding_EVEX) // Broadcast packed integer values read from memory to entire register INST3(vbroadcastf32x8, "broadcastf32x8", IUM_WR, BAD_CODE, BAD_CODE, SSE38(0x1B), INS_TT_TUPLE8, Input_32Bit | REX_W0 | Encoding_EVEX) // Broadcast packed float values read from memory to entire register diff --git a/src/coreclr/jit/jitconfigvalues.h b/src/coreclr/jit/jitconfigvalues.h index 9c22acb9b98..eb8ab7e1fb0 100644 --- a/src/coreclr/jit/jitconfigvalues.h +++ b/src/coreclr/jit/jitconfigvalues.h @@ -683,6 +683,9 @@ RELEASE_CONFIG_INTEGER(TC_OnStackReplacement_InitialCounter, W("TC_OnStackReplac // Enable partial compilation for Tier0 methods RELEASE_CONFIG_INTEGER(TC_PartialCompilation, W("TC_PartialCompilation"), 0) +// If partial compilation is enabled, use random heuristic for patchpoint placement +CONFIG_INTEGER(JitRandomPartialCompilation, W("JitRandomPartialCompilation"), 0) + // Patchpoint strategy: // 0 - backedge sources // 1 - backedge targets @@ -775,6 +778,9 @@ RELEASE_CONFIG_INTEGER(JitDoReversePostOrderLayout, W("JitDoReversePostOrderLayo // Enable strength reduction RELEASE_CONFIG_INTEGER(JitEnableStrengthReduction, W("JitEnableStrengthReduction"), 1) +// Enable IV optimizations +RELEASE_CONFIG_INTEGER(JitEnableInductionVariableOpts, W("JitEnableInductionVariableOpts"), 1) + // JitFunctionFile: Name of a file that contains a list of functions. If the currently compiled function is in the // file, certain other JIT config variables will be active. If the currently compiled function is not in the file, // the specific JIT config variables will not be active. diff --git a/src/coreclr/jit/jiteh.cpp b/src/coreclr/jit/jiteh.cpp index 313f42563d7..58abd897b9c 100644 --- a/src/coreclr/jit/jiteh.cpp +++ b/src/coreclr/jit/jiteh.cpp @@ -4519,31 +4519,3 @@ bool Compiler::fgCheckEHCanInsertAfterBlock(BasicBlock* blk, unsigned regionInde return insertOK; } - -//------------------------------------------------------------------------ -// fgIsFirstBlockOfFilterOrHandler: return true if the given block is the first block of an EH handler -// or filter. -// -// Arguments: -// block - the BasicBlock in question -// -// Return Value: -// As described above. -// -bool Compiler::fgIsFirstBlockOfFilterOrHandler(BasicBlock* block) -{ - if (!block->hasHndIndex()) - { - return false; - } - EHblkDsc* ehDsc = ehGetDsc(block->getHndIndex()); - if (ehDsc->ebdHndBeg == block) - { - return true; - } - if (ehDsc->HasFilter() && (ehDsc->ebdFilter == block)) - { - return true; - } - return false; -} diff --git a/src/coreclr/jit/lclvars.cpp b/src/coreclr/jit/lclvars.cpp index 6140bac510b..9243beac081 100644 --- a/src/coreclr/jit/lclvars.cpp +++ b/src/coreclr/jit/lclvars.cpp @@ -33,76 +33,6 @@ unsigned Compiler::s_lvaDoubleAlignedProcsCount = 0; /*****************************************************************************/ -void Compiler::lvaInit() -{ - lvaParameterPassingInfo = nullptr; - lvaParameterStackSize = 0; - - /* We haven't allocated stack variables yet */ - lvaRefCountState = RCS_INVALID; - - lvaGenericsContextInUse = false; - - lvaTrackedToVarNumSize = 0; - lvaTrackedToVarNum = nullptr; - - lvaTrackedFixed = false; // false: We can still add new tracked variables - - lvaDoneFrameLayout = NO_FRAME_LAYOUT; -#if defined(FEATURE_EH_WINDOWS_X86) - lvaShadowSPslotsVar = BAD_VAR_NUM; -#endif // FEATURE_EH_WINDOWS_X86 - lvaInlinedPInvokeFrameVar = BAD_VAR_NUM; - lvaReversePInvokeFrameVar = BAD_VAR_NUM; -#if FEATURE_FIXED_OUT_ARGS - lvaOutgoingArgSpaceVar = BAD_VAR_NUM; - lvaOutgoingArgSpaceSize = PhasedVar(); -#endif // FEATURE_FIXED_OUT_ARGS -#ifdef JIT32_GCENCODER - lvaLocAllocSPvar = BAD_VAR_NUM; -#endif // JIT32_GCENCODER - lvaNewObjArrayArgs = BAD_VAR_NUM; - lvaGSSecurityCookie = BAD_VAR_NUM; -#ifdef TARGET_ARM64 - lvaFfrRegister = BAD_VAR_NUM; -#endif -#ifdef TARGET_X86 - lvaVarargsBaseOfStkArgs = BAD_VAR_NUM; -#endif // TARGET_X86 - lvaVarargsHandleArg = BAD_VAR_NUM; - lvaStubArgumentVar = BAD_VAR_NUM; - lvaArg0Var = BAD_VAR_NUM; - lvaMonAcquired = BAD_VAR_NUM; - lvaRetAddrVar = BAD_VAR_NUM; - -#ifdef SWIFT_SUPPORT - lvaSwiftSelfArg = BAD_VAR_NUM; - lvaSwiftIndirectResultArg = BAD_VAR_NUM; - lvaSwiftErrorArg = BAD_VAR_NUM; -#endif - - lvaInlineeReturnSpillTemp = BAD_VAR_NUM; - - gsShadowVarInfo = nullptr; - lvaPSPSym = BAD_VAR_NUM; -#if FEATURE_SIMD - lvaSIMDInitTempVarNum = BAD_VAR_NUM; -#endif // FEATURE_SIMD - lvaCurEpoch = 0; - -#if defined(DEBUG) && defined(TARGET_XARCH) - lvaReturnSpCheck = BAD_VAR_NUM; -#endif - -#if defined(DEBUG) && defined(TARGET_X86) - lvaCallSpCheck = BAD_VAR_NUM; -#endif - - structPromotionHelper = new (this, CMK_Promotion) StructPromotionHelper(this); -} - -/*****************************************************************************/ - void Compiler::lvaInitTypeRef() { @@ -655,6 +585,19 @@ void Compiler::lvaInitUserArgs(InitVarDscInfo* varDscInfo, unsigned skipArgs, un CorInfoTypeWithMod corInfoType = info.compCompHnd->getArgType(&info.compMethodInfo->args, argLst, &typeHnd); varDsc->lvIsParam = 1; +#if defined(TARGET_X86) && defined(FEATURE_IJW) + if ((corInfoType & CORINFO_TYPE_MOD_COPY_WITH_HELPER) != 0) + { + CorInfoType typeWithoutMod = strip(corInfoType); + if (typeWithoutMod == CORINFO_TYPE_VALUECLASS || typeWithoutMod == CORINFO_TYPE_PTR || + typeWithoutMod == CORINFO_TYPE_BYREF) + { + JITDUMP("Marking user arg%02u as requiring special copy semantics\n", i); + recordArgRequiresSpecialCopy(i); + } + } +#endif // TARGET_X86 && FEATURE_IJW + lvaInitVarDsc(varDsc, varDscInfo->varNum, strip(corInfoType), typeHnd, argLst, &info.compMethodInfo->args); if (strip(corInfoType) == CORINFO_TYPE_CLASS) diff --git a/src/coreclr/jit/llvm.cpp b/src/coreclr/jit/llvm.cpp index 7390c3afbf8..d22e958da5e 100644 --- a/src/coreclr/jit/llvm.cpp +++ b/src/coreclr/jit/llvm.cpp @@ -422,7 +422,6 @@ bool Llvm::helperCallMayPhysicallyThrow(CorInfoHelpFunc helperFunc) const { FUNC(CORINFO_HELP_PROF_FCN_ENTER) }, { FUNC(CORINFO_HELP_PROF_FCN_LEAVE) }, { FUNC(CORINFO_HELP_PROF_FCN_TAILCALL) }, - { FUNC(CORINFO_HELP_BBT_FCN_ENTER) }, // Not used in NativeAOT. { FUNC(CORINFO_HELP_PINVOKE_CALLI) }, @@ -446,9 +445,7 @@ bool Llvm::helperCallMayPhysicallyThrow(CorInfoHelpFunc helperFunc) const // Not used in NativeAOT. { FUNC(CORINFO_HELP_RUNTIMEHANDLE_METHOD) }, - { FUNC(CORINFO_HELP_RUNTIMEHANDLE_METHOD_LOG) }, { FUNC(CORINFO_HELP_RUNTIMEHANDLE_CLASS) }, - { FUNC(CORINFO_HELP_RUNTIMEHANDLE_CLASS_LOG) }, // Implemented in "CoreLib\src\Internal\Runtime\CompilerHelpers\TypedReferenceHelpers.cs". { FUNC(CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE) CORINFO_TYPE_CLASS, { CORINFO_TYPE_PTR }, HFIF_SS_ARG }, diff --git a/src/coreclr/jit/lower.cpp b/src/coreclr/jit/lower.cpp index 77776a903d4..d92895a9d49 100644 --- a/src/coreclr/jit/lower.cpp +++ b/src/coreclr/jit/lower.cpp @@ -1994,9 +1994,148 @@ void Lowering::LowerArgsForCall(GenTreeCall* call) LowerArg(call, &arg, true); } +#if defined(TARGET_X86) && defined(FEATURE_IJW) + LowerSpecialCopyArgs(call); +#endif // defined(TARGET_X86) && defined(FEATURE_IJW) + LegalizeArgPlacement(call); } +#if defined(TARGET_X86) && defined(FEATURE_IJW) +//------------------------------------------------------------------------ +// LowerSpecialCopyArgs: Lower special copy arguments for P/Invoke IL stubs +// +// Arguments: +// call - the call node +// +// Notes: +// This method is used for P/Invoke IL stubs on x86 to handle arguments with special copy semantics. +// In particular, this method implements copy-constructor semantics for managed-to-unmanaged IL stubs +// for C++/CLI. In this case, the managed argument is passed by (managed or unmanaged) pointer in the +// P/Invoke signature with a speial modreq, but is passed to the unmanaged function by value. +// The value passed to the unmanaged function must be created through a copy-constructor call copying from +// the original source argument. +// We assume that the IL stub will be generated such that the following holds true: +// - If an argument to the IL stub has the special modreq, then its corresponding argument to the +// unmanaged function will be passed as the same argument index. Therefore, we can introduce the copy call +// from the original source argument to the argument slot in the unmanaged call. +void Lowering::LowerSpecialCopyArgs(GenTreeCall* call) +{ + // We only need to use the special copy helper on P/Invoke IL stubs + // for the unmanaged call. + if (comp->opts.jitFlags->IsSet(JitFlags::JIT_FLAG_IL_STUB) && comp->compMethodRequiresPInvokeFrame() && + call->IsUnmanaged() && comp->compHasSpecialCopyArgs()) + { + // Unmanaged calling conventions on Windows x86 are passed in reverse order + // of managed args, so we need to count down the number of args. + // If the call is thiscall, we need to account for the this parameter, + // which will be first in the list. + // The this parameter is always passed in registers, so we can ignore it. + unsigned argIndex = call->gtArgs.CountUserArgs() - 1; + assert(call->gtArgs.CountUserArgs() == comp->info.compILargsCount); + for (CallArg& arg : call->gtArgs.Args()) + { + if (!arg.IsUserArg()) + { + continue; + } + + if (call->GetUnmanagedCallConv() == CorInfoCallConvExtension::Thiscall && + argIndex == call->gtArgs.CountUserArgs() - 1) + { + assert(arg.GetNode()->OperIs(GT_PUTARG_REG)); + continue; + } + + unsigned paramLclNum = comp->compMapILargNum(argIndex); + assert(paramLclNum < comp->info.compArgsCount); + + // check if parameter at the same index as the IL argument is marked as requiring special copy, assuming + // that it is being passed 1:1 to the pinvoke + if (comp->argRequiresSpecialCopy(paramLclNum) && (arg.GetSignatureType() == TYP_STRUCT)) + { + assert(arg.GetNode()->OperIs(GT_PUTARG_STK)); + InsertSpecialCopyArg(arg.GetNode()->AsPutArgStk(), arg.GetSignatureClassHandle(), paramLclNum); + } + + argIndex--; + } + } +} + +//------------------------------------------------------------------------ +// InsertSpecialCopyArg: Insert a call to the special copy helper to copy from the (possibly value pointed-to by) local +// lclnum to the argument slot represented by putArgStk +// +// Arguments: +// putArgStk - the PutArgStk node representing the stack slot of the argument +// argType - the struct type of the argument +// lclNum - the local to use as the source for the special copy helper +// +// Notes: +// This method assumes that lclNum is either a by-ref to a struct of type argType +// or a struct of type argType. +// We use this to preserve special copy semantics for interop calls where we pass in a byref to a struct into a +// P/Invoke with a special modreq and the native function expects to recieve the struct by value with the argument +// being passed in having been created by the special copy helper. +// +void Lowering::InsertSpecialCopyArg(GenTreePutArgStk* putArgStk, CORINFO_CLASS_HANDLE argType, unsigned lclNum) +{ + assert(putArgStk != nullptr); + GenTree* dest = comp->gtNewPhysRegNode(REG_SPBASE, TYP_I_IMPL); + + GenTree* src; + var_types lclType = comp->lvaGetRealType(lclNum); + + if (lclType == TYP_BYREF || lclType == TYP_I_IMPL) + { + src = comp->gtNewLclVarNode(lclNum, lclType); + } + else + { + assert(lclType == TYP_STRUCT); + src = comp->gtNewLclAddrNode(lclNum, 0, TYP_I_IMPL); + } + + GenTree* destPlaceholder = comp->gtNewZeroConNode(dest->TypeGet()); + GenTree* srcPlaceholder = comp->gtNewZeroConNode(src->TypeGet()); + + GenTreeCall* call = + comp->gtNewCallNode(CT_USER_FUNC, comp->info.compCompHnd->getSpecialCopyHelper(argType), TYP_VOID); + + call->gtArgs.PushBack(comp, NewCallArg::Primitive(destPlaceholder)); + call->gtArgs.PushBack(comp, NewCallArg::Primitive(srcPlaceholder)); + + comp->fgMorphArgs(call); + + LIR::Range callRange = LIR::SeqTree(comp, call); + GenTree* callRangeStart = callRange.FirstNode(); + GenTree* callRangeEnd = callRange.LastNode(); + + BlockRange().InsertAfter(putArgStk, std::move(callRange)); + BlockRange().InsertAfter(putArgStk, dest); + BlockRange().InsertAfter(putArgStk, src); + + LIR::Use destUse; + LIR::Use srcUse; + BlockRange().TryGetUse(destPlaceholder, &destUse); + BlockRange().TryGetUse(srcPlaceholder, &srcUse); + destUse.ReplaceWith(dest); + srcUse.ReplaceWith(src); + destPlaceholder->SetUnusedValue(); + srcPlaceholder->SetUnusedValue(); + + LowerRange(callRangeStart, callRangeEnd); + + // Finally move all GT_PUTARG_* nodes + // Re-use the existing logic for CFG call args here + MoveCFGCallArgs(call); + + BlockRange().Remove(destPlaceholder); + BlockRange().Remove(srcPlaceholder); +} +#endif // defined(TARGET_X86) && defined(FEATURE_IJW) + //------------------------------------------------------------------------ // LegalizeArgPlacement: Move arg placement nodes (PUTARG_*) into a legal // ordering after they have been created. @@ -8823,12 +8962,22 @@ void Lowering::LowerStoreIndirCoalescing(GenTreeIndir* ind) assert(prevData.IsStore()); assert(currData.IsStore()); - // For now, only constants are supported for data. + // For now, only non-relocatable constants are supported for data. if (!prevData.value->OperIsConst() || !currData.value->OperIsConst()) { return; } + if (prevData.value->IsCnsIntOrI() && prevData.value->AsIntCon()->ImmedValNeedsReloc(comp)) + { + return; + } + + if (currData.value->IsCnsIntOrI() && currData.value->AsIntCon()->ImmedValNeedsReloc(comp)) + { + return; + } + // Otherwise, the difference between two offsets has to match the size of the type. // We don't support overlapping stores. if (abs(prevData.offset - currData.offset) != (int)genTypeSize(prevData.targetType)) diff --git a/src/coreclr/jit/lower.h b/src/coreclr/jit/lower.h index e52ed71be29..3396343e0de 100644 --- a/src/coreclr/jit/lower.h +++ b/src/coreclr/jit/lower.h @@ -183,6 +183,10 @@ class Lowering final : public Phase GenTree* LowerVirtualStubCall(GenTreeCall* call); void LowerArgsForCall(GenTreeCall* call); void ReplaceArgWithPutArgOrBitcast(GenTree** ppChild, GenTree* newNode); +#if defined(TARGET_X86) && defined(FEATURE_IJW) + void LowerSpecialCopyArgs(GenTreeCall* call); + void InsertSpecialCopyArg(GenTreePutArgStk* putArgStk, CORINFO_CLASS_HANDLE argType, unsigned lclNum); +#endif // defined(TARGET_X86) && defined(FEATURE_IJW) GenTree* NewPutArg(GenTreeCall* call, GenTree* arg, CallArg* callArg, var_types type); void LowerArg(GenTreeCall* call, CallArg* callArg, bool late); #if defined(TARGET_ARMARCH) || defined(TARGET_LOONGARCH64) || defined(TARGET_RISCV64) diff --git a/src/coreclr/jit/lowerarmarch.cpp b/src/coreclr/jit/lowerarmarch.cpp index 98f933c4c77..6b96564af86 100644 --- a/src/coreclr/jit/lowerarmarch.cpp +++ b/src/coreclr/jit/lowerarmarch.cpp @@ -1781,7 +1781,51 @@ GenTree* Lowering::LowerHWIntrinsic(GenTreeHWIntrinsic* node) break; } + + case NI_Sve_GatherVectorByteZeroExtendFirstFaulting: case NI_Sve_GatherVectorFirstFaulting: + case NI_Sve_GatherVectorInt16SignExtendFirstFaulting: + case NI_Sve_GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting: + case NI_Sve_GatherVectorInt32SignExtendFirstFaulting: + case NI_Sve_GatherVectorInt32WithByteOffsetsSignExtendFirstFaulting: + case NI_Sve_GatherVectorSByteSignExtendFirstFaulting: + case NI_Sve_GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting: + case NI_Sve_GatherVectorUInt16ZeroExtendFirstFaulting: + case NI_Sve_GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting: + case NI_Sve_GatherVectorUInt32ZeroExtendFirstFaulting: + case NI_Sve_GatherVectorWithByteOffsetFirstFaulting: + case NI_Sve_LoadVectorByteZeroExtendFirstFaulting: + case NI_Sve_LoadVectorFirstFaulting: + case NI_Sve_LoadVectorInt16SignExtendFirstFaulting: + case NI_Sve_LoadVectorInt32SignExtendFirstFaulting: + case NI_Sve_LoadVectorSByteSignExtendFirstFaulting: + case NI_Sve_LoadVectorUInt16ZeroExtendFirstFaulting: + case NI_Sve_LoadVectorUInt32ZeroExtendFirstFaulting: + case NI_Sve_LoadVectorByteNonFaultingZeroExtendToInt16: + case NI_Sve_LoadVectorByteNonFaultingZeroExtendToInt32: + case NI_Sve_LoadVectorByteNonFaultingZeroExtendToInt64: + case NI_Sve_LoadVectorByteNonFaultingZeroExtendToUInt16: + case NI_Sve_LoadVectorByteNonFaultingZeroExtendToUInt32: + case NI_Sve_LoadVectorByteNonFaultingZeroExtendToUInt64: + case NI_Sve_LoadVectorInt16NonFaultingSignExtendToInt32: + case NI_Sve_LoadVectorInt16NonFaultingSignExtendToInt64: + case NI_Sve_LoadVectorInt16NonFaultingSignExtendToUInt32: + case NI_Sve_LoadVectorInt16NonFaultingSignExtendToUInt64: + case NI_Sve_LoadVectorInt32NonFaultingSignExtendToInt64: + case NI_Sve_LoadVectorInt32NonFaultingSignExtendToUInt64: + case NI_Sve_LoadVectorNonFaulting: + case NI_Sve_LoadVectorSByteNonFaultingSignExtendToInt16: + case NI_Sve_LoadVectorSByteNonFaultingSignExtendToInt32: + case NI_Sve_LoadVectorSByteNonFaultingSignExtendToInt64: + case NI_Sve_LoadVectorSByteNonFaultingSignExtendToUInt16: + case NI_Sve_LoadVectorSByteNonFaultingSignExtendToUInt32: + case NI_Sve_LoadVectorSByteNonFaultingSignExtendToUInt64: + case NI_Sve_LoadVectorUInt16NonFaultingZeroExtendToInt32: + case NI_Sve_LoadVectorUInt16NonFaultingZeroExtendToInt64: + case NI_Sve_LoadVectorUInt16NonFaultingZeroExtendToUInt32: + case NI_Sve_LoadVectorUInt16NonFaultingZeroExtendToUInt64: + case NI_Sve_LoadVectorUInt32NonFaultingZeroExtendToInt64: + case NI_Sve_LoadVectorUInt32NonFaultingZeroExtendToUInt64: { LIR::Use use; bool foundUse = BlockRange().TryGetUse(node, &use); @@ -1802,11 +1846,15 @@ GenTree* Lowering::LowerHWIntrinsic(GenTreeHWIntrinsic* node) assert(node->GetAuxiliaryType() != TYP_UNKNOWN); node->ResetHWIntrinsicId(intrinsicId, comp, node->Op(1), node->Op(2), node->Op(3), lclVar); } - else + else if (node->GetOperandCount() == 2) { - assert(node->GetOperandCount() == 2); node->ResetHWIntrinsicId(intrinsicId, comp, node->Op(1), node->Op(2), lclVar); } + else + { + assert(node->GetOperandCount() == 1); + node->ResetHWIntrinsicId(intrinsicId, comp, node->Op(1), lclVar); + } } if (foundUse) @@ -1825,47 +1873,7 @@ GenTree* Lowering::LowerHWIntrinsic(GenTreeHWIntrinsic* node) StoreFFRValue(node); break; } - case NI_Sve_LoadVectorByteZeroExtendFirstFaulting: - case NI_Sve_LoadVectorFirstFaulting: - case NI_Sve_LoadVectorInt16SignExtendFirstFaulting: - case NI_Sve_LoadVectorInt32SignExtendFirstFaulting: - case NI_Sve_LoadVectorSByteSignExtendFirstFaulting: - case NI_Sve_LoadVectorUInt16ZeroExtendFirstFaulting: - case NI_Sve_LoadVectorUInt32ZeroExtendFirstFaulting: - { - LIR::Use use; - bool foundUse = BlockRange().TryGetUse(node, &use); - - if (m_ffrTrashed) - { - // Consume the FFR register value from local variable to simulate "use" of FFR, - // only if it was trashed. If it was not trashed, we do not have to reload the - // contents of the FFR register. - - unsigned lclNum = comp->getFFRegisterVarNum(); - GenTree* lclVar = comp->gtNewLclvNode(lclNum, TYP_MASK); - BlockRange().InsertBefore(node, lclVar); - LowerNode(lclVar); - - node->ResetHWIntrinsicId(intrinsicId, comp, node->Op(1), node->Op(2), lclVar); - } - - if (foundUse) - { - unsigned tmpNum = comp->lvaGrabTemp(true DEBUGARG("Return value result/FFR")); - LclVarDsc* tmpVarDsc = comp->lvaGetDesc(tmpNum); - tmpVarDsc->lvType = node->TypeGet(); - GenTree* storeLclVar; - use.ReplaceWithLclVar(comp, tmpNum, &storeLclVar); - } - else - { - node->SetUnusedValue(); - } - StoreFFRValue(node); - break; - } default: break; } @@ -3763,18 +3771,6 @@ void Lowering::ContainCheckHWIntrinsic(GenTreeHWIntrinsic* node) if (intrin.op2->IsCnsIntOrI()) { MakeSrcContained(node, intrin.op2); - - if ((intrin.op2->AsIntCon()->gtIconVal == 0) && intrin.op3->IsCnsFltOrDbl()) - { - assert(varTypeIsFloating(intrin.baseType)); - - const double dataValue = intrin.op3->AsDblCon()->DconValue(); - - if (comp->GetEmitter()->emitIns_valid_imm_for_fmov(dataValue)) - { - MakeSrcContained(node, intrin.op3); - } - } } break; @@ -4034,6 +4030,9 @@ void Lowering::ContainCheckHWIntrinsic(GenTreeHWIntrinsic* node) // node - The hardware intrinsic node of the form // ConditionalSelect(mask, trueValue, falseValue) // +// Returns: +// Next node to lower. +// GenTree* Lowering::LowerHWIntrinsicCndSel(GenTreeHWIntrinsic* cndSelNode) { assert(cndSelNode->OperIsHWIntrinsic(NI_Sve_ConditionalSelect)); @@ -4049,40 +4048,51 @@ GenTree* Lowering::LowerHWIntrinsicCndSel(GenTreeHWIntrinsic* cndSelNode) // `trueValue` GenTreeHWIntrinsic* nestedCndSel = op2->AsHWIntrinsic(); GenTree* nestedOp1 = nestedCndSel->Op(1); + GenTree* nestedOp2 = nestedCndSel->Op(2); assert(varTypeIsMask(nestedOp1)); - if (nestedOp1->IsMaskAllBitsSet()) + if (nestedOp2->OperIsHWIntrinsic()) { - GenTree* nestedOp2 = nestedCndSel->Op(2); - GenTree* nestedOp3 = nestedCndSel->Op(3); + NamedIntrinsic nestedOp2Id = nestedOp2->AsHWIntrinsic()->GetHWIntrinsicId(); - JITDUMP("lowering nested ConditionalSelect HWIntrinisic (before):\n"); - DISPTREERANGE(BlockRange(), cndSelNode); - JITDUMP("\n"); + // If the nested op uses Pg/Z, then inactive lanes will result in zeros, so can only transform if + // op3 is all zeros. Such a Csel operation is absorbed into the instruction when emitted. Skip this + // optimisation when the nestedOp is a reduce operation. - // Transform: - // - // CndSel(mask, CndSel(AllTrue, embeddedMask(trueValOp2), trueValOp3), op3) to - // CndSel(mask, embedded(trueValOp2), op3) - // - cndSelNode->Op(2) = nestedCndSel->Op(2); - if (nestedOp3->IsMaskZero()) + if (nestedOp1->IsMaskAllBitsSet() && !HWIntrinsicInfo::IsReduceOperation(nestedOp2Id) && + (!HWIntrinsicInfo::IsZeroingMaskedOperation(nestedOp2Id) || op3->IsVectorZero())) { - BlockRange().Remove(nestedOp3); - } - else - { - nestedOp3->SetUnusedValue(); - } + GenTree* nestedOp2 = nestedCndSel->Op(2); + GenTree* nestedOp3 = nestedCndSel->Op(3); + + JITDUMP("lowering nested ConditionalSelect HWIntrinisic (before):\n"); + DISPTREERANGE(BlockRange(), cndSelNode); + JITDUMP("\n"); + + // Transform: + // + // CndSel(mask, CndSel(AllTrue, embeddedMask(trueValOp2), trueValOp3), op3) to + // CndSel(mask, embedded(trueValOp2), op3) + // + cndSelNode->Op(2) = nestedCndSel->Op(2); + if (nestedOp3->IsMaskZero()) + { + BlockRange().Remove(nestedOp3); + } + else + { + nestedOp3->SetUnusedValue(); + } - BlockRange().Remove(nestedOp1); - BlockRange().Remove(nestedCndSel); + BlockRange().Remove(nestedOp1); + BlockRange().Remove(nestedCndSel); - JITDUMP("lowering nested ConditionalSelect HWIntrinisic (after):\n"); - DISPTREERANGE(BlockRange(), cndSelNode); - JITDUMP("\n"); + JITDUMP("lowering nested ConditionalSelect HWIntrinisic (after):\n"); + DISPTREERANGE(BlockRange(), cndSelNode); + JITDUMP("\n"); - return cndSelNode; + return cndSelNode; + } } } else if (op1->IsMaskAllBitsSet()) @@ -4118,13 +4128,15 @@ GenTree* Lowering::LowerHWIntrinsicCndSel(GenTreeHWIntrinsic* cndSelNode) op3->SetUnusedValue(); } op1->SetUnusedValue(); + + GenTree* next = cndSelNode->gtNext; BlockRange().Remove(cndSelNode); JITDUMP("lowering ConditionalSelect HWIntrinisic (after):\n"); DISPTREERANGE(BlockRange(), op2); JITDUMP("\n"); - return op2; + return next; } } @@ -4145,7 +4157,18 @@ void Lowering::StoreFFRValue(GenTreeHWIntrinsic* node) #ifdef DEBUG switch (node->GetHWIntrinsicId()) { + case NI_Sve_GatherVectorByteZeroExtendFirstFaulting: case NI_Sve_GatherVectorFirstFaulting: + case NI_Sve_GatherVectorInt16SignExtendFirstFaulting: + case NI_Sve_GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting: + case NI_Sve_GatherVectorInt32SignExtendFirstFaulting: + case NI_Sve_GatherVectorInt32WithByteOffsetsSignExtendFirstFaulting: + case NI_Sve_GatherVectorSByteSignExtendFirstFaulting: + case NI_Sve_GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting: + case NI_Sve_GatherVectorUInt16ZeroExtendFirstFaulting: + case NI_Sve_GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting: + case NI_Sve_GatherVectorUInt32ZeroExtendFirstFaulting: + case NI_Sve_GatherVectorWithByteOffsetFirstFaulting: case NI_Sve_LoadVectorByteZeroExtendFirstFaulting: case NI_Sve_LoadVectorFirstFaulting: case NI_Sve_LoadVectorInt16SignExtendFirstFaulting: @@ -4153,9 +4176,34 @@ void Lowering::StoreFFRValue(GenTreeHWIntrinsic* node) case NI_Sve_LoadVectorSByteSignExtendFirstFaulting: case NI_Sve_LoadVectorUInt16ZeroExtendFirstFaulting: case NI_Sve_LoadVectorUInt32ZeroExtendFirstFaulting: + case NI_Sve_LoadVectorByteNonFaultingZeroExtendToInt16: + case NI_Sve_LoadVectorByteNonFaultingZeroExtendToInt32: + case NI_Sve_LoadVectorByteNonFaultingZeroExtendToInt64: + case NI_Sve_LoadVectorByteNonFaultingZeroExtendToUInt16: + case NI_Sve_LoadVectorByteNonFaultingZeroExtendToUInt32: + case NI_Sve_LoadVectorByteNonFaultingZeroExtendToUInt64: + case NI_Sve_LoadVectorInt16NonFaultingSignExtendToInt32: + case NI_Sve_LoadVectorInt16NonFaultingSignExtendToInt64: + case NI_Sve_LoadVectorInt16NonFaultingSignExtendToUInt32: + case NI_Sve_LoadVectorInt16NonFaultingSignExtendToUInt64: + case NI_Sve_LoadVectorInt32NonFaultingSignExtendToInt64: + case NI_Sve_LoadVectorInt32NonFaultingSignExtendToUInt64: + case NI_Sve_LoadVectorNonFaulting: + case NI_Sve_LoadVectorSByteNonFaultingSignExtendToInt16: + case NI_Sve_LoadVectorSByteNonFaultingSignExtendToInt32: + case NI_Sve_LoadVectorSByteNonFaultingSignExtendToInt64: + case NI_Sve_LoadVectorSByteNonFaultingSignExtendToUInt16: + case NI_Sve_LoadVectorSByteNonFaultingSignExtendToUInt32: + case NI_Sve_LoadVectorSByteNonFaultingSignExtendToUInt64: + case NI_Sve_LoadVectorUInt16NonFaultingZeroExtendToInt32: + case NI_Sve_LoadVectorUInt16NonFaultingZeroExtendToInt64: + case NI_Sve_LoadVectorUInt16NonFaultingZeroExtendToUInt32: + case NI_Sve_LoadVectorUInt16NonFaultingZeroExtendToUInt64: + case NI_Sve_LoadVectorUInt32NonFaultingZeroExtendToInt64: + case NI_Sve_LoadVectorUInt32NonFaultingZeroExtendToUInt64: case NI_Sve_SetFfr: - break; + default: assert(!"Unexpected HWIntrinsicId"); } diff --git a/src/coreclr/jit/lowerxarch.cpp b/src/coreclr/jit/lowerxarch.cpp index 76edb0dca71..83d67383da2 100644 --- a/src/coreclr/jit/lowerxarch.cpp +++ b/src/coreclr/jit/lowerxarch.cpp @@ -1430,10 +1430,9 @@ GenTree* Lowering::LowerHWIntrinsic(GenTreeHWIntrinsic* node) const uint8_t B = 0xCC; const uint8_t C = 0xAA; - var_types simdType = node->TypeGet(); - CorInfoType simdBaseJitType = node->GetSimdBaseJitType(); - var_types simdBaseType = node->GetSimdBaseType(); - unsigned simdSize = node->GetSimdSize(); + var_types simdType = node->TypeGet(); + var_types simdBaseType = node->GetSimdBaseType(); + unsigned simdSize = node->GetSimdSize(); GenTree* op1 = node->Op(1); GenTree* op2 = node->Op(2); @@ -1455,6 +1454,10 @@ GenTree* Lowering::LowerHWIntrinsic(GenTreeHWIntrinsic* node) bool userIsScalar = false; genTreeOps userOper = userIntrin->GetOperForHWIntrinsicId(&isScalar); + // userIntrin may have re-interpreted the base type + // + simdBaseType = userIntrin->GetSimdBaseType(); + if (GenTreeHWIntrinsic::OperIsBitwiseHWIntrinsic(userOper)) { if (isOperNot && (userOper == GT_AND)) @@ -1672,6 +1675,11 @@ GenTree* Lowering::LowerHWIntrinsic(GenTreeHWIntrinsic* node) BlockRange().InsertBefore(userIntrin, op4); userIntrin->ResetHWIntrinsicId(ternaryLogicId, comp, op1, op2, op3, op4); + if (varTypeIsSmall(simdBaseType)) + { + assert(HWIntrinsicInfo::NeedsNormalizeSmallTypeToInt(ternaryLogicId)); + userIntrin->NormalizeJitBaseTypeToInt(ternaryLogicId, simdBaseType); + } return nextNode; } } @@ -1737,6 +1745,11 @@ GenTree* Lowering::LowerHWIntrinsic(GenTreeHWIntrinsic* node) BlockRange().InsertBefore(node, control); node->ResetHWIntrinsicId(ternaryLogicId, comp, op1, op2, op3, control); + if (varTypeIsSmall(simdBaseType)) + { + assert(HWIntrinsicInfo::NeedsNormalizeSmallTypeToInt(ternaryLogicId)); + node->NormalizeJitBaseTypeToInt(ternaryLogicId, simdBaseType); + } return LowerNode(node); } } @@ -1823,6 +1836,10 @@ GenTree* Lowering::LowerHWIntrinsic(GenTreeHWIntrinsic* node) LowerNode(op2); node->ResetHWIntrinsicId(intrinsicId, comp, op1, op2); + if (HWIntrinsicInfo::NeedsNormalizeSmallTypeToInt(intrinsicId) && varTypeIsSmall(simdBaseType)) + { + node->NormalizeJitBaseTypeToInt(intrinsicId, simdBaseType); + } break; } @@ -1882,6 +1899,10 @@ GenTree* Lowering::LowerHWIntrinsic(GenTreeHWIntrinsic* node) LowerNode(op3); node->ResetHWIntrinsicId(intrinsicId, comp, op1, op2, op3); + if (HWIntrinsicInfo::NeedsNormalizeSmallTypeToInt(intrinsicId) && varTypeIsSmall(simdBaseType)) + { + node->NormalizeJitBaseTypeToInt(intrinsicId, simdBaseType); + } break; } @@ -3052,11 +3073,12 @@ GenTree* Lowering::LowerHWIntrinsicCmpOp(GenTreeHWIntrinsic* node, genTreeOps cm GenTreeHWIntrinsic* op1Intrinsic = op1->AsHWIntrinsic(); NamedIntrinsic op1IntrinsicId = op1Intrinsic->GetHWIntrinsicId(); - switch (op1IntrinsicId) + bool isScalar = false; + genTreeOps oper = op1Intrinsic->GetOperForHWIntrinsicId(&isScalar); + + switch (oper) { - case NI_AVX512F_And: - case NI_AVX512DQ_And: - case NI_AVX10v1_V512_And: + case GT_AND: { // We have `(x & y) == 0` with GenCondition::EQ (jz, setz, cmovz) // or `(x & y) != 0`with GenCondition::NE (jnz, setnz, cmovnz) @@ -3076,8 +3098,62 @@ GenTree* Lowering::LowerHWIntrinsicCmpOp(GenTreeHWIntrinsic* node, genTreeOps cm assert(testIntrinsicId == NI_EVEX_PTESTM); - node->Op(1) = op1Intrinsic->Op(1); - node->Op(2) = op1Intrinsic->Op(2); + GenTree* nestedOp1 = op1Intrinsic->Op(1); + GenTree* nestedOp2 = op1Intrinsic->Op(2); + + if (nestedOp2->isContained() && nestedOp2->OperIsHWIntrinsic()) + { + GenTreeHWIntrinsic* nestedIntrin = nestedOp2->AsHWIntrinsic(); + NamedIntrinsic nestedIntrinId = nestedIntrin->GetHWIntrinsicId(); + + if ((nestedIntrinId == NI_SSE3_MoveAndDuplicate) || + (nestedIntrinId == NI_AVX2_BroadcastScalarToVector128) || + (nestedIntrinId == NI_AVX2_BroadcastScalarToVector256) || + (nestedIntrinId == NI_AVX512F_BroadcastScalarToVector512)) + { + // We need to rewrite the embedded broadcast back to a regular constant + // so that the subsequent containment check for ptestm can determine + // if the embedded broadcast is still relevant + + GenTree* broadcastOp = nestedIntrin->Op(1); + + if (broadcastOp->OperIsHWIntrinsic(NI_Vector128_CreateScalarUnsafe)) + { + BlockRange().Remove(broadcastOp); + broadcastOp = broadcastOp->AsHWIntrinsic()->Op(1); + } + + assert(broadcastOp->OperIsConst()); + + GenTree* vecCns = + comp->gtNewSimdCreateBroadcastNode(simdType, broadcastOp, + op1Intrinsic->GetSimdBaseJitType(), simdSize); + + BlockRange().InsertAfter(broadcastOp, vecCns); + nestedOp2 = vecCns; + + BlockRange().Remove(broadcastOp); + BlockRange().Remove(nestedIntrin); + } + } + + node->Op(1) = nestedOp1; + node->Op(2) = nestedOp2; + + // Make sure we aren't contained since ptestm will do its own containment check + nestedOp2->ClearContained(); + + if (varTypeIsSmall(simdBaseType)) + { + // Fixup the base type so embedded broadcast and the mask size checks still work + node->NormalizeJitBaseTypeToInt(testIntrinsicId, simdBaseType); + + simdBaseJitType = node->GetSimdBaseJitType(); + simdBaseType = node->GetSimdBaseType(); + + maskBaseJitType = simdBaseJitType; + maskBaseType = simdBaseType; + } BlockRange().Remove(op1); BlockRange().Remove(op2); @@ -3455,6 +3531,11 @@ GenTree* Lowering::LowerHWIntrinsicCndSel(GenTreeHWIntrinsic* node) BlockRange().InsertBefore(node, control); node->ResetHWIntrinsicId(ternaryLogicId, comp, op1, op2, op3, control); + if (varTypeIsSmall(simdBaseType)) + { + assert(HWIntrinsicInfo::NeedsNormalizeSmallTypeToInt(ternaryLogicId)); + node->NormalizeJitBaseTypeToInt(ternaryLogicId, simdBaseType); + } return LowerNode(node); } @@ -3820,7 +3901,7 @@ GenTree* Lowering::LowerHWIntrinsicTernaryLogic(GenTreeHWIntrinsic* node) std::swap(node->Op(1), node->Op(2)); // Make sure we also fixup the control byte - control = TernaryLogicInfo::GetTernaryControlByte(info, C, A, B); + control = TernaryLogicInfo::GetTernaryControlByte(info, B, C, A); op4->AsIntCon()->SetIconValue(control); useFlags = TernaryLogicUseFlags::BC; @@ -3846,6 +3927,13 @@ GenTree* Lowering::LowerHWIntrinsicTernaryLogic(GenTreeHWIntrinsic* node) } } + // Update the locals to reflect any operand swaps we did above. + + op1 = node->Op(1); + op2 = node->Op(2); + op3 = node->Op(3); + assert(op4 == node->Op(4)); + GenTree* replacementNode = nullptr; switch (useFlags) @@ -4757,8 +4845,6 @@ GenTree* Lowering::LowerHWIntrinsicCreate(GenTreeHWIntrinsic* node) case TYP_INT: case TYP_UINT: { - unsigned N = 0; - GenTree* opN = nullptr; NamedIntrinsic insIntrinsic = NI_Illegal; if ((simdBaseType == TYP_SHORT) || (simdBaseType == TYP_USHORT)) @@ -4773,7 +4859,7 @@ GenTree* Lowering::LowerHWIntrinsicCreate(GenTreeHWIntrinsic* node) if (insIntrinsic != NI_Illegal) { - for (N = 1; N < argCnt - 1; N++) + for (size_t N = 1; N < argCnt - 1; N++) { // We will be constructing the following parts: // ... @@ -4789,7 +4875,7 @@ GenTree* Lowering::LowerHWIntrinsicCreate(GenTreeHWIntrinsic* node) // tmp1 = Sse?.Insert(tmp1, opN, N); // ... - opN = node->Op(N + 1); + GenTree* opN = node->Op(N + 1); idx = comp->gtNewIconNode(N, TYP_INT); // Place the insert as early as possible to avoid creating a lot of long lifetimes. @@ -4801,26 +4887,24 @@ GenTree* Lowering::LowerHWIntrinsicCreate(GenTreeHWIntrinsic* node) LowerNode(tmp1); } - assert(N == (argCnt - 1)); - // We will be constructing the following parts: - // idx = CNS_INT int N - // /--* tmp1 simd16 - // +--* opN T - // +--* idx int + // idx = CNS_INT int (argCnt - 1) + // /--* tmp1 simd16 + // +--* lastOp T + // +--* idx int // node = * HWINTRINSIC simd16 T Insert // This is roughly the following managed code: // ... - // tmp1 = Sse?.Insert(tmp1, opN, N); + // tmp1 = Sse?.Insert(tmp1, lastOp, (argCnt - 1)); // ... - opN = node->Op(argCnt); + GenTree* lastOp = node->Op(argCnt); - idx = comp->gtNewIconNode(N, TYP_INT); - BlockRange().InsertAfter(opN, idx); + idx = comp->gtNewIconNode((argCnt - 1), TYP_INT); + BlockRange().InsertAfter(lastOp, idx); - node->ResetHWIntrinsicId(insIntrinsic, comp, tmp1, opN, idx); + node->ResetHWIntrinsicId(insIntrinsic, comp, tmp1, lastOp, idx); break; } @@ -4830,9 +4914,9 @@ GenTree* Lowering::LowerHWIntrinsicCreate(GenTreeHWIntrinsic* node) GenTree* op[16]; op[0] = tmp1; - for (N = 1; N < argCnt; N++) + for (size_t N = 1; N < argCnt; N++) { - opN = node->Op(N + 1); + GenTree* opN = node->Op(N + 1); op[N] = InsertNewSimdCreateScalarUnsafeNode(TYP_SIMD16, opN, simdBaseJitType, 16); LowerNode(op[N]); @@ -4840,7 +4924,7 @@ GenTree* Lowering::LowerHWIntrinsicCreate(GenTreeHWIntrinsic* node) if ((simdBaseType == TYP_BYTE) || (simdBaseType == TYP_UBYTE)) { - for (N = 0; N < argCnt; N += 4) + for (size_t N = 0; N < argCnt; N += 4) { // We will be constructing the following parts: // ... @@ -4870,9 +4954,9 @@ GenTree* Lowering::LowerHWIntrinsicCreate(GenTreeHWIntrinsic* node) // tmp3 = Sse2.UnpackLow(tmp1, tmp2); // ... - unsigned O = N + 1; - unsigned P = N + 2; - unsigned Q = N + 3; + size_t O = N + 1; + size_t P = N + 2; + size_t Q = N + 3; tmp1 = comp->gtNewSimdHWIntrinsicNode(simdType, op[N], op[O], NI_SSE2_UnpackLow, CORINFO_TYPE_UBYTE, simdSize); @@ -9829,7 +9913,8 @@ bool Lowering::IsContainableHWIntrinsicOp(GenTreeHWIntrinsic* parentNode, GenTre } bool childSupportsRegOptional; - if (IsContainableHWIntrinsicOp(hwintrinsic, broadcastOperand, &childSupportsRegOptional)) + if (IsContainableHWIntrinsicOp(hwintrinsic, broadcastOperand, &childSupportsRegOptional) && + IsSafeToContainMem(parentNode, hwintrinsic)) { return true; } @@ -10420,9 +10505,7 @@ void Lowering::ContainCheckHWIntrinsic(GenTreeHWIntrinsic* node) { containedOperand = op2; } - else if ((isCommutative || (intrinsicId == NI_BMI2_MultiplyNoFlags) || - (intrinsicId == NI_BMI2_X64_MultiplyNoFlags)) && - IsContainableHWIntrinsicOp(node, op1, &supportsOp1RegOptional)) + else if (isCommutative && IsContainableHWIntrinsicOp(node, op1, &supportsOp1RegOptional)) { containedOperand = op1; swapOperands = true; diff --git a/src/coreclr/jit/lsra.cpp b/src/coreclr/jit/lsra.cpp index 763a28989b3..dd766c51e3d 100644 --- a/src/coreclr/jit/lsra.cpp +++ b/src/coreclr/jit/lsra.cpp @@ -9789,10 +9789,26 @@ void LinearScan::resolveEdge(BasicBlock* fromBlock, if (location[targetReg] == REG_NA) { #ifdef TARGET_ARM - regNumber sourceReg = (regNumber)source[targetReg]; - Interval* interval = sourceIntervals[sourceReg]; + // For Arm, check two things: + // 1. If sourceReg relates to DOUBLE interval, then make sure + // the second half of targetReg is not participating in the resolution. + // 2. On the contrary, if targetReg is second half of a DOUBLE interval, + // then make sure the first half is not participating in the resolution. + // Only when both these conditions are met, can we safely assume + // that sourceReg can be moved to targetReg. + regNumber sourceReg = (regNumber)source[targetReg]; + Interval* interval = sourceIntervals[sourceReg]; + Interval* otherTargetInterval = nullptr; + regNumber otherHalfTargetReg = REG_NA; + if (genIsValidFloatReg(targetReg) && !genIsValidDoubleReg(targetReg)) + { + otherHalfTargetReg = REG_PREV(targetReg); + otherTargetInterval = sourceIntervals[otherHalfTargetReg]; + } + if (interval->registerType == TYP_DOUBLE) { + // Condition 1 above. // For ARM32, make sure that both of the float halves of the double register are available. assert(genIsValidDoubleReg(targetReg)); regNumber anotherHalfRegNum = REG_NEXT(targetReg); @@ -9801,11 +9817,22 @@ void LinearScan::resolveEdge(BasicBlock* fromBlock, targetRegsReady.AddRegNumInMask(targetReg); } } + else if ((otherTargetInterval != nullptr) && (otherTargetInterval->registerType == TYP_DOUBLE)) + { + // Condition 2 above. + assert(otherHalfTargetReg != REG_NA); + if (location[otherHalfTargetReg] == REG_NA) + { + targetRegsReady.AddRegNumInMask(targetReg); + } + } else -#endif // TARGET_ARM { targetRegsReady.AddRegNumInMask(targetReg); } +#else + targetRegsReady.AddRegNumInMask(targetReg); +#endif } } @@ -9848,24 +9875,40 @@ void LinearScan::resolveEdge(BasicBlock* fromBlock, { targetRegsReady.RemoveRegNumFromMask(fromReg); } + + // Since we want to check if we can free upperHalfReg, only do it + // if lowerHalfReg is ready. + if (targetRegsReady.IsRegNumInMask(fromReg)) + { + regNumber upperHalfSrcReg = (regNumber)source[upperHalfReg]; + regNumber upperHalfSrcLoc = (regNumber)location[upperHalfReg]; + // Necessary conditions: + // - There is a source register for this reg (upperHalfSrcReg != REG_NA) + // - It is currently free (upperHalfSrcLoc == REG_NA) + // - The source interval isn't yet completed (sourceIntervals[upperHalfSrcReg] != nullptr) + // - It's not resolved from stack (!targetRegsFromStack.IsRegNumInMask(upperHalfReg)) + if ((upperHalfSrcReg != REG_NA) && (upperHalfSrcLoc == REG_NA) && + (sourceIntervals[upperHalfSrcReg] != nullptr) && + !targetRegsFromStack.IsRegNumInMask(upperHalfReg)) + { + targetRegsReady.AddRegNumInMask(upperHalfReg); + } + } } } else if (genIsValidFloatReg(fromReg) && !genIsValidDoubleReg(fromReg)) { // We may have freed up the other half of a double where the lower half // was already free. - regNumber lowerHalfReg = REG_PREV(fromReg); - regNumber lowerHalfSrcReg = (regNumber)source[lowerHalfReg]; - regNumber lowerHalfSrcLoc = (regNumber)location[lowerHalfReg]; - regMaskTP lowerHalfRegMask = genRegMask(lowerHalfReg); + regNumber lowerHalfReg = REG_PREV(fromReg); + regNumber lowerHalfSrcReg = (regNumber)source[lowerHalfReg]; + regNumber lowerHalfSrcLoc = (regNumber)location[lowerHalfReg]; // Necessary conditions: // - There is a source register for this reg (lowerHalfSrcReg != REG_NA) // - It is currently free (lowerHalfSrcLoc == REG_NA) // - The source interval isn't yet completed (sourceIntervals[lowerHalfSrcReg] != nullptr) - // - It's not in the ready set ((targetRegsReady & lowerHalfRegMask) == - // RBM_NONE) - // - It's not resolved from stack ((targetRegsFromStack & lowerHalfRegMask) != - // lowerHalfRegMask) + // - It's not in the ready set (!targetRegsReady.IsRegNumInMask(lowerHalfReg)) + // - It's not resolved from stack (!targetRegsFromStack.IsRegNumInMask(lowerHalfReg)) if ((lowerHalfSrcReg != REG_NA) && (lowerHalfSrcLoc == REG_NA) && (sourceIntervals[lowerHalfSrcReg] != nullptr) && !targetRegsReady.IsRegNumInMask(lowerHalfReg) && @@ -10019,6 +10062,13 @@ void LinearScan::resolveEdge(BasicBlock* fromBlock, { compiler->codeGen->regSet.rsSetRegsModified(genRegMask(tempReg) DEBUGARG(true)); #ifdef TARGET_ARM + Interval* otherTargetInterval = nullptr; + regNumber otherHalfTargetReg = REG_NA; + if (genIsValidFloatReg(targetReg) && !genIsValidDoubleReg(targetReg)) + { + otherHalfTargetReg = REG_PREV(targetReg); + otherTargetInterval = sourceIntervals[otherHalfTargetReg]; + } if (sourceIntervals[fromReg]->registerType == TYP_DOUBLE) { assert(genIsValidDoubleReg(targetReg)); @@ -10027,8 +10077,15 @@ void LinearScan::resolveEdge(BasicBlock* fromBlock, addResolutionForDouble(block, insertionPoint, sourceIntervals, location, tempReg, targetReg, resolveType DEBUG_ARG(fromBlock) DEBUG_ARG(toBlock)); } + else if (otherTargetInterval != nullptr) + { + assert(otherHalfTargetReg != REG_NA); + assert(otherTargetInterval->registerType == TYP_DOUBLE); + + addResolutionForDouble(block, insertionPoint, sourceIntervals, location, tempReg, + otherHalfTargetReg, resolveType DEBUG_ARG(fromBlock) DEBUG_ARG(toBlock)); + } else -#endif // TARGET_ARM { assert(sourceIntervals[targetReg] != nullptr); @@ -10037,6 +10094,14 @@ void LinearScan::resolveEdge(BasicBlock* fromBlock, DEBUG_ARG(resolveTypeName[resolveType])); location[targetReg] = (regNumberSmall)tempReg; } +#else + assert(sourceIntervals[targetReg] != nullptr); + + addResolution(block, insertionPoint, sourceIntervals[targetReg], tempReg, + targetReg DEBUG_ARG(fromBlock) DEBUG_ARG(toBlock) + DEBUG_ARG(resolveTypeName[resolveType])); + location[targetReg] = (regNumberSmall)tempReg; +#endif // TARGET_ARM targetRegsReady |= targetRegMask; } } diff --git a/src/coreclr/jit/lsraarm64.cpp b/src/coreclr/jit/lsraarm64.cpp index f0bc32e1f3d..79bf3c16778 100644 --- a/src/coreclr/jit/lsraarm64.cpp +++ b/src/coreclr/jit/lsraarm64.cpp @@ -1944,7 +1944,8 @@ int LinearScan::BuildHWIntrinsic(GenTreeHWIntrinsic* intrinsicTree, int* pDstCou GenTreeHWIntrinsic* embOp2Node = intrin.op2->AsHWIntrinsic(); size_t numArgs = embOp2Node->GetOperandCount(); const HWIntrinsic intrinEmb(embOp2Node); - numArgs = embOp2Node->GetOperandCount(); + numArgs = embOp2Node->GetOperandCount(); + GenTree* prefUseNode = nullptr; if (HWIntrinsicInfo::IsFmaIntrinsic(intrinEmb.id)) { @@ -1961,44 +1962,15 @@ int LinearScan::BuildHWIntrinsic(GenTreeHWIntrinsic* intrinsicTree, int* pDstCou unsigned resultOpNum = embOp2Node->GetResultOpNumForRmwIntrinsic(user, intrinEmb.op1, intrinEmb.op2, intrinEmb.op3); - GenTree* emitOp1 = intrinEmb.op1; - GenTree* emitOp2 = intrinEmb.op2; - GenTree* emitOp3 = intrinEmb.op3; - - if (resultOpNum == 2) - { - // op2 = op1 + (op2 * op3) - std::swap(emitOp1, emitOp3); - std::swap(emitOp1, emitOp2); - // op1 = (op1 * op2) + op3 - } - else if (resultOpNum == 3) + if (resultOpNum == 0) { - // op3 = op1 + (op2 * op3) - std::swap(emitOp1, emitOp3); - // op1 = (op1 * op2) + op3 + prefUseNode = embOp2Node->Op(1); } else { - // op1 = op1 + (op2 * op3) - // Nothing needs to be done + assert(resultOpNum >= 1 && resultOpNum <= 3); + prefUseNode = embOp2Node->Op(resultOpNum); } - - GenTree* ops[] = {intrinEmb.op1, intrinEmb.op2, intrinEmb.op3}; - for (GenTree* op : ops) - { - if (op == emitOp1) - { - tgtPrefUse = BuildUse(op); - srcCount++; - } - else if (op == emitOp2 || op == emitOp3) - { - srcCount += BuildDelayFreeUses(op, emitOp1); - } - } - - srcCount += BuildDelayFreeUses(intrin.op3, emitOp1); } else { @@ -2045,22 +2017,32 @@ int LinearScan::BuildHWIntrinsic(GenTreeHWIntrinsic* intrinsicTree, int* pDstCou { prefUseOpNum = 2; } - GenTree* prefUseNode = embOp2Node->Op(prefUseOpNum); - for (size_t argNum = 1; argNum <= numArgs; argNum++) + prefUseNode = embOp2Node->Op(prefUseOpNum); + } + + for (size_t argNum = 1; argNum <= numArgs; argNum++) + { + GenTree* node = embOp2Node->Op(argNum); + + if (node == prefUseNode) { - if (argNum == prefUseOpNum) - { - tgtPrefUse = BuildUse(prefUseNode); - srcCount += 1; - } - else - { - srcCount += BuildDelayFreeUses(embOp2Node->Op(argNum), prefUseNode); - } + tgtPrefUse = BuildUse(node); + srcCount++; } + else + { + RefPosition* useRefPosition = nullptr; - srcCount += BuildDelayFreeUses(intrin.op3, prefUseNode); + int uses = BuildDelayFreeUses(node, nullptr, RBM_NONE, &useRefPosition); + srcCount += uses; + + // It is a hard requirement that these are not allocated to the same register as the destination, + // so verify no optimizations kicked in to skip setting the delay-free. + assert((useRefPosition != nullptr && useRefPosition->delayRegFree) || (uses == 0)); + } } + + srcCount += BuildDelayFreeUses(intrin.op3, prefUseNode); } else if (intrin.op2 != nullptr) { @@ -2105,14 +2087,24 @@ int LinearScan::BuildHWIntrinsic(GenTreeHWIntrinsic* intrinsicTree, int* pDstCou case NI_Sve_GatherVector: case NI_Sve_GatherVectorByteZeroExtend: case NI_Sve_GatherVectorInt16SignExtend: + case NI_Sve_GatherVectorInt16SignExtendFirstFaulting: case NI_Sve_GatherVectorInt16WithByteOffsetsSignExtend: + case NI_Sve_GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting: case NI_Sve_GatherVectorInt32SignExtend: + case NI_Sve_GatherVectorInt32SignExtendFirstFaulting: case NI_Sve_GatherVectorInt32WithByteOffsetsSignExtend: + case NI_Sve_GatherVectorInt32WithByteOffsetsSignExtendFirstFaulting: case NI_Sve_GatherVectorSByteSignExtend: + case NI_Sve_GatherVectorSByteSignExtendFirstFaulting: case NI_Sve_GatherVectorUInt16WithByteOffsetsZeroExtend: + case NI_Sve_GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting: case NI_Sve_GatherVectorUInt16ZeroExtend: + case NI_Sve_GatherVectorUInt16ZeroExtendFirstFaulting: case NI_Sve_GatherVectorUInt32WithByteOffsetsZeroExtend: + case NI_Sve_GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting: case NI_Sve_GatherVectorUInt32ZeroExtend: + case NI_Sve_GatherVectorUInt32ZeroExtendFirstFaulting: + case NI_Sve_GatherVectorWithByteOffsetFirstFaulting: assert(intrinsicTree->OperIsMemoryLoadOrStore()); FALLTHROUGH; diff --git a/src/coreclr/jit/lsrabuild.cpp b/src/coreclr/jit/lsrabuild.cpp index ee6d423db46..3c390ee2139 100644 --- a/src/coreclr/jit/lsrabuild.cpp +++ b/src/coreclr/jit/lsrabuild.cpp @@ -3679,13 +3679,18 @@ int LinearScan::BuildOperandUses(GenTree* node, SingleTypeRegSet candidates) { GenTreeHWIntrinsic* hwintrinsic = node->AsHWIntrinsic(); + size_t numArgs = hwintrinsic->GetOperandCount(); if (hwintrinsic->OperIsMemoryLoad()) { +#ifdef TARGET_ARM64 + if (numArgs == 2) + { + return BuildAddrUses(hwintrinsic->Op(1)) + BuildOperandUses(hwintrinsic->Op(2), candidates); + } +#endif return BuildAddrUses(hwintrinsic->Op(1)); } - size_t numArgs = hwintrinsic->GetOperandCount(); - if (numArgs != 1) { #ifdef TARGET_ARM64 diff --git a/src/coreclr/jit/morph.cpp b/src/coreclr/jit/morph.cpp index 206c1414786..d944469ebac 100644 --- a/src/coreclr/jit/morph.cpp +++ b/src/coreclr/jit/morph.cpp @@ -454,7 +454,8 @@ GenTree* Compiler::fgMorphExpandCast(GenTreeCast* tree) // Because there is no IL instruction conv.r4.un, uint/ulong -> float // casts are always imported as CAST(float <- CAST(double <- uint/ulong)). // We can eliminate the redundant intermediate cast as an optimization. - else if ((dstType == TYP_FLOAT) && (srcType == TYP_DOUBLE) && oper->OperIs(GT_CAST) + else if ((dstType == TYP_FLOAT) && (srcType == TYP_DOUBLE) && oper->OperIs(GT_CAST) && + !gtIsActiveCSE_Candidate(tree) #ifdef TARGET_ARM && !varTypeIsLong(oper->AsCast()->CastOp()) #endif @@ -1671,6 +1672,8 @@ void CallArgs::EvalArgsToTemps(Compiler* comp, GenTreeCall* call) unsigned tmpVarNum = comp->lvaGrabTemp(true DEBUGARG("argument with side effect")); GenTree* store = comp->gtNewTempStore(tmpVarNum, use.GetNode()); + INDEBUG(store->gtDebugFlags |= GTF_DEBUG_NODE_MORPHED); + if (setupArg == nullptr) { setupArg = store; @@ -1678,6 +1681,7 @@ void CallArgs::EvalArgsToTemps(Compiler* comp, GenTreeCall* call) else { setupArg = comp->gtNewOperNode(GT_COMMA, TYP_VOID, setupArg, store); + INDEBUG(setupArg->gtDebugFlags |= GTF_DEBUG_NODE_MORPHED); } use.SetNode(comp->gtNewLclvNode(tmpVarNum, genActualType(use.GetNode()))); @@ -1693,6 +1697,8 @@ void CallArgs::EvalArgsToTemps(Compiler* comp, GenTreeCall* call) setupArg = comp->gtNewTempStore(tmpVarNum, argx); + INDEBUG(setupArg->gtDebugFlags |= GTF_DEBUG_NODE_MORPHED); + LclVarDsc* varDsc = comp->lvaGetDesc(tmpVarNum); var_types lclVarType = genActualType(argx->gtType); var_types scalarType = TYP_UNKNOWN; @@ -7094,18 +7100,15 @@ GenTree* Compiler::fgMorphCall(GenTreeCall* call) // Morph stelem.ref helper call to store a null value, into a store into an array without the helper. // This needs to be done after the arguments are morphed to ensure constant propagation has already taken place. - if (opts.OptimizationEnabled() && call->IsHelperCall() && - (call->gtCallMethHnd == eeFindHelper(CORINFO_HELP_ARRADDR_ST))) + if (opts.OptimizationEnabled() && call->IsHelperCall(this, CORINFO_HELP_ARRADDR_ST)) { assert(call->gtArgs.CountArgs() == 3); + GenTree* arr = call->gtArgs.GetArgByIndex(0)->GetNode(); + GenTree* index = call->gtArgs.GetArgByIndex(1)->GetNode(); GenTree* value = call->gtArgs.GetArgByIndex(2)->GetNode(); - if (value->IsIntegralConst(0)) - { - assert(value->OperGet() == GT_CNS_INT); - - GenTree* arr = call->gtArgs.GetArgByIndex(0)->GetNode(); - GenTree* index = call->gtArgs.GetArgByIndex(1)->GetNode(); + if (gtCanSkipCovariantStoreCheck(value, arr)) + { // Either or both of the array and index arguments may have been spilled to temps by `fgMorphArgs`. Copy // the spill trees as well if necessary. GenTree* argSetup = nullptr; @@ -11165,8 +11168,8 @@ GenTree* Compiler::fgMorphRetInd(GenTreeOp* ret) bool canFold = (indSize == lclVarSize) && (lclVarSize <= REGSIZE_BYTES); #endif - // TODO: support `genReturnBB != nullptr`, it requires #11413 to avoid `Incompatible types for - // gtNewTempStore`. + // If we have a shared return temp we cannot represent the store properly with these retyped values, + // so skip the optimization in that case. if (canFold && (genReturnBB == nullptr)) { // Fold even if types do not match, lowering will handle it. This allows the local @@ -11592,12 +11595,7 @@ GenTree* Compiler::fgMorphHWIntrinsic(GenTreeHWIntrinsic* tree) // Try to fold it, maybe we get lucky, GenTree* morphedTree = gtFoldExpr(tree); - if (morphedTree != tree) - { - assert(!fgIsCommaThrow(morphedTree)); - INDEBUG(morphedTree->gtDebugFlags |= GTF_DEBUG_NODE_MORPHED); - } - else if (!morphedTree->OperIsHWIntrinsic()) + if ((morphedTree != tree) || !morphedTree->OperIsHWIntrinsic()) { INDEBUG(morphedTree->gtDebugFlags |= GTF_DEBUG_NODE_MORPHED); } diff --git a/src/coreclr/jit/namedintrinsiclist.h b/src/coreclr/jit/namedintrinsiclist.h index e6c26bb31ec..54d4d954abf 100644 --- a/src/coreclr/jit/namedintrinsiclist.h +++ b/src/coreclr/jit/namedintrinsiclist.h @@ -114,6 +114,7 @@ enum NamedIntrinsic : unsigned short NI_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray, NI_System_Runtime_CompilerServices_RuntimeHelpers_IsKnownConstant, NI_System_Runtime_CompilerServices_RuntimeHelpers_IsReferenceOrContainsReferences, + NI_System_Runtime_CompilerServices_RuntimeHelpers_GetMethodTable, NI_System_Runtime_InteropService_MemoryMarshal_GetArrayDataReference, diff --git a/src/coreclr/jit/optcse.cpp b/src/coreclr/jit/optcse.cpp index f633a5e3272..0d67ffd7a95 100644 --- a/src/coreclr/jit/optcse.cpp +++ b/src/coreclr/jit/optcse.cpp @@ -536,7 +536,15 @@ unsigned Compiler::optValnumCSE_Index(GenTree* tree, Statement* stmt) // than the one from its op2. For this case we want to create two different // CSE candidates. This allows us to CSE the GT_COMMA separately from its value. // - if (tree->OperGet() == GT_COMMA) + // Even this exception has an exception: for struct typed GT_COMMAs we + // cannot allow the comma and op2 to be separate candidates as, if we + // decide to CSE both the comma and its op2, then creating the store with + // the comma will sink it into the op2, potentially breaking the op2 CSE + // definition if it itself is another comma. This restriction is related to + // the fact that we do not have af first class representation for struct + // temporaries in our IR. + // + if (tree->OperIs(GT_COMMA) && !varTypeIsStruct(tree)) { // op2 is the value produced by a GT_COMMA GenTree* op2 = tree->AsOp()->gtOp2; @@ -588,7 +596,7 @@ unsigned Compiler::optValnumCSE_Index(GenTree* tree, Statement* stmt) key = vnLibNorm; } } - else // Not a GT_COMMA or a GT_CNS_INT + else // Not a primitive GT_COMMA or a GT_CNS_INT { key = vnLibNorm; } diff --git a/src/coreclr/jit/optimizebools.cpp b/src/coreclr/jit/optimizebools.cpp index 0362fdc2c91..2346ef7e9e2 100644 --- a/src/coreclr/jit/optimizebools.cpp +++ b/src/coreclr/jit/optimizebools.cpp @@ -1327,7 +1327,6 @@ void OptBoolsDsc::optOptimizeBoolsUpdateTrees() assert(m_b2->KindIs(BBJ_COND)); assert(m_b1->TrueTargetIs(m_b2->GetTrueTarget())); assert(m_b1->FalseTargetIs(m_b2)); - assert(!m_b2->IsLast()); // We now reach B2's false target via B1 false. // diff --git a/src/coreclr/jit/optimizer.cpp b/src/coreclr/jit/optimizer.cpp index 8884866b725..2f06cabc2f4 100644 --- a/src/coreclr/jit/optimizer.cpp +++ b/src/coreclr/jit/optimizer.cpp @@ -17,26 +17,6 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX /*****************************************************************************/ -void Compiler::optInit() -{ - fgHasLoops = false; - - optLoopsCanonical = false; - - /* Keep track of the number of calls and indirect calls made by this method */ - optCallCount = 0; - optIndirectCallCount = 0; - optNativeCallCount = 0; - optAssertionCount = 0; - optAssertionDep = nullptr; - optCSEstart = BAD_VAR_NUM; - optCSEcount = 0; - optCSECandidateCount = 0; - optCSEattempt = 0; - optCSEheuristic = nullptr; - optCSEunmarks = 0; -} - DataFlow::DataFlow(Compiler* pCompiler) : m_pCompiler(pCompiler) { @@ -2848,7 +2828,7 @@ void Compiler::optCompactLoop(FlowGraphNaturalLoop* loop) if (insertionPoint == nullptr) { - insertionPoint = optFindLoopCompactionInsertionPoint(loop, top); + insertionPoint = loop->GetLexicallyBottomMostBlock(); } BasicBlock* previous = cur->Prev(); @@ -2862,8 +2842,6 @@ void Compiler::optCompactLoop(FlowGraphNaturalLoop* loop) } // Now physically move the blocks. - BasicBlock* moveBefore = insertionPoint->Next(); - fgUnlinkRange(cur, lastNonLoopBlock); fgMoveBlocksAfter(cur, lastNonLoopBlock, insertionPoint); ehUpdateLastBlocks(insertionPoint, lastNonLoopBlock); @@ -2875,137 +2853,6 @@ void Compiler::optCompactLoop(FlowGraphNaturalLoop* loop) } } -//----------------------------------------------------------------------------- -// optFindLoopCompactionInsertionPoint: Find a good insertion point at which to -// move blocks from the lexical range of "loop" that is not part of the loop. -// -// Parameters: -// loop - The loop -// top - Lexical top block of the loop. -// -// Returns: -// Non-null insertion point. -// -BasicBlock* Compiler::optFindLoopCompactionInsertionPoint(FlowGraphNaturalLoop* loop, BasicBlock* top) -{ - // Find an insertion point for blocks we're going to move. Move them down - // out of the loop, and if possible find a spot that won't break up fall-through. - BasicBlock* bottom = loop->GetLexicallyBottomMostBlock(); - BasicBlock* insertionPoint = bottom; - while (!insertionPoint->IsLast()) - { - switch (insertionPoint->GetKind()) - { - case BBJ_ALWAYS: - if (!insertionPoint->JumpsToNext()) - { - // Found a branch that isn't to the next block, so we won't split up any fall-through. - return insertionPoint; - } - break; - - case BBJ_COND: - if (!insertionPoint->FalseTargetIs(insertionPoint->Next())) - { - // Found a conditional branch that doesn't have a false branch to the next block, - // so we won't split up any fall-through. - return insertionPoint; - } - break; - - case BBJ_CALLFINALLY: - if (!insertionPoint->isBBCallFinallyPair()) - { - // Found a retless BBJ_CALLFINALLY block, so we won't split up any fall-through. - return insertionPoint; - } - break; - - default: - // No fall-through to split up. - return insertionPoint; - } - - // Keep looking for a better insertion point if we can. - BasicBlock* newInsertionPoint = optTryAdvanceLoopCompactionInsertionPoint(loop, insertionPoint, top, bottom); - if (newInsertionPoint == nullptr) - { - // Ran out of candidate insertion points, so just split up the fall-through. - break; - } - - insertionPoint = newInsertionPoint; - } - - return insertionPoint; -} - -//----------------------------------------------------------------------------- -// optTryAdvanceLoopCompactionInsertionPoint: Advance the insertion point to -// avoid having to insert new blocks due to fallthrough. -// -// Parameters: -// loop - The loop -// insertionPoint - Current insertion point -// top - Lexical top block of the loop. -// bottom - Lexical bottom block of the loop. -// -// Returns: -// New insertion point. -// -BasicBlock* Compiler::optTryAdvanceLoopCompactionInsertionPoint(FlowGraphNaturalLoop* loop, - BasicBlock* insertionPoint, - BasicBlock* top, - BasicBlock* bottom) -{ - BasicBlock* newInsertionPoint = insertionPoint->Next(); - - if (!BasicBlock::sameEHRegion(insertionPoint, newInsertionPoint)) - { - // Don't cross an EH region boundary. - return nullptr; - } - - // TODO-Quirk: Compatibility with old compaction - if (newInsertionPoint->KindIs(BBJ_ALWAYS, BBJ_COND)) - { - BasicBlock* dest = - newInsertionPoint->KindIs(BBJ_ALWAYS) ? newInsertionPoint->GetTarget() : newInsertionPoint->GetTrueTarget(); - if ((dest->bbNum >= top->bbNum) && (dest->bbNum <= bottom->bbNum) && !loop->ContainsBlock(dest)) - { - return nullptr; - } - } - - // TODO-Quirk: Compatibility with old compaction - for (BasicBlock* const predBlock : newInsertionPoint->PredBlocks()) - { - if ((predBlock->bbNum >= top->bbNum) && (predBlock->bbNum <= bottom->bbNum) && !loop->ContainsBlock(predBlock)) - { - // Don't make this forward edge a backwards edge. - return nullptr; - } - } - - // Compaction runs on outer loops before inner loops. That means all - // unlexical blocks here are part of an ancestor loop (or trivial - // BBJ_ALWAYS exit blocks). To avoid breaking lexicality of ancestor loops - // we avoid moving any block past the bottom of an ancestor loop. - for (FlowGraphNaturalLoop* ancestor = loop->GetParent(); ancestor != nullptr; ancestor = ancestor->GetParent()) - { - if (newInsertionPoint == ancestor->GetLexicallyBottomMostBlock()) - { - return nullptr; - } - } - - // Advancing the insertion point is ok, except that we can't split up any call finally - // pair, so if we've got such a pair recurse to see if we can move past the whole thing. - return newInsertionPoint->isBBCallFinallyPair() - ? optTryAdvanceLoopCompactionInsertionPoint(loop, newInsertionPoint, top, bottom) - : newInsertionPoint; -} - //----------------------------------------------------------------------------- // optCreatePreheader: Create (or find) a preheader for a natural loop. // @@ -3044,16 +2891,10 @@ bool Compiler::optCreatePreheader(FlowGraphNaturalLoop* loop) } } - BasicBlock* insertBefore = loop->GetLexicallyTopMostBlock(); - if (!BasicBlock::sameEHRegion(insertBefore, header)) - { - insertBefore = header; - } - - BasicBlock* preheader = fgNewBBbefore(BBJ_ALWAYS, insertBefore, false); + BasicBlock* preheader = fgNewBBbefore(BBJ_ALWAYS, header, false); preheader->SetFlags(BBF_INTERNAL); fgSetEHRegionForNewPreheaderOrExit(preheader); - preheader->bbCodeOffs = insertBefore->bbCodeOffs; + preheader->bbCodeOffs = header->bbCodeOffs; JITDUMP("Created new preheader " FMT_BB " for " FMT_LP "\n", preheader->bbNum, loop->GetIndex()); @@ -3156,21 +2997,11 @@ bool Compiler::optCanonicalizeExit(FlowGraphNaturalLoop* loop, BasicBlock* exit) { // Branches to a BBJ_CALLFINALLY _must_ come from inside its associated // try region, and when we have callfinally thunks the BBJ_CALLFINALLY - // is outside it. First try to see if the lexically bottom most block - // is part of the try; if so, inserting after that is a good choice. + // is outside it. Thus, insert newExit at the end of the finally's + // try region. BasicBlock* finallyBlock = exit->GetTarget(); assert(finallyBlock->hasHndIndex()); - BasicBlock* bottom = loop->GetLexicallyBottomMostBlock(); - if (bottom->hasTryIndex() && (bottom->getTryIndex() == finallyBlock->getHndIndex()) && !bottom->hasHndIndex()) - { - newExit = fgNewBBafter(BBJ_ALWAYS, bottom, true); - } - else - { - // Otherwise just do the heavy-handed thing and insert it anywhere in the right region. - newExit = fgNewBBinRegion(BBJ_ALWAYS, finallyBlock->bbHndIndex, 0, nullptr, /* putInFilter */ false, - /* runRarely */ false, /* insertAtEnd */ true); - } + newExit = fgNewBBatTryRegionEnd(BBJ_ALWAYS, finallyBlock->getHndIndex()); } else { diff --git a/src/coreclr/jit/scev.cpp b/src/coreclr/jit/scev.cpp index 540d5bed9f0..8ae11130be6 100644 --- a/src/coreclr/jit/scev.cpp +++ b/src/coreclr/jit/scev.cpp @@ -515,6 +515,11 @@ Scev* ScalarEvolutionContext::CreateScevForConstant(GenTreeIntConCommon* tree) // Scev* ScalarEvolutionContext::AnalyzeNew(BasicBlock* block, GenTree* tree, int depth) { + if (!varTypeIsIntegralOrI(tree->TypeGet())) + { + return nullptr; + } + switch (tree->OperGet()) { case GT_CNS_INT: diff --git a/src/coreclr/jit/simd.h b/src/coreclr/jit/simd.h index 507fbd62406..1a0748667b3 100644 --- a/src/coreclr/jit/simd.h +++ b/src/coreclr/jit/simd.h @@ -363,6 +363,11 @@ typedef simd64_t simd_t; typedef simd16_t simd_t; #endif +inline bool IsUnaryBitwiseOperation(genTreeOps oper) +{ + return (oper == GT_LZCNT) || (oper == GT_NOT); +} + template TBase EvaluateUnaryScalarSpecialized(genTreeOps oper, TBase arg0) { @@ -404,27 +409,35 @@ TBase EvaluateUnaryScalarSpecialized(genTreeOps oper, TBase arg0) template <> inline float EvaluateUnaryScalarSpecialized(genTreeOps oper, float arg0) { - if (oper == GT_NEG) + switch (oper) { - return -arg0; - } + case GT_NEG: + { + return -arg0; + } - uint32_t arg0Bits = BitOperations::SingleToUInt32Bits(arg0); - uint32_t resultBits = EvaluateUnaryScalarSpecialized(oper, arg0Bits); - return BitOperations::UInt32BitsToSingle(resultBits); + default: + { + unreached(); + } + } } template <> inline double EvaluateUnaryScalarSpecialized(genTreeOps oper, double arg0) { - if (oper == GT_NEG) + switch (oper) { - return -arg0; - } + case GT_NEG: + { + return -arg0; + } - uint64_t arg0Bits = BitOperations::DoubleToUInt64Bits(arg0); - uint64_t resultBits = EvaluateUnaryScalarSpecialized(oper, arg0Bits); - return BitOperations::UInt64BitsToDouble(resultBits); + default: + { + unreached(); + } + } } template @@ -600,13 +613,37 @@ void EvaluateUnarySimd(genTreeOps oper, bool scalar, var_types baseType, TSimd* { case TYP_FLOAT: { - EvaluateUnarySimd(oper, scalar, result, arg0); + // Some operations are bitwise and we want to ensure inputs like + // sNaN are preserved rather than being converted to a qNaN when + // the CPU encounters them. So we check for and handle that early + // prior to extracting the element out of the vector value. + + if (IsUnaryBitwiseOperation(oper)) + { + EvaluateUnarySimd(oper, scalar, result, arg0); + } + else + { + EvaluateUnarySimd(oper, scalar, result, arg0); + } break; } case TYP_DOUBLE: { - EvaluateUnarySimd(oper, scalar, result, arg0); + // Some operations are bitwise and we want to ensure inputs like + // sNaN are preserved rather than being converted to a qNaN when + // the CPU encounters them. So we check for and handle that early + // prior to extracting the element out of the vector value. + + if (IsUnaryBitwiseOperation(oper)) + { + EvaluateUnarySimd(oper, scalar, result, arg0); + } + else + { + EvaluateUnarySimd(oper, scalar, result, arg0); + } break; } @@ -665,6 +702,12 @@ void EvaluateUnarySimd(genTreeOps oper, bool scalar, var_types baseType, TSimd* } } +inline bool IsBinaryBitwiseOperation(genTreeOps oper) +{ + return (oper == GT_AND) || (oper == GT_AND_NOT) || (oper == GT_LSH) || (oper == GT_OR) || (oper == GT_ROL) || + (oper == GT_ROR) || (oper == GT_RSH) || (oper == GT_RSZ) || (oper == GT_XOR); +} + template TBase EvaluateBinaryScalarRSZ(TBase arg0, TBase arg1) { @@ -802,17 +845,27 @@ TBase EvaluateBinaryScalarSpecialized(genTreeOps oper, TBase arg0, TBase arg1) case GT_ROL: { // Normalize the "rotate by" value - arg1 %= (sizeof(TBase) * BITS_PER_BYTE); + // EvaluateBinaryScalarRSZ allows overshifting and treats + // it as zeroing. + // But ROL ensures the rotateAmount is masked + // to be within range, so we pre-calculates this. + unsigned rotateCountMask = (sizeof(TBase) * BITS_PER_BYTE) - 1; + arg1 &= rotateCountMask; return EvaluateBinaryScalarSpecialized(GT_LSH, arg0, arg1) | - EvaluateBinaryScalarRSZ(arg0, (sizeof(TBase) * 8) - arg1); + EvaluateBinaryScalarRSZ(arg0, (sizeof(TBase) * BITS_PER_BYTE) - arg1); } case GT_ROR: { // Normalize the "rotate by" value - arg1 %= (sizeof(TBase) * BITS_PER_BYTE); + // EvaluateBinaryScalarRSZ allows overshifting and treats + // it as zeroing. + // But ROR ensures the rotateAmount is masked + // to be within range, so we pre-calculates this. + unsigned rotateCountMask = (sizeof(TBase) * BITS_PER_BYTE) - 1; + arg1 &= rotateCountMask; return EvaluateBinaryScalarRSZ(arg0, arg1) | - EvaluateBinaryScalarSpecialized(GT_LSH, arg0, (sizeof(TBase) * 8) - arg1); + EvaluateBinaryScalarSpecialized(GT_LSH, arg0, (sizeof(TBase) * BITS_PER_BYTE) - arg1); } case GT_RSH: @@ -892,11 +945,7 @@ inline float EvaluateBinaryScalarSpecialized(genTreeOps oper, float arg0, default: { - uint32_t arg0Bits = BitOperations::SingleToUInt32Bits(arg0); - uint32_t arg1Bits = BitOperations::SingleToUInt32Bits(arg1); - - uint32_t resultBits = EvaluateBinaryScalarSpecialized(oper, arg0Bits, arg1Bits); - return BitOperations::UInt32BitsToSingle(resultBits); + unreached(); } } } @@ -938,11 +987,7 @@ inline double EvaluateBinaryScalarSpecialized(genTreeOps oper, double ar default: { - uint64_t arg0Bits = BitOperations::DoubleToUInt64Bits(arg0); - uint64_t arg1Bits = BitOperations::DoubleToUInt64Bits(arg1); - - uint64_t resultBits = EvaluateBinaryScalarSpecialized(oper, arg0Bits, arg1Bits); - return BitOperations::UInt64BitsToDouble(resultBits); + unreached(); } } } @@ -1178,13 +1223,37 @@ void EvaluateBinarySimd( { case TYP_FLOAT: { - EvaluateBinarySimd(oper, scalar, result, arg0, arg1); + // Some operations are bitwise and we want to ensure inputs like + // sNaN are preserved rather than being converted to a qNaN when + // the CPU encounters them. So we check for and handle that early + // prior to extracting the element out of the vector value. + + if (IsBinaryBitwiseOperation(oper)) + { + EvaluateBinarySimd(oper, scalar, result, arg0, arg1); + } + else + { + EvaluateBinarySimd(oper, scalar, result, arg0, arg1); + } break; } case TYP_DOUBLE: { - EvaluateBinarySimd(oper, scalar, result, arg0, arg1); + // Some operations are bitwise and we want to ensure inputs like + // sNaN are preserved rather than being converted to a qNaN when + // the CPU encounters them. So we check for and handle that early + // prior to extracting the element out of the vector value. + + if (IsBinaryBitwiseOperation(oper)) + { + EvaluateBinarySimd(oper, scalar, result, arg0, arg1); + } + else + { + EvaluateBinarySimd(oper, scalar, result, arg0, arg1); + } break; } diff --git a/src/coreclr/jit/simdashwintrinsic.cpp b/src/coreclr/jit/simdashwintrinsic.cpp index 7c36076fa90..bfb24b6c7ed 100644 --- a/src/coreclr/jit/simdashwintrinsic.cpp +++ b/src/coreclr/jit/simdashwintrinsic.cpp @@ -593,6 +593,18 @@ GenTree* Compiler::impSimdAsHWIntrinsicSpecial(NamedIntrinsic intrinsic, break; } +#if defined(TARGET_X86) + case NI_VectorT_ToScalar: + { + if (varTypeIsLong(simdBaseType) && !compOpportunisticallyDependsOn(InstructionSet_SSE41)) + { + return nullptr; + } + + break; + } +#endif // TARGET_X86 + #if defined(TARGET_XARCH) case NI_VectorT_GetElement: { @@ -993,6 +1005,8 @@ GenTree* Compiler::impSimdAsHWIntrinsicSpecial(NamedIntrinsic intrinsic, #if defined(TARGET_X86) if (varTypeIsLong(simdBaseType)) { + // We should have verified SSE41 was available above. + assert(compIsaSupportedDebugOnly(InstructionSet_SSE41)); op2 = gtNewIconNode(0); return gtNewSimdGetElementNode(retType, op1, op2, simdBaseJitType, simdSize); } diff --git a/src/coreclr/jit/switchrecognition.cpp b/src/coreclr/jit/switchrecognition.cpp index dcfb57cabf4..b0d2fe94552 100644 --- a/src/coreclr/jit/switchrecognition.cpp +++ b/src/coreclr/jit/switchrecognition.cpp @@ -50,17 +50,19 @@ PhaseStatus Compiler::optSwitchRecognition() // constant test? e.g. JTRUE(EQ/NE(X, CNS)). // // Arguments: -// block - The block to check -// trueEdge - [out] The successor edge taken if X == CNS -// falseEdge - [out] The successor edge taken if X != CNS -// isReversed - [out] True if the condition is reversed (GT_NE) -// variableNode - [out] The variable node (X in the example above) -// cns - [out] The constant value (CNS in the example above) +// block - The block to check +// allowSideEffects - is variableNode allowed to have side-effects (COMMA)? +// trueEdge - [out] The successor edge taken if X == CNS +// falseEdge - [out] The successor edge taken if X != CNS +// isReversed - [out] True if the condition is reversed (GT_NE) +// variableNode - [out] The variable node (X in the example above) +// cns - [out] The constant value (CNS in the example above) // // Return Value: // True if the block represents a constant test, false otherwise // bool IsConstantTestCondBlock(const BasicBlock* block, + bool allowSideEffects, BasicBlock** trueTarget, BasicBlock** falseTarget, bool* isReversed, @@ -88,8 +90,14 @@ bool IsConstantTestCondBlock(const BasicBlock* block, // We're looking for "X EQ/NE CNS" or "CNS EQ/NE X" pattern if ((op1->IsCnsIntOrI() && !op1->IsIconHandle()) ^ (op2->IsCnsIntOrI() && !op2->IsIconHandle())) { - // TODO: relax this to support any side-effect free expression - if (!op1->OperIs(GT_LCL_VAR) && !op2->OperIs(GT_LCL_VAR)) + if (allowSideEffects) + { + if (!op1->gtEffectiveVal()->OperIs(GT_LCL_VAR) && !op2->gtEffectiveVal()->OperIs(GT_LCL_VAR)) + { + return false; + } + } + else if (!op1->OperIs(GT_LCL_VAR) && !op2->OperIs(GT_LCL_VAR)) { return false; } @@ -148,7 +156,7 @@ bool Compiler::optSwitchDetectAndConvert(BasicBlock* firstBlock) // and then try to accumulate as many constant test blocks as possible. Once we hit // a block that doesn't match the pattern, we start processing the accumulated blocks. bool isReversed = false; - if (IsConstantTestCondBlock(firstBlock, &trueTarget, &falseTarget, &isReversed, &variableNode, &cns)) + if (IsConstantTestCondBlock(firstBlock, true, &trueTarget, &falseTarget, &isReversed, &variableNode, &cns)) { if (isReversed) { @@ -185,8 +193,8 @@ bool Compiler::optSwitchDetectAndConvert(BasicBlock* firstBlock) } // Inspect secondary blocks - if (IsConstantTestCondBlock(currBb, &currTrueTarget, &currFalseTarget, &isReversed, &currVariableNode, - &currCns)) + if (IsConstantTestCondBlock(currBb, false, &currTrueTarget, &currFalseTarget, &isReversed, + &currVariableNode, &currCns)) { if (currTrueTarget != trueTarget) { @@ -194,7 +202,7 @@ bool Compiler::optSwitchDetectAndConvert(BasicBlock* firstBlock) return optSwitchConvert(firstBlock, testValueIndex, testValues, falseLikelihood, variableNode); } - if (!GenTree::Compare(currVariableNode, variableNode)) + if (!GenTree::Compare(currVariableNode, variableNode->gtEffectiveVal())) { // A different variable node is used, stop searching and process what we already have. return optSwitchConvert(firstBlock, testValueIndex, testValues, falseLikelihood, variableNode); @@ -324,7 +332,7 @@ bool Compiler::optSwitchConvert( BasicBlock* blockIfTrue = nullptr; BasicBlock* blockIfFalse = nullptr; bool isReversed = false; - const bool isTest = IsConstantTestCondBlock(lastBlock, &blockIfTrue, &blockIfFalse, &isReversed); + const bool isTest = IsConstantTestCondBlock(lastBlock, false, &blockIfTrue, &blockIfFalse, &isReversed); assert(isTest); assert(firstBlock->TrueTargetIs(blockIfTrue)); @@ -337,7 +345,7 @@ bool Compiler::optSwitchConvert( firstBlock->lastStmt()->GetRootNode()->ChangeOper(GT_SWITCH); // The root node is now SUB(nodeToTest, minValue) if minValue != 0 - GenTree* switchValue = gtCloneExpr(nodeToTest); + GenTree* switchValue = nodeToTest; if (minValue != 0) { switchValue = diff --git a/src/coreclr/jit/unwindloongarch64.cpp b/src/coreclr/jit/unwindloongarch64.cpp index e46d3ec60e0..1db7a41318e 100644 --- a/src/coreclr/jit/unwindloongarch64.cpp +++ b/src/coreclr/jit/unwindloongarch64.cpp @@ -121,100 +121,100 @@ short Compiler::mapRegNumToDwarfReg(regNumber reg) dwarfReg = 31; break; case REG_F0: - dwarfReg = 64; + dwarfReg = 32; break; case REG_F1: - dwarfReg = 65; + dwarfReg = 33; break; case REG_F2: - dwarfReg = 66; + dwarfReg = 34; break; case REG_F3: - dwarfReg = 67; + dwarfReg = 35; break; case REG_F4: - dwarfReg = 68; + dwarfReg = 36; break; case REG_F5: - dwarfReg = 69; + dwarfReg = 37; break; case REG_F6: - dwarfReg = 70; + dwarfReg = 38; break; case REG_F7: - dwarfReg = 71; + dwarfReg = 39; break; case REG_F8: - dwarfReg = 72; + dwarfReg = 40; break; case REG_F9: - dwarfReg = 73; + dwarfReg = 41; break; case REG_F10: - dwarfReg = 74; + dwarfReg = 42; break; case REG_F11: - dwarfReg = 75; + dwarfReg = 43; break; case REG_F12: - dwarfReg = 76; + dwarfReg = 44; break; case REG_F13: - dwarfReg = 77; + dwarfReg = 45; break; case REG_F14: - dwarfReg = 78; + dwarfReg = 46; break; case REG_F15: - dwarfReg = 79; + dwarfReg = 47; break; case REG_F16: - dwarfReg = 80; + dwarfReg = 48; break; case REG_F17: - dwarfReg = 81; + dwarfReg = 49; break; case REG_F18: - dwarfReg = 82; + dwarfReg = 50; break; case REG_F19: - dwarfReg = 83; + dwarfReg = 51; break; case REG_F20: - dwarfReg = 84; + dwarfReg = 52; break; case REG_F21: - dwarfReg = 85; + dwarfReg = 53; break; case REG_F22: - dwarfReg = 86; + dwarfReg = 54; break; case REG_F23: - dwarfReg = 87; + dwarfReg = 55; break; case REG_F24: - dwarfReg = 88; + dwarfReg = 56; break; case REG_F25: - dwarfReg = 89; + dwarfReg = 57; break; case REG_F26: - dwarfReg = 90; + dwarfReg = 58; break; case REG_F27: - dwarfReg = 91; + dwarfReg = 59; break; case REG_F28: - dwarfReg = 92; + dwarfReg = 60; break; case REG_F29: - dwarfReg = 93; + dwarfReg = 61; break; case REG_F30: - dwarfReg = 94; + dwarfReg = 62; break; case REG_F31: - dwarfReg = 95; + dwarfReg = 63; break; default: diff --git a/src/coreclr/jit/utils.cpp b/src/coreclr/jit/utils.cpp index 3a5441ac645..460fed71bab 100644 --- a/src/coreclr/jit/utils.cpp +++ b/src/coreclr/jit/utils.cpp @@ -1626,8 +1626,6 @@ void HelperCallProperties::init() case CORINFO_HELP_RUNTIMEHANDLE_METHOD: case CORINFO_HELP_RUNTIMEHANDLE_CLASS: - case CORINFO_HELP_RUNTIMEHANDLE_METHOD_LOG: - case CORINFO_HELP_RUNTIMEHANDLE_CLASS_LOG: // logging helpers are not technically pure but can be optimized away isPure = true; noThrow = true; @@ -1826,7 +1824,6 @@ void HelperCallProperties::init() isNoGC = true; FALLTHROUGH; case CORINFO_HELP_DBG_IS_JUST_MY_CODE: - case CORINFO_HELP_BBT_FCN_ENTER: case CORINFO_HELP_POLL_GC: case CORINFO_HELP_MON_ENTER: case CORINFO_HELP_MON_EXIT: @@ -2296,8 +2293,7 @@ double FloatingPointUtils::convertUInt64ToDouble(uint64_t uIntVal) float FloatingPointUtils::convertUInt64ToFloat(uint64_t u64) { - double d = convertUInt64ToDouble(u64); - return (float)d; + return (float)u64; } uint64_t FloatingPointUtils::convertDoubleToUInt64(double d) diff --git a/src/coreclr/jit/valuenum.cpp b/src/coreclr/jit/valuenum.cpp index 56d4d789031..3b0aea70d24 100644 --- a/src/coreclr/jit/valuenum.cpp +++ b/src/coreclr/jit/valuenum.cpp @@ -10303,7 +10303,9 @@ void ValueNumStore::vnDumpSimdType(Compiler* comp, VNFuncApp* simdType) int simdSize = ConstantValue(simdType->m_args[0]); CorInfoType baseJitType = (CorInfoType)ConstantValue(simdType->m_args[1]); - printf("%s(simd%d, %s)", VNFuncName(simdType->m_func), simdSize, varTypeName(JitType2PreciseVarType(baseJitType))); + printf("%s(simd%d, %s)", VNFuncName(simdType->m_func), simdSize, + baseJitType == CORINFO_TYPE_UNDEF ? varTypeName(TYP_UNDEF) + : varTypeName(JitType2PreciseVarType(baseJitType))); } #endif // FEATURE_SIMD @@ -11011,7 +11013,13 @@ void Compiler::fgValueNumberBlock(BasicBlock* blk) ValueNum newMemoryVN; FlowGraphNaturalLoop* loop = m_blockToLoop->GetLoop(blk); - if ((loop != nullptr) && (loop->GetHeader() == blk)) + if (bbIsHandlerBeg(blk)) + { + // We do not model memory SSA faithfully for handling (in particular, we do not model that + // the handler may see memory states from intermediate points in the enclosed blocks) + newMemoryVN = vnStore->VNForExpr(blk, TYP_HEAP); + } + else if ((loop != nullptr) && (loop->GetHeader() == blk)) { newMemoryVN = fgMemoryVNForLoopSideEffects(memoryKind, blk, loop); } @@ -11145,6 +11153,7 @@ void Compiler::fgValueNumberPhiDef(GenTreeLclVar* newSsaDef, BasicBlock* blk, bo GenTreePhi* phiNode = newSsaDef->AsLclVar()->Data()->AsPhi(); ValueNumPair sameVNP; + VNSet loopInvariantCache(getAllocator(CMK_ValueNumber)); for (GenTreePhi::Use& use : phiNode->Uses()) { @@ -11165,16 +11174,34 @@ void Compiler::fgValueNumberPhiDef(GenTreeLclVar* newSsaDef, BasicBlock* blk, bo ValueNumPair phiArgVNP = lvaGetDesc(phiArg)->GetPerSsaData(phiArg->GetSsaNum())->m_vnPair; -#ifdef DEBUG - if (verbose && isUpdate && (phiArgVNP != phiArg->gtVNPair)) + if (isUpdate && (phiArgVNP != phiArg->gtVNPair)) { - printf("Updating phi arg [%06u] VN from ", dspTreeID(phiArg)); - vnpPrint(phiArg->gtVNPair, 0); - printf(" to "); - vnpPrint(phiArgVNP, 0); - printf("\n"); - } + FlowGraphNaturalLoop* const blockLoop = m_loops->GetLoopByHeader(blk); + bool const canUseNewVN = optVNIsLoopInvariant(phiArgVNP.GetConservative(), blockLoop, &loopInvariantCache); + + if (canUseNewVN) + { +#ifdef DEBUG + if (verbose) + { + printf("Updating phi arg [%06u] VN from ", dspTreeID(phiArg)); + vnpPrint(phiArg->gtVNPair, 0); + printf(" to "); + vnpPrint(phiArgVNP, 0); + printf("\n"); + } #endif + } + else + { + JITDUMP("Can't update phi arg [%06u] with " FMT_VN " -- varies in " FMT_LP "\n", dspTreeID(phiArg), + phiArgVNP.GetConservative(), blockLoop->GetIndex()); + + // Code below uses phiArgVNP, reset to the old value + // + phiArgVNP = phiArg->gtVNPair; + } + } phiArg->gtVNPair = phiArgVNP; @@ -13931,7 +13958,6 @@ VNFunc Compiler::fgValueNumberJitHelperMethodVNFunc(CorInfoHelpFunc helpFunc) break; case CORINFO_HELP_RUNTIMEHANDLE_METHOD: - case CORINFO_HELP_RUNTIMEHANDLE_METHOD_LOG: vnf = VNF_RuntimeHandleMethod; break; @@ -13940,7 +13966,6 @@ VNFunc Compiler::fgValueNumberJitHelperMethodVNFunc(CorInfoHelpFunc helpFunc) break; case CORINFO_HELP_RUNTIMEHANDLE_CLASS: - case CORINFO_HELP_RUNTIMEHANDLE_CLASS_LOG: vnf = VNF_RuntimeHandleClass; break; diff --git a/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Unix.targets b/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Unix.targets index d2696ffbcad..efd3cfddaf2 100644 --- a/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Unix.targets +++ b/src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.Unix.targets @@ -24,12 +24,12 @@ The .NET Foundation licenses this file to you under the MIT license. lld bfd 1572864 - true + true libRuntime.WorkstationGC libRuntime.ServerGC @@ -168,6 +168,11 @@ The .NET Foundation licenses this file to you under the MIT license. + + + + + diff --git a/src/coreclr/nativeaot/Runtime/CommonMacros.h b/src/coreclr/nativeaot/Runtime/CommonMacros.h index 071f60bee6e..0dc80b4763b 100644 --- a/src/coreclr/nativeaot/Runtime/CommonMacros.h +++ b/src/coreclr/nativeaot/Runtime/CommonMacros.h @@ -302,14 +302,11 @@ typedef uint8_t CODE_LOCATION; typedef bool CLR_BOOL; -#if defined(TARGET_X86) || defined(TARGET_AMD64) -// The return value is artificially widened on x86 and amd64 typedef int32_t FC_BOOL_RET; -#else -typedef bool FC_BOOL_RET; -#endif +typedef int32_t FC_BOOL_ARG; #define FC_RETURN_BOOL(x) do { return !!(x); } while(0) +#define FC_ACCESS_BOOL(x) ((uint8_t)x != 0) #ifndef DACCESS_COMPILE #define IN_DAC(x) diff --git a/src/coreclr/nativeaot/Runtime/GCHelpers.cpp b/src/coreclr/nativeaot/Runtime/GCHelpers.cpp index 6975c8581e1..e2fc46b809d 100644 --- a/src/coreclr/nativeaot/Runtime/GCHelpers.cpp +++ b/src/coreclr/nativeaot/Runtime/GCHelpers.cpp @@ -178,9 +178,9 @@ FCIMPL0(int32_t, RhGetMaxGcGeneration) } FCIMPLEND -FCIMPL2(int32_t, RhGetGcCollectionCount, int32_t generation, CLR_BOOL getSpecialGCCount) +FCIMPL2(int32_t, RhGetGcCollectionCount, int32_t generation, FC_BOOL_ARG getSpecialGCCount) { - return GCHeapUtilities::GetGCHeap()->CollectionCount(generation, getSpecialGCCount); + return GCHeapUtilities::GetGCHeap()->CollectionCount(generation, FC_ACCESS_BOOL(getSpecialGCCount)); } FCIMPLEND diff --git a/src/coreclr/nativeaot/Runtime/StackFrameIterator.cpp b/src/coreclr/nativeaot/Runtime/StackFrameIterator.cpp index cd4f5d2e69e..5e75345d7af 100644 --- a/src/coreclr/nativeaot/Runtime/StackFrameIterator.cpp +++ b/src/coreclr/nativeaot/Runtime/StackFrameIterator.cpp @@ -813,11 +813,6 @@ PTR_VOID StackFrameIterator::HandleExCollide(PTR_ExInfo pExInfo) // Sync our 'current' ExInfo with the updated state (we may have skipped other dispatches) ResetNextExInfoForSP(m_RegDisplay.GetSP()); - // In case m_ControlPC is pre-adjusted, counteract here, since the caller of this routine - // will apply the adjustment again once we return. If the m_ControlPC is not pre-adjusted, - // this is simply an no-op. - m_ControlPC = m_OriginalControlPC; - m_dwFlags = curFlags; // The iterator has been moved to the "owner frame" (either a parent funclet or the main @@ -1832,7 +1827,9 @@ void StackFrameIterator::PrepareToYieldFrame() ASSERT(m_pInstance->IsManaged(m_ControlPC) || ((m_dwFlags & SkipNativeFrames) == 0 && (m_dwFlags & UnwoundReversePInvoke) != 0)); - if (m_dwFlags & ApplyReturnAddressAdjustment) + // Do not adjust the PC if ExCollide is set. In that case the m_ControlPC was copied from + // another stack frame iterator and it already has a correct value. + if ((m_dwFlags & (ApplyReturnAddressAdjustment | ExCollide)) == ApplyReturnAddressAdjustment) { m_ControlPC = AdjustReturnAddressBackward(m_ControlPC); } @@ -2141,9 +2138,9 @@ bool StackFrameIterator::Next(uint32_t* puExCollideClauseIdx, bool* pfUnwoundRev return isValid; } -FCIMPL4(FC_BOOL_RET, RhpSfiInit, StackFrameIterator* pThis, PAL_LIMITED_CONTEXT* pStackwalkCtx, CLR_BOOL instructionFault, CLR_BOOL* pfIsExceptionIntercepted) +FCIMPL4(FC_BOOL_RET, RhpSfiInit, StackFrameIterator* pThis, PAL_LIMITED_CONTEXT* pStackwalkCtx, FC_BOOL_ARG instructionFault, CLR_BOOL* pfIsExceptionIntercepted) { - bool isValid = pThis->Init(pStackwalkCtx, instructionFault); + bool isValid = pThis->Init(pStackwalkCtx, FC_ACCESS_BOOL(instructionFault)); if (pfIsExceptionIntercepted) { diff --git a/src/coreclr/nativeaot/Runtime/arm64/AllocFast.S b/src/coreclr/nativeaot/Runtime/arm64/AllocFast.S index 966b052a2b9..bb33e112ad5 100644 --- a/src/coreclr/nativeaot/Runtime/arm64/AllocFast.S +++ b/src/coreclr/nativeaot/Runtime/arm64/AllocFast.S @@ -5,13 +5,13 @@ #include "AsmOffsets.inc" // GC type flags -GC_ALLOC_FINALIZE = 1 +#define GC_ALLOC_FINALIZE 1 // // Rename fields of nested structs // -OFFSETOF__Thread__m_alloc_context__alloc_ptr = OFFSETOF__Thread__m_rgbAllocContextBuffer + OFFSETOF__gc_alloc_context__alloc_ptr -OFFSETOF__Thread__m_alloc_context__alloc_limit = OFFSETOF__Thread__m_rgbAllocContextBuffer + OFFSETOF__gc_alloc_context__alloc_limit +#define OFFSETOF__Thread__m_alloc_context__alloc_ptr (OFFSETOF__Thread__m_rgbAllocContextBuffer + OFFSETOF__gc_alloc_context__alloc_ptr) +#define OFFSETOF__Thread__m_alloc_context__alloc_limit (OFFSETOF__Thread__m_rgbAllocContextBuffer + OFFSETOF__gc_alloc_context__alloc_limit) diff --git a/src/coreclr/nativeaot/Runtime/arm64/GcProbe.S b/src/coreclr/nativeaot/Runtime/arm64/GcProbe.S index 8075335ea0b..0a1b71eeae7 100644 --- a/src/coreclr/nativeaot/Runtime/arm64/GcProbe.S +++ b/src/coreclr/nativeaot/Runtime/arm64/GcProbe.S @@ -4,12 +4,12 @@ #include #include "AsmOffsets.inc" -PROBE_FRAME_SIZE = 0xD0 // 4 * 8 for fixed part of PInvokeTransitionFrame (fp, lr, m_pThread, m_Flags) + - // 10 * 8 for callee saved registers + - // 1 * 8 for caller SP + - // 2 * 8 for int returns + - // 1 * 8 for alignment padding + - // 4 * 16 for FP/HFA/HVA returns +#define PROBE_FRAME_SIZE 0xD0 // 4 * 8 for fixed part of PInvokeTransitionFrame (fp, lr, m_pThread, m_Flags) + + // 10 * 8 for callee saved registers + + // 1 * 8 for caller SP + + // 2 * 8 for int returns + + // 1 * 8 for alignment padding + + // 4 * 16 for FP/HFA/HVA returns // See PUSH_COOP_PINVOKE_FRAME, this macro is very similar, but also saves return registers // and accepts the register bitmask diff --git a/src/coreclr/nativeaot/Runtime/arm64/InteropThunksHelpers.S b/src/coreclr/nativeaot/Runtime/arm64/InteropThunksHelpers.S index 31d151d4890..180d68b25d7 100644 --- a/src/coreclr/nativeaot/Runtime/arm64/InteropThunksHelpers.S +++ b/src/coreclr/nativeaot/Runtime/arm64/InteropThunksHelpers.S @@ -5,7 +5,7 @@ //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DATA SECTIONS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -POINTER_SIZE = 0x08 +#define POINTER_SIZE 0x08 //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Interop Thunks Helpers ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; diff --git a/src/coreclr/nativeaot/Runtime/arm64/PInvoke.S b/src/coreclr/nativeaot/Runtime/arm64/PInvoke.S index 8ed8a497d4a..d98f7aae927 100644 --- a/src/coreclr/nativeaot/Runtime/arm64/PInvoke.S +++ b/src/coreclr/nativeaot/Runtime/arm64/PInvoke.S @@ -7,17 +7,6 @@ .global RhpTrapThreads -// Note: these must match the defs in PInvokeTransitionFrameFlags defined in rhbinder.h -PTFF_SAVE_SP = 0x00000400 - -// Bit position for the flags above, to be used with tbz / tbnz instructions -PTFF_THREAD_ABORT_BIT = 36 - -// Bit position for the flags above, to be used with tbz/tbnz instructions -TSF_Attached_Bit = 0 -TSF_SuppressGcStress_Bit = 3 -TSF_DoNotTriggerGc_Bit = 4 - // // RhpPInvoke // diff --git a/src/coreclr/nativeaot/Runtime/arm64/WriteBarriers.S b/src/coreclr/nativeaot/Runtime/arm64/WriteBarriers.S index 474509ea587..6948e0fa94a 100644 --- a/src/coreclr/nativeaot/Runtime/arm64/WriteBarriers.S +++ b/src/coreclr/nativeaot/Runtime/arm64/WriteBarriers.S @@ -116,12 +116,10 @@ 2: // We can skip the card table write if the reference is to // an object not on the epehemeral segment. - PREPARE_EXTERNAL_VAR_INDIRECT g_ephemeral_low, x12 - cmp \refReg, x12 - blo 0f - - PREPARE_EXTERNAL_VAR_INDIRECT g_ephemeral_high, x12 + PREPARE_EXTERNAL_VAR_INDIRECT g_ephemeral_low, x12 + PREPARE_EXTERNAL_VAR_INDIRECT g_ephemeral_high, x17 cmp \refReg, x12 + ccmp \refReg, x17, #0x2, hs bhs 0f // Set this objects card, if it has not already been set. @@ -222,11 +220,10 @@ LEAF_END RhpByRefAssignRefArm64, _TEXT LEAF_ENTRY RhpCheckedAssignRefArm64, _TEXT // is destReg within the heap? - PREPARE_EXTERNAL_VAR_INDIRECT g_lowest_address, x12 + PREPARE_EXTERNAL_VAR_INDIRECT g_lowest_address, x12 + PREPARE_EXTERNAL_VAR_INDIRECT g_highest_address, x17 cmp x14, x12 - - PREPARE_EXTERNAL_VAR_INDIRECT g_highest_address, x12 - ccmp x14, x12, #0x2, hs + ccmp x14, x17, #0x2, hs bhs LOCAL_LABEL(NotInHeap) b C_FUNC(RhpAssignRefArm64) diff --git a/src/coreclr/nativeaot/Runtime/arm64/WriteBarriers.asm b/src/coreclr/nativeaot/Runtime/arm64/WriteBarriers.asm index 5ccccd2a301..05a26044ddd 100644 --- a/src/coreclr/nativeaot/Runtime/arm64/WriteBarriers.asm +++ b/src/coreclr/nativeaot/Runtime/arm64/WriteBarriers.asm @@ -130,12 +130,10 @@ INVALIDGCVALUE EQU 0xCCCCCCCD 2 ;; We can skip the card table write if the reference is to ;; an object not on the epehemeral segment. - PREPARE_EXTERNAL_VAR_INDIRECT g_ephemeral_low, x12 - cmp $refReg, x12 - blo %ft0 - - PREPARE_EXTERNAL_VAR_INDIRECT g_ephemeral_high, x12 + PREPARE_EXTERNAL_VAR_INDIRECT g_ephemeral_low, x12 + PREPARE_EXTERNAL_VAR_INDIRECT g_ephemeral_high, x17 cmp $refReg, x12 + ccmp $refReg, x17, #0x2, hs bhs %ft0 ;; Set this object's card, if it hasn't already been set. @@ -179,14 +177,10 @@ INVALIDGCVALUE EQU 0xCCCCCCCD ;; The "check" of this checked write barrier - is $destReg ;; within the heap? if no, early out. - PREPARE_EXTERNAL_VAR_INDIRECT g_lowest_address, x12 + PREPARE_EXTERNAL_VAR_INDIRECT g_lowest_address, x12 + PREPARE_EXTERNAL_VAR_INDIRECT g_highest_address, x17 cmp $destReg, x12 - - PREPARE_EXTERNAL_VAR_INDIRECT g_highest_address, x12 - - ;; If $destReg >= g_lowest_address, compare $destReg to g_highest_address. - ;; Otherwise, set the C flag (0x2) to take the next branch. - ccmp $destReg, x12, #0x2, hs + ccmp $destReg, x17, #0x2, hs bhs %ft0 INSERT_UNCHECKED_WRITE_BARRIER_CORE $destReg, $refReg @@ -237,11 +231,10 @@ INVALIDGCVALUE EQU 0xCCCCCCCD LEAF_ENTRY RhpCheckedAssignRefArm64 ;; is destReg within the heap? - PREPARE_EXTERNAL_VAR_INDIRECT g_lowest_address, x12 + PREPARE_EXTERNAL_VAR_INDIRECT g_lowest_address, x12 + PREPARE_EXTERNAL_VAR_INDIRECT g_highest_address, x17 cmp x14, x12 - - PREPARE_EXTERNAL_VAR_INDIRECT g_highest_address, x12 - ccmp x14, x12, #0x2, hs + ccmp x14, x17, #0x2, hs blo RhpAssignRefArm64 NotInHeap diff --git a/src/coreclr/nativeaot/Runtime/loongarch64/AllocFast.S b/src/coreclr/nativeaot/Runtime/loongarch64/AllocFast.S index dc344183e92..b40571eeaa1 100644 --- a/src/coreclr/nativeaot/Runtime/loongarch64/AllocFast.S +++ b/src/coreclr/nativeaot/Runtime/loongarch64/AllocFast.S @@ -5,13 +5,13 @@ #include "AsmOffsets.inc" // GC type flags -GC_ALLOC_FINALIZE = 1 +#define GC_ALLOC_FINALIZE 1 // // Rename fields of nested structs // -OFFSETOF__Thread__m_alloc_context__alloc_ptr = OFFSETOF__Thread__m_rgbAllocContextBuffer + OFFSETOF__gc_alloc_context__alloc_ptr -OFFSETOF__Thread__m_alloc_context__alloc_limit = OFFSETOF__Thread__m_rgbAllocContextBuffer + OFFSETOF__gc_alloc_context__alloc_limit +#define OFFSETOF__Thread__m_alloc_context__alloc_ptr (OFFSETOF__Thread__m_rgbAllocContextBuffer + OFFSETOF__gc_alloc_context__alloc_ptr) +#define OFFSETOF__Thread__m_alloc_context__alloc_limit (OFFSETOF__Thread__m_rgbAllocContextBuffer + OFFSETOF__gc_alloc_context__alloc_limit) diff --git a/src/coreclr/nativeaot/Runtime/loongarch64/GcProbe.S b/src/coreclr/nativeaot/Runtime/loongarch64/GcProbe.S index 497666bff3a..ac29bfa0f1e 100644 --- a/src/coreclr/nativeaot/Runtime/loongarch64/GcProbe.S +++ b/src/coreclr/nativeaot/Runtime/loongarch64/GcProbe.S @@ -4,12 +4,12 @@ #include #include "AsmOffsets.inc" -PROBE_FRAME_SIZE = 0xD0 // 4 * 8 for fixed part of PInvokeTransitionFrame (fp, ra, m_pThread, m_Flags) + - // 10 * 8 for callee saved registers + - // 1 * 8 for caller SP + - // 2 * 8 for int returns + - // 1 * 8 for alignment padding + - // 4 * 16 for FP returns +#define PROBE_FRAME_SIZE 0xD0 // 4 * 8 for fixed part of PInvokeTransitionFrame (fp, ra, m_pThread, m_Flags) + + // 10 * 8 for callee saved registers + + // 1 * 8 for caller SP + + // 2 * 8 for int returns + + // 1 * 8 for alignment padding + + // 4 * 16 for FP returns // See PUSH_COOP_PINVOKE_FRAME, this macro is very similar, but also saves return registers // and accepts the register bitmask diff --git a/src/coreclr/nativeaot/Runtime/loongarch64/InteropThunksHelpers.S b/src/coreclr/nativeaot/Runtime/loongarch64/InteropThunksHelpers.S index c096d777963..01a4246c34c 100644 --- a/src/coreclr/nativeaot/Runtime/loongarch64/InteropThunksHelpers.S +++ b/src/coreclr/nativeaot/Runtime/loongarch64/InteropThunksHelpers.S @@ -5,7 +5,7 @@ //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DATA SECTIONS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -POINTER_SIZE = 0x08 +#define POINTER_SIZE 0x08 //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Interop Thunks Helpers ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; diff --git a/src/coreclr/nativeaot/Runtime/loongarch64/PInvoke.S b/src/coreclr/nativeaot/Runtime/loongarch64/PInvoke.S index 5d17a016cc9..459ac9eb5c8 100644 --- a/src/coreclr/nativeaot/Runtime/loongarch64/PInvoke.S +++ b/src/coreclr/nativeaot/Runtime/loongarch64/PInvoke.S @@ -7,12 +7,6 @@ .global RhpTrapThreads -// Note: these must match the defs in PInvokeTransitionFrameFlags defined in rhbinder.h -PTFF_SAVE_SP = 0x00000200 - -// Bit position for the flags above, to be used with andi+beq/bne instructions -PTFF_THREAD_ABORT_BIT = 36 - // // RhpPInvoke // diff --git a/src/coreclr/nativeaot/Runtime/threadstore.cpp b/src/coreclr/nativeaot/Runtime/threadstore.cpp index fb6255ba118..c2b42491a38 100644 --- a/src/coreclr/nativeaot/Runtime/threadstore.cpp +++ b/src/coreclr/nativeaot/Runtime/threadstore.cpp @@ -406,9 +406,9 @@ EXTERN_C void* QCALLTYPE RhpGetCurrentThread() return ThreadStore::GetCurrentThread(); } -FCIMPL3(void, RhpInitiateThreadAbort, void* thread, Object * threadAbortException, CLR_BOOL doRudeAbort) +FCIMPL3(void, RhpInitiateThreadAbort, void* thread, Object * threadAbortException, FC_BOOL_ARG doRudeAbort) { - GetThreadStore()->InitiateThreadAbort((Thread*)thread, threadAbortException, doRudeAbort); + GetThreadStore()->InitiateThreadAbort((Thread*)thread, threadAbortException, FC_ACCESS_BOOL(doRudeAbort)); } FCIMPLEND diff --git a/src/coreclr/nativeaot/Runtime/unix/unixasmmacrosamd64.inc b/src/coreclr/nativeaot/Runtime/unix/unixasmmacrosamd64.inc index f8ec8f5037b..b1a437d8b57 100644 --- a/src/coreclr/nativeaot/Runtime/unix/unixasmmacrosamd64.inc +++ b/src/coreclr/nativeaot/Runtime/unix/unixasmmacrosamd64.inc @@ -33,7 +33,12 @@ C_FUNC(\Name): .endm .macro ALTERNATE_ENTRY Name +#if defined(__APPLE__) + .alt_entry C_FUNC(\Name) + .private_extern C_FUNC(\Name) +#else .global C_FUNC(\Name) +#endif C_FUNC(\Name): .endm @@ -306,7 +311,7 @@ C_FUNC(\Name): 1: .endm -DEFAULT_FRAME_SAVE_FLAGS = PTFF_SAVE_ALL_PRESERVED + PTFF_SAVE_RSP +#define DEFAULT_FRAME_SAVE_FLAGS (PTFF_SAVE_ALL_PRESERVED + PTFF_SAVE_RSP) .macro PUSH_COOP_PINVOKE_FRAME trashReg push_nonvol_reg rbp // push RBP frame diff --git a/src/coreclr/nativeaot/Runtime/unix/unixasmmacrosarm64.inc b/src/coreclr/nativeaot/Runtime/unix/unixasmmacrosarm64.inc index 2663406dd23..a02a770aa3b 100644 --- a/src/coreclr/nativeaot/Runtime/unix/unixasmmacrosarm64.inc +++ b/src/coreclr/nativeaot/Runtime/unix/unixasmmacrosarm64.inc @@ -24,8 +24,11 @@ C_FUNC(\Name): .endm .macro ALTERNATE_ENTRY Name +#if defined(__APPLE__) + .alt_entry C_FUNC(\Name) + .private_extern C_FUNC(\Name) +#else .global C_FUNC(\Name) -#if !defined(__APPLE__) .hidden C_FUNC(\Name) #endif C_FUNC(\Name): @@ -299,12 +302,12 @@ C_FUNC(\Name): .endm // Note: these must match the defs in PInvokeTransitionFrameFlags -PTFF_SAVE_SP = 0x00000400 -PTFF_SAVE_X0 = 0x00000800 -PTFF_SAVE_X1 = 0x00001000 -PTFF_SAVE_ALL_PRESERVED = 0x000003FF // NOTE: x19-x28 +#define PTFF_SAVE_SP 0x00000400 +#define PTFF_SAVE_X0 0x00000800 +#define PTFF_SAVE_X1 0x00001000 +#define PTFF_SAVE_ALL_PRESERVED 0x000003FF // NOTE: x19-x28 -DEFAULT_FRAME_SAVE_FLAGS = PTFF_SAVE_ALL_PRESERVED + PTFF_SAVE_SP +#define DEFAULT_FRAME_SAVE_FLAGS (PTFF_SAVE_ALL_PRESERVED + PTFF_SAVE_SP) .macro PUSH_COOP_PINVOKE_FRAME trashReg @@ -342,7 +345,7 @@ DEFAULT_FRAME_SAVE_FLAGS = PTFF_SAVE_ALL_PRESERVED + PTFF_SAVE_SP .endm // Bit position for the flags above, to be used with tbz / tbnz instructions -PTFF_THREAD_ABORT_BIT = 36 +#define PTFF_THREAD_ABORT_BIT 36 // // CONSTANTS -- INTEGER @@ -353,8 +356,8 @@ PTFF_THREAD_ABORT_BIT = 36 #define TSF_SuppressGcStress__OR__TSF_DoNotTriggerGC 0x18 // Bit position for the flags above, to be used with tbz / tbnz instructions -TrapThreadsFlags_AbortInProgress_Bit = 0 -TrapThreadsFlags_TrapThreads_Bit = 1 +#define TrapThreadsFlags_AbortInProgress_Bit 0 +#define TrapThreadsFlags_TrapThreads_Bit 1 // These must match the TrapThreadsFlags enum #define TrapThreadsFlags_None 0 diff --git a/src/coreclr/nativeaot/Runtime/unix/unixasmmacrosloongarch64.inc b/src/coreclr/nativeaot/Runtime/unix/unixasmmacrosloongarch64.inc index d7d2bedb3dd..65e9d88999c 100644 --- a/src/coreclr/nativeaot/Runtime/unix/unixasmmacrosloongarch64.inc +++ b/src/coreclr/nativeaot/Runtime/unix/unixasmmacrosloongarch64.inc @@ -158,15 +158,9 @@ C_FUNC(\Name): st.d $ra, $sp, -0x8 addi.d $sp, $sp, -16 - // This sequence of instructions is recognized and potentially patched + // This instruction is recognized and potentially patched // by the linker (GD->IE/LE relaxation). - // TODO-LOONGARCH64: Fix once TLSDESC is supported by LLVM - //la.local $a0, \var - //ld.d \target, $a0, 0 - //.tlsdesccall \var - //jirl $ra, \target, 0 - la.tls.ie $a0, \var - // End of the sequence + la.tls.desc $a0, \var ori \target, $tp, 0 add.d \target, \target, $a0 @@ -271,12 +265,12 @@ C_FUNC(\Name): .endm // Note: these must match the defs in PInvokeTransitionFrameFlags -PTFF_SAVE_SP = 0x00000200 -PTFF_SAVE_R4 = 0x00001000 -PTFF_SAVE_R5 = 0x00002000 -PTFF_SAVE_ALL_PRESERVED = 0x000001FF // NOTE: r23-r31 +#define PTFF_SAVE_SP 0x00000200 +#define PTFF_SAVE_R4 0x00001000 +#define PTFF_SAVE_R5 0x00002000 +#define PTFF_SAVE_ALL_PRESERVED 0x000001FF // NOTE: r23-r31 -DEFAULT_FRAME_SAVE_FLAGS = PTFF_SAVE_ALL_PRESERVED + PTFF_SAVE_SP +#define DEFAULT_FRAME_SAVE_FLAGS (PTFF_SAVE_ALL_PRESERVED + PTFF_SAVE_SP) .macro PUSH_COOP_PINVOKE_FRAME trashReg @@ -315,7 +309,7 @@ DEFAULT_FRAME_SAVE_FLAGS = PTFF_SAVE_ALL_PRESERVED + PTFF_SAVE_SP .endm // Bit position for the flags above, to be used with andi+beq/bne instructions -PTFF_THREAD_ABORT_BIT = 36 +#define PTFF_THREAD_ABORT_BIT 36 // // CONSTANTS -- INTEGER @@ -326,8 +320,8 @@ PTFF_THREAD_ABORT_BIT = 36 #define TSF_SuppressGcStress__OR__TSF_DoNotTriggerGC 0x18 // Bit position for the flags above, to be used with andi+beq/bne instructions -TrapThreadsFlags_AbortInProgress_Bit = 0 -TrapThreadsFlags_TrapThreads_Bit = 1 +#define TrapThreadsFlags_AbortInProgress_Bit 0 +#define TrapThreadsFlags_TrapThreads_Bit 1 // These must match the TrapThreadsFlags enum #define TrapThreadsFlags_None 0 diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/CompatibilitySuppressions.xml b/src/coreclr/nativeaot/System.Private.CoreLib/src/CompatibilitySuppressions.xml index 59195369242..507b4c14936 100644 --- a/src/coreclr/nativeaot/System.Private.CoreLib/src/CompatibilitySuppressions.xml +++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/CompatibilitySuppressions.xml @@ -709,10 +709,6 @@ CP0001 T:Internal.Runtime.CanonTypeKind - - CP0001 - T:Internal.Runtime.CompilerHelpers.ThrowHelpers - CP0001 T:Internal.Runtime.CompilerServices.FunctionPointerOps diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.xml b/src/coreclr/nativeaot/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.xml index 91859db1b0f..d5c7c1cddc9 100644 --- a/src/coreclr/nativeaot/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.xml +++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.xml @@ -1,22 +1,5 @@ - - - - - - - - - - - - - - - - - diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/Augments/RuntimeAugments.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/Augments/RuntimeAugments.cs index 6b5f341d26c..d91f8e131ba 100644 --- a/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/Augments/RuntimeAugments.cs +++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/Augments/RuntimeAugments.cs @@ -29,6 +29,7 @@ using Internal.Runtime.CompilerHelpers; using Internal.Runtime.CompilerServices; +using ExceptionStringID = Internal.TypeSystem.ExceptionStringID; using ReflectionPointer = System.Reflection.Pointer; namespace Internal.Runtime.Augments @@ -119,6 +120,32 @@ public static unsafe Array NewMultiDimArray(RuntimeTypeHandle typeHandleForArray return Array.NewMultiDimArray(typeHandleForArrayType.ToMethodTable(), pImmutableLengths, lengths.Length); } + public static unsafe void SetArrayValue(Array array, int[] indices, object value) + { + MethodTable* elementMT = array.ElementMethodTable; + + if (elementMT->IsPointer || elementMT->IsFunctionPointer) + { + Debug.Assert(value.GetMethodTable()->ValueTypeSize == IntPtr.Size); + elementMT = value.GetMethodTable(); + } + + if (elementMT->IsValueType) + { + Debug.Assert(value.GetMethodTable()->IsValueType && elementMT->ValueTypeSize == value.GetMethodTable()->ValueTypeSize); + nint flattenedIndex = array.GetFlattenedIndex(indices); + ref byte element = ref Unsafe.AddByteOffset(ref MemoryMarshal.GetArrayDataReference(array), (nuint)flattenedIndex * array.ElementSize); + RuntimeImports.RhUnbox(value, ref element, elementMT); + } + else + { + RuntimeImports.RhCheckArrayStore(array, value); + nint flattenedIndex = array.GetFlattenedIndex(indices); + ref object element = ref Unsafe.Add(ref Unsafe.As(ref MemoryMarshal.GetArrayDataReference(array)), flattenedIndex); + element = value; + } + } + public static IntPtr GetAllocateObjectHelperForType(RuntimeTypeHandle type) { return RuntimeImports.RhGetRuntimeHelperForType(type.ToMethodTable(), RuntimeHelperKind.AllocateObject); @@ -720,5 +747,45 @@ public static void RhHandleFree(IntPtr handle) { RuntimeImports.RhHandleFree(handle); } + + public static void ThrowTypeLoadExceptionWithArgument(ExceptionStringID id, string className, string typeName, string messageArg) + { + throw TypeLoaderExceptionHelper.CreateTypeLoadException(id, className, typeName, messageArg); + } + + public static void ThrowTypeLoadException(ExceptionStringID id, string className, string typeName) + { + throw TypeLoaderExceptionHelper.CreateTypeLoadException(id, className, typeName); + } + + public static void ThrowMissingMethodException(ExceptionStringID id, string methodName) + { + throw TypeLoaderExceptionHelper.CreateMissingMethodException(id, methodName); + } + + public static void ThrowMissingFieldException(ExceptionStringID id, string fieldName) + { + throw TypeLoaderExceptionHelper.CreateMissingFieldException(id, fieldName); + } + + public static void ThrowFileNotFoundException(ExceptionStringID id, string fileName) + { + throw TypeLoaderExceptionHelper.CreateFileNotFoundException(id, fileName); + } + + public static void ThrowInvalidProgramException(ExceptionStringID id) + { + throw TypeLoaderExceptionHelper.CreateInvalidProgramException(id); + } + + public static void ThrowInvalidProgramExceptionWithArgument(ExceptionStringID id, string methodName) + { + throw TypeLoaderExceptionHelper.CreateInvalidProgramException(id, methodName); + } + + public static void ThrowBadImageFormatException(ExceptionStringID id) + { + throw TypeLoaderExceptionHelper.CreateBadImageFormatException(id); + } } } diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs index 0a462fbc077..5a661b54878 100644 --- a/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs +++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs @@ -2,143 +2,123 @@ // The .NET Foundation licenses this file to you under the MIT license. using System; +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; using Internal.TypeSystem; namespace Internal.Runtime.CompilerHelpers { - /// - /// These methods are used to throw exceptions from generated code. The type and methods - /// need to be public as they constitute a public contract with the NativeAOT toolchain. - /// - public static class ThrowHelpers + internal static partial class ThrowHelpers { + [DoesNotReturn] + [DebuggerHidden] internal static void ThrowBodyRemoved() { throw new NotSupportedException(SR.NotSupported_BodyRemoved); } + [DoesNotReturn] + [DebuggerHidden] internal static void ThrowFeatureBodyRemoved() { throw new NotSupportedException(SR.NotSupported_FeatureBodyRemoved); } + [DoesNotReturn] + [DebuggerHidden] internal static void ThrowInstanceBodyRemoved() { throw new NotSupportedException(SR.NotSupported_InstanceBodyRemoved); } + [DoesNotReturn] + [DebuggerHidden] internal static void ThrowUnavailableType() { throw new TypeLoadException(SR.Arg_UnavailableTypeLoadException); } - public static void ThrowOverflowException() - { - throw new OverflowException(); - } - - public static void ThrowIndexOutOfRangeException() - { - throw new IndexOutOfRangeException(); - } - - public static void ThrowNullReferenceException() - { - throw new NullReferenceException(); - } - + [DoesNotReturn] + [DebuggerHidden] public static void ThrowDataMisalignedException() { throw new DataMisalignedException(); } - public static void ThrowDivideByZeroException() - { - throw new DivideByZeroException(); - } - - public static void ThrowArrayTypeMismatchException() - { - throw new ArrayTypeMismatchException(); - } - - public static void ThrowPlatformNotSupportedException() - { - throw new PlatformNotSupportedException(); - } - - public static void ThrowNotImplementedException() - { - throw NotImplemented.ByDesign; - } - - public static void ThrowNotSupportedException() - { - throw new NotSupportedException(); - } - - public static void ThrowBadImageFormatException(ExceptionStringID id) + [DoesNotReturn] + [DebuggerHidden] + internal static void ThrowBadImageFormatException(ExceptionStringID id) { throw TypeLoaderExceptionHelper.CreateBadImageFormatException(id); } - public static void ThrowTypeLoadException(ExceptionStringID id, string className, string typeName) + [DoesNotReturn] + [DebuggerHidden] + internal static void ThrowTypeLoadException(ExceptionStringID id, string className, string typeName) { throw TypeLoaderExceptionHelper.CreateTypeLoadException(id, className, typeName); } - public static void ThrowTypeLoadExceptionWithArgument(ExceptionStringID id, string className, string typeName, string messageArg) + [DoesNotReturn] + [DebuggerHidden] + internal static void ThrowTypeLoadExceptionWithArgument(ExceptionStringID id, string className, string typeName, string messageArg) { throw TypeLoaderExceptionHelper.CreateTypeLoadException(id, className, typeName, messageArg); } - public static void ThrowMissingMethodException(ExceptionStringID id, string methodName) + [DoesNotReturn] + [DebuggerHidden] + internal static void ThrowMissingMethodException(ExceptionStringID id, string methodName) { throw TypeLoaderExceptionHelper.CreateMissingMethodException(id, methodName); } - public static void ThrowMissingFieldException(ExceptionStringID id, string fieldName) + [DoesNotReturn] + [DebuggerHidden] + internal static void ThrowMissingFieldException(ExceptionStringID id, string fieldName) { throw TypeLoaderExceptionHelper.CreateMissingFieldException(id, fieldName); } - public static void ThrowFileNotFoundException(ExceptionStringID id, string fileName) + [DoesNotReturn] + [DebuggerHidden] + internal static void ThrowFileNotFoundException(ExceptionStringID id, string fileName) { throw TypeLoaderExceptionHelper.CreateFileNotFoundException(id, fileName); } - public static void ThrowInvalidProgramException(ExceptionStringID id) + [DoesNotReturn] + [DebuggerHidden] + internal static void ThrowInvalidProgramException(ExceptionStringID id) { throw TypeLoaderExceptionHelper.CreateInvalidProgramException(id); } - public static void ThrowInvalidProgramExceptionWithArgument(ExceptionStringID id, string methodName) + [DoesNotReturn] + [DebuggerHidden] + internal static void ThrowInvalidProgramExceptionWithArgument(ExceptionStringID id, string methodName) { throw TypeLoaderExceptionHelper.CreateInvalidProgramException(id, methodName); } - public static void ThrowMarshalDirectiveException(ExceptionStringID id) + [DoesNotReturn] + [DebuggerHidden] + internal static void ThrowMarshalDirectiveException(ExceptionStringID id) { throw TypeLoaderExceptionHelper.CreateMarshalDirectiveException(id); } - public static void ThrowAmbiguousMatchException(ExceptionStringID id) + [DoesNotReturn] + [DebuggerHidden] + internal static void ThrowAmbiguousMatchException(ExceptionStringID id) { throw TypeLoaderExceptionHelper.CreateAmbiguousMatchException(id); } - public static void ThrowArgumentException() - { - throw new ArgumentException(); - } - - public static void ThrowArgumentOutOfRangeException() - { - throw new ArgumentOutOfRangeException(); - } - - public static void ThrowNotSupportedInlineArrayEqualsGetHashCode() + [DoesNotReturn] + [DebuggerHidden] + internal static void ThrowNotSupportedInlineArrayEqualsGetHashCode() { throw new NotSupportedException(SR.NotSupported_InlineArrayEqualsGetHashCode); } diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System.Private.CoreLib.csproj b/src/coreclr/nativeaot/System.Private.CoreLib/src/System.Private.CoreLib.csproj index 9ee1a0d994d..68adb4bd964 100644 --- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System.Private.CoreLib.csproj +++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System.Private.CoreLib.csproj @@ -183,6 +183,7 @@ + @@ -219,7 +220,7 @@ - + @@ -296,7 +297,7 @@ Interop\Windows\Ole32\Interop.CoGetContextToken.cs - + Interop\Windows\OleAut32\Interop.VariantClear.cs @@ -624,8 +625,35 @@ + - - + + + + + src\System\Diagnostics\Eventing\NativeRuntimeEventSource.Generated.cs + + + + + + + + <_PythonWarningParameter>-Wall + <_PythonWarningParameter Condition="'$(MSBuildTreatWarningsAsErrors)' == 'true'">$(_PythonWarningParameter) -Werror + <_EventingSourceFileDirectory>%(EventingSourceFile.RootDir)%(EventingSourceFile.Directory) + <_EventingSourceFileDirectory Condition="HasTrailingSlash('$(_EventingSourceFileDirectory)')">$(_EventingSourceFileDirectory.TrimEnd('\')) + + + + + + + + diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Activator.NativeAot.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Activator.NativeAot.cs index a3b69bf6f52..ab710ed5804 100644 --- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Activator.NativeAot.cs +++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Activator.NativeAot.cs @@ -49,7 +49,7 @@ public static partial class Activator try { // Call the default constructor on the allocated instance. - if (RuntimeHelpers.IsReference()) + if (!typeof(T).IsValueType) { // Grab a pointer to the optimized allocator for the type and call it. IntPtr allocator = AllocatorOf(); diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Array.NativeAot.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Array.NativeAot.cs index 58378b92a9c..faa4d51e935 100644 --- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Array.NativeAot.cs +++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Array.NativeAot.cs @@ -727,7 +727,7 @@ private unsafe nint GetFlattenedIndex(int rawIndex) return rawIndex; } - private unsafe nint GetFlattenedIndex(ReadOnlySpan indices) + internal unsafe nint GetFlattenedIndex(ReadOnlySpan indices) { // Checked by the caller Debug.Assert(indices.Length == Rank); diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Collections/Generic/Comparer.NativeAot.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Collections/Generic/Comparer.NativeAot.cs index c14dc49f0e6..1b6f63912e5 100644 --- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Collections/Generic/Comparer.NativeAot.cs +++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Collections/Generic/Comparer.NativeAot.cs @@ -2,6 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. #nullable enable +using System.Diagnostics.CodeAnalysis; using System.Runtime.CompilerServices; using System.Threading; @@ -12,7 +13,7 @@ namespace System.Collections.Generic { public abstract partial class Comparer : IComparer, IComparer { - // The AOT compiler can flip this to false under certain circumstances. + [FeatureSwitchDefinition("System.Collections.Generic.DefaultComparers")] private static bool SupportsGenericIComparableInterfaces => true; [Intrinsic] diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Collections/Generic/EqualityComparer.NativeAot.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Collections/Generic/EqualityComparer.NativeAot.cs index b7d79959332..0e06ab4da79 100644 --- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Collections/Generic/EqualityComparer.NativeAot.cs +++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Collections/Generic/EqualityComparer.NativeAot.cs @@ -2,6 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. #nullable enable +using System.Diagnostics.CodeAnalysis; using System.Runtime.CompilerServices; using System.Threading; @@ -12,7 +13,7 @@ namespace System.Collections.Generic { public abstract partial class EqualityComparer : IEqualityComparer, IEqualityComparer { - // The AOT compiler can flip this to false under certain circumstances. + [FeatureSwitchDefinition("System.Collections.Generic.DefaultComparers")] private static bool SupportsGenericIEquatableInterfaces => true; [Intrinsic] diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/IO/Stream.NativeAot.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/IO/Stream.NativeAot.cs new file mode 100644 index 00000000000..b8633b200ab --- /dev/null +++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/IO/Stream.NativeAot.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Runtime.CompilerServices; + +namespace System.IO +{ + public abstract partial class Stream + { + [Intrinsic] + [MethodImpl(MethodImplOptions.InternalCall)] + private extern bool HasOverriddenBeginEndRead(); + + [Intrinsic] + [MethodImpl(MethodImplOptions.InternalCall)] + private extern bool HasOverriddenBeginEndWrite(); + } +} diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs index dac94886d75..fa929ccba5d 100644 --- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs +++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs @@ -1,6 +1,8 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System.Diagnostics.CodeAnalysis; + namespace System.Reflection.Metadata { public static class MetadataUpdater @@ -10,6 +12,7 @@ public static void ApplyUpdate(Assembly assembly, ReadOnlySpan metadataDel throw new PlatformNotSupportedException(); } + [FeatureSwitchDefinition("System.Reflection.Metadata.MetadataUpdater.IsSupported")] public static bool IsSupported => false; } } diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/Runtime/General/TypeUnifier.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/Runtime/General/TypeUnifier.cs index aca104df2b5..cc1855f5340 100644 --- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/Runtime/General/TypeUnifier.cs +++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/Runtime/General/TypeUnifier.cs @@ -4,6 +4,7 @@ using System; using System.Collections.Concurrent; using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; using System.Reflection; using System.Reflection.Runtime.General; using System.Reflection.Runtime.MethodInfos; @@ -36,6 +37,7 @@ namespace System.Reflection.Runtime.General { internal static partial class TypeUnifier { + [FeatureSwitchDefinition("System.Reflection.IsTypeConstructionEagerlyValidated")] // This can be replaced at native compile time using a feature switch. internal static bool IsTypeConstructionEagerlyValidated => true; diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/Runtime/TypeInfos/RuntimeArrayTypeInfo.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/Runtime/TypeInfos/RuntimeArrayTypeInfo.cs index ab9fd61a358..1f2f374b243 100644 --- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/Runtime/TypeInfos/RuntimeArrayTypeInfo.cs +++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/Runtime/TypeInfos/RuntimeArrayTypeInfo.cs @@ -213,7 +213,7 @@ internal sealed override IEnumerable SyntheticMethods for (int i = 0; i < rank; i++) indices[i] = (int)(args[i]); object value = args[rank]; - array.SetValue(value, indices); + RuntimeAugments.SetArrayValue(array, indices, value); return null; } ); diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.NativeAot.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.NativeAot.cs index 8da99ebcef6..2981b35f520 100644 --- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.NativeAot.cs +++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.NativeAot.cs @@ -179,12 +179,6 @@ public static unsafe bool TryEnsureSufficientExecutionStack() return (t_sufficientStackLimit = limit); } - [Intrinsic] - internal static unsafe bool IsReference() - { - return !MethodTable.Of()->IsValueType; - } - [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] internal static bool IsBitwiseEquatable() @@ -216,8 +210,8 @@ internal static unsafe ushort GetElementSize(this Array array) return array.GetMethodTable()->ComponentSize; } - internal static unsafe MethodTable* GetMethodTable(this object obj) - => obj.m_pEEType; + [Intrinsic] + internal static unsafe MethodTable* GetMethodTable(this object obj) => obj.GetMethodTable(); internal static unsafe ref MethodTable* GetMethodTableRef(this object obj) => ref obj.m_pEEType; diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.NativeAot.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.NativeAot.cs index f8547cb408f..cc33e85d739 100644 --- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.NativeAot.cs +++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.NativeAot.cs @@ -1,7 +1,7 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System; +using System.Collections; using System.Collections.Generic; using System.Diagnostics; using System.Diagnostics.CodeAnalysis; @@ -41,7 +41,7 @@ public abstract partial class ComWrappers private static readonly Guid IID_IWeakReferenceSource = new Guid(0x00000038, 0, 0, 0xC0, 0, 0, 0, 0, 0, 0, 0x46); private static readonly ConditionalWeakTable s_rcwTable = new ConditionalWeakTable(); - private static readonly List s_referenceTrackerNativeObjectWrapperCache = new List(); + private static readonly GCHandleSet s_referenceTrackerNativeObjectWrapperCache = new GCHandleSet(); private readonly ConditionalWeakTable _ccwTable = new ConditionalWeakTable(); private readonly Lock _lock = new Lock(useTrivialWaits: true); @@ -984,10 +984,7 @@ private unsafe bool TryGetOrCreateObjectForComInstanceInternal( throw new NotSupportedException(); } _rcwCache.Add(identity, wrapper._proxyHandle); - if (wrapper is ReferenceTrackerNativeObjectWrapper referenceTrackerNativeObjectWrapper) - { - s_referenceTrackerNativeObjectWrapperCache.Add(referenceTrackerNativeObjectWrapper._nativeObjectWrapperWeakHandle); - } + AddWrapperToReferenceTrackerHandleCache(wrapper); return true; } } @@ -1040,10 +1037,7 @@ private unsafe bool TryGetOrCreateObjectForComInstanceInternal( wrapper.Release(); throw new NotSupportedException(); } - if (wrapper is ReferenceTrackerNativeObjectWrapper referenceTrackerNativeObjectWrapper) - { - s_referenceTrackerNativeObjectWrapperCache.Add(referenceTrackerNativeObjectWrapper._nativeObjectWrapperWeakHandle); - } + AddWrapperToReferenceTrackerHandleCache(wrapper); return true; } @@ -1079,10 +1073,7 @@ private unsafe bool TryGetOrCreateObjectForComInstanceInternal( throw new NotSupportedException(); } _rcwCache.Add(identity, wrapper._proxyHandle); - if (wrapper is ReferenceTrackerNativeObjectWrapper referenceTrackerNativeObjectWrapper) - { - s_referenceTrackerNativeObjectWrapperCache.Add(referenceTrackerNativeObjectWrapper._nativeObjectWrapperWeakHandle); - } + AddWrapperToReferenceTrackerHandleCache(wrapper); } } @@ -1090,6 +1081,14 @@ private unsafe bool TryGetOrCreateObjectForComInstanceInternal( } #pragma warning restore IDE0060 + private static void AddWrapperToReferenceTrackerHandleCache(NativeObjectWrapper wrapper) + { + if (wrapper is ReferenceTrackerNativeObjectWrapper referenceTrackerNativeObjectWrapper) + { + s_referenceTrackerNativeObjectWrapperCache.Add(referenceTrackerNativeObjectWrapper._nativeObjectWrapperWeakHandle); + } + } + private void RemoveRCWFromCache(IntPtr comPointer, GCHandle expectedValue) { using (_lock.EnterScope()) @@ -1220,17 +1219,30 @@ internal static void ReleaseExternalObjectsFromCurrentThread() IntPtr contextToken = GetContextToken(); List objects = new List(); - foreach (GCHandle weakNativeObjectWrapperHandle in s_referenceTrackerNativeObjectWrapperCache) + + // Here we aren't part of a GC callback, so other threads can still be running + // who are adding and removing from the collection. This means we can possibly race + // with a handle being removed and freed and we can end up accessing a freed handle. + // To avoid this, we take a lock on modifications to the collection while we gather + // the objects. + using (s_referenceTrackerNativeObjectWrapperCache.ModificationLock.EnterScope()) { - ReferenceTrackerNativeObjectWrapper? nativeObjectWrapper = Unsafe.As(weakNativeObjectWrapperHandle.Target); - if (nativeObjectWrapper != null && - nativeObjectWrapper._contextToken == contextToken) + foreach (GCHandle weakNativeObjectWrapperHandle in s_referenceTrackerNativeObjectWrapperCache) { - objects.Add(nativeObjectWrapper._proxyHandle.Target); + ReferenceTrackerNativeObjectWrapper? nativeObjectWrapper = Unsafe.As(weakNativeObjectWrapperHandle.Target); + if (nativeObjectWrapper != null && + nativeObjectWrapper._contextToken == contextToken) + { + object? target = nativeObjectWrapper._proxyHandle.Target; + if (target != null) + { + objects.Add(target); + } - // Separate the wrapper from the tracker runtime prior to - // passing them. - nativeObjectWrapper.DisconnectTracker(); + // Separate the wrapper from the tracker runtime prior to + // passing them. + nativeObjectWrapper.DisconnectTracker(); + } } } @@ -1630,4 +1642,212 @@ private static unsafe IntPtr ObjectToComWeakRef(object target, out long wrapperI return IntPtr.Zero; } } + + // This is a GCHandle HashSet implementation based on LowLevelDictionary. + // It uses no locking for readers. While for writers (add / remove), + // it handles the locking itself. + // This implementation specifically makes sure that any readers of this + // collection during GC aren't impacted by other threads being + // frozen while in the middle of an write. It makes no guarantees on + // whether you will observe the element being added / removed, but does + // make sure the collection is in a good state and doesn't run into issues + // while iterating. + internal sealed class GCHandleSet : IEnumerable + { + private const int DefaultSize = 7; + + private Entry?[] _buckets = new Entry[DefaultSize]; + private int _numEntries; + private readonly Lock _lock = new Lock(useTrivialWaits: true); + + public Lock ModificationLock => _lock; + + public void Add(GCHandle handle) + { + using (_lock.EnterScope()) + { + int bucket = GetBucket(handle, _buckets.Length); + Entry? prev = null; + Entry? entry = _buckets[bucket]; + while (entry != null) + { + // Handle already exists, nothing to add. + if (handle.Equals(entry.m_value)) + { + return; + } + + prev = entry; + entry = entry.m_next; + } + + Entry newEntry = new Entry() + { + m_value = handle + }; + + if (prev == null) + { + _buckets[bucket] = newEntry; + } + else + { + prev.m_next = newEntry; + } + + // _numEntries is only maintained for the purposes of deciding whether to + // expand the bucket and is not used during iteration to handle the + // scenario where element is in bucket but _numEntries hasn't been incremented + // yet. + _numEntries++; + if (_numEntries > (_buckets.Length * 2)) + { + ExpandBuckets(); + } + } + } + + private void ExpandBuckets() + { + int newNumBuckets = _buckets.Length * 2 + 1; + Entry?[] newBuckets = new Entry[newNumBuckets]; + for (int i = 0; i < _buckets.Length; i++) + { + Entry? entry = _buckets[i]; + while (entry != null) + { + Entry? nextEntry = entry.m_next; + + int bucket = GetBucket(entry.m_value, newNumBuckets); + + // We are allocating new entries for the bucket to ensure that + // if there is an enumeration already in progress, we don't + // modify what it observes by changing next in existing instances. + Entry newEntry = new Entry() + { + m_value = entry.m_value, + m_next = newBuckets[bucket], + }; + newBuckets[bucket] = newEntry; + + entry = nextEntry; + } + } + _buckets = newBuckets; + } + + public void Remove(GCHandle handle) + { + using (_lock.EnterScope()) + { + int bucket = GetBucket(handle, _buckets.Length); + Entry? prev = null; + Entry? entry = _buckets[bucket]; + while (entry != null) + { + if (handle.Equals(entry.m_value)) + { + if (prev == null) + { + _buckets[bucket] = entry.m_next; + } + else + { + prev.m_next = entry.m_next; + } + _numEntries--; + return; + } + + prev = entry; + entry = entry.m_next; + } + } + } + + private static int GetBucket(GCHandle handle, int numBuckets) + { + int h = handle.GetHashCode(); + return (int)((uint)h % (uint)numBuckets); + } + + public Enumerator GetEnumerator() => new Enumerator(this); + + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + + IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable)this).GetEnumerator(); + + private sealed class Entry + { + public GCHandle m_value; + public Entry? m_next; + } + + public struct Enumerator : IEnumerator + { + private readonly Entry?[] _buckets; + private int _currentIdx; + private Entry? _currentEntry; + + public Enumerator(GCHandleSet set) + { + // We hold onto the buckets of the set rather than the set itself + // so that if it is ever expanded, we are not impacted by that during + // enumeration. + _buckets = set._buckets; + Reset(); + } + + public GCHandle Current + { + get + { + if (_currentEntry == null) + { + throw new InvalidOperationException("InvalidOperation_EnumOpCantHappen"); + } + + return _currentEntry.m_value; + } + } + + object IEnumerator.Current => Current; + + public void Dispose() + { + } + + public bool MoveNext() + { + if (_currentEntry != null) + { + _currentEntry = _currentEntry.m_next; + } + + if (_currentEntry == null) + { + // Certain buckets might be empty, so loop until we find + // one with an entry. + while (++_currentIdx != _buckets.Length) + { + _currentEntry = _buckets[_currentIdx]; + if (_currentEntry != null) + { + return true; + } + } + + return false; + } + + return true; + } + + public void Reset() + { + _currentIdx = -1; + _currentEntry = null; + } + } + } } diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/RuntimeImports.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/RuntimeImports.cs index d0d5db57a2a..0a17177e3be 100644 --- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/RuntimeImports.cs +++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/RuntimeImports.cs @@ -649,6 +649,10 @@ internal static IntPtr RhGetModuleSection(TypeManagerHandle module, ReadyToRunSe [RuntimeImport(RuntimeLibrary, "RhpLockCmpXchg32")] internal static extern int InterlockedCompareExchange(ref int location1, int value, int comparand); + [MethodImplAttribute(MethodImplOptions.InternalCall)] + [RuntimeImport(RuntimeLibrary, "RhpLockCmpXchg32")] + internal static extern unsafe int InterlockedCompareExchange(int* location1, int value, int comparand); + [MethodImplAttribute(MethodImplOptions.InternalCall)] [RuntimeImport(RuntimeLibrary, "RhpLockCmpXchg64")] internal static extern long InterlockedCompareExchange(ref long location1, long value, long comparand); diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/Interlocked.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/Interlocked.cs index 9dd57153b64..f15e753e2fc 100644 --- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/Interlocked.cs +++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/Interlocked.cs @@ -1,6 +1,7 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System.Diagnostics; using System.Diagnostics.CodeAnalysis; using System.Runtime; using System.Runtime.CompilerServices; @@ -23,6 +24,24 @@ public static int CompareExchange(ref int location1, int value, int comparand) #endif } + // This is used internally by NativeAOT runtime in cases where having a managed + // ref to the location is unsafe (Ex: it is the syncblock of a pinned object). + // The intrinsic expansion for this overload is exactly the same as for the `ref int` + // variant and will go on the same path since expansion is triggered by the name and + // return type of the method. + // The important part is avoiding `ref *location` in the unexpanded scenario, like + // in a case when compiling the Debug flavor of the app. + [Intrinsic] + internal static unsafe int CompareExchange(int* location1, int value, int comparand) + { +#if TARGET_X86 || TARGET_AMD64 || TARGET_ARM64 || TARGET_RISCV64 + return CompareExchange(location1, value, comparand); // Must expand intrinsic +#else + Debug.Assert(location1 != null); + return RuntimeImports.InterlockedCompareExchange(location1, value, comparand); +#endif + } + [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static long CompareExchange(ref long location1, long value, long comparand) diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/ObjectHeader.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/ObjectHeader.cs index 1d0c2775152..b56054d9f16 100644 --- a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/ObjectHeader.cs +++ b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Threading/ObjectHeader.cs @@ -152,7 +152,7 @@ private static unsafe int AssignHashCode(object o, int* pHeader) // there is nothing - try set hashcode inline Debug.Assert((oldBits & BIT_SBLK_IS_HASH_OR_SYNCBLKINDEX) == 0); int newBits = BIT_SBLK_IS_HASH_OR_SYNCBLKINDEX | BIT_SBLK_IS_HASHCODE | oldBits | newHash; - if (Interlocked.CompareExchange(ref *pHeader, newBits, oldBits) == oldBits) + if (Interlocked.CompareExchange(pHeader, newBits, oldBits) == oldBits) { return newHash; } @@ -247,7 +247,7 @@ public static unsafe void SetSyncEntryIndex(int* pHeader, int syncIndex) newBits = oldBits & ~(BIT_SBLK_IS_HASHCODE | MASK_HASHCODE_INDEX); newBits |= syncIndex | BIT_SBLK_IS_HASH_OR_SYNCBLKINDEX; } - while (Interlocked.CompareExchange(ref *pHeader, newBits, oldBits) != oldBits); + while (Interlocked.CompareExchange(pHeader, newBits, oldBits) != oldBits); } // @@ -312,7 +312,7 @@ public static unsafe int TryAcquire(object obj, int currentThreadID, bool oneSho // N.B. hashcode, thread ID and sync index are never 0, and hashcode is largest of all if ((oldBits & MASK_HASHCODE_INDEX) == 0) { - if (Interlocked.CompareExchange(ref *pHeader, oldBits | currentThreadID, oldBits) == oldBits) + if (Interlocked.CompareExchange(pHeader, oldBits | currentThreadID, oldBits) == oldBits) { return -1; } @@ -369,7 +369,7 @@ private static unsafe int TryAcquireUncommon(object obj, int currentThreadID, bo if ((oldBits & MASK_HASHCODE_INDEX) == 0) { int newBits = oldBits | currentThreadID; - if (Interlocked.CompareExchange(ref *pHeader, newBits, oldBits) == oldBits) + if (Interlocked.CompareExchange(pHeader, newBits, oldBits) == oldBits) { return -1; } @@ -398,7 +398,7 @@ private static unsafe int TryAcquireUncommon(object obj, int currentThreadID, bo int newBits = oldBits + SBLK_LOCK_RECLEVEL_INC; if ((newBits & SBLK_MASK_LOCK_RECLEVEL) != 0) { - if (Interlocked.CompareExchange(ref *pHeader, newBits, oldBits) == oldBits) + if (Interlocked.CompareExchange(pHeader, newBits, oldBits) == oldBits) { return -1; } @@ -458,7 +458,7 @@ public static unsafe void Release(object obj) oldBits - SBLK_LOCK_RECLEVEL_INC : oldBits & ~SBLK_MASK_LOCK_THREADID; - if (Interlocked.CompareExchange(ref *pHeader, newBits, oldBits) == oldBits) + if (Interlocked.CompareExchange(pHeader, newBits, oldBits) == oldBits) { return; } diff --git a/src/coreclr/nativeaot/System.Private.Reflection.Execution/src/Internal/Reflection/Execution/TypeLoader/ConstraintValidator.cs b/src/coreclr/nativeaot/System.Private.Reflection.Execution/src/Internal/Reflection/Execution/TypeLoader/ConstraintValidator.cs index d347b6d0f4a..3ead6a529d1 100644 --- a/src/coreclr/nativeaot/System.Private.Reflection.Execution/src/Internal/Reflection/Execution/TypeLoader/ConstraintValidator.cs +++ b/src/coreclr/nativeaot/System.Private.Reflection.Execution/src/Internal/Reflection/Execution/TypeLoader/ConstraintValidator.cs @@ -38,7 +38,7 @@ private static bool SatisfiesConstraints(this Type genericVariable, SigTypeConte if ((attributes & GenericParameterAttributes.DefaultConstructorConstraint) != 0) { - if (!typeArg.HasExplicitOrImplicitPublicDefaultConstructor()) + if (!typeArg.HasExplicitOrImplicitPublicDefaultConstructor() || typeArg.IsAbstract) return false; } diff --git a/src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeBuilderState.cs b/src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeBuilderState.cs index a95514e7bf0..b184395c2a5 100644 --- a/src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeBuilderState.cs +++ b/src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeBuilderState.cs @@ -355,10 +355,10 @@ public LowLevelList InstanceGCLayout else { Debug.Assert(TypeBeingBuilt.RetrieveRuntimeTypeHandleIfPossible() || - TypeBeingBuilt.IsTemplateCanonical() || (TypeBeingBuilt is PointerType) || (TypeBeingBuilt is ByRefType) || - (TypeBeingBuilt is FunctionPointerType)); + (TypeBeingBuilt is FunctionPointerType) || + TypeBeingBuilt.IsTemplateCanonical()); _instanceGCLayout = s_emptyLayout; } } diff --git a/src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/TypeSystem/ThrowHelper.cs b/src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/TypeSystem/ThrowHelper.cs index 345ce880d80..ce7487e2e19 100644 --- a/src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/TypeSystem/ThrowHelper.cs +++ b/src/coreclr/nativeaot/System.Private.TypeLoader/src/Internal/TypeSystem/ThrowHelper.cs @@ -1,7 +1,7 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using CoreLibThrow = Internal.Runtime.CompilerHelpers.ThrowHelpers; +using CoreLibThrow = Internal.Runtime.Augments.RuntimeAugments; namespace Internal.TypeSystem { diff --git a/src/coreclr/nativeaot/Test.CoreLib/src/System/Runtime/RuntimeImports.cs b/src/coreclr/nativeaot/Test.CoreLib/src/System/Runtime/RuntimeImports.cs index 70b0cda4d2f..52d1277f0bd 100644 --- a/src/coreclr/nativeaot/Test.CoreLib/src/System/Runtime/RuntimeImports.cs +++ b/src/coreclr/nativeaot/Test.CoreLib/src/System/Runtime/RuntimeImports.cs @@ -94,6 +94,10 @@ internal static IntPtr RhGetModuleSection(TypeManagerHandle module, ReadyToRunSe [RuntimeImport(RuntimeLibrary, "RhpLockCmpXchg32")] internal static extern int InterlockedCompareExchange(ref int location1, int value, int comparand); + [MethodImplAttribute(MethodImplOptions.InternalCall)] + [RuntimeImport(RuntimeLibrary, "RhpLockCmpXchg32")] + internal static extern unsafe int InterlockedCompareExchange(int* location1, int value, int comparand); + [MethodImplAttribute(MethodImplOptions.InternalCall)] [RuntimeImport(RuntimeLibrary, "RhpLockCmpXchg64")] internal static extern long InterlockedCompareExchange(ref long location1, long value, long comparand); diff --git a/src/coreclr/pal/inc/pal.h b/src/coreclr/pal/inc/pal.h index 77b641a5059..e4a520c1dcf 100644 --- a/src/coreclr/pal/inc/pal.h +++ b/src/coreclr/pal/inc/pal.h @@ -191,6 +191,7 @@ PAL_IsDebuggerPresent(); #define PAL_INITIALIZE_ENSURE_STACK_SIZE 0x20 #define PAL_INITIALIZE_REGISTER_SIGNALS 0x40 #define PAL_INITIALIZE_REGISTER_ACTIVATION_SIGNAL 0x80 +#define PAL_INITIALIZE_FLUSH_PROCESS_WRITE_BUFFERS 0x100 // PAL_Initialize() flags #define PAL_INITIALIZE (PAL_INITIALIZE_SYNC_THREAD | \ @@ -206,7 +207,8 @@ PAL_IsDebuggerPresent(); PAL_INITIALIZE_DEBUGGER_EXCEPTIONS | \ PAL_INITIALIZE_ENSURE_STACK_SIZE | \ PAL_INITIALIZE_REGISTER_SIGNALS | \ - PAL_INITIALIZE_REGISTER_ACTIVATION_SIGNAL) + PAL_INITIALIZE_REGISTER_ACTIVATION_SIGNAL | \ + PAL_INITIALIZE_FLUSH_PROCESS_WRITE_BUFFERS) typedef DWORD (PALAPI_NOEXPORT *PTHREAD_START_ROUTINE)(LPVOID lpThreadParameter); typedef PTHREAD_START_ROUTINE LPTHREAD_START_ROUTINE; diff --git a/src/coreclr/pal/inc/rt/palrt.h b/src/coreclr/pal/inc/rt/palrt.h index 18e25222c5d..13bbc7d250c 100644 --- a/src/coreclr/pal/inc/rt/palrt.h +++ b/src/coreclr/pal/inc/rt/palrt.h @@ -716,8 +716,6 @@ typename std::remove_reference::type&& move( T&& t ); #define __RPC__inout #define __RPC__deref_out_ecount_full_opt(x) -typedef DWORD OLE_COLOR; - typedef HANDLE HWND; typedef struct _LIST_ENTRY { diff --git a/src/coreclr/pal/inc/unixasmmacrosarm64.inc b/src/coreclr/pal/inc/unixasmmacrosarm64.inc index 976cc825f2e..6bbdbb299fa 100644 --- a/src/coreclr/pal/inc/unixasmmacrosarm64.inc +++ b/src/coreclr/pal/inc/unixasmmacrosarm64.inc @@ -17,7 +17,12 @@ .endm .macro PATCH_LABEL Name +#if defined(__APPLE__) + .alt_entry C_FUNC(\Name) + .private_extern C_FUNC(\Name) +#else .global C_FUNC(\Name) +#endif C_FUNC(\Name): .endm @@ -206,7 +211,7 @@ C_FUNC(\Name\()_End): // base address to be passed in $reg // -// Reserve 64 bytes of memory before calling SAVE_ARGUMENT_REGISTERS +// Reserve 72 bytes of memory before calling SAVE_ARGUMENT_REGISTERS .macro SAVE_ARGUMENT_REGISTERS reg, ofs str x8, [\reg, #(\ofs)] diff --git a/src/coreclr/pal/prebuilt/idl/metahost_i.cpp b/src/coreclr/pal/prebuilt/idl/metahost_i.cpp new file mode 100644 index 00000000000..27b3a1ab503 --- /dev/null +++ b/src/coreclr/pal/prebuilt/idl/metahost_i.cpp @@ -0,0 +1,92 @@ + + +/* this ALWAYS GENERATED file contains the IIDs and CLSIDs */ + +/* link this file in with the server and any clients */ + + + /* File created by MIDL compiler version 8.01.0628 */ +/* Compiler settings for metahost.idl: + Oicf, W1, Zp8, env=Win64 (32b run), target_arch=AMD64 8.01.0628 + protocol : dce , ms_ext, c_ext, robust + error checks: allocation ref bounds_check enum stub_data + VC __declspec() decoration level: + __declspec(uuid()), __declspec(selectany), __declspec(novtable) + DECLSPEC_UUID(), MIDL_INTERFACE() +*/ +/* @@MIDL_FILE_HEADING( ) */ + +#pragma warning( disable: 4049 ) /* more than 64k source lines */ + + +#ifdef __cplusplus +extern "C"{ +#endif + + +#include +#include + +#ifdef _MIDL_USE_GUIDDEF_ + +#ifndef INITGUID +#define INITGUID +#include +#undef INITGUID +#else +#include +#endif + +#define MIDL_DEFINE_GUID(type,name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) \ + DEFINE_GUID(name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) + +#else // !_MIDL_USE_GUIDDEF_ + +#ifndef __IID_DEFINED__ +#define __IID_DEFINED__ + +typedef struct _IID +{ + unsigned long x; + unsigned short s1; + unsigned short s2; + unsigned char c[8]; +} IID; + +#endif // __IID_DEFINED__ + +#ifndef CLSID_DEFINED +#define CLSID_DEFINED +typedef IID CLSID; +#endif // CLSID_DEFINED + +#define MIDL_DEFINE_GUID(type,name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) \ + EXTERN_C __declspec(selectany) const type name = {l,w1,w2,{b1,b2,b3,b4,b5,b6,b7,b8}} + +#endif // !_MIDL_USE_GUIDDEF_ + +MIDL_DEFINE_GUID(IID, IID_ICLRMetaHost,0xD332DB9E,0xB9B3,0x4125,0x82,0x07,0xA1,0x48,0x84,0xF5,0x32,0x16); + + +MIDL_DEFINE_GUID(IID, IID_ICLRDebuggingLibraryProvider,0x3151C08D,0x4D09,0x4f9b,0x88,0x38,0x28,0x80,0xBF,0x18,0xFE,0x51); + + +MIDL_DEFINE_GUID(IID, IID_ICLRDebuggingLibraryProvider2,0xE04E2FF1,0xDCFD,0x45D5,0xBC,0xD1,0x16,0xFF,0xF2,0xFA,0xF7,0xBA); + + +MIDL_DEFINE_GUID(IID, IID_ICLRDebuggingLibraryProvider3,0xDE3AAB18,0x46A0,0x48B4,0xBF,0x0D,0x2C,0x33,0x6E,0x69,0xEA,0x1B); + + +MIDL_DEFINE_GUID(IID, IID_ICLRDebugging,0xD28F3C5A,0x9634,0x4206,0xA5,0x09,0x47,0x75,0x52,0xEE,0xFB,0x10); + + +MIDL_DEFINE_GUID(IID, IID_ICLRRuntimeInfo,0xBD39D1D2,0xBA2F,0x486a,0x89,0xB0,0xB4,0xB0,0xCB,0x46,0x68,0x91); + +#undef MIDL_DEFINE_GUID + +#ifdef __cplusplus +} +#endif + + + diff --git a/src/coreclr/pal/prebuilt/inc/metahost.h b/src/coreclr/pal/prebuilt/inc/metahost.h index e0fc0fc0680..b96f035bfa8 100644 --- a/src/coreclr/pal/prebuilt/inc/metahost.h +++ b/src/coreclr/pal/prebuilt/inc/metahost.h @@ -3,11 +3,9 @@ /* this ALWAYS GENERATED file contains the definitions for the interfaces */ - /* File created by MIDL compiler version 8.01.0622 */ -/* at Mon Jan 18 19:14:07 2038 - */ + /* File created by MIDL compiler version 8.01.0628 */ /* Compiler settings for metahost.idl: - Oicf, W1, Zp8, env=Win32 (32b run), target_arch=X86 8.01.0622 + Oicf, W1, Zp8, env=Win64 (32b run), target_arch=AMD64 8.01.0628 protocol : dce , ms_ext, c_ext, robust error checks: allocation ref bounds_check enum stub_data VC __declspec() decoration level: @@ -43,6 +41,14 @@ #pragma once #endif +#ifndef DECLSPEC_XFGVIRT +#if defined(_CONTROL_FLOW_GUARD_XFG) +#define DECLSPEC_XFGVIRT(base, func) __declspec(xfg_virtual(base, func)) +#else +#define DECLSPEC_XFGVIRT(base, func) +#endif +#endif + /* Forward Declarations */ #ifndef __ICLRMetaHost_FWD_DEFINED__ @@ -66,6 +72,13 @@ typedef interface ICLRDebuggingLibraryProvider2 ICLRDebuggingLibraryProvider2; #endif /* __ICLRDebuggingLibraryProvider2_FWD_DEFINED__ */ +#ifndef __ICLRDebuggingLibraryProvider3_FWD_DEFINED__ +#define __ICLRDebuggingLibraryProvider3_FWD_DEFINED__ +typedef interface ICLRDebuggingLibraryProvider3 ICLRDebuggingLibraryProvider3; + +#endif /* __ICLRDebuggingLibraryProvider3_FWD_DEFINED__ */ + + #ifndef __ICLRDebugging_FWD_DEFINED__ #define __ICLRDebugging_FWD_DEFINED__ typedef interface ICLRDebugging ICLRDebugging; @@ -101,6 +114,7 @@ EXTERN_GUID(CLSID_CLRDebugging, 0xbacc578d, 0xfbdd, 0x48a4, 0x96, 0x9f, 0x2, 0xd EXTERN_GUID(IID_ICLRRuntimeInfo, 0xBD39D1D2, 0xBA2F, 0x486a, 0x89, 0xB0, 0xB4, 0xB0, 0xCB, 0x46, 0x68, 0x91); EXTERN_GUID(IID_ICLRDebuggingLibraryProvider, 0x3151c08d, 0x4d09, 0x4f9b, 0x88, 0x38, 0x28, 0x80, 0xbf, 0x18, 0xfe, 0x51); EXTERN_GUID(IID_ICLRDebuggingLibraryProvider2, 0xE04E2FF1, 0xDCFD, 0x45D5, 0xBC, 0xD1, 0x16, 0xFF, 0xF2, 0xFA, 0xF7, 0xBA); +EXTERN_GUID(IID_ICLRDebuggingLibraryProvider3, 0xde3aab18, 0x46a0, 0x48b4, 0xbf, 0xd, 0x2c, 0x33, 0x6e, 0x69, 0xea, 0x1b); typedef HRESULT ( __stdcall *CallbackThreadSetFnPtr )( void); @@ -111,6 +125,14 @@ typedef void ( __stdcall *RuntimeLoadedCallbackFnPtr )( CallbackThreadSetFnPtr pfnCallbackThreadSet, CallbackThreadUnsetFnPtr pfnCallbackThreadUnset); +typedef /* [public][public][public] */ +enum __MIDL___MIDL_itf_metahost_0000_0000_0001 + { + UnknownIndex = 0, + Identity = 1, + Runtime = 2 + } LIBRARY_PROVIDER_INDEX_TYPE; + extern RPC_IF_HANDLE __MIDL_itf_metahost_0000_0000_v0_0_c_ifspec; @@ -168,24 +190,29 @@ EXTERN_C const IID IID_ICLRMetaHost; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( ICLRMetaHost * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( ICLRMetaHost * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( ICLRMetaHost * This); + DECLSPEC_XFGVIRT(ICLRMetaHost, GetRuntime) HRESULT ( STDMETHODCALLTYPE *GetRuntime )( ICLRMetaHost * This, /* [in] */ LPCWSTR pwzVersion, /* [in] */ REFIID riid, /* [retval][iid_is][out] */ LPVOID *ppRuntime); + DECLSPEC_XFGVIRT(ICLRMetaHost, GetVersionFromFile) HRESULT ( STDMETHODCALLTYPE *GetVersionFromFile )( ICLRMetaHost * This, /* [in] */ LPCWSTR pwzFilePath, @@ -193,24 +220,29 @@ EXTERN_C const IID IID_ICLRMetaHost; _Out_writes_all_(*pcchBuffer) LPWSTR pwzBuffer, /* [out][in] */ DWORD *pcchBuffer); + DECLSPEC_XFGVIRT(ICLRMetaHost, EnumerateInstalledRuntimes) HRESULT ( STDMETHODCALLTYPE *EnumerateInstalledRuntimes )( ICLRMetaHost * This, /* [retval][out] */ IEnumUnknown **ppEnumerator); + DECLSPEC_XFGVIRT(ICLRMetaHost, EnumerateLoadedRuntimes) HRESULT ( STDMETHODCALLTYPE *EnumerateLoadedRuntimes )( ICLRMetaHost * This, /* [in] */ HANDLE hndProcess, /* [retval][out] */ IEnumUnknown **ppEnumerator); + DECLSPEC_XFGVIRT(ICLRMetaHost, RequestRuntimeLoadedNotification) HRESULT ( STDMETHODCALLTYPE *RequestRuntimeLoadedNotification )( ICLRMetaHost * This, /* [in] */ RuntimeLoadedCallbackFnPtr pCallbackFunction); + DECLSPEC_XFGVIRT(ICLRMetaHost, QueryLegacyV2RuntimeBinding) HRESULT ( STDMETHODCALLTYPE *QueryLegacyV2RuntimeBinding )( ICLRMetaHost * This, /* [in] */ REFIID riid, /* [retval][iid_is][out] */ LPVOID *ppUnk); + DECLSPEC_XFGVIRT(ICLRMetaHost, ExitProcess) HRESULT ( STDMETHODCALLTYPE *ExitProcess )( ICLRMetaHost * This, /* [in] */ INT32 iExitCode); @@ -324,18 +356,22 @@ EXTERN_C const IID IID_ICLRDebuggingLibraryProvider; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( ICLRDebuggingLibraryProvider * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( ICLRDebuggingLibraryProvider * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( ICLRDebuggingLibraryProvider * This); + DECLSPEC_XFGVIRT(ICLRDebuggingLibraryProvider, ProvideLibrary) HRESULT ( STDMETHODCALLTYPE *ProvideLibrary )( ICLRDebuggingLibraryProvider * This, /* [in] */ const WCHAR *pwszFileName, @@ -410,18 +446,22 @@ EXTERN_C const IID IID_ICLRDebuggingLibraryProvider2; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( ICLRDebuggingLibraryProvider2 * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( ICLRDebuggingLibraryProvider2 * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( ICLRDebuggingLibraryProvider2 * This); + DECLSPEC_XFGVIRT(ICLRDebuggingLibraryProvider2, ProvideLibrary2) HRESULT ( STDMETHODCALLTYPE *ProvideLibrary2 )( ICLRDebuggingLibraryProvider2 * This, /* [in] */ const WCHAR *pwszFileName, @@ -466,6 +506,121 @@ EXTERN_C const IID IID_ICLRDebuggingLibraryProvider2; #endif /* __ICLRDebuggingLibraryProvider2_INTERFACE_DEFINED__ */ +#ifndef __ICLRDebuggingLibraryProvider3_INTERFACE_DEFINED__ +#define __ICLRDebuggingLibraryProvider3_INTERFACE_DEFINED__ + +/* interface ICLRDebuggingLibraryProvider3 */ +/* [object][local][helpstring][version][uuid] */ + + +EXTERN_C const IID IID_ICLRDebuggingLibraryProvider3; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("DE3AAB18-46A0-48B4-BF0D-2C336E69EA1B") + ICLRDebuggingLibraryProvider3 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE ProvideWindowsLibrary( + /* [in] */ const WCHAR *pwszFileName, + /* [in] */ const WCHAR *pwszRuntimeModule, + /* [in] */ LIBRARY_PROVIDER_INDEX_TYPE indexType, + /* [in] */ DWORD dwTimestamp, + /* [in] */ DWORD dwSizeOfImage, + /* [out] */ LPWSTR *ppResolvedModulePath) = 0; + + virtual HRESULT STDMETHODCALLTYPE ProvideUnixLibrary( + /* [in] */ const WCHAR *pwszFileName, + /* [in] */ const WCHAR *pwszRuntimeModule, + /* [in] */ LIBRARY_PROVIDER_INDEX_TYPE indexType, + /* [in] */ BYTE *pbBuildId, + /* [in] */ int iBuildIdSize, + /* [out] */ LPWSTR *ppResolvedModulePath) = 0; + + }; + + +#else /* C style interface */ + + typedef struct ICLRDebuggingLibraryProvider3Vtbl + { + BEGIN_INTERFACE + + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + ICLRDebuggingLibraryProvider3 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + DECLSPEC_XFGVIRT(IUnknown, AddRef) + ULONG ( STDMETHODCALLTYPE *AddRef )( + ICLRDebuggingLibraryProvider3 * This); + + DECLSPEC_XFGVIRT(IUnknown, Release) + ULONG ( STDMETHODCALLTYPE *Release )( + ICLRDebuggingLibraryProvider3 * This); + + DECLSPEC_XFGVIRT(ICLRDebuggingLibraryProvider3, ProvideWindowsLibrary) + HRESULT ( STDMETHODCALLTYPE *ProvideWindowsLibrary )( + ICLRDebuggingLibraryProvider3 * This, + /* [in] */ const WCHAR *pwszFileName, + /* [in] */ const WCHAR *pwszRuntimeModule, + /* [in] */ LIBRARY_PROVIDER_INDEX_TYPE indexType, + /* [in] */ DWORD dwTimestamp, + /* [in] */ DWORD dwSizeOfImage, + /* [out] */ LPWSTR *ppResolvedModulePath); + + DECLSPEC_XFGVIRT(ICLRDebuggingLibraryProvider3, ProvideUnixLibrary) + HRESULT ( STDMETHODCALLTYPE *ProvideUnixLibrary )( + ICLRDebuggingLibraryProvider3 * This, + /* [in] */ const WCHAR *pwszFileName, + /* [in] */ const WCHAR *pwszRuntimeModule, + /* [in] */ LIBRARY_PROVIDER_INDEX_TYPE indexType, + /* [in] */ BYTE *pbBuildId, + /* [in] */ int iBuildIdSize, + /* [out] */ LPWSTR *ppResolvedModulePath); + + END_INTERFACE + } ICLRDebuggingLibraryProvider3Vtbl; + + interface ICLRDebuggingLibraryProvider3 + { + CONST_VTBL struct ICLRDebuggingLibraryProvider3Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ICLRDebuggingLibraryProvider3_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define ICLRDebuggingLibraryProvider3_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define ICLRDebuggingLibraryProvider3_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define ICLRDebuggingLibraryProvider3_ProvideWindowsLibrary(This,pwszFileName,pwszRuntimeModule,indexType,dwTimestamp,dwSizeOfImage,ppResolvedModulePath) \ + ( (This)->lpVtbl -> ProvideWindowsLibrary(This,pwszFileName,pwszRuntimeModule,indexType,dwTimestamp,dwSizeOfImage,ppResolvedModulePath) ) + +#define ICLRDebuggingLibraryProvider3_ProvideUnixLibrary(This,pwszFileName,pwszRuntimeModule,indexType,pbBuildId,iBuildIdSize,ppResolvedModulePath) \ + ( (This)->lpVtbl -> ProvideUnixLibrary(This,pwszFileName,pwszRuntimeModule,indexType,pbBuildId,iBuildIdSize,ppResolvedModulePath) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __ICLRDebuggingLibraryProvider3_INTERFACE_DEFINED__ */ + + #ifndef __ICLRDebugging_INTERFACE_DEFINED__ #define __ICLRDebugging_INTERFACE_DEFINED__ @@ -503,18 +658,22 @@ EXTERN_C const IID IID_ICLRDebugging; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( ICLRDebugging * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( ICLRDebugging * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( ICLRDebugging * This); + DECLSPEC_XFGVIRT(ICLRDebugging, OpenVirtualProcess) HRESULT ( STDMETHODCALLTYPE *OpenVirtualProcess )( ICLRDebugging * This, /* [in] */ ULONG64 moduleBaseAddress, @@ -526,6 +685,7 @@ EXTERN_C const IID IID_ICLRDebugging; /* [out][in] */ CLR_DEBUGGING_VERSION *pVersion, /* [out] */ CLR_DEBUGGING_PROCESS_FLAGS *pdwFlags); + DECLSPEC_XFGVIRT(ICLRDebugging, CanUnloadNow) HRESULT ( STDMETHODCALLTYPE *CanUnloadNow )( ICLRDebugging * This, HMODULE hModule); @@ -647,35 +807,42 @@ EXTERN_C const IID IID_ICLRRuntimeInfo; { BEGIN_INTERFACE + DECLSPEC_XFGVIRT(IUnknown, QueryInterface) HRESULT ( STDMETHODCALLTYPE *QueryInterface )( ICLRRuntimeInfo * This, /* [in] */ REFIID riid, /* [annotation][iid_is][out] */ _COM_Outptr_ void **ppvObject); + DECLSPEC_XFGVIRT(IUnknown, AddRef) ULONG ( STDMETHODCALLTYPE *AddRef )( ICLRRuntimeInfo * This); + DECLSPEC_XFGVIRT(IUnknown, Release) ULONG ( STDMETHODCALLTYPE *Release )( ICLRRuntimeInfo * This); + DECLSPEC_XFGVIRT(ICLRRuntimeInfo, GetVersionString) HRESULT ( STDMETHODCALLTYPE *GetVersionString )( ICLRRuntimeInfo * This, /* [annotation][size_is][out] */ _Out_writes_all_opt_(*pcchBuffer) LPWSTR pwzBuffer, /* [out][in] */ DWORD *pcchBuffer); + DECLSPEC_XFGVIRT(ICLRRuntimeInfo, GetRuntimeDirectory) HRESULT ( STDMETHODCALLTYPE *GetRuntimeDirectory )( ICLRRuntimeInfo * This, /* [annotation][size_is][out] */ _Out_writes_all_(*pcchBuffer) LPWSTR pwzBuffer, /* [out][in] */ DWORD *pcchBuffer); + DECLSPEC_XFGVIRT(ICLRRuntimeInfo, IsLoaded) HRESULT ( STDMETHODCALLTYPE *IsLoaded )( ICLRRuntimeInfo * This, /* [in] */ HANDLE hndProcess, /* [retval][out] */ BOOL *pbLoaded); + DECLSPEC_XFGVIRT(ICLRRuntimeInfo, LoadErrorString) HRESULT ( STDMETHODCALLTYPE *LoadErrorString )( ICLRRuntimeInfo * This, /* [in] */ UINT iResourceID, @@ -684,31 +851,37 @@ EXTERN_C const IID IID_ICLRRuntimeInfo; /* [out][in] */ DWORD *pcchBuffer, /* [lcid][in] */ LONG iLocaleID); + DECLSPEC_XFGVIRT(ICLRRuntimeInfo, LoadLibrary) HRESULT ( STDMETHODCALLTYPE *LoadLibrary )( ICLRRuntimeInfo * This, /* [in] */ LPCWSTR pwzDllName, /* [retval][out] */ HMODULE *phndModule); + DECLSPEC_XFGVIRT(ICLRRuntimeInfo, GetProcAddress) HRESULT ( STDMETHODCALLTYPE *GetProcAddress )( ICLRRuntimeInfo * This, /* [in] */ LPCSTR pszProcName, /* [retval][out] */ LPVOID *ppProc); + DECLSPEC_XFGVIRT(ICLRRuntimeInfo, GetInterface) HRESULT ( STDMETHODCALLTYPE *GetInterface )( ICLRRuntimeInfo * This, /* [in] */ REFCLSID rclsid, /* [in] */ REFIID riid, /* [retval][iid_is][out] */ LPVOID *ppUnk); + DECLSPEC_XFGVIRT(ICLRRuntimeInfo, IsLoadable) HRESULT ( STDMETHODCALLTYPE *IsLoadable )( ICLRRuntimeInfo * This, /* [retval][out] */ BOOL *pbLoadable); + DECLSPEC_XFGVIRT(ICLRRuntimeInfo, SetDefaultStartupFlags) HRESULT ( STDMETHODCALLTYPE *SetDefaultStartupFlags )( ICLRRuntimeInfo * This, /* [in] */ DWORD dwStartupFlags, /* [in] */ LPCWSTR pwzHostConfigFile); + DECLSPEC_XFGVIRT(ICLRRuntimeInfo, GetDefaultStartupFlags) HRESULT ( STDMETHODCALLTYPE *GetDefaultStartupFlags )( ICLRRuntimeInfo * This, /* [out] */ DWORD *pdwStartupFlags, @@ -716,9 +889,11 @@ EXTERN_C const IID IID_ICLRRuntimeInfo; _Out_writes_all_opt_(*pcchHostConfigFile) LPWSTR pwzHostConfigFile, /* [out][in] */ DWORD *pcchHostConfigFile); + DECLSPEC_XFGVIRT(ICLRRuntimeInfo, BindAsLegacyV2Runtime) HRESULT ( STDMETHODCALLTYPE *BindAsLegacyV2Runtime )( ICLRRuntimeInfo * This); + DECLSPEC_XFGVIRT(ICLRRuntimeInfo, IsStarted) HRESULT ( STDMETHODCALLTYPE *IsStarted )( ICLRRuntimeInfo * This, /* [out] */ BOOL *pbStarted, diff --git a/src/coreclr/pal/src/arch/loongarch64/debugbreak.S b/src/coreclr/pal/src/arch/loongarch64/debugbreak.S index 93fdfd8c4c5..54ba721a222 100644 --- a/src/coreclr/pal/src/arch/loongarch64/debugbreak.S +++ b/src/coreclr/pal/src/arch/loongarch64/debugbreak.S @@ -4,4 +4,5 @@ #include "unixasmmacros.inc" LEAF_ENTRY DBG_DebugBreak, _TEXT EMIT_BREAKPOINT + jirl $r0, $ra, 0 LEAF_END_MARKED DBG_DebugBreak, _TEXT diff --git a/src/coreclr/pal/src/arch/riscv64/debugbreak.S b/src/coreclr/pal/src/arch/riscv64/debugbreak.S index 93fdfd8c4c5..da73c13b45e 100644 --- a/src/coreclr/pal/src/arch/riscv64/debugbreak.S +++ b/src/coreclr/pal/src/arch/riscv64/debugbreak.S @@ -4,4 +4,5 @@ #include "unixasmmacros.inc" LEAF_ENTRY DBG_DebugBreak, _TEXT EMIT_BREAKPOINT + ret LEAF_END_MARKED DBG_DebugBreak, _TEXT diff --git a/src/coreclr/pal/src/exception/remote-unwind.cpp b/src/coreclr/pal/src/exception/remote-unwind.cpp index 4713d1efaff..05cba618a10 100644 --- a/src/coreclr/pal/src/exception/remote-unwind.cpp +++ b/src/coreclr/pal/src/exception/remote-unwind.cpp @@ -2119,6 +2119,7 @@ access_reg(unw_addr_space_t as, unw_regnum_t regnum, unw_word_t *valp, int write #elif defined(TARGET_LOONGARCH64) case UNW_LOONGARCH64_R1: *valp = (unw_word_t)winContext->Ra; break; case UNW_LOONGARCH64_R2: *valp = (unw_word_t)winContext->Tp; break; + case UNW_LOONGARCH64_R3: *valp = (unw_word_t)winContext->Sp; break; case UNW_LOONGARCH64_R22: *valp = (unw_word_t)winContext->Fp; break; case UNW_LOONGARCH64_R23: *valp = (unw_word_t)winContext->S0; break; case UNW_LOONGARCH64_R24: *valp = (unw_word_t)winContext->S1; break; diff --git a/src/coreclr/pal/src/exception/signal.cpp b/src/coreclr/pal/src/exception/signal.cpp index 3b38ca2817d..b49670a8f51 100644 --- a/src/coreclr/pal/src/exception/signal.cpp +++ b/src/coreclr/pal/src/exception/signal.cpp @@ -190,8 +190,13 @@ BOOL SEHInitializeSignals(CorUnix::CPalThread *pthrCurrent, DWORD flags) handle_signal(SIGSEGV, sigsegv_handler, &g_previous_sigsegv); #else handle_signal(SIGTRAP, sigtrap_handler, &g_previous_sigtrap); + int additionalFlagsForSigSegv = 0; +#ifndef TARGET_SUNOS + // On platforms that support signal handlers that don't return, // SIGSEGV handler runs on a separate stack so that we can handle stack overflow - handle_signal(SIGSEGV, sigsegv_handler, &g_previous_sigsegv, SA_ONSTACK); + additionalFlagsForSigSegv |= SA_ONSTACK; +#endif + handle_signal(SIGSEGV, sigsegv_handler, &g_previous_sigsegv, additionalFlagsForSigSegv); if (!pthrCurrent->EnsureSignalAlternateStack()) { @@ -344,7 +349,7 @@ Return : --*/ bool IsRunningOnAlternateStack(void *context) { -#if HAVE_MACH_EXCEPTIONS +#if HAVE_MACH_EXCEPTIONS || defined(TARGET_SUNOS) return false; #else bool isRunningOnAlternateStack; @@ -645,30 +650,34 @@ static void sigsegv_handler(int code, siginfo_t *siginfo, void *context) else { (void)!write(STDERR_FILENO, StackOverflowMessage, sizeof(StackOverflowMessage) - 1); - PROCAbort(SIGSEGV, siginfo); } - } - - // Now that we know the SIGSEGV didn't happen due to a stack overflow, execute the common - // hardware signal handler on the original stack. - if (GetCurrentPalThread() && IsRunningOnAlternateStack(context)) - { - if (SwitchStackAndExecuteHandler(code, siginfo, context, 0 /* sp */)) // sp == 0 indicates execution on the original stack - { - return; - } + // The current executable (shared library) doesn't have hardware exception handler installed or opted to not to + // handle it. So this handler will invoke the previously installed handler at the end of this function. } else { - // The code flow gets here when the signal handler is not running on an alternate stack or when it wasn't created - // by coreclr. In both cases, we execute the common_signal_handler directly. - // If thread isn't created by coreclr and has alternate signal stack GetCurrentPalThread() will return NULL too. - // But since in this case we don't handle hardware exceptions (IsSafeToHandleHardwareException returns false) - // we can call common_signal_handler on the alternate stack. - if (common_signal_handler(code, siginfo, context, 2, (size_t)0, (size_t)siginfo->si_addr)) + // Now that we know the SIGSEGV didn't happen due to a stack overflow, execute the common + // hardware signal handler on the original stack. + + if (GetCurrentPalThread() && IsRunningOnAlternateStack(context)) { - return; + if (SwitchStackAndExecuteHandler(code, siginfo, context, 0 /* sp */)) // sp == 0 indicates execution on the original stack + { + return; + } + } + else + { + // The code flow gets here when the signal handler is not running on an alternate stack or when it wasn't created + // by coreclr. In both cases, we execute the common_signal_handler directly. + // If thread isn't created by coreclr and has alternate signal stack GetCurrentPalThread() will return NULL too. + // But since in this case we don't handle hardware exceptions (IsSafeToHandleHardwareException returns false) + // we can call common_signal_handler on the alternate stack. + if (common_signal_handler(code, siginfo, context, 2, (size_t)0, (size_t)siginfo->si_addr)) + { + return; + } } } } diff --git a/src/coreclr/pal/src/init/pal.cpp b/src/coreclr/pal/src/init/pal.cpp index 7a8fc556724..4eeaa93b1e1 100644 --- a/src/coreclr/pal/src/init/pal.cpp +++ b/src/coreclr/pal/src/init/pal.cpp @@ -127,21 +127,6 @@ static BOOL INIT_SharedFilesPath(void); extern void PROCDumpThreadList(void); #endif -#if defined(__APPLE__) -static bool RunningNatively() -{ - int ret = 0; - size_t sz = sizeof(ret); - if (sysctlbyname("sysctl.proc_native", &ret, &sz, nullptr, 0) != 0) - { - // if the sysctl failed, we'll assume this OS does not support - // binary translation - so we must be running natively. - return true; - } - return ret != 0; -} -#endif // __APPLE__ - /*++ Function: PAL_Initialize @@ -328,14 +313,6 @@ Initialize( /*Firstly initiate a lastError */ SetLastError(ERROR_GEN_FAILURE); -#ifdef __APPLE__ - if (!RunningNatively()) - { - SetLastError(ERROR_BAD_FORMAT); - goto exit; - } -#endif // __APPLE__ - CriticalSectionSubSysInitialize(); if(nullptr == init_critsec) @@ -629,6 +606,17 @@ Initialize( goto CLEANUP10; } + if (flags & PAL_INITIALIZE_FLUSH_PROCESS_WRITE_BUFFERS) + { + // Initialize before first thread is created for faster load on Linux + if (!InitializeFlushProcessWriteBuffers()) + { + ERROR("Unable to initialize flush process write buffers\n"); + palError = ERROR_PALINIT_INITIALIZE_FLUSH_PROCESS_WRITE_BUFFERS; + goto CLEANUP10; + } + } + if (flags & PAL_INITIALIZE_SYNC_THREAD) { // @@ -730,9 +718,6 @@ Initialize( ASSERT("returning failure, but last error not set\n"); } -#ifdef __APPLE__ -exit : -#endif // __APPLE__ LOGEXIT("PAL_Initialize returns int %d\n", retval); return retval; } @@ -787,11 +772,6 @@ PAL_InitializeCoreCLR(const char *szExePath, BOOL runningInExe) return ERROR_PALINIT_PROCABORT_INITIALIZE; } - if (!InitializeFlushProcessWriteBuffers()) - { - return ERROR_PALINIT_INITIALIZE_FLUSH_PROCESS_WRITE_BUFFERS; - } - return ERROR_SUCCESS; } diff --git a/src/coreclr/pal/src/thread/context.cpp b/src/coreclr/pal/src/thread/context.cpp index 2abec3970f1..2894ce5e8a9 100644 --- a/src/coreclr/pal/src/thread/context.cpp +++ b/src/coreclr/pal/src/thread/context.cpp @@ -1700,6 +1700,12 @@ CONTEXT_GetThreadContextFromThreadState( // AMD64's FLOATING_POINT includes the xmm registers. memcpy(&lpContext->Xmm0, &pState->__fpu_xmm0, 16 * 16); + + if (threadStateFlavor == x86_FLOAT_STATE64) + { + // There was just a floating point state, so make sure the CONTEXT_XSTATE is not set + lpContext->ContextFlags &= ~(CONTEXT_XSTATE & CONTEXT_AREA_MASK); + } } break; } @@ -2068,12 +2074,12 @@ DBG_FlushInstructionCache( // As a workaround, we call __builtin___clear_cache on each page separately. const SIZE_T pageSize = GetVirtualPageSize(); - INT_PTR begin = (INT_PTR)lpBaseAddress; - const INT_PTR end = begin + dwSize; + UINT_PTR begin = (UINT_PTR)lpBaseAddress; + const UINT_PTR end = begin + dwSize; while (begin < end) { - INT_PTR endOrNextPageBegin = ALIGN_UP(begin + 1, pageSize); + UINT_PTR endOrNextPageBegin = ALIGN_UP(begin + 1, pageSize); if (endOrNextPageBegin > end) endOrNextPageBegin = end; diff --git a/src/coreclr/pal/tests/palsuite/exception_handling/pal_sxs/test1/CMakeLists.txt b/src/coreclr/pal/tests/palsuite/exception_handling/pal_sxs/test1/CMakeLists.txt index 1e653ecab83..ca5e4383d57 100644 --- a/src/coreclr/pal/tests/palsuite/exception_handling/pal_sxs/test1/CMakeLists.txt +++ b/src/coreclr/pal/tests/palsuite/exception_handling/pal_sxs/test1/CMakeLists.txt @@ -5,16 +5,14 @@ endif(CLR_CMAKE_HOST_UNIX) # Set the RPATH of paltest_pal_sxs_test1 so that it can find dependencies without needing to set LD_LIBRARY # For more information: http://www.cmake.org/Wiki/CMake_RPATH_handling. if(CORECLR_SET_RPATH) + set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE) if(CLR_CMAKE_HOST_OSX) set(CMAKE_BUILD_WITH_INSTALL_NAME_DIR ON) set(CMAKE_INSTALL_NAME_DIR "@rpath") - set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE) set(CMAKE_INSTALL_RPATH "@loader_path") - endif(CLR_CMAKE_HOST_OSX) - if(CLR_CMAKE_HOST_LINUX OR CLR_CMAKE_HOST_HAIKU) - set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE) + else() set(CMAKE_INSTALL_RPATH "\$ORIGIN") - endif(CLR_CMAKE_HOST_LINUX OR CLR_CMAKE_HOST_HAIKU) + endif(CLR_CMAKE_HOST_OSX) endif(CORECLR_SET_RPATH) # Test DLL1 diff --git a/src/coreclr/runtime.proj b/src/coreclr/runtime.proj index dce3f8beb61..061d9b9409d 100644 --- a/src/coreclr/runtime.proj +++ b/src/coreclr/runtime.proj @@ -1,8 +1,6 @@ - <_IcuDir Condition="'$(PkgMicrosoft_NETCore_Runtime_ICU_Transport)' != ''">$(PkgMicrosoft_NETCore_Runtime_ICU_Transport)/runtimes/$(TargetOS)-$(TargetArchitecture)$(_RuntimeVariant)/native - <_BuildNativeTargetOS>$(TargetOS) <_BuildNativeTargetOS Condition="'$(TargetsLinuxBionic)' == 'true'">linux-bionic @@ -11,10 +9,6 @@ - - - - - - <_CoreClrBuildArg Include="-cmakeargs "-DCMAKE_ICU_DIR=$(_IcuDir)"" /> - - <_CoreClrBuildArg Include="-DCMAKE_TOOLCHAIN_FILE=$(ANDROID_NDK_ROOT)/build/cmake/android.toolchain.cmake"/> <_CoreClrBuildArg Include="-DANDROID_NDK=$(ANDROID_NDK_ROOT)"/> diff --git a/src/coreclr/scripts/genRuntimeEventSources.py b/src/coreclr/scripts/genRuntimeEventSources.py index 5fcfbc0476f..ed13eeec723 100644 --- a/src/coreclr/scripts/genRuntimeEventSources.py +++ b/src/coreclr/scripts/genRuntimeEventSources.py @@ -5,8 +5,7 @@ import os import xml.dom.minidom as DOM -from utilities import open_for_update -from genEventing import RuntimeFlavor +from utilities import open_for_update, parseInclusionList import argparse import sys @@ -24,12 +23,8 @@ ######################################################################## # START CONFIGURATION ######################################################################## -coreCLRManifestsToGenerate = { - "Microsoft-Windows-DotNETRuntime" : "NativeRuntimeEventSource.CoreCLR.cs" -} - -monoManifestsToGenerate = { - "Microsoft-Windows-DotNETRuntime" : "NativeRuntimeEventSource.Mono.cs" +manifestsToGenerate = { + "Microsoft-Windows-DotNETRuntime" : "NativeRuntimeEventSource.Generated.cs" } providerNameToClassNameMap = { @@ -77,11 +72,22 @@ def writeOutput(outputFile, str): def getCSharpTypeFromManifestType(manifestType): return manifestTypeToCSharpTypeMap[manifestType] -def getManifestsToGenerate(runtimeFlavor): - if runtimeFlavor.coreclr: - return coreCLRManifestsToGenerate - elif runtimeFlavor.mono: - return monoManifestsToGenerate +def getManifestsToGenerate(): + return manifestsToGenerate + +def includeEvent(inclusionList, providerName, eventName): + if len(inclusionList) == 0: + return True + if providerName in inclusionList and eventName in inclusionList[providerName]: + return True + elif providerName in inclusionList and "*" in inclusionList[providerName]: + return True + elif "*" in inclusionList and eventName in inclusionList["*"]: + return True + elif "*" in inclusionList and "*" in inclusionList["*"]: + return True + else: + return False def generateEvent(eventNode, providerNode, outputFile, stringTable): @@ -174,7 +180,9 @@ def generateEvent(eventNode, providerNode, outputFile, stringTable): writeOutput(outputFile, "}\n\n") -def generateEvents(providerNode, outputFile, stringTable): +def generateEvents(providerNode, outputFile, stringTable, inclusion_list): + + providerName = providerNode.getAttribute("name") # Get the events element. for node in providerNode.getElementsByTagName("events"): @@ -188,6 +196,10 @@ def generateEvents(providerNode, outputFile, stringTable): # key = eventID, value = version eventList = dict() for eventNode in eventNodes: + eventName = eventNode.getAttribute('symbol') + if not includeEvent(inclusion_list, providerName, eventName): + continue + eventID = eventNode.getAttribute("value") eventVersion = eventNode.getAttribute("version") eventList[eventID] = eventVersion @@ -195,6 +207,10 @@ def generateEvents(providerNode, outputFile, stringTable): # Iterate over each event node and process it. # Only emit events for the latest version of the event, otherwise EventSource initialization will fail. for eventNode in eventNodes: + eventName = eventNode.getAttribute('symbol') + if not includeEvent(inclusion_list, providerName, eventName): + continue + eventID = eventNode.getAttribute("value") eventVersion = eventNode.getAttribute("version") if eventID in eventList and eventList[eventID] == eventVersion: @@ -305,7 +321,29 @@ def generateEnumTypeMap(providerNode): return typeMap -def generateKeywordsClass(providerNode, outputFile): +def generateKeywordsClass(providerNode, outputFile, inclusion_list): + + providerName = providerNode.getAttribute("name") + + # Get the events element. + for node in providerNode.getElementsByTagName("events"): + eventsNode = node + break + + # Get the list of event nodes. + eventNodes = eventsNode.getElementsByTagName("event") + + # Build the list of used keywords + keywordSet = set() + for eventNode in eventNodes: + eventName = eventNode.getAttribute('symbol') + if not includeEvent(inclusion_list, providerName, eventName): + continue + + # Not all events have keywords specified, and some have multiple keywords specified. + keywords = eventNode.getAttribute("keywords") + if keywords: + keywordSet = keywordSet.union(keywords.split()) # Find the keywords element. for node in providerNode.getElementsByTagName("keywords"): @@ -317,7 +355,11 @@ def generateKeywordsClass(providerNode, outputFile): increaseTabLevel() for keywordNode in keywordsNode.getElementsByTagName("keyword"): - writeOutput(outputFile, "public const EventKeywords " + keywordNode.getAttribute("name") + " = (EventKeywords)" + keywordNode.getAttribute("mask") + ";\n") + keywordName = keywordNode.getAttribute("name") + if keywordName not in keywordSet: + continue; + + writeOutput(outputFile, "public const EventKeywords " + keywordName + " = (EventKeywords)" + keywordNode.getAttribute("mask") + ";\n") decreaseTabLevel() writeOutput(outputFile, "}\n\n") @@ -338,7 +380,7 @@ def loadStringTable(manifest): return stringTable -def generateEventSources(manifestFullPath, intermediatesDirFullPath, runtimeFlavor): +def generateEventSources(manifestFullPath, intermediatesDirFullPath, inclusion_list): # Open the manifest for reading. manifest = DOM.parse(manifestFullPath) @@ -347,7 +389,7 @@ def generateEventSources(manifestFullPath, intermediatesDirFullPath, runtimeFlav stringTable = loadStringTable(manifest) # Iterate over each provider that we want to generate an EventSource for. - for providerName, outputFileName in getManifestsToGenerate(runtimeFlavor).items(): + for providerName, outputFileName in getManifestsToGenerate().items(): for node in manifest.getElementsByTagName("provider"): if node.getAttribute("name") == providerName: providerNode = node @@ -379,7 +421,7 @@ def generateEventSources(manifestFullPath, intermediatesDirFullPath, runtimeFlav increaseTabLevel() # Write the keywords class. - generateKeywordsClass(providerNode, outputFile) + generateKeywordsClass(providerNode, outputFile, inclusion_list) #### Disable enums until they are needed #### # Generate the enum type map. @@ -394,7 +436,7 @@ def generateEventSources(manifestFullPath, intermediatesDirFullPath, runtimeFlav #### Disable enums until they are needed #### # Generate events. - generateEvents(providerNode, outputFile, stringTable) + generateEvents(providerNode, outputFile, stringTable, inclusion_list) # Write the class footer. decreaseTabLevel() @@ -413,8 +455,8 @@ def main(argv): help='full path to manifest containing the description of events') required.add_argument('--intermediate', type=str, required=True, help='full path to eventprovider intermediate directory') - required.add_argument('--runtimeflavor', type=str,default="CoreCLR", - help='runtime flavor') + required.add_argument('--inc', type=str,default="", + help='full path to inclusion list') args, unknown = parser.parse_known_args(argv) if unknown: print('Unknown argument(s): ', ', '.join(unknown)) @@ -422,7 +464,7 @@ def main(argv): manifestFullPath = args.man intermediatesDirFullPath = args.intermediate - runtimeFlavor = RuntimeFlavor(args.runtimeflavor) + inclusion_filename = args.inc # Ensure the intermediates directory exists. try: @@ -431,8 +473,10 @@ def main(argv): if not os.path.isdir(intermediatesDirFullPath): raise + inclusion_list = parseInclusionList(inclusion_filename) + # Generate event sources. - generateEventSources(manifestFullPath, intermediatesDirFullPath, runtimeFlavor) + generateEventSources(manifestFullPath, intermediatesDirFullPath, inclusion_list) return 0 if __name__ == '__main__': diff --git a/src/coreclr/scripts/superpmi-collect.proj b/src/coreclr/scripts/superpmi-collect.proj index 2b15fac5698..a9a1f106982 100644 --- a/src/coreclr/scripts/superpmi-collect.proj +++ b/src/coreclr/scripts/superpmi-collect.proj @@ -148,6 +148,7 @@ false false + $(_Creator) @@ -245,21 +246,19 @@ - - - - - - + + + + + - - - - - - + + + + + diff --git a/src/coreclr/scripts/superpmi-diffs.proj b/src/coreclr/scripts/superpmi-diffs.proj index 624afc50e2c..14403126025 100644 --- a/src/coreclr/scripts/superpmi-diffs.proj +++ b/src/coreclr/scripts/superpmi-diffs.proj @@ -66,32 +66,18 @@ - - - - - - - - - - - - - - - - - + + + - - $(WorkItemCommand) -arch %(HelixWorkItem.Architecture) -host_os %(HelixWorkItem.HostOS) -target_os %(HelixWorkItem.TargetOS) + + $(WorkItemCommand) -partition_info $(ProductDirectory)/partitions/%(Identity).json $(WorkItemTimeout) - superpmi_download_%(HelixWorkItem.TargetOS)_%(HelixWorkItem.Architecture).log;superpmi_asmdiffs_%(HelixWorkItem.TargetOS)_%(HelixWorkItem.Architecture).log;superpmi_asmdiffs_summary_%(HelixWorkItem.TargetOS)_%(HelixWorkItem.Architecture).md;Asmdiffs_%(HelixWorkItem.TargetOS)_%(HelixWorkItem.Architecture).zip - superpmi_download_%(HelixWorkItem.TargetOS)_%(HelixWorkItem.Architecture).log;superpmi_tpdiff_%(HelixWorkItem.TargetOS)_%(HelixWorkItem.Architecture).log;superpmi_tpdiff_summary_%(HelixWorkItem.TargetOS)_%(HelixWorkItem.Architecture).md - superpmi_download_%(HelixWorkItem.TargetOS)_%(HelixWorkItem.Architecture).log;superpmi_asmdiffs_%(HelixWorkItem.TargetOS)_%(HelixWorkItem.Architecture).log;superpmi_asmdiffs_summary_%(HelixWorkItem.TargetOS)_%(HelixWorkItem.Architecture).md;Asmdiffs_%(HelixWorkItem.TargetOS)_%(HelixWorkItem.Architecture).zip;superpmi_tpdiff_%(HelixWorkItem.TargetOS)_%(HelixWorkItem.Architecture).log;superpmi_tpdiff_summary_%(HelixWorkItem.TargetOS)_%(HelixWorkItem.Architecture).md + superpmi_download_%(Identity).log;superpmi_asmdiffs_%(Identity).log;superpmi_asmdiffs_summary_%(Identity).json;Asmdiffs_%(Identity).zip + superpmi_download_%(Identity).log;superpmi_tpdiff_%(Identity).log;superpmi_tpdiff_summary_%(Identity).json + superpmi_download_%(Identity).log;superpmi_asmdiffs_%(Identity).log;superpmi_asmdiffs_summary_%(Identity).json;Asmdiffs_%(Identity).zip;superpmi_tpdiff_%(Identity).log;superpmi_tpdiff_summary_%(Identity).json diff --git a/src/coreclr/scripts/superpmi.py b/src/coreclr/scripts/superpmi.py index 74c9204213b..416960eae23 100644 --- a/src/coreclr/scripts/superpmi.py +++ b/src/coreclr/scripts/superpmi.py @@ -20,6 +20,7 @@ import asyncio import csv import datetime +import json import locale import logging import math @@ -125,6 +126,14 @@ 'mcs -merge -recursive -dedup -thin' followed by 'mcs -toc'. """ +summarize_description = """\ +Summarize multiple .json summaries created by --summary_as_json into a single .md file. +""" + +summary_type_help = "Type of summaries: asmdiffs or tpdiff" + +summaries_help = "List of .json files to summarize" + spmi_log_file_help = "Write SuperPMI tool output to a log file. Requires --sequential." jit_ee_version_help = """\ @@ -345,6 +354,7 @@ def add_core_root_arguments(parser, build_type_default, build_type_help): base_diff_parser.add_argument("-jitoption", action="append", help="Option to pass to both baseline and diff JIT. Format is key=value, where key is the option name without leading `DOTNET_`. `key#value` is also accepted.") base_diff_parser.add_argument("-base_jit_option", action="append", help="Option to pass to the baseline JIT. Format is key=value, where key is the option name without leading `DOTNET_`. `key#value` is also accepted.") base_diff_parser.add_argument("-diff_jit_option", action="append", help="Option to pass to the diff JIT. Format is key=value, where key is the option name without leading `DOTNET_`. `key#value` is also accepted.") +base_diff_parser.add_argument("--summary_as_json", action="store_true", help="Produce a .json file with summary information that can be summarized to markdown later") # subparser for asmdiffs asm_diff_parser = subparsers.add_parser("asmdiffs", description=asm_diff_description, parents=[core_root_parser, target_parser, superpmi_common_parser, replay_common_parser, base_diff_parser]) @@ -401,6 +411,14 @@ def add_core_root_arguments(parser, build_type_default, build_type_help): merge_mch_parser.add_argument("-pattern", required=True, help=merge_mch_pattern_help) merge_mch_parser.add_argument("--ci", action="store_true", help="Special collection mode for handling zero-sized files in Azure DevOps + Helix pipelines collections.") +# subparser for summarize + +summarize_parser = subparsers.add_parser("summarize", description=summarize_description, parents=[core_root_parser]) + +summarize_parser.add_argument("-summary_type", required=True, help=summary_type_help) +summarize_parser.add_argument("-summaries", required=True, nargs='+', help=summaries_help) +summarize_parser.add_argument("-output_long_summary_path", help="Path to output long summary to") + ################################################################################ # Helper functions ################################################################################ @@ -1873,14 +1891,23 @@ def format_pct(pct, num_decimals = 2): def compute_and_format_pct(base, diff): return format_pct(compute_pct(base, diff)) -def write_jit_options(coreclr_args, write_fh): +def write_jit_options(base_options, diff_options, write_fh): """ If any custom JIT options are specified then write their values out to a summmary Args: - coreclr_args: args class instance + base_options: base JIT options + diff_options: diff JIT options write_fh: file to output to """ + + if len(base_options) > 0: + write_fh.write("Base JIT options: {}\n\n".format(";".join(base_options))) + + if len(diff_options) > 0: + write_fh.write("Diff JIT options: {}\n\n".format(";".join(diff_options))) + +def get_base_diff_jit_options(coreclr_args): base_options = [] diff_options = [] @@ -1894,11 +1921,7 @@ def write_jit_options(coreclr_args, write_fh): if coreclr_args.diff_jit_option: diff_options += coreclr_args.diff_jit_option - if len(base_options) > 0: - write_fh.write("Base JIT options: {}\n\n".format(";".join(base_options))) - - if len(diff_options) > 0: - write_fh.write("Diff JIT options: {}\n\n".format(";".join(diff_options))) + return (base_options, diff_options) class DetailsSection: def __init__(self, write_fh, summary_text): @@ -2526,21 +2549,33 @@ def create_exception(): if not os.path.isdir(self.coreclr_args.spmi_location): os.makedirs(self.coreclr_args.spmi_location) - overall_md_summary_file = create_unique_file_name(self.coreclr_args.spmi_location, "diff_summary", "md") - if os.path.isfile(overall_md_summary_file): - os.remove(overall_md_summary_file) + summarizable_asm_diffs = self.create_summarizable_asm_diffs(asm_diffs) + (base_jit_options, diff_jit_options) = get_base_diff_jit_options(self.coreclr_args) + + if self.coreclr_args.summary_as_json: + overall_json_summary_file = create_unique_file_name(self.coreclr_args.spmi_location, "diff_summary", "json") + if os.path.isfile(overall_json_summary_file): + os.remove(overall_json_summary_file) - with open(overall_md_summary_file, "w") as write_fh: - self.write_asmdiffs_markdown_summary(write_fh, asm_diffs, True) - logging.info(" Summary Markdown file: %s", overall_md_summary_file) + with open(overall_json_summary_file, "w") as write_fh: + json.dump((base_jit_options, diff_jit_options, summarizable_asm_diffs), write_fh) + logging.info(" Summary JSON file: %s", overall_json_summary_file) + else: + overall_md_summary_file = create_unique_file_name(self.coreclr_args.spmi_location, "diff_summary", "md") + if os.path.isfile(overall_md_summary_file): + os.remove(overall_md_summary_file) + + with open(overall_md_summary_file, "w") as write_fh: + write_asmdiffs_markdown_summary(write_fh, base_jit_options, diff_jit_options, summarizable_asm_diffs, True) + logging.info(" Summary Markdown file: %s", overall_md_summary_file) - short_md_summary_file = create_unique_file_name(self.coreclr_args.spmi_location, "diff_short_summary", "md") - if os.path.isfile(short_md_summary_file): - os.remove(short_md_summary_file) + short_md_summary_file = create_unique_file_name(self.coreclr_args.spmi_location, "diff_short_summary", "md") + if os.path.isfile(short_md_summary_file): + os.remove(short_md_summary_file) - with open(short_md_summary_file, "w") as write_fh: - self.write_asmdiffs_markdown_summary(write_fh, asm_diffs, False) - logging.info(" Short Summary Markdown file: %s", short_md_summary_file) + with open(short_md_summary_file, "w") as write_fh: + write_asmdiffs_markdown_summary(write_fh, base_jit_options, diff_jit_options, summarizable_asm_diffs, False) + logging.info(" Short Summary Markdown file: %s", short_md_summary_file) # Report the set of MCH files with asm diffs and replay failures. @@ -2559,253 +2594,69 @@ def create_exception(): return result ################################################################################################ end of replay_with_asm_diffs() - def write_asmdiffs_markdown_summary(self, write_fh, asm_diffs, include_details): - """ Write a markdown summary file of the diffs that were found. + def create_summarizable_asm_diffs(self, asm_diffs): + """ Convert the information for each collection into a format that we + can summarize (either immediately or externally) Args: - write_fh : file handle for file to output to - asm_diffs : list of tuples: (mch_name, base_metrics, diff_metrics, diffs_info, jit_analyze_summary_file, examples_to_put_in_summary) + asm_diffs : list of tuples (mch_name, base_metrics, diffs_metrics, diffs_info, jit_analyze_summary_file, examples_to_put_in_summary) + where examples_to_put_in_summary is a list of tuples (diff_info_row, base_dasm_path, diff_dasm_path) + Returns: + List of tuples (mch_name, base_Metrics, diffs_metrics, diffs_info, jit_analyze_summary, examples_to_put_in_summary) + where examples_to_put_in_summary is a list of tuples (func_name, diff_info_row, diff_text) """ - def sum_base(row, col): - return sum(base_metrics[row][col] for (_, base_metrics, _, _, _, _) in asm_diffs) - - def sum_diff(row, col): - return sum(diff_metrics[row][col] for (_, _, diff_metrics, _, _, _) in asm_diffs) - - diffed_contexts = sum_diff("Overall", "Diffed contexts") - diffed_minopts_contexts = sum_diff("MinOpts", "Diffed contexts") - diffed_opts_contexts = sum_diff("FullOpts", "Diffed contexts") - missing_base_contexts = sum_base("Overall", "Missing compiles") - missing_diff_contexts = sum_diff("Overall", "Missing compiles") - total_contexts = missing_base_contexts + sum_base("Overall", "Successful compiles") + sum_base("Overall", "Failing compiles") - - def write_top_context_section(): - num_contexts_color = "#1460aa" - write_fh.write("Diffs are based on {} contexts ({} MinOpts, {} FullOpts).\n\n".format( - html_color(num_contexts_color, "{:,d}".format(diffed_contexts)), - html_color(num_contexts_color, "{:,d}".format(diffed_minopts_contexts)), - html_color(num_contexts_color, "{:,d}".format(diffed_opts_contexts)))) - - if missing_base_contexts > 0 or missing_diff_contexts > 0: - missed_color = "#d35400" - if missing_base_contexts == missing_diff_contexts: - write_fh.write("{} contexts: {}\n\n".format( - html_color(missed_color, "MISSED"), - html_color(missed_color, "{:,d} ({:1.2f}%)".format(missing_base_contexts, missing_base_contexts / total_contexts * 100)))) - else: - base_color = missed_color if missing_base_contexts > 0 else "green" - diff_color = missed_color if missing_diff_contexts > 0 else "green" - write_fh.write("{} contexts: base: {}, diff: {}\n\n".format( - html_color(missed_color, "MISSED"), - html_color(base_color, "{:,d} ({:1.2f}%)".format(missing_base_contexts, missing_base_contexts / total_contexts * 100)), - html_color(diff_color, "{:,d} ({:1.2f}%)".format(missing_diff_contexts, missing_diff_contexts / total_contexts * 100)))) - - write_jit_options(self.coreclr_args, write_fh) - - def has_diffs(row): - return row["Contexts with diffs"] > 0 - - any_diffs = any(has_diffs(diff_metrics["Overall"]) for (_, _, diff_metrics, _, _, _) in asm_diffs) - # Exclude entire diffs section? - if any_diffs: - def write_pivot_section(row): - # Exclude this particular Overall/MinOpts/FullOpts table? - if not any(has_diffs(diff_metrics[row]) for (_, _, diff_metrics, _, _, _) in asm_diffs): - return - - sum_base = sum(base_metrics[row]["Diffed code bytes"] for (_, base_metrics, _, _, _, _) in asm_diffs) - sum_diff = sum(diff_metrics[row]["Diffed code bytes"] for (_, _, diff_metrics, _, _, _) in asm_diffs) - - with DetailsSection(write_fh, "{} ({} bytes)".format(row, format_delta(sum_base, sum_diff))): - write_fh.write("|Collection|Base size (bytes)|Diff size (bytes)|PerfScore in Diffs\n") - write_fh.write("|---|--:|--:|--:|\n") - for (mch_file, base_metrics, diff_metrics, _, _, _) in asm_diffs: - # Exclude this particular row? - if not has_diffs(diff_metrics[row]): - continue - - write_fh.write("|{}|{:,d}|{}|{}|\n".format( - mch_file, - base_metrics[row]["Diffed code bytes"], - format_delta( - base_metrics[row]["Diffed code bytes"], - diff_metrics[row]["Diffed code bytes"]), - format_pct(diff_metrics[row]["Relative PerfScore Geomean (Diffs)"] * 100 - 100))) - - write_top_context_section() - write_pivot_section("Overall") - write_pivot_section("MinOpts") - write_pivot_section("FullOpts") - - if include_details: - # Next add a section with example diffs for each collection. - self.write_example_diffs_to_markdown_summary(write_fh, asm_diffs) - elif include_details: - write_top_context_section() - write_fh.write("No diffs found.\n") - - if include_details: - # Next write a detailed section - with DetailsSection(write_fh, "Details"): - if any_diffs: - write_fh.write("#### Size improvements/regressions per collection\n\n") - write_fh.write("|Collection|Contexts with diffs|Improvements|Regressions|Same size|Improvements (bytes)|Regressions (bytes)|\n") - write_fh.write("|---|--:|--:|--:|--:|--:|--:|\n") - - def write_row(name, diffs): - base_diff_sizes = [(int(r["Base size"]), int(r["Diff size"])) for r in diffs] - (num_improvements, num_regressions, num_same, byte_improvements, byte_regressions) = calculate_size_improvements_regressions(base_diff_sizes) - write_fh.write("|{}|{:,d}|{}|{}|{}|{}|{}|\n".format( - name, - len(diffs), - html_color("green", "{:,d}".format(num_improvements)), - html_color("red", "{:,d}".format(num_regressions)), - html_color("blue", "{:,d}".format(num_same)), - html_color("green", "-{:,d}".format(byte_improvements)), - html_color("red", "+{:,d}".format(byte_regressions)))) - - for (mch_file, _, diff_metrics, diffs, _, _) in asm_diffs: - write_row(mch_file, diffs) - - if len(asm_diffs) > 1: - write_row("", [r for (_, _, _, diffs, _, _) in asm_diffs for r in diffs]) - - write_fh.write("\n---\n\n") - write_fh.write("#### PerfScore improvements/regressions per collection\n\n") - write_fh.write("|Collection|Contexts with diffs|Improvements|Regressions|Same PerfScore|Improvements (PerfScore)|Regressions (PerfScore)|PerfScore Overall in FullOpts|\n") - write_fh.write("|---|--:|--:|--:|--:|--:|--:|--:|\n") - - def write_ps_row(name, diffs, perfscore_geomean): - base_diff_perfscores = [(float(r["Base PerfScore"]), float(r["Diff PerfScore"])) for r in diffs] - (num_improvements, num_regressions, num_same, ps_improvements, ps_regressions) = calculate_perfscore_improvements_regressions(base_diff_perfscores) - write_fh.write("|{}|{:,d}|{}|{}|{}|{}|{}|{}|\n".format( - name, - len(diffs), - html_color("green", "{:,d}".format(num_improvements)), - html_color("red", "{:,d}".format(num_regressions)), - html_color("blue", "{:,d}".format(num_same)), - format_pct(ps_improvements * 100), - format_pct(ps_regressions * 100), - format_pct(perfscore_geomean * 100, 4))) - - for (mch_file, _, diff_metrics, diffs, _, _) in asm_diffs: - write_ps_row(mch_file, diffs, diff_metrics["FullOpts"]["Relative PerfScore Geomean"] - 1) - - write_fh.write("\n---\n\n") - - write_fh.write("#### Context information\n\n") - write_fh.write("|Collection|Diffed contexts|MinOpts|FullOpts|Missed, base|Missed, diff|\n") - write_fh.write("|---|--:|--:|--:|--:|--:|\n") - - rows = [(mch_file, - diff_metrics["Overall"]["Diffed contexts"], - diff_metrics["MinOpts"]["Diffed contexts"], - diff_metrics["FullOpts"]["Diffed contexts"], - base_metrics["Overall"]["Missing compiles"], - diff_metrics["Overall"]["Missing compiles"], - base_metrics["Overall"]["Successful compiles"] + base_metrics["Overall"]["Failing compiles"] + base_metrics["Overall"]["Missing compiles"]) - for (mch_file, base_metrics, diff_metrics, _, _, _) in asm_diffs] - - def write_row(name, diffed_contexts, num_minopts, num_fullopts, num_missed_base, num_missed_diff, total_num_contexts): - write_fh.write("|{}|{:,d}|{:,d}|{:,d}|{:,d} ({:1.2f}%)|{:,d} ({:1.2f}%)|\n".format( - name, - diffed_contexts, - num_minopts, - num_fullopts, - num_missed_base, - num_missed_base / total_num_contexts * 100, - num_missed_diff, - num_missed_diff / total_num_contexts * 100)) + summarizable_asm_diffs = [] - for t in rows: - write_row(*t) - - if len(rows) > 1: - def sum_row(index): - return sum(r[index] for r in rows) - - write_row("", sum_row(1), sum_row(2), sum_row(3), sum_row(4), sum_row(5), sum_row(6)) - - write_fh.write("\n\n") - - if any(has_diff for (_, _, _, has_diff, _, _) in asm_diffs): - write_fh.write("---\n\n") - write_fh.write("#### jit-analyze output\n") - - for (mch_file, base_metrics, diff_metrics, has_diffs, jit_analyze_summary_file, _) in asm_diffs: - if not has_diffs or jit_analyze_summary_file is None: - continue - - with open(jit_analyze_summary_file, "r") as read_fh: - with DetailsSection(write_fh, mch_file): - write_fh.write("To reproduce these diffs on Windows {0}:\n".format(self.coreclr_args.arch)) - write_fh.write("```\n") - write_fh.write("superpmi.py asmdiffs -target_os {0} -target_arch {1} -arch {2}\n".format(self.coreclr_args.target_os, self.coreclr_args.target_arch, self.coreclr_args.arch)) - write_fh.write("```\n\n") - - shutil.copyfileobj(read_fh, write_fh) + git_exe = "git.exe" if platform.system() == "Windows" else "git" + path_var = os.environ.get("PATH") + git_path = find_file(git_exe, path_var.split(os.pathsep)) if path_var is not None else None - def write_example_diffs_to_markdown_summary(self, write_fh, asm_diffs): - """ Write a section with example diffs to the markdown summary. + for (mch_file, base_metrics, diff_metrics, diffs, jit_analyze_file, examples_to_put_in_summary) in asm_diffs: + if jit_analyze_file: + with open(jit_analyze_file, "r") as read_fh: + jit_analyze_result = read_fh.read() + else: + jit_analyze_result = None - Args: - write_fh : file handle for file to output to - asm_diffs : list of tuples: (mch_name, base_metrics, diff_metrics, diffs_info, jit_analyze_summary_file, examples_to_put_in_summary) + example_diffs = [] + for (diff, base_dasm_path, diff_dasm_path) in examples_to_put_in_summary: + context_num = int(diff["Context"]) + func_name = str(context_num) + ".dasm" - """ + assert(os.path.exists(base_dasm_path) and os.path.exists(diff_dasm_path)) - git_exe = "git.exe" if platform.system() == "Windows" else "git" - path_var = os.environ.get("PATH") - git_path = find_file(git_exe, path_var.split(os.pathsep)) if path_var is not None else None + with open(base_dasm_path) as f: + first_line = f.readline().rstrip() + if first_line and first_line.startswith("; Assembly listing for method "): + func_name += " - " + first_line[len("; Assembly listing for method "):] - if git_path is None: - write_fh.write("\nCould not find a git executable in PATH to create example diffs.\n\n") - return + diff_text = None + if git_path is None: + diff_text = "Could not find a git executable in PATH" + else: + git_diff_command = [ git_path, "diff", "--diff-algorithm=histogram", "--no-index", "--", base_dasm_path, diff_dasm_path ] + git_diff_proc = subprocess.Popen(git_diff_command, stdout=subprocess.PIPE) + (stdout, _) = git_diff_proc.communicate() + code = git_diff_proc.returncode + diff_lines = stdout.decode().splitlines() + diff_lines = diff_lines[4:] # Exclude patch header + + if code == 0 or len(diff_lines) <= 0: + diff_text = "No diffs found?" + else: + if len(diff_lines) > 250: + diff_lines = diff_lines[:250] + diff_lines.append("...") - with DetailsSection(write_fh, "Example diffs"): - for (collection_name, _, _, _, _, examples_to_put_in_summary) in asm_diffs: - if not any(examples_to_put_in_summary): - continue + diff_text = "```diff\n" + "\n".join(diff_lines) + "\n```" - with DetailsSection(write_fh, collection_name): - for (diff, base_dasm_path, diff_dasm_path) in examples_to_put_in_summary: - context_num = int(diff["Context"]) - func_name = str(context_num) + ".dasm" - - if not os.path.exists(base_dasm_path) or not os.path.exists(diff_dasm_path): - write_fh.write("Did not find base/diff .dasm files for context {}; cannot display example diff\n\n".format(context_num)) - continue - - with open(base_dasm_path) as f: - first_line = f.readline().rstrip() - if first_line and first_line.startswith("; Assembly listing for method "): - func_name += " - " + first_line[len("; Assembly listing for method "):] - - git_diff_command = [ git_path, "diff", "--diff-algorithm=histogram", "--no-index", "--", base_dasm_path, diff_dasm_path ] - git_diff_proc = subprocess.Popen(git_diff_command, stdout=subprocess.PIPE) - (stdout, _) = git_diff_proc.communicate() - code = git_diff_proc.returncode - diff_lines = stdout.decode().splitlines() - diff_lines = diff_lines[4:] # Exclude patch header - - base_size = int(diff["Base size"]) - diff_size = int(diff["Diff size"]) - with DetailsSection(write_fh, "{} ({}) : {}".format(format_delta(base_size, diff_size), compute_and_format_pct(base_size, diff_size), func_name)): - if code == 0 or len(diff_lines) <= 0: - write_fh.write("No diffs found?\n\n") - else: - write_fh.write("```diff\n") - if len(diff_lines) > 250: - diff_lines = diff_lines[:250] - diff_lines.append("...") + example_diffs.append((func_name, diff, diff_text)) - for line in diff_lines: - write_fh.write(line) - write_fh.write("\n") + summarizable_asm_diffs.append((mch_file, base_metrics, diff_metrics, diffs, jit_analyze_result, example_diffs)) - write_fh.write("\n```\n") + return summarizable_asm_diffs def pick_contexts_to_disassemble(self, diffs): """ Given information about diffs, pick the context numbers to create .dasm files for and examples to show diffs for. @@ -2885,6 +2736,212 @@ def diff_pct(r): final_contexts_indices.sort() return (final_contexts_indices, examples) +def write_asmdiffs_markdown_summary(write_fh, base_jit_options, diff_jit_options, asm_diffs, include_details): + """ Write a markdown summary file of the diffs that were found. + + Args: + write_fh : file handle for file to output to + base_jit_options: list of options used for base JIT + diff_jit_options: list of options used for diff JIT + asm_diffs : list of tuples: (mch_name, base_metrics, diff_metrics, diffs_info, jit_analyze_summary, examples_to_put_in_summary) + + """ + + def sum_base(row, col): + return sum(base_metrics[row][col] for (_, base_metrics, _, _, _, _) in asm_diffs) + + def sum_diff(row, col): + return sum(diff_metrics[row][col] for (_, _, diff_metrics, _, _, _) in asm_diffs) + + diffed_contexts = sum_diff("Overall", "Diffed contexts") + diffed_minopts_contexts = sum_diff("MinOpts", "Diffed contexts") + diffed_opts_contexts = sum_diff("FullOpts", "Diffed contexts") + missing_base_contexts = sum_base("Overall", "Missing compiles") + missing_diff_contexts = sum_diff("Overall", "Missing compiles") + total_contexts = missing_base_contexts + sum_base("Overall", "Successful compiles") + sum_base("Overall", "Failing compiles") + + def write_top_context_section(): + num_contexts_color = "#1460aa" + write_fh.write("Diffs are based on {} contexts ({} MinOpts, {} FullOpts).\n\n".format( + html_color(num_contexts_color, "{:,d}".format(diffed_contexts)), + html_color(num_contexts_color, "{:,d}".format(diffed_minopts_contexts)), + html_color(num_contexts_color, "{:,d}".format(diffed_opts_contexts)))) + + if missing_base_contexts > 0 or missing_diff_contexts > 0: + missed_color = "#d35400" + if missing_base_contexts == missing_diff_contexts: + write_fh.write("{} contexts: {}\n\n".format( + html_color(missed_color, "MISSED"), + html_color(missed_color, "{:,d} ({:1.2f}%)".format(missing_base_contexts, missing_base_contexts / total_contexts * 100)))) + else: + base_color = missed_color if missing_base_contexts > 0 else "green" + diff_color = missed_color if missing_diff_contexts > 0 else "green" + write_fh.write("{} contexts: base: {}, diff: {}\n\n".format( + html_color(missed_color, "MISSED"), + html_color(base_color, "{:,d} ({:1.2f}%)".format(missing_base_contexts, missing_base_contexts / total_contexts * 100)), + html_color(diff_color, "{:,d} ({:1.2f}%)".format(missing_diff_contexts, missing_diff_contexts / total_contexts * 100)))) + + write_jit_options(base_jit_options, diff_jit_options, write_fh) + + def has_diffs(row): + return row["Contexts with diffs"] > 0 + + any_diffs = any(has_diffs(diff_metrics["Overall"]) for (_, _, diff_metrics, _, _, _) in asm_diffs) + # Exclude entire diffs section? + if any_diffs: + def write_pivot_section(row): + # Exclude this particular Overall/MinOpts/FullOpts table? + if not any(has_diffs(diff_metrics[row]) for (_, _, diff_metrics, _, _, _) in asm_diffs): + return + + sum_base = sum(base_metrics[row]["Diffed code bytes"] for (_, base_metrics, _, _, _, _) in asm_diffs) + sum_diff = sum(diff_metrics[row]["Diffed code bytes"] for (_, _, diff_metrics, _, _, _) in asm_diffs) + + with DetailsSection(write_fh, "{} ({} bytes)".format(row, format_delta(sum_base, sum_diff))): + write_fh.write("|Collection|Base size (bytes)|Diff size (bytes)|PerfScore in Diffs\n") + write_fh.write("|---|--:|--:|--:|\n") + for (mch_file, base_metrics, diff_metrics, _, _, _) in asm_diffs: + # Exclude this particular row? + if not has_diffs(diff_metrics[row]): + continue + + write_fh.write("|{}|{:,d}|{}|{}|\n".format( + mch_file, + base_metrics[row]["Diffed code bytes"], + format_delta( + base_metrics[row]["Diffed code bytes"], + diff_metrics[row]["Diffed code bytes"]), + format_pct(diff_metrics[row]["Relative PerfScore Geomean (Diffs)"] * 100 - 100))) + + write_top_context_section() + write_pivot_section("Overall") + write_pivot_section("MinOpts") + write_pivot_section("FullOpts") + + if include_details: + # Next add a section with example diffs for each collection. + write_example_diffs_to_markdown_summary(write_fh, asm_diffs) + elif include_details: + write_top_context_section() + write_fh.write("No diffs found.\n") + + if include_details: + # Next write a detailed section + with DetailsSection(write_fh, "Details"): + if any_diffs: + write_fh.write("#### Size improvements/regressions per collection\n\n") + write_fh.write("|Collection|Contexts with diffs|Improvements|Regressions|Same size|Improvements (bytes)|Regressions (bytes)|\n") + write_fh.write("|---|--:|--:|--:|--:|--:|--:|\n") + + def write_row(name, diffs): + base_diff_sizes = [(int(r["Base size"]), int(r["Diff size"])) for r in diffs] + (num_improvements, num_regressions, num_same, byte_improvements, byte_regressions) = calculate_size_improvements_regressions(base_diff_sizes) + write_fh.write("|{}|{:,d}|{}|{}|{}|{}|{}|\n".format( + name, + len(diffs), + html_color("green", "{:,d}".format(num_improvements)), + html_color("red", "{:,d}".format(num_regressions)), + html_color("blue", "{:,d}".format(num_same)), + html_color("green", "-{:,d}".format(byte_improvements)), + html_color("red", "+{:,d}".format(byte_regressions)))) + + for (mch_file, _, diff_metrics, diffs, _, _) in asm_diffs: + write_row(mch_file, diffs) + + if len(asm_diffs) > 1: + write_row("", [r for (_, _, _, diffs, _, _) in asm_diffs for r in diffs]) + + write_fh.write("\n---\n\n") + write_fh.write("#### PerfScore improvements/regressions per collection\n\n") + write_fh.write("|Collection|Contexts with diffs|Improvements|Regressions|Same PerfScore|Improvements (PerfScore)|Regressions (PerfScore)|PerfScore Overall in FullOpts|\n") + write_fh.write("|---|--:|--:|--:|--:|--:|--:|--:|\n") + + def write_ps_row(name, diffs, perfscore_geomean): + base_diff_perfscores = [(float(r["Base PerfScore"]), float(r["Diff PerfScore"])) for r in diffs] + (num_improvements, num_regressions, num_same, ps_improvements, ps_regressions) = calculate_perfscore_improvements_regressions(base_diff_perfscores) + write_fh.write("|{}|{:,d}|{}|{}|{}|{}|{}|{}|\n".format( + name, + len(diffs), + html_color("green", "{:,d}".format(num_improvements)), + html_color("red", "{:,d}".format(num_regressions)), + html_color("blue", "{:,d}".format(num_same)), + format_pct(ps_improvements * 100), + format_pct(ps_regressions * 100), + format_pct(perfscore_geomean * 100, 4))) + + for (mch_file, _, diff_metrics, diffs, _, _) in asm_diffs: + write_ps_row(mch_file, diffs, diff_metrics["FullOpts"]["Relative PerfScore Geomean"] - 1) + + write_fh.write("\n---\n\n") + + write_fh.write("#### Context information\n\n") + write_fh.write("|Collection|Diffed contexts|MinOpts|FullOpts|Missed, base|Missed, diff|\n") + write_fh.write("|---|--:|--:|--:|--:|--:|\n") + + rows = [(mch_file, + diff_metrics["Overall"]["Diffed contexts"], + diff_metrics["MinOpts"]["Diffed contexts"], + diff_metrics["FullOpts"]["Diffed contexts"], + base_metrics["Overall"]["Missing compiles"], + diff_metrics["Overall"]["Missing compiles"], + base_metrics["Overall"]["Successful compiles"] + base_metrics["Overall"]["Failing compiles"] + base_metrics["Overall"]["Missing compiles"]) + for (mch_file, base_metrics, diff_metrics, _, _, _) in asm_diffs] + + def write_row(name, diffed_contexts, num_minopts, num_fullopts, num_missed_base, num_missed_diff, total_num_contexts): + write_fh.write("|{}|{:,d}|{:,d}|{:,d}|{:,d} ({:1.2f}%)|{:,d} ({:1.2f}%)|\n".format( + name, + diffed_contexts, + num_minopts, + num_fullopts, + num_missed_base, + num_missed_base / total_num_contexts * 100, + num_missed_diff, + num_missed_diff / total_num_contexts * 100)) + + for t in rows: + write_row(*t) + + if len(rows) > 1: + def sum_row(index): + return sum(r[index] for r in rows) + + write_row("", sum_row(1), sum_row(2), sum_row(3), sum_row(4), sum_row(5), sum_row(6)) + + write_fh.write("\n\n") + + if any(has_diff for (_, _, _, has_diff, _, _) in asm_diffs): + write_fh.write("---\n\n") + write_fh.write("#### jit-analyze output\n") + + for (mch_file, base_metrics, diff_metrics, has_diffs, jit_analyze_summary, _) in asm_diffs: + if not has_diffs or jit_analyze_summary is None: + continue + + with DetailsSection(write_fh, mch_file): + write_fh.write(jit_analyze_summary) + +def write_example_diffs_to_markdown_summary(write_fh, asm_diffs): + """ Write a section with example diffs to the markdown summary. + + Args: + write_fh : file handle for file to output to + asm_diffs : list of tuples: (mch_name, base_metrics, diff_metrics, diffs_info, jit_analyze_summary, examples_to_put_in_summary) + where examples_to_put_in_summary is a list of tuples (func_name, diff_info_row, diff_text) + + """ + + with DetailsSection(write_fh, "Example diffs"): + for (collection_name, _, _, _, _, examples_to_put_in_summary) in asm_diffs: + if not any(examples_to_put_in_summary): + continue + + with DetailsSection(write_fh, collection_name): + for (func_name, diff, diff_text) in examples_to_put_in_summary: + base_size = int(diff["Base size"]) + diff_size = int(diff["Diff size"]) + with DetailsSection(write_fh, "{} ({}) : {}".format(format_delta(base_size, diff_size), compute_and_format_pct(base_size, diff_size), func_name)): + write_fh.write(diff_text) + ################################################################################ # SuperPMI Replay/TP diff ################################################################################ @@ -3064,108 +3121,120 @@ def replay_with_throughput_diff(self): if not os.path.isdir(self.coreclr_args.spmi_location): os.makedirs(self.coreclr_args.spmi_location) - overall_md_summary_file = create_unique_file_name(self.coreclr_args.spmi_location, "tpdiff_summary", "md") + (base_jit_options, diff_jit_options) = get_base_diff_jit_options(self.coreclr_args) - if os.path.isfile(overall_md_summary_file): - os.remove(overall_md_summary_file) + if self.coreclr_args.summary_as_json: + overall_json_summary_file = create_unique_file_name(self.coreclr_args.spmi_location, "tpdiff_summary", "json") + if os.path.isfile(overall_json_summary_file): + os.remove(overall_json_summary_file) - with open(overall_md_summary_file, "w") as write_fh: - self.write_tpdiff_markdown_summary(write_fh, tp_diffs, base_jit_build_string_decoded, diff_jit_build_string_decoded, True) - logging.info(" Summary Markdown file: %s", overall_md_summary_file) + with open(overall_json_summary_file, "w") as write_fh: + json.dump((base_jit_build_string_decoded, diff_jit_build_string_decoded, base_jit_options, diff_jit_options, tp_diffs), write_fh) + logging.info(" Summary JSON file: %s", overall_json_summary_file) + else: + overall_md_summary_file = create_unique_file_name(self.coreclr_args.spmi_location, "tpdiff_summary", "md") + + if os.path.isfile(overall_md_summary_file): + os.remove(overall_md_summary_file) - short_md_summary_file = create_unique_file_name(self.coreclr_args.spmi_location, "tpdiff_short_summary", "md") + with open(overall_md_summary_file, "w") as write_fh: + self.write_tpdiff_markdown_summary(write_fh, base_jit_build_string_decoded, diff_jit_build_string_decoded, base_jit_options, diff_jit_options, tp_diffs, True) + logging.info(" Summary Markdown file: %s", overall_md_summary_file) - if os.path.isfile(short_md_summary_file): - os.remove(short_md_summary_file) + short_md_summary_file = create_unique_file_name(self.coreclr_args.spmi_location, "tpdiff_short_summary", "md") - with open(short_md_summary_file, "w") as write_fh: - self.write_tpdiff_markdown_summary(write_fh, tp_diffs, base_jit_build_string_decoded, diff_jit_build_string_decoded, False) - logging.info(" Short Summary Markdown file: %s", short_md_summary_file) + if os.path.isfile(short_md_summary_file): + os.remove(short_md_summary_file) + + with open(short_md_summary_file, "w") as write_fh: + self.write_tpdiff_markdown_summary(write_fh, base_jit_build_string_decoded, diff_jit_build_string_decoded, base_jit_options, diff_jit_options, tp_diffs, False) + logging.info(" Short Summary Markdown file: %s", short_md_summary_file) return True ################################################################################################ end of replay_with_throughput_diff() - def write_tpdiff_markdown_summary(self, write_fh, tp_diffs, base_jit_build_string_decoded, diff_jit_build_string_decoded, include_details): - - def write_top_context_section(): - if not base_jit_build_string_decoded: - write_fh.write("{} Could not decode base JIT build string".format(html_color("red", "Warning:"))) - if not diff_jit_build_string_decoded: - write_fh.write("{} Could not decode diff JIT build string".format(html_color("red", "Warning:"))) - if base_jit_build_string_decoded and diff_jit_build_string_decoded: - (base_jit_compiler_version, base_jit_with_native_pgo) = base_jit_build_string_decoded - (diff_jit_compiler_version, diff_jit_with_native_pgo) = diff_jit_build_string_decoded - - if base_jit_compiler_version != diff_jit_compiler_version: - write_fh.write("{} Different compilers used for base and diff JITs. Results may be misleading.\n".format(html_color("red", "Warning:"))) - write_fh.write("Base JIT's compiler: {}\n".format(base_jit_compiler_version)) - write_fh.write("Diff JIT's compiler: {}\n".format(diff_jit_compiler_version)) - - if base_jit_with_native_pgo: - write_fh.write("{} Base JIT was compiled with native PGO. Results may be misleading. Specify -p:NoPgoOptimize=true when building.".format(html_color("red", "Warning:"))) - if diff_jit_with_native_pgo: - write_fh.write("{} Diff JIT was compiled with native PGO. Results may be misleading. Specify -p:NoPgoOptimize=true when building.".format(html_color("red", "Warning:"))) - - write_jit_options(self.coreclr_args, write_fh) - - # We write two tables, an overview one with just significantly - # impacted collections and a detailed one that includes raw - # instruction count and all collections. - def is_significant_pct(base, diff): - if base == 0: - return diff != 0 - - return round((diff - base) / base * 100, 2) != 0 - - def is_significant(row, base, diff): - return is_significant_pct(base[row]["Diff executed instructions"], diff[row]["Diff executed instructions"]) - - if any(is_significant(row, base, diff) for row in ["Overall", "MinOpts", "FullOpts"] for (_, base, diff) in tp_diffs): - def write_pivot_section(row): - if not any(is_significant(row, base, diff) for (_, base, diff) in tp_diffs): - return - - pcts = [compute_pct(base_metrics[row]["Diff executed instructions"], diff_metrics[row]["Diff executed instructions"]) for (_, base_metrics, diff_metrics) in tp_diffs] - min_pct_str = format_pct(min(pcts)) - max_pct_str = format_pct(max(pcts)) - if min_pct_str == max_pct_str: - tp_summary = "{} ({})".format(row, min_pct_str) - else: - tp_summary = "{} ({} to {})".format(row, min_pct_str, max_pct_str) - - with DetailsSection(write_fh, tp_summary): - write_fh.write("|Collection|PDIFF|\n") - write_fh.write("|---|--:|\n") - for mch_file, base, diff in tp_diffs: - base_instructions = base[row]["Diff executed instructions"] - diff_instructions = diff[row]["Diff executed instructions"] - - if is_significant(row, base, diff): - write_fh.write("|{}|{}|\n".format( - mch_file, - compute_and_format_pct(base_instructions, diff_instructions))) - - write_top_context_section() - write_pivot_section("Overall") - write_pivot_section("MinOpts") - write_pivot_section("FullOpts") - elif include_details: - write_top_context_section() - write_fh.write("No significant throughput differences found\n") - if include_details: - with DetailsSection(write_fh, "Details"): - for (disp, row) in [("All", "Overall"), ("MinOpts", "MinOpts"), ("FullOpts", "FullOpts")]: - write_fh.write("{} contexts:\n\n".format(disp)) - write_fh.write("|Collection|Base # instructions|Diff # instructions|PDIFF|\n") - write_fh.write("|---|--:|--:|--:|\n") - for mch_file, base, diff in tp_diffs: - base_instructions = base[row]["Diff executed instructions"] - diff_instructions = diff[row]["Diff executed instructions"] - write_fh.write("|{}|{:,d}|{:,d}|{}|\n".format( - mch_file, base_instructions, diff_instructions, +def write_tpdiff_markdown_summary(write_fh, base_jit_build_string_decoded, diff_jit_build_string_decoded, base_jit_options, diff_jit_options, tp_diffs, include_details): + + def write_top_context_section(): + if not base_jit_build_string_decoded: + write_fh.write("{} Could not decode base JIT build string".format(html_color("red", "Warning:"))) + if not diff_jit_build_string_decoded: + write_fh.write("{} Could not decode diff JIT build string".format(html_color("red", "Warning:"))) + if base_jit_build_string_decoded and diff_jit_build_string_decoded: + (base_jit_compiler_version, base_jit_with_native_pgo) = base_jit_build_string_decoded + (diff_jit_compiler_version, diff_jit_with_native_pgo) = diff_jit_build_string_decoded + + if base_jit_compiler_version != diff_jit_compiler_version: + write_fh.write("{} Different compilers used for base and diff JITs. Results may be misleading.\n".format(html_color("red", "Warning:"))) + write_fh.write("Base JIT's compiler: {}\n".format(base_jit_compiler_version)) + write_fh.write("Diff JIT's compiler: {}\n".format(diff_jit_compiler_version)) + + if base_jit_with_native_pgo: + write_fh.write("{} Base JIT was compiled with native PGO. Results may be misleading. Specify -p:NoPgoOptimize=true when building.".format(html_color("red", "Warning:"))) + if diff_jit_with_native_pgo: + write_fh.write("{} Diff JIT was compiled with native PGO. Results may be misleading. Specify -p:NoPgoOptimize=true when building.".format(html_color("red", "Warning:"))) + + write_jit_options(base_jit_options, diff_jit_options, write_fh) + + # We write two tables, an overview one with just significantly + # impacted collections and a detailed one that includes raw + # instruction count and all collections. + def is_significant_pct(base, diff): + if base == 0: + return diff != 0 + + return round((diff - base) / base * 100, 2) != 0 + + def is_significant(row, base, diff): + return is_significant_pct(base[row]["Diff executed instructions"], diff[row]["Diff executed instructions"]) + + if any(is_significant(row, base, diff) for row in ["Overall", "MinOpts", "FullOpts"] for (_, base, diff) in tp_diffs): + def write_pivot_section(row): + if not any(is_significant(row, base, diff) for (_, base, diff) in tp_diffs): + return + + pcts = [compute_pct(base_metrics[row]["Diff executed instructions"], diff_metrics[row]["Diff executed instructions"]) for (_, base_metrics, diff_metrics) in tp_diffs] + min_pct_str = format_pct(min(pcts)) + max_pct_str = format_pct(max(pcts)) + if min_pct_str == max_pct_str: + tp_summary = "{} ({})".format(row, min_pct_str) + else: + tp_summary = "{} ({} to {})".format(row, min_pct_str, max_pct_str) + + with DetailsSection(write_fh, tp_summary): + write_fh.write("|Collection|PDIFF|\n") + write_fh.write("|---|--:|\n") + for mch_file, base, diff in tp_diffs: + base_instructions = base[row]["Diff executed instructions"] + diff_instructions = diff[row]["Diff executed instructions"] + + if is_significant(row, base, diff): + write_fh.write("|{}|{}|\n".format( + mch_file, compute_and_format_pct(base_instructions, diff_instructions))) - write_fh.write("\n") + + write_top_context_section() + write_pivot_section("Overall") + write_pivot_section("MinOpts") + write_pivot_section("FullOpts") + elif include_details: + write_top_context_section() + write_fh.write("No significant throughput differences found\n") + + if include_details: + with DetailsSection(write_fh, "Details"): + for (disp, row) in [("All", "Overall"), ("MinOpts", "MinOpts"), ("FullOpts", "FullOpts")]: + write_fh.write("{} contexts:\n\n".format(disp)) + write_fh.write("|Collection|Base # instructions|Diff # instructions|PDIFF|\n") + write_fh.write("|---|--:|--:|--:|\n") + for mch_file, base, diff in tp_diffs: + base_instructions = base[row]["Diff executed instructions"] + diff_instructions = diff[row]["Diff executed instructions"] + write_fh.write("|{}|{:,d}|{:,d}|{}|\n".format( + mch_file, base_instructions, diff_instructions, + compute_and_format_pct(base_instructions, diff_instructions))) + write_fh.write("\n") ################################################################################ # Argument handling helpers @@ -4071,6 +4140,60 @@ def merge_mch(coreclr_args): return True +def summarize_json_summaries(coreclr_args): + logging.info("Summarizing {} files:".format(coreclr_args.summary_type)) + for file in coreclr_args.summaries: + logging.info(" {}".format(file)) + + file_name_prefix = "diff" if coreclr_args.summary_type == "asmdiffs" else "tpdiff" + + if coreclr_args.output_long_summary_path: + overall_md_summary_file = coreclr_args.output_long_summary_path + else: + overall_md_summary_file = create_unique_file_name(coreclr_args.spmi_location, file_name_prefix + "_summary", "md") + if os.path.isfile(overall_md_summary_file): + os.remove(overall_md_summary_file) + + short_md_summary_file = create_unique_file_name(coreclr_args.spmi_location, file_name_prefix + "_short_summary", "md") + if os.path.isfile(short_md_summary_file): + os.remove(short_md_summary_file) + + if coreclr_args.summary_type == "asmdiffs": + base_jit_options = [] + diff_jit_options = [] + summarizable_asm_diffs = [] + + for json_file in coreclr_args.summaries: + with open(json_file, "r") as fh: + (base_jit_options, diff_jit_options, asm_diffs) = json.load(fh) + summarizable_asm_diffs.extend(asm_diffs) + + with open(overall_md_summary_file, "w") as write_fh: + write_asmdiffs_markdown_summary(write_fh, base_jit_options, diff_jit_options, summarizable_asm_diffs, True) + logging.info(" Summary Markdown file: %s", overall_md_summary_file) + + with open(short_md_summary_file, "w") as write_fh: + write_asmdiffs_markdown_summary(write_fh, base_jit_options, diff_jit_options, summarizable_asm_diffs, False) + logging.info(" Short Summary Markdown file: %s", short_md_summary_file) + else: + base_jit_build_string_decoded = "" + diff_jit_build_string_decoded = "" + base_jit_options = [] + diff_jit_options = [] + summarizable_tp_diffs = [] + + for json_file in coreclr_args.summaries: + with open(json_file, "r") as fh: + (base_jit_build_string_decoded, diff_jit_build_string_decoded, base_jit_options, diff_jit_options, tp_diffs) = json.load(fh) + summarizable_tp_diffs.extend(tp_diffs) + + with open(overall_md_summary_file, "w") as write_fh: + write_tpdiff_markdown_summary(write_fh, base_jit_build_string_decoded, diff_jit_build_string_decoded, base_jit_options, diff_jit_options, summarizable_tp_diffs, True) + logging.info(" Summary Markdown file: %s", overall_md_summary_file) + + with open(short_md_summary_file, "w") as write_fh: + write_tpdiff_markdown_summary(write_fh, base_jit_build_string_decoded, diff_jit_build_string_decoded, base_jit_options, diff_jit_options, summarizable_tp_diffs, False) + logging.info(" Short Summary Markdown file: %s", short_md_summary_file) def get_mch_files_for_replay(local_mch_paths, filters): """ Given a list of local MCH files, and any specified filters (in coreclr_args.filter), @@ -4573,6 +4696,11 @@ def verify_base_diff_args(): lambda unused: True, "Unable to set diff_jit_option.") + coreclr_args.verify(args, + "summary_as_json", + lambda unused: True, + "Unable to set summary_as_json") + if coreclr_args.jitoption: for o in coreclr_args.jitoption: if o.startswith("DOTNET_"): @@ -5115,6 +5243,23 @@ def verify_base_diff_args(): lambda unused: True, "Unable to set ci.") + elif coreclr_args.mode == "summarize": + + coreclr_args.verify(args, + "summary_type", + lambda unused: True, + "Unable to set summary_type") + + coreclr_args.verify(args, + "summaries", + lambda unused: True, + "Unable to set summaries") + + coreclr_args.verify(args, + "output_long_summary_path", + lambda unused: True, + "Unable to set output_long_summary_path") + if coreclr_args.mode == "replay" or coreclr_args.mode == "asmdiffs" or coreclr_args.mode == "tpdiff" or coreclr_args.mode == "download": if hasattr(coreclr_args, "private_store") and coreclr_args.private_store is not None: logging.info("Using private stores:") @@ -5322,6 +5467,9 @@ def main(args): elif coreclr_args.mode == "merge-mch": success = merge_mch(coreclr_args) + elif coreclr_args.mode == "summarize": + summarize_json_summaries(coreclr_args) + else: raise NotImplementedError(coreclr_args.mode) diff --git a/src/coreclr/scripts/superpmi_collect_setup.py b/src/coreclr/scripts/superpmi_collect_setup.py index 40c3a768e68..c1e325e8dae 100644 --- a/src/coreclr/scripts/superpmi_collect_setup.py +++ b/src/coreclr/scripts/superpmi_collect_setup.py @@ -53,6 +53,7 @@ parser.add_argument("-mch_file_tag", help="Tag to be used to mch files") parser.add_argument("-input_directory", help="Directory containing assemblies which SuperPMI will use for collection (for pmi/crossgen2 collections)") parser.add_argument("-max_size", help="Max size of each partition in MB (for pmi/crossgen2 collections)") +parser.add_argument("-public_queues", action="store_true", help="Whether to set up for public queues (or internal ones, if not specified)") is_windows = platform.system() == "Windows" @@ -264,6 +265,11 @@ def setup_args(args): max_size) * 1000 * 1000 if max_size is not None and max_size.isnumeric() else 0 # Convert to MB ) + + coreclr_args.verify(args, + "public_queues", + lambda unused: True, + "Whether to use public queues (or, if not specified, internal queues)") return coreclr_args @@ -450,22 +456,32 @@ def main(main_args): arch = coreclr_args.arch platform_name = coreclr_args.platform.lower() helix_source_prefix = "official" - creator = "" - ci = True # Determine the Helix queue name to use when running jobs. - # Note that we run in the 'internal', not 'public', instance, so we must use 'internal' queues defined in helix-queues-setup.yml. - if platform_name == "windows": - helix_queue = "Windows.11.Arm64" if arch == "arm64" else "Windows.10.Amd64.X86.Rt" - elif platform_name == "linux": - if arch == "arm": - helix_queue = "(Debian.12.Arm32)Ubuntu.2004.ArmArch@mcr.microsoft.com/dotnet-buildtools/prereqs:debian-12-helix-arm32v7" - elif arch == "arm64": - helix_queue = "(Ubuntu.1804.Arm64)Ubuntu.2004.ArmArch@mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-18.04-helix-arm64v8" - else: - helix_queue = "Ubuntu.2204.Amd64" - elif platform_name == "osx": - helix_queue = "OSX.1200.ARM64" if arch == "arm64" else "OSX.1200.Amd64" + if coreclr_args.public_queues: + if platform_name == "windows": + helix_queue = "Windows.11.Arm64.Open" if arch == "arm64" else "Windows.10.Amd64.Open" + elif platform_name == "linux": + if arch == "arm": + helix_queue = "(Debian.12.Arm32.Open)Ubuntu.2004.ArmArch.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:debian-12-helix-arm32v7" + elif arch == "arm64": + helix_queue = "(Ubuntu.2004.Arm64.Open)Ubuntu.2004.Armarch.Open@mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-20.04-helix-arm64v8" + else: + helix_queue = "Ubuntu.2204.Amd64.Open" + elif platform_name == "osx": + helix_queue = "OSX.1200.ARM64.Open" if arch == "arm64" else "OSX.1200.Amd64.Open" + else: + if platform_name == "windows": + helix_queue = "Windows.11.Arm64" if arch == "arm64" else "Windows.10.Amd64.X86.Rt" + elif platform_name == "linux": + if arch == "arm": + helix_queue = "(Debian.12.Arm32)Ubuntu.2004.ArmArch@mcr.microsoft.com/dotnet-buildtools/prereqs:debian-12-helix-arm32v7" + elif arch == "arm64": + helix_queue = "(Ubuntu.1804.Arm64)Ubuntu.2004.ArmArch@mcr.microsoft.com/dotnet-buildtools/prereqs:ubuntu-18.04-helix-arm64v8" + else: + helix_queue = "Ubuntu.2204.Amd64" + elif platform_name == "osx": + helix_queue = "OSX.1200.ARM64" if arch == "arm64" else "OSX.1200.Amd64" # Copy the superpmi scripts @@ -607,7 +623,6 @@ def make_readable(folder_name): set_pipeline_variable("InputArtifacts", input_artifacts) set_pipeline_variable("Python", ' '.join(get_python_name())) set_pipeline_variable("Architecture", arch) - set_pipeline_variable("Creator", creator) set_pipeline_variable("Queue", helix_queue) set_pipeline_variable("HelixSourcePrefix", helix_source_prefix) set_pipeline_variable("MchFileTag", coreclr_args.mch_file_tag) diff --git a/src/coreclr/scripts/superpmi_diffs.py b/src/coreclr/scripts/superpmi_diffs.py index 55388285e01..c4dd55de1bc 100644 --- a/src/coreclr/scripts/superpmi_diffs.py +++ b/src/coreclr/scripts/superpmi_diffs.py @@ -13,6 +13,8 @@ ################################################################################ import argparse +import json +from pathlib import Path from os import walk, path import shutil from coreclr_arguments import * @@ -20,14 +22,8 @@ parser = argparse.ArgumentParser(description="description") -host_os_help = "OS (windows, osx, linux). Default: current OS." - -target_os_help = "Target OS, for use with cross-compilation JIT (windows, osx, linux). Default: current OS." - -parser.add_argument("-arch", help="Architecture") parser.add_argument("-type", help="Type of diff (asmdiffs, tpdiff, all)") -parser.add_argument("-host_os", help=host_os_help) -parser.add_argument("-target_os", help=target_os_help) +parser.add_argument("-partition_info", help="Path to partition info file") parser.add_argument("-base_jit_directory", help="path to the directory containing base clrjit binaries") parser.add_argument("-diff_jit_directory", help="path to the directory containing diff clrjit binaries") parser.add_argument("-base_jit_options", help="Semicolon separated list of base jit options (in format A=B without DOTNET_ prefix)") @@ -52,21 +48,15 @@ def setup_args(args): coreclr_args = CoreclrArguments(args, require_built_core_root=False, require_built_product_dir=False, require_built_test_dir=False, default_build_type="Checked") - coreclr_args.verify(args, - "arch", - lambda unused: True, - "Unable to set arch") - coreclr_args.verify(args, "type", lambda type: type in ["asmdiffs", "tpdiff", "all"], "Invalid type \"{}\"".format) coreclr_args.verify(args, - "target_os", - lambda target_os: check_target_os(coreclr_args, target_os), - lambda target_os: "Unknown target_os {}\nSupported OS: {}".format(target_os, (", ".join(coreclr_args.valid_host_os))), - modify_arg=lambda target_os: target_os if target_os is not None else coreclr_args.host_os) # Default to `host_os` + "partition_info", + lambda unused: True, + "Unable to set partition_info") coreclr_args.verify(args, "base_jit_directory", @@ -117,9 +107,15 @@ def __init__(self, coreclr_args): self.spmi_location = os.path.join(self.script_dir, "artifacts", "spmi") self.log_directory = coreclr_args.log_directory - self.host_os = coreclr_args.host_os - self.target_os = coreclr_args.target_os - self.arch_name = coreclr_args.arch + self.host_os = "windows" if platform.system() == "Windows" else "linux" + + with open(coreclr_args.partition_info, "r") as file: + partition_info = json.load(file) + + self.target = Path(coreclr_args.partition_info).stem + self.target_os = partition_info["target_os"] + self.arch_name = partition_info["target_arch"] + self.col_name = partition_info["col_name"] self.host_arch_name = "x64" if self.arch_name.endswith("64") else "x86" # Core_Root is where the superpmi tools (superpmi.exe, mcs.exe) are expected to be found. @@ -129,15 +125,15 @@ def __init__(self, coreclr_args): # Assume everything succeeded. If any step fails, it will change this to True. self.failed = False - # List of summary MarkDown files - self.summary_md_files = [] + # List of summary json files + self.summary_json_files = [] def download_mch(self): """ Download MCH files for the diff """ print("Running superpmi.py download to get MCH files") - log_file = os.path.join(self.log_directory, "superpmi_download_{}_{}.log".format(self.target_os, self.arch_name)) + log_file = os.path.join(self.log_directory, "superpmi_download_{}.log".format(self.target)) run_command([ self.python_path, os.path.join(self.script_dir, "superpmi.py"), @@ -148,7 +144,8 @@ def download_mch(self): "-target_arch", self.arch_name, "-spmi_location", self.spmi_location, "-log_level", "debug", - "-log_file", log_file], _exit_on_fail=True) + "-log_file", log_file, + "-f", self.col_name], _exit_on_fail=True) def copy_dasm_files(self, upload_directory, tag_name): """ Copies .dasm files to a tempDirectory, zip it, and copy the compressed file to the upload directory. @@ -237,22 +234,15 @@ def do_asmdiffs(self): base_checked_jit_path = os.path.join(self.coreclr_args.base_jit_directory, "checked", jit_name) diff_checked_jit_path = os.path.join(self.coreclr_args.diff_jit_directory, "checked", jit_name) - log_file = os.path.join(self.log_directory, "superpmi_asmdiffs_{}_{}.log".format(self.target_os, self.arch_name)) + log_file = os.path.join(self.log_directory, "superpmi_asmdiffs_{}.log".format(self.target)) # This is the summary file name and location written by superpmi.py. If the file exists, remove it to ensure superpmi.py doesn't created a numbered version. - overall_md_asmdiffs_summary_file = os.path.join(self.spmi_location, "diff_summary.md") - if os.path.isfile(overall_md_asmdiffs_summary_file): - os.remove(overall_md_asmdiffs_summary_file) - - overall_md_asmdiffs_summary_file_target = os.path.join(self.log_directory, "superpmi_asmdiffs_summary_{}_{}.md".format(self.target_os, self.arch_name)) - self.summary_md_files.append((overall_md_asmdiffs_summary_file, overall_md_asmdiffs_summary_file_target)) + overall_json_asmdiffs_summary_file = os.path.join(self.spmi_location, "diff_summary.json") + if os.path.isfile(overall_json_asmdiffs_summary_file): + os.remove(overall_json_asmdiffs_summary_file) - short_md_asmdiffs_summary_file = os.path.join(self.spmi_location, "diff_short_summary.md") - if os.path.isfile(short_md_asmdiffs_summary_file): - os.remove(short_md_asmdiffs_summary_file) - - short_md_asmdiffs_summary_file_target = os.path.join(self.log_directory, "superpmi_asmdiffs_short_summary_{}_{}.md".format(self.target_os, self.arch_name)) - self.summary_md_files.append((short_md_asmdiffs_summary_file, short_md_asmdiffs_summary_file_target)) + overall_json_asmdiffs_summary_file_target = os.path.join(self.log_directory, "superpmi_asmdiffs_summary_{}.json".format(self.target)) + self.summary_json_files.append((overall_json_asmdiffs_summary_file, overall_json_asmdiffs_summary_file_target)) _, _, return_code = run_command([ self.python_path, @@ -267,6 +257,7 @@ def do_asmdiffs(self): "-diff_jit_path", diff_checked_jit_path, "-spmi_location", self.spmi_location, "-error_limit", "100", + "--summary_as_json", "-log_level", "debug", "-log_file", log_file] + self.create_jit_options_args()) @@ -275,7 +266,7 @@ def do_asmdiffs(self): self.failed = True # Prepare .dasm files to upload to AzDO - self.copy_dasm_files(self.log_directory, "{}_{}".format(self.target_os, self.arch_name)) + self.copy_dasm_files(self.log_directory, self.target) def do_tpdiff(self): """ Run tpdiff @@ -288,22 +279,15 @@ def do_tpdiff(self): base_release_jit_path = os.path.join(self.coreclr_args.base_jit_directory, "release", jit_name) diff_release_jit_path = os.path.join(self.coreclr_args.diff_jit_directory, "release", jit_name) - log_file = os.path.join(self.log_directory, "superpmi_tpdiff_{}_{}.log".format(self.target_os, self.arch_name)) + log_file = os.path.join(self.log_directory, "superpmi_tpdiff_{}.log".format(self.target)) # This is the summary file name and location written by superpmi.py. If the file exists, remove it to ensure superpmi.py doesn't created a numbered version. - overall_md_tpdiff_summary_file = os.path.join(self.spmi_location, "tpdiff_summary.md") - if os.path.isfile(overall_md_tpdiff_summary_file): - os.remove(overall_md_tpdiff_summary_file) - - overall_md_tpdiff_summary_file_target = os.path.join(self.log_directory, "superpmi_tpdiff_summary_{}_{}.md".format(self.target_os, self.arch_name)) - self.summary_md_files.append((overall_md_tpdiff_summary_file, overall_md_tpdiff_summary_file_target)) - - short_md_tpdiff_summary_file = os.path.join(self.spmi_location, "tpdiff_short_summary.md") - if os.path.isfile(short_md_tpdiff_summary_file): - os.remove(short_md_tpdiff_summary_file) + overall_json_tpdiff_summary_file = os.path.join(self.spmi_location, "tpdiff_summary.json") + if os.path.isfile(overall_json_tpdiff_summary_file): + os.remove(overall_json_tpdiff_summary_file) - short_md_tpdiff_summary_file_target = os.path.join(self.log_directory, "superpmi_tpdiff_short_summary_{}_{}.md".format(self.target_os, self.arch_name)) - self.summary_md_files.append((short_md_tpdiff_summary_file, short_md_tpdiff_summary_file_target)) + overall_json_tpdiff_summary_file_target = os.path.join(self.log_directory, "superpmi_tpdiff_summary_{}.json".format(self.target)) + self.summary_json_files.append((overall_json_tpdiff_summary_file, overall_json_tpdiff_summary_file_target)) _, _, return_code = run_command([ self.python_path, @@ -318,6 +302,7 @@ def do_tpdiff(self): "-diff_jit_path", diff_release_jit_path, "-spmi_location", self.spmi_location, "-error_limit", "100", + "--summary_as_json", "-log_level", "debug", "-log_file", log_file] + self.create_jit_options_args()) @@ -340,10 +325,10 @@ def create_jit_options_args(self): def summarize(self): """ Summarize the diffs """ - # If there are diffs, we'll get summary md files in the spmi_location directory. + # If there are diffs, we'll get summary JSON files in the spmi_location directory. # If there are no diffs, we still want to create this file and indicate there were no diffs. - for source, target in self.summary_md_files: + for source, target in self.summary_json_files: if os.path.isfile(source): try: print("Copying summary file {} -> {}".format(source, target)) @@ -355,7 +340,7 @@ def summarize(self): # errors when the Helix work item fails to upload this specified file if it doesn't exist. We should change the # upload to be conditional, or otherwise not error. with open(target, "a") as f: - f.write("") + f.write("\"\"") def main(main_args): diff --git a/src/coreclr/scripts/superpmi_diffs_setup.py b/src/coreclr/scripts/superpmi_diffs_setup.py index dd233a4191d..c6d57c1c168 100644 --- a/src/coreclr/scripts/superpmi_diffs_setup.py +++ b/src/coreclr/scripts/superpmi_diffs_setup.py @@ -19,8 +19,11 @@ ################################################################################ import argparse +import json import logging import os +import urllib +import xml.etree.ElementTree as ET from coreclr_arguments import * from jitutil import copy_directory, set_pipeline_variable, run_command, TempDir, download_files @@ -205,6 +208,67 @@ def build_jit_analyze(coreclr_args, source_directory, jit_analyze_build_director print('Error: {} not found'.format(jit_analyze_tool)) return 1 +def build_partitions(partitions_dir, bin_path, host_bitness): + mcs_path = os.path.join(bin_path, "mcs.exe" if is_windows else "mcs") + assert(os.path.exists(mcs_path)) + + command = [mcs_path, "-printJITEEVersion"] + proc = subprocess.Popen(command, stdout=subprocess.PIPE) + stdout_jit_ee_version, _ = proc.communicate() + return_code = proc.returncode + if return_code == 0: + jit_ee_version = stdout_jit_ee_version.decode('utf-8').strip() + jit_ee_version = jit_ee_version.lower() + else: + raise Exception("Could not determine JIT-EE version") + + print("JIT-EE version determined to be {}".format(jit_ee_version)) + + az_account_name = "clrjit2" + az_superpmi_container_name = "superpmi" + az_blob_storage_account_uri = "https://" + az_account_name + ".blob.core.windows.net/" + az_blob_storage_superpmi_container_uri = az_blob_storage_account_uri + az_superpmi_container_name + az_collections_root_folder = "collections" + prefix = az_collections_root_folder + "/" + jit_ee_version + prefix_urlencoded = urllib.parse.quote(prefix) + list_superpmi_container_uri = az_blob_storage_superpmi_container_uri + "?restype=container&comp=list&prefix=" + prefix_urlencoded + "/" + + try: + contents = urllib.request.urlopen(list_superpmi_container_uri).read().decode('utf-8') + except Exception as exception: + raise Exception("Didn't find any collections using %s", list_superpmi_container_uri) + + elem = ET.fromstring(contents) + + if not target_windows: + targets = [("linux", "x64")] + elif host_bitness == 64: + targets = [("windows", "x64"), ("windows", "arm64"), ("linux", "x64"), ("linux", "arm64"), ("osx", "arm64")] + else: + targets = [("windows", "x86"), ("linux", "arm")] + + targets = [(target_os, arch, []) for (target_os, arch) in targets] + + for blob in elem.findall(".//Blob"): + name = blob.find("Name").text + for (target_os, arch, collections) in targets: + name_pref = prefix + "/" + target_os + "/" + arch + "/" + if name.startswith(name_pref) and name.removesuffix(".zip").endswith(".mch"): + url = blob.find("Url").text + col_name = name[len(name_pref):].removesuffix(".zip") + collections.append({ "target_os": target_os, "target_arch": arch, "col_name": col_name, "col_url": url }) + + if not os.path.exists(partitions_dir): + os.makedirs(partitions_dir) + + for (target_os, arch, collections) in targets: + partition_index = 0 + for col in sorted(collections, key=lambda col: col["col_name"]): + json_path = os.path.join(partitions_dir, "{}-{}-{}.json".format(target_os, arch, partition_index)) + print("Partition {}-{}-{}: {}".format(target_os, arch, partition_index, col["col_name"])) + partition_index += 1 + with open(json_path, "w") as file: + file.write(json.dumps(col)) def main(main_args): """ Prepare the Helix data for SuperPMI diffs Azure DevOps pipeline. @@ -386,6 +450,11 @@ def main(main_args): if do_asmdiffs: build_jit_analyze(coreclr_args, source_directory, jit_analyze_build_directory) + ######## Generate partition information + + partitions_dir = os.path.join(correlation_payload_directory, "partitions") + build_partitions(partitions_dir, checked_directory if use_checked else release_directory, 64 if coreclr_args.arch == "x64" else 32) + ######## Set pipeline variables helix_source_prefix = "official" diff --git a/src/coreclr/scripts/superpmi_diffs_summarize.py b/src/coreclr/scripts/superpmi_diffs_summarize.py index 7d99052f9b2..3ced61fb06b 100644 --- a/src/coreclr/scripts/superpmi_diffs_summarize.py +++ b/src/coreclr/scripts/superpmi_diffs_summarize.py @@ -18,6 +18,7 @@ import os import re from coreclr_arguments import * +from jitutil import run_command parser = argparse.ArgumentParser(description="description") @@ -25,10 +26,10 @@ parser.add_argument("-arch", required=True, help="Architecture") parser.add_argument("-platform", required=True, help="OS platform") parser.add_argument("-type", required=True, help="Type of diff (asmdiffs, tpdiff, all)") +parser.add_argument("-source_directory", required=True, help="Path to the root directory of the dotnet/runtime source tree") target_windows = True - def setup_args(args): """ Setup the args. @@ -62,6 +63,11 @@ def setup_args(args): lambda type: type in ["asmdiffs", "tpdiff", "all"], "Invalid type \"{}\"".format) + coreclr_args.verify(args, + "source_directory", + os.path.isdir, + "source_directory doesn't exist") + do_asmdiffs = False do_tpdiff = False if coreclr_args.type == 'asmdiffs': @@ -139,6 +145,7 @@ def main(main_args): diff_summary_dir = coreclr_args.diff_summary_dir arch = coreclr_args.arch platform_name = coreclr_args.platform.lower() + source_directory = coreclr_args.source_directory do_asmdiffs = False do_tpdiff = False @@ -150,7 +157,43 @@ def main(main_args): do_asmdiffs = True do_tpdiff = True - # Consolidate all superpmi_asmdiffs_summary_*.md and superpmi_tpdiff_summary_*.md + superpmi_scripts_directory = os.path.join(source_directory, 'src', 'coreclr', 'scripts') + python_path = sys.executable + + # First summarize all .JSON to a .md for each (diff_type, target_os, target_arch). + per_diff_target = {} + for dir_path, _, file_names in os.walk(diff_summary_dir): + for file_name in sorted(file_names): + match = re.search("superpmi_(.*)_summary_(.*)-(.*)-(\\d+)\\.json", file_name) + if match: + diff_type = match.group(1) + target_os = match.group(2) + target_arch = match.group(3) + if (diff_type, target_os, target_arch) not in per_diff_target: + per_diff_target[(diff_type, target_os, target_arch)] = [] + + per_diff_target[(diff_type, target_os, target_arch)].append(os.path.join(dir_path, file_name)) + + superpmi_script = os.path.join(superpmi_scripts_directory, "superpmi.py") + for (diff_type, target_os, target_arch), json_files in per_diff_target.items(): + output_path = os.path.join(diff_summary_dir, "superpmi_{}_summary_{}_{}.md".format(diff_type, target_os, target_arch)) + args = [ + python_path, + superpmi_script, + "summarize", + "-summary_type", diff_type, + "-output_long_summary_path", output_path, + "-summaries" + ] + args.extend(json_files) + print("Invoking {}".format(" ".join(args))) + _, _, return_code = run_command(args, source_directory) + + if return_code != 0: + print("'{}' failed with '{}'".format(superpmi_script, return_code)) + return return_code + + # Consolidate all superpmi_asmdiffs_summary_*.json and superpmi_tpdiff_summary_*.json # into overall__summary__.md. # (Don't name it "superpmi_xxx.md" or we might consolidate it into itself.) # If there are no summary files found, add a "No diffs found" text to be explicit about that. @@ -170,7 +213,7 @@ def main(main_args): any_asmdiffs_found = False for dirpath, _, files in os.walk(diff_summary_dir): for file_name in files: - if file_name.startswith("superpmi_asmdiffs") and file_name.endswith(".md") and "_short_" not in file_name: + if file_name.startswith("superpmi_asmdiffs") and file_name.endswith(".md"): full_file_path = os.path.join(dirpath, file_name) if append_diff_file(f, file_name, full_file_path): any_asmdiffs_found = True diff --git a/src/coreclr/tools/Common/Compiler/Dataflow/DynamicallyAccessedMembersBinder.cs b/src/coreclr/tools/Common/Compiler/Dataflow/DynamicallyAccessedMembersBinder.cs index 3b317fbd01c..73b16ebfe5c 100644 --- a/src/coreclr/tools/Common/Compiler/Dataflow/DynamicallyAccessedMembersBinder.cs +++ b/src/coreclr/tools/Common/Compiler/Dataflow/DynamicallyAccessedMembersBinder.cs @@ -177,7 +177,7 @@ public static IEnumerable GetMethodsOnTypeHierarchy(this TypeDesc ty foreach (var method in type.GetMethods()) { // Ignore constructors as those are not considered methods from a reflection's point of view - if (method.IsConstructor) + if (method.IsConstructor || method.IsStaticConstructor) continue; // Ignore private methods on a base type - those are completely ignored by reflection diff --git a/src/coreclr/tools/Common/Compiler/DependencyAnalysis/Target_LoongArch64/LoongArch64Emitter.cs b/src/coreclr/tools/Common/Compiler/DependencyAnalysis/Target_LoongArch64/LoongArch64Emitter.cs index db7daeb8a90..47f8f471a17 100644 --- a/src/coreclr/tools/Common/Compiler/DependencyAnalysis/Target_LoongArch64/LoongArch64Emitter.cs +++ b/src/coreclr/tools/Common/Compiler/DependencyAnalysis/Target_LoongArch64/LoongArch64Emitter.cs @@ -144,5 +144,11 @@ public void EmitJE(Register regSrc, ISymbolNode symbol) EmitJMP(symbol); } + + // dbar + public void EmitDBAR() + { + Builder.EmitUInt(0x38720000); + } } } diff --git a/src/coreclr/tools/Common/Compiler/InstructionSetSupport.cs b/src/coreclr/tools/Common/Compiler/InstructionSetSupport.cs index f1fadd5d1cc..fbbc4753ca9 100644 --- a/src/coreclr/tools/Common/Compiler/InstructionSetSupport.cs +++ b/src/coreclr/tools/Common/Compiler/InstructionSetSupport.cs @@ -4,6 +4,7 @@ using System; using System.Collections.Generic; using System.Diagnostics; +using System.Linq; using Internal.TypeSystem; using Internal.JitInterface; @@ -341,12 +342,49 @@ public bool ComputeInstructionSetFlags(int maxVectorTBitWidth, { unsupportedInstructionSets.AddInstructionSet(instructionSetConversion[unsupported]); } + unsupportedInstructionSets.ExpandInstructionSetByReverseImplication(_architecture); unsupportedInstructionSets.Set64BitInstructionSetVariants(_architecture); if ((_architecture == TargetArchitecture.X86) || (_architecture == TargetArchitecture.ARM)) unsupportedInstructionSets.Set64BitInstructionSetVariantsUnconditionally(_architecture); + // While it's possible to enable individual AVX-512 ISA's, it is not + // optimal to do so, since they aren't totally functional this way, + // plus it is extremely rare to encounter hardware that doesn't support + // all of them. So, here we ensure that we are enabling all the ISA's + // if one is specified in the Crossgen2 or ILC command-lines. + // + // For more information, check this Github comment: + // https://github.com/dotnet/runtime/issues/106450#issuecomment-2299504035 + + if (_supportedInstructionSets.Any(iSet => iSet.Contains("avx512"))) + { + // We can simply try adding all of the AVX-512 ISA's here, + // since SortedSet just ignores the value if it is already present. + + _supportedInstructionSets.Add("avx512f"); + _supportedInstructionSets.Add("avx512f_vl"); + _supportedInstructionSets.Add("avx512bw"); + _supportedInstructionSets.Add("avx512bw_vl"); + _supportedInstructionSets.Add("avx512cd"); + _supportedInstructionSets.Add("avx512cd_vl"); + _supportedInstructionSets.Add("avx512dq"); + _supportedInstructionSets.Add("avx512dq_vl"); + + // If AVX-512VBMI is specified, then we have to include its VL + // counterpart as well. + + if (_supportedInstructionSets.Contains("avx512vbmi")) + _supportedInstructionSets.Add("avx512vbmi_vl"); + + // Having AVX10V1 and any AVX-512 instruction sets enabled, + // automatically implies AVX10V1-V512 as well. + + if (_supportedInstructionSets.Contains("avx10v1")) + _supportedInstructionSets.Add("avx10v1_v512"); + } + foreach (string supported in _supportedInstructionSets) { supportedInstructionSets.AddInstructionSet(instructionSetConversion[supported]); diff --git a/src/coreclr/tools/Common/InstructionSetHelpers.cs b/src/coreclr/tools/Common/InstructionSetHelpers.cs index b85e16fe43e..a9c4b35ed8d 100644 --- a/src/coreclr/tools/Common/InstructionSetHelpers.cs +++ b/src/coreclr/tools/Common/InstructionSetHelpers.cs @@ -117,9 +117,9 @@ public static InstructionSetSupport ConfigureInstructionSetSupport(string instru else if (instructionSet != null) { List instructionSetParams = new List(); + string[] instructionSetParamsInput = instructionSet.Split(','); // Normalize instruction set format to include implied +. - string[] instructionSetParamsInput = instructionSet.Split(','); for (int i = 0; i < instructionSetParamsInput.Length; i++) { instructionSet = instructionSetParamsInput[i].Trim(); @@ -128,14 +128,15 @@ public static InstructionSetSupport ConfigureInstructionSetSupport(string instru throw new CommandLineException(string.Format(mustNotBeMessage, "")); char firstChar = instructionSet[0]; + if ((firstChar != '+') && (firstChar != '-')) { - instructionSet = "+" + instructionSet; + instructionSet = "+" + instructionSet; } + instructionSetParams.Add(instructionSet); } - Dictionary instructionSetSpecification = new Dictionary(); foreach (string instructionSetSpecifier in instructionSetParams) { instructionSet = instructionSetSpecifier.Substring(1); diff --git a/src/coreclr/tools/Common/Internal/Runtime/ReadyToRunConstants.cs b/src/coreclr/tools/Common/Internal/Runtime/ReadyToRunConstants.cs index 21a74a3d184..85b66c56f01 100644 --- a/src/coreclr/tools/Common/Internal/Runtime/ReadyToRunConstants.cs +++ b/src/coreclr/tools/Common/Internal/Runtime/ReadyToRunConstants.cs @@ -255,7 +255,7 @@ public enum ReadyToRunHelper GetString = 0x50, // Used by /Tuning for Profile optimizations - LogMethodEnter = 0x51, + LogMethodEnter = 0x51, // No longer supported as of READYTORUN_MAJOR_VERSION 10.0 // Reflection helpers GetRuntimeTypeHandle = 0x54, diff --git a/src/coreclr/tools/Common/Internal/Runtime/RiscVLoongArch64FpStruct.cs b/src/coreclr/tools/Common/Internal/Runtime/RiscVLoongArch64FpStruct.cs index 9652bd7efeb..ad066f1d9ec 100644 --- a/src/coreclr/tools/Common/Internal/Runtime/RiscVLoongArch64FpStruct.cs +++ b/src/coreclr/tools/Common/Internal/Runtime/RiscVLoongArch64FpStruct.cs @@ -43,7 +43,6 @@ public struct FpStructInRegistersInfo public uint offset2nd; public uint SizeShift1st() { return (uint)((int)flags >> (int)FpStruct.PosSizeShift1st) & 0b11; } - public uint SizeShift2nd() { return (uint)((int)flags >> (int)FpStruct.PosSizeShift2nd) & 0b11; } public uint Size1st() { return 1u << (int)SizeShift1st(); } @@ -84,7 +83,7 @@ private static bool HandleInlineArray(int elementTypeIndex, int nElements, ref F int nFlattenedFieldsPerElement = typeIndex - elementTypeIndex; if (nFlattenedFieldsPerElement == 0) { - Debug.Assert(nElements == 1, "HasImpliedRepeatedFields must have returned a false positive"); + Debug.Assert(nElements == 1, "HasImpliedRepeatedFields must have returned a false, it can't be an array"); return true; // ignoring empty struct } @@ -158,6 +157,14 @@ private static bool FlattenFields(TypeDesc td, uint offset, ref FpStructInRegist { Debug.Assert(nFields == 1); int nElements = td.GetElementSize().AsInt / prevField.FieldType.GetElementSize().AsInt; + + // Only InlineArrays can have element type of empty struct, fixed-size buffers take only primitives + if ((typeIndex - elementTypeIndex) == 0 && (td as MetadataType).IsInlineArray) + { + Debug.Assert(nElements > 0, "InlineArray length must be > 0"); + return false; // struct containing an array of empty structs is passed by integer calling convention + } + if (!HandleInlineArray(elementTypeIndex, nElements, ref info, ref typeIndex)) return false; } diff --git a/src/coreclr/tools/Common/JitInterface/CorInfoHelpFunc.cs b/src/coreclr/tools/Common/JitInterface/CorInfoHelpFunc.cs index 03b74fa9c2c..bac09b78a30 100644 --- a/src/coreclr/tools/Common/JitInterface/CorInfoHelpFunc.cs +++ b/src/coreclr/tools/Common/JitInterface/CorInfoHelpFunc.cs @@ -186,8 +186,6 @@ which is the right helper to use to allocate an object of a given type. */ /* Miscellaneous */ - CORINFO_HELP_BBT_FCN_ENTER, // record the entry to a method for collecting Tuning data - CORINFO_HELP_PINVOKE_CALLI, // Indirect pinvoke call CORINFO_HELP_TAILCALL, // Perform a tail call @@ -202,9 +200,7 @@ which is the right helper to use to allocate an object of a given type. */ // not safe for unbounded size, does not trigger GC) CORINFO_HELP_RUNTIMEHANDLE_METHOD, // determine a type/field/method handle at run-time - CORINFO_HELP_RUNTIMEHANDLE_METHOD_LOG, // determine a type/field/method handle at run-time, with IBC logging CORINFO_HELP_RUNTIMEHANDLE_CLASS, // determine a type/field/method handle at run-time - CORINFO_HELP_RUNTIMEHANDLE_CLASS_LOG, // determine a type/field/method handle at run-time, with IBC logging CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE, // Convert from a TypeHandle (native structure pointer) to RuntimeType at run-time CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE_MAYBENULL, // Convert from a TypeHandle (native structure pointer) to RuntimeType at run-time, the type may be null diff --git a/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs b/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs index 084714c8f33..c968d546f45 100644 --- a/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs +++ b/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs @@ -2098,12 +2098,17 @@ private uint getClassAttribsInternal(TypeDesc type) return (uint)result; } - private CORINFO_MODULE_STRUCT_* getClassModule(CORINFO_CLASS_STRUCT_* cls) - { throw new NotImplementedException("getClassModule"); } - private CORINFO_ASSEMBLY_STRUCT_* getModuleAssembly(CORINFO_MODULE_STRUCT_* mod) - { throw new NotImplementedException("getModuleAssembly"); } - private byte* getAssemblyName(CORINFO_ASSEMBLY_STRUCT_* assem) - { throw new NotImplementedException("getAssemblyName"); } + private byte* getClassAssemblyName(CORINFO_CLASS_STRUCT_* cls) + { + TypeDesc type = HandleToObject(cls); + + if (type is MetadataType mdType) + { + return (byte*)GetPin(StringToUTF8(mdType.Module.Assembly.GetName().Name)); + } + + return null; + } #pragma warning disable CA1822 // Mark members as static private void* LongLifetimeMalloc(UIntPtr sz) @@ -2907,18 +2912,13 @@ private bool isMoreSpecificType(CORINFO_CLASS_STRUCT_* cls1, CORINFO_CLASS_STRUC TypeDesc type1 = HandleToObject(cls1); TypeDesc type2 = HandleToObject(cls2); - // If we have a mixture of shared and unshared types, - // consider the unshared type as more specific. - bool isType1CanonSubtype = type1.IsCanonicalSubtype(CanonicalFormKind.Any); - bool isType2CanonSubtype = type2.IsCanonicalSubtype(CanonicalFormKind.Any); - if (isType1CanonSubtype != isType2CanonSubtype) + // If both types have the same type definition while + // hnd1 is shared and hnd2 is not - consider hnd2 more specific. + if (type1.HasSameTypeDefinition(type2)) { - // Only one of type1 and type2 is shared. - // type2 is more specific if type1 is the shared type. - return isType1CanonSubtype; + return type1.IsCanonicalSubtype(CanonicalFormKind.Any) && !type2.IsCanonicalSubtype(CanonicalFormKind.Any); } - // Otherwise both types are either shared or not shared. // Look for a common parent type. TypeDesc merged = TypeExtensions.MergeTypesToCommonParent(type1, type2); @@ -3111,7 +3111,7 @@ private void getThreadLocalStaticBlocksInfo(CORINFO_THREAD_STATIC_BLOCKS_INFO* p return ObjectToHandle(fieldDesc.OwningType); } - private CorInfoType getFieldType(CORINFO_FIELD_STRUCT_* field, CORINFO_CLASS_STRUCT_** structType, CORINFO_CLASS_STRUCT_* memberParent) + private CorInfoType getFieldType(CORINFO_FIELD_STRUCT_* field, CORINFO_CLASS_STRUCT_** structType, CORINFO_CLASS_STRUCT_* fieldOwnerHint) { FieldDesc fieldDesc = HandleToObject(field); TypeDesc fieldType = fieldDesc.FieldType; @@ -4482,5 +4482,10 @@ private static bool TryReadRvaFieldData(FieldDesc field, byte* buffer, int buffe } return false; } + + private CORINFO_METHOD_STRUCT_* getSpecialCopyHelper(CORINFO_CLASS_STRUCT_* type) + { + throw new NotImplementedException("getSpecialCopyHelper"); + } } } diff --git a/src/coreclr/tools/Common/JitInterface/CorInfoImpl_generated.cs b/src/coreclr/tools/Common/JitInterface/CorInfoImpl_generated.cs index 94a45a5c574..26291e015b4 100644 --- a/src/coreclr/tools/Common/JitInterface/CorInfoImpl_generated.cs +++ b/src/coreclr/tools/Common/JitInterface/CorInfoImpl_generated.cs @@ -614,42 +614,12 @@ private static uint _getClassAttribs(IntPtr thisHandle, IntPtr* ppException, COR } [UnmanagedCallersOnly] - private static CORINFO_MODULE_STRUCT_* _getClassModule(IntPtr thisHandle, IntPtr* ppException, CORINFO_CLASS_STRUCT_* cls) + private static byte* _getClassAssemblyName(IntPtr thisHandle, IntPtr* ppException, CORINFO_CLASS_STRUCT_* cls) { var _this = GetThis(thisHandle); try { - return _this.getClassModule(cls); - } - catch (Exception ex) - { - *ppException = _this.AllocException(ex); - return default; - } - } - - [UnmanagedCallersOnly] - private static CORINFO_ASSEMBLY_STRUCT_* _getModuleAssembly(IntPtr thisHandle, IntPtr* ppException, CORINFO_MODULE_STRUCT_* mod) - { - var _this = GetThis(thisHandle); - try - { - return _this.getModuleAssembly(mod); - } - catch (Exception ex) - { - *ppException = _this.AllocException(ex); - return default; - } - } - - [UnmanagedCallersOnly] - private static byte* _getAssemblyName(IntPtr thisHandle, IntPtr* ppException, CORINFO_ASSEMBLY_STRUCT_* assem) - { - var _this = GetThis(thisHandle); - try - { - return _this.getAssemblyName(assem); + return _this.getClassAssemblyName(cls); } catch (Exception ex) { @@ -1421,12 +1391,12 @@ private static UIntPtr _printFieldName(IntPtr thisHandle, IntPtr* ppException, C } [UnmanagedCallersOnly] - private static CorInfoType _getFieldType(IntPtr thisHandle, IntPtr* ppException, CORINFO_FIELD_STRUCT_* field, CORINFO_CLASS_STRUCT_** structType, CORINFO_CLASS_STRUCT_* memberParent) + private static CorInfoType _getFieldType(IntPtr thisHandle, IntPtr* ppException, CORINFO_FIELD_STRUCT_* field, CORINFO_CLASS_STRUCT_** structType, CORINFO_CLASS_STRUCT_* fieldOwnerHint) { var _this = GetThis(thisHandle); try { - return _this.getFieldType(field, structType, memberParent); + return _this.getFieldType(field, structType, fieldOwnerHint); } catch (Exception ex) { @@ -2605,10 +2575,25 @@ private static uint _getJitFlags(IntPtr thisHandle, IntPtr* ppException, CORJIT_ } } + [UnmanagedCallersOnly] + private static CORINFO_METHOD_STRUCT_* _getSpecialCopyHelper(IntPtr thisHandle, IntPtr* ppException, CORINFO_CLASS_STRUCT_* type) + { + var _this = GetThis(thisHandle); + try + { + return _this.getSpecialCopyHelper(type); + } + catch (Exception ex) + { + *ppException = _this.AllocException(ex); + return default; + } + } + private static IntPtr GetUnmanagedCallbacks() { - void** callbacks = (void**)Marshal.AllocCoTaskMem(sizeof(IntPtr) * 176); + void** callbacks = (void**)Marshal.AllocCoTaskMem(sizeof(IntPtr) * 175); callbacks[0] = (delegate* unmanaged)&_isIntrinsic; callbacks[1] = (delegate* unmanaged)&_notifyMethodInfoUsage; @@ -2651,141 +2636,140 @@ private static IntPtr GetUnmanagedCallbacks() callbacks[38] = (delegate* unmanaged)&_printClassName; callbacks[39] = (delegate* unmanaged)&_isValueClass; callbacks[40] = (delegate* unmanaged)&_getClassAttribs; - callbacks[41] = (delegate* unmanaged)&_getClassModule; - callbacks[42] = (delegate* unmanaged)&_getModuleAssembly; - callbacks[43] = (delegate* unmanaged)&_getAssemblyName; - callbacks[44] = (delegate* unmanaged)&_LongLifetimeMalloc; - callbacks[45] = (delegate* unmanaged)&_LongLifetimeFree; - callbacks[46] = (delegate* unmanaged)&_getIsClassInitedFlagAddress; - callbacks[47] = (delegate* unmanaged)&_getClassThreadStaticDynamicInfo; - callbacks[48] = (delegate* unmanaged)&_getClassStaticDynamicInfo; - callbacks[49] = (delegate* unmanaged)&_getStaticBaseAddress; - callbacks[50] = (delegate* unmanaged)&_getClassSize; - callbacks[51] = (delegate* unmanaged)&_getHeapClassSize; - callbacks[52] = (delegate* unmanaged)&_canAllocateOnStack; - callbacks[53] = (delegate* unmanaged)&_getClassAlignmentRequirement; - callbacks[54] = (delegate* unmanaged)&_getClassGClayout; - callbacks[55] = (delegate* unmanaged)&_getClassNumInstanceFields; - callbacks[56] = (delegate* unmanaged)&_getFieldInClass; - callbacks[57] = (delegate* unmanaged)&_getTypeLayout; - callbacks[58] = (delegate* unmanaged)&_checkMethodModifier; - callbacks[59] = (delegate* unmanaged)&_getNewHelper; - callbacks[60] = (delegate* unmanaged)&_getNewArrHelper; - callbacks[61] = (delegate* unmanaged)&_getCastingHelper; - callbacks[62] = (delegate* unmanaged)&_getSharedCCtorHelper; - callbacks[63] = (delegate* unmanaged)&_getTypeForBox; - callbacks[64] = (delegate* unmanaged)&_getTypeForBoxOnStack; - callbacks[65] = (delegate* unmanaged)&_getBoxHelper; - callbacks[66] = (delegate* unmanaged)&_getUnBoxHelper; - callbacks[67] = (delegate* unmanaged)&_getRuntimeTypePointer; - callbacks[68] = (delegate* unmanaged)&_isObjectImmutable; - callbacks[69] = (delegate* unmanaged)&_getStringChar; - callbacks[70] = (delegate* unmanaged)&_getObjectType; - callbacks[71] = (delegate* unmanaged)&_getReadyToRunHelper; - callbacks[72] = (delegate* unmanaged)&_getReadyToRunDelegateCtorHelper; - callbacks[73] = (delegate* unmanaged)&_initClass; - callbacks[74] = (delegate* unmanaged)&_classMustBeLoadedBeforeCodeIsRun; - callbacks[75] = (delegate* unmanaged)&_getBuiltinClass; - callbacks[76] = (delegate* unmanaged)&_getTypeForPrimitiveValueClass; - callbacks[77] = (delegate* unmanaged)&_getTypeForPrimitiveNumericClass; - callbacks[78] = (delegate* unmanaged)&_canCast; - callbacks[79] = (delegate* unmanaged)&_compareTypesForCast; - callbacks[80] = (delegate* unmanaged)&_compareTypesForEquality; - callbacks[81] = (delegate* unmanaged)&_isMoreSpecificType; - callbacks[82] = (delegate* unmanaged)&_isExactType; - callbacks[83] = (delegate* unmanaged)&_isGenericType; - callbacks[84] = (delegate* unmanaged)&_isNullableType; - callbacks[85] = (delegate* unmanaged)&_isEnum; - callbacks[86] = (delegate* unmanaged)&_getParentType; - callbacks[87] = (delegate* unmanaged)&_getChildType; - callbacks[88] = (delegate* unmanaged)&_isSDArray; - callbacks[89] = (delegate* unmanaged)&_getArrayRank; - callbacks[90] = (delegate* unmanaged)&_getArrayIntrinsicID; - callbacks[91] = (delegate* unmanaged)&_getArrayInitializationData; - callbacks[92] = (delegate* unmanaged)&_canAccessClass; - callbacks[93] = (delegate* unmanaged)&_printFieldName; - callbacks[94] = (delegate* unmanaged)&_getFieldClass; - callbacks[95] = (delegate* unmanaged)&_getFieldType; - callbacks[96] = (delegate* unmanaged)&_getFieldOffset; - callbacks[97] = (delegate* unmanaged)&_getFieldInfo; - callbacks[98] = (delegate* unmanaged)&_getThreadLocalFieldInfo; - callbacks[99] = (delegate* unmanaged)&_getThreadLocalStaticBlocksInfo; - callbacks[100] = (delegate* unmanaged)&_getThreadLocalStaticInfo_NativeAOT; - callbacks[101] = (delegate* unmanaged)&_isFieldStatic; - callbacks[102] = (delegate* unmanaged)&_getArrayOrStringLength; - callbacks[103] = (delegate* unmanaged)&_getBoundaries; - callbacks[104] = (delegate* unmanaged)&_setBoundaries; - callbacks[105] = (delegate* unmanaged)&_getVars; - callbacks[106] = (delegate* unmanaged)&_setVars; - callbacks[107] = (delegate* unmanaged)&_reportRichMappings; - callbacks[108] = (delegate* unmanaged)&_reportMetadata; - callbacks[109] = (delegate* unmanaged)&_allocateArray; - callbacks[110] = (delegate* unmanaged)&_freeArray; - callbacks[111] = (delegate* unmanaged)&_getArgNext; - callbacks[112] = (delegate* unmanaged)&_getArgType; - callbacks[113] = (delegate* unmanaged)&_getExactClasses; - callbacks[114] = (delegate* unmanaged)&_getArgClass; - callbacks[115] = (delegate* unmanaged)&_getHFAType; - callbacks[116] = (delegate* unmanaged)&_runWithErrorTrap; - callbacks[117] = (delegate* unmanaged)&_runWithSPMIErrorTrap; - callbacks[118] = (delegate* unmanaged)&_getEEInfo; - callbacks[119] = (delegate* unmanaged)&_getJitTimeLogFilename; - callbacks[120] = (delegate* unmanaged)&_getMethodDefFromMethod; - callbacks[121] = (delegate* unmanaged)&_printMethodName; - callbacks[122] = (delegate* unmanaged)&_getMethodNameFromMetadata; - callbacks[123] = (delegate* unmanaged)&_getMethodHash; - callbacks[124] = (delegate* unmanaged)&_getSystemVAmd64PassStructInRegisterDescriptor; - callbacks[125] = (delegate* unmanaged)&_getSwiftLowering; - callbacks[126] = (delegate* unmanaged)&_getFpStructLowering; - callbacks[127] = (delegate* unmanaged)&_getThreadTLSIndex; - callbacks[128] = (delegate* unmanaged)&_getAddrOfCaptureThreadGlobal; - callbacks[129] = (delegate* unmanaged)&_getHelperFtn; - callbacks[130] = (delegate* unmanaged)&_getFunctionEntryPoint; - callbacks[131] = (delegate* unmanaged)&_getFunctionFixedEntryPoint; - callbacks[132] = (delegate* unmanaged)&_getMethodSync; - callbacks[133] = (delegate* unmanaged)&_getLazyStringLiteralHelper; - callbacks[134] = (delegate* unmanaged)&_embedModuleHandle; - callbacks[135] = (delegate* unmanaged)&_embedClassHandle; - callbacks[136] = (delegate* unmanaged)&_embedMethodHandle; - callbacks[137] = (delegate* unmanaged)&_embedFieldHandle; - callbacks[138] = (delegate* unmanaged)&_embedGenericHandle; - callbacks[139] = (delegate* unmanaged)&_getLocationOfThisType; - callbacks[140] = (delegate* unmanaged)&_getAddressOfPInvokeTarget; - callbacks[141] = (delegate* unmanaged)&_GetCookieForPInvokeCalliSig; - callbacks[142] = (delegate* unmanaged)&_canGetCookieForPInvokeCalliSig; - callbacks[143] = (delegate* unmanaged)&_getJustMyCodeHandle; - callbacks[144] = (delegate* unmanaged)&_GetProfilingHandle; - callbacks[145] = (delegate* unmanaged)&_getCallInfo; - callbacks[146] = (delegate* unmanaged)&_getStaticFieldContent; - callbacks[147] = (delegate* unmanaged)&_getObjectContent; - callbacks[148] = (delegate* unmanaged)&_getStaticFieldCurrentClass; - callbacks[149] = (delegate* unmanaged)&_getVarArgsHandle; - callbacks[150] = (delegate* unmanaged)&_canGetVarArgsHandle; - callbacks[151] = (delegate* unmanaged)&_constructStringLiteral; - callbacks[152] = (delegate* unmanaged)&_emptyStringLiteral; - callbacks[153] = (delegate* unmanaged)&_getFieldThreadLocalStoreID; - callbacks[154] = (delegate* unmanaged)&_GetDelegateCtor; - callbacks[155] = (delegate* unmanaged)&_MethodCompileComplete; - callbacks[156] = (delegate* unmanaged)&_getTailCallHelpers; - callbacks[157] = (delegate* unmanaged)&_convertPInvokeCalliToCall; - callbacks[158] = (delegate* unmanaged)&_notifyInstructionSetUsage; - callbacks[159] = (delegate* unmanaged)&_updateEntryPointForTailCall; - callbacks[160] = (delegate* unmanaged)&_allocMem; - callbacks[161] = (delegate* unmanaged)&_reserveUnwindInfo; - callbacks[162] = (delegate* unmanaged)&_allocUnwindInfo; - callbacks[163] = (delegate* unmanaged)&_allocGCInfo; - callbacks[164] = (delegate* unmanaged)&_setEHcount; - callbacks[165] = (delegate* unmanaged)&_setEHinfo; - callbacks[166] = (delegate* unmanaged)&_logMsg; - callbacks[167] = (delegate* unmanaged)&_doAssert; - callbacks[168] = (delegate* unmanaged)&_reportFatalError; - callbacks[169] = (delegate* unmanaged)&_getPgoInstrumentationResults; - callbacks[170] = (delegate* unmanaged)&_allocPgoInstrumentationBySchema; - callbacks[171] = (delegate* unmanaged)&_recordCallSite; - callbacks[172] = (delegate* unmanaged)&_recordRelocation; - callbacks[173] = (delegate* unmanaged)&_getRelocTypeHint; - callbacks[174] = (delegate* unmanaged)&_getExpectedTargetArchitecture; - callbacks[175] = (delegate* unmanaged)&_getJitFlags; + callbacks[41] = (delegate* unmanaged)&_getClassAssemblyName; + callbacks[42] = (delegate* unmanaged)&_LongLifetimeMalloc; + callbacks[43] = (delegate* unmanaged)&_LongLifetimeFree; + callbacks[44] = (delegate* unmanaged)&_getIsClassInitedFlagAddress; + callbacks[45] = (delegate* unmanaged)&_getClassThreadStaticDynamicInfo; + callbacks[46] = (delegate* unmanaged)&_getClassStaticDynamicInfo; + callbacks[47] = (delegate* unmanaged)&_getStaticBaseAddress; + callbacks[48] = (delegate* unmanaged)&_getClassSize; + callbacks[49] = (delegate* unmanaged)&_getHeapClassSize; + callbacks[50] = (delegate* unmanaged)&_canAllocateOnStack; + callbacks[51] = (delegate* unmanaged)&_getClassAlignmentRequirement; + callbacks[52] = (delegate* unmanaged)&_getClassGClayout; + callbacks[53] = (delegate* unmanaged)&_getClassNumInstanceFields; + callbacks[54] = (delegate* unmanaged)&_getFieldInClass; + callbacks[55] = (delegate* unmanaged)&_getTypeLayout; + callbacks[56] = (delegate* unmanaged)&_checkMethodModifier; + callbacks[57] = (delegate* unmanaged)&_getNewHelper; + callbacks[58] = (delegate* unmanaged)&_getNewArrHelper; + callbacks[59] = (delegate* unmanaged)&_getCastingHelper; + callbacks[60] = (delegate* unmanaged)&_getSharedCCtorHelper; + callbacks[61] = (delegate* unmanaged)&_getTypeForBox; + callbacks[62] = (delegate* unmanaged)&_getTypeForBoxOnStack; + callbacks[63] = (delegate* unmanaged)&_getBoxHelper; + callbacks[64] = (delegate* unmanaged)&_getUnBoxHelper; + callbacks[65] = (delegate* unmanaged)&_getRuntimeTypePointer; + callbacks[66] = (delegate* unmanaged)&_isObjectImmutable; + callbacks[67] = (delegate* unmanaged)&_getStringChar; + callbacks[68] = (delegate* unmanaged)&_getObjectType; + callbacks[69] = (delegate* unmanaged)&_getReadyToRunHelper; + callbacks[70] = (delegate* unmanaged)&_getReadyToRunDelegateCtorHelper; + callbacks[71] = (delegate* unmanaged)&_initClass; + callbacks[72] = (delegate* unmanaged)&_classMustBeLoadedBeforeCodeIsRun; + callbacks[73] = (delegate* unmanaged)&_getBuiltinClass; + callbacks[74] = (delegate* unmanaged)&_getTypeForPrimitiveValueClass; + callbacks[75] = (delegate* unmanaged)&_getTypeForPrimitiveNumericClass; + callbacks[76] = (delegate* unmanaged)&_canCast; + callbacks[77] = (delegate* unmanaged)&_compareTypesForCast; + callbacks[78] = (delegate* unmanaged)&_compareTypesForEquality; + callbacks[79] = (delegate* unmanaged)&_isMoreSpecificType; + callbacks[80] = (delegate* unmanaged)&_isExactType; + callbacks[81] = (delegate* unmanaged)&_isGenericType; + callbacks[82] = (delegate* unmanaged)&_isNullableType; + callbacks[83] = (delegate* unmanaged)&_isEnum; + callbacks[84] = (delegate* unmanaged)&_getParentType; + callbacks[85] = (delegate* unmanaged)&_getChildType; + callbacks[86] = (delegate* unmanaged)&_isSDArray; + callbacks[87] = (delegate* unmanaged)&_getArrayRank; + callbacks[88] = (delegate* unmanaged)&_getArrayIntrinsicID; + callbacks[89] = (delegate* unmanaged)&_getArrayInitializationData; + callbacks[90] = (delegate* unmanaged)&_canAccessClass; + callbacks[91] = (delegate* unmanaged)&_printFieldName; + callbacks[92] = (delegate* unmanaged)&_getFieldClass; + callbacks[93] = (delegate* unmanaged)&_getFieldType; + callbacks[94] = (delegate* unmanaged)&_getFieldOffset; + callbacks[95] = (delegate* unmanaged)&_getFieldInfo; + callbacks[96] = (delegate* unmanaged)&_getThreadLocalFieldInfo; + callbacks[97] = (delegate* unmanaged)&_getThreadLocalStaticBlocksInfo; + callbacks[98] = (delegate* unmanaged)&_getThreadLocalStaticInfo_NativeAOT; + callbacks[99] = (delegate* unmanaged)&_isFieldStatic; + callbacks[100] = (delegate* unmanaged)&_getArrayOrStringLength; + callbacks[101] = (delegate* unmanaged)&_getBoundaries; + callbacks[102] = (delegate* unmanaged)&_setBoundaries; + callbacks[103] = (delegate* unmanaged)&_getVars; + callbacks[104] = (delegate* unmanaged)&_setVars; + callbacks[105] = (delegate* unmanaged)&_reportRichMappings; + callbacks[106] = (delegate* unmanaged)&_reportMetadata; + callbacks[107] = (delegate* unmanaged)&_allocateArray; + callbacks[108] = (delegate* unmanaged)&_freeArray; + callbacks[109] = (delegate* unmanaged)&_getArgNext; + callbacks[110] = (delegate* unmanaged)&_getArgType; + callbacks[111] = (delegate* unmanaged)&_getExactClasses; + callbacks[112] = (delegate* unmanaged)&_getArgClass; + callbacks[113] = (delegate* unmanaged)&_getHFAType; + callbacks[114] = (delegate* unmanaged)&_runWithErrorTrap; + callbacks[115] = (delegate* unmanaged)&_runWithSPMIErrorTrap; + callbacks[116] = (delegate* unmanaged)&_getEEInfo; + callbacks[117] = (delegate* unmanaged)&_getJitTimeLogFilename; + callbacks[118] = (delegate* unmanaged)&_getMethodDefFromMethod; + callbacks[119] = (delegate* unmanaged)&_printMethodName; + callbacks[120] = (delegate* unmanaged)&_getMethodNameFromMetadata; + callbacks[121] = (delegate* unmanaged)&_getMethodHash; + callbacks[122] = (delegate* unmanaged)&_getSystemVAmd64PassStructInRegisterDescriptor; + callbacks[123] = (delegate* unmanaged)&_getSwiftLowering; + callbacks[124] = (delegate* unmanaged)&_getFpStructLowering; + callbacks[125] = (delegate* unmanaged)&_getThreadTLSIndex; + callbacks[126] = (delegate* unmanaged)&_getAddrOfCaptureThreadGlobal; + callbacks[127] = (delegate* unmanaged)&_getHelperFtn; + callbacks[128] = (delegate* unmanaged)&_getFunctionEntryPoint; + callbacks[129] = (delegate* unmanaged)&_getFunctionFixedEntryPoint; + callbacks[130] = (delegate* unmanaged)&_getMethodSync; + callbacks[131] = (delegate* unmanaged)&_getLazyStringLiteralHelper; + callbacks[132] = (delegate* unmanaged)&_embedModuleHandle; + callbacks[133] = (delegate* unmanaged)&_embedClassHandle; + callbacks[134] = (delegate* unmanaged)&_embedMethodHandle; + callbacks[135] = (delegate* unmanaged)&_embedFieldHandle; + callbacks[136] = (delegate* unmanaged)&_embedGenericHandle; + callbacks[137] = (delegate* unmanaged)&_getLocationOfThisType; + callbacks[138] = (delegate* unmanaged)&_getAddressOfPInvokeTarget; + callbacks[139] = (delegate* unmanaged)&_GetCookieForPInvokeCalliSig; + callbacks[140] = (delegate* unmanaged)&_canGetCookieForPInvokeCalliSig; + callbacks[141] = (delegate* unmanaged)&_getJustMyCodeHandle; + callbacks[142] = (delegate* unmanaged)&_GetProfilingHandle; + callbacks[143] = (delegate* unmanaged)&_getCallInfo; + callbacks[144] = (delegate* unmanaged)&_getStaticFieldContent; + callbacks[145] = (delegate* unmanaged)&_getObjectContent; + callbacks[146] = (delegate* unmanaged)&_getStaticFieldCurrentClass; + callbacks[147] = (delegate* unmanaged)&_getVarArgsHandle; + callbacks[148] = (delegate* unmanaged)&_canGetVarArgsHandle; + callbacks[149] = (delegate* unmanaged)&_constructStringLiteral; + callbacks[150] = (delegate* unmanaged)&_emptyStringLiteral; + callbacks[151] = (delegate* unmanaged)&_getFieldThreadLocalStoreID; + callbacks[152] = (delegate* unmanaged)&_GetDelegateCtor; + callbacks[153] = (delegate* unmanaged)&_MethodCompileComplete; + callbacks[154] = (delegate* unmanaged)&_getTailCallHelpers; + callbacks[155] = (delegate* unmanaged)&_convertPInvokeCalliToCall; + callbacks[156] = (delegate* unmanaged)&_notifyInstructionSetUsage; + callbacks[157] = (delegate* unmanaged)&_updateEntryPointForTailCall; + callbacks[158] = (delegate* unmanaged)&_allocMem; + callbacks[159] = (delegate* unmanaged)&_reserveUnwindInfo; + callbacks[160] = (delegate* unmanaged)&_allocUnwindInfo; + callbacks[161] = (delegate* unmanaged)&_allocGCInfo; + callbacks[162] = (delegate* unmanaged)&_setEHcount; + callbacks[163] = (delegate* unmanaged)&_setEHinfo; + callbacks[164] = (delegate* unmanaged)&_logMsg; + callbacks[165] = (delegate* unmanaged)&_doAssert; + callbacks[166] = (delegate* unmanaged)&_reportFatalError; + callbacks[167] = (delegate* unmanaged)&_getPgoInstrumentationResults; + callbacks[168] = (delegate* unmanaged)&_allocPgoInstrumentationBySchema; + callbacks[169] = (delegate* unmanaged)&_recordCallSite; + callbacks[170] = (delegate* unmanaged)&_recordRelocation; + callbacks[171] = (delegate* unmanaged)&_getRelocTypeHint; + callbacks[172] = (delegate* unmanaged)&_getExpectedTargetArchitecture; + callbacks[173] = (delegate* unmanaged)&_getJitFlags; + callbacks[174] = (delegate* unmanaged)&_getSpecialCopyHelper; return (IntPtr)callbacks; } diff --git a/src/coreclr/tools/Common/JitInterface/CorInfoTypes.cs b/src/coreclr/tools/Common/JitInterface/CorInfoTypes.cs index 902fa1159ed..74b260578fd 100644 --- a/src/coreclr/tools/Common/JitInterface/CorInfoTypes.cs +++ b/src/coreclr/tools/Common/JitInterface/CorInfoTypes.cs @@ -52,10 +52,6 @@ public struct CORINFO_MODULE_STRUCT_ { } - public struct CORINFO_ASSEMBLY_STRUCT_ - { - } - public struct CORINFO_CONTEXT_STRUCT { } @@ -783,6 +779,7 @@ public enum CorInfoTypeWithMod { CORINFO_TYPE_MASK = 0x3F, // lower 6 bits are type mask CORINFO_TYPE_MOD_PINNED = 0x40, // can be applied to CLASS, or BYREF to indicate pinned + CORINFO_TYPE_MOD_COPY_WITH_HELPER = 0x80, // can be applied to VALUECLASS to indicate 'needs helper to copy' }; public struct CORINFO_HELPER_ARG diff --git a/src/coreclr/tools/Common/JitInterface/ThunkGenerator/ThunkInput.txt b/src/coreclr/tools/Common/JitInterface/ThunkGenerator/ThunkInput.txt index a7ca75b0d7b..bf98cf70a7e 100644 --- a/src/coreclr/tools/Common/JitInterface/ThunkGenerator/ThunkInput.txt +++ b/src/coreclr/tools/Common/JitInterface/ThunkGenerator/ThunkInput.txt @@ -144,7 +144,6 @@ CORINFO_METHOD_HANDLE,CORINFO_METHOD_STRUCT_* CORINFO_FIELD_HANDLE,CORINFO_FIELD_STRUCT_* CORINFO_OBJECT_HANDLE,CORINFO_OBJECT_STRUCT_* CORINFO_CLASS_HANDLE,CORINFO_CLASS_STRUCT_* -CORINFO_ASSEMBLY_HANDLE,CORINFO_ASSEMBLY_STRUCT_* CORINFO_JUST_MY_CODE_HANDLE,CORINFO_JUST_MY_CODE_HANDLE_* CORINFO_MODULE_HANDLE*,CORINFO_MODULE_STRUCT_** CORINFO_CLASS_HANDLE*,CORINFO_CLASS_STRUCT_** @@ -205,9 +204,7 @@ FUNCTIONS size_t printClassName(CORINFO_CLASS_HANDLE cls, char* buffer, size_t bufferSize, size_t* pRequiredBufferSize) bool isValueClass(CORINFO_CLASS_HANDLE cls) uint32_t getClassAttribs(CORINFO_CLASS_HANDLE cls) - CORINFO_MODULE_HANDLE getClassModule(CORINFO_CLASS_HANDLE cls) - CORINFO_ASSEMBLY_HANDLE getModuleAssembly(CORINFO_MODULE_HANDLE mod) - const char* getAssemblyName(CORINFO_ASSEMBLY_HANDLE assem) + const char* getClassAssemblyName(CORINFO_CLASS_HANDLE cls) void* LongLifetimeMalloc(size_t sz) void LongLifetimeFree(void* obj) bool getIsClassInitedFlagAddress(CORINFO_CLASS_HANDLE cls, CORINFO_CONST_LOOKUP* addr, int* offset) @@ -259,7 +256,7 @@ FUNCTIONS CorInfoIsAccessAllowedResult canAccessClass(CORINFO_RESOLVED_TOKEN* pResolvedToken, CORINFO_METHOD_HANDLE callerHandle, CORINFO_HELPER_DESC* pAccessHelper) size_t printFieldName(CORINFO_FIELD_HANDLE field, char* buffer, size_t bufferSize, size_t* pRequiredBufferSize) CORINFO_CLASS_HANDLE getFieldClass(CORINFO_FIELD_HANDLE field) - CorInfoType getFieldType(CORINFO_FIELD_HANDLE field, CORINFO_CLASS_HANDLE* structType, CORINFO_CLASS_HANDLE memberParent) + CorInfoType getFieldType(CORINFO_FIELD_HANDLE field, CORINFO_CLASS_HANDLE* structType, CORINFO_CLASS_HANDLE fieldOwnerHint) unsigned getFieldOffset(CORINFO_FIELD_HANDLE field) void getFieldInfo(CORINFO_RESOLVED_TOKEN* pResolvedToken, CORINFO_METHOD_HANDLE callerHandle, CORINFO_ACCESS_FLAGS flags, CORINFO_FIELD_INFO* pResult) uint32_t getThreadLocalFieldInfo (CORINFO_FIELD_HANDLE field, bool isGCtype) @@ -340,3 +337,4 @@ FUNCTIONS uint16_t getRelocTypeHint(void* target) uint32_t getExpectedTargetArchitecture() uint32_t getJitFlags(CORJIT_FLAGS* flags, uint32_t sizeInBytes) + CORINFO_METHOD_HANDLE getSpecialCopyHelper(CORINFO_CLASS_HANDLE type) = 0; diff --git a/src/coreclr/tools/Common/TypeSystem/Common/LayoutInt.cs b/src/coreclr/tools/Common/TypeSystem/Common/LayoutInt.cs index a2067d04225..c533d9d12f0 100644 --- a/src/coreclr/tools/Common/TypeSystem/Common/LayoutInt.cs +++ b/src/coreclr/tools/Common/TypeSystem/Common/LayoutInt.cs @@ -92,6 +92,20 @@ public string ToStringInvariant() return new LayoutInt(checked(left._value - right._value)); } + public static LayoutInt AddThrowing(LayoutInt left, LayoutInt right, TypeDesc loadedType) + { + if (left.IsIndeterminate || right.IsIndeterminate) + return Indeterminate; + + int result = left._value + right._value; + + // Overflow if both arguments have the opposite sign of the result + if (((left._value ^ result) & (right._value ^ result)) < 0) + ThrowHelper.ThrowTypeLoadException(loadedType); + + return new LayoutInt(result); + } + public override bool Equals(object obj) { if (obj is LayoutInt) diff --git a/src/coreclr/tools/Common/TypeSystem/Common/MetadataFieldLayoutAlgorithm.cs b/src/coreclr/tools/Common/TypeSystem/Common/MetadataFieldLayoutAlgorithm.cs index 747df8d2b75..d9beea60014 100644 --- a/src/coreclr/tools/Common/TypeSystem/Common/MetadataFieldLayoutAlgorithm.cs +++ b/src/coreclr/tools/Common/TypeSystem/Common/MetadataFieldLayoutAlgorithm.cs @@ -436,7 +436,7 @@ protected ComputedInstanceFieldLayout ComputeSequentialFieldLayout(MetadataType cumulativeInstanceFieldPos = AlignUpInstanceFieldOffset(cumulativeInstanceFieldPos, fieldSizeAndAlignment.Alignment, type.Context.Target); offsets[fieldOrdinal] = new FieldAndOffset(field, cumulativeInstanceFieldPos + offsetBias); - cumulativeInstanceFieldPos = checked(cumulativeInstanceFieldPos + fieldSizeAndAlignment.Size); + cumulativeInstanceFieldPos = LayoutInt.AddThrowing(cumulativeInstanceFieldPos, fieldSizeAndAlignment.Size, type); fieldOrdinal++; } diff --git a/src/coreclr/tools/Common/TypeSystem/Common/MetadataVirtualMethodAlgorithm.cs b/src/coreclr/tools/Common/TypeSystem/Common/MetadataVirtualMethodAlgorithm.cs index 330296b18db..d87331f3926 100644 --- a/src/coreclr/tools/Common/TypeSystem/Common/MetadataVirtualMethodAlgorithm.cs +++ b/src/coreclr/tools/Common/TypeSystem/Common/MetadataVirtualMethodAlgorithm.cs @@ -461,7 +461,26 @@ private static void FindBaseUnificationGroup(MetadataType currentType, Unificati // Unless the current type has a name/sig match for the group, look to the base type to define the unification group further if ((nameSigMatchMethod == null) && (baseType != null)) { + // TODO! Consider if we should do this check even if the virtual name/sig match finds something. + // We may want to build up a unification group for the base just to check the further MethodImpl case here. FindBaseUnificationGroup(baseType, unificationGroup); + + // We should check to see if a the DefiningMethod on the base unification group is overriden via MethodImpl + // TODO! check to see if we need to check for MethodImpls affecting other members of the unification group + // other than the defining method + if (unificationGroup.DefiningMethod != null) + { + methodImpl = FindImplFromDeclFromMethodImpls(currentType, unificationGroup.DefiningMethod); + if (methodImpl != null) + { + if (methodImpl.RequiresSlotUnification()) + { + unificationGroup.AddMethodRequiringSlotUnification(unificationGroup.DefiningMethod); + unificationGroup.AddMethodRequiringSlotUnification(methodImpl); + } + unificationGroup.SetDefiningMethod(methodImpl); + } + } } Debug.Assert(unificationGroup.IsInGroupOrIsDefiningSlot(originalDefiningMethod)); diff --git a/src/coreclr/tools/Common/TypeSystem/Ecma/EcmaType.TypeEquivalence.cs b/src/coreclr/tools/Common/TypeSystem/Ecma/EcmaType.TypeEquivalence.cs index 94d7722c284..b7fb3327a26 100644 --- a/src/coreclr/tools/Common/TypeSystem/Ecma/EcmaType.TypeEquivalence.cs +++ b/src/coreclr/tools/Common/TypeSystem/Ecma/EcmaType.TypeEquivalence.cs @@ -14,6 +14,7 @@ public partial class EcmaType private TypeIdentifierData ComputeTypeIdentifierFromGuids() { CustomAttributeValue? guidAttribute; + if (IsInterface && _typeDefinition.Attributes.HasFlag(TypeAttributes.Import)) { // ComImport interfaces get scope from their GUID @@ -23,6 +24,7 @@ private TypeIdentifierData ComputeTypeIdentifierFromGuids() { // other equivalent types get it from the declaring assembly var attributeHandle = this.MetadataReader.GetCustomAttributeHandle(MetadataReader.GetAssemblyDefinition().GetCustomAttributes(), "System.Runtime.InteropServices", "GuidAttribute"); + if (attributeHandle.IsNil) return null; @@ -40,6 +42,7 @@ private TypeIdentifierData ComputeTypeIdentifierFromGuids() string scope = (string)guidAttribute.Value.FixedArguments[0].Value; string name = this.Name; + if (this.Namespace != null) name = this.Namespace + "." + name; @@ -53,6 +56,7 @@ private TypeIdentifierData ComputeTypeIdentifierData() // Check for type identifier attribute var typeIdentifierAttribute = this.GetDecodedCustomAttribute("System.Runtime.InteropServices", "TypeIdentifierAttribute"); + if (typeIdentifierAttribute.HasValue) { // If the type has a type identifier attribute it is always considered to be type equivalent @@ -68,28 +72,38 @@ private TypeIdentifierData ComputeTypeIdentifierData() if (typeIdentifierAttribute.Value.FixedArguments[1].Type != Context.GetWellKnownType(WellKnownType.String)) return null; - _data = new TypeIdentifierData((string)typeIdentifierAttribute.Value.FixedArguments[0].Value, (string)typeIdentifierAttribute.Value.FixedArguments[1].Value); - return _data; + return new TypeIdentifierData((string)typeIdentifierAttribute.Value.FixedArguments[0].Value, (string)typeIdentifierAttribute.Value.FixedArguments[1].Value); } - else + + // In addition to the TypeIdentifierAttribute certain other types may also be opted in to type equivalence + if (Context.SupportsCOMInterop) { - // In addition to the TypeIdentifierAttribute certain other types may also be opted in to type equivalence - if (Context.SupportsCOMInterop) + // 1. The assembly is marked with ImportedFromTypeLibAttribute or PrimaryInteropAssemblyAttribute + // We will verify this by checking for their attribute handles using the Metadata Reader. + + CustomAttributeHandle importedFromTypeLibHdl = this.MetadataReader.GetCustomAttributeHandle( + MetadataReader.GetAssemblyDefinition().GetCustomAttributes(), + "System.Runtime.InteropServices", + "ImportedFromTypeLibAttribute" + ); + + CustomAttributeHandle primaryInteropAssemblyHdl = this.MetadataReader.GetCustomAttributeHandle( + MetadataReader.GetAssemblyDefinition().GetCustomAttributes(), + "System.Runtime.InteropServices", + "PrimaryInteropAssemblyAttribute" + ); + + if (!importedFromTypeLibHdl.IsNil || !primaryInteropAssemblyHdl.IsNil) { - // 1. Type is within assembly marked with ImportedFromTypeLibAttribute or PrimaryInteropAssemblyAttribute - if (this.HasCustomAttribute("System.Runtime.InteropServices", "ImportedFromTypeLibAttribute") || this.HasCustomAttribute("System.Runtime.InteropServices", "PrimaryInteropAssemblyAttribute")) - { - // This type has a TypeIdentifier attribute if it has an appropriate shape to be considered type equivalent - } - + // This type has a TypeIdentifier attribute if it has an appropriate shape to be considered type equivalent if (!TypeHasCharacteristicsRequiredToBeTypeEquivalent) return null; - _data = ComputeTypeIdentifierFromGuids(); + return ComputeTypeIdentifierFromGuids(); } - - return null; } + + return null; } public override TypeIdentifierData TypeIdentifierData diff --git a/src/coreclr/tools/Common/TypeSystem/IL/Stubs/ComparerIntrinsics.cs b/src/coreclr/tools/Common/TypeSystem/IL/Stubs/ComparerIntrinsics.cs index e62d825af5a..a314dd3917b 100644 --- a/src/coreclr/tools/Common/TypeSystem/IL/Stubs/ComparerIntrinsics.cs +++ b/src/coreclr/tools/Common/TypeSystem/IL/Stubs/ComparerIntrinsics.cs @@ -1,6 +1,7 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System.Collections; using System.Collections.Generic; using Internal.TypeSystem; @@ -306,11 +307,11 @@ public static bool CanCompareValueTypeBits(MetadataType type, MethodDesc objectE private struct OverlappingFieldTracker { - private bool[] _usedBytes; + private BitArray _usedBytes; public OverlappingFieldTracker(MetadataType type) { - _usedBytes = new bool[type.InstanceFieldSize.AsInt]; + _usedBytes = new BitArray(type.InstanceFieldSize.AsInt); } public bool TrackField(FieldDesc field) diff --git a/src/coreclr/tools/Common/TypeSystem/IL/Stubs/RuntimeHelpersIntrinsics.cs b/src/coreclr/tools/Common/TypeSystem/IL/Stubs/RuntimeHelpersIntrinsics.cs index c0318b02959..ad0670d36f7 100644 --- a/src/coreclr/tools/Common/TypeSystem/IL/Stubs/RuntimeHelpersIntrinsics.cs +++ b/src/coreclr/tools/Common/TypeSystem/IL/Stubs/RuntimeHelpersIntrinsics.cs @@ -19,19 +19,6 @@ public static MethodIL EmitIL(MethodDesc method) Debug.Assert(((MetadataType)method.OwningType).Name == "RuntimeHelpers"); string methodName = method.Name; - if (methodName == "GetMethodTable") - { - ILEmitter emit = new ILEmitter(); - ILCodeStream codeStream = emit.NewCodeStream(); - codeStream.EmitLdArg(0); - codeStream.Emit(ILOpcode.ldflda, emit.NewToken(method.Context.SystemModule.GetKnownType("System.Runtime.CompilerServices", "RawData").GetField("Data"))); - codeStream.EmitLdc(-method.Context.Target.PointerSize); - codeStream.Emit(ILOpcode.add); - codeStream.Emit(ILOpcode.ldind_i); - codeStream.Emit(ILOpcode.ret); - return emit.Link(method); - } - // All the methods handled below are per-instantiation generic methods if (method.Instantiation.Length != 1 || method.IsTypicalMethodDefinition) return null; @@ -43,11 +30,7 @@ public static MethodIL EmitIL(MethodDesc method) return null; bool result; - if (methodName == "IsReference") - { - result = elementType.IsGCPointer; - } - else if (methodName == "IsBitwiseEquatable") + if (methodName == "IsBitwiseEquatable") { // Ideally we could detect automatically whether a type is trivially equatable // (i.e., its operator == could be implemented via memcmp). But for now we'll diff --git a/src/coreclr/tools/ILVerify/ILVerify.csproj b/src/coreclr/tools/ILVerify/ILVerify.csproj index 804f32ddc7b..e1915c65d6f 100644 --- a/src/coreclr/tools/ILVerify/ILVerify.csproj +++ b/src/coreclr/tools/ILVerify/ILVerify.csproj @@ -17,7 +17,6 @@ - diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/FlowAnnotations.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/FlowAnnotations.cs index 70c856f7ca2..737d99d93be 100644 --- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/FlowAnnotations.cs +++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/FlowAnnotations.cs @@ -232,7 +232,7 @@ public bool ShouldWarnWhenAccessedForReflection(MethodDesc method) // public override Type GetTypeWithFields() { return typeof(TestType); } // } // - // If TestType from above is trimmed, it may note have all its fields, and there would be no warnings generated. + // If TestType from above is trimmed, it may not have all its fields, and there would be no warnings generated. // But there has to be code like this somewhere in the app, in order to generate the override: // class RuntimeTypeGenerator // { @@ -440,6 +440,7 @@ protected override TypeAnnotations CreateValueFromKey(TypeDesc key) returnAnnotation = GetMemberTypesForDynamicallyAccessedMembersAttribute(reader, parameter.GetCustomAttributes()); if (returnAnnotation != DynamicallyAccessedMemberTypes.None && !IsTypeInterestingForDataflow(signature.ReturnType)) { + returnAnnotation = DynamicallyAccessedMemberTypes.None; _logger.LogWarning(method, DiagnosticId.DynamicallyAccessedMembersOnMethodReturnValueCanOnlyApplyToTypesOrStrings, method.GetDisplayName()); } } diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/HandleCallAction.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/HandleCallAction.cs index 3e9b8a1fa7d..6f9988295b6 100644 --- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/HandleCallAction.cs +++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/HandleCallAction.cs @@ -373,6 +373,11 @@ private partial bool TryHandleIntrinsic ( // case IntrinsicId.Object_GetType: { + if (instanceValue.IsEmpty ()) { + AddReturnValue (MultiValueLattice.Top); + break; + } + foreach (var valueNode in instanceValue.AsEnumerable ()) { // Note that valueNode can be statically typed in IL as some generic argument type. diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/ReflectionMarker.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/ReflectionMarker.cs index bf966393c0f..83b592554c6 100644 --- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/ReflectionMarker.cs +++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Dataflow/ReflectionMarker.cs @@ -325,9 +325,6 @@ static bool IsDeclaredWithinType(TypeSystemEntity member, TypeDesc type) var id = reportOnMember ? DiagnosticId.DynamicallyAccessedMembersOnTypeReferencesMemberWithDynamicallyAccessedMembers : DiagnosticId.DynamicallyAccessedMembersOnTypeReferencesMemberOnBaseWithDynamicallyAccessedMembers; _logger.LogWarning(origin, id, _typeHierarchyDataFlowOrigin.GetDisplayName(), entity.GetDisplayName()); } - - // We decided to not warn on reflection access to compiler-generated methods: - // https://github.com/dotnet/runtime/issues/85042 } private void ReportRequires(in MessageOrigin origin, TypeSystemEntity entity, string requiresAttributeName, in CustomAttributeValue requiresAttribute) diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/Target_LoongArch64/LoongArch64ReadyToRunGenericHelperNode.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/Target_LoongArch64/LoongArch64ReadyToRunGenericHelperNode.cs index 6d68882ae83..a391b3d081d 100644 --- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/Target_LoongArch64/LoongArch64ReadyToRunGenericHelperNode.cs +++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/Target_LoongArch64/LoongArch64ReadyToRunGenericHelperNode.cs @@ -76,6 +76,7 @@ protected sealed override void EmitCode(NodeFactory factory, ref LoongArch64Emit // We need to trigger the cctor before returning the base. It is stored at the beginning of the non-GC statics region. encoder.EmitADD(encoder.TargetRegister.Arg3, encoder.TargetRegister.Arg0, -NonGCStaticsNode.GetClassConstructorContextSize(factory.Target)); encoder.EmitLD(encoder.TargetRegister.Arg2, encoder.TargetRegister.Arg3, 0); + encoder.EmitDBAR(); encoder.EmitXOR(encoder.TargetRegister.IntraProcedureCallScratch1, encoder.TargetRegister.Arg2, 0); encoder.EmitRETIfEqual(Register.R21); @@ -108,6 +109,7 @@ protected sealed override void EmitCode(NodeFactory factory, ref LoongArch64Emit encoder.EmitADD(encoder.TargetRegister.Arg2, encoder.TargetRegister.Arg2, -NonGCStaticsNode.GetClassConstructorContextSize(factory.Target)); encoder.EmitLD(encoder.TargetRegister.Arg3, encoder.TargetRegister.Arg2, factory.Target.PointerSize); + encoder.EmitDBAR(); encoder.EmitXOR(encoder.TargetRegister.IntraProcedureCallScratch1, encoder.TargetRegister.Arg3, 1); encoder.EmitRETIfEqual(Register.R21); diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/Target_LoongArch64/LoongArch64ReadyToRunHelperNode.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/Target_LoongArch64/LoongArch64ReadyToRunHelperNode.cs index 91f05226db6..fee267399ec 100644 --- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/Target_LoongArch64/LoongArch64ReadyToRunHelperNode.cs +++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/Target_LoongArch64/LoongArch64ReadyToRunHelperNode.cs @@ -34,6 +34,7 @@ protected override void EmitCode(NodeFactory factory, ref LoongArch64Emitter enc // We need to trigger the cctor before returning the base. It is stored at the beginning of the non-GC statics region. encoder.EmitADD(encoder.TargetRegister.Arg3, encoder.TargetRegister.Result, -NonGCStaticsNode.GetClassConstructorContextSize(factory.Target)); encoder.EmitLD(encoder.TargetRegister.Arg2, encoder.TargetRegister.Arg3, factory.Target.PointerSize); + encoder.EmitDBAR(); encoder.EmitXOR(encoder.TargetRegister.IntraProcedureCallScratch1, encoder.TargetRegister.Arg2, 1); encoder.EmitRETIfEqual(encoder.TargetRegister.IntraProcedureCallScratch1); @@ -94,6 +95,7 @@ protected override void EmitCode(NodeFactory factory, ref LoongArch64Emitter enc encoder.EmitMOV(encoder.TargetRegister.Arg2, factory.TypeNonGCStaticsSymbol(target)); encoder.EmitADD(encoder.TargetRegister.Arg2, encoder.TargetRegister.Arg2, -NonGCStaticsNode.GetClassConstructorContextSize(factory.Target)); encoder.EmitLD(encoder.TargetRegister.Arg3, encoder.TargetRegister.Arg2, 0); + encoder.EmitDBAR(); encoder.EmitXOR(encoder.TargetRegister.IntraProcedureCallScratch1, encoder.TargetRegister.Arg3, 0); encoder.EmitRETIfEqual(Register.R21); diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/TypeMetadataNode.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/TypeMetadataNode.cs index 87a2c829c02..6ae29da0e6d 100644 --- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/TypeMetadataNode.cs +++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/TypeMetadataNode.cs @@ -77,9 +77,11 @@ public override IEnumerable GetStaticDependencies(NodeFacto { try { - // Make sure we're not adding a method to the dependency graph that is going to - // cause trouble down the line. This entire type would not actually load on CoreCLR anyway. - LibraryRootProvider.CheckCanGenerateMethod(method); + // Spot check by parsing signature. + // Previously we had LibraryRootProvider.CheckCanGenerateMethod(method) here, but that one + // expects fully instantiated types and methods. We operate on definitions here. + // This is not as thorough as it could be. This option is unsupported anyway. + _ = method.Signature; } catch (TypeSystemException) { diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ObjectWriter/MachNative.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ObjectWriter/MachNative.cs index 9c4f07c866c..14db96a9354 100644 --- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ObjectWriter/MachNative.cs +++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ObjectWriter/MachNative.cs @@ -96,6 +96,7 @@ internal static class MachNative public const byte N_INDR = 0xA; public const byte N_SECT = 0xE; public const byte N_PBUD = 0xC; + public const byte N_PEXT = 0x10; // Symbol descriptor flags public const ushort REFERENCE_FLAG_UNDEFINED_NON_LAZY = 0; diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ObjectWriter/MachObjectWriter.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ObjectWriter/MachObjectWriter.cs index 3001640249d..2424ec43412 100644 --- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ObjectWriter/MachObjectWriter.cs +++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ObjectWriter/MachObjectWriter.cs @@ -113,7 +113,7 @@ private protected override void EmitSectionsAndLayout() Name = $"lsection{sectionIndex}", Section = section, Value = section.VirtualAddress, - Descriptor = 0, + Descriptor = N_NO_DEAD_STRIP, Type = N_SECT, }; _symbolTable.Add(machSymbol); @@ -484,7 +484,7 @@ private protected override void EmitSymbolTable( Section = section, Value = section.VirtualAddress + (ulong)definition.Value, Descriptor = N_NO_DEAD_STRIP, - Type = N_SECT | N_EXT, + Type = (byte)(N_SECT | N_EXT | (definition.Global ? 0 : N_PEXT)), }); } sortedDefinedSymbols.Sort((symA, symB) => string.CompareOrdinal(symA.Name, symB.Name)); diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ObjectWriter/ObjectWriter.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ObjectWriter/ObjectWriter.cs index dca7910a6b5..b3203d08b0d 100644 --- a/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ObjectWriter/ObjectWriter.cs +++ b/src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ObjectWriter/ObjectWriter.cs @@ -424,11 +424,18 @@ private void EmitObject(string objectFilePath, IReadOnlyCollection _elementCount == 0; public int ArrayLength => Length; diff --git a/src/coreclr/tools/aot/ILCompiler.Compiler/IL/ILImporter.Scanner.cs b/src/coreclr/tools/aot/ILCompiler.Compiler/IL/ILImporter.Scanner.cs index 9dbe78a2d22..f6d640f7e26 100644 --- a/src/coreclr/tools/aot/ILCompiler.Compiler/IL/ILImporter.Scanner.cs +++ b/src/coreclr/tools/aot/ILCompiler.Compiler/IL/ILImporter.Scanner.cs @@ -866,7 +866,16 @@ private void ImportBranch(ILOpcode opcode, BasicBlock target, BasicBlock fallthr && ConstructedEETypeNode.CreationAllowed(typeEqualityCheckType) && !typeEqualityCheckType.ConvertToCanonForm(CanonicalFormKind.Specific).IsCanonicalSubtype(CanonicalFormKind.Any)) { - condition = _factory.MaximallyConstructableType(typeEqualityCheckType); + // If the type could generate metadata, we set the condition to the presence of the metadata. + // This covers situations where the typeof is compared against metadata-only types. + // Note this assumes a constructed MethodTable always implies having metadata. + // This will likely remain true because anyone can call Object.GetType on a constructed type. + // If the type cannot generate metadata, we only condition on the MethodTable itself. + if (!_factory.MetadataManager.IsReflectionBlocked(typeEqualityCheckType) + && typeEqualityCheckType.GetTypeDefinition() is MetadataType typeEqualityCheckMetadataType) + condition = _factory.TypeMetadata(typeEqualityCheckMetadataType); + else + condition = _factory.MaximallyConstructableType(typeEqualityCheckType); } } diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/Target_LoongArch64/ImportThunk.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/Target_LoongArch64/ImportThunk.cs index f729ca75771..4a3d47000a1 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/Target_LoongArch64/ImportThunk.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/Target_LoongArch64/ImportThunk.cs @@ -23,6 +23,7 @@ protected override void EmitCode(NodeFactory factory, ref LoongArch64Emitter ins case Kind.DelayLoadHelper: case Kind.VirtualStubDispatch: + case Kind.DelayLoadHelperWithExistingIndirectionCell: { // T8 contains indirection cell // Do nothing T8=R20 contains our first param diff --git a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs index cecfbe0e5d5..eebbbaceb7c 100644 --- a/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs +++ b/src/coreclr/tools/aot/ILCompiler.ReadyToRun/JitInterface/CorInfoImpl.ReadyToRun.cs @@ -1238,10 +1238,6 @@ private ISymbolNode GetHelperFtnUncached(CorInfoHelpFunc ftnNum) id = ReadyToRunHelper.PInvokeEnd; break; - case CorInfoHelpFunc.CORINFO_HELP_BBT_FCN_ENTER: - id = ReadyToRunHelper.LogMethodEnter; - break; - case CorInfoHelpFunc.CORINFO_HELP_STACK_PROBE: id = ReadyToRunHelper.StackProbe; break; diff --git a/src/coreclr/tools/aot/ILCompiler.Trimming.Tests/TestCases/TestSuites.cs b/src/coreclr/tools/aot/ILCompiler.Trimming.Tests/TestCases/TestSuites.cs index d4156edab60..1adbd655afa 100644 --- a/src/coreclr/tools/aot/ILCompiler.Trimming.Tests/TestCases/TestSuites.cs +++ b/src/coreclr/tools/aot/ILCompiler.Trimming.Tests/TestCases/TestSuites.cs @@ -74,6 +74,7 @@ public void Reflection (string t) case "ParametersUsedViaReflection": case "UnsafeAccessor": case "TypeUsedViaReflection": + case "RunClassConstructor": Run (t); break; default: diff --git a/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/Platform.cs b/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/Platform.cs index a2c1a1e06ad..f398474bb45 100644 --- a/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/Platform.cs +++ b/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/Platform.cs @@ -247,11 +247,17 @@ public static class RuntimeFeature public const string ByRefLikeGenerics = nameof(ByRefLikeGenerics); public const string UnmanagedSignatureCallingConvention = nameof(UnmanagedSignatureCallingConvention); public const string VirtualStaticsInInterfaces = nameof(VirtualStaticsInInterfaces); + public const string CovariantReturnsOfClasses = "CovariantReturnsOfClasses"; } internal sealed class IntrinsicAttribute : Attribute { } + + public sealed partial class PreserveBaseOverridesAttribute : System.Attribute + { + public PreserveBaseOverridesAttribute() { } + } } namespace System.Runtime.Intrinsics diff --git a/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/VirtualFunctionOverride.cs b/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/VirtualFunctionOverride.cs index 8440dfc3cd0..76b16f3ca46 100644 --- a/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/VirtualFunctionOverride.cs +++ b/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/CoreTestAssembly/VirtualFunctionOverride.cs @@ -60,4 +60,44 @@ unsafe class FunctionPointerOverloadDerived : FunctionPointerOverloadBase public override Type Method(delegate* unmanaged[Stdcall, SuppressGCTransition] p) => null; public override Type Method(delegate* p) => null; } + + class BaseCovariant + { + public virtual BaseCovariant FromType() + { + return new BaseCovariant(); + } + } + + class ImplCovariant : BaseCovariant + { + public override ImplCovariant FromType() + { + return new ImplCovariant(); + } + } + + class SubImplCovariant : ImplCovariant + { + public override SubImplCovariant FromType() + { + return new SubImplCovariant(); + } + } + + class SubImplCovariant2 : ImplCovariant + { + public override ImplCovariant FromType() + { + return new ImplCovariant(); + } + } + + class SubSubImplCovariant : SubImplCovariant2 + { + public override SubSubImplCovariant FromType() + { + return new SubSubImplCovariant(); + } + } } diff --git a/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/ILTestAssembly/ILTestAssembly.ilproj b/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/ILTestAssembly/ILTestAssembly.ilproj index 22c49cc0676..9cf5774a8a5 100644 --- a/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/ILTestAssembly/ILTestAssembly.ilproj +++ b/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/ILTestAssembly/ILTestAssembly.ilproj @@ -19,6 +19,7 @@ + diff --git a/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/ILTestAssembly/PreserveBaseOverridesAttibuteTesting.il b/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/ILTestAssembly/PreserveBaseOverridesAttibuteTesting.il new file mode 100644 index 00000000000..54bc08c4908 --- /dev/null +++ b/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/ILTestAssembly/PreserveBaseOverridesAttibuteTesting.il @@ -0,0 +1,1275 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +// This test validates the behavior in the presence/absence of the PreserveBaseOverridesAttribute. +// Each test scenario will have 3 layers of type inheritance (T1,T2,T3), and we test the following scenarios: +// +// Scenario A: Attribute placed T1's MethodDecl (attribute treated as NOP - only applicable to MethodImpls) +// ============================================================================== +// Scenario A.1: T2 explicitly overrides T1's, T3 explicitly overrides T1's MethodDecl +// Scenario A.2: T2 explicitly overrides T1's, T3 explicitly overrides T2's MethodImpl +// Scenario A.3: T2 explicitly overrides T1's, T3 implicitly overrides T1's MethodDecl +// Scenario A.4: T2 explicitly overrides T1's, T3 implicitly overrides T2's MethodImpl +// Scenario A.5: T2 implicitly overrides T1's, T3 explicitly overrides T1's method +// Scenario A.6: T2 implicitly overrides T1's, T3 explicitly overrides T2's method +// Scenario A.7: T2 implicitly overrides T1's, T3 implicitly overrides T1/T2's method +// +// SCENARIO B: T2 has MethodImpl that overrides T1's MethodDecl, WITHOUT any attribute +// ============================================================================== +// Scenario B.1: T3 explicitly overrides T1's MethodDecl +// Scenario B.2: T3 explicitly overrides T2's MethodImpl +// Scenario B.3: T3 implicitly overrides T1's MethodDecl +// Scenario B.4: T3 implicitly overrides T2's MethodImpl +// +// SCENARIO C: T2 has MethodImpl that overrides T1's MethodDecl, WITH the attribute +// ============================================================================== +// Scenario C.1: T3 explicitly overrides T1's MethodDecl +// Scenario C.2: T3 explicitly overrides T2's MethodImpl +// Scenario C.3: T3 implicitly overrides T1's MethodDecl +// Scenario C.4: T3 implicitly overrides T2's MethodImpl +// +// SCENARIO D: T2 implicitly overrides T1's method, WITH the attribute (Attribute treated as NOP) +// ============================================================================== +// Scenario D.1: T3 explicitly overrides T1's method +// Scenario D.2: T3 explicitly overrides T2's method +// Scenario D.3: T3 implicitly overrides T1/T2's method +// +// SCENARIO E: T2 implicitly overrides T1's method, WITHOUT the attribute +// ============================================================================== +// Scenario E.1: T3 explicitly overrides T1's method +// Scenario E.2: T3 explicitly overrides T2's method +// Scenario E.3: T3 implicitly overrides T1/T2's method +// + +// Scenario A +.namespace A +{ + .class public auto ansi beforefieldinit T1 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + + .method public hidebysig newslot virtual instance string Func1() + { + .custom instance void [CoreTestAssembly]System.Runtime.CompilerServices.PreserveBaseOverridesAttribute::.ctor() = (01 00 00 00) + ldstr "T1" + ret + } + } + .class public auto ansi beforefieldinit T2Exp extends A.T1 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig newslot virtual instance string Func2() + { + .override method instance string class A.T1::Func1() + ldstr "T2" + ret + } + } + .class public auto ansi beforefieldinit T2Imp extends A.T1 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig virtual instance string Func1() + { + ldstr "T2" + ret + } + } + + // Scenario A.1: T2 explicitly overrides T1's, T3 explicitly overrides T1's MethodDecl + .class public auto ansi beforefieldinit T3_1 extends A.T2Exp + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig newslot virtual instance string Func3() + { + .override method instance string class A.T1::Func1() + ldstr "T3" + ret + } + } + // Scenario A.2: T2 explicitly overrides T1's, T3 explicitly overrides T2's MethodImpl + .class public auto ansi beforefieldinit T3_2 extends A.T2Exp + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig newslot virtual instance string Func3() + { + .override method instance string class A.T2Exp::Func2() + ldstr "T3" + ret + } + } + + // Scenario A.3: T2 explicitly overrides T1's, T3 implicitly overrides T1's MethodDecl + .class public auto ansi beforefieldinit T3_3 extends A.T2Exp + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig virtual instance string Func1() + { + ldstr "T3" + ret + } + } + + // Scenario A.4: T2 explicitly overrides T1's, T3 implicitly overrides T2's MethodImpl + .class public auto ansi beforefieldinit T3_4 extends A.T2Exp + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig virtual instance string Func2() + { + ldstr "T3" + ret + } + } + + // Scenario A.5: T2 implicitly overrides T1's, T3 explicitly overrides T1's method + .class public auto ansi beforefieldinit T3_5 extends A.T2Imp + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig newslot virtual instance string Func3() + { + .override method instance string class A.T1::Func1() + ldstr "T3" + ret + } + } + + // Scenario A.6: T2 implicitly overrides T1's, T3 explicitly overrides T2's method + .class public auto ansi beforefieldinit T3_6 extends A.T2Imp + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig newslot virtual instance string Func3() + { + .override method instance string class A.T2Imp::Func1() + ldstr "T3" + ret + } + } + + // Scenario A.7: T2 implicitly overrides T1's, T3 implicitly overrides T1/T2's method + .class public auto ansi beforefieldinit T3_7 extends A.T2Imp + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig virtual instance string Func1() + { + ldstr "T3" + ret + } + } +} + +// Scenario B +.namespace B +{ + .class public auto ansi beforefieldinit T1 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig newslot virtual instance string Func1() + { + ldstr "T1" + ret + } + } + .class public auto ansi beforefieldinit T2 extends B.T1 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig newslot virtual instance string Func2() + { + .override method instance string class B.T1::Func1() + ldstr "T2" + ret + } + } + + // Scenario B.1: T3 explicitly overrides T1's MethodDecl + .class public auto ansi beforefieldinit T3_1 extends B.T2 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig newslot virtual instance string Func3() + { + .override method instance string class B.T1::Func1() + ldstr "T3" + ret + } + } + + // Scenario B.2: T3 explicitly overrides T2's MethodImpl + .class public auto ansi beforefieldinit T3_2 extends B.T2 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig newslot virtual instance string Func3() + { + .override method instance string class B.T2::Func2() + ldstr "T3" + ret + } + } + + // Scenario B.3: T3 implicitly overrides T1's MethodDecl + .class public auto ansi beforefieldinit T3_3 extends B.T2 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig virtual instance string Func1() + { + ldstr "T3" + ret + } + } + + // Scenario B.4: T3 implicitly overrides T2's MethodImpl + .class public auto ansi beforefieldinit T3_4 extends B.T2 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig virtual instance string Func2() + { + ldstr "T3" + ret + } + } +} + +// Scenario C +.namespace C +{ + .class public auto ansi beforefieldinit T1 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig newslot virtual instance string Func1() + { + ldstr "T1" + ret + } + } + .class public auto ansi beforefieldinit T2 extends C.T1 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig newslot virtual instance string Func2() + { + .custom instance void [CoreTestAssembly]System.Runtime.CompilerServices.PreserveBaseOverridesAttribute::.ctor() = (01 00 00 00) + .override method instance string class C.T1::Func1() + ldstr "T2" + ret + } + } + + // Scenario C.1: T3 explicitly overrides T1's MethodDecl + .class public auto ansi beforefieldinit T3_1 extends C.T2 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig newslot virtual instance string Func3() + { + .override method instance string class C.T1::Func1() + ldstr "T3" + ret + } + } + + // Scenario C.2: T3 explicitly overrides T2's MethodImpl + .class public auto ansi beforefieldinit T3_2 extends C.T2 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig newslot virtual instance string Func3() + { + .override method instance string class C.T2::Func2() + ldstr "T3" + ret + } + } + + // Scenario C.3: T3 implicitly overrides T1's MethodDecl + .class public auto ansi beforefieldinit T3_3 extends C.T2 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig virtual instance string Func1() + { + ldstr "T3" + ret + } + } + + // Scenario C.4: T3 implicitly overrides T2's MethodImpl + .class public auto ansi beforefieldinit T3_4 extends C.T2 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig virtual instance string Func2() + { + ldstr "T3" + ret + } + } +} + +// Scenario D +.namespace D +{ + .class public auto ansi beforefieldinit T1 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig newslot virtual instance string Func1() + { + ldstr "T1" + ret + } + } + .class public auto ansi beforefieldinit T2 extends D.T1 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig virtual instance string Func1() + { + .custom instance void [CoreTestAssembly]System.Runtime.CompilerServices.PreserveBaseOverridesAttribute::.ctor() = (01 00 00 00) + ldstr "T2" + ret + } + } + + // Scenario D.1: T3 explicitly overrides T1's method + .class public auto ansi beforefieldinit T3_1 extends D.T2 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig newslot virtual instance string Func3() + { + .override method instance string class D.T1::Func1() + ldstr "T3" + ret + } + } + + // Scenario D.2: T3 explicitly overrides T2's method + .class public auto ansi beforefieldinit T3_2 extends D.T2 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig newslot virtual instance string Func3() + { + .override method instance string class D.T2::Func1() + ldstr "T3" + ret + } + } + + // Scenario D.3: T3 implicitly overrides T1/T2's method + .class public auto ansi beforefieldinit T3_3 extends D.T2 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig virtual instance string Func1() + { + ldstr "T3" + ret + } + } +} + +// Scenario E +.namespace E +{ + .class public auto ansi beforefieldinit T1 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig newslot virtual instance string Func1() + { + ldstr "T1" + ret + } + } + .class public auto ansi beforefieldinit T2 extends E.T1 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig virtual instance string Func1() + { + ldstr "T2" + ret + } + } + + // Scenario E.1: T3 explicitly overrides T1's method + .class public auto ansi beforefieldinit T3_1 extends E.T2 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig newslot virtual instance string Func3() + { + .override method instance string class E.T1::Func1() + ldstr "T3" + ret + } + } + + // Scenario E.2: T3 explicitly overrides T2's method + .class public auto ansi beforefieldinit T3_2 extends E.T2 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig newslot virtual instance string Func3() + { + .override method instance string class E.T2::Func1() + ldstr "T3" + ret + } + } + + // Scenario E.3: T3 implicitly overrides T1/T2's method + .class public auto ansi beforefieldinit T3_3 extends E.T2 + { + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret } + .method public hidebysig virtual instance string Func1() + { + ldstr "T3" + ret + } + } +} +/* +.class public auto ansi beforefieldinit CMain extends [mscorlib]System.Object +{ + .method private hidebysig static bool CheckResult (string expected,string actual) cil managed + { + // Method begins at RVA 0x217c + // Code size 45 (0x2d) + .maxstack 8 + + // Console.WriteLine("EXPECTED: " + expected); + IL_0000: ldstr " EXPECTED: " + IL_0005: ldarg.0 + IL_0006: call string [CoreTestAssembly]System.String::Concat(string, string) + IL_000b: call void [System.Console]System.Console::WriteLine(string) + // Console.WriteLine("ACTUAL : " + actual); + IL_0010: ldstr " ACTUAL : " + IL_0015: ldarg.1 + IL_0016: call string [CoreTestAssembly]System.String::Concat(string, string) + IL_001b: call void [System.Console]System.Console::WriteLine(string) + // Console.WriteLine(); + IL_0020: call void [System.Console]System.Console::WriteLine() + // return expected == actual; + IL_0025: ldarg.0 + IL_0026: ldarg.1 + IL_0027: call bool [CoreTestAssembly]System.String::op_Equality(string, string) + // (no C# code) + IL_002c: ret + } // end of method Program::CheckResult + + + // =================================================== + + .method private hidebysig static bool ScenarioA_Test1 () cil managed + { + ldstr "ScenarioA_Test1" + call void [System.Console]System.Console::WriteLine(string) + + ldstr "T3" + newobj instance void A.T3_1::.ctor() + callvirt instance string class A.T1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T2" + newobj instance void A.T3_1::.ctor() + callvirt instance string A.T2Exp::Func2() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void A.T3_1::.ctor() + callvirt instance string A.T3_1::Func3() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldc.i4.1 + ret + FAILED: + ldc.i4.0 + ret + } + + .method private hidebysig static bool ScenarioA_Test2 () cil managed + { + ldstr "ScenarioA_Test2" + call void [System.Console]System.Console::WriteLine(string) + + ldstr "T3" + newobj instance void A.T3_2::.ctor() + callvirt instance string class A.T1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void A.T3_2::.ctor() + callvirt instance string A.T2Exp::Func2() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void A.T3_2::.ctor() + callvirt instance string A.T3_2::Func3() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldc.i4.1 + ret + FAILED: + ldc.i4.0 + ret + } + + .method private hidebysig static bool ScenarioA_Test3 () cil managed + { + ldstr "ScenarioA_Test3" + call void [System.Console]System.Console::WriteLine(string) + + ldstr "T3" + newobj instance void A.T3_3::.ctor() + callvirt instance string class A.T1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T2" + newobj instance void A.T3_3::.ctor() + callvirt instance string A.T2Exp::Func2() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void A.T3_3::.ctor() + callvirt instance string A.T3_3::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldc.i4.1 + ret + FAILED: + ldc.i4.0 + ret + } + + .method private hidebysig static bool ScenarioA_Test4 () cil managed + { + ldstr "ScenarioA_Test4" + call void [System.Console]System.Console::WriteLine(string) + + ldstr "T3" + newobj instance void A.T3_4::.ctor() + callvirt instance string class A.T1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void A.T3_4::.ctor() + callvirt instance string A.T2Exp::Func2() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void A.T3_4::.ctor() + callvirt instance string A.T3_4::Func2() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldc.i4.1 + ret + FAILED: + ldc.i4.0 + ret + } + + .method private hidebysig static bool ScenarioA_Test5 () cil managed + { + ldstr "ScenarioA_Test5" + call void [System.Console]System.Console::WriteLine(string) + + ldstr "T3" + newobj instance void A.T3_5::.ctor() + callvirt instance string class A.T1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void A.T3_5::.ctor() + callvirt instance string A.T2Imp::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void A.T3_5::.ctor() + callvirt instance string A.T3_5::Func3() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldc.i4.1 + ret + FAILED: + ldc.i4.0 + ret + } + + .method private hidebysig static bool ScenarioA_Test6 () cil managed + { + ldstr "ScenarioA_Test6" + call void [System.Console]System.Console::WriteLine(string) + + ldstr "T3" + newobj instance void A.T3_6::.ctor() + callvirt instance string class A.T1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void A.T3_6::.ctor() + callvirt instance string A.T2Imp::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void A.T3_6::.ctor() + callvirt instance string A.T3_6::Func3() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldc.i4.1 + ret + FAILED: + ldc.i4.0 + ret + } + + .method private hidebysig static bool ScenarioA_Test7 () cil managed + { + ldstr "ScenarioA_Test7" + call void [System.Console]System.Console::WriteLine(string) + + ldstr "T3" + newobj instance void A.T3_7::.ctor() + callvirt instance string class A.T1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void A.T3_7::.ctor() + callvirt instance string A.T2Imp::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void A.T3_7::.ctor() + callvirt instance string A.T3_7::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldc.i4.1 + ret + FAILED: + ldc.i4.0 + ret + } + + // =================================================== + + .method private hidebysig static bool ScenarioB_Test1 () cil managed + { + ldstr "ScenarioB_Test1" + call void [System.Console]System.Console::WriteLine(string) + + ldstr "T3" + newobj instance void B.T3_1::.ctor() + callvirt instance string class B.T1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T2" + newobj instance void B.T3_1::.ctor() + callvirt instance string B.T2::Func2() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void B.T3_1::.ctor() + callvirt instance string B.T3_1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldc.i4.1 + ret + FAILED: + ldc.i4.0 + ret + } + + .method private hidebysig static bool ScenarioB_Test2 () cil managed + { + ldstr "ScenarioB_Test2" + call void [System.Console]System.Console::WriteLine(string) + + ldstr "T3" + newobj instance void B.T3_2::.ctor() + callvirt instance string class B.T1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void B.T3_2::.ctor() + callvirt instance string B.T2::Func2() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void B.T3_2::.ctor() + callvirt instance string B.T3_2::Func2() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldc.i4.1 + ret + FAILED: + ldc.i4.0 + ret + } + + .method private hidebysig static bool ScenarioB_Test3 () cil managed + { + ldstr "ScenarioB_Test3" + call void [System.Console]System.Console::WriteLine(string) + + ldstr "T3" + newobj instance void B.T3_3::.ctor() + callvirt instance string class B.T1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T2" + newobj instance void B.T3_3::.ctor() + callvirt instance string B.T2::Func2() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void B.T3_3::.ctor() + callvirt instance string B.T3_3::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldc.i4.1 + ret + FAILED: + ldc.i4.0 + ret + } + + .method private hidebysig static bool ScenarioB_Test4 () cil managed + { + ldstr "ScenarioB_Test4" + call void [System.Console]System.Console::WriteLine(string) + + ldstr "T3" + newobj instance void B.T3_4::.ctor() + callvirt instance string class B.T1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void B.T3_4::.ctor() + callvirt instance string B.T2::Func2() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void B.T3_4::.ctor() + callvirt instance string B.T3_4::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void B.T3_4::.ctor() + callvirt instance string B.T3_4::Func2() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldc.i4.1 + ret + FAILED: + ldc.i4.0 + ret + } + + // =================================================== + + .method private hidebysig static bool ScenarioC_Test1 () cil managed + { + ldstr "ScenarioC_Test1" + call void [System.Console]System.Console::WriteLine(string) + + ldstr "T3" + newobj instance void C.T3_1::.ctor() + callvirt instance string class C.T1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void C.T3_1::.ctor() + callvirt instance string C.T2::Func2() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void C.T3_1::.ctor() + callvirt instance string C.T3_1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldc.i4.1 + ret + FAILED: + ldc.i4.0 + ret + } + + .method private hidebysig static bool ScenarioC_Test2 () cil managed + { + ldstr "ScenarioC_Test2" + call void [System.Console]System.Console::WriteLine(string) + + ldstr "T3" + newobj instance void C.T3_2::.ctor() + callvirt instance string class C.T1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void C.T3_2::.ctor() + callvirt instance string C.T2::Func2() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void C.T3_2::.ctor() + callvirt instance string C.T3_2::Func2() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldc.i4.1 + ret + FAILED: + ldc.i4.0 + ret + } + + .method private hidebysig static bool ScenarioC_Test3 () cil managed + { + ldstr "ScenarioC_Test3" + call void [System.Console]System.Console::WriteLine(string) + + ldstr "T3" + newobj instance void C.T3_3::.ctor() + callvirt instance string class C.T1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T2" + newobj instance void C.T3_3::.ctor() + callvirt instance string C.T2::Func2() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void C.T3_3::.ctor() + callvirt instance string C.T3_3::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldc.i4.1 + ret + FAILED: + ldc.i4.0 + ret + } + + .method private hidebysig static bool ScenarioC_Test4 () cil managed + { + ldstr "ScenarioC_Test4" + call void [System.Console]System.Console::WriteLine(string) + + ldstr "T3" + newobj instance void C.T3_4::.ctor() + callvirt instance string class C.T1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void C.T3_4::.ctor() + callvirt instance string C.T2::Func2() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void C.T3_4::.ctor() + callvirt instance string C.T3_4::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void C.T3_4::.ctor() + callvirt instance string C.T3_4::Func2() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldc.i4.1 + ret + FAILED: + ldc.i4.0 + ret + } + + // =================================================== + + .method private hidebysig static bool ScenarioD_Test1 () cil managed + { + ldstr "ScenarioD_Test1" + call void [System.Console]System.Console::WriteLine(string) + + ldstr "T3" + newobj instance void D.T3_1::.ctor() + callvirt instance string class D.T1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void D.T3_1::.ctor() + callvirt instance string D.T2::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void D.T3_1::.ctor() + callvirt instance string D.T3_1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void D.T3_1::.ctor() + callvirt instance string D.T3_1::Func3() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldc.i4.1 + ret + FAILED: + ldc.i4.0 + ret + } + + .method private hidebysig static bool ScenarioD_Test2 () cil managed + { + ldstr "ScenarioD_Test2" + call void [System.Console]System.Console::WriteLine(string) + + ldstr "T3" + newobj instance void D.T3_2::.ctor() + callvirt instance string class D.T1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void D.T3_2::.ctor() + callvirt instance string D.T2::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void D.T3_2::.ctor() + callvirt instance string D.T3_2::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void D.T3_1::.ctor() + callvirt instance string D.T3_1::Func3() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldc.i4.1 + ret + FAILED: + ldc.i4.0 + ret + } + + .method private hidebysig static bool ScenarioD_Test3 () cil managed + { + ldstr "ScenarioD_Test3" + call void [System.Console]System.Console::WriteLine(string) + + ldstr "T3" + newobj instance void D.T3_3::.ctor() + callvirt instance string class D.T1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void D.T3_3::.ctor() + callvirt instance string D.T2::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void D.T3_3::.ctor() + callvirt instance string D.T3_3::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldc.i4.1 + ret + FAILED: + ldc.i4.0 + ret + } + + // =================================================== + + .method private hidebysig static bool ScenarioE_Test1 () cil managed + { + ldstr "ScenarioE_Test1" + call void [System.Console]System.Console::WriteLine(string) + + ldstr "T3" + newobj instance void E.T3_1::.ctor() + callvirt instance string class E.T1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void E.T3_1::.ctor() + callvirt instance string E.T2::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void E.T3_1::.ctor() + callvirt instance string E.T3_1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void E.T3_1::.ctor() + callvirt instance string E.T3_1::Func3() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldc.i4.1 + ret + FAILED: + ldc.i4.0 + ret + } + + .method private hidebysig static bool ScenarioE_Test2 () cil managed + { + ldstr "ScenarioE_Test2" + call void [System.Console]System.Console::WriteLine(string) + + ldstr "T3" + newobj instance void E.T3_2::.ctor() + callvirt instance string class E.T1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void E.T3_2::.ctor() + callvirt instance string E.T2::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void E.T3_2::.ctor() + callvirt instance string E.T3_2::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void E.T3_1::.ctor() + callvirt instance string E.T3_1::Func3() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldc.i4.1 + ret + FAILED: + ldc.i4.0 + ret + } + + .method private hidebysig static bool ScenarioE_Test3 () cil managed + { + ldstr "ScenarioE_Test3" + call void [System.Console]System.Console::WriteLine(string) + + ldstr "T3" + newobj instance void E.T3_3::.ctor() + callvirt instance string class E.T1::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void E.T3_3::.ctor() + callvirt instance string E.T2::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldstr "T3" + newobj instance void E.T3_3::.ctor() + callvirt instance string E.T3_3::Func1() + call bool CMain::CheckResult(string, string) + brfalse.s FAILED + + ldc.i4.1 + ret + FAILED: + ldc.i4.0 + ret + } + + .method public hidebysig static int32 Main() cil managed + { + .entrypoint + .maxstack 2 + .locals init ( bool result ) + + ldc.i4.1 + stloc.0 + + // ==================================================== // + + ldloc.0 + call bool CMain::ScenarioA_Test1() + and + stloc.0 + + ldloc.0 + call bool CMain::ScenarioA_Test2() + and + stloc.0 + + ldloc.0 + call bool CMain::ScenarioA_Test3() + and + stloc.0 + + ldloc.0 + call bool CMain::ScenarioA_Test4() + and + stloc.0 + + ldloc.0 + call bool CMain::ScenarioA_Test5() + and + stloc.0 + + ldloc.0 + call bool CMain::ScenarioA_Test6() + and + stloc.0 + + ldloc.0 + call bool CMain::ScenarioA_Test7() + and + stloc.0 + + // ==================================================== // + + ldloc.0 + call bool CMain::ScenarioB_Test1() + and + stloc.0 + + ldloc.0 + call bool CMain::ScenarioB_Test2() + and + stloc.0 + + ldloc.0 + call bool CMain::ScenarioB_Test3() + and + stloc.0 + + ldloc.0 + call bool CMain::ScenarioB_Test4() + and + stloc.0 + + // ==================================================== // + + ldloc.0 + call bool CMain::ScenarioC_Test1() + and + stloc.0 + + ldloc.0 + call bool CMain::ScenarioC_Test2() + and + stloc.0 + + ldloc.0 + call bool CMain::ScenarioC_Test3() + and + stloc.0 + + ldloc.0 + call bool CMain::ScenarioC_Test4() + and + stloc.0 + + // ==================================================== // + + ldloc.0 + call bool CMain::ScenarioD_Test1() + and + stloc.0 + + ldloc.0 + call bool CMain::ScenarioD_Test2() + and + stloc.0 + + ldloc.0 + call bool CMain::ScenarioD_Test3() + and + stloc.0 + + // ==================================================== // + + ldloc.0 + call bool CMain::ScenarioE_Test1() + and + stloc.0 + + ldloc.0 + call bool CMain::ScenarioE_Test2() + and + stloc.0 + + ldloc.0 + call bool CMain::ScenarioE_Test3() + and + stloc.0 + + // ==================================================== // + + DONE: + ldloc.0 + brtrue.s PASS + + ldstr "Test FAILED" + call void [System.Console]System.Console::WriteLine(string) + ldc.i4.s 101 + ret + + PASS: + ldstr "Test PASSED" + call void [System.Console]System.Console::WriteLine(string) + ldc.i4.s 100 + ret + + ldc.i4.s 100 + ret + } + + .method public hidebysig specialname rtspecialname instance void .ctor() cil managed + { + .maxstack 8 + ldarg.0 + call instance void [mscorlib]System.Object::.ctor() + ret + } +} +*/ \ No newline at end of file diff --git a/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/VirtualFunctionOverrideTests.cs b/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/VirtualFunctionOverrideTests.cs index d2f9d9576c6..25adae65bda 100644 --- a/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/VirtualFunctionOverrideTests.cs +++ b/src/coreclr/tools/aot/ILCompiler.TypeSystem.Tests/VirtualFunctionOverrideTests.cs @@ -3,10 +3,14 @@ using System; using System.Collections.Generic; +using System.Diagnostics; using System.Linq; +using System.Reflection; +using Internal.IL; using Internal.TypeSystem; - +using Internal.TypeSystem.Ecma; using Xunit; +using Xunit.Abstractions; namespace TypeSystemTests @@ -17,9 +21,11 @@ public class VirtualFunctionOverrideTests private ModuleDesc _testModule; private DefType _stringType; private DefType _voidType; + private ITestOutputHelper _logger; - public VirtualFunctionOverrideTests() + public VirtualFunctionOverrideTests(ITestOutputHelper logger) { + _logger = logger; _context = new TestTypeSystemContext(TargetArchitecture.X64); var systemModule = _context.CreateModuleForSimpleName("CoreTestAssembly"); _context.SetSystemModule(systemModule); @@ -289,5 +295,179 @@ public void TestFunctionPointerOverloads() Assert.Equal(expectedMethods[0].Signature[0], expectedMethods[1].Signature[0]); Assert.NotEqual(expectedMethods[0].Signature[0], expectedMethods[3].Signature[0]); } + + [Theory] + // ScenarioA_Test1 + [InlineData("ScenarioA_Test1_1", "T3", "A.T3_1", "A.T1", "Func1")] + [InlineData("ScenarioA_Test1_2", "T2", "A.T3_1", "A.T2Exp", "Func2")] + [InlineData("ScenarioA_Test1_3", "T3", "A.T3_1", "A.T3_1", "Func3")] + + // ScenarioA_Test2 + [InlineData("ScenarioA_Test2_1", "T3", "A.T3_2", "A.T1", "Func1")] + [InlineData("ScenarioA_Test2_2", "T3", "A.T3_2", "A.T2Exp", "Func2")] + [InlineData("ScenarioA_Test2_3", "T3", "A.T3_2", "A.T3_2", "Func3")] + + // ScenarioA_Test3 + [InlineData("ScenarioA_Test3_1", "T3", "A.T3_3", "A.T1", "Func1")] + [InlineData("ScenarioA_Test3_2", "T2", "A.T3_3", "A.T2Exp", "Func2")] + [InlineData("ScenarioA_Test3_3", "T3", "A.T3_3", "A.T3_3", "Func1")] + + // ScenarioA_Test4 + [InlineData("ScenarioA_Test4_1", "T3", "A.T3_4", "A.T1", "Func1")] + [InlineData("ScenarioA_Test4_2", "T3", "A.T3_4", "A.T2Exp", "Func2")] + [InlineData("ScenarioA_Test4_3", "T3", "A.T3_4", "A.T3_4", "Func2")] + + // ScenarioA_Test5 + [InlineData("ScenarioA_Test5_1", "T3", "A.T3_5", "A.T1", "Func1")] + [InlineData("ScenarioA_Test5_2", "T3", "A.T3_5", "A.T2Imp", "Func1")] + [InlineData("ScenarioA_Test5_3", "T3", "A.T3_5", "A.T3_5", "Func3")] + + // ScenarioA_Test6 + [InlineData("ScenarioA_Test6_1", "T3", "A.T3_6", "A.T1", "Func1")] + [InlineData("ScenarioA_Test6_2", "T3", "A.T3_6", "A.T2Imp", "Func1")] + [InlineData("ScenarioA_Test6_3", "T3", "A.T3_6", "A.T3_6", "Func3")] + + // ScenarioA_Test7 + [InlineData("ScenarioA_Test7_1", "T3", "A.T3_7", "A.T1", "Func1")] + [InlineData("ScenarioA_Test7_2", "T3", "A.T3_7", "A.T2Imp", "Func1")] + [InlineData("ScenarioA_Test7_3", "T3", "A.T3_7", "A.T3_7", "Func1")] + + // ScenarioB_Test1 + [InlineData("ScenarioB_Test_1_1", "T3", "B.T3_1", "B.T1", "Func1")] + [InlineData("ScenarioB_Test_1_2", "T2", "B.T3_1", "B.T2", "Func2")] + [InlineData("ScenarioB_Test_1_3", "T3", "B.T3_1", "B.T3_1", "Func3")] // Change from IL + + // ScenarioB_Test2 + [InlineData("ScenarioB_Test_2_1", "T3", "B.T3_2", "B.T1", "Func1")] + [InlineData("ScenarioB_Test_2_2", "T3", "B.T3_2", "B.T2", "Func2")] + [InlineData("ScenarioB_Test_2_3", "T3", "B.T3_2", "B.T3_2", "Func3")] // Change from IL + + // ScenarioB_Test3 + [InlineData("ScenarioB_Test_3_1", "T3", "B.T3_3", "B.T1", "Func1")] + [InlineData("ScenarioB_Test_3_2", "T2", "B.T3_3", "B.T2", "Func2")] + [InlineData("ScenarioB_Test_3_3", "T3", "B.T3_3", "B.T3_3", "Func1")] + + // ScenarioB_Test4 + [InlineData("ScenarioB_Test_4_1", "T3", "B.T3_4", "B.T1", "Func1")] + [InlineData("ScenarioB_Test_4_2", "T3", "B.T3_4", "B.T2", "Func2")] + [InlineData("ScenarioB_Test_4_3", "T3", "B.T3_4", "B.T3_4", "Func2")] // Change from IL + + // ScenarioC_Test1 + [InlineData("ScenarioC_Test_1_1", "T3", "C.T3_1", "C.T1", "Func1")] + [InlineData("ScenarioC_Test_1_2", "T3", "C.T3_1", "C.T2", "Func2")] + [InlineData("ScenarioC_Test_1_3", "T3", "C.T3_1", "C.T3_1", "Func3")] + + // ScenarioC_Test2 + [InlineData("ScenarioC_Test_2_1", "T3", "C.T3_2", "C.T1", "Func1")] + [InlineData("ScenarioC_Test_2_2", "T3", "C.T3_2", "C.T2", "Func2")] + [InlineData("ScenarioC_Test_2_3", "T3", "C.T3_2", "C.T3_2", "Func3")] // Change from IL + + // ScenarioC_Test3 + [InlineData("ScenarioC_Test_3_1", "T3", "C.T3_3", "C.T1", "Func1")] + [InlineData("ScenarioC_Test_3_2", "T2", "C.T3_3", "C.T2", "Func2")] + [InlineData("ScenarioC_Test_3_3", "T3", "C.T3_3", "C.T3_3", "Func1")] + + // ScenarioC_Test4 + [InlineData("ScenarioC_Test_4_1", "T3", "C.T3_4", "C.T1", "Func1")] + [InlineData("ScenarioC_Test_4_2", "T3", "C.T3_4", "C.T2", "Func2")] + [InlineData("ScenarioC_Test_4_3", "T3", "C.T3_4", "C.T3_4", "Func2")] // Change from IL + [InlineData("ScenarioC_Test_4_4", "T3", "C.T3_4", "C.T3_4", "Func2")] + + // ScenarioD_Test1 + [InlineData("ScenarioD_Test_1_1", "T3", "D.T3_1", "D.T1", "Func1")] + [InlineData("ScenarioD_Test_1_2", "T3", "D.T3_1", "D.T2", "Func1")] + [InlineData("ScenarioD_Test_1_3", "T3", "D.T3_1", "D.T3_1", "Func3")] // Change from IL + [InlineData("ScenarioD_Test_1_4", "T3", "D.T3_1", "D.T3_1", "Func3")] + + // ScenarioD_Test2 + [InlineData("ScenarioD_Test_2_1", "T3", "D.T3_2", "D.T1", "Func1")] + [InlineData("ScenarioD_Test_2_2", "T3", "D.T3_2", "D.T2", "Func1")] + [InlineData("ScenarioD_Test_2_3", "T3", "D.T3_2", "D.T3_2", "Func3")] // Change from IL + // DUPLICATE?!?! [InlineData("T3", "D.T3_1", "D.T3_1", "Func3")] + + // ScenarioD_Test3 + [InlineData("ScenarioD_Test_3_1", "T3", "D.T3_3", "D.T1", "Func1")] + [InlineData("ScenarioD_Test_3_2", "T3", "D.T3_3", "D.T2", "Func1")] + [InlineData("ScenarioD_Test_3_3", "T3", "D.T3_3", "D.T3_3", "Func1")] + + // ScenarioE_Test1 + [InlineData("ScenarioE_Test_1_1", "T3", "E.T3_1", "E.T1", "Func1")] + [InlineData("ScenarioE_Test_1_2", "T3", "E.T3_1", "E.T2", "Func1")] + [InlineData("ScenarioE_Test_1_3", "T3", "E.T3_1", "E.T3_1", "Func3")] + + // ScenarioE_Test2 + [InlineData("ScenarioE_Test_2_1", "T3", "E.T3_2", "E.T1", "Func1")] + [InlineData("ScenarioE_Test_2_2", "T3", "E.T3_2", "E.T2", "Func1")] + [InlineData("ScenarioE_Test_2_3", "T3", "E.T3_2", "E.T3_2", "Func3")] + // DUPLICATE?!?!? [InlineData("T3", "E.T3_1", "E.T3_1", "Func3")] + + // ScenarioE_Test3 + [InlineData("ScenarioE_Test_3_1", "T3", "E.T3_3", "E.T1", "Func1")] + [InlineData("ScenarioE_Test_3_2", "T3", "E.T3_3", "E.T2", "Func1")] + [InlineData("ScenarioE_Test_3_3", "T3", "E.T3_3", "E.T3_3", "Func1")] + public void TestPreserveBaseOverridesBehavior(string exactScenarioName, string stringToExpect, string typeToConstruct, string typeOfMethodToCallOn, string methodName) + { + this._logger.WriteLine(exactScenarioName); + var ilModule = _context.GetModuleForSimpleName("ILTestAssembly"); + (string typeToConstructNamespace, string typeToConstructTypeName) = SplitIntoNameAndNamespace(typeToConstruct); + var constructedType = ilModule.GetType(typeToConstructNamespace, typeToConstructTypeName); + + (string typeToCallNamespace, string typeToCallTypeName) = SplitIntoNameAndNamespace(typeOfMethodToCallOn); + var typeToCall = ilModule.GetType(typeToCallNamespace, typeToCallTypeName); + + MethodDesc callMethod = typeToCall.GetMethod(methodName, null); + Assert.NotNull(callMethod); + + MethodDesc resolvedMethod = constructedType.FindVirtualFunctionTargetMethodOnObjectType(callMethod); + + var methodIL = Internal.IL.EcmaMethodIL.Create((EcmaMethod)resolvedMethod); + ILReader reader = new ILReader(methodIL.GetILBytes()); + Assert.Equal(ILOpcode.ldstr, reader.ReadILOpcode()); + + int userStringToken = reader.ReadILToken(); + string stringLoadedAsFirstILOpcodeInResolvedMethod = (string)methodIL.GetObject(userStringToken); + Assert.Equal(stringToExpect, stringLoadedAsFirstILOpcodeInResolvedMethod); + } + + + [Theory] + [InlineData("Base", "BaseCovariant")] + [InlineData("Impl", "ImplCovariant")] + [InlineData("SubImpl", "SubImplCovariant")] + [InlineData("SubImpl_OverrideViaNameSig", "SubImplCovariant2")] + [InlineData("SubImpl_OverrideViaNameSig_OverridenViaMethodImpl", "SubSubImplCovariant")] + public void TestSubImplCovariant(string exactScenarioName, string typeToConstruct) + { + this._logger.WriteLine(exactScenarioName); + + MetadataType derivedClass = _testModule.GetType("VirtualFunctionOverride", typeToConstruct); + MetadataType baseClass = derivedClass; + + while (baseClass != baseClass.Context.GetWellKnownType(WellKnownType.Object)) + { + this._logger.WriteLine("-----"); + this._logger.WriteLine(baseClass.ToString()); + MethodDesc callMethod = baseClass.GetMethod("FromType", null); + this._logger.WriteLine(callMethod.ToString()); + Assert.NotNull(callMethod); + + MethodDesc resolvedMethod = derivedClass.FindVirtualFunctionTargetMethodOnObjectType(callMethod); + this._logger.WriteLine(resolvedMethod.ToString()); + + Assert.Equal(typeToConstruct, ((EcmaType)((EcmaMethod)resolvedMethod).OwningType).Name); + + baseClass = (MetadataType)baseClass.BaseType; + } + } + + private static (string _namespace, string type) SplitIntoNameAndNamespace(string typeName) + { + int namespaceIndextypeName = typeName.LastIndexOf('.'); + Assert.True(namespaceIndextypeName > 0); + string typeNameNamespace = typeName.Substring(0, namespaceIndextypeName); + string typeNameTypeName = typeName.Substring(namespaceIndextypeName + 1); + Assert.True(typeNameTypeName.Length > 0); + return (typeNameNamespace, typeNameTypeName); + } } } diff --git a/src/coreclr/tools/aot/ILCompiler.TypeSystem/ILCompiler.TypeSystem.csproj b/src/coreclr/tools/aot/ILCompiler.TypeSystem/ILCompiler.TypeSystem.csproj index 92d6b7e836c..cafa4952376 100644 --- a/src/coreclr/tools/aot/ILCompiler.TypeSystem/ILCompiler.TypeSystem.csproj +++ b/src/coreclr/tools/aot/ILCompiler.TypeSystem/ILCompiler.TypeSystem.csproj @@ -30,7 +30,6 @@ - diff --git a/src/coreclr/tools/aot/ILCompiler/ILCompiler.csproj b/src/coreclr/tools/aot/ILCompiler/ILCompiler.csproj index 8ce209a7489..07f4e004984 100644 --- a/src/coreclr/tools/aot/ILCompiler/ILCompiler.csproj +++ b/src/coreclr/tools/aot/ILCompiler/ILCompiler.csproj @@ -15,14 +15,8 @@ true true true - true - - - - - > GetExtendedHelp(HelpContext _ Console.WriteLine("Use the '--' option to disambiguate between input files that have begin with -- and options. After a '--' option, all arguments are " + "considered to be input files. If no input files begin with '--' then this option is not necessary.\n"); - string[] ValidArchitectures = new string[] { "arm", "arm64", "x86", "x64", "riscv64" }; + string[] ValidArchitectures = new string[] { "arm", "arm64", "x86", "x64", "riscv64", "loongarch64" }; string[] ValidOS = new string[] { "windows", "linux", "freebsd", "osx", "maccatalyst", "ios", "iossimulator", "tvos", "tvossimulator" }; Console.WriteLine("Valid switches for {0} are: '{1}'. The default value is '{2}'\n", "--targetos", string.Join("', '", ValidOS), Helpers.GetTargetOS(null).ToString().ToLowerInvariant()); diff --git a/src/coreclr/tools/aot/ILCompiler/Program.cs b/src/coreclr/tools/aot/ILCompiler/Program.cs index 641a7d86498..587e89908ae 100644 --- a/src/coreclr/tools/aot/ILCompiler/Program.cs +++ b/src/coreclr/tools/aot/ILCompiler/Program.cs @@ -516,7 +516,7 @@ void RunScanner() interopStubManager = scanResults.GetInteropStubManager(interopStateManager, pinvokePolicy); - ilProvider = new SubstitutedILProvider(unsubstitutedILProvider, substitutionProvider, devirtualizationManager); + ilProvider = new SubstitutedILProvider(unsubstitutedILProvider, substitutionProvider, devirtualizationManager, metadataManager); // Use a more precise IL provider that uses whole program analysis for dead branch elimination builder.UseILProvider(ilProvider); diff --git a/src/coreclr/tools/aot/crossgen2/Crossgen2RootCommand.cs b/src/coreclr/tools/aot/crossgen2/Crossgen2RootCommand.cs index 5159f474f01..0f24eceeed0 100644 --- a/src/coreclr/tools/aot/crossgen2/Crossgen2RootCommand.cs +++ b/src/coreclr/tools/aot/crossgen2/Crossgen2RootCommand.cs @@ -294,7 +294,7 @@ public static IEnumerable> GetExtendedHelp(HelpContext _ Console.WriteLine(SR.DashDashHelp); Console.WriteLine(); - string[] ValidArchitectures = new string[] {"arm", "armel", "arm64", "x86", "x64", "riscv64"}; + string[] ValidArchitectures = new string[] {"arm", "armel", "arm64", "x86", "x64", "riscv64", "loongarch64"}; string[] ValidOS = new string[] {"windows", "linux", "osx"}; Console.WriteLine(String.Format(SR.SwitchWithDefaultHelp, "--targetos", String.Join("', '", ValidOS), Helpers.GetTargetOS(null).ToString().ToLowerInvariant())); diff --git a/src/coreclr/tools/aot/crossgen2/crossgen2_publish.csproj b/src/coreclr/tools/aot/crossgen2/crossgen2_publish.csproj index aebad93eae0..25bfcc096d9 100644 --- a/src/coreclr/tools/aot/crossgen2/crossgen2_publish.csproj +++ b/src/coreclr/tools/aot/crossgen2/crossgen2_publish.csproj @@ -37,6 +37,7 @@ + true $(CoreCLRILCompilerDir) $(CoreCLRCrossILCompilerDir) $(ROOTFS_DIR) diff --git a/src/coreclr/tools/aot/jitinterface/jitinterface_generated.h b/src/coreclr/tools/aot/jitinterface/jitinterface_generated.h index f1ddd133406..0e9bde0b4de 100644 --- a/src/coreclr/tools/aot/jitinterface/jitinterface_generated.h +++ b/src/coreclr/tools/aot/jitinterface/jitinterface_generated.h @@ -52,9 +52,7 @@ struct JitInterfaceCallbacks size_t (* printClassName)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_CLASS_HANDLE cls, char* buffer, size_t bufferSize, size_t* pRequiredBufferSize); bool (* isValueClass)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_CLASS_HANDLE cls); uint32_t (* getClassAttribs)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_CLASS_HANDLE cls); - CORINFO_MODULE_HANDLE (* getClassModule)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_CLASS_HANDLE cls); - CORINFO_ASSEMBLY_HANDLE (* getModuleAssembly)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_MODULE_HANDLE mod); - const char* (* getAssemblyName)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_ASSEMBLY_HANDLE assem); + const char* (* getClassAssemblyName)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_CLASS_HANDLE cls); void* (* LongLifetimeMalloc)(void * thisHandle, CorInfoExceptionClass** ppException, size_t sz); void (* LongLifetimeFree)(void * thisHandle, CorInfoExceptionClass** ppException, void* obj); bool (* getIsClassInitedFlagAddress)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_CLASS_HANDLE cls, CORINFO_CONST_LOOKUP* addr, int* offset); @@ -106,7 +104,7 @@ struct JitInterfaceCallbacks CorInfoIsAccessAllowedResult (* canAccessClass)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_RESOLVED_TOKEN* pResolvedToken, CORINFO_METHOD_HANDLE callerHandle, CORINFO_HELPER_DESC* pAccessHelper); size_t (* printFieldName)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_FIELD_HANDLE field, char* buffer, size_t bufferSize, size_t* pRequiredBufferSize); CORINFO_CLASS_HANDLE (* getFieldClass)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_FIELD_HANDLE field); - CorInfoType (* getFieldType)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_FIELD_HANDLE field, CORINFO_CLASS_HANDLE* structType, CORINFO_CLASS_HANDLE memberParent); + CorInfoType (* getFieldType)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_FIELD_HANDLE field, CORINFO_CLASS_HANDLE* structType, CORINFO_CLASS_HANDLE fieldOwnerHint); unsigned (* getFieldOffset)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_FIELD_HANDLE field); void (* getFieldInfo)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_RESOLVED_TOKEN* pResolvedToken, CORINFO_METHOD_HANDLE callerHandle, CORINFO_ACCESS_FLAGS flags, CORINFO_FIELD_INFO* pResult); uint32_t (* getThreadLocalFieldInfo)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_FIELD_HANDLE field, bool isGCtype); @@ -187,6 +185,7 @@ struct JitInterfaceCallbacks uint16_t (* getRelocTypeHint)(void * thisHandle, CorInfoExceptionClass** ppException, void* target); uint32_t (* getExpectedTargetArchitecture)(void * thisHandle, CorInfoExceptionClass** ppException); uint32_t (* getJitFlags)(void * thisHandle, CorInfoExceptionClass** ppException, CORJIT_FLAGS* flags, uint32_t sizeInBytes); + CORINFO_METHOD_HANDLE (* getSpecialCopyHelper)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_CLASS_HANDLE type); }; @@ -606,29 +605,11 @@ class JitInterfaceWrapper : public ICorJitInfo return temp; } - virtual CORINFO_MODULE_HANDLE getClassModule( + virtual const char* getClassAssemblyName( CORINFO_CLASS_HANDLE cls) { CorInfoExceptionClass* pException = nullptr; - CORINFO_MODULE_HANDLE temp = _callbacks->getClassModule(_thisHandle, &pException, cls); - if (pException != nullptr) throw pException; - return temp; -} - - virtual CORINFO_ASSEMBLY_HANDLE getModuleAssembly( - CORINFO_MODULE_HANDLE mod) -{ - CorInfoExceptionClass* pException = nullptr; - CORINFO_ASSEMBLY_HANDLE temp = _callbacks->getModuleAssembly(_thisHandle, &pException, mod); - if (pException != nullptr) throw pException; - return temp; -} - - virtual const char* getAssemblyName( - CORINFO_ASSEMBLY_HANDLE assem) -{ - CorInfoExceptionClass* pException = nullptr; - const char* temp = _callbacks->getAssemblyName(_thisHandle, &pException, assem); + const char* temp = _callbacks->getClassAssemblyName(_thisHandle, &pException, cls); if (pException != nullptr) throw pException; return temp; } @@ -1129,10 +1110,10 @@ class JitInterfaceWrapper : public ICorJitInfo virtual CorInfoType getFieldType( CORINFO_FIELD_HANDLE field, CORINFO_CLASS_HANDLE* structType, - CORINFO_CLASS_HANDLE memberParent) + CORINFO_CLASS_HANDLE fieldOwnerHint) { CorInfoExceptionClass* pException = nullptr; - CorInfoType temp = _callbacks->getFieldType(_thisHandle, &pException, field, structType, memberParent); + CorInfoType temp = _callbacks->getFieldType(_thisHandle, &pException, field, structType, fieldOwnerHint); if (pException != nullptr) throw pException; return temp; } @@ -1919,4 +1900,13 @@ class JitInterfaceWrapper : public ICorJitInfo if (pException != nullptr) throw pException; return temp; } + + virtual CORINFO_METHOD_HANDLE getSpecialCopyHelper( + CORINFO_CLASS_HANDLE type) +{ + CorInfoExceptionClass* pException = nullptr; + CORINFO_METHOD_HANDLE temp = _callbacks->getSpecialCopyHelper(_thisHandle, &pException, type); + if (pException != nullptr) throw pException; + return temp; +} }; diff --git a/src/coreclr/tools/r2rtest/Crossgen2Runner.cs b/src/coreclr/tools/r2rtest/Crossgen2Runner.cs index a93532e6382..e9024d58da3 100644 --- a/src/coreclr/tools/r2rtest/Crossgen2Runner.cs +++ b/src/coreclr/tools/r2rtest/Crossgen2Runner.cs @@ -24,15 +24,19 @@ class Crossgen2RunnerOptions class Crossgen2Runner : CompilerRunner { private Crossgen2RunnerOptions Crossgen2RunnerOptions; - public override CompilerIndex Index => CompilerIndex.CPAOT; + private bool IsAssembly => _options.Crossgen2Path != null && _options.Crossgen2Path.FullName.EndsWith(".dll"); - // Crossgen2 runs on top of corerun. + // Crossgen2 runs as a standalone binary protected override string CompilerRelativePath => ""; + protected override string CompilerFileName => ""; + + protected override string CompilerPath => IsAssembly ? _options.DotNetCli : _options.Crossgen2Path?.FullName + ?? Path.Combine(_options.CoreRootDirectory.FullName, "crossgen2", RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "crossgen2.exe" : "crossgen2"); + + public override CompilerIndex Index => CompilerIndex.CPAOT; - protected override string CompilerFileName => _options.DotNetCli; - protected readonly List _referenceFiles = new List(); + protected readonly List _referenceFiles = new(); - private string Crossgen2Path => _options.Crossgen2Path != null ? _options.Crossgen2Path.FullName : Path.Combine(_options.CoreRootDirectory.FullName, "crossgen2", "crossgen2.dll"); private bool CompositeMode => Crossgen2RunnerOptions != null ? Crossgen2RunnerOptions.Composite : _options.Composite; public Crossgen2Runner(BuildOptions options, Crossgen2RunnerOptions crossgen2RunnerOptions, IEnumerable references, string overrideOutputPath = null) @@ -64,7 +68,9 @@ public Crossgen2Runner(BuildOptions options, Crossgen2RunnerOptions crossgen2Run public override ProcessParameters CompilationProcess(string outputFileName, IEnumerable inputAssemblyFileNames) { ProcessParameters processParameters = base.CompilationProcess(outputFileName, inputAssemblyFileNames); - processParameters.Arguments = $"{Crossgen2Path} {processParameters.Arguments}"; + if (IsAssembly) + processParameters.Arguments = $"{_options.Crossgen2Path.FullName} {processParameters.Arguments}"; + // DOTNET_ variables processParameters.EnvironmentOverrides["DOTNET_GCStress"] = ""; processParameters.EnvironmentOverrides["DOTNET_HeapVerify"] = ""; @@ -76,6 +82,7 @@ public override ProcessParameters CompilationProcess(string outputFileName, IEnu processParameters.EnvironmentOverrides["COMPlus_HeapVerify"] = ""; processParameters.EnvironmentOverrides["COMPlus_ReadyToRun"] = ""; processParameters.EnvironmentOverrides["COMPlus_GCName"] = ""; + return processParameters; } diff --git a/src/coreclr/tools/superpmi/superpmi-shared/lwmlist.h b/src/coreclr/tools/superpmi/superpmi-shared/lwmlist.h index bb2c78da308..64b394309f5 100644 --- a/src/coreclr/tools/superpmi/superpmi-shared/lwmlist.h +++ b/src/coreclr/tools/superpmi/superpmi-shared/lwmlist.h @@ -102,9 +102,7 @@ LWM(GetLocationOfThisType, DWORDLONG, Agnostic_CORINFO_LOOKUP_KIND) LWM(IsIntrinsic, DWORDLONG, DWORD) LWM(NotifyMethodInfoUsage, DWORDLONG, DWORD) LWM(GetMethodAttribs, DWORDLONG, DWORD) -LWM(GetClassModule, DWORDLONG, DWORDLONG) -LWM(GetModuleAssembly, DWORDLONG, DWORDLONG) -LWM(GetAssemblyName, DWORDLONG, DWORD) +LWM(GetClassAssemblyName, DWORDLONG, DWORD) LWM(GetMethodClass, DWORDLONG, DWORDLONG) LWM(GetMethodDefFromMethod, DWORDLONG, DWORD) LWM(GetMethodHash, DWORDLONG, DWORD) @@ -131,6 +129,7 @@ LWM(GetSwiftLowering, DWORDLONG, Agnostic_GetSwiftLowering) LWM(GetFpStructLowering, DWORDLONG, Agnostic_GetFpStructLowering) LWM(GetTailCallHelpers, Agnostic_GetTailCallHelpers, Agnostic_CORINFO_TAILCALL_HELPERS) LWM(UpdateEntryPointForTailCall, Agnostic_CORINFO_CONST_LOOKUP, Agnostic_CORINFO_CONST_LOOKUP) +LWM(GetSpecialCopyHelper, DWORDLONG, DWORDLONG) LWM(GetThreadTLSIndex, DWORD, DLD) LWM(GetTokenTypeAsHandle, GetTokenTypeAsHandleValue, DWORDLONG) LWM(GetTypeForBox, DWORDLONG, DWORDLONG) diff --git a/src/coreclr/tools/superpmi/superpmi-shared/mclist.cpp b/src/coreclr/tools/superpmi/superpmi-shared/mclist.cpp index bea3ef6e937..79dca0cdc76 100644 --- a/src/coreclr/tools/superpmi/superpmi-shared/mclist.cpp +++ b/src/coreclr/tools/superpmi/superpmi-shared/mclist.cpp @@ -16,7 +16,7 @@ bool MCList::processArgAsMCL(char* input, int* count, int** list) size_t len = strlen(input); - for (unsigned int i = 0; (i < len) && isRangeList; i++) + for (size_t i = 0; (i < len) && isRangeList; i++) { if ((input[i] != '-') && (input[i] != ',') && (!isdigit((unsigned char)input[i]))) isRangeList = false; diff --git a/src/coreclr/tools/superpmi/superpmi-shared/methodcontext.cpp b/src/coreclr/tools/superpmi/superpmi-shared/methodcontext.cpp index 4c56364d865..36974d6534a 100644 --- a/src/coreclr/tools/superpmi/superpmi-shared/methodcontext.cpp +++ b/src/coreclr/tools/superpmi/superpmi-shared/methodcontext.cpp @@ -816,93 +816,44 @@ DWORD MethodContext::repGetMethodAttribs(CORINFO_METHOD_HANDLE methodHandle) return value; } -void MethodContext::recGetClassModule(CORINFO_CLASS_HANDLE cls, CORINFO_MODULE_HANDLE mod) +void MethodContext::recGetClassAssemblyName(CORINFO_CLASS_HANDLE cls, const char* assemblyName) { - if (GetClassModule == nullptr) - GetClassModule = new LightWeightMap(); - - DWORDLONG key = CastHandle(cls); - DWORDLONG value = CastHandle(mod); - GetClassModule->Add(key, value); - DEBUG_REC(dmpGetClassModule(key, value)); -} -void MethodContext::dmpGetClassModule(DWORDLONG key, DWORDLONG value) -{ - printf("GetClassModule cls-%016" PRIX64 ", mod-%016" PRIX64 "", key, value); -} -CORINFO_MODULE_HANDLE MethodContext::repGetClassModule(CORINFO_CLASS_HANDLE cls) -{ - DWORDLONG key = CastHandle(cls); - DWORDLONG value = LookupByKeyOrMiss(GetClassModule, key, ": key %016" PRIX64 "", key); - DEBUG_REP(dmpGetClassModule(key, value)); - CORINFO_MODULE_HANDLE result = (CORINFO_MODULE_HANDLE)value; - return result; -} - -void MethodContext::recGetModuleAssembly(CORINFO_MODULE_HANDLE mod, CORINFO_ASSEMBLY_HANDLE assem) -{ - if (GetModuleAssembly == nullptr) - GetModuleAssembly = new LightWeightMap(); - - DWORDLONG key = CastHandle(mod); - DWORDLONG value = CastHandle(assem); - GetModuleAssembly->Add(key, value); - DEBUG_REC(dmpGetModuleAssembly(key, value)); -} -void MethodContext::dmpGetModuleAssembly(DWORDLONG key, DWORDLONG value) -{ - printf("GetModuleAssembly mod-%016" PRIX64 ", assem-%016" PRIX64 "", key, value); -} -CORINFO_ASSEMBLY_HANDLE MethodContext::repGetModuleAssembly(CORINFO_MODULE_HANDLE mod) -{ - DWORDLONG key = CastHandle(mod); - DWORDLONG value = LookupByKeyOrMiss(GetModuleAssembly, key, ": key %016" PRIX64 "", key); - DEBUG_REP(dmpGetModuleAssembly(key, value)); - CORINFO_ASSEMBLY_HANDLE result = (CORINFO_ASSEMBLY_HANDLE)value; - return result; -} - -void MethodContext::recGetAssemblyName(CORINFO_ASSEMBLY_HANDLE assem, const char* assemblyName) -{ - if (GetAssemblyName == nullptr) - GetAssemblyName = new LightWeightMap(); + if (GetClassAssemblyName == nullptr) + GetClassAssemblyName = new LightWeightMap(); DWORD value; if (assemblyName != nullptr) { - value = GetAssemblyName->AddBuffer((const unsigned char*)assemblyName, (DWORD)strlen(assemblyName) + 1); + value = GetClassAssemblyName->AddBuffer((const unsigned char*)assemblyName, (DWORD)strlen(assemblyName) + 1); } else { value = (DWORD)-1; } - DWORDLONG key = CastHandle(assem); - GetAssemblyName->Add(key, value); - DEBUG_REC(dmpGetAssemblyName(key, value)); + DWORDLONG key = CastHandle(cls); + GetClassAssemblyName->Add(key, value); + DEBUG_REC(dmpGetClassAssemblyName(key, value)); } -void MethodContext::dmpGetAssemblyName(DWORDLONG key, DWORD value) +void MethodContext::dmpGetClassAssemblyName(DWORDLONG key, DWORD value) { - const char* assemblyName = (const char*)GetAssemblyName->GetBuffer(value); - printf("GetAssemblyName assem-%016" PRIX64 ", value-%u '%s'", key, value, assemblyName); - GetAssemblyName->Unlock(); + const char* assemblyName = (const char*)GetClassAssemblyName->GetBuffer(value); + printf("GetClassAssemblyName cls-%016" PRIX64 ", value-%u '%s'", key, value, assemblyName); + GetClassAssemblyName->Unlock(); } -const char* MethodContext::repGetAssemblyName(CORINFO_ASSEMBLY_HANDLE assem) +const char* MethodContext::repGetClassAssemblyName(CORINFO_CLASS_HANDLE cls) { - DWORDLONG key = CastHandle(assem); - const char* result = "hackishAssemblyName"; - DWORD value = (DWORD)-1; - int itemIndex = -1; - if (GetAssemblyName != nullptr) - { - itemIndex = GetAssemblyName->GetIndex(key); - } - if (itemIndex >= 0) + DWORDLONG key = CastHandle(cls); + DWORD value = LookupByKeyOrMiss(GetClassAssemblyName, key, ": key %016" PRIX64 "", key); + const char* result = nullptr; + + DEBUG_REP(dmpGetClassAssemblyName(key, value)); + + if (value != (DWORD)-1) { - value = GetAssemblyName->Get(key); - result = (const char*)GetAssemblyName->GetBuffer(value); + result = (const char*)GetClassAssemblyName->GetBuffer(value); } - DEBUG_REP(dmpGetAssemblyName(key, value)); + return result; } @@ -3718,7 +3669,7 @@ void MethodContext::recGetThreadLocalStaticBlocksInfo(CORINFO_THREAD_STATIC_BLOC void MethodContext::dmpGetThreadLocalStaticBlocksInfo(DWORD key, const Agnostic_GetThreadLocalStaticBlocksInfo& value) { printf("GetThreadLocalStaticBlocksInfo key %u, tlsIndex-%s, " - ", tlsGetAddrFtnPtr-%016" PRIX64 ", tlsIndexObject - %016" PRIX64 + ", tlsGetAddrFtnPtr-%016" PRIX64 ", tlsIndexObject - %016" PRIX64 ", threadVarsSection - %016" PRIX64 ", offsetOfThreadLocalStoragePointer-%u" ", offsetOfMaxThreadStaticBlocks-%u" @@ -5029,7 +4980,7 @@ GetTypeLayoutResult MethodContext::repGetTypeLayout(CORINFO_CLASS_HANDLE typeHnd void MethodContext::recGetFieldType(CORINFO_FIELD_HANDLE field, CORINFO_CLASS_HANDLE* structType, - CORINFO_CLASS_HANDLE memberParent, + CORINFO_CLASS_HANDLE fieldOwnerHint, CorInfoType result) { if (GetFieldType == nullptr) @@ -5038,7 +4989,7 @@ void MethodContext::recGetFieldType(CORINFO_FIELD_HANDLE field, DLDL key; ZeroMemory(&key, sizeof(key)); // Zero key including any struct padding key.A = CastHandle(field); - key.B = CastHandle(memberParent); + key.B = CastHandle(fieldOwnerHint); DLD value; value.B = (DWORD)result; @@ -5051,7 +5002,7 @@ void MethodContext::recGetFieldType(CORINFO_FIELD_HANDLE field, value.A = CastHandle(*structType); // If we had a previous call with null 'structType', we will not have captured the - // class handle (we use only 'field' and 'memberParent' as keys). + // class handle (we use only 'field' and 'fieldOwnerHint' as keys). // Update the value in that case. unsigned index = GetFieldType->GetIndex(key); if ((index != (unsigned)-1) && (GetFieldType->GetItem(index).A == 0)) @@ -5071,12 +5022,12 @@ void MethodContext::dmpGetFieldType(DLDL key, DLD value) } CorInfoType MethodContext::repGetFieldType(CORINFO_FIELD_HANDLE field, CORINFO_CLASS_HANDLE* structType, - CORINFO_CLASS_HANDLE memberParent) + CORINFO_CLASS_HANDLE fieldOwnerHint) { DLDL key; ZeroMemory(&key, sizeof(key)); // Zero key including any struct padding key.A = CastHandle(field); - key.B = CastHandle(memberParent); + key.B = CastHandle(fieldOwnerHint); DLD value = LookupByKeyOrMiss(GetFieldType, key, ": key %016" PRIX64 "", key.A); @@ -7212,6 +7163,33 @@ const WCHAR* MethodContext::repGetStringConfigValue(const WCHAR* name) return value; } +void MethodContext::recGetSpecialCopyHelper(CORINFO_CLASS_HANDLE type, CORINFO_METHOD_HANDLE helper) +{ + if (GetSpecialCopyHelper == nullptr) + GetSpecialCopyHelper = new LightWeightMap(); + + DWORDLONG key; + ZeroMemory(&key, sizeof(key)); // Zero key including any struct padding + key = CastHandle(type); + + DWORDLONG value = CastHandle(helper); + GetSpecialCopyHelper->Add(key, value); + DEBUG_REC(dmpGetSpecialCopyHelper(key, value)); +} + +void MethodContext::dmpGetSpecialCopyHelper(DWORDLONG key, DWORDLONG value) +{ + printf("getSpecialCopyHelper key %016" PRIX64 ", value %016" PRIX64 "", key, value); +} + +CORINFO_METHOD_HANDLE MethodContext::repGetSpecialCopyHelper(CORINFO_CLASS_HANDLE type) +{ + DWORDLONG key = CastHandle(type); + DWORDLONG value = LookupByKeyOrMiss(GetSpecialCopyHelper, key, ": key %016" PRIX64 "", key); + DEBUG_REP(dmpGetSpecialCopyHelper(key, value)); + return (CORINFO_METHOD_HANDLE)value; +} + void MethodContext::dmpSigInstHandleMap(DWORD key, DWORDLONG value) { printf("SigInstHandleMap key %u, value %016" PRIX64 "", key, value); diff --git a/src/coreclr/tools/superpmi/superpmi-shared/methodcontext.h b/src/coreclr/tools/superpmi/superpmi-shared/methodcontext.h index 0b2e84d3781..0fd63deb1ba 100644 --- a/src/coreclr/tools/superpmi/superpmi-shared/methodcontext.h +++ b/src/coreclr/tools/superpmi/superpmi-shared/methodcontext.h @@ -130,17 +130,9 @@ class MethodContext void dmpGetMethodAttribs(DWORDLONG key, DWORD value); DWORD repGetMethodAttribs(CORINFO_METHOD_HANDLE methodHandle); - void recGetClassModule(CORINFO_CLASS_HANDLE cls, CORINFO_MODULE_HANDLE mod); - void dmpGetClassModule(DWORDLONG key, DWORDLONG value); - CORINFO_MODULE_HANDLE repGetClassModule(CORINFO_CLASS_HANDLE cls); - - void recGetModuleAssembly(CORINFO_MODULE_HANDLE mod, CORINFO_ASSEMBLY_HANDLE assem); - void dmpGetModuleAssembly(DWORDLONG key, DWORDLONG value); - CORINFO_ASSEMBLY_HANDLE repGetModuleAssembly(CORINFO_MODULE_HANDLE mod); - - void recGetAssemblyName(CORINFO_ASSEMBLY_HANDLE assem, const char* assemblyName); - void dmpGetAssemblyName(DWORDLONG key, DWORD value); - const char* repGetAssemblyName(CORINFO_ASSEMBLY_HANDLE assem); + void recGetClassAssemblyName(CORINFO_CLASS_HANDLE cls, const char* assemblyName); + void dmpGetClassAssemblyName(DWORDLONG key, DWORD value); + const char* repGetClassAssemblyName(CORINFO_CLASS_HANDLE cls); void recGetVars(CORINFO_METHOD_HANDLE ftn, ULONG32* cVars, ICorDebugInfo::ILVarInfo** vars, bool* extendOthers); void dmpGetVars(DWORDLONG key, const Agnostic_GetVars& value); @@ -589,7 +581,7 @@ class MethodContext void recGetIsClassInitedFlagAddress(CORINFO_CLASS_HANDLE cls, CORINFO_CONST_LOOKUP* addr, int* offset, bool result); void dmpGetIsClassInitedFlagAddress(DWORDLONG key, const Agnostic_GetIsClassInitedFlagAddress& value); bool repGetIsClassInitedFlagAddress(CORINFO_CLASS_HANDLE cls, CORINFO_CONST_LOOKUP* addr, int* offset); - + void recGetStaticBaseAddress(CORINFO_CLASS_HANDLE cls, bool isGc, CORINFO_CONST_LOOKUP* addr, bool result); void dmpGetStaticBaseAddress(DLD key, const Agnostic_GetStaticBaseAddress& value); bool repGetStaticBaseAddress(CORINFO_CLASS_HANDLE cls, bool isGc, CORINFO_CONST_LOOKUP* addr); @@ -640,12 +632,12 @@ class MethodContext void recGetFieldType(CORINFO_FIELD_HANDLE field, CORINFO_CLASS_HANDLE* structType, - CORINFO_CLASS_HANDLE memberParent, + CORINFO_CLASS_HANDLE fieldOwnerHint, CorInfoType result); void dmpGetFieldType(DLDL key, DLD value); CorInfoType repGetFieldType(CORINFO_FIELD_HANDLE field, CORINFO_CLASS_HANDLE* structType, - CORINFO_CLASS_HANDLE memberParent); + CORINFO_CLASS_HANDLE fieldOwnerHint); void recSatisfiesMethodConstraints(CORINFO_CLASS_HANDLE parent, CORINFO_METHOD_HANDLE method, bool result); void dmpSatisfiesMethodConstraints(DLDL key, DWORD value); @@ -898,6 +890,10 @@ class MethodContext void dmpGetStringConfigValue(DWORD nameIndex, DWORD result); const WCHAR* repGetStringConfigValue(const WCHAR* name); + void recGetSpecialCopyHelper(CORINFO_CLASS_HANDLE type, CORINFO_METHOD_HANDLE helper); + void dmpGetSpecialCopyHelper(DWORDLONG key, DWORDLONG value); + CORINFO_METHOD_HANDLE repGetSpecialCopyHelper(CORINFO_CLASS_HANDLE type); + void dmpSigInstHandleMap(DWORD key, DWORDLONG value); struct Environment @@ -1154,9 +1150,9 @@ enum mcPackets Packet_AllocPgoInstrumentationBySchema = 186, Packet_GetPgoInstrumentationResults = 187, Packet_GetDefaultComparerClass = 188, - Packet_GetClassModule = 189, - Packet_GetModuleAssembly = 190, - Packet_GetAssemblyName = 191, + //Packet_GetClassModule = 189, + //Packet_GetModuleAssembly = 190, + //Packet_GetAssemblyName = 191, Packet_IsIntrinsic = 192, Packet_UpdateEntryPointForTailCall = 193, //Packet_GetLoongArch64PassStructInRegisterFlags = 194, @@ -1189,6 +1185,8 @@ enum mcPackets Packet_GetTypeForBoxOnStack = 221, Packet_GetTypeDefinition = 222, Packet_GetFpStructLowering = 223, + Packet_GetSpecialCopyHelper = 224, + Packet_GetClassAssemblyName = 225, }; void SetDebugDumpVariables(); diff --git a/src/coreclr/tools/superpmi/superpmi-shim-collector/icorjitinfo.cpp b/src/coreclr/tools/superpmi/superpmi-shim-collector/icorjitinfo.cpp index 368b2cbaec4..274ebcaa7eb 100644 --- a/src/coreclr/tools/superpmi/superpmi-shim-collector/icorjitinfo.cpp +++ b/src/coreclr/tools/superpmi/superpmi-shim-collector/icorjitinfo.cpp @@ -491,29 +491,12 @@ uint32_t interceptor_ICJI::getClassAttribs(CORINFO_CLASS_HANDLE cls) return temp; } -CORINFO_MODULE_HANDLE interceptor_ICJI::getClassModule(CORINFO_CLASS_HANDLE cls) +// Returns the assembly name of the class "cls". +const char* interceptor_ICJI::getClassAssemblyName(CORINFO_CLASS_HANDLE cls) { - mc->cr->AddCall("getClassModule"); - CORINFO_MODULE_HANDLE temp = original_ICorJitInfo->getClassModule(cls); - mc->recGetClassModule(cls, temp); - return temp; -} - -// Returns the assembly that contains the module "mod". -CORINFO_ASSEMBLY_HANDLE interceptor_ICJI::getModuleAssembly(CORINFO_MODULE_HANDLE mod) -{ - mc->cr->AddCall("getModuleAssembly"); - CORINFO_ASSEMBLY_HANDLE temp = original_ICorJitInfo->getModuleAssembly(mod); - mc->recGetModuleAssembly(mod, temp); - return temp; -} - -// Returns the name of the assembly "assem". -const char* interceptor_ICJI::getAssemblyName(CORINFO_ASSEMBLY_HANDLE assem) -{ - mc->cr->AddCall("getAssemblyName"); - const char* temp = original_ICorJitInfo->getAssemblyName(assem); - mc->recGetAssemblyName(assem, temp); + mc->cr->AddCall("getClassAssemblyName"); + const char* temp = original_ICorJitInfo->getClassAssemblyName(cls); + mc->recGetClassAssemblyName(cls, temp); return temp; } @@ -1062,16 +1045,16 @@ CORINFO_CLASS_HANDLE interceptor_ICJI::getFieldClass(CORINFO_FIELD_HANDLE field) // the field's value class (if 'structType' == 0, then don't bother // the structure info). // -// 'memberParent' is typically only set when verifying. It should be the -// result of calling getMemberParent. +// 'fieldOwnerHint' is, potentially, a more exact owner of the field. +// it's fine for it to be non-precise, it's just a hint. CorInfoType interceptor_ICJI::getFieldType(CORINFO_FIELD_HANDLE field, CORINFO_CLASS_HANDLE* structType, - CORINFO_CLASS_HANDLE memberParent /* IN */ + CORINFO_CLASS_HANDLE fieldOwnerHint /* IN */ ) { mc->cr->AddCall("getFieldType"); - CorInfoType temp = original_ICorJitInfo->getFieldType(field, structType, memberParent); - mc->recGetFieldType(field, structType, memberParent, temp); + CorInfoType temp = original_ICorJitInfo->getFieldType(field, structType, fieldOwnerHint); + mc->recGetFieldType(field, structType, fieldOwnerHint, temp); return temp; } @@ -2028,3 +2011,11 @@ bool interceptor_ICJI::notifyInstructionSetUsage(CORINFO_InstructionSet instruct { return original_ICorJitInfo->notifyInstructionSetUsage(instructionSet, supported); } + +CORINFO_METHOD_HANDLE interceptor_ICJI::getSpecialCopyHelper(CORINFO_CLASS_HANDLE type) +{ + mc->cr->AddCall("getSpecialCopyHelper"); + CORINFO_METHOD_HANDLE temp = original_ICorJitInfo->getSpecialCopyHelper(type); + mc->recGetSpecialCopyHelper(type, temp); + return temp; +} diff --git a/src/coreclr/tools/superpmi/superpmi-shim-counter/icorjitinfo_generated.cpp b/src/coreclr/tools/superpmi/superpmi-shim-counter/icorjitinfo_generated.cpp index 2702c0a409b..bba12312ee9 100644 --- a/src/coreclr/tools/superpmi/superpmi-shim-counter/icorjitinfo_generated.cpp +++ b/src/coreclr/tools/superpmi/superpmi-shim-counter/icorjitinfo_generated.cpp @@ -348,25 +348,11 @@ uint32_t interceptor_ICJI::getClassAttribs( return original_ICorJitInfo->getClassAttribs(cls); } -CORINFO_MODULE_HANDLE interceptor_ICJI::getClassModule( +const char* interceptor_ICJI::getClassAssemblyName( CORINFO_CLASS_HANDLE cls) { - mcs->AddCall("getClassModule"); - return original_ICorJitInfo->getClassModule(cls); -} - -CORINFO_ASSEMBLY_HANDLE interceptor_ICJI::getModuleAssembly( - CORINFO_MODULE_HANDLE mod) -{ - mcs->AddCall("getModuleAssembly"); - return original_ICorJitInfo->getModuleAssembly(mod); -} - -const char* interceptor_ICJI::getAssemblyName( - CORINFO_ASSEMBLY_HANDLE assem) -{ - mcs->AddCall("getAssemblyName"); - return original_ICorJitInfo->getAssemblyName(assem); + mcs->AddCall("getClassAssemblyName"); + return original_ICorJitInfo->getClassAssemblyName(cls); } void* interceptor_ICJI::LongLifetimeMalloc( @@ -766,10 +752,10 @@ CORINFO_CLASS_HANDLE interceptor_ICJI::getFieldClass( CorInfoType interceptor_ICJI::getFieldType( CORINFO_FIELD_HANDLE field, CORINFO_CLASS_HANDLE* structType, - CORINFO_CLASS_HANDLE memberParent) + CORINFO_CLASS_HANDLE fieldOwnerHint) { mcs->AddCall("getFieldType"); - return original_ICorJitInfo->getFieldType(field, structType, memberParent); + return original_ICorJitInfo->getFieldType(field, structType, fieldOwnerHint); } unsigned interceptor_ICJI::getFieldOffset( @@ -1437,3 +1423,10 @@ uint32_t interceptor_ICJI::getJitFlags( return original_ICorJitInfo->getJitFlags(flags, sizeInBytes); } +CORINFO_METHOD_HANDLE interceptor_ICJI::getSpecialCopyHelper( + CORINFO_CLASS_HANDLE type) +{ + mcs->AddCall("getSpecialCopyHelper"); + return original_ICorJitInfo->getSpecialCopyHelper(type); +} + diff --git a/src/coreclr/tools/superpmi/superpmi-shim-simple/icorjitinfo_generated.cpp b/src/coreclr/tools/superpmi/superpmi-shim-simple/icorjitinfo_generated.cpp index f2e6f5cbd99..2c789226b7f 100644 --- a/src/coreclr/tools/superpmi/superpmi-shim-simple/icorjitinfo_generated.cpp +++ b/src/coreclr/tools/superpmi/superpmi-shim-simple/icorjitinfo_generated.cpp @@ -307,22 +307,10 @@ uint32_t interceptor_ICJI::getClassAttribs( return original_ICorJitInfo->getClassAttribs(cls); } -CORINFO_MODULE_HANDLE interceptor_ICJI::getClassModule( +const char* interceptor_ICJI::getClassAssemblyName( CORINFO_CLASS_HANDLE cls) { - return original_ICorJitInfo->getClassModule(cls); -} - -CORINFO_ASSEMBLY_HANDLE interceptor_ICJI::getModuleAssembly( - CORINFO_MODULE_HANDLE mod) -{ - return original_ICorJitInfo->getModuleAssembly(mod); -} - -const char* interceptor_ICJI::getAssemblyName( - CORINFO_ASSEMBLY_HANDLE assem) -{ - return original_ICorJitInfo->getAssemblyName(assem); + return original_ICorJitInfo->getClassAssemblyName(cls); } void* interceptor_ICJI::LongLifetimeMalloc( @@ -671,9 +659,9 @@ CORINFO_CLASS_HANDLE interceptor_ICJI::getFieldClass( CorInfoType interceptor_ICJI::getFieldType( CORINFO_FIELD_HANDLE field, CORINFO_CLASS_HANDLE* structType, - CORINFO_CLASS_HANDLE memberParent) + CORINFO_CLASS_HANDLE fieldOwnerHint) { - return original_ICorJitInfo->getFieldType(field, structType, memberParent); + return original_ICorJitInfo->getFieldType(field, structType, fieldOwnerHint); } unsigned interceptor_ICJI::getFieldOffset( @@ -1261,3 +1249,9 @@ uint32_t interceptor_ICJI::getJitFlags( return original_ICorJitInfo->getJitFlags(flags, sizeInBytes); } +CORINFO_METHOD_HANDLE interceptor_ICJI::getSpecialCopyHelper( + CORINFO_CLASS_HANDLE type) +{ + return original_ICorJitInfo->getSpecialCopyHelper(type); +} + diff --git a/src/coreclr/tools/superpmi/superpmi/icorjitinfo.cpp b/src/coreclr/tools/superpmi/superpmi/icorjitinfo.cpp index 153ba612123..0fc1df067dd 100644 --- a/src/coreclr/tools/superpmi/superpmi/icorjitinfo.cpp +++ b/src/coreclr/tools/superpmi/superpmi/icorjitinfo.cpp @@ -416,24 +416,11 @@ uint32_t MyICJI::getClassAttribs(CORINFO_CLASS_HANDLE cls) return jitInstance->mc->repGetClassAttribs(cls); } -CORINFO_MODULE_HANDLE MyICJI::getClassModule(CORINFO_CLASS_HANDLE cls) +// Returns the assembly name of the class "cls". +const char* MyICJI::getClassAssemblyName(CORINFO_CLASS_HANDLE cls) { - jitInstance->mc->cr->AddCall("getClassModule"); - return jitInstance->mc->repGetClassModule(cls); -} - -// Returns the assembly that contains the module "mod". -CORINFO_ASSEMBLY_HANDLE MyICJI::getModuleAssembly(CORINFO_MODULE_HANDLE mod) -{ - jitInstance->mc->cr->AddCall("getModuleAssembly"); - return jitInstance->mc->repGetModuleAssembly(mod); -} - -// Returns the name of the assembly "assem". -const char* MyICJI::getAssemblyName(CORINFO_ASSEMBLY_HANDLE assem) -{ - jitInstance->mc->cr->AddCall("getAssemblyName"); - return jitInstance->mc->repGetAssemblyName(assem); + jitInstance->mc->cr->AddCall("getClassAssemblyName"); + return jitInstance->mc->repGetClassAssemblyName(cls); } // Allocate and delete process-lifetime objects. Should only be @@ -883,15 +870,15 @@ CORINFO_CLASS_HANDLE MyICJI::getFieldClass(CORINFO_FIELD_HANDLE field) // the field's value class (if 'structType' == 0, then don't bother // the structure info). // -// 'memberParent' is typically only set when verifying. It should be the -// result of calling getMemberParent. +// 'fieldOwnerHint' is, potentially, a more exact owner of the field. +// it's fine for it to be non-precise, it's just a hint. CorInfoType MyICJI::getFieldType(CORINFO_FIELD_HANDLE field, CORINFO_CLASS_HANDLE* structType, - CORINFO_CLASS_HANDLE memberParent /* IN */ + CORINFO_CLASS_HANDLE fieldOwnerHint /* IN */ ) { jitInstance->mc->cr->AddCall("getFieldType"); - return jitInstance->mc->repGetFieldType(field, structType, memberParent); + return jitInstance->mc->repGetFieldType(field, structType, fieldOwnerHint); } // return the data member's instance offset @@ -1775,7 +1762,7 @@ int MyICJI::doAssert(const char* szFile, int iLine, const char* szExpr) sprintf_s(buff, sizeof(buff), "%s (%d) - %s", szFile, iLine, szExpr); LogIssue(ISSUE_ASSERT, "#%d %s", jitInstance->mc->index, buff); - jitInstance->mc->cr->recMessageLog(buff); + jitInstance->mc->cr->recMessageLog("%s", buff); // Under "/boa", ask the user if they want to attach a debugger. If they do, the debugger will be attached, // then we'll call DebugBreakorAV(), which will issue a __debugbreak() and actually cause @@ -1864,3 +1851,10 @@ uint32_t MyICJI::getExpectedTargetArchitecture() DWORD result = jitInstance->mc->repGetExpectedTargetArchitecture(); return result; } + +CORINFO_METHOD_HANDLE MyICJI::getSpecialCopyHelper(CORINFO_CLASS_HANDLE type) +{ + jitInstance->mc->cr->AddCall("getSpecialCopyHelper"); + CORINFO_METHOD_HANDLE result = jitInstance->mc->repGetSpecialCopyHelper(type); + return result; +} diff --git a/src/coreclr/utilcode/clrhost.cpp b/src/coreclr/utilcode/clrhost.cpp index 35d30e441ae..a57b115fbfc 100644 --- a/src/coreclr/utilcode/clrhost.cpp +++ b/src/coreclr/utilcode/clrhost.cpp @@ -30,6 +30,13 @@ void* GetClrModuleBase() #else // DACCESS_COMPILE void* GetClrModuleBase() +{ + return GetCurrentModuleBase(); +} + +#endif // DACCESS_COMPILE + +void* GetCurrentModuleBase() { LIMITED_METHOD_CONTRACT; @@ -48,8 +55,6 @@ void* GetClrModuleBase() #endif // HOST_WINDOWS } -#endif // DACCESS_COMPILE - thread_local int t_CantAllocCount; DWORD GetClrModulePathName(SString& buffer) diff --git a/src/coreclr/utilcode/ex.cpp b/src/coreclr/utilcode/ex.cpp index 8197e4f0ef7..986f9b95d13 100644 --- a/src/coreclr/utilcode/ex.cpp +++ b/src/coreclr/utilcode/ex.cpp @@ -174,7 +174,7 @@ BOOL Exception::IsTerminal() GC_NOTRIGGER; NOTHROW; - // CLRException::GetHR() can eventually call BaseDomain::CreateHandle(), + // CLRException::GetHR() can eventually call AppDomain::CreateHandle(), // which can indirectly cause a lock if we get a miss in the handle table // cache (TableCacheMissOnAlloc). Since CLRException::GetHR() is virtual, // SCAN won't find this for you (though 40 minutes of one of the sql stress diff --git a/src/coreclr/utilcode/loaderheap.cpp b/src/coreclr/utilcode/loaderheap.cpp index 252f7afb237..9cbda2a5244 100644 --- a/src/coreclr/utilcode/loaderheap.cpp +++ b/src/coreclr/utilcode/loaderheap.cpp @@ -337,7 +337,7 @@ RangeList::RangeListBlock::EnumMemoryRegions(CLRDataEnumMemoryFlags flags) _ASSERTE( size < UINT32_MAX ); // ranges should be less than 4gig! // We can't be sure this entire range is mapped. For example, the code:StubLinkStubManager - // keeps track of all ranges in the code:BaseDomain::m_pStubHeap LoaderHeap, and + // keeps track of all ranges in the code:LoaderAllocator::m_pStubHeap LoaderHeap, and // code:LoaderHeap::UnlockedReservePages adds a range for the entire reserved region, instead // of updating the RangeList when pages are committed. But in that case, the committed region of // memory will be enumerated by the LoaderHeap anyway, so it's OK if this fails diff --git a/src/coreclr/utilcode/prettyprintsig.cpp b/src/coreclr/utilcode/prettyprintsig.cpp index 59f6e88c26d..31f6a93c4a1 100644 --- a/src/coreclr/utilcode/prettyprintsig.cpp +++ b/src/coreclr/utilcode/prettyprintsig.cpp @@ -674,6 +674,18 @@ static HRESULT PrettyPrintTypeA( sprintf_s(tempBuffer, 64, "pMT: %p", pMT); IfFailGo(appendStrA(out, tempBuffer)); break; + + case ELEMENT_TYPE_CMOD_INTERNAL: + { + bool required = *typePtr++ != 0; + void* pMT; + memcpy(&pMT, &typePtr, sizeof(pMT)); + typePtr += sizeof(pMT); + CHAR tempBuffer[64]; + sprintf_s(tempBuffer, 64, "pMT: %p", pMT); + IfFailGo(appendStrA(out, tempBuffer)); + break; + } case ELEMENT_TYPE_VALUETYPE: str = "value class "; diff --git a/src/coreclr/utilcode/util_nodependencies.cpp b/src/coreclr/utilcode/util_nodependencies.cpp index 91b18eec9e7..3a08158b0da 100644 --- a/src/coreclr/utilcode/util_nodependencies.cpp +++ b/src/coreclr/utilcode/util_nodependencies.cpp @@ -144,7 +144,7 @@ BOOL GetRegistryLongValue(HKEY hKeyParent, //---------------------------------------------------------------------------- // -// GetCurrentModuleFileName - Retrieve the current module's filename +// GetCurrentExecutableFileName - Retrieve the current executable's filename // // Arguments: // pBuffer - output string buffer @@ -155,7 +155,7 @@ BOOL GetRegistryLongValue(HKEY hKeyParent, // Note: // //---------------------------------------------------------------------------- -HRESULT GetCurrentModuleFileName(SString& pBuffer) +HRESULT GetCurrentExecutableFileName(SString& pBuffer) { LIMITED_METHOD_CONTRACT; @@ -211,7 +211,7 @@ BOOL IsCurrentModuleFileNameInAutoExclusionList() PathString wszAppName; // Get the appname to look up in the exclusion or inclusion list. - if (GetCurrentModuleFileName(wszAppName) != S_OK) + if (GetCurrentExecutableFileName(wszAppName) != S_OK) { // Assume it is not on the exclusion list if we cannot find the module's filename. return FALSE; @@ -380,7 +380,7 @@ HRESULT GetDebuggerSettingInfoWorker(_Out_writes_to_opt_(*pcchDebuggerString, *p long iValue; // Check DebugApplications setting - if ((SUCCEEDED(GetCurrentModuleFileName(wzAppName))) && + if ((SUCCEEDED(GetCurrentExecutableFileName(wzAppName))) && ( GetRegistryLongValue(HKEY_LOCAL_MACHINE, kDebugApplicationsPoliciesKey, wzAppName, &iValue, TRUE) || GetRegistryLongValue(HKEY_LOCAL_MACHINE, kDebugApplicationsKey, wzAppName, &iValue, TRUE) || diff --git a/src/coreclr/vm/.vscode/c_cpp_properties.json b/src/coreclr/vm/.vscode/c_cpp_properties.json index 30f8ba3e8f5..c61fa10a35d 100644 --- a/src/coreclr/vm/.vscode/c_cpp_properties.json +++ b/src/coreclr/vm/.vscode/c_cpp_properties.json @@ -53,7 +53,6 @@ "FEATURE_DEFAULT_INTERFACES", "FEATURE_EVENT_TRACE=1", "FEATURE_HIJACK", - "FEATURE_ICASTABLE", "FEATURE_INTEROP_DEBUGGING", "FEATURE_ISYM_READER", "FEATURE_MULTICASTSTUB_AS_IL", diff --git a/src/coreclr/vm/CMakeLists.txt b/src/coreclr/vm/CMakeLists.txt index 5db31ece3af..334faa6f167 100644 --- a/src/coreclr/vm/CMakeLists.txt +++ b/src/coreclr/vm/CMakeLists.txt @@ -345,7 +345,6 @@ set(VM_SOURCES_WKS nativeeventsource.cpp nativelibrary.cpp nativelibrarynative.cpp - objectlist.cpp olevariant.cpp pendingload.cpp pinvokeoverride.cpp @@ -444,7 +443,6 @@ set(VM_HEADERS_WKS multicorejit.h multicorejitimpl.h nativeeventsource.h - objectlist.h olevariant.h pendingload.h profdetach.h @@ -579,7 +577,6 @@ if(CLR_CMAKE_TARGET_WIN32) comtoclrcall.cpp dispatchinfo.cpp dispparammarshaler.cpp - mngstdinterfaces.cpp olecontexthelpers.cpp runtimecallablewrapper.cpp stdinterfaces.cpp @@ -595,7 +592,6 @@ if(CLR_CMAKE_TARGET_WIN32) comtoclrcall.h dispatchinfo.h dispparammarshaler.h - mngstdinterfaces.h olecontexthelpers.h runtimecallablewrapper.h stdinterfaces.h diff --git a/src/coreclr/vm/amd64/RedirectedHandledJITCase.asm b/src/coreclr/vm/amd64/RedirectedHandledJITCase.asm index 4aeb705922a..47b1ecfd50f 100644 --- a/src/coreclr/vm/amd64/RedirectedHandledJITCase.asm +++ b/src/coreclr/vm/amd64/RedirectedHandledJITCase.asm @@ -119,6 +119,9 @@ NESTED_ENTRY STUB, _TEXT, FILTER ; info. After this push, unwinding will work. push rcx + xor rax, rax + rdsspq rax + test rsp, 0fh jnz STUB&_FixRsp @@ -141,6 +144,7 @@ STUB&_RspAligned: mov dword ptr [rcx], 0 ; Initialize vtbl (it is not strictly necessary) mov dword ptr [rcx + OFFSETOF__FaultingExceptionFrame__m_fFilterExecuted], 0 ; Initialize BOOL for personality routine + mov r8, rax call TARGET @@ -181,6 +185,7 @@ NESTED_ENTRY RedirectForThrowControl2, _TEXT save_reg_postrsp rcx, REDIRECT_FOR_THROW_CONTROL_FRAME_SIZE + 8h ; FaultingExceptionFrame save_reg_postrsp rdx, REDIRECT_FOR_THROW_CONTROL_FRAME_SIZE + 10h ; Original RSP + save_reg_postrsp r8, REDIRECT_FOR_THROW_CONTROL_FRAME_SIZE + 18h ; SSP END_PROLOGUE @@ -193,7 +198,8 @@ NESTED_ENTRY RedirectForThrowControl2, _TEXT mov rdx, [rsp + REDIRECT_FOR_THROW_CONTROL_FRAME_SIZE + 10h] ; Original RSP mov [rdx - 8], rax - mov rcx, [rsp + REDIRECT_FOR_THROW_CONTROL_FRAME_SIZE + 8h] ; FaultingExceptionFrame + mov rcx, [rsp + REDIRECT_FOR_THROW_CONTROL_FRAME_SIZE + 8h] ; FaultingExceptionFrame + mov rdx, [rsp + REDIRECT_FOR_THROW_CONTROL_FRAME_SIZE + 18h] ; SSP call ThrowControlForThread ; ThrowControlForThread doesn't return. diff --git a/src/coreclr/vm/amd64/asmconstants.h b/src/coreclr/vm/amd64/asmconstants.h index 524e1fd40b7..1f4dc158dbd 100644 --- a/src/coreclr/vm/amd64/asmconstants.h +++ b/src/coreclr/vm/amd64/asmconstants.h @@ -409,7 +409,7 @@ ASMCONSTANTS_C_ASSERT(OFFSETOF__CONTEXT__Xmm15 ASMCONSTANTS_C_ASSERT(OFFSETOF__CONTEXT__VectorRegister == offsetof(CONTEXT, VectorRegister[0])); -#define SIZEOF__FaultingExceptionFrame (0x20 + SIZEOF__CONTEXT) +#define SIZEOF__FaultingExceptionFrame (0x20 + SIZEOF__CONTEXT + 16) ASMCONSTANTS_C_ASSERT(SIZEOF__FaultingExceptionFrame == sizeof(FaultingExceptionFrame)); @@ -417,6 +417,10 @@ ASMCONSTANTS_C_ASSERT(SIZEOF__FaultingExceptionFrame ASMCONSTANTS_C_ASSERT(OFFSETOF__FaultingExceptionFrame__m_fFilterExecuted == offsetof(FaultingExceptionFrame, m_fFilterExecuted)); +#define OFFSETOF__FaultingExceptionFrame__m_SSP (0x20 + SIZEOF__CONTEXT) +ASMCONSTANTS_C_ASSERT(OFFSETOF__FaultingExceptionFrame__m_SSP + == offsetof(FaultingExceptionFrame, m_SSP)); + #define OFFSETOF__PtrArray__m_NumComponents 0x8 ASMCONSTANTS_C_ASSERT(OFFSETOF__PtrArray__m_NumComponents == offsetof(PtrArray, m_NumComponents)); diff --git a/src/coreclr/vm/amd64/cgenamd64.cpp b/src/coreclr/vm/amd64/cgenamd64.cpp index a7ec8d33f05..a14a1eed650 100644 --- a/src/coreclr/vm/amd64/cgenamd64.cpp +++ b/src/coreclr/vm/amd64/cgenamd64.cpp @@ -231,10 +231,18 @@ void FaultingExceptionFrame::UpdateRegDisplay(const PREGDISPLAY pRD, bool update memcpy(pRD->pCurrentContext, &m_ctx, sizeof(CONTEXT)); + // Clear the CONTEXT_XSTATE, since the REGDISPLAY contains just plain CONTEXT structure + // that cannot contain any extended state. + pRD->pCurrentContext->ContextFlags &= ~(CONTEXT_XSTATE & CONTEXT_AREA_MASK); + pRD->ControlPC = m_ctx.Rip; pRD->SP = m_ctx.Rsp; +#ifdef TARGET_WINDOWS + pRD->SSP = m_SSP; +#endif + pRD->pCurrentContextPointers->Rax = &m_ctx.Rax; pRD->pCurrentContextPointers->Rcx = &m_ctx.Rcx; pRD->pCurrentContextPointers->Rdx = &m_ctx.Rdx; diff --git a/src/coreclr/vm/appdomain.cpp b/src/coreclr/vm/appdomain.cpp index 5d0e7b220aa..34f1f6b0dea 100644 --- a/src/coreclr/vm/appdomain.cpp +++ b/src/coreclr/vm/appdomain.cpp @@ -39,7 +39,6 @@ #ifdef FEATURE_COMINTEROP #include "comtoclrcall.h" #include "runtimecallablewrapper.h" -#include "mngstdinterfaces.h" #include "olevariant.h" #include "olecontexthelpers.h" #endif // FEATURE_COMINTEROP @@ -91,11 +90,6 @@ SPTR_IMPL(SystemDomain, SystemDomain, m_pSystemDomain); #ifndef DACCESS_COMPILE -// Base Domain Statics -CrstStatic BaseDomain::m_MethodTableExposedClassObjectCrst; - -int BaseDomain::m_iNumberOfProcessors = 0; - // System Domain Statics GlobalStringLiteralMap* SystemDomain::m_pGlobalStringLiteralMap = NULL; FrozenObjectHeapManager* SystemDomain::m_FrozenObjectHeapManager = NULL; @@ -107,7 +101,7 @@ CrstStatic SystemDomain::m_SystemDomainCrst; CrstStatic SystemDomain::m_DelayedUnloadCrst; // Constructor for the PinnedHeapHandleBucket class. -PinnedHeapHandleBucket::PinnedHeapHandleBucket(PinnedHeapHandleBucket *pNext, PTRARRAYREF pinnedHandleArrayObj, DWORD size, BaseDomain *pDomain) +PinnedHeapHandleBucket::PinnedHeapHandleBucket(PinnedHeapHandleBucket *pNext, PTRARRAYREF pinnedHandleArrayObj, DWORD size) : m_pNext(pNext) , m_ArraySize(size) , m_CurrentPos(0) @@ -118,7 +112,6 @@ PinnedHeapHandleBucket::PinnedHeapHandleBucket(PinnedHeapHandleBucket *pNext, PT THROWS; GC_NOTRIGGER; MODE_COOPERATIVE; - PRECONDITION(CheckPointer(pDomain)); INJECT_FAULT(COMPlusThrowOM();); } CONTRACTL_END; @@ -128,7 +121,7 @@ PinnedHeapHandleBucket::PinnedHeapHandleBucket(PinnedHeapHandleBucket *pNext, PT m_pArrayDataPtr = (OBJECTREF *)pinnedHandleArrayObj->GetDataPtr(); // Store the array in a strong handle to keep it alive. - m_hndHandleArray = pDomain->CreateStrongHandle((OBJECTREF)pinnedHandleArrayObj); + m_hndHandleArray = AppDomain::GetCurrentDomain()->CreateStrongHandle((OBJECTREF)pinnedHandleArrayObj); } @@ -218,9 +211,8 @@ void PinnedHeapHandleBucket::EnumStaticGCRefs(promote_func* fn, ScanContext* sc) #define MAX_BUCKETSIZE (16384 - 4) // Constructor for the PinnedHeapHandleTable class. -PinnedHeapHandleTable::PinnedHeapHandleTable(BaseDomain *pDomain, DWORD InitialBucketSize) +PinnedHeapHandleTable::PinnedHeapHandleTable(DWORD InitialBucketSize) : m_pHead(NULL) -, m_pDomain(pDomain) , m_NextBucketSize(InitialBucketSize) , m_pFreeSearchHint(NULL) , m_cEmbeddedFree(0) @@ -230,7 +222,6 @@ PinnedHeapHandleTable::PinnedHeapHandleTable(BaseDomain *pDomain, DWORD InitialB THROWS; GC_TRIGGERS; MODE_COOPERATIVE; - PRECONDITION(CheckPointer(pDomain)); INJECT_FAULT(COMPlusThrowOM();); } CONTRACTL_END; @@ -362,7 +353,7 @@ OBJECTREF* PinnedHeapHandleTable::AllocateHandles(DWORD nRequested) m_pHead->ConsumeRemaining(); } - m_pHead = new PinnedHeapHandleBucket(m_pHead, pinnedHandleArrayObj, newBucketSize, m_pDomain); + m_pHead = new PinnedHeapHandleBucket(m_pHead, pinnedHandleArrayObj, newBucketSize); // we already computed nextBucketSize to be double the previous size above, but it is possible that // other threads increased m_NextBucketSize while the lock was unheld. We want to ensure @@ -439,120 +430,9 @@ void PinnedHeapHandleTable::EnumStaticGCRefs(promote_func* fn, ScanContext* sc) } } -//***************************************************************************** -// BaseDomain -//***************************************************************************** -void BaseDomain::Attach() -{ - m_MethodTableExposedClassObjectCrst.Init(CrstMethodTableExposedObject); -} - -BaseDomain::BaseDomain() -{ - // initialize fields so the domain can be safely destructed - // shouldn't call anything that can fail here - use ::Init instead - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_ANY; - FORBID_FAULT; - } - CONTRACTL_END; - - m_pDefaultBinder = NULL; - - // Make sure the container is set to NULL so that it gets loaded when it is used. - m_pPinnedHeapHandleTable = NULL; - - // Note that m_handleStore is overridden by app domains - m_handleStore = GCHandleUtilities::GetGCHandleManager()->GetGlobalHandleStore(); - -#ifdef FEATURE_COMINTEROP - m_pMngStdInterfacesInfo = NULL; -#endif - m_FileLoadLock.PreInit(); - m_JITLock.PreInit(); - m_ClassInitLock.PreInit(); - m_ILStubGenLock.PreInit(); - m_NativeTypeLoadLock.PreInit(); -} //BaseDomain::BaseDomain - -//***************************************************************************** -void BaseDomain::Init() -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_ANY; - INJECT_FAULT(COMPlusThrowOM();); - } - CONTRACTL_END; - - // - // Initialize the domain locks - // - - if (this == reinterpret_cast(&g_pSystemDomainMemory[0])) - m_DomainCrst.Init(CrstSystemBaseDomain); - else - m_DomainCrst.Init(CrstBaseDomain); - - m_DomainCacheCrst.Init(CrstAppDomainCache); - m_crstGenericDictionaryExpansionLock.Init(CrstGenericDictionaryExpansion); - - // NOTE: CRST_UNSAFE_COOPGC prevents a GC mode switch to preemptive when entering this crst. - // If you remove this flag, we will switch to preemptive mode when entering - // m_FileLoadLock, which means all functions that enter it will become - // GC_TRIGGERS. (This includes all uses of PEFileListLockHolder, LoadLockHolder, etc.) So be sure - // to update the contracts if you remove this flag. - m_FileLoadLock.Init(CrstAssemblyLoader, - CrstFlags(CRST_HOST_BREAKABLE), TRUE); - - // - // The JIT lock and the CCtor locks are at the same level (and marked as - // UNSAFE_SAME_LEVEL) because they are all part of the same deadlock detection mechanism. We - // see through cycles of JITting and .cctor execution and then explicitly allow the cycle to - // be broken by giving access to uninitialized classes. If there is no cycle or if the cycle - // involves other locks that arent part of this special deadlock-breaking semantics, then - // we continue to block. - // - m_JITLock.Init(CrstJit, CrstFlags(CRST_REENTRANCY | CRST_UNSAFE_SAMELEVEL), TRUE); - m_ClassInitLock.Init(CrstClassInit, CrstFlags(CRST_REENTRANCY | CRST_UNSAFE_SAMELEVEL), TRUE); - - m_ILStubGenLock.Init(CrstILStubGen, CrstFlags(CRST_REENTRANCY), TRUE); - m_NativeTypeLoadLock.Init(CrstInteropData, CrstFlags(CRST_REENTRANCY), TRUE); - - m_crstLoaderAllocatorReferences.Init(CrstLoaderAllocatorReferences); - // Has to switch thread to GC_NOTRIGGER while being held (see code:BaseDomain#AssemblyListLock) - m_crstAssemblyList.Init(CrstAssemblyList, CrstFlags( - CRST_GC_NOTRIGGER_WHEN_TAKEN | CRST_DEBUGGER_THREAD | CRST_TAKEN_DURING_SHUTDOWN)); - -#ifdef FEATURE_COMINTEROP - // Allocate the managed standard interfaces information. - m_pMngStdInterfacesInfo = new MngStdInterfacesInfo(); -#endif // FEATURE_COMINTEROP - - m_dwSizedRefHandles = 0; - // For server GC this value indicates the number of GC heaps used in circular order to allocate sized - // ref handles. It must not exceed the array size allocated by the handle table (see getNumberOfSlots - // in objecthandle.cpp). We might want to use GetNumberOfHeaps if it were accessible here. - m_iNumberOfProcessors = min(GetCurrentProcessCpuCount(), GetTotalProcessorCount()); -} - #undef LOADERHEAP_PROFILE_COUNTER -void BaseDomain::InitVSD() -{ - STANDARD_VM_CONTRACT; - - m_typeIDMap.Init(); - - GetLoaderAllocator()->InitVirtualCallStubManager(this); -} - -void BaseDomain::ClearBinderContext() +void AppDomain::ClearBinderContext() { CONTRACTL { @@ -672,7 +552,7 @@ void AppDomain::SetNativeDllSearchDirectories(LPCWSTR wszNativeDllSearchDirector } } -OBJECTREF* BaseDomain::AllocateObjRefPtrsInLargeTable(int nRequested, DynamicStaticsInfo* pStaticsInfo, MethodTable *pMTToFillWithStaticBoxes, bool isClassInitdeByUpdatingStaticPointer) +OBJECTREF* AppDomain::AllocateObjRefPtrsInLargeTable(int nRequested, DynamicStaticsInfo* pStaticsInfo, MethodTable *pMTToFillWithStaticBoxes, bool isClassInitdeByUpdatingStaticPointer) { CONTRACTL { @@ -760,7 +640,7 @@ OBJECTREF AppDomain::GetMissingObject() #ifndef DACCESS_COMPILE -STRINGREF *BaseDomain::IsStringInterned(STRINGREF *pString) +STRINGREF* AppDomain::IsStringInterned(STRINGREF *pString) { CONTRACTL { @@ -775,7 +655,7 @@ STRINGREF *BaseDomain::IsStringInterned(STRINGREF *pString) return GetLoaderAllocator()->IsStringInterned(pString); } -STRINGREF *BaseDomain::GetOrInternString(STRINGREF *pString) +STRINGREF* AppDomain::GetOrInternString(STRINGREF *pString) { CONTRACTL { @@ -790,7 +670,7 @@ STRINGREF *BaseDomain::GetOrInternString(STRINGREF *pString) return GetLoaderAllocator()->GetOrInternString(pString); } -void BaseDomain::InitPinnedHeapHandleTable() +void AppDomain::InitPinnedHeapHandleTable() { CONTRACTL { @@ -801,7 +681,7 @@ void BaseDomain::InitPinnedHeapHandleTable() } CONTRACTL_END; - PinnedHeapHandleTable* pTable = new PinnedHeapHandleTable(this, STATIC_OBJECT_TABLE_BUCKET_SIZE); + PinnedHeapHandleTable* pTable = new PinnedHeapHandleTable(STATIC_OBJECT_TABLE_BUCKET_SIZE); if(InterlockedCompareExchangeT(&m_pPinnedHeapHandleTable, pTable, NULL) != NULL) { // another thread beat us to initializing the field, delete our copy @@ -865,9 +745,6 @@ void SystemDomain::Attach() "Created system domain at %p\n", m_pSystemDomain)); - // We need to initialize the memory pools etc. for the system domain. - m_pSystemDomain->BaseDomain::Init(); // Setup the memory heaps - // Create the one and only app domain AppDomain::Create(); @@ -911,7 +788,6 @@ void SystemDomain::DetachEnd() if(m_pSystemDomain) { GCX_PREEMP(); - m_pSystemDomain->ClearBinderContext(); AppDomain* pAppDomain = GetAppDomain(); if (pAppDomain) pAppDomain->ClearBinderContext(); @@ -938,7 +814,7 @@ void SystemDomain::PreallocateSpecialObjects() _ASSERTE(g_pPreallocatedSentinelObject == NULL); OBJECTREF pPreallocatedSentinelObject = AllocateObject(g_pObjectClass); - g_pPreallocatedSentinelObject = CreatePinningHandle( pPreallocatedSentinelObject ); + g_pPreallocatedSentinelObject = AppDomain::GetCurrentDomain()->CreatePinningHandle( pPreallocatedSentinelObject ); } void SystemDomain::CreatePreallocatedExceptions() @@ -956,27 +832,30 @@ void SystemDomain::CreatePreallocatedExceptions() pOutOfMemory->SetHResult(COR_E_OUTOFMEMORY); pOutOfMemory->SetXCode(EXCEPTION_COMPLUS); _ASSERTE(g_pPreallocatedOutOfMemoryException == NULL); - g_pPreallocatedOutOfMemoryException = CreateHandle(pOutOfMemory); + g_pPreallocatedOutOfMemoryException = AppDomain::GetCurrentDomain()->CreateHandle(pOutOfMemory); EXCEPTIONREF pStackOverflow = (EXCEPTIONREF)AllocateObject(g_pStackOverflowExceptionClass); pStackOverflow->SetHResult(COR_E_STACKOVERFLOW); pStackOverflow->SetXCode(EXCEPTION_COMPLUS); _ASSERTE(g_pPreallocatedStackOverflowException == NULL); - g_pPreallocatedStackOverflowException = CreateHandle(pStackOverflow); + g_pPreallocatedStackOverflowException = AppDomain::GetCurrentDomain()->CreateHandle(pStackOverflow); EXCEPTIONREF pExecutionEngine = (EXCEPTIONREF)AllocateObject(g_pExecutionEngineExceptionClass); pExecutionEngine->SetHResult(COR_E_EXECUTIONENGINE); pExecutionEngine->SetXCode(EXCEPTION_COMPLUS); _ASSERTE(g_pPreallocatedExecutionEngineException == NULL); - g_pPreallocatedExecutionEngineException = CreateHandle(pExecutionEngine); + g_pPreallocatedExecutionEngineException = AppDomain::GetCurrentDomain()->CreateHandle(pExecutionEngine); } void SystemDomain::Init() { STANDARD_VM_CONTRACT; + // The AppDomain should have already been created + _ASSERTE(AppDomain::GetCurrentDomain() != NULL); + HRESULT hr = S_OK; #ifdef _DEBUG @@ -996,10 +875,6 @@ void SystemDomain::Init() )); #endif // _DEBUG - // The base domain is initialized in SystemDomain::Attach() - // to allow stub caches to use the memory pool. Do not - // initialize it here! - m_pSystemPEAssembly = NULL; m_pSystemAssembly = NULL; @@ -1039,7 +914,7 @@ void SystemDomain::Init() PreallocateSpecialObjects(); // Finish loading CoreLib now. - m_pSystemAssembly->GetDomainAssembly()->EnsureActive(); + m_pSystemAssembly->EnsureActive(); // Set AwareLock's offset of the holding OS thread ID field into ThreadBlockingInfo's static field. That can be used // when doing managed debugging to get the OS ID of the thread holding the lock. The offset is currently not zero, and @@ -1127,31 +1002,6 @@ void SystemDomain::LazyInitFrozenObjectsHeap() RETURN; } -// Only called when EE is suspended. -DWORD SystemDomain::GetTotalNumSizedRefHandles() -{ - CONTRACTL - { - NOTHROW; - GC_NOTRIGGER; - MODE_ANY; - } - CONTRACTL_END; - - SystemDomain* sysDomain = SystemDomain::System(); - DWORD dwTotalNumSizedRefHandles = 0; - if (sysDomain) - { - AppDomain* pAppDomain = ::GetAppDomain(); - if (pAppDomain && pAppDomain->IsActive()) - { - dwTotalNumSizedRefHandles += pAppDomain->GetNumSizedRefHandles(); - } - } - - return dwTotalNumSizedRefHandles; -} - void SystemDomain::LoadBaseSystemClasses() { STANDARD_VM_CONTRACT; @@ -1164,7 +1014,7 @@ void SystemDomain::LoadBaseSystemClasses() // Only partially load the system assembly. Other parts of the code will want to access // the globals in this function before finishing the load. - m_pSystemAssembly = DefaultDomain()->LoadDomainAssembly(NULL, m_pSystemPEAssembly, FILE_LOAD_POST_ALLOCATE)->GetAssembly(); + m_pSystemAssembly = DefaultDomain()->LoadAssembly(NULL, m_pSystemPEAssembly, FILE_LOAD_BEFORE_TYPE_LOAD); // Set up binder for CoreLib CoreLibBinder::AttachModule(m_pSystemAssembly->GetModule()); @@ -1264,6 +1114,8 @@ void SystemDomain::LoadBaseSystemClasses() g_pCastHelpers = CoreLibBinder::GetClass(CLASS__CASTHELPERS); + g_pIDynamicInterfaceCastableInterface = CoreLibBinder::GetClass(CLASS__IDYNAMICINTERFACECASTABLE); + #ifdef FEATURE_COMINTEROP if (g_pConfig->IsBuiltInCOMSupported()) { @@ -1275,12 +1127,6 @@ void SystemDomain::LoadBaseSystemClasses() } #endif - g_pIDynamicInterfaceCastableInterface = CoreLibBinder::GetClass(CLASS__IDYNAMICINTERFACECASTABLE); - - #ifdef FEATURE_ICASTABLE - g_pICastableInterface = CoreLibBinder::GetClass(CLASS__ICASTABLE); - #endif // FEATURE_ICASTABLE - #ifdef FEATURE_EH_FUNCLETS g_pEHClass = CoreLibBinder::GetClass(CLASS__EH); g_pExceptionServicesInternalCallsClass = CoreLibBinder::GetClass(CLASS__EXCEPTIONSERVICES_INTERNALCALLS); @@ -1635,19 +1481,14 @@ void AppDomain::Create() { STANDARD_VM_CONTRACT; - AppDomainRefHolder pDomain(new AppDomain()); + _ASSERTE(m_pTheAppDomain == NULL); + AppDomainRefHolder pDomain(new AppDomain()); pDomain->Init(); - - // allocate a Virtual Call Stub Manager for the default domain - pDomain->InitVSD(); - pDomain->SetStage(AppDomain::STAGE_OPEN); pDomain->CreateDefaultBinder(); - pDomain.SuppressRelease(); - - m_pTheAppDomain = pDomain; + m_pTheAppDomain = pDomain.Extract(); LOG((LF_CLASSLOADER | LF_CORDB, LL_INFO10, @@ -1705,15 +1546,15 @@ void SystemDomain::NotifyProfilerStartup() { BEGIN_PROFILER_CALLBACK(CORProfilerTrackAppDomainLoads()); - _ASSERTE(System()->DefaultDomain()); - (&g_profControlBlock)->AppDomainCreationStarted((AppDomainID) System()->DefaultDomain()); + _ASSERTE(AppDomain::GetCurrentDomain()); + (&g_profControlBlock)->AppDomainCreationStarted((AppDomainID) AppDomain::GetCurrentDomain()); END_PROFILER_CALLBACK(); } { BEGIN_PROFILER_CALLBACK(CORProfilerTrackAppDomainLoads()); - _ASSERTE(System()->DefaultDomain()); - (&g_profControlBlock)->AppDomainCreationFinished((AppDomainID) System()->DefaultDomain(), S_OK); + _ASSERTE(AppDomain::GetCurrentDomain()); + (&g_profControlBlock)->AppDomainCreationFinished((AppDomainID) AppDomain::GetCurrentDomain(), S_OK); END_PROFILER_CALLBACK(); } } @@ -1744,15 +1585,15 @@ HRESULT SystemDomain::NotifyProfilerShutdown() { BEGIN_PROFILER_CALLBACK(CORProfilerTrackAppDomainLoads()); - _ASSERTE(System()->DefaultDomain()); - (&g_profControlBlock)->AppDomainShutdownStarted((AppDomainID) System()->DefaultDomain()); + _ASSERTE(AppDomain::GetCurrentDomain()); + (&g_profControlBlock)->AppDomainShutdownStarted((AppDomainID) AppDomain::GetCurrentDomain()); END_PROFILER_CALLBACK(); } { BEGIN_PROFILER_CALLBACK(CORProfilerTrackAppDomainLoads()); - _ASSERTE(System()->DefaultDomain()); - (&g_profControlBlock)->AppDomainShutdownFinished((AppDomainID) System()->DefaultDomain(), S_OK); + _ASSERTE(AppDomain::GetCurrentDomain()); + (&g_profControlBlock)->AppDomainShutdownFinished((AppDomainID) AppDomain::GetCurrentDomain(), S_OK); END_PROFILER_CALLBACK(); } return (S_OK); @@ -1760,6 +1601,31 @@ HRESULT SystemDomain::NotifyProfilerShutdown() #endif // PROFILING_SUPPORTED AppDomain::AppDomain() + : m_handleStore{NULL} + , m_pPinnedHeapHandleTable{NULL} + , m_pDefaultBinder{NULL} + , m_pRefClassFactHash{NULL} +#ifdef FEATURE_COMINTEROP + , m_pRefDispIDCache{NULL} + , m_hndMissing{NULL} +#endif //FEATURE_COMINTEROP + , m_pDelayedLoaderAllocatorUnloadList{NULL} + , m_friendlyName{NULL} + , m_pRootAssembly{NULL} + , m_dwFlags{0} + , m_cRef{1} +#ifdef FEATURE_COMINTEROP + , m_pRCWCache{NULL} +#endif //FEATURE_COMINTEROP +#ifdef FEATURE_COMWRAPPERS + , m_pRCWRefCache{NULL} +#endif // FEATURE_COMWRAPPERS + , m_Stage{STAGE_CREATING} + , m_MemoryPressure{0} + , m_ForceTrivialWaitOperations{false} +#ifdef FEATURE_TYPEEQUIVALENCE + , m_pTypeEquivalenceTable{NULL} +#endif // FEATURE_TYPEEQUIVALENCE { // initialize fields so the appdomain can be safely destructed // shouldn't call anything that can fail here - use ::Init instead @@ -1772,38 +1638,16 @@ AppDomain::AppDomain() } CONTRACTL_END; - m_cRef=1; - - m_pRootAssembly = NULL; - - m_dwFlags = 0; -#ifdef FEATURE_COMINTEROP - m_pRCWCache = NULL; -#endif //FEATURE_COMINTEROP -#ifdef FEATURE_COMWRAPPERS - m_pRCWRefCache = NULL; -#endif // FEATURE_COMWRAPPERS - - m_handleStore = NULL; + m_JITLock.PreInit(); + m_ClassInitLock.PreInit(); + m_ILStubGenLock.PreInit(); + m_NativeTypeLoadLock.PreInit(); + m_FileLoadLock.PreInit(); #ifdef _DEBUG m_Assemblies.Debug_SetAppDomain(this); #endif // _DEBUG -#ifdef FEATURE_COMINTEROP - m_pRefDispIDCache = NULL; - m_hndMissing = NULL; -#endif - - m_pRefClassFactHash = NULL; - - m_ForceTrivialWaitOperations = false; - m_Stage=STAGE_CREATING; - -#ifdef FEATURE_TYPEEQUIVALENCE - m_pTypeEquivalenceTable = NULL; -#endif // FEATURE_TYPEEQUIVALENCE - } // AppDomain::AppDomain AppDomain::~AppDomain() @@ -1827,30 +1671,42 @@ void AppDomain::Init() CONTRACTL { STANDARD_VM_CHECK; + PRECONDITION(m_Stage == STAGE_CREATING); } CONTRACTL_END; - m_pDelayedLoaderAllocatorUnloadList = NULL; + // + // The JIT lock and the CCtor locks are at the same level (and marked as + // UNSAFE_SAME_LEVEL) because they are all part of the same deadlock detection mechanism. We + // see through cycles of JITting and .cctor execution and then explicitly allow the cycle to + // be broken by giving access to uninitialized classes. If there is no cycle or if the cycle + // involves other locks that arent part of this special deadlock-breaking semantics, then + // we continue to block. + // + m_JITLock.Init(CrstJit, CrstFlags(CRST_REENTRANCY | CRST_UNSAFE_SAMELEVEL), TRUE); + m_ClassInitLock.Init(CrstClassInit, CrstFlags(CRST_REENTRANCY | CRST_UNSAFE_SAMELEVEL), TRUE); + m_ILStubGenLock.Init(CrstILStubGen, CrstFlags(CRST_REENTRANCY), TRUE); + m_NativeTypeLoadLock.Init(CrstInteropData, CrstFlags(CRST_REENTRANCY), TRUE); + m_crstGenericDictionaryExpansionLock.Init(CrstGenericDictionaryExpansion); + m_FileLoadLock.Init(CrstAssemblyLoader, CrstFlags(CRST_HOST_BREAKABLE), TRUE); + m_DomainCacheCrst.Init(CrstAppDomainCache); - SetStage( STAGE_CREATING); + // Has to switch thread to GC_NOTRIGGER while being held + m_crstAssemblyList.Init(CrstAssemblyList, CrstFlags( + CRST_GC_NOTRIGGER_WHEN_TAKEN | CRST_DEBUGGER_THREAD | CRST_TAKEN_DURING_SHUTDOWN)); - BaseDomain::Init(); + m_crstLoaderAllocatorReferences.Init(CrstLoaderAllocatorReferences); + m_MethodTableExposedClassObjectCrst.Init(CrstMethodTableExposedObject); // Set up the binding caches m_AssemblyCache.Init(&m_DomainCacheCrst, GetHighFrequencyHeap()); - m_MemoryPressure = 0; - - - // Default domain reuses the handletablemap that was created during EEStartup m_handleStore = GCHandleUtilities::GetGCHandleManager()->GetGlobalHandleStore(); - if (!m_handleStore) { COMPlusThrowOM(); } - #ifdef FEATURE_TYPEEQUIVALENCE m_TypeEquivalenceCrst.Init(CrstTypeEquivalenceMap); #endif @@ -1860,12 +1716,14 @@ void AppDomain::Init() SetStage(STAGE_READYFORMANAGEDCODE); - #ifdef FEATURE_TIERED_COMPILATION m_tieredCompilationManager.Init(); #endif m_nativeImageLoadCrst.Init(CrstNativeImageLoad); + + m_typeIDMap.Init(); + GetLoaderAllocator()->InitVirtualCallStubManager(); } // AppDomain::Init void AppDomain::Stop() @@ -1961,11 +1819,10 @@ BOOL AppDomain::ContainsAssembly(Assembly * assem) WRAPPER_NO_CONTRACT; AssemblyIterator i = IterateAssembliesEx((AssemblyIterationFlags)( kIncludeLoaded | kIncludeExecution)); - CollectibleAssemblyHolder pDomainAssembly; + CollectibleAssemblyHolder pAssembly; - while (i.Next(pDomainAssembly.This())) + while (i.Next(pAssembly.This())) { - CollectibleAssemblyHolder pAssembly = pDomainAssembly->GetAssembly(); if (pAssembly == assem) return TRUE; } @@ -2030,7 +1887,7 @@ DispIDCache* AppDomain::SetupRefDispIDCache() #endif // FEATURE_COMINTEROP -FileLoadLock *FileLoadLock::Create(PEFileListLock *pLock, PEAssembly * pPEAssembly, DomainAssembly *pDomainAssembly) +FileLoadLock *FileLoadLock::Create(PEFileListLock *pLock, PEAssembly * pPEAssembly, Assembly *pAssembly) { CONTRACTL { @@ -2043,7 +1900,7 @@ FileLoadLock *FileLoadLock::Create(PEFileListLock *pLock, PEAssembly * pPEAssemb } CONTRACTL_END; - NewHolder result(new FileLoadLock(pLock, pPEAssembly, pDomainAssembly)); + NewHolder result(new FileLoadLock(pLock, pPEAssembly, pAssembly)); pLock->AddElement(result); result->AddRef(); // Add one ref on behalf of the ListLock's reference. The corresponding Release() happens in FileLoadLock::CompleteLoadLevel. @@ -2063,10 +1920,10 @@ FileLoadLock::~FileLoadLock() ((PEAssembly *) m_data)->Release(); } -DomainAssembly *FileLoadLock::GetDomainAssembly() +Assembly *FileLoadLock::GetAssembly() { LIMITED_METHOD_CONTRACT; - return m_pDomainAssembly; + return m_pAssembly; } FileLoadLevel FileLoadLock::GetLoadLevel() @@ -2118,8 +1975,7 @@ static const char *fileLoadLevelName[] = { "CREATE", // FILE_LOAD_CREATE "BEGIN", // FILE_LOAD_BEGIN - "ALLOCATE", // FILE_LOAD_ALLOCATE - "POST_ALLOCATE", // FILE_LOAD_POST_ALLOCATE + "BEFORE_TYPE_LOAD", // FILE_LOAD_BEFORE_TYPE_LOAD "EAGER_FIXUPS", // FILE_LOAD_EAGER_FIXUPS "DELIVER_EVENTS", // FILE_LOAD_DELIVER_EVENTS "VTABLE FIXUPS", // FILE_LOAD_VTABLE_FIXUPS @@ -2143,7 +1999,7 @@ BOOL FileLoadLock::CompleteLoadLevel(FileLoadLevel level, BOOL success) if (level > m_level) { // Must complete each level in turn, unless we have an error - CONSISTENCY_CHECK(m_pDomainAssembly->IsError() || (level == (m_level+1))); + CONSISTENCY_CHECK(m_pAssembly->IsError() || (level == (m_level+1))); // Remove the lock from the list if the load is completed if (level >= FILE_ACTIVE) { @@ -2157,9 +2013,9 @@ BOOL FileLoadLock::CompleteLoadLevel(FileLoadLevel level, BOOL success) m_pList->Unlink(this); _ASSERTE(fDbgOnly_SuccessfulUnlink); - m_pDomainAssembly->ClearLoading(); + m_pAssembly->ClearLoading(); - CONSISTENCY_CHECK(m_dwRefCount >= 2); // Caller (LoadDomainAssembly) should have 1 refcount and m_pList should have another which was acquired in FileLoadLock::Create. + CONSISTENCY_CHECK(m_dwRefCount >= 2); // Caller (LoadAssembly) should have 1 refcount and m_pList should have another which was acquired in FileLoadLock::Create. m_level = (FileLoadLevel)level; @@ -2168,7 +2024,7 @@ BOOL FileLoadLock::CompleteLoadLevel(FileLoadLevel level, BOOL success) // we depend on the DomainAssembly's load level being up to date. Hence we must update the load // level while the m_pList lock is held. if (success) - m_pDomainAssembly->SetLoadLevel(level); + m_pAssembly->SetLoadLevel(level); } @@ -2180,17 +2036,16 @@ BOOL FileLoadLock::CompleteLoadLevel(FileLoadLevel level, BOOL success) m_level = (FileLoadLevel)level; if (success) - m_pDomainAssembly->SetLoadLevel(level); + m_pAssembly->SetLoadLevel(level); } #ifndef DACCESS_COMPILE switch(level) { - case FILE_LOAD_ALLOCATE: case FILE_LOAD_DELIVER_EVENTS: case FILE_LOADED: case FILE_ACTIVE: // The timing of stress logs is not critical, so even for the FILE_ACTIVE stage we need not do it while the m_pList lock is held. - STRESS_LOG3(LF_CLASSLOADER, LL_INFO100, "Completed Load Level %s for DomainAssembly %p - success = %i\n", fileLoadLevelName[level], m_pDomainAssembly, success); + STRESS_LOG3(LF_CLASSLOADER, LL_INFO100, "Completed Load Level %s for Assembly %p - success = %i\n", fileLoadLevelName[level], m_pAssembly, success); break; default: break; @@ -2219,9 +2074,9 @@ void FileLoadLock::SetError(Exception *ex) m_cachedHR = ex->GetHR(); LOG((LF_LOADER, LL_WARNING, "LOADER: ***%s*\t!!!Non-transient error 0x%x\n", - m_pDomainAssembly->GetSimpleName(), m_cachedHR)); + m_pAssembly->GetSimpleName(), m_cachedHR)); - m_pDomainAssembly->SetError(ex); + m_pAssembly->SetError(ex); CompleteLoadLevel(FILE_ACTIVE, FALSE); } @@ -2249,10 +2104,10 @@ UINT32 FileLoadLock::Release() return count; } -FileLoadLock::FileLoadLock(PEFileListLock *pLock, PEAssembly * pPEAssembly, DomainAssembly *pDomainAssembly) +FileLoadLock::FileLoadLock(PEFileListLock *pLock, PEAssembly * pPEAssembly, Assembly *pAssembly) : ListLockEntry(pLock, pPEAssembly, "File load lock"), m_level((FileLoadLevel) (FILE_LOAD_CREATE)), - m_pDomainAssembly(pDomainAssembly), + m_pAssembly(pAssembly), m_cachedHR(S_OK) { WRAPPER_NO_CONTRACT; @@ -2316,21 +2171,21 @@ void AppDomain::LoadSystemAssemblies() // thread has completed the load step. // -BOOL AppDomain::IsLoading(DomainAssembly *pFile, FileLoadLevel level) +BOOL AppDomain::IsLoading(Assembly *pAssembly, FileLoadLevel level) { // Cheap out - if (pFile->GetLoadLevel() < level) + if (pAssembly->GetLoadLevel() < level) { FileLoadLock *pLock = NULL; { LoadLockHolder lock(this); - pLock = (FileLoadLock *) lock->FindFileLock(pFile->GetPEAssembly()); + pLock = (FileLoadLock *) lock->FindFileLock(pAssembly->GetPEAssembly()); if (pLock == NULL) { // No thread involved with loading - return pFile->GetLoadLevel() >= level; + return pAssembly->GetLoadLevel() >= level; } pLock->AddRef(); @@ -2353,16 +2208,16 @@ BOOL AppDomain::IsLoading(DomainAssembly *pFile, FileLoadLevel level) // CheckLoading is a weaker form of IsLoading, which will not block on // other threads waiting for their status. This is appropriate for asserts. -CHECK AppDomain::CheckLoading(DomainAssembly *pFile, FileLoadLevel level) +CHECK AppDomain::CheckLoading(Assembly *pAssembly, FileLoadLevel level) { // Cheap out - if (pFile->GetLoadLevel() < level) + if (pAssembly->GetLoadLevel() < level) { FileLoadLock *pLock = NULL; LoadLockHolder lock(this); - pLock = (FileLoadLock *) lock->FindFileLock(pFile->GetPEAssembly()); + pLock = (FileLoadLock *) lock->FindFileLock(pAssembly->GetPEAssembly()); if (pLock != NULL && pLock->CanAcquire(level)) @@ -2419,7 +2274,7 @@ CHECK AppDomain::CheckCanExecuteManagedCode(MethodDesc* pMD) #endif // !DACCESS_COMPILE -void AppDomain::LoadDomainAssembly(DomainAssembly *pFile, +void AppDomain::LoadAssembly(Assembly *pAssembly, FileLoadLevel targetLevel) { CONTRACTL @@ -2432,26 +2287,26 @@ void AppDomain::LoadDomainAssembly(DomainAssembly *pFile, CONTRACTL_END; // Quick exit if finished - if (pFile->GetLoadLevel() >= targetLevel) + if (pAssembly->GetLoadLevel() >= targetLevel) return; // Handle the error case - pFile->ThrowIfError(targetLevel); + pAssembly->ThrowIfError(targetLevel); #ifndef DACCESS_COMPILE - if (pFile->IsLoading()) + if (pAssembly->IsLoading()) { GCX_PREEMP(); // Load some more if appropriate LoadLockHolder lock(this); - FileLoadLock* pLockEntry = (FileLoadLock *) lock->FindFileLock(pFile->GetPEAssembly()); + FileLoadLock* pLockEntry = (FileLoadLock *) lock->FindFileLock(pAssembly->GetPEAssembly()); if (pLockEntry == NULL) { - _ASSERTE (!pFile->IsLoading()); + _ASSERTE (!pAssembly->IsLoading()); return; } @@ -2459,7 +2314,7 @@ void AppDomain::LoadDomainAssembly(DomainAssembly *pFile, lock.Release(); - LoadDomainAssembly(pLockEntry, targetLevel); + LoadAssembly(pLockEntry, targetLevel); } #else // DACCESS_COMPILE @@ -2483,7 +2338,7 @@ namespace } } -Assembly *AppDomain::LoadAssembly(AssemblySpec* pIdentity, +Assembly *AppDomain::LoadAssembly(AssemblySpec* pSpec, PEAssembly * pPEAssembly, FileLoadLevel targetLevel) { @@ -2493,33 +2348,21 @@ Assembly *AppDomain::LoadAssembly(AssemblySpec* pIdentity, THROWS; MODE_ANY; PRECONDITION(CheckPointer(pPEAssembly)); - POSTCONDITION(CheckPointer(RETVAL, NULL_OK)); // May be NULL in recursive load case + POSTCONDITION(CheckPointer(RETVAL)); INJECT_FAULT(COMPlusThrowOM();); } CONTRACT_END; - DomainAssembly *pAssembly = LoadDomainAssembly(pIdentity, pPEAssembly, targetLevel); - PREFIX_ASSUME(pAssembly != NULL); - - RETURN pAssembly->GetAssembly(); -} - -DomainAssembly* AppDomain::LoadDomainAssembly(AssemblySpec* pSpec, - PEAssembly * pPEAssembly, - FileLoadLevel targetLevel) -{ - STATIC_CONTRACT_THROWS; - if (pSpec == nullptr) { // skip caching, since we don't have anything to base it on - return LoadDomainAssemblyInternal(pSpec, pPEAssembly, targetLevel); + RETURN LoadAssemblyInternal(pSpec, pPEAssembly, targetLevel); } - DomainAssembly* pRetVal = NULL; + Assembly* pRetVal = NULL; EX_TRY { - pRetVal = LoadDomainAssemblyInternal(pSpec, pPEAssembly, targetLevel); + pRetVal = LoadAssemblyInternal(pSpec, pPEAssembly, targetLevel); } EX_HOOK { @@ -2559,15 +2402,15 @@ DomainAssembly* AppDomain::LoadDomainAssembly(AssemblySpec* pSpec, } EX_END_HOOK; - return pRetVal; + RETURN pRetVal; } -DomainAssembly *AppDomain::LoadDomainAssemblyInternal(AssemblySpec* pIdentity, +Assembly *AppDomain::LoadAssemblyInternal(AssemblySpec* pIdentity, PEAssembly * pPEAssembly, FileLoadLevel targetLevel) { - CONTRACT(DomainAssembly *) + CONTRACT(Assembly *) { GC_TRIGGERS; THROWS; @@ -2583,7 +2426,7 @@ DomainAssembly *AppDomain::LoadDomainAssemblyInternal(AssemblySpec* pIdentity, CONTRACT_END; - DomainAssembly * result; + Assembly * result; // Go into preemptive mode since this may take a while. GCX_PREEMP(); @@ -2606,7 +2449,9 @@ DomainAssembly *AppDomain::LoadDomainAssemblyInternal(AssemblySpec* pIdentity, // Allocate the DomainAssembly a bit early to avoid GC mode problems. We could potentially avoid // a rare redundant allocation by moving this closer to FileLoadLock::Create, but it's not worth it. - NewHolder pDomainAssembly = new DomainAssembly(pPEAssembly, pLoaderAllocator); + AllocMemTracker amTracker; + AllocMemTracker *pamTracker = &amTracker; + NewHolder pDomainAssembly = new DomainAssembly(pPEAssembly, pLoaderAllocator, pamTracker); LoadLockHolder lock(this); @@ -2621,8 +2466,12 @@ DomainAssembly *AppDomain::LoadDomainAssemblyInternal(AssemblySpec* pIdentity, { // We are the first one in - create the DomainAssembly registerNewAssembly = true; - fileLock = FileLoadLock::Create(lock, pPEAssembly, pDomainAssembly); + fileLock = FileLoadLock::Create(lock, pPEAssembly, pDomainAssembly->GetAssembly()); pDomainAssembly.SuppressRelease(); + pamTracker->SuppressRelease(); + + // Set the assembly module to be tenured now that we know it won't be deleted + pDomainAssembly->GetAssembly()->SetIsTenured(); if (pDomainAssembly->IsCollectible()) { // We add the assembly to the LoaderAllocator only when we are sure that it can be added @@ -2640,12 +2489,12 @@ DomainAssembly *AppDomain::LoadDomainAssemblyInternal(AssemblySpec* pIdentity, if (result == NULL) { - // We pass our ref on fileLock to LoadDomainAssembly to release. + // We pass our ref on fileLock to LoadAssembly to release. // Note that if we throw here, we will poison fileLock with an error condition, // so it will not be removed until app domain unload. So there is no need // to release our ref count. - result = (DomainAssembly *)LoadDomainAssembly(fileLock, targetLevel); + result = LoadAssembly(fileLock, targetLevel); } else { @@ -2658,7 +2507,9 @@ DomainAssembly *AppDomain::LoadDomainAssemblyInternal(AssemblySpec* pIdentity, } } else + { result->EnsureLoadLevel(targetLevel); + } // Cache result in all cases, since found pPEAssembly could be from a different AssemblyRef than pIdentity if (pIdentity == NULL) @@ -2673,11 +2524,11 @@ DomainAssembly *AppDomain::LoadDomainAssemblyInternal(AssemblySpec* pIdentity, } RETURN result; -} // AppDomain::LoadDomainAssembly +} // AppDomain::LoadAssembly -DomainAssembly *AppDomain::LoadDomainAssembly(FileLoadLock *pLock, FileLoadLevel targetLevel) +Assembly *AppDomain::LoadAssembly(FileLoadLock *pLock, FileLoadLevel targetLevel) { - CONTRACT(DomainAssembly *) + CONTRACT(Assembly *) { STANDARD_VM_CHECK; PRECONDITION(CheckPointer(pLock)); @@ -2688,7 +2539,7 @@ DomainAssembly *AppDomain::LoadDomainAssembly(FileLoadLock *pLock, FileLoadLevel } CONTRACT_END; - DomainAssembly *pFile = pLock->GetDomainAssembly(); + Assembly *pAssembly = pLock->GetAssembly(); // Make sure we release the lock on exit FileLoadLockRefHolder lockRef(pLock); @@ -2696,9 +2547,9 @@ DomainAssembly *AppDomain::LoadDomainAssembly(FileLoadLock *pLock, FileLoadLevel // Do a quick out check for the already loaded case. if (pLock->GetLoadLevel() >= targetLevel) { - pFile->ThrowIfError(targetLevel); + pAssembly->ThrowIfError(targetLevel); - RETURN pFile; + RETURN pAssembly; } // Initialize a loading queue. This will hold any loads which are triggered recursively but @@ -2719,7 +2570,7 @@ DomainAssembly *AppDomain::LoadDomainAssembly(FileLoadLock *pLock, FileLoadLevel immediateTargetLevel = limit.GetLoadLevel(); LOG((LF_LOADER, LL_INFO100, "LOADER: ***%s*\t>>>Load initiated, %s/%s\n", - pFile->GetSimpleName(), + pAssembly->GetSimpleName(), fileLoadLevelName[immediateTargetLevel], fileLoadLevelName[targetLevel])); // Now loop and do the load incrementally to the target level. @@ -2746,28 +2597,28 @@ DomainAssembly *AppDomain::LoadDomainAssembly(FileLoadLock *pLock, FileLoadLevel || workLevel == FILE_ACTIVE) ? LL_INFO10 : LL_INFO1000, "LOADER: %p:***%s*\t loading at level %s\n", - this, pFile->GetSimpleName(), fileLoadLevelName[workLevel])); + this, pAssembly->GetSimpleName(), fileLoadLevelName[workLevel])); - TryIncrementalLoad(pFile, workLevel, fileLock); + TryIncrementalLoad(pAssembly, workLevel, fileLock); } } if (pLock->GetLoadLevel() == immediateTargetLevel-1) { LOG((LF_LOADER, LL_INFO100, "LOADER: ***%s*\t<<GetSimpleName(), + pAssembly->GetSimpleName(), fileLoadLevelName[immediateTargetLevel-1])); } } LOG((LF_LOADER, LL_INFO100, "LOADER: ***%s*\t<<GetSimpleName(), + pAssembly->GetSimpleName(), fileLoadLevelName[pLock->GetLoadLevel()])); } // There may have been an error stored on the domain file by another thread, or from a previous load - pFile->ThrowIfError(targetLevel); + pAssembly->ThrowIfError(targetLevel); // There are two normal results from the above loop. // @@ -2785,13 +2636,11 @@ DomainAssembly *AppDomain::LoadDomainAssembly(FileLoadLock *pLock, FileLoadLevel // (An alternate, and possibly preferable, strategy here would be for all callers to explicitly // specify the minimum load level acceptable and throw if not reached.) - pFile->RequireLoadLevel((FileLoadLevel)(immediateTargetLevel-1)); - - - RETURN pFile; + pAssembly->RequireLoadLevel((FileLoadLevel)(immediateTargetLevel-1)); + RETURN pAssembly; } -void AppDomain::TryIncrementalLoad(DomainAssembly *pFile, FileLoadLevel workLevel, FileLoadLockHolder &lockHolder) +void AppDomain::TryIncrementalLoad(Assembly *pAssembly, FileLoadLevel workLevel, FileLoadLockHolder &lockHolder) { STANDARD_VM_CONTRACT; @@ -2803,7 +2652,7 @@ void AppDomain::TryIncrementalLoad(DomainAssembly *pFile, FileLoadLevel workLeve EX_TRY { // Do the work - BOOL success = pFile->DoIncrementalLoad(workLevel); + BOOL success = pAssembly->DoIncrementalLoad(workLevel); // Complete the level. if (pLoadLock->CompleteLoadLevel(workLevel, success) && @@ -2811,7 +2660,7 @@ void AppDomain::TryIncrementalLoad(DomainAssembly *pFile, FileLoadLevel workLeve { lockHolder.Release(); released = TRUE; - pFile->DeliverAsyncEvents(); + pAssembly->DeliverAsyncEvents(); }; } EX_HOOK @@ -2820,7 +2669,7 @@ void AppDomain::TryIncrementalLoad(DomainAssembly *pFile, FileLoadLevel workLeve //We will cache this error and wire this load to forever fail, // unless the exception is transient or the file is loaded OK but just cannot execute - if (!pEx->IsTransient() && !pFile->IsLoaded()) + if (!pEx->IsTransient() && !pAssembly->IsLoaded()) { if (released) { @@ -2841,7 +2690,7 @@ void AppDomain::TryIncrementalLoad(DomainAssembly *pFile, FileLoadLevel workLeve } if (!EEFileLoadException::CheckType(pEx)) - EEFileLoadException::Throw(pFile->GetPEAssembly(), pEx->GetHR(), pEx); + EEFileLoadException::Throw(pAssembly->GetPEAssembly(), pEx->GetHR(), pEx); } // Otherwise, we simply abort this load, and can retry later on. @@ -2900,7 +2749,7 @@ void AppDomain::SetupSharedStatics() SetObjectReference( pEmptyStringHandle, StringObject::GetEmptyString()); } -DomainAssembly * AppDomain::FindAssembly(PEAssembly * pPEAssembly, FindAssemblyOptions options/* = FindAssemblyOptions_None*/) +Assembly * AppDomain::FindAssembly(PEAssembly * pPEAssembly, FindAssemblyOptions options/* = FindAssemblyOptions_None*/) { CONTRACTL { @@ -2914,10 +2763,10 @@ DomainAssembly * AppDomain::FindAssembly(PEAssembly * pPEAssembly, FindAssemblyO if (pPEAssembly->HasHostAssembly()) { - DomainAssembly * pDA = pPEAssembly->GetHostAssembly()->GetDomainAssembly(); - if (pDA != nullptr && (pDA->IsLoaded() || (includeFailedToLoad && pDA->IsError()))) + Assembly * pAssembly = pPEAssembly->GetHostAssembly()->GetRuntimeAssembly(); + if (pAssembly != nullptr && (pAssembly->IsLoaded() || (includeFailedToLoad && pAssembly->IsError()))) { - return pDA; + return pAssembly; } return nullptr; } @@ -2926,21 +2775,21 @@ DomainAssembly * AppDomain::FindAssembly(PEAssembly * pPEAssembly, FindAssemblyO kIncludeLoaded | (includeFailedToLoad ? kIncludeFailedToLoad : 0) | kIncludeExecution)); - CollectibleAssemblyHolder pDomainAssembly; + CollectibleAssemblyHolder pAssembly; - while (i.Next(pDomainAssembly.This())) + while (i.Next(pAssembly.This())) { - PEAssembly * pManifestFile = pDomainAssembly->GetPEAssembly(); + PEAssembly * pManifestFile = pAssembly->GetPEAssembly(); if (pManifestFile && pManifestFile->Equals(pPEAssembly)) { - return pDomainAssembly.GetValue(); + return pAssembly; } } return NULL; } -void AppDomain::SetFriendlyName(LPCWSTR pwzFriendlyName, BOOL fDebuggerCares/*=TRUE*/) +void AppDomain::SetFriendlyName(LPCWSTR pwzFriendlyName) { CONTRACTL { @@ -2958,29 +2807,15 @@ void AppDomain::SetFriendlyName(LPCWSTR pwzFriendlyName, BOOL fDebuggerCares/*=T if (pwzFriendlyName) tmpFriendlyName.Set(pwzFriendlyName); else - { - // If there is an assembly, try to get the name from it. - // If no assembly, but if it's the DefaultDomain, then give it a name - - if (m_pRootAssembly) - { - tmpFriendlyName.SetUTF8(m_pRootAssembly->GetSimpleName()); - - SString::Iterator i = tmpFriendlyName.End(); - if (tmpFriendlyName.FindBack(i, '.')) - tmpFriendlyName.Truncate(i); - } - else - { - tmpFriendlyName.Set(DEFAULT_DOMAIN_FRIENDLY_NAME); - } - } + tmpFriendlyName.Set(DEFAULT_DOMAIN_FRIENDLY_NAME); tmpFriendlyName.Normalize(); + // This happens at most twice in a process, so don't worry about freeing the old one. + LPWSTR newFriendlyName = new WCHAR[tmpFriendlyName.GetCount() + 1]; + u16_strcpy_s(newFriendlyName, tmpFriendlyName.GetCount() + 1, tmpFriendlyName.GetUnicode()); - m_friendlyName = tmpFriendlyName; - m_friendlyName.Normalize(); + m_friendlyName = newFriendlyName; if(g_pDebugInterface) { @@ -2988,42 +2823,32 @@ void AppDomain::SetFriendlyName(LPCWSTR pwzFriendlyName, BOOL fDebuggerCares/*=T if (SUCCEEDED(g_pDebugInterface->UpdateAppDomainEntryInIPC(this))) { // inform the attached debugger that the name of this appdomain has changed. - if (IsDebuggerAttached() && fDebuggerCares) + if (IsDebuggerAttached()) g_pDebugInterface->NameChangeEvent(this, NULL); } } } +#endif // !DACCESS_COMPILE -LPCWSTR AppDomain::GetFriendlyName(BOOL fDebuggerCares/*=TRUE*/) +LPCWSTR AppDomain::GetFriendlyName() { CONTRACT (LPCWSTR) { - THROWS; - if (GetThreadNULLOk()) {GC_TRIGGERS;} else {DISABLED(GC_NOTRIGGER);} + NOTHROW; + GC_NOTRIGGER; MODE_ANY; POSTCONDITION(CheckPointer(RETVAL, NULL_OK)); INJECT_FAULT(COMPlusThrowOM();); } CONTRACT_END; - if (m_friendlyName.IsEmpty()) - SetFriendlyName(NULL, fDebuggerCares); + if (m_friendlyName == NULL) + RETURN DEFAULT_DOMAIN_FRIENDLY_NAME; - RETURN m_friendlyName; + RETURN (LPCWSTR)m_friendlyName; } -LPCWSTR AppDomain::GetFriendlyNameForLogging() -{ - CONTRACT(LPCWSTR) - { - NOTHROW; - GC_NOTRIGGER; - MODE_ANY; - POSTCONDITION(CheckPointer(RETVAL,NULL_OK)); - } - CONTRACT_END; - RETURN (m_friendlyName.IsEmpty() ?W(""):(LPCWSTR)m_friendlyName); -} +#ifndef DACCESS_COMPILE LPCWSTR AppDomain::GetFriendlyNameForDebugger() { @@ -3037,7 +2862,7 @@ LPCWSTR AppDomain::GetFriendlyNameForDebugger() CONTRACT_END; - if (m_friendlyName.IsEmpty()) + if (m_friendlyName == NULL) { BOOL fSuccess = FALSE; @@ -3065,36 +2890,6 @@ LPCWSTR AppDomain::GetFriendlyNameForDebugger() #endif // !DACCESS_COMPILE -#ifdef DACCESS_COMPILE - -PVOID AppDomain::GetFriendlyNameNoSet(bool* isUtf8) -{ - SUPPORTS_DAC; - - if (!m_friendlyName.IsEmpty()) - { - *isUtf8 = false; - return m_friendlyName.DacGetRawContent(); - } - else if (m_pRootAssembly) - { - *isUtf8 = true; - return (PVOID)m_pRootAssembly->GetSimpleName(); - } - else if (dac_cast(this) == - dac_cast(SystemDomain::System()->DefaultDomain())) - { - *isUtf8 = false; - return (PVOID)DEFAULT_DOMAIN_FRIENDLY_NAME; - } - else - { - return NULL; - } -} - -#endif // DACCESS_COMPILE - #ifndef DACCESS_COMPILE BOOL AppDomain::AddFileToCache(AssemblySpec* pSpec, PEAssembly * pPEAssembly) @@ -3115,7 +2910,7 @@ BOOL AppDomain::AddFileToCache(AssemblySpec* pSpec, PEAssembly * pPEAssembly) return m_AssemblyCache.StorePEAssembly(pSpec, pPEAssembly); } -BOOL AppDomain::AddAssemblyToCache(AssemblySpec* pSpec, DomainAssembly *pAssembly) +BOOL AppDomain::AddAssemblyToCache(AssemblySpec* pSpec, Assembly *pAssembly) { CONTRACTL { @@ -3232,7 +3027,7 @@ BOOL AppDomain::RemoveFileFromCache(PEAssembly * pPEAssembly) return TRUE; } -BOOL AppDomain::RemoveAssemblyFromCache(DomainAssembly* pAssembly) +BOOL AppDomain::RemoveAssemblyFromCache(Assembly* pAssembly) { CONTRACTL { @@ -3585,7 +3380,7 @@ ULONG AppDomain::Release() -void AppDomain::RaiseLoadingAssemblyEvent(DomainAssembly *pAssembly) +void AppDomain::RaiseLoadingAssemblyEvent(Assembly *pAssembly) { CONTRACTL { @@ -3617,7 +3412,7 @@ void AppDomain::RaiseLoadingAssemblyEvent(DomainAssembly *pAssembly) ARG_SLOT args[1]; GCPROTECT_BEGIN(gc); - gc.orThis = pAssembly->GetExposedAssemblyObject(); + gc.orThis = pAssembly->GetExposedObject(); MethodDescCallSite onAssemblyLoad(METHOD__ASSEMBLYLOADCONTEXT__ON_ASSEMBLY_LOAD); @@ -3783,10 +3578,10 @@ BOOL AppDomain::NotifyDebuggerLoad(int flags, BOOL attaching) // Attach to our assemblies LOG((LF_CORDB, LL_INFO100, "AD::NDA: Iterating assemblies\n")); i = IterateAssembliesEx((AssemblyIterationFlags)(kIncludeLoaded | kIncludeLoading | kIncludeExecution)); - CollectibleAssemblyHolder pDomainAssembly; - while (i.Next(pDomainAssembly.This())) + CollectibleAssemblyHolder pAssembly; + while (i.Next(pAssembly.This())) { - result = (pDomainAssembly->NotifyDebuggerLoad(flags, attaching) || + result = (pAssembly->NotifyDebuggerLoad(flags, attaching) || result); } @@ -3803,13 +3598,13 @@ void AppDomain::NotifyDebuggerUnload() LOG((LF_CORDB, LL_INFO100, "AD::NDD: Interating domain bound assemblies\n")); AssemblyIterator i = IterateAssembliesEx((AssemblyIterationFlags)(kIncludeLoaded | kIncludeLoading | kIncludeExecution)); - CollectibleAssemblyHolder pDomainAssembly; + CollectibleAssemblyHolder pAssembly; // Detach from our assemblies - while (i.Next(pDomainAssembly.This())) + while (i.Next(pAssembly.This())) { LOG((LF_CORDB, LL_INFO100, "AD::NDD: Iterating assemblies\n")); - pDomainAssembly->NotifyDebuggerUnload(); + pAssembly->NotifyDebuggerUnload(); } } #endif // DEBUGGING_SUPPORTED @@ -3865,11 +3660,13 @@ RCWCache *AppDomain::CreateRCWCache() } _ASSERTE(g_pRCWCleanupList); + if (!m_pRCWCache) { - BaseDomain::LockHolder lh(this); - - if (!m_pRCWCache) - m_pRCWCache = new RCWCache(this); + NewHolder pRCWCache = new RCWCache(this); + if (InterlockedCompareExchangeT(&m_pRCWCache, (RCWCache *)pRCWCache, NULL) == NULL) + { + pRCWCache.SuppressRelease(); + } } RETURN m_pRCWCache; @@ -4166,14 +3963,14 @@ void AppDomain::EnumStaticGCRefs(promote_func* fn, ScanContext* sc) #endif // !DACCESS_COMPILE //------------------------------------------------------------------------ -PTR_LoaderAllocator BaseDomain::GetLoaderAllocator() +PTR_LoaderAllocator AppDomain::GetLoaderAllocator() { WRAPPER_NO_CONTRACT; return SystemDomain::GetGlobalLoaderAllocator(); // The one and only domain is not unloadable } //------------------------------------------------------------------------ -UINT32 BaseDomain::GetTypeID(PTR_MethodTable pMT) { +UINT32 AppDomain::GetTypeID(PTR_MethodTable pMT) { CONTRACTL { THROWS; GC_TRIGGERS; @@ -4184,7 +3981,7 @@ UINT32 BaseDomain::GetTypeID(PTR_MethodTable pMT) { //------------------------------------------------------------------------ // Returns the ID of the type if found. If not found, returns INVALID_TYPE_ID -UINT32 BaseDomain::LookupTypeID(PTR_MethodTable pMT) +UINT32 AppDomain::LookupTypeID(PTR_MethodTable pMT) { CONTRACTL { NOTHROW; @@ -4195,7 +3992,7 @@ UINT32 BaseDomain::LookupTypeID(PTR_MethodTable pMT) } //------------------------------------------------------------------------ -PTR_MethodTable BaseDomain::LookupType(UINT32 id) { +PTR_MethodTable AppDomain::LookupType(UINT32 id) { CONTRACTL { NOTHROW; WRAPPER(GC_TRIGGERS); @@ -4211,7 +4008,7 @@ PTR_MethodTable BaseDomain::LookupType(UINT32 id) { #ifndef DACCESS_COMPILE //--------------------------------------------------------------------------------------- -void BaseDomain::RemoveTypesFromTypeIDMap(LoaderAllocator* pLoaderAllocator) +void AppDomain::RemoveTypesFromTypeIDMap(LoaderAllocator* pLoaderAllocator) { CONTRACTL { NOTHROW; @@ -4226,7 +4023,7 @@ void BaseDomain::RemoveTypesFromTypeIDMap(LoaderAllocator* pLoaderAllocator) // BOOL AppDomain::AssemblyIterator::Next( - CollectibleAssemblyHolder * pDomainAssemblyHolder) + CollectibleAssemblyHolder * pAssemblyHolder) { CONTRACTL { NOTHROW; @@ -4235,7 +4032,7 @@ AppDomain::AssemblyIterator::Next( } CONTRACTL_END; CrstHolder ch(m_pAppDomain->GetAssemblyListLock()); - return Next_Unlocked(pDomainAssemblyHolder); + return Next_Unlocked(pAssemblyHolder); } //--------------------------------------------------------------------------------------- @@ -4244,7 +4041,7 @@ AppDomain::AssemblyIterator::Next( // BOOL AppDomain::AssemblyIterator::Next_Unlocked( - CollectibleAssemblyHolder * pDomainAssemblyHolder) + CollectibleAssemblyHolder * pAssemblyHolder) { CONTRACTL { NOTHROW; @@ -4265,20 +4062,21 @@ AppDomain::AssemblyIterator::Next_Unlocked( continue; } - if (pDomainAssembly->IsError()) + Assembly* pAssembly = pDomainAssembly->GetAssembly(); + if (pAssembly->IsError()) { if (m_assemblyIterationFlags & kIncludeFailedToLoad) { - *pDomainAssemblyHolder = pDomainAssembly; + *pAssemblyHolder = pAssembly; return TRUE; } continue; // reject } - // First, reject DomainAssemblies whose load status is not to be included in + // First, reject assemblies whose load status is not to be included in // the enumeration - if (pDomainAssembly->IsAvailableToProfilers() && + if (pAssembly->IsAvailableToProfilers() && (m_assemblyIterationFlags & kIncludeAvailableToProfilers)) { // The assembly has reached the state at which we would notify profilers, @@ -4288,7 +4086,7 @@ AppDomain::AssemblyIterator::Next_Unlocked( // kIncludeAvailableToProfilers contains some loaded AND loading // assemblies. } - else if (pDomainAssembly->IsLoaded()) + else if (pAssembly->IsLoaded()) { // A loaded assembly if (!(m_assemblyIterationFlags & kIncludeLoaded)) @@ -4305,7 +4103,7 @@ AppDomain::AssemblyIterator::Next_Unlocked( } } - // Next, reject DomainAssemblies whose execution status is + // Next, reject assemblies whose execution status is // not to be included in the enumeration // execution assembly @@ -4315,7 +4113,7 @@ AppDomain::AssemblyIterator::Next_Unlocked( } // Next, reject collectible assemblies - if (pDomainAssembly->IsCollectible()) + if (pAssembly->IsCollectible()) { if (m_assemblyIterationFlags & kExcludeCollectible) { @@ -4326,19 +4124,19 @@ AppDomain::AssemblyIterator::Next_Unlocked( // Un-tenured collectible assemblies should not be returned. (This can only happen in a brief // window during collectible assembly creation. No thread should need to have a pointer // to the just allocated DomainAssembly at this stage.) - if (!pDomainAssembly->GetAssembly()->GetModule()->IsTenured()) + if (!pAssembly->GetModule()->IsTenured()) { continue; // reject } - if (pDomainAssembly->GetLoaderAllocator()->AddReferenceIfAlive()) + if (pAssembly->GetLoaderAllocator()->AddReferenceIfAlive()) { // The assembly is alive // Set the holder value (incl. increasing ref-count) - *pDomainAssemblyHolder = pDomainAssembly; + *pAssemblyHolder = pAssembly; // Now release the reference we took in the if-condition - pDomainAssembly->GetLoaderAllocator()->Release(); + pAssembly->GetLoaderAllocator()->Release(); return TRUE; } // The assembly is not alive anymore (and we didn't increase its ref-count in the @@ -4350,15 +4148,15 @@ AppDomain::AssemblyIterator::Next_Unlocked( } // Set the holder value to assembly with 0 ref-count without increasing the ref-count (won't // call Release either) - pDomainAssemblyHolder->Assign(pDomainAssembly, FALSE); + pAssemblyHolder->Assign(pAssembly, FALSE); return TRUE; } - *pDomainAssemblyHolder = pDomainAssembly; + *pAssemblyHolder = pAssembly; return TRUE; } - *pDomainAssemblyHolder = NULL; + *pAssemblyHolder = NULL; return FALSE; } // AppDomain::AssemblyIterator::Next_Unlocked @@ -4519,26 +4317,11 @@ HRESULT RuntimeInvokeHostAssemblyResolver(INT_PTR pManagedAssemblyLoadContextToB // We were able to get the assembly loaded. Now, get its name since the host could have // performed the resolution using an assembly with different name. - DomainAssembly *pDomainAssembly = _gcRefs.oRefLoadedAssembly->GetDomainAssembly(); - PEAssembly *pLoadedPEAssembly = NULL; - bool fFailLoad = false; - if (!pDomainAssembly) - { - // Reflection emitted assemblies will not have a domain assembly. - fFailLoad = true; - } - else - { - pLoadedPEAssembly = pDomainAssembly->GetPEAssembly(); - if (!pLoadedPEAssembly->HasHostAssembly()) - { - // Reflection emitted assemblies will not have a domain assembly. - fFailLoad = true; - } - } + Assembly *pAssembly = _gcRefs.oRefLoadedAssembly->GetAssembly(); + _ASSERTE(pAssembly != NULL); - // The loaded assembly's BINDER_SPACE::Assembly* is saved as HostAssembly in PEAssembly - if (fFailLoad) + // Disallow reflection emitted assemblies returned in assembly resolution extension points + if (pAssembly->IsDynamic()) { PathString name; pAssemblyName->GetDisplayName(name, BINDER_SPACE::AssemblyName::INCLUDE_ALL); @@ -4547,9 +4330,9 @@ HRESULT RuntimeInvokeHostAssemblyResolver(INT_PTR pManagedAssemblyLoadContextToB // For collectible assemblies, ensure that the parent loader allocator keeps the assembly's loader allocator // alive for all its lifetime. - if (pDomainAssembly->IsCollectible()) + if (pAssembly->IsCollectible()) { - LoaderAllocator *pResultAssemblyLoaderAllocator = pDomainAssembly->GetLoaderAllocator(); + LoaderAllocator *pResultAssemblyLoaderAllocator = pAssembly->GetLoaderAllocator(); LoaderAllocator *pParentLoaderAllocator = pBinder->GetLoaderAllocator(); if (pParentLoaderAllocator == NULL) { @@ -4561,7 +4344,7 @@ HRESULT RuntimeInvokeHostAssemblyResolver(INT_PTR pManagedAssemblyLoadContextToB pParentLoaderAllocator->EnsureReference(pResultAssemblyLoaderAllocator); } - pResolvedAssembly = pLoadedPEAssembly->GetHostAssembly(); + pResolvedAssembly = pAssembly->GetPEAssembly()->GetHostAssembly(); } if (fResolvedAssembly) @@ -4623,14 +4406,14 @@ AppDomain::EnumMemoryRegions(CLRDataEnumMemoryFlags flags, bool enumThis) if (enumThis) { //sizeof(AppDomain) == 0xeb0 - DAC_ENUM_VTHIS(); + DAC_ENUM_DTHIS(); EMEM_OUT(("MEM: %p AppDomain\n", dac_cast(this))); } // We don't need AppDomain name in triage dumps. if (flags != CLRDATA_ENUM_MEM_TRIAGE) { - m_friendlyName.EnumMemoryRegions(flags); + m_friendlyName.EnumMem(); } if (flags == CLRDATA_ENUM_MEM_HEAP2) @@ -4640,11 +4423,11 @@ AppDomain::EnumMemoryRegions(CLRDataEnumMemoryFlags flags, bool enumThis) m_Assemblies.EnumMemoryRegions(flags); AssemblyIterator assem = IterateAssembliesEx((AssemblyIterationFlags)(kIncludeLoaded | kIncludeExecution)); - CollectibleAssemblyHolder pDomainAssembly; + CollectibleAssemblyHolder pAssembly; - while (assem.Next(pDomainAssembly.This())) + while (assem.Next(pAssembly.This())) { - pDomainAssembly->EnumMemoryRegions(flags); + pAssembly->GetDomainAssembly()->EnumMemoryRegions(flags); } } @@ -4654,13 +4437,13 @@ SystemDomain::EnumMemoryRegions(CLRDataEnumMemoryFlags flags, bool enumThis) SUPPORTS_DAC; if (enumThis) { - DAC_ENUM_VTHIS(); + DAC_ENUM_DTHIS(); EMEM_OUT(("MEM: %p SystemAppomain\n", dac_cast(this))); } if (flags == CLRDATA_ENUM_MEM_HEAP2) { - GetLoaderAllocator()->EnumMemoryRegions(flags); + GetGlobalLoaderAllocator()->EnumMemoryRegions(flags); } if (m_pSystemPEAssembly.IsValid()) { diff --git a/src/coreclr/vm/appdomain.hpp b/src/coreclr/vm/appdomain.hpp index 7bf26952da8..248d37f203a 100644 --- a/src/coreclr/vm/appdomain.hpp +++ b/src/coreclr/vm/appdomain.hpp @@ -35,13 +35,11 @@ #include "codeversion.h" -class BaseDomain; class SystemDomain; class AppDomain; class GlobalStringLiteralMap; class StringLiteralMap; class FrozenObjectHeapManager; -class MngStdInterfacesInfo; class DomainAssembly; class TypeEquivalenceHashTable; @@ -69,7 +67,7 @@ class PinnedHeapHandleBucket { public: // Constructor and desctructor. - PinnedHeapHandleBucket(PinnedHeapHandleBucket *pNext, PTRARRAYREF pinnedHandleArrayObj, DWORD size, BaseDomain *pDomain); + PinnedHeapHandleBucket(PinnedHeapHandleBucket *pNext, PTRARRAYREF pinnedHandleArrayObj, DWORD size); ~PinnedHeapHandleBucket(); // This returns the next bucket. @@ -124,7 +122,7 @@ class PinnedHeapHandleTable { public: // Constructor and desctructor. - PinnedHeapHandleTable(BaseDomain *pDomain, DWORD InitialBucketSize); + PinnedHeapHandleTable(DWORD InitialBucketSize); ~PinnedHeapHandleTable(); // Allocate handles from the pinned heap handle table. @@ -142,9 +140,6 @@ class PinnedHeapHandleTable // synchronized by m_Crst PinnedHeapHandleBucket *m_pHead; - // We need to know the containing domain so we know where to allocate handles - BaseDomain *m_pDomain; - // The size of the PinnedHeapHandleBucket. // synchronized by m_Crst DWORD m_NextBucketSize; @@ -310,15 +305,15 @@ typedef PEFileListLock::Holder PEFileListLockHolder; class FileLoadLock : public ListLockEntry { private: - FileLoadLevel m_level; - DomainAssembly *m_pDomainAssembly; - HRESULT m_cachedHR; + FileLoadLevel m_level; + Assembly* m_pAssembly; + HRESULT m_cachedHR; public: - static FileLoadLock *Create(PEFileListLock *pLock, PEAssembly *pPEAssembly, DomainAssembly *pDomainAssembly); + static FileLoadLock *Create(PEFileListLock *pLock, PEAssembly *pPEAssembly, Assembly *pAssembly); ~FileLoadLock(); - DomainAssembly *GetDomainAssembly(); + Assembly *GetAssembly(); FileLoadLevel GetLoadLevel(); // CanAcquire will return FALSE if Acquire will definitely not take the lock due @@ -345,7 +340,7 @@ class FileLoadLock : public ListLockEntry private: - FileLoadLock(PEFileListLock *pLock, PEAssembly *pPEAssembly, DomainAssembly *pDomainAssembly); + FileLoadLock(PEFileListLock *pLock, PEAssembly *pPEAssembly, Assembly *pAssembly); static void HolderLeave(FileLoadLock *pThis); @@ -423,379 +418,21 @@ class LoadLevelLimiter final void SetLoadLevel(FileLoadLevel level) { - LIMITED_METHOD_CONTRACT; - m_currentLevel = level; - } - - static LoadLevelLimiter* GetCurrent() - { - LIMITED_METHOD_CONTRACT; - return t_currentLoadLevelLimiter; - } -}; - -#define OVERRIDE_LOAD_LEVEL_LIMIT(newLimit) \ - LoadLevelLimiter __newLimit; \ - __newLimit.Activate(); \ - __newLimit.SetLoadLevel(newLimit); - -// A BaseDomain much basic information in a code:AppDomain including -// -// * code:#AppdomainHeaps - Heaps for any data structures that will be freed on appdomain unload -// -class BaseDomain -{ - friend class Assembly; - friend class AssemblySpec; - friend class AppDomain; - - VPTR_BASE_VTABLE_CLASS(BaseDomain) - VPTR_UNIQUE(VPTR_UNIQUE_BaseDomain) - -public: - - class AssemblyIterator; - friend class AssemblyIterator; - - // Static initialization. - static void Attach(); - - //**************************************************************************************** - // - // Initialization/shutdown routines for every instance of an BaseDomain. - - BaseDomain(); - virtual ~BaseDomain() {} - void Init(); - void Stop(); - - virtual BOOL IsAppDomain() { LIMITED_METHOD_DAC_CONTRACT; return FALSE; } - - PTR_LoaderAllocator GetLoaderAllocator(); - virtual PTR_AppDomain AsAppDomain() - { - LIMITED_METHOD_CONTRACT; - _ASSERTE(!"Not an AppDomain"); - return NULL; - } - -#ifdef FEATURE_COMINTEROP - MngStdInterfacesInfo * GetMngStdInterfacesInfo() - { - LIMITED_METHOD_CONTRACT; - - return m_pMngStdInterfacesInfo; - } -#endif // FEATURE_COMINTEROP - //**************************************************************************************** - // Get the class init lock. The method is limited to friends because inappropriate use - // will cause deadlocks in the system - ListLock* GetClassInitLock() - { - LIMITED_METHOD_CONTRACT; - - return &m_ClassInitLock; - } - - JitListLock* GetJitLock() - { - LIMITED_METHOD_CONTRACT; - return &m_JITLock; - } - - ListLock* GetILStubGenLock() - { - LIMITED_METHOD_CONTRACT; - return &m_ILStubGenLock; - } - - ListLock* GetNativeTypeLoadLock() - { - LIMITED_METHOD_CONTRACT; - return &m_NativeTypeLoadLock; - } - - STRINGREF *IsStringInterned(STRINGREF *pString); - STRINGREF *GetOrInternString(STRINGREF *pString); - - // Returns an array of OBJECTREF* that can be used to store domain specific data. - // Statics and reflection info (Types, MemberInfo,..) are stored this way - // If pStaticsInfo != 0, allocation will only take place if GC statics in the DynamicStaticsInfo are NULL (and the allocation - // will be properly serialized) - OBJECTREF *AllocateObjRefPtrsInLargeTable(int nRequested, DynamicStaticsInfo* pStaticsInfo = NULL, MethodTable *pMTToFillWithStaticBoxes = NULL, bool isClassInitdeByUpdatingStaticPointer = false); - - //**************************************************************************************** - // Handles - -#if !defined(DACCESS_COMPILE) - IGCHandleStore* GetHandleStore() - { - LIMITED_METHOD_CONTRACT; - return m_handleStore; - } - - OBJECTHANDLE CreateTypedHandle(OBJECTREF object, HandleType type) - { - WRAPPER_NO_CONTRACT; - return ::CreateHandleCommon(m_handleStore, object, type); - } - - OBJECTHANDLE CreateHandle(OBJECTREF object) - { - WRAPPER_NO_CONTRACT; - CONDITIONAL_CONTRACT_VIOLATION(ModeViolation, object == NULL) - return ::CreateHandle(m_handleStore, object); - } - - OBJECTHANDLE CreateWeakHandle(OBJECTREF object) - { - WRAPPER_NO_CONTRACT; - return ::CreateWeakHandle(m_handleStore, object); - } - - OBJECTHANDLE CreateShortWeakHandle(OBJECTREF object) - { - WRAPPER_NO_CONTRACT; - return ::CreateShortWeakHandle(m_handleStore, object); - } - - OBJECTHANDLE CreateLongWeakHandle(OBJECTREF object) - { - WRAPPER_NO_CONTRACT; - CONDITIONAL_CONTRACT_VIOLATION(ModeViolation, object == NULL) - return ::CreateLongWeakHandle(m_handleStore, object); - } - - OBJECTHANDLE CreateStrongHandle(OBJECTREF object) - { - WRAPPER_NO_CONTRACT; - return ::CreateStrongHandle(m_handleStore, object); - } - - OBJECTHANDLE CreatePinningHandle(OBJECTREF object) - { - WRAPPER_NO_CONTRACT; - return ::CreatePinningHandle(m_handleStore, object); - } - - OBJECTHANDLE CreateWeakInteriorHandle(OBJECTREF object, void* pInteriorPointerLocation) - { - WRAPPER_NO_CONTRACT; - return ::CreateWeakInteriorHandle(m_handleStore, object, pInteriorPointerLocation); - } - - OBJECTHANDLE CreateSizedRefHandle(OBJECTREF object) - { - WRAPPER_NO_CONTRACT; - OBJECTHANDLE h; - if (GCHeapUtilities::IsServerHeap()) - { - h = ::CreateSizedRefHandle(m_handleStore, object, m_dwSizedRefHandles % m_iNumberOfProcessors); - } - else - { - h = ::CreateSizedRefHandle(m_handleStore, object); - } - - InterlockedIncrement((LONG*)&m_dwSizedRefHandles); - return h; - } - -#if defined(FEATURE_COMINTEROP) || defined(FEATURE_COMWRAPPERS) - OBJECTHANDLE CreateRefcountedHandle(OBJECTREF object) - { - WRAPPER_NO_CONTRACT; - return ::CreateRefcountedHandle(m_handleStore, object); - } -#endif // FEATURE_COMINTEROP || FEATURE_COMWRAPPERS - - OBJECTHANDLE CreateDependentHandle(OBJECTREF primary, OBJECTREF secondary) - { - WRAPPER_NO_CONTRACT; - return ::CreateDependentHandle(m_handleStore, primary, secondary); - } - -#endif // DACCESS_COMPILE - - DefaultAssemblyBinder *GetDefaultBinder() {LIMITED_METHOD_CONTRACT; return m_pDefaultBinder; } - - CrstExplicitInit * GetLoaderAllocatorReferencesLock() - { - LIMITED_METHOD_CONTRACT; - return &m_crstLoaderAllocatorReferences; - } - - CrstExplicitInit* GetGenericDictionaryExpansionLock() - { - LIMITED_METHOD_CONTRACT; - return &m_crstGenericDictionaryExpansionLock; - } - - static CrstStatic* GetMethodTableExposedClassObjectLock() - { - LIMITED_METHOD_CONTRACT; - return &m_MethodTableExposedClassObjectCrst; - } - - void AssertLoadLockHeld() - { - _ASSERTE(m_FileLoadLock.HasLock()); - } - -protected: - - //**************************************************************************************** - // Helper method to initialize the large heap handle table. - void InitPinnedHeapHandleTable(); - - // Critical sections & locks - PEFileListLock m_FileLoadLock; // Protects the list of assemblies in the domain - CrstExplicitInit m_DomainCrst; // General Protection for the Domain - CrstExplicitInit m_DomainCacheCrst; // Protects the Assembly and Unmanaged caches - // Used to protect the reference lists in the collectible loader allocators attached to this appdomain - CrstExplicitInit m_crstLoaderAllocatorReferences; - CrstExplicitInit m_crstGenericDictionaryExpansionLock; - - //#AssemblyListLock - // Used to protect the assembly list. Taken also by GC or debugger thread, therefore we have to avoid - // triggering GC while holding this lock (by switching the thread to GC_NOTRIGGER while it is held). - CrstExplicitInit m_crstAssemblyList; - ListLock m_ClassInitLock; - JitListLock m_JITLock; - ListLock m_ILStubGenLock; - ListLock m_NativeTypeLoadLock; - - DefaultAssemblyBinder *m_pDefaultBinder; // Reference to the binding context that holds TPA list details - - IGCHandleStore* m_handleStore; - - // The pinned heap handle table. - PinnedHeapHandleTable *m_pPinnedHeapHandleTable; - -#ifdef FEATURE_COMINTEROP - // Information regarding the managed standard interfaces. - MngStdInterfacesInfo *m_pMngStdInterfacesInfo; -#endif // FEATURE_COMINTEROP - - // Protects allocation of slot IDs for thread statics - static CrstStatic m_MethodTableExposedClassObjectCrst; - -public: - // Only call this routine when you can guarantee there are no - // loads in progress. - void ClearBinderContext(); - - //**************************************************************************************** - // Synchronization holders. - - class LockHolder : public CrstHolder - { - public: - LockHolder(BaseDomain *pD) - : CrstHolder(&pD->m_DomainCrst) - { - WRAPPER_NO_CONTRACT; - } - }; - friend class LockHolder; - - // To be used when the thread will remain in preemptive GC mode while holding the lock - class DomainCacheCrstHolderForGCPreemp : private CrstHolder - { - public: - DomainCacheCrstHolderForGCPreemp(BaseDomain *pD) - : CrstHolder(&pD->m_DomainCacheCrst) - { - WRAPPER_NO_CONTRACT; - } - }; - - // To be used when the thread may enter cooperative GC mode while holding the lock. The thread enters a - // forbid-suspend-for-debugger region along with acquiring the lock, such that it would not suspend for the debugger while - // holding the lock, as that may otherwise cause a FuncEval to deadlock when trying to acquire the lock. - class DomainCacheCrstHolderForGCCoop : private CrstAndForbidSuspendForDebuggerHolder - { - public: - DomainCacheCrstHolderForGCCoop(BaseDomain *pD) - : CrstAndForbidSuspendForDebuggerHolder(&pD->m_DomainCacheCrst) - { - WRAPPER_NO_CONTRACT; - } - }; - - class LoadLockHolder : public PEFileListLockHolder - { - public: - LoadLockHolder(BaseDomain *pD, BOOL Take = TRUE) - : PEFileListLockHolder(&pD->m_FileLoadLock, Take) - { - CONTRACTL - { - NOTHROW; - GC_NOTRIGGER; - MODE_ANY; - CAN_TAKE_LOCK; - } - CONTRACTL_END; - } - }; - friend class LoadLockHolder; -public: - void InitVSD(); - -private: - TypeIDMap m_typeIDMap; - -public: - - - UINT32 GetTypeID(PTR_MethodTable pMT); - UINT32 LookupTypeID(PTR_MethodTable pMT); - PTR_MethodTable LookupType(UINT32 id); -#ifndef DACCESS_COMPILE - void RemoveTypesFromTypeIDMap(LoaderAllocator* pLoaderAllocator); -#endif // DACCESS_COMPILE - -private: - // I have yet to figure out an efficient way to get the number of handles - // of a particular type that's currently used by the process without - // spending more time looking at the handle table code. We know that - // our only customer (asp.net) in Dev10 is not going to create many of - // these handles so I am taking a shortcut for now and keep the sizedref - // handle count on the AD itself. - DWORD m_dwSizedRefHandles; - - static int m_iNumberOfProcessors; - -public: - // Called by DestroySizedRefHandle - void DecNumSizedRefHandles() - { - WRAPPER_NO_CONTRACT; - LONG result; - result = InterlockedDecrement((LONG*)&m_dwSizedRefHandles); - _ASSERTE(result >= 0); - } - - DWORD GetNumSizedRefHandles() - { - return m_dwSizedRefHandles; - } - -#ifdef FEATURE_CODE_VERSIONING -private: - CodeVersionManager m_codeVersionManager; - -public: - CodeVersionManager* GetCodeVersionManager() { return &m_codeVersionManager; } -#endif //FEATURE_CODE_VERSIONING + LIMITED_METHOD_CONTRACT; + m_currentLevel = level; + } -#ifdef DACCESS_COMPILE -public: - virtual void EnumMemoryRegions(CLRDataEnumMemoryFlags flags, bool enumThis) = 0; -#endif + static LoadLevelLimiter* GetCurrent() + { + LIMITED_METHOD_CONTRACT; + return t_currentLoadLevelLimiter; + } +}; -}; // class BaseDomain +#define OVERRIDE_LOAD_LEVEL_LIMIT(newLimit) \ + LoadLevelLimiter __newLimit; \ + __newLimit.Activate(); \ + __newLimit.SetLoadLevel(newLimit); enum { @@ -1008,25 +645,17 @@ const DWORD DefaultADID = 1; // Threads are always running in the context of a particular AppDomain. See // file:threads.h#RuntimeThreadLocals for more details. // -// see code:BaseDomain for much of the meat of a AppDomain (heaps locks, etc) // * code:AppDomain.m_Assemblies - is a list of code:Assembly in the appdomain // -class AppDomain : public BaseDomain +class AppDomain final { - friend class SystemDomain; - friend class AssemblyNative; - friend class AssemblySpec; - friend class ClassLoader; - friend class ThreadNative; + friend struct _DacGlobals; friend class ClrDataAccess; - friend class CheckAsmOffsets; - - VPTR_VTABLE_CLASS(AppDomain, BaseDomain) public: #ifndef DACCESS_COMPILE AppDomain(); - virtual ~AppDomain(); + ~AppDomain(); static void Create(); #endif @@ -1051,8 +680,10 @@ class AppDomain : public BaseDomain // final assembly cleanup void ShutdownFreeLoaderAllocators(); - virtual BOOL IsAppDomain() { LIMITED_METHOD_DAC_CONTRACT; return TRUE; } - virtual PTR_AppDomain AsAppDomain() { LIMITED_METHOD_CONTRACT; return dac_cast(this); } + PTR_LoaderAllocator GetLoaderAllocator(); + + STRINGREF *IsStringInterned(STRINGREF *pString); + STRINGREF *GetOrInternString(STRINGREF *pString); OBJECTREF GetRawExposedObject() { LIMITED_METHOD_CONTRACT; return NULL; } OBJECTHANDLE GetRawExposedObjectHandleForDebugger() { LIMITED_METHOD_DAC_CONTRACT; return (OBJECTHANDLE)NULL; } @@ -1062,7 +693,125 @@ class AppDomain : public BaseDomain PTR_NativeImage SetNativeImage(LPCUTF8 compositeFileName, PTR_NativeImage pNativeImage); #endif // DACCESS_COMPILE - //**************************************************************************************** + JitListLock* GetJitLock() + { + LIMITED_METHOD_CONTRACT; + return &m_JITLock; + } + + ListLock* GetClassInitLock() + { + LIMITED_METHOD_CONTRACT; + + return &m_ClassInitLock; + } + + ListLock* GetILStubGenLock() + { + LIMITED_METHOD_CONTRACT; + return &m_ILStubGenLock; + } + + ListLock* GetNativeTypeLoadLock() + { + LIMITED_METHOD_CONTRACT; + return &m_NativeTypeLoadLock; + } + + CrstExplicitInit* GetGenericDictionaryExpansionLock() + { + LIMITED_METHOD_CONTRACT; + return &m_crstGenericDictionaryExpansionLock; + } + + CrstExplicitInit* GetLoaderAllocatorReferencesLock() + { + LIMITED_METHOD_CONTRACT; + return &m_crstLoaderAllocatorReferences; + } + + CrstExplicitInit* GetMethodTableExposedClassObjectLock() + { + LIMITED_METHOD_CONTRACT; + return &m_MethodTableExposedClassObjectCrst; + } + +private: + JitListLock m_JITLock; + ListLock m_ClassInitLock; + ListLock m_ILStubGenLock; + ListLock m_NativeTypeLoadLock; + CrstExplicitInit m_crstGenericDictionaryExpansionLock; + + // Used to protect the reference lists in the collectible loader allocators attached to the app domain + CrstExplicitInit m_crstLoaderAllocatorReferences; + + // Protects allocation of slot IDs for thread statics + CrstExplicitInit m_MethodTableExposedClassObjectCrst; + +#if !defined(DACCESS_COMPILE) +public: // Handles + IGCHandleStore* GetHandleStore() + { + LIMITED_METHOD_CONTRACT; + return m_handleStore; + } + + OBJECTHANDLE CreateTypedHandle(OBJECTREF object, HandleType type) + { + WRAPPER_NO_CONTRACT; + return ::CreateHandleCommon(m_handleStore, object, type); + } + + OBJECTHANDLE CreateHandle(OBJECTREF object) + { + WRAPPER_NO_CONTRACT; + CONDITIONAL_CONTRACT_VIOLATION(ModeViolation, object == NULL) + return ::CreateHandle(m_handleStore, object); + } + + OBJECTHANDLE CreateLongWeakHandle(OBJECTREF object) + { + WRAPPER_NO_CONTRACT; + CONDITIONAL_CONTRACT_VIOLATION(ModeViolation, object == NULL) + return ::CreateLongWeakHandle(m_handleStore, object); + } + + OBJECTHANDLE CreateStrongHandle(OBJECTREF object) + { + WRAPPER_NO_CONTRACT; + return ::CreateStrongHandle(m_handleStore, object); + } + + OBJECTHANDLE CreatePinningHandle(OBJECTREF object) + { + WRAPPER_NO_CONTRACT; + return ::CreatePinningHandle(m_handleStore, object); + } + + OBJECTHANDLE CreateWeakInteriorHandle(OBJECTREF object, void* pInteriorPointerLocation) + { + WRAPPER_NO_CONTRACT; + return ::CreateWeakInteriorHandle(m_handleStore, object, pInteriorPointerLocation); + } + +#if defined(FEATURE_COMINTEROP) || defined(FEATURE_COMWRAPPERS) + OBJECTHANDLE CreateRefcountedHandle(OBJECTREF object) + { + WRAPPER_NO_CONTRACT; + return ::CreateRefcountedHandle(m_handleStore, object); + } +#endif // FEATURE_COMINTEROP || FEATURE_COMWRAPPERS + + OBJECTHANDLE CreateDependentHandle(OBJECTREF primary, OBJECTREF secondary) + { + WRAPPER_NO_CONTRACT; + return ::CreateDependentHandle(m_handleStore, primary, secondary); + } +#endif // DACCESS_COMPILE + +private: + IGCHandleStore* m_handleStore; protected: // Multi-thread safe access to the list of assemblies @@ -1239,6 +988,11 @@ class AppDomain : public BaseDomain return &m_crstAssemblyList; } +private: + // Used to protect the assembly list. Taken also by GC or debugger thread, therefore we have to avoid + // triggering GC while holding this lock (by switching the thread to GC_NOTRIGGER while it is held). + CrstExplicitInit m_crstAssemblyList; + public: class AssemblyIterator { @@ -1248,9 +1002,9 @@ class AppDomain : public BaseDomain AssemblyIterationFlags m_assemblyIterationFlags; public: - BOOL Next(CollectibleAssemblyHolder * pDomainAssemblyHolder); - // Note: Does not lock the assembly list, but AddRefs collectible assemblies. - BOOL Next_Unlocked(CollectibleAssemblyHolder * pDomainAssemblyHolder); + BOOL Next(CollectibleAssemblyHolder * pAssemblyHolder); + // Note: Does not lock the assembly list, but AddRefs collectible assemblies' loader allocator. + BOOL Next_Unlocked(CollectibleAssemblyHolder * pAssemblyHolder); private: inline DWORD GetIndex() @@ -1314,12 +1068,11 @@ class AppDomain : public BaseDomain CHECK CheckCanLoadTypes(Assembly *pAssembly); CHECK CheckCanExecuteManagedCode(MethodDesc* pMD); - CHECK CheckLoading(DomainAssembly *pFile, FileLoadLevel level); + CHECK CheckLoading(Assembly *pFile, FileLoadLevel level); - BOOL IsLoading(DomainAssembly *pFile, FileLoadLevel level); + BOOL IsLoading(Assembly *pFile, FileLoadLevel level); - void LoadDomainAssembly(DomainAssembly *pFile, - FileLoadLevel targetLevel); + void LoadAssembly(Assembly *pFile, FileLoadLevel targetLevel); enum FindAssemblyOptions { @@ -1327,64 +1080,59 @@ class AppDomain : public BaseDomain FindAssemblyOptions_IncludeFailedToLoad = 0x1 }; - DomainAssembly * FindAssembly(PEAssembly* pPEAssembly, FindAssemblyOptions options = FindAssemblyOptions_None) DAC_EMPTY_RET(NULL); + Assembly * FindAssembly(PEAssembly* pPEAssembly, FindAssemblyOptions options = FindAssemblyOptions_None) DAC_EMPTY_RET(NULL); Assembly *LoadAssembly(AssemblySpec* pIdentity, PEAssembly *pPEAssembly, FileLoadLevel targetLevel); - // this function does not provide caching, you must use LoadDomainAssembly + CHECK CheckValidModule(Module *pModule); + + void LoadSystemAssemblies(); + +private: + // this function does not provide caching, you must use LoadAssembly // unless the call is guaranteed to succeed or you don't need the caching // (e.g. if you will FailFast or tear down the AppDomain anyway) // The main point that you should not bypass caching if you might try to load the same file again, // resulting in multiple DomainAssembly objects that share the same PEAssembly for ngen image //which is violating our internal assumptions - DomainAssembly *LoadDomainAssemblyInternal( AssemblySpec* pIdentity, - PEAssembly *pPEAssembly, - FileLoadLevel targetLevel); - - DomainAssembly *LoadDomainAssembly( AssemblySpec* pIdentity, - PEAssembly *pPEAssembly, - FileLoadLevel targetLevel); - - - CHECK CheckValidModule(Module *pModule); - - // private: - void LoadSystemAssemblies(); + Assembly *LoadAssemblyInternal(AssemblySpec* pIdentity, + PEAssembly *pPEAssembly, + FileLoadLevel targetLevel); - DomainAssembly *LoadDomainAssembly(FileLoadLock *pLock, - FileLoadLevel targetLevel); + Assembly *LoadAssembly(FileLoadLock *pLock, FileLoadLevel targetLevel); - void TryIncrementalLoad(DomainAssembly *pFile, FileLoadLevel workLevel, FileLoadLockHolder &lockHolder); + void TryIncrementalLoad(Assembly *pFile, FileLoadLevel workLevel, FileLoadLockHolder &lockHolder); #ifndef DACCESS_COMPILE // needs AssemblySpec - +public: //**************************************************************************************** // Returns and Inserts assemblies into a lookup cache based on the binding information // in the AssemblySpec. There can be many AssemblySpecs to a single assembly. - DomainAssembly* FindCachedAssembly(AssemblySpec* pSpec, BOOL fThrow=TRUE) + Assembly* FindCachedAssembly(AssemblySpec* pSpec, BOOL fThrow=TRUE) { WRAPPER_NO_CONTRACT; return m_AssemblyCache.LookupAssembly(pSpec, fThrow); } +private: PEAssembly* FindCachedFile(AssemblySpec* pSpec, BOOL fThrow = TRUE); BOOL IsCached(AssemblySpec *pSpec); #endif // DACCESS_COMPILE +public: BOOL AddFileToCache(AssemblySpec* pSpec, PEAssembly *pPEAssembly); BOOL RemoveFileFromCache(PEAssembly *pPEAssembly); - BOOL AddAssemblyToCache(AssemblySpec* pSpec, DomainAssembly *pAssembly); - BOOL RemoveAssemblyFromCache(DomainAssembly* pAssembly); + BOOL AddAssemblyToCache(AssemblySpec* pSpec, Assembly *pAssembly); + BOOL RemoveAssemblyFromCache(Assembly* pAssembly); BOOL AddExceptionToCache(AssemblySpec* pSpec, Exception *ex); void AddUnmanagedImageToCache(LPCWSTR libraryName, NATIVE_LIBRARY_HANDLE hMod); NATIVE_LIBRARY_HANDLE FindUnmanagedImageInCache(LPCWSTR libraryName); - //**************************************************************************************** - // + // Adds or removes an assembly to the domain. void AddAssembly(DomainAssembly * assem); void RemoveAssembly(DomainAssembly * pAsm); @@ -1400,13 +1148,9 @@ class AppDomain : public BaseDomain ULONG Release(void) DAC_EMPTY_RET(0); //**************************************************************************************** - LPCWSTR GetFriendlyName(BOOL fDebuggerCares = TRUE); + LPCWSTR GetFriendlyName(); LPCWSTR GetFriendlyNameForDebugger(); - LPCWSTR GetFriendlyNameForLogging(); -#ifdef DACCESS_COMPILE - PVOID GetFriendlyNameNoSet(bool* isUtf8); -#endif - void SetFriendlyName(LPCWSTR pwzFriendlyName, BOOL fDebuggerCares = TRUE); + void SetFriendlyName(LPCWSTR pwzFriendlyName); PEAssembly * BindAssemblySpec( AssemblySpec *pSpec, @@ -1435,6 +1179,12 @@ class AppDomain : public BaseDomain void NotifyDebuggerUnload(); #endif // DEBUGGING_SUPPORTED +public: + // Returns an array of OBJECTREF* that can be used to store domain specific data. + // Statics and reflection info (Types, MemberInfo,..) are stored this way + // If pStaticsInfo != 0, allocation will only take place if GC statics in the DynamicStaticsInfo are NULL (and the allocation + // will be properly serialized) + OBJECTREF *AllocateObjRefPtrsInLargeTable(int nRequested, DynamicStaticsInfo* pStaticsInfo = NULL, MethodTable *pMTToFillWithStaticBoxes = NULL, bool isClassInitdeByUpdatingStaticPointer = false); #ifndef DACCESS_COMPILE OBJECTREF* AllocateStaticFieldObjRefPtrs(int nRequested) { @@ -1444,7 +1194,16 @@ class AppDomain : public BaseDomain } #endif // DACCESS_COMPILE - void EnumStaticGCRefs(promote_func* fn, ScanContext* sc); +private: + // Helper method to initialize the large heap handle table. + void InitPinnedHeapHandleTable(); + +private: + // The pinned heap handle table. + PinnedHeapHandleTable *m_pPinnedHeapHandleTable; + +public: + void EnumStaticGCRefs(promote_func* fn, ScanContext* sc); void SetupSharedStatics(); @@ -1479,6 +1238,10 @@ class AppDomain : public BaseDomain #endif // FEATURE_COMWRAPPERS DefaultAssemblyBinder *CreateDefaultBinder(); + DefaultAssemblyBinder *GetDefaultBinder() {LIMITED_METHOD_CONTRACT; return m_pDefaultBinder; } + + // Only call this routine when you can guarantee there are no loads in progress. + void ClearBinderContext(); void SetIgnoreUnhandledExceptions() { @@ -1522,16 +1285,28 @@ class AppDomain : public BaseDomain Assembly* RaiseAssemblyResolveEvent(AssemblySpec *pSpec); private: + DefaultAssemblyBinder *m_pDefaultBinder; // Reference to the binding context that holds TPA list details + CrstExplicitInit m_ReflectionCrst; CrstExplicitInit m_RefClassFactCrst; - EEClassFactoryInfoHashTable *m_pRefClassFactHash; // Hash table that maps a class factory info to a COM comp. #ifdef FEATURE_COMINTEROP DispIDCache *m_pRefDispIDCache; OBJECTHANDLE m_hndMissing; //Handle points to Missing.Value Object which is used for [Optional] arg scenario during IDispatch CCW Call #endif // FEATURE_COMINTEROP +public: + UINT32 GetTypeID(PTR_MethodTable pMT); + UINT32 LookupTypeID(PTR_MethodTable pMT); + PTR_MethodTable LookupType(UINT32 id); +#ifndef DACCESS_COMPILE + void RemoveTypesFromTypeIDMap(LoaderAllocator* pLoaderAllocator); +#endif // DACCESS_COMPILE + +private: + TypeIDMap m_typeIDMap; + public: CrstBase *GetRefClassFactCrst() @@ -1597,9 +1372,9 @@ class AppDomain : public BaseDomain #endif // FEATURE_COMINTEROP private: - void RaiseLoadingAssemblyEvent(DomainAssembly* pAssembly); + void RaiseLoadingAssemblyEvent(Assembly* pAssembly); - friend class DomainAssembly; + friend class Assembly; private: BOOL RaiseUnhandledExceptionEvent(OBJECTREF *pThrowable, BOOL isTerminating); @@ -1675,11 +1450,16 @@ class AppDomain : public BaseDomain } #endif + void AssertLoadLockHeld() + { + _ASSERTE(m_FileLoadLock.HasLock()); + } + // The one and only AppDomain SPTR_DECL(AppDomain, m_pTheAppDomain); private: - SString m_friendlyName; + PTR_CWSTR m_friendlyName; PTR_Assembly m_pRootAssembly; // General purpose flags. @@ -1750,6 +1530,53 @@ class AppDomain : public BaseDomain return FailedAssemblyIterator::Create(this); } +private: + PEFileListLock m_FileLoadLock; // Protects the list of assemblies in the domain + CrstExplicitInit m_DomainCacheCrst; // Protects the Assembly and Unmanaged caches + +public: + // To be used when the thread will remain in preemptive GC mode while holding the lock + class DomainCacheCrstHolderForGCPreemp : private CrstHolder + { + public: + DomainCacheCrstHolderForGCPreemp(AppDomain *pD) + : CrstHolder(&pD->m_DomainCacheCrst) + { + WRAPPER_NO_CONTRACT; + } + }; + + // To be used when the thread may enter cooperative GC mode while holding the lock. The thread enters a + // forbid-suspend-for-debugger region along with acquiring the lock, such that it would not suspend for the debugger while + // holding the lock, as that may otherwise cause a FuncEval to deadlock when trying to acquire the lock. + class DomainCacheCrstHolderForGCCoop : private CrstAndForbidSuspendForDebuggerHolder + { + public: + DomainCacheCrstHolderForGCCoop(AppDomain *pD) + : CrstAndForbidSuspendForDebuggerHolder(&pD->m_DomainCacheCrst) + { + WRAPPER_NO_CONTRACT; + } + }; + + class LoadLockHolder : public PEFileListLockHolder + { + public: + LoadLockHolder(AppDomain *pD, BOOL Take = TRUE) + : PEFileListLockHolder(&pD->m_FileLoadLock, Take) + { + CONTRACTL + { + NOTHROW; + GC_TRIGGERS; + MODE_ANY; + CAN_TAKE_LOCK; + } + CONTRACTL_END; + } + }; + friend class LoadLockHolder; + //--------------------------------------------------------- // Stub caches for Method stubs //--------------------------------------------------------- @@ -1788,6 +1615,14 @@ class AppDomain : public BaseDomain SHash m_unmanagedCache; +#ifdef FEATURE_CODE_VERSIONING +private: + CodeVersionManager m_codeVersionManager; + +public: + CodeVersionManager* GetCodeVersionManager() { return &m_codeVersionManager; } +#endif //FEATURE_CODE_VERSIONING + #ifdef FEATURE_TYPEEQUIVALENCE private: VolatilePtr m_pTypeEquivalenceTable; @@ -1800,7 +1635,7 @@ class AppDomain : public BaseDomain #ifdef DACCESS_COMPILE public: - virtual void EnumMemoryRegions(CLRDataEnumMemoryFlags flags, + void EnumMemoryRegions(CLRDataEnumMemoryFlags flags, bool enumThis); #endif @@ -1837,15 +1672,13 @@ class AppDomain : public BaseDomain // Just a ref holder typedef ReleaseHolder AppDomainRefHolder; -typedef VPTR(class SystemDomain) PTR_SystemDomain; +typedef DPTR(class SystemDomain) PTR_SystemDomain; -class SystemDomain : public BaseDomain +class SystemDomain final { + friend struct _DacGlobals; friend class ClrDataAccess; - VPTR_VTABLE_CLASS(SystemDomain, BaseDomain) - VPTR_UNIQUE(VPTR_UNIQUE_SystemDomain) - public: static PTR_LoaderAllocator GetGlobalLoaderAllocator(); @@ -2116,7 +1949,7 @@ class SystemDomain : public BaseDomain m_pDelayedUnloadListOfLoaderAllocators=NULL; - m_GlobalAllocator.Init(this); + m_GlobalAllocator.Init(); } #endif @@ -2125,7 +1958,6 @@ class SystemDomain : public BaseDomain GlobalLoaderAllocator m_GlobalAllocator; - InlineSString<100> m_BaseLibrary; InlineSString<100> m_SystemDirectory; @@ -2165,14 +1997,11 @@ inline static BOOL IsUnderDomainLock() { LIMITED_METHOD_CONTRACT; return m_Syste WRAPPER_NO_CONTRACT; } }; -#endif // DACCESS_COMPILE - -public: - DWORD GetTotalNumSizedRefHandles(); +#endif // !DACCESS_COMPILE #ifdef DACCESS_COMPILE public: - virtual void EnumMemoryRegions(CLRDataEnumMemoryFlags flags, + void EnumMemoryRegions(CLRDataEnumMemoryFlags flags, bool enumThis); #endif diff --git a/src/coreclr/vm/appdomainnative.cpp b/src/coreclr/vm/appdomainnative.cpp index d5b71565ded..ada5e6c7b68 100644 --- a/src/coreclr/vm/appdomainnative.cpp +++ b/src/coreclr/vm/appdomainnative.cpp @@ -70,14 +70,14 @@ extern "C" void QCALLTYPE AssemblyNative_GetLoadedAssemblies(QCall::ObjectHandle // loaded into this appdomain, on another thread. AppDomain::AssemblyIterator i = pApp->IterateAssembliesEx((AssemblyIterationFlags)( kIncludeLoaded | kIncludeExecution)); - CollectibleAssemblyHolder pDomainAssembly; + CollectibleAssemblyHolder pAssembly; - while (i.Next(pDomainAssembly.This()) && (numAssemblies < nArrayElems)) + while (i.Next(pAssembly.This()) && (numAssemblies < nArrayElems)) { // Do not change this code. This is done this way to // prevent a GC hole in the SetObjectReference() call. The compiler // is free to pick the order of evaluation. - OBJECTREF o = (OBJECTREF)pDomainAssembly->GetExposedAssemblyObject(); + OBJECTREF o = (OBJECTREF)pAssembly->GetExposedObject(); if (o == NULL) { // The assembly was collected and is not reachable from managed code anymore continue; diff --git a/src/coreclr/vm/arm/cgencpu.h b/src/coreclr/vm/arm/cgencpu.h index c98d94ad6af..e5d6ef97e61 100644 --- a/src/coreclr/vm/arm/cgencpu.h +++ b/src/coreclr/vm/arm/cgencpu.h @@ -47,7 +47,6 @@ class FramedMethodFrame; class Module; struct DeclActionInfo; class ComCallMethodDesc; -class BaseDomain; class ZapNode; struct ArgLocDesc; diff --git a/src/coreclr/vm/arm64/asmhelpers.S b/src/coreclr/vm/arm64/asmhelpers.S index ebfefd693f0..48c91e65a09 100644 --- a/src/coreclr/vm/arm64/asmhelpers.S +++ b/src/coreclr/vm/arm64/asmhelpers.S @@ -176,8 +176,7 @@ NESTED_END ThePreStub, _TEXT LEAF_ENTRY ThePreStubPatch, _TEXT nop -.globl C_FUNC(ThePreStubPatchLabel) -C_FUNC(ThePreStubPatchLabel): +PATCH_LABEL ThePreStubPatchLabel ret lr LEAF_END ThePreStubPatch, _TEXT @@ -607,8 +606,12 @@ NESTED_END ResolveWorkerAsmStub, _TEXT #ifdef FEATURE_READYTORUN NESTED_ENTRY DelayLoad_MethodCall_FakeProlog, _TEXT, NoHandler -C_FUNC(DelayLoad_MethodCall): +#if defined(__APPLE__) + .alt_entry C_FUNC(DelayLoad_MethodCall) +#endif .global C_FUNC(DelayLoad_MethodCall) +C_FUNC(DelayLoad_MethodCall): + PROLOG_WITH_TRANSITION_BLOCK add x0, sp, #__PWTB_TransitionBlock // pTransitionBlock @@ -627,8 +630,11 @@ NESTED_END DelayLoad_MethodCall_FakeProlog, _TEXT .macro DynamicHelper frameFlags, suffix NESTED_ENTRY DelayLoad_Helper\suffix\()_FakeProlog, _TEXT, NoHandler -C_FUNC(DelayLoad_Helper\suffix): +#if defined(__APPLE__) + .alt_entry C_FUNC(DelayLoad_Helper\suffix) +#endif .global C_FUNC(DelayLoad_Helper\suffix) +C_FUNC(DelayLoad_Helper\suffix): PROLOG_WITH_TRANSITION_BLOCK diff --git a/src/coreclr/vm/arm64/patchedcode.S b/src/coreclr/vm/arm64/patchedcode.S index ae8d07ab1f9..0e223cbc1d3 100644 --- a/src/coreclr/vm/arm64/patchedcode.S +++ b/src/coreclr/vm/arm64/patchedcode.S @@ -30,6 +30,7 @@ LEAF_ENTRY JIT_PatchedCodeStart, _TEXT ret lr LEAF_END JIT_PatchedCodeStart, _TEXT +//----------------------------------------------------------------------------- // void JIT_ByRefWriteBarrier // On entry: // x13 : the source address (points to object reference to write) @@ -40,7 +41,7 @@ LEAF_END JIT_PatchedCodeStart, _TEXT // x13 : incremented by 8 // x14 : incremented by 8 // x15 : trashed -// x17 : trashed (ip1) if FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP +// x17 : trashed (ip1) // // NOTE: Keep in sync with RBM_CALLEE_TRASH_WRITEBARRIER_BYREF and RBM_CALLEE_GCTRASH_WRITEBARRIER_BYREF // if you add more trashed registers. @@ -63,20 +64,16 @@ WRITE_BARRIER_END JIT_ByRefWriteBarrier // x12 : trashed // x14 : trashed (incremented by 8 to implement JIT_ByRefWriteBarrier contract) // x15 : trashed -// x17 : trashed (ip1) if FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP +// x17 : trashed (ip1) +// +// NOTE: Keep in sync with RBM_CALLEE_TRASH_WRITEBARRIER_BYREF and RBM_CALLEE_GCTRASH_WRITEBARRIER_BYREF +// if you add more trashed registers. // WRITE_BARRIER_ENTRY JIT_CheckedWriteBarrier ldr x12, LOCAL_LABEL(wbs_lowest_address) + ldr x17, LOCAL_LABEL(wbs_highest_address) cmp x14, x12 - - ldr x12, LOCAL_LABEL(wbs_highest_address) - - // Compare against the upper bound if the previous comparison indicated - // that the destination address is greater than or equal to the lower - // bound. Otherwise, set the C flag (specified by the 0x2) so that the - // branch below is not taken. - ccmp x14, x12, #0x2, hs - + ccmp x14, x17, #0x2, hs bhs LOCAL_LABEL(NotInHeap) b C_FUNC(JIT_WriteBarrier) @@ -86,6 +83,7 @@ LOCAL_LABEL(NotInHeap): ret lr WRITE_BARRIER_END JIT_CheckedWriteBarrier +//----------------------------------------------------------------------------- // void JIT_WriteBarrier(Object** dst, Object* src) // On entry: // x14 : the destination address (LHS of the assignment) @@ -95,7 +93,10 @@ WRITE_BARRIER_END JIT_CheckedWriteBarrier // x12 : trashed // x14 : trashed (incremented by 8 to implement JIT_ByRefWriteBarrier contract) // x15 : trashed -// x17 : trashed (ip1) if FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP +// x17 : trashed (ip1) +// +// NOTE: Keep in sync with RBM_CALLEE_TRASH_WRITEBARRIER_BYREF and RBM_CALLEE_GCTRASH_WRITEBARRIER_BYREF +// if you add more trashed registers. // WRITE_BARRIER_ENTRY JIT_WriteBarrier stlr x15, [x14] @@ -105,20 +106,17 @@ WRITE_BARRIER_ENTRY JIT_WriteBarrier // Do not perform the work if g_GCShadow is 0 ldr x12, LOCAL_LABEL(wbs_GCShadow) - cbz x12, LOCAL_LABEL(ShadowUpdateDisabled) - - // need temporary register. Save before using. - str x13, [sp, #-16]! + cbz x12, LOCAL_LABEL(ShadowUpdateEnd) // Compute address of shadow heap location: // pShadow = g_GCShadow + (x14 - g_lowest_address) - ldr x13, LOCAL_LABEL(wbs_lowest_address) - sub x13, x14, x13 - add x12, x13, x12 + ldr x17, LOCAL_LABEL(wbs_lowest_address) + sub x17, x14, x17 + add x12, x17, x12 // if (pShadow >= g_GCShadowEnd) goto end - ldr x13, LOCAL_LABEL(wbs_GCShadowEnd) - cmp x12, x13 + ldr x17, LOCAL_LABEL(wbs_GCShadowEnd) + cmp x12, x17 bhs LOCAL_LABEL(ShadowUpdateEnd) // *pShadow = x15 @@ -129,18 +127,16 @@ WRITE_BARRIER_ENTRY JIT_WriteBarrier dmb ish // if ([x14] == x15) goto end - ldr x13, [x14] - cmp x13, x15 + ldr x17, [x14] + cmp x17, x15 beq LOCAL_LABEL(ShadowUpdateEnd) // *pShadow = INVALIDGCVALUE (0xcccccccd) - movz x13, #0xcccd - movk x13, #0xcccc, LSL #16 - str x13, [x12] + movz x17, #0xcccd + movk x17, #0xcccc, LSL #16 + str x17, [x12] LOCAL_LABEL(ShadowUpdateEnd): - ldr x13, [sp], #16 -LOCAL_LABEL(ShadowUpdateDisabled): #endif #ifdef FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP @@ -156,22 +152,12 @@ LOCAL_LABEL(ShadowUpdateDisabled): LOCAL_LABEL(CheckCardTable): // Branch to Exit if the reference is not in the Gen0 heap - // ldr x12, LOCAL_LABEL(wbs_ephemeral_low) - cbz x12, LOCAL_LABEL(SkipEphemeralCheck) - cmp x15, x12 - - ldr x12, LOCAL_LABEL(wbs_ephemeral_high) - - // Compare against the upper bound if the previous comparison indicated - // that the destination address is greater than or equal to the lower - // bound. Otherwise, set the C flag (specified by the 0x2) so that the - // branch to exit is taken. - ccmp x15, x12, #0x2, hs - + ldr x17, LOCAL_LABEL(wbs_ephemeral_high) + cmp x15, x12 + ccmp x15, x17, #0x2, hs bhs LOCAL_LABEL(Exit) -LOCAL_LABEL(SkipEphemeralCheck): // Check if we need to update the card table ldr x12, LOCAL_LABEL(wbs_card_table) add x15, x12, x14, lsr #11 @@ -179,7 +165,7 @@ LOCAL_LABEL(SkipEphemeralCheck): cmp x12, 0xFF beq LOCAL_LABEL(Exit) -LOCAL_LABEL(UpdateCardTable): + // Update the card table mov x12, 0xFF strb w12, [x15] @@ -191,12 +177,15 @@ LOCAL_LABEL(UpdateCardTable): cmp x12, 0xFF beq LOCAL_LABEL(Exit) -LOCAL_LABEL(UpdateCardBundle): + // Update the card bundle mov x12, 0xFF strb w12, [x15] #endif LOCAL_LABEL(Exit): + // Increment by 8 to implement JIT_ByRefWriteBarrier contract. + // TODO: Consider duplicating the logic to get rid of this redundant 'add' + // for JIT_WriteBarrier/JIT_CheckedWriteBarrier add x14, x14, 8 ret lr WRITE_BARRIER_END JIT_WriteBarrier diff --git a/src/coreclr/vm/arm64/patchedcode.asm b/src/coreclr/vm/arm64/patchedcode.asm index 4bb8aa19681..454b8cac0c4 100644 --- a/src/coreclr/vm/arm64/patchedcode.asm +++ b/src/coreclr/vm/arm64/patchedcode.asm @@ -64,6 +64,7 @@ wbs_GCShadowEnd #endif WRITE_BARRIER_END JIT_WriteBarrier_Table +;----------------------------------------------------------------------------- ; void JIT_ByRefWriteBarrier ; On entry: ; x13 : the source address (points to object reference to write) @@ -74,7 +75,7 @@ wbs_GCShadowEnd ; x13 : incremented by 8 ; x14 : incremented by 8 ; x15 : trashed -; x17 : trashed (ip1) if FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP +; x17 : trashed (ip1) ; ; NOTE: Keep in sync with RBM_CALLEE_TRASH_WRITEBARRIER_BYREF and RBM_CALLEE_GCTRASH_WRITEBARRIER_BYREF ; if you add more trashed registers. @@ -97,14 +98,16 @@ wbs_GCShadowEnd ; x12 : trashed ; x14 : incremented by 8 ; x15 : trashed -; x17 : trashed (ip1) if FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP +; x17 : trashed (ip1) +; +; NOTE: Keep in sync with RBM_CALLEE_TRASH_WRITEBARRIER_BYREF and RBM_CALLEE_GCTRASH_WRITEBARRIER_BYREF +; if you add more trashed registers. ; WRITE_BARRIER_ENTRY JIT_CheckedWriteBarrier ldr x12, wbs_lowest_address + ldr x17, wbs_highest_address cmp x14, x12 - - ldr x12, wbs_highest_address - ccmphs x14, x12, #0x2 + ccmphs x14, x17, #0x2 blo JIT_WriteBarrier NotInHeap @@ -112,6 +115,7 @@ NotInHeap ret lr WRITE_BARRIER_END JIT_CheckedWriteBarrier +;----------------------------------------------------------------------------- ; void JIT_WriteBarrier(Object** dst, Object* src) ; On entry: ; x14 : the destination address (LHS of the assignment) @@ -121,7 +125,10 @@ NotInHeap ; x12 : trashed ; x14 : incremented by 8 ; x15 : trashed -; x17 : trashed (ip1) if FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP +; x17 : trashed (ip1) +; +; NOTE: Keep in sync with RBM_CALLEE_TRASH_WRITEBARRIER_BYREF and RBM_CALLEE_GCTRASH_WRITEBARRIER_BYREF +; if you add more trashed registers. ; WRITE_BARRIER_ENTRY JIT_WriteBarrier stlr x15, [x14] @@ -131,20 +138,17 @@ NotInHeap ; Do not perform the work if g_GCShadow is 0 ldr x12, wbs_GCShadow - cbz x12, ShadowUpdateDisabled - - ; need temporary register. Save before using. - str x13, [sp, #-16]! + cbz x12, ShadowUpdateEnd ; Compute address of shadow heap location: ; pShadow = $g_GCShadow + (x14 - g_lowest_address) - ldr x13, wbs_lowest_address - sub x13, x14, x13 - add x12, x13, x12 + ldr x17, wbs_lowest_address + sub x17, x14, x17 + add x12, x17, x12 ; if (pShadow >= $g_GCShadowEnd) goto end - ldr x13, wbs_GCShadowEnd - cmp x12, x13 + ldr x17, wbs_GCShadowEnd + cmp x12, x17 bhs ShadowUpdateEnd ; *pShadow = x15 @@ -155,18 +159,16 @@ NotInHeap dmb ish ; if ([x14] == x15) goto end - ldr x13, [x14] - cmp x13, x15 - beq ShadowUpdateEnd + ldr x17, [x14] + cmp x17, x15 + beq ShadowUpdateEnd ; *pShadow = INVALIDGCVALUE (0xcccccccd) - movz x13, #0xcccd - movk x13, #0xcccc, LSL #16 - str x13, [x12] + movz x17, #0xcccd + movk x17, #0xcccc, LSL #16 + str x17, [x12] ShadowUpdateEnd - ldr x13, [sp], #16 -ShadowUpdateDisabled #endif #ifdef FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP @@ -182,22 +184,12 @@ ShadowUpdateDisabled CheckCardTable ; Branch to Exit if the reference is not in the Gen0 heap - ; ldr x12, wbs_ephemeral_low - cbz x12, SkipEphemeralCheck + ldr x17, wbs_ephemeral_high cmp x15, x12 - - ldr x12, wbs_ephemeral_high - - ; Compare against the upper bound if the previous comparison indicated - ; that the destination address is greater than or equal to the lower - ; bound. Otherwise, set the C flag (specified by the 0x2) so that the - ; branch to exit is taken. - ccmp x15, x12, #0x2, hs - + ccmp x15, x17, #0x2, hs bhs Exit -SkipEphemeralCheck ; Check if we need to update the card table ldr x12, wbs_card_table @@ -208,7 +200,7 @@ SkipEphemeralCheck cmp x12, 0xFF beq Exit -UpdateCardTable + ; Update the card table mov x12, 0xFF strb w12, [x15] @@ -228,6 +220,9 @@ UpdateCardTable #endif Exit + ; Increment by 8 to implement JIT_ByRefWriteBarrier contract. + ; TODO: Consider duplicating the logic to get rid of this redundant 'add' + ; for JIT_WriteBarrier/JIT_CheckedWriteBarrier add x14, x14, 8 ret lr WRITE_BARRIER_END JIT_WriteBarrier diff --git a/src/coreclr/vm/arm64/stubs.cpp b/src/coreclr/vm/arm64/stubs.cpp index 25a62472d1e..7d1a91b9789 100644 --- a/src/coreclr/vm/arm64/stubs.cpp +++ b/src/coreclr/vm/arm64/stubs.cpp @@ -635,6 +635,10 @@ void FaultingExceptionFrame::UpdateRegDisplay(const PREGDISPLAY pRD, bool update // Copy the context to regdisplay memcpy(pRD->pCurrentContext, &m_ctx, sizeof(T_CONTEXT)); + // Clear the CONTEXT_XSTATE, since the REGDISPLAY contains just plain CONTEXT structure + // that cannot contain any extended state. + pRD->pCurrentContext->ContextFlags &= ~(CONTEXT_XSTATE & CONTEXT_AREA_MASK); + pRD->ControlPC = ::GetIP(&m_ctx); pRD->SP = ::GetSP(&m_ctx); diff --git a/src/coreclr/vm/array.cpp b/src/coreclr/vm/array.cpp index b034357ef3c..9c2f495a844 100644 --- a/src/coreclr/vm/array.cpp +++ b/src/coreclr/vm/array.cpp @@ -337,7 +337,6 @@ MethodTable* Module::CreateArrayMethodTable(TypeHandle elemTypeHnd, CorElementTy pClass->SetInternalCorElementType(arrayKind); pClass->SetAttrClass (tdPublic | tdSerializable | tdSealed); // This class is public, serializable, sealed pClass->SetRank (Rank); - pClass->SetArrayElementType (elemType); pClass->SetMethodTable (pMT); // Fill In the method table @@ -658,9 +657,8 @@ class ArrayOpLinker : public ILStubLinker hiddenArgIdx = 0; } #endif - - ArrayClass *pcls = (ArrayClass*)(pMT->GetClass()); - if(pcls->GetArrayElementType() == ELEMENT_TYPE_CLASS) + CorElementType sigElementType = pMT->GetArrayElementType(); + if (CorTypeInfo::IsObjRef(sigElementType)) { // Type Check if(m_pMD->GetArrayFuncIndex() == ArrayMethodDesc::ARRAY_FUNC_SET) diff --git a/src/coreclr/vm/assembly.cpp b/src/coreclr/vm/assembly.cpp index 721bd437508..bca764804c4 100644 --- a/src/coreclr/vm/assembly.cpp +++ b/src/coreclr/vm/assembly.cpp @@ -117,27 +117,40 @@ void Assembly::Initialize() // It cannot do any allocations or operations that might fail. Those operations should be done // in Assembly::Init() //---------------------------------------------------------------------------------------------- -Assembly::Assembly(PEAssembly* pPEAssembly, DebuggerAssemblyControlFlags debuggerFlags, BOOL fIsCollectible) : - m_pClassLoader(NULL), - m_pEntryPoint(NULL), - m_pModule(NULL), - m_pPEAssembly(clr::SafeAddRef(pPEAssembly)), - m_pFriendAssemblyDescriptor(NULL), - m_isDynamic(false), +Assembly::Assembly(PEAssembly* pPEAssembly, DebuggerAssemblyControlFlags debuggerFlags, LoaderAllocator *pLoaderAllocator) + : m_pClassLoader(NULL) + , m_pEntryPoint(NULL) + , m_pModule(NULL) + , m_pPEAssembly(clr::SafeAddRef(pPEAssembly)) + , m_pFriendAssemblyDescriptor(NULL) +#ifdef FEATURE_COMINTEROP + , m_pITypeLib(NULL) + , m_InteropAttributeStatus(INTEROP_ATTRIBUTE_UNSET) +#endif + , m_pLoaderAllocator{pLoaderAllocator} #ifdef FEATURE_COLLECTIBLE_TYPES - m_isCollectible(fIsCollectible), + , m_isCollectible{pLoaderAllocator->IsCollectible() != FALSE} #endif - m_pLoaderAllocator(NULL), -#ifdef FEATURE_COMINTEROP - m_pITypeLib(NULL), -#endif // FEATURE_COMINTEROP -#ifdef FEATURE_COMINTEROP - m_InteropAttributeStatus(INTEROP_ATTRIBUTE_UNSET), + , m_isDynamic(false) + , m_isLoading{true} + , m_isTerminated{false} + , m_level{FILE_LOAD_CREATE} + , m_notifyFlags{NOT_NOTIFIED} + , m_pError{NULL} +#ifdef _DEBUG + , m_bDisableActivationCheck{false} #endif - m_debuggerFlags(debuggerFlags), - m_fTerminated(FALSE) + , m_debuggerFlags(debuggerFlags) + , m_hExposedObject{} { - STANDARD_VM_CONTRACT; + CONTRACTL + { + STANDARD_VM_CHECK; + PRECONDITION(pPEAssembly != NULL); + PRECONDITION(pLoaderAllocator != NULL); + PRECONDITION(pLoaderAllocator->IsCollectible() || pLoaderAllocator == SystemDomain::GetGlobalLoaderAllocator()); + } + CONTRACTL_END } // This name needs to stay in sync with AssemblyBuilder.ManifestModuleName @@ -150,32 +163,10 @@ Assembly::Assembly(PEAssembly* pPEAssembly, DebuggerAssemblyControlFlags debugge // and the assembly is safely destructable. Whether this function throws or succeeds, // it must leave the Assembly in a safely destructable state. //---------------------------------------------------------------------------------------------- -void Assembly::Init(AllocMemTracker *pamTracker, LoaderAllocator *pLoaderAllocator) +void Assembly::Init(AllocMemTracker *pamTracker) { STANDARD_VM_CONTRACT; - if (IsSystem()) - { - _ASSERTE(pLoaderAllocator == NULL); // pLoaderAllocator may only be non-null for collectible types - m_pLoaderAllocator = SystemDomain::GetGlobalLoaderAllocator(); - } - else - { - if (!IsCollectible()) - { - // pLoaderAllocator will only be non-null for reflection emit assemblies - _ASSERTE((pLoaderAllocator == NULL) || (pLoaderAllocator == AppDomain::GetCurrentDomain()->GetLoaderAllocator())); - m_pLoaderAllocator = AppDomain::GetCurrentDomain()->GetLoaderAllocator(); - } - else - { - _ASSERTE(pLoaderAllocator != NULL); // ppLoaderAllocator must be non-null for collectible assemblies - - m_pLoaderAllocator = pLoaderAllocator; - } - } - _ASSERTE(m_pLoaderAllocator != NULL); - m_pClassLoader = new ClassLoader(this); m_pClassLoader->Init(pamTracker); @@ -239,9 +230,18 @@ Assembly::~Assembly() if (m_pPEAssembly) { + // Remove association first. + if (m_level >= FILE_LOAD_BEGIN) + { + UnregisterFromHostAssembly(); + } + m_pPEAssembly->Release(); } + delete m_pError; + + #ifdef FEATURE_COMINTEROP if (m_pITypeLib != nullptr && m_pITypeLib != Assembly::InvalidTypeLib) { @@ -295,7 +295,7 @@ void Assembly::Terminate( BOOL signalProfiler ) STRESS_LOG1(LF_LOADER, LL_INFO100, "Assembly::Terminate (this = 0x%p)\n", reinterpret_cast(this)); - if (this->m_fTerminated) + if (m_isTerminated) return; if (m_pClassLoader != NULL) @@ -314,19 +314,25 @@ void Assembly::Terminate( BOOL signalProfiler ) } #endif // PROFILING_SUPPORTED - this->m_fTerminated = TRUE; + m_isTerminated = true; } Assembly * Assembly::Create( PEAssembly * pPEAssembly, DebuggerAssemblyControlFlags debuggerFlags, - BOOL fIsCollectible, AllocMemTracker * pamTracker, LoaderAllocator * pLoaderAllocator) { - STANDARD_VM_CONTRACT; + CONTRACTL + { + STANDARD_VM_CHECK; + PRECONDITION(pPEAssembly != NULL); + PRECONDITION(pLoaderAllocator != NULL); + PRECONDITION(pLoaderAllocator->IsCollectible() || pLoaderAllocator == SystemDomain::GetGlobalLoaderAllocator()); + } + CONTRACTL_END - NewHolder pAssembly (new Assembly(pPEAssembly, debuggerFlags, fIsCollectible)); + NewHolder pAssembly (new Assembly(pPEAssembly, debuggerFlags, pLoaderAllocator)); #ifdef PROFILING_SUPPORTED { @@ -340,7 +346,7 @@ Assembly * Assembly::Create( EX_TRY #endif { - pAssembly->Init(pamTracker, pLoaderAllocator); + pAssembly->Init(pamTracker); } #ifdef PROFILING_SUPPORTED EX_HOOK @@ -435,6 +441,7 @@ Assembly *Assembly::CreateDynamic(AssemblyBinder* pBinder, NativeAssemblyNamePar AppDomain* pDomain = ::GetAppDomain(); NewHolder pDomainAssembly; + Assembly* pAssem; BOOL createdNewAssemblyLoaderAllocator = FALSE; { @@ -454,7 +461,7 @@ Assembly *Assembly::CreateDynamic(AssemblyBinder* pBinder, NativeAssemblyNamePar // Some of the initialization functions are not virtual. Call through the derived class // to prevent calling the base class version. - pCollectibleLoaderAllocator->Init(pDomain); + pCollectibleLoaderAllocator->Init(); // Setup the managed proxy now, but do not actually transfer ownership to it. // Once everything is setup and nothing can fail anymore, the ownership will be @@ -478,7 +485,9 @@ Assembly *Assembly::CreateDynamic(AssemblyBinder* pBinder, NativeAssemblyNamePar } // Create a domain assembly - pDomainAssembly = new DomainAssembly(pPEAssembly, pLoaderAllocator); + pDomainAssembly = new DomainAssembly(pPEAssembly, pLoaderAllocator, pamTracker); + pAssem = pDomainAssembly->GetAssembly(); + pAssem->m_isDynamic = true; if (pDomainAssembly->IsCollectible()) { // We add the assembly to the LoaderAllocator only when we are sure that it can be added @@ -488,66 +497,48 @@ Assembly *Assembly::CreateDynamic(AssemblyBinder* pBinder, NativeAssemblyNamePar } // Start loading process + if (createdNewAssemblyLoaderAllocator) { - // Create a concrete assembly - // (!Do not remove scoping brace: order is important here: the Assembly holder must destruct before the AllocMemTracker!) - NewHolder pAssem; + GCX_PREEMP(); - { - GCX_PREEMP(); - // Assembly::Create will call SuppressRelease on the NewHolder that holds the LoaderAllocator when it transfers ownership - pAssem = Assembly::Create(pPEAssembly, pDomainAssembly->GetDebuggerInfoBits(), pLoaderAllocator->IsCollectible(), pamTracker, pLoaderAllocator); + // Initializing the virtual call stub manager is delayed to remove the need for the LoaderAllocator destructor to properly handle + // uninitializing the VSD system. (There is a need to suspend the runtime, and that's tricky) + pLoaderAllocator->InitVirtualCallStubManager(); + } - ReflectionModule* pModule = (ReflectionModule*) pAssem->GetModule(); + { + GCX_PREEMP(); - if (createdNewAssemblyLoaderAllocator) - { - // Initializing the virtual call stub manager is delayed to remove the need for the LoaderAllocator destructor to properly handle - // uninitializing the VSD system. (There is a need to suspend the runtime, and that's tricky) - pLoaderAllocator->InitVirtualCallStubManager(pDomain); - } - } + // Finish loading process + // would be REALLY nice to unify this with main loading loop + pAssem->Begin(); + pAssem->DeliverSyncEvents(); + pAssem->DeliverAsyncEvents(); + pAssem->FinishLoad(); + pAssem->ClearLoading(); + pAssem->m_level = FILE_ACTIVE; + } - pAssem->m_isDynamic = true; + { + CANNOTTHROWCOMPLUSEXCEPTION(); + FAULT_FORBID(); - //we need to suppress release for pAssem to avoid double release - pAssem.SuppressRelease (); + // Cannot fail after this point - { - GCX_PREEMP(); - - // Finish loading process - // would be REALLY nice to unify this with main loading loop - pDomainAssembly->Begin(); - pDomainAssembly->SetAssembly(pAssem); - pDomainAssembly->m_level = FILE_LOAD_ALLOCATE; - pDomainAssembly->DeliverSyncEvents(); - pDomainAssembly->DeliverAsyncEvents(); - pDomainAssembly->FinishLoad(); - pDomainAssembly->ClearLoading(); - pDomainAssembly->m_level = FILE_ACTIVE; - } + pDomainAssembly.SuppressRelease(); + pamTracker->SuppressRelease(); + // Once we reach this point, the loader allocator lifetime is controlled by the Assembly object. + if (createdNewAssemblyLoaderAllocator) { - CANNOTTHROWCOMPLUSEXCEPTION(); - FAULT_FORBID(); - - //Cannot fail after this point - - pDomainAssembly.SuppressRelease(); // This also effectively suppresses the release of the pAssem - pamTracker->SuppressRelease(); - - // Once we reach this point, the loader allocator lifetime is controlled by the Assembly object. - if (createdNewAssemblyLoaderAllocator) - { - // Atomically transfer ownership to the managed heap - pLoaderAllocator->ActivateManagedTracking(); - pLoaderAllocator.SuppressRelease(); - } - - pAssem->SetIsTenured(); - pRetVal = pAssem; + // Atomically transfer ownership to the managed heap + pLoaderAllocator->ActivateManagedTracking(); + pLoaderAllocator.SuppressRelease(); } + + // Set the assembly module to be tenured now that we know it won't be deleted + pAssem->SetIsTenured(); + pRetVal = pAssem; } RETURN pRetVal; @@ -654,11 +645,9 @@ Module *Assembly::FindModuleByExportedType(mdExportedType mdType, { #ifndef DACCESS_COMPILE // LoadAssembly never returns NULL - DomainAssembly * pDomainAssembly = - GetModule()->LoadAssembly(mdLinkRef); - PREFIX_ASSUME(pDomainAssembly != NULL); - - RETURN pDomainAssembly->GetModule(); + pAssembly = GetModule()->LoadAssembly(mdLinkRef); + PREFIX_ASSUME(pAssembly != NULL); + break; #else _ASSERTE(!"DAC shouldn't attempt to trigger loading"); return NULL; @@ -883,14 +872,7 @@ Module * Assembly::FindModuleByTypeRef( RETURN NULL; } - - DomainAssembly * pDomainAssembly = pModule->LoadAssembly(tkType); - - - if (pDomainAssembly == NULL) - RETURN NULL; - - pAssembly = pDomainAssembly->GetAssembly(); + pAssembly = pModule->LoadAssembly(tkType); if (pAssembly == NULL) { RETURN NULL; @@ -1546,6 +1528,11 @@ MethodDesc* Assembly::GetEntryPoint() RETURN m_pEntryPoint; } +//--------------------------------------------------------------------------------------- +// +// Returns managed representation of the assembly (Assembly or AssemblyBuilder). +// Returns NULL if the managed scout was already collected (see code:LoaderAllocator#AssemblyPhases). +// OBJECTREF Assembly::GetExposedObject() { CONTRACT(OBJECTREF) @@ -1557,7 +1544,71 @@ OBJECTREF Assembly::GetExposedObject() } CONTRACT_END; - RETURN GetDomainAssembly()->GetExposedAssemblyObject(); + LoaderAllocator * pLoaderAllocator = GetLoaderAllocator(); + + // We already collected the managed scout, so we cannot re-create any managed objects + // Note: This is an optimization, as the managed scout can be collected right after this check + if (!pLoaderAllocator->IsManagedScoutAlive()) + return NULL; + + if (m_hExposedObject == (LOADERHANDLE)NULL) + { + // Atomically create a handle + LOADERHANDLE handle = pLoaderAllocator->AllocateHandle(NULL); + InterlockedCompareExchangeT(&m_hExposedObject, handle, static_cast(0)); + } + + if (pLoaderAllocator->GetHandleValue(m_hExposedObject) == NULL) + { + MethodTable* pMT = CoreLibBinder::GetClass(CLASS__ASSEMBLY); + + // Will be TRUE only if LoaderAllocator managed object was already collected and therefore we should + // return NULL + BOOL fIsLoaderAllocatorCollected = FALSE; + + ASSEMBLYREF assemblyObj = NULL; + + // Create the assembly object + GCPROTECT_BEGIN(assemblyObj); + assemblyObj = (ASSEMBLYREF)AllocateObject(pMT); + assemblyObj->SetAssembly(this); + + // Attach the reference to the assembly to keep the LoaderAllocator for this collectible type + // alive as long as a reference to the assembly is kept alive. + // Currently we overload the sync root field of the assembly to do so, but the overload is not necessary. + { + OBJECTREF refLA = GetLoaderAllocator()->GetExposedObject(); + if ((refLA == NULL) && GetLoaderAllocator()->IsCollectible()) + { // The managed LoaderAllocator object was collected + fIsLoaderAllocatorCollected = TRUE; + } + assemblyObj->SetSyncRoot(refLA); + } + + if (!fIsLoaderAllocatorCollected) + { // We should not expose this value in case the LoaderAllocator managed object was already + // collected + pLoaderAllocator->CompareExchangeValueInHandle(m_hExposedObject, (OBJECTREF)assemblyObj, NULL); + } + GCPROTECT_END(); + + // The LoaderAllocator managed object was already collected, we cannot re-create it + // Note: We did not publish the allocated Assembly/AssmeblyBuilder object, it will get collected by GC + // by GC + if (fIsLoaderAllocatorCollected) + return NULL; + } + + RETURN pLoaderAllocator->GetHandleValue(m_hExposedObject); +} + +OBJECTREF Assembly::GetExposedObjectIfExists() +{ + LIMITED_METHOD_CONTRACT; + + OBJECTREF objRet = NULL; + GET_LOADERHANDLE_VALUE_FAST(GetLoaderAllocator(), m_hExposedObject, &objRet); + return objRet; } /* static */ @@ -1845,33 +1896,6 @@ void DECLSPEC_NORETURN Assembly::ThrowBadImageException(LPCUTF8 pszNameSpace, #endif // #ifndef DACCESS_COMPILE -#ifndef DACCESS_COMPILE -void Assembly::EnsureActive() -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - INJECT_FAULT(COMPlusThrowOM();); - } - CONTRACTL_END; - - GetDomainAssembly()->EnsureActive(); -} -#endif //!DACCESS_COMPILE - -CHECK Assembly::CheckActivated() -{ -#ifndef DACCESS_COMPILE - WRAPPER_NO_CONTRACT; - - CHECK(GetDomainAssembly()->CheckActivated()); -#endif - CHECK_OK; -} - - - #ifdef DACCESS_COMPILE void diff --git a/src/coreclr/vm/assembly.hpp b/src/coreclr/vm/assembly.hpp index 617aa076764..441e1c828e2 100644 --- a/src/coreclr/vm/assembly.hpp +++ b/src/coreclr/vm/assembly.hpp @@ -23,15 +23,12 @@ #include "cordbpriv.h" #include "assemblyspec.hpp" -class BaseDomain; class AppDomain; class DomainAssembly; -class DomainModule; class SystemDomain; class ClassLoader; class AssemblyNative; class AssemblySpec; -class Pending; class AllocMemTracker; class FriendAssemblyDescriptor; @@ -45,24 +42,128 @@ class FriendAssemblyDescriptor; // class Assembly { - friend class BaseDomain; - friend class SystemDomain; friend class ClassLoader; friend class AssemblyNative; friend class AssemblySpec; - friend class NDirect; - friend class AssemblyNameNative; friend class ClrDataAccess; private: - Assembly(PEAssembly *pPEAssembly, DebuggerAssemblyControlFlags debuggerFlags, BOOL fIsCollectible); - void Init(AllocMemTracker *pamTracker, LoaderAllocator *pLoaderAllocator); + Assembly(PEAssembly *pPEAssembly, DebuggerAssemblyControlFlags debuggerFlags, LoaderAllocator* pLoaderAllocator); + void Init(AllocMemTracker *pamTracker); + +// Load state tracking +public: + // Return the File's load level. Note that this is the last level actually successfully completed. + // Note that this is subtly different than the FileLoadLock's level, which is the last level + // which was triggered (but potentially skipped if error or inappropriate.) + FileLoadLevel GetLoadLevel() { LIMITED_METHOD_DAC_CONTRACT; return m_level; } + + // Error means that a permanent load error has occurred. + bool IsError() + { + LIMITED_METHOD_DAC_CONTRACT; + DACCOP_IGNORE(FieldAccess, "No marshalling required"); + return m_pError != NULL; + } + + // Loading means that the load is still being tracked by a FileLoadLock. + bool IsLoading() { LIMITED_METHOD_CONTRACT; return m_isLoading; } + + // Loaded means that the file can be used passively. This includes loading types, reflection, + // and jitting. + bool IsLoaded() { LIMITED_METHOD_DAC_CONTRACT; return m_level >= FILE_LOAD_DELIVER_EVENTS; } + + // Active means that the file can be used actively. This includes code execution, static field + // access, and instance allocation. + bool IsActive() { LIMITED_METHOD_CONTRACT; return m_level >= FILE_ACTIVE; } + + // Checks if the load has reached the point where profilers may be notified + // about the file. It's important that IF a profiler is notified, THEN this returns + // TRUE, otherwise there can be profiler-attach races where the profiler doesn't see + // the file via either enumeration or notification. As a result, this begins + // returning TRUE just before the profiler is actually notified. See + // code:ProfilerFunctionEnum::Init#ProfilerEnumAssemblies + bool IsAvailableToProfilers() + { + LIMITED_METHOD_DAC_CONTRACT; + return IsProfilerNotified(); // despite the name, this function returns TRUE just before we notify the profiler + } + + BOOL DoIncrementalLoad(FileLoadLevel targetLevel); + + void ClearLoading() { LIMITED_METHOD_CONTRACT; m_isLoading = false; } + void SetLoadLevel(FileLoadLevel level) { LIMITED_METHOD_CONTRACT; m_level = level; } + + BOOL NotifyDebuggerLoad(int flags, BOOL attaching); + void NotifyDebuggerUnload(); + + // Ensure that an assembly has reached at least the IsActive state. Throw if not + void EnsureActive() + { + WRAPPER_NO_CONTRACT; + return EnsureLoadLevel(FILE_ACTIVE); + } + + // CheckActivated is appropriate for asserts that the assembly can be actively used. + // Note that this is slightly different from IsActive in that it deals with reentrancy cases properly. + CHECK CheckActivated(); + + // EnsureLoadLevel is a generic routine used to ensure that the file is not in a delay loaded + // state (unless it needs to be.) This should be used when a particular level of loading + // is required for an operation. Note that deadlocks are tolerated so the level may be one + void EnsureLoadLevel(FileLoadLevel targetLevel) DAC_EMPTY(); + + // RequireLoadLevel throws an exception if the domain file isn't loaded enough. Note + // that this is intolerant of deadlock related failures so is only really appropriate for + // checks inside the main loading loop. + void RequireLoadLevel(FileLoadLevel targetLevel) DAC_EMPTY(); + + // This should be used to permanently set the load to fail. Do not use with transient conditions + void SetError(Exception *ex); + + // Throws if a load error has occurred + void ThrowIfError(FileLoadLevel targetLevel) DAC_EMPTY(); + + // Checks that a load error has not occurred before the given level + CHECK CheckNoError(FileLoadLevel targetLevel) DAC_EMPTY_RET(CHECK::OK()); + +private: + friend class AppDomain; + friend class FileLoadLock; + +#ifndef DACCESS_COMPILE + void Begin(); + void BeforeTypeLoad(); + void EagerFixups(); + void VtableFixups(); + void DeliverSyncEvents(); + void DeliverAsyncEvents(); + void FinishLoad(); + void Activate(); + + void RegisterWithHostAssembly(); + void UnregisterFromHostAssembly(); +#endif + + void SetProfilerNotified() { LIMITED_METHOD_CONTRACT; m_notifyFlags |= PROFILER_NOTIFIED; } + void SetDebuggerNotified() { LIMITED_METHOD_CONTRACT; m_notifyFlags |= DEBUGGER_NOTIFIED; } + void SetShouldNotifyDebugger() { LIMITED_METHOD_CONTRACT; m_notifyFlags |= DEBUGGER_NEEDNOTIFICATION; } + + // IsNotified means that the profiler API notification has been delivered + bool IsProfilerNotified() { LIMITED_METHOD_CONTRACT; return (m_notifyFlags & PROFILER_NOTIFIED) == PROFILER_NOTIFIED; } + bool IsDebuggerNotified() { LIMITED_METHOD_CONTRACT; return (m_notifyFlags & DEBUGGER_NOTIFIED) == DEBUGGER_NOTIFIED; } + bool ShouldNotifyDebugger() { LIMITED_METHOD_CONTRACT; return (m_notifyFlags & DEBUGGER_NEEDNOTIFICATION) == DEBUGGER_NEEDNOTIFICATION; } + + // CheckLoadLevel is an assert predicate used to verify the load level of an assembly. + // deadlockOK indicates that the level is allowed to be one short if we are restricted + // by loader reentrancy. + CHECK CheckLoadLevel(FileLoadLevel requiredLevel, BOOL deadlockOK = TRUE) DAC_EMPTY_RET(CHECK::OK()); public: void StartUnload(); void Terminate( BOOL signalProfiler = TRUE ); - static Assembly *Create(PEAssembly *pPEAssembly, DebuggerAssemblyControlFlags debuggerFlags, BOOL fIsCollectible, AllocMemTracker *pamTracker, LoaderAllocator *pLoaderAllocator); + static Assembly *Create(PEAssembly *pPEAssembly, DebuggerAssemblyControlFlags debuggerFlags, AllocMemTracker *pamTracker, LoaderAllocator *pLoaderAllocator); static void Initialize(); BOOL IsSystem() { WRAPPER_NO_CONTRACT; return m_pPEAssembly->IsSystem(); } @@ -96,20 +197,6 @@ class Assembly return m_pClassLoader; } - //----------------------------------------------------------------------------------------- - // EnsureActive ensures that the assembly is properly prepped in the current app domain - // for active uses like code execution, static field access, and instance allocation - //----------------------------------------------------------------------------------------- -#ifndef DACCESS_COMPILE - VOID EnsureActive(); -#endif - - //----------------------------------------------------------------------------------------- - // CheckActivated is a check predicate which should be used in active use paths like code - // execution, static field access, and instance allocation - //----------------------------------------------------------------------------------------- - CHECK CheckActivated(); - PTR_LoaderAllocator GetLoaderAllocator() { LIMITED_METHOD_DAC_CONTRACT; return m_pLoaderAllocator; } #ifdef LOGGING @@ -221,6 +308,7 @@ class Assembly } OBJECTREF GetExposedObject(); + OBJECTREF GetExposedObjectIfExists(); DebuggerAssemblyControlFlags GetDebuggerInfoBits(void) { @@ -267,8 +355,8 @@ class Assembly void EnumMemoryRegions(CLRDataEnumMemoryFlags flags); #endif - FORCEINLINE BOOL IsDynamic() { LIMITED_METHOD_CONTRACT; return m_isDynamic; } - FORCEINLINE BOOL IsCollectible() { LIMITED_METHOD_DAC_CONTRACT; return m_isCollectible; } + FORCEINLINE bool IsDynamic() { LIMITED_METHOD_CONTRACT; return m_isDynamic; } + FORCEINLINE bool IsCollectible() { LIMITED_METHOD_DAC_CONTRACT; return m_isCollectible; } void AddType(Module* pModule, mdTypeDef cl); @@ -362,7 +450,6 @@ class Assembly static void AddDiagnosticStartupHookPath(LPCWSTR wszPath); - protected: #ifdef FEATURE_COMINTEROP @@ -407,6 +494,7 @@ class Assembly #endif public: void UpdateCachedFriendAssemblyInfo(); + private: PTR_ClassLoader m_pClassLoader; // Single Loader @@ -416,21 +504,32 @@ class Assembly FriendAssemblyDescriptor *m_pFriendAssemblyDescriptor; - BOOL m_isDynamic; -#ifdef FEATURE_COLLECTIBLE_TYPES - BOOL m_isCollectible; -#endif // FEATURE_COLLECTIBLE_TYPES - PTR_LoaderAllocator m_pLoaderAllocator; - #ifdef FEATURE_COMINTEROP // If a TypeLib is ever required for this module, cache the pointer here. ITypeLib *m_pITypeLib; InteropAttributeStatus m_InteropAttributeStatus; #endif // FEATURE_COMINTEROP + PTR_LoaderAllocator m_pLoaderAllocator; +#ifdef FEATURE_COLLECTIBLE_TYPES + bool m_isCollectible; +#endif // FEATURE_COLLECTIBLE_TYPES + bool m_isDynamic; + + // Load state tracking + bool m_isLoading; + bool m_isTerminated; + FileLoadLevel m_level; + DWORD m_notifyFlags; + Exception* m_pError; + +#ifdef _DEBUG + bool m_bDisableActivationCheck; +#endif + DebuggerAssemblyControlFlags m_debuggerFlags; - BOOL m_fTerminated; + LOADERHANDLE m_hExposedObject; }; #ifndef DACCESS_COMPILE diff --git a/src/coreclr/vm/assemblybinder.cpp b/src/coreclr/vm/assemblybinder.cpp index 36c07df10b2..23dbd296cff 100644 --- a/src/coreclr/vm/assemblybinder.cpp +++ b/src/coreclr/vm/assemblybinder.cpp @@ -31,7 +31,7 @@ NativeImage* AssemblyBinder::LoadNativeImage(Module* componentModule, LPCUTF8 na { STANDARD_VM_CONTRACT; - BaseDomain::LoadLockHolder lock(AppDomain::GetCurrentDomain()); + AppDomain::LoadLockHolder lock(AppDomain::GetCurrentDomain()); AssemblyBinder* binder = componentModule->GetPEAssembly()->GetAssemblyBinder(); PTR_LoaderAllocator moduleLoaderAllocator = componentModule->GetLoaderAllocator(); @@ -158,7 +158,7 @@ void AssemblyBinder::DeclareLoadedAssembly(Assembly* loadedAssembly) void AssemblyBinder::AddLoadedAssembly(Assembly* loadedAssembly) { - BaseDomain::LoadLockHolder lock(AppDomain::GetCurrentDomain()); + AppDomain::LoadLockHolder lock(AppDomain::GetCurrentDomain()); m_loadedAssemblies.Append(loadedAssembly); #ifdef FEATURE_READYTORUN diff --git a/src/coreclr/vm/assemblynative.cpp b/src/coreclr/vm/assemblynative.cpp index ed6f24b06a7..3ca0783d653 100644 --- a/src/coreclr/vm/assemblynative.cpp +++ b/src/coreclr/vm/assemblynative.cpp @@ -170,8 +170,7 @@ Assembly* AssemblyNative::LoadFromPEImage(AssemblyBinder* pBinder, PEImage *pIma PEAssemblyHolder pPEAssembly(PEAssembly::Open(pAssembly->GetPEImage(), pAssembly)); bindOperation.SetResult(pPEAssembly.GetValue()); - DomainAssembly *pDomainAssembly = pCurDomain->LoadDomainAssembly(&spec, pPEAssembly, FILE_LOADED); - RETURN pDomainAssembly->GetAssembly(); + RETURN pCurDomain->LoadAssembly(&spec, pPEAssembly, FILE_LOADED); } extern "C" void QCALLTYPE AssemblyNative_LoadFromPath(INT_PTR ptrNativeAssemblyBinder, LPCWSTR pwzILPath, LPCWSTR pwzNIPath, QCall::ObjectHandleOnStack retLoadedAssembly) @@ -336,7 +335,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetLocation(QCall::AssemblyHandle pAsse END_QCALL; } -extern "C" void QCALLTYPE AssemblyNative_GetTypeCore(QCall::AssemblyHandle assemblyHandle, +extern "C" void QCALLTYPE AssemblyNative_GetTypeCore(QCall::AssemblyHandle pAssembly, LPCSTR szTypeName, LPCSTR * rgszNestedTypeNames, int32_t cNestedTypeNamesLength, @@ -351,8 +350,6 @@ extern "C" void QCALLTYPE AssemblyNative_GetTypeCore(QCall::AssemblyHandle assem BEGIN_QCALL; - Assembly* pAssembly = assemblyHandle->GetAssembly(); - TypeHandle th = TypeHandle(); Module* pManifestModule = pAssembly->GetModule(); ClassLoader* pClassLoader = pAssembly->GetLoader(); @@ -421,7 +418,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetTypeCoreIgnoreCase(QCall::AssemblyHa BEGIN_QCALL; - Assembly* pAssembly = assemblyHandle->GetAssembly(); + Assembly* pAssembly = assemblyHandle; TypeHandle th = TypeHandle(); Module* pManifestModule = pAssembly->GetModule(); @@ -499,14 +496,13 @@ extern "C" void QCALLTYPE AssemblyNative_GetForwardedType(QCall::AssemblyHandle LPCSTR pszClassName; mdToken mdImpl; - Assembly * pAsm = pAssembly->GetAssembly(); - Module *pManifestModule = pAsm->GetModule(); + Module *pManifestModule = pAssembly->GetModule(); IfFailThrow(pManifestModule->GetMDImport()->GetExportedTypeProps(mdtExternalType, &pszNameSpace, &pszClassName, &mdImpl, NULL, NULL)); if (TypeFromToken(mdImpl) == mdtAssemblyRef) { NameHandle typeName(pszNameSpace, pszClassName); typeName.SetTypeToken(pManifestModule, mdtExternalType); - TypeHandle typeHnd = pAsm->GetLoader()->LoadTypeHandleThrowIfFailed(&typeName); + TypeHandle typeHnd = pAssembly->GetLoader()->LoadTypeHandleThrowIfFailed(&typeName); { GCX_COOP(); retType.Set(typeHnd.GetManagedClassObject()); @@ -516,16 +512,16 @@ extern "C" void QCALLTYPE AssemblyNative_GetForwardedType(QCall::AssemblyHandle END_QCALL; } -FCIMPL1(FC_BOOL_RET, AssemblyNative::IsDynamic, AssemblyBaseObject* pAssemblyUNSAFE) +FCIMPL1(FC_BOOL_RET, AssemblyNative::GetIsDynamic, Assembly* pAssembly) { - FCALL_CONTRACT; - - ASSEMBLYREF refAssembly = (ASSEMBLYREF)ObjectToOBJECTREF(pAssemblyUNSAFE); - - if (refAssembly == NULL) - FCThrowRes(kArgumentNullException, W("Arg_InvalidHandle")); + CONTRACTL + { + FCALL_CHECK; + PRECONDITION(CheckPointer(pAssembly)); + } + CONTRACTL_END; - FC_RETURN_BOOL(refAssembly->GetDomainAssembly()->GetPEAssembly()->IsReflectionEmit()); + FC_RETURN_BOOL(pAssembly->GetPEAssembly()->IsReflectionEmit()); } FCIMPLEND @@ -648,7 +644,7 @@ extern "C" BYTE * QCALLTYPE AssemblyNative_GetResource(QCall::AssemblyHandle pAs pAssembly->GetPEAssembly()->GetResource(pNameUTF8, length, &pbInMemoryResource, NULL, NULL, - NULL, pAssembly->GetAssembly()); + NULL, pAssembly); END_QCALL; @@ -680,7 +676,7 @@ extern "C" INT32 QCALLTYPE AssemblyNative_GetManifestResourceInfo(QCall::Assembl DWORD dwLocation = 0; if (pAssembly->GetPEAssembly()->GetResource(pNameUTF8, NULL, NULL, &pReferencedAssembly, &pFileName, - &dwLocation, pAssembly->GetAssembly())) + &dwLocation, pAssembly)) { if (pFileName) retFileName.Set(pFileName); @@ -815,10 +811,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle BEGIN_QCALL; InlineSArray types; - - Assembly * pAsm = pAssembly->GetAssembly(); - - IMDInternalImport *pImport = pAsm->GetMDImport(); + IMDInternalImport *pImport = pAssembly->GetMDImport(); { HENUMTypeDefInternalHolder phTDEnum(pImport); @@ -846,7 +839,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle if (IsTdPublic(dwFlags)) { - TypeHandle typeHnd = ClassLoader::LoadTypeDefThrowing(pAsm->GetModule(), mdTD, + TypeHandle typeHnd = ClassLoader::LoadTypeDefThrowing(pAssembly->GetModule(), mdTD, ClassLoader::ThrowIfNotFound, ClassLoader::PermitUninstDefOrRef); types.Append(typeHnd); @@ -894,8 +887,8 @@ extern "C" void QCALLTYPE AssemblyNative_GetExportedTypes(QCall::AssemblyHandle IsTdPublic(dwFlags)) { NameHandle typeName(pszNameSpace, pszClassName); - typeName.SetTypeToken(pAsm->GetModule(), mdCT); - TypeHandle typeHnd = pAsm->GetLoader()->LoadTypeHandleThrowIfFailed(&typeName); + typeName.SetTypeToken(pAssembly->GetModule(), mdCT); + TypeHandle typeHnd = pAssembly->GetLoader()->LoadTypeHandleThrowIfFailed(&typeName); types.Append(typeHnd); } @@ -935,10 +928,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetForwardedTypes(QCall::AssemblyHandle BEGIN_QCALL; InlineSArray types; - - Assembly * pAsm = pAssembly->GetAssembly(); - - IMDInternalImport *pImport = pAsm->GetMDImport(); + IMDInternalImport *pImport = pAssembly->GetMDImport(); // enumerate the ExportedTypes table { @@ -964,8 +954,8 @@ extern "C" void QCALLTYPE AssemblyNative_GetForwardedTypes(QCall::AssemblyHandle if ((TypeFromToken(mdImpl) == mdtAssemblyRef) && (mdImpl != mdAssemblyRefNil)) { NameHandle typeName(pszNameSpace, pszClassName); - typeName.SetTypeToken(pAsm->GetModule(), mdCT); - TypeHandle typeHnd = pAsm->GetLoader()->LoadTypeHandleThrowIfFailed(&typeName); + typeName.SetTypeToken(pAssembly->GetModule(), mdCT); + TypeHandle typeHnd = pAssembly->GetLoader()->LoadTypeHandleThrowIfFailed(&typeName); types.Append(typeHnd); } @@ -1005,9 +995,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetManifestResourceNames(QCall::Assembl BEGIN_QCALL; - Assembly * pAsm = pAssembly->GetAssembly(); - - IMDInternalImport *pImport = pAsm->GetMDImport(); + IMDInternalImport *pImport = pAssembly->GetMDImport(); HENUMInternalHolder phEnum(pImport); phEnum.EnumInit(mdtManifestResource, mdTokenNil); @@ -1047,9 +1035,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetReferencedAssemblies(QCall::Assembly { BEGIN_QCALL; - Assembly * pAsm = pAssembly->GetAssembly(); - - IMDInternalImport *pImport = pAsm->GetMDImport(); + IMDInternalImport *pImport = pAssembly->GetMDImport(); HENUMInternalHolder phEnum(pImport); phEnum.EnumInit(mdtAssemblyRef, mdTokenNil); @@ -1099,7 +1085,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetEntryPoint(QCall::AssemblyHandle pAs BEGIN_QCALL; - pMeth = pAssembly->GetAssembly()->GetEntryPoint(); + pMeth = pAssembly->GetEntryPoint(); if (pMeth != NULL) { GCX_COOP(); @@ -1132,16 +1118,13 @@ extern "C" void QCALLTYPE AssemblyNative_GetExecutingAssembly(QCall::StackCrawlM { QCALL_CONTRACT; - DomainAssembly * pExecutingAssembly = NULL; - BEGIN_QCALL; Assembly* pAssembly = SystemDomain::GetCallersAssembly(stackMark); if(pAssembly) { - pExecutingAssembly = pAssembly->GetDomainAssembly(); GCX_COOP(); - retAssembly.Set(pExecutingAssembly->GetExposedAssemblyObject()); + retAssembly.Set(pAssembly->GetExposedObject()); } END_QCALL; @@ -1153,14 +1136,11 @@ extern "C" void QCALLTYPE AssemblyNative_GetEntryAssembly(QCall::ObjectHandleOnS BEGIN_QCALL; - DomainAssembly * pRootAssembly = NULL; Assembly * pAssembly = GetAppDomain()->GetRootAssembly(); - if (pAssembly) { - pRootAssembly = pAssembly->GetDomainAssembly(); GCX_COOP(); - retAssembly.Set(pRootAssembly->GetExposedAssemblyObject()); + retAssembly.Set(pAssembly->GetExposedObject()); } END_QCALL; @@ -1224,8 +1204,8 @@ extern "C" INT_PTR QCALLTYPE AssemblyNative_InitializeAssemblyLoadContext(INT_PT GCX_PREEMP(); // Some of the initialization functions are not virtual. Call through the derived class // to prevent calling the base class version. - loaderAllocator->Init(pCurDomain); - loaderAllocator->InitVirtualCallStubManager(pCurDomain); + loaderAllocator->Init(); + loaderAllocator->InitVirtualCallStubManager(); // Setup the managed proxy now, but do not actually transfer ownership to it. // Once everything is setup and nothing can fail anymore, the ownership will be diff --git a/src/coreclr/vm/assemblynative.hpp b/src/coreclr/vm/assemblynative.hpp index 80ae3da8c2b..1ff73a406c7 100644 --- a/src/coreclr/vm/assemblynative.hpp +++ b/src/coreclr/vm/assemblynative.hpp @@ -19,10 +19,6 @@ class CustomAssemblyBinder; class AssemblyNative { - friend class Assembly; - friend class BaseDomain; - friend class DomainAssembly; - public: static Assembly* LoadFromPEImage(AssemblyBinder* pBinder, PEImage *pImage, bool excludeAppPaths = false); @@ -35,7 +31,7 @@ class AssemblyNative // static - FCDECL1(FC_BOOL_RET, IsDynamic, AssemblyBaseObject * pAssemblyUNSAFE); + FCDECL1(FC_BOOL_RET, GetIsDynamic, Assembly* pAssembly); }; extern "C" uint32_t QCALLTYPE AssemblyNative_GetAssemblyCount(); diff --git a/src/coreclr/vm/assemblyspec.cpp b/src/coreclr/vm/assemblyspec.cpp index 11a394f665c..671b74045d3 100644 --- a/src/coreclr/vm/assemblyspec.cpp +++ b/src/coreclr/vm/assemblyspec.cpp @@ -30,7 +30,7 @@ // assertions. The problem is that the real LookupAssembly can throw an OOM // simply because it can't allocate scratch space. For the sake of asserting, // we can treat those as successful lookups. -BOOL UnsafeVerifyLookupAssembly(AssemblySpecBindingCache *pCache, AssemblySpec *pSpec, DomainAssembly *pComparator) +BOOL UnsafeVerifyLookupAssembly(AssemblySpecBindingCache *pCache, AssemblySpec *pSpec, Assembly *pComparator) { STATIC_CONTRACT_NOTHROW; STATIC_CONTRACT_GC_TRIGGERS; @@ -295,24 +295,6 @@ void AssemblySpec::InitializeAssemblyNameRef(_In_ BINDER_SPACE::AssemblyName* as spec.AssemblyNameInit(assemblyNameRef); } -Assembly *AssemblySpec::LoadAssembly(FileLoadLevel targetLevel, BOOL fThrowOnFileNotFound) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_ANY; - } - CONTRACTL_END; - - DomainAssembly * pDomainAssembly = LoadDomainAssembly(targetLevel, fThrowOnFileNotFound); - if (pDomainAssembly == NULL) { - _ASSERTE(!fThrowOnFileNotFound); - return NULL; - } - return pDomainAssembly->GetAssembly(); -} - AssemblyBinder* AssemblySpec::GetBinderFromParentAssembly(AppDomain *pDomain) { CONTRACTL @@ -372,10 +354,10 @@ AssemblyBinder* AssemblySpec::GetBinderFromParentAssembly(AppDomain *pDomain) return pParentAssemblyBinder; } -DomainAssembly *AssemblySpec::LoadDomainAssembly(FileLoadLevel targetLevel, - BOOL fThrowOnFileNotFound) +Assembly *AssemblySpec::LoadAssembly(FileLoadLevel targetLevel, + BOOL fThrowOnFileNotFound) { - CONTRACT(DomainAssembly *) + CONTRACT(Assembly *) { INSTANCE_CHECK; THROWS; @@ -390,23 +372,21 @@ DomainAssembly *AssemblySpec::LoadDomainAssembly(FileLoadLevel targetLevel, ETWOnStartup (LoaderCatchCall_V1, LoaderCatchCallEnd_V1); AppDomain* pDomain = GetAppDomain(); - DomainAssembly* pAssembly = pDomain->FindCachedAssembly(this); - if (pAssembly) + Assembly* assembly = pDomain->FindCachedAssembly(this); + if (assembly) { BinderTracing::AssemblyBindOperation bindOperation(this); - bindOperation.SetResult(pAssembly->GetPEAssembly(), true /*cached*/); + bindOperation.SetResult(assembly->GetPEAssembly(), true /*cached*/); - pDomain->LoadDomainAssembly(pAssembly, targetLevel); - RETURN pAssembly; + pDomain->LoadAssembly(assembly, targetLevel); + RETURN assembly; } PEAssemblyHolder pFile(pDomain->BindAssemblySpec(this, fThrowOnFileNotFound)); if (pFile == NULL) RETURN NULL; - pAssembly = pDomain->LoadDomainAssembly(this, pFile, targetLevel); - - RETURN pAssembly; + RETURN pDomain->LoadAssembly(this, pFile, targetLevel); } /* static */ @@ -681,10 +661,10 @@ BOOL AssemblySpecBindingCache::Contains(AssemblySpec *pSpec) return (LookupInternal(pSpec, TRUE) != (AssemblyBinding *) INVALIDENTRY); } -DomainAssembly *AssemblySpecBindingCache::LookupAssembly(AssemblySpec *pSpec, +Assembly *AssemblySpecBindingCache::LookupAssembly(AssemblySpec *pSpec, BOOL fThrow /*=TRUE*/) { - CONTRACT(DomainAssembly *) + CONTRACT(Assembly *) { INSTANCE_CHECK; if (fThrow) { @@ -850,7 +830,7 @@ class AssemblyBindingHolder // 2 -> 4 -BOOL AssemblySpecBindingCache::StoreAssembly(AssemblySpec *pSpec, DomainAssembly *pAssembly) +BOOL AssemblySpecBindingCache::StoreAssembly(AssemblySpec *pSpec, Assembly *pAssembly) { CONTRACT(BOOL) { @@ -858,8 +838,7 @@ BOOL AssemblySpecBindingCache::StoreAssembly(AssemblySpec *pSpec, DomainAssembly THROWS; GC_TRIGGERS; MODE_ANY; - POSTCONDITION(UnsafeContains(this, pSpec)); - POSTCONDITION(UnsafeVerifyLookupAssembly(this, pSpec, pAssembly)); + POSTCONDITION((!RETVAL) || (UnsafeContains(this, pSpec) && UnsafeVerifyLookupAssembly(this, pSpec, pAssembly))); INJECT_FAULT(COMPlusThrowOM();); } CONTRACT_END; @@ -887,7 +866,7 @@ BOOL AssemblySpecBindingCache::StoreAssembly(AssemblySpec *pSpec, DomainAssembly } entry = abHolder.CreateAssemblyBinding(pHeap); - entry->Init(pSpec,pAssembly->GetPEAssembly(),pAssembly,NULL,pHeap, abHolder.GetPamTracker()); + entry->Init(pSpec, pAssembly->GetPEAssembly(), pAssembly, NULL, pHeap, abHolder.GetPamTracker()); m_map.InsertValue(key, entry); @@ -1069,7 +1048,7 @@ BOOL AssemblySpecBindingCache::StoreException(AssemblySpec *pSpec, Exception* pE } } -BOOL AssemblySpecBindingCache::RemoveAssembly(DomainAssembly* pAssembly) +BOOL AssemblySpecBindingCache::RemoveAssembly(Assembly* pAssembly) { CONTRACT(BOOL) { diff --git a/src/coreclr/vm/assemblyspec.hpp b/src/coreclr/vm/assemblyspec.hpp index 96b8e409d1d..97aab7aa4f5 100644 --- a/src/coreclr/vm/assemblyspec.hpp +++ b/src/coreclr/vm/assemblyspec.hpp @@ -45,7 +45,6 @@ class AssemblySpec : public BaseAssemblySpec friend Assembly * Module::GetAssemblyIfLoaded( mdAssemblyRef kAssemblyRef, IMDInternalImport * pMDImportOverride, - BOOL fDoNotUtilizeExtraChecks, AssemblyBinder *pBinderForLoadedAssembly); public: @@ -175,8 +174,6 @@ class AssemblySpec : public BaseAssemblySpec Assembly *LoadAssembly(FileLoadLevel targetLevel, BOOL fThrowOnFileNotFound = TRUE); - DomainAssembly *LoadDomainAssembly(FileLoadLevel targetLevel, - BOOL fThrowOnFileNotFound = TRUE); public: // static // Creates and loads an assembly based on the name and context. @@ -321,8 +318,8 @@ class AssemblySpecBindingCache delete m_pException; }; - inline DomainAssembly* GetAssembly(){ LIMITED_METHOD_CONTRACT; return m_pAssembly;}; - inline void SetAssembly(DomainAssembly* pAssembly){ LIMITED_METHOD_CONTRACT; m_pAssembly=pAssembly;}; + inline Assembly* GetAssembly(){ LIMITED_METHOD_CONTRACT; return m_pAssembly; }; + inline void SetAssembly(Assembly* pAssembly){ LIMITED_METHOD_CONTRACT; m_pAssembly = pAssembly; }; inline PEAssembly* GetFile(){ LIMITED_METHOD_CONTRACT; return m_pPEAssembly;}; inline BOOL IsError(){ LIMITED_METHOD_CONTRACT; return (m_exceptionType!=EXTYPE_NONE);}; @@ -347,7 +344,7 @@ class AssemblySpecBindingCache default: _ASSERTE(!"Unexpected exception type"); } }; - inline void Init(AssemblySpec* pSpec, PEAssembly* pPEAssembly, DomainAssembly* pAssembly, Exception* pEx, LoaderHeap *pHeap, AllocMemTracker *pamTracker) + inline void Init(AssemblySpec* pSpec, PEAssembly* pPEAssembly, Assembly* pAssembly, Exception* pEx, LoaderHeap *pHeap, AllocMemTracker *pamTracker) { CONTRACTL { @@ -357,7 +354,7 @@ class AssemblySpecBindingCache } CONTRACTL_END; - InitInternal(pSpec,pPEAssembly,pAssembly); + InitInternal(pSpec, pPEAssembly, pAssembly); if (pHeap != NULL) { m_spec.CloneFieldsToLoaderHeap(pHeap, pamTracker); @@ -367,7 +364,6 @@ class AssemblySpecBindingCache m_spec.CloneFields(); } InitException(pEx); - } inline HRESULT GetHR() @@ -426,7 +422,7 @@ class AssemblySpecBindingCache }; protected: - inline void InitInternal(AssemblySpec* pSpec, PEAssembly* pPEAssembly, DomainAssembly* pAssembly ) + inline void InitInternal(AssemblySpec* pSpec, PEAssembly* pPEAssembly, Assembly* pAssembly ) { WRAPPER_NO_CONTRACT; m_spec.CopyFrom(pSpec); @@ -439,7 +435,7 @@ class AssemblySpecBindingCache AssemblySpec m_spec; PEAssembly *m_pPEAssembly; - DomainAssembly *m_pAssembly; + Assembly *m_pAssembly; enum{ EXTYPE_NONE = 0x00000000, EXTYPE_HR = 0x00000001, @@ -468,15 +464,15 @@ class AssemblySpecBindingCache BOOL Contains(AssemblySpec *pSpec); - DomainAssembly *LookupAssembly(AssemblySpec *pSpec, BOOL fThrow=TRUE); + Assembly *LookupAssembly(AssemblySpec *pSpec, BOOL fThrow=TRUE); PEAssembly *LookupFile(AssemblySpec *pSpec, BOOL fThrow = TRUE); - BOOL StoreAssembly(AssemblySpec *pSpec, DomainAssembly *pAssembly); + BOOL StoreAssembly(AssemblySpec *pSpec, Assembly *pAssembly); BOOL StorePEAssembly(AssemblySpec *pSpec, PEAssembly *pPEAssembly); BOOL StoreException(AssemblySpec *pSpec, Exception* pEx); - BOOL RemoveAssembly(DomainAssembly* pAssembly); + BOOL RemoveAssembly(Assembly* pAssembly); DWORD Hash(AssemblySpec *pSpec) { @@ -485,7 +481,7 @@ class AssemblySpecBindingCache } #if !defined(DACCESS_COMPILE) - void GetAllAssemblies(SetSHash& assemblyList) + void GetAllAssemblies(SetSHash& assemblyList) { PtrHashMap::PtrIterator i = m_map.begin(); while (!i.end()) diff --git a/src/coreclr/vm/binder.cpp b/src/coreclr/vm/binder.cpp index 14e1cbfe549..7805f1f37d9 100644 --- a/src/coreclr/vm/binder.cpp +++ b/src/coreclr/vm/binder.cpp @@ -775,22 +775,22 @@ static void FCallCheckSignature(MethodDesc* pMD, PCODE pImpl) expectedType = pMD->IsCtor() ? NULL : "void"; break; case ELEMENT_TYPE_BOOLEAN: - expectedType = (argIndex == -2) ? "FC_BOOL_RET" : "CLR_BOOL"; + expectedType = (argIndex == -2) ? "FC_BOOL_RET" : "FC_BOOL_ARG"; break; case ELEMENT_TYPE_CHAR: - expectedType = (argIndex == -2) ? "FC_CHAR_RET" : "CLR_CHAR"; + expectedType = (argIndex == -2) ? "FC_CHAR_RET" : "FC_CHAR_ARG"; break; case ELEMENT_TYPE_I1: - expectedType = (argIndex == -2) ? "FC_INT8_RET" : "INT8"; + expectedType = (argIndex == -2) ? "FC_INT8_RET" : "FC_INT8_ARG"; break; case ELEMENT_TYPE_U1: - expectedType = (argIndex == -2) ? "FC_UINT8_RET" : "UINT8"; + expectedType = (argIndex == -2) ? "FC_UINT8_RET" : "FC_UINT8_ARG"; break; case ELEMENT_TYPE_I2: - expectedType = (argIndex == -2) ? "FC_INT16_RET" : "INT16"; + expectedType = (argIndex == -2) ? "FC_INT16_RET" : "FC_INT16_ARG"; break; case ELEMENT_TYPE_U2: - expectedType = (argIndex == -2) ? "FC_UINT16_RET" : "UINT16"; + expectedType = (argIndex == -2) ? "FC_UINT16_RET" : "FC_UINT16_ARG"; break; //case ELEMENT_TYPE_I4: // expectedType = "INT32"; diff --git a/src/coreclr/vm/callconvbuilder.cpp b/src/coreclr/vm/callconvbuilder.cpp index d68ac7f023e..9e1d760dc22 100644 --- a/src/coreclr/vm/callconvbuilder.cpp +++ b/src/coreclr/vm/callconvbuilder.cpp @@ -358,25 +358,49 @@ HRESULT CallConv::TryGetUnmanagedCallingConventionFromModOpt( _ASSERTE(pWalk <= pSig + cSig); CallConvBuilder& callConvBuilder = *builder; - while ((pWalk < (pSig + cSig)) && ((*pWalk == ELEMENT_TYPE_CMOD_OPT) || (*pWalk == ELEMENT_TYPE_CMOD_REQD))) + while ((pWalk < (pSig + cSig)) && ((*pWalk == ELEMENT_TYPE_CMOD_OPT) || (*pWalk == ELEMENT_TYPE_CMOD_REQD) || (*pWalk == ELEMENT_TYPE_CMOD_INTERNAL))) { - BOOL fIsOptional = (*pWalk == ELEMENT_TYPE_CMOD_OPT); - - pWalk++; - if (pWalk + CorSigUncompressedDataSize(pWalk) > pSig + cSig) + CORINFO_MODULE_HANDLE tokenLookupModule = pModule; + mdToken tk; + LPCSTR typeNamespace; + LPCSTR typeName; + if (*pWalk == ELEMENT_TYPE_CMOD_INTERNAL) { - *errorResID = BFA_BAD_SIGNATURE; - return COR_E_BADIMAGEFORMAT; // Bad formatting + // Skip internal modifiers + pWalk++; + if (pWalk + 1 + sizeof(void*) > pSig + cSig) + { + *errorResID = BFA_BAD_SIGNATURE; + return COR_E_BADIMAGEFORMAT; // Bad formatting + } + + BOOL required = *pWalk++ != 0; + void* pType; + pWalk += CorSigUncompressPointer(pWalk, &pType); + TypeHandle type = TypeHandle::FromPtr(pType); + + if (!required) + continue; + + tokenLookupModule = GetScopeHandle(type.GetModule()); + tk = type.GetCl(); } + else + { + BOOL fIsOptional = (*pWalk == ELEMENT_TYPE_CMOD_OPT); - mdToken tk; - pWalk += CorSigUncompressToken(pWalk, &tk); + pWalk++; + if (pWalk + CorSigUncompressedDataSize(pWalk) > pSig + cSig) + { + *errorResID = BFA_BAD_SIGNATURE; + return COR_E_BADIMAGEFORMAT; // Bad formatting + } - if (!fIsOptional) - continue; + pWalk += CorSigUncompressToken(pWalk, &tk); - LPCSTR typeNamespace; - LPCSTR typeName; + if (!fIsOptional) + continue; + } // Check for CallConv types specified in modopt if (FAILED(GetNameOfTypeRefOrDef(pModule, tk, &typeNamespace, &typeName))) @@ -490,21 +514,14 @@ bool CallConv::TryGetCallingConventionFromUnmanagedCallersOnly(_In_ MethodDesc* BYTE* pData = NULL; LONG cData = 0; - bool nativeCallableInternalData = false; HRESULT hr = pMD->GetCustomAttribute(WellKnownAttribute::UnmanagedCallersOnly, (const VOID **)(&pData), (ULONG *)&cData); - if (hr == S_FALSE) - { - hr = pMD->GetCustomAttribute(WellKnownAttribute::NativeCallableInternal, (const VOID **)(&pData), (ULONG *)&cData); - nativeCallableInternalData = SUCCEEDED(hr); - } - IfFailThrow(hr); _ASSERTE(cData > 0); CustomAttributeParser ca(pData, cData); - // UnmanagedCallersOnly and NativeCallableInternal each + // UnmanagedCallersOnly each // have optional named arguments. CaNamedArg namedArgs[2]; @@ -512,15 +529,8 @@ bool CallConv::TryGetCallingConventionFromUnmanagedCallersOnly(_In_ MethodDesc* CaType caCallConvs; // Define attribute specific optional named properties - if (nativeCallableInternalData) - { - namedArgs[0].InitI4FieldEnum("CallingConvention", "System.Runtime.InteropServices.CallingConvention", (ULONG)(CorPinvokeMap)0); - } - else - { - caCallConvs.Init(SERIALIZATION_TYPE_SZARRAY, SERIALIZATION_TYPE_TYPE, SERIALIZATION_TYPE_UNDEFINED, NULL, 0); - namedArgs[0].Init("CallConvs", SERIALIZATION_TYPE_SZARRAY, caCallConvs); - } + caCallConvs.Init(SERIALIZATION_TYPE_SZARRAY, SERIALIZATION_TYPE_TYPE, SERIALIZATION_TYPE_UNDEFINED, NULL, 0); + namedArgs[0].Init("CallConvs", SERIALIZATION_TYPE_SZARRAY, caCallConvs); // Define common optional named properties CaTypeCtor caEntryPoint(SERIALIZATION_TYPE_STRING); @@ -542,25 +552,17 @@ bool CallConv::TryGetCallingConventionFromUnmanagedCallersOnly(_In_ MethodDesc* if (namedArgs[0].val.type.tag == SERIALIZATION_TYPE_UNDEFINED) return false; - CorInfoCallConvExtension callConvLocal; - if (nativeCallableInternalData) + CallConvBuilder builder; + if (!TryGetCallingConventionFromTypeArray(&namedArgs[0].val, &builder)) { - callConvLocal = (CorInfoCallConvExtension)(namedArgs[0].val.u4 << 8); + // We found a second base calling convention. + return false; } - else - { - CallConvBuilder builder; - if (!TryGetCallingConventionFromTypeArray(&namedArgs[0].val, &builder)) - { - // We found a second base calling convention. - return false; - } - callConvLocal = builder.GetCurrentCallConv(); - if (callConvLocal == CallConvBuilder::UnsetValue) - { - callConvLocal = CallConv::GetDefaultUnmanagedCallingConvention(); - } + CorInfoCallConvExtension callConvLocal = builder.GetCurrentCallConv(); + if (callConvLocal == CallConvBuilder::UnsetValue) + { + callConvLocal = CallConv::GetDefaultUnmanagedCallingConvention(); } *pCallConv = callConvLocal; diff --git a/src/coreclr/vm/callhelpers.h b/src/coreclr/vm/callhelpers.h index b39586d82c3..0e7f16dc021 100644 --- a/src/coreclr/vm/callhelpers.h +++ b/src/coreclr/vm/callhelpers.h @@ -473,7 +473,6 @@ class MethodDescCallSite MDCALLDEF_VOID( CallWithValueTypes, TRUE) MDCALLDEF_ARGSLOT( CallWithValueTypes, _RetArgSlot) MDCALLDEF_REFTYPE( CallWithValueTypes, TRUE, _RetOBJECTREF, Object*, OBJECTREF) - MDCALLDEF( CallWithValueTypes, TRUE, _RetOleColor, OLE_COLOR, OTHER_ELEMENT_TYPE) #undef OTHER_ELEMENT_TYPE #undef MDCALL_ARG_SIG_STD_RETTYPES #undef MDCALLDEF diff --git a/src/coreclr/vm/ceeload.cpp b/src/coreclr/vm/ceeload.cpp index eb3a2d8015c..38838f70ec2 100644 --- a/src/coreclr/vm/ceeload.cpp +++ b/src/coreclr/vm/ceeload.cpp @@ -332,6 +332,7 @@ Module::Module(Assembly *pAssembly, PEAssembly *pPEAssembly) : m_pPEAssembly{pPEAssembly} , m_dwTransientFlags{CLASSES_FREED} , m_pAssembly{pAssembly} + , m_pDynamicMethodTable{NULL} , m_hExposedObject{} { CONTRACTL @@ -743,6 +744,8 @@ void Module::Destruct() } m_pPEAssembly->Release(); + if (m_pDynamicMethodTable) + m_pDynamicMethodTable->Destroy(); #if defined(PROFILING_SUPPORTED) delete m_pJitInlinerTrackingMap; @@ -2255,7 +2258,6 @@ Assembly * Module::GetAssemblyIfLoaded( mdAssemblyRef kAssemblyRef, IMDInternalImport * pMDImportOverride, // = NULL - BOOL fDoNotUtilizeExtraChecks, // = FALSE AssemblyBinder *pBinderForLoadedAssembly // = NULL ) { @@ -2298,8 +2300,7 @@ Module::GetAssemblyIfLoaded( if ((pAssembly != NULL) && !IsGCThread() && !IsStackWalkerThread()) { _ASSERTE(::GetAppDomain() != NULL); - DomainAssembly * pDomainAssembly = pAssembly->GetDomainAssembly(); - if ((pDomainAssembly == NULL) || !pDomainAssembly->IsLoaded()) + if (!pAssembly->IsLoaded()) pAssembly = NULL; } @@ -2326,10 +2327,10 @@ Module::GetAssemblyIfLoaded( spec.SetBinder(pBinderForLoadedAssembly); } - DomainAssembly * pDomainAssembly = AppDomain::GetCurrentDomain()->FindCachedAssembly(&spec, FALSE /*fThrow*/); + Assembly * pCachedAssembly = AppDomain::GetCurrentDomain()->FindCachedAssembly(&spec, FALSE /*fThrow*/); - if (pDomainAssembly && pDomainAssembly->IsLoaded()) - pAssembly = pDomainAssembly->GetAssembly(); + if (pCachedAssembly && pCachedAssembly->IsLoaded()) + pAssembly = pCachedAssembly; // Only store in the rid map if working with the current AppDomain. if (fCanUseRidMap && pAssembly) @@ -2384,9 +2385,9 @@ ModuleBase::GetAssemblyRefFlags( } // Module::GetAssemblyRefFlags #ifndef DACCESS_COMPILE -DomainAssembly * Module::LoadAssemblyImpl(mdAssemblyRef kAssemblyRef) +Assembly * Module::LoadAssemblyImpl(mdAssemblyRef kAssemblyRef) { - CONTRACT(DomainAssembly *) + CONTRACT(Assembly *) { INSTANCE_CHECK; if (FORBIDGC_LOADER_USE_ENABLED()) NOTHROW; else THROWS; @@ -2399,18 +2400,14 @@ DomainAssembly * Module::LoadAssemblyImpl(mdAssemblyRef kAssemblyRef) ETWOnStartup (LoaderCatchCall_V1, LoaderCatchCallEnd_V1); - DomainAssembly * pDomainAssembly; - // // Early out quickly if the result is cached // Assembly * pAssembly = LookupAssemblyRef(kAssemblyRef); if (pAssembly != NULL) { - pDomainAssembly = pAssembly->GetDomainAssembly(); - ::GetAppDomain()->LoadDomainAssembly(pDomainAssembly, FILE_LOADED); - - RETURN pDomainAssembly; + ::GetAppDomain()->LoadAssembly(pAssembly, FILE_LOADED); + RETURN pAssembly; } { @@ -2425,26 +2422,20 @@ DomainAssembly * Module::LoadAssemblyImpl(mdAssemblyRef kAssemblyRef) { spec.SetBinder(pBinder); } - pDomainAssembly = GetAppDomain()->LoadDomainAssembly(&spec, pPEAssembly, FILE_LOADED); + pAssembly = GetAppDomain()->LoadAssembly(&spec, pPEAssembly, FILE_LOADED); } - if (pDomainAssembly != NULL) - { - _ASSERTE( - pDomainAssembly->IsSystem() || // GetAssemblyIfLoaded will not find CoreLib (see AppDomain::FindCachedFile) - !pDomainAssembly->IsLoaded() || // GetAssemblyIfLoaded will not find not-yet-loaded assemblies - GetAssemblyIfLoaded(kAssemblyRef, NULL, FALSE, pDomainAssembly->GetPEAssembly()->GetHostAssembly()->GetBinder()) != NULL); // GetAssemblyIfLoaded should find all remaining cases + _ASSERTE(pAssembly != NULL && pAssembly->IsLoaded()); + _ASSERTE( + pAssembly->IsSystem() || // GetAssemblyIfLoaded will not find CoreLib (see AppDomain::FindCachedFile) + GetAssemblyIfLoaded(kAssemblyRef, NULL, pAssembly->GetPEAssembly()->GetHostAssembly()->GetBinder()) != NULL); // GetAssemblyIfLoaded should find all remaining cases - if (pDomainAssembly->GetAssembly() != NULL) - { - StoreAssemblyRef(kAssemblyRef, pDomainAssembly->GetAssembly()); - } - } + StoreAssemblyRef(kAssemblyRef, pAssembly); - RETURN pDomainAssembly; + RETURN pAssembly; } #else -DomainAssembly * Module::LoadAssemblyImpl(mdAssemblyRef kAssemblyRef) +Assembly * Module::LoadAssemblyImpl(mdAssemblyRef kAssemblyRef) { WRAPPER_NO_CONTRACT; ThrowHR(E_FAIL); @@ -2915,7 +2906,7 @@ void Module::UpdateDynamicMetadataIfNeeded() #endif // DEBUGGING_SUPPORTED -BOOL Module::NotifyDebuggerLoad(AppDomain *pDomain, DomainAssembly * pDomainAssembly, int flags, BOOL attaching) +BOOL Module::NotifyDebuggerLoad(DomainAssembly * pDomainAssembly, int flags, BOOL attaching) { WRAPPER_NO_CONTRACT; @@ -2930,10 +2921,10 @@ BOOL Module::NotifyDebuggerLoad(AppDomain *pDomain, DomainAssembly * pDomainAsse pModule->UpdateDynamicMetadataIfNeeded(); } - // // Remaining work is only needed if a debugger is attached // + AppDomain* pDomain = AppDomain::GetCurrentDomain(); if (!attaching && !pDomain->IsDebuggerAttached()) return FALSE; @@ -2946,7 +2937,6 @@ BOOL Module::NotifyDebuggerLoad(AppDomain *pDomain, DomainAssembly * pDomainAsse m_pPEAssembly->GetPath(), m_pPEAssembly->GetPath().GetCount(), GetAssembly(), - pDomain, pDomainAssembly, attaching); @@ -2969,10 +2959,11 @@ BOOL Module::NotifyDebuggerLoad(AppDomain *pDomain, DomainAssembly * pDomainAsse return result; } -void Module::NotifyDebuggerUnload(AppDomain *pDomain) +void Module::NotifyDebuggerUnload() { LIMITED_METHOD_CONTRACT; + AppDomain* pDomain = AppDomain::GetCurrentDomain(); if (!pDomain->IsDebuggerAttached()) return; @@ -2990,7 +2981,7 @@ void Module::NotifyDebuggerUnload(AppDomain *pDomain) } } - g_pDebugInterface->UnloadModule(this, pDomain); + g_pDebugInterface->UnloadModule(this); } using GetTokenForVTableEntry_t = mdToken(STDMETHODCALLTYPE*)(HMODULE module, BYTE**ppVTEntry); @@ -4464,30 +4455,12 @@ VOID Module::EnsureActive() MODE_ANY; } CONTRACTL_END; - GetDomainAssembly()->EnsureActive(); + GetAssembly()->EnsureActive(); } #endif // DACCESS_COMPILE #include - -#ifndef DACCESS_COMPILE - -VOID Module::EnsureAllocated() -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_ANY; - } - CONTRACTL_END; - - GetDomainAssembly()->EnsureAllocated(); -} - -#endif // !DACCESS_COMPILE - CHECK Module::CheckActivated() { CONTRACTL @@ -4499,10 +4472,10 @@ CHECK Module::CheckActivated() CONTRACTL_END; #ifndef DACCESS_COMPILE - DomainAssembly *pDomainAssembly = GetDomainAssembly(); - CHECK(pDomainAssembly != NULL); - PREFIX_ASSUME(pDomainAssembly != NULL); - CHECK(pDomainAssembly->CheckActivated()); + Assembly *pAssembly = GetAssembly(); + CHECK(pAssembly != NULL); + PREFIX_ASSUME(pAssembly != NULL); + CHECK(pAssembly->CheckActivated()); #endif CHECK_OK; } diff --git a/src/coreclr/vm/ceeload.h b/src/coreclr/vm/ceeload.h index 5ba8ea1fb4a..b2c1068c0ae 100644 --- a/src/coreclr/vm/ceeload.h +++ b/src/coreclr/vm/ceeload.h @@ -52,7 +52,6 @@ class EEStringData; class MethodDescChunk; class SigTypeContext; class Assembly; -class BaseDomain; class AppDomain; class SystemDomain; class Module; @@ -466,7 +465,7 @@ class ModuleBase // The vtable needs to match between DAC and non-DAC, but we don't want any use of IsSigInIL in the DAC virtual BOOL IsSigInILImpl(PCCOR_SIGNATURE signature) { return FALSE; } // ModuleBase doesn't have a PE image to examine // The vtable needs to match between DAC and non-DAC, but we don't want any use of LoadAssembly in the DAC - virtual DomainAssembly * LoadAssemblyImpl(mdAssemblyRef kAssemblyRef) = 0; + virtual Assembly * LoadAssemblyImpl(mdAssemblyRef kAssemblyRef) = 0; // The vtable needs to match between DAC and non-DAC, but we don't want any use of ThrowTypeLoadException in the DAC virtual void DECLSPEC_NORETURN ThrowTypeLoadExceptionImpl(IMDInternalImport *pInternalImport, @@ -552,7 +551,6 @@ class ModuleBase virtual Assembly * GetAssemblyIfLoaded( mdAssemblyRef kAssemblyRef, IMDInternalImport * pMDImportOverride = NULL, - BOOL fDoNotUtilizeExtraChecks = FALSE, AssemblyBinder *pBinderForLoadedAssembly = NULL ) { @@ -573,7 +571,7 @@ class ModuleBase // The vtable needs to match between DAC and non-DAC, but we don't want any use of IsSigInIL in the DAC BOOL IsSigInIL(PCCOR_SIGNATURE signature) { return IsSigInILImpl(signature); } - DomainAssembly * LoadAssembly(mdAssemblyRef kAssemblyRef) + Assembly * LoadAssembly(mdAssemblyRef kAssemblyRef) { WRAPPER_NO_CONTRACT; return LoadAssemblyImpl(kAssemblyRef); @@ -948,7 +946,6 @@ class Module : public ModuleBase #ifndef DACCESS_COMPILE VOID EnsureActive(); - VOID EnsureAllocated(); #endif CHECK CheckActivated(); @@ -1130,7 +1127,6 @@ class Module : public ModuleBase Assembly * GetAssemblyIfLoaded( mdAssemblyRef kAssemblyRef, IMDInternalImport * pMDImportOverride = NULL, - BOOL fDoNotUtilizeExtraChecks = FALSE, AssemblyBinder *pBinderForLoadedAssembly = NULL ) final; @@ -1141,7 +1137,7 @@ class Module : public ModuleBase UINT resIDWhy) final; #endif - DomainAssembly * LoadAssemblyImpl(mdAssemblyRef kAssemblyRef) final; + Assembly * LoadAssemblyImpl(mdAssemblyRef kAssemblyRef) final; public: PTR_Module LookupModule(mdToken kFile) final; Module *GetModuleIfLoaded(mdFile kFile) final; @@ -1323,11 +1319,22 @@ class Module : public ModuleBase MethodDesc *FindMethodThrowing(mdToken pMethod); MethodDesc *FindMethod(mdToken pMethod); +#ifndef DACCESS_COMPILE +public: + // light code gen. Keep the list of MethodTables needed for creating dynamic methods + DynamicMethodTable* GetDynamicMethodTable(); +#endif +private: + // m_pDynamicMethodTable is used by the light code generation to allow method + // generation on the fly. They are lazily created when/if a dynamic method is requested + // for this specific module + DynamicMethodTable* m_pDynamicMethodTable; + public: // Debugger stuff - BOOL NotifyDebuggerLoad(AppDomain *pDomain, DomainAssembly * pDomainAssembly, int level, BOOL attaching); - void NotifyDebuggerUnload(AppDomain *pDomain); + BOOL NotifyDebuggerLoad(DomainAssembly * pDomainAssembly, int level, BOOL attaching); + void NotifyDebuggerUnload(); void SetDebuggerInfoBits(DebuggerAssemblyControlFlags newBits); @@ -1639,14 +1646,16 @@ struct cdac_data static constexpr size_t LoaderAllocator = offsetof(Module, m_loaderAllocator); static constexpr size_t ThunkHeap = offsetof(Module, m_pThunkHeap); static constexpr size_t DynamicMetadata = offsetof(Module, m_pDynamicMetadata); + static constexpr size_t Path = offsetof(Module, m_path); // Lookup map pointers - static constexpr size_t FieldDefToDescMap = offsetof(Module, m_FieldDefToDescMap) + offsetof(LookupMap, pTable); - static constexpr size_t ManifestModuleReferencesMap = offsetof(Module, m_ManifestModuleReferencesMap) + offsetof(LookupMap, pTable); - static constexpr size_t MemberRefToDescMap = offsetof(Module, m_MemberRefMap) + offsetof(LookupMap, pTable); - static constexpr size_t MethodDefToDescMap = offsetof(Module, m_MethodDefToDescMap) + offsetof(LookupMap, pTable); - static constexpr size_t TypeDefToMethodTableMap = offsetof(Module, m_TypeDefToMethodTableMap) + offsetof(LookupMap, pTable); - static constexpr size_t TypeRefToMethodTableMap = offsetof(Module, m_TypeRefToMethodTableMap) + offsetof(LookupMap, pTable); + static constexpr size_t FieldDefToDescMap = offsetof(Module, m_FieldDefToDescMap); + static constexpr size_t ManifestModuleReferencesMap = offsetof(Module, m_ManifestModuleReferencesMap); + static constexpr size_t MemberRefToDescMap = offsetof(Module, m_MemberRefMap); + static constexpr size_t MethodDefToDescMap = offsetof(Module, m_MethodDefToDescMap); + static constexpr size_t TypeDefToMethodTableMap = offsetof(Module, m_TypeDefToMethodTableMap); + static constexpr size_t TypeRefToMethodTableMap = offsetof(Module, m_TypeRefToMethodTableMap); + static constexpr size_t MethodDefToILCodeVersioningStateMap = offsetof(Module, m_ILCodeVersioningStateMap); }; // diff --git a/src/coreclr/vm/ceeload.inl b/src/coreclr/vm/ceeload.inl index 1fa6588d991..06a5001c23b 100644 --- a/src/coreclr/vm/ceeload.inl +++ b/src/coreclr/vm/ceeload.inl @@ -285,7 +285,6 @@ inline PTR_ILCodeVersioningState Module::LookupILCodeVersioningState(mdMethodDef } CONTRACTL_END - _ASSERTE(CodeVersionManager::IsLockOwnedByCurrentThread()); _ASSERTE(TypeFromToken(token) == mdtMethodDef); return m_ILCodeVersioningStateMap.GetElement(RidFromToken(token)); } diff --git a/src/coreclr/vm/ceemain.cpp b/src/coreclr/vm/ceemain.cpp index 3a1ab790f47..38c47a97496 100644 --- a/src/coreclr/vm/ceemain.cpp +++ b/src/coreclr/vm/ceemain.cpp @@ -173,7 +173,6 @@ #ifdef FEATURE_COMINTEROP #include "runtimecallablewrapper.h" -#include "mngstdinterfaces.h" #include "interoplibinterface.h" #endif // FEATURE_COMINTEROP @@ -829,11 +828,9 @@ void EEStartupHelper() VirtualCallStubManager::InitStatic(); - // Setup the domains. Threads are started in a default domain. // Static initialization - BaseDomain::Attach(); SystemDomain::Attach(); // Start up the EE initializing all the global variables @@ -845,7 +842,6 @@ void EEStartupHelper() JitHost::Init(); - #ifndef TARGET_UNIX if (!RegisterOutOfProcessWatsonCallbacks()) { @@ -947,7 +943,6 @@ void EEStartupHelper() MethodDesc::Init(); #endif - Assembly::Initialize(); SystemDomain::System()->Init(); diff --git a/src/coreclr/vm/class.cpp b/src/coreclr/vm/class.cpp index e7aec3bce33..f15c87cf3b9 100644 --- a/src/coreclr/vm/class.cpp +++ b/src/coreclr/vm/class.cpp @@ -144,10 +144,6 @@ void EEClass::Destruct(MethodTable * pOwningMT) ExecutableWriterHolder stubWriterHolder(pDelegateEEClass->m_pInstRetBuffCallStub, sizeof(Stub)); stubWriterHolder.GetRW()->DecRef(); } - // While m_pMultiCastInvokeStub is also a member, - // it is owned by the m_pMulticastStubCache, not by the class - // - it is shared across classes. So we don't decrement - // its ref count here } #ifdef FEATURE_COMINTEROP @@ -459,10 +455,10 @@ HRESULT EEClass::AddField(MethodTable* pMT, mdFieldDef fieldDef, FieldDesc** ppN AppDomain::AssemblyIterator appIt = pDomain->IterateAssembliesEx((AssemblyIterationFlags)(kIncludeLoaded | kIncludeExecution)); bool isStaticField = !!pNewFD->IsStatic(); - CollectibleAssemblyHolder pDomainAssembly; - while (appIt.Next(pDomainAssembly.This()) && SUCCEEDED(hr)) + CollectibleAssemblyHolder pAssembly; + while (appIt.Next(pAssembly.This()) && SUCCEEDED(hr)) { - Module* pMod = pDomainAssembly->GetModule(); + Module* pMod = pAssembly->GetModule(); LOG((LF_ENC, LL_INFO100, "EEClass::AddField Checking: %s mod:%p\n", pMod->GetDebugName(), pMod)); EETypeHashTable* paramTypes = pMod->GetAvailableParamTypes(); @@ -655,10 +651,10 @@ HRESULT EEClass::AddMethod(MethodTable* pMT, mdMethodDef methodDef, MethodDesc** PTR_AppDomain pDomain = AppDomain::GetCurrentDomain(); AppDomain::AssemblyIterator appIt = pDomain->IterateAssembliesEx((AssemblyIterationFlags)(kIncludeLoaded | kIncludeExecution)); - CollectibleAssemblyHolder pDomainAssembly; - while (appIt.Next(pDomainAssembly.This()) && SUCCEEDED(hr)) + CollectibleAssemblyHolder pAssembly; + while (appIt.Next(pAssembly.This()) && SUCCEEDED(hr)) { - Module* pMod = pDomainAssembly->GetModule(); + Module* pMod = pAssembly->GetModule(); LOG((LF_ENC, LL_INFO100, "EEClass::AddMethod Checking: %s mod:%p\n", pMod->GetDebugName(), pMod)); EETypeHashTable* paramTypes = pMod->GetAvailableParamTypes(); diff --git a/src/coreclr/vm/class.h b/src/coreclr/vm/class.h index 3d936b7bf69..71044dd056b 100644 --- a/src/coreclr/vm/class.h +++ b/src/coreclr/vm/class.h @@ -1895,11 +1895,9 @@ class DelegateEEClass : public EEClass PTR_Stub m_pStaticCallStub; PTR_Stub m_pInstRetBuffCallStub; PTR_MethodDesc m_pInvokeMethod; - PTR_Stub m_pMultiCastInvokeStub; - PTR_Stub m_pWrapperDelegateInvokeStub; + PCODE m_pMultiCastInvokeStub; + PCODE m_pWrapperDelegateInvokeStub; UMThunkMarshInfo* m_pUMThunkMarshInfo; - PTR_MethodDesc m_pBeginInvokeMethod; - PTR_MethodDesc m_pEndInvokeMethod; Volatile m_pMarshalStub; #ifdef FEATURE_COMINTEROP @@ -1911,16 +1909,6 @@ class DelegateEEClass : public EEClass return m_pInvokeMethod; } - PTR_MethodDesc GetBeginInvokeMethod() - { - return m_pBeginInvokeMethod; - } - - PTR_MethodDesc GetEndInvokeMethod() - { - return m_pEndInvokeMethod; - } - #ifndef DACCESS_COMPILE DelegateEEClass() : EEClass() { @@ -1953,7 +1941,6 @@ class ArrayClass : public EEClass DAC_ALIGNAS(EEClass) // Align the first member to the alignment of the base class unsigned char m_rank; - CorElementType m_ElementType;// Cache of element type in m_ElementTypeHnd public: DWORD GetRank() { @@ -1969,16 +1956,6 @@ class ArrayClass : public EEClass m_rank = (unsigned char)Rank; } - CorElementType GetArrayElementType() { - LIMITED_METHOD_CONTRACT; - return m_ElementType; - } - void SetArrayElementType(CorElementType ElementType) { - LIMITED_METHOD_CONTRACT; - m_ElementType = ElementType; - } - - // Allocate a new MethodDesc for the methods we add to this class void InitArrayMethodDesc( ArrayMethodDesc* pNewMD, diff --git a/src/coreclr/vm/classcompat.cpp b/src/coreclr/vm/classcompat.cpp index ece9384703b..0304440fa41 100644 --- a/src/coreclr/vm/classcompat.cpp +++ b/src/coreclr/vm/classcompat.cpp @@ -2705,13 +2705,13 @@ VOID MethodTableBuilder::EnumerateClassMethods() if (dwMethodRVA == 0) Classification = mcFCall; else - Classification = mcNDirect; + Classification = mcPInvoke; } // The NAT_L attribute is present, marking this method as NDirect else { CONSISTENCY_CHECK(hr == S_OK); - Classification = mcNDirect; + Classification = mcPInvoke; } } else if (IsMiRuntime(dwImplFlags)) @@ -2771,11 +2771,6 @@ VOID MethodTableBuilder::EnumerateClassMethods() // Static methods in interfaces need nothing special. Classification = mcIL; } - else if (bmtProp->fIsMngStandardItf) - { - // If the interface is a standard managed interface then allocate space for an FCall method desc. - Classification = mcFCall; - } else if (IsMdAbstract(dwMemberAttrs)) { // If COM interop is supported then all other interface MDs may be @@ -2840,7 +2835,7 @@ VOID MethodTableBuilder::EnumerateClassMethods() } BYTE type; - if ((Classification & mdfClassification) == mcNDirect) + if ((Classification & mdfClassification) == mcPInvoke) { type = METHOD_TYPE_NDIRECT; } diff --git a/src/coreclr/vm/classcompat.h b/src/coreclr/vm/classcompat.h index 0f022cf4e76..8876334faa1 100644 --- a/src/coreclr/vm/classcompat.h +++ b/src/coreclr/vm/classcompat.h @@ -312,7 +312,6 @@ class MethodTableBuilder // Com Interop, ComWrapper classes extend from ComObject BOOL fIsComObjectType; // whether this class is an instance of ComObject class - BOOL fIsMngStandardItf; // Set to true if the interface is a manages standard interface. BOOL fComEventItfType; // Set to true if the class is a special COM event interface. BOOL fIsValueClass; diff --git a/src/coreclr/vm/classnames.h b/src/coreclr/vm/classnames.h index 29ee7c26d5e..81160ea4ff6 100644 --- a/src/coreclr/vm/classnames.h +++ b/src/coreclr/vm/classnames.h @@ -70,8 +70,6 @@ #define g_ReflectionConstructorName "System.Reflection.RuntimeConstructorInfo" #define g_ReflectionEventInfoName "System.Reflection.EventInfo" #define g_ReflectionEventName "System.Reflection.RuntimeEventInfo" -#define g_CMExpandoToDispatchExMarshaler "System.Runtime.InteropServices.CustomMarshalers.ExpandoToDispatchExMarshaler" -#define g_CMExpandoViewOfDispatchEx "System.Runtime.InteropServices.CustomMarshalers.ExpandoViewOfDispatchEx" #define g_ReflectionFieldName "System.Reflection.RuntimeFieldInfo" #define g_ReflectionMemberInfoName "System.Reflection.MemberInfo" #define g_MethodBaseName "System.Reflection.MethodBase" @@ -86,7 +84,6 @@ #define g_ReflectionParamInfoName "System.Reflection.ParameterInfo" #define g_ReflectionParamName "System.Reflection.RuntimeParameterInfo" #define g_ReflectionPropInfoName "System.Reflection.RuntimePropertyInfo" -#define g_ReflectionReflectItfName "System.Reflection.IReflect" #define g_RuntimeArgumentHandleName "RuntimeArgumentHandle" #define g_RuntimeFieldHandleClassName "System.RuntimeFieldHandle" #define g_RuntimeFieldHandleInternalName "RuntimeFieldHandleInternal" diff --git a/src/coreclr/vm/clrtocomcall.cpp b/src/coreclr/vm/clrtocomcall.cpp index 3df537c9656..4be5a434ba3 100644 --- a/src/coreclr/vm/clrtocomcall.cpp +++ b/src/coreclr/vm/clrtocomcall.cpp @@ -389,13 +389,13 @@ static CallsiteDetails CreateCallsiteDetails(_In_ FramedMethodFrame *pFrame) DelegateEEClass* delegateCls = (DelegateEEClass*)pMD->GetMethodTable()->GetClass(); _ASSERTE(pFrame->GetThis()->GetMethodTable()->IsDelegate()); - if (pMD == delegateCls->m_pBeginInvokeMethod) + if (strcmp(pMD->GetName(), "BeginInvoke") == 0) { callsiteFlags |= CallsiteDetails::BeginInvoke; } else { - _ASSERTE(pMD == delegateCls->m_pEndInvokeMethod); + _ASSERTE(strcmp(pMD->GetName(), "EndInvoke") == 0); callsiteFlags |= CallsiteDetails::EndInvoke; } diff --git a/src/coreclr/vm/clsload.cpp b/src/coreclr/vm/clsload.cpp index c2a2f9c7a90..ce23d1e907f 100644 --- a/src/coreclr/vm/clsload.cpp +++ b/src/coreclr/vm/clsload.cpp @@ -836,27 +836,6 @@ void ClassLoader::EnsureLoaded(TypeHandle typeHnd, ClassLoadLevel level) #endif // DACCESS_COMPILE } -/*static*/ -void ClassLoader::TryEnsureLoaded(TypeHandle typeHnd, ClassLoadLevel level) -{ - WRAPPER_NO_CONTRACT; - -#ifndef DACCESS_COMPILE // Nothing to do for the DAC case - - EX_TRY - { - ClassLoader::EnsureLoaded(typeHnd, level); - } - EX_CATCH - { - // Some type may not load successfully. For eg. generic instantiations - // that do not satisfy the constraints of the type arguments. - } - EX_END_CATCH(RethrowTerminalExceptions); - -#endif // DACCESS_COMPILE -} - /* static */ TypeHandle ClassLoader::LookupTypeKey(const TypeKey *pKey, EETypeHashTable *pTable) { @@ -2695,7 +2674,7 @@ TypeHandle ClassLoader::CreateTypeHandleForTypeKey(const TypeKey* pKey, AllocMem DWORD numArgs = pKey->GetNumArgs(); BYTE* mem = (BYTE*) pamTracker->Track(pLoaderModule->GetAssembly()->GetLowFrequencyHeap()->AllocMem(S_SIZE_T(sizeof(FnPtrTypeDesc)) + S_SIZE_T(sizeof(TypeHandle)) * S_SIZE_T(numArgs))); - typeHnd = TypeHandle(new(mem) FnPtrTypeDesc(pKey->GetCallConv(), numArgs, pKey->GetRetAndArgTypes())); + typeHnd = TypeHandle(new(mem) FnPtrTypeDesc(pKey->GetCallConv(), numArgs, pKey->GetRetAndArgTypes(), pLoaderModule)); } else { diff --git a/src/coreclr/vm/clsload.hpp b/src/coreclr/vm/clsload.hpp index 95afa2716ec..f6cb4f06c00 100644 --- a/src/coreclr/vm/clsload.hpp +++ b/src/coreclr/vm/clsload.hpp @@ -564,11 +564,6 @@ class ClassLoader Module * pLookInThisModuleOnly, Loader::LoadFlag loadFlag); - static PTR_Module ComputeLoaderModuleForCompilation(Module *pDefinitionModule, // the module that declares the generic type or method - mdToken token, - Instantiation classInst, // the type arguments to the type (if any) - Instantiation methodInst); // the type arguments to the method (if any) - public: void Init(AllocMemTracker *pamTracker); @@ -718,7 +713,6 @@ class ClassLoader BOOL * pfUsesTypeForwarder = NULL); static void EnsureLoaded(TypeHandle typeHnd, ClassLoadLevel level = CLASS_LOADED); - static void TryEnsureLoaded(TypeHandle typeHnd, ClassLoadLevel level = CLASS_LOADED); public: // Look up a class by name @@ -889,24 +883,7 @@ class ClassLoader static void DECLSPEC_NORETURN ThrowTypeLoadException(const TypeKey *pKey, UINT resIDWhy); - - BOOL IsNested(const NameHandle* pName, mdToken *mdEncloser); - static BOOL IsNested(ModuleBase *pModude, mdToken typeDefOrRef, mdToken *mdEncloser); - public: - // Helpers for FindClassModule() - BOOL CompareNestedEntryWithTypeDef(IMDInternalImport *pImport, - mdTypeDef mdCurrent, - EEClassHashTable *pClassHash, - PTR_EEClassHashEntry pEntry); - BOOL CompareNestedEntryWithTypeRef(IMDInternalImport *pImport, - mdTypeRef mdCurrent, - EEClassHashTable *pClassHash, - PTR_EEClassHashEntry pEntry); - BOOL CompareNestedEntryWithExportedType(IMDInternalImport *pImport, - mdExportedType mdCurrent, - EEClassHashTable *pClassHash, - PTR_EEClassHashEntry pEntry); //Attempts to find/load/create a type handle but does not throw // if used in "find" mode. diff --git a/src/coreclr/vm/codeman.cpp b/src/coreclr/vm/codeman.cpp index d019affc33b..0314a2920f0 100644 --- a/src/coreclr/vm/codeman.cpp +++ b/src/coreclr/vm/codeman.cpp @@ -2376,6 +2376,16 @@ HeapList* LoaderCodeHeap::CreateCodeHeap(CodeHeapRequestInfo *pInfo, LoaderHeap } else { + // Include internal CodeHeap structures in the reserve + allocationSize = ALIGN_UP(allocationSize, VIRTUAL_ALLOC_RESERVE_GRANULARITY); + reserveSize = max(reserveSize, allocationSize); + + if (reserveSize != (DWORD) reserveSize) + { + _ASSERTE(!"reserveSize does not fit in a DWORD"); + EEPOLICY_HANDLE_FATAL_ERROR(COR_E_EXECUTIONENGINE); + } + if (loAddr != NULL || hiAddr != NULL) { #ifdef _DEBUG diff --git a/src/coreclr/vm/codeman.h b/src/coreclr/vm/codeman.h index 0ff86927b6a..7ea0d5dbff8 100644 --- a/src/coreclr/vm/codeman.h +++ b/src/coreclr/vm/codeman.h @@ -108,9 +108,6 @@ enum StubCodeBlockKind : int STUB_CODE_BLOCK_NOCODE, STUB_CODE_BLOCK_MANAGED, STUB_CODE_BLOCK_STUBLINK, - // Placeholdes used by NGen images - STUB_CODE_BLOCK_VIRTUAL_METHOD_THUNK, - STUB_CODE_BLOCK_EXTERNAL_METHOD_THUNK, // Placeholdes used by ReadyToRun images STUB_CODE_BLOCK_METHOD_CALL_THUNK, }; diff --git a/src/coreclr/vm/codeversion.cpp b/src/coreclr/vm/codeversion.cpp index 846168cf5cd..4fb4364ff33 100644 --- a/src/coreclr/vm/codeversion.cpp +++ b/src/coreclr/vm/codeversion.cpp @@ -94,12 +94,6 @@ ReJITID NativeCodeVersionNode::GetILVersionId() const ILCodeVersion NativeCodeVersionNode::GetILCodeVersion() const { LIMITED_METHOD_DAC_CONTRACT; -#ifdef DEBUG - if (GetILVersionId() != 0) - { - _ASSERTE(CodeVersionManager::IsLockOwnedByCurrentThread()); - } -#endif PTR_MethodDesc pMD = GetMethodDesc(); return pMD->GetCodeVersionManager()->GetILCodeVersion(pMD, GetILVersionId()); } @@ -169,7 +163,7 @@ void NativeCodeVersionNode::SetOptimizationTier(NativeCodeVersion::OptimizationT #ifdef FEATURE_ON_STACK_REPLACEMENT -PatchpointInfo* NativeCodeVersionNode::GetOSRInfo(unsigned * ilOffset) +PatchpointInfo* NativeCodeVersionNode::GetOSRInfo(unsigned * ilOffset) const { LIMITED_METHOD_DAC_CONTRACT; *ilOffset = m_ilOffset; @@ -622,14 +616,12 @@ DWORD ILCodeVersionNode::GetJitFlags() const const InstrumentedILOffsetMapping* ILCodeVersionNode::GetInstrumentedILMap() const { LIMITED_METHOD_DAC_CONTRACT; - _ASSERTE(CodeVersionManager::IsLockOwnedByCurrentThread()); return &m_instrumentedILMap; } PTR_ILCodeVersionNode ILCodeVersionNode::GetNextILVersionNode() const { LIMITED_METHOD_DAC_CONTRACT; - _ASSERTE(CodeVersionManager::IsLockOwnedByCurrentThread()); return m_pNextILVersionNode; } @@ -812,6 +804,8 @@ NativeCodeVersionCollection ILCodeVersion::GetNativeCodeVersions(PTR_MethodDesc NativeCodeVersion ILCodeVersion::GetActiveNativeCodeVersion(PTR_MethodDesc pClosedMethodDesc) const { LIMITED_METHOD_DAC_CONTRACT; + _ASSERTE(CodeVersionManager::IsLockOwnedByCurrentThread()); + NativeCodeVersionCollection versions = GetNativeCodeVersions(pClosedMethodDesc); for (NativeCodeVersionIterator cur = versions.Begin(), end = versions.End(); cur != end; cur++) { @@ -1019,6 +1013,8 @@ HRESULT ILCodeVersion::AddNativeCodeVersion( HRESULT ILCodeVersion::GetOrCreateActiveNativeCodeVersion(MethodDesc* pClosedMethodDesc, NativeCodeVersion* pActiveNativeCodeVersion) { LIMITED_METHOD_CONTRACT; + _ASSERTE(CodeVersionManager::IsLockOwnedByCurrentThread()); + HRESULT hr = S_OK; NativeCodeVersion activeNativeChild = GetActiveNativeCodeVersion(pClosedMethodDesc); if (activeNativeChild.IsNull()) @@ -1143,7 +1139,6 @@ void ILCodeVersionIterator::Next() } if (m_stage == IterationStage::ImplicitCodeVersion) { - _ASSERTE(CodeVersionManager::IsLockOwnedByCurrentThread()); CodeVersionManager* pCodeVersionManager = m_pCollection->m_pModule->GetCodeVersionManager(); PTR_ILCodeVersioningState pILCodeVersioningState = pCodeVersionManager->GetILCodeVersioningState(m_pCollection->m_pModule, m_pCollection->m_methodDef); if (pILCodeVersioningState != NULL) @@ -1235,7 +1230,7 @@ void MethodDescVersioningState::LinkNativeCodeVersionNode(NativeCodeVersionNode* { LIMITED_METHOD_CONTRACT; pNativeCodeVersionNode->m_pNextMethodDescSibling = m_pFirstVersionNode; - m_pFirstVersionNode = pNativeCodeVersionNode; + VolatileStore(&m_pFirstVersionNode, pNativeCodeVersionNode); } #endif @@ -1297,8 +1292,9 @@ void ILCodeVersioningState::SetActiveVersion(ILCodeVersion ilActiveCodeVersion) void ILCodeVersioningState::LinkILCodeVersionNode(ILCodeVersionNode* pILCodeVersionNode) { LIMITED_METHOD_CONTRACT; + _ASSERTE(CodeVersionManager::IsLockOwnedByCurrentThread()); pILCodeVersionNode->SetNextILVersionNode(m_pFirstVersionNode); - m_pFirstVersionNode = pILCodeVersionNode; + VolatileStore(&m_pFirstVersionNode, pILCodeVersionNode); } #endif @@ -1309,6 +1305,7 @@ bool CodeVersionManager::s_initialNativeCodeVersionMayNotBeTheDefaultNativeCodeV PTR_ILCodeVersioningState CodeVersionManager::GetILCodeVersioningState(PTR_Module pModule, mdMethodDef methodDef) const { LIMITED_METHOD_DAC_CONTRACT; + // Safe without any locks, because this uses a LookupMap, which is safe for concurrent reads of pre-initialized data return pModule->LookupILCodeVersioningState(methodDef); } @@ -1408,14 +1405,12 @@ BOOL CodeVersionManager::HasNonDefaultILVersions() ILCodeVersionCollection CodeVersionManager::GetILCodeVersions(PTR_MethodDesc pMethod) { LIMITED_METHOD_DAC_CONTRACT; - _ASSERTE(IsLockOwnedByCurrentThread()); return GetILCodeVersions(dac_cast(pMethod->GetModule()), pMethod->GetMemberDef()); } ILCodeVersionCollection CodeVersionManager::GetILCodeVersions(PTR_Module pModule, mdMethodDef methodDef) { LIMITED_METHOD_DAC_CONTRACT; - _ASSERTE(IsLockOwnedByCurrentThread()); return ILCodeVersionCollection(pModule, methodDef); } @@ -1444,7 +1439,6 @@ ILCodeVersion CodeVersionManager::GetActiveILCodeVersion(PTR_Module pModule, mdM ILCodeVersion CodeVersionManager::GetILCodeVersion(PTR_MethodDesc pMethod, ReJITID rejitId) { LIMITED_METHOD_DAC_CONTRACT; - _ASSERTE(IsLockOwnedByCurrentThread()); #ifdef FEATURE_REJIT ILCodeVersionCollection collection = GetILCodeVersions(pMethod); @@ -1465,14 +1459,12 @@ ILCodeVersion CodeVersionManager::GetILCodeVersion(PTR_MethodDesc pMethod, ReJIT NativeCodeVersionCollection CodeVersionManager::GetNativeCodeVersions(PTR_MethodDesc pMethod) const { LIMITED_METHOD_DAC_CONTRACT; - _ASSERTE(IsLockOwnedByCurrentThread()); return NativeCodeVersionCollection(pMethod, ILCodeVersion()); } NativeCodeVersion CodeVersionManager::GetNativeCodeVersion(PTR_MethodDesc pMethod, PCODE codeStartAddress) const { LIMITED_METHOD_DAC_CONTRACT; - _ASSERTE(IsLockOwnedByCurrentThread()); NativeCodeVersionCollection nativeCodeVersions = GetNativeCodeVersions(pMethod); for (NativeCodeVersionIterator cur = nativeCodeVersions.Begin(), end = nativeCodeVersions.End(); cur != end; cur++) @@ -2063,8 +2055,8 @@ HRESULT CodeVersionManager::EnumerateDomainClosedMethodDescs( pModuleContainingMethodDef, methodDef, assemFlags); - CollectibleAssemblyHolder pDomainAssembly; - while (it.Next(pDomainAssembly.This())) + CollectibleAssemblyHolder pAssembly; + while (it.Next(pAssembly.This())) { MethodDesc * pLoadedMD = it.Current(); diff --git a/src/coreclr/vm/codeversion.h b/src/coreclr/vm/codeversion.h index bd778bd47d7..faf01578836 100644 --- a/src/coreclr/vm/codeversion.h +++ b/src/coreclr/vm/codeversion.h @@ -263,11 +263,11 @@ class NativeCodeVersionNode PatchpointInfo* patchpointInfo, unsigned ilOffset); #endif - PTR_MethodDesc GetMethodDesc() const; - NativeCodeVersionId GetVersionId() const; - PCODE GetNativeCode() const; - ReJITID GetILVersionId() const; - ILCodeVersion GetILCodeVersion() const; + PTR_MethodDesc GetMethodDesc() const; // Can be called without any locks + NativeCodeVersionId GetVersionId() const; // Can be called without any locks + PCODE GetNativeCode() const; // Can be called without any locks, but result may be stale if it wasn't already set + ReJITID GetILVersionId() const; // Can be called without any locks + ILCodeVersion GetILCodeVersion() const;// Can be called without any locks BOOL IsActiveChildVersion() const; #ifndef DACCESS_COMPILE BOOL SetNativeCodeInterlocked(PCODE pCode, PCODE pExpected); @@ -287,28 +287,28 @@ class NativeCodeVersionNode #endif #ifdef FEATURE_ON_STACK_REPLACEMENT - PatchpointInfo * GetOSRInfo(unsigned * ilOffset); + PatchpointInfo * GetOSRInfo(unsigned * ilOffset) const; #endif private: //union - could save a little memory? //{ PCODE m_pNativeCode; - PTR_MethodDesc m_pMethodDesc; + DAC_IGNORE(const) PTR_MethodDesc m_pMethodDesc; //}; - ReJITID m_parentId; - PTR_NativeCodeVersionNode m_pNextMethodDescSibling; - NativeCodeVersionId m_id; + DAC_IGNORE(const) ReJITID m_parentId; + PTR_NativeCodeVersionNode m_pNextMethodDescSibling; // Never modified after being added to the linked list + DAC_IGNORE(const) NativeCodeVersionId m_id; #ifdef FEATURE_TIERED_COMPILATION - NativeCodeVersion::OptimizationTier m_optTier; + NativeCodeVersion::OptimizationTier m_optTier; // Set in constructor, but as the JIT runs it may upgrade the optimization tier #endif #ifdef HAVE_GCCOVER PTR_GCCoverageInfo m_gcCover; #endif #ifdef FEATURE_ON_STACK_REPLACEMENT - PTR_PatchpointInfo m_patchpointInfo; - unsigned m_ilOffset; + DAC_IGNORE(const) PTR_PatchpointInfo m_patchpointInfo; + DAC_IGNORE(const) unsigned m_ilOffset; #endif enum NativeCodeVersionNodeFlags @@ -388,10 +388,10 @@ class ILCodeVersionNode #endif private: - PTR_Module m_pModule; - mdMethodDef m_methodDef; - ReJITID m_rejitId; - PTR_ILCodeVersionNode m_pNextILVersionNode; + const PTR_Module m_pModule; + const mdMethodDef m_methodDef; + const ReJITID m_rejitId; + PTR_ILCodeVersionNode m_pNextILVersionNode; // Never modified after being added to the linked list Volatile m_rejitState; VolatilePtr m_pIL; Volatile m_jitFlags; diff --git a/src/coreclr/vm/comdelegate.cpp b/src/coreclr/vm/comdelegate.cpp index 2cb10d29b1a..63eee56011b 100644 --- a/src/coreclr/vm/comdelegate.cpp +++ b/src/coreclr/vm/comdelegate.cpp @@ -1945,19 +1945,8 @@ PCODE COMDelegate::GetInvokeMethodStub(EEImplMethodDesc* pMD) } else { - - // Since we do not support asynchronous delegates in CoreCLR, we much ensure that it was indeed a async delegate call - // and not an invalid-delegate-layout condition. - // - // If the call was indeed for async delegate invocation, we will just throw an exception. - if ((pMD == pClass->GetBeginInvokeMethod()) || (pMD == pClass->GetEndInvokeMethod())) - { - COMPlusThrow(kPlatformNotSupportedException); - } - - - _ASSERTE(!"Bad Delegate layout"); - COMPlusThrow(kInvalidProgramException); + // We do not support asynchronous delegates in CoreCLR + COMPlusThrow(kPlatformNotSupportedException); } RETURN ret; @@ -2137,8 +2126,7 @@ FCIMPL1(PCODE, COMDelegate::GetMulticastInvoke, MethodTable* pDelegateMT) _ASSERTE(pDelegateMT != NULL); DelegateEEClass* delegateEEClass = (DelegateEEClass*)pDelegateMT->GetClass(); - Stub *pStub = delegateEEClass->m_pMultiCastInvokeStub; - return (pStub != NULL) ? pStub->GetEntryPoint() : (PCODE)NULL; + return delegateEEClass->m_pMultiCastInvokeStub; } FCIMPLEND @@ -2147,13 +2135,13 @@ extern "C" PCODE QCALLTYPE Delegate_GetMulticastInvokeSlow(MethodTable* pDelegat QCALL_CONTRACT; _ASSERTE(pDelegateMT != NULL); - PCODE fptr = (PCODE)NULL; + PCODE pStub = (PCODE)NULL; BEGIN_QCALL; DelegateEEClass *delegateEEClass = (DelegateEEClass*)pDelegateMT->GetClass(); - Stub *pStub = delegateEEClass->m_pMultiCastInvokeStub; - if (pStub == NULL) + pStub = delegateEEClass->m_pMultiCastInvokeStub; + if (pStub == (PCODE)NULL) { MethodDesc* pMD = delegateEEClass->GetInvokeMethod(); @@ -2263,17 +2251,15 @@ extern "C" PCODE QCALLTYPE Delegate_GetMulticastInvokeSlow(MethodTable* pDelegat pSig, cbSig, NULL, &sl); - pStub = Stub::NewStub(JitILStub(pStubMD)); + pStub = JitILStub(pStubMD); - InterlockedCompareExchangeT(&delegateEEClass->m_pMultiCastInvokeStub, pStub, NULL); + InterlockedCompareExchangeT(&delegateEEClass->m_pMultiCastInvokeStub, pStub, (PCODE)NULL); pStub = delegateEEClass->m_pMultiCastInvokeStub; } - fptr = pStub->GetEntryPoint(); - END_QCALL; - return fptr; + return pStub; } PCODE COMDelegate::GetWrapperInvoke(MethodDesc* pMD) @@ -2288,11 +2274,10 @@ PCODE COMDelegate::GetWrapperInvoke(MethodDesc* pMD) MethodTable * pDelegateMT = pMD->GetMethodTable(); DelegateEEClass* delegateEEClass = (DelegateEEClass*) pDelegateMT->GetClass(); - Stub *pStub = delegateEEClass->m_pWrapperDelegateInvokeStub; + PCODE pStub = delegateEEClass->m_pWrapperDelegateInvokeStub; - if (pStub == NULL) + if (pStub == (PCODE)NULL) { - GCX_PREEMP(); MetaSig sig(pMD); @@ -2333,12 +2318,12 @@ PCODE COMDelegate::GetWrapperInvoke(MethodDesc* pMD) NULL, &sl); - pStub = Stub::NewStub(JitILStub(pStubMD)); - - InterlockedCompareExchangeT(&delegateEEClass->m_pWrapperDelegateInvokeStub, pStub, NULL); + pStub = JitILStub(pStubMD); + InterlockedCompareExchangeT(&delegateEEClass->m_pWrapperDelegateInvokeStub, pStub, (PCODE)NULL); + pStub = delegateEEClass->m_pWrapperDelegateInvokeStub; } - return pStub->GetEntryPoint(); + return pStub; } diff --git a/src/coreclr/vm/comdelegate.h b/src/coreclr/vm/comdelegate.h index bb12973f505..a195264acdb 100644 --- a/src/coreclr/vm/comdelegate.h +++ b/src/coreclr/vm/comdelegate.h @@ -213,7 +213,7 @@ class ShuffleThunkCache : public StubCacheBase STANDARD_VM_CONTRACT; ((CPUSTUBLINKER*)pstublinker)->EmitShuffleThunk((ShuffleEntry*)pRawStub); - return NEWSTUB_FL_THUNK; + return NEWSTUB_FL_SHUFFLE_THUNK; } //--------------------------------------------------------- diff --git a/src/coreclr/vm/common.h b/src/coreclr/vm/common.h index 92e9c5f1d58..0cac8853053 100644 --- a/src/coreclr/vm/common.h +++ b/src/coreclr/vm/common.h @@ -101,14 +101,13 @@ using std::min; typedef VPTR(class LoaderAllocator) PTR_LoaderAllocator; typedef DPTR(PTR_LoaderAllocator) PTR_PTR_LoaderAllocator; -typedef VPTR(class AppDomain) PTR_AppDomain; +typedef DPTR(class AppDomain) PTR_AppDomain; typedef DPTR(class ArrayBase) PTR_ArrayBase; typedef DPTR(class Assembly) PTR_Assembly; typedef DPTR(class AssemblyBaseObject) PTR_AssemblyBaseObject; typedef DPTR(class AssemblyLoadContextBaseObject) PTR_AssemblyLoadContextBaseObject; typedef DPTR(class AssemblyBinder) PTR_AssemblyBinder; typedef DPTR(class AssemblyNameBaseObject) PTR_AssemblyNameBaseObject; -typedef VPTR(class BaseDomain) PTR_BaseDomain; typedef DPTR(class ClassLoader) PTR_ClassLoader; typedef DPTR(class ComCallMethodDesc) PTR_ComCallMethodDesc; typedef DPTR(class CLRToCOMCallMethodDesc) PTR_CLRToCOMCallMethodDesc; diff --git a/src/coreclr/vm/comsynchronizable.cpp b/src/coreclr/vm/comsynchronizable.cpp index 23dfb4d2388..7f1751aaa15 100644 --- a/src/coreclr/vm/comsynchronizable.cpp +++ b/src/coreclr/vm/comsynchronizable.cpp @@ -69,37 +69,28 @@ static INT32 MapToNTPriority(INT32 ours) } CONTRACTL_END; - INT32 NTPriority = 0; - switch (ours) { case ThreadNative::PRIORITY_LOWEST: - NTPriority = THREAD_PRIORITY_LOWEST; - break; + return THREAD_PRIORITY_LOWEST; case ThreadNative::PRIORITY_BELOW_NORMAL: - NTPriority = THREAD_PRIORITY_BELOW_NORMAL; - break; + return THREAD_PRIORITY_BELOW_NORMAL; case ThreadNative::PRIORITY_NORMAL: - NTPriority = THREAD_PRIORITY_NORMAL; - break; + return THREAD_PRIORITY_NORMAL; case ThreadNative::PRIORITY_ABOVE_NORMAL: - NTPriority = THREAD_PRIORITY_ABOVE_NORMAL; - break; + return THREAD_PRIORITY_ABOVE_NORMAL; case ThreadNative::PRIORITY_HIGHEST: - NTPriority = THREAD_PRIORITY_HIGHEST; - break; + return THREAD_PRIORITY_HIGHEST; default: COMPlusThrow(kArgumentOutOfRangeException, W("Argument_InvalidFlag")); } - return NTPriority; } - // Map to our exposed notion of thread priorities from the enumeration that NT uses. INT32 MapFromNTPriority(INT32 NTPriority) { @@ -252,6 +243,8 @@ extern "C" void QCALLTYPE ThreadNative_Start(QCall::ThreadHandle thread, int thr void ThreadNative::Start(Thread* pNewThread, int threadStackSize, int priority, PCWSTR pThreadName) { + STANDARD_VM_CONTRACT; + _ASSERTE(pNewThread != NULL); // Is the thread already started? You can't restart a thread. @@ -292,7 +285,9 @@ void ThreadNative::Start(Thread* pNewThread, int threadStackSize, int priority, // After we have established the thread handle, we can check m_Priority. // This ordering is required to eliminate the race condition on setting the // priority of a thread just as it starts up. - pNewThread->SetThreadPriority(MapToNTPriority(priority)); + INT32 NTPriority = MapToNTPriority(priority); + + pNewThread->SetThreadPriority(NTPriority); pNewThread->ChooseThreadCPUGroupAffinity(); pNewThread->SetThreadState(Thread::TS_LegalToJoin); @@ -326,147 +321,58 @@ void ThreadNative::Start(Thread* pNewThread, int threadStackSize, int priority, } } -// Note that you can manipulate the priority of a thread that hasn't started yet, -// or one that is running. But you get an exception if you manipulate the priority -// of a thread that has died. -FCIMPL1(INT32, ThreadNative::GetPriority, ThreadBaseObject* pThisUNSAFE) +extern "C" void QCALLTYPE ThreadNative_SetPriority(QCall::ObjectHandleOnStack thread, INT32 iPriority) { - FCALL_CONTRACT; - - if (pThisUNSAFE==NULL) - FCThrowRes(kNullReferenceException, W("NullReference_This")); - - // validate the handle - if (ThreadIsDead(pThisUNSAFE->GetInternal())) - FCThrowRes(kThreadStateException, W("ThreadState_Dead_Priority")); - - return pThisUNSAFE->m_Priority; -} -FCIMPLEND + QCALL_CONTRACT; -FCIMPL2(void, ThreadNative::SetPriority, ThreadBaseObject* pThisUNSAFE, INT32 iPriority) -{ - FCALL_CONTRACT; + BEGIN_QCALL; - int priority; - Thread *thread; + GCX_COOP(); - THREADBASEREF pThis = (THREADBASEREF) pThisUNSAFE; - HELPER_METHOD_FRAME_BEGIN_1(pThis); + THREADBASEREF threadRef = NULL; + GCPROTECT_BEGIN(threadRef) + threadRef = (THREADBASEREF)thread.Get(); - if (pThis==NULL) - { + if (threadRef == NULL) COMPlusThrow(kNullReferenceException, W("NullReference_This")); - } - // translate the priority (validating as well) - priority = MapToNTPriority(iPriority); // can throw; needs a frame - - // validate the thread - thread = pThis->GetInternal(); - - if (ThreadIsDead(thread)) - { + // Note that you can manipulate the priority of a thread that hasn't started yet, + // or one that is running. But you get an exception if you manipulate the priority + // of a thread that has died. + Thread* th = threadRef->GetInternal(); + if (ThreadIsDead(th)) COMPlusThrow(kThreadStateException, W("ThreadState_Dead_Priority")); - } - INT32 oldPriority = pThis->m_Priority; + // translate the priority (validating as well) + INT32 priority = MapToNTPriority(iPriority); + + INT32 oldPriority = threadRef->GetPriority(); - // Eliminate the race condition by establishing m_Priority before we check for if - // the thread is running. See ThreadNative::Start() for the other half. - pThis->m_Priority = iPriority; + // Eliminate the race condition by setting priority field before we check for if + // the thread is running. See ThreadNative::Start() for the other half. + threadRef->SetPriority(iPriority); - if (!thread->SetThreadPriority(priority)) + if (!th->SetThreadPriority(priority)) { - pThis->m_Priority = oldPriority; + threadRef->SetPriority(oldPriority); COMPlusThrow(kThreadStateException, W("ThreadState_SetPriorityFailed")); } - HELPER_METHOD_FRAME_END(); -} -FCIMPLEND - -FCIMPL1(FC_BOOL_RET, ThreadNative::IsAlive, ThreadBaseObject* pThisUNSAFE) -{ - FCALL_CONTRACT; - - if (pThisUNSAFE==NULL) - FCThrowRes(kNullReferenceException, W("NullReference_This")); - - THREADBASEREF thisRef(pThisUNSAFE); - BOOL ret = false; - - // Keep managed Thread object alive, since the native object's - // lifetime is tied to the managed object's finalizer. And with - // resurrection, it may be possible to get a dangling pointer here - - // consider both protecting thisRef and setting the managed object's - // Thread* to NULL in the GC's ScanForFinalization method. - HELPER_METHOD_FRAME_BEGIN_RET_1(thisRef); - - Thread *thread = thisRef->GetInternal(); - - if (thread == 0) - COMPlusThrow(kThreadStateException, IDS_EE_THREAD_CANNOT_GET); - - ret = ThreadIsRunning(thread); - - HELPER_METHOD_POLL(); - HELPER_METHOD_FRAME_END(); - - FC_RETURN_BOOL(ret); -} -FCIMPLEND - -FCIMPL2(FC_BOOL_RET, ThreadNative::Join, ThreadBaseObject* pThisUNSAFE, INT32 Timeout) -{ - FCALL_CONTRACT; - - BOOL retVal = FALSE; - THREADBASEREF pThis = (THREADBASEREF) pThisUNSAFE; - - HELPER_METHOD_FRAME_BEGIN_RET_1(pThis); - - if (pThis==NULL) - COMPlusThrow(kNullReferenceException, W("NullReference_This")); - - // validate the timeout - if ((Timeout < 0) && (Timeout != INFINITE_TIMEOUT)) - COMPlusThrowArgumentOutOfRange(W("millisecondsTimeout"), W("ArgumentOutOfRange_NeedNonNegOrNegative1")); - - retVal = DoJoin(pThis, Timeout); - - HELPER_METHOD_FRAME_END(); - - FC_RETURN_BOOL(retVal); + GCPROTECT_END(); + END_QCALL; } -FCIMPLEND -NOINLINE static Object* GetCurrentThreadHelper() +extern "C" void QCALLTYPE ThreadNative_GetCurrentThread(QCall::ObjectHandleOnStack thread) { - FCALL_CONTRACT; - FC_INNER_PROLOG(ThreadNative::GetCurrentThread); - OBJECTREF refRetVal = NULL; + QCALL_CONTRACT; - HELPER_METHOD_FRAME_BEGIN_RET_ATTRIB_1(Frame::FRAME_ATTR_EXACT_DEPTH|Frame::FRAME_ATTR_CAPTURE_DEPTH_2, refRetVal); - refRetVal = GetThread()->GetExposedObject(); - HELPER_METHOD_FRAME_END(); + BEGIN_QCALL; - FC_INNER_EPILOG(); - return OBJECTREFToObject(refRetVal); -} + GCX_COOP(); + thread.Set(GetThread()->GetExposedObject()); -FCIMPL0(Object*, ThreadNative::GetCurrentThread) -{ - FCALL_CONTRACT; - OBJECTHANDLE ExposedObject = GetThread()->m_ExposedObject; - _ASSERTE(ExposedObject != 0); //Thread's constructor always initializes its GCHandle - Object* result = *((Object**) ExposedObject); - if (result != 0) - return result; - - FC_INNER_RETURN(Object*, GetCurrentThreadHelper()); + END_QCALL; } -FCIMPLEND extern "C" UINT64 QCALLTYPE ThreadNative_GetCurrentOSThreadId() { @@ -490,33 +396,36 @@ extern "C" UINT64 QCALLTYPE ThreadNative_GetCurrentOSThreadId() return threadId; } -FCIMPL1(void, ThreadNative::Initialize, ThreadBaseObject* pThisUNSAFE) +extern "C" void QCALLTYPE ThreadNative_Initialize(QCall::ObjectHandleOnStack t) { - FCALL_CONTRACT; + QCALL_CONTRACT; - THREADBASEREF pThis = (THREADBASEREF) pThisUNSAFE; + BEGIN_QCALL; - HELPER_METHOD_FRAME_BEGIN_1(pThis); + GCX_COOP(); - _ASSERTE(pThis != NULL); - _ASSERTE(pThis->m_InternalThread == NULL); + THREADBASEREF threadRef = NULL; + GCPROTECT_BEGIN(threadRef) + threadRef = (THREADBASEREF)t.Get(); + + _ASSERTE(threadRef != NULL); + _ASSERTE(threadRef->GetInternal() == NULL); // if we don't have an internal Thread object associated with this exposed object, // now is our first opportunity to create one. - Thread *unstarted = SetupUnstartedThread(); - + Thread* unstarted = SetupUnstartedThread(); PREFIX_ASSUME(unstarted != NULL); - pThis->SetInternal(unstarted); - pThis->SetManagedThreadId(unstarted->GetThreadId()); - unstarted->SetExposedObject(pThis); + threadRef->SetInternal(unstarted); + threadRef->SetManagedThreadId(unstarted->GetThreadId()); + unstarted->SetExposedObject(threadRef); // Initialize the thread priority to normal. - pThis->SetPriority(ThreadNative::PRIORITY_NORMAL); + threadRef->SetPriority(ThreadNative::PRIORITY_NORMAL); - HELPER_METHOD_FRAME_END(); + GCPROTECT_END(); + END_QCALL; } -FCIMPLEND // Return whether or not this is a background thread. FCIMPL1(FC_BOOL_RET, ThreadNative::GetIsBackground, ThreadBaseObject* pThisUNSAFE) @@ -537,137 +446,67 @@ FCIMPL1(FC_BOOL_RET, ThreadNative::GetIsBackground, ThreadBaseObject* pThisUNSAF FCIMPLEND // Deliver the state of the thread as a consistent set of bits. -// This copied in VM\EEDbgInterfaceImpl.h's -// CorDebugUserState GetUserState( Thread *pThread ) -// , so propagate changes to both functions -FCIMPL1(INT32, ThreadNative::GetThreadState, ThreadBaseObject* pThisUNSAFE) +// Duplicate logic in DacDbiInterfaceImpl::GetPartialUserState() +extern "C" INT32 QCALLTYPE ThreadNative_GetThreadState(QCall::ThreadHandle thread) { - FCALL_CONTRACT; - - INT32 res = 0; - Thread::ThreadState state; - - if (pThisUNSAFE==NULL) - FCThrowRes(kNullReferenceException, W("NullReference_This")); - - // validate the thread. Failure here implies that the thread was finalized - // and then resurrected. - Thread *thread = pThisUNSAFE->GetInternal(); - - if (!thread) - FCThrowEx(kThreadStateException, IDS_EE_THREAD_CANNOT_GET, NULL, NULL, NULL); + CONTRACTL + { + QCALL_CHECK_NO_GC_TRANSITION; + PRECONDITION(thread != NULL); + } + CONTRACTL_END; - HELPER_METHOD_FRAME_BEGIN_RET_0(); + INT32 res = 0; // grab a snapshot - state = thread->GetSnapshotState(); + Thread::ThreadState state = thread->GetSnapshotState(); if (state & Thread::TS_Background) - res |= ThreadBackground; + res |= ThreadNative::ThreadBackground; if (state & Thread::TS_Unstarted) - res |= ThreadUnstarted; + res |= ThreadNative::ThreadUnstarted; // Don't report a StopRequested if the thread has actually stopped. if (state & Thread::TS_Dead) { - res |= ThreadStopped; + res |= ThreadNative::ThreadStopped; } else { if (state & Thread::TS_AbortRequested) - res |= ThreadAbortRequested; + res |= ThreadNative::ThreadAbortRequested; } if (state & Thread::TS_Interruptible) - res |= ThreadWaitSleepJoin; - - HELPER_METHOD_POLL(); - HELPER_METHOD_FRAME_END(); + res |= ThreadNative::ThreadWaitSleepJoin; return res; } -FCIMPLEND #ifdef FEATURE_COMINTEROP_APARTMENT_SUPPORT -// Indicate whether the thread will host an STA (this may fail if the thread has -// already been made part of the MTA, use GetApartmentState or the return state -// from this routine to check for this). -FCIMPL2(INT32, ThreadNative::SetApartmentState, ThreadBaseObject* pThisUNSAFE, INT32 iState) -{ - FCALL_CONTRACT; - - if (pThisUNSAFE==NULL) - FCThrowRes(kNullReferenceException, W("NullReference_This")); - - BOOL ok = TRUE; - THREADBASEREF pThis = (THREADBASEREF) pThisUNSAFE; - - HELPER_METHOD_FRAME_BEGIN_RET_1(pThis); - - Thread *thread = pThis->GetInternal(); - if (!thread) - COMPlusThrow(kThreadStateException, IDS_EE_THREAD_CANNOT_GET); - - { - pThis->EnterObjMonitor(); - - // We can only change the apartment if the thread is unstarted or - // running, and if it's running we have to be in the thread's - // context. - if ((!ThreadNotStarted(thread) && !ThreadIsRunning(thread)) || - (!ThreadNotStarted(thread) && (GetThread() != thread))) - ok = FALSE; - else - { - EX_TRY - { - iState = thread->SetApartment((Thread::ApartmentState)iState); - } - EX_CATCH - { - pThis->LeaveObjMonitor(); - EX_RETHROW; - } - EX_END_CATCH_UNREACHABLE; - } - - pThis->LeaveObjMonitor(); - } - - // Now it's safe to throw exceptions again. - if (!ok) - COMPlusThrow(kThreadStateException); - - HELPER_METHOD_FRAME_END(); - - return iState; -} -FCIMPLEND - // Return whether the thread hosts an STA, is a member of the MTA or is not // currently initialized for COM. -FCIMPL1(INT32, ThreadNative::GetApartmentState, ThreadBaseObject* pThisUNSAFE) +extern "C" INT32 QCALLTYPE ThreadNative_GetApartmentState(QCall::ObjectHandleOnStack t) { - FCALL_CONTRACT; + QCALL_CONTRACT; INT32 retVal = 0; - THREADBASEREF refThis = (THREADBASEREF) ObjectToOBJECTREF(pThisUNSAFE); - - HELPER_METHOD_FRAME_BEGIN_RET_1(refThis); + BEGIN_QCALL; - if (refThis == NULL) + Thread* thread = NULL; { - COMPlusThrow(kNullReferenceException, W("NullReference_This")); - } + GCX_COOP(); + THREADBASEREF threadRef = (THREADBASEREF)t.Get(); + if (threadRef == NULL) + COMPlusThrow(kNullReferenceException, W("NullReference_This")); - Thread* thread = refThis->GetInternal(); + thread = threadRef->GetInternal(); - if (ThreadIsDead(thread)) - { - COMPlusThrow(kThreadStateException, W("ThreadState_Dead_State")); + if (ThreadIsDead(thread)) + COMPlusThrow(kThreadStateException, W("ThreadState_Dead_State")); } retVal = thread->GetApartment(); @@ -686,12 +525,45 @@ FCIMPL1(INT32, ThreadNative::GetApartmentState, ThreadBaseObject* pThisUNSAFE) } #endif // FEATURE_COMINTEROP - HELPER_METHOD_FRAME_END(); - + END_QCALL; return retVal; } -FCIMPLEND +// Indicate whether the thread will host an STA (this may fail if the thread has +// already been made part of the MTA, use GetApartmentState or the return state +// from this routine to check for this). +extern "C" INT32 QCALLTYPE ThreadNative_SetApartmentState(QCall::ObjectHandleOnStack t, INT32 iState) +{ + QCALL_CONTRACT; + + INT32 retVal = 0; + + BEGIN_QCALL; + + Thread* thread = NULL; + { + GCX_COOP(); + THREADBASEREF threadRef = (THREADBASEREF)t.Get(); + if (threadRef == NULL) + COMPlusThrow(kNullReferenceException, W("NullReference_This")); + + thread = threadRef->GetInternal(); + } + + // We can only change the apartment if the thread is unstarted or + // running, and if it's running we have to be in the thread's + // context. + if (!ThreadNotStarted(thread) + && (!ThreadIsRunning(thread) || (GetThread() != thread))) + { + COMPlusThrow(kThreadStateException); + } + + retVal = thread->SetApartment((Thread::ApartmentState)iState); + + END_QCALL; + return retVal; +} #endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT void ReleaseThreadExternalCount(Thread * pThread) @@ -703,23 +575,23 @@ void ReleaseThreadExternalCount(Thread * pThread) typedef Holder ThreadExternalCountHolder; // Wait for the thread to die -BOOL ThreadNative::DoJoin(THREADBASEREF DyingThread, INT32 timeout) +static BOOL DoJoin(THREADBASEREF dyingThread, INT32 timeout) { CONTRACTL { THROWS; GC_TRIGGERS; MODE_COOPERATIVE; - PRECONDITION(DyingThread != NULL); + PRECONDITION(dyingThread != NULL); PRECONDITION((timeout >= 0) || (timeout == INFINITE_TIMEOUT)); } CONTRACTL_END; - Thread * DyingInternal = DyingThread->GetInternal(); + Thread* DyingInternal = dyingThread->GetInternal(); // Validate the handle. It's valid to Join a thread that's not running -- so // long as it was once started. - if (DyingInternal == 0 || + if (DyingInternal == NULL || !(DyingInternal->m_State & Thread::TS_LegalToJoin)) { COMPlusThrow(kThreadStateException, W("ThreadState_NotStarted")); @@ -730,12 +602,8 @@ BOOL ThreadNative::DoJoin(THREADBASEREF DyingThread, INT32 timeout) if (ThreadIsDead(DyingInternal) || !DyingInternal->HasValidThreadHandle()) return TRUE; - DWORD dwTimeOut32 = (timeout == INFINITE_TIMEOUT - ? INFINITE - : (DWORD) timeout); - - // There is a race here. DyingThread is going to close its thread handle. - // If we grab the handle and then DyingThread closes it, we will wait forever + // There is a race here. The Thread is going to close its thread handle. + // If we grab the handle and then the Thread closes it, we will wait forever // in DoAppropriateWait. int RefCount = DyingInternal->IncExternalCount(); if (RefCount == 1) @@ -756,8 +624,11 @@ BOOL ThreadNative::DoJoin(THREADBASEREF DyingThread, INT32 timeout) } GCX_PREEMP(); - DWORD rv = DyingInternal->JoinEx(dwTimeOut32, (WaitMode)(WaitMode_Alertable/*alertable*/|WaitMode_InDeadlock)); + DWORD dwTimeOut32 = (timeout == INFINITE_TIMEOUT + ? INFINITE + : (DWORD) timeout); + DWORD rv = DyingInternal->JoinEx(dwTimeOut32, (WaitMode)(WaitMode_Alertable/*alertable*/|WaitMode_InDeadlock)); switch(rv) { case WAIT_OBJECT_0: @@ -779,6 +650,22 @@ BOOL ThreadNative::DoJoin(THREADBASEREF DyingThread, INT32 timeout) return FALSE; } +extern "C" BOOL QCALLTYPE ThreadNative_Join(QCall::ObjectHandleOnStack thread, INT32 Timeout) +{ + QCALL_CONTRACT; + + BOOL retVal = FALSE; + + BEGIN_QCALL; + + GCX_COOP(); + retVal = DoJoin((THREADBASEREF)thread.Get(), Timeout); + + END_QCALL; + + return retVal; +} + // If the exposed object is created after-the-fact, for an existing thread, we call // InitExisting on it. This is the other "construction", as opposed to SetDelegate. void ThreadBaseObject::InitExisting() @@ -998,16 +885,12 @@ extern "C" void QCALLTYPE ThreadNative_DisableComObjectEagerCleanup(QCall::Threa { CONTRACTL { - QCALL_CHECK; + QCALL_CHECK_NO_GC_TRANSITION; PRECONDITION(thread != NULL); } CONTRACTL_END; - BEGIN_QCALL; - thread->SetDisableComObjectEagerCleanup(); - - END_QCALL; } #endif //FEATURE_COMINTEROP diff --git a/src/coreclr/vm/comsynchronizable.h b/src/coreclr/vm/comsynchronizable.h index b0f5b72295a..b7c64c52908 100644 --- a/src/coreclr/vm/comsynchronizable.h +++ b/src/coreclr/vm/comsynchronizable.h @@ -52,22 +52,9 @@ friend class ThreadBaseObject; ThreadAbortRequested = 128, }; - static FCDECL1(INT32, GetPriority, ThreadBaseObject* pThisUNSAFE); - static FCDECL2(void, SetPriority, ThreadBaseObject* pThisUNSAFE, INT32 iPriority); - static FCDECL1(FC_BOOL_RET, IsAlive, ThreadBaseObject* pThisUNSAFE); - static FCDECL2(FC_BOOL_RET, Join, ThreadBaseObject* pThisUNSAFE, INT32 Timeout); - static FCDECL1(void, Initialize, ThreadBaseObject* pThisUNSAFE); static FCDECL1(FC_BOOL_RET, GetIsBackground, ThreadBaseObject* pThisUNSAFE); - static FCDECL1(INT32, GetThreadState, ThreadBaseObject* pThisUNSAFE); - -#ifdef FEATURE_COMINTEROP_APARTMENT_SUPPORT - static FCDECL1(INT32, GetApartmentState, ThreadBaseObject* pThis); - static FCDECL2(INT32, SetApartmentState, ThreadBaseObject* pThisUNSAFE, INT32 iState); -#endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT - static FCDECL0(INT32, GetOptimalMaxSpinWaitsPerSpinIteration); - static FCDECL0(Object*, GetCurrentThread); static FCDECL1(void, Finalize, ThreadBaseObject* pThis); static FCDECL1(FC_BOOL_RET,IsThreadpoolThread, ThreadBaseObject* thread); static FCDECL1(void, SetIsThreadpoolThread, ThreadBaseObject* thread); @@ -84,14 +71,24 @@ friend class ThreadBaseObject; static void KickOffThread_Worker(LPVOID /* KickOffThread_Args* */); static ULONG WINAPI KickOffThread(void *pass); - static BOOL DoJoin(THREADBASEREF DyingThread, INT32 timeout); }; extern "C" void QCALLTYPE ThreadNative_Start(QCall::ThreadHandle thread, int threadStackSize, int priority, PCWSTR pThreadName); +extern "C" void QCALLTYPE ThreadNative_SetPriority(QCall::ObjectHandleOnStack thread, INT32 iPriority); +extern "C" void QCALLTYPE ThreadNative_GetCurrentThread(QCall::ObjectHandleOnStack thread); extern "C" void QCALLTYPE ThreadNative_SetIsBackground(QCall::ThreadHandle thread, BOOL value); extern "C" void QCALLTYPE ThreadNative_InformThreadNameChange(QCall::ThreadHandle thread, LPCWSTR name, INT32 len); extern "C" BOOL QCALLTYPE ThreadNative_YieldThread(); extern "C" UINT64 QCALLTYPE ThreadNative_GetCurrentOSThreadId(); +extern "C" void QCALLTYPE ThreadNative_Initialize(QCall::ObjectHandleOnStack t); +extern "C" INT32 QCALLTYPE ThreadNative_GetThreadState(QCall::ThreadHandle thread); + +#ifdef FEATURE_COMINTEROP_APARTMENT_SUPPORT +extern "C" INT32 QCALLTYPE ThreadNative_GetApartmentState(QCall::ObjectHandleOnStack t); +extern "C" INT32 QCALLTYPE ThreadNative_SetApartmentState(QCall::ObjectHandleOnStack t, INT32 iState); +#endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT + +extern "C" BOOL QCALLTYPE ThreadNative_Join(QCall::ObjectHandleOnStack thread, INT32 Timeout); extern "C" void QCALLTYPE ThreadNative_Abort(QCall::ThreadHandle thread); extern "C" void QCALLTYPE ThreadNative_ResetAbort(); extern "C" void QCALLTYPE ThreadNative_SpinWait(INT32 iterations); diff --git a/src/coreclr/vm/comutilnative.cpp b/src/coreclr/vm/comutilnative.cpp index 82a855f8864..f15b1085eba 100644 --- a/src/coreclr/vm/comutilnative.cpp +++ b/src/coreclr/vm/comutilnative.cpp @@ -78,29 +78,26 @@ FCIMPLEND // Given an exception object, this method will mark its stack trace as frozen and return it to the caller. // Frozen stack traces are immutable, when a thread attempts to add a frame to it, the stack trace is cloned first. -FCIMPL1(Object *, ExceptionNative::GetFrozenStackTrace, Object* pExceptionObjectUnsafe); +extern "C" void QCALLTYPE ExceptionNative_GetFrozenStackTrace(QCall::ObjectHandleOnStack exception, QCall::ObjectHandleOnStack ret) { - CONTRACTL - { - FCALL_CHECK; - } - CONTRACTL_END; + QCALL_CONTRACT; + + BEGIN_QCALL; - ASSERT(pExceptionObjectUnsafe != NULL); + GCX_COOP(); + + _ASSERTE(exception.Get() != NULL); struct { StackTraceArray stackTrace; EXCEPTIONREF refException = NULL; PTRARRAYREF keepAliveArray = NULL; // Object array of Managed Resolvers / AssemblyLoadContexts - OBJECTREF result = NULL; } gc; - - // GC protect the array reference - HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(gc); + GCPROTECT_BEGIN(gc); // Get the exception object reference - gc.refException = (EXCEPTIONREF)(ObjectToOBJECTREF(pExceptionObjectUnsafe)); + gc.refException = (EXCEPTIONREF)exception.Get(); gc.refException->GetStackTrace(gc.stackTrace, &gc.keepAliveArray); @@ -108,22 +105,20 @@ FCIMPL1(Object *, ExceptionNative::GetFrozenStackTrace, Object* pExceptionObject if (gc.keepAliveArray != NULL) { - gc.result = gc.keepAliveArray; + ret.Set(gc.keepAliveArray); } else { - gc.result = gc.stackTrace.Get(); + ret.Set(gc.stackTrace.Get()); } + GCPROTECT_END(); - HELPER_METHOD_FRAME_END(); - - return OBJECTREFToObject(gc.result); + END_QCALL; } -FCIMPLEND #ifdef FEATURE_COMINTEROP -BSTR BStrFromString(STRINGREF s) +static BSTR BStrFromString(STRINGREF s) { CONTRACTL { @@ -926,34 +921,30 @@ FCIMPLEND /*===============================AllocateNewArray=============================== **Action: Allocates a new array object. Allows passing extra flags -**Returns: The allocated array. -**Arguments: elementTypeHandle -> type of the element, -** length -> number of elements, -** zeroingOptional -> whether caller prefers to skip clearing the content of the array, if possible. +**Arguments: typeHandlePtr -> TypeHandle pointer of array, +** length -> Number of elements, +** flags -> Flags that impact allocated memory, +** ret -> The allocated array. **Exceptions: IDS_EE_ARRAY_DIMENSIONS_EXCEEDED when size is too large. OOM if can't allocate. ==============================================================================*/ -FCIMPL3(Object*, GCInterface::AllocateNewArray, void* arrayTypeHandle, INT32 length, INT32 flags) +extern "C" void QCALLTYPE GCInterface_AllocateNewArray(void* typeHandlePtr, INT32 length, INT32 flags, QCall::ObjectHandleOnStack ret) { - CONTRACTL { - FCALL_CHECK; - } CONTRACTL_END; + QCALL_CONTRACT; + _ASSERTE(typeHandlePtr != NULL); - OBJECTREF pRet = NULL; - TypeHandle arrayType = TypeHandle::FromPtr(arrayTypeHandle); + BEGIN_QCALL; - HELPER_METHOD_FRAME_BEGIN_RET_0(); + GCX_COOP(); + + TypeHandle typeHandle = TypeHandle::FromPtr(typeHandlePtr); + _ASSERTE(typeHandle.IsArray()); //Only the following flags are used by GC.cs, so we'll just assert it here. _ASSERTE((flags & ~(GC_ALLOC_ZEROING_OPTIONAL | GC_ALLOC_PINNED_OBJECT_HEAP)) == 0); + ret.Set(AllocateSzArray(typeHandle, length, (GC_ALLOC_FLAGS)flags)); - pRet = AllocateSzArray(arrayType, length, (GC_ALLOC_FLAGS)flags); - - HELPER_METHOD_FRAME_END(); - - return OBJECTREFToObject(pRet); + END_QCALL; } -FCIMPLEND - FCIMPL0(INT64, GCInterface::GetTotalAllocatedBytesApproximate) { @@ -1873,71 +1864,49 @@ extern "C" BOOL QCALLTYPE TypeHandle_CanCastTo_NoCacheLookup(void* fromTypeHnd, return ret; } -static MethodTable * g_pStreamMT; -static WORD g_slotBeginRead, g_slotEndRead; -static WORD g_slotBeginWrite, g_slotEndWrite; - -static bool HasOverriddenStreamMethod(MethodTable * pMT, WORD slot) +static bool HasOverriddenStreamMethod(MethodTable* streamMT, MethodTable* pMT, WORD slot) { - CONTRACTL{ - THROWS; - GC_NOTRIGGER; - MODE_ANY; + CONTRACTL + { + STANDARD_VM_CHECK; + PRECONDITION(streamMT != NULL); + PRECONDITION(pMT != NULL); } CONTRACTL_END; PCODE actual = pMT->GetRestoredSlot(slot); - PCODE base = g_pStreamMT->GetRestoredSlot(slot); - if (actual == base) - return false; + PCODE base = streamMT->GetRestoredSlot(slot); - // If CoreLib is JITed, the slots can be patched and thus we need to compare the actual MethodDescs - // to detect match reliably - if (MethodTable::GetMethodDescForSlotAddress(actual) == MethodTable::GetMethodDescForSlotAddress(base)) + // If the PCODEs match, then there is no override. + if (actual == base) return false; - return true; + // If CoreLib is JITed, the slots can be patched and thus we need to compare + // the actual MethodDescs to detect match reliably. + return MethodTable::GetMethodDescForSlotAddress(actual) != MethodTable::GetMethodDescForSlotAddress(base); } -FCIMPL1(FC_BOOL_RET, StreamNative::HasOverriddenBeginEndRead, Object *stream) +extern "C" BOOL QCALLTYPE Stream_HasOverriddenSlow(MethodTable* pMT, BOOL isRead) { - FCALL_CONTRACT; - - if (stream == NULL) - FC_RETURN_BOOL(TRUE); - - if (g_pStreamMT == NULL || g_slotBeginRead == 0 || g_slotEndRead == 0) - { - HELPER_METHOD_FRAME_BEGIN_RET_1(stream); - g_pStreamMT = CoreLibBinder::GetClass(CLASS__STREAM); - g_slotBeginRead = CoreLibBinder::GetMethod(METHOD__STREAM__BEGIN_READ)->GetSlot(); - g_slotEndRead = CoreLibBinder::GetMethod(METHOD__STREAM__END_READ)->GetSlot(); - HELPER_METHOD_FRAME_END(); - } + QCALL_CONTRACT; + _ASSERTE(pMT != NULL); - MethodTable * pMT = stream->GetMethodTable(); + BOOL readOverride = FALSE; + BOOL writeOverride = FALSE; - FC_RETURN_BOOL(HasOverriddenStreamMethod(pMT, g_slotBeginRead) || HasOverriddenStreamMethod(pMT, g_slotEndRead)); -} -FCIMPLEND - -FCIMPL1(FC_BOOL_RET, StreamNative::HasOverriddenBeginEndWrite, Object *stream) -{ - FCALL_CONTRACT; + BEGIN_QCALL; - if (stream == NULL) - FC_RETURN_BOOL(TRUE); + MethodTable* pStreamMT = CoreLibBinder::GetClass(CLASS__STREAM); + WORD slotBeginRead = CoreLibBinder::GetMethod(METHOD__STREAM__BEGIN_READ)->GetSlot(); + WORD slotEndRead = CoreLibBinder::GetMethod(METHOD__STREAM__END_READ)->GetSlot(); + WORD slotBeginWrite = CoreLibBinder::GetMethod(METHOD__STREAM__BEGIN_WRITE)->GetSlot(); + WORD slotEndWrite = CoreLibBinder::GetMethod(METHOD__STREAM__END_WRITE)->GetSlot(); - if (g_pStreamMT == NULL || g_slotBeginWrite == 0 || g_slotEndWrite == 0) - { - HELPER_METHOD_FRAME_BEGIN_RET_1(stream); - g_pStreamMT = CoreLibBinder::GetClass(CLASS__STREAM); - g_slotBeginWrite = CoreLibBinder::GetMethod(METHOD__STREAM__BEGIN_WRITE)->GetSlot(); - g_slotEndWrite = CoreLibBinder::GetMethod(METHOD__STREAM__END_WRITE)->GetSlot(); - HELPER_METHOD_FRAME_END(); - } + // Check the current MethodTable for Stream overrides and set state on the MethodTable. + readOverride = HasOverriddenStreamMethod(pStreamMT, pMT, slotBeginRead) || HasOverriddenStreamMethod(pStreamMT, pMT, slotEndRead); + writeOverride = HasOverriddenStreamMethod(pStreamMT, pMT, slotBeginWrite) || HasOverriddenStreamMethod(pStreamMT, pMT, slotEndWrite); + pMT->GetAuxiliaryDataForWrite()->SetStreamOverrideState(readOverride, writeOverride); - MethodTable * pMT = stream->GetMethodTable(); + END_QCALL; - FC_RETURN_BOOL(HasOverriddenStreamMethod(pMT, g_slotBeginWrite) || HasOverriddenStreamMethod(pMT, g_slotEndWrite)); + return isRead ? readOverride : writeOverride; } -FCIMPLEND diff --git a/src/coreclr/vm/comutilnative.h b/src/coreclr/vm/comutilnative.h index 3f2b3f26a93..ef41239a6bb 100644 --- a/src/coreclr/vm/comutilnative.h +++ b/src/coreclr/vm/comutilnative.h @@ -40,9 +40,7 @@ class ExceptionNative public: static FCDECL1(FC_BOOL_RET, IsImmutableAgileException, Object* pExceptionUNSAFE); static FCDECL1(FC_BOOL_RET, IsTransient, INT32 hresult); - static FCDECL3(StringObject *, StripFileInfo, Object *orefExcepUNSAFE, StringObject *orefStrUNSAFE, CLR_BOOL isRemoteStackTrace); static FCDECL0(VOID, PrepareForForeignExceptionRaise); - static FCDECL1(Object *, GetFrozenStackTrace, Object* pExceptionObjectUnsafe); #ifdef FEATURE_COMINTEROP // NOTE: caller cleans up any partially initialized BSTRs in pED @@ -55,6 +53,8 @@ class ExceptionNative static FCDECL0(UINT32, GetExceptionCount); }; +extern "C" void QCALLTYPE ExceptionNative_GetFrozenStackTrace(QCall::ObjectHandleOnStack exception, QCall::ObjectHandleOnStack ret); + enum class ExceptionMessageKind { ThreadAbort = 1, ThreadInterrupted = 2, @@ -183,8 +183,6 @@ class GCInterface { static FCDECL0(INT64, GetAllocatedBytesForCurrentThread); static FCDECL0(INT64, GetTotalAllocatedBytesApproximate); - static FCDECL3(Object*, AllocateNewArray, void* elementTypeHandle, INT32 length, INT32 flags); - NOINLINE static void SendEtwRemoveMemoryPressureEvent(UINT64 bytesAllocated); static void SendEtwAddMemoryPressureEvent(UINT64 bytesAllocated); @@ -204,6 +202,8 @@ class GCInterface { extern "C" INT64 QCALLTYPE GCInterface_GetTotalAllocatedBytesPrecise(); +extern "C" void QCALLTYPE GCInterface_AllocateNewArray(void* typeHandlePtr, INT32 length, INT32 flags, QCall::ObjectHandleOnStack ret); + extern "C" INT64 QCALLTYPE GCInterface_GetTotalMemory(); extern "C" void QCALLTYPE GCInterface_Collect(INT32 generation, INT32 mode); @@ -265,12 +265,8 @@ extern "C" BOOL QCALLTYPE MethodTable_CanCompareBitsOrUseFastGetHashCode(MethodT extern "C" BOOL QCALLTYPE TypeHandle_CanCastTo_NoCacheLookup(void* fromTypeHnd, void* toTypeHnd); extern "C" INT32 QCALLTYPE ValueType_GetHashCodeStrategy(MethodTable* mt, QCall::ObjectHandleOnStack objHandle, UINT32* fieldOffset, UINT32* fieldSize, MethodTable** fieldMT); -class StreamNative { -public: - static FCDECL1(FC_BOOL_RET, HasOverriddenBeginEndRead, Object *stream); - static FCDECL1(FC_BOOL_RET, HasOverriddenBeginEndWrite, Object *stream); -}; - BOOL CanCompareBitsOrUseFastGetHashCode(MethodTable* mt); +extern "C" BOOL QCALLTYPE Stream_HasOverriddenSlow(MethodTable* pMT, BOOL isRead); + #endif // _COMUTILNATIVE_H_ diff --git a/src/coreclr/vm/comwaithandle.cpp b/src/coreclr/vm/comwaithandle.cpp index 3af42e09ecd..e80675cc03f 100644 --- a/src/coreclr/vm/comwaithandle.cpp +++ b/src/coreclr/vm/comwaithandle.cpp @@ -11,56 +11,33 @@ ** ===========================================================*/ #include "common.h" -#include "object.h" -#include "field.h" -#include "excep.h" #include "comwaithandle.h" -FCIMPL3(INT32, WaitHandleNative::CorWaitOneNative, HANDLE handle, INT32 timeout, CLR_BOOL useTrivialWaits) +extern "C" INT32 QCALLTYPE WaitHandle_WaitOneCore(HANDLE handle, INT32 timeout, BOOL useTrivialWaits) { - FCALL_CONTRACT; + QCALL_CONTRACT; INT32 retVal = 0; - HELPER_METHOD_FRAME_BEGIN_RET_0(); + + BEGIN_QCALL; _ASSERTE(handle != 0); _ASSERTE(handle != INVALID_HANDLE_VALUE); Thread* pThread = GET_THREAD(); - WaitMode waitMode = (WaitMode)((!useTrivialWaits ? WaitMode_Alertable : WaitMode_None) | WaitMode_IgnoreSyncCtx); retVal = pThread->DoAppropriateWait(1, &handle, TRUE, timeout, waitMode); - HELPER_METHOD_FRAME_END(); + END_QCALL; return retVal; } -FCIMPLEND -#ifdef TARGET_UNIX -extern "C" INT32 QCALLTYPE WaitHandle_CorWaitOnePrioritizedNative(HANDLE handle, INT32 timeoutMs) +extern "C" INT32 QCALLTYPE WaitHandle_WaitMultipleIgnoringSyncContext(HANDLE *handleArray, INT32 numHandles, BOOL waitForAll, INT32 timeout) { QCALL_CONTRACT; - DWORD result = WAIT_FAILED; - - BEGIN_QCALL; - - _ASSERTE(handle != NULL); - _ASSERTE(handle != INVALID_HANDLE_VALUE); - - result = PAL_WaitForSingleObjectPrioritized(handle, timeoutMs); - - END_QCALL; - return (INT32)result; -} -#endif - -FCIMPL4(INT32, WaitHandleNative::CorWaitMultipleNative, HANDLE *handleArray, INT32 numHandles, CLR_BOOL waitForAll, INT32 timeout) -{ - FCALL_CONTRACT; - INT32 ret = 0; - HELPER_METHOD_FRAME_BEGIN_RET_0(); + BEGIN_QCALL; Thread * pThread = GET_THREAD(); @@ -75,42 +52,52 @@ FCIMPL4(INT32, WaitHandleNative::CorWaitMultipleNative, HANDLE *handleArray, INT ret = pThread->DoAppropriateWait(numHandles, handleArray, waitForAll, timeout, (WaitMode)(WaitMode_Alertable | WaitMode_IgnoreSyncCtx)); - HELPER_METHOD_FRAME_END(); + END_QCALL; return ret; } -FCIMPLEND -FCIMPL3(INT32, WaitHandleNative::CorSignalAndWaitOneNative, HANDLE waitHandleSignalUNSAFE, HANDLE waitHandleWaitUNSAFE, INT32 timeout) +extern "C" INT32 QCALLTYPE WaitHandle_SignalAndWait(HANDLE waitHandleSignal, HANDLE waitHandleWait, INT32 timeout) { - FCALL_CONTRACT; + QCALL_CONTRACT; - INT32 retVal = 0; + INT32 retVal = (DWORD)-1; - HELPER_METHOD_FRAME_BEGIN_RET_0(); + BEGIN_QCALL; - _ASSERTE(waitHandleSignalUNSAFE != 0); - _ASSERTE(waitHandleWaitUNSAFE != 0); + _ASSERTE(waitHandleSignal != 0); + _ASSERTE(waitHandleWait != 0); Thread* pThread = GET_THREAD(); -#ifdef FEATURE_COMINTEROP - if (pThread->GetApartment() == Thread::AS_InSTA) { - COMPlusThrow(kNotSupportedException, W("NotSupported_SignalAndWaitSTAThread")); // Change this message - } -#endif - - DWORD res = (DWORD) -1; - - HANDLE handles[2]; - handles[0] = waitHandleSignalUNSAFE; - handles[1] = waitHandleWaitUNSAFE; +#ifdef FEATURE_COMINTEROP_APARTMENT_SUPPORT + if (pThread->GetApartment() == Thread::AS_InSTA) { - res = pThread->DoSignalAndWait(handles, timeout, TRUE /*alertable*/); + COMPlusThrow(kNotSupportedException, W("NotSupported_SignalAndWaitSTAThread")); } +#endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT - retVal = res; + HANDLE handles[] = { waitHandleSignal, waitHandleWait }; + retVal = pThread->DoSignalAndWait(handles, timeout, TRUE /*alertable*/); - HELPER_METHOD_FRAME_END(); + END_QCALL; return retVal; } -FCIMPLEND + +#ifdef TARGET_UNIX +extern "C" INT32 QCALLTYPE WaitHandle_WaitOnePrioritized(HANDLE handle, INT32 timeoutMs) +{ + QCALL_CONTRACT; + + DWORD result = WAIT_FAILED; + + BEGIN_QCALL; + + _ASSERTE(handle != NULL); + _ASSERTE(handle != INVALID_HANDLE_VALUE); + + result = PAL_WaitForSingleObjectPrioritized(handle, timeoutMs); + + END_QCALL; + return (INT32)result; +} +#endif // TARGET_UNIX diff --git a/src/coreclr/vm/comwaithandle.h b/src/coreclr/vm/comwaithandle.h index c892d7aae85..ac605389129 100644 --- a/src/coreclr/vm/comwaithandle.h +++ b/src/coreclr/vm/comwaithandle.h @@ -14,15 +14,12 @@ #ifndef _COM_WAITABLE_HANDLE_H #define _COM_WAITABLE_HANDLE_H +extern "C" INT32 QCALLTYPE WaitHandle_WaitOneCore(HANDLE handle, INT32 timeout, BOOL useTrivialWaits); +extern "C" INT32 QCALLTYPE WaitHandle_WaitMultipleIgnoringSyncContext(HANDLE *handleArray, INT32 numHandles, BOOL waitForAll, INT32 timeout); +extern "C" INT32 QCALLTYPE WaitHandle_SignalAndWait(HANDLE waitHandleSignal, HANDLE waitHandleWait, INT32 timeout); -class WaitHandleNative -{ -public: - static FCDECL3(INT32, CorWaitOneNative, HANDLE handle, INT32 timeout, CLR_BOOL useTrivialWaits); - static FCDECL4(INT32, CorWaitMultipleNative, HANDLE *handleArray, INT32 numHandles, CLR_BOOL waitForAll, INT32 timeout); - static FCDECL3(INT32, CorSignalAndWaitOneNative, HANDLE waitHandleSignalUNSAFE, HANDLE waitHandleWaitUNSAFE, INT32 timeout); -}; #ifdef TARGET_UNIX -extern "C" INT32 QCALLTYPE WaitHandle_CorWaitOnePrioritizedNative(HANDLE handle, INT32 timeoutMs); -#endif -#endif +extern "C" INT32 QCALLTYPE WaitHandle_WaitOnePrioritized(HANDLE handle, INT32 timeoutMs); +#endif // TARGET_UNIX + +#endif // _COM_WAITABLE_HANDLE_H diff --git a/src/coreclr/vm/contractimpl.h b/src/coreclr/vm/contractimpl.h index 786139745df..f8d7d81856f 100644 --- a/src/coreclr/vm/contractimpl.h +++ b/src/coreclr/vm/contractimpl.h @@ -120,7 +120,6 @@ class DispatchMapTypeID struct DispatchTokenFat { friend struct DispatchToken; - friend class BaseDomain; private: UINT32 m_typeId; diff --git a/src/coreclr/vm/corelib.cpp b/src/coreclr/vm/corelib.cpp index e172f6a5423..4c3f7438a55 100644 --- a/src/coreclr/vm/corelib.cpp +++ b/src/coreclr/vm/corelib.cpp @@ -47,7 +47,6 @@ #ifdef FEATURE_COMINTEROP #include "variant.h" -#include "mngstdinterfaces.h" #endif // FEATURE_COMINTEROP #include "interoplibinterface.h" diff --git a/src/coreclr/vm/corelib.h b/src/coreclr/vm/corelib.h index 661ec814eaf..ec5ee0795a5 100644 --- a/src/coreclr/vm/corelib.h +++ b/src/coreclr/vm/corelib.h @@ -371,14 +371,10 @@ DEFINE_CLASS(GUID, System, Guid) BEGIN_ILLINK_FEATURE_SWITCH(System.Runtime.InteropServices.BuiltInComInterop.IsSupported, true, true) #ifdef FEATURE_COMINTEROP DEFINE_CLASS(VARIANT, System, Variant) -DEFINE_METHOD(VARIANT, CONVERT_OBJECT_TO_VARIANT,MarshalHelperConvertObjectToVariant,SM_Obj_RefVariant_RetVoid) -DEFINE_METHOD(VARIANT, CAST_VARIANT, MarshalHelperCastVariant, SM_Obj_Int_RefVariant_RetVoid) -DEFINE_METHOD(VARIANT, CONVERT_VARIANT_TO_OBJECT,MarshalHelperConvertVariantToObject,SM_RefVariant_RetObject) - -DEFINE_CLASS_U(System, Variant, VariantData) -DEFINE_FIELD_U(_objref, VariantData, m_objref) -DEFINE_FIELD_U(_data, VariantData, m_data) -DEFINE_FIELD_U(_flags, VariantData, m_flags) +DEFINE_METHOD(VARIANT, CONVERT_OBJECT_TO_VARIANT,MarshalHelperConvertObjectToVariant,SM_Obj_RefComVariant_RetVoid) +DEFINE_METHOD(VARIANT, CAST_VARIANT, MarshalHelperCastVariant, SM_Obj_Int_RefComVariant_RetVoid) +DEFINE_METHOD(VARIANT, CONVERT_VARIANT_TO_OBJECT,MarshalHelperConvertVariantToObject,SM_RefComVariant_RetObject) + #endif // FEATURE_COMINTEROP END_ILLINK_FEATURE_SWITCH() @@ -388,11 +384,8 @@ DEFINE_CLASS(ICUSTOM_ATTR_PROVIDER, Reflection, ICustomAttributeProv DEFINE_METHOD(ICUSTOM_ATTR_PROVIDER,GET_CUSTOM_ATTRIBUTES, GetCustomAttributes, IM_Type_RetArrObj) DEFINE_CLASS(ICUSTOM_MARSHALER, Interop, ICustomMarshaler) -DEFINE_METHOD(ICUSTOM_MARSHALER, MARSHAL_NATIVE_TO_MANAGED,MarshalNativeToManaged, IM_IntPtr_RetObj) -DEFINE_METHOD(ICUSTOM_MARSHALER, MARSHAL_MANAGED_TO_NATIVE,MarshalManagedToNative, IM_Obj_RetIntPtr) -DEFINE_METHOD(ICUSTOM_MARSHALER, CLEANUP_NATIVE_DATA, CleanUpNativeData, IM_IntPtr_RetVoid) -DEFINE_METHOD(ICUSTOM_MARSHALER, CLEANUP_MANAGED_DATA, CleanUpManagedData, IM_Obj_RetVoid) -DEFINE_METHOD(ICUSTOM_MARSHALER, GET_NATIVE_DATA_SIZE, GetNativeDataSize, IM_RetInt) + +DEFINE_CLASS(ICUSTOMADAPTER, Interop, ICustomAdapter) DEFINE_CLASS(IDYNAMICINTERFACECASTABLE, Interop, IDynamicInterfaceCastable) DEFINE_CLASS(DYNAMICINTERFACECASTABLEHELPERS, Interop, DynamicInterfaceCastableHelpers) @@ -404,6 +397,9 @@ BEGIN_ILLINK_FEATURE_SWITCH(System.Runtime.InteropServices.BuiltInComInterop.IsS DEFINE_CLASS(ICUSTOM_QUERYINTERFACE, Interop, ICustomQueryInterface) DEFINE_METHOD(ICUSTOM_QUERYINTERFACE, GET_INTERFACE, GetInterface, IM_RefGuid_OutIntPtr_RetCustomQueryInterfaceResult) DEFINE_CLASS(CUSTOMQUERYINTERFACERESULT, Interop, CustomQueryInterfaceResult) + +DEFINE_CLASS(ENUMERATORTOENUMVARIANTMARSHALER, CustomMarshalers, EnumeratorToEnumVariantMarshaler) +DEFINE_METHOD(ENUMERATORTOENUMVARIANTMARSHALER, INTERNALMARSHALNATIVETOMANAGED, InternalMarshalNativeToManaged, SM_IntPtr_RetObj) #endif //FEATURE_COMINTEROP END_ILLINK_FEATURE_SWITCH() @@ -627,7 +623,6 @@ DEFINE_METHOD(RTFIELD, GET_FIELDHANDLE, GetFieldHandle, DEFINE_CLASS(RUNTIME_HELPERS, CompilerServices, RuntimeHelpers) DEFINE_METHOD(RUNTIME_HELPERS, IS_BITWISE_EQUATABLE, IsBitwiseEquatable, NoSig) -DEFINE_METHOD(RUNTIME_HELPERS, GET_METHOD_TABLE, GetMethodTable, NoSig) DEFINE_METHOD(RUNTIME_HELPERS, GET_RAW_DATA, GetRawData, NoSig) DEFINE_METHOD(RUNTIME_HELPERS, GET_UNINITIALIZED_OBJECT, GetUninitializedObject, SM_Type_RetObj) DEFINE_METHOD(RUNTIME_HELPERS, ENUM_EQUALS, EnumEquals, NoSig) @@ -635,25 +630,26 @@ DEFINE_METHOD(RUNTIME_HELPERS, ENUM_COMPARE_TO, EnumCompareTo, NoSig DEFINE_METHOD(RUNTIME_HELPERS, ALLOC_TAILCALL_ARG_BUFFER, AllocTailCallArgBuffer, SM_Int_IntPtr_RetIntPtr) DEFINE_METHOD(RUNTIME_HELPERS, GET_TAILCALL_INFO, GetTailCallInfo, NoSig) DEFINE_METHOD(RUNTIME_HELPERS, DISPATCH_TAILCALLS, DispatchTailCalls, NoSig) +DEFINE_METHOD(RUNTIME_HELPERS, COPY_CONSTRUCT, CopyConstruct, NoSig) DEFINE_CLASS(SPAN_HELPERS, System, SpanHelpers) DEFINE_METHOD(SPAN_HELPERS, MEMSET, Fill, SM_RefByte_Byte_UIntPtr_RetVoid) DEFINE_METHOD(SPAN_HELPERS, MEMZERO, ClearWithoutReferences, SM_RefByte_UIntPtr_RetVoid) DEFINE_METHOD(SPAN_HELPERS, MEMCOPY, Memmove, SM_RefByte_RefByte_UIntPtr_RetVoid) -DEFINE_CLASS(THROWHELPER, System, ThrowHelper) -DEFINE_METHOD(THROWHELPER, THROWARGUMENTEXCEPTION, ThrowArgumentException, SM_RetVoid) -DEFINE_METHOD(THROWHELPER, THROWARGUMENTOUTOFRANGEEXCEPTION, ThrowArgumentOutOfRangeException, SM_RetVoid) -DEFINE_METHOD(THROWHELPER, THROWINDEXOUTOFRANGEEXCEPTION, ThrowIndexOutOfRangeException, SM_RetVoid) -DEFINE_METHOD(THROWHELPER, THROWNOTIMPLEMENTEDEXCEPTION, ThrowNotImplementedException, SM_RetVoid) -DEFINE_METHOD(THROWHELPER, THROWPLATFORMNOTSUPPORTEDEXCEPTION, ThrowPlatformNotSupportedException, SM_RetVoid) -DEFINE_METHOD(THROWHELPER, THROWTYPENOTSUPPORTED, ThrowTypeNotSupportedException, SM_RetVoid) -DEFINE_METHOD(THROWHELPER, THROWOVERFLOWEXCEPTION, ThrowOverflowException, SM_RetVoid) -DEFINE_METHOD(THROWHELPER, THROWDIVIDEBYZEROEXCEPTION, ThrowDivideByZeroException, SM_RetVoid) -DEFINE_METHOD(THROWHELPER, THROWNULLREFEXCEPTION, ThrowNullReferenceException, SM_RetVoid) -DEFINE_METHOD(THROWHELPER, THROWVERIFICATIONEXCEPTION, ThrowVerificationException, SM_Int_RetVoid) -DEFINE_METHOD(THROWHELPER, THROWAMBIGUOUSRESOLUTIONEXCEPTION, ThrowAmbiguousResolutionException, SM_PtrVoid_PtrVoid_PtrVoid_RetVoid) -DEFINE_METHOD(THROWHELPER, THROWENTRYPOINTNOTFOUNDEXCEPTION, ThrowEntryPointNotFoundException, SM_PtrVoid_PtrVoid_PtrVoid_RetVoid) +DEFINE_CLASS(THROWHELPERS, InternalCompilerHelpers, ThrowHelpers) +DEFINE_METHOD(THROWHELPERS, THROWARGUMENTEXCEPTION, ThrowArgumentException, SM_RetVoid) +DEFINE_METHOD(THROWHELPERS, THROWARGUMENTOUTOFRANGEEXCEPTION, ThrowArgumentOutOfRangeException, SM_RetVoid) +DEFINE_METHOD(THROWHELPERS, THROWINDEXOUTOFRANGEEXCEPTION, ThrowIndexOutOfRangeException, SM_RetVoid) +DEFINE_METHOD(THROWHELPERS, THROWNOTIMPLEMENTEDEXCEPTION, ThrowNotImplementedException, SM_RetVoid) +DEFINE_METHOD(THROWHELPERS, THROWPLATFORMNOTSUPPORTEDEXCEPTION, ThrowPlatformNotSupportedException, SM_RetVoid) +DEFINE_METHOD(THROWHELPERS, THROWTYPENOTSUPPORTED, ThrowTypeNotSupportedException, SM_RetVoid) +DEFINE_METHOD(THROWHELPERS, THROWOVERFLOWEXCEPTION, ThrowOverflowException, SM_RetVoid) +DEFINE_METHOD(THROWHELPERS, THROWDIVIDEBYZEROEXCEPTION, ThrowDivideByZeroException, SM_RetVoid) +DEFINE_METHOD(THROWHELPERS, THROWNULLREFEXCEPTION, ThrowNullReferenceException, SM_RetVoid) +DEFINE_METHOD(THROWHELPERS, THROWVERIFICATIONEXCEPTION, ThrowVerificationException, SM_Int_RetVoid) +DEFINE_METHOD(THROWHELPERS, THROWAMBIGUOUSRESOLUTIONEXCEPTION, ThrowAmbiguousResolutionException, SM_PtrVoid_PtrVoid_PtrVoid_RetVoid) +DEFINE_METHOD(THROWHELPERS, THROWENTRYPOINTNOTFOUNDEXCEPTION, ThrowEntryPointNotFoundException, SM_PtrVoid_PtrVoid_PtrVoid_RetVoid) DEFINE_CLASS(UNSAFE, CompilerServices, Unsafe) DEFINE_METHOD(UNSAFE, AS_POINTER, AsPointer, NoSig) @@ -756,7 +752,6 @@ DEFINE_METHOD(SAFE_HANDLE, DISPOSE_BOOL, Dispose, DEFINE_CLASS(SECURITY_EXCEPTION, Security, SecurityException) DEFINE_CLASS_U(Diagnostics, StackFrameHelper, StackFrameHelper) -DEFINE_FIELD_U(targetThread, StackFrameHelper, targetThread) DEFINE_FIELD_U(rgiOffset, StackFrameHelper, rgiOffset) DEFINE_FIELD_U(rgiILOffset, StackFrameHelper, rgiILOffset) DEFINE_FIELD_U(dynamicMethods, StackFrameHelper, dynamicMethods) @@ -840,8 +835,8 @@ DEFINE_FIELD_U(_name, ThreadBaseObject, m_Name) DEFINE_FIELD_U(_startHelper, ThreadBaseObject, m_StartHelper) DEFINE_FIELD_U(_DONT_USE_InternalThread, ThreadBaseObject, m_InternalThread) DEFINE_FIELD_U(_priority, ThreadBaseObject, m_Priority) +DEFINE_FIELD_U(_isDead, ThreadBaseObject, m_IsDead) DEFINE_CLASS(THREAD, Threading, Thread) -DEFINE_METHOD(THREAD, INTERNAL_GET_CURRENT_THREAD, InternalGetCurrentThread, SM_RetIntPtr) DEFINE_METHOD(THREAD, START_CALLBACK, StartCallback, IM_RetVoid) #ifdef FEATURE_OBJCMARSHAL DEFINE_CLASS(AUTORELEASEPOOL, Threading, AutoreleasePool) @@ -929,16 +924,18 @@ DEFINE_METHOD(STUBHELPERS, KEEP_ALIVE_VIA_CLEANUP_LIST, KeepAliveVia DEFINE_METHOD(STUBHELPERS, DESTROY_CLEANUP_LIST, DestroyCleanupList, SM_RefCleanupWorkListElement_RetVoid) DEFINE_METHOD(STUBHELPERS, GET_HR_EXCEPTION_OBJECT, GetHRExceptionObject, SM_Int_RetException) DEFINE_METHOD(STUBHELPERS, GET_PENDING_EXCEPTION_OBJECT, GetPendingExceptionObject, SM_RetException) -DEFINE_METHOD(STUBHELPERS, CREATE_CUSTOM_MARSHALER_HELPER, CreateCustomMarshalerHelper, SM_IntPtr_Int_IntPtr_RetIntPtr) +DEFINE_METHOD(STUBHELPERS, CREATE_CUSTOM_MARSHALER, CreateCustomMarshaler, SM_IntPtr_Int_IntPtr_RetObj) +#ifdef FEATURE_COMINTEROP +DEFINE_METHOD(STUBHELPERS, GET_IENUMERATOR_TO_ENUM_VARIANT_MARSHALER, GetIEnumeratorToEnumVariantMarshaler, SM_RetObj) +#endif // FEATURE_COMINTEROP DEFINE_METHOD(STUBHELPERS, CHECK_STRING_LENGTH, CheckStringLength, SM_Int_RetVoid) DEFINE_METHOD(STUBHELPERS, FMT_CLASS_UPDATE_NATIVE_INTERNAL, FmtClassUpdateNativeInternal, SM_Obj_PtrByte_RefCleanupWorkListElement_RetVoid) DEFINE_METHOD(STUBHELPERS, FMT_CLASS_UPDATE_CLR_INTERNAL, FmtClassUpdateCLRInternal, SM_Obj_PtrByte_RetVoid) DEFINE_METHOD(STUBHELPERS, LAYOUT_DESTROY_NATIVE_INTERNAL, LayoutDestroyNativeInternal, SM_Obj_PtrByte_RetVoid) -DEFINE_METHOD(STUBHELPERS, ALLOCATE_INTERNAL, AllocateInternal, SM_IntPtr_RetObj) -DEFINE_METHOD(STUBHELPERS, MARSHAL_TO_MANAGED_VA_LIST_INTERNAL,MarshalToManagedVaListInternal, SM_IntPtr_IntPtr_RetVoid) -DEFINE_METHOD(STUBHELPERS, MARSHAL_TO_UNMANAGED_VA_LIST_INTERNAL,MarshalToUnmanagedVaListInternal,SM_IntPtr_UInt_IntPtr_RetVoid) +DEFINE_METHOD(STUBHELPERS, MARSHAL_TO_MANAGED_VA_LIST, MarshalToManagedVaList, SM_IntPtr_IntPtr_RetVoid) +DEFINE_METHOD(STUBHELPERS, MARSHAL_TO_UNMANAGED_VA_LIST, MarshalToUnmanagedVaList, SM_IntPtr_UInt_IntPtr_RetVoid) DEFINE_METHOD(STUBHELPERS, CALC_VA_LIST_SIZE, CalcVaListSize, SM_IntPtr_RetUInt) DEFINE_METHOD(STUBHELPERS, VALIDATE_OBJECT, ValidateObject, SM_Obj_IntPtr_Obj_RetVoid) DEFINE_METHOD(STUBHELPERS, VALIDATE_BYREF, ValidateByref, SM_IntPtr_IntPtr_Obj_RetVoid) @@ -949,8 +946,8 @@ DEFINE_METHOD(STUBHELPERS, SAFE_HANDLE_ADD_REF, SafeHandleAddRef, DEFINE_METHOD(STUBHELPERS, SAFE_HANDLE_RELEASE, SafeHandleRelease, SM_SafeHandle_RetVoid) #ifdef PROFILING_SUPPORTED -DEFINE_METHOD(STUBHELPERS, PROFILER_BEGIN_TRANSITION_CALLBACK, ProfilerBeginTransitionCallback, SM_IntPtr_IntPtr_Obj_RetIntPtr) -DEFINE_METHOD(STUBHELPERS, PROFILER_END_TRANSITION_CALLBACK, ProfilerEndTransitionCallback, SM_IntPtr_IntPtr_RetVoid) +DEFINE_METHOD(STUBHELPERS, PROFILER_BEGIN_TRANSITION_CALLBACK, ProfilerBeginTransitionCallback, SM_PtrVoid_RetPtrVoid) +DEFINE_METHOD(STUBHELPERS, PROFILER_END_TRANSITION_CALLBACK, ProfilerEndTransitionCallback, SM_PtrVoid_RetVoid) #endif DEFINE_METHOD(STUBHELPERS, MULTICAST_DEBUGGER_TRACE_HELPER, MulticastDebuggerTraceHelper, SM_Obj_Int_RetVoid) @@ -1002,6 +999,11 @@ DEFINE_METHOD(MNGD_SAFE_ARRAY_MARSHALER, CONVERT_CONTENTS_TO_NATIVE, ConvertCon DEFINE_METHOD(MNGD_SAFE_ARRAY_MARSHALER, CONVERT_SPACE_TO_MANAGED, ConvertSpaceToManaged, SM_IntPtr_RefObj_IntPtr_RetVoid) DEFINE_METHOD(MNGD_SAFE_ARRAY_MARSHALER, CONVERT_CONTENTS_TO_MANAGED, ConvertContentsToManaged, SM_IntPtr_RefObj_IntPtr_RetVoid) DEFINE_METHOD(MNGD_SAFE_ARRAY_MARSHALER, CLEAR_NATIVE, ClearNative, SM_IntPtr_RefObj_IntPtr_RetVoid) + +DEFINE_CLASS(COLORMARSHALER, StubHelpers, ColorMarshaler) +DEFINE_METHOD(COLORMARSHALER, CONVERT_TO_NATIVE, ConvertToNative, SM_Obj_RetInt) +DEFINE_METHOD(COLORMARSHALER, CONVERT_TO_MANAGED, ConvertToManaged, SM_Int_RetObj) +DEFINE_FIELD(COLORMARSHALER, COLOR_TYPE, s_colorType) #endif // FEATURE_COMINTEROP END_ILLINK_FEATURE_SWITCH() @@ -1036,7 +1038,6 @@ DEFINE_METHOD(MNGD_REF_CUSTOM_MARSHALER, CONVERT_CONTENTS_TO_NATIVE, ConvertCon DEFINE_METHOD(MNGD_REF_CUSTOM_MARSHALER, CONVERT_CONTENTS_TO_MANAGED, ConvertContentsToManaged, SM_ICustomMarshaler_RefObj_PtrIntPtr_RetVoid) DEFINE_METHOD(MNGD_REF_CUSTOM_MARSHALER, CLEAR_NATIVE, ClearNative, SM_ICustomMarshaler_RefObj_PtrIntPtr_RetVoid) DEFINE_METHOD(MNGD_REF_CUSTOM_MARSHALER, CLEAR_MANAGED, ClearManaged, SM_ICustomMarshaler_RefObj_PtrIntPtr_RetVoid) -DEFINE_METHOD(MNGD_REF_CUSTOM_MARSHALER, GET_MARSHALER, GetMarshaler, SM_IntPtr_RetICustomMarshaler) DEFINE_CLASS(ASANY_MARSHALER, StubHelpers, AsAnyMarshaler) DEFINE_METHOD(ASANY_MARSHALER, CTOR, .ctor, IM_IntPtr_RetVoid) @@ -1049,21 +1050,6 @@ DEFINE_METHOD(HANDLE_MARSHALER, CONVERT_SAFEHANDLE_TO_NATIVE,ConvertSaf DEFINE_METHOD(HANDLE_MARSHALER, THROW_SAFEHANDLE_FIELD_CHANGED, ThrowSafeHandleFieldChanged, SM_RetVoid) DEFINE_METHOD(HANDLE_MARSHALER, THROW_CRITICALHANDLE_FIELD_CHANGED, ThrowCriticalHandleFieldChanged, SM_RetVoid) -#ifdef TARGET_WINDOWS -#ifdef TARGET_X86 -DEFINE_CLASS(COPY_CONSTRUCTOR_CHAIN, StubHelpers, CopyConstructorChain) -DEFINE_METHOD(COPY_CONSTRUCTOR_CHAIN, EXECUTE_CURRENT_COPIES_AND_GET_TARGET, ExecuteCurrentCopiesAndGetTarget, SM_PtrVoid_RetPtrVoid) -DEFINE_METHOD(COPY_CONSTRUCTOR_CHAIN, INSTALL, Install, IM_PtrVoid_RetVoid) -DEFINE_METHOD(COPY_CONSTRUCTOR_CHAIN, ADD, Add, IM_PtrCopyConstructorCookie_RetVoid) - -DEFINE_CLASS(COPY_CONSTRUCTOR_COOKIE, StubHelpers, CopyConstructorCookie) -DEFINE_FIELD(COPY_CONSTRUCTOR_COOKIE, SOURCE, m_source) -DEFINE_FIELD(COPY_CONSTRUCTOR_COOKIE, DESTINATION_OFFSET, m_destinationOffset) -DEFINE_FIELD(COPY_CONSTRUCTOR_COOKIE, COPY_CONSTRUCTOR, m_copyConstructor) -DEFINE_FIELD(COPY_CONSTRUCTOR_COOKIE, DESTRUCTOR, m_destructor) -#endif // TARGET_X86 -#endif // TARGET_WINDOWS - DEFINE_CLASS(COMVARIANT, Marshalling, ComVariant) DEFINE_CLASS(SZARRAYHELPER, System, SZArrayHelper) @@ -1119,16 +1105,8 @@ DEFINE_FIELD_U(_condition, ContractExceptionObject, _Condition) DEFINE_CLASS(MODULEBASE, Reflection, Module) -#ifdef FEATURE_ICASTABLE -DEFINE_CLASS(ICASTABLE, CompilerServices, ICastable) - -DEFINE_CLASS(ICASTABLEHELPERS, CompilerServices, ICastableHelpers) -DEFINE_METHOD(ICASTABLEHELPERS, ISINSTANCEOF, IsInstanceOfInterface, SM_ICastable_RtType_RefException_RetBool) -DEFINE_METHOD(ICASTABLEHELPERS, GETIMPLTYPE, GetImplType, SM_ICastable_RtType_RetRtType) - -#endif // FEATURE_ICASTABLE - DEFINE_CLASS(STACKALLOCATEDBOX, CompilerServices, StackAllocatedBox`1) +DEFINE_FIELD(STACKALLOCATEDBOX, VALUE, _value) DEFINE_CLASS(UTF8STRINGMARSHALLER, Marshalling, Utf8StringMarshaller) DEFINE_METHOD(UTF8STRINGMARSHALLER, CONVERT_TO_MANAGED, ConvertToManaged, SM_PtrByte_RetStr) diff --git a/src/coreclr/vm/corhost.cpp b/src/coreclr/vm/corhost.cpp index 35c724e10a9..990eb02b00d 100644 --- a/src/coreclr/vm/corhost.cpp +++ b/src/coreclr/vm/corhost.cpp @@ -559,11 +559,11 @@ HRESULT CorHost2::CreateAppDomainWithManager( BEGIN_EXTERNAL_ENTRYPOINT(&hr); - AppDomain* pDomain = SystemDomain::System()->DefaultDomain(); + AppDomain* pDomain = AppDomain::GetCurrentDomain(); pDomain->SetFriendlyName(wszFriendlyName); - ETW::LoaderLog::DomainLoad(pDomain, (LPWSTR)wszFriendlyName); + ETW::LoaderLog::DomainLoad((LPWSTR)wszFriendlyName); if (dwFlags & APPDOMAIN_IGNORE_UNHANDLED_EXCEPTIONS) pDomain->SetIgnoreUnhandledExceptions(); diff --git a/src/coreclr/vm/custommarshalerinfo.cpp b/src/coreclr/vm/custommarshalerinfo.cpp index 4c7a93441fc..c505be13232 100644 --- a/src/coreclr/vm/custommarshalerinfo.cpp +++ b/src/coreclr/vm/custommarshalerinfo.cpp @@ -17,20 +17,60 @@ #include "mlinfo.h" #include "sigbuilder.h" +namespace +{ + MethodDesc * FindGetInstanceMethod(TypeHandle hndCustomMarshalerType) + { + CONTRACTL + { + THROWS; + GC_TRIGGERS; + MODE_COOPERATIVE; + } + CONTRACTL_END; + + + MethodTable *pMT = hndCustomMarshalerType.AsMethodTable(); + + MethodDesc *pMD = MemberLoader::FindMethod(pMT, "GetInstance", &gsig_SM_Str_RetICustomMarshaler); + if (!pMD) + { + DefineFullyQualifiedNameForClassW() + COMPlusThrow(kApplicationException, + IDS_EE_GETINSTANCENOTIMPL, + GetFullyQualifiedNameForClassW(pMT)); + }; + + // If the GetInstance method is generic, get an instantiating stub for it - + // the CallDescr infrastructure doesn't know how to pass secret generic arguments. + if (pMD->RequiresInstMethodTableArg()) + { + pMD = MethodDesc::FindOrCreateAssociatedMethodDesc( + pMD, + pMT, + FALSE, // forceBoxedEntryPoint + Instantiation(), // methodInst + FALSE, // allowInstParam + FALSE); // forceRemotableMethod + + _ASSERTE(!pMD->RequiresInstMethodTableArg()); + } + + // Ensure that the value types in the signature are loaded. + MetaSig::EnsureSigValueTypesLoaded(pMD); + + // Return the specified method desc. + return pMD; + } +} + //========================================================================== // Implementation of the custom marshaler info class. //========================================================================== CustomMarshalerInfo::CustomMarshalerInfo(LoaderAllocator *pLoaderAllocator, TypeHandle hndCustomMarshalerType, TypeHandle hndManagedType, LPCUTF8 strCookie, DWORD cCookieStrBytes) -: m_NativeSize(0) -, m_hndManagedType(hndManagedType) -, m_pLoaderAllocator(pLoaderAllocator) +: m_pLoaderAllocator(pLoaderAllocator) , m_hndCustomMarshaler{} -, m_pMarshalNativeToManagedMD(NULL) -, m_pMarshalManagedToNativeMD(NULL) -, m_pCleanUpNativeDataMD(NULL) -, m_pCleanUpManagedDataMD(NULL) -, m_bDataIsByValue(FALSE) { CONTRACTL { @@ -51,37 +91,19 @@ CustomMarshalerInfo::CustomMarshalerInfo(LoaderAllocator *pLoaderAllocator, Type GetFullyQualifiedNameForClassW(hndCustomMarshalerType.GetMethodTable())); } - // Determine if this type is a value class. - m_bDataIsByValue = m_hndManagedType.GetMethodTable()->IsValueType(); - - // Custom marshalling of value classes is not currently supported. - if (m_bDataIsByValue) + // Custom marshalling of value classes is not supported. + if (hndManagedType.GetMethodTable()->IsValueType()) COMPlusThrow(kNotSupportedException, W("NotSupported_ValueClassCM")); // Run the on the marshaler since it might not have run yet. hndCustomMarshalerType.GetMethodTable()->EnsureInstanceActive(); hndCustomMarshalerType.GetMethodTable()->CheckRunClassInitThrowing(); - // Create a COM+ string that will contain the string cookie. + // Create a .NET string that will contain the string cookie. STRINGREF CookieStringObj = StringObject::NewString(strCookie, cCookieStrBytes); GCPROTECT_BEGIN(CookieStringObj); // Load the method desc for the static method to retrieve the instance. - MethodDesc *pGetCustomMarshalerMD = GetCustomMarshalerMD(CustomMarshalerMethods_GetInstance, hndCustomMarshalerType); - - // If the GetInstance method is generic, get an instantiating stub for it - - // the CallDescr infrastructure doesn't know how to pass secret generic arguments. - if (pGetCustomMarshalerMD->RequiresInstMethodTableArg()) - { - pGetCustomMarshalerMD = MethodDesc::FindOrCreateAssociatedMethodDesc( - pGetCustomMarshalerMD, - hndCustomMarshalerType.GetMethodTable(), - FALSE, // forceBoxedEntryPoint - Instantiation(), // methodInst - FALSE, // allowInstParam - FALSE); // forceRemotableMethod - - _ASSERTE(!pGetCustomMarshalerMD->RequiresInstMethodTableArg()); - } + MethodDesc *pGetCustomMarshalerMD = FindGetInstanceMethod(hndCustomMarshalerType); MethodDescCallSite getCustomMarshaler(pGetCustomMarshalerMD, (OBJECTREF*)&CookieStringObj); @@ -103,28 +125,9 @@ CustomMarshalerInfo::CustomMarshalerInfo(LoaderAllocator *pLoaderAllocator, Type IDS_EE_NOCUSTOMMARSHALER, GetFullyQualifiedNameForClassW(hndCustomMarshalerType.GetMethodTable())); } - // Load the method desc's for all the methods in the ICustomMarshaler interface based on the type of the marshaler object. - TypeHandle customMarshalerObjType = CustomMarshalerObj->GetMethodTable(); - - m_pMarshalNativeToManagedMD = GetCustomMarshalerMD(CustomMarshalerMethods_MarshalNativeToManaged, customMarshalerObjType); - m_pMarshalManagedToNativeMD = GetCustomMarshalerMD(CustomMarshalerMethods_MarshalManagedToNative, customMarshalerObjType); - m_pCleanUpNativeDataMD = GetCustomMarshalerMD(CustomMarshalerMethods_CleanUpNativeData, customMarshalerObjType); - m_pCleanUpManagedDataMD = GetCustomMarshalerMD(CustomMarshalerMethods_CleanUpManagedData, customMarshalerObjType); m_hndCustomMarshaler = pLoaderAllocator->AllocateHandle(CustomMarshalerObj); GCPROTECT_END(); - - // Retrieve the size of the native data. - if (m_bDataIsByValue) - { - // @TODO(DM): Call GetNativeDataSize() to retrieve the size of the native data. - _ASSERTE(!"Value classes are not yet supported by the custom marshaler!"); - } - else - { - m_NativeSize = sizeof(void *); - } - GCPROTECT_END(); } @@ -166,202 +169,39 @@ void CustomMarshalerInfo::operator delete(void *pMem) LIMITED_METHOD_CONTRACT; } -OBJECTREF CustomMarshalerInfo::InvokeMarshalNativeToManagedMeth(void *pNative) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; - PRECONDITION(CheckPointer(pNative, NULL_OK)); - } - CONTRACTL_END; - - if (!pNative) - return NULL; - - OBJECTREF managedObject; - - OBJECTREF customMarshaler = m_pLoaderAllocator->GetHandleValue(m_hndCustomMarshaler); - GCPROTECT_BEGIN (customMarshaler); - MethodDescCallSite marshalNativeToManaged(m_pMarshalNativeToManagedMD, &customMarshaler); - - ARG_SLOT Args[] = { - ObjToArgSlot(customMarshaler), - PtrToArgSlot(pNative) - }; - - managedObject = marshalNativeToManaged.Call_RetOBJECTREF(Args); - GCPROTECT_END (); - - return managedObject; -} - - -void *CustomMarshalerInfo::InvokeMarshalManagedToNativeMeth(OBJECTREF MngObj) +#ifdef FEATURE_COMINTEROP +CustomMarshalerInfo* CustomMarshalerInfo::CreateIEnumeratorMarshalerInfo(LoaderHeap* pHeap, LoaderAllocator* pLoaderAllocator) { CONTRACTL { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; + STANDARD_VM_CHECK; + PRECONDITION(CheckPointer(pHeap)); + PRECONDITION(CheckPointer(pLoaderAllocator)); } CONTRACTL_END; - void *RetVal = NULL; - - if (!MngObj) - return NULL; - - GCPROTECT_BEGIN (MngObj); - OBJECTREF customMarshaler = m_pLoaderAllocator->GetHandleValue(m_hndCustomMarshaler); - GCPROTECT_BEGIN (customMarshaler); - MethodDescCallSite marshalManagedToNative(m_pMarshalManagedToNativeMD, &customMarshaler); - - ARG_SLOT Args[] = { - ObjToArgSlot(customMarshaler), - ObjToArgSlot(MngObj) - }; - - RetVal = marshalManagedToNative.Call_RetLPVOID(Args); - GCPROTECT_END (); - GCPROTECT_END (); - - return RetVal; -} - + CustomMarshalerInfo* pInfo = nullptr; + OBJECTREF IEnumeratorMarshalerObj = nullptr; -void CustomMarshalerInfo::InvokeCleanUpNativeMeth(void *pNative) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; - PRECONDITION(CheckPointer(pNative, NULL_OK)); - } - CONTRACTL_END; - - if (!pNative) - return; + GCX_COOP(); + GCPROTECT_BEGIN(IEnumeratorMarshalerObj); - OBJECTREF customMarshaler = m_pLoaderAllocator->GetHandleValue(m_hndCustomMarshaler); - GCPROTECT_BEGIN (customMarshaler); - MethodDescCallSite cleanUpNativeData(m_pCleanUpNativeDataMD, &customMarshaler); + MethodDescCallSite getMarshaler(METHOD__STUBHELPERS__GET_IENUMERATOR_TO_ENUM_VARIANT_MARSHALER); + IEnumeratorMarshalerObj = getMarshaler.Call_RetOBJECTREF(NULL); - ARG_SLOT Args[] = { - ObjToArgSlot(customMarshaler), - PtrToArgSlot(pNative) - }; + pInfo = new (pHeap) CustomMarshalerInfo(pLoaderAllocator, pLoaderAllocator->AllocateHandle(IEnumeratorMarshalerObj)); - cleanUpNativeData.Call(Args); GCPROTECT_END(); -} - -void CustomMarshalerInfo::InvokeCleanUpManagedMeth(OBJECTREF MngObj) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; - } - CONTRACTL_END; - - if (!MngObj) - return; - - GCPROTECT_BEGIN (MngObj); - OBJECTREF customMarshaler = m_pLoaderAllocator->GetHandleValue(m_hndCustomMarshaler); - GCPROTECT_BEGIN (customMarshaler); - MethodDescCallSite cleanUpManagedData(m_pCleanUpManagedDataMD, &customMarshaler); - - ARG_SLOT Args[] = { - ObjToArgSlot(customMarshaler), - ObjToArgSlot(MngObj) - }; - - cleanUpManagedData.Call(Args); - GCPROTECT_END (); - GCPROTECT_END (); + return pInfo; } - -MethodDesc *CustomMarshalerInfo::GetCustomMarshalerMD(EnumCustomMarshalerMethods Method, TypeHandle hndCustomMarshalertype) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; - } - CONTRACTL_END; - - - MethodTable *pMT = hndCustomMarshalertype.AsMethodTable(); - - _ASSERTE(pMT->CanCastToInterface(CoreLibBinder::GetClass(CLASS__ICUSTOM_MARSHALER))); - - MethodDesc *pMD = NULL; - - switch (Method) - { - case CustomMarshalerMethods_MarshalNativeToManaged: - pMD = pMT->GetMethodDescForInterfaceMethod( - CoreLibBinder::GetMethod(METHOD__ICUSTOM_MARSHALER__MARSHAL_NATIVE_TO_MANAGED), - TRUE /* throwOnConflict */); - break; - case CustomMarshalerMethods_MarshalManagedToNative: - pMD = pMT->GetMethodDescForInterfaceMethod( - CoreLibBinder::GetMethod(METHOD__ICUSTOM_MARSHALER__MARSHAL_MANAGED_TO_NATIVE), - TRUE /* throwOnConflict */); - break; - case CustomMarshalerMethods_CleanUpNativeData: - pMD = pMT->GetMethodDescForInterfaceMethod( - CoreLibBinder::GetMethod(METHOD__ICUSTOM_MARSHALER__CLEANUP_NATIVE_DATA), - TRUE /* throwOnConflict */); - break; - - case CustomMarshalerMethods_CleanUpManagedData: - pMD = pMT->GetMethodDescForInterfaceMethod( - CoreLibBinder::GetMethod(METHOD__ICUSTOM_MARSHALER__CLEANUP_MANAGED_DATA), - TRUE /* throwOnConflict */); - break; - case CustomMarshalerMethods_GetNativeDataSize: - pMD = pMT->GetMethodDescForInterfaceMethod( - CoreLibBinder::GetMethod(METHOD__ICUSTOM_MARSHALER__GET_NATIVE_DATA_SIZE), - TRUE /* throwOnConflict */); - break; - case CustomMarshalerMethods_GetInstance: - // Must look this up by name since it's static - pMD = MemberLoader::FindMethod(pMT, "GetInstance", &gsig_SM_Str_RetICustomMarshaler); - if (!pMD) - { - DefineFullyQualifiedNameForClassW() - COMPlusThrow(kApplicationException, - IDS_EE_GETINSTANCENOTIMPL, - GetFullyQualifiedNameForClassW(pMT)); - } - break; - default: - _ASSERTE(!"Unknown custom marshaler method"); - } - - _ASSERTE(pMD && "Unable to find specified CustomMarshaler method"); - - // Ensure that the value types in the signature are loaded. - MetaSig::EnsureSigValueTypesLoaded(pMD); - - // Return the specified method desc. - return pMD; -} - +#endif //========================================================================== // Implementation of the custom marshaler hashtable helper. //========================================================================== -EEHashEntry_t * EECMHelperHashtableHelper::AllocateEntry(EECMHelperHashtableKey *pKey, BOOL bDeepCopy, void* pHeap) +EEHashEntry_t * EECMInfoHashtableHelper::AllocateEntry(EECMInfoHashtableKey *pKey, BOOL bDeepCopy, void* pHeap) { CONTRACTL { @@ -376,11 +216,11 @@ EEHashEntry_t * EECMHelperHashtableHelper::AllocateEntry(EECMHelperHashtableKey if (bDeepCopy) { - S_SIZE_T cbEntry = S_SIZE_T(sizeof(EEHashEntry) - 1 + sizeof(EECMHelperHashtableKey)); + S_SIZE_T cbEntry = S_SIZE_T(sizeof(EEHashEntry) - 1 + sizeof(EECMInfoHashtableKey)); cbEntry += S_SIZE_T(pKey->GetMarshalerTypeNameByteCount()); cbEntry += S_SIZE_T(pKey->GetCookieStringByteCount()); cbEntry += S_SIZE_T(pKey->GetMarshalerInstantiation().GetNumArgs()) * S_SIZE_T(sizeof(LPVOID)); - cbEntry += S_SIZE_T(sizeof(LPVOID)); // For EECMHelperHashtableKey::m_invokingAssembly + cbEntry += S_SIZE_T(sizeof(LPVOID)); // For EECMInfoHashtableKey::m_invokingAssembly if (cbEntry.IsOverflow()) return NULL; @@ -389,11 +229,11 @@ EEHashEntry_t * EECMHelperHashtableHelper::AllocateEntry(EECMHelperHashtableKey if (!pEntry) return NULL; - EECMHelperHashtableKey *pEntryKey = (EECMHelperHashtableKey *) pEntry->Key; + EECMInfoHashtableKey *pEntryKey = (EECMInfoHashtableKey *) pEntry->Key; pEntryKey->m_cMarshalerTypeNameBytes = pKey->GetMarshalerTypeNameByteCount(); - pEntryKey->m_strMarshalerTypeName = (LPSTR) pEntry->Key + sizeof(EECMHelperHashtableKey); + pEntryKey->m_strMarshalerTypeName = (LPSTR) pEntry->Key + sizeof(EECMInfoHashtableKey); pEntryKey->m_cCookieStrBytes = pKey->GetCookieStringByteCount(); - pEntryKey->m_strCookie = (LPSTR) pEntry->Key + sizeof(EECMHelperHashtableKey) + pEntryKey->m_cMarshalerTypeNameBytes; + pEntryKey->m_strCookie = (LPSTR) pEntry->Key + sizeof(EECMInfoHashtableKey) + pEntryKey->m_cMarshalerTypeNameBytes; pEntryKey->m_Instantiation = Instantiation( (TypeHandle *) (pEntryKey->m_strCookie + pEntryKey->m_cCookieStrBytes), pKey->GetMarshalerInstantiation().GetNumArgs()); @@ -406,11 +246,11 @@ EEHashEntry_t * EECMHelperHashtableHelper::AllocateEntry(EECMHelperHashtableKey else { pEntry = (EEHashEntry_t *) - new (nothrow) BYTE[sizeof(EEHashEntry) - 1 + sizeof(EECMHelperHashtableKey)]; + new (nothrow) BYTE[sizeof(EEHashEntry) - 1 + sizeof(EECMInfoHashtableKey)]; if (!pEntry) return NULL; - EECMHelperHashtableKey *pEntryKey = (EECMHelperHashtableKey *) pEntry->Key; + EECMInfoHashtableKey *pEntryKey = (EECMInfoHashtableKey *) pEntry->Key; pEntryKey->m_cMarshalerTypeNameBytes = pKey->GetMarshalerTypeNameByteCount(); pEntryKey->m_strMarshalerTypeName = pKey->GetMarshalerTypeName(); pEntryKey->m_cCookieStrBytes = pKey->GetCookieStringByteCount(); @@ -423,7 +263,7 @@ EEHashEntry_t * EECMHelperHashtableHelper::AllocateEntry(EECMHelperHashtableKey } -void EECMHelperHashtableHelper::DeleteEntry(EEHashEntry_t *pEntry, void* pHeap) +void EECMInfoHashtableHelper::DeleteEntry(EEHashEntry_t *pEntry, void* pHeap) { CONTRACTL { @@ -434,11 +274,15 @@ void EECMHelperHashtableHelper::DeleteEntry(EEHashEntry_t *pEntry, void* pHeap) } CONTRACTL_END; + CustomMarshalerInfo* pInfo = reinterpret_cast(pEntry->Data); + + delete pInfo; + delete[] (BYTE*)pEntry; } -BOOL EECMHelperHashtableHelper::CompareKeys(EEHashEntry_t *pEntry, EECMHelperHashtableKey *pKey) +BOOL EECMInfoHashtableHelper::CompareKeys(EEHashEntry_t *pEntry, EECMInfoHashtableKey *pKey) { CONTRACTL { @@ -450,7 +294,7 @@ BOOL EECMHelperHashtableHelper::CompareKeys(EEHashEntry_t *pEntry, EECMHelperHas } CONTRACTL_END; - EECMHelperHashtableKey *pEntryKey = (EECMHelperHashtableKey *) pEntry->Key; + EECMInfoHashtableKey *pEntryKey = (EECMInfoHashtableKey *) pEntry->Key; if (pEntryKey->GetMarshalerTypeNameByteCount() != pKey->GetMarshalerTypeNameByteCount()) return FALSE; @@ -481,7 +325,7 @@ BOOL EECMHelperHashtableHelper::CompareKeys(EEHashEntry_t *pEntry, EECMHelperHas } -DWORD EECMHelperHashtableHelper::Hash(EECMHelperHashtableKey *pKey) +DWORD EECMInfoHashtableHelper::Hash(EECMInfoHashtableKey *pKey) { WRAPPER_NO_CONTRACT; @@ -490,169 +334,3 @@ DWORD EECMHelperHashtableHelper::Hash(EECMHelperHashtableKey *pKey) HashBytes((const BYTE *) pKey->GetCookieString(), pKey->GetCookieStringByteCount()) + HashBytes((const BYTE *) pKey->GetMarshalerInstantiation().GetRawArgs(), pKey->GetMarshalerInstantiation().GetNumArgs() * sizeof(LPVOID))); } - - -OBJECTREF CustomMarshalerHelper::InvokeMarshalNativeToManagedMeth(void *pNative) -{ - WRAPPER_NO_CONTRACT; - return GetCustomMarshalerInfo()->InvokeMarshalNativeToManagedMeth(pNative); -} - - -void *CustomMarshalerHelper::InvokeMarshalManagedToNativeMeth(OBJECTREF MngObj) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; - } - CONTRACTL_END; - - void *RetVal = NULL; - - GCPROTECT_BEGIN(MngObj) - { - CustomMarshalerInfo *pCMInfo = GetCustomMarshalerInfo(); - RetVal = pCMInfo->InvokeMarshalManagedToNativeMeth(MngObj); - } - GCPROTECT_END(); - - return RetVal; -} - - -void CustomMarshalerHelper::InvokeCleanUpNativeMeth(void *pNative) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; - } - CONTRACTL_END; - - OBJECTREF ExceptionObj = NULL; - GCPROTECT_BEGIN(ExceptionObj) - { - EX_TRY - { - GetCustomMarshalerInfo()->InvokeCleanUpNativeMeth(pNative); - } - EX_CATCH - { - ExceptionObj = GET_THROWABLE(); - } - EX_END_CATCH(SwallowAllExceptions); - } - GCPROTECT_END(); -} - - -void CustomMarshalerHelper::InvokeCleanUpManagedMeth(OBJECTREF MngObj) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; - } - CONTRACTL_END; - - GCPROTECT_BEGIN(MngObj) - { - CustomMarshalerInfo *pCMInfo = GetCustomMarshalerInfo(); - pCMInfo->InvokeCleanUpManagedMeth(MngObj); - } - GCPROTECT_END(); -} - - -void *NonSharedCustomMarshalerHelper::operator new(size_t size, LoaderHeap *pHeap) -{ - CONTRACTL - { - THROWS; - GC_NOTRIGGER; - MODE_ANY; - INJECT_FAULT(COMPlusThrowOM()); - PRECONDITION(CheckPointer(pHeap)); - } - CONTRACTL_END; - - return pHeap->AllocMem(S_SIZE_T(sizeof(NonSharedCustomMarshalerHelper))); -} - - -void NonSharedCustomMarshalerHelper::operator delete(void *pMem) -{ - // Instances of this class are always allocated on the loader heap so - // the delete operator has nothing to do. - LIMITED_METHOD_CONTRACT; -} - - -SharedCustomMarshalerHelper::SharedCustomMarshalerHelper(Assembly *pAssembly, TypeHandle hndManagedType, LPCUTF8 strMarshalerTypeName, DWORD cMarshalerTypeNameBytes, LPCUTF8 strCookie, DWORD cCookieStrBytes) -: m_pAssembly(pAssembly) -, m_hndManagedType(hndManagedType) -, m_cMarshalerTypeNameBytes(cMarshalerTypeNameBytes) -, m_strMarshalerTypeName(strMarshalerTypeName) -, m_cCookieStrBytes(cCookieStrBytes) -, m_strCookie(strCookie) -{ - WRAPPER_NO_CONTRACT; -} - - -void *SharedCustomMarshalerHelper::operator new(size_t size, LoaderHeap *pHeap) -{ - CONTRACTL - { - THROWS; - GC_NOTRIGGER; - MODE_ANY; - INJECT_FAULT(COMPlusThrowOM()); - PRECONDITION(CheckPointer(pHeap)); - } - CONTRACTL_END; - - return pHeap->AllocMem(S_SIZE_T(sizeof(SharedCustomMarshalerHelper))); -} - - -void SharedCustomMarshalerHelper::operator delete(void *pMem) -{ - // Instances of this class are always allocated on the loader heap so - // the delete operator has nothing to do. - LIMITED_METHOD_CONTRACT; -} - - -CustomMarshalerInfo *SharedCustomMarshalerHelper::GetCustomMarshalerInfo() -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; - } - CONTRACTL_END; - - // Retrieve the marshalling data for the current app domain. - EEMarshalingData *pMarshalingData = AppDomain::GetCurrentDomain()->GetLoaderAllocator()->GetMarshalingData(); - - // Retrieve the custom marshaling information for the current shared custom - // marshaling helper. - return pMarshalingData->GetCustomMarshalerInfo(this); -} - -extern "C" void QCALLTYPE CustomMarshaler_GetMarshalerObject(CustomMarshalerHelper* pCMHelper, QCall::ObjectHandleOnStack retObject) -{ - QCALL_CONTRACT; - BEGIN_QCALL; - GCX_COOP(); - - retObject.Set(pCMHelper->GetCustomMarshalerInfo()->GetCustomMarshaler()); - - END_QCALL; -} diff --git a/src/coreclr/vm/custommarshalerinfo.h b/src/coreclr/vm/custommarshalerinfo.h index 802918dcd67..98dd71858a0 100644 --- a/src/coreclr/vm/custommarshalerinfo.h +++ b/src/coreclr/vm/custommarshalerinfo.h @@ -17,21 +17,7 @@ #include "vars.hpp" #include "slist.h" - -// This enumeration is used to retrieve a method desc from CustomMarshalerInfo::GetCustomMarshalerMD(). -enum EnumCustomMarshalerMethods -{ - CustomMarshalerMethods_MarshalNativeToManaged = 0, - CustomMarshalerMethods_MarshalManagedToNative, - CustomMarshalerMethods_CleanUpNativeData, - CustomMarshalerMethods_CleanUpManagedData, - CustomMarshalerMethods_GetNativeDataSize, - CustomMarshalerMethods_GetInstance, - CustomMarshalerMethods_LastMember -}; - - -class CustomMarshalerInfo +class CustomMarshalerInfo final { public: // Constructor and destructor. @@ -43,82 +29,35 @@ class CustomMarshalerInfo void* operator new(size_t size, LoaderHeap* pHeap); void operator delete(void* pMem); - // Helpers used to invoke the different methods in the ICustomMarshaler interface. - OBJECTREF InvokeMarshalNativeToManagedMeth(void* pNative); - void* InvokeMarshalManagedToNativeMeth(OBJECTREF MngObj); - void InvokeCleanUpNativeMeth(void* pNative); - void InvokeCleanUpManagedMeth(OBJECTREF MngObj); - // Accessors. - int GetNativeSize() - { - LIMITED_METHOD_CONTRACT; - return m_NativeSize; - } - - int GetManagedSize() - { - WRAPPER_NO_CONTRACT; - return m_hndManagedType.GetSize(); - } - - TypeHandle GetManagedType() - { - LIMITED_METHOD_CONTRACT; - return m_hndManagedType; - } - - BOOL IsDataByValue() - { - LIMITED_METHOD_CONTRACT; - return m_bDataIsByValue; - } - OBJECTREF GetCustomMarshaler() { LIMITED_METHOD_CONTRACT; return m_pLoaderAllocator->GetHandleValue(m_hndCustomMarshaler); } - TypeHandle GetCustomMarshalerType() - { - CONTRACTL - { - NOTHROW; - GC_NOTRIGGER; - MODE_COOPERATIVE; - } - CONTRACTL_END; - return m_pLoaderAllocator->GetHandleValue(m_hndCustomMarshaler)->GetTypeHandle(); - } - - // Helper function to retrieve a custom marshaler method desc. - static MethodDesc* GetCustomMarshalerMD(EnumCustomMarshalerMethods Method, TypeHandle hndCustomMarshalertype); - - // Link used to contain this CM info in a linked list. - SLink m_Link; +#ifdef FEATURE_COMINTEROP + static CustomMarshalerInfo* CreateIEnumeratorMarshalerInfo(LoaderHeap* pHeap, LoaderAllocator* pLoaderAllocator); +#endif // FEATURE_COMINTEROP private: - int m_NativeSize; - TypeHandle m_hndManagedType; LoaderAllocator* m_pLoaderAllocator; LOADERHANDLE m_hndCustomMarshaler; - MethodDesc* m_pMarshalNativeToManagedMD; - MethodDesc* m_pMarshalManagedToNativeMD; - MethodDesc* m_pCleanUpNativeDataMD; - MethodDesc* m_pCleanUpManagedDataMD; - BOOL m_bDataIsByValue; -}; - -typedef SList CMINFOLIST; + CustomMarshalerInfo(LoaderAllocator* pLoaderAllocator, LOADERHANDLE hndCustomMarshaler) + : m_pLoaderAllocator(pLoaderAllocator) + , m_hndCustomMarshaler(hndCustomMarshaler) + { + LIMITED_METHOD_CONTRACT; + } +}; class Assembly; -class EECMHelperHashtableKey +class EECMInfoHashtableKey { public: - EECMHelperHashtableKey(DWORD cMarshalerTypeNameBytes, LPCSTR strMarshalerTypeName, DWORD cCookieStrBytes, LPCSTR strCookie, Instantiation instantiation, Assembly* invokingAssembly) + EECMInfoHashtableKey(DWORD cMarshalerTypeNameBytes, LPCSTR strMarshalerTypeName, DWORD cCookieStrBytes, LPCSTR strCookie, Instantiation instantiation, Assembly* invokingAssembly) : m_cMarshalerTypeNameBytes(cMarshalerTypeNameBytes) , m_strMarshalerTypeName(strMarshalerTypeName) , m_cCookieStrBytes(cCookieStrBytes) @@ -169,152 +108,16 @@ class EECMHelperHashtableKey }; -class EECMHelperHashtableHelper +class EECMInfoHashtableHelper { public: - static EEHashEntry_t* AllocateEntry(EECMHelperHashtableKey* pKey, BOOL bDeepCopy, AllocationHeap Heap); + static EEHashEntry_t* AllocateEntry(EECMInfoHashtableKey* pKey, BOOL bDeepCopy, AllocationHeap Heap); static void DeleteEntry(EEHashEntry_t* pEntry, AllocationHeap Heap); - static BOOL CompareKeys(EEHashEntry_t* pEntry, EECMHelperHashtableKey* pKey); - static DWORD Hash(EECMHelperHashtableKey* pKey); -}; - - -typedef EEHashTable EECMHelperHashTable; - - -class CustomMarshalerHelper -{ -public: - // Helpers used to invoke the different methods in the ICustomMarshaler interface. - OBJECTREF InvokeMarshalNativeToManagedMeth(void* pNative); - void* InvokeMarshalManagedToNativeMeth(OBJECTREF MngObj); - void InvokeCleanUpNativeMeth(void* pNative); - void InvokeCleanUpManagedMeth(OBJECTREF MngObj); - - // Accessors. - int GetNativeSize() - { - WRAPPER_NO_CONTRACT; - return GetCustomMarshalerInfo()->GetNativeSize(); - } - - int GetManagedSize() - { - WRAPPER_NO_CONTRACT; - return GetCustomMarshalerInfo()->GetManagedSize(); - } - - TypeHandle GetManagedType() - { - WRAPPER_NO_CONTRACT; - return GetCustomMarshalerInfo()->GetManagedType(); - } - - BOOL IsDataByValue() - { - WRAPPER_NO_CONTRACT; - return GetCustomMarshalerInfo()->IsDataByValue(); - } - - // Helper function to retrieve the custom marshaler object. - virtual CustomMarshalerInfo* GetCustomMarshalerInfo() = 0; - -protected: - ~CustomMarshalerHelper( void ) - { - LIMITED_METHOD_CONTRACT; - } + static BOOL CompareKeys(EEHashEntry_t* pEntry, EECMInfoHashtableKey* pKey); + static DWORD Hash(EECMInfoHashtableKey* pKey); }; -class NonSharedCustomMarshalerHelper : public CustomMarshalerHelper -{ -public: - // Constructor. - NonSharedCustomMarshalerHelper(CustomMarshalerInfo* pCMInfo) : m_pCMInfo(pCMInfo) - { - WRAPPER_NO_CONTRACT; - } - - // CustomMarshalerHelpers's are always allocated on the loader heap so we need to redefine - // the new and delete operators to ensure this. - void *operator new(size_t size, LoaderHeap *pHeap); - void operator delete(void* pMem); - -protected: - // Helper function to retrieve the custom marshaler object. - virtual CustomMarshalerInfo* GetCustomMarshalerInfo() - { - LIMITED_METHOD_CONTRACT; - return m_pCMInfo; - } - -private: - CustomMarshalerInfo* m_pCMInfo; -}; - - -class SharedCustomMarshalerHelper : public CustomMarshalerHelper -{ -public: - // Constructor. - SharedCustomMarshalerHelper(Assembly* pAssembly, TypeHandle hndManagedType, LPCUTF8 strMarshalerTypeName, DWORD cMarshalerTypeNameBytes, LPCUTF8 strCookie, DWORD cCookieStrBytes); - - // CustomMarshalerHelpers's are always allocated on the loader heap so we need to redefine - // the new and delete operators to ensure this. - void* operator new(size_t size, LoaderHeap* pHeap); - void operator delete(void* pMem); - - // Accessors. - inline Assembly* GetAssembly() - { - LIMITED_METHOD_CONTRACT; - return m_pAssembly; - } - - inline TypeHandle GetManagedType() - { - LIMITED_METHOD_CONTRACT; - return m_hndManagedType; - } - - inline DWORD GetMarshalerTypeNameByteCount() - { - LIMITED_METHOD_CONTRACT; - return m_cMarshalerTypeNameBytes; - } - - inline LPCSTR GetMarshalerTypeName() - { - LIMITED_METHOD_CONTRACT; - return m_strMarshalerTypeName; - } - - inline LPCSTR GetCookieString() - { - LIMITED_METHOD_CONTRACT; - return m_strCookie; - } - - inline ULONG GetCookieStringByteCount() - { - LIMITED_METHOD_CONTRACT; - return m_cCookieStrBytes; - } - -protected: - // Helper function to retrieve the custom marshaler object. - virtual CustomMarshalerInfo* GetCustomMarshalerInfo(); - -private: - Assembly* m_pAssembly; - TypeHandle m_hndManagedType; - DWORD m_cMarshalerTypeNameBytes; - LPCUTF8 m_strMarshalerTypeName; - DWORD m_cCookieStrBytes; - LPCUTF8 m_strCookie; -}; - -extern "C" void QCALLTYPE CustomMarshaler_GetMarshalerObject(CustomMarshalerHelper* pCMHelper, QCall::ObjectHandleOnStack retObject); +typedef EEHashTable EECMInfoHashTable; #endif // _CUSTOMMARSHALERINFO_H_ diff --git a/src/coreclr/vm/dbginterface.h b/src/coreclr/vm/dbginterface.h index 830b273b133..0e247a2dea4 100644 --- a/src/coreclr/vm/dbginterface.h +++ b/src/coreclr/vm/dbginterface.h @@ -67,7 +67,6 @@ class DebugInterface LPCWSTR psModuleName, // module file name DWORD dwModuleName, // number of characters in file name excludign null Assembly * pAssembly, // the assembly the module belongs to - AppDomain * pAppDomain, // the AppDomain the module is being loaded into DomainAssembly * pDomainAssembly, BOOL fAttaching) = 0; // true if this notification is due to a debugger // being attached to the process @@ -78,7 +77,7 @@ class DebugInterface // calls and before any UnloadAssembly or RemoveAppDomainFromIPCBlock calls realted // to this module. On CLR shutdown, we are not guaranteed to get UnloadModule calls for // all outstanding loaded modules. - virtual void UnloadModule(Module* pRuntimeModule, AppDomain *pAppDomain) = 0; + virtual void UnloadModule(Module* pRuntimeModule) = 0; // Called when a Module* is being destroyed. // Specifically, the Module has completed unloading (which may have been done asyncronously), all resources diff --git a/src/coreclr/vm/debugdebugger.cpp b/src/coreclr/vm/debugdebugger.cpp index 057de85b2bf..abb873942ab 100644 --- a/src/coreclr/vm/debugdebugger.cpp +++ b/src/coreclr/vm/debugdebugger.cpp @@ -40,12 +40,12 @@ // Else if a native debugger is attached, this should send a native break event (kernel32!DebugBreak) // Else, this should invoke Watson. // -FCIMPL0(void, DebugDebugger::Break) +extern "C" void QCALLTYPE DebugDebugger_Break() { - FCALL_CONTRACT; + QCALL_CONTRACT; #ifdef DEBUGGING_SUPPORTED - HELPER_METHOD_FRAME_BEGIN_0(); + BEGIN_QCALL; #ifdef _DEBUG { @@ -73,21 +73,17 @@ FCIMPL0(void, DebugDebugger::Break) // No managed debugger, but a native debug is attached. Explicitly fire a native user breakpoint. // Don't rely on Watson support since that may have a different policy. - // Toggle to preemptive before firing the debug event. This allows the debugger to suspend this + // Confirm we're in preemptive before firing the debug event. This allows the debugger to suspend this // thread at the debug event. - GCX_PREEMP(); + _ASSERTE(!GetThread()->PreemptiveGCDisabled()); // This becomes an unmanaged breakpoint, such as int 3. DebugBreak(); } - else - { - } - HELPER_METHOD_FRAME_END(); + END_QCALL; #endif // DEBUGGING_SUPPORTED } -FCIMPLEND extern "C" BOOL QCALLTYPE DebugDebugger_Launch() { @@ -230,44 +226,146 @@ FCIMPL0(FC_BOOL_RET, DebugDebugger::IsLogging) } FCIMPLEND -FCIMPL4(void, DebugStackTrace::GetStackFramesInternal, - StackFrameHelper* pStackFrameHelperUNSAFE, - INT32 iSkip, - CLR_BOOL fNeedFileInfo, - Object* pExceptionUNSAFE - ) +static StackWalkAction GetStackFramesCallback(CrawlFrame* pCf, VOID* data) { CONTRACTL { - FCALL_CHECK; - PRECONDITION(CheckPointer(pStackFrameHelperUNSAFE)); - PRECONDITION(CheckPointer(pExceptionUNSAFE, NULL_OK)); + THROWS; + GC_TRIGGERS; + MODE_COOPERATIVE; } CONTRACTL_END; - STACKFRAMEHELPERREF pStackFrameHelper = (STACKFRAMEHELPERREF)ObjectToOBJECTREF(pStackFrameHelperUNSAFE); - OBJECTREF pException = ObjectToOBJECTREF(pExceptionUNSAFE); - PTRARRAYREF dynamicMethodArrayOrig = NULL; + // @todo: How do we know what kind of frame we have? + // Can we always assume FramedMethodFrame? + // NOT AT ALL!!!, but we can assume it's a function + // because we asked the stackwalker for it! + MethodDesc* pFunc = pCf->GetFunction(); - HELPER_METHOD_FRAME_BEGIN_2(pStackFrameHelper, pException); + DebugStackTrace::GetStackFramesData* pData = (DebugStackTrace::GetStackFramesData*)data; + if (pData->cElements >= pData->cElementsAllocated) + { + DebugStackTrace::Element* pTemp = new (nothrow) DebugStackTrace::Element[2*pData->cElementsAllocated]; + if (pTemp == NULL) + { + return SWA_ABORT; + } - GCPROTECT_BEGIN(dynamicMethodArrayOrig); + memcpy(pTemp, pData->pElements, pData->cElementsAllocated * sizeof(DebugStackTrace::Element)); - ASSERT(iSkip >= 0); + delete [] pData->pElements; + + pData->pElements = pTemp; + pData->cElementsAllocated *= 2; + } - GetStackFramesData data; + PCODE ip; + DWORD dwNativeOffset; - data.pDomain = GetAppDomain(); + if (pCf->IsFrameless()) + { + // Real method with jitted code. + dwNativeOffset = pCf->GetRelOffset(); + ip = GetControlPC(pCf->GetRegisterSet()); + } + else + { + ip = (PCODE)NULL; + dwNativeOffset = 0; + } + + // Pass on to InitPass2 that the IP has already been adjusted (decremented by 1) + INT flags = pCf->IsIPadjusted() ? STEF_IP_ADJUSTED : 0; + + pData->pElements[pData->cElements].InitPass1( + dwNativeOffset, + pFunc, + ip, + flags); + + // We'll init the IL offsets outside the TSL lock. + + ++pData->cElements; + + // check if we already have the number of frames that the user had asked for + if ((pData->NumFramesRequested != 0) && (pData->NumFramesRequested <= pData->cElements)) + { + return SWA_ABORT; + } + + return SWA_CONTINUE; +} + +static void GetStackFrames(DebugStackTrace::GetStackFramesData *pData) +{ + CONTRACTL + { + MODE_COOPERATIVE; + GC_TRIGGERS; + THROWS; + } + CONTRACTL_END; + + ASSERT (pData != NULL); + + pData->cElements = 0; + + // if the caller specified (< 20) frames are required, then allocate + // only that many + if ((pData->NumFramesRequested > 0) && (pData->NumFramesRequested < 20)) + { + pData->cElementsAllocated = pData->NumFramesRequested; + } + else + { + pData->cElementsAllocated = 20; + } + + // Allocate memory for the initial 'n' frames + pData->pElements = new DebugStackTrace::Element[pData->cElementsAllocated]; + GetThread()->StackWalkFrames(GetStackFramesCallback, pData, FUNCTIONSONLY | QUICKUNWIND, NULL); + + // Do a 2nd pass outside of any locks. + // This will compute IL offsets. + for (INT32 i = 0; i < pData->cElements; i++) + { + pData->pElements[i].InitPass2(); + } +} + +extern "C" void QCALLTYPE StackTrace_GetStackFramesInternal( + QCall::ObjectHandleOnStack stackFrameHelper, + BOOL fNeedFileInfo, + QCall::ObjectHandleOnStack exception) +{ + QCALL_CONTRACT; - data.skip = iSkip; + BEGIN_QCALL; - data.NumFramesRequested = pStackFrameHelper->iFrameCount; + GCX_COOP(); - if (pException == NULL) + struct { - // Thread is NULL if it's the current thread. - data.TargetThread = pStackFrameHelper->targetThread; - GetStackFrames(NULL, (void*)-1, &data); + STACKFRAMEHELPERREF pStackFrameHelper; + OBJECTREF pException; + PTRARRAYREF dynamicMethodArrayOrig; + } gc{}; + gc.pStackFrameHelper = NULL; + gc.pException = NULL; + gc.dynamicMethodArrayOrig = NULL; + GCPROTECT_BEGIN(gc); + gc.pStackFrameHelper = (STACKFRAMEHELPERREF)stackFrameHelper.Get(); + gc.pException = exception.Get(); + + DebugStackTrace::GetStackFramesData data; + + data.pDomain = GetAppDomain(); + + data.NumFramesRequested = gc.pStackFrameHelper->iFrameCount; + + if (gc.pException == NULL) + { + GetStackFrames(&data); } else { @@ -276,10 +374,14 @@ FCIMPL4(void, DebugStackTrace::GetStackFramesInternal, // is thrown again (resetting the dynamic method array reference in the object) // that may result in resolver objects getting collected before they can be reachable again // (from the code below). - GetStackFramesFromException(&pException, &data, &dynamicMethodArrayOrig); + DebugStackTrace::GetStackFramesFromException(&gc.pException, &data, &gc.dynamicMethodArrayOrig); } - if (data.cElements != 0) + if (data.cElements == 0) + { + gc.pStackFrameHelper->iFrameCount = 0; + } + else { #if defined(FEATURE_ISYM_READER) && defined(FEATURE_COMINTEROP) if (fNeedFileInfo) @@ -291,59 +393,59 @@ FCIMPL4(void, DebugStackTrace::GetStackFramesInternal, // Allocate memory for the MethodInfo objects BASEARRAYREF methodInfoArray = (BASEARRAYREF) AllocatePrimitiveArray(ELEMENT_TYPE_I, data.cElements); - SetObjectReference( (OBJECTREF *)&(pStackFrameHelper->rgMethodHandle), (OBJECTREF)methodInfoArray); + SetObjectReference( (OBJECTREF *)&(gc.pStackFrameHelper->rgMethodHandle), (OBJECTREF)methodInfoArray); // Allocate memory for the Offsets OBJECTREF offsets = AllocatePrimitiveArray(ELEMENT_TYPE_I4, data.cElements); - SetObjectReference( (OBJECTREF *)&(pStackFrameHelper->rgiOffset), (OBJECTREF)offsets); + SetObjectReference( (OBJECTREF *)&(gc.pStackFrameHelper->rgiOffset), (OBJECTREF)offsets); // Allocate memory for the ILOffsets OBJECTREF ilOffsets = AllocatePrimitiveArray(ELEMENT_TYPE_I4, data.cElements); - SetObjectReference( (OBJECTREF *)&(pStackFrameHelper->rgiILOffset), (OBJECTREF)ilOffsets); + SetObjectReference( (OBJECTREF *)&(gc.pStackFrameHelper->rgiILOffset), (OBJECTREF)ilOffsets); // Allocate memory for the array of assembly file names PTRARRAYREF assemblyPathArray = (PTRARRAYREF) AllocateObjectArray(data.cElements, g_pStringClass); - SetObjectReference( (OBJECTREF *)&(pStackFrameHelper->rgAssemblyPath), (OBJECTREF)assemblyPathArray); + SetObjectReference( (OBJECTREF *)&(gc.pStackFrameHelper->rgAssemblyPath), (OBJECTREF)assemblyPathArray); // Allocate memory for the array of assemblies PTRARRAYREF assemblyArray = (PTRARRAYREF) AllocateObjectArray(data.cElements, g_pObjectClass); - SetObjectReference( (OBJECTREF *)&(pStackFrameHelper->rgAssembly), (OBJECTREF)assemblyArray); + SetObjectReference( (OBJECTREF *)&(gc.pStackFrameHelper->rgAssembly), (OBJECTREF)assemblyArray); // Allocate memory for the LoadedPeAddress BASEARRAYREF loadedPeAddressArray = (BASEARRAYREF) AllocatePrimitiveArray(ELEMENT_TYPE_I, data.cElements); - SetObjectReference( (OBJECTREF *)&(pStackFrameHelper->rgLoadedPeAddress), (OBJECTREF)loadedPeAddressArray); + SetObjectReference( (OBJECTREF *)&(gc.pStackFrameHelper->rgLoadedPeAddress), (OBJECTREF)loadedPeAddressArray); // Allocate memory for the LoadedPeSize OBJECTREF loadedPeSizeArray = AllocatePrimitiveArray(ELEMENT_TYPE_I4, data.cElements); - SetObjectReference( (OBJECTREF *)&(pStackFrameHelper->rgiLoadedPeSize), (OBJECTREF)loadedPeSizeArray); + SetObjectReference( (OBJECTREF *)&(gc.pStackFrameHelper->rgiLoadedPeSize), (OBJECTREF)loadedPeSizeArray); // Allocate memory for the IsFileLayout flags OBJECTREF isFileLayouts = AllocatePrimitiveArray(ELEMENT_TYPE_BOOLEAN, data.cElements); - SetObjectReference( (OBJECTREF *)&(pStackFrameHelper->rgiIsFileLayout), (OBJECTREF)isFileLayouts); + SetObjectReference( (OBJECTREF *)&(gc.pStackFrameHelper->rgiIsFileLayout), (OBJECTREF)isFileLayouts); // Allocate memory for the InMemoryPdbAddress BASEARRAYREF inMemoryPdbAddressArray = (BASEARRAYREF) AllocatePrimitiveArray(ELEMENT_TYPE_I, data.cElements); - SetObjectReference( (OBJECTREF *)&(pStackFrameHelper->rgInMemoryPdbAddress), (OBJECTREF)inMemoryPdbAddressArray); + SetObjectReference( (OBJECTREF *)&(gc.pStackFrameHelper->rgInMemoryPdbAddress), (OBJECTREF)inMemoryPdbAddressArray); // Allocate memory for the InMemoryPdbSize OBJECTREF inMemoryPdbSizeArray = AllocatePrimitiveArray(ELEMENT_TYPE_I4, data.cElements); - SetObjectReference( (OBJECTREF *)&(pStackFrameHelper->rgiInMemoryPdbSize), (OBJECTREF)inMemoryPdbSizeArray); + SetObjectReference( (OBJECTREF *)&(gc.pStackFrameHelper->rgiInMemoryPdbSize), (OBJECTREF)inMemoryPdbSizeArray); // Allocate memory for the MethodTokens OBJECTREF methodTokens = AllocatePrimitiveArray(ELEMENT_TYPE_I4, data.cElements); - SetObjectReference( (OBJECTREF *)&(pStackFrameHelper->rgiMethodToken), (OBJECTREF)methodTokens); + SetObjectReference( (OBJECTREF *)&(gc.pStackFrameHelper->rgiMethodToken), (OBJECTREF)methodTokens); // Allocate memory for the Filename string objects PTRARRAYREF filenameArray = (PTRARRAYREF) AllocateObjectArray(data.cElements, g_pStringClass); - SetObjectReference( (OBJECTREF *)&(pStackFrameHelper->rgFilename), (OBJECTREF)filenameArray); + SetObjectReference( (OBJECTREF *)&(gc.pStackFrameHelper->rgFilename), (OBJECTREF)filenameArray); // Allocate memory for the LineNumbers OBJECTREF lineNumbers = AllocatePrimitiveArray(ELEMENT_TYPE_I4, data.cElements); - SetObjectReference( (OBJECTREF *)&(pStackFrameHelper->rgiLineNumber), (OBJECTREF)lineNumbers); + SetObjectReference( (OBJECTREF *)&(gc.pStackFrameHelper->rgiLineNumber), (OBJECTREF)lineNumbers); // Allocate memory for the ColumnNumbers OBJECTREF columnNumbers = AllocatePrimitiveArray(ELEMENT_TYPE_I4, data.cElements); - SetObjectReference( (OBJECTREF *)&(pStackFrameHelper->rgiColumnNumber), (OBJECTREF)columnNumbers); + SetObjectReference( (OBJECTREF *)&(gc.pStackFrameHelper->rgiColumnNumber), (OBJECTREF)columnNumbers); // Allocate memory for the flag indicating if this frame represents the last one from a foreign // exception stack trace provided we have any such frames. Otherwise, set it to null. @@ -357,11 +459,11 @@ FCIMPL4(void, DebugStackTrace::GetStackFramesInternal, { IsLastFrameFromForeignStackTraceFlags = AllocatePrimitiveArray(ELEMENT_TYPE_BOOLEAN, data.cElements); - SetObjectReference( (OBJECTREF *)&(pStackFrameHelper->rgiLastFrameFromForeignExceptionStackTrace), (OBJECTREF)IsLastFrameFromForeignStackTraceFlags); + SetObjectReference( (OBJECTREF *)&(gc.pStackFrameHelper->rgiLastFrameFromForeignExceptionStackTrace), (OBJECTREF)IsLastFrameFromForeignStackTraceFlags); } else { - SetObjectReference( (OBJECTREF *)&(pStackFrameHelper->rgiLastFrameFromForeignExceptionStackTrace), NULL); + SetObjectReference( (OBJECTREF *)&(gc.pStackFrameHelper->rgiLastFrameFromForeignExceptionStackTrace), NULL); } // Determine if there are any dynamic methods in the stack trace. If there are, @@ -385,7 +487,7 @@ FCIMPL4(void, DebugStackTrace::GetStackFramesInternal, if (iNumDynamics) { PTRARRAYREF dynamicDataArray = (PTRARRAYREF) AllocateObjectArray(iNumDynamics, g_pObjectClass); - SetObjectReference( (OBJECTREF *)&(pStackFrameHelper->dynamicMethods), (OBJECTREF)dynamicDataArray); + SetObjectReference( (OBJECTREF *)&(gc.pStackFrameHelper->dynamicMethods), (OBJECTREF)dynamicDataArray); } int iNumValidFrames = 0; @@ -401,25 +503,25 @@ FCIMPL4(void, DebugStackTrace::GetStackFramesInternal, _ASSERTE(pFunc->IsRuntimeMethodHandle()); // Method handle - size_t *pElem = (size_t*)pStackFrameHelper->rgMethodHandle->GetDataPtr(); + size_t *pElem = (size_t*)gc.pStackFrameHelper->rgMethodHandle->GetDataPtr(); pElem[iNumValidFrames] = (size_t)pFunc; // Native offset - CLR_I4 *pI4 = (CLR_I4 *)((I4ARRAYREF)pStackFrameHelper->rgiOffset)->GetDirectPointerToNonObjectElements(); + CLR_I4 *pI4 = (CLR_I4 *)((I4ARRAYREF)gc.pStackFrameHelper->rgiOffset)->GetDirectPointerToNonObjectElements(); pI4[iNumValidFrames] = data.pElements[i].dwOffset; // IL offset - CLR_I4 *pILI4 = (CLR_I4 *)((I4ARRAYREF)pStackFrameHelper->rgiILOffset)->GetDirectPointerToNonObjectElements(); + CLR_I4 *pILI4 = (CLR_I4 *)((I4ARRAYREF)gc.pStackFrameHelper->rgiILOffset)->GetDirectPointerToNonObjectElements(); pILI4[iNumValidFrames] = data.pElements[i].dwILOffset; // Assembly OBJECTREF pAssembly = pFunc->GetAssembly()->GetExposedObject(); - pStackFrameHelper->rgAssembly->SetAt(iNumValidFrames, pAssembly); + gc.pStackFrameHelper->rgAssembly->SetAt(iNumValidFrames, pAssembly); if (data.fDoWeHaveAnyFramesFromForeignStackTrace) { // Set the BOOL indicating if the frame represents the last frame from a foreign exception stack trace. - CLR_U1 *pIsLastFrameFromForeignExceptionStackTraceU1 = (CLR_U1 *)((BOOLARRAYREF)pStackFrameHelper->rgiLastFrameFromForeignExceptionStackTrace) + CLR_U1 *pIsLastFrameFromForeignExceptionStackTraceU1 = (CLR_U1 *)((BOOLARRAYREF)gc.pStackFrameHelper->rgiLastFrameFromForeignExceptionStackTrace) ->GetDirectPointerToNonObjectElements(); pIsLastFrameFromForeignExceptionStackTraceU1 [iNumValidFrames] = (CLR_U1)(data.pElements[i].flags & STEF_LAST_FRAME_FROM_FOREIGN_STACK_TRACE); } @@ -436,13 +538,13 @@ FCIMPL4(void, DebugStackTrace::GetStackFramesInternal, OBJECTREF pResolver = pDMD->GetLCGMethodResolver()->GetManagedResolver(); _ASSERTE(pResolver != NULL); - ((PTRARRAYREF)pStackFrameHelper->dynamicMethods)->SetAt(iCurDynamic++, pResolver); + ((PTRARRAYREF)gc.pStackFrameHelper->dynamicMethods)->SetAt(iCurDynamic++, pResolver); } else if (pMethod->GetMethodTable()->Collectible()) { OBJECTREF pLoaderAllocator = pMethod->GetMethodTable()->GetLoaderAllocator()->GetExposedObject(); _ASSERTE(pLoaderAllocator != NULL); - ((PTRARRAYREF)pStackFrameHelper->dynamicMethods)->SetAt(iCurDynamic++, pLoaderAllocator); + ((PTRARRAYREF)gc.pStackFrameHelper->dynamicMethods)->SetAt(iCurDynamic++, pLoaderAllocator); } } @@ -658,15 +760,15 @@ FCIMPL4(void, DebugStackTrace::GetStackFramesInternal, if (fFileInfoSet) { // Set the line and column numbers - CLR_I4 *pI4Line = (CLR_I4 *)((I4ARRAYREF)pStackFrameHelper->rgiLineNumber)->GetDirectPointerToNonObjectElements(); + CLR_I4 *pI4Line = (CLR_I4 *)((I4ARRAYREF)gc.pStackFrameHelper->rgiLineNumber)->GetDirectPointerToNonObjectElements(); pI4Line[iNumValidFrames] = sourceLine; - CLR_I4 *pI4Column = (CLR_I4 *)((I4ARRAYREF)pStackFrameHelper->rgiColumnNumber)->GetDirectPointerToNonObjectElements(); + CLR_I4 *pI4Column = (CLR_I4 *)((I4ARRAYREF)gc.pStackFrameHelper->rgiColumnNumber)->GetDirectPointerToNonObjectElements(); pI4Column[iNumValidFrames] = sourceColumn; // Set the file name OBJECTREF obj = (OBJECTREF) StringObject::NewString(wszFileName); - pStackFrameHelper->rgFilename->SetAt(iNumValidFrames, obj); + gc.pStackFrameHelper->rgFilename->SetAt(iNumValidFrames, obj); } } @@ -676,7 +778,7 @@ FCIMPL4(void, DebugStackTrace::GetStackFramesInternal, #endif // FEATURE_ISYM_READER { // Save MethodToken for the function - CLR_I4 *pMethodToken = (CLR_I4 *)((I4ARRAYREF)pStackFrameHelper->rgiMethodToken)->GetDirectPointerToNonObjectElements(); + CLR_I4 *pMethodToken = (CLR_I4 *)((I4ARRAYREF)gc.pStackFrameHelper->rgiMethodToken)->GetDirectPointerToNonObjectElements(); pMethodToken[iNumValidFrames] = pMethod->GetMemberDef(); PEAssembly *pPEAssembly = pModule->GetPEAssembly(); @@ -686,17 +788,17 @@ FCIMPL4(void, DebugStackTrace::GetStackFramesInternal, PTR_CVOID peAddress = pPEAssembly->GetLoadedImageContents(&peSize); // Save the PE address and size - PTR_CVOID *pLoadedPeAddress = (PTR_CVOID *)pStackFrameHelper->rgLoadedPeAddress->GetDataPtr(); + PTR_CVOID *pLoadedPeAddress = (PTR_CVOID *)gc.pStackFrameHelper->rgLoadedPeAddress->GetDataPtr(); pLoadedPeAddress[iNumValidFrames] = peAddress; - CLR_I4 *pLoadedPeSize = (CLR_I4 *)((I4ARRAYREF)pStackFrameHelper->rgiLoadedPeSize)->GetDirectPointerToNonObjectElements(); + CLR_I4 *pLoadedPeSize = (CLR_I4 *)((I4ARRAYREF)gc.pStackFrameHelper->rgiLoadedPeSize)->GetDirectPointerToNonObjectElements(); pLoadedPeSize[iNumValidFrames] = (CLR_I4)peSize; // Set flag indicating PE file in memory has the on disk layout if (!pPEAssembly->IsReflectionEmit()) { // This flag is only available for non-dynamic assemblies. - CLR_U1 *pIsFileLayout = (CLR_U1 *)((BOOLARRAYREF)pStackFrameHelper->rgiIsFileLayout)->GetDirectPointerToNonObjectElements(); + CLR_U1 *pIsFileLayout = (CLR_U1 *)((BOOLARRAYREF)gc.pStackFrameHelper->rgiIsFileLayout)->GetDirectPointerToNonObjectElements(); pIsFileLayout[iNumValidFrames] = (CLR_U1) pPEAssembly->GetLoadedLayout()->IsFlat(); } @@ -707,10 +809,10 @@ FCIMPL4(void, DebugStackTrace::GetStackFramesInternal, MemoryRange range = stream->GetRawBuffer(); // Save the in-memory PDB address and size - PTR_VOID *pInMemoryPdbAddress = (PTR_VOID *)pStackFrameHelper->rgInMemoryPdbAddress->GetDataPtr(); + PTR_VOID *pInMemoryPdbAddress = (PTR_VOID *)gc.pStackFrameHelper->rgInMemoryPdbAddress->GetDataPtr(); pInMemoryPdbAddress[iNumValidFrames] = range.StartAddress(); - CLR_I4 *pInMemoryPdbSize = (CLR_I4 *)((I4ARRAYREF)pStackFrameHelper->rgiInMemoryPdbSize)->GetDirectPointerToNonObjectElements(); + CLR_I4 *pInMemoryPdbSize = (CLR_I4 *)((I4ARRAYREF)gc.pStackFrameHelper->rgiInMemoryPdbSize)->GetDirectPointerToNonObjectElements(); pInMemoryPdbSize[iNumValidFrames] = (CLR_I4)range.Size(); } else @@ -720,7 +822,7 @@ FCIMPL4(void, DebugStackTrace::GetStackFramesInternal, if (!assemblyPath.IsEmpty()) { OBJECTREF obj = (OBJECTREF)StringObject::NewString(assemblyPath.GetUnicode()); - pStackFrameHelper->rgAssemblyPath->SetAt(iNumValidFrames, obj); + gc.pStackFrameHelper->rgAssemblyPath->SetAt(iNumValidFrames, obj); } } } @@ -729,20 +831,15 @@ FCIMPL4(void, DebugStackTrace::GetStackFramesInternal, iNumValidFrames++; } - pStackFrameHelper->iFrameCount = iNumValidFrames; - } - else - { - pStackFrameHelper->iFrameCount = 0; + gc.pStackFrameHelper->iFrameCount = iNumValidFrames; } GCPROTECT_END(); - HELPER_METHOD_FRAME_END(); + END_QCALL; } -FCIMPLEND -extern MethodDesc* QCALLTYPE StackFrame_GetMethodDescFromNativeIP(LPVOID ip) +extern "C" MethodDesc* QCALLTYPE StackFrame_GetMethodDescFromNativeIP(LPVOID ip) { QCALL_CONTRACT; @@ -770,242 +867,39 @@ typedef Wrapper, HolderDestroyStrongHandle // receives a custom notification object from the target and sends it to the RS via // code:Debugger::SendCustomDebuggerNotification // Argument: dataUNSAFE - a pointer the custom notification object being sent -FCIMPL1(void, DebugDebugger::CustomNotification, Object * dataUNSAFE) +extern "C" void QCALLTYPE DebugDebugger_CustomNotification(QCall::ObjectHandleOnStack data) { - CONTRACTL - { - FCALL_CHECK; - } - CONTRACTL_END; - - OBJECTREF pData = ObjectToOBJECTREF(dataUNSAFE); + QCALL_CONTRACT; #ifdef DEBUGGING_SUPPORTED // Send notification only if the debugger is attached - if (CORDebuggerAttached() ) - { - HELPER_METHOD_FRAME_BEGIN_PROTECT(pData); - - Thread * pThread = GetThread(); - AppDomain * pAppDomain = AppDomain::GetCurrentDomain(); - - StrongHandleHolder objHandle = pAppDomain->CreateStrongHandle(pData); - MethodTable * pMT = pData->GetGCSafeMethodTable(); - Module * pModule = pMT->GetModule(); - DomainAssembly * pDomainAssembly = pModule->GetDomainAssembly(); - mdTypeDef classToken = pMT->GetCl(); - - pThread->SetThreadCurrNotification(objHandle); - g_pDebugInterface->SendCustomDebuggerNotification(pThread, pDomainAssembly, classToken); - pThread->ClearThreadCurrNotification(); - - if (pThread->IsAbortRequested()) - { - pThread->HandleThreadAbort(); - } - - HELPER_METHOD_FRAME_END(); - } - -#endif // DEBUGGING_SUPPORTED - -} -FCIMPLEND - - -void DebugStackTrace::GetStackFramesHelper(Frame *pStartFrame, - void* pStopStack, - GetStackFramesData *pData - ) -{ - CONTRACTL - { - MODE_COOPERATIVE; - GC_TRIGGERS; - THROWS; - } - CONTRACTL_END; - - ASSERT (pData != NULL); - - pData->cElements = 0; - - // if the caller specified (< 20) frames are required, then allocate - // only that many - if ((pData->NumFramesRequested > 0) && (pData->NumFramesRequested < 20)) - { - pData->cElementsAllocated = pData->NumFramesRequested; - } - else - { - pData->cElementsAllocated = 20; - } - - // Allocate memory for the initial 'n' frames - pData->pElements = new DebugStackTraceElement[pData->cElementsAllocated]; - - if (pData->TargetThread == NULL || - pData->TargetThread->GetInternal() == GetThread()) - { - // Null target thread specifies current thread. - GetThread()->StackWalkFrames(GetStackFramesCallback, pData, FUNCTIONSONLY | QUICKUNWIND, pStartFrame); - } - else - { - Thread *pThread = pData->TargetThread->GetInternal(); - _ASSERTE (pThread != NULL); - - // Here's the timeline for the TS_SyncSuspended bit. - // 0) TS_SyncSuspended is not set. - // 1) The suspending thread grabs the thread store lock - // then puts in place trip wires for the suspendee (if it is in managed code) - // and releases the thread store lock. - // 2) The suspending thread waits for the "SafeEvent". - // 3) The suspendee continues execution until it tries to enter preemptive mode. - // If it trips over the wires put in place by the suspending thread, - // it will try to enter preemptive mode. - // 4) The suspendee sets TS_SyncSuspended and the "SafeEvent". - // 5) AT THIS POINT, IT IS SAFE TO WALK THE SUSPENDEE'S STACK. - // 6) The suspendee clears the TS_SyncSuspended flag. - // - // In other words, it is safe to trace the thread's stack IF we're holding the - // thread store lock AND TS_SyncSuspended is set. - // - // This is because: - // - If we were not holding the thread store lock, the thread could be resumed - // underneath us. - // - When TS_SyncSuspended is set, we race against it resuming execution. - - ThreadStoreLockHolder tsl; - - // We erect a barrier so that if the thread tries to disable preemptive GC, - // it could resume execution of managed code during our stack walk. - TSSuspendHolder shTrap; - - Thread::ThreadState state = pThread->GetSnapshotState(); - if (state & (Thread::TS_Unstarted|Thread::TS_Dead|Thread::TS_Detached)) - { - goto LSafeToTrace; - } - - COMPlusThrow(kThreadStateException, IDS_EE_THREAD_BAD_STATE); - - LSafeToTrace: - pThread->StackWalkFrames(GetStackFramesCallback, - pData, - FUNCTIONSONLY|ALLOW_ASYNC_STACK_WALK, - pStartFrame); - } - - // Do a 2nd pass outside of any locks. - // This will compute IL offsets. - for (INT32 i = 0; i < pData->cElements; i++) - { - pData->pElements[i].InitPass2(); - } - -} - - -void DebugStackTrace::GetStackFrames(Frame *pStartFrame, - void* pStopStack, - GetStackFramesData *pData - ) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; - } - CONTRACTL_END; - - GetStackFramesHelper(pStartFrame, pStopStack, pData); -} - - -StackWalkAction DebugStackTrace::GetStackFramesCallback(CrawlFrame* pCf, VOID* data) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; - } - CONTRACTL_END; - - GetStackFramesData* pData = (GetStackFramesData*)data; - - if (pData->skip > 0) - { - pData->skip--; - return SWA_CONTINUE; - } - - // @todo: How do we know what kind of frame we have? - // Can we always assume FramedMethodFrame? - // NOT AT ALL!!!, but we can assume it's a function - // because we asked the stackwalker for it! - MethodDesc* pFunc = pCf->GetFunction(); - - if (pData->cElements >= pData->cElementsAllocated) - { - - DebugStackTraceElement* pTemp = new (nothrow) DebugStackTraceElement[2*pData->cElementsAllocated]; - - if (!pTemp) - { - return SWA_ABORT; - } - - memcpy(pTemp, pData->pElements, pData->cElementsAllocated * sizeof(DebugStackTraceElement)); - - delete [] pData->pElements; - - pData->pElements = pTemp; - pData->cElementsAllocated *= 2; - } - - PCODE ip; - DWORD dwNativeOffset; - - if (pCf->IsFrameless()) - { - // Real method with jitted code. - dwNativeOffset = pCf->GetRelOffset(); - ip = GetControlPC(pCf->GetRegisterSet()); - } - else - { - ip = (PCODE)NULL; - dwNativeOffset = 0; - } + if (!CORDebuggerAttached()) + return; - // Pass on to InitPass2 that the IP has already been adjusted (decremented by 1) - INT flags = pCf->IsIPadjusted() ? STEF_IP_ADJUSTED : 0; + BEGIN_QCALL; - pData->pElements[pData->cElements].InitPass1( - dwNativeOffset, - pFunc, - ip, - flags); + GCX_COOP(); - // We'll init the IL offsets outside the TSL lock. + Thread * pThread = GetThread(); + AppDomain * pAppDomain = AppDomain::GetCurrentDomain(); - ++pData->cElements; + StrongHandleHolder objHandle = pAppDomain->CreateStrongHandle(data.Get()); + MethodTable* pMT = data.Get()->GetGCSafeMethodTable(); + Module* pModule = pMT->GetModule(); + DomainAssembly* pDomainAssembly = pModule->GetDomainAssembly(); + mdTypeDef classToken = pMT->GetCl(); - // Since we may be asynchronously walking another thread's stack, - // check (frequently) for stack-buffer-overrun corruptions after - // any long operation - pCf->CheckGSCookies(); + pThread->SetThreadCurrNotification(objHandle); + g_pDebugInterface->SendCustomDebuggerNotification(pThread, pDomainAssembly, classToken); + pThread->ClearThreadCurrNotification(); - // check if we already have the number of frames that the user had asked for - if ((pData->NumFramesRequested != 0) && (pData->NumFramesRequested <= pData->cElements)) + if (pThread->IsAbortRequested()) { - return SWA_ABORT; + pThread->HandleThreadAbort(); } - return SWA_CONTINUE; + END_QCALL; +#endif // DEBUGGING_SUPPORTED } #endif // !DACCESS_COMPILE @@ -1057,7 +951,7 @@ void DebugStackTrace::GetStackFramesFromException(OBJECTREF * e, if (pData->cElements != 0) { // Allocate the memory to contain the data - pData->pElements = new DebugStackTraceElement[pData->cElements]; + pData->pElements = new Element[pData->cElements]; // Fill in the data for (unsigned i = 0; i < (unsigned)pData->cElements; i++) @@ -1123,7 +1017,7 @@ void DebugStackTrace::GetStackFramesFromException(OBJECTREF * e, // Init a stack-trace element. // Initialization done potentially under the TSL. -void DebugStackTrace::DebugStackTraceElement::InitPass1( +void DebugStackTrace::Element::InitPass1( DWORD dwNativeOffset, MethodDesc *pFunc, PCODE ip, @@ -1146,7 +1040,7 @@ void DebugStackTrace::DebugStackTraceElement::InitPass1( // Initialization done outside the TSL. // This may need to call locking operations that aren't safe under the TSL. -void DebugStackTrace::DebugStackTraceElement::InitPass2() +void DebugStackTrace::Element::InitPass2() { CONTRACTL { diff --git a/src/coreclr/vm/debugdebugger.h b/src/coreclr/vm/debugdebugger.h index a9ea997b7aa..bbf06268752 100644 --- a/src/coreclr/vm/debugdebugger.h +++ b/src/coreclr/vm/debugdebugger.h @@ -19,19 +19,15 @@ class DebugDebugger { public: - static FCDECL0(void, Break); static FCDECL0(FC_BOOL_RET, IsDebuggerAttached); - // receives a custom notification object from the target and sends it to the RS via - // code:Debugger::SendCustomDebuggerNotification - static FCDECL1(void, CustomNotification, Object * dataUNSAFE); - static FCDECL0(FC_BOOL_RET, IsLogging); }; +extern "C" void QCALLTYPE DebugDebugger_Break(); extern "C" BOOL QCALLTYPE DebugDebugger_Launch(); extern "C" void QCALLTYPE DebugDebugger_Log(INT32 Level, PCWSTR pwzModule, PCWSTR pwzMessage); - +extern "C" void QCALLTYPE DebugDebugger_CustomNotification(QCall::ObjectHandleOnStack data); class StackFrameHelper : public Object { @@ -39,7 +35,6 @@ class StackFrameHelper : public Object // Modifying the order or fields of this object may require other changes to the // classlib definition of the StackFrameHelper class. public: - THREADBASEREF targetThread; I4ARRAYREF rgiOffset; I4ARRAYREF rgiILOffset; PTRARRAYREF dynamicMethods; @@ -88,12 +83,7 @@ typedef StackFrameHelper* STACKFRAMEHELPERREF; class DebugStackTrace { public: - -#ifndef DACCESS_COMPILE -// the DAC directly uses the GetStackFramesData and DebugStackTraceElement types -private: -#endif // DACCESS_COMPILE - struct DebugStackTraceElement { + struct Element { DWORD dwOffset; // native offset DWORD dwILOffset; MethodDesc *pFunc; @@ -117,29 +107,25 @@ class DebugStackTrace public: - struct GetStackFramesData { - - // Used for the integer-skip version - INT32 skip; + struct GetStackFramesData + { INT32 NumFramesRequested; INT32 cElementsAllocated; INT32 cElements; - DebugStackTraceElement* pElements; + Element* pElements; THREADBASEREF TargetThread; AppDomain *pDomain; BOOL fDoWeHaveAnyFramesFromForeignStackTrace; - - GetStackFramesData() : skip(0), - NumFramesRequested (0), - cElementsAllocated(0), - cElements(0), - pElements(NULL), - TargetThread((THREADBASEREF)(TADDR)NULL) + GetStackFramesData() + : NumFramesRequested (0) + , cElementsAllocated(0) + , cElements(0) + , pElements(NULL) + , TargetThread((THREADBASEREF)(TADDR)NULL) + , fDoWeHaveAnyFramesFromForeignStackTrace(FALSE) { LIMITED_METHOD_CONTRACT; - fDoWeHaveAnyFramesFromForeignStackTrace = FALSE; - } ~GetStackFramesData() @@ -148,29 +134,14 @@ class DebugStackTrace } }; - static FCDECL4(void, - GetStackFramesInternal, - StackFrameHelper* pStackFrameHelper, - INT32 iSkip, - CLR_BOOL fNeedFileInfo, - Object* pException - ); - static void GetStackFramesFromException(OBJECTREF * e, GetStackFramesData *pData, PTRARRAYREF * pDynamicMethodArray = NULL); - -#ifndef DACCESS_COMPILE -// the DAC directly calls GetStackFramesFromException -private: -#endif - - static void GetStackFramesHelper(Frame *pStartFrame, void* pStopStack, GetStackFramesData *pData); - - static void GetStackFrames(Frame *pStartFrame, void* pStopStack, GetStackFramesData *pData); - - static StackWalkAction GetStackFramesCallback(CrawlFrame* pCf, VOID* data); - }; +extern "C" void QCALLTYPE StackTrace_GetStackFramesInternal( + QCall::ObjectHandleOnStack stackFrameHelper, + BOOL fNeedFileInfo, + QCall::ObjectHandleOnStack exception); + extern "C" MethodDesc* QCALLTYPE StackFrame_GetMethodDescFromNativeIP(LPVOID ip); #endif // __DEBUG_DEBUGGER_h__ diff --git a/src/coreclr/vm/debuginfostore.cpp b/src/coreclr/vm/debuginfostore.cpp index 8d8b05a6762..789693f33b6 100644 --- a/src/coreclr/vm/debuginfostore.cpp +++ b/src/coreclr/vm/debuginfostore.cpp @@ -985,7 +985,7 @@ BOOL DebugInfoManager::GetBoundariesAndVars( CONTRACTL { THROWS; - WRAPPER(GC_TRIGGERS); // depends on fpNew + GC_NOTRIGGER; SUPPORTS_DAC; } CONTRACTL_END; diff --git a/src/coreclr/vm/dispparammarshaler.cpp b/src/coreclr/vm/dispparammarshaler.cpp index 9286bd1ec39..5ec105ce4de 100644 --- a/src/coreclr/vm/dispparammarshaler.cpp +++ b/src/coreclr/vm/dispparammarshaler.cpp @@ -96,14 +96,7 @@ void DispParamOleColorMarshaler::MarshalNativeToManaged(VARIANT *pSrcVar, OBJECT OLE_COLOR OleColor = bByref ? *V_UI4REF(pSrcVar) : V_UI4(pSrcVar); // Convert the OLECOLOR to a System.Drawing.Color. - SYSTEMCOLOR MngColor; - ConvertOleColorToSystemColor(OleColor, &MngColor); - - // Box the System.Drawing.Color value class and give back the boxed object. - TypeHandle hndColorType = - AppDomain::GetCurrentDomain()->GetLoaderAllocator()->GetMarshalingData()->GetOleColorMarshalingInfo()->GetColorType(); - - *pDestObj = hndColorType.GetMethodTable()->Box(&MngColor); + ConvertOleColorToSystemColor(OleColor, pDestObj); } void DispParamOleColorMarshaler::MarshalManagedToNative(OBJECTREF *pSrcObj, VARIANT *pDestVar) @@ -354,7 +347,7 @@ void DispParamArrayMarshaler::MarshalManagedToNativeRef(OBJECTREF *pSrcObj, VARI } // Copy the converted variant back into the byref variant. - OleVariant::InsertContentsIntoByrefVariant(&vtmp, pRefVar); + OleVariant::InsertContentsIntoByRefVariant(&vtmp, pRefVar); } void DispParamRecordMarshaler::MarshalNativeToManaged(VARIANT *pSrcVar, OBJECTREF *pDestObj) @@ -556,7 +549,18 @@ void DispParamCustomMarshaler::MarshalNativeToManaged(VARIANT *pSrcVar, OBJECTRE IUnknown *pUnk = bByref ? *V_UNKNOWNREF(pSrcVar) : V_UNKNOWN(pSrcVar); // Marshal the contents of the VARIANT using the custom marshaler. - *pDestObj = m_pCMHelper->InvokeMarshalNativeToManagedMeth(pUnk); + OBJECTREF customMarshaler = m_pCMInfo->GetCustomMarshaler(); + GCPROTECT_BEGIN (customMarshaler); + MethodDescCallSite marshalNativeToManaged(METHOD__MNGD_REF_CUSTOM_MARSHALER__CONVERT_CONTENTS_TO_MANAGED); + + ARG_SLOT Args[] = { + ObjToArgSlot(customMarshaler), + PtrToArgSlot(pDestObj), + PtrToArgSlot(&pUnk) + }; + + marshalNativeToManaged.Call(Args); + GCPROTECT_END (); } void DispParamCustomMarshaler::MarshalManagedToNative(OBJECTREF *pSrcObj, VARIANT *pDestVar) @@ -577,7 +581,21 @@ void DispParamCustomMarshaler::MarshalManagedToNative(OBJECTREF *pSrcObj, VARIAN SafeVariantClear(pDestVar); // Invoke the MarshalManagedToNative method. - pUnk = (IUnknown*)m_pCMHelper->InvokeMarshalManagedToNativeMeth(*pSrcObj); + IUnknown* pUnkRaw = nullptr; + OBJECTREF customMarshaler = m_pCMInfo->GetCustomMarshaler(); + GCPROTECT_BEGIN (customMarshaler); + MethodDescCallSite marshalManagedToNative(METHOD__MNGD_REF_CUSTOM_MARSHALER__CONVERT_CONTENTS_TO_NATIVE); + + ARG_SLOT Args[] = { + ObjToArgSlot(customMarshaler), + PtrToArgSlot(pSrcObj), + PtrToArgSlot(&pUnkRaw) + }; + + marshalManagedToNative.Call(Args); + GCPROTECT_END(); + pUnk = pUnkRaw; + if (!pUnk) { // Put a null IDispatch pointer in the VARIANT. @@ -631,7 +649,18 @@ void DispParamCustomMarshaler::MarshalManagedToNativeRef(OBJECTREF *pSrcObj, VAR SafeVariantClear(&vtmp); // Convert the object using the custom marshaler. - V_UNKNOWN(&vtmp) = (IUnknown*)m_pCMHelper->InvokeMarshalManagedToNativeMeth(*pSrcObj); + OBJECTREF customMarshaler = m_pCMInfo->GetCustomMarshaler(); + GCPROTECT_BEGIN (customMarshaler); + MethodDescCallSite marshalManagedToNative(METHOD__MNGD_REF_CUSTOM_MARSHALER__CONVERT_CONTENTS_TO_NATIVE); + + ARG_SLOT Args[] = { + ObjToArgSlot(customMarshaler), + PtrToArgSlot(pSrcObj), + PtrToArgSlot(V_UNKNOWN(&vtmp)) + }; + + marshalManagedToNative.Call(Args); + GCPROTECT_END(); V_VT(&vtmp) = m_vt; // Call VariantChangeType if required. @@ -649,7 +678,7 @@ void DispParamCustomMarshaler::MarshalManagedToNativeRef(OBJECTREF *pSrcObj, VAR } // Copy the converted variant back into the byref variant. - OleVariant::InsertContentsIntoByrefVariant(&vtmp, pRefVar); + OleVariant::InsertContentsIntoByRefVariant(&vtmp, pRefVar); } void DispParamCustomMarshaler::CleanUpManaged(OBJECTREF *pObj) @@ -661,5 +690,19 @@ void DispParamCustomMarshaler::CleanUpManaged(OBJECTREF *pObj) MODE_COOPERATIVE; } CONTRACTL_END; - m_pCMHelper->InvokeCleanUpManagedMeth(*pObj); + + OBJECTREF customMarshaler = m_pCMInfo->GetCustomMarshaler(); + GCPROTECT_BEGIN (customMarshaler); + MethodDescCallSite clearManaged(METHOD__MNGD_REF_CUSTOM_MARSHALER__CLEAR_MANAGED); + + void* dummyNative = nullptr; + + ARG_SLOT Args[] = { + ObjToArgSlot(customMarshaler), + PtrToArgSlot(pObj), + PtrToArgSlot(&dummyNative) + }; + + clearManaged.Call(Args); + GCPROTECT_END (); } diff --git a/src/coreclr/vm/dispparammarshaler.h b/src/coreclr/vm/dispparammarshaler.h index 5bf22445dbe..51d4a359da4 100644 --- a/src/coreclr/vm/dispparammarshaler.h +++ b/src/coreclr/vm/dispparammarshaler.h @@ -196,8 +196,8 @@ class DispParamDelegateMarshaler : public DispParamMarshaler class DispParamCustomMarshaler : public DispParamMarshaler { public: - DispParamCustomMarshaler(CustomMarshalerHelper *pCMHelper, VARTYPE vt) : - m_pCMHelper(pCMHelper), + DispParamCustomMarshaler(CustomMarshalerInfo *pCMHelper, VARTYPE vt) : + m_pCMInfo(pCMHelper), m_vt(vt) { WRAPPER_NO_CONTRACT; @@ -215,8 +215,8 @@ class DispParamCustomMarshaler : public DispParamMarshaler virtual void CleanUpManaged(OBJECTREF *pObj); private: - CustomMarshalerHelper* m_pCMHelper; - VARTYPE m_vt; + CustomMarshalerInfo* m_pCMInfo; + VARTYPE m_vt; }; #endif // _DISPPARAMMARSHALER_H diff --git a/src/coreclr/vm/dllimport.cpp b/src/coreclr/vm/dllimport.cpp index d6ebd11a59c..33966400d5a 100644 --- a/src/coreclr/vm/dllimport.cpp +++ b/src/coreclr/vm/dllimport.cpp @@ -211,7 +211,7 @@ class StubState virtual void SetLastError(BOOL fSetLastError) = 0; virtual void BeginEmit(DWORD dwStubFlags) = 0; virtual void MarshalReturn(MarshalInfo* pInfo, int argOffset) = 0; - virtual void MarshalArgument(MarshalInfo* pInfo, int argOffset, UINT nativeStackOffset) = 0; + virtual void MarshalArgument(MarshalInfo* pInfo, int argOffset) = 0; virtual void MarshalLCID(int argIdx) = 0; virtual void MarshalField(MarshalInfo* pInfo, UINT32 managedOffset, UINT32 nativeOffset, FieldDesc* pFieldDesc) = 0; @@ -288,7 +288,7 @@ class ILStubState : public StubState SF_IsHRESULTSwapping(m_dwStubFlags)); } - void MarshalArgument(MarshalInfo* pInfo, int argOffset, UINT nativeStackOffset) + void MarshalArgument(MarshalInfo* pInfo, int argOffset) { CONTRACTL { @@ -297,7 +297,7 @@ class ILStubState : public StubState } CONTRACTL_END; - pInfo->GenerateArgumentIL(&m_slIL, argOffset, nativeStackOffset, SF_IsForwardStub(m_dwStubFlags)); + pInfo->GenerateArgumentIL(&m_slIL, argOffset, SF_IsForwardStub(m_dwStubFlags)); } void MarshalField(MarshalInfo* pInfo, UINT32 managedOffset, UINT32 nativeOffset, FieldDesc* pFieldDesc) @@ -407,8 +407,9 @@ class ILStubState : public StubState SigBuilder sigBuilder; { + // Convert to a module independent signature SigPointer sigPtr(pStubMD->GetSig()); - sigPtr.ConvertToInternalSignature(pStubMD->GetModule(), NULL, &sigBuilder); + sigPtr.ConvertToInternalSignature(pStubMD->GetModule(), NULL, &sigBuilder, /* bSkipCustomModifier */ FALSE); } // @@ -464,6 +465,26 @@ class ILStubState : public StubState cbTempModuleIndependentSigLength); } + void ConvertMethodDescSigToModuleIndependentSig(MethodDesc* pStubMD) + { + SigBuilder sigBuilder; + _ASSERTE(pStubMD->IsNoMetadata()); + SigPointer sigPtr(pStubMD->GetSig()); + sigPtr.ConvertToInternalSignature(pStubMD->GetModule(), NULL, &sigBuilder, /* bSkipCustomModifier */ FALSE); + + // + // make a domain-local copy of the sig so that this state can outlive the + // compile time state. + // + DWORD cbNewSig = sigBuilder.GetSignatureLength(); + PVOID pNewSigBuffer = sigBuilder.GetSignature(&cbNewSig); + PCCOR_SIGNATURE pNewSig = (PCCOR_SIGNATURE)(void *)pStubMD->GetLoaderAllocator()->GetHighFrequencyHeap()->AllocMem(S_SIZE_T(cbNewSig)); + + memcpyNoGCRefs((void *)pNewSig, pNewSigBuffer, cbNewSig); + + pStubMD->AsDynamicMethodDesc()->SetStoredMethodSig(pNewSig, cbNewSig); + } + void EmitInvokeTarget(MethodDesc *pStubMD) { STANDARD_VM_CONTRACT; @@ -664,7 +685,11 @@ class ILStubState : public StubState DWORD dwMethodDescLocalNum = (DWORD)-1; // Notify the profiler of call out of the runtime - if (!SF_IsReverseCOMStub(m_dwStubFlags) && !SF_IsReverseDelegateStub(m_dwStubFlags) && !SF_IsStructMarshalStub(m_dwStubFlags) && CORProfilerTrackTransitions()) + if (CORProfilerTrackTransitions() + && !SF_SkipTransitionNotify(m_dwStubFlags) + && !SF_IsReverseCOMStub(m_dwStubFlags) + && !SF_IsReverseDelegateStub(m_dwStubFlags) + && !SF_IsStructMarshalStub(m_dwStubFlags)) { dwMethodDescLocalNum = m_slIL.EmitProfilerBeginTransitionCallback(pcsDispatch, m_dwStubFlags); _ASSERTE(dwMethodDescLocalNum != (DWORD)-1); @@ -799,8 +824,17 @@ class ILStubState : public StubState if (SF_IsReverseStub(m_dwStubFlags)) { + // If we're in a Reverse stub, the target signature we've built + // is the signature of the stub, and the current signature of the stub + // is the target signature. We need to swap them. SwapStubSignatures(pStubMD); } + else + { + // If we're not in a Reverse stub, the signatures are correct, + // but we need to convert the signature into a module-independent form. + ConvertMethodDescSigToModuleIndependentSig(pStubMD); + } ILCodeLabel* pTryBeginLabel = nullptr; ILCodeLabel* pTryEndAndCatchBeginLabel = nullptr; @@ -1103,6 +1137,7 @@ class ILStubState : public StubState LogOneFlag(dwStubFlags, NDIRECTSTUB_FL_CONVSIGASVARARG, " NDIRECTSTUB_FL_CONVSIGASVARARG\n", facility, level); LogOneFlag(dwStubFlags, NDIRECTSTUB_FL_BESTFIT, " NDIRECTSTUB_FL_BESTFIT\n", facility, level); LogOneFlag(dwStubFlags, NDIRECTSTUB_FL_THROWONUNMAPPABLECHAR, " NDIRECTSTUB_FL_THROWONUNMAPPABLECHAR\n", facility, level); + LogOneFlag(dwStubFlags, NDIRECTSTUB_FL_SKIP_TRANSITION_NOTIFY, " NDIRECTSTUB_FL_SKIP_TRANSITION_NOTIFY\n", facility, level); LogOneFlag(dwStubFlags, NDIRECTSTUB_FL_DELEGATE, " NDIRECTSTUB_FL_DELEGATE\n", facility, level); LogOneFlag(dwStubFlags, NDIRECTSTUB_FL_DOHRESULTSWAPPING, " NDIRECTSTUB_FL_DOHRESULTSWAPPING\n", facility, level); LogOneFlag(dwStubFlags, NDIRECTSTUB_FL_REVERSE_INTEROP, " NDIRECTSTUB_FL_REVERSE_INTEROP\n", facility, level); @@ -1127,6 +1162,7 @@ class ILStubState : public StubState NDIRECTSTUB_FL_CONVSIGASVARARG | NDIRECTSTUB_FL_BESTFIT | NDIRECTSTUB_FL_THROWONUNMAPPABLECHAR | + NDIRECTSTUB_FL_SKIP_TRANSITION_NOTIFY | NDIRECTSTUB_FL_DELEGATE | NDIRECTSTUB_FL_DOHRESULTSWAPPING | NDIRECTSTUB_FL_REVERSE_INTEROP | @@ -1583,7 +1619,6 @@ NDirectStubLinker::NDirectStubLinker( m_fHasExceptionCleanupCode(FALSE), m_fCleanupWorkListIsSetup(FALSE), m_targetHasThis((dwStubFlags & NDIRECTSTUB_FL_TARGET_HAS_THIS) != 0), - m_dwThreadLocalNum(-1), m_dwCleanupWorkListLocalNum(-1), m_dwRetValLocalNum(-1), m_ErrorResID(-1), @@ -1620,10 +1655,6 @@ NDirectStubLinker::NDirectStubLinker( m_pcsSetup->EmitSTLOC(m_dwTargetInterfacePointerLocalNum); } #endif // FEATURE_COMINTEROP - -#if defined(TARGET_X86) && defined(FEATURE_IJW) - m_dwCopyCtorChainLocalNum = (DWORD)-1; -#endif // defined(TARGET_X86) && defined(FEATURE_IJW) } void NDirectStubLinker::SetCallingConvention(CorInfoCallConvExtension unmngCallConv, BOOL fIsVarArg) @@ -1815,44 +1846,12 @@ DWORD NDirectStubLinker::GetCleanupWorkListLocalNum() return m_dwCleanupWorkListLocalNum; } -DWORD NDirectStubLinker::GetThreadLocalNum() -{ - STANDARD_VM_CONTRACT; - - if (m_dwThreadLocalNum == (DWORD)-1) - { - // The local is created and initialized lazily when first asked. - m_dwThreadLocalNum = NewLocal(ELEMENT_TYPE_I); - m_pcsSetup->EmitCALL(METHOD__THREAD__INTERNAL_GET_CURRENT_THREAD, 0, 1); - m_pcsSetup->EmitSTLOC(m_dwThreadLocalNum); - } - - return m_dwThreadLocalNum; -} - DWORD NDirectStubLinker::GetReturnValueLocalNum() { LIMITED_METHOD_CONTRACT; return m_dwRetValLocalNum; } -#if defined(TARGET_X86) && defined(FEATURE_IJW) -DWORD NDirectStubLinker::GetCopyCtorChainLocalNum() -{ - STANDARD_VM_CONTRACT; - - if (m_dwCopyCtorChainLocalNum == (DWORD)-1) - { - // The local is created and initialized lazily when first asked. - m_dwCopyCtorChainLocalNum = NewLocal(CoreLibBinder::GetClass(CLASS__COPY_CONSTRUCTOR_CHAIN)); - m_pcsSetup->EmitLDLOCA(m_dwCopyCtorChainLocalNum); - m_pcsSetup->EmitINITOBJ(m_pcsSetup->GetToken(CoreLibBinder::GetClass(CLASS__COPY_CONSTRUCTOR_CHAIN))); - } - - return m_dwCopyCtorChainLocalNum; -} -#endif // defined(TARGET_X86) && defined(FEATURE_IJW) - BOOL NDirectStubLinker::IsCleanupNeeded() { LIMITED_METHOD_CONTRACT; @@ -2082,10 +2081,6 @@ void NDirectStubLinker::End(DWORD dwStubFlags) } } -#if defined(TARGET_X86) && defined(TARGET_WINDOWS) -EXTERN_C void STDCALL CopyConstructorCallStub(void); -#endif // defined(TARGET_X86) && defined(TARGET_WINDOWS) - void NDirectStubLinker::DoNDirect(ILCodeStream *pcsEmit, DWORD dwStubFlags, MethodDesc * pStubMD) { STANDARD_VM_CONTRACT; @@ -2169,21 +2164,6 @@ void NDirectStubLinker::DoNDirect(ILCodeStream *pcsEmit, DWORD dwStubFlags, Meth } } -#if defined(TARGET_X86) && defined(FEATURE_IJW) - if (m_dwCopyCtorChainLocalNum != (DWORD)-1) - { - // If we have a copy constructor chain local, we need to call the copy constructor stub - // to ensure that the chain is called correctly. - // Let's install the stub chain here and redirect the call to the stub. - DWORD targetLoc = NewLocal(ELEMENT_TYPE_I); - pcsEmit->EmitSTLOC(targetLoc); - pcsEmit->EmitLDLOCA(m_dwCopyCtorChainLocalNum); - pcsEmit->EmitLDLOC(targetLoc); - pcsEmit->EmitCALL(METHOD__COPY_CONSTRUCTOR_CHAIN__INSTALL, 2, 0); - pcsEmit->EmitLDC((DWORD_PTR)&CopyConstructorCallStub); - } -#endif // defined(TARGET_X86) && defined(FEATURE_IJW) - // For managed-to-native calls, the rest of the work is done by the JIT. It will // erect InlinedCallFrame, flip GC mode, and use the specified calling convention // to call the target. For native-to-managed calls, this is an ordinary managed @@ -2252,31 +2232,25 @@ DWORD NDirectStubLinker::EmitProfilerBeginTransitionCallback(ILCodeStream* pcsEm { STANDARD_VM_CONTRACT; - if (SF_IsForwardDelegateStub(dwStubFlags) || SF_IsCALLIStub(dwStubFlags)) - { - // secret argument does not contain MD nor UMEntryThunk - pcsEmit->EmitLoadNullPtr(); - } - else + if (!SF_IsForwardDelegateStub(dwStubFlags) && !SF_IsCALLIStub(dwStubFlags)) { + // COM interop or the pinvoke case, should have a non-null 'secret argument'. EmitLoadStubContext(pcsEmit, dwStubFlags); } - - pcsEmit->EmitLDLOC(GetThreadLocalNum()); - - // In the unmanaged delegate case, we need the "this" object to retrieve the MD - // in StubHelpers::ProfilerEnterCallback(). - if (SF_IsDelegateStub(dwStubFlags)) + else if (SF_IsDelegateStub(dwStubFlags)) { + // In the unmanaged delegate case, we use the "this" object to retrieve the MD _ASSERTE(SF_IsForwardStub(dwStubFlags)); pcsEmit->EmitLoadThis(); + pcsEmit->EmitCALL(METHOD__DELEGATE__GET_INVOKE_METHOD, 1, 1); } else { - pcsEmit->EmitLDNULL(); + // It is the calli pinvoke case, so pass null. + pcsEmit->EmitLoadNullPtr(); } - pcsEmit->EmitCALL(METHOD__STUBHELPERS__PROFILER_BEGIN_TRANSITION_CALLBACK, 3, 1); + pcsEmit->EmitCALL(METHOD__STUBHELPERS__PROFILER_BEGIN_TRANSITION_CALLBACK, 1, 1); // Store the MD for StubHelpers::ProfilerLeaveCallback(). DWORD dwMethodDescLocalNum = pcsEmit->NewLocal(ELEMENT_TYPE_I); @@ -2290,8 +2264,7 @@ void NDirectStubLinker::EmitProfilerEndTransitionCallback(ILCodeStream* pcsEmit, pcsEmit->EmitLDLOC(dwMethodDescLocalNum); _ASSERTE(SF_IsForwardStub(dwStubFlags)); - pcsEmit->EmitLDLOC(GetThreadLocalNum()); - pcsEmit->EmitCALL(METHOD__STUBHELPERS__PROFILER_END_TRANSITION_CALLBACK, 2, 0); + pcsEmit->EmitCALL(METHOD__STUBHELPERS__PROFILER_END_TRANSITION_CALLBACK, 1, 0); } #endif // PROFILING_SUPPPORTED @@ -2304,30 +2277,28 @@ void NDirectStubLinker::EmitValidateLocal(ILCodeStream* pcsEmit, DWORD dwLocalNu if (SF_IsDelegateStub(dwStubFlags)) { - pcsEmit->EmitLoadNullPtr(); pcsEmit->EmitLoadThis(); + pcsEmit->EmitCALL(METHOD__DELEGATE__GET_INVOKE_METHOD, 1, 1); } else if (SF_IsCALLIStub(dwStubFlags)) { pcsEmit->EmitLoadNullPtr(); - pcsEmit->EmitLDNULL(); } else { // P/Invoke, CLR->COM EmitLoadStubContext(pcsEmit, dwStubFlags); - pcsEmit->EmitLDNULL(); } if (fIsByref) { - // StubHelpers.ValidateByref(byref, pMD, pThis) - pcsEmit->EmitCALL(METHOD__STUBHELPERS__VALIDATE_BYREF, 3, 0); + // StubHelpers.ValidateByref(byref, pMD) + pcsEmit->EmitCALL(METHOD__STUBHELPERS__VALIDATE_BYREF, 2, 0); } else { - // StubHelpers.ValidateObject(obj, pMD, pThis) - pcsEmit->EmitCALL(METHOD__STUBHELPERS__VALIDATE_OBJECT, 3, 0); + // StubHelpers.ValidateObject(obj, pMD) + pcsEmit->EmitCALL(METHOD__STUBHELPERS__VALIDATE_OBJECT, 2, 0); } } @@ -2415,7 +2386,7 @@ class DispatchStubState : public StubState // For CLR-to-COM late-bound/eventing CONTRACTL_END; } - void MarshalArgument(MarshalInfo* pInfo, int argOffset, UINT nativeStackOffset) + void MarshalArgument(MarshalInfo* pInfo, int argOffset) { CONTRACTL { @@ -3457,7 +3428,6 @@ static MarshalInfo::MarshalType DoMarshalReturnValue(MetaSig& msig, int argOffset, DWORD dwStubFlags, MethodDesc *pMD, - UINT& nativeStackOffset, bool& fStubNeedsCOM, int nativeArgIndex DEBUG_ARG(LPCUTF8 pDebugName) @@ -3580,19 +3550,6 @@ static MarshalInfo::MarshalType DoMarshalReturnValue(MetaSig& msig, return marshalType; } -static inline UINT GetStackOffsetFromStackSize(UINT stackSize, bool fThisCall) -{ - LIMITED_METHOD_CONTRACT; -#ifdef TARGET_X86 - if (fThisCall) - { - // -1 means that the argument is not on the stack - return (stackSize >= TARGET_POINTER_SIZE ? (stackSize - TARGET_POINTER_SIZE) : (UINT)-1); - } -#endif // TARGET_X86 - return stackSize; -} - //--------------------------------------------------------- // Creates a new stub for a N/Direct call. Return refcount is 1. // Note that this function may now throw if it fails to create @@ -3782,7 +3739,7 @@ static void CreateNDirectStubWorker(StubState* pss, MarshalInfo &info = pParamMarshalInfo[argidx - 1]; - pss->MarshalArgument(&info, argOffset, GetStackOffsetFromStackSize(nativeStackSize, fThisCall)); + pss->MarshalArgument(&info, argOffset); nativeStackSize += info.GetNativeArgSize(); fStubNeedsCOM |= info.MarshalerRequiresCOM(); @@ -3818,7 +3775,6 @@ static void CreateNDirectStubWorker(StubState* pss, argOffset, dwStubFlags, pMD, - nativeStackSize, fStubNeedsCOM, nativeArgIndex DEBUG_ARG(pSigDesc->m_pDebugName) @@ -4078,8 +4034,9 @@ namespace // note that ConvertToInternalSignature also resolves generics so different instantiations will get different // hash blobs for methods that have generic parameters in their signature + // The signature may have custom modifiers that influence behavior, so don't skip them SigBuilder sigBuilder; - sigPtr.ConvertToInternalSignature(pParams->m_pModule, pParams->m_pTypeContext, &sigBuilder, /* bSkipCustomModifier = */ FALSE); + sigPtr.ConvertToInternalSignature(pParams->m_pModule, pParams->m_pTypeContext, &sigBuilder, /* bSkipCustomModifier */ FALSE); DWORD cbSig; PVOID pSig = sigBuilder.GetSignature(&cbSig); @@ -4342,6 +4299,11 @@ static void CreateNDirectStubAccessMetadata( lcidArg = GetLCIDParameterIndex(pMD); if (lcidArg != -1 && lcidArg > (*pNumArgs)) COMPlusThrow(kIndexOutOfRangeException, IDS_EE_INVALIDLCIDPARAM); + + // Do not notify the profiler about QCalls + // See ProfilerManagedToUnmanagedTransitionMD() + if (pMD->IsQCall()) + *pdwStubFlags |= NDIRECTSTUB_FL_SKIP_TRANSITION_NOTIFY; } (*piLCIDArg) = lcidArg; @@ -5457,30 +5419,30 @@ MethodDesc* NDirect::CreateCLRToNativeILStub(PInvokeStaticSigInfo* pSigInfo, pSigInfo->GetStubFlags() | dwStubFlags); } -MethodDesc* NDirect::GetILStubMethodDesc(NDirectMethodDesc* pNMD, PInvokeStaticSigInfo* pSigInfo, DWORD dwStubFlags) +namespace { - CONTRACTL + MethodDesc* GetILStubMethodDesc(NDirectMethodDesc* pNMD, PInvokeStaticSigInfo* pSigInfo, DWORD dwStubFlags) { - STANDARD_VM_CHECK; - PRECONDITION(pNMD != NULL); - } - CONTRACTL_END; + CONTRACTL + { + STANDARD_VM_CHECK; + PRECONDITION(pNMD != NULL); + } + CONTRACTL_END; - MethodDesc* pStubMD = NULL; + MethodDesc* pStubMD = NULL; - if (!pNMD->IsVarArgs() || SF_IsForNumParamBytes(dwStubFlags)) - { - pStubMD = CreateCLRToNativeILStub( - pSigInfo, - dwStubFlags & ~NDIRECTSTUB_FL_FOR_NUMPARAMBYTES, - pNMD); - } + if (!pNMD->IsVarArgs() || SF_IsForNumParamBytes(dwStubFlags)) + { + pStubMD = NDirect::CreateCLRToNativeILStub( + pSigInfo, + dwStubFlags & ~NDIRECTSTUB_FL_FOR_NUMPARAMBYTES, + pNMD); + } - return pStubMD; -} + return pStubMD; + } -namespace -{ LPVOID NDirectGetEntryPoint(NDirectMethodDesc *pMD, NATIVE_LIBRARY_HANDLE hMod) { // GetProcAddress cannot be called while preemptive GC is disabled. @@ -5597,7 +5559,7 @@ PCODE NDirect::GetStubForILStub(NDirectMethodDesc* pNMD, MethodDesc** ppStubMD, PInvokeStaticSigInfo sigInfo; NDirect::InitializeSigInfoAndPopulateNDirectMethodDesc(pNMD, &sigInfo); - *ppStubMD = NDirect::GetILStubMethodDesc(pNMD, &sigInfo, dwStubFlags); + *ppStubMD = GetILStubMethodDesc(pNMD, &sigInfo, dwStubFlags); if (SF_IsForNumParamBytes(dwStubFlags)) return (PCODE)NULL; @@ -6113,21 +6075,415 @@ PCODE GetILStubForCalli(VASigCookie *pVASigCookie, MethodDesc *pMD) RETURN pVASigCookie->pNDirectILStub; } -#if defined(TARGET_X86) && defined(FEATURE_IJW) -// Copy constructor support for C++/CLI -EXTERN_C void* STDCALL CallCopyConstructorsWorker(void* esp) +namespace { - STATIC_CONTRACT_THROWS; - STATIC_CONTRACT_GC_TRIGGERS; - STATIC_CONTRACT_MODE_PREEMPTIVE; // we've already switched to preemptive + //------------------------------------------------------------------------------------- + // Return the copy ctor for a VC class (if any exists) + //------------------------------------------------------------------------------------- + void FindCopyConstructor(Module *pModule, MethodTable *pMT, MethodDesc **pMDOut) + { + CONTRACTL + { + THROWS; + GC_TRIGGERS; // CompareTypeTokens may trigger GC + MODE_ANY; + } + CONTRACTL_END; + + *pMDOut = NULL; + + HRESULT hr; + mdMethodDef tk; + mdTypeDef cl = pMT->GetCl(); + TypeHandle th = TypeHandle(pMT); + SigTypeContext typeContext(th); - using ExecuteCallback = void*(STDMETHODCALLTYPE*)(void*); + IMDInternalImport *pInternalImport = pModule->GetMDImport(); + MDEnumHolder hEnumMethod(pInternalImport); + + // + // First try for the new syntax: + // + IfFailThrow(pInternalImport->EnumInit(mdtMethodDef, cl, &hEnumMethod)); - MethodDesc* pMD = CoreLibBinder::GetMethod(METHOD__COPY_CONSTRUCTOR_CHAIN__EXECUTE_CURRENT_COPIES_AND_GET_TARGET); - ExecuteCallback pExecute = (ExecuteCallback)pMD->GetMultiCallableAddrOfCode(); + while (pInternalImport->EnumNext(&hEnumMethod, &tk)) + { + _ASSERTE(TypeFromToken(tk) == mdtMethodDef); + DWORD dwMemberAttrs; + IfFailThrow(pInternalImport->GetMethodDefProps(tk, &dwMemberAttrs)); + + if (IsMdSpecialName(dwMemberAttrs)) + { + ULONG cSig; + PCCOR_SIGNATURE pSig; + LPCSTR pName; + IfFailThrow(pInternalImport->GetNameAndSigOfMethodDef(tk, &pSig, &cSig, &pName)); + + const char *pBaseName = ""; + int ncBaseName = (int)strlen(pBaseName); + int nc = (int)strlen(pName); + if (nc >= ncBaseName && 0 == strcmp(pName + nc - ncBaseName, pBaseName)) + { + MetaSig msig(pSig, cSig, pModule, &typeContext); + + // Looking for the prototype void (Ptr VC, Ptr VC); + if (msig.NumFixedArgs() == 2) + { + if (msig.GetReturnType() == ELEMENT_TYPE_VOID) + { + if (msig.NextArg() == ELEMENT_TYPE_PTR) + { + SigPointer sp1 = msig.GetArgProps(); + IfFailThrow(sp1.GetElemType(NULL)); + CorElementType eType; + IfFailThrow(sp1.GetElemType(&eType)); + if (eType == ELEMENT_TYPE_VALUETYPE) + { + mdToken tk1; + IfFailThrow(sp1.GetToken(&tk1)); + hr = CompareTypeTokensNT(tk1, cl, pModule, pModule); + if (FAILED(hr)) + { + pInternalImport->EnumClose(&hEnumMethod); + ThrowHR(hr); + } + + if (hr == S_OK) + { + if (msig.NextArg() == ELEMENT_TYPE_PTR) + { + SigPointer sp2 = msig.GetArgProps(); + IfFailThrow(sp2.GetElemType(NULL)); + IfFailThrow(sp2.GetElemType(&eType)); + if (eType == ELEMENT_TYPE_VALUETYPE) + { + mdToken tk2; + IfFailThrow(sp2.GetToken(&tk2)); + + hr = (tk2 == tk1) ? S_OK : CompareTypeTokensNT(tk2, cl, pModule, pModule); + if (hr == S_OK) + { + *pMDOut = pModule->LookupMethodDef(tk); + return; + } + } + } + } + } + } + } + } + } + } + } + + // + // Next try the old syntax: global .__ctor + // + IfFailThrow(pInternalImport->EnumGlobalFunctionsInit(&hEnumMethod)); + + while (pInternalImport->EnumNext(&hEnumMethod, &tk)) + { + _ASSERTE(TypeFromToken(tk) == mdtMethodDef); + DWORD dwMemberAttrs; + IfFailThrow(pInternalImport->GetMethodDefProps(tk, &dwMemberAttrs)); + + if (IsMdSpecialName(dwMemberAttrs)) + { + ULONG cSig; + PCCOR_SIGNATURE pSig; + LPCSTR pName; + IfFailThrow(pInternalImport->GetNameAndSigOfMethodDef(tk, &pSig, &cSig, &pName)); + + const char *pBaseName = ".__ctor"; + int ncBaseName = (int)strlen(pBaseName); + int nc = (int)strlen(pName); + if (nc >= ncBaseName && 0 == strcmp(pName + nc - ncBaseName, pBaseName)) + { + + MetaSig msig(pSig, cSig, pModule, &typeContext); + + // Looking for the prototype Ptr VC __ctor(Ptr VC, ByRef VC); + if (msig.NumFixedArgs() == 2) + { + if (msig.GetReturnType() == ELEMENT_TYPE_PTR) + { + SigPointer spret = msig.GetReturnProps(); + IfFailThrow(spret.GetElemType(NULL)); + CorElementType eType; + IfFailThrow(spret.GetElemType(&eType)); + if (eType == ELEMENT_TYPE_VALUETYPE) + { + mdToken tk0; + IfFailThrow(spret.GetToken(&tk0)); + hr = CompareTypeTokensNT(tk0, cl, pModule, pModule); + if (FAILED(hr)) + { + pInternalImport->EnumClose(&hEnumMethod); + ThrowHR(hr); + } + + if (hr == S_OK) + { + if (msig.NextArg() == ELEMENT_TYPE_PTR) + { + SigPointer sp1 = msig.GetArgProps(); + IfFailThrow(sp1.GetElemType(NULL)); + IfFailThrow(sp1.GetElemType(&eType)); + if (eType == ELEMENT_TYPE_VALUETYPE) + { + mdToken tk1; + IfFailThrow(sp1.GetToken(&tk1)); + hr = (tk1 == tk0) ? S_OK : CompareTypeTokensNT(tk1, cl, pModule, pModule); + if (FAILED(hr)) + { + pInternalImport->EnumClose(&hEnumMethod); + ThrowHR(hr); + } + + if (hr == S_OK) + { + if (msig.NextArg() == ELEMENT_TYPE_PTR && + msig.GetArgProps().HasCustomModifier(pModule, "Microsoft.VisualC.IsCXXReferenceModifier", ELEMENT_TYPE_CMOD_OPT)) + { + SigPointer sp2 = msig.GetArgProps(); + IfFailThrow(sp2.GetElemType(NULL)); + IfFailThrow(sp2.GetElemType(&eType)); + if (eType == ELEMENT_TYPE_VALUETYPE) + { + mdToken tk2; + IfFailThrow(sp2.GetToken(&tk2)); + + hr = (tk2 == tk0) ? S_OK : CompareTypeTokensNT(tk2, cl, pModule, pModule); + if (hr == S_OK) + { + *pMDOut = pModule->LookupMethodDef(tk); + return; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + + + //------------------------------------------------------------------------------------- + // Return the destructor for a VC class (if any exists) + //------------------------------------------------------------------------------------- + void FindDestructor(Module *pModule, MethodTable *pMT, MethodDesc **pMDOut) + { + CONTRACTL + { + THROWS; + GC_TRIGGERS; // CompareTypeTokens may trigger GC + MODE_ANY; + } + CONTRACTL_END; + + *pMDOut = NULL; + + HRESULT hr; + mdMethodDef tk; + mdTypeDef cl = pMT->GetCl(); + TypeHandle th = TypeHandle(pMT); + SigTypeContext typeContext(th); + + IMDInternalImport *pInternalImport = pModule->GetMDImport(); + MDEnumHolder hEnumMethod(pInternalImport); + + // + // First try for the new syntax: + // + IfFailThrow(pInternalImport->EnumInit(mdtMethodDef, cl, &hEnumMethod)); + + while (pInternalImport->EnumNext(&hEnumMethod, &tk)) + { + _ASSERTE(TypeFromToken(tk) == mdtMethodDef); + DWORD dwMemberAttrs; + IfFailThrow(pInternalImport->GetMethodDefProps(tk, &dwMemberAttrs)); + + if (IsMdSpecialName(dwMemberAttrs)) + { + ULONG cSig; + PCCOR_SIGNATURE pSig; + LPCSTR pName; + IfFailThrow(pInternalImport->GetNameAndSigOfMethodDef(tk, &pSig, &cSig, &pName)); + + const char *pBaseName = ""; + int ncBaseName = (int)strlen(pBaseName); + int nc = (int)strlen(pName); + if (nc >= ncBaseName && 0 == strcmp(pName + nc - ncBaseName, pBaseName)) + { + MetaSig msig(pSig, cSig, pModule, &typeContext); + + // Looking for the prototype void (Ptr VC); + if (msig.NumFixedArgs() == 1) + { + if (msig.GetReturnType() == ELEMENT_TYPE_VOID) + { + if (msig.NextArg() == ELEMENT_TYPE_PTR) + { + SigPointer sp1 = msig.GetArgProps(); + IfFailThrow(sp1.GetElemType(NULL)); + CorElementType eType; + IfFailThrow(sp1.GetElemType(&eType)); + if (eType == ELEMENT_TYPE_VALUETYPE) + { + mdToken tk1; + IfFailThrow(sp1.GetToken(&tk1)); + + hr = CompareTypeTokensNT(tk1, cl, pModule, pModule); + IfFailThrow(hr); + + if (hr == S_OK) + { + *pMDOut = pModule->LookupMethodDef(tk); + return; + } + } + } + } + } + } + } + } + + + // + // Next try the old syntax: global .__dtor + // + IfFailThrow(pInternalImport->EnumGlobalFunctionsInit(&hEnumMethod)); + + while (pInternalImport->EnumNext(&hEnumMethod, &tk)) + { + _ASSERTE(TypeFromToken(tk) == mdtMethodDef); + ULONG cSig; + PCCOR_SIGNATURE pSig; + LPCSTR pName; + IfFailThrow(pInternalImport->GetNameAndSigOfMethodDef(tk, &pSig, &cSig, &pName)); + + const char *pBaseName = ".__dtor"; + int ncBaseName = (int)strlen(pBaseName); + int nc = (int)strlen(pName); + if (nc >= ncBaseName && 0 == strcmp(pName + nc - ncBaseName, pBaseName)) + { + MetaSig msig(pSig, cSig, pModule, &typeContext); + + // Looking for the prototype void __dtor(Ptr VC); + if (msig.NumFixedArgs() == 1) + { + if (msig.GetReturnType() == ELEMENT_TYPE_VOID) + { + if (msig.NextArg() == ELEMENT_TYPE_PTR) + { + SigPointer sp1 = msig.GetArgProps(); + IfFailThrow(sp1.GetElemType(NULL)); + CorElementType eType; + IfFailThrow(sp1.GetElemType(&eType)); + if (eType == ELEMENT_TYPE_VALUETYPE) + { + mdToken tk1; + IfFailThrow(sp1.GetToken(&tk1)); + hr = CompareTypeTokensNT(tk1, cl, pModule, pModule); + if (FAILED(hr)) + { + pInternalImport->EnumClose(&hEnumMethod); + ThrowHR(hr); + } + + if (hr == S_OK) + { + *pMDOut = pModule->LookupMethodDef(tk); + return; + } + } + } + } + } + } + } + } +} + +bool GenerateCopyConstructorHelper(MethodDesc* ftn, TypeHandle type, DynamicResolver** ppResolver, COR_ILMETHOD_DECODER** ppHeader, CORINFO_METHOD_INFO* methInfo) +{ + if (!type.IsValueType()) + return false; + + MethodTable * pMT = type.AsMethodTable(); + + MethodDesc* pCopyCtor = nullptr; + FindCopyConstructor(pMT->GetModule(), pMT, &pCopyCtor); + + MethodDesc* pDestructor = nullptr; + FindDestructor(pMT->GetModule(), pMT, &pDestructor); + + NewHolder ilResolver = new ILStubResolver(); + ilResolver->SetStubMethodDesc(ftn); + + SigTypeContext genericContext; + SigTypeContext::InitTypeContext(ftn, &genericContext); + + ILStubLinker sl( + ftn->GetModule(), + ftn->GetSignature(), + &genericContext, + ftn, + ILSTUB_LINKER_FLAG_NONE); + + ILCodeStream* pCode = sl.NewCodeStream(ILStubLinker::kDispatch); + + pCode->EmitLDARG(0); + pCode->EmitLDARG(1); + if (pCopyCtor != nullptr) + { + pCode->EmitCALL(pCode->GetToken(pCopyCtor), 2, 0); + } + else + { + pCode->EmitLDC(type.GetSize()); + pCode->EmitCPBLK(); + } + + if (pDestructor != nullptr) + { + pCode->EmitLDARG(1); + pCode->EmitCALL(pCode->GetToken(pDestructor), 1, 0); + } + + pCode->EmitRET(); + + // Generate all IL associated data for JIT + { + UINT maxStack; + size_t cbCode = sl.Link(&maxStack); + DWORD cbSig = sl.GetLocalSigSize(); + + COR_ILMETHOD_DECODER* pILHeader = ilResolver->AllocGeneratedIL(cbCode, cbSig, maxStack); + BYTE* pbBuffer = (BYTE*)pILHeader->Code; + BYTE* pbLocalSig = (BYTE*)pILHeader->LocalVarSig; + _ASSERTE(cbSig == pILHeader->cbLocalVarSig); + sl.GenerateCode(pbBuffer, cbCode); + sl.GetLocalSig(pbLocalSig, cbSig); + + // Store the token lookup map + ilResolver->SetTokenLookupMap(sl.GetTokenLookupMap()); + ilResolver->SetJitFlags(CORJIT_FLAGS(CORJIT_FLAGS::CORJIT_FLAG_IL_STUB)); + + *ppResolver = (DynamicResolver*)ilResolver; + *ppHeader = pILHeader; + } - return pExecute(esp); + ilResolver.SuppressRelease(); + return true; } -#endif // defined(TARGET_X86) && defined(FEATURE_IJW) #endif // #ifndef DACCESS_COMPILE diff --git a/src/coreclr/vm/dllimport.h b/src/coreclr/vm/dllimport.h index f5e2c058fb1..5a43d1f8fbf 100644 --- a/src/coreclr/vm/dllimport.h +++ b/src/coreclr/vm/dllimport.h @@ -133,7 +133,6 @@ class NDirect DWORD dwStubFlags, MethodDesc* pMD); - static MethodDesc* GetILStubMethodDesc(NDirectMethodDesc* pNMD, PInvokeStaticSigInfo* pSigInfo, DWORD dwStubFlags); static PCODE GetStubForILStub(NDirectMethodDesc* pNMD, MethodDesc** ppStubMD, DWORD dwStubFlags); static PCODE GetStubForILStub(MethodDesc* pMD, MethodDesc** ppStubMD, DWORD dwStubFlags); @@ -149,7 +148,7 @@ enum NDirectStubFlags NDIRECTSTUB_FL_CONVSIGASVARARG = 0x00000001, NDIRECTSTUB_FL_BESTFIT = 0x00000002, NDIRECTSTUB_FL_THROWONUNMAPPABLECHAR = 0x00000004, - // unused = 0x00000008, + NDIRECTSTUB_FL_SKIP_TRANSITION_NOTIFY = 0x00000008, NDIRECTSTUB_FL_DELEGATE = 0x00000010, NDIRECTSTUB_FL_DOHRESULTSWAPPING = 0x00000020, NDIRECTSTUB_FL_REVERSE_INTEROP = 0x00000040, @@ -214,6 +213,7 @@ enum ILStubTypes inline bool SF_IsVarArgStub (DWORD dwStubFlags) { LIMITED_METHOD_CONTRACT; return (dwStubFlags < NDIRECTSTUB_FL_INVALID && 0 != (dwStubFlags & NDIRECTSTUB_FL_CONVSIGASVARARG)); } inline bool SF_IsBestFit (DWORD dwStubFlags) { LIMITED_METHOD_CONTRACT; return (dwStubFlags < NDIRECTSTUB_FL_INVALID && 0 != (dwStubFlags & NDIRECTSTUB_FL_BESTFIT)); } inline bool SF_IsThrowOnUnmappableChar (DWORD dwStubFlags) { LIMITED_METHOD_CONTRACT; return (dwStubFlags < NDIRECTSTUB_FL_INVALID && 0 != (dwStubFlags & NDIRECTSTUB_FL_THROWONUNMAPPABLECHAR)); } +inline bool SF_SkipTransitionNotify (DWORD dwStubFlags) { LIMITED_METHOD_CONTRACT; return (dwStubFlags < NDIRECTSTUB_FL_INVALID && 0 != (dwStubFlags & NDIRECTSTUB_FL_SKIP_TRANSITION_NOTIFY)); } inline bool SF_IsDelegateStub (DWORD dwStubFlags) { LIMITED_METHOD_CONTRACT; return (dwStubFlags < NDIRECTSTUB_FL_INVALID && 0 != (dwStubFlags & NDIRECTSTUB_FL_DELEGATE)); } inline bool SF_IsHRESULTSwapping (DWORD dwStubFlags) { LIMITED_METHOD_CONTRACT; return (dwStubFlags < NDIRECTSTUB_FL_INVALID && 0 != (dwStubFlags & NDIRECTSTUB_FL_DOHRESULTSWAPPING)); } inline bool SF_IsReverseStub (DWORD dwStubFlags) { LIMITED_METHOD_CONTRACT; return (dwStubFlags < NDIRECTSTUB_FL_INVALID && 0 != (dwStubFlags & NDIRECTSTUB_FL_REVERSE_INTEROP)); } @@ -486,11 +486,7 @@ class NDirectStubLinker : public ILStubLinker void EmitLoadRCWThis(ILCodeStream *pcsEmit, DWORD dwStubFlags); #endif // FEATURE_COMINTEROP DWORD GetCleanupWorkListLocalNum(); - DWORD GetThreadLocalNum(); DWORD GetReturnValueLocalNum(); -#if defined(TARGET_X86) && defined(FEATURE_IJW) - DWORD GetCopyCtorChainLocalNum(); -#endif // defined(TARGET_X86) && defined(FEATURE_IJW) void SetCleanupNeeded(); void SetExceptionCleanupNeeded(); BOOL IsCleanupWorkListSetup(); @@ -560,15 +556,10 @@ class NDirectStubLinker : public ILStubLinker DWORD m_dwTargetEntryPointLocalNum; #endif // FEATURE_COMINTEROP -#if defined(TARGET_X86) && defined(FEATURE_IJW) - DWORD m_dwCopyCtorChainLocalNum; -#endif // defined(TARGET_X86) && defined(FEATURE_IJW) - BOOL m_fHasCleanupCode; BOOL m_fHasExceptionCleanupCode; BOOL m_fCleanupWorkListIsSetup; BOOL m_targetHasThis; - DWORD m_dwThreadLocalNum; // managed-to-native only DWORD m_dwArgMarshalIndexLocalNum; DWORD m_dwCleanupWorkListLocalNum; DWORD m_dwRetValLocalNum; @@ -599,6 +590,7 @@ HRESULT FindPredefinedILStubMethod(MethodDesc *pTargetMD, DWORD dwStubFlags, Met #ifndef DACCESS_COMPILE void MarshalStructViaILStub(MethodDesc* pStubMD, void* pManagedData, void* pNativeData, StructMarshalStubs::MarshalOperation operation, void** ppCleanupWorkList = nullptr); void MarshalStructViaILStubCode(PCODE pStubCode, void* pManagedData, void* pNativeData, StructMarshalStubs::MarshalOperation operation, void** ppCleanupWorkList = nullptr); +bool GenerateCopyConstructorHelper(MethodDesc* ftn, TypeHandle type, DynamicResolver** ppResolver, COR_ILMETHOD_DECODER** ppHeader, CORINFO_METHOD_INFO* methInfo); #endif // DACCESS_COMPILE // diff --git a/src/coreclr/vm/domainassembly.cpp b/src/coreclr/vm/domainassembly.cpp index 0e66000689a..391bea7fc3b 100644 --- a/src/coreclr/vm/domainassembly.cpp +++ b/src/coreclr/vm/domainassembly.cpp @@ -24,23 +24,14 @@ #include "peimagelayout.inl" #ifndef DACCESS_COMPILE -DomainAssembly::DomainAssembly(PEAssembly* pPEAssembly, LoaderAllocator* pLoaderAllocator) : - m_pAssembly(NULL), - m_pPEAssembly(pPEAssembly), - m_pModule(NULL), - m_fCollectible(pLoaderAllocator->IsCollectible()), - m_NextDomainAssemblyInSameALC(NULL), - m_pLoaderAllocator(pLoaderAllocator), - m_level(FILE_LOAD_CREATE), - m_loading(TRUE), - m_hExposedAssemblyObject{}, - m_pError(NULL), - m_bDisableActivationCheck(FALSE), - m_fHostAssemblyPublished(FALSE), - m_pDynamicMethodTable(NULL), - m_debuggerFlags(DACF_NONE), - m_notifyflags(NOT_NOTIFIED), - m_fDebuggerUnloadStarted(FALSE) +DomainAssembly::DomainAssembly(PEAssembly* pPEAssembly, LoaderAllocator* pLoaderAllocator, AllocMemTracker* memTracker) + : m_pAssembly(NULL) + , m_pPEAssembly(pPEAssembly) + , m_pModule(NULL) + , m_fCollectible(pLoaderAllocator->IsCollectible()) + , m_NextDomainAssemblyInSameALC(NULL) + , m_pLoaderAllocator(pLoaderAllocator) + , m_debuggerFlags(DACF_NONE) { CONTRACTL { @@ -55,6 +46,17 @@ DomainAssembly::DomainAssembly(PEAssembly* pPEAssembly, LoaderAllocator* pLoader pPEAssembly->ValidateForExecution(); SetupDebuggingConfig(); + + // Create the Assembly + NewHolder assembly = Assembly::Create(pPEAssembly, GetDebuggerInfoBits(), memTracker, pLoaderAllocator); + + m_pAssembly = assembly.Extract(); + m_pModule = m_pAssembly->GetModule(); + + m_pAssembly->SetDomainAssembly(this); + + // Creating the Assembly should have ensured the PEAssembly is loaded + _ASSERT(GetPEAssembly()->IsLoaded()); } DomainAssembly::~DomainAssembly() @@ -69,16 +71,6 @@ DomainAssembly::~DomainAssembly() CONTRACTL_END; m_pPEAssembly->Release(); - if (m_pDynamicMethodTable) - m_pDynamicMethodTable->Destroy(); - - delete m_pError; - - if (m_fHostAssemblyPublished) - { - // Remove association first. - UnregisterFromHostAssembly(); - } if (m_pAssembly != NULL) { @@ -88,7 +80,7 @@ DomainAssembly::~DomainAssembly() // Optimization intended for EnsureLoadLevel only #include -void DomainAssembly::EnsureLoadLevel(FileLoadLevel targetLevel) +void Assembly::EnsureLoadLevel(FileLoadLevel targetLevel) { CONTRACT_VOID { @@ -101,7 +93,7 @@ void DomainAssembly::EnsureLoadLevel(FileLoadLevel targetLevel) TRIGGERSGC (); if (IsLoading()) { - AppDomain::GetCurrentDomain()->LoadDomainAssembly(this, targetLevel); + AppDomain::GetCurrentDomain()->LoadAssembly(this, targetLevel); // Enforce the loading requirement. Note that we may have a deadlock in which case we // may be off by one which is OK. (At this point if we are short of targetLevel we know @@ -116,7 +108,7 @@ void DomainAssembly::EnsureLoadLevel(FileLoadLevel targetLevel) } #include -CHECK DomainAssembly::CheckLoadLevel(FileLoadLevel requiredLevel, BOOL deadlockOK) +CHECK Assembly::CheckLoadLevel(FileLoadLevel requiredLevel, BOOL deadlockOK) { CONTRACTL { @@ -146,7 +138,7 @@ CHECK DomainAssembly::CheckLoadLevel(FileLoadLevel requiredLevel, BOOL deadlockO -void DomainAssembly::RequireLoadLevel(FileLoadLevel targetLevel) +void Assembly::RequireLoadLevel(FileLoadLevel targetLevel) { CONTRACT_VOID { @@ -166,7 +158,7 @@ void DomainAssembly::RequireLoadLevel(FileLoadLevel targetLevel) } -void DomainAssembly::SetError(Exception *ex) +void Assembly::SetError(Exception *ex) { CONTRACT_VOID { @@ -179,7 +171,7 @@ void DomainAssembly::SetError(Exception *ex) } CONTRACT_END; - m_pError = new ExInfo(ex->DomainBoundClone()); + m_pError = ex->DomainBoundClone(); if (m_pModule) { @@ -200,7 +192,7 @@ void DomainAssembly::SetError(Exception *ex) RETURN; } -void DomainAssembly::ThrowIfError(FileLoadLevel targetLevel) +void Assembly::ThrowIfError(FileLoadLevel targetLevel) { CONTRACT_VOID { @@ -211,16 +203,15 @@ void DomainAssembly::ThrowIfError(FileLoadLevel targetLevel) } CONTRACT_END; - if (m_level < targetLevel) + if (m_level < targetLevel && m_pError != NULL) { - if (m_pError) - m_pError->Throw(); + PAL_CPP_THROW(Exception*, m_pError->DomainBoundClone()); } RETURN; } -CHECK DomainAssembly::CheckNoError(FileLoadLevel targetLevel) +CHECK Assembly::CheckNoError(FileLoadLevel targetLevel) { LIMITED_METHOD_CONTRACT; CHECK(m_level >= targetLevel @@ -229,7 +220,7 @@ CHECK DomainAssembly::CheckNoError(FileLoadLevel targetLevel) CHECK_OK; } -CHECK DomainAssembly::CheckLoaded() +CHECK Assembly::CheckActivated() { CONTRACTL { @@ -240,35 +231,7 @@ CHECK DomainAssembly::CheckLoaded() } CONTRACTL_END; - CHECK_MSG(CheckNoError(FILE_LOADED), "DomainAssembly load resulted in an error"); - - if (IsLoaded()) - CHECK_OK; - - // CoreLib is allowed to run managed code much earlier than other - // assemblies for bootstrapping purposes. This is because it has no - // dependencies, security checks, and doesn't rely on loader notifications. - - if (GetPEAssembly()->IsSystem()) - CHECK_OK; - - CHECK_MSG(GetPEAssembly()->IsLoaded(), "PEAssembly has not been loaded"); - - CHECK_OK; -} - -CHECK DomainAssembly::CheckActivated() -{ - CONTRACTL - { - INSTANCE_CHECK; - NOTHROW; - GC_NOTRIGGER; - MODE_ANY; - } - CONTRACTL_END; - - CHECK_MSG(CheckNoError(FILE_ACTIVE), "DomainAssembly load resulted in an error"); + CHECK_MSG(CheckNoError(FILE_ACTIVE), "Assembly load resulted in an error"); if (IsActive()) CHECK_OK; @@ -281,54 +244,32 @@ CHECK DomainAssembly::CheckActivated() CHECK_OK; CHECK_MSG(GetPEAssembly()->IsLoaded(), "PEAssembly has not been loaded"); - CHECK_MSG(IsLoaded(), "DomainAssembly has not been fully loaded"); + CHECK_MSG(IsLoaded(), "Assembly has not been fully loaded"); +#ifdef _DEBUG CHECK_MSG(m_bDisableActivationCheck || CheckLoadLevel(FILE_ACTIVE), "File has not had execution verified"); - +#endif CHECK_OK; } #endif //!DACCESS_COMPILE -// Return true iff the debugger should get notifications about this assembly. -// -// Notes: -// The debuggee may be stopped while a DomainAssmebly is being initialized. In this time window, -// GetAssembly() may be NULL. If that's the case, this function has to return FALSE. Later on, when -// the DomainAssembly is fully initialized, this function will return TRUE. This is the only scenario -// where this function is mutable. In other words, a DomainAssembly can only change from being invisible -// to visible, but NOT vice versa. Once a DomainAssmebly is fully initialized, this function should be -// immutable for an instance of a module. That ensures that the debugger gets consistent -// notifications about it. It this value mutates, than the debugger may miss relevant notifications. -BOOL DomainAssembly::IsVisibleToDebugger() -{ - WRAPPER_NO_CONTRACT; - SUPPORTS_DAC; - - return (GetAssembly() != NULL); -} - #ifndef DACCESS_COMPILE -BOOL DomainAssembly::DoIncrementalLoad(FileLoadLevel level) +BOOL Assembly::DoIncrementalLoad(FileLoadLevel level) { STANDARD_VM_CONTRACT; if (IsError()) return FALSE; - Thread *pThread = GetThread(); switch (level) { case FILE_LOAD_BEGIN: Begin(); break; - case FILE_LOAD_ALLOCATE: - Allocate(); - break; - - case FILE_LOAD_POST_ALLOCATE: - PostAllocate(); + case FILE_LOAD_BEFORE_TYPE_LOAD: + BeforeTypeLoad(); break; case FILE_LOAD_EAGER_FIXUPS: @@ -369,7 +310,7 @@ BOOL DomainAssembly::DoIncrementalLoad(FileLoadLevel level) return TRUE; } -void DomainAssembly::PostAllocate() +void Assembly::BeforeTypeLoad() { CONTRACTL { @@ -405,7 +346,7 @@ void DomainAssembly::PostAllocate() #endif } -void DomainAssembly::EagerFixups() +void Assembly::EagerFixups() { WRAPPER_NO_CONTRACT; @@ -418,14 +359,14 @@ void DomainAssembly::EagerFixups() #endif // FEATURE_READYTORUN } -void DomainAssembly::VtableFixups() +void Assembly::VtableFixups() { WRAPPER_NO_CONTRACT; GetModule()->FixupVTables(); } -void DomainAssembly::FinishLoad() +void Assembly::FinishLoad() { CONTRACTL { @@ -441,7 +382,7 @@ void DomainAssembly::FinishLoad() DACNotify::DoModuleLoadNotification(m_pModule); } -void DomainAssembly::Activate() +void Assembly::Activate() { CONTRACT_VOID { @@ -454,7 +395,6 @@ void DomainAssembly::Activate() // We cannot execute any code in this assembly until we know what exception plan it is on. // At the point of an exception's stack-crawl it is too late because we cannot tolerate a GC. // See PossiblyUnwrapThrowable and its callers. - _ASSERTE(GetModule() == GetAssembly()->GetModule()); GetModule()->IsRuntimeWrapExceptions(); // @@ -466,7 +406,9 @@ void DomainAssembly::Activate() if (pMT != NULL) { pMT->CheckRestore(); +#ifdef _DEBUG m_bDisableActivationCheck=TRUE; +#endif pMT->CheckRunClassInitThrowing(); } #ifdef _DEBUG @@ -486,115 +428,19 @@ void DomainAssembly::Activate() RETURN; } -void DomainAssembly::SetAssembly(Assembly* pAssembly) -{ - STANDARD_VM_CONTRACT; - - _ASSERTE(pAssembly->GetModule()->GetPEAssembly()==m_pPEAssembly); - _ASSERTE(m_pAssembly == NULL); - - m_pAssembly = pAssembly; - m_pModule = pAssembly->GetModule(); - - pAssembly->SetDomainAssembly(this); -} - - -//--------------------------------------------------------------------------------------- -// -// Returns managed representation of the assembly (Assembly or AssemblyBuilder). -// Returns NULL if the managed scout was already collected (see code:LoaderAllocator#AssemblyPhases). -// -OBJECTREF DomainAssembly::GetExposedAssemblyObject() -{ - CONTRACTL - { - INSTANCE_CHECK; - THROWS; - MODE_COOPERATIVE; - GC_TRIGGERS; - } - CONTRACTL_END; - - LoaderAllocator * pLoaderAllocator = GetLoaderAllocator(); - - if (!pLoaderAllocator->IsManagedScoutAlive()) - { // We already collected the managed scout, so we cannot re-create any managed objects - // Note: This is an optimization, as the managed scout can be collected right after this check - return NULL; - } - - if (m_hExposedAssemblyObject == (LOADERHANDLE)NULL) - { - // Atomically create a handle - - LOADERHANDLE handle = pLoaderAllocator->AllocateHandle(NULL); - - InterlockedCompareExchangeT(&m_hExposedAssemblyObject, handle, static_cast(0)); - } - - if (pLoaderAllocator->GetHandleValue(m_hExposedAssemblyObject) == NULL) - { - ASSEMBLYREF assemblyObj = NULL; - MethodTable * pMT; - - pMT = CoreLibBinder::GetClass(CLASS__ASSEMBLY); - - // Will be TRUE only if LoaderAllocator managed object was already collected and therefore we should - // return NULL - BOOL fIsLoaderAllocatorCollected = FALSE; - - // Create the assembly object - GCPROTECT_BEGIN(assemblyObj); - assemblyObj = (ASSEMBLYREF)AllocateObject(pMT); - - assemblyObj->SetAssembly(this); - - // Attach the reference to the assembly to keep the LoaderAllocator for this collectible type - // alive as long as a reference to the assembly is kept alive. - // Currently we overload the sync root field of the assembly to do so, but the overload is not necessary. - if (GetAssembly() != NULL) - { - OBJECTREF refLA = GetAssembly()->GetLoaderAllocator()->GetExposedObject(); - if ((refLA == NULL) && GetAssembly()->GetLoaderAllocator()->IsCollectible()) - { // The managed LoaderAllocator object was collected - fIsLoaderAllocatorCollected = TRUE; - } - assemblyObj->SetSyncRoot(refLA); - } - - if (!fIsLoaderAllocatorCollected) - { // We should not expose this value in case the LoaderAllocator managed object was already - // collected - pLoaderAllocator->CompareExchangeValueInHandle(m_hExposedAssemblyObject, (OBJECTREF)assemblyObj, NULL); - } - GCPROTECT_END(); - - if (fIsLoaderAllocatorCollected) - { // The LoaderAllocator managed object was already collected, we cannot re-create it - // Note: We did not publish the allocated Assembly/AssmeblyBuilder object, it will get collected - // by GC - return NULL; - } - } - - return pLoaderAllocator->GetHandleValue(m_hExposedAssemblyObject); -} - -void DomainAssembly::Begin() +void Assembly::Begin() { STANDARD_VM_CONTRACT; { AppDomain::LoadLockHolder lock(AppDomain::GetCurrentDomain()); - AppDomain::GetCurrentDomain()->AddAssembly(this); + AppDomain::GetCurrentDomain()->AddAssembly(GetDomainAssembly()); } // Make it possible to find this DomainAssembly object from associated BINDER_SPACE::Assembly. RegisterWithHostAssembly(); - m_fHostAssemblyPublished = true; } -void DomainAssembly::RegisterWithHostAssembly() +void Assembly::RegisterWithHostAssembly() { CONTRACTL { @@ -606,11 +452,11 @@ void DomainAssembly::RegisterWithHostAssembly() if (GetPEAssembly()->HasHostAssembly()) { - GetPEAssembly()->GetHostAssembly()->SetDomainAssembly(this); + GetPEAssembly()->GetHostAssembly()->SetRuntimeAssembly(this); } } -void DomainAssembly::UnregisterFromHostAssembly() +void Assembly::UnregisterFromHostAssembly() { CONTRACTL { @@ -622,43 +468,11 @@ void DomainAssembly::UnregisterFromHostAssembly() if (GetPEAssembly()->HasHostAssembly()) { - GetPEAssembly()->GetHostAssembly()->SetDomainAssembly(nullptr); + GetPEAssembly()->GetHostAssembly()->SetRuntimeAssembly(nullptr); } } -void DomainAssembly::Allocate() -{ - CONTRACTL - { - INSTANCE_CHECK; - STANDARD_VM_CHECK; - INJECT_FAULT(COMPlusThrowOM();); - PRECONDITION(m_pAssembly == NULL); - } - CONTRACTL_END; - - AllocMemTracker amTracker; - AllocMemTracker * pamTracker = &amTracker; - - Assembly * pAssembly; - { - // Order is important here - in the case of an exception, the Assembly holder must destruct before the AllocMemTracker declared above. - NewHolder assemblyHolder(NULL); - - assemblyHolder = pAssembly = Assembly::Create(GetPEAssembly(), GetDebuggerInfoBits(), this->IsCollectible(), pamTracker, this->IsCollectible() ? this->GetLoaderAllocator() : NULL); - assemblyHolder->SetIsTenured(); - - pamTracker->SuppressRelease(); - assemblyHolder.SuppressRelease(); - } - - SetAssembly(pAssembly); - - // Creating the Assembly should have ensured the PEAssembly is loaded - _ASSERT(GetPEAssembly()->IsLoaded()); -} - -void DomainAssembly::DeliverAsyncEvents() +void Assembly::DeliverAsyncEvents() { CONTRACTL { @@ -673,7 +487,7 @@ void DomainAssembly::DeliverAsyncEvents() AppDomain::GetCurrentDomain()->RaiseLoadingAssemblyEvent(this); } -void DomainAssembly::DeliverSyncEvents() +void Assembly::DeliverSyncEvents() { CONTRACTL { @@ -831,15 +645,12 @@ HRESULT DomainAssembly::GetDebuggingCustomAttributes(DWORD *pdwFlags) return hr; } -BOOL DomainAssembly::NotifyDebuggerLoad(int flags, BOOL attaching) +BOOL Assembly::NotifyDebuggerLoad(int flags, BOOL attaching) { WRAPPER_NO_CONTRACT; BOOL result = FALSE; - if (!IsVisibleToDebugger()) - return FALSE; - // Debugger Attach is done totally out-of-process. Does not call code in-proc. _ASSERTE(!attaching); @@ -855,7 +666,7 @@ BOOL DomainAssembly::NotifyDebuggerLoad(int flags, BOOL attaching) { if (ShouldNotifyDebugger()) { - g_pDebugInterface->LoadAssembly(this); + g_pDebugInterface->LoadAssembly(GetDomainAssembly()); } result = TRUE; } @@ -863,35 +674,30 @@ BOOL DomainAssembly::NotifyDebuggerLoad(int flags, BOOL attaching) if(this->ShouldNotifyDebugger()) { result = result || - this->GetModule()->NotifyDebuggerLoad(AppDomain::GetCurrentDomain(), this, flags, attaching); + this->GetModule()->NotifyDebuggerLoad(GetDomainAssembly(), flags, attaching); } if( ShouldNotifyDebugger()) { - result|=m_pModule->NotifyDebuggerLoad(AppDomain::GetCurrentDomain(), this, ATTACH_MODULE_LOAD, attaching); + result|=m_pModule->NotifyDebuggerLoad(GetDomainAssembly(), ATTACH_MODULE_LOAD, attaching); SetDebuggerNotified(); } return result; } -void DomainAssembly::NotifyDebuggerUnload() +void Assembly::NotifyDebuggerUnload() { LIMITED_METHOD_CONTRACT; - if (!IsVisibleToDebugger()) - return; - if (!AppDomain::GetCurrentDomain()->IsDebuggerAttached()) return; - m_fDebuggerUnloadStarted = TRUE; - // Dispatch module unload for the module. Debugger is resilient in case we haven't dispatched // a previous load event (such as if debugger attached after the modules was loaded). - this->GetModule()->NotifyDebuggerUnload(AppDomain::GetCurrentDomain()); + this->GetModule()->NotifyDebuggerUnload(); - g_pDebugInterface->UnloadAssembly(this); + g_pDebugInterface->UnloadAssembly(GetDomainAssembly()); } #endif // #ifndef DACCESS_COMPILE diff --git a/src/coreclr/vm/domainassembly.h b/src/coreclr/vm/domainassembly.h index 9ba6b458e59..8ae63bff9f7 100644 --- a/src/coreclr/vm/domainassembly.h +++ b/src/coreclr/vm/domainassembly.h @@ -35,8 +35,7 @@ enum FileLoadLevel FILE_LOAD_CREATE, FILE_LOAD_BEGIN, - FILE_LOAD_ALLOCATE, - FILE_LOAD_POST_ALLOCATE, + FILE_LOAD_BEFORE_TYPE_LOAD, FILE_LOAD_EAGER_FIXUPS, FILE_LOAD_DELIVER_EVENTS, FILE_LOAD_VTABLE_FIXUPS, @@ -44,7 +43,6 @@ enum FileLoadLevel FILE_ACTIVE // Fully active (constructors run & security checked) }; - enum NotificationStatus { NOT_NOTIFIED=0, @@ -80,7 +78,6 @@ class DomainAssembly final Assembly* GetAssembly() { LIMITED_METHOD_DAC_CONTRACT; - CONSISTENCY_CHECK(CheckLoaded()); return m_pAssembly; } @@ -88,36 +85,10 @@ class DomainAssembly final Module* GetModule() { LIMITED_METHOD_CONTRACT; - CONSISTENCY_CHECK(CheckLoaded()); return m_pModule; } - IMDInternalImport *GetMDImport() - { - WRAPPER_NO_CONTRACT; - return m_pPEAssembly->GetMDImport(); - } - - OBJECTREF GetExposedAssemblyObjectIfExists() - { - LIMITED_METHOD_CONTRACT; - - OBJECTREF objRet = NULL; - GET_LOADERHANDLE_VALUE_FAST(GetLoaderAllocator(), m_hExposedAssemblyObject, &objRet); - return objRet; - } - - // Returns managed representation of the assembly (Assembly or AssemblyBuilder). - // Returns NULL if the managed scout was already collected (see code:LoaderAllocator#AssemblyPhases). - OBJECTREF GetExposedAssemblyObject(); - - BOOL IsSystem() - { - WRAPPER_NO_CONTRACT; - return GetPEAssembly()->IsSystem(); - } - LPCUTF8 GetSimpleName() { WRAPPER_NO_CONTRACT; @@ -138,101 +109,6 @@ class DomainAssembly final return m_fCollectible; } - // ------------------------------------------------------------ - // Loading state checks - // ------------------------------------------------------------ - - // Return the File's load level. Note that this is the last level actually successfully completed. - // Note that this is subtly different than the FileLoadLock's level, which is the last level - // which was triggered (but potentially skipped if error or inappropriate.) - FileLoadLevel GetLoadLevel() { LIMITED_METHOD_DAC_CONTRACT; return m_level; } - - // Error means that a permanent x-appdomain load error has occurred. - BOOL IsError() - { - LIMITED_METHOD_DAC_CONTRACT; - DACCOP_IGNORE(FieldAccess, "No marshalling required"); - return m_pError != NULL; - } - - // Loading means that the load is still being tracked by a FileLoadLock. - BOOL IsLoading() { LIMITED_METHOD_CONTRACT; return m_loading; } - - // Loaded means that the file can be used passively. This includes loading types, reflection, and - // jitting. - BOOL IsLoaded() { LIMITED_METHOD_DAC_CONTRACT; return m_level >= FILE_LOAD_DELIVER_EVENTS; } - - // Active means that the file can be used actively in the current app domain. Note that a shared file - // may conditionally not be able to be made active on a per app domain basis. - BOOL IsActive() { LIMITED_METHOD_CONTRACT; return m_level >= FILE_ACTIVE; } - - // Checks if the load has reached the point where profilers may be notified - // about the file. It's important that IF a profiler is notified, THEN this returns - // TRUE, otherwise there can be profiler-attach races where the profiler doesn't see - // the file via either enumeration or notification. As a result, this begins - // returning TRUE just before the profiler is actually notified. See - // code:ProfilerFunctionEnum::Init#ProfilerEnumAssemblies - BOOL IsAvailableToProfilers() - { - LIMITED_METHOD_DAC_CONTRACT; - return IsProfilerNotified(); // despite the name, this function returns TRUE just before we notify the profiler - } - - // CheckLoaded is appropriate for asserts that the assembly can be passively used. - CHECK CheckLoaded(); - - // CheckActivated is appropriate for asserts that the assembly can be actively used. Note that - // it is slightly different from IsActive in that it deals with reentrancy cases properly. - CHECK CheckActivated(); - - // Ensure that an assembly has reached at least the IsLoaded state. Throw if not. - void EnsureLoaded() - { - WRAPPER_NO_CONTRACT; - return EnsureLoadLevel(FILE_LOADED); - } - - // Ensure that an assembly has reached at least the IsActive state. Throw if not. - void EnsureActive() - { - WRAPPER_NO_CONTRACT; - return EnsureLoadLevel(FILE_ACTIVE); - } - - // Ensure that an assembly has reached at least the Allocated state. Throw if not. - void EnsureAllocated() - { - WRAPPER_NO_CONTRACT; - return EnsureLoadLevel(FILE_LOAD_ALLOCATE); - } - - // EnsureLoadLevel is a generic routine used to ensure that the file is not in a delay loaded - // state (unless it needs to be.) This should be used when a particular level of loading - // is required for an operation. Note that deadlocks are tolerated so the level may be one - void EnsureLoadLevel(FileLoadLevel targetLevel) DAC_EMPTY(); - - // CheckLoadLevel is an assert predicate used to verify the load level of an assembly. - // deadlockOK indicates that the level is allowed to be one short if we are restricted - // by loader reentrancy. - CHECK CheckLoadLevel(FileLoadLevel requiredLevel, BOOL deadlockOK = TRUE) DAC_EMPTY_RET(CHECK::OK()); - - // RequireLoadLevel throws an exception if the domain file isn't loaded enough. Note - // that this is intolerant of deadlock related failures so is only really appropriate for - // checks inside the main loading loop. - void RequireLoadLevel(FileLoadLevel targetLevel) DAC_EMPTY(); - - // Throws if a load error has occurred - void ThrowIfError(FileLoadLevel targetLevel) DAC_EMPTY(); - - // Checks that a load error has not occurred before the given level - CHECK CheckNoError(FileLoadLevel targetLevel) DAC_EMPTY_RET(CHECK::OK()); - - // IsNotified means that the profiler API notification has been delivered - BOOL IsProfilerNotified() { LIMITED_METHOD_CONTRACT; return m_notifyflags & PROFILER_NOTIFIED; } - BOOL IsDebuggerNotified() { LIMITED_METHOD_CONTRACT; return m_notifyflags & DEBUGGER_NOTIFIED; } - BOOL ShouldNotifyDebugger() { LIMITED_METHOD_CONTRACT; return m_notifyflags & DEBUGGER_NEEDNOTIFICATION; } - - // ------------------------------------------------------------ // Other public APIs // ------------------------------------------------------------ @@ -246,11 +122,6 @@ class DomainAssembly final void EnumMemoryRegions(CLRDataEnumMemoryFlags flags); #endif -#ifndef DACCESS_COMPILE - // light code gen. Keep the list of MethodTables needed for creating dynamic methods - DynamicMethodTable* GetDynamicMethodTable(); -#endif - DomainAssembly* GetNextDomainAssemblyInSameALC() { return m_NextDomainAssemblyInSameALC; @@ -275,86 +146,8 @@ class DomainAssembly final friend class AppDomain; friend class Assembly; - friend class Module; - friend class FileLoadLock; - - DomainAssembly(PEAssembly* pPEAssembly, LoaderAllocator* pLoaderAllocator); - BOOL DoIncrementalLoad(FileLoadLevel targetLevel); - void ClearLoading() { LIMITED_METHOD_CONTRACT; m_loading = FALSE; } - void SetLoadLevel(FileLoadLevel level) { LIMITED_METHOD_CONTRACT; m_level = level; } - -#ifndef DACCESS_COMPILE - void Begin(); - void Allocate(); - void PostAllocate(); - void EagerFixups(); - void VtableFixups(); - void DeliverSyncEvents(); - void DeliverAsyncEvents(); - void FinishLoad(); - void Activate(); - - void RegisterWithHostAssembly(); - void UnregisterFromHostAssembly(); -#endif - - // This should be used to permanently set the load to fail. Do not use with transient conditions - void SetError(Exception *ex); - void SetAssembly(Assembly* pAssembly); - - void SetProfilerNotified() { LIMITED_METHOD_CONTRACT; m_notifyflags|= PROFILER_NOTIFIED; } - void SetDebuggerNotified() { LIMITED_METHOD_CONTRACT; m_notifyflags|=DEBUGGER_NOTIFIED; } - void SetShouldNotifyDebugger() { LIMITED_METHOD_CONTRACT; m_notifyflags|=DEBUGGER_NEEDNOTIFICATION; } - - class ExInfo - { - enum - { - ExType_ClrEx, - ExType_HR - } - m_type; - union - { - Exception* m_pEx; - HRESULT m_hr; - }; - - public: - void Throw() - { - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_ANY; - } - CONTRACTL_END; - if (m_type == ExType_ClrEx) - { - PAL_CPP_THROW(Exception*, m_pEx->DomainBoundClone()); - } - if (m_type == ExType_HR) - ThrowHR(m_hr); - _ASSERTE(!"Bad exception type"); - ThrowHR(E_UNEXPECTED); - }; - - ExInfo(Exception* pEx) - { - LIMITED_METHOD_CONTRACT; - m_type = ExType_ClrEx; - m_pEx = pEx; - }; - - ~ExInfo() - { - LIMITED_METHOD_CONTRACT; - if (m_type == ExType_ClrEx) - delete m_pEx; - } - }; + DomainAssembly(PEAssembly* pPEAssembly, LoaderAllocator* pLoaderAllocator, AllocMemTracker* memTracker); public: // ------------------------------------------------------------ @@ -378,10 +171,6 @@ class DomainAssembly final HRESULT GetDebuggingCustomAttributes(DWORD* pdwFlags); - BOOL IsVisibleToDebugger(); - BOOL NotifyDebuggerLoad(int flags, BOOL attaching); - void NotifyDebuggerUnload(); - private: // ------------------------------------------------------------ // Instance data @@ -395,25 +184,7 @@ class DomainAssembly final DomainAssembly* m_NextDomainAssemblyInSameALC; PTR_LoaderAllocator m_pLoaderAllocator; - FileLoadLevel m_level; - BOOL m_loading; - - LOADERHANDLE m_hExposedAssemblyObject; - - ExInfo* m_pError; - - BOOL m_bDisableActivationCheck; - BOOL m_fHostAssemblyPublished; - - // m_pDynamicMethodTable is used by the light code generation to allow method - // generation on the fly. They are lazily created when/if a dynamic method is requested - // for this specific module - DynamicMethodTable* m_pDynamicMethodTable; - - DebuggerAssemblyControlFlags m_debuggerFlags; - DWORD m_notifyflags; - BOOL m_fDebuggerUnloadStarted; }; #endif // _DOMAINASSEMBLY_H_ diff --git a/src/coreclr/vm/dwbucketmanager.hpp b/src/coreclr/vm/dwbucketmanager.hpp index 782cc89519d..dec761a97e5 100644 --- a/src/coreclr/vm/dwbucketmanager.hpp +++ b/src/coreclr/vm/dwbucketmanager.hpp @@ -451,7 +451,7 @@ void BaseBucketParamsManager::GetAppName(_Out_writes_(maxLength) WCHAR* targetPa CONTRACTL_END; PathString appPath; - if (GetCurrentModuleFileName(appPath) == S_OK) + if (GetCurrentExecutableFileName(appPath) == S_OK) { // Get just the module name; remove the path const WCHAR* appName = u16_strrchr(appPath, DIRECTORY_SEPARATOR_CHAR_W); @@ -479,7 +479,7 @@ void BaseBucketParamsManager::GetAppVersion(_Out_writes_(maxLength) WCHAR* targe WCHAR verBuf[23] = {0}; USHORT major, minor, build, revision; - if ((GetCurrentModuleFileName(appPath) == S_OK) && SUCCEEDED(DwGetFileVersionInfo(appPath, major, minor, build, revision))) + if ((GetCurrentExecutableFileName(appPath) == S_OK) && SUCCEEDED(DwGetFileVersionInfo(appPath, major, minor, build, revision))) { _snwprintf_s(targetParam, maxLength, diff --git a/src/coreclr/vm/dynamicmethod.cpp b/src/coreclr/vm/dynamicmethod.cpp index 6d674130010..d4a75cbbadb 100644 --- a/src/coreclr/vm/dynamicmethod.cpp +++ b/src/coreclr/vm/dynamicmethod.cpp @@ -20,7 +20,7 @@ #ifndef DACCESS_COMPILE // get the method table for dynamic methods -DynamicMethodTable* DomainAssembly::GetDynamicMethodTable() +DynamicMethodTable* Module::GetDynamicMethodTable() { CONTRACT (DynamicMethodTable*) { @@ -34,7 +34,7 @@ DynamicMethodTable* DomainAssembly::GetDynamicMethodTable() CONTRACT_END; if (!m_pDynamicMethodTable) - DynamicMethodTable::CreateDynamicMethodTable(&m_pDynamicMethodTable, GetModule(), GetAppDomain()); + DynamicMethodTable::CreateDynamicMethodTable(&m_pDynamicMethodTable, this, AppDomain::GetCurrentDomain()); RETURN m_pDynamicMethodTable; diff --git a/src/coreclr/vm/ecalllist.h b/src/coreclr/vm/ecalllist.h index 00429788f0b..b1f475b3b16 100644 --- a/src/coreclr/vm/ecalllist.h +++ b/src/coreclr/vm/ecalllist.h @@ -54,10 +54,6 @@ FCFuncStart(gDependentHandleFuncs) FCFuncElement("InternalFree", DependentHandle::InternalFree) FCFuncEnd() -FCFuncStart(gObjectFuncs) - FCFuncElement("GetType", ObjectNative::GetClass) -FCFuncEnd() - FCFuncStart(gStringFuncs) FCDynamic("FastAllocateString", ECall::FastAllocateString) FCDynamicSig(COR_CTOR_METHOD_NAME, &gsig_IM_ArrChar_RetVoid, ECall::CtorCharArrayManaged) @@ -72,14 +68,8 @@ FCFuncStart(gStringFuncs) FCFuncEnd() FCFuncStart(gDiagnosticsDebugger) - FCFuncElement("BreakInternal", DebugDebugger::Break) FCFuncElement("get_IsAttached", DebugDebugger::IsDebuggerAttached) FCFuncElement("IsLogging", DebugDebugger::IsLogging) - FCFuncElement("CustomNotification", DebugDebugger::CustomNotification) -FCFuncEnd() - -FCFuncStart(gDiagnosticsStackTrace) - FCFuncElement("GetStackFramesInternal", DebugStackTrace::GetStackFramesInternal) FCFuncEnd() FCFuncStart(gEnvironmentFuncs) @@ -93,7 +83,6 @@ FCFuncEnd() FCFuncStart(gExceptionFuncs) FCFuncElement("IsImmutableAgileException", ExceptionNative::IsImmutableAgileException) FCFuncElement("PrepareForForeignExceptionRaise", ExceptionNative::PrepareForForeignExceptionRaise) - FCFuncElement("GetFrozenStackTrace", ExceptionNative::GetFrozenStackTrace) FCFuncElement("GetExceptionCount", ExceptionNative::GetExceptionCount) FCFuncEnd() @@ -120,8 +109,8 @@ FCFuncStart(gCOMTypeHandleFuncs) FCFuncElement("GetFirstIntroducedMethod", RuntimeTypeHandle::GetFirstIntroducedMethod) FCFuncElement("GetNextIntroducedMethod", RuntimeTypeHandle::GetNextIntroducedMethod) FCFuncElement("GetCorElementType", RuntimeTypeHandle::GetCorElementType) - FCFuncElement("GetAssembly", RuntimeTypeHandle::GetAssembly) - FCFuncElement("GetModule", RuntimeTypeHandle::GetModule) + FCFuncElement("GetAssemblyIfExists", RuntimeTypeHandle::GetAssemblyIfExists) + FCFuncElement("GetModuleIfExists", RuntimeTypeHandle::GetModuleIfExists) FCFuncElement("GetBaseType", RuntimeTypeHandle::GetBaseType) FCFuncElement("GetElementType", RuntimeTypeHandle::GetElementType) FCFuncElement("GetArrayRank", RuntimeTypeHandle::GetArrayRank) @@ -233,7 +222,7 @@ FCFuncStart(gCOMModuleHandleFuncs) FCFuncEnd() FCFuncStart(gRuntimeAssemblyFuncs) - FCFuncElement("FCallIsDynamic", AssemblyNative::IsDynamic) + FCFuncElement("GetIsDynamic", AssemblyNative::GetIsDynamic) FCFuncElement("GetManifestModule", AssemblyHandle::GetManifestModule) FCFuncElement("GetToken", AssemblyHandle::GetToken) FCFuncEnd() @@ -309,22 +298,10 @@ FCFuncStart(gMathFFuncs) FCFuncEnd() FCFuncStart(gThreadFuncs) - FCFuncElement("InternalGetCurrentThread", GetThread) - FCFuncElement("Initialize", ThreadNative::Initialize) - FCFuncElement("GetCurrentThreadNative", ThreadNative::GetCurrentThread) FCFuncElement("InternalFinalize", ThreadNative::Finalize) - FCFuncElement("get_IsAlive", ThreadNative::IsAlive) FCFuncElement("GetIsBackground", ThreadNative::GetIsBackground) FCFuncElement("get_IsThreadPoolThread", ThreadNative::IsThreadpoolThread) FCFuncElement("set_IsThreadPoolThread", ThreadNative::SetIsThreadpoolThread) - FCFuncElement("GetPriorityNative", ThreadNative::GetPriority) - FCFuncElement("SetPriorityNative", ThreadNative::SetPriority) - FCFuncElement("GetThreadStateNative", ThreadNative::GetThreadState) -#ifdef FEATURE_COMINTEROP_APARTMENT_SUPPORT - FCFuncElement("GetApartmentStateNative", ThreadNative::GetApartmentState) - FCFuncElement("SetApartmentStateNative", ThreadNative::SetApartmentState) -#endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT - FCFuncElement("Join", ThreadNative::Join) FCFuncElement("get_OptimalMaxSpinWaitsPerSpinIteration", ThreadNative::GetOptimalMaxSpinWaitsPerSpinIteration) FCFuncEnd() @@ -332,19 +309,6 @@ FCFuncStart(gThreadPoolFuncs) FCFuncElement("GetNextConfigUInt32Value", ThreadPoolNative::GetNextConfigUInt32Value) FCFuncEnd() -FCFuncStart(gWaitHandleFuncs) - FCFuncElement("WaitOneCore", WaitHandleNative::CorWaitOneNative) - FCFuncElement("WaitMultipleIgnoringSyncContext", WaitHandleNative::CorWaitMultipleNative) - FCFuncElement("SignalAndWaitNative", WaitHandleNative::CorSignalAndWaitOneNative) -FCFuncEnd() - -#ifdef FEATURE_COMINTEROP -FCFuncStart(gVariantFuncs) - FCFuncElement("SetFieldsObject", COMVariant::SetFieldsObject) - FCFuncElement("BoxEnum", COMVariant::BoxEnum) -FCFuncEnd() -#endif // FEATURE_COMINTEROP - FCFuncStart(gCastHelpers) FCFuncElement("IsInstanceOfAny_NoCacheLookup", ::IsInstanceOfAny_NoCacheLookup) FCFuncElement("ChkCastAny_NoCacheLookup", ::ChkCastAny_NoCacheLookup) @@ -382,8 +346,6 @@ FCFuncStart(gGCInterfaceFuncs) FCFuncElement("GetAllocatedBytesForCurrentThread", GCInterface::GetAllocatedBytesForCurrentThread) FCFuncElement("GetTotalAllocatedBytesApproximate", GCInterface::GetTotalAllocatedBytesApproximate) - - FCFuncElement("AllocateNewArray", GCInterface::AllocateNewArray) FCFuncEnd() FCFuncStart(gGCSettingsFuncs) @@ -432,7 +394,6 @@ FCFuncEnd() FCFuncStart(gRuntimeHelpers) FCFuncElement("PrepareDelegate", ReflectionInvocation::PrepareDelegate) - FCFuncElement("GetHashCode", ObjectNative::GetHashCode) FCFuncElement("TryGetHashCode", ObjectNative::TryGetHashCode) FCFuncElement("ContentEquals", ObjectNative::ContentEquals) FCFuncElement("EnsureSufficientExecutionStack", ReflectionInvocation::EnsureSufficientExecutionStack) @@ -453,21 +414,10 @@ FCFuncStart(gStubHelperFuncs) FCFuncElement("TryGetStringTrailByte", StubHelpers::TryGetStringTrailByte) FCFuncElement("SetLastError", StubHelpers::SetLastError) FCFuncElement("ClearLastError", StubHelpers::ClearLastError) - FCFuncElement("InternalGetHRExceptionObject", StubHelpers::GetHRExceptionObject) #ifdef FEATURE_COMINTEROP - FCFuncElement("InternalGetCOMHRExceptionObject", StubHelpers::GetCOMHRExceptionObject) FCFuncElement("GetCOMIPFromRCW", StubHelpers::GetCOMIPFromRCW) #endif // FEATURE_COMINTEROP -#ifdef PROFILING_SUPPORTED - FCFuncElement("ProfilerBeginTransitionCallback", StubHelpers::ProfilerBeginTransitionCallback) - FCFuncElement("ProfilerEndTransitionCallback", StubHelpers::ProfilerEndTransitionCallback) -#endif - FCFuncElement("AllocateInternal", StubHelpers::AllocateInternal) - FCFuncElement("MarshalToUnmanagedVaListInternal", StubHelpers::MarshalToUnmanagedVaListInternal) - FCFuncElement("MarshalToManagedVaListInternal", StubHelpers::MarshalToManagedVaListInternal) FCFuncElement("CalcVaListSize", StubHelpers::CalcVaListSize) - FCFuncElement("ValidateObject", StubHelpers::ValidateObject) - FCFuncElement("ValidateByref", StubHelpers::ValidateByref) FCFuncElement("LogPinnedArgument", StubHelpers::LogPinnedArgument) FCFuncElement("GetStubContext", StubHelpers::GetStubContext) FCFuncElement("MulticastDebuggerTraceHelper", StubHelpers::MulticastDebuggerTraceHelper) @@ -482,38 +432,10 @@ FCFuncStart(gGCHandleFuncs) FCFuncElement("InternalCompareExchange", MarshalNative::GCHandleInternalCompareExchange) FCFuncEnd() -FCFuncStart(gStreamFuncs) - FCFuncElement("HasOverriddenBeginEndRead", StreamNative::HasOverriddenBeginEndRead) - FCFuncElement("HasOverriddenBeginEndWrite", StreamNative::HasOverriddenBeginEndWrite) -FCFuncEnd() - FCFuncStart(gComAwareWeakReferenceFuncs) FCFuncElement("HasInteropInfo", ComAwareWeakReferenceNative::HasInteropInfo) FCFuncEnd() -#ifdef FEATURE_COMINTEROP - -// -// ECall helpers for the standard managed interfaces. -// - -#define MNGSTDITF_BEGIN_INTERFACE(FriendlyName, strMngItfName, strUCOMMngItfName, strCustomMarshalerName, strCustomMarshalerCookie, strManagedViewName, NativeItfIID, bCanCastOnNativeItfQI) \ -FCFuncStart(g##FriendlyName##Funcs) - -#define MNGSTDITF_DEFINE_METH_IMPL(FriendlyName, FCallMethName, MethName, MethSig, FcallDecl) \ - FCUnreferenced FCFuncElementSig(#MethName, MethSig, FriendlyName::FCallMethName) - -#define MNGSTDITF_END_INTERFACE(FriendlyName) \ -FCFuncEnd() - -#include "mngstditflist.h" - -#undef MNGSTDITF_BEGIN_INTERFACE -#undef MNGSTDITF_DEFINE_METH_IMPL -#undef MNGSTDITF_END_INTERFACE - -#endif // FEATURE_COMINTEROP - // // // Class definitions @@ -537,11 +459,6 @@ FCClassElement("GC", "System", gGCInterfaceFuncs) FCClassElement("GCFrameRegistration", "System.Runtime", gGCFrameRegistration) FCClassElement("GCHandle", "System.Runtime.InteropServices", gGCHandleFuncs) FCClassElement("GCSettings", "System.Runtime", gGCSettingsFuncs) -#ifdef FEATURE_COMINTEROP -FCClassElement("IEnumerable", "System.Collections", gStdMngIEnumerableFuncs) -FCClassElement("IEnumerator", "System.Collections", gStdMngIEnumeratorFuncs) -FCClassElement("IReflect", "System.Reflection", gStdMngIReflectFuncs) -#endif FCClassElement("Interlocked", "System.Threading", gInterlockedFuncs) FCClassElement("JitInfo", "System.Runtime", gJitInfoFuncs) FCClassElement("Marshal", "System.Runtime.InteropServices", gInteropMarshalFuncs) @@ -551,7 +468,6 @@ FCClassElement("MetadataImport", "System.Reflection", gMetaDataImport) FCClassElement("MethodTable", "System.Runtime.CompilerServices", gMethodTableFuncs) FCClassElement("ModuleHandle", "System", gCOMModuleHandleFuncs) FCClassElement("Monitor", "System.Threading", gMonitorFuncs) -FCClassElement("Object", "System", gObjectFuncs) FCClassElement("RuntimeAssembly", "System.Reflection", gRuntimeAssemblyFuncs) FCClassElement("RuntimeFieldHandle", "System", gCOMFieldHandleNewFuncs) @@ -561,18 +477,12 @@ FCClassElement("RuntimeType", "System", gSystem_RuntimeType) FCClassElement("RuntimeTypeHandle", "System", gCOMTypeHandleFuncs) FCClassElement("Signature", "System", gSignatureNative) -FCClassElement("StackTrace", "System.Diagnostics", gDiagnosticsStackTrace) -FCClassElement("Stream", "System.IO", gStreamFuncs) FCClassElement("String", "System", gStringFuncs) FCClassElement("StubHelpers", "System.StubHelpers", gStubHelperFuncs) FCClassElement("Thread", "System.Threading", gThreadFuncs) FCClassElement("ThreadPool", "System.Threading", gThreadPoolFuncs) FCClassElement("Type", "System", gSystem_Type) FCClassElement("TypedReference", "System", gTypedReferenceFuncs) -#ifdef FEATURE_COMINTEROP -FCClassElement("Variant", "System", gVariantFuncs) -#endif -FCClassElement("WaitHandle", "System.Threading", gWaitHandleFuncs) #undef FCFuncElement #undef FCFuncElementSig diff --git a/src/coreclr/vm/eehash.cpp b/src/coreclr/vm/eehash.cpp index efd6145567e..4bd014e5dc3 100644 --- a/src/coreclr/vm/eehash.cpp +++ b/src/coreclr/vm/eehash.cpp @@ -15,91 +15,6 @@ #include "typectxt.h" #include "genericdict.h" -// ============================================================================ -// UTF8 string hash table helper. -// ============================================================================ -EEHashEntry_t * EEUtf8HashTableHelper::AllocateEntry(LPCUTF8 pKey, BOOL bDeepCopy, void *pHeap) -{ - CONTRACTL - { - NOTHROW; - GC_NOTRIGGER; - INJECT_FAULT(return NULL;); - } - CONTRACTL_END - - EEHashEntry_t *pEntry; - - if (bDeepCopy) - { - SIZE_T StringLen = strlen(pKey); - SIZE_T BufLen = 0; - if (!ClrSafeInt::addition(StringLen, SIZEOF_EEHASH_ENTRY + sizeof(LPUTF8) + 1, BufLen)) - return NULL; - pEntry = (EEHashEntry_t *) new (nothrow) BYTE[BufLen]; - if (!pEntry) - return NULL; - - memcpy(pEntry->Key + sizeof(LPUTF8), pKey, StringLen + 1); - *((LPUTF8*)pEntry->Key) = (LPUTF8)(pEntry->Key + sizeof(LPUTF8)); - } - else - { - pEntry = (EEHashEntry_t *) new (nothrow)BYTE[SIZEOF_EEHASH_ENTRY + sizeof(LPUTF8)]; - if (pEntry) - *((LPCUTF8*)pEntry->Key) = pKey; - } - - return pEntry; -} - - -void EEUtf8HashTableHelper::DeleteEntry(EEHashEntry_t *pEntry, void *pHeap) -{ - CONTRACTL - { - NOTHROW; - GC_NOTRIGGER; - FORBID_FAULT; - } - CONTRACTL_END - - delete [] (BYTE*)pEntry; -} - - -BOOL EEUtf8HashTableHelper::CompareKeys(EEHashEntry_t *pEntry, LPCUTF8 pKey) -{ - LIMITED_METHOD_DAC_CONTRACT; - - LPCUTF8 pEntryKey = *((LPCUTF8*)pEntry->Key); - return (strcmp(pEntryKey, pKey) == 0) ? TRUE : FALSE; -} - - -DWORD EEUtf8HashTableHelper::Hash(LPCUTF8 pKey) -{ - LIMITED_METHOD_DAC_CONTRACT; - - DWORD dwHash = 0; - - while (*pKey != 0) - { - dwHash = (dwHash << 5) + (dwHash >> 5) + (*pKey); - pKey++; - } - - return dwHash; -} - - -LPCUTF8 EEUtf8HashTableHelper::GetKey(EEHashEntry_t *pEntry) -{ - LIMITED_METHOD_CONTRACT; - - return *((LPCUTF8*)pEntry->Key); -} - #ifndef DACCESS_COMPILE // ============================================================================ diff --git a/src/coreclr/vm/eehash.h b/src/coreclr/vm/eehash.h index 1179440aa79..f4e221d247f 100644 --- a/src/coreclr/vm/eehash.h +++ b/src/coreclr/vm/eehash.h @@ -350,21 +350,6 @@ class EEPtrPlusIntHashTableHelper typedef EEHashTable EEPtrPlusIntHashTable; -// UTF8 string hash table. The UTF8 strings are NULL terminated. - -class EEUtf8HashTableHelper -{ -public: - static EEHashEntry_t * AllocateEntry(LPCUTF8 pKey, BOOL bDeepCopy, AllocationHeap Heap); - static void DeleteEntry(EEHashEntry_t *pEntry, AllocationHeap Heap); - static BOOL CompareKeys(EEHashEntry_t *pEntry, LPCUTF8 pKey); - static DWORD Hash(LPCUTF8 pKey); - static LPCUTF8 GetKey(EEHashEntry_t *pEntry); -}; - -typedef EEHashTable EEUtf8StringHashTable; -typedef DPTR(EEUtf8StringHashTable) PTR_EEUtf8StringHashTable; - // Unicode String hash table - the keys are UNICODE strings which may // contain embedded nulls. An EEStringData struct is used for the key // which contains the length of the item. Note that this string is diff --git a/src/coreclr/vm/encee.cpp b/src/coreclr/vm/encee.cpp index 7dec6bc2045..250a90eb51e 100644 --- a/src/coreclr/vm/encee.cpp +++ b/src/coreclr/vm/encee.cpp @@ -343,8 +343,8 @@ HRESULT EditAndContinueModule::UpdateMethod(MethodDesc *pMethod) module, tkMethod, AssemblyIterationFlags(kIncludeLoaded | kIncludeExecution)); - CollectibleAssemblyHolder pDomainAssembly; - while (it.Next(pDomainAssembly.This())) + CollectibleAssemblyHolder pAssembly; + while (it.Next(pAssembly.This())) { MethodDesc* pMD = it.Current(); pMD->ResetCodeEntryPointForEnC(); diff --git a/src/coreclr/vm/eventreporter.cpp b/src/coreclr/vm/eventreporter.cpp index 9a4d01b8af9..8ffab60bbd9 100644 --- a/src/coreclr/vm/eventreporter.cpp +++ b/src/coreclr/vm/eventreporter.cpp @@ -632,7 +632,6 @@ void ReportExceptionStackHelper(OBJECTREF exObj, EventReporter& reporter, SmallS DebugStackTrace::GetStackFramesData stackFramesData; stackFramesData.pDomain = NULL; - stackFramesData.skip = 0; stackFramesData.NumFramesRequested = 0; DebugStackTrace::GetStackFramesFromException(&(gc.exObj), &stackFramesData); diff --git a/src/coreclr/vm/eventtrace.cpp b/src/coreclr/vm/eventtrace.cpp index 79c3043a249..726205a15e7 100644 --- a/src/coreclr/vm/eventtrace.cpp +++ b/src/coreclr/vm/eventtrace.cpp @@ -1926,7 +1926,7 @@ VOID ETW::EnumerationLog::ModuleRangeRundown() TRACE_LEVEL_INFORMATION, CLR_PERFTRACK_PRIVATE_KEYWORD)) { - ETW::EnumerationLog::EnumerationHelper(NULL, NULL, ETW::EnumerationLog::EnumerationStructs::ModuleRangeLoadPrivate); + ETW::EnumerationLog::EnumerationHelper(NULL, ETW::EnumerationLog::EnumerationStructs::ModuleRangeLoadPrivate); } } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions); } @@ -2037,7 +2037,7 @@ VOID ETW::EnumerationLog::StartRundown() enumerationOptions |= ETW::EnumerationLog::EnumerationStructs::JittedMethodRichDebugInfo; } - ETW::EnumerationLog::EnumerationHelper(NULL, NULL, enumerationOptions); + ETW::EnumerationLog::EnumerationHelper(NULL, enumerationOptions); if (bIsThreadingRundownEnabled) { @@ -2124,9 +2124,8 @@ VOID ETW::EnumerationLog::EnumerateForCaptureState() { DWORD enumerationOptions = GetEnumerationOptionsFromRuntimeKeywords(); - // Send unload events for all remaining domains, including shared domain and - // default domain. - ETW::EnumerationLog::EnumerationHelper(NULL /* module filter */, NULL /* domain filter */, enumerationOptions); + // Send unload events for all remaining modules + ETW::EnumerationLog::EnumerationHelper(NULL /* module filter */, enumerationOptions); // Send thread created events for all currently active threads, if requested if (ETW_TRACING_CATEGORY_ENABLED(MICROSOFT_WINDOWS_DOTNETRUNTIME_PROVIDER_DOTNET_Context, @@ -2227,7 +2226,7 @@ VOID ETW::EnumerationLog::EndRundown() enumerationOptions |= ETW::EnumerationLog::EnumerationStructs::JittedMethodRichDebugInfo; } - ETW::EnumerationLog::EnumerationHelper(NULL, NULL, enumerationOptions); + ETW::EnumerationLog::EnumerationHelper(NULL, enumerationOptions); if (bIsThreadingRundownEnabled) { @@ -2964,7 +2963,7 @@ VOID ETW::ExceptionLog::ExceptionFilterEnd() /****************************************************************************/ /* This is called by the runtime when a domain is loaded */ /****************************************************************************/ -VOID ETW::LoaderLog::DomainLoadReal(BaseDomain *pDomain, _In_opt_ LPWSTR wszFriendlyName) +VOID ETW::LoaderLog::DomainLoadReal(_In_opt_ LPWSTR wszFriendlyName) { CONTRACTL { NOTHROW; @@ -2978,7 +2977,7 @@ VOID ETW::LoaderLog::DomainLoadReal(BaseDomain *pDomain, _In_opt_ LPWSTR wszFrie CLR_LOADER_KEYWORD)) { DWORD dwEventOptions = ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleLoad; - ETW::LoaderLog::SendDomainEvent(pDomain, dwEventOptions, wszFriendlyName); + ETW::LoaderLog::SendDomainEvent(dwEventOptions, wszFriendlyName); } } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions); } @@ -2986,7 +2985,7 @@ VOID ETW::LoaderLog::DomainLoadReal(BaseDomain *pDomain, _In_opt_ LPWSTR wszFrie /****************************************************************************/ /* This is called by the runtime when an AppDomain is unloaded */ /****************************************************************************/ -VOID ETW::LoaderLog::DomainUnload(AppDomain *pDomain) +VOID ETW::LoaderLog::DomainUnload() { CONTRACTL { NOTHROW; @@ -3009,7 +3008,7 @@ VOID ETW::LoaderLog::DomainUnload(AppDomain *pDomain) enumerationOptions |= ETW::EnumerationLog::EnumerationStructs::TypeUnload; } - ETW::EnumerationLog::EnumerationHelper(NULL, pDomain, enumerationOptions); + ETW::EnumerationLog::EnumerationHelper(NULL, enumerationOptions); } } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions); } @@ -3873,7 +3872,7 @@ VOID ETW::LoaderLog::ModuleLoad(Module *pModule, LONG liReportedSharedModule) if(bTraceFlagLoaderSet || bTraceFlagPerfTrackSet) ETW::LoaderLog::SendModuleEvent(pModule, ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleLoad | ETW::EnumerationLog::EnumerationStructs::ModuleRangeLoad); - ETW::EnumerationLog::EnumerationHelper(pModule, NULL, enumerationOptions); + ETW::EnumerationLog::EnumerationHelper(pModule, enumerationOptions); } // we want to report domainmodule events whenever they are loaded in any AppDomain @@ -3910,9 +3909,8 @@ VOID ETW::EnumerationLog::ProcessShutdown() { DWORD enumerationOptions = GetEnumerationOptionsFromRuntimeKeywords(); - // Send unload events for all remaining domains, including shared domain and - // default domain. - ETW::EnumerationLog::EnumerationHelper(NULL /* module filter */, NULL /* domain filter */, enumerationOptions); + // Send unload events for all remaining modules + ETW::EnumerationLog::EnumerationHelper(NULL /* module filter */, enumerationOptions); } } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions); } @@ -3926,20 +3924,20 @@ VOID ETW::EnumerationLog::ProcessShutdown() /****************************************************************************/ /* This routine is used to send a domain load/unload or rundown event */ /****************************************************************************/ -VOID ETW::LoaderLog::SendDomainEvent(BaseDomain *pBaseDomain, DWORD dwEventOptions, LPCWSTR wszFriendlyName) +VOID ETW::LoaderLog::SendDomainEvent(DWORD dwEventOptions, LPCWSTR wszFriendlyName) { CONTRACTL { THROWS; GC_TRIGGERS; + PRECONDITION(AppDomain::GetCurrentDomain() != NULL); } CONTRACTL_END; - if(!pBaseDomain) - return; + AppDomain* pDomain = AppDomain::GetCurrentDomain(); PCWSTR szDtraceOutput1=W(""); - BOOL bIsAppDomain = pBaseDomain->IsAppDomain(); + BOOL bIsAppDomain = TRUE; - ULONGLONG ullDomainId = (ULONGLONG)pBaseDomain; + ULONGLONG ullDomainId = (ULONGLONG)pDomain; ULONG ulDomainFlags = ETW::LoaderLog::LoaderStructs::DefaultDomain | ETW::LoaderLog::LoaderStructs::ExecutableDomain; LPCWSTR wsEmptyString = W(""); @@ -3949,7 +3947,7 @@ VOID ETW::LoaderLog::SendDomainEvent(BaseDomain *pBaseDomain, DWORD dwEventOptio if(wszFriendlyName) lpswzDomainName = (PWCHAR)wszFriendlyName; else - lpswzDomainName = (PWCHAR)pBaseDomain->AsAppDomain()->GetFriendlyName(); + lpswzDomainName = (PWCHAR)pDomain->GetFriendlyName(); /* prepare events args for ETW and ETM */ szDtraceOutput1 = (PCWSTR)lpswzDomainName; @@ -5238,12 +5236,9 @@ VOID ETW::MethodLog::SendEventsForJitMethodsHelper(LoaderAllocator *pLoaderAlloc /****************************************************************************/ /* This routine sends back method events of type 'dwEventOptions', for all JITed methods in either a given LoaderAllocator (if pLoaderAllocatorFilter is non NULL) - or in a given Domain (if pDomainFilter is non NULL) or for - all methods (if both filters are null) */ + or all methods (if pLoaderAllocatorFilter is null) */ /****************************************************************************/ -// Code review indicates this method is never called with both filters NULL. Ideally we would -// assert this and change the comment above, but given I am making a change late in the release I am being cautious -VOID ETW::MethodLog::SendEventsForJitMethods(BaseDomain *pDomainFilter, LoaderAllocator *pLoaderAllocatorFilter, DWORD dwEventOptions) +VOID ETW::MethodLog::SendEventsForJitMethods(BOOL getCodeVersionIds, LoaderAllocator *pLoaderAllocatorFilter, DWORD dwEventOptions) { CONTRACTL { NOTHROW; @@ -5303,9 +5298,8 @@ VOID ETW::MethodLog::SendEventsForJitMethods(BaseDomain *pDomainFilter, LoaderAl // table lock that corresponds to the domain or module we're currently iterating over. // - // We only support getting rejit IDs when filtering by domain. #ifdef FEATURE_CODE_VERSIONING - if (pDomainFilter) + if (getCodeVersionIds) { CodeVersionManager::LockHolder codeVersioningLockHolder; SendEventsForJitMethodsHelper( @@ -5337,21 +5331,24 @@ VOID ETW::MethodLog::SendEventsForJitMethods(BaseDomain *pDomainFilter, LoaderAl //--------------------------------------------------------------------------------------- // -// Wrapper around IterateDomain, which locks the AppDomain to be < -// STAGE_FINALIZED until the iteration is complete. +// This routine fires ETW events for +// Domain +// Assemblies in them +// Modules in them +// JIT methods in them +// R2R methods in them +// based on enumeration options // // Arguments: -// pAppDomain - AppDomain to iterate -// enumerationOptions - Flags indicating what to enumerate. Just passed -// straight through to IterateDomain +// enumerationOptions - Flags indicating what to enumerate. // -VOID ETW::EnumerationLog::IterateAppDomain(AppDomain * pAppDomain, DWORD enumerationOptions) +VOID ETW::EnumerationLog::IterateAppDomain(DWORD enumerationOptions) { CONTRACTL { THROWS; GC_TRIGGERS; - PRECONDITION(pAppDomain != NULL); + PRECONDITION(AppDomain::GetCurrentDomain() != NULL); } CONTRACTL_END; @@ -5359,65 +5356,32 @@ VOID ETW::EnumerationLog::IterateAppDomain(AppDomain * pAppDomain, DWORD enumera // ensure the App Domain does not get finalized until we're all done SystemDomain::LockHolder lh; - // Now it's safe to do the iteration - IterateDomain(pAppDomain, enumerationOptions); -} - -/********************************************************************************/ -/* This routine fires ETW events for - Domain, - Assemblies in them, - DomainModule's in them, - Modules in them, - JIT methods in them, - and the NGEN methods in them - based on enumerationOptions.*/ -/********************************************************************************/ -VOID ETW::EnumerationLog::IterateDomain(BaseDomain *pDomain, DWORD enumerationOptions) -{ - CONTRACTL { - THROWS; - GC_TRIGGERS; - PRECONDITION(pDomain != NULL); - } CONTRACTL_END; - -#if defined(_DEBUG) && !defined(DACCESS_COMPILE) - // Do not call IterateDomain() directly with an AppDomain. Use - // IterateAppDomain(), which wraps this function with a hold on the - // SystemDomain lock, which ensures pDomain's type data doesn't disappear - // on us. - if (pDomain->IsAppDomain()) - { - _ASSERTE(SystemDomain::IsUnderDomainLock()); - } -#endif // defined(_DEBUG) && !defined(DACCESS_COMPILE) - + AppDomain* pDomain = AppDomain::GetCurrentDomain(); EX_TRY { // DC Start events for Domain if(enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart) { - ETW::LoaderLog::SendDomainEvent(pDomain, enumerationOptions); + ETW::LoaderLog::SendDomainEvent(enumerationOptions); } // DC End or Unload Jit Method events if (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodUnloadOrDCEndAny) { - ETW::MethodLog::SendEventsForJitMethods(pDomain, NULL, enumerationOptions); + ETW::MethodLog::SendEventsForJitMethods(TRUE /*getCodeVersionIds*/, NULL, enumerationOptions); } - AppDomain::AssemblyIterator assemblyIterator = pDomain->AsAppDomain()->IterateAssembliesEx( + AppDomain::AssemblyIterator assemblyIterator = pDomain->IterateAssembliesEx( (AssemblyIterationFlags)(kIncludeLoaded | kIncludeExecution)); - CollectibleAssemblyHolder pDomainAssembly; - while (assemblyIterator.Next(pDomainAssembly.This())) + CollectibleAssemblyHolder pAssembly; + while (assemblyIterator.Next(pAssembly.This())) { - CollectibleAssemblyHolder pAssembly = pDomainAssembly->GetAssembly(); if (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCStart) { ETW::EnumerationLog::IterateAssembly(pAssembly, enumerationOptions); } - Module * pModule = pDomainAssembly->GetModule(); + Module * pModule = pAssembly->GetModule(); ETW::EnumerationLog::IterateModule(pModule, enumerationOptions); if((enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd) || @@ -5430,14 +5394,14 @@ VOID ETW::EnumerationLog::IterateDomain(BaseDomain *pDomain, DWORD enumerationOp // DC Start or Load Jit Method events if (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodLoadOrDCStartAny) { - ETW::MethodLog::SendEventsForJitMethods(pDomain, NULL, enumerationOptions); + ETW::MethodLog::SendEventsForJitMethods(TRUE /*getCodeVersionIds*/, NULL, enumerationOptions); } // DC End or Unload events for Domain if((enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleDCEnd) || (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::DomainAssemblyModuleUnload)) { - ETW::LoaderLog::SendDomainEvent(pDomain, enumerationOptions); + ETW::LoaderLog::SendDomainEvent(enumerationOptions); } } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions); } @@ -5465,7 +5429,7 @@ VOID ETW::EnumerationLog::IterateCollectibleLoaderAllocator(AssemblyLoaderAlloca // Unload Jit Method events if (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodUnload) { - ETW::MethodLog::SendEventsForJitMethods(NULL, pLoaderAllocator, enumerationOptions); + ETW::MethodLog::SendEventsForJitMethods(FALSE /*getCodeVersionIds*/, pLoaderAllocator, enumerationOptions); } // Iterate on all DomainAssembly loaded from the same AssemblyLoaderAllocator @@ -5488,7 +5452,7 @@ VOID ETW::EnumerationLog::IterateCollectibleLoaderAllocator(AssemblyLoaderAlloca // Load Jit Method events if (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodLoad) { - ETW::MethodLog::SendEventsForJitMethods(NULL, pLoaderAllocator, enumerationOptions); + ETW::MethodLog::SendEventsForJitMethods(FALSE /*getCodeVersionIds*/, pLoaderAllocator, enumerationOptions); } } EX_CATCH { } EX_END_CATCH(SwallowAllExceptions); } @@ -5593,17 +5557,12 @@ VOID ETW::EnumerationLog::IterateModule(Module *pModule, DWORD enumerationOption // // Arguments: // * moduleFilter - if non-NULL, events from only moduleFilter module are reported -// * domainFilter - if non-NULL, events from only domainFilter domain are reported // * enumerationOptions - Flags from ETW::EnumerationLog::EnumerationStructs which // describe which events should be sent. // -// Notes: -// * if all filter args are NULL, events from all domains are reported -// -// // static -VOID ETW::EnumerationLog::EnumerationHelper(Module *moduleFilter, BaseDomain *domainFilter, DWORD enumerationOptions) +VOID ETW::EnumerationLog::EnumerationHelper(Module *moduleFilter, DWORD enumerationOptions) { CONTRACTL { THROWS; @@ -5625,36 +5584,18 @@ VOID ETW::EnumerationLog::EnumerationHelper(Module *moduleFilter, BaseDomain *do // DC End or Unload Jit Method events from all Domains if (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodUnloadOrDCEndAny) { - ETW::MethodLog::SendEventsForJitMethods(NULL, NULL, enumerationOptions); + ETW::MethodLog::SendEventsForJitMethods(FALSE /*getCodeVersionIds*/, NULL, enumerationOptions); } // DC Start or Load Jit Method events from all Domains if (enumerationOptions & ETW::EnumerationLog::EnumerationStructs::JitMethodLoadOrDCStartAny) { - ETW::MethodLog::SendEventsForJitMethods(NULL, NULL, enumerationOptions); + ETW::MethodLog::SendEventsForJitMethods(FALSE /*getCodeVersionIds*/, NULL, enumerationOptions); } } else { - if(domainFilter) - { - if(domainFilter->IsAppDomain()) - { - ETW::EnumerationLog::IterateAppDomain(domainFilter->AsAppDomain(), enumerationOptions); - } - else - { - ETW::EnumerationLog::IterateDomain(domainFilter, enumerationOptions); - } - } - else - { - AppDomain *pDomain = AppDomain::GetCurrentDomain(); - if (pDomain != NULL) - { - ETW::EnumerationLog::IterateAppDomain(pDomain, enumerationOptions); - } - } + ETW::EnumerationLog::IterateAppDomain(enumerationOptions); } } diff --git a/src/coreclr/vm/eventtrace_bulktype.cpp b/src/coreclr/vm/eventtrace_bulktype.cpp index 934bb14fd7f..1cb9e212ce4 100644 --- a/src/coreclr/vm/eventtrace_bulktype.cpp +++ b/src/coreclr/vm/eventtrace_bulktype.cpp @@ -513,16 +513,15 @@ void BulkStaticsLogger::LogAllStatics() AppDomain *domain = ::GetAppDomain(); // There is only 1 AppDomain, so no iterator here. AppDomain::AssemblyIterator assemblyIter = domain->IterateAssembliesEx((AssemblyIterationFlags)(kIncludeLoaded|kIncludeExecution)); - CollectibleAssemblyHolder pDomainAssembly; - while (assemblyIter.Next(pDomainAssembly.This())) + CollectibleAssemblyHolder pAssembly; + while (assemblyIter.Next(pAssembly.This())) { // Make sure the assembly is loaded. - if (!pDomainAssembly->IsLoaded()) + if (!pAssembly->IsLoaded()) continue; - CollectibleAssemblyHolder pAssembly = pDomainAssembly->GetAssembly(); // Get the domain module from the module/appdomain pair. - Module *module = pDomainAssembly->GetModule(); + Module *module = pAssembly->GetModule(); if (module == NULL) continue; @@ -531,7 +530,7 @@ void BulkStaticsLogger::LogAllStatics() continue; // Ensure the module has fully loaded. - if (!domainAssembly->IsActive()) + if (!pAssembly->IsActive()) continue; // Now iterate all types with diff --git a/src/coreclr/vm/excep.cpp b/src/coreclr/vm/excep.cpp index 1942aab2d79..8418202b933 100644 --- a/src/coreclr/vm/excep.cpp +++ b/src/coreclr/vm/excep.cpp @@ -5705,9 +5705,6 @@ void AdjustContextForThreadStop(Thread* pThread, pThread->ResetThrowControlForThread(); - // Should never get here if we're already throwing an exception. - _ASSERTE(!pThread->IsExceptionInProgress() || pThread->IsRudeAbort()); - // Should never get here if we're already abort initiated. _ASSERTE(!pThread->IsAbortInitiated() || pThread->IsRudeAbort()); @@ -6363,6 +6360,11 @@ void FaultingExceptionFrame::Init(CONTEXT *pContext) m_ReturnAddress = ::GetIP(pContext); CopyOSContext(&m_ctx, pContext); #endif // !FEATURE_EH_FUNCLETS + +#if defined(TARGET_AMD64) && defined(TARGET_WINDOWS) + m_SSP = 0; +#endif + } // @@ -7504,7 +7506,7 @@ VOID DECLSPEC_NORETURN UnwindAndContinueRethrowHelperAfterCatch(Frame* pEntryFra } else { - DispatchManagedException(orThrowable, /* preserveStackTrace */ false); + DispatchManagedException(orThrowable); } } else diff --git a/src/coreclr/vm/exceptionhandling.cpp b/src/coreclr/vm/exceptionhandling.cpp index 191367f0a81..311f2434e23 100644 --- a/src/coreclr/vm/exceptionhandling.cpp +++ b/src/coreclr/vm/exceptionhandling.cpp @@ -970,7 +970,7 @@ ProcessCLRExceptionNew(IN PEXCEPTION_RECORD pExceptionRecord, else { OBJECTREF oref = ExceptionTracker::CreateThrowable(pExceptionRecord, FALSE); - DispatchManagedException(oref, pContextRecord, /* preserveStackTrace */ false); + DispatchManagedException(oref, pContextRecord); } } #endif // !HOST_UNIX @@ -5426,14 +5426,14 @@ BOOL IsSafeToCallExecutionManager() BOOL IsSafeToHandleHardwareException(PCONTEXT contextRecord, PEXCEPTION_RECORD exceptionRecord) { -#ifdef FEATURE_EMULATE_SINGLESTEP +#ifdef FEATURE_EMULATE_SINGLESTEP Thread *pThread = GetThreadNULLOk(); if (pThread && pThread->IsSingleStepEnabled() && exceptionRecord->ExceptionCode != STATUS_BREAKPOINT && exceptionRecord->ExceptionCode != STATUS_SINGLE_STEP && exceptionRecord->ExceptionCode != STATUS_STACK_OVERFLOW) { - // tried to consolidate the code and only call HandleSingleStep here but + // tried to consolidate the code and only call HandleSingleStep here but // for some reason not investigated the debugger tests failed with this change pThread->HandleSingleStep(contextRecord, exceptionRecord->ExceptionCode); } @@ -5649,7 +5649,7 @@ void FirstChanceExceptionNotification() #endif // TARGET_UNIX } -VOID DECLSPEC_NORETURN DispatchManagedException(OBJECTREF throwable, CONTEXT* pExceptionContext, bool preserveStackTrace) +VOID DECLSPEC_NORETURN DispatchManagedException(OBJECTREF throwable, CONTEXT* pExceptionContext) { STATIC_CONTRACT_THROWS; STATIC_CONTRACT_GC_TRIGGERS; @@ -5661,19 +5661,12 @@ VOID DECLSPEC_NORETURN DispatchManagedException(OBJECTREF throwable, CONTEXT* pE Thread *pThread = GetThread(); - if (preserveStackTrace) - { - pThread->IncPreventAbort(); - ExceptionPreserveStackTrace(throwable); - pThread->DecPreventAbort(); - } - ULONG_PTR hr = GetHRFromThrowable(throwable); EXCEPTION_RECORD exceptionRecord; exceptionRecord.ExceptionCode = EXCEPTION_COMPLUS; exceptionRecord.ExceptionFlags = EXCEPTION_NONCONTINUABLE | EXCEPTION_SOFTWARE_ORIGINATE; - exceptionRecord.ExceptionAddress = (void *)(void (*)(OBJECTREF, bool))&DispatchManagedException; + exceptionRecord.ExceptionAddress = (void *)(void (*)(OBJECTREF))&DispatchManagedException; exceptionRecord.NumberParameters = MarkAsThrownByUs(exceptionRecord.ExceptionInformation, hr); exceptionRecord.ExceptionRecord = NULL; @@ -5709,7 +5702,7 @@ VOID DECLSPEC_NORETURN DispatchManagedException(OBJECTREF throwable, CONTEXT* pE UNREACHABLE(); } -VOID DECLSPEC_NORETURN DispatchManagedException(OBJECTREF throwable, bool preserveStackTrace) +VOID DECLSPEC_NORETURN DispatchManagedException(OBJECTREF throwable) { STATIC_CONTRACT_THROWS; STATIC_CONTRACT_GC_TRIGGERS; @@ -5718,7 +5711,7 @@ VOID DECLSPEC_NORETURN DispatchManagedException(OBJECTREF throwable, bool preser CONTEXT exceptionContext; RtlCaptureContext(&exceptionContext); - DispatchManagedException(throwable, &exceptionContext, preserveStackTrace); + DispatchManagedException(throwable, &exceptionContext); UNREACHABLE(); } @@ -7691,7 +7684,7 @@ size_t GetSSPForFrameOnCurrentStack(TADDR ip) { size_t *targetSSP = (size_t *)_rdsspq(); // The SSP we search is pointing to the return address of the frame represented - // by the passed in IP. So we search for the instruction pointer from + // by the passed in IP. So we search for the instruction pointer from // the context and return one slot up from there. if (targetSSP != NULL) { @@ -7882,7 +7875,7 @@ extern "C" void * QCALLTYPE CallCatchFunclet(QCall::ObjectHandleOnStack exceptio pvRegDisplay->pCurrentContext->Lr = GetIP(pvRegDisplay->pCurrentContext); #elif defined(HOST_ARM) pvRegDisplay->pCurrentContext->Lr = GetIP(pvRegDisplay->pCurrentContext); -#elif defined(HOST_RISCV) || defined(HOST_LOONGARCH64) +#elif defined(HOST_RISCV64) || defined(HOST_LOONGARCH64) pvRegDisplay->pCurrentContext->Ra = GetIP(pvRegDisplay->pCurrentContext); #endif SetIP(pvRegDisplay->pCurrentContext, (PCODE)(void (*)(Object*))PropagateExceptionThroughNativeFrames); @@ -8439,7 +8432,12 @@ extern "C" bool QCALLTYPE SfiInit(StackFrameIterator* pThis, CONTEXT* pStackwalk // Get the SSP for the first managed frame. It is incremented during the stack walk so that // when we reach the handling frame, it contains correct SSP to set when resuming after // the catch handler. - pThis->m_crawl.GetRegisterSet()->SSP = GetSSPForFrameOnCurrentStack(controlPC); + // For hardware exceptions and thread abort exceptions propagated from ThrowControlForThread, + // the SSP is already known. For other cases, find it by scanning the shadow stack. + if ((pExInfo->m_passNumber == 2) && (pThis->m_crawl.GetRegisterSet()->SSP == 0)) + { + pThis->m_crawl.GetRegisterSet()->SSP = GetSSPForFrameOnCurrentStack(controlPC); + } #endif if (!pThis->m_crawl.HasFaulted() && !pThis->m_crawl.IsIPadjusted()) diff --git a/src/coreclr/vm/exceptionhandling.h b/src/coreclr/vm/exceptionhandling.h index 108856bec40..64e02a85e78 100644 --- a/src/coreclr/vm/exceptionhandling.h +++ b/src/coreclr/vm/exceptionhandling.h @@ -22,8 +22,8 @@ ProcessCLRException(IN PEXCEPTION_RECORD pExceptionRecord, IN OUT PT_CONTEXT pContextRecord, IN OUT PT_DISPATCHER_CONTEXT pDispatcherContext); -VOID DECLSPEC_NORETURN DispatchManagedException(OBJECTREF throwable, CONTEXT *pExceptionContext, bool preserveStackTrace = true); -VOID DECLSPEC_NORETURN DispatchManagedException(OBJECTREF throwable, bool preserveStackTrace = true); +VOID DECLSPEC_NORETURN DispatchManagedException(OBJECTREF throwable, CONTEXT *pExceptionContext); +VOID DECLSPEC_NORETURN DispatchManagedException(OBJECTREF throwable); VOID DECLSPEC_NORETURN DispatchManagedException(RuntimeExceptionKind reKind); enum CLRUnwindStatus { UnwindPending, FirstPassComplete, SecondPassComplete }; diff --git a/src/coreclr/vm/fcall.h b/src/coreclr/vm/fcall.h index c52a6d86872..a8b11854e79 100644 --- a/src/coreclr/vm/fcall.h +++ b/src/coreclr/vm/fcall.h @@ -151,7 +151,7 @@ // Also, initialize all the OBJECTREF's first. Like this: // // FCIMPL4(Object*, COMNlsInfo::nativeChangeCaseString, LocaleIDObject* localeUNSAFE, -// INT_PTR pNativeTextInfo, StringObject* pStringUNSAFE, CLR_BOOL bIsToUpper) +// INT_PTR pNativeTextInfo, StringObject* pStringUNSAFE, FC_BOOL_ARG bIsToUpper) // { // [ignoring CONTRACT for now] // struct _gc @@ -1335,7 +1335,10 @@ typedef UINT32 FC_UINT8_RET; typedef INT32 FC_INT16_RET; typedef UINT32 FC_UINT16_RET; +// Small primitive args are not widened. +typedef INT32 FC_BOOL_ARG; +#define FC_ACCESS_BOOL(x) ((BYTE)x != 0) // The fcall entrypoints has to be at unique addresses. Use this helper macro to make // the code of the fcalls unique if you get assert in ecall.cpp that mentions it. diff --git a/src/coreclr/vm/frames.h b/src/coreclr/vm/frames.h index 6d4535aa1ca..b225d3aac2e 100644 --- a/src/coreclr/vm/frames.h +++ b/src/coreclr/vm/frames.h @@ -1064,6 +1064,10 @@ class FaultingExceptionFrame : public Frame T_CONTEXT m_ctx; #endif // !FEATURE_EH_FUNCLETS +#ifdef TARGET_AMD64 + TADDR m_SSP; +#endif + VPTR_VTABLE_CLASS(FaultingExceptionFrame, Frame) public: @@ -1124,6 +1128,13 @@ class FaultingExceptionFrame : public Frame } #endif // FEATURE_EH_FUNCLETS +#ifdef TARGET_AMD64 + void SetSSP(TADDR value) + { + m_SSP = value; + } +#endif + virtual BOOL NeedsUpdateRegDisplay() { return TRUE; diff --git a/src/coreclr/vm/gcenv.ee.cpp b/src/coreclr/vm/gcenv.ee.cpp index 852c655cf95..fade8473fb3 100644 --- a/src/coreclr/vm/gcenv.ee.cpp +++ b/src/coreclr/vm/gcenv.ee.cpp @@ -1605,7 +1605,7 @@ uint32_t GCToEEInterface::GetTotalNumSizedRefHandles() { LIMITED_METHOD_CONTRACT; - return SystemDomain::System()->GetTotalNumSizedRefHandles(); + return 0; } NormalizedTimer analysisTimer; diff --git a/src/coreclr/vm/gchandleutilities.h b/src/coreclr/vm/gchandleutilities.h index 35613235660..ea1a826c9dd 100644 --- a/src/coreclr/vm/gchandleutilities.h +++ b/src/coreclr/vm/gchandleutilities.h @@ -126,23 +126,6 @@ inline OBJECTHANDLE CreateRefcountedHandle(IGCHandleStore* store, OBJECTREF obje return CreateHandleCommon(store, object, HNDTYPE_REFCOUNTED); } -inline OBJECTHANDLE CreateSizedRefHandle(IGCHandleStore* store, OBJECTREF object) -{ - return CreateHandleCommon(store, object, HNDTYPE_SIZEDREF); -} - -inline OBJECTHANDLE CreateSizedRefHandle(IGCHandleStore* store, OBJECTREF object, int heapToAffinitizeTo) -{ - OBJECTHANDLE hnd = store->CreateHandleOfType(OBJECTREFToObject(object), HNDTYPE_SIZEDREF, heapToAffinitizeTo); - if (!hnd) - { - COMPlusThrowOM(); - } - - DiagHandleCreated(hnd, object); - return hnd; -} - inline OBJECTHANDLE CreateDependentHandle(IGCHandleStore* store, OBJECTREF primary, OBJECTREF secondary) { OBJECTHANDLE hnd = store->CreateDependentHandle(OBJECTREFToObject(primary), OBJECTREFToObject(secondary)); diff --git a/src/coreclr/vm/gchelpers.cpp b/src/coreclr/vm/gchelpers.cpp index e9b0245867a..d69796f0104 100644 --- a/src/coreclr/vm/gchelpers.cpp +++ b/src/coreclr/vm/gchelpers.cpp @@ -402,7 +402,7 @@ OBJECTREF AllocateSzArray(MethodTable* pArrayMT, INT32 cElements, GC_ALLOC_FLAGS #endif #ifdef FEATURE_DOUBLE_ALIGNMENT_HINT - if ((pArrayMT->GetArrayElementType() == ELEMENT_TYPE_R8) && + if ((pArrayMT->GetArrayElementTypeHandle() == CoreLibBinder::GetElementType(ELEMENT_TYPE_R8)) && ((DWORD)cElements >= g_pConfig->GetDoubleArrayToLargeObjectHeapThreshold())) { STRESS_LOG2(LF_GC, LL_INFO10, "Allocating double MD array of size %d and length %d to large object heap\n", totalSize, cElements); @@ -425,7 +425,7 @@ OBJECTREF AllocateSzArray(MethodTable* pArrayMT, INT32 cElements, GC_ALLOC_FLAGS else { #ifdef FEATURE_DOUBLE_ALIGNMENT_HINT - if (pArrayMT->GetArrayElementType() == ELEMENT_TYPE_R8) + if (pArrayMT->GetArrayElementTypeHandle() == CoreLibBinder::GetElementType(ELEMENT_TYPE_R8)) { flags |= GC_ALLOC_ALIGN8; } @@ -497,7 +497,7 @@ OBJECTREF TryAllocateFrozenSzArray(MethodTable* pArrayMT, INT32 cElements) // FrozenObjectHeapManager doesn't yet support objects with a custom alignment, // so we give up on arrays of value types requiring 8 byte alignment on 32bit platforms. - if ((DATA_ALIGNMENT < sizeof(double)) && (pArrayMT->GetArrayElementType() == ELEMENT_TYPE_R8)) + if ((DATA_ALIGNMENT < sizeof(double)) && (pArrayMT->GetArrayElementTypeHandle() == CoreLibBinder::GetElementType(ELEMENT_TYPE_R8))) { return NULL; } @@ -665,7 +665,7 @@ OBJECTREF AllocateArrayEx(MethodTable *pArrayMT, INT32 *pArgs, DWORD dwNumArgs, #endif #ifdef FEATURE_DOUBLE_ALIGNMENT_HINT - if ((pArrayMT->GetArrayElementType() == ELEMENT_TYPE_R8) && + if ((pArrayMT->GetArrayElementTypeHandle() == CoreLibBinder::GetElementType(ELEMENT_TYPE_R8)) && (cElements >= g_pConfig->GetDoubleArrayToLargeObjectHeapThreshold())) { STRESS_LOG2(LF_GC, LL_INFO10, "Allocating double MD array of size %d and length %d to large object heap\n", totalSize, cElements); diff --git a/src/coreclr/vm/gcinfodecoder.cpp b/src/coreclr/vm/gcinfodecoder.cpp index 32c74bab8b4..097037fd812 100644 --- a/src/coreclr/vm/gcinfodecoder.cpp +++ b/src/coreclr/vm/gcinfodecoder.cpp @@ -1,7 +1,9 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +#ifndef SOS_INCLUDE #include "common.h" +#endif #include "gcinfodecoder.h" @@ -1802,7 +1804,7 @@ void GcInfoDecoder::ReportRegisterToGC( // ARM64 LOG((LF_GCROOTS, LL_INFO1000, "Reporting " FMT_REG, regNum )); OBJECTREF* pObjRef = GetRegisterSlot( regNum, pRD ); -#if defined(TARGET_UNIX) && !defined(FEATURE_NATIVEAOT) && !defined(SOS_TARGET_AMD64) +#if defined(TARGET_UNIX) && !defined(FEATURE_NATIVEAOT) && !defined(SOS_TARGET_ARM64) // On PAL, we don't always have the context pointers available due to // a limitation of an unwinding library. In such case, the context // pointers for some nonvolatile registers are NULL. @@ -1955,7 +1957,7 @@ void GcInfoDecoder::ReportRegisterToGC( LOG((LF_GCROOTS, LL_INFO1000, "Reporting " FMT_REG, regNum )); OBJECTREF* pObjRef = GetRegisterSlot( regNum, pRD ); -#if defined(TARGET_UNIX) && !defined(FEATURE_NATIVEAOT) && !defined(SOS_TARGET_AMD64) +#if defined(TARGET_UNIX) && !defined(FEATURE_NATIVEAOT) && !defined(SOS_TARGET_LOONGARCH64) // On PAL, we don't always have the context pointers available due to // a limitation of an unwinding library. In such case, the context @@ -1976,7 +1978,7 @@ void GcInfoDecoder::ReportRegisterToGC( gcFlags |= GC_CALL_PINNED; } -#endif // TARGET_UNIX && !SOS_TARGET_ARM64 +#endif // TARGET_UNIX && !SOS_TARGET_LOONGARCH64 #ifdef _DEBUG if(IsScratchRegister(regNum, pRD)) @@ -2093,7 +2095,7 @@ void GcInfoDecoder::ReportRegisterToGC( LOG((LF_GCROOTS, LL_INFO1000, "Reporting " FMT_REG, regNum )); OBJECTREF* pObjRef = GetRegisterSlot( regNum, pRD ); -#if defined(TARGET_UNIX) && !defined(FEATURE_NATIVEAOT) && !defined(SOS_TARGET_AMD64) +#if defined(TARGET_UNIX) && !defined(FEATURE_NATIVEAOT) && !defined(SOS_TARGET_RISCV64) // On PAL, we don't always have the context pointers available due to // a limitation of an unwinding library. In such case, the context @@ -2114,7 +2116,7 @@ void GcInfoDecoder::ReportRegisterToGC( gcFlags |= GC_CALL_PINNED; } -#endif // TARGET_UNIX && !SOS_TARGET_ARM64 +#endif // TARGET_UNIX && !SOS_TARGET_RISCV64 #ifdef _DEBUG if(IsScratchRegister(regNum, pRD)) diff --git a/src/coreclr/vm/gdbjit.h b/src/coreclr/vm/gdbjit.h index d0adbc9cee8..8a73ce52ba8 100644 --- a/src/coreclr/vm/gdbjit.h +++ b/src/coreclr/vm/gdbjit.h @@ -74,6 +74,7 @@ static constexpr const int CorElementTypeToDWEncoding[] = /* ELEMENT_TYPE_CMOD_REQD */ DW_ATE_address, /* ELEMENT_TYPE_CMOD_OPT */ DW_ATE_address, /* ELEMENT_TYPE_INTERNAL */ DW_ATE_address, +/* ELEMENT_TYPE_CMOD_INTERNAL */DW_ATE_address, /* ELEMENT_TYPE_MAX */ DW_ATE_address, }; diff --git a/src/coreclr/vm/genericdict.h b/src/coreclr/vm/genericdict.h index 277250fdae4..3fa28e0a9c9 100644 --- a/src/coreclr/vm/genericdict.h +++ b/src/coreclr/vm/genericdict.h @@ -45,7 +45,6 @@ class TypeHandleList; class Module; -class BaseDomain; class SigTypeContext; class SigBuilder; @@ -182,7 +181,7 @@ class DictionaryLayout class Dictionary { private: - // First N entries are generic instantiations arguments. + // First N entries are generic instantiations arguments. // The rest of the open array are normal pointers (no optional indirection) and may be NULL. DictionaryEntry m_pEntries[1]; diff --git a/src/coreclr/vm/genmeth.cpp b/src/coreclr/vm/genmeth.cpp index 64394585c8f..af6c53ee9d9 100644 --- a/src/coreclr/vm/genmeth.cpp +++ b/src/coreclr/vm/genmeth.cpp @@ -63,6 +63,7 @@ // Helper method that creates a method-desc off a template method desc static MethodDesc* CreateMethodDesc(LoaderAllocator *pAllocator, + Module* pLoaderModule, MethodTable *pMT, MethodDesc *pTemplateMD, DWORD classification, @@ -91,7 +92,8 @@ static MethodDesc* CreateMethodDesc(LoaderAllocator *pAllocator, TRUE /* fNonVtableSlot*/, fNativeCodeSlot, pMT, - pamTracker); + pamTracker, + pLoaderModule); // Now initialize the MDesc at the single method descriptor in // the new chunk @@ -415,6 +417,7 @@ InstantiatedMethodDesc::NewInstantiatedMethodDesc(MethodTable *pExactMT, // used in some of the subsequent setup methods for method descs. // pNewMD = (InstantiatedMethodDesc*) (CreateMethodDesc(pAllocator, + pExactMDLoaderModule, pExactMT, pGenericMDescInRepMT, mcInstantiated, @@ -894,6 +897,7 @@ MethodDesc::FindOrCreateAssociatedMethodDesc(MethodDesc* pDefMD, AllocMemTracker amt; pResultMD = CreateMethodDesc(pAllocator, + pLoaderModule, pRepMT, pMDescInCanonMT, mcInstantiated, @@ -975,6 +979,7 @@ MethodDesc::FindOrCreateAssociatedMethodDesc(MethodDesc* pDefMD, _ASSERTE(pDefMD->GetClassification() == mcInstantiated); pResultMD = CreateMethodDesc(pAllocator, + pLoaderModule, pExactMT, pNonUnboxingStub, mcInstantiated, diff --git a/src/coreclr/vm/i386/asmhelpers.asm b/src/coreclr/vm/i386/asmhelpers.asm index 07f6e8b955d..801de374073 100644 --- a/src/coreclr/vm/i386/asmhelpers.asm +++ b/src/coreclr/vm/i386/asmhelpers.asm @@ -40,7 +40,6 @@ EXTERN _NDirectImportWorker@4:PROC EXTERN _VarargPInvokeStubWorker@12:PROC EXTERN _GenericPInvokeCalliStubWorker@12:PROC -EXTERN _CallCopyConstructorsWorker@4:PROC EXTERN _PreStubWorker@8:PROC EXTERN _TheUMEntryPrestubWorker@4:PROC @@ -1006,29 +1005,6 @@ GoCallCalliWorker: _GenericPInvokeCalliHelper@0 endp -;========================================================================== -; This is small stub whose purpose is to record current stack pointer and -; call CallCopyConstructorsWorker to invoke copy constructors and destructors -; as appropriate. This stub operates on arguments already pushed to the -; stack by JITted IL stub and must not create a new frame, i.e. it must tail -; call to the target for it to see the arguments that copy ctors have been -; called on. -; -_CopyConstructorCallStub@0 proc public - ; there may be an argument in ecx - save it - push ecx - - ; push pointer to arguments - lea edx, [esp + 8] - push edx - - call _CallCopyConstructorsWorker@4 - - ; restore ecx and tail call to the target - pop ecx - jmp eax -_CopyConstructorCallStub@0 endp - ifdef FEATURE_COMINTEROP ;========================================================================== diff --git a/src/coreclr/vm/i386/cgencpu.h b/src/coreclr/vm/i386/cgencpu.h index 05013a50185..f5783f73503 100644 --- a/src/coreclr/vm/i386/cgencpu.h +++ b/src/coreclr/vm/i386/cgencpu.h @@ -29,7 +29,6 @@ class MethodDesc; class FramedMethodFrame; class Module; class ComCallMethodDesc; -class BaseDomain; // CPU-dependent functions Stub * GenerateInitPInvokeFrameHelper(); diff --git a/src/coreclr/vm/i386/cgenx86.cpp b/src/coreclr/vm/i386/cgenx86.cpp index 1738fd04905..878405e0db1 100644 --- a/src/coreclr/vm/i386/cgenx86.cpp +++ b/src/coreclr/vm/i386/cgenx86.cpp @@ -478,6 +478,10 @@ void FaultingExceptionFrame::UpdateRegDisplay(const PREGDISPLAY pRD, bool update memcpy(pRD->pCurrentContext, &m_ctx, sizeof(CONTEXT)); + // Clear the CONTEXT_XSTATE, since the REGDISPLAY contains just plain CONTEXT structure + // that cannot contain any extended state. + pRD->pCurrentContext->ContextFlags &= ~(CONTEXT_XSTATE & CONTEXT_AREA_MASK); + pRD->SP = m_ctx.Esp; pRD->ControlPC = m_ctx.Eip; diff --git a/src/coreclr/vm/i386/jitinterfacex86.cpp b/src/coreclr/vm/i386/jitinterfacex86.cpp index 0b6607aff6d..f643365aae5 100644 --- a/src/coreclr/vm/i386/jitinterfacex86.cpp +++ b/src/coreclr/vm/i386/jitinterfacex86.cpp @@ -96,25 +96,6 @@ extern "C" void STDCALL WriteBarrierAssert(BYTE* ptr, Object* obj) #endif // _DEBUG -FCDECL1(Object*, JIT_New, CORINFO_CLASS_HANDLE typeHnd_); - - -HCIMPL1(Object*, AllocObjectWrapper, MethodTable *pMT) -{ - CONTRACTL - { - FCALL_CHECK; - } - CONTRACTL_END; - - OBJECTREF newObj = NULL; - HELPER_METHOD_FRAME_BEGIN_RET_0(); // Set up a frame - newObj = AllocateObject(pMT); - HELPER_METHOD_FRAME_END(); - return OBJECTREFToObject(newObj); -} -HCIMPLEND - /*********************************************************************/ #ifndef UNIX_X86_ABI extern "C" void* g_TailCallFrameVptr; @@ -361,6 +342,8 @@ void JIT_TrialAlloc::EmitNoAllocCode(CPUSTUBLINKER *psl, Flags flags) } } +FCDECL1(Object*, JIT_New, CORINFO_CLASS_HANDLE typeHnd_); + void *JIT_TrialAlloc::GenAllocSFast(Flags flags) { STANDARD_VM_CONTRACT; diff --git a/src/coreclr/vm/ilmarshalers.cpp b/src/coreclr/vm/ilmarshalers.cpp index 75d979076bd..aa9b3d65315 100644 --- a/src/coreclr/vm/ilmarshalers.cpp +++ b/src/coreclr/vm/ilmarshalers.cpp @@ -1477,25 +1477,19 @@ LocalDesc ILOleColorMarshaler::GetManagedType() { STANDARD_VM_CONTRACT; - LoaderAllocator* pLoader = m_pargs->m_pMarshalInfo->GetModule()->GetLoaderAllocator(); - TypeHandle hndColorType = pLoader->GetMarshalingData()->GetOleColorMarshalingInfo()->GetColorType(); - // // value class // - return LocalDesc(hndColorType); // System.Drawing.Color + return LocalDesc(m_pargs->color.m_pColorType); } void ILOleColorMarshaler::EmitConvertContentsCLRToNative(ILCodeStream* pslILEmit) { STANDARD_VM_CONTRACT; - LoaderAllocator* pLoader = m_pargs->m_pMarshalInfo->GetModule()->GetLoaderAllocator(); - MethodDesc* pConvertMD = pLoader->GetMarshalingData()->GetOleColorMarshalingInfo()->GetSystemColorToOleColorMD(); - EmitLoadManagedValue(pslILEmit); - // int System.Drawing.ColorTranslator.ToOle(System.Drawing.Color c) - pslILEmit->EmitCALL(pslILEmit->GetToken(pConvertMD), 1, 1); + pslILEmit->EmitBOX(pslILEmit->GetToken(m_pargs->color.m_pColorType)); + pslILEmit->EmitCALL(METHOD__COLORMARSHALER__CONVERT_TO_NATIVE, 1, 1); EmitStoreNativeValue(pslILEmit); } @@ -1503,12 +1497,9 @@ void ILOleColorMarshaler::EmitConvertContentsNativeToCLR(ILCodeStream* pslILEmit { STANDARD_VM_CONTRACT; - LoaderAllocator* pLoader = m_pargs->m_pMarshalInfo->GetModule()->GetLoaderAllocator(); - MethodDesc* pConvertMD = pLoader->GetMarshalingData()->GetOleColorMarshalingInfo()->GetOleColorToSystemColorMD(); - EmitLoadNativeValue(pslILEmit); - // System.Drawing.Color System.Drawing.ColorTranslator.FromOle(int oleColor) - pslILEmit->EmitCALL(pslILEmit->GetToken(pConvertMD), 1, 1); + pslILEmit->EmitCALL(METHOD__COLORMARSHALER__CONVERT_TO_MANAGED, 1, 1); + pslILEmit->EmitUNBOX_ANY(pslILEmit->GetToken(m_pargs->color.m_pColorType)); EmitStoreManagedValue(pslILEmit); } @@ -2233,9 +2224,10 @@ void ILLayoutClassPtrMarshalerBase::EmitConvertSpaceNativeToCLR(ILCodeStream* ps pslILEmit->EmitBRFALSE(pNullRefLabel); pslILEmit->EmitLDTOKEN(pslILEmit->GetToken(m_pargs->m_pMT)); - pslILEmit->EmitCALL(METHOD__RT_TYPE_HANDLE__TO_INTPTR, 1, 1); - // static object AllocateInternal(IntPtr typeHandle); - pslILEmit->EmitCALL(METHOD__STUBHELPERS__ALLOCATE_INTERNAL, 1, 1); + // static Type Type.GetTypeFromHandle(RuntimeTypeHandle handle) + pslILEmit->EmitCALL(METHOD__TYPE__GET_TYPE_FROM_HANDLE, 1, 1); + // static object RuntimeHelpers.GetUninitializedObject(Type type) + pslILEmit->EmitCALL(METHOD__RUNTIME_HELPERS__GET_UNINITIALIZED_OBJECT, 1, 1); EmitStoreManagedValue(pslILEmit); pslILEmit->EmitLabel(pNullRefLabel); } @@ -2644,8 +2636,7 @@ MarshalerOverrideStatus ILHandleRefMarshaler::ArgumentOverride(NDirectStubLinker BOOL fManagedToNative, OverrideProcArgs* pargs, UINT* pResID, - UINT argidx, - UINT nativeStackOffset) + UINT argidx) { CONTRACTL { @@ -2737,8 +2728,7 @@ MarshalerOverrideStatus ILSafeHandleMarshaler::ArgumentOverride(NDirectStubLinke BOOL fManagedToNative, OverrideProcArgs* pargs, UINT* pResID, - UINT argidx, - UINT nativeStackOffset) + UINT argidx) { CONTRACTL { @@ -3095,8 +3085,7 @@ MarshalerOverrideStatus ILCriticalHandleMarshaler::ArgumentOverride(NDirectStubL BOOL fManagedToNative, OverrideProcArgs* pargs, UINT* pResID, - UINT argidx, - UINT nativeStackOffset) + UINT argidx) { CONTRACTL { @@ -3402,8 +3391,7 @@ MarshalerOverrideStatus ILBlittableValueClassWithCopyCtorMarshaler::ArgumentOver BOOL fManagedToNative, OverrideProcArgs* pargs, UINT* pResID, - UINT argidx, - UINT nativeStackOffset) + UINT argidx) { CONTRACTL { @@ -3424,75 +3412,40 @@ MarshalerOverrideStatus ILBlittableValueClassWithCopyCtorMarshaler::ArgumentOver if (fManagedToNative) { - // 1) create new native value type local - // 2) run new->CopyCtor(old) - // 3) run old->Dtor() - +#ifdef TARGET_X86 LocalDesc locDesc(pargs->mm.m_pMT); + pslIL->SetStubTargetArgType(&locDesc); // native type is the value type + locDesc.MakeByRef(); - DWORD dwNewValueTypeLocal; + locDesc.MakePinned(); + + DWORD dwPinnedArgLocal; // Step 1 - dwNewValueTypeLocal = pslIL->NewLocal(locDesc); + dwPinnedArgLocal = pslIL->NewLocal(locDesc); - // Step 2 - if (pargs->mm.m_pCopyCtor) - { - // Managed copy constructor has signature of CopyCtor(T* new, T old); - pslIL->EmitLDLOCA(dwNewValueTypeLocal); - pslIL->EmitLDARG(argidx); - pslIL->EmitCALL(pslIL->GetToken(pargs->mm.m_pCopyCtor), 2, 0); - } - else - { - pslIL->EmitLDARG(argidx); - pslIL->EmitLDOBJ(pslIL->GetToken(pargs->mm.m_pMT)); - pslIL->EmitSTLOC(dwNewValueTypeLocal); - } + pslIL->EmitLDARG(argidx); + pslIL->EmitSTLOC(dwPinnedArgLocal); - // Step 3 - if (pargs->mm.m_pDtor) - { - // Managed destructor has signature of Destructor(T old); - pslIL->EmitLDARG(argidx); - pslIL->EmitCALL(pslIL->GetToken(pargs->mm.m_pDtor), 1, 0); - } -#ifdef TARGET_X86 - pslIL->SetStubTargetArgType(&locDesc); // native type is the value type - pslILDispatch->EmitLDLOC(dwNewValueTypeLocal); // we load the local directly - - // Record this argument's stack slot in the copy constructor chain so we can correctly invoke the copy constructor. - DWORD ctorCookie = pslIL->NewLocal(CoreLibBinder::GetClass(CLASS__COPY_CONSTRUCTOR_COOKIE)); - pslIL->EmitLDLOCA(ctorCookie); - pslIL->EmitINITOBJ(pslIL->GetToken(CoreLibBinder::GetClass(CLASS__COPY_CONSTRUCTOR_COOKIE))); - pslIL->EmitLDLOCA(ctorCookie); - pslIL->EmitLDLOCA(dwNewValueTypeLocal); - pslIL->EmitSTFLD(pslIL->GetToken(CoreLibBinder::GetField(FIELD__COPY_CONSTRUCTOR_COOKIE__SOURCE))); - pslIL->EmitLDLOCA(ctorCookie); - pslIL->EmitLDC(nativeStackOffset); - pslIL->EmitSTFLD(pslIL->GetToken(CoreLibBinder::GetField(FIELD__COPY_CONSTRUCTOR_COOKIE__DESTINATION_OFFSET))); - - if (pargs->mm.m_pCopyCtor) - { - pslIL->EmitLDLOCA(ctorCookie); - pslIL->EmitLDFTN(pslIL->GetToken(pargs->mm.m_pCopyCtor)); - pslIL->EmitSTFLD(pslIL->GetToken(CoreLibBinder::GetField(FIELD__COPY_CONSTRUCTOR_COOKIE__COPY_CONSTRUCTOR))); - } + pslILDispatch->EmitLDARG(argidx); + pslILDispatch->EmitLDOBJ(pslIL->GetToken(pargs->mm.m_pMT)); +#else + LocalDesc locDesc(pargs->mm.m_pMT); - if (pargs->mm.m_pDtor) - { - pslIL->EmitLDLOCA(ctorCookie); - pslIL->EmitLDFTN(pslIL->GetToken(pargs->mm.m_pDtor)); - pslIL->EmitSTFLD(pslIL->GetToken(CoreLibBinder::GetField(FIELD__COPY_CONSTRUCTOR_COOKIE__DESTRUCTOR))); - } + locDesc.MakeByRef(); + locDesc.MakePinned(); - pslIL->EmitLDLOCA(psl->GetCopyCtorChainLocalNum()); - pslIL->EmitLDLOCA(ctorCookie); - pslIL->EmitCALL(METHOD__COPY_CONSTRUCTOR_CHAIN__ADD, 2, 0); + DWORD dwPinnedArgLocal; -#else - pslIL->SetStubTargetArgType(ELEMENT_TYPE_I); // native type is a pointer - EmitLoadNativeLocalAddrForByRefDispatch(pslILDispatch, dwNewValueTypeLocal); + // Step 1 + dwPinnedArgLocal = pslIL->NewLocal(locDesc); + + pslIL->EmitLDARG(argidx); + pslIL->EmitSTLOC(dwPinnedArgLocal); + + pslIL->SetStubTargetArgType(ELEMENT_TYPE_U); // native type is a pointer + pslILDispatch->EmitLDLOC(dwPinnedArgLocal); + pslILDispatch->EmitCONV_U(); #endif return OVERRIDDEN; @@ -3504,10 +3457,9 @@ MarshalerOverrideStatus ILBlittableValueClassWithCopyCtorMarshaler::ArgumentOver // but on other platforms it comes by-reference #ifdef TARGET_X86 LocalDesc locDesc(pargs->mm.m_pMT); + locDesc.AddModifier(true, pargs->mm.m_pSigMod); pslIL->SetStubTargetArgType(&locDesc); - DWORD dwNewValueTypeLocal; - dwNewValueTypeLocal = pslIL->NewLocal(locDesc); pslILDispatch->EmitLDARGA(argidx); #else LocalDesc locDesc(pargs->mm.m_pMT); @@ -3562,11 +3514,11 @@ void ILArgIteratorMarshaler::EmitConvertSpaceAndContentsCLRToNative(ILCodeStream pslILEmit->EmitLOCALLOC(); EmitStoreNativeValue(pslILEmit); - // void MarshalToUnmanagedVaListInternal(va_list, uint vaListSize, VARARGS* data) + // void MarshalToUnmanagedVaList(va_list, uint vaListSize, VARARGS* data) EmitLoadNativeValue(pslILEmit); pslILEmit->EmitLDLOC(dwVaListSizeLocal); EmitLoadManagedHomeAddr(pslILEmit); - pslILEmit->EmitCALL(METHOD__STUBHELPERS__MARSHAL_TO_UNMANAGED_VA_LIST_INTERNAL, 3, 0); + pslILEmit->EmitCALL(METHOD__STUBHELPERS__MARSHAL_TO_UNMANAGED_VA_LIST, 3, 0); } void ILArgIteratorMarshaler::EmitConvertContentsNativeToCLR(ILCodeStream* pslILEmit) @@ -3575,7 +3527,7 @@ void ILArgIteratorMarshaler::EmitConvertContentsNativeToCLR(ILCodeStream* pslILE EmitLoadManagedHomeAddr(pslILEmit); // void MarshalToManagedVaList(va_list va, VARARGS *dataout) - pslILEmit->EmitCALL(METHOD__STUBHELPERS__MARSHAL_TO_MANAGED_VA_LIST_INTERNAL, 2, 0); + pslILEmit->EmitCALL(METHOD__STUBHELPERS__MARSHAL_TO_MANAGED_VA_LIST, 2, 0); } LocalDesc ILArrayWithOffsetMarshaler::GetNativeType() @@ -4383,7 +4335,7 @@ extern "C" void QCALLTYPE MngdNativeArrayMarshaler_ConvertContentsToNative(MngdN if ( (!ClrSafeInt::multiply(cElements, OleVariant::GetElementSizeForVarType(pThis->m_vt, pThis->m_pElementMT), cElements)) || cElements > MAX_SIZE_FOR_INTEROP) COMPlusThrow(kArgumentException, IDS_EE_STRUCTARRAYTOOLARGE); - _ASSERTE(!GetTypeHandleForCVType(OleVariant::GetCVTypeForVarType(pThis->m_vt)).GetMethodTable()->ContainsGCPointers()); + _ASSERTE(!OleVariant::GetTypeHandleForVarType(pThis->m_vt).GetMethodTable()->ContainsGCPointers()); memcpyNoGCRefs(*pNativeHome, arrayRef->GetDataPtr(), cElements); } else @@ -4452,7 +4404,7 @@ extern "C" void QCALLTYPE MngdNativeArrayMarshaler_ConvertContentsToManaged(Mngd COMPlusThrow(kArgumentException, IDS_EE_STRUCTARRAYTOOLARGE); // If we are copying variants, strings, etc, we need to use write barrier - _ASSERTE(!GetTypeHandleForCVType(OleVariant::GetCVTypeForVarType(pThis->m_vt)).GetMethodTable()->ContainsGCPointers()); + _ASSERTE(!OleVariant::GetTypeHandleForVarType(pThis->m_vt).GetMethodTable()->ContainsGCPointers()); memcpyNoGCRefs(arrayRef->GetDataPtr(), *pNativeHome, cElements); } else @@ -4567,7 +4519,7 @@ extern "C" void QCALLTYPE MngdFixedArrayMarshaler_ConvertContentsToNative(MngdFi SIZE_T cElements = arrayRef->GetNumComponents(); if (pMarshaler == NULL || pMarshaler->ComToOleArray == NULL) { - _ASSERTE(!GetTypeHandleForCVType(OleVariant::GetCVTypeForVarType(pThis->m_vt)).GetMethodTable()->ContainsGCPointers()); + _ASSERTE(!OleVariant::GetTypeHandleForVarType(pThis->m_vt).GetMethodTable()->ContainsGCPointers()); memcpyNoGCRefs(pNativeHome, arrayRef->GetDataPtr(), nativeSize); } else @@ -4641,7 +4593,7 @@ extern "C" void QCALLTYPE MngdFixedArrayMarshaler_ConvertContentsToManaged(MngdF if (pMarshaler == NULL || pMarshaler->OleToComArray == NULL) { // If we are copying variants, strings, etc, we need to use write barrier - _ASSERTE(!GetTypeHandleForCVType(OleVariant::GetCVTypeForVarType(pThis->m_vt)).GetMethodTable()->ContainsGCPointers()); + _ASSERTE(!OleVariant::GetTypeHandleForVarType(pThis->m_vt).GetMethodTable()->ContainsGCPointers()); memcpyNoGCRefs(arrayRef->GetDataPtr(), pNativeHome, nativeSize); } else @@ -4974,7 +4926,7 @@ void ILReferenceCustomMarshaler::EmitCreateMngdMarshaler(ILCodeStream* pslILEmit m_dwMngdMarshalerLocalNum = pslILEmit->NewLocal(LocalDesc(CoreLibBinder::GetClass(CLASS__ICUSTOM_MARSHALER))); // - // call CreateCustomMarshalerHelper + // call CreateCustomMarshaler // pslILEmit->EmitLDTOKEN(pslILEmit->GetToken(m_pargs->rcm.m_pMD)); @@ -4985,10 +4937,7 @@ void ILReferenceCustomMarshaler::EmitCreateMngdMarshaler(ILCodeStream* pslILEmit pslILEmit->EmitLDTOKEN(pslILEmit->GetToken(TypeHandle::FromPtr(m_pargs->rcm.m_hndManagedType))); pslILEmit->EmitCALL(METHOD__RT_TYPE_HANDLE__TO_INTPTR, 1, 1); - pslILEmit->EmitCALL(METHOD__STUBHELPERS__CREATE_CUSTOM_MARSHALER_HELPER, 3, 1); // Create the CustomMarshalerHelper - - // Get the managed ICustomMarshaler object from the helper - pslILEmit->EmitCALL(METHOD__MNGD_REF_CUSTOM_MARSHALER__GET_MARSHALER, 1, 1); + pslILEmit->EmitCALL(METHOD__STUBHELPERS__CREATE_CUSTOM_MARSHALER, 3, 1); // Create the ICustomMarshaler pslILEmit->EmitSTLOC(m_dwMngdMarshalerLocalNum); // Store the ICustomMarshaler as our marshaler state } diff --git a/src/coreclr/vm/ilmarshalers.h b/src/coreclr/vm/ilmarshalers.h index 11c3983fc65..7f5dad6bb22 100644 --- a/src/coreclr/vm/ilmarshalers.h +++ b/src/coreclr/vm/ilmarshalers.h @@ -1490,8 +1490,7 @@ class ILMarshaler BOOL fManagedToNative, OverrideProcArgs* pargs, UINT* pResID, - UINT argidx, - UINT nativeStackOffset) + UINT argidx) { LIMITED_METHOD_CONTRACT; return HANDLEASNORMAL; @@ -2207,8 +2206,7 @@ class ILHandleRefMarshaler : public ILMarshaler BOOL fManagedToNative, OverrideProcArgs* pargs, UINT* pResID, - UINT argidx, - UINT nativeStackOffset); + UINT argidx); static MarshalerOverrideStatus ReturnOverride(NDirectStubLinker* psl, BOOL fManagedToNative, @@ -2248,8 +2246,7 @@ class ILSafeHandleMarshaler : public ILMarshaler BOOL fManagedToNative, OverrideProcArgs* pargs, UINT* pResID, - UINT argidx, - UINT nativeStackOffset); + UINT argidx); static MarshalerOverrideStatus ReturnOverride(NDirectStubLinker *psl, BOOL fManagedToNative, @@ -2292,8 +2289,7 @@ class ILCriticalHandleMarshaler : public ILMarshaler BOOL fManagedToNative, OverrideProcArgs* pargs, UINT* pResID, - UINT argidx, - UINT nativeStackOffset); + UINT argidx); static MarshalerOverrideStatus ReturnOverride(NDirectStubLinker *psl, BOOL fManagedToNative, @@ -2537,7 +2533,7 @@ class ILOleColorMarshaler : public ILMarshaler enum { c_fInOnly = TRUE, - c_nativeSize = sizeof(OLE_COLOR), + c_nativeSize = sizeof(uint32_t), }; protected: @@ -2952,8 +2948,7 @@ class ILBlittableValueClassWithCopyCtorMarshaler : public ILMarshaler BOOL fManagedToNative, OverrideProcArgs* pargs, UINT* pResID, - UINT argidx, - UINT nativeStackOffset); + UINT argidx); }; diff --git a/src/coreclr/vm/ilstubcache.cpp b/src/coreclr/vm/ilstubcache.cpp index cf97371eee3..9935471e7d5 100644 --- a/src/coreclr/vm/ilstubcache.cpp +++ b/src/coreclr/vm/ilstubcache.cpp @@ -55,7 +55,7 @@ void CreateModuleIndependentSignature(LoaderHeap* pCreationHeap, SigPointer sigPtr(pSig, cbSig); SigBuilder sigBuilder; - sigPtr.ConvertToInternalSignature(pSigModule, pTypeContext, &sigBuilder); + sigPtr.ConvertToInternalSignature(pSigModule, pTypeContext, &sigBuilder, /* bSkipCustomModifier */ FALSE); DWORD cbNewSig; PVOID pConvertedSig = sigBuilder.GetSignature(&cbNewSig); @@ -447,9 +447,9 @@ MethodDesc* ILStubCache::InsertStubMethodDesc(MethodDesc *pMD, ILStubHashBlob* p // // JIT'ed IL stubs // -// - The ILStubCache is per-BaseDomain +// - The ILStubCache is per-LoaderAllocator // -// - Each BaseDomain's ILStubCache will lazily create a "minimal MethodTable" to +// - Each LoaderAllocator's ILStubCache will lazily create a "minimal MethodTable" to // serve as the home for IL stub MethodDescs // // - The created MethodTables will use the Module belonging to one of the @@ -463,10 +463,7 @@ MethodDesc* ILStubCache::InsertStubMethodDesc(MethodDesc *pMD, ILStubHashBlob* p // // It's important to point out that the Module we latch onto here has no knowledge // of the MethodTable that we've just "added" to it. There only exists a "back -// pointer" to the Module from the MethodTable itself. So we're really only using -// that module to answer the question of what BaseDomain the MethodTable lives in. -// So as long as the BaseDomain for that module is the same as the BaseDomain the -// ILStubCache lives in, I think we have a fairly consistent story here. +// pointer" to the Module from the MethodTable itself. // // We're relying on the fact that a VASigCookie may only mention types within the // corresponding module used to qualify the signature and the fact that interop @@ -475,14 +472,7 @@ MethodDesc* ILStubCache::InsertStubMethodDesc(MethodDesc *pMD, ILStubHashBlob* p // ELEMENT_TYPE_INTERNAL, which may refer to any type. // // We can only access E_T_INTERNAL through LCG, which does not permit referring -// to types in other BaseDomains. -// -// -// Places for improvement: -// -// - allow NGEN'ing of CALLI pinvoke and vararg pinvoke -// -// - pre-populate the per-BaseDomain cache with IL stubs from NGEN'ed image +// to types in other AppDomains. // MethodDesc* ILStubCache::GetStubMethodDesc( diff --git a/src/coreclr/vm/ilstubresolver.cpp b/src/coreclr/vm/ilstubresolver.cpp index 980d62032a4..7e2786baa9d 100644 --- a/src/coreclr/vm/ilstubresolver.cpp +++ b/src/coreclr/vm/ilstubresolver.cpp @@ -546,4 +546,4 @@ void ILStubResolver::StubGenFailed(ILStubResolver* pResolver) } pResolver->ClearCompileTimeState(ILNotYetGenerated); -} +} \ No newline at end of file diff --git a/src/coreclr/vm/instmethhash.h b/src/coreclr/vm/instmethhash.h index 153bbe47408..e7844088637 100644 --- a/src/coreclr/vm/instmethhash.h +++ b/src/coreclr/vm/instmethhash.h @@ -26,7 +26,7 @@ class AllocMemTracker; // Each persisted Module has an InstMethodHashTable used for such methods that // were ngen'ed into that module. See ceeload.hpp for more information about ngen modules. // -// Methods created at runtime are placed in an InstMethHashTable in BaseDomain. +// Methods created at runtime are placed in an InstMethHashTable in Module. // // Keys are always derivable from the data stored in the table (MethodDesc) // diff --git a/src/coreclr/vm/interoputil.cpp b/src/coreclr/vm/interoputil.cpp index a96ced9828d..15f9e5b1ece 100644 --- a/src/coreclr/vm/interoputil.cpp +++ b/src/coreclr/vm/interoputil.cpp @@ -2187,10 +2187,9 @@ void GetComSourceInterfacesForClass(MethodTable *pMT, CQuickArray } } - //-------------------------------------------------------------------------------- -// These methods convert a native IEnumVARIANT to a managed IEnumerator. -OBJECTREF ConvertEnumVariantToMngEnum(IEnumVARIANT *pNativeEnum) +// This method converts an OLE_COLOR to a boxed Color object. +void ConvertOleColorToSystemColor(OLE_COLOR SrcOleColor, OBJECTREF *pDestSysColor) { CONTRACTL { @@ -2200,33 +2199,19 @@ OBJECTREF ConvertEnumVariantToMngEnum(IEnumVARIANT *pNativeEnum) } CONTRACTL_END; - OBJECTREF MngEnum = NULL; - OBJECTREF EnumeratorToEnumVariantMarshaler = NULL; - GCPROTECT_BEGIN(EnumeratorToEnumVariantMarshaler) - { - // Retrieve the custom marshaler and the MD to use to convert the IEnumVARIANT. - StdMngIEnumerator *pStdMngIEnumInfo = SystemDomain::GetCurrentDomain()->GetMngStdInterfacesInfo()->GetStdMngIEnumerator(); - MethodDesc *pEnumNativeToManagedMD = pStdMngIEnumInfo->GetCustomMarshalerMD(CustomMarshalerMethods_MarshalNativeToManaged); - EnumeratorToEnumVariantMarshaler = pStdMngIEnumInfo->GetCustomMarshaler(); - MethodDescCallSite enumNativeToManaged(pEnumNativeToManagedMD, &EnumeratorToEnumVariantMarshaler); + MethodDescCallSite oleColorToSystemColor(METHOD__COLORMARSHALER__CONVERT_TO_MANAGED); - // Prepare the arguments that will be passed to MarshalNativeToManaged. - ARG_SLOT MarshalNativeToManagedArgs[] = { - ObjToArgSlot(EnumeratorToEnumVariantMarshaler), - (ARG_SLOT)pNativeEnum - }; - - // Retrieve the managed view for the current native interface pointer. - MngEnum = enumNativeToManaged.Call_RetOBJECTREF(MarshalNativeToManagedArgs); - } - GCPROTECT_END(); + ARG_SLOT Args[] = + { + PtrToArgSlot(&SrcOleColor) + }; - return MngEnum; + *pDestSysColor = oleColorToSystemColor.Call_RetOBJECTREF(Args); } //-------------------------------------------------------------------------------- -// This method converts an OLE_COLOR to a System.Color. -void ConvertOleColorToSystemColor(OLE_COLOR SrcOleColor, SYSTEMCOLOR *pDestSysColor) +// This method converts a System.Color to an OLE_COLOR. +OLE_COLOR ConvertSystemColorToOleColor(OBJECTREF *pSrcObj) { CONTRACTL { @@ -2236,43 +2221,24 @@ void ConvertOleColorToSystemColor(OLE_COLOR SrcOleColor, SYSTEMCOLOR *pDestSysCo } CONTRACTL_END; - // Retrieve the method desc to use for the current AD. - MethodDesc *pOleColorToSystemColorMD = - GetAppDomain()->GetLoaderAllocator()->GetMarshalingData()->GetOleColorMarshalingInfo()->GetOleColorToSystemColorMD(); + OLE_COLOR result; + OBJECTREF sysColor = NULL; + + GCPROTECT_BEGIN(sysColor); - MethodDescCallSite oleColorToSystemColor(pOleColorToSystemColorMD); + sysColor = *pSrcObj; - _ASSERTE(pOleColorToSystemColorMD->HasRetBuffArg()); + MethodDescCallSite sysColorToOleColor(METHOD__COLORMARSHALER__CONVERT_TO_NATIVE); ARG_SLOT Args[] = { - PtrToArgSlot(pDestSysColor), - PtrToArgSlot(SrcOleColor) + ObjToArgSlot(sysColor) }; - oleColorToSystemColor.Call(Args); -} + result = (OLE_COLOR)sysColorToOleColor.Call_RetI4(Args); -//-------------------------------------------------------------------------------- -// This method converts a System.Color to an OLE_COLOR. -OLE_COLOR ConvertSystemColorToOleColor(OBJECTREF *pSrcObj) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; - } - CONTRACTL_END; - - // Retrieve the method desc to use for the current AD. - MethodDesc *pSystemColorToOleColorMD = - GetAppDomain()->GetLoaderAllocator()->GetMarshalingData()->GetOleColorMarshalingInfo()->GetSystemColorToOleColorMD(); - MethodDescCallSite systemColorToOleColor(pSystemColorToOleColorMD); - - // Set up the args and call the method. - SYSTEMCOLOR *pSrcSysColor = (SYSTEMCOLOR *)(*pSrcObj)->UnBox(); - return systemColorToOleColor.CallWithValueTypes_RetOleColor((const ARG_SLOT *)&pSrcSysColor); + GCPROTECT_END(); + return result; } //-------------------------------------------------------------------------------- @@ -3042,7 +3008,27 @@ class DispParamHolder : public Wrapper &rItfList); //-------------------------------------------------------------------------------- -// This methods converts an IEnumVARIANT to a managed IEnumerator. -OBJECTREF ConvertEnumVariantToMngEnum(IEnumVARIANT *pNativeEnum); - -//-------------------------------------------------------------------------------- -// These methods convert an OLE_COLOR to a System.Color and vice versa. -void ConvertOleColorToSystemColor(OLE_COLOR SrcOleColor, SYSTEMCOLOR *pDestSysColor); -OLE_COLOR ConvertSystemColorToOleColor(SYSTEMCOLOR *pSrcSysColor); +// These methods convert an OLE_COLOR to a boxed Color object and vice versa. +void ConvertOleColorToSystemColor(OLE_COLOR SrcOleColor, OBJECTREF *pDestSysColor); OLE_COLOR ConvertSystemColorToOleColor(OBJECTREF *pSrcObj); //-------------------------------------------------------------------------------- @@ -392,9 +370,6 @@ VOID EnsureComStarted(BOOL fCoInitCurrentThread = TRUE); IUnknown* MarshalObjectToInterface(OBJECTREF* ppObject, MethodTable* pItfMT, MethodTable* pClassMT, DWORD dwFlags); void UnmarshalObjectFromInterface(OBJECTREF *ppObjectDest, IUnknown **ppUnkSrc, MethodTable *pItfMT, MethodTable *pClassMT, DWORD dwFlags); - -#define DEFINE_ASM_QUAL_TYPE_NAME(varname, typename, asmname) static const char varname##[] = { typename##", "##asmname## }; - #else // FEATURE_COMINTEROP inline HRESULT EnsureComStartedNoThrow() { diff --git a/src/coreclr/vm/jithelpers.cpp b/src/coreclr/vm/jithelpers.cpp index b365309257d..5777d7feea5 100644 --- a/src/coreclr/vm/jithelpers.cpp +++ b/src/coreclr/vm/jithelpers.cpp @@ -901,6 +901,12 @@ HCIMPL1(void*, JIT_GetNonGCThreadStaticBaseOptimized, UINT32 staticBlockIndex) FCALL_CONTRACT; + staticBlock = GetThreadLocalStaticBaseIfExistsAndInitialized(staticBlockIndex); + if (staticBlock != NULL) + { + return staticBlock; + } + HELPER_METHOD_FRAME_BEGIN_RET_0(); // Set up a frame TLSIndex tlsIndex(staticBlockIndex); // Check if the class constructor needs to be run @@ -975,6 +981,12 @@ HCIMPL1(void*, JIT_GetGCThreadStaticBaseOptimized, UINT32 staticBlockIndex) FCALL_CONTRACT; + staticBlock = GetThreadLocalStaticBaseIfExistsAndInitialized(staticBlockIndex); + if (staticBlock != NULL) + { + return staticBlock; + } + HELPER_METHOD_FRAME_BEGIN_RET_0(); // Set up a frame TLSIndex tlsIndex(staticBlockIndex); @@ -1080,35 +1092,6 @@ BOOL ObjIsInstanceOfCore(Object *pObject, TypeHandle toTypeHnd, BOOL throwCastEx } else #endif // FEATURE_COMINTEROP -#ifdef FEATURE_ICASTABLE - // If type implements ICastable interface we give it a chance to tell us if it can be casted - // to a given type. - if (pMT->IsICastable()) - { - // Make actual call to ICastableHelpers.IsInstanceOfInterface(obj, interfaceTypeObj, out exception) - OBJECTREF exception = NULL; - GCPROTECT_BEGIN(exception); - - PREPARE_NONVIRTUAL_CALLSITE(METHOD__ICASTABLEHELPERS__ISINSTANCEOF); - - OBJECTREF managedType = toTypeHnd.GetManagedClassObject(); //GC triggers - - DECLARE_ARGHOLDER_ARRAY(args, 3); - args[ARGNUM_0] = OBJECTREF_TO_ARGHOLDER(obj); - args[ARGNUM_1] = OBJECTREF_TO_ARGHOLDER(managedType); - args[ARGNUM_2] = PTR_TO_ARGHOLDER(&exception); - - CALL_MANAGED_METHOD(fCast, BOOL, args); - INDEBUG(managedType = NULL); // managedType isn't protected during the call - - if (!fCast && throwCastException && exception != NULL) - { - RealCOMPlusThrow(exception); - } - GCPROTECT_END(); //exception - } - else -#endif // FEATURE_ICASTABLE if (pMT->IsIDynamicInterfaceCastable()) { fCast = DynamicInterfaceCastable::IsInstanceOf(&obj, toTypeHnd, throwCastException); @@ -2288,26 +2271,6 @@ HCIMPL2(CORINFO_GENERIC_HANDLE, JIT_GenericHandleMethodWithSlotAndModule, CORINF HCIMPLEND #include -/*********************************************************************/ -HCIMPL2(CORINFO_GENERIC_HANDLE, JIT_GenericHandleMethodLogging, CORINFO_METHOD_HANDLE methodHnd, LPVOID signature) -{ - CONTRACTL { - FCALL_CHECK; - PRECONDITION(CheckPointer(methodHnd)); - PRECONDITION(CheckPointer(signature)); - } CONTRACTL_END; - - JitGenericHandleCacheKey key(NULL, methodHnd, signature); - HashDatum res; - if (g_pJitGenericHandleCache->GetValueSpeculative(&key,&res)) - return (CORINFO_GENERIC_HANDLE) (DictionaryEntry) res; - - // Tailcall to the slow helper - ENDFORBIDGC(); - return HCCALL5(JIT_GenericHandle_Framed, NULL, methodHnd, signature, -1, NULL); -} -HCIMPLEND - /*********************************************************************/ #include HCIMPL2(CORINFO_GENERIC_HANDLE, JIT_GenericHandleClass, CORINFO_CLASS_HANDLE classHnd, LPVOID signature) @@ -2349,26 +2312,6 @@ HCIMPL2(CORINFO_GENERIC_HANDLE, JIT_GenericHandleClassWithSlotAndModule, CORINFO HCIMPLEND #include -/*********************************************************************/ -HCIMPL2(CORINFO_GENERIC_HANDLE, JIT_GenericHandleClassLogging, CORINFO_CLASS_HANDLE classHnd, LPVOID signature) -{ - CONTRACTL { - FCALL_CHECK; - PRECONDITION(CheckPointer(classHnd)); - PRECONDITION(CheckPointer(signature)); - } CONTRACTL_END; - - JitGenericHandleCacheKey key(classHnd, NULL, signature); - HashDatum res; - if (g_pJitGenericHandleCache->GetValueSpeculative(&key,&res)) - return (CORINFO_GENERIC_HANDLE) (DictionaryEntry) res; - - // Tailcall to the slow helper - ENDFORBIDGC(); - return HCCALL5(JIT_GenericHandle_Framed, classHnd, NULL, signature, -1, NULL); -} -HCIMPLEND - /*********************************************************************/ // Resolve a virtual method at run-time, either because of // aggressive backpatching or because the call is to a generic @@ -3060,7 +3003,7 @@ void ThrowNew(OBJECTREF oref) } } - DispatchManagedException(oref, /* preserveStackTrace */ false); + DispatchManagedException(oref); } #endif // FEATURE_EH_FUNCLETS @@ -3486,15 +3429,6 @@ HRESULT EEToProfInterfaceImpl::SetEnterLeaveFunctionHooksForJit(FunctionEnter3 * } #endif // PROFILING_SUPPORTED -/*************************************************************/ -HCIMPL1(void, JIT_LogMethodEnter, CORINFO_METHOD_HANDLE methHnd_) - FCALL_CONTRACT; - - // - // Record an access to this method desc - // - -HCIMPLEND diff --git a/src/coreclr/vm/jitinterface.cpp b/src/coreclr/vm/jitinterface.cpp index edabdbc3d43..9e265926481 100644 --- a/src/coreclr/vm/jitinterface.cpp +++ b/src/coreclr/vm/jitinterface.cpp @@ -106,27 +106,27 @@ int64_t AtomicLoad64WithoutTearing(int64_t volatile *valueRef) #endif // TARGET_64BIT } -FCIMPL1(INT64, GetCompiledILBytes, CLR_BOOL currentThread) +FCIMPL1(INT64, GetCompiledILBytes, FC_BOOL_ARG currentThread) { FCALL_CONTRACT; - return currentThread ? t_cbILJittedForThread : AtomicLoad64WithoutTearing(&g_cbILJitted); + return FC_ACCESS_BOOL(currentThread) ? t_cbILJittedForThread : AtomicLoad64WithoutTearing(&g_cbILJitted); } FCIMPLEND -FCIMPL1(INT64, GetCompiledMethodCount, CLR_BOOL currentThread) +FCIMPL1(INT64, GetCompiledMethodCount, FC_BOOL_ARG currentThread) { FCALL_CONTRACT; - return currentThread ? t_cMethodsJittedForThread : AtomicLoad64WithoutTearing(&g_cMethodsJitted); + return FC_ACCESS_BOOL(currentThread) ? t_cMethodsJittedForThread : AtomicLoad64WithoutTearing(&g_cMethodsJitted); } FCIMPLEND -FCIMPL1(INT64, GetCompilationTimeInTicks, CLR_BOOL currentThread) +FCIMPL1(INT64, GetCompilationTimeInTicks, FC_BOOL_ARG currentThread) { FCALL_CONTRACT; - return currentThread ? t_c100nsTicksInJitForThread : AtomicLoad64WithoutTearing(&g_c100nsTicksInJit); + return FC_ACCESS_BOOL(currentThread) ? t_c100nsTicksInJitForThread : AtomicLoad64WithoutTearing(&g_c100nsTicksInJit); } FCIMPLEND @@ -391,6 +391,7 @@ CorInfoType CEEInfo::asCorInfoType(CorElementType eeType, CORINFO_TYPE_UNDEF, // CMOD_REQD CORINFO_TYPE_UNDEF, // CMOD_OPT CORINFO_TYPE_UNDEF, // INTERNAL + CORINFO_TYPE_UNDEF, // CMOD_INTERNAL }; _ASSERTE(sizeof(map) == ELEMENT_TYPE_MAX); @@ -2974,8 +2975,6 @@ void CEEInfo::ComputeRuntimeLookupForSharedGenericToken(DictionaryEntryKind entr if (!pContextMD->IsSharedByGenericInstantiations()) COMPlusThrow(kInvalidProgramException); - BOOL fInstrument = FALSE; - if (pContextMD->RequiresInstMethodDescArg()) { pResultLookup->lookupKind.runtimeLookupKind = CORINFO_LOOKUP_METHODPARAM; @@ -2991,10 +2990,7 @@ void CEEInfo::ComputeRuntimeLookupForSharedGenericToken(DictionaryEntryKind entr // If we've got a method type parameter of any kind then we must look in the method desc arg if (pContextMD->RequiresInstMethodDescArg()) { - pResult->helper = fInstrument ? CORINFO_HELP_RUNTIMEHANDLE_METHOD_LOG : CORINFO_HELP_RUNTIMEHANDLE_METHOD; - - if (fInstrument) - goto NoSpecialCase; + pResult->helper = CORINFO_HELP_RUNTIMEHANDLE_METHOD; // Special cases: // (1) Naked method type variable: look up directly in instantiation hanging off runtime md @@ -3059,18 +3055,15 @@ void CEEInfo::ComputeRuntimeLookupForSharedGenericToken(DictionaryEntryKind entr if (pContextMD->RequiresInstMethodTableArg()) { // If we've got a vtable extra argument, go through that - pResult->helper = fInstrument ? CORINFO_HELP_RUNTIMEHANDLE_CLASS_LOG : CORINFO_HELP_RUNTIMEHANDLE_CLASS; + pResult->helper = CORINFO_HELP_RUNTIMEHANDLE_CLASS; } // If we've got an object, go through its vtable else { _ASSERTE(pContextMD->AcquiresInstMethodTableFromThis()); - pResult->helper = fInstrument ? CORINFO_HELP_RUNTIMEHANDLE_CLASS_LOG : CORINFO_HELP_RUNTIMEHANDLE_CLASS; + pResult->helper = CORINFO_HELP_RUNTIMEHANDLE_CLASS; } - if (fInstrument) - goto NoSpecialCase; - // Special cases: // (1) Naked class type variable: look up directly in instantiation hanging off vtable // (2) C where C is the context's class and C is sealed: just return vtable ptr @@ -3483,49 +3476,7 @@ size_t CEEInfo::printClassName(CORINFO_CLASS_HANDLE cls, char* buffer, size_t bu } /*********************************************************************/ -CORINFO_MODULE_HANDLE CEEInfo::getClassModule(CORINFO_CLASS_HANDLE clsHnd) -{ - CONTRACTL { - NOTHROW; - GC_NOTRIGGER; - MODE_PREEMPTIVE; - } CONTRACTL_END; - - CORINFO_MODULE_HANDLE result = NULL; - - JIT_TO_EE_TRANSITION_LEAF(); - - TypeHandle VMClsHnd(clsHnd); - - result = CORINFO_MODULE_HANDLE(VMClsHnd.GetModule()); - - EE_TO_JIT_TRANSITION_LEAF(); - - return result; -} - -/*********************************************************************/ -CORINFO_ASSEMBLY_HANDLE CEEInfo::getModuleAssembly(CORINFO_MODULE_HANDLE modHnd) -{ - CONTRACTL { - NOTHROW; - GC_NOTRIGGER; - MODE_PREEMPTIVE; - } CONTRACTL_END; - - CORINFO_ASSEMBLY_HANDLE result = NULL; - - JIT_TO_EE_TRANSITION_LEAF(); - - result = CORINFO_ASSEMBLY_HANDLE(GetModule(modHnd)->GetAssembly()); - - EE_TO_JIT_TRANSITION_LEAF(); - - return result; -} - -/*********************************************************************/ -const char* CEEInfo::getAssemblyName(CORINFO_ASSEMBLY_HANDLE asmHnd) +const char* CEEInfo::getClassAssemblyName(CORINFO_CLASS_HANDLE clsHnd) { CONTRACTL { THROWS; @@ -3533,10 +3484,11 @@ const char* CEEInfo::getAssemblyName(CORINFO_ASSEMBLY_HANDLE asmHnd) MODE_PREEMPTIVE; } CONTRACTL_END; - const char* result = NULL; + const char* result = NULL; JIT_TO_EE_TRANSITION(); - result = ((Assembly*)asmHnd)->GetSimpleName(); + TypeHandle th(clsHnd); + result = th.GetAssembly()->GetSimpleName(); EE_TO_JIT_TRANSITION(); return result; @@ -3743,18 +3695,8 @@ uint32_t CEEInfo::getClassAttribsInternal (CORINFO_CLASS_HANDLE clsHnd) if (pMT->IsByRefLike()) ret |= CORINFO_FLG_BYREF_LIKE; - // In Reverse P/Invoke stubs, we are generating the code - // and we are not generating the code patterns that the GS checks - // are meant to catch. - // As a result, we can skip setting this flag. - // We do this as the GS checks (emitted when this flag is set) - // can break C++/CLI's copy-constructor semantics by missing copies. - if (pClass->IsUnsafeValueClass() - && !(m_pMethodBeingCompiled->IsILStub() - && dac_cast(m_pMethodBeingCompiled)->GetILStubType() == DynamicMethodDesc::StubNativeToCLRInterop)) - { + if (pClass->IsUnsafeValueClass()) ret |= CORINFO_FLG_UNSAFE_VALUECLASS; - } } if (pClass->HasExplicitFieldOffsetLayout() && pClass->HasOverlaidField()) ret |= CORINFO_FLG_OVERLAPPING_FIELDS; @@ -4209,8 +4151,8 @@ TypeCompareState CEEInfo::compareTypesForCast( else #endif // FEATURE_COMINTEROP - // If casting from ICastable or IDynamicInterfaceCastable, don't try to optimize - if (fromHnd.GetMethodTable()->IsICastable() || fromHnd.GetMethodTable()->IsIDynamicInterfaceCastable()) + // If casting from IDynamicInterfaceCastable, don't try to optimize + if (fromHnd.GetMethodTable()->IsIDynamicInterfaceCastable()) { result = TypeCompareState::May; } @@ -4380,18 +4322,14 @@ static BOOL isMoreSpecificTypeHelper(TypeHandle hnd1, TypeHandle hnd2) return FALSE; } - // If we have a mixture of shared and unshared types, - // consider the unshared type as more specific. - BOOL isHnd1CanonSubtype = hnd1.IsCanonicalSubtype(); - BOOL isHnd2CanonSubtype = hnd2.IsCanonicalSubtype(); - if (isHnd1CanonSubtype != isHnd2CanonSubtype) + // If both types have the same type definition while + // hnd1 is shared and hnd2 is not - consider hnd2 more specific. + if (!hnd1.IsTypeDesc() && !hnd2.IsTypeDesc() && + hnd1.AsMethodTable()->HasSameTypeDefAs(hnd2.AsMethodTable())) { - // Only one of hnd1 and hnd2 is shared. - // hdn2 is more specific if hnd1 is the shared type. - return isHnd1CanonSubtype; + return hnd1.IsCanonicalSubtype() && !hnd2.IsCanonicalSubtype(); } - // Otherwise both types are either shared or not shared. // Look for a common parent type. TypeHandle merged = TypeHandle::MergeTypeHandlesToCommonParent(hnd1, hnd2); @@ -6185,6 +6123,12 @@ CORINFO_CLASS_HANDLE CEEInfo::getTypeForBoxOnStack(CORINFO_CLASS_HANDLE cls) TypeHandle stackAllocatedBox = CoreLibBinder::GetClass(CLASS__STACKALLOCATEDBOX); TypeHandle stackAllocatedBoxInst = stackAllocatedBox.Instantiate(boxedFieldsInst); result = static_cast(stackAllocatedBoxInst.AsPtr()); + +#ifdef _DEBUG + FieldDesc* pValueFD = CoreLibBinder::GetField(FIELD__STACKALLOCATEDBOX__VALUE); + DWORD index = pValueFD->GetApproxEnclosingMethodTable()->GetIndexForFieldDesc(pValueFD); + _ASSERTE(stackAllocatedBoxInst.GetMethodTable()->GetFieldDescByIndex(index)->GetOffset() == TARGET_POINTER_SIZE); +#endif } EE_TO_JIT_TRANSITION(); @@ -7332,43 +7276,6 @@ bool getILIntrinsicImplementationForRuntimeHelpers(MethodDesc * ftn, return true; } - if (tk == CoreLibBinder::GetMethod(METHOD__RUNTIME_HELPERS__GET_METHOD_TABLE)->GetMemberDef()) - { - mdToken tokRawData = CoreLibBinder::GetField(FIELD__RAW_DATA__DATA)->GetMemberDef(); - - // In the CLR, an object is laid out as follows. - // [ object_header || MethodTable* (64-bit pointer) || instance_data ] - // ^ ^-- ref .firstField points here - // `-- reference (type O) points here - // - // So essentially what we want to do is to turn an object reference (type O) into a - // native int&, then dereference it to get the MethodTable*. (Essentially, an object - // reference is a MethodTable**.) Per ECMA-335, Sec. III.1.5, we can add - // (but not subtract) a & and an int32 to produce a &. So we'll get a reference to - // .firstField (type &), then back up one pointer length to get a value of - // essentially type (MethodTable*)&. Both of these are legal GC-trackable references - // to , regardless of 's actual length. - - static BYTE ilcode[] = { CEE_LDARG_0, // stack contains [ O ] = - CEE_LDFLDA,0,0,0,0, // stack contains [ & ] = ref .firstField - CEE_LDC_I4_S,(BYTE)(-TARGET_POINTER_SIZE), // stack contains [ &, int32 ] = -IntPtr.Size - CEE_ADD, // stack contains [ & ] = ref .methodTablePtr - CEE_LDIND_I, // stack contains [ native int ] = .methodTablePtr - CEE_RET }; - - ilcode[2] = (BYTE)(tokRawData); - ilcode[3] = (BYTE)(tokRawData >> 8); - ilcode[4] = (BYTE)(tokRawData >> 16); - ilcode[5] = (BYTE)(tokRawData >> 24); - - methInfo->ILCode = const_cast(ilcode); - methInfo->ILCodeSize = sizeof(ilcode); - methInfo->maxStack = 2; - methInfo->EHcount = 0; - methInfo->options = (CorInfoOptions)0; - return true; - } - if (tk == CoreLibBinder::GetMethod(METHOD__RUNTIME_HELPERS__ENUM_EQUALS)->GetMemberDef()) { // Normally we would follow the above pattern and unconditionally replace the IL, @@ -7644,6 +7551,26 @@ static void getMethodInfoHelper( SigPointer localSig = pResolver->GetLocalSig(); localSig.GetSignature(&pLocalSig, &cbLocalSig); } + else if (ftn->GetMemberDef() == CoreLibBinder::GetMethod(METHOD__RUNTIME_HELPERS__COPY_CONSTRUCT)->GetMemberDef()) + { + _ASSERTE(ftn->HasMethodInstantiation()); + Instantiation inst = ftn->GetMethodInstantiation(); + + _ASSERTE(inst.GetNumArgs() == 1); + TypeHandle type = inst[0]; + + if (!GenerateCopyConstructorHelper(ftn, type, &cxt.TransientResolver, &cxt.Header, methInfo)) + { + ThrowHR(COR_E_BADIMAGEFORMAT); + } + + scopeHnd = cxt.CreateScopeHandle(); + + _ASSERTE(cxt.Header != NULL); + getMethodInfoILMethodHeaderHelper(cxt.Header, methInfo); + pLocalSig = cxt.Header->LocalVarSig; + cbLocalSig = cxt.Header->cbLocalVarSig; + } else { if (!ftn->TryGenerateUnsafeAccessor(&cxt.TransientResolver, &cxt.Header)) @@ -9166,11 +9093,11 @@ CORINFO_CLASS_HANDLE CEEInfo::getFieldClass (CORINFO_FIELD_HANDLE fieldHnd) // // pTypeHnd - Optional. If not null then on return, for reference and value types, // *pTypeHnd will contain the normalized type of the field. -// owner - Optional. For resolving in a generic context +// fieldOwnerHint - Optional. For resolving in a generic context CorInfoType CEEInfo::getFieldType (CORINFO_FIELD_HANDLE fieldHnd, CORINFO_CLASS_HANDLE* pTypeHnd, - CORINFO_CLASS_HANDLE owner) + CORINFO_CLASS_HANDLE fieldOwnerHint) { CONTRACTL { THROWS; @@ -9182,7 +9109,7 @@ CorInfoType CEEInfo::getFieldType (CORINFO_FIELD_HANDLE fieldHnd, JIT_TO_EE_TRANSITION(); - result = getFieldTypeInternal(fieldHnd, pTypeHnd, owner); + result = getFieldTypeInternal(fieldHnd, pTypeHnd, fieldOwnerHint); EE_TO_JIT_TRANSITION(); @@ -9192,7 +9119,7 @@ CorInfoType CEEInfo::getFieldType (CORINFO_FIELD_HANDLE fieldHnd, /*********************************************************************/ CorInfoType CEEInfo::getFieldTypeInternal (CORINFO_FIELD_HANDLE fieldHnd, CORINFO_CLASS_HANDLE* pTypeHnd, - CORINFO_CLASS_HANDLE owner) + CORINFO_CLASS_HANDLE fieldOwnerHint) { STANDARD_VM_CONTRACT; @@ -9217,10 +9144,33 @@ CorInfoType CEEInfo::getFieldTypeInternal (CORINFO_FIELD_HANDLE fieldHnd, SigPointer ptr(sig, sigCount); + // Actual field's owner + MethodTable* actualFieldsOwner = field->GetApproxEnclosingMethodTable(); + + // Potentially, a more specific field's owner (hint) + TypeHandle hintedFieldOwner = TypeHandle(fieldOwnerHint); + + // Validate the hint: + TypeHandle moreExactFieldOwner = TypeHandle(); + if (!hintedFieldOwner.IsNull() && !hintedFieldOwner.IsTypeDesc()) + { + MethodTable* matchingHintedFieldOwner = hintedFieldOwner.AsMethodTable()->GetMethodTableMatchingParentClass(actualFieldsOwner); + if (matchingHintedFieldOwner != NULL) + { + // we take matchingHintedFieldOwner only if actualFieldsOwner is shared and matchingHintedFieldOwner + // is not, hence, it's definitely more exact. + if (actualFieldsOwner->IsSharedByGenericInstantiations() && + !matchingHintedFieldOwner->IsSharedByGenericInstantiations()) + { + moreExactFieldOwner = matchingHintedFieldOwner; + } + } + } + // For verifying code involving generics, use the class instantiation // of the optional owner (to provide exact, not representative, // type information) - SigTypeContext typeContext(field, (TypeHandle)owner); + SigTypeContext typeContext(field, moreExactFieldOwner); clsHnd = ptr.GetTypeHandleThrowing(field->GetModule(), &typeContext); _ASSERTE(!clsHnd.IsNull()); @@ -9427,7 +9377,6 @@ CORINFO_ARG_LIST_HANDLE CEEInfo::getArgNext(CORINFO_ARG_LIST_HANDLE args) /*********************************************************************/ - CorInfoTypeWithMod CEEInfo::getArgType ( CORINFO_SIG_INFO* sig, CORINFO_ARG_LIST_HANDLE args, @@ -9458,12 +9407,18 @@ CorInfoTypeWithMod CEEInfo::getArgType ( IfFailThrow(ptr.PeekElemType(&eType)); } + Module* pModule = GetModule(sig->scope); + + if (ptr.HasCustomModifier(pModule, "Microsoft.VisualC.NeedsCopyConstructorModifier", ELEMENT_TYPE_CMOD_REQD) || + ptr.HasCustomModifier(pModule, "System.Runtime.CompilerServices.IsCopyConstructed", ELEMENT_TYPE_CMOD_REQD)) + { + result = CorInfoTypeWithMod((int)result | CORINFO_TYPE_MOD_COPY_WITH_HELPER); + } + // Now read off the "real" element type after taking any instantiations into consideration SigTypeContext typeContext; GetTypeContext(&sig->sigInst,&typeContext); - Module* pModule = GetModule(sig->scope); - CorElementType type = ptr.PeekElemTypeClosed(pModule, &typeContext); TypeHandle typeHnd = TypeHandle(); @@ -9501,6 +9456,15 @@ CorInfoTypeWithMod CEEInfo::getArgType ( classMustBeLoadedBeforeCodeIsRun(CORINFO_CLASS_HANDLE(thPtr.AsPtr())); } } + FALLTHROUGH; + + case ELEMENT_TYPE_BYREF: + IfFailThrow(ptr.GetElemType(NULL)); + if (ptr.HasCustomModifier(pModule, "Microsoft.VisualC.NeedsCopyConstructorModifier", ELEMENT_TYPE_CMOD_REQD) || + ptr.HasCustomModifier(pModule, "System.Runtime.CompilerServices.IsCopyConstructed", ELEMENT_TYPE_CMOD_REQD)) + { + result = CorInfoTypeWithMod((int)result | CORINFO_TYPE_MOD_COPY_WITH_HELPER); + } break; case ELEMENT_TYPE_VOID: @@ -9953,6 +9917,40 @@ void CEEInfo::getAddressOfPInvokeTarget(CORINFO_METHOD_HANDLE method, EE_TO_JIT_TRANSITION(); } +CORINFO_METHOD_HANDLE CEEInfo::getSpecialCopyHelper(CORINFO_CLASS_HANDLE type) +{ + CONTRACTL { + THROWS; + GC_TRIGGERS; + MODE_PREEMPTIVE; + } CONTRACTL_END; + + CORINFO_METHOD_HANDLE result = NULL; + + JIT_TO_EE_TRANSITION(); + + TypeHandle th = TypeHandle(type); + + _ASSERTE(th.IsValueType()); + + MethodDesc* pHelperMD = CoreLibBinder::GetMethod(METHOD__RUNTIME_HELPERS__COPY_CONSTRUCT); + + pHelperMD = MethodDesc::FindOrCreateAssociatedMethodDesc( + pHelperMD, + pHelperMD->GetMethodTable(), + FALSE, + Instantiation(&th, 1), + FALSE, + FALSE); + + pHelperMD->CheckRestore(); + result = (CORINFO_METHOD_HANDLE)pHelperMD; + + EE_TO_JIT_TRANSITION(); + + return result; +} + /*********************************************************************/ CORINFO_JUST_MY_CODE_HANDLE CEEInfo::getJustMyCodeHandle( CORINFO_METHOD_HANDLE method, diff --git a/src/coreclr/vm/jitinterface.h b/src/coreclr/vm/jitinterface.h index a473576d1aa..d65d41e4662 100644 --- a/src/coreclr/vm/jitinterface.h +++ b/src/coreclr/vm/jitinterface.h @@ -1136,8 +1136,8 @@ extern thread_local int64_t t_cbILJittedForThread; extern thread_local int64_t t_cMethodsJittedForThread; extern thread_local int64_t t_c100nsTicksInJitForThread; -FCDECL1(INT64, GetCompiledILBytes, CLR_BOOL currentThread); -FCDECL1(INT64, GetCompiledMethodCount, CLR_BOOL currentThread); -FCDECL1(INT64, GetCompilationTimeInTicks, CLR_BOOL currentThread); +FCDECL1(INT64, GetCompiledILBytes, FC_BOOL_ARG currentThread); +FCDECL1(INT64, GetCompiledMethodCount, FC_BOOL_ARG currentThread); +FCDECL1(INT64, GetCompilationTimeInTicks, FC_BOOL_ARG currentThread); #endif // JITINTERFACE_H diff --git a/src/coreclr/vm/loaderallocator.cpp b/src/coreclr/vm/loaderallocator.cpp index 6cc8b62480a..6ad3a8457f5 100644 --- a/src/coreclr/vm/loaderallocator.cpp +++ b/src/coreclr/vm/loaderallocator.cpp @@ -17,7 +17,7 @@ UINT64 LoaderAllocator::cLoaderAllocatorsCreated = 1; -LoaderAllocator::LoaderAllocator(bool collectible) : +LoaderAllocator::LoaderAllocator(bool collectible) : m_stubPrecodeRangeList(STUB_CODE_BLOCK_STUBPRECODE, collectible), m_fixupPrecodeRangeList(STUB_CODE_BLOCK_FIXUPPRECODE, collectible) { @@ -62,7 +62,6 @@ LoaderAllocator::LoaderAllocator(bool collectible) : m_fUnloaded = false; m_fMarked = false; m_pLoaderAllocatorDestroyNext = NULL; - m_pDomain = NULL; m_pCodeHeapInitialAlloc = NULL; m_pVSDHeapInitialAlloc = NULL; m_pLastUsedCodeHeap = NULL; @@ -200,14 +199,14 @@ BOOL LoaderAllocator::CheckAddReference_Unlocked(LoaderAllocator *pOtherLA) { THROWS; MODE_ANY; + PRECONDITION(pOtherLA != this); + PRECONDITION(IsCollectible()); + PRECONDITION(Id()->GetType() == LAT_Assembly); } CONTRACTL_END; - // This must be checked before calling this function - _ASSERTE(pOtherLA != this); - // This function requires the that loader allocator lock have been taken. - _ASSERTE(GetDomain()->GetLoaderAllocatorReferencesLock()->OwnedByCurrentThread()); + _ASSERTE(GetAppDomain()->GetLoaderAllocatorReferencesLock()->OwnedByCurrentThread()); if (m_LoaderAllocatorReferences.Lookup(pOtherLA) == NULL) { @@ -238,7 +237,7 @@ BOOL LoaderAllocator::EnsureReference(LoaderAllocator *pOtherLA) CONTRACTL_END; // Check if this lock can be taken in all places that the function is called - _ASSERTE(GetDomain()->GetLoaderAllocatorReferencesLock()->Debug_CanTake()); + _ASSERTE(GetAppDomain()->GetLoaderAllocatorReferencesLock()->Debug_CanTake()); if (!IsCollectible()) return FALSE; @@ -249,7 +248,8 @@ BOOL LoaderAllocator::EnsureReference(LoaderAllocator *pOtherLA) if (!pOtherLA->IsCollectible()) return FALSE; - CrstHolder ch(GetDomain()->GetLoaderAllocatorReferencesLock()); + _ASSERTE(Id()->GetType() == LAT_Assembly); + CrstHolder ch(GetAppDomain()->GetLoaderAllocatorReferencesLock()); return CheckAddReference_Unlocked(pOtherLA); } @@ -265,12 +265,13 @@ BOOL LoaderAllocator::EnsureInstantiation(Module *pDefiningModule, Instantiation BOOL fNewReferenceNeeded = FALSE; // Check if this lock can be taken in all places that the function is called - _ASSERTE(GetDomain()->GetLoaderAllocatorReferencesLock()->Debug_CanTake()); + _ASSERTE(GetAppDomain()->GetLoaderAllocatorReferencesLock()->Debug_CanTake()); if (!IsCollectible()) return FALSE; - CrstHolder ch(GetDomain()->GetLoaderAllocatorReferencesLock()); + _ASSERTE(Id()->GetType() == LAT_Assembly); + CrstHolder ch(GetAppDomain()->GetLoaderAllocatorReferencesLock()); if (pDefiningModule != NULL) { @@ -356,13 +357,10 @@ LoaderAllocator * LoaderAllocator::GCLoaderAllocators_RemoveAssemblies(AppDomain AppDomain::AssemblyIterator iData; iData = pAppDomain->IterateAssembliesEx((AssemblyIterationFlags)( kIncludeExecution | kIncludeLoaded | kIncludeCollected)); - CollectibleAssemblyHolder pDomainAssembly; + CollectibleAssemblyHolder pAssembly; - while (iData.Next_Unlocked(pDomainAssembly.This())) + while (iData.Next_Unlocked(pAssembly.This())) { - // The assembly could be collected (ref-count = 0), do not use holder which calls add-ref - Assembly * pAssembly = pDomainAssembly->GetAssembly(); - if (pAssembly != NULL) { LoaderAllocator * pLoaderAllocator = pAssembly->GetLoaderAllocator(); @@ -390,13 +388,10 @@ LoaderAllocator * LoaderAllocator::GCLoaderAllocators_RemoveAssemblies(AppDomain i = pAppDomain->IterateAssembliesEx((AssemblyIterationFlags)( kIncludeExecution | kIncludeLoaded | kIncludeCollected)); - CollectibleAssemblyHolder pDomainAssembly; + CollectibleAssemblyHolder pAssembly; - while (i.Next_Unlocked(pDomainAssembly.This())) + while (i.Next_Unlocked(pAssembly.This())) { - // The assembly could be collected (ref-count = 0), do not use holder which calls add-ref - Assembly * pAssembly = pDomainAssembly->GetAssembly(); - if (pAssembly != NULL) { LoaderAllocator * pLoaderAllocator = pAssembly->GetLoaderAllocator(); @@ -413,11 +408,8 @@ LoaderAllocator * LoaderAllocator::GCLoaderAllocators_RemoveAssemblies(AppDomain i = pAppDomain->IterateAssembliesEx((AssemblyIterationFlags)( kIncludeExecution | kIncludeLoaded | kIncludeCollected)); - while (i.Next_Unlocked(pDomainAssembly.This())) + while (i.Next_Unlocked(pAssembly.This())) { - // The assembly could be collected (ref-count = 0), do not use holder which calls add-ref - Assembly * pAssembly = pDomainAssembly->GetAssembly(); - if (pAssembly != NULL) { LoaderAllocator * pLoaderAllocator = pAssembly->GetLoaderAllocator(); @@ -480,7 +472,7 @@ LoaderAllocator * LoaderAllocator::GCLoaderAllocators_RemoveAssemblies(AppDomain pAppDomain->RemoveFileFromCache(domainAssemblyToRemove->GetPEAssembly()); AssemblySpec spec; spec.InitializeSpec(domainAssemblyToRemove->GetPEAssembly()); - VERIFY(pAppDomain->RemoveAssemblyFromCache(domainAssemblyToRemove)); + VERIFY(pAppDomain->RemoveAssemblyFromCache(domainAssemblyToRemove->GetAssembly())); } domainAssemblyIt++; @@ -504,13 +496,16 @@ void LoaderAllocator::GCLoaderAllocators(LoaderAllocator* pOriginalLoaderAllocat THROWS; GC_TRIGGERS; MODE_PREEMPTIVE; + PRECONDITION(pOriginalLoaderAllocator != NULL); + PRECONDITION(pOriginalLoaderAllocator->IsCollectible()); + PRECONDITION(pOriginalLoaderAllocator->Id()->GetType() == LAT_Assembly); } CONTRACTL_END; // List of LoaderAllocators being deleted LoaderAllocator * pFirstDestroyedLoaderAllocator = NULL; - AppDomain* pAppDomain = (AppDomain*)pOriginalLoaderAllocator->GetDomain(); + AppDomain* pAppDomain = AppDomain::GetCurrentDomain(); // Collect all LoaderAllocators that don't have anymore DomainAssemblies alive // Note: that it may not collect our pOriginalLoaderAllocator in case this @@ -538,7 +533,7 @@ void LoaderAllocator::GCLoaderAllocators(LoaderAllocator* pOriginalLoaderAllocat // Call AssemblyUnloadStarted event domainAssemblyIt->GetAssembly()->StartUnload(); // Notify the debugger - domainAssemblyIt->NotifyDebuggerUnload(); + domainAssemblyIt->GetAssembly()->NotifyDebuggerUnload(); domainAssemblyIt++; } @@ -842,7 +837,7 @@ LOADERHANDLE LoaderAllocator::AllocateHandle(OBJECTREF value) } else { - OBJECTREF* pRef = GetDomain()->AllocateObjRefPtrsInLargeTable(1); + OBJECTREF* pRef = AppDomain::GetCurrentDomain()->AllocateObjRefPtrsInLargeTable(1); SetObjectReference(pRef, gc.value); retVal = (((UINT_PTR)pRef) + 1); } @@ -1022,7 +1017,7 @@ void LoaderAllocator::SetupManagedTracking(LOADERALLOCATORREF * pKeepLoaderAlloc initLoaderAllocator.Call(args); - m_hLoaderAllocatorObjectHandle = GetDomain()->CreateLongWeakHandle(*pKeepLoaderAllocatorAlive); + m_hLoaderAllocatorObjectHandle = AppDomain::GetCurrentDomain()->CreateLongWeakHandle(*pKeepLoaderAllocatorAlive); RegisterHandleForCleanup(m_hLoaderAllocatorObjectHandle); } @@ -1057,12 +1052,10 @@ void LoaderAllocator::ActivateManagedTracking() #define COLLECTIBLE_CODEHEAP_SIZE (10 * GetOsPageSize()) #define COLLECTIBLE_VIRTUALSTUBDISPATCH_HEAP_SPACE (2 * GetOsPageSize()) -void LoaderAllocator::Init(BaseDomain *pDomain, BYTE *pExecutableHeapMemory) +void LoaderAllocator::Init(BYTE *pExecutableHeapMemory) { STANDARD_VM_CONTRACT; - m_pDomain = pDomain; - m_crstLoaderAllocator.Init(CrstLoaderAllocator, (CrstFlags)CRST_UNSAFE_COOPGC); m_crstLoaderAllocatorHandleTable.Init(CrstLeafLock, (CrstFlags)CRST_UNSAFE_COOPGC); m_InteropDataCrst.Init(CrstInteropData, CRST_REENTRANCY); @@ -1444,7 +1437,6 @@ void LoaderAllocator::Terminate() m_pFuncPtrStubs = NULL; } - // This was the block reserved by BaseDomain::Init for the loaderheaps. if (m_InitialReservedMemForLoaderHeaps) { ExecutableAllocator::Instance()->Release(m_InitialReservedMemForLoaderHeaps); @@ -1621,14 +1613,14 @@ DispatchToken LoaderAllocator::GetDispatchToken( return DispatchToken::CreateDispatchToken(typeId, slotNumber); } -void LoaderAllocator::InitVirtualCallStubManager(BaseDomain * pDomain) +void LoaderAllocator::InitVirtualCallStubManager() { STANDARD_VM_CONTRACT; NewHolder pMgr(new VirtualCallStubManager()); // Init the manager, including all heaps and such. - pMgr->Init(pDomain, this); + pMgr->Init(this); m_pVirtualCallStubManager = pMgr; @@ -1723,7 +1715,7 @@ void DomainAssemblyIterator::operator++() #ifndef DACCESS_COMPILE -void AssemblyLoaderAllocator::Init(AppDomain* pAppDomain) +void AssemblyLoaderAllocator::Init() { m_Id.Init(); @@ -1731,7 +1723,7 @@ void AssemblyLoaderAllocator::Init(AppDomain* pAppDomain) // GC mode, in case the caller requires that m_dependentHandleToNativeObjectSetCrst.Init(CrstLeafLock, CRST_UNSAFE_ANYMODE); - LoaderAllocator::Init((BaseDomain *)pAppDomain); + LoaderAllocator::Init(NULL /*pExecutableHeapMemory*/); if (IsCollectible()) { // TODO: the ShuffleThunkCache should really be using the m_pStubHeap, however the unloadability support @@ -1931,10 +1923,11 @@ void AssemblyLoaderAllocator::CleanupHandles() NOTHROW; MODE_ANY; CAN_TAKE_LOCK; + PRECONDITION(IsCollectible()); + PRECONDITION(Id()->GetType() == LAT_Assembly); } CONTRACTL_END; - _ASSERTE(GetDomain()->IsAppDomain()); if (m_hLoaderAllocatorObjectHandle != NULL) { @@ -2056,12 +2049,12 @@ void LoaderAllocator::CleanupFailedTypeInit() return; } - _ASSERTE(GetDomain()->IsAppDomain()); + _ASSERTE(Id()->GetType() == LAT_Assembly); // This method doesn't take a lock around loader allocator state access, because // it's supposed to be called only during cleanup. However, the domain-level state // might be accessed by multiple threads. - ListLock *pLock = GetDomain()->GetClassInitLock(); + ListLock *pLock = AppDomain::GetCurrentDomain()->GetClassInitLock(); while (!m_failedTypeInitCleanupList.IsEmpty()) { @@ -2382,7 +2375,7 @@ void LoaderAllocator::AllocateGCHandlesBytesForStaticVariables(DynamicStaticsInf } else { - GetDomain()->AllocateObjRefPtrsInLargeTable(cSlots, pStaticsInfo, pMTToFillWithStaticBoxes, isClassInitedByUpdatingStaticPointer); + AppDomain::GetCurrentDomain()->AllocateObjRefPtrsInLargeTable(cSlots, pStaticsInfo, pMTToFillWithStaticBoxes, isClassInitedByUpdatingStaticPointer); } } #endif // !DACCESS_COMPILE diff --git a/src/coreclr/vm/loaderallocator.hpp b/src/coreclr/vm/loaderallocator.hpp index 0bf475e33d5..2bce73a85cc 100644 --- a/src/coreclr/vm/loaderallocator.hpp +++ b/src/coreclr/vm/loaderallocator.hpp @@ -264,6 +264,8 @@ class SegmentedHandleIndexStack public: + ~SegmentedHandleIndexStack(); + // Push the value to the stack. If the push cannot be done due to OOM, return false; inline bool Push(DWORD value); @@ -360,8 +362,6 @@ class LoaderAllocator BYTE *GetVSDHeapInitialBlock(DWORD *pSize); BYTE *GetCodeHeapInitialBlock(const BYTE * loAddr, const BYTE * hiAddr, DWORD minimumSize, DWORD *pSize); - BaseDomain *m_pDomain; - // ExecutionManager caches void * m_pLastUsedCodeHeap; void * m_pLastUsedDynamicCodeHeap; @@ -735,9 +735,8 @@ class LoaderAllocator LoaderAllocator(bool collectible); virtual ~LoaderAllocator(); - BaseDomain *GetDomain() { LIMITED_METHOD_CONTRACT; return m_pDomain; } virtual BOOL CanUnload() = 0; - void Init(BaseDomain *pDomain, BYTE *pExecutableHeapMemory = NULL); + void Init(BYTE *pExecutableHeapMemory); void Terminate(); virtual void ReleaseManagedAssemblyLoadContext() {} @@ -776,7 +775,7 @@ class LoaderAllocator STRINGREF *GetOrInternString(STRINGREF *pString); void CleanupStringLiteralMap(); - void InitVirtualCallStubManager(BaseDomain *pDomain); + void InitVirtualCallStubManager(); void UninitVirtualCallStubManager(); inline PTR_VirtualCallStubManager GetVirtualCallStubManager() @@ -887,7 +886,7 @@ class GlobalLoaderAllocator : public LoaderAllocator LoaderAllocatorID m_Id; public: - void Init(BaseDomain *pDomain); + void Init(); GlobalLoaderAllocator() : LoaderAllocator(false), m_Id(LAT_Global, (void*)1) { LIMITED_METHOD_CONTRACT;}; virtual LoaderAllocatorID* Id(); virtual BOOL CanUnload(); @@ -913,7 +912,7 @@ class AssemblyLoaderAllocator : public LoaderAllocator , m_binderToRelease(NULL) #endif { LIMITED_METHOD_CONTRACT; } - void Init(AppDomain *pAppDomain); + void Init(); virtual BOOL CanUnload(); void AddDomainAssembly(DomainAssembly *pDomainAssembly) diff --git a/src/coreclr/vm/loaderallocator.inl b/src/coreclr/vm/loaderallocator.inl index d839a463227..374e19902fd 100644 --- a/src/coreclr/vm/loaderallocator.inl +++ b/src/coreclr/vm/loaderallocator.inl @@ -24,9 +24,9 @@ inline bool LoaderAllocator::IsExposedObjectLive() return !ObjectHandleIsNull(m_hLoaderAllocatorObjectHandle); } -inline void GlobalLoaderAllocator::Init(BaseDomain *pDomain) +inline void GlobalLoaderAllocator::Init() { - LoaderAllocator::Init(pDomain, m_ExecutableHeapInstance); + LoaderAllocator::Init(m_ExecutableHeapInstance); } inline BOOL LoaderAllocatorID::Equals(LoaderAllocatorID *pId) @@ -208,6 +208,19 @@ inline DWORD SegmentedHandleIndexStack::Pop() return m_TOSSegment->m_data[--m_TOSIndex]; } +inline SegmentedHandleIndexStack::~SegmentedHandleIndexStack() +{ + LIMITED_METHOD_CONTRACT; + + while (m_TOSSegment != NULL) + { + Segment* prevSegment = m_TOSSegment->m_prev; + delete m_TOSSegment; + m_TOSSegment = prevSegment; + } + m_freeSegment = NULL; +} + inline bool SegmentedHandleIndexStack::IsEmpty() { LIMITED_METHOD_CONTRACT; diff --git a/src/coreclr/vm/loongarch64/asmhelpers.S b/src/coreclr/vm/loongarch64/asmhelpers.S index 4848fc409ff..99889eee097 100644 --- a/src/coreclr/vm/loongarch64/asmhelpers.S +++ b/src/coreclr/vm/loongarch64/asmhelpers.S @@ -1088,7 +1088,7 @@ GenerateProfileHelper ProfileTailcall, PROFILE_TAILCALL NESTED_ENTRY OnCallCountThresholdReachedStub, _TEXT, NoHandler PROLOG_WITH_TRANSITION_BLOCK - addi.d $a0, $sp, __PWTB_TransitionBlock // TransitionBlock * + addi.d $a0, $sp, __PWTB_TransitionBlock // TransitionBlock * ori $a1, $t1, 0 // stub-identifying token bl C_FUNC(OnCallCountThresholdReached) ori $t4,$a0,0 @@ -1112,3 +1112,18 @@ LEAF_ENTRY GetThreadStaticsVariableOffset, _TEXT EPILOG_RETURN LEAF_END GetThreadStaticsVariableOffset, _TEXT // ------------------------------------------------------------------ + +// ------------------------------------------------------------------ +// size_t GetTLSResolverAddress() + +// Helper to get the TLS resolver address. This will be then used to determine if we have a static or dynamic resolver. +LEAF_ENTRY GetTLSResolverAddress, _TEXT + // $fp,$ra + PROLOG_SAVE_REG_PAIR_INDEXED 22, 1, 16 + pcalau12i $a0, %desc_pc_hi20(t_ThreadStatics) + addi.d $a0, $a0, %desc_pc_lo12(t_ThreadStatics) + ld.d $a0, $a0, %desc_ld(t_ThreadStatics) + EPILOG_RESTORE_REG_PAIR_INDEXED 22, 1, 16 + EPILOG_RETURN +LEAF_END GetTLSResolverAddress, _TEXT +// ------------------------------------------------------------------ diff --git a/src/coreclr/vm/loongarch64/profiler.cpp b/src/coreclr/vm/loongarch64/profiler.cpp index 8da4c3d5137..0d926a88f96 100644 --- a/src/coreclr/vm/loongarch64/profiler.cpp +++ b/src/coreclr/vm/loongarch64/profiler.cpp @@ -119,10 +119,12 @@ LPVOID ProfileArgIterator::GetNextArgAddr() } LPVOID pArg = nullptr; + int argSize = m_argIterator.IsArgPassedByRef() ? (int)sizeof(void*) : m_argIterator.GetArgSize(); if (TransitionBlock::IsFloatArgumentRegisterOffset(argOffset)) { - pArg = (LPBYTE)&pData->floatArgumentRegisters + (argOffset - TransitionBlock::GetOffsetOfFloatArgumentRegisters()); + int offset = argOffset - TransitionBlock::GetOffsetOfFloatArgumentRegisters(); + pArg = (LPBYTE)&pData->floatArgumentRegisters + offset; ArgLocDesc* pArgLocDesc = m_argIterator.GetArgLocDescForStructInRegs(); @@ -147,16 +149,18 @@ LPVOID ProfileArgIterator::GetNextArgAddr() } return (LPBYTE)&pData->buffer[bufferPos]; } - _ASSERTE(pArgLocDesc->m_cFloatReg == 2); } + _ASSERTE(offset + argSize <= sizeof(pData->floatArgumentRegisters)); + return pArg; } if (TransitionBlock::IsArgumentRegisterOffset(argOffset)) { - pArg = (LPBYTE)&pData->argumentRegisters + (argOffset - TransitionBlock::GetOffsetOfArgumentRegisters()); + int offset = argOffset - TransitionBlock::GetOffsetOfArgumentRegisters(); + pArg = (LPBYTE)&pData->argumentRegisters + offset; ArgLocDesc* pArgLocDesc = m_argIterator.GetArgLocDescForStructInRegs(); if (pArgLocDesc) @@ -175,14 +179,32 @@ LPVOID ProfileArgIterator::GetNextArgAddr() return (LPBYTE)&pData->buffer[bufferPos]; } - _ASSERTE(pArgLocDesc->m_cFloatReg == 0); } + + if (offset + argSize > (int)sizeof(pData->argumentRegisters)) + { + // Struct partially spilled on stack. + // The first part of struct must be in last argument register. + const int regIndex = NUM_ARGUMENT_REGISTERS - 1; + _ASSERTE(regIndex == offset / sizeof(pData->argumentRegisters.a[0])); + _ASSERTE(argSize <= 16); + _ASSERTE(m_bufferPos + 16 <= sizeof(pData->buffer)); + + UINT32 bufferPos = m_bufferPos; + UINT64* dst = (UINT64*)&pData->buffer[bufferPos]; + m_bufferPos += 16; + + *dst = *(UINT64*)pArg; + // spilled part must be first on stack (if we copy too much, that's ok) + *(dst + 1) = *(UINT64*)pData->profiledSp; + + return (LPBYTE)&pData->buffer[bufferPos]; + } } else { _ASSERTE(TransitionBlock::IsStackArgumentOffset(argOffset)); - pArg = (LPBYTE)pData->profiledSp + (argOffset - TransitionBlock::GetOffsetOfArgs()); } diff --git a/src/coreclr/vm/loongarch64/stubs.cpp b/src/coreclr/vm/loongarch64/stubs.cpp index 94e71fc9fce..ac1b170ebec 100644 --- a/src/coreclr/vm/loongarch64/stubs.cpp +++ b/src/coreclr/vm/loongarch64/stubs.cpp @@ -319,7 +319,7 @@ void LazyMachState::unwindLazyState(LazyMachState* baseState, context.S8 = unwoundstate->captureCalleeSavedRegisters[8] = baseState->captureCalleeSavedRegisters[8]; context.Fp = unwoundstate->captureCalleeSavedRegisters[9] = baseState->captureCalleeSavedRegisters[9]; context.Tp = unwoundstate->captureCalleeSavedRegisters[10] = baseState->captureCalleeSavedRegisters[10]; - context.Ra = NULL; // Filled by the unwinder + context.Ra = 0; // Filled by the unwinder context.Sp = baseState->captureSp; context.Pc = baseState->captureIp; @@ -340,7 +340,7 @@ void LazyMachState::unwindLazyState(LazyMachState* baseState, nonVolContextPtrs.S8 = &unwoundstate->captureCalleeSavedRegisters[8]; nonVolContextPtrs.Fp = &unwoundstate->captureCalleeSavedRegisters[9]; nonVolContextPtrs.Tp = &unwoundstate->captureCalleeSavedRegisters[10]; - nonVolContextPtrs.Ra = NULL; // Filled by the unwinder + nonVolContextPtrs.Ra = 0; // Filled by the unwinder #endif // DACCESS_COMPILE @@ -487,7 +487,7 @@ void HelperMethodFrame::UpdateRegDisplay(const PREGDISPLAY pRD, bool updateFloat pRD->pCurrentContext->S8 = (DWORD64)(pUnwoundState->captureCalleeSavedRegisters[8]); pRD->pCurrentContext->Fp = (DWORD64)(pUnwoundState->captureCalleeSavedRegisters[9]); pRD->pCurrentContext->Tp = (DWORD64)(pUnwoundState->captureCalleeSavedRegisters[10]); - pRD->pCurrentContext->Ra = NULL; // Unwind again to get Caller's PC + pRD->pCurrentContext->Ra = 0; // Unwind again to get Caller's PC pRD->pCurrentContextPointers->S0 = pUnwoundState->ptrCalleeSavedRegisters[0]; pRD->pCurrentContextPointers->S1 = pUnwoundState->ptrCalleeSavedRegisters[1]; @@ -525,7 +525,7 @@ void HelperMethodFrame::UpdateRegDisplay(const PREGDISPLAY pRD, bool updateFloat pRD->pCurrentContext->S8 = m_MachState.ptrCalleeSavedRegisters[8] ? *m_MachState.ptrCalleeSavedRegisters[8] : m_MachState.captureCalleeSavedRegisters[8]; pRD->pCurrentContext->Fp = m_MachState.ptrCalleeSavedRegisters[9] ? *m_MachState.ptrCalleeSavedRegisters[9] : m_MachState.captureCalleeSavedRegisters[9]; pRD->pCurrentContext->Tp = m_MachState.ptrCalleeSavedRegisters[10] ? *m_MachState.ptrCalleeSavedRegisters[10] : m_MachState.captureCalleeSavedRegisters[10]; - pRD->pCurrentContext->Ra = NULL; // Unwind again to get Caller's PC + pRD->pCurrentContext->Ra = 0; // Unwind again to get Caller's PC #else // TARGET_UNIX pRD->pCurrentContext->S0 = *m_MachState.ptrCalleeSavedRegisters[0]; pRD->pCurrentContext->S1 = *m_MachState.ptrCalleeSavedRegisters[1]; @@ -538,7 +538,7 @@ void HelperMethodFrame::UpdateRegDisplay(const PREGDISPLAY pRD, bool updateFloat pRD->pCurrentContext->S8 = *m_MachState.ptrCalleeSavedRegisters[8]; pRD->pCurrentContext->Fp = *m_MachState.ptrCalleeSavedRegisters[9]; pRD->pCurrentContext->Tp = *m_MachState.ptrCalleeSavedRegisters[10]; - pRD->pCurrentContext->Ra = NULL; // Unwind again to get Caller's PC + pRD->pCurrentContext->Ra = 0; // Unwind again to get Caller's PC #endif #if !defined(DACCESS_COMPILE) diff --git a/src/coreclr/vm/loongarch64/virtualcallstubcpu.hpp b/src/coreclr/vm/loongarch64/virtualcallstubcpu.hpp index ed1a13fda42..ff1952a6c63 100644 --- a/src/coreclr/vm/loongarch64/virtualcallstubcpu.hpp +++ b/src/coreclr/vm/loongarch64/virtualcallstubcpu.hpp @@ -343,7 +343,7 @@ struct ResolveHolder _stub._resolveWorkerTarget = resolveWorkerTarget; _ASSERTE(resolveWorkerTarget == (PCODE)ResolveWorkerChainLookupAsmStub); - _ASSERTE(patcherTarget == NULL); + _ASSERTE(patcherTarget == (PCODE)NULL); #undef DATA_OFFSET #undef PC_REL_OFFSET diff --git a/src/coreclr/vm/marshalnative.cpp b/src/coreclr/vm/marshalnative.cpp index 8b20efe4a3f..e3435ac6c64 100644 --- a/src/coreclr/vm/marshalnative.cpp +++ b/src/coreclr/vm/marshalnative.cpp @@ -349,7 +349,7 @@ FCIMPL2(LPVOID, MarshalNative::GCHandleInternalAlloc, Object *obj, int type) { FCALL_CONTRACT; - assert(type >= HNDTYPE_WEAK_SHORT && type <= HNDTYPE_SIZEDREF); + assert(type >= HNDTYPE_WEAK_SHORT && type <= HNDTYPE_DEPENDENT); if (CORProfilerTrackGC()) return NULL; diff --git a/src/coreclr/vm/metasig.h b/src/coreclr/vm/metasig.h index 0f0b5cd898a..7f1feca8f4e 100644 --- a/src/coreclr/vm/metasig.h +++ b/src/coreclr/vm/metasig.h @@ -31,8 +31,6 @@ // r -- Ref -- a byref // Ret -- indicates function return type // -// Var -- Variant -// // b -- Byte -- (unsigned) byte // u -- Char -- character (2 byte unsigned unicode) // d -- Dbl -- double @@ -200,15 +198,15 @@ DEFINE_METASIG_T(SM(Obj_RefGuid_RefIntPtr_RetInt, j r(g(GUID)) r(I), i)) DEFINE_METASIG_T(SM(Exception_Obj_RefIntPtr_RetVoidPtr, C(EXCEPTION) j r(I), P(v))) #endif // FEATURE_OBJCMARSHAL DEFINE_METASIG(SM(Int_RetVoid, i, v)) +DEFINE_METASIG(SM(Int_RetObj, i, j)) DEFINE_METASIG(SM(Int_Int_RetVoid, i i, v)) DEFINE_METASIG(SM(Str_RetIntPtr, s, I)) DEFINE_METASIG(SM(Str_RetBool, s, F)) DEFINE_METASIG(SM(IntPtr_IntPtr_RetVoid, I I, v)) -DEFINE_METASIG(SM(IntPtr_IntPtr_Obj_RetIntPtr, I I j, I)) DEFINE_METASIG(SM(IntPtr_IntPtr_Int_Obj_RetIntPtr, I I i j, I)) DEFINE_METASIG(SM(IntPtr_IntPtr_IntPtr_RetVoid, I I I, v)) DEFINE_METASIG(SM(IntPtr_IntPtr_IntPtr_UShrt_IntPtr_RetVoid, I I I H I, v)) -DEFINE_METASIG(SM(IntPtr_Int_IntPtr_RetIntPtr, I i I, I)) +DEFINE_METASIG(SM(IntPtr_Int_IntPtr_RetObj, I i I, j)) DEFINE_METASIG(SM(IntPtr_IntPtr_Int_Bool_IntPtr_RetVoid, I I i F I, v)) DEFINE_METASIG(SM(IntPtr_IntPtr_Obj_RetVoid, I I j, v)) DEFINE_METASIG_T(SM(Obj_Array_RetVoid, j C(ARRAY), v)) @@ -253,7 +251,6 @@ DEFINE_METASIG(SM(Obj_Int_RetVoid, j i,v)) DEFINE_METASIG(SM(PtrVoid_Obj_RetObj, P(v) j, j)) DEFINE_METASIG(SM(PtrVoid_Obj_RetRefByte, P(v) j, r(b))) DEFINE_METASIG_T(SM(ICustomMarshaler_RefObj_PtrIntPtr_RetVoid, C(ICUSTOM_MARSHALER) r(j) P(I), v)) -DEFINE_METASIG_T(SM(IntPtr_RetICustomMarshaler, I, C(ICUSTOM_MARSHALER))) DEFINE_METASIG(SM(RefDbl_Dbl_RetDbl, r(d) d, d)) DEFINE_METASIG(SM(RefDbl_Dbl_Dbl_RetDbl, r(d) d d, d)) @@ -351,6 +348,7 @@ DEFINE_METASIG(SM(PtrChar_RetInt, P(u), i)) DEFINE_METASIG(SM(PtrChar_RetVoid, P(u), v)) DEFINE_METASIG(SM(IntPtr_IntPtr_RetIntPtr, I I, I)) DEFINE_METASIG(SM(IntPtr_IntPtr_Int_RetIntPtr, I I i, I)) +DEFINE_METASIG(SM(PtrVoid_RetVoid, P(v), v)) DEFINE_METASIG(SM(PtrVoid_PtrVoid_RetVoid, P(v) P(v), v)) DEFINE_METASIG(SM(PtrVoid_PtrVoid_UInt_RetVoid, P(v) P(v) K, v)) DEFINE_METASIG(IM(Obj_RetBool, j, F)) @@ -363,9 +361,9 @@ DEFINE_METASIG(SM(Obj_Bool_RetArrByte, j F, a(b))) DEFINE_METASIG(SM(Obj_Obj_RefArrByte_RetArrByte, j j r(a(b)), a(b))) #ifdef FEATURE_COMINTEROP -DEFINE_METASIG_T(SM(Obj_Int_RefVariant_RetVoid, j i r(g(VARIANT)), v)) -DEFINE_METASIG_T(SM(Obj_RefVariant_RetVoid, j r(g(VARIANT)), v)) -DEFINE_METASIG_T(SM(RefVariant_RetObject, r(g(VARIANT)), j)) +DEFINE_METASIG_T(SM(Obj_Int_RefComVariant_RetVoid, j i r(g(COMVARIANT)), v)) +DEFINE_METASIG_T(SM(Obj_RefComVariant_RetVoid, j r(g(COMVARIANT)), v)) +DEFINE_METASIG_T(SM(RefComVariant_RetObject, r(g(COMVARIANT)), j)) DEFINE_METASIG_T(IM(RuntimeTypeHandle_RefBool_RefIntPtr_RetVoid, g(RT_TYPE_HANDLE) r(F) r(I), v)) #endif @@ -381,9 +379,6 @@ DEFINE_METASIG(SM(Str_Bool_Int_RetV, s F i, v)) DEFINE_METASIG_T(SM(Type_RetObj, C(TYPE), j)) DEFINE_METASIG_T(SM(Type_RetInt, C(TYPE), i)) -DEFINE_METASIG(SM(ArrByte_RetObj, a(b), j)) -DEFINE_METASIG(SM(ArrByte_Bool_RetObj, a(b) F, j)) -DEFINE_METASIG(SM(ArrByte_ArrByte_RefObj_RetObj, a(b) a(b) r(j), j)) DEFINE_METASIG(IM(Long_RetVoid, l, v)) DEFINE_METASIG(IM(IntPtr_Int_RetVoid, I i, v)) @@ -449,16 +444,13 @@ DEFINE_METASIG(IM(Int_Int_RetVoid, i i, v)) DEFINE_METASIG(IM(Int_Int_Int_RetVoid, i i i, v)) DEFINE_METASIG(IM(Int_Int_Int_Int_RetVoid, i i i i, v)) DEFINE_METASIG_T(IM(Obj_EventArgs_RetVoid, j C(EVENT_ARGS), v)) -DEFINE_METASIG_T(IM(Obj_UnhandledExceptionEventArgs_RetVoid, j C(UNHANDLED_EVENTARGS), v)) DEFINE_METASIG_T(IM(Exception_RetVoid, C(EXCEPTION), v)) -DEFINE_METASIG(IM(IntPtr_RetObj, I, j)) DEFINE_METASIG(IM(IntPtr_RetVoid, I, v)) DEFINE_METASIG_T(IM(RefGuid_RetIntPtr, r(g(GUID)), I)) DEFINE_METASIG(IM(Obj_RetInt, j, i)) -DEFINE_METASIG(IM(Obj_RetIntPtr, j, I)) DEFINE_METASIG(IM(Obj_RetVoid, j, v)) DEFINE_METASIG(IM(Obj_RetObj, j, j)) DEFINE_METASIG(IM(Obj_IntPtr_RetVoid, j I, v)) @@ -475,7 +467,6 @@ DEFINE_METASIG_T(IM(Str_BindingFlags_Obj_ArrObj_ArrBool_ArrInt_ArrType_Type_RetO DEFINE_METASIG_T(IM(Obj_Obj_BindingFlags_Binder_CultureInfo_RetVoid, j j g(BINDING_FLAGS) C(BINDER) C(CULTURE_INFO), v)) DEFINE_METASIG_T(IM(Obj_Obj_BindingFlags_Binder_ArrObj_CultureInfo_RetVoid, j j g(BINDING_FLAGS) C(BINDER) a(j) C(CULTURE_INFO), v)) DEFINE_METASIG_T(IM(Obj_BindingFlags_Binder_ArrObj_CultureInfo_RetObj, j g(BINDING_FLAGS) C(BINDER) a(j) C(CULTURE_INFO), j)) -DEFINE_METASIG(IM(IntPtr_ArrObj_Obj_RefArrObj_RetObj, I a(j) j r(a(j)), j)) DEFINE_METASIG(IM(RefObject_RetBool, r(j), F)) DEFINE_METASIG_T(IM(Class_RetObj, C(CLASS), j)) DEFINE_METASIG(IM(Int_VoidPtr_RetVoid, i P(v), v)) @@ -497,23 +488,14 @@ DEFINE_METASIG(SM(PtrChar_Int_PtrPtrChar_RetArrStr, P(u) i P(P(u)), a(s))) DEFINE_METASIG(SM(RefBool_RefBool_RetVoid, r(F) r(F), v)) DEFINE_METASIG_T(IM(Str_Exception_RetVoid, s C(EXCEPTION), v)) DEFINE_METASIG(IM(Str_Obj_RetVoid, s j, v)) -DEFINE_METASIG_T(IM(Str_BindingFlags_Binder_ArrType_ArrParameterModifier_RetMethodInfo, \ - s g(BINDING_FLAGS) C(BINDER) a(C(TYPE)) a(g(PARAMETER_MODIFIER)), C(METHOD_INFO))) -DEFINE_METASIG_T(IM(Str_BindingFlags_Binder_Type_ArrType_ArrParameterModifier_RetPropertyInfo, \ - s g(BINDING_FLAGS) C(BINDER) C(TYPE) a(C(TYPE)) a(g(PARAMETER_MODIFIER)), C(PROPERTY_INFO))) DEFINE_METASIG(IM(Str_Str_RetStr, s s, s)) DEFINE_METASIG(IM(Str_Str_RetVoid, s s, v)) DEFINE_METASIG(IM(Str_Str_Str_RetVoid, s s s, v)) DEFINE_METASIG(IM(Str_Int_RetVoid, s i, v)) DEFINE_METASIG(IM(Str_Str_Int_RetVoid, s s i, v)) DEFINE_METASIG(IM(Str_Str_Str_Int_RetVoid, s s s i, v)) -DEFINE_METASIG_T(IM(Str_BindingFlags_RetFieldInfo, s g(BINDING_FLAGS), C(FIELD_INFO))) -DEFINE_METASIG_T(IM(Str_BindingFlags_RetMemberInfo, s g(BINDING_FLAGS), a(C(MEMBER)))) -DEFINE_METASIG_T(IM(Str_BindingFlags_RetMethodInfo, s g(BINDING_FLAGS), C(METHOD_INFO))) -DEFINE_METASIG_T(IM(Str_BindingFlags_RetPropertyInfo, s g(BINDING_FLAGS), C(PROPERTY_INFO))) DEFINE_METASIG_T(IM(Str_BindingFlags_Binder_Obj_ArrObj_ArrParameterModifier_CultureInfo_ArrStr_RetObj, \ s g(BINDING_FLAGS) C(BINDER) j a(j) a(g(PARAMETER_MODIFIER)) C(CULTURE_INFO) a(s), j)) -DEFINE_METASIG_T(IM(Str_Type_Str_RetVoid, s C(TYPE) s, v)) DEFINE_METASIG_T(SM(Delegate_RetIntPtr, C(DELEGATE), I)) DEFINE_METASIG_T(SM(RuntimeTypeHandle_RetType, g(RT_TYPE_HANDLE), C(TYPE))) DEFINE_METASIG_T(SM(RuntimeTypeHandle_RetIntPtr, g(RT_TYPE_HANDLE), I)) @@ -525,7 +507,6 @@ DEFINE_METASIG(IM(RetRefByte, _, r(b))) DEFINE_METASIG_T(IM(Type_RetArrObj, C(TYPE) F, a(j))) DEFINE_METASIG(IM(Bool_RetVoid, F, v)) DEFINE_METASIG_T(IM(BindingFlags_RetArrFieldInfo, g(BINDING_FLAGS), a(C(FIELD_INFO)))) -DEFINE_METASIG_T(IM(BindingFlags_RetArrMemberInfo, g(BINDING_FLAGS), a(C(MEMBER)))) DEFINE_METASIG_T(IM(BindingFlags_RetArrMethodInfo, g(BINDING_FLAGS), a(C(METHOD_INFO)))) DEFINE_METASIG_T(IM(BindingFlags_RetArrPropertyInfo, g(BINDING_FLAGS), a(C(PROPERTY_INFO)))) DEFINE_METASIG(IM(ArrByte_RetVoid, a(b), v)) @@ -535,7 +516,6 @@ DEFINE_METASIG_T(IM(ArrType_ArrException_Str_RetVoid, a(C(TYPE)) a(C(EXCEPTION)) DEFINE_METASIG(IM(RefInt_RefInt_RefInt_RetArrByte, r(i) r(i) r(i), a(b))) DEFINE_METASIG_T(IM(RefInt_RetRuntimeType, r(i) , C(CLASS))) DEFINE_METASIG_T(IM(RuntimeType_RetVoid, C(CLASS) , v)) -DEFINE_METASIG_T(SM(ArrException_PtrInt_RetVoid, a(C(EXCEPTION)) P(i), v)) DEFINE_METASIG_T(IM(RuntimeArgumentHandle_PtrVoid_RetVoid, g(ARGUMENT_HANDLE) P(v), v)) @@ -589,15 +569,6 @@ DEFINE_METASIG_T(SM(RefCleanupWorkListElement_Obj_RetVoid, r(C(CLEANUP_WORK_LIST DEFINE_METASIG(SM(PtrVoid_RetPtrVoid, P(v), P(v))) DEFINE_METASIG(SM(PtrVoid_PtrVoid_PtrVoid_RetVoid, P(v) P(v) P(v), v)) DEFINE_METASIG(IM(PtrVoid_RetVoid, P(v), v)) -#if defined(TARGET_X86) && defined(TARGET_WINDOWS) -DEFINE_METASIG_T(IM(PtrCopyConstructorCookie_RetVoid, P(g(COPY_CONSTRUCTOR_COOKIE)), v)) -#endif // defined(TARGET_X86) && defined(TARGET_WINDOWS) - - -#ifdef FEATURE_ICASTABLE -DEFINE_METASIG_T(SM(ICastable_RtType_RefException_RetBool, C(ICASTABLE) C(CLASS) r(C(EXCEPTION)), F)) -DEFINE_METASIG_T(SM(ICastable_RtType_RetRtType, C(ICASTABLE) C(CLASS), C(CLASS))) -#endif // FEATURE_ICASTABLE DEFINE_METASIG_T(SM(IDynamicInterfaceCastable_RuntimeType_Bool_RetBool, C(IDYNAMICINTERFACECASTABLE) C(CLASS) F, F)) DEFINE_METASIG_T(SM(IDynamicInterfaceCastable_RuntimeType_RetRtType, C(IDYNAMICINTERFACECASTABLE) C(CLASS), C(CLASS))) diff --git a/src/coreclr/vm/method.cpp b/src/coreclr/vm/method.cpp index d8313fdc965..d9441162165 100644 --- a/src/coreclr/vm/method.cpp +++ b/src/coreclr/vm/method.cpp @@ -68,7 +68,7 @@ static_assert_no_msg((sizeof(DynamicMethodDesc) & MethodDesc::ALIGNMENT_MASK #define METHOD_DESC_SIZES(adjustment) \ adjustment + sizeof(MethodDesc), /* mcIL */ \ adjustment + sizeof(FCallMethodDesc), /* mcFCall */ \ - adjustment + sizeof(NDirectMethodDesc), /* mcNDirect */ \ + adjustment + sizeof(NDirectMethodDesc), /* mcPInvoke */ \ adjustment + sizeof(EEImplMethodDesc), /* mcEEImpl */ \ adjustment + sizeof(ArrayMethodDesc), /* mcArray */ \ adjustment + sizeof(InstantiatedMethodDesc), /* mcInstantiated */ \ @@ -1506,6 +1506,20 @@ DWORD MethodDesc::GetImplAttrs() return props; } +PTR_Module MethodDescChunk::GetLoaderModule() +{ + LIMITED_METHOD_DAC_CONTRACT; + if (IsLoaderModuleAttachedToChunk()) + { + TADDR ppLoaderModule = dac_cast(this) + SizeOf() - sizeof(PTR_Module); + return *dac_cast(ppLoaderModule); + } + else + { + return GetMethodTable()->GetLoaderModule(); + } +} + //******************************************************************************* Module* MethodDesc::GetLoaderModule() { @@ -1517,17 +1531,24 @@ Module* MethodDesc::GetLoaderModule() } CONTRACTL_END; + Module* pLoaderModule = GetMethodDescChunk()->GetLoaderModule(); + +#ifdef _DEBUG + // Verify that the LoaderModule stored in the MethodDescChunk matches the result achieved by computation if (HasMethodInstantiation() && !IsGenericMethodDefinition()) { - Module *retVal = ClassLoader::ComputeLoaderModule(GetMethodTable(), + Module *computeLoaderModuleAlgorithmResult = ClassLoader::ComputeLoaderModule(GetMethodTable(), GetMemberDef(), GetMethodInstantiation()); - return retVal; + _ASSERTE(computeLoaderModuleAlgorithmResult == pLoaderModule); } else { - return GetMethodTable()->GetLoaderModule(); + _ASSERTE(pLoaderModule == GetMethodTable()->GetLoaderModule()); } +#endif // _DEBUG + + return pLoaderModule; } //******************************************************************************* @@ -1845,7 +1866,7 @@ MethodDesc* MethodDesc::StripMethodInstantiation() //******************************************************************************* MethodDescChunk *MethodDescChunk::CreateChunk(LoaderHeap *pHeap, DWORD methodDescCount, - DWORD classification, BOOL fNonVtableSlot, BOOL fNativeCodeSlot, MethodTable *pInitialMT, AllocMemTracker *pamTracker) + DWORD classification, BOOL fNonVtableSlot, BOOL fNativeCodeSlot, MethodTable *pInitialMT, AllocMemTracker *pamTracker, Module *pLoaderModule) { CONTRACT(MethodDescChunk *) { @@ -1878,18 +1899,28 @@ MethodDescChunk *MethodDescChunk::CreateChunk(LoaderHeap *pHeap, DWORD methodDes MethodDescChunk * pFirstChunk = NULL; + bool needsExplicitLoaderModule = false; + if (pLoaderModule != NULL && pLoaderModule != pInitialMT->GetLoaderModule()) + { + needsExplicitLoaderModule = true; + } + do { DWORD count = min(methodDescCount, maxMethodDescsPerChunk); void * pMem = pamTracker->Track( - pHeap->AllocMem(S_SIZE_T(sizeof(MethodDescChunk) + oneSize * count))); + pHeap->AllocMem(S_SIZE_T(sizeof(MethodDescChunk) + oneSize * count + (needsExplicitLoaderModule ? sizeof(Module *) : 0)))); // Skip pointer to temporary entrypoints MethodDescChunk * pChunk = (MethodDescChunk *)((BYTE*)pMem); pChunk->SetSizeAndCount(oneSize * count, count); pChunk->SetMethodTable(pInitialMT); + if (needsExplicitLoaderModule) + { + pChunk->SetLoaderModuleAttachedToChunk(pLoaderModule); + } MethodDesc * pMD = pChunk->GetFirstMethodDesc(); for (DWORD i = 0; i < count; i++) @@ -2539,7 +2570,7 @@ BOOL MethodDesc::MayHaveNativeCode() break; case mcFCall: // FCalls do not have real native code. return FALSE; - case mcNDirect: // NDirect never have native code (note that the NDirect method + case mcPInvoke: // NDirect never have native code (note that the NDirect method return FALSE; // does not appear as having a native code even for stubs as IL) case mcEEImpl: // Runtime provided implementation. No native code. return FALSE; @@ -3486,14 +3517,6 @@ BOOL MethodDesc::HasUnmanagedCallersOnlyAttribute() WellKnownAttribute::UnmanagedCallersOnly, nullptr, nullptr); - if (hr != S_OK) - { - // See https://github.com/dotnet/runtime/issues/37622 - hr = GetCustomAttribute( - WellKnownAttribute::NativeCallableInternal, - nullptr, - nullptr); - } return (hr == S_OK) ? TRUE : FALSE; } diff --git a/src/coreclr/vm/method.hpp b/src/coreclr/vm/method.hpp index 628eb39864b..35882fdde5d 100644 --- a/src/coreclr/vm/method.hpp +++ b/src/coreclr/vm/method.hpp @@ -93,7 +93,7 @@ enum MethodClassification { mcIL = 0, // IL mcFCall = 1, // FCall (also includes tlbimped ctor, Delegate ctor) - mcNDirect = 2, // N/Direct + mcPInvoke = 2, // PInvoke method also known as N/Direct in this codebase mcEEImpl = 3, // special method; implementation provided by EE (like Delegate Invoke) mcArray = 4, // Array ECall mcInstantiated = 5, // Instantiated generic methods, including descriptors @@ -637,7 +637,7 @@ class MethodDesc inline DWORD IsNDirect() { LIMITED_METHOD_DAC_CONTRACT; - return mcNDirect == GetClassification(); + return mcPInvoke == GetClassification(); } inline DWORD IsInterface() @@ -1001,8 +1001,6 @@ class MethodDesc inline PTR_MethodTable GetMethodTable() const; - inline DPTR(PTR_MethodTable) GetMethodTablePtr() const; - public: inline MethodDescChunk* GetMethodDescChunk() const; inline int GetMethodDescChunkIndex() const; @@ -1917,6 +1915,7 @@ template<> struct cdac_data static constexpr size_t ChunkIndex = offsetof(MethodDesc, m_chunkIndex); static constexpr size_t Slot = offsetof(MethodDesc, m_wSlotNumber); static constexpr size_t Flags = offsetof(MethodDesc, m_wFlags); + static constexpr size_t Flags3AndTokenRemainder = offsetof(MethodDesc, m_wFlags3AndTokenRemainder); }; #ifndef DACCESS_COMPILE @@ -2214,7 +2213,8 @@ class MethodDescChunk // and for the logic that splits the token to be algorithmically generated based on the // #define enum_flag_DeterminedIsEligibleForTieredCompilation = 0x4000, // Has this chunk had its methods been determined eligible for tiered compilation or not - // unused = 0x8000, + enum_flag_LoaderModuleAttachedToChunk = 0x8000, // Is this chunk associated with a LoaderModule directly? If this flag is set, then the + // LoaderModule pointer is placed at the end of the chunk. }; #ifndef DACCESS_COMPILE @@ -2231,7 +2231,8 @@ class MethodDescChunk BOOL fNonVtableSlot, BOOL fNativeCodeSlot, MethodTable *initialMT, - class AllocMemTracker *pamTracker); + class AllocMemTracker *pamTracker, + Module* pLoaderModule = NULL); bool DeterminedIfMethodsAreEligibleForTieredCompilation() { @@ -2247,10 +2248,13 @@ class MethodDescChunk return m_methodTable; } - inline DPTR(PTR_MethodTable) GetMethodTablePtr() const +public: + PTR_Module GetLoaderModule(); + + inline bool IsLoaderModuleAttachedToChunk() const { LIMITED_METHOD_DAC_CONTRACT; - return dac_cast(PTR_HOST_MEMBER_TADDR(MethodDescChunk, this, m_methodTable)); + return (m_flagsAndTokenRange & enum_flag_LoaderModuleAttachedToChunk) != 0; } #ifndef DACCESS_COMPILE @@ -2280,6 +2284,13 @@ class MethodDescChunk LIMITED_METHOD_CONTRACT; m_next = chunk; } + + void SetLoaderModuleAttachedToChunk(Module* pModule) + { + m_flagsAndTokenRange |= enum_flag_LoaderModuleAttachedToChunk; + TADDR ppLoaderModule = dac_cast(this) + SizeOf() - sizeof(PTR_Module); + *(Module**)ppLoaderModule = pModule; + } #endif // !DACCESS_COMPILE PTR_MethodDescChunk GetNextChunk() @@ -2300,10 +2311,10 @@ class MethodDescChunk return m_flagsAndTokenRange & enum_flag_TokenRangeMask; } - inline SIZE_T SizeOf() + inline SIZE_T SizeOf() const { LIMITED_METHOD_DAC_CONTRACT; - return sizeof(MethodDescChunk) + (m_size + 1) * MethodDesc::ALIGNMENT; + return sizeof(MethodDescChunk) + (m_size + 1) * MethodDesc::ALIGNMENT + (IsLoaderModuleAttachedToChunk() ? sizeof(PTR_Module) : 0); } inline MethodDesc *GetFirstMethodDesc() @@ -2348,6 +2359,7 @@ struct cdac_data static constexpr size_t Next = offsetof(MethodDescChunk, m_next); static constexpr size_t Size = offsetof(MethodDescChunk, m_size); static constexpr size_t Count = offsetof(MethodDescChunk, m_count); + static constexpr size_t FlagsAndTokenRange = offsetof(MethodDescChunk, m_flagsAndTokenRange); }; inline int MethodDesc::GetMethodDescChunkIndex() const @@ -2424,6 +2436,15 @@ class StoredSigMethodDesc : public MethodDesc #ifdef DACCESS_COMPILE void EnumMemoryRegions(CLRDataEnumMemoryFlags flags); #endif + template friend struct ::cdac_data; +}; + +template<> +struct cdac_data +{ + static constexpr size_t Sig = offsetof(StoredSigMethodDesc, m_pSig); + static constexpr size_t cSig = offsetof(StoredSigMethodDesc, m_cSig); + static constexpr size_t ExtendedFlags = offsetof(StoredSigMethodDesc, m_dwExtendedFlags); }; //----------------------------------------------------------------------- @@ -2665,8 +2686,14 @@ class DynamicMethodDesc : public StoredSigMethodDesc // following implementations defined in DynamicMethod.cpp // void Destroy(); + template friend struct ::cdac_data; }; +template<> +struct cdac_data +{ + static constexpr size_t MethodName = offsetof(DynamicMethodDesc, m_pszMethodName); +}; class ArrayMethodDesc : public StoredSigMethodDesc { @@ -3418,7 +3445,14 @@ class InstantiatedMethodDesc final : public MethodDesc MethodDesc* pSharedMDescForStub, Instantiation methodInst, BOOL getSharedNotStub); + template friend struct ::cdac_data; +}; +template<> struct cdac_data +{ + static constexpr size_t PerInstInfo = offsetof(InstantiatedMethodDesc, m_pPerInstInfo); + static constexpr size_t Flags2 = offsetof(InstantiatedMethodDesc, m_wFlags2); + static constexpr size_t NumGenericArgs = offsetof(InstantiatedMethodDesc, m_wNumGenericArgs); }; inline PTR_MethodTable MethodDesc::GetMethodTable() const @@ -3430,15 +3464,6 @@ inline PTR_MethodTable MethodDesc::GetMethodTable() const return pChunk->GetMethodTable(); } -inline DPTR(PTR_MethodTable) MethodDesc::GetMethodTablePtr() const -{ - LIMITED_METHOD_DAC_CONTRACT; - - MethodDescChunk *pChunk = GetMethodDescChunk(); - PREFIX_ASSUME(pChunk != NULL); - return pChunk->GetMethodTablePtr(); -} - inline MethodTable* MethodDesc::GetCanonicalMethodTable() { LIMITED_METHOD_DAC_CONTRACT; diff --git a/src/coreclr/vm/methoditer.cpp b/src/coreclr/vm/methoditer.cpp index 409cbb991f2..7f84806123d 100644 --- a/src/coreclr/vm/methoditer.cpp +++ b/src/coreclr/vm/methoditer.cpp @@ -18,7 +18,7 @@ // assembly might be without a reference and get deallocated (even the native part). // BOOL LoadedMethodDescIterator::Next( - CollectibleAssemblyHolder * pDomainAssemblyHolder) + CollectibleAssemblyHolder * pAssemblyHolder) { CONTRACTL { @@ -35,7 +35,7 @@ BOOL LoadedMethodDescIterator::Next( // If the method + type is not generic, then nothing more to iterate. if (!m_mainMD->HasClassOrMethodInstantiation()) { - *pDomainAssemblyHolder = NULL; + *pAssemblyHolder = NULL; return FALSE; } goto ADVANCE_METHOD; @@ -53,31 +53,31 @@ BOOL LoadedMethodDescIterator::Next( // at the method table, flags and token etc. if (m_mainMD == NULL) { - *pDomainAssemblyHolder = NULL; + *pAssemblyHolder = NULL; return FALSE; } // Needs to work w/ non-generic methods too. if (!m_mainMD->HasClassOrMethodInstantiation()) { - *pDomainAssemblyHolder = NULL; + *pAssemblyHolder = NULL; return TRUE; } m_assemIterator = m_pAppDomain->IterateAssembliesEx(m_assemIterationFlags); ADVANCE_ASSEMBLY: - if (!m_assemIterator.Next(pDomainAssemblyHolder)) + if (!m_assemIterator.Next(pAssemblyHolder)) { - _ASSERTE(*pDomainAssemblyHolder == NULL); + _ASSERTE(*pAssemblyHolder == NULL); return FALSE; } #ifdef _DEBUG - dbg_m_pDomainAssembly = *pDomainAssemblyHolder; + dbg_m_pAssembly = *pAssemblyHolder; #endif //_DEBUG - m_currentModule = (*pDomainAssemblyHolder)->GetModule(); + m_currentModule = (*pAssemblyHolder)->GetModule(); if (m_mainMD->HasClassInstantiation()) { @@ -149,7 +149,7 @@ BOOL LoadedMethodDescIterator::Next( // Note: We don't need to keep the assembly alive in DAC - see code:CollectibleAssemblyHolder#CAH_DAC #ifndef DACCESS_COMPILE _ASSERTE_MSG( - *pDomainAssemblyHolder == dbg_m_pDomainAssembly, + *pAssemblyHolder == dbg_m_pAssembly, "Caller probably modified the assembly holder, which they shouldn't - see method comment."); #endif //DACCESS_COMPILE diff --git a/src/coreclr/vm/methoditer.h b/src/coreclr/vm/methoditer.h index fdc49e2ce59..90ccc67e96f 100644 --- a/src/coreclr/vm/methoditer.h +++ b/src/coreclr/vm/methoditer.h @@ -56,14 +56,14 @@ class LoadedMethodDescIterator BOOL m_fFirstTime; #ifdef _DEBUG - DomainAssembly * dbg_m_pDomainAssembly; + Assembly * dbg_m_pAssembly; #endif //_DEBUG public: // Iterates next MethodDesc. Updates the holder only if the assembly differs from the previous one. // Caller should not release (i.e. change) the holder explicitly between calls, otherwise collectible // assembly might be without a reference and get deallocated (even the native part). - BOOL Next(CollectibleAssemblyHolder * pDomainAssemblyHolder); + BOOL Next(CollectibleAssemblyHolder * pAssemblyHolder); MethodDesc *Current(); void Start(AppDomain * pAppDomain, Module *pModule, diff --git a/src/coreclr/vm/methodtable.cpp b/src/coreclr/vm/methodtable.cpp index 5e0ba6c09bf..ba0e9ab987b 100644 --- a/src/coreclr/vm/methodtable.cpp +++ b/src/coreclr/vm/methodtable.cpp @@ -375,24 +375,6 @@ void MethodTable::SetComObjectType() SetFlag(enum_flag_ComObject); } -#ifdef FEATURE_ICASTABLE -void MethodTable::SetICastable() -{ - LIMITED_METHOD_CONTRACT; - SetFlag(enum_flag_ICastable); -} -#endif - -BOOL MethodTable::IsICastable() -{ - LIMITED_METHOD_DAC_CONTRACT; -#ifdef FEATURE_ICASTABLE - return GetFlag(enum_flag_ICastable); -#else - return FALSE; -#endif -} - void MethodTable::SetIDynamicInterfaceCastable() { LIMITED_METHOD_CONTRACT; @@ -499,41 +481,21 @@ PTR_MethodTable InterfaceInfo_t::GetApproxMethodTable(Module * pContainingModule MethodTable *pServerMT = (*pServer)->GetMethodTable(); PREFIX_ASSUME(pServerMT != NULL); -#ifdef FEATURE_ICASTABLE - // In case of ICastable, instead of trying to find method implementation in the real object type - // we call GetMethodDescForInterfaceMethod() again with whatever type it returns. - // It allows objects that implement ICastable to mimic behavior of other types. - if (pServerMT->IsICastable() && - !pItfMD->HasMethodInstantiation() && - !TypeHandle(pServerMT).CanCastTo(ownerType)) // we need to make sure object doesn't implement this interface in a natural way +#ifdef FEATURE_COMINTEROP + if (pServerMT->IsComObjectType() && !pItfMD->HasMethodInstantiation()) { - GCStress::MaybeTrigger(); - - // Make call to ICastableHelpers.GetImplType(obj, interfaceTypeObj) - PREPARE_NONVIRTUAL_CALLSITE(METHOD__ICASTABLEHELPERS__GETIMPLTYPE); - - OBJECTREF ownerManagedType = ownerType.GetManagedClassObject(); //GC triggers - - DECLARE_ARGHOLDER_ARRAY(args, 2); - args[ARGNUM_0] = OBJECTREF_TO_ARGHOLDER(*pServer); - args[ARGNUM_1] = OBJECTREF_TO_ARGHOLDER(ownerManagedType); - - OBJECTREF impTypeObj = NULL; - CALL_MANAGED_METHOD_RETREF(impTypeObj, OBJECTREF, args); - - INDEBUG(ownerManagedType = NULL); //ownerManagedType wasn't protected during the call - if (impTypeObj == NULL) // GetImplType returns default(RuntimeTypeHandle) - { - COMPlusThrow(kEntryPointNotFoundException); - } - - ReflectClassBaseObject* resultTypeObj = ((ReflectClassBaseObject*)OBJECTREFToObject(impTypeObj)); - TypeHandle resultTypeHnd = resultTypeObj->GetType(); - MethodTable *pResultMT = resultTypeHnd.GetMethodTable(); + // interop needs an exact MethodDesc + pItfMD = MethodDesc::FindOrCreateAssociatedMethodDesc( + pItfMD, + ownerType.GetMethodTable(), + FALSE, // forceBoxedEntryPoint + Instantiation(), // methodInst + FALSE, // allowInstParam + TRUE); // forceRemotableMethod - RETURN(pResultMT->GetMethodDescForInterfaceMethod(ownerType, pItfMD, TRUE /* throwOnConflict */)); + RETURN(pServerMT->GetMethodDescForComInterfaceMethod(pItfMD, false)); } -#endif +#endif // !FEATURE_COMINTEROP // For IDynamicInterfaceCastable, instead of trying to find method implementation in the real object type // we call GetInterfaceImplementation on the object and call GetMethodDescForInterfaceMethod @@ -555,22 +517,6 @@ PTR_MethodTable InterfaceInfo_t::GetApproxMethodTable(Module * pContainingModule RETURN(implTypeHandle.GetMethodTable()->GetMethodDescForInterfaceMethod(ownerType, pItfMD, TRUE /* throwOnConflict */)); } -#ifdef FEATURE_COMINTEROP - if (pServerMT->IsComObjectType() && !pItfMD->HasMethodInstantiation()) - { - // interop needs an exact MethodDesc - pItfMD = MethodDesc::FindOrCreateAssociatedMethodDesc( - pItfMD, - ownerType.GetMethodTable(), - FALSE, // forceBoxedEntryPoint - Instantiation(), // methodInst - FALSE, // allowInstParam - TRUE); // forceRemotableMethod - - RETURN(pServerMT->GetMethodDescForComInterfaceMethod(pItfMD, false)); - } -#endif // !FEATURE_COMINTEROP - // Handle pure COM+ types. RETURN (pServerMT->GetMethodDescForInterfaceMethod(ownerType, pItfMD, TRUE /* throwOnConflict */)); } @@ -1462,8 +1408,8 @@ BOOL MethodTable::CanCastTo(MethodTable* pTargetMT, TypeHandlePairList* pVisited CanCastToClass(pTargetMT, pVisited); // We only consider type-based conversion rules here. - // Therefore a negative result cannot rule out convertibility for ICastable, IDynamicInterfaceCastable, and COM objects - if (result || !(pTargetMT->IsInterface() && (this->IsComObjectType() || this->IsICastable() || this->IsIDynamicInterfaceCastable()))) + // Therefore a negative result cannot rule out convertibility for IDynamicInterfaceCastable and COM objects + if (result || !(pTargetMT->IsInterface() && (this->IsComObjectType() || this->IsIDynamicInterfaceCastable()))) { CastCache::TryAddToCache(this, pTargetMT, (BOOL)result); } @@ -2764,7 +2710,7 @@ static bool HandleInlineArray(int elementTypeIndex, int nElements, FpStructInReg int nFlattenedFieldsPerElement = typeIndex - elementTypeIndex; if (nFlattenedFieldsPerElement == 0) { - assert(nElements == 1); // HasImpliedRepeatedFields must have returned a false positive + assert(nElements == 1); // HasImpliedRepeatedFields must have returned a false positive, it can't be an array LOG((LF_JIT, LL_EVERYTHING, "FpStructInRegistersInfo:%*s * ignoring empty struct\n", nestingLevel * 4, "")); return true; @@ -2873,6 +2819,17 @@ static bool FlattenFields(TypeHandle th, uint32_t offset, FpStructInRegistersInf { assert(nFields == 1); int nElements = pMT->GetNumInstanceFieldBytes() / fields[0].GetSize(); + + // Only InlineArrays can have element type of empty struct, fixed-size buffers take only primitives + if ((typeIndex - elementTypeIndex) == 0 && pMT->GetClass()->IsInlineArray()) + { + assert(nElements > 0); // InlineArray length must be > 0 + LOG((LF_JIT, LL_EVERYTHING, "FpStructInRegistersInfo:%*s " + " * struct %s containing a %i-element array of empty structs %s is passed by integer calling convention\n", + nestingLevel * 4, "", pMT->GetDebugClassName(), nElements, fields[0].GetDebugName())); + return false; + } + if (!HandleInlineArray(elementTypeIndex, nElements, info, typeIndex DEBUG_ARG(nestingLevel + 1))) return false; } @@ -3840,8 +3797,8 @@ void MethodTable::CheckRunClassInitThrowing() // To find GC hole easier... TRIGGERSGC(); - // Don't initialize shared generic instantiations (e.g. MyClass<__Canon>) - if (IsSharedByGenericInstantiations()) + // Don't initialize shared generic instantiations (e.g. MyClass<__Canon>), or an already initialized MethodTable + if (IsClassInited() || IsSharedByGenericInstantiations()) return; _ASSERTE(!ContainsGenericVariables()); @@ -3946,7 +3903,11 @@ void MethodTable::EnsureTlsIndexAllocated() CONTRACTL_END; PTR_MethodTableAuxiliaryData pAuxiliaryData = GetAuxiliaryDataForWrite(); - if (!pAuxiliaryData->IsTlsIndexAllocated() && GetNumThreadStaticFields() > 0) + + if (pAuxiliaryData->IsTlsIndexAllocated()) + return; + + if (GetNumThreadStaticFields() > 0) { ThreadStaticsInfo *pThreadStaticsInfo = MethodTableAuxiliaryData::GetThreadStaticsInfo(GetAuxiliaryDataForWrite()); // Allocate space for normal statics if we might have them @@ -7868,8 +7829,9 @@ MethodTable::ResolveVirtualStaticMethod( ClassLoadLevel level) { CONTRACTL{ - THROWS; - GC_TRIGGERS; + MODE_ANY; + THROWS; + GC_TRIGGERS; } CONTRACTL_END; bool verifyImplemented = (resolveVirtualStaticMethodFlags & ResolveVirtualStaticMethodFlags::VerifyImplemented) != ResolveVirtualStaticMethodFlags::None; @@ -8029,6 +7991,12 @@ MethodTable::ResolveVirtualStaticMethod( MethodDesc* MethodTable::TryResolveVirtualStaticMethodOnThisType(MethodTable* pInterfaceType, MethodDesc* pInterfaceMD, ResolveVirtualStaticMethodFlags resolveVirtualStaticMethodFlags, ClassLoadLevel level) { + CONTRACTL{ + MODE_ANY; + THROWS; + GC_TRIGGERS; + } CONTRACTL_END; + bool instantiateMethodParameters = (resolveVirtualStaticMethodFlags & ResolveVirtualStaticMethodFlags::InstantiateResultOverFinalMethodDesc) != ResolveVirtualStaticMethodFlags::None; bool allowVariance = (resolveVirtualStaticMethodFlags & ResolveVirtualStaticMethodFlags::AllowVariantMatches) != ResolveVirtualStaticMethodFlags::None; bool verifyImplemented = (resolveVirtualStaticMethodFlags & ResolveVirtualStaticMethodFlags::VerifyImplemented) != ResolveVirtualStaticMethodFlags::None; @@ -8084,7 +8052,7 @@ MethodTable::TryResolveVirtualStaticMethodOnThisType(MethodTable* pInterfaceType { // Allow variant, but not equivalent interface match if (!pInterfaceType->HasSameTypeDefAs(pInterfaceMT) || - !pInterfaceMT->CanCastTo(pInterfaceType, NULL)) + !TypeHandle(pInterfaceMT).CanCastTo(pInterfaceType, NULL)) { continue; } diff --git a/src/coreclr/vm/methodtable.h b/src/coreclr/vm/methodtable.h index 751ec9d0855..e7e44470da3 100644 --- a/src/coreclr/vm/methodtable.h +++ b/src/coreclr/vm/methodtable.h @@ -293,16 +293,9 @@ struct GenericsDictInfo // Number of type parameters (NOT including those of superclasses). WORD m_wNumTyPars; - template friend struct ::cdac_data; }; // struct GenericsDictInfo typedef DPTR(GenericsDictInfo) PTR_GenericsDictInfo; -template<> -struct cdac_data -{ - static constexpr size_t NumTypeArgs = offsetof(GenericsDictInfo, m_wNumTyPars); -}; - // These various statics structures exist directly before the MethodTableAuxiliaryData // Any MethodTable which has static variables has this structure @@ -333,30 +326,23 @@ struct MethodTableAuxiliaryData // TO BE UPDATED IN ORDER TO ENSURE THAT METHODTABLES DUPLICATED FOR GENERIC INSTANTIATIONS // CARRY THE CORRECT INITIAL FLAGS. - enum_flag_Initialized = 0x0001, - enum_flag_HasCheckedCanCompareBitsOrUseFastGetHashCode = 0x0002, // Whether we have checked the overridden Equals or GetHashCode - enum_flag_CanCompareBitsOrUseFastGetHashCode = 0x0004, // Is any field type or sub field type overridden Equals or GetHashCode - + enum_flag_Initialized = 0x0001, + enum_flag_HasCheckedCanCompareBitsOrUseFastGetHashCode = 0x0002, // Whether we have checked the overridden Equals or GetHashCode + enum_flag_CanCompareBitsOrUseFastGetHashCode = 0x0004, // Is any field type or sub field type overridden Equals or GetHashCode + enum_flag_IsTlsIndexAllocated = 0x0008, enum_flag_HasApproxParent = 0x0010, -#ifdef _DEBUG - // The MethodTable is in the right state to be published, and will be inevitably. - // Currently DEBUG only as it does not affect behavior in any way in a release build - enum_flag_IsPublished = 0x0020, -#endif + enum_flag_MayHaveOpenInterfaceInInterfaceMap = 0x0020, enum_flag_IsNotFullyLoaded = 0x0040, enum_flag_DependenciesLoaded = 0x0080, // class and all dependencies loaded up to CLASS_LOADED_BUT_NOT_VERIFIED enum_flag_IsInitError = 0x0100, enum_flag_IsStaticDataAllocated = 0x0200, // When this is set, if the class can be marked as initialized without any further code execution it will be. - // unum_unused = 0x0400, - enum_flag_IsTlsIndexAllocated = 0x0800, - enum_flag_MayHaveOpenInterfaceInInterfaceMap = 0x1000, - // enum_unused = 0x2000, - -#ifdef _DEBUG - enum_flag_ParentMethodTablePointerValid = 0x4000, - enum_flag_HasInjectedInterfaceDuplicates = 0x8000, -#endif + enum_flag_HasCheckedStreamOverride = 0x0400, + enum_flag_StreamOverriddenRead = 0x0800, + enum_flag_StreamOverriddenWrite = 0x1000, + // unused enum = 0x2000, + // unused enum = 0x4000, + // unused enum = 0x8000, }; union { @@ -376,6 +362,16 @@ struct MethodTableAuxiliaryData RUNTIMETYPEHANDLE m_hExposedClassObject; #ifdef _DEBUG + enum + { + // The MethodTable is in the right state to be published, and will be inevitably. + // Currently DEBUG only as it does not affect behavior in any way in a release build + enum_flagDebug_IsPublished = 0x2000, + enum_flagDebug_ParentMethodTablePointerValid = 0x4000, + enum_flagDebug_HasInjectedInterfaceDuplicates = 0x8000, + }; + DWORD m_dwFlagsDebug; + // to avoid verify same method table too many times when it's not changing, we cache the GC count // on which the method table is verified. When fast GC STRESS is turned on, we only verify the MT if // current GC count is bigger than the number. Note most thing which will invalidate a MT will require a @@ -410,13 +406,13 @@ struct MethodTableAuxiliaryData { LIMITED_METHOD_DAC_CONTRACT; - return (m_dwFlags & enum_flag_ParentMethodTablePointerValid); + return (m_dwFlagsDebug & enum_flagDebug_ParentMethodTablePointerValid); } inline void SetParentMethodTablePointerValid() { LIMITED_METHOD_CONTRACT; - m_dwFlags |= enum_flag_ParentMethodTablePointerValid; + m_dwFlagsDebug |= enum_flagDebug_ParentMethodTablePointerValid; } #endif @@ -492,6 +488,15 @@ struct MethodTableAuxiliaryData } #endif + inline void SetStreamOverrideState(BOOL read, BOOL write) + { + LONG streamOverride = + enum_flag_HasCheckedStreamOverride + | (read ? enum_flag_StreamOverriddenRead : 0) + | (write ? enum_flag_StreamOverriddenWrite : 0); + InterlockedOr((LONG*)&m_dwFlags, streamOverride); + } + inline RUNTIMETYPEHANDLE GetExposedClassObjectHandle() const { LIMITED_METHOD_CONTRACT; @@ -522,7 +527,7 @@ struct MethodTableAuxiliaryData void SetIsPublished() { LIMITED_METHOD_CONTRACT; - m_dwFlags |= (MethodTableAuxiliaryData::enum_flag_IsPublished); + m_dwFlagsDebug |= (MethodTableAuxiliaryData::enum_flagDebug_IsPublished); } #endif @@ -531,7 +536,7 @@ struct MethodTableAuxiliaryData bool IsPublished() const { LIMITED_METHOD_CONTRACT; - return (VolatileLoad(&m_dwFlags) & enum_flag_IsPublished); + return (VolatileLoad(&m_dwFlagsDebug) & enum_flagDebug_IsPublished); } #endif // _DEBUG @@ -737,6 +742,7 @@ SystemVClassificationType CorInfoType2UnixAmd64Classification(CorElementType eeT SystemVClassificationTypeUnknown, // ELEMENT_TYPE_CMOD_REQD SystemVClassificationTypeUnknown, // ELEMENT_TYPE_CMOD_OPT SystemVClassificationTypeUnknown, // ELEMENT_TYPE_INTERNAL + SystemVClassificationTypeUnknown, // ELEMENT_TYPE_CMOD_INTERNAL }; _ASSERTE(sizeof(toSystemVAmd64ClassificationTypeMap) == ELEMENT_TYPE_MAX); @@ -1031,12 +1037,6 @@ class MethodTable // mark the class type as COM object class void SetComObjectType(); -#ifdef FEATURE_ICASTABLE - void SetICastable(); -#endif - - BOOL IsICastable(); // This type implements ICastable interface - void SetIDynamicInterfaceCastable(); BOOL IsIDynamicInterfaceCastable(); @@ -2567,10 +2567,10 @@ class MethodTable inline PTR_BYTE GetNonGCThreadStaticsBasePointer(PTR_Thread pThread); inline PTR_BYTE GetGCThreadStaticsBasePointer(PTR_Thread pThread); - inline DWORD IsDynamicStatics() + inline BOOL IsDynamicStatics() { LIMITED_METHOD_DAC_CONTRACT; - return GetFlag(enum_flag_DynamicStatics); + return GetFlag(enum_flag_DynamicStatics) == enum_flag_DynamicStatics; } inline void SetDynamicStatics() @@ -2789,7 +2789,11 @@ class MethodTable } // The following methods are only valid for the method tables for array types. - CorElementType GetArrayElementType(); + CorElementType GetArrayElementType() + { + return GetArrayElementTypeHandle().GetSignatureCorElementType(); + } + DWORD GetRank(); TypeHandle GetArrayElementTypeHandle() @@ -3060,12 +3064,12 @@ public : inline BOOL Debug_HasInjectedInterfaceDuplicates() const { LIMITED_METHOD_CONTRACT; - return (GetAuxiliaryData()->m_dwFlags & MethodTableAuxiliaryData::enum_flag_HasInjectedInterfaceDuplicates) != 0; + return (GetAuxiliaryData()->m_dwFlagsDebug & MethodTableAuxiliaryData::enum_flagDebug_HasInjectedInterfaceDuplicates) != 0; } inline void Debug_SetHasInjectedInterfaceDuplicates() { LIMITED_METHOD_CONTRACT; - GetAuxiliaryDataForWrite()->m_dwFlags |= MethodTableAuxiliaryData::enum_flag_HasInjectedInterfaceDuplicates; + GetAuxiliaryDataForWrite()->m_dwFlagsDebug |= MethodTableAuxiliaryData::enum_flagDebug_HasInjectedInterfaceDuplicates; } #endif // _DEBUG @@ -3697,7 +3701,7 @@ public : enum_flag_HasFinalizer = 0x00100000, // instances require finalization. GC depends on this bit. enum_flag_Collectible = 0x00200000, // GC depends on this bit. - enum_flag_ICastable = 0x00400000, // class implements ICastable interface + // enum_flag_unused = 0x00400000, #ifdef FEATURE_64BIT_ALIGNMENT enum_flag_RequiresAlign8 = 0x00800000, // Type requires 8-byte alignment (only set on platforms that require this and don't get it implicitly) @@ -3717,7 +3721,6 @@ public : // Types that require non-trivial interface cast have this bit set in the category enum_flag_NonTrivialInterfaceCast = enum_flag_Category_Array | enum_flag_ComObject - | enum_flag_ICastable | enum_flag_IDynamicInterfaceCastable | enum_flag_Category_ValueType diff --git a/src/coreclr/vm/methodtable.inl b/src/coreclr/vm/methodtable.inl index 9ad333b0655..819bc0eb8d4 100644 --- a/src/coreclr/vm/methodtable.inl +++ b/src/coreclr/vm/methodtable.inl @@ -299,15 +299,6 @@ inline BOOL MethodTable::IsValueType() return GetFlag(enum_flag_Category_ValueType_Mask) == enum_flag_Category_ValueType; } -//========================================================================================== -inline CorElementType MethodTable::GetArrayElementType() -{ - WRAPPER_NO_CONTRACT; - - _ASSERTE (IsArray()); - return dac_cast(GetClass())->GetArrayElementType(); -} - //========================================================================================== inline DWORD MethodTable::GetRank() { diff --git a/src/coreclr/vm/methodtablebuilder.cpp b/src/coreclr/vm/methodtablebuilder.cpp index 70d4ea47aff..205060bff04 100644 --- a/src/coreclr/vm/methodtablebuilder.cpp +++ b/src/coreclr/vm/methodtablebuilder.cpp @@ -1260,8 +1260,6 @@ MethodTableBuilder::BuildMethodTableThrowing( } CONTRACTL_END; - pModule->EnsureAllocated(); - // The following structs, defined as private members of MethodTableBuilder, contain the necessary local // parameters needed for BuildMethodTable Look at the struct definitions for a detailed list of all // parameters available to BuildMethodTableThrowing. @@ -1807,6 +1805,12 @@ MethodTableBuilder::BuildMethodTableThrowing( } } + if (IsValueClass()) + { + if ((int)bmtFP->NumInstanceFieldBytes != (INT64)bmtFP->NumInstanceFieldBytes) + BuildMethodTableThrowException(IDS_CLASSLOAD_FIELDTOOLARGE); + } + if (CheckIfSIMDAndUpdateSize()) { totalDeclaredFieldSize = bmtFP->NumInstanceFieldBytes; @@ -1998,13 +2002,6 @@ MethodTableBuilder::BuildMethodTableThrowing( if (!IsValueClass()) { -#ifdef FEATURE_ICASTABLE - if (g_pICastableInterface != NULL && pMT->CanCastToInterface(g_pICastableInterface)) - { - pMT->SetICastable(); - } -#endif // FEATURE_ICASTABLE - if (g_pIDynamicInterfaceCastableInterface != NULL && pMT->CanCastToInterface(g_pIDynamicInterfaceCastableInterface)) { pMT->SetIDynamicInterfaceCastable(); @@ -3183,14 +3180,14 @@ MethodTableBuilder::EnumerateClassMethods() } else { - type = mcNDirect; + type = mcPInvoke; } } // The NAT_L attribute is present, marking this method as NDirect else { CONSISTENCY_CHECK(hr == S_OK); - type = mcNDirect; + type = mcPInvoke; } } else if (IsMiRuntime(dwImplFlags)) @@ -3256,11 +3253,6 @@ MethodTableBuilder::EnumerateClassMethods() // Methods in instantiated interfaces need nothing special - they are not visible from COM etc. type = mcIL; } - else if (bmtProp->fIsMngStandardItf) - { - // If the interface is a standard managed interface then allocate space for an FCall method desc. - type = mcFCall; - } else if (IsMdAbstract(dwMemberAttrs)) { // If COM interop is supported then all other interface MDs may be @@ -5093,7 +5085,7 @@ MethodTableBuilder::ValidateMethods() { BuildMethodTableThrowException(IDS_CLASSLOAD_BAD_UNMANAGED_RVA, it.Token()); } - if (it.MethodType() != mcNDirect) + if (it.MethodType() != mcPInvoke) { BuildMethodTableThrowException(BFA_BAD_UNMANAGED_ENTRY_POINT); } @@ -6099,7 +6091,7 @@ MethodTableBuilder::InitMethodDesc( switch (Classification) { - case mcNDirect: + case mcPInvoke: { // NDirect specific initialization. NDirectMethodDesc *pNewNMD = (NDirectMethodDesc*)pNewMD; @@ -6146,15 +6138,9 @@ MethodTableBuilder::InitMethodDesc( BAD_FORMAT_NOTHROW_ASSERT(((DelegateEEClass*)GetHalfBakedClass())->m_pInvokeMethod == NULL); ((DelegateEEClass*)GetHalfBakedClass())->m_pInvokeMethod = pNewMD; } - else if (strcmp(pMethodName, "BeginInvoke") == 0) - { - BAD_FORMAT_NOTHROW_ASSERT(((DelegateEEClass*)GetHalfBakedClass())->m_pBeginInvokeMethod == NULL); - ((DelegateEEClass*)GetHalfBakedClass())->m_pBeginInvokeMethod = pNewMD; - } - else if (strcmp(pMethodName, "EndInvoke") == 0) + else if (strcmp(pMethodName, "BeginInvoke") == 0 || strcmp(pMethodName, "EndInvoke") == 0) { - BAD_FORMAT_NOTHROW_ASSERT(((DelegateEEClass*)GetHalfBakedClass())->m_pEndInvokeMethod == NULL); - ((DelegateEEClass*)GetHalfBakedClass())->m_pEndInvokeMethod = pNewMD; + // Obsolete async methods } else { @@ -11371,10 +11357,8 @@ VOID MethodTableBuilder::CheckForRemotingProxyAttrib() //******************************************************************************* -// Checks for a bunch of special interface names and if it matches then it sets -// bmtProp->fIsMngStandardItf to TRUE. Additionally, it checks to see if the -// type is an interface and if it has ComEventInterfaceAttribute custom attribute -// set, then it sets bmtProp->fComEventItfType to true. +// Checks to see if the type is an interface and if it has ComEventInterfaceAttribute +// custom attribute set, then it sets bmtProp->fComEventItfType to true. // // NOTE: This only does anything when COM interop is enabled. @@ -11383,54 +11367,6 @@ VOID MethodTableBuilder::CheckForSpecialTypes() #ifdef FEATURE_COMINTEROP STANDARD_VM_CONTRACT; - - Module *pModule = GetModule(); - IMDInternalImport *pMDImport = pModule->GetMDImport(); - - // Check to see if this type is a managed standard interface. All the managed - // standard interfaces live in CoreLib so checking for that first - // makes the strcmp that comes afterwards acceptable. - if (pModule->IsSystem()) - { - if (IsInterface()) - { - LPCUTF8 pszClassName; - LPCUTF8 pszClassNamespace; - if (FAILED(pMDImport->GetNameOfTypeDef(GetCl(), &pszClassName, &pszClassNamespace))) - { - pszClassName = pszClassNamespace = NULL; - } - if ((pszClassName != NULL) && (pszClassNamespace != NULL)) - { - LPUTF8 pszFullyQualifiedName = NULL; - MAKE_FULLY_QUALIFIED_NAME(pszFullyQualifiedName, pszClassNamespace, pszClassName); - - // This is just to give us a scope to break out of. - do - { - -#define MNGSTDITF_BEGIN_INTERFACE(FriendlyName, strMngItfName, strUCOMMngItfName, strCustomMarshalerName, strCustomMarshalerCookie, strManagedViewName, NativeItfIID, bCanCastOnNativeItfQI) \ - if (strcmp(strMngItfName, pszFullyQualifiedName) == 0) \ - { \ - bmtProp->fIsMngStandardItf = true; \ - break; \ - } - -#define MNGSTDITF_DEFINE_METH_IMPL(FriendlyName, ECallMethName, MethName, MethSig, FcallDecl) - -#define MNGSTDITF_END_INTERFACE(FriendlyName) - -#include "mngstditflist.h" - -#undef MNGSTDITF_BEGIN_INTERFACE -#undef MNGSTDITF_DEFINE_METH_IMPL -#undef MNGSTDITF_END_INTERFACE - - } while (FALSE); - } - } - } - // Check to see if the type is a COM event interface (classic COM interop only). if (IsInterface()) { diff --git a/src/coreclr/vm/methodtablebuilder.h b/src/coreclr/vm/methodtablebuilder.h index eebc6351064..485161300eb 100644 --- a/src/coreclr/vm/methodtablebuilder.h +++ b/src/coreclr/vm/methodtablebuilder.h @@ -1282,7 +1282,6 @@ class MethodTableBuilder // Com Interop, ComWrapper classes extend from ComObject bool fIsComObjectType; // whether this class is an instance of ComObject class #ifdef FEATURE_COMINTEROP - bool fIsMngStandardItf; // Set to true if the interface is a manages standard interface. bool fComEventItfType; // Set to true if the class is a special COM event interface. #endif // FEATURE_COMINTEROP #ifdef FEATURE_TYPEEQUIVALENCE diff --git a/src/coreclr/vm/mlinfo.cpp b/src/coreclr/vm/mlinfo.cpp index 8131e4fd305..6785ad0999a 100644 --- a/src/coreclr/vm/mlinfo.cpp +++ b/src/coreclr/vm/mlinfo.cpp @@ -25,22 +25,6 @@ #include "dispparammarshaler.h" #endif // FEATURE_COMINTEROP -#ifdef FEATURE_COMINTEROP - DEFINE_ASM_QUAL_TYPE_NAME(ENUMERATOR_TO_ENUM_VARIANT_CM_NAME, g_EnumeratorToEnumClassName, g_CorelibAsmName); - - static const int ENUMERATOR_TO_ENUM_VARIANT_CM_NAME_LEN = ARRAY_SIZE(ENUMERATOR_TO_ENUM_VARIANT_CM_NAME); - static const char ENUMERATOR_TO_ENUM_VARIANT_CM_COOKIE[] = {""}; - static const int ENUMERATOR_TO_ENUM_VARIANT_CM_COOKIE_LEN = ARRAY_SIZE(ENUMERATOR_TO_ENUM_VARIANT_CM_COOKIE); - - DEFINE_ASM_QUAL_TYPE_NAME(COLOR_TRANSLATOR_ASM_QUAL_TYPE_NAME, g_ColorTranslatorClassName, g_DrawingAsmName); - DEFINE_ASM_QUAL_TYPE_NAME(COLOR_ASM_QUAL_TYPE_NAME, g_ColorClassName, g_DrawingAsmName); - - #define OLECOLOR_TO_SYSTEMCOLOR_METH_NAME "FromOle" - #define SYSTEMCOLOR_TO_OLECOLOR_METH_NAME "ToOle" -#endif // FEATURE_COMINTEROP - - - #define INITIAL_NUM_STRUCT_ILSTUB_HASHTABLE_BUCKETS 32 #define INITIAL_NUM_CMHELPER_HASHTABLE_BUCKETS 32 #define INITIAL_NUM_CMINFO_HASHTABLE_BUCKETS 32 @@ -48,366 +32,49 @@ namespace { - //------------------------------------------------------------------------------------- - // Return the copy ctor for a VC class (if any exists) - //------------------------------------------------------------------------------------- - void FindCopyCtor(Module *pModule, MethodTable *pMT, MethodDesc **pMDOut) + //========================================================================== + // Sets up the custom marshaler information. + //========================================================================== + CustomMarshalerInfo *SetupCustomMarshalerInfo(LPCUTF8 strMarshalerTypeName, DWORD cMarshalerTypeNameBytes, LPCUTF8 strCookie, DWORD cCookieStrBytes, Assembly *pAssembly, TypeHandle hndManagedType) { - CONTRACTL + CONTRACT (CustomMarshalerInfo*) { - THROWS; - GC_TRIGGERS; // CompareTypeTokens may trigger GC - MODE_ANY; + STANDARD_VM_CHECK; + PRECONDITION(CheckPointer(pAssembly)); + POSTCONDITION(CheckPointer(RETVAL)); } - CONTRACTL_END; - - *pMDOut = NULL; - - HRESULT hr; - mdMethodDef tk; - mdTypeDef cl = pMT->GetCl(); - TypeHandle th = TypeHandle(pMT); - SigTypeContext typeContext(th); - - IMDInternalImport *pInternalImport = pModule->GetMDImport(); - MDEnumHolder hEnumMethod(pInternalImport); - - // - // First try for the new syntax: - // - IfFailThrow(pInternalImport->EnumInit(mdtMethodDef, cl, &hEnumMethod)); + CONTRACT_END; - while (pInternalImport->EnumNext(&hEnumMethod, &tk)) - { - _ASSERTE(TypeFromToken(tk) == mdtMethodDef); - DWORD dwMemberAttrs; - IfFailThrow(pInternalImport->GetMethodDefProps(tk, &dwMemberAttrs)); + EEMarshalingData *pMarshalingData = NULL; - if (IsMdSpecialName(dwMemberAttrs)) - { - ULONG cSig; - PCCOR_SIGNATURE pSig; - LPCSTR pName; - IfFailThrow(pInternalImport->GetNameAndSigOfMethodDef(tk, &pSig, &cSig, &pName)); - - const char *pBaseName = ""; - int ncBaseName = (int)strlen(pBaseName); - int nc = (int)strlen(pName); - if (nc >= ncBaseName && 0 == strcmp(pName + nc - ncBaseName, pBaseName)) - { - MetaSig msig(pSig, cSig, pModule, &typeContext); + // The assembly is not shared so we use the current app domain's marshaling data. + pMarshalingData = pAssembly->GetLoaderAllocator()->GetMarshalingData(); - // Looking for the prototype void (Ptr VC, Ptr VC); - if (msig.NumFixedArgs() == 2) - { - if (msig.GetReturnType() == ELEMENT_TYPE_VOID) - { - if (msig.NextArg() == ELEMENT_TYPE_PTR) - { - SigPointer sp1 = msig.GetArgProps(); - IfFailThrow(sp1.GetElemType(NULL)); - CorElementType eType; - IfFailThrow(sp1.GetElemType(&eType)); - if (eType == ELEMENT_TYPE_VALUETYPE) - { - mdToken tk1; - IfFailThrow(sp1.GetToken(&tk1)); - hr = CompareTypeTokensNT(tk1, cl, pModule, pModule); - if (FAILED(hr)) - { - pInternalImport->EnumClose(&hEnumMethod); - ThrowHR(hr); - } - - if (hr == S_OK) - { - if (msig.NextArg() == ELEMENT_TYPE_PTR) - { - SigPointer sp2 = msig.GetArgProps(); - IfFailThrow(sp2.GetElemType(NULL)); - IfFailThrow(sp2.GetElemType(&eType)); - if (eType == ELEMENT_TYPE_VALUETYPE) - { - mdToken tk2; - IfFailThrow(sp2.GetToken(&tk2)); - - hr = (tk2 == tk1) ? S_OK : CompareTypeTokensNT(tk2, cl, pModule, pModule); - if (hr == S_OK) - { - *pMDOut = pModule->LookupMethodDef(tk); - return; - } - } - } - } - } - } - } - } - } - } - } - - // - // Next try the old syntax: global .__ctor - // - IfFailThrow(pInternalImport->EnumGlobalFunctionsInit(&hEnumMethod)); - - while (pInternalImport->EnumNext(&hEnumMethod, &tk)) - { - _ASSERTE(TypeFromToken(tk) == mdtMethodDef); - DWORD dwMemberAttrs; - IfFailThrow(pInternalImport->GetMethodDefProps(tk, &dwMemberAttrs)); - - if (IsMdSpecialName(dwMemberAttrs)) - { - ULONG cSig; - PCCOR_SIGNATURE pSig; - LPCSTR pName; - IfFailThrow(pInternalImport->GetNameAndSigOfMethodDef(tk, &pSig, &cSig, &pName)); - - const char *pBaseName = ".__ctor"; - int ncBaseName = (int)strlen(pBaseName); - int nc = (int)strlen(pName); - if (nc >= ncBaseName && 0 == strcmp(pName + nc - ncBaseName, pBaseName)) - { - - MetaSig msig(pSig, cSig, pModule, &typeContext); - - // Looking for the prototype Ptr VC __ctor(Ptr VC, ByRef VC); - if (msig.NumFixedArgs() == 2) - { - if (msig.GetReturnType() == ELEMENT_TYPE_PTR) - { - SigPointer spret = msig.GetReturnProps(); - IfFailThrow(spret.GetElemType(NULL)); - CorElementType eType; - IfFailThrow(spret.GetElemType(&eType)); - if (eType == ELEMENT_TYPE_VALUETYPE) - { - mdToken tk0; - IfFailThrow(spret.GetToken(&tk0)); - hr = CompareTypeTokensNT(tk0, cl, pModule, pModule); - if (FAILED(hr)) - { - pInternalImport->EnumClose(&hEnumMethod); - ThrowHR(hr); - } - - if (hr == S_OK) - { - if (msig.NextArg() == ELEMENT_TYPE_PTR) - { - SigPointer sp1 = msig.GetArgProps(); - IfFailThrow(sp1.GetElemType(NULL)); - IfFailThrow(sp1.GetElemType(&eType)); - if (eType == ELEMENT_TYPE_VALUETYPE) - { - mdToken tk1; - IfFailThrow(sp1.GetToken(&tk1)); - hr = (tk1 == tk0) ? S_OK : CompareTypeTokensNT(tk1, cl, pModule, pModule); - if (FAILED(hr)) - { - pInternalImport->EnumClose(&hEnumMethod); - ThrowHR(hr); - } - - if (hr == S_OK) - { - if (msig.NextArg() == ELEMENT_TYPE_PTR && - msig.GetArgProps().HasCustomModifier(pModule, "Microsoft.VisualC.IsCXXReferenceModifier", ELEMENT_TYPE_CMOD_OPT)) - { - SigPointer sp2 = msig.GetArgProps(); - IfFailThrow(sp2.GetElemType(NULL)); - IfFailThrow(sp2.GetElemType(&eType)); - if (eType == ELEMENT_TYPE_VALUETYPE) - { - mdToken tk2; - IfFailThrow(sp2.GetToken(&tk2)); - - hr = (tk2 == tk0) ? S_OK : CompareTypeTokensNT(tk2, cl, pModule, pModule); - if (hr == S_OK) - { - *pMDOut = pModule->LookupMethodDef(tk); - return; - } - } - } - } - } - } - } - } - } - } - } - } - } + // Retrieve the custom marshaler helper from the EE marshaling data. + RETURN pMarshalingData->GetCustomMarshalerInfo(pAssembly, hndManagedType, strMarshalerTypeName, cMarshalerTypeNameBytes, strCookie, cCookieStrBytes); } - - //------------------------------------------------------------------------------------- - // Return the destructor for a VC class (if any exists) - //------------------------------------------------------------------------------------- - void FindDtor(Module *pModule, MethodTable *pMT, MethodDesc **pMDOut) +#ifdef FEATURE_COMINTEROP + CustomMarshalerInfo *GetIEnumeratorCustomMarshalerInfo(Assembly *pAssembly) { - CONTRACTL + CONTRACT (CustomMarshalerInfo*) { - THROWS; - GC_TRIGGERS; // CompareTypeTokens may trigger GC - MODE_ANY; + STANDARD_VM_CHECK; + PRECONDITION(CheckPointer(pAssembly)); + POSTCONDITION(CheckPointer(RETVAL)); } - CONTRACTL_END; + CONTRACT_END; - *pMDOut = NULL; + EEMarshalingData *pMarshalingData = NULL; - HRESULT hr; - mdMethodDef tk; - mdTypeDef cl = pMT->GetCl(); - TypeHandle th = TypeHandle(pMT); - SigTypeContext typeContext(th); + // The assembly is not shared so we use the current app domain's marshaling data. + pMarshalingData = pAssembly->GetLoaderAllocator()->GetMarshalingData(); - IMDInternalImport *pInternalImport = pModule->GetMDImport(); - MDEnumHolder hEnumMethod(pInternalImport); - - // - // First try for the new syntax: - // - IfFailThrow(pInternalImport->EnumInit(mdtMethodDef, cl, &hEnumMethod)); - - while (pInternalImport->EnumNext(&hEnumMethod, &tk)) - { - _ASSERTE(TypeFromToken(tk) == mdtMethodDef); - DWORD dwMemberAttrs; - IfFailThrow(pInternalImport->GetMethodDefProps(tk, &dwMemberAttrs)); - - if (IsMdSpecialName(dwMemberAttrs)) - { - ULONG cSig; - PCCOR_SIGNATURE pSig; - LPCSTR pName; - IfFailThrow(pInternalImport->GetNameAndSigOfMethodDef(tk, &pSig, &cSig, &pName)); - - const char *pBaseName = ""; - int ncBaseName = (int)strlen(pBaseName); - int nc = (int)strlen(pName); - if (nc >= ncBaseName && 0 == strcmp(pName + nc - ncBaseName, pBaseName)) - { - MetaSig msig(pSig, cSig, pModule, &typeContext); - - // Looking for the prototype void (Ptr VC); - if (msig.NumFixedArgs() == 1) - { - if (msig.GetReturnType() == ELEMENT_TYPE_VOID) - { - if (msig.NextArg() == ELEMENT_TYPE_PTR) - { - SigPointer sp1 = msig.GetArgProps(); - IfFailThrow(sp1.GetElemType(NULL)); - CorElementType eType; - IfFailThrow(sp1.GetElemType(&eType)); - if (eType == ELEMENT_TYPE_VALUETYPE) - { - mdToken tk1; - IfFailThrow(sp1.GetToken(&tk1)); - - hr = CompareTypeTokensNT(tk1, cl, pModule, pModule); - IfFailThrow(hr); - - if (hr == S_OK) - { - *pMDOut = pModule->LookupMethodDef(tk); - return; - } - } - } - } - } - } - } - } - - - // - // Next try the old syntax: global .__dtor - // - IfFailThrow(pInternalImport->EnumGlobalFunctionsInit(&hEnumMethod)); - - while (pInternalImport->EnumNext(&hEnumMethod, &tk)) - { - _ASSERTE(TypeFromToken(tk) == mdtMethodDef); - ULONG cSig; - PCCOR_SIGNATURE pSig; - LPCSTR pName; - IfFailThrow(pInternalImport->GetNameAndSigOfMethodDef(tk, &pSig, &cSig, &pName)); - - const char *pBaseName = ".__dtor"; - int ncBaseName = (int)strlen(pBaseName); - int nc = (int)strlen(pName); - if (nc >= ncBaseName && 0 == strcmp(pName + nc - ncBaseName, pBaseName)) - { - MetaSig msig(pSig, cSig, pModule, &typeContext); - - // Looking for the prototype void __dtor(Ptr VC); - if (msig.NumFixedArgs() == 1) - { - if (msig.GetReturnType() == ELEMENT_TYPE_VOID) - { - if (msig.NextArg() == ELEMENT_TYPE_PTR) - { - SigPointer sp1 = msig.GetArgProps(); - IfFailThrow(sp1.GetElemType(NULL)); - CorElementType eType; - IfFailThrow(sp1.GetElemType(&eType)); - if (eType == ELEMENT_TYPE_VALUETYPE) - { - mdToken tk1; - IfFailThrow(sp1.GetToken(&tk1)); - hr = CompareTypeTokensNT(tk1, cl, pModule, pModule); - if (FAILED(hr)) - { - pInternalImport->EnumClose(&hEnumMethod); - ThrowHR(hr); - } - - if (hr == S_OK) - { - *pMDOut = pModule->LookupMethodDef(tk); - return; - } - } - } - } - } - } - } + // Retrieve the custom marshaler helper from the EE marshaling data. + RETURN pMarshalingData->GetIEnumeratorMarshalerInfo(); } -} - -//========================================================================== -// Set's up the custom marshaler information. -//========================================================================== -CustomMarshalerHelper *SetupCustomMarshalerHelper(LPCUTF8 strMarshalerTypeName, DWORD cMarshalerTypeNameBytes, LPCUTF8 strCookie, DWORD cCookieStrBytes, Assembly *pAssembly, TypeHandle hndManagedType) -{ - CONTRACT (CustomMarshalerHelper*) - { - STANDARD_VM_CHECK; - PRECONDITION(CheckPointer(pAssembly)); - POSTCONDITION(CheckPointer(RETVAL)); - } - CONTRACT_END; - - EEMarshalingData *pMarshalingData = NULL; - - // The assembly is not shared so we use the current app domain's marshaling data. - pMarshalingData = pAssembly->GetLoaderAllocator()->GetMarshalingData(); - - // Retrieve the custom marshaler helper from the EE marshaling data. - RETURN pMarshalingData->GetCustomMarshalerHelper(pAssembly, hndManagedType, strMarshalerTypeName, cMarshalerTypeNameBytes, strCookie, cCookieStrBytes); -} +#endif // FEATURE_COMINTEROP -namespace -{ //========================================================================== // Return: S_OK if there is valid data to compress // S_FALSE if at end of data block @@ -743,69 +410,6 @@ VOID CollateParamTokens(IMDInternalImport *pInternalImport, mdMethodDef md, ULON } } - -#ifdef FEATURE_COMINTEROP -OleColorMarshalingInfo::OleColorMarshalingInfo() : - m_OleColorToSystemColorMD(NULL), - m_SystemColorToOleColorMD(NULL) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_ANY; - } - CONTRACTL_END; - - SString qualifiedColorTranslatorTypeName(SString::Utf8, COLOR_TRANSLATOR_ASM_QUAL_TYPE_NAME); - - // Load the color translator class. - TypeHandle hndColorTranslatorType = TypeName::GetTypeFromAsmQualifiedName(qualifiedColorTranslatorTypeName.GetUnicode(), TRUE /* bThrowIfNotFound */); - - SString qualifiedColorTypeName(SString::Utf8, COLOR_ASM_QUAL_TYPE_NAME); - // Load the color class. - m_hndColorType = TypeName::GetTypeFromAsmQualifiedName(qualifiedColorTypeName.GetUnicode(), TRUE /* bThrowIfNotFound */); - - // Retrieve the method to convert an OLE_COLOR to a System.Drawing.Color. - m_OleColorToSystemColorMD = MemberLoader::FindMethodByName(hndColorTranslatorType.GetMethodTable(), OLECOLOR_TO_SYSTEMCOLOR_METH_NAME); - _ASSERTE(m_OleColorToSystemColorMD && "Unable to find the translator method to convert an OLE_COLOR to a System.Drawing.Color!"); - _ASSERTE(m_OleColorToSystemColorMD->IsStatic() && "The translator method to convert an OLE_COLOR to a System.Drawing.Color must be static!"); - - // Retrieve the method to convert a System.Drawing.Color to an OLE_COLOR. - m_SystemColorToOleColorMD = MemberLoader::FindMethodByName(hndColorTranslatorType.GetMethodTable(), SYSTEMCOLOR_TO_OLECOLOR_METH_NAME); - _ASSERTE(m_SystemColorToOleColorMD && "Unable to find the translator method to convert a System.Drawing.Color to an OLE_COLOR!"); - _ASSERTE(m_SystemColorToOleColorMD->IsStatic() && "The translator method to convert a System.Drawing.Color to an OLE_COLOR must be static!"); -} - - -void *OleColorMarshalingInfo::operator new(size_t size, LoaderHeap *pHeap) -{ - CONTRACT (void*) - { - THROWS; - GC_NOTRIGGER; - MODE_ANY; - INJECT_FAULT(COMPlusThrowOM()); - PRECONDITION(CheckPointer(pHeap)); - POSTCONDITION(CheckPointer(RETVAL)); - } - CONTRACT_END; - - void* mem = pHeap->AllocMem(S_SIZE_T(size)); - - RETURN mem; -} - - -void OleColorMarshalingInfo::operator delete(void *pMem) -{ - LIMITED_METHOD_CONTRACT; - // Instances of this class are always allocated on the loader heap so - // the delete operator has nothing to do. -} - -#endif // FEATURE_COMINTEROP - EEMarshalingData::EEMarshalingData(LoaderAllocator* pAllocator, CrstBase *pCrst) : m_pAllocator(pAllocator), m_pHeap(pAllocator->GetLowFrequencyHeap()), @@ -821,8 +425,7 @@ EEMarshalingData::EEMarshalingData(LoaderAllocator* pAllocator, CrstBase *pCrst) LockOwner lock = {pCrst, IsOwnerOfCrst}; m_structILStubCache.Init(INITIAL_NUM_STRUCT_ILSTUB_HASHTABLE_BUCKETS, &lock); - m_CMHelperHashtable.Init(INITIAL_NUM_CMHELPER_HASHTABLE_BUCKETS, &lock); - m_SharedCMHelperToCMInfoMap.Init(INITIAL_NUM_CMINFO_HASHTABLE_BUCKETS, &lock); + m_CMInfoHashTable.Init(INITIAL_NUM_CMHELPER_HASHTABLE_BUCKETS, &lock); } @@ -830,22 +433,11 @@ EEMarshalingData::~EEMarshalingData() { WRAPPER_NO_CONTRACT; - CustomMarshalerInfo *pCMInfo; - - // @TODO(DM): Remove the linked list of CMInfo's and instead hang the OBJECTHANDLE - // contained inside the CMInfo off the AppDomain directly. The AppDomain can have - // a list of tasks to do when it gets teared down and we could leverage that - // to release the object handles. - - // Walk through the linked list and delete all the custom marshaler info's. - while ((pCMInfo = m_pCMInfoList.RemoveHead()) != NULL) - delete pCMInfo; - #ifdef FEATURE_COMINTEROP - if (m_pOleColorInfo) + if (m_pIEnumeratorMarshalerInfo) { - delete m_pOleColorInfo; - m_pOleColorInfo = NULL; + delete m_pIEnumeratorMarshalerInfo; + m_pIEnumeratorMarshalerInfo = NULL; } #endif } @@ -895,31 +487,28 @@ void EEMarshalingData::CacheStructILStub(MethodTable* pMT, MethodDesc* pStubMD) } -CustomMarshalerHelper *EEMarshalingData::GetCustomMarshalerHelper(Assembly *pAssembly, TypeHandle hndManagedType, LPCUTF8 strMarshalerTypeName, DWORD cMarshalerTypeNameBytes, LPCUTF8 strCookie, DWORD cCookieStrBytes) +CustomMarshalerInfo *EEMarshalingData::GetCustomMarshalerInfo(Assembly *pAssembly, TypeHandle hndManagedType, LPCUTF8 strMarshalerTypeName, DWORD cMarshalerTypeNameBytes, LPCUTF8 strCookie, DWORD cCookieStrBytes) { - CONTRACT (CustomMarshalerHelper*) + CONTRACT (CustomMarshalerInfo*) { - THROWS; - GC_TRIGGERS; - MODE_ANY; + STANDARD_VM_CHECK; INJECT_FAULT(COMPlusThrowOM()); PRECONDITION(CheckPointer(pAssembly)); POSTCONDITION(CheckPointer(RETVAL)); } CONTRACT_END; - CustomMarshalerHelper *pCMHelper = NULL; - CustomMarshalerHelper* pNewCMHelper = NULL; + CustomMarshalerInfo *pCMInfo = NULL; NewHolder pNewCMInfo(NULL); TypeHandle hndCustomMarshalerType; // Create the key that will be used to lookup in the hashtable. - EECMHelperHashtableKey Key(cMarshalerTypeNameBytes, strMarshalerTypeName, cCookieStrBytes, strCookie, hndManagedType.GetInstantiation(), pAssembly); + EECMInfoHashtableKey Key(cMarshalerTypeNameBytes, strMarshalerTypeName, cCookieStrBytes, strCookie, hndManagedType.GetInstantiation(), pAssembly); // Lookup the custom marshaler helper in the hashtable. - if (m_CMHelperHashtable.GetValue(&Key, (HashDatum*)&pCMHelper)) - RETURN pCMHelper; + if (m_CMInfoHashTable.GetValue(&Key, (HashDatum*)&pCMInfo)) + RETURN pCMInfo; { GCX_COOP(); @@ -941,127 +530,54 @@ CustomMarshalerHelper *EEMarshalingData::GetCustomMarshalerHelper(Assembly *pAss // Create the custom marshaler info in the specified heap. pNewCMInfo = new (m_pHeap) CustomMarshalerInfo(m_pAllocator, hndCustomMarshalerType, hndManagedType, strCookie, cCookieStrBytes); - - // Create the custom marshaler helper in the specified heap. - pNewCMHelper = new (m_pHeap) NonSharedCustomMarshalerHelper(pNewCMInfo); } { CrstHolder lock(m_lock); // Verify that the custom marshaler helper has not already been added by another thread. - if (m_CMHelperHashtable.GetValue(&Key, (HashDatum*)&pCMHelper)) - { - RETURN pCMHelper; - } - - // Add the custom marshaler helper to the hash table. - m_CMHelperHashtable.InsertValue(&Key, pNewCMHelper, FALSE); - - // If we create the CM info, then add it to the linked list. - if (pNewCMInfo) - { - m_pCMInfoList.InsertHead(pNewCMInfo); - pNewCMInfo.SuppressRelease(); - } - - // Release the lock and return the custom marshaler info. - } - - RETURN pNewCMHelper; -} - -CustomMarshalerInfo *EEMarshalingData::GetCustomMarshalerInfo(SharedCustomMarshalerHelper *pSharedCMHelper) -{ - CONTRACT (CustomMarshalerInfo*) - { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; - INJECT_FAULT(COMPlusThrowOM()); - POSTCONDITION(CheckPointer(RETVAL)); - } - CONTRACT_END; - - CustomMarshalerInfo *pCMInfo = NULL; - NewHolder pNewCMInfo(NULL); - TypeHandle hndCustomMarshalerType; - - // Lookup the custom marshaler helper in the hashtable. - if (m_SharedCMHelperToCMInfoMap.GetValue(pSharedCMHelper, (HashDatum*)&pCMInfo)) - RETURN pCMInfo; - - // Append a NULL terminator to the marshaler type name. - CQuickArray strCMMarshalerTypeName; - DWORD strLen = pSharedCMHelper->GetMarshalerTypeNameByteCount(); - strCMMarshalerTypeName.ReSizeThrows(pSharedCMHelper->GetMarshalerTypeNameByteCount() + 1); - memcpy(strCMMarshalerTypeName.Ptr(), pSharedCMHelper->GetMarshalerTypeName(), strLen); - strCMMarshalerTypeName[strLen] = 0; - - // Load the custom marshaler class. - hndCustomMarshalerType = TypeName::GetTypeReferencedByCustomAttribute(strCMMarshalerTypeName.Ptr(), pSharedCMHelper->GetAssembly()); - if (hndCustomMarshalerType.IsGenericTypeDefinition()) - { - // Instantiate generic custom marshalers using the instantiation of the type being marshaled. - hndCustomMarshalerType = hndCustomMarshalerType.Instantiate(pSharedCMHelper->GetManagedType().GetInstantiation()); - } - - // Create the custom marshaler info in the specified heap. - pNewCMInfo = new (m_pHeap) CustomMarshalerInfo(m_pAllocator, - hndCustomMarshalerType, - pSharedCMHelper->GetManagedType(), - pSharedCMHelper->GetCookieString(), - pSharedCMHelper->GetCookieStringByteCount()); - - { - CrstHolder lock(m_lock); - - // Verify that the custom marshaler info has not already been added by another thread. - if (m_SharedCMHelperToCMInfoMap.GetValue(pSharedCMHelper, (HashDatum*)&pCMInfo)) + if (m_CMInfoHashTable.GetValue(&Key, (HashDatum*)&pCMInfo)) { RETURN pCMInfo; } // Add the custom marshaler helper to the hash table. - m_SharedCMHelperToCMInfoMap.InsertValue(pSharedCMHelper, pNewCMInfo, FALSE); + m_CMInfoHashTable.InsertValue(&Key, pNewCMInfo); - // Add the custom marshaler into the linked list. - m_pCMInfoList.InsertHead(pNewCMInfo); + // If we create the CM info, then add it to the linked list. + pNewCMInfo.SuppressRelease(); // Release the lock and return the custom marshaler info. } - pNewCMInfo.SuppressRelease(); RETURN pNewCMInfo; } #ifdef FEATURE_COMINTEROP -OleColorMarshalingInfo *EEMarshalingData::GetOleColorMarshalingInfo() +CustomMarshalerInfo *EEMarshalingData::GetIEnumeratorMarshalerInfo() { - CONTRACT (OleColorMarshalingInfo*) + CONTRACT (CustomMarshalerInfo*) { - THROWS; - GC_TRIGGERS; - MODE_ANY; + STANDARD_VM_CHECK; INJECT_FAULT(COMPlusThrowOM()); POSTCONDITION(CheckPointer(RETVAL)); } CONTRACT_END; - if (m_pOleColorInfo == NULL) + if (m_pIEnumeratorMarshalerInfo == NULL) { - OleColorMarshalingInfo *pOleColorInfo = new (m_pHeap) OleColorMarshalingInfo(); + CustomMarshalerInfo *pMarshalerInfo = CustomMarshalerInfo::CreateIEnumeratorMarshalerInfo(m_pHeap, m_pAllocator); - if (InterlockedCompareExchangeT(&m_pOleColorInfo, pOleColorInfo, NULL) != NULL) + if (InterlockedCompareExchangeT(&m_pIEnumeratorMarshalerInfo, pMarshalerInfo, NULL) != NULL) { - // Another thread beat us to it. Delete on OleColorMarshalingInfo is an empty operation + // Another thread beat us to it. Delete on CustomMarshalerInfo is an empty operation // which is OK, since the possible leak is rare, small, and constant. This is the same // pattern as in code:GetCustomMarshalerInfo. - delete pOleColorInfo; + delete pMarshalerInfo; } } - RETURN m_pOleColorInfo; + RETURN m_pIEnumeratorMarshalerInfo; } #endif // FEATURE_COMINTEROP @@ -1117,6 +633,7 @@ namespace // Skip modreqs and modopts in the signature. case ELEMENT_TYPE_CMOD_OPT: case ELEMENT_TYPE_CMOD_REQD: + case ELEMENT_TYPE_CMOD_INTERNAL: { if(FAILED(sig.GetElemType(NULL))) { @@ -1251,13 +768,14 @@ MarshalInfo::MarshalInfo(Module* pModule, CorNativeType nativeType = NATIVE_TYPE_DEFAULT; Assembly *pAssembly = pModule->GetAssembly(); - BOOL fNeedsCopyCtor = FALSE; + Module* pCopyCtorModule = NULL; + mdToken pCopyCtorModifier = mdTokenNil; m_BestFit = BestFit; m_ThrowOnUnmappableChar = ThrowOnUnmappableChar; m_ms = ms; m_fAnsi = (ms == MARSHAL_SCENARIO_NDIRECT || ms == MARSHAL_SCENARIO_FIELD) && (nlType == nltAnsi); m_nativeArgSize = 0; - m_pCMHelper = NULL; + m_pCMInfo = NULL; m_CMVt = VT_EMPTY; m_args.m_pMarshalInfo = this; m_args.m_pMT = NULL; @@ -1378,11 +896,10 @@ MarshalInfo::MarshalInfo(Module* pModule, // Skip ET_BYREF IfFailGoto(sigtmp.GetByte(NULL), lFail); - if (sigtmp.HasCustomModifier(pModule, "Microsoft.VisualC.NeedsCopyConstructorModifier", ELEMENT_TYPE_CMOD_REQD) || - sigtmp.HasCustomModifier(pModule, "System.Runtime.CompilerServices.IsCopyConstructed", ELEMENT_TYPE_CMOD_REQD) ) + if (sigtmp.HasCustomModifier(pModule, "Microsoft.VisualC.NeedsCopyConstructorModifier", ELEMENT_TYPE_CMOD_REQD, &pCopyCtorModule, &pCopyCtorModifier) || + sigtmp.HasCustomModifier(pModule, "System.Runtime.CompilerServices.IsCopyConstructed", ELEMENT_TYPE_CMOD_REQD, &pCopyCtorModule, &pCopyCtorModifier) ) { mtype = ELEMENT_TYPE_VALUETYPE; - fNeedsCopyCtor = TRUE; m_byref = FALSE; } } @@ -1411,8 +928,8 @@ MarshalInfo::MarshalInfo(Module* pModule, if (!th.IsEnum()) { // Check for Copy Constructor Modifier - if (sigtmp.HasCustomModifier(pModule, "Microsoft.VisualC.NeedsCopyConstructorModifier", ELEMENT_TYPE_CMOD_REQD) || - sigtmp.HasCustomModifier(pModule, "System.Runtime.CompilerServices.IsCopyConstructed", ELEMENT_TYPE_CMOD_REQD) ) + if (sigtmp.HasCustomModifier(pModule, "Microsoft.VisualC.NeedsCopyConstructorModifier", ELEMENT_TYPE_CMOD_REQD, &pCopyCtorModule, &pCopyCtorModifier) || + sigtmp.HasCustomModifier(pModule, "System.Runtime.CompilerServices.IsCopyConstructed", ELEMENT_TYPE_CMOD_REQD, &pCopyCtorModule, &pCopyCtorModifier) ) { mtype = mtype2; @@ -1420,7 +937,6 @@ MarshalInfo::MarshalInfo(Module* pModule, // of this method we are pretending that the parameter is a value type passed by-value. IfFailGoto(sig.GetElemType(NULL), lFail); - fNeedsCopyCtor = TRUE; m_byref = FALSE; } } @@ -1454,7 +970,7 @@ MarshalInfo::MarshalInfo(Module* pModule, IfFailGoto(E_FAIL, lFail); } - // Set m_type to MARSHAL_TYPE_UNKNOWN in case SetupCustomMarshalerHelper throws. + // Set m_type to MARSHAL_TYPE_UNKNOWN in case SetupCustomMarshalerInfo throws. m_type = MARSHAL_TYPE_UNKNOWN; if (fLoadCustomMarshal) @@ -1464,7 +980,7 @@ MarshalInfo::MarshalInfo(Module* pModule, if (!fEmitsIL) { - m_pCMHelper = SetupCustomMarshalerHelper(ParamInfo.m_strCMMarshalerTypeName, + m_pCMInfo = SetupCustomMarshalerInfo(ParamInfo.m_strCMMarshalerTypeName, ParamInfo.m_cCMMarshalerTypeNameBytes, ParamInfo.m_strCMCookie, ParamInfo.m_cCMCookieStrBytes, @@ -1473,7 +989,7 @@ MarshalInfo::MarshalInfo(Module* pModule, } else { - m_pCMHelper = NULL; + m_pCMInfo = NULL; MethodDesc* pMDforModule = pMD; if (pMD->IsILStub()) { @@ -1952,15 +1468,11 @@ MarshalInfo::MarshalInfo(Module* pModule, { if (!fEmitsIL) { - m_pCMHelper = SetupCustomMarshalerHelper(ENUMERATOR_TO_ENUM_VARIANT_CM_NAME, - ENUMERATOR_TO_ENUM_VARIANT_CM_NAME_LEN, - ENUMERATOR_TO_ENUM_VARIANT_CM_COOKIE, - ENUMERATOR_TO_ENUM_VARIANT_CM_COOKIE_LEN, - pAssembly, sigTH); + m_pCMInfo = GetIEnumeratorCustomMarshalerInfo(pAssembly); } else { - m_pCMHelper = NULL; + m_pCMInfo = NULL; MethodDesc* pMDforModule = pMD; if (pMD->IsILStub()) { @@ -2295,6 +1807,14 @@ MarshalInfo::MarshalInfo(Module* pModule, IfFailGoto(E_FAIL, lFail); } + GCX_COOP(); + + FieldDesc* pColorTypeField = CoreLibBinder::GetField(FIELD__COLORMARSHALER__COLOR_TYPE); + pColorTypeField->CheckRunClassInitThrowing(); + void* colorTypeHandle = pColorTypeField->GetStaticValuePtr(); + + m_args.color.m_pColorType = TypeHandle::FromPtr(colorTypeHandle).GetMethodTable(); + m_type = MARSHAL_TYPE_OLECOLOR; } #endif // FEATURE_COMINTEROP @@ -2381,17 +1901,11 @@ MarshalInfo::MarshalInfo(Module* pModule, } else { - if (fNeedsCopyCtor && !IsFieldScenario()) // We don't support automatically discovering copy constructors for fields. + if (pCopyCtorModifier != mdTokenNil && !IsFieldScenario()) // We don't support automatically discovering copy constructors for fields. { #if defined(FEATURE_IJW) - MethodDesc *pCopyCtor; - MethodDesc *pDtor; - FindCopyCtor(pModule, m_pMT, &pCopyCtor); - FindDtor(pModule, m_pMT, &pDtor); - + m_args.mm.m_pSigMod = ClassLoader::LoadTypeDefOrRefThrowing(pCopyCtorModule, pCopyCtorModifier).AsMethodTable(); m_args.mm.m_pMT = m_pMT; - m_args.mm.m_pCopyCtor = pCopyCtor; - m_args.mm.m_pDtor = pDtor; m_type = MARSHAL_TYPE_BLITTABLEVALUECLASSWITHCOPYCTOR; #else // !defined(FEATURE_IJW) m_resID = IDS_EE_BADMARSHAL_BADMANAGED; @@ -2813,7 +2327,6 @@ namespace void MarshalInfo::GenerateArgumentIL(NDirectStubLinker* psl, int argOffset, // the argument's index is m_paramidx + argOffset - UINT nativeStackOffset, // offset of the argument on the native stack BOOL fMngToNative) { CONTRACTL @@ -2841,8 +2354,7 @@ void MarshalInfo::GenerateArgumentIL(NDirectStubLinker* psl, fMngToNative, &m_args, &resID, - m_paramidx + argOffset, - nativeStackOffset); + m_paramidx + argOffset); if (amostat == OVERRIDDEN) @@ -3627,7 +3139,7 @@ DispParamMarshaler *MarshalInfo::GenerateDispParamMarshaler() break; case MARSHAL_TYPE_REFERENCECUSTOMMARSHALER: - pDispParamMarshaler = new DispParamCustomMarshaler(m_pCMHelper, m_CMVt); + pDispParamMarshaler = new DispParamCustomMarshaler(m_pCMInfo, m_CMVt); break; } @@ -4079,14 +3591,14 @@ bool IsUnsupportedTypedrefReturn(MetaSig& msig) #include "stubhelpers.h" -extern "C" void* QCALLTYPE StubHelpers_CreateCustomMarshalerHelper(MethodDesc* pMD, mdToken paramToken, TypeHandle hndManagedType) +extern "C" void QCALLTYPE StubHelpers_CreateCustomMarshaler(MethodDesc* pMD, mdToken paramToken, TypeHandle hndManagedType, QCall::ObjectHandleOnStack retObject) { QCALL_CONTRACT; - CustomMarshalerHelper* pCMHelper = NULL; - BEGIN_QCALL; + CustomMarshalerInfo* pCMInfo = NULL; + Module* pModule = pMD->GetModule(); Assembly* pAssembly = pModule->GetAssembly(); @@ -4094,40 +3606,37 @@ extern "C" void* QCALLTYPE StubHelpers_CreateCustomMarshalerHelper(MethodDesc* p if (!hndManagedType.IsTypeDesc() && IsTypeRefOrDef(g_CollectionsEnumeratorClassName, hndManagedType.GetModule(), hndManagedType.GetCl())) { - pCMHelper = SetupCustomMarshalerHelper(ENUMERATOR_TO_ENUM_VARIANT_CM_NAME, - ENUMERATOR_TO_ENUM_VARIANT_CM_NAME_LEN, - ENUMERATOR_TO_ENUM_VARIANT_CM_COOKIE, - ENUMERATOR_TO_ENUM_VARIANT_CM_COOKIE_LEN, - pAssembly, hndManagedType); + _ASSERTE(!"Setting the custom marshaler for IEnumerator should be done on the managed side."); } - else #endif // FEATURE_COMINTEROP - { - // - // Retrieve the native type for the current parameter. - // - BOOL result; - NativeTypeParamInfo ParamInfo; - result = ParseNativeTypeInfo(paramToken, pModule->GetMDImport(), &ParamInfo); + // + // Retrieve the native type for the current parameter. + // + + BOOL result; + NativeTypeParamInfo ParamInfo; + result = ParseNativeTypeInfo(paramToken, pModule->GetMDImport(), &ParamInfo); - // - // this should all have been done at stub creation time - // - CONSISTENCY_CHECK(result != 0); - CONSISTENCY_CHECK(ParamInfo.m_NativeType == NATIVE_TYPE_CUSTOMMARSHALER); - - // Set up the custom marshaler info. - pCMHelper = SetupCustomMarshalerHelper(ParamInfo.m_strCMMarshalerTypeName, - ParamInfo.m_cCMMarshalerTypeNameBytes, - ParamInfo.m_strCMCookie, - ParamInfo.m_cCMCookieStrBytes, - pAssembly, - hndManagedType); + // + // this should all have been done at stub creation time + // + CONSISTENCY_CHECK(result != 0); + CONSISTENCY_CHECK(ParamInfo.m_NativeType == NATIVE_TYPE_CUSTOMMARSHALER); + + // Set up the custom marshaler info. + pCMInfo = SetupCustomMarshalerInfo(ParamInfo.m_strCMMarshalerTypeName, + ParamInfo.m_cCMMarshalerTypeNameBytes, + ParamInfo.m_strCMCookie, + ParamInfo.m_cCMCookieStrBytes, + pAssembly, + hndManagedType); + + { + GCX_COOP(); + retObject.Set(pCMInfo->GetCustomMarshaler()); } END_QCALL; - - return (void*)pCMHelper; } diff --git a/src/coreclr/vm/mlinfo.h b/src/coreclr/vm/mlinfo.h index 93a0f554d30..3d2c5186556 100644 --- a/src/coreclr/vm/mlinfo.h +++ b/src/coreclr/vm/mlinfo.h @@ -87,9 +87,8 @@ struct OverrideProcArgs struct { + MethodTable* m_pSigMod; MethodTable* m_pMT; - MethodDesc* m_pCopyCtor; - MethodDesc* m_pDtor; } mm; struct @@ -103,6 +102,13 @@ struct OverrideProcArgs { UINT32 fixedStringLength; } fs; + +#ifdef FEATURE_COMINTEROP + struct + { + MethodTable* m_pColorType; + } color; +#endif }; }; @@ -113,8 +119,7 @@ typedef MarshalerOverrideStatus (*OVERRIDEPROC)(NDirectStubLinker* psl, BOOL fManagedToNative, OverrideProcArgs* pargs, UINT* pResID, - UINT argidx, - UINT nativeStackOffset); + UINT argidx); typedef MarshalerOverrideStatus (*RETURNOVERRIDEPROC)(NDirectStubLinker* psl, BOOL fManagedToNative, @@ -190,45 +195,6 @@ BOOL ParseNativeTypeInfo(mdToken token, BOOL IsFixedBuffer(mdFieldDef field, IMDInternalImport* pInternalImport); #endif -#ifdef FEATURE_COMINTEROP -class OleColorMarshalingInfo -{ -public: - // Constructor. - OleColorMarshalingInfo(); - - // OleColorMarshalingInfo's are always allocated on the loader heap so we need to redefine - // the new and delete operators to ensure this. - void *operator new(size_t size, LoaderHeap *pHeap); - void operator delete(void *pMem); - - // Accessors. - TypeHandle GetColorType() - { - LIMITED_METHOD_CONTRACT; - return m_hndColorType; - } - MethodDesc *GetOleColorToSystemColorMD() - { - LIMITED_METHOD_CONTRACT; - return m_OleColorToSystemColorMD; - } - MethodDesc *GetSystemColorToOleColorMD() - { - LIMITED_METHOD_CONTRACT; - return m_SystemColorToOleColorMD; - } - - -private: - TypeHandle m_hndColorType; - MethodDesc* m_OleColorToSystemColorMD; - MethodDesc* m_SystemColorToOleColorMD; -}; - -#endif // FEATURE_COMINTEROP - - class EEMarshalingData { public: @@ -260,27 +226,21 @@ class EEMarshalingData void CacheStructILStub(MethodTable* pMT, MethodDesc* pStubMD); #endif - // This method returns the custom marshaling helper associated with the name cookie pair. If the + // This method returns the custom marshaling info associated with the name cookie pair. If the // CM info has not been created yet for this pair then it will be created and returned. - CustomMarshalerHelper *GetCustomMarshalerHelper(Assembly *pAssembly, TypeHandle hndManagedType, LPCUTF8 strMarshalerTypeName, DWORD cMarshalerTypeNameBytes, LPCUTF8 strCookie, DWORD cCookieStrBytes); - - // This method returns the custom marshaling info associated with shared CM helper. - CustomMarshalerInfo *GetCustomMarshalerInfo(SharedCustomMarshalerHelper *pSharedCMHelper); + CustomMarshalerInfo *GetCustomMarshalerInfo(Assembly *pAssembly, TypeHandle hndManagedType, LPCUTF8 strMarshalerTypeName, DWORD cMarshalerTypeNameBytes, LPCUTF8 strCookie, DWORD cCookieStrBytes); #ifdef FEATURE_COMINTEROP - // This method retrieves OLE_COLOR marshaling info. - OleColorMarshalingInfo *GetOleColorMarshalingInfo(); + CustomMarshalerInfo *GetIEnumeratorMarshalerInfo(); #endif // FEATURE_COMINTEROP private: EEPtrHashTable m_structILStubCache; - EECMHelperHashTable m_CMHelperHashtable; - EEPtrHashTable m_SharedCMHelperToCMInfoMap; + EECMInfoHashTable m_CMInfoHashTable; LoaderAllocator* m_pAllocator; LoaderHeap* m_pHeap; - CMINFOLIST m_pCMInfoList; #ifdef FEATURE_COMINTEROP - OleColorMarshalingInfo* m_pOleColorInfo; + CustomMarshalerInfo* m_pIEnumeratorMarshalerInfo; #endif // FEATURE_COMINTEROP CrstBase* m_lock; }; @@ -356,7 +316,6 @@ class MarshalInfo void GenerateArgumentIL(NDirectStubLinker* psl, int argOffset, // the argument's index is m_paramidx + argOffset - UINT nativeStackOffset, // offset of the argument on the native stack BOOL fMngToNative); void GenerateReturnIL(NDirectStubLinker* psl, @@ -546,7 +505,7 @@ class MarshalInfo #endif // FEATURE_COMINTEROP // Information used by NT_CUSTOMMARSHALER. - CustomMarshalerHelper* m_pCMHelper; + CustomMarshalerInfo* m_pCMInfo; VARTYPE m_CMVt; OverrideProcArgs m_args; diff --git a/src/coreclr/vm/mngstdinterfaces.cpp b/src/coreclr/vm/mngstdinterfaces.cpp deleted file mode 100644 index 1e8a4800be4..00000000000 --- a/src/coreclr/vm/mngstdinterfaces.cpp +++ /dev/null @@ -1,813 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -/*============================================================ -** -** Header: MngStdInterfaces.cpp -** -** -** Purpose: Contains the implementation of the MngStdInterfaces -** class. This class is used to determine the associated -** -** - -===========================================================*/ - -#include "common.h" - -#include "mngstdinterfaces.h" -#include "dispex.h" -#include "class.h" -#include "method.hpp" -#include "runtimecallablewrapper.h" -#include "excep.h" - -// -// Declare the static field int the ManagedStdInterfaceMap class. -// - -MngStdInterfaceMap *MngStdInterfaceMap::m_pMngStdItfMap=NULL; - - -// -// Defines used ManagedStdInterfaceMap class implementation. -// - -// Use this macro to define an entry in the managed standard interface map. -#define STD_INTERFACE_MAP_ENTRY(TypeName, NativeIID) \ - m_TypeNameToNativeIIDMap.InsertValue((TypeName), (void*)&(NativeIID), TRUE) - -// -// Defines used StdMngItfBase class implementation. -// - -// The GetInstance method name and signature. -#define GET_INSTANCE_METH_NAME "GetInstance" -#define GET_INSTANCE_METH_SIG &gsig_SM_Str_RetICustomMarshaler - -// The initial number of buckets in the managed standard interface map. -#define INITIAL_NUM_BUCKETS 64 - - -// -// This method is used to build the managed standard interface map. -// - -MngStdInterfaceMap::MngStdInterfaceMap() -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - INJECT_FAULT(COMPlusThrowOM()); - } - CONTRACTL_END - - // - // Initialize the hashtable. - // - - m_TypeNameToNativeIIDMap.Init(INITIAL_NUM_BUCKETS,NULL,NULL); - - // - // Define the mapping for the managed standard interfaces. - // - -#define MNGSTDITF_BEGIN_INTERFACE(FriendlyName, strMngItfName, strUCOMMngItfName, strCustomMarshalerName, strCustomMarshalerCookie, strManagedViewName, NativeItfIID, bCanCastOnNativeItfQI) \ - STD_INTERFACE_MAP_ENTRY(strMngItfName, bCanCastOnNativeItfQI ? NativeItfIID : GUID_NULL); - -#define MNGSTDITF_DEFINE_METH_IMPL(FriendlyName, ECallMethName, MethName, MethSig, FcallDecl) - -#define MNGSTDITF_END_INTERFACE(FriendlyName) - -#include "mngstditflist.h" - -#undef MNGSTDITF_BEGIN_INTERFACE -#undef MNGSTDITF_DEFINE_METH_IMPL -#undef MNGSTDITF_END_INTERFACE -} - - -// -// Helper method to load the types used inside the classes that implement the ECall's for -// the managed standard interfaces. -// - -void MngStdItfBase::InitHelper( - LPCUTF8 strMngItfTypeName, - LPCUTF8 strUComItfTypeName, - LPCUTF8 strCMTypeName, - LPCUTF8 strCookie, - LPCUTF8 strManagedViewName, - TypeHandle *pMngItfType, - TypeHandle *pUComItfType, - TypeHandle *pCustomMarshalerType, - TypeHandle *pManagedViewType, - OBJECTHANDLE *phndMarshaler) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - INJECT_FAULT(COMPlusThrowOM()); - } - CONTRACTL_END - - // Load the managed interface type. - *pMngItfType = ClassLoader::LoadTypeByNameThrowing(SystemDomain::SystemAssembly(), NULL, strMngItfTypeName); - - // Run the for the managed interface type. - pMngItfType->GetMethodTable()->CheckRestore(); - pMngItfType->GetMethodTable()->CheckRunClassInitThrowing(); - - // Load the UCom type. - *pUComItfType = ClassLoader::LoadTypeByNameThrowing(SystemDomain::SystemAssembly(), NULL, strUComItfTypeName); - - // Run the for the UCom type. - pUComItfType->GetMethodTable()->CheckRestore(); - pUComItfType->GetMethodTable()->CheckRunClassInitThrowing(); - - // Retrieve the custom marshaler type handle. - *pCustomMarshalerType = ClassLoader::LoadTypeByNameThrowing(SystemDomain::SystemAssembly(), NULL, strCMTypeName); - - // Run the for the marshaller. - pCustomMarshalerType->GetMethodTable()->EnsureInstanceActive(); - pCustomMarshalerType->GetMethodTable()->CheckRunClassInitThrowing(); - - // Load the managed view. - *pManagedViewType = ClassLoader::LoadTypeByNameThrowing(SystemDomain::SystemAssembly(), NULL, strManagedViewName); - - // Run the for the managed view. - pManagedViewType->GetMethodTable()->EnsureInstanceActive(); - pManagedViewType->GetMethodTable()->CheckRunClassInitThrowing(); - - // Retrieve the GetInstance method. - MethodDesc *pGetInstanceMD = MemberLoader::FindMethod(pCustomMarshalerType->GetMethodTable(), GET_INSTANCE_METH_NAME, GET_INSTANCE_METH_SIG); - _ASSERTE(pGetInstanceMD && "Unable to find specified custom marshaler method"); - - // Allocate the string object that will be passed to the GetInstance method. - STRINGREF strObj = StringObject::NewString(strCookie); - GCPROTECT_BEGIN(strObj); - { - MethodDescCallSite getInstance(pGetInstanceMD, (OBJECTREF*)&strObj); - - // Prepare the arguments that will be passed to GetInstance. - ARG_SLOT GetInstanceArgs[] = { - ObjToArgSlot(strObj) - }; - - // Call the static GetInstance method to retrieve the custom marshaler to use. - OBJECTREF Marshaler = getInstance.Call_RetOBJECTREF(GetInstanceArgs); - - // Cache the handle to the marshaler for faster access. - (*phndMarshaler) = SystemDomain::GetCurrentDomain()->CreateHandle(Marshaler); - } - GCPROTECT_END(); -} - - -// -// Helper method that forwards the calls to either the managed view or to the native component if it -// implements the managed interface. -// - -LPVOID MngStdItfBase::ForwardCallToManagedView( - OBJECTHANDLE hndMarshaler, - MethodDesc *pMngItfMD, - MethodDesc *pUComItfMD, - MethodDesc *pMarshalNativeToManagedMD, - MethodDesc *pMngViewMD, - IID *pMngItfIID, - IID *pNativeItfIID, - ARG_SLOT* pArgs) -{ - STATIC_CONTRACT_THROWS; - STATIC_CONTRACT_GC_TRIGGERS; - STATIC_CONTRACT_FAULT; - - Object* Result = 0; - ULONG cbRef; - HRESULT hr; - IUnknown *pMngItf; - IUnknown *pNativeItf; - OBJECTREF ManagedView; - BOOL RetValIsProtected = FALSE; - struct LocalGcRefs { - OBJECTREF Obj; - OBJECTREF Result; - } Lr; - - // Retrieve the object that the call was made on. - Lr.Obj = ArgSlotToObj(pArgs[0]); - Lr.Result = NULL; - GCPROTECT_BEGIN(Lr); - { - SafeComHolder pUnk = NULL; - - _ASSERTE(Lr.Obj != NULL); - - MethodTable *pTargetMT = Lr.Obj->GetMethodTable(); - - { - // The target isn't a TP so it better be a COM object. - _ASSERTE(Lr.Obj->GetMethodTable()->IsComObjectType()); - - { - RCWHolder pRCW(GetThread()); - RCWPROTECT_BEGIN(pRCW, Lr.Obj); - - // Get the IUnknown on the current thread. - pUnk = pRCW->GetIUnknown(); - _ASSERTE(pUnk); - - RCW_VTABLEPTR(pRCW); - - // Check to see if the component implements the interface natively. - hr = SafeQueryInterface(pUnk, *pMngItfIID, &pMngItf); - LogInteropQI(pUnk, *pMngItfIID, hr, "Custom marshaler fwd call QI for managed interface"); - if (SUCCEEDED(hr)) - { - // Release our ref-count on the managed interface. - cbRef = SafeRelease(pMngItf); - LogInteropRelease(pMngItf, cbRef, "Custom marshaler call releasing managed interface"); - - MethodDescCallSite UComItf(pUComItfMD, &Lr.Obj); - - // The component implements the interface natively so we need to dispatch to it directly. - Result = UComItf.Call_RetObjPtr(pArgs); - if (UComItf.GetMetaSig()->IsObjectRefReturnType()) - { - Lr.Result = ObjectToOBJECTREF(Result); - RetValIsProtected = TRUE; - } - } - else - { - // QI for the native interface that will be passed to MarshalNativeToManaged. - hr = SafeQueryInterface(pUnk, *pNativeItfIID, (IUnknown**)&pNativeItf); - LogInteropQI(pUnk, *pNativeItfIID, hr, "Custom marshaler call QI for native interface"); - _ASSERTE(SUCCEEDED(hr)); - - MethodDescCallSite marshalNativeToManaged(pMarshalNativeToManagedMD, hndMarshaler); - - // Prepare the arguments that will be passed to GetInstance. - ARG_SLOT MarshalNativeToManagedArgs[] = { - ObjToArgSlot(ObjectFromHandle(hndMarshaler)), - (ARG_SLOT)pNativeItf - }; - - // Retrieve the managed view for the current native interface pointer. - ManagedView = marshalNativeToManaged.Call_RetOBJECTREF(MarshalNativeToManagedArgs); - GCPROTECT_BEGIN(ManagedView); - { - // Release our ref-count on pNativeItf. - cbRef = SafeRelease(pNativeItf); - LogInteropRelease(pNativeItf, cbRef, "Custom marshaler fwd call releasing native interface"); - - MethodDescCallSite mngView(pMngViewMD, &ManagedView); - - // Replace the this in pArgs by the this of the managed view. - (*(Object**)pArgs) = OBJECTREFToObject(ManagedView); - - // Do the actual call to the method in the managed view passing in the args. - Result = mngView.Call_RetObjPtr(pArgs); - if (mngView.GetMetaSig()->IsObjectRefReturnType()) - { - Lr.Result = ObjectToOBJECTREF(Result); - RetValIsProtected = TRUE; - } - } - GCPROTECT_END(); - } - RCWPROTECT_END(pRCW); - } - } - } - GCPROTECT_END(); - - if (RetValIsProtected) - Result = OBJECTREFToObject(Lr.Result); - - return (void*)Result; -} - - -#define MNGSTDITF_BEGIN_INTERFACE(FriendlyName, strMngItfName, strUCOMMngItfName, strCustomMarshalerName, strCustomMarshalerCookie, strManagedViewName, NativeItfIID, bCanCastOnNativeItfQI) \ - -#define MNGSTDITF_DEFINE_METH_IMPL(FriendlyName, ECallMethName, MethName, MethSig, FcallDecl) \ -\ - LPVOID __stdcall FriendlyName::ECallMethName##Worker(ARG_SLOT* pArgs) \ - { \ - WRAPPER_NO_CONTRACT; \ - FriendlyName *pMngStdItfInfo = SystemDomain::GetCurrentDomain()->GetMngStdInterfacesInfo()->Get##FriendlyName(); \ - return ForwardCallToManagedView( \ - pMngStdItfInfo->m_hndCustomMarshaler, \ - pMngStdItfInfo->GetMngItfMD(FriendlyName##Methods_##ECallMethName, #MethName, MethSig), \ - pMngStdItfInfo->GetUComItfMD(FriendlyName##Methods_##ECallMethName, #MethName, MethSig), \ - pMngStdItfInfo->GetCustomMarshalerMD(CustomMarshalerMethods_MarshalNativeToManaged), \ - pMngStdItfInfo->GetManagedViewMD(FriendlyName##Methods_##ECallMethName, #MethName, MethSig), \ - &pMngStdItfInfo->m_MngItfIID, \ - &pMngStdItfInfo->m_NativeItfIID, \ - pArgs); \ - } - -#define MNGSTDITF_END_INTERFACE(FriendlyName) - - -#include "mngstditflist.h" - - -#undef MNGSTDITF_BEGIN_INTERFACE -#undef MNGSTDITF_DEFINE_METH_IMPL -#undef MNGSTDITF_END_INTERFACE - - -FCIMPL1(FC_BOOL_RET, StdMngIEnumerator::MoveNext, Object* refThisUNSAFE) -{ - CONTRACTL - { - FCALL_CHECK; - PRECONDITION(CheckPointer(refThisUNSAFE)); - } - CONTRACTL_END; - - LPVOID retVal = NULL; - ARG_SLOT args[1] = - { - ObjToArgSlot(ObjectToOBJECTREF(refThisUNSAFE)) - }; - - HELPER_METHOD_FRAME_BEGIN_RET_NOPOLL(); - - GCPROTECT_ARRAY_BEGIN(args[0], 1); - - retVal = MoveNextWorker(args); - - GCPROTECT_END(); - HELPER_METHOD_FRAME_END_POLL(); - - // Actual return type is a managed 'bool', so only look at a CLR_BOOL-sized - // result. The high bits are undefined on AMD64. (Note that a narrowing - // cast to CLR_BOOL will not work since it is the same as checking the - // size_t result != 0.) - FC_RETURN_BOOL(*(CLR_BOOL*)StackElemEndiannessFixup(&retVal, sizeof(CLR_BOOL))); -} -FCIMPLEND - -FCIMPL1(Object*, StdMngIEnumerator::get_Current, Object* refThisUNSAFE) -{ - CONTRACTL - { - FCALL_CHECK; - PRECONDITION(CheckPointer(refThisUNSAFE)); - } - CONTRACTL_END; - - OBJECTREF retVal = NULL; - ARG_SLOT args[1] = - { - ObjToArgSlot(ObjectToOBJECTREF(refThisUNSAFE)) - }; - - HELPER_METHOD_FRAME_BEGIN_RET_NOPOLL(); - - GCPROTECT_ARRAY_BEGIN(args[0], 1); - - retVal = ObjectToOBJECTREF((Object*)get_CurrentWorker(args)); - - GCPROTECT_END(); - HELPER_METHOD_FRAME_END(); - - FC_GC_POLL_AND_RETURN_OBJREF(retVal); -} -FCIMPLEND - -FCIMPL1(void, StdMngIEnumerator::Reset, Object* refThisUNSAFE) -{ - CONTRACTL - { - FCALL_CHECK; - PRECONDITION(CheckPointer(refThisUNSAFE)); - } - CONTRACTL_END; - - ARG_SLOT args[1] = - { - ObjToArgSlot(ObjectToOBJECTREF(refThisUNSAFE)) - }; - - HELPER_METHOD_FRAME_BEGIN_NOPOLL(); - - GCPROTECT_ARRAY_BEGIN(args[0], 1); - - ResetWorker(args); - - GCPROTECT_END(); - HELPER_METHOD_FRAME_END_POLL(); -} -FCIMPLEND - -FCIMPL6(Object*, StdMngIReflect::GetMethod, Object* refThisUNSAFE, Object* refNameUNSAFE, INT32 enumBindingAttr, Object* refBinderUNSAFE, Object* refTypesArrayUNSAFE, Object* refModifiersArrayUNSAFE) -{ - CONTRACTL - { - FCALL_CHECK; - PRECONDITION(CheckPointer(refThisUNSAFE)); - } - CONTRACTL_END; - - OBJECTREF retVal = NULL; - ARG_SLOT args[6] = - { - /* 0 */ ObjToArgSlot(ObjectToOBJECTREF(refThisUNSAFE)), - /* 1 */ ObjToArgSlot(ObjectToOBJECTREF(refNameUNSAFE)), - /* 2 */ enumBindingAttr, - /* 3 */ ObjToArgSlot(ObjectToOBJECTREF(refBinderUNSAFE)), - /* 4 */ ObjToArgSlot(ObjectToOBJECTREF(refTypesArrayUNSAFE)), - /* 5 */ ObjToArgSlot(ObjectToOBJECTREF(refModifiersArrayUNSAFE)) - }; - - HELPER_METHOD_FRAME_BEGIN_RET_NOPOLL(); - - GCPROTECT_ARRAY_BEGIN(args[0], 2); - GCPROTECT_ARRAY_BEGIN(args[3], 3); - - retVal = ObjectToOBJECTREF((Object*)GetMethodWorker(args)); - - GCPROTECT_END(); - GCPROTECT_END(); - HELPER_METHOD_FRAME_END(); - - FC_GC_POLL_AND_RETURN_OBJREF(retVal); -} -FCIMPLEND - -FCIMPL3(Object*, StdMngIReflect::GetMethod_2, Object* refThisUNSAFE, Object* refNameUNSAFE, INT32 enumBindingAttr) -{ - CONTRACTL - { - FCALL_CHECK; - PRECONDITION(CheckPointer(refThisUNSAFE)); - } - CONTRACTL_END; - - OBJECTREF retVal = NULL; - ARG_SLOT args[3] = - { - ObjToArgSlot(ObjectToOBJECTREF(refThisUNSAFE)), - ObjToArgSlot(ObjectToOBJECTREF(refNameUNSAFE)), - enumBindingAttr - }; - - HELPER_METHOD_FRAME_BEGIN_RET_NOPOLL(); - - GCPROTECT_ARRAY_BEGIN(args[0], 2); - - retVal = ObjectToOBJECTREF((Object*)GetMethod_2Worker(args)); - - GCPROTECT_END(); - HELPER_METHOD_FRAME_END(); - - FC_GC_POLL_AND_RETURN_OBJREF(retVal); -} -FCIMPLEND - -FCIMPL2(Object*, StdMngIReflect::GetMethods, Object* refThisUNSAFE, INT32 enumBindingAttr) -{ - CONTRACTL - { - FCALL_CHECK; - PRECONDITION(CheckPointer(refThisUNSAFE)); - } - CONTRACTL_END; - - OBJECTREF retVal = NULL; - ARG_SLOT args[2] = - { - ObjToArgSlot(ObjectToOBJECTREF(refThisUNSAFE)), - enumBindingAttr - }; - - HELPER_METHOD_FRAME_BEGIN_RET_NOPOLL(); - - GCPROTECT_ARRAY_BEGIN(args[0], 1); - - retVal = ObjectToOBJECTREF((Object*)GetMethodsWorker(args)); - - GCPROTECT_END(); - HELPER_METHOD_FRAME_END(); - - FC_GC_POLL_AND_RETURN_OBJREF(retVal); -} -FCIMPLEND - -FCIMPL3(Object*, StdMngIReflect::GetField, Object* refThisUNSAFE, Object* refNameUNSAFE, INT32 enumBindingAttr) -{ - CONTRACTL - { - FCALL_CHECK; - PRECONDITION(CheckPointer(refThisUNSAFE)); - } - CONTRACTL_END; - - OBJECTREF retVal = NULL; - ARG_SLOT args[3] = - { - ObjToArgSlot(ObjectToOBJECTREF(refThisUNSAFE)), - ObjToArgSlot(ObjectToOBJECTREF(refNameUNSAFE)), - enumBindingAttr - }; - - HELPER_METHOD_FRAME_BEGIN_RET_NOPOLL(); - - GCPROTECT_ARRAY_BEGIN(args[0], 2); - - retVal = ObjectToOBJECTREF((Object*)GetFieldWorker(args)); - - GCPROTECT_END(); - HELPER_METHOD_FRAME_END(); - - FC_GC_POLL_AND_RETURN_OBJREF(retVal); -} -FCIMPLEND - -FCIMPL2(Object*, StdMngIReflect::GetFields, Object* refThisUNSAFE, INT32 enumBindingAttr) -{ - CONTRACTL - { - FCALL_CHECK; - PRECONDITION(CheckPointer(refThisUNSAFE)); - } - CONTRACTL_END; - - OBJECTREF retVal = NULL; - ARG_SLOT args[2] = - { - ObjToArgSlot(ObjectToOBJECTREF(refThisUNSAFE)), - enumBindingAttr - }; - - HELPER_METHOD_FRAME_BEGIN_RET_NOPOLL(); - - GCPROTECT_ARRAY_BEGIN(args[0], 1); - - retVal = ObjectToOBJECTREF((Object*)GetFieldsWorker(args)); - - GCPROTECT_END(); - HELPER_METHOD_FRAME_END(); - - FC_GC_POLL_AND_RETURN_OBJREF(retVal); -} -FCIMPLEND - -FCIMPL7(Object*, StdMngIReflect::GetProperty, Object* refThisUNSAFE, Object* refNameUNSAFE, INT32 enumBindingAttr, Object* refBinderUNSAFE, Object* refTypeUNSAFE, Object* refTypesArrayUNSAFE, Object* refModifiersArrayUNSAFE) -{ - CONTRACTL - { - FCALL_CHECK; - PRECONDITION(CheckPointer(refThisUNSAFE)); - } - CONTRACTL_END; - - OBJECTREF retVal = NULL; - ARG_SLOT args[7] = - { - /* 0 */ ObjToArgSlot(ObjectToOBJECTREF(refThisUNSAFE)), - /* 1 */ ObjToArgSlot(ObjectToOBJECTREF(refNameUNSAFE)), - /* 2 */ enumBindingAttr, - /* 3 */ ObjToArgSlot(ObjectToOBJECTREF(refBinderUNSAFE)), - /* 4 */ ObjToArgSlot(ObjectToOBJECTREF(refTypeUNSAFE)), - /* 5 */ ObjToArgSlot(ObjectToOBJECTREF(refTypesArrayUNSAFE)), - /* 6 */ ObjToArgSlot(ObjectToOBJECTREF(refModifiersArrayUNSAFE)) - }; - - HELPER_METHOD_FRAME_BEGIN_RET_NOPOLL(); - - GCPROTECT_ARRAY_BEGIN(args[0], 2); - GCPROTECT_ARRAY_BEGIN(args[3], 4); - - retVal = ObjectToOBJECTREF((Object*)GetFieldWorker(args)); - - GCPROTECT_END(); - GCPROTECT_END(); - HELPER_METHOD_FRAME_END(); - - FC_GC_POLL_AND_RETURN_OBJREF(retVal); -} -FCIMPLEND - -FCIMPL3(Object*, StdMngIReflect::GetProperty_2, Object* refThisUNSAFE, Object* refNameUNSAFE, INT32 enumBindingAttr) -{ - CONTRACTL - { - FCALL_CHECK; - PRECONDITION(CheckPointer(refThisUNSAFE)); - } - CONTRACTL_END; - - OBJECTREF retVal = NULL; - ARG_SLOT args[3] = - { - ObjToArgSlot(ObjectToOBJECTREF(refThisUNSAFE)), - ObjToArgSlot(ObjectToOBJECTREF(refNameUNSAFE)), - enumBindingAttr - }; - - HELPER_METHOD_FRAME_BEGIN_RET_NOPOLL(); - - GCPROTECT_ARRAY_BEGIN(args[0], 2); - - retVal = ObjectToOBJECTREF((Object*)GetProperty_2Worker(args)); - - GCPROTECT_END(); - HELPER_METHOD_FRAME_END(); - - FC_GC_POLL_AND_RETURN_OBJREF(retVal); -} -FCIMPLEND - -FCIMPL2(Object*, StdMngIReflect::GetProperties, Object* refThisUNSAFE, INT32 enumBindingAttr) -{ - CONTRACTL - { - FCALL_CHECK; - PRECONDITION(CheckPointer(refThisUNSAFE)); - } - CONTRACTL_END; - - OBJECTREF retVal = NULL; - ARG_SLOT args[2] = - { - ObjToArgSlot(ObjectToOBJECTREF(refThisUNSAFE)), - enumBindingAttr - }; - - HELPER_METHOD_FRAME_BEGIN_RET_NOPOLL(); - - GCPROTECT_ARRAY_BEGIN(args[0], 1); - - retVal = ObjectToOBJECTREF((Object*)GetPropertiesWorker(args)); - - GCPROTECT_END(); - HELPER_METHOD_FRAME_END(); - - FC_GC_POLL_AND_RETURN_OBJREF(retVal); -} -FCIMPLEND - -FCIMPL3(Object*, StdMngIReflect::GetMember, Object* refThisUNSAFE, Object* refNameUNSAFE, INT32 enumBindingAttr) -{ - CONTRACTL - { - FCALL_CHECK; - PRECONDITION(CheckPointer(refThisUNSAFE)); - } - CONTRACTL_END; - - OBJECTREF retVal = NULL; - ARG_SLOT args[3] = - { - ObjToArgSlot(ObjectToOBJECTREF(refThisUNSAFE)), - ObjToArgSlot(ObjectToOBJECTREF(refNameUNSAFE)), - enumBindingAttr - }; - - HELPER_METHOD_FRAME_BEGIN_RET_NOPOLL(); - - GCPROTECT_ARRAY_BEGIN(args[0], 2); - - retVal = ObjectToOBJECTREF((Object*)GetMemberWorker(args)); - - GCPROTECT_END(); - HELPER_METHOD_FRAME_END(); - - FC_GC_POLL_AND_RETURN_OBJREF(retVal); -} -FCIMPLEND - -FCIMPL2(Object*, StdMngIReflect::GetMembers, Object* refThisUNSAFE, INT32 enumBindingAttr) -{ - CONTRACTL - { - FCALL_CHECK; - PRECONDITION(CheckPointer(refThisUNSAFE)); - } - CONTRACTL_END; - - OBJECTREF retVal = NULL; - ARG_SLOT args[2] = - { - ObjToArgSlot(ObjectToOBJECTREF(refThisUNSAFE)), - enumBindingAttr - }; - - HELPER_METHOD_FRAME_BEGIN_RET_NOPOLL(); - - GCPROTECT_ARRAY_BEGIN(args[0], 1); - - retVal = ObjectToOBJECTREF((Object*)GetMembersWorker(args)); - - GCPROTECT_END(); - HELPER_METHOD_FRAME_END(); - - FC_GC_POLL_AND_RETURN_OBJREF(retVal); -} -FCIMPLEND - -FCIMPL9(Object*, StdMngIReflect::InvokeMember, Object* refThisUNSAFE, Object* refNameUNSAFE, INT32 enumBindingAttr, Object* refBinderUNSAFE, Object* refTargetUNSAFE, Object* refArgsArrayUNSAFE, Object* refModifiersArrayUNSAFE, Object* refCultureUNSAFE, Object* refNamedParamsArrayUNSAFE) -{ - CONTRACTL - { - FCALL_CHECK; - PRECONDITION(CheckPointer(refThisUNSAFE)); - } - CONTRACTL_END; - - OBJECTREF retVal = NULL; - ARG_SLOT args[9] = - { - /* 0 */ ObjToArgSlot(ObjectToOBJECTREF(refThisUNSAFE)), - /* 1 */ ObjToArgSlot(ObjectToOBJECTREF(refNameUNSAFE)), - /* 2 */ enumBindingAttr, - /* 3 */ ObjToArgSlot(ObjectToOBJECTREF(refBinderUNSAFE)), - /* 4 */ ObjToArgSlot(ObjectToOBJECTREF(refTargetUNSAFE)), - /* 5 */ ObjToArgSlot(ObjectToOBJECTREF(refArgsArrayUNSAFE)), - /* 6 */ ObjToArgSlot(ObjectToOBJECTREF(refModifiersArrayUNSAFE)), - /* 7 */ ObjToArgSlot(ObjectToOBJECTREF(refCultureUNSAFE)), - /* 8 */ ObjToArgSlot(ObjectToOBJECTREF(refNamedParamsArrayUNSAFE)) - }; - - HELPER_METHOD_FRAME_BEGIN_RET_NOPOLL(); - - GCPROTECT_ARRAY_BEGIN(args[0], 2); - GCPROTECT_ARRAY_BEGIN(args[3], 6); - - retVal = ObjectToOBJECTREF((Object*)InvokeMemberWorker(args)); - - GCPROTECT_END(); - GCPROTECT_END(); - HELPER_METHOD_FRAME_END(); - - FC_GC_POLL_AND_RETURN_OBJREF(retVal); -} -FCIMPLEND - -FCIMPL1(Object*, StdMngIReflect::get_UnderlyingSystemType, Object* refThisUNSAFE) -{ - CONTRACTL - { - FCALL_CHECK; - PRECONDITION(CheckPointer(refThisUNSAFE)); - } - CONTRACTL_END; - - OBJECTREF retVal = NULL; - ARG_SLOT args[1] = - { - ObjToArgSlot(ObjectToOBJECTREF(refThisUNSAFE)) - }; - - HELPER_METHOD_FRAME_BEGIN_RET_NOPOLL(); - - GCPROTECT_ARRAY_BEGIN(args[0], 1); - - retVal = ObjectToOBJECTREF((Object*)get_UnderlyingSystemTypeWorker(args)); - - GCPROTECT_END(); - HELPER_METHOD_FRAME_END(); - - FC_GC_POLL_AND_RETURN_OBJREF(retVal); -} -FCIMPLEND - - -FCIMPL1(Object*, StdMngIEnumerable::GetEnumerator, Object* refThisUNSAFE) -{ - CONTRACTL - { - FCALL_CHECK; - PRECONDITION(CheckPointer(refThisUNSAFE)); - } - CONTRACTL_END; - - OBJECTREF retVal = NULL; - ARG_SLOT args[1] = - { - ObjToArgSlot(ObjectToOBJECTREF(refThisUNSAFE)) - }; - OBJECTREF *porefThis = (OBJECTREF *)&args[0]; - - HELPER_METHOD_FRAME_BEGIN_RET_NOPOLL(); - - GCPROTECT_ARRAY_BEGIN(args[0], 1); - - // To handle calls via IEnumerable::GetEnumerator on an RCW we use - // EnumerableToDispatchMarshaler (legacy COM interop) - retVal = ObjectToOBJECTREF((Object*)GetEnumeratorWorker(args)); - - GCPROTECT_END(); - HELPER_METHOD_FRAME_END(); - - FC_GC_POLL_AND_RETURN_OBJREF(retVal); -} -FCIMPLEND diff --git a/src/coreclr/vm/mngstdinterfaces.h b/src/coreclr/vm/mngstdinterfaces.h deleted file mode 100644 index 8c2d251dd1b..00000000000 --- a/src/coreclr/vm/mngstdinterfaces.h +++ /dev/null @@ -1,397 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -/*============================================================ -** -** Header: MngStdInterfaceMap.h -** -** -** Purpose: Contains types and method signatures for the Com wrapper class -** -** - -===========================================================*/ - -#ifndef _MNGSTDINTERFACEMAP_H -#define _MNGSTDINTERFACEMAP_H - -#ifndef FEATURE_COMINTEROP -#error FEATURE_COMINTEROP is required for this file -#endif // FEATURE_COMINTEROP - -#include "vars.hpp" -#include "eehash.h" -#include "class.h" -#include "mlinfo.h" - -#ifndef DACCESS_COMPILE -// -// This class is used to establish a mapping between a managed standard interface and its -// unmanaged counterpart. -// - -class MngStdInterfaceMap -{ -public: - // This method retrieves the native IID of the interface that the specified - // managed type is a standard interface for. If the specified type is not - // a standard interface then GUIDNULL is returned. - inline static IID* GetNativeIIDForType(TypeHandle th) - { - CONTRACTL - { - THROWS; - GC_TRIGGERS; - INJECT_FAULT(COMPlusThrowOM()); - } - CONTRACTL_END - - // Only simple class types can have native IIDs - if (th.IsTypeDesc() || th.IsArray()) - return NULL; - - HashDatum Data; - - // Retrieve the name of the type. - LPCUTF8 ns, name; - LPUTF8 strTypeName; - name = th.GetMethodTable()->GetFullyQualifiedNameInfo(&ns); - MAKE_FULL_PATH_ON_STACK_UTF8(strTypeName, ns, name); - - if (m_pMngStdItfMap == NULL) { - MngStdInterfaceMap *tmp = new MngStdInterfaceMap; - if (InterlockedCompareExchangeT(&m_pMngStdItfMap, tmp, NULL) != NULL) { - tmp->m_TypeNameToNativeIIDMap.ClearHashTable(); - delete tmp; - } - } - if (m_pMngStdItfMap->m_TypeNameToNativeIIDMap.GetValue(strTypeName, &Data) && (*((GUID*)Data) != GUID_NULL)) - { - // The type is a standard interface. - return (IID*)Data; - } - else - { - // The type is not a standard interface. - return NULL; - } - } - -private: - // Disalow creation of this class by anybody outside of it. - MngStdInterfaceMap(); - - // The map of type names to native IID's. - EEUtf8StringHashTable m_TypeNameToNativeIIDMap; - - // The one and only instance of the managed std interface map. - static MngStdInterfaceMap *m_pMngStdItfMap; -}; - -#endif // DACCESS_COMPILE - -// -// Base class for all the classes that contain the ECall's for the managed standard interfaces. -// - -class MngStdItfBase -{ -protected: - static void InitHelper( - LPCUTF8 strMngItfTypeName, - LPCUTF8 strUComItfTypeName, - LPCUTF8 strCMTypeName, - LPCUTF8 strCookie, - LPCUTF8 strManagedViewName, - TypeHandle *pMngItfType, - TypeHandle *pUComItfType, - TypeHandle *pCustomMarshalerType, - TypeHandle *pManagedViewType, - OBJECTHANDLE *phndMarshaler); - - static LPVOID ForwardCallToManagedView( - OBJECTHANDLE hndMarshaler, - MethodDesc *pMngItfMD, - MethodDesc *pUComItfMD, - MethodDesc *pMarshalNativeToManagedMD, - MethodDesc *pMngViewMD, - IID *pMngItfIID, - IID *pNativeItfIID, - ARG_SLOT* pArgs); -}; - - -// -// Define the enum of methods on the managed standard interface. -// - -#define MNGSTDITF_BEGIN_INTERFACE(FriendlyName, strMngItfName, strUCOMMngItfName, strCustomMarshalerName, strCustomMarshalerCookie, strManagedViewName, NativeItfIID, bCanCastOnNativeItfQI) \ -\ -enum FriendlyName##Methods \ -{ \ - FriendlyName##Methods_Dummy = -1, - - -#define MNGSTDITF_DEFINE_METH_IMPL(FriendlyName, ECallMethName, MethName, MethSig, FcallDecl) \ - FriendlyName##Methods_##ECallMethName, - - -#define MNGSTDITF_END_INTERFACE(FriendlyName) \ - FriendlyName##Methods_LastMember \ -}; \ - - -#include "mngstditflist.h" - - -#undef MNGSTDITF_BEGIN_INTERFACE -#undef MNGSTDITF_DEFINE_METH_IMPL -#undef MNGSTDITF_END_INTERFACE - - -// -// Define the class that implements the ECall's for the managed standard interface. -// - -#define MNGSTDITF_BEGIN_INTERFACE(FriendlyName, strMngItfName, strUCOMMngItfName, strCustomMarshalerName, strCustomMarshalerCookie, strManagedViewName, NativeItfIID, bCanCastOnNativeItfQI) \ -\ -class FriendlyName : public MngStdItfBase \ -{ \ -public: \ - FriendlyName() \ - { \ - CONTRACTL \ - { \ - THROWS; \ - GC_TRIGGERS; \ - INJECT_FAULT(COMPlusThrowOM()); \ - } \ - CONTRACTL_END \ - InitHelper(strMngItfName, strUCOMMngItfName, strCustomMarshalerName, strCustomMarshalerCookie, strManagedViewName, &m_MngItfType, &m_UComItfType, &m_CustomMarshalerType, &m_ManagedViewType, &m_hndCustomMarshaler); \ - m_NativeItfIID = NativeItfIID; \ - m_UComItfType.GetMethodTable()->GetGuid(&m_MngItfIID, TRUE); \ - memset(m_apCustomMarshalerMD, 0, CustomMarshalerMethods_LastMember * sizeof(MethodDesc *)); \ - memset(m_apManagedViewMD, 0, FriendlyName##Methods_LastMember * sizeof(MethodDesc *)); \ - memset(m_apUComItfMD, 0, FriendlyName##Methods_LastMember * sizeof(MethodDesc *)); \ - memset(m_apMngItfMD, 0, FriendlyName##Methods_LastMember * sizeof(MethodDesc *)); \ - } \ -\ - OBJECTREF GetCustomMarshaler() \ - { \ - WRAPPER_NO_CONTRACT; \ - return ObjectFromHandle(m_hndCustomMarshaler); \ - } \ -\ - MethodDesc* GetCustomMarshalerMD(EnumCustomMarshalerMethods Method) \ - { \ - CONTRACTL \ - { \ - THROWS; \ - GC_TRIGGERS; \ - INJECT_FAULT(COMPlusThrowOM()); \ - } \ - CONTRACTL_END \ - MethodDesc *pMD = NULL; \ - \ - if (m_apCustomMarshalerMD[Method]) \ - return m_apCustomMarshalerMD[Method]; \ - \ - pMD = CustomMarshalerInfo::GetCustomMarshalerMD(Method, m_CustomMarshalerType); \ - _ASSERTE(pMD && "Unable to find specified method on the custom marshaler"); \ - MetaSig::EnsureSigValueTypesLoaded(pMD); \ - \ - m_apCustomMarshalerMD[Method] = pMD; \ - return pMD; \ - } \ -\ - MethodDesc* GetManagedViewMD(FriendlyName##Methods Method, LPCUTF8 strMethName, LPHARDCODEDMETASIG pSig) \ - { \ - CONTRACTL \ - { \ - THROWS; \ - GC_TRIGGERS; \ - INJECT_FAULT(COMPlusThrowOM()); \ - } \ - CONTRACTL_END \ - MethodDesc *pMD = NULL; \ - \ - if (m_apManagedViewMD[Method]) \ - return m_apManagedViewMD[Method]; \ - \ - pMD = MemberLoader::FindMethod(m_ManagedViewType.GetMethodTable(), strMethName, pSig); \ - _ASSERTE(pMD && "Unable to find specified method on the managed view"); \ - MetaSig::EnsureSigValueTypesLoaded(pMD); \ - \ - m_apManagedViewMD[Method] = pMD; \ - return pMD; \ - } \ -\ - MethodDesc* GetUComItfMD(FriendlyName##Methods Method, LPCUTF8 strMethName, LPHARDCODEDMETASIG pSig) \ - { \ - CONTRACTL \ - { \ - THROWS; \ - GC_TRIGGERS; \ - INJECT_FAULT(COMPlusThrowOM()); \ - } \ - CONTRACTL_END \ - MethodDesc *pMD = NULL; \ - \ - if (m_apUComItfMD[Method]) \ - return m_apUComItfMD[Method]; \ - \ - pMD = MemberLoader::FindMethod(m_UComItfType.GetMethodTable(), strMethName, pSig); \ - _ASSERTE(pMD && "Unable to find specified method in UCom interface"); \ - MetaSig::EnsureSigValueTypesLoaded(pMD); \ - \ - m_apUComItfMD[Method] = pMD; \ - return pMD; \ - } \ -\ - MethodDesc* GetMngItfMD(FriendlyName##Methods Method, LPCUTF8 strMethName, LPHARDCODEDMETASIG pSig) \ - { \ - CONTRACTL \ - { \ - THROWS; \ - GC_TRIGGERS; \ - INJECT_FAULT(COMPlusThrowOM()); \ - } \ - CONTRACTL_END \ - MethodDesc *pMD = NULL; \ - \ - if (m_apMngItfMD[Method]) \ - return m_apMngItfMD[Method]; \ - \ - pMD = MemberLoader::FindMethod(m_MngItfType.GetMethodTable(), strMethName, pSig); \ - _ASSERTE(pMD && "Unable to find specified method in UCom interface"); \ - MetaSig::EnsureSigValueTypesLoaded(pMD); \ - \ - m_apMngItfMD[Method] = pMD; \ - return pMD; \ - } \ -\ -private: \ - MethodDesc* m_apCustomMarshalerMD[CustomMarshalerMethods_LastMember]; \ - MethodDesc* m_apManagedViewMD[FriendlyName##Methods_LastMember]; \ - MethodDesc* m_apUComItfMD[FriendlyName##Methods_LastMember]; \ - MethodDesc* m_apMngItfMD[FriendlyName##Methods_LastMember]; \ - TypeHandle m_CustomMarshalerType; \ - TypeHandle m_ManagedViewType; \ - TypeHandle m_UComItfType; \ - TypeHandle m_MngItfType; \ - OBJECTHANDLE m_hndCustomMarshaler; \ - GUID m_MngItfIID; \ - GUID m_NativeItfIID; \ -\ - -#define MNGSTDITF_DEFINE_METH_IMPL(FriendlyName, ECallMethName, MethName, MethSig, FcallDecl) \ -\ -public: static LPVOID __stdcall ECallMethName##Worker(ARG_SLOT* pArgs); \ -public: static FcallDecl; \ -\ - -#define MNGSTDITF_END_INTERFACE(FriendlyName) \ -}; \ -\ - - -#include "mngstditflist.h" - - -#undef MNGSTDITF_BEGIN_INTERFACE -#undef MNGSTDITF_DEFINE_METH_IMPL -#undef MNGSTDITF_END_INTERFACE - - -// -// App domain level information on the managed standard interfaces . -// - -class MngStdInterfacesInfo -{ -public: - // Constructor and destructor. - MngStdInterfacesInfo() - { - STATIC_CONTRACT_THROWS; - STATIC_CONTRACT_FAULT; - -#define MNGSTDITF_BEGIN_INTERFACE(FriendlyName, strMngItfName, strUCOMMngItfName, strCustomMarshalerName, strCustomMarshalerCookie, strManagedViewName, NativeItfIID, bCanCastOnNativeItfQI) \ -\ - m_p##FriendlyName = 0; \ -\ - -#define MNGSTDITF_DEFINE_METH_IMPL(FriendlyName, ECallMethName, MethName, MethSig, FcallDecl) -#define MNGSTDITF_END_INTERFACE(FriendlyName) - - -#include "mngstditflist.h" - - -#undef MNGSTDITF_BEGIN_INTERFACE -#undef MNGSTDITF_DEFINE_METH_IMPL -#undef MNGSTDITF_END_INTERFACE - } - - ~MngStdInterfacesInfo() - { - WRAPPER_NO_CONTRACT; - -#define MNGSTDITF_BEGIN_INTERFACE(FriendlyName, strMngItfName, strUCOMMngItfName, strCustomMarshalerName, strCustomMarshalerCookie, strManagedViewName, NativeItfIID, bCanCastOnNativeItfQI) \ -\ - if (m_p##FriendlyName) \ - delete m_p##FriendlyName; \ -\ - -#define MNGSTDITF_DEFINE_METH_IMPL(FriendlyName, ECallMethName, MethName, MethSig, FcallDecl) -#define MNGSTDITF_END_INTERFACE(FriendlyName) - - -#include "mngstditflist.h" - - -#undef MNGSTDITF_BEGIN_INTERFACE -#undef MNGSTDITF_DEFINE_METH_IMPL -#undef MNGSTDITF_END_INTERFACE - } - - - // Accessors for each of the managed standard interfaces. -#define MNGSTDITF_BEGIN_INTERFACE(FriendlyName, strMngItfName, strUCOMMngItfName, strCustomMarshalerName, strCustomMarshalerCookie, strManagedViewName, NativeItfIID, bCanCastOnNativeItfQI) \ -\ -public: \ - FriendlyName *Get##FriendlyName() \ - { \ - CONTRACTL \ - { \ - THROWS; \ - GC_TRIGGERS; \ - INJECT_FAULT(COMPlusThrowOM()); \ - } \ - CONTRACTL_END \ - if (!m_p##FriendlyName) \ - { \ - NewHolder pFriendlyName = new FriendlyName(); \ - if (InterlockedCompareExchangeT(&m_p##FriendlyName, pFriendlyName.GetValue(), NULL) == NULL) \ - pFriendlyName.SuppressRelease(); \ - } \ - return m_p##FriendlyName; \ - } \ -\ -private: \ - FriendlyName *m_p##FriendlyName; \ -\ - -#define MNGSTDITF_DEFINE_METH_IMPL(FriendlyName, ECallMethName, MethName, MethSig, FcallDecl) -#define MNGSTDITF_END_INTERFACE(FriendlyName) - - -#include "mngstditflist.h" - - -#undef MNGSTDITF_BEGIN_INTERFACE -#undef MNGSTDITF_DEFINE_METH_IMPL -#undef MNGSTDITF_END_INTERFACE -}; - -#endif // _MNGSTDINTERFACEMAP_H diff --git a/src/coreclr/vm/mngstditflist.h b/src/coreclr/vm/mngstditflist.h deleted file mode 100644 index 5356cc7bc03..00000000000 --- a/src/coreclr/vm/mngstditflist.h +++ /dev/null @@ -1,119 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -/*============================================================ -** -** Header: MngStdItfList.h -** -** -** Purpose: This file contains the list of managed standard -** interfaces. Each standard interface also has the -** list of method that it contains. -** -===========================================================*/ - -#ifndef FEATURE_COMINTEROP -#error FEATURE_COMINTEROP is required for this file -#endif // FEATURE_COMINTEROP - -// -// Helper macros -// - -#define MNGSTDITF_DEFINE_METH(FriendlyName, MethName, MethSig, FcallDecl) \ - MNGSTDITF_DEFINE_METH_IMPL(FriendlyName, MethName, MethName, MethSig, FcallDecl) - -#define MNGSTDITF_DEFINE_METH2(FriendlyName, MethName, MethSig, FcallDecl) \ - MNGSTDITF_DEFINE_METH_IMPL(FriendlyName, MethName##_2, MethName, MethSig, FcallDecl) - -#define MNGSTDITF_DEFINE_METH3(FriendlyName, MethName, MethSig, FcallDecl) \ - MNGSTDITF_DEFINE_METH_IMPL(FriendlyName, MethName##_3, MethName, MethSig, FcallDecl) - - - -// -// MNGSTDITF_BEGIN_INTERFACE(FriendlyName, strMngItfName, strUCOMMngItfName, strCustomMarshalerName, strCustomMarshalerCookie, strManagedViewName, NativeItfIID) \ -// -// This macro defines a new managed standard interface. -// -// FriendlyName Friendly name for the class that implements the ECall's. -// idMngItf BinderClassID of the managed interface. -// idUCOMMngItf BinderClassID of the UCom version of the managed interface. -// idCustomMarshaler BinderClassID of the custom marshaler. -// idGetInstMethod BinderMethodID of the GetInstance method of the custom marshaler. -// strCustomMarshalerCookie String containing the cookie to be passed to the custom marshaler. -// strManagedViewName String containing the name of the managed view of the native interface. -// NativeItfIID IID of the native interface. -// bCanCastOnNativeItfQI If this is true casting to a COM object that supports the native interface -// will cause the cast to succeed. -// - -// -// MNGSTDITF_DEFINE_METH(FriendlyName, MethName, MethSig) -// -// This macro defines a method of the standard managed interface. -// MNGSTDITF_DEFINE_METH2 and MNGSTDITF_DEFINE_METH3 are used to -// define overloaded versions of the method. -// -// FriendlyName Friendly name for the class that implements the ECall's. -// MethName This is the method name -// MethSig This is the method signature. -// - - -// -// IReflect -// - - -#define MNGSTDITF_IREFLECT_DECL__GETMETHOD FCDECL6(Object*, GetMethod, Object* refThisUNSAFE, Object* refNameUNSAFE, INT32 enumBindingAttr, Object* refBinderUNSAFE, Object* refTypesArrayUNSAFE, Object* refModifiersArrayUNSAFE) -#define MNGSTDITF_IREFLECT_DECL__GETMETHOD_2 FCDECL3(Object*, GetMethod_2, Object* refThisUNSAFE, Object* refNameUNSAFE, INT32 enumBindingAttr) -#define MNGSTDITF_IREFLECT_DECL__GETMETHODS FCDECL2(Object*, GetMethods, Object* refThisUNSAFE, INT32 enumBindingAttr) -#define MNGSTDITF_IREFLECT_DECL__GETFIELD FCDECL3(Object*, GetField, Object* refThisUNSAFE, Object* refNameUNSAFE, INT32 enumBindingAttr) -#define MNGSTDITF_IREFLECT_DECL__GETFIELDS FCDECL2(Object*, GetFields, Object* refThisUNSAFE, INT32 enumBindingAttr) -#define MNGSTDITF_IREFLECT_DECL__GETPROPERTY FCDECL7(Object*, GetProperty, Object* refThisUNSAFE, Object* refNameUNSAFE, INT32 enumBindingAttr, Object* refBinderUNSAFE, Object* refReturnTypeUNSAFE, Object* refTypesArrayUNSAFE, Object* refModifiersArrayUNSAFE) -#define MNGSTDITF_IREFLECT_DECL__GETPROPERTY_2 FCDECL3(Object*, GetProperty_2, Object* refThisUNSAFE, Object* refNameUNSAFE, INT32 enumBindingAttr) -#define MNGSTDITF_IREFLECT_DECL__GETPROPERTIES FCDECL2(Object*, GetProperties, Object* refThisUNSAFE, INT32 enumBindingAttr) -#define MNGSTDITF_IREFLECT_DECL__GETMEMBER FCDECL3(Object*, GetMember, Object* refThisUNSAFE, Object* refNameUNSAFE, INT32 enumBindingAttr) -#define MNGSTDITF_IREFLECT_DECL__GETMEMBERS FCDECL2(Object*, GetMembers, Object* refThisUNSAFE, INT32 enumBindingAttr) -#define MNGSTDITF_IREFLECT_DECL__INVOKEMEMBER FCDECL9(Object*, InvokeMember, Object* refThisUNSAFE, Object* refNameUNSAFE, INT32 enumBindingAttr, Object* refBinderUNSAFE, Object* refTargetUNSAFE, Object* refArgsArrayUNSAFE, Object* refModifiersArrayUNSAFE, Object* refCultureUNSAFE, Object* refNamedParamsArrayUNSAFE) -#define MNGSTDITF_IREFLECT_DECL__GET_UNDERLYING_SYSTEM_TYPE FCDECL1(Object*, get_UnderlyingSystemType, Object* refThisUNSAFE) - -MNGSTDITF_BEGIN_INTERFACE(StdMngIReflect, g_ReflectionReflectItfName, "System.Runtime.InteropServices.ComTypes.IReflect", g_CMExpandoToDispatchExMarshaler, "IReflect", g_CMExpandoViewOfDispatchEx, IID_IDispatchEx, TRUE) - MNGSTDITF_DEFINE_METH(StdMngIReflect, GetMethod, &gsig_IM_Str_BindingFlags_Binder_ArrType_ArrParameterModifier_RetMethodInfo, MNGSTDITF_IREFLECT_DECL__GETMETHOD) - MNGSTDITF_DEFINE_METH2(StdMngIReflect,GetMethod, &gsig_IM_Str_BindingFlags_RetMethodInfo, MNGSTDITF_IREFLECT_DECL__GETMETHOD_2) - MNGSTDITF_DEFINE_METH(StdMngIReflect, GetMethods, &gsig_IM_BindingFlags_RetArrMethodInfo, MNGSTDITF_IREFLECT_DECL__GETMETHODS) - MNGSTDITF_DEFINE_METH(StdMngIReflect, GetField, &gsig_IM_Str_BindingFlags_RetFieldInfo, MNGSTDITF_IREFLECT_DECL__GETFIELD) - MNGSTDITF_DEFINE_METH(StdMngIReflect, GetFields, &gsig_IM_BindingFlags_RetArrFieldInfo, MNGSTDITF_IREFLECT_DECL__GETFIELDS) - MNGSTDITF_DEFINE_METH(StdMngIReflect, GetProperty, &gsig_IM_Str_BindingFlags_Binder_Type_ArrType_ArrParameterModifier_RetPropertyInfo, MNGSTDITF_IREFLECT_DECL__GETPROPERTY) - MNGSTDITF_DEFINE_METH2(StdMngIReflect,GetProperty, &gsig_IM_Str_BindingFlags_RetPropertyInfo, MNGSTDITF_IREFLECT_DECL__GETPROPERTY_2) - MNGSTDITF_DEFINE_METH(StdMngIReflect, GetProperties,&gsig_IM_BindingFlags_RetArrPropertyInfo, MNGSTDITF_IREFLECT_DECL__GETPROPERTIES) - MNGSTDITF_DEFINE_METH(StdMngIReflect, GetMember, &gsig_IM_Str_BindingFlags_RetMemberInfo, MNGSTDITF_IREFLECT_DECL__GETMEMBER) - MNGSTDITF_DEFINE_METH(StdMngIReflect, GetMembers, &gsig_IM_BindingFlags_RetArrMemberInfo, MNGSTDITF_IREFLECT_DECL__GETMEMBERS) - MNGSTDITF_DEFINE_METH(StdMngIReflect, InvokeMember, &gsig_IM_Str_BindingFlags_Binder_Obj_ArrObj_ArrParameterModifier_CultureInfo_ArrStr_RetObj, MNGSTDITF_IREFLECT_DECL__INVOKEMEMBER) - MNGSTDITF_DEFINE_METH(StdMngIReflect, get_UnderlyingSystemType, &gsig_IM_RetType, MNGSTDITF_IREFLECT_DECL__GET_UNDERLYING_SYSTEM_TYPE) -MNGSTDITF_END_INTERFACE(StdMngIReflect) - -// -// IEnumerator -// - -#define MNGSTDITF_IENUMERATOR_DECL__MOVE_NEXT FCDECL1(FC_BOOL_RET, MoveNext, Object* refThisUNSAFE) -#define MNGSTDITF_IENUMERATOR_DECL__GET_CURRENT FCDECL1(Object*, get_Current, Object* refThisUNSAFE) -#define MNGSTDITF_IENUMERATOR_DECL__RESET FCDECL1(void, Reset, Object* refThisUNSAFE) - -MNGSTDITF_BEGIN_INTERFACE(StdMngIEnumerator, g_CollectionsEnumeratorClassName, "System.Runtime.InteropServices.ComTypes.IEnumerator", g_EnumeratorToEnumClassName, "", "System.Runtime.InteropServices.CustomMarshalers.EnumeratorViewOfEnumVariant", IID_IEnumVARIANT, TRUE) - MNGSTDITF_DEFINE_METH(StdMngIEnumerator, MoveNext, &gsig_IM_RetBool, MNGSTDITF_IENUMERATOR_DECL__MOVE_NEXT) - MNGSTDITF_DEFINE_METH(StdMngIEnumerator, get_Current, &gsig_IM_RetObj, MNGSTDITF_IENUMERATOR_DECL__GET_CURRENT) - MNGSTDITF_DEFINE_METH(StdMngIEnumerator, Reset, &gsig_IM_RetVoid, MNGSTDITF_IENUMERATOR_DECL__RESET) -MNGSTDITF_END_INTERFACE(StdMngIEnumerator) - -// -// IEnumerable -// - -#define MNGSTDITF_IENUMERABLE_DECL__GETENUMERATOR FCDECL1(Object*, GetEnumerator, Object* refThisUNSAFE) - -MNGSTDITF_BEGIN_INTERFACE(StdMngIEnumerable, g_CollectionsEnumerableItfName, "System.Runtime.InteropServices.ComTypes.IEnumerable", "System.Runtime.InteropServices.CustomMarshalers.EnumerableToDispatchMarshaler", "", "System.Runtime.InteropServices.CustomMarshalers.EnumerableViewOfDispatch", IID_IDispatch, FALSE) - MNGSTDITF_DEFINE_METH(StdMngIEnumerable, GetEnumerator, &gsig_IM_RetIEnumerator, MNGSTDITF_IENUMERABLE_DECL__GETENUMERATOR) -MNGSTDITF_END_INTERFACE(StdMngIEnumerable) diff --git a/src/coreclr/vm/multicorejit.cpp b/src/coreclr/vm/multicorejit.cpp index d052cbeb3d9..ab6d2e65fc7 100644 --- a/src/coreclr/vm/multicorejit.cpp +++ b/src/coreclr/vm/multicorejit.cpp @@ -237,11 +237,11 @@ FileLoadLevel MulticoreJitManager::GetModuleFileLoadLevel(Module * pModule) if (pModule != NULL) { - DomainAssembly * pDomainAssembly = pModule->GetDomainAssembly(); + Assembly * pAssembly = pModule->GetAssembly(); - if (pDomainAssembly != NULL) + if (pAssembly != NULL) { - level = pDomainAssembly->GetLoadLevel(); + level = pAssembly->GetLoadLevel(); } } @@ -768,7 +768,7 @@ DWORD MulticoreJitRecorder::EncodeModule(Module * pReferencedModule) } // Enumerate all modules within an assembly, call OnModule virtual method -HRESULT MulticoreJitModuleEnumerator::HandleAssembly(DomainAssembly * pAssembly) +HRESULT MulticoreJitModuleEnumerator::HandleAssembly(Assembly * pAssembly) { STANDARD_VM_CONTRACT; @@ -786,12 +786,12 @@ HRESULT MulticoreJitModuleEnumerator::EnumerateLoadedModules(AppDomain * pDomain AppDomain::AssemblyIterator appIt = pDomain->IterateAssembliesEx((AssemblyIterationFlags)(kIncludeLoaded | kIncludeExecution)); - CollectibleAssemblyHolder pDomainAssembly; + CollectibleAssemblyHolder pAssembly; - while (appIt.Next(pDomainAssembly.This()) && SUCCEEDED(hr)) + while (appIt.Next(pAssembly.This()) && SUCCEEDED(hr)) { { - hr = HandleAssembly(pDomainAssembly); + hr = HandleAssembly(pAssembly); } } diff --git a/src/coreclr/vm/multicorejitimpl.h b/src/coreclr/vm/multicorejitimpl.h index be57644071d..63400e7cb20 100644 --- a/src/coreclr/vm/multicorejitimpl.h +++ b/src/coreclr/vm/multicorejitimpl.h @@ -253,7 +253,7 @@ class MulticoreJitModuleEnumerator public: HRESULT EnumerateLoadedModules(AppDomain * pDomain); - HRESULT HandleAssembly(DomainAssembly * pAssembly); + HRESULT HandleAssembly(Assembly * pAssembly); }; @@ -306,7 +306,7 @@ friend class MulticoreJitRecorder; HRESULT ReadCheckFile(const WCHAR * pFileName); - DomainAssembly * LoadAssembly(SString & assemblyName); + Assembly * LoadAssembly(SString & assemblyName); public: @@ -632,8 +632,6 @@ class MulticoreJitRecorder unsigned RecordModuleInfo(Module * pModule); void RecordOrUpdateModuleInfo(FileLoadLevel needLevel, unsigned moduleIndex); - void AddAllModulesInAsm(DomainAssembly * pAssembly); - HRESULT WriteOutput(IStream * pStream); HRESULT WriteOutput(); diff --git a/src/coreclr/vm/multicorejitplayer.cpp b/src/coreclr/vm/multicorejitplayer.cpp index 4d810bd7d9c..fcc4a46a33f 100644 --- a/src/coreclr/vm/multicorejitplayer.cpp +++ b/src/coreclr/vm/multicorejitplayer.cpp @@ -45,7 +45,7 @@ void MulticoreJitCodeStorage::Init() CONTRACTL { THROWS; - MODE_ANY; // called from BaseDomain::Init which is MODE_ANY + MODE_ANY; // called from SystemDomain::Attach which is MODE_ANY } CONTRACTL_END; @@ -780,13 +780,13 @@ HRESULT MulticoreJitProfilePlayer::HandleModuleInfoRecord(unsigned moduleTo, uns assemblyName.SetASCII(mod.m_pRecord->GetAssemblyName(), mod.m_pRecord->AssemblyNameLen()); // Load the assembly. - DomainAssembly * pDomainAssembly = LoadAssembly(assemblyName); + Assembly * pAssembly = LoadAssembly(assemblyName); - if (pDomainAssembly) + if (pAssembly) { // If we successfully loaded the assembly, enumerate the modules in the assembly // and update all modules status. - moduleEnumerator.HandleAssembly(pDomainAssembly); + moduleEnumerator.HandleAssembly(pAssembly); if (mod.m_pModule == NULL) { @@ -819,7 +819,7 @@ HRESULT MulticoreJitProfilePlayer::HandleModuleInfoRecord(unsigned moduleTo, uns return hr; } -DomainAssembly * MulticoreJitProfilePlayer::LoadAssembly(SString & assemblyName) +Assembly * MulticoreJitProfilePlayer::LoadAssembly(SString & assemblyName) { STANDARD_VM_CONTRACT; @@ -839,7 +839,7 @@ DomainAssembly * MulticoreJitProfilePlayer::LoadAssembly(SString & assemblyName) } // Bind and load the assembly. - return spec.LoadDomainAssembly( + return spec.LoadAssembly( FILE_LOADED, FALSE); // Don't throw on FileNotFound. } @@ -1132,7 +1132,7 @@ HRESULT MulticoreJitProfilePlayer::PlayProfile() MulticoreJitTrace(("PlayProfile %d bytes in (%s)", nSize, - GetAppDomain()->GetFriendlyNameForLogging())); + GetAppDomain()->GetFriendlyName())); while ((SUCCEEDED(hr)) && (nSize > sizeof(unsigned))) { diff --git a/src/coreclr/vm/namespace.h b/src/coreclr/vm/namespace.h index a8ae97a5c18..699049b3ea0 100644 --- a/src/coreclr/vm/namespace.h +++ b/src/coreclr/vm/namespace.h @@ -31,13 +31,15 @@ #define g_ReflectionNS g_SystemNS ".Reflection" #define g_ReflectionEmitNS g_ReflectionNS ".Emit" -#define g_InteropNS g_RuntimeNS ".InteropServices" -#define g_ObjectiveCNS g_InteropNS ".ObjectiveC" -#define g_MarshallingNS g_InteropNS ".Marshalling" +#define g_InteropNS g_RuntimeNS ".InteropServices" +#define g_CustomMarshalersNS g_InteropNS ".CustomMarshalers" +#define g_ObjectiveCNS g_InteropNS ".ObjectiveC" +#define g_MarshallingNS g_InteropNS ".Marshalling" #define g_IntrinsicsNS g_RuntimeNS ".Intrinsics" #define g_NumericsNS g_SystemNS ".Numerics" +#define g_InternalCompilerHelpersNS "Internal.Runtime.CompilerHelpers" #define g_CompilerServicesNS g_RuntimeNS ".CompilerServices" #define g_ConstrainedExecutionNS g_RuntimeNS ".ConstrainedExecution" diff --git a/src/coreclr/vm/nativelibrarynative.cpp b/src/coreclr/vm/nativelibrarynative.cpp index 1aeff462f4b..780871eff3f 100644 --- a/src/coreclr/vm/nativelibrarynative.cpp +++ b/src/coreclr/vm/nativelibrarynative.cpp @@ -32,11 +32,10 @@ extern "C" INT_PTR QCALLTYPE NativeLibrary_LoadByName(LPCWSTR name, QCall::Assem QCALL_CONTRACT; NATIVE_LIBRARY_HANDLE handle = nullptr; - Assembly *pAssembly = callingAssembly->GetAssembly(); BEGIN_QCALL; - handle = NativeLibrary::LoadLibraryByName(name, pAssembly, hasDllImportSearchPathFlag, dllImportSearchPathFlag, throwOnError); + handle = NativeLibrary::LoadLibraryByName(name, callingAssembly, hasDllImportSearchPathFlag, dllImportSearchPathFlag, throwOnError); END_QCALL; diff --git a/src/coreclr/vm/object.cpp b/src/coreclr/vm/object.cpp index 1d624f6087c..477b256578a 100644 --- a/src/coreclr/vm/object.cpp +++ b/src/coreclr/vm/object.cpp @@ -278,7 +278,7 @@ TypeHandle Object::GetGCSafeTypeHandleIfPossible() const Assembly *AssemblyBaseObject::GetAssembly() { WRAPPER_NO_CONTRACT; - return m_pAssembly->GetAssembly(); + return m_pAssembly; } STRINGREF AllocateString(SString sstr) @@ -1489,7 +1489,7 @@ void StackTraceArray::Allocate(size_t size) { EX_THROW(EEMessageException, (kOverflowException, IDS_EE_ARRAY_DIMENSIONS_EXCEEDED)); } - + SetArray(I1ARRAYREF(AllocatePrimitiveArray(ELEMENT_TYPE_I1, static_cast(raw_size.Value())))); SetSize(0); SetKeepAliveItemsCount(0); @@ -1915,7 +1915,7 @@ void ExceptionObject::SetStackTrace(OBJECTREF stackTrace) // - if the stack trace was created by the current thread, the arrays are returned as is. // - if it was created by another thread, deep copies of the arrays are returned. It is ensured // that both of these arrays are consistent. That means that the stack trace doesn't contain -// frames that need keep alive objects and that are not protected by entries in the keep alive +// frames that need keep alive objects and that are not protected by entries in the keep alive // array. void ExceptionObject::GetStackTrace(StackTraceArray & stackTrace, PTRARRAYREF * outKeepAliveArray /*= NULL*/) const { @@ -1956,7 +1956,7 @@ void ExceptionObject::GetStackTrace(StackTraceArray & stackTrace, PTRARRAYREF * uint32_t keepAliveArrayCapacity = ((*outKeepAliveArray) == NULL) ? 0 : (*outKeepAliveArray)->GetNumComponents(); - // It is possible that another thread was modifying the stack trace array and keep alive array while we were making the copies. + // It is possible that another thread was modifying the stack trace array and keep alive array while we were making the copies. // The following sequence of events could have happened: // Case 1: // * The current thread gets the stack trace array and the keep alive array references using the ExceptionObject::GetStackTraceParts above @@ -2014,10 +2014,10 @@ void ExceptionObject::GetStackTrace(StackTraceArray & stackTrace, PTRARRAYREF * } GCPROTECT_END(); } -#endif // DACCESS_COMPILE +#endif // DACCESS_COMPILE } -// Get the stack trace and the dynamic method array from the stack trace object. +// Get the stack trace and the dynamic method array from the stack trace object. // If the stack trace was created by another thread, it returns clones of both arrays. /* static */ void ExceptionObject::GetStackTraceParts(OBJECTREF stackTraceObj, StackTraceArray & stackTrace, PTRARRAYREF * outKeepAliveArray /*= NULL*/) diff --git a/src/coreclr/vm/object.h b/src/coreclr/vm/object.h index 61b7a23a6cd..91e38c5ac94 100644 --- a/src/coreclr/vm/object.h +++ b/src/coreclr/vm/object.h @@ -77,7 +77,6 @@ void ErectWriteBarrierForMT(MethodTable **dst, MethodTable *ref); class MethodTable; class Thread; -class BaseDomain; class Assembly; class DomainAssembly; class AssemblyNative; @@ -1219,13 +1218,6 @@ class ReflectModuleBaseObject : public Object } }; -NOINLINE ReflectModuleBaseObject* GetRuntimeModuleHelper(LPVOID __me, Module *pModule, OBJECTREF keepAlive); -#define FC_RETURN_MODULE_OBJECT(pModule, refKeepAlive) FC_INNER_RETURN(ReflectModuleBaseObject*, GetRuntimeModuleHelper(__me, pModule, refKeepAlive)) - - - - - class ThreadBaseObject; class SynchronizationContextObject: public Object { @@ -1302,7 +1294,6 @@ typedef DPTR(class ThreadBaseObject) PTR_ThreadBaseObject; class ThreadBaseObject : public Object { friend class ClrDataAccess; - friend class ThreadNative; friend class CoreLibBinder; friend class Object; @@ -1333,6 +1324,9 @@ class ThreadBaseObject : public Object // Only used by managed code, see comment there bool m_MayNeedResetForThreadPool; + // Set in unmanaged code and read in managed code. + bool m_IsDead; + protected: // the ctor and dtor can do no useful work. ThreadBaseObject() {LIMITED_METHOD_CONTRACT;}; @@ -1384,6 +1378,12 @@ class ThreadBaseObject : public Object LIMITED_METHOD_CONTRACT; return m_Priority; } + + void SetIsDead() + { + LIMITED_METHOD_CONTRACT; + m_IsDead = true; + } }; // MarshalByRefObjectBaseObject @@ -1408,7 +1408,7 @@ class AssemblyBaseObject : public Object OBJECTREF m_pModuleEventHandler; // Delegate for 'resolve module' event STRINGREF m_fullname; // Slot for storing assemblies fullname OBJECTREF m_pSyncRoot; // Pointer to loader allocator to keep collectible types alive, and to serve as the syncroot for assembly building in ref.emit - DomainAssembly* m_pAssembly; // Pointer to the Assembly Structure + Assembly* m_pAssembly; // Pointer to the Assembly Structure protected: AssemblyBaseObject() { LIMITED_METHOD_CONTRACT; } @@ -1416,18 +1416,12 @@ class AssemblyBaseObject : public Object public: - void SetAssembly(DomainAssembly* p) + void SetAssembly(Assembly* p) { LIMITED_METHOD_CONTRACT; m_pAssembly = p; } - DomainAssembly* GetDomainAssembly() - { - LIMITED_METHOD_CONTRACT; - return m_pAssembly; - } - Assembly* GetAssembly(); void SetSyncRoot(OBJECTREF pSyncRoot) @@ -1436,8 +1430,6 @@ class AssemblyBaseObject : public Object SetObjectReference(&m_pSyncRoot, pSyncRoot); } }; -NOINLINE AssemblyBaseObject* GetRuntimeAssemblyHelper(LPVOID __me, DomainAssembly *pAssembly, OBJECTREF keepAlive); -#define FC_RETURN_ASSEMBLY_OBJECT(pAssembly, refKeepAlive) FC_INNER_RETURN(AssemblyBaseObject*, GetRuntimeAssemblyHelper(__me, pAssembly, refKeepAlive)) // AssemblyLoadContextBaseObject // This class is the base class for AssemblyLoadContext diff --git a/src/coreclr/vm/objectlist.cpp b/src/coreclr/vm/objectlist.cpp deleted file mode 100644 index 1d73cdc3425..00000000000 --- a/src/coreclr/vm/objectlist.cpp +++ /dev/null @@ -1,207 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - - -#include "common.h" -#include "objectlist.h" - -#ifndef DACCESS_COMPILE - -ObjectList::ObjectList( void ) -: freeIndexHead_( INVALID_COMPRESSEDSTACK_INDEX ), - listLock_( CrstObjectList, CrstFlags(CRST_UNSAFE_SAMELEVEL | CRST_UNSAFE_ANYMODE) ) -{ - CONTRACTL { - THROWS; - GC_NOTRIGGER; - MODE_ANY; - } CONTRACTL_END; -} - -#endif - -#define MAX_LOOP 2 - -DWORD -ObjectList::AddToList( PVOID ptr ) -{ - CONTRACTL { - THROWS; - GC_NOTRIGGER; - MODE_ANY; - PRECONDITION(CheckPointer(ptr)); - } CONTRACTL_END; - - - // sanity check that the pointer low bit is not set - _ASSERTE( (((DWORD)(size_t)ptr & 0x1) == 0) && "Invalid pointer" ); - - DWORD retval = INVALID_COMPRESSEDSTACK_INDEX; - - CrstHolder ch( &listLock_ ); - - // If there is an entry in the free list, simply use it. - - if (this->freeIndexHead_ != INVALID_COMPRESSEDSTACK_INDEX) - { - _ASSERTE( this->listLock_.OwnedByCurrentThread() ); - - // grab the head of the list - retval = (this->freeIndexHead_ >> 1); - - DWORD nextFreeIndex = (DWORD)(size_t)this->allEntries_.Get( retval ); - - // index in use, pointer values have low bit as 0 - _ASSERTE( ((nextFreeIndex & 0x01) == 1) && "The free list points to an index that is in use" ); - // update the head of the list with the next free index stored in the array list - this->freeIndexHead_ = nextFreeIndex; - - // store the pointer - this->allEntries_.Set( retval, ptr); - } - // Otherwise we place this new entry at that end of the list. - else - { - _ASSERTE( this->listLock_.OwnedByCurrentThread() ); - retval = this->allEntries_.GetCount(); - IfFailThrow(this->allEntries_.Append(ptr)); - } - - _ASSERTE( retval != INVALID_COMPRESSEDSTACK_INDEX ); - - return retval; -} - -void -ObjectList::RemoveFromList( PVOID ptr ) -{ - CONTRACTL { - THROWS; - GC_TRIGGERS; - MODE_ANY; - PRECONDITION(CheckPointer(ptr)); - } CONTRACTL_END; - - // sanity check that the pointer low bit is not set - _ASSERTE( (((DWORD)(size_t)ptr & 0x1) == 0) && "Invalid pointer" ); - - DWORD index = INVALID_COMPRESSEDSTACK_INDEX; - - CrstHolder ch( &listLock_ ); - - ObjectList::Iterator iter = Iterate(); - - while (iter.Next()) - { - if (iter.GetElement() == ptr) - { - index = iter.GetIndex(); - break; - } - } - - if (index == INVALID_COMPRESSEDSTACK_INDEX) - { - _ASSERTE( FALSE && "Unable to find object" ); - } - else - { - // add the index to the free list ( shift the freeIndex left and set the low bit) - this->allEntries_.Set( index, (PVOID)(size_t)(this->freeIndexHead_)); - this-> freeIndexHead_ = ((index<<1) | 0x1); - } -} - - - -void -ObjectList::RemoveFromList( DWORD index, PVOID ptr ) -{ - CONTRACTL { - NOTHROW; - GC_NOTRIGGER; - MODE_ANY; - PRECONDITION(CheckPointer(ptr)); - } CONTRACTL_END; - - CrstHolder ch( &listLock_ ); - - // sanity check that the pointer low bit is not set - _ASSERTE( (((DWORD)(size_t)ptr & 0x1) == 0) && "Invalid pointer" ); - - _ASSERTE( index < this->allEntries_.GetCount() ); - _ASSERTE( this->allEntries_.Get( index ) == ptr && "Index tracking failed for this object" ); - - // add the index to the free list ( shift the freeIndex left and set the low bit) - this->allEntries_.Set( index, (PVOID)(size_t)(this->freeIndexHead_)); - this-> freeIndexHead_ = ((index<<1) | 0x1); - -} - -PVOID -ObjectList::Get( DWORD index ) -{ - LIMITED_METHOD_CONTRACT; - return this->allEntries_.Get( index ); -} - - -UnsynchronizedBlockAllocator::UnsynchronizedBlockAllocator( size_t blockSize ) -: blockSize_( blockSize ), - offset_( blockSize ), - index_( INVALID_COMPRESSEDSTACK_INDEX ) -{ - LIMITED_METHOD_CONTRACT; - // We start off the offset at the block size to force the first - // allocation to create a new (first) block -} - -UnsynchronizedBlockAllocator::~UnsynchronizedBlockAllocator( void ) -{ - LIMITED_METHOD_CONTRACT; - ArrayList::Iterator iter = this->blockList_.Iterate(); - - while (iter.Next()) - { - delete [] (BYTE *) iter.GetElement(); - } -} - - -PVOID -UnsynchronizedBlockAllocator::Allocate( size_t size ) -{ - CONTRACTL { - THROWS; - GC_NOTRIGGER; - MODE_ANY; - } CONTRACTL_END; - - _ASSERTE( size <= this->blockSize_ ); - - S_SIZE_T sizecheck = S_SIZE_T(this->offset_) + S_SIZE_T(size) ; - if( sizecheck.IsOverflow() ) - { - ThrowOutOfMemory(); - } - - BYTE* bufferPtr; - if (sizecheck.Value() > this->blockSize_) - { - NewArrayHolder buffer = new BYTE[this->blockSize_]; - bufferPtr = (BYTE*)buffer.GetValue(); - IfFailThrow(this->blockList_.Append( bufferPtr )); - buffer.SuppressRelease(); - ++this->index_; - this->offset_ = 0; - } - else - { - bufferPtr = (BYTE*)this->blockList_.Get( index_ ); - } - - void* retval = bufferPtr + this->offset_; - this->offset_ += size; - - return retval; -} diff --git a/src/coreclr/vm/objectlist.h b/src/coreclr/vm/objectlist.h deleted file mode 100644 index 4542c890f80..00000000000 --- a/src/coreclr/vm/objectlist.h +++ /dev/null @@ -1,99 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - - - -#ifndef __objectlist_h__ -#define __objectlist_h__ - - -#include "arraylist.h" -#include "holder.h" - -#define INVALID_COMPRESSEDSTACK_INDEX ((DWORD)-1) -#ifdef _DEBUG -#define FREE_LIST_SIZE 128 -#else -#define FREE_LIST_SIZE 1024 -#endif - - - -class ObjectList -{ -public: - class Iterator - { - friend class ObjectList; - - protected: - ArrayList::Iterator _iter; - - public: - - PTR_VOID GetElement() - { - LIMITED_METHOD_CONTRACT; - PTR_VOID ptr = _iter.GetElement(); - if (((DWORD)(size_t)(dac_cast(ptr)) & 0x1) == 0) - { - return ptr; - } - else - { - return NULL; - } - } - - DWORD GetIndex() - { - LIMITED_METHOD_CONTRACT; - return _iter.GetIndex(); - } - - BOOL Next() - { - LIMITED_METHOD_CONTRACT; - return _iter.Next(); - } - }; - - ObjectList() DAC_EMPTY(); - - DWORD AddToList( PVOID ptr ); - void RemoveFromList( PVOID ptr ); - void RemoveFromList( DWORD index, PVOID ptr ); - PVOID Get( DWORD index ); - - ObjectList::Iterator Iterate() - { - LIMITED_METHOD_CONTRACT; - ObjectList::Iterator i; - i._iter = this->allEntries_.Iterate(); - return i; - } - -private: - ArrayList allEntries_; - DWORD freeIndexHead_; - Crst listLock_; -}; - -class UnsynchronizedBlockAllocator -{ -public: - UnsynchronizedBlockAllocator( size_t blockSize ); - ~UnsynchronizedBlockAllocator( void ); - - PVOID Allocate( size_t size ); - -private: - ArrayList blockList_; - - size_t blockSize_; - size_t offset_; - DWORD index_; - -}; - -#endif // __objectlist_h__ diff --git a/src/coreclr/vm/olevariant.cpp b/src/coreclr/vm/olevariant.cpp index 5f7913b07b7..ab42391080e 100644 --- a/src/coreclr/vm/olevariant.cpp +++ b/src/coreclr/vm/olevariant.cpp @@ -24,68 +24,12 @@ #define NO_MAPPING ((BYTE) -1) -#define GCPROTECT_BEGIN_VARIANTDATA(/*VARIANTDATA*/vd) do { \ - GCFrame __gcframe(vd.GetObjRefPtr(), 1, FALSE); \ - /* work around unreachable code warning */ \ - if (true) { DEBUG_ASSURE_NO_RETURN_BEGIN(GCPROTECT); - - -#define GCPROTECT_END_VARIANTDATA() \ - DEBUG_ASSURE_NO_RETURN_END(GCPROTECT); } \ - } while(0) - - -//Mapping from CVType to type handle. Used for conversion between the two internally. -const BinderClassID CVTypeToBinderClassID[] = -{ - CLASS__EMPTY, //CV_EMPTY - CLASS__VOID, //CV_VOID, Changing this to object messes up signature resolution very badly. - CLASS__BOOLEAN, //CV_BOOLEAN - CLASS__CHAR, //CV_CHAR - CLASS__SBYTE, //CV_I1 - CLASS__BYTE, //CV_U1 - CLASS__INT16, //CV_I2 - CLASS__UINT16, //CV_U2 - CLASS__INT32, //CV_I4 - CLASS__UINT32, //CV_UI4 - CLASS__INT64, //CV_I8 - CLASS__UINT64, //CV_UI8 - CLASS__SINGLE, //CV_R4 - CLASS__DOUBLE, //CV_R8 - CLASS__STRING, //CV_STRING - CLASS__VOID, //CV_PTR...We treat this as void - CLASS__DATE_TIME, //CV_DATETIME - CLASS__TIMESPAN, //CV_TIMESPAN - CLASS__OBJECT, //CV_OBJECT - CLASS__DECIMAL, //CV_DECIMAL - CLASS__CURRENCY, //CV_CURRENCY - CLASS__OBJECT, //ENUM...We treat this as OBJECT - CLASS__MISSING, //CV_MISSING - CLASS__NULL, //CV_NULL - CLASS__NIL, //CV_LAST -}; - -// Use this very carefully. There is not a direct mapping between -// CorElementType and CVTypes for a bunch of things. In this case -// we return CV_LAST. You need to check this at the call site. -CVTypes CorElementTypeToCVTypes(CorElementType type) -{ - LIMITED_METHOD_CONTRACT; - - if (type <= ELEMENT_TYPE_STRING) - return (CVTypes) type; - - if (type == ELEMENT_TYPE_CLASS || type == ELEMENT_TYPE_OBJECT) - return (CVTypes) ELEMENT_TYPE_CLASS; - - return CV_LAST; -} /* ------------------------------------------------------------------------- * * Mapping routines * ------------------------------------------------------------------------- */ -VARTYPE OleVariant::GetVarTypeForCVType(CVTypes type) +VARTYPE GetVarTypeForCorElementType(CorElementType type) { CONTRACTL { @@ -97,33 +41,24 @@ VARTYPE OleVariant::GetVarTypeForCVType(CVTypes type) static const BYTE map[] = { - VT_EMPTY, // CV_EMPTY - VT_VOID, // CV_VOID - VT_BOOL, // CV_BOOLEAN - VT_UI2, // CV_CHAR - VT_I1, // CV_I1 - VT_UI1, // CV_U1 - VT_I2, // CV_I2 - VT_UI2, // CV_U2 - VT_I4, // CV_I4 - VT_UI4, // CV_U4 - VT_I8, // CV_I8 - VT_UI8, // CV_U8 - VT_R4, // CV_R4 - VT_R8, // CV_R8 - VT_BSTR, // CV_STRING - NO_MAPPING, // CV_PTR - VT_DATE, // CV_DATETIME - NO_MAPPING, // CV_TIMESPAN - VT_DISPATCH, // CV_OBJECT - VT_DECIMAL, // CV_DECIMAL - VT_CY, // CV_CURRENCY - VT_I4, // CV_ENUM - VT_ERROR, // CV_MISSING - VT_NULL // CV_NULL + VT_EMPTY, // ELEMENT_TYPE_END + VT_VOID, // ELEMENT_TYPE_VOID + VT_BOOL, // ELEMENT_TYPE_BOOLEAN + VT_UI2, // ELEMENT_TYPE_CHAR + VT_I1, // ELEMENT_TYPE_I1 + VT_UI1, // ELEMENT_TYPE_U1 + VT_I2, // ELEMENT_TYPE_I2 + VT_UI2, // ELEMENT_TYPE_U2 + VT_I4, // ELEMENT_TYPE_I4 + VT_UI4, // ELEMENT_TYPE_U4 + VT_I8, // ELEMENT_TYPE_I8 + VT_UI8, // ELEMENT_TYPE_U8 + VT_R4, // ELEMENT_TYPE_R4 + VT_R8, // ELEMENT_TYPE_R8 + VT_BSTR, // ELEMENT_TYPE_STRING }; - _ASSERTE(type < (CVTypes) (sizeof(map) / sizeof(map[0]))); + _ASSERTE(type < (CorElementType) (sizeof(map) / sizeof(map[0]))); VARTYPE vt = VARTYPE(map[type]); @@ -134,48 +69,48 @@ VARTYPE OleVariant::GetVarTypeForCVType(CVTypes type) } // -// GetCVTypeForVarType returns the COM+ variant type for a given +// GetTypeHandleForVarType returns the TypeHandle for a given // VARTYPE. This is called by the marshaller in the context of // a function call. // -CVTypes OleVariant::GetCVTypeForVarType(VARTYPE vt) +TypeHandle OleVariant::GetTypeHandleForVarType(VARTYPE vt) { CONTRACTL { THROWS; - GC_NOTRIGGER; + GC_TRIGGERS; MODE_ANY; } CONTRACTL_END; static const BYTE map[] = { - CV_EMPTY, // VT_EMPTY - CV_NULL, // VT_NULL - CV_I2, // VT_I2 - CV_I4, // VT_I4 - CV_R4, // VT_R4 - CV_R8, // VT_R8 - CV_DECIMAL, // VT_CY - CV_DATETIME, // VT_DATE - CV_STRING, // VT_BSTR - CV_OBJECT, // VT_DISPATCH - CV_I4, // VT_ERROR - CV_BOOLEAN, // VT_BOOL + CLASS__EMPTY, // VT_EMPTY + CLASS__NULL, // VT_NULL + CLASS__INT16, // VT_I2 + CLASS__INT32, // VT_I4 + CLASS__SINGLE, // VT_R4 + CLASS__DOUBLE, // VT_R8 + CLASS__DECIMAL, // VT_CY + CLASS__DATE_TIME, // VT_DATE + CLASS__STRING, // VT_BSTR + CLASS__OBJECT, // VT_DISPATCH + CLASS__INT32, // VT_ERROR + CLASS__BOOLEAN, // VT_BOOL NO_MAPPING, // VT_VARIANT - CV_OBJECT, // VT_UNKNOWN - CV_DECIMAL, // VT_DECIMAL + CLASS__OBJECT, // VT_UNKNOWN + CLASS__DECIMAL, // VT_DECIMAL NO_MAPPING, // unused - CV_I1, // VT_I1 - CV_U1, // VT_UI1 - CV_U2, // VT_UI2 - CV_U4, // VT_UI4 - CV_I8, // VT_I8 - CV_U8, // VT_UI8 - CV_I4, // VT_INT - CV_U4, // VT_UINT - CV_VOID, // VT_VOID + CLASS__SBYTE, // VT_I1 + CLASS__BYTE, // VT_UI1 + CLASS__UINT16, // VT_UI2 + CLASS__UINT32, // VT_UI4 + CLASS__INT64, // VT_I8 + CLASS__UINT64, // VT_UI8 + CLASS__INT32, // VT_INT + CLASS__UINT32, // VT_UINT + CLASS__VOID, // VT_VOID NO_MAPPING, // VT_HRESULT NO_MAPPING, // VT_PTR NO_MAPPING, // VT_SAFEARRAY @@ -187,102 +122,25 @@ CVTypes OleVariant::GetCVTypeForVarType(VARTYPE vt) NO_MAPPING, // unused NO_MAPPING, // unused NO_MAPPING, // unused - CV_OBJECT, // VT_RECORD + CLASS__OBJECT, // VT_RECORD }; - CVTypes type = CV_LAST; + BinderClassID type = CLASS__NIL; // Validate the arguments. _ASSERTE((vt & VT_BYREF) == 0); - // Array's map to CV_OBJECT. + // Array's map to object. if (vt & VT_ARRAY) - return CV_OBJECT; + return TypeHandle(CoreLibBinder::GetClass(CLASS__OBJECT)); // This is prety much a workaround because you cannot cast a CorElementType into a CVTYPE - if (vt > VT_RECORD || (BYTE)(type = (CVTypes) map[vt]) == NO_MAPPING) + if (vt > VT_RECORD || (type = (BinderClassID) map[vt]) == NO_MAPPING) COMPlusThrow(kArgumentException, IDS_EE_COM_UNSUPPORTED_TYPE); - return type; + return TypeHandle(CoreLibBinder::GetClass(type)); } // CVTypes OleVariant::GetCVTypeForVarType() -#ifdef FEATURE_COMINTEROP - -// GetVarTypeForComVariant retusn the VARTYPE for the contents -// of a COM+ variant. -// -VARTYPE OleVariant::GetVarTypeForComVariant(VariantData *pComVariant) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; - } - CONTRACTL_END; - - CVTypes type = pComVariant->GetType(); - VARTYPE vt; - - vt = pComVariant->GetVT(); - if (vt != VT_EMPTY) - { - // This variant was originally unmarshaled from unmanaged, and had the original VT recorded in it. - // We'll always use that over inference. - return vt; - } - - if (type == CV_OBJECT) - { - OBJECTREF obj = pComVariant->GetObjRef(); - - // Null objects will be converted to VT_DISPATCH variants with a null - // IDispatch pointer. - if (obj == NULL) - return VT_DISPATCH; - - // Retrieve the object's method table. - MethodTable *pMT = obj->GetMethodTable(); - - // Handle the value class case. - if (pMT->IsValueType()) - return VT_RECORD; - - // Handle the array case. - if (pMT->IsArray()) - { - vt = GetElementVarTypeForArrayRef((BASEARRAYREF)obj); - if (vt == VT_ARRAY) - vt = VT_VARIANT; - - return vt | VT_ARRAY; - } - -#ifdef FEATURE_COMINTEROP - // SafeHandle's or CriticalHandle's cannot be stored in VARIANT's. - if (pMT->CanCastToClass(CoreLibBinder::GetClass(CLASS__SAFE_HANDLE))) - COMPlusThrow(kArgumentException, IDS_EE_SH_IN_VARIANT_NOT_SUPPORTED); - if (pMT->CanCastToClass(CoreLibBinder::GetClass(CLASS__CRITICAL_HANDLE))) - COMPlusThrow(kArgumentException, IDS_EE_CH_IN_VARIANT_NOT_SUPPORTED); - - // VariantWrappers cannot be stored in VARIANT's. - if (CoreLibBinder::IsClass(pMT, CLASS__VARIANT_WRAPPER)) - COMPlusThrow(kArgumentException, IDS_EE_VAR_WRAP_IN_VAR_NOT_SUPPORTED); - - // We are dealing with a normal object (not a wrapper) so we will - // leave the VT as VT_DISPATCH for now and we will determine the actual - // VT when we convert the object to a COM IP. - return VT_DISPATCH; -#else // FEATURE_COMINTEROP - return VT_UNKNOWN; -#endif // FEATURE_COMINTEROP - } - - return GetVarTypeForCVType(type); -} - -#endif // FEATURE_COMINTEROP - VARTYPE OleVariant::GetVarTypeForTypeHandle(TypeHandle type) { CONTRACTL @@ -296,7 +154,7 @@ VARTYPE OleVariant::GetVarTypeForTypeHandle(TypeHandle type) // Handle primitive types. CorElementType elemType = type.GetSignatureCorElementType(); if (elemType <= ELEMENT_TYPE_R8) - return GetVarTypeForCVType(CorElementTypeToCVTypes(elemType)); + return GetVarTypeForCorElementType(elemType); // Types incompatible with interop. if (type.IsTypeDesc()) @@ -350,7 +208,7 @@ VARTYPE OleVariant::GetVarTypeForTypeHandle(TypeHandle type) #endif // FEATURE_COMINTEROP if (pMT->IsEnum()) - return GetVarTypeForCVType((CVTypes)type.GetInternalCorElementType()); + return GetVarTypeForCorElementType(type.GetInternalCorElementType()); if (pMT->IsValueType()) return VT_RECORD; @@ -868,26 +726,14 @@ const OleVariant::Marshaler *OleVariant::GetMarshalerForVarType(VARTYPE vt, BOOL } CONTRACT_END; -#ifdef FEATURE_COMINTEROP - -#define RETURN_MARSHALER(OleToCom, ComToOle, OleRefToCom, ArrayOleToCom, ArrayComToOle, ClearArray) \ - { static const Marshaler marshaler = { OleToCom, ComToOle, OleRefToCom, ArrayOleToCom, ArrayComToOle, ClearArray }; RETURN &marshaler; } - -#else // FEATURE_COMINTEROP - -#define RETURN_MARSHALER(OleToCom, ComToOle, OleRefToCom, ArrayOleToCom, ArrayComToOle, ClearArray) \ +#define RETURN_MARSHALER(ArrayOleToCom, ArrayComToOle, ClearArray) \ { static const Marshaler marshaler = { ArrayOleToCom, ArrayComToOle, ClearArray }; RETURN &marshaler; } -#endif // FEATURE_COMINTEROP - #ifdef FEATURE_COMINTEROP if (vt & VT_ARRAY) { VariantArray: RETURN_MARSHALER( - MarshalArrayVariantOleToCom, - MarshalArrayVariantComToOle, - MarshalArrayVariantOleRefToCom, NULL, NULL, ClearVariantArray @@ -899,9 +745,6 @@ const OleVariant::Marshaler *OleVariant::GetMarshalerForVarType(VARTYPE vt, BOOL { case VT_BOOL: RETURN_MARSHALER( - MarshalBoolVariantOleToCom, - NULL, - NULL, MarshalBoolArrayOleToCom, MarshalBoolArrayComToOle, NULL @@ -909,28 +752,14 @@ const OleVariant::Marshaler *OleVariant::GetMarshalerForVarType(VARTYPE vt, BOOL case VT_DATE: RETURN_MARSHALER( - MarshalDateVariantOleToCom, - MarshalDateVariantComToOle, - MarshalDateVariantOleRefToCom, MarshalDateArrayOleToCom, MarshalDateArrayComToOle, NULL ); - case VT_DECIMAL: - RETURN_MARSHALER( - MarshalDecimalVariantOleToCom, - MarshalDecimalVariantComToOle, - MarshalDecimalVariantOleRefToCom, - NULL, NULL, NULL - ); - #ifdef FEATURE_COMINTEROP case VT_CY: RETURN_MARSHALER( - MarshalCurrencyVariantOleToCom, - MarshalCurrencyVariantComToOle, - MarshalCurrencyVariantOleRefToCom, MarshalCurrencyArrayOleToCom, MarshalCurrencyArrayComToOle, NULL @@ -938,9 +767,6 @@ const OleVariant::Marshaler *OleVariant::GetMarshalerForVarType(VARTYPE vt, BOOL case VT_BSTR: RETURN_MARSHALER( - MarshalBSTRVariantOleToCom, - MarshalBSTRVariantComToOle, - NULL, MarshalBSTRArrayOleToCom, MarshalBSTRArrayComToOle, ClearBSTRArray @@ -948,9 +774,6 @@ const OleVariant::Marshaler *OleVariant::GetMarshalerForVarType(VARTYPE vt, BOOL case VT_UNKNOWN: RETURN_MARSHALER( - MarshalInterfaceVariantOleToCom, - MarshalInterfaceVariantComToOle, - MarshalInterfaceVariantOleRefToCom, MarshalInterfaceArrayOleToCom, MarshalIUnknownArrayComToOle, ClearInterfaceArray @@ -958,9 +781,6 @@ const OleVariant::Marshaler *OleVariant::GetMarshalerForVarType(VARTYPE vt, BOOL case VT_DISPATCH: RETURN_MARSHALER( - MarshalInterfaceVariantOleToCom, - MarshalInterfaceVariantComToOle, - MarshalInterfaceVariantOleRefToCom, MarshalInterfaceArrayOleToCom, MarshalIDispatchArrayComToOle, ClearInterfaceArray @@ -971,24 +791,15 @@ const OleVariant::Marshaler *OleVariant::GetMarshalerForVarType(VARTYPE vt, BOOL case VT_VARIANT: RETURN_MARSHALER( - NULL, NULL, NULL, MarshalVariantArrayOleToCom, MarshalVariantArrayComToOle, ClearVariantArray ); - case VT_ERROR: - RETURN_MARSHALER( - MarshalErrorVariantOleToCom, - MarshalErrorVariantComToOle, - MarshalErrorVariantOleRefToCom, - NULL, NULL, NULL - ); #endif // FEATURE_COMINTEROP case VTHACK_NONBLITTABLERECORD: RETURN_MARSHALER( - NULL, NULL, NULL, MarshalNonBlittableRecordArrayOleToCom, MarshalNonBlittableRecordArrayComToOle, ClearNonBlittableRecordArray @@ -999,9 +810,6 @@ const OleVariant::Marshaler *OleVariant::GetMarshalerForVarType(VARTYPE vt, BOOL case VTHACK_WINBOOL: RETURN_MARSHALER( - MarshalWinBoolVariantOleToCom, - MarshalWinBoolVariantComToOle, - MarshalWinBoolVariantOleRefToCom, MarshalWinBoolArrayOleToCom, MarshalWinBoolArrayComToOle, NULL @@ -1009,9 +817,6 @@ const OleVariant::Marshaler *OleVariant::GetMarshalerForVarType(VARTYPE vt, BOOL case VTHACK_CBOOL: RETURN_MARSHALER( - MarshalCBoolVariantOleToCom, - MarshalCBoolVariantComToOle, - MarshalCBoolVariantOleRefToCom, MarshalCBoolArrayOleToCom, MarshalCBoolArrayComToOle, NULL @@ -1019,9 +824,6 @@ const OleVariant::Marshaler *OleVariant::GetMarshalerForVarType(VARTYPE vt, BOOL case VTHACK_ANSICHAR: RETURN_MARSHALER( - MarshalAnsiCharVariantOleToCom, - MarshalAnsiCharVariantComToOle, - MarshalAnsiCharVariantOleRefToCom, MarshalAnsiCharArrayOleToCom, MarshalAnsiCharArrayComToOle, NULL @@ -1029,7 +831,6 @@ const OleVariant::Marshaler *OleVariant::GetMarshalerForVarType(VARTYPE vt, BOOL case VT_LPSTR: RETURN_MARSHALER( - NULL, NULL, NULL, MarshalLPSTRArrayOleToCom, MarshalLPSTRRArrayComToOle, ClearLPSTRArray @@ -1037,7 +838,6 @@ const OleVariant::Marshaler *OleVariant::GetMarshalerForVarType(VARTYPE vt, BOOL case VT_LPWSTR: RETURN_MARSHALER( - NULL, NULL, NULL, MarshalLPWSTRArrayOleToCom, MarshalLPWSTRRArrayComToOle, ClearLPWSTRArray @@ -1046,16 +846,12 @@ const OleVariant::Marshaler *OleVariant::GetMarshalerForVarType(VARTYPE vt, BOOL case VT_RECORD: #ifdef FEATURE_COMINTEROP RETURN_MARSHALER( - MarshalRecordVariantOleToCom, - MarshalRecordVariantComToOle, - MarshalRecordVariantOleRefToCom, MarshalRecordArrayOleToCom, MarshalRecordArrayComToOle, ClearRecordArray ); #else RETURN_MARSHALER( - NULL, NULL, NULL, MarshalRecordArrayOleToCom, MarshalRecordArrayComToOle, ClearRecordArray @@ -1081,79 +877,6 @@ const OleVariant::Marshaler *OleVariant::GetMarshalerForVarType(VARTYPE vt, BOOL #ifdef FEATURE_COMINTEROP -/*==================================NewVariant================================== -**N.B.: This method does a GC Allocation. Any method calling it is required to -** GC_PROTECT the OBJECTREF. -** -**Actions: Allocates a new Variant and fills it with the appropriate data. -**Returns: A new Variant with all of the appropriate fields filled out. -**Exceptions: OutOfMemoryError if v can't be allocated. -==============================================================================*/ -void VariantData::NewVariant(VariantData * const& dest, const CVTypes type, INT64 data - DEBUG_ARG(BOOL bDestIsInterior)) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; - // Don't pass an object in for Empty. - PRECONDITION(CheckPointer(dest)); - PRECONDITION((bDestIsInterior && IsProtectedByGCFrame ((OBJECTREF *) &dest)) - || (!bDestIsInterior && IsProtectedByGCFrame (dest->GetObjRefPtr ()))); - PRECONDITION((type == CV_EMPTY) || (type == CV_NULL) || (type == CV_U4) || (type == CV_U8)); - } - CONTRACTL_END; - - //If both arguments are null or both are specified, we're in an illegal situation. Bail. - //If all three are null, we're creating an empty variant - if ( (type != CV_EMPTY) && (type != CV_NULL) && (type != CV_U4) && (type != CV_U8) ) - { - COMPlusThrow(kArgumentException); - } - - //Fill in the data. - dest->SetType(type); - - switch (type) - { - case CV_U4: - dest->SetObjRef(NULL); - dest->SetDataAsUInt32((UINT32)data); - break; - - case CV_U8: - dest->SetObjRef(NULL); - dest->SetDataAsInt64(data); - break; - - case CV_NULL: - { - FieldDesc * pFD = CoreLibBinder::GetField(FIELD__NULL__VALUE); - _ASSERTE(pFD); - - pFD->CheckRunClassInitThrowing(); - - OBJECTREF obj = pFD->GetStaticOBJECTREF(); - _ASSERTE(obj!=NULL); - - dest->SetObjRef(obj); - dest->SetDataAsInt64(0); - break; - } - - case CV_EMPTY: - { - dest->SetObjRef(NULL); - break; - } - - default: - // Did you add any new CVTypes? - COMPlusThrow(kNotSupportedException, W("Arg_InvalidOleVariantTypeException")); - } -} - void SafeVariantClear(VARIANT* pVar) { CONTRACTL @@ -1226,26 +949,6 @@ class RecordVariantHolder : public Wrapper, Reco * Boolean marshaling routines * ------------------------------------------------------------------------- */ -#ifdef FEATURE_COMINTEROP - -void OleVariant::MarshalBoolVariantOleToCom(VARIANT *pOleVariant, - VariantData *pComVariant) -{ - CONTRACTL - { - NOTHROW; - GC_NOTRIGGER; - MODE_ANY; - PRECONDITION(CheckPointer(pComVariant)); - PRECONDITION(CheckPointer(pOleVariant)); - } - CONTRACTL_END; - - *(INT64*)pComVariant->GetData() = V_BOOL(pOleVariant) ? 1 : 0; -} - -#endif // FEATURE_COMINTEROP - void OleVariant::MarshalBoolArrayOleToCom(void *oleArray, BASEARRAYREF *pComArray, MethodTable *pInterfaceMT, PCODE pManagedMarshalerCode) { @@ -1311,32 +1014,6 @@ void OleVariant::MarshalBoolArrayComToOle(BASEARRAYREF *pComArray, void *oleArra * WinBoolean marshaling routines * ------------------------------------------------------------------------- */ -#ifdef FEATURE_COMINTEROP -void OleVariant::MarshalWinBoolVariantOleToCom(VARIANT *pOleVariant, - VariantData *pComVariant) -{ - LIMITED_METHOD_CONTRACT; - - _ASSERTE(!"Not supposed to get here."); -} - -void OleVariant::MarshalWinBoolVariantComToOle(VariantData *pComVariant, - VARIANT *pOleVariant) -{ - LIMITED_METHOD_CONTRACT; - - _ASSERTE(!"Not supposed to get here."); -} - -void OleVariant::MarshalWinBoolVariantOleRefToCom(VARIANT *pOleVariant, - VariantData *pComVariant) -{ - LIMITED_METHOD_CONTRACT; - - _ASSERTE(!"Not supposed to get here."); -} -#endif // FEATURE_COMINTEROP - void OleVariant::MarshalWinBoolArrayOleToCom(void *oleArray, BASEARRAYREF *pComArray, MethodTable *pInterfaceMT, PCODE pManagedMarshalerCode) { @@ -1402,29 +1079,6 @@ void OleVariant::MarshalWinBoolArrayComToOle(BASEARRAYREF *pComArray, void *oleA * CBool marshaling routines * ------------------------------------------------------------------------- */ -#ifdef FEATURE_COMINTEROP -void OleVariant::MarshalCBoolVariantOleToCom(VARIANT* pOleVariant, VariantData* pComVariant) -{ - LIMITED_METHOD_CONTRACT; - - _ASSERTE(!"Not supposed to get here."); -} - -void OleVariant::MarshalCBoolVariantComToOle(VariantData* pComVariant, VARIANT* pOleVariant) -{ - LIMITED_METHOD_CONTRACT; - - _ASSERTE(!"Not supposed to get here."); -} - -void OleVariant::MarshalCBoolVariantOleRefToCom(VARIANT* pOleVariant, VariantData* pComVariant) -{ - LIMITED_METHOD_CONTRACT; - - _ASSERTE(!"Not supposed to get here."); -} -#endif // FEATURE_COMINTEROP - void OleVariant::MarshalCBoolArrayOleToCom(void* oleArray, BASEARRAYREF* pComArray, MethodTable* pInterfaceMT, PCODE pManagedMarshalerCode) { @@ -1496,32 +1150,6 @@ void OleVariant::MarshalCBoolArrayComToOle(BASEARRAYREF* pComArray, void* oleArr * Ansi char marshaling routines * ------------------------------------------------------------------------- */ -#ifdef FEATURE_COMINTEROP -void OleVariant::MarshalAnsiCharVariantOleToCom(VARIANT *pOleVariant, - VariantData *pComVariant) -{ - LIMITED_METHOD_CONTRACT; - - _ASSERTE(!"Not supposed to get here."); -} - -void OleVariant::MarshalAnsiCharVariantComToOle(VariantData *pComVariant, - VARIANT *pOleVariant) -{ - LIMITED_METHOD_CONTRACT; - - _ASSERTE(!"Not supposed to get here."); -} - -void OleVariant::MarshalAnsiCharVariantOleRefToCom(VARIANT *pOleVariant, - VariantData *pComVariant) -{ - LIMITED_METHOD_CONTRACT; - - _ASSERTE(!"Not supposed to get here."); -} -#endif // FEATURE_COMINTEROP - void OleVariant::MarshalAnsiCharArrayOleToCom(void *oleArray, BASEARRAYREF *pComArray, MethodTable *pInterfaceMT, PCODE pManagedMarshalerCode) { @@ -1593,118 +1221,6 @@ void OleVariant::MarshalAnsiCharArrayComToOle(BASEARRAYREF *pComArray, void *ole * ------------------------------------------------------------------------- */ #ifdef FEATURE_COMINTEROP -void OleVariant::MarshalInterfaceVariantOleToCom(VARIANT *pOleVariant, - VariantData *pComVariant) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; - PRECONDITION(CheckPointer(pOleVariant)); - PRECONDITION(CheckPointer(pComVariant)); - } - CONTRACTL_END; - - IUnknown *unk = V_UNKNOWN(pOleVariant); - - OBJECTREF obj = NULL; - if (unk != NULL) - { - GCPROTECT_BEGIN(obj); - GetObjectRefFromComIP(&obj, V_UNKNOWN(pOleVariant)); - GCPROTECT_END(); - } - - pComVariant->SetObjRef(obj); -} - -void OleVariant::MarshalInterfaceVariantComToOle(VariantData *pComVariant, - VARIANT *pOleVariant) - -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; - PRECONDITION(CheckPointer(pOleVariant)); - PRECONDITION(CheckPointer(pComVariant)); - } - CONTRACTL_END; - - OBJECTREF *obj = pComVariant->GetObjRefPtr(); - VARTYPE vt = pComVariant->GetVT(); - - ASSERT_PROTECTED(obj); - - if (*obj == NULL) - { - // If there is no VT set in the managed variant, then default to VT_UNKNOWN. - if (vt == VT_EMPTY) - vt = VT_UNKNOWN; - - V_UNKNOWN(pOleVariant) = NULL; - V_VT(pOleVariant) = vt; - } - else - { -#ifdef FEATURE_COMINTEROP - ComIpType FetchedIpType = ComIpType_None; - ComIpType ReqIpType; - - if (vt != VT_EMPTY) - { - // We are dealing with an UnknownWrapper or DispatchWrapper. - // In this case, we need to respect the VT. - _ASSERTE(vt == VT_DISPATCH || vt == VT_UNKNOWN); - ReqIpType = vt == VT_DISPATCH ? ComIpType_Dispatch : ComIpType_Unknown; - } - else - { - // We are dealing with a normal object so we can give either - // IDispatch or IUnknown out depending on what it supports. - ReqIpType = ComIpType_Both; - } - - IUnknown *unk = GetComIPFromObjectRef(obj, ReqIpType, &FetchedIpType); - BOOL ItfIsDispatch = FetchedIpType == ComIpType_Dispatch; - - V_UNKNOWN(pOleVariant) = unk; - V_VT(pOleVariant) = static_cast(ItfIsDispatch ? VT_DISPATCH : VT_UNKNOWN); -#else // FEATURE_COMINTEROP - V_UNKNOWN(pOleVariant) = GetComIPFromObjectRef(obj); - V_VT(pOleVariant) = VT_UNKNOWN; -#endif // FEATURE_COMINTEROP - } -} - -void OleVariant::MarshalInterfaceVariantOleRefToCom(VARIANT *pOleVariant, - VariantData *pComVariant) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; - PRECONDITION(CheckPointer(pOleVariant)); - PRECONDITION(CheckPointer(pComVariant)); - } - CONTRACTL_END; - - IUnknown *unk = V_UNKNOWN(pOleVariant); - - OBJECTREF obj = NULL; - if (unk != NULL) - { - GCPROTECT_BEGIN(obj); - GetObjectRefFromComIP(&obj, *V_UNKNOWNREF(pOleVariant)); - GCPROTECT_END(); - } - - pComVariant->SetObjRef(obj); -} - void OleVariant::MarshalInterfaceArrayOleToCom(void *oleArray, BASEARRAYREF *pComArray, MethodTable *pElementMT, PCODE pManagedMarshalerCode) { @@ -1815,55 +1331,6 @@ void OleVariant::ClearInterfaceArray(void *oleArray, SIZE_T cElements, MethodTab * BSTR marshaling routines * ------------------------------------------------------------------------- */ -void OleVariant::MarshalBSTRVariantOleToCom(VARIANT *pOleVariant, - VariantData *pComVariant) -{ - CONTRACTL - { - WRAPPER(THROWS); - WRAPPER(GC_TRIGGERS); - MODE_COOPERATIVE; - INJECT_FAULT(COMPlusThrowOM()); - PRECONDITION(CheckPointer(pOleVariant)); - PRECONDITION(CheckPointer(pComVariant)); - } - CONTRACTL_END; - - BSTR bstr = V_BSTR(pOleVariant); - - STRINGREF stringObj = NULL; - GCPROTECT_BEGIN(stringObj) - { - ConvertBSTRToString(bstr, &stringObj); - pComVariant->SetObjRef((OBJECTREF) stringObj); - } - GCPROTECT_END(); - - pComVariant->SetObjRef((OBJECTREF) stringObj); -} - -void OleVariant::MarshalBSTRVariantComToOle(VariantData *pComVariant, - VARIANT *pOleVariant) -{ - CONTRACTL - { - THROWS; - WRAPPER(GC_TRIGGERS); - MODE_COOPERATIVE; - INJECT_FAULT(COMPlusThrowOM()); - PRECONDITION(CheckPointer(pOleVariant)); - PRECONDITION(CheckPointer(pComVariant)); - } - CONTRACTL_END; - - STRINGREF stringObj = (STRINGREF) pComVariant->GetObjRef(); - GCPROTECT_BEGIN(stringObj) - { - V_BSTR(pOleVariant) = ConvertStringToBSTR(&stringObj); - } - GCPROTECT_END(); -} - void OleVariant::MarshalBSTRArrayOleToCom(void *oleArray, BASEARRAYREF *pComArray, MethodTable *pInterfaceMT, PCODE pManagedMarshalerCode) { @@ -2374,38 +1841,12 @@ void OleVariant::ClearLPSTRArray(void *oleArray, SIZE_T cElements, MethodTable * if (lpstr != NULL) CoTaskMemFree(lpstr); - } -} - -/* ------------------------------------------------------------------------- * - * Date marshaling routines - * ------------------------------------------------------------------------- */ - -#ifdef FEATURE_COMINTEROP -void OleVariant::MarshalDateVariantOleToCom(VARIANT *pOleVariant, - VariantData *pComVariant) -{ - WRAPPER_NO_CONTRACT; - - *(INT64*)pComVariant->GetData() = COMDateTime::DoubleDateToTicks(V_DATE(pOleVariant)); -} - -void OleVariant::MarshalDateVariantComToOle(VariantData *pComVariant, - VARIANT *pOleVariant) -{ - WRAPPER_NO_CONTRACT; - - V_DATE(pOleVariant) = COMDateTime::TicksToDoubleDate(*(INT64*)pComVariant->GetData()); -} - -void OleVariant::MarshalDateVariantOleRefToCom(VARIANT *pOleVariant, - VariantData *pComVariant) -{ - WRAPPER_NO_CONTRACT; - - *(INT64*)pComVariant->GetData() = COMDateTime::DoubleDateToTicks(*V_DATEREF(pOleVariant)); + } } -#endif // FEATURE_COMINTEROP + +/* ------------------------------------------------------------------------- * + * Date marshaling routines + * ------------------------------------------------------------------------- */ void OleVariant::MarshalDateArrayOleToCom(void *oleArray, BASEARRAYREF *pComArray, MethodTable *pInterfaceMT, PCODE pManagedMarshalerCode) @@ -2469,87 +1910,13 @@ void OleVariant::MarshalDateArrayComToOle(BASEARRAYREF *pComArray, void *oleArra *pOle++ = COMDateTime::TicksToDoubleDate(*pCom++); } -/* ------------------------------------------------------------------------- * - * Decimal marshaling routines - * ------------------------------------------------------------------------- */ - -#ifdef FEATURE_COMINTEROP - -void OleVariant::MarshalDecimalVariantOleToCom(VARIANT *pOleVariant, - VariantData *pComVariant) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; - INJECT_FAULT(COMPlusThrowOM()); - PRECONDITION(CheckPointer(pOleVariant)); - PRECONDITION(CheckPointer(pComVariant)); - } - CONTRACTL_END; - - OBJECTREF pDecimalRef = AllocateObject(CoreLibBinder::GetClass(CLASS__DECIMAL)); - - DECIMAL* pDecimal = (DECIMAL *) pDecimalRef->UnBox(); - *pDecimal = V_DECIMAL(pOleVariant); - // Mashaling uses the reserved value to store the variant type, so clear it out when marshaling back - pDecimal->wReserved = 0; - - pComVariant->SetObjRef(pDecimalRef); -} - -void OleVariant::MarshalDecimalVariantComToOle(VariantData *pComVariant, - VARIANT *pOleVariant) -{ - CONTRACTL - { - WRAPPER(THROWS); - WRAPPER(GC_TRIGGERS); - MODE_COOPERATIVE; - PRECONDITION(CheckPointer(pOleVariant)); - PRECONDITION(CheckPointer(pComVariant)); - } - CONTRACTL_END; - - VARTYPE vt = V_VT(pOleVariant); - _ASSERTE(vt == VT_DECIMAL); - V_DECIMAL(pOleVariant) = * (DECIMAL*) pComVariant->GetObjRef()->UnBox(); - V_VT(pOleVariant) = vt; -} - -void OleVariant::MarshalDecimalVariantOleRefToCom(VARIANT *pOleVariant, - VariantData *pComVariant ) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; - INJECT_FAULT(COMPlusThrowOM()); - PRECONDITION(CheckPointer(pOleVariant)); - PRECONDITION(CheckPointer(pComVariant)); - } - CONTRACTL_END; - - OBJECTREF pDecimalRef = AllocateObject(CoreLibBinder::GetClass(CLASS__DECIMAL)); - - DECIMAL* pDecimal = (DECIMAL *) pDecimalRef->UnBox(); - *pDecimal = *V_DECIMALREF(pOleVariant); - // Mashaling uses the reserved value to store the variant type, so clear it out when marshaling back - pDecimal->wReserved = 0; - - pComVariant->SetObjRef(pDecimalRef); -} -#endif // FEATURE_COMINTEROP - /* ------------------------------------------------------------------------- * * Record marshaling routines * ------------------------------------------------------------------------- */ #ifdef FEATURE_COMINTEROP -void OleVariant::MarshalRecordVariantOleToCom(VARIANT *pOleVariant, - VariantData *pComVariant) +void OleVariant::MarshalRecordVariantOleToObject(const VARIANT *pOleVariant, + OBJECTREF * const & pObj) { CONTRACTL { @@ -2558,7 +1925,8 @@ void OleVariant::MarshalRecordVariantOleToCom(VARIANT *pOleVariant, MODE_COOPERATIVE; INJECT_FAULT(COMPlusThrowOM()); PRECONDITION(CheckPointer(pOleVariant)); - PRECONDITION(CheckPointer(pComVariant)); + PRECONDITION(CheckPointer(pObj)); + PRECONDITION(*pObj == NULL || (IsProtectedByGCFrame (pObj))); } CONTRACTL_END; @@ -2570,7 +1938,7 @@ void OleVariant::MarshalRecordVariantOleToCom(VARIANT *pOleVariant, LPVOID pvRecord = V_RECORD(pOleVariant); if (pvRecord == NULL) { - pComVariant->SetObjRef(NULL); + SetObjectReference(pObj, NULL); return; } @@ -2595,42 +1963,10 @@ void OleVariant::MarshalRecordVariantOleToCom(VARIANT *pOleVariant, // boxed value class and copy the contents of the record into it. BoxedValueClass = AllocateObject(pValueClass); memcpyNoGCRefs(BoxedValueClass->GetData(), (BYTE*)pvRecord, pValueClass->GetNativeSize()); - pComVariant->SetObjRef(BoxedValueClass); - } - GCPROTECT_END(); -} - -void OleVariant::MarshalRecordVariantComToOle(VariantData *pComVariant, - VARIANT *pOleVariant) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; - PRECONDITION(CheckPointer(pOleVariant)); - PRECONDITION(CheckPointer(pComVariant)); - } - CONTRACTL_END; - - OBJECTREF BoxedValueClass = pComVariant->GetObjRef(); - GCPROTECT_BEGIN(BoxedValueClass) - { - _ASSERTE(BoxedValueClass != NULL); - ConvertValueClassToVariant(&BoxedValueClass, pOleVariant); + SetObjectReference(pObj, BoxedValueClass); } GCPROTECT_END(); } - -void OleVariant::MarshalRecordVariantOleRefToCom(VARIANT *pOleVariant, - VariantData *pComVariant) -{ - WRAPPER_NO_CONTRACT; - - // The representation of a VT_RECORD and a VT_BYREF | VT_RECORD VARIANT are - // the same so we can simply forward the call to the non byref API. - MarshalRecordVariantOleToCom(pOleVariant, pComVariant); -} #endif // FEATURE_COMINTEROP void OleVariant::MarshalRecordArrayOleToCom(void *oleArray, BASEARRAYREF *pComArray, @@ -2778,6 +2114,11 @@ void OleVariant::MarshalOleVariantForObject(OBJECTREF * const & pObj, VARIANT *p V_I1(pOle) = *(CHAR*)( (*pObj)->GetData() ); V_VT(pOle) = VT_I1; } + else if (pMT == CoreLibBinder::GetElementType(ELEMENT_TYPE_I8)) + { + V_I8(pOle) = *(INT64*)( (*pObj)->GetData() ); + V_VT(pOle) = VT_I8; + } else if (pMT == CoreLibBinder::GetElementType(ELEMENT_TYPE_U4)) { V_UI4(pOle) = *(ULONG*)( (*pObj)->GetData() ); @@ -2793,6 +2134,11 @@ void OleVariant::MarshalOleVariantForObject(OBJECTREF * const & pObj, VARIANT *p V_UI1(pOle) = *(BYTE*)( (*pObj)->GetData() ); V_VT(pOle) = VT_UI1; } + else if (pMT == CoreLibBinder::GetElementType(ELEMENT_TYPE_U8)) + { + V_UI8(pOle) = *(UINT64*)( (*pObj)->GetData() ); + V_VT(pOle) = VT_UI8; + } else if (pMT == CoreLibBinder::GetElementType(ELEMENT_TYPE_R4)) { V_R4(pOle) = *(FLOAT*)( (*pObj)->GetData() ); @@ -2820,22 +2166,7 @@ void OleVariant::MarshalOleVariantForObject(OBJECTREF * const & pObj, VARIANT *p } else { - MethodDescCallSite convertObjectToVariant(METHOD__VARIANT__CONVERT_OBJECT_TO_VARIANT); - - VariantData managedVariant; - FillMemory(&managedVariant, sizeof(managedVariant), 0); - GCPROTECT_BEGIN_VARIANTDATA(managedVariant) - { - ARG_SLOT args[] = { - ObjToArgSlot(*pObj), - PtrToArgSlot(&managedVariant), - }; - - convertObjectToVariant.Call(args); - - OleVariant::MarshalOleVariantForComVariant(&managedVariant, pOle); - } - GCPROTECT_END_VARIANTDATA(); + OleVariant::MarshalOleVariantForObjectUncommon(pObj, pOle); } } } @@ -2872,49 +2203,19 @@ void OleVariant::MarshalOleRefVariantForObject(OBJECTREF *pObj, VARIANT *pOle) // MarshalOleRefVariantForObjectNoCast has checked that the variant is not an array // so we can use the marshal cast helper to coerce the object to the proper type. - VariantData vd; - FillMemory(&vd, sizeof(vd), 0); + VARIANT vtmp; + VariantInit(&vtmp); VARTYPE vt = V_VT(pOle) & ~VT_BYREF; - GCPROTECT_BEGIN_VARIANTDATA(vd); - { - ARG_SLOT args[3]; - args[0] = ObjToArgSlot(*pObj); - args[1] = (ARG_SLOT)vt; - args[2] = PtrToArgSlot(&vd); - castVariant.Call(args); - VARIANT vtmp; - VariantInit(&vtmp); - OleVariant::MarshalOleVariantForComVariant(&vd, &vtmp); - - // If the variant types are still not the same then call VariantChangeType to - // try and coerse them. - if (V_VT(&vtmp) != vt) - { - VARIANT vtmp2; - memset(&vtmp2, 0, sizeof(VARIANT)); - - // The type of the variant has changed so attempt to change - // the type back. - hr = SafeVariantChangeType(&vtmp2, &vtmp, 0, vt); - if (FAILED(hr)) - { - if (hr == DISP_E_TYPEMISMATCH) - COMPlusThrow(kInvalidCastException, IDS_EE_CANNOT_COERCE_BYREF_VARIANT); - else - COMPlusThrowHR(hr); - } + ARG_SLOT args[3]; + args[0] = ObjToArgSlot(*pObj); + args[1] = (ARG_SLOT)vt; + args[2] = PtrToArgSlot(&vtmp); + castVariant.Call(args); - // Copy the converted variant back into the original variant and clear the temp. - InsertContentsIntoByrefVariant(&vtmp2, pOle); - SafeVariantClear(&vtmp); - } - else - { - InsertContentsIntoByrefVariant(&vtmp, pOle); - } - } - GCPROTECT_END_VARIANTDATA(); + // Managed implementation of CastVariant should either return correct type or throw. + _ASSERTE(V_VT(&vtmp) == vt); + InsertContentsIntoByRefVariant(&vtmp, pOle); } } } @@ -2959,6 +2260,13 @@ HRESULT OleVariant::MarshalCommonOleRefVariantForObject(OBJECTREF *pObj, VARIANT *(V_I1REF(pOle)) = *(CHAR*)( (*pObj)->GetData() ); } + else if ( (V_VT(pOle) == (VT_BYREF | VT_I8) || V_VT(pOle) == (VT_BYREF | VT_UI8)) && (pMT == CoreLibBinder::GetElementType(ELEMENT_TYPE_I8) || pMT == CoreLibBinder::GetElementType(ELEMENT_TYPE_U8)) ) + { + // deallocation of old value optimized away since there's nothing to + // deallocate for this vartype. + + *(V_I8REF(pOle)) = *(INT64*)( (*pObj)->GetData() ); + } else if ( V_VT(pOle) == (VT_BYREF | VT_R4) && pMT == CoreLibBinder::GetElementType(ELEMENT_TYPE_R4) ) { // deallocation of old value optimized away since there's nothing to @@ -3018,7 +2326,7 @@ HRESULT OleVariant::MarshalCommonOleRefVariantForObject(OBJECTREF *pObj, VARIANT // Since variants can contain any VARTYPE we simply convert the object to // a variant and stuff it back into the byref variant. MarshalOleVariantForObject(pObj, &vtmp); - InsertContentsIntoByrefVariant(&vtmp, pOle); + InsertContentsIntoByRefVariant(&vtmp, pOle); } else if (vt & VT_ARRAY) { @@ -3031,7 +2339,7 @@ HRESULT OleVariant::MarshalCommonOleRefVariantForObject(OBJECTREF *pObj, VARIANT hr = DISP_E_TYPEMISMATCH; goto Exit; } - InsertContentsIntoByrefVariant(&vtmp, pOle); + InsertContentsIntoByRefVariant(&vtmp, pOle); } else if ( (*pObj) == NULL && (vt == VT_BSTR || @@ -3047,7 +2355,7 @@ HRESULT OleVariant::MarshalCommonOleRefVariantForObject(OBJECTREF *pObj, VARIANT // conversion will return a VT_EMPTY which isn't what we want. V_VT(&vtmp) = vt; V_UNKNOWN(&vtmp) = NULL; - InsertContentsIntoByrefVariant(&vtmp, pOle); + InsertContentsIntoByRefVariant(&vtmp, pOle); } else { @@ -3160,6 +2468,30 @@ void OleVariant::MarshalObjectForOleVariant(const VARIANT * pOle, OBJECTREF * co AllocateObject(CoreLibBinder::GetElementType(ELEMENT_TYPE_U1)) ); *(BYTE*)((*pObj)->GetData()) = *(V_UI1REF(pOle)); break; + + case VT_I8: + SetObjectReference( pObj, + AllocateObject(CoreLibBinder::GetElementType(ELEMENT_TYPE_I8)) ); + *(INT64*)((*pObj)->GetData()) = V_I8(pOle); + break; + + case VT_BYREF|VT_I8: + SetObjectReference( pObj, + AllocateObject(CoreLibBinder::GetElementType(ELEMENT_TYPE_I8)) ); + *(INT64*)((*pObj)->GetData()) = *(V_I8REF(pOle)); + break; + + case VT_UI8: + SetObjectReference( pObj, + AllocateObject(CoreLibBinder::GetElementType(ELEMENT_TYPE_U8)) ); + *(UINT64*)((*pObj)->GetData()) = V_UI8(pOle); + break; + + case VT_BYREF|VT_UI8: + SetObjectReference( pObj, + AllocateObject(CoreLibBinder::GetElementType(ELEMENT_TYPE_U8)) ); + *(UINT64*)((*pObj)->GetData()) = *(V_UI8REF(pOle)); + break; case VT_R4: SetObjectReference( pObj, @@ -3206,20 +2538,7 @@ void OleVariant::MarshalObjectForOleVariant(const VARIANT * pOle, OBJECTREF * co break; default: - { - MethodDescCallSite convertVariantToObject(METHOD__VARIANT__CONVERT_VARIANT_TO_OBJECT); - - VariantData managedVariant; - FillMemory(&managedVariant, sizeof(managedVariant), 0); - GCPROTECT_BEGIN_VARIANTDATA(managedVariant) - { - OleVariant::MarshalComVariantForOleVariant((VARIANT*)pOle, &managedVariant); - ARG_SLOT args[] = { PtrToArgSlot(&managedVariant) }; - SetObjectReference( pObj, - convertVariantToObject.Call_RetOBJECTREF(args) ); - } - GCPROTECT_END_VARIANTDATA(); - } + MarshalObjectForOleVariantUncommon(pOle, pObj); } RETURN; } @@ -3303,7 +2622,7 @@ void OleVariant::ExtractContentsFromByrefVariant(VARIANT *pByrefVar, VARIANT *pD RETURN; } -void OleVariant::InsertContentsIntoByrefVariant(VARIANT *pSrcVar, VARIANT *pByrefVar) +void OleVariant::InsertContentsIntoByRefVariant(VARIANT *pSrcVar, VARIANT *pByrefVar) { CONTRACT_VOID { @@ -3434,7 +2753,7 @@ void OleVariant::CreateByrefVariantForVariant(VARIANT *pSrcVar, VARIANT *pByrefV // the COM variant. // -void OleVariant::MarshalComVariantForOleVariant(VARIANT *pOle, VariantData *pCom) +void OleVariant::MarshalObjectForOleVariantUncommon(const VARIANT *pOle, OBJECTREF * const & pObj) { CONTRACTL { @@ -3442,7 +2761,8 @@ void OleVariant::MarshalComVariantForOleVariant(VARIANT *pOle, VariantData *pCom GC_TRIGGERS; MODE_COOPERATIVE; PRECONDITION(CheckPointer(pOle)); - PRECONDITION(CheckPointer(pCom)); + PRECONDITION(CheckPointer(pObj)); + PRECONDITION(*pObj == NULL || (IsProtectedByGCFrame (pObj))); } CONTRACTL_END; @@ -3467,54 +2787,24 @@ void OleVariant::MarshalComVariantForOleVariant(VARIANT *pOle, VariantData *pCom COMPlusThrow(kInvalidOleVariantTypeException, IDS_EE_INVALID_OLE_VARIANT); } - CVTypes cvt = GetCVTypeForVarType(vt); - const Marshaler *marshal = GetMarshalerForVarType(vt, TRUE); - - pCom->SetType(cvt); - pCom->SetVT(vt); // store away VT for return trip. - if (marshal == NULL || (byref - ? marshal->OleRefToComVariant == NULL - : marshal->OleToComVariant == NULL)) + if ((vt & VT_ARRAY)) { - if (cvt==CV_EMPTY) - { - if (V_ISBYREF(pOle)) - { - // Must set ObjectRef field of Variant to a specific instance. -#ifdef HOST_64BIT - VariantData::NewVariant(pCom, CV_U8, (INT64)(size_t)V_BYREF(pOle)); -#else // HOST_64BIT - VariantData::NewVariant(pCom, CV_U4, (INT32)(size_t)V_BYREF(pOle)); -#endif // HOST_64BIT - } - else - { - VariantData::NewVariant(pCom, cvt, NULL); - } - } - else if (cvt==CV_NULL) - { - VariantData::NewVariant(pCom, cvt, NULL); - } + if (byref) + MarshalArrayVariantOleRefToObject(pOle, pObj); else - { - pCom->SetObjRef(NULL); - if (byref) - { - INT64 data = 0; - CopyMemory(&data, V_R8REF(pOle), GetElementSizeForVarType(vt, NULL)); - pCom->SetData(&data); - } - else - pCom->SetData(&V_R8(pOle)); - } + MarshalArrayVariantOleToObject(pOle, pObj); + } + else if (vt == VT_RECORD) + { + // The representation of a VT_RECORD and a VT_BYREF | VT_RECORD VARIANT are the same + MarshalRecordVariantOleToObject(pOle, pObj); } else { - if (byref) - marshal->OleRefToComVariant(pOle, pCom); - else - marshal->OleToComVariant(pOle, pCom); + MethodDescCallSite convertVariantToObject(METHOD__VARIANT__CONVERT_VARIANT_TO_OBJECT); + ARG_SLOT args[] = { PtrToArgSlot(pOle) }; + SetObjectReference( pObj, + convertVariantToObject.Call_RetOBJECTREF(args) ); } } @@ -3523,14 +2813,15 @@ void OleVariant::MarshalComVariantForOleVariant(VARIANT *pOle, VariantData *pCom // the COM variant. // -void OleVariant::MarshalOleVariantForComVariant(VariantData *pCom, VARIANT *pOle) +void OleVariant::MarshalOleVariantForObjectUncommon(OBJECTREF * const & pObj, VARIANT *pOle) { CONTRACTL { THROWS; GC_TRIGGERS; MODE_COOPERATIVE; - PRECONDITION(CheckPointer(pCom)); + PRECONDITION(CheckPointer(pObj)); + PRECONDITION(*pObj == NULL || (IsProtectedByGCFrame (pObj))); PRECONDITION(CheckPointer(pOle)); } CONTRACTL_END; @@ -3540,18 +2831,26 @@ void OleVariant::MarshalOleVariantForComVariant(VariantData *pCom, VARIANT *pOle VariantEmptyHolder veh; veh = pOle; - VARTYPE vt = GetVarTypeForComVariant(pCom); - V_VT(pOle) = vt; - - const Marshaler *marshal = GetMarshalerForVarType(vt, TRUE); - - if (marshal == NULL || marshal->ComToOleVariant == NULL) + if ((*pObj)->GetMethodTable()->IsArray()) { - *(INT64*)&V_R8(pOle) = *(INT64*)pCom->GetData(); + // Get VarType for array + VARTYPE vt = GetElementVarTypeForArrayRef((BASEARRAYREF)*pObj); + if (vt == VT_ARRAY) + vt = VT_VARIANT; + + V_VT(pOle) = vt | VT_ARRAY; + MarshalArrayVariantObjectToOle(pObj, pOle); } else { - marshal->ComToOleVariant(pCom, pOle); + MethodDescCallSite convertObjectToVariant(METHOD__VARIANT__CONVERT_OBJECT_TO_VARIANT); + + ARG_SLOT args[] = { + ObjToArgSlot(*pObj), + PtrToArgSlot(pOle), + }; + + convertObjectToVariant.Call(args); } veh.SuppressRelease(); @@ -3752,79 +3051,6 @@ void OleVariant::MarshalIDispatchArrayComToOle(BASEARRAYREF *pComArray, void *ol * Currency marshaling routines * ------------------------------------------------------------------------- */ -void OleVariant::MarshalCurrencyVariantOleToCom(VARIANT *pOleVariant, - VariantData *pComVariant) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; - INJECT_FAULT(COMPlusThrowOM()); - PRECONDITION(CheckPointer(pOleVariant)); - PRECONDITION(CheckPointer(pComVariant)); - } - CONTRACTL_END; - - OBJECTREF pDecimalRef = AllocateObject(CoreLibBinder::GetClass(CLASS__DECIMAL)); - DECIMAL DecVal; - - // Convert the currency to a decimal. - VarDecFromCyCanonicalize(V_CY(pOleVariant), &DecVal); - - // Store the value into the unboxes decimal and store the decimal in the variant. - *(DECIMAL *) pDecimalRef->UnBox() = DecVal; - pComVariant->SetObjRef(pDecimalRef); -} - -void OleVariant::MarshalCurrencyVariantComToOle(VariantData *pComVariant, - VARIANT *pOleVariant) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; - PRECONDITION(CheckPointer(pOleVariant)); - PRECONDITION(CheckPointer(pComVariant)); - } - CONTRACTL_END; - - CURRENCY CyVal; - - // Convert the decimal to a currency. - HRESULT hr = VarCyFromDec((DECIMAL*)pComVariant->GetObjRef()->UnBox(), &CyVal); - IfFailThrow(hr); - - // Store the currency in the VARIANT and set the VT. - V_CY(pOleVariant) = CyVal; -} - -void OleVariant::MarshalCurrencyVariantOleRefToCom(VARIANT *pOleVariant, - VariantData *pComVariant) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; - INJECT_FAULT(COMPlusThrowOM()); - PRECONDITION(CheckPointer(pOleVariant)); - PRECONDITION(CheckPointer(pComVariant)); - } - CONTRACTL_END; - - OBJECTREF pDecimalRef = AllocateObject(CoreLibBinder::GetClass(CLASS__DECIMAL)); - DECIMAL DecVal; - - // Convert the currency to a decimal. - VarDecFromCyCanonicalize(*V_CYREF(pOleVariant), &DecVal); - - // Store the value into the unboxes decimal and store the decimal in the variant. - *(DECIMAL *) pDecimalRef->UnBox() = DecVal; - pComVariant->SetObjRef(pDecimalRef); -} - void OleVariant::MarshalCurrencyArrayOleToCom(void *oleArray, BASEARRAYREF *pComArray, MethodTable *pInterfaceMT, PCODE pManagedMarshalerCode) { @@ -4040,8 +3266,8 @@ void OleVariant::ClearVariantArray(void *oleArray, SIZE_T cElements, MethodTable * ------------------------------------------------------------------------- */ #ifdef FEATURE_COMINTEROP -void OleVariant::MarshalArrayVariantOleToCom(VARIANT *pOleVariant, - VariantData *pComVariant) +void OleVariant::MarshalArrayVariantOleToObject(const VARIANT* pOleVariant, + OBJECTREF * const & pObj) { CONTRACTL { @@ -4049,7 +3275,8 @@ void OleVariant::MarshalArrayVariantOleToCom(VARIANT *pOleVariant, GC_TRIGGERS; MODE_COOPERATIVE; PRECONDITION(CheckPointer(pOleVariant)); - PRECONDITION(CheckPointer(pComVariant)); + PRECONDITION(CheckPointer(pObj)); + PRECONDITION(*pObj == NULL || (IsProtectedByGCFrame (pObj))); } CONTRACTL_END; @@ -4075,17 +3302,17 @@ void OleVariant::MarshalArrayVariantOleToCom(VARIANT *pOleVariant, } BASEARRAYREF pArrayRef = CreateArrayRefForSafeArray(pSafeArray, vt, pElemMT); - pComVariant->SetObjRef((OBJECTREF) pArrayRef); - MarshalArrayRefForSafeArray(pSafeArray, (BASEARRAYREF *) pComVariant->GetObjRefPtr(), vt, pStructMarshalStub != nullptr ? pStructMarshalStub->GetMultiCallableAddrOfCode() : NULL, pElemMT); + SetObjectReference(pObj, pArrayRef); + MarshalArrayRefForSafeArray(pSafeArray, (BASEARRAYREF *) pObj, vt, pStructMarshalStub != nullptr ? pStructMarshalStub->GetMultiCallableAddrOfCode() : NULL, pElemMT); } else { - pComVariant->SetObjRef(NULL); + SetObjectReference(pObj, NULL); } } -void OleVariant::MarshalArrayVariantComToOle(VariantData *pComVariant, - VARIANT *pOleVariant) +void OleVariant::MarshalArrayVariantObjectToOle(OBJECTREF * const & pObj, + VARIANT* pOleVariant) { CONTRACTL { @@ -4093,12 +3320,13 @@ void OleVariant::MarshalArrayVariantComToOle(VariantData *pComVariant, GC_TRIGGERS; MODE_COOPERATIVE; PRECONDITION(CheckPointer(pOleVariant)); - PRECONDITION(CheckPointer(pComVariant)); + PRECONDITION(CheckPointer(pObj)); + PRECONDITION(*pObj == NULL || (IsProtectedByGCFrame (pObj))); } CONTRACTL_END; SafeArrayPtrHolder pSafeArray = NULL; - BASEARRAYREF *pArrayRef = (BASEARRAYREF *) pComVariant->GetObjRefPtr(); + BASEARRAYREF *pArrayRef = (BASEARRAYREF *) pObj; MethodTable *pElemMT = NULL; _ASSERTE(pArrayRef); @@ -4128,8 +3356,8 @@ void OleVariant::MarshalArrayVariantComToOle(VariantData *pComVariant, pSafeArray.SuppressRelease(); } -void OleVariant::MarshalArrayVariantOleRefToCom(VARIANT *pOleVariant, - VariantData *pComVariant) +void OleVariant::MarshalArrayVariantOleRefToObject(const VARIANT *pOleVariant, + OBJECTREF * const & pObj) { CONTRACTL { @@ -4137,7 +3365,8 @@ void OleVariant::MarshalArrayVariantOleRefToCom(VARIANT *pOleVariant, GC_TRIGGERS; MODE_COOPERATIVE; PRECONDITION(CheckPointer(pOleVariant)); - PRECONDITION(CheckPointer(pComVariant)); + PRECONDITION(CheckPointer(pObj)); + PRECONDITION(*pObj == NULL || (IsProtectedByGCFrame (pObj))); } CONTRACTL_END; @@ -4160,93 +3389,17 @@ void OleVariant::MarshalArrayVariantOleRefToCom(VARIANT *pOleVariant, } BASEARRAYREF pArrayRef = CreateArrayRefForSafeArray(pSafeArray, vt, pElemMT); - pComVariant->SetObjRef((OBJECTREF) pArrayRef); - MarshalArrayRefForSafeArray(pSafeArray, (BASEARRAYREF *) pComVariant->GetObjRefPtr(), vt, pStructMarshalStub != nullptr ? pStructMarshalStub->GetMultiCallableAddrOfCode() : NULL, pElemMT); + SetObjectReference(pObj, pArrayRef); + MarshalArrayRefForSafeArray(pSafeArray, (BASEARRAYREF *) pObj, vt, pStructMarshalStub != nullptr ? pStructMarshalStub->GetMultiCallableAddrOfCode() : NULL, pElemMT); } else { - pComVariant->SetObjRef(NULL); + SetObjectReference(pObj, NULL); } } #endif //FEATURE_COMINTEROP -/* ------------------------------------------------------------------------- * - * Error marshaling routines - * ------------------------------------------------------------------------- */ - -void OleVariant::MarshalErrorVariantOleToCom(VARIANT *pOleVariant, - VariantData *pComVariant) -{ - CONTRACTL - { - NOTHROW; - GC_NOTRIGGER; - MODE_ANY; - PRECONDITION(CheckPointer(pOleVariant)); - PRECONDITION(CheckPointer(pComVariant)); - } - CONTRACTL_END; - - // Check to see if the variant represents a missing argument. - if (V_ERROR(pOleVariant) == DISP_E_PARAMNOTFOUND) - { - pComVariant->SetType(CV_MISSING); - } - else - { - pComVariant->SetDataAsInt32(V_ERROR(pOleVariant)); - } -} - -void OleVariant::MarshalErrorVariantOleRefToCom(VARIANT *pOleVariant, - VariantData *pComVariant) -{ - CONTRACTL - { - NOTHROW; - GC_NOTRIGGER; - MODE_ANY; - PRECONDITION(CheckPointer(pOleVariant)); - PRECONDITION(CheckPointer(pComVariant)); - } - CONTRACTL_END; - - // Check to see if the variant represents a missing argument. - if (*V_ERRORREF(pOleVariant) == DISP_E_PARAMNOTFOUND) - { - pComVariant->SetType(CV_MISSING); - } - else - { - pComVariant->SetDataAsInt32(*V_ERRORREF(pOleVariant)); - } -} - -void OleVariant::MarshalErrorVariantComToOle(VariantData *pComVariant, - VARIANT *pOleVariant) -{ - CONTRACTL - { - NOTHROW; - GC_NOTRIGGER; - MODE_ANY; - PRECONDITION(CheckPointer(pOleVariant)); - PRECONDITION(CheckPointer(pComVariant)); - } - CONTRACTL_END; - - if (pComVariant->GetType() == CV_MISSING) - { - V_ERROR(pOleVariant) = DISP_E_PARAMNOTFOUND; - } - else - { - V_ERROR(pOleVariant) = pComVariant->GetDataAsInt32(); - } -} - - /* ------------------------------------------------------------------------- * * Safearray allocation & conversion * ------------------------------------------------------------------------- */ @@ -4681,6 +3834,7 @@ void OleVariant::ConvertValueClassToVariant(OBJECTREF *pBoxedValueClass, VARIANT MODE_COOPERATIVE; PRECONDITION(CheckPointer(pBoxedValueClass)); PRECONDITION(CheckPointer(pOleVariant)); + PRECONDITION(*pBoxedValueClass == NULL || (IsProtectedByGCFrame (pBoxedValueClass))); } CONTRACTL_END; diff --git a/src/coreclr/vm/olevariant.h b/src/coreclr/vm/olevariant.h index 1220e7b92be..7d62924db8e 100644 --- a/src/coreclr/vm/olevariant.h +++ b/src/coreclr/vm/olevariant.h @@ -24,324 +24,6 @@ #define VTHACK_WINBOOL 254 -//These types must be kept in sync with the CorElementTypes defined in cor.h -//NOTE: If you add values to this enum you need to look at OAVariant.cpp. There is -// a mapping between CV type and VT types found there. -//NOTE: This is also found in a table in OleVariant.cpp. -//NOTE: These are also found in Variant.cs -typedef enum -{ - CV_EMPTY = 0x0, // CV_EMPTY - CV_VOID = ELEMENT_TYPE_VOID, - CV_BOOLEAN = ELEMENT_TYPE_BOOLEAN, - CV_CHAR = ELEMENT_TYPE_CHAR, - CV_I1 = ELEMENT_TYPE_I1, - CV_U1 = ELEMENT_TYPE_U1, - CV_I2 = ELEMENT_TYPE_I2, - CV_U2 = ELEMENT_TYPE_U2, - CV_I4 = ELEMENT_TYPE_I4, - CV_U4 = ELEMENT_TYPE_U4, - CV_I8 = ELEMENT_TYPE_I8, - CV_U8 = ELEMENT_TYPE_U8, - CV_R4 = ELEMENT_TYPE_R4, - CV_R8 = ELEMENT_TYPE_R8, - CV_STRING = ELEMENT_TYPE_STRING, - - // For the rest, we map directly if it is defined in CorHdr.h and fill - // in holes for the rest. - CV_PTR = ELEMENT_TYPE_PTR, - CV_DATETIME = 0x10, // ELEMENT_TYPE_BYREF - CV_TIMESPAN = 0x11, // ELEMENT_TYPE_VALUETYPE - CV_OBJECT = ELEMENT_TYPE_CLASS, - CV_DECIMAL = 0x13, // ELEMENT_TYPE_UNUSED1 - CV_CURRENCY = 0x14, // ELEMENT_TYPE_ARRAY - CV_ENUM = 0x15, // - CV_MISSING = 0x16, // - CV_NULL = 0x17, // - CV_LAST = 0x18, // -} CVTypes; - -//Mapping from CVType to type handle. Used for conversion between the two internally. -extern const BinderClassID CVTypeToBinderClassID[]; - -inline TypeHandle GetTypeHandleForCVType(CVTypes elemType) -{ - CONTRACT (TypeHandle) - { - WRAPPER(THROWS); - WRAPPER(GC_TRIGGERS); - MODE_ANY; - PRECONDITION(elemType < CV_LAST); - } - CONTRACT_END; - - RETURN TypeHandle(CoreLibBinder::GetClass(CVTypeToBinderClassID[elemType])); -} - -// Use this very carefully. There is not a direct mapping between -// CorElementType and CVTypes for a bunch of things. In this case -// we return CV_LAST. You need to check this at the call site. -extern CVTypes CorElementTypeToCVTypes(CorElementType type); - - -#ifdef FEATURE_COMINTEROP - -#include - - -/*** Variant Design Restrictions (ie, decisions we've had to re-do differently): - 1) A Variant containing all zeros should be a valid Variant of type empty. - 2) Variant must contain an OBJECTREF field for Objects, etc. Since we - have no way of expressing a union between an OBJECTREF and an int, we - always box Decimals in a Variant. - 3) The m_flags field is not a CVType and will contain extra bits. People - should use VariantData::GetType() to get the CVType. - 4) You should use SetObjRef and GetObjRef to manipulate the OBJECTREF field. - These will handle write barriers correctly, as well as CV_EMPTY. - - - Empty, Missing & Null: - Variants of type CV_EMPTY will be all zero's. This forces us to add in - special cases for all functions that convert a Variant into an object (such - as copying a Variant into an Object[]). - - Variants of type Missing and Null will have their objectref field set to - Missing.Value and Null.Value respectively. This simplifies the code in - Variant.cs and strewn throughout the EE. -*/ - -#define VARIANT_TYPE_MASK 0xFFFF -#define VT_MASK 0xFF000000 -#define VT_BITSHIFT 24 - -struct VariantData -{ - friend class CoreLibBinder; - -public: - static void NewVariant(VariantData * const& dest, const CVTypes type, INT64 data - DEBUG_ARG(BOOL bDestIsInterior = FALSE)); - - FORCEINLINE CVTypes GetType() const - { - LIMITED_METHOD_CONTRACT; - - return (CVTypes)(m_flags & VARIANT_TYPE_MASK); - } - - FORCEINLINE void SetType(INT32 in) - { - LIMITED_METHOD_CONTRACT; - m_flags = in; - } - - FORCEINLINE VARTYPE GetVT() const - { - LIMITED_METHOD_CONTRACT; - - VARTYPE vt = (m_flags & VT_MASK) >> VT_BITSHIFT; - if (vt & 0x80) - { - vt &= ~0x80; - vt |= VT_ARRAY; - } - return vt; - } - - FORCEINLINE void SetVT(VARTYPE vt) - { - CONTRACTL - { - NOTHROW; - GC_NOTRIGGER; - MODE_ANY; - PRECONDITION( !(vt & VT_BYREF) ); - PRECONDITION( (vt & ~VT_ARRAY) < 128 ); - } - CONTRACTL_END; - - if (vt & VT_ARRAY) - { - vt &= ~VT_ARRAY; - vt |= 0x80; - } - m_flags = (m_flags & ~((INT32)VT_MASK)) | (vt << VT_BITSHIFT); - } - - - FORCEINLINE OBJECTREF GetObjRef() const - { - WRAPPER_NO_CONTRACT; - - return (OBJECTREF)m_objref; - } - - OBJECTREF* GetObjRefPtr() - { - CONTRACT (OBJECTREF*) - { - NOTHROW; - GC_NOTRIGGER; - MODE_COOPERATIVE; - POSTCONDITION(CheckPointer(RETVAL, NULL_OK)); - } - CONTRACT_END; - - RETURN (OBJECTREF*)&m_objref; - } - - void SetObjRef(OBJECTREF objRef) - { - CONTRACTL - { - NOTHROW; - GC_NOTRIGGER; - MODE_COOPERATIVE; - } - CONTRACTL_END; - - if (objRef!=NULL) - { - SetObjectReference((OBJECTREF*)&m_objref, objRef); - } - else - { - // Casting trick to avoid going thru overloaded operator= (which - // in this case would trigger a false write barrier violation assert.) - *(LPVOID*)(OBJECTREF*)&m_objref=NULL; - } - } - - FORCEINLINE void* GetData() const - { - LIMITED_METHOD_CONTRACT; - return (void *)(&m_data); - } - - FORCEINLINE INT8 GetDataAsInt8() const - { - LIMITED_METHOD_CONTRACT; - return (INT8)m_data; - } - - FORCEINLINE UINT8 GetDataAsUInt8() const - { - LIMITED_METHOD_CONTRACT; - return (UINT8)m_data; - } - - FORCEINLINE INT16 GetDataAsInt16() const - { - LIMITED_METHOD_CONTRACT; - return (INT16)m_data; - } - - FORCEINLINE UINT16 GetDataAsUInt16() const - { - LIMITED_METHOD_CONTRACT; - return (UINT16)m_data; - } - - FORCEINLINE INT32 GetDataAsInt32() const - { - LIMITED_METHOD_CONTRACT; - return (INT32)m_data; - } - - FORCEINLINE UINT32 GetDataAsUInt32() const - { - LIMITED_METHOD_CONTRACT; - return (UINT32)m_data; - } - - FORCEINLINE INT64 GetDataAsInt64() const - { - LIMITED_METHOD_CONTRACT; - return (INT64)m_data; - } - - FORCEINLINE UINT64 GetDataAsUInt64() const - { - LIMITED_METHOD_CONTRACT; - return (UINT64)m_data; - } - - FORCEINLINE void SetData(void *in) - { - LIMITED_METHOD_CONTRACT; - - if (!in) - m_data=0; - else - m_data = *(INT64 *)in; - } - - // When possible, please use the most specific SetDataAsXxx function. - // This is necessary to guarantee we do sign extension correctly - // for all types smaller than 32 bits. R4's, R8's, U8's, DateTimes, - // Currencies, and TimeSpans can all be treated as ints of the appropriate - // size - sign extension is irrelevant in those cases. - FORCEINLINE void SetDataAsInt8(INT8 data) - { - LIMITED_METHOD_CONTRACT; - m_data=data; - } - - FORCEINLINE void SetDataAsUInt8(UINT8 data) - { - LIMITED_METHOD_CONTRACT; - m_data=data; - } - - FORCEINLINE void SetDataAsInt16(INT16 data) - { - LIMITED_METHOD_CONTRACT; - m_data=data; - } - - FORCEINLINE void SetDataAsUInt16(UINT16 data) - { - LIMITED_METHOD_CONTRACT; - m_data=data; - } - - FORCEINLINE void SetDataAsInt32(INT32 data) - { - LIMITED_METHOD_CONTRACT; - m_data=data; - } - - FORCEINLINE void SetDataAsUInt32(UINT32 data) - { - LIMITED_METHOD_CONTRACT; - m_data=data; - } - - FORCEINLINE void SetDataAsInt64(INT64 data) - { - LIMITED_METHOD_CONTRACT; - m_data=data; - } - -private: - // Typeloader reorders fields of non-blitable types. This reordering differs between 32-bit and 64-bit platforms. -#ifdef TARGET_64BIT - Object* m_objref; - INT64 m_data; - INT32 m_flags; - INT32 m_padding; -#else - INT64 m_data; - Object* m_objref; - INT32 m_flags; -#endif -}; - -#include - -#endif // FEATURE_COMINTEROP - - class OleVariant { public: @@ -361,8 +43,8 @@ class OleVariant static BSTR AllocateEmptyBSTRForString(STRINGREF *pStringObj); static void ConvertContentsStringToBSTR(STRINGREF *pStringObj, BSTR bstr); static BSTR ConvertStringToBSTR(STRINGREF *pStringObj); - static void MarshalComVariantForOleVariant(VARIANT *pOle, VariantData *pCom); - static void MarshalOleVariantForComVariant(VariantData *pCom, VARIANT *pOle); + static void MarshalObjectForOleVariantUncommon(const VARIANT *pOle, OBJECTREF * const & pObj); + static void MarshalOleVariantForObjectUncommon(OBJECTREF * const & pObj, VARIANT *pOle); #endif // FEATURE_COMINTEROP #ifdef FEATURE_COMINTEROP @@ -412,14 +94,11 @@ class OleVariant // Type conversion utilities static void ExtractContentsFromByrefVariant(VARIANT* pByrefVar, VARIANT* pDestVar); - static void InsertContentsIntoByrefVariant(VARIANT* pSrcVar, VARIANT* pByrefVar); + static void InsertContentsIntoByRefVariant(VARIANT* pSrcVar, VARIANT* pByrefVar); static void CreateByrefVariantForVariant(VARIANT* pSrcVar, VARIANT* pByrefVar); - - static VARTYPE GetVarTypeForComVariant(VariantData* pComVariant); #endif // FEATURE_COMINTEROP - static CVTypes GetCVTypeForVarType(VARTYPE vt); - static VARTYPE GetVarTypeForCVType(CVTypes); + static TypeHandle GetTypeHandleForVarType(VARTYPE vt); static VARTYPE GetVarTypeForTypeHandle(TypeHandle typeHnd); static VARTYPE GetVarTypeForValueClassArrayName(LPCUTF8 pArrayClassName); @@ -450,11 +129,6 @@ class OleVariant struct Marshaler { -#ifdef FEATURE_COMINTEROP - void (*OleToComVariant)(VARIANT* pOleVariant, VariantData* pComVariant); - void (*ComToOleVariant)(VariantData* pComVariant, VARIANT* pOleVariant); - void (*OleRefToComVariant)(VARIANT* pOleVariant, VariantData* pComVariant); -#endif // FEATURE_COMINTEROP void (*OleToComArray)(void* oleArray, BASEARRAYREF* pComArray, MethodTable* pInterfaceMT, PCODE pManagedMarshalerCode); void (*ComToOleArray)(BASEARRAYREF* pComArray, void* oleArray, MethodTable* pInterfaceMT, BOOL fBestFitMapping, BOOL fThrowOnUnmappableChar, @@ -488,9 +162,6 @@ class OleVariant MethodTable* pInterfaceMT, BOOL fBestFitMapping, BOOL fThrowOnUnmappableChar, BOOL fOleArrayValid, SIZE_T cElements, PCODE pManagedMarshalerCode); - static void MarshalCBoolVariantOleToCom(VARIANT* pOleVariant, VariantData* pComVariant); - static void MarshalCBoolVariantComToOle(VariantData* pComVariant, VARIANT* pOleVariant); - static void MarshalCBoolVariantOleRefToCom(VARIANT* pOleVariant, VariantData* pComVariant); static void MarshalCBoolArrayOleToCom(void* oleArray, BASEARRAYREF* pComArray, MethodTable* pInterfaceMT, PCODE pManagedMarshalerCode); static void MarshalCBoolArrayComToOle(BASEARRAYREF* pComArray, void* oleArray, @@ -574,40 +245,10 @@ class OleVariant SIZE_T cElements, PCODE pManagedMarshalerCode); static void ClearInterfaceArray(void* oleArray, SIZE_T cElements, MethodTable* pInterfaceMT, PCODE pManagedMarshalerCode); - static void MarshalBoolVariantOleToCom(VARIANT* pOleVariant, VariantData* pComVariant); - - static void MarshalWinBoolVariantOleToCom(VARIANT* pOleVariant, VariantData* pComVariant); - static void MarshalWinBoolVariantComToOle(VariantData* pComVariant, VARIANT* pOleVariant); - static void MarshalWinBoolVariantOleRefToCom(VARIANT* pOleVariant, VariantData* pComVariant); - - static void MarshalAnsiCharVariantOleToCom(VARIANT* pOleVariant, VariantData* pComVariant); - static void MarshalAnsiCharVariantComToOle(VariantData* pComVariant, VARIANT* pOleVariant); - static void MarshalAnsiCharVariantOleRefToCom(VARIANT* pOleVariant, VariantData* pComVariant); - - static void MarshalInterfaceVariantOleToCom(VARIANT* pOleVariant, VariantData* pComVariant); - static void MarshalInterfaceVariantComToOle(VariantData* pComVariant, VARIANT* pOleVariant); - static void MarshalInterfaceVariantOleRefToCom(VARIANT* pOleVariant, VariantData* pComVariant); - - static void MarshalBSTRVariantOleToCom(VARIANT* pOleVariant, VariantData* pComVariant); - static void MarshalBSTRVariantComToOle(VariantData* pComVariant, VARIANT* pOleVariant); - - static void MarshalDateVariantOleToCom(VARIANT* pOleVariant, VariantData* pComVariant); - static void MarshalDateVariantComToOle(VariantData* pComVariant, VARIANT* pOleVariant); - static void MarshalDateVariantOleRefToCom(VARIANT* pOleVariant, VariantData* pComVariant); - - static void MarshalDecimalVariantOleToCom(VARIANT* pOleVariant, VariantData* pComVariant); - static void MarshalDecimalVariantComToOle(VariantData* pComVariant, VARIANT* pOleVariant); - static void MarshalDecimalVariantOleRefToCom(VARIANT* pOleVariant, VariantData* pComVariant); - #ifdef FEATURE_COMINTEROP - static void MarshalRecordVariantOleToCom(VARIANT* pOleVariant, VariantData* pComVariant); - static void MarshalRecordVariantComToOle(VariantData* pComVariant, VARIANT* pOleVariant); - static void MarshalRecordVariantOleRefToCom(VARIANT* pOleVariant, VariantData* pComVariant); + static void MarshalRecordVariantOleToObject(const VARIANT* pOleVariant, OBJECTREF * const & pComVariant); #endif - static void MarshalCurrencyVariantOleToCom(VARIANT* pOleVariant, VariantData* pComVariant); - static void MarshalCurrencyVariantComToOle(VariantData* pComVariant, VARIANT* pOleVariant); - static void MarshalCurrencyVariantOleRefToCom(VARIANT* pOleVariant, VariantData* pComVariant); static void MarshalCurrencyArrayOleToCom(void* oleArray, BASEARRAYREF* pComArray, MethodTable* pInterfaceMT, PCODE pManagedMarshalerCode); static void MarshalCurrencyArrayComToOle(BASEARRAYREF* pComArray, void* oleArray, @@ -624,14 +265,10 @@ class OleVariant static void ClearVariantArray(void* oleArray, SIZE_T cElements, MethodTable* pInterfaceMT, PCODE pManagedMarshalerCode); #ifdef FEATURE_COMINTEROP - static void MarshalArrayVariantOleToCom(VARIANT* pOleVariant, VariantData* pComVariant); - static void MarshalArrayVariantComToOle(VariantData* pComVariant, VARIANT* pOleVariant); - static void MarshalArrayVariantOleRefToCom(VARIANT* pOleVariant, VariantData* pComVariant); + static void MarshalArrayVariantOleToObject(const VARIANT* pOleVariant, OBJECTREF * const & pObj); + static void MarshalArrayVariantOleRefToObject(const VARIANT* pOleVariant, OBJECTREF * const & pObj); + static void MarshalArrayVariantObjectToOle(OBJECTREF * const & pObj, VARIANT* pOleVariant); #endif - - static void MarshalErrorVariantOleToCom(VARIANT* pOleVariant, VariantData* pComVariant); - static void MarshalErrorVariantOleRefToCom(VARIANT* pOleVariant, VariantData* pComVariant); - static void MarshalErrorVariantComToOle(VariantData* pComVariant, VARIANT* pOleVariant); #endif // FEATURE_COMINTEROP }; diff --git a/src/coreclr/vm/peassembly.cpp b/src/coreclr/vm/peassembly.cpp index 3f54dbff556..7613cdfd180 100644 --- a/src/coreclr/vm/peassembly.cpp +++ b/src/coreclr/vm/peassembly.cpp @@ -497,7 +497,7 @@ PEAssembly* PEAssembly::LoadAssembly(mdAssemblyRef kAssemblyRef) AssemblySpec spec; - spec.InitializeSpec(kAssemblyRef, pImport, GetAppDomain()->FindAssembly(this)->GetAssembly()); + spec.InitializeSpec(kAssemblyRef, pImport, GetAppDomain()->FindAssembly(this)); RETURN GetAppDomain()->BindAssemblySpec(&spec, TRUE); } @@ -538,8 +538,8 @@ BOOL PEAssembly::GetResource(LPCSTR szName, DWORD *cbResource, else { AppDomain* pAppDomain = AppDomain::GetCurrentDomain(); - DomainAssembly* pParentAssembly = pAppDomain->FindAssembly(this); - pAssembly = pAppDomain->RaiseResourceResolveEvent(pParentAssembly->GetAssembly(), szName); + Assembly* pParentAssembly = pAppDomain->FindAssembly(this); + pAssembly = pAppDomain->RaiseResourceResolveEvent(pParentAssembly, szName); if (pAssembly == NULL) return FALSE; pPEAssembly = pAssembly->GetPEAssembly(); @@ -575,11 +575,11 @@ BOOL PEAssembly::GetResource(LPCSTR szName, DWORD *cbResource, AssemblySpec spec; spec.InitializeSpec(mdLinkRef, GetMDImport(), pAssembly); - DomainAssembly* pDomainAssembly = spec.LoadDomainAssembly(FILE_LOADED); + Assembly* pLoadedAssembly = spec.LoadAssembly(FILE_LOADED); if (dwLocation) { if (pAssemblyRef) - *pAssemblyRef = pDomainAssembly->GetAssembly(); + *pAssemblyRef = pLoadedAssembly; *dwLocation = *dwLocation | 2; // ResourceLocation.containedInAnotherAssembly } @@ -590,7 +590,7 @@ BOOL PEAssembly::GetResource(LPCSTR szName, DWORD *cbResource, pAssemblyRef, szFileName, dwLocation, - pDomainAssembly->GetAssembly()); + pLoadedAssembly); } case mdtFile: diff --git a/src/coreclr/vm/perfmap.cpp b/src/coreclr/vm/perfmap.cpp index 2d823e546fc..1f515b00922 100644 --- a/src/coreclr/vm/perfmap.cpp +++ b/src/coreclr/vm/perfmap.cpp @@ -108,11 +108,9 @@ void PerfMap::Enable(PerfMapType type, bool sendExisting) { AppDomain::AssemblyIterator assemblyIterator = GetAppDomain()->IterateAssembliesEx( (AssemblyIterationFlags)(kIncludeLoaded | kIncludeExecution)); - CollectibleAssemblyHolder pDomainAssembly; - while (assemblyIterator.Next(pDomainAssembly.This())) + CollectibleAssemblyHolder pAssembly; + while (assemblyIterator.Next(pAssembly.This())) { - CollectibleAssemblyHolder pAssembly = pDomainAssembly->GetAssembly(); - // PerfMap does not log R2R methods so only proceed if we are emitting jitdumps if (type == PerfMapType::ALL || type == PerfMapType::JITDUMP) { diff --git a/src/coreclr/vm/prestub.cpp b/src/coreclr/vm/prestub.cpp index de1f7fd0900..63189a4780e 100644 --- a/src/coreclr/vm/prestub.cpp +++ b/src/coreclr/vm/prestub.cpp @@ -1294,7 +1294,7 @@ namespace Instantiation targetMethodInst; if (targetType->HasInstantiation()) { - declClassInst = declaration->GetMethodTable()->GetInstantiation(); + declClassInst = declaration->GetMethodTable()->GetTypicalMethodTable()->GetInstantiation(); targetClassInst = targetType->GetTypicalMethodTable()->GetInstantiation(); } if (targetMethod->HasMethodInstantiation()) @@ -2662,7 +2662,7 @@ extern "C" PCODE STDCALL PreStubWorker(TransitionBlock* pTransitionBlock, Method { pDispatchingMT = curobj->GetMethodTable(); - if (pDispatchingMT->IsICastable() || pDispatchingMT->IsIDynamicInterfaceCastable()) + if (pDispatchingMT->IsIDynamicInterfaceCastable()) { MethodTable* pMDMT = pMD->GetMethodTable(); TypeHandle objectType(pDispatchingMT); @@ -2672,7 +2672,7 @@ extern "C" PCODE STDCALL PreStubWorker(TransitionBlock* pTransitionBlock, Method INDEBUG(curobj = NULL); // curobj is unprotected and CanCastTo() can trigger GC if (!objectType.CanCastTo(methodType)) { - // Apparently ICastable magic was involved when we chose this method to be called + // Apparently IDynamicInterfaceCastable magic was involved when we chose this method to be called // that's why we better stick to the MethodTable it belongs to, otherwise // DoPrestub() will fail not being able to find implementation for pMD in pDispatchingMT. @@ -3534,7 +3534,7 @@ static PCODE getHelperForStaticBase(Module * pModule, CORCOMPILE_FIXUP_BLOB_KIND bool threadStatic = (kind == ENCODE_THREAD_STATIC_BASE_NONGC_HELPER || kind == ENCODE_THREAD_STATIC_BASE_GC_HELPER); CorInfoHelpFunc helper; - + if (threadStatic) { if (GCStatic) diff --git a/src/coreclr/vm/profilingenumerators.cpp b/src/coreclr/vm/profilingenumerators.cpp index c55d40ffbee..f214be043f0 100644 --- a/src/coreclr/vm/profilingenumerators.cpp +++ b/src/coreclr/vm/profilingenumerators.cpp @@ -302,18 +302,14 @@ HRESULT IterateUnsharedModules(AppDomain * pAppDomain, // earlier during FILE_LOAD_LOADLIBRARY. This does not affect the timeline, as either // way the profiler receives the notification AFTER the assembly would appear in the // enumeration. - // - // Although it's called an "AssemblyIterator", it actually iterates over - // DomainAssembly instances. - AppDomain::AssemblyIterator domainAssemblyIterator = + AppDomain::AssemblyIterator assemblyIterator = pAppDomain->IterateAssembliesEx( (AssemblyIterationFlags) (kIncludeAvailableToProfilers | kIncludeExecution)); - CollectibleAssemblyHolder pDomainAssembly; + CollectibleAssemblyHolder pAssembly; - while (domainAssemblyIterator.Next(pDomainAssembly.This())) + while (assemblyIterator.Next(pAssembly.This())) { - _ASSERTE(pDomainAssembly != NULL); - _ASSERTE(pDomainAssembly->GetAssembly() != NULL); + _ASSERTE(pAssembly != NULL); // #ProfilerEnumModules (See also code:#ProfilerEnumGeneral) // @@ -327,7 +323,7 @@ HRESULT IterateUnsharedModules(AppDomain * pAppDomain, // code:#ProfilerEnumAssemblies for info on how the timing works. // Call user-supplied callback, and cancel iteration if requested - HRESULT hr = (callbackObj->*callbackMethod)(pDomainAssembly->GetModule()); + HRESULT hr = (callbackObj->*callbackMethod)(pAssembly->GetModule()); if (hr != S_OK) { return hr; @@ -491,8 +487,8 @@ HRESULT IterateAppDomainContainingModule::AddAppDomainContainingModule(AppDomain } CONTRACTL_END; - DomainAssembly * pDomainAssembly = m_pModule->GetDomainAssembly(); - if ((pDomainAssembly != NULL) && (pDomainAssembly->IsAvailableToProfilers())) + Assembly * pAssembly = m_pModule->GetAssembly(); + if ((pAssembly != NULL) && (pAssembly->IsAvailableToProfilers())) { if (m_index < m_cAppDomainIds) { diff --git a/src/coreclr/vm/proftoeeinterfaceimpl.cpp b/src/coreclr/vm/proftoeeinterfaceimpl.cpp index e99273beb5d..f84f30f4fde 100644 --- a/src/coreclr/vm/proftoeeinterfaceimpl.cpp +++ b/src/coreclr/vm/proftoeeinterfaceimpl.cpp @@ -2048,9 +2048,8 @@ HRESULT ProfToEEInterfaceImpl::GetFunctionFromIP2(LPCBYTE ip, FunctionID * pFunc // Yay! NOTHROW; - // Grabbing the rejitid requires entering the rejit manager's hash table & lock, - // which can switch us to preemptive mode and trigger GCs - GC_TRIGGERS; + // Yay! + GC_NOTRIGGER; // Yay! MODE_ANY; @@ -2068,7 +2067,7 @@ HRESULT ProfToEEInterfaceImpl::GetFunctionFromIP2(LPCBYTE ip, FunctionID * pFunc PERMANENT_CONTRACT_VIOLATION(TakesLockViolation, ReasonProfilerAsyncCannotRetakeLock); PROFILER_TO_CLR_ENTRYPOINT_SYNC_EX( - kP2EEAllowableAfterAttach | kP2EETriggers, + kP2EEAllowableAfterAttach, (LF_CORPROF, LL_INFO1000, "**PROF: GetFunctionFromIP2 0x%p.\n", @@ -2500,9 +2499,8 @@ HRESULT ProfToEEInterfaceImpl::GetCodeInfo3(FunctionID functionId, // Yay! NOTHROW; - // We need to access the rejitmanager, which means taking locks, which means we - // may trigger a GC - GC_TRIGGERS; + // Yay! + GC_NOTRIGGER; // Yay! MODE_ANY; @@ -2510,10 +2508,10 @@ HRESULT ProfToEEInterfaceImpl::GetCodeInfo3(FunctionID functionId, // Yay! EE_THREAD_NOT_REQUIRED; - // We need to access the rejitmanager, which means taking locks + // We need to take the ExecutionManager reader lock to find the + // appropriate jit manager. CAN_TAKE_LOCK; - PRECONDITION(CheckPointer(pcCodeInfos, NULL_OK)); PRECONDITION(CheckPointer(codeInfos, NULL_OK)); } @@ -2523,7 +2521,7 @@ HRESULT ProfToEEInterfaceImpl::GetCodeInfo3(FunctionID functionId, PERMANENT_CONTRACT_VIOLATION(TakesLockViolation, ReasonProfilerAsyncCannotRetakeLock); PROFILER_TO_CLR_ENTRYPOINT_SYNC_EX( - kP2EEAllowableAfterAttach | kP2EETriggers, + kP2EEAllowableAfterAttach, (LF_CORPROF, LL_INFO1000, "**PROF: GetCodeInfo3 0x%p 0x%p.\n", @@ -2541,8 +2539,6 @@ HRESULT ProfToEEInterfaceImpl::GetCodeInfo3(FunctionID functionId, PCODE pCodeStart = (PCODE)NULL; CodeVersionManager* pCodeVersionManager = pMethodDesc->GetCodeVersionManager(); { - CodeVersionManager::LockHolder codeVersioningLockHolder; - ILCodeVersion ilCodeVersion = pCodeVersionManager->GetILCodeVersion(pMethodDesc, reJitId); NativeCodeVersionCollection nativeCodeVersions = ilCodeVersion.GetNativeCodeVersions(pMethodDesc); @@ -3148,9 +3144,9 @@ HRESULT ProfToEEInterfaceImpl::GetAppDomainStaticAddress(ClassID classId, return E_INVALIDARG; } - // Some domains, like the system domain, aren't APP domains, and thus don't contain any + // The system domain isn't an APP domain and thus doesn't contain any // statics. See if the profiler is trying to be naughty. - if (!((BaseDomain*) appDomainId)->IsAppDomain()) + if (appDomainId == (AppDomainID)SystemDomain::System()) { return E_INVALIDARG; } @@ -3382,9 +3378,9 @@ HRESULT ProfToEEInterfaceImpl::GetThreadStaticAddress2(ClassID classId, return E_INVALIDARG; } - // Some domains, like the system domain, aren't APP domains, and thus don't contain any + // The system domain isn't an APP domain and thus doesn't contain any // statics. See if the profiler is trying to be naughty. - if (!((BaseDomain*) appDomainId)->IsAppDomain()) + if (appDomainId == (AppDomainID)SystemDomain::System()) { return E_INVALIDARG; } @@ -4928,8 +4924,6 @@ HRESULT ProfToEEInterfaceImpl::GetILToNativeMapping2(FunctionID functionId, CodeVersionManager *pCodeVersionManager = pMD->GetCodeVersionManager(); ILCodeVersion ilCodeVersion = NULL; { - CodeVersionManager::LockHolder codeVersioningLockHolder; - pCodeVersionManager->GetILCodeVersion(pMD, reJitId); NativeCodeVersionCollection nativeCodeVersions = ilCodeVersion.GetNativeCodeVersions(pMD); @@ -5455,20 +5449,20 @@ HRESULT ProfToEEInterfaceImpl::GetAppDomainInfo(AppDomainID appDomainId, // Yay! NOTHROW; - // AppDomain::GetFriendlyNameForDebugger triggers - GC_TRIGGERS; + // Yay! + GC_NOTRIGGER; // Yay! MODE_ANY; - // AppDomain::GetFriendlyNameForDebugger takes a lock - CAN_TAKE_LOCK; + // Yay! + CANNOT_TAKE_LOCK; } CONTRACTL_END; PROFILER_TO_CLR_ENTRYPOINT_SYNC_EX( - kP2EEAllowableAfterAttach | kP2EETriggers, + kP2EEAllowableAfterAttach, (LF_CORPROF, LL_INFO1000, "**PROF: GetAppDomainInfo 0x%p.\n", @@ -5479,25 +5473,8 @@ HRESULT ProfToEEInterfaceImpl::GetAppDomainInfo(AppDomainID appDomainId, return E_INVALIDARG; } - BaseDomain *pDomain; // Internal data structure. HRESULT hr = S_OK; - // @todo: - // Right now, this ID is not a true AppDomain, since we use the old - // AppDomain/SystemDomain model in the profiling API. This means that - // the profiler exposes the SharedDomain and the SystemDomain to the - // outside world. It's not clear whether this is actually the right thing - // to do or not. - seantrow - // - // Postponed to V2. - // - - pDomain = (BaseDomain *) appDomainId; - - // Make sure they've passed in a valid appDomainId - if (pDomain == NULL) - return (E_INVALIDARG); - // Pick sensible defaults. if (pcchName) *pcchName = 0; @@ -5507,10 +5484,10 @@ HRESULT ProfToEEInterfaceImpl::GetAppDomainInfo(AppDomainID appDomainId, *pProcessId = 0; LPCWSTR szFriendlyName; - if (pDomain == SystemDomain::System()) + if (appDomainId == (AppDomainID)SystemDomain::System()) szFriendlyName = g_pwBaseLibrary; else - szFriendlyName = ((AppDomain*)pDomain)->GetFriendlyNameForDebugger(); + szFriendlyName = ((AppDomain*)appDomainId)->GetFriendlyName(); if (szFriendlyName != NULL) { @@ -6236,13 +6213,11 @@ HRESULT ProfToEEInterfaceImpl::GetFunctionFromIP3(LPCBYTE ip, FunctionID * pFunc { NOTHROW; - // Grabbing the rejitid requires entering the rejit manager's hash table & lock, - // which can switch us to preemptive mode and trigger GCs - GC_TRIGGERS; + GC_NOTRIGGER; MODE_ANY; EE_THREAD_NOT_REQUIRED; - // Grabbing the rejitid requires entering the rejit manager's hash table & lock, + // Calling GetFunctionFromIPInternal may take a reader lock CAN_TAKE_LOCK; } @@ -6252,7 +6227,7 @@ HRESULT ProfToEEInterfaceImpl::GetFunctionFromIP3(LPCBYTE ip, FunctionID * pFunc PERMANENT_CONTRACT_VIOLATION(TakesLockViolation, ReasonProfilerAsyncCannotRetakeLock); PROFILER_TO_CLR_ENTRYPOINT_SYNC_EX( - kP2EEAllowableAfterAttach | kP2EETriggers, + kP2EEAllowableAfterAttach, (LF_CORPROF, LL_INFO1000, "**PROF: GetFunctionFromIP3 0x%p.\n", @@ -6613,7 +6588,7 @@ HRESULT ProfToEEInterfaceImpl::GetCodeInfo4(UINT_PTR pNativeCodeStartAddress, CONTRACTL { NOTHROW; - GC_TRIGGERS; + GC_NOTRIGGER; MODE_ANY; EE_THREAD_NOT_REQUIRED; CAN_TAKE_LOCK; @@ -6625,7 +6600,7 @@ HRESULT ProfToEEInterfaceImpl::GetCodeInfo4(UINT_PTR pNativeCodeStartAddress, CONTRACTL_END; PROFILER_TO_CLR_ENTRYPOINT_SYNC_EX( - kP2EEAllowableAfterAttach | kP2EETriggers, + kP2EEAllowableAfterAttach, (LF_CORPROF, LL_INFO1000, "**PROF: GetCodeInfo4 0x%p.\n", @@ -10771,6 +10746,7 @@ GCX_COOP_THREAD_EXISTS(GET_THREAD()); HCIMPL_PROLOG(ProfileEnter) { FCALL_CONTRACT; + FC_GC_POLL_NOT_NEEDED(); // we pulse GC mode, so we are doing a poll if (GetThreadNULLOk() == NULL) { @@ -10810,13 +10786,10 @@ HCIMPL_PROLOG(ProfileEnter) _ASSERTE(GetThread()->PreemptiveGCDisabled()); _ASSERTE(platformSpecificHandle != NULL); - // Set up a frame - HELPER_METHOD_FRAME_BEGIN_ATTRIB_NOPOLL(Frame::FRAME_ATTR_CAPTURE_DEPTH_2); - - // Our contract is FCALL_CONTRACT, which is considered triggers if you set up a - // frame, like we're about to do. + // This callback is called from the prolog of a method, without a valid ability to suspend the runtime/take a GC. + // This means that we cannot trigger a GC. SetCallbackStateFlagsHolder csf( - COR_PRF_CALLBACKSTATE_INCALLBACK | COR_PRF_CALLBACKSTATE_IN_TRIGGERS_SCOPE); + COR_PRF_CALLBACKSTATE_INCALLBACK); COR_PRF_ELT_INFO_INTERNAL eltInfo; eltInfo.platformSpecificHandle = platformSpecificHandle; @@ -10943,8 +10916,6 @@ HCIMPL_PROLOG(ProfileEnter) LExit: ; - HELPER_METHOD_FRAME_END(); // Un-link the frame - #endif // PROFILING_SUPPORTED } HCIMPLEND @@ -10984,13 +10955,10 @@ HCIMPL_PROLOG(ProfileLeave) _ASSERTE(GetThread()->PreemptiveGCDisabled()); _ASSERTE(platformSpecificHandle != NULL); - // Set up a frame - HELPER_METHOD_FRAME_BEGIN_ATTRIB_NOPOLL(Frame::FRAME_ATTR_CAPTURE_DEPTH_2); - - // Our contract is FCALL_CONTRACT, which is considered triggers if you set up a - // frame, like we're about to do. + // This callback is called from the epilog of a method, without a valid ability to suspend the runtime/take a GC. + // This means that we cannot trigger a GC. SetCallbackStateFlagsHolder csf( - COR_PRF_CALLBACKSTATE_INCALLBACK | COR_PRF_CALLBACKSTATE_IN_TRIGGERS_SCOPE); + COR_PRF_CALLBACKSTATE_INCALLBACK); COR_PRF_ELT_INFO_INTERNAL eltInfo; eltInfo.platformSpecificHandle = platformSpecificHandle; @@ -11077,8 +11045,6 @@ HCIMPL_PROLOG(ProfileLeave) ; - HELPER_METHOD_FRAME_END(); // Un-link the frame - #endif // PROFILING_SUPPORTED } HCIMPLEND @@ -11116,13 +11082,10 @@ HCIMPL2(EXTERN_C void, ProfileTailcall, UINT_PTR clientData, void * platformSpec _ASSERTE(GetThread()->PreemptiveGCDisabled()); _ASSERTE(platformSpecificHandle != NULL); - // Set up a frame - HELPER_METHOD_FRAME_BEGIN_ATTRIB_NOPOLL(Frame::FRAME_ATTR_CAPTURE_DEPTH_2); - - // Our contract is FCALL_CONTRACT, which is considered triggers if you set up a - // frame, like we're about to do. + // This callback is called from the epilog of a method, without a valid ability to suspend the runtime/take a GC. + // This means that we cannot trigger a GC. SetCallbackStateFlagsHolder csf( - COR_PRF_CALLBACKSTATE_INCALLBACK | COR_PRF_CALLBACKSTATE_IN_TRIGGERS_SCOPE); + COR_PRF_CALLBACKSTATE_INCALLBACK); COR_PRF_ELT_INFO_INTERNAL eltInfo; eltInfo.platformSpecificHandle = platformSpecificHandle; @@ -11205,8 +11168,6 @@ HCIMPL2(EXTERN_C void, ProfileTailcall, UINT_PTR clientData, void * platformSpec ; - HELPER_METHOD_FRAME_END(); // Un-link the frame - #endif // PROFILING_SUPPORTED } HCIMPLEND diff --git a/src/coreclr/vm/qcall.h b/src/coreclr/vm/qcall.h index e3154c7b133..9daa0398a30 100644 --- a/src/coreclr/vm/qcall.h +++ b/src/coreclr/vm/qcall.h @@ -27,7 +27,7 @@ // // // The preferred type of QCall arguments is primitive types that efficiently handled by the P/Invoke marshaler (INT32, LPCWSTR, BOOL). -// (Notice that BOOL is the correct boolean flavor for QCall arguments. CLR_BOOL is the correct boolean flavor for FCall arguments.) +// (Notice that BOOL is the correct boolean flavor for QCall arguments. FC_BOOL_ARG is the correct boolean flavor for FCall arguments.) // // The pointers to common unmanaged EE structures should be wrapped into helper handle types. This is to make the managed implementation // type safe and avoid falling into unsafe C# everywhere. See the AssemblyHandle below for a good example. @@ -248,15 +248,15 @@ class QCall struct AssemblyHandle { Object ** m_ppObject; - DomainAssembly * m_pAssembly; + Assembly * m_pAssembly; - operator DomainAssembly * () + operator Assembly * () { LIMITED_METHOD_CONTRACT; return m_pAssembly; } - DomainAssembly * operator->() const + Assembly * operator->() const { LIMITED_METHOD_CONTRACT; return m_pAssembly; diff --git a/src/coreclr/vm/qcallentrypoints.cpp b/src/coreclr/vm/qcallentrypoints.cpp index bf2a8f6ce3a..4181a027e66 100644 --- a/src/coreclr/vm/qcallentrypoints.cpp +++ b/src/coreclr/vm/qcallentrypoints.cpp @@ -43,7 +43,6 @@ #ifdef FEATURE_COMINTEROP #include "variant.h" -#include "mngstdinterfaces.h" #endif // FEATURE_COMINTEROP #include "interoplibinterface.h" @@ -84,8 +83,10 @@ static const Entry s_QCall[] = DllImportEntry(CustomAttribute_CreateCustomAttributeInstance) DllImportEntry(CustomAttribute_CreatePropertyOrFieldData) DllImportEntry(Enum_GetValuesAndNames) + DllImportEntry(DebugDebugger_Break) DllImportEntry(DebugDebugger_Launch) DllImportEntry(DebugDebugger_Log) + DllImportEntry(DebugDebugger_CustomNotification) DllImportEntry(Delegate_BindToMethodName) DllImportEntry(Delegate_BindToMethodInfo) DllImportEntry(Delegate_InitializeVirtualCallStub) @@ -98,6 +99,7 @@ static const Entry s_QCall[] = DllImportEntry(Environment_Exit) DllImportEntry(Environment_FailFast) DllImportEntry(Environment_GetProcessorCount) + DllImportEntry(ExceptionNative_GetFrozenStackTrace) DllImportEntry(ExceptionNative_GetMessageFromNativeResources) DllImportEntry(ExceptionNative_GetMethodFromStackTrace) DllImportEntry(ExceptionNative_ThrowAmbiguousResolutionException) @@ -109,12 +111,15 @@ static const Entry s_QCall[] = DllImportEntry(MethodTable_CanCompareBitsOrUseFastGetHashCode) DllImportEntry(TypeHandle_CanCastTo_NoCacheLookup) DllImportEntry(ValueType_GetHashCodeStrategy) + DllImportEntry(Stream_HasOverriddenSlow) DllImportEntry(RuntimeTypeHandle_MakePointer) DllImportEntry(RuntimeTypeHandle_MakeByRef) DllImportEntry(RuntimeTypeHandle_MakeSZArray) DllImportEntry(RuntimeTypeHandle_MakeArray) DllImportEntry(RuntimeTypeHandle_IsCollectible) DllImportEntry(RuntimeTypeHandle_GetConstraints) + DllImportEntry(RuntimeTypeHandle_GetAssemblySlow) + DllImportEntry(RuntimeTypeHandle_GetModuleSlow) DllImportEntry(RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals) DllImportEntry(RuntimeTypeHandle_VerifyInterfaceIsImplemented) DllImportEntry(RuntimeTypeHandle_GetInterfaceMethodImplementation) @@ -139,6 +144,7 @@ static const Entry s_QCall[] = DllImportEntry(RuntimeModule_GetFullyQualifiedName) DllImportEntry(RuntimeModule_GetTypes) DllImportEntry(RuntimeFieldHandle_GetRVAFieldInfo) + DllImportEntry(StackTrace_GetStackFramesInternal) DllImportEntry(StackFrame_GetMethodDescFromNativeIP) DllImportEntry(ModuleBuilder_GetStringConstant) DllImportEntry(ModuleBuilder_GetTypeRef) @@ -154,6 +160,7 @@ static const Entry s_QCall[] = DllImportEntry(ModuleHandle_ResolveMethod) DllImportEntry(ModuleHandle_ResolveField) DllImportEntry(ModuleHandle_GetPEKind) + DllImportEntry(AssemblyHandle_GetManifestModuleSlow) DllImportEntry(TypeBuilder_DefineGenericParam) DllImportEntry(TypeBuilder_DefineType) DllImportEntry(TypeBuilder_SetParentType) @@ -226,15 +233,23 @@ static const Entry s_QCall[] = DllImportEntry(MultiCoreJIT_InternalStartProfile) #endif DllImportEntry(LoaderAllocator_Destroy) - DllImportEntry(CustomMarshaler_GetMarshalerObject) DllImportEntry(String_Intern) DllImportEntry(String_IsInterned) DllImportEntry(AppDomain_CreateDynamicAssembly) DllImportEntry(ThreadNative_Start) + DllImportEntry(ThreadNative_SetPriority) + DllImportEntry(ThreadNative_GetCurrentThread) DllImportEntry(ThreadNative_SetIsBackground) DllImportEntry(ThreadNative_InformThreadNameChange) DllImportEntry(ThreadNative_YieldThread) DllImportEntry(ThreadNative_GetCurrentOSThreadId) + DllImportEntry(ThreadNative_Initialize) + DllImportEntry(ThreadNative_GetThreadState) +#ifdef FEATURE_COMINTEROP_APARTMENT_SUPPORT + DllImportEntry(ThreadNative_GetApartmentState) + DllImportEntry(ThreadNative_SetApartmentState) +#endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT + DllImportEntry(ThreadNative_Join) DllImportEntry(ThreadNative_Abort) DllImportEntry(ThreadNative_ResetAbort) DllImportEntry(ThreadNative_SpinWait) @@ -243,9 +258,12 @@ static const Entry s_QCall[] = #ifdef FEATURE_COMINTEROP DllImportEntry(ThreadNative_DisableComObjectEagerCleanup) #endif // FEATURE_COMINTEROP + DllImportEntry(WaitHandle_WaitOneCore) + DllImportEntry(WaitHandle_WaitMultipleIgnoringSyncContext) + DllImportEntry(WaitHandle_SignalAndWait) #ifdef TARGET_UNIX - DllImportEntry(WaitHandle_CorWaitOnePrioritizedNative) -#endif + DllImportEntry(WaitHandle_WaitOnePrioritized) +#endif // TARGET_UNIX DllImportEntry(ClrConfig_GetConfigBoolValue) DllImportEntry(Buffer_Clear) DllImportEntry(Buffer_MemMove) @@ -256,6 +274,7 @@ static const Entry s_QCall[] = DllImportEntry(GCInterface_WaitForFullGCComplete) DllImportEntry(GCInterface_StartNoGCRegion) DllImportEntry(GCInterface_EndNoGCRegion) + DllImportEntry(GCInterface_AllocateNewArray) DllImportEntry(GCInterface_GetTotalMemory) DllImportEntry(GCInterface_Collect) DllImportEntry(GCInterface_ReRegisterForFinalize) @@ -326,8 +345,7 @@ static const Entry s_QCall[] = DllImportEntry(MngdSafeArrayMarshaler_ConvertSpaceToManaged) DllImportEntry(MngdSafeArrayMarshaler_ConvertContentsToManaged) DllImportEntry(MngdSafeArrayMarshaler_ClearNative) - DllImportEntry(Variant_ConvertSystemColorToOleColor) - DllImportEntry(Variant_ConvertOleColorToSystemColor) + DllImportEntry(Variant_ConvertValueTypeToRecord) #endif // FEATURE_COMINTEROP DllImportEntry(NativeLibrary_LoadFromPath) DllImportEntry(NativeLibrary_LoadByName) @@ -337,6 +355,8 @@ static const Entry s_QCall[] = DllImportEntry(GetFileLoadExceptionMessage) DllImportEntry(FileLoadException_GetMessageForHR) DllImportEntry(Interlocked_MemoryBarrierProcessWide) + DllImportEntry(ObjectNative_GetHashCodeSlow) + DllImportEntry(ObjectNative_GetTypeSlow) DllImportEntry(ObjectNative_AllocateUninitializedClone) DllImportEntry(Monitor_Wait) DllImportEntry(Monitor_Pulse) @@ -421,10 +441,21 @@ static const Entry s_QCall[] = #if defined(TARGET_X86) || defined(TARGET_AMD64) DllImportEntry(X86BaseCpuId) #endif - DllImportEntry(StubHelpers_CreateCustomMarshalerHelper) + DllImportEntry(StubHelpers_CreateCustomMarshaler) DllImportEntry(StubHelpers_SetStringTrailByte) DllImportEntry(StubHelpers_ThrowInteropParamException) + DllImportEntry(StubHelpers_MarshalToManagedVaList) + DllImportEntry(StubHelpers_MarshalToUnmanagedVaList) + DllImportEntry(StubHelpers_ValidateObject) + DllImportEntry(StubHelpers_ValidateByref) +#ifdef PROFILING_SUPPORTED + DllImportEntry(StubHelpers_ProfilerBeginTransitionCallback) + DllImportEntry(StubHelpers_ProfilerEndTransitionCallback) +#endif + DllImportEntry(StubHelpers_GetHRExceptionObject) #if defined(FEATURE_COMINTEROP) + DllImportEntry(StubHelpers_GetCOMHRExceptionObject) + DllImportEntry(StubHelpers_GetCOMIPFromRCWSlow) DllImportEntry(ObjectMarshaler_ConvertToNative) DllImportEntry(ObjectMarshaler_ConvertToManaged) DllImportEntry(InterfaceMarshaler_ConvertToNative) diff --git a/src/coreclr/vm/readytoruninfo.cpp b/src/coreclr/vm/readytoruninfo.cpp index bc27ae28d45..19ab4b62146 100644 --- a/src/coreclr/vm/readytoruninfo.cpp +++ b/src/coreclr/vm/readytoruninfo.cpp @@ -742,7 +742,7 @@ ReadyToRunInfo::ReadyToRunInfo(Module * pModule, LoaderAllocator* pLoaderAllocat const GUID *componentMvids = (const GUID *)m_pComposite->GetLayout()->GetDirectoryData(pComponentAssemblyMvids); // Take load lock so that DeclareDependencyOnMvid can be called - BaseDomain::LoadLockHolder lock(AppDomain::GetCurrentDomain(), pNativeImage == NULL); // LoadLock is already held for composite images + AppDomain::LoadLockHolder lock(AppDomain::GetCurrentDomain(), pNativeImage == NULL); // LoadLock is already held for composite images AppDomain::GetCurrentDomain()->AssertLoadLockHeld(); while (pNativeMDImport->EnumNext(&assemblyEnum, &assemblyRef)) @@ -1526,7 +1526,7 @@ class NativeManifestModule : public ModuleBase return GetModuleIfLoaded(kFile); } - DomainAssembly * LoadAssemblyImpl(mdAssemblyRef kAssemblyRef) final + Assembly * LoadAssemblyImpl(mdAssemblyRef kAssemblyRef) final { STANDARD_VM_CONTRACT; // Since we can only load via ModuleRef, this should never fail unless the module is improperly formatted diff --git a/src/coreclr/vm/reflectioninvocation.cpp b/src/coreclr/vm/reflectioninvocation.cpp index 37dd3e6635a..d332fc12a46 100644 --- a/src/coreclr/vm/reflectioninvocation.cpp +++ b/src/coreclr/vm/reflectioninvocation.cpp @@ -410,7 +410,7 @@ FCIMPL4(Object*, RuntimeMethodHandle::InvokeMethod, Object *target, PVOID* args, // An array of byrefs SignatureNative* pSigUNSAFE, - CLR_BOOL fConstructor) + FC_BOOL_ARG fConstructor) { FCALL_CONTRACT; @@ -443,7 +443,7 @@ FCIMPL4(Object*, RuntimeMethodHandle::InvokeMethod, BOOL fCtorOfVariableSizedObject = FALSE; - if (fConstructor) + if (FC_ACCESS_BOOL(fConstructor)) { // If we are invoking a constructor on an array then we must // handle this specially. @@ -550,7 +550,7 @@ FCIMPL4(Object*, RuntimeMethodHandle::InvokeMethod, if (!pMeth->IsStatic() && !fCtorOfVariableSizedObject) { PVOID pThisPtr; - if (fConstructor) + if (FC_ACCESS_BOOL(fConstructor)) { // Copy "this" pointer: only unbox if type is value type and method is not unboxing stub if (ownerType.IsValueType() && !pMeth->IsUnboxingStub()) { @@ -672,7 +672,7 @@ FCIMPL4(Object*, RuntimeMethodHandle::InvokeMethod, CallDescrWorkerWithHandler(&callDescrData); // It is still illegal to do a GC here. The return type might have/contain GC pointers. - if (fConstructor) + if (FC_ACCESS_BOOL(fConstructor)) { // We have a special case for Strings...The object is returned... if (fCtorOfVariableSizedObject) { @@ -1282,7 +1282,7 @@ extern "C" BOOL QCALLTYPE RuntimeFieldHandle_GetRVAFieldInfo(FieldDesc* pField, Module* pModule = pField->GetModule(); *address = pModule->GetRvaField(pField->GetOffset()); *size = pField->LoadSize(); - + ret = TRUE; } @@ -1332,12 +1332,12 @@ extern "C" void QCALLTYPE ReflectionInvocation_RunModuleConstructor(QCall::Modul { QCALL_CONTRACT; - DomainAssembly *pDomainAssembly = pModule->GetDomainAssembly(); - if (pDomainAssembly != NULL && pDomainAssembly->IsActive()) + Assembly *pAssembly = pModule->GetAssembly(); + if (pAssembly != NULL && pAssembly->IsActive()) return; BEGIN_QCALL; - pDomainAssembly->EnsureActive(); + pAssembly->EnsureActive(); END_QCALL; } diff --git a/src/coreclr/vm/rejit.cpp b/src/coreclr/vm/rejit.cpp index aa07730259f..689e30d7d83 100644 --- a/src/coreclr/vm/rejit.cpp +++ b/src/coreclr/vm/rejit.cpp @@ -731,15 +731,14 @@ HRESULT ReJitManager::UpdateNativeInlinerActiveILVersions( // Iterate through all modules, for any that are NGEN or R2R need to check if there are inliners there and call // RequestReJIT on them - AppDomain::AssemblyIterator domainAssemblyIterator = SystemDomain::System()->DefaultDomain()->IterateAssembliesEx((AssemblyIterationFlags) (kIncludeLoaded | kIncludeExecution)); - CollectibleAssemblyHolder pDomainAssembly; + AppDomain::AssemblyIterator assemblyIterator = AppDomain::GetCurrentDomain()->IterateAssembliesEx((AssemblyIterationFlags) (kIncludeLoaded | kIncludeExecution)); + CollectibleAssemblyHolder pAssembly; NativeImageInliningIterator inlinerIter; - while (domainAssemblyIterator.Next(pDomainAssembly.This())) + while (assemblyIterator.Next(pAssembly.This())) { - _ASSERTE(pDomainAssembly != NULL); - _ASSERTE(pDomainAssembly->GetAssembly() != NULL); + _ASSERTE(pAssembly != NULL); - Module * pModule = pDomainAssembly->GetModule(); + Module * pModule = pAssembly->GetModule(); if (pModule->HasReadyToRunInlineTrackingMap()) { inlinerIter.Reset(pModule, MethodInModule(pInlineeModule, inlineeMethodDef)); @@ -1123,53 +1122,21 @@ ReJITID ReJitManager::GetReJitId(PTR_MethodDesc pMD, PCODE pCodeStart) CONTRACTL { NOTHROW; - CAN_TAKE_LOCK; - GC_TRIGGERS; + CANNOT_TAKE_LOCK; + GC_NOTRIGGER; PRECONDITION(CheckPointer(pMD)); PRECONDITION(pCodeStart != NULL); } CONTRACTL_END; - // Fast-path: If the rejit map is empty, no need to look up anything. Do this outside - // of a lock to impact our caller (the prestub worker) as little as possible. If the - // map is nonempty, we'll acquire the lock at that point and do the lookup for real. + // Fast-path: If the rejit map is empty, no need to look up anything. CodeVersionManager* pCodeVersionManager = pMD->GetCodeVersionManager(); if (!pCodeVersionManager->HasNonDefaultILVersions()) { return 0; } - CodeVersionManager::LockHolder codeVersioningLockHolder; - return ReJitManager::GetReJitIdNoLock(pMD, pCodeStart); -} - -//--------------------------------------------------------------------------------------- -// -// See comment above code:ReJitManager::GetReJitId for main details of what this does. -// -// This function is basically the same as GetReJitId, except caller is expected to take -// the ReJitManager lock directly (via ReJitManager::TableLockHolder). This exists so -// that ETW can explicitly take the triggering ReJitManager lock up front, and in the -// proper order, to avoid lock leveling issues, and triggering issues with other locks it -// takes that are CRST_UNSAFE_ANYMODE -// - -ReJITID ReJitManager::GetReJitIdNoLock(PTR_MethodDesc pMD, PCODE pCodeStart) -{ - CONTRACTL - { - NOTHROW; - CANNOT_TAKE_LOCK; - GC_NOTRIGGER; - PRECONDITION(CheckPointer(pMD)); - PRECONDITION(pCodeStart != NULL); - } - CONTRACTL_END; - - // Caller must ensure this lock is taken! - _ASSERTE(CodeVersionManager::IsLockOwnedByCurrentThread()); - - NativeCodeVersion nativeCodeVersion = pMD->GetCodeVersionManager()->GetNativeCodeVersion(pMD, pCodeStart); + NativeCodeVersion nativeCodeVersion = pCodeVersionManager->GetNativeCodeVersion(pMD, pCodeStart); if (nativeCodeVersion.IsNull()) { return 0; @@ -1269,11 +1236,6 @@ ReJITID ReJitManager::GetReJitId(PTR_MethodDesc pMD, PCODE pCodeStart) return 0; } -ReJITID ReJitManager::GetReJitIdNoLock(PTR_MethodDesc pMD, PCODE pCodeStart) -{ - return 0; -} - HRESULT ReJitManager::GetReJITIDs(PTR_MethodDesc pMD, ULONG cReJitIds, ULONG * pcReJitIds, ReJITID reJitIds[]) { return E_NOTIMPL; diff --git a/src/coreclr/vm/rejit.h b/src/coreclr/vm/rejit.h index c54c567e592..a994f9d3455 100644 --- a/src/coreclr/vm/rejit.h +++ b/src/coreclr/vm/rejit.h @@ -114,7 +114,6 @@ class ReJitManager static CORJIT_FLAGS JitFlagsFromProfCodegenFlags(DWORD dwCodegenFlags); static ReJITID GetReJitId(PTR_MethodDesc pMD, PCODE pCodeStart); - static ReJITID GetReJitIdNoLock(PTR_MethodDesc pMD, PCODE pCodeStart); static HRESULT GetReJITIDs(PTR_MethodDesc pMD, ULONG cReJitIds, ULONG * pcReJitIds, ReJITID reJitIds[]); #ifdef FEATURE_REJIT diff --git a/src/coreclr/vm/riscv64/asmconstants.h b/src/coreclr/vm/riscv64/asmconstants.h index a2fb19faef1..fb7577c643e 100644 --- a/src/coreclr/vm/riscv64/asmconstants.h +++ b/src/coreclr/vm/riscv64/asmconstants.h @@ -174,6 +174,14 @@ ASMCONSTANTS_C_ASSERT(MethodDesc_ALIGNMENT_SHIFT == MethodDesc::ALIGNMENT_SHIFT) ASMCONSTANTS_C_ASSERT(ResolveCacheElem__target == offsetof(ResolveCacheElem, target)); ASMCONSTANTS_C_ASSERT(ResolveCacheElem__pNext == offsetof(ResolveCacheElem, pNext)); +#define OFFSETOF__DynamicStaticsInfo__m_pNonGCStatics 0x8 +ASMCONSTANTS_C_ASSERT(OFFSETOF__DynamicStaticsInfo__m_pNonGCStatics + == offsetof(DynamicStaticsInfo, m_pNonGCStatics)); + +#define OFFSETOF__DynamicStaticsInfo__m_pGCStatics 0 +ASMCONSTANTS_C_ASSERT(OFFSETOF__DynamicStaticsInfo__m_pGCStatics + == offsetof(DynamicStaticsInfo, m_pGCStatics)); + // For JIT_PInvokeBegin and JIT_PInvokeEnd helpers #define Frame__m_Next 0x08 ASMCONSTANTS_C_ASSERT(Frame__m_Next == offsetof(Frame, m_Next)) diff --git a/src/coreclr/vm/riscv64/asmhelpers.S b/src/coreclr/vm/riscv64/asmhelpers.S index ffe13eea7a0..94ee7bb6e03 100644 --- a/src/coreclr/vm/riscv64/asmhelpers.S +++ b/src/coreclr/vm/riscv64/asmhelpers.S @@ -813,6 +813,38 @@ LEAF_END setFPReturn, _TEXT #endif // FEATURE_COMINTEROP +// ------------------------------------------------------------------ +// void* JIT_GetDynamicNonGCStaticBase(DynamicStaticsInfo* pStaticsInfo) + +LEAF_ENTRY JIT_GetDynamicNonGCStaticBase_SingleAppDomain, _TEXT + // If class is not initialized, bail to C++ helper + ld a1, OFFSETOF__DynamicStaticsInfo__m_pNonGCStatics(a0) + bnez a1, LOCAL_LABEL(JIT_GetDynamicNonGCStaticBase_SingleAppDomain_CallHelper) + mv a0, a1 + ret + +LOCAL_LABEL(JIT_GetDynamicNonGCStaticBase_SingleAppDomain_CallHelper): + // Tail call JIT_GetDynamicNonGCStaticBase_Portable + la a1, JIT_GetDynamicNonGCStaticBase_Portable + jr a1 +LEAF_END JIT_GetDynamicNonGCStaticBase_SingleAppDomain, _TEXT + +// ------------------------------------------------------------------ +// void* JIT_GetDynamicGCStaticBase(DynamicStaticsInfo* pStaticsInfo) + +LEAF_ENTRY JIT_GetDynamicGCStaticBase_SingleAppDomain, _TEXT + // If class is not initialized, bail to C++ helper + ld a1, OFFSETOF__DynamicStaticsInfo__m_pGCStatics(a0) + bnez a1, LOCAL_LABEL(JIT_GetDynamicGCStaticBase_SingleAppDomain_CallHelper) + mv a0, a1 + ret + +LOCAL_LABEL(JIT_GetDynamicGCStaticBase_SingleAppDomain_CallHelper): + // Tail call JIT_GetDynamicGCStaticBase_Portable + la a1, JIT_GetDynamicGCStaticBase_Portable + jr a1 +LEAF_END JIT_GetDynamicGCStaticBase_SingleAppDomain, _TEXT + #ifdef FEATURE_READYTORUN NESTED_ENTRY DelayLoad_MethodCall_FakeProlog, _TEXT, NoHandler diff --git a/src/coreclr/vm/riscv64/cgencpu.h b/src/coreclr/vm/riscv64/cgencpu.h index 8d0453254e8..0b9b53fb9f6 100644 --- a/src/coreclr/vm/riscv64/cgencpu.h +++ b/src/coreclr/vm/riscv64/cgencpu.h @@ -104,6 +104,8 @@ inline unsigned StackElemSize(unsigned parmSize, bool isValueType, bool isFloatH // // Create alias for optimized implementations of helpers provided on this platform // +#define JIT_GetDynamicGCStaticBase JIT_GetDynamicGCStaticBase_SingleAppDomain +#define JIT_GetDynamicNonGCStaticBase JIT_GetDynamicNonGCStaticBase_SingleAppDomain //********************************************************************** // Frames diff --git a/src/coreclr/vm/riscv64/virtualcallstubcpu.hpp b/src/coreclr/vm/riscv64/virtualcallstubcpu.hpp index 77ceb4cb0a5..f77147dd5fc 100644 --- a/src/coreclr/vm/riscv64/virtualcallstubcpu.hpp +++ b/src/coreclr/vm/riscv64/virtualcallstubcpu.hpp @@ -193,7 +193,7 @@ struct ResolveHolder ;;cachemask => [CALL_STUB_CACHE_MASK * sizeof(void*)] // Called directly by JITTED code - // ResolveStub._resolveEntryPoint(a0:Object*, a1 ...,a7, t8:IndirectionCellAndFlags) + // ResolveStub._resolveEntryPoint(a0:Object*, a1 ...,a7, t5:IndirectionCellAndFlags) // { // MethodTable mt = a0.m_pMethTab; // int i = ((mt + mt >> 12) ^ this._hashedToken) & _cacheMask @@ -263,14 +263,14 @@ struct ResolveHolder _stub._resolveEntryPoint[n++] = 0x01cf9a63;// | PC_REL_OFFSET(_slowEntryPoint[0], n); // ld t6, 0(t1) # t6 = e.token; - _stub._resolveEntryPoint[n++] = 0x00033f83 | ((offsetof(ResolveCacheElem, token) & 0xfff)<<10); + _stub._resolveEntryPoint[n++] = 0x00033f83 | ((offsetof(ResolveCacheElem, token) & 0xfff)<<20); // bne t6, t2, next _stub._resolveEntryPoint[n++] = 0x007f9663;// | PC_REL_OFFSET(_slowEntryPoint[0], n); pc_offset = offsetof(ResolveCacheElem, target) & 0xffffffff; _ASSERTE(pc_offset >=0 && pc_offset%8 == 0); // ld t3, 0(t1) # t3 = e.target; - _stub._resolveEntryPoint[n++] = 0x00033e03 | ((offsetof(ResolveCacheElem, target) & 0xfff)<<10); + _stub._resolveEntryPoint[n++] = 0x00033e03 | ((offsetof(ResolveCacheElem, target) & 0xfff)<<20); // jalr x0, t3, 0 _stub._resolveEntryPoint[n++] = 0x000e0067; @@ -289,7 +289,7 @@ struct ResolveHolder // auipc t0, 0 _stub._slowEntryPoint[0] = 0x00000297; - // ld t6, 0(t0) # r21 = _resolveWorkerTarget; + // ld t6, 0(t0) # t6 = _resolveWorkerTarget; static_assert_no_msg((0x14*4) == ((INT32)(offsetof(ResolveStub, _resolveWorkerTarget) - (offsetof(ResolveStub, _slowEntryPoint[0]))))); static_assert_no_msg((ResolveStub::slowEntryPointLen + ResolveStub::failEntryPointLen+1+3*2) == 0x14); _stub._slowEntryPoint[1] = 0x0002bf83 | ((0x14 * 4) << 20); diff --git a/src/coreclr/vm/runtimecallablewrapper.cpp b/src/coreclr/vm/runtimecallablewrapper.cpp index 21fa3b8879f..fcdb7a27bcd 100644 --- a/src/coreclr/vm/runtimecallablewrapper.cpp +++ b/src/coreclr/vm/runtimecallablewrapper.cpp @@ -39,6 +39,7 @@ class Object; #include "classnames.h" #include "objectnative.h" #include "finalizerthread.h" +#include "dynamicinterfacecastable.h" // static SLIST_HEADER RCW::s_RCWStandbyList; @@ -2299,87 +2300,6 @@ void RCW::ReleaseAllInterfaces() } } -//--------------------------------------------------------------------- -// Returns true if the RCW supports given "standard managed" interface. -bool RCW::SupportsMngStdInterface(MethodTable *pItfMT) -{ - CONTRACTL - { - THROWS; - GC_TRIGGERS; - MODE_COOPERATIVE; - PRECONDITION(CheckPointer(pItfMT)); - } - CONTRACTL_END; - - // - // Handle casts to normal managed standard interfaces. - // - - // Check to see if the interface is a managed standard interface. - IID *pNativeIID = MngStdInterfaceMap::GetNativeIIDForType(pItfMT); - if (pNativeIID != NULL) - { - // It is a managed standard interface so we need to check to see if the COM component - // implements the native interface associated with it. - SafeComHolder pNativeItf = NULL; - - // QI for the native interface. - SafeQueryInterfaceRemoteAware(*pNativeIID, &pNativeItf); - - // If the component supports the native interface then we can say it implements the - // standard interface. - if (pNativeItf) - return true; - } - else - { - // - // Handle casts to IEnumerable. - // - - // If the requested interface is IEnumerable then we need to check to see if the - // COM object implements IDispatch and has a member with DISPID_NEWENUM. - if (pItfMT == CoreLibBinder::GetClass(CLASS__IENUMERABLE)) - { - SafeComHolder pDisp = GetIDispatch(); - if (pDisp) - { - DISPPARAMS DispParams = {0, 0, NULL, NULL}; - VariantHolder VarResult; - - // Initialize the return variant. - SafeVariantInit(&VarResult); - - HRESULT hr = E_FAIL; - { - // We are about to make a call to COM so switch to preemptive GC. - GCX_PREEMP(); - - // Call invoke with DISPID_NEWENUM to see if such a member exists. - hr = pDisp->Invoke( - DISPID_NEWENUM, - IID_NULL, - LOCALE_USER_DEFAULT, - DISPATCH_METHOD | DISPATCH_PROPERTYGET, - &DispParams, - &VarResult, - NULL, - NULL - ); - } - - // If the invoke succeeded then the component has a member DISPID_NEWENUM - // so we can expose it as an IEnumerable. - if (SUCCEEDED(hr)) - return true; - } - } - } - - return false; -} - //-------------------------------------------------------------------------------- // OBJECTREF ComObject::CreateComObjectRef(MethodTable* pMT) // returns NULL for out of memory scenarios @@ -2491,7 +2411,7 @@ BOOL ComObject::SupportsInterface(OBJECTREF oref, MethodTable* pIntfTable) } } } - else if (pRCW->SupportsMngStdInterface(pIntfTable)) + else if (DynamicInterfaceCastable::IsInstanceOf(&oref, { pIntfTable }, FALSE)) { bSupportsItf = true; } @@ -2636,27 +2556,6 @@ void ComObject::ThrowInvalidCastException(OBJECTREF *pObj, MethodTable *pCastToM COMPlusThrow(kInvalidCastException, IDS_EE_RCW_INVALIDCAST_IENUMERABLE, strHRDescription.GetUnicode(), strComObjClassName.GetUnicode(), strCastToName.GetUnicode(), strIID); } - else if ((pNativeIID = MngStdInterfaceMap::GetNativeIIDForType(thCastTo)) != NULL) - { - // Convert the source interface IID to a string. - WCHAR strNativeItfIID[GUID_STR_BUFFER_LEN]; - GuidToLPWSTR(*pNativeIID, strNativeItfIID); - - // Query for the interface to determine the failure HRESULT. - HRESULT hr2 = pRCW->SafeQueryInterfaceRemoteAware(iid, (IUnknown**)&pItf); - - // If this function was called, it means the QI call failed in the past. If it - // no longer fails now, we still need to throw, so throw a generic invalid cast exception. - if (SUCCEEDED(hr2)) - COMPlusThrow(kInvalidCastException, IDS_EE_CANNOTCAST, strComObjClassName.GetUnicode(), strCastToName.GetUnicode()); - - // Obtain the textual description of the 2nd HRESULT. - SString strHR2Description; - GetHRMsg(hr2, strHR2Description); - - COMPlusThrow(kInvalidCastException, IDS_EE_RCW_INVALIDCAST_MNGSTDITF, strHRDescription.GetUnicode(), strComObjClassName.GetUnicode(), - strCastToName.GetUnicode(), strIID, strNativeItfIID, strHR2Description.GetUnicode()); - } else { COMPlusThrow(kInvalidCastException, IDS_EE_RCW_INVALIDCAST_ITF, diff --git a/src/coreclr/vm/runtimecallablewrapper.h b/src/coreclr/vm/runtimecallablewrapper.h index 229966e307f..10e398dc117 100644 --- a/src/coreclr/vm/runtimecallablewrapper.h +++ b/src/coreclr/vm/runtimecallablewrapper.h @@ -62,7 +62,6 @@ #include "vars.hpp" #include "spinlock.h" #include "interoputil.h" -#include "mngstdinterfaces.h" #include "excep.h" #include "comcache.h" #include "threads.h" @@ -124,7 +123,7 @@ struct RCW if (m_InlineCacheIndex >= INTERFACE_ENTRY_CACHE_SIZE) return FALSE; - + // stop incrementing m_InlineCacheIndex once we reach INTERFACE_ENTRY_CACHE_SIZE if (++m_InlineCacheIndex < INTERFACE_ENTRY_CACHE_SIZE) return TRUE; @@ -452,12 +451,6 @@ struct RCW return CachedInterfaceEntryIterator(dac_cast(this)); } - //--------------------------------------------------------------------- - // Returns true iff pItfMT is a "standard managed" interface, such as - // IEnumerator, and the RCW supports the interface through classic COM - // interop mechanisms. - bool SupportsMngStdInterface(MethodTable *pItfMT); - #ifdef _DEBUG // Does not throw if m_UnkEntry.m_pUnknown is no longer valid, debug only. IUnknown *GetRawIUnknown_NoAddRef_NoThrow() @@ -1325,7 +1318,7 @@ class RCWCleanupList public: RCWCleanupList() : m_pFirstBucket(NULL), m_lock(CrstRCWCleanupList, CRST_UNSAFE_ANYMODE), - m_pCurCleanupThread(NULL), m_doCleanupInContexts(FALSE) + m_pCurCleanupThread(NULL), m_doCleanupInContexts(FALSE) { WRAPPER_NO_CONTRACT; } diff --git a/src/coreclr/vm/runtimehandles.cpp b/src/coreclr/vm/runtimehandles.cpp index e9bfa7bce66..7b067cf8103 100644 --- a/src/coreclr/vm/runtimehandles.cpp +++ b/src/coreclr/vm/runtimehandles.cpp @@ -161,43 +161,6 @@ NOINLINE static ReflectClassBaseObject* GetRuntimeTypeHelper(LPVOID __me, TypeHa #define RETURN_CLASS_OBJECT(typeHandle, keepAlive) FC_INNER_RETURN(ReflectClassBaseObject*, GetRuntimeTypeHelper(__me, typeHandle, keepAlive)) -NOINLINE ReflectModuleBaseObject* GetRuntimeModuleHelper(LPVOID __me, Module *pModule, OBJECTREF keepAlive) -{ - FC_INNER_PROLOG_NO_ME_SETUP(); - if (pModule == NULL) - return NULL; - - OBJECTREF refModule = pModule->GetExposedObjectIfExists(); - if (refModule != NULL) - return (ReflectModuleBaseObject*)OBJECTREFToObject(refModule); - - HELPER_METHOD_FRAME_BEGIN_RET_ATTRIB_1(Frame::FRAME_ATTR_EXACT_DEPTH|Frame::FRAME_ATTR_CAPTURE_DEPTH_2, keepAlive); - refModule = pModule->GetExposedObject(); - HELPER_METHOD_FRAME_END(); - - FC_INNER_EPILOG(); - return (ReflectModuleBaseObject*)OBJECTREFToObject(refModule); -} - -NOINLINE AssemblyBaseObject* GetRuntimeAssemblyHelper(LPVOID __me, DomainAssembly *pAssembly, OBJECTREF keepAlive) -{ - FC_INNER_PROLOG_NO_ME_SETUP(); - if (pAssembly == NULL) - return NULL; - - OBJECTREF refAssembly = (pAssembly != NULL) ? pAssembly->GetExposedAssemblyObjectIfExists() : NULL; - - if(refAssembly != NULL) - return (AssemblyBaseObject*)OBJECTREFToObject(refAssembly); - - HELPER_METHOD_FRAME_BEGIN_RET_ATTRIB_1(Frame::FRAME_ATTR_EXACT_DEPTH|Frame::FRAME_ATTR_CAPTURE_DEPTH_2, keepAlive); - refAssembly = pAssembly->GetExposedAssemblyObject(); - HELPER_METHOD_FRAME_END(); - - FC_INNER_EPILOG(); - return (AssemblyBaseObject*)OBJECTREFToObject(refAssembly); -} - FCIMPL1(ReflectClassBaseObject*, RuntimeTypeHandle::GetRuntimeType, EnregisteredTypeHandle th) { FCALL_CONTRACT; @@ -298,24 +261,35 @@ FCIMPL1(INT32, RuntimeTypeHandle::GetCorElementType, ReflectClassBaseObject *pTy } FCIMPLEND -FCIMPL1(AssemblyBaseObject*, RuntimeTypeHandle::GetAssembly, ReflectClassBaseObject *pTypeUNSAFE) { - CONTRACTL { - FCALL_CHECK; - } - CONTRACTL_END; +FCIMPL1(AssemblyBaseObject*, RuntimeTypeHandle::GetAssemblyIfExists, ReflectClassBaseObject *pTypeUNSAFE) +{ + FCALL_CONTRACT; REFLECTCLASSBASEREF refType = (REFLECTCLASSBASEREF)ObjectToOBJECTREF(pTypeUNSAFE); - if (refType == NULL) - FCThrowRes(kArgumentNullException, W("Arg_InvalidHandle")); - - Module *pModule = refType->GetType().GetAssembly()->GetModule(); - DomainAssembly *pDomainAssembly = pModule->GetDomainAssembly(); + return NULL; - FC_RETURN_ASSEMBLY_OBJECT(pDomainAssembly, refType); + Assembly* pAssembly = refType->GetType().GetAssembly(); + OBJECTREF refAssembly = pAssembly->GetExposedObjectIfExists(); + return (AssemblyBaseObject*)OBJECTREFToObject(refAssembly); } FCIMPLEND +extern "C" void QCALLTYPE RuntimeTypeHandle_GetAssemblySlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack assembly) +{ + QCALL_CONTRACT; + + BEGIN_QCALL; + GCX_COOP(); + + if (type.Get() == NULL) + COMPlusThrow(kArgumentNullException, W("Arg_InvalidHandle")); + + Assembly* pAssembly = ((REFLECTCLASSBASEREF)type.Get())->GetType().GetAssembly(); + assembly.Set(pAssembly->GetExposedObject()); + END_QCALL; +} + FCIMPL1(FC_BOOL_RET, RuntimeFieldHandle::AcquiresContextFromThis, FieldDesc* pField) { CONTRACTL { @@ -352,25 +326,35 @@ FCIMPL1(Object*, RuntimeFieldHandle::GetLoaderAllocator, FieldDesc* pField) } FCIMPLEND -FCIMPL1(ReflectModuleBaseObject*, RuntimeTypeHandle::GetModule, ReflectClassBaseObject *pTypeUNSAFE) { - CONTRACTL { - FCALL_CHECK; - } - CONTRACTL_END; - - Module *result; +FCIMPL1(ReflectModuleBaseObject*, RuntimeTypeHandle::GetModuleIfExists, ReflectClassBaseObject *pTypeUNSAFE) +{ + FCALL_CONTRACT; REFLECTCLASSBASEREF refType = (REFLECTCLASSBASEREF)ObjectToOBJECTREF(pTypeUNSAFE); - if (refType == NULL) - FCThrowRes(kArgumentNullException, W("Arg_InvalidHandle")); - - result = refType->GetType().GetModule(); + return NULL; - FC_RETURN_MODULE_OBJECT(result, refType); + Module* pModule = refType->GetType().GetModule(); + OBJECTREF refModule = pModule->GetExposedObjectIfExists(); + return (ReflectModuleBaseObject*)OBJECTREFToObject(refModule); } FCIMPLEND +extern "C" void QCALLTYPE RuntimeTypeHandle_GetModuleSlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack module) +{ + QCALL_CONTRACT; + + BEGIN_QCALL; + GCX_COOP(); + + if (type.Get() == NULL) + COMPlusThrow(kArgumentNullException, W("Arg_InvalidHandle")); + + Module* pModule = ((REFLECTCLASSBASEREF)type.Get())->GetType().GetModule(); + module.Set(pModule->GetExposedObject()); + END_QCALL; +} + FCIMPL1(ReflectClassBaseObject *, RuntimeTypeHandle::GetBaseType, ReflectClassBaseObject *pTypeUNSAFE) { CONTRACTL { FCALL_CHECK; @@ -409,17 +393,17 @@ FCIMPL1(ReflectClassBaseObject *, RuntimeTypeHandle::GetElementType, ReflectClas TypeHandle typeHandle = refType->GetType(); TypeHandle typeReturn; - if (typeHandle.IsArray()) + if (!typeHandle.IsTypeDesc()) { + if (!typeHandle.AsMethodTable()->IsArray()) + return NULL; + typeReturn = typeHandle.GetArrayElementTypeHandle(); } else { - if (!typeHandle.IsTypeDesc()) - return 0; - if (typeHandle.IsGenericVariable()) - return 0; + return NULL; typeReturn = typeHandle.AsTypeDesc()->GetTypeParam(); } @@ -955,7 +939,7 @@ extern "C" PVOID QCALLTYPE QCall_GetGCHandleForTypeHandle(QCall::TypeHandle pTyp GCX_COOP(); TypeHandle th = pTypeHandle.AsTypeHandle(); - assert(handleType >= HNDTYPE_WEAK_SHORT && handleType <= HNDTYPE_SIZEDREF); + assert(handleType >= HNDTYPE_WEAK_SHORT && handleType <= HNDTYPE_DEPENDENT); objHandle = AppDomain::GetCurrentDomain()->CreateTypedHandle(NULL, static_cast(handleType)); th.GetLoaderAllocator()->RegisterHandleForCleanup(objHandle); @@ -1815,7 +1799,7 @@ FCIMPLEND FCIMPL3(Object *, SignatureNative::GetCustomModifiersAtOffset, SignatureNative* pSignatureUNSAFE, INT32 offset, - CLR_BOOL fRequired) + FC_BOOL_ARG fRequired) { FCALL_CONTRACT; @@ -1840,7 +1824,7 @@ FCIMPL3(Object *, SignatureNative::GetCustomModifiersAtOffset, INT32 cMods = 0; CorElementType cmodType; - CorElementType cmodTypeExpected = fRequired ? ELEMENT_TYPE_CMOD_REQD : ELEMENT_TYPE_CMOD_OPT; + CorElementType cmodTypeExpected = FC_ACCESS_BOOL(fRequired) ? ELEMENT_TYPE_CMOD_REQD : ELEMENT_TYPE_CMOD_OPT; // Discover the number of required and optional custom modifiers. while(TRUE) @@ -1855,13 +1839,24 @@ FCIMPL3(Object *, SignatureNative::GetCustomModifiersAtOffset, { cMods ++; } + + IfFailThrow(sp.GetToken(NULL)); + } + else if (cmodType == ELEMENT_TYPE_CMOD_INTERNAL) + { + BYTE required; + IfFailThrow(sp.GetByte(&required)); + if (fRequired == (required != 0)) + { + cMods ++; + } + + IfFailThrow(sp.GetPointer(NULL)); } else if (cmodType != ELEMENT_TYPE_SENTINEL) { break; } - - IfFailThrow(sp.GetToken(NULL)); } // Reset sp and populate the arrays for the required and optional custom @@ -1879,18 +1874,35 @@ FCIMPL3(Object *, SignatureNative::GetCustomModifiersAtOffset, IfFailThrow(sp.GetByte(&data)); cmodType = (CorElementType)data; - mdToken token; - IfFailThrow(sp.GetToken(&token)); + if (cmodType == ELEMENT_TYPE_CMOD_INTERNAL) + { + BYTE required; + IfFailThrow(sp.GetByte(&required)); - if (cmodType == cmodTypeExpected) + TypeHandle th; + IfFailThrow(sp.GetPointer((void**)&th)); + + if (fRequired == (required != 0)) + { + OBJECTREF refType = th.GetManagedClassObject(); + gc.retVal->SetAt(--cMods, refType); + } + } + else { - TypeHandle th = ClassLoader::LoadTypeDefOrRefOrSpecThrowing(pModule, token, - &typeContext, - ClassLoader::ThrowIfNotFound, - ClassLoader::FailIfUninstDefOrRef); + mdToken token; + IfFailThrow(sp.GetToken(&token)); + + if (cmodType == cmodTypeExpected) + { + TypeHandle th = ClassLoader::LoadTypeDefOrRefOrSpecThrowing(pModule, token, + &typeContext, + ClassLoader::ThrowIfNotFound, + ClassLoader::FailIfUninstDefOrRef); - OBJECTREF refType = th.GetManagedClassObject(); - gc.retVal->SetAt(--cMods, refType); + OBJECTREF refType = th.GetManagedClassObject(); + gc.retVal->SetAt(--cMods, refType); + } } } } @@ -2652,18 +2664,17 @@ FCIMPL2(FieldDesc*, RuntimeFieldHandle::GetStaticFieldForGenericType, FieldDesc } FCIMPLEND -FCIMPL1(ReflectModuleBaseObject*, AssemblyHandle::GetManifestModule, AssemblyBaseObject* pAssemblyUNSAFE) { +FCIMPL1(ReflectModuleBaseObject*, AssemblyHandle::GetManifestModule, AssemblyBaseObject* pAssemblyUNSAFE) +{ FCALL_CONTRACT; ASSEMBLYREF refAssembly = (ASSEMBLYREF)ObjectToOBJECTREF(pAssemblyUNSAFE); - if (refAssembly == NULL) - FCThrowRes(kArgumentNullException, W("Arg_InvalidHandle")); - - DomainAssembly *pAssembly = refAssembly->GetDomainAssembly(); - Assembly* currentAssembly = pAssembly->GetAssembly(); + return NULL; - FC_RETURN_MODULE_OBJECT(currentAssembly->GetModule(), refAssembly); + Module* pModule = refAssembly->GetAssembly()->GetModule(); + OBJECTREF refModule = pModule->GetExposedObjectIfExists(); + return (ReflectModuleBaseObject*)OBJECTREFToObject(refModule); } FCIMPLEND @@ -2675,10 +2686,8 @@ FCIMPL1(INT32, AssemblyHandle::GetToken, AssemblyBaseObject* pAssemblyUNSAFE) { if (refAssembly == NULL) FCThrowRes(kArgumentNullException, W("Arg_InvalidHandle")); - DomainAssembly *pAssembly = refAssembly->GetDomainAssembly(); mdAssembly token = mdAssemblyNil; - - IMDInternalImport *mdImport = pAssembly->GetAssembly()->GetMDImport(); + IMDInternalImport *mdImport = refAssembly->GetAssembly()->GetMDImport(); if (mdImport != 0) { @@ -2692,6 +2701,20 @@ FCIMPL1(INT32, AssemblyHandle::GetToken, AssemblyBaseObject* pAssemblyUNSAFE) { } FCIMPLEND +extern "C" void QCALLTYPE AssemblyHandle_GetManifestModuleSlow(QCall::ObjectHandleOnStack assembly, QCall::ObjectHandleOnStack module) +{ + QCALL_CONTRACT; + + BEGIN_QCALL; + GCX_COOP(); + + if (assembly.Get() == NULL) + COMPlusThrow(kArgumentNullException, W("Arg_InvalidHandle")); + + Module* pModule = ((ASSEMBLYREF)assembly.Get())->GetAssembly()->GetModule(); + module.Set(pModule->GetExposedObject()); + END_QCALL; +} extern "C" void QCALLTYPE ModuleHandle_GetPEKind(QCall::ModuleHandle pModule, DWORD* pdwPEKind, DWORD* pdwMachine) { @@ -2821,13 +2844,13 @@ extern "C" void QCALLTYPE ModuleHandle_GetAssembly(QCall::ModuleHandle pModule, { QCALL_CONTRACT; - DomainAssembly *pAssembly = NULL; + Assembly *pAssembly = NULL; BEGIN_QCALL; - pAssembly = pModule->GetDomainAssembly(); + pAssembly = pModule->GetAssembly(); GCX_COOP(); - retAssembly.Set(pAssembly->GetExposedAssemblyObject()); + retAssembly.Set(pAssembly->GetExposedObject()); END_QCALL; return; @@ -2864,8 +2887,6 @@ FCIMPL5(ReflectMethodObject*, ModuleHandle::GetDynamicMethod, ReflectMethodObjec HELPER_METHOD_FRAME_BEGIN_RET_PROTECT(gc); - DomainAssembly *pDomainModule = pModule->GetDomainAssembly(); - U1ARRAYREF dataArray = (U1ARRAYREF)sig; DWORD sigSize = dataArray->GetNumComponents(); NewArrayHolder pSig(new BYTE[sigSize]); @@ -2878,7 +2899,7 @@ FCIMPL5(ReflectMethodObject*, ModuleHandle::GetDynamicMethod, ReflectMethodObjec if (length) pName[length / sizeof(char)] = '\0'; - DynamicMethodTable *pMTForDynamicMethods = pDomainModule->GetDynamicMethodTable(); + DynamicMethodTable *pMTForDynamicMethods = pModule->GetDynamicMethodTable(); pNewMD = pMTForDynamicMethods->GetDynamicMethod(pSig, sigSize, pName); _ASSERTE(pNewMD != NULL); // pNewMD now owns pSig and pName. diff --git a/src/coreclr/vm/runtimehandles.h b/src/coreclr/vm/runtimehandles.h index 98cfff8d888..fd6661b791c 100644 --- a/src/coreclr/vm/runtimehandles.h +++ b/src/coreclr/vm/runtimehandles.h @@ -119,9 +119,9 @@ class RuntimeTypeHandle { static FCDECL2(FC_BOOL_RET, IsEquivalentTo, ReflectClassBaseObject *rtType1UNSAFE, ReflectClassBaseObject *rtType2UNSAFE); - static FCDECL1(AssemblyBaseObject*, GetAssembly, ReflectClassBaseObject *pType); + static FCDECL1(AssemblyBaseObject*, GetAssemblyIfExists, ReflectClassBaseObject *pType); static FCDECL1(ReflectClassBaseObject*, GetBaseType, ReflectClassBaseObject* pType); - static FCDECL1(ReflectModuleBaseObject*, GetModule, ReflectClassBaseObject* pType); + static FCDECL1(ReflectModuleBaseObject*, GetModuleIfExists, ReflectClassBaseObject* pType); static FCDECL1(INT32, GetAttributes, ReflectClassBaseObject* pType); static FCDECL1(INT32, GetToken, ReflectClassBaseObject* pType); static FCDECL1(LPCUTF8, GetUtf8Name, ReflectClassBaseObject* pType); @@ -191,6 +191,8 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_GetInstantiation(QCall::TypeHandle p extern "C" void QCALLTYPE RuntimeTypeHandle_Instantiate(QCall::TypeHandle pTypeHandle, TypeHandle * pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack retType); extern "C" void QCALLTYPE RuntimeTypeHandle_GetGenericTypeDefinition(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType); extern "C" void QCALLTYPE RuntimeTypeHandle_GetConstraints(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retTypes); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetAssemblySlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack assembly); +extern "C" void QCALLTYPE RuntimeTypeHandle_GetModuleSlow(QCall::ObjectHandleOnStack type, QCall::ObjectHandleOnStack module); extern "C" INT32 QCALLTYPE RuntimeTypeHandle_GetNumVirtualsAndStaticVirtuals(QCall::TypeHandle pTypeHandle); extern "C" void QCALLTYPE RuntimeTypeHandle_VerifyInterfaceIsImplemented(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pIFaceHandle); extern "C" MethodDesc* QCALLTYPE RuntimeTypeHandle_GetInterfaceMethodImplementation(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pOwner, MethodDesc * pMD); @@ -199,7 +201,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_RegisterCollectibleTypeDependency(QC class RuntimeMethodHandle { public: - static FCDECL4(Object*, InvokeMethod, Object *target, PVOID* args, SignatureNative* pSig, CLR_BOOL fConstructor); + static FCDECL4(Object*, InvokeMethod, Object *target, PVOID* args, SignatureNative* pSig, FC_BOOL_ARG fConstructor); static FCDECL2(Object*, ReboxToNullable, Object *pBoxedValUNSAFE, ReflectClassBaseObject *pDestUNSAFE); static FCDECL1(Object*, ReboxFromNullable, Object *pBoxedValUNSAFE); @@ -330,14 +332,15 @@ extern "C" void QCALLTYPE ModuleHandle_GetAssembly(QCall::ModuleHandle pModule, extern "C" void QCALLTYPE ModuleHandle_GetPEKind(QCall::ModuleHandle pModule, DWORD* pdwPEKind, DWORD* pdwMachine); -class AssemblyHandle { - +class AssemblyHandle +{ public: static FCDECL1(ReflectModuleBaseObject*, GetManifestModule, AssemblyBaseObject *pAssemblyUNSAFE); - static FCDECL1(INT32, GetToken, AssemblyBaseObject *pAssemblyUNSAFE); }; +extern "C" void QCALLTYPE AssemblyHandle_GetManifestModuleSlow(QCall::ObjectHandleOnStack assembly, QCall::ObjectHandleOnStack module); + class SignatureNative; typedef DPTR(SignatureNative) PTR_SignatureNative; @@ -368,7 +371,7 @@ class SignatureNative : public Object static FCDECL2(FC_INT8_RET, GetCallingConventionFromFunctionPointerAtOffset, SignatureNative* pSig, INT32 offset); - static FCDECL3(Object *, GetCustomModifiersAtOffset, SignatureNative* pSig, INT32 offset, CLR_BOOL fRequired); + static FCDECL3(Object *, GetCustomModifiersAtOffset, SignatureNative* pSig, INT32 offset, FC_BOOL_ARG fRequired); BOOL HasThis() { LIMITED_METHOD_CONTRACT; return (m_managedCallingConvention & CALLCONV_HasThis); } INT32 NumFixedArgs() { WRAPPER_NO_CONTRACT; return m_PtrArrayarguments->GetNumComponents(); } diff --git a/src/coreclr/vm/siginfo.cpp b/src/coreclr/vm/siginfo.cpp index facb809cd48..ce791517e62 100644 --- a/src/coreclr/vm/siginfo.cpp +++ b/src/coreclr/vm/siginfo.cpp @@ -126,6 +126,7 @@ DEFINEELEMENTTYPEINFO(ELEMENT_TYPE_MVAR, -1, TYPE_GC DEFINEELEMENTTYPEINFO(ELEMENT_TYPE_CMOD_REQD, -1, TYPE_GC_NONE, 1) DEFINEELEMENTTYPEINFO(ELEMENT_TYPE_CMOD_OPT, -1, TYPE_GC_NONE, 1) DEFINEELEMENTTYPEINFO(ELEMENT_TYPE_INTERNAL, -1, TYPE_GC_NONE, 0) +DEFINEELEMENTTYPEINFO(ELEMENT_TYPE_CMOD_INTERNAL, -1, TYPE_GC_NONE, 0) }; unsigned GetSizeForCorElementType(CorElementType etyp) @@ -152,8 +153,9 @@ void SigPointer::ConvertToInternalExactlyOne(Module* pSigModule, SigTypeContext CorElementType typ = ELEMENT_TYPE_END; - // Check whether we need to skip custom modifier - // Only preserve custom modifier when calculating IL stub hash blob + // If we don't have a token lookup map, skip custom modifiers. + // We can't accurately represent them in the internal signature unless we can + // resolve tokens through a token lookup map. if (bSkipCustomModifier) { // GetElemType eats sentinel and custom modifiers @@ -180,6 +182,17 @@ void SigPointer::ConvertToInternalExactlyOne(Module* pSigModule, SigTypeContext return; } + if (typ == ELEMENT_TYPE_CMOD_REQD || typ == ELEMENT_TYPE_CMOD_OPT) + { + mdToken tk; + IfFailThrowBF(GetToken(&tk), BFA_BAD_COMPLUS_SIG, pSigModule); + TypeHandle th = ClassLoader::LoadTypeDefOrRefThrowing(pSigModule, tk); + pSigBuilder->AppendElementType(ELEMENT_TYPE_CMOD_INTERNAL); + pSigBuilder->AppendByte(typ == ELEMENT_TYPE_CMOD_REQD); // "is required" byte + pSigBuilder->AppendPointer(th.AsPtr()); + return ConvertToInternalExactlyOne(pSigModule, pTypeContext, pSigBuilder, bSkipCustomModifier); + } + if (pTypeContext != NULL) { uint32_t varNum; @@ -272,6 +285,29 @@ void SigPointer::ConvertToInternalExactlyOne(Module* pSigModule, SigTypeContext } break; + case ELEMENT_TYPE_CMOD_INTERNAL: + { + uint8_t required; + IfFailThrowBF(GetByte(&required), BFA_BAD_COMPLUS_SIG, pSigModule); + pSigBuilder->AppendByte(required); + + // this check is not functional in DAC and provides no security against a malicious dump + // the DAC is prepared to receive an invalid type handle +#ifndef DACCESS_COMPILE + if (pSigModule->IsSigInIL(m_ptr)) + THROW_BAD_FORMAT(BFA_BAD_COMPLUS_SIG, pSigModule); +#endif + + TypeHandle hType; + + IfFailThrowBF(GetPointer((void**)&hType), BFA_BAD_COMPLUS_SIG, pSigModule); + + pSigBuilder->AppendPointer(hType.AsPtr()); + + ConvertToInternalExactlyOne(pSigModule, pTypeContext, pSigBuilder, bSkipCustomModifier); + } + break; + case ELEMENT_TYPE_INTERNAL: { // this check is not functional in DAC and provides no security against a malicious dump @@ -306,20 +342,6 @@ void SigPointer::ConvertToInternalExactlyOne(Module* pSigModule, SigTypeContext } } break; - - // Note: the following is only for correctly computing IL stub hash for modifiers in order to support C++ scenarios - case ELEMENT_TYPE_CMOD_OPT: - case ELEMENT_TYPE_CMOD_REQD: - { - mdToken tk; - IfFailThrowBF(GetToken(&tk), BFA_BAD_COMPLUS_SIG, pSigModule); - TypeHandle th = ClassLoader::LoadTypeDefOrRefThrowing(pSigModule, tk); - pSigBuilder->AppendElementType(ELEMENT_TYPE_INTERNAL); - pSigBuilder->AppendPointer(th.AsPtr()); - - ConvertToInternalExactlyOne(pSigModule, pTypeContext, pSigBuilder, bSkipCustomModifier); - } - break; } } } @@ -937,6 +959,25 @@ IsTypeRefOrDef( return(true); } // IsTypeRefOrDef +BOOL IsTypeRefOrDef( + LPCSTR szClassName, + DynamicResolver * pResolver, + mdToken token) +{ + STANDARD_VM_CONTRACT; + + ResolvedToken resolved; + pResolver->ResolveToken(token, &resolved); + + if (resolved.TypeHandle.IsNull()) + return false; + + DefineFullyQualifiedNameForClassOnStack(); + LPCUTF8 fullyQualifiedName = GetFullyQualifiedNameForClass(resolved.TypeHandle.GetMethodTable()); + + return (strcmp(szClassName, fullyQualifiedName) == 0); +} + TypeHandle SigPointer::GetTypeHandleNT(Module* pModule, const SigTypeContext *pTypeContext) const { @@ -2282,7 +2323,7 @@ BOOL SigPointer::IsClassHelper(Module* pModule, LPCUTF8 szClassName, const SigTy //------------------------------------------------------------------------ // Tests for the existence of a custom modifier //------------------------------------------------------------------------ -BOOL SigPointer::HasCustomModifier(Module *pModule, LPCSTR szModName, CorElementType cmodtype) const +BOOL SigPointer::HasCustomModifier(Module *pModule, LPCSTR szModName, CorElementType cmodtype, Module** pModifierScope, mdToken* pModifierType) const { CONTRACTL { @@ -2310,14 +2351,41 @@ BOOL SigPointer::HasCustomModifier(Module *pModule, LPCSTR szModName, CorElement etyp = (CorElementType)data; - while (etyp == ELEMENT_TYPE_CMOD_OPT || etyp == ELEMENT_TYPE_CMOD_REQD) { - + while (etyp == ELEMENT_TYPE_CMOD_OPT || etyp == ELEMENT_TYPE_CMOD_REQD || etyp == ELEMENT_TYPE_CMOD_INTERNAL) { + Module* lookupModule = pModule; mdToken tk; - if (FAILED(sp.GetToken(&tk))) - return FALSE; - if (etyp == cmodtype && IsTypeRefOrDef(szModName, pModule, tk)) + if (etyp == ELEMENT_TYPE_CMOD_INTERNAL) + { + uint8_t required; + if (FAILED(sp.GetByte(&required))) + return FALSE; + + void* typeHandle; + if (FAILED(sp.GetPointer(&typeHandle))) + return FALSE; + + TypeHandle type = TypeHandle::FromPtr(typeHandle); + tk = type.GetCl(); + lookupModule = type.GetModule(); + etyp = required ? ELEMENT_TYPE_CMOD_REQD : ELEMENT_TYPE_CMOD_OPT; + } + else + { + if (FAILED(sp.GetToken(&tk))) + return FALSE; + } + + if (etyp == cmodtype && IsTypeRefOrDef(szModName, lookupModule, tk)) { + if (pModifierScope != nullptr) + { + *pModifierScope = lookupModule; + } + if (pModifierType != nullptr) + { + *pModifierType = tk; + } return(TRUE); } @@ -3205,11 +3273,6 @@ BOOL IsTypeDefEquivalent(mdToken tk, Module *pModule) if (!IsTypeDefExternallyVisible(tk, pModule, dwAttrType)) return FALSE; - // since the token has not been loaded yet, - // its module might be not fully initialized in this domain - // take care of that possibility - pModule->EnsureAllocated(); - // 6. If type is nested, nesting type must be equivalent. if (IsTdNested(dwAttrType)) { @@ -3607,6 +3670,7 @@ BOOL CompareTypeTokens(mdToken tk1, mdToken tk2, ModuleBase *pModule1, ModuleBas static void ConsumeCustomModifiers(PCCOR_SIGNATURE& pSig, PCCOR_SIGNATURE pEndSig) { mdToken tk; + void* ptr; CorElementType type; PCCOR_SIGNATURE pSigTmp = pSig; @@ -3617,6 +3681,15 @@ static void ConsumeCustomModifiers(PCCOR_SIGNATURE& pSig, PCCOR_SIGNATURE pEndSi switch (type) { + case ELEMENT_TYPE_CMOD_INTERNAL: + if (pSigTmp + 1 > pEndSig) + { + IfFailThrow(META_E_BAD_SIGNATURE); + } + pSigTmp++; // Skip the required bit + IfFailThrow(CorSigUncompressPointer_EndPtr(pSigTmp, pEndSig, &ptr)); + pSig = pSigTmp; + break; case ELEMENT_TYPE_CMOD_REQD: case ELEMENT_TYPE_CMOD_OPT: IfFailThrow(CorSigUncompressToken_EndPtr(pSigTmp, pEndSig, &tk)); @@ -3828,6 +3901,71 @@ MetaSig::CompareElementType( } } + if (Type1 == ELEMENT_TYPE_CMOD_INTERNAL || Type2 == ELEMENT_TYPE_CMOD_INTERNAL) + { + bool internalRequired; + TypeHandle hInternal; + CorElementType eOtherType; + ModuleBase * pOtherModule; + + // One type is already loaded, collect all the necessary information to identify the other type. + if (Type1 == ELEMENT_TYPE_CMOD_INTERNAL) + { + if (pSig1 + 1 > pEndSig1) + { + IfFailThrow(META_E_BAD_SIGNATURE); + } + internalRequired = *pSig1++; + IfFailThrow(CorSigUncompressPointer_EndPtr(pSig1, pEndSig1, (void**)&hInternal)); + + eOtherType = Type2; + pOtherModule = pModule2; + } + else + { + if (pSig2 + 1 > pEndSig2) + { + IfFailThrow(META_E_BAD_SIGNATURE); + } + internalRequired = *pSig2++; + IfFailThrow(CorSigUncompressPointer_EndPtr(pSig2, pEndSig2, (void **)&hInternal)); + + eOtherType = Type1; + pOtherModule = pModule1; + } + + if (internalRequired && (eOtherType != ELEMENT_TYPE_CMOD_REQD)) + { + return FALSE; + } + else if (!internalRequired && (eOtherType != ELEMENT_TYPE_CMOD_OPT)) + { + return FALSE; + } + + mdToken tkOther; + if (Type1 == ELEMENT_TYPE_CMOD_INTERNAL) + { + IfFailThrow(CorSigUncompressToken_EndPtr(pSig2, pEndSig2, &tkOther)); + } + else + { + IfFailThrow(CorSigUncompressToken_EndPtr(pSig1, pEndSig1, &tkOther)); + } + + TypeHandle hOtherType = ClassLoader::LoadTypeDefOrRefThrowing( + pOtherModule, + tkOther, + ClassLoader::ReturnNullIfNotFound, + ClassLoader::FailIfUninstDefOrRef); + + if (hInternal != hOtherType) + { + return FALSE; + } + goto redo; + + } return FALSE; // types must be the same } @@ -4144,6 +4282,39 @@ MetaSig::CompareElementType( return (hType1 == hType2); } + case ELEMENT_TYPE_CMOD_INTERNAL: + { + uint8_t required1, required2; + + if (pSig1 + 1 > pEndSig1) + { + IfFailThrow(META_E_BAD_SIGNATURE); + } + required1 = *pSig1++; + + if (pSig2 + 1 > pEndSig2) + { + IfFailThrow(META_E_BAD_SIGNATURE); + } + required2 = *pSig2++; + + if (required1 != required2) + { + return FALSE; + } + + TypeHandle hType1, hType2; + + IfFailThrow(CorSigUncompressPointer_EndPtr(pSig1, pEndSig1, (void **)&hType1)); + IfFailThrow(CorSigUncompressPointer_EndPtr(pSig2, pEndSig2, (void **)&hType2)); + + if (hType1 != hType2) + { + return FALSE; + } + + goto redo; + } } // switch // Unreachable UNREACHABLE(); diff --git a/src/coreclr/vm/siginfo.hpp b/src/coreclr/vm/siginfo.hpp index fab9a79260d..5715eee6366 100644 --- a/src/coreclr/vm/siginfo.hpp +++ b/src/coreclr/vm/siginfo.hpp @@ -49,6 +49,8 @@ unsigned GetSizeForCorElementType(CorElementType etyp); class SigBuilder; class ArgDestination; +class TokenLookupMap; +class DynamicResolver; typedef const struct HardCodedMetaSig *LPHARDCODEDMETASIG; @@ -277,7 +279,7 @@ class SigPointer : public SigParser //------------------------------------------------------------------------ // Tests for the existence of a custom modifier //------------------------------------------------------------------------ - BOOL HasCustomModifier(Module *pModule, LPCSTR szModName, CorElementType cmodtype) const; + BOOL HasCustomModifier(Module *pModule, LPCSTR szModName, CorElementType cmodtype, Module** pModifierScope = NULL, mdToken* pModifierType = NULL) const; //------------------------------------------------------------------------ // Tests for ELEMENT_TYPE_CLASS or ELEMENT_TYPE_VALUETYPE followed by a TypeDef, diff --git a/src/coreclr/vm/stringliteralmap.cpp b/src/coreclr/vm/stringliteralmap.cpp index 168ab5503f4..ba1937f4f3e 100644 --- a/src/coreclr/vm/stringliteralmap.cpp +++ b/src/coreclr/vm/stringliteralmap.cpp @@ -298,7 +298,7 @@ GlobalStringLiteralMap::GlobalStringLiteralMap() : m_StringToEntryHashTable(NULL) , m_MemoryPool(NULL) , m_HashTableCrstGlobal(CrstGlobalStrLiteralMap) -, m_PinnedHeapHandleTable(SystemDomain::System(), GLOBAL_STRING_TABLE_BUCKET_SIZE) +, m_PinnedHeapHandleTable(GLOBAL_STRING_TABLE_BUCKET_SIZE) { CONTRACTL { diff --git a/src/coreclr/vm/stubgen.cpp b/src/coreclr/vm/stubgen.cpp index 283b6d3fa2d..4692bfb3a4c 100644 --- a/src/coreclr/vm/stubgen.cpp +++ b/src/coreclr/vm/stubgen.cpp @@ -1177,6 +1177,11 @@ void ILCodeStream::EmitBNE_UN(ILCodeLabel* pCodeLabel) WRAPPER_NO_CONTRACT; Emit(CEE_BNE_UN, -2, (UINT_PTR)pCodeLabel); } +void ILCodeStream::EmitBOX(int token) +{ + WRAPPER_NO_CONTRACT; + Emit(CEE_BOX, 0, token); +} void ILCodeStream::EmitBR(ILCodeLabel* pCodeLabel) { WRAPPER_NO_CONTRACT; @@ -1812,6 +1817,11 @@ void ILCodeStream::EmitUNALIGNED(BYTE alignment) Emit(CEE_UNALIGNED, 0, alignment); } +void ILCodeStream::EmitUNBOX_ANY(int token) +{ + WRAPPER_NO_CONTRACT; + Emit(CEE_UNBOX_ANY, 0, token); +} void ILCodeStream::EmitNEWOBJ(BinderMethodID id, int numInArgs) { @@ -1938,7 +1948,13 @@ DWORD StubSigBuilder::Append(LocalDesc* pLoc) } CONTRACTL_END; - EnsureEnoughQuickBytes(pLoc->cbType + sizeof(TypeHandle)); + // Ensure we have enough bytes for the provided signature, + // the handle for ELEMENT_TYPE_INTERNAL, + // and the byte and handle for ELEMENT_TYPE_CMOD_INTERNAL + const size_t InternalPayloadSize = sizeof(TypeHandle); + const size_t CModInternalPayloadSize = sizeof(BYTE) + sizeof(TypeHandle); + EnsureEnoughQuickBytes(pLoc->cbType + InternalPayloadSize + CModInternalPayloadSize); + BYTE* pbSigStart = m_pbSigCursor; memcpyNoGCRefs(m_pbSigCursor, pLoc->ElementType, pLoc->cbType); m_pbSigCursor += pLoc->cbType; @@ -1958,6 +1974,23 @@ DWORD StubSigBuilder::Append(LocalDesc* pLoc) m_pbSigCursor += sizeof(TypeHandle); m_cbSig += sizeof(TypeHandle); break; + + case ELEMENT_TYPE_CMOD_INTERNAL: + { + // Nove later elements in the signature to make room for the CMOD_INTERNAL payload + memmove(pbSigStart + i + 1 + CModInternalPayloadSize, pbSigStart + i + 1, pLoc->cbType - i - 1); + _ASSERTE(pbSigStart[i] == ELEMENT_TYPE_CMOD_INTERNAL); + BYTE* pbSigInternalPayload = pbSigStart + i + 1; + + // Write the "required" byte + *pbSigInternalPayload++ = pLoc->InternalModifierRequired ? 1 : 0; + + // Write the modifier + SET_UNALIGNED_PTR(pbSigInternalPayload, (UINT_PTR)pLoc->InternalModifierToken.AsPtr()); + m_pbSigCursor += CModInternalPayloadSize; + m_cbSig += CModInternalPayloadSize; + break; + } case ELEMENT_TYPE_FNPTR: { @@ -2083,9 +2116,27 @@ void FunctionSigBuilder::SetReturnType(LocalDesc* pLoc) { case ELEMENT_TYPE_INTERNAL: m_qbReturnSig.ReSizeThrows(m_qbReturnSig.Size() + sizeof(TypeHandle)); - SET_UNALIGNED_PTR((BYTE *)m_qbReturnSig.Ptr() + m_qbReturnSig.Size() - + sizeof(TypeHandle), (UINT_PTR)pLoc->InternalToken.AsPtr()); + SET_UNALIGNED_PTR((BYTE *)m_qbReturnSig.Ptr() + m_qbReturnSig.Size() - sizeof(TypeHandle), (UINT_PTR)pLoc->InternalToken.AsPtr()); break; + case ELEMENT_TYPE_CMOD_INTERNAL: + { + // Nove later elements in the signature to make room for the CMOD_INTERNAL payload + const size_t CModInternalPayloadSize = sizeof(BYTE) + sizeof(TypeHandle); + m_qbReturnSig.ReSizeThrows(m_qbReturnSig.Size() + CModInternalPayloadSize); + BYTE* pbSigStart = (BYTE*)m_qbReturnSig.Ptr(); + memmove(pbSigStart + i + 1 + CModInternalPayloadSize, pbSigStart + i + 1, pLoc->cbType - i); + _ASSERTE(pbSigStart[i] == ELEMENT_TYPE_CMOD_INTERNAL); + BYTE* pbSigInternalPayload = pbSigStart + i + 1; + + // Write the "required" byte + *pbSigInternalPayload++ = pLoc->InternalModifierRequired ? 1 : 0; + + // Write the modifier + SET_UNALIGNED_PTR(pbSigInternalPayload, (UINT_PTR)pLoc->InternalModifierToken.AsPtr()); + break; + } + case ELEMENT_TYPE_FNPTR: { SigPointer ptr(pLoc->pSig); @@ -2608,69 +2659,90 @@ void ILStubLinker::TransformArgForJIT(LocalDesc *pLoc) // byrefs which are OK only when they ref stack data or are pinned. This condition // cannot be verified by code:NDirect.MarshalingRequired so we explicitly get rid // of them here. - switch (pLoc->ElementType[0]) - { - // primitives - case ELEMENT_TYPE_VOID: - case ELEMENT_TYPE_BOOLEAN: - case ELEMENT_TYPE_CHAR: - case ELEMENT_TYPE_I1: - case ELEMENT_TYPE_U1: - case ELEMENT_TYPE_I2: - case ELEMENT_TYPE_U2: - case ELEMENT_TYPE_I4: - case ELEMENT_TYPE_U4: - case ELEMENT_TYPE_I8: - case ELEMENT_TYPE_U8: - case ELEMENT_TYPE_R4: - case ELEMENT_TYPE_R8: - case ELEMENT_TYPE_I: - case ELEMENT_TYPE_U: + bool again; + BYTE* elementType = pLoc->ElementType; + do + { + again = false; + switch (*elementType) { - // no transformation needed - break; - } + // primitives + case ELEMENT_TYPE_VOID: + case ELEMENT_TYPE_BOOLEAN: + case ELEMENT_TYPE_CHAR: + case ELEMENT_TYPE_I1: + case ELEMENT_TYPE_U1: + case ELEMENT_TYPE_I2: + case ELEMENT_TYPE_U2: + case ELEMENT_TYPE_I4: + case ELEMENT_TYPE_U4: + case ELEMENT_TYPE_I8: + case ELEMENT_TYPE_U8: + case ELEMENT_TYPE_R4: + case ELEMENT_TYPE_R8: + case ELEMENT_TYPE_I: + case ELEMENT_TYPE_U: + { + // no transformation needed + break; + } - case ELEMENT_TYPE_VALUETYPE: - { - _ASSERTE(!"Should have been replaced by a native value type!"); - break; - } + case ELEMENT_TYPE_VALUETYPE: + { + _ASSERTE(!"Should have been replaced by a native value type!"); + break; + } - case ELEMENT_TYPE_PTR: - { - // Don't transform pointer types to ELEMENT_TYPE_I. The JIT can handle the correct type information, - // and it's required for some cases (such as SwiftError*). - break; - } + case ELEMENT_TYPE_PTR: + { + // Don't transform pointer types to ELEMENT_TYPE_I. The JIT can handle the correct type information, + // and it's required for some cases (such as SwiftError*). + break; + } - case ELEMENT_TYPE_BYREF: - { - // Transform ELEMENT_TYPE_BYREF to ELEMENT_TYPE_PTR to retain the pointed-to type information - // while making the type blittable. - pLoc->ElementType[0] = ELEMENT_TYPE_PTR; - break; - } + case ELEMENT_TYPE_BYREF: + { + // Transform ELEMENT_TYPE_BYREF to ELEMENT_TYPE_PTR to retain the pointed-to type information + // while making the type blittable. + *elementType = ELEMENT_TYPE_PTR; + break; + } - case ELEMENT_TYPE_INTERNAL: - { - // JIT will handle structures - if (pLoc->InternalToken.IsValueType()) + case ELEMENT_TYPE_INTERNAL: + { + // JIT will handle structures + if (pLoc->InternalToken.IsValueType()) + { + _ASSERTE(pLoc->InternalToken.IsNativeValueType() || !pLoc->InternalToken.GetMethodTable()->ContainsGCPointers()); + break; + } + FALLTHROUGH; + } + + case ELEMENT_TYPE_CMOD_REQD: + case ELEMENT_TYPE_CMOD_OPT: + { + _ASSERTE("Custom modifiers should be represented in a LocalDesc as ELEMENT_TYPE_CMOD_INTERNAL. Use AddModifier to add custom modifiers."); + FALLTHROUGH; + } + case ELEMENT_TYPE_CMOD_INTERNAL: { - _ASSERTE(pLoc->InternalToken.IsNativeValueType() || !pLoc->InternalToken.GetMethodTable()->ContainsGCPointers()); + again = true; break; } - FALLTHROUGH; - } - // ref types -> ELEMENT_TYPE_I - default: - { - pLoc->ElementType[0] = ELEMENT_TYPE_I; - pLoc->cbType = 1; - break; + // ref types -> ELEMENT_TYPE_I + default: + { + pLoc->ElementType[0] = ELEMENT_TYPE_I; + pLoc->cbType = 1; + return; + } } + elementType++; + _ASSERTE(elementType - pLoc->ElementType <= (ptrdiff_t)pLoc->cbType); } + while(again); } Module *ILStubLinker::GetStubSigModule() diff --git a/src/coreclr/vm/stubgen.h b/src/coreclr/vm/stubgen.h index 968e5f9b482..ba42eae5be6 100644 --- a/src/coreclr/vm/stubgen.h +++ b/src/coreclr/vm/stubgen.h @@ -39,6 +39,10 @@ struct LocalDesc size_t cbType; TypeHandle InternalToken; // only valid with ELEMENT_TYPE_INTERNAL + // only valid with ELEMENT_TYPE_CMOD_INTERNAL + bool InternalModifierRequired; + TypeHandle InternalModifierToken; + // used only for E_T_FNPTR and E_T_ARRAY PCCOR_SIGNATURE pSig; union @@ -96,6 +100,14 @@ struct LocalDesc ChangeType(ELEMENT_TYPE_PTR); } + void AddModifier(bool required, TypeHandle thModifier) + { + _ASSERTE_MSG(InternalModifierToken.IsNull(), "Only one custom modifier is supported per element signature"); + ChangeType(ELEMENT_TYPE_CMOD_INTERNAL); + InternalModifierRequired = required; + InternalModifierToken = thModifier; + } + void ChangeType(CorElementType elemType) { LIMITED_METHOD_CONTRACT; @@ -267,7 +279,6 @@ class FunctionSigBuilder : protected StubSigBuilder #else // _DEBUG #define TOKEN_LOOKUP_MAP_SIZE (64*sizeof(void*)) #endif // _DEBUG - //--------------------------------------------------------------------------------------- // class TokenLookupMap @@ -841,6 +852,7 @@ class ILCodeStream void EmitBLE_UN (ILCodeLabel* pCodeLabel); void EmitBLT (ILCodeLabel* pCodeLabel); void EmitBNE_UN (ILCodeLabel* pCodeLabel); + void EmitBOX (int token); void EmitBR (ILCodeLabel* pCodeLabel); void EmitBREAK (); void EmitBRFALSE (ILCodeLabel* pCodeLabel); @@ -932,6 +944,7 @@ class ILCodeStream void EmitSUB (); void EmitTHROW (); void EmitUNALIGNED (BYTE alignment); + void EmitUNBOX_ANY (int token); // Overloads to simplify common usage patterns void EmitNEWOBJ (BinderMethodID id, int numInArgs); diff --git a/src/coreclr/vm/stubhelpers.cpp b/src/coreclr/vm/stubhelpers.cpp index eba0ee96a63..775c965c7a9 100644 --- a/src/coreclr/vm/stubhelpers.cpp +++ b/src/coreclr/vm/stubhelpers.cpp @@ -28,77 +28,58 @@ #ifdef VERIFY_HEAP -CQuickArray StubHelpers::s_ByrefValidationEntries; -SIZE_T StubHelpers::s_ByrefValidationIndex = 0; -CrstStatic StubHelpers::s_ByrefValidationLock; - -// static -void StubHelpers::Init() +struct ByrefValidationEntry final { - WRAPPER_NO_CONTRACT; - s_ByrefValidationLock.Init(CrstPinnedByrefValidation); -} + void *pByref; // pointer to GC heap + MethodDesc *pMD; // interop MD this byref was passed to +}; -// static -void StubHelpers::ValidateObjectInternal(Object *pObjUNSAFE, BOOL fValidateNextObj) -{ - CONTRACTL - { - NOTHROW; - GC_NOTRIGGER; - MODE_ANY; -} - CONTRACTL_END; - - _ASSERTE(GCHeapUtilities::GetGCHeap()->RuntimeStructuresValid()); - - // validate the object - there's no need to validate next object's - // header since we validate the next object explicitly below - if (pObjUNSAFE) - { - pObjUNSAFE->Validate(/*bDeep=*/ TRUE, /*bVerifyNextHeader=*/ FALSE, /*bVerifySyncBlock=*/ TRUE); - } - - // and the next object as required - if (fValidateNextObj) - { - Object *nextObj = GCHeapUtilities::GetGCHeap()->NextObj(pObjUNSAFE); - if (nextObj != NULL) - { - // Note that the MethodTable of the object (i.e. the pointer at offset 0) can change from - // g_pFreeObjectMethodTable to NULL, from NULL to , or possibly also from - // g_pFreeObjectMethodTable to concurrently while executing this function. - // Once is seen, we believe that the object should pass the Validate check. - // We have to be careful and read the pointer only once to avoid "phantom reads". - MethodTable *pMT = VolatileLoad(nextObj->GetMethodTablePtr()); - if (pMT != NULL && pMT != g_pFreeObjectMethodTable) - { - // do *not* verify the next object's syncblock - the next object is not guaranteed to - // be "alive" so the finalizer thread may have already released its syncblock - nextObj->Validate(/*bDeep=*/ TRUE, /*bVerifyNextHeader=*/ FALSE, /*bVerifySyncBlock=*/ FALSE); - } - } - } -} +static CQuickArray s_ByrefValidationEntries; +static SIZE_T s_ByrefValidationIndex = 0; +static CrstStatic s_ByrefValidationLock; -// static -MethodDesc *StubHelpers::ResolveInteropMethod(Object *pThisUNSAFE, MethodDesc *pMD) +static void ValidateObjectInternal(Object *pObjUNSAFE, BOOL fValidateNextObj) { - WRAPPER_NO_CONTRACT; + CONTRACTL + { + NOTHROW; + GC_NOTRIGGER; + MODE_ANY; + } + CONTRACTL_END; + + _ASSERTE(GCHeapUtilities::GetGCHeap()->RuntimeStructuresValid()); - if (pMD == NULL && pThisUNSAFE != NULL) + // validate the object - there's no need to validate next object's + // header since we validate the next object explicitly below + if (pObjUNSAFE) { - // if this is a call via delegate, get its Invoke method - MethodTable *pMT = pThisUNSAFE->GetMethodTable(); + pObjUNSAFE->Validate(/*bDeep=*/ TRUE, /*bVerifyNextHeader=*/ FALSE, /*bVerifySyncBlock=*/ TRUE); + } - _ASSERTE(pMT->IsDelegate()); - return ((DelegateEEClass *)pMT->GetClass())->GetInvokeMethod(); + // and the next object as required + if (fValidateNextObj) + { + Object *nextObj = GCHeapUtilities::GetGCHeap()->NextObj(pObjUNSAFE); + if (nextObj != NULL) + { + // Note that the MethodTable of the object (i.e. the pointer at offset 0) can change from + // g_pFreeObjectMethodTable to NULL, from NULL to , or possibly also from + // g_pFreeObjectMethodTable to concurrently while executing this function. + // Once is seen, we believe that the object should pass the Validate check. + // We have to be careful and read the pointer only once to avoid "phantom reads". + MethodTable *pMT = VolatileLoad(nextObj->GetMethodTablePtr()); + if (pMT != NULL && pMT != g_pFreeObjectMethodTable) + { + // do *not* verify the next object's syncblock - the next object is not guaranteed to + // be "alive" so the finalizer thread may have already released its syncblock + nextObj->Validate(/*bDeep=*/ TRUE, /*bVerifyNextHeader=*/ FALSE, /*bVerifySyncBlock=*/ FALSE); + } + } } - return pMD; } -// static -void StubHelpers::FormatValidationMessage(MethodDesc *pMD, SString &ssErrorString) +static void FormatValidationMessage(MethodDesc *pMD, SString &ssErrorString) { CONTRACTL { @@ -108,25 +89,25 @@ void StubHelpers::FormatValidationMessage(MethodDesc *pMD, SString &ssErrorStrin } CONTRACTL_END; - ssErrorString.Append(W("Detected managed heap corruption, likely culprit is interop call through ")); + ssErrorString.AppendUTF8("Detected managed heap corruption, likely culprit is interop call through "); if (pMD == NULL) { // the only case where we don't have interop MD is CALLI - ssErrorString.Append(W("CALLI.")); + ssErrorString.AppendUTF8("CALLI."); } else { - ssErrorString.Append(W("method '")); + ssErrorString.AppendUTF8("method '"); StackSString ssClassName; pMD->GetMethodTable()->_GetFullyQualifiedNameForClass(ssClassName); ssErrorString.Append(ssClassName); - ssErrorString.Append(NAMESPACE_SEPARATOR_CHAR); + ssErrorString.AppendUTF8(NAMESPACE_SEPARATOR_CHAR); ssErrorString.AppendUTF8(pMD->GetName()); - ssErrorString.Append(W("'.")); + ssErrorString.AppendUTF8("'."); } } @@ -178,6 +159,15 @@ void StubHelpers::ProcessByrefValidationList() #endif // VERIFY_HEAP +// static +void StubHelpers::Init() +{ + WRAPPER_NO_CONTRACT; +#ifdef VERIFY_HEAP + s_ByrefValidationLock.Init(CrstPinnedByrefValidation); +#endif // VERIFY_HEAP +} + #ifdef FEATURE_COMINTEROP FORCEINLINE static void GetCOMIPFromRCW_ClearFP() @@ -246,39 +236,10 @@ FORCEINLINE static void *GetCOMIPFromRCW_GetTarget(IUnknown *pUnk, CLRToCOMCallI { LIMITED_METHOD_CONTRACT; - LPVOID *lpVtbl = *(LPVOID **)pUnk; return lpVtbl[pComInfo->m_cachedComSlot]; } -NOINLINE static IUnknown* GetCOMIPFromRCWHelper(LPVOID pFCall, OBJECTREF pSrc, MethodDesc* pMD, void **ppTarget) -{ - FC_INNER_PROLOG(pFCall); - - IUnknown *pIntf = NULL; - - // This is only called in IL stubs which are in CER, so we don't need to worry about ThreadAbort - HELPER_METHOD_FRAME_BEGIN_RET_ATTRIB_1(Frame::FRAME_ATTR_NO_THREAD_ABORT|Frame::FRAME_ATTR_EXACT_DEPTH|Frame::FRAME_ATTR_CAPTURE_DEPTH_2, pSrc); - - SafeComHolder pRetUnk; - - CLRToCOMCallInfo *pComInfo = CLRToCOMCallInfo::FromMethodDesc(pMD); - pRetUnk = ComObject::GetComIPFromRCWThrowing(&pSrc, pComInfo->m_pInterfaceMT); - - *ppTarget = GetCOMIPFromRCW_GetTarget(pRetUnk, pComInfo); - _ASSERTE(*ppTarget != NULL); - - GetCOMIPFromRCW_ClearFP(); - - pIntf = pRetUnk.Extract(); - - // No exception will be thrown here (including thread abort as it is delayed in IL stubs) - HELPER_METHOD_FRAME_END(); - - FC_INNER_EPILOG(); - return pIntf; -} - //================================================================================================================== // The GetCOMIPFromRCW helper exists in four specialized versions to optimize CLR->COM perf. Please be careful when // changing this code as one of these methods is executed as part of every CLR->COM call so every instruction counts. @@ -289,7 +250,7 @@ NOINLINE static IUnknown* GetCOMIPFromRCWHelper(LPVOID pFCall, OBJECTREF pSrc, M // This helper can handle any CLR->COM call, it supports hosting, // and clears FP state on x86 for compatibility with VB6. -FCIMPL4(IUnknown*, StubHelpers::GetCOMIPFromRCW, Object* pSrcUNSAFE, MethodDesc* pMD, void **ppTarget, CLR_BOOL* pfNeedsRelease) +FCIMPL3(IUnknown*, StubHelpers::GetCOMIPFromRCW, Object* pSrcUNSAFE, MethodDesc* pMD, void **ppTarget) { CONTRACTL { @@ -299,13 +260,10 @@ FCIMPL4(IUnknown*, StubHelpers::GetCOMIPFromRCW, Object* pSrcUNSAFE, MethodDesc* CONTRACTL_END; OBJECTREF pSrc = ObjectToOBJECTREF(pSrcUNSAFE); - *pfNeedsRelease = false; - CLRToCOMCallInfo *pComInfo = CLRToCOMCallInfo::FromMethodDesc(pMD); RCW *pRCW = pSrc->PassiveGetSyncBlock()->GetInteropInfoNoCreate()->GetRawRCW(); if (pRCW != NULL) { - IUnknown * pUnk = GetCOMIPFromRCW_GetIUnknownFromRCWCache(pRCW, pComInfo->m_pInterfaceMT); if (pUnk != NULL) { @@ -317,15 +275,41 @@ FCIMPL4(IUnknown*, StubHelpers::GetCOMIPFromRCW, Object* pSrcUNSAFE, MethodDesc* } } } - - /* if we didn't find the COM interface pointer in the cache we will have to erect an HMF */ - *pfNeedsRelease = true; - FC_INNER_RETURN(IUnknown*, GetCOMIPFromRCWHelper(StubHelpers::GetCOMIPFromRCW, pSrc, pMD, ppTarget)); + return NULL; } FCIMPLEND #include +extern "C" IUnknown* QCALLTYPE StubHelpers_GetCOMIPFromRCWSlow(QCall::ObjectHandleOnStack pSrc, MethodDesc* pMD, void** ppTarget) +{ + QCALL_CONTRACT; + _ASSERTE(pMD != NULL); + _ASSERTE(ppTarget != NULL); + + IUnknown *pIntf = NULL; + BEGIN_QCALL; + + GCX_COOP(); + + OBJECTREF objRef = pSrc.Get(); + GCPROTECT_BEGIN(objRef); + + CLRToCOMCallInfo* pComInfo = CLRToCOMCallInfo::FromMethodDesc(pMD); + SafeComHolder pRetUnk = ComObject::GetComIPFromRCWThrowing(&objRef, pComInfo->m_pInterfaceMT); + *ppTarget = GetCOMIPFromRCW_GetTarget(pRetUnk, pComInfo); + _ASSERTE(*ppTarget != NULL); + + GetCOMIPFromRCW_ClearFP(); + pIntf = pRetUnk.Extract(); + + GCPROTECT_END(); + + END_QCALL; + + return pIntf; +} + extern "C" void QCALLTYPE ObjectMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pSrcUNSAFE, VARIANT* pDest) { QCALL_CONTRACT; @@ -498,241 +482,185 @@ extern "C" void QCALLTYPE StubHelpers_ThrowInteropParamException(INT resID, INT } #ifdef PROFILING_SUPPORTED -FCIMPL3(SIZE_T, StubHelpers::ProfilerBeginTransitionCallback, SIZE_T pSecretParam, Thread* pThread, Object* unsafe_pThis) +extern "C" void* QCALLTYPE StubHelpers_ProfilerBeginTransitionCallback(MethodDesc* pTargetMD) { - FCALL_CONTRACT; - - // We can get here with an ngen image generated with "/prof", - // even if the profiler doesn't want to track transitions. - if (!CORProfilerTrackTransitions()) - { - return 0; - } - - MethodDesc* pRealMD = NULL; - BEGIN_PRESERVE_LAST_ERROR; - // We must transition to preemptive GC mode before calling out to the profiler, - // and the transition requires us to set up a HMF. - DELEGATEREF dref = (DELEGATEREF)ObjectToOBJECTREF(unsafe_pThis); - HELPER_METHOD_FRAME_BEGIN_RET_1(dref); - - if (pSecretParam == 0) - { - // Secret param is null. This is the calli pinvoke case or the unmanaged delegate case. - // We have an unmanaged target address but no MD. For the unmanaged delegate case, we can - // still retrieve the MD by looking at the "this" object. - - if (dref == NULL) - { - // calli pinvoke case - pRealMD = NULL; - } - else - { - // unmanaged delegate case - MethodTable* pMT = dref->GetMethodTable(); - _ASSERTE(pMT->IsDelegate()); - - EEClass * pClass = pMT->GetClass(); - pRealMD = ((DelegateEEClass*)pClass)->GetInvokeMethod(); - _ASSERTE(pRealMD); - } - } - else - { - // This is either the COM interop or the pinvoke case. - pRealMD = (MethodDesc*)pSecretParam; - } + QCALL_CONTRACT; - { - _ASSERTE(pThread != nullptr); - GCX_PREEMP_THREAD_EXISTS(pThread); + BEGIN_QCALL; - ProfilerManagedToUnmanagedTransitionMD(pRealMD, COR_PRF_TRANSITION_CALL); - } + ProfilerManagedToUnmanagedTransitionMD(pTargetMD, COR_PRF_TRANSITION_CALL); - HELPER_METHOD_FRAME_END(); + END_QCALL; END_PRESERVE_LAST_ERROR; - return (SIZE_T)pRealMD; + return pTargetMD; } -FCIMPLEND -FCIMPL2(void, StubHelpers::ProfilerEndTransitionCallback, MethodDesc* pRealMD, Thread* pThread) +extern "C" void QCALLTYPE StubHelpers_ProfilerEndTransitionCallback(MethodDesc* pTargetMD) { - FCALL_CONTRACT; + BEGIN_PRESERVE_LAST_ERROR; - // We can get here with an ngen image generated with "/prof", - // even if the profiler doesn't want to track transitions. - if (!CORProfilerTrackTransitions()) - { - return; - } + QCALL_CONTRACT; - BEGIN_PRESERVE_LAST_ERROR; + BEGIN_QCALL; - // We must transition to preemptive GC mode before calling out to the profiler, - // and the transition requires us to set up a HMF. - HELPER_METHOD_FRAME_BEGIN_0(); - { - _ASSERTE(pThread != nullptr); - GCX_PREEMP_THREAD_EXISTS(pThread); + ProfilerUnmanagedToManagedTransitionMD(pTargetMD, COR_PRF_TRANSITION_RETURN); - ProfilerUnmanagedToManagedTransitionMD(pRealMD, COR_PRF_TRANSITION_RETURN); - } - HELPER_METHOD_FRAME_END(); + END_QCALL; END_PRESERVE_LAST_ERROR; } -FCIMPLEND #endif // PROFILING_SUPPORTED -FCIMPL1(Object*, StubHelpers::GetHRExceptionObject, HRESULT hr) +extern "C" void QCALLTYPE StubHelpers_GetHRExceptionObject(HRESULT hr, QCall::ObjectHandleOnStack result) { - FCALL_CONTRACT; + QCALL_CONTRACT; + + BEGIN_QCALL; + + GCX_COOP(); OBJECTREF oThrowable = NULL; + GCPROTECT_BEGIN(oThrowable); - HELPER_METHOD_FRAME_BEGIN_RET_1(oThrowable); - { - // GetExceptionForHR uses equivalant logic as COMPlusThrowHR - GetExceptionForHR(hr, &oThrowable); - } - HELPER_METHOD_FRAME_END(); + // GetExceptionForHR uses equivalant logic as COMPlusThrowHR + GetExceptionForHR(hr, &oThrowable); + result.Set(oThrowable); + + GCPROTECT_END(); - return OBJECTREFToObject(oThrowable); + END_QCALL; } -FCIMPLEND #ifdef FEATURE_COMINTEROP -FCIMPL3(Object*, StubHelpers::GetCOMHRExceptionObject, HRESULT hr, MethodDesc *pMD, Object *unsafe_pThis) +extern "C" void QCALLTYPE StubHelpers_GetCOMHRExceptionObject( + HRESULT hr, + MethodDesc* pMD, + QCall::ObjectHandleOnStack pThis, + QCall::ObjectHandleOnStack result) { - FCALL_CONTRACT; + QCALL_CONTRACT; - OBJECTREF oThrowable = NULL; + BEGIN_QCALL; - // get 'this' - OBJECTREF oref = ObjectToOBJECTREF(unsafe_pThis); + GCX_COOP(); - HELPER_METHOD_FRAME_BEGIN_RET_2(oref, oThrowable); + struct + { + OBJECTREF oThrowable; + OBJECTREF oref; + } gc; + gc.oThrowable = NULL; + gc.oref = NULL; + GCPROTECT_BEGIN(gc); + + IErrorInfo* pErrorInfo = NULL; + if (pMD != NULL) { - IErrorInfo *pErrInfo = NULL; + // Retrieve the interface method table. + MethodTable* pItfMT = CLRToCOMCallInfo::FromMethodDesc(pMD)->m_pInterfaceMT; - if (pMD != NULL) - { - // Retrieve the interface method table. - MethodTable *pItfMT = CLRToCOMCallInfo::FromMethodDesc(pMD)->m_pInterfaceMT; + // get 'this' + gc.oref = ObjectToOBJECTREF(pThis.Get()); - // Get IUnknown pointer for this interface on this object - IUnknown* pUnk = ComObject::GetComIPFromRCW(&oref, pItfMT); - if (pUnk != NULL) - { - // Check to see if the component supports error information for this interface. - IID ItfIID; - pItfMT->GetGuid(&ItfIID, TRUE); - pErrInfo = GetSupportedErrorInfo(pUnk, ItfIID); + // Get IUnknown pointer for this interface on this object + IUnknown* pUnk = ComObject::GetComIPFromRCW(&gc.oref, pItfMT); + if (pUnk != NULL) + { + // Check to see if the component supports error information for this interface. + IID ItfIID; + pItfMT->GetGuid(&ItfIID, TRUE); + pErrorInfo = GetSupportedErrorInfo(pUnk, ItfIID); - DWORD cbRef = SafeRelease(pUnk); - LogInteropRelease(pUnk, cbRef, "IUnk to QI for ISupportsErrorInfo"); - } + DWORD cbRef = SafeRelease(pUnk); + LogInteropRelease(pUnk, cbRef, "IUnk to QI for ISupportsErrorInfo"); } - - GetExceptionForHR(hr, pErrInfo, &oThrowable); } - HELPER_METHOD_FRAME_END(); - return OBJECTREFToObject(oThrowable); + // GetExceptionForHR will handle lifetime of IErrorInfo. + GetExceptionForHR(hr, pErrorInfo, &gc.oThrowable); + result.Set(gc.oThrowable); + + GCPROTECT_END(); + + END_QCALL; } -FCIMPLEND #endif // FEATURE_COMINTEROP -FCIMPL1(Object*, StubHelpers::AllocateInternal, EnregisteredTypeHandle pRegisteredTypeHnd) +extern "C" void QCALLTYPE StubHelpers_MarshalToManagedVaList(va_list va, VARARGS* pArgIterator) { - FCALL_CONTRACT; - - TypeHandle typeHnd = TypeHandle::FromPtr(pRegisteredTypeHnd); - OBJECTREF objRet = NULL; - HELPER_METHOD_FRAME_BEGIN_RET_1(objRet); - - MethodTable* pMT = typeHnd.GetMethodTable(); - objRet = pMT->Allocate(); - - HELPER_METHOD_FRAME_END(); + QCALL_CONTRACT; - return OBJECTREFToObject(objRet); + BEGIN_QCALL; + VARARGS::MarshalToManagedVaList(va, pArgIterator); + END_QCALL; } -FCIMPLEND -FCIMPL3(void, StubHelpers::MarshalToUnmanagedVaListInternal, va_list va, DWORD cbVaListSize, const VARARGS* pArgIterator) +extern "C" void QCALLTYPE StubHelpers_MarshalToUnmanagedVaList(va_list va, DWORD cbVaListSize, const VARARGS* pArgIterator) { - FCALL_CONTRACT; + QCALL_CONTRACT; - HELPER_METHOD_FRAME_BEGIN_0(); + BEGIN_QCALL; VARARGS::MarshalToUnmanagedVaList(va, cbVaListSize, pArgIterator); - HELPER_METHOD_FRAME_END(); + END_QCALL; } -FCIMPLEND -FCIMPL2(void, StubHelpers::MarshalToManagedVaListInternal, va_list va, VARARGS* pArgIterator) +extern "C" void QCALLTYPE StubHelpers_ValidateObject(QCall::ObjectHandleOnStack pObj, MethodDesc *pMD) { - FCALL_CONTRACT; - - VARARGS::MarshalToManagedVaList(va, pArgIterator); -} -FCIMPLEND + QCALL_CONTRACT; -FCIMPL3(void, StubHelpers::ValidateObject, Object *pObjUNSAFE, MethodDesc *pMD, Object *pThisUNSAFE) -{ - FCALL_CONTRACT; + BEGIN_QCALL; #ifdef VERIFY_HEAP - HELPER_METHOD_FRAME_BEGIN_0(); + GCX_COOP(); StackSString errorString; EX_TRY { AVInRuntimeImplOkayHolder AVOkay; - // don't validate the next object if a BGC is in progress. we can race with background - // sweep which could make the next object a Free object underneath us if it's dead. - ValidateObjectInternal(pObjUNSAFE, !(GCHeapUtilities::GetGCHeap()->IsConcurrentGCInProgress())); + // don't validate the next object if a BGC is in progress. we can race with background + // sweep which could make the next object a Free object underneath us if it's dead. + ValidateObjectInternal(OBJECTREFToObject(pObj.Get()), !(GCHeapUtilities::GetGCHeap()->IsConcurrentGCInProgress())); } EX_CATCH { - FormatValidationMessage(ResolveInteropMethod(pThisUNSAFE, pMD), errorString); + FormatValidationMessage(pMD, errorString); EEPOLICY_HANDLE_FATAL_ERROR_WITH_MESSAGE(COR_E_EXECUTIONENGINE, errorString.GetUnicode()); } EX_END_CATCH_UNREACHABLE; - HELPER_METHOD_FRAME_END(); #else // VERIFY_HEAP - FCUnique(0xa3); - UNREACHABLE_MSG("No validation support without VERIFY_HEAP"); + EEPOLICY_HANDLE_FATAL_ERROR_WITH_MESSAGE(COR_E_FAILFAST, "No validation support without VERIFY_HEAP"); #endif // VERIFY_HEAP + + END_QCALL; } -FCIMPLEND -FCIMPL3(void, StubHelpers::ValidateByref, void *pByref, MethodDesc *pMD, Object *pThisUNSAFE) +extern "C" void QCALLTYPE StubHelpers_ValidateByref(void *pByref, MethodDesc *pMD) { - FCALL_CONTRACT; - -#ifdef VERIFY_HEAP - // We cannot validate byrefs at this point as code:GCHeap.GetContainingObject could potentially race - // with allocations on other threads. We'll just remember this byref along with the interop MD and - // perform the validation on next GC (see code:StubHelpers.ProcessByrefValidationList). + QCALL_CONTRACT; // Skip byref if is not pointing inside managed heap if (!GCHeapUtilities::GetGCHeap()->IsHeapPointer(pByref)) { return; } + + BEGIN_QCALL; + +#ifdef VERIFY_HEAP + GCX_COOP(); + + // We cannot validate byrefs at this point as code:GCHeap.GetContainingObject could potentially race + // with allocations on other threads. We'll just remember this byref along with the interop MD and + // perform the validation on next GC (see code:StubHelpers.ProcessByrefValidationList). + ByrefValidationEntry entry; entry.pByref = pByref; - entry.pMD = ResolveInteropMethod(pThisUNSAFE, pMD); - - HELPER_METHOD_FRAME_BEGIN_0(); + entry.pMD = pMD; SIZE_T NumOfEntries = 0; { @@ -761,14 +689,12 @@ FCIMPL3(void, StubHelpers::ValidateByref, void *pByref, MethodDesc *pMD, Object // if the list is too big, trigger GC now GCHeapUtilities::GetGCHeap()->GarbageCollect(0); } - - HELPER_METHOD_FRAME_END(); #else // VERIFY_HEAP - FCUnique(0xa4); - UNREACHABLE_MSG("No validation support without VERIFY_HEAP"); + EEPOLICY_HANDLE_FATAL_ERROR_WITH_MESSAGE(COR_E_FAILFAST, "No validation support without VERIFY_HEAP"); #endif // VERIFY_HEAP + + END_QCALL; } -FCIMPLEND FCIMPL0(void*, StubHelpers::GetStubContext) { diff --git a/src/coreclr/vm/stubhelpers.h b/src/coreclr/vm/stubhelpers.h index 3a5c1f30e57..72f5102aa9c 100644 --- a/src/coreclr/vm/stubhelpers.h +++ b/src/coreclr/vm/stubhelpers.h @@ -15,27 +15,10 @@ class StubHelpers { -#ifdef VERIFY_HEAP - struct ByrefValidationEntry - { - void *pByref; // pointer to GC heap - MethodDesc *pMD; // interop MD this byref was passed to - }; - - static CQuickArray s_ByrefValidationEntries; - static SIZE_T s_ByrefValidationIndex; - static CrstStatic s_ByrefValidationLock; - - static void ValidateObjectInternal(Object *pObjUNSAFE, BOOL fValidateNextObj); - static MethodDesc *ResolveInteropMethod(Object *pThisUNSAFE, MethodDesc *pMD); - static void FormatValidationMessage(MethodDesc *pMD, SString &ssErrorString); - public: static void Init(); +#ifdef VERIFY_HEAP static void ProcessByrefValidationList(); -#else // VERIFY_HEAP -public: - static void Init() { LIMITED_METHOD_CONTRACT; } #endif // VERIFY_HEAP //------------------------------------------------------- @@ -43,7 +26,7 @@ class StubHelpers //------------------------------------------------------- #ifdef FEATURE_COMINTEROP - static FCDECL4(IUnknown*, GetCOMIPFromRCW, Object* pSrcUNSAFE, MethodDesc* pMD, void **ppTarget, CLR_BOOL* pfNeedsRelease); + static FCDECL3(IUnknown*, GetCOMIPFromRCW, Object* pSrcUNSAFE, MethodDesc* pMD, void **ppTarget); #endif // FEATURE_COMINTEROP static FCDECL0(void, SetLastError ); @@ -52,37 +35,29 @@ class StubHelpers static FCDECL2(FC_BOOL_RET, TryGetStringTrailByte, StringObject* thisRefUNSAFE, UINT8 *pbData); - static FCDECL1(Object*, GetHRExceptionObject, HRESULT hr); - -#ifdef FEATURE_COMINTEROP - static FCDECL3(Object*, GetCOMHRExceptionObject, HRESULT hr, MethodDesc *pMD, Object *unsafe_pThis); -#endif // FEATURE_COMINTEROP - - static FCDECL1(Object*, AllocateInternal, EnregisteredTypeHandle typeHnd); - static FCDECL3(void, MarshalToUnmanagedVaListInternal, va_list va, DWORD cbVaListSize, const VARARGS* pArgIterator); - static FCDECL2(void, MarshalToManagedVaListInternal, va_list va, VARARGS* pArgIterator); static FCDECL0(void*, GetStubContext); static FCDECL2(void, LogPinnedArgument, MethodDesc *localDesc, Object *nativeArg); static FCDECL1(DWORD, CalcVaListSize, VARARGS *varargs); - static FCDECL3(void, ValidateObject, Object *pObjUNSAFE, MethodDesc *pMD, Object *pThisUNSAFE); - static FCDECL3(void, ValidateByref, void *pByref, MethodDesc *pMD, Object *pThisUNSAFE); - -#ifdef PROFILING_SUPPORTED - //------------------------------------------------------- - // Profiler helper - //------------------------------------------------------- - static FCDECL3(SIZE_T, ProfilerBeginTransitionCallback, SIZE_T pSecretParam, Thread* pThread, Object* unsafe_pThis); - static FCDECL2(void, ProfilerEndTransitionCallback, MethodDesc* pRealMD, Thread* pThread); -#endif static FCDECL2(void, MulticastDebuggerTraceHelper, Object*, INT32); static FCDECL0(void*, NextCallReturnAddress); }; -extern "C" void* QCALLTYPE StubHelpers_CreateCustomMarshalerHelper(MethodDesc* pMD, mdToken paramToken, TypeHandle hndManagedType); +extern "C" void QCALLTYPE StubHelpers_CreateCustomMarshaler(MethodDesc* pMD, mdToken paramToken, TypeHandle hndManagedType, QCall::ObjectHandleOnStack retObject); + +#ifdef PROFILING_SUPPORTED +extern "C" void* QCALLTYPE StubHelpers_ProfilerBeginTransitionCallback(MethodDesc* pTargetMD); +extern "C" void QCALLTYPE StubHelpers_ProfilerEndTransitionCallback(MethodDesc* pTargetMD); +#endif + +extern "C" void QCALLTYPE StubHelpers_GetHRExceptionObject(HRESULT hr, QCall::ObjectHandleOnStack result); #ifdef FEATURE_COMINTEROP +extern "C" void QCALLTYPE StubHelpers_GetCOMHRExceptionObject(HRESULT hr, MethodDesc *pMD, QCall::ObjectHandleOnStack pThis, QCall::ObjectHandleOnStack result); + +extern "C" IUnknown* QCALLTYPE StubHelpers_GetCOMIPFromRCWSlow(QCall::ObjectHandleOnStack pSrc, MethodDesc* pMD, void** ppTarget); + extern "C" void QCALLTYPE ObjectMarshaler_ConvertToNative(QCall::ObjectHandleOnStack pSrcUNSAFE, VARIANT* pDest); extern "C" void QCALLTYPE ObjectMarshaler_ConvertToManaged(VARIANT* pSrc, QCall::ObjectHandleOnStack retObject); @@ -93,4 +68,10 @@ extern "C" void QCALLTYPE InterfaceMarshaler_ConvertToManaged(IUnknown** ppUnk, extern "C" void QCALLTYPE StubHelpers_SetStringTrailByte(QCall::StringHandleOnStack str, UINT8 bData); extern "C" void QCALLTYPE StubHelpers_ThrowInteropParamException(INT resID, INT paramIdx); +extern "C" void QCALLTYPE StubHelpers_MarshalToManagedVaList(va_list va, VARARGS* pArgIterator); +extern "C" void QCALLTYPE StubHelpers_MarshalToUnmanagedVaList(va_list va, DWORD cbVaListSize, const VARARGS* pArgIterator); + +extern "C" void QCALLTYPE StubHelpers_ValidateObject(QCall::ObjectHandleOnStack pObj, MethodDesc *pMD); +extern "C" void QCALLTYPE StubHelpers_ValidateByref(void *pByref, MethodDesc *pMD); + #endif // __STUBHELPERS_h__ diff --git a/src/coreclr/vm/stublink.cpp b/src/coreclr/vm/stublink.cpp index be99fec4577..efe9f73776a 100644 --- a/src/coreclr/vm/stublink.cpp +++ b/src/coreclr/vm/stublink.cpp @@ -350,7 +350,6 @@ StubLinker::StubLinker() m_pCodeElements = NULL; m_pFirstCodeLabel = NULL; m_pFirstLabelRef = NULL; - m_pPatchLabel = NULL; m_pTargetMethod = NULL; m_stackSize = 0; m_fDataOnly = FALSE; @@ -622,26 +621,6 @@ CodeLabel* StubLinker::EmitNewCodeLabel() } -//--------------------------------------------------------------- -// Creates & emits the patch offset label for the stub -//--------------------------------------------------------------- -VOID StubLinker::EmitPatchLabel() -{ - CONTRACTL - { - THROWS; - GC_NOTRIGGER; - } - CONTRACTL_END; - - // - // Note that it's OK to have re-emit the patch label, - // just use the later one. - // - - m_pPatchLabel = EmitNewCodeLabel(); -} - //--------------------------------------------------------------- // Returns final location of label as an offset from the start // of the stub. Can only be called after linkage. @@ -1099,31 +1078,15 @@ bool StubLinker::EmitStub(Stub* pStub, int globalsize, int totalSize, LoaderHeap ZeroMemory(pCodeRW + lastCodeOffset, globalsize - lastCodeOffset); } - // Set additional stub data. - // - Fill in the target method for the Instantiating stub. - // - // - Fill in patch offset, if we have one - // Note that these offsets are relative to the start of the stub, - // not the code, so you'll have to add sizeof(Stub) to get to the - // right spot. + // Fill in the target method for the Instantiating stub. if (pStubRW->IsInstantiatingStub()) { _ASSERTE(m_pTargetMethod != NULL); - _ASSERTE(m_pPatchLabel == NULL); pStubRW->SetInstantiatedMethodDesc(m_pTargetMethod); LOG((LF_CORDB, LL_INFO100, "SL::ES: InstantiatedMethod fd:0x%x\n", pStub->GetInstantiatedMethodDesc())); } - else if (m_pPatchLabel != NULL) - { - UINT32 uLabelOffset = GetLabelOffset(m_pPatchLabel); - _ASSERTE(FitsIn(uLabelOffset)); - pStubRW->SetPatchOffset(static_cast(uLabelOffset)); - - LOG((LF_CORDB, LL_INFO100, "SL::ES: patch offset:0x%x\n", - pStub->GetPatchOffset())); - } #ifdef STUBLINKER_GENERATES_UNWIND_INFO if (pStub->HasUnwindInfo()) @@ -2260,8 +2223,8 @@ void Stub::SetupStub(int numCodeBytes, DWORD flags m_numCodeBytesAndFlags |= EXTERNAL_ENTRY_BIT; if ((flags & NEWSTUB_FL_INSTANTIATING_METHOD) != 0) m_numCodeBytesAndFlags |= INSTANTIATING_STUB_BIT; - if ((flags & NEWSTUB_FL_THUNK) != 0) - m_numCodeBytesAndFlags |= THUNK_BIT; + if ((flags & NEWSTUB_FL_SHUFFLE_THUNK) != 0) + m_numCodeBytesAndFlags |= SHUFFLE_THUNK_BIT; } #ifdef STUBLINKER_GENERATES_UNWIND_INFO diff --git a/src/coreclr/vm/stublink.h b/src/coreclr/vm/stublink.h index 3d01f2b6561..4856aa2e709 100644 --- a/src/coreclr/vm/stublink.h +++ b/src/coreclr/vm/stublink.h @@ -184,12 +184,6 @@ class StubLinker //--------------------------------------------------------------- VOID EmitLabel(CodeLabel* pCodeLabel); - //--------------------------------------------------------------- - // Emits the patch label for the stub. - // Throws exception on failure. - //--------------------------------------------------------------- - void EmitPatchLabel(); - //--------------------------------------------------------------- // Create a new label to an external address. // Throws exception on failure. @@ -280,9 +274,6 @@ class StubLinker CodeElement *m_pCodeElements; // stored in *reverse* order CodeLabel *m_pFirstCodeLabel; // linked list of CodeLabels LabelRef *m_pFirstLabelRef; // linked list of references - CodeLabel *m_pPatchLabel; // label of stub patch offset - // currently just for multicast - // frames. PTR_MethodDesc m_pTargetMethod; // Used for instantiating stubs. SHORT m_stackSize; // count of pushes/pops CQuickHeap m_quickHeap; // throwaway heap for @@ -452,7 +443,7 @@ enum NewStubFlags NEWSTUB_FL_MULTICAST = 0x00000002, NEWSTUB_FL_EXTERNAL = 0x00000004, NEWSTUB_FL_LOADERHEAP = 0x00000008, - NEWSTUB_FL_THUNK = 0x00000010 + NEWSTUB_FL_SHUFFLE_THUNK = 0x00000010 }; @@ -477,12 +468,12 @@ class Stub LOADER_HEAP_BIT = 0x20000000, INSTANTIATING_STUB_BIT = 0x10000000, UNWIND_INFO_BIT = 0x08000000, - THUNK_BIT = 0x04000000, + SHUFFLE_THUNK_BIT = 0x04000000, - CODEBYTES_MASK = THUNK_BIT - 1, + CODEBYTES_MASK = SHUFFLE_THUNK_BIT - 1, MAX_CODEBYTES = CODEBYTES_MASK + 1, }; - static_assert_no_msg(CODEBYTES_MASK < THUNK_BIT); + static_assert_no_msg(CODEBYTES_MASK < SHUFFLE_THUNK_BIT); public: //------------------------------------------------------------------- @@ -530,46 +521,10 @@ class Stub //------------------------------------------------------------------- // Used by the debugger to help step through stubs //------------------------------------------------------------------- - BOOL IsManagedThunk() - { - LIMITED_METHOD_CONTRACT; - return (m_numCodeBytesAndFlags & THUNK_BIT) != 0; - } - - //------------------------------------------------------------------- - // For stubs which execute user code, a patch offset needs to be set - // to tell the debugger how far into the stub code the debugger has - // to step until the frame is set up. - //------------------------------------------------------------------- - void SetPatchOffset(USHORT offset) - { - LIMITED_METHOD_CONTRACT; - _ASSERTE(!IsInstantiatingStub()); - m_data.PatchOffset = offset; - } - - //------------------------------------------------------------------- - // For stubs which execute user code, a patch offset needs to be set - // to tell the debugger how far into the stub code the debugger has - // to step until the frame is set up. - //------------------------------------------------------------------- - USHORT GetPatchOffset() - { - LIMITED_METHOD_CONTRACT; - _ASSERTE(!IsInstantiatingStub()); - return m_data.PatchOffset; - } - - //------------------------------------------------------------------- - // For stubs which execute user code, a patch offset needs to be set - // to tell the debugger how far into the stub code the debugger has - // to step until the frame is set up. - //------------------------------------------------------------------- - TADDR GetPatchAddress() + BOOL IsShuffleThunk() { LIMITED_METHOD_CONTRACT; - _ASSERTE(!IsInstantiatingStub()); - return dac_cast(GetEntryPointInternal()) + GetPatchOffset(); + return (m_numCodeBytesAndFlags & SHUFFLE_THUNK_BIT) != 0; } //------------------------------------------------------------------- @@ -834,8 +789,8 @@ class Stub UINT32 m_numCodeBytesAndFlags; union { - USHORT PatchOffset; - PTR_MethodDesc InstantiatedMethod; + // Stub kind specific data + PTR_MethodDesc InstantiatedMethod; // Valid for IsInstantiatingStub() only } m_data; #ifdef _DEBUG diff --git a/src/coreclr/vm/stubmgr.cpp b/src/coreclr/vm/stubmgr.cpp index ed2a9c3b98c..d7f18a4a54c 100644 --- a/src/coreclr/vm/stubmgr.cpp +++ b/src/coreclr/vm/stubmgr.cpp @@ -938,10 +938,15 @@ BOOL ThePreStubManager::DoTraceStub(PCODE stubStartAddress, TraceDestination *tr // We cannot tell where the stub will end up // until after the prestub worker has been run. // - +#if defined(TARGET_ARM64) && defined(__APPLE__) + // On ARM64 Mac, we cannot put a breakpoint inside of ThePreStubPatchLabel + LOG((LF_CORDB, LL_INFO10000, "TPSM::DoTraceStub: Skipping on arm64-macOS\n")); + return FALSE; +#else trace->InitForFramePush(GetEEFuncEntryPoint(ThePreStubPatchLabel)); return TRUE; +#endif //defined(TARGET_ARM64) && defined(__APPLE__) } //----------------------------------------------------------- @@ -1028,7 +1033,13 @@ BOOL PrecodeStubManager::DoTraceStub(PCODE stubStartAddress, #ifdef HAS_NDIRECT_IMPORT_PRECODE case PRECODE_NDIRECT_IMPORT: #ifndef DACCESS_COMPILE +#if defined(TARGET_ARM64) && defined(__APPLE__) + // On ARM64 Mac, we cannot put a breakpoint inside of NDirectImportThunk + LOG((LF_CORDB, LL_INFO10000, "PSM::DoTraceStub: Skipping on arm64-macOS\n")); + return FALSE; +#else trace->InitForUnmanaged(GetEEFuncEntryPoint(NDirectImportThunk)); +#endif //defined(TARGET_ARM64) && defined(__APPLE__) #else trace->InitForOther((PCODE)NULL); #endif @@ -1274,21 +1285,14 @@ BOOL StubLinkStubManager::DoTraceStub(PCODE stubStartAddress, LOG_TRACE_DESTINATION(trace, stubStartAddress, "StubLinkStubManager(InstantiatingMethod)::DoTraceStub"); return TRUE; } - else if (stub->IsManagedThunk()) + else if (stub->IsShuffleThunk()) { trace->InitForManagerPush(stubStartAddress, this); - LOG_TRACE_DESTINATION(trace, stubStartAddress, "StubLinkStubManager(ManagedThunk)::DoTraceStub"); - return TRUE; - } - else if (stub->GetPatchOffset() != 0) - { - // The patch offset is currently only non-zero in x86 non-IL delegate scenarios. - trace->InitForFramePush((PCODE)stub->GetPatchAddress()); - LOG_TRACE_DESTINATION(trace, stubStartAddress, "StubLinkStubManager::DoTraceStub"); + LOG_TRACE_DESTINATION(trace, stubStartAddress, "StubLinkStubManager(ShuffleThunk)::DoTraceStub"); return TRUE; } - LOG((LF_CORDB, LL_INFO10000, "StubLinkStubManager::DoTraceStub: patch offset is 0!\n")); + LOG((LF_CORDB, LL_INFO10000, "StubLinkStubManager::DoTraceStub: no known target\n")); return FALSE; } @@ -1321,9 +1325,7 @@ static PCODE GetStubTarget(PTR_MethodDesc pTargetMD) return targetCode.GetNativeCode(); } -// Managed thunks are often implemented in terms of Delegates -// so the below utilizes Delegate internals. -static BOOL TraceManagedThunk( +static BOOL TraceShuffleThunk( TraceDestination *trace, T_CONTEXT *pContext, BYTE **pRetAddr) @@ -1334,89 +1336,14 @@ static BOOL TraceManagedThunk( } CONTRACTL_END; - PCODE destAddr; - PCODE pc = ::GetIP(pContext); - - // Retrieve the this pointer from the context. -#if defined(TARGET_X86) - (*pRetAddr) = *(BYTE **)(size_t)(pContext->Esp); - - BYTE* pThis = (BYTE*)(size_t)(pContext->Ecx); - - destAddr = *(PCODE*)(pThis + DelegateObject::GetOffsetOfMethodPtrAux()); - -#elif defined(TARGET_AMD64) - - // - // We need to check whether the following is the correct return address. - // - (*pRetAddr) = *(BYTE **)(size_t)(pContext->Rsp); - - LOG((LF_CORDB, LL_INFO10000, "TraceManagedThunk: at %p, retAddr is %p\n", pc, (*pRetAddr))); - - // NOTE: This doesn't work correctly and we anticipate changing it in the future. See - // the discussion at https://github.com/dotnet/runtime/pull/104731/files#r1693796408 - // for details. - DELEGATEREF orDelegate; - if (GetEEFuncEntryPoint(SinglecastDelegateInvokeStub) == pc) - { - LOG((LF_CORDB, LL_INFO10000, "TraceManagedThunk: isSingle\n")); - - orDelegate = (DELEGATEREF)ObjectToOBJECTREF(StubManagerHelpers::GetThisPtr(pContext)); - destAddr = orDelegate->GetMethodPtr(); - if (StubManager::TraceStub(destAddr, trace)) - { - LOG((LF_CORDB,LL_INFO10000, "TraceManagedThunk: ppbDest: %p\n", destAddr)); - LOG((LF_CORDB,LL_INFO10000, "TraceManagedThunk: res: 1, result type: %d\n", trace->GetTraceType())); - return TRUE; - } - } - else - { - // We get here if we are stopped at the beginning of a shuffle thunk. - // The next address we are going to is _methodPtrAux. - Stub* pStub = Stub::RecoverStub(pc); - - // We use the patch offset field to indicate whether the stub has a hidden return buffer argument. - // This field is set in SetupShuffleThunk(). - orDelegate = (pStub->GetPatchOffset() != 0) - ? (DELEGATEREF)ObjectToOBJECTREF(StubManagerHelpers::GetSecondArg(pContext)) // This stub has a hidden return buffer argument. - : (DELEGATEREF)ObjectToOBJECTREF(StubManagerHelpers::GetThisPtr(pContext)); - } - - destAddr = orDelegate->GetMethodPtrAux(); - -#elif defined(TARGET_ARM) - (*pRetAddr) = (BYTE *)(size_t)(pContext->Lr); - BYTE* pThis = (BYTE*)(size_t)(pContext->R0); - - // Could be in the singlecast invoke stub (in which case the next destination is in _methodPtr) or a - // shuffle thunk (destination in _methodPtrAux). - int offsetOfNextDest = (pc == GetEEFuncEntryPoint(SinglecastDelegateInvokeStub)) - ? DelegateObject::GetOffsetOfMethodPtr() - : DelegateObject::GetOffsetOfMethodPtrAux(); - destAddr = *(PCODE*)(pThis + offsetOfNextDest); - -#elif defined(TARGET_ARM64) - (*pRetAddr) = (BYTE *)(size_t)(pContext->Lr); - BYTE* pThis = (BYTE*)(size_t)(pContext->X0); - - // Could be in the singlecast invoke stub (in which case the next destination is in _methodPtr) or a - // shuffle thunk (destination in _methodPtrAux). - int offsetOfNextDest = (pc == GetEEFuncEntryPoint(SinglecastDelegateInvokeStub)) - ? DelegateObject::GetOffsetOfMethodPtr() - : DelegateObject::GetOffsetOfMethodPtrAux(); - destAddr = *(PCODE*)(pThis + offsetOfNextDest); - -#else - PORTABILITY_ASSERT("TraceManagedThunk"); - destAddr = (PCODE)NULL; -#endif + *pRetAddr = (BYTE *)StubManagerHelpers::GetReturnAddress(pContext); - LOG((LF_CORDB,LL_INFO10000, "TraceManagedThunk: ppbDest: %p\n", destAddr)); + DELEGATEREF orDelegate = (DELEGATEREF)ObjectToOBJECTREF(StubManagerHelpers::GetThisPtr(pContext)); + PCODE destAddr = orDelegate->GetMethodPtrAux(); + LOG((LF_CORDB,LL_INFO10000, "TraceShuffleThunk: ppbDest: %p\n", destAddr)); BOOL res = StubManager::TraceStub(destAddr, trace); - LOG((LF_CORDB,LL_INFO10000, "TraceManagedThunk: res: %d, result type: %d\n", res, trace->GetTraceType())); + LOG((LF_CORDB,LL_INFO10000, "TraceShuffleThunk: res: %d, result type: %d\n", res, trace->GetTraceType())); return res; } @@ -1464,10 +1391,10 @@ BOOL StubLinkStubManager::TraceManager(Thread *thread, BYTE *pbDel = (BYTE *)StubManagerHelpers::GetThisPtr(pContext); return TraceDelegateObject(pbDel, trace); } - else if (stub->IsManagedThunk()) + else if (stub->IsShuffleThunk()) { - LOG((LF_CORDB,LL_INFO10000, "SLSM:TM ManagedThunk\n")); - return TraceManagedThunk(trace, pContext, pRetAddr); + LOG((LF_CORDB,LL_INFO10000, "SLSM:TM ShuffleThunk\n")); + return TraceShuffleThunk(trace, pContext, pRetAddr); } // Runtime bug if we get here. Did we make a change in StubLinkStubManager::DoTraceStub() that @@ -1609,8 +1536,6 @@ BOOL RangeSectionStubManager::CheckIsStub_Internal(PCODE stubStartAddress) case STUB_CODE_BLOCK_PRECODE: case STUB_CODE_BLOCK_JUMPSTUB: case STUB_CODE_BLOCK_STUBLINK: - case STUB_CODE_BLOCK_VIRTUAL_METHOD_THUNK: - case STUB_CODE_BLOCK_EXTERNAL_METHOD_THUNK: case STUB_CODE_BLOCK_METHOD_CALL_THUNK: case STUB_CODE_BLOCK_VSD_DISPATCH_STUB: case STUB_CODE_BLOCK_VSD_RESOLVE_STUB: @@ -1656,8 +1581,14 @@ BOOL RangeSectionStubManager::DoTraceStub(PCODE stubStartAddress, TraceDestinati case STUB_CODE_BLOCK_METHOD_CALL_THUNK: #ifdef DACCESS_COMPILE DacNotImpl(); +#else +#if defined(TARGET_ARM64) && defined(__APPLE__) + // On ARM64 Mac, we cannot put a breakpoint inside of ExternalMethodFixupPatchLabel + LOG((LF_CORDB, LL_INFO10000, "RSM::DoTraceStub: Skipping on arm64-macOS\n")); + return FALSE; #else trace->InitForManagerPush(GetEEFuncEntryPoint(ExternalMethodFixupPatchLabel), this); +#endif //defined(TARGET_ARM64) && defined(__APPLE__) #endif return TRUE; @@ -1708,12 +1639,6 @@ LPCWSTR RangeSectionStubManager::GetStubManagerName(PCODE addr) case STUB_CODE_BLOCK_STUBLINK: return W("StubLinkStub"); - case STUB_CODE_BLOCK_VIRTUAL_METHOD_THUNK: - return W("VirtualMethodThunk"); - - case STUB_CODE_BLOCK_EXTERNAL_METHOD_THUNK: - return W("ExternalMethodThunk"); - case STUB_CODE_BLOCK_METHOD_CALL_THUNK: return W("MethodCallThunk"); @@ -1801,7 +1726,13 @@ BOOL ILStubManager::DoTraceStub(PCODE stubStartAddress, MethodDesc* pStubMD = ExecutionManager::GetCodeMethodDesc(stubStartAddress); if (pStubMD != NULL && pStubMD->AsDynamicMethodDesc()->IsMulticastStub()) { +#if defined(TARGET_ARM64) && defined(__APPLE__) + //On ARM64 Mac, we cannot put a breakpoint inside of MulticastDebuggerTraceHelper + LOG((LF_CORDB, LL_INFO10000, "ILSM::DoTraceStub: skipping on arm64-macOS\n")); + return FALSE; +#else traceDestination = GetEEFuncEntryPoint(StubHelpers::MulticastDebuggerTraceHelper); +#endif //defined(TARGET_ARM64) && defined(__APPLE__) } else { @@ -2104,18 +2035,30 @@ BOOL InteropDispatchStubManager::TraceManager(Thread *thread, if (IsVarargPInvokeStub(GetIP(pContext))) { +#if defined(TARGET_ARM64) && defined(__APPLE__) + //On ARM64 Mac, we cannot put a breakpoint inside of VarargPInvokeStub + LOG((LF_CORDB, LL_INFO10000, "IDSM::TraceManager: Skipping on arm64-macOS\n")); + return FALSE; +#else NDirectMethodDesc *pNMD = (NDirectMethodDesc *)arg; _ASSERTE(pNMD->IsNDirect()); PCODE target = (PCODE)pNMD->GetNDirectTarget(); - LOG((LF_CORDB, LL_INFO10000, "IDSM::TraceManager: Vararg P/Invoke case 0x%p\n", target)); + LOG((LF_CORDB, LL_INFO10000, "IDSM::TraceManager: Vararg P/Invoke case %p\n", target)); trace->InitForUnmanaged(target); +#endif //defined(TARGET_ARM64) && defined(__APPLE__) } else if (GetIP(pContext) == GetEEFuncEntryPoint(GenericPInvokeCalliHelper)) { +#if defined(TARGET_ARM64) && defined(__APPLE__) + //On ARM64 Mac, we cannot put a breakpoint inside of GenericPInvokeCalliHelper + LOG((LF_CORDB, LL_INFO10000, "IDSM::TraceManager: Skipping on arm64-macOS\n")); + return FALSE; +#else PCODE target = (PCODE)arg; - LOG((LF_CORDB, LL_INFO10000, "IDSM::TraceManager: Unmanaged CALLI case 0x%p\n", target)); + LOG((LF_CORDB, LL_INFO10000, "IDSM::TraceManager: Unmanaged CALLI case %p\n", target)); trace->InitForUnmanaged(target); +#endif //defined(TARGET_ARM64) && defined(__APPLE__) } #ifdef FEATURE_COMINTEROP else diff --git a/src/coreclr/vm/threads.cpp b/src/coreclr/vm/threads.cpp index 8c60b2b5a79..99a366e9a2f 100644 --- a/src/coreclr/vm/threads.cpp +++ b/src/coreclr/vm/threads.cpp @@ -2765,6 +2765,10 @@ void Thread::CooperativeCleanup() // Clear out the alloc context pointer for this thread. When TLS is gone, this pointer will point into freed memory. m_pRuntimeThreadLocals = nullptr; } + + OBJECTREF threadObjMaybe = GetExposedObjectRaw(); + if (threadObjMaybe != NULL) + ((THREADBASEREF)threadObjMaybe)->SetIsDead(); } // See general comments on thread destruction (code:#threadDestruction) above. @@ -3112,14 +3116,14 @@ DWORD MsgWaitHelper(int numWaiters, HANDLE* phEvent, BOOL bWaitAll, DWORD millis // want true WAIT_ALL, we need to fire up a different thread in the MTA and wait // on its result. This isn't implemented yet. // - // A change was added to WaitHandleNative::CorWaitMultipleNative to disable WaitAll + // A change was added to WaitHandle_WaitMultipleIgnoringSyncContext to disable WaitAll // in an STA with more than one handle. if (bWaitAll) { if (numWaiters == 1) bWaitAll = FALSE; - // The check that's supposed to prevent this condition from occurring, in WaitHandleNative::CorWaitMultipleNative, + // The check that's supposed to prevent this condition from occurring, in WaitHandle_WaitMultipleIgnoringSyncContext, // is unfortunately behind FEATURE_COMINTEROP instead of FEATURE_COMINTEROP_APARTMENT_SUPPORT. // So on CoreCLR (where FEATURE_COMINTEROP is not currently defined) we can actually reach this point. // We can't fix this, because it's a breaking change, so we just won't assert here. @@ -4781,20 +4785,6 @@ Thread::ApartmentState Thread::GetFinalApartment() return as; } -// when we get apartment tear-down notification, -// we want reset the apartment state we cache on the thread -VOID Thread::ResetApartment() -{ - CONTRACTL { - NOTHROW; - GC_NOTRIGGER; - } - CONTRACTL_END; - - // reset the TS_InSTA bit and TS_InMTA bit - ResetThreadState((Thread::ThreadState)(TS_InSTA | TS_InMTA)); -} - // Attempt to set current thread's apartment state. The actual apartment state // achieved is returned and may differ from the input state if someone managed // to call CoInitializeEx on this thread first (note that calls to SetApartment diff --git a/src/coreclr/vm/threads.h b/src/coreclr/vm/threads.h index 4a4bd2ff867..5c0f0bc8e1c 100644 --- a/src/coreclr/vm/threads.h +++ b/src/coreclr/vm/threads.h @@ -378,6 +378,9 @@ EXTERN_C void ThrowControlForThread( #ifdef FEATURE_EH_FUNCLETS FaultingExceptionFrame *pfef #endif // FEATURE_EH_FUNCLETS +#if defined(TARGET_AMD64) && defined(TARGET_WINDOWS) + , TADDR ssp +#endif // TARGET_AMD64 && TARGET_WINDOWS ); #if defined(_DEBUG) @@ -468,7 +471,6 @@ class Thread friend class ThreadSuspend; friend class SyncBlock; friend struct PendingSync; - friend class ThreadNative; #ifdef _DEBUG friend class EEContract; #endif @@ -2168,10 +2170,6 @@ class Thread // call CoInitializeEx on this thread first (note that calls to SetApartment made // before the thread has started are guaranteed to succeed). ApartmentState SetApartment(ApartmentState state); - - // when we get apartment tear-down notification, - // we want reset the apartment state we cache on the thread - VOID ResetApartment(); #endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT // Either perform WaitForSingleObject or MsgWaitForSingleObject as appropriate. @@ -2710,6 +2708,24 @@ class Thread #endif // TRACK_SYNC + // Access to thread handle and ThreadId. + HANDLE GetThreadHandle() + { + LIMITED_METHOD_CONTRACT; +#if defined(_DEBUG) && !defined(DACCESS_COMPILE) + { + CounterHolder handleHolder(&m_dwThreadHandleBeingUsed); + HANDLE handle = m_ThreadHandle; + _ASSERTE ( handle == INVALID_HANDLE_VALUE + || m_OSThreadId == 0 + || m_OSThreadId == 0xbaadf00d + || ::MatchThreadHandleToOsId(handle, (DWORD)m_OSThreadId) ); + } +#endif + DACCOP_IGNORE(FieldAccess, "Treated as raw address, no marshaling is necessary"); + return m_ThreadHandle; + } + private: // For suspends: CLREvent m_DebugSuspendEvent; @@ -2733,25 +2749,6 @@ class Thread return walk; } - // Access to thread handle and ThreadId. - HANDLE GetThreadHandle() - { - LIMITED_METHOD_CONTRACT; -#if defined(_DEBUG) && !defined(DACCESS_COMPILE) - { - CounterHolder handleHolder(&m_dwThreadHandleBeingUsed); - HANDLE handle = m_ThreadHandle; - _ASSERTE ( handle == INVALID_HANDLE_VALUE - || m_OSThreadId == 0 - || m_OSThreadId == 0xbaadf00d - || ::MatchThreadHandleToOsId(handle, (DWORD)m_OSThreadId) ); - } -#endif - - DACCOP_IGNORE(FieldAccess, "Treated as raw address, no marshaling is necessary"); - return m_ThreadHandle; - } - void SetThreadHandle(HANDLE h) { LIMITED_METHOD_CONTRACT; @@ -4267,12 +4264,6 @@ struct cdac_data static constexpr size_t DeadCount = offsetof(ThreadStore, m_DeadThreadCount); }; -struct TSSuspendHelper { - static void SetTrap() { ThreadStore::IncrementTrapReturningThreads(); } - static void UnsetTrap() { ThreadStore::DecrementTrapReturningThreads(); } -}; -typedef StateHolder TSSuspendHolder; - typedef StateHolder ThreadStoreLockHolder; diff --git a/src/coreclr/vm/threadstatics.cpp b/src/coreclr/vm/threadstatics.cpp index 31d0c53f74e..dbb218464a6 100644 --- a/src/coreclr/vm/threadstatics.cpp +++ b/src/coreclr/vm/threadstatics.cpp @@ -33,7 +33,6 @@ static TLSIndexToMethodTableMap *g_pThreadStaticCollectibleTypeIndices; static TLSIndexToMethodTableMap *g_pThreadStaticNonCollectibleTypeIndices; static PTR_MethodTable g_pMethodTablesForDirectThreadLocalData[offsetof(ThreadLocalData, ExtendedDirectThreadLocalTLSData) - offsetof(ThreadLocalData, ThreadBlockingInfo_First) + EXTENDED_DIRECT_THREAD_LOCAL_SIZE]; -static Volatile s_GCsWhichDoRelocateAndCanEmptyOutTheTLSIndices = 0; static uint32_t g_NextTLSSlot = 1; static uint32_t g_NextNonCollectibleTlsSlot = NUMBER_OF_TLSOFFSETS_NOT_USED_IN_NONCOLLECTIBLE_ARRAY; static uint32_t g_directThreadLocalTLSBytesAvailable = EXTENDED_DIRECT_THREAD_LOCAL_SIZE; @@ -277,7 +276,7 @@ void TLSIndexToMethodTableMap::Clear(TLSIndex index, uint8_t whenCleared) _ASSERTE(IsClearedValue(pMap[index.GetIndexOffset()])); } -bool TLSIndexToMethodTableMap::FindClearedIndex(uint8_t whenClearedMarkerToAvoid, TLSIndex* pIndex) +bool TLSIndexToMethodTableMap::FindClearedIndex(TLSIndex* pIndex) { CONTRACTL { @@ -291,15 +290,6 @@ bool TLSIndexToMethodTableMap::FindClearedIndex(uint8_t whenClearedMarkerToAvoid { if (entry.IsClearedValue) { - uint8_t whenClearedMarker = entry.ClearedMarker; - if ((whenClearedMarker == whenClearedMarkerToAvoid) || - (whenClearedMarker == (whenClearedMarkerToAvoid - 1)) || - (whenClearedMarker == (whenClearedMarkerToAvoid - 2))) - { - // Make sure we are not within 2 of the marker we are trying to avoid - // Use multiple compares instead of trying to fuss around with the overflow style comparisons - continue; - } *pIndex = entry.TlsIndex; return true; } @@ -317,7 +307,7 @@ void InitializeThreadStaticData() } CONTRACTL_END; - g_pThreadStaticCollectibleTypeIndices = new TLSIndexToMethodTableMap(TLSIndexType::NonCollectible); + g_pThreadStaticCollectibleTypeIndices = new TLSIndexToMethodTableMap(TLSIndexType::Collectible); g_pThreadStaticNonCollectibleTypeIndices = new TLSIndexToMethodTableMap(TLSIndexType::NonCollectible); g_TLSCrst.Init(CrstThreadLocalStorageLock, CRST_UNSAFE_ANYMODE); } @@ -387,7 +377,7 @@ void FreeLoaderAllocatorHandlesForTLSData(Thread *pThread) #endif for (const auto& entry : g_pThreadStaticCollectibleTypeIndices->CollectibleEntries()) { - _ASSERTE((entry.TlsIndex.GetIndexOffset() < pThread->cLoaderHandles) || allRemainingIndicesAreNotValid); + _ASSERTE((entry.TlsIndex.GetIndexOffset() <= pThread->cLoaderHandles) || allRemainingIndicesAreNotValid); if (entry.TlsIndex.GetIndexOffset() >= pThread->cLoaderHandles) { #ifndef _DEBUG @@ -405,6 +395,13 @@ void FreeLoaderAllocatorHandlesForTLSData(Thread *pThread) } } } + + pThread->cLoaderHandles = -1; // Sentinel value indicating that there are no LoaderHandles and the thread is permanently dead. + if (pThread->pLoaderHandles != NULL) + { + delete[] pThread->pLoaderHandles; + pThread->pLoaderHandles = NULL; + } } } @@ -431,34 +428,46 @@ void FreeThreadStaticData(Thread* pThread) } CONTRACTL_END; - SpinLockHolder spinLock(&pThread->m_TlsSpinLock); + InFlightTLSData* pOldInFlightData = nullptr; - ThreadLocalData *pThreadLocalData = &t_ThreadStatics; + int32_t oldCollectibleTlsDataCount = 0; + DPTR(OBJECTHANDLE) pOldCollectibleTlsArrayData = nullptr; + + { + SpinLockHolder spinLock(&pThread->m_TlsSpinLock); - for (int32_t iTlsSlot = 0; iTlsSlot < pThreadLocalData->cCollectibleTlsData; ++iTlsSlot) + ThreadLocalData *pThreadLocalData = &t_ThreadStatics; + + pOldCollectibleTlsArrayData = pThreadLocalData->pCollectibleTlsArrayData; + oldCollectibleTlsDataCount = pThreadLocalData->cCollectibleTlsData; + + pThreadLocalData->pCollectibleTlsArrayData = NULL; + pThreadLocalData->cCollectibleTlsData = 0; + pThreadLocalData->pNonCollectibleTlsArrayData = NULL; + pThreadLocalData->cNonCollectibleTlsData = 0; + + pOldInFlightData = pThreadLocalData->pInFlightData; + pThreadLocalData->pInFlightData = NULL; + _ASSERTE(pThreadLocalData->pThread == pThread); + pThreadLocalData->pThread = NULL; + } + + for (int32_t iTlsSlot = 0; iTlsSlot < oldCollectibleTlsDataCount; ++iTlsSlot) { - if (!IsHandleNullUnchecked(pThreadLocalData->pCollectibleTlsArrayData[iTlsSlot])) + if (!IsHandleNullUnchecked(pOldCollectibleTlsArrayData[iTlsSlot])) { - DestroyLongWeakHandle(pThreadLocalData->pCollectibleTlsArrayData[iTlsSlot]); + DestroyLongWeakHandle(pOldCollectibleTlsArrayData[iTlsSlot]); } } - delete[] (uint8_t*)pThreadLocalData->pCollectibleTlsArrayData; + delete[] (uint8_t*)pOldCollectibleTlsArrayData; - pThreadLocalData->pCollectibleTlsArrayData = 0; - pThreadLocalData->cCollectibleTlsData = 0; - pThreadLocalData->pNonCollectibleTlsArrayData = 0; - pThreadLocalData->cNonCollectibleTlsData = 0; - - while (pThreadLocalData->pInFlightData != NULL) + while (pOldInFlightData != NULL) { - InFlightTLSData* pInFlightData = pThreadLocalData->pInFlightData; - pThreadLocalData->pInFlightData = pInFlightData->pNext; + InFlightTLSData* pInFlightData = pOldInFlightData; + pOldInFlightData = pInFlightData->pNext; delete pInFlightData; } - - _ASSERTE(pThreadLocalData->pThread == pThread); - pThreadLocalData->pThread = NULL; } void SetTLSBaseValue(TADDR *ppTLSBaseAddress, TADDR pTLSBaseAddress, bool useGCBarrierInsteadOfHandleStore) @@ -553,6 +562,8 @@ void* GetThreadLocalStaticBase(TLSIndex index) delete[] pOldArray; } + _ASSERTE(t_ThreadStatics.pThread->cLoaderHandles != -1); // Check sentinel value indicating that there are no LoaderHandles, the thread has gone through termination and is permanently dead. + if (isCollectible && t_ThreadStatics.pThread->cLoaderHandles <= index.GetIndexOffset()) { // Grow the underlying TLS array @@ -594,9 +605,11 @@ void* GetThreadLocalStaticBase(TLSIndex index) gcBaseAddresses.pTLSBaseAddress = dac_cast(OBJECTREFToObject(ObjectFromHandle(pInFlightData->hTLSData))); if (pMT->IsClassInited()) { - SpinLockHolder spinLock(&t_ThreadStatics.pThread->m_TlsSpinLock); - SetTLSBaseValue(gcBaseAddresses.ppTLSBaseAddress, gcBaseAddresses.pTLSBaseAddress, staticIsNonCollectible); - *ppOldNextPtr = pInFlightData->pNext; + { + SpinLockHolder spinLock(&t_ThreadStatics.pThread->m_TlsSpinLock); + SetTLSBaseValue(gcBaseAddresses.ppTLSBaseAddress, gcBaseAddresses.pTLSBaseAddress, staticIsNonCollectible); + *ppOldNextPtr = pInFlightData->pNext; + } delete pInFlightData; } break; @@ -744,7 +757,7 @@ void GetTLSIndexForThreadStatic(MethodTable* pMT, bool gcStatic, TLSIndex* pInde } else { - if (!g_pThreadStaticCollectibleTypeIndices->FindClearedIndex(s_GCsWhichDoRelocateAndCanEmptyOutTheTLSIndices, &newTLSIndex)) + if (!g_pThreadStaticCollectibleTypeIndices->FindClearedIndex(&newTLSIndex)) { uint32_t tlsRawIndex = g_NextTLSSlot; newTLSIndex = TLSIndex(TLSIndexType::Collectible, tlsRawIndex); @@ -777,16 +790,16 @@ void FreeTLSIndicesForLoaderAllocator(LoaderAllocator *pLoaderAllocator) while (current != end) { - g_pThreadStaticCollectibleTypeIndices->Clear(tlsIndicesToCleanup[current], s_GCsWhichDoRelocateAndCanEmptyOutTheTLSIndices); + g_pThreadStaticCollectibleTypeIndices->Clear(tlsIndicesToCleanup[current], 0); ++current; } } static void* GetTlsIndexObjectAddress(); -#if !defined(TARGET_OSX) && defined(TARGET_UNIX) && defined(TARGET_ARM64) +#if !defined(TARGET_OSX) && defined(TARGET_UNIX) && (defined(TARGET_ARM64) || defined(TARGET_LOONGARCH64)) extern "C" size_t GetTLSResolverAddress(); -#endif // !TARGET_OSX && TARGET_UNIX && TARGET_ARM64 +#endif // !TARGET_OSX && TARGET_UNIX && (TARGET_ARM64 || TARGET_LOONGARCH64) bool CanJITOptimizeTLSAccess() { @@ -833,6 +846,28 @@ bool CanJITOptimizeTLSAccess() } #endif } +#elif defined(TARGET_LOONGARCH64) + // Optimization is enabled for linux/loongarch64 only for static resolver. + // For static resolver, the TP offset is same for all threads. + // For dynamic resolver, TP offset returned is for the current thread and + // will be different for the other threads. + uint32_t* resolverAddress = reinterpret_cast(GetTLSResolverAddress()); + + if ( + // ld.d a0, a0, 8 + (resolverAddress[0] == 0x28c02084) && + // ret + (resolverAddress[1] == 0x4c000020) + ) + { + optimizeThreadStaticAccess = true; +#ifdef _DEBUG + if (CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_AssertNotStaticTlsResolver) != 0) + { + _ASSERTE(!"Detected static resolver in use when not expected"); + } +#endif + } #else optimizeThreadStaticAccess = true; #if !defined(TARGET_OSX) && defined(TARGET_UNIX) && defined(TARGET_AMD64) diff --git a/src/coreclr/vm/threadstatics.h b/src/coreclr/vm/threadstatics.h index 3ab3806cbf9..4d979d168bf 100644 --- a/src/coreclr/vm/threadstatics.h +++ b/src/coreclr/vm/threadstatics.h @@ -304,7 +304,7 @@ class TLSIndexToMethodTableMap #ifndef DACCESS_COMPILE void Set(TLSIndex index, PTR_MethodTable pMT, bool isGCStatic); - bool FindClearedIndex(uint8_t whenClearedMarkerToAvoid, TLSIndex* pIndex); + bool FindClearedIndex(TLSIndex* pIndex); void Clear(TLSIndex index, uint8_t whenCleared); #endif // !DACCESS_COMPILE diff --git a/src/coreclr/vm/threadsuspend.cpp b/src/coreclr/vm/threadsuspend.cpp index e9b9ab99b37..1506516f124 100644 --- a/src/coreclr/vm/threadsuspend.cpp +++ b/src/coreclr/vm/threadsuspend.cpp @@ -28,26 +28,6 @@ ThreadSuspend::SUSPEND_REASON ThreadSuspend::m_suspendReason; void* ThreadSuspend::g_returnAddressHijackTarget = NULL; #endif // TARGET_WINDOWS -#if defined(TARGET_ARM64) -// Mirror the XSTATE_ARM64_SVE flags from winnt.h - -#ifndef XSTATE_ARM64_SVE -#define XSTATE_ARM64_SVE (2) -#endif // XSTATE_ARM64_SVE - -#ifndef XSTATE_MASK_ARM64_SVE -#define XSTATE_MASK_ARM64_SVE (1ui64 << (XSTATE_ARM64_SVE)) -#endif // XSTATE_MASK_ARM64_SVE - -#ifndef CONTEXT_ARM64_XSTATE -#define CONTEXT_ARM64_XSTATE (CONTEXT_ARM64 | 0x20L) -#endif // CONTEXT_ARM64_XSTATE - -#ifndef CONTEXT_XSTATE -#define CONTEXT_XSTATE CONTEXT_ARM64_XSTATE -#endif // CONTEXT_XSTATE -#endif // TARGET_ARM64 - // If you add any thread redirection function, make sure the debugger can 1) recognize the redirection // function, and 2) retrieve the original CONTEXT. See code:Debugger.InitializeHijackFunctionAddress and // code:DacDbiInterfaceImpl.RetrieveHijackedContext. @@ -3755,6 +3735,9 @@ ThrowControlForThread( #ifdef FEATURE_EH_FUNCLETS FaultingExceptionFrame *pfef #endif // FEATURE_EH_FUNCLETS +#if defined(TARGET_AMD64) && defined(TARGET_WINDOWS) + , TADDR ssp +#endif // TARGET_AMD64 && TARGET_WINDOWS ) { STATIC_CONTRACT_THROWS; @@ -3804,6 +3787,10 @@ ThrowControlForThread( #endif // FEATURE_EH_FUNCLETS pfef->InitAndLink(pThread->m_OSContext); +#if defined(TARGET_AMD64) && defined(TARGET_WINDOWS) + pfef->SetSSP(ssp); +#endif + // !!! Can not assert here. Sometimes our EHInfo for catch clause extends beyond // !!! Jit_EndCatch. Not sure if we have guarantee on catch clause. //_ASSERTE (pThread->ReadyForAbort()); diff --git a/src/coreclr/vm/typedesc.cpp b/src/coreclr/vm/typedesc.cpp index d920e7864fb..1d2ac6960da 100644 --- a/src/coreclr/vm/typedesc.cpp +++ b/src/coreclr/vm/typedesc.cpp @@ -74,16 +74,7 @@ PTR_Module TypeDesc::GetLoaderModule() } else { - PTR_Module retVal = NULL; - BOOL fFail = FALSE; - - _ASSERTE(GetInternalCorElementType() == ELEMENT_TYPE_FNPTR); - PTR_FnPtrTypeDesc asFnPtr = dac_cast(this); - if (!fFail) - { - retVal = ClassLoader::ComputeLoaderModuleForFunctionPointer(asFnPtr->GetRetAndArgTypesPointer(), asFnPtr->GetNumArgs()+1); - } - return retVal; + return dac_cast(this)->GetLoaderModule(); } } @@ -1464,7 +1455,7 @@ BOOL TypeVarTypeDesc::SatisfiesConstraints(SigTypeContext *pTypeContextOfConstra if ((specialConstraints & gpDefaultConstructorConstraint) != 0) { - if (thArg.IsTypeDesc() || (!thArg.AsMethodTable()->HasExplicitOrImplicitPublicDefaultConstructor())) + if (thArg.IsTypeDesc() || (!thArg.AsMethodTable()->HasExplicitOrImplicitPublicDefaultConstructor() || thArg.IsAbstract())) return FALSE; } diff --git a/src/coreclr/vm/typedesc.h b/src/coreclr/vm/typedesc.h index 3932b07d3db..593e71b63b8 100644 --- a/src/coreclr/vm/typedesc.h +++ b/src/coreclr/vm/typedesc.h @@ -415,8 +415,8 @@ class FnPtrTypeDesc : public TypeDesc public: #ifndef DACCESS_COMPILE - FnPtrTypeDesc(BYTE callConv, DWORD numArgs, TypeHandle * retAndArgTypes) - : TypeDesc(ELEMENT_TYPE_FNPTR), m_NumArgs(numArgs), m_CallConv(callConv) + FnPtrTypeDesc(BYTE callConv, DWORD numArgs, TypeHandle * retAndArgTypes, PTR_Module pLoaderModule) + : TypeDesc(ELEMENT_TYPE_FNPTR), m_pLoaderModule(pLoaderModule), m_NumArgs(numArgs), m_CallConv(callConv) { LIMITED_METHOD_CONTRACT; for (DWORD i = 0; i <= numArgs; i++) @@ -469,6 +469,8 @@ class FnPtrTypeDesc : public TypeDesc BOOL IsExternallyVisible() const; #endif //DACCESS_COMPILE + PTR_Module GetLoaderModule() const { LIMITED_METHOD_DAC_CONTRACT; return m_pLoaderModule; } + #ifdef DACCESS_COMPILE static ULONG32 DacSize(TADDR addr) { @@ -481,6 +483,9 @@ class FnPtrTypeDesc : public TypeDesc #endif //DACCESS_COMPILE protected: + // LoaderModule of the TypeDesc + PTR_Module m_pLoaderModule; + // Number of arguments DWORD m_NumArgs; @@ -499,6 +504,7 @@ struct cdac_data static constexpr size_t NumArgs = offsetof(FnPtrTypeDesc, m_NumArgs); static constexpr size_t RetAndArgTypes = offsetof(FnPtrTypeDesc, m_RetAndArgTypes); static constexpr size_t CallConv = offsetof(FnPtrTypeDesc, m_CallConv); + static constexpr size_t LoaderModule = offsetof(FnPtrTypeDesc, m_pLoaderModule); }; #endif // TYPEDESC_H diff --git a/src/coreclr/vm/typehandle.cpp b/src/coreclr/vm/typehandle.cpp index d5fea81cb48..5116f1aec0c 100644 --- a/src/coreclr/vm/typehandle.cpp +++ b/src/coreclr/vm/typehandle.cpp @@ -342,7 +342,7 @@ void TypeHandle::AllocateManagedClassObject(RUNTIMETYPEHANDLE* pDest) { // Allocate RuntimeType on a frozen segment // Take a lock here since we don't want to allocate redundant objects which won't be collected - CrstHolder exposedClassLock(AppDomain::GetMethodTableExposedClassObjectLock()); + CrstHolder exposedClassLock(AppDomain::GetCurrentDomain()->GetMethodTableExposedClassObjectLock()); if (VolatileLoad(pDest) == 0) { diff --git a/src/coreclr/vm/typehandle.h b/src/coreclr/vm/typehandle.h index 9e624629b72..49339467fae 100644 --- a/src/coreclr/vm/typehandle.h +++ b/src/coreclr/vm/typehandle.h @@ -27,7 +27,6 @@ class MethodTable; class EEClass; class Module; class Assembly; -class BaseDomain; class MethodDesc; class TypeKey; class TypeHandleList; diff --git a/src/coreclr/vm/typehash.h b/src/coreclr/vm/typehash.h index 8afe7dff89a..86a97b888dd 100644 --- a/src/coreclr/vm/typehash.h +++ b/src/coreclr/vm/typehash.h @@ -15,10 +15,7 @@ // This hash table is used by class loaders to look up constructed types: // arrays, pointers and instantiations of user-defined generic types. // -// Each persisted module structure has an EETypeHashTable used for constructed types that -// were ngen'ed into that module. See ceeload.hpp for more information about ngen modules. -// -// Types created at runtime are placed in an EETypeHashTable in BaseDomain. +// Types created at runtime are placed in an EETypeHashTable in Module. // // Keys are derivable from the data stored in the table (TypeHandle) // - for an instantiated type, the typedef module, typedef token, and instantiation diff --git a/src/coreclr/vm/typestring.h b/src/coreclr/vm/typestring.h index 869039ffe5d..f3bd23bfc67 100644 --- a/src/coreclr/vm/typestring.h +++ b/src/coreclr/vm/typestring.h @@ -184,7 +184,7 @@ class TypeString // Append a representation of the method m to the string s // The following flags in the FormatFlags argument are significant: FormatNamespace FormatFullInst FormatAssembly FormatSignature FormatNoVersion - static void AppendMethodInternal(SString& s, MethodDesc *pMD, const DWORD format = FormatNamespace|FormatSignature|FormatStubInfo); + static void AppendMethodInternal(SString& s, MethodDesc *pMD, const DWORD format); // Append the field name and generic instantiation info. static void AppendField(SString& s, FieldDesc *pFD, Instantiation typeInstantiation, const DWORD format = FormatNamespace); diff --git a/src/coreclr/vm/util.cpp b/src/coreclr/vm/util.cpp index 2065677ed81..4531a8cd623 100644 --- a/src/coreclr/vm/util.cpp +++ b/src/coreclr/vm/util.cpp @@ -369,6 +369,86 @@ SIZE_T GetRegOffsInCONTEXT(ICorDebugInfo::RegNum regNum) case ICorDebugInfo::REGNUM_AMBIENT_SP: return offsetof(T_CONTEXT, Sp); default: _ASSERTE(!"Bad regNum"); return (SIZE_T)(-1); } +#elif defined(TARGET_LOONGARCH64) + + switch(regNum) + { + case ICorDebugInfo::REGNUM_R0: return offsetof(T_CONTEXT, R0); + case ICorDebugInfo::REGNUM_RA: return offsetof(T_CONTEXT, Ra); + case ICorDebugInfo::REGNUM_TP: return offsetof(T_CONTEXT, Tp); + case ICorDebugInfo::REGNUM_SP: return offsetof(T_CONTEXT, Sp); + case ICorDebugInfo::REGNUM_A0: return offsetof(T_CONTEXT, A0); + case ICorDebugInfo::REGNUM_A1: return offsetof(T_CONTEXT, A1); + case ICorDebugInfo::REGNUM_A2: return offsetof(T_CONTEXT, A2); + case ICorDebugInfo::REGNUM_A3: return offsetof(T_CONTEXT, A3); + case ICorDebugInfo::REGNUM_A4: return offsetof(T_CONTEXT, A4); + case ICorDebugInfo::REGNUM_A5: return offsetof(T_CONTEXT, A5); + case ICorDebugInfo::REGNUM_A6: return offsetof(T_CONTEXT, A6); + case ICorDebugInfo::REGNUM_A7: return offsetof(T_CONTEXT, A7); + case ICorDebugInfo::REGNUM_T0: return offsetof(T_CONTEXT, T0); + case ICorDebugInfo::REGNUM_T1: return offsetof(T_CONTEXT, T1); + case ICorDebugInfo::REGNUM_T2: return offsetof(T_CONTEXT, T2); + case ICorDebugInfo::REGNUM_T3: return offsetof(T_CONTEXT, T3); + case ICorDebugInfo::REGNUM_T4: return offsetof(T_CONTEXT, T4); + case ICorDebugInfo::REGNUM_T5: return offsetof(T_CONTEXT, T5); + case ICorDebugInfo::REGNUM_T6: return offsetof(T_CONTEXT, T6); + case ICorDebugInfo::REGNUM_T7: return offsetof(T_CONTEXT, T7); + case ICorDebugInfo::REGNUM_T8: return offsetof(T_CONTEXT, T8); + case ICorDebugInfo::REGNUM_X0: return offsetof(T_CONTEXT, X0); + case ICorDebugInfo::REGNUM_FP: return offsetof(T_CONTEXT, Fp); + case ICorDebugInfo::REGNUM_S0: return offsetof(T_CONTEXT, S0); + case ICorDebugInfo::REGNUM_S1: return offsetof(T_CONTEXT, S1); + case ICorDebugInfo::REGNUM_S2: return offsetof(T_CONTEXT, S2); + case ICorDebugInfo::REGNUM_S3: return offsetof(T_CONTEXT, S3); + case ICorDebugInfo::REGNUM_S4: return offsetof(T_CONTEXT, S4); + case ICorDebugInfo::REGNUM_S5: return offsetof(T_CONTEXT, S5); + case ICorDebugInfo::REGNUM_S6: return offsetof(T_CONTEXT, S6); + case ICorDebugInfo::REGNUM_S7: return offsetof(T_CONTEXT, S7); + case ICorDebugInfo::REGNUM_S8: return offsetof(T_CONTEXT, S8); + case ICorDebugInfo::REGNUM_PC: return offsetof(T_CONTEXT, Pc); + case ICorDebugInfo::REGNUM_AMBIENT_SP: return offsetof(T_CONTEXT, Sp); + default: _ASSERTE(!"Bad regNum"); return (SIZE_T)(-1); + } +#elif defined(TARGET_RISCV64) + + switch(regNum) + { + case ICorDebugInfo::REGNUM_R0: return offsetof(T_CONTEXT, R0); + case ICorDebugInfo::REGNUM_RA: return offsetof(T_CONTEXT, Ra); + case ICorDebugInfo::REGNUM_SP: return offsetof(T_CONTEXT, Sp); + case ICorDebugInfo::REGNUM_GP: return offsetof(T_CONTEXT, Gp); + case ICorDebugInfo::REGNUM_TP: return offsetof(T_CONTEXT, Tp); + case ICorDebugInfo::REGNUM_T0: return offsetof(T_CONTEXT, T0); + case ICorDebugInfo::REGNUM_T1: return offsetof(T_CONTEXT, T1); + case ICorDebugInfo::REGNUM_T2: return offsetof(T_CONTEXT, T2); + case ICorDebugInfo::REGNUM_FP: return offsetof(T_CONTEXT, Fp); + case ICorDebugInfo::REGNUM_S1: return offsetof(T_CONTEXT, S1); + case ICorDebugInfo::REGNUM_A0: return offsetof(T_CONTEXT, A0); + case ICorDebugInfo::REGNUM_A1: return offsetof(T_CONTEXT, A1); + case ICorDebugInfo::REGNUM_A2: return offsetof(T_CONTEXT, A2); + case ICorDebugInfo::REGNUM_A3: return offsetof(T_CONTEXT, A3); + case ICorDebugInfo::REGNUM_A4: return offsetof(T_CONTEXT, A4); + case ICorDebugInfo::REGNUM_A5: return offsetof(T_CONTEXT, A5); + case ICorDebugInfo::REGNUM_A6: return offsetof(T_CONTEXT, A6); + case ICorDebugInfo::REGNUM_A7: return offsetof(T_CONTEXT, A7); + case ICorDebugInfo::REGNUM_S2: return offsetof(T_CONTEXT, S2); + case ICorDebugInfo::REGNUM_S3: return offsetof(T_CONTEXT, S3); + case ICorDebugInfo::REGNUM_S4: return offsetof(T_CONTEXT, S4); + case ICorDebugInfo::REGNUM_S5: return offsetof(T_CONTEXT, S5); + case ICorDebugInfo::REGNUM_S6: return offsetof(T_CONTEXT, S6); + case ICorDebugInfo::REGNUM_S7: return offsetof(T_CONTEXT, S7); + case ICorDebugInfo::REGNUM_S8: return offsetof(T_CONTEXT, S8); + case ICorDebugInfo::REGNUM_S9: return offsetof(T_CONTEXT, S9); + case ICorDebugInfo::REGNUM_S10: return offsetof(T_CONTEXT, S10); + case ICorDebugInfo::REGNUM_S11: return offsetof(T_CONTEXT, S11); + case ICorDebugInfo::REGNUM_T3: return offsetof(T_CONTEXT, T3); + case ICorDebugInfo::REGNUM_T4: return offsetof(T_CONTEXT, T4); + case ICorDebugInfo::REGNUM_T5: return offsetof(T_CONTEXT, T5); + case ICorDebugInfo::REGNUM_T6: return offsetof(T_CONTEXT, T6); + case ICorDebugInfo::REGNUM_PC: return offsetof(T_CONTEXT, Pc); + case ICorDebugInfo::REGNUM_AMBIENT_SP: return offsetof(T_CONTEXT, Sp); + default: _ASSERTE(!"Bad regNum"); return (SIZE_T)(-1); + } #else PORTABILITY_ASSERT("GetRegOffsInCONTEXT is not implemented on this platform."); return (SIZE_T) -1; diff --git a/src/coreclr/vm/vars.cpp b/src/coreclr/vm/vars.cpp index 7ff76d014a4..ebd5310e40e 100644 --- a/src/coreclr/vm/vars.cpp +++ b/src/coreclr/vm/vars.cpp @@ -72,11 +72,6 @@ GPTR_IMPL(MethodTable, g_pBaseCOMObject); #endif GPTR_IMPL(MethodTable, g_pIDynamicInterfaceCastableInterface); - -#ifdef FEATURE_ICASTABLE -GPTR_IMPL(MethodTable, g_pICastableInterface); -#endif // FEATURE_ICASTABLE - GPTR_IMPL(MethodDesc, g_pObjectFinalizerMD); GPTR_IMPL(Thread,g_pFinalizerThread); diff --git a/src/coreclr/vm/vars.hpp b/src/coreclr/vm/vars.hpp index 5814aa1ee83..528d513e9d7 100644 --- a/src/coreclr/vm/vars.hpp +++ b/src/coreclr/vm/vars.hpp @@ -350,11 +350,6 @@ GPTR_DECL(MethodTable, g_pBaseCOMObject); #endif GPTR_DECL(MethodTable, g_pIDynamicInterfaceCastableInterface); - -#ifdef FEATURE_ICASTABLE -GPTR_DECL(MethodTable, g_pICastableInterface); -#endif // FEATURE_ICASTABLE - GPTR_DECL(MethodDesc, g_pObjectFinalizerMD); #ifdef FEATURE_INTEROP_DEBUGGING diff --git a/src/coreclr/vm/virtualcallstub.cpp b/src/coreclr/vm/virtualcallstub.cpp index 63669da4425..4ead0cadb8b 100644 --- a/src/coreclr/vm/virtualcallstub.cpp +++ b/src/coreclr/vm/virtualcallstub.cpp @@ -478,17 +478,14 @@ void VirtualCallStubManager::ResetCache() } -void VirtualCallStubManager::Init(BaseDomain *pDomain, LoaderAllocator *pLoaderAllocator) +void VirtualCallStubManager::Init(LoaderAllocator *pLoaderAllocator) { CONTRACTL { THROWS; GC_TRIGGERS; - PRECONDITION(CheckPointer(pDomain)); INJECT_FAULT(COMPlusThrowOM();); } CONTRACTL_END; - // Record the parent domain - parentDomain = pDomain; m_loaderAllocator = pLoaderAllocator; // @@ -1570,7 +1567,6 @@ PCODE VirtualCallStubManager::ResolveWorker(StubCallSite* pCallSite, #if defined(_DEBUG) if (!objectType->IsComObjectType() - && !objectType->IsICastable() && !objectType->IsIDynamicInterfaceCastable()) { CONSISTENCY_CHECK(!MethodTable::GetMethodDescForSlotAddress(target)->IsGenericMethodDefinition()); @@ -1975,9 +1971,13 @@ VirtualCallStubManager::Resolver( } } #ifdef FEATURE_COMINTEROP - else if (pMT->IsComObjectType() && IsInterfaceToken(token)) + else if (pMT->IsComObjectType() + && IsInterfaceToken(token) + && GetTypeFromToken(token) != CoreLibBinder::GetClass(CLASS__IENUMERABLE) // Interfaces handled by IDIC on __ComObject. + && GetTypeFromToken(token) != CoreLibBinder::GetClass(CLASS__IENUMERATOR) + && GetTypeFromToken(token) != CoreLibBinder::GetClass(CLASS__ICUSTOMADAPTER)) { - MethodTable * pItfMT = GetTypeFromToken(token); + MethodTable* pItfMT = GetTypeFromToken(token); implSlot = pItfMT->FindDispatchSlot(TYPE_ID_THIS_CLASS, token.GetSlotNumber(), throwOnConflict); _ASSERTE(!pItfMT->HasInstantiation()); @@ -1985,41 +1985,6 @@ VirtualCallStubManager::Resolver( fShouldPatch = TRUE; } #endif // FEATURE_COMINTEROP -#ifdef FEATURE_ICASTABLE - else if (pMT->IsICastable() && protectedObj != NULL && *protectedObj != NULL) - { - GCStress::MaybeTrigger(); - - // In case of ICastable, instead of trying to find method implementation in the real object type - // we call Resolver() again with whatever type it returns. - // It allows objects that implement ICastable to mimic behavior of other types. - MethodTable * pTokenMT = GetTypeFromToken(token); - - // Make call to ICastableHelpers.GetImplType(this, interfaceTypeObj) - PREPARE_NONVIRTUAL_CALLSITE(METHOD__ICASTABLEHELPERS__GETIMPLTYPE); - - OBJECTREF tokenManagedType = pTokenMT->GetManagedClassObject(); //GC triggers - - DECLARE_ARGHOLDER_ARRAY(args, 2); - args[ARGNUM_0] = OBJECTREF_TO_ARGHOLDER(*protectedObj); - args[ARGNUM_1] = OBJECTREF_TO_ARGHOLDER(tokenManagedType); - - OBJECTREF impTypeObj = NULL; - CALL_MANAGED_METHOD_RETREF(impTypeObj, OBJECTREF, args); - - INDEBUG(tokenManagedType = NULL); //tokenManagedType wasn't protected during the call - if (impTypeObj == NULL) // GetImplType returns default(RuntimeTypeHandle) - { - COMPlusThrow(kEntryPointNotFoundException); - } - - ReflectClassBaseObject* resultTypeObj = ((ReflectClassBaseObject*)OBJECTREFToObject(impTypeObj)); - TypeHandle resultTypeHnd = resultTypeObj->GetType(); - MethodTable *pResultMT = resultTypeHnd.GetMethodTable(); - - return Resolver(pResultMT, token, protectedObj, ppTarget, throwOnConflict); - } -#endif // FEATURE_ICASTABLE else if (pMT->IsIDynamicInterfaceCastable() && protectedObj != NULL && *protectedObj != NULL @@ -2230,8 +2195,7 @@ VirtualCallStubManager::GetTarget( // No match, now do full resolve BOOL fPatch; - // TODO: passing NULL as protectedObj here can lead to incorrect behavior for ICastable objects - // We need to review if this is the case and refactor this code if we want ICastable to become officially supported + // TODO: passing NULL as protectedObj here can lead to incorrect behavior for IDynamicInterfaceCastable objects fPatch = Resolver(pMT, token, NULL, &target, throwOnConflict); _ASSERTE(!throwOnConflict || target != (PCODE)NULL); @@ -3810,8 +3774,7 @@ MethodDesc *VirtualCallStubManagerManager::Entry2MethodDesc( DispatchToken token(VirtualCallStubManager::GetTokenFromStubQuick(pMgr, stubStartAddress, sk)); PCODE target = (PCODE)NULL; - // TODO: passing NULL as protectedObj here can lead to incorrect behavior for ICastable objects - // We need to review if this is the case and refactor this code if we want ICastable to become officially supported + // TODO: passing NULL as protectedObj here can lead to incorrect behavior for IDynamicInterfaceCastable objects VirtualCallStubManager::Resolver(pMT, token, NULL, &target, TRUE /* throwOnConflict */); return pMT->GetMethodDescForSlotAddress(target); diff --git a/src/coreclr/vm/virtualcallstub.h b/src/coreclr/vm/virtualcallstub.h index da7583ecdab..7638f2aec1e 100644 --- a/src/coreclr/vm/virtualcallstub.h +++ b/src/coreclr/vm/virtualcallstub.h @@ -239,7 +239,7 @@ class VirtualCallStubManager : public StubManager static void LogFinalStats(); // Per instance initialization - called during AppDomain::Init and ::Uninit and for collectible loader allocators - void Init(BaseDomain* pDomain, LoaderAllocator *pLoaderAllocator); + void Init(LoaderAllocator *pLoaderAllocator); void Uninit(); //@TODO: the logging should be tied into the VMs normal logging mechanisms, @@ -262,7 +262,6 @@ class VirtualCallStubManager : public StubManager VirtualCallStubManager() : StubManager(), cache_entry_rangeList(), - parentDomain(NULL), m_loaderAllocator(NULL), m_initialReservedMemForHeaps(NULL), m_FreeIndCellList(NULL), @@ -486,9 +485,6 @@ class VirtualCallStubManager : public StubManager TraceDestination *trace); private: - // The parent domain of this manager - PTR_BaseDomain parentDomain; - PTR_LoaderAllocator m_loaderAllocator; BYTE * m_initialReservedMemForHeaps; diff --git a/src/coreclr/vm/wellknownattributes.h b/src/coreclr/vm/wellknownattributes.h index 85a747b2c9a..aa7b9396149 100644 --- a/src/coreclr/vm/wellknownattributes.h +++ b/src/coreclr/vm/wellknownattributes.h @@ -29,7 +29,6 @@ enum class WellKnownAttribute : DWORD ManagedToNativeComInteropStub, UnmanagedCallConv, UnmanagedCallersOnly, - NativeCallableInternal, // This is needed to support MCG scenarios TypeIdentifier, UnmanagedFunctionPointer, ThreadStatic, @@ -92,8 +91,6 @@ inline const char *GetWellKnownAttributeName(WellKnownAttribute attribute) return "System.Runtime.InteropServices.UnmanagedCallConvAttribute"; case WellKnownAttribute::UnmanagedCallersOnly: return "System.Runtime.InteropServices.UnmanagedCallersOnlyAttribute"; - case WellKnownAttribute::NativeCallableInternal: - return "System.Runtime.InteropServices.NativeCallableInternalAttribute"; case WellKnownAttribute::TypeIdentifier: return "System.Runtime.InteropServices.TypeIdentifierAttribute"; case WellKnownAttribute::UnmanagedFunctionPointer: diff --git a/src/coreclr/vm/zapsig.cpp b/src/coreclr/vm/zapsig.cpp index 87d679e34b4..f4d1b7962f2 100644 --- a/src/coreclr/vm/zapsig.cpp +++ b/src/coreclr/vm/zapsig.cpp @@ -579,7 +579,7 @@ ModuleBase *ZapSig::DecodeModuleFromIndex(Module *fromModule, } else { - pAssembly = fromModule->LoadAssembly(RidToToken(index, mdtAssemblyRef))->GetAssembly(); + pAssembly = fromModule->LoadAssembly(RidToToken(index, mdtAssemblyRef)); } } else diff --git a/src/installer/managed/Microsoft.NET.HostModel/ResourceUpdater.cs b/src/installer/managed/Microsoft.NET.HostModel/ResourceUpdater.cs index 33872873612..e4791a6bb14 100644 --- a/src/installer/managed/Microsoft.NET.HostModel/ResourceUpdater.cs +++ b/src/installer/managed/Microsoft.NET.HostModel/ResourceUpdater.cs @@ -67,7 +67,7 @@ public ResourceUpdater AddResourcesFromPEImage(string peFile) if (_resourceData == null) ThrowExceptionForInvalidUpdate(); - using var module = new PEReader(File.Open(peFile, FileMode.Open, FileAccess.Read, FileShare.Read)); + using var module = new PEReader(File.OpenRead(peFile)); var moduleResources = new ResourceData(module); _resourceData.CopyResourcesFrom(moduleResources); return this; diff --git a/src/installer/pkg/sfx/Microsoft.NETCore.App/Directory.Build.props b/src/installer/pkg/sfx/Microsoft.NETCore.App/Directory.Build.props index d6af2ef9b78..6fd91975b78 100644 --- a/src/installer/pkg/sfx/Microsoft.NETCore.App/Directory.Build.props +++ b/src/installer/pkg/sfx/Microsoft.NETCore.App/Directory.Build.props @@ -6,7 +6,6 @@ $(MicrosoftNetCoreAppFrameworkName) false .NET Runtime - true + true - - - true diff --git a/src/libraries/Fuzzing/Directory.Build.props b/src/libraries/Fuzzing/Directory.Build.props index e21857f2f89..bc4d985cad2 100644 --- a/src/libraries/Fuzzing/Directory.Build.props +++ b/src/libraries/Fuzzing/Directory.Build.props @@ -1,6 +1,6 @@  - 9.0 + 10.0 net$(NetCoreAppCurrentVersion) $(NetCoreAppCurrentVersion).0 ..\..\Common\tests\TestUtilities diff --git a/src/libraries/Fuzzing/DotnetFuzzing.sln b/src/libraries/Fuzzing/DotnetFuzzing.sln index 367a6baee63..bfd3d21a714 100644 --- a/src/libraries/Fuzzing/DotnetFuzzing.sln +++ b/src/libraries/Fuzzing/DotnetFuzzing.sln @@ -1,5 +1,4 @@ - -Microsoft Visual Studio Solution File, Format Version 12.00 +Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 17 VisualStudioVersion = 17.11.34807.36 MinimumVisualStudioVersion = 10.0.40219.1 @@ -33,4 +32,4 @@ Global GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {0BAD3B6E-67D4-418D-A45F-49B3F79168DF} EndGlobalSection -EndGlobal +EndGlobal \ No newline at end of file diff --git a/src/libraries/Fuzzing/DotnetFuzzing/Assert.cs b/src/libraries/Fuzzing/DotnetFuzzing/Assert.cs index 810174ccbc1..a5f2a9dd1d1 100644 --- a/src/libraries/Fuzzing/DotnetFuzzing/Assert.cs +++ b/src/libraries/Fuzzing/DotnetFuzzing/Assert.cs @@ -18,6 +18,17 @@ static void Throw(T expected, T actual) => throw new Exception($"Expected={expected} Actual={actual}"); } + public static void NotNull(T value) + { + if (value == null) + { + ThrowNull(); + } + + static void ThrowNull() => + throw new Exception("Value is null"); + } + public static void SequenceEqual(ReadOnlySpan expected, ReadOnlySpan actual) { if (!expected.SequenceEqual(actual)) diff --git a/src/libraries/Fuzzing/DotnetFuzzing/Dictionaries/assemblynameinfo.dict b/src/libraries/Fuzzing/DotnetFuzzing/Dictionaries/assemblynameinfo.dict new file mode 100644 index 00000000000..f15a4c6c721 --- /dev/null +++ b/src/libraries/Fuzzing/DotnetFuzzing/Dictionaries/assemblynameinfo.dict @@ -0,0 +1,16 @@ +"MyAssemblyName, Version=1.0.0.0, PublicKeyToken=b77a5c561934e089" +"System.IO.Pipelines.Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001004b86c4cb78549b34bab61a3b1800e23bfeb5b3ec390074041536a7e3cbd97f5f04cf0f857155a8928eaa29ebfd11cfbbad3ba70efea7bda3226c6a8d370a4cd303f714486b6ebc225985a638471e6ef571cc92a4613c00b8fa65d61ccee0cbe5f36330c9a01f4183559f1bef24cc2917c6d913e3a541333a1d05d9bed22b38cb" +"System.IO.Pipelines.Tests, PublicKey=null" +"Abc, ProcessorArchitecture=X86" +"Abc, ProcessorArchitecture=Amd64" +"Abc, ProcessorArchitecture=Arm" +"Abc, ProcessorArchitecture=MSIL" +"Abc, ContentType=WindowsRuntime" +"Abc, Retargetable=Yes" +"Esc\\[aped" +"MyAssemblyName, Version=1.0.0.0, PublicKeyToken=b77a5c561934e089", "MyAssemblyName, Version=1.0.0.0, PublicKeyToken=b77a5c561934e089" +"MyAssemblyName, Version=1.0.0.0, PublicKey=00000000000000000400000000000000", "MyAssemblyName, Version=1.0.0.0, PublicKeyToken=b77a5c561934e089" +"TerraFX.Interop.Windows, PublicKey=002400000c800000940000000602000000240000525341310004000001000100897039f5ff762b25b9ba982c3f5836c34e299279c33df505bf806a07bccdf0e1216e661943f557b954cb18422ed522a5b3174b85385052677f39c4ce19f30a1ddbaa507054bc5943461651f396afc612cd80419c5ee2b5277571ff65f51d14ba99e4e4196de0f393e89850a465f019dbdc365ed5e81bbafe1370f54efd254ba8, TerraFX.Interop.Windows, PublicKeyToken=35b01b53313a6f7e" +"aaaa, language=en-en" +"aaaa, foo=bar, foo=baz" +"aa/name " \ No newline at end of file diff --git a/src/libraries/Fuzzing/DotnetFuzzing/Dictionaries/nrbfdecoder.dict b/src/libraries/Fuzzing/DotnetFuzzing/Dictionaries/nrbfdecoder.dict new file mode 100644 index 00000000000..1b8f14f961c --- /dev/null +++ b/src/libraries/Fuzzing/DotnetFuzzing/Dictionaries/nrbfdecoder.dict @@ -0,0 +1,16 @@ +# "Hello World!" +"\x00\x01\x00\x00\x00\xFF\xFF\xFF\xFF\x01\x00\x00\x00\x00\x00\x00\x00\x06\x01\x00\x00\x00\x0C\x48\x65\x6C\x6C\x6F\x20\x57\x6F\x72\x6C\x64\x21\x0B" +# new DateTime(2024, 2, 29) +"\x00\x01\x00\x00\x00\xFF\xFF\xFF\xFF\x01\x00\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x00\x0F\x53\x79\x73\x74\x65\x6D\x2E\x44\x61\x74\x65\x54\x69\x6D\x65\x02\x00\x00\x00\x05\x74\x69\x63\x6B\x73\x08\x64\x61\x74\x65\x44\x61\x74\x61\x00\x00\x09\x10\x00\x00\x60\x5F\xB9\x38\xDC\x08\x00\x00\x60\x5F\xB9\x38\xDC\x08\x0B" +# new int[] { 1, 2, 3 } +"\x00\x01\x00\x00\x00\xFF\xFF\xFF\xFF\x01\x00\x00\x00\x00\x00\x00\x00\x0F\x01\x00\x00\x00\x03\x00\x00\x00\x08\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x0B" +# new object[] { int.MaxValue, "string", null } +"\x00\x01\x00\x00\x00\xFF\xFF\xFF\xFF\x01\x00\x00\x00\x00\x00\x00\x00\x10\x01\x00\x00\x00\x03\x00\x00\x00\x08\x08\xFF\xFF\xFF\x7F\x06\x02\x00\x00\x00\x06\x73\x74\x72\x69\x6E\x67\x0A\x0B" +# new int?[Array.MaxLength] (plenty of nulls) +"\x00\x01\x00\x00\x00\xFF\xFF\xFF\xFF\x01\x00\x00\x00\x00\x00\x00\x00\x07\x01\x00\x00\x00\x00\x01\x00\x00\x00\xC7\xFF\xFF\x7F\x03\x6E\x53\x79\x73\x74\x65\x6D\x2E\x4E\x75\x6C\x6C\x61\x62\x6C\x65\x60\x31\x5B\x5B\x53\x79\x73\x74\x65\x6D\x2E\x49\x6E\x74\x33\x32\x2C\x20\x6D\x73\x63\x6F\x72\x6C\x69\x62\x2C\x20\x56\x65\x72\x73\x69\x6F\x6E\x3D\x34\x2E\x30\x2E\x30\x2E\x30\x2C\x20\x43\x75\x6C\x74\x75\x72\x65\x3D\x6E\x65\x75\x74\x72\x61\x6C\x2C\x20\x50\x75\x62\x6C\x69\x63\x4B\x65\x79\x54\x6F\x6B\x65\x6E\x3D\x62\x37\x37\x61\x35\x63\x35\x36\x31\x39\x33\x34\x65\x30\x38\x39\x5D\x5D\x0E\xC7\xFF\xFF\x7F\x0B" +# [["jagged", "array"], ["of", "strings"]] +"\x00\x01\x00\x00\x00\xFF\xFF\xFF\xFF\x01\x00\x00\x00\x00\x00\x00\x00\x07\x01\x00\x00\x00\x01\x01\x00\x00\x00\x02\x00\x00\x00\x06\x09\x02\x00\x00\x00\x09\x03\x00\x00\x00\x11\x02\x00\x00\x00\x02\x00\x00\x00\x06\x04\x00\x00\x00\x06\x6A\x61\x67\x67\x65\x64\x06\x05\x00\x00\x00\x05\x61\x72\x72\x61\x79\x11\x03\x00\x00\x00\x02\x00\x00\x00\x06\x06\x00\x00\x00\x02\x6F\x66\x06\x07\x00\x00\x00\x07\x73\x74\x72\x69\x6E\x67\x73\x0B" +# new Dictionary { { "1", true }, { "2", false } } +"\x00\x01\x00\x00\x00\xFF\xFF\xFF\xFF\x01\x00\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x00\xE3\x01\x53\x79\x73\x74\x65\x6D\x2E\x43\x6F\x6C\x6C\x65\x63\x74\x69\x6F\x6E\x73\x2E\x47\x65\x6E\x65\x72\x69\x63\x2E\x44\x69\x63\x74\x69\x6F\x6E\x61\x72\x79\x60\x32\x5B\x5B\x53\x79\x73\x74\x65\x6D\x2E\x53\x74\x72\x69\x6E\x67\x2C\x20\x6D\x73\x63\x6F\x72\x6C\x69\x62\x2C\x20\x56\x65\x72\x73\x69\x6F\x6E\x3D\x34\x2E\x30\x2E\x30\x2E\x30\x2C\x20\x43\x75\x6C\x74\x75\x72\x65\x3D\x6E\x65\x75\x74\x72\x61\x6C\x2C\x20\x50\x75\x62\x6C\x69\x63\x4B\x65\x79\x54\x6F\x6B\x65\x6E\x3D\x62\x37\x37\x61\x35\x63\x35\x36\x31\x39\x33\x34\x65\x30\x38\x39\x5D\x2C\x5B\x53\x79\x73\x74\x65\x6D\x2E\x42\x6F\x6F\x6C\x65\x61\x6E\x2C\x20\x6D\x73\x63\x6F\x72\x6C\x69\x62\x2C\x20\x56\x65\x72\x73\x69\x6F\x6E\x3D\x34\x2E\x30\x2E\x30\x2E\x30\x2C\x20\x43\x75\x6C\x74\x75\x72\x65\x3D\x6E\x65\x75\x74\x72\x61\x6C\x2C\x20\x50\x75\x62\x6C\x69\x63\x4B\x65\x79\x54\x6F\x6B\x65\x6E\x3D\x62\x37\x37\x61\x35\x63\x35\x36\x31\x39\x33\x34\x65\x30\x38\x39\x5D\x5D\x04\x00\x00\x00\x07\x56\x65\x72\x73\x69\x6F\x6E\x08\x43\x6F\x6D\x70\x61\x72\x65\x72\x08\x48\x61\x73\x68\x53\x69\x7A\x65\x0D\x4B\x65\x79\x56\x61\x6C\x75\x65\x50\x61\x69\x72\x73\x00\x03\x00\x03\x08\x92\x01\x53\x79\x73\x74\x65\x6D\x2E\x43\x6F\x6C\x6C\x65\x63\x74\x69\x6F\x6E\x73\x2E\x47\x65\x6E\x65\x72\x69\x63\x2E\x47\x65\x6E\x65\x72\x69\x63\x45\x71\x75\x61\x6C\x69\x74\x79\x43\x6F\x6D\x70\x61\x72\x65\x72\x60\x31\x5B\x5B\x53\x79\x73\x74\x65\x6D\x2E\x53\x74\x72\x69\x6E\x67\x2C\x20\x6D\x73\x63\x6F\x72\x6C\x69\x62\x2C\x20\x56\x65\x72\x73\x69\x6F\x6E\x3D\x34\x2E\x30\x2E\x30\x2E\x30\x2C\x20\x43\x75\x6C\x74\x75\x72\x65\x3D\x6E\x65\x75\x74\x72\x61\x6C\x2C\x20\x50\x75\x62\x6C\x69\x63\x4B\x65\x79\x54\x6F\x6B\x65\x6E\x3D\x62\x37\x37\x61\x35\x63\x35\x36\x31\x39\x33\x34\x65\x30\x38\x39\x5D\x5D\x08\xE7\x01\x53\x79\x73\x74\x65\x6D\x2E\x43\x6F\x6C\x6C\x65\x63\x74\x69\x6F\x6E\x73\x2E\x47\x65\x6E\x65\x72\x69\x63\x2E\x4B\x65\x79\x56\x61\x6C\x75\x65\x50\x61\x69\x72\x60\x32\x5B\x5B\x53\x79\x73\x74\x65\x6D\x2E\x53\x74\x72\x69\x6E\x67\x2C\x20\x6D\x73\x63\x6F\x72\x6C\x69\x62\x2C\x20\x56\x65\x72\x73\x69\x6F\x6E\x3D\x34\x2E\x30\x2E\x30\x2E\x30\x2C\x20\x43\x75\x6C\x74\x75\x72\x65\x3D\x6E\x65\x75\x74\x72\x61\x6C\x2C\x20\x50\x75\x62\x6C\x69\x63\x4B\x65\x79\x54\x6F\x6B\x65\x6E\x3D\x62\x37\x37\x61\x35\x63\x35\x36\x31\x39\x33\x34\x65\x30\x38\x39\x5D\x2C\x5B\x53\x79\x73\x74\x65\x6D\x2E\x42\x6F\x6F\x6C\x65\x61\x6E\x2C\x20\x6D\x73\x63\x6F\x72\x6C\x69\x62\x2C\x20\x56\x65\x72\x73\x69\x6F\x6E\x3D\x34\x2E\x30\x2E\x30\x2E\x30\x2C\x20\x43\x75\x6C\x74\x75\x72\x65\x3D\x6E\x65\x75\x74\x72\x61\x6C\x2C\x20\x50\x75\x62\x6C\x69\x63\x4B\x65\x79\x54\x6F\x6B\x65\x6E\x3D\x62\x37\x37\x61\x35\x63\x35\x36\x31\x39\x33\x34\x65\x30\x38\x39\x5D\x5D\x5B\x5D\x02\x00\x00\x00\x09\x02\x00\x00\x00\x03\x00\x00\x00\x09\x03\x00\x00\x00\x04\x02\x00\x00\x00\x92\x01\x53\x79\x73\x74\x65\x6D\x2E\x43\x6F\x6C\x6C\x65\x63\x74\x69\x6F\x6E\x73\x2E\x47\x65\x6E\x65\x72\x69\x63\x2E\x47\x65\x6E\x65\x72\x69\x63\x45\x71\x75\x61\x6C\x69\x74\x79\x43\x6F\x6D\x70\x61\x72\x65\x72\x60\x31\x5B\x5B\x53\x79\x73\x74\x65\x6D\x2E\x53\x74\x72\x69\x6E\x67\x2C\x20\x6D\x73\x63\x6F\x72\x6C\x69\x62\x2C\x20\x56\x65\x72\x73\x69\x6F\x6E\x3D\x34\x2E\x30\x2E\x30\x2E\x30\x2C\x20\x43\x75\x6C\x74\x75\x72\x65\x3D\x6E\x65\x75\x74\x72\x61\x6C\x2C\x20\x50\x75\x62\x6C\x69\x63\x4B\x65\x79\x54\x6F\x6B\x65\x6E\x3D\x62\x37\x37\x61\x35\x63\x35\x36\x31\x39\x33\x34\x65\x30\x38\x39\x5D\x5D\x00\x00\x00\x00\x07\x03\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\xE5\x01\x53\x79\x73\x74\x65\x6D\x2E\x43\x6F\x6C\x6C\x65\x63\x74\x69\x6F\x6E\x73\x2E\x47\x65\x6E\x65\x72\x69\x63\x2E\x4B\x65\x79\x56\x61\x6C\x75\x65\x50\x61\x69\x72\x60\x32\x5B\x5B\x53\x79\x73\x74\x65\x6D\x2E\x53\x74\x72\x69\x6E\x67\x2C\x20\x6D\x73\x63\x6F\x72\x6C\x69\x62\x2C\x20\x56\x65\x72\x73\x69\x6F\x6E\x3D\x34\x2E\x30\x2E\x30\x2E\x30\x2C\x20\x43\x75\x6C\x74\x75\x72\x65\x3D\x6E\x65\x75\x74\x72\x61\x6C\x2C\x20\x50\x75\x62\x6C\x69\x63\x4B\x65\x79\x54\x6F\x6B\x65\x6E\x3D\x62\x37\x37\x61\x35\x63\x35\x36\x31\x39\x33\x34\x65\x30\x38\x39\x5D\x2C\x5B\x53\x79\x73\x74\x65\x6D\x2E\x42\x6F\x6F\x6C\x65\x61\x6E\x2C\x20\x6D\x73\x63\x6F\x72\x6C\x69\x62\x2C\x20\x56\x65\x72\x73\x69\x6F\x6E\x3D\x34\x2E\x30\x2E\x30\x2E\x30\x2C\x20\x43\x75\x6C\x74\x75\x72\x65\x3D\x6E\x65\x75\x74\x72\x61\x6C\x2C\x20\x50\x75\x62\x6C\x69\x63\x4B\x65\x79\x54\x6F\x6B\x65\x6E\x3D\x62\x37\x37\x61\x35\x63\x35\x36\x31\x39\x33\x34\x65\x30\x38\x39\x5D\x5D\x04\xFC\xFF\xFF\xFF\xE5\x01\x53\x79\x73\x74\x65\x6D\x2E\x43\x6F\x6C\x6C\x65\x63\x74\x69\x6F\x6E\x73\x2E\x47\x65\x6E\x65\x72\x69\x63\x2E\x4B\x65\x79\x56\x61\x6C\x75\x65\x50\x61\x69\x72\x60\x32\x5B\x5B\x53\x79\x73\x74\x65\x6D\x2E\x53\x74\x72\x69\x6E\x67\x2C\x20\x6D\x73\x63\x6F\x72\x6C\x69\x62\x2C\x20\x56\x65\x72\x73\x69\x6F\x6E\x3D\x34\x2E\x30\x2E\x30\x2E\x30\x2C\x20\x43\x75\x6C\x74\x75\x72\x65\x3D\x6E\x65\x75\x74\x72\x61\x6C\x2C\x20\x50\x75\x62\x6C\x69\x63\x4B\x65\x79\x54\x6F\x6B\x65\x6E\x3D\x62\x37\x37\x61\x35\x63\x35\x36\x31\x39\x33\x34\x65\x30\x38\x39\x5D\x2C\x5B\x53\x79\x73\x74\x65\x6D\x2E\x42\x6F\x6F\x6C\x65\x61\x6E\x2C\x20\x6D\x73\x63\x6F\x72\x6C\x69\x62\x2C\x20\x56\x65\x72\x73\x69\x6F\x6E\x3D\x34\x2E\x30\x2E\x30\x2E\x30\x2C\x20\x43\x75\x6C\x74\x75\x72\x65\x3D\x6E\x65\x75\x74\x72\x61\x6C\x2C\x20\x50\x75\x62\x6C\x69\x63\x4B\x65\x79\x54\x6F\x6B\x65\x6E\x3D\x62\x37\x37\x61\x35\x63\x35\x36\x31\x39\x33\x34\x65\x30\x38\x39\x5D\x5D\x02\x00\x00\x00\x03\x6B\x65\x79\x05\x76\x61\x6C\x75\x65\x01\x00\x01\x06\x05\x00\x00\x00\x01\x31\x01\x01\xFA\xFF\xFF\xFF\xFC\xFF\xFF\xFF\x06\x07\x00\x00\x00\x01\x32\x00\x0B" +# new ComplexType2D { I = 1, J = 2 } (non-system class) +"\x00\x01\x00\x00\x00\xFF\xFF\xFF\xFF\x01\x00\x00\x00\x00\x00\x00\x00\x0C\x02\x00\x00\x00\x3D\x42\x66\x44\x65\x6D\x6F\x2C\x20\x56\x65\x72\x73\x69\x6F\x6E\x3D\x31\x2E\x30\x2E\x30\x2E\x30\x2C\x20\x43\x75\x6C\x74\x75\x72\x65\x3D\x6E\x65\x75\x74\x72\x61\x6C\x2C\x20\x50\x75\x62\x6C\x69\x63\x4B\x65\x79\x54\x6F\x6B\x65\x6E\x3D\x6E\x75\x6C\x6C\x05\x01\x00\x00\x00\x14\x42\x66\x44\x65\x6D\x6F\x2E\x43\x6F\x6D\x70\x6C\x65\x78\x54\x79\x70\x65\x32\x44\x02\x00\x00\x00\x01\x49\x01\x4A\x00\x00\x08\x08\x02\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x0B" \ No newline at end of file diff --git a/src/libraries/Fuzzing/DotnetFuzzing/Dictionaries/typename.dict b/src/libraries/Fuzzing/DotnetFuzzing/Dictionaries/typename.dict new file mode 100644 index 00000000000..1380ac70af0 --- /dev/null +++ b/src/libraries/Fuzzing/DotnetFuzzing/Dictionaries/typename.dict @@ -0,0 +1,26 @@ +" " +"0" +"," +"[*[" +" System.Int32 " +"System.Int32&&" +"System.Int32[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,]" +"System.Int32[*******************************]" +"System.Int32[][][][][][][][][][][][][][][][][][][][]" +".NoNamespace" +"Namespace.Ko\xC5\x9B\xC4\x87" +"Declaring+Nested" +"Declaring+Deep+Deeper+Nested" +"Declaring+Deep+Deeper+Nested, Lib" +"MyNamespace.MyType+NestedType" +"Pointer*******" +"Generic`1[[A]]" +"Generic`2[[A],[B]]" +"Generic`3[[A],[B],[C]]" +"Generic`3[A,B,C]" +"Generic`2[[System.Int32, mscorlib, Version=4.0.0, Culture=neutral, PublicKeyToken=b77a5c561934],[System.Boolean, mscorlib, Version=5.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]" +"Generic`3[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089], System.Boolean, [System.Byte, other, Version=, Culture=neutral, PublicKeyToken=b77a5c561934e089]]" +"TypeNameWith\\TheEscapingCharacter" +"TypeNameWith[[]]NestedSquareBrackets" +"TypeNameWith\\[]+*&,AllSpecialCharacters" +"System.Reflection.Metadata.Tests.TypeNameTests+NestedGeneric_0`1+NestedGeneric_1`2+NestedGeneric_2`3+NestedNonGeneric_3[[System.Int32, System.Private.CoreLib, Version=9.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e],[System.String, System.Private.CoreLib, Version=9.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e],[System.Boolean, System.Private.CoreLib, Version=9.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e],[System.Int16, System.Private.CoreLib, Version=9.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e],[System.Byte, System.Private.CoreLib, Version=9.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e],[System.SByte, System.Private.CoreLib, Version=9.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e]], System.Reflection.Metadata.Tests, Version=9.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51" \ No newline at end of file diff --git a/src/libraries/Fuzzing/DotnetFuzzing/DotnetFuzzing.csproj b/src/libraries/Fuzzing/DotnetFuzzing/DotnetFuzzing.csproj index 6db5eb5a9ed..82f54f412ac 100644 --- a/src/libraries/Fuzzing/DotnetFuzzing/DotnetFuzzing.csproj +++ b/src/libraries/Fuzzing/DotnetFuzzing/DotnetFuzzing.csproj @@ -2,7 +2,7 @@ Exe - $(NetCoreAppCurrent)-windows + net9.0-windows true enable enable @@ -30,4 +30,8 @@ + + + + diff --git a/src/libraries/Fuzzing/DotnetFuzzing/Fuzzers/AssemblyNameInfoFuzzer.cs b/src/libraries/Fuzzing/DotnetFuzzing/Fuzzers/AssemblyNameInfoFuzzer.cs new file mode 100644 index 00000000000..d166726665a --- /dev/null +++ b/src/libraries/Fuzzing/DotnetFuzzing/Fuzzers/AssemblyNameInfoFuzzer.cs @@ -0,0 +1,80 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Buffers; +using System.Reflection.Metadata; +using System.Runtime.InteropServices; +using System.Text; + +namespace DotnetFuzzing.Fuzzers +{ + internal sealed class AssemblyNameInfoFuzzer : IFuzzer + { + public string[] TargetAssemblies => ["System.Reflection.Metadata"]; + + public string[] TargetCoreLibPrefixes => []; + + public string Dictionary => "assemblynameinfo.dict"; + + public void FuzzTarget(ReadOnlySpan bytes) + { + Span chars = new char[Encoding.UTF8.GetCharCount(bytes)]; + Encoding.UTF8.GetChars(bytes, chars); + + using PooledBoundedMemory inputPoisonedBefore = PooledBoundedMemory.Rent(chars, PoisonPagePlacement.Before); + using PooledBoundedMemory inputPoisonedAfter = PooledBoundedMemory.Rent(chars, PoisonPagePlacement.After); + + Test(inputPoisonedBefore.Span); + Test(inputPoisonedAfter.Span); + } + + private static void Test(Span span) + { + if (AssemblyNameInfo.TryParse(span, out AssemblyNameInfo? fromTryParse)) + { + AssemblyNameInfo fromParse = AssemblyNameInfo.Parse(span); + + Assert.Equal(fromTryParse.Name, fromParse.Name); + Assert.Equal(fromTryParse.FullName, fromParse.FullName); + Assert.Equal(fromTryParse.CultureName, fromParse.CultureName); + Assert.Equal(fromTryParse.Flags, fromParse.Flags); + Assert.Equal(fromTryParse.Version, fromParse.Version); + Assert.SequenceEqual(fromTryParse.PublicKeyOrToken.AsSpan(), fromParse.PublicKeyOrToken.AsSpan()); + + Assert.Equal(fromTryParse.ToAssemblyName().Name, fromParse.ToAssemblyName().Name); + Assert.Equal(fromTryParse.ToAssemblyName().Version, fromParse.ToAssemblyName().Version); + Assert.Equal(fromTryParse.ToAssemblyName().ContentType, fromParse.ToAssemblyName().ContentType); + Assert.Equal(fromTryParse.ToAssemblyName().CultureName, fromParse.ToAssemblyName().CultureName); + + Assert.Equal(fromTryParse.Name, fromParse.ToAssemblyName().Name); + Assert.Equal(fromTryParse.CultureName, fromParse.ToAssemblyName().CultureName); + Assert.Equal(fromTryParse.Version, fromParse.ToAssemblyName().Version); + + // AssemblyNameInfo.FullName can be different than AssemblyName.FullName: + // AssemblyNameInfo includes public key, AssemblyName only its Token. + + try + { + Assert.Equal(fromTryParse.ToAssemblyName().FullName, fromParse.ToAssemblyName().FullName); + } + catch (System.Security.SecurityException) + { + // AssemblyName.FullName performs public key validation, AssemblyNameInfo does not (on purpose). + } + } + else + { + try + { + _ = AssemblyNameInfo.Parse(span); + } + catch (ArgumentException) + { + return; + } + + throw new Exception("Parsing was supposed to fail!"); + } + } + } +} diff --git a/src/libraries/Fuzzing/DotnetFuzzing/Fuzzers/Base64UrlFuzzer.cs b/src/libraries/Fuzzing/DotnetFuzzing/Fuzzers/Base64UrlFuzzer.cs new file mode 100644 index 00000000000..e65b2df740d --- /dev/null +++ b/src/libraries/Fuzzing/DotnetFuzzing/Fuzzers/Base64UrlFuzzer.cs @@ -0,0 +1,136 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Buffers; +using System.Buffers.Text; +using System.Formats.Asn1; +using System.Reflection; + +namespace DotnetFuzzing.Fuzzers +{ + internal sealed class Base64UrlFuzzer : IFuzzer + { + public string[] TargetAssemblies => []; + + public string[] TargetCoreLibPrefixes => ["System.Buffers.Text"]; + + public void FuzzTarget(ReadOnlySpan bytes) + { + int encodedLength = Base64Url.GetEncodedLength(bytes.Length); + int maxDecodedLength = Base64Url.GetMaxDecodedLength(encodedLength); + + using PooledBoundedMemory inputPoisoned = PooledBoundedMemory.Rent(bytes, PoisonPagePlacement.After); + using PooledBoundedMemory destPoisoned = PooledBoundedMemory.Rent(encodedLength, PoisonPagePlacement.After); + using PooledBoundedMemory decoderDestPoisoned = PooledBoundedMemory.Rent(maxDecodedLength, PoisonPagePlacement.After); + + Span input = inputPoisoned.Span; + Span encoderDest = destPoisoned.Span; + Span decoderDest = decoderDestPoisoned.Span; + + { // IsFinalBlock = true + OperationStatus status = Base64Url.EncodeToChars(input, encoderDest, out int bytesConsumed, out int bytesEncoded); + + Assert.Equal(OperationStatus.Done, status); + Assert.Equal(bytes.Length, bytesConsumed); + Assert.Equal(true, encodedLength == bytesEncoded); + + string encodedString = Base64Url.EncodeToString(input); + Assert.Equal(encodedString, new string(encoderDest)); + + status = Base64Url.DecodeFromChars(encoderDest, decoderDest, out int bytesRead, out int bytesDecoded); + + Assert.Equal(OperationStatus.Done, status); + Assert.Equal(bytes.Length, bytesDecoded); + Assert.Equal(bytesEncoded, bytesRead); + Assert.SequenceEqual(bytes, decoderDest.Slice(0, bytesDecoded)); + } + + { // IsFinalBlock = false + encoderDest.Clear(); + decoderDest.Clear(); + OperationStatus status = Base64Url.EncodeToChars(input, encoderDest, out int bytesConsumed, out int bytesEncoded, isFinalBlock: false); + Span decodeInput = encoderDest.Slice(0, bytesEncoded); + + if (bytes.Length % 3 == 0) + { + Assert.Equal(OperationStatus.Done, status); + Assert.Equal(bytes.Length, bytesConsumed); + Assert.Equal(true, encodedLength == bytesEncoded); + + status = Base64Url.DecodeFromChars(decodeInput, decoderDest, out int bytesRead, out int bytesDecoded, isFinalBlock: false); + + Assert.Equal(OperationStatus.Done, status); + Assert.Equal(bytes.Length, bytesDecoded); + Assert.Equal(bytesEncoded, bytesRead); + Assert.SequenceEqual(bytes, decoderDest.Slice(0, bytesDecoded)); + } + else + { + Assert.Equal(OperationStatus.NeedMoreData, status); + Assert.Equal(true, input.Length / 3 * 4 == bytesEncoded); + + status = Base64Url.DecodeFromChars(decodeInput, decoderDest, out int bytesRead, out int bytesDecoded, isFinalBlock: false); + + if (decodeInput.Length % 4 == 0) + { + Assert.Equal(OperationStatus.Done, status); + Assert.Equal(bytesConsumed, bytesDecoded); + Assert.Equal(bytesEncoded, bytesRead); + } + else + { + Assert.Equal(OperationStatus.NeedMoreData, status); + } + + Assert.SequenceEqual(bytes.Slice(0, bytesDecoded), decoderDest.Slice(0, bytesDecoded)); + } + } + + { // Encode / decode in place + using PooledBoundedMemory destPoisoned2 = PooledBoundedMemory.Rent(encodedLength, PoisonPagePlacement.After); + Span tryEncode = destPoisoned2.Span; + input.CopyTo(tryEncode); + + Assert.Equal(true, Base64Url.TryEncodeToUtf8InPlace(tryEncode, input.Length, out int bytesEncoded)); + Assert.Equal(encodedLength, bytesEncoded); + + int bytesDecoded = Base64Url.DecodeFromUtf8InPlace(tryEncode); + + Assert.Equal(bytes.Length, bytesDecoded); + Assert.SequenceEqual(bytes, tryEncode.Slice(0, bytesDecoded)); + } + + { // Decode the random input directly, Assert IsValid result matches with decoded result + decoderDest.Clear(); + if (Base64Url.IsValid(input, out int decodedLength)) + { + maxDecodedLength = Base64Url.GetMaxDecodedLength(input.Length); + OperationStatus status = Base64Url.DecodeFromUtf8(input, decoderDest, out int bytesRead, out int bytesDecoded); + Assert.Equal(OperationStatus.Done, status); + Assert.Equal(input.Length, bytesRead); + Assert.Equal(decodedLength, bytesDecoded); + Assert.Equal(true, maxDecodedLength >= bytesDecoded); + + Span tryDecode = new byte[maxDecodedLength]; + Assert.Equal(true, Base64Url.TryDecodeFromUtf8(input, tryDecode, out bytesDecoded)); + Assert.Equal(decodedLength, bytesDecoded); + Assert.SequenceEqual(tryDecode.Slice(0, bytesDecoded), decoderDest.Slice(0, bytesDecoded)); + + int decoded = Base64Url.DecodeFromUtf8InPlace(input); + Assert.Equal(OperationStatus.Done, status); + Assert.Equal(bytesDecoded, decoded); + Assert.SequenceEqual(input.Slice(0, decoded), decoderDest.Slice(0, bytesDecoded)); + } + else + { + Assert.Equal(OperationStatus.InvalidData, Base64Url.DecodeFromUtf8(input, decoderDest, out int _, out int bytesDecoded)); + try + { + Assert.Equal(0, Base64Url.DecodeFromUtf8InPlace(input)); + } + catch (FormatException) { /* DecodeFromUtf8InPlace would throw FormatException for InvalidData*/ } + } + } + } + } +} diff --git a/src/libraries/Fuzzing/DotnetFuzzing/Fuzzers/NrbfDecoderFuzzer.cs b/src/libraries/Fuzzing/DotnetFuzzing/Fuzzers/NrbfDecoderFuzzer.cs new file mode 100644 index 00000000000..5c6397187ff --- /dev/null +++ b/src/libraries/Fuzzing/DotnetFuzzing/Fuzzers/NrbfDecoderFuzzer.cs @@ -0,0 +1,126 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Buffers; +using System.Formats.Nrbf; +using System.Runtime.Serialization; +using System.Text; + +namespace DotnetFuzzing.Fuzzers +{ + internal sealed class NrbfDecoderFuzzer : IFuzzer + { + public string[] TargetAssemblies { get; } = ["System.Formats.Nrbf"]; + + public string[] TargetCoreLibPrefixes => []; + + public string Dictionary => "nrbfdecoder.dict"; + + public void FuzzTarget(ReadOnlySpan bytes) + { + Test(bytes, PoisonPagePlacement.Before); + Test(bytes, PoisonPagePlacement.After); + } + + private static void Test(ReadOnlySpan bytes, PoisonPagePlacement poisonPagePlacement) + { + using PooledBoundedMemory inputPoisoned = PooledBoundedMemory.Rent(bytes, poisonPagePlacement); + + using MemoryStream seekableStream = new(inputPoisoned.Memory.ToArray()); + Test(inputPoisoned.Span, seekableStream); + + // NrbfDecoder has few code paths dedicated to non-seekable streams, let's test them as well. + using NonSeekableStream nonSeekableStream = new(inputPoisoned.Memory.ToArray()); + Test(inputPoisoned.Span, nonSeekableStream); + } + + private static void Test(Span testSpan, Stream stream) + { + if (NrbfDecoder.StartsWithPayloadHeader(testSpan)) + { + try + { + SerializationRecord record = NrbfDecoder.Decode(stream, out IReadOnlyDictionary recordMap); + switch (record.RecordType) + { + case SerializationRecordType.ArraySingleObject: + SZArrayRecord arrayObj = (SZArrayRecord)record; + object?[] objArray = arrayObj.GetArray(); + Assert.Equal(arrayObj.Length, objArray.Length); + Assert.Equal(1, arrayObj.Rank); + break; + case SerializationRecordType.ArraySingleString: + SZArrayRecord arrayString = (SZArrayRecord)record; + string?[] array = arrayString.GetArray(); + Assert.Equal(arrayString.Length, array.Length); + Assert.Equal(1, arrayString.Rank); + Assert.Equal(true, arrayString.TypeNameMatches(typeof(string[]))); + break; + case SerializationRecordType.ArraySinglePrimitive: + case SerializationRecordType.BinaryArray: + ArrayRecord arrayBinary = (ArrayRecord)record; + Assert.NotNull(arrayBinary.TypeName); + break; + case SerializationRecordType.BinaryObjectString: + _ = ((PrimitiveTypeRecord)record).Value; + break; + case SerializationRecordType.ClassWithId: + case SerializationRecordType.ClassWithMembersAndTypes: + case SerializationRecordType.SystemClassWithMembersAndTypes: + ClassRecord classRecord = (ClassRecord)record; + Assert.NotNull(classRecord.TypeName); + + foreach (string name in classRecord.MemberNames) + { + Assert.Equal(true, classRecord.HasMember(name)); + } + break; + case SerializationRecordType.MemberPrimitiveTyped: + PrimitiveTypeRecord primitiveType = (PrimitiveTypeRecord)record; + Assert.NotNull(primitiveType.Value); + break; + case SerializationRecordType.MemberReference: + Assert.NotNull(record.TypeName); + break; + case SerializationRecordType.BinaryLibrary: + Assert.Equal(false, record.Id.Equals(default)); + break; + case SerializationRecordType.ObjectNull: + case SerializationRecordType.ObjectNullMultiple: + case SerializationRecordType.ObjectNullMultiple256: + Assert.Equal(default, record.Id); + break; + case SerializationRecordType.MessageEnd: + case SerializationRecordType.SerializedStreamHeader: + // case SerializationRecordType.ClassWithMembers: will cause NotSupportedException + // case SerializationRecordType.SystemClassWithMembers: will cause NotSupportedException + default: + throw new Exception("Unexpected RecordType"); + } + } + catch (SerializationException) { /* Reading from the stream encountered invalid NRBF data.*/ } + catch (NotSupportedException) { /* Reading from the stream encountered unsupported records */ } + catch (DecoderFallbackException) { /* Reading from the stream encountered an invalid UTF8 sequence. */ } + catch (EndOfStreamException) { /* The end of the stream was reached before reading SerializationRecordType.MessageEnd record. */ } + catch (IOException) { /* An I/O error occurred. */ } + } + else + { + try + { + NrbfDecoder.Decode(stream); + throw new Exception("Decoding supposed to fail!"); + } + catch (SerializationException) { /* Everything has to start with a header */ } + catch (NotSupportedException) { /* Reading from the stream encountered unsupported records */ } + catch (EndOfStreamException) { /* The end of the stream was reached before reading SerializationRecordType.MessageEnd record. */ } + } + } + + private class NonSeekableStream : MemoryStream + { + public NonSeekableStream(byte[] buffer) : base(buffer) { } + public override bool CanSeek => false; + } + } +} diff --git a/src/libraries/Fuzzing/DotnetFuzzing/Fuzzers/TypeNameFuzzer.cs b/src/libraries/Fuzzing/DotnetFuzzing/Fuzzers/TypeNameFuzzer.cs new file mode 100644 index 00000000000..0a189da4f18 --- /dev/null +++ b/src/libraries/Fuzzing/DotnetFuzzing/Fuzzers/TypeNameFuzzer.cs @@ -0,0 +1,63 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Buffers; +using System.Reflection.Metadata; +using System.Text; + +namespace DotnetFuzzing.Fuzzers +{ + internal sealed class TypeNameFuzzer : IFuzzer + { + public string[] TargetAssemblies { get; } = ["System.Reflection.Metadata"]; + public string[] TargetCoreLibPrefixes => []; + public string Dictionary => "typename.dict"; + + public void FuzzTarget(ReadOnlySpan bytes) + { + Span charSpan = new char[Encoding.UTF8.GetCharCount(bytes)]; + Encoding.UTF8.GetChars(bytes, charSpan); + using var poisonAfter = PooledBoundedMemory.Rent(charSpan, PoisonPagePlacement.After); + using var poisonBefore = PooledBoundedMemory.Rent(charSpan, PoisonPagePlacement.Before); + + Test(poisonAfter.Span); + Test(poisonBefore.Span); + } + + private static void Test(Span testSpan) + { + if (TypeName.TryParse(testSpan, out TypeName? result1)) + { + TypeName result2 = TypeName.Parse(testSpan); + Assert.Equal(result1.Name, result2.Name); + Assert.Equal(result1.FullName, result2.FullName); + Assert.Equal(result1.AssemblyQualifiedName, result2.AssemblyQualifiedName); + Assert.Equal(result1.IsSimple, result2.IsSimple); + Assert.Equal(result1.IsNested, result2.IsNested); + Assert.Equal(result1.IsArray, result2.IsArray); + Assert.Equal(result1.GetNodeCount(), result2.GetNodeCount()); + if (result1.AssemblyName != null) + { + Assert.Equal(result1.AssemblyName.Name, result2.AssemblyName!.Name); + Assert.Equal(result1.AssemblyName.FullName, result2.AssemblyName.FullName); + Assert.Equal(result1.AssemblyName.CultureName, result2.AssemblyName.CultureName); + Assert.Equal(result1.AssemblyName.Version?.ToString(), result2.AssemblyName.Version?.ToString()); + } + else + { + Assert.Equal(result1.AssemblyName, result2.AssemblyName); + } + } + else + { + try + { + TypeName.Parse(testSpan); + throw new Exception("Parsing was supposed to fail!"); + } + catch (ArgumentException) { } + catch (InvalidOperationException) { } + } + } + } +} diff --git a/src/libraries/Fuzzing/nuget.config b/src/libraries/Fuzzing/nuget.config index 9aa79050d31..efa62fa824b 100644 --- a/src/libraries/Fuzzing/nuget.config +++ b/src/libraries/Fuzzing/nuget.config @@ -12,6 +12,7 @@ + diff --git a/src/libraries/Microsoft.Bcl.AsyncInterfaces/Microsoft.Bcl.AsyncInterfaces.sln b/src/libraries/Microsoft.Bcl.AsyncInterfaces/Microsoft.Bcl.AsyncInterfaces.sln index 8fe54df3154..580c63b466b 100644 --- a/src/libraries/Microsoft.Bcl.AsyncInterfaces/Microsoft.Bcl.AsyncInterfaces.sln +++ b/src/libraries/Microsoft.Bcl.AsyncInterfaces/Microsoft.Bcl.AsyncInterfaces.sln @@ -5,7 +5,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Bcl.AsyncInterfac EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Bcl.AsyncInterfaces.Tests", "tests\Microsoft.Bcl.AsyncInterfaces.Tests.csproj", "{51D9518A-464D-4257-9567-3BDCFF24F3EE}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{0AE44453-273B-4F0E-9901-A87891A73C1B}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{E0D86B5A-9442-4E89-9B28-1869E23C824E}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{D0F1936C-CF7C-4448-9F90-B9DEABE89EBB}" EndProject @@ -51,10 +51,10 @@ Global {51D9518A-464D-4257-9567-3BDCFF24F3EE}.Debug|Any CPU.Build.0 = Debug|Any CPU {51D9518A-464D-4257-9567-3BDCFF24F3EE}.Release|Any CPU.ActiveCfg = Release|Any CPU {51D9518A-464D-4257-9567-3BDCFF24F3EE}.Release|Any CPU.Build.0 = Release|Any CPU - {0AE44453-273B-4F0E-9901-A87891A73C1B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {0AE44453-273B-4F0E-9901-A87891A73C1B}.Debug|Any CPU.Build.0 = Debug|Any CPU - {0AE44453-273B-4F0E-9901-A87891A73C1B}.Release|Any CPU.ActiveCfg = Release|Any CPU - {0AE44453-273B-4F0E-9901-A87891A73C1B}.Release|Any CPU.Build.0 = Release|Any CPU + {E0D86B5A-9442-4E89-9B28-1869E23C824E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E0D86B5A-9442-4E89-9B28-1869E23C824E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E0D86B5A-9442-4E89-9B28-1869E23C824E}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E0D86B5A-9442-4E89-9B28-1869E23C824E}.Release|Any CPU.Build.0 = Release|Any CPU {D0F1936C-CF7C-4448-9F90-B9DEABE89EBB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {D0F1936C-CF7C-4448-9F90-B9DEABE89EBB}.Debug|Any CPU.Build.0 = Debug|Any CPU {D0F1936C-CF7C-4448-9F90-B9DEABE89EBB}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -87,7 +87,7 @@ Global {CAEE0409-CCC3-4EA6-AB54-177FD305D42D} = {6614EF7F-23FC-4809-AFF5-1ADBF1B6422C} {51D9518A-464D-4257-9567-3BDCFF24F3EE} = {6614EF7F-23FC-4809-AFF5-1ADBF1B6422C} {4D4BED71-8904-4A74-88CD-63D002CCACD0} = {85204CF5-0C88-4BBB-9E70-D8CCED82ED3D} - {0AE44453-273B-4F0E-9901-A87891A73C1B} = {D6A9108E-553B-445E-A037-FA4F3140A279} + {E0D86B5A-9442-4E89-9B28-1869E23C824E} = {D6A9108E-553B-445E-A037-FA4F3140A279} {D0F1936C-CF7C-4448-9F90-B9DEABE89EBB} = {D6A9108E-553B-445E-A037-FA4F3140A279} {59CE8DDB-AFFD-4C6F-B09F-94DE4DD0AAEA} = {F4939A3B-3316-4166-8AE6-34E1D0863CF5} {0225750F-4DC0-4C71-9B33-314ACA0EF682} = {F4939A3B-3316-4166-8AE6-34E1D0863CF5} diff --git a/src/libraries/Microsoft.Bcl.Cryptography/Microsoft.Bcl.Cryptography.sln b/src/libraries/Microsoft.Bcl.Cryptography/Microsoft.Bcl.Cryptography.sln index 6ff99b02d0a..3f61b2415b8 100644 --- a/src/libraries/Microsoft.Bcl.Cryptography/Microsoft.Bcl.Cryptography.sln +++ b/src/libraries/Microsoft.Bcl.Cryptography/Microsoft.Bcl.Cryptography.sln @@ -13,6 +13,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Formats.Asn1", "..\S EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{F512A7E1-C119-4803-9312-020005D4FF5F}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{94AD69C1-FB03-4496-99D3-038CCE7C9917}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{E9271403-BEF5-46E9-B68B-16EF69AA7149}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{A4C2BDDC-1AFB-45A8-9E9B-4AD7396A4DF2}" @@ -85,6 +87,10 @@ Global {F512A7E1-C119-4803-9312-020005D4FF5F}.Debug|Any CPU.Build.0 = Debug|Any CPU {F512A7E1-C119-4803-9312-020005D4FF5F}.Release|Any CPU.ActiveCfg = Release|Any CPU {F512A7E1-C119-4803-9312-020005D4FF5F}.Release|Any CPU.Build.0 = Release|Any CPU + {94AD69C1-FB03-4496-99D3-038CCE7C9917}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {94AD69C1-FB03-4496-99D3-038CCE7C9917}.Debug|Any CPU.Build.0 = Debug|Any CPU + {94AD69C1-FB03-4496-99D3-038CCE7C9917}.Release|Any CPU.ActiveCfg = Release|Any CPU + {94AD69C1-FB03-4496-99D3-038CCE7C9917}.Release|Any CPU.Build.0 = Release|Any CPU {E9271403-BEF5-46E9-B68B-16EF69AA7149}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {E9271403-BEF5-46E9-B68B-16EF69AA7149}.Debug|Any CPU.Build.0 = Debug|Any CPU {E9271403-BEF5-46E9-B68B-16EF69AA7149}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -145,6 +151,7 @@ Global {A2B1AF52-7F1C-49DA-A5B0-0BCF85031DC0} = {7E9F6DE1-771B-4E25-A603-EC43D0291C8B} {FBFED603-DDBC-4EE3-B252-4C46883D8CC5} = {7E9F6DE1-771B-4E25-A603-EC43D0291C8B} {F512A7E1-C119-4803-9312-020005D4FF5F} = {34897637-11A1-48A4-AF1F-E11463A61D0B} + {94AD69C1-FB03-4496-99D3-038CCE7C9917} = {34897637-11A1-48A4-AF1F-E11463A61D0B} {E9271403-BEF5-46E9-B68B-16EF69AA7149} = {34897637-11A1-48A4-AF1F-E11463A61D0B} {A4C2BDDC-1AFB-45A8-9E9B-4AD7396A4DF2} = {34897637-11A1-48A4-AF1F-E11463A61D0B} {777AF5DE-3EB3-4E62-A0D8-CA10D77B5343} = {568C437D-072B-48BA-BBB4-20F39E2ADA15} diff --git a/src/libraries/Microsoft.Bcl.Cryptography/tests/Microsoft.Bcl.Cryptography.Tests.csproj b/src/libraries/Microsoft.Bcl.Cryptography/tests/Microsoft.Bcl.Cryptography.Tests.csproj index 265d2a512e0..be85e50d295 100644 --- a/src/libraries/Microsoft.Bcl.Cryptography/tests/Microsoft.Bcl.Cryptography.Tests.csproj +++ b/src/libraries/Microsoft.Bcl.Cryptography/tests/Microsoft.Bcl.Cryptography.Tests.csproj @@ -25,13 +25,13 @@ + Link="CommonTest\System\Security\Cryptography\X509Certificates\TestData.cs" /> + Link="CommonTest\System\Security\Cryptography\X509Certificates\X509CertificateLoaderPkcs12CollectionTests.cs" /> + Link="CommonTest\System\Security\Cryptography\X509Certificates\X509CertificateLoaderPkcs12Tests.cs" /> + Link="CommonTest\System\Security\Cryptography\X509Certificates\X509CertificateLoaderTests.cs" /> diff --git a/src/libraries/Microsoft.Bcl.Memory/Microsoft.Bcl.Memory.sln b/src/libraries/Microsoft.Bcl.Memory/Microsoft.Bcl.Memory.sln index d9b6edccf34..b505527da2c 100644 --- a/src/libraries/Microsoft.Bcl.Memory/Microsoft.Bcl.Memory.sln +++ b/src/libraries/Microsoft.Bcl.Memory/Microsoft.Bcl.Memory.sln @@ -5,7 +5,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Bcl.Memory", "src EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Bcl.Memory.Tests", "tests\Microsoft.Bcl.Memory.Tests.csproj", "{6916DB98-2958-498D-83E7-90080BEA9D39}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{C5E6E7BE-85A7-411C-942D-58D1CF536B69}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{2EB5E79B-65A9-45C6-9824-13D93F46F0ED}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{BDF81187-85CE-4BA7-8354-A248CF38F6A3}" EndProject @@ -51,10 +51,10 @@ Global {6916DB98-2958-498D-83E7-90080BEA9D39}.Debug|Any CPU.Build.0 = Debug|Any CPU {6916DB98-2958-498D-83E7-90080BEA9D39}.Release|Any CPU.ActiveCfg = Release|Any CPU {6916DB98-2958-498D-83E7-90080BEA9D39}.Release|Any CPU.Build.0 = Release|Any CPU - {C5E6E7BE-85A7-411C-942D-58D1CF536B69}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {C5E6E7BE-85A7-411C-942D-58D1CF536B69}.Debug|Any CPU.Build.0 = Debug|Any CPU - {C5E6E7BE-85A7-411C-942D-58D1CF536B69}.Release|Any CPU.ActiveCfg = Release|Any CPU - {C5E6E7BE-85A7-411C-942D-58D1CF536B69}.Release|Any CPU.Build.0 = Release|Any CPU + {2EB5E79B-65A9-45C6-9824-13D93F46F0ED}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {2EB5E79B-65A9-45C6-9824-13D93F46F0ED}.Debug|Any CPU.Build.0 = Debug|Any CPU + {2EB5E79B-65A9-45C6-9824-13D93F46F0ED}.Release|Any CPU.ActiveCfg = Release|Any CPU + {2EB5E79B-65A9-45C6-9824-13D93F46F0ED}.Release|Any CPU.Build.0 = Release|Any CPU {BDF81187-85CE-4BA7-8354-A248CF38F6A3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {BDF81187-85CE-4BA7-8354-A248CF38F6A3}.Debug|Any CPU.Build.0 = Debug|Any CPU {BDF81187-85CE-4BA7-8354-A248CF38F6A3}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -87,7 +87,7 @@ Global {DC079FC4-E827-4F1C-9C85-803E2D92B3D4} = {E78D7A3F-384B-4AA3-ABF1-C4464BE9237C} {6916DB98-2958-498D-83E7-90080BEA9D39} = {E78D7A3F-384B-4AA3-ABF1-C4464BE9237C} {D4D9D9AC-E482-457A-8047-5267BDF2C2EE} = {76C22FE9-D65E-40C3-BE2D-98BD628779EC} - {C5E6E7BE-85A7-411C-942D-58D1CF536B69} = {101F8A3D-BAEB-4D16-B83E-1136CDF98795} + {2EB5E79B-65A9-45C6-9824-13D93F46F0ED} = {101F8A3D-BAEB-4D16-B83E-1136CDF98795} {BDF81187-85CE-4BA7-8354-A248CF38F6A3} = {101F8A3D-BAEB-4D16-B83E-1136CDF98795} {F1DE07AA-87C9-478A-9D43-7DF7813D6250} = {F2D0981A-13D5-4858-AE51-23BB61AE0E2B} {BA90C3CA-BEA8-4E9E-9CB2-ADE8EAA1E975} = {F2D0981A-13D5-4858-AE51-23BB61AE0E2B} diff --git a/src/libraries/Microsoft.Bcl.Memory/src/Microsoft.Bcl.Memory.csproj b/src/libraries/Microsoft.Bcl.Memory/src/Microsoft.Bcl.Memory.csproj index bd686ec2da9..32ae6a4e5c6 100644 --- a/src/libraries/Microsoft.Bcl.Memory/src/Microsoft.Bcl.Memory.csproj +++ b/src/libraries/Microsoft.Bcl.Memory/src/Microsoft.Bcl.Memory.csproj @@ -9,17 +9,7 @@ Once this package has shipped a stable version, the following line should be removed in order to re-enable validation. --> true - - Provides Base64Url encoding, decoding and validation APIs support for .NET Framework and .NET Standard. - Provides Index and Range types support for .NET Framework and .NET Standard 2.0. - - Commonly Used Types: - System.Buffers.Text.Base64Url - System.Index - System.Range - - - false + Provides Base64Url, Index and Range types support for .NET Framework and .NET Standard. diff --git a/src/libraries/Microsoft.Bcl.Memory/src/PACKAGE.md b/src/libraries/Microsoft.Bcl.Memory/src/PACKAGE.md new file mode 100644 index 00000000000..eac081364db --- /dev/null +++ b/src/libraries/Microsoft.Bcl.Memory/src/PACKAGE.md @@ -0,0 +1,83 @@ +## About + +Provides `Index` and `Range` types to simplify slicing operations on collections for .NET Framework and .NET Standard 2.0. +Provides `Base64Url` for encoding data in a URL-safe manner on .NET Framework and .NET Standard. + +This library is not necessary nor recommended when targeting versions of .NET that include the relevant support. + +## Key Features + + + +* Enables the use of `Index` and `Range` types on older .NET platforms. +* Provides `Base64Url` encoding, decoding, and validation for URL-safe data processing on older .NET platforms. + +## How to Use + + + +The `Index` and `Range` types simplify working with slices of arrays, strings, or other collections. + +```csharp +string[] words = ["The", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog"]; + +// Use Index to reference the last element +Console.WriteLine(words[^1]); +// Output: "dog" + +// Use Range to reference a slice +string[] phrase = words[1..4]; +Console.WriteLine(string.Join(" ", phrase)); +// Output: "quick brown fox" +``` + +`Base64Url` encoding is a URL-safe version of Base64, commonly used in web applications, such as JWT tokens. + +```csharp +using System.Buffers.Text; +using System.Text; + +// Original data +byte[] data = Encoding.UTF8.GetBytes("Hello World!"); + +Span encoded = new byte[Base64Url.GetEncodedLength(data.Length)]; +Base64Url.EncodeToUtf8(data, encoded, out int _, out int bytesWritten); + +string encodedString = Base64Url.EncodeToString(data); +Console.WriteLine($"Encoded: {encodedString}"); +// Encoded: SGVsbG8gV29ybGQh + +Span decoded = new byte[data.Length]; +Base64Url.DecodeFromUtf8(encoded[..bytesWritten], decoded, out _, out bytesWritten); + +string decodedString = Encoding.UTF8.GetString(decoded[..bytesWritten]); +Console.WriteLine($"Decoded: {decodedString}"); +// Decoded: Hello World! +``` + +## Main Types + + + +The main types provided by this library are: + +* `System.Index` +* `System.Range` +* `System.Buffers.Text.Base64Url` + +## Additional Documentation + + + +API documentation + +* [System.Index](https://learn.microsoft.com/dotnet/api/system.index) +* [System.Range](https://learn.microsoft.com/dotnet/api/system.range) +* [System.Buffers.Text.Base64Url](https://learn.microsoft.com/dotnet/api/system.buffers.text.base64url) + +## Feedback & Contributing + + + +Microsoft.Bcl.Memory is released as open source under the [MIT license](https://licenses.nuget.org/MIT). +Bug reports and contributions are welcome at [the GitHub repository](https://github.com/dotnet/runtime). diff --git a/src/libraries/Microsoft.Bcl.Numerics/Microsoft.Bcl.Numerics.sln b/src/libraries/Microsoft.Bcl.Numerics/Microsoft.Bcl.Numerics.sln index 4680502ea0e..eac600f64d3 100644 --- a/src/libraries/Microsoft.Bcl.Numerics/Microsoft.Bcl.Numerics.sln +++ b/src/libraries/Microsoft.Bcl.Numerics/Microsoft.Bcl.Numerics.sln @@ -5,7 +5,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Bcl.Numerics", "s EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Bcl.Numerics.Tests", "tests\Microsoft.Bcl.Numerics.Tests.csproj", "{51D9518A-464D-4257-9567-3BDCFF24F3EE}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{0AE44453-273B-4F0E-9901-A87891A73C1B}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{D81DAC34-FFE5-494C-9E80-A7696331FC6C}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{D0F1936C-CF7C-4448-9F90-B9DEABE89EBB}" EndProject @@ -51,10 +51,10 @@ Global {51D9518A-464D-4257-9567-3BDCFF24F3EE}.Debug|Any CPU.Build.0 = Debug|Any CPU {51D9518A-464D-4257-9567-3BDCFF24F3EE}.Release|Any CPU.ActiveCfg = Release|Any CPU {51D9518A-464D-4257-9567-3BDCFF24F3EE}.Release|Any CPU.Build.0 = Release|Any CPU - {0AE44453-273B-4F0E-9901-A87891A73C1B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {0AE44453-273B-4F0E-9901-A87891A73C1B}.Debug|Any CPU.Build.0 = Debug|Any CPU - {0AE44453-273B-4F0E-9901-A87891A73C1B}.Release|Any CPU.ActiveCfg = Release|Any CPU - {0AE44453-273B-4F0E-9901-A87891A73C1B}.Release|Any CPU.Build.0 = Release|Any CPU + {D81DAC34-FFE5-494C-9E80-A7696331FC6C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D81DAC34-FFE5-494C-9E80-A7696331FC6C}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D81DAC34-FFE5-494C-9E80-A7696331FC6C}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D81DAC34-FFE5-494C-9E80-A7696331FC6C}.Release|Any CPU.Build.0 = Release|Any CPU {D0F1936C-CF7C-4448-9F90-B9DEABE89EBB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {D0F1936C-CF7C-4448-9F90-B9DEABE89EBB}.Debug|Any CPU.Build.0 = Debug|Any CPU {D0F1936C-CF7C-4448-9F90-B9DEABE89EBB}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -87,7 +87,7 @@ Global {CAEE0409-CCC3-4EA6-AB54-177FD305D42D} = {6614EF7F-23FC-4809-AFF5-1ADBF1B6422C} {51D9518A-464D-4257-9567-3BDCFF24F3EE} = {6614EF7F-23FC-4809-AFF5-1ADBF1B6422C} {4D4BED71-8904-4A74-88CD-63D002CCACD0} = {85204CF5-0C88-4BBB-9E70-D8CCED82ED3D} - {0AE44453-273B-4F0E-9901-A87891A73C1B} = {D6A9108E-553B-445E-A037-FA4F3140A279} + {D81DAC34-FFE5-494C-9E80-A7696331FC6C} = {D6A9108E-553B-445E-A037-FA4F3140A279} {D0F1936C-CF7C-4448-9F90-B9DEABE89EBB} = {D6A9108E-553B-445E-A037-FA4F3140A279} {21224EF3-8706-4C95-8009-ADCA451B1513} = {0B6D6DEB-1D82-4C19-98F5-7CCDB5AEBACA} {5455F8B5-6A95-42AE-9D6E-AA13D0324D9A} = {0B6D6DEB-1D82-4C19-98F5-7CCDB5AEBACA} diff --git a/src/libraries/Microsoft.Bcl.Numerics/src/System/MathF.cs b/src/libraries/Microsoft.Bcl.Numerics/src/System/MathF.cs index 505bc666889..56890feed6c 100644 --- a/src/libraries/Microsoft.Bcl.Numerics/src/System/MathF.cs +++ b/src/libraries/Microsoft.Bcl.Numerics/src/System/MathF.cs @@ -55,28 +55,28 @@ private static unsafe bool IsNegative(float f) /// Returns the absolute value of a single-precision floating-point number. /// /// The number to take the absolute value of. - /// The absolute value of + /// The absolute value of . public static float Abs(float x) => Math.Abs(x); /// /// Returns the angle whose cosine is the specified number. /// /// The number to take the acos of. - /// The acos of + /// The acos of . public static float Acos(float x) => (float)Math.Acos(x); /// /// Returns the angle whose sine is the specified number. /// /// The number to take the asin of. - /// The asin of + /// The asin of . public static float Asin(float x) => (float)Math.Asin(x); /// /// Returns the angle whose tangent is the specified number. /// /// The number to take the atan of. - /// The atan of + /// The atan of . public static float Atan(float x) => (float)Math.Atan(x); /// @@ -84,42 +84,42 @@ private static unsafe bool IsNegative(float f) /// /// The first number. /// The second number. - /// The angle whose tangent is the quotient of and + /// The angle whose tangent is the quotient of and . public static float Atan2(float y, float x) => (float)Math.Atan2(y, x); /// /// Returns the smallest integral value that is greater than or equal to the specified single-precision floating-point number. /// /// The number to take the ceiling of. - /// The ceiling of + /// The ceiling of . public static float Ceiling(float x) => (float)Math.Ceiling(x); /// /// Returns the cosine of the specified angle. /// /// The angle to take the cosine of. - /// The cosine of + /// The cosine of . public static float Cos(float x) => (float)Math.Cos(x); /// /// Returns the hyperbolic cosine of the specified angle. /// /// The angle to take the hyperbolic cosine of. - /// The hyperbolic cosine of + /// The hyperbolic cosine of . public static float Cosh(float x) => (float)Math.Cosh(x); /// /// Returns e raised to the specified power. /// /// The number to raise e to. - /// e raised to the power of + /// e raised to the power of . public static float Exp(float x) => (float)Math.Exp(x); /// /// Returns the largest integral value less than or equal to the specified single-precision floating-point number. /// /// The number to take the floor of. - /// The floor of + /// The floor of . public static float Floor(float x) => (float)Math.Floor(x); /// @@ -127,7 +127,7 @@ private static unsafe bool IsNegative(float f) /// /// The numerator /// The denominator - /// The result of dividing by + /// The result of dividing by . public static float IEEERemainder(float x, float y) { if (float.IsNaN(x)) @@ -183,7 +183,7 @@ public static float IEEERemainder(float x, float y) /// Returns the natural (base e) logarithm of a specified number. /// /// The number to take the natural log of. - /// The natural log of + /// The natural log of . public static float Log(float x) => (float)Math.Log(x); /// @@ -191,7 +191,7 @@ public static float IEEERemainder(float x, float y) /// /// The number to take the log of. /// The base of the log - /// The log of with base + /// The log of with base . public static float Log(float x, float y) { if (float.IsNaN(x)) @@ -221,7 +221,7 @@ public static float Log(float x, float y) /// Returns the base 10 logarithm of a specified number. /// /// The number to take the base 10 log of. - /// The base 10 log of + /// The base 10 log of . public static float Log10(float x) => (float)Math.Log10(x); /// @@ -229,7 +229,7 @@ public static float Log(float x, float y) /// /// The first number to compare. /// The second number to compare. - /// The larger of and + /// The larger of and . public static float Max(float x, float y) => Math.Max(x, y); /// @@ -237,7 +237,7 @@ public static float Log(float x, float y) /// /// The first number to compare. /// The second number to compare. - /// The smaller of and + /// The smaller of and . public static float Min(float x, float y) => Math.Min(x, y); /// @@ -245,14 +245,14 @@ public static float Log(float x, float y) /// /// The base number. /// The specified power. - /// raised to the power of + /// raised to the power of . public static float Pow(float x, float y) => (float)Math.Pow(x, y); /// /// Rounds a single-precision floating-point value to the nearest integral value, and rounds midpoint values to the nearest even number. /// /// The number to round. - /// The rounded representation of + /// The rounded representation of . public static float Round(float x) => (float)Math.Round(x); /// @@ -284,49 +284,49 @@ public static float Log(float x, float y) /// Returns an integer that indicates the sign of a single-precision floating-point number. /// /// The number check the sign of. - /// The sign of + /// The sign of . public static int Sign(float x) => Math.Sign(x); /// /// Returns the sine of the specified angle. /// /// The angle to take the sine of. - /// The sine of + /// The sine of . public static float Sin(float x) => (float)Math.Sin(x); /// /// Returns the hyperbolic sine of the specified angle. /// /// The angle to take the hyperbolic sine of. - /// The hyperbolic sine of + /// The hyperbolic sine of . public static float Sinh(float x) => (float)Math.Sinh(x); /// /// Returns the square root of a specified number. /// /// The number to take the square root of. - /// The square root of + /// The square root of . public static float Sqrt(float x) => (float)Math.Sqrt(x); /// /// Returns the tangent of the specified angle. /// /// The angle to take the tangent of. - /// The tangent of + /// The tangent of . public static float Tan(float x) => (float)Math.Tan(x); /// /// Returns the hyperbolic tangent of the specified angle. /// /// The angle to take the hyperbolic tangent of. - /// The hyperbolic tangent of + /// The hyperbolic tangent of . public static float Tanh(float x) => (float)Math.Tanh(x); /// /// Calculates the integral part of a specified single-precision floating-point number. /// /// The number to truncate. - /// The truncated representation of + /// The truncated representation of . public static float Truncate(float x) => (float)Math.Truncate(x); } } diff --git a/src/libraries/Microsoft.Bcl.TimeProvider/Microsoft.Bcl.TimeProvider.sln b/src/libraries/Microsoft.Bcl.TimeProvider/Microsoft.Bcl.TimeProvider.sln index 63d59f21f6f..16faf71927c 100644 --- a/src/libraries/Microsoft.Bcl.TimeProvider/Microsoft.Bcl.TimeProvider.sln +++ b/src/libraries/Microsoft.Bcl.TimeProvider/Microsoft.Bcl.TimeProvider.sln @@ -7,7 +7,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Bcl.TimeProvider" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Bcl.TimeProvider.Tests", "tests\Microsoft.Bcl.TimeProvider.Tests.csproj", "{8DBA87BA-C9C5-48AF-9D34-4B9877B28F9E}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{4FB1DB0F-1371-4635-8160-6AB3B3D3BB04}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{B1A650D0-0A3F-41FD-8DA6-08AE2FF667B8}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{6D351E62-CB41-4E2A-B7E7-55FAC33C6B16}" EndProject @@ -57,10 +57,10 @@ Global {8DBA87BA-C9C5-48AF-9D34-4B9877B28F9E}.Debug|Any CPU.Build.0 = Debug|Any CPU {8DBA87BA-C9C5-48AF-9D34-4B9877B28F9E}.Release|Any CPU.ActiveCfg = Release|Any CPU {8DBA87BA-C9C5-48AF-9D34-4B9877B28F9E}.Release|Any CPU.Build.0 = Release|Any CPU - {4FB1DB0F-1371-4635-8160-6AB3B3D3BB04}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {4FB1DB0F-1371-4635-8160-6AB3B3D3BB04}.Debug|Any CPU.Build.0 = Debug|Any CPU - {4FB1DB0F-1371-4635-8160-6AB3B3D3BB04}.Release|Any CPU.ActiveCfg = Release|Any CPU - {4FB1DB0F-1371-4635-8160-6AB3B3D3BB04}.Release|Any CPU.Build.0 = Release|Any CPU + {B1A650D0-0A3F-41FD-8DA6-08AE2FF667B8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {B1A650D0-0A3F-41FD-8DA6-08AE2FF667B8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {B1A650D0-0A3F-41FD-8DA6-08AE2FF667B8}.Release|Any CPU.ActiveCfg = Release|Any CPU + {B1A650D0-0A3F-41FD-8DA6-08AE2FF667B8}.Release|Any CPU.Build.0 = Release|Any CPU {6D351E62-CB41-4E2A-B7E7-55FAC33C6B16}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {6D351E62-CB41-4E2A-B7E7-55FAC33C6B16}.Debug|Any CPU.Build.0 = Debug|Any CPU {6D351E62-CB41-4E2A-B7E7-55FAC33C6B16}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -94,7 +94,7 @@ Global {8DBA87BA-C9C5-48AF-9D34-4B9877B28F9E} = {B7AA510C-BBAF-4D08-A81C-56A134460112} {C3AF8C81-DFF3-474F-8CDD-3E30319AEBB4} = {C2DE61FC-AB38-4E50-8892-1363AFFCEC63} {6BF3C14F-036A-4A04-90EC-82ADC2900805} = {C2DE61FC-AB38-4E50-8892-1363AFFCEC63} - {4FB1DB0F-1371-4635-8160-6AB3B3D3BB04} = {2DA8DE52-952C-4E9B-8C4D-5FF6AC27CA62} + {B1A650D0-0A3F-41FD-8DA6-08AE2FF667B8} = {2DA8DE52-952C-4E9B-8C4D-5FF6AC27CA62} {6D351E62-CB41-4E2A-B7E7-55FAC33C6B16} = {2DA8DE52-952C-4E9B-8C4D-5FF6AC27CA62} {E993DE92-F571-45CF-A879-87ADA3CCEF7E} = {F0432FE3-6BCD-4B1C-BF81-2CDEDA0B8F50} {5E7E6A50-109D-45DA-A70C-B00AB5BCF964} = {F0432FE3-6BCD-4B1C-BF81-2CDEDA0B8F50} diff --git a/src/libraries/Microsoft.Bcl.TimeProvider/src/System/Threading/Tasks/TimeProviderTaskExtensions.cs b/src/libraries/Microsoft.Bcl.TimeProvider/src/System/Threading/Tasks/TimeProviderTaskExtensions.cs index 2153d859c00..a2398b9d6cd 100644 --- a/src/libraries/Microsoft.Bcl.TimeProvider/src/System/Threading/Tasks/TimeProviderTaskExtensions.cs +++ b/src/libraries/Microsoft.Bcl.TimeProvider/src/System/Threading/Tasks/TimeProviderTaskExtensions.cs @@ -4,11 +4,11 @@ namespace System.Threading.Tasks { /// - /// Provide extensions methods for operations with . + /// Provides extensions methods for operations with . /// /// /// The Microsoft.Bcl.TimeProvider library interfaces are intended solely for use in building against pre-.NET 8 surface area. - /// If your code is being built against .NET 8 or higher, then this library should not be utilized. + /// If your code is being built against .NET 8 or higher, then you shouldn't use this library. /// public static class TimeProviderTaskExtensions { @@ -66,14 +66,14 @@ public static Task Delay(this TimeProvider timeProvider, TimeSpan delay, Cancell throw new ArgumentOutOfRangeException(nameof(delay)); } - if (delay == TimeSpan.Zero) + if (cancellationToken.IsCancellationRequested) { - return Task.CompletedTask; + return Task.FromCanceled(cancellationToken); } - if (cancellationToken.IsCancellationRequested) + if (delay == TimeSpan.Zero) { - return Task.FromCanceled(cancellationToken); + return Task.CompletedTask; } DelayState state = new(cancellationToken); @@ -128,8 +128,7 @@ public static Task Delay(this TimeProvider timeProvider, TimeSpan delay, Cancell /// The with which to interpret . /// The to monitor for a cancellation request. /// The representing the asynchronous wait. It may or may not be the same instance as the current instance. - /// The argument is null. - /// The argument is null. + /// or is . /// represents a negative time interval other than . public static Task WaitAsync(this Task task, TimeSpan timeout, TimeProvider timeProvider, CancellationToken cancellationToken = default) { @@ -161,14 +160,14 @@ public static Task WaitAsync(this Task task, TimeSpan timeout, TimeProvider time return task; } - if (timeout == TimeSpan.Zero) + if (cancellationToken.IsCancellationRequested) { - return Task.FromException(new TimeoutException()); + return Task.FromCanceled(cancellationToken); } - if (cancellationToken.IsCancellationRequested) + if (timeout == TimeSpan.Zero) { - return Task.FromCanceled(cancellationToken); + return Task.FromException(new TimeoutException()); } WaitAsyncState state = new(cancellationToken); @@ -224,9 +223,8 @@ public static Task WaitAsync(this Task task, TimeSpan timeout, TimeProvider time /// The timeout after which the should be faulted with a if it hasn't otherwise completed. /// The with which to interpret . /// The to monitor for a cancellation request. - /// The representing the asynchronous wait. It may or may not be the same instance as the current instance. - /// The argument is null. - /// The argument is null. + /// The representing the asynchronous wait. It may or may not be the same instance as the current instance. + /// or is . /// represents a negative time interval other than . #if NET8_0_OR_GREATER public static Task WaitAsync(this Task task, TimeSpan timeout, TimeProvider timeProvider, CancellationToken cancellationToken = default) @@ -242,7 +240,7 @@ public static async Task WaitAsync(this Task task, Ti /// Initializes a new instance of the class that will be canceled after the specified . /// The with which to interpret the . /// The time interval to wait before canceling this . - /// The is negative and not equal to or greater than maximum allowed timer duration. + /// is negative and not equal to or greater than maximum allowed timer duration. /// that will be canceled after the specified . /// /// diff --git a/src/libraries/Microsoft.CSharp/Microsoft.CSharp.sln b/src/libraries/Microsoft.CSharp/Microsoft.CSharp.sln index e88fae60820..e4b552c8deb 100644 --- a/src/libraries/Microsoft.CSharp/Microsoft.CSharp.sln +++ b/src/libraries/Microsoft.CSharp/Microsoft.CSharp.sln @@ -15,6 +15,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ObjectModel", "..\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{BB30502C-6FBE-467E-AE6B-380EC60BD666}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{A4FBFB01-5DDE-40EB-B01F-2C6DB351ABED}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{B78B9BD0-6D82-400A-A373-C42051D9C3D8}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{7223E4B2-40ED-48FB-9BFA-07002AD674DB}" @@ -85,6 +87,10 @@ Global {BB30502C-6FBE-467E-AE6B-380EC60BD666}.Debug|Any CPU.Build.0 = Debug|Any CPU {BB30502C-6FBE-467E-AE6B-380EC60BD666}.Release|Any CPU.ActiveCfg = Release|Any CPU {BB30502C-6FBE-467E-AE6B-380EC60BD666}.Release|Any CPU.Build.0 = Release|Any CPU + {A4FBFB01-5DDE-40EB-B01F-2C6DB351ABED}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A4FBFB01-5DDE-40EB-B01F-2C6DB351ABED}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A4FBFB01-5DDE-40EB-B01F-2C6DB351ABED}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A4FBFB01-5DDE-40EB-B01F-2C6DB351ABED}.Release|Any CPU.Build.0 = Release|Any CPU {B78B9BD0-6D82-400A-A373-C42051D9C3D8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {B78B9BD0-6D82-400A-A373-C42051D9C3D8}.Debug|Any CPU.Build.0 = Debug|Any CPU {B78B9BD0-6D82-400A-A373-C42051D9C3D8}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -131,6 +137,7 @@ Global {C89FC14C-795C-469E-A053-A2844C0B7AA8} = {8C230199-AEBC-4299-A612-5025FC987A41} {78073F44-8382-473D-8B24-90D54B57129E} = {ABC2DBF6-FE78-44B1-86B8-D759660B5462} {BB30502C-6FBE-467E-AE6B-380EC60BD666} = {D293C8E5-5C86-4096-9F9D-0129396A1AD7} + {A4FBFB01-5DDE-40EB-B01F-2C6DB351ABED} = {D293C8E5-5C86-4096-9F9D-0129396A1AD7} {B78B9BD0-6D82-400A-A373-C42051D9C3D8} = {D293C8E5-5C86-4096-9F9D-0129396A1AD7} {7223E4B2-40ED-48FB-9BFA-07002AD674DB} = {D293C8E5-5C86-4096-9F9D-0129396A1AD7} {780BF284-2765-4B96-A817-CE9AEB1BC979} = {B8ED6D66-6E4D-4715-B862-DAC366129D3A} diff --git a/src/libraries/Microsoft.Extensions.Caching.Abstractions/Microsoft.Extensions.Caching.Abstractions.sln b/src/libraries/Microsoft.Extensions.Caching.Abstractions/Microsoft.Extensions.Caching.Abstractions.sln index adf3c27de3b..788f95bf78b 100644 --- a/src/libraries/Microsoft.Extensions.Caching.Abstractions/Microsoft.Extensions.Caching.Abstractions.sln +++ b/src/libraries/Microsoft.Extensions.Caching.Abstractions/Microsoft.Extensions.Caching.Abstractions.sln @@ -7,7 +7,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Primit EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Primitives", "..\Microsoft.Extensions.Primitives\src\Microsoft.Extensions.Primitives.csproj", "{9556B0C4-098C-45E3-A7EB-1A219B7F941C}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{E1D67575-BF5F-43EB-A81E-6043A427FBEF}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{A9F88088-141C-4C2A-BD08-ACCB24813A0E}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{22B98A76-A2BE-47ED-82F2-9BD0EF50B22D}" EndProject @@ -57,10 +57,10 @@ Global {9556B0C4-098C-45E3-A7EB-1A219B7F941C}.Debug|Any CPU.Build.0 = Debug|Any CPU {9556B0C4-098C-45E3-A7EB-1A219B7F941C}.Release|Any CPU.ActiveCfg = Release|Any CPU {9556B0C4-098C-45E3-A7EB-1A219B7F941C}.Release|Any CPU.Build.0 = Release|Any CPU - {E1D67575-BF5F-43EB-A81E-6043A427FBEF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {E1D67575-BF5F-43EB-A81E-6043A427FBEF}.Debug|Any CPU.Build.0 = Debug|Any CPU - {E1D67575-BF5F-43EB-A81E-6043A427FBEF}.Release|Any CPU.ActiveCfg = Release|Any CPU - {E1D67575-BF5F-43EB-A81E-6043A427FBEF}.Release|Any CPU.Build.0 = Release|Any CPU + {A9F88088-141C-4C2A-BD08-ACCB24813A0E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A9F88088-141C-4C2A-BD08-ACCB24813A0E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A9F88088-141C-4C2A-BD08-ACCB24813A0E}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A9F88088-141C-4C2A-BD08-ACCB24813A0E}.Release|Any CPU.Build.0 = Release|Any CPU {22B98A76-A2BE-47ED-82F2-9BD0EF50B22D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {22B98A76-A2BE-47ED-82F2-9BD0EF50B22D}.Debug|Any CPU.Build.0 = Debug|Any CPU {22B98A76-A2BE-47ED-82F2-9BD0EF50B22D}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -94,7 +94,7 @@ Global {3CE7A561-5A2F-4AF3-8CC2-8148BC5CCE90} = {4B23C940-1856-48C0-94F2-66D4ADC41EA4} {5904EB23-3221-4992-A1F9-70F8B5478DF2} = {F5D1F8C5-8A12-4EE8-9ABA-D393EBBCB1AA} {9556B0C4-098C-45E3-A7EB-1A219B7F941C} = {F5D1F8C5-8A12-4EE8-9ABA-D393EBBCB1AA} - {E1D67575-BF5F-43EB-A81E-6043A427FBEF} = {CF895AB4-6805-4E7D-B8B3-7D363C7D6027} + {A9F88088-141C-4C2A-BD08-ACCB24813A0E} = {CF895AB4-6805-4E7D-B8B3-7D363C7D6027} {22B98A76-A2BE-47ED-82F2-9BD0EF50B22D} = {CF895AB4-6805-4E7D-B8B3-7D363C7D6027} {62920990-3992-4020-BE2A-82061DD47813} = {CE894530-F3D6-4868-B0B1-5FF935ACE502} {4094B781-6FCF-4ED4-ABD5-D273FCB81909} = {CE894530-F3D6-4868-B0B1-5FF935ACE502} diff --git a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/CacheEntryExtensions.cs b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/CacheEntryExtensions.cs index f991a4adebd..93b88c4c90c 100644 --- a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/CacheEntryExtensions.cs +++ b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/CacheEntryExtensions.cs @@ -8,7 +8,7 @@ namespace Microsoft.Extensions.Caching.Memory { /// - /// Provide extensions methods for operations. + /// Provides extensions methods for operations. /// public static class CacheEntryExtensions { @@ -27,7 +27,7 @@ public static ICacheEntry SetPriority( } /// - /// Expire the cache entry if the given expires. + /// Expires the cache entry if the given expires. /// /// The . /// The that causes the cache entry to expire. @@ -71,8 +71,8 @@ public static ICacheEntry SetAbsoluteExpiration( } /// - /// Sets how long the cache entry can be inactive (e.g. not accessed) before it will be removed. - /// This will not extend the entry lifetime beyond the absolute expiration (if set). + /// Sets how long the cache entry can be inactive (for example, not accessed) before it will be removed. + /// This method does not extend the entry lifetime beyond the absolute expiration (if set). /// /// The . /// A representing a sliding expiration. @@ -86,7 +86,7 @@ public static ICacheEntry SetSlidingExpiration( } /// - /// The given callback will be fired after the cache entry is evicted from the cache. + /// Fires the given callback after the cache entry is evicted from the cache. /// /// The . /// The callback to run after the entry is evicted. @@ -101,7 +101,7 @@ public static ICacheEntry RegisterPostEvictionCallback( } /// - /// The given callback will be fired after the cache entry is evicted from the cache. + /// Fires the given callback after the cache entry is evicted from the cache. /// /// The . /// The callback to run after the entry is evicted. diff --git a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/DistributedCacheEntryExtensions.cs b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/DistributedCacheEntryExtensions.cs index f5a048ee3a7..fa74dd0cec9 100644 --- a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/DistributedCacheEntryExtensions.cs +++ b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/DistributedCacheEntryExtensions.cs @@ -6,7 +6,7 @@ namespace Microsoft.Extensions.Caching.Distributed { /// - /// Extension methods for operations. + /// Provides extension methods for operations. /// public static class DistributedCacheEntryExtensions { @@ -37,7 +37,7 @@ public static DistributedCacheEntryOptions SetAbsoluteExpiration( } /// - /// Sets how long the cache entry can be inactive (e.g. not accessed) before it will be removed. + /// Sets how long the cache entry can be inactive (for example, not accessed) before it will be removed. /// This will not extend the entry lifetime beyond the absolute expiration (if set). /// /// The options to be operated on. diff --git a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/DistributedCacheEntryOptions.cs b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/DistributedCacheEntryOptions.cs index a1b5b9ae39a..10370e92acb 100644 --- a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/DistributedCacheEntryOptions.cs +++ b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/DistributedCacheEntryOptions.cs @@ -53,7 +53,7 @@ public TimeSpan? AbsoluteExpirationRelativeToNow } /// - /// Gets or sets how long a cache entry can be inactive (e.g. not accessed) before it will be removed. + /// Gets or sets how long a cache entry can be inactive (for example, not accessed) before it will be removed. /// This will not extend the entry lifetime beyond the absolute expiration (if set). /// public TimeSpan? SlidingExpiration diff --git a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/DistributedCacheExtensions.cs b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/DistributedCacheExtensions.cs index 4b9f396ff0b..c6f8d23fc40 100644 --- a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/DistributedCacheExtensions.cs +++ b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/DistributedCacheExtensions.cs @@ -19,7 +19,7 @@ public static class DistributedCacheExtensions /// The cache in which to store the data. /// The key to store the data in. /// The data to store in the cache. - /// Thrown when or is null. + /// or is null. public static void Set(this IDistributedCache cache, string key, byte[] value) { ThrowHelper.ThrowIfNull(key); @@ -36,7 +36,7 @@ public static void Set(this IDistributedCache cache, string key, byte[] value) /// The data to store in the cache. /// Optional. A to cancel the operation. /// A task that represents the asynchronous set operation. - /// Thrown when or is null. + /// or is null. public static Task SetAsync(this IDistributedCache cache, string key, byte[] value, CancellationToken token = default(CancellationToken)) { ThrowHelper.ThrowIfNull(key); @@ -51,7 +51,7 @@ public static void Set(this IDistributedCache cache, string key, byte[] value) /// The cache in which to store the data. /// The key to store the data in. /// The data to store in the cache. - /// Thrown when or is null. + /// or is null. public static void SetString(this IDistributedCache cache, string key, string value) { cache.SetString(key, value, new DistributedCacheEntryOptions()); @@ -64,7 +64,7 @@ public static void SetString(this IDistributedCache cache, string key, string va /// The key to store the data in. /// The data to store in the cache. /// The cache options for the entry. - /// Thrown when or is null. + /// or is null. public static void SetString(this IDistributedCache cache, string key, string value, DistributedCacheEntryOptions options) { ThrowHelper.ThrowIfNull(key); @@ -81,7 +81,7 @@ public static void SetString(this IDistributedCache cache, string key, string va /// The data to store in the cache. /// Optional. A to cancel the operation. /// A task that represents the asynchronous set operation. - /// Thrown when or is null. + /// or is null. public static Task SetStringAsync(this IDistributedCache cache, string key, string value, CancellationToken token = default(CancellationToken)) { return cache.SetStringAsync(key, value, new DistributedCacheEntryOptions(), token); @@ -96,7 +96,7 @@ public static void SetString(this IDistributedCache cache, string key, string va /// The cache options for the entry. /// Optional. A to cancel the operation. /// A task that represents the asynchronous set operation. - /// Thrown when or is null. + /// or is null. public static Task SetStringAsync(this IDistributedCache cache, string key, string value, DistributedCacheEntryOptions options, CancellationToken token = default(CancellationToken)) { ThrowHelper.ThrowIfNull(key); diff --git a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/EvictionReason.cs b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/EvictionReason.cs index cda96835792..280882d5294 100644 --- a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/EvictionReason.cs +++ b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/EvictionReason.cs @@ -4,7 +4,7 @@ namespace Microsoft.Extensions.Caching.Memory { /// - /// Specify the reasons why an entry was evicted from the cache. + /// Specifies the reasons why an entry was evicted from the cache. /// public enum EvictionReason { diff --git a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/Hybrid/HybridCache.cs b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/Hybrid/HybridCache.cs index 479d0bbe697..d1867d1090c 100644 --- a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/Hybrid/HybridCache.cs +++ b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/Hybrid/HybridCache.cs @@ -22,7 +22,7 @@ public abstract class HybridCache /// The type of additional state required by . /// The type of the data being considered. /// The key of the entry to look for or create. - /// Provides the underlying data service is the data is not available in the cache. + /// Provides the underlying data service if the data is not available in the cache. /// The state required for . /// Additional options for this cache entry. /// The tags to associate with this cache item. @@ -36,7 +36,7 @@ public abstract ValueTask GetOrCreateAsync(string key, TState stat /// /// The type of the data being considered. /// The key of the entry to look for or create. - /// Provides the underlying data service is the data is not available in the cache. + /// Provides the underlying data service if the data is not available in the cache. /// Additional options for this cache entry. /// The tags to associate with this cache item. /// The used to propagate notifications that the operation should be canceled. diff --git a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/Hybrid/HybridCacheEntryOptions.cs b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/Hybrid/HybridCacheEntryOptions.cs index 8bc7343a52c..f9708fdd6bd 100644 --- a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/Hybrid/HybridCacheEntryOptions.cs +++ b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/Hybrid/HybridCacheEntryOptions.cs @@ -7,10 +7,10 @@ namespace Microsoft.Extensions.Caching.Hybrid; /// -/// Additional options (expiration, etc.) that apply to a operation. When options +/// Specifies additional options (for example, expiration) that apply to a operation. When options /// can be specified at multiple levels (for example, globally and per-call), the values are composed; the /// most granular non-null value is used, with null values being inherited. If no value is specified at -/// any level, the implementation may choose a reasonable default. +/// any level, the implementation can choose a reasonable default. /// public sealed class HybridCacheEntryOptions { diff --git a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/Hybrid/IHybridCacheSerializer.cs b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/Hybrid/IHybridCacheSerializer.cs index 5863a0721df..1f7197a4e52 100644 --- a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/Hybrid/IHybridCacheSerializer.cs +++ b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/Hybrid/IHybridCacheSerializer.cs @@ -6,18 +6,18 @@ namespace Microsoft.Extensions.Caching.Hybrid; /// -/// Per-type serialization/deserialization support for . +/// Provides per-type serialization and deserialization support for . /// /// The type being serialized/deserialized. public interface IHybridCacheSerializer { /// - /// Deserialize a value from the provided . + /// Deserializes a value from the provided . /// T Deserialize(ReadOnlySequence source); /// - /// Serialize to the provided . + /// Serializes to the provided . /// void Serialize(T value, IBufferWriter target); } diff --git a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/Hybrid/IHybridCacheSerializerFactory.cs b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/Hybrid/IHybridCacheSerializerFactory.cs index d500ddfb2ba..a301b1fbbe2 100644 --- a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/Hybrid/IHybridCacheSerializerFactory.cs +++ b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/Hybrid/IHybridCacheSerializerFactory.cs @@ -11,9 +11,9 @@ namespace Microsoft.Extensions.Caching.Hybrid; public interface IHybridCacheSerializerFactory { /// - /// Request a serializer for the provided type, if possible. + /// Requests a serializer for the provided type, if possible. /// - /// The type being serialized/deserialized. + /// The type being serialized or deserialized. /// The serializer. /// true if the factory supports this type, false otherwise. bool TryCreateSerializer([NotNullWhen(true)] out IHybridCacheSerializer? serializer); diff --git a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/IBufferDistributedCache.cs b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/IBufferDistributedCache.cs index 994d52766a9..ee3bd079ef2 100644 --- a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/IBufferDistributedCache.cs +++ b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/IBufferDistributedCache.cs @@ -13,22 +13,22 @@ public interface IBufferDistributedCache : IDistributedCache { /// - /// Attempt to retrieve an existing cache item. + /// Attempts to retrieve an existing cache item. /// /// The unique key for the cache item. /// The target to write the cache contents on success. /// true if the cache item is found, false otherwise. - /// This is functionally similar to , but avoids the array allocation. + /// This method is functionally similar to , but avoids the array allocation. bool TryGet(string key, IBufferWriter destination); /// - /// Asynchronously attempt to retrieve an existing cache entry. + /// Asynchronously attempts to retrieve an existing cache entry. /// /// The unique key for the cache entry. /// The target to write the cache contents on success. /// The used to propagate notifications that the operation should be canceled. /// true if the cache entry is found, false otherwise. - /// This is functionally similar to , but avoids the array allocation. + /// This method is functionally similar to , but avoids the array allocation. ValueTask TryGetAsync(string key, IBufferWriter destination, CancellationToken token = default); /// @@ -37,7 +37,7 @@ public interface IBufferDistributedCache : IDistributedCache /// The key of the entry to create. /// The value for this cache entry. /// The cache options for the entry. - /// This is functionally similar to , but avoids the array allocation. + /// This method is functionally similar to , but avoids the array allocation. void Set(string key, ReadOnlySequence value, DistributedCacheEntryOptions options); /// @@ -47,6 +47,6 @@ public interface IBufferDistributedCache : IDistributedCache /// The value for this cache entry. /// The cache options for the value. /// The used to propagate notifications that the operation should be canceled. - /// This is functionally similar to , but avoids the array allocation. + /// This method is functionally similar to , but avoids the array allocation. ValueTask SetAsync(string key, ReadOnlySequence value, DistributedCacheEntryOptions options, CancellationToken token = default); } diff --git a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/MemoryCacheEntryExtensions.cs b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/MemoryCacheEntryExtensions.cs index 9a2a87918d4..201993aeeb7 100644 --- a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/MemoryCacheEntryExtensions.cs +++ b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/MemoryCacheEntryExtensions.cs @@ -45,7 +45,7 @@ public static MemoryCacheEntryOptions SetSize( } /// - /// Expire the cache entry if the given expires. + /// Expires the cache entry if the given expires. /// /// The . /// The that causes the cache entry to expire. @@ -104,7 +104,7 @@ public static MemoryCacheEntryOptions SetSlidingExpiration( } /// - /// The given callback will be fired after the cache entry is evicted from the cache. + /// Fires the given callback after the cache entry is evicted from the cache. /// /// The . /// The callback to register for calling after an entry is evicted. @@ -119,7 +119,7 @@ public static MemoryCacheEntryOptions RegisterPostEvictionCallback( } /// - /// The given callback will be fired after the cache entry is evicted from the cache. + /// Fires the given callback after the cache entry is evicted from the cache. /// /// The . /// The callback to register for calling after an entry is evicted. diff --git a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/MemoryCacheExtensions.cs b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/MemoryCacheExtensions.cs index 5ea58dc486d..c53cda1b0ea 100644 --- a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/MemoryCacheExtensions.cs +++ b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/MemoryCacheExtensions.cs @@ -8,7 +8,7 @@ namespace Microsoft.Extensions.Caching.Memory { /// - /// Provide extensions methods for operations. + /// Provides extensions methods for operations. /// public static class CacheExtensions { @@ -37,13 +37,13 @@ public static class CacheExtensions } /// - /// Try to get the value associated with the given key. + /// Tries to get the value associated with the given key. /// /// The type of the object to get. /// The instance this method extends. /// The key of the value to get. /// The value associated with the given key. - /// true if the key was found. false otherwise. + /// true if the key was found; false otherwise. public static bool TryGetValue(this IMemoryCache cache, object key, out TItem? value) { if (cache.TryGetValue(key, out object? result)) @@ -70,7 +70,7 @@ public static bool TryGetValue(this IMemoryCache cache, object key, out T /// /// The type of the object to set. /// The instance this method extends. - /// The key of the entry to add. + /// The key of the entry to set. /// The value to associate with the key. /// The value that was set. public static TItem Set(this IMemoryCache cache, object key, TItem value) @@ -86,7 +86,7 @@ public static TItem Set(this IMemoryCache cache, object key, TItem value) /// /// The type of the object to set. /// The instance this method extends. - /// The key of the entry to add. + /// The key of the entry to set. /// The value to associate with the key. /// The point in time at which the cache entry will expire. /// The value that was set. @@ -104,7 +104,7 @@ public static TItem Set(this IMemoryCache cache, object key, TItem value, /// /// The type of the object to set. /// The instance this method extends. - /// The key of the entry to add. + /// The key of the entry to set. /// The value to associate with the key. /// The duration from now after which the cache entry will expire. /// The value that was set. @@ -122,7 +122,7 @@ public static TItem Set(this IMemoryCache cache, object key, TItem value, /// /// The type of the object to set. /// The instance this method extends. - /// The key of the entry to add. + /// The key of the entry to set. /// The value to associate with the key. /// The that causes the cache entry to expire. /// The value that was set. @@ -140,7 +140,7 @@ public static TItem Set(this IMemoryCache cache, object key, TItem value, /// /// The type of the object to set. /// The instance this method extends. - /// The key of the entry to add. + /// The key of the entry to set. /// The value to associate with the key. /// The existing instance to apply to the new entry. /// The value that was set. diff --git a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/PostEvictionDelegate.cs b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/PostEvictionDelegate.cs index 6414f2154a9..182bf90750b 100644 --- a/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/PostEvictionDelegate.cs +++ b/src/libraries/Microsoft.Extensions.Caching.Abstractions/src/PostEvictionDelegate.cs @@ -4,7 +4,7 @@ namespace Microsoft.Extensions.Caching.Memory { /// - /// Signature of the callback which gets called when a cache entry expires. + /// Represents the callback method that gets called when a cache entry expires. /// /// The key of the entry being evicted. /// The value of the entry being evicted. diff --git a/src/libraries/Microsoft.Extensions.Caching.Memory/Microsoft.Extensions.Caching.Memory.sln b/src/libraries/Microsoft.Extensions.Caching.Memory/Microsoft.Extensions.Caching.Memory.sln index 73d835e6eef..5b1b3d1dac6 100644 --- a/src/libraries/Microsoft.Extensions.Caching.Memory/Microsoft.Extensions.Caching.Memory.sln +++ b/src/libraries/Microsoft.Extensions.Caching.Memory/Microsoft.Extensions.Caching.Memory.sln @@ -47,6 +47,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Diagnostics.Diagnost EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{FFF6F64C-FDBF-4436-9D07-2FC96BCB7881}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{4BA8112C-4C5C-44E9-AF36-CD3B0B4C09DF}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{88C1F3B9-B92E-4847-AF86-A437FA34382B}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{94673D00-C1BB-48F3-8A1B-75DDEA247AB0}" @@ -181,6 +183,10 @@ Global {FFF6F64C-FDBF-4436-9D07-2FC96BCB7881}.Debug|Any CPU.Build.0 = Debug|Any CPU {FFF6F64C-FDBF-4436-9D07-2FC96BCB7881}.Release|Any CPU.ActiveCfg = Release|Any CPU {FFF6F64C-FDBF-4436-9D07-2FC96BCB7881}.Release|Any CPU.Build.0 = Release|Any CPU + {4BA8112C-4C5C-44E9-AF36-CD3B0B4C09DF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {4BA8112C-4C5C-44E9-AF36-CD3B0B4C09DF}.Debug|Any CPU.Build.0 = Debug|Any CPU + {4BA8112C-4C5C-44E9-AF36-CD3B0B4C09DF}.Release|Any CPU.ActiveCfg = Release|Any CPU + {4BA8112C-4C5C-44E9-AF36-CD3B0B4C09DF}.Release|Any CPU.Build.0 = Release|Any CPU {88C1F3B9-B92E-4847-AF86-A437FA34382B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {88C1F3B9-B92E-4847-AF86-A437FA34382B}.Debug|Any CPU.Build.0 = Debug|Any CPU {88C1F3B9-B92E-4847-AF86-A437FA34382B}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -243,6 +249,7 @@ Global {51A94A31-6734-4BD1-AACF-73A0D704C985} = {C77F6550-84B5-4C20-8541-8B6118A8651A} {C66BFC12-83ED-4131-8F16-C366185E4687} = {C77F6550-84B5-4C20-8541-8B6118A8651A} {FFF6F64C-FDBF-4436-9D07-2FC96BCB7881} = {C77F6550-84B5-4C20-8541-8B6118A8651A} + {4BA8112C-4C5C-44E9-AF36-CD3B0B4C09DF} = {C77F6550-84B5-4C20-8541-8B6118A8651A} {88C1F3B9-B92E-4847-AF86-A437FA34382B} = {C77F6550-84B5-4C20-8541-8B6118A8651A} {94673D00-C1BB-48F3-8A1B-75DDEA247AB0} = {C77F6550-84B5-4C20-8541-8B6118A8651A} {AC487C8F-3F9C-4E47-BB15-B46BA7494E4E} = {DD1F186A-F6F9-4409-8CB3-81EBE93D68E5} diff --git a/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryCache.cs b/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryCache.cs index add0ceebe6c..0c954996944 100644 --- a/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryCache.cs +++ b/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryCache.cs @@ -16,7 +16,7 @@ namespace Microsoft.Extensions.Caching.Memory { /// - /// An implementation of using a dictionary to + /// Implements using a dictionary to /// store its entries. /// public class MemoryCache : IMemoryCache @@ -434,9 +434,13 @@ private void ScanForExpiredItems() } /// - /// Returns true if increasing the cache size by the size of entry would - /// cause it to exceed any size limit on the cache, otherwise, returns false. + /// Determines if increasing the cache size by the size of the + /// entry would cause it to exceed any size limit on the cache. /// + /// + /// if increasing the cache size would + /// cause it to exceed the size limit; otherwise, . + /// private bool UpdateCacheSizeExceedsCapacity(CacheEntry entry, CacheEntry? priorEntry, CoherentState coherentState) { long sizeLimit = _options.SizeLimitValue; @@ -621,9 +625,9 @@ public void Dispose() } /// - /// Dispose the cache and clear all entries. + /// Disposes the cache and clears all entries. /// - /// Dispose the object resources if true; otherwise, take no action. + /// to dispose the object resources; to take no action. protected virtual void Dispose(bool disposing) { if (!_disposed) diff --git a/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryCacheOptions.cs b/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryCacheOptions.cs index 7401c97d04a..8f15cd10e3a 100644 --- a/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryCacheOptions.cs +++ b/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryCacheOptions.cs @@ -9,7 +9,7 @@ namespace Microsoft.Extensions.Caching.Memory { /// - /// Options class for . + /// Specifies options for . /// public class MemoryCacheOptions : IOptions { @@ -35,6 +35,12 @@ public class MemoryCacheOptions : IOptions /// /// Gets or sets the maximum size of the cache. /// + /// + /// The units are arbitrary. Users specify the size of every entry they add to the cache. + /// If no size is specified, the entry has no size and the size limit is ignored for that entry. + /// For more information, see + /// Use SetSize, Size, and SizeLimit to limit cache size. + /// public long? SizeLimit { get => _sizeLimit < 0 ? null : _sizeLimit; @@ -50,14 +56,14 @@ public long? SizeLimit } /// - /// Enables ot disables the option to compact the cache when the maximum size is exceeded. + /// Gets or sets a value that indicates whether the cache is compacted when the maximum size is exceeded. /// [EditorBrowsableAttribute(EditorBrowsableState.Never)] [Obsolete("This property is retained only for compatibility. Remove use and instead call MemoryCache.Compact as needed.", error: true)] public bool CompactOnMemoryPressure { get; set; } /// - /// Gets or sets the amount to compact the cache by when the maximum size is exceeded. + /// Gets or sets the amount the cache is compacted by when the maximum size is exceeded. /// public double CompactionPercentage { @@ -74,14 +80,22 @@ public double CompactionPercentage } /// - /// Gets or sets whether to track linked entries. Disabled by default. + /// Gets or sets a value that indicates whether linked entries are tracked. /// - /// Prior to .NET 7 this feature was always enabled. + /// + /// if linked entries are tracked; otherwise, . + /// The default is . + /// + /// Prior to .NET 7, this feature was always enabled. public bool TrackLinkedCacheEntries { get; set; } /// - /// Gets or sets whether to track memory cache statistics. Disabled by default. + /// Gets or sets a value that indicates whether memory cache statistics are tracked. /// + /// + /// if memory cache statistics are tracked; otherwise, . + /// The default is . + /// public bool TrackStatistics { get; set; } MemoryCacheOptions IOptions.Value diff --git a/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryCacheServiceCollectionExtensions.cs b/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryCacheServiceCollectionExtensions.cs index b8d443cbac1..f04a674209b 100644 --- a/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryCacheServiceCollectionExtensions.cs +++ b/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryCacheServiceCollectionExtensions.cs @@ -14,7 +14,7 @@ namespace Microsoft.Extensions.DependencyInjection public static class MemoryCacheServiceCollectionExtensions { /// - /// Adds a non distributed in memory implementation of to the + /// Adds a non distributed in-memory implementation of to the /// . /// /// The to add services to. @@ -30,7 +30,7 @@ public static IServiceCollection AddMemoryCache(this IServiceCollection services } /// - /// Adds a non distributed in memory implementation of to the + /// Adds a non distributed in-memory implementation of to the /// . /// /// The to add services to. diff --git a/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryDistributedCache.cs b/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryDistributedCache.cs index 7d6b45c2009..a588e361abd 100644 --- a/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryDistributedCache.cs +++ b/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryDistributedCache.cs @@ -12,7 +12,7 @@ namespace Microsoft.Extensions.Caching.Distributed { /// - /// An implementation of using . + /// Implements using . /// public class MemoryDistributedCache : IDistributedCache { diff --git a/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryDistributedCacheOptions.cs b/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryDistributedCacheOptions.cs index 73afd8100e0..0e48a50e7be 100644 --- a/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryDistributedCacheOptions.cs +++ b/src/libraries/Microsoft.Extensions.Caching.Memory/src/MemoryDistributedCacheOptions.cs @@ -4,7 +4,7 @@ namespace Microsoft.Extensions.Caching.Memory { /// - /// Options class for . + /// Specifies options for . /// public class MemoryDistributedCacheOptions : MemoryCacheOptions { diff --git a/src/libraries/Microsoft.Extensions.Configuration.Abstractions/Microsoft.Extensions.Configuration.Abstractions.sln b/src/libraries/Microsoft.Extensions.Configuration.Abstractions/Microsoft.Extensions.Configuration.Abstractions.sln index f827b05854a..17b81c44de4 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Abstractions/Microsoft.Extensions.Configuration.Abstractions.sln +++ b/src/libraries/Microsoft.Extensions.Configuration.Abstractions/Microsoft.Extensions.Configuration.Abstractions.sln @@ -7,7 +7,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Primit EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Primitives", "..\Microsoft.Extensions.Primitives\src\Microsoft.Extensions.Primitives.csproj", "{EEE9E1A2-8512-4154-8B5D-532244B896CD}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{CB6528FF-88EB-402B-910C-9C64EABA0436}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{F7DD8DA1-0A9A-4953-8F66-B38919B0D444}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{92E86957-5217-456B-B9CA-E0C204822367}" EndProject @@ -57,10 +57,10 @@ Global {EEE9E1A2-8512-4154-8B5D-532244B896CD}.Debug|Any CPU.Build.0 = Debug|Any CPU {EEE9E1A2-8512-4154-8B5D-532244B896CD}.Release|Any CPU.ActiveCfg = Release|Any CPU {EEE9E1A2-8512-4154-8B5D-532244B896CD}.Release|Any CPU.Build.0 = Release|Any CPU - {CB6528FF-88EB-402B-910C-9C64EABA0436}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {CB6528FF-88EB-402B-910C-9C64EABA0436}.Debug|Any CPU.Build.0 = Debug|Any CPU - {CB6528FF-88EB-402B-910C-9C64EABA0436}.Release|Any CPU.ActiveCfg = Release|Any CPU - {CB6528FF-88EB-402B-910C-9C64EABA0436}.Release|Any CPU.Build.0 = Release|Any CPU + {F7DD8DA1-0A9A-4953-8F66-B38919B0D444}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F7DD8DA1-0A9A-4953-8F66-B38919B0D444}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F7DD8DA1-0A9A-4953-8F66-B38919B0D444}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F7DD8DA1-0A9A-4953-8F66-B38919B0D444}.Release|Any CPU.Build.0 = Release|Any CPU {92E86957-5217-456B-B9CA-E0C204822367}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {92E86957-5217-456B-B9CA-E0C204822367}.Debug|Any CPU.Build.0 = Debug|Any CPU {92E86957-5217-456B-B9CA-E0C204822367}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -94,7 +94,7 @@ Global {711119F1-7759-49B9-8B66-EF72F4163729} = {B8E3F471-7DA8-4D1D-9468-21542AAD0A2B} {CAA4A23C-2C58-4C93-87BA-CCC87260F20A} = {343DB133-E1E0-4FC0-896C-DA15D0C58AD5} {EEE9E1A2-8512-4154-8B5D-532244B896CD} = {343DB133-E1E0-4FC0-896C-DA15D0C58AD5} - {CB6528FF-88EB-402B-910C-9C64EABA0436} = {0FE1CBCE-E173-4926-9CD1-64D7AE63A994} + {F7DD8DA1-0A9A-4953-8F66-B38919B0D444} = {0FE1CBCE-E173-4926-9CD1-64D7AE63A994} {92E86957-5217-456B-B9CA-E0C204822367} = {0FE1CBCE-E173-4926-9CD1-64D7AE63A994} {E98D77D5-E88C-4E0A-A6BE-F97B48370A96} = {53E613E6-9657-4256-A4A5-479D23F0E43B} {CFA06A25-EE15-40BC-A852-0E5AD8B40E26} = {53E613E6-9657-4256-A4A5-479D23F0E43B} diff --git a/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/ConfigurationDebugViewContext.cs b/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/ConfigurationDebugViewContext.cs index 4f7b3d6fa27..f0c70176f6c 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/ConfigurationDebugViewContext.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/ConfigurationDebugViewContext.cs @@ -4,7 +4,7 @@ namespace Microsoft.Extensions.Configuration { /// - /// Provides the data about current item of the configuration. + /// Provides data about the current item of the configuration. /// public readonly struct ConfigurationDebugViewContext { diff --git a/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/ConfigurationExtensions.cs b/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/ConfigurationExtensions.cs index fa008b09591..408b8cb9034 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/ConfigurationExtensions.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/ConfigurationExtensions.cs @@ -9,7 +9,7 @@ namespace Microsoft.Extensions.Configuration { /// - /// Extension methods for configuration classes. + /// Provides extension methods for configuration classes. /// public static class ConfigurationExtensions { @@ -27,7 +27,8 @@ public static class ConfigurationExtensions } /// - /// Shorthand for GetSection("ConnectionStrings")[name]. + /// Gets the specified connection string from the specified configuration. + /// Shorthand for GetSection("ConnectionStrings")[name]. /// /// The configuration to enumerate. /// The connection string key. @@ -48,7 +49,7 @@ public static class ConfigurationExtensions /// Get the enumeration of key value pairs within the /// /// The configuration to enumerate. - /// If true, the child keys returned will have the current configuration's Path trimmed from the front. + /// to trim the current configuration's path from the front of the returned child keys. /// An enumeration of key value pairs. public static IEnumerable> AsEnumerable(this IConfiguration configuration, bool makePathsRelative) { @@ -71,7 +72,7 @@ public static class ConfigurationExtensions } /// - /// Determines whether the section has a or has children + /// Determines whether the section has a or has children. /// /// The section to enumerate. /// if the section has values or children; otherwise, . @@ -85,7 +86,7 @@ public static bool Exists([NotNullWhen(true)] this IConfigurationSection? sectio } /// - /// Gets a configuration sub-section with the specified key. + /// Gets a configuration subsection with the specified key. /// /// The configuration to enumerate. /// The key of the configuration section. diff --git a/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/ConfigurationKeyNameAttribute.cs b/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/ConfigurationKeyNameAttribute.cs index d9a4e520267..49e34e5893c 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/ConfigurationKeyNameAttribute.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/ConfigurationKeyNameAttribute.cs @@ -18,7 +18,7 @@ public sealed class ConfigurationKeyNameAttribute : Attribute public ConfigurationKeyNameAttribute(string name) => Name = name; /// - /// The key name for a configuration property. + /// Gets the key name for a configuration property. /// public string Name { get; } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/ConfigurationPath.cs b/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/ConfigurationPath.cs index 14865e1b5f6..bd366e6b295 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/ConfigurationPath.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/ConfigurationPath.cs @@ -8,7 +8,7 @@ namespace Microsoft.Extensions.Configuration { /// - /// Utility methods and constants for manipulating Configuration paths + /// Provides utility methods and constants for manipulating Configuration paths. /// public static class ConfigurationPath { diff --git a/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/ConfigurationRootExtensions.cs b/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/ConfigurationRootExtensions.cs index 8a76e9486d9..fa323db0721 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/ConfigurationRootExtensions.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/ConfigurationRootExtensions.cs @@ -9,14 +9,14 @@ namespace Microsoft.Extensions.Configuration { /// - /// Extension methods for . + /// Provides extension methods for . /// public static class ConfigurationRootExtensions { /// /// Generates a human-readable view of the configuration showing where each value came from. /// - /// The debug view. + /// The debug view. public static string GetDebugView(this IConfigurationRoot root) { return GetDebugView(root, processValue: null); @@ -25,14 +25,14 @@ public static string GetDebugView(this IConfigurationRoot root) /// /// Generates a human-readable view of the configuration showing where each value came from. /// - /// Configuration root + /// The configuration root. /// - /// Function for processing the value e.g. hiding secrets + /// The function for processing the value, for example, hiding secrets. /// Parameters: - /// ConfigurationDebugViewContext: Context of the current configuration item - /// returns: A string value is used to assign as the Value of the configuration section + /// ConfigurationDebugViewContext: Context of the current configuration item. + /// returns: A string value is used to assign as the Value of the configuration section. /// - /// The debug view. + /// The debug view. public static string GetDebugView(this IConfigurationRoot root, Func? processValue) { void RecurseChildren( diff --git a/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/IConfiguration.cs b/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/IConfiguration.cs index 0e9da613685..188decf9b4a 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/IConfiguration.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/IConfiguration.cs @@ -38,7 +38,7 @@ public interface IConfiguration /// /// Returns a that can be used to observe when this configuration is reloaded. /// - /// A . + /// An token if this provider supports change tracking; otherwise, . IChangeToken GetReloadToken(); } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/IConfigurationProvider.cs b/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/IConfigurationProvider.cs index e957d91a089..c5684909eaf 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/IConfigurationProvider.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/IConfigurationProvider.cs @@ -15,8 +15,8 @@ public interface IConfigurationProvider /// Tries to get a configuration value for the specified key. /// /// The key. - /// The value. - /// True if a value for the specified key was found, otherwise false. + /// When this method returns, contains the value for the specified key. + /// if a value for the specified key was found, otherwise . bool TryGet(string key, out string? value); /// @@ -38,9 +38,9 @@ public interface IConfigurationProvider void Load(); /// - /// Returns the immediate descendant configuration keys for a given parent path based on this - /// s data and the set of keys returned by all the preceding - /// s. + /// Returns the immediate descendant configuration keys for a given parent path based on the data of this + /// and the set of keys returned by all the preceding + /// providers. /// /// The child keys returned by the preceding providers for the same parent path. /// The parent path. diff --git a/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/IConfigurationRoot.cs b/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/IConfigurationRoot.cs index dabdcc5da66..8c65634f7a8 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/IConfigurationRoot.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Abstractions/src/IConfigurationRoot.cs @@ -11,12 +11,12 @@ namespace Microsoft.Extensions.Configuration public interface IConfigurationRoot : IConfiguration { /// - /// Force the configuration values to be reloaded from the underlying s. + /// Forces the configuration values to be reloaded from the underlying providers. /// void Reload(); /// - /// The s for this configuration. + /// Gets the providers for this configuration. /// IEnumerable Providers { get; } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/Microsoft.Extensions.Configuration.Binder.sln b/src/libraries/Microsoft.Extensions.Configuration.Binder/Microsoft.Extensions.Configuration.Binder.sln index e62a6091c50..9b8f783fa24 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/Microsoft.Extensions.Configuration.Binder.sln +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/Microsoft.Extensions.Configuration.Binder.sln @@ -75,6 +75,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Memory", "..\System. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{9E2C43CF-2E01-4570-8C02-F678607DDAFF}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{215561D1-D9E1-471C-8D98-6600515E988A}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{05B7F752-4991-4DC8-9B06-8269211E7817}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{6E58AF2F-AB35-4279-9135-67E97BCE1432}" @@ -281,6 +283,10 @@ Global {9E2C43CF-2E01-4570-8C02-F678607DDAFF}.Debug|Any CPU.Build.0 = Debug|Any CPU {9E2C43CF-2E01-4570-8C02-F678607DDAFF}.Release|Any CPU.ActiveCfg = Release|Any CPU {9E2C43CF-2E01-4570-8C02-F678607DDAFF}.Release|Any CPU.Build.0 = Release|Any CPU + {215561D1-D9E1-471C-8D98-6600515E988A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {215561D1-D9E1-471C-8D98-6600515E988A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {215561D1-D9E1-471C-8D98-6600515E988A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {215561D1-D9E1-471C-8D98-6600515E988A}.Release|Any CPU.Build.0 = Release|Any CPU {05B7F752-4991-4DC8-9B06-8269211E7817}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {05B7F752-4991-4DC8-9B06-8269211E7817}.Debug|Any CPU.Build.0 = Debug|Any CPU {05B7F752-4991-4DC8-9B06-8269211E7817}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -393,6 +399,7 @@ Global {D4B3EEA1-7394-49EA-A088-897C0CD26D11} = {CC3961B0-C62D-44B9-91DB-11D94A3F91A5} {F132C649-6660-4583-8AD1-36D38711A994} = {CC3961B0-C62D-44B9-91DB-11D94A3F91A5} {9E2C43CF-2E01-4570-8C02-F678607DDAFF} = {CC3961B0-C62D-44B9-91DB-11D94A3F91A5} + {215561D1-D9E1-471C-8D98-6600515E988A} = {CC3961B0-C62D-44B9-91DB-11D94A3F91A5} {05B7F752-4991-4DC8-9B06-8269211E7817} = {CC3961B0-C62D-44B9-91DB-11D94A3F91A5} {6E58AF2F-AB35-4279-9135-67E97BCE1432} = {CC3961B0-C62D-44B9-91DB-11D94A3F91A5} {D2FE6BEA-70F5-4AE3-8D29-DB6568A9DE49} = {CC3961B0-C62D-44B9-91DB-11D94A3F91A5} diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/gen/ConfigurationBindingGenerator.Parser.cs b/src/libraries/Microsoft.Extensions.Configuration.Binder/gen/ConfigurationBindingGenerator.Parser.cs index 81fb4985537..dc940d2cb07 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/gen/ConfigurationBindingGenerator.Parser.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/gen/ConfigurationBindingGenerator.Parser.cs @@ -197,7 +197,7 @@ private TypeSpec CreateTypeSpec(TypeParseInfo typeParseInfo) } else if (IsCollection(type)) { - spec = CreateCollectionSpec(typeParseInfo); + spec = CreateCollectionSpec(typeParseInfo) ?? CreateObjectSpec(typeParseInfo); } else if (SymbolEqualityComparer.Default.Equals(type, _typeSymbols.IConfigurationSection)) { @@ -360,34 +360,37 @@ private TypeSpec CreateArraySpec(TypeParseInfo typeParseInfo) }; } - private TypeSpec CreateCollectionSpec(TypeParseInfo typeParseInfo) + private TypeSpec? CreateCollectionSpec(TypeParseInfo typeParseInfo) { INamedTypeSymbol type = (INamedTypeSymbol)typeParseInfo.TypeSymbol; - TypeSpec spec; + TypeSpec? spec; if (IsCandidateDictionary(type, out ITypeSymbol? keyType, out ITypeSymbol? elementType)) { spec = CreateDictionarySpec(typeParseInfo, keyType, elementType); - Debug.Assert(spec is DictionarySpec or UnsupportedTypeSpec); + Debug.Assert(spec is DictionarySpec or UnsupportedTypeSpec or null); } else { spec = CreateEnumerableSpec(typeParseInfo); - Debug.Assert(spec is EnumerableSpec or UnsupportedTypeSpec); + Debug.Assert(spec is EnumerableSpec or UnsupportedTypeSpec or null); } return spec; } - private TypeSpec CreateDictionarySpec(TypeParseInfo typeParseInfo, ITypeSymbol keyTypeSymbol, ITypeSymbol elementTypeSymbol) + private TypeSpec? CreateDictionarySpec(TypeParseInfo typeParseInfo, ITypeSymbol keyTypeSymbol, ITypeSymbol elementTypeSymbol) { + INamedTypeSymbol type = (INamedTypeSymbol)typeParseInfo.TypeSymbol; + + // treat as unsupported if it implements IDictionary<,>, otherwise we'll try to fallback and treat as an object + bool isDictionary = _typeSymbols.GenericICollection is not null && GetInterface(type, _typeSymbols.GenericIDictionary_Unbound) is not null; + if (IsUnsupportedType(keyTypeSymbol) || IsUnsupportedType(elementTypeSymbol)) { - return CreateUnsupportedCollectionSpec(typeParseInfo); + return isDictionary ? CreateUnsupportedCollectionSpec(typeParseInfo) : null; } - INamedTypeSymbol type = (INamedTypeSymbol)typeParseInfo.TypeSymbol; - CollectionInstantiationStrategy instantiationStrategy; CollectionInstantiationConcreteType instantiationConcreteType; CollectionPopulationCastType populationCastType; @@ -402,14 +405,15 @@ private TypeSpec CreateDictionarySpec(TypeParseInfo typeParseInfo, ITypeSymbol k { populationCastType = CollectionPopulationCastType.NotApplicable; } - else if (_typeSymbols.GenericIDictionary is not null && GetInterface(type, _typeSymbols.GenericIDictionary_Unbound) is not null) + else if (isDictionary) { // implements IDictionary<,> -- cast to it. populationCastType = CollectionPopulationCastType.IDictionary; } else { - return CreateUnsupportedCollectionSpec(typeParseInfo); + // not a dictionary + return null; } } else if (_typeSymbols.Dictionary is not null && @@ -429,7 +433,7 @@ private TypeSpec CreateDictionarySpec(TypeParseInfo typeParseInfo, ITypeSymbol k } else { - return CreateUnsupportedCollectionSpec(typeParseInfo); + return isDictionary ? CreateUnsupportedCollectionSpec(typeParseInfo) : null; } TypeRef keyTypeRef = EnqueueTransitiveType(typeParseInfo, keyTypeSymbol, DiagnosticDescriptors.DictionaryKeyNotSupported); @@ -447,18 +451,20 @@ private TypeSpec CreateDictionarySpec(TypeParseInfo typeParseInfo, ITypeSymbol k }; } - private TypeSpec CreateEnumerableSpec(TypeParseInfo typeParseInfo) + private TypeSpec? CreateEnumerableSpec(TypeParseInfo typeParseInfo) { INamedTypeSymbol type = (INamedTypeSymbol)typeParseInfo.TypeSymbol; + bool isCollection = _typeSymbols.GenericICollection is not null && GetInterface(type, _typeSymbols.GenericICollection_Unbound) is not null; + if (!TryGetElementType(type, out ITypeSymbol? elementType)) { - return CreateUnsupportedCollectionSpec(typeParseInfo); + return isCollection ? CreateUnsupportedCollectionSpec(typeParseInfo) : null; } if (IsUnsupportedType(elementType)) { - return CreateUnsupportedCollectionSpec(typeParseInfo); + return isCollection ? CreateUnsupportedCollectionSpec(typeParseInfo) : null; } CollectionInstantiationStrategy instantiationStrategy; @@ -475,14 +481,15 @@ private TypeSpec CreateEnumerableSpec(TypeParseInfo typeParseInfo) { populationCastType = CollectionPopulationCastType.NotApplicable; } - else if (_typeSymbols.GenericICollection is not null && GetInterface(type, _typeSymbols.GenericICollection_Unbound) is not null) + else if (isCollection) { // implements ICollection<> -- cast to it populationCastType = CollectionPopulationCastType.ICollection; } else { - return CreateUnsupportedCollectionSpec(typeParseInfo); + // not a collection + return null; } } else if ((IsInterfaceMatch(type, _typeSymbols.GenericICollection_Unbound) || IsInterfaceMatch(type, _typeSymbols.GenericIList_Unbound))) @@ -523,7 +530,7 @@ private TypeSpec CreateEnumerableSpec(TypeParseInfo typeParseInfo) } else { - return CreateUnsupportedCollectionSpec(typeParseInfo); + return isCollection ? CreateUnsupportedCollectionSpec(typeParseInfo) : null; } TypeRef elementTypeRef = EnqueueTransitiveType(typeParseInfo, elementType, DiagnosticDescriptors.ElementTypeNotSupported); @@ -545,7 +552,9 @@ private bool IsAssignableTo(ITypeSymbol source, ITypeSymbol dest) return conversion.IsReference && conversion.IsImplicit; } - private bool IsUnsupportedType(ITypeSymbol type) + private HashSet? _visitedTypes = new(SymbolEqualityComparer.Default); + + private bool IsUnsupportedType(ITypeSymbol type, HashSet? visitedTypes = null) { if (type.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T) { @@ -562,25 +571,55 @@ private bool IsUnsupportedType(ITypeSymbol type) return true; } - if (type is IArrayTypeSymbol arrayTypeSymbol) + if (visitedTypes?.Contains(type) is true) { - return arrayTypeSymbol.Rank > 1 || IsUnsupportedType(arrayTypeSymbol.ElementType); + // avoid infinite recursion in nested types like + // public record RecursiveType + // { + // public TreeElement? Tree { get; set; } + // } + // public sealed class TreeElement : Dictionary; + // + // return false for the second call. The type will continue be checked in the first call anyway. + return false; } - if (IsCollection(type)) + IArrayTypeSymbol? arrayTypeSymbol = type as IArrayTypeSymbol; + if (arrayTypeSymbol is null) { - INamedTypeSymbol collectionType = (INamedTypeSymbol)type; - - if (IsCandidateDictionary(collectionType, out ITypeSymbol? keyType, out ITypeSymbol? elementType)) - { - return IsUnsupportedType(keyType) || IsUnsupportedType(elementType); - } - else if (TryGetElementType(collectionType, out elementType)) + if (!IsCollection(type)) { - return IsUnsupportedType(elementType); + return false; } } + if (visitedTypes is null) + { + visitedTypes = _visitedTypes; + visitedTypes.Clear(); + } + + visitedTypes.Add(type); + + if (arrayTypeSymbol is not null) + { + return arrayTypeSymbol.Rank > 1 || IsUnsupportedType(arrayTypeSymbol.ElementType, visitedTypes); + } + + Debug.Assert(IsCollection(type)); + + INamedTypeSymbol collectionType = (INamedTypeSymbol)type; + + if (IsCandidateDictionary(collectionType, out ITypeSymbol? keyType, out ITypeSymbol? elementType)) + { + return IsUnsupportedType(keyType, visitedTypes) || IsUnsupportedType(elementType, visitedTypes); + } + + if (TryGetElementType(collectionType, out elementType)) + { + return IsUnsupportedType(elementType, visitedTypes); + } + return false; } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/gen/Emitter/CoreBindingHelpers.cs b/src/libraries/Microsoft.Extensions.Configuration.Binder/gen/Emitter/CoreBindingHelpers.cs index 3433544bf9e..685850bb16e 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/gen/Emitter/CoreBindingHelpers.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/gen/Emitter/CoreBindingHelpers.cs @@ -901,6 +901,15 @@ private bool EmitBindImplForMember( } case ComplexTypeSpec complexType: { + // Early detection of types we cannot bind to and skip it. + if (!_typeIndex.HasBindableMembers(complexType) && + !_typeIndex.GetEffectiveTypeSpec(complexType).IsValueType && + complexType is not CollectionSpec && + ((ObjectSpec)complexType).InstantiationStrategy == ObjectInstantiationStrategy.ParameterizedConstructor) + { + return false; + } + string sectionValidationCall = $"{MethodsToGen_CoreBindingHelper.AsConfigWithChildren}({sectionParseExpr})"; string sectionIdentifier = GetIncrementalIdentifier(Identifier.section); @@ -968,15 +977,31 @@ private void EmitBindingLogicForComplexMember( initKind = InitializationKind.SimpleAssignment; } - Action? writeOnSuccess = !canSet - ? null - : bindedValueIdentifier => - { - if (memberAccessExpr != bindedValueIdentifier) - { - _writer.WriteLine($"{memberAccessExpr} = {bindedValueIdentifier};"); - } - }; + Action? writeOnSuccess = !canSet + ? null + : (bindedValueIdentifier, tempIdentifierStoringExpr) => + { + if (memberAccessExpr != bindedValueIdentifier) + { + _writer.WriteLine($"{memberAccessExpr} = {bindedValueIdentifier};"); + + if (tempIdentifierStoringExpr is not null) + { + _writer.WriteLine($"{tempIdentifierStoringExpr}"); + } + + if (member.CanGet && _typeIndex.CanInstantiate(effectiveMemberType)) + { + EmitEndBlock(); + EmitStartBlock("else"); + _writer.WriteLine($"{memberAccessExpr} = {memberAccessExpr};"); + } + } + else + { + _writer.WriteLine($"{tempIdentifierStoringExpr}"); + } + }; EmitBindingLogic( effectiveMemberType, @@ -994,7 +1019,7 @@ private void EmitBindingLogic( string configArgExpr, InitializationKind initKind, ValueDefaulting valueDefaulting, - Action? writeOnSuccess = null) + Action? writeOnSuccess = null) { if (!_typeIndex.HasBindableMembers(type)) { @@ -1022,15 +1047,14 @@ private void EmitBindingLogic( } else if (initKind is InitializationKind.None && type.IsValueType) { - EmitBindingLogic(tempIdentifier, InitializationKind.Declaration); - _writer.WriteLine($"{memberAccessExpr} = {tempIdentifier};"); + EmitBindingLogic(tempIdentifier, InitializationKind.Declaration, $"{memberAccessExpr} = {tempIdentifier};"); } else { EmitBindingLogic(memberAccessExpr, initKind); } - void EmitBindingLogic(string instanceToBindExpr, InitializationKind initKind) + void EmitBindingLogic(string instanceToBindExpr, InitializationKind initKind, string? tempIdentifierStoringExpr = null) { string bindCoreCall = $@"{nameof(MethodsToGen_CoreBindingHelper.BindCore)}({configArgExpr}, ref {instanceToBindExpr}, defaultValueIfNotFound: {FormatDefaultValueIfNotFound()}, {Identifier.binderOptions});"; @@ -1060,7 +1084,7 @@ void EmitBindingLogic(string instanceToBindExpr, InitializationKind initKind) void EmitBindCoreCall() { _writer.WriteLine(bindCoreCall); - writeOnSuccess?.Invoke(instanceToBindExpr); + writeOnSuccess?.Invoke(instanceToBindExpr, tempIdentifierStoringExpr); } string FormatDefaultValueIfNotFound() => valueDefaulting == ValueDefaulting.CallSetter ? "true" : "false"; @@ -1094,7 +1118,9 @@ private void EmitBindingLogic( } else { - EmitStartBlock($"if ({sectionValueExpr} is string {nonNull_StringValue_Identifier})"); + // In case of calling parsing methods, check the section value first for null or empty before calling parse. + string extraCondition = typeKind == StringParsableTypeKind.AssignFromSectionValue ? "" : $" && !string.IsNullOrEmpty({nonNull_StringValue_Identifier})"; + EmitStartBlock($"if ({sectionValueExpr} is string {nonNull_StringValue_Identifier}{extraCondition})"); writeOnSuccess?.Invoke(parsedValueExpr); EmitEndBlock(); } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/gen/Specs/BindingHelperInfo.cs b/src/libraries/Microsoft.Extensions.Configuration.Binder/gen/Specs/BindingHelperInfo.cs index dfa3c5f1690..5cdc40e0115 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/gen/Specs/BindingHelperInfo.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/gen/Specs/BindingHelperInfo.cs @@ -131,6 +131,9 @@ bool TryRegisterCore() } case DictionarySpec dictionarySpec: { + // Base case to avoid stack overflow for recursive object graphs. + _seenTransitiveTypes.Add(typeRef, true); + bool shouldRegister = _typeIndex.CanBindTo(typeRef) && TryRegisterTransitiveTypesForMethodGen(dictionarySpec.KeyTypeRef) && TryRegisterTransitiveTypesForMethodGen(dictionarySpec.ElementTypeRef) && @@ -145,6 +148,9 @@ bool TryRegisterCore() } case CollectionSpec collectionSpec: { + // Base case to avoid stack overflow for recursive object graphs. + _seenTransitiveTypes.Add(typeRef, true); + if (_typeIndex.GetTypeSpec(collectionSpec.ElementTypeRef) is ComplexTypeSpec) { _namespaces.Add("System.Linq"); @@ -157,8 +163,7 @@ bool TryRegisterCore() { // Base case to avoid stack overflow for recursive object graphs. // Register all object types for gen; we need to throw runtime exceptions in some cases. - bool shouldRegister = true; - _seenTransitiveTypes.Add(typeRef, shouldRegister); + _seenTransitiveTypes.Add(typeRef, true); // List is used in generated code as a temp holder for formatting // an error for config properties that don't map to object properties. diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/src/BinderOptions.cs b/src/libraries/Microsoft.Extensions.Configuration.Binder/src/BinderOptions.cs index b4664675b15..9bdb48da5c1 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/src/BinderOptions.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/src/BinderOptions.cs @@ -4,22 +4,25 @@ namespace Microsoft.Extensions.Configuration { /// - /// Options class used by the . + /// Specifies options used by the . /// public class BinderOptions { /// - /// When false (the default), the binder will only attempt to set public properties. - /// If true, the binder will attempt to set all non read-only properties. + /// Gets or sets a value that indicates whether the binder attempts to set all properties or only public properties. /// + /// + /// if the binder attempts to set all non-read-only properties; if only public properties are set. + /// public bool BindNonPublicProperties { get; set; } /// - /// When false (the default), no exceptions are thrown when trying to convert a value or when a configuration - /// key is found for which the provided model object does not have an appropriate property which matches the key's name. - /// When true, an is thrown with a description - /// of the error. + /// Gets or sets a value that indicates whether exceptions are thrown when converting a value or when a configuration + /// key is found for which the provided model object doesn't have an appropriate property that matches the key's name. /// + /// + /// if an is thrown with a description; if no exceptions are thrown. The default is . + /// public bool ErrorOnUnknownConfiguration { get; set; } } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/Common/ConfigurationBinderTests.TestClasses.cs b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/Common/ConfigurationBinderTests.TestClasses.cs index 0e6e09e637c..96be1fa6c41 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/Common/ConfigurationBinderTests.TestClasses.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/Common/ConfigurationBinderTests.TestClasses.cs @@ -2,6 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. using System; +using System.Collections; using System.Collections.Generic; using System.Collections.ObjectModel; using System.ComponentModel; @@ -188,6 +189,29 @@ public string Color } } + public sealed class TreeElement : Dictionary; + + public record TypeWithRecursionThroughCollections + { + public TreeElement? Tree { get; set; } + public TreeElement?[]? Flat { get; set; } + public List? List { get; set; } + } + + public class TypeWithValueMutatorPropertySetter + { + private string _value = "Uninitialized"; + public string Value + { + get { return _value; } + set + { + _value = value == "Uninitialized" ? "Initialized" : value; + } + } + public ISet SomeSet { get; set; } = new HashSet(StringComparer.OrdinalIgnoreCase); + } + public record RecordWithArrayParameter(string[] Array); public readonly record struct ReadonlyRecordStructTypeOptions(string Color, int Length); @@ -1067,5 +1091,45 @@ public class DerivedClassWithHiddenMembers : IntermediateDerivedClass public override int X { set => base.X = value + 1; } } + public class EnumerableNotCollection : IEnumerable> + { + public string Names { get; set; } + + public string[] Keywords { get; set; } + + public bool Enabled { get; set; } + + private IEnumerable> enumerate() + { + yield return new KeyValuePair(nameof(Names), Names); + yield return new KeyValuePair(nameof(Keywords), string.Join(",", Keywords)); + yield return new KeyValuePair(nameof(Enabled), Enabled.ToString()); + } + + public IEnumerator> GetEnumerator() => enumerate().GetEnumerator(); + + IEnumerator IEnumerable.GetEnumerator() => enumerate().GetEnumerator(); + } + + public class ParsableValuesClass + { + public int? IntValue { get; set; } + public double? DoubleValue { get; set; } + public bool? BoolValue { get; set; } + public decimal? DecimalValue { get; set; } + public float? FloatValue { get; set; } + public long? LongValue { get; set; } + public short? ShortValue { get; set; } + public byte? ByteValue { get; set; } + public sbyte? SByteValue { get; set; } + public uint? UIntValue { get; set; } + public ushort? UShortValue { get; set; } + public ulong? ULongValue { get; set; } + public DateTime? DateTimeValue { get; set; } + public DateTimeOffset? DateTimeOffsetValue { get; set; } + public TimeSpan? TimeSpanValue { get; set; } + public Guid? GuidValue { get; set; } + public StringComparison? StringComparisonValue { get; set; } + } } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/Common/ConfigurationBinderTests.cs b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/Common/ConfigurationBinderTests.cs index 406738478d1..ef822713f36 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/Common/ConfigurationBinderTests.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/Common/ConfigurationBinderTests.cs @@ -1544,6 +1544,197 @@ public void CanBindOnParametersAndProperties_RecordWithArrayConstructorParameter Assert.Equal(new string[] { "a", "b", "c" }, options.Array); } + + public static IEnumerable Configuration_TestData() + { + yield return new object[] + { + new ConfigurationBuilder() + .AddJsonStream(new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(@"{ + ""IntValue"" : """", + ""DoubleValue"" : """", + ""BoolValue"" : """", + ""DecimalValue"" : """", + ""FloatValue"" : """", + ""LongValue"" : """", + ""ShortValue"" : """", + ""ByteValue"" : """", + ""SByteValue"" : """", + ""UIntValue"" : """", + ""UShortValue"" : """", + ""ULongValue"" : """", + ""DateTimeValue"" : """", + ""DateTimeOffsetValue"" : """", + ""TimeSpanValue"" : """", + ""GuidValue"" : """", + ""StringComparisonValue"" : """" + }" + ))).Build() + }; + + yield return new object[] + { + new ConfigurationBuilder().AddInMemoryCollection( + new Dictionary + { + { "IntValue", null }, + { "DoubleValue", null }, + { "BoolValue", null }, + { "DecimalValue", null }, + { "FloatValue", null }, + { "LongValue", null }, + { "ShortValue", null }, + { "ByteValue", null }, + { "SByteValue", null }, + { "UIntValue", null }, + { "UShortValue", null }, + { "ULongValue", null }, + { "DateTimeValue", null }, + { "DateTimeOffsetValue", null }, + { "TimeSpanValue", null }, + { "GuidValue", null }, + { "StringComparisonValue", null }, + }).Build() + }; + } + + /// + /// Test binding a value parsable types to null configuration values. + /// The test ensure the binding will succeed without exceptions and the value will be null (not set). + /// + [Theory] + [MemberData(nameof(Configuration_TestData))] + public void BindToKnownParsableTypesWithNullValueTest(IConfiguration configuration) + { + ParsableValuesClass instance = configuration.Get(); + Assert.Null(instance.IntValue); + Assert.Null(instance.DoubleValue); + Assert.Null(instance.BoolValue); + Assert.Null(instance.DecimalValue); + Assert.Null(instance.FloatValue); + Assert.Null(instance.LongValue); + Assert.Null(instance.ShortValue); + Assert.Null(instance.ByteValue); + Assert.Null(instance.SByteValue); + Assert.Null(instance.UIntValue); + Assert.Null(instance.UShortValue); + Assert.Null(instance.ULongValue); + Assert.Null(instance.DateTimeValue); + Assert.Null(instance.DateTimeOffsetValue); + Assert.Null(instance.TimeSpanValue); + Assert.Null(instance.GuidValue); + Assert.Null(instance.StringComparisonValue); + } + + /// + /// Test binding to recursive types using Dictionary or Collections. + /// This ensure no stack overflow will occur during the compilation through the source gen or at runtime. + /// + [Fact] + public void BindToRecursiveTypesTest() + { + string jsonConfig = @"{ + ""Tree"": { + ""Branch1"": { + ""Leaf1"": {}, + ""Leaf2"": {} + }, + ""Branch2"": { + ""Leaf3"": {} + } + }, + ""Flat"": [ + { + ""Element1"": { + ""SubElement1"": {} + } + }, + { + ""Element2"": { + ""SubElement2"": {} + } + }, + { + ""Element3"": {} + } + ], + ""List"": [ + { + ""Item1"": { + ""NestedItem1"": {} + } + }, + { + ""Item2"": {} + }, + ] + }"; + + var configuration = new ConfigurationBuilder() + .AddJsonStream(new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(jsonConfig))) + .Build(); + + var instance = new TypeWithRecursionThroughCollections(); + configuration.Bind(instance); + + // Validate the dictionary + Assert.NotNull(instance.Tree); + Assert.Equal(2, instance.Tree.Count); + Assert.NotNull(instance.Tree["Branch1"]); + Assert.Equal(2, instance.Tree["Branch1"].Count); + Assert.Equal(["Leaf1", "Leaf2"], instance.Tree["Branch1"].Keys); + Assert.Equal(["Leaf3"], instance.Tree["Branch2"].Keys); + + // Validate the array + Assert.NotNull(instance.Flat); + Assert.Equal(3, instance.Flat.Length); + Assert.Equal(["Element1"], instance.Flat[0].Keys); + Assert.Equal(["Element2"], instance.Flat[1].Keys); + Assert.Equal(["Element3"], instance.Flat[2].Keys); + Assert.Equal(1, instance.Flat[0].Values.Count); + Assert.Equal(["SubElement1"], instance.Flat[0].Values.ToArray()[0].Keys); + Assert.Equal(1, instance.Flat[1].Values.Count); + Assert.Equal(["SubElement2"], instance.Flat[1].Values.ToArray()[0].Keys); + Assert.Equal(1, instance.Flat[2].Values.Count); + + // Validate the List + Assert.NotNull(instance.Flat); + Assert.Equal(2, instance.List.Count); + Assert.Equal(["Item1"], instance.List[0].Keys); + Assert.Equal(["Item2"], instance.List[1].Keys); + Assert.Equal(1, instance.List[0].Values.Count); + Assert.Equal(["NestedItem1"], instance.List[0].Values.ToArray()[0].Keys); + Assert.Equal(1, instance.List[1].Values.Count); + } + + /// + /// This test ensures that the property setter is invoked during binding, even when there is no configuration for the property. + /// + [Fact] + public void PropertySetterCalledTest() + { + string jsonConfig = @"{ + ""Configuration"": { + ""SomeSet"": [ + ""path"" + ] + } + }"; + + var configuration = new ConfigurationBuilder() + .AddJsonStream(new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(jsonConfig))) + .Build(); + + TypeWithValueMutatorPropertySetter t1 = new(); + Assert.Equal(0, t1.SomeSet.Count); + Assert.Equal("Uninitialized", t1.Value); + + TypeWithValueMutatorPropertySetter t2 = configuration.GetSection("Configuration").Get()!; + Assert.Equal(1, t2.SomeSet.Count); + Assert.True(t2.SomeSet.Contains("path")); + Assert.Equal("Initialized", t2.Value); + } + [Fact] public void CanBindReadonlyRecordStructOptions() { @@ -2602,5 +2793,27 @@ public void CanBindToClassWithNewProperties() Assert.Equal(53, obj.X); Assert.Equal(53, obj.XBase); } + + [Fact] + public void CanGetEnumerableNotCollection() + { + var builder = new ConfigurationBuilder(); + builder.AddInMemoryCollection(new KeyValuePair[] + { + new("Names", "John,Jane,Stephen"), + new("Enabled", "true"), + new("Keywords:1", "new"), + new("Keywords:2", "class"), + new("Keywords:3", "rosebud") + }); + + var config = builder.Build(); + + var result = config.Get(); + + Assert.Equal("John,Jane,Stephen", result.Names); + Assert.True(result.Enabled); + Assert.Equal(new [] { "new", "class", "rosebud"}, result.Keywords); + } } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Bind.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Bind.generated.txt index 6b35d5b73af..d969a2ce0a9 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Bind.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Bind.generated.txt @@ -96,7 +96,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -143,7 +143,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value1) + if (configuration["MyInt"] is string value1 && !string.IsNullOrEmpty(value1)) { instance.MyInt = ParseInt(value1, configuration.GetSection("MyInt").Path); } @@ -159,6 +159,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section2, ref temp4, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp4; } + else + { + instance.MyList = instance.MyList; + } if (AsConfigWithChildren(configuration.GetSection("MyDictionary")) is IConfigurationSection section5) { @@ -167,6 +171,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section5, ref temp7, defaultValueIfNotFound: false, binderOptions); instance.MyDictionary = temp7; } + else + { + instance.MyDictionary = instance.MyDictionary; + } if (AsConfigWithChildren(configuration.GetSection("MyComplexDictionary")) is IConfigurationSection section8) { @@ -175,6 +183,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section8, ref temp10, defaultValueIfNotFound: false, binderOptions); instance.MyComplexDictionary = temp10; } + else + { + instance.MyComplexDictionary = instance.MyComplexDictionary; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Bind_Instance.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Bind_Instance.generated.txt index ed6db21e40a..243c0c75244 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Bind_Instance.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Bind_Instance.generated.txt @@ -60,7 +60,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -107,7 +107,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value1) + if (configuration["MyInt"] is string value1 && !string.IsNullOrEmpty(value1)) { instance.MyInt = ParseInt(value1, configuration.GetSection("MyInt").Path); } @@ -123,6 +123,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section2, ref temp4, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp4; } + else + { + instance.MyList = instance.MyList; + } if (AsConfigWithChildren(configuration.GetSection("MyDictionary")) is IConfigurationSection section5) { @@ -131,6 +135,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section5, ref temp7, defaultValueIfNotFound: false, binderOptions); instance.MyDictionary = temp7; } + else + { + instance.MyDictionary = instance.MyDictionary; + } if (AsConfigWithChildren(configuration.GetSection("MyComplexDictionary")) is IConfigurationSection section8) { @@ -139,6 +147,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section8, ref temp10, defaultValueIfNotFound: false, binderOptions); instance.MyComplexDictionary = temp10; } + else + { + instance.MyComplexDictionary = instance.MyComplexDictionary; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Bind_Instance_BinderOptions.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Bind_Instance_BinderOptions.generated.txt index c8abf9d79fb..52b29ac2896 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Bind_Instance_BinderOptions.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Bind_Instance_BinderOptions.generated.txt @@ -60,7 +60,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -107,7 +107,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value1) + if (configuration["MyInt"] is string value1 && !string.IsNullOrEmpty(value1)) { instance.MyInt = ParseInt(value1, configuration.GetSection("MyInt").Path); } @@ -123,6 +123,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section2, ref temp4, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp4; } + else + { + instance.MyList = instance.MyList; + } if (AsConfigWithChildren(configuration.GetSection("MyDictionary")) is IConfigurationSection section5) { @@ -131,6 +135,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section5, ref temp7, defaultValueIfNotFound: false, binderOptions); instance.MyDictionary = temp7; } + else + { + instance.MyDictionary = instance.MyDictionary; + } if (AsConfigWithChildren(configuration.GetSection("MyComplexDictionary")) is IConfigurationSection section8) { @@ -139,6 +147,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section8, ref temp10, defaultValueIfNotFound: false, binderOptions); instance.MyComplexDictionary = temp10; } + else + { + instance.MyComplexDictionary = instance.MyComplexDictionary; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Bind_Key_Instance.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Bind_Key_Instance.generated.txt index ee106169a27..aa3c6a9e943 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Bind_Key_Instance.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Bind_Key_Instance.generated.txt @@ -60,7 +60,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -107,7 +107,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value1) + if (configuration["MyInt"] is string value1 && !string.IsNullOrEmpty(value1)) { instance.MyInt = ParseInt(value1, configuration.GetSection("MyInt").Path); } @@ -123,6 +123,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section2, ref temp4, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp4; } + else + { + instance.MyList = instance.MyList; + } if (AsConfigWithChildren(configuration.GetSection("MyDictionary")) is IConfigurationSection section5) { @@ -131,6 +135,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section5, ref temp7, defaultValueIfNotFound: false, binderOptions); instance.MyDictionary = temp7; } + else + { + instance.MyDictionary = instance.MyDictionary; + } if (AsConfigWithChildren(configuration.GetSection("MyComplexDictionary")) is IConfigurationSection section8) { @@ -139,6 +147,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section8, ref temp10, defaultValueIfNotFound: false, binderOptions); instance.MyComplexDictionary = temp10; } + else + { + instance.MyComplexDictionary = instance.MyComplexDictionary; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Get.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Get.generated.txt index 61b94ba858c..68ddfa4c042 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Get.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Get.generated.txt @@ -89,7 +89,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -102,7 +102,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { temp2.Add(ParseInt(value, section.Path)); } @@ -141,7 +141,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value4) + if (configuration["MyInt"] is string value4 && !string.IsNullOrEmpty(value4)) { instance.MyInt = ParseInt(value4, configuration.GetSection("MyInt").Path); } @@ -157,6 +157,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section5, ref temp7, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp7; } + else + { + instance.MyList = instance.MyList; + } if (AsConfigWithChildren(configuration.GetSection("MyArray")) is IConfigurationSection section8) { @@ -165,6 +169,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section8, ref temp10, defaultValueIfNotFound: false, binderOptions); instance.MyArray = temp10; } + else + { + instance.MyArray = instance.MyArray; + } if (AsConfigWithChildren(configuration.GetSection("MyDictionary")) is IConfigurationSection section11) { @@ -173,13 +181,17 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section11, ref temp13, defaultValueIfNotFound: false, binderOptions); instance.MyDictionary = temp13; } + else + { + instance.MyDictionary = instance.MyDictionary; + } } public static void BindCore(IConfiguration configuration, ref global::Program.MyClass2 instance, bool defaultValueIfNotFound, BinderOptions? binderOptions) { ValidateConfigurationKeys(typeof(global::Program.MyClass2), s_configKeys_ProgramMyClass2, configuration, binderOptions); - if (configuration["MyInt"] is string value14) + if (configuration["MyInt"] is string value14 && !string.IsNullOrEmpty(value14)) { instance.MyInt = ParseInt(value14, configuration.GetSection("MyInt").Path); } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Get_PrimitivesOnly.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Get_PrimitivesOnly.generated.txt index 8ac6d07d29c..97cdab82512 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Get_PrimitivesOnly.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Get_PrimitivesOnly.generated.txt @@ -71,7 +71,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { throw new InvalidOperationException(); } - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { return ParseInt(value, section.Path); } @@ -90,7 +90,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { throw new InvalidOperationException(); } - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { return ParseFloat(value, section.Path); } @@ -101,7 +101,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { throw new InvalidOperationException(); } - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { return ParseDouble(value, section.Path); } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Get_T.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Get_T.generated.txt index 205783d6a98..1c7b92598f4 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Get_T.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Get_T.generated.txt @@ -70,7 +70,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -83,7 +83,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { temp1.Add(ParseInt(value, section.Path)); } @@ -122,7 +122,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value3) + if (configuration["MyInt"] is string value3 && !string.IsNullOrEmpty(value3)) { instance.MyInt = ParseInt(value3, configuration.GetSection("MyInt").Path); } @@ -138,6 +138,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section4, ref temp6, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp6; } + else + { + instance.MyList = instance.MyList; + } if (AsConfigWithChildren(configuration.GetSection("MyArray")) is IConfigurationSection section7) { @@ -146,6 +150,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section7, ref temp9, defaultValueIfNotFound: false, binderOptions); instance.MyArray = temp9; } + else + { + instance.MyArray = instance.MyArray; + } if (AsConfigWithChildren(configuration.GetSection("MyDictionary")) is IConfigurationSection section10) { @@ -154,6 +162,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section10, ref temp12, defaultValueIfNotFound: false, binderOptions); instance.MyDictionary = temp12; } + else + { + instance.MyDictionary = instance.MyDictionary; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Get_T_BinderOptions.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Get_T_BinderOptions.generated.txt index 8b4644d2b27..7598e236600 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Get_T_BinderOptions.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Get_T_BinderOptions.generated.txt @@ -70,7 +70,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -83,7 +83,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { temp1.Add(ParseInt(value, section.Path)); } @@ -122,7 +122,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value3) + if (configuration["MyInt"] is string value3 && !string.IsNullOrEmpty(value3)) { instance.MyInt = ParseInt(value3, configuration.GetSection("MyInt").Path); } @@ -138,6 +138,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section4, ref temp6, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp6; } + else + { + instance.MyList = instance.MyList; + } if (AsConfigWithChildren(configuration.GetSection("MyArray")) is IConfigurationSection section7) { @@ -146,6 +150,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section7, ref temp9, defaultValueIfNotFound: false, binderOptions); instance.MyArray = temp9; } + else + { + instance.MyArray = instance.MyArray; + } if (AsConfigWithChildren(configuration.GetSection("MyDictionary")) is IConfigurationSection section10) { @@ -154,6 +162,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section10, ref temp12, defaultValueIfNotFound: false, binderOptions); instance.MyDictionary = temp12; } + else + { + instance.MyDictionary = instance.MyDictionary; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Get_TypeOf.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Get_TypeOf.generated.txt index 09c568050ea..589f4b4fb10 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Get_TypeOf.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Get_TypeOf.generated.txt @@ -70,7 +70,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { ValidateConfigurationKeys(typeof(global::Program.MyClass2), s_configKeys_ProgramMyClass2, configuration, binderOptions); - if (configuration["MyInt"] is string value1) + if (configuration["MyInt"] is string value1 && !string.IsNullOrEmpty(value1)) { instance.MyInt = ParseInt(value1, configuration.GetSection("MyInt").Path); } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Get_TypeOf_BinderOptions.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Get_TypeOf_BinderOptions.generated.txt index 3d3c4340e97..53ee49e5ed1 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Get_TypeOf_BinderOptions.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ConfigurationBinder/Version1/Get_TypeOf_BinderOptions.generated.txt @@ -70,7 +70,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { ValidateConfigurationKeys(typeof(global::Program.MyClass2), s_configKeys_ProgramMyClass2, configuration, binderOptions); - if (configuration["MyInt"] is string value1) + if (configuration["MyInt"] is string value1 && !string.IsNullOrEmpty(value1)) { instance.MyInt = ParseInt(value1, configuration.GetSection("MyInt").Path); } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/OptionsBuilder/Version1/BindConfiguration.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/OptionsBuilder/Version1/BindConfiguration.generated.txt index 12dc3a77b0e..7981bfc8de6 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/OptionsBuilder/Version1/BindConfiguration.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/OptionsBuilder/Version1/BindConfiguration.generated.txt @@ -101,7 +101,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -125,7 +125,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value2) + if (configuration["MyInt"] is string value2 && !string.IsNullOrEmpty(value2)) { instance.MyInt = ParseInt(value2, configuration.GetSection("MyInt").Path); } @@ -141,6 +141,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section3, ref temp5, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp5; } + else + { + instance.MyList = instance.MyList; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/OptionsBuilder/Version1/BindConfigurationWithConfigureActions.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/OptionsBuilder/Version1/BindConfigurationWithConfigureActions.generated.txt index 103423d5b0b..7c89f54e229 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/OptionsBuilder/Version1/BindConfigurationWithConfigureActions.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/OptionsBuilder/Version1/BindConfigurationWithConfigureActions.generated.txt @@ -101,7 +101,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -125,7 +125,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value2) + if (configuration["MyInt"] is string value2 && !string.IsNullOrEmpty(value2)) { instance.MyInt = ParseInt(value2, configuration.GetSection("MyInt").Path); } @@ -141,6 +141,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section3, ref temp5, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp5; } + else + { + instance.MyList = instance.MyList; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/OptionsBuilder/Version1/Bind_T.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/OptionsBuilder/Version1/Bind_T.generated.txt index 4ca0ba31f4a..d76fb22d50b 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/OptionsBuilder/Version1/Bind_T.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/OptionsBuilder/Version1/Bind_T.generated.txt @@ -107,7 +107,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -131,7 +131,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value2) + if (configuration["MyInt"] is string value2 && !string.IsNullOrEmpty(value2)) { instance.MyInt = ParseInt(value2, configuration.GetSection("MyInt").Path); } @@ -147,6 +147,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section3, ref temp5, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp5; } + else + { + instance.MyList = instance.MyList; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/OptionsBuilder/Version1/Bind_T_BinderOptions.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/OptionsBuilder/Version1/Bind_T_BinderOptions.generated.txt index a8cc253765c..782feb78786 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/OptionsBuilder/Version1/Bind_T_BinderOptions.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/OptionsBuilder/Version1/Bind_T_BinderOptions.generated.txt @@ -101,7 +101,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -125,7 +125,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value2) + if (configuration["MyInt"] is string value2 && !string.IsNullOrEmpty(value2)) { instance.MyInt = ParseInt(value2, configuration.GetSection("MyInt").Path); } @@ -141,6 +141,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section3, ref temp5, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp5; } + else + { + instance.MyList = instance.MyList; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ServiceCollection/Version1/Configure_T.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ServiceCollection/Version1/Configure_T.generated.txt index 417f221d0aa..a15b599220a 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ServiceCollection/Version1/Configure_T.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ServiceCollection/Version1/Configure_T.generated.txt @@ -95,7 +95,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -106,7 +106,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { ValidateConfigurationKeys(typeof(global::Program.MyClass2), s_configKeys_ProgramMyClass2, configuration, binderOptions); - if (configuration["MyInt"] is string value1) + if (configuration["MyInt"] is string value1 && !string.IsNullOrEmpty(value1)) { instance.MyInt = ParseInt(value1, configuration.GetSection("MyInt").Path); } @@ -158,7 +158,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value4) + if (configuration["MyInt"] is string value4 && !string.IsNullOrEmpty(value4)) { instance.MyInt = ParseInt(value4, configuration.GetSection("MyInt").Path); } @@ -174,6 +174,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section5, ref temp7, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp7; } + else + { + instance.MyList = instance.MyList; + } if (AsConfigWithChildren(configuration.GetSection("MyList2")) is IConfigurationSection section8) { @@ -182,6 +186,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section8, ref temp10, defaultValueIfNotFound: false, binderOptions); instance.MyList2 = temp10; } + else + { + instance.MyList2 = instance.MyList2; + } if (AsConfigWithChildren(configuration.GetSection("MyDictionary")) is IConfigurationSection section11) { @@ -190,6 +198,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section11, ref temp13, defaultValueIfNotFound: false, binderOptions); instance.MyDictionary = temp13; } + else + { + instance.MyDictionary = instance.MyDictionary; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ServiceCollection/Version1/Configure_T_BinderOptions.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ServiceCollection/Version1/Configure_T_BinderOptions.generated.txt index 98580f73b91..3e65d96e3f4 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ServiceCollection/Version1/Configure_T_BinderOptions.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ServiceCollection/Version1/Configure_T_BinderOptions.generated.txt @@ -95,7 +95,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -106,7 +106,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { ValidateConfigurationKeys(typeof(global::Program.MyClass2), s_configKeys_ProgramMyClass2, configuration, binderOptions); - if (configuration["MyInt"] is string value1) + if (configuration["MyInt"] is string value1 && !string.IsNullOrEmpty(value1)) { instance.MyInt = ParseInt(value1, configuration.GetSection("MyInt").Path); } @@ -158,7 +158,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value4) + if (configuration["MyInt"] is string value4 && !string.IsNullOrEmpty(value4)) { instance.MyInt = ParseInt(value4, configuration.GetSection("MyInt").Path); } @@ -174,6 +174,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section5, ref temp7, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp7; } + else + { + instance.MyList = instance.MyList; + } if (AsConfigWithChildren(configuration.GetSection("MyList2")) is IConfigurationSection section8) { @@ -182,6 +186,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section8, ref temp10, defaultValueIfNotFound: false, binderOptions); instance.MyList2 = temp10; } + else + { + instance.MyList2 = instance.MyList2; + } if (AsConfigWithChildren(configuration.GetSection("MyDictionary")) is IConfigurationSection section11) { @@ -190,6 +198,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section11, ref temp13, defaultValueIfNotFound: false, binderOptions); instance.MyDictionary = temp13; } + else + { + instance.MyDictionary = instance.MyDictionary; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ServiceCollection/Version1/Configure_T_name.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ServiceCollection/Version1/Configure_T_name.generated.txt index 25d182f7ac1..af745624005 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ServiceCollection/Version1/Configure_T_name.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ServiceCollection/Version1/Configure_T_name.generated.txt @@ -95,7 +95,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -106,7 +106,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { ValidateConfigurationKeys(typeof(global::Program.MyClass2), s_configKeys_ProgramMyClass2, configuration, binderOptions); - if (configuration["MyInt"] is string value1) + if (configuration["MyInt"] is string value1 && !string.IsNullOrEmpty(value1)) { instance.MyInt = ParseInt(value1, configuration.GetSection("MyInt").Path); } @@ -158,7 +158,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value4) + if (configuration["MyInt"] is string value4 && !string.IsNullOrEmpty(value4)) { instance.MyInt = ParseInt(value4, configuration.GetSection("MyInt").Path); } @@ -174,6 +174,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section5, ref temp7, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp7; } + else + { + instance.MyList = instance.MyList; + } if (AsConfigWithChildren(configuration.GetSection("MyList2")) is IConfigurationSection section8) { @@ -182,6 +186,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section8, ref temp10, defaultValueIfNotFound: false, binderOptions); instance.MyList2 = temp10; } + else + { + instance.MyList2 = instance.MyList2; + } if (AsConfigWithChildren(configuration.GetSection("MyDictionary")) is IConfigurationSection section11) { @@ -190,6 +198,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section11, ref temp13, defaultValueIfNotFound: false, binderOptions); instance.MyDictionary = temp13; } + else + { + instance.MyDictionary = instance.MyDictionary; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ServiceCollection/Version1/Configure_T_name_BinderOptions.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ServiceCollection/Version1/Configure_T_name_BinderOptions.generated.txt index 7e4337e45c1..b5f3bd2069b 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ServiceCollection/Version1/Configure_T_name_BinderOptions.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/ServiceCollection/Version1/Configure_T_name_BinderOptions.generated.txt @@ -89,7 +89,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -100,7 +100,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { ValidateConfigurationKeys(typeof(global::Program.MyClass2), s_configKeys_ProgramMyClass2, configuration, binderOptions); - if (configuration["MyInt"] is string value1) + if (configuration["MyInt"] is string value1 && !string.IsNullOrEmpty(value1)) { instance.MyInt = ParseInt(value1, configuration.GetSection("MyInt").Path); } @@ -152,7 +152,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value4) + if (configuration["MyInt"] is string value4 && !string.IsNullOrEmpty(value4)) { instance.MyInt = ParseInt(value4, configuration.GetSection("MyInt").Path); } @@ -168,6 +168,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section5, ref temp7, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp7; } + else + { + instance.MyList = instance.MyList; + } if (AsConfigWithChildren(configuration.GetSection("MyList2")) is IConfigurationSection section8) { @@ -176,6 +180,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section8, ref temp10, defaultValueIfNotFound: false, binderOptions); instance.MyList2 = temp10; } + else + { + instance.MyList2 = instance.MyList2; + } if (AsConfigWithChildren(configuration.GetSection("MyDictionary")) is IConfigurationSection section11) { @@ -184,6 +192,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section11, ref temp13, defaultValueIfNotFound: false, binderOptions); instance.MyDictionary = temp13; } + else + { + instance.MyDictionary = instance.MyDictionary; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/Version1/Collections.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/Version1/Collections.generated.txt index c261c340aaf..3bb04809ead 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/Version1/Collections.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/Version1/Collections.generated.txt @@ -71,7 +71,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance[section.Key] = ParseInt(value, section.Path); } @@ -98,7 +98,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { temp.Add(ParseInt(value, section.Path)); } @@ -114,7 +114,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { temp[section.Key] = ParseInt(value, section.Path); } @@ -145,6 +145,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section1, ref temp3, defaultValueIfNotFound: false, binderOptions); instance.CustomDictionary = temp3; } + else + { + instance.CustomDictionary = instance.CustomDictionary; + } if (AsConfigWithChildren(configuration.GetSection("CustomList")) is IConfigurationSection section4) { @@ -153,6 +157,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section4, ref temp6, defaultValueIfNotFound: false, binderOptions); instance.CustomList = temp6; } + else + { + instance.CustomList = instance.CustomList; + } if (AsConfigWithChildren(configuration.GetSection("IReadOnlyList")) is IConfigurationSection section7) { @@ -161,6 +169,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section7, ref temp9, defaultValueIfNotFound: false, binderOptions); instance.IReadOnlyList = temp9; } + else + { + instance.IReadOnlyList = instance.IReadOnlyList; + } if (AsConfigWithChildren(configuration.GetSection("IReadOnlyDictionary")) is IConfigurationSection section10) { @@ -169,6 +181,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section10, ref temp12, defaultValueIfNotFound: false, binderOptions); instance.IReadOnlyDictionary = temp12; } + else + { + instance.IReadOnlyDictionary = instance.IReadOnlyDictionary; + } if (AsConfigWithChildren(configuration.GetSection("CollectionStructExplicit")) is IConfigurationSection section13) { @@ -178,6 +194,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.CollectionStructExplicit = temp15; temp14 = temp15; } + else + { + instance.CollectionStructExplicit = instance.CollectionStructExplicit; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/Version1/DefaultConstructorParameters.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/Version1/DefaultConstructorParameters.generated.txt index dbcadc11d17..bf84547cab0 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/Version1/DefaultConstructorParameters.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/Version1/DefaultConstructorParameters.generated.txt @@ -76,73 +76,73 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } int age = (int)(42); - if (configuration["Age"] is string value2) + if (configuration["Age"] is string value2 && !string.IsNullOrEmpty(value2)) { age = ParseInt(value2, configuration.GetSection("Age").Path); } float f = 42F; - if (configuration["F"] is string value3) + if (configuration["F"] is string value3 && !string.IsNullOrEmpty(value3)) { f = ParseFloat(value3, configuration.GetSection("F").Path); } double d = 3.1415899999999999D; - if (configuration["D"] is string value4) + if (configuration["D"] is string value4 && !string.IsNullOrEmpty(value4)) { d = ParseDouble(value4, configuration.GetSection("D").Path); } decimal m = 3.1415926535897932384626433M; - if (configuration["M"] is string value5) + if (configuration["M"] is string value5 && !string.IsNullOrEmpty(value5)) { m = ParseDecimal(value5, configuration.GetSection("M").Path); } global::System.StringComparison sc = (global::System.StringComparison)(4); - if (configuration["SC"] is string value6) + if (configuration["SC"] is string value6 && !string.IsNullOrEmpty(value6)) { sc = ParseEnum(value6, configuration.GetSection("SC").Path); } char c = 'q'; - if (configuration["C"] is string value7) + if (configuration["C"] is string value7 && !string.IsNullOrEmpty(value7)) { c = ParseChar(value7, configuration.GetSection("C").Path); } int? nage = (int?)(42); - if (configuration["NAge"] is string value8) + if (configuration["NAge"] is string value8 && !string.IsNullOrEmpty(value8)) { nage = ParseInt(value8, configuration.GetSection("NAge").Path); } float? nf = 42F; - if (configuration["NF"] is string value9) + if (configuration["NF"] is string value9 && !string.IsNullOrEmpty(value9)) { nf = ParseFloat(value9, configuration.GetSection("NF").Path); } double? nd = 3.1415899999999999D; - if (configuration["ND"] is string value10) + if (configuration["ND"] is string value10 && !string.IsNullOrEmpty(value10)) { nd = ParseDouble(value10, configuration.GetSection("ND").Path); } decimal? nm = 3.1415926535897932384626433M; - if (configuration["NM"] is string value11) + if (configuration["NM"] is string value11 && !string.IsNullOrEmpty(value11)) { nm = ParseDecimal(value11, configuration.GetSection("NM").Path); } global::System.StringComparison? nsc = (global::System.StringComparison?)(4); - if (configuration["NSC"] is string value12) + if (configuration["NSC"] is string value12 && !string.IsNullOrEmpty(value12)) { nsc = ParseEnum(value12, configuration.GetSection("NSC").Path); } char? nc = 'q'; - if (configuration["NC"] is string value13) + if (configuration["NC"] is string value13 && !string.IsNullOrEmpty(value13)) { nc = ParseChar(value13, configuration.GetSection("NC").Path); } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/Version1/Primitives.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/Version1/Primitives.generated.txt index 57e6403dc82..862e062c054 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/Version1/Primitives.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/Version1/Primitives.generated.txt @@ -60,7 +60,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { ValidateConfigurationKeys(typeof(global::Program.MyClass), s_configKeys_ProgramMyClass, configuration, binderOptions); - if (configuration["Prop0"] is string value0) + if (configuration["Prop0"] is string value0 && !string.IsNullOrEmpty(value0)) { instance.Prop0 = ParseBool(value0, configuration.GetSection("Prop0").Path); } @@ -69,7 +69,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop0 = instance.Prop0; } - if (configuration["Prop1"] is string value1) + if (configuration["Prop1"] is string value1 && !string.IsNullOrEmpty(value1)) { instance.Prop1 = ParseByte(value1, configuration.GetSection("Prop1").Path); } @@ -78,7 +78,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop1 = instance.Prop1; } - if (configuration["Prop2"] is string value2) + if (configuration["Prop2"] is string value2 && !string.IsNullOrEmpty(value2)) { instance.Prop2 = ParseSbyte(value2, configuration.GetSection("Prop2").Path); } @@ -87,7 +87,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop2 = instance.Prop2; } - if (configuration["Prop3"] is string value3) + if (configuration["Prop3"] is string value3 && !string.IsNullOrEmpty(value3)) { instance.Prop3 = ParseChar(value3, configuration.GetSection("Prop3").Path); } @@ -96,7 +96,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop3 = instance.Prop3; } - if (configuration["Prop4"] is string value4) + if (configuration["Prop4"] is string value4 && !string.IsNullOrEmpty(value4)) { instance.Prop4 = ParseDouble(value4, configuration.GetSection("Prop4").Path); } @@ -118,7 +118,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["Prop6"] is string value6) + if (configuration["Prop6"] is string value6 && !string.IsNullOrEmpty(value6)) { instance.Prop6 = ParseInt(value6, configuration.GetSection("Prop6").Path); } @@ -127,7 +127,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop6 = instance.Prop6; } - if (configuration["Prop8"] is string value7) + if (configuration["Prop8"] is string value7 && !string.IsNullOrEmpty(value7)) { instance.Prop8 = ParseShort(value7, configuration.GetSection("Prop8").Path); } @@ -136,7 +136,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop8 = instance.Prop8; } - if (configuration["Prop9"] is string value8) + if (configuration["Prop9"] is string value8 && !string.IsNullOrEmpty(value8)) { instance.Prop9 = ParseLong(value8, configuration.GetSection("Prop9").Path); } @@ -145,7 +145,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop9 = instance.Prop9; } - if (configuration["Prop10"] is string value9) + if (configuration["Prop10"] is string value9 && !string.IsNullOrEmpty(value9)) { instance.Prop10 = ParseFloat(value9, configuration.GetSection("Prop10").Path); } @@ -154,7 +154,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop10 = instance.Prop10; } - if (configuration["Prop13"] is string value10) + if (configuration["Prop13"] is string value10 && !string.IsNullOrEmpty(value10)) { instance.Prop13 = ParseUshort(value10, configuration.GetSection("Prop13").Path); } @@ -163,7 +163,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop13 = instance.Prop13; } - if (configuration["Prop14"] is string value11) + if (configuration["Prop14"] is string value11 && !string.IsNullOrEmpty(value11)) { instance.Prop14 = ParseUint(value11, configuration.GetSection("Prop14").Path); } @@ -172,7 +172,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop14 = instance.Prop14; } - if (configuration["Prop15"] is string value12) + if (configuration["Prop15"] is string value12 && !string.IsNullOrEmpty(value12)) { instance.Prop15 = ParseUlong(value12, configuration.GetSection("Prop15").Path); } @@ -194,7 +194,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["Prop17"] is string value14) + if (configuration["Prop17"] is string value14 && !string.IsNullOrEmpty(value14)) { instance.Prop17 = ParseSystemGlobalizationCultureInfo(value14, configuration.GetSection("Prop17").Path); } @@ -207,7 +207,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["Prop19"] is string value15) + if (configuration["Prop19"] is string value15 && !string.IsNullOrEmpty(value15)) { instance.Prop19 = ParseSystemDateTime(value15, configuration.GetSection("Prop19").Path); } @@ -216,7 +216,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop19 = instance.Prop19; } - if (configuration["Prop20"] is string value16) + if (configuration["Prop20"] is string value16 && !string.IsNullOrEmpty(value16)) { instance.Prop20 = ParseSystemDateTimeOffset(value16, configuration.GetSection("Prop20").Path); } @@ -225,7 +225,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop20 = instance.Prop20; } - if (configuration["Prop21"] is string value17) + if (configuration["Prop21"] is string value17 && !string.IsNullOrEmpty(value17)) { instance.Prop21 = ParseDecimal(value17, configuration.GetSection("Prop21").Path); } @@ -234,7 +234,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop21 = instance.Prop21; } - if (configuration["Prop23"] is string value18) + if (configuration["Prop23"] is string value18 && !string.IsNullOrEmpty(value18)) { instance.Prop23 = ParseSystemTimeSpan(value18, configuration.GetSection("Prop23").Path); } @@ -243,7 +243,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop23 = instance.Prop23; } - if (configuration["Prop24"] is string value19) + if (configuration["Prop24"] is string value19 && !string.IsNullOrEmpty(value19)) { instance.Prop24 = ParseSystemGuid(value19, configuration.GetSection("Prop24").Path); } @@ -252,7 +252,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop24 = instance.Prop24; } - if (configuration["Prop25"] is string value20) + if (configuration["Prop25"] is string value20 && !string.IsNullOrEmpty(value20)) { instance.Prop25 = ParseSystemUri(value20, configuration.GetSection("Prop25").Path); } @@ -265,7 +265,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["Prop26"] is string value21) + if (configuration["Prop26"] is string value21 && !string.IsNullOrEmpty(value21)) { instance.Prop26 = ParseSystemVersion(value21, configuration.GetSection("Prop26").Path); } @@ -278,7 +278,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["Prop27"] is string value22) + if (configuration["Prop27"] is string value22 && !string.IsNullOrEmpty(value22)) { instance.Prop27 = ParseEnum(value22, configuration.GetSection("Prop27").Path); } @@ -287,7 +287,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop27 = instance.Prop27; } - if (configuration["Prop28"] is string value23) + if (configuration["Prop28"] is string value23 && !string.IsNullOrEmpty(value23)) { instance.Prop28 = ParseByteArray(value23, configuration.GetSection("Prop28").Path); } @@ -300,7 +300,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["Prop29"] is string value24) + if (configuration["Prop29"] is string value24 && !string.IsNullOrEmpty(value24)) { instance.Prop29 = ParseInt(value24, configuration.GetSection("Prop29").Path); } @@ -309,7 +309,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop29 = instance.Prop29; } - if (configuration["Prop30"] is string value25) + if (configuration["Prop30"] is string value25 && !string.IsNullOrEmpty(value25)) { instance.Prop30 = ParseSystemDateTime(value25, configuration.GetSection("Prop30").Path); } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/Version1/UnsupportedTypes.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/Version1/UnsupportedTypes.generated.txt index 9f784cc0193..6b9ae8a88e9 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/Version1/UnsupportedTypes.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/net462/Version1/UnsupportedTypes.generated.txt @@ -143,7 +143,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["Age"] is string value3) + if (configuration["Age"] is string value3 && !string.IsNullOrEmpty(value3)) { instance.Age = ParseInt(value3, configuration.GetSection("Age").Path); } @@ -159,6 +159,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section4, ref temp6, defaultValueIfNotFound: false, binderOptions); instance.List = temp6; } + else + { + instance.List = instance.List; + } if (AsConfigWithChildren(configuration.GetSection("Array")) is IConfigurationSection section7) { @@ -167,6 +171,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section7, ref temp9, defaultValueIfNotFound: false, binderOptions); instance.Array = temp9; } + else + { + instance.Array = instance.Array; + } if (AsConfigWithChildren(configuration.GetSection("Record")) is IConfigurationSection section10) { @@ -175,12 +183,16 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section10, ref temp12, defaultValueIfNotFound: false, binderOptions); instance.Record = temp12; } + else + { + instance.Record = instance.Record; + } } public static global::Record InitializeRecordAction(IConfiguration configuration, BinderOptions? binderOptions) { int x = (int)(10); - if (configuration["x"] is string value13) + if (configuration["x"] is string value13 && !string.IsNullOrEmpty(value13)) { x = ParseInt(value13, configuration.GetSection("x").Path); } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Bind.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Bind.generated.txt index baca17797df..499cd068953 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Bind.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Bind.generated.txt @@ -87,7 +87,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -134,7 +134,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value1) + if (configuration["MyInt"] is string value1 && !string.IsNullOrEmpty(value1)) { instance.MyInt = ParseInt(value1, configuration.GetSection("MyInt").Path); } @@ -150,6 +150,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section2, ref temp4, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp4; } + else + { + instance.MyList = instance.MyList; + } if (AsConfigWithChildren(configuration.GetSection("MyDictionary")) is IConfigurationSection section5) { @@ -158,6 +162,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section5, ref temp7, defaultValueIfNotFound: false, binderOptions); instance.MyDictionary = temp7; } + else + { + instance.MyDictionary = instance.MyDictionary; + } if (AsConfigWithChildren(configuration.GetSection("MyComplexDictionary")) is IConfigurationSection section8) { @@ -166,6 +174,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section8, ref temp10, defaultValueIfNotFound: false, binderOptions); instance.MyComplexDictionary = temp10; } + else + { + instance.MyComplexDictionary = instance.MyComplexDictionary; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Bind_Instance.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Bind_Instance.generated.txt index 55fc88c6e54..43edcd50559 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Bind_Instance.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Bind_Instance.generated.txt @@ -57,7 +57,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -104,7 +104,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value1) + if (configuration["MyInt"] is string value1 && !string.IsNullOrEmpty(value1)) { instance.MyInt = ParseInt(value1, configuration.GetSection("MyInt").Path); } @@ -120,6 +120,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section2, ref temp4, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp4; } + else + { + instance.MyList = instance.MyList; + } if (AsConfigWithChildren(configuration.GetSection("MyDictionary")) is IConfigurationSection section5) { @@ -128,6 +132,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section5, ref temp7, defaultValueIfNotFound: false, binderOptions); instance.MyDictionary = temp7; } + else + { + instance.MyDictionary = instance.MyDictionary; + } if (AsConfigWithChildren(configuration.GetSection("MyComplexDictionary")) is IConfigurationSection section8) { @@ -136,6 +144,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section8, ref temp10, defaultValueIfNotFound: false, binderOptions); instance.MyComplexDictionary = temp10; } + else + { + instance.MyComplexDictionary = instance.MyComplexDictionary; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Bind_Instance_BinderOptions.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Bind_Instance_BinderOptions.generated.txt index a1c971d891e..b6e930a7f3e 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Bind_Instance_BinderOptions.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Bind_Instance_BinderOptions.generated.txt @@ -57,7 +57,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -104,7 +104,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value1) + if (configuration["MyInt"] is string value1 && !string.IsNullOrEmpty(value1)) { instance.MyInt = ParseInt(value1, configuration.GetSection("MyInt").Path); } @@ -120,6 +120,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section2, ref temp4, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp4; } + else + { + instance.MyList = instance.MyList; + } if (AsConfigWithChildren(configuration.GetSection("MyDictionary")) is IConfigurationSection section5) { @@ -128,6 +132,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section5, ref temp7, defaultValueIfNotFound: false, binderOptions); instance.MyDictionary = temp7; } + else + { + instance.MyDictionary = instance.MyDictionary; + } if (AsConfigWithChildren(configuration.GetSection("MyComplexDictionary")) is IConfigurationSection section8) { @@ -136,6 +144,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section8, ref temp10, defaultValueIfNotFound: false, binderOptions); instance.MyComplexDictionary = temp10; } + else + { + instance.MyComplexDictionary = instance.MyComplexDictionary; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Bind_Key_Instance.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Bind_Key_Instance.generated.txt index b3aa0044f92..471dd1aeded 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Bind_Key_Instance.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Bind_Key_Instance.generated.txt @@ -57,7 +57,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -104,7 +104,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value1) + if (configuration["MyInt"] is string value1 && !string.IsNullOrEmpty(value1)) { instance.MyInt = ParseInt(value1, configuration.GetSection("MyInt").Path); } @@ -120,6 +120,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section2, ref temp4, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp4; } + else + { + instance.MyList = instance.MyList; + } if (AsConfigWithChildren(configuration.GetSection("MyDictionary")) is IConfigurationSection section5) { @@ -128,6 +132,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section5, ref temp7, defaultValueIfNotFound: false, binderOptions); instance.MyDictionary = temp7; } + else + { + instance.MyDictionary = instance.MyDictionary; + } if (AsConfigWithChildren(configuration.GetSection("MyComplexDictionary")) is IConfigurationSection section8) { @@ -136,6 +144,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section8, ref temp10, defaultValueIfNotFound: false, binderOptions); instance.MyComplexDictionary = temp10; } + else + { + instance.MyComplexDictionary = instance.MyComplexDictionary; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Get.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Get.generated.txt index 25f336d16d2..cf7bf6a8fbf 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Get.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Get.generated.txt @@ -86,7 +86,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -99,7 +99,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { temp2.Add(ParseInt(value, section.Path)); } @@ -138,7 +138,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value4) + if (configuration["MyInt"] is string value4 && !string.IsNullOrEmpty(value4)) { instance.MyInt = ParseInt(value4, configuration.GetSection("MyInt").Path); } @@ -154,6 +154,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section5, ref temp7, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp7; } + else + { + instance.MyList = instance.MyList; + } if (AsConfigWithChildren(configuration.GetSection("MyArray")) is IConfigurationSection section8) { @@ -162,6 +166,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section8, ref temp10, defaultValueIfNotFound: false, binderOptions); instance.MyArray = temp10; } + else + { + instance.MyArray = instance.MyArray; + } if (AsConfigWithChildren(configuration.GetSection("MyDictionary")) is IConfigurationSection section11) { @@ -170,13 +178,17 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section11, ref temp13, defaultValueIfNotFound: false, binderOptions); instance.MyDictionary = temp13; } + else + { + instance.MyDictionary = instance.MyDictionary; + } } public static void BindCore(IConfiguration configuration, ref global::Program.MyClass2 instance, bool defaultValueIfNotFound, BinderOptions? binderOptions) { ValidateConfigurationKeys(typeof(global::Program.MyClass2), s_configKeys_ProgramMyClass2, configuration, binderOptions); - if (configuration["MyInt"] is string value14) + if (configuration["MyInt"] is string value14 && !string.IsNullOrEmpty(value14)) { instance.MyInt = ParseInt(value14, configuration.GetSection("MyInt").Path); } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Get_PrimitivesOnly.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Get_PrimitivesOnly.generated.txt index 7ce53871d7d..9b1bc5e1ea5 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Get_PrimitivesOnly.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Get_PrimitivesOnly.generated.txt @@ -68,7 +68,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { throw new InvalidOperationException(); } - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { return ParseInt(value, section.Path); } @@ -87,7 +87,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { throw new InvalidOperationException(); } - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { return ParseFloat(value, section.Path); } @@ -98,7 +98,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { throw new InvalidOperationException(); } - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { return ParseDouble(value, section.Path); } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Get_T.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Get_T.generated.txt index ae367c81fd0..a1fa448fd76 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Get_T.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Get_T.generated.txt @@ -67,7 +67,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -80,7 +80,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { temp1.Add(ParseInt(value, section.Path)); } @@ -119,7 +119,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value3) + if (configuration["MyInt"] is string value3 && !string.IsNullOrEmpty(value3)) { instance.MyInt = ParseInt(value3, configuration.GetSection("MyInt").Path); } @@ -135,6 +135,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section4, ref temp6, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp6; } + else + { + instance.MyList = instance.MyList; + } if (AsConfigWithChildren(configuration.GetSection("MyArray")) is IConfigurationSection section7) { @@ -143,6 +147,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section7, ref temp9, defaultValueIfNotFound: false, binderOptions); instance.MyArray = temp9; } + else + { + instance.MyArray = instance.MyArray; + } if (AsConfigWithChildren(configuration.GetSection("MyDictionary")) is IConfigurationSection section10) { @@ -151,6 +159,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section10, ref temp12, defaultValueIfNotFound: false, binderOptions); instance.MyDictionary = temp12; } + else + { + instance.MyDictionary = instance.MyDictionary; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Get_T_BinderOptions.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Get_T_BinderOptions.generated.txt index 938d15f5734..8224f0967d1 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Get_T_BinderOptions.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Get_T_BinderOptions.generated.txt @@ -67,7 +67,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -80,7 +80,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { temp1.Add(ParseInt(value, section.Path)); } @@ -119,7 +119,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value3) + if (configuration["MyInt"] is string value3 && !string.IsNullOrEmpty(value3)) { instance.MyInt = ParseInt(value3, configuration.GetSection("MyInt").Path); } @@ -135,6 +135,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section4, ref temp6, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp6; } + else + { + instance.MyList = instance.MyList; + } if (AsConfigWithChildren(configuration.GetSection("MyArray")) is IConfigurationSection section7) { @@ -143,6 +147,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section7, ref temp9, defaultValueIfNotFound: false, binderOptions); instance.MyArray = temp9; } + else + { + instance.MyArray = instance.MyArray; + } if (AsConfigWithChildren(configuration.GetSection("MyDictionary")) is IConfigurationSection section10) { @@ -151,6 +159,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section10, ref temp12, defaultValueIfNotFound: false, binderOptions); instance.MyDictionary = temp12; } + else + { + instance.MyDictionary = instance.MyDictionary; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Get_TypeOf.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Get_TypeOf.generated.txt index 096d659c117..4ed9fffb984 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Get_TypeOf.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Get_TypeOf.generated.txt @@ -67,7 +67,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { ValidateConfigurationKeys(typeof(global::Program.MyClass2), s_configKeys_ProgramMyClass2, configuration, binderOptions); - if (configuration["MyInt"] is string value1) + if (configuration["MyInt"] is string value1 && !string.IsNullOrEmpty(value1)) { instance.MyInt = ParseInt(value1, configuration.GetSection("MyInt").Path); } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Get_TypeOf_BinderOptions.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Get_TypeOf_BinderOptions.generated.txt index 2d338610619..5a576795bfd 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Get_TypeOf_BinderOptions.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ConfigurationBinder/Version1/Get_TypeOf_BinderOptions.generated.txt @@ -67,7 +67,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { ValidateConfigurationKeys(typeof(global::Program.MyClass2), s_configKeys_ProgramMyClass2, configuration, binderOptions); - if (configuration["MyInt"] is string value1) + if (configuration["MyInt"] is string value1 && !string.IsNullOrEmpty(value1)) { instance.MyInt = ParseInt(value1, configuration.GetSection("MyInt").Path); } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/OptionsBuilder/Version1/BindConfiguration.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/OptionsBuilder/Version1/BindConfiguration.generated.txt index 3bf1c7fffb3..70ca8bf3f05 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/OptionsBuilder/Version1/BindConfiguration.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/OptionsBuilder/Version1/BindConfiguration.generated.txt @@ -92,7 +92,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -116,7 +116,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value2) + if (configuration["MyInt"] is string value2 && !string.IsNullOrEmpty(value2)) { instance.MyInt = ParseInt(value2, configuration.GetSection("MyInt").Path); } @@ -132,6 +132,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section3, ref temp5, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp5; } + else + { + instance.MyList = instance.MyList; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/OptionsBuilder/Version1/BindConfigurationWithConfigureActions.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/OptionsBuilder/Version1/BindConfigurationWithConfigureActions.generated.txt index 68fd25284f9..52d92bd33df 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/OptionsBuilder/Version1/BindConfigurationWithConfigureActions.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/OptionsBuilder/Version1/BindConfigurationWithConfigureActions.generated.txt @@ -92,7 +92,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -116,7 +116,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value2) + if (configuration["MyInt"] is string value2 && !string.IsNullOrEmpty(value2)) { instance.MyInt = ParseInt(value2, configuration.GetSection("MyInt").Path); } @@ -132,6 +132,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section3, ref temp5, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp5; } + else + { + instance.MyList = instance.MyList; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/OptionsBuilder/Version1/Bind_T.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/OptionsBuilder/Version1/Bind_T.generated.txt index 79b3242d6bd..8479f9c6672 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/OptionsBuilder/Version1/Bind_T.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/OptionsBuilder/Version1/Bind_T.generated.txt @@ -98,7 +98,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -122,7 +122,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value2) + if (configuration["MyInt"] is string value2 && !string.IsNullOrEmpty(value2)) { instance.MyInt = ParseInt(value2, configuration.GetSection("MyInt").Path); } @@ -138,6 +138,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section3, ref temp5, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp5; } + else + { + instance.MyList = instance.MyList; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/OptionsBuilder/Version1/Bind_T_BinderOptions.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/OptionsBuilder/Version1/Bind_T_BinderOptions.generated.txt index 8451a807165..6b7825d2ca8 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/OptionsBuilder/Version1/Bind_T_BinderOptions.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/OptionsBuilder/Version1/Bind_T_BinderOptions.generated.txt @@ -92,7 +92,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -116,7 +116,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value2) + if (configuration["MyInt"] is string value2 && !string.IsNullOrEmpty(value2)) { instance.MyInt = ParseInt(value2, configuration.GetSection("MyInt").Path); } @@ -132,6 +132,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section3, ref temp5, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp5; } + else + { + instance.MyList = instance.MyList; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ServiceCollection/Version1/Configure_T.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ServiceCollection/Version1/Configure_T.generated.txt index 4acfc2c04b2..2c322e75c16 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ServiceCollection/Version1/Configure_T.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ServiceCollection/Version1/Configure_T.generated.txt @@ -89,7 +89,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -100,7 +100,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { ValidateConfigurationKeys(typeof(global::Program.MyClass2), s_configKeys_ProgramMyClass2, configuration, binderOptions); - if (configuration["MyInt"] is string value1) + if (configuration["MyInt"] is string value1 && !string.IsNullOrEmpty(value1)) { instance.MyInt = ParseInt(value1, configuration.GetSection("MyInt").Path); } @@ -152,7 +152,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value4) + if (configuration["MyInt"] is string value4 && !string.IsNullOrEmpty(value4)) { instance.MyInt = ParseInt(value4, configuration.GetSection("MyInt").Path); } @@ -168,6 +168,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section5, ref temp7, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp7; } + else + { + instance.MyList = instance.MyList; + } if (AsConfigWithChildren(configuration.GetSection("MyList2")) is IConfigurationSection section8) { @@ -176,6 +180,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section8, ref temp10, defaultValueIfNotFound: false, binderOptions); instance.MyList2 = temp10; } + else + { + instance.MyList2 = instance.MyList2; + } if (AsConfigWithChildren(configuration.GetSection("MyDictionary")) is IConfigurationSection section11) { @@ -184,6 +192,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section11, ref temp13, defaultValueIfNotFound: false, binderOptions); instance.MyDictionary = temp13; } + else + { + instance.MyDictionary = instance.MyDictionary; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ServiceCollection/Version1/Configure_T_BinderOptions.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ServiceCollection/Version1/Configure_T_BinderOptions.generated.txt index 99c67141401..d9d27cdee4c 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ServiceCollection/Version1/Configure_T_BinderOptions.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ServiceCollection/Version1/Configure_T_BinderOptions.generated.txt @@ -89,7 +89,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -100,7 +100,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { ValidateConfigurationKeys(typeof(global::Program.MyClass2), s_configKeys_ProgramMyClass2, configuration, binderOptions); - if (configuration["MyInt"] is string value1) + if (configuration["MyInt"] is string value1 && !string.IsNullOrEmpty(value1)) { instance.MyInt = ParseInt(value1, configuration.GetSection("MyInt").Path); } @@ -152,7 +152,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value4) + if (configuration["MyInt"] is string value4 && !string.IsNullOrEmpty(value4)) { instance.MyInt = ParseInt(value4, configuration.GetSection("MyInt").Path); } @@ -168,6 +168,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section5, ref temp7, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp7; } + else + { + instance.MyList = instance.MyList; + } if (AsConfigWithChildren(configuration.GetSection("MyList2")) is IConfigurationSection section8) { @@ -176,6 +180,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section8, ref temp10, defaultValueIfNotFound: false, binderOptions); instance.MyList2 = temp10; } + else + { + instance.MyList2 = instance.MyList2; + } if (AsConfigWithChildren(configuration.GetSection("MyDictionary")) is IConfigurationSection section11) { @@ -184,6 +192,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section11, ref temp13, defaultValueIfNotFound: false, binderOptions); instance.MyDictionary = temp13; } + else + { + instance.MyDictionary = instance.MyDictionary; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ServiceCollection/Version1/Configure_T_name.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ServiceCollection/Version1/Configure_T_name.generated.txt index 07fa717a301..68019fb6069 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ServiceCollection/Version1/Configure_T_name.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ServiceCollection/Version1/Configure_T_name.generated.txt @@ -89,7 +89,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -100,7 +100,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { ValidateConfigurationKeys(typeof(global::Program.MyClass2), s_configKeys_ProgramMyClass2, configuration, binderOptions); - if (configuration["MyInt"] is string value1) + if (configuration["MyInt"] is string value1 && !string.IsNullOrEmpty(value1)) { instance.MyInt = ParseInt(value1, configuration.GetSection("MyInt").Path); } @@ -152,7 +152,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value4) + if (configuration["MyInt"] is string value4 && !string.IsNullOrEmpty(value4)) { instance.MyInt = ParseInt(value4, configuration.GetSection("MyInt").Path); } @@ -168,6 +168,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section5, ref temp7, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp7; } + else + { + instance.MyList = instance.MyList; + } if (AsConfigWithChildren(configuration.GetSection("MyList2")) is IConfigurationSection section8) { @@ -176,6 +180,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section8, ref temp10, defaultValueIfNotFound: false, binderOptions); instance.MyList2 = temp10; } + else + { + instance.MyList2 = instance.MyList2; + } if (AsConfigWithChildren(configuration.GetSection("MyDictionary")) is IConfigurationSection section11) { @@ -184,6 +192,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section11, ref temp13, defaultValueIfNotFound: false, binderOptions); instance.MyDictionary = temp13; } + else + { + instance.MyDictionary = instance.MyDictionary; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ServiceCollection/Version1/Configure_T_name_BinderOptions.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ServiceCollection/Version1/Configure_T_name_BinderOptions.generated.txt index 20a36e76d99..80ad0e0943f 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ServiceCollection/Version1/Configure_T_name_BinderOptions.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/ServiceCollection/Version1/Configure_T_name_BinderOptions.generated.txt @@ -83,7 +83,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance.Add(ParseInt(value, section.Path)); } @@ -94,7 +94,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { ValidateConfigurationKeys(typeof(global::Program.MyClass2), s_configKeys_ProgramMyClass2, configuration, binderOptions); - if (configuration["MyInt"] is string value1) + if (configuration["MyInt"] is string value1 && !string.IsNullOrEmpty(value1)) { instance.MyInt = ParseInt(value1, configuration.GetSection("MyInt").Path); } @@ -146,7 +146,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["MyInt"] is string value4) + if (configuration["MyInt"] is string value4 && !string.IsNullOrEmpty(value4)) { instance.MyInt = ParseInt(value4, configuration.GetSection("MyInt").Path); } @@ -162,6 +162,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section5, ref temp7, defaultValueIfNotFound: false, binderOptions); instance.MyList = temp7; } + else + { + instance.MyList = instance.MyList; + } if (AsConfigWithChildren(configuration.GetSection("MyList2")) is IConfigurationSection section8) { @@ -170,6 +174,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section8, ref temp10, defaultValueIfNotFound: false, binderOptions); instance.MyList2 = temp10; } + else + { + instance.MyList2 = instance.MyList2; + } if (AsConfigWithChildren(configuration.GetSection("MyDictionary")) is IConfigurationSection section11) { @@ -178,6 +186,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section11, ref temp13, defaultValueIfNotFound: false, binderOptions); instance.MyDictionary = temp13; } + else + { + instance.MyDictionary = instance.MyDictionary; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/Version1/Collections.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/Version1/Collections.generated.txt index 8c25f92341e..2d0e1f3207e 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/Version1/Collections.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/Version1/Collections.generated.txt @@ -68,7 +68,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { instance[section.Key] = ParseInt(value, section.Path); } @@ -95,7 +95,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { temp.Add(ParseInt(value, section.Path)); } @@ -111,7 +111,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration foreach (IConfigurationSection section in configuration.GetChildren()) { - if (section.Value is string value) + if (section.Value is string value && !string.IsNullOrEmpty(value)) { temp[section.Key] = ParseInt(value, section.Path); } @@ -142,6 +142,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section1, ref temp3, defaultValueIfNotFound: false, binderOptions); instance.CustomDictionary = temp3; } + else + { + instance.CustomDictionary = instance.CustomDictionary; + } if (AsConfigWithChildren(configuration.GetSection("CustomList")) is IConfigurationSection section4) { @@ -150,6 +154,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section4, ref temp6, defaultValueIfNotFound: false, binderOptions); instance.CustomList = temp6; } + else + { + instance.CustomList = instance.CustomList; + } if (AsConfigWithChildren(configuration.GetSection("IReadOnlyList")) is IConfigurationSection section7) { @@ -158,6 +166,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section7, ref temp9, defaultValueIfNotFound: false, binderOptions); instance.IReadOnlyList = temp9; } + else + { + instance.IReadOnlyList = instance.IReadOnlyList; + } if (AsConfigWithChildren(configuration.GetSection("IReadOnlyDictionary")) is IConfigurationSection section10) { @@ -166,6 +178,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section10, ref temp12, defaultValueIfNotFound: false, binderOptions); instance.IReadOnlyDictionary = temp12; } + else + { + instance.IReadOnlyDictionary = instance.IReadOnlyDictionary; + } if (AsConfigWithChildren(configuration.GetSection("CollectionStructExplicit")) is IConfigurationSection section13) { @@ -175,6 +191,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.CollectionStructExplicit = temp15; temp14 = temp15; } + else + { + instance.CollectionStructExplicit = instance.CollectionStructExplicit; + } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/Version1/DefaultConstructorParameters.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/Version1/DefaultConstructorParameters.generated.txt index 57fabba9d1f..f726e225426 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/Version1/DefaultConstructorParameters.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/Version1/DefaultConstructorParameters.generated.txt @@ -73,73 +73,73 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } int age = (int)(42); - if (configuration["Age"] is string value2) + if (configuration["Age"] is string value2 && !string.IsNullOrEmpty(value2)) { age = ParseInt(value2, configuration.GetSection("Age").Path); } float f = 42F; - if (configuration["F"] is string value3) + if (configuration["F"] is string value3 && !string.IsNullOrEmpty(value3)) { f = ParseFloat(value3, configuration.GetSection("F").Path); } double d = 3.1415899999999999D; - if (configuration["D"] is string value4) + if (configuration["D"] is string value4 && !string.IsNullOrEmpty(value4)) { d = ParseDouble(value4, configuration.GetSection("D").Path); } decimal m = 3.1415926535897932384626433M; - if (configuration["M"] is string value5) + if (configuration["M"] is string value5 && !string.IsNullOrEmpty(value5)) { m = ParseDecimal(value5, configuration.GetSection("M").Path); } global::System.StringComparison sc = (global::System.StringComparison)(4); - if (configuration["SC"] is string value6) + if (configuration["SC"] is string value6 && !string.IsNullOrEmpty(value6)) { sc = ParseEnum(value6, configuration.GetSection("SC").Path); } char c = 'q'; - if (configuration["C"] is string value7) + if (configuration["C"] is string value7 && !string.IsNullOrEmpty(value7)) { c = ParseChar(value7, configuration.GetSection("C").Path); } int? nage = (int?)(42); - if (configuration["NAge"] is string value8) + if (configuration["NAge"] is string value8 && !string.IsNullOrEmpty(value8)) { nage = ParseInt(value8, configuration.GetSection("NAge").Path); } float? nf = 42F; - if (configuration["NF"] is string value9) + if (configuration["NF"] is string value9 && !string.IsNullOrEmpty(value9)) { nf = ParseFloat(value9, configuration.GetSection("NF").Path); } double? nd = 3.1415899999999999D; - if (configuration["ND"] is string value10) + if (configuration["ND"] is string value10 && !string.IsNullOrEmpty(value10)) { nd = ParseDouble(value10, configuration.GetSection("ND").Path); } decimal? nm = 3.1415926535897932384626433M; - if (configuration["NM"] is string value11) + if (configuration["NM"] is string value11 && !string.IsNullOrEmpty(value11)) { nm = ParseDecimal(value11, configuration.GetSection("NM").Path); } global::System.StringComparison? nsc = (global::System.StringComparison?)(4); - if (configuration["NSC"] is string value12) + if (configuration["NSC"] is string value12 && !string.IsNullOrEmpty(value12)) { nsc = ParseEnum(value12, configuration.GetSection("NSC").Path); } char? nc = 'q'; - if (configuration["NC"] is string value13) + if (configuration["NC"] is string value13 && !string.IsNullOrEmpty(value13)) { nc = ParseChar(value13, configuration.GetSection("NC").Path); } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/Version1/Primitives.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/Version1/Primitives.generated.txt index 7e442555da5..92787bd1909 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/Version1/Primitives.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/Version1/Primitives.generated.txt @@ -57,7 +57,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration { ValidateConfigurationKeys(typeof(global::Program.MyClass), s_configKeys_ProgramMyClass, configuration, binderOptions); - if (configuration["Prop0"] is string value0) + if (configuration["Prop0"] is string value0 && !string.IsNullOrEmpty(value0)) { instance.Prop0 = ParseBool(value0, configuration.GetSection("Prop0").Path); } @@ -66,7 +66,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop0 = instance.Prop0; } - if (configuration["Prop1"] is string value1) + if (configuration["Prop1"] is string value1 && !string.IsNullOrEmpty(value1)) { instance.Prop1 = ParseByte(value1, configuration.GetSection("Prop1").Path); } @@ -75,7 +75,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop1 = instance.Prop1; } - if (configuration["Prop2"] is string value2) + if (configuration["Prop2"] is string value2 && !string.IsNullOrEmpty(value2)) { instance.Prop2 = ParseSbyte(value2, configuration.GetSection("Prop2").Path); } @@ -84,7 +84,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop2 = instance.Prop2; } - if (configuration["Prop3"] is string value3) + if (configuration["Prop3"] is string value3 && !string.IsNullOrEmpty(value3)) { instance.Prop3 = ParseChar(value3, configuration.GetSection("Prop3").Path); } @@ -93,7 +93,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop3 = instance.Prop3; } - if (configuration["Prop4"] is string value4) + if (configuration["Prop4"] is string value4 && !string.IsNullOrEmpty(value4)) { instance.Prop4 = ParseDouble(value4, configuration.GetSection("Prop4").Path); } @@ -115,7 +115,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["Prop6"] is string value6) + if (configuration["Prop6"] is string value6 && !string.IsNullOrEmpty(value6)) { instance.Prop6 = ParseInt(value6, configuration.GetSection("Prop6").Path); } @@ -124,7 +124,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop6 = instance.Prop6; } - if (configuration["Prop8"] is string value7) + if (configuration["Prop8"] is string value7 && !string.IsNullOrEmpty(value7)) { instance.Prop8 = ParseShort(value7, configuration.GetSection("Prop8").Path); } @@ -133,7 +133,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop8 = instance.Prop8; } - if (configuration["Prop9"] is string value8) + if (configuration["Prop9"] is string value8 && !string.IsNullOrEmpty(value8)) { instance.Prop9 = ParseLong(value8, configuration.GetSection("Prop9").Path); } @@ -142,7 +142,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop9 = instance.Prop9; } - if (configuration["Prop10"] is string value9) + if (configuration["Prop10"] is string value9 && !string.IsNullOrEmpty(value9)) { instance.Prop10 = ParseFloat(value9, configuration.GetSection("Prop10").Path); } @@ -151,7 +151,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop10 = instance.Prop10; } - if (configuration["Prop13"] is string value10) + if (configuration["Prop13"] is string value10 && !string.IsNullOrEmpty(value10)) { instance.Prop13 = ParseUshort(value10, configuration.GetSection("Prop13").Path); } @@ -160,7 +160,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop13 = instance.Prop13; } - if (configuration["Prop14"] is string value11) + if (configuration["Prop14"] is string value11 && !string.IsNullOrEmpty(value11)) { instance.Prop14 = ParseUint(value11, configuration.GetSection("Prop14").Path); } @@ -169,7 +169,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop14 = instance.Prop14; } - if (configuration["Prop15"] is string value12) + if (configuration["Prop15"] is string value12 && !string.IsNullOrEmpty(value12)) { instance.Prop15 = ParseUlong(value12, configuration.GetSection("Prop15").Path); } @@ -191,7 +191,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["Prop17"] is string value14) + if (configuration["Prop17"] is string value14 && !string.IsNullOrEmpty(value14)) { instance.Prop17 = ParseSystemGlobalizationCultureInfo(value14, configuration.GetSection("Prop17").Path); } @@ -204,7 +204,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["Prop19"] is string value15) + if (configuration["Prop19"] is string value15 && !string.IsNullOrEmpty(value15)) { instance.Prop19 = ParseSystemDateTime(value15, configuration.GetSection("Prop19").Path); } @@ -213,7 +213,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop19 = instance.Prop19; } - if (configuration["Prop20"] is string value16) + if (configuration["Prop20"] is string value16 && !string.IsNullOrEmpty(value16)) { instance.Prop20 = ParseSystemDateTimeOffset(value16, configuration.GetSection("Prop20").Path); } @@ -222,7 +222,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop20 = instance.Prop20; } - if (configuration["Prop21"] is string value17) + if (configuration["Prop21"] is string value17 && !string.IsNullOrEmpty(value17)) { instance.Prop21 = ParseDecimal(value17, configuration.GetSection("Prop21").Path); } @@ -231,7 +231,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop21 = instance.Prop21; } - if (configuration["Prop23"] is string value18) + if (configuration["Prop23"] is string value18 && !string.IsNullOrEmpty(value18)) { instance.Prop23 = ParseSystemTimeSpan(value18, configuration.GetSection("Prop23").Path); } @@ -240,7 +240,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop23 = instance.Prop23; } - if (configuration["Prop24"] is string value19) + if (configuration["Prop24"] is string value19 && !string.IsNullOrEmpty(value19)) { instance.Prop24 = ParseSystemGuid(value19, configuration.GetSection("Prop24").Path); } @@ -249,7 +249,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop24 = instance.Prop24; } - if (configuration["Prop25"] is string value20) + if (configuration["Prop25"] is string value20 && !string.IsNullOrEmpty(value20)) { instance.Prop25 = ParseSystemUri(value20, configuration.GetSection("Prop25").Path); } @@ -262,7 +262,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["Prop26"] is string value21) + if (configuration["Prop26"] is string value21 && !string.IsNullOrEmpty(value21)) { instance.Prop26 = ParseSystemVersion(value21, configuration.GetSection("Prop26").Path); } @@ -275,7 +275,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["Prop27"] is string value22) + if (configuration["Prop27"] is string value22 && !string.IsNullOrEmpty(value22)) { instance.Prop27 = ParseEnum(value22, configuration.GetSection("Prop27").Path); } @@ -284,7 +284,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop27 = instance.Prop27; } - if (configuration["Prop7"] is string value23) + if (configuration["Prop7"] is string value23 && !string.IsNullOrEmpty(value23)) { instance.Prop7 = ParseSystemInt128(value23, configuration.GetSection("Prop7").Path); } @@ -293,7 +293,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop7 = instance.Prop7; } - if (configuration["Prop11"] is string value24) + if (configuration["Prop11"] is string value24 && !string.IsNullOrEmpty(value24)) { instance.Prop11 = ParseSystemHalf(value24, configuration.GetSection("Prop11").Path); } @@ -302,7 +302,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop11 = instance.Prop11; } - if (configuration["Prop12"] is string value25) + if (configuration["Prop12"] is string value25 && !string.IsNullOrEmpty(value25)) { instance.Prop12 = ParseSystemUInt128(value25, configuration.GetSection("Prop12").Path); } @@ -311,7 +311,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop12 = instance.Prop12; } - if (configuration["Prop18"] is string value26) + if (configuration["Prop18"] is string value26 && !string.IsNullOrEmpty(value26)) { instance.Prop18 = ParseSystemDateOnly(value26, configuration.GetSection("Prop18").Path); } @@ -320,7 +320,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop18 = instance.Prop18; } - if (configuration["Prop22"] is string value27) + if (configuration["Prop22"] is string value27 && !string.IsNullOrEmpty(value27)) { instance.Prop22 = ParseSystemTimeOnly(value27, configuration.GetSection("Prop22").Path); } @@ -329,7 +329,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop22 = instance.Prop22; } - if (configuration["Prop28"] is string value28) + if (configuration["Prop28"] is string value28 && !string.IsNullOrEmpty(value28)) { instance.Prop28 = ParseByteArray(value28, configuration.GetSection("Prop28").Path); } @@ -342,7 +342,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["Prop29"] is string value29) + if (configuration["Prop29"] is string value29 && !string.IsNullOrEmpty(value29)) { instance.Prop29 = ParseInt(value29, configuration.GetSection("Prop29").Path); } @@ -351,7 +351,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration instance.Prop29 = instance.Prop29; } - if (configuration["Prop30"] is string value30) + if (configuration["Prop30"] is string value30 && !string.IsNullOrEmpty(value30)) { instance.Prop30 = ParseSystemDateTime(value30, configuration.GetSection("Prop30").Path); } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/Version1/UnsupportedTypes.generated.txt b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/Version1/UnsupportedTypes.generated.txt index 509dbb05c39..119788b0842 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/Version1/UnsupportedTypes.generated.txt +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/Baselines/netcoreapp/Version1/UnsupportedTypes.generated.txt @@ -137,7 +137,7 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration } } - if (configuration["Age"] is string value3) + if (configuration["Age"] is string value3 && !string.IsNullOrEmpty(value3)) { instance.Age = ParseInt(value3, configuration.GetSection("Age").Path); } @@ -153,6 +153,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section4, ref temp6, defaultValueIfNotFound: false, binderOptions); instance.List = temp6; } + else + { + instance.List = instance.List; + } if (AsConfigWithChildren(configuration.GetSection("Array")) is IConfigurationSection section7) { @@ -161,6 +165,10 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section7, ref temp9, defaultValueIfNotFound: false, binderOptions); instance.Array = temp9; } + else + { + instance.Array = instance.Array; + } if (AsConfigWithChildren(configuration.GetSection("Record")) is IConfigurationSection section10) { @@ -169,12 +177,16 @@ namespace Microsoft.Extensions.Configuration.Binder.SourceGeneration BindCore(section10, ref temp12, defaultValueIfNotFound: false, binderOptions); instance.Record = temp12; } + else + { + instance.Record = instance.Record; + } } public static global::Record InitializeRecordAction(IConfiguration configuration, BinderOptions? binderOptions) { int x = (int)(10); - if (configuration["x"] is string value13) + if (configuration["x"] is string value13 && !string.IsNullOrEmpty(value13)) { x = ParseInt(value13, configuration.GetSection("x").Path); } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/GeneratorTests.cs b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/GeneratorTests.cs index f4f9c906a93..1442c623f3f 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/GeneratorTests.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Binder/tests/SourceGenerationTests/GeneratorTests.cs @@ -257,6 +257,39 @@ async Task Test(bool expectOutput) } } + /// + /// We binding the type "SslClientAuthenticationOptions" which has a property "CipherSuitesPolicy" of type "CipherSuitesPolicy". We can't bind this type. + /// This test is to ensure not including the property "CipherSuitesPolicy" in the generated code caused a build break. + /// + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNetCore))] + public async Task IgnoredUnBindablePropertiesTest() + { + string source = """ + using System; + using System.Net.Security; + using Microsoft.Extensions.Configuration; + using System.Collections.Immutable; + using System.Text; + using System.Text.Json; + + public class Program + { + public static void Main() + { + ConfigurationBuilder configurationBuilder = new(); + IConfiguration config = configurationBuilder.Build(); + + var obj = config.Get(); + } + } + """; + + ConfigBindingGenRunResult result = await RunGeneratorAndUpdateCompilation(source, assemblyReferences: GetAssemblyRefsWithAdditional(typeof(ImmutableArray<>), typeof(Encoding), typeof(JsonSerializer), typeof(System.Net.Security.AuthenticatedStream))); + Assert.NotNull(result.GeneratedSource); + + Assert.DoesNotContain("CipherSuitesPolicy = ", result.GeneratedSource.Value.SourceText.ToString()); + } + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNetCore))] [ActiveIssue("Work out why we aren't getting all the expected diagnostics.")] public async Task IssueDiagnosticsForAllOffendingCallsites() diff --git a/src/libraries/Microsoft.Extensions.Configuration.CommandLine/Microsoft.Extensions.Configuration.CommandLine.sln b/src/libraries/Microsoft.Extensions.Configuration.CommandLine/Microsoft.Extensions.Configuration.CommandLine.sln index 5b4aec3e159..595dc05d25b 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.CommandLine/Microsoft.Extensions.Configuration.CommandLine.sln +++ b/src/libraries/Microsoft.Extensions.Configuration.CommandLine/Microsoft.Extensions.Configuration.CommandLine.sln @@ -29,7 +29,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Primit EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Primitives", "..\Microsoft.Extensions.Primitives\src\Microsoft.Extensions.Primitives.csproj", "{DD7282C4-85F7-4C0F-9E43-1EC487A5FD20}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{085296E6-03AF-485A-BBF9-538E27DF269D}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{A04C961F-4979-4FF3-B1E5-2B80E1A465E9}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{EFCE9CE3-9F0E-442A-97CF-01113E3F2A0A}" EndProject @@ -125,10 +125,10 @@ Global {DD7282C4-85F7-4C0F-9E43-1EC487A5FD20}.Debug|Any CPU.Build.0 = Debug|Any CPU {DD7282C4-85F7-4C0F-9E43-1EC487A5FD20}.Release|Any CPU.ActiveCfg = Release|Any CPU {DD7282C4-85F7-4C0F-9E43-1EC487A5FD20}.Release|Any CPU.Build.0 = Release|Any CPU - {085296E6-03AF-485A-BBF9-538E27DF269D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {085296E6-03AF-485A-BBF9-538E27DF269D}.Debug|Any CPU.Build.0 = Debug|Any CPU - {085296E6-03AF-485A-BBF9-538E27DF269D}.Release|Any CPU.ActiveCfg = Release|Any CPU - {085296E6-03AF-485A-BBF9-538E27DF269D}.Release|Any CPU.Build.0 = Release|Any CPU + {A04C961F-4979-4FF3-B1E5-2B80E1A465E9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A04C961F-4979-4FF3-B1E5-2B80E1A465E9}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A04C961F-4979-4FF3-B1E5-2B80E1A465E9}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A04C961F-4979-4FF3-B1E5-2B80E1A465E9}.Release|Any CPU.Build.0 = Release|Any CPU {EFCE9CE3-9F0E-442A-97CF-01113E3F2A0A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {EFCE9CE3-9F0E-442A-97CF-01113E3F2A0A}.Debug|Any CPU.Build.0 = Debug|Any CPU {EFCE9CE3-9F0E-442A-97CF-01113E3F2A0A}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -173,7 +173,7 @@ Global {27EB8901-D9CB-4814-8565-8D2CE564F2C8} = {F8D4BCC4-4B13-4EFC-A5AE-38C26519EDDF} {DD7282C4-85F7-4C0F-9E43-1EC487A5FD20} = {F8D4BCC4-4B13-4EFC-A5AE-38C26519EDDF} {666035CA-DF32-4759-8E5D-5845F137FE2C} = {24F3652F-573B-445E-8690-BE73B8F0A2C7} - {085296E6-03AF-485A-BBF9-538E27DF269D} = {24F3652F-573B-445E-8690-BE73B8F0A2C7} + {A04C961F-4979-4FF3-B1E5-2B80E1A465E9} = {24F3652F-573B-445E-8690-BE73B8F0A2C7} {EFCE9CE3-9F0E-442A-97CF-01113E3F2A0A} = {24F3652F-573B-445E-8690-BE73B8F0A2C7} {4BC663D6-2D40-4DF3-9640-09321F1853BC} = {6798366E-2129-4EA8-99FD-725A4CA62DE4} {04AE44D5-E27B-4901-914A-E1DEB97590DB} = {6798366E-2129-4EA8-99FD-725A4CA62DE4} diff --git a/src/libraries/Microsoft.Extensions.Configuration.CommandLine/src/CommandLineConfigurationProvider.cs b/src/libraries/Microsoft.Extensions.Configuration.CommandLine/src/CommandLineConfigurationProvider.cs index 8877a3086b2..7afcfc40fa6 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.CommandLine/src/CommandLineConfigurationProvider.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.CommandLine/src/CommandLineConfigurationProvider.cs @@ -7,7 +7,7 @@ namespace Microsoft.Extensions.Configuration.CommandLine { /// - /// A command line based . + /// Provides configuration key-value pairs that are obtained from the command line. /// public class CommandLineConfigurationProvider : ConfigurationProvider { @@ -31,12 +31,12 @@ public CommandLineConfigurationProvider(IEnumerable args, IDictionary - /// The command line arguments. + /// Gets the command-line arguments. /// protected IEnumerable Args { get; } /// - /// Loads the configuration data from the command line args. + /// Loads the configuration data from the command-line arguments. /// public override void Load() { diff --git a/src/libraries/Microsoft.Extensions.Configuration.CommandLine/src/CommandLineConfigurationSource.cs b/src/libraries/Microsoft.Extensions.Configuration.CommandLine/src/CommandLineConfigurationSource.cs index 1dc7ad91181..f352ef944e1 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.CommandLine/src/CommandLineConfigurationSource.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.CommandLine/src/CommandLineConfigurationSource.cs @@ -7,7 +7,7 @@ namespace Microsoft.Extensions.Configuration.CommandLine { /// - /// Represents command line arguments as an . + /// Represents command-line arguments as an . /// public class CommandLineConfigurationSource : IConfigurationSource { @@ -17,7 +17,7 @@ public class CommandLineConfigurationSource : IConfigurationSource public IDictionary? SwitchMappings { get; set; } /// - /// Gets or sets the command line args. + /// Gets or sets the command line arguments. /// public IEnumerable Args { get; set; } = Array.Empty(); @@ -25,7 +25,7 @@ public class CommandLineConfigurationSource : IConfigurationSource /// Builds the for this source. /// /// The . - /// A + /// A . public IConfigurationProvider Build(IConfigurationBuilder builder) { return new CommandLineConfigurationProvider(Args, SwitchMappings); diff --git a/src/libraries/Microsoft.Extensions.Configuration.EnvironmentVariables/Microsoft.Extensions.Configuration.EnvironmentVariables.sln b/src/libraries/Microsoft.Extensions.Configuration.EnvironmentVariables/Microsoft.Extensions.Configuration.EnvironmentVariables.sln index 969519febf7..e556e72946b 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.EnvironmentVariables/Microsoft.Extensions.Configuration.EnvironmentVariables.sln +++ b/src/libraries/Microsoft.Extensions.Configuration.EnvironmentVariables/Microsoft.Extensions.Configuration.EnvironmentVariables.sln @@ -29,7 +29,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Primit EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Primitives", "..\Microsoft.Extensions.Primitives\src\Microsoft.Extensions.Primitives.csproj", "{73CB2C25-1A22-479C-9FC0-CE65BFE272DB}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{8931287A-8B13-415E-9043-2E2BB8A09F2D}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{5ACCD02B-248F-4F09-A7E1-CD027DC7142A}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{45730CA0-CC0F-4D63-8E2E-08A4414599EC}" EndProject @@ -125,10 +125,10 @@ Global {73CB2C25-1A22-479C-9FC0-CE65BFE272DB}.Debug|Any CPU.Build.0 = Debug|Any CPU {73CB2C25-1A22-479C-9FC0-CE65BFE272DB}.Release|Any CPU.ActiveCfg = Release|Any CPU {73CB2C25-1A22-479C-9FC0-CE65BFE272DB}.Release|Any CPU.Build.0 = Release|Any CPU - {8931287A-8B13-415E-9043-2E2BB8A09F2D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {8931287A-8B13-415E-9043-2E2BB8A09F2D}.Debug|Any CPU.Build.0 = Debug|Any CPU - {8931287A-8B13-415E-9043-2E2BB8A09F2D}.Release|Any CPU.ActiveCfg = Release|Any CPU - {8931287A-8B13-415E-9043-2E2BB8A09F2D}.Release|Any CPU.Build.0 = Release|Any CPU + {5ACCD02B-248F-4F09-A7E1-CD027DC7142A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {5ACCD02B-248F-4F09-A7E1-CD027DC7142A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {5ACCD02B-248F-4F09-A7E1-CD027DC7142A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {5ACCD02B-248F-4F09-A7E1-CD027DC7142A}.Release|Any CPU.Build.0 = Release|Any CPU {45730CA0-CC0F-4D63-8E2E-08A4414599EC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {45730CA0-CC0F-4D63-8E2E-08A4414599EC}.Debug|Any CPU.Build.0 = Debug|Any CPU {45730CA0-CC0F-4D63-8E2E-08A4414599EC}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -173,7 +173,7 @@ Global {3D1CF09A-2A49-4F79-89F3-C04EC00FFC32} = {D5A074D2-033F-4577-A5CC-568CAC9CC729} {73CB2C25-1A22-479C-9FC0-CE65BFE272DB} = {D5A074D2-033F-4577-A5CC-568CAC9CC729} {AB77DCB0-99E3-45F5-BD7A-96FF34FAC245} = {8F8CE472-78AF-419D-8D46-9DF1CAACD48E} - {8931287A-8B13-415E-9043-2E2BB8A09F2D} = {8F8CE472-78AF-419D-8D46-9DF1CAACD48E} + {5ACCD02B-248F-4F09-A7E1-CD027DC7142A} = {8F8CE472-78AF-419D-8D46-9DF1CAACD48E} {45730CA0-CC0F-4D63-8E2E-08A4414599EC} = {8F8CE472-78AF-419D-8D46-9DF1CAACD48E} {B909A98C-3265-440A-8417-F3472E95EAF4} = {CCB95EA0-6D55-44F2-A02F-88CE1C1BA70E} {6AFC4513-94DE-4B45-BC93-BF88BF13B9F0} = {CCB95EA0-6D55-44F2-A02F-88CE1C1BA70E} diff --git a/src/libraries/Microsoft.Extensions.Configuration.EnvironmentVariables/src/EnvironmentVariablesConfigurationProvider.cs b/src/libraries/Microsoft.Extensions.Configuration.EnvironmentVariables/src/EnvironmentVariablesConfigurationProvider.cs index 3888ac33a16..8025246ec88 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.EnvironmentVariables/src/EnvironmentVariablesConfigurationProvider.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.EnvironmentVariables/src/EnvironmentVariablesConfigurationProvider.cs @@ -8,7 +8,7 @@ namespace Microsoft.Extensions.Configuration.EnvironmentVariables { /// - /// An environment variable based . + /// Provides configuration key-value pairs that are obtained from environment variables. /// public class EnvironmentVariablesConfigurationProvider : ConfigurationProvider { @@ -48,7 +48,7 @@ public override void Load() => /// /// Generates a string representing this provider name and relevant details. /// - /// The configuration name. + /// The configuration name. public override string ToString() { string s = GetType().Name; diff --git a/src/libraries/Microsoft.Extensions.Configuration.EnvironmentVariables/src/EnvironmentVariablesConfigurationSource.cs b/src/libraries/Microsoft.Extensions.Configuration.EnvironmentVariables/src/EnvironmentVariablesConfigurationSource.cs index 66e941af7f9..079c8cf5eea 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.EnvironmentVariables/src/EnvironmentVariablesConfigurationSource.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.EnvironmentVariables/src/EnvironmentVariablesConfigurationSource.cs @@ -17,7 +17,7 @@ public class EnvironmentVariablesConfigurationSource : IConfigurationSource /// Builds the for this source. /// /// The . - /// A + /// A . public IConfigurationProvider Build(IConfigurationBuilder builder) { return new EnvironmentVariablesConfigurationProvider(Prefix); diff --git a/src/libraries/Microsoft.Extensions.Configuration.EnvironmentVariables/src/EnvironmentVariablesExtensions.cs b/src/libraries/Microsoft.Extensions.Configuration.EnvironmentVariables/src/EnvironmentVariablesExtensions.cs index a5826a82a3a..5f265613204 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.EnvironmentVariables/src/EnvironmentVariablesExtensions.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.EnvironmentVariables/src/EnvironmentVariablesExtensions.cs @@ -7,7 +7,7 @@ namespace Microsoft.Extensions.Configuration { /// - /// Extension methods for registering with . + /// Provides extension methods for registering with . /// public static class EnvironmentVariablesExtensions { @@ -41,7 +41,7 @@ public static IConfigurationBuilder AddEnvironmentVariables( /// Adds an that reads configuration values from environment variables. /// /// The to add to. - /// Configures the source. + /// The action that configures the source. /// The . public static IConfigurationBuilder AddEnvironmentVariables(this IConfigurationBuilder builder, Action? configureSource) => builder.Add(configureSource); diff --git a/src/libraries/Microsoft.Extensions.Configuration.FileExtensions/Microsoft.Extensions.Configuration.FileExtensions.sln b/src/libraries/Microsoft.Extensions.Configuration.FileExtensions/Microsoft.Extensions.Configuration.FileExtensions.sln index 61201b5481b..f9f250475e9 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.FileExtensions/Microsoft.Extensions.Configuration.FileExtensions.sln +++ b/src/libraries/Microsoft.Extensions.Configuration.FileExtensions/Microsoft.Extensions.Configuration.FileExtensions.sln @@ -31,7 +31,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Primit EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Primitives", "..\Microsoft.Extensions.Primitives\src\Microsoft.Extensions.Primitives.csproj", "{96F56B6D-B82D-433A-95CB-A35179529934}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{3064B45D-E4A3-47CC-8F7C-1635A647F738}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{A577E1B9-6D75-48ED-A654-884056418CF1}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{C57D0E23-18B5-4EAE-8E69-433171C57C01}" EndProject @@ -131,10 +131,10 @@ Global {96F56B6D-B82D-433A-95CB-A35179529934}.Debug|Any CPU.Build.0 = Debug|Any CPU {96F56B6D-B82D-433A-95CB-A35179529934}.Release|Any CPU.ActiveCfg = Release|Any CPU {96F56B6D-B82D-433A-95CB-A35179529934}.Release|Any CPU.Build.0 = Release|Any CPU - {3064B45D-E4A3-47CC-8F7C-1635A647F738}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {3064B45D-E4A3-47CC-8F7C-1635A647F738}.Debug|Any CPU.Build.0 = Debug|Any CPU - {3064B45D-E4A3-47CC-8F7C-1635A647F738}.Release|Any CPU.ActiveCfg = Release|Any CPU - {3064B45D-E4A3-47CC-8F7C-1635A647F738}.Release|Any CPU.Build.0 = Release|Any CPU + {A577E1B9-6D75-48ED-A654-884056418CF1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A577E1B9-6D75-48ED-A654-884056418CF1}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A577E1B9-6D75-48ED-A654-884056418CF1}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A577E1B9-6D75-48ED-A654-884056418CF1}.Release|Any CPU.Build.0 = Release|Any CPU {C57D0E23-18B5-4EAE-8E69-433171C57C01}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {C57D0E23-18B5-4EAE-8E69-433171C57C01}.Debug|Any CPU.Build.0 = Debug|Any CPU {C57D0E23-18B5-4EAE-8E69-433171C57C01}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -180,7 +180,7 @@ Global {D49BC1CE-AE45-47D1-A662-9F4C0300930D} = {D55A8909-6199-44E5-A5DC-339F3FC2BF2B} {7E4BF22A-B413-40E4-88C9-6579502B17F9} = {D55A8909-6199-44E5-A5DC-339F3FC2BF2B} {96F56B6D-B82D-433A-95CB-A35179529934} = {D55A8909-6199-44E5-A5DC-339F3FC2BF2B} - {3064B45D-E4A3-47CC-8F7C-1635A647F738} = {4DFFE138-A7D8-4B2D-9FA6-B26635D29EFF} + {A577E1B9-6D75-48ED-A654-884056418CF1} = {4DFFE138-A7D8-4B2D-9FA6-B26635D29EFF} {C57D0E23-18B5-4EAE-8E69-433171C57C01} = {4DFFE138-A7D8-4B2D-9FA6-B26635D29EFF} {51626848-29B2-4B8D-9C16-CF36096EAEDC} = {6A27AADF-5939-4F52-87CB-DAE472C8B7C5} {ECA79973-C00F-4FBD-A5A4-3398B132C5EE} = {6A27AADF-5939-4F52-87CB-DAE472C8B7C5} diff --git a/src/libraries/Microsoft.Extensions.Configuration.FileExtensions/src/FileConfigurationExtensions.cs b/src/libraries/Microsoft.Extensions.Configuration.FileExtensions/src/FileConfigurationExtensions.cs index f84c5c10eea..669c9c3aee9 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.FileExtensions/src/FileConfigurationExtensions.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.FileExtensions/src/FileConfigurationExtensions.cs @@ -7,7 +7,7 @@ namespace Microsoft.Extensions.Configuration { /// - /// Extension methods for . + /// Provides extension methods for . /// public static class FileConfigurationExtensions { diff --git a/src/libraries/Microsoft.Extensions.Configuration.FileExtensions/src/FileConfigurationProvider.cs b/src/libraries/Microsoft.Extensions.Configuration.FileExtensions/src/FileConfigurationProvider.cs index d226051b1ab..d2cc8f5d85a 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.FileExtensions/src/FileConfigurationProvider.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.FileExtensions/src/FileConfigurationProvider.cs @@ -13,7 +13,7 @@ namespace Microsoft.Extensions.Configuration { /// - /// Base class for file based . + /// Provides the base class for file-based providers. /// public abstract class FileConfigurationProvider : ConfigurationProvider, IDisposable { @@ -42,14 +42,14 @@ public FileConfigurationProvider(FileConfigurationSource source) } /// - /// The source settings for this provider. + /// Gets the source settings for this provider. /// public FileConfigurationSource Source { get; } /// /// Generates a string representing this provider name and relevant details. /// - /// The configuration name. + /// The configuration name. public override string ToString() => $"{GetType().Name} for '{Source.Path}' ({(Source.Optional ? "Optional" : "Required")})"; @@ -156,7 +156,7 @@ private void HandleException(ExceptionDispatchInfo info) public void Dispose() => Dispose(true); /// - /// Dispose the provider. + /// Disposes the provider. /// /// true if invoked from . protected virtual void Dispose(bool disposing) diff --git a/src/libraries/Microsoft.Extensions.Configuration.FileExtensions/src/FileConfigurationSource.cs b/src/libraries/Microsoft.Extensions.Configuration.FileExtensions/src/FileConfigurationSource.cs index d58c265f406..ebbe0a6ffda 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.FileExtensions/src/FileConfigurationSource.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.FileExtensions/src/FileConfigurationSource.cs @@ -9,39 +9,44 @@ namespace Microsoft.Extensions.Configuration { /// - /// Represents a base class for file based . + /// Provides the base class for file-based . /// public abstract class FileConfigurationSource : IConfigurationSource { /// - /// Used to access the contents of the file. + /// Gets or sets the provider used to access the contents of the file. /// public IFileProvider? FileProvider { get; set; } /// - /// The path to the file. + /// Gets or sets the path to the file. /// [DisallowNull] public string? Path { get; set; } /// - /// Determines if loading the file is optional. + /// Gets or sets a value that indicates whether loading the file is optional. /// public bool Optional { get; set; } /// - /// Determines whether the source will be loaded if the underlying file changes. + /// Gets or sets a value that indicates whether the source will be loaded if the underlying file changes. /// public bool ReloadOnChange { get; set; } /// - /// Number of milliseconds that reload will wait before calling Load. This helps - /// avoid triggering reload before a file is completely written. Default is 250. + /// Gets or sets the number of milliseconds that reload will wait before calling Load. /// + /// + /// The number of milliseconds that reload waits before calling Load. The default is 250. + /// + /// + /// This delay helps avoid triggering reload before a file is completely written. + /// public int ReloadDelay { get; set; } = 250; /// - /// Will be called if an uncaught exception occurs in FileConfigurationProvider.Load. + /// Gets or sets the action that's called if an uncaught exception occurs in FileConfigurationProvider.Load. /// public Action? OnLoadException { get; set; } @@ -49,7 +54,7 @@ public abstract class FileConfigurationSource : IConfigurationSource /// Builds the for this source. /// /// The . - /// A + /// To be added. public abstract IConfigurationProvider Build(IConfigurationBuilder builder); /// @@ -63,8 +68,7 @@ public void EnsureDefaults(IConfigurationBuilder builder) } /// - /// If no file provider has been set, for absolute Path, this will creates a physical file provider - /// for the nearest existing directory. + /// Creates a physical file provider for the nearest existing directory if no file provider has been set, for absolute Path. /// public void ResolveFileProvider() { diff --git a/src/libraries/Microsoft.Extensions.Configuration.FileExtensions/src/FileLoadExceptionContext.cs b/src/libraries/Microsoft.Extensions.Configuration.FileExtensions/src/FileLoadExceptionContext.cs index 1d619335d5e..b8e393a3971 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.FileExtensions/src/FileLoadExceptionContext.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.FileExtensions/src/FileLoadExceptionContext.cs @@ -11,18 +11,21 @@ namespace Microsoft.Extensions.Configuration public class FileLoadExceptionContext { /// - /// The that caused the exception. + /// Gets or sets the that caused the exception. /// public FileConfigurationProvider Provider { get; set; } = null!; /// - /// The exception that occurred in Load. + /// Gets or sets the exception that occurred in Load. /// public Exception Exception { get; set; } = null!; /// - /// If true, the exception will not be rethrown. + /// Gets or sets a value that indicates whether the exception is rethrown. /// + /// + /// if the exception isn't rethrown; otherwise, . + /// public bool Ignore { get; set; } } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Ini/Microsoft.Extensions.Configuration.Ini.sln b/src/libraries/Microsoft.Extensions.Configuration.Ini/Microsoft.Extensions.Configuration.Ini.sln index a4fdf815e17..3555a213eb1 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Ini/Microsoft.Extensions.Configuration.Ini.sln +++ b/src/libraries/Microsoft.Extensions.Configuration.Ini/Microsoft.Extensions.Configuration.Ini.sln @@ -41,7 +41,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Primit EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Primitives", "..\Microsoft.Extensions.Primitives\src\Microsoft.Extensions.Primitives.csproj", "{3FAB6852-68A1-4317-B972-6B8088AB6DCF}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{3C6E7802-EA64-4225-A695-583A1D08E3A6}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{4AA84019-0A9E-4F62-BB84-EA9F2CF9325A}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{5CF9010C-D0A8-4DCA-800C-57F38FC9D159}" EndProject @@ -161,10 +161,10 @@ Global {3FAB6852-68A1-4317-B972-6B8088AB6DCF}.Debug|Any CPU.Build.0 = Debug|Any CPU {3FAB6852-68A1-4317-B972-6B8088AB6DCF}.Release|Any CPU.ActiveCfg = Release|Any CPU {3FAB6852-68A1-4317-B972-6B8088AB6DCF}.Release|Any CPU.Build.0 = Release|Any CPU - {3C6E7802-EA64-4225-A695-583A1D08E3A6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {3C6E7802-EA64-4225-A695-583A1D08E3A6}.Debug|Any CPU.Build.0 = Debug|Any CPU - {3C6E7802-EA64-4225-A695-583A1D08E3A6}.Release|Any CPU.ActiveCfg = Release|Any CPU - {3C6E7802-EA64-4225-A695-583A1D08E3A6}.Release|Any CPU.Build.0 = Release|Any CPU + {4AA84019-0A9E-4F62-BB84-EA9F2CF9325A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {4AA84019-0A9E-4F62-BB84-EA9F2CF9325A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {4AA84019-0A9E-4F62-BB84-EA9F2CF9325A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {4AA84019-0A9E-4F62-BB84-EA9F2CF9325A}.Release|Any CPU.Build.0 = Release|Any CPU {5CF9010C-D0A8-4DCA-800C-57F38FC9D159}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {5CF9010C-D0A8-4DCA-800C-57F38FC9D159}.Debug|Any CPU.Build.0 = Debug|Any CPU {5CF9010C-D0A8-4DCA-800C-57F38FC9D159}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -215,7 +215,7 @@ Global {F3FA11C3-612D-4F2B-9A2B-5D3FDCF1C077} = {E562A241-4253-44F8-9E3F-2E03C4058D7B} {3FAB6852-68A1-4317-B972-6B8088AB6DCF} = {E562A241-4253-44F8-9E3F-2E03C4058D7B} {BAFE33FD-877B-4CC8-89CC-467576FC67FA} = {1FEF4F42-130B-4504-A561-17191FE763C3} - {3C6E7802-EA64-4225-A695-583A1D08E3A6} = {1FEF4F42-130B-4504-A561-17191FE763C3} + {4AA84019-0A9E-4F62-BB84-EA9F2CF9325A} = {1FEF4F42-130B-4504-A561-17191FE763C3} {5CF9010C-D0A8-4DCA-800C-57F38FC9D159} = {1FEF4F42-130B-4504-A561-17191FE763C3} {76674EB7-50F1-4581-84CC-5A10056641CC} = {3E16581F-C5C2-4935-BA70-0BE08A878F7B} {4E6BA64D-C5F3-4FFC-810D-E961F66953E8} = {3E16581F-C5C2-4935-BA70-0BE08A878F7B} diff --git a/src/libraries/Microsoft.Extensions.Configuration.Ini/src/IniConfigurationExtensions.cs b/src/libraries/Microsoft.Extensions.Configuration.Ini/src/IniConfigurationExtensions.cs index 8331591b215..d77f18f3b8f 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Ini/src/IniConfigurationExtensions.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Ini/src/IniConfigurationExtensions.cs @@ -9,7 +9,7 @@ namespace Microsoft.Extensions.Configuration { /// - /// Extension methods for adding . + /// Provides extension methods for adding . /// public static class IniConfigurationExtensions { @@ -17,7 +17,7 @@ public static class IniConfigurationExtensions /// Adds the INI configuration provider at to . /// /// The to add to. - /// Path relative to the base path stored in + /// The path relative to the base path stored in /// of . /// The . public static IConfigurationBuilder AddIniFile(this IConfigurationBuilder builder, string path) @@ -29,7 +29,7 @@ public static IConfigurationBuilder AddIniFile(this IConfigurationBuilder builde /// Adds the INI configuration provider at to . /// /// The to add to. - /// Path relative to the base path stored in + /// The path relative to the base path stored in /// of . /// Whether the file is optional. /// The . @@ -44,8 +44,8 @@ public static IConfigurationBuilder AddIniFile(this IConfigurationBuilder builde /// The to add to. /// Path relative to the base path stored in /// of . - /// Whether the file is optional. - /// Whether the configuration should be reloaded if the file changes. + /// if the file is optional; otherwise, . + /// Whether the configuration should be reloaded if the file changes; otherwise, . /// The . public static IConfigurationBuilder AddIniFile(this IConfigurationBuilder builder, string path, bool optional, bool reloadOnChange) { @@ -59,8 +59,8 @@ public static IConfigurationBuilder AddIniFile(this IConfigurationBuilder builde /// The to use to access the file. /// Path relative to the base path stored in /// of . - /// Whether the file is optional. - /// Whether the configuration should be reloaded if the file changes. + /// if the file is optional; otherwise, . + /// if the configuration should be reloaded if the file changes; otherwise, . /// The . public static IConfigurationBuilder AddIniFile(this IConfigurationBuilder builder, IFileProvider? provider, string path, bool optional, bool reloadOnChange) { @@ -94,7 +94,7 @@ public static IConfigurationBuilder AddIniFile(this IConfigurationBuilder builde /// Adds a INI configuration source to . /// /// The to add to. - /// The to read the ini configuration data from. + /// The to read the INI configuration data from. /// The . public static IConfigurationBuilder AddIniStream(this IConfigurationBuilder builder, Stream stream) { diff --git a/src/libraries/Microsoft.Extensions.Configuration.Ini/src/IniConfigurationProvider.cs b/src/libraries/Microsoft.Extensions.Configuration.Ini/src/IniConfigurationProvider.cs index 3d601510a7f..c63216856b2 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Ini/src/IniConfigurationProvider.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Ini/src/IniConfigurationProvider.cs @@ -6,7 +6,7 @@ namespace Microsoft.Extensions.Configuration.Ini { /// - /// An INI file based . + /// Provides configuration key-value pairs that are obtained from an INI file. /// Files are simple line structures (INI Files on Wikipedia) /// /// diff --git a/src/libraries/Microsoft.Extensions.Configuration.Ini/src/IniStreamConfigurationProvider.cs b/src/libraries/Microsoft.Extensions.Configuration.Ini/src/IniStreamConfigurationProvider.cs index 9b010dc4762..df6038b0290 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Ini/src/IniStreamConfigurationProvider.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Ini/src/IniStreamConfigurationProvider.cs @@ -8,12 +8,12 @@ namespace Microsoft.Extensions.Configuration.Ini { /// - /// An INI file based . + /// Provides configuration key-value pairs that are obtained from an INI stream. /// public class IniStreamConfigurationProvider : StreamConfigurationProvider { /// - /// Constructor. + /// Initializes a new instance of . /// /// The . public IniStreamConfigurationProvider(IniStreamConfigurationSource source) : base(source) { } @@ -85,9 +85,9 @@ public IniStreamConfigurationProvider(IniStreamConfigurationSource source) : bas } /// - /// Loads INI configuration key/values from a stream into a provider. + /// Loads INI configuration key-value pairs from a stream into a provider. /// - /// The to load ini configuration data from. + /// The to load INI configuration data from. public override void Load(Stream stream) { Data = Read(stream); diff --git a/src/libraries/Microsoft.Extensions.Configuration.Ini/src/IniStreamConfigurationSource.cs b/src/libraries/Microsoft.Extensions.Configuration.Ini/src/IniStreamConfigurationSource.cs index 01f594d91ce..dbce82e51ee 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Ini/src/IniStreamConfigurationSource.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Ini/src/IniStreamConfigurationSource.cs @@ -4,7 +4,7 @@ namespace Microsoft.Extensions.Configuration.Ini { /// - /// Represents an INI file as an . + /// Represents an INI stream as an . /// Files are simple line structures (INI Files on Wikipedia) /// /// @@ -21,7 +21,7 @@ public class IniStreamConfigurationSource : StreamConfigurationSource /// Builds the for this source. /// /// The . - /// An + /// An . public override IConfigurationProvider Build(IConfigurationBuilder builder) => new IniStreamConfigurationProvider(this); } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Json/Microsoft.Extensions.Configuration.Json.sln b/src/libraries/Microsoft.Extensions.Configuration.Json/Microsoft.Extensions.Configuration.Json.sln index 80f8ea66c23..fa8204e191e 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Json/Microsoft.Extensions.Configuration.Json.sln +++ b/src/libraries/Microsoft.Extensions.Configuration.Json/Microsoft.Extensions.Configuration.Json.sln @@ -55,6 +55,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Memory", "..\System. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{DC7A797D-9D21-4D38-8611-BE0E3D7BA541}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{20B742C4-DB08-487E-AD83-AC3A51AF6F6F}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{774F9552-3770-461E-BAAA-9D50222497BA}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{AFEFC5C1-C952-45EE-BCF9-DC246ADE43DF}" @@ -221,6 +223,10 @@ Global {DC7A797D-9D21-4D38-8611-BE0E3D7BA541}.Debug|Any CPU.Build.0 = Debug|Any CPU {DC7A797D-9D21-4D38-8611-BE0E3D7BA541}.Release|Any CPU.ActiveCfg = Release|Any CPU {DC7A797D-9D21-4D38-8611-BE0E3D7BA541}.Release|Any CPU.Build.0 = Release|Any CPU + {20B742C4-DB08-487E-AD83-AC3A51AF6F6F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {20B742C4-DB08-487E-AD83-AC3A51AF6F6F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {20B742C4-DB08-487E-AD83-AC3A51AF6F6F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {20B742C4-DB08-487E-AD83-AC3A51AF6F6F}.Release|Any CPU.Build.0 = Release|Any CPU {774F9552-3770-461E-BAAA-9D50222497BA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {774F9552-3770-461E-BAAA-9D50222497BA}.Debug|Any CPU.Build.0 = Debug|Any CPU {774F9552-3770-461E-BAAA-9D50222497BA}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -323,6 +329,7 @@ Global {6EB2865B-C9F6-4F9B-82DA-4C577587B577} = {1F57E720-CBFF-4648-A507-EFCBCECB5FD3} {D011C341-C474-499C-B262-4C57C6D64901} = {B4A09B09-2C03-4FC7-B12F-5DD6FC10A5B1} {DC7A797D-9D21-4D38-8611-BE0E3D7BA541} = {B4A09B09-2C03-4FC7-B12F-5DD6FC10A5B1} + {20B742C4-DB08-487E-AD83-AC3A51AF6F6F} = {B4A09B09-2C03-4FC7-B12F-5DD6FC10A5B1} {774F9552-3770-461E-BAAA-9D50222497BA} = {B4A09B09-2C03-4FC7-B12F-5DD6FC10A5B1} {AFEFC5C1-C952-45EE-BCF9-DC246ADE43DF} = {B4A09B09-2C03-4FC7-B12F-5DD6FC10A5B1} {CC3E9E0A-4417-4678-87CC-1D2B001C3232} = {B4A09B09-2C03-4FC7-B12F-5DD6FC10A5B1} diff --git a/src/libraries/Microsoft.Extensions.Configuration.Json/src/JsonConfigurationProvider.cs b/src/libraries/Microsoft.Extensions.Configuration.Json/src/JsonConfigurationProvider.cs index c2c1ef898a0..3b127c74849 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Json/src/JsonConfigurationProvider.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Json/src/JsonConfigurationProvider.cs @@ -9,7 +9,7 @@ namespace Microsoft.Extensions.Configuration.Json { /// - /// A JSON file based . + /// Provides configuration key-value pairs that are obtained from a JSON file. /// public class JsonConfigurationProvider : FileConfigurationProvider { diff --git a/src/libraries/Microsoft.Extensions.Configuration.Json/src/JsonConfigurationSource.cs b/src/libraries/Microsoft.Extensions.Configuration.Json/src/JsonConfigurationSource.cs index da5eaf736b2..28e239562b6 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Json/src/JsonConfigurationSource.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Json/src/JsonConfigurationSource.cs @@ -14,7 +14,7 @@ public class JsonConfigurationSource : FileConfigurationSource /// Builds the for this source. /// /// The . - /// A + /// A instance. public override IConfigurationProvider Build(IConfigurationBuilder builder) { EnsureDefaults(builder); diff --git a/src/libraries/Microsoft.Extensions.Configuration.Json/src/JsonStreamConfigurationProvider.cs b/src/libraries/Microsoft.Extensions.Configuration.Json/src/JsonStreamConfigurationProvider.cs index 2ed6ad11910..86e1c0afd5d 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Json/src/JsonStreamConfigurationProvider.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Json/src/JsonStreamConfigurationProvider.cs @@ -6,20 +6,20 @@ namespace Microsoft.Extensions.Configuration.Json { /// - /// Loads configuration key/values from a json stream into a provider. + /// Provides configuration key-value pairs that are obtained from a JSON stream. /// public class JsonStreamConfigurationProvider : StreamConfigurationProvider { /// - /// Constructor. + /// Initializes a new instance of the class. /// /// The . public JsonStreamConfigurationProvider(JsonStreamConfigurationSource source) : base(source) { } /// - /// Loads json configuration key/values from a stream into a provider. + /// Loads JSON configuration key-value pairs from a stream into a provider. /// - /// The json to load configuration data from. + /// The JSON to load configuration data from. public override void Load(Stream stream) { Data = JsonConfigurationFileParser.Parse(stream); diff --git a/src/libraries/Microsoft.Extensions.Configuration.Json/src/Microsoft.Extensions.Configuration.Json.csproj b/src/libraries/Microsoft.Extensions.Configuration.Json/src/Microsoft.Extensions.Configuration.Json.csproj index f981f3e064b..3e217a0a5cf 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Json/src/Microsoft.Extensions.Configuration.Json.csproj +++ b/src/libraries/Microsoft.Extensions.Configuration.Json/src/Microsoft.Extensions.Configuration.Json.csproj @@ -13,9 +13,12 @@ - + + + + diff --git a/src/libraries/Microsoft.Extensions.Configuration.UserSecrets/Microsoft.Extensions.Configuration.UserSecrets.sln b/src/libraries/Microsoft.Extensions.Configuration.UserSecrets/Microsoft.Extensions.Configuration.UserSecrets.sln index fc0ebb6af9b..f31d5880cb4 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.UserSecrets/Microsoft.Extensions.Configuration.UserSecrets.sln +++ b/src/libraries/Microsoft.Extensions.Configuration.UserSecrets/Microsoft.Extensions.Configuration.UserSecrets.sln @@ -53,6 +53,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Memory", "..\System. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{AE3A3D06-1D92-477D-9A55-21F457430FAD}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{681C11D6-9F5C-44D8-B685-C8CC4E67DFDB}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{5C82F684-E28B-4487-9606-3AA0B6909EF7}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{0243557C-E886-4392-8E9F-ECA0820E094B}" @@ -215,6 +217,10 @@ Global {AE3A3D06-1D92-477D-9A55-21F457430FAD}.Debug|Any CPU.Build.0 = Debug|Any CPU {AE3A3D06-1D92-477D-9A55-21F457430FAD}.Release|Any CPU.ActiveCfg = Release|Any CPU {AE3A3D06-1D92-477D-9A55-21F457430FAD}.Release|Any CPU.Build.0 = Release|Any CPU + {681C11D6-9F5C-44D8-B685-C8CC4E67DFDB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {681C11D6-9F5C-44D8-B685-C8CC4E67DFDB}.Debug|Any CPU.Build.0 = Debug|Any CPU + {681C11D6-9F5C-44D8-B685-C8CC4E67DFDB}.Release|Any CPU.ActiveCfg = Release|Any CPU + {681C11D6-9F5C-44D8-B685-C8CC4E67DFDB}.Release|Any CPU.Build.0 = Release|Any CPU {5C82F684-E28B-4487-9606-3AA0B6909EF7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {5C82F684-E28B-4487-9606-3AA0B6909EF7}.Debug|Any CPU.Build.0 = Debug|Any CPU {5C82F684-E28B-4487-9606-3AA0B6909EF7}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -316,6 +322,7 @@ Global {D3256E08-CC12-4C90-848B-6A2F68DFFB97} = {9A8D52D9-CDB4-4F59-8014-94BF08B4FAB3} {705F880D-3E27-4ACA-87CC-808BB7DDA610} = {9A8D52D9-CDB4-4F59-8014-94BF08B4FAB3} {AE3A3D06-1D92-477D-9A55-21F457430FAD} = {48CD61B8-2937-4229-8BAB-3F1167B54E61} + {681C11D6-9F5C-44D8-B685-C8CC4E67DFDB} = {48CD61B8-2937-4229-8BAB-3F1167B54E61} {5C82F684-E28B-4487-9606-3AA0B6909EF7} = {48CD61B8-2937-4229-8BAB-3F1167B54E61} {0243557C-E886-4392-8E9F-ECA0820E094B} = {48CD61B8-2937-4229-8BAB-3F1167B54E61} {C5BA84F6-C75B-4698-9733-38C67C285215} = {48CD61B8-2937-4229-8BAB-3F1167B54E61} diff --git a/src/libraries/Microsoft.Extensions.Configuration.UserSecrets/src/PathHelper.cs b/src/libraries/Microsoft.Extensions.Configuration.UserSecrets/src/PathHelper.cs index 823693fd764..e3423173406 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.UserSecrets/src/PathHelper.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.UserSecrets/src/PathHelper.cs @@ -14,15 +14,14 @@ public class PathHelper internal const string SecretsFileName = "secrets.json"; /// - /// /// Returns the path to the JSON file that stores user secrets. - /// - /// - /// This uses the current user profile to locate the secrets file on disk in a location outside of source control. - /// /// /// The user secret ID. /// The full path to the secret file. + /// + /// This method uses the current user profile to locate the secrets + /// file on disk in a location outside of source control. + /// public static string GetSecretsPathFromSecretsId(string userSecretsId) { return InternalGetSecretsPathFromSecretsId(userSecretsId, throwIfNoRoot: true); diff --git a/src/libraries/Microsoft.Extensions.Configuration.UserSecrets/src/UserSecretsConfigurationExtensions.cs b/src/libraries/Microsoft.Extensions.Configuration.UserSecrets/src/UserSecretsConfigurationExtensions.cs index 61098fb255a..e82f5534aab 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.UserSecrets/src/UserSecretsConfigurationExtensions.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.UserSecrets/src/UserSecretsConfigurationExtensions.cs @@ -10,7 +10,7 @@ namespace Microsoft.Extensions.Configuration { /// - /// Configuration extensions for adding user secrets configuration source. + /// Provides configuration extensions for adding user secrets configuration source. /// public static class UserSecretsConfigurationExtensions { @@ -25,7 +25,7 @@ public static class UserSecretsConfigurationExtensions /// /// The configuration builder. /// The type from the assembly to search for an instance of . - /// Thrown when the assembly containing does not have . + /// The assembly containing does not have . /// The configuration builder. public static IConfigurationBuilder AddUserSecrets(this IConfigurationBuilder configuration) where T : class @@ -42,7 +42,7 @@ public static IConfigurationBuilder AddUserSecrets(this IConfigurationBuilder /// /// The configuration builder. /// Whether loading secrets is optional. When false, this method may throw. - /// Thrown when is false and the assembly containing does not have a valid . + /// is false and the assembly containing does not have a valid . /// The type from the assembly to search for an instance of . /// The configuration builder. public static IConfigurationBuilder AddUserSecrets(this IConfigurationBuilder configuration, bool optional) @@ -61,7 +61,7 @@ public static IConfigurationBuilder AddUserSecrets(this IConfigurationBuilder /// The configuration builder. /// Whether loading secrets is optional. When false, this method may throw. /// Whether the configuration should be reloaded if the file changes. - /// Thrown when is false and the assembly containing does not have a valid . + /// is and the assembly containing does not have a valid . /// The type from the assembly to search for an instance of . /// The configuration builder. public static IConfigurationBuilder AddUserSecrets(this IConfigurationBuilder configuration, bool optional, bool reloadOnChange) @@ -79,7 +79,7 @@ public static IConfigurationBuilder AddUserSecrets(this IConfigurationBuilder /// /// The configuration builder. /// The assembly with the . - /// Thrown when does not have a valid + /// does not have a valid . /// The configuration builder. public static IConfigurationBuilder AddUserSecrets(this IConfigurationBuilder configuration, Assembly assembly) => configuration.AddUserSecrets(assembly, optional: true, reloadOnChange: false); @@ -96,7 +96,7 @@ public static IConfigurationBuilder AddUserSecrets(this IConfigurationBuilder co /// The configuration builder. /// The assembly with the . /// Whether loading secrets is optional. When false, this method may throw. - /// Thrown when is false and does not have a valid . + /// is false and does not have a valid . /// The configuration builder. public static IConfigurationBuilder AddUserSecrets(this IConfigurationBuilder configuration, Assembly assembly, bool optional) => configuration.AddUserSecrets(assembly, optional, reloadOnChange: false); @@ -114,7 +114,7 @@ public static IConfigurationBuilder AddUserSecrets(this IConfigurationBuilder co /// The assembly with the . /// Whether loading secrets is optional. When false, this method may throw. /// Whether the configuration should be reloaded if the file changes. - /// Thrown when is false and does not have a valid . + /// is false and does not have a valid . /// The configuration builder. public static IConfigurationBuilder AddUserSecrets(this IConfigurationBuilder configuration, Assembly assembly, bool optional, bool reloadOnChange) { diff --git a/src/libraries/Microsoft.Extensions.Configuration.UserSecrets/src/UserSecretsIdAttribute.cs b/src/libraries/Microsoft.Extensions.Configuration.UserSecrets/src/UserSecretsIdAttribute.cs index e49752055e4..cad8addf47f 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.UserSecrets/src/UserSecretsIdAttribute.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.UserSecrets/src/UserSecretsIdAttribute.cs @@ -6,15 +6,13 @@ namespace Microsoft.Extensions.Configuration.UserSecrets { /// - /// /// Represents the user secrets ID. - /// - /// + /// + /// /// In most cases, this attribute is automatically generated during compilation by MSBuild targets /// included in the UserSecrets NuGet package. These targets use the MSBuild property 'UserSecretsId' /// to set the value for . - /// - /// + /// [AttributeUsage(AttributeTargets.Assembly, Inherited = false, AllowMultiple = false)] public class UserSecretsIdAttribute : Attribute { @@ -33,7 +31,7 @@ public UserSecretsIdAttribute(string userSecretId) } /// - /// The user secrets ID. + /// Gets the user secrets ID. /// public string UserSecretsId { get; } } diff --git a/src/libraries/Microsoft.Extensions.Configuration.Xml/Microsoft.Extensions.Configuration.Xml.sln b/src/libraries/Microsoft.Extensions.Configuration.Xml/Microsoft.Extensions.Configuration.Xml.sln index e51db2012de..c20e3477587 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Xml/Microsoft.Extensions.Configuration.Xml.sln +++ b/src/libraries/Microsoft.Extensions.Configuration.Xml/Microsoft.Extensions.Configuration.Xml.sln @@ -51,6 +51,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Formats.Asn1", "..\S EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{38A073CB-D9DA-4075-B8A1-57B491AA0CDA}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{040E6662-C94F-4CD9-93F2-F6012BCF05EC}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{03B854C7-609C-4C64-B7EA-266D65E2E548}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{B9613E48-832E-496D-9788-C2304BBEAF1F}" @@ -203,6 +205,10 @@ Global {38A073CB-D9DA-4075-B8A1-57B491AA0CDA}.Debug|Any CPU.Build.0 = Debug|Any CPU {38A073CB-D9DA-4075-B8A1-57B491AA0CDA}.Release|Any CPU.ActiveCfg = Release|Any CPU {38A073CB-D9DA-4075-B8A1-57B491AA0CDA}.Release|Any CPU.Build.0 = Release|Any CPU + {040E6662-C94F-4CD9-93F2-F6012BCF05EC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {040E6662-C94F-4CD9-93F2-F6012BCF05EC}.Debug|Any CPU.Build.0 = Debug|Any CPU + {040E6662-C94F-4CD9-93F2-F6012BCF05EC}.Release|Any CPU.ActiveCfg = Release|Any CPU + {040E6662-C94F-4CD9-93F2-F6012BCF05EC}.Release|Any CPU.Build.0 = Release|Any CPU {03B854C7-609C-4C64-B7EA-266D65E2E548}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {03B854C7-609C-4C64-B7EA-266D65E2E548}.Debug|Any CPU.Build.0 = Debug|Any CPU {03B854C7-609C-4C64-B7EA-266D65E2E548}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -292,6 +298,7 @@ Global {A3C9F01C-6D4D-413B-BADE-A8B9046F985F} = {AB0BAC3A-1FE6-4649-83DF-DC165669C74F} {880064B4-71DF-49DC-B052-38F93DF02527} = {A3D28D8F-E2E7-4A24-A8E6-12C51D7A55E9} {38A073CB-D9DA-4075-B8A1-57B491AA0CDA} = {A3D28D8F-E2E7-4A24-A8E6-12C51D7A55E9} + {040E6662-C94F-4CD9-93F2-F6012BCF05EC} = {A3D28D8F-E2E7-4A24-A8E6-12C51D7A55E9} {03B854C7-609C-4C64-B7EA-266D65E2E548} = {A3D28D8F-E2E7-4A24-A8E6-12C51D7A55E9} {B9613E48-832E-496D-9788-C2304BBEAF1F} = {A3D28D8F-E2E7-4A24-A8E6-12C51D7A55E9} {59DCA8A0-A480-441D-BC20-6BCDDDA7DBBD} = {E8CBBF0B-CA7F-46F8-BBA7-94520481757B} diff --git a/src/libraries/Microsoft.Extensions.Configuration.Xml/src/XmlConfigurationExtensions.cs b/src/libraries/Microsoft.Extensions.Configuration.Xml/src/XmlConfigurationExtensions.cs index 716dc553848..35eb1602a9e 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Xml/src/XmlConfigurationExtensions.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Xml/src/XmlConfigurationExtensions.cs @@ -34,7 +34,7 @@ public static IConfigurationBuilder AddXmlFile(this IConfigurationBuilder builde /// The to add to. /// Path relative to the base path stored in /// of . - /// Whether the file is optional. + /// if the file is optional. /// The . [RequiresDynamicCode(XmlDocumentDecryptor.RequiresDynamicCodeMessage)] [RequiresUnreferencedCode(XmlDocumentDecryptor.RequiresUnreferencedCodeMessage)] @@ -49,7 +49,7 @@ public static IConfigurationBuilder AddXmlFile(this IConfigurationBuilder builde /// The to add to. /// Path relative to the base path stored in /// of . - /// Whether the file is optional. + /// if the file is optional. /// Whether the configuration should be reloaded if the file changes. /// The . [RequiresDynamicCode(XmlDocumentDecryptor.RequiresDynamicCodeMessage)] @@ -60,13 +60,13 @@ public static IConfigurationBuilder AddXmlFile(this IConfigurationBuilder builde } /// - /// Adds a XML configuration source to . + /// Adds an XML configuration source to . /// /// The to add to. /// The to use to access the file. /// Path relative to the base path stored in /// of . - /// Whether the file is optional. + /// if the file is optional. /// Whether the configuration should be reloaded if the file changes. /// The . [RequiresDynamicCode(XmlDocumentDecryptor.RequiresDynamicCodeMessage)] @@ -91,7 +91,7 @@ public static IConfigurationBuilder AddXmlFile(this IConfigurationBuilder builde } /// - /// Adds a XML configuration source to . + /// Adds an XML configuration source to . /// /// The to add to. /// Configures the source. @@ -102,7 +102,7 @@ public static IConfigurationBuilder AddXmlFile(this IConfigurationBuilder builde => builder.Add(configureSource); /// - /// Adds a XML configuration source to . + /// Adds an XML configuration source to . /// /// The to add to. /// The to read the XML configuration data from. diff --git a/src/libraries/Microsoft.Extensions.Configuration.Xml/src/XmlConfigurationProvider.cs b/src/libraries/Microsoft.Extensions.Configuration.Xml/src/XmlConfigurationProvider.cs index 029a24c2a46..0753f30080e 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Xml/src/XmlConfigurationProvider.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Xml/src/XmlConfigurationProvider.cs @@ -7,7 +7,7 @@ namespace Microsoft.Extensions.Configuration.Xml { /// - /// Represents an XML file as an . + /// Provides configuration key-value pairs that are obtained from an XML file. /// [RequiresDynamicCode(XmlDocumentDecryptor.RequiresDynamicCodeMessage)] [RequiresUnreferencedCode(XmlDocumentDecryptor.RequiresUnreferencedCodeMessage)] diff --git a/src/libraries/Microsoft.Extensions.Configuration.Xml/src/XmlDocumentDecryptor.cs b/src/libraries/Microsoft.Extensions.Configuration.Xml/src/XmlDocumentDecryptor.cs index 51bfb352228..24f88d5166d 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Xml/src/XmlDocumentDecryptor.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Xml/src/XmlDocumentDecryptor.cs @@ -11,7 +11,7 @@ namespace Microsoft.Extensions.Configuration.Xml { /// - /// Class responsible for encrypting and decrypting XML. + /// Encrypts and decrypts XML. /// public class XmlDocumentDecryptor { @@ -26,7 +26,7 @@ public class XmlDocumentDecryptor private readonly Func? _encryptedXmlFactory; /// - /// Initializes a XmlDocumentDecryptor. + /// Initializes a new instance of the XmlDocumentDecryptor class. /// // don't create an instance of this directly protected XmlDocumentDecryptor() @@ -96,12 +96,17 @@ public XmlReader CreateDecryptingXmlReader(Stream input, XmlReaderSettings? sett /// Creates a reader that can decrypt an encrypted XML document. /// /// The document. - /// An XmlReader which can read the document. + /// An XmlReader that can read the document. [UnsupportedOSPlatform("browser")] [RequiresDynamicCode(RequiresDynamicCodeMessage)] [RequiresUnreferencedCode(RequiresUnreferencedCodeMessage)] protected virtual XmlReader DecryptDocumentAndCreateXmlReader(XmlDocument document) { +#if !NETSTANDARD2_1 && !NETSTANDARD2_0 && !NETFRAMEWORK // TODO remove with https://github.com/dotnet/runtime/pull/107185 + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); +#else + #pragma warning disable CA1416 +#endif // Perform the actual decryption step, updating the XmlDocument in-place. EncryptedXml encryptedXml = _encryptedXmlFactory?.Invoke(document) ?? new EncryptedXml(document); encryptedXml.DecryptDocument(); diff --git a/src/libraries/Microsoft.Extensions.Configuration.Xml/src/XmlStreamConfigurationProvider.cs b/src/libraries/Microsoft.Extensions.Configuration.Xml/src/XmlStreamConfigurationProvider.cs index b2db3ebc0e3..0dc0eeb48f8 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Xml/src/XmlStreamConfigurationProvider.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Xml/src/XmlStreamConfigurationProvider.cs @@ -12,7 +12,7 @@ namespace Microsoft.Extensions.Configuration.Xml { /// - /// An XML file based . + /// Provides configuration key-value pairs that are obtained from an XML stream. /// [RequiresDynamicCode(XmlDocumentDecryptor.RequiresDynamicCodeMessage)] [RequiresUnreferencedCode(XmlDocumentDecryptor.RequiresUnreferencedCodeMessage)] @@ -25,17 +25,17 @@ internal static class Consts } /// - /// Constructor. + /// Initializes a new instance of the class. /// /// The . public XmlStreamConfigurationProvider(XmlStreamConfigurationSource source) : base(source) { } /// - /// Read a stream of XML values into a key/value dictionary. + /// Reads a stream of XML values into a key/value dictionary. /// /// The stream of XML data. /// The to use to decrypt. - /// The which was read from the stream. + /// The that was read from the stream. public static IDictionary Read(Stream stream, XmlDocumentDecryptor decryptor) { var readerSettings = new XmlReaderSettings() diff --git a/src/libraries/Microsoft.Extensions.Configuration.Xml/src/XmlStreamConfigurationSource.cs b/src/libraries/Microsoft.Extensions.Configuration.Xml/src/XmlStreamConfigurationSource.cs index 8bcaee55545..6d0bafcb56f 100644 --- a/src/libraries/Microsoft.Extensions.Configuration.Xml/src/XmlStreamConfigurationSource.cs +++ b/src/libraries/Microsoft.Extensions.Configuration.Xml/src/XmlStreamConfigurationSource.cs @@ -6,7 +6,7 @@ namespace Microsoft.Extensions.Configuration.Xml { /// - /// Represents a XML file as an . + /// Represents an XML file as an . /// [RequiresDynamicCode(XmlDocumentDecryptor.RequiresDynamicCodeMessage)] [RequiresUnreferencedCode(XmlDocumentDecryptor.RequiresUnreferencedCodeMessage)] @@ -16,7 +16,7 @@ public class XmlStreamConfigurationSource : StreamConfigurationSource /// Builds the for this source. /// /// The . - /// An + /// An . public override IConfigurationProvider Build(IConfigurationBuilder builder) => new XmlStreamConfigurationProvider(this); } diff --git a/src/libraries/Microsoft.Extensions.Configuration/Microsoft.Extensions.Configuration.sln b/src/libraries/Microsoft.Extensions.Configuration/Microsoft.Extensions.Configuration.sln index da81a9a7038..c289efd66fe 100644 --- a/src/libraries/Microsoft.Extensions.Configuration/Microsoft.Extensions.Configuration.sln +++ b/src/libraries/Microsoft.Extensions.Configuration/Microsoft.Extensions.Configuration.sln @@ -83,6 +83,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Memory", "..\System. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{1CAC17CE-D864-4482-9774-F3289F92543A}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{B878181E-BC75-4726-8406-A7F3D290D7C7}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{D937FDF2-45B2-470B-98F0-ED57F768BC31}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{27A201BF-246A-44B2-A018-DF67C8A6DC02}" @@ -315,6 +317,10 @@ Global {1CAC17CE-D864-4482-9774-F3289F92543A}.Debug|Any CPU.Build.0 = Debug|Any CPU {1CAC17CE-D864-4482-9774-F3289F92543A}.Release|Any CPU.ActiveCfg = Release|Any CPU {1CAC17CE-D864-4482-9774-F3289F92543A}.Release|Any CPU.Build.0 = Release|Any CPU + {B878181E-BC75-4726-8406-A7F3D290D7C7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {B878181E-BC75-4726-8406-A7F3D290D7C7}.Debug|Any CPU.Build.0 = Debug|Any CPU + {B878181E-BC75-4726-8406-A7F3D290D7C7}.Release|Any CPU.ActiveCfg = Release|Any CPU + {B878181E-BC75-4726-8406-A7F3D290D7C7}.Release|Any CPU.Build.0 = Release|Any CPU {D937FDF2-45B2-470B-98F0-ED57F768BC31}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {D937FDF2-45B2-470B-98F0-ED57F768BC31}.Debug|Any CPU.Build.0 = Debug|Any CPU {D937FDF2-45B2-470B-98F0-ED57F768BC31}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -456,6 +462,7 @@ Global {CFDBC0E2-792D-4F88-8AB5-978DF8E2167D} = {DC224BF8-12E5-4992-B750-B12011238C26} {63ECC588-0E61-49BF-9E8E-2A2C81AFC192} = {DCF01C23-85A0-4385-B480-D1276ED99A92} {1CAC17CE-D864-4482-9774-F3289F92543A} = {DCF01C23-85A0-4385-B480-D1276ED99A92} + {B878181E-BC75-4726-8406-A7F3D290D7C7} = {DCF01C23-85A0-4385-B480-D1276ED99A92} {D937FDF2-45B2-470B-98F0-ED57F768BC31} = {DCF01C23-85A0-4385-B480-D1276ED99A92} {27A201BF-246A-44B2-A018-DF67C8A6DC02} = {DCF01C23-85A0-4385-B480-D1276ED99A92} {11C8AB75-D137-4A1B-85E5-1018EBFB422B} = {DCF01C23-85A0-4385-B480-D1276ED99A92} diff --git a/src/libraries/Microsoft.Extensions.Configuration/src/ChainedBuilderExtensions.cs b/src/libraries/Microsoft.Extensions.Configuration/src/ChainedBuilderExtensions.cs index f6e013fa1c3..53552dd9bb7 100644 --- a/src/libraries/Microsoft.Extensions.Configuration/src/ChainedBuilderExtensions.cs +++ b/src/libraries/Microsoft.Extensions.Configuration/src/ChainedBuilderExtensions.cs @@ -7,7 +7,7 @@ namespace Microsoft.Extensions.Configuration { /// - /// Extension methods for adding to an . + /// Provides extension methods for adding to an . /// public static class ChainedBuilderExtensions { diff --git a/src/libraries/Microsoft.Extensions.Configuration/src/ChainedConfigurationProvider.cs b/src/libraries/Microsoft.Extensions.Configuration/src/ChainedConfigurationProvider.cs index 4cfe5db2dd1..71a324b6bb8 100644 --- a/src/libraries/Microsoft.Extensions.Configuration/src/ChainedConfigurationProvider.cs +++ b/src/libraries/Microsoft.Extensions.Configuration/src/ChainedConfigurationProvider.cs @@ -8,7 +8,7 @@ namespace Microsoft.Extensions.Configuration { /// - /// Chained implementation of + /// Provides a chained implementation of . /// public class ChainedConfigurationProvider : IConfigurationProvider, IDisposable { @@ -16,7 +16,7 @@ public class ChainedConfigurationProvider : IConfigurationProvider, IDisposable private readonly bool _shouldDisposeConfig; /// - /// Initialize a new instance from the source configuration. + /// Initializes a new instance from the source configuration. /// /// The source configuration. public ChainedConfigurationProvider(ChainedConfigurationSource source) @@ -36,8 +36,8 @@ public ChainedConfigurationProvider(ChainedConfigurationSource source) /// Tries to get a configuration value for the specified key. /// /// The key. - /// The value. - /// True if a value for the specified key was found, otherwise false. + /// When this method returns, contains the value. + /// if a value for the specified key was found, otherwise . public bool TryGet(string key, out string? value) { value = _config[key]; @@ -52,7 +52,7 @@ public bool TryGet(string key, out string? value) public void Set(string key, string? value) => _config[key] = value; /// - /// Returns a change token if this provider supports change tracking, null otherwise. + /// Returns a change token if this provider supports change tracking; otherwise returns . /// /// The change token. public IChangeToken GetReloadToken() => _config.GetReloadToken(); @@ -63,9 +63,9 @@ public bool TryGet(string key, out string? value) public void Load() { } /// - /// Returns the immediate descendant configuration keys for a given parent path based on this - /// s data and the set of keys returned by all the preceding - /// s. + /// Returns the immediate descendant configuration keys for a given parent path based on the data of this + /// and the set of keys returned by all the preceding + /// objects. /// /// The child keys returned by the preceding providers for the same parent path. /// The parent path. diff --git a/src/libraries/Microsoft.Extensions.Configuration/src/ChainedConfigurationSource.cs b/src/libraries/Microsoft.Extensions.Configuration/src/ChainedConfigurationSource.cs index b5a9c68c522..a1500f2e094 100644 --- a/src/libraries/Microsoft.Extensions.Configuration/src/ChainedConfigurationSource.cs +++ b/src/libraries/Microsoft.Extensions.Configuration/src/ChainedConfigurationSource.cs @@ -11,14 +11,14 @@ namespace Microsoft.Extensions.Configuration public class ChainedConfigurationSource : IConfigurationSource { /// - /// The chained configuration. + /// Gets or sets the chained configuration. /// [DisallowNull] public IConfiguration? Configuration { get; set; } /// - /// Whether the chained configuration should be disposed when the - /// configuration provider gets disposed. + /// Gets or sets a value that indicates whether the chained configuration + /// is disposed when the configuration provider is disposed. /// public bool ShouldDisposeConfiguration { get; set; } @@ -26,7 +26,7 @@ public class ChainedConfigurationSource : IConfigurationSource /// Builds the for this source. /// /// The . - /// A + /// A instance. public IConfigurationProvider Build(IConfigurationBuilder builder) => new ChainedConfigurationProvider(this); } diff --git a/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationBuilder.cs b/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationBuilder.cs index dc7f3c536ac..ca558cc1eb7 100644 --- a/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationBuilder.cs +++ b/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationBuilder.cs @@ -7,20 +7,20 @@ namespace Microsoft.Extensions.Configuration { /// - /// Used to build key/value based configuration settings for use in an application. + /// Builds key/value-based configuration settings for use in an application. /// public class ConfigurationBuilder : IConfigurationBuilder { private readonly List _sources = new(); /// - /// Returns the sources used to obtain configuration values. + /// Gets the sources used to obtain configuration values. /// public IList Sources => _sources; /// /// Gets a key/value collection that can be used to share data between the - /// and the registered s. + /// and the registered providers. /// public IDictionary Properties { get; } = new Dictionary(); diff --git a/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationKeyComparer.cs b/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationKeyComparer.cs index 274f4696dd9..d7ece22ed0e 100644 --- a/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationKeyComparer.cs +++ b/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationKeyComparer.cs @@ -7,14 +7,14 @@ namespace Microsoft.Extensions.Configuration { /// - /// IComparer implementation used to order configuration keys. + /// Implements IComparer to order configuration keys. /// public class ConfigurationKeyComparer : IComparer { private const char KeyDelimiter = ':'; /// - /// The default instance. + /// Gets the default instance. /// public static ConfigurationKeyComparer Instance { get; } = new ConfigurationKeyComparer(); diff --git a/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationProvider.cs b/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationProvider.cs index ea73d6041f4..3f39758d25b 100644 --- a/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationProvider.cs +++ b/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationProvider.cs @@ -10,14 +10,14 @@ namespace Microsoft.Extensions.Configuration { /// - /// Base helper class for implementing an + /// Defines the core behavior of configuration providers and provides a base for derived classes. /// public abstract class ConfigurationProvider : IConfigurationProvider { private ConfigurationReloadToken _reloadToken = new ConfigurationReloadToken(); /// - /// Initializes a new + /// Initializes a new . /// protected ConfigurationProvider() { @@ -25,16 +25,16 @@ protected ConfigurationProvider() } /// - /// The configuration key value pairs for this provider. + /// Gets or sets the configuration key-value pairs for this provider. /// protected IDictionary Data { get; set; } /// - /// Attempts to find a value with the given key, returns true if one is found, false otherwise. + /// Attempts to find a value with the given key. /// /// The key to lookup. - /// The value found at key if one is found. - /// True if key has a value, false otherwise. + /// When this method returns, contains the value if one is found. + /// if has a value; otherwise . public virtual bool TryGet(string key, out string? value) => Data.TryGetValue(key, out value); @@ -121,7 +121,7 @@ protected void OnReload() /// /// Generates a string representing this provider name and relevant details. /// - /// The configuration name. + /// The configuration name. public override string ToString() => GetType().Name; } } diff --git a/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationReloadToken.cs b/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationReloadToken.cs index 8168a93dcaf..c6ff23dd938 100644 --- a/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationReloadToken.cs +++ b/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationReloadToken.cs @@ -9,22 +9,22 @@ namespace Microsoft.Extensions.Configuration { /// - /// Implements + /// Propagates notifications that a configuration change has occurred. /// public class ConfigurationReloadToken : IChangeToken { private readonly CancellationTokenSource _cts = new CancellationTokenSource(); /// - /// Indicates if this token will proactively raise callbacks. Callbacks are still guaranteed to be invoked, eventually. + /// Gets a value that indicates whether this token proactively raises callbacks. Callbacks are still guaranteed to be invoked, eventually. /// - /// True if the token will proactively raise callbacks. + /// if the token proactively raises callbacks. public bool ActiveChangeCallbacks { get; private set; } = true; /// /// Gets a value that indicates if a change has occurred. /// - /// True if a change has occurred. + /// if a change has occurred. public bool HasChanged => _cts.IsCancellationRequested; /// @@ -45,7 +45,7 @@ public IDisposable RegisterChangeCallback(Action callback, object? stat } /// - /// Used to trigger the change token when a reload occurs. + /// Triggers the change token when a reload occurs. /// public void OnReload() => _cts.Cancel(); } diff --git a/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationRoot.cs b/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationRoot.cs index d3eefe19f77..50449bb6a21 100644 --- a/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationRoot.cs +++ b/src/libraries/Microsoft.Extensions.Configuration/src/ConfigurationRoot.cs @@ -10,7 +10,7 @@ namespace Microsoft.Extensions.Configuration { /// - /// The root node for a configuration. + /// Represents the root node for a configuration. /// [DebuggerDisplay("{DebuggerToString(),nq}")] [DebuggerTypeProxy(typeof(ConfigurationRootDebugView))] @@ -54,7 +54,7 @@ public string? this[string key] } /// - /// Gets the immediate children sub-sections. + /// Gets the immediate children subsections. /// /// The children. public IEnumerable GetChildren() => this.GetChildrenImplementation(null); @@ -66,19 +66,19 @@ public string? this[string key] public IChangeToken GetReloadToken() => _changeToken; /// - /// Gets a configuration sub-section with the specified key. + /// Gets a configuration subsection with the specified key. /// /// The key of the configuration section. /// The . /// - /// This method will never return null. If no matching sub-section is found with the specified key, - /// an empty will be returned. + /// This method will never return null. If no matching subsection is found with the specified key, + /// an empty is returned. /// public IConfigurationSection GetSection(string key) => new ConfigurationSection(this, key); /// - /// Force the configuration values to be reloaded from the underlying sources. + /// Forces the configuration values to be reloaded from the underlying sources. /// public void Reload() { diff --git a/src/libraries/Microsoft.Extensions.Configuration/src/MemoryConfigurationProvider.cs b/src/libraries/Microsoft.Extensions.Configuration/src/MemoryConfigurationProvider.cs index 4e0774702b1..8eea6ba8da3 100644 --- a/src/libraries/Microsoft.Extensions.Configuration/src/MemoryConfigurationProvider.cs +++ b/src/libraries/Microsoft.Extensions.Configuration/src/MemoryConfigurationProvider.cs @@ -8,7 +8,7 @@ namespace Microsoft.Extensions.Configuration.Memory { /// - /// In-memory implementation of + /// Provides configuration key-value pairs that are obtained from memory. /// public class MemoryConfigurationProvider : ConfigurationProvider, IEnumerable> { @@ -34,7 +34,7 @@ public MemoryConfigurationProvider(MemoryConfigurationSource source) } /// - /// Add a new key and value pair. + /// Adds a new key-value pair. /// /// The configuration key. /// The configuration value. diff --git a/src/libraries/Microsoft.Extensions.Configuration/src/StreamConfigurationProvider.cs b/src/libraries/Microsoft.Extensions.Configuration/src/StreamConfigurationProvider.cs index 58bf27d0482..be9f40a65a3 100644 --- a/src/libraries/Microsoft.Extensions.Configuration/src/StreamConfigurationProvider.cs +++ b/src/libraries/Microsoft.Extensions.Configuration/src/StreamConfigurationProvider.cs @@ -7,19 +7,19 @@ namespace Microsoft.Extensions.Configuration { /// - /// Stream based configuration provider + /// Defines the core behavior of stream-based configuration providers and provides a base for derived classes. /// public abstract class StreamConfigurationProvider : ConfigurationProvider { /// - /// The source settings for this provider. + /// Gets the source settings for this provider. /// public StreamConfigurationSource Source { get; } private bool _loaded; /// - /// Constructor. + /// Initializes a new instance of the class. /// /// The source. public StreamConfigurationProvider(StreamConfigurationSource source) @@ -30,14 +30,17 @@ public StreamConfigurationProvider(StreamConfigurationSource source) } /// - /// Load the configuration data from the stream. + /// Loads the configuration data from the stream. /// /// The data stream. public abstract void Load(Stream stream); /// - /// Load the configuration data from the stream. Will throw after the first call. + /// Loads the configuration data from the stream. /// + /// + /// This method throws an exception on subsequent calls. + /// public override void Load() { if (_loaded) diff --git a/src/libraries/Microsoft.Extensions.Configuration/src/StreamConfigurationSource.cs b/src/libraries/Microsoft.Extensions.Configuration/src/StreamConfigurationSource.cs index f857b9b313d..64f6502aebf 100644 --- a/src/libraries/Microsoft.Extensions.Configuration/src/StreamConfigurationSource.cs +++ b/src/libraries/Microsoft.Extensions.Configuration/src/StreamConfigurationSource.cs @@ -7,12 +7,12 @@ namespace Microsoft.Extensions.Configuration { /// - /// Stream based . + /// Defines the core behavior of stream-based configuration sources and provides a base for derived classes. /// public abstract class StreamConfigurationSource : IConfigurationSource { /// - /// The stream containing the configuration data. + /// Gets or sets the stream containing the configuration data. /// [DisallowNull] public Stream? Stream { get; set; } @@ -21,7 +21,7 @@ public abstract class StreamConfigurationSource : IConfigurationSource /// Builds the for this source. /// /// The . - /// An + /// An instance. public abstract IConfigurationProvider Build(IConfigurationBuilder builder); } } diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/Microsoft.Extensions.DependencyInjection.Abstractions.sln b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/Microsoft.Extensions.DependencyInjection.Abstractions.sln index f7ee598f0f4..067252d4c39 100644 --- a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/Microsoft.Extensions.DependencyInjection.Abstractions.sln +++ b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/Microsoft.Extensions.DependencyInjection.Abstractions.sln @@ -5,7 +5,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Depend EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.DependencyInjection.Abstractions", "src\Microsoft.Extensions.DependencyInjection.Abstractions.csproj", "{D1AEAA98-0D46-4E23-8644-6BD5EBCE32AF}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{DAC5CD72-8A72-40C3-BD9D-703B7CB6FE04}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{F77245FF-79B7-44C9-8C75-CB7D14BC3DB9}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{B7469EEF-415C-485B-9FEC-3D9640400A7B}" EndProject @@ -51,10 +51,10 @@ Global {D1AEAA98-0D46-4E23-8644-6BD5EBCE32AF}.Debug|Any CPU.Build.0 = Debug|Any CPU {D1AEAA98-0D46-4E23-8644-6BD5EBCE32AF}.Release|Any CPU.ActiveCfg = Release|Any CPU {D1AEAA98-0D46-4E23-8644-6BD5EBCE32AF}.Release|Any CPU.Build.0 = Release|Any CPU - {DAC5CD72-8A72-40C3-BD9D-703B7CB6FE04}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {DAC5CD72-8A72-40C3-BD9D-703B7CB6FE04}.Debug|Any CPU.Build.0 = Debug|Any CPU - {DAC5CD72-8A72-40C3-BD9D-703B7CB6FE04}.Release|Any CPU.ActiveCfg = Release|Any CPU - {DAC5CD72-8A72-40C3-BD9D-703B7CB6FE04}.Release|Any CPU.Build.0 = Release|Any CPU + {F77245FF-79B7-44C9-8C75-CB7D14BC3DB9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F77245FF-79B7-44C9-8C75-CB7D14BC3DB9}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F77245FF-79B7-44C9-8C75-CB7D14BC3DB9}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F77245FF-79B7-44C9-8C75-CB7D14BC3DB9}.Release|Any CPU.Build.0 = Release|Any CPU {B7469EEF-415C-485B-9FEC-3D9640400A7B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {B7469EEF-415C-485B-9FEC-3D9640400A7B}.Debug|Any CPU.Build.0 = Debug|Any CPU {B7469EEF-415C-485B-9FEC-3D9640400A7B}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -87,7 +87,7 @@ Global {F170EDB3-E92B-456A-8749-F3ACE3471510} = {09E0C315-2A88-4F30-93DA-E22625BF82AB} {D1AEAA98-0D46-4E23-8644-6BD5EBCE32AF} = {09E0C315-2A88-4F30-93DA-E22625BF82AB} {B8B63EFF-64D9-49AB-ACE9-6182DADC7574} = {C494A755-24D9-4E80-AEC3-CF8FEBAFCAC6} - {DAC5CD72-8A72-40C3-BD9D-703B7CB6FE04} = {BF723277-314D-45F4-B29A-6A8683860A93} + {F77245FF-79B7-44C9-8C75-CB7D14BC3DB9} = {BF723277-314D-45F4-B29A-6A8683860A93} {B7469EEF-415C-485B-9FEC-3D9640400A7B} = {BF723277-314D-45F4-B29A-6A8683860A93} {C1EC51FB-C819-4CC5-9600-42CCE195DE78} = {83FB9805-C27B-4039-A30D-7010422CCDCE} {A3FEEE13-7E52-4C07-B34E-2E038FC8D401} = {83FB9805-C27B-4039-A30D-7010422CCDCE} diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/ref/Microsoft.Extensions.DependencyInjection.Abstractions.cs b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/ref/Microsoft.Extensions.DependencyInjection.Abstractions.cs index c9b3d241f0f..dfb07e7ea9b 100644 --- a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/ref/Microsoft.Extensions.DependencyInjection.Abstractions.cs +++ b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/ref/Microsoft.Extensions.DependencyInjection.Abstractions.cs @@ -218,6 +218,7 @@ public static partial class ServiceProviderKeyedServiceExtensions public static System.Collections.Generic.IEnumerable GetKeyedServices(this System.IServiceProvider provider, System.Type serviceType, object? serviceKey) { throw null; } public static System.Collections.Generic.IEnumerable GetKeyedServices(this System.IServiceProvider provider, object? serviceKey) { throw null; } public static T? GetKeyedService(this System.IServiceProvider provider, object? serviceKey) { throw null; } + public static object? GetKeyedService(this System.IServiceProvider provider, System.Type serviceType, object? serviceKey) { throw null; } public static object GetRequiredKeyedService(this System.IServiceProvider provider, System.Type serviceType, object? serviceKey) { throw null; } public static T GetRequiredKeyedService(this System.IServiceProvider provider, object? serviceKey) where T : notnull { throw null; } } diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/ActivatorUtilities.cs b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/ActivatorUtilities.cs index 9789a7ecaff..e61a1c90403 100644 --- a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/ActivatorUtilities.cs +++ b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/ActivatorUtilities.cs @@ -38,12 +38,12 @@ public static class ActivatorUtilities new Func(GetService).Method; /// - /// Instantiate a type with constructor arguments provided directly and/or from an . + /// Instantiates a type with constructor arguments provided directly and/or from an . /// - /// The service provider used to resolve dependencies - /// The type to activate + /// The service provider used to resolve dependencies. + /// The type to activate. /// Constructor arguments not provided by the . - /// An activated object of type instanceType + /// An activated object of type instanceType. public static object CreateInstance( IServiceProvider provider, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type instanceType, @@ -262,16 +262,16 @@ private static ConstructorInfoEx[] CreateConstructorInfoExs( } /// - /// Create a delegate that will instantiate a type with constructor arguments provided directly + /// Creates a delegate that will instantiate a type with constructor arguments provided directly /// and/or from an . /// - /// The type to activate + /// The type to activate. /// - /// The types of objects, in order, that will be passed to the returned function as its second parameter + /// The types of objects, in order, that will be passed to the returned function as its second parameter. /// /// /// A factory that will instantiate instanceType using an - /// and an argument array containing objects matching the types defined in argumentTypes + /// and an argument array containing objects matching the types defined in argumentTypes. /// public static ObjectFactory CreateFactory( [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type instanceType, @@ -291,24 +291,24 @@ public static ObjectFactory CreateFactory( #endif CreateFactoryInternal(instanceType, argumentTypes, out ParameterExpression provider, out ParameterExpression argumentArray, out Expression factoryExpressionBody); - var factoryLambda = Expression.Lambda>( + var factoryLambda = Expression.Lambda( factoryExpressionBody, provider, argumentArray); - Func? result = factoryLambda.Compile(); - return result.Invoke; + ObjectFactory? result = factoryLambda.Compile(); + return result; } /// - /// Create a delegate that will instantiate a type with constructor arguments provided directly + /// Creates a delegate that will instantiate a type with constructor arguments provided directly /// and/or from an . /// - /// The type to activate + /// The type to activate. /// - /// The types of objects, in order, that will be passed to the returned function as its second parameter + /// The types of objects, in order, that will be passed to the returned function as its second parameter. /// /// - /// A factory that will instantiate type T using an - /// and an argument array containing objects matching the types defined in argumentTypes + /// A factory that will instantiate type using an + /// and an argument array containing objects matching the types defined in . /// public static ObjectFactory CreateFactory<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] T>( @@ -324,11 +324,11 @@ public static ObjectFactory #endif CreateFactoryInternal(typeof(T), argumentTypes, out ParameterExpression provider, out ParameterExpression argumentArray, out Expression factoryExpressionBody); - var factoryLambda = Expression.Lambda>( + var factoryLambda = Expression.Lambda>( factoryExpressionBody, provider, argumentArray); - Func? result = factoryLambda.Compile(); - return result.Invoke; + ObjectFactory? result = factoryLambda.Compile(); + return result; } private static void CreateFactoryInternal([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type instanceType, Type[] argumentTypes, out ParameterExpression provider, out ParameterExpression argumentArray, out Expression factoryExpressionBody) @@ -341,12 +341,12 @@ private static void CreateFactoryInternal([DynamicallyAccessedMembers(Dynamicall } /// - /// Instantiate a type with constructor arguments provided directly and/or from an . + /// Instantiates a type with constructor arguments provided directly and/or from an . /// - /// The type to activate - /// The service provider used to resolve dependencies - /// Constructor arguments not provided by the . - /// An activated object of type T + /// The type to activate. + /// The service provider used to resolve dependencies. + /// Constructor arguments not provided by . + /// An activated object of type . public static T CreateInstance<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] T>(IServiceProvider provider, params object[] parameters) { return (T)CreateInstance(provider, typeof(T), parameters); @@ -355,9 +355,9 @@ private static void CreateFactoryInternal([DynamicallyAccessedMembers(Dynamicall /// /// Retrieve an instance of the given type from the service provider. If one is not found then instantiate it directly. /// - /// The type of the service - /// The service provider used to resolve dependencies - /// The resolved service or created instance + /// The type of the service. + /// The service provider used to resolve dependencies. + /// The resolved service or created instance. public static T GetServiceOrCreateInstance<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] T>(IServiceProvider provider) { return (T)GetServiceOrCreateInstance(provider, typeof(T)); @@ -366,9 +366,9 @@ private static void CreateFactoryInternal([DynamicallyAccessedMembers(Dynamicall /// /// Retrieve an instance of the given type from the service provider. If one is not found then instantiate it directly. /// - /// The service provider - /// The type of the service - /// The resolved service or created instance + /// The service provider. + /// The type of the service. + /// The resolved service or created instance. public static object GetServiceOrCreateInstance( IServiceProvider provider, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type type) diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IKeyedServiceProvider.cs b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IKeyedServiceProvider.cs index af025a5bf6a..3527adac431 100644 --- a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IKeyedServiceProvider.cs +++ b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IKeyedServiceProvider.cs @@ -6,8 +6,7 @@ namespace Microsoft.Extensions.DependencyInjection { /// - /// IKeyedServiceProvider is a service provider that can be used to retrieve services using a key in addition - /// to a type. + /// Retrieves services using a key and a type. /// public interface IKeyedServiceProvider : IServiceProvider { @@ -16,7 +15,9 @@ public interface IKeyedServiceProvider : IServiceProvider /// /// An object that specifies the type of service object to get. /// An object that specifies the key of service object to get. - /// A service object of type serviceType. -or- null if there is no service object of type serviceType. + /// A service object of type . + /// -or- + /// if there is no service object of type . object? GetKeyedService(Type serviceType, object? serviceKey); /// @@ -31,12 +32,12 @@ public interface IKeyedServiceProvider : IServiceProvider } /// - /// Statics for use with . + /// Provides static APIs for use with . /// public static class KeyedService { /// - /// Represents a key that matches any key. + /// Gets a key that matches any key. /// public static object AnyKey { get; } = new AnyKeyObj(); diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IServiceProviderFactory.cs b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IServiceProviderFactory.cs index 35854cc836b..8ea9bc282c8 100644 --- a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IServiceProviderFactory.cs +++ b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IServiceProviderFactory.cs @@ -13,15 +13,15 @@ public interface IServiceProviderFactory where TContainerBuil /// /// Creates a container builder from an . /// - /// The collection of services + /// The collection of services. /// A container builder that can be used to create an . TContainerBuilder CreateBuilder(IServiceCollection services); /// /// Creates an from the container builder. /// - /// The container builder - /// An + /// The container builder. + /// An instance. IServiceProvider CreateServiceProvider(TContainerBuilder containerBuilder); } } diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IServiceProviderIsKeyedService.cs b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IServiceProviderIsKeyedService.cs index 1517011a67b..d0d852900aa 100644 --- a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IServiceProviderIsKeyedService.cs +++ b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IServiceProviderIsKeyedService.cs @@ -6,7 +6,7 @@ namespace Microsoft.Extensions.DependencyInjection { /// - /// Optional service used to determine if the specified type with the specified service key is available + /// Provides methods to determine if the specified type with the specified service key is available /// from the . /// public interface IServiceProviderIsKeyedService : IServiceProviderIsService diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IServiceProviderIsService.cs b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IServiceProviderIsService.cs index b24ab154d16..1fb7236ad48 100644 --- a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IServiceProviderIsService.cs +++ b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IServiceProviderIsService.cs @@ -6,7 +6,7 @@ namespace Microsoft.Extensions.DependencyInjection { /// - /// Optional service used to determine if the specified type is available from the . + /// Provides methods to determine if the specified type is available from the . /// public interface IServiceProviderIsService { diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IServiceScope.cs b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IServiceScope.cs index e83a33dde92..803e96d9fd0 100644 --- a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IServiceScope.cs +++ b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IServiceScope.cs @@ -6,15 +6,18 @@ namespace Microsoft.Extensions.DependencyInjection { /// + /// Defines a disposable service scope. + /// + /// /// The method ends the scope lifetime. Once Dispose /// is called, any scoped services that have been resolved from /// will be /// disposed. - /// + /// public interface IServiceScope : IDisposable { /// - /// The used to resolve dependencies from the scope. + /// Gets the used to resolve dependencies from the scope. /// IServiceProvider ServiceProvider { get; } } diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IServiceScopeFactory.cs b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IServiceScopeFactory.cs index 9d9aede9003..7b3b97ec722 100644 --- a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IServiceScopeFactory.cs +++ b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/IServiceScopeFactory.cs @@ -4,13 +4,13 @@ namespace Microsoft.Extensions.DependencyInjection { /// - /// A factory for creating instances of , which is used to create + /// Creates instances of , which is used to create /// services within a scope. /// public interface IServiceScopeFactory { /// - /// Create an which + /// Create an that /// contains an used to resolve dependencies from a /// newly created scope. /// diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/ObjectFactoryT.cs b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/ObjectFactoryT.cs index 52ec33f8dc7..b5a1e25980a 100644 --- a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/ObjectFactoryT.cs +++ b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/ObjectFactoryT.cs @@ -6,11 +6,11 @@ namespace Microsoft.Extensions.DependencyInjection { /// - /// The result of . A delegate to specify a factory method to call to instantiate an instance of type `T` + /// Returns the result of , which is a delegate that specifies a factory method to call to instantiate an instance of type . /// - /// The type of the instance being returned + /// The type of the instance that's returned. /// The to get service arguments from. /// Additional constructor arguments. - /// An instance of T + /// An instance of type . public delegate T ObjectFactory(IServiceProvider serviceProvider, object?[]? arguments); } diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/ServiceKeyAttribute.cs b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/ServiceKeyAttribute.cs index eccdd34b48b..b60e0de42a6 100644 --- a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/ServiceKeyAttribute.cs +++ b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/ServiceKeyAttribute.cs @@ -6,8 +6,7 @@ namespace Microsoft.Extensions.DependencyInjection { /// - /// ServiceKeyAttribute can be specified on a parameter to inject the key that was used for - /// registration/resolution. + /// Specifies the parameter to inject the key that was used for registration or resolution. /// [AttributeUsage(AttributeTargets.Parameter)] public class ServiceKeyAttribute : Attribute diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/ServiceProviderKeyedServiceExtensions.cs b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/ServiceProviderKeyedServiceExtensions.cs index 4ae52a0e9ed..03075fbc9c2 100644 --- a/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/ServiceProviderKeyedServiceExtensions.cs +++ b/src/libraries/Microsoft.Extensions.DependencyInjection.Abstractions/src/ServiceProviderKeyedServiceExtensions.cs @@ -31,6 +31,26 @@ public static class ServiceProviderKeyedServiceExtensions throw new InvalidOperationException(SR.KeyedServicesNotSupported); } + /// + /// Get service of type from the . + /// + /// The to retrieve the service object from. + /// An object that specifies the type of service object to get. + /// An object that specifies the key of service object to get. + /// A service object of type or null if there is no such service. + public static object? GetKeyedService(this IServiceProvider provider, Type serviceType, object? serviceKey) + { + ThrowHelper.ThrowIfNull(provider); + ThrowHelper.ThrowIfNull(serviceType); + + if (provider is IKeyedServiceProvider keyedServiceProvider) + { + return keyedServiceProvider.GetKeyedService(serviceType, serviceKey); + } + + throw new InvalidOperationException(SR.KeyedServicesNotSupported); + } + /// /// Get service of type from the . /// diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection.Specification.Tests/src/KeyedDependencyInjectionSpecificationTests.cs b/src/libraries/Microsoft.Extensions.DependencyInjection.Specification.Tests/src/KeyedDependencyInjectionSpecificationTests.cs index 8916a906d85..ee7daad0be7 100644 --- a/src/libraries/Microsoft.Extensions.DependencyInjection.Specification.Tests/src/KeyedDependencyInjectionSpecificationTests.cs +++ b/src/libraries/Microsoft.Extensions.DependencyInjection.Specification.Tests/src/KeyedDependencyInjectionSpecificationTests.cs @@ -27,6 +27,10 @@ public void ResolveKeyedService() Assert.Null(provider.GetService()); Assert.Same(service1, provider.GetKeyedService("service1")); Assert.Same(service2, provider.GetKeyedService("service2")); + + Assert.Null(provider.GetService(typeof(IService))); + Assert.Same(service1, provider.GetKeyedService(typeof(IService), "service1")); + Assert.Same(service2, provider.GetKeyedService(typeof(IService), "service2")); } [Fact] @@ -39,10 +43,12 @@ public void ResolveNullKeyedService() var provider = CreateServiceProvider(serviceCollection); var nonKeyed = provider.GetService(); - var nullKey = provider.GetKeyedService(null); + var nullKeyOfT = provider.GetKeyedService(null); + var nullKeyOfType = provider.GetKeyedService(typeof(IService), null); Assert.Same(service1, nonKeyed); - Assert.Same(service1, nullKey); + Assert.Same(service1, nullKeyOfT); + Assert.Same(service1, nullKeyOfType); } [Fact] @@ -192,6 +198,7 @@ public void ResolveKeyedServiceSingletonInstance() Assert.Null(provider.GetService()); Assert.Same(service, provider.GetKeyedService("service1")); + Assert.Same(service, provider.GetKeyedService(typeof(IService), "service1")); } [Fact] @@ -355,6 +362,7 @@ public void ResolveKeyedServiceSingletonFactory() Assert.Null(provider.GetService()); Assert.Same(service, provider.GetKeyedService("service1")); + Assert.Same(service, provider.GetKeyedService(typeof(IService), "service1")); } [Fact] @@ -388,6 +396,7 @@ public void ResolveKeyedServiceSingletonFactoryWithAnyKeyIgnoreWrongType() Assert.Null(provider.GetService()); Assert.NotNull(provider.GetKeyedService(87)); Assert.ThrowsAny(() => provider.GetKeyedService(new object())); + Assert.ThrowsAny(() => provider.GetKeyedService(typeof(IService), new object())); } [Fact] @@ -554,6 +563,20 @@ public void ResolveKeyedTransientFromScopeServiceProvider() Assert.NotSame(serviceA1, serviceB1); } + [Fact] + public void ResolveKeyedServiceThrowsIfNotSupported() + { + var provider = new NonKeyedServiceProvider(); + var serviceKey = new object(); + + Assert.Throws(() => provider.GetKeyedService(serviceKey)); + Assert.Throws(() => provider.GetKeyedService(typeof(IService), serviceKey)); + Assert.Throws(() => provider.GetKeyedServices(serviceKey)); + Assert.Throws(() => provider.GetKeyedServices(typeof(IService), serviceKey)); + Assert.Throws(() => provider.GetRequiredKeyedService(serviceKey)); + Assert.Throws(() => provider.GetRequiredKeyedService(typeof(IService), serviceKey)); + } + public interface IService { } public class Service : IService @@ -664,5 +687,10 @@ public interface ISimpleService { } public class SimpleService : ISimpleService { } public class AnotherSimpleService : ISimpleService { } + + public class NonKeyedServiceProvider : IServiceProvider + { + public object GetService(Type serviceType) => throw new NotImplementedException(); + } } } diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection.Specification.Tests/src/Microsoft.Extensions.DependencyInjection.Specification.Tests.csproj b/src/libraries/Microsoft.Extensions.DependencyInjection.Specification.Tests/src/Microsoft.Extensions.DependencyInjection.Specification.Tests.csproj index 05abed41e1c..3257a2ecfc6 100644 --- a/src/libraries/Microsoft.Extensions.DependencyInjection.Specification.Tests/src/Microsoft.Extensions.DependencyInjection.Specification.Tests.csproj +++ b/src/libraries/Microsoft.Extensions.DependencyInjection.Specification.Tests/src/Microsoft.Extensions.DependencyInjection.Specification.Tests.csproj @@ -15,8 +15,6 @@ Suite of xUnit.net tests to check for container compatibility with Microsoft.Extensions.DependencyInjection. false - - false diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection.Specification.Tests/src/PACKAGE.md b/src/libraries/Microsoft.Extensions.DependencyInjection.Specification.Tests/src/PACKAGE.md new file mode 100644 index 00000000000..2565bb26d5f --- /dev/null +++ b/src/libraries/Microsoft.Extensions.DependencyInjection.Specification.Tests/src/PACKAGE.md @@ -0,0 +1,68 @@ +## About + +Provides a suite of xUnit.net tests designed to ensure compatibility with the `Microsoft.Extensions.DependencyInjection` framework. + +This package is intended for developers implementing their own Dependency Injection (DI) containers, allowing them to verify that their implementations conform to the expected behavior of the Microsoft Dependency Injection framework. + +## Key Features + + + +* Comprehensive suite of tests to validate DI container compatibility with the Microsoft Dependency Injection framework. +* Includes fakes and mocks (`Microsoft.Extensions.DependencyInjection.Specification.Fakes`) for testing common scenarios. + +## How to Use + + + +To utilize the `Microsoft.Extensions.DependencyInjection.Specification.Tests` in a custom DI container implementation, create a test project and include this package as a dependency. +Then, run the specification tests against the DI container to validate its compatibility with the `Microsoft.Extensions.DependencyInjection` framework. + +1. Start by creating a test project to run the specification tests. +2. Add the following NuGet packages to the test project: + + * Microsoft.Extensions.DependencyInjection.Specification.Tests + * xunit + +3. Add the custom DI container package (e.g., `MyCustomDI`) +4. In the test project, create a class that inherits from `DependencyInjectionSpecificationTests` provided by the `Microsoft.Extensions.DependencyInjection.Specification.Tests` package. + + Override the `CreateServiceProvider` method to return an instance of the DI container's service provider. + + ```csharp + using Microsoft.Extensions.DependencyInjection; + using Microsoft.Extensions.DependencyInjection.Specification.Tests; + using Xunit; + using MyCustomDI; + + public class MyCustomDIContainerTests : DependencyInjectionSpecificationTests + { + protected override IServiceProvider CreateServiceProvider(IServiceCollection serviceCollection) + { + // Create an instance of your custom DI container and build the service provider + return MyCustomDIContainer.BuildServiceProvider(serviceCollection); + } + } + ``` + +5. Run the tests to validate that the custom DI container behaves according to the Microsoft Dependency Injection specifications. + +## Main Types + + + +The main types provided by this library are: + +* `Microsoft.Extensions.DependencyInjection.Specification.DependencyInjectionSpecificationTests` +* `Microsoft.Extensions.DependencyInjection.Specification.KeyedDependencyInjectionSpecificationTests` + + + + + +## Feedback & Contributing + + + +Microsoft.Extensions.DependencyInjection.Specification.Tests is released as open source under the [MIT license](https://licenses.nuget.org/MIT). +Bug reports and contributions are welcome at [the GitHub repository](https://github.com/dotnet/runtime). diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/Microsoft.Extensions.DependencyInjection.sln b/src/libraries/Microsoft.Extensions.DependencyInjection/Microsoft.Extensions.DependencyInjection.sln index 3a32a185ff3..31a6a2c8334 100644 --- a/src/libraries/Microsoft.Extensions.DependencyInjection/Microsoft.Extensions.DependencyInjection.sln +++ b/src/libraries/Microsoft.Extensions.DependencyInjection/Microsoft.Extensions.DependencyInjection.sln @@ -19,7 +19,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Depend EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.DependencyInjection.Tests", "tests\DI.Tests\Microsoft.Extensions.DependencyInjection.Tests.csproj", "{1EE6CA66-6585-459D-8889-666D4C2D4C27}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{FD3C8D4F-0EAA-4575-A685-F77C6D340E60}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{B667E66C-2E5E-4698-8011-2BA37EDD9D16}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{9E5124E4-BEDA-4B2D-9699-60E2A7B1881D}" EndProject @@ -95,10 +95,10 @@ Global {1EE6CA66-6585-459D-8889-666D4C2D4C27}.Debug|Any CPU.Build.0 = Debug|Any CPU {1EE6CA66-6585-459D-8889-666D4C2D4C27}.Release|Any CPU.ActiveCfg = Release|Any CPU {1EE6CA66-6585-459D-8889-666D4C2D4C27}.Release|Any CPU.Build.0 = Release|Any CPU - {FD3C8D4F-0EAA-4575-A685-F77C6D340E60}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {FD3C8D4F-0EAA-4575-A685-F77C6D340E60}.Debug|Any CPU.Build.0 = Debug|Any CPU - {FD3C8D4F-0EAA-4575-A685-F77C6D340E60}.Release|Any CPU.ActiveCfg = Release|Any CPU - {FD3C8D4F-0EAA-4575-A685-F77C6D340E60}.Release|Any CPU.Build.0 = Release|Any CPU + {B667E66C-2E5E-4698-8011-2BA37EDD9D16}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {B667E66C-2E5E-4698-8011-2BA37EDD9D16}.Debug|Any CPU.Build.0 = Debug|Any CPU + {B667E66C-2E5E-4698-8011-2BA37EDD9D16}.Release|Any CPU.ActiveCfg = Release|Any CPU + {B667E66C-2E5E-4698-8011-2BA37EDD9D16}.Release|Any CPU.Build.0 = Release|Any CPU {9E5124E4-BEDA-4B2D-9699-60E2A7B1881D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {9E5124E4-BEDA-4B2D-9699-60E2A7B1881D}.Debug|Any CPU.Build.0 = Debug|Any CPU {9E5124E4-BEDA-4B2D-9699-60E2A7B1881D}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -138,7 +138,7 @@ Global {C5ECD02C-FA5A-4B56-9CA2-47AD8989714A} = {74C4FAFF-491D-448C-8CA0-F8E5FC838CC5} {6D90C067-5CCD-4443-81A5-B9C385011F68} = {E168C5B8-F2EB-4BDE-942A-59C1EB130D59} {66E6ADF5-200F-41F3-9CA4-858EF69D2A61} = {E168C5B8-F2EB-4BDE-942A-59C1EB130D59} - {FD3C8D4F-0EAA-4575-A685-F77C6D340E60} = {28065F40-B930-4A5D-95D8-A3BD5F86CE11} + {B667E66C-2E5E-4698-8011-2BA37EDD9D16} = {28065F40-B930-4A5D-95D8-A3BD5F86CE11} {9E5124E4-BEDA-4B2D-9699-60E2A7B1881D} = {28065F40-B930-4A5D-95D8-A3BD5F86CE11} {C85FD264-C77B-44F3-926C-D61C5DAD369E} = {0B56ECAF-7B4A-4135-A343-1577ACE09920} {A2CD66D3-74F2-4608-A56E-F866CC494620} = {0B56ECAF-7B4A-4135-A343-1577ACE09920} diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/src/ILLink/ILLink.Substitutions.xml b/src/libraries/Microsoft.Extensions.DependencyInjection/src/ILLink/ILLink.Substitutions.xml deleted file mode 100644 index 6aa354ee236..00000000000 --- a/src/libraries/Microsoft.Extensions.DependencyInjection/src/ILLink/ILLink.Substitutions.xml +++ /dev/null @@ -1,10 +0,0 @@ - - - - - - - - - - diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/src/Microsoft.Extensions.DependencyInjection.csproj b/src/libraries/Microsoft.Extensions.DependencyInjection/src/Microsoft.Extensions.DependencyInjection.csproj index 6dc4c5cd9ce..21e3e191946 100644 --- a/src/libraries/Microsoft.Extensions.DependencyInjection/src/Microsoft.Extensions.DependencyInjection.csproj +++ b/src/libraries/Microsoft.Extensions.DependencyInjection/src/Microsoft.Extensions.DependencyInjection.csproj @@ -18,10 +18,6 @@ '$(ILEmitBackendSaveAssemblies)' == 'true'">$(DefineConstants);SAVE_ASSEMBLIES - - - - @@ -47,6 +43,10 @@ + + + + diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/Expressions/ExpressionResolverBuilder.cs b/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/Expressions/ExpressionResolverBuilder.cs index 670c62ee2f6..dd6db1467ee 100644 --- a/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/Expressions/ExpressionResolverBuilder.cs +++ b/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceLookup/Expressions/ExpressionResolverBuilder.cs @@ -32,6 +32,7 @@ internal sealed class ExpressionResolverBuilder : CallSiteVisitor), Expression.Call(ScopeParameter, ServiceLookupHelpers.CaptureDisposableMethodInfo, CaptureDisposableParameter), CaptureDisposableParameter); diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceProvider.cs b/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceProvider.cs index ff5efbe98cf..d3177c229e3 100644 --- a/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceProvider.cs +++ b/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceProvider.cs @@ -34,9 +34,11 @@ public sealed class ServiceProvider : IServiceProvider, IKeyedServiceProvider, I internal ServiceProviderEngineScope Root { get; } + [FeatureSwitchDefinition("Microsoft.Extensions.DependencyInjection.VerifyOpenGenericServiceTrimmability")] internal static bool VerifyOpenGenericServiceTrimmability { get; } = AppContext.TryGetSwitch("Microsoft.Extensions.DependencyInjection.VerifyOpenGenericServiceTrimmability", out bool verifyOpenGenerics) ? verifyOpenGenerics : false; + [FeatureSwitchDefinition("Microsoft.Extensions.DependencyInjection.DisableDynamicEngine")] internal static bool DisableDynamicEngine { get; } = AppContext.TryGetSwitch("Microsoft.Extensions.DependencyInjection.DisableDynamicEngine", out bool disableDynamicEngine) ? disableDynamicEngine : false; @@ -113,12 +115,12 @@ internal ServiceProvider(ICollection serviceDescriptors, Serv => GetService(new ServiceIdentifier(serviceKey, serviceType), serviceProviderEngineScope); /// - /// Gets the service object of the specified type. Will throw if the service not found. + /// Gets the service object of the specified type. /// /// The type of the service to get. /// The key of the service to get. /// The keyed service. - /// + /// The service wasn't found. public object GetRequiredKeyedService(Type serviceType, object? serviceKey) => GetRequiredKeyedService(serviceType, serviceKey, Root); diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceProviderOptions.cs b/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceProviderOptions.cs index 4cb165bf9c4..09c75aaeee2 100644 --- a/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceProviderOptions.cs +++ b/src/libraries/Microsoft.Extensions.DependencyInjection/src/ServiceProviderOptions.cs @@ -14,14 +14,16 @@ public class ServiceProviderOptions internal static readonly ServiceProviderOptions Default = new ServiceProviderOptions(); /// - /// true to perform check verifying that scoped services never gets resolved from root provider; otherwise false. Defaults to false. + /// Gets or sets a value that indicates whether validation is performed to ensure that scoped services are never resolved from the root provider. /// public bool ValidateScopes { get; set; } /// - /// true to perform check verifying that all services can be created during BuildServiceProvider call; otherwise false. Defaults to false. - /// NOTE: this check doesn't verify open generics services. + /// Gets or sets a value that indicates whether validation is performed to ensure all services can be created when is called. /// + /// + /// Open generics services aren't validated. + /// public bool ValidateOnBuild { get; set; } } } diff --git a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/ServiceProviderContainerTests.cs b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/ServiceProviderContainerTests.cs index 8bcaa9240f6..94802673078 100644 --- a/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/ServiceProviderContainerTests.cs +++ b/src/libraries/Microsoft.Extensions.DependencyInjection/tests/DI.Tests/ServiceProviderContainerTests.cs @@ -392,10 +392,10 @@ public void GetAsyncService_DisposeAsyncOnSameThread_ThrowsAndDoesNotHangAndDisp var service = sp.GetRequiredService(); }); }); - }).Wait(TimeSpan.FromSeconds(10)); + }).Wait(TimeSpan.FromSeconds(20)); - Assert.True(doesNotHang); - Assert.True(asyncDisposableResource.DisposeAsyncCalled); + Assert.True(doesNotHang, "!doesNotHang"); + Assert.True(asyncDisposableResource.DisposeAsyncCalled, "!DisposeAsyncCalled"); } [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))] diff --git a/src/libraries/Microsoft.Extensions.DependencyModel/Microsoft.Extensions.DependencyModel.sln b/src/libraries/Microsoft.Extensions.DependencyModel/Microsoft.Extensions.DependencyModel.sln index 3220c6925a9..d98e46032be 100644 --- a/src/libraries/Microsoft.Extensions.DependencyModel/Microsoft.Extensions.DependencyModel.sln +++ b/src/libraries/Microsoft.Extensions.DependencyModel/Microsoft.Extensions.DependencyModel.sln @@ -23,6 +23,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Memory", "..\System. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{FA796FCD-5901-407B-BF40-166169718A0F}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{C4382A2D-8765-4823-B53E-5FAE7539320F}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{7B4B86A8-EF62-45F0-A431-05F4C11A2E0D}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{6F992337-EAEE-4F7A-BF3B-DDC526F054F7}" @@ -125,6 +127,10 @@ Global {FA796FCD-5901-407B-BF40-166169718A0F}.Debug|Any CPU.Build.0 = Debug|Any CPU {FA796FCD-5901-407B-BF40-166169718A0F}.Release|Any CPU.ActiveCfg = Release|Any CPU {FA796FCD-5901-407B-BF40-166169718A0F}.Release|Any CPU.Build.0 = Release|Any CPU + {C4382A2D-8765-4823-B53E-5FAE7539320F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {C4382A2D-8765-4823-B53E-5FAE7539320F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C4382A2D-8765-4823-B53E-5FAE7539320F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {C4382A2D-8765-4823-B53E-5FAE7539320F}.Release|Any CPU.Build.0 = Release|Any CPU {7B4B86A8-EF62-45F0-A431-05F4C11A2E0D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {7B4B86A8-EF62-45F0-A431-05F4C11A2E0D}.Debug|Any CPU.Build.0 = Debug|Any CPU {7B4B86A8-EF62-45F0-A431-05F4C11A2E0D}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -211,6 +217,7 @@ Global {50F89560-1449-44E4-844E-72815256534B} = {50BA55F5-BD05-4C05-910F-2BFD20BD3465} {8E212A9D-391B-4EFA-943D-7D104A9D3D7E} = {50BA55F5-BD05-4C05-910F-2BFD20BD3465} {FA796FCD-5901-407B-BF40-166169718A0F} = {55D04C80-4A8F-40AC-967D-3FA77C814D7B} + {C4382A2D-8765-4823-B53E-5FAE7539320F} = {55D04C80-4A8F-40AC-967D-3FA77C814D7B} {7B4B86A8-EF62-45F0-A431-05F4C11A2E0D} = {55D04C80-4A8F-40AC-967D-3FA77C814D7B} {6F992337-EAEE-4F7A-BF3B-DDC526F054F7} = {55D04C80-4A8F-40AC-967D-3FA77C814D7B} {240E7B1C-6D7D-4932-9598-815C2EA420AF} = {55D04C80-4A8F-40AC-967D-3FA77C814D7B} diff --git a/src/libraries/Microsoft.Extensions.DependencyModel/src/Microsoft.Extensions.DependencyModel.csproj b/src/libraries/Microsoft.Extensions.DependencyModel/src/Microsoft.Extensions.DependencyModel.csproj index ab700f9cadc..b730684c2c0 100644 --- a/src/libraries/Microsoft.Extensions.DependencyModel/src/Microsoft.Extensions.DependencyModel.csproj +++ b/src/libraries/Microsoft.Extensions.DependencyModel/src/Microsoft.Extensions.DependencyModel.csproj @@ -19,7 +19,7 @@ By default, the dependency manifest contains information about the application's - + @@ -27,10 +27,10 @@ By default, the dependency manifest contains information about the application's - + - + @@ -43,5 +43,5 @@ By default, the dependency manifest contains information about the application's - + diff --git a/src/libraries/Microsoft.Extensions.Diagnostics.Abstractions/Microsoft.Extensions.Diagnostics.Abstractions.sln b/src/libraries/Microsoft.Extensions.Diagnostics.Abstractions/Microsoft.Extensions.Diagnostics.Abstractions.sln index 740065aa292..1925f266ee4 100644 --- a/src/libraries/Microsoft.Extensions.Diagnostics.Abstractions/Microsoft.Extensions.Diagnostics.Abstractions.sln +++ b/src/libraries/Microsoft.Extensions.Diagnostics.Abstractions/Microsoft.Extensions.Diagnostics.Abstractions.sln @@ -33,6 +33,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Diagnostics.Diagnost EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{40058320-9546-45A9-9D6E-CC80EB2E4D95}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{FA9064CF-5EBB-45AF-AB62-B8ED0B8F4954}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{2DB6B79C-C8B4-428F-AC57-1B5947C75021}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{25420CB4-919B-4299-A8CB-1190E22438F2}" @@ -139,6 +141,10 @@ Global {40058320-9546-45A9-9D6E-CC80EB2E4D95}.Debug|Any CPU.Build.0 = Debug|Any CPU {40058320-9546-45A9-9D6E-CC80EB2E4D95}.Release|Any CPU.ActiveCfg = Release|Any CPU {40058320-9546-45A9-9D6E-CC80EB2E4D95}.Release|Any CPU.Build.0 = Release|Any CPU + {FA9064CF-5EBB-45AF-AB62-B8ED0B8F4954}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {FA9064CF-5EBB-45AF-AB62-B8ED0B8F4954}.Debug|Any CPU.Build.0 = Debug|Any CPU + {FA9064CF-5EBB-45AF-AB62-B8ED0B8F4954}.Release|Any CPU.ActiveCfg = Release|Any CPU + {FA9064CF-5EBB-45AF-AB62-B8ED0B8F4954}.Release|Any CPU.Build.0 = Release|Any CPU {2DB6B79C-C8B4-428F-AC57-1B5947C75021}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {2DB6B79C-C8B4-428F-AC57-1B5947C75021}.Debug|Any CPU.Build.0 = Debug|Any CPU {2DB6B79C-C8B4-428F-AC57-1B5947C75021}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -194,6 +200,7 @@ Global {69D08457-EC2F-4BC8-A562-6154C2D6D2DC} = {7631380A-FB73-4241-9987-0891A21E9769} {AA2E94ED-4C40-4028-84E5-7459EDB8F66E} = {D64F512B-CF20-4CE0-8FE8-1E65C1A84E90} {40058320-9546-45A9-9D6E-CC80EB2E4D95} = {D64F512B-CF20-4CE0-8FE8-1E65C1A84E90} + {FA9064CF-5EBB-45AF-AB62-B8ED0B8F4954} = {D64F512B-CF20-4CE0-8FE8-1E65C1A84E90} {2DB6B79C-C8B4-428F-AC57-1B5947C75021} = {D64F512B-CF20-4CE0-8FE8-1E65C1A84E90} {25420CB4-919B-4299-A8CB-1190E22438F2} = {D64F512B-CF20-4CE0-8FE8-1E65C1A84E90} {50B9EFE8-8D38-4D22-9423-F27356D8EFA7} = {D4B78CD9-7251-426B-AA22-48BC8EDD396A} diff --git a/src/libraries/Microsoft.Extensions.Diagnostics.Abstractions/src/Microsoft.Extensions.Diagnostics.Abstractions.csproj b/src/libraries/Microsoft.Extensions.Diagnostics.Abstractions/src/Microsoft.Extensions.Diagnostics.Abstractions.csproj index 5bb4f9addc2..155167326af 100644 --- a/src/libraries/Microsoft.Extensions.Diagnostics.Abstractions/src/Microsoft.Extensions.Diagnostics.Abstractions.csproj +++ b/src/libraries/Microsoft.Extensions.Diagnostics.Abstractions/src/Microsoft.Extensions.Diagnostics.Abstractions.csproj @@ -33,8 +33,11 @@ Microsoft.Extensions.Diagnostics.Metrics.MetricsOptions - + + + + diff --git a/src/libraries/Microsoft.Extensions.Diagnostics/Microsoft.Extensions.Diagnostics.sln b/src/libraries/Microsoft.Extensions.Diagnostics/Microsoft.Extensions.Diagnostics.sln index dd27ac7234e..dbbe99d8a4d 100644 --- a/src/libraries/Microsoft.Extensions.Diagnostics/Microsoft.Extensions.Diagnostics.sln +++ b/src/libraries/Microsoft.Extensions.Diagnostics/Microsoft.Extensions.Diagnostics.sln @@ -145,6 +145,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Memory", "..\System. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{ED105ED3-0060-4035-AD5E-1F857F94C2DF}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{0479E974-3C1B-42AF-B5D6-35ECD266EF37}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{0A0D7CB1-3864-478F-98FC-5AA53C6A72C2}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{3FEA305D-0B5F-46A6-8E18-587387FCBFBF}" @@ -491,6 +493,10 @@ Global {ED105ED3-0060-4035-AD5E-1F857F94C2DF}.Debug|Any CPU.Build.0 = Debug|Any CPU {ED105ED3-0060-4035-AD5E-1F857F94C2DF}.Release|Any CPU.ActiveCfg = Release|Any CPU {ED105ED3-0060-4035-AD5E-1F857F94C2DF}.Release|Any CPU.Build.0 = Release|Any CPU + {0479E974-3C1B-42AF-B5D6-35ECD266EF37}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {0479E974-3C1B-42AF-B5D6-35ECD266EF37}.Debug|Any CPU.Build.0 = Debug|Any CPU + {0479E974-3C1B-42AF-B5D6-35ECD266EF37}.Release|Any CPU.ActiveCfg = Release|Any CPU + {0479E974-3C1B-42AF-B5D6-35ECD266EF37}.Release|Any CPU.Build.0 = Release|Any CPU {0A0D7CB1-3864-478F-98FC-5AA53C6A72C2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {0A0D7CB1-3864-478F-98FC-5AA53C6A72C2}.Debug|Any CPU.Build.0 = Debug|Any CPU {0A0D7CB1-3864-478F-98FC-5AA53C6A72C2}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -638,6 +644,7 @@ Global {D2C7FA66-96C4-41BD-A654-83B05090BFAA} = {66953A8A-9E31-486F-AF8E-7310F6707E4F} {14375EFA-3F3D-4D48-8C83-56356BCF8DB3} = {66953A8A-9E31-486F-AF8E-7310F6707E4F} {ED105ED3-0060-4035-AD5E-1F857F94C2DF} = {66953A8A-9E31-486F-AF8E-7310F6707E4F} + {0479E974-3C1B-42AF-B5D6-35ECD266EF37} = {66953A8A-9E31-486F-AF8E-7310F6707E4F} {0A0D7CB1-3864-478F-98FC-5AA53C6A72C2} = {66953A8A-9E31-486F-AF8E-7310F6707E4F} {3FEA305D-0B5F-46A6-8E18-587387FCBFBF} = {66953A8A-9E31-486F-AF8E-7310F6707E4F} {440BCAA1-EB67-4300-B9E6-E77250D86C24} = {66953A8A-9E31-486F-AF8E-7310F6707E4F} diff --git a/src/libraries/Microsoft.Extensions.FileProviders.Abstractions/Microsoft.Extensions.FileProviders.Abstractions.sln b/src/libraries/Microsoft.Extensions.FileProviders.Abstractions/Microsoft.Extensions.FileProviders.Abstractions.sln index 97334079831..5c89e7654f3 100644 --- a/src/libraries/Microsoft.Extensions.FileProviders.Abstractions/Microsoft.Extensions.FileProviders.Abstractions.sln +++ b/src/libraries/Microsoft.Extensions.FileProviders.Abstractions/Microsoft.Extensions.FileProviders.Abstractions.sln @@ -7,7 +7,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Primit EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Primitives", "..\Microsoft.Extensions.Primitives\src\Microsoft.Extensions.Primitives.csproj", "{E7FEEB55-F4A7-4677-AFD5-7DE90A4897AE}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{D84E4D42-84EA-41B1-A689-00E964FED8DD}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{C55E047C-69D6-40C7-A931-3A6719F52FF6}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{4F62F683-8B2A-46EE-BC34-5CC192DE0C32}" EndProject @@ -57,10 +57,10 @@ Global {E7FEEB55-F4A7-4677-AFD5-7DE90A4897AE}.Debug|Any CPU.Build.0 = Debug|Any CPU {E7FEEB55-F4A7-4677-AFD5-7DE90A4897AE}.Release|Any CPU.ActiveCfg = Release|Any CPU {E7FEEB55-F4A7-4677-AFD5-7DE90A4897AE}.Release|Any CPU.Build.0 = Release|Any CPU - {D84E4D42-84EA-41B1-A689-00E964FED8DD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {D84E4D42-84EA-41B1-A689-00E964FED8DD}.Debug|Any CPU.Build.0 = Debug|Any CPU - {D84E4D42-84EA-41B1-A689-00E964FED8DD}.Release|Any CPU.ActiveCfg = Release|Any CPU - {D84E4D42-84EA-41B1-A689-00E964FED8DD}.Release|Any CPU.Build.0 = Release|Any CPU + {C55E047C-69D6-40C7-A931-3A6719F52FF6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {C55E047C-69D6-40C7-A931-3A6719F52FF6}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C55E047C-69D6-40C7-A931-3A6719F52FF6}.Release|Any CPU.ActiveCfg = Release|Any CPU + {C55E047C-69D6-40C7-A931-3A6719F52FF6}.Release|Any CPU.Build.0 = Release|Any CPU {4F62F683-8B2A-46EE-BC34-5CC192DE0C32}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {4F62F683-8B2A-46EE-BC34-5CC192DE0C32}.Debug|Any CPU.Build.0 = Debug|Any CPU {4F62F683-8B2A-46EE-BC34-5CC192DE0C32}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -94,7 +94,7 @@ Global {F985DC40-F983-4464-B866-3BD17EE3B6B1} = {BE15F96C-8AA4-4F7D-9A69-9924531A6136} {DD99D42D-60FD-45D8-9F55-BE3AE38626D0} = {D948D4F3-4232-4FEA-936D-5F554D335FEA} {E7FEEB55-F4A7-4677-AFD5-7DE90A4897AE} = {D948D4F3-4232-4FEA-936D-5F554D335FEA} - {D84E4D42-84EA-41B1-A689-00E964FED8DD} = {1EB544B8-7931-492C-BB70-82C96C195BCD} + {C55E047C-69D6-40C7-A931-3A6719F52FF6} = {1EB544B8-7931-492C-BB70-82C96C195BCD} {4F62F683-8B2A-46EE-BC34-5CC192DE0C32} = {1EB544B8-7931-492C-BB70-82C96C195BCD} {9CC188A7-707F-4B20-8B78-D66CC06BDA6B} = {5BC2401B-E368-4524-85B1-5A6E2B80BB01} {3E5B825A-F1D4-4068-B9A2-B3871E5DE574} = {5BC2401B-E368-4524-85B1-5A6E2B80BB01} diff --git a/src/libraries/Microsoft.Extensions.FileProviders.Abstractions/src/IFileProvider.cs b/src/libraries/Microsoft.Extensions.FileProviders.Abstractions/src/IFileProvider.cs index bce6d2d81f6..8b4b937dffb 100644 --- a/src/libraries/Microsoft.Extensions.FileProviders.Abstractions/src/IFileProvider.cs +++ b/src/libraries/Microsoft.Extensions.FileProviders.Abstractions/src/IFileProvider.cs @@ -11,24 +11,24 @@ namespace Microsoft.Extensions.FileProviders public interface IFileProvider { /// - /// Locate a file at the given path. + /// Locates a file at the given path. /// - /// Relative path that identifies the file. + /// The relative path that identifies the file. /// The file information. Caller must check Exists property. IFileInfo GetFileInfo(string subpath); /// - /// Enumerate a directory at the given path, if any. + /// Enumerates a directory at the given path, if any. /// - /// Relative path that identifies the directory. + /// The relative path that identifies the directory. /// Returns the contents of the directory. IDirectoryContents GetDirectoryContents(string subpath); /// - /// Creates a for the specified . + /// Creates an for the specified . /// - /// Filter string used to determine what files or folders to monitor. Example: **/*.cs, *.*, subFolder/**/*.cshtml. - /// An that is notified when a file matching is added, modified or deleted. + /// A filter string used to determine what files or folders to monitor. Examples: **/*.cs, *.*, subFolder/**/*.cshtml. + /// An that is notified when a file matching is added, modified, or deleted. IChangeToken Watch(string filter); } } diff --git a/src/libraries/Microsoft.Extensions.FileProviders.Composite/Microsoft.Extensions.FileProviders.Composite.sln b/src/libraries/Microsoft.Extensions.FileProviders.Composite/Microsoft.Extensions.FileProviders.Composite.sln index 08c8ed1d5dc..cee3da789f4 100644 --- a/src/libraries/Microsoft.Extensions.FileProviders.Composite/Microsoft.Extensions.FileProviders.Composite.sln +++ b/src/libraries/Microsoft.Extensions.FileProviders.Composite/Microsoft.Extensions.FileProviders.Composite.sln @@ -15,7 +15,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Primit EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Primitives", "..\Microsoft.Extensions.Primitives\src\Microsoft.Extensions.Primitives.csproj", "{FC76C7E7-C2C3-43D0-99AE-C77E8402FBE3}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{79F0E6DD-E665-4CAD-9C1D-D3570DBDA5FB}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{0194B333-FF62-4892-BE71-9611F46082E9}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{9FA8F495-A781-4D1E-8793-EB08E862AA37}" EndProject @@ -83,10 +83,10 @@ Global {FC76C7E7-C2C3-43D0-99AE-C77E8402FBE3}.Debug|Any CPU.Build.0 = Debug|Any CPU {FC76C7E7-C2C3-43D0-99AE-C77E8402FBE3}.Release|Any CPU.ActiveCfg = Release|Any CPU {FC76C7E7-C2C3-43D0-99AE-C77E8402FBE3}.Release|Any CPU.Build.0 = Release|Any CPU - {79F0E6DD-E665-4CAD-9C1D-D3570DBDA5FB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {79F0E6DD-E665-4CAD-9C1D-D3570DBDA5FB}.Debug|Any CPU.Build.0 = Debug|Any CPU - {79F0E6DD-E665-4CAD-9C1D-D3570DBDA5FB}.Release|Any CPU.ActiveCfg = Release|Any CPU - {79F0E6DD-E665-4CAD-9C1D-D3570DBDA5FB}.Release|Any CPU.Build.0 = Release|Any CPU + {0194B333-FF62-4892-BE71-9611F46082E9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {0194B333-FF62-4892-BE71-9611F46082E9}.Debug|Any CPU.Build.0 = Debug|Any CPU + {0194B333-FF62-4892-BE71-9611F46082E9}.Release|Any CPU.ActiveCfg = Release|Any CPU + {0194B333-FF62-4892-BE71-9611F46082E9}.Release|Any CPU.Build.0 = Release|Any CPU {9FA8F495-A781-4D1E-8793-EB08E862AA37}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {9FA8F495-A781-4D1E-8793-EB08E862AA37}.Debug|Any CPU.Build.0 = Debug|Any CPU {9FA8F495-A781-4D1E-8793-EB08E862AA37}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -124,7 +124,7 @@ Global {4A904B1E-5710-4D31-A734-33C734C9D989} = {998B15B4-464F-40EB-92DA-61637BE9C838} {7A8F66B3-8D37-4D83-B54F-0955EC11F675} = {998B15B4-464F-40EB-92DA-61637BE9C838} {FC76C7E7-C2C3-43D0-99AE-C77E8402FBE3} = {998B15B4-464F-40EB-92DA-61637BE9C838} - {79F0E6DD-E665-4CAD-9C1D-D3570DBDA5FB} = {94912E31-E514-4648-BD9F-3259A8116AC0} + {0194B333-FF62-4892-BE71-9611F46082E9} = {94912E31-E514-4648-BD9F-3259A8116AC0} {9FA8F495-A781-4D1E-8793-EB08E862AA37} = {94912E31-E514-4648-BD9F-3259A8116AC0} {03B4234A-E0E5-41E8-9477-DD6BC1062931} = {B6DA6974-633C-47A5-BE72-16549D0FBE8A} {CAC0C5B3-60CC-4F10-8BEC-DD9AE08F8A87} = {B6DA6974-633C-47A5-BE72-16549D0FBE8A} diff --git a/src/libraries/Microsoft.Extensions.FileProviders.Composite/src/CompositeFileProvider.cs b/src/libraries/Microsoft.Extensions.FileProviders.Composite/src/CompositeFileProvider.cs index 1343ab4bbe4..0b5721a39e7 100644 --- a/src/libraries/Microsoft.Extensions.FileProviders.Composite/src/CompositeFileProvider.cs +++ b/src/libraries/Microsoft.Extensions.FileProviders.Composite/src/CompositeFileProvider.cs @@ -17,18 +17,18 @@ public class CompositeFileProvider : IFileProvider private readonly IFileProvider[] _fileProviders; /// - /// Initializes a new instance of the class using a collection of file provider. + /// Initializes a new instance of the class using a collection of file provider objects. /// - /// The collection of + /// The collection of objects. public CompositeFileProvider(params IFileProvider[]? fileProviders) { _fileProviders = fileProviders ?? Array.Empty(); } /// - /// Initializes a new instance of the class using a collection of file provider. + /// Initializes a new instance of the class using a collection of file provider objects. /// - /// The collection of + /// The collection of objects. public CompositeFileProvider(IEnumerable fileProviders) { ThrowHelper.ThrowIfNull(fileProviders); @@ -40,7 +40,7 @@ public CompositeFileProvider(IEnumerable fileProviders) /// Locates a file at the given path. /// /// The path that identifies the file. - /// The file information. Caller must check Exists property. This will be the first existing returned by the provided or a not found if no existing files is found. + /// The file information. The caller must check the property. This is the first existing returned by the provided or a not found if no existing files are found. public IFileInfo GetFileInfo(string subpath) { foreach (IFileProvider fileProvider in _fileProviders) @@ -55,12 +55,12 @@ public IFileInfo GetFileInfo(string subpath) } /// - /// Enumerate a directory at the given path, if any. + /// Enumerates a directory at the given path, if any. /// - /// The path that identifies the directory - /// Contents of the directory. Caller must check Exists property. + /// The path that identifies the directory. + /// The contents of the directory. Caller must check Exists property. /// The content is a merge of the contents of the provided . - /// When there is multiple with the same Name property, only the first one is included on the results. + /// When there are multiple objects with the same Name property, only the first one is included in the results. public IDirectoryContents GetDirectoryContents(string subpath) { var directoryContents = new CompositeDirectoryContents(_fileProviders, subpath); @@ -70,9 +70,9 @@ public IDirectoryContents GetDirectoryContents(string subpath) /// /// Creates a for the specified . /// - /// Filter string used to determine what files or folders to monitor. Example: **/*.cs, *.*, subFolder/**/*.cshtml. - /// An that is notified when a file matching is added, modified or deleted. - /// The change token will be notified when one of the change token returned by the provided will be notified. + /// A filter string used to determine what files or folders to monitor. Examples: \*\*/\*.cs, \*.\*, subFolder/\*\*/\*.cshtml. + /// An that is notified when a file matching is added, modified, or deleted. + /// The change token will be notified when one of the change token returned by the provided is notified. public IChangeToken Watch(string pattern) { // Watch all file providers diff --git a/src/libraries/Microsoft.Extensions.FileProviders.Physical/Microsoft.Extensions.FileProviders.Physical.sln b/src/libraries/Microsoft.Extensions.FileProviders.Physical/Microsoft.Extensions.FileProviders.Physical.sln index ba5b87033f3..a2b3848c981 100644 --- a/src/libraries/Microsoft.Extensions.FileProviders.Physical/Microsoft.Extensions.FileProviders.Physical.sln +++ b/src/libraries/Microsoft.Extensions.FileProviders.Physical/Microsoft.Extensions.FileProviders.Physical.sln @@ -19,7 +19,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Primit EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Primitives", "..\Microsoft.Extensions.Primitives\src\Microsoft.Extensions.Primitives.csproj", "{C55245FA-CAA6-43F7-917C-602E97BC8D52}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{9ECEF693-0104-4829-85E6-9CC81A8A0FA1}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{5B92517B-031B-4863-9548-BBD9109C1E30}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{FE431CFB-8AC4-4118-95D7-7EBE1722CB66}" EndProject @@ -95,10 +95,10 @@ Global {C55245FA-CAA6-43F7-917C-602E97BC8D52}.Debug|Any CPU.Build.0 = Debug|Any CPU {C55245FA-CAA6-43F7-917C-602E97BC8D52}.Release|Any CPU.ActiveCfg = Release|Any CPU {C55245FA-CAA6-43F7-917C-602E97BC8D52}.Release|Any CPU.Build.0 = Release|Any CPU - {9ECEF693-0104-4829-85E6-9CC81A8A0FA1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {9ECEF693-0104-4829-85E6-9CC81A8A0FA1}.Debug|Any CPU.Build.0 = Debug|Any CPU - {9ECEF693-0104-4829-85E6-9CC81A8A0FA1}.Release|Any CPU.ActiveCfg = Release|Any CPU - {9ECEF693-0104-4829-85E6-9CC81A8A0FA1}.Release|Any CPU.Build.0 = Release|Any CPU + {5B92517B-031B-4863-9548-BBD9109C1E30}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {5B92517B-031B-4863-9548-BBD9109C1E30}.Debug|Any CPU.Build.0 = Debug|Any CPU + {5B92517B-031B-4863-9548-BBD9109C1E30}.Release|Any CPU.ActiveCfg = Release|Any CPU + {5B92517B-031B-4863-9548-BBD9109C1E30}.Release|Any CPU.Build.0 = Release|Any CPU {FE431CFB-8AC4-4118-95D7-7EBE1722CB66}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {FE431CFB-8AC4-4118-95D7-7EBE1722CB66}.Debug|Any CPU.Build.0 = Debug|Any CPU {FE431CFB-8AC4-4118-95D7-7EBE1722CB66}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -138,7 +138,7 @@ Global {55A66A71-A400-4A36-9A19-9F8B549647D7} = {7DDADA4C-8D27-4582-93DD-ABE98D76B3FF} {DBE052B4-23A7-4F40-BFFE-9604E39AAACF} = {7DDADA4C-8D27-4582-93DD-ABE98D76B3FF} {C55245FA-CAA6-43F7-917C-602E97BC8D52} = {7DDADA4C-8D27-4582-93DD-ABE98D76B3FF} - {9ECEF693-0104-4829-85E6-9CC81A8A0FA1} = {4A7AB018-13B5-44F7-BFF2-AE38E425BDD2} + {5B92517B-031B-4863-9548-BBD9109C1E30} = {4A7AB018-13B5-44F7-BFF2-AE38E425BDD2} {FE431CFB-8AC4-4118-95D7-7EBE1722CB66} = {4A7AB018-13B5-44F7-BFF2-AE38E425BDD2} {95F48786-2334-4200-8B52-E1CA9A2F365F} = {A1651C23-E749-42FE-89F6-890C8849E730} {51E5638C-7F4A-427E-A65A-2D768C2A5926} = {A1651C23-E749-42FE-89F6-890C8849E730} diff --git a/src/libraries/Microsoft.Extensions.FileProviders.Physical/src/PhysicalFileProvider.cs b/src/libraries/Microsoft.Extensions.FileProviders.Physical/src/PhysicalFileProvider.cs index 925df989275..c80d9f32a2c 100644 --- a/src/libraries/Microsoft.Extensions.FileProviders.Physical/src/PhysicalFileProvider.cs +++ b/src/libraries/Microsoft.Extensions.FileProviders.Physical/src/PhysicalFileProvider.cs @@ -164,7 +164,7 @@ internal PhysicalFilesWatcher CreateFileWatcher() FileSystemWatcher? watcher; #if NET // For browser/iOS/tvOS we will proactively fallback to polling since FileSystemWatcher is not supported. - if (OperatingSystem.IsBrowser() || (OperatingSystem.IsIOS() && !OperatingSystem.IsMacCatalyst()) || OperatingSystem.IsTvOS()) + if (OperatingSystem.IsBrowser() || OperatingSystem.IsWasi() || (OperatingSystem.IsIOS() && !OperatingSystem.IsMacCatalyst()) || OperatingSystem.IsTvOS()) { UsePollingFileWatcher = true; UseActivePolling = true; diff --git a/src/libraries/Microsoft.Extensions.FileProviders.Physical/src/PhysicalFilesWatcher.cs b/src/libraries/Microsoft.Extensions.FileProviders.Physical/src/PhysicalFilesWatcher.cs index 712a83a3ef2..aaf35606fd9 100644 --- a/src/libraries/Microsoft.Extensions.FileProviders.Physical/src/PhysicalFilesWatcher.cs +++ b/src/libraries/Microsoft.Extensions.FileProviders.Physical/src/PhysicalFilesWatcher.cs @@ -89,7 +89,7 @@ public PhysicalFilesWatcher( if (fileSystemWatcher != null) { #if NET - if (OperatingSystem.IsBrowser() || (OperatingSystem.IsIOS() && !OperatingSystem.IsMacCatalyst()) || OperatingSystem.IsTvOS()) + if (OperatingSystem.IsBrowser() || OperatingSystem.IsWasi() || (OperatingSystem.IsIOS() && !OperatingSystem.IsMacCatalyst()) || OperatingSystem.IsTvOS()) { throw new PlatformNotSupportedException(SR.Format(SR.FileSystemWatcher_PlatformNotSupported, typeof(FileSystemWatcher))); } @@ -276,6 +276,7 @@ protected virtual void Dispose(bool disposing) } [UnsupportedOSPlatform("browser")] + [UnsupportedOSPlatform("wasi")] [UnsupportedOSPlatform("ios")] [UnsupportedOSPlatform("tvos")] [SupportedOSPlatform("maccatalyst")] @@ -312,6 +313,7 @@ ex is DirectoryNotFoundException || } [UnsupportedOSPlatform("browser")] + [UnsupportedOSPlatform("wasi")] [UnsupportedOSPlatform("ios")] [UnsupportedOSPlatform("tvos")] [SupportedOSPlatform("maccatalyst")] @@ -321,6 +323,7 @@ private void OnChanged(object sender, FileSystemEventArgs e) } [UnsupportedOSPlatform("browser")] + [UnsupportedOSPlatform("wasi")] [UnsupportedOSPlatform("ios")] [UnsupportedOSPlatform("tvos")] [SupportedOSPlatform("maccatalyst")] @@ -334,6 +337,7 @@ private void OnError(object sender, ErrorEventArgs e) } [UnsupportedOSPlatform("browser")] + [UnsupportedOSPlatform("wasi")] [UnsupportedOSPlatform("ios")] [UnsupportedOSPlatform("tvos")] [SupportedOSPlatform("maccatalyst")] @@ -360,6 +364,7 @@ ex is SecurityException || } [UnsupportedOSPlatform("browser")] + [UnsupportedOSPlatform("wasi")] [UnsupportedOSPlatform("ios")] [UnsupportedOSPlatform("tvos")] [SupportedOSPlatform("maccatalyst")] @@ -400,6 +405,7 @@ private void ReportChangeForMatchedEntries(string path) } [UnsupportedOSPlatform("browser")] + [UnsupportedOSPlatform("wasi")] [UnsupportedOSPlatform("ios")] [UnsupportedOSPlatform("tvos")] [SupportedOSPlatform("maccatalyst")] @@ -421,6 +427,7 @@ private void TryDisableFileSystemWatcher() } [UnsupportedOSPlatform("browser")] + [UnsupportedOSPlatform("wasi")] [UnsupportedOSPlatform("ios")] [UnsupportedOSPlatform("tvos")] [SupportedOSPlatform("maccatalyst")] diff --git a/src/libraries/Microsoft.Extensions.FileSystemGlobbing/Microsoft.Extensions.FileSystemGlobbing.sln b/src/libraries/Microsoft.Extensions.FileSystemGlobbing/Microsoft.Extensions.FileSystemGlobbing.sln index e506a206313..f281c3e77c7 100644 --- a/src/libraries/Microsoft.Extensions.FileSystemGlobbing/Microsoft.Extensions.FileSystemGlobbing.sln +++ b/src/libraries/Microsoft.Extensions.FileSystemGlobbing/Microsoft.Extensions.FileSystemGlobbing.sln @@ -7,7 +7,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.FileSy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.FileSystemGlobbing.Tests", "tests\Microsoft.Extensions.FileSystemGlobbing.Tests.csproj", "{79B284F9-326E-4FEB-9A32-EA72A31B4B60}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{7A85F84A-4E74-471D-8F9C-3D06D5D8BD74}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{EC3D7952-F4CB-4C70-A43B-05CB002F4E4F}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{404A8198-B2DF-42AB-BA33-69509A8E0C91}" EndProject @@ -59,10 +59,10 @@ Global {79B284F9-326E-4FEB-9A32-EA72A31B4B60}.Debug|Any CPU.Build.0 = Debug|Any CPU {79B284F9-326E-4FEB-9A32-EA72A31B4B60}.Release|Any CPU.ActiveCfg = Release|Any CPU {79B284F9-326E-4FEB-9A32-EA72A31B4B60}.Release|Any CPU.Build.0 = Release|Any CPU - {7A85F84A-4E74-471D-8F9C-3D06D5D8BD74}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {7A85F84A-4E74-471D-8F9C-3D06D5D8BD74}.Debug|Any CPU.Build.0 = Debug|Any CPU - {7A85F84A-4E74-471D-8F9C-3D06D5D8BD74}.Release|Any CPU.ActiveCfg = Release|Any CPU - {7A85F84A-4E74-471D-8F9C-3D06D5D8BD74}.Release|Any CPU.Build.0 = Release|Any CPU + {EC3D7952-F4CB-4C70-A43B-05CB002F4E4F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {EC3D7952-F4CB-4C70-A43B-05CB002F4E4F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {EC3D7952-F4CB-4C70-A43B-05CB002F4E4F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {EC3D7952-F4CB-4C70-A43B-05CB002F4E4F}.Release|Any CPU.Build.0 = Release|Any CPU {404A8198-B2DF-42AB-BA33-69509A8E0C91}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {404A8198-B2DF-42AB-BA33-69509A8E0C91}.Debug|Any CPU.Build.0 = Debug|Any CPU {404A8198-B2DF-42AB-BA33-69509A8E0C91}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -96,7 +96,7 @@ Global {79B284F9-326E-4FEB-9A32-EA72A31B4B60} = {7438714C-BB16-491E-8D9C-A2B7CB0EFA35} {ECFF7A87-0D5F-4EA1-9FED-1126A51B5D55} = {4A9C0071-CAD0-4ABB-A489-04280BA258A5} {A9547748-8B4F-450E-B0E3-CD9A1A80B319} = {AE2C386A-473E-46FF-97DB-4CB1727122BB} - {7A85F84A-4E74-471D-8F9C-3D06D5D8BD74} = {2EF45468-C4F8-4194-9720-592D0186B585} + {EC3D7952-F4CB-4C70-A43B-05CB002F4E4F} = {2EF45468-C4F8-4194-9720-592D0186B585} {404A8198-B2DF-42AB-BA33-69509A8E0C91} = {2EF45468-C4F8-4194-9720-592D0186B585} {41434677-8D75-4375-A24C-D9A1004FB758} = {E75B0897-7E50-4614-8AF0-FEFD894ADD53} {D50F036B-C776-4C6D-BAC8-53F7F0D13CBD} = {E75B0897-7E50-4614-8AF0-FEFD894ADD53} diff --git a/src/libraries/Microsoft.Extensions.HostFactoryResolver/Microsoft.Extensions.HostFactoryResolver.sln b/src/libraries/Microsoft.Extensions.HostFactoryResolver/Microsoft.Extensions.HostFactoryResolver.sln index b61f2909824..f6b29d9ad2c 100644 --- a/src/libraries/Microsoft.Extensions.HostFactoryResolver/Microsoft.Extensions.HostFactoryResolver.sln +++ b/src/libraries/Microsoft.Extensions.HostFactoryResolver/Microsoft.Extensions.HostFactoryResolver.sln @@ -179,6 +179,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Memory", "..\System. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{BE1F44EC-1298-412C-BEF9-4578CA6DE547}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{5E21D41B-0BB7-474A-961E-7B0AA041DCB7}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{1406D871-3350-4754-9E69-DA6E75E56857}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{0A3C61A6-F9D7-4189-B23C-41BF629E8237}" @@ -593,6 +595,10 @@ Global {BE1F44EC-1298-412C-BEF9-4578CA6DE547}.Debug|Any CPU.Build.0 = Debug|Any CPU {BE1F44EC-1298-412C-BEF9-4578CA6DE547}.Release|Any CPU.ActiveCfg = Release|Any CPU {BE1F44EC-1298-412C-BEF9-4578CA6DE547}.Release|Any CPU.Build.0 = Release|Any CPU + {5E21D41B-0BB7-474A-961E-7B0AA041DCB7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {5E21D41B-0BB7-474A-961E-7B0AA041DCB7}.Debug|Any CPU.Build.0 = Debug|Any CPU + {5E21D41B-0BB7-474A-961E-7B0AA041DCB7}.Release|Any CPU.ActiveCfg = Release|Any CPU + {5E21D41B-0BB7-474A-961E-7B0AA041DCB7}.Release|Any CPU.Build.0 = Release|Any CPU {1406D871-3350-4754-9E69-DA6E75E56857}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {1406D871-3350-4754-9E69-DA6E75E56857}.Debug|Any CPU.Build.0 = Debug|Any CPU {1406D871-3350-4754-9E69-DA6E75E56857}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -757,6 +763,7 @@ Global {A8840229-74D9-4A14-8975-272C8C436190} = {64423F79-97D4-45E8-9F06-6CFB06A36C0F} {14313E39-4A4C-405A-BF84-849A09DF3F09} = {64423F79-97D4-45E8-9F06-6CFB06A36C0F} {BE1F44EC-1298-412C-BEF9-4578CA6DE547} = {64423F79-97D4-45E8-9F06-6CFB06A36C0F} + {5E21D41B-0BB7-474A-961E-7B0AA041DCB7} = {64423F79-97D4-45E8-9F06-6CFB06A36C0F} {1406D871-3350-4754-9E69-DA6E75E56857} = {64423F79-97D4-45E8-9F06-6CFB06A36C0F} {0A3C61A6-F9D7-4189-B23C-41BF629E8237} = {64423F79-97D4-45E8-9F06-6CFB06A36C0F} {5A1C0774-4BF1-478D-812F-5CF34431AAD0} = {64423F79-97D4-45E8-9F06-6CFB06A36C0F} diff --git a/src/libraries/Microsoft.Extensions.Hosting.Abstractions/Microsoft.Extensions.Hosting.Abstractions.sln b/src/libraries/Microsoft.Extensions.Hosting.Abstractions/Microsoft.Extensions.Hosting.Abstractions.sln index 0fc42beb0b8..dda91b64591 100644 --- a/src/libraries/Microsoft.Extensions.Hosting.Abstractions/Microsoft.Extensions.Hosting.Abstractions.sln +++ b/src/libraries/Microsoft.Extensions.Hosting.Abstractions/Microsoft.Extensions.Hosting.Abstractions.sln @@ -47,6 +47,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Diagnostics.Diagnost EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{EFB29682-1F77-4E0E-AB8E-418196CFC20F}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{4A7B7CCC-11E7-44EC-B70C-F550FD22D251}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{BBDA0B2E-BC21-4B90-8704-60600A84CB35}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{984774FC-974E-422D-9C34-5DE60308EC02}" @@ -179,6 +181,10 @@ Global {EFB29682-1F77-4E0E-AB8E-418196CFC20F}.Debug|Any CPU.Build.0 = Debug|Any CPU {EFB29682-1F77-4E0E-AB8E-418196CFC20F}.Release|Any CPU.ActiveCfg = Release|Any CPU {EFB29682-1F77-4E0E-AB8E-418196CFC20F}.Release|Any CPU.Build.0 = Release|Any CPU + {4A7B7CCC-11E7-44EC-B70C-F550FD22D251}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {4A7B7CCC-11E7-44EC-B70C-F550FD22D251}.Debug|Any CPU.Build.0 = Debug|Any CPU + {4A7B7CCC-11E7-44EC-B70C-F550FD22D251}.Release|Any CPU.ActiveCfg = Release|Any CPU + {4A7B7CCC-11E7-44EC-B70C-F550FD22D251}.Release|Any CPU.Build.0 = Release|Any CPU {BBDA0B2E-BC21-4B90-8704-60600A84CB35}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {BBDA0B2E-BC21-4B90-8704-60600A84CB35}.Debug|Any CPU.Build.0 = Debug|Any CPU {BBDA0B2E-BC21-4B90-8704-60600A84CB35}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -241,6 +247,7 @@ Global {40F96C08-9936-47DA-AA41-E54954F02EE8} = {BC6A7FDF-74EB-4DA1-9C71-4A8D46D39C15} {52A08EB3-0680-4C2A-BA78-7110D9ABBC8C} = {BC6A7FDF-74EB-4DA1-9C71-4A8D46D39C15} {EFB29682-1F77-4E0E-AB8E-418196CFC20F} = {BC6A7FDF-74EB-4DA1-9C71-4A8D46D39C15} + {4A7B7CCC-11E7-44EC-B70C-F550FD22D251} = {BC6A7FDF-74EB-4DA1-9C71-4A8D46D39C15} {BBDA0B2E-BC21-4B90-8704-60600A84CB35} = {BC6A7FDF-74EB-4DA1-9C71-4A8D46D39C15} {984774FC-974E-422D-9C34-5DE60308EC02} = {BC6A7FDF-74EB-4DA1-9C71-4A8D46D39C15} {CF9B2C75-3FDD-4F6F-9912-E10DB3BA294B} = {CE599F12-D209-41F2-964F-BECBE6D1812D} diff --git a/src/libraries/Microsoft.Extensions.Hosting.Systemd/Microsoft.Extensions.Hosting.Systemd.sln b/src/libraries/Microsoft.Extensions.Hosting.Systemd/Microsoft.Extensions.Hosting.Systemd.sln index 556f81b68e3..3f8c390e633 100644 --- a/src/libraries/Microsoft.Extensions.Hosting.Systemd/Microsoft.Extensions.Hosting.Systemd.sln +++ b/src/libraries/Microsoft.Extensions.Hosting.Systemd/Microsoft.Extensions.Hosting.Systemd.sln @@ -149,6 +149,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Memory", "..\System. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{E89B69FA-5B8B-4921-97BF-AA8FB60C7A15}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{A505A56D-3241-4471-8BFE-B09F1F59BE77}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{EDF8F173-CFE7-40FB-8EEB-795A1DFB6D99}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{D8A16E22-8BF8-49ED-A033-0150D6341282}" @@ -503,6 +505,10 @@ Global {E89B69FA-5B8B-4921-97BF-AA8FB60C7A15}.Debug|Any CPU.Build.0 = Debug|Any CPU {E89B69FA-5B8B-4921-97BF-AA8FB60C7A15}.Release|Any CPU.ActiveCfg = Release|Any CPU {E89B69FA-5B8B-4921-97BF-AA8FB60C7A15}.Release|Any CPU.Build.0 = Release|Any CPU + {A505A56D-3241-4471-8BFE-B09F1F59BE77}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A505A56D-3241-4471-8BFE-B09F1F59BE77}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A505A56D-3241-4471-8BFE-B09F1F59BE77}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A505A56D-3241-4471-8BFE-B09F1F59BE77}.Release|Any CPU.Build.0 = Release|Any CPU {EDF8F173-CFE7-40FB-8EEB-795A1DFB6D99}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {EDF8F173-CFE7-40FB-8EEB-795A1DFB6D99}.Debug|Any CPU.Build.0 = Debug|Any CPU {EDF8F173-CFE7-40FB-8EEB-795A1DFB6D99}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -652,6 +658,7 @@ Global {7D8C7904-C8AC-4732-89BE-0DB348E6E9AC} = {694561D4-7901-4727-B87C-109C7CED0404} {AA0DB387-9639-4997-A4B7-555EF45BFB4A} = {694561D4-7901-4727-B87C-109C7CED0404} {E89B69FA-5B8B-4921-97BF-AA8FB60C7A15} = {694561D4-7901-4727-B87C-109C7CED0404} + {A505A56D-3241-4471-8BFE-B09F1F59BE77} = {694561D4-7901-4727-B87C-109C7CED0404} {EDF8F173-CFE7-40FB-8EEB-795A1DFB6D99} = {694561D4-7901-4727-B87C-109C7CED0404} {D8A16E22-8BF8-49ED-A033-0150D6341282} = {694561D4-7901-4727-B87C-109C7CED0404} {5C6A1B61-B02B-46AA-8AD5-B8F61EE57453} = {694561D4-7901-4727-B87C-109C7CED0404} diff --git a/src/libraries/Microsoft.Extensions.Hosting.Systemd/src/SystemdHelpers.cs b/src/libraries/Microsoft.Extensions.Hosting.Systemd/src/SystemdHelpers.cs index 53d382c5e7c..0094144b740 100644 --- a/src/libraries/Microsoft.Extensions.Hosting.Systemd/src/SystemdHelpers.cs +++ b/src/libraries/Microsoft.Extensions.Hosting.Systemd/src/SystemdHelpers.cs @@ -19,7 +19,7 @@ public static class SystemdHelpers private static readonly bool _isSystemdService = GetIsSystemdService(); /// - /// Check if the current process is hosted as a systemd Service. + /// Checks if the current process is hosted as a systemd Service. /// /// /// if the current process is hosted as a systemd Service; otherwise, . diff --git a/src/libraries/Microsoft.Extensions.Hosting.Systemd/src/SystemdNotifier.cs b/src/libraries/Microsoft.Extensions.Hosting.Systemd/src/SystemdNotifier.cs index 2bc1865423f..a27a7c9154e 100644 --- a/src/libraries/Microsoft.Extensions.Hosting.Systemd/src/SystemdNotifier.cs +++ b/src/libraries/Microsoft.Extensions.Hosting.Systemd/src/SystemdNotifier.cs @@ -41,6 +41,12 @@ public void Notify(ServiceState state) return; } +#if !NETSTANDARD2_1 && !NETSTANDARD2_0 && !NETFRAMEWORK // TODO remove with https://github.com/dotnet/runtime/pull/107185 + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); +#else + #pragma warning disable CA1416 +#endif + using (var socket = new Socket(AddressFamily.Unix, SocketType.Dgram, ProtocolType.Unspecified)) { var endPoint = new UnixDomainSocketEndPoint(_socketPath!); diff --git a/src/libraries/Microsoft.Extensions.Hosting.WindowsServices/Microsoft.Extensions.Hosting.WindowsServices.sln b/src/libraries/Microsoft.Extensions.Hosting.WindowsServices/Microsoft.Extensions.Hosting.WindowsServices.sln index 0ce0f5d8e72..18bba6f5849 100644 --- a/src/libraries/Microsoft.Extensions.Hosting.WindowsServices/Microsoft.Extensions.Hosting.WindowsServices.sln +++ b/src/libraries/Microsoft.Extensions.Hosting.WindowsServices/Microsoft.Extensions.Hosting.WindowsServices.sln @@ -149,6 +149,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Memory", "..\System. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{72D5BDD7-85ED-4CBF-9659-5AE4BD863A4C}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{3562B514-94AB-414F-9BE5-47ABC1714E03}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{34C7A201-C14D-4586-9903-8358EF179EAD}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{11EE7722-5FA4-403C-B53B-59A154EE0267}" @@ -507,6 +509,10 @@ Global {72D5BDD7-85ED-4CBF-9659-5AE4BD863A4C}.Debug|Any CPU.Build.0 = Debug|Any CPU {72D5BDD7-85ED-4CBF-9659-5AE4BD863A4C}.Release|Any CPU.ActiveCfg = Release|Any CPU {72D5BDD7-85ED-4CBF-9659-5AE4BD863A4C}.Release|Any CPU.Build.0 = Release|Any CPU + {3562B514-94AB-414F-9BE5-47ABC1714E03}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {3562B514-94AB-414F-9BE5-47ABC1714E03}.Debug|Any CPU.Build.0 = Debug|Any CPU + {3562B514-94AB-414F-9BE5-47ABC1714E03}.Release|Any CPU.ActiveCfg = Release|Any CPU + {3562B514-94AB-414F-9BE5-47ABC1714E03}.Release|Any CPU.Build.0 = Release|Any CPU {34C7A201-C14D-4586-9903-8358EF179EAD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {34C7A201-C14D-4586-9903-8358EF179EAD}.Debug|Any CPU.Build.0 = Debug|Any CPU {34C7A201-C14D-4586-9903-8358EF179EAD}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -666,6 +672,7 @@ Global {ACA22F95-D64E-462A-99C6-CB31B3F45347} = {0D30E826-4EE9-4404-A74D-5255FDB76A12} {E5CD419F-E73D-4BFF-B9D8-ACDE673E31BF} = {0D30E826-4EE9-4404-A74D-5255FDB76A12} {72D5BDD7-85ED-4CBF-9659-5AE4BD863A4C} = {0D30E826-4EE9-4404-A74D-5255FDB76A12} + {3562B514-94AB-414F-9BE5-47ABC1714E03} = {0D30E826-4EE9-4404-A74D-5255FDB76A12} {34C7A201-C14D-4586-9903-8358EF179EAD} = {0D30E826-4EE9-4404-A74D-5255FDB76A12} {11EE7722-5FA4-403C-B53B-59A154EE0267} = {0D30E826-4EE9-4404-A74D-5255FDB76A12} {0EC461A2-083B-4E9E-AADE-935ECB15B951} = {0D30E826-4EE9-4404-A74D-5255FDB76A12} diff --git a/src/libraries/Microsoft.Extensions.Hosting.WindowsServices/src/WindowsServiceLifetime.cs b/src/libraries/Microsoft.Extensions.Hosting.WindowsServices/src/WindowsServiceLifetime.cs index a1561b110cb..65d220058ac 100644 --- a/src/libraries/Microsoft.Extensions.Hosting.WindowsServices/src/WindowsServiceLifetime.cs +++ b/src/libraries/Microsoft.Extensions.Hosting.WindowsServices/src/WindowsServiceLifetime.cs @@ -140,9 +140,11 @@ protected override void OnStart(string[] args) /// /// Executes when a Stop command is sent to the service by the Service Control Manager (SCM). - /// Triggers and waits for . - /// Shortly after this method returns, the Service will be marked as stopped in SCM and the process may exit at any point. /// + /// + /// Triggers and waits for . + /// Shortly after this method returns, the Service will be marked as stopped in SCM and the process might exit at any point. + /// protected override void OnStop() { _serviceStopRequested = true; @@ -154,9 +156,11 @@ protected override void OnStop() /// /// Executes when a Shutdown command is sent to the service by the Service Control Manager (SCM). - /// Triggers and waits for . - /// Shortly after this method returns, the Service will be marked as stopped in SCM and the process may exit at any point. /// + /// + /// Triggers and waits for . + /// Shortly after this method returns, the Service will be marked as stopped in SCM and the process might exit at any point. + /// protected override void OnShutdown() { _serviceStopRequested = true; diff --git a/src/libraries/Microsoft.Extensions.Hosting.WindowsServices/src/WindowsServiceLifetimeOptions.cs b/src/libraries/Microsoft.Extensions.Hosting.WindowsServices/src/WindowsServiceLifetimeOptions.cs index c1858dbe0c7..abc5aefeabb 100644 --- a/src/libraries/Microsoft.Extensions.Hosting.WindowsServices/src/WindowsServiceLifetimeOptions.cs +++ b/src/libraries/Microsoft.Extensions.Hosting.WindowsServices/src/WindowsServiceLifetimeOptions.cs @@ -6,7 +6,7 @@ namespace Microsoft.Extensions.Hosting { /// - /// Options to configure the lifetime of a windows service. + /// Specifies options to configure the lifetime of a Windows service. /// public class WindowsServiceLifetimeOptions { diff --git a/src/libraries/Microsoft.Extensions.Hosting.WindowsServices/tests/WindowsServiceTester.cs b/src/libraries/Microsoft.Extensions.Hosting.WindowsServices/tests/WindowsServiceTester.cs index 880fae3e046..e39313c0f18 100644 --- a/src/libraries/Microsoft.Extensions.Hosting.WindowsServices/tests/WindowsServiceTester.cs +++ b/src/libraries/Microsoft.Extensions.Hosting.WindowsServices/tests/WindowsServiceTester.cs @@ -48,7 +48,7 @@ private WindowsServiceTester(SafeServiceHandle serviceHandle, RemoteInvokeHandle { } } - public static TimeSpan WaitForStatusTimeout { get; set; } = TimeSpan.FromSeconds(30); + public static TimeSpan WaitForStatusTimeout { get; set; } = TimeSpan.FromMinutes(3); public new void WaitForStatus(ServiceControllerStatus desiredStatus) => WaitForStatus(desiredStatus, WaitForStatusTimeout); @@ -61,15 +61,15 @@ private WindowsServiceTester(SafeServiceHandle serviceHandle, RemoteInvokeHandle } // the following overloads are necessary to ensure the compiler will produce the correct signature from a lambda. - public static WindowsServiceTester Create(Func serviceMain, [CallerMemberName] string serviceName = null) => Create(RemoteExecutor.Invoke(serviceMain, remoteInvokeOptions), serviceName); + public static WindowsServiceTester Create(Func serviceMain, [CallerMemberName] string serviceName = null) => Create(RemoteExecutor.Invoke(serviceMain, CreateRemoteInvokeOptions()), serviceName); - public static WindowsServiceTester Create(Func> serviceMain, [CallerMemberName] string serviceName = null) => Create(RemoteExecutor.Invoke(serviceMain, remoteInvokeOptions), serviceName); + public static WindowsServiceTester Create(Func> serviceMain, [CallerMemberName] string serviceName = null) => Create(RemoteExecutor.Invoke(serviceMain, CreateRemoteInvokeOptions()), serviceName); - public static WindowsServiceTester Create(Func serviceMain, [CallerMemberName] string serviceName = null) => Create(RemoteExecutor.Invoke(serviceMain, remoteInvokeOptions), serviceName); + public static WindowsServiceTester Create(Func serviceMain, [CallerMemberName] string serviceName = null) => Create(RemoteExecutor.Invoke(serviceMain, CreateRemoteInvokeOptions()), serviceName); - public static WindowsServiceTester Create(Action serviceMain, [CallerMemberName] string serviceName = null) => Create(RemoteExecutor.Invoke(serviceMain, remoteInvokeOptions), serviceName); + public static WindowsServiceTester Create(Action serviceMain, [CallerMemberName] string serviceName = null) => Create(RemoteExecutor.Invoke(serviceMain, CreateRemoteInvokeOptions()), serviceName); - private static RemoteInvokeOptions remoteInvokeOptions = new RemoteInvokeOptions() { Start = false }; + private static RemoteInvokeOptions CreateRemoteInvokeOptions() => new RemoteInvokeOptions() { Start = false }; private static WindowsServiceTester Create(RemoteInvokeHandle remoteInvokeHandle, string serviceName) { diff --git a/src/libraries/Microsoft.Extensions.Hosting/Microsoft.Extensions.Hosting.sln b/src/libraries/Microsoft.Extensions.Hosting/Microsoft.Extensions.Hosting.sln index db22fb4c009..dac77be68c0 100644 --- a/src/libraries/Microsoft.Extensions.Hosting/Microsoft.Extensions.Hosting.sln +++ b/src/libraries/Microsoft.Extensions.Hosting/Microsoft.Extensions.Hosting.sln @@ -149,6 +149,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Memory", "..\System. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{CCF8862C-E2D7-45B0-96EF-54134178DA5A}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{38E4B9C2-B9D9-42DC-86A8-865496A5F871}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{C00722C2-E56B-424F-9216-FA6A91788986}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{90DD4D77-E3DC-456E-A27F-F13DA6194481}" @@ -503,6 +505,10 @@ Global {CCF8862C-E2D7-45B0-96EF-54134178DA5A}.Debug|Any CPU.Build.0 = Debug|Any CPU {CCF8862C-E2D7-45B0-96EF-54134178DA5A}.Release|Any CPU.ActiveCfg = Release|Any CPU {CCF8862C-E2D7-45B0-96EF-54134178DA5A}.Release|Any CPU.Build.0 = Release|Any CPU + {38E4B9C2-B9D9-42DC-86A8-865496A5F871}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {38E4B9C2-B9D9-42DC-86A8-865496A5F871}.Debug|Any CPU.Build.0 = Debug|Any CPU + {38E4B9C2-B9D9-42DC-86A8-865496A5F871}.Release|Any CPU.ActiveCfg = Release|Any CPU + {38E4B9C2-B9D9-42DC-86A8-865496A5F871}.Release|Any CPU.Build.0 = Release|Any CPU {C00722C2-E56B-424F-9216-FA6A91788986}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {C00722C2-E56B-424F-9216-FA6A91788986}.Debug|Any CPU.Build.0 = Debug|Any CPU {C00722C2-E56B-424F-9216-FA6A91788986}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -652,6 +658,7 @@ Global {3F732A69-1E48-4EA7-A40E-9C6C9332388E} = {A9A8D649-4C09-4FD1-9837-EE7B9D902253} {85C80343-56B0-4D77-8A5F-8E4A773F103C} = {A9A8D649-4C09-4FD1-9837-EE7B9D902253} {CCF8862C-E2D7-45B0-96EF-54134178DA5A} = {A9A8D649-4C09-4FD1-9837-EE7B9D902253} + {38E4B9C2-B9D9-42DC-86A8-865496A5F871} = {A9A8D649-4C09-4FD1-9837-EE7B9D902253} {C00722C2-E56B-424F-9216-FA6A91788986} = {A9A8D649-4C09-4FD1-9837-EE7B9D902253} {90DD4D77-E3DC-456E-A27F-F13DA6194481} = {A9A8D649-4C09-4FD1-9837-EE7B9D902253} {0A495D7B-44DE-4E59-8497-6CBF7C55CFA5} = {A9A8D649-4C09-4FD1-9837-EE7B9D902253} diff --git a/src/libraries/Microsoft.Extensions.Hosting/src/HostBuilder.netcoreapp.cs b/src/libraries/Microsoft.Extensions.Hosting/src/HostBuilder.netcoreapp.cs index 1407f690de3..453f92886d3 100644 --- a/src/libraries/Microsoft.Extensions.Hosting/src/HostBuilder.netcoreapp.cs +++ b/src/libraries/Microsoft.Extensions.Hosting/src/HostBuilder.netcoreapp.cs @@ -11,7 +11,7 @@ public partial class HostBuilder { private static void AddLifetime(IServiceCollection services) { - if (!OperatingSystem.IsAndroid() && !OperatingSystem.IsBrowser() && !OperatingSystem.IsIOS() && !OperatingSystem.IsTvOS()) + if (!OperatingSystem.IsAndroid() && !OperatingSystem.IsBrowser() && !OperatingSystem.IsWasi() && !OperatingSystem.IsIOS() && !OperatingSystem.IsTvOS()) { services.AddSingleton(); } diff --git a/src/libraries/Microsoft.Extensions.Hosting/src/HostingHostBuilderExtensions.cs b/src/libraries/Microsoft.Extensions.Hosting/src/HostingHostBuilderExtensions.cs index 09274bad3a3..73313d9c020 100644 --- a/src/libraries/Microsoft.Extensions.Hosting/src/HostingHostBuilderExtensions.cs +++ b/src/libraries/Microsoft.Extensions.Hosting/src/HostingHostBuilderExtensions.cs @@ -293,7 +293,7 @@ internal static void AddDefaultServices(HostBuilderContext hostingContext, IServ logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging")); #if NET - if (!OperatingSystem.IsBrowser()) + if (!OperatingSystem.IsBrowser() && !OperatingSystem.IsWasi()) #endif { logging.AddConsole(); diff --git a/src/libraries/Microsoft.Extensions.Hosting/src/Internal/ConsoleLifetime.cs b/src/libraries/Microsoft.Extensions.Hosting/src/Internal/ConsoleLifetime.cs index 09f0a326ce0..a146865e6a8 100644 --- a/src/libraries/Microsoft.Extensions.Hosting/src/Internal/ConsoleLifetime.cs +++ b/src/libraries/Microsoft.Extensions.Hosting/src/Internal/ConsoleLifetime.cs @@ -24,21 +24,21 @@ public partial class ConsoleLifetime : IHostLifetime, IDisposable private CancellationTokenRegistration _applicationStoppingRegistration; /// - /// Initializes a instance using the specified console lifetime options, host environment, host application lifetime and host options. + /// Initializes a instance using the specified console lifetime options, host environment, host application lifetime, and host options. /// /// An object used to retrieve instances. - /// An object that contains information about the hosting environment an application is running in. + /// Information about the hosting environment an application is running in. /// An object that allows consumers to be notified of application lifetime events. - /// An object used to retrieve instances. + /// An object used to retrieve internal host options instances. /// or or or is . public ConsoleLifetime(IOptions options, IHostEnvironment environment, IHostApplicationLifetime applicationLifetime, IOptions hostOptions) : this(options, environment, applicationLifetime, hostOptions, NullLoggerFactory.Instance) { } /// - /// Initializes a instance using the specified console lifetime options, host environment, host options and logger factory. + /// Initializes a instance using the specified console lifetime options, host environment, host options, and logger factory. /// - /// An object used to retrieve instances - /// An object that contains information about the hosting environment an application is running in. + /// An object used to retrieve instances. + /// Information about the hosting environment an application is running in. /// An object that allows consumers to be notified of application lifetime events. /// An object used to retrieve instances. /// An object to configure the logging system and create instances of from the registered . diff --git a/src/libraries/Microsoft.Extensions.Hosting/tests/UnitTests/Microsoft.Extensions.Hosting.Unit.Tests.csproj b/src/libraries/Microsoft.Extensions.Hosting/tests/UnitTests/Microsoft.Extensions.Hosting.Unit.Tests.csproj index 494c88fba49..962f3f02fca 100644 --- a/src/libraries/Microsoft.Extensions.Hosting/tests/UnitTests/Microsoft.Extensions.Hosting.Unit.Tests.csproj +++ b/src/libraries/Microsoft.Extensions.Hosting/tests/UnitTests/Microsoft.Extensions.Hosting.Unit.Tests.csproj @@ -19,4 +19,11 @@ + + + + + diff --git a/src/libraries/Microsoft.Extensions.Http/Microsoft.Extensions.Http.sln b/src/libraries/Microsoft.Extensions.Http/Microsoft.Extensions.Http.sln index 7f2baaf6515..7f166c65f28 100644 --- a/src/libraries/Microsoft.Extensions.Http/Microsoft.Extensions.Http.sln +++ b/src/libraries/Microsoft.Extensions.Http/Microsoft.Extensions.Http.sln @@ -73,6 +73,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Diagnostics.Diagnost EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{B11D1627-86EC-4E6D-A184-868DD220AB9B}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{E19D258F-9686-423C-9931-52CE3DC846DD}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{083B8368-1518-40DE-904F-CD028C8E21F1}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{167FDAED-3220-4516-AC8F-C506F593896D}" @@ -259,6 +261,10 @@ Global {B11D1627-86EC-4E6D-A184-868DD220AB9B}.Debug|Any CPU.Build.0 = Debug|Any CPU {B11D1627-86EC-4E6D-A184-868DD220AB9B}.Release|Any CPU.ActiveCfg = Release|Any CPU {B11D1627-86EC-4E6D-A184-868DD220AB9B}.Release|Any CPU.Build.0 = Release|Any CPU + {E19D258F-9686-423C-9931-52CE3DC846DD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E19D258F-9686-423C-9931-52CE3DC846DD}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E19D258F-9686-423C-9931-52CE3DC846DD}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E19D258F-9686-423C-9931-52CE3DC846DD}.Release|Any CPU.Build.0 = Release|Any CPU {083B8368-1518-40DE-904F-CD028C8E21F1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {083B8368-1518-40DE-904F-CD028C8E21F1}.Debug|Any CPU.Build.0 = Debug|Any CPU {083B8368-1518-40DE-904F-CD028C8E21F1}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -334,6 +340,7 @@ Global {E0BC3CBF-BE02-4228-AF7F-876CC4C832EA} = {D1CE7D63-2182-40E3-83E0-618DA3770779} {34143E09-2676-4D22-B454-B719EF0629DA} = {D1CE7D63-2182-40E3-83E0-618DA3770779} {B11D1627-86EC-4E6D-A184-868DD220AB9B} = {D1CE7D63-2182-40E3-83E0-618DA3770779} + {E19D258F-9686-423C-9931-52CE3DC846DD} = {D1CE7D63-2182-40E3-83E0-618DA3770779} {083B8368-1518-40DE-904F-CD028C8E21F1} = {D1CE7D63-2182-40E3-83E0-618DA3770779} {167FDAED-3220-4516-AC8F-C506F593896D} = {D1CE7D63-2182-40E3-83E0-618DA3770779} {DFABB1CD-6617-4548-8C8A-5EF3A420064A} = {FDC92BCB-A135-47C1-A3A3-30D5D743D0A1} diff --git a/src/libraries/Microsoft.Extensions.Http/src/DependencyInjection/HttpClientBuilderExtensions.Logging.cs b/src/libraries/Microsoft.Extensions.Http/src/DependencyInjection/HttpClientBuilderExtensions.Logging.cs index f87aff245cd..bf1b3c6d4ae 100644 --- a/src/libraries/Microsoft.Extensions.Http/src/DependencyInjection/HttpClientBuilderExtensions.Logging.cs +++ b/src/libraries/Microsoft.Extensions.Http/src/DependencyInjection/HttpClientBuilderExtensions.Logging.cs @@ -21,14 +21,14 @@ public static partial class HttpClientBuilderExtensions /// An that can be used to configure the client. /// /// - /// If the is `true`, and + /// If the is `true`, and /// would be executed before all /// other additional handlers in the chain. and /// would be executed after all /// other additional handlers, essentially wrapping the whole pipeline. /// /// - /// If the is `false`, and + /// If the is `false`, and /// would be executed after all /// other additional handlers in the chain, right before the primary handler. and /// would be executed before all @@ -83,14 +83,14 @@ public static IHttpClientBuilder AddLogger(this IHttpClientBuilder builder, Func /// /// /// - /// If the is `true`, and + /// If the is `true`, and /// would be executed before all /// other additional handlers in the chain. and /// would be executed after all /// other additional handlers, essentially wrapping the whole pipeline. /// /// - /// If the is `false`, and + /// If the is `false`, and /// would be executed after all /// other additional handlers in the chain, right before the primary handler. and /// would be executed before all diff --git a/src/libraries/Microsoft.Extensions.Http/src/DependencyInjection/HttpClientBuilderExtensions.cs b/src/libraries/Microsoft.Extensions.Http/src/DependencyInjection/HttpClientBuilderExtensions.cs index ebda07a8f77..7b93ebe2ea1 100644 --- a/src/libraries/Microsoft.Extensions.Http/src/DependencyInjection/HttpClientBuilderExtensions.cs +++ b/src/libraries/Microsoft.Extensions.Http/src/DependencyInjection/HttpClientBuilderExtensions.cs @@ -15,7 +15,7 @@ namespace Microsoft.Extensions.DependencyInjection { /// - /// Extension methods for configuring an + /// Extension methods for configuring an . /// public static partial class HttpClientBuilderExtensions { @@ -68,7 +68,7 @@ public static IHttpClientBuilder ConfigureHttpClient(this IHttpClientBuilder bui /// A delegate that is used to create a . /// An that can be used to configure the client. /// - /// The delegate should return a new instance of the message handler each time it + /// The delegate should return a new instance of the message handler each time it /// is invoked. /// public static IHttpClientBuilder AddHttpMessageHandler(this IHttpClientBuilder builder, Func configureHandler) @@ -88,10 +88,11 @@ public static IHttpClientBuilder AddHttpMessageHandler(this IHttpClientBuilder b /// Adds a delegate that will be used to create an additional message handler for a named . /// /// The . - /// A delegate that is used to create a . /// An that can be used to configure the client. + /// A delegate that is used to create a . + /// An that can be used to configure the client. /// /// - /// The delegate should return a new instance of the message handler each time it + /// The delegate should return a new instance of the message handler each time it /// is invoked. /// /// @@ -147,7 +148,7 @@ public static IHttpClientBuilder AddHttpMessageHandler(this IHttpClien /// A delegate that is used to create an . /// An that can be used to configure the client. /// - /// The delegate should return a new instance of the message handler each time it + /// The delegate should return a new instance of the message handler each time it /// is invoked. /// public static IHttpClientBuilder ConfigurePrimaryHttpMessageHandler(this IHttpClientBuilder builder, Func configureHandler) @@ -172,7 +173,7 @@ public static IHttpClientBuilder ConfigurePrimaryHttpMessageHandler(this IHttpCl /// An that can be used to configure the client. /// /// - /// The delegate should return a new instance of the message handler each time it + /// The delegate should return a new instance of the message handler each time it /// is invoked. /// /// @@ -195,7 +196,7 @@ public static IHttpClientBuilder ConfigurePrimaryHttpMessageHandler(this IHttpCl /// /// Configures the primary from the dependency injection container - /// for a named . + /// for a named . /// /// The . /// An that can be used to configure the client. @@ -645,16 +646,51 @@ public static IHttpClientBuilder ConfigureAdditionalHttpMessageHandlers(this IHt return builder; } -#pragma warning disable 1591 // TODO: Document this API. https://github.com/dotnet/runtime/issues/105974 + /// + /// Registers a named and the related handler pipeline as keyed + /// services with the client's name as the key, and a lifetime provided in the parameter. + /// By default, the lifetime is . + /// + /// The . + /// Lifetime of the keyed services registered. + /// An that can be used to configure the client. + /// + /// + /// A named client resolved from DI as a keyed service will behave similarly to a client you would create with . This + /// means that the client will continue reusing the same instance for the duration of , + /// and it will continue to use the separate, handler's DI scope instead of the scope it was resolved from. + /// + /// + /// WARNING: Registering the client as a keyed service will lead to the and + /// instances being captured by DI as both implement . This might lead to memory leaks if the client is resolved multiple times within a + /// service. + /// + /// + /// WARNING: In case of (1) a keyed registration, or (2) a keyed + /// injected into a service, or (3) long-running application scopes, + /// the instances will get captured by a singleton or a long-running scope, so they will NOT be able to participate in the handler rotation, + /// which can result in the loss of DNS changes. (This is a similar issue to the one with Typed Clients, that are registered as services.) + /// + /// + /// If called twice with for a builder with the same name, the lifetime of the keyed service will be updated to the latest used value. + /// + /// + /// If called for a typed client, only the related named client and handler will be registered as keyed. The typed client itself will continue to be registered as + /// a transient service. + /// + /// + /// If used in conjunction with , + /// the key is used, so any named instance will be resolvable as a keyed service (unless explicitly opted-out + /// from the keyed registration via ). + /// + /// public static IHttpClientBuilder AddAsKeyed(this IHttpClientBuilder builder, ServiceLifetime lifetime = ServiceLifetime.Scoped) { ThrowHelper.ThrowIfNull(builder); string? name = builder.Name; IServiceCollection services = builder.Services; - HttpClientMappingRegistry registry = GetMappingRegistry(services); - - UpdateEmptyNameHttpClient(services, registry); + HttpClientMappingRegistry registry = services.GetMappingRegistry(); if (name == null) { @@ -678,15 +714,25 @@ public static IHttpClientBuilder AddAsKeyed(this IHttpClientBuilder builder, Ser return builder; } + /// + /// Removes the keyed registrations for the named and . + /// + /// The . + /// An that can be used to configure the client. + /// + /// + /// If used in conjunction with , + /// it will only affect the previous "global" registration, and won't affect the clients registered for a specific name + /// with . + /// + /// public static IHttpClientBuilder RemoveAsKeyed(this IHttpClientBuilder builder) { ThrowHelper.ThrowIfNull(builder); string? name = builder.Name; IServiceCollection services = builder.Services; - HttpClientMappingRegistry registry = GetMappingRegistry(services); - - UpdateEmptyNameHttpClient(services, registry); + HttpClientMappingRegistry registry = services.GetMappingRegistry(); if (name == null) { @@ -704,32 +750,6 @@ public static IHttpClientBuilder RemoveAsKeyed(this IHttpClientBuilder builder) return builder; } -#pragma warning restore 1591 - - // workaround for https://github.com/dotnet/runtime/issues/102654 - private static void UpdateEmptyNameHttpClient(IServiceCollection services, HttpClientMappingRegistry registry) - { - if (registry.EmptyNameHttpClientDescriptor is not null) - { - bool removed = services.Remove(registry.EmptyNameHttpClientDescriptor); - - if (removed) - { - // trying to add it as keyed instead - if (!registry.KeyedLifetimeMap.ContainsKey(string.Empty)) - { - var clientLifetime = new HttpClientKeyedLifetime(string.Empty, ServiceLifetime.Transient); - registry.KeyedLifetimeMap[string.Empty] = clientLifetime; - clientLifetime.AddRegistration(services); - } - } - } - - if (services.Any(sd => sd.ServiceType == typeof(HttpClient) && sd.ServiceKey is null)) - { - throw new InvalidOperationException($"{nameof(AddAsKeyed)} isn't supported when {nameof(HttpClient)} is registered as a service."); - } - } // See comments on HttpClientMappingRegistry. private static void ReserveClient(IHttpClientBuilder builder, Type type, string name, bool validateSingleType) @@ -763,7 +783,11 @@ private static void ReserveClient(IHttpClientBuilder builder, Type type, string } } - private static HttpClientMappingRegistry GetMappingRegistry(IServiceCollection services) - => HttpClientFactoryServiceCollectionExtensions.GetMappingRegistry(services); + internal static HttpClientMappingRegistry GetMappingRegistry(this IServiceCollection services) + { + var registry = (HttpClientMappingRegistry?)services.Single(sd => sd.ServiceType == typeof(HttpClientMappingRegistry)).ImplementationInstance; + Debug.Assert(registry != null); + return registry; + } } } diff --git a/src/libraries/Microsoft.Extensions.Http/src/DependencyInjection/HttpClientFactoryServiceCollectionExtensions.cs b/src/libraries/Microsoft.Extensions.Http/src/DependencyInjection/HttpClientFactoryServiceCollectionExtensions.cs index 239a7bd8525..c2ed4860643 100644 --- a/src/libraries/Microsoft.Extensions.Http/src/DependencyInjection/HttpClientFactoryServiceCollectionExtensions.cs +++ b/src/libraries/Microsoft.Extensions.Http/src/DependencyInjection/HttpClientFactoryServiceCollectionExtensions.cs @@ -63,7 +63,10 @@ public static IServiceCollection AddHttpClient(this IServiceCollection services) services.TryAddSingleton(new DefaultHttpClientConfigurationTracker()); // Register default client as HttpClient - TryAddEmptyNameHttpClient(services); + services.TryAddTransient(s => + { + return s.GetRequiredService().CreateClient(string.Empty); + }); return services; } @@ -219,7 +222,7 @@ public static IHttpClientBuilder AddHttpClient(this IServiceCollection services, /// /// /// The implementation type of the typed client. The type specified will be instantiated by the - /// + /// . /// /// The . /// An that can be used to configure the client. @@ -298,7 +301,7 @@ public static IHttpClientBuilder AddHttpClient(this IServiceCollection services, /// /// /// The implementation type of the typed client. The type specified will be instantiated by the - /// + /// . /// /// The . /// The logical name of the to configure. @@ -421,7 +424,7 @@ public static IHttpClientBuilder AddHttpClient(this IServiceCollection services, /// /// /// The implementation type of the typed client. The type specified will be instantiated by the - /// + /// . /// /// The . /// A delegate that is used to configure an . @@ -465,7 +468,7 @@ public static IHttpClientBuilder AddHttpClient(this IServiceCollection services, /// /// /// The implementation type of the typed client. The type specified will be instantiated by the - /// + /// . /// /// The . /// A delegate that is used to configure an . @@ -592,7 +595,7 @@ public static IHttpClientBuilder AddHttpClient(this IServiceCollection services, /// /// /// The implementation type of the typed client. The type specified will be instantiated by the - /// + /// . /// /// The . /// The logical name of the to configure. @@ -639,7 +642,7 @@ public static IHttpClientBuilder AddHttpClient(this IServiceCollection services, /// /// /// The implementation type of the typed client. The type specified will be instantiated by the - /// + /// . /// /// The . /// The logical name of the to configure. @@ -831,34 +834,5 @@ public static IHttpClientBuilder AddHttpClient(this IS builder.AddTypedClient(factory); return builder; } - - internal static HttpClientMappingRegistry GetMappingRegistry(IServiceCollection services) - { - var registry = (HttpClientMappingRegistry?)services.Single(sd => sd.ServiceType == typeof(HttpClientMappingRegistry)).ImplementationInstance; - Debug.Assert(registry != null); - return registry; - } - - private static void TryAddEmptyNameHttpClient(IServiceCollection services) - { - HttpClientMappingRegistry mappingRegistry = GetMappingRegistry(services); - - if (mappingRegistry.EmptyNameHttpClientDescriptor is not null) - { - return; - } - - if (services.Any(sd => sd.ServiceType == typeof(HttpClient) && sd.ServiceKey is null)) - { - return; - } - - mappingRegistry.EmptyNameHttpClientDescriptor = ServiceDescriptor.Transient(s => - { - return s.GetRequiredService().CreateClient(string.Empty); - }); - - services.Add(mappingRegistry.EmptyNameHttpClientDescriptor); - } } } diff --git a/src/libraries/Microsoft.Extensions.Http/src/DependencyInjection/HttpClientMappingRegistry.cs b/src/libraries/Microsoft.Extensions.Http/src/DependencyInjection/HttpClientMappingRegistry.cs index 73ca788cd81..3c47458430f 100644 --- a/src/libraries/Microsoft.Extensions.Http/src/DependencyInjection/HttpClientMappingRegistry.cs +++ b/src/libraries/Microsoft.Extensions.Http/src/DependencyInjection/HttpClientMappingRegistry.cs @@ -18,7 +18,5 @@ internal sealed class HttpClientMappingRegistry public Dictionary KeyedLifetimeMap { get; } = new(); public HttpClientKeyedLifetime? DefaultKeyedLifetime { get; set; } - - public ServiceDescriptor? EmptyNameHttpClientDescriptor { get; set; } } } diff --git a/src/libraries/Microsoft.Extensions.Http/src/DependencyInjection/ISocketsHttpHandlerBuilder.cs b/src/libraries/Microsoft.Extensions.Http/src/DependencyInjection/ISocketsHttpHandlerBuilder.cs index 75333f8d747..c942b42c580 100644 --- a/src/libraries/Microsoft.Extensions.Http/src/DependencyInjection/ISocketsHttpHandlerBuilder.cs +++ b/src/libraries/Microsoft.Extensions.Http/src/DependencyInjection/ISocketsHttpHandlerBuilder.cs @@ -5,7 +5,7 @@ namespace Microsoft.Extensions.DependencyInjection { /// - /// A builder for configuring for a named + /// Configures for a named /// instances returned by . /// public interface ISocketsHttpHandlerBuilder diff --git a/src/libraries/Microsoft.Extensions.Http/src/HttpClientFactoryOptions.cs b/src/libraries/Microsoft.Extensions.Http/src/HttpClientFactoryOptions.cs index ec82a6ca5e4..c3254d9a64f 100644 --- a/src/libraries/Microsoft.Extensions.Http/src/HttpClientFactoryOptions.cs +++ b/src/libraries/Microsoft.Extensions.Http/src/HttpClientFactoryOptions.cs @@ -6,6 +6,7 @@ using System.Net.Http; using System.Threading; using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Http.Logging; namespace Microsoft.Extensions.Http { @@ -72,7 +73,7 @@ public TimeSpan HandlerLifetime /// /// The which determines whether to redact the HTTP header value before logging. /// - public Func ShouldRedactHeaderValue { get; set; } = (header) => false; + public Func ShouldRedactHeaderValue { get; set; } = LogHelper.ShouldRedactHeaderValue; /// /// diff --git a/src/libraries/Microsoft.Extensions.Http/src/Logging/LogHelper.cs b/src/libraries/Microsoft.Extensions.Http/src/Logging/LogHelper.cs index 2a37f6b3f3d..da6c45d19c4 100644 --- a/src/libraries/Microsoft.Extensions.Http/src/Logging/LogHelper.cs +++ b/src/libraries/Microsoft.Extensions.Http/src/Logging/LogHelper.cs @@ -25,13 +25,19 @@ private static class EventIds public static readonly EventId RequestHeader = new EventId(102, "RequestHeader"); public static readonly EventId ResponseHeader = new EventId(103, "ResponseHeader"); + public static readonly EventId RequestFailed = new EventId(104, "RequestFailed"); + public static readonly EventId PipelineStart = new EventId(100, "RequestPipelineStart"); public static readonly EventId PipelineEnd = new EventId(101, "RequestPipelineEnd"); public static readonly EventId RequestPipelineRequestHeader = new EventId(102, "RequestPipelineRequestHeader"); public static readonly EventId RequestPipelineResponseHeader = new EventId(103, "RequestPipelineResponseHeader"); + + public static readonly EventId PipelineFailed = new EventId(104, "RequestPipelineFailed"); } + public static readonly Func ShouldRedactHeaderValue = (header) => true; + private static readonly Action _requestStart = LoggerMessage.Define( LogLevel.Information, EventIds.RequestStart, @@ -43,6 +49,11 @@ private static class EventIds EventIds.RequestEnd, "Received HTTP response headers after {ElapsedMilliseconds}ms - {StatusCode}"); + private static readonly Action _requestFailed = LoggerMessage.Define( + LogLevel.Information, + EventIds.RequestFailed, + "HTTP request failed after {ElapsedMilliseconds}ms"); + private static readonly Func _beginRequestPipelineScope = LoggerMessage.DefineScope("HTTP {HttpMethod} {Uri}"); private static readonly Action _requestPipelineStart = LoggerMessage.Define( @@ -55,6 +66,11 @@ private static class EventIds EventIds.PipelineEnd, "End processing HTTP request after {ElapsedMilliseconds}ms - {StatusCode}"); + private static readonly Action _requestPipelineFailed = LoggerMessage.Define( + LogLevel.Information, + EventIds.PipelineFailed, + "HTTP request failed after {ElapsedMilliseconds}ms"); + private static bool GetDisableUriRedactionSettingValue() { if (AppContext.TryGetSwitch("System.Net.Http.DisableUriRedaction", out bool value)) @@ -110,6 +126,9 @@ public static void LogRequestEnd(this ILogger logger, HttpResponseMessage respon } } + public static void LogRequestFailed(this ILogger logger, TimeSpan duration, HttpRequestException exception) => + _requestFailed(logger, duration.TotalMilliseconds, exception); + public static IDisposable? BeginRequestPipelineScope(this ILogger logger, HttpRequestMessage request, out string? formattedUri) { formattedUri = GetRedactedUriString(request.RequestUri); @@ -146,6 +165,9 @@ public static void LogRequestPipelineEnd(this ILogger logger, HttpResponseMessag } } + public static void LogRequestPipelineFailed(this ILogger logger, TimeSpan duration, HttpRequestException exception) => + _requestPipelineFailed(logger, duration.TotalMilliseconds, exception); + internal static string? GetRedactedUriString(Uri? uri) { if (uri is null) diff --git a/src/libraries/Microsoft.Extensions.Http/src/Logging/LoggingHttpMessageHandler.cs b/src/libraries/Microsoft.Extensions.Http/src/Logging/LoggingHttpMessageHandler.cs index c86d149a0f2..077d48382e8 100644 --- a/src/libraries/Microsoft.Extensions.Http/src/Logging/LoggingHttpMessageHandler.cs +++ b/src/libraries/Microsoft.Extensions.Http/src/Logging/LoggingHttpMessageHandler.cs @@ -19,8 +19,6 @@ public class LoggingHttpMessageHandler : DelegatingHandler private readonly ILogger _logger; private readonly HttpClientFactoryOptions? _options; - private static readonly Func _shouldNotRedactHeaderValue = (header) => false; - /// /// Initializes a new instance of the class with a specified logger. /// @@ -55,22 +53,31 @@ private Task SendCoreAsync(HttpRequestMessage request, bool async Task Core(HttpRequestMessage request, bool useAsync, CancellationToken cancellationToken) { - Func shouldRedactHeaderValue = _options?.ShouldRedactHeaderValue ?? _shouldNotRedactHeaderValue; + Func shouldRedactHeaderValue = _options?.ShouldRedactHeaderValue ?? LogHelper.ShouldRedactHeaderValue; // Not using a scope here because we always expect this to be at the end of the pipeline, thus there's // not really anything to surround. _logger.LogRequestStart(request, shouldRedactHeaderValue); var stopwatch = ValueStopwatch.StartNew(); - HttpResponseMessage response = useAsync - ? await base.SendAsync(request, cancellationToken).ConfigureAwait(false) + + try + { + HttpResponseMessage response = useAsync + ? await base.SendAsync(request, cancellationToken).ConfigureAwait(false) #if NET - : base.Send(request, cancellationToken); + : base.Send(request, cancellationToken); #else - : throw new NotImplementedException("Unreachable code"); + : throw new NotImplementedException("Unreachable code"); #endif - _logger.LogRequestEnd(response, stopwatch.GetElapsedTime(), shouldRedactHeaderValue); + _logger.LogRequestEnd(response, stopwatch.GetElapsedTime(), shouldRedactHeaderValue); - return response; + return response; + } + catch (HttpRequestException ex) + { + _logger.LogRequestFailed(stopwatch.GetElapsedTime(), ex); + throw; + } } } diff --git a/src/libraries/Microsoft.Extensions.Http/src/Logging/LoggingScopeHttpMessageHandler.cs b/src/libraries/Microsoft.Extensions.Http/src/Logging/LoggingScopeHttpMessageHandler.cs index a25a9366ac8..033234b38e4 100644 --- a/src/libraries/Microsoft.Extensions.Http/src/Logging/LoggingScopeHttpMessageHandler.cs +++ b/src/libraries/Microsoft.Extensions.Http/src/Logging/LoggingScopeHttpMessageHandler.cs @@ -18,8 +18,6 @@ public class LoggingScopeHttpMessageHandler : DelegatingHandler private readonly ILogger _logger; private readonly HttpClientFactoryOptions? _options; - private static readonly Func _shouldNotRedactHeaderValue = (header) => false; - /// /// Initializes a new instance of the class with a specified logger. /// @@ -56,21 +54,30 @@ async Task Core(HttpRequestMessage request, bool useAsync, { var stopwatch = ValueStopwatch.StartNew(); - Func shouldRedactHeaderValue = _options?.ShouldRedactHeaderValue ?? _shouldNotRedactHeaderValue; + Func shouldRedactHeaderValue = _options?.ShouldRedactHeaderValue ?? LogHelper.ShouldRedactHeaderValue; using (_logger.BeginRequestPipelineScope(request, out string? formattedUri)) { _logger.LogRequestPipelineStart(request, formattedUri, shouldRedactHeaderValue); - HttpResponseMessage response = useAsync - ? await base.SendAsync(request, cancellationToken).ConfigureAwait(false) + + try + { + HttpResponseMessage response = useAsync + ? await base.SendAsync(request, cancellationToken).ConfigureAwait(false) #if NET - : base.Send(request, cancellationToken); + : base.Send(request, cancellationToken); #else - : throw new NotImplementedException("Unreachable code"); + : throw new NotImplementedException("Unreachable code"); #endif - _logger.LogRequestPipelineEnd(response, stopwatch.GetElapsedTime(), shouldRedactHeaderValue); + _logger.LogRequestPipelineEnd(response, stopwatch.GetElapsedTime(), shouldRedactHeaderValue); - return response; + return response; + } + catch (HttpRequestException ex) + { + _logger.LogRequestPipelineFailed(stopwatch.GetElapsedTime(), ex); + throw; + } } } } diff --git a/src/libraries/Microsoft.Extensions.Http/src/MetricsFactoryHttpMessageHandlerFilter.cs b/src/libraries/Microsoft.Extensions.Http/src/MetricsFactoryHttpMessageHandlerFilter.cs index d55f35a2708..0a9193299f1 100644 --- a/src/libraries/Microsoft.Extensions.Http/src/MetricsFactoryHttpMessageHandlerFilter.cs +++ b/src/libraries/Microsoft.Extensions.Http/src/MetricsFactoryHttpMessageHandlerFilter.cs @@ -33,7 +33,7 @@ public Action Configure(Action d.ServiceType == typeof(HttpClient)); - Assert.False(emptyNameDescriptor.IsKeyedService); - - serviceCollection.AddHttpClient(Test).AddAsKeyed(); - - emptyNameDescriptor = Assert.Single(serviceCollection, d => d.ServiceType == typeof(HttpClient) && !(d.ServiceKey is string s && s == Test)); - Assert.True(emptyNameDescriptor.IsKeyedService); - Assert.Equal(string.Empty, emptyNameDescriptor.ServiceKey); - } - - [Fact] - public void AddAsKeyed_NonFactoryHttpClientAdded_Throws() // test for workaround for https://github.com/dotnet/runtime/issues/102654 - { - var serviceCollection = new ServiceCollection(); - - serviceCollection.AddSingleton(new HttpClient()); - - var emptyNameDescriptor = Assert.Single(serviceCollection, d => d.ServiceType == typeof(HttpClient)); - Assert.False(emptyNameDescriptor.IsKeyedService); - Assert.Equal(ServiceLifetime.Singleton, emptyNameDescriptor.Lifetime); - - var builder = serviceCollection.AddHttpClient(Test); - - emptyNameDescriptor = Assert.Single(serviceCollection, d => d.ServiceType == typeof(HttpClient)); - Assert.False(emptyNameDescriptor.IsKeyedService); - Assert.Equal(ServiceLifetime.Singleton, emptyNameDescriptor.Lifetime); - - Assert.Throws(() => builder.AddAsKeyed()); - } - [Fact] public void AddAsKeyed_ScopedLifetime() { @@ -150,10 +112,10 @@ public void RemoveAsKeyed_PerName_AnyKeyDescriptorRemains() } private static bool IsKeyedClientDescriptor(ServiceDescriptor descriptor) - => descriptor.ServiceType == typeof(HttpClient) && descriptor.IsKeyedService && (descriptor.ServiceKey is not string name || name.Length > 0); + => descriptor.IsKeyedService && descriptor.ServiceType == typeof(HttpClient); private static bool IsKeyedHandlerDescriptor(ServiceDescriptor descriptor) - => descriptor.ServiceType == typeof(HttpMessageHandler) && descriptor.IsKeyedService && (descriptor.ServiceKey is not string name || name.Length > 0); + => descriptor.IsKeyedService && descriptor.ServiceType == typeof(HttpMessageHandler); private static void AssertSingleKeyedClientDescriptor(IServiceCollection services, ServiceLifetime lifetime, object key) { diff --git a/src/libraries/Microsoft.Extensions.Http/tests/Microsoft.Extensions.Http.Tests/Logging/FailedHttpRequestLoggingTests.cs b/src/libraries/Microsoft.Extensions.Http/tests/Microsoft.Extensions.Http.Tests/Logging/FailedHttpRequestLoggingTests.cs new file mode 100644 index 00000000000..e1ab591fc47 --- /dev/null +++ b/src/libraries/Microsoft.Extensions.Http/tests/Microsoft.Extensions.Http.Tests/Logging/FailedHttpRequestLoggingTests.cs @@ -0,0 +1,77 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Linq; +using System.Net.Http; +using System.Threading; +using System.Threading.Tasks; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Logging.Testing; +using Xunit; + +namespace Microsoft.Extensions.Http.Tests.Logging +{ + public class FailedHttpRequestLoggingTests + { + private const string OuterLoggerName = "System.Net.Http.HttpClient.test.LogicalHandler"; + private const string InnerLoggerName = "System.Net.Http.HttpClient.test.ClientHandler"; + + private static class EventIds + { + public static readonly EventId RequestFailed = new EventId(104, "RequestFailed"); + public static readonly EventId PipelineFailed = new EventId(104, "RequestPipelineFailed"); + } + + [Fact] + public async Task FailedHttpRequestLogged() + { + // Arrange + var sink = new TestSink(); + + var serviceCollection = new ServiceCollection(); + serviceCollection.AddLogging(); + serviceCollection.AddSingleton(new TestLoggerFactory(sink, enabled: true)); + + // Act + serviceCollection + .AddHttpClient("test") + .ConfigurePrimaryHttpMessageHandler(() => new FailMessageHandler()); + + // Assert + var services = serviceCollection.BuildServiceProvider(); + + var client = services.GetRequiredService().CreateClient("test"); + + var request = new HttpRequestMessage(HttpMethod.Get, "http://example.com"); + + await Assert.ThrowsAsync(async () => + await client.SendAsync(request)); + + var messages = sink.Writes.ToArray(); + + var requestFailedMessage = Assert.Single(messages.Where(m => + { + return + m.EventId == EventIds.RequestFailed && + m.LoggerName == InnerLoggerName; + })); + var pipelineFailedMessage = Assert.Single(messages.Where(m => + { + return + m.EventId == EventIds.PipelineFailed && + m.LoggerName == OuterLoggerName; + })); + } + + private const string ExceptionMessage = "Dummy error message"; + + private class FailMessageHandler : HttpClientHandler + { + protected override Task SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) + { + throw new HttpRequestException(ExceptionMessage); + } + } + } +} diff --git a/src/libraries/Microsoft.Extensions.Http/tests/Microsoft.Extensions.Http.Tests/Logging/RedactedLogValueIntegrationTest.cs b/src/libraries/Microsoft.Extensions.Http/tests/Microsoft.Extensions.Http.Tests/Logging/RedactedLogValueIntegrationTest.cs index 20279de2598..e2c42c7bc0e 100644 --- a/src/libraries/Microsoft.Extensions.Http/tests/Microsoft.Extensions.Http.Tests/Logging/RedactedLogValueIntegrationTest.cs +++ b/src/libraries/Microsoft.Extensions.Http/tests/Microsoft.Extensions.Http.Tests/Logging/RedactedLogValueIntegrationTest.cs @@ -16,6 +16,9 @@ namespace Microsoft.Extensions.Http.Logging { public class RedactedLogValueIntegrationTest { + private const string OuterLoggerName = "System.Net.Http.HttpClient.test.LogicalHandler"; + private const string InnerLoggerName = "System.Net.Http.HttpClient.test.ClientHandler"; + private static class EventIds { public static readonly EventId RequestHeader = new EventId(102, "RequestHeader"); @@ -25,6 +28,91 @@ private static class EventIds public static readonly EventId RequestPipelineResponseHeader = new EventId(103, "RequestPipelineResponseHeader"); } + [Fact] + public async Task RedactLoggedHeadersNotCalled_AllValuesAreRedactedBeforeLogging() + { + // Arrange + var sink = new TestSink(); + + var serviceCollection = new ServiceCollection(); + serviceCollection.AddLogging(); + serviceCollection.AddSingleton(new TestLoggerFactory(sink, enabled: true)); + + // Act + serviceCollection + .AddHttpClient("test") + .ConfigurePrimaryHttpMessageHandler(() => new TestMessageHandler()); + + // Assert + var services = serviceCollection.BuildServiceProvider(); + + var client = services.GetRequiredService().CreateClient("test"); + + var request = new HttpRequestMessage(HttpMethod.Get, "http://example.com"); + request.Headers.Authorization = new AuthenticationHeaderValue("fake", "secret value"); + request.Headers.CacheControl = new CacheControlHeaderValue() { NoCache = true, }; + + await client.SendAsync(request); + + var messages = sink.Writes.ToArray(); + + var message = Assert.Single(messages.Where(m => + { + return + m.EventId == EventIds.RequestPipelineRequestHeader && + m.LoggerName == OuterLoggerName; + })); + Assert.StartsWith(LineEndingsHelper.Normalize( + """ + Request Headers: + Authorization: * + Cache-Control: * + """), + message.Message); + + message = Assert.Single(messages.Where(m => + { + return + m.EventId == EventIds.RequestHeader && + m.LoggerName == InnerLoggerName; + })); + Assert.StartsWith(LineEndingsHelper.Normalize( + """ + Request Headers: + Authorization: * + Cache-Control: * + """), + message.Message); + + message = Assert.Single(messages.Where(m => + { + return + m.EventId == EventIds.ResponseHeader && + m.LoggerName == InnerLoggerName; + })); + Assert.StartsWith(LineEndingsHelper.Normalize( + """ + Response Headers: + X-Sensitive: * + Y-Non-Sensitive: * + """), + message.Message); + + message = Assert.Single(messages.Where(m => + { + return + m.EventId == EventIds.RequestPipelineResponseHeader && + m.LoggerName == OuterLoggerName; + })); + Assert.StartsWith(LineEndingsHelper.Normalize( + """ + Response Headers: + X-Sensitive: * + Y-Non-Sensitive: * + """), + message.Message); + } + [Fact] public async Task RedactHeaderValueWithHeaderList_ValueIsRedactedBeforeLogging() { @@ -58,7 +146,7 @@ public async Task RedactHeaderValueWithHeaderList_ValueIsRedactedBeforeLogging() { return m.EventId == EventIds.RequestPipelineRequestHeader && - m.LoggerName == "System.Net.Http.HttpClient.test.LogicalHandler"; + m.LoggerName == OuterLoggerName; })); Assert.StartsWith(LineEndingsHelper.Normalize( @"Request Headers: @@ -70,7 +158,7 @@ public async Task RedactHeaderValueWithHeaderList_ValueIsRedactedBeforeLogging() { return m.EventId == EventIds.RequestHeader && - m.LoggerName == "System.Net.Http.HttpClient.test.ClientHandler"; + m.LoggerName == InnerLoggerName; })); Assert.StartsWith(LineEndingsHelper.Normalize( @"Request Headers: @@ -82,7 +170,7 @@ public async Task RedactHeaderValueWithHeaderList_ValueIsRedactedBeforeLogging() { return m.EventId == EventIds.ResponseHeader && - m.LoggerName == "System.Net.Http.HttpClient.test.ClientHandler"; + m.LoggerName == InnerLoggerName; })); Assert.StartsWith(LineEndingsHelper.Normalize( @"Response Headers: @@ -94,7 +182,7 @@ public async Task RedactHeaderValueWithHeaderList_ValueIsRedactedBeforeLogging() { return m.EventId == EventIds.RequestPipelineResponseHeader && - m.LoggerName == "System.Net.Http.HttpClient.test.LogicalHandler"; + m.LoggerName == OuterLoggerName; })); Assert.StartsWith(LineEndingsHelper.Normalize( @"Response Headers: @@ -139,7 +227,7 @@ public async Task RedactHeaderValueWithPredicate_ValueIsRedactedBeforeLogging() { return m.EventId == EventIds.RequestPipelineRequestHeader && - m.LoggerName == "System.Net.Http.HttpClient.test.LogicalHandler"; + m.LoggerName == OuterLoggerName; })); Assert.StartsWith(LineEndingsHelper.Normalize( @"Request Headers: @@ -151,7 +239,7 @@ public async Task RedactHeaderValueWithPredicate_ValueIsRedactedBeforeLogging() { return m.EventId == EventIds.RequestHeader && - m.LoggerName == "System.Net.Http.HttpClient.test.ClientHandler"; + m.LoggerName == InnerLoggerName; })); Assert.StartsWith(LineEndingsHelper.Normalize( @"Request Headers: @@ -163,7 +251,7 @@ public async Task RedactHeaderValueWithPredicate_ValueIsRedactedBeforeLogging() { return m.EventId == EventIds.ResponseHeader && - m.LoggerName == "System.Net.Http.HttpClient.test.ClientHandler"; + m.LoggerName == InnerLoggerName; })); Assert.StartsWith(LineEndingsHelper.Normalize( @"Response Headers: @@ -175,7 +263,7 @@ public async Task RedactHeaderValueWithPredicate_ValueIsRedactedBeforeLogging() { return m.EventId == EventIds.RequestPipelineResponseHeader && - m.LoggerName == "System.Net.Http.HttpClient.test.LogicalHandler"; + m.LoggerName == OuterLoggerName; })); Assert.StartsWith(LineEndingsHelper.Normalize( @"Response Headers: diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/Microsoft.Extensions.Logging.Abstractions.sln b/src/libraries/Microsoft.Extensions.Logging.Abstractions/Microsoft.Extensions.Logging.Abstractions.sln index cd1cb498c9b..7205e9e8027 100644 --- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/Microsoft.Extensions.Logging.Abstractions.sln +++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/Microsoft.Extensions.Logging.Abstractions.sln @@ -29,6 +29,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Diagnostics.Diagnost EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{FE6A1AA9-8D0B-4EC6-8D2A-C9D8EF183FDB}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{8F33CD11-661E-40F2-AE43-61DEB102D74A}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{852D4E16-58C3-47C2-A6BC-A5B12B37209F}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{6645D0C4-83D1-4426-B9CD-67096CB7A60F}" @@ -127,6 +129,10 @@ Global {FE6A1AA9-8D0B-4EC6-8D2A-C9D8EF183FDB}.Debug|Any CPU.Build.0 = Debug|Any CPU {FE6A1AA9-8D0B-4EC6-8D2A-C9D8EF183FDB}.Release|Any CPU.ActiveCfg = Release|Any CPU {FE6A1AA9-8D0B-4EC6-8D2A-C9D8EF183FDB}.Release|Any CPU.Build.0 = Release|Any CPU + {8F33CD11-661E-40F2-AE43-61DEB102D74A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {8F33CD11-661E-40F2-AE43-61DEB102D74A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {8F33CD11-661E-40F2-AE43-61DEB102D74A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {8F33CD11-661E-40F2-AE43-61DEB102D74A}.Release|Any CPU.Build.0 = Release|Any CPU {852D4E16-58C3-47C2-A6BC-A5B12B37209F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {852D4E16-58C3-47C2-A6BC-A5B12B37209F}.Debug|Any CPU.Build.0 = Debug|Any CPU {852D4E16-58C3-47C2-A6BC-A5B12B37209F}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -180,6 +186,7 @@ Global {A5439E79-96D6-4F02-8DD0-23DFF979851D} = {03F31CEE-D63E-4E7F-949F-139B33DC3385} {BF948816-45E1-4F0F-985A-0B4DB4D3BF40} = {03F31CEE-D63E-4E7F-949F-139B33DC3385} {FE6A1AA9-8D0B-4EC6-8D2A-C9D8EF183FDB} = {03F31CEE-D63E-4E7F-949F-139B33DC3385} + {8F33CD11-661E-40F2-AE43-61DEB102D74A} = {03F31CEE-D63E-4E7F-949F-139B33DC3385} {852D4E16-58C3-47C2-A6BC-A5B12B37209F} = {03F31CEE-D63E-4E7F-949F-139B33DC3385} {6645D0C4-83D1-4426-B9CD-67096CB7A60F} = {03F31CEE-D63E-4E7F-949F-139B33DC3385} {848C51FA-3CCE-4402-8E5F-C670B6A9FEBC} = {87F606D1-D311-4EDC-9A37-8F008B55597C} diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.cs.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.cs.xlf index eb8dd19b8c7..b27bf9b6030 100644 --- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.cs.xlf +++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.cs.xlf @@ -4,7 +4,7 @@ Argument '{0}' is not referenced from the logging message - Na argument {0} se ve zprávÄ› o protokolování neodkazuje. + Na argument {0} se ve zprávÄ› o protokolování neodkazuje. @@ -34,12 +34,12 @@ Argument '{0}' is using the unsupported out parameter modifier - Argument {0} používá nepodporovaný modifikátor výstupních parametrů. + Argument '{0}' is using the unsupported out parameter modifier Argument is using the unsupported out parameter modifier - Argument používá nepodporovaný modifikátor výstupních parametrů + Argument is using the unsupported out parameter modifier @@ -69,22 +69,22 @@ The Logging source generator is not available in C# {0}. Please use language version {1} or greater. - Zdrojový generátor protokolování není k dispozici v jazyce C# {0}. Použijte prosím jazykovou verzi {1} nebo vyšší. + The Logging source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - Zdrojový generátor nepodporuje jazykovou verzi jazyka C#. + C# language version not supported by the source generator. Logging method '{0}' contains malformed format strings - Metoda protokolování {0} obsahuje Å™etÄ›zce s poÅ¡kozeným formátem. + Logging method '{0}' contains malformed format strings Logging method contains malformed format strings - Metoda protokolování obsahuje Å™etÄ›zce s poÅ¡kozeným formátem + Logging method contains malformed format strings @@ -184,12 +184,12 @@ Multiple logging methods are using event name {0} in class {1} - Více než jedna metoda protokolování používá název události {0} ve třídÄ› {1} + Multiple logging methods are using event name {0} in class {1} Multiple logging methods should not use the same event name within a class - Více než jedna metoda protokolování by nemÄ›lo používat stejný název události v rámci třídy + Multiple logging methods should not use the same event name within a class diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.de.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.de.xlf index b508628ac5e..da85a583040 100644 --- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.de.xlf +++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.de.xlf @@ -4,7 +4,7 @@ Argument '{0}' is not referenced from the logging message - Auf das Argument „{0}“ wird in der Protokollierungsnachricht nicht verwiesen. + Auf das Argument „{0}“ wird in der Protokollierungsnachricht nicht verwiesen. @@ -34,12 +34,12 @@ Argument '{0}' is using the unsupported out parameter modifier - Das Argument „{0}“ verwendet den nicht unterstützten Parametermodifizierer „out“. + Argument '{0}' is using the unsupported out parameter modifier Argument is using the unsupported out parameter modifier - Das Argument verwendet den nicht unterstützten Parametermodifizierer „out“. + Argument is using the unsupported out parameter modifier @@ -69,22 +69,22 @@ The Logging source generator is not available in C# {0}. Please use language version {1} or greater. - Der Protokollierungsquellgenerator ist in C# {0} nicht verfügbar. Verwenden Sie die Sprachversion {1} oder höher. + The Logging source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - Die C#-Sprachversion wird vom Quellgenerator nicht unterstützt. + C# language version not supported by the source generator. Logging method '{0}' contains malformed format strings - Die Protokollierungsmethode „{0}“ enthält nicht wohlgeformte Formatzeichenfolgen. + Logging method '{0}' contains malformed format strings Logging method contains malformed format strings - Die Protokollierungsmethode enthält nicht wohlgeformte Formatzeichenfolgen. + Logging method contains malformed format strings @@ -184,12 +184,12 @@ Multiple logging methods are using event name {0} in class {1} - Der Ereignisname „{0}“ wird in der Klasse „{1}“ von mehreren Protokollierungsmethoden verwendet. + Multiple logging methods are using event name {0} in class {1} Multiple logging methods should not use the same event name within a class - Derselbe Ereignisname kann innerhalb einer Klasse nicht von mehreren Protokollierungsmethoden verwendet werden. + Multiple logging methods should not use the same event name within a class diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.es.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.es.xlf index fd199f459d9..4baeb40d885 100644 --- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.es.xlf +++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.es.xlf @@ -4,7 +4,7 @@ Argument '{0}' is not referenced from the logging message - No se hace referencia al argumento "{0}" en el mensaje de registro + No se hace referencia al argumento "{0}" en el mensaje de registro @@ -34,12 +34,12 @@ Argument '{0}' is using the unsupported out parameter modifier - El argumento “{0}†está usando el modificador del parámetro de salida no admitido + Argument '{0}' is using the unsupported out parameter modifier Argument is using the unsupported out parameter modifier - El argumento usa el modificador del parámetro de salida no admitido + Argument is using the unsupported out parameter modifier @@ -69,22 +69,22 @@ The Logging source generator is not available in C# {0}. Please use language version {1} or greater. - El generador de origen de registro no está disponible en C# {0}. Use la versión de idioma {1} o superior. + The Logging source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - La versión del idioma C# no es compatible con el generador de origen. + C# language version not supported by the source generator. Logging method '{0}' contains malformed format strings - El método de registro “{0}†contiene cadenas con formato incorrecto + Logging method '{0}' contains malformed format strings Logging method contains malformed format strings - El método de registro contiene cadenas con formato incorrecto + Logging method contains malformed format strings @@ -184,12 +184,12 @@ Multiple logging methods are using event name {0} in class {1} - Varios métodos de registro usan el nombre de evento {0} en la clase {1} + Multiple logging methods are using event name {0} in class {1} Multiple logging methods should not use the same event name within a class - Varios métodos de registro no pueden usar un mismo nombre de evento en una clase + Multiple logging methods should not use the same event name within a class diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.fr.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.fr.xlf index ac019c9dabf..dc0da2a086a 100644 --- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.fr.xlf +++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.fr.xlf @@ -4,7 +4,7 @@ Argument '{0}' is not referenced from the logging message - L’argument « {0} » n’est pas référencé à partir du message de journalisation + L’argument « {0} » n’est pas référencé à partir du message de journalisation @@ -34,12 +34,12 @@ Argument '{0}' is using the unsupported out parameter modifier - L'argument '{0}' utilise le modificateur de paramètre out non pris en charge + Argument '{0}' is using the unsupported out parameter modifier Argument is using the unsupported out parameter modifier - L'argument utilise le modificateur de paramètre out non pris en charge + Argument is using the unsupported out parameter modifier @@ -69,22 +69,22 @@ The Logging source generator is not available in C# {0}. Please use language version {1} or greater. - Le générateur de source de connexion n'est pas disponible en C# « {0} ». Veuillez utiliser la version linguistique {1} ou supérieure. + The Logging source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - Version du langage C# non prise en charge par le générateur de source. + C# language version not supported by the source generator. Logging method '{0}' contains malformed format strings - La méthode de journalisation « {0} »contient des chaînes de format incorrectes + Logging method '{0}' contains malformed format strings Logging method contains malformed format strings - La méthode de journalisation contient des chaînes de format incorrectes + Logging method contains malformed format strings @@ -184,12 +184,12 @@ Multiple logging methods are using event name {0} in class {1} - Plusieurs méthodes de journalisation utilisent le nom d’événement {0} dans la classe {1} + Multiple logging methods are using event name {0} in class {1} Multiple logging methods should not use the same event name within a class - Il ne faut pas que plusieurs méthodes de journalisation utilisent le même nom d’événement au sein d’une classe + Multiple logging methods should not use the same event name within a class diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.it.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.it.xlf index dc2f02184e1..fb668b707d8 100644 --- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.it.xlf +++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.it.xlf @@ -4,7 +4,7 @@ Argument '{0}' is not referenced from the logging message - Il messaggio di registrazione non fa riferimento all'argomento '{0}' + Il messaggio di registrazione non fa riferimento all'argomento '{0}' @@ -34,12 +34,12 @@ Argument '{0}' is using the unsupported out parameter modifier - L'argomento "{0}" usa il modificatore di parametro out non supportato + Argument '{0}' is using the unsupported out parameter modifier Argument is using the unsupported out parameter modifier - L'argomento utilizza il modificatore di parametro out non supportato + Argument is using the unsupported out parameter modifier @@ -69,22 +69,22 @@ The Logging source generator is not available in C# {0}. Please use language version {1} or greater. - Il generatore dell'origine di registrazione non è disponibile in C# {0}. Usare la versione del linguaggio {1} o successiva. + The Logging source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - Versione del linguaggio C# non supportata dal generatore di origine. + C# language version not supported by the source generator. Logging method '{0}' contains malformed format strings - Il metodo di registrazione '{0}' contiene stringhe in formato non valido + Logging method '{0}' contains malformed format strings Logging method contains malformed format strings - Il metodo di registrazione contiene stringhe in formato non valido + Logging method contains malformed format strings @@ -184,12 +184,12 @@ Multiple logging methods are using event name {0} in class {1} - Più metodi di registrazione stanno utilizzando il nome evento {0} nella classe {1} + Multiple logging methods are using event name {0} in class {1} Multiple logging methods should not use the same event name within a class - Più metodi di registrazione non devono usare lo stesso nome di evento all'interno di una classe + Multiple logging methods should not use the same event name within a class diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.ja.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.ja.xlf index 3f012705018..6dfb110dd0c 100644 --- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.ja.xlf +++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.ja.xlf @@ -4,7 +4,7 @@ Argument '{0}' is not referenced from the logging message - 引数 '{0}' ã¯ãƒ­ã‚° メッセージã‹ã‚‰å‚ç…§ã•ã‚Œã¦ã„ã¾ã›ã‚“ + 引数 '{0}' ã¯ãƒ­ã‚° メッセージã‹ã‚‰å‚ç…§ã•ã‚Œã¦ã„ã¾ã›ã‚“ @@ -34,12 +34,12 @@ Argument '{0}' is using the unsupported out parameter modifier - 引数 '{0}' ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ãªã„ out パラメーター修飾å­ã‚’使用ã—ã¦ã„ã¾ã™ + Argument '{0}' is using the unsupported out parameter modifier Argument is using the unsupported out parameter modifier - 引数ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ãªã„ out パラメーター修飾å­ã‚’使用ã—ã¦ã„ã¾ã™ + Argument is using the unsupported out parameter modifier @@ -69,22 +69,22 @@ The Logging source generator is not available in C# {0}. Please use language version {1} or greater. - ログ ソース ジェãƒãƒ¬ãƒ¼ã‚¿ãƒ¼ã¯ã€C# {0} ã§ã¯ä½¿ç”¨ã§ãã¾ã›ã‚“。言語ãƒãƒ¼ã‚¸ãƒ§ãƒ³ {1} 以é™ã‚’使用ã—ã¦ãã ã•ã„。 + The Logging source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - ソース ジェãƒãƒ¬ãƒ¼ã‚¿ãƒ¼ã§ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ãªã„ C# 言語ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã€‚ + C# language version not supported by the source generator. Logging method '{0}' contains malformed format strings - ログ メソッド '{0}' ã«ã€å½¢å¼ã®æ­£ã—ããªã„文字列ãŒå«ã¾ã‚Œã¦ã„ã¾ã™ + Logging method '{0}' contains malformed format strings Logging method contains malformed format strings - ログ メソッドã«å½¢å¼ã®æ­£ã—ããªã„文字列ãŒå«ã¾ã‚Œã¦ã„ã¾ã™ + Logging method contains malformed format strings @@ -184,12 +184,12 @@ Multiple logging methods are using event name {0} in class {1} - 複数ã®ãƒ­ã‚°è¨˜éŒ²æ–¹æ³•ã§ã‚¯ãƒ©ã‚¹ {1} 内ã®ã‚¤ãƒ™ãƒ³ãƒˆå {0} を使用ã—ã¦ã„ã¾ã™ + Multiple logging methods are using event name {0} in class {1} Multiple logging methods should not use the same event name within a class - 複数ã®ãƒ­ã‚°è¨˜éŒ²æ–¹æ³•ã§ã¯ã€ã‚¯ãƒ©ã‚¹å†…ã§åŒã˜ã‚¤ãƒ™ãƒ³ãƒˆåを使用ã—ãªã„よã†ã«ã™ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ + Multiple logging methods should not use the same event name within a class diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.ko.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.ko.xlf index 5bb9507b859..3ae54a62ae0 100644 --- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.ko.xlf +++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.ko.xlf @@ -4,7 +4,7 @@ Argument '{0}' is not referenced from the logging message - 로깅 메시지ì—ì„œ ‘{0}’ ì¸ìˆ˜ë¥¼ 참조하지 않습니다. + 로깅 메시지ì—ì„œ ‘{0}’ ì¸ìˆ˜ë¥¼ 참조하지 않습니다. @@ -34,12 +34,12 @@ Argument '{0}' is using the unsupported out parameter modifier - ì¸ìˆ˜ '{0}'ì´(ê°€) 지ì›ë˜ì§€ 않는 out 매개 변수 한정ìžë¥¼ 사용하고 있습니다. + Argument '{0}' is using the unsupported out parameter modifier Argument is using the unsupported out parameter modifier - ì¸ìˆ˜ê°€ 지ì›ë˜ì§€ 않는 out 매개 변수 한정ìžë¥¼ 사용하고 있습니다. + Argument is using the unsupported out parameter modifier @@ -69,22 +69,22 @@ The Logging source generator is not available in C# {0}. Please use language version {1} or greater. - 로깅 ì›ë³¸ ìƒì„±ê¸°ëŠ” C# {0}ì—ì„œ 사용할 수 없습니다. {1} ì´ìƒì˜ 언어 ë²„ì „ì„ ì‚¬ìš©í•˜ì„¸ìš”. + The Logging source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - ì›ë³¸ ìƒì„±ê¸°ì—ì„œ 지ì›ë˜ì§€ 않는 C# 언어 버전입니다. + C# language version not supported by the source generator. Logging method '{0}' contains malformed format strings - 로깅 메서드 '{0}'ì— ìž˜ëª»ëœ í˜•ì‹ì˜ 문ìžì—´ì´ í¬í•¨ë˜ì–´ 있습니다. + Logging method '{0}' contains malformed format strings Logging method contains malformed format strings - 로깅 ë©”ì„œë“œì— ìž˜ëª»ëœ í˜•ì‹ì˜ 문ìžì—´ì´ í¬í•¨ë˜ì–´ 있습니다. + Logging method contains malformed format strings @@ -184,12 +184,12 @@ Multiple logging methods are using event name {0} in class {1} - {0} í´ëž˜ìŠ¤ì—ì„œ 여러 로깅 메서드가 ì´ë²¤íŠ¸ ì´ë¦„ {1}ì„(를) 사용함 + Multiple logging methods are using event name {0} in class {1} Multiple logging methods should not use the same event name within a class - 여러 로깅 메서드가 í•œ í´ëž˜ìŠ¤ ë‚´ì—ì„œ ë™ì¼í•œ ì´ë²¤íŠ¸ ì´ë¦„ì„ ì‚¬ìš©í•˜ì§€ 않아야 합니다 + Multiple logging methods should not use the same event name within a class diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.pl.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.pl.xlf index 0c014dd5317..a93cfe758c1 100644 --- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.pl.xlf +++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.pl.xlf @@ -4,7 +4,7 @@ Argument '{0}' is not referenced from the logging message - Do argumentu „{0}†nie odwoÅ‚uje siÄ™ komunikat rejestrowania + Do argumentu „{0}†nie odwoÅ‚uje siÄ™ komunikat rejestrowania @@ -34,12 +34,12 @@ Argument '{0}' is using the unsupported out parameter modifier - Argument „{0}†używa nieobsÅ‚ugiwanego modyfikatora parametrów danych wyjÅ›ciowych + Argument '{0}' is using the unsupported out parameter modifier Argument is using the unsupported out parameter modifier - Argument używa nieobsÅ‚ugiwanego modyfikatora parametrów danych wyjÅ›ciowych + Argument is using the unsupported out parameter modifier @@ -69,22 +69,22 @@ The Logging source generator is not available in C# {0}. Please use language version {1} or greater. - Generator źródÅ‚a rejestrowania nie jest dostÄ™pny w jÄ™zyku C# {0}. Użyj wersji jÄ™zykowej {1} lub nowszej. + The Logging source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - Wersja jÄ™zyka C# nie jest obsÅ‚ugiwana przez generator źródÅ‚a. + C# language version not supported by the source generator. Logging method '{0}' contains malformed format strings - Metoda rejestrowania „{0}†zawiera źle sformuÅ‚owane ciÄ…gi formatu + Logging method '{0}' contains malformed format strings Logging method contains malformed format strings - Metoda rejestrowania zawiera źle sformuÅ‚owane ciÄ…gi formatu + Logging method contains malformed format strings @@ -184,12 +184,12 @@ Multiple logging methods are using event name {0} in class {1} - Wiele metod rejestrowania używa nazwy zdarzenia {0} w klasie {1} + Multiple logging methods are using event name {0} in class {1} Multiple logging methods should not use the same event name within a class - Wiele metod rejestrowania nie powinno używać tej samej nazwy zdarzenia w klasie + Multiple logging methods should not use the same event name within a class diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.pt-BR.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.pt-BR.xlf index 6a4a35d1acc..56f3134aa02 100644 --- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.pt-BR.xlf +++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.pt-BR.xlf @@ -4,7 +4,7 @@ Argument '{0}' is not referenced from the logging message - O argumento '{0}' não é referenciado na mensagem de registro em log + O argumento '{0}' não é referenciado na mensagem de registro em log @@ -34,12 +34,12 @@ Argument '{0}' is using the unsupported out parameter modifier - O argumento '{0}' está usando o modificador de parâmetro out sem suporte + Argument '{0}' is using the unsupported out parameter modifier Argument is using the unsupported out parameter modifier - O argumento está usando o modificador de parâmetro out sem suporte + Argument is using the unsupported out parameter modifier @@ -69,22 +69,22 @@ The Logging source generator is not available in C# {0}. Please use language version {1} or greater. - O gerador de fonte de log não está disponível em C# {0}. Use a versão do idioma {1} ou superior. + The Logging source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - Versão da linguagem C# não suportada pelo gerador de origem. + C# language version not supported by the source generator. Logging method '{0}' contains malformed format strings - O método de registro '{0}' contém strings de formato malformado + Logging method '{0}' contains malformed format strings Logging method contains malformed format strings - O método de registro contém strings de formato malformadas + Logging method contains malformed format strings @@ -184,12 +184,12 @@ Multiple logging methods are using event name {0} in class {1} - Múltiplos métodos de registro em log estão usando o nome de evento {0} na classe {1} + Multiple logging methods are using event name {0} in class {1} Multiple logging methods should not use the same event name within a class - Múltiplos métodos de registro em log não devem usar o mesmo nome de evento dentro de uma classe + Multiple logging methods should not use the same event name within a class diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.ru.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.ru.xlf index 053970d8886..d8a5c6a4640 100644 --- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.ru.xlf +++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.ru.xlf @@ -4,7 +4,7 @@ Argument '{0}' is not referenced from the logging message - Ð’ Ñообщении Ð²ÐµÐ´ÐµÐ½Ð¸Ñ Ð¶ÑƒÑ€Ð½Ð°Ð»Ð° нет ÑÑылки на аргумент "{0}" + Ð’ Ñообщении Ð²ÐµÐ´ÐµÐ½Ð¸Ñ Ð¶ÑƒÑ€Ð½Ð°Ð»Ð° нет ÑÑылки на аргумент "{0}" @@ -34,12 +34,12 @@ Argument '{0}' is using the unsupported out parameter modifier - Ðргумент "{0}" иÑпользует неподдерживаемый модификатор выходного параметра + Argument '{0}' is using the unsupported out parameter modifier Argument is using the unsupported out parameter modifier - Ðргумент иÑпользует неподдерживаемый модификатор выходного параметра + Argument is using the unsupported out parameter modifier @@ -69,22 +69,22 @@ The Logging source generator is not available in C# {0}. Please use language version {1} or greater. - Генератор иÑходного кода Ð²ÐµÐ´ÐµÐ½Ð¸Ñ Ð¶ÑƒÑ€Ð½Ð°Ð»Ð° недоÑтупен в C# {0}. ИÑпользуйте Ñзыковую верÑию {1} или более позднюю. + The Logging source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - ВерÑÐ¸Ñ Ñзыка C# не поддерживаетÑÑ Ð³ÐµÐ½ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð¾Ð¼ иÑходного кода. + C# language version not supported by the source generator. Logging method '{0}' contains malformed format strings - Метод Ð²ÐµÐ´ÐµÐ½Ð¸Ñ Ð¶ÑƒÑ€Ð½Ð°Ð»Ð° Ñобытий "{0}" Ñодержит Ñтроки неправильного формата + Logging method '{0}' contains malformed format strings Logging method contains malformed format strings - Метод Ð²ÐµÐ´ÐµÐ½Ð¸Ñ Ð¶ÑƒÑ€Ð½Ð°Ð»Ð° Ñобытий Ñодержит Ñтроки неправильного формата + Logging method contains malformed format strings @@ -184,12 +184,12 @@ Multiple logging methods are using event name {0} in class {1} - ÐеÑколько методов Ð²ÐµÐ´ÐµÐ½Ð¸Ñ Ð¶ÑƒÑ€Ð½Ð°Ð»Ð° иÑпользуют Ð¸Ð¼Ñ ÑÐ¾Ð±Ñ‹Ñ‚Ð¸Ñ {0} в клаÑÑе {1} + Multiple logging methods are using event name {0} in class {1} Multiple logging methods should not use the same event name within a class - ÐеÑколько методов Ð²ÐµÐ´ÐµÐ½Ð¸Ñ Ð¶ÑƒÑ€Ð½Ð°Ð»Ð° не могут иÑпользовать одинаковое Ð¸Ð¼Ñ ÑÐ¾Ð±Ñ‹Ñ‚Ð¸Ñ Ð² пределах клаÑÑа + Multiple logging methods should not use the same event name within a class diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.tr.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.tr.xlf index 03f094a1607..fd6619804fa 100644 --- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.tr.xlf +++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.tr.xlf @@ -4,7 +4,7 @@ Argument '{0}' is not referenced from the logging message - '{0}' bağımsız deÄŸiÅŸkenine günlük iletisinden baÅŸvurulmuyor + '{0}' bağımsız deÄŸiÅŸkenine günlük iletisinden baÅŸvurulmuyor @@ -34,12 +34,12 @@ Argument '{0}' is using the unsupported out parameter modifier - '{0}' bağımsız deÄŸiÅŸkeni, desteklenmeyen dış parametre deÄŸiÅŸtiriciyi kullanıyor + Argument '{0}' is using the unsupported out parameter modifier Argument is using the unsupported out parameter modifier - Bağımsız deÄŸiÅŸken, desteklenmeyen dış parametre deÄŸiÅŸtiriciyi kullanıyor + Argument is using the unsupported out parameter modifier @@ -69,22 +69,22 @@ The Logging source generator is not available in C# {0}. Please use language version {1} or greater. - Günlüğe kaydetme kaynak oluÅŸturucusu C# {0} sürümünde kullanılamıyor. Lütfen dil sürümü {1} veya üstü bir sürümü kullanın. + The Logging source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - C# dil sürümü kaynak oluÅŸturucu tarafından desteklenmiyor. + C# language version not supported by the source generator. Logging method '{0}' contains malformed format strings - '{0}' günlüğe kaydetme yöntemi hatalı biçimlendirilmiÅŸ biçim dizeleri içeriyor + Logging method '{0}' contains malformed format strings Logging method contains malformed format strings - Günlüğe kaydetme yöntemi hatalı biçimlendirilmiÅŸ biçim dizeleri içeriyor + Logging method contains malformed format strings @@ -184,12 +184,12 @@ Multiple logging methods are using event name {0} in class {1} - Birden çok günlüğe kaydetme yöntemi {1} sınıfında {0} olay adını kullanıyor + Multiple logging methods are using event name {0} in class {1} Multiple logging methods should not use the same event name within a class - Birden çok günlüğe kaydetme yöntemi bir sınıf içinde aynı olay adını kullanmamalıdır + Multiple logging methods should not use the same event name within a class diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.zh-Hans.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.zh-Hans.xlf index 2217d0a4cc9..a7e9d9b9339 100644 --- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.zh-Hans.xlf +++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.zh-Hans.xlf @@ -4,7 +4,7 @@ Argument '{0}' is not referenced from the logging message - 未从日志记录消æ¯ä¸­å¼•ç”¨å‚数“{0}†+ 未从日志记录消æ¯ä¸­å¼•ç”¨å‚数“{0}†@@ -34,12 +34,12 @@ Argument '{0}' is using the unsupported out parameter modifier - å‚æ•° "{0}" 正在使用ä¸å—支æŒçš„ out å‚数修饰符 + Argument '{0}' is using the unsupported out parameter modifier Argument is using the unsupported out parameter modifier - å‚数正在使用ä¸å—支æŒçš„ out å‚数修饰符 + Argument is using the unsupported out parameter modifier @@ -69,22 +69,22 @@ The Logging source generator is not available in C# {0}. Please use language version {1} or greater. - 记录æºç”Ÿæˆå™¨åœ¨ C#“{0}â€ä¸­ä¸å¯ç”¨ã€‚请使用{1}或更高版本的语言版本。 + The Logging source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - æºç”Ÿæˆå™¨ä¸æ”¯æŒ C# 语言版本。 + C# language version not supported by the source generator. Logging method '{0}' contains malformed format strings - 日志记录方法“{0}â€åŒ…å«æ ¼å¼é”™è¯¯çš„字符串 + Logging method '{0}' contains malformed format strings Logging method contains malformed format strings - 日志记录方法包å«æ ¼å¼é”™è¯¯çš„字符串 + Logging method contains malformed format strings @@ -184,12 +184,12 @@ Multiple logging methods are using event name {0} in class {1} - 多个日志记录方法正在类 {1} 中使用事件å称 {0} + Multiple logging methods are using event name {0} in class {1} Multiple logging methods should not use the same event name within a class - 多个日志记录方法ä¸åº”在类中使用相åŒçš„事件å称 + Multiple logging methods should not use the same event name within a class diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.zh-Hant.xlf b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.zh-Hant.xlf index 6044c601d92..106c5241798 100644 --- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.zh-Hant.xlf +++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/gen/Resources/xlf/Strings.zh-Hant.xlf @@ -4,7 +4,7 @@ Argument '{0}' is not referenced from the logging message - 引數 '{0}' 未åƒç…§è¨˜éŒ„è¨Šæ¯ + 引數 '{0}' 未åƒç…§è¨˜éŒ„è¨Šæ¯ @@ -34,12 +34,12 @@ Argument '{0}' is using the unsupported out parameter modifier - 引數 '{0}' 使用ä¸æ”¯æ´çš„ out åƒæ•¸ä¿®é£¾å…ƒ + Argument '{0}' is using the unsupported out parameter modifier Argument is using the unsupported out parameter modifier - 引數使用ä¸æ”¯æ´çš„ out åƒæ•¸ä¿®é£¾å…ƒ + Argument is using the unsupported out parameter modifier @@ -69,22 +69,22 @@ The Logging source generator is not available in C# {0}. Please use language version {1} or greater. - 記錄來æºç”¢ç”Ÿå™¨åœ¨ C# {0} 中ä¸å¯ç”¨ã€‚請使用語言版本 {1} 或更新版本。 + The Logging source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - 來æºç”¢ç”Ÿå™¨ä¸æ”¯æ´ C# 語言版本。 + C# language version not supported by the source generator. Logging method '{0}' contains malformed format strings - 記錄方法 '{0}' 包å«æ ¼å¼éŒ¯èª¤çš„æ ¼å¼å­—串 + Logging method '{0}' contains malformed format strings Logging method contains malformed format strings - 記錄方法包å«æ ¼å¼éŒ¯èª¤çš„æ ¼å¼å­—串 + Logging method contains malformed format strings @@ -184,12 +184,12 @@ Multiple logging methods are using event name {0} in class {1} - 多個記錄方法是使用類別 {0} 中的事件å稱 {1} + Multiple logging methods are using event name {0} in class {1} Multiple logging methods should not use the same event name within a class - 多個記錄方法ä¸æ‡‰åœ¨é¡žåˆ¥å…§ä½¿ç”¨ç›¸åŒçš„事件å稱 + Multiple logging methods should not use the same event name within a class diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/EventId.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/EventId.cs index 1cb4775b275..0896903b4f7 100644 --- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/EventId.cs +++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/EventId.cs @@ -21,7 +21,7 @@ public static implicit operator EventId(int i) } /// - /// Checks if two specified instances have the same value. They are equal if they have the same Id. + /// Checks if two specified instances have the same value. They are equal if they have the same ID. /// /// The first . /// The second . @@ -70,10 +70,10 @@ public override string ToString() } /// - /// Indicates whether the current object is equal to another object of the same type. Two events are equal if they have the same id. + /// Compares the current instance to another object of the same type. Two events are equal if they have the same ID. /// /// An object to compare with this object. - /// if the current object is equal to the other parameter; otherwise, . + /// if the current object is equal to ; otherwise, . public bool Equals(EventId other) { return Id == other.Id; diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LogValuesFormatter.cs b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LogValuesFormatter.cs index 69707c14c3f..09fe16792d9 100644 --- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LogValuesFormatter.cs +++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/LogValuesFormatter.cs @@ -186,32 +186,26 @@ internal string Format() #if NET8_0_OR_GREATER internal string Format(TArg0 arg0) { - object? arg0String = null; return - !TryFormatArgumentIfNullOrEnumerable(arg0, ref arg0String) ? + !TryFormatArgumentIfNullOrEnumerable(arg0, out object? arg0String) ? string.Format(CultureInfo.InvariantCulture, _format, arg0) : string.Format(CultureInfo.InvariantCulture, _format, arg0String); } internal string Format(TArg0 arg0, TArg1 arg1) { - object? arg0String = null, arg1String = null; return - !TryFormatArgumentIfNullOrEnumerable(arg0, ref arg0String) && - !TryFormatArgumentIfNullOrEnumerable(arg1, ref arg1String) ? - string.Format(CultureInfo.InvariantCulture, _format, arg0, arg1) : - string.Format(CultureInfo.InvariantCulture, _format, arg0String ?? arg0, arg1String ?? arg1); + TryFormatArgumentIfNullOrEnumerable(arg0, out object? arg0String) | TryFormatArgumentIfNullOrEnumerable(arg1, out object? arg1String) ? + string.Format(CultureInfo.InvariantCulture, _format, arg0String ?? arg0, arg1String ?? arg1) : + string.Format(CultureInfo.InvariantCulture, _format, arg0, arg1); } internal string Format(TArg0 arg0, TArg1 arg1, TArg2 arg2) { - object? arg0String = null, arg1String = null, arg2String = null; return - !TryFormatArgumentIfNullOrEnumerable(arg0, ref arg0String) && - !TryFormatArgumentIfNullOrEnumerable(arg1, ref arg1String) && - !TryFormatArgumentIfNullOrEnumerable(arg2, ref arg2String) ? - string.Format(CultureInfo.InvariantCulture, _format, arg0, arg1, arg2) : - string.Format(CultureInfo.InvariantCulture, _format, arg0String ?? arg0, arg1String ?? arg1, arg2String ?? arg2); + TryFormatArgumentIfNullOrEnumerable(arg0, out object? arg0String) | TryFormatArgumentIfNullOrEnumerable(arg1, out object? arg1String) | TryFormatArgumentIfNullOrEnumerable(arg2, out object? arg2String) ? + string.Format(CultureInfo.InvariantCulture, _format, arg0String ?? arg0, arg1String ?? arg1, arg2String ?? arg2): + string.Format(CultureInfo.InvariantCulture, _format, arg0, arg1, arg2); } #else internal string Format(object? arg0) => @@ -253,11 +247,10 @@ internal string Format(object? arg0, object? arg1, object? arg2) => private static object FormatArgument(object? value) { - object? stringValue = null; - return TryFormatArgumentIfNullOrEnumerable(value, ref stringValue) ? stringValue : value!; + return TryFormatArgumentIfNullOrEnumerable(value, out object? stringValue) ? stringValue : value!; } - private static bool TryFormatArgumentIfNullOrEnumerable(T? value, [NotNullWhen(true)] ref object? stringValue) + private static bool TryFormatArgumentIfNullOrEnumerable(T? value, [NotNullWhen(true)] out object? stringValue) { if (value == null) { @@ -284,6 +277,7 @@ private static bool TryFormatArgumentIfNullOrEnumerable(T? value, [NotNullWhe return true; } + stringValue = null; return false; } } diff --git a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/Microsoft.Extensions.Logging.Abstractions.csproj b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/Microsoft.Extensions.Logging.Abstractions.csproj index 00d83a69146..fa3f20ac4c7 100644 --- a/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/Microsoft.Extensions.Logging.Abstractions.csproj +++ b/src/libraries/Microsoft.Extensions.Logging.Abstractions/src/Microsoft.Extensions.Logging.Abstractions.csproj @@ -38,6 +38,10 @@ Microsoft.Extensions.Logging.Abstractions.NullLogger + + + + @@ -53,7 +57,6 @@ Microsoft.Extensions.Logging.Abstractions.NullLogger - diff --git a/src/libraries/Microsoft.Extensions.Logging.Configuration/Microsoft.Extensions.Logging.Configuration.sln b/src/libraries/Microsoft.Extensions.Logging.Configuration/Microsoft.Extensions.Logging.Configuration.sln index 9d3e292fb1b..24375eb5967 100644 --- a/src/libraries/Microsoft.Extensions.Logging.Configuration/Microsoft.Extensions.Logging.Configuration.sln +++ b/src/libraries/Microsoft.Extensions.Logging.Configuration/Microsoft.Extensions.Logging.Configuration.sln @@ -61,6 +61,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Diagnostics.Diagnost EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{2BD666C1-CC16-4A64-B915-06701A1B54BA}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{2F3B3FAD-12F4-434E-9370-709ECCB3AAAA}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{4531AA3F-D0FC-4C1F-BF54-71E0D29CBA16}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{5D09D653-A257-4673-810F-6157486964F4}" @@ -221,6 +223,10 @@ Global {2BD666C1-CC16-4A64-B915-06701A1B54BA}.Debug|Any CPU.Build.0 = Debug|Any CPU {2BD666C1-CC16-4A64-B915-06701A1B54BA}.Release|Any CPU.ActiveCfg = Release|Any CPU {2BD666C1-CC16-4A64-B915-06701A1B54BA}.Release|Any CPU.Build.0 = Release|Any CPU + {2F3B3FAD-12F4-434E-9370-709ECCB3AAAA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {2F3B3FAD-12F4-434E-9370-709ECCB3AAAA}.Debug|Any CPU.Build.0 = Debug|Any CPU + {2F3B3FAD-12F4-434E-9370-709ECCB3AAAA}.Release|Any CPU.ActiveCfg = Release|Any CPU + {2F3B3FAD-12F4-434E-9370-709ECCB3AAAA}.Release|Any CPU.Build.0 = Release|Any CPU {4531AA3F-D0FC-4C1F-BF54-71E0D29CBA16}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {4531AA3F-D0FC-4C1F-BF54-71E0D29CBA16}.Debug|Any CPU.Build.0 = Debug|Any CPU {4531AA3F-D0FC-4C1F-BF54-71E0D29CBA16}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -290,6 +296,7 @@ Global {962C4BF1-F689-4344-847D-9A657E55B5FA} = {B51C2035-38E7-4F22-9F9B-A49DC2B6C92F} {28A7A861-15D3-4FB9-BF74-57C835A32727} = {B51C2035-38E7-4F22-9F9B-A49DC2B6C92F} {2BD666C1-CC16-4A64-B915-06701A1B54BA} = {B51C2035-38E7-4F22-9F9B-A49DC2B6C92F} + {2F3B3FAD-12F4-434E-9370-709ECCB3AAAA} = {B51C2035-38E7-4F22-9F9B-A49DC2B6C92F} {4531AA3F-D0FC-4C1F-BF54-71E0D29CBA16} = {B51C2035-38E7-4F22-9F9B-A49DC2B6C92F} {5D09D653-A257-4673-810F-6157486964F4} = {B51C2035-38E7-4F22-9F9B-A49DC2B6C92F} {F0259C06-98B1-4F6D-9B4A-DF7F7C54B7BB} = {D7763B6D-EFA4-4393-B548-EBA806172FA1} diff --git a/src/libraries/Microsoft.Extensions.Logging.Console/Microsoft.Extensions.Logging.Console.sln b/src/libraries/Microsoft.Extensions.Logging.Console/Microsoft.Extensions.Logging.Console.sln index f9fcc592253..8b06d616e15 100644 --- a/src/libraries/Microsoft.Extensions.Logging.Console/Microsoft.Extensions.Logging.Console.sln +++ b/src/libraries/Microsoft.Extensions.Logging.Console/Microsoft.Extensions.Logging.Console.sln @@ -79,6 +79,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Memory", "..\System. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{9D77F47E-EA44-4FA4-A04F-ED022D91F429}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{FD5E6442-302D-4BC5-B6E2-7A8C4D548E5F}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{17C4DD18-64B1-43FF-89A2-1D5EBFD4202E}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{83BADB4A-BD97-4121-B0B8-78BD3E3A352A}" @@ -293,6 +295,10 @@ Global {9D77F47E-EA44-4FA4-A04F-ED022D91F429}.Debug|Any CPU.Build.0 = Debug|Any CPU {9D77F47E-EA44-4FA4-A04F-ED022D91F429}.Release|Any CPU.ActiveCfg = Release|Any CPU {9D77F47E-EA44-4FA4-A04F-ED022D91F429}.Release|Any CPU.Build.0 = Release|Any CPU + {FD5E6442-302D-4BC5-B6E2-7A8C4D548E5F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {FD5E6442-302D-4BC5-B6E2-7A8C4D548E5F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {FD5E6442-302D-4BC5-B6E2-7A8C4D548E5F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {FD5E6442-302D-4BC5-B6E2-7A8C4D548E5F}.Release|Any CPU.Build.0 = Release|Any CPU {17C4DD18-64B1-43FF-89A2-1D5EBFD4202E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {17C4DD18-64B1-43FF-89A2-1D5EBFD4202E}.Debug|Any CPU.Build.0 = Debug|Any CPU {17C4DD18-64B1-43FF-89A2-1D5EBFD4202E}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -407,6 +413,7 @@ Global {629A8EEE-69D9-4EBA-BDB4-D0CDE942D3DB} = {561502B1-98F5-40E0-B9D5-0F720E88E657} {CD1A607B-CB38-4381-BF23-FCEFD3B8C54F} = {561502B1-98F5-40E0-B9D5-0F720E88E657} {9D77F47E-EA44-4FA4-A04F-ED022D91F429} = {561502B1-98F5-40E0-B9D5-0F720E88E657} + {FD5E6442-302D-4BC5-B6E2-7A8C4D548E5F} = {561502B1-98F5-40E0-B9D5-0F720E88E657} {17C4DD18-64B1-43FF-89A2-1D5EBFD4202E} = {561502B1-98F5-40E0-B9D5-0F720E88E657} {83BADB4A-BD97-4121-B0B8-78BD3E3A352A} = {561502B1-98F5-40E0-B9D5-0F720E88E657} {A276A0DD-B092-455B-90A7-6EE82BFF4C4B} = {561502B1-98F5-40E0-B9D5-0F720E88E657} diff --git a/src/libraries/Microsoft.Extensions.Logging.Console/src/Microsoft.Extensions.Logging.Console.csproj b/src/libraries/Microsoft.Extensions.Logging.Console/src/Microsoft.Extensions.Logging.Console.csproj index 7a93c35c785..bb9145aaab7 100644 --- a/src/libraries/Microsoft.Extensions.Logging.Console/src/Microsoft.Extensions.Logging.Console.csproj +++ b/src/libraries/Microsoft.Extensions.Logging.Console/src/Microsoft.Extensions.Logging.Console.csproj @@ -48,6 +48,9 @@ + + + diff --git a/src/libraries/Microsoft.Extensions.Logging.Console/tests/Microsoft.Extensions.Logging.Console.Tests/ConsoleLoggerTest.cs b/src/libraries/Microsoft.Extensions.Logging.Console/tests/Microsoft.Extensions.Logging.Console.Tests/ConsoleLoggerTest.cs index 900d667f8e1..6747e98ebf3 100644 --- a/src/libraries/Microsoft.Extensions.Logging.Console/tests/Microsoft.Extensions.Logging.Console.Tests/ConsoleLoggerTest.cs +++ b/src/libraries/Microsoft.Extensions.Logging.Console/tests/Microsoft.Extensions.Logging.Console.Tests/ConsoleLoggerTest.cs @@ -1409,6 +1409,31 @@ public void ConsoleLoggerOptions_IncludeScopes_IsReadFromLoggingConfiguration() Assert.True(formatter.FormatterOptions.IncludeScopes); } + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))] + public void LogMultipleArrays() + { + // Arrange + using var t = SetUp(); + var logger = t.Logger; + var sink = t.Sink; + + var define1 = LoggerMessage.Define(LogLevel.Information, new EventId(), "Log: {Array1} and {Array2}"); + var define2 = LoggerMessage.Define(LogLevel.Information, new EventId(), "Log {Number}: {Array1} and {Array2}"); + + // Act + define1(logger, ["a", "b", "c"], ["d", "e", "f"], null); + define2(logger, 30, ["a", "b", "c"], ["d", "e", "f"], null); + + var expectedMessage1 = $"{CreateHeader(ConsoleLoggerFormat.Default)}{Environment.NewLine}{_paddingString}Log: a, b, c and d, e, f{Environment.NewLine}"; + var expectedMessage2 = $"{CreateHeader(ConsoleLoggerFormat.Default)}{Environment.NewLine}{_paddingString}Log 30: a, b, c and d, e, f{Environment.NewLine}"; + + Assert.Equal(4, sink.Writes.Count); + Assert.Equal("info", sink.Writes[0].Message); + Assert.Equal(expectedMessage1, sink.Writes[1].Message); + Assert.Equal("info", sink.Writes[2].Message); + Assert.Equal(expectedMessage2, sink.Writes[3].Message); + } + public static TheoryData FormatsAndLevels { get diff --git a/src/libraries/Microsoft.Extensions.Logging.Debug/Microsoft.Extensions.Logging.Debug.sln b/src/libraries/Microsoft.Extensions.Logging.Debug/Microsoft.Extensions.Logging.Debug.sln index 697e5414259..8d77fe9d366 100644 --- a/src/libraries/Microsoft.Extensions.Logging.Debug/Microsoft.Extensions.Logging.Debug.sln +++ b/src/libraries/Microsoft.Extensions.Logging.Debug/Microsoft.Extensions.Logging.Debug.sln @@ -43,6 +43,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Diagnostics.Diagnost EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{6861E718-D940-4E2A-A2EC-CB4F2EB68848}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{B1E33C5C-C439-4211-9226-6B6583E7246C}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{04FB7C63-ACEF-41F4-98E4-35F5635B4D73}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{635C575E-2759-4F37-A7CA-2A51BDCC84C5}" @@ -167,6 +169,10 @@ Global {6861E718-D940-4E2A-A2EC-CB4F2EB68848}.Debug|Any CPU.Build.0 = Debug|Any CPU {6861E718-D940-4E2A-A2EC-CB4F2EB68848}.Release|Any CPU.ActiveCfg = Release|Any CPU {6861E718-D940-4E2A-A2EC-CB4F2EB68848}.Release|Any CPU.Build.0 = Release|Any CPU + {B1E33C5C-C439-4211-9226-6B6583E7246C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {B1E33C5C-C439-4211-9226-6B6583E7246C}.Debug|Any CPU.Build.0 = Debug|Any CPU + {B1E33C5C-C439-4211-9226-6B6583E7246C}.Release|Any CPU.ActiveCfg = Release|Any CPU + {B1E33C5C-C439-4211-9226-6B6583E7246C}.Release|Any CPU.Build.0 = Release|Any CPU {04FB7C63-ACEF-41F4-98E4-35F5635B4D73}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {04FB7C63-ACEF-41F4-98E4-35F5635B4D73}.Debug|Any CPU.Build.0 = Debug|Any CPU {04FB7C63-ACEF-41F4-98E4-35F5635B4D73}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -227,6 +233,7 @@ Global {93655DA5-BC50-4F07-85B3-509076003CBD} = {B1578203-268C-45C3-B62C-3D5CFC340AB4} {79A27ACF-3616-4F3A-912A-85B066CAFBB7} = {B1578203-268C-45C3-B62C-3D5CFC340AB4} {6861E718-D940-4E2A-A2EC-CB4F2EB68848} = {B1578203-268C-45C3-B62C-3D5CFC340AB4} + {B1E33C5C-C439-4211-9226-6B6583E7246C} = {B1578203-268C-45C3-B62C-3D5CFC340AB4} {04FB7C63-ACEF-41F4-98E4-35F5635B4D73} = {B1578203-268C-45C3-B62C-3D5CFC340AB4} {635C575E-2759-4F37-A7CA-2A51BDCC84C5} = {B1578203-268C-45C3-B62C-3D5CFC340AB4} {AD3D11F1-8E50-4728-9ADE-90CFC857852C} = {B57846B6-4EB4-475F-AF4D-A4317F6B7754} diff --git a/src/libraries/Microsoft.Extensions.Logging.EventLog/Microsoft.Extensions.Logging.EventLog.sln b/src/libraries/Microsoft.Extensions.Logging.EventLog/Microsoft.Extensions.Logging.EventLog.sln index 21e9080752b..234be6c6679 100644 --- a/src/libraries/Microsoft.Extensions.Logging.EventLog/Microsoft.Extensions.Logging.EventLog.sln +++ b/src/libraries/Microsoft.Extensions.Logging.EventLog/Microsoft.Extensions.Logging.EventLog.sln @@ -49,6 +49,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Diagnostics.EventLog EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{F47FCBE9-78EB-40FE-B2F9-3D5DD4BDF9DF}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{D153031D-81C4-4131-AA0C-60A97493408A}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{7D8210EC-014D-4901-97D4-0C8AC919804E}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{82D7CA6B-8647-49A1-B4A1-40A8C6B9D7C2}" @@ -185,6 +187,10 @@ Global {F47FCBE9-78EB-40FE-B2F9-3D5DD4BDF9DF}.Debug|Any CPU.Build.0 = Debug|Any CPU {F47FCBE9-78EB-40FE-B2F9-3D5DD4BDF9DF}.Release|Any CPU.ActiveCfg = Release|Any CPU {F47FCBE9-78EB-40FE-B2F9-3D5DD4BDF9DF}.Release|Any CPU.Build.0 = Release|Any CPU + {D153031D-81C4-4131-AA0C-60A97493408A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D153031D-81C4-4131-AA0C-60A97493408A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D153031D-81C4-4131-AA0C-60A97493408A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D153031D-81C4-4131-AA0C-60A97493408A}.Release|Any CPU.Build.0 = Release|Any CPU {7D8210EC-014D-4901-97D4-0C8AC919804E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {7D8210EC-014D-4901-97D4-0C8AC919804E}.Debug|Any CPU.Build.0 = Debug|Any CPU {7D8210EC-014D-4901-97D4-0C8AC919804E}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -248,6 +254,7 @@ Global {4F09A07F-70C7-4288-A6F3-EFBD5306E1F7} = {677D11A9-4811-41EA-8F93-F8DB15BF27DD} {618F18BC-549D-4DAA-8551-3726CCA9A478} = {677D11A9-4811-41EA-8F93-F8DB15BF27DD} {F47FCBE9-78EB-40FE-B2F9-3D5DD4BDF9DF} = {677D11A9-4811-41EA-8F93-F8DB15BF27DD} + {D153031D-81C4-4131-AA0C-60A97493408A} = {677D11A9-4811-41EA-8F93-F8DB15BF27DD} {7D8210EC-014D-4901-97D4-0C8AC919804E} = {677D11A9-4811-41EA-8F93-F8DB15BF27DD} {82D7CA6B-8647-49A1-B4A1-40A8C6B9D7C2} = {677D11A9-4811-41EA-8F93-F8DB15BF27DD} {33358624-4070-44F4-8F87-0C1ADE0C45B9} = {16797022-28AE-4250-970B-7A27D77C97FD} diff --git a/src/libraries/Microsoft.Extensions.Logging.EventSource/Microsoft.Extensions.Logging.EventSource.sln b/src/libraries/Microsoft.Extensions.Logging.EventSource/Microsoft.Extensions.Logging.EventSource.sln index 77fd2bd1bba..92b6aaf0684 100644 --- a/src/libraries/Microsoft.Extensions.Logging.EventSource/Microsoft.Extensions.Logging.EventSource.sln +++ b/src/libraries/Microsoft.Extensions.Logging.EventSource/Microsoft.Extensions.Logging.EventSource.sln @@ -57,6 +57,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Memory", "..\System. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{EBF082B5-11B0-4514-BC86-F1D009382F90}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{E52787E9-A6D2-4804-8135-6CEA43F9C6EB}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{05F7A599-FAFB-4F24-ABB5-548219FF6492}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{F722EACC-BB4F-4A88-B833-BB931E20CFCD}" @@ -227,6 +229,10 @@ Global {EBF082B5-11B0-4514-BC86-F1D009382F90}.Debug|Any CPU.Build.0 = Debug|Any CPU {EBF082B5-11B0-4514-BC86-F1D009382F90}.Release|Any CPU.ActiveCfg = Release|Any CPU {EBF082B5-11B0-4514-BC86-F1D009382F90}.Release|Any CPU.Build.0 = Release|Any CPU + {E52787E9-A6D2-4804-8135-6CEA43F9C6EB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E52787E9-A6D2-4804-8135-6CEA43F9C6EB}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E52787E9-A6D2-4804-8135-6CEA43F9C6EB}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E52787E9-A6D2-4804-8135-6CEA43F9C6EB}.Release|Any CPU.Build.0 = Release|Any CPU {05F7A599-FAFB-4F24-ABB5-548219FF6492}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {05F7A599-FAFB-4F24-ABB5-548219FF6492}.Debug|Any CPU.Build.0 = Debug|Any CPU {05F7A599-FAFB-4F24-ABB5-548219FF6492}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -330,6 +336,7 @@ Global {1201F595-5DD2-400E-B707-16C215E39FF9} = {590E1BD9-E5AD-456B-B954-E26EA0BFE405} {97074CAA-5BD7-41F3-8E99-D6D405A3D5EA} = {590E1BD9-E5AD-456B-B954-E26EA0BFE405} {EBF082B5-11B0-4514-BC86-F1D009382F90} = {590E1BD9-E5AD-456B-B954-E26EA0BFE405} + {E52787E9-A6D2-4804-8135-6CEA43F9C6EB} = {590E1BD9-E5AD-456B-B954-E26EA0BFE405} {05F7A599-FAFB-4F24-ABB5-548219FF6492} = {590E1BD9-E5AD-456B-B954-E26EA0BFE405} {F722EACC-BB4F-4A88-B833-BB931E20CFCD} = {590E1BD9-E5AD-456B-B954-E26EA0BFE405} {62AECDFA-699B-41B0-AE5F-4B7D5D8F26B1} = {590E1BD9-E5AD-456B-B954-E26EA0BFE405} diff --git a/src/libraries/Microsoft.Extensions.Logging.EventSource/src/Microsoft.Extensions.Logging.EventSource.csproj b/src/libraries/Microsoft.Extensions.Logging.EventSource/src/Microsoft.Extensions.Logging.EventSource.csproj index cdf8b243f26..93f6eb01c75 100644 --- a/src/libraries/Microsoft.Extensions.Logging.EventSource/src/Microsoft.Extensions.Logging.EventSource.csproj +++ b/src/libraries/Microsoft.Extensions.Logging.EventSource/src/Microsoft.Extensions.Logging.EventSource.csproj @@ -31,7 +31,10 @@ - + + + + diff --git a/src/libraries/Microsoft.Extensions.Logging.TraceSource/Microsoft.Extensions.Logging.TraceSource.sln b/src/libraries/Microsoft.Extensions.Logging.TraceSource/Microsoft.Extensions.Logging.TraceSource.sln index 0b80194fca6..224ede76fae 100644 --- a/src/libraries/Microsoft.Extensions.Logging.TraceSource/Microsoft.Extensions.Logging.TraceSource.sln +++ b/src/libraries/Microsoft.Extensions.Logging.TraceSource/Microsoft.Extensions.Logging.TraceSource.sln @@ -43,6 +43,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Diagnostics.Diagnost EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{FC7A7BE7-332C-4970-8744-50CCBABAF0F4}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{85476AA3-A4AA-4323-9ECF-D6C93573750E}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{F5F7EA6D-5CBB-4711-8B79-17AF857DE2AC}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{4559571A-68B4-40DD-B22F-76D6E06683EB}" @@ -167,6 +169,10 @@ Global {FC7A7BE7-332C-4970-8744-50CCBABAF0F4}.Debug|Any CPU.Build.0 = Debug|Any CPU {FC7A7BE7-332C-4970-8744-50CCBABAF0F4}.Release|Any CPU.ActiveCfg = Release|Any CPU {FC7A7BE7-332C-4970-8744-50CCBABAF0F4}.Release|Any CPU.Build.0 = Release|Any CPU + {85476AA3-A4AA-4323-9ECF-D6C93573750E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {85476AA3-A4AA-4323-9ECF-D6C93573750E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {85476AA3-A4AA-4323-9ECF-D6C93573750E}.Release|Any CPU.ActiveCfg = Release|Any CPU + {85476AA3-A4AA-4323-9ECF-D6C93573750E}.Release|Any CPU.Build.0 = Release|Any CPU {F5F7EA6D-5CBB-4711-8B79-17AF857DE2AC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {F5F7EA6D-5CBB-4711-8B79-17AF857DE2AC}.Debug|Any CPU.Build.0 = Debug|Any CPU {F5F7EA6D-5CBB-4711-8B79-17AF857DE2AC}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -227,6 +233,7 @@ Global {7B81FBBF-6DC2-4854-990F-0D4394E00A8A} = {E852D5A7-219C-4E2B-A327-6C6B988E65FC} {A78E92E0-2B40-422E-A77B-E94ADE714502} = {E852D5A7-219C-4E2B-A327-6C6B988E65FC} {FC7A7BE7-332C-4970-8744-50CCBABAF0F4} = {E852D5A7-219C-4E2B-A327-6C6B988E65FC} + {85476AA3-A4AA-4323-9ECF-D6C93573750E} = {E852D5A7-219C-4E2B-A327-6C6B988E65FC} {F5F7EA6D-5CBB-4711-8B79-17AF857DE2AC} = {E852D5A7-219C-4E2B-A327-6C6B988E65FC} {4559571A-68B4-40DD-B22F-76D6E06683EB} = {E852D5A7-219C-4E2B-A327-6C6B988E65FC} {0DE6DDCB-D85C-42C3-A2C5-7DA1609CB216} = {05ABF419-55CC-431B-845C-9899458A3DC5} diff --git a/src/libraries/Microsoft.Extensions.Logging/Microsoft.Extensions.Logging.sln b/src/libraries/Microsoft.Extensions.Logging/Microsoft.Extensions.Logging.sln index c3e4c25f3b3..c17e4bf6ad4 100644 --- a/src/libraries/Microsoft.Extensions.Logging/Microsoft.Extensions.Logging.sln +++ b/src/libraries/Microsoft.Extensions.Logging/Microsoft.Extensions.Logging.sln @@ -119,6 +119,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Memory", "..\System. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{CDA036E5-80B8-4854-81ED-4664E203B0D0}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{0BA2A7C6-5D0C-4ACC-AEF4-023D875ADAC8}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{7268FF18-CAB4-4BC8-A767-161033C9D0BB}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{2CBBB613-7A47-495A-839D-76824F6C2100}" @@ -413,6 +415,10 @@ Global {CDA036E5-80B8-4854-81ED-4664E203B0D0}.Debug|Any CPU.Build.0 = Debug|Any CPU {CDA036E5-80B8-4854-81ED-4664E203B0D0}.Release|Any CPU.ActiveCfg = Release|Any CPU {CDA036E5-80B8-4854-81ED-4664E203B0D0}.Release|Any CPU.Build.0 = Release|Any CPU + {0BA2A7C6-5D0C-4ACC-AEF4-023D875ADAC8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {0BA2A7C6-5D0C-4ACC-AEF4-023D875ADAC8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {0BA2A7C6-5D0C-4ACC-AEF4-023D875ADAC8}.Release|Any CPU.ActiveCfg = Release|Any CPU + {0BA2A7C6-5D0C-4ACC-AEF4-023D875ADAC8}.Release|Any CPU.Build.0 = Release|Any CPU {7268FF18-CAB4-4BC8-A767-161033C9D0BB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {7268FF18-CAB4-4BC8-A767-161033C9D0BB}.Debug|Any CPU.Build.0 = Debug|Any CPU {7268FF18-CAB4-4BC8-A767-161033C9D0BB}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -547,6 +553,7 @@ Global {E1519A2D-BBC6-4C15-BCAA-6B42EBE6FB0A} = {BCF59319-979C-42FA-9B5E-19EFCC91D288} {D5F7EDA2-2AA7-4598-AB90-45065C0FD0E2} = {BCF59319-979C-42FA-9B5E-19EFCC91D288} {CDA036E5-80B8-4854-81ED-4664E203B0D0} = {BCF59319-979C-42FA-9B5E-19EFCC91D288} + {0BA2A7C6-5D0C-4ACC-AEF4-023D875ADAC8} = {BCF59319-979C-42FA-9B5E-19EFCC91D288} {7268FF18-CAB4-4BC8-A767-161033C9D0BB} = {BCF59319-979C-42FA-9B5E-19EFCC91D288} {2CBBB613-7A47-495A-839D-76824F6C2100} = {BCF59319-979C-42FA-9B5E-19EFCC91D288} {C1557157-7D8E-43A3-89D1-9F4F2621D838} = {BCF59319-979C-42FA-9B5E-19EFCC91D288} diff --git a/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/Microsoft.Extensions.Options.ConfigurationExtensions.sln b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/Microsoft.Extensions.Options.ConfigurationExtensions.sln index 2bf3344b9df..204022bacbe 100644 --- a/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/Microsoft.Extensions.Options.ConfigurationExtensions.sln +++ b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/Microsoft.Extensions.Options.ConfigurationExtensions.sln @@ -43,7 +43,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Primit EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Primitives", "..\Microsoft.Extensions.Primitives\src\Microsoft.Extensions.Primitives.csproj", "{616C55BF-AE90-47F2-A005-980CADDBD990}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{69B3A343-3883-4F35-8B8A-2A126A9B0762}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{E58F2EFF-49B0-4AD9-B6D4-16E9F9CD3FB1}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{9621BAB7-9AFF-4CAD-BFFF-B6BC1341155C}" EndProject @@ -167,10 +167,10 @@ Global {616C55BF-AE90-47F2-A005-980CADDBD990}.Debug|Any CPU.Build.0 = Debug|Any CPU {616C55BF-AE90-47F2-A005-980CADDBD990}.Release|Any CPU.ActiveCfg = Release|Any CPU {616C55BF-AE90-47F2-A005-980CADDBD990}.Release|Any CPU.Build.0 = Release|Any CPU - {69B3A343-3883-4F35-8B8A-2A126A9B0762}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {69B3A343-3883-4F35-8B8A-2A126A9B0762}.Debug|Any CPU.Build.0 = Debug|Any CPU - {69B3A343-3883-4F35-8B8A-2A126A9B0762}.Release|Any CPU.ActiveCfg = Release|Any CPU - {69B3A343-3883-4F35-8B8A-2A126A9B0762}.Release|Any CPU.Build.0 = Release|Any CPU + {E58F2EFF-49B0-4AD9-B6D4-16E9F9CD3FB1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E58F2EFF-49B0-4AD9-B6D4-16E9F9CD3FB1}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E58F2EFF-49B0-4AD9-B6D4-16E9F9CD3FB1}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E58F2EFF-49B0-4AD9-B6D4-16E9F9CD3FB1}.Release|Any CPU.Build.0 = Release|Any CPU {9621BAB7-9AFF-4CAD-BFFF-B6BC1341155C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {9621BAB7-9AFF-4CAD-BFFF-B6BC1341155C}.Debug|Any CPU.Build.0 = Debug|Any CPU {9621BAB7-9AFF-4CAD-BFFF-B6BC1341155C}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -222,7 +222,7 @@ Global {E8051516-B4B6-479E-BA8D-F3355B169F8D} = {1FFB0A3C-B679-431A-B36B-123EE6166D14} {8F355290-0867-40A2-8F92-E9A3C5F5BAAF} = {F4006304-5C88-478E-A93C-621D71A5097F} {13292F01-310D-434D-BC4D-7E102ABE17BB} = {F4006304-5C88-478E-A93C-621D71A5097F} - {69B3A343-3883-4F35-8B8A-2A126A9B0762} = {F4006304-5C88-478E-A93C-621D71A5097F} + {E58F2EFF-49B0-4AD9-B6D4-16E9F9CD3FB1} = {F4006304-5C88-478E-A93C-621D71A5097F} {9621BAB7-9AFF-4CAD-BFFF-B6BC1341155C} = {F4006304-5C88-478E-A93C-621D71A5097F} {0E0027B4-8633-40E0-BB3C-6A09BA077006} = {29852EC8-54F4-4C93-A9AA-D86D2B532042} {32F49285-E4F8-486F-AF11-323D963878F5} = {29852EC8-54F4-4C93-A9AA-D86D2B532042} diff --git a/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/OptionsConfigurationServiceCollectionExtensions.cs b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/OptionsConfigurationServiceCollectionExtensions.cs index 89c15c052ee..aae277058fe 100644 --- a/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/OptionsConfigurationServiceCollectionExtensions.cs +++ b/src/libraries/Microsoft.Extensions.Options.ConfigurationExtensions/src/OptionsConfigurationServiceCollectionExtensions.cs @@ -9,12 +9,12 @@ namespace Microsoft.Extensions.DependencyInjection { /// - /// Extension methods for adding configuration related options services to the DI container. + /// Extension methods for adding configuration-related options services to the DI container. /// public static class OptionsConfigurationServiceCollectionExtensions { /// - /// Registers a configuration instance which TOptions will bind against. + /// Registers a configuration instance that will bind against. /// /// The type of options being configured. /// The to add the services to. @@ -26,7 +26,7 @@ public static class OptionsConfigurationServiceCollectionExtensions => services.Configure(Options.Options.DefaultName, config); /// - /// Registers a configuration instance which TOptions will bind against. + /// Registers a configuration instance that will bind against. /// /// The type of options being configured. /// The to add the services to. @@ -39,7 +39,7 @@ public static class OptionsConfigurationServiceCollectionExtensions => services.Configure(name, config, _ => { }); /// - /// Registers a configuration instance which TOptions will bind against. + /// Registers a configuration instance that will bind against. /// /// The type of options being configured. /// The to add the services to. @@ -53,7 +53,7 @@ public static class OptionsConfigurationServiceCollectionExtensions => services.Configure(Options.Options.DefaultName, config, configureBinder); /// - /// Registers a configuration instance which TOptions will bind against. + /// Registers a configuration instance that will bind against. /// /// The type of options being configured. /// The to add the services to. diff --git a/src/libraries/Microsoft.Extensions.Options.DataAnnotations/Microsoft.Extensions.Options.DataAnnotations.sln b/src/libraries/Microsoft.Extensions.Options.DataAnnotations/Microsoft.Extensions.Options.DataAnnotations.sln index 48bb9d27f01..9ec7fa1409f 100644 --- a/src/libraries/Microsoft.Extensions.Options.DataAnnotations/Microsoft.Extensions.Options.DataAnnotations.sln +++ b/src/libraries/Microsoft.Extensions.Options.DataAnnotations/Microsoft.Extensions.Options.DataAnnotations.sln @@ -19,7 +19,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Primit EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Primitives", "..\Microsoft.Extensions.Primitives\src\Microsoft.Extensions.Primitives.csproj", "{065B4B16-B618-41D8-B1DE-F31AFC9E6C84}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{47E4AB7D-BC64-4323-B723-CD2B7DA9BB88}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{61C71B61-54B0-4D88-AFF2-4B1A1A8DD21A}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{BBFDDC90-8F98-4DD7-8A18-8E2345C18904}" EndProject @@ -93,10 +93,10 @@ Global {065B4B16-B618-41D8-B1DE-F31AFC9E6C84}.Debug|Any CPU.Build.0 = Debug|Any CPU {065B4B16-B618-41D8-B1DE-F31AFC9E6C84}.Release|Any CPU.ActiveCfg = Release|Any CPU {065B4B16-B618-41D8-B1DE-F31AFC9E6C84}.Release|Any CPU.Build.0 = Release|Any CPU - {47E4AB7D-BC64-4323-B723-CD2B7DA9BB88}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {47E4AB7D-BC64-4323-B723-CD2B7DA9BB88}.Debug|Any CPU.Build.0 = Debug|Any CPU - {47E4AB7D-BC64-4323-B723-CD2B7DA9BB88}.Release|Any CPU.ActiveCfg = Release|Any CPU - {47E4AB7D-BC64-4323-B723-CD2B7DA9BB88}.Release|Any CPU.Build.0 = Release|Any CPU + {61C71B61-54B0-4D88-AFF2-4B1A1A8DD21A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {61C71B61-54B0-4D88-AFF2-4B1A1A8DD21A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {61C71B61-54B0-4D88-AFF2-4B1A1A8DD21A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {61C71B61-54B0-4D88-AFF2-4B1A1A8DD21A}.Release|Any CPU.Build.0 = Release|Any CPU {BBFDDC90-8F98-4DD7-8A18-8E2345C18904}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {BBFDDC90-8F98-4DD7-8A18-8E2345C18904}.Debug|Any CPU.Build.0 = Debug|Any CPU {BBFDDC90-8F98-4DD7-8A18-8E2345C18904}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -136,7 +136,7 @@ Global {8F8A5D2D-A829-4E0E-9DCC-57FF2C89C544} = {DE5517CB-9721-49A0-9ECB-BC08460946AC} {0E60E743-56C9-466D-A428-232FEAEEF41E} = {DE5517CB-9721-49A0-9ECB-BC08460946AC} {AE2D1BFD-FD06-4227-98A7-14604F9D0EFC} = {5B543880-D43D-48B8-9C46-CEE391D03B73} - {47E4AB7D-BC64-4323-B723-CD2B7DA9BB88} = {5B543880-D43D-48B8-9C46-CEE391D03B73} + {61C71B61-54B0-4D88-AFF2-4B1A1A8DD21A} = {5B543880-D43D-48B8-9C46-CEE391D03B73} {BBFDDC90-8F98-4DD7-8A18-8E2345C18904} = {5B543880-D43D-48B8-9C46-CEE391D03B73} {78B102D5-FBC0-4304-B14D-D6CFF50A30DA} = {237F45C3-B835-4C47-A298-604D5BFC60DC} {D7C772DD-9024-422B-BFBF-BB1F943FC50F} = {237F45C3-B835-4C47-A298-604D5BFC60DC} diff --git a/src/libraries/Microsoft.Extensions.Options/Microsoft.Extensions.Options.sln b/src/libraries/Microsoft.Extensions.Options/Microsoft.Extensions.Options.sln index 8af8aa064f8..0ab284f81d2 100644 --- a/src/libraries/Microsoft.Extensions.Options/Microsoft.Extensions.Options.sln +++ b/src/libraries/Microsoft.Extensions.Options/Microsoft.Extensions.Options.sln @@ -169,6 +169,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Resources.Writer", " EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{62065BFE-5477-44DD-A328-582B0F050EC3}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{AD9DC49B-97C3-4C83-A941-C4A114AAD08E}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{02425B61-8D98-4F4A-88AE-F77D4837DF9E}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{E0460280-2F49-474C-862D-1787D9244CC8}" @@ -563,6 +565,10 @@ Global {62065BFE-5477-44DD-A328-582B0F050EC3}.Debug|Any CPU.Build.0 = Debug|Any CPU {62065BFE-5477-44DD-A328-582B0F050EC3}.Release|Any CPU.ActiveCfg = Release|Any CPU {62065BFE-5477-44DD-A328-582B0F050EC3}.Release|Any CPU.Build.0 = Release|Any CPU + {AD9DC49B-97C3-4C83-A941-C4A114AAD08E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {AD9DC49B-97C3-4C83-A941-C4A114AAD08E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {AD9DC49B-97C3-4C83-A941-C4A114AAD08E}.Release|Any CPU.ActiveCfg = Release|Any CPU + {AD9DC49B-97C3-4C83-A941-C4A114AAD08E}.Release|Any CPU.Build.0 = Release|Any CPU {02425B61-8D98-4F4A-88AE-F77D4837DF9E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {02425B61-8D98-4F4A-88AE-F77D4837DF9E}.Debug|Any CPU.Build.0 = Debug|Any CPU {02425B61-8D98-4F4A-88AE-F77D4837DF9E}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -722,6 +728,7 @@ Global {333116ED-7874-4ECD-91EC-641B8479F696} = {C25891DB-FBAC-4B92-9BB9-A8181B5A0EF1} {2B8ED012-22B5-47DD-A879-FD2AFD4C067D} = {C25891DB-FBAC-4B92-9BB9-A8181B5A0EF1} {62065BFE-5477-44DD-A328-582B0F050EC3} = {C25891DB-FBAC-4B92-9BB9-A8181B5A0EF1} + {AD9DC49B-97C3-4C83-A941-C4A114AAD08E} = {C25891DB-FBAC-4B92-9BB9-A8181B5A0EF1} {02425B61-8D98-4F4A-88AE-F77D4837DF9E} = {C25891DB-FBAC-4B92-9BB9-A8181B5A0EF1} {E0460280-2F49-474C-862D-1787D9244CC8} = {C25891DB-FBAC-4B92-9BB9-A8181B5A0EF1} {B5F25A78-B7FB-460B-9B71-BE82D22923FD} = {C25891DB-FBAC-4B92-9BB9-A8181B5A0EF1} diff --git a/src/libraries/Microsoft.Extensions.Options/src/IOptionsMonitor.cs b/src/libraries/Microsoft.Extensions.Options/src/IOptionsMonitor.cs index 3511305dade..fbb3759b1a9 100644 --- a/src/libraries/Microsoft.Extensions.Options/src/IOptionsMonitor.cs +++ b/src/libraries/Microsoft.Extensions.Options/src/IOptionsMonitor.cs @@ -20,7 +20,7 @@ public interface IOptionsMonitor<[DynamicallyAccessedMembers(Options.Dynamically /// /// Returns a configured instance with the given . /// - /// The name of the instance, if a is used. + /// The name of the instance. If , , which is the empty string, is used. /// The instance that matches the given . TOptions Get(string? name); @@ -28,7 +28,7 @@ public interface IOptionsMonitor<[DynamicallyAccessedMembers(Options.Dynamically /// Registers a listener to be called whenever a named changes. /// /// The action to be invoked when has changed. - /// An which should be disposed to stop listening for changes. + /// An that should be disposed to stop listening for changes. IDisposable? OnChange(Action listener); } } diff --git a/src/libraries/Microsoft.Extensions.Options/src/IOptionsSnapshot.cs b/src/libraries/Microsoft.Extensions.Options/src/IOptionsSnapshot.cs index 4db3dc2d15e..c7f430b3d2d 100644 --- a/src/libraries/Microsoft.Extensions.Options/src/IOptionsSnapshot.cs +++ b/src/libraries/Microsoft.Extensions.Options/src/IOptionsSnapshot.cs @@ -16,7 +16,7 @@ public interface IOptionsSnapshot<[DynamicallyAccessedMembers(Options.Dynamicall /// /// Returns a configured instance with the given . /// - /// The name of the instance, if is used. + /// The name of the instance. If , , which is the empty string, is used. /// The instance that matches the given . TOptions Get(string? name); } diff --git a/src/libraries/Microsoft.Extensions.Options/src/OptionsBuilderExtensions.cs b/src/libraries/Microsoft.Extensions.Options/src/OptionsBuilderExtensions.cs index 2eacc9038e3..92eb966ca30 100644 --- a/src/libraries/Microsoft.Extensions.Options/src/OptionsBuilderExtensions.cs +++ b/src/libraries/Microsoft.Extensions.Options/src/OptionsBuilderExtensions.cs @@ -9,14 +9,14 @@ namespace Microsoft.Extensions.DependencyInjection { /// - /// Extension methods for adding configuration related options services to the DI container via . + /// Extension methods for adding configuration-related options services to the DI container via . /// [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2091:UnrecognizedReflectionPattern", Justification = "Workaround for https://github.com/mono/linker/issues/1416. Outer method has been annotated with DynamicallyAccessedMembers.")] public static class OptionsBuilderExtensions { /// - /// Enforces options validation check on start rather than in runtime. + /// Enforces options validation check on start rather than at run time. /// /// The type of options. /// The to configure options instance. diff --git a/src/libraries/Microsoft.Extensions.Options/src/OptionsManager.cs b/src/libraries/Microsoft.Extensions.Options/src/OptionsManager.cs index a3a41394d3f..efbe0fe5813 100644 --- a/src/libraries/Microsoft.Extensions.Options/src/OptionsManager.cs +++ b/src/libraries/Microsoft.Extensions.Options/src/OptionsManager.cs @@ -7,7 +7,7 @@ namespace Microsoft.Extensions.Options { /// - /// Implementation of and . + /// Implements and . /// /// Options type. public class OptionsManager<[DynamicallyAccessedMembers(Options.DynamicallyAccessedMembers)] TOptions> : @@ -35,7 +35,7 @@ public OptionsManager(IOptionsFactory factory) /// /// Returns a configured instance with the given . /// - /// The name of the instance, if is used. + /// The name of the instance. If , , which is the empty string, is used. /// The instance that matches the given . /// One or more return failed when validating the instance been created. /// The does not have a public parameterless constructor or is . diff --git a/src/libraries/Microsoft.Extensions.Options/src/OptionsMonitor.cs b/src/libraries/Microsoft.Extensions.Options/src/OptionsMonitor.cs index 49dffcfb5a5..624dcf66af9 100644 --- a/src/libraries/Microsoft.Extensions.Options/src/OptionsMonitor.cs +++ b/src/libraries/Microsoft.Extensions.Options/src/OptionsMonitor.cs @@ -9,7 +9,7 @@ namespace Microsoft.Extensions.Options { /// - /// Implementation of . + /// Implements . /// /// Options type. public class OptionsMonitor<[DynamicallyAccessedMembers(Options.DynamicallyAccessedMembers)] TOptions> : @@ -23,7 +23,7 @@ public class OptionsMonitor<[DynamicallyAccessedMembers(Options.DynamicallyAcces internal event Action? _onChange; /// - /// Constructor. + /// Initializes a new instance of with the specified factory, sources, and cache. /// /// The factory to use to create options. /// The sources used to listen for changes to the options instance. @@ -82,7 +82,7 @@ public TOptions CurrentValue /// /// Returns a configured instance with the given . /// - /// The name of the instance, if is used. + /// The name of the instance. If , , which is the empty string, is used. /// The instance that matches the given . /// One or more return failed when validating the instance been created. /// The does not have a public parameterless constructor or is . @@ -105,7 +105,7 @@ public virtual TOptions Get(string? name) /// Registers a listener to be called whenever changes. /// /// The action to be invoked when has changed. - /// An which should be disposed to stop listening for changes. + /// An that should be disposed to stop listening for changes. public IDisposable OnChange(Action listener) { var disposable = new ChangeTrackerDisposable(this, listener); diff --git a/src/libraries/Microsoft.Extensions.Options/src/OptionsServiceCollectionExtensions.cs b/src/libraries/Microsoft.Extensions.Options/src/OptionsServiceCollectionExtensions.cs index 6f212cc3b35..131f5d66e92 100644 --- a/src/libraries/Microsoft.Extensions.Options/src/OptionsServiceCollectionExtensions.cs +++ b/src/libraries/Microsoft.Extensions.Options/src/OptionsServiceCollectionExtensions.cs @@ -32,7 +32,7 @@ public static IServiceCollection AddOptions(this IServiceCollection services) } /// - /// Adds services required for using options and enforces options validation check on start rather than in runtime. + /// Adds services required for using options and enforces options validation check on start rather than at run time. /// /// /// The extension is called by this method. @@ -51,7 +51,7 @@ public static OptionsBuilder AddOptionsWithValidateOnStart< } /// - /// Adds services required for using options and enforces options validation check on start rather than in runtime. + /// Adds services required for using options and enforces options validation check on start rather than at run time. /// /// /// The extension is called by this method. diff --git a/src/libraries/Microsoft.Extensions.Primitives/Microsoft.Extensions.Primitives.sln b/src/libraries/Microsoft.Extensions.Primitives/Microsoft.Extensions.Primitives.sln index a1e7da32e32..e2c57dd3b95 100644 --- a/src/libraries/Microsoft.Extensions.Primitives/Microsoft.Extensions.Primitives.sln +++ b/src/libraries/Microsoft.Extensions.Primitives/Microsoft.Extensions.Primitives.sln @@ -7,7 +7,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Primit EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Primitives.Tests", "tests\Microsoft.Extensions.Primitives.Tests.csproj", "{43DBAD84-A865-4F5F-AB76-7F3EB6784E99}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{87AA8A4F-2785-4E1D-BAB2-3C6414C8D387}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{2BFB1E6A-0C9A-4262-BE08-D985793F3BDB}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{959348BC-2D38-41F4-9F3D-2E1CD18D9477}" EndProject @@ -59,10 +59,10 @@ Global {43DBAD84-A865-4F5F-AB76-7F3EB6784E99}.Debug|Any CPU.Build.0 = Debug|Any CPU {43DBAD84-A865-4F5F-AB76-7F3EB6784E99}.Release|Any CPU.ActiveCfg = Release|Any CPU {43DBAD84-A865-4F5F-AB76-7F3EB6784E99}.Release|Any CPU.Build.0 = Release|Any CPU - {87AA8A4F-2785-4E1D-BAB2-3C6414C8D387}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {87AA8A4F-2785-4E1D-BAB2-3C6414C8D387}.Debug|Any CPU.Build.0 = Debug|Any CPU - {87AA8A4F-2785-4E1D-BAB2-3C6414C8D387}.Release|Any CPU.ActiveCfg = Release|Any CPU - {87AA8A4F-2785-4E1D-BAB2-3C6414C8D387}.Release|Any CPU.Build.0 = Release|Any CPU + {2BFB1E6A-0C9A-4262-BE08-D985793F3BDB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {2BFB1E6A-0C9A-4262-BE08-D985793F3BDB}.Debug|Any CPU.Build.0 = Debug|Any CPU + {2BFB1E6A-0C9A-4262-BE08-D985793F3BDB}.Release|Any CPU.ActiveCfg = Release|Any CPU + {2BFB1E6A-0C9A-4262-BE08-D985793F3BDB}.Release|Any CPU.Build.0 = Release|Any CPU {959348BC-2D38-41F4-9F3D-2E1CD18D9477}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {959348BC-2D38-41F4-9F3D-2E1CD18D9477}.Debug|Any CPU.Build.0 = Debug|Any CPU {959348BC-2D38-41F4-9F3D-2E1CD18D9477}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -96,7 +96,7 @@ Global {43DBAD84-A865-4F5F-AB76-7F3EB6784E99} = {76DC9C4C-EE53-47E6-B6BF-7B135EA8CAF3} {EF75497C-6CB7-4471-980A-619EA1AB8CF6} = {9BF048D0-411D-4C2A-8C32-3A3255501D27} {09E28D94-B771-48EB-800C-5A80C2C0055C} = {A447D0CB-601B-479E-A2B2-76E48F5D4D61} - {87AA8A4F-2785-4E1D-BAB2-3C6414C8D387} = {069D6714-DE43-45C4-BABC-C8246B974CA7} + {2BFB1E6A-0C9A-4262-BE08-D985793F3BDB} = {069D6714-DE43-45C4-BABC-C8246B974CA7} {959348BC-2D38-41F4-9F3D-2E1CD18D9477} = {069D6714-DE43-45C4-BABC-C8246B974CA7} {AB1FA57B-0C7A-4181-B28C-2D8B63AF602B} = {759FB424-166D-4160-90E2-F862915F67C8} {92CF1194-29BD-444D-952E-77EEA741D8DD} = {759FB424-166D-4160-90E2-F862915F67C8} diff --git a/src/libraries/Microsoft.Extensions.Primitives/src/StringValues.cs b/src/libraries/Microsoft.Extensions.Primitives/src/StringValues.cs index 591830f3bec..67d9261276d 100644 --- a/src/libraries/Microsoft.Extensions.Primitives/src/StringValues.cs +++ b/src/libraries/Microsoft.Extensions.Primitives/src/StringValues.cs @@ -302,7 +302,7 @@ static string GetJoinedStringValueFromArray(string?[] values) /// Returns the zero-based index of the first occurrence of an item in the . /// /// The string to locate in the . - /// the zero-based index of the first occurrence of within the , if found; otherwise, -1. + /// The zero-based index of the first occurrence of within the , if found; otherwise, -1. int IList.IndexOf(string? item) { return IndexOf(item); @@ -335,7 +335,7 @@ private int IndexOf(string? item) /// Determines whether a string is in the . /// The to locate in the . - /// true if item is found in the ; otherwise, false. + /// if is found in the ; otherwise, . bool ICollection.Contains(string? item) { return IndexOf(item) >= 0; @@ -346,9 +346,9 @@ private int IndexOf(string? item) /// /// The one-dimensional that is the destination of the elements copied from. The must have zero-based indexing. /// The zero-based index in the destination array at which copying begins. - /// array is null. - /// arrayIndex is less than 0. - /// The number of elements in the source is greater than the available space from arrayIndex to the end of the destination array. + /// is null. + /// is less than 0. + /// The number of elements in the source is greater than the available space from to the end of the destination . void ICollection.CopyTo(string?[] array, int arrayIndex) { CopyTo(array, arrayIndex); @@ -418,7 +418,7 @@ IEnumerator IEnumerable.GetEnumerator() /// Indicates whether the specified contains no string values. /// /// The to test. - /// true if value contains a single null or empty string or an empty array; otherwise, false. + /// true if contains a single null or empty string or an empty array; otherwise, false. public static bool IsNullOrEmpty(StringValues value) { object? data = value._values; diff --git a/src/libraries/Microsoft.VisualBasic.Core/Microsoft.VisualBasic.Core.sln b/src/libraries/Microsoft.VisualBasic.Core/Microsoft.VisualBasic.Core.sln index 669f9bd038d..e0a53dcdaf8 100644 --- a/src/libraries/Microsoft.VisualBasic.Core/Microsoft.VisualBasic.Core.sln +++ b/src/libraries/Microsoft.VisualBasic.Core/Microsoft.VisualBasic.Core.sln @@ -11,6 +11,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.IO.FileSystem.DriveI EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{58FF6A8C-3BAB-4C28-9940-1FAAD0896D2E}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{683B4D00-EC23-4233-9363-3C1B91BBEEB9}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{18CE2A0D-C20E-42E5-9845-A934A5073529}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{DD515FA9-D026-4B9B-9456-2D174634C12D}" @@ -77,6 +79,10 @@ Global {58FF6A8C-3BAB-4C28-9940-1FAAD0896D2E}.Debug|Any CPU.Build.0 = Debug|Any CPU {58FF6A8C-3BAB-4C28-9940-1FAAD0896D2E}.Release|Any CPU.ActiveCfg = Release|Any CPU {58FF6A8C-3BAB-4C28-9940-1FAAD0896D2E}.Release|Any CPU.Build.0 = Release|Any CPU + {683B4D00-EC23-4233-9363-3C1B91BBEEB9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {683B4D00-EC23-4233-9363-3C1B91BBEEB9}.Debug|Any CPU.Build.0 = Debug|Any CPU + {683B4D00-EC23-4233-9363-3C1B91BBEEB9}.Release|Any CPU.ActiveCfg = Release|Any CPU + {683B4D00-EC23-4233-9363-3C1B91BBEEB9}.Release|Any CPU.Build.0 = Release|Any CPU {18CE2A0D-C20E-42E5-9845-A934A5073529}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {18CE2A0D-C20E-42E5-9845-A934A5073529}.Debug|Any CPU.Build.0 = Debug|Any CPU {18CE2A0D-C20E-42E5-9845-A934A5073529}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -131,6 +137,7 @@ Global {E741B977-6B3F-4DA7-A22B-251A1B3E42F7} = {2FC8E7CF-2E28-42BB-BCC0-DD0EDF96A483} {30CC7F8D-60DB-49C5-BE59-81477BFE0376} = {2FC8E7CF-2E28-42BB-BCC0-DD0EDF96A483} {58FF6A8C-3BAB-4C28-9940-1FAAD0896D2E} = {037CA0A6-EB43-4A49-A854-E13AE7B8972D} + {683B4D00-EC23-4233-9363-3C1B91BBEEB9} = {037CA0A6-EB43-4A49-A854-E13AE7B8972D} {18CE2A0D-C20E-42E5-9845-A934A5073529} = {037CA0A6-EB43-4A49-A854-E13AE7B8972D} {DD515FA9-D026-4B9B-9456-2D174634C12D} = {037CA0A6-EB43-4A49-A854-E13AE7B8972D} {0618F03A-8DB1-41C5-AAEF-A1A54E024260} = {CAF72038-74B0-44E3-A557-E7828DF9A914} diff --git a/src/libraries/Microsoft.Win32.Primitives/Microsoft.Win32.Primitives.sln b/src/libraries/Microsoft.Win32.Primitives/Microsoft.Win32.Primitives.sln index 43eab4816f4..02a0e27ff1d 100644 --- a/src/libraries/Microsoft.Win32.Primitives/Microsoft.Win32.Primitives.sln +++ b/src/libraries/Microsoft.Win32.Primitives/Microsoft.Win32.Primitives.sln @@ -13,6 +13,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib.Gene EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\System.Private.CoreLib\ref\System.Private.CoreLib.csproj", "{895AA9ED-9EBE-489A-B765-22D3358A3438}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{4E73E829-955B-496A-B37C-94F758B1F660}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{5918B01B-FCAE-4321-8DCA-44466A57C04E}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{EE5972A3-AD58-430B-ACEB-4F608FD1C0D6}" @@ -220,6 +222,27 @@ Global {895AA9ED-9EBE-489A-B765-22D3358A3438}.Checked|arm64.ActiveCfg = Debug|Any CPU {895AA9ED-9EBE-489A-B765-22D3358A3438}.Checked|x64.ActiveCfg = Debug|Any CPU {895AA9ED-9EBE-489A-B765-22D3358A3438}.Checked|x86.ActiveCfg = Debug|Any CPU + {4E73E829-955B-496A-B37C-94F758B1F660}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {4E73E829-955B-496A-B37C-94F758B1F660}.Debug|Any CPU.Build.0 = Debug|Any CPU + {4E73E829-955B-496A-B37C-94F758B1F660}.Debug|arm.ActiveCfg = Debug|Any CPU + {4E73E829-955B-496A-B37C-94F758B1F660}.Debug|arm64.ActiveCfg = Debug|Any CPU + {4E73E829-955B-496A-B37C-94F758B1F660}.Debug|x64.ActiveCfg = Debug|Any CPU + {4E73E829-955B-496A-B37C-94F758B1F660}.Debug|x64.Build.0 = Debug|Any CPU + {4E73E829-955B-496A-B37C-94F758B1F660}.Debug|x86.ActiveCfg = Debug|Any CPU + {4E73E829-955B-496A-B37C-94F758B1F660}.Debug|x86.Build.0 = Debug|Any CPU + {4E73E829-955B-496A-B37C-94F758B1F660}.Release|Any CPU.ActiveCfg = Release|Any CPU + {4E73E829-955B-496A-B37C-94F758B1F660}.Release|Any CPU.Build.0 = Release|Any CPU + {4E73E829-955B-496A-B37C-94F758B1F660}.Release|arm.ActiveCfg = Release|Any CPU + {4E73E829-955B-496A-B37C-94F758B1F660}.Release|arm64.ActiveCfg = Release|Any CPU + {4E73E829-955B-496A-B37C-94F758B1F660}.Release|x64.ActiveCfg = Release|Any CPU + {4E73E829-955B-496A-B37C-94F758B1F660}.Release|x64.Build.0 = Release|Any CPU + {4E73E829-955B-496A-B37C-94F758B1F660}.Release|x86.ActiveCfg = Release|Any CPU + {4E73E829-955B-496A-B37C-94F758B1F660}.Release|x86.Build.0 = Release|Any CPU + {4E73E829-955B-496A-B37C-94F758B1F660}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {4E73E829-955B-496A-B37C-94F758B1F660}.Checked|arm.ActiveCfg = Debug|Any CPU + {4E73E829-955B-496A-B37C-94F758B1F660}.Checked|arm64.ActiveCfg = Debug|Any CPU + {4E73E829-955B-496A-B37C-94F758B1F660}.Checked|x64.ActiveCfg = Debug|Any CPU + {4E73E829-955B-496A-B37C-94F758B1F660}.Checked|x86.ActiveCfg = Debug|Any CPU {5918B01B-FCAE-4321-8DCA-44466A57C04E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {5918B01B-FCAE-4321-8DCA-44466A57C04E}.Debug|Any CPU.Build.0 = Debug|Any CPU {5918B01B-FCAE-4321-8DCA-44466A57C04E}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -401,6 +424,7 @@ Global {895AA9ED-9EBE-489A-B765-22D3358A3438} = {08BAF9E0-068B-4201-91E6-91B725ABE3D2} {EC1A6210-05C0-4F57-969C-0EE0F29B5B67} = {08BAF9E0-068B-4201-91E6-91B725ABE3D2} {5F4ABB4F-CE69-47B7-860F-40B0DA68A7DB} = {A48D1F08-4510-44F9-9E77-7164B2769064} + {4E73E829-955B-496A-B37C-94F758B1F660} = {A48D1F08-4510-44F9-9E77-7164B2769064} {5918B01B-FCAE-4321-8DCA-44466A57C04E} = {A48D1F08-4510-44F9-9E77-7164B2769064} {EE5972A3-AD58-430B-ACEB-4F608FD1C0D6} = {A48D1F08-4510-44F9-9E77-7164B2769064} {559BBFDE-D6B6-4F51-A3A2-F7978E492FD6} = {32BFF540-62FE-4B93-BE7E-A41853C63CA9} diff --git a/src/libraries/Microsoft.Win32.Registry.AccessControl/Microsoft.Win32.Registry.AccessControl.sln b/src/libraries/Microsoft.Win32.Registry.AccessControl/Microsoft.Win32.Registry.AccessControl.sln index 957f4bb900d..3889528a88d 100644 --- a/src/libraries/Microsoft.Win32.Registry.AccessControl/Microsoft.Win32.Registry.AccessControl.sln +++ b/src/libraries/Microsoft.Win32.Registry.AccessControl/Microsoft.Win32.Registry.AccessControl.sln @@ -7,7 +7,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Win32.Registry.Ac EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Win32.Registry.AccessControl.Tests", "tests\Microsoft.Win32.Registry.AccessControl.Tests.csproj", "{BC8FAA75-A595-475E-B947-FA2D1E225B48}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{CD8304A8-4F14-45B7-B035-6D45D5ED3ECE}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{2973CC78-DC35-4305-BB7D-0F3698956832}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{9BCDE466-92C1-45ED-A9F1-6973D93DF5DF}" EndProject @@ -59,10 +59,10 @@ Global {BC8FAA75-A595-475E-B947-FA2D1E225B48}.Debug|Any CPU.Build.0 = Debug|Any CPU {BC8FAA75-A595-475E-B947-FA2D1E225B48}.Release|Any CPU.ActiveCfg = Release|Any CPU {BC8FAA75-A595-475E-B947-FA2D1E225B48}.Release|Any CPU.Build.0 = Release|Any CPU - {CD8304A8-4F14-45B7-B035-6D45D5ED3ECE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {CD8304A8-4F14-45B7-B035-6D45D5ED3ECE}.Debug|Any CPU.Build.0 = Debug|Any CPU - {CD8304A8-4F14-45B7-B035-6D45D5ED3ECE}.Release|Any CPU.ActiveCfg = Release|Any CPU - {CD8304A8-4F14-45B7-B035-6D45D5ED3ECE}.Release|Any CPU.Build.0 = Release|Any CPU + {2973CC78-DC35-4305-BB7D-0F3698956832}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {2973CC78-DC35-4305-BB7D-0F3698956832}.Debug|Any CPU.Build.0 = Debug|Any CPU + {2973CC78-DC35-4305-BB7D-0F3698956832}.Release|Any CPU.ActiveCfg = Release|Any CPU + {2973CC78-DC35-4305-BB7D-0F3698956832}.Release|Any CPU.Build.0 = Release|Any CPU {9BCDE466-92C1-45ED-A9F1-6973D93DF5DF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {9BCDE466-92C1-45ED-A9F1-6973D93DF5DF}.Debug|Any CPU.Build.0 = Debug|Any CPU {9BCDE466-92C1-45ED-A9F1-6973D93DF5DF}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -96,7 +96,7 @@ Global {BC8FAA75-A595-475E-B947-FA2D1E225B48} = {BF17487D-E9E3-4054-85A7-E64243B91780} {97F37414-7633-4B76-AFA4-284E26894FB4} = {84D58703-7569-445A-89B8-14D024FB6091} {9A0E9CD8-33FA-4E02-8EB6-5685CD84D727} = {29A3E154-E50B-49E7-96C3-32A91CAB9BA0} - {CD8304A8-4F14-45B7-B035-6D45D5ED3ECE} = {BEA56439-DD4D-4DF6-9F07-33670D77D7FD} + {2973CC78-DC35-4305-BB7D-0F3698956832} = {BEA56439-DD4D-4DF6-9F07-33670D77D7FD} {9BCDE466-92C1-45ED-A9F1-6973D93DF5DF} = {BEA56439-DD4D-4DF6-9F07-33670D77D7FD} {7AC324E3-BF40-4F3E-BA55-020DD43F69E6} = {902A660A-58FF-4672-8E24-AA4728DAD6D4} {27443A96-187A-4AD4-9239-DE4E84915559} = {902A660A-58FF-4672-8E24-AA4728DAD6D4} diff --git a/src/libraries/Microsoft.Win32.Registry/Microsoft.Win32.Registry.sln b/src/libraries/Microsoft.Win32.Registry/Microsoft.Win32.Registry.sln index 40042fdc73d..afa5ee0ed99 100644 --- a/src/libraries/Microsoft.Win32.Registry/Microsoft.Win32.Registry.sln +++ b/src/libraries/Microsoft.Win32.Registry/Microsoft.Win32.Registry.sln @@ -11,6 +11,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Collections.NonGener EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{5E90F801-5451-4E8A-8117-E86AB2A95F01}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{209890E0-A8FA-4D9B-AE15-7057142BAF2E}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{2FD3F0C9-DB36-4156-9A78-51B476636685}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{E8981301-50DC-4A1E-9BB0-537F9C5F2B8F}" @@ -79,6 +81,10 @@ Global {5E90F801-5451-4E8A-8117-E86AB2A95F01}.Debug|Any CPU.Build.0 = Debug|Any CPU {5E90F801-5451-4E8A-8117-E86AB2A95F01}.Release|Any CPU.ActiveCfg = Release|Any CPU {5E90F801-5451-4E8A-8117-E86AB2A95F01}.Release|Any CPU.Build.0 = Release|Any CPU + {209890E0-A8FA-4D9B-AE15-7057142BAF2E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {209890E0-A8FA-4D9B-AE15-7057142BAF2E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {209890E0-A8FA-4D9B-AE15-7057142BAF2E}.Release|Any CPU.ActiveCfg = Release|Any CPU + {209890E0-A8FA-4D9B-AE15-7057142BAF2E}.Release|Any CPU.Build.0 = Release|Any CPU {2FD3F0C9-DB36-4156-9A78-51B476636685}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {2FD3F0C9-DB36-4156-9A78-51B476636685}.Debug|Any CPU.Build.0 = Debug|Any CPU {2FD3F0C9-DB36-4156-9A78-51B476636685}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -138,6 +144,7 @@ Global {7AA650CB-13BD-4AC8-B570-E78A03DE97ED} = {DE8642D5-1264-473C-9896-35F348E89DBF} {3446E090-1587-4D16-AE6A-99C1788E86A6} = {66BCDB38-AFF7-4B7C-97F5-8869D5C2EDA9} {5E90F801-5451-4E8A-8117-E86AB2A95F01} = {DC4533A7-1325-497B-91FE-89765F77DFBF} + {209890E0-A8FA-4D9B-AE15-7057142BAF2E} = {DC4533A7-1325-497B-91FE-89765F77DFBF} {2FD3F0C9-DB36-4156-9A78-51B476636685} = {DC4533A7-1325-497B-91FE-89765F77DFBF} {E8981301-50DC-4A1E-9BB0-537F9C5F2B8F} = {DC4533A7-1325-497B-91FE-89765F77DFBF} {511763F8-9EA6-4997-BAF4-DC888D488659} = {762BA1D0-62D6-475D-91F2-C1CDE6654DCB} diff --git a/src/libraries/Microsoft.Win32.SystemEvents/Microsoft.Win32.SystemEvents.sln b/src/libraries/Microsoft.Win32.SystemEvents/Microsoft.Win32.SystemEvents.sln index 7cfb2daceab..f73c3713d22 100644 --- a/src/libraries/Microsoft.Win32.SystemEvents/Microsoft.Win32.SystemEvents.sln +++ b/src/libraries/Microsoft.Win32.SystemEvents/Microsoft.Win32.SystemEvents.sln @@ -7,7 +7,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Win32.SystemEvent EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Win32.SystemEvents.Tests", "tests\Microsoft.Win32.SystemEvents.Tests.csproj", "{86962B5A-AC38-44FA-B25B-74ABAC57E534}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{2D9943FB-EBD4-4994-BDCA-7C0087CD499B}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{4FAAE797-A6A9-46EB-A5F0-B8B8491FD3BF}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{1F21915D-D799-4AAA-9053-8BFFD5102FF1}" EndProject @@ -59,10 +59,10 @@ Global {86962B5A-AC38-44FA-B25B-74ABAC57E534}.Debug|Any CPU.Build.0 = Debug|Any CPU {86962B5A-AC38-44FA-B25B-74ABAC57E534}.Release|Any CPU.ActiveCfg = Release|Any CPU {86962B5A-AC38-44FA-B25B-74ABAC57E534}.Release|Any CPU.Build.0 = Release|Any CPU - {2D9943FB-EBD4-4994-BDCA-7C0087CD499B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {2D9943FB-EBD4-4994-BDCA-7C0087CD499B}.Debug|Any CPU.Build.0 = Debug|Any CPU - {2D9943FB-EBD4-4994-BDCA-7C0087CD499B}.Release|Any CPU.ActiveCfg = Release|Any CPU - {2D9943FB-EBD4-4994-BDCA-7C0087CD499B}.Release|Any CPU.Build.0 = Release|Any CPU + {4FAAE797-A6A9-46EB-A5F0-B8B8491FD3BF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {4FAAE797-A6A9-46EB-A5F0-B8B8491FD3BF}.Debug|Any CPU.Build.0 = Debug|Any CPU + {4FAAE797-A6A9-46EB-A5F0-B8B8491FD3BF}.Release|Any CPU.ActiveCfg = Release|Any CPU + {4FAAE797-A6A9-46EB-A5F0-B8B8491FD3BF}.Release|Any CPU.Build.0 = Release|Any CPU {1F21915D-D799-4AAA-9053-8BFFD5102FF1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {1F21915D-D799-4AAA-9053-8BFFD5102FF1}.Debug|Any CPU.Build.0 = Debug|Any CPU {1F21915D-D799-4AAA-9053-8BFFD5102FF1}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -96,7 +96,7 @@ Global {86962B5A-AC38-44FA-B25B-74ABAC57E534} = {F2A4093D-6291-4A9C-87FC-6B06D2324E38} {A586D099-E8B0-4C2F-B4AD-BCFA98429DBF} = {8BF90E54-BE73-4BBF-89CB-E9BE5DD1FC9E} {20C56707-2960-4DF2-BF76-5556304EE7CF} = {A9588D3E-04F0-4294-8D1A-84CF3D84804A} - {2D9943FB-EBD4-4994-BDCA-7C0087CD499B} = {B7447478-7C05-441D-BDDF-538008B24CBD} + {4FAAE797-A6A9-46EB-A5F0-B8B8491FD3BF} = {B7447478-7C05-441D-BDDF-538008B24CBD} {1F21915D-D799-4AAA-9053-8BFFD5102FF1} = {B7447478-7C05-441D-BDDF-538008B24CBD} {B1351B74-82F9-4CE6-AE68-25521A465AF4} = {8B8F314C-81E4-4624-B88D-DEF6F2F34C03} {FF36AE65-50BE-4C1D-8216-5038443D3BA4} = {8B8F314C-81E4-4624-B88D-DEF6F2F34C03} diff --git a/src/libraries/Microsoft.XmlSerializer.Generator/Microsoft.XmlSerializer.Generator.sln b/src/libraries/Microsoft.XmlSerializer.Generator/Microsoft.XmlSerializer.Generator.sln index 50e0e8ae8f1..37965b1d463 100644 --- a/src/libraries/Microsoft.XmlSerializer.Generator/Microsoft.XmlSerializer.Generator.sln +++ b/src/libraries/Microsoft.XmlSerializer.Generator/Microsoft.XmlSerializer.Generator.sln @@ -7,7 +7,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.XmlSerializer.Gen EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SerializableAssembly", "tests\SerializableAssembly.csproj", "{9D614FC7-0A88-4E85-B8A9-25FFFD71C47A}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{2307F11D-6FF4-45B0-9FA2-7B9807647E2B}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{75B963AC-07BE-4C63-9390-3E893897C60D}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{B1A05556-02FE-4BC0-89E4-4C6CC751675B}" EndProject @@ -57,10 +57,10 @@ Global {9D614FC7-0A88-4E85-B8A9-25FFFD71C47A}.Debug|Any CPU.Build.0 = Debug|Any CPU {9D614FC7-0A88-4E85-B8A9-25FFFD71C47A}.Release|Any CPU.ActiveCfg = Release|Any CPU {9D614FC7-0A88-4E85-B8A9-25FFFD71C47A}.Release|Any CPU.Build.0 = Release|Any CPU - {2307F11D-6FF4-45B0-9FA2-7B9807647E2B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {2307F11D-6FF4-45B0-9FA2-7B9807647E2B}.Debug|Any CPU.Build.0 = Debug|Any CPU - {2307F11D-6FF4-45B0-9FA2-7B9807647E2B}.Release|Any CPU.ActiveCfg = Release|Any CPU - {2307F11D-6FF4-45B0-9FA2-7B9807647E2B}.Release|Any CPU.Build.0 = Release|Any CPU + {75B963AC-07BE-4C63-9390-3E893897C60D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {75B963AC-07BE-4C63-9390-3E893897C60D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {75B963AC-07BE-4C63-9390-3E893897C60D}.Release|Any CPU.ActiveCfg = Release|Any CPU + {75B963AC-07BE-4C63-9390-3E893897C60D}.Release|Any CPU.Build.0 = Release|Any CPU {B1A05556-02FE-4BC0-89E4-4C6CC751675B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {B1A05556-02FE-4BC0-89E4-4C6CC751675B}.Debug|Any CPU.Build.0 = Debug|Any CPU {B1A05556-02FE-4BC0-89E4-4C6CC751675B}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -94,7 +94,7 @@ Global {A90B6063-66BB-486C-8267-43AC8F9C5196} = {BA160273-1658-4D63-8BB0-BEDDA0DAF20D} {9D614FC7-0A88-4E85-B8A9-25FFFD71C47A} = {BA160273-1658-4D63-8BB0-BEDDA0DAF20D} {3C8417AB-8E73-4EBF-B090-1367F3D23468} = {CC406051-3EEC-4E4F-8152-2F1BE15D61BA} - {2307F11D-6FF4-45B0-9FA2-7B9807647E2B} = {A3A8F98E-3524-4E5A-87C5-5324FD52E296} + {75B963AC-07BE-4C63-9390-3E893897C60D} = {A3A8F98E-3524-4E5A-87C5-5324FD52E296} {B1A05556-02FE-4BC0-89E4-4C6CC751675B} = {A3A8F98E-3524-4E5A-87C5-5324FD52E296} {B420E4A6-7A45-4FFA-B3AC-1A1A49D9C08F} = {99FE37B2-FBA7-4093-996F-702B154514C6} {0317802B-EEEA-4AFB-A8D2-B67A12EAD0C2} = {99FE37B2-FBA7-4093-996F-702B154514C6} diff --git a/src/libraries/Microsoft.XmlSerializer.Generator/tests/Expected.SerializableAssembly.XmlSerializers.cs b/src/libraries/Microsoft.XmlSerializer.Generator/tests/Expected.SerializableAssembly.XmlSerializers.cs index 593096b7a7a..1b0becc039e 100644 --- a/src/libraries/Microsoft.XmlSerializer.Generator/tests/Expected.SerializableAssembly.XmlSerializers.cs +++ b/src/libraries/Microsoft.XmlSerializer.Generator/tests/Expected.SerializableAssembly.XmlSerializers.cs @@ -6,7 +6,7 @@ namespace Microsoft.Xml.Serialization.GeneratedAssembly { public class XmlSerializationWriter1 : System.Xml.Serialization.XmlSerializationWriter { - public void Write107_TypeWithXmlElementProperty(object o) { + public void Write111_TypeWithXmlElementProperty(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithXmlElementProperty", @""); @@ -16,7 +16,7 @@ public void Write107_TypeWithXmlElementProperty(object o) { Write2_TypeWithXmlElementProperty(@"TypeWithXmlElementProperty", @"", ((global::TypeWithXmlElementProperty)o), true, false); } - public void Write108_TypeWithXmlDocumentProperty(object o) { + public void Write112_TypeWithXmlDocumentProperty(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithXmlDocumentProperty", @""); @@ -26,7 +26,7 @@ public void Write108_TypeWithXmlDocumentProperty(object o) { Write3_TypeWithXmlDocumentProperty(@"TypeWithXmlDocumentProperty", @"", ((global::TypeWithXmlDocumentProperty)o), true, false); } - public void Write109_TypeWithBinaryProperty(object o) { + public void Write113_TypeWithBinaryProperty(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithBinaryProperty", @""); @@ -36,7 +36,7 @@ public void Write109_TypeWithBinaryProperty(object o) { Write4_TypeWithBinaryProperty(@"TypeWithBinaryProperty", @"", ((global::TypeWithBinaryProperty)o), true, false); } - public void Write110_Item(object o) { + public void Write114_Item(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithDateTimeOffsetProperties", @""); @@ -46,7 +46,7 @@ public void Write110_Item(object o) { Write5_Item(@"TypeWithDateTimeOffsetProperties", @"", ((global::TypeWithDateTimeOffsetProperties)o), true, false); } - public void Write111_TypeWithTimeSpanProperty(object o) { + public void Write115_TypeWithTimeSpanProperty(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithTimeSpanProperty", @""); @@ -56,7 +56,7 @@ public void Write111_TypeWithTimeSpanProperty(object o) { Write6_TypeWithTimeSpanProperty(@"TypeWithTimeSpanProperty", @"", ((global::TypeWithTimeSpanProperty)o), true, false); } - public void Write112_Item(object o) { + public void Write116_Item(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithDefaultTimeSpanProperty", @""); @@ -66,7 +66,7 @@ public void Write112_Item(object o) { Write7_Item(@"TypeWithDefaultTimeSpanProperty", @"", ((global::TypeWithDefaultTimeSpanProperty)o), true, false); } - public void Write113_TypeWithByteProperty(object o) { + public void Write117_TypeWithByteProperty(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithByteProperty", @""); @@ -76,7 +76,7 @@ public void Write113_TypeWithByteProperty(object o) { Write8_TypeWithByteProperty(@"TypeWithByteProperty", @"", ((global::TypeWithByteProperty)o), true, false); } - public void Write114_TypeWithXmlNodeArrayProperty(object o) { + public void Write118_TypeWithXmlNodeArrayProperty(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithXmlNodeArrayProperty", @""); @@ -86,7 +86,7 @@ public void Write114_TypeWithXmlNodeArrayProperty(object o) { Write9_TypeWithXmlNodeArrayProperty(@"TypeWithXmlNodeArrayProperty", @"", ((global::TypeWithXmlNodeArrayProperty)o), true, false); } - public void Write115_Animal(object o) { + public void Write119_Animal(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"Animal", @""); @@ -96,7 +96,7 @@ public void Write115_Animal(object o) { Write10_Animal(@"Animal", @"", ((global::Animal)o), true, false); } - public void Write116_Dog(object o) { + public void Write120_Dog(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"Dog", @""); @@ -106,7 +106,7 @@ public void Write116_Dog(object o) { Write12_Dog(@"Dog", @"", ((global::Dog)o), true, false); } - public void Write117_DogBreed(object o) { + public void Write121_DogBreed(object o) { WriteStartDocument(); if (o == null) { WriteEmptyTag(@"DogBreed", @""); @@ -115,7 +115,7 @@ public void Write117_DogBreed(object o) { WriteElementString(@"DogBreed", @"", Write11_DogBreed(((global::DogBreed)o))); } - public void Write118_Group(object o) { + public void Write122_Group(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"Group", @""); @@ -125,7 +125,7 @@ public void Write118_Group(object o) { Write14_Group(@"Group", @"", ((global::Group)o), true, false); } - public void Write119_Vehicle(object o) { + public void Write123_Vehicle(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"Vehicle", @""); @@ -135,7 +135,7 @@ public void Write119_Vehicle(object o) { Write13_Vehicle(@"Vehicle", @"", ((global::Vehicle)o), true, false); } - public void Write120_Employee(object o) { + public void Write124_Employee(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"Employee", @""); @@ -145,7 +145,7 @@ public void Write120_Employee(object o) { Write15_Employee(@"Employee", @"", ((global::Employee)o), true, false); } - public void Write121_BaseClass(object o) { + public void Write125_BaseClass(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"BaseClass", @""); @@ -155,7 +155,7 @@ public void Write121_BaseClass(object o) { Write17_BaseClass(@"BaseClass", @"", ((global::BaseClass)o), true, false); } - public void Write122_DerivedClass(object o) { + public void Write126_DerivedClass(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"DerivedClass", @""); @@ -165,67 +165,107 @@ public void Write122_DerivedClass(object o) { Write16_DerivedClass(@"DerivedClass", @"", ((global::DerivedClass)o), true, false); } - public void Write123_PurchaseOrder(object o) { + public void Write127_SimpleBaseClass(object o) { + WriteStartDocument(); + if (o == null) { + WriteNullTagLiteral(@"SimpleBaseClass", @""); + return; + } + TopLevelElement(); + Write19_SimpleBaseClass(@"SimpleBaseClass", @"", ((global::SimpleBaseClass)o), true, false); + } + + public void Write128_SimpleDerivedClass(object o) { + WriteStartDocument(); + if (o == null) { + WriteNullTagLiteral(@"SimpleDerivedClass", @""); + return; + } + TopLevelElement(); + Write18_SimpleDerivedClass(@"SimpleDerivedClass", @"", ((global::SimpleDerivedClass)o), true, false); + } + + public void Write129_BaseIXmlSerializable(object o) { + WriteStartDocument(); + if (o == null) { + WriteNullTagLiteral(@"BaseIXmlSerializable", @"http://example.com/serializer-test-namespace"); + return; + } + TopLevelElement(); + WriteSerializable((System.Xml.Serialization.IXmlSerializable)((global::XmlSerializableBaseClass)o), @"BaseIXmlSerializable", @"http://example.com/serializer-test-namespace", true, true); + } + + public void Write130_DerivedIXmlSerializable(object o) { + WriteStartDocument(); + if (o == null) { + WriteNullTagLiteral(@"DerivedIXmlSerializable", @""); + return; + } + TopLevelElement(); + WriteSerializable((System.Xml.Serialization.IXmlSerializable)((global::XmlSerializableDerivedClass)o), @"DerivedIXmlSerializable", @"", true, true); + } + + public void Write131_PurchaseOrder(object o) { WriteStartDocument(); if (o == null) { WriteEmptyTag(@"PurchaseOrder", @"http://www.contoso1.com"); return; } TopLevelElement(); - Write20_PurchaseOrder(@"PurchaseOrder", @"http://www.contoso1.com", ((global::PurchaseOrder)o), false, false); + Write22_PurchaseOrder(@"PurchaseOrder", @"http://www.contoso1.com", ((global::PurchaseOrder)o), false, false); } - public void Write124_Address(object o) { + public void Write132_Address(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"Address", @""); return; } TopLevelElement(); - Write21_Address(@"Address", @"", ((global::Address)o), true, false); + Write23_Address(@"Address", @"", ((global::Address)o), true, false); } - public void Write125_OrderedItem(object o) { + public void Write133_OrderedItem(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"OrderedItem", @""); return; } TopLevelElement(); - Write22_OrderedItem(@"OrderedItem", @"", ((global::OrderedItem)o), true, false); + Write24_OrderedItem(@"OrderedItem", @"", ((global::OrderedItem)o), true, false); } - public void Write126_AliasedTestType(object o) { + public void Write134_AliasedTestType(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"AliasedTestType", @""); return; } TopLevelElement(); - Write23_AliasedTestType(@"AliasedTestType", @"", ((global::AliasedTestType)o), true, false); + Write25_AliasedTestType(@"AliasedTestType", @"", ((global::AliasedTestType)o), true, false); } - public void Write127_BaseClass1(object o) { + public void Write135_BaseClass1(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"BaseClass1", @""); return; } TopLevelElement(); - Write24_BaseClass1(@"BaseClass1", @"", ((global::BaseClass1)o), true, false); + Write26_BaseClass1(@"BaseClass1", @"", ((global::BaseClass1)o), true, false); } - public void Write128_DerivedClass1(object o) { + public void Write136_DerivedClass1(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"DerivedClass1", @""); return; } TopLevelElement(); - Write25_DerivedClass1(@"DerivedClass1", @"", ((global::DerivedClass1)o), true, false); + Write27_DerivedClass1(@"DerivedClass1", @"", ((global::DerivedClass1)o), true, false); } - public void Write129_ArrayOfDateTime(object o) { + public void Write137_ArrayOfDateTime(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"ArrayOfDateTime", @""); @@ -250,235 +290,235 @@ public void Write129_ArrayOfDateTime(object o) { } } - public void Write130_Orchestra(object o) { + public void Write138_Orchestra(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"Orchestra", @""); return; } TopLevelElement(); - Write27_Orchestra(@"Orchestra", @"", ((global::Orchestra)o), true, false); + Write29_Orchestra(@"Orchestra", @"", ((global::Orchestra)o), true, false); } - public void Write131_Instrument(object o) { + public void Write139_Instrument(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"Instrument", @""); return; } TopLevelElement(); - Write26_Instrument(@"Instrument", @"", ((global::Instrument)o), true, false); + Write28_Instrument(@"Instrument", @"", ((global::Instrument)o), true, false); } - public void Write132_Brass(object o) { + public void Write140_Brass(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"Brass", @""); return; } TopLevelElement(); - Write28_Brass(@"Brass", @"", ((global::Brass)o), true, false); + Write30_Brass(@"Brass", @"", ((global::Brass)o), true, false); } - public void Write133_Trumpet(object o) { + public void Write141_Trumpet(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"Trumpet", @""); return; } TopLevelElement(); - Write29_Trumpet(@"Trumpet", @"", ((global::Trumpet)o), true, false); + Write31_Trumpet(@"Trumpet", @"", ((global::Trumpet)o), true, false); } - public void Write134_Pet(object o) { + public void Write142_Pet(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"Pet", @""); return; } TopLevelElement(); - Write30_Pet(@"Pet", @"", ((global::Pet)o), true, false); + Write32_Pet(@"Pet", @"", ((global::Pet)o), true, false); } - public void Write135_DefaultValuesSetToNaN(object o) { + public void Write143_DefaultValuesSetToNaN(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"DefaultValuesSetToNaN", @""); return; } TopLevelElement(); - Write31_DefaultValuesSetToNaN(@"DefaultValuesSetToNaN", @"", ((global::DefaultValuesSetToNaN)o), true, false); + Write33_DefaultValuesSetToNaN(@"DefaultValuesSetToNaN", @"", ((global::DefaultValuesSetToNaN)o), true, false); } - public void Write136_Item(object o) { + public void Write144_Item(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"DefaultValuesSetToPositiveInfinity", @""); return; } TopLevelElement(); - Write32_Item(@"DefaultValuesSetToPositiveInfinity", @"", ((global::DefaultValuesSetToPositiveInfinity)o), true, false); + Write34_Item(@"DefaultValuesSetToPositiveInfinity", @"", ((global::DefaultValuesSetToPositiveInfinity)o), true, false); } - public void Write137_Item(object o) { + public void Write145_Item(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"DefaultValuesSetToNegativeInfinity", @""); return; } TopLevelElement(); - Write33_Item(@"DefaultValuesSetToNegativeInfinity", @"", ((global::DefaultValuesSetToNegativeInfinity)o), true, false); + Write35_Item(@"DefaultValuesSetToNegativeInfinity", @"", ((global::DefaultValuesSetToNegativeInfinity)o), true, false); } - public void Write138_RootElement(object o) { + public void Write146_RootElement(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"RootElement", @""); return; } TopLevelElement(); - Write34_Item(@"RootElement", @"", ((global::TypeWithMismatchBetweenAttributeAndPropertyType)o), true, false); + Write36_Item(@"RootElement", @"", ((global::TypeWithMismatchBetweenAttributeAndPropertyType)o), true, false); } - public void Write139_TypeWithLinkedProperty(object o) { + public void Write147_TypeWithLinkedProperty(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithLinkedProperty", @""); return; } TopLevelElement(); - Write35_TypeWithLinkedProperty(@"TypeWithLinkedProperty", @"", ((global::TypeWithLinkedProperty)o), true, false); + Write37_TypeWithLinkedProperty(@"TypeWithLinkedProperty", @"", ((global::TypeWithLinkedProperty)o), true, false); } - public void Write140_Document(object o) { + public void Write148_Document(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"Document", @"http://example.com"); return; } TopLevelElement(); - Write36_MsgDocumentType(@"Document", @"http://example.com", ((global::MsgDocumentType)o), true, false); + Write38_MsgDocumentType(@"Document", @"http://example.com", ((global::MsgDocumentType)o), true, false); } - public void Write141_RootClass(object o) { + public void Write149_RootClass(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"RootClass", @""); return; } TopLevelElement(); - Write39_RootClass(@"RootClass", @"", ((global::RootClass)o), true, false); + Write41_RootClass(@"RootClass", @"", ((global::RootClass)o), true, false); } - public void Write142_Parameter(object o) { + public void Write150_Parameter(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"Parameter", @""); return; } TopLevelElement(); - Write38_Parameter(@"Parameter", @"", ((global::Parameter)o), true, false); + Write40_Parameter(@"Parameter", @"", ((global::Parameter)o), true, false); } - public void Write143_XElementWrapper(object o) { + public void Write151_XElementWrapper(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"XElementWrapper", @""); return; } TopLevelElement(); - Write40_XElementWrapper(@"XElementWrapper", @"", ((global::XElementWrapper)o), true, false); + Write42_XElementWrapper(@"XElementWrapper", @"", ((global::XElementWrapper)o), true, false); } - public void Write144_XElementStruct(object o) { + public void Write152_XElementStruct(object o) { WriteStartDocument(); if (o == null) { WriteEmptyTag(@"XElementStruct", @""); return; } - Write41_XElementStruct(@"XElementStruct", @"", ((global::XElementStruct)o), false); + Write43_XElementStruct(@"XElementStruct", @"", ((global::XElementStruct)o), false); } - public void Write145_XElementArrayWrapper(object o) { + public void Write153_XElementArrayWrapper(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"XElementArrayWrapper", @""); return; } TopLevelElement(); - Write42_XElementArrayWrapper(@"XElementArrayWrapper", @"", ((global::XElementArrayWrapper)o), true, false); + Write44_XElementArrayWrapper(@"XElementArrayWrapper", @"", ((global::XElementArrayWrapper)o), true, false); } - public void Write146_TypeWithDateTimeStringProperty(object o) { + public void Write154_TypeWithDateTimeStringProperty(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithDateTimeStringProperty", @""); return; } TopLevelElement(); - Write43_TypeWithDateTimeStringProperty(@"TypeWithDateTimeStringProperty", @"", ((global::SerializationTypes.TypeWithDateTimeStringProperty)o), true, false); + Write45_TypeWithDateTimeStringProperty(@"TypeWithDateTimeStringProperty", @"", ((global::SerializationTypes.TypeWithDateTimeStringProperty)o), true, false); } - public void Write147_SimpleType(object o) { + public void Write155_SimpleType(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"SimpleType", @""); return; } TopLevelElement(); - Write44_SimpleType(@"SimpleType", @"", ((global::SerializationTypes.SimpleType)o), true, false); + Write46_SimpleType(@"SimpleType", @"", ((global::SerializationTypes.SimpleType)o), true, false); } - public void Write148_TypeWithGetSetArrayMembers(object o) { + public void Write156_TypeWithGetSetArrayMembers(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithGetSetArrayMembers", @""); return; } TopLevelElement(); - Write45_TypeWithGetSetArrayMembers(@"TypeWithGetSetArrayMembers", @"", ((global::SerializationTypes.TypeWithGetSetArrayMembers)o), true, false); + Write47_TypeWithGetSetArrayMembers(@"TypeWithGetSetArrayMembers", @"", ((global::SerializationTypes.TypeWithGetSetArrayMembers)o), true, false); } - public void Write149_TypeWithGetOnlyArrayProperties(object o) { + public void Write157_TypeWithGetOnlyArrayProperties(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithGetOnlyArrayProperties", @""); return; } TopLevelElement(); - Write46_TypeWithGetOnlyArrayProperties(@"TypeWithGetOnlyArrayProperties", @"", ((global::SerializationTypes.TypeWithGetOnlyArrayProperties)o), true, false); + Write48_TypeWithGetOnlyArrayProperties(@"TypeWithGetOnlyArrayProperties", @"", ((global::SerializationTypes.TypeWithGetOnlyArrayProperties)o), true, false); } - public void Write150_StructNotSerializable(object o) { + public void Write158_StructNotSerializable(object o) { WriteStartDocument(); if (o == null) { WriteEmptyTag(@"StructNotSerializable", @""); return; } - Write47_StructNotSerializable(@"StructNotSerializable", @"", ((global::SerializationTypes.StructNotSerializable)o), false); + Write49_StructNotSerializable(@"StructNotSerializable", @"", ((global::SerializationTypes.StructNotSerializable)o), false); } - public void Write151_TypeWithMyCollectionField(object o) { + public void Write159_TypeWithMyCollectionField(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithMyCollectionField", @""); return; } TopLevelElement(); - Write48_TypeWithMyCollectionField(@"TypeWithMyCollectionField", @"", ((global::SerializationTypes.TypeWithMyCollectionField)o), true, false); + Write50_TypeWithMyCollectionField(@"TypeWithMyCollectionField", @"", ((global::SerializationTypes.TypeWithMyCollectionField)o), true, false); } - public void Write152_Item(object o) { + public void Write160_Item(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithReadOnlyMyCollectionProperty", @""); return; } TopLevelElement(); - Write49_Item(@"TypeWithReadOnlyMyCollectionProperty", @"", ((global::SerializationTypes.TypeWithReadOnlyMyCollectionProperty)o), true, false); + Write51_Item(@"TypeWithReadOnlyMyCollectionProperty", @"", ((global::SerializationTypes.TypeWithReadOnlyMyCollectionProperty)o), true, false); } - public void Write153_ArrayOfAnyType(object o) { + public void Write161_ArrayOfAnyType(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"ArrayOfAnyType", @""); @@ -500,574 +540,609 @@ public void Write153_ArrayOfAnyType(object o) { } } - public void Write154_MyEnum(object o) { + public void Write162_MyEnum(object o) { WriteStartDocument(); if (o == null) { WriteEmptyTag(@"MyEnum", @""); return; } - WriteElementString(@"MyEnum", @"", Write50_MyEnum(((global::SerializationTypes.MyEnum)o))); + WriteElementString(@"MyEnum", @"", Write52_MyEnum(((global::SerializationTypes.MyEnum)o))); } - public void Write155_TypeWithEnumMembers(object o) { + public void Write163_TypeWithEnumMembers(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithEnumMembers", @""); return; } TopLevelElement(); - Write51_TypeWithEnumMembers(@"TypeWithEnumMembers", @"", ((global::SerializationTypes.TypeWithEnumMembers)o), true, false); + Write53_TypeWithEnumMembers(@"TypeWithEnumMembers", @"", ((global::SerializationTypes.TypeWithEnumMembers)o), true, false); } - public void Write156_DCStruct(object o) { + public void Write164_DCStruct(object o) { WriteStartDocument(); if (o == null) { WriteEmptyTag(@"DCStruct", @""); return; } - Write52_DCStruct(@"DCStruct", @"", ((global::SerializationTypes.DCStruct)o), false); + Write54_DCStruct(@"DCStruct", @"", ((global::SerializationTypes.DCStruct)o), false); } - public void Write157_DCClassWithEnumAndStruct(object o) { + public void Write165_DCClassWithEnumAndStruct(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"DCClassWithEnumAndStruct", @""); return; } TopLevelElement(); - Write53_DCClassWithEnumAndStruct(@"DCClassWithEnumAndStruct", @"", ((global::SerializationTypes.DCClassWithEnumAndStruct)o), true, false); + Write55_DCClassWithEnumAndStruct(@"DCClassWithEnumAndStruct", @"", ((global::SerializationTypes.DCClassWithEnumAndStruct)o), true, false); } - public void Write158_BuiltInTypes(object o) { + public void Write166_BuiltInTypes(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"BuiltInTypes", @""); return; } TopLevelElement(); - Write54_BuiltInTypes(@"BuiltInTypes", @"", ((global::SerializationTypes.BuiltInTypes)o), true, false); + Write56_BuiltInTypes(@"BuiltInTypes", @"", ((global::SerializationTypes.BuiltInTypes)o), true, false); } - public void Write159_TypeA(object o) { + public void Write167_TypeA(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeA", @""); return; } TopLevelElement(); - Write55_TypeA(@"TypeA", @"", ((global::SerializationTypes.TypeA)o), true, false); + Write57_TypeA(@"TypeA", @"", ((global::SerializationTypes.TypeA)o), true, false); } - public void Write160_TypeB(object o) { + public void Write168_TypeB(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeB", @""); return; } TopLevelElement(); - Write56_TypeB(@"TypeB", @"", ((global::SerializationTypes.TypeB)o), true, false); + Write58_TypeB(@"TypeB", @"", ((global::SerializationTypes.TypeB)o), true, false); } - public void Write161_TypeHasArrayOfASerializedAsB(object o) { + public void Write169_TypeHasArrayOfASerializedAsB(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeHasArrayOfASerializedAsB", @""); return; } TopLevelElement(); - Write57_TypeHasArrayOfASerializedAsB(@"TypeHasArrayOfASerializedAsB", @"", ((global::SerializationTypes.TypeHasArrayOfASerializedAsB)o), true, false); + Write59_TypeHasArrayOfASerializedAsB(@"TypeHasArrayOfASerializedAsB", @"", ((global::SerializationTypes.TypeHasArrayOfASerializedAsB)o), true, false); } - public void Write162_Item(object o) { + public void Write170_Item(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"__TypeNameWithSpecialCharacters漢ñ", @""); return; } TopLevelElement(); - Write58_Item(@"__TypeNameWithSpecialCharacters漢ñ", @"", ((global::SerializationTypes.@__TypeNameWithSpecialCharacters漢ñ)o), true, false); + Write60_Item(@"__TypeNameWithSpecialCharacters漢ñ", @"", ((global::SerializationTypes.@__TypeNameWithSpecialCharacters漢ñ)o), true, false); } - public void Write163_BaseClassWithSamePropertyName(object o) { + public void Write171_BaseClassWithSamePropertyName(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"BaseClassWithSamePropertyName", @""); return; } TopLevelElement(); - Write59_BaseClassWithSamePropertyName(@"BaseClassWithSamePropertyName", @"", ((global::SerializationTypes.BaseClassWithSamePropertyName)o), true, false); + Write61_BaseClassWithSamePropertyName(@"BaseClassWithSamePropertyName", @"", ((global::SerializationTypes.BaseClassWithSamePropertyName)o), true, false); } - public void Write164_DerivedClassWithSameProperty(object o) { + public void Write172_DerivedClassWithSameProperty(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"DerivedClassWithSameProperty", @""); return; } TopLevelElement(); - Write60_DerivedClassWithSameProperty(@"DerivedClassWithSameProperty", @"", ((global::SerializationTypes.DerivedClassWithSameProperty)o), true, false); + Write62_DerivedClassWithSameProperty(@"DerivedClassWithSameProperty", @"", ((global::SerializationTypes.DerivedClassWithSameProperty)o), true, false); } - public void Write165_DerivedClassWithSameProperty2(object o) { + public void Write173_DerivedClassWithSameProperty2(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"DerivedClassWithSameProperty2", @""); return; } TopLevelElement(); - Write61_DerivedClassWithSameProperty2(@"DerivedClassWithSameProperty2", @"", ((global::SerializationTypes.DerivedClassWithSameProperty2)o), true, false); + Write63_DerivedClassWithSameProperty2(@"DerivedClassWithSameProperty2", @"", ((global::SerializationTypes.DerivedClassWithSameProperty2)o), true, false); } - public void Write166_Item(object o) { + public void Write174_Item(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithDateTimePropertyAsXmlTime", @""); return; } TopLevelElement(); - Write62_Item(@"TypeWithDateTimePropertyAsXmlTime", @"", ((global::SerializationTypes.TypeWithDateTimePropertyAsXmlTime)o), true, false); + Write64_Item(@"TypeWithDateTimePropertyAsXmlTime", @"", ((global::SerializationTypes.TypeWithDateTimePropertyAsXmlTime)o), true, false); } - public void Write167_TypeWithByteArrayAsXmlText(object o) { + public void Write175_TypeWithByteArrayAsXmlText(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithByteArrayAsXmlText", @""); return; } TopLevelElement(); - Write63_TypeWithByteArrayAsXmlText(@"TypeWithByteArrayAsXmlText", @"", ((global::SerializationTypes.TypeWithByteArrayAsXmlText)o), true, false); + Write65_TypeWithByteArrayAsXmlText(@"TypeWithByteArrayAsXmlText", @"", ((global::SerializationTypes.TypeWithByteArrayAsXmlText)o), true, false); } - public void Write168_SimpleDC(object o) { + public void Write176_SimpleDC(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"SimpleDC", @""); return; } TopLevelElement(); - Write64_SimpleDC(@"SimpleDC", @"", ((global::SerializationTypes.SimpleDC)o), true, false); + Write66_SimpleDC(@"SimpleDC", @"", ((global::SerializationTypes.SimpleDC)o), true, false); } - public void Write169_Item(object o) { + public void Write177_Item(object o) { WriteStartDocument(); if (o == null) { WriteEmptyTag(@"TypeWithXmlTextAttributeOnArray", @"http://schemas.xmlsoap.org/ws/2005/04/discovery"); return; } TopLevelElement(); - Write65_Item(@"TypeWithXmlTextAttributeOnArray", @"http://schemas.xmlsoap.org/ws/2005/04/discovery", ((global::SerializationTypes.TypeWithXmlTextAttributeOnArray)o), false, false); + Write67_Item(@"TypeWithXmlTextAttributeOnArray", @"http://schemas.xmlsoap.org/ws/2005/04/discovery", ((global::SerializationTypes.TypeWithXmlTextAttributeOnArray)o), false, false); } - public void Write170_EnumFlags(object o) { + public void Write178_EnumFlags(object o) { WriteStartDocument(); if (o == null) { WriteEmptyTag(@"EnumFlags", @""); return; } - WriteElementString(@"EnumFlags", @"", Write66_EnumFlags(((global::SerializationTypes.EnumFlags)o))); + WriteElementString(@"EnumFlags", @"", Write68_EnumFlags(((global::SerializationTypes.EnumFlags)o))); } - public void Write171_ClassImplementsInterface(object o) { + public void Write179_ClassImplementsInterface(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"ClassImplementsInterface", @""); return; } TopLevelElement(); - Write67_ClassImplementsInterface(@"ClassImplementsInterface", @"", ((global::SerializationTypes.ClassImplementsInterface)o), true, false); + Write69_ClassImplementsInterface(@"ClassImplementsInterface", @"", ((global::SerializationTypes.ClassImplementsInterface)o), true, false); } - public void Write172_WithStruct(object o) { + public void Write180_WithStruct(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"WithStruct", @""); return; } TopLevelElement(); - Write69_WithStruct(@"WithStruct", @"", ((global::SerializationTypes.WithStruct)o), true, false); + Write71_WithStruct(@"WithStruct", @"", ((global::SerializationTypes.WithStruct)o), true, false); } - public void Write173_SomeStruct(object o) { + public void Write181_SomeStruct(object o) { WriteStartDocument(); if (o == null) { WriteEmptyTag(@"SomeStruct", @""); return; } - Write68_SomeStruct(@"SomeStruct", @"", ((global::SerializationTypes.SomeStruct)o), false); + Write70_SomeStruct(@"SomeStruct", @"", ((global::SerializationTypes.SomeStruct)o), false); } - public void Write174_WithEnums(object o) { + public void Write182_WithEnums(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"WithEnums", @""); return; } TopLevelElement(); - Write72_WithEnums(@"WithEnums", @"", ((global::SerializationTypes.WithEnums)o), true, false); + Write74_WithEnums(@"WithEnums", @"", ((global::SerializationTypes.WithEnums)o), true, false); } - public void Write175_WithNullables(object o) { + public void Write183_WithNullables(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"WithNullables", @""); return; } TopLevelElement(); - Write73_WithNullables(@"WithNullables", @"", ((global::SerializationTypes.WithNullables)o), true, false); + Write75_WithNullables(@"WithNullables", @"", ((global::SerializationTypes.WithNullables)o), true, false); } - public void Write176_ByteEnum(object o) { + public void Write184_ByteEnum(object o) { WriteStartDocument(); if (o == null) { WriteEmptyTag(@"ByteEnum", @""); return; } - WriteElementString(@"ByteEnum", @"", Write74_ByteEnum(((global::SerializationTypes.ByteEnum)o))); + WriteElementString(@"ByteEnum", @"", Write76_ByteEnum(((global::SerializationTypes.ByteEnum)o))); } - public void Write177_SByteEnum(object o) { + public void Write185_SByteEnum(object o) { WriteStartDocument(); if (o == null) { WriteEmptyTag(@"SByteEnum", @""); return; } - WriteElementString(@"SByteEnum", @"", Write75_SByteEnum(((global::SerializationTypes.SByteEnum)o))); + WriteElementString(@"SByteEnum", @"", Write77_SByteEnum(((global::SerializationTypes.SByteEnum)o))); } - public void Write178_ShortEnum(object o) { + public void Write186_ShortEnum(object o) { WriteStartDocument(); if (o == null) { WriteEmptyTag(@"ShortEnum", @""); return; } - WriteElementString(@"ShortEnum", @"", Write71_ShortEnum(((global::SerializationTypes.ShortEnum)o))); + WriteElementString(@"ShortEnum", @"", Write73_ShortEnum(((global::SerializationTypes.ShortEnum)o))); } - public void Write179_IntEnum(object o) { + public void Write187_IntEnum(object o) { WriteStartDocument(); if (o == null) { WriteEmptyTag(@"IntEnum", @""); return; } - WriteElementString(@"IntEnum", @"", Write70_IntEnum(((global::SerializationTypes.IntEnum)o))); + WriteElementString(@"IntEnum", @"", Write72_IntEnum(((global::SerializationTypes.IntEnum)o))); } - public void Write180_UIntEnum(object o) { + public void Write188_UIntEnum(object o) { WriteStartDocument(); if (o == null) { WriteEmptyTag(@"UIntEnum", @""); return; } - WriteElementString(@"UIntEnum", @"", Write76_UIntEnum(((global::SerializationTypes.UIntEnum)o))); + WriteElementString(@"UIntEnum", @"", Write78_UIntEnum(((global::SerializationTypes.UIntEnum)o))); } - public void Write181_LongEnum(object o) { + public void Write189_LongEnum(object o) { WriteStartDocument(); if (o == null) { WriteEmptyTag(@"LongEnum", @""); return; } - WriteElementString(@"LongEnum", @"", Write77_LongEnum(((global::SerializationTypes.LongEnum)o))); + WriteElementString(@"LongEnum", @"", Write79_LongEnum(((global::SerializationTypes.LongEnum)o))); } - public void Write182_ULongEnum(object o) { + public void Write190_ULongEnum(object o) { WriteStartDocument(); if (o == null) { WriteEmptyTag(@"ULongEnum", @""); return; } - WriteElementString(@"ULongEnum", @"", Write78_ULongEnum(((global::SerializationTypes.ULongEnum)o))); + WriteElementString(@"ULongEnum", @"", Write80_ULongEnum(((global::SerializationTypes.ULongEnum)o))); } - public void Write183_AttributeTesting(object o) { + public void Write191_AttributeTesting(object o) { WriteStartDocument(); if (o == null) { WriteEmptyTag(@"AttributeTesting", @""); return; } TopLevelElement(); - Write80_XmlSerializerAttributes(@"AttributeTesting", @"", ((global::SerializationTypes.XmlSerializerAttributes)o), false, false); + Write82_XmlSerializerAttributes(@"AttributeTesting", @"", ((global::SerializationTypes.XmlSerializerAttributes)o), false, false); } - public void Write184_ItemChoiceType(object o) { + public void Write192_ItemChoiceType(object o) { WriteStartDocument(); if (o == null) { WriteEmptyTag(@"ItemChoiceType", @""); return; } - WriteElementString(@"ItemChoiceType", @"", Write79_ItemChoiceType(((global::SerializationTypes.ItemChoiceType)o))); + WriteElementString(@"ItemChoiceType", @"", Write81_ItemChoiceType(((global::SerializationTypes.ItemChoiceType)o))); } - public void Write185_TypeWithAnyAttribute(object o) { + public void Write193_TypeWithAnyAttribute(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithAnyAttribute", @""); return; } TopLevelElement(); - Write81_TypeWithAnyAttribute(@"TypeWithAnyAttribute", @"", ((global::SerializationTypes.TypeWithAnyAttribute)o), true, false); + Write83_TypeWithAnyAttribute(@"TypeWithAnyAttribute", @"", ((global::SerializationTypes.TypeWithAnyAttribute)o), true, false); } - public void Write186_KnownTypesThroughConstructor(object o) { + public void Write194_KnownTypesThroughConstructor(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"KnownTypesThroughConstructor", @""); return; } TopLevelElement(); - Write82_KnownTypesThroughConstructor(@"KnownTypesThroughConstructor", @"", ((global::SerializationTypes.KnownTypesThroughConstructor)o), true, false); + Write84_KnownTypesThroughConstructor(@"KnownTypesThroughConstructor", @"", ((global::SerializationTypes.KnownTypesThroughConstructor)o), true, false); } - public void Write187_SimpleKnownTypeValue(object o) { + public void Write195_SimpleKnownTypeValue(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"SimpleKnownTypeValue", @""); return; } TopLevelElement(); - Write83_SimpleKnownTypeValue(@"SimpleKnownTypeValue", @"", ((global::SerializationTypes.SimpleKnownTypeValue)o), true, false); + Write85_SimpleKnownTypeValue(@"SimpleKnownTypeValue", @"", ((global::SerializationTypes.SimpleKnownTypeValue)o), true, false); } - public void Write188_Item(object o) { + public void Write196_Item(object o) { WriteStartDocument(); if (o == null) { - WriteNullTagLiteral(@"ClassImplementingIXmlSerialiable", @""); + WriteNullTagLiteral(@"ClassImplementingIXmlSerializable", @""); return; } TopLevelElement(); - WriteSerializable((System.Xml.Serialization.IXmlSerializable)((global::SerializationTypes.ClassImplementingIXmlSerialiable)o), @"ClassImplementingIXmlSerialiable", @"", true, true); + WriteSerializable((System.Xml.Serialization.IXmlSerializable)((global::SerializationTypes.ClassImplementingIXmlSerializable)o), @"ClassImplementingIXmlSerializable", @"", true, true); } - public void Write189_TypeWithPropertyNameSpecified(object o) { + public void Write197_TypeWithPropertyNameSpecified(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithPropertyNameSpecified", @""); return; } TopLevelElement(); - Write84_TypeWithPropertyNameSpecified(@"TypeWithPropertyNameSpecified", @"", ((global::SerializationTypes.TypeWithPropertyNameSpecified)o), true, false); + Write86_TypeWithPropertyNameSpecified(@"TypeWithPropertyNameSpecified", @"", ((global::SerializationTypes.TypeWithPropertyNameSpecified)o), true, false); } - public void Write190_TypeWithXmlSchemaFormAttribute(object o) { + public void Write198_TypeWithXmlSchemaFormAttribute(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithXmlSchemaFormAttribute", @""); return; } TopLevelElement(); - Write85_TypeWithXmlSchemaFormAttribute(@"TypeWithXmlSchemaFormAttribute", @"", ((global::SerializationTypes.TypeWithXmlSchemaFormAttribute)o), true, false); + Write87_TypeWithXmlSchemaFormAttribute(@"TypeWithXmlSchemaFormAttribute", @"", ((global::SerializationTypes.TypeWithXmlSchemaFormAttribute)o), true, false); } - public void Write191_MyXmlType(object o) { + public void Write199_MyXmlType(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"MyXmlType", @""); return; } TopLevelElement(); - Write86_Item(@"MyXmlType", @"", ((global::SerializationTypes.TypeWithTypeNameInXmlTypeAttribute)o), true, false); + Write88_Item(@"MyXmlType", @"", ((global::SerializationTypes.TypeWithTypeNameInXmlTypeAttribute)o), true, false); } - public void Write192_Item(object o) { + public void Write200_Item(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithSchemaFormInXmlAttribute", @""); return; } TopLevelElement(); - Write87_Item(@"TypeWithSchemaFormInXmlAttribute", @"", ((global::SerializationTypes.TypeWithSchemaFormInXmlAttribute)o), true, false); + Write89_Item(@"TypeWithSchemaFormInXmlAttribute", @"", ((global::SerializationTypes.TypeWithSchemaFormInXmlAttribute)o), true, false); + } + + public void Write201_CustomDocument(object o) { + WriteStartDocument(); + if (o == null) { + WriteNullTagLiteral(@"CustomDocument", @""); + return; + } + TopLevelElement(); + Write91_CustomDocument(@"CustomDocument", @"", ((global::SerializationTypes.CustomDocument)o), true, false); + } + + public void Write202_CustomElement(object o) { + WriteStartDocument(); + if (o == null) { + WriteNullTagLiteral(@"CustomElement", @""); + return; + } + TopLevelElement(); + Write90_CustomElement(@"CustomElement", @"", ((global::SerializationTypes.CustomElement)o), true, false); + } + + public void Write203_Item(object o) { + WriteStartDocument(); + if (o == null) { + WriteNullTagLiteral(@"", null); + return; + } + TopLevelElement(); + if ((o) is System.Xml.XmlNode || o == null) { + WriteElementLiteral((System.Xml.XmlNode)o, @"", null, true, true); + } + else { + throw CreateInvalidAnyTypeException(o); + } } - public void Write193_Item(object o) { + public void Write204_Item(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithNonPublicDefaultConstructor", @""); return; } TopLevelElement(); - Write88_Item(@"TypeWithNonPublicDefaultConstructor", @"", ((global::SerializationTypes.TypeWithNonPublicDefaultConstructor)o), true, false); + Write92_Item(@"TypeWithNonPublicDefaultConstructor", @"", ((global::SerializationTypes.TypeWithNonPublicDefaultConstructor)o), true, false); } - public void Write194_ServerSettings(object o) { + public void Write205_ServerSettings(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"ServerSettings", @""); return; } TopLevelElement(); - Write89_ServerSettings(@"ServerSettings", @"", ((global::SerializationTypes.ServerSettings)o), true, false); + Write93_ServerSettings(@"ServerSettings", @"", ((global::SerializationTypes.ServerSettings)o), true, false); } - public void Write195_TypeWithXmlQualifiedName(object o) { + public void Write206_TypeWithXmlQualifiedName(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithXmlQualifiedName", @""); return; } TopLevelElement(); - Write90_TypeWithXmlQualifiedName(@"TypeWithXmlQualifiedName", @"", ((global::SerializationTypes.TypeWithXmlQualifiedName)o), true, false); + Write94_TypeWithXmlQualifiedName(@"TypeWithXmlQualifiedName", @"", ((global::SerializationTypes.TypeWithXmlQualifiedName)o), true, false); } - public void Write196_TypeWith2DArrayProperty2(object o) { + public void Write207_TypeWith2DArrayProperty2(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWith2DArrayProperty2", @""); return; } TopLevelElement(); - Write91_TypeWith2DArrayProperty2(@"TypeWith2DArrayProperty2", @"", ((global::SerializationTypes.TypeWith2DArrayProperty2)o), true, false); + Write95_TypeWith2DArrayProperty2(@"TypeWith2DArrayProperty2", @"", ((global::SerializationTypes.TypeWith2DArrayProperty2)o), true, false); } - public void Write197_Item(object o) { + public void Write208_Item(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithPropertiesHavingDefaultValue", @""); return; } TopLevelElement(); - Write92_Item(@"TypeWithPropertiesHavingDefaultValue", @"", ((global::SerializationTypes.TypeWithPropertiesHavingDefaultValue)o), true, false); + Write96_Item(@"TypeWithPropertiesHavingDefaultValue", @"", ((global::SerializationTypes.TypeWithPropertiesHavingDefaultValue)o), true, false); } - public void Write198_Item(object o) { + public void Write209_Item(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithEnumPropertyHavingDefaultValue", @""); return; } TopLevelElement(); - Write93_Item(@"TypeWithEnumPropertyHavingDefaultValue", @"", ((global::SerializationTypes.TypeWithEnumPropertyHavingDefaultValue)o), true, false); + Write97_Item(@"TypeWithEnumPropertyHavingDefaultValue", @"", ((global::SerializationTypes.TypeWithEnumPropertyHavingDefaultValue)o), true, false); } - public void Write199_Item(object o) { + public void Write210_Item(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithEnumFlagPropertyHavingDefaultValue", @""); return; } TopLevelElement(); - Write94_Item(@"TypeWithEnumFlagPropertyHavingDefaultValue", @"", ((global::SerializationTypes.TypeWithEnumFlagPropertyHavingDefaultValue)o), true, false); + Write98_Item(@"TypeWithEnumFlagPropertyHavingDefaultValue", @"", ((global::SerializationTypes.TypeWithEnumFlagPropertyHavingDefaultValue)o), true, false); } - public void Write200_TypeWithShouldSerializeMethod(object o) { + public void Write211_TypeWithShouldSerializeMethod(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithShouldSerializeMethod", @""); return; } TopLevelElement(); - Write95_TypeWithShouldSerializeMethod(@"TypeWithShouldSerializeMethod", @"", ((global::SerializationTypes.TypeWithShouldSerializeMethod)o), true, false); + Write99_TypeWithShouldSerializeMethod(@"TypeWithShouldSerializeMethod", @"", ((global::SerializationTypes.TypeWithShouldSerializeMethod)o), true, false); } - public void Write201_Item(object o) { + public void Write212_Item(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"KnownTypesThroughConstructorWithArrayProperties", @""); return; } TopLevelElement(); - Write96_Item(@"KnownTypesThroughConstructorWithArrayProperties", @"", ((global::SerializationTypes.KnownTypesThroughConstructorWithArrayProperties)o), true, false); + Write100_Item(@"KnownTypesThroughConstructorWithArrayProperties", @"", ((global::SerializationTypes.KnownTypesThroughConstructorWithArrayProperties)o), true, false); } - public void Write202_Item(object o) { + public void Write213_Item(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"KnownTypesThroughConstructorWithValue", @""); return; } TopLevelElement(); - Write97_Item(@"KnownTypesThroughConstructorWithValue", @"", ((global::SerializationTypes.KnownTypesThroughConstructorWithValue)o), true, false); + Write101_Item(@"KnownTypesThroughConstructorWithValue", @"", ((global::SerializationTypes.KnownTypesThroughConstructorWithValue)o), true, false); } - public void Write203_Item(object o) { + public void Write214_Item(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithTypesHavingCustomFormatter", @""); return; } TopLevelElement(); - Write98_Item(@"TypeWithTypesHavingCustomFormatter", @"", ((global::SerializationTypes.TypeWithTypesHavingCustomFormatter)o), true, false); + Write102_Item(@"TypeWithTypesHavingCustomFormatter", @"", ((global::SerializationTypes.TypeWithTypesHavingCustomFormatter)o), true, false); } - public void Write204_Item(object o) { + public void Write215_Item(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithArrayPropertyHavingChoice", @""); return; } TopLevelElement(); - Write100_Item(@"TypeWithArrayPropertyHavingChoice", @"", ((global::SerializationTypes.TypeWithArrayPropertyHavingChoice)o), true, false); + Write104_Item(@"TypeWithArrayPropertyHavingChoice", @"", ((global::SerializationTypes.TypeWithArrayPropertyHavingChoice)o), true, false); } - public void Write205_MoreChoices(object o) { + public void Write216_MoreChoices(object o) { WriteStartDocument(); if (o == null) { WriteEmptyTag(@"MoreChoices", @""); return; } - WriteElementString(@"MoreChoices", @"", Write99_MoreChoices(((global::SerializationTypes.MoreChoices)o))); + WriteElementString(@"MoreChoices", @"", Write103_MoreChoices(((global::SerializationTypes.MoreChoices)o))); } - public void Write206_TypeWithFieldsOrdered(object o) { + public void Write217_TypeWithFieldsOrdered(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithFieldsOrdered", @""); return; } TopLevelElement(); - Write101_TypeWithFieldsOrdered(@"TypeWithFieldsOrdered", @"", ((global::SerializationTypes.TypeWithFieldsOrdered)o), true, false); + Write105_TypeWithFieldsOrdered(@"TypeWithFieldsOrdered", @"", ((global::SerializationTypes.TypeWithFieldsOrdered)o), true, false); } - public void Write207_Item(object o) { + public void Write218_Item(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeWithKnownTypesOfCollectionsWithConflictingXmlName", @""); return; } TopLevelElement(); - Write102_Item(@"TypeWithKnownTypesOfCollectionsWithConflictingXmlName", @"", ((global::SerializationTypes.TypeWithKnownTypesOfCollectionsWithConflictingXmlName)o), true, false); + Write106_Item(@"TypeWithKnownTypesOfCollectionsWithConflictingXmlName", @"", ((global::SerializationTypes.TypeWithKnownTypesOfCollectionsWithConflictingXmlName)o), true, false); } - public void Write208_Root(object o) { + public void Write219_Root(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"Root", @""); return; } TopLevelElement(); - Write105_Item(@"Root", @"", ((global::SerializationTypes.NamespaceTypeNameClashContainer)o), true, false); + Write109_Item(@"Root", @"", ((global::SerializationTypes.NamespaceTypeNameClashContainer)o), true, false); } - public void Write209_TypeClashB(object o) { + public void Write220_TypeClashB(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeClashB", @""); return; } TopLevelElement(); - Write104_TypeNameClash(@"TypeClashB", @"", ((global::SerializationTypes.TypeNameClashB.TypeNameClash)o), true, false); + Write108_TypeNameClash(@"TypeClashB", @"", ((global::SerializationTypes.TypeNameClashB.TypeNameClash)o), true, false); } - public void Write210_TypeClashA(object o) { + public void Write221_TypeClashA(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"TypeClashA", @""); return; } TopLevelElement(); - Write103_TypeNameClash(@"TypeClashA", @"", ((global::SerializationTypes.TypeNameClashA.TypeNameClash)o), true, false); + Write107_TypeNameClash(@"TypeClashA", @"", ((global::SerializationTypes.TypeNameClashA.TypeNameClash)o), true, false); } - public void Write211_Person(object o) { + public void Write222_Person(object o) { WriteStartDocument(); if (o == null) { WriteNullTagLiteral(@"Person", @""); return; } TopLevelElement(); - Write106_Person(@"Person", @"", ((global::Outer.Person)o), true, false); + Write110_Person(@"Person", @"", ((global::Outer.Person)o), true, false); } - void Write106_Person(string n, string ns, global::Outer.Person o, bool isNullable, bool needType) { + void Write110_Person(string n, string ns, global::Outer.Person o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -1088,7 +1163,7 @@ void Write106_Person(string n, string ns, global::Outer.Person o, bool isNullabl WriteEndElement(o); } - void Write103_TypeNameClash(string n, string ns, global::SerializationTypes.TypeNameClashA.TypeNameClash o, bool isNullable, bool needType) { + void Write107_TypeNameClash(string n, string ns, global::SerializationTypes.TypeNameClashA.TypeNameClash o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -1107,7 +1182,7 @@ void Write103_TypeNameClash(string n, string ns, global::SerializationTypes.Type WriteEndElement(o); } - void Write104_TypeNameClash(string n, string ns, global::SerializationTypes.TypeNameClashB.TypeNameClash o, bool isNullable, bool needType) { + void Write108_TypeNameClash(string n, string ns, global::SerializationTypes.TypeNameClashB.TypeNameClash o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -1126,7 +1201,7 @@ void Write104_TypeNameClash(string n, string ns, global::SerializationTypes.Type WriteEndElement(o); } - void Write105_Item(string n, string ns, global::SerializationTypes.NamespaceTypeNameClashContainer o, bool isNullable, bool needType) { + void Write109_Item(string n, string ns, global::SerializationTypes.NamespaceTypeNameClashContainer o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -1145,7 +1220,7 @@ void Write105_Item(string n, string ns, global::SerializationTypes.NamespaceType global::SerializationTypes.TypeNameClashA.TypeNameClash[] a = (global::SerializationTypes.TypeNameClashA.TypeNameClash[])o.@A; if (a != null) { for (int ia = 0; ia < a.Length; ia++) { - Write103_TypeNameClash(@"A", @"", ((global::SerializationTypes.TypeNameClashA.TypeNameClash)a[ia]), false, false); + Write107_TypeNameClash(@"A", @"", ((global::SerializationTypes.TypeNameClashA.TypeNameClash)a[ia]), false, false); } } } @@ -1153,14 +1228,14 @@ void Write105_Item(string n, string ns, global::SerializationTypes.NamespaceType global::SerializationTypes.TypeNameClashB.TypeNameClash[] a = (global::SerializationTypes.TypeNameClashB.TypeNameClash[])o.@B; if (a != null) { for (int ia = 0; ia < a.Length; ia++) { - Write104_TypeNameClash(@"B", @"", ((global::SerializationTypes.TypeNameClashB.TypeNameClash)a[ia]), false, false); + Write108_TypeNameClash(@"B", @"", ((global::SerializationTypes.TypeNameClashB.TypeNameClash)a[ia]), false, false); } } } WriteEndElement(o); } - void Write102_Item(string n, string ns, global::SerializationTypes.TypeWithKnownTypesOfCollectionsWithConflictingXmlName o, bool isNullable, bool needType) { + void Write106_Item(string n, string ns, global::SerializationTypes.TypeWithKnownTypesOfCollectionsWithConflictingXmlName o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -1191,311 +1266,327 @@ void Write1_Object(string n, string ns, global::System.Object o, bool isNullable } else { if (t == typeof(global::Outer.Person)) { - Write106_Person(n, ns,(global::Outer.Person)o, isNullable, true); + Write110_Person(n, ns,(global::Outer.Person)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.NamespaceTypeNameClashContainer)) { - Write105_Item(n, ns,(global::SerializationTypes.NamespaceTypeNameClashContainer)o, isNullable, true); + Write109_Item(n, ns,(global::SerializationTypes.NamespaceTypeNameClashContainer)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeNameClashB.TypeNameClash)) { - Write104_TypeNameClash(n, ns,(global::SerializationTypes.TypeNameClashB.TypeNameClash)o, isNullable, true); + Write108_TypeNameClash(n, ns,(global::SerializationTypes.TypeNameClashB.TypeNameClash)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeNameClashA.TypeNameClash)) { - Write103_TypeNameClash(n, ns,(global::SerializationTypes.TypeNameClashA.TypeNameClash)o, isNullable, true); + Write107_TypeNameClash(n, ns,(global::SerializationTypes.TypeNameClashA.TypeNameClash)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeWithKnownTypesOfCollectionsWithConflictingXmlName)) { - Write102_Item(n, ns,(global::SerializationTypes.TypeWithKnownTypesOfCollectionsWithConflictingXmlName)o, isNullable, true); + Write106_Item(n, ns,(global::SerializationTypes.TypeWithKnownTypesOfCollectionsWithConflictingXmlName)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeWithFieldsOrdered)) { - Write101_TypeWithFieldsOrdered(n, ns,(global::SerializationTypes.TypeWithFieldsOrdered)o, isNullable, true); + Write105_TypeWithFieldsOrdered(n, ns,(global::SerializationTypes.TypeWithFieldsOrdered)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeWithArrayPropertyHavingChoice)) { - Write100_Item(n, ns,(global::SerializationTypes.TypeWithArrayPropertyHavingChoice)o, isNullable, true); + Write104_Item(n, ns,(global::SerializationTypes.TypeWithArrayPropertyHavingChoice)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeWithTypesHavingCustomFormatter)) { - Write98_Item(n, ns,(global::SerializationTypes.TypeWithTypesHavingCustomFormatter)o, isNullable, true); + Write102_Item(n, ns,(global::SerializationTypes.TypeWithTypesHavingCustomFormatter)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.KnownTypesThroughConstructorWithValue)) { - Write97_Item(n, ns,(global::SerializationTypes.KnownTypesThroughConstructorWithValue)o, isNullable, true); + Write101_Item(n, ns,(global::SerializationTypes.KnownTypesThroughConstructorWithValue)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.KnownTypesThroughConstructorWithArrayProperties)) { - Write96_Item(n, ns,(global::SerializationTypes.KnownTypesThroughConstructorWithArrayProperties)o, isNullable, true); + Write100_Item(n, ns,(global::SerializationTypes.KnownTypesThroughConstructorWithArrayProperties)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeWithShouldSerializeMethod)) { - Write95_TypeWithShouldSerializeMethod(n, ns,(global::SerializationTypes.TypeWithShouldSerializeMethod)o, isNullable, true); + Write99_TypeWithShouldSerializeMethod(n, ns,(global::SerializationTypes.TypeWithShouldSerializeMethod)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeWithEnumFlagPropertyHavingDefaultValue)) { - Write94_Item(n, ns,(global::SerializationTypes.TypeWithEnumFlagPropertyHavingDefaultValue)o, isNullable, true); + Write98_Item(n, ns,(global::SerializationTypes.TypeWithEnumFlagPropertyHavingDefaultValue)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeWithEnumPropertyHavingDefaultValue)) { - Write93_Item(n, ns,(global::SerializationTypes.TypeWithEnumPropertyHavingDefaultValue)o, isNullable, true); + Write97_Item(n, ns,(global::SerializationTypes.TypeWithEnumPropertyHavingDefaultValue)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeWithPropertiesHavingDefaultValue)) { - Write92_Item(n, ns,(global::SerializationTypes.TypeWithPropertiesHavingDefaultValue)o, isNullable, true); + Write96_Item(n, ns,(global::SerializationTypes.TypeWithPropertiesHavingDefaultValue)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeWith2DArrayProperty2)) { - Write91_TypeWith2DArrayProperty2(n, ns,(global::SerializationTypes.TypeWith2DArrayProperty2)o, isNullable, true); + Write95_TypeWith2DArrayProperty2(n, ns,(global::SerializationTypes.TypeWith2DArrayProperty2)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeWithXmlQualifiedName)) { - Write90_TypeWithXmlQualifiedName(n, ns,(global::SerializationTypes.TypeWithXmlQualifiedName)o, isNullable, true); + Write94_TypeWithXmlQualifiedName(n, ns,(global::SerializationTypes.TypeWithXmlQualifiedName)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.ServerSettings)) { - Write89_ServerSettings(n, ns,(global::SerializationTypes.ServerSettings)o, isNullable, true); + Write93_ServerSettings(n, ns,(global::SerializationTypes.ServerSettings)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeWithNonPublicDefaultConstructor)) { - Write88_Item(n, ns,(global::SerializationTypes.TypeWithNonPublicDefaultConstructor)o, isNullable, true); + Write92_Item(n, ns,(global::SerializationTypes.TypeWithNonPublicDefaultConstructor)o, isNullable, true); + return; + } + if (t == typeof(global::SerializationTypes.CustomDocument)) { + Write91_CustomDocument(n, ns,(global::SerializationTypes.CustomDocument)o, isNullable, true); + return; + } + if (t == typeof(global::SerializationTypes.CustomElement)) { + Write90_CustomElement(n, ns,(global::SerializationTypes.CustomElement)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeWithTypeNameInXmlTypeAttribute)) { - Write86_Item(n, ns,(global::SerializationTypes.TypeWithTypeNameInXmlTypeAttribute)o, isNullable, true); + Write88_Item(n, ns,(global::SerializationTypes.TypeWithTypeNameInXmlTypeAttribute)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeWithXmlSchemaFormAttribute)) { - Write85_TypeWithXmlSchemaFormAttribute(n, ns,(global::SerializationTypes.TypeWithXmlSchemaFormAttribute)o, isNullable, true); + Write87_TypeWithXmlSchemaFormAttribute(n, ns,(global::SerializationTypes.TypeWithXmlSchemaFormAttribute)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeWithPropertyNameSpecified)) { - Write84_TypeWithPropertyNameSpecified(n, ns,(global::SerializationTypes.TypeWithPropertyNameSpecified)o, isNullable, true); + Write86_TypeWithPropertyNameSpecified(n, ns,(global::SerializationTypes.TypeWithPropertyNameSpecified)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.SimpleKnownTypeValue)) { - Write83_SimpleKnownTypeValue(n, ns,(global::SerializationTypes.SimpleKnownTypeValue)o, isNullable, true); + Write85_SimpleKnownTypeValue(n, ns,(global::SerializationTypes.SimpleKnownTypeValue)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.KnownTypesThroughConstructor)) { - Write82_KnownTypesThroughConstructor(n, ns,(global::SerializationTypes.KnownTypesThroughConstructor)o, isNullable, true); + Write84_KnownTypesThroughConstructor(n, ns,(global::SerializationTypes.KnownTypesThroughConstructor)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeWithAnyAttribute)) { - Write81_TypeWithAnyAttribute(n, ns,(global::SerializationTypes.TypeWithAnyAttribute)o, isNullable, true); + Write83_TypeWithAnyAttribute(n, ns,(global::SerializationTypes.TypeWithAnyAttribute)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.XmlSerializerAttributes)) { - Write80_XmlSerializerAttributes(n, ns,(global::SerializationTypes.XmlSerializerAttributes)o, isNullable, true); + Write82_XmlSerializerAttributes(n, ns,(global::SerializationTypes.XmlSerializerAttributes)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.WithNullables)) { - Write73_WithNullables(n, ns,(global::SerializationTypes.WithNullables)o, isNullable, true); + Write75_WithNullables(n, ns,(global::SerializationTypes.WithNullables)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.WithEnums)) { - Write72_WithEnums(n, ns,(global::SerializationTypes.WithEnums)o, isNullable, true); + Write74_WithEnums(n, ns,(global::SerializationTypes.WithEnums)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.WithStruct)) { - Write69_WithStruct(n, ns,(global::SerializationTypes.WithStruct)o, isNullable, true); + Write71_WithStruct(n, ns,(global::SerializationTypes.WithStruct)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.SomeStruct)) { - Write68_SomeStruct(n, ns,(global::SerializationTypes.SomeStruct)o, true); + Write70_SomeStruct(n, ns,(global::SerializationTypes.SomeStruct)o, true); return; } if (t == typeof(global::SerializationTypes.ClassImplementsInterface)) { - Write67_ClassImplementsInterface(n, ns,(global::SerializationTypes.ClassImplementsInterface)o, isNullable, true); + Write69_ClassImplementsInterface(n, ns,(global::SerializationTypes.ClassImplementsInterface)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeWithXmlTextAttributeOnArray)) { - Write65_Item(n, ns,(global::SerializationTypes.TypeWithXmlTextAttributeOnArray)o, isNullable, true); + Write67_Item(n, ns,(global::SerializationTypes.TypeWithXmlTextAttributeOnArray)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.SimpleDC)) { - Write64_SimpleDC(n, ns,(global::SerializationTypes.SimpleDC)o, isNullable, true); + Write66_SimpleDC(n, ns,(global::SerializationTypes.SimpleDC)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeWithByteArrayAsXmlText)) { - Write63_TypeWithByteArrayAsXmlText(n, ns,(global::SerializationTypes.TypeWithByteArrayAsXmlText)o, isNullable, true); + Write65_TypeWithByteArrayAsXmlText(n, ns,(global::SerializationTypes.TypeWithByteArrayAsXmlText)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeWithDateTimePropertyAsXmlTime)) { - Write62_Item(n, ns,(global::SerializationTypes.TypeWithDateTimePropertyAsXmlTime)o, isNullable, true); + Write64_Item(n, ns,(global::SerializationTypes.TypeWithDateTimePropertyAsXmlTime)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.BaseClassWithSamePropertyName)) { - Write59_BaseClassWithSamePropertyName(n, ns,(global::SerializationTypes.BaseClassWithSamePropertyName)o, isNullable, true); + Write61_BaseClassWithSamePropertyName(n, ns,(global::SerializationTypes.BaseClassWithSamePropertyName)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.DerivedClassWithSameProperty)) { - Write60_DerivedClassWithSameProperty(n, ns,(global::SerializationTypes.DerivedClassWithSameProperty)o, isNullable, true); + Write62_DerivedClassWithSameProperty(n, ns,(global::SerializationTypes.DerivedClassWithSameProperty)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.DerivedClassWithSameProperty2)) { - Write61_DerivedClassWithSameProperty2(n, ns,(global::SerializationTypes.DerivedClassWithSameProperty2)o, isNullable, true); + Write63_DerivedClassWithSameProperty2(n, ns,(global::SerializationTypes.DerivedClassWithSameProperty2)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.@__TypeNameWithSpecialCharacters漢ñ)) { - Write58_Item(n, ns,(global::SerializationTypes.@__TypeNameWithSpecialCharacters漢ñ)o, isNullable, true); + Write60_Item(n, ns,(global::SerializationTypes.@__TypeNameWithSpecialCharacters漢ñ)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeHasArrayOfASerializedAsB)) { - Write57_TypeHasArrayOfASerializedAsB(n, ns,(global::SerializationTypes.TypeHasArrayOfASerializedAsB)o, isNullable, true); + Write59_TypeHasArrayOfASerializedAsB(n, ns,(global::SerializationTypes.TypeHasArrayOfASerializedAsB)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeB)) { - Write56_TypeB(n, ns,(global::SerializationTypes.TypeB)o, isNullable, true); + Write58_TypeB(n, ns,(global::SerializationTypes.TypeB)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeA)) { - Write55_TypeA(n, ns,(global::SerializationTypes.TypeA)o, isNullable, true); + Write57_TypeA(n, ns,(global::SerializationTypes.TypeA)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.BuiltInTypes)) { - Write54_BuiltInTypes(n, ns,(global::SerializationTypes.BuiltInTypes)o, isNullable, true); + Write56_BuiltInTypes(n, ns,(global::SerializationTypes.BuiltInTypes)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.DCClassWithEnumAndStruct)) { - Write53_DCClassWithEnumAndStruct(n, ns,(global::SerializationTypes.DCClassWithEnumAndStruct)o, isNullable, true); + Write55_DCClassWithEnumAndStruct(n, ns,(global::SerializationTypes.DCClassWithEnumAndStruct)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.DCStruct)) { - Write52_DCStruct(n, ns,(global::SerializationTypes.DCStruct)o, true); + Write54_DCStruct(n, ns,(global::SerializationTypes.DCStruct)o, true); return; } if (t == typeof(global::SerializationTypes.TypeWithEnumMembers)) { - Write51_TypeWithEnumMembers(n, ns,(global::SerializationTypes.TypeWithEnumMembers)o, isNullable, true); + Write53_TypeWithEnumMembers(n, ns,(global::SerializationTypes.TypeWithEnumMembers)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeWithReadOnlyMyCollectionProperty)) { - Write49_Item(n, ns,(global::SerializationTypes.TypeWithReadOnlyMyCollectionProperty)o, isNullable, true); + Write51_Item(n, ns,(global::SerializationTypes.TypeWithReadOnlyMyCollectionProperty)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeWithMyCollectionField)) { - Write48_TypeWithMyCollectionField(n, ns,(global::SerializationTypes.TypeWithMyCollectionField)o, isNullable, true); + Write50_TypeWithMyCollectionField(n, ns,(global::SerializationTypes.TypeWithMyCollectionField)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.StructNotSerializable)) { - Write47_StructNotSerializable(n, ns,(global::SerializationTypes.StructNotSerializable)o, true); + Write49_StructNotSerializable(n, ns,(global::SerializationTypes.StructNotSerializable)o, true); return; } if (t == typeof(global::SerializationTypes.TypeWithGetOnlyArrayProperties)) { - Write46_TypeWithGetOnlyArrayProperties(n, ns,(global::SerializationTypes.TypeWithGetOnlyArrayProperties)o, isNullable, true); + Write48_TypeWithGetOnlyArrayProperties(n, ns,(global::SerializationTypes.TypeWithGetOnlyArrayProperties)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeWithGetSetArrayMembers)) { - Write45_TypeWithGetSetArrayMembers(n, ns,(global::SerializationTypes.TypeWithGetSetArrayMembers)o, isNullable, true); + Write47_TypeWithGetSetArrayMembers(n, ns,(global::SerializationTypes.TypeWithGetSetArrayMembers)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.SimpleType)) { - Write44_SimpleType(n, ns,(global::SerializationTypes.SimpleType)o, isNullable, true); + Write46_SimpleType(n, ns,(global::SerializationTypes.SimpleType)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.TypeWithDateTimeStringProperty)) { - Write43_TypeWithDateTimeStringProperty(n, ns,(global::SerializationTypes.TypeWithDateTimeStringProperty)o, isNullable, true); + Write45_TypeWithDateTimeStringProperty(n, ns,(global::SerializationTypes.TypeWithDateTimeStringProperty)o, isNullable, true); return; } if (t == typeof(global::XElementArrayWrapper)) { - Write42_XElementArrayWrapper(n, ns,(global::XElementArrayWrapper)o, isNullable, true); + Write44_XElementArrayWrapper(n, ns,(global::XElementArrayWrapper)o, isNullable, true); return; } if (t == typeof(global::XElementStruct)) { - Write41_XElementStruct(n, ns,(global::XElementStruct)o, true); + Write43_XElementStruct(n, ns,(global::XElementStruct)o, true); return; } if (t == typeof(global::XElementWrapper)) { - Write40_XElementWrapper(n, ns,(global::XElementWrapper)o, isNullable, true); + Write42_XElementWrapper(n, ns,(global::XElementWrapper)o, isNullable, true); return; } if (t == typeof(global::RootClass)) { - Write39_RootClass(n, ns,(global::RootClass)o, isNullable, true); + Write41_RootClass(n, ns,(global::RootClass)o, isNullable, true); return; } if (t == typeof(global::Parameter)) { - Write38_Parameter(n, ns,(global::Parameter)o, isNullable, true); + Write40_Parameter(n, ns,(global::Parameter)o, isNullable, true); return; } if (t == typeof(global::Parameter)) { - Write37_ParameterOfString(n, ns,(global::Parameter)o, isNullable, true); + Write39_ParameterOfString(n, ns,(global::Parameter)o, isNullable, true); return; } if (t == typeof(global::MsgDocumentType)) { - Write36_MsgDocumentType(n, ns,(global::MsgDocumentType)o, isNullable, true); + Write38_MsgDocumentType(n, ns,(global::MsgDocumentType)o, isNullable, true); return; } if (t == typeof(global::TypeWithLinkedProperty)) { - Write35_TypeWithLinkedProperty(n, ns,(global::TypeWithLinkedProperty)o, isNullable, true); + Write37_TypeWithLinkedProperty(n, ns,(global::TypeWithLinkedProperty)o, isNullable, true); return; } if (t == typeof(global::TypeWithMismatchBetweenAttributeAndPropertyType)) { - Write34_Item(n, ns,(global::TypeWithMismatchBetweenAttributeAndPropertyType)o, isNullable, true); + Write36_Item(n, ns,(global::TypeWithMismatchBetweenAttributeAndPropertyType)o, isNullable, true); return; } if (t == typeof(global::DefaultValuesSetToNegativeInfinity)) { - Write33_Item(n, ns,(global::DefaultValuesSetToNegativeInfinity)o, isNullable, true); + Write35_Item(n, ns,(global::DefaultValuesSetToNegativeInfinity)o, isNullable, true); return; } if (t == typeof(global::DefaultValuesSetToPositiveInfinity)) { - Write32_Item(n, ns,(global::DefaultValuesSetToPositiveInfinity)o, isNullable, true); + Write34_Item(n, ns,(global::DefaultValuesSetToPositiveInfinity)o, isNullable, true); return; } if (t == typeof(global::DefaultValuesSetToNaN)) { - Write31_DefaultValuesSetToNaN(n, ns,(global::DefaultValuesSetToNaN)o, isNullable, true); + Write33_DefaultValuesSetToNaN(n, ns,(global::DefaultValuesSetToNaN)o, isNullable, true); return; } if (t == typeof(global::Pet)) { - Write30_Pet(n, ns,(global::Pet)o, isNullable, true); + Write32_Pet(n, ns,(global::Pet)o, isNullable, true); return; } if (t == typeof(global::Orchestra)) { - Write27_Orchestra(n, ns,(global::Orchestra)o, isNullable, true); + Write29_Orchestra(n, ns,(global::Orchestra)o, isNullable, true); return; } if (t == typeof(global::Instrument)) { - Write26_Instrument(n, ns,(global::Instrument)o, isNullable, true); + Write28_Instrument(n, ns,(global::Instrument)o, isNullable, true); return; } if (t == typeof(global::Brass)) { - Write28_Brass(n, ns,(global::Brass)o, isNullable, true); + Write30_Brass(n, ns,(global::Brass)o, isNullable, true); return; } if (t == typeof(global::Trumpet)) { - Write29_Trumpet(n, ns,(global::Trumpet)o, isNullable, true); + Write31_Trumpet(n, ns,(global::Trumpet)o, isNullable, true); return; } if (t == typeof(global::BaseClass1)) { - Write24_BaseClass1(n, ns,(global::BaseClass1)o, isNullable, true); + Write26_BaseClass1(n, ns,(global::BaseClass1)o, isNullable, true); return; } if (t == typeof(global::DerivedClass1)) { - Write25_DerivedClass1(n, ns,(global::DerivedClass1)o, isNullable, true); + Write27_DerivedClass1(n, ns,(global::DerivedClass1)o, isNullable, true); return; } if (t == typeof(global::AliasedTestType)) { - Write23_AliasedTestType(n, ns,(global::AliasedTestType)o, isNullable, true); + Write25_AliasedTestType(n, ns,(global::AliasedTestType)o, isNullable, true); return; } if (t == typeof(global::OrderedItem)) { - Write22_OrderedItem(n, ns,(global::OrderedItem)o, isNullable, true); + Write24_OrderedItem(n, ns,(global::OrderedItem)o, isNullable, true); return; } if (t == typeof(global::Address)) { - Write21_Address(n, ns,(global::Address)o, isNullable, true); + Write23_Address(n, ns,(global::Address)o, isNullable, true); return; } if (t == typeof(global::PurchaseOrder)) { - Write20_PurchaseOrder(n, ns,(global::PurchaseOrder)o, isNullable, true); + Write22_PurchaseOrder(n, ns,(global::PurchaseOrder)o, isNullable, true); return; } if (t == typeof(global::OrderedItem)) { - Write19_OrderedItem(n, ns,(global::OrderedItem)o, isNullable, true); + Write21_OrderedItem(n, ns,(global::OrderedItem)o, isNullable, true); return; } if (t == typeof(global::Address)) { - Write18_Address(n, ns,(global::Address)o, isNullable, true); + Write20_Address(n, ns,(global::Address)o, isNullable, true); + return; + } + if (t == typeof(global::SimpleBaseClass)) { + Write19_SimpleBaseClass(n, ns,(global::SimpleBaseClass)o, isNullable, true); + return; + } + if (t == typeof(global::SimpleDerivedClass)) { + Write18_SimpleDerivedClass(n, ns,(global::SimpleDerivedClass)o, isNullable, true); return; } if (t == typeof(global::BaseClass)) { @@ -1572,7 +1663,7 @@ void Write1_Object(string n, string ns, global::System.Object o, bool isNullable global::OrderedItem[] a = (global::OrderedItem[])o; if (a != null) { for (int ia = 0; ia < a.Length; ia++) { - Write19_OrderedItem(@"OrderedItem", @"http://www.contoso1.com", ((global::OrderedItem)a[ia]), true, false); + Write21_OrderedItem(@"OrderedItem", @"http://www.contoso1.com", ((global::OrderedItem)a[ia]), true, false); } } } @@ -1645,7 +1736,7 @@ void Write1_Object(string n, string ns, global::System.Object o, bool isNullable global::Instrument[] a = (global::Instrument[])o; if (a != null) { for (int ia = 0; ia < a.Length; ia++) { - Write26_Instrument(@"Instrument", @"", ((global::Instrument)a[ia]), true, false); + Write28_Instrument(@"Instrument", @"", ((global::Instrument)a[ia]), true, false); } } } @@ -1659,7 +1750,7 @@ void Write1_Object(string n, string ns, global::System.Object o, bool isNullable global::System.Collections.Generic.List a = (global::System.Collections.Generic.List)o; if (a != null) { for (int ia = 0; ia < ((System.Collections.ICollection)a).Count; ia++) { - Write35_TypeWithLinkedProperty(@"TypeWithLinkedProperty", @"", ((global::TypeWithLinkedProperty)a[ia]), true, false); + Write37_TypeWithLinkedProperty(@"TypeWithLinkedProperty", @"", ((global::TypeWithLinkedProperty)a[ia]), true, false); } } } @@ -1673,7 +1764,7 @@ void Write1_Object(string n, string ns, global::System.Object o, bool isNullable global::System.Collections.Generic.List a = (global::System.Collections.Generic.List)o; if (a != null) { for (int ia = 0; ia < ((System.Collections.ICollection)a).Count; ia++) { - Write38_Parameter(@"Parameter", @"", ((global::Parameter)a[ia]), true, false); + Write40_Parameter(@"Parameter", @"", ((global::Parameter)a[ia]), true, false); } } } @@ -1701,7 +1792,7 @@ void Write1_Object(string n, string ns, global::System.Object o, bool isNullable global::SerializationTypes.SimpleType[] a = (global::SerializationTypes.SimpleType[])o; if (a != null) { for (int ia = 0; ia < a.Length; ia++) { - Write44_SimpleType(@"SimpleType", @"", ((global::SerializationTypes.SimpleType)a[ia]), true, false); + Write46_SimpleType(@"SimpleType", @"", ((global::SerializationTypes.SimpleType)a[ia]), true, false); } } } @@ -1725,7 +1816,7 @@ void Write1_Object(string n, string ns, global::System.Object o, bool isNullable if (t == typeof(global::SerializationTypes.MyEnum)) { Writer.WriteStartElement(n, ns); WriteXsiType(@"MyEnum", @""); - Writer.WriteString(Write50_MyEnum((global::SerializationTypes.MyEnum)o)); + Writer.WriteString(Write52_MyEnum((global::SerializationTypes.MyEnum)o)); Writer.WriteEndElement(); return; } @@ -1736,7 +1827,7 @@ void Write1_Object(string n, string ns, global::System.Object o, bool isNullable global::SerializationTypes.TypeA[] a = (global::SerializationTypes.TypeA[])o; if (a != null) { for (int ia = 0; ia < a.Length; ia++) { - Write55_TypeA(@"TypeA", @"", ((global::SerializationTypes.TypeA)a[ia]), true, false); + Write57_TypeA(@"TypeA", @"", ((global::SerializationTypes.TypeA)a[ia]), true, false); } } } @@ -1746,63 +1837,63 @@ void Write1_Object(string n, string ns, global::System.Object o, bool isNullable if (t == typeof(global::SerializationTypes.EnumFlags)) { Writer.WriteStartElement(n, ns); WriteXsiType(@"EnumFlags", @""); - Writer.WriteString(Write66_EnumFlags((global::SerializationTypes.EnumFlags)o)); + Writer.WriteString(Write68_EnumFlags((global::SerializationTypes.EnumFlags)o)); Writer.WriteEndElement(); return; } if (t == typeof(global::SerializationTypes.IntEnum)) { Writer.WriteStartElement(n, ns); WriteXsiType(@"IntEnum", @""); - Writer.WriteString(Write70_IntEnum((global::SerializationTypes.IntEnum)o)); + Writer.WriteString(Write72_IntEnum((global::SerializationTypes.IntEnum)o)); Writer.WriteEndElement(); return; } if (t == typeof(global::SerializationTypes.ShortEnum)) { Writer.WriteStartElement(n, ns); WriteXsiType(@"ShortEnum", @""); - Writer.WriteString(Write71_ShortEnum((global::SerializationTypes.ShortEnum)o)); + Writer.WriteString(Write73_ShortEnum((global::SerializationTypes.ShortEnum)o)); Writer.WriteEndElement(); return; } if (t == typeof(global::SerializationTypes.ByteEnum)) { Writer.WriteStartElement(n, ns); WriteXsiType(@"ByteEnum", @""); - Writer.WriteString(Write74_ByteEnum((global::SerializationTypes.ByteEnum)o)); + Writer.WriteString(Write76_ByteEnum((global::SerializationTypes.ByteEnum)o)); Writer.WriteEndElement(); return; } if (t == typeof(global::SerializationTypes.SByteEnum)) { Writer.WriteStartElement(n, ns); WriteXsiType(@"SByteEnum", @""); - Writer.WriteString(Write75_SByteEnum((global::SerializationTypes.SByteEnum)o)); + Writer.WriteString(Write77_SByteEnum((global::SerializationTypes.SByteEnum)o)); Writer.WriteEndElement(); return; } if (t == typeof(global::SerializationTypes.UIntEnum)) { Writer.WriteStartElement(n, ns); WriteXsiType(@"UIntEnum", @""); - Writer.WriteString(Write76_UIntEnum((global::SerializationTypes.UIntEnum)o)); + Writer.WriteString(Write78_UIntEnum((global::SerializationTypes.UIntEnum)o)); Writer.WriteEndElement(); return; } if (t == typeof(global::SerializationTypes.LongEnum)) { Writer.WriteStartElement(n, ns); WriteXsiType(@"LongEnum", @""); - Writer.WriteString(Write77_LongEnum((global::SerializationTypes.LongEnum)o)); + Writer.WriteString(Write79_LongEnum((global::SerializationTypes.LongEnum)o)); Writer.WriteEndElement(); return; } if (t == typeof(global::SerializationTypes.ULongEnum)) { Writer.WriteStartElement(n, ns); WriteXsiType(@"ULongEnum", @""); - Writer.WriteString(Write78_ULongEnum((global::SerializationTypes.ULongEnum)o)); + Writer.WriteString(Write80_ULongEnum((global::SerializationTypes.ULongEnum)o)); Writer.WriteEndElement(); return; } if (t == typeof(global::SerializationTypes.ItemChoiceType)) { Writer.WriteStartElement(n, ns); WriteXsiType(@"ItemChoiceType", @""); - Writer.WriteString(Write79_ItemChoiceType((global::SerializationTypes.ItemChoiceType)o)); + Writer.WriteString(Write81_ItemChoiceType((global::SerializationTypes.ItemChoiceType)o)); Writer.WriteEndElement(); return; } @@ -1813,7 +1904,7 @@ void Write1_Object(string n, string ns, global::System.Object o, bool isNullable global::SerializationTypes.ItemChoiceType[] a = (global::SerializationTypes.ItemChoiceType[])o; if (a != null) { for (int ia = 0; ia < a.Length; ia++) { - WriteElementString(@"ItemChoiceType", @"", Write79_ItemChoiceType(((global::SerializationTypes.ItemChoiceType)a[ia]))); + WriteElementString(@"ItemChoiceType", @"", Write81_ItemChoiceType(((global::SerializationTypes.ItemChoiceType)a[ia]))); } } } @@ -1870,7 +1961,7 @@ void Write1_Object(string n, string ns, global::System.Object o, bool isNullable if (a != null){ WriteStartElement(@"SimpleType", @"", null, false); for (int ia = 0; ia < a.Length; ia++) { - Write44_SimpleType(@"SimpleType", @"", ((global::SerializationTypes.SimpleType)a[ia]), true, false); + Write46_SimpleType(@"SimpleType", @"", ((global::SerializationTypes.SimpleType)a[ia]), true, false); } WriteEndElement(); } @@ -1881,7 +1972,7 @@ void Write1_Object(string n, string ns, global::System.Object o, bool isNullable if (t == typeof(global::SerializationTypes.MoreChoices)) { Writer.WriteStartElement(n, ns); WriteXsiType(@"MoreChoices", @""); - Writer.WriteString(Write99_MoreChoices((global::SerializationTypes.MoreChoices)o)); + Writer.WriteString(Write103_MoreChoices((global::SerializationTypes.MoreChoices)o)); Writer.WriteEndElement(); return; } @@ -1893,7 +1984,7 @@ void Write1_Object(string n, string ns, global::System.Object o, bool isNullable WriteEndElement(o); } - string Write99_MoreChoices(global::SerializationTypes.MoreChoices v) { + string Write103_MoreChoices(global::SerializationTypes.MoreChoices v) { string s = null; switch (v) { case global::SerializationTypes.MoreChoices.@None: s = @"None"; break; @@ -1904,7 +1995,7 @@ string Write99_MoreChoices(global::SerializationTypes.MoreChoices v) { return s; } - void Write44_SimpleType(string n, string ns, global::SerializationTypes.SimpleType o, bool isNullable, bool needType) { + void Write46_SimpleType(string n, string ns, global::SerializationTypes.SimpleType o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -1924,7 +2015,7 @@ void Write44_SimpleType(string n, string ns, global::SerializationTypes.SimpleTy WriteEndElement(o); } - string Write79_ItemChoiceType(global::SerializationTypes.ItemChoiceType v) { + string Write81_ItemChoiceType(global::SerializationTypes.ItemChoiceType v) { string s = null; switch (v) { case global::SerializationTypes.ItemChoiceType.@None: s = @"None"; break; @@ -1936,7 +2027,7 @@ string Write79_ItemChoiceType(global::SerializationTypes.ItemChoiceType v) { return s; } - string Write78_ULongEnum(global::SerializationTypes.ULongEnum v) { + string Write80_ULongEnum(global::SerializationTypes.ULongEnum v) { string s = null; switch (v) { case global::SerializationTypes.ULongEnum.@Option0: s = @"Option0"; break; @@ -1947,7 +2038,7 @@ string Write78_ULongEnum(global::SerializationTypes.ULongEnum v) { return s; } - string Write77_LongEnum(global::SerializationTypes.LongEnum v) { + string Write79_LongEnum(global::SerializationTypes.LongEnum v) { string s = null; switch (v) { case global::SerializationTypes.LongEnum.@Option0: s = @"Option0"; break; @@ -1958,7 +2049,7 @@ string Write77_LongEnum(global::SerializationTypes.LongEnum v) { return s; } - string Write76_UIntEnum(global::SerializationTypes.UIntEnum v) { + string Write78_UIntEnum(global::SerializationTypes.UIntEnum v) { string s = null; switch (v) { case global::SerializationTypes.UIntEnum.@Option0: s = @"Option0"; break; @@ -1969,7 +2060,7 @@ string Write76_UIntEnum(global::SerializationTypes.UIntEnum v) { return s; } - string Write75_SByteEnum(global::SerializationTypes.SByteEnum v) { + string Write77_SByteEnum(global::SerializationTypes.SByteEnum v) { string s = null; switch (v) { case global::SerializationTypes.SByteEnum.@Option0: s = @"Option0"; break; @@ -1980,7 +2071,7 @@ string Write75_SByteEnum(global::SerializationTypes.SByteEnum v) { return s; } - string Write74_ByteEnum(global::SerializationTypes.ByteEnum v) { + string Write76_ByteEnum(global::SerializationTypes.ByteEnum v) { string s = null; switch (v) { case global::SerializationTypes.ByteEnum.@Option0: s = @"Option0"; break; @@ -1991,7 +2082,7 @@ string Write74_ByteEnum(global::SerializationTypes.ByteEnum v) { return s; } - string Write71_ShortEnum(global::SerializationTypes.ShortEnum v) { + string Write73_ShortEnum(global::SerializationTypes.ShortEnum v) { string s = null; switch (v) { case global::SerializationTypes.ShortEnum.@Option0: s = @"Option0"; break; @@ -2002,7 +2093,7 @@ string Write71_ShortEnum(global::SerializationTypes.ShortEnum v) { return s; } - string Write70_IntEnum(global::SerializationTypes.IntEnum v) { + string Write72_IntEnum(global::SerializationTypes.IntEnum v) { string s = null; switch (v) { case global::SerializationTypes.IntEnum.@Option0: s = @"Option0"; break; @@ -2013,7 +2104,7 @@ string Write70_IntEnum(global::SerializationTypes.IntEnum v) { return s; } - string Write66_EnumFlags(global::SerializationTypes.EnumFlags v) { + string Write68_EnumFlags(global::SerializationTypes.EnumFlags v) { string s = null; switch (v) { case global::SerializationTypes.EnumFlags.@One: s = @"One"; break; @@ -2031,7 +2122,7 @@ string Write66_EnumFlags(global::SerializationTypes.EnumFlags v) { return s; } - void Write55_TypeA(string n, string ns, global::SerializationTypes.TypeA o, bool isNullable, bool needType) { + void Write57_TypeA(string n, string ns, global::SerializationTypes.TypeA o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -2050,7 +2141,7 @@ void Write55_TypeA(string n, string ns, global::SerializationTypes.TypeA o, bool WriteEndElement(o); } - string Write50_MyEnum(global::SerializationTypes.MyEnum v) { + string Write52_MyEnum(global::SerializationTypes.MyEnum v) { string s = null; switch (v) { case global::SerializationTypes.MyEnum.@One: s = @"One"; break; @@ -2061,7 +2152,7 @@ string Write50_MyEnum(global::SerializationTypes.MyEnum v) { return s; } - void Write38_Parameter(string n, string ns, global::Parameter o, bool isNullable, bool needType) { + void Write40_Parameter(string n, string ns, global::Parameter o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -2072,7 +2163,7 @@ void Write38_Parameter(string n, string ns, global::Parameter o, bool isNullable } else { if (t == typeof(global::Parameter)) { - Write37_ParameterOfString(n, ns,(global::Parameter)o, isNullable, true); + Write39_ParameterOfString(n, ns,(global::Parameter)o, isNullable, true); return; } throw CreateUnknownTypeException(o); @@ -2084,7 +2175,7 @@ void Write38_Parameter(string n, string ns, global::Parameter o, bool isNullable WriteEndElement(o); } - void Write37_ParameterOfString(string n, string ns, global::Parameter o, bool isNullable, bool needType) { + void Write39_ParameterOfString(string n, string ns, global::Parameter o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -2104,7 +2195,7 @@ void Write37_ParameterOfString(string n, string ns, global::Parameter a = (global::System.Collections.Generic.List)((global::System.Collections.Generic.List)o.@Children); if (a != null){ WriteStartElement(@"Children", @"", null, false); for (int ia = 0; ia < ((System.Collections.ICollection)a).Count; ia++) { - Write35_TypeWithLinkedProperty(@"TypeWithLinkedProperty", @"", ((global::TypeWithLinkedProperty)a[ia]), true, false); + Write37_TypeWithLinkedProperty(@"TypeWithLinkedProperty", @"", ((global::TypeWithLinkedProperty)a[ia]), true, false); } WriteEndElement(); } @@ -2133,7 +2224,7 @@ void Write35_TypeWithLinkedProperty(string n, string ns, global::TypeWithLinkedP WriteEndElement(o); } - void Write26_Instrument(string n, string ns, global::Instrument o, bool isNullable, bool needType) { + void Write28_Instrument(string n, string ns, global::Instrument o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -2144,11 +2235,11 @@ void Write26_Instrument(string n, string ns, global::Instrument o, bool isNullab } else { if (t == typeof(global::Brass)) { - Write28_Brass(n, ns,(global::Brass)o, isNullable, true); + Write30_Brass(n, ns,(global::Brass)o, isNullable, true); return; } if (t == typeof(global::Trumpet)) { - Write29_Trumpet(n, ns,(global::Trumpet)o, isNullable, true); + Write31_Trumpet(n, ns,(global::Trumpet)o, isNullable, true); return; } throw CreateUnknownTypeException(o); @@ -2160,7 +2251,7 @@ void Write26_Instrument(string n, string ns, global::Instrument o, bool isNullab WriteEndElement(o); } - void Write29_Trumpet(string n, string ns, global::Trumpet o, bool isNullable, bool needType) { + void Write31_Trumpet(string n, string ns, global::Trumpet o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -2181,7 +2272,7 @@ void Write29_Trumpet(string n, string ns, global::Trumpet o, bool isNullable, bo WriteEndElement(o); } - void Write28_Brass(string n, string ns, global::Brass o, bool isNullable, bool needType) { + void Write30_Brass(string n, string ns, global::Brass o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -2192,7 +2283,7 @@ void Write28_Brass(string n, string ns, global::Brass o, bool isNullable, bool n } else { if (t == typeof(global::Trumpet)) { - Write29_Trumpet(n, ns,(global::Trumpet)o, isNullable, true); + Write31_Trumpet(n, ns,(global::Trumpet)o, isNullable, true); return; } throw CreateUnknownTypeException(o); @@ -2205,7 +2296,7 @@ void Write28_Brass(string n, string ns, global::Brass o, bool isNullable, bool n WriteEndElement(o); } - void Write19_OrderedItem(string n, string ns, global::OrderedItem o, bool isNullable, bool needType) { + void Write21_OrderedItem(string n, string ns, global::OrderedItem o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -2585,7 +2676,52 @@ void Write17_BaseClass(string n, string ns, global::BaseClass o, bool isNullable WriteEndElement(o); } - void Write18_Address(string n, string ns, global::Address o, bool isNullable, bool needType) { + void Write18_SimpleDerivedClass(string n, string ns, global::SimpleDerivedClass o, bool isNullable, bool needType) { + if ((object)o == null) { + if (isNullable) WriteNullTagLiteral(n, ns); + return; + } + if (!needType) { + System.Type t = o.GetType(); + if (t == typeof(global::SimpleDerivedClass)) { + } + else { + throw CreateUnknownTypeException(o); + } + } + WriteStartElement(n, ns, o, false, null); + if (needType) WriteXsiType(@"SimpleDerivedClass", @""); + WriteAttribute(@"AttributeString", @"", ((global::System.String)o.@AttributeString)); + WriteAttribute(@"DateTimeValue", @"", FromDateTime(((global::System.DateTime)o.@DateTimeValue))); + WriteAttribute(@"BoolValue", @"", System.Xml.XmlConvert.ToString((global::System.Boolean)((global::System.Boolean)o.@BoolValue))); + WriteEndElement(o); + } + + void Write19_SimpleBaseClass(string n, string ns, global::SimpleBaseClass o, bool isNullable, bool needType) { + if ((object)o == null) { + if (isNullable) WriteNullTagLiteral(n, ns); + return; + } + if (!needType) { + System.Type t = o.GetType(); + if (t == typeof(global::SimpleBaseClass)) { + } + else { + if (t == typeof(global::SimpleDerivedClass)) { + Write18_SimpleDerivedClass(n, ns,(global::SimpleDerivedClass)o, isNullable, true); + return; + } + throw CreateUnknownTypeException(o); + } + } + WriteStartElement(n, ns, o, false, null); + if (needType) WriteXsiType(@"SimpleBaseClass", @""); + WriteAttribute(@"AttributeString", @"", ((global::System.String)o.@AttributeString)); + WriteAttribute(@"DateTimeValue", @"", FromDateTime(((global::System.DateTime)o.@DateTimeValue))); + WriteEndElement(o); + } + + void Write20_Address(string n, string ns, global::Address o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -2608,7 +2744,7 @@ void Write18_Address(string n, string ns, global::Address o, bool isNullable, bo WriteEndElement(o); } - void Write20_PurchaseOrder(string n, string ns, global::PurchaseOrder o, bool isNullable, bool needType) { + void Write22_PurchaseOrder(string n, string ns, global::PurchaseOrder o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -2623,14 +2759,14 @@ void Write20_PurchaseOrder(string n, string ns, global::PurchaseOrder o, bool is } WriteStartElement(n, ns, o, false, null); if (needType) WriteXsiType(@"PurchaseOrder", @"http://www.contoso1.com"); - Write18_Address(@"ShipTo", @"http://www.contoso1.com", ((global::Address)o.@ShipTo), false, false); + Write20_Address(@"ShipTo", @"http://www.contoso1.com", ((global::Address)o.@ShipTo), false, false); WriteElementString(@"OrderDate", @"http://www.contoso1.com", ((global::System.String)o.@OrderDate)); { global::OrderedItem[] a = (global::OrderedItem[])((global::OrderedItem[])o.@OrderedItems); if (a != null){ WriteStartElement(@"Items", @"http://www.contoso1.com", null, false); for (int ia = 0; ia < a.Length; ia++) { - Write19_OrderedItem(@"OrderedItem", @"http://www.contoso1.com", ((global::OrderedItem)a[ia]), true, false); + Write21_OrderedItem(@"OrderedItem", @"http://www.contoso1.com", ((global::OrderedItem)a[ia]), true, false); } WriteEndElement(); } @@ -2641,7 +2777,7 @@ void Write20_PurchaseOrder(string n, string ns, global::PurchaseOrder o, bool is WriteEndElement(o); } - void Write21_Address(string n, string ns, global::Address o, bool isNullable, bool needType) { + void Write23_Address(string n, string ns, global::Address o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -2664,7 +2800,7 @@ void Write21_Address(string n, string ns, global::Address o, bool isNullable, bo WriteEndElement(o); } - void Write22_OrderedItem(string n, string ns, global::OrderedItem o, bool isNullable, bool needType) { + void Write24_OrderedItem(string n, string ns, global::OrderedItem o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -2687,7 +2823,7 @@ void Write22_OrderedItem(string n, string ns, global::OrderedItem o, bool isNull WriteEndElement(o); } - void Write23_AliasedTestType(string n, string ns, global::AliasedTestType o, bool isNullable, bool needType) { + void Write25_AliasedTestType(string n, string ns, global::AliasedTestType o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -2746,7 +2882,7 @@ void Write23_AliasedTestType(string n, string ns, global::AliasedTestType o, boo WriteEndElement(o); } - void Write25_DerivedClass1(string n, string ns, global::DerivedClass1 o, bool isNullable, bool needType) { + void Write27_DerivedClass1(string n, string ns, global::DerivedClass1 o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -2775,7 +2911,7 @@ void Write25_DerivedClass1(string n, string ns, global::DerivedClass1 o, bool is WriteEndElement(o); } - void Write24_BaseClass1(string n, string ns, global::BaseClass1 o, bool isNullable, bool needType) { + void Write26_BaseClass1(string n, string ns, global::BaseClass1 o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -2786,7 +2922,7 @@ void Write24_BaseClass1(string n, string ns, global::BaseClass1 o, bool isNullab } else { if (t == typeof(global::DerivedClass1)) { - Write25_DerivedClass1(n, ns,(global::DerivedClass1)o, isNullable, true); + Write27_DerivedClass1(n, ns,(global::DerivedClass1)o, isNullable, true); return; } throw CreateUnknownTypeException(o); @@ -2808,7 +2944,7 @@ void Write24_BaseClass1(string n, string ns, global::BaseClass1 o, bool isNullab WriteEndElement(o); } - void Write27_Orchestra(string n, string ns, global::Orchestra o, bool isNullable, bool needType) { + void Write29_Orchestra(string n, string ns, global::Orchestra o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -2828,7 +2964,7 @@ void Write27_Orchestra(string n, string ns, global::Orchestra o, bool isNullable if (a != null){ WriteStartElement(@"Instruments", @"", null, false); for (int ia = 0; ia < a.Length; ia++) { - Write26_Instrument(@"Instrument", @"", ((global::Instrument)a[ia]), true, false); + Write28_Instrument(@"Instrument", @"", ((global::Instrument)a[ia]), true, false); } WriteEndElement(); } @@ -2836,7 +2972,7 @@ void Write27_Orchestra(string n, string ns, global::Orchestra o, bool isNullable WriteEndElement(o); } - void Write30_Pet(string n, string ns, global::Pet o, bool isNullable, bool needType) { + void Write32_Pet(string n, string ns, global::Pet o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -2858,7 +2994,7 @@ void Write30_Pet(string n, string ns, global::Pet o, bool isNullable, bool needT WriteEndElement(o); } - void Write31_DefaultValuesSetToNaN(string n, string ns, global::DefaultValuesSetToNaN o, bool isNullable, bool needType) { + void Write33_DefaultValuesSetToNaN(string n, string ns, global::DefaultValuesSetToNaN o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -2888,7 +3024,7 @@ void Write31_DefaultValuesSetToNaN(string n, string ns, global::DefaultValuesSet WriteEndElement(o); } - void Write32_Item(string n, string ns, global::DefaultValuesSetToPositiveInfinity o, bool isNullable, bool needType) { + void Write34_Item(string n, string ns, global::DefaultValuesSetToPositiveInfinity o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -2918,7 +3054,7 @@ void Write32_Item(string n, string ns, global::DefaultValuesSetToPositiveInfinit WriteEndElement(o); } - void Write33_Item(string n, string ns, global::DefaultValuesSetToNegativeInfinity o, bool isNullable, bool needType) { + void Write35_Item(string n, string ns, global::DefaultValuesSetToNegativeInfinity o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -2948,7 +3084,7 @@ void Write33_Item(string n, string ns, global::DefaultValuesSetToNegativeInfinit WriteEndElement(o); } - void Write34_Item(string n, string ns, global::TypeWithMismatchBetweenAttributeAndPropertyType o, bool isNullable, bool needType) { + void Write36_Item(string n, string ns, global::TypeWithMismatchBetweenAttributeAndPropertyType o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -2969,7 +3105,7 @@ void Write34_Item(string n, string ns, global::TypeWithMismatchBetweenAttributeA WriteEndElement(o); } - void Write36_MsgDocumentType(string n, string ns, global::MsgDocumentType o, bool isNullable, bool needType) { + void Write38_MsgDocumentType(string n, string ns, global::MsgDocumentType o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3000,7 +3136,7 @@ void Write36_MsgDocumentType(string n, string ns, global::MsgDocumentType o, boo WriteEndElement(o); } - void Write39_RootClass(string n, string ns, global::RootClass o, bool isNullable, bool needType) { + void Write41_RootClass(string n, string ns, global::RootClass o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3020,7 +3156,7 @@ void Write39_RootClass(string n, string ns, global::RootClass o, bool isNullable if (a != null){ WriteStartElement(@"Parameters", @"", null, false); for (int ia = 0; ia < ((System.Collections.ICollection)a).Count; ia++) { - Write38_Parameter(@"Parameter", @"", ((global::Parameter)a[ia]), true, false); + Write40_Parameter(@"Parameter", @"", ((global::Parameter)a[ia]), true, false); } WriteEndElement(); } @@ -3028,7 +3164,7 @@ void Write39_RootClass(string n, string ns, global::RootClass o, bool isNullable WriteEndElement(o); } - void Write40_XElementWrapper(string n, string ns, global::XElementWrapper o, bool isNullable, bool needType) { + void Write42_XElementWrapper(string n, string ns, global::XElementWrapper o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3047,7 +3183,7 @@ void Write40_XElementWrapper(string n, string ns, global::XElementWrapper o, boo WriteEndElement(o); } - void Write41_XElementStruct(string n, string ns, global::XElementStruct o, bool needType) { + void Write43_XElementStruct(string n, string ns, global::XElementStruct o, bool needType) { if (!needType) { System.Type t = o.GetType(); if (t == typeof(global::XElementStruct)) { @@ -3062,7 +3198,7 @@ void Write41_XElementStruct(string n, string ns, global::XElementStruct o, bool WriteEndElement(o); } - void Write42_XElementArrayWrapper(string n, string ns, global::XElementArrayWrapper o, bool isNullable, bool needType) { + void Write44_XElementArrayWrapper(string n, string ns, global::XElementArrayWrapper o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3090,7 +3226,7 @@ void Write42_XElementArrayWrapper(string n, string ns, global::XElementArrayWrap WriteEndElement(o); } - void Write43_TypeWithDateTimeStringProperty(string n, string ns, global::SerializationTypes.TypeWithDateTimeStringProperty o, bool isNullable, bool needType) { + void Write45_TypeWithDateTimeStringProperty(string n, string ns, global::SerializationTypes.TypeWithDateTimeStringProperty o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3110,7 +3246,7 @@ void Write43_TypeWithDateTimeStringProperty(string n, string ns, global::Seriali WriteEndElement(o); } - void Write45_TypeWithGetSetArrayMembers(string n, string ns, global::SerializationTypes.TypeWithGetSetArrayMembers o, bool isNullable, bool needType) { + void Write47_TypeWithGetSetArrayMembers(string n, string ns, global::SerializationTypes.TypeWithGetSetArrayMembers o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3130,7 +3266,7 @@ void Write45_TypeWithGetSetArrayMembers(string n, string ns, global::Serializati if (a != null){ WriteStartElement(@"F1", @"", null, false); for (int ia = 0; ia < a.Length; ia++) { - Write44_SimpleType(@"SimpleType", @"", ((global::SerializationTypes.SimpleType)a[ia]), true, false); + Write46_SimpleType(@"SimpleType", @"", ((global::SerializationTypes.SimpleType)a[ia]), true, false); } WriteEndElement(); } @@ -3150,7 +3286,7 @@ void Write45_TypeWithGetSetArrayMembers(string n, string ns, global::Serializati if (a != null){ WriteStartElement(@"P1", @"", null, false); for (int ia = 0; ia < a.Length; ia++) { - Write44_SimpleType(@"SimpleType", @"", ((global::SerializationTypes.SimpleType)a[ia]), true, false); + Write46_SimpleType(@"SimpleType", @"", ((global::SerializationTypes.SimpleType)a[ia]), true, false); } WriteEndElement(); } @@ -3168,7 +3304,7 @@ void Write45_TypeWithGetSetArrayMembers(string n, string ns, global::Serializati WriteEndElement(o); } - void Write46_TypeWithGetOnlyArrayProperties(string n, string ns, global::SerializationTypes.TypeWithGetOnlyArrayProperties o, bool isNullable, bool needType) { + void Write48_TypeWithGetOnlyArrayProperties(string n, string ns, global::SerializationTypes.TypeWithGetOnlyArrayProperties o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3186,7 +3322,7 @@ void Write46_TypeWithGetOnlyArrayProperties(string n, string ns, global::Seriali WriteEndElement(o); } - void Write47_StructNotSerializable(string n, string ns, global::SerializationTypes.StructNotSerializable o, bool needType) { + void Write49_StructNotSerializable(string n, string ns, global::SerializationTypes.StructNotSerializable o, bool needType) { if (!needType) { System.Type t = o.GetType(); if (t == typeof(global::SerializationTypes.StructNotSerializable)) { @@ -3201,7 +3337,7 @@ void Write47_StructNotSerializable(string n, string ns, global::SerializationTyp WriteEndElement(o); } - void Write48_TypeWithMyCollectionField(string n, string ns, global::SerializationTypes.TypeWithMyCollectionField o, bool isNullable, bool needType) { + void Write50_TypeWithMyCollectionField(string n, string ns, global::SerializationTypes.TypeWithMyCollectionField o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3232,7 +3368,7 @@ void Write48_TypeWithMyCollectionField(string n, string ns, global::Serializatio WriteEndElement(o); } - void Write49_Item(string n, string ns, global::SerializationTypes.TypeWithReadOnlyMyCollectionProperty o, bool isNullable, bool needType) { + void Write51_Item(string n, string ns, global::SerializationTypes.TypeWithReadOnlyMyCollectionProperty o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3263,7 +3399,7 @@ void Write49_Item(string n, string ns, global::SerializationTypes.TypeWithReadOn WriteEndElement(o); } - void Write51_TypeWithEnumMembers(string n, string ns, global::SerializationTypes.TypeWithEnumMembers o, bool isNullable, bool needType) { + void Write53_TypeWithEnumMembers(string n, string ns, global::SerializationTypes.TypeWithEnumMembers o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3278,12 +3414,12 @@ void Write51_TypeWithEnumMembers(string n, string ns, global::SerializationTypes } WriteStartElement(n, ns, o, false, null); if (needType) WriteXsiType(@"TypeWithEnumMembers", @""); - WriteElementString(@"F1", @"", Write50_MyEnum(((global::SerializationTypes.MyEnum)o.@F1))); - WriteElementString(@"P1", @"", Write50_MyEnum(((global::SerializationTypes.MyEnum)o.@P1))); + WriteElementString(@"F1", @"", Write52_MyEnum(((global::SerializationTypes.MyEnum)o.@F1))); + WriteElementString(@"P1", @"", Write52_MyEnum(((global::SerializationTypes.MyEnum)o.@P1))); WriteEndElement(o); } - void Write52_DCStruct(string n, string ns, global::SerializationTypes.DCStruct o, bool needType) { + void Write54_DCStruct(string n, string ns, global::SerializationTypes.DCStruct o, bool needType) { if (!needType) { System.Type t = o.GetType(); if (t == typeof(global::SerializationTypes.DCStruct)) { @@ -3298,7 +3434,7 @@ void Write52_DCStruct(string n, string ns, global::SerializationTypes.DCStruct o WriteEndElement(o); } - void Write53_DCClassWithEnumAndStruct(string n, string ns, global::SerializationTypes.DCClassWithEnumAndStruct o, bool isNullable, bool needType) { + void Write55_DCClassWithEnumAndStruct(string n, string ns, global::SerializationTypes.DCClassWithEnumAndStruct o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3313,12 +3449,12 @@ void Write53_DCClassWithEnumAndStruct(string n, string ns, global::Serialization } WriteStartElement(n, ns, o, false, null); if (needType) WriteXsiType(@"DCClassWithEnumAndStruct", @""); - Write52_DCStruct(@"MyStruct", @"", ((global::SerializationTypes.DCStruct)o.@MyStruct), false); - WriteElementString(@"MyEnum1", @"", Write50_MyEnum(((global::SerializationTypes.MyEnum)o.@MyEnum1))); + Write54_DCStruct(@"MyStruct", @"", ((global::SerializationTypes.DCStruct)o.@MyStruct), false); + WriteElementString(@"MyEnum1", @"", Write52_MyEnum(((global::SerializationTypes.MyEnum)o.@MyEnum1))); WriteEndElement(o); } - void Write54_BuiltInTypes(string n, string ns, global::SerializationTypes.BuiltInTypes o, bool isNullable, bool needType) { + void Write56_BuiltInTypes(string n, string ns, global::SerializationTypes.BuiltInTypes o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3337,7 +3473,7 @@ void Write54_BuiltInTypes(string n, string ns, global::SerializationTypes.BuiltI WriteEndElement(o); } - void Write56_TypeB(string n, string ns, global::SerializationTypes.TypeB o, bool isNullable, bool needType) { + void Write58_TypeB(string n, string ns, global::SerializationTypes.TypeB o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3356,7 +3492,7 @@ void Write56_TypeB(string n, string ns, global::SerializationTypes.TypeB o, bool WriteEndElement(o); } - void Write57_TypeHasArrayOfASerializedAsB(string n, string ns, global::SerializationTypes.TypeHasArrayOfASerializedAsB o, bool isNullable, bool needType) { + void Write59_TypeHasArrayOfASerializedAsB(string n, string ns, global::SerializationTypes.TypeHasArrayOfASerializedAsB o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3376,7 +3512,7 @@ void Write57_TypeHasArrayOfASerializedAsB(string n, string ns, global::Serializa if (a != null){ WriteStartElement(@"Items", @"", null, false); for (int ia = 0; ia < a.Length; ia++) { - Write55_TypeA(@"TypeA", @"", ((global::SerializationTypes.TypeA)a[ia]), true, false); + Write57_TypeA(@"TypeA", @"", ((global::SerializationTypes.TypeA)a[ia]), true, false); } WriteEndElement(); } @@ -3384,7 +3520,7 @@ void Write57_TypeHasArrayOfASerializedAsB(string n, string ns, global::Serializa WriteEndElement(o); } - void Write58_Item(string n, string ns, global::SerializationTypes.@__TypeNameWithSpecialCharacters漢ñ o, bool isNullable, bool needType) { + void Write60_Item(string n, string ns, global::SerializationTypes.@__TypeNameWithSpecialCharacters漢ñ o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3403,7 +3539,7 @@ void Write58_Item(string n, string ns, global::SerializationTypes.@__TypeNameWit WriteEndElement(o); } - void Write61_DerivedClassWithSameProperty2(string n, string ns, global::SerializationTypes.DerivedClassWithSameProperty2 o, bool isNullable, bool needType) { + void Write63_DerivedClassWithSameProperty2(string n, string ns, global::SerializationTypes.DerivedClassWithSameProperty2 o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3434,7 +3570,7 @@ void Write61_DerivedClassWithSameProperty2(string n, string ns, global::Serializ WriteEndElement(o); } - void Write60_DerivedClassWithSameProperty(string n, string ns, global::SerializationTypes.DerivedClassWithSameProperty o, bool isNullable, bool needType) { + void Write62_DerivedClassWithSameProperty(string n, string ns, global::SerializationTypes.DerivedClassWithSameProperty o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3445,7 +3581,7 @@ void Write60_DerivedClassWithSameProperty(string n, string ns, global::Serializa } else { if (t == typeof(global::SerializationTypes.DerivedClassWithSameProperty2)) { - Write61_DerivedClassWithSameProperty2(n, ns,(global::SerializationTypes.DerivedClassWithSameProperty2)o, isNullable, true); + Write63_DerivedClassWithSameProperty2(n, ns,(global::SerializationTypes.DerivedClassWithSameProperty2)o, isNullable, true); return; } throw CreateUnknownTypeException(o); @@ -3469,7 +3605,7 @@ void Write60_DerivedClassWithSameProperty(string n, string ns, global::Serializa WriteEndElement(o); } - void Write59_BaseClassWithSamePropertyName(string n, string ns, global::SerializationTypes.BaseClassWithSamePropertyName o, bool isNullable, bool needType) { + void Write61_BaseClassWithSamePropertyName(string n, string ns, global::SerializationTypes.BaseClassWithSamePropertyName o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3480,11 +3616,11 @@ void Write59_BaseClassWithSamePropertyName(string n, string ns, global::Serializ } else { if (t == typeof(global::SerializationTypes.DerivedClassWithSameProperty)) { - Write60_DerivedClassWithSameProperty(n, ns,(global::SerializationTypes.DerivedClassWithSameProperty)o, isNullable, true); + Write62_DerivedClassWithSameProperty(n, ns,(global::SerializationTypes.DerivedClassWithSameProperty)o, isNullable, true); return; } if (t == typeof(global::SerializationTypes.DerivedClassWithSameProperty2)) { - Write61_DerivedClassWithSameProperty2(n, ns,(global::SerializationTypes.DerivedClassWithSameProperty2)o, isNullable, true); + Write63_DerivedClassWithSameProperty2(n, ns,(global::SerializationTypes.DerivedClassWithSameProperty2)o, isNullable, true); return; } throw CreateUnknownTypeException(o); @@ -3508,7 +3644,7 @@ void Write59_BaseClassWithSamePropertyName(string n, string ns, global::Serializ WriteEndElement(o); } - void Write62_Item(string n, string ns, global::SerializationTypes.TypeWithDateTimePropertyAsXmlTime o, bool isNullable, bool needType) { + void Write64_Item(string n, string ns, global::SerializationTypes.TypeWithDateTimePropertyAsXmlTime o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3529,7 +3665,7 @@ void Write62_Item(string n, string ns, global::SerializationTypes.TypeWithDateTi WriteEndElement(o); } - void Write63_TypeWithByteArrayAsXmlText(string n, string ns, global::SerializationTypes.TypeWithByteArrayAsXmlText o, bool isNullable, bool needType) { + void Write65_TypeWithByteArrayAsXmlText(string n, string ns, global::SerializationTypes.TypeWithByteArrayAsXmlText o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3550,7 +3686,7 @@ void Write63_TypeWithByteArrayAsXmlText(string n, string ns, global::Serializati WriteEndElement(o); } - void Write64_SimpleDC(string n, string ns, global::SerializationTypes.SimpleDC o, bool isNullable, bool needType) { + void Write66_SimpleDC(string n, string ns, global::SerializationTypes.SimpleDC o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3569,7 +3705,7 @@ void Write64_SimpleDC(string n, string ns, global::SerializationTypes.SimpleDC o WriteEndElement(o); } - void Write65_Item(string n, string ns, global::SerializationTypes.TypeWithXmlTextAttributeOnArray o, bool isNullable, bool needType) { + void Write67_Item(string n, string ns, global::SerializationTypes.TypeWithXmlTextAttributeOnArray o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3597,7 +3733,7 @@ void Write65_Item(string n, string ns, global::SerializationTypes.TypeWithXmlTex WriteEndElement(o); } - void Write67_ClassImplementsInterface(string n, string ns, global::SerializationTypes.ClassImplementsInterface o, bool isNullable, bool needType) { + void Write69_ClassImplementsInterface(string n, string ns, global::SerializationTypes.ClassImplementsInterface o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3619,7 +3755,7 @@ void Write67_ClassImplementsInterface(string n, string ns, global::Serialization WriteEndElement(o); } - void Write68_SomeStruct(string n, string ns, global::SerializationTypes.SomeStruct o, bool needType) { + void Write70_SomeStruct(string n, string ns, global::SerializationTypes.SomeStruct o, bool needType) { if (!needType) { System.Type t = o.GetType(); if (t == typeof(global::SerializationTypes.SomeStruct)) { @@ -3635,7 +3771,7 @@ void Write68_SomeStruct(string n, string ns, global::SerializationTypes.SomeStru WriteEndElement(o); } - void Write69_WithStruct(string n, string ns, global::SerializationTypes.WithStruct o, bool isNullable, bool needType) { + void Write71_WithStruct(string n, string ns, global::SerializationTypes.WithStruct o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3650,11 +3786,11 @@ void Write69_WithStruct(string n, string ns, global::SerializationTypes.WithStru } WriteStartElement(n, ns, o, false, null); if (needType) WriteXsiType(@"WithStruct", @""); - Write68_SomeStruct(@"Some", @"", ((global::SerializationTypes.SomeStruct)o.@Some), false); + Write70_SomeStruct(@"Some", @"", ((global::SerializationTypes.SomeStruct)o.@Some), false); WriteEndElement(o); } - void Write72_WithEnums(string n, string ns, global::SerializationTypes.WithEnums o, bool isNullable, bool needType) { + void Write74_WithEnums(string n, string ns, global::SerializationTypes.WithEnums o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3669,12 +3805,12 @@ void Write72_WithEnums(string n, string ns, global::SerializationTypes.WithEnums } WriteStartElement(n, ns, o, false, null); if (needType) WriteXsiType(@"WithEnums", @""); - WriteElementString(@"Int", @"", Write70_IntEnum(((global::SerializationTypes.IntEnum)o.@Int))); - WriteElementString(@"Short", @"", Write71_ShortEnum(((global::SerializationTypes.ShortEnum)o.@Short))); + WriteElementString(@"Int", @"", Write72_IntEnum(((global::SerializationTypes.IntEnum)o.@Int))); + WriteElementString(@"Short", @"", Write73_ShortEnum(((global::SerializationTypes.ShortEnum)o.@Short))); WriteEndElement(o); } - void Write73_WithNullables(string n, string ns, global::SerializationTypes.WithNullables o, bool isNullable, bool needType) { + void Write75_WithNullables(string n, string ns, global::SerializationTypes.WithNullables o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3690,13 +3826,13 @@ void Write73_WithNullables(string n, string ns, global::SerializationTypes.WithN WriteStartElement(n, ns, o, false, null); if (needType) WriteXsiType(@"WithNullables", @""); if (o.@Optional != null) { - WriteElementString(@"Optional", @"", Write70_IntEnum(((global::SerializationTypes.IntEnum)o.@Optional))); + WriteElementString(@"Optional", @"", Write72_IntEnum(((global::SerializationTypes.IntEnum)o.@Optional))); } else { WriteNullTagLiteral(@"Optional", @""); } if (o.@Optionull != null) { - WriteElementString(@"Optionull", @"", Write70_IntEnum(((global::SerializationTypes.IntEnum)o.@Optionull))); + WriteElementString(@"Optionull", @"", Write72_IntEnum(((global::SerializationTypes.IntEnum)o.@Optionull))); } else { WriteNullTagLiteral(@"Optionull", @""); @@ -3714,13 +3850,13 @@ void Write73_WithNullables(string n, string ns, global::SerializationTypes.WithN WriteNullTagLiteral(@"OptionullInt", @""); } if (o.@Struct1 != null) { - Write68_SomeStruct(@"Struct1", @"", ((global::SerializationTypes.SomeStruct)o.@Struct1), false); + Write70_SomeStruct(@"Struct1", @"", ((global::SerializationTypes.SomeStruct)o.@Struct1), false); } else { WriteNullTagLiteral(@"Struct1", @""); } if (o.@Struct2 != null) { - Write68_SomeStruct(@"Struct2", @"", ((global::SerializationTypes.SomeStruct)o.@Struct2), false); + Write70_SomeStruct(@"Struct2", @"", ((global::SerializationTypes.SomeStruct)o.@Struct2), false); } else { WriteNullTagLiteral(@"Struct2", @""); @@ -3728,7 +3864,7 @@ void Write73_WithNullables(string n, string ns, global::SerializationTypes.WithN WriteEndElement(o); } - void Write80_XmlSerializerAttributes(string n, string ns, global::SerializationTypes.XmlSerializerAttributes o, bool isNullable, bool needType) { + void Write82_XmlSerializerAttributes(string n, string ns, global::SerializationTypes.XmlSerializerAttributes o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3767,7 +3903,7 @@ void Write80_XmlSerializerAttributes(string n, string ns, global::SerializationT if (a != null){ WriteStartElement(@"XmlEnumProperty", @"", null, false); for (int ia = 0; ia < a.Length; ia++) { - WriteElementString(@"ItemChoiceType", @"", Write79_ItemChoiceType(((global::SerializationTypes.ItemChoiceType)a[ia]))); + WriteElementString(@"ItemChoiceType", @"", Write81_ItemChoiceType(((global::SerializationTypes.ItemChoiceType)a[ia]))); } WriteEndElement(); } @@ -3790,7 +3926,7 @@ void Write80_XmlSerializerAttributes(string n, string ns, global::SerializationT WriteEndElement(o); } - void Write81_TypeWithAnyAttribute(string n, string ns, global::SerializationTypes.TypeWithAnyAttribute o, bool isNullable, bool needType) { + void Write83_TypeWithAnyAttribute(string n, string ns, global::SerializationTypes.TypeWithAnyAttribute o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3819,7 +3955,7 @@ void Write81_TypeWithAnyAttribute(string n, string ns, global::SerializationType WriteEndElement(o); } - void Write82_KnownTypesThroughConstructor(string n, string ns, global::SerializationTypes.KnownTypesThroughConstructor o, bool isNullable, bool needType) { + void Write84_KnownTypesThroughConstructor(string n, string ns, global::SerializationTypes.KnownTypesThroughConstructor o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3839,7 +3975,7 @@ void Write82_KnownTypesThroughConstructor(string n, string ns, global::Serializa WriteEndElement(o); } - void Write83_SimpleKnownTypeValue(string n, string ns, global::SerializationTypes.SimpleKnownTypeValue o, bool isNullable, bool needType) { + void Write85_SimpleKnownTypeValue(string n, string ns, global::SerializationTypes.SimpleKnownTypeValue o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3858,7 +3994,7 @@ void Write83_SimpleKnownTypeValue(string n, string ns, global::SerializationType WriteEndElement(o); } - void Write84_TypeWithPropertyNameSpecified(string n, string ns, global::SerializationTypes.TypeWithPropertyNameSpecified o, bool isNullable, bool needType) { + void Write86_TypeWithPropertyNameSpecified(string n, string ns, global::SerializationTypes.TypeWithPropertyNameSpecified o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3882,7 +4018,7 @@ void Write84_TypeWithPropertyNameSpecified(string n, string ns, global::Serializ WriteEndElement(o); } - void Write85_TypeWithXmlSchemaFormAttribute(string n, string ns, global::SerializationTypes.TypeWithXmlSchemaFormAttribute o, bool isNullable, bool needType) { + void Write87_TypeWithXmlSchemaFormAttribute(string n, string ns, global::SerializationTypes.TypeWithXmlSchemaFormAttribute o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3930,7 +4066,7 @@ void Write85_TypeWithXmlSchemaFormAttribute(string n, string ns, global::Seriali WriteEndElement(o); } - void Write86_Item(string n, string ns, global::SerializationTypes.TypeWithTypeNameInXmlTypeAttribute o, bool isNullable, bool needType) { + void Write88_Item(string n, string ns, global::SerializationTypes.TypeWithTypeNameInXmlTypeAttribute o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3949,7 +4085,83 @@ void Write86_Item(string n, string ns, global::SerializationTypes.TypeWithTypeNa WriteEndElement(o); } - void Write88_Item(string n, string ns, global::SerializationTypes.TypeWithNonPublicDefaultConstructor o, bool isNullable, bool needType) { + void Write90_CustomElement(string n, string ns, global::SerializationTypes.CustomElement o, bool isNullable, bool needType) { + if ((object)o == null) { + if (isNullable) WriteNullTagLiteral(n, ns); + return; + } + if (!needType) { + System.Type t = o.GetType(); + if (t == typeof(global::SerializationTypes.CustomElement)) { + } + else { + throw CreateUnknownTypeException(o); + } + } + WriteStartElement(n, ns, o, false, null); + if (needType) WriteXsiType(@"CustomElement", @""); + WriteAttribute(@"name", @"", ((global::System.String)o.@Name)); + { + global::System.Xml.XmlAttribute[] a = (global::System.Xml.XmlAttribute[])o.@Attributes; + if (a != null) { + for (int i = 0; i < a.Length; i++) { + global::System.Xml.XmlAttribute ai = (global::System.Xml.XmlAttribute)a[i]; + WriteXmlAttribute(ai, o); + } + } + } + { + global::System.Xml.XmlNode[] a = (global::System.Xml.XmlNode[])o.@CustomAttributes; + if (a != null) { + for (int i = 0; i < a.Length; i++) { + global::System.Xml.XmlNode ai = (global::System.Xml.XmlNode)a[i]; + WriteXmlAttribute(ai, o); + } + } + } + WriteEndElement(o); + } + + void Write91_CustomDocument(string n, string ns, global::SerializationTypes.CustomDocument o, bool isNullable, bool needType) { + if ((object)o == null) { + if (isNullable) WriteNullTagLiteral(n, ns); + return; + } + if (!needType) { + System.Type t = o.GetType(); + if (t == typeof(global::SerializationTypes.CustomDocument)) { + } + else { + throw CreateUnknownTypeException(o); + } + } + WriteStartElement(n, ns, o, false, null); + if (needType) WriteXsiType(@"CustomDocument", @""); + { + global::System.Collections.Generic.List a = (global::System.Collections.Generic.List)o.@CustomItems; + if (a != null) { + for (int ia = 0; ia < ((System.Collections.ICollection)a).Count; ia++) { + Write90_CustomElement(@"customElement", @"", ((global::SerializationTypes.CustomElement)a[ia]), false, false); + } + } + } + { + global::System.Xml.XmlNode[] a = (global::System.Xml.XmlNode[])o.@Items; + if (a != null) { + for (int ia = 0; ia < a.Length; ia++) { + if ((a[ia]) is System.Xml.XmlNode || a[ia] == null) { + WriteElementLiteral((System.Xml.XmlNode)a[ia], @"", null, false, true); + } + else { + throw CreateInvalidAnyTypeException(a[ia]); + } + } + } + } + WriteEndElement(o); + } + + void Write92_Item(string n, string ns, global::SerializationTypes.TypeWithNonPublicDefaultConstructor o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3968,7 +4180,7 @@ void Write88_Item(string n, string ns, global::SerializationTypes.TypeWithNonPub WriteEndElement(o); } - void Write89_ServerSettings(string n, string ns, global::SerializationTypes.ServerSettings o, bool isNullable, bool needType) { + void Write93_ServerSettings(string n, string ns, global::SerializationTypes.ServerSettings o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -3988,7 +4200,7 @@ void Write89_ServerSettings(string n, string ns, global::SerializationTypes.Serv WriteEndElement(o); } - void Write90_TypeWithXmlQualifiedName(string n, string ns, global::SerializationTypes.TypeWithXmlQualifiedName o, bool isNullable, bool needType) { + void Write94_TypeWithXmlQualifiedName(string n, string ns, global::SerializationTypes.TypeWithXmlQualifiedName o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -4007,7 +4219,7 @@ void Write90_TypeWithXmlQualifiedName(string n, string ns, global::Serialization WriteEndElement(o); } - void Write91_TypeWith2DArrayProperty2(string n, string ns, global::SerializationTypes.TypeWith2DArrayProperty2 o, bool isNullable, bool needType) { + void Write95_TypeWith2DArrayProperty2(string n, string ns, global::SerializationTypes.TypeWith2DArrayProperty2 o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -4032,7 +4244,7 @@ void Write91_TypeWith2DArrayProperty2(string n, string ns, global::Serialization if (aa != null){ WriteStartElement(@"SimpleType", @"", null, false); for (int iaa = 0; iaa < aa.Length; iaa++) { - Write44_SimpleType(@"SimpleType", @"", ((global::SerializationTypes.SimpleType)aa[iaa]), true, false); + Write46_SimpleType(@"SimpleType", @"", ((global::SerializationTypes.SimpleType)aa[iaa]), true, false); } WriteEndElement(); } @@ -4044,7 +4256,7 @@ void Write91_TypeWith2DArrayProperty2(string n, string ns, global::Serialization WriteEndElement(o); } - void Write92_Item(string n, string ns, global::SerializationTypes.TypeWithPropertiesHavingDefaultValue o, bool isNullable, bool needType) { + void Write96_Item(string n, string ns, global::SerializationTypes.TypeWithPropertiesHavingDefaultValue o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -4072,7 +4284,7 @@ void Write92_Item(string n, string ns, global::SerializationTypes.TypeWithProper WriteEndElement(o); } - void Write93_Item(string n, string ns, global::SerializationTypes.TypeWithEnumPropertyHavingDefaultValue o, bool isNullable, bool needType) { + void Write97_Item(string n, string ns, global::SerializationTypes.TypeWithEnumPropertyHavingDefaultValue o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -4088,12 +4300,12 @@ void Write93_Item(string n, string ns, global::SerializationTypes.TypeWithEnumPr WriteStartElement(n, ns, o, false, null); if (needType) WriteXsiType(@"TypeWithEnumPropertyHavingDefaultValue", @""); if (((global::SerializationTypes.IntEnum)o.@EnumProperty) != global::SerializationTypes.IntEnum.@Option1) { - WriteElementString(@"EnumProperty", @"", Write70_IntEnum(((global::SerializationTypes.IntEnum)o.@EnumProperty))); + WriteElementString(@"EnumProperty", @"", Write72_IntEnum(((global::SerializationTypes.IntEnum)o.@EnumProperty))); } WriteEndElement(o); } - void Write94_Item(string n, string ns, global::SerializationTypes.TypeWithEnumFlagPropertyHavingDefaultValue o, bool isNullable, bool needType) { + void Write98_Item(string n, string ns, global::SerializationTypes.TypeWithEnumFlagPropertyHavingDefaultValue o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -4110,12 +4322,12 @@ void Write94_Item(string n, string ns, global::SerializationTypes.TypeWithEnumFl if (needType) WriteXsiType(@"TypeWithEnumFlagPropertyHavingDefaultValue", @""); if (((global::SerializationTypes.EnumFlags)o.@EnumProperty) != (global::SerializationTypes.EnumFlags.@One | global::SerializationTypes.EnumFlags.@Four)) { - WriteElementString(@"EnumProperty", @"", Write66_EnumFlags(((global::SerializationTypes.EnumFlags)o.@EnumProperty))); + WriteElementString(@"EnumProperty", @"", Write68_EnumFlags(((global::SerializationTypes.EnumFlags)o.@EnumProperty))); } WriteEndElement(o); } - void Write95_TypeWithShouldSerializeMethod(string n, string ns, global::SerializationTypes.TypeWithShouldSerializeMethod o, bool isNullable, bool needType) { + void Write99_TypeWithShouldSerializeMethod(string n, string ns, global::SerializationTypes.TypeWithShouldSerializeMethod o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -4136,7 +4348,7 @@ void Write95_TypeWithShouldSerializeMethod(string n, string ns, global::Serializ WriteEndElement(o); } - void Write96_Item(string n, string ns, global::SerializationTypes.KnownTypesThroughConstructorWithArrayProperties o, bool isNullable, bool needType) { + void Write100_Item(string n, string ns, global::SerializationTypes.KnownTypesThroughConstructorWithArrayProperties o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -4156,7 +4368,7 @@ void Write96_Item(string n, string ns, global::SerializationTypes.KnownTypesThro WriteEndElement(o); } - void Write97_Item(string n, string ns, global::SerializationTypes.KnownTypesThroughConstructorWithValue o, bool isNullable, bool needType) { + void Write101_Item(string n, string ns, global::SerializationTypes.KnownTypesThroughConstructorWithValue o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -4175,7 +4387,7 @@ void Write97_Item(string n, string ns, global::SerializationTypes.KnownTypesThro WriteEndElement(o); } - void Write98_Item(string n, string ns, global::SerializationTypes.TypeWithTypesHavingCustomFormatter o, bool isNullable, bool needType) { + void Write102_Item(string n, string ns, global::SerializationTypes.TypeWithTypesHavingCustomFormatter o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -4202,7 +4414,7 @@ void Write98_Item(string n, string ns, global::SerializationTypes.TypeWithTypesH WriteEndElement(o); } - void Write100_Item(string n, string ns, global::SerializationTypes.TypeWithArrayPropertyHavingChoice o, bool isNullable, bool needType) { + void Write104_Item(string n, string ns, global::SerializationTypes.TypeWithArrayPropertyHavingChoice o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -4245,7 +4457,7 @@ void Write100_Item(string n, string ns, global::SerializationTypes.TypeWithArray WriteEndElement(o); } - void Write101_TypeWithFieldsOrdered(string n, string ns, global::SerializationTypes.TypeWithFieldsOrdered o, bool isNullable, bool needType) { + void Write105_TypeWithFieldsOrdered(string n, string ns, global::SerializationTypes.TypeWithFieldsOrdered o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -4260,14 +4472,14 @@ void Write101_TypeWithFieldsOrdered(string n, string ns, global::SerializationTy } WriteStartElement(n, ns, o, false, null); if (needType) WriteXsiType(@"TypeWithFieldsOrdered", @""); - WriteElementStringRaw(@"IntField1", @"", System.Xml.XmlConvert.ToString((global::System.Int32)((global::System.Int32)o.@IntField1))); WriteElementStringRaw(@"IntField2", @"", System.Xml.XmlConvert.ToString((global::System.Int32)((global::System.Int32)o.@IntField2))); - WriteElementString(@"StringField2", @"", ((global::System.String)o.@StringField2)); - WriteElementString(@"StringField1", @"", ((global::System.String)o.@StringField1)); + WriteElementStringRaw(@"IntField1", @"", System.Xml.XmlConvert.ToString((global::System.Int32)((global::System.Int32)o.@IntField1))); + WriteElementString(@"strfld", @"", ((global::System.String)o.@StringField2)); + WriteElementString(@"strfld", @"", ((global::System.String)o.@StringField1)); WriteEndElement(o); } - void Write87_Item(string n, string ns, global::SerializationTypes.TypeWithSchemaFormInXmlAttribute o, bool isNullable, bool needType) { + void Write89_Item(string n, string ns, global::SerializationTypes.TypeWithSchemaFormInXmlAttribute o, bool isNullable, bool needType) { if ((object)o == null) { if (isNullable) WriteNullTagLiteral(n, ns); return; @@ -4292,7 +4504,7 @@ protected override void InitCallbacks() { public class XmlSerializationReader1 : System.Xml.Serialization.XmlSerializationReader { - public object Read111_TypeWithXmlElementProperty() { + public object Read115_TypeWithXmlElementProperty() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { @@ -4310,7 +4522,7 @@ public object Read111_TypeWithXmlElementProperty() { return (object)o; } - public object Read112_TypeWithXmlDocumentProperty() { + public object Read116_TypeWithXmlDocumentProperty() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { @@ -4328,7 +4540,7 @@ public object Read112_TypeWithXmlDocumentProperty() { return (object)o; } - public object Read113_TypeWithBinaryProperty() { + public object Read117_TypeWithBinaryProperty() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { @@ -4346,7 +4558,7 @@ public object Read113_TypeWithBinaryProperty() { return (object)o; } - public object Read114_Item() { + public object Read118_Item() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { @@ -4364,7 +4576,7 @@ public object Read114_Item() { return (object)o; } - public object Read115_TypeWithTimeSpanProperty() { + public object Read119_TypeWithTimeSpanProperty() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { @@ -4382,7 +4594,7 @@ public object Read115_TypeWithTimeSpanProperty() { return (object)o; } - public object Read116_Item() { + public object Read120_Item() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { @@ -4400,7 +4612,7 @@ public object Read116_Item() { return (object)o; } - public object Read117_TypeWithByteProperty() { + public object Read121_TypeWithByteProperty() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { @@ -4418,7 +4630,7 @@ public object Read117_TypeWithByteProperty() { return (object)o; } - public object Read118_TypeWithXmlNodeArrayProperty() { + public object Read122_TypeWithXmlNodeArrayProperty() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { @@ -4436,7 +4648,7 @@ public object Read118_TypeWithXmlNodeArrayProperty() { return (object)o; } - public object Read119_Animal() { + public object Read123_Animal() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { @@ -4454,7 +4666,7 @@ public object Read119_Animal() { return (object)o; } - public object Read120_Dog() { + public object Read124_Dog() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { @@ -4472,7 +4684,7 @@ public object Read120_Dog() { return (object)o; } - public object Read121_DogBreed() { + public object Read125_DogBreed() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { @@ -4492,7 +4704,7 @@ public object Read121_DogBreed() { return (object)o; } - public object Read122_Group() { + public object Read126_Group() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { @@ -4510,7 +4722,7 @@ public object Read122_Group() { return (object)o; } - public object Read123_Vehicle() { + public object Read127_Vehicle() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { @@ -4528,7 +4740,7 @@ public object Read123_Vehicle() { return (object)o; } - public object Read124_Employee() { + public object Read128_Employee() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { @@ -4546,7 +4758,7 @@ public object Read124_Employee() { return (object)o; } - public object Read125_BaseClass() { + public object Read129_BaseClass() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { @@ -4564,7 +4776,7 @@ public object Read125_BaseClass() { return (object)o; } - public object Read126_DerivedClass() { + public object Read130_DerivedClass() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { @@ -4582,13 +4794,94 @@ public object Read126_DerivedClass() { return (object)o; } - public object Read127_PurchaseOrder() { + public object Read131_SimpleBaseClass() { + object o = null; + Reader.MoveToContent(); + if (Reader.NodeType == System.Xml.XmlNodeType.Element) { + do { + if (((object) Reader.LocalName == (object)id18_SimpleBaseClass && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read20_SimpleBaseClass(true, true); + break; + } + throw CreateUnknownNodeException(); + } while (false); + } + else { + UnknownNode(null, @":SimpleBaseClass"); + } + return (object)o; + } + + public object Read132_SimpleDerivedClass() { + object o = null; + Reader.MoveToContent(); + if (Reader.NodeType == System.Xml.XmlNodeType.Element) { + do { + if (((object) Reader.LocalName == (object)id19_SimpleDerivedClass && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read19_SimpleDerivedClass(true, true); + break; + } + throw CreateUnknownNodeException(); + } while (false); + } + else { + UnknownNode(null, @":SimpleDerivedClass"); + } + return (object)o; + } + + public object Read133_BaseIXmlSerializable() { + object o = null; + Reader.MoveToContent(); + if (Reader.NodeType == System.Xml.XmlNodeType.Element) { + do { + if (((object) Reader.LocalName == (object)id20_BaseIXmlSerializable && (object) Reader.NamespaceURI == (object)id21_Item)) { + System.Xml.XmlQualifiedName tser = GetXsiType(); + if (tser == null || ((object) ((System.Xml.XmlQualifiedName)tser).Name == (object)id20_BaseIXmlSerializable && (object) ((System.Xml.XmlQualifiedName)tser).Namespace == (object)id21_Item)) { + o = (global::XmlSerializableBaseClass)ReadSerializable(( System.Xml.Serialization.IXmlSerializable)new global::XmlSerializableBaseClass()); + } + else if (tser == null || ((object) ((System.Xml.XmlQualifiedName)tser).Name == (object)id22_DerivedIXmlSerializable && (object) ((System.Xml.XmlQualifiedName)tser).Namespace == (object)id21_Item)) { + o = (global::XmlSerializableBaseClass)ReadSerializable(( System.Xml.Serialization.IXmlSerializable)new global::XmlSerializableDerivedClass()); + } + else { + UnknownNode(null); + } + break; + } + throw CreateUnknownNodeException(); + } while (false); + } + else { + UnknownNode(null, @"http://example.com/serializer-test-namespace:BaseIXmlSerializable"); + } + return (object)o; + } + + public object Read134_DerivedIXmlSerializable() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id18_PurchaseOrder && (object) Reader.NamespaceURI == (object)id19_httpwwwcontoso1com)) { - o = Read21_PurchaseOrder(false, true); + if (((object) Reader.LocalName == (object)id22_DerivedIXmlSerializable && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = (global::XmlSerializableDerivedClass)ReadSerializable(( System.Xml.Serialization.IXmlSerializable)new global::XmlSerializableDerivedClass()); + break; + } + throw CreateUnknownNodeException(); + } while (false); + } + else { + UnknownNode(null, @":DerivedIXmlSerializable"); + } + return (object)o; + } + + public object Read135_PurchaseOrder() { + object o = null; + Reader.MoveToContent(); + if (Reader.NodeType == System.Xml.XmlNodeType.Element) { + do { + if (((object) Reader.LocalName == (object)id23_PurchaseOrder && (object) Reader.NamespaceURI == (object)id24_httpwwwcontoso1com)) { + o = Read23_PurchaseOrder(false, true); break; } throw CreateUnknownNodeException(); @@ -4600,13 +4893,13 @@ public object Read127_PurchaseOrder() { return (object)o; } - public object Read128_Address() { + public object Read136_Address() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id20_Address && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read22_Address(true, true); + if (((object) Reader.LocalName == (object)id25_Address && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read24_Address(true, true); break; } throw CreateUnknownNodeException(); @@ -4618,13 +4911,13 @@ public object Read128_Address() { return (object)o; } - public object Read129_OrderedItem() { + public object Read137_OrderedItem() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id21_OrderedItem && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read23_OrderedItem(true, true); + if (((object) Reader.LocalName == (object)id26_OrderedItem && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read25_OrderedItem(true, true); break; } throw CreateUnknownNodeException(); @@ -4636,13 +4929,13 @@ public object Read129_OrderedItem() { return (object)o; } - public object Read130_AliasedTestType() { + public object Read138_AliasedTestType() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id22_AliasedTestType && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read24_AliasedTestType(true, true); + if (((object) Reader.LocalName == (object)id27_AliasedTestType && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read26_AliasedTestType(true, true); break; } throw CreateUnknownNodeException(); @@ -4654,13 +4947,13 @@ public object Read130_AliasedTestType() { return (object)o; } - public object Read131_BaseClass1() { + public object Read139_BaseClass1() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id23_BaseClass1 && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read25_BaseClass1(true, true); + if (((object) Reader.LocalName == (object)id28_BaseClass1 && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read27_BaseClass1(true, true); break; } throw CreateUnknownNodeException(); @@ -4672,13 +4965,13 @@ public object Read131_BaseClass1() { return (object)o; } - public object Read132_DerivedClass1() { + public object Read140_DerivedClass1() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id24_DerivedClass1 && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read26_DerivedClass1(true, true); + if (((object) Reader.LocalName == (object)id29_DerivedClass1 && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read28_DerivedClass1(true, true); break; } throw CreateUnknownNodeException(); @@ -4690,12 +4983,12 @@ public object Read132_DerivedClass1() { return (object)o; } - public object Read133_ArrayOfDateTime() { + public object Read141_ArrayOfDateTime() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id25_ArrayOfDateTime && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id30_ArrayOfDateTime && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { if ((object)(o) == null) o = new global::MyCollection1(); global::MyCollection1 a_0_0 = (global::MyCollection1)o; @@ -4708,7 +5001,7 @@ public object Read133_ArrayOfDateTime() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id26_dateTime && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id31_dateTime && (object) Reader.NamespaceURI == (object)id2_Item)) { { a_0_0.Add(ToDateTime(Reader.ReadElementString())); } @@ -4740,13 +5033,13 @@ public object Read133_ArrayOfDateTime() { return (object)o; } - public object Read134_Orchestra() { + public object Read142_Orchestra() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id27_Orchestra && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read28_Orchestra(true, true); + if (((object) Reader.LocalName == (object)id32_Orchestra && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read30_Orchestra(true, true); break; } throw CreateUnknownNodeException(); @@ -4758,13 +5051,13 @@ public object Read134_Orchestra() { return (object)o; } - public object Read135_Instrument() { + public object Read143_Instrument() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id28_Instrument && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read27_Instrument(true, true); + if (((object) Reader.LocalName == (object)id33_Instrument && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read29_Instrument(true, true); break; } throw CreateUnknownNodeException(); @@ -4776,13 +5069,13 @@ public object Read135_Instrument() { return (object)o; } - public object Read136_Brass() { + public object Read144_Brass() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id29_Brass && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read29_Brass(true, true); + if (((object) Reader.LocalName == (object)id34_Brass && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read31_Brass(true, true); break; } throw CreateUnknownNodeException(); @@ -4794,13 +5087,13 @@ public object Read136_Brass() { return (object)o; } - public object Read137_Trumpet() { + public object Read145_Trumpet() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id30_Trumpet && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read30_Trumpet(true, true); + if (((object) Reader.LocalName == (object)id35_Trumpet && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read32_Trumpet(true, true); break; } throw CreateUnknownNodeException(); @@ -4812,13 +5105,13 @@ public object Read137_Trumpet() { return (object)o; } - public object Read138_Pet() { + public object Read146_Pet() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id31_Pet && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read31_Pet(true, true); + if (((object) Reader.LocalName == (object)id36_Pet && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read33_Pet(true, true); break; } throw CreateUnknownNodeException(); @@ -4830,13 +5123,13 @@ public object Read138_Pet() { return (object)o; } - public object Read139_DefaultValuesSetToNaN() { + public object Read147_DefaultValuesSetToNaN() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id32_DefaultValuesSetToNaN && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read32_DefaultValuesSetToNaN(true, true); + if (((object) Reader.LocalName == (object)id37_DefaultValuesSetToNaN && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read34_DefaultValuesSetToNaN(true, true); break; } throw CreateUnknownNodeException(); @@ -4848,13 +5141,13 @@ public object Read139_DefaultValuesSetToNaN() { return (object)o; } - public object Read140_Item() { + public object Read148_Item() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id33_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read33_Item(true, true); + if (((object) Reader.LocalName == (object)id38_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read35_Item(true, true); break; } throw CreateUnknownNodeException(); @@ -4866,13 +5159,13 @@ public object Read140_Item() { return (object)o; } - public object Read141_Item() { + public object Read149_Item() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id34_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read34_Item(true, true); + if (((object) Reader.LocalName == (object)id39_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read36_Item(true, true); break; } throw CreateUnknownNodeException(); @@ -4884,13 +5177,13 @@ public object Read141_Item() { return (object)o; } - public object Read142_RootElement() { + public object Read150_RootElement() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id35_RootElement && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read35_Item(true, true); + if (((object) Reader.LocalName == (object)id40_RootElement && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read37_Item(true, true); break; } throw CreateUnknownNodeException(); @@ -4902,13 +5195,13 @@ public object Read142_RootElement() { return (object)o; } - public object Read143_TypeWithLinkedProperty() { + public object Read151_TypeWithLinkedProperty() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id36_TypeWithLinkedProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read36_TypeWithLinkedProperty(true, true); + if (((object) Reader.LocalName == (object)id41_TypeWithLinkedProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read38_TypeWithLinkedProperty(true, true); break; } throw CreateUnknownNodeException(); @@ -4920,13 +5213,13 @@ public object Read143_TypeWithLinkedProperty() { return (object)o; } - public object Read144_Document() { + public object Read152_Document() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id37_Document && (object) Reader.NamespaceURI == (object)id38_httpexamplecom)) { - o = Read37_MsgDocumentType(true, true); + if (((object) Reader.LocalName == (object)id42_Document && (object) Reader.NamespaceURI == (object)id43_httpexamplecom)) { + o = Read39_MsgDocumentType(true, true); break; } throw CreateUnknownNodeException(); @@ -4938,13 +5231,13 @@ public object Read144_Document() { return (object)o; } - public object Read145_RootClass() { + public object Read153_RootClass() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id39_RootClass && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read40_RootClass(true, true); + if (((object) Reader.LocalName == (object)id44_RootClass && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read42_RootClass(true, true); break; } throw CreateUnknownNodeException(); @@ -4956,13 +5249,13 @@ public object Read145_RootClass() { return (object)o; } - public object Read146_Parameter() { + public object Read154_Parameter() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id40_Parameter && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read39_Parameter(true, true); + if (((object) Reader.LocalName == (object)id45_Parameter && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read41_Parameter(true, true); break; } throw CreateUnknownNodeException(); @@ -4974,13 +5267,13 @@ public object Read146_Parameter() { return (object)o; } - public object Read147_XElementWrapper() { + public object Read155_XElementWrapper() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id41_XElementWrapper && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read41_XElementWrapper(true, true); + if (((object) Reader.LocalName == (object)id46_XElementWrapper && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read43_XElementWrapper(true, true); break; } throw CreateUnknownNodeException(); @@ -4992,13 +5285,13 @@ public object Read147_XElementWrapper() { return (object)o; } - public object Read148_XElementStruct() { + public object Read156_XElementStruct() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id42_XElementStruct && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read42_XElementStruct(true); + if (((object) Reader.LocalName == (object)id47_XElementStruct && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read44_XElementStruct(true); break; } throw CreateUnknownNodeException(); @@ -5010,13 +5303,13 @@ public object Read148_XElementStruct() { return (object)o; } - public object Read149_XElementArrayWrapper() { + public object Read157_XElementArrayWrapper() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id43_XElementArrayWrapper && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read43_XElementArrayWrapper(true, true); + if (((object) Reader.LocalName == (object)id48_XElementArrayWrapper && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read45_XElementArrayWrapper(true, true); break; } throw CreateUnknownNodeException(); @@ -5028,13 +5321,13 @@ public object Read149_XElementArrayWrapper() { return (object)o; } - public object Read150_TypeWithDateTimeStringProperty() { + public object Read158_TypeWithDateTimeStringProperty() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id44_TypeWithDateTimeStringProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read44_TypeWithDateTimeStringProperty(true, true); + if (((object) Reader.LocalName == (object)id49_TypeWithDateTimeStringProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read46_TypeWithDateTimeStringProperty(true, true); break; } throw CreateUnknownNodeException(); @@ -5046,13 +5339,13 @@ public object Read150_TypeWithDateTimeStringProperty() { return (object)o; } - public object Read151_SimpleType() { + public object Read159_SimpleType() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id45_SimpleType && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read45_SimpleType(true, true); + if (((object) Reader.LocalName == (object)id50_SimpleType && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read47_SimpleType(true, true); break; } throw CreateUnknownNodeException(); @@ -5064,13 +5357,13 @@ public object Read151_SimpleType() { return (object)o; } - public object Read152_TypeWithGetSetArrayMembers() { + public object Read160_TypeWithGetSetArrayMembers() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id46_TypeWithGetSetArrayMembers && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read46_TypeWithGetSetArrayMembers(true, true); + if (((object) Reader.LocalName == (object)id51_TypeWithGetSetArrayMembers && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read48_TypeWithGetSetArrayMembers(true, true); break; } throw CreateUnknownNodeException(); @@ -5082,13 +5375,13 @@ public object Read152_TypeWithGetSetArrayMembers() { return (object)o; } - public object Read153_TypeWithGetOnlyArrayProperties() { + public object Read161_TypeWithGetOnlyArrayProperties() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id47_TypeWithGetOnlyArrayProperties && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read47_TypeWithGetOnlyArrayProperties(true, true); + if (((object) Reader.LocalName == (object)id52_TypeWithGetOnlyArrayProperties && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read49_TypeWithGetOnlyArrayProperties(true, true); break; } throw CreateUnknownNodeException(); @@ -5100,13 +5393,13 @@ public object Read153_TypeWithGetOnlyArrayProperties() { return (object)o; } - public object Read154_StructNotSerializable() { + public object Read162_StructNotSerializable() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id48_StructNotSerializable && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read48_StructNotSerializable(true); + if (((object) Reader.LocalName == (object)id53_StructNotSerializable && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read50_StructNotSerializable(true); break; } throw CreateUnknownNodeException(); @@ -5118,13 +5411,13 @@ public object Read154_StructNotSerializable() { return (object)o; } - public object Read155_TypeWithMyCollectionField() { + public object Read163_TypeWithMyCollectionField() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id49_TypeWithMyCollectionField && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read49_TypeWithMyCollectionField(true, true); + if (((object) Reader.LocalName == (object)id54_TypeWithMyCollectionField && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read51_TypeWithMyCollectionField(true, true); break; } throw CreateUnknownNodeException(); @@ -5136,13 +5429,13 @@ public object Read155_TypeWithMyCollectionField() { return (object)o; } - public object Read156_Item() { + public object Read164_Item() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id50_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read50_Item(true, true); + if (((object) Reader.LocalName == (object)id55_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read52_Item(true, true); break; } throw CreateUnknownNodeException(); @@ -5154,12 +5447,12 @@ public object Read156_Item() { return (object)o; } - public object Read157_ArrayOfAnyType() { + public object Read165_ArrayOfAnyType() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id51_ArrayOfAnyType && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id56_ArrayOfAnyType && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { if ((object)(o) == null) o = new global::SerializationTypes.MyList(); global::SerializationTypes.MyList a_0_0 = (global::SerializationTypes.MyList)o; @@ -5172,7 +5465,7 @@ public object Read157_ArrayOfAnyType() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id52_anyType && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id57_anyType && (object) Reader.NamespaceURI == (object)id2_Item)) { if ((object)(a_0_0) == null) Reader.Skip(); else a_0_0.Add(Read1_Object(true, true)); break; } @@ -5202,14 +5495,14 @@ public object Read157_ArrayOfAnyType() { return (object)o; } - public object Read158_MyEnum() { + public object Read166_MyEnum() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id53_MyEnum && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id58_MyEnum && (object) Reader.NamespaceURI == (object)id2_Item)) { { - o = Read51_MyEnum(Reader.ReadElementString()); + o = Read53_MyEnum(Reader.ReadElementString()); } break; } @@ -5222,13 +5515,13 @@ public object Read158_MyEnum() { return (object)o; } - public object Read159_TypeWithEnumMembers() { + public object Read167_TypeWithEnumMembers() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id54_TypeWithEnumMembers && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read52_TypeWithEnumMembers(true, true); + if (((object) Reader.LocalName == (object)id59_TypeWithEnumMembers && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read54_TypeWithEnumMembers(true, true); break; } throw CreateUnknownNodeException(); @@ -5240,13 +5533,13 @@ public object Read159_TypeWithEnumMembers() { return (object)o; } - public object Read160_DCStruct() { + public object Read168_DCStruct() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id55_DCStruct && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read53_DCStruct(true); + if (((object) Reader.LocalName == (object)id60_DCStruct && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read55_DCStruct(true); break; } throw CreateUnknownNodeException(); @@ -5258,13 +5551,13 @@ public object Read160_DCStruct() { return (object)o; } - public object Read161_DCClassWithEnumAndStruct() { + public object Read169_DCClassWithEnumAndStruct() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id56_DCClassWithEnumAndStruct && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read54_DCClassWithEnumAndStruct(true, true); + if (((object) Reader.LocalName == (object)id61_DCClassWithEnumAndStruct && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read56_DCClassWithEnumAndStruct(true, true); break; } throw CreateUnknownNodeException(); @@ -5276,13 +5569,13 @@ public object Read161_DCClassWithEnumAndStruct() { return (object)o; } - public object Read162_BuiltInTypes() { + public object Read170_BuiltInTypes() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id57_BuiltInTypes && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read55_BuiltInTypes(true, true); + if (((object) Reader.LocalName == (object)id62_BuiltInTypes && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read57_BuiltInTypes(true, true); break; } throw CreateUnknownNodeException(); @@ -5294,13 +5587,13 @@ public object Read162_BuiltInTypes() { return (object)o; } - public object Read163_TypeA() { + public object Read171_TypeA() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id58_TypeA && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read56_TypeA(true, true); + if (((object) Reader.LocalName == (object)id63_TypeA && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read58_TypeA(true, true); break; } throw CreateUnknownNodeException(); @@ -5312,13 +5605,13 @@ public object Read163_TypeA() { return (object)o; } - public object Read164_TypeB() { + public object Read172_TypeB() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id59_TypeB && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read57_TypeB(true, true); + if (((object) Reader.LocalName == (object)id64_TypeB && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read59_TypeB(true, true); break; } throw CreateUnknownNodeException(); @@ -5330,13 +5623,13 @@ public object Read164_TypeB() { return (object)o; } - public object Read165_TypeHasArrayOfASerializedAsB() { + public object Read173_TypeHasArrayOfASerializedAsB() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id60_TypeHasArrayOfASerializedAsB && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read58_TypeHasArrayOfASerializedAsB(true, true); + if (((object) Reader.LocalName == (object)id65_TypeHasArrayOfASerializedAsB && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read60_TypeHasArrayOfASerializedAsB(true, true); break; } throw CreateUnknownNodeException(); @@ -5348,13 +5641,13 @@ public object Read165_TypeHasArrayOfASerializedAsB() { return (object)o; } - public object Read166_Item() { + public object Read174_Item() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id61_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read59_Item(true, true); + if (((object) Reader.LocalName == (object)id66_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read61_Item(true, true); break; } throw CreateUnknownNodeException(); @@ -5366,13 +5659,13 @@ public object Read166_Item() { return (object)o; } - public object Read167_BaseClassWithSamePropertyName() { + public object Read175_BaseClassWithSamePropertyName() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id62_BaseClassWithSamePropertyName && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read60_BaseClassWithSamePropertyName(true, true); + if (((object) Reader.LocalName == (object)id67_BaseClassWithSamePropertyName && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read62_BaseClassWithSamePropertyName(true, true); break; } throw CreateUnknownNodeException(); @@ -5384,13 +5677,13 @@ public object Read167_BaseClassWithSamePropertyName() { return (object)o; } - public object Read168_DerivedClassWithSameProperty() { + public object Read176_DerivedClassWithSameProperty() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id63_DerivedClassWithSameProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read61_DerivedClassWithSameProperty(true, true); + if (((object) Reader.LocalName == (object)id68_DerivedClassWithSameProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read63_DerivedClassWithSameProperty(true, true); break; } throw CreateUnknownNodeException(); @@ -5402,13 +5695,13 @@ public object Read168_DerivedClassWithSameProperty() { return (object)o; } - public object Read169_DerivedClassWithSameProperty2() { + public object Read177_DerivedClassWithSameProperty2() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id64_DerivedClassWithSameProperty2 && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read62_DerivedClassWithSameProperty2(true, true); + if (((object) Reader.LocalName == (object)id69_DerivedClassWithSameProperty2 && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read64_DerivedClassWithSameProperty2(true, true); break; } throw CreateUnknownNodeException(); @@ -5420,13 +5713,13 @@ public object Read169_DerivedClassWithSameProperty2() { return (object)o; } - public object Read170_Item() { + public object Read178_Item() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id65_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read63_Item(true, true); + if (((object) Reader.LocalName == (object)id70_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read65_Item(true, true); break; } throw CreateUnknownNodeException(); @@ -5438,13 +5731,13 @@ public object Read170_Item() { return (object)o; } - public object Read171_TypeWithByteArrayAsXmlText() { + public object Read179_TypeWithByteArrayAsXmlText() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id66_TypeWithByteArrayAsXmlText && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read64_TypeWithByteArrayAsXmlText(true, true); + if (((object) Reader.LocalName == (object)id71_TypeWithByteArrayAsXmlText && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read66_TypeWithByteArrayAsXmlText(true, true); break; } throw CreateUnknownNodeException(); @@ -5456,13 +5749,13 @@ public object Read171_TypeWithByteArrayAsXmlText() { return (object)o; } - public object Read172_SimpleDC() { + public object Read180_SimpleDC() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id67_SimpleDC && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read65_SimpleDC(true, true); + if (((object) Reader.LocalName == (object)id72_SimpleDC && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read67_SimpleDC(true, true); break; } throw CreateUnknownNodeException(); @@ -5474,13 +5767,13 @@ public object Read172_SimpleDC() { return (object)o; } - public object Read173_Item() { + public object Read181_Item() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id68_Item && (object) Reader.NamespaceURI == (object)id69_Item)) { - o = Read66_Item(false, true); + if (((object) Reader.LocalName == (object)id73_Item && (object) Reader.NamespaceURI == (object)id74_Item)) { + o = Read68_Item(false, true); break; } throw CreateUnknownNodeException(); @@ -5492,14 +5785,14 @@ public object Read173_Item() { return (object)o; } - public object Read174_EnumFlags() { + public object Read182_EnumFlags() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id70_EnumFlags && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id75_EnumFlags && (object) Reader.NamespaceURI == (object)id2_Item)) { { - o = Read67_EnumFlags(Reader.ReadElementString()); + o = Read69_EnumFlags(Reader.ReadElementString()); } break; } @@ -5512,13 +5805,13 @@ public object Read174_EnumFlags() { return (object)o; } - public object Read175_ClassImplementsInterface() { + public object Read183_ClassImplementsInterface() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id71_ClassImplementsInterface && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read68_ClassImplementsInterface(true, true); + if (((object) Reader.LocalName == (object)id76_ClassImplementsInterface && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read70_ClassImplementsInterface(true, true); break; } throw CreateUnknownNodeException(); @@ -5530,13 +5823,13 @@ public object Read175_ClassImplementsInterface() { return (object)o; } - public object Read176_WithStruct() { + public object Read184_WithStruct() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id72_WithStruct && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read70_WithStruct(true, true); + if (((object) Reader.LocalName == (object)id77_WithStruct && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read72_WithStruct(true, true); break; } throw CreateUnknownNodeException(); @@ -5548,13 +5841,13 @@ public object Read176_WithStruct() { return (object)o; } - public object Read177_SomeStruct() { + public object Read185_SomeStruct() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id73_SomeStruct && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read69_SomeStruct(true); + if (((object) Reader.LocalName == (object)id78_SomeStruct && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read71_SomeStruct(true); break; } throw CreateUnknownNodeException(); @@ -5566,13 +5859,13 @@ public object Read177_SomeStruct() { return (object)o; } - public object Read178_WithEnums() { + public object Read186_WithEnums() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id74_WithEnums && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read73_WithEnums(true, true); + if (((object) Reader.LocalName == (object)id79_WithEnums && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read75_WithEnums(true, true); break; } throw CreateUnknownNodeException(); @@ -5584,13 +5877,13 @@ public object Read178_WithEnums() { return (object)o; } - public object Read179_WithNullables() { + public object Read187_WithNullables() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id75_WithNullables && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read77_WithNullables(true, true); + if (((object) Reader.LocalName == (object)id80_WithNullables && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read79_WithNullables(true, true); break; } throw CreateUnknownNodeException(); @@ -5602,14 +5895,14 @@ public object Read179_WithNullables() { return (object)o; } - public object Read180_ByteEnum() { + public object Read188_ByteEnum() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id76_ByteEnum && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id81_ByteEnum && (object) Reader.NamespaceURI == (object)id2_Item)) { { - o = Read78_ByteEnum(Reader.ReadElementString()); + o = Read80_ByteEnum(Reader.ReadElementString()); } break; } @@ -5622,14 +5915,14 @@ public object Read180_ByteEnum() { return (object)o; } - public object Read181_SByteEnum() { + public object Read189_SByteEnum() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id77_SByteEnum && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id82_SByteEnum && (object) Reader.NamespaceURI == (object)id2_Item)) { { - o = Read79_SByteEnum(Reader.ReadElementString()); + o = Read81_SByteEnum(Reader.ReadElementString()); } break; } @@ -5642,14 +5935,14 @@ public object Read181_SByteEnum() { return (object)o; } - public object Read182_ShortEnum() { + public object Read190_ShortEnum() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id78_ShortEnum && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id83_ShortEnum && (object) Reader.NamespaceURI == (object)id2_Item)) { { - o = Read72_ShortEnum(Reader.ReadElementString()); + o = Read74_ShortEnum(Reader.ReadElementString()); } break; } @@ -5662,14 +5955,14 @@ public object Read182_ShortEnum() { return (object)o; } - public object Read183_IntEnum() { + public object Read191_IntEnum() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id79_IntEnum && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id84_IntEnum && (object) Reader.NamespaceURI == (object)id2_Item)) { { - o = Read71_IntEnum(Reader.ReadElementString()); + o = Read73_IntEnum(Reader.ReadElementString()); } break; } @@ -5682,14 +5975,14 @@ public object Read183_IntEnum() { return (object)o; } - public object Read184_UIntEnum() { + public object Read192_UIntEnum() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id80_UIntEnum && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id85_UIntEnum && (object) Reader.NamespaceURI == (object)id2_Item)) { { - o = Read80_UIntEnum(Reader.ReadElementString()); + o = Read82_UIntEnum(Reader.ReadElementString()); } break; } @@ -5702,14 +5995,14 @@ public object Read184_UIntEnum() { return (object)o; } - public object Read185_LongEnum() { + public object Read193_LongEnum() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id81_LongEnum && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id86_LongEnum && (object) Reader.NamespaceURI == (object)id2_Item)) { { - o = Read81_LongEnum(Reader.ReadElementString()); + o = Read83_LongEnum(Reader.ReadElementString()); } break; } @@ -5722,14 +6015,14 @@ public object Read185_LongEnum() { return (object)o; } - public object Read186_ULongEnum() { + public object Read194_ULongEnum() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id82_ULongEnum && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id87_ULongEnum && (object) Reader.NamespaceURI == (object)id2_Item)) { { - o = Read82_ULongEnum(Reader.ReadElementString()); + o = Read84_ULongEnum(Reader.ReadElementString()); } break; } @@ -5742,13 +6035,13 @@ public object Read186_ULongEnum() { return (object)o; } - public object Read187_AttributeTesting() { + public object Read195_AttributeTesting() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id83_AttributeTesting && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read84_XmlSerializerAttributes(false, true); + if (((object) Reader.LocalName == (object)id88_AttributeTesting && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read86_XmlSerializerAttributes(false, true); break; } throw CreateUnknownNodeException(); @@ -5760,14 +6053,14 @@ public object Read187_AttributeTesting() { return (object)o; } - public object Read188_ItemChoiceType() { + public object Read196_ItemChoiceType() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id84_ItemChoiceType && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id89_ItemChoiceType && (object) Reader.NamespaceURI == (object)id2_Item)) { { - o = Read83_ItemChoiceType(Reader.ReadElementString()); + o = Read85_ItemChoiceType(Reader.ReadElementString()); } break; } @@ -5780,13 +6073,13 @@ public object Read188_ItemChoiceType() { return (object)o; } - public object Read189_TypeWithAnyAttribute() { + public object Read197_TypeWithAnyAttribute() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id85_TypeWithAnyAttribute && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read85_TypeWithAnyAttribute(true, true); + if (((object) Reader.LocalName == (object)id90_TypeWithAnyAttribute && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read87_TypeWithAnyAttribute(true, true); break; } throw CreateUnknownNodeException(); @@ -5798,13 +6091,13 @@ public object Read189_TypeWithAnyAttribute() { return (object)o; } - public object Read190_KnownTypesThroughConstructor() { + public object Read198_KnownTypesThroughConstructor() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id86_KnownTypesThroughConstructor && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read86_KnownTypesThroughConstructor(true, true); + if (((object) Reader.LocalName == (object)id91_KnownTypesThroughConstructor && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read88_KnownTypesThroughConstructor(true, true); break; } throw CreateUnknownNodeException(); @@ -5816,13 +6109,13 @@ public object Read190_KnownTypesThroughConstructor() { return (object)o; } - public object Read191_SimpleKnownTypeValue() { + public object Read199_SimpleKnownTypeValue() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id87_SimpleKnownTypeValue && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read87_SimpleKnownTypeValue(true, true); + if (((object) Reader.LocalName == (object)id92_SimpleKnownTypeValue && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read89_SimpleKnownTypeValue(true, true); break; } throw CreateUnknownNodeException(); @@ -5834,31 +6127,31 @@ public object Read191_SimpleKnownTypeValue() { return (object)o; } - public object Read192_Item() { + public object Read200_Item() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id88_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = (global::SerializationTypes.ClassImplementingIXmlSerialiable)ReadSerializable(( System.Xml.Serialization.IXmlSerializable)new global::SerializationTypes.ClassImplementingIXmlSerialiable()); + if (((object) Reader.LocalName == (object)id93_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = (global::SerializationTypes.ClassImplementingIXmlSerializable)ReadSerializable(( System.Xml.Serialization.IXmlSerializable)new global::SerializationTypes.ClassImplementingIXmlSerializable()); break; } throw CreateUnknownNodeException(); } while (false); } else { - UnknownNode(null, @":ClassImplementingIXmlSerialiable"); + UnknownNode(null, @":ClassImplementingIXmlSerializable"); } return (object)o; } - public object Read193_TypeWithPropertyNameSpecified() { + public object Read201_TypeWithPropertyNameSpecified() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id89_TypeWithPropertyNameSpecified && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read88_TypeWithPropertyNameSpecified(true, true); + if (((object) Reader.LocalName == (object)id94_TypeWithPropertyNameSpecified && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read90_TypeWithPropertyNameSpecified(true, true); break; } throw CreateUnknownNodeException(); @@ -5870,13 +6163,13 @@ public object Read193_TypeWithPropertyNameSpecified() { return (object)o; } - public object Read194_TypeWithXmlSchemaFormAttribute() { + public object Read202_TypeWithXmlSchemaFormAttribute() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id90_TypeWithXmlSchemaFormAttribute && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read89_TypeWithXmlSchemaFormAttribute(true, true); + if (((object) Reader.LocalName == (object)id95_TypeWithXmlSchemaFormAttribute && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read91_TypeWithXmlSchemaFormAttribute(true, true); break; } throw CreateUnknownNodeException(); @@ -5888,13 +6181,13 @@ public object Read194_TypeWithXmlSchemaFormAttribute() { return (object)o; } - public object Read195_MyXmlType() { + public object Read203_MyXmlType() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id91_MyXmlType && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read90_Item(true, true); + if (((object) Reader.LocalName == (object)id96_MyXmlType && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read92_Item(true, true); break; } throw CreateUnknownNodeException(); @@ -5906,13 +6199,13 @@ public object Read195_MyXmlType() { return (object)o; } - public object Read196_Item() { + public object Read204_Item() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id92_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read91_Item(true, true); + if (((object) Reader.LocalName == (object)id97_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read93_Item(true, true); break; } throw CreateUnknownNodeException(); @@ -5924,157 +6217,205 @@ public object Read196_Item() { return (object)o; } - public object Read197_Item() { + public object Read205_CustomDocument() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id93_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read92_Item(true, true); + if (((object) Reader.LocalName == (object)id98_CustomDocument && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read95_CustomDocument(true, true); break; } throw CreateUnknownNodeException(); } while (false); } else { - UnknownNode(null, @":TypeWithNonPublicDefaultConstructor"); + UnknownNode(null, @":CustomDocument"); } return (object)o; } - public object Read198_ServerSettings() { + public object Read206_CustomElement() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id94_ServerSettings && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read93_ServerSettings(true, true); + if (((object) Reader.LocalName == (object)id99_CustomElement && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read94_CustomElement(true, true); break; } throw CreateUnknownNodeException(); } while (false); } else { - UnknownNode(null, @":ServerSettings"); + UnknownNode(null, @":CustomElement"); } return (object)o; } - public object Read199_TypeWithXmlQualifiedName() { + public object Read207_Item() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { - do { - if (((object) Reader.LocalName == (object)id95_TypeWithXmlQualifiedName && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read94_TypeWithXmlQualifiedName(true, true); - break; - } - throw CreateUnknownNodeException(); - } while (false); + o = (global::SerializationTypes.CustomAttribute)ReadXmlNode(false); } else { - UnknownNode(null, @":TypeWithXmlQualifiedName"); + UnknownNode(null, @""); } return (object)o; } - public object Read200_TypeWith2DArrayProperty2() { + public object Read208_Item() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id96_TypeWith2DArrayProperty2 && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read95_TypeWith2DArrayProperty2(true, true); + if (((object) Reader.LocalName == (object)id100_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read96_Item(true, true); break; } throw CreateUnknownNodeException(); } while (false); } else { - UnknownNode(null, @":TypeWith2DArrayProperty2"); + UnknownNode(null, @":TypeWithNonPublicDefaultConstructor"); } return (object)o; } - public object Read201_Item() { + public object Read209_ServerSettings() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id97_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read96_Item(true, true); + if (((object) Reader.LocalName == (object)id101_ServerSettings && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read97_ServerSettings(true, true); break; } throw CreateUnknownNodeException(); } while (false); } else { - UnknownNode(null, @":TypeWithPropertiesHavingDefaultValue"); + UnknownNode(null, @":ServerSettings"); } return (object)o; } - public object Read202_Item() { + public object Read210_TypeWithXmlQualifiedName() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id98_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read97_Item(true, true); + if (((object) Reader.LocalName == (object)id102_TypeWithXmlQualifiedName && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read98_TypeWithXmlQualifiedName(true, true); break; } throw CreateUnknownNodeException(); } while (false); } else { - UnknownNode(null, @":TypeWithEnumPropertyHavingDefaultValue"); + UnknownNode(null, @":TypeWithXmlQualifiedName"); } return (object)o; } - public object Read203_Item() { + public object Read211_TypeWith2DArrayProperty2() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id99_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read98_Item(true, true); + if (((object) Reader.LocalName == (object)id103_TypeWith2DArrayProperty2 && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read99_TypeWith2DArrayProperty2(true, true); break; } throw CreateUnknownNodeException(); } while (false); } else { - UnknownNode(null, @":TypeWithEnumFlagPropertyHavingDefaultValue"); + UnknownNode(null, @":TypeWith2DArrayProperty2"); } return (object)o; } - public object Read204_TypeWithShouldSerializeMethod() { + public object Read212_Item() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id100_TypeWithShouldSerializeMethod && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read99_TypeWithShouldSerializeMethod(true, true); + if (((object) Reader.LocalName == (object)id104_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read100_Item(true, true); break; } throw CreateUnknownNodeException(); } while (false); } else { - UnknownNode(null, @":TypeWithShouldSerializeMethod"); + UnknownNode(null, @":TypeWithPropertiesHavingDefaultValue"); } return (object)o; } - public object Read205_Item() { + public object Read213_Item() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id101_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read100_Item(true, true); + if (((object) Reader.LocalName == (object)id105_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read101_Item(true, true); + break; + } + throw CreateUnknownNodeException(); + } while (false); + } + else { + UnknownNode(null, @":TypeWithEnumPropertyHavingDefaultValue"); + } + return (object)o; + } + + public object Read214_Item() { + object o = null; + Reader.MoveToContent(); + if (Reader.NodeType == System.Xml.XmlNodeType.Element) { + do { + if (((object) Reader.LocalName == (object)id106_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read102_Item(true, true); + break; + } + throw CreateUnknownNodeException(); + } while (false); + } + else { + UnknownNode(null, @":TypeWithEnumFlagPropertyHavingDefaultValue"); + } + return (object)o; + } + + public object Read215_TypeWithShouldSerializeMethod() { + object o = null; + Reader.MoveToContent(); + if (Reader.NodeType == System.Xml.XmlNodeType.Element) { + do { + if (((object) Reader.LocalName == (object)id107_TypeWithShouldSerializeMethod && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read103_TypeWithShouldSerializeMethod(true, true); + break; + } + throw CreateUnknownNodeException(); + } while (false); + } + else { + UnknownNode(null, @":TypeWithShouldSerializeMethod"); + } + return (object)o; + } + + public object Read216_Item() { + object o = null; + Reader.MoveToContent(); + if (Reader.NodeType == System.Xml.XmlNodeType.Element) { + do { + if (((object) Reader.LocalName == (object)id108_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read104_Item(true, true); break; } throw CreateUnknownNodeException(); @@ -6086,13 +6427,13 @@ public object Read205_Item() { return (object)o; } - public object Read206_Item() { + public object Read217_Item() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id102_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read101_Item(true, true); + if (((object) Reader.LocalName == (object)id109_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read105_Item(true, true); break; } throw CreateUnknownNodeException(); @@ -6104,13 +6445,13 @@ public object Read206_Item() { return (object)o; } - public object Read207_Item() { + public object Read218_Item() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id103_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read102_Item(true, true); + if (((object) Reader.LocalName == (object)id110_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read106_Item(true, true); break; } throw CreateUnknownNodeException(); @@ -6122,13 +6463,13 @@ public object Read207_Item() { return (object)o; } - public object Read208_Item() { + public object Read219_Item() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id104_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read104_Item(true, true); + if (((object) Reader.LocalName == (object)id111_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read108_Item(true, true); break; } throw CreateUnknownNodeException(); @@ -6140,14 +6481,14 @@ public object Read208_Item() { return (object)o; } - public object Read209_MoreChoices() { + public object Read220_MoreChoices() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id105_MoreChoices && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id112_MoreChoices && (object) Reader.NamespaceURI == (object)id2_Item)) { { - o = Read103_MoreChoices(Reader.ReadElementString()); + o = Read107_MoreChoices(Reader.ReadElementString()); } break; } @@ -6160,13 +6501,13 @@ public object Read209_MoreChoices() { return (object)o; } - public object Read210_TypeWithFieldsOrdered() { + public object Read221_TypeWithFieldsOrdered() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id106_TypeWithFieldsOrdered && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read105_TypeWithFieldsOrdered(true, true); + if (((object) Reader.LocalName == (object)id113_TypeWithFieldsOrdered && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read109_TypeWithFieldsOrdered(true, true); break; } throw CreateUnknownNodeException(); @@ -6178,13 +6519,13 @@ public object Read210_TypeWithFieldsOrdered() { return (object)o; } - public object Read211_Item() { + public object Read222_Item() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id107_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read106_Item(true, true); + if (((object) Reader.LocalName == (object)id114_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read110_Item(true, true); break; } throw CreateUnknownNodeException(); @@ -6196,13 +6537,13 @@ public object Read211_Item() { return (object)o; } - public object Read212_Root() { + public object Read223_Root() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id108_Root && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read109_Item(true, true); + if (((object) Reader.LocalName == (object)id115_Root && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read113_Item(true, true); break; } throw CreateUnknownNodeException(); @@ -6214,13 +6555,13 @@ public object Read212_Root() { return (object)o; } - public object Read213_TypeClashB() { + public object Read224_TypeClashB() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id109_TypeClashB && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read108_TypeNameClash(true, true); + if (((object) Reader.LocalName == (object)id116_TypeClashB && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read112_TypeNameClash(true, true); break; } throw CreateUnknownNodeException(); @@ -6232,13 +6573,13 @@ public object Read213_TypeClashB() { return (object)o; } - public object Read214_TypeClashA() { + public object Read225_TypeClashA() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id110_TypeClashA && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read107_TypeNameClash(true, true); + if (((object) Reader.LocalName == (object)id117_TypeClashA && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read111_TypeNameClash(true, true); break; } throw CreateUnknownNodeException(); @@ -6250,13 +6591,13 @@ public object Read214_TypeClashA() { return (object)o; } - public object Read215_Person() { + public object Read226_Person() { object o = null; Reader.MoveToContent(); if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id111_Person && (object) Reader.NamespaceURI == (object)id2_Item)) { - o = Read110_Person(true, true); + if (((object) Reader.LocalName == (object)id118_Person && (object) Reader.NamespaceURI == (object)id2_Item)) { + o = Read114_Person(true, true); break; } throw CreateUnknownNodeException(); @@ -6268,12 +6609,12 @@ public object Read215_Person() { return (object)o; } - global::Outer.Person Read110_Person(bool isNullable, bool checkType) { + global::Outer.Person Read114_Person(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id111_Person && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id118_Person && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -6298,21 +6639,21 @@ public object Read215_Person() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id112_FirstName && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id119_FirstName && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@FirstName = Reader.ReadElementString(); } paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id113_MiddleName && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id120_MiddleName && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@MiddleName = Reader.ReadElementString(); } paramsRead[1] = true; break; } - if (!paramsRead[2] && ((object) Reader.LocalName == (object)id114_LastName && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[2] && ((object) Reader.LocalName == (object)id121_LastName && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@LastName = Reader.ReadElementString(); } @@ -6331,12 +6672,12 @@ public object Read215_Person() { return o; } - global::SerializationTypes.TypeNameClashA.TypeNameClash Read107_TypeNameClash(bool isNullable, bool checkType) { + global::SerializationTypes.TypeNameClashA.TypeNameClash Read111_TypeNameClash(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id110_TypeClashA && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id117_TypeClashA && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -6361,7 +6702,7 @@ public object Read215_Person() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id115_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id122_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Name = Reader.ReadElementString(); } @@ -6380,12 +6721,12 @@ public object Read215_Person() { return o; } - global::SerializationTypes.TypeNameClashB.TypeNameClash Read108_TypeNameClash(bool isNullable, bool checkType) { + global::SerializationTypes.TypeNameClashB.TypeNameClash Read112_TypeNameClash(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id109_TypeClashB && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id116_TypeClashB && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -6410,7 +6751,7 @@ public object Read215_Person() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id115_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id122_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Name = Reader.ReadElementString(); } @@ -6429,12 +6770,12 @@ public object Read215_Person() { return o; } - global::SerializationTypes.NamespaceTypeNameClashContainer Read109_Item(bool isNullable, bool checkType) { + global::SerializationTypes.NamespaceTypeNameClashContainer Read113_Item(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id116_ContainerType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id123_ContainerType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -6465,12 +6806,12 @@ public object Read215_Person() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id117_A && (object) Reader.NamespaceURI == (object)id2_Item)) { - a_0 = (global::SerializationTypes.TypeNameClashA.TypeNameClash[])EnsureArrayIndex(a_0, ca_0, typeof(global::SerializationTypes.TypeNameClashA.TypeNameClash));a_0[ca_0++] = Read107_TypeNameClash(false, true); + if (((object) Reader.LocalName == (object)id124_A && (object) Reader.NamespaceURI == (object)id2_Item)) { + a_0 = (global::SerializationTypes.TypeNameClashA.TypeNameClash[])EnsureArrayIndex(a_0, ca_0, typeof(global::SerializationTypes.TypeNameClashA.TypeNameClash));a_0[ca_0++] = Read111_TypeNameClash(false, true); break; } - if (((object) Reader.LocalName == (object)id118_B && (object) Reader.NamespaceURI == (object)id2_Item)) { - a_1 = (global::SerializationTypes.TypeNameClashB.TypeNameClash[])EnsureArrayIndex(a_1, ca_1, typeof(global::SerializationTypes.TypeNameClashB.TypeNameClash));a_1[ca_1++] = Read108_TypeNameClash(false, true); + if (((object) Reader.LocalName == (object)id125_B && (object) Reader.NamespaceURI == (object)id2_Item)) { + a_1 = (global::SerializationTypes.TypeNameClashB.TypeNameClash[])EnsureArrayIndex(a_1, ca_1, typeof(global::SerializationTypes.TypeNameClashB.TypeNameClash));a_1[ca_1++] = Read112_TypeNameClash(false, true); break; } UnknownNode((object)o, @":A, :B"); @@ -6487,12 +6828,12 @@ public object Read215_Person() { return o; } - global::SerializationTypes.TypeWithKnownTypesOfCollectionsWithConflictingXmlName Read106_Item(bool isNullable, bool checkType) { + global::SerializationTypes.TypeWithKnownTypesOfCollectionsWithConflictingXmlName Read110_Item(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id107_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id114_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -6517,12 +6858,12 @@ public object Read215_Person() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id119_Value1 && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id126_Value1 && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@Value1 = Read1_Object(false, true); paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id120_Value2 && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id127_Value2 && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@Value2 = Read1_Object(false, true); paramsRead[1] = true; break; @@ -6552,160 +6893,168 @@ public object Read215_Person() { return ReadTypedPrimitive(new System.Xml.XmlQualifiedName("anyType", "http://www.w3.org/2001/XMLSchema")); } else { - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id111_Person && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read110_Person(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id116_ContainerType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read109_Item(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id109_TypeClashB && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read108_TypeNameClash(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id110_TypeClashA && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read107_TypeNameClash(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id107_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id118_Person && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read114_Person(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id123_ContainerType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read113_Item(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id116_TypeClashB && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read112_TypeNameClash(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id117_TypeClashA && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read111_TypeNameClash(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id114_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read110_Item(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id113_TypeWithFieldsOrdered && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read109_TypeWithFieldsOrdered(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id111_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read108_Item(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id110_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) return Read106_Item(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id106_TypeWithFieldsOrdered && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read105_TypeWithFieldsOrdered(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id104_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id109_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read105_Item(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id108_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) return Read104_Item(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id103_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id107_TypeWithShouldSerializeMethod && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read103_TypeWithShouldSerializeMethod(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id106_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) return Read102_Item(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id102_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id105_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) return Read101_Item(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id101_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id104_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) return Read100_Item(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id100_TypeWithShouldSerializeMethod && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read99_TypeWithShouldSerializeMethod(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id99_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read98_Item(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id98_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read97_Item(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id97_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id103_TypeWith2DArrayProperty2 && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read99_TypeWith2DArrayProperty2(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id102_TypeWithXmlQualifiedName && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read98_TypeWithXmlQualifiedName(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id101_ServerSettings && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read97_ServerSettings(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id100_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) return Read96_Item(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id96_TypeWith2DArrayProperty2 && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read95_TypeWith2DArrayProperty2(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id95_TypeWithXmlQualifiedName && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read94_TypeWithXmlQualifiedName(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id94_ServerSettings && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read93_ServerSettings(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id93_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id98_CustomDocument && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read95_CustomDocument(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id99_CustomElement && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read94_CustomElement(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id96_MyXmlType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) return Read92_Item(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id91_MyXmlType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read90_Item(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id90_TypeWithXmlSchemaFormAttribute && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read89_TypeWithXmlSchemaFormAttribute(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id89_TypeWithPropertyNameSpecified && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read88_TypeWithPropertyNameSpecified(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id87_SimpleKnownTypeValue && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read87_SimpleKnownTypeValue(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id86_KnownTypesThroughConstructor && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read86_KnownTypesThroughConstructor(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id85_TypeWithAnyAttribute && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read85_TypeWithAnyAttribute(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id121_XmlSerializerAttributes && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read84_XmlSerializerAttributes(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id75_WithNullables && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read77_WithNullables(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id74_WithEnums && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read73_WithEnums(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id72_WithStruct && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read70_WithStruct(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id73_SomeStruct && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read69_SomeStruct(false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id71_ClassImplementsInterface && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read68_ClassImplementsInterface(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id68_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id69_Item)) - return Read66_Item(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id67_SimpleDC && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read65_SimpleDC(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id66_TypeWithByteArrayAsXmlText && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read64_TypeWithByteArrayAsXmlText(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id65_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read63_Item(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id62_BaseClassWithSamePropertyName && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read60_BaseClassWithSamePropertyName(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id63_DerivedClassWithSameProperty && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read61_DerivedClassWithSameProperty(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id64_DerivedClassWithSameProperty2 && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read62_DerivedClassWithSameProperty2(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id61_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read59_Item(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id60_TypeHasArrayOfASerializedAsB && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read58_TypeHasArrayOfASerializedAsB(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id59_TypeB && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read57_TypeB(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id58_TypeA && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read56_TypeA(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id57_BuiltInTypes && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read55_BuiltInTypes(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id56_DCClassWithEnumAndStruct && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read54_DCClassWithEnumAndStruct(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id55_DCStruct && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read53_DCStruct(false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id54_TypeWithEnumMembers && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read52_TypeWithEnumMembers(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id50_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read50_Item(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id49_TypeWithMyCollectionField && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read49_TypeWithMyCollectionField(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id48_StructNotSerializable && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read48_StructNotSerializable(false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id47_TypeWithGetOnlyArrayProperties && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read47_TypeWithGetOnlyArrayProperties(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id46_TypeWithGetSetArrayMembers && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read46_TypeWithGetSetArrayMembers(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id45_SimpleType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read45_SimpleType(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id44_TypeWithDateTimeStringProperty && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read44_TypeWithDateTimeStringProperty(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id43_XElementArrayWrapper && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read43_XElementArrayWrapper(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id42_XElementStruct && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read42_XElementStruct(false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id41_XElementWrapper && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read41_XElementWrapper(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id39_RootClass && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read40_RootClass(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id40_Parameter && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read39_Parameter(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id122_ParameterOfString && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read38_ParameterOfString(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id123_MsgDocumentType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id38_httpexamplecom)) - return Read37_MsgDocumentType(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id36_TypeWithLinkedProperty && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read36_TypeWithLinkedProperty(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id124_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id95_TypeWithXmlSchemaFormAttribute && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read91_TypeWithXmlSchemaFormAttribute(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id94_TypeWithPropertyNameSpecified && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read90_TypeWithPropertyNameSpecified(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id92_SimpleKnownTypeValue && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read89_SimpleKnownTypeValue(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id91_KnownTypesThroughConstructor && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read88_KnownTypesThroughConstructor(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id90_TypeWithAnyAttribute && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read87_TypeWithAnyAttribute(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id128_XmlSerializerAttributes && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read86_XmlSerializerAttributes(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id80_WithNullables && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read79_WithNullables(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id79_WithEnums && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read75_WithEnums(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id77_WithStruct && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read72_WithStruct(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id78_SomeStruct && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read71_SomeStruct(false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id76_ClassImplementsInterface && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read70_ClassImplementsInterface(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id73_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id74_Item)) + return Read68_Item(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id72_SimpleDC && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read67_SimpleDC(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id71_TypeWithByteArrayAsXmlText && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read66_TypeWithByteArrayAsXmlText(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id70_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read65_Item(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id67_BaseClassWithSamePropertyName && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read62_BaseClassWithSamePropertyName(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id68_DerivedClassWithSameProperty && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read63_DerivedClassWithSameProperty(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id69_DerivedClassWithSameProperty2 && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read64_DerivedClassWithSameProperty2(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id66_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read61_Item(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id65_TypeHasArrayOfASerializedAsB && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read60_TypeHasArrayOfASerializedAsB(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id64_TypeB && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read59_TypeB(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id63_TypeA && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read58_TypeA(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id62_BuiltInTypes && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read57_BuiltInTypes(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id61_DCClassWithEnumAndStruct && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read56_DCClassWithEnumAndStruct(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id60_DCStruct && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read55_DCStruct(false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id59_TypeWithEnumMembers && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read54_TypeWithEnumMembers(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id55_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read52_Item(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id54_TypeWithMyCollectionField && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read51_TypeWithMyCollectionField(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id53_StructNotSerializable && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read50_StructNotSerializable(false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id52_TypeWithGetOnlyArrayProperties && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read49_TypeWithGetOnlyArrayProperties(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id51_TypeWithGetSetArrayMembers && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read48_TypeWithGetSetArrayMembers(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id50_SimpleType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read47_SimpleType(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id49_TypeWithDateTimeStringProperty && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read46_TypeWithDateTimeStringProperty(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id48_XElementArrayWrapper && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read45_XElementArrayWrapper(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id47_XElementStruct && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read44_XElementStruct(false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id46_XElementWrapper && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read43_XElementWrapper(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id44_RootClass && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read42_RootClass(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id45_Parameter && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read41_Parameter(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id129_ParameterOfString && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read40_ParameterOfString(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id130_MsgDocumentType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id43_httpexamplecom)) + return Read39_MsgDocumentType(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id41_TypeWithLinkedProperty && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read38_TypeWithLinkedProperty(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id131_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read37_Item(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id39_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read36_Item(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id38_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) return Read35_Item(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id34_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read34_Item(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id33_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read33_Item(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id32_DefaultValuesSetToNaN && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read32_DefaultValuesSetToNaN(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id31_Pet && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read31_Pet(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id27_Orchestra && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read28_Orchestra(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id28_Instrument && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read27_Instrument(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id29_Brass && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read29_Brass(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id30_Trumpet && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read30_Trumpet(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id23_BaseClass1 && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read25_BaseClass1(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id24_DerivedClass1 && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read26_DerivedClass1(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id22_AliasedTestType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read24_AliasedTestType(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id21_OrderedItem && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read23_OrderedItem(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id20_Address && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read22_Address(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id18_PurchaseOrder && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id19_httpwwwcontoso1com)) - return Read21_PurchaseOrder(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id21_OrderedItem && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id19_httpwwwcontoso1com)) - return Read20_OrderedItem(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id20_Address && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id19_httpwwwcontoso1com)) - return Read19_Address(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id37_DefaultValuesSetToNaN && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read34_DefaultValuesSetToNaN(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id36_Pet && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read33_Pet(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id32_Orchestra && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read30_Orchestra(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id33_Instrument && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read29_Instrument(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id34_Brass && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read31_Brass(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id35_Trumpet && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read32_Trumpet(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id28_BaseClass1 && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read27_BaseClass1(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id29_DerivedClass1 && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read28_DerivedClass1(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id27_AliasedTestType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read26_AliasedTestType(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id26_OrderedItem && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read25_OrderedItem(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id25_Address && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read24_Address(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id23_PurchaseOrder && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id24_httpwwwcontoso1com)) + return Read23_PurchaseOrder(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id26_OrderedItem && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id24_httpwwwcontoso1com)) + return Read22_OrderedItem(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id25_Address && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id24_httpwwwcontoso1com)) + return Read21_Address(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id18_SimpleBaseClass && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read20_SimpleBaseClass(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id19_SimpleDerivedClass && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read19_SimpleDerivedClass(isNullable, false); if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id16_BaseClass && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) return Read18_BaseClass(isNullable, false); if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id17_DerivedClass && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) @@ -6742,7 +7091,7 @@ public object Read215_Person() { ReadEndElement(); return e; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id125_ArrayOfOrderedItem && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id19_httpwwwcontoso1com)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id132_ArrayOfOrderedItem && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id24_httpwwwcontoso1com)) { global::OrderedItem[] a = null; if (!ReadNull()) { global::OrderedItem[] z_0_0 = null; @@ -6756,8 +7105,8 @@ public object Read215_Person() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id21_OrderedItem && (object) Reader.NamespaceURI == (object)id19_httpwwwcontoso1com)) { - z_0_0 = (global::OrderedItem[])EnsureArrayIndex(z_0_0, cz_0_0, typeof(global::OrderedItem));z_0_0[cz_0_0++] = Read20_OrderedItem(true, true); + if (((object) Reader.LocalName == (object)id26_OrderedItem && (object) Reader.NamespaceURI == (object)id24_httpwwwcontoso1com)) { + z_0_0 = (global::OrderedItem[])EnsureArrayIndex(z_0_0, cz_0_0, typeof(global::OrderedItem));z_0_0[cz_0_0++] = Read22_OrderedItem(true, true); break; } UnknownNode(null, @"http://www.contoso1.com:OrderedItem"); @@ -6774,7 +7123,7 @@ public object Read215_Person() { } return a; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id126_ArrayOfInt && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id133_ArrayOfInt && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { global::System.Collections.Generic.List a = null; if (!ReadNull()) { if ((object)(a) == null) a = new global::System.Collections.Generic.List(); @@ -6788,7 +7137,7 @@ public object Read215_Person() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id127_int && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id134_int && (object) Reader.NamespaceURI == (object)id2_Item)) { { z_0_0.Add(System.Xml.XmlConvert.ToInt32(Reader.ReadElementString())); } @@ -6807,7 +7156,7 @@ public object Read215_Person() { } return a; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id128_ArrayOfString && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id135_ArrayOfString && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { global::System.Collections.Generic.List a = null; if (!ReadNull()) { if ((object)(a) == null) a = new global::System.Collections.Generic.List(); @@ -6821,7 +7170,7 @@ public object Read215_Person() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id129_string && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id136_string && (object) Reader.NamespaceURI == (object)id2_Item)) { if (ReadNull()) { z_0_0.Add(null); } @@ -6843,7 +7192,7 @@ public object Read215_Person() { } return a; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id130_ArrayOfDouble && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id137_ArrayOfDouble && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { global::System.Collections.Generic.List a = null; if (!ReadNull()) { if ((object)(a) == null) a = new global::System.Collections.Generic.List(); @@ -6857,7 +7206,7 @@ public object Read215_Person() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id131_double && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id138_double && (object) Reader.NamespaceURI == (object)id2_Item)) { { z_0_0.Add(System.Xml.XmlConvert.ToDouble(Reader.ReadElementString())); } @@ -6876,7 +7225,7 @@ public object Read215_Person() { } return a; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id25_ArrayOfDateTime && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id30_ArrayOfDateTime && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { global::MyCollection1 a = null; if (!ReadNull()) { if ((object)(a) == null) a = new global::MyCollection1(); @@ -6890,7 +7239,7 @@ public object Read215_Person() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id26_dateTime && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id31_dateTime && (object) Reader.NamespaceURI == (object)id2_Item)) { { z_0_0.Add(ToDateTime(Reader.ReadElementString())); } @@ -6909,7 +7258,7 @@ public object Read215_Person() { } return a; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id132_ArrayOfInstrument && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id139_ArrayOfInstrument && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { global::Instrument[] a = null; if (!ReadNull()) { global::Instrument[] z_0_0 = null; @@ -6923,8 +7272,8 @@ public object Read215_Person() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id28_Instrument && (object) Reader.NamespaceURI == (object)id2_Item)) { - z_0_0 = (global::Instrument[])EnsureArrayIndex(z_0_0, cz_0_0, typeof(global::Instrument));z_0_0[cz_0_0++] = Read27_Instrument(true, true); + if (((object) Reader.LocalName == (object)id33_Instrument && (object) Reader.NamespaceURI == (object)id2_Item)) { + z_0_0 = (global::Instrument[])EnsureArrayIndex(z_0_0, cz_0_0, typeof(global::Instrument));z_0_0[cz_0_0++] = Read29_Instrument(true, true); break; } UnknownNode(null, @":Instrument"); @@ -6941,7 +7290,7 @@ public object Read215_Person() { } return a; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id133_ArrayOfTypeWithLinkedProperty && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id140_ArrayOfTypeWithLinkedProperty && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { global::System.Collections.Generic.List a = null; if (!ReadNull()) { if ((object)(a) == null) a = new global::System.Collections.Generic.List(); @@ -6955,8 +7304,8 @@ public object Read215_Person() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id36_TypeWithLinkedProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { - if ((object)(z_0_0) == null) Reader.Skip(); else z_0_0.Add(Read36_TypeWithLinkedProperty(true, true)); + if (((object) Reader.LocalName == (object)id41_TypeWithLinkedProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if ((object)(z_0_0) == null) Reader.Skip(); else z_0_0.Add(Read38_TypeWithLinkedProperty(true, true)); break; } UnknownNode(null, @":TypeWithLinkedProperty"); @@ -6972,7 +7321,7 @@ public object Read215_Person() { } return a; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id134_ArrayOfParameter && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id141_ArrayOfParameter && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { global::System.Collections.Generic.List a = null; if (!ReadNull()) { if ((object)(a) == null) a = new global::System.Collections.Generic.List(); @@ -6986,8 +7335,8 @@ public object Read215_Person() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id40_Parameter && (object) Reader.NamespaceURI == (object)id2_Item)) { - if ((object)(z_0_0) == null) Reader.Skip(); else z_0_0.Add(Read39_Parameter(true, true)); + if (((object) Reader.LocalName == (object)id45_Parameter && (object) Reader.NamespaceURI == (object)id2_Item)) { + if ((object)(z_0_0) == null) Reader.Skip(); else z_0_0.Add(Read41_Parameter(true, true)); break; } UnknownNode(null, @":Parameter"); @@ -7003,7 +7352,7 @@ public object Read215_Person() { } return a; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id135_ArrayOfXElement && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id142_ArrayOfXElement && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { global::System.Xml.Linq.XElement[] a = null; if (!ReadNull()) { global::System.Xml.Linq.XElement[] z_0_0 = null; @@ -7017,7 +7366,7 @@ public object Read215_Person() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id136_XElement && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id143_XElement && (object) Reader.NamespaceURI == (object)id2_Item)) { z_0_0 = (global::System.Xml.Linq.XElement[])EnsureArrayIndex(z_0_0, cz_0_0, typeof(global::System.Xml.Linq.XElement));z_0_0[cz_0_0++] = (global::System.Xml.Linq.XElement)ReadSerializable(( System.Xml.Serialization.IXmlSerializable)new global::System.Xml.Linq.XElement("default"), true ); break; @@ -7036,7 +7385,7 @@ public object Read215_Person() { } return a; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id137_ArrayOfSimpleType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id144_ArrayOfSimpleType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { global::SerializationTypes.SimpleType[] a = null; if (!ReadNull()) { global::SerializationTypes.SimpleType[] z_0_0 = null; @@ -7050,8 +7399,8 @@ public object Read215_Person() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id45_SimpleType && (object) Reader.NamespaceURI == (object)id2_Item)) { - z_0_0 = (global::SerializationTypes.SimpleType[])EnsureArrayIndex(z_0_0, cz_0_0, typeof(global::SerializationTypes.SimpleType));z_0_0[cz_0_0++] = Read45_SimpleType(true, true); + if (((object) Reader.LocalName == (object)id50_SimpleType && (object) Reader.NamespaceURI == (object)id2_Item)) { + z_0_0 = (global::SerializationTypes.SimpleType[])EnsureArrayIndex(z_0_0, cz_0_0, typeof(global::SerializationTypes.SimpleType));z_0_0[cz_0_0++] = Read47_SimpleType(true, true); break; } UnknownNode(null, @":SimpleType"); @@ -7068,7 +7417,7 @@ public object Read215_Person() { } return a; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id51_ArrayOfAnyType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id56_ArrayOfAnyType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { global::SerializationTypes.MyList a = null; if (!ReadNull()) { if ((object)(a) == null) a = new global::SerializationTypes.MyList(); @@ -7082,7 +7431,7 @@ public object Read215_Person() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id52_anyType && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id57_anyType && (object) Reader.NamespaceURI == (object)id2_Item)) { if ((object)(z_0_0) == null) Reader.Skip(); else z_0_0.Add(Read1_Object(true, true)); break; } @@ -7099,13 +7448,13 @@ public object Read215_Person() { } return a; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id53_MyEnum && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id58_MyEnum && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { Reader.ReadStartElement(); - object e = Read51_MyEnum(CollapseWhitespace(Reader.ReadString())); + object e = Read53_MyEnum(CollapseWhitespace(Reader.ReadString())); ReadEndElement(); return e; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id138_ArrayOfTypeA && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id145_ArrayOfTypeA && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { global::SerializationTypes.TypeA[] a = null; if (!ReadNull()) { global::SerializationTypes.TypeA[] z_0_0 = null; @@ -7119,8 +7468,8 @@ public object Read215_Person() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id58_TypeA && (object) Reader.NamespaceURI == (object)id2_Item)) { - z_0_0 = (global::SerializationTypes.TypeA[])EnsureArrayIndex(z_0_0, cz_0_0, typeof(global::SerializationTypes.TypeA));z_0_0[cz_0_0++] = Read56_TypeA(true, true); + if (((object) Reader.LocalName == (object)id63_TypeA && (object) Reader.NamespaceURI == (object)id2_Item)) { + z_0_0 = (global::SerializationTypes.TypeA[])EnsureArrayIndex(z_0_0, cz_0_0, typeof(global::SerializationTypes.TypeA));z_0_0[cz_0_0++] = Read58_TypeA(true, true); break; } UnknownNode(null, @":TypeA"); @@ -7137,61 +7486,61 @@ public object Read215_Person() { } return a; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id70_EnumFlags && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id75_EnumFlags && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { Reader.ReadStartElement(); - object e = Read67_EnumFlags(CollapseWhitespace(Reader.ReadString())); + object e = Read69_EnumFlags(CollapseWhitespace(Reader.ReadString())); ReadEndElement(); return e; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id79_IntEnum && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id84_IntEnum && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { Reader.ReadStartElement(); - object e = Read71_IntEnum(CollapseWhitespace(Reader.ReadString())); + object e = Read73_IntEnum(CollapseWhitespace(Reader.ReadString())); ReadEndElement(); return e; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id78_ShortEnum && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id83_ShortEnum && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { Reader.ReadStartElement(); - object e = Read72_ShortEnum(CollapseWhitespace(Reader.ReadString())); + object e = Read74_ShortEnum(CollapseWhitespace(Reader.ReadString())); ReadEndElement(); return e; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id76_ByteEnum && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id81_ByteEnum && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { Reader.ReadStartElement(); - object e = Read78_ByteEnum(CollapseWhitespace(Reader.ReadString())); + object e = Read80_ByteEnum(CollapseWhitespace(Reader.ReadString())); ReadEndElement(); return e; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id77_SByteEnum && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id82_SByteEnum && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { Reader.ReadStartElement(); - object e = Read79_SByteEnum(CollapseWhitespace(Reader.ReadString())); + object e = Read81_SByteEnum(CollapseWhitespace(Reader.ReadString())); ReadEndElement(); return e; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id80_UIntEnum && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id85_UIntEnum && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { Reader.ReadStartElement(); - object e = Read80_UIntEnum(CollapseWhitespace(Reader.ReadString())); + object e = Read82_UIntEnum(CollapseWhitespace(Reader.ReadString())); ReadEndElement(); return e; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id81_LongEnum && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id86_LongEnum && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { Reader.ReadStartElement(); - object e = Read81_LongEnum(CollapseWhitespace(Reader.ReadString())); + object e = Read83_LongEnum(CollapseWhitespace(Reader.ReadString())); ReadEndElement(); return e; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id82_ULongEnum && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id87_ULongEnum && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { Reader.ReadStartElement(); - object e = Read82_ULongEnum(CollapseWhitespace(Reader.ReadString())); + object e = Read84_ULongEnum(CollapseWhitespace(Reader.ReadString())); ReadEndElement(); return e; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id84_ItemChoiceType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id89_ItemChoiceType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { Reader.ReadStartElement(); - object e = Read83_ItemChoiceType(CollapseWhitespace(Reader.ReadString())); + object e = Read85_ItemChoiceType(CollapseWhitespace(Reader.ReadString())); ReadEndElement(); return e; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id139_ArrayOfItemChoiceType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id146_ArrayOfItemChoiceType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { global::SerializationTypes.ItemChoiceType[] a = null; if (!ReadNull()) { global::SerializationTypes.ItemChoiceType[] z_0_0 = null; @@ -7205,9 +7554,9 @@ public object Read215_Person() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id84_ItemChoiceType && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id89_ItemChoiceType && (object) Reader.NamespaceURI == (object)id2_Item)) { { - z_0_0 = (global::SerializationTypes.ItemChoiceType[])EnsureArrayIndex(z_0_0, cz_0_0, typeof(global::SerializationTypes.ItemChoiceType));z_0_0[cz_0_0++] = Read83_ItemChoiceType(Reader.ReadElementString()); + z_0_0 = (global::SerializationTypes.ItemChoiceType[])EnsureArrayIndex(z_0_0, cz_0_0, typeof(global::SerializationTypes.ItemChoiceType));z_0_0[cz_0_0++] = Read85_ItemChoiceType(Reader.ReadElementString()); } break; } @@ -7225,7 +7574,7 @@ public object Read215_Person() { } return a; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id128_ArrayOfString && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id140_httpmynamespace)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id135_ArrayOfString && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id147_httpmynamespace)) { global::System.Object[] a = null; if (!ReadNull()) { global::System.Object[] z_0_0 = null; @@ -7239,7 +7588,7 @@ public object Read215_Person() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id129_string && (object) Reader.NamespaceURI == (object)id140_httpmynamespace)) { + if (((object) Reader.LocalName == (object)id136_string && (object) Reader.NamespaceURI == (object)id147_httpmynamespace)) { if (ReadNull()) { z_0_0 = (global::System.Object[])EnsureArrayIndex(z_0_0, cz_0_0, typeof(global::System.Object));z_0_0[cz_0_0++] = null; } @@ -7262,7 +7611,7 @@ public object Read215_Person() { } return a; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id141_ArrayOfString1 && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id148_ArrayOfString1 && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { global::System.Collections.Generic.List a = null; if (!ReadNull()) { if ((object)(a) == null) a = new global::System.Collections.Generic.List(); @@ -7276,7 +7625,7 @@ public object Read215_Person() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id142_NoneParameter && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id149_NoneParameter && (object) Reader.NamespaceURI == (object)id2_Item)) { { z_0_0.Add(Reader.ReadElementString()); } @@ -7295,7 +7644,7 @@ public object Read215_Person() { } return a; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id143_ArrayOfBoolean && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id150_ArrayOfBoolean && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { global::System.Collections.Generic.List a = null; if (!ReadNull()) { if ((object)(a) == null) a = new global::System.Collections.Generic.List(); @@ -7309,7 +7658,7 @@ public object Read215_Person() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id144_QualifiedParameter && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id151_QualifiedParameter && (object) Reader.NamespaceURI == (object)id2_Item)) { { z_0_0.Add(System.Xml.XmlConvert.ToBoolean(Reader.ReadElementString())); } @@ -7328,7 +7677,7 @@ public object Read215_Person() { } return a; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id145_ArrayOfArrayOfSimpleType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id152_ArrayOfArrayOfSimpleType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { global::SerializationTypes.SimpleType[][] a = null; if (!ReadNull()) { global::SerializationTypes.SimpleType[][] z_0_0 = null; @@ -7342,7 +7691,7 @@ public object Read215_Person() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id45_SimpleType && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id50_SimpleType && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { global::SerializationTypes.SimpleType[] z_0_0_0 = null; int cz_0_0_0 = 0; @@ -7355,8 +7704,8 @@ public object Read215_Person() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id45_SimpleType && (object) Reader.NamespaceURI == (object)id2_Item)) { - z_0_0_0 = (global::SerializationTypes.SimpleType[])EnsureArrayIndex(z_0_0_0, cz_0_0_0, typeof(global::SerializationTypes.SimpleType));z_0_0_0[cz_0_0_0++] = Read45_SimpleType(true, true); + if (((object) Reader.LocalName == (object)id50_SimpleType && (object) Reader.NamespaceURI == (object)id2_Item)) { + z_0_0_0 = (global::SerializationTypes.SimpleType[])EnsureArrayIndex(z_0_0_0, cz_0_0_0, typeof(global::SerializationTypes.SimpleType));z_0_0_0[cz_0_0_0++] = Read47_SimpleType(true, true); break; } UnknownNode(null, @":SimpleType"); @@ -7387,9 +7736,9 @@ public object Read215_Person() { } return a; } - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id105_MoreChoices && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id112_MoreChoices && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { Reader.ReadStartElement(); - object e = Read103_MoreChoices(CollapseWhitespace(Reader.ReadString())); + object e = Read107_MoreChoices(CollapseWhitespace(Reader.ReadString())); ReadEndElement(); return e; } @@ -7425,7 +7774,7 @@ public object Read215_Person() { return o; } - global::SerializationTypes.MoreChoices Read103_MoreChoices(string s) { + global::SerializationTypes.MoreChoices Read107_MoreChoices(string s) { switch (s) { case @"None": return global::SerializationTypes.MoreChoices.@None; case @"Item": return global::SerializationTypes.MoreChoices.@Item; @@ -7434,12 +7783,12 @@ public object Read215_Person() { } } - global::SerializationTypes.SimpleType Read45_SimpleType(bool isNullable, bool checkType) { + global::SerializationTypes.SimpleType Read47_SimpleType(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id45_SimpleType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id50_SimpleType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -7464,14 +7813,14 @@ public object Read215_Person() { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id146_P1 && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id153_P1 && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@P1 = Reader.ReadElementString(); } paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id147_P2 && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id154_P2 && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@P2 = System.Xml.XmlConvert.ToInt32(Reader.ReadElementString()); } @@ -7490,7 +7839,7 @@ public object Read215_Person() { return o; } - global::SerializationTypes.ItemChoiceType Read83_ItemChoiceType(string s) { + global::SerializationTypes.ItemChoiceType Read85_ItemChoiceType(string s) { switch (s) { case @"None": return global::SerializationTypes.ItemChoiceType.@None; case @"Word": return global::SerializationTypes.ItemChoiceType.@Word; @@ -7500,7 +7849,7 @@ public object Read215_Person() { } } - global::SerializationTypes.ULongEnum Read82_ULongEnum(string s) { + global::SerializationTypes.ULongEnum Read84_ULongEnum(string s) { switch (s) { case @"Option0": return global::SerializationTypes.ULongEnum.@Option0; case @"Option1": return global::SerializationTypes.ULongEnum.@Option1; @@ -7509,7 +7858,7 @@ public object Read215_Person() { } } - global::SerializationTypes.LongEnum Read81_LongEnum(string s) { + global::SerializationTypes.LongEnum Read83_LongEnum(string s) { switch (s) { case @"Option0": return global::SerializationTypes.LongEnum.@Option0; case @"Option1": return global::SerializationTypes.LongEnum.@Option1; @@ -7518,7 +7867,7 @@ public object Read215_Person() { } } - global::SerializationTypes.UIntEnum Read80_UIntEnum(string s) { + global::SerializationTypes.UIntEnum Read82_UIntEnum(string s) { switch (s) { case @"Option0": return global::SerializationTypes.UIntEnum.@Option0; case @"Option1": return global::SerializationTypes.UIntEnum.@Option1; @@ -7527,7 +7876,7 @@ public object Read215_Person() { } } - global::SerializationTypes.SByteEnum Read79_SByteEnum(string s) { + global::SerializationTypes.SByteEnum Read81_SByteEnum(string s) { switch (s) { case @"Option0": return global::SerializationTypes.SByteEnum.@Option0; case @"Option1": return global::SerializationTypes.SByteEnum.@Option1; @@ -7536,7 +7885,7 @@ public object Read215_Person() { } } - global::SerializationTypes.ByteEnum Read78_ByteEnum(string s) { + global::SerializationTypes.ByteEnum Read80_ByteEnum(string s) { switch (s) { case @"Option0": return global::SerializationTypes.ByteEnum.@Option0; case @"Option1": return global::SerializationTypes.ByteEnum.@Option1; @@ -7545,7 +7894,7 @@ public object Read215_Person() { } } - global::SerializationTypes.ShortEnum Read72_ShortEnum(string s) { + global::SerializationTypes.ShortEnum Read74_ShortEnum(string s) { switch (s) { case @"Option0": return global::SerializationTypes.ShortEnum.@Option0; case @"Option1": return global::SerializationTypes.ShortEnum.@Option1; @@ -7554,7 +7903,7 @@ public object Read215_Person() { } } - global::SerializationTypes.IntEnum Read71_IntEnum(string s) { + global::SerializationTypes.IntEnum Read73_IntEnum(string s) { switch (s) { case @"Option0": return global::SerializationTypes.IntEnum.@Option0; case @"Option1": return global::SerializationTypes.IntEnum.@Option1; @@ -7579,16 +7928,16 @@ internal System.Collections.Hashtable EnumFlagsValues { } } - global::SerializationTypes.EnumFlags Read67_EnumFlags(string s) { + global::SerializationTypes.EnumFlags Read69_EnumFlags(string s) { return (global::SerializationTypes.EnumFlags)ToEnum(s, EnumFlagsValues, @"global::SerializationTypes.EnumFlags"); } - global::SerializationTypes.TypeA Read56_TypeA(bool isNullable, bool checkType) { + global::SerializationTypes.TypeA Read58_TypeA(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id58_TypeA && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id63_TypeA && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -7613,7 +7962,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id115_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id122_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Name = Reader.ReadElementString(); } @@ -7632,7 +7981,7 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.MyEnum Read51_MyEnum(string s) { + global::SerializationTypes.MyEnum Read53_MyEnum(string s) { switch (s) { case @"One": return global::SerializationTypes.MyEnum.@One; case @"Two": return global::SerializationTypes.MyEnum.@Two; @@ -7641,16 +7990,16 @@ internal System.Collections.Hashtable EnumFlagsValues { } } - global::Parameter Read39_Parameter(bool isNullable, bool checkType) { + global::Parameter Read41_Parameter(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id40_Parameter && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id45_Parameter && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id122_ParameterOfString && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read38_ParameterOfString(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id129_ParameterOfString && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read40_ParameterOfString(isNullable, false); throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); } } @@ -7659,7 +8008,7 @@ internal System.Collections.Hashtable EnumFlagsValues { o = new global::Parameter(); System.Span paramsRead = stackalloc bool[1]; while (Reader.MoveToNextAttribute()) { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id115_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id122_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@Name = Reader.Value; paramsRead[0] = true; } @@ -7687,12 +8036,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::Parameter Read38_ParameterOfString(bool isNullable, bool checkType) { + global::Parameter Read40_ParameterOfString(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id122_ParameterOfString && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id129_ParameterOfString && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -7703,7 +8052,7 @@ internal System.Collections.Hashtable EnumFlagsValues { o = new global::Parameter(); System.Span paramsRead = stackalloc bool[2]; while (Reader.MoveToNextAttribute()) { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id115_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id122_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@Name = Reader.Value; paramsRead[0] = true; } @@ -7721,7 +8070,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id148_Value && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id155_Value && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Value = Reader.ReadElementString(); } @@ -7740,12 +8089,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::TypeWithLinkedProperty Read36_TypeWithLinkedProperty(bool isNullable, bool checkType) { + global::TypeWithLinkedProperty Read38_TypeWithLinkedProperty(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id36_TypeWithLinkedProperty && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id41_TypeWithLinkedProperty && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -7772,12 +8121,12 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id149_Child && (object) Reader.NamespaceURI == (object)id2_Item)) { - o.@Child = Read36_TypeWithLinkedProperty(false, true); + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id156_Child && (object) Reader.NamespaceURI == (object)id2_Item)) { + o.@Child = Read38_TypeWithLinkedProperty(false, true); paramsRead[0] = true; break; } - if (((object) Reader.LocalName == (object)id150_Children && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id157_Children && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { if ((object)(o.@Children) == null) o.@Children = new global::System.Collections.Generic.List(); global::System.Collections.Generic.List a_1_0 = (global::System.Collections.Generic.List)o.@Children; @@ -7790,8 +8139,8 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id36_TypeWithLinkedProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { - if ((object)(a_1_0) == null) Reader.Skip(); else a_1_0.Add(Read36_TypeWithLinkedProperty(true, true)); + if (((object) Reader.LocalName == (object)id41_TypeWithLinkedProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if ((object)(a_1_0) == null) Reader.Skip(); else a_1_0.Add(Read38_TypeWithLinkedProperty(true, true)); break; } UnknownNode(null, @":TypeWithLinkedProperty"); @@ -7819,18 +8168,18 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::Instrument Read27_Instrument(bool isNullable, bool checkType) { + global::Instrument Read29_Instrument(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id28_Instrument && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id33_Instrument && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id29_Brass && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read29_Brass(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id30_Trumpet && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read30_Trumpet(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id34_Brass && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read31_Brass(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id35_Trumpet && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read32_Trumpet(isNullable, false); throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); } } @@ -7853,7 +8202,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id115_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id122_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Name = Reader.ReadElementString(); } @@ -7872,12 +8221,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::Trumpet Read30_Trumpet(bool isNullable, bool checkType) { + global::Trumpet Read32_Trumpet(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id30_Trumpet && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id35_Trumpet && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -7902,21 +8251,21 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id115_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id122_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Name = Reader.ReadElementString(); } paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id151_IsValved && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id158_IsValved && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@IsValved = System.Xml.XmlConvert.ToBoolean(Reader.ReadElementString()); } paramsRead[1] = true; break; } - if (!paramsRead[2] && ((object) Reader.LocalName == (object)id152_Modulation && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[2] && ((object) Reader.LocalName == (object)id159_Modulation && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Modulation = ToChar(Reader.ReadElementString()); } @@ -7935,16 +8284,16 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::Brass Read29_Brass(bool isNullable, bool checkType) { + global::Brass Read31_Brass(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id29_Brass && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id34_Brass && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id30_Trumpet && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read30_Trumpet(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id35_Trumpet && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read32_Trumpet(isNullable, false); throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); } } @@ -7967,14 +8316,14 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id115_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id122_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Name = Reader.ReadElementString(); } paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id151_IsValved && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id158_IsValved && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@IsValved = System.Xml.XmlConvert.ToBoolean(Reader.ReadElementString()); } @@ -7993,12 +8342,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::OrderedItem Read20_OrderedItem(bool isNullable, bool checkType) { + global::OrderedItem Read22_OrderedItem(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id21_OrderedItem && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id19_httpwwwcontoso1com)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id26_OrderedItem && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id24_httpwwwcontoso1com)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -8023,35 +8372,35 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id153_ItemName && (object) Reader.NamespaceURI == (object)id19_httpwwwcontoso1com)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id160_ItemName && (object) Reader.NamespaceURI == (object)id24_httpwwwcontoso1com)) { { o.@ItemName = Reader.ReadElementString(); } paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id154_Description && (object) Reader.NamespaceURI == (object)id19_httpwwwcontoso1com)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id161_Description && (object) Reader.NamespaceURI == (object)id24_httpwwwcontoso1com)) { { o.@Description = Reader.ReadElementString(); } paramsRead[1] = true; break; } - if (!paramsRead[2] && ((object) Reader.LocalName == (object)id155_UnitPrice && (object) Reader.NamespaceURI == (object)id19_httpwwwcontoso1com)) { + if (!paramsRead[2] && ((object) Reader.LocalName == (object)id162_UnitPrice && (object) Reader.NamespaceURI == (object)id24_httpwwwcontoso1com)) { { o.@UnitPrice = System.Xml.XmlConvert.ToDecimal(Reader.ReadElementString()); } paramsRead[2] = true; break; } - if (!paramsRead[3] && ((object) Reader.LocalName == (object)id156_Quantity && (object) Reader.NamespaceURI == (object)id19_httpwwwcontoso1com)) { + if (!paramsRead[3] && ((object) Reader.LocalName == (object)id163_Quantity && (object) Reader.NamespaceURI == (object)id24_httpwwwcontoso1com)) { { o.@Quantity = System.Xml.XmlConvert.ToInt32(Reader.ReadElementString()); } paramsRead[3] = true; break; } - if (!paramsRead[4] && ((object) Reader.LocalName == (object)id157_LineTotal && (object) Reader.NamespaceURI == (object)id19_httpwwwcontoso1com)) { + if (!paramsRead[4] && ((object) Reader.LocalName == (object)id164_LineTotal && (object) Reader.NamespaceURI == (object)id24_httpwwwcontoso1com)) { { o.@LineTotal = System.Xml.XmlConvert.ToDecimal(Reader.ReadElementString()); } @@ -8152,7 +8501,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id37_Document && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id42_Document && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@Document = (global::System.Xml.XmlDocument)ReadXmlDocument(true); paramsRead[0] = true; break; @@ -8199,14 +8548,14 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id158_BinaryHexContent && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id165_BinaryHexContent && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@BinaryHexContent = ToByteArrayHex(false); } paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id159_Base64Content && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id166_Base64Content && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Base64Content = ToByteArrayBase64(false); } @@ -8255,7 +8604,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id160_DTO && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id167_DTO && (object) Reader.NamespaceURI == (object)id2_Item)) { { if (Reader.IsEmptyElement) { Reader.Skip(); @@ -8268,7 +8617,7 @@ internal System.Collections.Hashtable EnumFlagsValues { paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id161_DTO2 && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id168_DTO2 && (object) Reader.NamespaceURI == (object)id2_Item)) { { if (Reader.IsEmptyElement) { Reader.Skip(); @@ -8281,7 +8630,7 @@ internal System.Collections.Hashtable EnumFlagsValues { paramsRead[1] = true; break; } - if (!paramsRead[2] && ((object) Reader.LocalName == (object)id162_DefaultDTO && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[2] && ((object) Reader.LocalName == (object)id169_DefaultDTO && (object) Reader.NamespaceURI == (object)id2_Item)) { if (Reader.IsEmptyElement) { Reader.Skip(); } @@ -8297,12 +8646,12 @@ internal System.Collections.Hashtable EnumFlagsValues { paramsRead[2] = true; break; } - if (!paramsRead[3] && ((object) Reader.LocalName == (object)id163_NullableDTO && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[3] && ((object) Reader.LocalName == (object)id170_NullableDTO && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@NullableDTO = Read5_NullableOfDateTimeOffset(true); paramsRead[3] = true; break; } - if (!paramsRead[4] && ((object) Reader.LocalName == (object)id164_NullableDefaultDTO && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[4] && ((object) Reader.LocalName == (object)id171_NullableDefaultDTO && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@NullableDTOWithDefault = Read5_NullableOfDateTimeOffset(true); paramsRead[4] = true; break; @@ -8365,7 +8714,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id165_TimeSpanProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id172_TimeSpanProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { { if (Reader.IsEmptyElement) { Reader.Skip(); @@ -8420,7 +8769,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id165_TimeSpanProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id172_TimeSpanProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { if (Reader.IsEmptyElement) { Reader.Skip(); } @@ -8436,7 +8785,7 @@ internal System.Collections.Hashtable EnumFlagsValues { paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id166_TimeSpanProperty2 && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id173_TimeSpanProperty2 && (object) Reader.NamespaceURI == (object)id2_Item)) { if (Reader.IsEmptyElement) { Reader.Skip(); } @@ -8494,7 +8843,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id167_ByteProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id174_ByteProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@ByteProperty = System.Xml.XmlConvert.ToByte(Reader.ReadElementString()); } @@ -8594,21 +8943,21 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id168_Age && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id175_Age && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Age = System.Xml.XmlConvert.ToInt32(Reader.ReadElementString()); } paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id115_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id122_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Name = Reader.ReadElementString(); } paramsRead[1] = true; break; } - if (!paramsRead[2] && ((object) Reader.LocalName == (object)id169_Breed && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[2] && ((object) Reader.LocalName == (object)id176_Breed && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Breed = Read12_DogBreed(Reader.ReadElementString()); } @@ -8659,14 +9008,14 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id168_Age && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id175_Age && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Age = System.Xml.XmlConvert.ToInt32(Reader.ReadElementString()); } paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id115_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id122_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Name = Reader.ReadElementString(); } @@ -8715,7 +9064,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id170_LicenseNumber && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id177_LicenseNumber && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@LicenseNumber = Reader.ReadElementString(); } @@ -8764,14 +9113,14 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id171_GroupName && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id178_GroupName && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@GroupName = Reader.ReadElementString(); } paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id172_GroupVehicle && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id179_GroupVehicle && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@GroupVehicle = Read14_Vehicle(false, true); paramsRead[1] = true; break; @@ -8818,7 +9167,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id173_EmployeeName && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id180_EmployeeName && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@EmployeeName = Reader.ReadElementString(); } @@ -8867,14 +9216,14 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id148_Value && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id155_Value && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Value = Reader.ReadElementString(); } paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id174_value && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id181_value && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@value = Reader.ReadElementString(); } @@ -8925,14 +9274,14 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id148_Value && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id155_Value && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Value = Reader.ReadElementString(); } paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id174_value && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id181_value && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@value = Reader.ReadElementString(); } @@ -8951,12 +9300,114 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::Address Read19_Address(bool isNullable, bool checkType) { + global::SimpleDerivedClass Read19_SimpleDerivedClass(bool isNullable, bool checkType) { + System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; + bool isNull = false; + if (isNullable) isNull = ReadNull(); + if (checkType) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id19_SimpleDerivedClass && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + } + else { + throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); + } + } + if (isNull) return null; + global::SimpleDerivedClass o; + o = new global::SimpleDerivedClass(); + System.Span paramsRead = stackalloc bool[3]; + while (Reader.MoveToNextAttribute()) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id182_AttributeString && (object) Reader.NamespaceURI == (object)id2_Item)) { + o.@AttributeString = Reader.Value; + paramsRead[0] = true; + } + else if (!paramsRead[1] && ((object) Reader.LocalName == (object)id183_DateTimeValue && (object) Reader.NamespaceURI == (object)id2_Item)) { + o.@DateTimeValue = ToDateTime(Reader.Value); + paramsRead[1] = true; + } + else if (!paramsRead[2] && ((object) Reader.LocalName == (object)id184_BoolValue && (object) Reader.NamespaceURI == (object)id2_Item)) { + o.@BoolValue = System.Xml.XmlConvert.ToBoolean(Reader.Value); + paramsRead[2] = true; + } + else if (!IsXmlnsAttribute(Reader.Name)) { + UnknownNode((object)o, @":AttributeString, :DateTimeValue, :BoolValue"); + } + } + Reader.MoveToElement(); + if (Reader.IsEmptyElement) { + Reader.Skip(); + return o; + } + Reader.ReadStartElement(); + Reader.MoveToContent(); + while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { + if (Reader.NodeType == System.Xml.XmlNodeType.Element) { + UnknownNode((object)o, @""); + } + else { + UnknownNode((object)o, @""); + } + Reader.MoveToContent(); + } + ReadEndElement(); + return o; + } + + global::SimpleBaseClass Read20_SimpleBaseClass(bool isNullable, bool checkType) { + System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; + bool isNull = false; + if (isNullable) isNull = ReadNull(); + if (checkType) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id18_SimpleBaseClass && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + } + else { + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id19_SimpleDerivedClass && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read19_SimpleDerivedClass(isNullable, false); + throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); + } + } + if (isNull) return null; + global::SimpleBaseClass o; + o = new global::SimpleBaseClass(); + System.Span paramsRead = stackalloc bool[2]; + while (Reader.MoveToNextAttribute()) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id182_AttributeString && (object) Reader.NamespaceURI == (object)id2_Item)) { + o.@AttributeString = Reader.Value; + paramsRead[0] = true; + } + else if (!paramsRead[1] && ((object) Reader.LocalName == (object)id183_DateTimeValue && (object) Reader.NamespaceURI == (object)id2_Item)) { + o.@DateTimeValue = ToDateTime(Reader.Value); + paramsRead[1] = true; + } + else if (!IsXmlnsAttribute(Reader.Name)) { + UnknownNode((object)o, @":AttributeString, :DateTimeValue"); + } + } + Reader.MoveToElement(); + if (Reader.IsEmptyElement) { + Reader.Skip(); + return o; + } + Reader.ReadStartElement(); + Reader.MoveToContent(); + while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { + if (Reader.NodeType == System.Xml.XmlNodeType.Element) { + UnknownNode((object)o, @""); + } + else { + UnknownNode((object)o, @""); + } + Reader.MoveToContent(); + } + ReadEndElement(); + return o; + } + + global::Address Read21_Address(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id20_Address && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id19_httpwwwcontoso1com)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id25_Address && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id24_httpwwwcontoso1com)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -8967,7 +9418,7 @@ internal System.Collections.Hashtable EnumFlagsValues { o = new global::Address(); System.Span paramsRead = stackalloc bool[5]; while (Reader.MoveToNextAttribute()) { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id115_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id122_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@Name = Reader.Value; paramsRead[0] = true; } @@ -8985,28 +9436,28 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id175_Line1 && (object) Reader.NamespaceURI == (object)id19_httpwwwcontoso1com)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id185_Line1 && (object) Reader.NamespaceURI == (object)id24_httpwwwcontoso1com)) { { o.@Line1 = Reader.ReadElementString(); } paramsRead[1] = true; break; } - if (!paramsRead[2] && ((object) Reader.LocalName == (object)id176_City && (object) Reader.NamespaceURI == (object)id19_httpwwwcontoso1com)) { + if (!paramsRead[2] && ((object) Reader.LocalName == (object)id186_City && (object) Reader.NamespaceURI == (object)id24_httpwwwcontoso1com)) { { o.@City = Reader.ReadElementString(); } paramsRead[2] = true; break; } - if (!paramsRead[3] && ((object) Reader.LocalName == (object)id177_State && (object) Reader.NamespaceURI == (object)id19_httpwwwcontoso1com)) { + if (!paramsRead[3] && ((object) Reader.LocalName == (object)id187_State && (object) Reader.NamespaceURI == (object)id24_httpwwwcontoso1com)) { { o.@State = Reader.ReadElementString(); } paramsRead[3] = true; break; } - if (!paramsRead[4] && ((object) Reader.LocalName == (object)id178_Zip && (object) Reader.NamespaceURI == (object)id19_httpwwwcontoso1com)) { + if (!paramsRead[4] && ((object) Reader.LocalName == (object)id188_Zip && (object) Reader.NamespaceURI == (object)id24_httpwwwcontoso1com)) { { o.@Zip = Reader.ReadElementString(); } @@ -9025,12 +9476,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::PurchaseOrder Read21_PurchaseOrder(bool isNullable, bool checkType) { + global::PurchaseOrder Read23_PurchaseOrder(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id18_PurchaseOrder && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id19_httpwwwcontoso1com)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id23_PurchaseOrder && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id24_httpwwwcontoso1com)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -9057,19 +9508,19 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id179_ShipTo && (object) Reader.NamespaceURI == (object)id19_httpwwwcontoso1com)) { - o.@ShipTo = Read19_Address(false, true); + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id189_ShipTo && (object) Reader.NamespaceURI == (object)id24_httpwwwcontoso1com)) { + o.@ShipTo = Read21_Address(false, true); paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id180_OrderDate && (object) Reader.NamespaceURI == (object)id19_httpwwwcontoso1com)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id190_OrderDate && (object) Reader.NamespaceURI == (object)id24_httpwwwcontoso1com)) { { o.@OrderDate = Reader.ReadElementString(); } paramsRead[1] = true; break; } - if (((object) Reader.LocalName == (object)id181_Items && (object) Reader.NamespaceURI == (object)id19_httpwwwcontoso1com)) { + if (((object) Reader.LocalName == (object)id191_Items && (object) Reader.NamespaceURI == (object)id24_httpwwwcontoso1com)) { if (!ReadNull()) { global::OrderedItem[] a_2_0 = null; int ca_2_0 = 0; @@ -9082,8 +9533,8 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id21_OrderedItem && (object) Reader.NamespaceURI == (object)id19_httpwwwcontoso1com)) { - a_2_0 = (global::OrderedItem[])EnsureArrayIndex(a_2_0, ca_2_0, typeof(global::OrderedItem));a_2_0[ca_2_0++] = Read20_OrderedItem(true, true); + if (((object) Reader.LocalName == (object)id26_OrderedItem && (object) Reader.NamespaceURI == (object)id24_httpwwwcontoso1com)) { + a_2_0 = (global::OrderedItem[])EnsureArrayIndex(a_2_0, ca_2_0, typeof(global::OrderedItem));a_2_0[ca_2_0++] = Read22_OrderedItem(true, true); break; } UnknownNode(null, @"http://www.contoso1.com:OrderedItem"); @@ -9100,21 +9551,21 @@ internal System.Collections.Hashtable EnumFlagsValues { } break; } - if (!paramsRead[3] && ((object) Reader.LocalName == (object)id182_SubTotal && (object) Reader.NamespaceURI == (object)id19_httpwwwcontoso1com)) { + if (!paramsRead[3] && ((object) Reader.LocalName == (object)id192_SubTotal && (object) Reader.NamespaceURI == (object)id24_httpwwwcontoso1com)) { { o.@SubTotal = System.Xml.XmlConvert.ToDecimal(Reader.ReadElementString()); } paramsRead[3] = true; break; } - if (!paramsRead[4] && ((object) Reader.LocalName == (object)id183_ShipCost && (object) Reader.NamespaceURI == (object)id19_httpwwwcontoso1com)) { + if (!paramsRead[4] && ((object) Reader.LocalName == (object)id193_ShipCost && (object) Reader.NamespaceURI == (object)id24_httpwwwcontoso1com)) { { o.@ShipCost = System.Xml.XmlConvert.ToDecimal(Reader.ReadElementString()); } paramsRead[4] = true; break; } - if (!paramsRead[5] && ((object) Reader.LocalName == (object)id184_TotalCost && (object) Reader.NamespaceURI == (object)id19_httpwwwcontoso1com)) { + if (!paramsRead[5] && ((object) Reader.LocalName == (object)id194_TotalCost && (object) Reader.NamespaceURI == (object)id24_httpwwwcontoso1com)) { { o.@TotalCost = System.Xml.XmlConvert.ToDecimal(Reader.ReadElementString()); } @@ -9133,12 +9584,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::Address Read22_Address(bool isNullable, bool checkType) { + global::Address Read24_Address(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id20_Address && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id25_Address && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -9149,7 +9600,7 @@ internal System.Collections.Hashtable EnumFlagsValues { o = new global::Address(); System.Span paramsRead = stackalloc bool[5]; while (Reader.MoveToNextAttribute()) { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id115_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id122_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@Name = Reader.Value; paramsRead[0] = true; } @@ -9167,28 +9618,28 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id175_Line1 && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id185_Line1 && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Line1 = Reader.ReadElementString(); } paramsRead[1] = true; break; } - if (!paramsRead[2] && ((object) Reader.LocalName == (object)id176_City && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[2] && ((object) Reader.LocalName == (object)id186_City && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@City = Reader.ReadElementString(); } paramsRead[2] = true; break; } - if (!paramsRead[3] && ((object) Reader.LocalName == (object)id177_State && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[3] && ((object) Reader.LocalName == (object)id187_State && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@State = Reader.ReadElementString(); } paramsRead[3] = true; break; } - if (!paramsRead[4] && ((object) Reader.LocalName == (object)id178_Zip && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[4] && ((object) Reader.LocalName == (object)id188_Zip && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Zip = Reader.ReadElementString(); } @@ -9207,12 +9658,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::OrderedItem Read23_OrderedItem(bool isNullable, bool checkType) { + global::OrderedItem Read25_OrderedItem(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id21_OrderedItem && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id26_OrderedItem && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -9237,35 +9688,35 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id153_ItemName && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id160_ItemName && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@ItemName = Reader.ReadElementString(); } paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id154_Description && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id161_Description && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Description = Reader.ReadElementString(); } paramsRead[1] = true; break; } - if (!paramsRead[2] && ((object) Reader.LocalName == (object)id155_UnitPrice && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[2] && ((object) Reader.LocalName == (object)id162_UnitPrice && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@UnitPrice = System.Xml.XmlConvert.ToDecimal(Reader.ReadElementString()); } paramsRead[2] = true; break; } - if (!paramsRead[3] && ((object) Reader.LocalName == (object)id156_Quantity && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[3] && ((object) Reader.LocalName == (object)id163_Quantity && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Quantity = System.Xml.XmlConvert.ToInt32(Reader.ReadElementString()); } paramsRead[3] = true; break; } - if (!paramsRead[4] && ((object) Reader.LocalName == (object)id157_LineTotal && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[4] && ((object) Reader.LocalName == (object)id164_LineTotal && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@LineTotal = System.Xml.XmlConvert.ToDecimal(Reader.ReadElementString()); } @@ -9284,12 +9735,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::AliasedTestType Read24_AliasedTestType(bool isNullable, bool checkType) { + global::AliasedTestType Read26_AliasedTestType(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id22_AliasedTestType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id27_AliasedTestType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -9314,7 +9765,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id185_X && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id195_X && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { if ((object)(o.@Aliased) == null) o.@Aliased = new global::System.Collections.Generic.List(); global::System.Collections.Generic.List a_0_0 = (global::System.Collections.Generic.List)o.@Aliased; @@ -9327,7 +9778,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id127_int && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id134_int && (object) Reader.NamespaceURI == (object)id2_Item)) { { a_0_0.Add(System.Xml.XmlConvert.ToInt32(Reader.ReadElementString())); } @@ -9347,7 +9798,7 @@ internal System.Collections.Hashtable EnumFlagsValues { paramsRead[0] = true; break; } - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id186_Y && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id196_Y && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { if ((object)(o.@Aliased) == null) o.@Aliased = new global::System.Collections.Generic.List(); global::System.Collections.Generic.List a_0_0 = (global::System.Collections.Generic.List)o.@Aliased; @@ -9360,7 +9811,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id129_string && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id136_string && (object) Reader.NamespaceURI == (object)id2_Item)) { if (ReadNull()) { a_0_0.Add(null); } @@ -9383,7 +9834,7 @@ internal System.Collections.Hashtable EnumFlagsValues { paramsRead[0] = true; break; } - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id187_Z && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id197_Z && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { if ((object)(o.@Aliased) == null) o.@Aliased = new global::System.Collections.Generic.List(); global::System.Collections.Generic.List a_0_0 = (global::System.Collections.Generic.List)o.@Aliased; @@ -9396,7 +9847,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id131_double && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id138_double && (object) Reader.NamespaceURI == (object)id2_Item)) { { a_0_0.Add(System.Xml.XmlConvert.ToDouble(Reader.ReadElementString())); } @@ -9428,12 +9879,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::DerivedClass1 Read26_DerivedClass1(bool isNullable, bool checkType) { + global::DerivedClass1 Read28_DerivedClass1(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id24_DerivedClass1 && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id29_DerivedClass1 && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -9460,7 +9911,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id188_Prop && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id198_Prop && (object) Reader.NamespaceURI == (object)id2_Item)) { { a_0.Add(ToDateTime(Reader.ReadElementString())); } @@ -9478,16 +9929,16 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::BaseClass1 Read25_BaseClass1(bool isNullable, bool checkType) { + global::BaseClass1 Read27_BaseClass1(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id23_BaseClass1 && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id28_BaseClass1 && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id24_DerivedClass1 && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read26_DerivedClass1(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id29_DerivedClass1 && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read28_DerivedClass1(isNullable, false); throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); } } @@ -9512,7 +9963,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id188_Prop && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id198_Prop && (object) Reader.NamespaceURI == (object)id2_Item)) { { a_0.Add(ToDateTime(Reader.ReadElementString())); } @@ -9530,12 +9981,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::Orchestra Read28_Orchestra(bool isNullable, bool checkType) { + global::Orchestra Read30_Orchestra(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id27_Orchestra && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id32_Orchestra && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -9562,7 +10013,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id189_Instruments && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id199_Instruments && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { global::Instrument[] a_0_0 = null; int ca_0_0 = 0; @@ -9575,8 +10026,8 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id28_Instrument && (object) Reader.NamespaceURI == (object)id2_Item)) { - a_0_0 = (global::Instrument[])EnsureArrayIndex(a_0_0, ca_0_0, typeof(global::Instrument));a_0_0[ca_0_0++] = Read27_Instrument(true, true); + if (((object) Reader.LocalName == (object)id33_Instrument && (object) Reader.NamespaceURI == (object)id2_Item)) { + a_0_0 = (global::Instrument[])EnsureArrayIndex(a_0_0, ca_0_0, typeof(global::Instrument));a_0_0[ca_0_0++] = Read29_Instrument(true, true); break; } UnknownNode(null, @":Instrument"); @@ -9605,12 +10056,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::Pet Read31_Pet(bool isNullable, bool checkType) { + global::Pet Read33_Pet(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id31_Pet && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id36_Pet && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -9642,7 +10093,7 @@ internal System.Collections.Hashtable EnumFlagsValues { paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id190_Comment2 && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id200_Comment2 && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Comment2 = Reader.ReadElementString(); } @@ -9661,12 +10112,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::DefaultValuesSetToNaN Read32_DefaultValuesSetToNaN(bool isNullable, bool checkType) { + global::DefaultValuesSetToNaN Read34_DefaultValuesSetToNaN(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id32_DefaultValuesSetToNaN && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id37_DefaultValuesSetToNaN && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -9691,7 +10142,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id191_DoubleField && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id201_DoubleField && (object) Reader.NamespaceURI == (object)id2_Item)) { if (Reader.IsEmptyElement) { Reader.Skip(); } @@ -9701,7 +10152,7 @@ internal System.Collections.Hashtable EnumFlagsValues { paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id192_SingleField && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id202_SingleField && (object) Reader.NamespaceURI == (object)id2_Item)) { if (Reader.IsEmptyElement) { Reader.Skip(); } @@ -9711,7 +10162,7 @@ internal System.Collections.Hashtable EnumFlagsValues { paramsRead[1] = true; break; } - if (!paramsRead[2] && ((object) Reader.LocalName == (object)id193_DoubleProp && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[2] && ((object) Reader.LocalName == (object)id203_DoubleProp && (object) Reader.NamespaceURI == (object)id2_Item)) { if (Reader.IsEmptyElement) { Reader.Skip(); } @@ -9721,7 +10172,7 @@ internal System.Collections.Hashtable EnumFlagsValues { paramsRead[2] = true; break; } - if (!paramsRead[3] && ((object) Reader.LocalName == (object)id194_FloatProp && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[3] && ((object) Reader.LocalName == (object)id204_FloatProp && (object) Reader.NamespaceURI == (object)id2_Item)) { if (Reader.IsEmptyElement) { Reader.Skip(); } @@ -9743,12 +10194,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::DefaultValuesSetToPositiveInfinity Read33_Item(bool isNullable, bool checkType) { + global::DefaultValuesSetToPositiveInfinity Read35_Item(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id33_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id38_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -9773,7 +10224,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id191_DoubleField && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id201_DoubleField && (object) Reader.NamespaceURI == (object)id2_Item)) { if (Reader.IsEmptyElement) { Reader.Skip(); } @@ -9783,7 +10234,7 @@ internal System.Collections.Hashtable EnumFlagsValues { paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id192_SingleField && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id202_SingleField && (object) Reader.NamespaceURI == (object)id2_Item)) { if (Reader.IsEmptyElement) { Reader.Skip(); } @@ -9793,7 +10244,7 @@ internal System.Collections.Hashtable EnumFlagsValues { paramsRead[1] = true; break; } - if (!paramsRead[2] && ((object) Reader.LocalName == (object)id193_DoubleProp && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[2] && ((object) Reader.LocalName == (object)id203_DoubleProp && (object) Reader.NamespaceURI == (object)id2_Item)) { if (Reader.IsEmptyElement) { Reader.Skip(); } @@ -9803,7 +10254,7 @@ internal System.Collections.Hashtable EnumFlagsValues { paramsRead[2] = true; break; } - if (!paramsRead[3] && ((object) Reader.LocalName == (object)id194_FloatProp && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[3] && ((object) Reader.LocalName == (object)id204_FloatProp && (object) Reader.NamespaceURI == (object)id2_Item)) { if (Reader.IsEmptyElement) { Reader.Skip(); } @@ -9825,12 +10276,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::DefaultValuesSetToNegativeInfinity Read34_Item(bool isNullable, bool checkType) { + global::DefaultValuesSetToNegativeInfinity Read36_Item(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id34_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id39_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -9855,7 +10306,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id191_DoubleField && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id201_DoubleField && (object) Reader.NamespaceURI == (object)id2_Item)) { if (Reader.IsEmptyElement) { Reader.Skip(); } @@ -9865,7 +10316,7 @@ internal System.Collections.Hashtable EnumFlagsValues { paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id192_SingleField && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id202_SingleField && (object) Reader.NamespaceURI == (object)id2_Item)) { if (Reader.IsEmptyElement) { Reader.Skip(); } @@ -9875,7 +10326,7 @@ internal System.Collections.Hashtable EnumFlagsValues { paramsRead[1] = true; break; } - if (!paramsRead[2] && ((object) Reader.LocalName == (object)id193_DoubleProp && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[2] && ((object) Reader.LocalName == (object)id203_DoubleProp && (object) Reader.NamespaceURI == (object)id2_Item)) { if (Reader.IsEmptyElement) { Reader.Skip(); } @@ -9885,7 +10336,7 @@ internal System.Collections.Hashtable EnumFlagsValues { paramsRead[2] = true; break; } - if (!paramsRead[3] && ((object) Reader.LocalName == (object)id194_FloatProp && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[3] && ((object) Reader.LocalName == (object)id204_FloatProp && (object) Reader.NamespaceURI == (object)id2_Item)) { if (Reader.IsEmptyElement) { Reader.Skip(); } @@ -9907,12 +10358,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::TypeWithMismatchBetweenAttributeAndPropertyType Read35_Item(bool isNullable, bool checkType) { + global::TypeWithMismatchBetweenAttributeAndPropertyType Read37_Item(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id124_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id131_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -9923,7 +10374,7 @@ internal System.Collections.Hashtable EnumFlagsValues { o = new global::TypeWithMismatchBetweenAttributeAndPropertyType(); System.Span paramsRead = stackalloc bool[1]; while (Reader.MoveToNextAttribute()) { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id195_IntValue && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id205_IntValue && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@IntValue = System.Xml.XmlConvert.ToInt32(Reader.Value); paramsRead[0] = true; } @@ -9951,12 +10402,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::MsgDocumentType Read37_MsgDocumentType(bool isNullable, bool checkType) { + global::MsgDocumentType Read39_MsgDocumentType(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id123_MsgDocumentType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id38_httpexamplecom)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id130_MsgDocumentType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id43_httpexamplecom)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -9969,11 +10420,11 @@ internal System.Collections.Hashtable EnumFlagsValues { int ca_1 = 0; System.Span paramsRead = stackalloc bool[2]; while (Reader.MoveToNextAttribute()) { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id196_id && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id206_id && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@Id = CollapseWhitespace(Reader.Value); paramsRead[0] = true; } - else if (((object) Reader.LocalName == (object)id197_refs && (object) Reader.NamespaceURI == (object)id2_Item)) { + else if (((object) Reader.LocalName == (object)id207_refs && (object) Reader.NamespaceURI == (object)id2_Item)) { string listValues = Reader.Value; string[] vals = listValues.Split(null); for (int i = 0; i < vals.Length; i++) { @@ -10006,12 +10457,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::RootClass Read40_RootClass(bool isNullable, bool checkType) { + global::RootClass Read42_RootClass(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id39_RootClass && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id44_RootClass && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -10038,7 +10489,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id198_Parameters && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id208_Parameters && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { if ((object)(o.@Parameters) == null) o.@Parameters = new global::System.Collections.Generic.List(); global::System.Collections.Generic.List a_0_0 = (global::System.Collections.Generic.List)o.@Parameters; @@ -10051,8 +10502,8 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id40_Parameter && (object) Reader.NamespaceURI == (object)id2_Item)) { - if ((object)(a_0_0) == null) Reader.Skip(); else a_0_0.Add(Read39_Parameter(true, true)); + if (((object) Reader.LocalName == (object)id45_Parameter && (object) Reader.NamespaceURI == (object)id2_Item)) { + if ((object)(a_0_0) == null) Reader.Skip(); else a_0_0.Add(Read41_Parameter(true, true)); break; } UnknownNode(null, @":Parameter"); @@ -10080,12 +10531,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::XElementWrapper Read41_XElementWrapper(bool isNullable, bool checkType) { + global::XElementWrapper Read43_XElementWrapper(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id41_XElementWrapper && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id46_XElementWrapper && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -10110,7 +10561,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id148_Value && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id155_Value && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@Value = (global::System.Xml.Linq.XElement)ReadSerializable(( System.Xml.Serialization.IXmlSerializable)new global::System.Xml.Linq.XElement("default"), true ); paramsRead[0] = true; @@ -10128,11 +10579,11 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::XElementStruct Read42_XElementStruct(bool checkType) { + global::XElementStruct Read44_XElementStruct(bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id42_XElementStruct && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id47_XElementStruct && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -10164,7 +10615,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id199_xelement && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id209_xelement && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@xelement = (global::System.Xml.Linq.XElement)ReadSerializable(( System.Xml.Serialization.IXmlSerializable)new global::System.Xml.Linq.XElement("default"), true ); paramsRead[0] = true; @@ -10182,12 +10633,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::XElementArrayWrapper Read43_XElementArrayWrapper(bool isNullable, bool checkType) { + global::XElementArrayWrapper Read45_XElementArrayWrapper(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id43_XElementArrayWrapper && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id48_XElementArrayWrapper && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -10214,7 +10665,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id200_xelements && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id210_xelements && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { global::System.Xml.Linq.XElement[] a_0_0 = null; int ca_0_0 = 0; @@ -10227,7 +10678,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id136_XElement && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id143_XElement && (object) Reader.NamespaceURI == (object)id2_Item)) { a_0_0 = (global::System.Xml.Linq.XElement[])EnsureArrayIndex(a_0_0, ca_0_0, typeof(global::System.Xml.Linq.XElement));a_0_0[ca_0_0++] = (global::System.Xml.Linq.XElement)ReadSerializable(( System.Xml.Serialization.IXmlSerializable)new global::System.Xml.Linq.XElement("default"), true ); break; @@ -10258,12 +10709,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeWithDateTimeStringProperty Read44_TypeWithDateTimeStringProperty(bool isNullable, bool checkType) { + global::SerializationTypes.TypeWithDateTimeStringProperty Read46_TypeWithDateTimeStringProperty(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id44_TypeWithDateTimeStringProperty && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id49_TypeWithDateTimeStringProperty && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -10288,14 +10739,14 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id201_DateTimeString && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id211_DateTimeString && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@DateTimeString = Reader.ReadElementString(); } paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id202_CurrentDateTime && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id212_CurrentDateTime && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@CurrentDateTime = ToDateTime(Reader.ReadElementString()); } @@ -10314,12 +10765,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeWithGetSetArrayMembers Read46_TypeWithGetSetArrayMembers(bool isNullable, bool checkType) { + global::SerializationTypes.TypeWithGetSetArrayMembers Read48_TypeWithGetSetArrayMembers(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id46_TypeWithGetSetArrayMembers && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id51_TypeWithGetSetArrayMembers && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -10352,7 +10803,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id203_F1 && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id213_F1 && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { global::SerializationTypes.SimpleType[] a_0_0 = null; int ca_0_0 = 0; @@ -10365,8 +10816,8 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id45_SimpleType && (object) Reader.NamespaceURI == (object)id2_Item)) { - a_0_0 = (global::SerializationTypes.SimpleType[])EnsureArrayIndex(a_0_0, ca_0_0, typeof(global::SerializationTypes.SimpleType));a_0_0[ca_0_0++] = Read45_SimpleType(true, true); + if (((object) Reader.LocalName == (object)id50_SimpleType && (object) Reader.NamespaceURI == (object)id2_Item)) { + a_0_0 = (global::SerializationTypes.SimpleType[])EnsureArrayIndex(a_0_0, ca_0_0, typeof(global::SerializationTypes.SimpleType));a_0_0[ca_0_0++] = Read47_SimpleType(true, true); break; } UnknownNode(null, @":SimpleType"); @@ -10383,7 +10834,7 @@ internal System.Collections.Hashtable EnumFlagsValues { } break; } - if (((object) Reader.LocalName == (object)id204_F2 && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id214_F2 && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { global::System.Int32[] a_1_0 = null; int ca_1_0 = 0; @@ -10396,7 +10847,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id127_int && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id134_int && (object) Reader.NamespaceURI == (object)id2_Item)) { { a_1_0 = (global::System.Int32[])EnsureArrayIndex(a_1_0, ca_1_0, typeof(global::System.Int32));a_1_0[ca_1_0++] = System.Xml.XmlConvert.ToInt32(Reader.ReadElementString()); } @@ -10416,7 +10867,7 @@ internal System.Collections.Hashtable EnumFlagsValues { } break; } - if (((object) Reader.LocalName == (object)id146_P1 && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id153_P1 && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { global::SerializationTypes.SimpleType[] a_2_0 = null; int ca_2_0 = 0; @@ -10429,8 +10880,8 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id45_SimpleType && (object) Reader.NamespaceURI == (object)id2_Item)) { - a_2_0 = (global::SerializationTypes.SimpleType[])EnsureArrayIndex(a_2_0, ca_2_0, typeof(global::SerializationTypes.SimpleType));a_2_0[ca_2_0++] = Read45_SimpleType(true, true); + if (((object) Reader.LocalName == (object)id50_SimpleType && (object) Reader.NamespaceURI == (object)id2_Item)) { + a_2_0 = (global::SerializationTypes.SimpleType[])EnsureArrayIndex(a_2_0, ca_2_0, typeof(global::SerializationTypes.SimpleType));a_2_0[ca_2_0++] = Read47_SimpleType(true, true); break; } UnknownNode(null, @":SimpleType"); @@ -10447,7 +10898,7 @@ internal System.Collections.Hashtable EnumFlagsValues { } break; } - if (((object) Reader.LocalName == (object)id147_P2 && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id154_P2 && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { global::System.Int32[] a_3_0 = null; int ca_3_0 = 0; @@ -10460,7 +10911,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id127_int && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id134_int && (object) Reader.NamespaceURI == (object)id2_Item)) { { a_3_0 = (global::System.Int32[])EnsureArrayIndex(a_3_0, ca_3_0, typeof(global::System.Int32));a_3_0[ca_3_0++] = System.Xml.XmlConvert.ToInt32(Reader.ReadElementString()); } @@ -10492,12 +10943,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeWithGetOnlyArrayProperties Read47_TypeWithGetOnlyArrayProperties(bool isNullable, bool checkType) { + global::SerializationTypes.TypeWithGetOnlyArrayProperties Read49_TypeWithGetOnlyArrayProperties(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id47_TypeWithGetOnlyArrayProperties && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id52_TypeWithGetOnlyArrayProperties && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -10532,11 +10983,11 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.StructNotSerializable Read48_StructNotSerializable(bool checkType) { + global::SerializationTypes.StructNotSerializable Read50_StructNotSerializable(bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id48_StructNotSerializable && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id53_StructNotSerializable && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -10568,7 +11019,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id174_value && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id181_value && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@value = System.Xml.XmlConvert.ToInt32(Reader.ReadElementString()); } @@ -10587,12 +11038,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeWithMyCollectionField Read49_TypeWithMyCollectionField(bool isNullable, bool checkType) { + global::SerializationTypes.TypeWithMyCollectionField Read51_TypeWithMyCollectionField(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id49_TypeWithMyCollectionField && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id54_TypeWithMyCollectionField && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -10619,7 +11070,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id205_Collection && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id215_Collection && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { if ((object)(o.@Collection) == null) o.@Collection = new global::SerializationTypes.MyCollection(); global::SerializationTypes.MyCollection a_0_0 = (global::SerializationTypes.MyCollection)o.@Collection; @@ -10632,7 +11083,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id129_string && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id136_string && (object) Reader.NamespaceURI == (object)id2_Item)) { if (ReadNull()) { a_0_0.Add(null); } @@ -10666,12 +11117,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeWithReadOnlyMyCollectionProperty Read50_Item(bool isNullable, bool checkType) { + global::SerializationTypes.TypeWithReadOnlyMyCollectionProperty Read52_Item(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id50_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id55_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -10697,7 +11148,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id205_Collection && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id215_Collection && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { global::SerializationTypes.MyCollection a_0_0 = (global::SerializationTypes.MyCollection)o.@Collection; if (((object)(a_0_0) == null) || (Reader.IsEmptyElement)) { @@ -10709,7 +11160,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id129_string && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id136_string && (object) Reader.NamespaceURI == (object)id2_Item)) { if (ReadNull()) { a_0_0.Add(null); } @@ -10743,12 +11194,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeWithEnumMembers Read52_TypeWithEnumMembers(bool isNullable, bool checkType) { + global::SerializationTypes.TypeWithEnumMembers Read54_TypeWithEnumMembers(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id54_TypeWithEnumMembers && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id59_TypeWithEnumMembers && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -10773,16 +11224,16 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id203_F1 && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id213_F1 && (object) Reader.NamespaceURI == (object)id2_Item)) { { - o.@F1 = Read51_MyEnum(Reader.ReadElementString()); + o.@F1 = Read53_MyEnum(Reader.ReadElementString()); } paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id146_P1 && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id153_P1 && (object) Reader.NamespaceURI == (object)id2_Item)) { { - o.@P1 = Read51_MyEnum(Reader.ReadElementString()); + o.@P1 = Read53_MyEnum(Reader.ReadElementString()); } paramsRead[1] = true; break; @@ -10799,11 +11250,11 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.DCStruct Read53_DCStruct(bool checkType) { + global::SerializationTypes.DCStruct Read55_DCStruct(bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id55_DCStruct && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id60_DCStruct && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -10835,7 +11286,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id206_Data && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id216_Data && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Data = Reader.ReadElementString(); } @@ -10854,12 +11305,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.DCClassWithEnumAndStruct Read54_DCClassWithEnumAndStruct(bool isNullable, bool checkType) { + global::SerializationTypes.DCClassWithEnumAndStruct Read56_DCClassWithEnumAndStruct(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id56_DCClassWithEnumAndStruct && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id61_DCClassWithEnumAndStruct && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -10884,14 +11335,14 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id207_MyStruct && (object) Reader.NamespaceURI == (object)id2_Item)) { - o.@MyStruct = Read53_DCStruct(true); + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id217_MyStruct && (object) Reader.NamespaceURI == (object)id2_Item)) { + o.@MyStruct = Read55_DCStruct(true); paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id208_MyEnum1 && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id218_MyEnum1 && (object) Reader.NamespaceURI == (object)id2_Item)) { { - o.@MyEnum1 = Read51_MyEnum(Reader.ReadElementString()); + o.@MyEnum1 = Read53_MyEnum(Reader.ReadElementString()); } paramsRead[1] = true; break; @@ -10908,12 +11359,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.BuiltInTypes Read55_BuiltInTypes(bool isNullable, bool checkType) { + global::SerializationTypes.BuiltInTypes Read57_BuiltInTypes(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id57_BuiltInTypes && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id62_BuiltInTypes && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -10938,7 +11389,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id209_ByteArray && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id219_ByteArray && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@ByteArray = ToByteArrayBase64(false); } @@ -10957,12 +11408,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeB Read57_TypeB(bool isNullable, bool checkType) { + global::SerializationTypes.TypeB Read59_TypeB(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id59_TypeB && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id64_TypeB && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -10987,7 +11438,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id115_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id122_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Name = Reader.ReadElementString(); } @@ -11006,12 +11457,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeHasArrayOfASerializedAsB Read58_TypeHasArrayOfASerializedAsB(bool isNullable, bool checkType) { + global::SerializationTypes.TypeHasArrayOfASerializedAsB Read60_TypeHasArrayOfASerializedAsB(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id60_TypeHasArrayOfASerializedAsB && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id65_TypeHasArrayOfASerializedAsB && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -11038,7 +11489,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id181_Items && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id191_Items && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { global::SerializationTypes.TypeA[] a_0_0 = null; int ca_0_0 = 0; @@ -11051,8 +11502,8 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id58_TypeA && (object) Reader.NamespaceURI == (object)id2_Item)) { - a_0_0 = (global::SerializationTypes.TypeA[])EnsureArrayIndex(a_0_0, ca_0_0, typeof(global::SerializationTypes.TypeA));a_0_0[ca_0_0++] = Read56_TypeA(true, true); + if (((object) Reader.LocalName == (object)id63_TypeA && (object) Reader.NamespaceURI == (object)id2_Item)) { + a_0_0 = (global::SerializationTypes.TypeA[])EnsureArrayIndex(a_0_0, ca_0_0, typeof(global::SerializationTypes.TypeA));a_0_0[ca_0_0++] = Read58_TypeA(true, true); break; } UnknownNode(null, @":TypeA"); @@ -11081,12 +11532,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.@__TypeNameWithSpecialCharacters漢ñ Read59_Item(bool isNullable, bool checkType) { + global::SerializationTypes.@__TypeNameWithSpecialCharacters漢ñ Read61_Item(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id61_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id66_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -11111,7 +11562,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id210_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id220_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@PropertyNameWithSpecialCharacters漢ñ = Reader.ReadElementString(); } @@ -11130,12 +11581,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.DerivedClassWithSameProperty2 Read62_DerivedClassWithSameProperty2(bool isNullable, bool checkType) { + global::SerializationTypes.DerivedClassWithSameProperty2 Read64_DerivedClassWithSameProperty2(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id64_DerivedClassWithSameProperty2 && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id69_DerivedClassWithSameProperty2 && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -11162,28 +11613,28 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id211_StringProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id221_StringProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@StringProperty = Reader.ReadElementString(); } paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id212_IntProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id222_IntProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@IntProperty = System.Xml.XmlConvert.ToInt32(Reader.ReadElementString()); } paramsRead[1] = true; break; } - if (!paramsRead[2] && ((object) Reader.LocalName == (object)id213_DateTimeProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[2] && ((object) Reader.LocalName == (object)id223_DateTimeProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@DateTimeProperty = ToDateTime(Reader.ReadElementString()); } paramsRead[2] = true; break; } - if (((object) Reader.LocalName == (object)id214_ListProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id224_ListProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { if ((object)(o.@ListProperty) == null) o.@ListProperty = new global::System.Collections.Generic.List(); global::System.Collections.Generic.List a_3_0 = (global::System.Collections.Generic.List)o.@ListProperty; @@ -11196,7 +11647,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id129_string && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id136_string && (object) Reader.NamespaceURI == (object)id2_Item)) { if (ReadNull()) { a_3_0.Add(null); } @@ -11230,16 +11681,16 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.DerivedClassWithSameProperty Read61_DerivedClassWithSameProperty(bool isNullable, bool checkType) { + global::SerializationTypes.DerivedClassWithSameProperty Read63_DerivedClassWithSameProperty(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id63_DerivedClassWithSameProperty && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id68_DerivedClassWithSameProperty && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id64_DerivedClassWithSameProperty2 && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read62_DerivedClassWithSameProperty2(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id69_DerivedClassWithSameProperty2 && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read64_DerivedClassWithSameProperty2(isNullable, false); throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); } } @@ -11264,28 +11715,28 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id211_StringProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id221_StringProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@StringProperty = Reader.ReadElementString(); } paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id212_IntProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id222_IntProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@IntProperty = System.Xml.XmlConvert.ToInt32(Reader.ReadElementString()); } paramsRead[1] = true; break; } - if (!paramsRead[2] && ((object) Reader.LocalName == (object)id213_DateTimeProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[2] && ((object) Reader.LocalName == (object)id223_DateTimeProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@DateTimeProperty = ToDateTime(Reader.ReadElementString()); } paramsRead[2] = true; break; } - if (((object) Reader.LocalName == (object)id214_ListProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id224_ListProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { if ((object)(o.@ListProperty) == null) o.@ListProperty = new global::System.Collections.Generic.List(); global::System.Collections.Generic.List a_3_0 = (global::System.Collections.Generic.List)o.@ListProperty; @@ -11298,7 +11749,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id129_string && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id136_string && (object) Reader.NamespaceURI == (object)id2_Item)) { if (ReadNull()) { a_3_0.Add(null); } @@ -11332,18 +11783,18 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.BaseClassWithSamePropertyName Read60_BaseClassWithSamePropertyName(bool isNullable, bool checkType) { + global::SerializationTypes.BaseClassWithSamePropertyName Read62_BaseClassWithSamePropertyName(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id62_BaseClassWithSamePropertyName && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id67_BaseClassWithSamePropertyName && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id63_DerivedClassWithSameProperty && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read61_DerivedClassWithSameProperty(isNullable, false); - if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id64_DerivedClassWithSameProperty2 && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) - return Read62_DerivedClassWithSameProperty2(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id68_DerivedClassWithSameProperty && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read63_DerivedClassWithSameProperty(isNullable, false); + if (((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id69_DerivedClassWithSameProperty2 && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) + return Read64_DerivedClassWithSameProperty2(isNullable, false); throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); } } @@ -11368,28 +11819,28 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id211_StringProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id221_StringProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@StringProperty = Reader.ReadElementString(); } paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id212_IntProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id222_IntProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@IntProperty = System.Xml.XmlConvert.ToInt32(Reader.ReadElementString()); } paramsRead[1] = true; break; } - if (!paramsRead[2] && ((object) Reader.LocalName == (object)id213_DateTimeProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[2] && ((object) Reader.LocalName == (object)id223_DateTimeProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@DateTimeProperty = ToDateTime(Reader.ReadElementString()); } paramsRead[2] = true; break; } - if (((object) Reader.LocalName == (object)id214_ListProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id224_ListProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { if ((object)(o.@ListProperty) == null) o.@ListProperty = new global::System.Collections.Generic.List(); global::System.Collections.Generic.List a_3_0 = (global::System.Collections.Generic.List)o.@ListProperty; @@ -11402,7 +11853,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id129_string && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id136_string && (object) Reader.NamespaceURI == (object)id2_Item)) { if (ReadNull()) { a_3_0.Add(null); } @@ -11436,12 +11887,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeWithDateTimePropertyAsXmlTime Read63_Item(bool isNullable, bool checkType) { + global::SerializationTypes.TypeWithDateTimePropertyAsXmlTime Read65_Item(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id65_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id70_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -11483,12 +11934,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeWithByteArrayAsXmlText Read64_TypeWithByteArrayAsXmlText(bool isNullable, bool checkType) { + global::SerializationTypes.TypeWithByteArrayAsXmlText Read66_TypeWithByteArrayAsXmlText(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id66_TypeWithByteArrayAsXmlText && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id71_TypeWithByteArrayAsXmlText && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -11530,12 +11981,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.SimpleDC Read65_SimpleDC(bool isNullable, bool checkType) { + global::SerializationTypes.SimpleDC Read67_SimpleDC(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id67_SimpleDC && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id72_SimpleDC && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -11560,7 +12011,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id206_Data && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id216_Data && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Data = Reader.ReadElementString(); } @@ -11579,12 +12030,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeWithXmlTextAttributeOnArray Read66_Item(bool isNullable, bool checkType) { + global::SerializationTypes.TypeWithXmlTextAttributeOnArray Read68_Item(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id68_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id69_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id73_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id74_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -11630,12 +12081,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.ClassImplementsInterface Read68_ClassImplementsInterface(bool isNullable, bool checkType) { + global::SerializationTypes.ClassImplementsInterface Read70_ClassImplementsInterface(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id71_ClassImplementsInterface && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id76_ClassImplementsInterface && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -11660,28 +12111,28 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id215_ClassID && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id225_ClassID && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@ClassID = Reader.ReadElementString(); } paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id216_DisplayName && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id226_DisplayName && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@DisplayName = Reader.ReadElementString(); } paramsRead[1] = true; break; } - if (!paramsRead[2] && ((object) Reader.LocalName == (object)id217_Id && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[2] && ((object) Reader.LocalName == (object)id227_Id && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Id = Reader.ReadElementString(); } paramsRead[2] = true; break; } - if (!paramsRead[3] && ((object) Reader.LocalName == (object)id218_IsLoaded && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[3] && ((object) Reader.LocalName == (object)id228_IsLoaded && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@IsLoaded = System.Xml.XmlConvert.ToBoolean(Reader.ReadElementString()); } @@ -11700,11 +12151,11 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.SomeStruct Read69_SomeStruct(bool checkType) { + global::SerializationTypes.SomeStruct Read71_SomeStruct(bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id73_SomeStruct && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id78_SomeStruct && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -11736,14 +12187,14 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id117_A && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id124_A && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@A = System.Xml.XmlConvert.ToInt32(Reader.ReadElementString()); } paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id118_B && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id125_B && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@B = System.Xml.XmlConvert.ToInt32(Reader.ReadElementString()); } @@ -11762,12 +12213,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.WithStruct Read70_WithStruct(bool isNullable, bool checkType) { + global::SerializationTypes.WithStruct Read72_WithStruct(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id72_WithStruct && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id77_WithStruct && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -11792,8 +12243,8 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id219_Some && (object) Reader.NamespaceURI == (object)id2_Item)) { - o.@Some = Read69_SomeStruct(true); + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id229_Some && (object) Reader.NamespaceURI == (object)id2_Item)) { + o.@Some = Read71_SomeStruct(true); paramsRead[0] = true; break; } @@ -11809,12 +12260,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.WithEnums Read73_WithEnums(bool isNullable, bool checkType) { + global::SerializationTypes.WithEnums Read75_WithEnums(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id74_WithEnums && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id79_WithEnums && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -11839,16 +12290,16 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id220_Int && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id230_Int && (object) Reader.NamespaceURI == (object)id2_Item)) { { - o.@Int = Read71_IntEnum(Reader.ReadElementString()); + o.@Int = Read73_IntEnum(Reader.ReadElementString()); } paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id221_Short && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id231_Short && (object) Reader.NamespaceURI == (object)id2_Item)) { { - o.@Short = Read72_ShortEnum(Reader.ReadElementString()); + o.@Short = Read74_ShortEnum(Reader.ReadElementString()); } paramsRead[1] = true; break; @@ -11865,12 +12316,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.WithNullables Read77_WithNullables(bool isNullable, bool checkType) { + global::SerializationTypes.WithNullables Read79_WithNullables(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id75_WithNullables && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id80_WithNullables && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -11895,33 +12346,33 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id222_Optional && (object) Reader.NamespaceURI == (object)id2_Item)) { - o.@Optional = Read74_NullableOfIntEnum(true); + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id232_Optional && (object) Reader.NamespaceURI == (object)id2_Item)) { + o.@Optional = Read76_NullableOfIntEnum(true); paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id223_Optionull && (object) Reader.NamespaceURI == (object)id2_Item)) { - o.@Optionull = Read74_NullableOfIntEnum(true); + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id233_Optionull && (object) Reader.NamespaceURI == (object)id2_Item)) { + o.@Optionull = Read76_NullableOfIntEnum(true); paramsRead[1] = true; break; } - if (!paramsRead[2] && ((object) Reader.LocalName == (object)id224_OptionalInt && (object) Reader.NamespaceURI == (object)id2_Item)) { - o.@OptionalInt = Read75_NullableOfInt32(true); + if (!paramsRead[2] && ((object) Reader.LocalName == (object)id234_OptionalInt && (object) Reader.NamespaceURI == (object)id2_Item)) { + o.@OptionalInt = Read77_NullableOfInt32(true); paramsRead[2] = true; break; } - if (!paramsRead[3] && ((object) Reader.LocalName == (object)id225_OptionullInt && (object) Reader.NamespaceURI == (object)id2_Item)) { - o.@OptionullInt = Read75_NullableOfInt32(true); + if (!paramsRead[3] && ((object) Reader.LocalName == (object)id235_OptionullInt && (object) Reader.NamespaceURI == (object)id2_Item)) { + o.@OptionullInt = Read77_NullableOfInt32(true); paramsRead[3] = true; break; } - if (!paramsRead[4] && ((object) Reader.LocalName == (object)id226_Struct1 && (object) Reader.NamespaceURI == (object)id2_Item)) { - o.@Struct1 = Read76_NullableOfSomeStruct(true); + if (!paramsRead[4] && ((object) Reader.LocalName == (object)id236_Struct1 && (object) Reader.NamespaceURI == (object)id2_Item)) { + o.@Struct1 = Read78_NullableOfSomeStruct(true); paramsRead[4] = true; break; } - if (!paramsRead[5] && ((object) Reader.LocalName == (object)id227_Struct2 && (object) Reader.NamespaceURI == (object)id2_Item)) { - o.@Struct2 = Read76_NullableOfSomeStruct(true); + if (!paramsRead[5] && ((object) Reader.LocalName == (object)id237_Struct2 && (object) Reader.NamespaceURI == (object)id2_Item)) { + o.@Struct2 = Read78_NullableOfSomeStruct(true); paramsRead[5] = true; break; } @@ -11937,15 +12388,15 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::System.Nullable Read76_NullableOfSomeStruct(bool checkType) { + global::System.Nullable Read78_NullableOfSomeStruct(bool checkType) { global::System.Nullable o = default(global::System.Nullable); if (ReadNull()) return o; - o = Read69_SomeStruct(true); + o = Read71_SomeStruct(true); return o; } - global::System.Nullable Read75_NullableOfInt32(bool checkType) { + global::System.Nullable Read77_NullableOfInt32(bool checkType) { global::System.Nullable o = default(global::System.Nullable); if (ReadNull()) return o; @@ -11955,22 +12406,22 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::System.Nullable Read74_NullableOfIntEnum(bool checkType) { + global::System.Nullable Read76_NullableOfIntEnum(bool checkType) { global::System.Nullable o = default(global::System.Nullable); if (ReadNull()) return o; { - o = Read71_IntEnum(Reader.ReadElementString()); + o = Read73_IntEnum(Reader.ReadElementString()); } return o; } - global::SerializationTypes.XmlSerializerAttributes Read84_XmlSerializerAttributes(bool isNullable, bool checkType) { + global::SerializationTypes.XmlSerializerAttributes Read86_XmlSerializerAttributes(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id121_XmlSerializerAttributes && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id128_XmlSerializerAttributes && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -11985,7 +12436,7 @@ internal System.Collections.Hashtable EnumFlagsValues { int ca_7 = 0; System.Span paramsRead = stackalloc bool[8]; while (Reader.MoveToNextAttribute()) { - if (!paramsRead[6] && ((object) Reader.LocalName == (object)id228_XmlAttributeName && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[6] && ((object) Reader.LocalName == (object)id238_XmlAttributeName && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@XmlAttributeProperty = System.Xml.XmlConvert.ToInt32(Reader.Value); paramsRead[6] = true; } @@ -12004,7 +12455,7 @@ internal System.Collections.Hashtable EnumFlagsValues { string tmp = null; if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id229_Word && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id239_Word && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@MyChoice = Reader.ReadElementString(); } @@ -12012,7 +12463,7 @@ internal System.Collections.Hashtable EnumFlagsValues { paramsRead[0] = true; break; } - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id230_Number && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id240_Number && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@MyChoice = System.Xml.XmlConvert.ToInt32(Reader.ReadElementString()); } @@ -12020,7 +12471,7 @@ internal System.Collections.Hashtable EnumFlagsValues { paramsRead[0] = true; break; } - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id231_DecimalNumber && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id241_DecimalNumber && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@MyChoice = System.Xml.XmlConvert.ToDouble(Reader.ReadElementString()); } @@ -12028,12 +12479,12 @@ internal System.Collections.Hashtable EnumFlagsValues { paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id232_XmlIncludeProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id242_XmlIncludeProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@XmlIncludeProperty = Read1_Object(false, true); paramsRead[1] = true; break; } - if (((object) Reader.LocalName == (object)id233_XmlEnumProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id243_XmlEnumProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { global::SerializationTypes.ItemChoiceType[] a_2_0 = null; int ca_2_0 = 0; @@ -12046,9 +12497,9 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id84_ItemChoiceType && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id89_ItemChoiceType && (object) Reader.NamespaceURI == (object)id2_Item)) { { - a_2_0 = (global::SerializationTypes.ItemChoiceType[])EnsureArrayIndex(a_2_0, ca_2_0, typeof(global::SerializationTypes.ItemChoiceType));a_2_0[ca_2_0++] = Read83_ItemChoiceType(Reader.ReadElementString()); + a_2_0 = (global::SerializationTypes.ItemChoiceType[])EnsureArrayIndex(a_2_0, ca_2_0, typeof(global::SerializationTypes.ItemChoiceType));a_2_0[ca_2_0++] = Read85_ItemChoiceType(Reader.ReadElementString()); } break; } @@ -12066,21 +12517,21 @@ internal System.Collections.Hashtable EnumFlagsValues { } break; } - if (!paramsRead[4] && ((object) Reader.LocalName == (object)id234_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[4] && ((object) Reader.LocalName == (object)id244_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@XmlNamespaceDeclarationsProperty = Reader.ReadElementString(); } paramsRead[4] = true; break; } - if (!paramsRead[5] && ((object) Reader.LocalName == (object)id235_XmlElementPropertyNode && (object) Reader.NamespaceURI == (object)id236_httpelement)) { + if (!paramsRead[5] && ((object) Reader.LocalName == (object)id245_XmlElementPropertyNode && (object) Reader.NamespaceURI == (object)id246_httpelement)) { { o.@XmlElementProperty = System.Xml.XmlConvert.ToInt32(Reader.ReadElementString()); } paramsRead[5] = true; break; } - if (((object) Reader.LocalName == (object)id237_CustomXmlArrayProperty && (object) Reader.NamespaceURI == (object)id140_httpmynamespace)) { + if (((object) Reader.LocalName == (object)id247_CustomXmlArrayProperty && (object) Reader.NamespaceURI == (object)id147_httpmynamespace)) { if (!ReadNull()) { global::System.Object[] a_7_0 = null; int ca_7_0 = 0; @@ -12093,7 +12544,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id129_string && (object) Reader.NamespaceURI == (object)id140_httpmynamespace)) { + if (((object) Reader.LocalName == (object)id136_string && (object) Reader.NamespaceURI == (object)id147_httpmynamespace)) { if (ReadNull()) { a_7_0 = (global::System.Object[])EnsureArrayIndex(a_7_0, ca_7_0, typeof(global::System.Object));a_7_0[ca_7_0++] = null; } @@ -12135,12 +12586,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeWithAnyAttribute Read85_TypeWithAnyAttribute(bool isNullable, bool checkType) { + global::SerializationTypes.TypeWithAnyAttribute Read87_TypeWithAnyAttribute(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id85_TypeWithAnyAttribute && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id90_TypeWithAnyAttribute && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -12153,7 +12604,7 @@ internal System.Collections.Hashtable EnumFlagsValues { int ca_2 = 0; System.Span paramsRead = stackalloc bool[3]; while (Reader.MoveToNextAttribute()) { - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id212_IntProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id222_IntProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@IntProperty = System.Xml.XmlConvert.ToInt32(Reader.Value); paramsRead[1] = true; } @@ -12175,7 +12626,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id115_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id122_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Name = Reader.ReadElementString(); } @@ -12195,12 +12646,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.KnownTypesThroughConstructor Read86_KnownTypesThroughConstructor(bool isNullable, bool checkType) { + global::SerializationTypes.KnownTypesThroughConstructor Read88_KnownTypesThroughConstructor(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id86_KnownTypesThroughConstructor && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id91_KnownTypesThroughConstructor && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -12225,12 +12676,12 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id238_EnumValue && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id248_EnumValue && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@EnumValue = Read1_Object(false, true); paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id239_SimpleTypeValue && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id249_SimpleTypeValue && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@SimpleTypeValue = Read1_Object(false, true); paramsRead[1] = true; break; @@ -12247,12 +12698,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.SimpleKnownTypeValue Read87_SimpleKnownTypeValue(bool isNullable, bool checkType) { + global::SerializationTypes.SimpleKnownTypeValue Read89_SimpleKnownTypeValue(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id87_SimpleKnownTypeValue && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id92_SimpleKnownTypeValue && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -12277,7 +12728,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id240_StrProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id250_StrProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@StrProperty = Reader.ReadElementString(); } @@ -12296,12 +12747,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeWithPropertyNameSpecified Read88_TypeWithPropertyNameSpecified(bool isNullable, bool checkType) { + global::SerializationTypes.TypeWithPropertyNameSpecified Read90_TypeWithPropertyNameSpecified(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id89_TypeWithPropertyNameSpecified && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id94_TypeWithPropertyNameSpecified && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -12326,7 +12777,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id241_MyField && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id251_MyField && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@MyFieldSpecified = true; { o.@MyField = Reader.ReadElementString(); @@ -12334,7 +12785,7 @@ internal System.Collections.Hashtable EnumFlagsValues { paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id242_MyFieldIgnored && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id252_MyFieldIgnored && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@MyFieldIgnoredSpecified = true; { o.@MyFieldIgnored = System.Xml.XmlConvert.ToInt32(Reader.ReadElementString()); @@ -12354,12 +12805,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeWithXmlSchemaFormAttribute Read89_TypeWithXmlSchemaFormAttribute(bool isNullable, bool checkType) { + global::SerializationTypes.TypeWithXmlSchemaFormAttribute Read91_TypeWithXmlSchemaFormAttribute(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id90_TypeWithXmlSchemaFormAttribute && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id95_TypeWithXmlSchemaFormAttribute && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -12390,7 +12841,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id243_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id253_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { if ((object)(o.@UnqualifiedSchemaFormListProperty) == null) o.@UnqualifiedSchemaFormListProperty = new global::System.Collections.Generic.List(); global::System.Collections.Generic.List a_0_0 = (global::System.Collections.Generic.List)o.@UnqualifiedSchemaFormListProperty; @@ -12403,7 +12854,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id127_int && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id134_int && (object) Reader.NamespaceURI == (object)id2_Item)) { { a_0_0.Add(System.Xml.XmlConvert.ToInt32(Reader.ReadElementString())); } @@ -12422,7 +12873,7 @@ internal System.Collections.Hashtable EnumFlagsValues { } break; } - if (((object) Reader.LocalName == (object)id244_NoneSchemaFormListProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id254_NoneSchemaFormListProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { if ((object)(o.@NoneSchemaFormListProperty) == null) o.@NoneSchemaFormListProperty = new global::System.Collections.Generic.List(); global::System.Collections.Generic.List a_1_0 = (global::System.Collections.Generic.List)o.@NoneSchemaFormListProperty; @@ -12435,7 +12886,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id142_NoneParameter && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id149_NoneParameter && (object) Reader.NamespaceURI == (object)id2_Item)) { { a_1_0.Add(Reader.ReadElementString()); } @@ -12454,7 +12905,7 @@ internal System.Collections.Hashtable EnumFlagsValues { } break; } - if (((object) Reader.LocalName == (object)id245_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id255_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { if ((object)(o.@QualifiedSchemaFormListProperty) == null) o.@QualifiedSchemaFormListProperty = new global::System.Collections.Generic.List(); global::System.Collections.Generic.List a_2_0 = (global::System.Collections.Generic.List)o.@QualifiedSchemaFormListProperty; @@ -12467,7 +12918,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id144_QualifiedParameter && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id151_QualifiedParameter && (object) Reader.NamespaceURI == (object)id2_Item)) { { a_2_0.Add(System.Xml.XmlConvert.ToBoolean(Reader.ReadElementString())); } @@ -12498,12 +12949,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeWithTypeNameInXmlTypeAttribute Read90_Item(bool isNullable, bool checkType) { + global::SerializationTypes.TypeWithTypeNameInXmlTypeAttribute Read92_Item(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id91_MyXmlType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id96_MyXmlType && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -12514,7 +12965,7 @@ internal System.Collections.Hashtable EnumFlagsValues { o = new global::SerializationTypes.TypeWithTypeNameInXmlTypeAttribute(); System.Span paramsRead = stackalloc bool[1]; while (Reader.MoveToNextAttribute()) { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id246_XmlAttributeForm && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id256_XmlAttributeForm && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@XmlAttributeForm = Reader.Value; paramsRead[0] = true; } @@ -12542,12 +12993,122 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeWithNonPublicDefaultConstructor Read92_Item(bool isNullable, bool checkType) { + global::SerializationTypes.CustomElement Read94_CustomElement(bool isNullable, bool checkType) { + System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; + bool isNull = false; + if (isNullable) isNull = ReadNull(); + if (checkType) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id99_CustomElement && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + } + else { + throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); + } + } + if (isNull) return null; + global::SerializationTypes.CustomElement o; + o = new global::SerializationTypes.CustomElement(); + global::System.Xml.XmlAttribute[] a_1 = null; + int ca_1 = 0; + global::System.Xml.XmlNode[] a_2 = null; + int ca_2 = 0; + System.Span paramsRead = stackalloc bool[3]; + while (Reader.MoveToNextAttribute()) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id257_name && (object) Reader.NamespaceURI == (object)id2_Item)) { + o.@Name = Reader.Value; + paramsRead[0] = true; + } + else if (!IsXmlnsAttribute(Reader.Name)) { + System.Xml.XmlAttribute attr = (System.Xml.XmlAttribute) Document.ReadNode(Reader); + ParseWsdlArrayType(attr); + if (attr is System.Xml.XmlAttribute) { + a_2 = (global::System.Xml.XmlNode[])EnsureArrayIndex(a_2, ca_2, typeof(global::System.Xml.XmlNode));a_2[ca_2++] = (System.Xml.XmlAttribute)attr; + } + } + } + o.@Attributes = (global::System.Xml.XmlAttribute[])ShrinkArray(a_1, ca_1, typeof(global::System.Xml.XmlAttribute), true); + o.@CustomAttributes = (global::System.Xml.XmlNode[])ShrinkArray(a_2, ca_2, typeof(global::System.Xml.XmlNode), true); + Reader.MoveToElement(); + if (Reader.IsEmptyElement) { + Reader.Skip(); + o.@Attributes = (global::System.Xml.XmlAttribute[])ShrinkArray(a_1, ca_1, typeof(global::System.Xml.XmlAttribute), true); + o.@CustomAttributes = (global::System.Xml.XmlNode[])ShrinkArray(a_2, ca_2, typeof(global::System.Xml.XmlNode), true); + return o; + } + Reader.ReadStartElement(); + Reader.MoveToContent(); + while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { + if (Reader.NodeType == System.Xml.XmlNodeType.Element) { + UnknownNode((object)o, @""); + } + else { + UnknownNode((object)o, @""); + } + Reader.MoveToContent(); + } + o.@Attributes = (global::System.Xml.XmlAttribute[])ShrinkArray(a_1, ca_1, typeof(global::System.Xml.XmlAttribute), true); + o.@CustomAttributes = (global::System.Xml.XmlNode[])ShrinkArray(a_2, ca_2, typeof(global::System.Xml.XmlNode), true); + ReadEndElement(); + return o; + } + + global::SerializationTypes.CustomDocument Read95_CustomDocument(bool isNullable, bool checkType) { + System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; + bool isNull = false; + if (isNullable) isNull = ReadNull(); + if (checkType) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id98_CustomDocument && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + } + else { + throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); + } + } + if (isNull) return null; + global::SerializationTypes.CustomDocument o; + o = new global::SerializationTypes.CustomDocument(); + if ((object)(o.@CustomItems) == null) o.@CustomItems = new global::System.Collections.Generic.List(); + global::System.Collections.Generic.List a_0 = (global::System.Collections.Generic.List)o.@CustomItems; + global::System.Xml.XmlNode[] a_1 = null; + int ca_1 = 0; + System.Span paramsRead = stackalloc bool[2]; + while (Reader.MoveToNextAttribute()) { + if (!IsXmlnsAttribute(Reader.Name)) { + UnknownNode((object)o); + } + } + Reader.MoveToElement(); + if (Reader.IsEmptyElement) { + Reader.Skip(); + o.@Items = (global::System.Xml.XmlNode[])ShrinkArray(a_1, ca_1, typeof(global::System.Xml.XmlNode), true); + return o; + } + Reader.ReadStartElement(); + Reader.MoveToContent(); + while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { + if (Reader.NodeType == System.Xml.XmlNodeType.Element) { + do { + if (((object) Reader.LocalName == (object)id258_customElement && (object) Reader.NamespaceURI == (object)id2_Item)) { + if ((object)(a_0) == null) Reader.Skip(); else a_0.Add(Read94_CustomElement(false, true)); + break; + } + a_1 = (global::System.Xml.XmlNode[])EnsureArrayIndex(a_1, ca_1, typeof(global::System.Xml.XmlNode));a_1[ca_1++] = (global::System.Xml.XmlNode)ReadXmlNode(false); + } while (false); + } + else { + UnknownNode((object)o, @":customElement"); + } + Reader.MoveToContent(); + } + o.@Items = (global::System.Xml.XmlNode[])ShrinkArray(a_1, ca_1, typeof(global::System.Xml.XmlNode), true); + ReadEndElement(); + return o; + } + + global::SerializationTypes.TypeWithNonPublicDefaultConstructor Read96_Item(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id93_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id100_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -12580,7 +13141,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id115_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id122_Name && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Name = Reader.ReadElementString(); } @@ -12599,12 +13160,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.ServerSettings Read93_ServerSettings(bool isNullable, bool checkType) { + global::SerializationTypes.ServerSettings Read97_ServerSettings(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id94_ServerSettings && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id101_ServerSettings && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -12629,14 +13190,14 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id247_DS2Root && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id259_DS2Root && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@DS2Root = Reader.ReadElementString(); } paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id248_MetricConfigUrl && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id260_MetricConfigUrl && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@MetricConfigUrl = Reader.ReadElementString(); } @@ -12655,12 +13216,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeWithXmlQualifiedName Read94_TypeWithXmlQualifiedName(bool isNullable, bool checkType) { + global::SerializationTypes.TypeWithXmlQualifiedName Read98_TypeWithXmlQualifiedName(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id95_TypeWithXmlQualifiedName && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id102_TypeWithXmlQualifiedName && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -12685,7 +13246,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id148_Value && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id155_Value && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Value = ReadElementQualifiedName(); } @@ -12704,12 +13265,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeWith2DArrayProperty2 Read95_TypeWith2DArrayProperty2(bool isNullable, bool checkType) { + global::SerializationTypes.TypeWith2DArrayProperty2 Read99_TypeWith2DArrayProperty2(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id96_TypeWith2DArrayProperty2 && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id103_TypeWith2DArrayProperty2 && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -12736,7 +13297,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id249_TwoDArrayOfSimpleType && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id261_TwoDArrayOfSimpleType && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { global::SerializationTypes.SimpleType[][] a_0_0 = null; int ca_0_0 = 0; @@ -12749,7 +13310,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id45_SimpleType && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id50_SimpleType && (object) Reader.NamespaceURI == (object)id2_Item)) { if (!ReadNull()) { global::SerializationTypes.SimpleType[] a_0_0_0 = null; int ca_0_0_0 = 0; @@ -12762,8 +13323,8 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id45_SimpleType && (object) Reader.NamespaceURI == (object)id2_Item)) { - a_0_0_0 = (global::SerializationTypes.SimpleType[])EnsureArrayIndex(a_0_0_0, ca_0_0_0, typeof(global::SerializationTypes.SimpleType));a_0_0_0[ca_0_0_0++] = Read45_SimpleType(true, true); + if (((object) Reader.LocalName == (object)id50_SimpleType && (object) Reader.NamespaceURI == (object)id2_Item)) { + a_0_0_0 = (global::SerializationTypes.SimpleType[])EnsureArrayIndex(a_0_0_0, ca_0_0_0, typeof(global::SerializationTypes.SimpleType));a_0_0_0[ca_0_0_0++] = Read47_SimpleType(true, true); break; } UnknownNode(null, @":SimpleType"); @@ -12806,12 +13367,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeWithPropertiesHavingDefaultValue Read96_Item(bool isNullable, bool checkType) { + global::SerializationTypes.TypeWithPropertiesHavingDefaultValue Read100_Item(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id97_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id104_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -12836,21 +13397,21 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id250_EmptyStringProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id262_EmptyStringProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@EmptyStringProperty = Reader.ReadElementString(); } paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id211_StringProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id221_StringProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@StringProperty = Reader.ReadElementString(); } paramsRead[1] = true; break; } - if (!paramsRead[2] && ((object) Reader.LocalName == (object)id212_IntProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[2] && ((object) Reader.LocalName == (object)id222_IntProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { if (Reader.IsEmptyElement) { Reader.Skip(); } @@ -12860,7 +13421,7 @@ internal System.Collections.Hashtable EnumFlagsValues { paramsRead[2] = true; break; } - if (!paramsRead[3] && ((object) Reader.LocalName == (object)id251_CharProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[3] && ((object) Reader.LocalName == (object)id263_CharProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { if (Reader.IsEmptyElement) { Reader.Skip(); } @@ -12882,12 +13443,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeWithEnumPropertyHavingDefaultValue Read97_Item(bool isNullable, bool checkType) { + global::SerializationTypes.TypeWithEnumPropertyHavingDefaultValue Read101_Item(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id98_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id105_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -12912,12 +13473,12 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id252_EnumProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id264_EnumProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { if (Reader.IsEmptyElement) { Reader.Skip(); } else { - o.@EnumProperty = Read71_IntEnum(Reader.ReadElementString()); + o.@EnumProperty = Read73_IntEnum(Reader.ReadElementString()); } paramsRead[0] = true; break; @@ -12934,12 +13495,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeWithEnumFlagPropertyHavingDefaultValue Read98_Item(bool isNullable, bool checkType) { + global::SerializationTypes.TypeWithEnumFlagPropertyHavingDefaultValue Read102_Item(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id99_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id106_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -12964,12 +13525,12 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id252_EnumProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id264_EnumProperty && (object) Reader.NamespaceURI == (object)id2_Item)) { if (Reader.IsEmptyElement) { Reader.Skip(); } else { - o.@EnumProperty = Read67_EnumFlags(Reader.ReadElementString()); + o.@EnumProperty = Read69_EnumFlags(Reader.ReadElementString()); } paramsRead[0] = true; break; @@ -12986,12 +13547,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeWithShouldSerializeMethod Read99_TypeWithShouldSerializeMethod(bool isNullable, bool checkType) { + global::SerializationTypes.TypeWithShouldSerializeMethod Read103_TypeWithShouldSerializeMethod(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id100_TypeWithShouldSerializeMethod && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id107_TypeWithShouldSerializeMethod && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -13016,7 +13577,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id253_Foo && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id265_Foo && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Foo = Reader.ReadElementString(); } @@ -13035,12 +13596,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.KnownTypesThroughConstructorWithArrayProperties Read100_Item(bool isNullable, bool checkType) { + global::SerializationTypes.KnownTypesThroughConstructorWithArrayProperties Read104_Item(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id101_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id108_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -13065,12 +13626,12 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id254_StringArrayValue && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id266_StringArrayValue && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@StringArrayValue = Read1_Object(false, true); paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id255_IntArrayValue && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id267_IntArrayValue && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@IntArrayValue = Read1_Object(false, true); paramsRead[1] = true; break; @@ -13087,12 +13648,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.KnownTypesThroughConstructorWithValue Read101_Item(bool isNullable, bool checkType) { + global::SerializationTypes.KnownTypesThroughConstructorWithValue Read105_Item(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id102_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id109_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -13117,7 +13678,7 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id148_Value && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id155_Value && (object) Reader.NamespaceURI == (object)id2_Item)) { o.@Value = Read1_Object(false, true); paramsRead[0] = true; break; @@ -13134,12 +13695,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeWithTypesHavingCustomFormatter Read102_Item(bool isNullable, bool checkType) { + global::SerializationTypes.TypeWithTypesHavingCustomFormatter Read106_Item(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id103_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id110_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -13164,63 +13725,63 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id256_DateTimeContent && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id268_DateTimeContent && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@DateTimeContent = ToDateTime(Reader.ReadElementString()); } paramsRead[0] = true; break; } - if (!paramsRead[1] && ((object) Reader.LocalName == (object)id257_QNameContent && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[1] && ((object) Reader.LocalName == (object)id269_QNameContent && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@QNameContent = ReadElementQualifiedName(); } paramsRead[1] = true; break; } - if (!paramsRead[2] && ((object) Reader.LocalName == (object)id258_DateContent && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[2] && ((object) Reader.LocalName == (object)id270_DateContent && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@DateContent = ToDate(Reader.ReadElementString()); } paramsRead[2] = true; break; } - if (!paramsRead[3] && ((object) Reader.LocalName == (object)id259_NameContent && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[3] && ((object) Reader.LocalName == (object)id271_NameContent && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@NameContent = ToXmlName(Reader.ReadElementString()); } paramsRead[3] = true; break; } - if (!paramsRead[4] && ((object) Reader.LocalName == (object)id260_NCNameContent && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[4] && ((object) Reader.LocalName == (object)id272_NCNameContent && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@NCNameContent = ToXmlNCName(Reader.ReadElementString()); } paramsRead[4] = true; break; } - if (!paramsRead[5] && ((object) Reader.LocalName == (object)id261_NMTOKENContent && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[5] && ((object) Reader.LocalName == (object)id273_NMTOKENContent && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@NMTOKENContent = ToXmlNmToken(Reader.ReadElementString()); } paramsRead[5] = true; break; } - if (!paramsRead[6] && ((object) Reader.LocalName == (object)id262_NMTOKENSContent && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[6] && ((object) Reader.LocalName == (object)id274_NMTOKENSContent && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@NMTOKENSContent = ToXmlNmTokens(Reader.ReadElementString()); } paramsRead[6] = true; break; } - if (!paramsRead[7] && ((object) Reader.LocalName == (object)id263_Base64BinaryContent && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[7] && ((object) Reader.LocalName == (object)id275_Base64BinaryContent && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@Base64BinaryContent = ToByteArrayBase64(false); } paramsRead[7] = true; break; } - if (!paramsRead[8] && ((object) Reader.LocalName == (object)id264_HexBinaryContent && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (!paramsRead[8] && ((object) Reader.LocalName == (object)id276_HexBinaryContent && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@HexBinaryContent = ToByteArrayHex(false); } @@ -13239,12 +13800,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeWithArrayPropertyHavingChoice Read104_Item(bool isNullable, bool checkType) { + global::SerializationTypes.TypeWithArrayPropertyHavingChoice Read108_Item(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id104_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id111_Item && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -13275,14 +13836,14 @@ internal System.Collections.Hashtable EnumFlagsValues { while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { do { - if (((object) Reader.LocalName == (object)id265_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id277_Item && (object) Reader.NamespaceURI == (object)id2_Item)) { { a_0 = (global::System.Object[])EnsureArrayIndex(a_0, ca_0, typeof(global::System.Object));a_0[ca_0++] = Reader.ReadElementString(); } choice_a_0 = (global::SerializationTypes.MoreChoices[])EnsureArrayIndex(choice_a_0, cchoice_a_0, typeof(global::SerializationTypes.MoreChoices));choice_a_0[cchoice_a_0++] = global::SerializationTypes.MoreChoices.@Item; break; } - if (((object) Reader.LocalName == (object)id266_Amount && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id278_Amount && (object) Reader.NamespaceURI == (object)id2_Item)) { { a_0 = (global::System.Object[])EnsureArrayIndex(a_0, ca_0, typeof(global::System.Object));a_0[ca_0++] = System.Xml.XmlConvert.ToInt32(Reader.ReadElementString()); } @@ -13303,12 +13864,12 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeWithFieldsOrdered Read105_TypeWithFieldsOrdered(bool isNullable, bool checkType) { + global::SerializationTypes.TypeWithFieldsOrdered Read109_TypeWithFieldsOrdered(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); if (checkType) { - if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id106_TypeWithFieldsOrdered && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { + if (xsiType == null || ((object) ((System.Xml.XmlQualifiedName)xsiType).Name == (object)id113_TypeWithFieldsOrdered && (object) ((System.Xml.XmlQualifiedName)xsiType).Namespace == (object)id2_Item)) { } else { throw CreateUnknownTypeException((System.Xml.XmlQualifiedName)xsiType); @@ -13335,23 +13896,23 @@ internal System.Collections.Hashtable EnumFlagsValues { if (Reader.NodeType == System.Xml.XmlNodeType.Element) { switch (state) { case 0: - if (((object) Reader.LocalName == (object)id267_IntField1 && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id280_IntField2 && (object) Reader.NamespaceURI == (object)id2_Item)) { { - o.@IntField1 = System.Xml.XmlConvert.ToInt32(Reader.ReadElementString()); + o.@IntField2 = System.Xml.XmlConvert.ToInt32(Reader.ReadElementString()); } } state = 1; break; case 1: - if (((object) Reader.LocalName == (object)id268_IntField2 && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id279_IntField1 && (object) Reader.NamespaceURI == (object)id2_Item)) { { - o.@IntField2 = System.Xml.XmlConvert.ToInt32(Reader.ReadElementString()); + o.@IntField1 = System.Xml.XmlConvert.ToInt32(Reader.ReadElementString()); } } state = 2; break; case 2: - if (((object) Reader.LocalName == (object)id269_StringField2 && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id281_strfld && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@StringField2 = Reader.ReadElementString(); } @@ -13359,7 +13920,7 @@ internal System.Collections.Hashtable EnumFlagsValues { state = 3; break; case 3: - if (((object) Reader.LocalName == (object)id270_StringField1 && (object) Reader.NamespaceURI == (object)id2_Item)) { + if (((object) Reader.LocalName == (object)id281_strfld && (object) Reader.NamespaceURI == (object)id2_Item)) { { o.@StringField1 = Reader.ReadElementString(); } @@ -13380,7 +13941,7 @@ internal System.Collections.Hashtable EnumFlagsValues { return o; } - global::SerializationTypes.TypeWithSchemaFormInXmlAttribute Read91_Item(bool isNullable, bool checkType) { + global::SerializationTypes.TypeWithSchemaFormInXmlAttribute Read93_Item(bool isNullable, bool checkType) { System.Xml.XmlQualifiedName xsiType = checkType ? GetXsiType() : null; bool isNull = false; if (isNullable) isNull = ReadNull(); @@ -13396,7 +13957,7 @@ internal System.Collections.Hashtable EnumFlagsValues { o = new global::SerializationTypes.TypeWithSchemaFormInXmlAttribute(); System.Span paramsRead = stackalloc bool[1]; while (Reader.MoveToNextAttribute()) { - if (!paramsRead[0] && ((object) Reader.LocalName == (object)id271_TestProperty && (object) Reader.NamespaceURI == (object)id272_httptestcom)) { + if (!paramsRead[0] && ((object) Reader.LocalName == (object)id282_TestProperty && (object) Reader.NamespaceURI == (object)id283_httptestcom)) { o.@TestProperty = Reader.Value; paramsRead[0] = true; } @@ -13427,552 +13988,574 @@ internal System.Collections.Hashtable EnumFlagsValues { protected override void InitCallbacks() { } - string id168_Age; - string id201_DateTimeString; - string id194_FloatProp; - string id33_Item; - string id214_ListProperty; - string id216_DisplayName; - string id118_B; - string id53_MyEnum; - string id263_Base64BinaryContent; - string id68_Item; - string id196_id; - string id161_DTO2; - string id234_Item; - string id260_NCNameContent; - string id55_DCStruct; - string id10_Animal; - string id165_TimeSpanProperty; - string id186_Y; - string id228_XmlAttributeName; - string id250_EmptyStringProperty; - string id79_IntEnum; - string id187_Z; - string id117_A; - string id212_IntProperty; - string id231_DecimalNumber; - string id66_TypeWithByteArrayAsXmlText; - string id235_XmlElementPropertyNode; - string id210_Item; - string id43_XElementArrayWrapper; - string id129_string; - string id252_EnumProperty; - string id31_Pet; - string id128_ArrayOfString; - string id18_PurchaseOrder; - string id271_TestProperty; - string id241_MyField; - string id170_LicenseNumber; - string id78_ShortEnum; - string id211_StringProperty; - string id243_Item; - string id207_MyStruct; - string id21_OrderedItem; - string id208_MyEnum1; - string id160_DTO; - string id169_Breed; - string id35_RootElement; - string id265_Item; - string id142_NoneParameter; - string id141_ArrayOfString1; - string id215_ClassID; - string id100_TypeWithShouldSerializeMethod; - string id26_dateTime; - string id6_TypeWithTimeSpanProperty; - string id162_DefaultDTO; - string id114_LastName; - string id105_MoreChoices; - string id206_Data; - string id172_GroupVehicle; - string id192_SingleField; - string id87_SimpleKnownTypeValue; - string id97_Item; - string id232_XmlIncludeProperty; - string id99_Item; - string id74_WithEnums; - string id264_HexBinaryContent; - string id37_Document; - string id42_XElementStruct; - string id113_MiddleName; - string id41_XElementWrapper; - string id44_TypeWithDateTimeStringProperty; - string id226_Struct1; - string id183_ShipCost; - string id145_ArrayOfArrayOfSimpleType; - string id22_AliasedTestType; - string id32_DefaultValuesSetToNaN; - string id167_ByteProperty; - string id151_IsValved; - string id34_Item; - string id209_ByteArray; - string id152_Modulation; - string id111_Person; - string id188_Prop; - string id29_Brass; - string id25_ArrayOfDateTime; - string id184_TotalCost; - string id268_IntField2; - string id204_F2; - string id15_Employee; - string id195_IntValue; - string id147_P2; - string id36_TypeWithLinkedProperty; - string id136_XElement; - string id199_xelement; - string id50_Item; - string id236_httpelement; - string id112_FirstName; - string id58_TypeA; - string id85_TypeWithAnyAttribute; - string id153_ItemName; - string id48_StructNotSerializable; - string id116_ContainerType; - string id227_Struct2; - string id163_NullableDTO; - string id110_TypeClashA; - string id11_Dog; - string id8_TypeWithByteProperty; - string id127_int; - string id185_X; - string id139_ArrayOfItemChoiceType; - string id137_ArrayOfSimpleType; - string id23_BaseClass1; - string id123_MsgDocumentType; - string id173_EmployeeName; - string id150_Children; - string id131_double; - string id119_Value1; - string id38_httpexamplecom; + string id243_XmlEnumProperty; + string id56_ArrayOfAnyType; + string id245_XmlElementPropertyNode; + string id193_ShipCost; + string id79_WithEnums; + string id197_Z; + string id48_XElementArrayWrapper; + string id124_A; + string id155_Value; + string id225_ClassID; + string id7_Item; + string id212_CurrentDateTime; + string id141_ArrayOfParameter; + string id105_Item; + string id251_MyField; + string id237_Struct2; string id12_DogBreed; - string id175_Line1; - string id115_Name; - string id166_TimeSpanProperty2; - string id91_MyXmlType; - string id248_MetricConfigUrl; - string id5_Item; - string id217_Id; - string id98_Item; - string id126_ArrayOfInt; - string id237_CustomXmlArrayProperty; - string id242_MyFieldIgnored; - string id213_DateTimeProperty; - string id77_SByteEnum; - string id102_Item; - string id156_Quantity; - string id164_NullableDefaultDTO; - string id17_DerivedClass; - string id262_NMTOKENSContent; - string id82_ULongEnum; - string id223_Optionull; - string id54_TypeWithEnumMembers; - string id178_Zip; - string id224_OptionalInt; - string id272_httptestcom; - string id190_Comment2; - string id83_AttributeTesting; - string id30_Trumpet; - string id47_TypeWithGetOnlyArrayProperties; - string id65_Item; - string id51_ArrayOfAnyType; - string id255_IntArrayValue; - string id222_Optional; - string id28_Instrument; - string id253_Foo; + string id267_IntArrayValue; + string id74_Item; + string id256_XmlAttributeForm; + string id88_AttributeTesting; + string id259_DS2Root; + string id275_Base64BinaryContent; + string id119_FirstName; + string id160_ItemName; string id13_Group; - string id24_DerivedClass1; - string id81_LongEnum; - string id94_ServerSettings; - string id62_BaseClassWithSamePropertyName; - string id146_P1; - string id133_ArrayOfTypeWithLinkedProperty; - string id230_Number; - string id239_SimpleTypeValue; - string id89_TypeWithPropertyNameSpecified; - string id269_StringField2; - string id159_Base64Content; - string id122_ParameterOfString; - string id155_UnitPrice; - string id233_XmlEnumProperty; - string id134_ArrayOfParameter; - string id174_value; - string id246_XmlAttributeForm; - string id198_Parameters; - string id130_ArrayOfDouble; - string id193_DoubleProp; - string id101_Item; - string id219_Some; - string id138_ArrayOfTypeA; - string id59_TypeB; - string id2_Item; - string id45_SimpleType; - string id181_Items; - string id154_Description; - string id240_StrProperty; - string id106_TypeWithFieldsOrdered; - string id256_DateTimeContent; - string id63_DerivedClassWithSameProperty; - string id261_NMTOKENContent; - string id7_Item; - string id86_KnownTypesThroughConstructor; - string id247_DS2Root; - string id1_TypeWithXmlElementProperty; - string id225_OptionullInt; - string id177_State; - string id67_SimpleDC; - string id14_Vehicle; - string id84_ItemChoiceType; - string id60_TypeHasArrayOfASerializedAsB; - string id49_TypeWithMyCollectionField; - string id176_City; - string id52_anyType; - string id75_WithNullables; - string id27_Orchestra; - string id251_CharProperty; - string id197_refs; - string id19_httpwwwcontoso1com; - string id218_IsLoaded; - string id40_Parameter; - string id238_EnumValue; - string id148_Value; - string id73_SomeStruct; - string id92_Item; - string id88_Item; - string id135_ArrayOfXElement; - string id244_NoneSchemaFormListProperty; - string id71_ClassImplementsInterface; - string id109_TypeClashB; - string id140_httpmynamespace; - string id96_TypeWith2DArrayProperty2; - string id143_ArrayOfBoolean; - string id103_Item; - string id245_Item; - string id267_IntField1; - string id90_TypeWithXmlSchemaFormAttribute; - string id76_ByteEnum; - string id93_Item; - string id202_CurrentDateTime; - string id200_xelements; - string id189_Instruments; - string id171_GroupName; - string id80_UIntEnum; + string id53_StructNotSerializable; + string id35_Trumpet; + string id46_XElementWrapper; + string id146_ArrayOfItemChoiceType; + string id201_DoubleField; + string id117_TypeClashA; + string id223_DateTimeProperty; + string id126_Value1; + string id121_LastName; + string id258_customElement; + string id33_Instrument; + string id255_Item; + string id45_Parameter; + string id174_ByteProperty; + string id176_Breed; + string id266_StringArrayValue; + string id184_BoolValue; + string id28_BaseClass1; + string id44_RootClass; + string id190_OrderDate; + string id249_SimpleTypeValue; + string id228_IsLoaded; + string id80_WithNullables; + string id233_Optionull; + string id57_anyType; + string id163_Quantity; + string id139_ArrayOfInstrument; + string id159_Modulation; + string id58_MyEnum; + string id77_WithStruct; + string id55_Item; + string id264_EnumProperty; + string id265_Foo; + string id200_Comment2; + string id24_httpwwwcontoso1com; + string id102_TypeWithXmlQualifiedName; + string id99_CustomElement; + string id34_Brass; + string id209_xelement; + string id111_Item; + string id213_F1; + string id272_NCNameContent; + string id98_CustomDocument; + string id281_strfld; + string id63_TypeA; + string id131_Item; + string id109_Item; + string id279_IntField1; + string id181_value; + string id185_Line1; + string id123_ContainerType; + string id90_TypeWithAnyAttribute; + string id217_MyStruct; + string id169_DefaultDTO; + string id166_Base64Content; + string id23_PurchaseOrder; + string id8_TypeWithByteProperty; + string id182_AttributeString; + string id140_ArrayOfTypeWithLinkedProperty; + string id161_Description; string id16_BaseClass; - string id72_WithStruct; - string id205_Collection; - string id95_TypeWithXmlQualifiedName; - string id257_QNameContent; - string id179_ShipTo; - string id132_ArrayOfInstrument; - string id57_BuiltInTypes; - string id61_Item; - string id158_BinaryHexContent; + string id268_DateTimeContent; + string id199_Instruments; + string id78_SomeStruct; + string id250_StrProperty; + string id238_XmlAttributeName; + string id145_ArrayOfTypeA; + string id64_TypeB; + string id42_Document; + string id273_NMTOKENContent; + string id191_Items; + string id59_TypeWithEnumMembers; + string id49_TypeWithDateTimeStringProperty; + string id196_Y; + string id231_Short; + string id128_XmlSerializerAttributes; + string id83_ShortEnum; + string id151_QualifiedParameter; + string id120_MiddleName; + string id89_ItemChoiceType; + string id26_OrderedItem; + string id172_TimeSpanProperty; + string id133_ArrayOfInt; + string id219_ByteArray; + string id252_MyFieldIgnored; + string id202_SingleField; + string id207_refs; + string id113_TypeWithFieldsOrdered; + string id39_Item; + string id142_ArrayOfXElement; + string id108_Item; + string id278_Amount; + string id112_MoreChoices; + string id138_double; + string id43_httpexamplecom; + string id229_Some; + string id20_BaseIXmlSerializable; + string id110_Item; + string id81_ByteEnum; + string id198_Prop; + string id82_SByteEnum; + string id192_SubTotal; + string id239_Word; + string id17_DerivedClass; + string id18_SimpleBaseClass; + string id47_XElementStruct; + string id205_IntValue; + string id246_httpelement; + string id76_ClassImplementsInterface; + string id54_TypeWithMyCollectionField; + string id85_UIntEnum; + string id189_ShipTo; + string id127_Value2; + string id253_Item; + string id62_BuiltInTypes; + string id260_MetricConfigUrl; + string id115_Root; + string id283_httptestcom; + string id107_TypeWithShouldSerializeMethod; + string id274_NMTOKENSContent; + string id271_NameContent; + string id95_TypeWithXmlSchemaFormAttribute; + string id66_Item; + string id136_string; + string id149_NoneParameter; + string id214_F2; + string id234_OptionalInt; + string id242_XmlIncludeProperty; + string id73_Item; + string id257_name; + string id31_dateTime; + string id270_DateContent; + string id240_Number; + string id254_NoneSchemaFormListProperty; string id104_Item; - string id124_Item; - string id249_TwoDArrayOfSimpleType; - string id191_DoubleField; - string id46_TypeWithGetSetArrayMembers; + string id41_TypeWithLinkedProperty; + string id5_Item; + string id179_GroupVehicle; + string id27_AliasedTestType; + string id215_Collection; + string id168_DTO2; + string id210_xelements; + string id222_IntProperty; + string id180_EmployeeName; + string id22_DerivedIXmlSerializable; + string id277_Item; + string id232_Optional; + string id276_HexBinaryContent; + string id152_ArrayOfArrayOfSimpleType; + string id144_ArrayOfSimpleType; + string id93_Item; + string id230_Int; + string id97_Item; + string id211_DateTimeString; + string id280_IntField2; + string id147_httpmynamespace; + string id11_Dog; + string id52_TypeWithGetOnlyArrayProperties; + string id61_DCClassWithEnumAndStruct; + string id175_Age; + string id114_Item; + string id71_TypeWithByteArrayAsXmlText; string id4_TypeWithBinaryProperty; - string id221_Short; - string id144_QualifiedParameter; - string id149_Child; - string id203_F1; - string id69_Item; - string id229_Word; - string id3_TypeWithXmlDocumentProperty; - string id20_Address; - string id120_Value2; - string id121_XmlSerializerAttributes; - string id180_OrderDate; - string id70_EnumFlags; - string id266_Amount; + string id118_Person; + string id261_TwoDArrayOfSimpleType; + string id32_Orchestra; + string id220_Item; + string id216_Data; + string id60_DCStruct; + string id148_ArrayOfString1; + string id165_BinaryHexContent; + string id91_KnownTypesThroughConstructor; + string id224_ListProperty; + string id195_X; + string id6_TypeWithTimeSpanProperty; + string id203_DoubleProp; + string id106_Item; + string id103_TypeWith2DArrayProperty2; + string id156_Child; + string id86_LongEnum; string id9_TypeWithXmlNodeArrayProperty; - string id259_NameContent; - string id220_Int; - string id64_DerivedClassWithSameProperty2; - string id125_ArrayOfOrderedItem; - string id157_LineTotal; - string id254_StringArrayValue; - string id107_Item; - string id56_DCClassWithEnumAndStruct; - string id270_StringField1; - string id182_SubTotal; - string id108_Root; - string id39_RootClass; - string id258_DateContent; + string id25_Address; + string id162_UnitPrice; + string id125_B; + string id68_DerivedClassWithSameProperty; + string id51_TypeWithGetSetArrayMembers; + string id236_Struct1; + string id150_ArrayOfBoolean; + string id177_LicenseNumber; + string id72_SimpleDC; + string id94_TypeWithPropertyNameSpecified; + string id96_MyXmlType; + string id101_ServerSettings; + string id226_DisplayName; + string id19_SimpleDerivedClass; + string id153_P1; + string id183_DateTimeValue; + string id154_P2; + string id2_Item; + string id269_QNameContent; + string id1_TypeWithXmlElementProperty; + string id3_TypeWithXmlDocumentProperty; + string id263_CharProperty; + string id178_GroupName; + string id134_int; + string id186_City; + string id69_DerivedClassWithSameProperty2; + string id75_EnumFlags; + string id235_OptionullInt; + string id158_IsValved; + string id157_Children; + string id92_SimpleKnownTypeValue; + string id262_EmptyStringProperty; + string id194_TotalCost; + string id171_NullableDefaultDTO; + string id100_Item; + string id132_ArrayOfOrderedItem; + string id143_XElement; + string id15_Employee; + string id187_State; + string id173_TimeSpanProperty2; + string id188_Zip; + string id122_Name; + string id241_DecimalNumber; + string id221_StringProperty; + string id204_FloatProp; + string id218_MyEnum1; + string id30_ArrayOfDateTime; + string id65_TypeHasArrayOfASerializedAsB; + string id87_ULongEnum; + string id84_IntEnum; + string id248_EnumValue; + string id50_SimpleType; + string id206_id; + string id247_CustomXmlArrayProperty; + string id38_Item; + string id36_Pet; + string id208_Parameters; + string id67_BaseClassWithSamePropertyName; + string id116_TypeClashB; + string id21_Item; + string id282_TestProperty; + string id129_ParameterOfString; + string id14_Vehicle; + string id130_MsgDocumentType; + string id10_Animal; + string id29_DerivedClass1; + string id135_ArrayOfString; + string id170_NullableDTO; + string id244_Item; + string id70_Item; + string id37_DefaultValuesSetToNaN; + string id40_RootElement; + string id227_Id; + string id137_ArrayOfDouble; + string id167_DTO; + string id164_LineTotal; protected override void InitIDs() { - id168_Age = Reader.NameTable.Add(@"Age"); - id201_DateTimeString = Reader.NameTable.Add(@"DateTimeString"); - id194_FloatProp = Reader.NameTable.Add(@"FloatProp"); - id33_Item = Reader.NameTable.Add(@"DefaultValuesSetToPositiveInfinity"); - id214_ListProperty = Reader.NameTable.Add(@"ListProperty"); - id216_DisplayName = Reader.NameTable.Add(@"DisplayName"); - id118_B = Reader.NameTable.Add(@"B"); - id53_MyEnum = Reader.NameTable.Add(@"MyEnum"); - id263_Base64BinaryContent = Reader.NameTable.Add(@"Base64BinaryContent"); - id68_Item = Reader.NameTable.Add(@"TypeWithXmlTextAttributeOnArray"); - id196_id = Reader.NameTable.Add(@"id"); - id161_DTO2 = Reader.NameTable.Add(@"DTO2"); - id234_Item = Reader.NameTable.Add(@"XmlNamespaceDeclarationsProperty"); - id260_NCNameContent = Reader.NameTable.Add(@"NCNameContent"); - id55_DCStruct = Reader.NameTable.Add(@"DCStruct"); - id10_Animal = Reader.NameTable.Add(@"Animal"); - id165_TimeSpanProperty = Reader.NameTable.Add(@"TimeSpanProperty"); - id186_Y = Reader.NameTable.Add(@"Y"); - id228_XmlAttributeName = Reader.NameTable.Add(@"XmlAttributeName"); - id250_EmptyStringProperty = Reader.NameTable.Add(@"EmptyStringProperty"); - id79_IntEnum = Reader.NameTable.Add(@"IntEnum"); - id187_Z = Reader.NameTable.Add(@"Z"); - id117_A = Reader.NameTable.Add(@"A"); - id212_IntProperty = Reader.NameTable.Add(@"IntProperty"); - id231_DecimalNumber = Reader.NameTable.Add(@"DecimalNumber"); - id66_TypeWithByteArrayAsXmlText = Reader.NameTable.Add(@"TypeWithByteArrayAsXmlText"); - id235_XmlElementPropertyNode = Reader.NameTable.Add(@"XmlElementPropertyNode"); - id210_Item = Reader.NameTable.Add(@"PropertyNameWithSpecialCharacters漢ñ"); - id43_XElementArrayWrapper = Reader.NameTable.Add(@"XElementArrayWrapper"); - id129_string = Reader.NameTable.Add(@"string"); - id252_EnumProperty = Reader.NameTable.Add(@"EnumProperty"); - id31_Pet = Reader.NameTable.Add(@"Pet"); - id128_ArrayOfString = Reader.NameTable.Add(@"ArrayOfString"); - id18_PurchaseOrder = Reader.NameTable.Add(@"PurchaseOrder"); - id271_TestProperty = Reader.NameTable.Add(@"TestProperty"); - id241_MyField = Reader.NameTable.Add(@"MyField"); - id170_LicenseNumber = Reader.NameTable.Add(@"LicenseNumber"); - id78_ShortEnum = Reader.NameTable.Add(@"ShortEnum"); - id211_StringProperty = Reader.NameTable.Add(@"StringProperty"); - id243_Item = Reader.NameTable.Add(@"UnqualifiedSchemaFormListProperty"); - id207_MyStruct = Reader.NameTable.Add(@"MyStruct"); - id21_OrderedItem = Reader.NameTable.Add(@"OrderedItem"); - id208_MyEnum1 = Reader.NameTable.Add(@"MyEnum1"); - id160_DTO = Reader.NameTable.Add(@"DTO"); - id169_Breed = Reader.NameTable.Add(@"Breed"); - id35_RootElement = Reader.NameTable.Add(@"RootElement"); - id265_Item = Reader.NameTable.Add(@"Item"); - id142_NoneParameter = Reader.NameTable.Add(@"NoneParameter"); - id141_ArrayOfString1 = Reader.NameTable.Add(@"ArrayOfString1"); - id215_ClassID = Reader.NameTable.Add(@"ClassID"); - id100_TypeWithShouldSerializeMethod = Reader.NameTable.Add(@"TypeWithShouldSerializeMethod"); - id26_dateTime = Reader.NameTable.Add(@"dateTime"); - id6_TypeWithTimeSpanProperty = Reader.NameTable.Add(@"TypeWithTimeSpanProperty"); - id162_DefaultDTO = Reader.NameTable.Add(@"DefaultDTO"); - id114_LastName = Reader.NameTable.Add(@"LastName"); - id105_MoreChoices = Reader.NameTable.Add(@"MoreChoices"); - id206_Data = Reader.NameTable.Add(@"Data"); - id172_GroupVehicle = Reader.NameTable.Add(@"GroupVehicle"); - id192_SingleField = Reader.NameTable.Add(@"SingleField"); - id87_SimpleKnownTypeValue = Reader.NameTable.Add(@"SimpleKnownTypeValue"); - id97_Item = Reader.NameTable.Add(@"TypeWithPropertiesHavingDefaultValue"); - id232_XmlIncludeProperty = Reader.NameTable.Add(@"XmlIncludeProperty"); - id99_Item = Reader.NameTable.Add(@"TypeWithEnumFlagPropertyHavingDefaultValue"); - id74_WithEnums = Reader.NameTable.Add(@"WithEnums"); - id264_HexBinaryContent = Reader.NameTable.Add(@"HexBinaryContent"); - id37_Document = Reader.NameTable.Add(@"Document"); - id42_XElementStruct = Reader.NameTable.Add(@"XElementStruct"); - id113_MiddleName = Reader.NameTable.Add(@"MiddleName"); - id41_XElementWrapper = Reader.NameTable.Add(@"XElementWrapper"); - id44_TypeWithDateTimeStringProperty = Reader.NameTable.Add(@"TypeWithDateTimeStringProperty"); - id226_Struct1 = Reader.NameTable.Add(@"Struct1"); - id183_ShipCost = Reader.NameTable.Add(@"ShipCost"); - id145_ArrayOfArrayOfSimpleType = Reader.NameTable.Add(@"ArrayOfArrayOfSimpleType"); - id22_AliasedTestType = Reader.NameTable.Add(@"AliasedTestType"); - id32_DefaultValuesSetToNaN = Reader.NameTable.Add(@"DefaultValuesSetToNaN"); - id167_ByteProperty = Reader.NameTable.Add(@"ByteProperty"); - id151_IsValved = Reader.NameTable.Add(@"IsValved"); - id34_Item = Reader.NameTable.Add(@"DefaultValuesSetToNegativeInfinity"); - id209_ByteArray = Reader.NameTable.Add(@"ByteArray"); - id152_Modulation = Reader.NameTable.Add(@"Modulation"); - id111_Person = Reader.NameTable.Add(@"Person"); - id188_Prop = Reader.NameTable.Add(@"Prop"); - id29_Brass = Reader.NameTable.Add(@"Brass"); - id25_ArrayOfDateTime = Reader.NameTable.Add(@"ArrayOfDateTime"); - id184_TotalCost = Reader.NameTable.Add(@"TotalCost"); - id268_IntField2 = Reader.NameTable.Add(@"IntField2"); - id204_F2 = Reader.NameTable.Add(@"F2"); - id15_Employee = Reader.NameTable.Add(@"Employee"); - id195_IntValue = Reader.NameTable.Add(@"IntValue"); - id147_P2 = Reader.NameTable.Add(@"P2"); - id36_TypeWithLinkedProperty = Reader.NameTable.Add(@"TypeWithLinkedProperty"); - id136_XElement = Reader.NameTable.Add(@"XElement"); - id199_xelement = Reader.NameTable.Add(@"xelement"); - id50_Item = Reader.NameTable.Add(@"TypeWithReadOnlyMyCollectionProperty"); - id236_httpelement = Reader.NameTable.Add(@"http://element"); - id112_FirstName = Reader.NameTable.Add(@"FirstName"); - id58_TypeA = Reader.NameTable.Add(@"TypeA"); - id85_TypeWithAnyAttribute = Reader.NameTable.Add(@"TypeWithAnyAttribute"); - id153_ItemName = Reader.NameTable.Add(@"ItemName"); - id48_StructNotSerializable = Reader.NameTable.Add(@"StructNotSerializable"); - id116_ContainerType = Reader.NameTable.Add(@"ContainerType"); - id227_Struct2 = Reader.NameTable.Add(@"Struct2"); - id163_NullableDTO = Reader.NameTable.Add(@"NullableDTO"); - id110_TypeClashA = Reader.NameTable.Add(@"TypeClashA"); - id11_Dog = Reader.NameTable.Add(@"Dog"); - id8_TypeWithByteProperty = Reader.NameTable.Add(@"TypeWithByteProperty"); - id127_int = Reader.NameTable.Add(@"int"); - id185_X = Reader.NameTable.Add(@"X"); - id139_ArrayOfItemChoiceType = Reader.NameTable.Add(@"ArrayOfItemChoiceType"); - id137_ArrayOfSimpleType = Reader.NameTable.Add(@"ArrayOfSimpleType"); - id23_BaseClass1 = Reader.NameTable.Add(@"BaseClass1"); - id123_MsgDocumentType = Reader.NameTable.Add(@"MsgDocumentType"); - id173_EmployeeName = Reader.NameTable.Add(@"EmployeeName"); - id150_Children = Reader.NameTable.Add(@"Children"); - id131_double = Reader.NameTable.Add(@"double"); - id119_Value1 = Reader.NameTable.Add(@"Value1"); - id38_httpexamplecom = Reader.NameTable.Add(@"http://example.com"); + id243_XmlEnumProperty = Reader.NameTable.Add(@"XmlEnumProperty"); + id56_ArrayOfAnyType = Reader.NameTable.Add(@"ArrayOfAnyType"); + id245_XmlElementPropertyNode = Reader.NameTable.Add(@"XmlElementPropertyNode"); + id193_ShipCost = Reader.NameTable.Add(@"ShipCost"); + id79_WithEnums = Reader.NameTable.Add(@"WithEnums"); + id197_Z = Reader.NameTable.Add(@"Z"); + id48_XElementArrayWrapper = Reader.NameTable.Add(@"XElementArrayWrapper"); + id124_A = Reader.NameTable.Add(@"A"); + id155_Value = Reader.NameTable.Add(@"Value"); + id225_ClassID = Reader.NameTable.Add(@"ClassID"); + id7_Item = Reader.NameTable.Add(@"TypeWithDefaultTimeSpanProperty"); + id212_CurrentDateTime = Reader.NameTable.Add(@"CurrentDateTime"); + id141_ArrayOfParameter = Reader.NameTable.Add(@"ArrayOfParameter"); + id105_Item = Reader.NameTable.Add(@"TypeWithEnumPropertyHavingDefaultValue"); + id251_MyField = Reader.NameTable.Add(@"MyField"); + id237_Struct2 = Reader.NameTable.Add(@"Struct2"); id12_DogBreed = Reader.NameTable.Add(@"DogBreed"); - id175_Line1 = Reader.NameTable.Add(@"Line1"); - id115_Name = Reader.NameTable.Add(@"Name"); - id166_TimeSpanProperty2 = Reader.NameTable.Add(@"TimeSpanProperty2"); - id91_MyXmlType = Reader.NameTable.Add(@"MyXmlType"); - id248_MetricConfigUrl = Reader.NameTable.Add(@"MetricConfigUrl"); - id5_Item = Reader.NameTable.Add(@"TypeWithDateTimeOffsetProperties"); - id217_Id = Reader.NameTable.Add(@"Id"); - id98_Item = Reader.NameTable.Add(@"TypeWithEnumPropertyHavingDefaultValue"); - id126_ArrayOfInt = Reader.NameTable.Add(@"ArrayOfInt"); - id237_CustomXmlArrayProperty = Reader.NameTable.Add(@"CustomXmlArrayProperty"); - id242_MyFieldIgnored = Reader.NameTable.Add(@"MyFieldIgnored"); - id213_DateTimeProperty = Reader.NameTable.Add(@"DateTimeProperty"); - id77_SByteEnum = Reader.NameTable.Add(@"SByteEnum"); - id102_Item = Reader.NameTable.Add(@"KnownTypesThroughConstructorWithValue"); - id156_Quantity = Reader.NameTable.Add(@"Quantity"); - id164_NullableDefaultDTO = Reader.NameTable.Add(@"NullableDefaultDTO"); - id17_DerivedClass = Reader.NameTable.Add(@"DerivedClass"); - id262_NMTOKENSContent = Reader.NameTable.Add(@"NMTOKENSContent"); - id82_ULongEnum = Reader.NameTable.Add(@"ULongEnum"); - id223_Optionull = Reader.NameTable.Add(@"Optionull"); - id54_TypeWithEnumMembers = Reader.NameTable.Add(@"TypeWithEnumMembers"); - id178_Zip = Reader.NameTable.Add(@"Zip"); - id224_OptionalInt = Reader.NameTable.Add(@"OptionalInt"); - id272_httptestcom = Reader.NameTable.Add(@"http://test.com"); - id190_Comment2 = Reader.NameTable.Add(@"Comment2"); - id83_AttributeTesting = Reader.NameTable.Add(@"AttributeTesting"); - id30_Trumpet = Reader.NameTable.Add(@"Trumpet"); - id47_TypeWithGetOnlyArrayProperties = Reader.NameTable.Add(@"TypeWithGetOnlyArrayProperties"); - id65_Item = Reader.NameTable.Add(@"TypeWithDateTimePropertyAsXmlTime"); - id51_ArrayOfAnyType = Reader.NameTable.Add(@"ArrayOfAnyType"); - id255_IntArrayValue = Reader.NameTable.Add(@"IntArrayValue"); - id222_Optional = Reader.NameTable.Add(@"Optional"); - id28_Instrument = Reader.NameTable.Add(@"Instrument"); - id253_Foo = Reader.NameTable.Add(@"Foo"); + id267_IntArrayValue = Reader.NameTable.Add(@"IntArrayValue"); + id74_Item = Reader.NameTable.Add(@"http://schemas.xmlsoap.org/ws/2005/04/discovery"); + id256_XmlAttributeForm = Reader.NameTable.Add(@"XmlAttributeForm"); + id88_AttributeTesting = Reader.NameTable.Add(@"AttributeTesting"); + id259_DS2Root = Reader.NameTable.Add(@"DS2Root"); + id275_Base64BinaryContent = Reader.NameTable.Add(@"Base64BinaryContent"); + id119_FirstName = Reader.NameTable.Add(@"FirstName"); + id160_ItemName = Reader.NameTable.Add(@"ItemName"); id13_Group = Reader.NameTable.Add(@"Group"); - id24_DerivedClass1 = Reader.NameTable.Add(@"DerivedClass1"); - id81_LongEnum = Reader.NameTable.Add(@"LongEnum"); - id94_ServerSettings = Reader.NameTable.Add(@"ServerSettings"); - id62_BaseClassWithSamePropertyName = Reader.NameTable.Add(@"BaseClassWithSamePropertyName"); - id146_P1 = Reader.NameTable.Add(@"P1"); - id133_ArrayOfTypeWithLinkedProperty = Reader.NameTable.Add(@"ArrayOfTypeWithLinkedProperty"); - id230_Number = Reader.NameTable.Add(@"Number"); - id239_SimpleTypeValue = Reader.NameTable.Add(@"SimpleTypeValue"); - id89_TypeWithPropertyNameSpecified = Reader.NameTable.Add(@"TypeWithPropertyNameSpecified"); - id269_StringField2 = Reader.NameTable.Add(@"StringField2"); - id159_Base64Content = Reader.NameTable.Add(@"Base64Content"); - id122_ParameterOfString = Reader.NameTable.Add(@"ParameterOfString"); - id155_UnitPrice = Reader.NameTable.Add(@"UnitPrice"); - id233_XmlEnumProperty = Reader.NameTable.Add(@"XmlEnumProperty"); - id134_ArrayOfParameter = Reader.NameTable.Add(@"ArrayOfParameter"); - id174_value = Reader.NameTable.Add(@"value"); - id246_XmlAttributeForm = Reader.NameTable.Add(@"XmlAttributeForm"); - id198_Parameters = Reader.NameTable.Add(@"Parameters"); - id130_ArrayOfDouble = Reader.NameTable.Add(@"ArrayOfDouble"); - id193_DoubleProp = Reader.NameTable.Add(@"DoubleProp"); - id101_Item = Reader.NameTable.Add(@"KnownTypesThroughConstructorWithArrayProperties"); - id219_Some = Reader.NameTable.Add(@"Some"); - id138_ArrayOfTypeA = Reader.NameTable.Add(@"ArrayOfTypeA"); - id59_TypeB = Reader.NameTable.Add(@"TypeB"); - id2_Item = Reader.NameTable.Add(@""); - id45_SimpleType = Reader.NameTable.Add(@"SimpleType"); - id181_Items = Reader.NameTable.Add(@"Items"); - id154_Description = Reader.NameTable.Add(@"Description"); - id240_StrProperty = Reader.NameTable.Add(@"StrProperty"); - id106_TypeWithFieldsOrdered = Reader.NameTable.Add(@"TypeWithFieldsOrdered"); - id256_DateTimeContent = Reader.NameTable.Add(@"DateTimeContent"); - id63_DerivedClassWithSameProperty = Reader.NameTable.Add(@"DerivedClassWithSameProperty"); - id261_NMTOKENContent = Reader.NameTable.Add(@"NMTOKENContent"); - id7_Item = Reader.NameTable.Add(@"TypeWithDefaultTimeSpanProperty"); - id86_KnownTypesThroughConstructor = Reader.NameTable.Add(@"KnownTypesThroughConstructor"); - id247_DS2Root = Reader.NameTable.Add(@"DS2Root"); - id1_TypeWithXmlElementProperty = Reader.NameTable.Add(@"TypeWithXmlElementProperty"); - id225_OptionullInt = Reader.NameTable.Add(@"OptionullInt"); - id177_State = Reader.NameTable.Add(@"State"); - id67_SimpleDC = Reader.NameTable.Add(@"SimpleDC"); - id14_Vehicle = Reader.NameTable.Add(@"Vehicle"); - id84_ItemChoiceType = Reader.NameTable.Add(@"ItemChoiceType"); - id60_TypeHasArrayOfASerializedAsB = Reader.NameTable.Add(@"TypeHasArrayOfASerializedAsB"); - id49_TypeWithMyCollectionField = Reader.NameTable.Add(@"TypeWithMyCollectionField"); - id176_City = Reader.NameTable.Add(@"City"); - id52_anyType = Reader.NameTable.Add(@"anyType"); - id75_WithNullables = Reader.NameTable.Add(@"WithNullables"); - id27_Orchestra = Reader.NameTable.Add(@"Orchestra"); - id251_CharProperty = Reader.NameTable.Add(@"CharProperty"); - id197_refs = Reader.NameTable.Add(@"refs"); - id19_httpwwwcontoso1com = Reader.NameTable.Add(@"http://www.contoso1.com"); - id218_IsLoaded = Reader.NameTable.Add(@"IsLoaded"); - id40_Parameter = Reader.NameTable.Add(@"Parameter"); - id238_EnumValue = Reader.NameTable.Add(@"EnumValue"); - id148_Value = Reader.NameTable.Add(@"Value"); - id73_SomeStruct = Reader.NameTable.Add(@"SomeStruct"); - id92_Item = Reader.NameTable.Add(@"TypeWithSchemaFormInXmlAttribute"); - id88_Item = Reader.NameTable.Add(@"ClassImplementingIXmlSerialiable"); - id135_ArrayOfXElement = Reader.NameTable.Add(@"ArrayOfXElement"); - id244_NoneSchemaFormListProperty = Reader.NameTable.Add(@"NoneSchemaFormListProperty"); - id71_ClassImplementsInterface = Reader.NameTable.Add(@"ClassImplementsInterface"); - id109_TypeClashB = Reader.NameTable.Add(@"TypeClashB"); - id140_httpmynamespace = Reader.NameTable.Add(@"http://mynamespace"); - id96_TypeWith2DArrayProperty2 = Reader.NameTable.Add(@"TypeWith2DArrayProperty2"); - id143_ArrayOfBoolean = Reader.NameTable.Add(@"ArrayOfBoolean"); - id103_Item = Reader.NameTable.Add(@"TypeWithTypesHavingCustomFormatter"); - id245_Item = Reader.NameTable.Add(@"QualifiedSchemaFormListProperty"); - id267_IntField1 = Reader.NameTable.Add(@"IntField1"); - id90_TypeWithXmlSchemaFormAttribute = Reader.NameTable.Add(@"TypeWithXmlSchemaFormAttribute"); - id76_ByteEnum = Reader.NameTable.Add(@"ByteEnum"); - id93_Item = Reader.NameTable.Add(@"TypeWithNonPublicDefaultConstructor"); - id202_CurrentDateTime = Reader.NameTable.Add(@"CurrentDateTime"); - id200_xelements = Reader.NameTable.Add(@"xelements"); - id189_Instruments = Reader.NameTable.Add(@"Instruments"); - id171_GroupName = Reader.NameTable.Add(@"GroupName"); - id80_UIntEnum = Reader.NameTable.Add(@"UIntEnum"); + id53_StructNotSerializable = Reader.NameTable.Add(@"StructNotSerializable"); + id35_Trumpet = Reader.NameTable.Add(@"Trumpet"); + id46_XElementWrapper = Reader.NameTable.Add(@"XElementWrapper"); + id146_ArrayOfItemChoiceType = Reader.NameTable.Add(@"ArrayOfItemChoiceType"); + id201_DoubleField = Reader.NameTable.Add(@"DoubleField"); + id117_TypeClashA = Reader.NameTable.Add(@"TypeClashA"); + id223_DateTimeProperty = Reader.NameTable.Add(@"DateTimeProperty"); + id126_Value1 = Reader.NameTable.Add(@"Value1"); + id121_LastName = Reader.NameTable.Add(@"LastName"); + id258_customElement = Reader.NameTable.Add(@"customElement"); + id33_Instrument = Reader.NameTable.Add(@"Instrument"); + id255_Item = Reader.NameTable.Add(@"QualifiedSchemaFormListProperty"); + id45_Parameter = Reader.NameTable.Add(@"Parameter"); + id174_ByteProperty = Reader.NameTable.Add(@"ByteProperty"); + id176_Breed = Reader.NameTable.Add(@"Breed"); + id266_StringArrayValue = Reader.NameTable.Add(@"StringArrayValue"); + id184_BoolValue = Reader.NameTable.Add(@"BoolValue"); + id28_BaseClass1 = Reader.NameTable.Add(@"BaseClass1"); + id44_RootClass = Reader.NameTable.Add(@"RootClass"); + id190_OrderDate = Reader.NameTable.Add(@"OrderDate"); + id249_SimpleTypeValue = Reader.NameTable.Add(@"SimpleTypeValue"); + id228_IsLoaded = Reader.NameTable.Add(@"IsLoaded"); + id80_WithNullables = Reader.NameTable.Add(@"WithNullables"); + id233_Optionull = Reader.NameTable.Add(@"Optionull"); + id57_anyType = Reader.NameTable.Add(@"anyType"); + id163_Quantity = Reader.NameTable.Add(@"Quantity"); + id139_ArrayOfInstrument = Reader.NameTable.Add(@"ArrayOfInstrument"); + id159_Modulation = Reader.NameTable.Add(@"Modulation"); + id58_MyEnum = Reader.NameTable.Add(@"MyEnum"); + id77_WithStruct = Reader.NameTable.Add(@"WithStruct"); + id55_Item = Reader.NameTable.Add(@"TypeWithReadOnlyMyCollectionProperty"); + id264_EnumProperty = Reader.NameTable.Add(@"EnumProperty"); + id265_Foo = Reader.NameTable.Add(@"Foo"); + id200_Comment2 = Reader.NameTable.Add(@"Comment2"); + id24_httpwwwcontoso1com = Reader.NameTable.Add(@"http://www.contoso1.com"); + id102_TypeWithXmlQualifiedName = Reader.NameTable.Add(@"TypeWithXmlQualifiedName"); + id99_CustomElement = Reader.NameTable.Add(@"CustomElement"); + id34_Brass = Reader.NameTable.Add(@"Brass"); + id209_xelement = Reader.NameTable.Add(@"xelement"); + id111_Item = Reader.NameTable.Add(@"TypeWithArrayPropertyHavingChoice"); + id213_F1 = Reader.NameTable.Add(@"F1"); + id272_NCNameContent = Reader.NameTable.Add(@"NCNameContent"); + id98_CustomDocument = Reader.NameTable.Add(@"CustomDocument"); + id281_strfld = Reader.NameTable.Add(@"strfld"); + id63_TypeA = Reader.NameTable.Add(@"TypeA"); + id131_Item = Reader.NameTable.Add(@"TypeWithMismatchBetweenAttributeAndPropertyType"); + id109_Item = Reader.NameTable.Add(@"KnownTypesThroughConstructorWithValue"); + id279_IntField1 = Reader.NameTable.Add(@"IntField1"); + id181_value = Reader.NameTable.Add(@"value"); + id185_Line1 = Reader.NameTable.Add(@"Line1"); + id123_ContainerType = Reader.NameTable.Add(@"ContainerType"); + id90_TypeWithAnyAttribute = Reader.NameTable.Add(@"TypeWithAnyAttribute"); + id217_MyStruct = Reader.NameTable.Add(@"MyStruct"); + id169_DefaultDTO = Reader.NameTable.Add(@"DefaultDTO"); + id166_Base64Content = Reader.NameTable.Add(@"Base64Content"); + id23_PurchaseOrder = Reader.NameTable.Add(@"PurchaseOrder"); + id8_TypeWithByteProperty = Reader.NameTable.Add(@"TypeWithByteProperty"); + id182_AttributeString = Reader.NameTable.Add(@"AttributeString"); + id140_ArrayOfTypeWithLinkedProperty = Reader.NameTable.Add(@"ArrayOfTypeWithLinkedProperty"); + id161_Description = Reader.NameTable.Add(@"Description"); id16_BaseClass = Reader.NameTable.Add(@"BaseClass"); - id72_WithStruct = Reader.NameTable.Add(@"WithStruct"); - id205_Collection = Reader.NameTable.Add(@"Collection"); - id95_TypeWithXmlQualifiedName = Reader.NameTable.Add(@"TypeWithXmlQualifiedName"); - id257_QNameContent = Reader.NameTable.Add(@"QNameContent"); - id179_ShipTo = Reader.NameTable.Add(@"ShipTo"); - id132_ArrayOfInstrument = Reader.NameTable.Add(@"ArrayOfInstrument"); - id57_BuiltInTypes = Reader.NameTable.Add(@"BuiltInTypes"); - id61_Item = Reader.NameTable.Add(@"__TypeNameWithSpecialCharacters漢ñ"); - id158_BinaryHexContent = Reader.NameTable.Add(@"BinaryHexContent"); - id104_Item = Reader.NameTable.Add(@"TypeWithArrayPropertyHavingChoice"); - id124_Item = Reader.NameTable.Add(@"TypeWithMismatchBetweenAttributeAndPropertyType"); - id249_TwoDArrayOfSimpleType = Reader.NameTable.Add(@"TwoDArrayOfSimpleType"); - id191_DoubleField = Reader.NameTable.Add(@"DoubleField"); - id46_TypeWithGetSetArrayMembers = Reader.NameTable.Add(@"TypeWithGetSetArrayMembers"); + id268_DateTimeContent = Reader.NameTable.Add(@"DateTimeContent"); + id199_Instruments = Reader.NameTable.Add(@"Instruments"); + id78_SomeStruct = Reader.NameTable.Add(@"SomeStruct"); + id250_StrProperty = Reader.NameTable.Add(@"StrProperty"); + id238_XmlAttributeName = Reader.NameTable.Add(@"XmlAttributeName"); + id145_ArrayOfTypeA = Reader.NameTable.Add(@"ArrayOfTypeA"); + id64_TypeB = Reader.NameTable.Add(@"TypeB"); + id42_Document = Reader.NameTable.Add(@"Document"); + id273_NMTOKENContent = Reader.NameTable.Add(@"NMTOKENContent"); + id191_Items = Reader.NameTable.Add(@"Items"); + id59_TypeWithEnumMembers = Reader.NameTable.Add(@"TypeWithEnumMembers"); + id49_TypeWithDateTimeStringProperty = Reader.NameTable.Add(@"TypeWithDateTimeStringProperty"); + id196_Y = Reader.NameTable.Add(@"Y"); + id231_Short = Reader.NameTable.Add(@"Short"); + id128_XmlSerializerAttributes = Reader.NameTable.Add(@"XmlSerializerAttributes"); + id83_ShortEnum = Reader.NameTable.Add(@"ShortEnum"); + id151_QualifiedParameter = Reader.NameTable.Add(@"QualifiedParameter"); + id120_MiddleName = Reader.NameTable.Add(@"MiddleName"); + id89_ItemChoiceType = Reader.NameTable.Add(@"ItemChoiceType"); + id26_OrderedItem = Reader.NameTable.Add(@"OrderedItem"); + id172_TimeSpanProperty = Reader.NameTable.Add(@"TimeSpanProperty"); + id133_ArrayOfInt = Reader.NameTable.Add(@"ArrayOfInt"); + id219_ByteArray = Reader.NameTable.Add(@"ByteArray"); + id252_MyFieldIgnored = Reader.NameTable.Add(@"MyFieldIgnored"); + id202_SingleField = Reader.NameTable.Add(@"SingleField"); + id207_refs = Reader.NameTable.Add(@"refs"); + id113_TypeWithFieldsOrdered = Reader.NameTable.Add(@"TypeWithFieldsOrdered"); + id39_Item = Reader.NameTable.Add(@"DefaultValuesSetToNegativeInfinity"); + id142_ArrayOfXElement = Reader.NameTable.Add(@"ArrayOfXElement"); + id108_Item = Reader.NameTable.Add(@"KnownTypesThroughConstructorWithArrayProperties"); + id278_Amount = Reader.NameTable.Add(@"Amount"); + id112_MoreChoices = Reader.NameTable.Add(@"MoreChoices"); + id138_double = Reader.NameTable.Add(@"double"); + id43_httpexamplecom = Reader.NameTable.Add(@"http://example.com"); + id229_Some = Reader.NameTable.Add(@"Some"); + id20_BaseIXmlSerializable = Reader.NameTable.Add(@"BaseIXmlSerializable"); + id110_Item = Reader.NameTable.Add(@"TypeWithTypesHavingCustomFormatter"); + id81_ByteEnum = Reader.NameTable.Add(@"ByteEnum"); + id198_Prop = Reader.NameTable.Add(@"Prop"); + id82_SByteEnum = Reader.NameTable.Add(@"SByteEnum"); + id192_SubTotal = Reader.NameTable.Add(@"SubTotal"); + id239_Word = Reader.NameTable.Add(@"Word"); + id17_DerivedClass = Reader.NameTable.Add(@"DerivedClass"); + id18_SimpleBaseClass = Reader.NameTable.Add(@"SimpleBaseClass"); + id47_XElementStruct = Reader.NameTable.Add(@"XElementStruct"); + id205_IntValue = Reader.NameTable.Add(@"IntValue"); + id246_httpelement = Reader.NameTable.Add(@"http://element"); + id76_ClassImplementsInterface = Reader.NameTable.Add(@"ClassImplementsInterface"); + id54_TypeWithMyCollectionField = Reader.NameTable.Add(@"TypeWithMyCollectionField"); + id85_UIntEnum = Reader.NameTable.Add(@"UIntEnum"); + id189_ShipTo = Reader.NameTable.Add(@"ShipTo"); + id127_Value2 = Reader.NameTable.Add(@"Value2"); + id253_Item = Reader.NameTable.Add(@"UnqualifiedSchemaFormListProperty"); + id62_BuiltInTypes = Reader.NameTable.Add(@"BuiltInTypes"); + id260_MetricConfigUrl = Reader.NameTable.Add(@"MetricConfigUrl"); + id115_Root = Reader.NameTable.Add(@"Root"); + id283_httptestcom = Reader.NameTable.Add(@"http://test.com"); + id107_TypeWithShouldSerializeMethod = Reader.NameTable.Add(@"TypeWithShouldSerializeMethod"); + id274_NMTOKENSContent = Reader.NameTable.Add(@"NMTOKENSContent"); + id271_NameContent = Reader.NameTable.Add(@"NameContent"); + id95_TypeWithXmlSchemaFormAttribute = Reader.NameTable.Add(@"TypeWithXmlSchemaFormAttribute"); + id66_Item = Reader.NameTable.Add(@"__TypeNameWithSpecialCharacters漢ñ"); + id136_string = Reader.NameTable.Add(@"string"); + id149_NoneParameter = Reader.NameTable.Add(@"NoneParameter"); + id214_F2 = Reader.NameTable.Add(@"F2"); + id234_OptionalInt = Reader.NameTable.Add(@"OptionalInt"); + id242_XmlIncludeProperty = Reader.NameTable.Add(@"XmlIncludeProperty"); + id73_Item = Reader.NameTable.Add(@"TypeWithXmlTextAttributeOnArray"); + id257_name = Reader.NameTable.Add(@"name"); + id31_dateTime = Reader.NameTable.Add(@"dateTime"); + id270_DateContent = Reader.NameTable.Add(@"DateContent"); + id240_Number = Reader.NameTable.Add(@"Number"); + id254_NoneSchemaFormListProperty = Reader.NameTable.Add(@"NoneSchemaFormListProperty"); + id104_Item = Reader.NameTable.Add(@"TypeWithPropertiesHavingDefaultValue"); + id41_TypeWithLinkedProperty = Reader.NameTable.Add(@"TypeWithLinkedProperty"); + id5_Item = Reader.NameTable.Add(@"TypeWithDateTimeOffsetProperties"); + id179_GroupVehicle = Reader.NameTable.Add(@"GroupVehicle"); + id27_AliasedTestType = Reader.NameTable.Add(@"AliasedTestType"); + id215_Collection = Reader.NameTable.Add(@"Collection"); + id168_DTO2 = Reader.NameTable.Add(@"DTO2"); + id210_xelements = Reader.NameTable.Add(@"xelements"); + id222_IntProperty = Reader.NameTable.Add(@"IntProperty"); + id180_EmployeeName = Reader.NameTable.Add(@"EmployeeName"); + id22_DerivedIXmlSerializable = Reader.NameTable.Add(@"DerivedIXmlSerializable"); + id277_Item = Reader.NameTable.Add(@"Item"); + id232_Optional = Reader.NameTable.Add(@"Optional"); + id276_HexBinaryContent = Reader.NameTable.Add(@"HexBinaryContent"); + id152_ArrayOfArrayOfSimpleType = Reader.NameTable.Add(@"ArrayOfArrayOfSimpleType"); + id144_ArrayOfSimpleType = Reader.NameTable.Add(@"ArrayOfSimpleType"); + id93_Item = Reader.NameTable.Add(@"ClassImplementingIXmlSerializable"); + id230_Int = Reader.NameTable.Add(@"Int"); + id97_Item = Reader.NameTable.Add(@"TypeWithSchemaFormInXmlAttribute"); + id211_DateTimeString = Reader.NameTable.Add(@"DateTimeString"); + id280_IntField2 = Reader.NameTable.Add(@"IntField2"); + id147_httpmynamespace = Reader.NameTable.Add(@"http://mynamespace"); + id11_Dog = Reader.NameTable.Add(@"Dog"); + id52_TypeWithGetOnlyArrayProperties = Reader.NameTable.Add(@"TypeWithGetOnlyArrayProperties"); + id61_DCClassWithEnumAndStruct = Reader.NameTable.Add(@"DCClassWithEnumAndStruct"); + id175_Age = Reader.NameTable.Add(@"Age"); + id114_Item = Reader.NameTable.Add(@"TypeWithKnownTypesOfCollectionsWithConflictingXmlName"); + id71_TypeWithByteArrayAsXmlText = Reader.NameTable.Add(@"TypeWithByteArrayAsXmlText"); id4_TypeWithBinaryProperty = Reader.NameTable.Add(@"TypeWithBinaryProperty"); - id221_Short = Reader.NameTable.Add(@"Short"); - id144_QualifiedParameter = Reader.NameTable.Add(@"QualifiedParameter"); - id149_Child = Reader.NameTable.Add(@"Child"); - id203_F1 = Reader.NameTable.Add(@"F1"); - id69_Item = Reader.NameTable.Add(@"http://schemas.xmlsoap.org/ws/2005/04/discovery"); - id229_Word = Reader.NameTable.Add(@"Word"); - id3_TypeWithXmlDocumentProperty = Reader.NameTable.Add(@"TypeWithXmlDocumentProperty"); - id20_Address = Reader.NameTable.Add(@"Address"); - id120_Value2 = Reader.NameTable.Add(@"Value2"); - id121_XmlSerializerAttributes = Reader.NameTable.Add(@"XmlSerializerAttributes"); - id180_OrderDate = Reader.NameTable.Add(@"OrderDate"); - id70_EnumFlags = Reader.NameTable.Add(@"EnumFlags"); - id266_Amount = Reader.NameTable.Add(@"Amount"); + id118_Person = Reader.NameTable.Add(@"Person"); + id261_TwoDArrayOfSimpleType = Reader.NameTable.Add(@"TwoDArrayOfSimpleType"); + id32_Orchestra = Reader.NameTable.Add(@"Orchestra"); + id220_Item = Reader.NameTable.Add(@"PropertyNameWithSpecialCharacters漢ñ"); + id216_Data = Reader.NameTable.Add(@"Data"); + id60_DCStruct = Reader.NameTable.Add(@"DCStruct"); + id148_ArrayOfString1 = Reader.NameTable.Add(@"ArrayOfString1"); + id165_BinaryHexContent = Reader.NameTable.Add(@"BinaryHexContent"); + id91_KnownTypesThroughConstructor = Reader.NameTable.Add(@"KnownTypesThroughConstructor"); + id224_ListProperty = Reader.NameTable.Add(@"ListProperty"); + id195_X = Reader.NameTable.Add(@"X"); + id6_TypeWithTimeSpanProperty = Reader.NameTable.Add(@"TypeWithTimeSpanProperty"); + id203_DoubleProp = Reader.NameTable.Add(@"DoubleProp"); + id106_Item = Reader.NameTable.Add(@"TypeWithEnumFlagPropertyHavingDefaultValue"); + id103_TypeWith2DArrayProperty2 = Reader.NameTable.Add(@"TypeWith2DArrayProperty2"); + id156_Child = Reader.NameTable.Add(@"Child"); + id86_LongEnum = Reader.NameTable.Add(@"LongEnum"); id9_TypeWithXmlNodeArrayProperty = Reader.NameTable.Add(@"TypeWithXmlNodeArrayProperty"); - id259_NameContent = Reader.NameTable.Add(@"NameContent"); - id220_Int = Reader.NameTable.Add(@"Int"); - id64_DerivedClassWithSameProperty2 = Reader.NameTable.Add(@"DerivedClassWithSameProperty2"); - id125_ArrayOfOrderedItem = Reader.NameTable.Add(@"ArrayOfOrderedItem"); - id157_LineTotal = Reader.NameTable.Add(@"LineTotal"); - id254_StringArrayValue = Reader.NameTable.Add(@"StringArrayValue"); - id107_Item = Reader.NameTable.Add(@"TypeWithKnownTypesOfCollectionsWithConflictingXmlName"); - id56_DCClassWithEnumAndStruct = Reader.NameTable.Add(@"DCClassWithEnumAndStruct"); - id270_StringField1 = Reader.NameTable.Add(@"StringField1"); - id182_SubTotal = Reader.NameTable.Add(@"SubTotal"); - id108_Root = Reader.NameTable.Add(@"Root"); - id39_RootClass = Reader.NameTable.Add(@"RootClass"); - id258_DateContent = Reader.NameTable.Add(@"DateContent"); + id25_Address = Reader.NameTable.Add(@"Address"); + id162_UnitPrice = Reader.NameTable.Add(@"UnitPrice"); + id125_B = Reader.NameTable.Add(@"B"); + id68_DerivedClassWithSameProperty = Reader.NameTable.Add(@"DerivedClassWithSameProperty"); + id51_TypeWithGetSetArrayMembers = Reader.NameTable.Add(@"TypeWithGetSetArrayMembers"); + id236_Struct1 = Reader.NameTable.Add(@"Struct1"); + id150_ArrayOfBoolean = Reader.NameTable.Add(@"ArrayOfBoolean"); + id177_LicenseNumber = Reader.NameTable.Add(@"LicenseNumber"); + id72_SimpleDC = Reader.NameTable.Add(@"SimpleDC"); + id94_TypeWithPropertyNameSpecified = Reader.NameTable.Add(@"TypeWithPropertyNameSpecified"); + id96_MyXmlType = Reader.NameTable.Add(@"MyXmlType"); + id101_ServerSettings = Reader.NameTable.Add(@"ServerSettings"); + id226_DisplayName = Reader.NameTable.Add(@"DisplayName"); + id19_SimpleDerivedClass = Reader.NameTable.Add(@"SimpleDerivedClass"); + id153_P1 = Reader.NameTable.Add(@"P1"); + id183_DateTimeValue = Reader.NameTable.Add(@"DateTimeValue"); + id154_P2 = Reader.NameTable.Add(@"P2"); + id2_Item = Reader.NameTable.Add(@""); + id269_QNameContent = Reader.NameTable.Add(@"QNameContent"); + id1_TypeWithXmlElementProperty = Reader.NameTable.Add(@"TypeWithXmlElementProperty"); + id3_TypeWithXmlDocumentProperty = Reader.NameTable.Add(@"TypeWithXmlDocumentProperty"); + id263_CharProperty = Reader.NameTable.Add(@"CharProperty"); + id178_GroupName = Reader.NameTable.Add(@"GroupName"); + id134_int = Reader.NameTable.Add(@"int"); + id186_City = Reader.NameTable.Add(@"City"); + id69_DerivedClassWithSameProperty2 = Reader.NameTable.Add(@"DerivedClassWithSameProperty2"); + id75_EnumFlags = Reader.NameTable.Add(@"EnumFlags"); + id235_OptionullInt = Reader.NameTable.Add(@"OptionullInt"); + id158_IsValved = Reader.NameTable.Add(@"IsValved"); + id157_Children = Reader.NameTable.Add(@"Children"); + id92_SimpleKnownTypeValue = Reader.NameTable.Add(@"SimpleKnownTypeValue"); + id262_EmptyStringProperty = Reader.NameTable.Add(@"EmptyStringProperty"); + id194_TotalCost = Reader.NameTable.Add(@"TotalCost"); + id171_NullableDefaultDTO = Reader.NameTable.Add(@"NullableDefaultDTO"); + id100_Item = Reader.NameTable.Add(@"TypeWithNonPublicDefaultConstructor"); + id132_ArrayOfOrderedItem = Reader.NameTable.Add(@"ArrayOfOrderedItem"); + id143_XElement = Reader.NameTable.Add(@"XElement"); + id15_Employee = Reader.NameTable.Add(@"Employee"); + id187_State = Reader.NameTable.Add(@"State"); + id173_TimeSpanProperty2 = Reader.NameTable.Add(@"TimeSpanProperty2"); + id188_Zip = Reader.NameTable.Add(@"Zip"); + id122_Name = Reader.NameTable.Add(@"Name"); + id241_DecimalNumber = Reader.NameTable.Add(@"DecimalNumber"); + id221_StringProperty = Reader.NameTable.Add(@"StringProperty"); + id204_FloatProp = Reader.NameTable.Add(@"FloatProp"); + id218_MyEnum1 = Reader.NameTable.Add(@"MyEnum1"); + id30_ArrayOfDateTime = Reader.NameTable.Add(@"ArrayOfDateTime"); + id65_TypeHasArrayOfASerializedAsB = Reader.NameTable.Add(@"TypeHasArrayOfASerializedAsB"); + id87_ULongEnum = Reader.NameTable.Add(@"ULongEnum"); + id84_IntEnum = Reader.NameTable.Add(@"IntEnum"); + id248_EnumValue = Reader.NameTable.Add(@"EnumValue"); + id50_SimpleType = Reader.NameTable.Add(@"SimpleType"); + id206_id = Reader.NameTable.Add(@"id"); + id247_CustomXmlArrayProperty = Reader.NameTable.Add(@"CustomXmlArrayProperty"); + id38_Item = Reader.NameTable.Add(@"DefaultValuesSetToPositiveInfinity"); + id36_Pet = Reader.NameTable.Add(@"Pet"); + id208_Parameters = Reader.NameTable.Add(@"Parameters"); + id67_BaseClassWithSamePropertyName = Reader.NameTable.Add(@"BaseClassWithSamePropertyName"); + id116_TypeClashB = Reader.NameTable.Add(@"TypeClashB"); + id21_Item = Reader.NameTable.Add(@"http://example.com/serializer-test-namespace"); + id282_TestProperty = Reader.NameTable.Add(@"TestProperty"); + id129_ParameterOfString = Reader.NameTable.Add(@"ParameterOfString"); + id14_Vehicle = Reader.NameTable.Add(@"Vehicle"); + id130_MsgDocumentType = Reader.NameTable.Add(@"MsgDocumentType"); + id10_Animal = Reader.NameTable.Add(@"Animal"); + id29_DerivedClass1 = Reader.NameTable.Add(@"DerivedClass1"); + id135_ArrayOfString = Reader.NameTable.Add(@"ArrayOfString"); + id170_NullableDTO = Reader.NameTable.Add(@"NullableDTO"); + id244_Item = Reader.NameTable.Add(@"XmlNamespaceDeclarationsProperty"); + id70_Item = Reader.NameTable.Add(@"TypeWithDateTimePropertyAsXmlTime"); + id37_DefaultValuesSetToNaN = Reader.NameTable.Add(@"DefaultValuesSetToNaN"); + id40_RootElement = Reader.NameTable.Add(@"RootElement"); + id227_Id = Reader.NameTable.Add(@"Id"); + id137_ArrayOfDouble = Reader.NameTable.Add(@"ArrayOfDouble"); + id167_DTO = Reader.NameTable.Add(@"DTO"); + id164_LineTotal = Reader.NameTable.Add(@"LineTotal"); } } @@ -13992,11 +14575,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write107_TypeWithXmlElementProperty(objectToSerialize); + ((XmlSerializationWriter1)writer).Write111_TypeWithXmlElementProperty(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read111_TypeWithXmlElementProperty(); + return ((XmlSerializationReader1)reader).Read115_TypeWithXmlElementProperty(); } } @@ -14007,11 +14590,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write108_TypeWithXmlDocumentProperty(objectToSerialize); + ((XmlSerializationWriter1)writer).Write112_TypeWithXmlDocumentProperty(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read112_TypeWithXmlDocumentProperty(); + return ((XmlSerializationReader1)reader).Read116_TypeWithXmlDocumentProperty(); } } @@ -14022,11 +14605,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write109_TypeWithBinaryProperty(objectToSerialize); + ((XmlSerializationWriter1)writer).Write113_TypeWithBinaryProperty(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read113_TypeWithBinaryProperty(); + return ((XmlSerializationReader1)reader).Read117_TypeWithBinaryProperty(); } } @@ -14037,11 +14620,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write110_Item(objectToSerialize); + ((XmlSerializationWriter1)writer).Write114_Item(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read114_Item(); + return ((XmlSerializationReader1)reader).Read118_Item(); } } @@ -14052,11 +14635,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write111_TypeWithTimeSpanProperty(objectToSerialize); + ((XmlSerializationWriter1)writer).Write115_TypeWithTimeSpanProperty(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read115_TypeWithTimeSpanProperty(); + return ((XmlSerializationReader1)reader).Read119_TypeWithTimeSpanProperty(); } } @@ -14067,11 +14650,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write112_Item(objectToSerialize); + ((XmlSerializationWriter1)writer).Write116_Item(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read116_Item(); + return ((XmlSerializationReader1)reader).Read120_Item(); } } @@ -14082,11 +14665,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write113_TypeWithByteProperty(objectToSerialize); + ((XmlSerializationWriter1)writer).Write117_TypeWithByteProperty(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read117_TypeWithByteProperty(); + return ((XmlSerializationReader1)reader).Read121_TypeWithByteProperty(); } } @@ -14097,11 +14680,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write114_TypeWithXmlNodeArrayProperty(objectToSerialize); + ((XmlSerializationWriter1)writer).Write118_TypeWithXmlNodeArrayProperty(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read118_TypeWithXmlNodeArrayProperty(); + return ((XmlSerializationReader1)reader).Read122_TypeWithXmlNodeArrayProperty(); } } @@ -14112,11 +14695,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write115_Animal(objectToSerialize); + ((XmlSerializationWriter1)writer).Write119_Animal(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read119_Animal(); + return ((XmlSerializationReader1)reader).Read123_Animal(); } } @@ -14127,11 +14710,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write116_Dog(objectToSerialize); + ((XmlSerializationWriter1)writer).Write120_Dog(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read120_Dog(); + return ((XmlSerializationReader1)reader).Read124_Dog(); } } @@ -14142,11 +14725,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write117_DogBreed(objectToSerialize); + ((XmlSerializationWriter1)writer).Write121_DogBreed(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read121_DogBreed(); + return ((XmlSerializationReader1)reader).Read125_DogBreed(); } } @@ -14157,11 +14740,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write118_Group(objectToSerialize); + ((XmlSerializationWriter1)writer).Write122_Group(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read122_Group(); + return ((XmlSerializationReader1)reader).Read126_Group(); } } @@ -14172,11 +14755,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write119_Vehicle(objectToSerialize); + ((XmlSerializationWriter1)writer).Write123_Vehicle(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read123_Vehicle(); + return ((XmlSerializationReader1)reader).Read127_Vehicle(); } } @@ -14187,11 +14770,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write120_Employee(objectToSerialize); + ((XmlSerializationWriter1)writer).Write124_Employee(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read124_Employee(); + return ((XmlSerializationReader1)reader).Read128_Employee(); } } @@ -14202,11 +14785,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write121_BaseClass(objectToSerialize); + ((XmlSerializationWriter1)writer).Write125_BaseClass(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read125_BaseClass(); + return ((XmlSerializationReader1)reader).Read129_BaseClass(); } } @@ -14217,11 +14800,71 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write122_DerivedClass(objectToSerialize); + ((XmlSerializationWriter1)writer).Write126_DerivedClass(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read126_DerivedClass(); + return ((XmlSerializationReader1)reader).Read130_DerivedClass(); + } + } + + public sealed class SimpleBaseClassSerializer : XmlSerializer1 { + + public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { + return xmlReader.IsStartElement(@"SimpleBaseClass", @""); + } + + protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { + ((XmlSerializationWriter1)writer).Write127_SimpleBaseClass(objectToSerialize); + } + + protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { + return ((XmlSerializationReader1)reader).Read131_SimpleBaseClass(); + } + } + + public sealed class SimpleDerivedClassSerializer : XmlSerializer1 { + + public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { + return xmlReader.IsStartElement(@"SimpleDerivedClass", @""); + } + + protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { + ((XmlSerializationWriter1)writer).Write128_SimpleDerivedClass(objectToSerialize); + } + + protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { + return ((XmlSerializationReader1)reader).Read132_SimpleDerivedClass(); + } + } + + public sealed class XmlSerializableBaseClassSerializer : XmlSerializer1 { + + public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { + return xmlReader.IsStartElement(@"BaseIXmlSerializable", @"http://example.com/serializer-test-namespace"); + } + + protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { + ((XmlSerializationWriter1)writer).Write129_BaseIXmlSerializable(objectToSerialize); + } + + protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { + return ((XmlSerializationReader1)reader).Read133_BaseIXmlSerializable(); + } + } + + public sealed class XmlSerializableDerivedClassSerializer : XmlSerializer1 { + + public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { + return xmlReader.IsStartElement(@"DerivedIXmlSerializable", @""); + } + + protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { + ((XmlSerializationWriter1)writer).Write130_DerivedIXmlSerializable(objectToSerialize); + } + + protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { + return ((XmlSerializationReader1)reader).Read134_DerivedIXmlSerializable(); } } @@ -14232,11 +14875,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write123_PurchaseOrder(objectToSerialize); + ((XmlSerializationWriter1)writer).Write131_PurchaseOrder(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read127_PurchaseOrder(); + return ((XmlSerializationReader1)reader).Read135_PurchaseOrder(); } } @@ -14247,11 +14890,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write124_Address(objectToSerialize); + ((XmlSerializationWriter1)writer).Write132_Address(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read128_Address(); + return ((XmlSerializationReader1)reader).Read136_Address(); } } @@ -14262,11 +14905,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write125_OrderedItem(objectToSerialize); + ((XmlSerializationWriter1)writer).Write133_OrderedItem(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read129_OrderedItem(); + return ((XmlSerializationReader1)reader).Read137_OrderedItem(); } } @@ -14277,11 +14920,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write126_AliasedTestType(objectToSerialize); + ((XmlSerializationWriter1)writer).Write134_AliasedTestType(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read130_AliasedTestType(); + return ((XmlSerializationReader1)reader).Read138_AliasedTestType(); } } @@ -14292,11 +14935,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write127_BaseClass1(objectToSerialize); + ((XmlSerializationWriter1)writer).Write135_BaseClass1(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read131_BaseClass1(); + return ((XmlSerializationReader1)reader).Read139_BaseClass1(); } } @@ -14307,11 +14950,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write128_DerivedClass1(objectToSerialize); + ((XmlSerializationWriter1)writer).Write136_DerivedClass1(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read132_DerivedClass1(); + return ((XmlSerializationReader1)reader).Read140_DerivedClass1(); } } @@ -14322,11 +14965,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write129_ArrayOfDateTime(objectToSerialize); + ((XmlSerializationWriter1)writer).Write137_ArrayOfDateTime(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read133_ArrayOfDateTime(); + return ((XmlSerializationReader1)reader).Read141_ArrayOfDateTime(); } } @@ -14337,11 +14980,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write130_Orchestra(objectToSerialize); + ((XmlSerializationWriter1)writer).Write138_Orchestra(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read134_Orchestra(); + return ((XmlSerializationReader1)reader).Read142_Orchestra(); } } @@ -14352,11 +14995,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write131_Instrument(objectToSerialize); + ((XmlSerializationWriter1)writer).Write139_Instrument(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read135_Instrument(); + return ((XmlSerializationReader1)reader).Read143_Instrument(); } } @@ -14367,11 +15010,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write132_Brass(objectToSerialize); + ((XmlSerializationWriter1)writer).Write140_Brass(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read136_Brass(); + return ((XmlSerializationReader1)reader).Read144_Brass(); } } @@ -14382,11 +15025,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write133_Trumpet(objectToSerialize); + ((XmlSerializationWriter1)writer).Write141_Trumpet(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read137_Trumpet(); + return ((XmlSerializationReader1)reader).Read145_Trumpet(); } } @@ -14397,11 +15040,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write134_Pet(objectToSerialize); + ((XmlSerializationWriter1)writer).Write142_Pet(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read138_Pet(); + return ((XmlSerializationReader1)reader).Read146_Pet(); } } @@ -14412,11 +15055,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write135_DefaultValuesSetToNaN(objectToSerialize); + ((XmlSerializationWriter1)writer).Write143_DefaultValuesSetToNaN(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read139_DefaultValuesSetToNaN(); + return ((XmlSerializationReader1)reader).Read147_DefaultValuesSetToNaN(); } } @@ -14427,11 +15070,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write136_Item(objectToSerialize); + ((XmlSerializationWriter1)writer).Write144_Item(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read140_Item(); + return ((XmlSerializationReader1)reader).Read148_Item(); } } @@ -14442,11 +15085,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write137_Item(objectToSerialize); + ((XmlSerializationWriter1)writer).Write145_Item(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read141_Item(); + return ((XmlSerializationReader1)reader).Read149_Item(); } } @@ -14457,11 +15100,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write138_RootElement(objectToSerialize); + ((XmlSerializationWriter1)writer).Write146_RootElement(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read142_RootElement(); + return ((XmlSerializationReader1)reader).Read150_RootElement(); } } @@ -14472,11 +15115,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write139_TypeWithLinkedProperty(objectToSerialize); + ((XmlSerializationWriter1)writer).Write147_TypeWithLinkedProperty(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read143_TypeWithLinkedProperty(); + return ((XmlSerializationReader1)reader).Read151_TypeWithLinkedProperty(); } } @@ -14487,11 +15130,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write140_Document(objectToSerialize); + ((XmlSerializationWriter1)writer).Write148_Document(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read144_Document(); + return ((XmlSerializationReader1)reader).Read152_Document(); } } @@ -14502,11 +15145,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write141_RootClass(objectToSerialize); + ((XmlSerializationWriter1)writer).Write149_RootClass(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read145_RootClass(); + return ((XmlSerializationReader1)reader).Read153_RootClass(); } } @@ -14517,11 +15160,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write142_Parameter(objectToSerialize); + ((XmlSerializationWriter1)writer).Write150_Parameter(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read146_Parameter(); + return ((XmlSerializationReader1)reader).Read154_Parameter(); } } @@ -14532,11 +15175,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write143_XElementWrapper(objectToSerialize); + ((XmlSerializationWriter1)writer).Write151_XElementWrapper(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read147_XElementWrapper(); + return ((XmlSerializationReader1)reader).Read155_XElementWrapper(); } } @@ -14547,11 +15190,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write144_XElementStruct(objectToSerialize); + ((XmlSerializationWriter1)writer).Write152_XElementStruct(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read148_XElementStruct(); + return ((XmlSerializationReader1)reader).Read156_XElementStruct(); } } @@ -14562,11 +15205,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write145_XElementArrayWrapper(objectToSerialize); + ((XmlSerializationWriter1)writer).Write153_XElementArrayWrapper(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read149_XElementArrayWrapper(); + return ((XmlSerializationReader1)reader).Read157_XElementArrayWrapper(); } } @@ -14577,11 +15220,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write146_TypeWithDateTimeStringProperty(objectToSerialize); + ((XmlSerializationWriter1)writer).Write154_TypeWithDateTimeStringProperty(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read150_TypeWithDateTimeStringProperty(); + return ((XmlSerializationReader1)reader).Read158_TypeWithDateTimeStringProperty(); } } @@ -14592,11 +15235,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write147_SimpleType(objectToSerialize); + ((XmlSerializationWriter1)writer).Write155_SimpleType(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read151_SimpleType(); + return ((XmlSerializationReader1)reader).Read159_SimpleType(); } } @@ -14607,11 +15250,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write148_TypeWithGetSetArrayMembers(objectToSerialize); + ((XmlSerializationWriter1)writer).Write156_TypeWithGetSetArrayMembers(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read152_TypeWithGetSetArrayMembers(); + return ((XmlSerializationReader1)reader).Read160_TypeWithGetSetArrayMembers(); } } @@ -14622,11 +15265,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write149_TypeWithGetOnlyArrayProperties(objectToSerialize); + ((XmlSerializationWriter1)writer).Write157_TypeWithGetOnlyArrayProperties(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read153_TypeWithGetOnlyArrayProperties(); + return ((XmlSerializationReader1)reader).Read161_TypeWithGetOnlyArrayProperties(); } } @@ -14637,11 +15280,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write150_StructNotSerializable(objectToSerialize); + ((XmlSerializationWriter1)writer).Write158_StructNotSerializable(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read154_StructNotSerializable(); + return ((XmlSerializationReader1)reader).Read162_StructNotSerializable(); } } @@ -14652,11 +15295,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write151_TypeWithMyCollectionField(objectToSerialize); + ((XmlSerializationWriter1)writer).Write159_TypeWithMyCollectionField(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read155_TypeWithMyCollectionField(); + return ((XmlSerializationReader1)reader).Read163_TypeWithMyCollectionField(); } } @@ -14667,11 +15310,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write152_Item(objectToSerialize); + ((XmlSerializationWriter1)writer).Write160_Item(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read156_Item(); + return ((XmlSerializationReader1)reader).Read164_Item(); } } @@ -14682,11 +15325,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write153_ArrayOfAnyType(objectToSerialize); + ((XmlSerializationWriter1)writer).Write161_ArrayOfAnyType(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read157_ArrayOfAnyType(); + return ((XmlSerializationReader1)reader).Read165_ArrayOfAnyType(); } } @@ -14697,11 +15340,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write154_MyEnum(objectToSerialize); + ((XmlSerializationWriter1)writer).Write162_MyEnum(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read158_MyEnum(); + return ((XmlSerializationReader1)reader).Read166_MyEnum(); } } @@ -14712,11 +15355,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write155_TypeWithEnumMembers(objectToSerialize); + ((XmlSerializationWriter1)writer).Write163_TypeWithEnumMembers(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read159_TypeWithEnumMembers(); + return ((XmlSerializationReader1)reader).Read167_TypeWithEnumMembers(); } } @@ -14727,11 +15370,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write156_DCStruct(objectToSerialize); + ((XmlSerializationWriter1)writer).Write164_DCStruct(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read160_DCStruct(); + return ((XmlSerializationReader1)reader).Read168_DCStruct(); } } @@ -14742,11 +15385,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write157_DCClassWithEnumAndStruct(objectToSerialize); + ((XmlSerializationWriter1)writer).Write165_DCClassWithEnumAndStruct(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read161_DCClassWithEnumAndStruct(); + return ((XmlSerializationReader1)reader).Read169_DCClassWithEnumAndStruct(); } } @@ -14757,11 +15400,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write158_BuiltInTypes(objectToSerialize); + ((XmlSerializationWriter1)writer).Write166_BuiltInTypes(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read162_BuiltInTypes(); + return ((XmlSerializationReader1)reader).Read170_BuiltInTypes(); } } @@ -14772,11 +15415,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write159_TypeA(objectToSerialize); + ((XmlSerializationWriter1)writer).Write167_TypeA(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read163_TypeA(); + return ((XmlSerializationReader1)reader).Read171_TypeA(); } } @@ -14787,11 +15430,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write160_TypeB(objectToSerialize); + ((XmlSerializationWriter1)writer).Write168_TypeB(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read164_TypeB(); + return ((XmlSerializationReader1)reader).Read172_TypeB(); } } @@ -14802,11 +15445,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write161_TypeHasArrayOfASerializedAsB(objectToSerialize); + ((XmlSerializationWriter1)writer).Write169_TypeHasArrayOfASerializedAsB(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read165_TypeHasArrayOfASerializedAsB(); + return ((XmlSerializationReader1)reader).Read173_TypeHasArrayOfASerializedAsB(); } } @@ -14817,11 +15460,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write162_Item(objectToSerialize); + ((XmlSerializationWriter1)writer).Write170_Item(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read166_Item(); + return ((XmlSerializationReader1)reader).Read174_Item(); } } @@ -14832,11 +15475,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write163_BaseClassWithSamePropertyName(objectToSerialize); + ((XmlSerializationWriter1)writer).Write171_BaseClassWithSamePropertyName(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read167_BaseClassWithSamePropertyName(); + return ((XmlSerializationReader1)reader).Read175_BaseClassWithSamePropertyName(); } } @@ -14847,11 +15490,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write164_DerivedClassWithSameProperty(objectToSerialize); + ((XmlSerializationWriter1)writer).Write172_DerivedClassWithSameProperty(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read168_DerivedClassWithSameProperty(); + return ((XmlSerializationReader1)reader).Read176_DerivedClassWithSameProperty(); } } @@ -14862,11 +15505,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write165_DerivedClassWithSameProperty2(objectToSerialize); + ((XmlSerializationWriter1)writer).Write173_DerivedClassWithSameProperty2(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read169_DerivedClassWithSameProperty2(); + return ((XmlSerializationReader1)reader).Read177_DerivedClassWithSameProperty2(); } } @@ -14877,11 +15520,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write166_Item(objectToSerialize); + ((XmlSerializationWriter1)writer).Write174_Item(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read170_Item(); + return ((XmlSerializationReader1)reader).Read178_Item(); } } @@ -14892,11 +15535,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write167_TypeWithByteArrayAsXmlText(objectToSerialize); + ((XmlSerializationWriter1)writer).Write175_TypeWithByteArrayAsXmlText(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read171_TypeWithByteArrayAsXmlText(); + return ((XmlSerializationReader1)reader).Read179_TypeWithByteArrayAsXmlText(); } } @@ -14907,11 +15550,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write168_SimpleDC(objectToSerialize); + ((XmlSerializationWriter1)writer).Write176_SimpleDC(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read172_SimpleDC(); + return ((XmlSerializationReader1)reader).Read180_SimpleDC(); } } @@ -14922,11 +15565,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write169_Item(objectToSerialize); + ((XmlSerializationWriter1)writer).Write177_Item(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read173_Item(); + return ((XmlSerializationReader1)reader).Read181_Item(); } } @@ -14937,11 +15580,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write170_EnumFlags(objectToSerialize); + ((XmlSerializationWriter1)writer).Write178_EnumFlags(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read174_EnumFlags(); + return ((XmlSerializationReader1)reader).Read182_EnumFlags(); } } @@ -14952,11 +15595,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write171_ClassImplementsInterface(objectToSerialize); + ((XmlSerializationWriter1)writer).Write179_ClassImplementsInterface(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read175_ClassImplementsInterface(); + return ((XmlSerializationReader1)reader).Read183_ClassImplementsInterface(); } } @@ -14967,11 +15610,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write172_WithStruct(objectToSerialize); + ((XmlSerializationWriter1)writer).Write180_WithStruct(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read176_WithStruct(); + return ((XmlSerializationReader1)reader).Read184_WithStruct(); } } @@ -14982,11 +15625,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write173_SomeStruct(objectToSerialize); + ((XmlSerializationWriter1)writer).Write181_SomeStruct(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read177_SomeStruct(); + return ((XmlSerializationReader1)reader).Read185_SomeStruct(); } } @@ -14997,11 +15640,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write174_WithEnums(objectToSerialize); + ((XmlSerializationWriter1)writer).Write182_WithEnums(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read178_WithEnums(); + return ((XmlSerializationReader1)reader).Read186_WithEnums(); } } @@ -15012,11 +15655,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write175_WithNullables(objectToSerialize); + ((XmlSerializationWriter1)writer).Write183_WithNullables(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read179_WithNullables(); + return ((XmlSerializationReader1)reader).Read187_WithNullables(); } } @@ -15027,11 +15670,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write176_ByteEnum(objectToSerialize); + ((XmlSerializationWriter1)writer).Write184_ByteEnum(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read180_ByteEnum(); + return ((XmlSerializationReader1)reader).Read188_ByteEnum(); } } @@ -15042,11 +15685,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write177_SByteEnum(objectToSerialize); + ((XmlSerializationWriter1)writer).Write185_SByteEnum(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read181_SByteEnum(); + return ((XmlSerializationReader1)reader).Read189_SByteEnum(); } } @@ -15057,11 +15700,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write178_ShortEnum(objectToSerialize); + ((XmlSerializationWriter1)writer).Write186_ShortEnum(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read182_ShortEnum(); + return ((XmlSerializationReader1)reader).Read190_ShortEnum(); } } @@ -15072,11 +15715,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write179_IntEnum(objectToSerialize); + ((XmlSerializationWriter1)writer).Write187_IntEnum(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read183_IntEnum(); + return ((XmlSerializationReader1)reader).Read191_IntEnum(); } } @@ -15087,11 +15730,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write180_UIntEnum(objectToSerialize); + ((XmlSerializationWriter1)writer).Write188_UIntEnum(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read184_UIntEnum(); + return ((XmlSerializationReader1)reader).Read192_UIntEnum(); } } @@ -15102,11 +15745,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write181_LongEnum(objectToSerialize); + ((XmlSerializationWriter1)writer).Write189_LongEnum(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read185_LongEnum(); + return ((XmlSerializationReader1)reader).Read193_LongEnum(); } } @@ -15117,11 +15760,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write182_ULongEnum(objectToSerialize); + ((XmlSerializationWriter1)writer).Write190_ULongEnum(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read186_ULongEnum(); + return ((XmlSerializationReader1)reader).Read194_ULongEnum(); } } @@ -15132,11 +15775,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write183_AttributeTesting(objectToSerialize); + ((XmlSerializationWriter1)writer).Write191_AttributeTesting(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read187_AttributeTesting(); + return ((XmlSerializationReader1)reader).Read195_AttributeTesting(); } } @@ -15147,11 +15790,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write184_ItemChoiceType(objectToSerialize); + ((XmlSerializationWriter1)writer).Write192_ItemChoiceType(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read188_ItemChoiceType(); + return ((XmlSerializationReader1)reader).Read196_ItemChoiceType(); } } @@ -15162,11 +15805,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write185_TypeWithAnyAttribute(objectToSerialize); + ((XmlSerializationWriter1)writer).Write193_TypeWithAnyAttribute(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read189_TypeWithAnyAttribute(); + return ((XmlSerializationReader1)reader).Read197_TypeWithAnyAttribute(); } } @@ -15177,11 +15820,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write186_KnownTypesThroughConstructor(objectToSerialize); + ((XmlSerializationWriter1)writer).Write194_KnownTypesThroughConstructor(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read190_KnownTypesThroughConstructor(); + return ((XmlSerializationReader1)reader).Read198_KnownTypesThroughConstructor(); } } @@ -15192,26 +15835,26 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write187_SimpleKnownTypeValue(objectToSerialize); + ((XmlSerializationWriter1)writer).Write195_SimpleKnownTypeValue(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read191_SimpleKnownTypeValue(); + return ((XmlSerializationReader1)reader).Read199_SimpleKnownTypeValue(); } } - public sealed class ClassImplementingIXmlSerialiableSerializer : XmlSerializer1 { + public sealed class ClassImplementingIXmlSerializableSerializer : XmlSerializer1 { public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { - return xmlReader.IsStartElement(@"ClassImplementingIXmlSerialiable", @""); + return xmlReader.IsStartElement(@"ClassImplementingIXmlSerializable", @""); } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write188_Item(objectToSerialize); + ((XmlSerializationWriter1)writer).Write196_Item(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read192_Item(); + return ((XmlSerializationReader1)reader).Read200_Item(); } } @@ -15222,11 +15865,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write189_TypeWithPropertyNameSpecified(objectToSerialize); + ((XmlSerializationWriter1)writer).Write197_TypeWithPropertyNameSpecified(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read193_TypeWithPropertyNameSpecified(); + return ((XmlSerializationReader1)reader).Read201_TypeWithPropertyNameSpecified(); } } @@ -15237,11 +15880,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write190_TypeWithXmlSchemaFormAttribute(objectToSerialize); + ((XmlSerializationWriter1)writer).Write198_TypeWithXmlSchemaFormAttribute(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read194_TypeWithXmlSchemaFormAttribute(); + return ((XmlSerializationReader1)reader).Read202_TypeWithXmlSchemaFormAttribute(); } } @@ -15252,11 +15895,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write191_MyXmlType(objectToSerialize); + ((XmlSerializationWriter1)writer).Write199_MyXmlType(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read195_MyXmlType(); + return ((XmlSerializationReader1)reader).Read203_MyXmlType(); } } @@ -15267,11 +15910,56 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write192_Item(objectToSerialize); + ((XmlSerializationWriter1)writer).Write200_Item(objectToSerialize); + } + + protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { + return ((XmlSerializationReader1)reader).Read204_Item(); + } + } + + public sealed class CustomDocumentSerializer : XmlSerializer1 { + + public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { + return xmlReader.IsStartElement(@"CustomDocument", @""); + } + + protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { + ((XmlSerializationWriter1)writer).Write201_CustomDocument(objectToSerialize); + } + + protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { + return ((XmlSerializationReader1)reader).Read205_CustomDocument(); + } + } + + public sealed class CustomElementSerializer : XmlSerializer1 { + + public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { + return xmlReader.IsStartElement(@"CustomElement", @""); + } + + protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { + ((XmlSerializationWriter1)writer).Write202_CustomElement(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read196_Item(); + return ((XmlSerializationReader1)reader).Read206_CustomElement(); + } + } + + public sealed class CustomAttributeSerializer : XmlSerializer1 { + + public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { + return true; + } + + protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { + ((XmlSerializationWriter1)writer).Write203_Item(objectToSerialize); + } + + protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { + return ((XmlSerializationReader1)reader).Read207_Item(); } } @@ -15282,11 +15970,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write193_Item(objectToSerialize); + ((XmlSerializationWriter1)writer).Write204_Item(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read197_Item(); + return ((XmlSerializationReader1)reader).Read208_Item(); } } @@ -15297,11 +15985,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write194_ServerSettings(objectToSerialize); + ((XmlSerializationWriter1)writer).Write205_ServerSettings(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read198_ServerSettings(); + return ((XmlSerializationReader1)reader).Read209_ServerSettings(); } } @@ -15312,11 +16000,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write195_TypeWithXmlQualifiedName(objectToSerialize); + ((XmlSerializationWriter1)writer).Write206_TypeWithXmlQualifiedName(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read199_TypeWithXmlQualifiedName(); + return ((XmlSerializationReader1)reader).Read210_TypeWithXmlQualifiedName(); } } @@ -15327,11 +16015,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write196_TypeWith2DArrayProperty2(objectToSerialize); + ((XmlSerializationWriter1)writer).Write207_TypeWith2DArrayProperty2(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read200_TypeWith2DArrayProperty2(); + return ((XmlSerializationReader1)reader).Read211_TypeWith2DArrayProperty2(); } } @@ -15342,11 +16030,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write197_Item(objectToSerialize); + ((XmlSerializationWriter1)writer).Write208_Item(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read201_Item(); + return ((XmlSerializationReader1)reader).Read212_Item(); } } @@ -15357,11 +16045,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write198_Item(objectToSerialize); + ((XmlSerializationWriter1)writer).Write209_Item(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read202_Item(); + return ((XmlSerializationReader1)reader).Read213_Item(); } } @@ -15372,11 +16060,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write199_Item(objectToSerialize); + ((XmlSerializationWriter1)writer).Write210_Item(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read203_Item(); + return ((XmlSerializationReader1)reader).Read214_Item(); } } @@ -15387,11 +16075,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write200_TypeWithShouldSerializeMethod(objectToSerialize); + ((XmlSerializationWriter1)writer).Write211_TypeWithShouldSerializeMethod(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read204_TypeWithShouldSerializeMethod(); + return ((XmlSerializationReader1)reader).Read215_TypeWithShouldSerializeMethod(); } } @@ -15402,11 +16090,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write201_Item(objectToSerialize); + ((XmlSerializationWriter1)writer).Write212_Item(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read205_Item(); + return ((XmlSerializationReader1)reader).Read216_Item(); } } @@ -15417,11 +16105,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write202_Item(objectToSerialize); + ((XmlSerializationWriter1)writer).Write213_Item(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read206_Item(); + return ((XmlSerializationReader1)reader).Read217_Item(); } } @@ -15432,11 +16120,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write203_Item(objectToSerialize); + ((XmlSerializationWriter1)writer).Write214_Item(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read207_Item(); + return ((XmlSerializationReader1)reader).Read218_Item(); } } @@ -15447,11 +16135,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write204_Item(objectToSerialize); + ((XmlSerializationWriter1)writer).Write215_Item(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read208_Item(); + return ((XmlSerializationReader1)reader).Read219_Item(); } } @@ -15462,11 +16150,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write205_MoreChoices(objectToSerialize); + ((XmlSerializationWriter1)writer).Write216_MoreChoices(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read209_MoreChoices(); + return ((XmlSerializationReader1)reader).Read220_MoreChoices(); } } @@ -15477,11 +16165,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write206_TypeWithFieldsOrdered(objectToSerialize); + ((XmlSerializationWriter1)writer).Write217_TypeWithFieldsOrdered(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read210_TypeWithFieldsOrdered(); + return ((XmlSerializationReader1)reader).Read221_TypeWithFieldsOrdered(); } } @@ -15492,11 +16180,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write207_Item(objectToSerialize); + ((XmlSerializationWriter1)writer).Write218_Item(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read211_Item(); + return ((XmlSerializationReader1)reader).Read222_Item(); } } @@ -15507,11 +16195,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write208_Root(objectToSerialize); + ((XmlSerializationWriter1)writer).Write219_Root(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read212_Root(); + return ((XmlSerializationReader1)reader).Read223_Root(); } } @@ -15522,11 +16210,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write209_TypeClashB(objectToSerialize); + ((XmlSerializationWriter1)writer).Write220_TypeClashB(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read213_TypeClashB(); + return ((XmlSerializationReader1)reader).Read224_TypeClashB(); } } @@ -15537,11 +16225,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write210_TypeClashA(objectToSerialize); + ((XmlSerializationWriter1)writer).Write221_TypeClashA(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read214_TypeClashA(); + return ((XmlSerializationReader1)reader).Read225_TypeClashA(); } } @@ -15552,11 +16240,11 @@ public override System.Boolean CanDeserialize(System.Xml.XmlReader xmlReader) { } protected override void Serialize(object objectToSerialize, System.Xml.Serialization.XmlSerializationWriter writer) { - ((XmlSerializationWriter1)writer).Write211_Person(objectToSerialize); + ((XmlSerializationWriter1)writer).Write222_Person(objectToSerialize); } protected override object Deserialize(System.Xml.Serialization.XmlSerializationReader reader) { - return ((XmlSerializationReader1)reader).Read215_Person(); + return ((XmlSerializationReader1)reader).Read226_Person(); } } @@ -15568,111 +16256,118 @@ public override System.Collections.Hashtable ReadMethods { get { if (readMethods == null) { System.Collections.Hashtable _tmp = new System.Collections.Hashtable(); - _tmp[@"TypeWithXmlElementProperty::"] = @"Read111_TypeWithXmlElementProperty"; - _tmp[@"TypeWithXmlDocumentProperty::"] = @"Read112_TypeWithXmlDocumentProperty"; - _tmp[@"TypeWithBinaryProperty::"] = @"Read113_TypeWithBinaryProperty"; - _tmp[@"TypeWithDateTimeOffsetProperties::"] = @"Read114_Item"; - _tmp[@"TypeWithTimeSpanProperty::"] = @"Read115_TypeWithTimeSpanProperty"; - _tmp[@"TypeWithDefaultTimeSpanProperty::"] = @"Read116_Item"; - _tmp[@"TypeWithByteProperty::"] = @"Read117_TypeWithByteProperty"; - _tmp[@"TypeWithXmlNodeArrayProperty:::True:"] = @"Read118_TypeWithXmlNodeArrayProperty"; - _tmp[@"Animal::"] = @"Read119_Animal"; - _tmp[@"Dog::"] = @"Read120_Dog"; - _tmp[@"DogBreed::"] = @"Read121_DogBreed"; - _tmp[@"Group::"] = @"Read122_Group"; - _tmp[@"Vehicle::"] = @"Read123_Vehicle"; - _tmp[@"Employee::"] = @"Read124_Employee"; - _tmp[@"BaseClass::"] = @"Read125_BaseClass"; - _tmp[@"DerivedClass::"] = @"Read126_DerivedClass"; - _tmp[@"PurchaseOrder:http://www.contoso1.com:PurchaseOrder:False:"] = @"Read127_PurchaseOrder"; - _tmp[@"Address::"] = @"Read128_Address"; - _tmp[@"OrderedItem::"] = @"Read129_OrderedItem"; - _tmp[@"AliasedTestType::"] = @"Read130_AliasedTestType"; - _tmp[@"BaseClass1::"] = @"Read131_BaseClass1"; - _tmp[@"DerivedClass1::"] = @"Read132_DerivedClass1"; - _tmp[@"MyCollection1::"] = @"Read133_ArrayOfDateTime"; - _tmp[@"Orchestra::"] = @"Read134_Orchestra"; - _tmp[@"Instrument::"] = @"Read135_Instrument"; - _tmp[@"Brass::"] = @"Read136_Brass"; - _tmp[@"Trumpet::"] = @"Read137_Trumpet"; - _tmp[@"Pet::"] = @"Read138_Pet"; - _tmp[@"DefaultValuesSetToNaN::"] = @"Read139_DefaultValuesSetToNaN"; - _tmp[@"DefaultValuesSetToPositiveInfinity::"] = @"Read140_Item"; - _tmp[@"DefaultValuesSetToNegativeInfinity::"] = @"Read141_Item"; - _tmp[@"TypeWithMismatchBetweenAttributeAndPropertyType::RootElement:True:"] = @"Read142_RootElement"; - _tmp[@"TypeWithLinkedProperty::"] = @"Read143_TypeWithLinkedProperty"; - _tmp[@"MsgDocumentType:http://example.com:Document:True:"] = @"Read144_Document"; - _tmp[@"RootClass::"] = @"Read145_RootClass"; - _tmp[@"Parameter::"] = @"Read146_Parameter"; - _tmp[@"XElementWrapper::"] = @"Read147_XElementWrapper"; - _tmp[@"XElementStruct::"] = @"Read148_XElementStruct"; - _tmp[@"XElementArrayWrapper::"] = @"Read149_XElementArrayWrapper"; - _tmp[@"SerializationTypes.TypeWithDateTimeStringProperty::"] = @"Read150_TypeWithDateTimeStringProperty"; - _tmp[@"SerializationTypes.SimpleType::"] = @"Read151_SimpleType"; - _tmp[@"SerializationTypes.TypeWithGetSetArrayMembers::"] = @"Read152_TypeWithGetSetArrayMembers"; - _tmp[@"SerializationTypes.TypeWithGetOnlyArrayProperties::"] = @"Read153_TypeWithGetOnlyArrayProperties"; - _tmp[@"SerializationTypes.StructNotSerializable::"] = @"Read154_StructNotSerializable"; - _tmp[@"SerializationTypes.TypeWithMyCollectionField::"] = @"Read155_TypeWithMyCollectionField"; - _tmp[@"SerializationTypes.TypeWithReadOnlyMyCollectionProperty::"] = @"Read156_Item"; - _tmp[@"SerializationTypes.MyList::"] = @"Read157_ArrayOfAnyType"; - _tmp[@"SerializationTypes.MyEnum::"] = @"Read158_MyEnum"; - _tmp[@"SerializationTypes.TypeWithEnumMembers::"] = @"Read159_TypeWithEnumMembers"; - _tmp[@"SerializationTypes.DCStruct::"] = @"Read160_DCStruct"; - _tmp[@"SerializationTypes.DCClassWithEnumAndStruct::"] = @"Read161_DCClassWithEnumAndStruct"; - _tmp[@"SerializationTypes.BuiltInTypes::"] = @"Read162_BuiltInTypes"; - _tmp[@"SerializationTypes.TypeA::"] = @"Read163_TypeA"; - _tmp[@"SerializationTypes.TypeB::"] = @"Read164_TypeB"; - _tmp[@"SerializationTypes.TypeHasArrayOfASerializedAsB::"] = @"Read165_TypeHasArrayOfASerializedAsB"; - _tmp[@"SerializationTypes.__TypeNameWithSpecialCharacters漢ñ::"] = @"Read166_Item"; - _tmp[@"SerializationTypes.BaseClassWithSamePropertyName::"] = @"Read167_BaseClassWithSamePropertyName"; - _tmp[@"SerializationTypes.DerivedClassWithSameProperty::"] = @"Read168_DerivedClassWithSameProperty"; - _tmp[@"SerializationTypes.DerivedClassWithSameProperty2::"] = @"Read169_DerivedClassWithSameProperty2"; - _tmp[@"SerializationTypes.TypeWithDateTimePropertyAsXmlTime::"] = @"Read170_Item"; - _tmp[@"SerializationTypes.TypeWithByteArrayAsXmlText::"] = @"Read171_TypeWithByteArrayAsXmlText"; - _tmp[@"SerializationTypes.SimpleDC::"] = @"Read172_SimpleDC"; - _tmp[@"SerializationTypes.TypeWithXmlTextAttributeOnArray:http://schemas.xmlsoap.org/ws/2005/04/discovery::False:"] = @"Read173_Item"; - _tmp[@"SerializationTypes.EnumFlags::"] = @"Read174_EnumFlags"; - _tmp[@"SerializationTypes.ClassImplementsInterface::"] = @"Read175_ClassImplementsInterface"; - _tmp[@"SerializationTypes.WithStruct::"] = @"Read176_WithStruct"; - _tmp[@"SerializationTypes.SomeStruct::"] = @"Read177_SomeStruct"; - _tmp[@"SerializationTypes.WithEnums::"] = @"Read178_WithEnums"; - _tmp[@"SerializationTypes.WithNullables::"] = @"Read179_WithNullables"; - _tmp[@"SerializationTypes.ByteEnum::"] = @"Read180_ByteEnum"; - _tmp[@"SerializationTypes.SByteEnum::"] = @"Read181_SByteEnum"; - _tmp[@"SerializationTypes.ShortEnum::"] = @"Read182_ShortEnum"; - _tmp[@"SerializationTypes.IntEnum::"] = @"Read183_IntEnum"; - _tmp[@"SerializationTypes.UIntEnum::"] = @"Read184_UIntEnum"; - _tmp[@"SerializationTypes.LongEnum::"] = @"Read185_LongEnum"; - _tmp[@"SerializationTypes.ULongEnum::"] = @"Read186_ULongEnum"; - _tmp[@"SerializationTypes.XmlSerializerAttributes::AttributeTesting:False:"] = @"Read187_AttributeTesting"; - _tmp[@"SerializationTypes.ItemChoiceType::"] = @"Read188_ItemChoiceType"; - _tmp[@"SerializationTypes.TypeWithAnyAttribute::"] = @"Read189_TypeWithAnyAttribute"; - _tmp[@"SerializationTypes.KnownTypesThroughConstructor::"] = @"Read190_KnownTypesThroughConstructor"; - _tmp[@"SerializationTypes.SimpleKnownTypeValue::"] = @"Read191_SimpleKnownTypeValue"; - _tmp[@"SerializationTypes.ClassImplementingIXmlSerialiable::"] = @"Read192_Item"; - _tmp[@"SerializationTypes.TypeWithPropertyNameSpecified::"] = @"Read193_TypeWithPropertyNameSpecified"; - _tmp[@"SerializationTypes.TypeWithXmlSchemaFormAttribute:::True:"] = @"Read194_TypeWithXmlSchemaFormAttribute"; - _tmp[@"SerializationTypes.TypeWithTypeNameInXmlTypeAttribute::"] = @"Read195_MyXmlType"; - _tmp[@"SerializationTypes.TypeWithSchemaFormInXmlAttribute::"] = @"Read196_Item"; - _tmp[@"SerializationTypes.TypeWithNonPublicDefaultConstructor::"] = @"Read197_Item"; - _tmp[@"SerializationTypes.ServerSettings::"] = @"Read198_ServerSettings"; - _tmp[@"SerializationTypes.TypeWithXmlQualifiedName::"] = @"Read199_TypeWithXmlQualifiedName"; - _tmp[@"SerializationTypes.TypeWith2DArrayProperty2::"] = @"Read200_TypeWith2DArrayProperty2"; - _tmp[@"SerializationTypes.TypeWithPropertiesHavingDefaultValue::"] = @"Read201_Item"; - _tmp[@"SerializationTypes.TypeWithEnumPropertyHavingDefaultValue::"] = @"Read202_Item"; - _tmp[@"SerializationTypes.TypeWithEnumFlagPropertyHavingDefaultValue::"] = @"Read203_Item"; - _tmp[@"SerializationTypes.TypeWithShouldSerializeMethod::"] = @"Read204_TypeWithShouldSerializeMethod"; - _tmp[@"SerializationTypes.KnownTypesThroughConstructorWithArrayProperties::"] = @"Read205_Item"; - _tmp[@"SerializationTypes.KnownTypesThroughConstructorWithValue::"] = @"Read206_Item"; - _tmp[@"SerializationTypes.TypeWithTypesHavingCustomFormatter::"] = @"Read207_Item"; - _tmp[@"SerializationTypes.TypeWithArrayPropertyHavingChoice::"] = @"Read208_Item"; - _tmp[@"SerializationTypes.MoreChoices::"] = @"Read209_MoreChoices"; - _tmp[@"SerializationTypes.TypeWithFieldsOrdered::"] = @"Read210_TypeWithFieldsOrdered"; - _tmp[@"SerializationTypes.TypeWithKnownTypesOfCollectionsWithConflictingXmlName::"] = @"Read211_Item"; - _tmp[@"SerializationTypes.NamespaceTypeNameClashContainer::Root:True:"] = @"Read212_Root"; - _tmp[@"SerializationTypes.TypeNameClashB.TypeNameClash::"] = @"Read213_TypeClashB"; - _tmp[@"SerializationTypes.TypeNameClashA.TypeNameClash::"] = @"Read214_TypeClashA"; - _tmp[@"Outer+Person::"] = @"Read215_Person"; + _tmp[@"TypeWithXmlElementProperty::"] = @"Read115_TypeWithXmlElementProperty"; + _tmp[@"TypeWithXmlDocumentProperty::"] = @"Read116_TypeWithXmlDocumentProperty"; + _tmp[@"TypeWithBinaryProperty::"] = @"Read117_TypeWithBinaryProperty"; + _tmp[@"TypeWithDateTimeOffsetProperties::"] = @"Read118_Item"; + _tmp[@"TypeWithTimeSpanProperty::"] = @"Read119_TypeWithTimeSpanProperty"; + _tmp[@"TypeWithDefaultTimeSpanProperty::"] = @"Read120_Item"; + _tmp[@"TypeWithByteProperty::"] = @"Read121_TypeWithByteProperty"; + _tmp[@"TypeWithXmlNodeArrayProperty:::True:"] = @"Read122_TypeWithXmlNodeArrayProperty"; + _tmp[@"Animal::"] = @"Read123_Animal"; + _tmp[@"Dog::"] = @"Read124_Dog"; + _tmp[@"DogBreed::"] = @"Read125_DogBreed"; + _tmp[@"Group::"] = @"Read126_Group"; + _tmp[@"Vehicle::"] = @"Read127_Vehicle"; + _tmp[@"Employee::"] = @"Read128_Employee"; + _tmp[@"BaseClass::"] = @"Read129_BaseClass"; + _tmp[@"DerivedClass::"] = @"Read130_DerivedClass"; + _tmp[@"SimpleBaseClass::"] = @"Read131_SimpleBaseClass"; + _tmp[@"SimpleDerivedClass::"] = @"Read132_SimpleDerivedClass"; + _tmp[@"XmlSerializableBaseClass:http://example.com/serializer-test-namespace::True:"] = @"Read133_BaseIXmlSerializable"; + _tmp[@"XmlSerializableDerivedClass::"] = @"Read134_DerivedIXmlSerializable"; + _tmp[@"PurchaseOrder:http://www.contoso1.com:PurchaseOrder:False:"] = @"Read135_PurchaseOrder"; + _tmp[@"Address::"] = @"Read136_Address"; + _tmp[@"OrderedItem::"] = @"Read137_OrderedItem"; + _tmp[@"AliasedTestType::"] = @"Read138_AliasedTestType"; + _tmp[@"BaseClass1::"] = @"Read139_BaseClass1"; + _tmp[@"DerivedClass1::"] = @"Read140_DerivedClass1"; + _tmp[@"MyCollection1::"] = @"Read141_ArrayOfDateTime"; + _tmp[@"Orchestra::"] = @"Read142_Orchestra"; + _tmp[@"Instrument::"] = @"Read143_Instrument"; + _tmp[@"Brass::"] = @"Read144_Brass"; + _tmp[@"Trumpet::"] = @"Read145_Trumpet"; + _tmp[@"Pet::"] = @"Read146_Pet"; + _tmp[@"DefaultValuesSetToNaN::"] = @"Read147_DefaultValuesSetToNaN"; + _tmp[@"DefaultValuesSetToPositiveInfinity::"] = @"Read148_Item"; + _tmp[@"DefaultValuesSetToNegativeInfinity::"] = @"Read149_Item"; + _tmp[@"TypeWithMismatchBetweenAttributeAndPropertyType::RootElement:True:"] = @"Read150_RootElement"; + _tmp[@"TypeWithLinkedProperty::"] = @"Read151_TypeWithLinkedProperty"; + _tmp[@"MsgDocumentType:http://example.com:Document:True:"] = @"Read152_Document"; + _tmp[@"RootClass::"] = @"Read153_RootClass"; + _tmp[@"Parameter::"] = @"Read154_Parameter"; + _tmp[@"XElementWrapper::"] = @"Read155_XElementWrapper"; + _tmp[@"XElementStruct::"] = @"Read156_XElementStruct"; + _tmp[@"XElementArrayWrapper::"] = @"Read157_XElementArrayWrapper"; + _tmp[@"SerializationTypes.TypeWithDateTimeStringProperty::"] = @"Read158_TypeWithDateTimeStringProperty"; + _tmp[@"SerializationTypes.SimpleType::"] = @"Read159_SimpleType"; + _tmp[@"SerializationTypes.TypeWithGetSetArrayMembers::"] = @"Read160_TypeWithGetSetArrayMembers"; + _tmp[@"SerializationTypes.TypeWithGetOnlyArrayProperties::"] = @"Read161_TypeWithGetOnlyArrayProperties"; + _tmp[@"SerializationTypes.StructNotSerializable::"] = @"Read162_StructNotSerializable"; + _tmp[@"SerializationTypes.TypeWithMyCollectionField::"] = @"Read163_TypeWithMyCollectionField"; + _tmp[@"SerializationTypes.TypeWithReadOnlyMyCollectionProperty::"] = @"Read164_Item"; + _tmp[@"SerializationTypes.MyList::"] = @"Read165_ArrayOfAnyType"; + _tmp[@"SerializationTypes.MyEnum::"] = @"Read166_MyEnum"; + _tmp[@"SerializationTypes.TypeWithEnumMembers::"] = @"Read167_TypeWithEnumMembers"; + _tmp[@"SerializationTypes.DCStruct::"] = @"Read168_DCStruct"; + _tmp[@"SerializationTypes.DCClassWithEnumAndStruct::"] = @"Read169_DCClassWithEnumAndStruct"; + _tmp[@"SerializationTypes.BuiltInTypes::"] = @"Read170_BuiltInTypes"; + _tmp[@"SerializationTypes.TypeA::"] = @"Read171_TypeA"; + _tmp[@"SerializationTypes.TypeB::"] = @"Read172_TypeB"; + _tmp[@"SerializationTypes.TypeHasArrayOfASerializedAsB::"] = @"Read173_TypeHasArrayOfASerializedAsB"; + _tmp[@"SerializationTypes.__TypeNameWithSpecialCharacters漢ñ::"] = @"Read174_Item"; + _tmp[@"SerializationTypes.BaseClassWithSamePropertyName::"] = @"Read175_BaseClassWithSamePropertyName"; + _tmp[@"SerializationTypes.DerivedClassWithSameProperty::"] = @"Read176_DerivedClassWithSameProperty"; + _tmp[@"SerializationTypes.DerivedClassWithSameProperty2::"] = @"Read177_DerivedClassWithSameProperty2"; + _tmp[@"SerializationTypes.TypeWithDateTimePropertyAsXmlTime::"] = @"Read178_Item"; + _tmp[@"SerializationTypes.TypeWithByteArrayAsXmlText::"] = @"Read179_TypeWithByteArrayAsXmlText"; + _tmp[@"SerializationTypes.SimpleDC::"] = @"Read180_SimpleDC"; + _tmp[@"SerializationTypes.TypeWithXmlTextAttributeOnArray:http://schemas.xmlsoap.org/ws/2005/04/discovery::False:"] = @"Read181_Item"; + _tmp[@"SerializationTypes.EnumFlags::"] = @"Read182_EnumFlags"; + _tmp[@"SerializationTypes.ClassImplementsInterface::"] = @"Read183_ClassImplementsInterface"; + _tmp[@"SerializationTypes.WithStruct::"] = @"Read184_WithStruct"; + _tmp[@"SerializationTypes.SomeStruct::"] = @"Read185_SomeStruct"; + _tmp[@"SerializationTypes.WithEnums::"] = @"Read186_WithEnums"; + _tmp[@"SerializationTypes.WithNullables::"] = @"Read187_WithNullables"; + _tmp[@"SerializationTypes.ByteEnum::"] = @"Read188_ByteEnum"; + _tmp[@"SerializationTypes.SByteEnum::"] = @"Read189_SByteEnum"; + _tmp[@"SerializationTypes.ShortEnum::"] = @"Read190_ShortEnum"; + _tmp[@"SerializationTypes.IntEnum::"] = @"Read191_IntEnum"; + _tmp[@"SerializationTypes.UIntEnum::"] = @"Read192_UIntEnum"; + _tmp[@"SerializationTypes.LongEnum::"] = @"Read193_LongEnum"; + _tmp[@"SerializationTypes.ULongEnum::"] = @"Read194_ULongEnum"; + _tmp[@"SerializationTypes.XmlSerializerAttributes::AttributeTesting:False:"] = @"Read195_AttributeTesting"; + _tmp[@"SerializationTypes.ItemChoiceType::"] = @"Read196_ItemChoiceType"; + _tmp[@"SerializationTypes.TypeWithAnyAttribute::"] = @"Read197_TypeWithAnyAttribute"; + _tmp[@"SerializationTypes.KnownTypesThroughConstructor::"] = @"Read198_KnownTypesThroughConstructor"; + _tmp[@"SerializationTypes.SimpleKnownTypeValue::"] = @"Read199_SimpleKnownTypeValue"; + _tmp[@"SerializationTypes.ClassImplementingIXmlSerializable::"] = @"Read200_Item"; + _tmp[@"SerializationTypes.TypeWithPropertyNameSpecified::"] = @"Read201_TypeWithPropertyNameSpecified"; + _tmp[@"SerializationTypes.TypeWithXmlSchemaFormAttribute:::True:"] = @"Read202_TypeWithXmlSchemaFormAttribute"; + _tmp[@"SerializationTypes.TypeWithTypeNameInXmlTypeAttribute::"] = @"Read203_MyXmlType"; + _tmp[@"SerializationTypes.TypeWithSchemaFormInXmlAttribute::"] = @"Read204_Item"; + _tmp[@"SerializationTypes.CustomDocument::"] = @"Read205_CustomDocument"; + _tmp[@"SerializationTypes.CustomElement::"] = @"Read206_CustomElement"; + _tmp[@"SerializationTypes.CustomAttribute::"] = @"Read207_Item"; + _tmp[@"SerializationTypes.TypeWithNonPublicDefaultConstructor::"] = @"Read208_Item"; + _tmp[@"SerializationTypes.ServerSettings::"] = @"Read209_ServerSettings"; + _tmp[@"SerializationTypes.TypeWithXmlQualifiedName::"] = @"Read210_TypeWithXmlQualifiedName"; + _tmp[@"SerializationTypes.TypeWith2DArrayProperty2::"] = @"Read211_TypeWith2DArrayProperty2"; + _tmp[@"SerializationTypes.TypeWithPropertiesHavingDefaultValue::"] = @"Read212_Item"; + _tmp[@"SerializationTypes.TypeWithEnumPropertyHavingDefaultValue::"] = @"Read213_Item"; + _tmp[@"SerializationTypes.TypeWithEnumFlagPropertyHavingDefaultValue::"] = @"Read214_Item"; + _tmp[@"SerializationTypes.TypeWithShouldSerializeMethod::"] = @"Read215_TypeWithShouldSerializeMethod"; + _tmp[@"SerializationTypes.KnownTypesThroughConstructorWithArrayProperties::"] = @"Read216_Item"; + _tmp[@"SerializationTypes.KnownTypesThroughConstructorWithValue::"] = @"Read217_Item"; + _tmp[@"SerializationTypes.TypeWithTypesHavingCustomFormatter::"] = @"Read218_Item"; + _tmp[@"SerializationTypes.TypeWithArrayPropertyHavingChoice::"] = @"Read219_Item"; + _tmp[@"SerializationTypes.MoreChoices::"] = @"Read220_MoreChoices"; + _tmp[@"SerializationTypes.TypeWithFieldsOrdered::"] = @"Read221_TypeWithFieldsOrdered"; + _tmp[@"SerializationTypes.TypeWithKnownTypesOfCollectionsWithConflictingXmlName::"] = @"Read222_Item"; + _tmp[@"SerializationTypes.NamespaceTypeNameClashContainer::Root:True:"] = @"Read223_Root"; + _tmp[@"SerializationTypes.TypeNameClashB.TypeNameClash::"] = @"Read224_TypeClashB"; + _tmp[@"SerializationTypes.TypeNameClashA.TypeNameClash::"] = @"Read225_TypeClashA"; + _tmp[@"Outer+Person::"] = @"Read226_Person"; if (readMethods == null) readMethods = _tmp; } return readMethods; @@ -15683,111 +16378,118 @@ public override System.Collections.Hashtable WriteMethods { get { if (writeMethods == null) { System.Collections.Hashtable _tmp = new System.Collections.Hashtable(); - _tmp[@"TypeWithXmlElementProperty::"] = @"Write107_TypeWithXmlElementProperty"; - _tmp[@"TypeWithXmlDocumentProperty::"] = @"Write108_TypeWithXmlDocumentProperty"; - _tmp[@"TypeWithBinaryProperty::"] = @"Write109_TypeWithBinaryProperty"; - _tmp[@"TypeWithDateTimeOffsetProperties::"] = @"Write110_Item"; - _tmp[@"TypeWithTimeSpanProperty::"] = @"Write111_TypeWithTimeSpanProperty"; - _tmp[@"TypeWithDefaultTimeSpanProperty::"] = @"Write112_Item"; - _tmp[@"TypeWithByteProperty::"] = @"Write113_TypeWithByteProperty"; - _tmp[@"TypeWithXmlNodeArrayProperty:::True:"] = @"Write114_TypeWithXmlNodeArrayProperty"; - _tmp[@"Animal::"] = @"Write115_Animal"; - _tmp[@"Dog::"] = @"Write116_Dog"; - _tmp[@"DogBreed::"] = @"Write117_DogBreed"; - _tmp[@"Group::"] = @"Write118_Group"; - _tmp[@"Vehicle::"] = @"Write119_Vehicle"; - _tmp[@"Employee::"] = @"Write120_Employee"; - _tmp[@"BaseClass::"] = @"Write121_BaseClass"; - _tmp[@"DerivedClass::"] = @"Write122_DerivedClass"; - _tmp[@"PurchaseOrder:http://www.contoso1.com:PurchaseOrder:False:"] = @"Write123_PurchaseOrder"; - _tmp[@"Address::"] = @"Write124_Address"; - _tmp[@"OrderedItem::"] = @"Write125_OrderedItem"; - _tmp[@"AliasedTestType::"] = @"Write126_AliasedTestType"; - _tmp[@"BaseClass1::"] = @"Write127_BaseClass1"; - _tmp[@"DerivedClass1::"] = @"Write128_DerivedClass1"; - _tmp[@"MyCollection1::"] = @"Write129_ArrayOfDateTime"; - _tmp[@"Orchestra::"] = @"Write130_Orchestra"; - _tmp[@"Instrument::"] = @"Write131_Instrument"; - _tmp[@"Brass::"] = @"Write132_Brass"; - _tmp[@"Trumpet::"] = @"Write133_Trumpet"; - _tmp[@"Pet::"] = @"Write134_Pet"; - _tmp[@"DefaultValuesSetToNaN::"] = @"Write135_DefaultValuesSetToNaN"; - _tmp[@"DefaultValuesSetToPositiveInfinity::"] = @"Write136_Item"; - _tmp[@"DefaultValuesSetToNegativeInfinity::"] = @"Write137_Item"; - _tmp[@"TypeWithMismatchBetweenAttributeAndPropertyType::RootElement:True:"] = @"Write138_RootElement"; - _tmp[@"TypeWithLinkedProperty::"] = @"Write139_TypeWithLinkedProperty"; - _tmp[@"MsgDocumentType:http://example.com:Document:True:"] = @"Write140_Document"; - _tmp[@"RootClass::"] = @"Write141_RootClass"; - _tmp[@"Parameter::"] = @"Write142_Parameter"; - _tmp[@"XElementWrapper::"] = @"Write143_XElementWrapper"; - _tmp[@"XElementStruct::"] = @"Write144_XElementStruct"; - _tmp[@"XElementArrayWrapper::"] = @"Write145_XElementArrayWrapper"; - _tmp[@"SerializationTypes.TypeWithDateTimeStringProperty::"] = @"Write146_TypeWithDateTimeStringProperty"; - _tmp[@"SerializationTypes.SimpleType::"] = @"Write147_SimpleType"; - _tmp[@"SerializationTypes.TypeWithGetSetArrayMembers::"] = @"Write148_TypeWithGetSetArrayMembers"; - _tmp[@"SerializationTypes.TypeWithGetOnlyArrayProperties::"] = @"Write149_TypeWithGetOnlyArrayProperties"; - _tmp[@"SerializationTypes.StructNotSerializable::"] = @"Write150_StructNotSerializable"; - _tmp[@"SerializationTypes.TypeWithMyCollectionField::"] = @"Write151_TypeWithMyCollectionField"; - _tmp[@"SerializationTypes.TypeWithReadOnlyMyCollectionProperty::"] = @"Write152_Item"; - _tmp[@"SerializationTypes.MyList::"] = @"Write153_ArrayOfAnyType"; - _tmp[@"SerializationTypes.MyEnum::"] = @"Write154_MyEnum"; - _tmp[@"SerializationTypes.TypeWithEnumMembers::"] = @"Write155_TypeWithEnumMembers"; - _tmp[@"SerializationTypes.DCStruct::"] = @"Write156_DCStruct"; - _tmp[@"SerializationTypes.DCClassWithEnumAndStruct::"] = @"Write157_DCClassWithEnumAndStruct"; - _tmp[@"SerializationTypes.BuiltInTypes::"] = @"Write158_BuiltInTypes"; - _tmp[@"SerializationTypes.TypeA::"] = @"Write159_TypeA"; - _tmp[@"SerializationTypes.TypeB::"] = @"Write160_TypeB"; - _tmp[@"SerializationTypes.TypeHasArrayOfASerializedAsB::"] = @"Write161_TypeHasArrayOfASerializedAsB"; - _tmp[@"SerializationTypes.__TypeNameWithSpecialCharacters漢ñ::"] = @"Write162_Item"; - _tmp[@"SerializationTypes.BaseClassWithSamePropertyName::"] = @"Write163_BaseClassWithSamePropertyName"; - _tmp[@"SerializationTypes.DerivedClassWithSameProperty::"] = @"Write164_DerivedClassWithSameProperty"; - _tmp[@"SerializationTypes.DerivedClassWithSameProperty2::"] = @"Write165_DerivedClassWithSameProperty2"; - _tmp[@"SerializationTypes.TypeWithDateTimePropertyAsXmlTime::"] = @"Write166_Item"; - _tmp[@"SerializationTypes.TypeWithByteArrayAsXmlText::"] = @"Write167_TypeWithByteArrayAsXmlText"; - _tmp[@"SerializationTypes.SimpleDC::"] = @"Write168_SimpleDC"; - _tmp[@"SerializationTypes.TypeWithXmlTextAttributeOnArray:http://schemas.xmlsoap.org/ws/2005/04/discovery::False:"] = @"Write169_Item"; - _tmp[@"SerializationTypes.EnumFlags::"] = @"Write170_EnumFlags"; - _tmp[@"SerializationTypes.ClassImplementsInterface::"] = @"Write171_ClassImplementsInterface"; - _tmp[@"SerializationTypes.WithStruct::"] = @"Write172_WithStruct"; - _tmp[@"SerializationTypes.SomeStruct::"] = @"Write173_SomeStruct"; - _tmp[@"SerializationTypes.WithEnums::"] = @"Write174_WithEnums"; - _tmp[@"SerializationTypes.WithNullables::"] = @"Write175_WithNullables"; - _tmp[@"SerializationTypes.ByteEnum::"] = @"Write176_ByteEnum"; - _tmp[@"SerializationTypes.SByteEnum::"] = @"Write177_SByteEnum"; - _tmp[@"SerializationTypes.ShortEnum::"] = @"Write178_ShortEnum"; - _tmp[@"SerializationTypes.IntEnum::"] = @"Write179_IntEnum"; - _tmp[@"SerializationTypes.UIntEnum::"] = @"Write180_UIntEnum"; - _tmp[@"SerializationTypes.LongEnum::"] = @"Write181_LongEnum"; - _tmp[@"SerializationTypes.ULongEnum::"] = @"Write182_ULongEnum"; - _tmp[@"SerializationTypes.XmlSerializerAttributes::AttributeTesting:False:"] = @"Write183_AttributeTesting"; - _tmp[@"SerializationTypes.ItemChoiceType::"] = @"Write184_ItemChoiceType"; - _tmp[@"SerializationTypes.TypeWithAnyAttribute::"] = @"Write185_TypeWithAnyAttribute"; - _tmp[@"SerializationTypes.KnownTypesThroughConstructor::"] = @"Write186_KnownTypesThroughConstructor"; - _tmp[@"SerializationTypes.SimpleKnownTypeValue::"] = @"Write187_SimpleKnownTypeValue"; - _tmp[@"SerializationTypes.ClassImplementingIXmlSerialiable::"] = @"Write188_Item"; - _tmp[@"SerializationTypes.TypeWithPropertyNameSpecified::"] = @"Write189_TypeWithPropertyNameSpecified"; - _tmp[@"SerializationTypes.TypeWithXmlSchemaFormAttribute:::True:"] = @"Write190_TypeWithXmlSchemaFormAttribute"; - _tmp[@"SerializationTypes.TypeWithTypeNameInXmlTypeAttribute::"] = @"Write191_MyXmlType"; - _tmp[@"SerializationTypes.TypeWithSchemaFormInXmlAttribute::"] = @"Write192_Item"; - _tmp[@"SerializationTypes.TypeWithNonPublicDefaultConstructor::"] = @"Write193_Item"; - _tmp[@"SerializationTypes.ServerSettings::"] = @"Write194_ServerSettings"; - _tmp[@"SerializationTypes.TypeWithXmlQualifiedName::"] = @"Write195_TypeWithXmlQualifiedName"; - _tmp[@"SerializationTypes.TypeWith2DArrayProperty2::"] = @"Write196_TypeWith2DArrayProperty2"; - _tmp[@"SerializationTypes.TypeWithPropertiesHavingDefaultValue::"] = @"Write197_Item"; - _tmp[@"SerializationTypes.TypeWithEnumPropertyHavingDefaultValue::"] = @"Write198_Item"; - _tmp[@"SerializationTypes.TypeWithEnumFlagPropertyHavingDefaultValue::"] = @"Write199_Item"; - _tmp[@"SerializationTypes.TypeWithShouldSerializeMethod::"] = @"Write200_TypeWithShouldSerializeMethod"; - _tmp[@"SerializationTypes.KnownTypesThroughConstructorWithArrayProperties::"] = @"Write201_Item"; - _tmp[@"SerializationTypes.KnownTypesThroughConstructorWithValue::"] = @"Write202_Item"; - _tmp[@"SerializationTypes.TypeWithTypesHavingCustomFormatter::"] = @"Write203_Item"; - _tmp[@"SerializationTypes.TypeWithArrayPropertyHavingChoice::"] = @"Write204_Item"; - _tmp[@"SerializationTypes.MoreChoices::"] = @"Write205_MoreChoices"; - _tmp[@"SerializationTypes.TypeWithFieldsOrdered::"] = @"Write206_TypeWithFieldsOrdered"; - _tmp[@"SerializationTypes.TypeWithKnownTypesOfCollectionsWithConflictingXmlName::"] = @"Write207_Item"; - _tmp[@"SerializationTypes.NamespaceTypeNameClashContainer::Root:True:"] = @"Write208_Root"; - _tmp[@"SerializationTypes.TypeNameClashB.TypeNameClash::"] = @"Write209_TypeClashB"; - _tmp[@"SerializationTypes.TypeNameClashA.TypeNameClash::"] = @"Write210_TypeClashA"; - _tmp[@"Outer+Person::"] = @"Write211_Person"; + _tmp[@"TypeWithXmlElementProperty::"] = @"Write111_TypeWithXmlElementProperty"; + _tmp[@"TypeWithXmlDocumentProperty::"] = @"Write112_TypeWithXmlDocumentProperty"; + _tmp[@"TypeWithBinaryProperty::"] = @"Write113_TypeWithBinaryProperty"; + _tmp[@"TypeWithDateTimeOffsetProperties::"] = @"Write114_Item"; + _tmp[@"TypeWithTimeSpanProperty::"] = @"Write115_TypeWithTimeSpanProperty"; + _tmp[@"TypeWithDefaultTimeSpanProperty::"] = @"Write116_Item"; + _tmp[@"TypeWithByteProperty::"] = @"Write117_TypeWithByteProperty"; + _tmp[@"TypeWithXmlNodeArrayProperty:::True:"] = @"Write118_TypeWithXmlNodeArrayProperty"; + _tmp[@"Animal::"] = @"Write119_Animal"; + _tmp[@"Dog::"] = @"Write120_Dog"; + _tmp[@"DogBreed::"] = @"Write121_DogBreed"; + _tmp[@"Group::"] = @"Write122_Group"; + _tmp[@"Vehicle::"] = @"Write123_Vehicle"; + _tmp[@"Employee::"] = @"Write124_Employee"; + _tmp[@"BaseClass::"] = @"Write125_BaseClass"; + _tmp[@"DerivedClass::"] = @"Write126_DerivedClass"; + _tmp[@"SimpleBaseClass::"] = @"Write127_SimpleBaseClass"; + _tmp[@"SimpleDerivedClass::"] = @"Write128_SimpleDerivedClass"; + _tmp[@"XmlSerializableBaseClass:http://example.com/serializer-test-namespace::True:"] = @"Write129_BaseIXmlSerializable"; + _tmp[@"XmlSerializableDerivedClass::"] = @"Write130_DerivedIXmlSerializable"; + _tmp[@"PurchaseOrder:http://www.contoso1.com:PurchaseOrder:False:"] = @"Write131_PurchaseOrder"; + _tmp[@"Address::"] = @"Write132_Address"; + _tmp[@"OrderedItem::"] = @"Write133_OrderedItem"; + _tmp[@"AliasedTestType::"] = @"Write134_AliasedTestType"; + _tmp[@"BaseClass1::"] = @"Write135_BaseClass1"; + _tmp[@"DerivedClass1::"] = @"Write136_DerivedClass1"; + _tmp[@"MyCollection1::"] = @"Write137_ArrayOfDateTime"; + _tmp[@"Orchestra::"] = @"Write138_Orchestra"; + _tmp[@"Instrument::"] = @"Write139_Instrument"; + _tmp[@"Brass::"] = @"Write140_Brass"; + _tmp[@"Trumpet::"] = @"Write141_Trumpet"; + _tmp[@"Pet::"] = @"Write142_Pet"; + _tmp[@"DefaultValuesSetToNaN::"] = @"Write143_DefaultValuesSetToNaN"; + _tmp[@"DefaultValuesSetToPositiveInfinity::"] = @"Write144_Item"; + _tmp[@"DefaultValuesSetToNegativeInfinity::"] = @"Write145_Item"; + _tmp[@"TypeWithMismatchBetweenAttributeAndPropertyType::RootElement:True:"] = @"Write146_RootElement"; + _tmp[@"TypeWithLinkedProperty::"] = @"Write147_TypeWithLinkedProperty"; + _tmp[@"MsgDocumentType:http://example.com:Document:True:"] = @"Write148_Document"; + _tmp[@"RootClass::"] = @"Write149_RootClass"; + _tmp[@"Parameter::"] = @"Write150_Parameter"; + _tmp[@"XElementWrapper::"] = @"Write151_XElementWrapper"; + _tmp[@"XElementStruct::"] = @"Write152_XElementStruct"; + _tmp[@"XElementArrayWrapper::"] = @"Write153_XElementArrayWrapper"; + _tmp[@"SerializationTypes.TypeWithDateTimeStringProperty::"] = @"Write154_TypeWithDateTimeStringProperty"; + _tmp[@"SerializationTypes.SimpleType::"] = @"Write155_SimpleType"; + _tmp[@"SerializationTypes.TypeWithGetSetArrayMembers::"] = @"Write156_TypeWithGetSetArrayMembers"; + _tmp[@"SerializationTypes.TypeWithGetOnlyArrayProperties::"] = @"Write157_TypeWithGetOnlyArrayProperties"; + _tmp[@"SerializationTypes.StructNotSerializable::"] = @"Write158_StructNotSerializable"; + _tmp[@"SerializationTypes.TypeWithMyCollectionField::"] = @"Write159_TypeWithMyCollectionField"; + _tmp[@"SerializationTypes.TypeWithReadOnlyMyCollectionProperty::"] = @"Write160_Item"; + _tmp[@"SerializationTypes.MyList::"] = @"Write161_ArrayOfAnyType"; + _tmp[@"SerializationTypes.MyEnum::"] = @"Write162_MyEnum"; + _tmp[@"SerializationTypes.TypeWithEnumMembers::"] = @"Write163_TypeWithEnumMembers"; + _tmp[@"SerializationTypes.DCStruct::"] = @"Write164_DCStruct"; + _tmp[@"SerializationTypes.DCClassWithEnumAndStruct::"] = @"Write165_DCClassWithEnumAndStruct"; + _tmp[@"SerializationTypes.BuiltInTypes::"] = @"Write166_BuiltInTypes"; + _tmp[@"SerializationTypes.TypeA::"] = @"Write167_TypeA"; + _tmp[@"SerializationTypes.TypeB::"] = @"Write168_TypeB"; + _tmp[@"SerializationTypes.TypeHasArrayOfASerializedAsB::"] = @"Write169_TypeHasArrayOfASerializedAsB"; + _tmp[@"SerializationTypes.__TypeNameWithSpecialCharacters漢ñ::"] = @"Write170_Item"; + _tmp[@"SerializationTypes.BaseClassWithSamePropertyName::"] = @"Write171_BaseClassWithSamePropertyName"; + _tmp[@"SerializationTypes.DerivedClassWithSameProperty::"] = @"Write172_DerivedClassWithSameProperty"; + _tmp[@"SerializationTypes.DerivedClassWithSameProperty2::"] = @"Write173_DerivedClassWithSameProperty2"; + _tmp[@"SerializationTypes.TypeWithDateTimePropertyAsXmlTime::"] = @"Write174_Item"; + _tmp[@"SerializationTypes.TypeWithByteArrayAsXmlText::"] = @"Write175_TypeWithByteArrayAsXmlText"; + _tmp[@"SerializationTypes.SimpleDC::"] = @"Write176_SimpleDC"; + _tmp[@"SerializationTypes.TypeWithXmlTextAttributeOnArray:http://schemas.xmlsoap.org/ws/2005/04/discovery::False:"] = @"Write177_Item"; + _tmp[@"SerializationTypes.EnumFlags::"] = @"Write178_EnumFlags"; + _tmp[@"SerializationTypes.ClassImplementsInterface::"] = @"Write179_ClassImplementsInterface"; + _tmp[@"SerializationTypes.WithStruct::"] = @"Write180_WithStruct"; + _tmp[@"SerializationTypes.SomeStruct::"] = @"Write181_SomeStruct"; + _tmp[@"SerializationTypes.WithEnums::"] = @"Write182_WithEnums"; + _tmp[@"SerializationTypes.WithNullables::"] = @"Write183_WithNullables"; + _tmp[@"SerializationTypes.ByteEnum::"] = @"Write184_ByteEnum"; + _tmp[@"SerializationTypes.SByteEnum::"] = @"Write185_SByteEnum"; + _tmp[@"SerializationTypes.ShortEnum::"] = @"Write186_ShortEnum"; + _tmp[@"SerializationTypes.IntEnum::"] = @"Write187_IntEnum"; + _tmp[@"SerializationTypes.UIntEnum::"] = @"Write188_UIntEnum"; + _tmp[@"SerializationTypes.LongEnum::"] = @"Write189_LongEnum"; + _tmp[@"SerializationTypes.ULongEnum::"] = @"Write190_ULongEnum"; + _tmp[@"SerializationTypes.XmlSerializerAttributes::AttributeTesting:False:"] = @"Write191_AttributeTesting"; + _tmp[@"SerializationTypes.ItemChoiceType::"] = @"Write192_ItemChoiceType"; + _tmp[@"SerializationTypes.TypeWithAnyAttribute::"] = @"Write193_TypeWithAnyAttribute"; + _tmp[@"SerializationTypes.KnownTypesThroughConstructor::"] = @"Write194_KnownTypesThroughConstructor"; + _tmp[@"SerializationTypes.SimpleKnownTypeValue::"] = @"Write195_SimpleKnownTypeValue"; + _tmp[@"SerializationTypes.ClassImplementingIXmlSerializable::"] = @"Write196_Item"; + _tmp[@"SerializationTypes.TypeWithPropertyNameSpecified::"] = @"Write197_TypeWithPropertyNameSpecified"; + _tmp[@"SerializationTypes.TypeWithXmlSchemaFormAttribute:::True:"] = @"Write198_TypeWithXmlSchemaFormAttribute"; + _tmp[@"SerializationTypes.TypeWithTypeNameInXmlTypeAttribute::"] = @"Write199_MyXmlType"; + _tmp[@"SerializationTypes.TypeWithSchemaFormInXmlAttribute::"] = @"Write200_Item"; + _tmp[@"SerializationTypes.CustomDocument::"] = @"Write201_CustomDocument"; + _tmp[@"SerializationTypes.CustomElement::"] = @"Write202_CustomElement"; + _tmp[@"SerializationTypes.CustomAttribute::"] = @"Write203_Item"; + _tmp[@"SerializationTypes.TypeWithNonPublicDefaultConstructor::"] = @"Write204_Item"; + _tmp[@"SerializationTypes.ServerSettings::"] = @"Write205_ServerSettings"; + _tmp[@"SerializationTypes.TypeWithXmlQualifiedName::"] = @"Write206_TypeWithXmlQualifiedName"; + _tmp[@"SerializationTypes.TypeWith2DArrayProperty2::"] = @"Write207_TypeWith2DArrayProperty2"; + _tmp[@"SerializationTypes.TypeWithPropertiesHavingDefaultValue::"] = @"Write208_Item"; + _tmp[@"SerializationTypes.TypeWithEnumPropertyHavingDefaultValue::"] = @"Write209_Item"; + _tmp[@"SerializationTypes.TypeWithEnumFlagPropertyHavingDefaultValue::"] = @"Write210_Item"; + _tmp[@"SerializationTypes.TypeWithShouldSerializeMethod::"] = @"Write211_TypeWithShouldSerializeMethod"; + _tmp[@"SerializationTypes.KnownTypesThroughConstructorWithArrayProperties::"] = @"Write212_Item"; + _tmp[@"SerializationTypes.KnownTypesThroughConstructorWithValue::"] = @"Write213_Item"; + _tmp[@"SerializationTypes.TypeWithTypesHavingCustomFormatter::"] = @"Write214_Item"; + _tmp[@"SerializationTypes.TypeWithArrayPropertyHavingChoice::"] = @"Write215_Item"; + _tmp[@"SerializationTypes.MoreChoices::"] = @"Write216_MoreChoices"; + _tmp[@"SerializationTypes.TypeWithFieldsOrdered::"] = @"Write217_TypeWithFieldsOrdered"; + _tmp[@"SerializationTypes.TypeWithKnownTypesOfCollectionsWithConflictingXmlName::"] = @"Write218_Item"; + _tmp[@"SerializationTypes.NamespaceTypeNameClashContainer::Root:True:"] = @"Write219_Root"; + _tmp[@"SerializationTypes.TypeNameClashB.TypeNameClash::"] = @"Write220_TypeClashB"; + _tmp[@"SerializationTypes.TypeNameClashA.TypeNameClash::"] = @"Write221_TypeClashA"; + _tmp[@"Outer+Person::"] = @"Write222_Person"; if (writeMethods == null) writeMethods = _tmp; } return writeMethods; @@ -15798,111 +16500,118 @@ public override System.Collections.Hashtable TypedSerializers { get { if (typedSerializers == null) { System.Collections.Hashtable _tmp = new System.Collections.Hashtable(); - _tmp.Add(@"XElementArrayWrapper::", new XElementArrayWrapperSerializer()); - _tmp.Add(@"TypeWithDefaultTimeSpanProperty::", new TypeWithDefaultTimeSpanPropertySerializer()); - _tmp.Add(@"SerializationTypes.ClassImplementsInterface::", new ClassImplementsInterfaceSerializer()); - _tmp.Add(@"MsgDocumentType:http://example.com:Document:True:", new MsgDocumentTypeSerializer()); - _tmp.Add(@"SerializationTypes.TypeWithEnumMembers::", new TypeWithEnumMembersSerializer()); - _tmp.Add(@"SerializationTypes.TypeWithDateTimePropertyAsXmlTime::", new TypeWithDateTimePropertyAsXmlTimeSerializer()); - _tmp.Add(@"SerializationTypes.TypeWithKnownTypesOfCollectionsWithConflictingXmlName::", new TypeWithKnownTypesOfCollectionsWithConflictingXmlNameSerializer()); - _tmp.Add(@"Vehicle::", new VehicleSerializer()); - _tmp.Add(@"TypeWithByteProperty::", new TypeWithBytePropertySerializer()); - _tmp.Add(@"SerializationTypes.ItemChoiceType::", new ItemChoiceTypeSerializer()); - _tmp.Add(@"SerializationTypes.ServerSettings::", new ServerSettingsSerializer()); - _tmp.Add(@"Address::", new AddressSerializer()); _tmp.Add(@"DerivedClass::", new DerivedClassSerializer()); - _tmp.Add(@"SerializationTypes.TypeWithMyCollectionField::", new TypeWithMyCollectionFieldSerializer()); - _tmp.Add(@"Brass::", new BrassSerializer()); - _tmp.Add(@"SerializationTypes.ClassImplementingIXmlSerialiable::", new ClassImplementingIXmlSerialiableSerializer()); - _tmp.Add(@"SerializationTypes.TypeWithNonPublicDefaultConstructor::", new TypeWithNonPublicDefaultConstructorSerializer()); + _tmp.Add(@"XElementStruct::", new XElementStructSerializer()); + _tmp.Add(@"Orchestra::", new OrchestraSerializer()); + _tmp.Add(@"SerializationTypes.KnownTypesThroughConstructorWithArrayProperties::", new KnownTypesThroughConstructorWithArrayPropertiesSerializer()); + _tmp.Add(@"DefaultValuesSetToNaN::", new DefaultValuesSetToNaNSerializer()); + _tmp.Add(@"SerializationTypes.CustomAttribute::", new CustomAttributeSerializer()); _tmp.Add(@"SerializationTypes.WithEnums::", new WithEnumsSerializer()); - _tmp.Add(@"SerializationTypes.MoreChoices::", new MoreChoicesSerializer()); - _tmp.Add(@"AliasedTestType::", new AliasedTestTypeSerializer()); + _tmp.Add(@"SerializationTypes.TypeWithGetOnlyArrayProperties::", new TypeWithGetOnlyArrayPropertiesSerializer()); + _tmp.Add(@"SerializationTypes.TypeWithKnownTypesOfCollectionsWithConflictingXmlName::", new TypeWithKnownTypesOfCollectionsWithConflictingXmlNameSerializer()); + _tmp.Add(@"XmlSerializableBaseClass:http://example.com/serializer-test-namespace::True:", new XmlSerializableBaseClassSerializer()); + _tmp.Add(@"SerializationTypes.KnownTypesThroughConstructorWithValue::", new KnownTypesThroughConstructorWithValueSerializer()); + _tmp.Add(@"SerializationTypes.ItemChoiceType::", new ItemChoiceTypeSerializer()); + _tmp.Add(@"TypeWithDateTimeOffsetProperties::", new TypeWithDateTimeOffsetPropertiesSerializer()); _tmp.Add(@"TypeWithXmlElementProperty::", new TypeWithXmlElementPropertySerializer()); - _tmp.Add(@"SerializationTypes.TypeWith2DArrayProperty2::", new TypeWith2DArrayProperty2Serializer()); - _tmp.Add(@"SerializationTypes.XmlSerializerAttributes::AttributeTesting:False:", new XmlSerializerAttributesSerializer()); - _tmp.Add(@"SerializationTypes.ULongEnum::", new ULongEnumSerializer()); - _tmp.Add(@"SerializationTypes.KnownTypesThroughConstructorWithArrayProperties::", new KnownTypesThroughConstructorWithArrayPropertiesSerializer()); - _tmp.Add(@"Pet::", new PetSerializer()); - _tmp.Add(@"TypeWithMismatchBetweenAttributeAndPropertyType::RootElement:True:", new TypeWithMismatchBetweenAttributeAndPropertyTypeSerializer()); - _tmp.Add(@"Instrument::", new InstrumentSerializer()); + _tmp.Add(@"SerializationTypes.TypeWithByteArrayAsXmlText::", new TypeWithByteArrayAsXmlTextSerializer()); + _tmp.Add(@"Vehicle::", new VehicleSerializer()); + _tmp.Add(@"SerializationTypes.TypeWithXmlTextAttributeOnArray:http://schemas.xmlsoap.org/ws/2005/04/discovery::False:", new TypeWithXmlTextAttributeOnArraySerializer()); _tmp.Add(@"SerializationTypes.__TypeNameWithSpecialCharacters漢ñ::", new __TypeNameWithSpecialCharacters漢ñSerializer()); - _tmp.Add(@"Outer+Person::", new PersonSerializer()); - _tmp.Add(@"TypeWithBinaryProperty::", new TypeWithBinaryPropertySerializer()); - _tmp.Add(@"SerializationTypes.TypeWithPropertyNameSpecified::", new TypeWithPropertyNameSpecifiedSerializer()); + _tmp.Add(@"SerializationTypes.WithStruct::", new WithStructSerializer()); _tmp.Add(@"SerializationTypes.SimpleKnownTypeValue::", new SimpleKnownTypeValueSerializer()); - _tmp.Add(@"SerializationTypes.TypeWithXmlQualifiedName::", new TypeWithXmlQualifiedNameSerializer()); - _tmp.Add(@"TypeWithDateTimeOffsetProperties::", new TypeWithDateTimeOffsetPropertiesSerializer()); - _tmp.Add(@"MyCollection1::", new MyCollection1Serializer()); - _tmp.Add(@"SerializationTypes.TypeWithSchemaFormInXmlAttribute::", new TypeWithSchemaFormInXmlAttributeSerializer()); - _tmp.Add(@"DefaultValuesSetToPositiveInfinity::", new DefaultValuesSetToPositiveInfinitySerializer()); - _tmp.Add(@"TypeWithTimeSpanProperty::", new TypeWithTimeSpanPropertySerializer()); + _tmp.Add(@"SerializationTypes.TypeWithEnumPropertyHavingDefaultValue::", new TypeWithEnumPropertyHavingDefaultValueSerializer()); + _tmp.Add(@"SimpleBaseClass::", new SimpleBaseClassSerializer()); + _tmp.Add(@"SerializationTypes.ShortEnum::", new ShortEnumSerializer()); + _tmp.Add(@"BaseClass1::", new BaseClass1Serializer()); + _tmp.Add(@"XElementArrayWrapper::", new XElementArrayWrapperSerializer()); + _tmp.Add(@"Instrument::", new InstrumentSerializer()); _tmp.Add(@"DerivedClass1::", new DerivedClass1Serializer()); - _tmp.Add(@"SerializationTypes.UIntEnum::", new UIntEnumSerializer()); - _tmp.Add(@"BaseClass::", new BaseClassSerializer()); - _tmp.Add(@"PurchaseOrder:http://www.contoso1.com:PurchaseOrder:False:", new PurchaseOrderSerializer()); + _tmp.Add(@"SerializationTypes.TypeWithMyCollectionField::", new TypeWithMyCollectionFieldSerializer()); + _tmp.Add(@"SerializationTypes.TypeWithSchemaFormInXmlAttribute::", new TypeWithSchemaFormInXmlAttributeSerializer()); + _tmp.Add(@"SerializationTypes.CustomDocument::", new CustomDocumentSerializer()); + _tmp.Add(@"SerializationTypes.NamespaceTypeNameClashContainer::Root:True:", new NamespaceTypeNameClashContainerSerializer()); _tmp.Add(@"SerializationTypes.TypeWithReadOnlyMyCollectionProperty::", new TypeWithReadOnlyMyCollectionPropertySerializer()); + _tmp.Add(@"SerializationTypes.ULongEnum::", new ULongEnumSerializer()); _tmp.Add(@"SerializationTypes.TypeA::", new TypeASerializer()); - _tmp.Add(@"Trumpet::", new TrumpetSerializer()); - _tmp.Add(@"SerializationTypes.BaseClassWithSamePropertyName::", new BaseClassWithSamePropertyNameSerializer()); - _tmp.Add(@"BaseClass1::", new BaseClass1Serializer()); - _tmp.Add(@"SerializationTypes.ShortEnum::", new ShortEnumSerializer()); - _tmp.Add(@"SerializationTypes.TypeWithTypeNameInXmlTypeAttribute::", new TypeWithTypeNameInXmlTypeAttributeSerializer()); - _tmp.Add(@"SerializationTypes.WithStruct::", new WithStructSerializer()); - _tmp.Add(@"Group::", new GroupSerializer()); - _tmp.Add(@"SerializationTypes.TypeWithGetSetArrayMembers::", new TypeWithGetSetArrayMembersSerializer()); - _tmp.Add(@"Animal::", new AnimalSerializer()); - _tmp.Add(@"OrderedItem::", new OrderedItemSerializer()); - _tmp.Add(@"SerializationTypes.IntEnum::", new IntEnumSerializer()); - _tmp.Add(@"TypeWithLinkedProperty::", new TypeWithLinkedPropertySerializer()); - _tmp.Add(@"SerializationTypes.TypeWithByteArrayAsXmlText::", new TypeWithByteArrayAsXmlTextSerializer()); + _tmp.Add(@"SerializationTypes.SByteEnum::", new SByteEnumSerializer()); + _tmp.Add(@"SerializationTypes.DCClassWithEnumAndStruct::", new DCClassWithEnumAndStructSerializer()); + _tmp.Add(@"SerializationTypes.KnownTypesThroughConstructor::", new KnownTypesThroughConstructorSerializer()); _tmp.Add(@"SerializationTypes.TypeNameClashA.TypeNameClash::", new TypeNameClashSerializer1()); - _tmp.Add(@"TypeWithXmlDocumentProperty::", new TypeWithXmlDocumentPropertySerializer()); - _tmp.Add(@"Employee::", new EmployeeSerializer()); - _tmp.Add(@"SerializationTypes.TypeWithDateTimeStringProperty::", new TypeWithDateTimeStringPropertySerializer()); - _tmp.Add(@"XElementStruct::", new XElementStructSerializer()); - _tmp.Add(@"SerializationTypes.SomeStruct::", new SomeStructSerializer()); - _tmp.Add(@"SerializationTypes.TypeWithAnyAttribute::", new TypeWithAnyAttributeSerializer()); - _tmp.Add(@"SerializationTypes.TypeWithXmlSchemaFormAttribute:::True:", new TypeWithXmlSchemaFormAttributeSerializer()); - _tmp.Add(@"SerializationTypes.TypeB::", new TypeBSerializer()); - _tmp.Add(@"SerializationTypes.SimpleType::", new SimpleTypeSerializer()); - _tmp.Add(@"SerializationTypes.MyList::", new MyListSerializer()); + _tmp.Add(@"BaseClass::", new BaseClassSerializer()); _tmp.Add(@"SerializationTypes.SimpleDC::", new SimpleDCSerializer()); - _tmp.Add(@"SerializationTypes.TypeWithTypesHavingCustomFormatter::", new TypeWithTypesHavingCustomFormatterSerializer()); - _tmp.Add(@"SerializationTypes.MyEnum::", new MyEnumSerializer()); - _tmp.Add(@"SerializationTypes.TypeWithGetOnlyArrayProperties::", new TypeWithGetOnlyArrayPropertiesSerializer()); _tmp.Add(@"SerializationTypes.StructNotSerializable::", new StructNotSerializableSerializer()); - _tmp.Add(@"SerializationTypes.NamespaceTypeNameClashContainer::Root:True:", new NamespaceTypeNameClashContainerSerializer()); + _tmp.Add(@"SerializationTypes.TypeWithDateTimePropertyAsXmlTime::", new TypeWithDateTimePropertyAsXmlTimeSerializer()); + _tmp.Add(@"MsgDocumentType:http://example.com:Document:True:", new MsgDocumentTypeSerializer()); + _tmp.Add(@"SerializationTypes.TypeWithXmlSchemaFormAttribute:::True:", new TypeWithXmlSchemaFormAttributeSerializer()); + _tmp.Add(@"SerializationTypes.TypeNameClashB.TypeNameClash::", new TypeNameClashSerializer()); + _tmp.Add(@"SerializationTypes.TypeWithDateTimeStringProperty::", new TypeWithDateTimeStringPropertySerializer()); + _tmp.Add(@"OrderedItem::", new OrderedItemSerializer()); + _tmp.Add(@"XElementWrapper::", new XElementWrapperSerializer()); + _tmp.Add(@"TypeWithLinkedProperty::", new TypeWithLinkedPropertySerializer()); + _tmp.Add(@"Pet::", new PetSerializer()); + _tmp.Add(@"SerializationTypes.TypeB::", new TypeBSerializer()); + _tmp.Add(@"XmlSerializableDerivedClass::", new XmlSerializableDerivedClassSerializer()); _tmp.Add(@"SerializationTypes.BuiltInTypes::", new BuiltInTypesSerializer()); + _tmp.Add(@"DefaultValuesSetToNegativeInfinity::", new DefaultValuesSetToNegativeInfinitySerializer()); + _tmp.Add(@"SerializationTypes.EnumFlags::", new EnumFlagsSerializer()); + _tmp.Add(@"TypeWithBinaryProperty::", new TypeWithBinaryPropertySerializer()); + _tmp.Add(@"SerializationTypes.TypeWithNonPublicDefaultConstructor::", new TypeWithNonPublicDefaultConstructorSerializer()); + _tmp.Add(@"DefaultValuesSetToPositiveInfinity::", new DefaultValuesSetToPositiveInfinitySerializer()); + _tmp.Add(@"Trumpet::", new TrumpetSerializer()); + _tmp.Add(@"SerializationTypes.ClassImplementingIXmlSerializable::", new ClassImplementingIXmlSerializableSerializer()); + _tmp.Add(@"SerializationTypes.BaseClassWithSamePropertyName::", new BaseClassWithSamePropertyNameSerializer()); _tmp.Add(@"RootClass::", new RootClassSerializer()); - _tmp.Add(@"SerializationTypes.SByteEnum::", new SByteEnumSerializer()); - _tmp.Add(@"XElementWrapper::", new XElementWrapperSerializer()); - _tmp.Add(@"SerializationTypes.DCStruct::", new DCStructSerializer()); - _tmp.Add(@"SerializationTypes.TypeWithXmlTextAttributeOnArray:http://schemas.xmlsoap.org/ws/2005/04/discovery::False:", new TypeWithXmlTextAttributeOnArraySerializer()); - _tmp.Add(@"SerializationTypes.KnownTypesThroughConstructor::", new KnownTypesThroughConstructorSerializer()); + _tmp.Add(@"SerializationTypes.TypeWithXmlQualifiedName::", new TypeWithXmlQualifiedNameSerializer()); + _tmp.Add(@"SerializationTypes.TypeWithTypeNameInXmlTypeAttribute::", new TypeWithTypeNameInXmlTypeAttributeSerializer()); + _tmp.Add(@"SerializationTypes.WithNullables::", new WithNullablesSerializer()); + _tmp.Add(@"Animal::", new AnimalSerializer()); + _tmp.Add(@"SerializationTypes.SomeStruct::", new SomeStructSerializer()); + _tmp.Add(@"Parameter::", new ParameterSerializer()); + _tmp.Add(@"TypeWithMismatchBetweenAttributeAndPropertyType::RootElement:True:", new TypeWithMismatchBetweenAttributeAndPropertyTypeSerializer()); _tmp.Add(@"SerializationTypes.DerivedClassWithSameProperty::", new DerivedClassWithSamePropertySerializer()); - _tmp.Add(@"SerializationTypes.DCClassWithEnumAndStruct::", new DCClassWithEnumAndStructSerializer()); _tmp.Add(@"DogBreed::", new DogBreedSerializer()); - _tmp.Add(@"SerializationTypes.DerivedClassWithSameProperty2::", new DerivedClassWithSameProperty2Serializer()); - _tmp.Add(@"SerializationTypes.TypeWithFieldsOrdered::", new TypeWithFieldsOrderedSerializer()); - _tmp.Add(@"DefaultValuesSetToNegativeInfinity::", new DefaultValuesSetToNegativeInfinitySerializer()); - _tmp.Add(@"Dog::", new DogSerializer()); + _tmp.Add(@"SerializationTypes.TypeWithPropertiesHavingDefaultValue::", new TypeWithPropertiesHavingDefaultValueSerializer()); + _tmp.Add(@"SerializationTypes.TypeWithAnyAttribute::", new TypeWithAnyAttributeSerializer()); + _tmp.Add(@"Employee::", new EmployeeSerializer()); + _tmp.Add(@"Outer+Person::", new PersonSerializer()); + _tmp.Add(@"SimpleDerivedClass::", new SimpleDerivedClassSerializer()); _tmp.Add(@"TypeWithXmlNodeArrayProperty:::True:", new TypeWithXmlNodeArrayPropertySerializer()); - _tmp.Add(@"SerializationTypes.TypeWithEnumPropertyHavingDefaultValue::", new TypeWithEnumPropertyHavingDefaultValueSerializer()); + _tmp.Add(@"AliasedTestType::", new AliasedTestTypeSerializer()); _tmp.Add(@"SerializationTypes.TypeWithEnumFlagPropertyHavingDefaultValue::", new TypeWithEnumFlagPropertyHavingDefaultValueSerializer()); - _tmp.Add(@"SerializationTypes.WithNullables::", new WithNullablesSerializer()); - _tmp.Add(@"SerializationTypes.TypeNameClashB.TypeNameClash::", new TypeNameClashSerializer()); - _tmp.Add(@"SerializationTypes.ByteEnum::", new ByteEnumSerializer()); - _tmp.Add(@"DefaultValuesSetToNaN::", new DefaultValuesSetToNaNSerializer()); - _tmp.Add(@"Orchestra::", new OrchestraSerializer()); - _tmp.Add(@"SerializationTypes.TypeWithArrayPropertyHavingChoice::", new TypeWithArrayPropertyHavingChoiceSerializer()); - _tmp.Add(@"Parameter::", new ParameterSerializer()); - _tmp.Add(@"SerializationTypes.EnumFlags::", new EnumFlagsSerializer()); - _tmp.Add(@"SerializationTypes.KnownTypesThroughConstructorWithValue::", new KnownTypesThroughConstructorWithValueSerializer()); - _tmp.Add(@"SerializationTypes.TypeWithPropertiesHavingDefaultValue::", new TypeWithPropertiesHavingDefaultValueSerializer()); + _tmp.Add(@"SerializationTypes.SimpleType::", new SimpleTypeSerializer()); _tmp.Add(@"SerializationTypes.LongEnum::", new LongEnumSerializer()); - _tmp.Add(@"SerializationTypes.TypeWithShouldSerializeMethod::", new TypeWithShouldSerializeMethodSerializer()); + _tmp.Add(@"MyCollection1::", new MyCollection1Serializer()); + _tmp.Add(@"TypeWithByteProperty::", new TypeWithBytePropertySerializer()); + _tmp.Add(@"SerializationTypes.ServerSettings::", new ServerSettingsSerializer()); + _tmp.Add(@"SerializationTypes.TypeWithArrayPropertyHavingChoice::", new TypeWithArrayPropertyHavingChoiceSerializer()); + _tmp.Add(@"SerializationTypes.TypeWith2DArrayProperty2::", new TypeWith2DArrayProperty2Serializer()); + _tmp.Add(@"SerializationTypes.ByteEnum::", new ByteEnumSerializer()); + _tmp.Add(@"Group::", new GroupSerializer()); + _tmp.Add(@"SerializationTypes.TypeWithGetSetArrayMembers::", new TypeWithGetSetArrayMembersSerializer()); + _tmp.Add(@"SerializationTypes.MyEnum::", new MyEnumSerializer()); + _tmp.Add(@"Dog::", new DogSerializer()); _tmp.Add(@"SerializationTypes.TypeHasArrayOfASerializedAsB::", new TypeHasArrayOfASerializedAsBSerializer()); + _tmp.Add(@"SerializationTypes.DerivedClassWithSameProperty2::", new DerivedClassWithSameProperty2Serializer()); + _tmp.Add(@"TypeWithXmlDocumentProperty::", new TypeWithXmlDocumentPropertySerializer()); + _tmp.Add(@"SerializationTypes.ClassImplementsInterface::", new ClassImplementsInterfaceSerializer()); + _tmp.Add(@"Address::", new AddressSerializer()); + _tmp.Add(@"SerializationTypes.TypeWithEnumMembers::", new TypeWithEnumMembersSerializer()); + _tmp.Add(@"SerializationTypes.TypeWithShouldSerializeMethod::", new TypeWithShouldSerializeMethodSerializer()); + _tmp.Add(@"SerializationTypes.MoreChoices::", new MoreChoicesSerializer()); + _tmp.Add(@"SerializationTypes.XmlSerializerAttributes::AttributeTesting:False:", new XmlSerializerAttributesSerializer()); + _tmp.Add(@"SerializationTypes.TypeWithPropertyNameSpecified::", new TypeWithPropertyNameSpecifiedSerializer()); + _tmp.Add(@"SerializationTypes.UIntEnum::", new UIntEnumSerializer()); + _tmp.Add(@"TypeWithTimeSpanProperty::", new TypeWithTimeSpanPropertySerializer()); + _tmp.Add(@"SerializationTypes.MyList::", new MyListSerializer()); + _tmp.Add(@"Brass::", new BrassSerializer()); + _tmp.Add(@"SerializationTypes.CustomElement::", new CustomElementSerializer()); + _tmp.Add(@"SerializationTypes.TypeWithTypesHavingCustomFormatter::", new TypeWithTypesHavingCustomFormatterSerializer()); + _tmp.Add(@"SerializationTypes.TypeWithFieldsOrdered::", new TypeWithFieldsOrderedSerializer()); + _tmp.Add(@"PurchaseOrder:http://www.contoso1.com:PurchaseOrder:False:", new PurchaseOrderSerializer()); + _tmp.Add(@"SerializationTypes.IntEnum::", new IntEnumSerializer()); + _tmp.Add(@"SerializationTypes.DCStruct::", new DCStructSerializer()); + _tmp.Add(@"TypeWithDefaultTimeSpanProperty::", new TypeWithDefaultTimeSpanPropertySerializer()); if (typedSerializers == null) typedSerializers = _tmp; } return typedSerializers; @@ -15925,6 +16634,10 @@ public override System.Boolean CanSerialize(System.Type type) { if (type == typeof(global::Employee)) return true; if (type == typeof(global::BaseClass)) return true; if (type == typeof(global::DerivedClass)) return true; + if (type == typeof(global::SimpleBaseClass)) return true; + if (type == typeof(global::SimpleDerivedClass)) return true; + if (type == typeof(global::XmlSerializableBaseClass)) return true; + if (type == typeof(global::XmlSerializableDerivedClass)) return true; if (type == typeof(global::PurchaseOrder)) return true; if (type == typeof(global::Address)) return true; if (type == typeof(global::OrderedItem)) return true; @@ -15990,11 +16703,14 @@ public override System.Boolean CanSerialize(System.Type type) { if (type == typeof(global::SerializationTypes.TypeWithAnyAttribute)) return true; if (type == typeof(global::SerializationTypes.KnownTypesThroughConstructor)) return true; if (type == typeof(global::SerializationTypes.SimpleKnownTypeValue)) return true; - if (type == typeof(global::SerializationTypes.ClassImplementingIXmlSerialiable)) return true; + if (type == typeof(global::SerializationTypes.ClassImplementingIXmlSerializable)) return true; if (type == typeof(global::SerializationTypes.TypeWithPropertyNameSpecified)) return true; if (type == typeof(global::SerializationTypes.TypeWithXmlSchemaFormAttribute)) return true; if (type == typeof(global::SerializationTypes.TypeWithTypeNameInXmlTypeAttribute)) return true; if (type == typeof(global::SerializationTypes.TypeWithSchemaFormInXmlAttribute)) return true; + if (type == typeof(global::SerializationTypes.CustomDocument)) return true; + if (type == typeof(global::SerializationTypes.CustomElement)) return true; + if (type == typeof(global::SerializationTypes.CustomAttribute)) return true; if (type == typeof(global::SerializationTypes.TypeWithNonPublicDefaultConstructor)) return true; if (type == typeof(global::SerializationTypes.ServerSettings)) return true; if (type == typeof(global::SerializationTypes.TypeWithXmlQualifiedName)) return true; @@ -16033,6 +16749,10 @@ public override System.Xml.Serialization.XmlSerializer GetSerializer(System.Type if (type == typeof(global::Employee)) return new EmployeeSerializer(); if (type == typeof(global::BaseClass)) return new BaseClassSerializer(); if (type == typeof(global::DerivedClass)) return new DerivedClassSerializer(); + if (type == typeof(global::SimpleBaseClass)) return new SimpleBaseClassSerializer(); + if (type == typeof(global::SimpleDerivedClass)) return new SimpleDerivedClassSerializer(); + if (type == typeof(global::XmlSerializableBaseClass)) return new XmlSerializableBaseClassSerializer(); + if (type == typeof(global::XmlSerializableDerivedClass)) return new XmlSerializableDerivedClassSerializer(); if (type == typeof(global::PurchaseOrder)) return new PurchaseOrderSerializer(); if (type == typeof(global::Address)) return new AddressSerializer(); if (type == typeof(global::OrderedItem)) return new OrderedItemSerializer(); @@ -16098,11 +16818,14 @@ public override System.Xml.Serialization.XmlSerializer GetSerializer(System.Type if (type == typeof(global::SerializationTypes.TypeWithAnyAttribute)) return new TypeWithAnyAttributeSerializer(); if (type == typeof(global::SerializationTypes.KnownTypesThroughConstructor)) return new KnownTypesThroughConstructorSerializer(); if (type == typeof(global::SerializationTypes.SimpleKnownTypeValue)) return new SimpleKnownTypeValueSerializer(); - if (type == typeof(global::SerializationTypes.ClassImplementingIXmlSerialiable)) return new ClassImplementingIXmlSerialiableSerializer(); + if (type == typeof(global::SerializationTypes.ClassImplementingIXmlSerializable)) return new ClassImplementingIXmlSerializableSerializer(); if (type == typeof(global::SerializationTypes.TypeWithPropertyNameSpecified)) return new TypeWithPropertyNameSpecifiedSerializer(); if (type == typeof(global::SerializationTypes.TypeWithXmlSchemaFormAttribute)) return new TypeWithXmlSchemaFormAttributeSerializer(); if (type == typeof(global::SerializationTypes.TypeWithTypeNameInXmlTypeAttribute)) return new TypeWithTypeNameInXmlTypeAttributeSerializer(); if (type == typeof(global::SerializationTypes.TypeWithSchemaFormInXmlAttribute)) return new TypeWithSchemaFormInXmlAttributeSerializer(); + if (type == typeof(global::SerializationTypes.CustomDocument)) return new CustomDocumentSerializer(); + if (type == typeof(global::SerializationTypes.CustomElement)) return new CustomElementSerializer(); + if (type == typeof(global::SerializationTypes.CustomAttribute)) return new CustomAttributeSerializer(); if (type == typeof(global::SerializationTypes.TypeWithNonPublicDefaultConstructor)) return new TypeWithNonPublicDefaultConstructorSerializer(); if (type == typeof(global::SerializationTypes.ServerSettings)) return new ServerSettingsSerializer(); if (type == typeof(global::SerializationTypes.TypeWithXmlQualifiedName)) return new TypeWithXmlQualifiedNameSerializer(); diff --git a/src/libraries/System.CodeDom/Directory.Build.props b/src/libraries/System.CodeDom/Directory.Build.props index 72712f3351c..53773781258 100644 --- a/src/libraries/System.CodeDom/Directory.Build.props +++ b/src/libraries/System.CodeDom/Directory.Build.props @@ -2,6 +2,6 @@ true - browser;ios;tvos;maccatalyst + browser;wasi;ios;tvos;maccatalyst \ No newline at end of file diff --git a/src/libraries/System.CodeDom/System.CodeDom.sln b/src/libraries/System.CodeDom/System.CodeDom.sln index cb1e942fcd8..7ad94ce0bd2 100644 --- a/src/libraries/System.CodeDom/System.CodeDom.sln +++ b/src/libraries/System.CodeDom/System.CodeDom.sln @@ -7,7 +7,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.CodeDom", "src\Syste EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.CodeDom.Tests", "tests\System.CodeDom.Tests.csproj", "{627FFEFC-A317-4AD1-809F-B26CA7F475BD}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{B9251B70-FF97-4950-ABA7-50AB281D8F8E}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{6399648F-4FF4-4088-8362-41D69145457C}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{BB92EB52-7A9C-49C7-AC26-53864BAD4E1A}" EndProject @@ -59,10 +59,10 @@ Global {627FFEFC-A317-4AD1-809F-B26CA7F475BD}.Debug|Any CPU.Build.0 = Debug|Any CPU {627FFEFC-A317-4AD1-809F-B26CA7F475BD}.Release|Any CPU.ActiveCfg = Release|Any CPU {627FFEFC-A317-4AD1-809F-B26CA7F475BD}.Release|Any CPU.Build.0 = Release|Any CPU - {B9251B70-FF97-4950-ABA7-50AB281D8F8E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {B9251B70-FF97-4950-ABA7-50AB281D8F8E}.Debug|Any CPU.Build.0 = Debug|Any CPU - {B9251B70-FF97-4950-ABA7-50AB281D8F8E}.Release|Any CPU.ActiveCfg = Release|Any CPU - {B9251B70-FF97-4950-ABA7-50AB281D8F8E}.Release|Any CPU.Build.0 = Release|Any CPU + {6399648F-4FF4-4088-8362-41D69145457C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {6399648F-4FF4-4088-8362-41D69145457C}.Debug|Any CPU.Build.0 = Debug|Any CPU + {6399648F-4FF4-4088-8362-41D69145457C}.Release|Any CPU.ActiveCfg = Release|Any CPU + {6399648F-4FF4-4088-8362-41D69145457C}.Release|Any CPU.Build.0 = Release|Any CPU {BB92EB52-7A9C-49C7-AC26-53864BAD4E1A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {BB92EB52-7A9C-49C7-AC26-53864BAD4E1A}.Debug|Any CPU.Build.0 = Debug|Any CPU {BB92EB52-7A9C-49C7-AC26-53864BAD4E1A}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -96,7 +96,7 @@ Global {627FFEFC-A317-4AD1-809F-B26CA7F475BD} = {2D7D470B-B092-45BC-900A-CDB20CA94BE7} {74AE27CF-E940-4EEB-9A19-0968689B627E} = {54321C0F-1323-4962-A01C-AC07028C3FA8} {14D5A803-D5BF-44E5-B2B5-0B0BC297748E} = {6591788E-0894-4655-AE2F-602407C4F766} - {B9251B70-FF97-4950-ABA7-50AB281D8F8E} = {91ED5DF2-6A20-4B11-B671-19BB53254EE7} + {6399648F-4FF4-4088-8362-41D69145457C} = {91ED5DF2-6A20-4B11-B671-19BB53254EE7} {BB92EB52-7A9C-49C7-AC26-53864BAD4E1A} = {91ED5DF2-6A20-4B11-B671-19BB53254EE7} {D1FCA81A-628F-42E8-9998-B1AE3AADF8FD} = {D7A93C90-3F4E-4BC8-B5BD-5D8F5329B1AB} {6911785C-F046-4726-9035-5F67887F3AA9} = {D7A93C90-3F4E-4BC8-B5BD-5D8F5329B1AB} diff --git a/src/libraries/System.CodeDom/src/PACKAGE.md b/src/libraries/System.CodeDom/src/PACKAGE.md new file mode 100644 index 00000000000..2785a3e5888 --- /dev/null +++ b/src/libraries/System.CodeDom/src/PACKAGE.md @@ -0,0 +1,127 @@ +## About + + + +Provides functionality for dynamically generating and compiling source code using the Code Document Object Model (CodeDOM). + +It allows developers to represent code in a language-agnostic format and then generate code in multiple languages, such as C# and VB.NET. +The primary use cases include creating dynamic code generation tools, runtime code generation, and facilitating code analysis or transformation. + +For a new modern development consider using the [.NET Compiler Platform SDK](https://learn.microsoft.com/dotnet/csharp/roslyn-sdk/), in particular [Roslyn source generators](https://learn.microsoft.com/dotnet/csharp/roslyn-sdk/source-generators-overview#get-started-with-source-generators). + +## Key Features + + + +* Write code using a common object model that can be translated into multiple programming languages. +* Generate and compile code at runtime based on the CodeDOM. + +## How to Use + + + +Generating and compiling C# code: + +```csharp +using System.CodeDom; +using System.CodeDom.Compiler; +using Microsoft.CSharp; + +// Create a new CodeCompileUnit to hold the code +var compileUnit = new CodeCompileUnit(); + +// Create a namespace +var codeNamespace = new CodeNamespace("MyNamespace"); +compileUnit.Namespaces.Add(codeNamespace); + +// Create a class +var classDeclaration = new CodeTypeDeclaration("MyClass") +{ + IsClass = true +}; +codeNamespace.Types.Add(classDeclaration); + +// Add a simple method to the class +var method = new CodeMemberMethod +{ + Name = "HelloWorld", + ReturnType = new CodeTypeReference(typeof(void)), +}; +classDeclaration.Members.Add(method); + +var methodInvocation = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression("Console"), + "WriteLine", + new CodePrimitiveExpression("Hello, World!")); +method.Statements.Add(methodInvocation); + +// Generate C# code from the CodeDOM structure +CodeDomProvider provider = new CSharpCodeProvider(); + +using (var writer = new StringWriter()) +{ + var codeGenereationOptions = new CodeGeneratorOptions() + { + BlankLinesBetweenMembers = false, + IndentString = " ", + }; + + provider.GenerateCodeFromCompileUnit(compileUnit, writer, codeGenereationOptions); + Console.WriteLine(writer.GetStringBuilder().ToString()); +} +``` + +This example generates: + +```csharp +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace MyNamespace { + + public class MyClass { + private void HelloWorld() { + Console.WriteLine("Hello, World!"); + } + } +} +``` + +## Main Types + + + +The main types provided by this library are: + +* `System.CodeDom.CodeObject` +* `System.CodeDom.CodeCompileUnit` +* `System.CodeDom.CodeNamespace` +* `System.CodeDom.CodeTypeDeclaration` +* `System.CodeDom.CodeMemberMethod` +* `System.CodeDom.CodeTypeReference` +* `System.CodeDom.CodeMethodInvokeExpression` +* `System.CodeDom.CodeTypeReferenceExpression` +* `System.CodeDom.CodePrimitiveExpression` +* `System.CodeDom.Compiler.CodeDomProvider` +* `System.CodeDom.Compiler.CodeGeneratorOptions` +* `Microsoft.CSharp.CSharpCodeProvider` +* `Microsoft.VisualBasic.VBCodeProvider` + +## Additional Documentation + + + +* [API documentation](https://learn.microsoft.com/dotnet/api/system.codedom) +* [Compile and generate dynamic source code](https://learn.microsoft.com/dotnet/framework/reflection-and-codedom/dynamic-source-code-generation-and-compilation) + +## Feedback & Contributing + + + +System.CodeDom is released as open source under the [MIT license](https://licenses.nuget.org/MIT). +Bug reports and contributions are welcome at [the GitHub repository](https://github.com/dotnet/runtime). diff --git a/src/libraries/System.CodeDom/src/System.CodeDom.csproj b/src/libraries/System.CodeDom/src/System.CodeDom.csproj index a987278ff05..76ba0e1a9d3 100644 --- a/src/libraries/System.CodeDom/src/System.CodeDom.csproj +++ b/src/libraries/System.CodeDom/src/System.CodeDom.csproj @@ -6,19 +6,11 @@ false false true - Provides types that can be used to model the structure of a source code document and to output source code for that model in a supported language. - -Commonly Used Types: -System.CodeDom.CodeObject -System.CodeDom.Compiler.CodeDomProvider -Microsoft.CSharp.CSharpCodeProvider -Microsoft.VisualBasic.VBCodeProvider + Provides types that can be used to model the structure of a source code document and to output source code for that model in C# or Visual Basic. disable $(NoWarn);nullable - - false diff --git a/src/libraries/System.Collections.Concurrent/System.Collections.Concurrent.sln b/src/libraries/System.Collections.Concurrent/System.Collections.Concurrent.sln index 5b118d03742..c8de294f190 100644 --- a/src/libraries/System.Collections.Concurrent/System.Collections.Concurrent.sln +++ b/src/libraries/System.Collections.Concurrent/System.Collections.Concurrent.sln @@ -21,6 +21,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib.Gene EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\System.Private.CoreLib\ref\System.Private.CoreLib.csproj", "{6C5BE0DF-C0E1-4971-9E4A-01105A4A013A}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{816784D4-4EC7-44A4-899A-22F7D82EF348}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{1E072489-1073-4526-8C5D-64AC2A97BF9B}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{2DB3F8FB-BDD7-471E-BF8F-D3C4D6A2BDC3}" @@ -316,6 +318,27 @@ Global {6C5BE0DF-C0E1-4971-9E4A-01105A4A013A}.Checked|arm64.ActiveCfg = Debug|Any CPU {6C5BE0DF-C0E1-4971-9E4A-01105A4A013A}.Checked|x64.ActiveCfg = Debug|Any CPU {6C5BE0DF-C0E1-4971-9E4A-01105A4A013A}.Checked|x86.ActiveCfg = Debug|Any CPU + {816784D4-4EC7-44A4-899A-22F7D82EF348}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {816784D4-4EC7-44A4-899A-22F7D82EF348}.Debug|Any CPU.Build.0 = Debug|Any CPU + {816784D4-4EC7-44A4-899A-22F7D82EF348}.Debug|arm.ActiveCfg = Debug|Any CPU + {816784D4-4EC7-44A4-899A-22F7D82EF348}.Debug|arm64.ActiveCfg = Debug|Any CPU + {816784D4-4EC7-44A4-899A-22F7D82EF348}.Debug|x64.ActiveCfg = Debug|Any CPU + {816784D4-4EC7-44A4-899A-22F7D82EF348}.Debug|x64.Build.0 = Debug|Any CPU + {816784D4-4EC7-44A4-899A-22F7D82EF348}.Debug|x86.ActiveCfg = Debug|Any CPU + {816784D4-4EC7-44A4-899A-22F7D82EF348}.Debug|x86.Build.0 = Debug|Any CPU + {816784D4-4EC7-44A4-899A-22F7D82EF348}.Release|Any CPU.ActiveCfg = Release|Any CPU + {816784D4-4EC7-44A4-899A-22F7D82EF348}.Release|Any CPU.Build.0 = Release|Any CPU + {816784D4-4EC7-44A4-899A-22F7D82EF348}.Release|arm.ActiveCfg = Release|Any CPU + {816784D4-4EC7-44A4-899A-22F7D82EF348}.Release|arm64.ActiveCfg = Release|Any CPU + {816784D4-4EC7-44A4-899A-22F7D82EF348}.Release|x64.ActiveCfg = Release|Any CPU + {816784D4-4EC7-44A4-899A-22F7D82EF348}.Release|x64.Build.0 = Release|Any CPU + {816784D4-4EC7-44A4-899A-22F7D82EF348}.Release|x86.ActiveCfg = Release|Any CPU + {816784D4-4EC7-44A4-899A-22F7D82EF348}.Release|x86.Build.0 = Release|Any CPU + {816784D4-4EC7-44A4-899A-22F7D82EF348}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {816784D4-4EC7-44A4-899A-22F7D82EF348}.Checked|arm.ActiveCfg = Debug|Any CPU + {816784D4-4EC7-44A4-899A-22F7D82EF348}.Checked|arm64.ActiveCfg = Debug|Any CPU + {816784D4-4EC7-44A4-899A-22F7D82EF348}.Checked|x64.ActiveCfg = Debug|Any CPU + {816784D4-4EC7-44A4-899A-22F7D82EF348}.Checked|x86.ActiveCfg = Debug|Any CPU {1E072489-1073-4526-8C5D-64AC2A97BF9B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {1E072489-1073-4526-8C5D-64AC2A97BF9B}.Debug|Any CPU.Build.0 = Debug|Any CPU {1E072489-1073-4526-8C5D-64AC2A97BF9B}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -545,6 +568,7 @@ Global {BE035215-7EB5-4B56-9DD2-67519A631A89} = {CA1F4ADE-3F2A-40E3-9242-549F88F0367F} {36F808C9-93D1-41D2-A2F8-E0F113B3F10F} = {CA1F4ADE-3F2A-40E3-9242-549F88F0367F} {431D18E4-4464-45C0-BBF2-1834B73E8095} = {93EF6213-7FD5-4A26-A8AB-AF8E4DB470FD} + {816784D4-4EC7-44A4-899A-22F7D82EF348} = {93EF6213-7FD5-4A26-A8AB-AF8E4DB470FD} {1E072489-1073-4526-8C5D-64AC2A97BF9B} = {93EF6213-7FD5-4A26-A8AB-AF8E4DB470FD} {2DB3F8FB-BDD7-471E-BF8F-D3C4D6A2BDC3} = {93EF6213-7FD5-4A26-A8AB-AF8E4DB470FD} {2266BB4C-0245-437D-8346-CFF899111225} = {66E1333A-027B-4577-AED6-A2457698A6D9} diff --git a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary.cs b/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary.cs index 5748725a154..91387fbcde0 100644 --- a/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary.cs +++ b/src/libraries/System.Collections.Concurrent/src/System/Collections/Concurrent/ConcurrentDictionary.cs @@ -443,57 +443,52 @@ private bool TryRemoveInternal(TKey key, [MaybeNullWhen(false)] out TValue value object[] locks = tables._locks; ref Node? bucket = ref GetBucketAndLock(tables, hashcode, out uint lockNo); - // Do a hot read on number of items stored in the bucket. If it's empty, we can avoid - // taking the lock and fail fast. - if (tables._countPerLock[lockNo] != 0) + lock (locks[lockNo]) { - lock (locks[lockNo]) + // If the table just got resized, we may not be holding the right lock, and must retry. + // This should be a rare occurrence. + if (tables != _tables) { - // If the table just got resized, we may not be holding the right lock, and must retry. - // This should be a rare occurrence. - if (tables != _tables) + tables = _tables; + if (!ReferenceEquals(comparer, tables._comparer)) { - tables = _tables; - if (!ReferenceEquals(comparer, tables._comparer)) - { - comparer = tables._comparer; - hashcode = GetHashCode(comparer, key); - } - continue; + comparer = tables._comparer; + hashcode = GetHashCode(comparer, key); } + continue; + } - Node? prev = null; - for (Node? curr = bucket; curr is not null; curr = curr._next) - { - Debug.Assert((prev is null && curr == bucket) || prev!._next == curr); + Node? prev = null; + for (Node? curr = bucket; curr is not null; curr = curr._next) + { + Debug.Assert((prev is null && curr == bucket) || prev!._next == curr); - if (hashcode == curr._hashcode && NodeEqualsKey(comparer, curr, key)) + if (hashcode == curr._hashcode && NodeEqualsKey(comparer, curr, key)) + { + if (matchValue) { - if (matchValue) - { - bool valuesMatch = EqualityComparer.Default.Equals(oldValue, curr._value); - if (!valuesMatch) - { - value = default; - return false; - } - } - - if (prev is null) - { - Volatile.Write(ref bucket, curr._next); - } - else + bool valuesMatch = EqualityComparer.Default.Equals(oldValue, curr._value); + if (!valuesMatch) { - prev._next = curr._next; + value = default; + return false; } + } - value = curr._value; - tables._countPerLock[lockNo]--; - return true; + if (prev is null) + { + Volatile.Write(ref bucket, curr._next); } - prev = curr; + else + { + prev._next = curr._next; + } + + value = curr._value; + tables._countPerLock[lockNo]--; + return true; } + prev = curr; } } @@ -2547,6 +2542,7 @@ private bool TryAdd(TAlternateKey key, TValue value, bool updateIfExists, out TV /// When this method returns, contains the value associated with the specified key, if the key is found; /// otherwise, the default value for the type of the value parameter. /// + /// if an entry was found; otherwise, . /// is . public bool TryGetValue(TAlternateKey key, [MaybeNullWhen(false)] out TValue value) => TryGetValue(key, out _, out value); @@ -2561,6 +2557,7 @@ public bool TryGetValue(TAlternateKey key, [MaybeNullWhen(false)] out TValue val /// When this method returns, contains the value associated with the specified key, if the key is found; /// otherwise, the default value for the type of the value parameter. /// + /// if an entry was found; otherwise, . /// is . public bool TryGetValue(TAlternateKey key, [MaybeNullWhen(false)] out TKey actualKey, [MaybeNullWhen(false)] out TValue value) { diff --git a/src/libraries/System.Collections.Immutable/System.Collections.Immutable.sln b/src/libraries/System.Collections.Immutable/System.Collections.Immutable.sln index fb0d9d415a7..afcdb4d4f00 100644 --- a/src/libraries/System.Collections.Immutable/System.Collections.Immutable.sln +++ b/src/libraries/System.Collections.Immutable/System.Collections.Immutable.sln @@ -11,6 +11,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Collections", "..\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{9E9FE095-8503-43E9-9291-F61597ABF8F0}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{C55CDFD3-6BDA-40D1-91BD-A22F2E67AA7A}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{E52EB126-11CE-4437-AA53-2001EEEEF9BC}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{FCC1AE83-36B9-464B-8A5B-8C9E8244905B}" @@ -73,6 +75,10 @@ Global {9E9FE095-8503-43E9-9291-F61597ABF8F0}.Debug|Any CPU.Build.0 = Debug|Any CPU {9E9FE095-8503-43E9-9291-F61597ABF8F0}.Release|Any CPU.ActiveCfg = Release|Any CPU {9E9FE095-8503-43E9-9291-F61597ABF8F0}.Release|Any CPU.Build.0 = Release|Any CPU + {C55CDFD3-6BDA-40D1-91BD-A22F2E67AA7A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {C55CDFD3-6BDA-40D1-91BD-A22F2E67AA7A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C55CDFD3-6BDA-40D1-91BD-A22F2E67AA7A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {C55CDFD3-6BDA-40D1-91BD-A22F2E67AA7A}.Release|Any CPU.Build.0 = Release|Any CPU {E52EB126-11CE-4437-AA53-2001EEEEF9BC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {E52EB126-11CE-4437-AA53-2001EEEEF9BC}.Debug|Any CPU.Build.0 = Debug|Any CPU {E52EB126-11CE-4437-AA53-2001EEEEF9BC}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -117,6 +123,7 @@ Global {53DB26DA-695E-4FF9-BCE9-1CE465681F64} = {12BB8B2C-950F-4AA8-BFED-D87D2873FEDA} {F9520C8A-A85B-4AB0-8535-D1F2124DAC76} = {50502C33-83FC-41E3-A25D-E870C5AAB7CE} {9E9FE095-8503-43E9-9291-F61597ABF8F0} = {EEC12D52-2DAA-4D12-A123-BB4AC370814B} + {C55CDFD3-6BDA-40D1-91BD-A22F2E67AA7A} = {EEC12D52-2DAA-4D12-A123-BB4AC370814B} {E52EB126-11CE-4437-AA53-2001EEEEF9BC} = {EEC12D52-2DAA-4D12-A123-BB4AC370814B} {FCC1AE83-36B9-464B-8A5B-8C9E8244905B} = {EEC12D52-2DAA-4D12-A123-BB4AC370814B} {32394700-F98D-435B-A1CD-0B010059784A} = {A2DA4053-61CD-4591-A7D2-EE3074258D23} diff --git a/src/libraries/System.Collections.Immutable/ref/System.Collections.Immutable.net9.cs b/src/libraries/System.Collections.Immutable/ref/System.Collections.Immutable.net9.cs index 4cde549aac3..9a22864bd7e 100644 --- a/src/libraries/System.Collections.Immutable/ref/System.Collections.Immutable.net9.cs +++ b/src/libraries/System.Collections.Immutable/ref/System.Collections.Immutable.net9.cs @@ -22,9 +22,9 @@ public abstract partial class FrozenDictionary } public abstract partial class FrozenSet { - public System.Collections.Frozen.FrozenSet.AlternateLookup GetAlternateLookup() { throw null; } - public bool TryGetAlternateLookup(out System.Collections.Frozen.FrozenSet.AlternateLookup lookup) { throw null; } - public readonly partial struct AlternateLookup + public System.Collections.Frozen.FrozenSet.AlternateLookup GetAlternateLookup() where TAlternate : allows ref struct { throw null; } + public bool TryGetAlternateLookup(out System.Collections.Frozen.FrozenSet.AlternateLookup lookup) where TAlternate : allows ref struct { throw null; } + public readonly partial struct AlternateLookup where TAlternate : allows ref struct { private readonly object _dummy; private readonly int _dummyPrimitive; diff --git a/src/libraries/System.Collections.Immutable/src/Properties/InternalsVisibleTo.cs b/src/libraries/System.Collections.Immutable/src/Properties/InternalsVisibleTo.cs deleted file mode 100644 index a72ff9ffdcb..00000000000 --- a/src/libraries/System.Collections.Immutable/src/Properties/InternalsVisibleTo.cs +++ /dev/null @@ -1,6 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Runtime.CompilerServices; - -[assembly: InternalsVisibleTo("System.Collections.Immutable.Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001004b86c4cb78549b34bab61a3b1800e23bfeb5b3ec390074041536a7e3cbd97f5f04cf0f857155a8928eaa29ebfd11cfbbad3ba70efea7bda3226c6a8d370a4cd303f714486b6ebc225985a638471e6ef571cc92a4613c00b8fa65d61ccee0cbe5f36330c9a01f4183559f1bef24cc2917c6d913e3a541333a1d05d9bed22b38cb")] diff --git a/src/libraries/System.Collections.Immutable/src/System.Collections.Immutable.csproj b/src/libraries/System.Collections.Immutable/src/System.Collections.Immutable.csproj index 47c5898a66c..d2eac5d7d45 100644 --- a/src/libraries/System.Collections.Immutable/src/System.Collections.Immutable.csproj +++ b/src/libraries/System.Collections.Immutable/src/System.Collections.Immutable.csproj @@ -11,7 +11,6 @@ The System.Collections.Immutable library is built-in as part of the shared frame - @@ -68,18 +67,13 @@ The System.Collections.Immutable library is built-in as part of the shared frame - - - - - @@ -87,7 +81,6 @@ The System.Collections.Immutable library is built-in as part of the shared frame - diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Frozen/FrozenDictionary.AlternateLookup.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Frozen/FrozenDictionary.AlternateLookup.cs index dccd24a590e..acdcc49835d 100644 --- a/src/libraries/System.Collections.Immutable/src/System/Collections/Frozen/FrozenDictionary.AlternateLookup.cs +++ b/src/libraries/System.Collections.Immutable/src/System/Collections/Frozen/FrozenDictionary.AlternateLookup.cs @@ -122,6 +122,7 @@ public bool ContainsKey(TAlternateKey key) => /// When this method returns, contains the value associated with the specified key, if the key is found; /// otherwise, the default value for the type of the value parameter. /// + /// if an entry was found; otherwise, . /// is . public bool TryGetValue(TAlternateKey key, [MaybeNullWhen(false)] out TValue value) { diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Generic/IHashKeyCollection.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Generic/IHashKeyCollection.cs deleted file mode 100644 index 30ce4bc7ddd..00000000000 --- a/src/libraries/System.Collections.Immutable/src/System/Collections/Generic/IHashKeyCollection.cs +++ /dev/null @@ -1,17 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -namespace System.Collections.Generic -{ - /// - /// Defined on a generic collection that hashes its contents using an . - /// - /// The type of element hashed in the collection. - internal interface IHashKeyCollection - { - /// - /// Gets the comparer used to obtain hash codes for the keys and check equality. - /// - IEqualityComparer KeyComparer { get; } - } -} diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Generic/ISortKeyCollection.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Generic/ISortKeyCollection.cs deleted file mode 100644 index cb5c4452cba..00000000000 --- a/src/libraries/System.Collections.Immutable/src/System/Collections/Generic/ISortKeyCollection.cs +++ /dev/null @@ -1,19 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Diagnostics.CodeAnalysis; - -namespace System.Collections.Generic -{ - /// - /// Defined on a generic collection that sorts its contents using an . - /// - /// The type of element sorted in the collection. - internal interface ISortKeyCollection - { - /// - /// Gets the comparer used to sort keys. - /// - IComparer KeyComparer { get; } - } -} diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/IBinaryTree.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/IBinaryTree.cs deleted file mode 100644 index 7f4dc492d76..00000000000 --- a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/IBinaryTree.cs +++ /dev/null @@ -1,58 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -namespace System.Collections.Immutable -{ - /// - /// An interface for binary tree nodes that allow our common enumerator to walk the graph. - /// - internal interface IBinaryTree - { - /// - /// Gets the depth of the tree below this node. - /// - int Height { get; } - - /// - /// Gets a value indicating whether this node is empty. - /// - bool IsEmpty { get; } - - /// - /// Gets the number of non-empty nodes at this node and below. - /// - /// Thrown if the implementation does not store this value at the node. - int Count { get; } - /// - /// Gets the left branch of this node. - /// - IBinaryTree? Left { get; } - - /// - /// Gets the right branch of this node. - /// - IBinaryTree? Right { get; } - } - - /// - /// An interface for binary tree nodes that allow our common enumerator to walk the graph. - /// - /// The type of value for each node. - internal interface IBinaryTree : IBinaryTree - { - /// - /// Gets the value represented by the current node. - /// - T Value { get; } - - /// - /// Gets the left branch of this node. - /// - new IBinaryTree? Left { get; } - - /// - /// Gets the right branch of this node. - /// - new IBinaryTree? Right { get; } - } -} diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/IImmutableListQueries.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/IImmutableListQueries.cs deleted file mode 100644 index cb19d186960..00000000000 --- a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/IImmutableListQueries.cs +++ /dev/null @@ -1,332 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Collections.Generic; -using System.Diagnostics.CodeAnalysis; - -namespace System.Collections.Immutable -{ - /// - /// An interface that describes the methods that the and types have in common. - /// - /// The type of element in the collection. - internal interface IImmutableListQueries : IReadOnlyList - { - /// - /// Converts the elements in the current to - /// another type, and returns a list containing the converted elements. - /// - /// - /// A delegate that converts each element from - /// one type to another type. - /// - /// - /// The type of the elements of the target array. - /// - /// - /// A of the target type containing the converted - /// elements from the current . - /// - ImmutableList ConvertAll(Func converter); - - /// - /// Performs the specified action on each element of the list. - /// - /// The delegate to perform on each element of the list. - void ForEach(Action action); - - /// - /// Creates a shallow copy of a range of elements in the source . - /// - /// - /// The zero-based index at which the range - /// starts. - /// - /// - /// The number of elements in the range. - /// - /// - /// A shallow copy of a range of elements in the source . - /// - ImmutableList GetRange(int index, int count); - - /// - /// Copies the entire to a compatible one-dimensional - /// array, starting at the beginning of the target array. - /// - /// - /// The one-dimensional that is the destination of the elements - /// copied from . The must have - /// zero-based indexing. - /// - void CopyTo(T[] array); - - /// - /// Copies the entire to a compatible one-dimensional - /// array, starting at the specified index of the target array. - /// - /// - /// The one-dimensional that is the destination of the elements - /// copied from . The must have - /// zero-based indexing. - /// - /// - /// The zero-based index in at which copying begins. - /// - void CopyTo(T[] array, int arrayIndex); - - /// - /// Copies a range of elements from the to - /// a compatible one-dimensional array, starting at the specified index of the - /// target array. - /// - /// - /// The zero-based index in the source at - /// which copying begins. - /// - /// - /// The one-dimensional that is the destination of the elements - /// copied from . The must have - /// zero-based indexing. - /// - /// The zero-based index in at which copying begins. - /// The number of elements to copy. - void CopyTo(int index, T[] array, int arrayIndex, int count); - - /// - /// Determines whether the contains elements - /// that match the conditions defined by the specified predicate. - /// - /// - /// The delegate that defines the conditions of the elements - /// to search for. - /// - /// - /// true if the contains one or more elements - /// that match the conditions defined by the specified predicate; otherwise, - /// false. - /// - bool Exists(Predicate match); - - /// - /// Searches for an element that matches the conditions defined by the specified - /// predicate, and returns the first occurrence within the entire . - /// - /// - /// The delegate that defines the conditions of the element - /// to search for. - /// - /// - /// The first element that matches the conditions defined by the specified predicate, - /// if found; otherwise, the default value for type . - /// - T? Find(Predicate match); - - /// - /// Retrieves all the elements that match the conditions defined by the specified - /// predicate. - /// - /// - /// The delegate that defines the conditions of the elements - /// to search for. - /// - /// - /// A containing all the elements that match - /// the conditions defined by the specified predicate, if found; otherwise, an - /// empty . - /// - ImmutableList FindAll(Predicate match); - - /// - /// Searches for an element that matches the conditions defined by the specified - /// predicate, and returns the zero-based index of the first occurrence within - /// the entire . - /// - /// - /// The delegate that defines the conditions of the element - /// to search for. - /// - /// - /// The zero-based index of the first occurrence of an element that matches the - /// conditions defined by , if found; otherwise, -1. - /// - int FindIndex(Predicate match); - - /// - /// Searches for an element that matches the conditions defined by the specified - /// predicate, and returns the zero-based index of the first occurrence within - /// the range of elements in the that extends - /// from the specified index to the last element. - /// - /// The zero-based starting index of the search. - /// The delegate that defines the conditions of the element to search for. - /// - /// The zero-based index of the first occurrence of an element that matches the - /// conditions defined by , if found; otherwise, -1. - /// - int FindIndex(int startIndex, Predicate match); - - /// - /// Searches for an element that matches the conditions defined by the specified - /// predicate, and returns the zero-based index of the first occurrence within - /// the range of elements in the that starts - /// at the specified index and contains the specified number of elements. - /// - /// The zero-based starting index of the search. - /// The number of elements in the section to search. - /// The delegate that defines the conditions of the element to search for. - /// - /// The zero-based index of the first occurrence of an element that matches the - /// conditions defined by , if found; otherwise, -1. - /// - int FindIndex(int startIndex, int count, Predicate match); - - /// - /// Searches for an element that matches the conditions defined by the specified - /// predicate, and returns the last occurrence within the entire . - /// - /// - /// The delegate that defines the conditions of the element - /// to search for. - /// - /// - /// The last element that matches the conditions defined by the specified predicate, - /// if found; otherwise, the default value for type . - /// - T? FindLast(Predicate match); - - /// - /// Searches for an element that matches the conditions defined by the specified - /// predicate, and returns the zero-based index of the last occurrence within - /// the entire . - /// - /// - /// The delegate that defines the conditions of the element - /// to search for. - /// - /// - /// The zero-based index of the last occurrence of an element that matches the - /// conditions defined by , if found; otherwise, -1. - /// - int FindLastIndex(Predicate match); - - /// - /// Searches for an element that matches the conditions defined by the specified - /// predicate, and returns the zero-based index of the last occurrence within - /// the range of elements in the that extends - /// from the first element to the specified index. - /// - /// The zero-based starting index of the backward search. - /// The delegate that defines the conditions of the element - /// to search for. - /// - /// The zero-based index of the last occurrence of an element that matches the - /// conditions defined by , if found; otherwise, -1. - /// - int FindLastIndex(int startIndex, Predicate match); - - /// - /// Searches for an element that matches the conditions defined by the specified - /// predicate, and returns the zero-based index of the last occurrence within - /// the range of elements in the that contains - /// the specified number of elements and ends at the specified index. - /// - /// The zero-based starting index of the backward search. - /// The number of elements in the section to search. - /// - /// The delegate that defines the conditions of the element - /// to search for. - /// - /// - /// The zero-based index of the last occurrence of an element that matches the - /// conditions defined by , if found; otherwise, -1. - /// - int FindLastIndex(int startIndex, int count, Predicate match); - - /// - /// Determines whether every element in the - /// matches the conditions defined by the specified predicate. - /// - /// - /// The delegate that defines the conditions to check against - /// the elements. - /// - /// - /// true if every element in the matches the - /// conditions defined by the specified predicate; otherwise, false. If the list - /// has no elements, the return value is true. - /// - bool TrueForAll(Predicate match); - - /// - /// Searches the entire sorted for an element - /// using the default comparer and returns the zero-based index of the element. - /// - /// The object to locate. The value can be null for reference types. - /// - /// The zero-based index of in the sorted , - /// if is found; otherwise, a negative number that is the bitwise complement - /// of the index of the next element that is larger than or, if there is - /// no larger element, the bitwise complement of . - /// - /// - /// The default comparer cannot - /// find an implementation of the generic interface or - /// the interface for type . - /// - int BinarySearch(T item); - - /// - /// Searches the entire sorted for an element - /// using the specified comparer and returns the zero-based index of the element. - /// - /// The object to locate. The value can be null for reference types. - /// - /// The implementation to use when comparing - /// elements.-or-null to use the default comparer . - /// - /// - /// The zero-based index of in the sorted , - /// if is found; otherwise, a negative number that is the bitwise complement - /// of the index of the next element that is larger than or, if there is - /// no larger element, the bitwise complement of . - /// - /// - /// is null, and the default comparer - /// cannot find an implementation of the generic interface - /// or the interface for type . - /// - int BinarySearch(T item, IComparer? comparer); - - /// - /// Searches a range of elements in the sorted - /// for an element using the specified comparer and returns the zero-based index - /// of the element. - /// - /// The zero-based starting index of the range to search. - /// The length of the range to search. - /// The object to locate. The value can be null for reference types. - /// - /// The implementation to use when comparing - /// elements, or null to use the default comparer . - /// - /// - /// The zero-based index of in the sorted , - /// if is found; otherwise, a negative number that is the bitwise complement - /// of the index of the next element that is larger than or, if there is - /// no larger element, the bitwise complement of . - /// - /// - /// is less than 0.-or- is less than 0. - /// - /// - /// and do not denote a valid range in the . - /// - /// - /// is null, and the default comparer - /// cannot find an implementation of the generic interface - /// or the interface for type . - /// - int BinarySearch(int index, int count, T item, IComparer? comparer); - } -} diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/IOrderedCollection.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/IOrderedCollection.cs deleted file mode 100644 index c4f33bae782..00000000000 --- a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/IOrderedCollection.cs +++ /dev/null @@ -1,24 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Collections.Generic; - -namespace System.Collections.Immutable -{ - /// - /// Describes an ordered collection of elements. - /// - /// The type of element in the collection. - internal interface IOrderedCollection : IEnumerable - { - /// - /// Gets the number of elements in the collection. - /// - int Count { get; } - - /// - /// Gets the element in the collection at a given index. - /// - T this[int index] { get; } - } -} diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableDictionary_2.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableDictionary_2.cs index ee164957d36..5e2f31a961b 100644 --- a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableDictionary_2.cs +++ b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableDictionary_2.cs @@ -15,7 +15,7 @@ namespace System.Collections.Immutable /// The type of the value. [DebuggerDisplay("Count = {Count}")] [DebuggerTypeProxy(typeof(ImmutableDictionaryDebuggerProxy<,>))] - public sealed partial class ImmutableDictionary : IImmutableDictionary, IImmutableDictionaryInternal, IHashKeyCollection, IDictionary, IDictionary where TKey : notnull + public sealed partial class ImmutableDictionary : IImmutableDictionary, IImmutableDictionaryInternal, IDictionary, IDictionary where TKey : notnull { /// /// An empty immutable dictionary with default equality comparers. diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableEnumerableDebuggerProxy.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableEnumerableDebuggerProxy.cs index 1522e0a8f05..b3258e35eb9 100644 --- a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableEnumerableDebuggerProxy.cs +++ b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableEnumerableDebuggerProxy.cs @@ -54,7 +54,7 @@ public ImmutableDictionaryDebuggerProxy(IReadOnlyDictionary dictio /// This class should only be used with immutable enumerables, since it /// caches the enumerable into an array for display in the debugger. /// - internal class ImmutableEnumerableDebuggerProxy + internal sealed class ImmutableEnumerableDebuggerProxy { /// /// The enumerable to show to the debugger. diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableExtensions.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableExtensions.cs index 8d941eb0bce..637bc0e022c 100644 --- a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableExtensions.cs +++ b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableExtensions.cs @@ -41,11 +41,11 @@ internal static bool IsValueType() /// The type of elements in the collection. /// The collection. /// An ordered collection. May not be thread-safe. Never null. - internal static IOrderedCollection AsOrderedCollection(this IEnumerable sequence) + internal static IReadOnlyList AsReadOnlyList(this IEnumerable sequence) { Requires.NotNull(sequence, nameof(sequence)); - if (sequence is IOrderedCollection orderedCollection) + if (sequence is IReadOnlyList orderedCollection) { return orderedCollection; } @@ -105,7 +105,7 @@ internal static DisposableEnumeratorAdapter GetEnumerableDisposa /// Wraps a as an ordered collection. /// /// The type of element in the collection. - private sealed class ListOfTWrapper : IOrderedCollection + private sealed class ListOfTWrapper : IReadOnlyList { /// /// The list being exposed. @@ -165,7 +165,7 @@ IEnumerator IEnumerable.GetEnumerator() /// Wraps any as an ordered, indexable list. /// /// The type of element in the collection. - private sealed class FallbackWrapper : IOrderedCollection + private sealed class FallbackWrapper : IReadOnlyList { /// /// The original sequence. diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableHashSet_1.HashBucketByRefEqualityComparer.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableHashSet_1.HashBucketByRefEqualityComparer.cs index 05cd5ddc786..b9b4f0200d4 100644 --- a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableHashSet_1.HashBucketByRefEqualityComparer.cs +++ b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableHashSet_1.HashBucketByRefEqualityComparer.cs @@ -8,7 +8,7 @@ namespace System.Collections.Immutable /// /// Contains the inner class. /// - public sealed partial class ImmutableHashSet : IImmutableSet, IHashKeyCollection, IReadOnlyCollection, ICollection, ISet, ICollection, IStrongEnumerable.Enumerator> + public sealed partial class ImmutableHashSet : IImmutableSet, IReadOnlyCollection, ICollection, ISet, ICollection, IStrongEnumerable.Enumerator> { /// /// Compares equality between two instances diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableHashSet_1.HashBucketByValueEqualityComparer.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableHashSet_1.HashBucketByValueEqualityComparer.cs index 3cac674f706..1cc97a6f466 100644 --- a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableHashSet_1.HashBucketByValueEqualityComparer.cs +++ b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableHashSet_1.HashBucketByValueEqualityComparer.cs @@ -8,7 +8,7 @@ namespace System.Collections.Immutable /// /// Contains the inner class. /// - public sealed partial class ImmutableHashSet : IImmutableSet, IHashKeyCollection, IReadOnlyCollection, ICollection, ISet, ICollection, IStrongEnumerable.Enumerator> + public sealed partial class ImmutableHashSet : IImmutableSet, IReadOnlyCollection, ICollection, ISet, ICollection, IStrongEnumerable.Enumerator> { /// /// Compares equality between two instances diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableHashSet_1.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableHashSet_1.cs index 2ff4b68d19a..c6b6f3140e4 100644 --- a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableHashSet_1.cs +++ b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableHashSet_1.cs @@ -16,9 +16,9 @@ namespace System.Collections.Immutable [DebuggerDisplay("Count = {Count}")] [DebuggerTypeProxy(typeof(ImmutableEnumerableDebuggerProxy<>))] #if NET - public sealed partial class ImmutableHashSet : IImmutableSet, IHashKeyCollection, IReadOnlyCollection, ICollection, ISet, IReadOnlySet, ICollection, IStrongEnumerable.Enumerator> + public sealed partial class ImmutableHashSet : IImmutableSet, IReadOnlyCollection, ICollection, ISet, IReadOnlySet, ICollection, IStrongEnumerable.Enumerator> #else - public sealed partial class ImmutableHashSet : IImmutableSet, IHashKeyCollection, IReadOnlyCollection, ICollection, ISet, ICollection, IStrongEnumerable.Enumerator> + public sealed partial class ImmutableHashSet : IImmutableSet, IReadOnlyCollection, ICollection, ISet, ICollection, IStrongEnumerable.Enumerator> #endif { /// @@ -102,8 +102,6 @@ public bool IsEmpty get { return this.Count == 0; } } - #region IHashKeyCollection Properties - /// /// See the interface. /// @@ -112,8 +110,6 @@ public IEqualityComparer KeyComparer get { return _equalityComparer; } } - #endregion - #region IImmutableSet Properties /// @@ -152,14 +148,6 @@ bool ICollection.IsSynchronized #endregion - /// - /// Gets the root node (for testing purposes). - /// - internal IBinaryTree Root - { - get { return _root; } - } - /// /// Gets a data structure that captures the current state of this map, as an input into a query or mutating function. /// diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableList_1.Builder.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableList_1.Builder.cs index 5f43b156cd6..fc75f69a594 100644 --- a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableList_1.Builder.cs +++ b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableList_1.Builder.cs @@ -28,7 +28,7 @@ public sealed partial class ImmutableList /// [DebuggerDisplay("Count = {Count}")] [DebuggerTypeProxy(typeof(ImmutableListBuilderDebuggerProxy<>))] - public sealed class Builder : IList, IList, IOrderedCollection, IImmutableListQueries, IReadOnlyList + public sealed class Builder : IList, IList, IReadOnlyList { /// /// The binary tree used to store the contents of the list. Contents are typically not entirely frozen. @@ -137,17 +137,6 @@ public T this[int index] } } - /// - /// Gets the element in the collection at a given index. - /// - T IOrderedCollection.this[int index] - { - get - { - return this[index]; - } - } - /// /// Gets a read-only reference to the value for a given index into the list. /// diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableList_1.Node.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableList_1.Node.cs index a83976402eb..03eae53582c 100644 --- a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableList_1.Node.cs +++ b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableList_1.Node.cs @@ -14,7 +14,7 @@ public sealed partial class ImmutableList /// A node in the AVL tree storing this set. /// [DebuggerDisplay("{_key}")] - internal sealed class Node : IBinaryTree, IEnumerable + internal sealed class Node : IEnumerable { /// /// The default empty node. @@ -120,31 +120,11 @@ public bool IsEmpty /// public Node? Left => _left; - /// - /// Gets the left branch of this node. - /// - IBinaryTree? IBinaryTree.Left => _left; - /// /// Gets the right branch of this node. /// public Node? Right => _right; - /// - /// Gets the right branch of this node. - /// - IBinaryTree? IBinaryTree.Right => _right; - - /// - /// Gets the left branch of this node. - /// - IBinaryTree? IBinaryTree.Left => _left; - - /// - /// Gets the right branch of this node. - /// - IBinaryTree? IBinaryTree.Right => _right; - /// /// Gets the value represented by the current node. /// @@ -260,7 +240,7 @@ private ref readonly T ItemRefUnchecked(int index) /// The starting index within that should be captured by the node tree. /// The number of elements from that should be captured by the node tree. /// The root of the created node tree. - internal static Node NodeTreeFromList(IOrderedCollection items, int start, int length) + internal static Node NodeTreeFromList(IReadOnlyList items, int start, int length) { Requires.NotNull(items, nameof(items)); Requires.Range(start >= 0, nameof(start)); @@ -597,7 +577,7 @@ internal Node Sort(Comparison comparison) var array = new T[this.Count]; this.CopyTo(array); Array.Sort(array, comparison); - return NodeTreeFromList(array.AsOrderedCollection(), 0, this.Count); + return NodeTreeFromList(array.AsReadOnlyList(), 0, this.Count); } /// @@ -636,7 +616,7 @@ internal Node Sort(int index, int count, IComparer? comparer) var array = new T[this.Count]; this.CopyTo(array); Array.Sort(array, index, count, comparer); - return NodeTreeFromList(array.AsOrderedCollection(), 0, this.Count); + return NodeTreeFromList(array.AsReadOnlyList(), 0, this.Count); } /// @@ -1578,7 +1558,7 @@ private static Node CreateRange(IEnumerable keys) return other._root; } - IOrderedCollection list = keys.AsOrderedCollection(); + IReadOnlyList list = keys.AsReadOnlyList(); return NodeTreeFromList(list, 0, list.Count); } diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableList_1.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableList_1.cs index e962b19d1a7..cdca30b5dd9 100644 --- a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableList_1.cs +++ b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableList_1.cs @@ -16,7 +16,7 @@ namespace System.Collections.Immutable [CollectionBuilder(typeof(ImmutableList), nameof(ImmutableList.Create))] [DebuggerDisplay("Count = {Count}")] [DebuggerTypeProxy(typeof(ImmutableEnumerableDebuggerProxy<>))] - public sealed partial class ImmutableList : IImmutableList, IList, IList, IOrderedCollection, IImmutableListQueries, IStrongEnumerable.Enumerator> + public sealed partial class ImmutableList : IImmutableList, IList, IList, IStrongEnumerable.Enumerator> { /// /// An empty immutable list. @@ -180,15 +180,6 @@ private ImmutableList(Node root) #endregion - #region IOrderedCollection Indexers - - /// - /// Gets the element in the collection at a given index. - /// - T IOrderedCollection.this[int index] => this[index]; - - #endregion - #region Public methods /// @@ -1097,11 +1088,6 @@ T IList.this[int index] /// public Enumerator GetEnumerator() => new Enumerator(_root); - /// - /// Returns the root of the list - /// - internal Node Root => _root; - /// /// Creates a new sorted set wrapper for a node tree. /// @@ -1191,7 +1177,7 @@ private static ImmutableList CreateRange(IEnumerable items) // index into that sequence like a list, so the one possible piece of // garbage produced is a temporary array to store the list while // we build the tree. - IOrderedCollection list = items.AsOrderedCollection(); + IReadOnlyList list = items.AsReadOnlyList(); if (list.Count == 0) { return Empty; diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedDictionary_2.Node.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedDictionary_2.Node.cs index 76330f19c18..280682da09e 100644 --- a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedDictionary_2.Node.cs +++ b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedDictionary_2.Node.cs @@ -14,7 +14,7 @@ public sealed partial class ImmutableSortedDictionary /// A node in the AVL tree storing this map. /// [DebuggerDisplay("{_key} = {_value}")] - internal sealed class Node : IBinaryTree>, IEnumerable> + internal sealed class Node : IEnumerable> { /// /// The default empty node. @@ -105,22 +105,6 @@ public bool IsEmpty } } - /// - /// Gets the left branch of this node. - /// - IBinaryTree>? IBinaryTree>.Left - { - get { return _left; } - } - - /// - /// Gets the right branch of this node. - /// - IBinaryTree>? IBinaryTree>.Right - { - get { return _right; } - } - /// /// Gets the height of the tree beneath this node. /// @@ -131,27 +115,11 @@ public bool IsEmpty /// public Node? Left { get { return _left; } } - /// - /// Gets the left branch of this node. - /// - IBinaryTree? IBinaryTree.Left - { - get { return _left; } - } - /// /// Gets the right branch of this node. /// public Node? Right { get { return _right; } } - /// - /// Gets the right branch of this node. - /// - IBinaryTree? IBinaryTree.Right - { - get { return _right; } - } - /// /// Gets the value represented by the current node. /// @@ -160,14 +128,6 @@ public KeyValuePair Value get { return new KeyValuePair(_key, _value); } } - /// - /// Gets the number of elements contained by this node and below. - /// - int IBinaryTree.Count - { - get { throw new NotSupportedException(); } - } - /// /// Gets the keys. /// @@ -272,7 +232,7 @@ internal static Node NodeTreeFromSortedDictionary(SortedDictionary { Requires.NotNull(dictionary, nameof(dictionary)); - IOrderedCollection> list = dictionary.AsOrderedCollection(); + IReadOnlyList> list = dictionary.AsReadOnlyList(); return NodeTreeFromList(list, 0, list.Count); } @@ -626,7 +586,7 @@ private static Node MakeBalanced(Node tree) /// The starting index within that should be captured by the node tree. /// The number of elements from that should be captured by the node tree. /// The root of the created node tree. - private static Node NodeTreeFromList(IOrderedCollection> items, int start, int length) + private static Node NodeTreeFromList(IReadOnlyList> items, int start, int length) { Requires.NotNull(items, nameof(items)); Requires.Range(start >= 0, nameof(start)); diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedDictionary_2.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedDictionary_2.cs index d44687253fa..ab7d775fd5c 100644 --- a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedDictionary_2.cs +++ b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedDictionary_2.cs @@ -16,7 +16,7 @@ namespace System.Collections.Immutable /// The type of the value. [DebuggerDisplay("Count = {Count}")] [DebuggerTypeProxy(typeof(ImmutableDictionaryDebuggerProxy<,>))] - public sealed partial class ImmutableSortedDictionary : IImmutableDictionary, ISortKeyCollection, IDictionary, IDictionary + public sealed partial class ImmutableSortedDictionary : IImmutableDictionary, IDictionary, IDictionary { /// /// An empty sorted dictionary with default sort and equality comparers. @@ -177,14 +177,6 @@ public IComparer KeyComparer #endregion - /// - /// Gets the root node (for testing purposes). - /// - internal Node Root - { - get { return _root; } - } - #region IImmutableMap Indexers /// diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedSet_1.Builder.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedSet_1.Builder.cs index 1aa94496f43..2f0a963972d 100644 --- a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedSet_1.Builder.cs +++ b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedSet_1.Builder.cs @@ -28,7 +28,7 @@ public sealed partial class ImmutableSortedSet /// [DebuggerDisplay("Count = {Count}")] [DebuggerTypeProxy(typeof(ImmutableSortedSetBuilderDebuggerProxy<>))] - public sealed class Builder : ISortKeyCollection, IReadOnlyCollection, ISet, ICollection + public sealed class Builder : IReadOnlyCollection, ISet, ICollection { /// /// The root of the binary tree that stores the collection. Contents are typically not entirely frozen. diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedSet_1.Node.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedSet_1.Node.cs index 8021f77ce38..f8168919661 100644 --- a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedSet_1.Node.cs +++ b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedSet_1.Node.cs @@ -13,7 +13,7 @@ public sealed partial class ImmutableSortedSet /// A node in the AVL tree storing this set. /// [DebuggerDisplay("{_key}")] - internal sealed class Node : IBinaryTree, IEnumerable + internal sealed class Node : IEnumerable { /// /// The default empty node. @@ -119,14 +119,6 @@ public Node? Left get { return _left; } } - /// - /// Gets the left branch of this node. - /// - IBinaryTree? IBinaryTree.Left - { - get { return _left; } - } - /// /// Gets the right branch of this node. /// @@ -135,30 +127,6 @@ public Node? Right get { return _right; } } - /// - /// Gets the right branch of this node. - /// - IBinaryTree? IBinaryTree.Right - { - get { return _right; } - } - - /// - /// Gets the left branch of this node. - /// - IBinaryTree? IBinaryTree.Left - { - get { return _left; } - } - - /// - /// Gets the right branch of this node. - /// - IBinaryTree? IBinaryTree.Right - { - get { return _right; } - } - /// /// Gets the value represented by the current node. /// @@ -750,7 +718,7 @@ private static Node MakeBalanced(Node tree) /// The starting index within that should be captured by the node tree. /// The number of elements from that should be captured by the node tree. /// The root of the created node tree. - internal static Node NodeTreeFromList(IOrderedCollection items, int start, int length) + internal static Node NodeTreeFromList(IReadOnlyList items, int start, int length) { Requires.NotNull(items, nameof(items)); Debug.Assert(start >= 0); diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedSet_1.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedSet_1.cs index ee1d369c6ea..b6f3bf81b0f 100644 --- a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedSet_1.cs +++ b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableSortedSet_1.cs @@ -21,9 +21,9 @@ namespace System.Collections.Immutable [DebuggerDisplay("Count = {Count}")] [DebuggerTypeProxy(typeof(ImmutableEnumerableDebuggerProxy<>))] #if NET - public sealed partial class ImmutableSortedSet : IImmutableSet, ISortKeyCollection, IReadOnlySet, IReadOnlyList, IList, ISet, IList, IStrongEnumerable.Enumerator> + public sealed partial class ImmutableSortedSet : IImmutableSet, IReadOnlySet, IReadOnlyList, IList, ISet, IList, IStrongEnumerable.Enumerator> #else - public sealed partial class ImmutableSortedSet : IImmutableSet, ISortKeyCollection, IReadOnlyList, IList, ISet, IList, IStrongEnumerable.Enumerator> + public sealed partial class ImmutableSortedSet : IImmutableSet, IReadOnlyList, IList, ISet, IList, IStrongEnumerable.Enumerator> #endif { /// @@ -119,26 +119,14 @@ public int Count #endregion - #region ISortKeyCollection Properties - /// - /// See the interface. + /// See the interface. /// public IComparer KeyComparer { get { return _comparer; } } - #endregion - - /// - /// Gets the root node (for testing purposes). - /// - internal IBinaryTree Root - { - get { return _root; } - } - #region IReadOnlyList Indexers /// @@ -1169,7 +1157,7 @@ private ImmutableSortedSet LeafToRootRefill(IEnumerable addedItems) list.RemoveRange(index, list.Count - index); // Use the now sorted list of unique items to construct a new sorted set. - Node root = Node.NodeTreeFromList(list.AsOrderedCollection(), 0, list.Count); + Node root = Node.NodeTreeFromList(list.AsReadOnlyList(), 0, list.Count); return this.Wrap(root); } @@ -1227,7 +1215,7 @@ private ImmutableSortedSet LeafToRootRefill(ReadOnlySpan addedItems) list.RemoveRange(index, list.Count - index); // Use the now sorted list of unique items to construct a new sorted set. - Node root = Node.NodeTreeFromList(list.AsOrderedCollection(), 0, list.Count); + Node root = Node.NodeTreeFromList(list.AsReadOnlyList(), 0, list.Count); return this.Wrap(root); } diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/SortedInt32KeyNode.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/SortedInt32KeyNode.cs index 08b011fc160..115f7403986 100644 --- a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/SortedInt32KeyNode.cs +++ b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/SortedInt32KeyNode.cs @@ -19,7 +19,7 @@ namespace System.Collections.Immutable /// the comparer's implementation. /// [DebuggerDisplay("{_key} = {_value}")] - internal sealed partial class SortedInt32KeyNode : IBinaryTree + internal sealed partial class SortedInt32KeyNode { /// /// The default empty node. @@ -114,24 +114,6 @@ private SortedInt32KeyNode(int key, TValue value, SortedInt32KeyNode lef /// public SortedInt32KeyNode? Right { get { return _right; } } - /// - /// Gets the left branch of this node. - /// - IBinaryTree? IBinaryTree.Left { get { return _left; } } - - /// - /// Gets the right branch of this node. - /// - IBinaryTree? IBinaryTree.Right { get { return _right; } } - - /// - /// Gets the number of elements contained by this node and below. - /// - int IBinaryTree.Count - { - get { throw new NotSupportedException(); } - } - /// /// Gets the value represented by the current node. /// diff --git a/src/libraries/System.Collections.Immutable/tests/BinaryTreeProxy.cs b/src/libraries/System.Collections.Immutable/tests/BinaryTreeProxy.cs new file mode 100644 index 00000000000..d1eba56cbbb --- /dev/null +++ b/src/libraries/System.Collections.Immutable/tests/BinaryTreeProxy.cs @@ -0,0 +1,25 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace System.Collections.Immutable.Tests +{ + /// + /// Defines a proxy class for accessing non-public binary tree implementation details. + /// + public sealed class BinaryTreeProxy(object underlyingValue, Type underlyingType) + { + public int Height => (int)GetProperty(nameof(Height)); + public bool IsEmpty => (bool)GetProperty(nameof(IsEmpty)); + public int Count => (int)GetProperty(nameof(Count)); + public BinaryTreeProxy? Left => GetProperty(nameof(Left)) is { } leftValue + ? new(leftValue, underlyingType) + : null; + + public BinaryTreeProxy? Right => GetProperty(nameof(Right)) is { } rightValue + ? new(rightValue, underlyingType) + : null; + + private object? GetProperty(string propertyName) + => underlyingType.GetProperty(propertyName)!.GetValue(underlyingValue); + } +} diff --git a/src/libraries/System.Collections.Immutable/tests/Frozen/KeyAnalyzerTests.cs b/src/libraries/System.Collections.Immutable/tests/Frozen/KeyAnalyzerTests.cs index 00a16bf3cef..7e82e00390f 100644 --- a/src/libraries/System.Collections.Immutable/tests/Frozen/KeyAnalyzerTests.cs +++ b/src/libraries/System.Collections.Immutable/tests/Frozen/KeyAnalyzerTests.cs @@ -1,7 +1,6 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System; using System.Collections.Generic; using System.Linq; using Xunit; diff --git a/src/libraries/System.Collections.Immutable/tests/ImmutableArrayBuilderTest.cs b/src/libraries/System.Collections.Immutable/tests/ImmutableArrayBuilderTest.cs index 6bac524a428..841bfc451e3 100644 --- a/src/libraries/System.Collections.Immutable/tests/ImmutableArrayBuilderTest.cs +++ b/src/libraries/System.Collections.Immutable/tests/ImmutableArrayBuilderTest.cs @@ -57,7 +57,7 @@ public void NormalConstructionValueType() [Fact] public void NormalConstructionRefType() { - var builder = new ImmutableArray.Builder(3); + var builder = ImmutableArray.CreateBuilder(); Assert.Equal(0, builder.Count); Assert.False(((ICollection)builder).IsReadOnly); for (int i = 0; i < builder.Count; i++) @@ -77,7 +77,7 @@ public void NormalConstructionRefType() [Fact] public void AddRangeIEnumerable() { - var builder = new ImmutableArray.Builder(2); + var builder = ImmutableArray.CreateBuilder(2); builder.AddRange((IEnumerable)new[] { 1 }); Assert.Equal(1, builder.Count); @@ -119,8 +119,8 @@ public void Add() [Fact] public void AddRangeBuilder() { - ImmutableArray.Builder builder1 = new ImmutableArray.Builder(2); - ImmutableArray.Builder builder2 = new ImmutableArray.Builder(2); + ImmutableArray.Builder builder1 = ImmutableArray.CreateBuilder(2); + ImmutableArray.Builder builder2 = ImmutableArray.CreateBuilder(2); builder1.AddRange(builder2); Assert.Equal(0, builder1.Count); @@ -137,7 +137,7 @@ public void AddRangeBuilder() [Fact] public void AddRangeImmutableArray() { - ImmutableArray.Builder builder1 = new ImmutableArray.Builder(2); + ImmutableArray.Builder builder1 = ImmutableArray.CreateBuilder(2); ImmutableArray array = ImmutableArray.Create(1, 2, 3); builder1.AddRange(array); @@ -154,8 +154,8 @@ public void AddRangeImmutableArray() Assert.Throws(() => builder1.AddRange(default(ImmutableArray))); builder1.AddRange(default(ImmutableArray), 42); - var builder2 = new ImmutableArray.Builder(); - builder2.AddRange(default(ImmutableArray)); + var builder2 = ImmutableArray.CreateBuilder(); + AssertExtensions.Throws(() => builder2.AddRange(default(ImmutableArray))); AssertExtensions.Throws("items", () => builder2.AddRange((ImmutableArray.Builder)null)); } @@ -164,7 +164,7 @@ public void AddRangeImmutableArray() public void AddRangeDerivedArray(string[] builderElements, string[] rangeElements, string[] expectedResult) { // Initialize builder - var builder = new ImmutableArray.Builder(); + var builder = ImmutableArray.CreateBuilder(); builder.AddRange(builderElements); // AddRange @@ -179,7 +179,7 @@ public void AddRangeDerivedArray(string[] builderElements, string[] rangeElement public void AddRangeSpan(string[] builderElements, string[] rangeElements, string[] expectedResult) { // Initialize builder - var builder = new ImmutableArray.Builder(); + var builder = ImmutableArray.CreateBuilder(); builder.AddRange(builderElements); // AddRange @@ -194,7 +194,7 @@ public void AddRangeSpan(string[] builderElements, string[] rangeElements, strin public void AddRangeDerivedSpan(string[] builderElements, string[] rangeElements, string[] expectedResult) { // Initialize builder - var builder = new ImmutableArray.Builder(); + var builder = ImmutableArray.CreateBuilder(); builder.AddRange(builderElements); // AddRange @@ -209,7 +209,7 @@ public void AddRangeDerivedSpan(string[] builderElements, string[] rangeElements public void AddRangeDerivedImmutableArray(string[] builderElements, string[] rangeElements, string[] expectedResult) { // Initialize builder - var builder = new ImmutableArray.Builder(); + var builder = ImmutableArray.CreateBuilder(); builder.AddRange(builderElements); // AddRange @@ -224,11 +224,11 @@ public void AddRangeDerivedImmutableArray(string[] builderElements, string[] ran public void AddRangeDerivedBuilder(string[] builderElements, string[] rangeElements, string[] expectedResult) { // Initialize builder - var builderBase = new ImmutableArray.Builder(); + var builderBase = ImmutableArray.CreateBuilder(); builderBase.AddRange(builderElements); // Prepare another builder to add - var builder = new ImmutableArray.Builder(); + var builder = ImmutableArray.CreateBuilder(); builder.AddRange(rangeElements); // AddRange @@ -241,7 +241,7 @@ public void AddRangeDerivedBuilder(string[] builderElements, string[] rangeEleme [Fact] public void Contains() { - var builder = new ImmutableArray.Builder(); + var builder = ImmutableArray.CreateBuilder(); Assert.False(builder.Contains(1)); builder.Add(1); Assert.True(builder.Contains(1)); @@ -283,7 +283,7 @@ public void LastIndexOf() [Fact] public void Insert() { - var builder = new ImmutableArray.Builder(); + var builder = ImmutableArray.CreateBuilder(); builder.AddRange(1, 2, 3); builder.Insert(1, 4); builder.Insert(4, 5); @@ -295,7 +295,7 @@ public void Insert() [Fact] public void InsertRange() { - var builder = new ImmutableArray.Builder(); + var builder = ImmutableArray.CreateBuilder(); builder.InsertRange(0, Enumerable.Range(1, 4)); Assert.Equal(new[] { 1, 2, 3, 4 }, builder); @@ -303,7 +303,7 @@ public void InsertRange() builder.InsertRange(1, Enumerable.Range(5, 2)); Assert.Equal(new[] { 1, 5, 6, 2, 3, 4 }, builder); - builder.InsertRange(0, new ImmutableArray(new int[] { 7, 8 })); + builder.InsertRange(0, ImmutableArray.Create(new int[] { 7, 8 })); Assert.Equal(new[] { 7, 8, 1, 5, 6, 2, 3, 4 }, builder); AssertExtensions.Throws("index", () => builder.InsertRange(-1, Enumerable.Range(1, 2))); @@ -317,7 +317,7 @@ public void InsertRange() [Fact] public void Remove() { - var builder = new ImmutableArray.Builder(); + var builder = ImmutableArray.CreateBuilder(); builder.AddRange(1, 2, 3, 4); Assert.True(builder.Remove(1)); Assert.False(builder.Remove(6)); @@ -346,7 +346,7 @@ public void Remove_EqualityComparer() [Fact] public void RemoveAt() { - var builder = new ImmutableArray.Builder(); + var builder = ImmutableArray.CreateBuilder(); builder.AddRange(1, 2, 3, 4); builder.RemoveAt(0); AssertExtensions.Throws("index", () => builder.RemoveAt(-1)); @@ -363,7 +363,7 @@ public void RemoveAt() [Fact] public void RemoveRange_ValueType() { - var builder = new ImmutableArray.Builder(); + var builder = ImmutableArray.CreateBuilder(); builder.AddRange(1, 2, 3, 4, 5); builder.RemoveRange(1, 2); @@ -386,7 +386,7 @@ public void RemoveRange_ValueType() [Fact] public void RemoveRange_ReferenceType() { - var builder = new ImmutableArray.Builder(); + var builder = ImmutableArray.CreateBuilder(); builder.AddRange(new GenericParameterHelper(1), new GenericParameterHelper(2), new GenericParameterHelper(3), new GenericParameterHelper(4)); builder.RemoveRange(1, 2); @@ -408,7 +408,7 @@ public void RemoveRange_EqualityComparer() [Fact] public void RemoveAll() { - var builder = new ImmutableArray.Builder(); + var builder = ImmutableArray.CreateBuilder(); builder.AddRange(Enumerable.Range(1, 8)); builder.RemoveAll(n => n % 2 == 0); @@ -418,7 +418,7 @@ public void RemoveAll() [Fact] public void ReverseContents() { - var builder = new ImmutableArray.Builder(); + var builder = ImmutableArray.CreateBuilder(); builder.AddRange(1, 2, 3, 4); builder.Reverse(); Assert.Equal(new[] { 4, 3, 2, 1 }, builder); @@ -443,7 +443,7 @@ public void ReverseContents() [Fact] public void Sort() { - var builder = new ImmutableArray.Builder(); + var builder = ImmutableArray.CreateBuilder(); builder.AddRange(2, 4, 1, 3); builder.Sort(); Assert.Equal(new[] { 1, 2, 3, 4 }, builder); @@ -452,7 +452,7 @@ public void Sort() [Fact] public void Sort_Comparison() { - var builder = new ImmutableArray.Builder(4); + var builder = ImmutableArray.CreateBuilder(4); builder.Sort((x, y) => y.CompareTo(x)); Assert.Equal(Array.Empty(), builder); @@ -491,17 +491,17 @@ public void SortOneElementArray() { int[] resultantArray = new[] { 4 }; - var builder1 = new ImmutableArray.Builder(); + var builder1 = ImmutableArray.CreateBuilder(); builder1.Add(4); builder1.Sort(); Assert.Equal(resultantArray, builder1); - var builder2 = new ImmutableArray.Builder(); + var builder2 = ImmutableArray.CreateBuilder(); builder2.Add(4); builder2.Sort(Comparer.Default); Assert.Equal(resultantArray, builder2); - var builder3 = new ImmutableArray.Builder(); + var builder3 = ImmutableArray.CreateBuilder(); builder3.Add(4); builder3.Sort(0, 1, Comparer.Default); Assert.Equal(resultantArray, builder3); @@ -510,7 +510,7 @@ public void SortOneElementArray() [Fact] public void SortRange() { - var builder = new ImmutableArray.Builder(); + var builder = ImmutableArray.CreateBuilder(); builder.AddRange(2, 4, 1, 3); AssertExtensions.Throws("index", () => builder.Sort(-1, 2, Comparer.Default)); AssertExtensions.Throws("count", () => builder.Sort(1, 4, Comparer.Default)); @@ -526,8 +526,8 @@ public void SortRange() [Fact] public void SortComparer() { - var builder1 = new ImmutableArray.Builder(); - var builder2 = new ImmutableArray.Builder(); + var builder1 = ImmutableArray.CreateBuilder(); + var builder2 = ImmutableArray.CreateBuilder(); builder1.AddRange("c", "B", "a"); builder2.AddRange("c", "B", "a"); builder1.Sort(StringComparer.OrdinalIgnoreCase); @@ -539,7 +539,7 @@ public void SortComparer() [Fact] public void Count() { - var builder = new ImmutableArray.Builder(3); + var builder = ImmutableArray.CreateBuilder(3); // Initial count is at zero, which is less than capacity. Assert.Equal(0, builder.Count); @@ -566,7 +566,7 @@ public void Count() [Fact] public void CountContract() { - var builder = new ImmutableArray.Builder(100); + var builder = ImmutableArray.CreateBuilder(100); builder.AddRange(Enumerable.Range(1, 100)); builder.Count = 10; Assert.Equal(Enumerable.Range(1, 10), builder); @@ -577,7 +577,7 @@ public void CountContract() [Fact] public void IndexSetter() { - var builder = new ImmutableArray.Builder(); + var builder = ImmutableArray.CreateBuilder(); Assert.Throws(() => builder[0] = 1); Assert.Throws(() => builder[-1] = 1); @@ -597,7 +597,7 @@ public void IndexSetter() [Fact] public void ToImmutable() { - var builder = new ImmutableArray.Builder(); + var builder = ImmutableArray.CreateBuilder(); builder.AddRange(1, 2, 3); ImmutableArray array = builder.ToImmutable(); @@ -617,7 +617,7 @@ public void ToImmutable() [Fact] public void ToImmutableArray() { - var builder = new ImmutableArray.Builder(); + var builder = ImmutableArray.CreateBuilder(); builder.AddRange(0, 1, 2); ImmutableArray array = builder.ToImmutableArray(); @@ -705,7 +705,7 @@ public void CopyToSpan() [Fact] public void Clear() { - var builder = new ImmutableArray.Builder(2); + var builder = ImmutableArray.CreateBuilder(2); builder.Add(1); builder.Add(1); builder.Clear(); @@ -716,7 +716,7 @@ public void Clear() [Fact] public void MutationsSucceedAfterToImmutable() { - var builder = new ImmutableArray.Builder(1); + var builder = ImmutableArray.CreateBuilder(1); builder.Add(1); ImmutableArray immutable = builder.ToImmutable(); builder[0] = 0; @@ -727,11 +727,11 @@ public void MutationsSucceedAfterToImmutable() [Fact] public void Enumerator() { - var empty = new ImmutableArray.Builder(0); + var empty = ImmutableArray.CreateBuilder(0); IEnumerator enumerator = empty.GetEnumerator(); Assert.False(enumerator.MoveNext()); - var manyElements = new ImmutableArray.Builder(3); + var manyElements = ImmutableArray.CreateBuilder(3); manyElements.AddRange(1, 2, 3); enumerator = manyElements.GetEnumerator(); @@ -748,11 +748,11 @@ public void Enumerator() [Fact] public void IEnumerator() { - var empty = new ImmutableArray.Builder(0); + var empty = ImmutableArray.CreateBuilder(0); IEnumerator enumerator = ((IEnumerable)empty).GetEnumerator(); Assert.False(enumerator.MoveNext()); - var manyElements = new ImmutableArray.Builder(3); + var manyElements = ImmutableArray.CreateBuilder(3); manyElements.AddRange(1, 2, 3); enumerator = ((IEnumerable)manyElements).GetEnumerator(); @@ -1108,7 +1108,7 @@ public static void TestDebuggerAttributes_Null() [Fact] public void ItemRef() { - var builder = new ImmutableArray.Builder(); + var builder = ImmutableArray.CreateBuilder(); builder.Add(1); builder.Add(2); builder.Add(3); @@ -1126,7 +1126,7 @@ public void ItemRef() [Fact] public void ItemRef_OutOfBounds() { - var builder = new ImmutableArray.Builder(); + var builder = ImmutableArray.CreateBuilder(); builder.Add(1); builder.Add(2); builder.Add(3); @@ -1143,7 +1143,7 @@ private static ImmutableArray.Builder CreateBuilderWithCount(int count) protected override IEnumerable GetEnumerableOf(params T[] contents) { - var builder = new ImmutableArray.Builder(contents.Length); + var builder = ImmutableArray.CreateBuilder(contents.Length); builder.AddRange(contents); return builder; } diff --git a/src/libraries/System.Collections.Immutable/tests/ImmutableDictionaryTest.nonnetstandard.cs b/src/libraries/System.Collections.Immutable/tests/ImmutableDictionaryTest.nonnetstandard.cs index c30e0738f37..d6ff8b49bf4 100644 --- a/src/libraries/System.Collections.Immutable/tests/ImmutableDictionaryTest.nonnetstandard.cs +++ b/src/libraries/System.Collections.Immutable/tests/ImmutableDictionaryTest.nonnetstandard.cs @@ -2,9 +2,6 @@ // The .NET Foundation licenses this file to you under the MIT license. using System.Collections.Generic; -using System.Diagnostics; -using System.Linq; -using System.Reflection; using Xunit; namespace System.Collections.Immutable.Tests @@ -25,14 +22,14 @@ public void EnumeratorWithHashCollisionsTest() this.EnumeratorTestHelper(emptyMap); } - internal override IBinaryTree GetRootNode(IImmutableDictionary dictionary) + internal override BinaryTreeProxy GetRootNode(IImmutableDictionary dictionary) { - return ((ImmutableDictionary)dictionary).Root; + return ((ImmutableDictionary)dictionary).GetBinaryTreeProxy(); } private void EmptyTestHelperHash(IImmutableDictionary empty, TKey someKey) { - Assert.Same(EqualityComparer.Default, ((IHashKeyCollection)empty).KeyComparer); + Assert.Same(EqualityComparer.Default, ((ImmutableDictionary)empty).KeyComparer); } } } diff --git a/src/libraries/System.Collections.Immutable/tests/ImmutableDictionaryTestBase.nonnetstandard.cs b/src/libraries/System.Collections.Immutable/tests/ImmutableDictionaryTestBase.nonnetstandard.cs index 97d1c2cfbed..2396991a33a 100644 --- a/src/libraries/System.Collections.Immutable/tests/ImmutableDictionaryTestBase.nonnetstandard.cs +++ b/src/libraries/System.Collections.Immutable/tests/ImmutableDictionaryTestBase.nonnetstandard.cs @@ -262,7 +262,7 @@ protected void EnumeratorTestHelper(IImmutableDictionary(() => manualEnum.Current); } - internal abstract IBinaryTree GetRootNode(IImmutableDictionary dictionary); + internal abstract BinaryTreeProxy GetRootNode(IImmutableDictionary dictionary); private static void KeysOrValuesTestHelper(ICollection collection, T containedValue) { @@ -287,7 +287,7 @@ private static void KeysOrValuesTestHelper(ICollection collection, T conta private void VerifyAvlTreeState(IImmutableDictionary dictionary) { - IBinaryTree rootNode = this.GetRootNode(dictionary); + BinaryTreeProxy rootNode = this.GetRootNode(dictionary); rootNode.VerifyBalanced(); rootNode.VerifyHeightIsWithinTolerance(dictionary.Count); } diff --git a/src/libraries/System.Collections.Immutable/tests/ImmutableHashSetTest.nonnetstandard.cs b/src/libraries/System.Collections.Immutable/tests/ImmutableHashSetTest.nonnetstandard.cs index 9ea7ce3d5c5..a8e7547945d 100644 --- a/src/libraries/System.Collections.Immutable/tests/ImmutableHashSetTest.nonnetstandard.cs +++ b/src/libraries/System.Collections.Immutable/tests/ImmutableHashSetTest.nonnetstandard.cs @@ -2,9 +2,6 @@ // The .NET Foundation licenses this file to you under the MIT license. using System.Collections.Generic; -using System.Diagnostics; -using System.Linq; -using System.Reflection; using Xunit; namespace System.Collections.Immutable.Tests @@ -24,9 +21,9 @@ public void TryGetValueTest() this.TryGetValueTestHelper(ImmutableHashSet.Empty.WithComparer(StringComparer.OrdinalIgnoreCase)); } - internal override IBinaryTree GetRootNode(IImmutableSet set) + internal override BinaryTreeProxy GetRootNode(IImmutableSet set) { - return ((ImmutableHashSet)set).Root; + return ((ImmutableHashSet)set).GetBinaryTreeProxy(); } /// @@ -42,7 +39,7 @@ private void EmptyTestHelper(IImmutableSet emptySet, T value, IEqualityCom this.EmptyTestHelper(emptySet); Assert.Same(emptySet, emptySet.ToImmutableHashSet(comparer)); - Assert.Same(comparer ?? EqualityComparer.Default, ((IHashKeyCollection)emptySet).KeyComparer); + Assert.Same(comparer ?? EqualityComparer.Default, ((ImmutableHashSet)emptySet).KeyComparer); if (comparer == null) { diff --git a/src/libraries/System.Collections.Immutable/tests/ImmutableListBuilderTest.cs b/src/libraries/System.Collections.Immutable/tests/ImmutableListBuilderTest.cs index 01bad4efa1b..741dfbd085c 100644 --- a/src/libraries/System.Collections.Immutable/tests/ImmutableListBuilderTest.cs +++ b/src/libraries/System.Collections.Immutable/tests/ImmutableListBuilderTest.cs @@ -435,7 +435,8 @@ public static void TestDebuggerAttributes_Null() public void ItemRef() { var list = new[] { 1, 2, 3 }.ToImmutableList(); - var builder = new ImmutableList.Builder(list); + var builder = ImmutableList.CreateBuilder(); + builder.AddRange(list); ref readonly int safeRef = ref builder.ItemRef(1); ref int unsafeRef = ref Unsafe.AsRef(in safeRef); @@ -451,7 +452,8 @@ public void ItemRef() public void ItemRef_OutOfBounds() { var list = new[] { 1, 2, 3 }.ToImmutableList(); - var builder = new ImmutableList.Builder(list); + var builder = ImmutableList.CreateBuilder(); + builder.AddRange(list); Assert.Throws(() => builder.ItemRef(5)); } @@ -483,7 +485,7 @@ public void ToImmutableList() protected override IEnumerable GetEnumerableOf(params T[] contents) { - return ImmutableList.Empty.AddRange((ReadOnlySpan)contents).ToBuilder(); + return ImmutableList.Empty.AddRange(contents).ToBuilder(); } protected override void RemoveAllTestHelper(ImmutableList list, Predicate test) @@ -506,9 +508,9 @@ protected override void ReverseTestHelper(ImmutableList list, int index, i Assert.Equal(expected, builder.ToList()); } - internal override IImmutableListQueries GetListQuery(ImmutableList list) + internal override ImmutableListQueries GetListQuery(ImmutableList list) { - return list.ToBuilder(); + return new ImmutableListBuilderQuery(list.ToBuilder()); } protected override List SortTestHelper(ImmutableList list) @@ -538,5 +540,29 @@ protected override List SortTestHelper(ImmutableList list, int index, i builder.Sort(index, count, comparer); return builder.ToImmutable().ToList(); } + + private sealed class ImmutableListBuilderQuery(ImmutableList.Builder list) : ImmutableListQueries(list) + { + public override int BinarySearch(T item) => list.BinarySearch(item); + public override int BinarySearch(T item, IComparer? comparer) => list.BinarySearch(item, comparer); + public override int BinarySearch(int index, int count, T item, IComparer? comparer) => list.BinarySearch(index, count, item, comparer); + public override ImmutableList ConvertAll(Func converter) => list.ConvertAll(converter); + public override void CopyTo(T[] array) => list.CopyTo(array); + public override void CopyTo(T[] array, int arrayIndex) => list.CopyTo(array, arrayIndex); + public override void CopyTo(int index, T[] array, int arrayIndex, int count) => list.CopyTo(index, array, arrayIndex, count); + public override bool Exists(Predicate match) => list.Exists(match); + public override T? Find(Predicate match) => list.Find(match); + public override ImmutableList FindAll(Predicate match) => list.FindAll(match); + public override int FindIndex(Predicate match) => list.FindIndex(match); + public override int FindIndex(int startIndex, Predicate match) => list.FindIndex(startIndex, match); + public override int FindIndex(int startIndex, int count, Predicate match) => list.FindIndex(startIndex, count, match); + public override T? FindLast(Predicate match) => list.FindLast(match); + public override int FindLastIndex(Predicate match) => list.FindLastIndex(match); + public override int FindLastIndex(int startIndex, Predicate match) => list.FindLastIndex(startIndex, match); + public override int FindLastIndex(int startIndex, int count, Predicate match) => list.FindLastIndex(startIndex, count, match); + public override void ForEach(Action action) => list.ForEach(action); + public override ImmutableList GetRange(int index, int count) => list.GetRange(index, count); + public override bool TrueForAll(Predicate match) => list.TrueForAll(match); + } } } diff --git a/src/libraries/System.Collections.Immutable/tests/ImmutableListQueries.cs b/src/libraries/System.Collections.Immutable/tests/ImmutableListQueries.cs new file mode 100644 index 00000000000..eedfda01ce5 --- /dev/null +++ b/src/libraries/System.Collections.Immutable/tests/ImmutableListQueries.cs @@ -0,0 +1,62 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Generic; + +namespace System.Collections.Immutable.Tests +{ + /// + /// Defines a bridging API for testing various immutable list implementations. + /// + public abstract class ImmutableListQueries(IList underlyingList) : ICollection, IList + { + public int Count => underlyingList.Count; + public T this[int index] => underlyingList[index]; + public abstract ImmutableList ConvertAll(Func converter); + public abstract void ForEach(Action action); + public abstract ImmutableList GetRange(int index, int count); + public abstract void CopyTo(T[] array); + public abstract void CopyTo(T[] array, int arrayIndex); + public abstract void CopyTo(int index, T[] array, int arrayIndex, int count); + public abstract bool Exists(Predicate match); + public abstract T? Find(Predicate match); + public abstract ImmutableList FindAll(Predicate match); + public abstract int FindIndex(Predicate match); + public abstract int FindIndex(int startIndex, Predicate match); + public abstract int FindIndex(int startIndex, int count, Predicate match); + public abstract T? FindLast(Predicate match); + public abstract int FindLastIndex(Predicate match); + public abstract int FindLastIndex(int startIndex, Predicate match); + public abstract int FindLastIndex(int startIndex, int count, Predicate match); + public abstract bool TrueForAll(Predicate match); + public abstract int BinarySearch(T item); + public abstract int BinarySearch(T item, IComparer? comparer); + public abstract int BinarySearch(int index, int count, T item, IComparer? comparer); + public IEnumerator GetEnumerator() => underlyingList.GetEnumerator(); + IEnumerator IEnumerable.GetEnumerator() => underlyingList.GetEnumerator(); + + + void ICollection.Add(T item) => underlyingList.Add(item); + void ICollection.Clear() => underlyingList.Clear(); + bool ICollection.Contains(T item) => underlyingList.Contains(item); + bool ICollection.Remove(T item) => underlyingList.Remove(item); + int IList.Add(object? value) => ((IList)underlyingList).Add(value); + void IList.Clear() => ((IList)underlyingList).Clear(); + bool IList.Contains(object? value) => ((IList)underlyingList).Contains(value); + int IList.IndexOf(object? value) => ((IList)underlyingList).IndexOf(value); + void IList.Insert(int index, object? value) => ((IList)underlyingList).Insert(index, value); + void IList.Remove(object? value) => ((IList)underlyingList).Remove(value); + void IList.RemoveAt(int index) => ((IList)underlyingList).RemoveAt(index); + void ICollection.CopyTo(Array array, int index) => ((ICollection)underlyingList).CopyTo(array, index); + bool ICollection.IsReadOnly => underlyingList.IsReadOnly; + bool IList.IsFixedSize => ((IList)underlyingList).IsFixedSize; + bool IList.IsReadOnly => ((IList)underlyingList).IsReadOnly; + bool ICollection.IsSynchronized => ((IList)underlyingList).IsSynchronized; + object ICollection.SyncRoot => ((IList)underlyingList).SyncRoot; + object? IList.this[int index] + { + get => underlyingList[index]; + set => underlyingList[index] = (T)value!; + } + } +} diff --git a/src/libraries/System.Collections.Immutable/tests/ImmutableListTest.cs b/src/libraries/System.Collections.Immutable/tests/ImmutableListTest.cs index b3e2e8bc30b..84fb7392466 100644 --- a/src/libraries/System.Collections.Immutable/tests/ImmutableListTest.cs +++ b/src/libraries/System.Collections.Immutable/tests/ImmutableListTest.cs @@ -206,7 +206,7 @@ public void AddRangeBalanceTest() Assert.Equal(Enumerable.Range(1, expectedTotalSize), list); - list.Root.VerifyHeightIsWithinTolerance(); + list.GetBinaryTreeProxy().VerifyHeightIsWithinTolerance(); } [Fact] @@ -235,10 +235,10 @@ public void InsertRangeRandomBalanceTest() list.InsertRange(startPosition, values); Assert.Equal(list, immutableList); - immutableList.Root.VerifyBalanced(); + immutableList.GetBinaryTreeProxy().VerifyBalanced(); } - immutableList.Root.VerifyHeightIsWithinTolerance(); + immutableList.GetBinaryTreeProxy().VerifyHeightIsWithinTolerance(); } [Fact] @@ -879,14 +879,14 @@ protected override List SortTestHelper(ImmutableList list, int index, i return list.Sort(index, count, comparer).ToList(); } - internal override IImmutableListQueries GetListQuery(ImmutableList list) + internal override ImmutableListQueries GetListQuery(ImmutableList list) { - return list; + return new ImmutableListQuery(list); } private static void VerifyBalanced(ImmutableList tree) { - tree.Root.VerifyBalanced(); + tree.GetBinaryTreeProxy().VerifyBalanced(); } private struct Person @@ -907,5 +907,29 @@ public int GetHashCode(Person obj) return obj.Name.GetHashCode(); } } + + private sealed class ImmutableListQuery(ImmutableList list) : ImmutableListQueries(list) + { + public override int BinarySearch(T item) => list.BinarySearch(item); + public override int BinarySearch(T item, IComparer? comparer) => list.BinarySearch(item, comparer); + public override int BinarySearch(int index, int count, T item, IComparer? comparer) => list.BinarySearch(index, count, item, comparer); + public override ImmutableList ConvertAll(Func converter) => list.ConvertAll(converter); + public override void CopyTo(T[] array) => list.CopyTo(array); + public override void CopyTo(T[] array, int arrayIndex) => list.CopyTo(array, arrayIndex); + public override void CopyTo(int index, T[] array, int arrayIndex, int count) => list.CopyTo(index, array, arrayIndex, count); + public override bool Exists(Predicate match) => list.Exists(match); + public override T? Find(Predicate match) => list.Find(match); + public override ImmutableList FindAll(Predicate match) => list.FindAll(match); + public override int FindIndex(Predicate match) => list.FindIndex(match); + public override int FindIndex(int startIndex, Predicate match) => list.FindIndex(startIndex, match); + public override int FindIndex(int startIndex, int count, Predicate match) => list.FindIndex(startIndex, count, match); + public override T? FindLast(Predicate match) => list.FindLast(match); + public override int FindLastIndex(Predicate match) => list.FindLastIndex(match); + public override int FindLastIndex(int startIndex, Predicate match) => list.FindLastIndex(startIndex, match); + public override int FindLastIndex(int startIndex, int count, Predicate match) => list.FindLastIndex(startIndex, count, match); + public override void ForEach(Action action) => list.ForEach(action); + public override ImmutableList GetRange(int index, int count) => list.GetRange(index, count); + public override bool TrueForAll(Predicate match) => list.TrueForAll(match); + } } } diff --git a/src/libraries/System.Collections.Immutable/tests/ImmutableListTestBase.cs b/src/libraries/System.Collections.Immutable/tests/ImmutableListTestBase.cs index 09eeac7214e..86640628603 100644 --- a/src/libraries/System.Collections.Immutable/tests/ImmutableListTestBase.cs +++ b/src/libraries/System.Collections.Immutable/tests/ImmutableListTestBase.cs @@ -14,7 +14,7 @@ public abstract class ImmutableListTestBase : SimpleElementImmutablesTestBase protected static readonly Func ContainsFunc = (l, v) => l.Contains(v); protected static readonly Func RemoveFunc = (l, v) => { l.Remove(v); return l.Count; }; - internal abstract IImmutableListQueries GetListQuery(ImmutableList list); + internal abstract ImmutableListQueries GetListQuery(ImmutableList list); [Fact] public void CopyToEmptyTest() @@ -29,7 +29,7 @@ public void CopyToEmptyTest() [Fact] public void CopyToTest() { - IImmutableListQueries listQuery = this.GetListQuery(ImmutableList.Create(1, 2)); + ImmutableListQueries listQuery = this.GetListQuery(ImmutableList.Create(1, 2)); var list = (IEnumerable)listQuery; var array = new int[2]; @@ -397,7 +397,7 @@ public void SortTest() public void BinarySearch() { var basis = new List(Enumerable.Range(1, 50).Select(n => n * 2)); - IImmutableListQueries query = this.GetListQuery(basis.ToImmutableList()); + ImmutableListQueries query = this.GetListQuery(basis.ToImmutableList()); for (int value = basis.First() - 1; value <= basis.Last() + 1; value++) { int expected = basis.BinarySearch(value); @@ -436,7 +436,7 @@ private void BinarySearchPartialSortedListHelper(ImmutableArray inputData, int max = inputData[sortedIndex + sortedLength - 1]; var basis = new List(inputData); - IImmutableListQueries query = this.GetListQuery(inputData.ToImmutableList()); + ImmutableListQueries query = this.GetListQuery(inputData.ToImmutableList()); for (int value = min - 1; value <= max + 1; value++) { for (int index = sortedIndex; index < sortedIndex + sortedLength; index++) // make sure the index we pass in is always within the sorted range in the list. diff --git a/src/libraries/System.Collections.Immutable/tests/ImmutableSetTest.nonnetstandard.cs b/src/libraries/System.Collections.Immutable/tests/ImmutableSetTest.nonnetstandard.cs index 821e0841920..34b6ded17bd 100644 --- a/src/libraries/System.Collections.Immutable/tests/ImmutableSetTest.nonnetstandard.cs +++ b/src/libraries/System.Collections.Immutable/tests/ImmutableSetTest.nonnetstandard.cs @@ -26,13 +26,9 @@ public void SymmetricExceptTest() [Fact] public void EnumeratorTest() { - IComparer comparer = null; IImmutableSet set = this.Empty(); - var sortedSet = set as ISortKeyCollection; - if (sortedSet != null) - { - comparer = sortedSet.KeyComparer; - } + Assert.True(set is ImmutableSortedSet or ImmutableHashSet); + IComparer? comparer = (set as ImmutableSortedSet)?.KeyComparer; this.EnumeratorTestHelper(set, comparer, 3, 5, 1); double[] data = this.GenerateDummyFillData(); @@ -54,7 +50,7 @@ public void UnionTest() this.UnionTestHelper(this.Empty().Union(new[] { 2 }), Enumerable.Range(0, 1000).ToArray()); } - internal abstract IBinaryTree GetRootNode(IImmutableSet set); + internal abstract BinaryTreeProxy GetRootNode(IImmutableSet set); protected void TryGetValueTestHelper(IImmutableSet set) { @@ -134,7 +130,7 @@ private void UnionTestHelper(IImmutableSet set, params T[] values) private void VerifyAvlTreeState(IImmutableSet set) { - IBinaryTree rootNode = this.GetRootNode(set); + BinaryTreeProxy rootNode = this.GetRootNode(set); rootNode.VerifyBalanced(); rootNode.VerifyHeightIsWithinTolerance(set.Count); } diff --git a/src/libraries/System.Collections.Immutable/tests/ImmutableSortedDictionaryTest.nonnetstandard.cs b/src/libraries/System.Collections.Immutable/tests/ImmutableSortedDictionaryTest.nonnetstandard.cs index f3a0cacefd0..970977ee806 100644 --- a/src/libraries/System.Collections.Immutable/tests/ImmutableSortedDictionaryTest.nonnetstandard.cs +++ b/src/libraries/System.Collections.Immutable/tests/ImmutableSortedDictionaryTest.nonnetstandard.cs @@ -13,9 +13,9 @@ namespace System.Collections.Immutable.Tests { public partial class ImmutableSortedDictionaryTest : ImmutableDictionaryTestBase { - internal override IBinaryTree GetRootNode(IImmutableDictionary dictionary) + internal override BinaryTreeProxy GetRootNode(IImmutableDictionary dictionary) { - return ((ImmutableSortedDictionary)dictionary).Root; + return ((ImmutableSortedDictionary)dictionary).GetBinaryTreeProxy(); } } } diff --git a/src/libraries/System.Collections.Immutable/tests/ImmutableSortedSetBuilderDebuggerProxyTest.cs b/src/libraries/System.Collections.Immutable/tests/ImmutableSortedSetBuilderDebuggerProxyTest.cs index 9b91a8bc37b..b9bdcda1f5d 100644 --- a/src/libraries/System.Collections.Immutable/tests/ImmutableSortedSetBuilderDebuggerProxyTest.cs +++ b/src/libraries/System.Collections.Immutable/tests/ImmutableSortedSetBuilderDebuggerProxyTest.cs @@ -4,6 +4,7 @@ using System.Collections.Generic; using System.Diagnostics; using System.Linq; +using System.Reflection; using Xunit; namespace System.Collections.Immutable.Tests @@ -15,10 +16,14 @@ public void DoesNotCacheContents() { ImmutableSortedSet set = ImmutableSortedSet.Empty.Add(1); ImmutableSortedSet.Builder builder = set.ToBuilder(); - var debuggerProxy = new ImmutableSortedSetBuilderDebuggerProxy(builder); - _ = debuggerProxy.Contents; // view the contents to trigger caching + DebuggerTypeProxyAttribute debuggerProxyAttribute = builder.GetType().GetCustomAttribute(); + Type debuggerProxyType = Type.GetType(debuggerProxyAttribute.ProxyTypeName).MakeGenericType(typeof(int)); + object debuggerProxy = Activator.CreateInstance(debuggerProxyType, [builder]); + _ = GetContents(); // view the contents to trigger caching builder.Add(2); - Assert.Equal(builder.ToArray(), debuggerProxy.Contents); + Assert.Equal(builder.ToArray(), GetContents()); + + ICollection GetContents() => (ICollection)debuggerProxyType.GetProperty("Contents").GetValue(debuggerProxy); } } } diff --git a/src/libraries/System.Collections.Immutable/tests/ImmutableSortedSetBuilderTest.nonnetstandard.cs b/src/libraries/System.Collections.Immutable/tests/ImmutableSortedSetBuilderTest.nonnetstandard.cs index 7b8dc5b3778..1ce51125d38 100644 --- a/src/libraries/System.Collections.Immutable/tests/ImmutableSortedSetBuilderTest.nonnetstandard.cs +++ b/src/libraries/System.Collections.Immutable/tests/ImmutableSortedSetBuilderTest.nonnetstandard.cs @@ -16,7 +16,11 @@ public partial class ImmutableSortedSetBuilderTest : ImmutablesTestBase public void ItemRef() { var array = new[] { 1, 2, 3 }.ToImmutableSortedSet(); - var builder = new ImmutableSortedSet.Builder(array); + var builder = ImmutableSortedSet.CreateBuilder(); + foreach (int item in array) + { + builder.Add(item); + } ref readonly int safeRef = ref builder.ItemRef(1); ref int unsafeRef = ref Unsafe.AsRef(in safeRef); @@ -32,7 +36,11 @@ public void ItemRef() public void ItemRef_OutOfBounds() { var array = new[] { 1, 2, 3 }.ToImmutableSortedSet(); - var builder = new ImmutableSortedSet.Builder(array); + var builder = ImmutableSortedSet.CreateBuilder(); + foreach (int item in array) + { + builder.Add(item); + } Assert.Throws(() => builder.ItemRef(5)); } diff --git a/src/libraries/System.Collections.Immutable/tests/ImmutableSortedSetTest.nonnetstandard.cs b/src/libraries/System.Collections.Immutable/tests/ImmutableSortedSetTest.nonnetstandard.cs index 32a91e0ebc3..7df72d18b19 100644 --- a/src/libraries/System.Collections.Immutable/tests/ImmutableSortedSetTest.nonnetstandard.cs +++ b/src/libraries/System.Collections.Immutable/tests/ImmutableSortedSetTest.nonnetstandard.cs @@ -26,9 +26,9 @@ public void TryGetValueTest() this.TryGetValueTestHelper(ImmutableSortedSet.Empty.WithComparer(StringComparer.OrdinalIgnoreCase)); } - internal override IBinaryTree GetRootNode(IImmutableSet set) + internal override BinaryTreeProxy GetRootNode(IImmutableSet set) { - return ((ImmutableSortedSet)set).Root; + return ((ImmutableSortedSet)set).GetBinaryTreeProxy(); } /// @@ -44,7 +44,7 @@ private void EmptyTestHelper(IImmutableSet emptySet, T value, IComparer this.EmptyTestHelper(emptySet); Assert.Same(emptySet, emptySet.ToImmutableSortedSet(comparer)); - Assert.Same(comparer ?? Comparer.Default, ((ISortKeyCollection)emptySet).KeyComparer); + Assert.Same(comparer ?? Comparer.Default, ((ImmutableSortedSet)emptySet).KeyComparer); IImmutableSet reemptied = emptySet.Add(value).Clear(); Assert.Same(reemptied, reemptied.ToImmutableSortedSet(comparer)); //, "Getting the empty set from a non-empty instance did not preserve the comparer."); diff --git a/src/libraries/System.Collections.Immutable/tests/System.Collections.Immutable.Tests.csproj b/src/libraries/System.Collections.Immutable/tests/System.Collections.Immutable.Tests.csproj index cc324a605ee..3f734f107c9 100644 --- a/src/libraries/System.Collections.Immutable/tests/System.Collections.Immutable.Tests.csproj +++ b/src/libraries/System.Collections.Immutable/tests/System.Collections.Immutable.Tests.csproj @@ -3,6 +3,7 @@ $(NoWarn);0436 $(NetCoreAppCurrent);$(NetFrameworkMinimum) true + true @@ -10,7 +11,13 @@ + + + + + + @@ -29,6 +36,7 @@ + diff --git a/src/libraries/System.Collections.Immutable/tests/TestExtensionsMethods.cs b/src/libraries/System.Collections.Immutable/tests/TestExtensionsMethods.cs index 6415cd41d5a..b96d74ed5d8 100644 --- a/src/libraries/System.Collections.Immutable/tests/TestExtensionsMethods.cs +++ b/src/libraries/System.Collections.Immutable/tests/TestExtensionsMethods.cs @@ -2,6 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. using System.Collections.Generic; +using System.Reflection; using Xunit; using Xunit.Sdk; @@ -33,5 +34,16 @@ internal static void ValidateDefaultThisBehavior(ReadOnlySpan span, throw ThrowsException.ForNoException(typeof(NullReferenceException)); } + + internal static BinaryTreeProxy GetBinaryTreeProxy(this IReadOnlyCollection value) + { + FieldInfo rootField = value.GetType().GetField("_root", BindingFlags.Instance | BindingFlags.NonPublic); + Assert.NotNull(rootField); + + object root = rootField.GetValue(value); + Assert.NotNull(root); + + return new BinaryTreeProxy(root, root.GetType()); + } } } diff --git a/src/libraries/System.Collections.Immutable/tests/TestExtensionsMethods.nonnetstandard.cs b/src/libraries/System.Collections.Immutable/tests/TestExtensionsMethods.nonnetstandard.cs index 7ea0f04c8cb..3ed71c361a4 100644 --- a/src/libraries/System.Collections.Immutable/tests/TestExtensionsMethods.nonnetstandard.cs +++ b/src/libraries/System.Collections.Immutable/tests/TestExtensionsMethods.nonnetstandard.cs @@ -36,7 +36,7 @@ internal static IDictionary ToBuilder(this IImmutabl /// Verifies that a binary tree is balanced according to AVL rules. /// /// The root node of the binary tree. - internal static void VerifyBalanced(this IBinaryTree node) + internal static void VerifyBalanced(this BinaryTreeProxy node) { if (node.Left != null) { @@ -66,8 +66,8 @@ internal static void VerifyBalanced(this IBinaryTree node) /// Verifies that a binary tree is no taller than necessary to store the data if it were optimally balanced. /// /// The root node. - /// The number of nodes in the tree. May be null if is functional. - internal static void VerifyHeightIsWithinTolerance(this IBinaryTree node, int? count = null) + /// The number of nodes in the tree. May be null if is functional. + internal static void VerifyHeightIsWithinTolerance(this BinaryTreeProxy node, int? count = null) { // http://en.wikipedia.org/wiki/AVL_tree double heightMustBeLessThan = Math.Log(2, s_GoldenRatio) * Math.Log(Math.Sqrt(5) * ((count ?? node.Count) + 2), 2) - 2; diff --git a/src/libraries/System.Collections.NonGeneric/System.Collections.NonGeneric.sln b/src/libraries/System.Collections.NonGeneric/System.Collections.NonGeneric.sln index bc948836055..a8a916a5171 100644 --- a/src/libraries/System.Collections.NonGeneric/System.Collections.NonGeneric.sln +++ b/src/libraries/System.Collections.NonGeneric/System.Collections.NonGeneric.sln @@ -7,7 +7,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Collections.NonGener EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Collections.NonGeneric.Tests", "tests\System.Collections.NonGeneric.Tests.csproj", "{AF7C053E-2774-4355-8541-945594C4AF9C}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{FC7A2623-48CD-4805-8C91-046D5E3D260F}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{5961687D-6523-4DB1-AF7D-8D434BFFA726}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{EC51C488-C247-436A-B610-C55A01DA3037}" EndProject @@ -61,10 +61,10 @@ Global {AF7C053E-2774-4355-8541-945594C4AF9C}.Debug|Any CPU.Build.0 = Debug|Any CPU {AF7C053E-2774-4355-8541-945594C4AF9C}.Release|Any CPU.ActiveCfg = Release|Any CPU {AF7C053E-2774-4355-8541-945594C4AF9C}.Release|Any CPU.Build.0 = Release|Any CPU - {FC7A2623-48CD-4805-8C91-046D5E3D260F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {FC7A2623-48CD-4805-8C91-046D5E3D260F}.Debug|Any CPU.Build.0 = Debug|Any CPU - {FC7A2623-48CD-4805-8C91-046D5E3D260F}.Release|Any CPU.ActiveCfg = Release|Any CPU - {FC7A2623-48CD-4805-8C91-046D5E3D260F}.Release|Any CPU.Build.0 = Release|Any CPU + {5961687D-6523-4DB1-AF7D-8D434BFFA726}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {5961687D-6523-4DB1-AF7D-8D434BFFA726}.Debug|Any CPU.Build.0 = Debug|Any CPU + {5961687D-6523-4DB1-AF7D-8D434BFFA726}.Release|Any CPU.ActiveCfg = Release|Any CPU + {5961687D-6523-4DB1-AF7D-8D434BFFA726}.Release|Any CPU.Build.0 = Release|Any CPU {EC51C488-C247-436A-B610-C55A01DA3037}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {EC51C488-C247-436A-B610-C55A01DA3037}.Debug|Any CPU.Build.0 = Debug|Any CPU {EC51C488-C247-436A-B610-C55A01DA3037}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -103,7 +103,7 @@ Global {D3B134E9-5B26-4455-9F2D-22302BD8E350} = {3F8044D4-DD3D-46CA-8EAE-CD03358DA425} {DEAD48C1-587C-459A-B62F-1EF6E03739C3} = {3F8044D4-DD3D-46CA-8EAE-CD03358DA425} {8B963C6C-CF59-433B-B8FB-6C1EB4650DF2} = {97782A88-6BFA-46E2-9027-E72BF7E3062E} - {FC7A2623-48CD-4805-8C91-046D5E3D260F} = {121A7C7D-3D67-4606-AE3E-4C9E55510A86} + {5961687D-6523-4DB1-AF7D-8D434BFFA726} = {121A7C7D-3D67-4606-AE3E-4C9E55510A86} {EC51C488-C247-436A-B610-C55A01DA3037} = {121A7C7D-3D67-4606-AE3E-4C9E55510A86} {57B529EF-80FE-4697-B949-4C474241DEC4} = {1DD8D515-13DD-4318-B9E9-FA5816B8C532} {B17AD940-28E8-41FD-AF9B-21F550441871} = {1DD8D515-13DD-4318-B9E9-FA5816B8C532} diff --git a/src/libraries/System.Collections.NonGeneric/tests/System.Collections.NonGeneric.Tests.csproj b/src/libraries/System.Collections.NonGeneric/tests/System.Collections.NonGeneric.Tests.csproj index 69a3250dd15..6b8a633698e 100644 --- a/src/libraries/System.Collections.NonGeneric/tests/System.Collections.NonGeneric.Tests.csproj +++ b/src/libraries/System.Collections.NonGeneric/tests/System.Collections.NonGeneric.Tests.csproj @@ -44,5 +44,10 @@ + + + diff --git a/src/libraries/System.Collections.Specialized/System.Collections.Specialized.sln b/src/libraries/System.Collections.Specialized/System.Collections.Specialized.sln index 4eb47716a24..40464e0a660 100644 --- a/src/libraries/System.Collections.Specialized/System.Collections.Specialized.sln +++ b/src/libraries/System.Collections.Specialized/System.Collections.Specialized.sln @@ -17,7 +17,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ComponentModel", ".. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ObjectModel", "..\System.ObjectModel\ref\System.ObjectModel.csproj", "{0EF89147-2673-4252-92FE-6771C129853A}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{C1FF9F3B-CDD2-493F-ACB6-C630FC5B3034}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{68A3F00B-E9CC-4943-8B89-475983BA3C44}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{66B6FD95-517D-47E6-B08B-382EB32DE466}" EndProject @@ -91,10 +91,10 @@ Global {0EF89147-2673-4252-92FE-6771C129853A}.Debug|Any CPU.Build.0 = Debug|Any CPU {0EF89147-2673-4252-92FE-6771C129853A}.Release|Any CPU.ActiveCfg = Release|Any CPU {0EF89147-2673-4252-92FE-6771C129853A}.Release|Any CPU.Build.0 = Release|Any CPU - {C1FF9F3B-CDD2-493F-ACB6-C630FC5B3034}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {C1FF9F3B-CDD2-493F-ACB6-C630FC5B3034}.Debug|Any CPU.Build.0 = Debug|Any CPU - {C1FF9F3B-CDD2-493F-ACB6-C630FC5B3034}.Release|Any CPU.ActiveCfg = Release|Any CPU - {C1FF9F3B-CDD2-493F-ACB6-C630FC5B3034}.Release|Any CPU.Build.0 = Release|Any CPU + {68A3F00B-E9CC-4943-8B89-475983BA3C44}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {68A3F00B-E9CC-4943-8B89-475983BA3C44}.Debug|Any CPU.Build.0 = Debug|Any CPU + {68A3F00B-E9CC-4943-8B89-475983BA3C44}.Release|Any CPU.ActiveCfg = Release|Any CPU + {68A3F00B-E9CC-4943-8B89-475983BA3C44}.Release|Any CPU.Build.0 = Release|Any CPU {66B6FD95-517D-47E6-B08B-382EB32DE466}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {66B6FD95-517D-47E6-B08B-382EB32DE466}.Debug|Any CPU.Build.0 = Debug|Any CPU {66B6FD95-517D-47E6-B08B-382EB32DE466}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -138,7 +138,7 @@ Global {0EF89147-2673-4252-92FE-6771C129853A} = {129030A4-7D4E-401C-9F7E-722D99DC8407} {97DA293F-0743-42EA-A0B4-0E8EE4249674} = {129030A4-7D4E-401C-9F7E-722D99DC8407} {FE0B5511-A5E1-4E19-A232-B89F628C417E} = {1799B533-6E09-44A9-BF2B-B723ADB5F2F2} - {C1FF9F3B-CDD2-493F-ACB6-C630FC5B3034} = {02B8FF7B-DDCB-4A38-A626-39877203DF37} + {68A3F00B-E9CC-4943-8B89-475983BA3C44} = {02B8FF7B-DDCB-4A38-A626-39877203DF37} {66B6FD95-517D-47E6-B08B-382EB32DE466} = {02B8FF7B-DDCB-4A38-A626-39877203DF37} {88E9D01A-6EA9-4887-8521-22631E4BE71C} = {EDEBAC03-9968-413D-9545-EE39F2FCC976} {2ADC895F-4F19-493B-8F07-67E655D81187} = {EDEBAC03-9968-413D-9545-EE39F2FCC976} diff --git a/src/libraries/System.Collections.Specialized/ref/System.Collections.Specialized.cs b/src/libraries/System.Collections.Specialized/ref/System.Collections.Specialized.cs index b91fe8eb108..c5bce875fe9 100644 --- a/src/libraries/System.Collections.Specialized/ref/System.Collections.Specialized.cs +++ b/src/libraries/System.Collections.Specialized/ref/System.Collections.Specialized.cs @@ -213,10 +213,10 @@ public StringCollection() { } bool System.Collections.IList.IsReadOnly { get { throw null; } } object? System.Collections.IList.this[int index] { get { throw null; } set { } } public int Add(string? value) { throw null; } - public void AddRange(string[] value) { } + public void AddRange(string?[] value) { } public void Clear() { } public bool Contains(string? value) { throw null; } - public void CopyTo(string[] array, int index) { } + public void CopyTo(string?[] array, int index) { } public System.Collections.Specialized.StringEnumerator GetEnumerator() { throw null; } public int IndexOf(string? value) { throw null; } public void Insert(int index, string? value) { } diff --git a/src/libraries/System.Collections.Specialized/src/System/Collections/Specialized/StringCollection.cs b/src/libraries/System.Collections.Specialized/src/System/Collections/Specialized/StringCollection.cs index ff0cba7fc19..b27aebf5de6 100644 --- a/src/libraries/System.Collections.Specialized/src/System/Collections/Specialized/StringCollection.cs +++ b/src/libraries/System.Collections.Specialized/src/System/Collections/Specialized/StringCollection.cs @@ -69,7 +69,7 @@ public int Add(string? value) /// /// Copies the elements of a string array to the end of the . /// - public void AddRange(string[] value) + public void AddRange(string?[] value) { ArgumentNullException.ThrowIfNull(value); @@ -99,7 +99,7 @@ public bool Contains(string? value) /// Copies the values to a one-dimensional instance at the /// specified index. /// - public void CopyTo(string[] array, int index) + public void CopyTo(string?[] array, int index) { data.CopyTo(array, index); } diff --git a/src/libraries/System.Collections.Specialized/tests/System.Collections.Specialized.Tests.csproj b/src/libraries/System.Collections.Specialized/tests/System.Collections.Specialized.Tests.csproj index d0e1a252098..364fd2adff7 100644 --- a/src/libraries/System.Collections.Specialized/tests/System.Collections.Specialized.Tests.csproj +++ b/src/libraries/System.Collections.Specialized/tests/System.Collections.Specialized.Tests.csproj @@ -75,5 +75,10 @@ + + + diff --git a/src/libraries/System.Collections/System.Collections.sln b/src/libraries/System.Collections/System.Collections.sln index 0eec5add565..c415f401f87 100644 --- a/src/libraries/System.Collections/System.Collections.sln +++ b/src/libraries/System.Collections/System.Collections.sln @@ -13,6 +13,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib.Gene EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\System.Private.CoreLib\ref\System.Private.CoreLib.csproj", "{2B114AFB-EB05-4615-B0AC-8FFF0D5D0D13}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{55082AD4-A4E3-464D-82A3-57D3DBC218E5}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{389B3CD7-FF7C-4004-A6BA-29B39B4BDF3A}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{00398A78-1620-4996-9922-C82D1AF84714}" @@ -220,6 +222,27 @@ Global {2B114AFB-EB05-4615-B0AC-8FFF0D5D0D13}.Checked|arm64.ActiveCfg = Debug|Any CPU {2B114AFB-EB05-4615-B0AC-8FFF0D5D0D13}.Checked|x64.ActiveCfg = Debug|Any CPU {2B114AFB-EB05-4615-B0AC-8FFF0D5D0D13}.Checked|x86.ActiveCfg = Debug|Any CPU + {55082AD4-A4E3-464D-82A3-57D3DBC218E5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {55082AD4-A4E3-464D-82A3-57D3DBC218E5}.Debug|Any CPU.Build.0 = Debug|Any CPU + {55082AD4-A4E3-464D-82A3-57D3DBC218E5}.Debug|arm.ActiveCfg = Debug|Any CPU + {55082AD4-A4E3-464D-82A3-57D3DBC218E5}.Debug|arm64.ActiveCfg = Debug|Any CPU + {55082AD4-A4E3-464D-82A3-57D3DBC218E5}.Debug|x64.ActiveCfg = Debug|Any CPU + {55082AD4-A4E3-464D-82A3-57D3DBC218E5}.Debug|x64.Build.0 = Debug|Any CPU + {55082AD4-A4E3-464D-82A3-57D3DBC218E5}.Debug|x86.ActiveCfg = Debug|Any CPU + {55082AD4-A4E3-464D-82A3-57D3DBC218E5}.Debug|x86.Build.0 = Debug|Any CPU + {55082AD4-A4E3-464D-82A3-57D3DBC218E5}.Release|Any CPU.ActiveCfg = Release|Any CPU + {55082AD4-A4E3-464D-82A3-57D3DBC218E5}.Release|Any CPU.Build.0 = Release|Any CPU + {55082AD4-A4E3-464D-82A3-57D3DBC218E5}.Release|arm.ActiveCfg = Release|Any CPU + {55082AD4-A4E3-464D-82A3-57D3DBC218E5}.Release|arm64.ActiveCfg = Release|Any CPU + {55082AD4-A4E3-464D-82A3-57D3DBC218E5}.Release|x64.ActiveCfg = Release|Any CPU + {55082AD4-A4E3-464D-82A3-57D3DBC218E5}.Release|x64.Build.0 = Release|Any CPU + {55082AD4-A4E3-464D-82A3-57D3DBC218E5}.Release|x86.ActiveCfg = Release|Any CPU + {55082AD4-A4E3-464D-82A3-57D3DBC218E5}.Release|x86.Build.0 = Release|Any CPU + {55082AD4-A4E3-464D-82A3-57D3DBC218E5}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {55082AD4-A4E3-464D-82A3-57D3DBC218E5}.Checked|arm.ActiveCfg = Debug|Any CPU + {55082AD4-A4E3-464D-82A3-57D3DBC218E5}.Checked|arm64.ActiveCfg = Debug|Any CPU + {55082AD4-A4E3-464D-82A3-57D3DBC218E5}.Checked|x64.ActiveCfg = Debug|Any CPU + {55082AD4-A4E3-464D-82A3-57D3DBC218E5}.Checked|x86.ActiveCfg = Debug|Any CPU {389B3CD7-FF7C-4004-A6BA-29B39B4BDF3A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {389B3CD7-FF7C-4004-A6BA-29B39B4BDF3A}.Debug|Any CPU.Build.0 = Debug|Any CPU {389B3CD7-FF7C-4004-A6BA-29B39B4BDF3A}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -401,6 +424,7 @@ Global {2B114AFB-EB05-4615-B0AC-8FFF0D5D0D13} = {06AE90FB-F007-4E70-BCD2-5CAD106A7C97} {EE21C87C-5515-45E1-9F94-F11BE4CEE2CA} = {06AE90FB-F007-4E70-BCD2-5CAD106A7C97} {F2E57833-4968-430D-8149-733DE03A7314} = {B958B834-96D2-4B18-AA42-22B312BE9925} + {55082AD4-A4E3-464D-82A3-57D3DBC218E5} = {B958B834-96D2-4B18-AA42-22B312BE9925} {389B3CD7-FF7C-4004-A6BA-29B39B4BDF3A} = {B958B834-96D2-4B18-AA42-22B312BE9925} {00398A78-1620-4996-9922-C82D1AF84714} = {B958B834-96D2-4B18-AA42-22B312BE9925} {C5B6496A-65D2-4215-9C55-49F4E3B64FDD} = {ECAFEE63-F771-4990-B11D-86F64675F943} diff --git a/src/libraries/System.Collections/src/System/Collections/Generic/PriorityQueue.cs b/src/libraries/System.Collections/src/System/Collections/Generic/PriorityQueue.cs index 5047b764337..c4d66bf14fd 100644 --- a/src/libraries/System.Collections/src/System/Collections/Generic/PriorityQueue.cs +++ b/src/libraries/System.Collections/src/System/Collections/Generic/PriorityQueue.cs @@ -532,16 +532,30 @@ public bool Remove( if (index < newSize) { // We're removing an element from the middle of the heap. - // Pop the last element in the collection and sift downward from the removed index. + // Pop the last element in the collection and sift from the removed index. (TElement Element, TPriority Priority) lastNode = nodes[newSize]; if (_comparer == null) { - MoveDownDefaultComparer(lastNode, index); + if (Comparer.Default.Compare(lastNode.Priority, priority) < 0) + { + MoveUpDefaultComparer(lastNode, index); + } + else + { + MoveDownDefaultComparer(lastNode, index); + } } else { - MoveDownCustomComparer(lastNode, index); + if (_comparer.Compare(lastNode.Priority, priority) < 0) + { + MoveUpCustomComparer(lastNode, index); + } + else + { + MoveDownCustomComparer(lastNode, index); + } } } diff --git a/src/libraries/System.Collections/tests/Generic/Dictionary/Dictionary.Tests.cs b/src/libraries/System.Collections/tests/Generic/Dictionary/Dictionary.Tests.cs index d7674f24de7..02a5a89db5c 100644 --- a/src/libraries/System.Collections/tests/Generic/Dictionary/Dictionary.Tests.cs +++ b/src/libraries/System.Collections/tests/Generic/Dictionary/Dictionary.Tests.cs @@ -452,6 +452,13 @@ private static void TestComparerSerialization(IEqualityComparer equalityCo s.Position = 0; dict = (Dictionary)bf.Deserialize(s); + if (equalityComparer.Equals(EqualityComparer.Default)) + { + // EqualityComparer.Default is mapped to StringEqualityComparer, but serialized as GenericEqualityComparer + Assert.Equal("System.Collections.Generic.GenericEqualityComparer`1[System.String]", dict.Comparer.GetType().ToString()); + return; + } + if (internalTypeName == null) { Assert.IsType(equalityComparer.GetType(), dict.Comparer); diff --git a/src/libraries/System.Collections/tests/Generic/HashSet/HashSet.Generic.Tests.cs b/src/libraries/System.Collections/tests/Generic/HashSet/HashSet.Generic.Tests.cs index e3d4829cdab..25a4803a5d1 100644 --- a/src/libraries/System.Collections/tests/Generic/HashSet/HashSet.Generic.Tests.cs +++ b/src/libraries/System.Collections/tests/Generic/HashSet/HashSet.Generic.Tests.cs @@ -886,6 +886,13 @@ static void TestComparerSerialization(IEqualityComparer eq s.Position = 0; set = (HashSet)bf.Deserialize(s); + if (equalityComparer.Equals(EqualityComparer.Default)) + { + // EqualityComparer.Default is mapped to StringEqualityComparer, but serialized as GenericEqualityComparer + Assert.Equal("System.Collections.Generic.GenericEqualityComparer`1[System.String]", set.Comparer.GetType().ToString()); + return; + } + if (internalTypeName == null) { Assert.IsType(equalityComparer.GetType(), set.Comparer); diff --git a/src/libraries/System.Collections/tests/Generic/HashSet/HashSet.NonGeneric.Tests.cs b/src/libraries/System.Collections/tests/Generic/HashSet/HashSet.NonGeneric.Tests.cs new file mode 100644 index 00000000000..94705efb6fc --- /dev/null +++ b/src/libraries/System.Collections/tests/Generic/HashSet/HashSet.NonGeneric.Tests.cs @@ -0,0 +1,39 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Generic; +using System.Reflection; +using System.Runtime.Serialization; +using Xunit; + +namespace System.Collections.Tests +{ + public static class HashSet_NonGeneric_Tests + { + [Fact] + public static void HashSet_CopyConstructor_ShouldWorkWithRandomizedEffectiveComparer() + { + HashSet set = CreateCopyWithRandomizedComparer(new HashSet() { "a", "b" }); + Assert.True(set.Contains("a")); + + HashSet copiedSet = new(set); + Assert.True(copiedSet.Contains("a")); + + static HashSet CreateCopyWithRandomizedComparer(HashSet set) + { + // To reproduce the bug, we need a HashSet instance that has fallen back to + // the randomized comparer. This typically happens when there are many collisions but + // it can also happen when the set is serialized and deserialized via ISerializable. + // For consistent results and to avoid brute forcing collisions, use the latter approach. + + SerializationInfo info = new(typeof(HashSet), new FormatterConverter()); + StreamingContext context = new(StreamingContextStates.All); + set.GetObjectData(info, context); + + HashSet copiedSet = (HashSet)Activator.CreateInstance(typeof(HashSet), BindingFlags.NonPublic | BindingFlags.Instance, null, [info, context], null); + copiedSet.OnDeserialization(null); + return copiedSet; + } + } + } +} diff --git a/src/libraries/System.Collections/tests/Generic/PriorityQueue/PriorityQueue.Tests.cs b/src/libraries/System.Collections/tests/Generic/PriorityQueue/PriorityQueue.Tests.cs index 03419ab9f6a..e5bd24a5dbf 100644 --- a/src/libraries/System.Collections/tests/Generic/PriorityQueue/PriorityQueue.Tests.cs +++ b/src/libraries/System.Collections/tests/Generic/PriorityQueue/PriorityQueue.Tests.cs @@ -266,6 +266,33 @@ public void PriorityQueue_EmptyCollection_Remove_ShouldReturnFalse() Assert.Null(removedPriority); } + [Fact] + public void PriorityQueue_LargeCollection_Remove_ShouldPreserveHeapInvariant() + { + // Regression test for https://github.com/dotnet/runtime/issues/107292 + + PriorityQueue queue = new(); + for (int i = 19; i >= 0; i--) + { + queue.Enqueue(i, i); + } + + queue.Remove(10, out int _, out int _); + + List sortedValues = queue.UnorderedItems + .OrderBy(e => e.Priority) + .Select(e => e.Element) + .ToList(); + + List dequeuedValues = new(); + while (queue.Count > 0) + { + dequeuedValues.Add(queue.Dequeue()); + } + + Assert.Equal(sortedValues, dequeuedValues); + } + #region EnsureCapacity, TrimExcess [Fact] diff --git a/src/libraries/System.Collections/tests/System.Collections.Tests.csproj b/src/libraries/System.Collections/tests/System.Collections.Tests.csproj index 83a763207a8..6445d52cb3d 100644 --- a/src/libraries/System.Collections/tests/System.Collections.Tests.csproj +++ b/src/libraries/System.Collections/tests/System.Collections.Tests.csproj @@ -4,6 +4,10 @@ true true + + + + @@ -28,6 +32,7 @@ + diff --git a/src/libraries/System.ComponentModel.Annotations/System.ComponentModel.Annotations.sln b/src/libraries/System.ComponentModel.Annotations/System.ComponentModel.Annotations.sln index 573c7c6dabd..ee52417bbcd 100644 --- a/src/libraries/System.ComponentModel.Annotations/System.ComponentModel.Annotations.sln +++ b/src/libraries/System.ComponentModel.Annotations/System.ComponentModel.Annotations.sln @@ -21,7 +21,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ObjectModel", "..\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Resources.Writer", "..\System.Resources.Writer\ref\System.Resources.Writer.csproj", "{F07A9522-62A3-4516-BAC2-6BE603D648D4}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{1E2C1B63-290E-409E-ACF8-22E2752D2936}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{AFE5764E-2C8C-4CC8-BEAA-25CAB765F2C4}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{FBE888A3-6DCE-4766-A4E4-D1748AC5B688}" EndProject @@ -103,10 +103,10 @@ Global {F07A9522-62A3-4516-BAC2-6BE603D648D4}.Debug|Any CPU.Build.0 = Debug|Any CPU {F07A9522-62A3-4516-BAC2-6BE603D648D4}.Release|Any CPU.ActiveCfg = Release|Any CPU {F07A9522-62A3-4516-BAC2-6BE603D648D4}.Release|Any CPU.Build.0 = Release|Any CPU - {1E2C1B63-290E-409E-ACF8-22E2752D2936}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {1E2C1B63-290E-409E-ACF8-22E2752D2936}.Debug|Any CPU.Build.0 = Debug|Any CPU - {1E2C1B63-290E-409E-ACF8-22E2752D2936}.Release|Any CPU.ActiveCfg = Release|Any CPU - {1E2C1B63-290E-409E-ACF8-22E2752D2936}.Release|Any CPU.Build.0 = Release|Any CPU + {AFE5764E-2C8C-4CC8-BEAA-25CAB765F2C4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {AFE5764E-2C8C-4CC8-BEAA-25CAB765F2C4}.Debug|Any CPU.Build.0 = Debug|Any CPU + {AFE5764E-2C8C-4CC8-BEAA-25CAB765F2C4}.Release|Any CPU.ActiveCfg = Release|Any CPU + {AFE5764E-2C8C-4CC8-BEAA-25CAB765F2C4}.Release|Any CPU.Build.0 = Release|Any CPU {FBE888A3-6DCE-4766-A4E4-D1748AC5B688}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {FBE888A3-6DCE-4766-A4E4-D1748AC5B688}.Debug|Any CPU.Build.0 = Debug|Any CPU {FBE888A3-6DCE-4766-A4E4-D1748AC5B688}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -152,7 +152,7 @@ Global {F07A9522-62A3-4516-BAC2-6BE603D648D4} = {52233040-4669-4A28-8E8F-A35F80039C13} {B19E6C6F-4950-495D-832B-7C998A5914A8} = {52233040-4669-4A28-8E8F-A35F80039C13} {B60893E1-864C-4236-9D4B-F17540DEED86} = {E1ABC6C6-D95F-4452-A9E2-7DAB63667861} - {1E2C1B63-290E-409E-ACF8-22E2752D2936} = {0BCBBCAE-BD70-482D-BA22-916184DB9EE6} + {AFE5764E-2C8C-4CC8-BEAA-25CAB765F2C4} = {0BCBBCAE-BD70-482D-BA22-916184DB9EE6} {FBE888A3-6DCE-4766-A4E4-D1748AC5B688} = {0BCBBCAE-BD70-482D-BA22-916184DB9EE6} {E46F0F08-A4BF-4496-875B-C78D35E97170} = {1ABC7D61-CAB5-48D2-979E-CBFE23EC7A2C} {8B4D69DD-7EF8-428C-B5F1-4815C6D4F9FC} = {1ABC7D61-CAB5-48D2-979E-CBFE23EC7A2C} diff --git a/src/libraries/System.ComponentModel.Annotations/tests/System.ComponentModel.Annotations.Tests.csproj b/src/libraries/System.ComponentModel.Annotations/tests/System.ComponentModel.Annotations.Tests.csproj index a7415591d31..9d330b2beeb 100644 --- a/src/libraries/System.ComponentModel.Annotations/tests/System.ComponentModel.Annotations.Tests.csproj +++ b/src/libraries/System.ComponentModel.Annotations/tests/System.ComponentModel.Annotations.Tests.csproj @@ -48,5 +48,10 @@ + + + diff --git a/src/libraries/System.ComponentModel.Composition.Registration/System.ComponentModel.Composition.Registration.sln b/src/libraries/System.ComponentModel.Composition.Registration/System.ComponentModel.Composition.Registration.sln index cad0a3680df..f7bbbc0e612 100644 --- a/src/libraries/System.ComponentModel.Composition.Registration/System.ComponentModel.Composition.Registration.sln +++ b/src/libraries/System.ComponentModel.Composition.Registration/System.ComponentModel.Composition.Registration.sln @@ -15,7 +15,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.Context", EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.Context", "..\System.Reflection.Context\src\System.Reflection.Context.csproj", "{9154CFB5-AC90-4BC7-BECB-3BB588356ABE}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{AFA86D76-CB87-4031-BF82-5B2E091F4CA7}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{5B31112F-6827-4952-83EC-19AB2B7E4779}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{70C60407-FA4F-47F9-8584-249E5528209D}" EndProject @@ -83,10 +83,10 @@ Global {9154CFB5-AC90-4BC7-BECB-3BB588356ABE}.Debug|Any CPU.Build.0 = Debug|Any CPU {9154CFB5-AC90-4BC7-BECB-3BB588356ABE}.Release|Any CPU.ActiveCfg = Release|Any CPU {9154CFB5-AC90-4BC7-BECB-3BB588356ABE}.Release|Any CPU.Build.0 = Release|Any CPU - {AFA86D76-CB87-4031-BF82-5B2E091F4CA7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {AFA86D76-CB87-4031-BF82-5B2E091F4CA7}.Debug|Any CPU.Build.0 = Debug|Any CPU - {AFA86D76-CB87-4031-BF82-5B2E091F4CA7}.Release|Any CPU.ActiveCfg = Release|Any CPU - {AFA86D76-CB87-4031-BF82-5B2E091F4CA7}.Release|Any CPU.Build.0 = Release|Any CPU + {5B31112F-6827-4952-83EC-19AB2B7E4779}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {5B31112F-6827-4952-83EC-19AB2B7E4779}.Debug|Any CPU.Build.0 = Debug|Any CPU + {5B31112F-6827-4952-83EC-19AB2B7E4779}.Release|Any CPU.ActiveCfg = Release|Any CPU + {5B31112F-6827-4952-83EC-19AB2B7E4779}.Release|Any CPU.Build.0 = Release|Any CPU {70C60407-FA4F-47F9-8584-249E5528209D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {70C60407-FA4F-47F9-8584-249E5528209D}.Debug|Any CPU.Build.0 = Debug|Any CPU {70C60407-FA4F-47F9-8584-249E5528209D}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -124,7 +124,7 @@ Global {E427BC70-0F51-4DA8-995A-AC46E8E3A31B} = {3D168EC8-5581-468D-BE77-0A787F5042F2} {D598C12E-CFC4-42A8-A6D2-99FC7F527179} = {3D168EC8-5581-468D-BE77-0A787F5042F2} {9154CFB5-AC90-4BC7-BECB-3BB588356ABE} = {3D168EC8-5581-468D-BE77-0A787F5042F2} - {AFA86D76-CB87-4031-BF82-5B2E091F4CA7} = {9A073A19-15DD-424C-A7B8-1DBEB11E690D} + {5B31112F-6827-4952-83EC-19AB2B7E4779} = {9A073A19-15DD-424C-A7B8-1DBEB11E690D} {70C60407-FA4F-47F9-8584-249E5528209D} = {9A073A19-15DD-424C-A7B8-1DBEB11E690D} {39035FBA-DD3B-434C-8E50-BD14EDAC5CC0} = {B083251E-8032-4B8D-A3C6-E54C5307F369} {3A398326-BE86-44B6-B643-83B18CBE3010} = {B083251E-8032-4B8D-A3C6-E54C5307F369} diff --git a/src/libraries/System.ComponentModel.Composition/System.ComponentModel.Composition.sln b/src/libraries/System.ComponentModel.Composition/System.ComponentModel.Composition.sln index 45bb16847f6..a8b3da99649 100644 --- a/src/libraries/System.ComponentModel.Composition/System.ComponentModel.Composition.sln +++ b/src/libraries/System.ComponentModel.Composition/System.ComponentModel.Composition.sln @@ -9,7 +9,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ComponentModel.Compo EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ComponentModel.Composition.Tests", "tests\System.ComponentModel.Composition.Tests.csproj", "{B21E5872-33E7-40D6-8A7F-33C0264A83E9}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{2BD2DB5E-FB31-43E3-9184-BEFE59786826}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{F0302673-94C7-424B-9810-797EC4D1CAFD}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{90E6CD04-1022-4A7A-B6DD-114C6F61ECA0}" EndProject @@ -65,10 +65,10 @@ Global {B21E5872-33E7-40D6-8A7F-33C0264A83E9}.Debug|Any CPU.Build.0 = Debug|Any CPU {B21E5872-33E7-40D6-8A7F-33C0264A83E9}.Release|Any CPU.ActiveCfg = Release|Any CPU {B21E5872-33E7-40D6-8A7F-33C0264A83E9}.Release|Any CPU.Build.0 = Release|Any CPU - {2BD2DB5E-FB31-43E3-9184-BEFE59786826}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {2BD2DB5E-FB31-43E3-9184-BEFE59786826}.Debug|Any CPU.Build.0 = Debug|Any CPU - {2BD2DB5E-FB31-43E3-9184-BEFE59786826}.Release|Any CPU.ActiveCfg = Release|Any CPU - {2BD2DB5E-FB31-43E3-9184-BEFE59786826}.Release|Any CPU.Build.0 = Release|Any CPU + {F0302673-94C7-424B-9810-797EC4D1CAFD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F0302673-94C7-424B-9810-797EC4D1CAFD}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F0302673-94C7-424B-9810-797EC4D1CAFD}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F0302673-94C7-424B-9810-797EC4D1CAFD}.Release|Any CPU.Build.0 = Release|Any CPU {90E6CD04-1022-4A7A-B6DD-114C6F61ECA0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {90E6CD04-1022-4A7A-B6DD-114C6F61ECA0}.Debug|Any CPU.Build.0 = Debug|Any CPU {90E6CD04-1022-4A7A-B6DD-114C6F61ECA0}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -103,7 +103,7 @@ Global {B21E5872-33E7-40D6-8A7F-33C0264A83E9} = {E041B502-1C74-4540-9D57-0924674899B0} {82F98B94-4E9D-457B-A391-F8F2766FBB2E} = {4857D2B5-405B-490F-BFC8-B730C8A3220A} {B1B4D6FA-25CA-4F88-A7B4-BEADC53E9613} = {56CC716E-A917-46F2-8238-D809E1AF9D17} - {2BD2DB5E-FB31-43E3-9184-BEFE59786826} = {902418FB-E47F-49F5-BC32-32E9022ECD94} + {F0302673-94C7-424B-9810-797EC4D1CAFD} = {902418FB-E47F-49F5-BC32-32E9022ECD94} {90E6CD04-1022-4A7A-B6DD-114C6F61ECA0} = {902418FB-E47F-49F5-BC32-32E9022ECD94} {72A42835-4702-4C72-862F-3252C0A0CE82} = {B0D89897-4981-4A40-9C6F-C35D89A028C4} {B51D1564-6DE7-470A-86AD-0813F5A848F0} = {B0D89897-4981-4A40-9C6F-C35D89A028C4} diff --git a/src/libraries/System.ComponentModel.Composition/src/System/ComponentModel/Composition/ReflectionModel/GenericServices.cs b/src/libraries/System.ComponentModel.Composition/src/System/ComponentModel/Composition/ReflectionModel/GenericServices.cs index 31560a94bfe..4c244f139fa 100644 --- a/src/libraries/System.ComponentModel.Composition/src/System/ComponentModel/Composition/ReflectionModel/GenericServices.cs +++ b/src/libraries/System.ComponentModel.Composition/src/System/ComponentModel/Composition/ReflectionModel/GenericServices.cs @@ -178,7 +178,7 @@ public static bool CanSpecialize(Type type, GenericParameterAttributes attribute if ((attributes & GenericParameterAttributes.DefaultConstructorConstraint) != 0) { // value types always have default constructors - if (!type.IsValueType && (type.GetConstructor(Type.EmptyTypes) == null)) + if (!type.IsValueType && ((type.GetConstructor(Type.EmptyTypes) == null) || type.IsAbstract)) { return false; } diff --git a/src/libraries/System.ComponentModel.EventBasedAsync/System.ComponentModel.EventBasedAsync.sln b/src/libraries/System.ComponentModel.EventBasedAsync/System.ComponentModel.EventBasedAsync.sln index 380c34d65a9..b66f72e28e9 100644 --- a/src/libraries/System.ComponentModel.EventBasedAsync/System.ComponentModel.EventBasedAsync.sln +++ b/src/libraries/System.ComponentModel.EventBasedAsync/System.ComponentModel.EventBasedAsync.sln @@ -17,7 +17,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ComponentModel", ".. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ObjectModel", "..\System.ObjectModel\ref\System.ObjectModel.csproj", "{5CA6A31A-C90D-4E90-A0B6-B9331EAB0215}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{DD873B5A-85F5-4C40-A33F-C998F5B5409D}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{CCD9E2A2-0F62-411E-8F5A-8900974A8706}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{AA09E7A5-58F5-4BAB-B6EE-B594F50C17E2}" EndProject @@ -93,10 +93,10 @@ Global {5CA6A31A-C90D-4E90-A0B6-B9331EAB0215}.Debug|Any CPU.Build.0 = Debug|Any CPU {5CA6A31A-C90D-4E90-A0B6-B9331EAB0215}.Release|Any CPU.ActiveCfg = Release|Any CPU {5CA6A31A-C90D-4E90-A0B6-B9331EAB0215}.Release|Any CPU.Build.0 = Release|Any CPU - {DD873B5A-85F5-4C40-A33F-C998F5B5409D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {DD873B5A-85F5-4C40-A33F-C998F5B5409D}.Debug|Any CPU.Build.0 = Debug|Any CPU - {DD873B5A-85F5-4C40-A33F-C998F5B5409D}.Release|Any CPU.ActiveCfg = Release|Any CPU - {DD873B5A-85F5-4C40-A33F-C998F5B5409D}.Release|Any CPU.Build.0 = Release|Any CPU + {CCD9E2A2-0F62-411E-8F5A-8900974A8706}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {CCD9E2A2-0F62-411E-8F5A-8900974A8706}.Debug|Any CPU.Build.0 = Debug|Any CPU + {CCD9E2A2-0F62-411E-8F5A-8900974A8706}.Release|Any CPU.ActiveCfg = Release|Any CPU + {CCD9E2A2-0F62-411E-8F5A-8900974A8706}.Release|Any CPU.Build.0 = Release|Any CPU {AA09E7A5-58F5-4BAB-B6EE-B594F50C17E2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {AA09E7A5-58F5-4BAB-B6EE-B594F50C17E2}.Debug|Any CPU.Build.0 = Debug|Any CPU {AA09E7A5-58F5-4BAB-B6EE-B594F50C17E2}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -145,7 +145,7 @@ Global {7E1B7EA2-4094-4D61-B976-757692346220} = {8F9719E0-3A02-421C-B564-64559817B4A7} {BC901D3C-2411-450F-9388-82989E188C44} = {8F9719E0-3A02-421C-B564-64559817B4A7} {04E0F296-DF67-45EB-8967-DADF4CBC9D6E} = {EEC4342D-1B9E-462C-98FE-2C8BC16B75BE} - {DD873B5A-85F5-4C40-A33F-C998F5B5409D} = {B2151F7B-8333-4467-B311-145FAD7BC484} + {CCD9E2A2-0F62-411E-8F5A-8900974A8706} = {B2151F7B-8333-4467-B311-145FAD7BC484} {AA09E7A5-58F5-4BAB-B6EE-B594F50C17E2} = {B2151F7B-8333-4467-B311-145FAD7BC484} {561B4C1F-875F-43FB-A069-3CC73D47E675} = {C21AB887-8CD7-4FEB-A348-AA43A527CD36} {A211DB21-34D0-4256-BF48-EA8EE9E74674} = {C21AB887-8CD7-4FEB-A348-AA43A527CD36} diff --git a/src/libraries/System.ComponentModel.Primitives/System.ComponentModel.Primitives.sln b/src/libraries/System.ComponentModel.Primitives/System.ComponentModel.Primitives.sln index 77cea00a067..ad1a35a85ad 100644 --- a/src/libraries/System.ComponentModel.Primitives/System.ComponentModel.Primitives.sln +++ b/src/libraries/System.ComponentModel.Primitives/System.ComponentModel.Primitives.sln @@ -15,7 +15,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ComponentModel", ".. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ObjectModel", "..\System.ObjectModel\ref\System.ObjectModel.csproj", "{ED792312-6FED-4E9D-A7AB-2AB10D153C3E}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{E8CC2715-0EA3-4ADC-9896-508FB1E7349A}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{E184013C-6350-43BC-BA9F-8F7F23882066}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{BE0F37D2-BEF7-4365-AFFB-B08271D25844}" EndProject @@ -85,10 +85,10 @@ Global {ED792312-6FED-4E9D-A7AB-2AB10D153C3E}.Debug|Any CPU.Build.0 = Debug|Any CPU {ED792312-6FED-4E9D-A7AB-2AB10D153C3E}.Release|Any CPU.ActiveCfg = Release|Any CPU {ED792312-6FED-4E9D-A7AB-2AB10D153C3E}.Release|Any CPU.Build.0 = Release|Any CPU - {E8CC2715-0EA3-4ADC-9896-508FB1E7349A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {E8CC2715-0EA3-4ADC-9896-508FB1E7349A}.Debug|Any CPU.Build.0 = Debug|Any CPU - {E8CC2715-0EA3-4ADC-9896-508FB1E7349A}.Release|Any CPU.ActiveCfg = Release|Any CPU - {E8CC2715-0EA3-4ADC-9896-508FB1E7349A}.Release|Any CPU.Build.0 = Release|Any CPU + {E184013C-6350-43BC-BA9F-8F7F23882066}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E184013C-6350-43BC-BA9F-8F7F23882066}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E184013C-6350-43BC-BA9F-8F7F23882066}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E184013C-6350-43BC-BA9F-8F7F23882066}.Release|Any CPU.Build.0 = Release|Any CPU {BE0F37D2-BEF7-4365-AFFB-B08271D25844}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {BE0F37D2-BEF7-4365-AFFB-B08271D25844}.Debug|Any CPU.Build.0 = Debug|Any CPU {BE0F37D2-BEF7-4365-AFFB-B08271D25844}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -131,7 +131,7 @@ Global {ED792312-6FED-4E9D-A7AB-2AB10D153C3E} = {4D0700F8-3BC3-4CE5-8258-1004C0BD007D} {1B341E00-2D7F-496B-B905-AF508EF41A91} = {4D0700F8-3BC3-4CE5-8258-1004C0BD007D} {E6024DD2-79AD-4639-A141-9DA38282F61B} = {F199F24A-6408-4204-84CF-7A2C9ED758CA} - {E8CC2715-0EA3-4ADC-9896-508FB1E7349A} = {2D5F3044-9A0F-46C5-B714-7816F501604F} + {E184013C-6350-43BC-BA9F-8F7F23882066} = {2D5F3044-9A0F-46C5-B714-7816F501604F} {BE0F37D2-BEF7-4365-AFFB-B08271D25844} = {2D5F3044-9A0F-46C5-B714-7816F501604F} {26DCFFF8-A1AD-4682-ABC1-9FC9DF35C431} = {17F1014E-DBFF-4CF1-9C8B-A8080658B433} {2E0222A0-8756-4377-845A-2E41AEA621E3} = {17F1014E-DBFF-4CF1-9C8B-A8080658B433} diff --git a/src/libraries/System.ComponentModel.Primitives/tests/System.ComponentModel.Primitives.Tests.csproj b/src/libraries/System.ComponentModel.Primitives/tests/System.ComponentModel.Primitives.Tests.csproj index 80d60eb2991..21017a070be 100644 --- a/src/libraries/System.ComponentModel.Primitives/tests/System.ComponentModel.Primitives.Tests.csproj +++ b/src/libraries/System.ComponentModel.Primitives/tests/System.ComponentModel.Primitives.Tests.csproj @@ -26,5 +26,10 @@ + + + \ No newline at end of file diff --git a/src/libraries/System.ComponentModel.TypeConverter/System.ComponentModel.TypeConverter.sln b/src/libraries/System.ComponentModel.TypeConverter/System.ComponentModel.TypeConverter.sln index e033bb82d48..7ddd00ef9f8 100644 --- a/src/libraries/System.ComponentModel.TypeConverter/System.ComponentModel.TypeConverter.sln +++ b/src/libraries/System.ComponentModel.TypeConverter/System.ComponentModel.TypeConverter.sln @@ -21,6 +21,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Resources.Writer", " EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{CD069E8D-AA7A-4958-B872-932CBA5EABFE}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{E67AC8F4-B8AE-4E0B-9BB5-CBE9884ADFB0}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{113EA49F-2525-47A0-AD4D-EA510476F50B}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{970B0849-990C-4368-B317-063BFD82CAD5}" @@ -105,6 +107,10 @@ Global {CD069E8D-AA7A-4958-B872-932CBA5EABFE}.Debug|Any CPU.Build.0 = Debug|Any CPU {CD069E8D-AA7A-4958-B872-932CBA5EABFE}.Release|Any CPU.ActiveCfg = Release|Any CPU {CD069E8D-AA7A-4958-B872-932CBA5EABFE}.Release|Any CPU.Build.0 = Release|Any CPU + {E67AC8F4-B8AE-4E0B-9BB5-CBE9884ADFB0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E67AC8F4-B8AE-4E0B-9BB5-CBE9884ADFB0}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E67AC8F4-B8AE-4E0B-9BB5-CBE9884ADFB0}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E67AC8F4-B8AE-4E0B-9BB5-CBE9884ADFB0}.Release|Any CPU.Build.0 = Release|Any CPU {113EA49F-2525-47A0-AD4D-EA510476F50B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {113EA49F-2525-47A0-AD4D-EA510476F50B}.Debug|Any CPU.Build.0 = Debug|Any CPU {113EA49F-2525-47A0-AD4D-EA510476F50B}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -158,6 +164,7 @@ Global {AA260434-0F27-4878-8883-1B9690421BD2} = {2F8CF65B-8616-42BC-A893-8C7C9FD990C5} {CE7DA286-D119-4087-A953-D542727AFA02} = {CD3CE573-0987-4590-8D30-EE1F1296D931} {CD069E8D-AA7A-4958-B872-932CBA5EABFE} = {D06EAE06-636A-4A7A-B22F-5D106F7CCC75} + {E67AC8F4-B8AE-4E0B-9BB5-CBE9884ADFB0} = {D06EAE06-636A-4A7A-B22F-5D106F7CCC75} {113EA49F-2525-47A0-AD4D-EA510476F50B} = {D06EAE06-636A-4A7A-B22F-5D106F7CCC75} {970B0849-990C-4368-B317-063BFD82CAD5} = {D06EAE06-636A-4A7A-B22F-5D106F7CCC75} {B681D74E-6DAD-4C73-9EEF-CB1C17063E32} = {D06EAE06-636A-4A7A-B22F-5D106F7CCC75} diff --git a/src/libraries/System.ComponentModel.TypeConverter/src/ILLink/ILLink.Substitutions.xml b/src/libraries/System.ComponentModel.TypeConverter/src/ILLink/ILLink.Substitutions.xml deleted file mode 100644 index d5df6acfa1c..00000000000 --- a/src/libraries/System.ComponentModel.TypeConverter/src/ILLink/ILLink.Substitutions.xml +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/src/libraries/System.ComponentModel.TypeConverter/src/System.ComponentModel.TypeConverter.csproj b/src/libraries/System.ComponentModel.TypeConverter/src/System.ComponentModel.TypeConverter.csproj index 6979742610c..874d860b1bd 100644 --- a/src/libraries/System.ComponentModel.TypeConverter/src/System.ComponentModel.TypeConverter.csproj +++ b/src/libraries/System.ComponentModel.TypeConverter/src/System.ComponentModel.TypeConverter.csproj @@ -7,10 +7,6 @@ false - - - - diff --git a/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/AmbientValueAttribute.cs b/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/AmbientValueAttribute.cs index ae52e7ebc93..72dc418fc44 100644 --- a/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/AmbientValueAttribute.cs +++ b/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/AmbientValueAttribute.cs @@ -18,6 +18,7 @@ public sealed class AmbientValueAttribute : Attribute /// This is the default value. /// private object? _value; + private static readonly object? s_throwSentinel = IDesignerHost.IsSupported ? null : new(); /// /// Initializes a new instance of the class, converting the @@ -32,6 +33,7 @@ public AmbientValueAttribute([DynamicallyAccessedMembers(DynamicallyAccessedMemb Debug.Assert(IDesignerHost.IsSupported, "Runtime instantiation of this attribute is not allowed with trimming."); if (!IDesignerHost.IsSupported) { + _value = s_throwSentinel; return; } @@ -142,7 +144,7 @@ public AmbientValueAttribute(object? value) public object? Value { get { - if (!IDesignerHost.IsSupported) + if (!IDesignerHost.IsSupported && ReferenceEquals(_value, s_throwSentinel)) { throw new ArgumentException(SR.RuntimeInstanceNotAllowed); } diff --git a/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/Design/DesigntimeLicenseContextSerializer.cs b/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/Design/DesigntimeLicenseContextSerializer.cs index 9c23426554e..8949472330c 100644 --- a/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/Design/DesigntimeLicenseContextSerializer.cs +++ b/src/libraries/System.ComponentModel.TypeConverter/src/System/ComponentModel/Design/DesigntimeLicenseContextSerializer.cs @@ -17,6 +17,7 @@ public class DesigntimeLicenseContextSerializer { internal const byte BinaryWriterMagic = 255; + [FeatureSwitchDefinition("System.ComponentModel.TypeConverter.EnableUnsafeBinaryFormatterInDesigntimeLicenseContextSerialization")] private static bool EnableUnsafeBinaryFormatterInDesigntimeLicenseContextSerialization { get; } = AppContext.TryGetSwitch("System.ComponentModel.TypeConverter.EnableUnsafeBinaryFormatterInDesigntimeLicenseContextSerialization", out bool isEnabled) ? isEnabled : false; // Not creatable. diff --git a/src/libraries/System.ComponentModel.TypeConverter/src/System/Security/Authentication/ExtendedProtection/ExtendedProtectionPolicyTypeConverter.cs b/src/libraries/System.ComponentModel.TypeConverter/src/System/Security/Authentication/ExtendedProtection/ExtendedProtectionPolicyTypeConverter.cs index c918ac07258..9672c785a63 100644 --- a/src/libraries/System.ComponentModel.TypeConverter/src/System/Security/Authentication/ExtendedProtection/ExtendedProtectionPolicyTypeConverter.cs +++ b/src/libraries/System.ComponentModel.TypeConverter/src/System/Security/Authentication/ExtendedProtection/ExtendedProtectionPolicyTypeConverter.cs @@ -21,6 +21,8 @@ public override bool CanConvertTo(ITypeDescriptorContext? context, [NotNullWhen( [UnsupportedOSPlatform("browser")] public override object? ConvertTo(ITypeDescriptorContext? context, CultureInfo? culture, object? value, Type destinationType) { + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 + if (destinationType == typeof(InstanceDescriptor)) { if (value is ExtendedProtectionPolicy policy) diff --git a/src/libraries/System.ComponentModel.TypeConverter/tests/AmbientValueAttributeTests.cs b/src/libraries/System.ComponentModel.TypeConverter/tests/AmbientValueAttributeTests.cs index 1773c5d5b6f..9af0e61f424 100644 --- a/src/libraries/System.ComponentModel.TypeConverter/tests/AmbientValueAttributeTests.cs +++ b/src/libraries/System.ComponentModel.TypeConverter/tests/AmbientValueAttributeTests.cs @@ -8,7 +8,9 @@ namespace System.ComponentModel.Tests { public class AmbientValueAttributeTests { - [Theory] + public static bool IDesignerHostIsSupported => AppContext.TryGetSwitch("System.ComponentModel.Design.IDesignerHost.IsSupported", out bool isSupported) ? isSupported : true; + + [ConditionalTheory(nameof(IDesignerHostIsSupported))] [InlineData(null, null, null)] [InlineData(typeof(int*), "1", null)] [InlineData(typeof(string), "1", "1")] diff --git a/src/libraries/System.ComponentModel.TypeConverter/tests/Security/Authentication/ExtendedProtection/ExtendedProtectionPolicyTypeConverterTests.cs b/src/libraries/System.ComponentModel.TypeConverter/tests/Security/Authentication/ExtendedProtection/ExtendedProtectionPolicyTypeConverterTests.cs index 82676a7f3f6..5a00c40b8da 100644 --- a/src/libraries/System.ComponentModel.TypeConverter/tests/Security/Authentication/ExtendedProtection/ExtendedProtectionPolicyTypeConverterTests.cs +++ b/src/libraries/System.ComponentModel.TypeConverter/tests/Security/Authentication/ExtendedProtection/ExtendedProtectionPolicyTypeConverterTests.cs @@ -58,6 +58,7 @@ public void ConvertTo_PositiveTests() [Theory] [SkipOnPlatform(TestPlatforms.Browser, "System.Net.Security is not supported on this platform.")] + [SkipOnPlatform(TestPlatforms.Wasi, "System.Net.Security is not supported on this platform.")] [InlineData(typeof(int))] [InlineData(typeof(ExtendedProtectionPolicy))] [InlineData(typeof(bool))] diff --git a/src/libraries/System.ComponentModel.TypeConverter/tests/System.ComponentModel.TypeConverter.Tests.csproj b/src/libraries/System.ComponentModel.TypeConverter/tests/System.ComponentModel.TypeConverter.Tests.csproj index 6abc8b4552e..0b536e69264 100644 --- a/src/libraries/System.ComponentModel.TypeConverter/tests/System.ComponentModel.TypeConverter.Tests.csproj +++ b/src/libraries/System.ComponentModel.TypeConverter/tests/System.ComponentModel.TypeConverter.Tests.csproj @@ -166,6 +166,10 @@ + + diff --git a/src/libraries/System.ComponentModel.TypeConverter/tests/ToolboxItemAttributeTests.cs b/src/libraries/System.ComponentModel.TypeConverter/tests/ToolboxItemAttributeTests.cs index d073840ed06..9b8210b9235 100644 --- a/src/libraries/System.ComponentModel.TypeConverter/tests/ToolboxItemAttributeTests.cs +++ b/src/libraries/System.ComponentModel.TypeConverter/tests/ToolboxItemAttributeTests.cs @@ -8,11 +8,19 @@ namespace System.ComponentModel { public class ToolboxItemAttributeTests { + internal static bool IDesignerHostIsSupported => AppContext.TryGetSwitch("System.ComponentModel.Design.IDesignerHost.IsSupported", out bool isSupported) ? isSupported : true; + [Theory] [InlineData(true)] [InlineData(false)] public void Ctor_Bool(bool defaultType) { + if (!IDesignerHostIsSupported && defaultType) + { + AssertExtensions.Throws(() => new ToolboxItemAttribute(defaultType)); + return; + } + var attribute = new ToolboxItemAttribute(defaultType); if (defaultType) { diff --git a/src/libraries/System.ComponentModel/System.ComponentModel.sln b/src/libraries/System.ComponentModel/System.ComponentModel.sln index bbf9c64dccf..8e7fd39535f 100644 --- a/src/libraries/System.ComponentModel/System.ComponentModel.sln +++ b/src/libraries/System.ComponentModel/System.ComponentModel.sln @@ -7,7 +7,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ComponentModel", "sr EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ComponentModel.Tests", "tests\System.ComponentModel.Tests.csproj", "{4E375A78-D856-4C1E-B7CB-A4026C9FD8E7}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{AD87AB87-946C-4297-8ACB-C8FB1B604DE7}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{5AED2813-956F-4EB9-A4E0-AC74A910F7B3}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{22E91D96-49E2-4691-B4E5-4C22938C2F2A}" EndProject @@ -61,10 +61,10 @@ Global {4E375A78-D856-4C1E-B7CB-A4026C9FD8E7}.Debug|Any CPU.Build.0 = Debug|Any CPU {4E375A78-D856-4C1E-B7CB-A4026C9FD8E7}.Release|Any CPU.ActiveCfg = Release|Any CPU {4E375A78-D856-4C1E-B7CB-A4026C9FD8E7}.Release|Any CPU.Build.0 = Release|Any CPU - {AD87AB87-946C-4297-8ACB-C8FB1B604DE7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {AD87AB87-946C-4297-8ACB-C8FB1B604DE7}.Debug|Any CPU.Build.0 = Debug|Any CPU - {AD87AB87-946C-4297-8ACB-C8FB1B604DE7}.Release|Any CPU.ActiveCfg = Release|Any CPU - {AD87AB87-946C-4297-8ACB-C8FB1B604DE7}.Release|Any CPU.Build.0 = Release|Any CPU + {5AED2813-956F-4EB9-A4E0-AC74A910F7B3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {5AED2813-956F-4EB9-A4E0-AC74A910F7B3}.Debug|Any CPU.Build.0 = Debug|Any CPU + {5AED2813-956F-4EB9-A4E0-AC74A910F7B3}.Release|Any CPU.ActiveCfg = Release|Any CPU + {5AED2813-956F-4EB9-A4E0-AC74A910F7B3}.Release|Any CPU.Build.0 = Release|Any CPU {22E91D96-49E2-4691-B4E5-4C22938C2F2A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {22E91D96-49E2-4691-B4E5-4C22938C2F2A}.Debug|Any CPU.Build.0 = Debug|Any CPU {22E91D96-49E2-4691-B4E5-4C22938C2F2A}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -103,7 +103,7 @@ Global {E954E33E-6349-4FA2-AF54-A3BCFE430879} = {C6EF640A-0AED-46F1-97D6-3206BD0186F0} {5113780E-0A6C-42A2-94E0-A019815E051C} = {C6EF640A-0AED-46F1-97D6-3206BD0186F0} {EFFECBCD-A544-4649-AF79-3C2A7EEB4C6F} = {797FC0E7-1785-46B3-B280-2992A716A4ED} - {AD87AB87-946C-4297-8ACB-C8FB1B604DE7} = {C3164BD9-1105-4795-B05D-3F2583479C41} + {5AED2813-956F-4EB9-A4E0-AC74A910F7B3} = {C3164BD9-1105-4795-B05D-3F2583479C41} {22E91D96-49E2-4691-B4E5-4C22938C2F2A} = {C3164BD9-1105-4795-B05D-3F2583479C41} {DE549F9A-F3EC-4F34-872A-1B0867108D76} = {F8EA386B-5A35-4416-83D9-AB77469F8F86} {B341755D-DE06-4626-9CF0-3C6F510EC598} = {F8EA386B-5A35-4416-83D9-AB77469F8F86} diff --git a/src/libraries/System.Composition.AttributedModel/System.Composition.AttributedModel.sln b/src/libraries/System.Composition.AttributedModel/System.Composition.AttributedModel.sln index 5b4c3b4bda9..d4729db8e83 100644 --- a/src/libraries/System.Composition.AttributedModel/System.Composition.AttributedModel.sln +++ b/src/libraries/System.Composition.AttributedModel/System.Composition.AttributedModel.sln @@ -9,7 +9,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Composition.Attribut EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Composition.AttributeModel.Tests", "tests\System.Composition.AttributeModel.Tests.csproj", "{C2EBC4C3-C97B-4F64-A647-87DAE2816A06}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{24833E1B-95AF-4BB0-A290-5C6C79B3517F}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{2BE76E3B-7AE2-40E5-B653-054A7B5748E7}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{1167919A-CDD3-4EBB-9659-A2515B8D81D5}" EndProject @@ -65,10 +65,10 @@ Global {C2EBC4C3-C97B-4F64-A647-87DAE2816A06}.Debug|Any CPU.Build.0 = Debug|Any CPU {C2EBC4C3-C97B-4F64-A647-87DAE2816A06}.Release|Any CPU.ActiveCfg = Release|Any CPU {C2EBC4C3-C97B-4F64-A647-87DAE2816A06}.Release|Any CPU.Build.0 = Release|Any CPU - {24833E1B-95AF-4BB0-A290-5C6C79B3517F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {24833E1B-95AF-4BB0-A290-5C6C79B3517F}.Debug|Any CPU.Build.0 = Debug|Any CPU - {24833E1B-95AF-4BB0-A290-5C6C79B3517F}.Release|Any CPU.ActiveCfg = Release|Any CPU - {24833E1B-95AF-4BB0-A290-5C6C79B3517F}.Release|Any CPU.Build.0 = Release|Any CPU + {2BE76E3B-7AE2-40E5-B653-054A7B5748E7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {2BE76E3B-7AE2-40E5-B653-054A7B5748E7}.Debug|Any CPU.Build.0 = Debug|Any CPU + {2BE76E3B-7AE2-40E5-B653-054A7B5748E7}.Release|Any CPU.ActiveCfg = Release|Any CPU + {2BE76E3B-7AE2-40E5-B653-054A7B5748E7}.Release|Any CPU.Build.0 = Release|Any CPU {1167919A-CDD3-4EBB-9659-A2515B8D81D5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {1167919A-CDD3-4EBB-9659-A2515B8D81D5}.Debug|Any CPU.Build.0 = Debug|Any CPU {1167919A-CDD3-4EBB-9659-A2515B8D81D5}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -103,7 +103,7 @@ Global {B62DF545-08AB-40E1-9DED-755583B0B3B3} = {5D6DA61D-2DBA-49B9-A8D0-1566890D3293} {7C81E44B-A3A6-4707-AC60-8B6452FE35C2} = {378856D0-3326-428C-A8FB-FF958D0C4D49} {3DD99E03-A4D3-456A-BA2F-A7351423B800} = {378856D0-3326-428C-A8FB-FF958D0C4D49} - {24833E1B-95AF-4BB0-A290-5C6C79B3517F} = {4E66055C-EBEE-4A40-BA5C-EDC98CEE758E} + {2BE76E3B-7AE2-40E5-B653-054A7B5748E7} = {4E66055C-EBEE-4A40-BA5C-EDC98CEE758E} {1167919A-CDD3-4EBB-9659-A2515B8D81D5} = {4E66055C-EBEE-4A40-BA5C-EDC98CEE758E} {136A85A5-AF8F-460F-A600-E0D8DB744502} = {721AA8C2-0353-4E97-84AF-552621DF84BD} {E2101146-2E02-4FCC-8926-1E72026A40B4} = {721AA8C2-0353-4E97-84AF-552621DF84BD} diff --git a/src/libraries/System.Composition.AttributedModel/src/PACKAGE.md b/src/libraries/System.Composition.AttributedModel/src/PACKAGE.md new file mode 100644 index 00000000000..57bbc8bf032 --- /dev/null +++ b/src/libraries/System.Composition.AttributedModel/src/PACKAGE.md @@ -0,0 +1,140 @@ +## About + + + +`System.Composition.AttributedModel` is part of the Managed Extensibility Framework (MEF) 2.0, a composition library for .NET that enables dependency injection through attributes or conventions. + +This package provides the foundational attributes that allow you to declare parts for composition, such as imports, exports, and metadata. +It is used to mark classes, properties, methods, and constructors for MEF's discovery and composition process. + +## Key Features + + + +* Provides attributes for declaring composable parts, importing dependencies, metadata, and creating shared or non-shared parts + +## How to Use + + + +Mark classes for export and import using attributes. + +```csharp +using System.Composition; +using System.Composition.Hosting; + +var configuration = new ContainerConfiguration() + .WithPart() + .WithPart(); + +using CompositionHost container = configuration.CreateContainer(); + +Application app = container.GetExport(); +app.Service.Execute(); +// Service is running! + +[Export] +public class Application +{ + [Import] + public Service Service { get; set; } +} + +[Export] +public class Service +{ + public void Execute() => Console.WriteLine("Service is running!"); +} +``` + +Metadata can be used to differentiate between multiple exports of the same contract. + +```csharp +using System.Composition; +using System.Composition.Hosting; + +ContainerConfiguration configuration = new ContainerConfiguration() + .WithPart() + .WithPart() + .WithPart(); + +using CompositionHost container = configuration.CreateContainer(); + +Application app = container.GetExport(); +app.Run(); +// Using FileLogger to log. +// FileLogger: Hello, World! +// Using ConsoleLogger to log. +// ConsoleLogger: Hello, World! + +public interface ILogger +{ + void Log(string message); +} + +[Export(typeof(ILogger))] +[ExportMetadata("Name", "FileLogger")] +public class FileLogger : ILogger +{ + public void Log(string message) => Console.WriteLine($"FileLogger: {message}"); +} + +[Export(typeof(ILogger))] +[ExportMetadata("Name", "ConsoleLogger")] +public class ConsoleLogger : ILogger +{ + public void Log(string message) => Console.WriteLine($"ConsoleLogger: {message}"); +} + +[Export] +public class Application +{ + [ImportMany] + public required IEnumerable>> Loggers { get; set; } + + public void Run() + { + foreach (var logger in Loggers) + { + var name = logger.Metadata["Name"]; + + Console.WriteLine($"Using {name} to log."); + logger.Value.Log("Hello, World!"); + } + } +} +``` + +## Main Types + + + +The main types provided by this library are: + +* `System.Composition.ExportAttribute` +* `System.Composition.ImportAttribute` +* `System.Composition.ExportMetadataAttribute` + +## Additional Documentation + + + +* [API documentation](https://learn.microsoft.com/dotnet/api/system.composition) +* [Managed Extensibility Framework (MEF)](https://learn.microsoft.com/dotnet/framework/mef/) + +## Related Packages + + + +* [System.Composition](https://www.nuget.org/packages/System.Composition) +* [System.Composition.Convention](https://www.nuget.org/packages/System.Composition.Convention) +* [System.Composition.Hosting](https://www.nuget.org/packages/System.Composition.Hosting) +* [System.Composition.Runtime](https://www.nuget.org/packages/System.Composition.Runtime) +* [System.Composition.TypedParts](https://www.nuget.org/packages/System.Composition.TypedParts) + +## Feedback & Contributing + + + +System.Composition.AttributedModel is released as open source under the [MIT license](https://licenses.nuget.org/MIT). +Bug reports and contributions are welcome at [the GitHub repository](https://github.com/dotnet/runtime). diff --git a/src/libraries/System.Composition.AttributedModel/src/System.Composition.AttributedModel.csproj b/src/libraries/System.Composition.AttributedModel/src/System.Composition.AttributedModel.csproj index 21e5bd32d21..44856544cf5 100644 --- a/src/libraries/System.Composition.AttributedModel/src/System.Composition.AttributedModel.csproj +++ b/src/libraries/System.Composition.AttributedModel/src/System.Composition.AttributedModel.csproj @@ -5,17 +5,10 @@ Microsoft false true - Provides common attributes used by System.Composition types. - -Commonly Used Types: -System.Composition.ExportAttribute -System.Composition.ImportAttribute -System.Composition.Convention.AttributedModelProvider + Provides the foundational attributes that allow you to declare parts for composition, such as imports, exports, and metadata with the Managed Extensibility Framework (MEF). disable $(NoWarn);nullable - - false diff --git a/src/libraries/System.Composition.Convention/System.Composition.Convention.sln b/src/libraries/System.Composition.Convention/System.Composition.Convention.sln index a9205e23a86..f1af946a532 100644 --- a/src/libraries/System.Composition.Convention/System.Composition.Convention.sln +++ b/src/libraries/System.Composition.Convention/System.Composition.Convention.sln @@ -13,7 +13,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Composition.Runtime" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Composition.TypedParts", "..\System.Composition.TypedParts\src\System.Composition.TypedParts.csproj", "{5AAFDB16-AACF-4446-9285-26AAC815101B}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{0E526574-8462-4D78-BBCA-BD761904574A}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{3787E91C-94B7-4449-80B7-EC3409918FBD}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{5D902FB1-35C6-4396-98B2-CBC0BF09F356}" EndProject @@ -75,10 +75,10 @@ Global {5AAFDB16-AACF-4446-9285-26AAC815101B}.Debug|Any CPU.Build.0 = Debug|Any CPU {5AAFDB16-AACF-4446-9285-26AAC815101B}.Release|Any CPU.ActiveCfg = Release|Any CPU {5AAFDB16-AACF-4446-9285-26AAC815101B}.Release|Any CPU.Build.0 = Release|Any CPU - {0E526574-8462-4D78-BBCA-BD761904574A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {0E526574-8462-4D78-BBCA-BD761904574A}.Debug|Any CPU.Build.0 = Debug|Any CPU - {0E526574-8462-4D78-BBCA-BD761904574A}.Release|Any CPU.ActiveCfg = Release|Any CPU - {0E526574-8462-4D78-BBCA-BD761904574A}.Release|Any CPU.Build.0 = Release|Any CPU + {3787E91C-94B7-4449-80B7-EC3409918FBD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {3787E91C-94B7-4449-80B7-EC3409918FBD}.Debug|Any CPU.Build.0 = Debug|Any CPU + {3787E91C-94B7-4449-80B7-EC3409918FBD}.Release|Any CPU.ActiveCfg = Release|Any CPU + {3787E91C-94B7-4449-80B7-EC3409918FBD}.Release|Any CPU.Build.0 = Release|Any CPU {5D902FB1-35C6-4396-98B2-CBC0BF09F356}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {5D902FB1-35C6-4396-98B2-CBC0BF09F356}.Debug|Any CPU.Build.0 = Debug|Any CPU {5D902FB1-35C6-4396-98B2-CBC0BF09F356}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -115,7 +115,7 @@ Global {7839BCF8-8B5A-465B-A4B6-86CE4227AF81} = {D6A9A080-5B74-41A2-871E-F417FA9FF705} {782AA503-8808-4741-AECF-D79A6BF3EFF7} = {D6A9A080-5B74-41A2-871E-F417FA9FF705} {5AAFDB16-AACF-4446-9285-26AAC815101B} = {D6A9A080-5B74-41A2-871E-F417FA9FF705} - {0E526574-8462-4D78-BBCA-BD761904574A} = {DDADB978-93BC-489A-90C8-523AFE08EBC1} + {3787E91C-94B7-4449-80B7-EC3409918FBD} = {DDADB978-93BC-489A-90C8-523AFE08EBC1} {5D902FB1-35C6-4396-98B2-CBC0BF09F356} = {DDADB978-93BC-489A-90C8-523AFE08EBC1} {7F5928C7-00A1-4786-9916-F58A60ADEAEC} = {0690F4F7-22B9-4290-9223-6D8622F18445} {9CFB3C11-E653-4969-8B4C-135E4E20E6C8} = {0690F4F7-22B9-4290-9223-6D8622F18445} diff --git a/src/libraries/System.Composition.Convention/src/PACKAGE.md b/src/libraries/System.Composition.Convention/src/PACKAGE.md new file mode 100644 index 00000000000..4f6e1fdc235 --- /dev/null +++ b/src/libraries/System.Composition.Convention/src/PACKAGE.md @@ -0,0 +1,97 @@ +## About + + + +`System.Composition.Convention` is part of the Managed Extensibility Framework (MEF) 2.0, a composition library for .NET that enables dependency injection through attributes or conventions. + +This package simplifies the process of applying consistent patterns for part exports, imports, and metadata by using convention-based configurations. +It is useful for scenarios where you want to avoid repetitive attribute-based decoration and instead define conventions for registering types in your composition container. + +## Key Features + + + +* Configure exports, imports, and metadata for parts using conventions rather than attributes. +* Allows defining conventions through a fluent API, making configuration more flexible and readable. + +## How to Use + + + +Configure parts for composition without using attributes. + +```csharp +using System.Composition.Convention; +using System.Composition.Hosting; + +var conventions = new ConventionBuilder(); + +// Apply conventions: any class that implements ILogger will be exported as ILogger +conventions + .ForTypesDerivedFrom() + .Export(); + +var configuration = new ContainerConfiguration() + .WithPart(conventions) + .WithPart(conventions); + +using CompositionHost container = configuration.CreateContainer(); + +var loggers = container.GetExports(); + +foreach (var logger in loggers) +{ + logger.Log("Hello, World!"); +} +// FileLogger: Hello, World! +// ConsoleLogger: Hello, World! + +public interface ILogger +{ + void Log(string message); +} + +public class FileLogger : ILogger +{ + public void Log(string message) => Console.WriteLine($"FileLogger: {message}"); +} + +public class ConsoleLogger : ILogger +{ + public void Log(string message) => Console.WriteLine($"ConsoleLogger: {message}"); +} +``` + +## Main Types + + + +The main types provided by this library are: + +* `System.Composition.Convention.ConventionBuilder` +* `System.Composition.Convention.PartConventionBuilder` +* `System.Composition.Convention.ParameterImportConventionBuilder` + +## Additional Documentation + + + +* [API documentation](https://learn.microsoft.com/dotnet/api/system.composition.convention) +* [Managed Extensibility Framework (MEF)](https://learn.microsoft.com/dotnet/framework/mef/) + +## Related Packages + + + +* [System.Composition](https://www.nuget.org/packages/System.Composition) +* [System.Composition.AttributedModel](https://www.nuget.org/packages/System.Composition.AttributedModel) +* [System.Composition.Hosting](https://www.nuget.org/packages/System.Composition.Hosting) +* [System.Composition.Runtime](https://www.nuget.org/packages/System.Composition.Runtime) +* [System.Composition.TypedParts](https://www.nuget.org/packages/System.Composition.TypedParts) + +## Feedback & Contributing + + + +System.Composition.Convention is released as open source under the [MIT license](https://licenses.nuget.org/MIT). +Bug reports and contributions are welcome at [the GitHub repository](https://github.com/dotnet/runtime). diff --git a/src/libraries/System.Composition.Convention/src/System.Composition.Convention.csproj b/src/libraries/System.Composition.Convention/src/System.Composition.Convention.csproj index 8e1f44ee3df..2544944eec7 100644 --- a/src/libraries/System.Composition.Convention/src/System.Composition.Convention.csproj +++ b/src/libraries/System.Composition.Convention/src/System.Composition.Convention.csproj @@ -6,19 +6,10 @@ Microsoft false true - Provides types that support using Managed Extensibility Framework with a convention-based configuration model. - -Commonly Used Types: -System.Composition.Convention.ConventionBuilder -System.Composition.Convention.ExportConventionBuilder -System.Composition.Convention.ImportConventionBuilder -System.Composition.Convention.PartConventionBuilder -System.Composition.Convention.ParameterImportConventionBuilder + Provides types that support using Managed Extensibility Framework (MEF) with a convention-based configuration model. disable $(NoWarn);nullable - - false diff --git a/src/libraries/System.Composition.Hosting/System.Composition.Hosting.sln b/src/libraries/System.Composition.Hosting/System.Composition.Hosting.sln index 0a2ca82bef7..f0bee0ea79e 100644 --- a/src/libraries/System.Composition.Hosting/System.Composition.Hosting.sln +++ b/src/libraries/System.Composition.Hosting/System.Composition.Hosting.sln @@ -7,7 +7,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Composition.Hosting. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Composition.Runtime", "..\System.Composition.Runtime\src\System.Composition.Runtime.csproj", "{4C5E5AB8-480F-49F2-AF28-29C2EE713A39}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{FD8449C3-8A72-4ECF-B85D-C920253B88D8}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{F545329D-CE53-4032-8184-73E18444DE90}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{5DBEE1CE-A97E-4F4A-98FF-DD689E5EF629}" EndProject @@ -57,10 +57,10 @@ Global {4C5E5AB8-480F-49F2-AF28-29C2EE713A39}.Debug|Any CPU.Build.0 = Debug|Any CPU {4C5E5AB8-480F-49F2-AF28-29C2EE713A39}.Release|Any CPU.ActiveCfg = Release|Any CPU {4C5E5AB8-480F-49F2-AF28-29C2EE713A39}.Release|Any CPU.Build.0 = Release|Any CPU - {FD8449C3-8A72-4ECF-B85D-C920253B88D8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {FD8449C3-8A72-4ECF-B85D-C920253B88D8}.Debug|Any CPU.Build.0 = Debug|Any CPU - {FD8449C3-8A72-4ECF-B85D-C920253B88D8}.Release|Any CPU.ActiveCfg = Release|Any CPU - {FD8449C3-8A72-4ECF-B85D-C920253B88D8}.Release|Any CPU.Build.0 = Release|Any CPU + {F545329D-CE53-4032-8184-73E18444DE90}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F545329D-CE53-4032-8184-73E18444DE90}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F545329D-CE53-4032-8184-73E18444DE90}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F545329D-CE53-4032-8184-73E18444DE90}.Release|Any CPU.Build.0 = Release|Any CPU {5DBEE1CE-A97E-4F4A-98FF-DD689E5EF629}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {5DBEE1CE-A97E-4F4A-98FF-DD689E5EF629}.Debug|Any CPU.Build.0 = Debug|Any CPU {5DBEE1CE-A97E-4F4A-98FF-DD689E5EF629}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -94,7 +94,7 @@ Global {0F595512-D4BE-4042-9C8A-F0816A7B27AD} = {7AEF3556-BD3A-432D-A849-DFE1509F905E} {991FC8D9-6A92-4A79-91EC-BD72005687AF} = {D140917D-0E52-4DC6-920A-B222BD2025AE} {4C5E5AB8-480F-49F2-AF28-29C2EE713A39} = {D140917D-0E52-4DC6-920A-B222BD2025AE} - {FD8449C3-8A72-4ECF-B85D-C920253B88D8} = {1EEFB4CE-0917-418F-B83C-3B376CB39BC4} + {F545329D-CE53-4032-8184-73E18444DE90} = {1EEFB4CE-0917-418F-B83C-3B376CB39BC4} {5DBEE1CE-A97E-4F4A-98FF-DD689E5EF629} = {1EEFB4CE-0917-418F-B83C-3B376CB39BC4} {576EC47D-A253-424B-8695-40257B07B282} = {E3B907A0-538F-47D6-B89A-9701F6D4B382} {4DED17FD-82E0-4566-932A-1371911AD33A} = {E3B907A0-538F-47D6-B89A-9701F6D4B382} diff --git a/src/libraries/System.Composition.Hosting/src/PACKAGE.md b/src/libraries/System.Composition.Hosting/src/PACKAGE.md new file mode 100644 index 00000000000..9f5556e7a4d --- /dev/null +++ b/src/libraries/System.Composition.Hosting/src/PACKAGE.md @@ -0,0 +1,80 @@ +## About + + + +`System.Composition.Hosting` is part of the Managed Extensibility Framework (MEF) 2.0, a composition library for .NET that enables dependency injection through attributes or conventions. + +This package provides core services for creating composition containers. +It offers tools to configure and manage the composition of parts within your application, facilitating dependency injection and enabling modular architectures. + +## Key Features + + + +* Create and manage composition containers for dynamic dependency injection. + +## How to Use + + + +Create a composition host and compose parts. + +```csharp +using System.Composition; +using System.Composition.Hosting; + +// Create a container configuration +var configuration = new ContainerConfiguration() + .WithPart(); + +// Create the composition host (container) +using CompositionHost container = configuration.CreateContainer(); + +// Get an instance of the service +var service = container.GetExport(); +service.Run(); +// Service is running! + +public interface IService +{ + void Run(); +} + +[Export(typeof(IService))] +public class Service : IService +{ + public void Run() => Console.WriteLine("Service is running!"); +} +``` + +## Main Types + + + +The main type provided by this library is: + +* `System.Composition.CompositionHost` + +## Additional Documentation + + + +* [API documentation](https://learn.microsoft.com/dotnet/api/system.composition.hosting) +* [Managed Extensibility Framework (MEF)](https://learn.microsoft.com/dotnet/framework/mef/) + +## Related Packages + + + +* [System.Composition](https://www.nuget.org/packages/System.Composition) +* [System.Composition.AttributedModel](https://www.nuget.org/packages/System.Composition.AttributedModel) +* [System.Composition.Convention](https://www.nuget.org/packages/System.Composition.Convention) +* [System.Composition.Runtime](https://www.nuget.org/packages/System.Composition.Runtime) +* [System.Composition.TypedParts](https://www.nuget.org/packages/System.Composition.TypedParts) + +## Feedback & Contributing + + + +System.Composition.Hosting is released as open source under the [MIT license](https://licenses.nuget.org/MIT). +Bug reports and contributions are welcome at [the GitHub repository](https://github.com/dotnet/runtime). diff --git a/src/libraries/System.Composition.Hosting/src/System.Composition.Hosting.csproj b/src/libraries/System.Composition.Hosting/src/System.Composition.Hosting.csproj index cd017f48b69..18d027e8ad1 100644 --- a/src/libraries/System.Composition.Hosting/src/System.Composition.Hosting.csproj +++ b/src/libraries/System.Composition.Hosting/src/System.Composition.Hosting.csproj @@ -7,15 +7,10 @@ Microsoft false true - Provides Managed Extensibility Framework types that are useful to developers of extensible applications, or hosts. - -Commonly Used Types: -System.Composition.Hosting.CompositionHost + Provides Managed Extensibility Framework (MEF) types that are useful to developers of extensible applications, or hosts. disable $(NoWarn);nullable - - false diff --git a/src/libraries/System.Composition.Runtime/System.Composition.Runtime.sln b/src/libraries/System.Composition.Runtime/System.Composition.Runtime.sln index 7013e98c2c2..833eaa99873 100644 --- a/src/libraries/System.Composition.Runtime/System.Composition.Runtime.sln +++ b/src/libraries/System.Composition.Runtime/System.Composition.Runtime.sln @@ -5,7 +5,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Composition.Runtime" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Composition.Runtime.Tests", "tests\System.Composition.Runtime.Tests.csproj", "{B19B1509-313D-497D-9636-9A7AD5022DCF}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{669F1F31-D3A6-40CD-878C-90FCAE3108F4}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{49B69F76-3873-4472-83B9-F3136426E088}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{1EE96691-E213-40A7-9392-A6A4417AFC4F}" EndProject @@ -51,10 +51,10 @@ Global {B19B1509-313D-497D-9636-9A7AD5022DCF}.Debug|Any CPU.Build.0 = Debug|Any CPU {B19B1509-313D-497D-9636-9A7AD5022DCF}.Release|Any CPU.ActiveCfg = Release|Any CPU {B19B1509-313D-497D-9636-9A7AD5022DCF}.Release|Any CPU.Build.0 = Release|Any CPU - {669F1F31-D3A6-40CD-878C-90FCAE3108F4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {669F1F31-D3A6-40CD-878C-90FCAE3108F4}.Debug|Any CPU.Build.0 = Debug|Any CPU - {669F1F31-D3A6-40CD-878C-90FCAE3108F4}.Release|Any CPU.ActiveCfg = Release|Any CPU - {669F1F31-D3A6-40CD-878C-90FCAE3108F4}.Release|Any CPU.Build.0 = Release|Any CPU + {49B69F76-3873-4472-83B9-F3136426E088}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {49B69F76-3873-4472-83B9-F3136426E088}.Debug|Any CPU.Build.0 = Debug|Any CPU + {49B69F76-3873-4472-83B9-F3136426E088}.Release|Any CPU.ActiveCfg = Release|Any CPU + {49B69F76-3873-4472-83B9-F3136426E088}.Release|Any CPU.Build.0 = Release|Any CPU {1EE96691-E213-40A7-9392-A6A4417AFC4F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {1EE96691-E213-40A7-9392-A6A4417AFC4F}.Debug|Any CPU.Build.0 = Debug|Any CPU {1EE96691-E213-40A7-9392-A6A4417AFC4F}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -87,7 +87,7 @@ Global {31F52C37-63E5-46F9-A5DE-894E8AC91475} = {677DCCA2-C84B-4D33-AFA8-8906764CBAE7} {B19B1509-313D-497D-9636-9A7AD5022DCF} = {677DCCA2-C84B-4D33-AFA8-8906764CBAE7} {BAC53BBD-B949-419D-833B-54B6A03A1389} = {81E62E76-E824-4685-93D0-9C8C1F5C7AE2} - {669F1F31-D3A6-40CD-878C-90FCAE3108F4} = {0D8AEC7B-1995-4D2C-90E4-8011BDA3D750} + {49B69F76-3873-4472-83B9-F3136426E088} = {0D8AEC7B-1995-4D2C-90E4-8011BDA3D750} {1EE96691-E213-40A7-9392-A6A4417AFC4F} = {0D8AEC7B-1995-4D2C-90E4-8011BDA3D750} {DD9FECB3-A071-4941-9AEC-AD377B0B9B57} = {1D0C0EB9-4579-46E6-B4F4-593EC762FAA8} {FEAF43AA-74B0-4152-AB51-8B4BF2D9D4A9} = {1D0C0EB9-4579-46E6-B4F4-593EC762FAA8} diff --git a/src/libraries/System.Composition.Runtime/src/PACKAGE.md b/src/libraries/System.Composition.Runtime/src/PACKAGE.md new file mode 100644 index 00000000000..177bb802688 --- /dev/null +++ b/src/libraries/System.Composition.Runtime/src/PACKAGE.md @@ -0,0 +1,87 @@ +## About + + + +`System.Composition.Runtime` is part of the Managed Extensibility Framework (MEF) 2.0, a composition library for .NET that enables dependency injection through attributes or conventions. + +This package enables the discovery and composition of parts in applications using MEF 2.0. +It offers the runtime implementation needed for managing composable parts, resolving dependencies, and dynamically wiring components together. + +## Key Features + + + +* Facilitates runtime discovery and composition of parts. + +## How to Use + + + +Resolve dependencies on the fly and can be useful for dynamically loaded components or plugins. + +```csharp +using System.Composition; +using System.Composition.Hosting; + +var configuration = new ContainerConfiguration() + .WithPart(); + +using CompositionHost container = configuration.CreateContainer(); + +var consumer = new Consumer(container); +consumer.Execute(); +// Service is running. + +public interface IService +{ + void Run(); +} + +[Export(typeof(IService))] +public class Service : IService +{ + public void Run() => Console.WriteLine("Service is running."); +} + +public class Consumer(CompositionContext context) +{ + public void Execute() + { + // Use the context to resolve the service + var service = context.GetExport(); + service.Run(); + } +} +``` + +## Main Types + + + +The main type provided by this library is: + +* `System.Composition.CompositionContext` + +## Additional Documentation + + + +* [API documentation](https://learn.microsoft.com/dotnet/api/system.composition.compositioncontext) +* [Managed Extensibility Framework (MEF)](https://learn.microsoft.com/dotnet/framework/mef/) + +## Related Packages + + + +* [System.Composition](https://www.nuget.org/packages/System.Composition) +* [System.Composition.AttributedModel](https://www.nuget.org/packages/System.Composition.AttributedModel) +* [System.Composition.Convention](https://www.nuget.org/packages/System.Composition.Convention) +* [System.Composition.Hosting](https://www.nuget.org/packages/System.Composition.Hosting) +* [System.Composition.TypedParts](https://www.nuget.org/packages/System.Composition.TypedParts) + +## Feedback & Contributing + + + +System.Composition.Runtime is released as open source under the [MIT license](https://licenses.nuget.org/MIT). +Bug reports and contributions are welcome at [the GitHub repository](https://github.com/dotnet/runtime). diff --git a/src/libraries/System.Composition.Runtime/src/System.Composition.Runtime.csproj b/src/libraries/System.Composition.Runtime/src/System.Composition.Runtime.csproj index 57ee9457ea3..93ef06e572a 100644 --- a/src/libraries/System.Composition.Runtime/src/System.Composition.Runtime.csproj +++ b/src/libraries/System.Composition.Runtime/src/System.Composition.Runtime.csproj @@ -7,15 +7,10 @@ Microsoft false true - Contains runtime components of the Managed Extensibility Framework. - -Commonly Used Types: -System.Composition.CompositionContext + Contains runtime components of the Managed Extensibility Framework (MEF). disable $(NoWarn);nullable - - false diff --git a/src/libraries/System.Composition.TypedParts/System.Composition.TypedParts.sln b/src/libraries/System.Composition.TypedParts/System.Composition.TypedParts.sln index 76f8e66da14..07de990debf 100644 --- a/src/libraries/System.Composition.TypedParts/System.Composition.TypedParts.sln +++ b/src/libraries/System.Composition.TypedParts/System.Composition.TypedParts.sln @@ -13,7 +13,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Composition.TypedPar EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Composition.TypedParts.Tests", "tests\System.Composition.TypedParts.Tests.csproj", "{38C096D0-5E23-47E2-A074-5F9852075459}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{73B190CC-D704-484D-BC34-F28A6E307D29}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{4DA998D5-D352-4ABB-8E99-530A3A8F82D5}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{4FDFF976-E09D-4788-9AE2-BEB9AD129970}" EndProject @@ -75,10 +75,10 @@ Global {38C096D0-5E23-47E2-A074-5F9852075459}.Debug|Any CPU.Build.0 = Debug|Any CPU {38C096D0-5E23-47E2-A074-5F9852075459}.Release|Any CPU.ActiveCfg = Release|Any CPU {38C096D0-5E23-47E2-A074-5F9852075459}.Release|Any CPU.Build.0 = Release|Any CPU - {73B190CC-D704-484D-BC34-F28A6E307D29}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {73B190CC-D704-484D-BC34-F28A6E307D29}.Debug|Any CPU.Build.0 = Debug|Any CPU - {73B190CC-D704-484D-BC34-F28A6E307D29}.Release|Any CPU.ActiveCfg = Release|Any CPU - {73B190CC-D704-484D-BC34-F28A6E307D29}.Release|Any CPU.Build.0 = Release|Any CPU + {4DA998D5-D352-4ABB-8E99-530A3A8F82D5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {4DA998D5-D352-4ABB-8E99-530A3A8F82D5}.Debug|Any CPU.Build.0 = Debug|Any CPU + {4DA998D5-D352-4ABB-8E99-530A3A8F82D5}.Release|Any CPU.ActiveCfg = Release|Any CPU + {4DA998D5-D352-4ABB-8E99-530A3A8F82D5}.Release|Any CPU.Build.0 = Release|Any CPU {4FDFF976-E09D-4788-9AE2-BEB9AD129970}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {4FDFF976-E09D-4788-9AE2-BEB9AD129970}.Debug|Any CPU.Build.0 = Debug|Any CPU {4FDFF976-E09D-4788-9AE2-BEB9AD129970}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -115,7 +115,7 @@ Global {C8B6031E-5DD0-4BE8-9D70-960B24B1D23D} = {D9ED6745-3C2A-46CB-97DA-C46BA1A3A07B} {E5E6C1F3-C318-47FF-B0BC-CFC04BC4AB15} = {D9ED6745-3C2A-46CB-97DA-C46BA1A3A07B} {1B533355-A67E-4912-9605-A08FC7870291} = {D9ED6745-3C2A-46CB-97DA-C46BA1A3A07B} - {73B190CC-D704-484D-BC34-F28A6E307D29} = {C335D433-9DCB-40C6-BF0E-556237F94898} + {4DA998D5-D352-4ABB-8E99-530A3A8F82D5} = {C335D433-9DCB-40C6-BF0E-556237F94898} {4FDFF976-E09D-4788-9AE2-BEB9AD129970} = {C335D433-9DCB-40C6-BF0E-556237F94898} {2DD92A7D-BB66-496A-84A2-6CE277908E45} = {B3E6363B-21EE-414C-A7F4-A5B8C81C0AEA} {FA77F597-EEA3-464D-B1F7-34D8A34127B4} = {B3E6363B-21EE-414C-A7F4-A5B8C81C0AEA} diff --git a/src/libraries/System.Composition.TypedParts/src/PACKAGE.md b/src/libraries/System.Composition.TypedParts/src/PACKAGE.md new file mode 100644 index 00000000000..de02f4525c8 --- /dev/null +++ b/src/libraries/System.Composition.TypedParts/src/PACKAGE.md @@ -0,0 +1,88 @@ +## About + + + +`System.Composition.TypedParts` is part of the Managed Extensibility Framework (MEF) 2.0, a composition library for .NET that enables dependency injection through attributes or conventions. + +Provides `ContainerConfiguration` and some extension methods for the Managed Extensibility Framework (MEF). + +## Key Features + + + +* Provides container configuration. + +## How to Use + + + +Register parts from an entire assembly. + +```csharp +using System.Composition; +using System.Composition.Hosting; +using System.Reflection; + +// Register all parts from the current assembly +var configuration = new ContainerConfiguration() + .WithAssembly(Assembly.GetExecutingAssembly()); + +using CompositionHost container = configuration.CreateContainer(); + +var handlers = container.GetExports(); +foreach (var handler in handlers) +{ + handler.Handle(); +} +// HandlerA is handling. +// HandlerB is handling. + +public interface IHandler +{ + void Handle(); +} + +[Export(typeof(IHandler))] +public class HandlerA : IHandler +{ + public void Handle() => Console.WriteLine("HandlerA is handling."); +} + +[Export(typeof(IHandler))] +public class HandlerB : IHandler +{ + public void Handle() => Console.WriteLine("HandlerB is handling."); +} +``` + +## Main Types + + + +The main types provided by this library are: + +* `System.Composition.Hosting.ContainerConfiguration` +* `System.Composition.CompositionContextExtensions` + +## Additional Documentation + + + +* [Managed Extensibility Framework (MEF)](https://learn.microsoft.com/dotnet/framework/mef/) + +## Related Packages + + + +* [System.Composition](https://www.nuget.org/packages/System.Composition) +* [System.Composition.AttributedModel](https://www.nuget.org/packages/System.Composition.AttributedModel) +* [System.Composition.Convention](https://www.nuget.org/packages/System.Composition.Convention) +* [System.Composition.Hosting](https://www.nuget.org/packages/System.Composition.Hosting) +* [System.Composition.Runtime](https://www.nuget.org/packages/System.Composition.Runtime) + +## Feedback & Contributing + + + +System.Composition.TypedParts is released as open source under the [MIT license](https://licenses.nuget.org/MIT). +Bug reports and contributions are welcome at [the GitHub repository](https://github.com/dotnet/runtime). diff --git a/src/libraries/System.Composition.TypedParts/src/System.Composition.TypedParts.csproj b/src/libraries/System.Composition.TypedParts/src/System.Composition.TypedParts.csproj index 4e82792a399..3a2874d9d3f 100644 --- a/src/libraries/System.Composition.TypedParts/src/System.Composition.TypedParts.csproj +++ b/src/libraries/System.Composition.TypedParts/src/System.Composition.TypedParts.csproj @@ -8,16 +8,10 @@ Microsoft false true - Provides some extension methods for the Managed Extensibility Framework. - -Commonly Used Types: -System.Composition.CompositionContextExtensions -System.Composition.Hosting.ContainerConfiguration + Provides container configuration and some extension methods for the Managed Extensibility Framework (MEF). disable $(NoWarn);nullable - - false diff --git a/src/libraries/System.Composition/System.Composition.sln b/src/libraries/System.Composition/System.Composition.sln index db46937271c..c62fce10112 100644 --- a/src/libraries/System.Composition/System.Composition.sln +++ b/src/libraries/System.Composition/System.Composition.sln @@ -19,7 +19,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Composition.Tests", EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestLibrary", "tests\TestLibrary\TestLibrary.csproj", "{B16BCA17-DCA8-43B7-8E8A-89033F7A676E}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{872B3C94-AC4C-4CE3-B8B1-6FDE84C50CE3}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{4BBBDBE2-82DB-4F87-9F13-1D44FFE61A88}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{3EA50BD8-ABA5-47D8-AC31-4C6D1C2CAE63}" EndProject @@ -93,10 +93,10 @@ Global {B16BCA17-DCA8-43B7-8E8A-89033F7A676E}.Debug|Any CPU.Build.0 = Debug|Any CPU {B16BCA17-DCA8-43B7-8E8A-89033F7A676E}.Release|Any CPU.ActiveCfg = Release|Any CPU {B16BCA17-DCA8-43B7-8E8A-89033F7A676E}.Release|Any CPU.Build.0 = Release|Any CPU - {872B3C94-AC4C-4CE3-B8B1-6FDE84C50CE3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {872B3C94-AC4C-4CE3-B8B1-6FDE84C50CE3}.Debug|Any CPU.Build.0 = Debug|Any CPU - {872B3C94-AC4C-4CE3-B8B1-6FDE84C50CE3}.Release|Any CPU.ActiveCfg = Release|Any CPU - {872B3C94-AC4C-4CE3-B8B1-6FDE84C50CE3}.Release|Any CPU.Build.0 = Release|Any CPU + {4BBBDBE2-82DB-4F87-9F13-1D44FFE61A88}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {4BBBDBE2-82DB-4F87-9F13-1D44FFE61A88}.Debug|Any CPU.Build.0 = Debug|Any CPU + {4BBBDBE2-82DB-4F87-9F13-1D44FFE61A88}.Release|Any CPU.ActiveCfg = Release|Any CPU + {4BBBDBE2-82DB-4F87-9F13-1D44FFE61A88}.Release|Any CPU.Build.0 = Release|Any CPU {3EA50BD8-ABA5-47D8-AC31-4C6D1C2CAE63}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {3EA50BD8-ABA5-47D8-AC31-4C6D1C2CAE63}.Debug|Any CPU.Build.0 = Debug|Any CPU {3EA50BD8-ABA5-47D8-AC31-4C6D1C2CAE63}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -136,7 +136,7 @@ Global {60940C78-4DDA-4CDD-BA1C-8C9B6DB4FB64} = {A1E6CEE6-45AE-4A8A-A7FA-FFC34DB87C94} {E3295CB6-16E3-497C-A696-71A077DD5828} = {A1E6CEE6-45AE-4A8A-A7FA-FFC34DB87C94} {D1273F2F-1B6C-4EFB-ABF8-6072054E906C} = {A1E6CEE6-45AE-4A8A-A7FA-FFC34DB87C94} - {872B3C94-AC4C-4CE3-B8B1-6FDE84C50CE3} = {AB19313E-E606-4F39-AA2E-D3299DC26D7C} + {4BBBDBE2-82DB-4F87-9F13-1D44FFE61A88} = {AB19313E-E606-4F39-AA2E-D3299DC26D7C} {3EA50BD8-ABA5-47D8-AC31-4C6D1C2CAE63} = {AB19313E-E606-4F39-AA2E-D3299DC26D7C} {F3F80D91-1286-4EC5-B2C1-500A3E8C4807} = {8F4758E9-C437-439D-9151-260D62ACF586} {E8567397-C664-455F-BBB1-74DF0BE07570} = {8F4758E9-C437-439D-9151-260D62ACF586} diff --git a/src/libraries/System.Composition/src/PACKAGE.md b/src/libraries/System.Composition/src/PACKAGE.md new file mode 100644 index 00000000000..d6378b7ed0d --- /dev/null +++ b/src/libraries/System.Composition/src/PACKAGE.md @@ -0,0 +1,77 @@ +## About + + + +Provides the Managed Extensibility Framework (MEF) 2.0, a lightweight, attribute-driven Dependency Injection (DI) container. + +MEF simplifies the composition of applications by allowing components to be loosely coupled and dynamically discovered. +This package supports the development of modular and maintainable applications by enabling parts to be composed at runtime. + +## Key Features + + + +* Components are discovered and composed using attributes. +* Provides dependency injection capabilities for loosely coupled modules. + +## How to Use + + + +Running code from a discovered component. + +```csharp +using System.Composition; +using System.Composition.Hosting; + +var configuration = new ContainerConfiguration().WithPart(); + +using var container = configuration.CreateContainer(); + +var service = container.GetExport(); +service.Execute(); +// Output: Service is running! + +[Export] +public class Service +{ + public void Execute() => Console.WriteLine("Service is running!"); +} +``` + +## Main Types + + + +The main types provided by this library are: + +* `System.Composition.ExportAttribute` +* `System.Composition.ImportAttribute` +* `System.Composition.Convention.ConventionBuilder` +* `System.Composition.Hosting.CompositionHost` +* `System.Composition.CompositionContext` +* `System.Composition.CompositionContextExtensions` + +## Additional Documentation + + + +* [API documentation](https://learn.microsoft.com/dotnet/api/system.composition) +* [Managed Extensibility Framework (MEF)](https://learn.microsoft.com/dotnet/framework/mef/) + +## Related Packages + + + +* [System.Composition.AttributedModel](https://www.nuget.org/packages/System.Composition.AttributedModel) +* [System.Composition.Convention](https://www.nuget.org/packages/System.Composition.Convention) +* [System.Composition.Hosting](https://www.nuget.org/packages/System.Composition.Hosting) +* [System.Composition.Runtime](https://www.nuget.org/packages/System.Composition.Runtime) +* [System.Composition.TypedParts](https://www.nuget.org/packages/System.Composition.TypedParts) + +## Feedback & Contributing + + + +System.Composition is released as open source under the [MIT license](https://licenses.nuget.org/MIT). +Bug reports and contributions are welcome at [the GitHub repository](https://github.com/dotnet/runtime). diff --git a/src/libraries/System.Composition/src/System.Composition.csproj b/src/libraries/System.Composition/src/System.Composition.csproj index 0d0c67320ef..a360f80b58e 100644 --- a/src/libraries/System.Composition/src/System.Composition.csproj +++ b/src/libraries/System.Composition/src/System.Composition.csproj @@ -8,21 +8,10 @@ $(NoWarn);NU5128 false - This package provides a version of the Managed Extensibility Framework (MEF) that is lightweight and specifically optimized for high throughput scenarios, such as the web. - -Commonly Used Types: -System.Composition.ExportAttribute -System.Composition.ImportAttribute -System.Composition.Convention.ConventionBuilder -System.Composition.Hosting.CompositionHost -System.Composition.CompositionContext -System.Composition.CompositionContextExtensions - + Provides a version of the Managed Extensibility Framework (MEF) that is lightweight and specifically optimized for high throughput scenarios, such as the web. disable $(NoWarn);nullable - - false diff --git a/src/libraries/System.Configuration.ConfigurationManager/Directory.Build.props b/src/libraries/System.Configuration.ConfigurationManager/Directory.Build.props index c843a6347ce..3a3d8f98324 100644 --- a/src/libraries/System.Configuration.ConfigurationManager/Directory.Build.props +++ b/src/libraries/System.Configuration.ConfigurationManager/Directory.Build.props @@ -2,6 +2,6 @@ true - browser + browser;wasi \ No newline at end of file diff --git a/src/libraries/System.Configuration.ConfigurationManager/System.Configuration.ConfigurationManager.sln b/src/libraries/System.Configuration.ConfigurationManager/System.Configuration.ConfigurationManager.sln index 0e9382f21c0..d91e91e9ed3 100644 --- a/src/libraries/System.Configuration.ConfigurationManager/System.Configuration.ConfigurationManager.sln +++ b/src/libraries/System.Configuration.ConfigurationManager/System.Configuration.ConfigurationManager.sln @@ -23,6 +23,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", ". EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.Uri", "..\System.Private.Uri\src\System.Private.Uri.csproj", "{8D66707F-68BE-47FD-8A83-34A949B6F000}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{5BEEC07B-67E3-4B64-BAA4-05A1089DE5B1}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{355B775A-BFE1-4384-BC83-C6B5D1FB77BB}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{66EC63BC-99DC-40CA-B53B-B4D8BF6D1630}" @@ -349,6 +351,27 @@ Global {8D66707F-68BE-47FD-8A83-34A949B6F000}.Checked|arm64.ActiveCfg = Debug|Any CPU {8D66707F-68BE-47FD-8A83-34A949B6F000}.Checked|x64.ActiveCfg = Debug|Any CPU {8D66707F-68BE-47FD-8A83-34A949B6F000}.Checked|x86.ActiveCfg = Debug|Any CPU + {5BEEC07B-67E3-4B64-BAA4-05A1089DE5B1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {5BEEC07B-67E3-4B64-BAA4-05A1089DE5B1}.Debug|Any CPU.Build.0 = Debug|Any CPU + {5BEEC07B-67E3-4B64-BAA4-05A1089DE5B1}.Debug|arm.ActiveCfg = Debug|Any CPU + {5BEEC07B-67E3-4B64-BAA4-05A1089DE5B1}.Debug|arm64.ActiveCfg = Debug|Any CPU + {5BEEC07B-67E3-4B64-BAA4-05A1089DE5B1}.Debug|x64.ActiveCfg = Debug|Any CPU + {5BEEC07B-67E3-4B64-BAA4-05A1089DE5B1}.Debug|x64.Build.0 = Debug|Any CPU + {5BEEC07B-67E3-4B64-BAA4-05A1089DE5B1}.Debug|x86.ActiveCfg = Debug|Any CPU + {5BEEC07B-67E3-4B64-BAA4-05A1089DE5B1}.Debug|x86.Build.0 = Debug|Any CPU + {5BEEC07B-67E3-4B64-BAA4-05A1089DE5B1}.Release|Any CPU.ActiveCfg = Release|Any CPU + {5BEEC07B-67E3-4B64-BAA4-05A1089DE5B1}.Release|Any CPU.Build.0 = Release|Any CPU + {5BEEC07B-67E3-4B64-BAA4-05A1089DE5B1}.Release|arm.ActiveCfg = Release|Any CPU + {5BEEC07B-67E3-4B64-BAA4-05A1089DE5B1}.Release|arm64.ActiveCfg = Release|Any CPU + {5BEEC07B-67E3-4B64-BAA4-05A1089DE5B1}.Release|x64.ActiveCfg = Release|Any CPU + {5BEEC07B-67E3-4B64-BAA4-05A1089DE5B1}.Release|x64.Build.0 = Release|Any CPU + {5BEEC07B-67E3-4B64-BAA4-05A1089DE5B1}.Release|x86.ActiveCfg = Release|Any CPU + {5BEEC07B-67E3-4B64-BAA4-05A1089DE5B1}.Release|x86.Build.0 = Release|Any CPU + {5BEEC07B-67E3-4B64-BAA4-05A1089DE5B1}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {5BEEC07B-67E3-4B64-BAA4-05A1089DE5B1}.Checked|arm.ActiveCfg = Debug|Any CPU + {5BEEC07B-67E3-4B64-BAA4-05A1089DE5B1}.Checked|arm64.ActiveCfg = Debug|Any CPU + {5BEEC07B-67E3-4B64-BAA4-05A1089DE5B1}.Checked|x64.ActiveCfg = Debug|Any CPU + {5BEEC07B-67E3-4B64-BAA4-05A1089DE5B1}.Checked|x86.ActiveCfg = Debug|Any CPU {355B775A-BFE1-4384-BC83-C6B5D1FB77BB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {355B775A-BFE1-4384-BC83-C6B5D1FB77BB}.Debug|Any CPU.Build.0 = Debug|Any CPU {355B775A-BFE1-4384-BC83-C6B5D1FB77BB}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -689,6 +712,7 @@ Global {CFF7519C-4D41-4713-991D-27777DA2DB21} = {751DA007-D916-4F22-AF16-85F343C2992C} {3278A0F9-8E0A-42E1-8FE3-1A01851A6248} = {751DA007-D916-4F22-AF16-85F343C2992C} {AFE5CE59-CCFC-472D-AE84-143F282335A6} = {BFBE3E0E-4E75-4665-A373-132D283D366D} + {5BEEC07B-67E3-4B64-BAA4-05A1089DE5B1} = {BFBE3E0E-4E75-4665-A373-132D283D366D} {355B775A-BFE1-4384-BC83-C6B5D1FB77BB} = {BFBE3E0E-4E75-4665-A373-132D283D366D} {66EC63BC-99DC-40CA-B53B-B4D8BF6D1630} = {BFBE3E0E-4E75-4665-A373-132D283D366D} {F9B974AE-C95E-4C9E-8F2F-0FAC091F7FF7} = {D6587945-D604-4FCB-B87A-230F32CD9E12} diff --git a/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/SettingsProperty.cs b/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/SettingsProperty.cs index 46719e8ece9..10310b40b55 100644 --- a/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/SettingsProperty.cs +++ b/src/libraries/System.Configuration.ConfigurationManager/src/System/Configuration/SettingsProperty.cs @@ -52,6 +52,10 @@ public SettingsProperty( throw new NotSupportedException(Obsoletions.BinaryFormatterMessage); } } + else + { + SerializeAs = serializeAs; + } Attributes = attributes; ThrowOnErrorDeserializing = throwOnErrorDeserializing; ThrowOnErrorSerializing = throwOnErrorSerializing; diff --git a/src/libraries/System.Configuration.ConfigurationManager/tests/System.Configuration.ConfigurationManager.Tests.csproj b/src/libraries/System.Configuration.ConfigurationManager/tests/System.Configuration.ConfigurationManager.Tests.csproj index d6cb608fded..a4582dbd358 100644 --- a/src/libraries/System.Configuration.ConfigurationManager/tests/System.Configuration.ConfigurationManager.Tests.csproj +++ b/src/libraries/System.Configuration.ConfigurationManager/tests/System.Configuration.ConfigurationManager.Tests.csproj @@ -78,6 +78,7 @@ + @@ -93,7 +94,7 @@ - + @@ -106,4 +107,10 @@ + + + + diff --git a/src/libraries/System.Configuration.ConfigurationManager/tests/System/Configuration/SettingsPropertyTests.cs b/src/libraries/System.Configuration.ConfigurationManager/tests/System/Configuration/SettingsPropertyTests.cs new file mode 100644 index 00000000000..6565d2f26ce --- /dev/null +++ b/src/libraries/System.Configuration.ConfigurationManager/tests/System/Configuration/SettingsPropertyTests.cs @@ -0,0 +1,53 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Configuration; +using Xunit; + +namespace System.ConfigurationTests +{ + public class SettingsPropertyTests + { + [Fact] + public void SettingsProperty_WithNoArguments() + { + var settingsProperty = new SettingsProperty("TestName"); + Assert.Equal("TestName", settingsProperty.Name); + Assert.False(settingsProperty.IsReadOnly); + Assert.Null(settingsProperty.DefaultValue); + Assert.Null(settingsProperty.PropertyType); + Assert.Equal(SettingsSerializeAs.String, settingsProperty.SerializeAs); + Assert.Null(settingsProperty.Provider); + Assert.NotNull(settingsProperty.Attributes); + Assert.False(settingsProperty.ThrowOnErrorDeserializing); + Assert.False(settingsProperty.ThrowOnErrorSerializing); + } + + [Theory] + [InlineData(SettingsSerializeAs.String)] + [InlineData(SettingsSerializeAs.Xml)] + [InlineData(SettingsSerializeAs.ProviderSpecific)] + public void SettingsProperty_WithArguments(SettingsSerializeAs serializeAs) + { + var settingsProperty = new SettingsProperty( + "TestName", + typeof(string), + provider: null, + isReadOnly: true, + "TestDefaultValue", + serializeAs, + new SettingsAttributeDictionary(), + throwOnErrorDeserializing: true, + throwOnErrorSerializing: false); + Assert.Equal("TestName", settingsProperty.Name); + Assert.True(settingsProperty.IsReadOnly); + Assert.Equal("TestDefaultValue", settingsProperty.DefaultValue); + Assert.Equal(typeof(string), settingsProperty.PropertyType); + Assert.Equal(serializeAs, settingsProperty.SerializeAs); + Assert.Null(settingsProperty.Provider); + Assert.NotNull(settingsProperty.Attributes); + Assert.True(settingsProperty.ThrowOnErrorDeserializing); + Assert.False(settingsProperty.ThrowOnErrorSerializing); + } + } +} diff --git a/src/libraries/System.Console/System.Console.sln b/src/libraries/System.Console/System.Console.sln index 2f2b36054cb..e24e6c442e4 100644 --- a/src/libraries/System.Console/System.Console.sln +++ b/src/libraries/System.Console/System.Console.sln @@ -11,6 +11,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Console.Tests", "tes EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{EEBFF320-0756-4467-ACAC-F946AA7D7902}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{F8A32DF2-8B25-44D1-8F3E-7FAC687FB22A}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{2B4D1069-DAB2-4A22-96A5-A12DF9B8CA22}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{128A0AF8-9794-49E3-8A07-E518EB9F1402}" @@ -73,6 +75,10 @@ Global {EEBFF320-0756-4467-ACAC-F946AA7D7902}.Debug|Any CPU.Build.0 = Debug|Any CPU {EEBFF320-0756-4467-ACAC-F946AA7D7902}.Release|Any CPU.ActiveCfg = Release|Any CPU {EEBFF320-0756-4467-ACAC-F946AA7D7902}.Release|Any CPU.Build.0 = Release|Any CPU + {F8A32DF2-8B25-44D1-8F3E-7FAC687FB22A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F8A32DF2-8B25-44D1-8F3E-7FAC687FB22A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F8A32DF2-8B25-44D1-8F3E-7FAC687FB22A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F8A32DF2-8B25-44D1-8F3E-7FAC687FB22A}.Release|Any CPU.Build.0 = Release|Any CPU {2B4D1069-DAB2-4A22-96A5-A12DF9B8CA22}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {2B4D1069-DAB2-4A22-96A5-A12DF9B8CA22}.Debug|Any CPU.Build.0 = Debug|Any CPU {2B4D1069-DAB2-4A22-96A5-A12DF9B8CA22}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -117,6 +123,7 @@ Global {4DF18F16-0F36-431E-BD64-5F1F0BACA0A6} = {87011BFC-F4A7-4BEB-A794-ED75999604BF} {7EAA30FF-8911-4427-BFAC-9FC8BF8B3606} = {5F676CAA-AE1E-4ACE-9769-FA07DA7F0F99} {EEBFF320-0756-4467-ACAC-F946AA7D7902} = {6A697E68-D9B1-47F4-8AC0-B528E9AA3727} + {F8A32DF2-8B25-44D1-8F3E-7FAC687FB22A} = {6A697E68-D9B1-47F4-8AC0-B528E9AA3727} {2B4D1069-DAB2-4A22-96A5-A12DF9B8CA22} = {6A697E68-D9B1-47F4-8AC0-B528E9AA3727} {128A0AF8-9794-49E3-8A07-E518EB9F1402} = {6A697E68-D9B1-47F4-8AC0-B528E9AA3727} {D55C47E2-C4C7-42C8-962D-44CCDC8FDC7B} = {0EC43FF3-51A9-45DD-8686-744CE1B3FF92} diff --git a/src/libraries/System.Console/ref/System.Console.cs b/src/libraries/System.Console/ref/System.Console.cs index 297f94aac0e..6d814278c1a 100644 --- a/src/libraries/System.Console/ref/System.Console.cs +++ b/src/libraries/System.Console/ref/System.Console.cs @@ -69,18 +69,10 @@ public static partial class Console [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")] [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")] public static bool TreatControlCAsInput { get { throw null; } set { } } - [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("android")] - [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("browser")] - [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")] - [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")] - public static int WindowHeight { get { throw null; } set { } } + public static int WindowHeight { [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("android"), System.Runtime.Versioning.UnsupportedOSPlatformAttribute("browser"), System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios"), System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")] get { throw null; } [System.Runtime.Versioning.SupportedOSPlatformAttribute("windows")] set { } } public static int WindowLeft { get { throw null; } [System.Runtime.Versioning.SupportedOSPlatformAttribute("windows")] set { } } public static int WindowTop { get { throw null; } [System.Runtime.Versioning.SupportedOSPlatformAttribute("windows")] set { } } - [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("android")] - [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("browser")] - [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")] - [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")] - public static int WindowWidth { get { throw null; } set { } } + public static int WindowWidth { [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("android"), System.Runtime.Versioning.UnsupportedOSPlatformAttribute("browser"), System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios"), System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")] get { throw null; } [System.Runtime.Versioning.SupportedOSPlatformAttribute("windows")] set { } } [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("android")] [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("browser")] [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")] @@ -155,10 +147,7 @@ public static void SetIn(System.IO.TextReader newIn) { } public static void SetOut(System.IO.TextWriter newOut) { } [System.Runtime.Versioning.SupportedOSPlatformAttribute("windows")] public static void SetWindowPosition(int left, int top) { } - [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("android")] - [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("browser")] - [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("ios")] - [System.Runtime.Versioning.UnsupportedOSPlatformAttribute("tvos")] + [System.Runtime.Versioning.SupportedOSPlatformAttribute("windows")] public static void SetWindowSize(int width, int height) { } public static void Write(bool value) { } public static void Write(char value) { } @@ -171,6 +160,7 @@ public static void Write(long value) { } public static void Write(object? value) { } public static void Write(float value) { } public static void Write(string? value) { } + public static void Write(System.ReadOnlySpan value) { } public static void Write([System.Diagnostics.CodeAnalysis.StringSyntaxAttribute("CompositeFormat")] string format, object? arg0) { } public static void Write([System.Diagnostics.CodeAnalysis.StringSyntaxAttribute("CompositeFormat")] string format, object? arg0, object? arg1) { } public static void Write([System.Diagnostics.CodeAnalysis.StringSyntaxAttribute("CompositeFormat")] string format, object? arg0, object? arg1, object? arg2) { } @@ -192,6 +182,7 @@ public static void WriteLine(long value) { } public static void WriteLine(object? value) { } public static void WriteLine(float value) { } public static void WriteLine(string? value) { } + public static void WriteLine(ReadOnlySpan value) { } public static void WriteLine([System.Diagnostics.CodeAnalysis.StringSyntaxAttribute("CompositeFormat")] string format, object? arg0) { } public static void WriteLine([System.Diagnostics.CodeAnalysis.StringSyntaxAttribute("CompositeFormat")] string format, object? arg0, object? arg1) { } public static void WriteLine([System.Diagnostics.CodeAnalysis.StringSyntaxAttribute("CompositeFormat")] string format, object? arg0, object? arg1, object? arg2) { } diff --git a/src/libraries/System.Console/src/System/Console.cs b/src/libraries/System.Console/src/System/Console.cs index 1948788067d..8664567c051 100644 --- a/src/libraries/System.Console/src/System/Console.cs +++ b/src/libraries/System.Console/src/System/Console.cs @@ -392,42 +392,27 @@ public static int WindowTop set { ConsolePal.WindowTop = value; } } - [UnsupportedOSPlatform("android")] - [UnsupportedOSPlatform("browser")] - [UnsupportedOSPlatform("ios")] - [UnsupportedOSPlatform("tvos")] public static int WindowWidth { + [UnsupportedOSPlatform("android")] + [UnsupportedOSPlatform("browser")] + [UnsupportedOSPlatform("ios")] + [UnsupportedOSPlatform("tvos")] get { return ConsolePal.WindowWidth; } - set - { - if (Console.IsOutputRedirected) - { - throw new IOException(SR.InvalidOperation_SetWindowSize); - } - - ArgumentOutOfRangeException.ThrowIfNegativeOrZero(value, nameof(WindowWidth)); - - ConsolePal.WindowWidth = value; - } + [SupportedOSPlatform("windows")] + set { ConsolePal.WindowWidth = value; } } - [UnsupportedOSPlatform("android")] - [UnsupportedOSPlatform("browser")] - [UnsupportedOSPlatform("ios")] - [UnsupportedOSPlatform("tvos")] public static int WindowHeight { + [UnsupportedOSPlatform("android")] + [UnsupportedOSPlatform("browser")] + [UnsupportedOSPlatform("ios")] + [UnsupportedOSPlatform("tvos")] get { return ConsolePal.WindowHeight; } + [SupportedOSPlatform("windows")] set { - if (Console.IsOutputRedirected) - { - throw new IOException(SR.InvalidOperation_SetWindowSize); - } - - ArgumentOutOfRangeException.ThrowIfNegativeOrZero(value, nameof(WindowHeight)); - ConsolePal.WindowHeight = value; } } @@ -438,20 +423,9 @@ public static void SetWindowPosition(int left, int top) ConsolePal.SetWindowPosition(left, top); } - [UnsupportedOSPlatform("android")] - [UnsupportedOSPlatform("browser")] - [UnsupportedOSPlatform("ios")] - [UnsupportedOSPlatform("tvos")] + [SupportedOSPlatform("windows")] public static void SetWindowSize(int width, int height) { - if (Console.IsOutputRedirected) - { - throw new IOException(SR.InvalidOperation_SetWindowSize); - } - - ArgumentOutOfRangeException.ThrowIfNegativeOrZero(width, nameof(width)); - ArgumentOutOfRangeException.ThrowIfNegativeOrZero(height, nameof(height)); - ConsolePal.SetWindowSize(width, height); } @@ -839,6 +813,12 @@ public static void WriteLine(string? value) Out.WriteLine(value); } + [MethodImplAttribute(MethodImplOptions.NoInlining)] + public static void WriteLine(ReadOnlySpan value) + { + Out.WriteLine(value); + } + [MethodImplAttribute(MethodImplOptions.NoInlining)] public static void WriteLine([StringSyntax(StringSyntaxAttribute.CompositeFormat)] string format, object? arg0) { @@ -995,6 +975,12 @@ public static void Write(string? value) Out.Write(value); } + [MethodImplAttribute(MethodImplOptions.NoInlining)] + public static void Write(ReadOnlySpan value) + { + Out.Write(value); + } + private static void HandlePosixSignal(PosixSignalContext ctx) { Debug.Assert(ctx.Signal == PosixSignal.SIGINT || ctx.Signal == PosixSignal.SIGQUIT); diff --git a/src/libraries/System.Console/src/System/ConsolePal.Unix.cs b/src/libraries/System.Console/src/System/ConsolePal.Unix.cs index 77a679150b2..e7acb0e8504 100644 --- a/src/libraries/System.Console/src/System/ConsolePal.Unix.cs +++ b/src/libraries/System.Console/src/System/ConsolePal.Unix.cs @@ -378,24 +378,11 @@ private static void GetWindowSize(out int width, out int height) public static void SetWindowSize(int width, int height) { - lock (Console.Out) - { - Interop.Sys.WinSize winsize = default; - winsize.Row = (ushort)height; - winsize.Col = (ushort)width; - if (Interop.Sys.SetWindowSize(in winsize) == 0) - { - s_windowWidth = winsize.Col; - s_windowHeight = winsize.Row; - } - else - { - Interop.ErrorInfo errorInfo = Interop.Sys.GetLastErrorInfo(); - throw errorInfo.Error == Interop.Error.ENOTSUP ? - new PlatformNotSupportedException() : - Interop.GetIOException(errorInfo); - } - } + // note: We can't implement SetWindowSize using TIOCSWINSZ. + // TIOCSWINSZ is meant to inform the kernel of the terminal size. + // The window that shows the terminal doesn't change to match that size. + + throw new PlatformNotSupportedException(); } public static bool CursorVisible diff --git a/src/libraries/System.Console/src/System/ConsolePal.Windows.cs b/src/libraries/System.Console/src/System/ConsolePal.Windows.cs index 03f74d941f9..9bcc2ac38f6 100644 --- a/src/libraries/System.Console/src/System/ConsolePal.Windows.cs +++ b/src/libraries/System.Console/src/System/ConsolePal.Windows.cs @@ -1012,6 +1012,14 @@ public static unsafe void SetWindowPosition(int left, int top) public static unsafe void SetWindowSize(int width, int height) { + if (Console.IsOutputRedirected) + { + throw new IOException(SR.InvalidOperation_SetWindowSize); + } + + ArgumentOutOfRangeException.ThrowIfNegativeOrZero(width, nameof(width)); + ArgumentOutOfRangeException.ThrowIfNegativeOrZero(height, nameof(height)); + // Get the position of the current console window Interop.Kernel32.CONSOLE_SCREEN_BUFFER_INFO csbi = GetBufferInfo(); diff --git a/src/libraries/System.Console/tests/ManualTests/ManualTests.cs b/src/libraries/System.Console/tests/ManualTests/ManualTests.cs index 67d1bf2721a..de603921c8f 100644 --- a/src/libraries/System.Console/tests/ManualTests/ManualTests.cs +++ b/src/libraries/System.Console/tests/ManualTests/ManualTests.cs @@ -5,9 +5,7 @@ using System.Diagnostics; using System.Threading.Tasks; using System.IO; -using System.Runtime.InteropServices; using System.Text; -using System.Threading; using Xunit; namespace System @@ -334,37 +332,6 @@ public static void CursorLeftFromLastColumn() AssertUserExpectedResults("single line with '1' at the start and '2' at the end."); } - [ConditionalFact(nameof(ManualTestsEnabled))] - [SkipOnPlatform(TestPlatforms.Browser | TestPlatforms.iOS | TestPlatforms.MacCatalyst | TestPlatforms.tvOS, "Not supported on Browser, iOS, MacCatalyst, or tvOS.")] - public static void ResizeTest() - { - bool wasResized = false; - - using (ManualResetEvent manualResetEvent = new(false)) - using (PosixSignalRegistration.Create(PosixSignal.SIGWINCH, - ctx => - { - wasResized = true; - Assert.Equal(PosixSignal.SIGWINCH, ctx.Signal); - manualResetEvent.Set(); - })) - { - int widthBefore = Console.WindowWidth; - int heightBefore = Console.WindowHeight; - - Assert.False(wasResized); - - Console.SetWindowSize(widthBefore / 2, heightBefore / 2); - - Assert.True(manualResetEvent.WaitOne(TimeSpan.FromMilliseconds(50))); - Assert.True(wasResized); - Assert.Equal(widthBefore / 2, Console.WindowWidth ); - Assert.Equal(heightBefore / 2, Console.WindowHeight ); - - Console.SetWindowSize(widthBefore, heightBefore); - } - } - private static void AssertUserExpectedResults(string expected) { Console.Write($"Did you see {expected}? [y/n] "); diff --git a/src/libraries/System.Console/tests/ReadAndWrite.cs b/src/libraries/System.Console/tests/ReadAndWrite.cs index 3e165d38263..546ce256869 100644 --- a/src/libraries/System.Console/tests/ReadAndWrite.cs +++ b/src/libraries/System.Console/tests/ReadAndWrite.cs @@ -105,6 +105,7 @@ private static void WriteCore() Console.Write(50UL); Console.Write(new object()); Console.Write("Hello World"); + Console.Write("Hello World".AsSpan()); } private static void WriteLineCore() @@ -145,6 +146,7 @@ private static void WriteLineCore() Console.WriteLine(50UL); Console.WriteLine(new object()); Console.WriteLine("Hello World"); + Console.WriteLine("Hello World".AsSpan()); } [Fact] @@ -187,6 +189,7 @@ public static async Task OutWriteAndWriteLineOverloads() writer.Write(50UL); writer.Write(new object()); writer.Write("Hello World"); + writer.Write("Hello World".AsSpan()); writer.Flush(); diff --git a/src/libraries/System.Console/tests/WindowAndCursorProps.cs b/src/libraries/System.Console/tests/WindowAndCursorProps.cs index 3f70f02019d..edac5a39987 100644 --- a/src/libraries/System.Console/tests/WindowAndCursorProps.cs +++ b/src/libraries/System.Console/tests/WindowAndCursorProps.cs @@ -46,7 +46,7 @@ public static void SetBufferSize_Unix_ThrowsPlatformNotSupportedException() } [Theory] - [PlatformSpecific((TestPlatforms.Windows) | (TestPlatforms.AnyUnix & ~TestPlatforms.Browser & ~TestPlatforms.iOS & ~TestPlatforms.MacCatalyst & ~TestPlatforms.tvOS))] + [PlatformSpecific(TestPlatforms.Windows)] [InlineData(0)] [InlineData(-1)] public static void WindowWidth_SetInvalid_ThrowsArgumentOutOfRangeException(int value) @@ -71,14 +71,14 @@ public static void WindowWidth_GetUnix_Success() } [Fact] - [PlatformSpecific(TestPlatforms.iOS | TestPlatforms.MacCatalyst | TestPlatforms.tvOS)] // Expected behavior specific to Unix + [PlatformSpecific(TestPlatforms.AnyUnix)] public static void WindowWidth_SetUnix_ThrowsPlatformNotSupportedException() { Assert.Throws(() => Console.WindowWidth = 100); } [Theory] - [PlatformSpecific((TestPlatforms.Windows) | (TestPlatforms.AnyUnix & ~TestPlatforms.Browser & ~TestPlatforms.iOS & ~TestPlatforms.MacCatalyst & ~TestPlatforms.tvOS))] + [PlatformSpecific(TestPlatforms.Windows)] [InlineData(0)] [InlineData(-1)] public static void WindowHeight_SetInvalid_ThrowsArgumentOutOfRangeException(int value) @@ -111,7 +111,7 @@ public static void LargestWindowWidth_UnixGet_ReturnsExpected() } [Fact] - [PlatformSpecific(TestPlatforms.Browser | TestPlatforms.iOS | TestPlatforms.MacCatalyst | TestPlatforms.tvOS)] // Expected behavior specific to Unix + [PlatformSpecific(TestPlatforms.AnyUnix)] public static void WindowHeight_SetUnix_ThrowsPlatformNotSupportedException() { Assert.Throws(() => Console.WindowHeight = 100); @@ -579,7 +579,7 @@ public void SetWindowSize_GetWindowSize_ReturnsExpected() } [Fact] - [PlatformSpecific(TestPlatforms.Browser | TestPlatforms.iOS | TestPlatforms.MacCatalyst | TestPlatforms.tvOS)] + [PlatformSpecific(TestPlatforms.AnyUnix)] public void SetWindowSize_Unix_ThrowsPlatformNotSupportedException() { Assert.Throws(() => Console.SetWindowSize(50, 50)); diff --git a/src/libraries/System.Data.Common/System.Data.Common.sln b/src/libraries/System.Data.Common/System.Data.Common.sln index e377ad86749..fb0f4d09e35 100644 --- a/src/libraries/System.Data.Common/System.Data.Common.sln +++ b/src/libraries/System.Data.Common/System.Data.Common.sln @@ -43,6 +43,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Resources.Writer", " EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{293AF059-A4CC-43FE-9A5F-E19579B4F7AC}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{6930EAE4-16B1-44E9-9E54-5B4C331C61A8}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{44DCA516-EEB1-4976-9794-9D6A26A952E9}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{D291982D-1FC0-4CA2-A39F-4B490F809F01}" @@ -575,6 +577,27 @@ Global {293AF059-A4CC-43FE-9A5F-E19579B4F7AC}.Checked|arm64.ActiveCfg = Debug|Any CPU {293AF059-A4CC-43FE-9A5F-E19579B4F7AC}.Checked|x64.ActiveCfg = Debug|Any CPU {293AF059-A4CC-43FE-9A5F-E19579B4F7AC}.Checked|x86.ActiveCfg = Debug|Any CPU + {6930EAE4-16B1-44E9-9E54-5B4C331C61A8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {6930EAE4-16B1-44E9-9E54-5B4C331C61A8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {6930EAE4-16B1-44E9-9E54-5B4C331C61A8}.Debug|arm.ActiveCfg = Debug|Any CPU + {6930EAE4-16B1-44E9-9E54-5B4C331C61A8}.Debug|arm64.ActiveCfg = Debug|Any CPU + {6930EAE4-16B1-44E9-9E54-5B4C331C61A8}.Debug|x64.ActiveCfg = Debug|Any CPU + {6930EAE4-16B1-44E9-9E54-5B4C331C61A8}.Debug|x64.Build.0 = Debug|Any CPU + {6930EAE4-16B1-44E9-9E54-5B4C331C61A8}.Debug|x86.ActiveCfg = Debug|Any CPU + {6930EAE4-16B1-44E9-9E54-5B4C331C61A8}.Debug|x86.Build.0 = Debug|Any CPU + {6930EAE4-16B1-44E9-9E54-5B4C331C61A8}.Release|Any CPU.ActiveCfg = Release|Any CPU + {6930EAE4-16B1-44E9-9E54-5B4C331C61A8}.Release|Any CPU.Build.0 = Release|Any CPU + {6930EAE4-16B1-44E9-9E54-5B4C331C61A8}.Release|arm.ActiveCfg = Release|Any CPU + {6930EAE4-16B1-44E9-9E54-5B4C331C61A8}.Release|arm64.ActiveCfg = Release|Any CPU + {6930EAE4-16B1-44E9-9E54-5B4C331C61A8}.Release|x64.ActiveCfg = Release|Any CPU + {6930EAE4-16B1-44E9-9E54-5B4C331C61A8}.Release|x64.Build.0 = Release|Any CPU + {6930EAE4-16B1-44E9-9E54-5B4C331C61A8}.Release|x86.ActiveCfg = Release|Any CPU + {6930EAE4-16B1-44E9-9E54-5B4C331C61A8}.Release|x86.Build.0 = Release|Any CPU + {6930EAE4-16B1-44E9-9E54-5B4C331C61A8}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {6930EAE4-16B1-44E9-9E54-5B4C331C61A8}.Checked|arm.ActiveCfg = Debug|Any CPU + {6930EAE4-16B1-44E9-9E54-5B4C331C61A8}.Checked|arm64.ActiveCfg = Debug|Any CPU + {6930EAE4-16B1-44E9-9E54-5B4C331C61A8}.Checked|x64.ActiveCfg = Debug|Any CPU + {6930EAE4-16B1-44E9-9E54-5B4C331C61A8}.Checked|x86.ActiveCfg = Debug|Any CPU {44DCA516-EEB1-4976-9794-9D6A26A952E9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {44DCA516-EEB1-4976-9794-9D6A26A952E9}.Debug|Any CPU.Build.0 = Debug|Any CPU {44DCA516-EEB1-4976-9794-9D6A26A952E9}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -880,6 +903,7 @@ Global {521CFFC1-DB45-4FB2-87EF-6BF4F413A011} = {79588763-C99B-4C1B-88D3-181A92A98364} {D5A85F0E-509A-424F-BFD0-A7CC38D43CCD} = {D92FD5A3-15A6-4EFA-ADC9-4DDEE8D31782} {293AF059-A4CC-43FE-9A5F-E19579B4F7AC} = {D92FD5A3-15A6-4EFA-ADC9-4DDEE8D31782} + {6930EAE4-16B1-44E9-9E54-5B4C331C61A8} = {D92FD5A3-15A6-4EFA-ADC9-4DDEE8D31782} {44DCA516-EEB1-4976-9794-9D6A26A952E9} = {D92FD5A3-15A6-4EFA-ADC9-4DDEE8D31782} {D291982D-1FC0-4CA2-A39F-4B490F809F01} = {D92FD5A3-15A6-4EFA-ADC9-4DDEE8D31782} {EDDAE59E-8700-49DC-8E46-534037F7F476} = {D92FD5A3-15A6-4EFA-ADC9-4DDEE8D31782} diff --git a/src/libraries/System.Data.Common/src/Resources/Strings.resx b/src/libraries/System.Data.Common/src/Resources/Strings.resx index 8c3c530ceb3..4b5d9b14a66 100644 --- a/src/libraries/System.Data.Common/src/Resources/Strings.resx +++ b/src/libraries/System.Data.Common/src/Resources/Strings.resx @@ -527,4 +527,5 @@ The DataRowComparer does not work with DataRows that have been deleted since it only compares current values. The source contains a deleted DataRow that cannot be copied to the DataTable. Cannot cast DBNull. Value to type '{0}'. Please use a nullable type. + DataSet implementation of IXmlSerializable is not trim compatible and has been disabled in the app configuration. diff --git a/src/libraries/System.Data.Common/src/System/Data/DataSet.cs b/src/libraries/System.Data.Common/src/System/Data/DataSet.cs index 37c1fb283d7..56fa3c9118f 100644 --- a/src/libraries/System.Data.Common/src/System/Data/DataSet.cs +++ b/src/libraries/System.Data.Common/src/System/Data/DataSet.cs @@ -77,6 +77,12 @@ public class DataSet : MarshalByValueComponent, IListSource, IXmlSerializable, I internal bool _useDataSetSchemaOnly; // UseDataSetSchemaOnly , for YUKON internal bool _udtIsWrapped; // if UDT is wrapped , for YUKON + [FeatureSwitchDefinition("System.Data.DataSet.XmlSerializationIsSupported")] + [FeatureGuard(typeof(RequiresUnreferencedCodeAttribute))] +#pragma warning disable IL4000 + internal static bool XmlSerializationIsSupported => AppContext.TryGetSwitch("System.Data.DataSet.XmlSerializationIsSupported", out bool isSupported) ? isSupported : true; +#pragma warning restore IL4000 + /// /// Initializes a new instance of the class. /// @@ -3459,6 +3465,11 @@ public static XmlSchemaComplexType GetDataSetSchema(XmlSchemaSet? schemaSet) XmlSchema? IXmlSerializable.GetSchema() { + if (!XmlSerializationIsSupported) + { + throw new NotSupportedException(SR.DataSet_XmlSerializationUnsupported); + } + if (GetType() == typeof(DataSet)) { return null; @@ -3469,9 +3480,7 @@ public static XmlSchemaComplexType GetDataSetSchema(XmlSchemaSet? schemaSet) XmlWriter writer = new XmlTextWriter(stream, null); if (writer != null) { -#pragma warning disable IL2026 // suppressed in ILLink.Suppressions.LibraryBuild.xml WriteXmlSchema(this, writer); -#pragma warning restore IL2026 } stream.Position = 0; return XmlSchema.Read(new XmlTextReader(stream), null); @@ -3485,6 +3494,11 @@ private static void WriteXmlSchema(DataSet ds, XmlWriter writer) void IXmlSerializable.ReadXml(XmlReader reader) { + if (!XmlSerializationIsSupported) + { + throw new NotSupportedException(SR.DataSet_XmlSerializationUnsupported); + } + bool fNormalization = true; XmlTextReader? xmlTextReader = null; IXmlTextParser? xmlTextParser = reader as IXmlTextParser; @@ -3503,9 +3517,7 @@ void IXmlSerializable.ReadXml(XmlReader reader) } } -#pragma warning disable IL2026 // suppressed in ILLink.Suppressions.LibraryBuild.xml ReadXmlSerializableInternal(reader); -#pragma warning restore IL2026 if (xmlTextParser != null) { @@ -3525,9 +3537,12 @@ private void ReadXmlSerializableInternal(XmlReader reader) void IXmlSerializable.WriteXml(XmlWriter writer) { -#pragma warning disable IL2026 // suppressed in ILLink.Suppressions.LibraryBuild.xml + if (!XmlSerializationIsSupported) + { + throw new NotSupportedException(SR.DataSet_XmlSerializationUnsupported); + } + WriteXmlInternal(writer); -#pragma warning restore IL2026 } [RequiresUnreferencedCode("DataSet.WriteXml uses XmlSerialization underneath which is not trimming safe. Members from serialized types may be trimmed if not referenced directly.")] diff --git a/src/libraries/System.Data.Common/src/System/Data/DataTable.cs b/src/libraries/System.Data.Common/src/System/Data/DataTable.cs index dedde6f7efb..ab92707b1c2 100644 --- a/src/libraries/System.Data.Common/src/System/Data/DataTable.cs +++ b/src/libraries/System.Data.Common/src/System/Data/DataTable.cs @@ -6664,9 +6664,15 @@ public static XmlSchemaComplexType GetDataTableSchema(XmlSchemaSet? schemaSet) return type; } -#pragma warning disable IL2026 // suppressed in ILLink.Suppressions.LibraryBuild.xml - XmlSchema? IXmlSerializable.GetSchema() => GetXmlSchema(); -#pragma warning restore IL2026 + XmlSchema? IXmlSerializable.GetSchema() + { + if (!DataSet.XmlSerializationIsSupported) + { + throw new NotSupportedException(SR.DataSet_XmlSerializationUnsupported); + } + + return GetXmlSchema(); + } [RequiresUnreferencedCode(DataSet.RequiresUnreferencedCodeMessage)] [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2046:UnrecognizedReflectionPattern", @@ -6693,6 +6699,11 @@ public static XmlSchemaComplexType GetDataTableSchema(XmlSchemaSet? schemaSet) void IXmlSerializable.ReadXml(XmlReader reader) { + if (!DataSet.XmlSerializationIsSupported) + { + throw new NotSupportedException(SR.DataSet_XmlSerializationUnsupported); + } + IXmlTextParser? textReader = reader as IXmlTextParser; bool fNormalization = true; if (textReader != null) @@ -6700,9 +6711,7 @@ void IXmlSerializable.ReadXml(XmlReader reader) fNormalization = textReader.Normalized; textReader.Normalized = false; } -#pragma warning disable IL2026 // suppressed in ILLink.Suppressions.LibraryBuild.xml ReadXmlSerializableInternal(reader); -#pragma warning restore IL2026 if (textReader != null) { @@ -6718,9 +6727,12 @@ private void ReadXmlSerializableInternal(XmlReader reader) void IXmlSerializable.WriteXml(XmlWriter writer) { -#pragma warning disable IL2026 // suppressed in ILLink.Suppressions.LibraryBuild.xml + if (!DataSet.XmlSerializationIsSupported) + { + throw new NotSupportedException(SR.DataSet_XmlSerializationUnsupported); + } + WriteXmlInternal(writer); -#pragma warning restore IL2026 } [RequiresUnreferencedCode("DataTable.WriteXml uses XmlSerialization underneath which is not trimming safe. Members from serialized types may be trimmed if not referenced directly.")] diff --git a/src/libraries/System.Data.Common/tests/System.Data.Common.Tests.csproj b/src/libraries/System.Data.Common/tests/System.Data.Common.Tests.csproj index ae85c66d7e8..dd1046a757c 100644 --- a/src/libraries/System.Data.Common/tests/System.Data.Common.Tests.csproj +++ b/src/libraries/System.Data.Common/tests/System.Data.Common.Tests.csproj @@ -118,6 +118,11 @@ Link="Common\System\Diagnostics\Tracing\TestEventListener.cs" /> + + + diff --git a/src/libraries/System.Data.Common/tests/TrimmingTests/DataSetXmlSerialization.cs b/src/libraries/System.Data.Common/tests/TrimmingTests/DataSetXmlSerialization.cs new file mode 100644 index 00000000000..502133d912d --- /dev/null +++ b/src/libraries/System.Data.Common/tests/TrimmingTests/DataSetXmlSerialization.cs @@ -0,0 +1,82 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Data; +using System.Xml.Schema; +using System.Xml.Serialization; + +namespace DataSetXmlSerializationTrimmingTests +{ + class Program + { + static int Main(string[] args) + { + IXmlSerializable xmlSerializable = new DataSet(); + + // Calling GetSchema should throw NotSupportedException + try + { + xmlSerializable.GetSchema(); + return -1; + } + catch (NotSupportedException) + { + } + + // Calling ReadXml should throw NotSupportedException + try + { + xmlSerializable.ReadXml(null); + return -2; + } + catch (NotSupportedException) + { + } + + // Calling WriteXml should throw NotSupportedException + try + { + xmlSerializable.WriteXml(null); + return -3; + } + catch (NotSupportedException) + { + } + + xmlSerializable = new DataTable(); + + // Calling GetSchema should throw NotSupportedException + try + { + xmlSerializable.GetSchema(); + return -4; + } + catch (NotSupportedException) + { + } + + // Calling ReadXml should throw NotSupportedException + try + { + xmlSerializable.ReadXml(null); + return -5; + } + catch (NotSupportedException) + { + } + + // Calling WriteXml should throw NotSupportedException + try + { + xmlSerializable.WriteXml(null); + return -6; + } + catch (NotSupportedException) + { + } + + return 100; + } + } +} diff --git a/src/libraries/System.Data.Common/tests/TrimmingTests/System.Data.Common.TrimmingTests.proj b/src/libraries/System.Data.Common/tests/TrimmingTests/System.Data.Common.TrimmingTests.proj index 7254c33fc9c..9d59bb0f97e 100644 --- a/src/libraries/System.Data.Common/tests/TrimmingTests/System.Data.Common.TrimmingTests.proj +++ b/src/libraries/System.Data.Common/tests/TrimmingTests/System.Data.Common.TrimmingTests.proj @@ -4,6 +4,9 @@ + + System.Data.DataSet.XmlSerializationIsSupported + diff --git a/src/libraries/System.Data.Odbc/Directory.Build.props b/src/libraries/System.Data.Odbc/Directory.Build.props index c843a6347ce..3a3d8f98324 100644 --- a/src/libraries/System.Data.Odbc/Directory.Build.props +++ b/src/libraries/System.Data.Odbc/Directory.Build.props @@ -2,6 +2,6 @@ true - browser + browser;wasi \ No newline at end of file diff --git a/src/libraries/System.Data.Odbc/System.Data.Odbc.sln b/src/libraries/System.Data.Odbc/System.Data.Odbc.sln index fc92668a192..830c2caf46b 100644 --- a/src/libraries/System.Data.Odbc/System.Data.Odbc.sln +++ b/src/libraries/System.Data.Odbc/System.Data.Odbc.sln @@ -7,18 +7,10 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Data.Odbc", "src\Sys EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Data.Odbc.Tests", "tests\System.Data.Odbc.Tests.csproj", "{B0451507-A304-47CB-B14F-257E44B8AC18}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{8DD9B5E3-A86A-4E2D-9CD4-567E358184FE}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{76183E18-B488-4466-AEE5-3C5D0B3CD917}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{15FB5B87-7452-45A1-B880-4DAA72BFF971}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{C41CDCD9-00FB-4A87-893A-9E4788790EE7}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Runtime", "..\System.Runtime\ref\System.Runtime.csproj", "{239BC95C-775B-4694-9DBD-BCC653529C85}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Text.Encoding.CodePages", "..\System.Text.Encoding.CodePages\ref\System.Text.Encoding.CodePages.csproj", "{D7E6B130-F82B-40B6-B76C-BD6451753BE1}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Text.Encoding.CodePages", "..\System.Text.Encoding.CodePages\src\System.Text.Encoding.CodePages.csproj", "{BD3A8348-A2AC-468A-B8D9-B639190B0FD8}" -EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ILLink.CodeFixProvider", "..\..\tools\illink\src\ILLink.CodeFix\ILLink.CodeFixProvider.csproj", "{3884A327-F48F-402A-8A7D-53B2040391CB}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ILLink.RoslynAnalyzer", "..\..\tools\illink\src\ILLink.RoslynAnalyzer\ILLink.RoslynAnalyzer.csproj", "{DEEDEF15-3088-4AEE-ADBE-9AC13D930C1A}" @@ -67,30 +59,14 @@ Global {B0451507-A304-47CB-B14F-257E44B8AC18}.Debug|Any CPU.Build.0 = Debug|Any CPU {B0451507-A304-47CB-B14F-257E44B8AC18}.Release|Any CPU.ActiveCfg = Release|Any CPU {B0451507-A304-47CB-B14F-257E44B8AC18}.Release|Any CPU.Build.0 = Release|Any CPU - {8DD9B5E3-A86A-4E2D-9CD4-567E358184FE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {8DD9B5E3-A86A-4E2D-9CD4-567E358184FE}.Debug|Any CPU.Build.0 = Debug|Any CPU - {8DD9B5E3-A86A-4E2D-9CD4-567E358184FE}.Release|Any CPU.ActiveCfg = Release|Any CPU - {8DD9B5E3-A86A-4E2D-9CD4-567E358184FE}.Release|Any CPU.Build.0 = Release|Any CPU - {76183E18-B488-4466-AEE5-3C5D0B3CD917}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {76183E18-B488-4466-AEE5-3C5D0B3CD917}.Debug|Any CPU.Build.0 = Debug|Any CPU - {76183E18-B488-4466-AEE5-3C5D0B3CD917}.Release|Any CPU.ActiveCfg = Release|Any CPU - {76183E18-B488-4466-AEE5-3C5D0B3CD917}.Release|Any CPU.Build.0 = Release|Any CPU + {15FB5B87-7452-45A1-B880-4DAA72BFF971}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {15FB5B87-7452-45A1-B880-4DAA72BFF971}.Debug|Any CPU.Build.0 = Debug|Any CPU + {15FB5B87-7452-45A1-B880-4DAA72BFF971}.Release|Any CPU.ActiveCfg = Release|Any CPU + {15FB5B87-7452-45A1-B880-4DAA72BFF971}.Release|Any CPU.Build.0 = Release|Any CPU {C41CDCD9-00FB-4A87-893A-9E4788790EE7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {C41CDCD9-00FB-4A87-893A-9E4788790EE7}.Debug|Any CPU.Build.0 = Debug|Any CPU {C41CDCD9-00FB-4A87-893A-9E4788790EE7}.Release|Any CPU.ActiveCfg = Release|Any CPU {C41CDCD9-00FB-4A87-893A-9E4788790EE7}.Release|Any CPU.Build.0 = Release|Any CPU - {239BC95C-775B-4694-9DBD-BCC653529C85}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {239BC95C-775B-4694-9DBD-BCC653529C85}.Debug|Any CPU.Build.0 = Debug|Any CPU - {239BC95C-775B-4694-9DBD-BCC653529C85}.Release|Any CPU.ActiveCfg = Release|Any CPU - {239BC95C-775B-4694-9DBD-BCC653529C85}.Release|Any CPU.Build.0 = Release|Any CPU - {D7E6B130-F82B-40B6-B76C-BD6451753BE1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {D7E6B130-F82B-40B6-B76C-BD6451753BE1}.Debug|Any CPU.Build.0 = Debug|Any CPU - {D7E6B130-F82B-40B6-B76C-BD6451753BE1}.Release|Any CPU.ActiveCfg = Release|Any CPU - {D7E6B130-F82B-40B6-B76C-BD6451753BE1}.Release|Any CPU.Build.0 = Release|Any CPU - {BD3A8348-A2AC-468A-B8D9-B639190B0FD8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {BD3A8348-A2AC-468A-B8D9-B639190B0FD8}.Debug|Any CPU.Build.0 = Debug|Any CPU - {BD3A8348-A2AC-468A-B8D9-B639190B0FD8}.Release|Any CPU.ActiveCfg = Release|Any CPU - {BD3A8348-A2AC-468A-B8D9-B639190B0FD8}.Release|Any CPU.Build.0 = Release|Any CPU {3884A327-F48F-402A-8A7D-53B2040391CB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {3884A327-F48F-402A-8A7D-53B2040391CB}.Debug|Any CPU.Build.0 = Debug|Any CPU {3884A327-F48F-402A-8A7D-53B2040391CB}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -119,12 +95,8 @@ Global {04309507-4EF4-4B93-9C4C-B2B538227C65} = {D561F200-5EE8-46AF-A1B8-537A2A0EFA8F} {B0451507-A304-47CB-B14F-257E44B8AC18} = {D561F200-5EE8-46AF-A1B8-537A2A0EFA8F} {531EA13B-CADA-4EBF-840B-4CE996247317} = {08F7B256-AB13-4784-98C4-737888DC7428} - {239BC95C-775B-4694-9DBD-BCC653529C85} = {08F7B256-AB13-4784-98C4-737888DC7428} - {D7E6B130-F82B-40B6-B76C-BD6451753BE1} = {08F7B256-AB13-4784-98C4-737888DC7428} {EDE27BD9-9134-4118-94BD-C9782811684D} = {416AFA87-B3A9-4F0C-822F-BB08F8837609} - {BD3A8348-A2AC-468A-B8D9-B639190B0FD8} = {416AFA87-B3A9-4F0C-822F-BB08F8837609} - {8DD9B5E3-A86A-4E2D-9CD4-567E358184FE} = {4A564597-B792-466F-A641-DC264A3D6C66} - {76183E18-B488-4466-AEE5-3C5D0B3CD917} = {4A564597-B792-466F-A641-DC264A3D6C66} + {15FB5B87-7452-45A1-B880-4DAA72BFF971} = {4A564597-B792-466F-A641-DC264A3D6C66} {C41CDCD9-00FB-4A87-893A-9E4788790EE7} = {4A564597-B792-466F-A641-DC264A3D6C66} {3884A327-F48F-402A-8A7D-53B2040391CB} = {A36F3BE8-9F0C-47C0-9670-0F6CDBD32F03} {DEEDEF15-3088-4AEE-ADBE-9AC13D930C1A} = {A36F3BE8-9F0C-47C0-9670-0F6CDBD32F03} diff --git a/src/libraries/System.Data.Odbc/src/System.Data.Odbc.csproj b/src/libraries/System.Data.Odbc/src/System.Data.Odbc.csproj index 26d8469f76d..13e559dbb3c 100644 --- a/src/libraries/System.Data.Odbc/src/System.Data.Odbc.csproj +++ b/src/libraries/System.Data.Odbc/src/System.Data.Odbc.csproj @@ -157,8 +157,4 @@ System.Data.Odbc.OdbcTransaction - - - - diff --git a/src/libraries/System.Data.OleDb/System.Data.Oledb.sln b/src/libraries/System.Data.OleDb/System.Data.Oledb.sln index 608a8ce7732..f6206fe2435 100644 --- a/src/libraries/System.Data.OleDb/System.Data.Oledb.sln +++ b/src/libraries/System.Data.OleDb/System.Data.Oledb.sln @@ -31,6 +31,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", ". EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.Uri", "..\System.Private.Uri\src\System.Private.Uri.csproj", "{B90DD406-44B4-47A9-8BB7-75452A95751F}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{23DB0ED8-6962-49A7-9C39-7F880ED1BA76}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{A2ED3B1E-5AAC-47AF-BDCE-B59226B65E63}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{C273C3A4-5651-489C-9FA4-2DCAAA7A7D97}" @@ -441,6 +443,27 @@ Global {B90DD406-44B4-47A9-8BB7-75452A95751F}.Checked|arm64.ActiveCfg = Debug|Any CPU {B90DD406-44B4-47A9-8BB7-75452A95751F}.Checked|x64.ActiveCfg = Debug|Any CPU {B90DD406-44B4-47A9-8BB7-75452A95751F}.Checked|x86.ActiveCfg = Debug|Any CPU + {23DB0ED8-6962-49A7-9C39-7F880ED1BA76}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {23DB0ED8-6962-49A7-9C39-7F880ED1BA76}.Debug|Any CPU.Build.0 = Debug|Any CPU + {23DB0ED8-6962-49A7-9C39-7F880ED1BA76}.Debug|arm.ActiveCfg = Debug|Any CPU + {23DB0ED8-6962-49A7-9C39-7F880ED1BA76}.Debug|arm64.ActiveCfg = Debug|Any CPU + {23DB0ED8-6962-49A7-9C39-7F880ED1BA76}.Debug|x64.ActiveCfg = Debug|Any CPU + {23DB0ED8-6962-49A7-9C39-7F880ED1BA76}.Debug|x64.Build.0 = Debug|Any CPU + {23DB0ED8-6962-49A7-9C39-7F880ED1BA76}.Debug|x86.ActiveCfg = Debug|Any CPU + {23DB0ED8-6962-49A7-9C39-7F880ED1BA76}.Debug|x86.Build.0 = Debug|Any CPU + {23DB0ED8-6962-49A7-9C39-7F880ED1BA76}.Release|Any CPU.ActiveCfg = Release|Any CPU + {23DB0ED8-6962-49A7-9C39-7F880ED1BA76}.Release|Any CPU.Build.0 = Release|Any CPU + {23DB0ED8-6962-49A7-9C39-7F880ED1BA76}.Release|arm.ActiveCfg = Release|Any CPU + {23DB0ED8-6962-49A7-9C39-7F880ED1BA76}.Release|arm64.ActiveCfg = Release|Any CPU + {23DB0ED8-6962-49A7-9C39-7F880ED1BA76}.Release|x64.ActiveCfg = Release|Any CPU + {23DB0ED8-6962-49A7-9C39-7F880ED1BA76}.Release|x64.Build.0 = Release|Any CPU + {23DB0ED8-6962-49A7-9C39-7F880ED1BA76}.Release|x86.ActiveCfg = Release|Any CPU + {23DB0ED8-6962-49A7-9C39-7F880ED1BA76}.Release|x86.Build.0 = Release|Any CPU + {23DB0ED8-6962-49A7-9C39-7F880ED1BA76}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {23DB0ED8-6962-49A7-9C39-7F880ED1BA76}.Checked|arm.ActiveCfg = Debug|Any CPU + {23DB0ED8-6962-49A7-9C39-7F880ED1BA76}.Checked|arm64.ActiveCfg = Debug|Any CPU + {23DB0ED8-6962-49A7-9C39-7F880ED1BA76}.Checked|x64.ActiveCfg = Debug|Any CPU + {23DB0ED8-6962-49A7-9C39-7F880ED1BA76}.Checked|x86.ActiveCfg = Debug|Any CPU {A2ED3B1E-5AAC-47AF-BDCE-B59226B65E63}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {A2ED3B1E-5AAC-47AF-BDCE-B59226B65E63}.Debug|Any CPU.Build.0 = Debug|Any CPU {A2ED3B1E-5AAC-47AF-BDCE-B59226B65E63}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -785,6 +808,7 @@ Global {C73C11A5-863A-440D-B568-00CA5E7C9DA0} = {9AB0B44D-9A64-449F-A0CD-07D39ABEF343} {D7C9E59C-0B7B-491E-9FC5-63A29290EE06} = {9AB0B44D-9A64-449F-A0CD-07D39ABEF343} {B749BF37-D346-475F-8C22-13C67A7DA2B6} = {39D097CC-4757-405F-B3C5-17B8050F438C} + {23DB0ED8-6962-49A7-9C39-7F880ED1BA76} = {39D097CC-4757-405F-B3C5-17B8050F438C} {A2ED3B1E-5AAC-47AF-BDCE-B59226B65E63} = {39D097CC-4757-405F-B3C5-17B8050F438C} {C273C3A4-5651-489C-9FA4-2DCAAA7A7D97} = {39D097CC-4757-405F-B3C5-17B8050F438C} {66C42AC6-739D-45C5-9E37-06B43F285AA7} = {C421505B-16CA-4879-B53D-A932AA7083EF} diff --git a/src/libraries/System.Diagnostics.Contracts/System.Diagnostics.Contracts.sln b/src/libraries/System.Diagnostics.Contracts/System.Diagnostics.Contracts.sln index 9848440e26a..180d970b9ad 100644 --- a/src/libraries/System.Diagnostics.Contracts/System.Diagnostics.Contracts.sln +++ b/src/libraries/System.Diagnostics.Contracts/System.Diagnostics.Contracts.sln @@ -13,6 +13,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib.Gene EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\System.Private.CoreLib\ref\System.Private.CoreLib.csproj", "{B0B27299-653F-4B2C-A69B-81056AC2FE46}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{41DF6BC2-3767-43FA-A89F-A33F1B5B63EA}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{B1366F4C-E5CC-4AF3-A67F-C28216E570B3}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{9C3EAF3C-A96C-4D5F-95FE-BBCB1580DECA}" @@ -220,6 +222,27 @@ Global {B0B27299-653F-4B2C-A69B-81056AC2FE46}.Checked|arm64.ActiveCfg = Debug|Any CPU {B0B27299-653F-4B2C-A69B-81056AC2FE46}.Checked|x64.ActiveCfg = Debug|Any CPU {B0B27299-653F-4B2C-A69B-81056AC2FE46}.Checked|x86.ActiveCfg = Debug|Any CPU + {41DF6BC2-3767-43FA-A89F-A33F1B5B63EA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {41DF6BC2-3767-43FA-A89F-A33F1B5B63EA}.Debug|Any CPU.Build.0 = Debug|Any CPU + {41DF6BC2-3767-43FA-A89F-A33F1B5B63EA}.Debug|arm.ActiveCfg = Debug|Any CPU + {41DF6BC2-3767-43FA-A89F-A33F1B5B63EA}.Debug|arm64.ActiveCfg = Debug|Any CPU + {41DF6BC2-3767-43FA-A89F-A33F1B5B63EA}.Debug|x64.ActiveCfg = Debug|Any CPU + {41DF6BC2-3767-43FA-A89F-A33F1B5B63EA}.Debug|x64.Build.0 = Debug|Any CPU + {41DF6BC2-3767-43FA-A89F-A33F1B5B63EA}.Debug|x86.ActiveCfg = Debug|Any CPU + {41DF6BC2-3767-43FA-A89F-A33F1B5B63EA}.Debug|x86.Build.0 = Debug|Any CPU + {41DF6BC2-3767-43FA-A89F-A33F1B5B63EA}.Release|Any CPU.ActiveCfg = Release|Any CPU + {41DF6BC2-3767-43FA-A89F-A33F1B5B63EA}.Release|Any CPU.Build.0 = Release|Any CPU + {41DF6BC2-3767-43FA-A89F-A33F1B5B63EA}.Release|arm.ActiveCfg = Release|Any CPU + {41DF6BC2-3767-43FA-A89F-A33F1B5B63EA}.Release|arm64.ActiveCfg = Release|Any CPU + {41DF6BC2-3767-43FA-A89F-A33F1B5B63EA}.Release|x64.ActiveCfg = Release|Any CPU + {41DF6BC2-3767-43FA-A89F-A33F1B5B63EA}.Release|x64.Build.0 = Release|Any CPU + {41DF6BC2-3767-43FA-A89F-A33F1B5B63EA}.Release|x86.ActiveCfg = Release|Any CPU + {41DF6BC2-3767-43FA-A89F-A33F1B5B63EA}.Release|x86.Build.0 = Release|Any CPU + {41DF6BC2-3767-43FA-A89F-A33F1B5B63EA}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {41DF6BC2-3767-43FA-A89F-A33F1B5B63EA}.Checked|arm.ActiveCfg = Debug|Any CPU + {41DF6BC2-3767-43FA-A89F-A33F1B5B63EA}.Checked|arm64.ActiveCfg = Debug|Any CPU + {41DF6BC2-3767-43FA-A89F-A33F1B5B63EA}.Checked|x64.ActiveCfg = Debug|Any CPU + {41DF6BC2-3767-43FA-A89F-A33F1B5B63EA}.Checked|x86.ActiveCfg = Debug|Any CPU {B1366F4C-E5CC-4AF3-A67F-C28216E570B3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {B1366F4C-E5CC-4AF3-A67F-C28216E570B3}.Debug|Any CPU.Build.0 = Debug|Any CPU {B1366F4C-E5CC-4AF3-A67F-C28216E570B3}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -401,6 +424,7 @@ Global {B0B27299-653F-4B2C-A69B-81056AC2FE46} = {8B71FA04-1D67-4607-94A4-E2A85977B1FA} {CA4E8737-E42F-4524-A1A0-D2673B7B7AAF} = {8B71FA04-1D67-4607-94A4-E2A85977B1FA} {452B9C44-BE4A-4D0E-9412-07280582D3BB} = {24204C7B-8FCC-4D46-8E72-BB7128DB5572} + {41DF6BC2-3767-43FA-A89F-A33F1B5B63EA} = {24204C7B-8FCC-4D46-8E72-BB7128DB5572} {B1366F4C-E5CC-4AF3-A67F-C28216E570B3} = {24204C7B-8FCC-4D46-8E72-BB7128DB5572} {9C3EAF3C-A96C-4D5F-95FE-BBCB1580DECA} = {24204C7B-8FCC-4D46-8E72-BB7128DB5572} {2230688E-229F-4044-9C82-79988F03047E} = {0FD77A15-66A8-4E7D-BE30-4976EB1A74B9} diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/System.Diagnostics.DiagnosticSource.sln b/src/libraries/System.Diagnostics.DiagnosticSource/System.Diagnostics.DiagnosticSource.sln index f89f842787f..10eb0c9b910 100644 --- a/src/libraries/System.Diagnostics.DiagnosticSource/System.Diagnostics.DiagnosticSource.sln +++ b/src/libraries/System.Diagnostics.DiagnosticSource/System.Diagnostics.DiagnosticSource.sln @@ -11,6 +11,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Diagnostics.Diagnost EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{19AD004A-4F95-43BF-B1A4-5D9CE185EDCC}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{6F2BEED1-A017-445B-AE59-74E0DBE3D9B6}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{C43479BA-BAF7-4F1D-B9AF-418869CF9143}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{F97FBDC1-22F3-4745-B934-2E2A650EDA6A}" @@ -73,6 +75,10 @@ Global {19AD004A-4F95-43BF-B1A4-5D9CE185EDCC}.Debug|Any CPU.Build.0 = Debug|Any CPU {19AD004A-4F95-43BF-B1A4-5D9CE185EDCC}.Release|Any CPU.ActiveCfg = Release|Any CPU {19AD004A-4F95-43BF-B1A4-5D9CE185EDCC}.Release|Any CPU.Build.0 = Release|Any CPU + {6F2BEED1-A017-445B-AE59-74E0DBE3D9B6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {6F2BEED1-A017-445B-AE59-74E0DBE3D9B6}.Debug|Any CPU.Build.0 = Debug|Any CPU + {6F2BEED1-A017-445B-AE59-74E0DBE3D9B6}.Release|Any CPU.ActiveCfg = Release|Any CPU + {6F2BEED1-A017-445B-AE59-74E0DBE3D9B6}.Release|Any CPU.Build.0 = Release|Any CPU {C43479BA-BAF7-4F1D-B9AF-418869CF9143}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {C43479BA-BAF7-4F1D-B9AF-418869CF9143}.Debug|Any CPU.Build.0 = Debug|Any CPU {C43479BA-BAF7-4F1D-B9AF-418869CF9143}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -117,6 +123,7 @@ Global {ADF92A08-5F09-4726-9211-F348E2DFA18F} = {4667237A-8A15-43B3-8CDF-2D0E9B212182} {C841EE65-4F8E-4779-987C-7E64BACFAC59} = {995CF17B-85CD-4C9E-BE9D-8A2A3240FF6B} {19AD004A-4F95-43BF-B1A4-5D9CE185EDCC} = {E2336D66-4276-48F1-9619-1F79CE7140EC} + {6F2BEED1-A017-445B-AE59-74E0DBE3D9B6} = {E2336D66-4276-48F1-9619-1F79CE7140EC} {C43479BA-BAF7-4F1D-B9AF-418869CF9143} = {E2336D66-4276-48F1-9619-1F79CE7140EC} {F97FBDC1-22F3-4745-B934-2E2A650EDA6A} = {E2336D66-4276-48F1-9619-1F79CE7140EC} {490375CF-2958-45D6-BC5D-5F7D9FE03127} = {BCC999D8-B42C-41F8-899D-B804886E4C03} diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/src/ILLink/ILLink.Substitutions.Shared.xml b/src/libraries/System.Diagnostics.DiagnosticSource/src/ILLink/ILLink.Substitutions.Shared.xml index b67ac8623c4..5580f696621 100644 --- a/src/libraries/System.Diagnostics.DiagnosticSource/src/ILLink/ILLink.Substitutions.Shared.xml +++ b/src/libraries/System.Diagnostics.DiagnosticSource/src/ILLink/ILLink.Substitutions.Shared.xml @@ -1,8 +1,5 @@ - - - diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/src/System.Diagnostics.DiagnosticSource.csproj b/src/libraries/System.Diagnostics.DiagnosticSource/src/System.Diagnostics.DiagnosticSource.csproj index 3db1dbd5a06..d6d306ab4f9 100644 --- a/src/libraries/System.Diagnostics.DiagnosticSource/src/System.Diagnostics.DiagnosticSource.csproj +++ b/src/libraries/System.Diagnostics.DiagnosticSource/src/System.Diagnostics.DiagnosticSource.csproj @@ -89,6 +89,10 @@ System.Diagnostics.DiagnosticSource + + + + @@ -123,6 +127,10 @@ System.Diagnostics.DiagnosticSource + + + + @@ -154,4 +162,23 @@ System.Diagnostics.DiagnosticSource + + + + + + + + + + + + + diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/ActivitySource.cs b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/ActivitySource.cs index ebaddab4ec8..f82e54e65d5 100644 --- a/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/ActivitySource.cs +++ b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/ActivitySource.cs @@ -407,105 +407,94 @@ internal void NotifyActivityAddException(Activity activity, Exception exception, } } - // SynchronizedList is a helper collection which ensure thread safety on the collection - // and allow enumerating the collection items and execute some action on the enumerated item and can detect any change in the collection - // during the enumeration which force restarting the enumeration again. - // Caution: We can have the action executed on the same item more than once which is ok in our scenarios. + // This class uses a copy-on-write design to ensure thread safety all operations are thread safe. + // However, it is possible for read-only operations to see stale versions of the item while a change + // is occurring. internal sealed class SynchronizedList { - private readonly List _list; - private uint _version; - - public SynchronizedList() => _list = new List(); + private readonly object _writeLock; + // This array must not be mutated directly. To mutate, obtain the lock, copy the array and then replace it with the new array. + private T[] _volatileArray; + public SynchronizedList() + { + _volatileArray = []; + _writeLock = new(); + } public void Add(T item) { - lock (_list) + lock (_writeLock) { - _list.Add(item); - _version++; + T[] newArray = new T[_volatileArray.Length + 1]; + + Array.Copy(_volatileArray, newArray, _volatileArray.Length);// copy existing items + newArray[_volatileArray.Length] = item;// copy new item + + _volatileArray = newArray; } } public bool AddIfNotExist(T item) { - lock (_list) + lock (_writeLock) { - if (!_list.Contains(item)) + int index = Array.IndexOf(_volatileArray, item); + + if (index >= 0) { - _list.Add(item); - _version++; - return true; + return false; } - return false; + + T[] newArray = new T[_volatileArray.Length + 1]; + + Array.Copy(_volatileArray, newArray, _volatileArray.Length);// copy existing items + newArray[_volatileArray.Length] = item;// copy new item + + _volatileArray = newArray; + + return true; } } public bool Remove(T item) { - lock (_list) + lock (_writeLock) { - if (_list.Remove(item)) + int index = Array.IndexOf(_volatileArray, item); + + if (index < 0) { - _version++; - return true; + return false; } - return false; + + T[] newArray = new T[_volatileArray.Length - 1]; + + Array.Copy(_volatileArray, newArray, index);// copy existing items before index + + Array.Copy( + _volatileArray, index + 1, // position after the index, skipping it + newArray, index, _volatileArray.Length - index - 1// remaining items accounting for removed item + ); + + _volatileArray = newArray; + return true; } } - public int Count => _list.Count; + public int Count => _volatileArray.Length; public void EnumWithFunc(ActivitySource.Function func, ref ActivityCreationOptions data, ref ActivitySamplingResult samplingResult, ref ActivityCreationOptions dataWithContext) { - uint version = _version; - int index = 0; - - while (index < _list.Count) + foreach (T item in _volatileArray) { - T item; - lock (_list) - { - if (version != _version) - { - version = _version; - index = 0; - continue; - } - - item = _list[index]; - index++; - } - - // Important to call the func outside the lock. - // This is the whole point we are having this wrapper class. func(item, ref data, ref samplingResult, ref dataWithContext); } } public void EnumWithAction(Action action, object arg) { - uint version = _version; - int index = 0; - - while (index < _list.Count) + foreach (T item in _volatileArray) { - T item; - lock (_list) - { - if (version != _version) - { - version = _version; - index = 0; - continue; - } - - item = _list[index]; - index++; - } - - // Important to call the action outside the lock. - // This is the whole point we are having this wrapper class. action(item, arg); } } @@ -517,27 +506,8 @@ public void EnumWithExceptionNotification(Activity activity, Exception exception return; } - uint version = _version; - int index = 0; - - while (index < _list.Count) + foreach (T item in _volatileArray) { - T item; - lock (_list) - { - if (version != _version) - { - version = _version; - index = 0; - continue; - } - - item = _list[index]; - index++; - } - - // Important to notify outside the lock. - // This is the whole point we are having this wrapper class. (item as ActivityListener)!.ExceptionRecorder?.Invoke(activity, exception, ref tags); } } diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/DiagnosticSourceEventSource.cs b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/DiagnosticSourceEventSource.cs index 065e81ccdac..673671b3ad5 100644 --- a/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/DiagnosticSourceEventSource.cs +++ b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/DiagnosticSourceEventSource.cs @@ -349,12 +349,29 @@ public void ActivityStart(string SourceName, string ActivityName, IEnumerable> Arguments) => WriteEvent(12, SourceName, ActivityName, Arguments); + /// + /// Used to send version information. + /// + [Event(13, Keywords = Keywords.Messages)] + public void Version(int Major, int Minor, int Patch) + { + WriteEvent(13, Major, Minor, Patch); + } + /// /// Called when the EventSource gets a command from a EventListener or ETW. /// [NonEvent] protected override void OnEventCommand(EventCommandEventArgs command) { + if (command.Command == EventCommand.Enable) + { + Version( + ThisAssembly.AssemblyFileVersion.Major, + ThisAssembly.AssemblyFileVersion.Minor, + ThisAssembly.AssemblyFileVersion.Build); + } + // On every command (which the debugger can force by turning on this EventSource with ETW) // call a function that the debugger can hook to do an arbitrary func evaluation. BreakPointWithDebuggerFuncEval(); diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/Meter.cs b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/Meter.cs index a80e0f47895..7afc120baeb 100644 --- a/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/Meter.cs +++ b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/Meter.cs @@ -4,6 +4,7 @@ using System.Collections.Generic; using System.ComponentModel; using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; using System.Threading; namespace System.Diagnostics.Metrics @@ -20,6 +21,7 @@ public class Meter : IDisposable internal bool Disposed { get; private set; } + [FeatureSwitchDefinition("System.Diagnostics.Metrics.Meter.IsSupported")] internal static bool IsSupported { get; } = InitializeIsSupported(); private static bool InitializeIsSupported() => diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/MetricsEventSource.cs b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/MetricsEventSource.cs index b6c05113bbc..9640b68b8cf 100644 --- a/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/MetricsEventSource.cs +++ b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/MetricsEventSource.cs @@ -277,12 +277,29 @@ public void MultipleSessionsConfiguredIncorrectlyError(string clientId, string e WriteEvent(17, clientId, expectedMaxHistograms, actualMaxHistograms, expectedMaxTimeSeries, actualMaxTimeSeries, expectedRefreshInterval, actualRefreshInterval); } + /// + /// Used to send version information. + /// + [Event(18, Keywords = Keywords.Messages)] + public void Version(int Major, int Minor, int Patch) + { + WriteEvent(18, Major, Minor, Patch); + } + /// /// Called when the EventSource gets a command from a EventListener or ETW. /// [NonEvent] protected override void OnEventCommand(EventCommandEventArgs command) { + if (command.Command == EventCommand.Enable) + { + Version( + ThisAssembly.AssemblyFileVersion.Major, + ThisAssembly.AssemblyFileVersion.Minor, + ThisAssembly.AssemblyFileVersion.Build); + } + lock (this) { Handler.OnEventCommand(command); @@ -319,7 +336,7 @@ public void OnEventCommand(EventCommandEventArgs command) try { #if OS_ISBROWSER_SUPPORT - if (OperatingSystem.IsBrowser()) + if (OperatingSystem.IsBrowser() || OperatingSystem.IsWasi()) { // AggregationManager uses a dedicated thread to avoid losing data for apps experiencing threadpool starvation // and browser doesn't support Thread.Start() @@ -327,7 +344,7 @@ public void OnEventCommand(EventCommandEventArgs command) // This limitation shouldn't really matter because browser also doesn't support out-of-proc EventSource communication // which is the intended scenario for this EventSource. If it matters in the future AggregationManager can be // modified to have some other fallback path that works for browser. - Parent.Error("", "System.Diagnostics.Metrics EventSource not supported on browser"); + Parent.Error("", "System.Diagnostics.Metrics EventSource not supported on browser and wasi"); return; } #endif @@ -649,12 +666,6 @@ private void ParseSpecs(string? metricsSpecs) return; } - if (metricsSpecs.Length == 0) - { - _aggregationManager!.IncludeAll(); - return; - } - string[] specStrings = metricsSpecs.Split(s_instrumentSeparators, StringSplitOptions.RemoveEmptyEntries); foreach (string specString in specStrings) { diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/RuntimeMetrics.cs b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/RuntimeMetrics.cs index fc746ff1f35..a9bd6b28665 100644 --- a/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/RuntimeMetrics.cs +++ b/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/RuntimeMetrics.cs @@ -49,14 +49,7 @@ static RuntimeMetrics() s_meter.CreateObservableUpDownCounter( "dotnet.gc.last_collection.memory.committed_size", - () => - { - GCMemoryInfo gcInfo = GC.GetGCMemoryInfo(); - - return gcInfo.Index == 0 - ? Array.Empty>() - : [new(gcInfo.TotalCommittedBytes)]; - }, + () => GC.GetGCMemoryInfo().TotalCommittedBytes, unit: "By", description: "The amount of committed virtual memory in use by the .NET GC, as observed during the latest garbage collection."); @@ -153,7 +146,7 @@ static RuntimeMetrics() unit: "{cpu}", description: "The number of processors available to the process."); - if (!OperatingSystem.IsBrowser() && !OperatingSystem.IsTvOS() && !(OperatingSystem.IsIOS() && !OperatingSystem.IsMacCatalyst())) + if (!OperatingSystem.IsBrowser() && !OperatingSystem.IsWasi() && !OperatingSystem.IsTvOS() && !(OperatingSystem.IsIOS() && !OperatingSystem.IsMacCatalyst())) { s_meter.CreateObservableCounter( "dotnet.process.cpu.time", @@ -181,7 +174,7 @@ private static IEnumerable> GetGarbageCollectionCounts() [SupportedOSPlatform("maccatalyst")] private static IEnumerable> GetCpuTime() { - Debug.Assert(!OperatingSystem.IsBrowser() && !OperatingSystem.IsTvOS() && !(OperatingSystem.IsIOS() && !OperatingSystem.IsMacCatalyst())); + Debug.Assert(!OperatingSystem.IsBrowser() && !OperatingSystem.IsWasi() &&!OperatingSystem.IsTvOS() && !(OperatingSystem.IsIOS() && !OperatingSystem.IsMacCatalyst())); Environment.ProcessCpuUsage processCpuUsage = Environment.CpuUsage; @@ -193,9 +186,6 @@ private static IEnumerable> GetHeapSizes() { GCMemoryInfo gcInfo = GC.GetGCMemoryInfo(); - if (gcInfo.Index == 0) - yield break; - for (int i = 0; i < s_maxGenerations; ++i) { yield return new(gcInfo.GenerationInfo[i].SizeAfterBytes, new KeyValuePair("gc.heap.generation", s_genNames[i])); @@ -206,9 +196,6 @@ private static IEnumerable> GetHeapFragmentation() { GCMemoryInfo gcInfo = GC.GetGCMemoryInfo(); - if (gcInfo.Index == 0) - yield break; - for (int i = 0; i < s_maxGenerations; ++i) { yield return new(gcInfo.GenerationInfo[i].FragmentationAfterBytes, new KeyValuePair("gc.heap.generation", s_genNames[i])); diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/src/ThisAssembly.cs.in b/src/libraries/System.Diagnostics.DiagnosticSource/src/ThisAssembly.cs.in new file mode 100644 index 00000000000..788ab480aca --- /dev/null +++ b/src/libraries/System.Diagnostics.DiagnosticSource/src/ThisAssembly.cs.in @@ -0,0 +1,11 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace System.Diagnostics; + +internal static class ThisAssembly +{ + private const string BuildAssemblyFileVersion = "${AssemblyFileVersion}"; + + public static Version AssemblyFileVersion { get; } = new(BuildAssemblyFileVersion); +} diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/tests/DiagnosticSourceEventSourceBridgeTests.cs b/src/libraries/System.Diagnostics.DiagnosticSource/tests/DiagnosticSourceEventSourceBridgeTests.cs index 136e33807a4..311d9732ba3 100644 --- a/src/libraries/System.Diagnostics.DiagnosticSource/tests/DiagnosticSourceEventSourceBridgeTests.cs +++ b/src/libraries/System.Diagnostics.DiagnosticSource/tests/DiagnosticSourceEventSourceBridgeTests.cs @@ -3,6 +3,7 @@ using System.Collections.Generic; using System.Diagnostics.Tracing; +using System.Reflection; using System.Text; using System.Threading; using Microsoft.DotNet.RemoteExecutor; @@ -959,6 +960,42 @@ public void TestMessages() }).Dispose(); } + // Tests that version event from DiagnosticSourceEventSource is fired. + [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))] + public void TestVersion() + { + RemoteExecutor.Invoke(static () => + { + Activity a = new Activity("test"); // we need this to ensure DiagnosticSourceEventSource.Logger creation. + + using (var eventSourceListener = new TestDiagnosticSourceEventListener()) + { + Assert.Equal(0, eventSourceListener.EventCount); + + Version? version = null; + + eventSourceListener.OtherEventWritten += delegate (EventWrittenEventArgs evnt) + { + if (evnt.EventName == "Version") + { + version = new( + (int)evnt.Payload[0], + (int)evnt.Payload[1], + (int)evnt.Payload[2]); + } + }; + + eventSourceListener.Enable(""); + Assert.Equal(0, eventSourceListener.EventCount); + + Assert.NotNull(version); + Assert.Equal( + new Version(typeof(Activity).Assembly.GetCustomAttribute()?.Version ?? "0.0.0").ToString(3), + version.ToString()); + } + }).Dispose(); + } + /// /// Tests the feature to send the messages as EventSource Activities. /// diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/tests/MetricEventSourceTests.cs b/src/libraries/System.Diagnostics.DiagnosticSource/tests/MetricEventSourceTests.cs index e622e38da8d..15bdf85ea25 100644 --- a/src/libraries/System.Diagnostics.DiagnosticSource/tests/MetricEventSourceTests.cs +++ b/src/libraries/System.Diagnostics.DiagnosticSource/tests/MetricEventSourceTests.cs @@ -46,6 +46,35 @@ public void GetInstanceMethodIsReflectable() Assert.True(o is EventSource, "Expected object returned from MetricsEventSource.GetInstance() to be assignable to EventSource"); } + // Tests that version event from MetricsEventSource is fired. + [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))] + public void TestVersion() + { + RemoteExecutor.Invoke(static () => + { + using var meter = new Meter("test"); // we need this to ensure MetricsEventSource.Logger creation. + + using (var eventSourceListener = new MetricsEventListener(NullTestOutputHelper.Instance, EventKeywords.All, 60)) + { + var versionEvents = eventSourceListener.Events.Where(e => e.EventName == "Version"); + + Assert.Single(versionEvents); + + var versionEvent = versionEvents.First(); + + var version = new Version( + (int)versionEvent.Payload[0], + (int)versionEvent.Payload[1], + (int)versionEvent.Payload[2]); + + Assert.NotNull(version); + Assert.Equal( + new Version(typeof(Meter).Assembly.GetCustomAttribute()?.Version ?? "0.0.0").ToString(3), + version.ToString()); + } + }).Dispose(); + } + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotBrowser))] [OuterLoop("Slow and has lots of console spew")] public void MultipleListeners_DifferentCounters() @@ -249,7 +278,7 @@ public void SingleListener_Wildcard() Counter c3 = meter3.CreateCounter("counter3"); EventWrittenEventArgs[] events; - using (MetricsEventListener listener = new MetricsEventListener(_output, MetricsEventListener.TimeSeriesValues, isShared: true, IntervalSecs, "")) + using (MetricsEventListener listener = new MetricsEventListener(_output, MetricsEventListener.TimeSeriesValues, isShared: true, IntervalSecs, "*")) { listener.WaitForCollectionStop(s_waitForEventTimeout, 1); c.Add(5); @@ -1788,7 +1817,7 @@ private static void AssertInstrumentPublishingEventsPresent(EventWrittenEventArg Assert.Equal(Helpers.FormatTags(i.Tags), e.InstrumentTags); Assert.Equal(Helpers.FormatTags(i.Meter.Tags), e.MeterTags); Assert.Equal(Helpers.FormatObjectHash(i.Meter.Scope), e.ScopeHash); - Assert.True(e.InstrumentId > 0); + Assert.True(e.InstrumentId >= 0); // It is possible getting Id 0 with InstrumentPublished event when measurements are not enabling (e.g. CounterRateValuePublished event) } Assert.Equal(expectedInstruments.Length, publishEvents.Length); @@ -2102,7 +2131,11 @@ public override void Dispose() protected override void OnEventWritten(EventWrittenEventArgs eventData) { string sessionId = eventData.Payload[0].ToString(); - if (eventData.EventName != "MultipleSessionsNotSupportedError" && eventData.EventName != "MultipleSessionsConfiguredIncorrectlyError" && sessionId != "" && sessionId != _sessionId) + if (eventData.EventName != "MultipleSessionsNotSupportedError" + && eventData.EventName != "MultipleSessionsConfiguredIncorrectlyError" + && eventData.EventName != "Version" + && sessionId != "" + && sessionId != _sessionId) { return; } diff --git a/src/libraries/System.Diagnostics.DiagnosticSource/tests/RuntimeMetricsTests.cs b/src/libraries/System.Diagnostics.DiagnosticSource/tests/RuntimeMetricsTests.cs index 8049d1b5e25..2963533ac7c 100644 --- a/src/libraries/System.Diagnostics.DiagnosticSource/tests/RuntimeMetricsTests.cs +++ b/src/libraries/System.Diagnostics.DiagnosticSource/tests/RuntimeMetricsTests.cs @@ -288,13 +288,6 @@ private void EnsureAllHeapTags(string metricName) instrumentRecorder.RecordObservableInstruments(); var measurements = instrumentRecorder.GetMeasurements(); - if (GC.GetGCMemoryInfo().Index == 0) - { - // No GC has occurred which can be the case on some platforms. - Assert.Empty(measurements); - return; - } - bool[] foundGenerations = new bool[s_genNames.Length]; for (int i = 0; i < 5; i++) { diff --git a/src/libraries/System.Diagnostics.EventLog/System.Diagnostics.EventLog.sln b/src/libraries/System.Diagnostics.EventLog/System.Diagnostics.EventLog.sln index c59acbb4018..5fcba821423 100644 --- a/src/libraries/System.Diagnostics.EventLog/System.Diagnostics.EventLog.sln +++ b/src/libraries/System.Diagnostics.EventLog/System.Diagnostics.EventLog.sln @@ -9,7 +9,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Diagnostics.EventLog EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Diagnostics.EventLog.Tests", "tests\System.Diagnostics.EventLog.Tests.csproj", "{DE282697-BDF2-4FC7-B34C-911F35AE47D6}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{C470A83B-8C8C-4C87-9A3F-31B2E0070A13}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{1FD80521-E218-443D-A71C-B96FE15DFB34}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{D49EF33F-919D-4DE5-B4B1-CF6697EF3806}" EndProject @@ -65,10 +65,10 @@ Global {DE282697-BDF2-4FC7-B34C-911F35AE47D6}.Debug|Any CPU.Build.0 = Debug|Any CPU {DE282697-BDF2-4FC7-B34C-911F35AE47D6}.Release|Any CPU.ActiveCfg = Release|Any CPU {DE282697-BDF2-4FC7-B34C-911F35AE47D6}.Release|Any CPU.Build.0 = Release|Any CPU - {C470A83B-8C8C-4C87-9A3F-31B2E0070A13}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {C470A83B-8C8C-4C87-9A3F-31B2E0070A13}.Debug|Any CPU.Build.0 = Debug|Any CPU - {C470A83B-8C8C-4C87-9A3F-31B2E0070A13}.Release|Any CPU.ActiveCfg = Release|Any CPU - {C470A83B-8C8C-4C87-9A3F-31B2E0070A13}.Release|Any CPU.Build.0 = Release|Any CPU + {1FD80521-E218-443D-A71C-B96FE15DFB34}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {1FD80521-E218-443D-A71C-B96FE15DFB34}.Debug|Any CPU.Build.0 = Debug|Any CPU + {1FD80521-E218-443D-A71C-B96FE15DFB34}.Release|Any CPU.ActiveCfg = Release|Any CPU + {1FD80521-E218-443D-A71C-B96FE15DFB34}.Release|Any CPU.Build.0 = Release|Any CPU {D49EF33F-919D-4DE5-B4B1-CF6697EF3806}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {D49EF33F-919D-4DE5-B4B1-CF6697EF3806}.Debug|Any CPU.Build.0 = Debug|Any CPU {D49EF33F-919D-4DE5-B4B1-CF6697EF3806}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -103,7 +103,7 @@ Global {635F5794-A69E-489D-9D1F-1D20D3DDE740} = {FFB9A9A0-BCDB-42B1-9D58-E25AC8B95C4C} {A5B6EFFE-E24B-4DC8-B0FA-68ADCE59B74C} = {DBD1571C-0586-470C-83A4-84A174680603} {5BB72C32-4B04-415E-A504-F41F2FE0E54D} = {DBD1571C-0586-470C-83A4-84A174680603} - {C470A83B-8C8C-4C87-9A3F-31B2E0070A13} = {1096CED3-1AA7-4FA5-BF1A-EEFD977B6D3B} + {1FD80521-E218-443D-A71C-B96FE15DFB34} = {1096CED3-1AA7-4FA5-BF1A-EEFD977B6D3B} {D49EF33F-919D-4DE5-B4B1-CF6697EF3806} = {1096CED3-1AA7-4FA5-BF1A-EEFD977B6D3B} {545F883A-09C0-4390-A199-09F8C2357926} = {B18C3D31-F222-4259-A29E-0803ED18C3A1} {428AA723-E444-4F5A-B7D5-7C8AB0EF6D40} = {B18C3D31-F222-4259-A29E-0803ED18C3A1} diff --git a/src/libraries/System.Diagnostics.FileVersionInfo/Directory.Build.props b/src/libraries/System.Diagnostics.FileVersionInfo/Directory.Build.props index ce244cbea56..58979d42f06 100644 --- a/src/libraries/System.Diagnostics.FileVersionInfo/Directory.Build.props +++ b/src/libraries/System.Diagnostics.FileVersionInfo/Directory.Build.props @@ -3,6 +3,6 @@ Microsoft true - browser + browser;wasi \ No newline at end of file diff --git a/src/libraries/System.Diagnostics.FileVersionInfo/System.Diagnostics.FileVersionInfo.sln b/src/libraries/System.Diagnostics.FileVersionInfo/System.Diagnostics.FileVersionInfo.sln index 261723cd522..703b003057f 100644 --- a/src/libraries/System.Diagnostics.FileVersionInfo/System.Diagnostics.FileVersionInfo.sln +++ b/src/libraries/System.Diagnostics.FileVersionInfo/System.Diagnostics.FileVersionInfo.sln @@ -11,6 +11,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Diagnostics.FileVers EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{74DEABD1-2996-4B68-8D08-B5BD4F467172}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{65FA4DC8-3E99-4902-A540-A6631CC25665}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{B9224F74-9714-4C37-895C-BFAE0FC97B59}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{C07D96C2-F7BA-45D5-BAE2-C06B68FF9F05}" @@ -73,6 +75,10 @@ Global {74DEABD1-2996-4B68-8D08-B5BD4F467172}.Debug|Any CPU.Build.0 = Debug|Any CPU {74DEABD1-2996-4B68-8D08-B5BD4F467172}.Release|Any CPU.ActiveCfg = Release|Any CPU {74DEABD1-2996-4B68-8D08-B5BD4F467172}.Release|Any CPU.Build.0 = Release|Any CPU + {65FA4DC8-3E99-4902-A540-A6631CC25665}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {65FA4DC8-3E99-4902-A540-A6631CC25665}.Debug|Any CPU.Build.0 = Debug|Any CPU + {65FA4DC8-3E99-4902-A540-A6631CC25665}.Release|Any CPU.ActiveCfg = Release|Any CPU + {65FA4DC8-3E99-4902-A540-A6631CC25665}.Release|Any CPU.Build.0 = Release|Any CPU {B9224F74-9714-4C37-895C-BFAE0FC97B59}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {B9224F74-9714-4C37-895C-BFAE0FC97B59}.Debug|Any CPU.Build.0 = Debug|Any CPU {B9224F74-9714-4C37-895C-BFAE0FC97B59}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -117,6 +123,7 @@ Global {25C578E4-95E6-41C1-9B4C-E4C20619C14D} = {36141B8B-E6F5-4AAF-A053-BDD189531BAF} {922C96F5-9F92-4F0E-A83D-D1BCDDD187F2} = {888B9739-0B73-4F21-A3CC-4694AEFE55CA} {74DEABD1-2996-4B68-8D08-B5BD4F467172} = {AC3F6844-B70D-4DC3-A930-43073DA6F2D8} + {65FA4DC8-3E99-4902-A540-A6631CC25665} = {AC3F6844-B70D-4DC3-A930-43073DA6F2D8} {B9224F74-9714-4C37-895C-BFAE0FC97B59} = {AC3F6844-B70D-4DC3-A930-43073DA6F2D8} {C07D96C2-F7BA-45D5-BAE2-C06B68FF9F05} = {AC3F6844-B70D-4DC3-A930-43073DA6F2D8} {46D26418-BF6C-4743-A862-B88FB2C1209D} = {CABCA940-694B-4ED8-9239-411DE575C92D} diff --git a/src/libraries/System.Diagnostics.PerformanceCounter/System.Diagnostics.PerformanceCounter.sln b/src/libraries/System.Diagnostics.PerformanceCounter/System.Diagnostics.PerformanceCounter.sln index 9eee96af24b..62ea10a32ab 100644 --- a/src/libraries/System.Diagnostics.PerformanceCounter/System.Diagnostics.PerformanceCounter.sln +++ b/src/libraries/System.Diagnostics.PerformanceCounter/System.Diagnostics.PerformanceCounter.sln @@ -27,6 +27,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", ". EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.Uri", "..\System.Private.Uri\src\System.Private.Uri.csproj", "{9F6EC049-D2C2-4228-B043-96D0918DF894}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{8163578D-BE70-4813-BB3B-69AF0702553D}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{11F700BE-429D-4AAA-B797-4C6322503872}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{B690A8D8-E3BF-44D3-8FBC-D64A517B8AF3}" @@ -395,6 +397,27 @@ Global {9F6EC049-D2C2-4228-B043-96D0918DF894}.Checked|arm64.ActiveCfg = Debug|Any CPU {9F6EC049-D2C2-4228-B043-96D0918DF894}.Checked|x64.ActiveCfg = Debug|Any CPU {9F6EC049-D2C2-4228-B043-96D0918DF894}.Checked|x86.ActiveCfg = Debug|Any CPU + {8163578D-BE70-4813-BB3B-69AF0702553D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {8163578D-BE70-4813-BB3B-69AF0702553D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {8163578D-BE70-4813-BB3B-69AF0702553D}.Debug|arm.ActiveCfg = Debug|Any CPU + {8163578D-BE70-4813-BB3B-69AF0702553D}.Debug|arm64.ActiveCfg = Debug|Any CPU + {8163578D-BE70-4813-BB3B-69AF0702553D}.Debug|x64.ActiveCfg = Debug|Any CPU + {8163578D-BE70-4813-BB3B-69AF0702553D}.Debug|x64.Build.0 = Debug|Any CPU + {8163578D-BE70-4813-BB3B-69AF0702553D}.Debug|x86.ActiveCfg = Debug|Any CPU + {8163578D-BE70-4813-BB3B-69AF0702553D}.Debug|x86.Build.0 = Debug|Any CPU + {8163578D-BE70-4813-BB3B-69AF0702553D}.Release|Any CPU.ActiveCfg = Release|Any CPU + {8163578D-BE70-4813-BB3B-69AF0702553D}.Release|Any CPU.Build.0 = Release|Any CPU + {8163578D-BE70-4813-BB3B-69AF0702553D}.Release|arm.ActiveCfg = Release|Any CPU + {8163578D-BE70-4813-BB3B-69AF0702553D}.Release|arm64.ActiveCfg = Release|Any CPU + {8163578D-BE70-4813-BB3B-69AF0702553D}.Release|x64.ActiveCfg = Release|Any CPU + {8163578D-BE70-4813-BB3B-69AF0702553D}.Release|x64.Build.0 = Release|Any CPU + {8163578D-BE70-4813-BB3B-69AF0702553D}.Release|x86.ActiveCfg = Release|Any CPU + {8163578D-BE70-4813-BB3B-69AF0702553D}.Release|x86.Build.0 = Release|Any CPU + {8163578D-BE70-4813-BB3B-69AF0702553D}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {8163578D-BE70-4813-BB3B-69AF0702553D}.Checked|arm.ActiveCfg = Debug|Any CPU + {8163578D-BE70-4813-BB3B-69AF0702553D}.Checked|arm64.ActiveCfg = Debug|Any CPU + {8163578D-BE70-4813-BB3B-69AF0702553D}.Checked|x64.ActiveCfg = Debug|Any CPU + {8163578D-BE70-4813-BB3B-69AF0702553D}.Checked|x86.ActiveCfg = Debug|Any CPU {11F700BE-429D-4AAA-B797-4C6322503872}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {11F700BE-429D-4AAA-B797-4C6322503872}.Debug|Any CPU.Build.0 = Debug|Any CPU {11F700BE-429D-4AAA-B797-4C6322503872}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -737,6 +760,7 @@ Global {F8480484-A2CA-4215-AC4B-82F6149FEC02} = {BFF04E9C-277E-4CE3-8D38-FAFCA9B2D872} {97932D09-4DF9-4836-ADEF-C52DBC0661CD} = {BFF04E9C-277E-4CE3-8D38-FAFCA9B2D872} {C8008A7A-9910-4D19-AB2B-B96FF8538139} = {651A1BB1-501D-45DA-9284-77F8FC083889} + {8163578D-BE70-4813-BB3B-69AF0702553D} = {651A1BB1-501D-45DA-9284-77F8FC083889} {11F700BE-429D-4AAA-B797-4C6322503872} = {651A1BB1-501D-45DA-9284-77F8FC083889} {B690A8D8-E3BF-44D3-8FBC-D64A517B8AF3} = {651A1BB1-501D-45DA-9284-77F8FC083889} {E33CEC60-CDBC-42F4-BF7C-55BFD8D3F9C2} = {9C612F41-D9CB-48D7-92BE-B364078E1D66} diff --git a/src/libraries/System.Diagnostics.Process/Directory.Build.props b/src/libraries/System.Diagnostics.Process/Directory.Build.props index ce244cbea56..58979d42f06 100644 --- a/src/libraries/System.Diagnostics.Process/Directory.Build.props +++ b/src/libraries/System.Diagnostics.Process/Directory.Build.props @@ -3,6 +3,6 @@ Microsoft true - browser + browser;wasi \ No newline at end of file diff --git a/src/libraries/System.Diagnostics.Process/System.Diagnostics.Process.sln b/src/libraries/System.Diagnostics.Process/System.Diagnostics.Process.sln index f36893f7f24..2c07814c406 100644 --- a/src/libraries/System.Diagnostics.Process/System.Diagnostics.Process.sln +++ b/src/libraries/System.Diagnostics.Process/System.Diagnostics.Process.sln @@ -49,6 +49,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.Uri", "..\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{ABF31AAD-012E-4DD3-9B10-2F4590333A22}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{B4CB7B86-EE86-4559-8E44-6ECBB175F910}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{C8F1CF01-F4E9-4459-9FBB-34363A0C377E}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{FD985738-3603-4C41-9FDE-1C96F7922725}" @@ -656,6 +658,27 @@ Global {ABF31AAD-012E-4DD3-9B10-2F4590333A22}.Checked|arm64.ActiveCfg = Debug|Any CPU {ABF31AAD-012E-4DD3-9B10-2F4590333A22}.Checked|x64.ActiveCfg = Debug|Any CPU {ABF31AAD-012E-4DD3-9B10-2F4590333A22}.Checked|x86.ActiveCfg = Debug|Any CPU + {B4CB7B86-EE86-4559-8E44-6ECBB175F910}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {B4CB7B86-EE86-4559-8E44-6ECBB175F910}.Debug|Any CPU.Build.0 = Debug|Any CPU + {B4CB7B86-EE86-4559-8E44-6ECBB175F910}.Debug|arm.ActiveCfg = Debug|Any CPU + {B4CB7B86-EE86-4559-8E44-6ECBB175F910}.Debug|arm64.ActiveCfg = Debug|Any CPU + {B4CB7B86-EE86-4559-8E44-6ECBB175F910}.Debug|x64.ActiveCfg = Debug|Any CPU + {B4CB7B86-EE86-4559-8E44-6ECBB175F910}.Debug|x64.Build.0 = Debug|Any CPU + {B4CB7B86-EE86-4559-8E44-6ECBB175F910}.Debug|x86.ActiveCfg = Debug|Any CPU + {B4CB7B86-EE86-4559-8E44-6ECBB175F910}.Debug|x86.Build.0 = Debug|Any CPU + {B4CB7B86-EE86-4559-8E44-6ECBB175F910}.Release|Any CPU.ActiveCfg = Release|Any CPU + {B4CB7B86-EE86-4559-8E44-6ECBB175F910}.Release|Any CPU.Build.0 = Release|Any CPU + {B4CB7B86-EE86-4559-8E44-6ECBB175F910}.Release|arm.ActiveCfg = Release|Any CPU + {B4CB7B86-EE86-4559-8E44-6ECBB175F910}.Release|arm64.ActiveCfg = Release|Any CPU + {B4CB7B86-EE86-4559-8E44-6ECBB175F910}.Release|x64.ActiveCfg = Release|Any CPU + {B4CB7B86-EE86-4559-8E44-6ECBB175F910}.Release|x64.Build.0 = Release|Any CPU + {B4CB7B86-EE86-4559-8E44-6ECBB175F910}.Release|x86.ActiveCfg = Release|Any CPU + {B4CB7B86-EE86-4559-8E44-6ECBB175F910}.Release|x86.Build.0 = Release|Any CPU + {B4CB7B86-EE86-4559-8E44-6ECBB175F910}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {B4CB7B86-EE86-4559-8E44-6ECBB175F910}.Checked|arm.ActiveCfg = Debug|Any CPU + {B4CB7B86-EE86-4559-8E44-6ECBB175F910}.Checked|arm64.ActiveCfg = Debug|Any CPU + {B4CB7B86-EE86-4559-8E44-6ECBB175F910}.Checked|x64.ActiveCfg = Debug|Any CPU + {B4CB7B86-EE86-4559-8E44-6ECBB175F910}.Checked|x86.ActiveCfg = Debug|Any CPU {C8F1CF01-F4E9-4459-9FBB-34363A0C377E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {C8F1CF01-F4E9-4459-9FBB-34363A0C377E}.Debug|Any CPU.Build.0 = Debug|Any CPU {C8F1CF01-F4E9-4459-9FBB-34363A0C377E}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -1097,6 +1120,7 @@ Global {546D7B53-3A00-47A4-BBE0-F4BA12126D6F} = {8A0AABD7-E3CA-40EA-8290-CEB1D3D0F9AD} {4165769D-C4EE-46C4-9FA2-068DBF1BDB0A} = {8CB89ED5-7600-48B5-B7F4-72026EB9F533} {ABF31AAD-012E-4DD3-9B10-2F4590333A22} = {8CB89ED5-7600-48B5-B7F4-72026EB9F533} + {B4CB7B86-EE86-4559-8E44-6ECBB175F910} = {8CB89ED5-7600-48B5-B7F4-72026EB9F533} {C8F1CF01-F4E9-4459-9FBB-34363A0C377E} = {8CB89ED5-7600-48B5-B7F4-72026EB9F533} {FD985738-3603-4C41-9FDE-1C96F7922725} = {8CB89ED5-7600-48B5-B7F4-72026EB9F533} {9A6E8083-DD07-4006-831D-23C49831981A} = {AB1A5F67-F907-4B8C-9076-1279BC039D8C} diff --git a/src/libraries/System.Diagnostics.Process/tests/ProcessThreadTests.Unix.cs b/src/libraries/System.Diagnostics.Process/tests/ProcessThreadTests.Unix.cs index d7ce1abcdb5..d8d5cad8169 100644 --- a/src/libraries/System.Diagnostics.Process/tests/ProcessThreadTests.Unix.cs +++ b/src/libraries/System.Diagnostics.Process/tests/ProcessThreadTests.Unix.cs @@ -44,6 +44,7 @@ private static int GetCurrentThreadId() Architecture.S390x => 236, Architecture.Ppc64le => 207, Architecture.RiscV64 => 178, + Architecture.LoongArch64 => 178, _ => 178, }; diff --git a/src/libraries/System.Diagnostics.StackTrace/System.Diagnostics.StackTrace.sln b/src/libraries/System.Diagnostics.StackTrace/System.Diagnostics.StackTrace.sln index d331a126e9b..23ed5f2cc91 100644 --- a/src/libraries/System.Diagnostics.StackTrace/System.Diagnostics.StackTrace.sln +++ b/src/libraries/System.Diagnostics.StackTrace/System.Diagnostics.StackTrace.sln @@ -39,6 +39,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.Metadata" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{F18C3460-7F92-4570-9DE9-32B3C3DA6DA8}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{6A9EB51E-6ABB-4D0C-A15F-E1D7FDBAE470}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{56B120CF-EBB5-4422-A7B5-5216FE4F71E3}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{C0FDA629-485A-4795-80D1-BC228F610163}" @@ -525,6 +527,27 @@ Global {F18C3460-7F92-4570-9DE9-32B3C3DA6DA8}.Checked|arm64.ActiveCfg = Debug|Any CPU {F18C3460-7F92-4570-9DE9-32B3C3DA6DA8}.Checked|x64.ActiveCfg = Debug|Any CPU {F18C3460-7F92-4570-9DE9-32B3C3DA6DA8}.Checked|x86.ActiveCfg = Debug|Any CPU + {6A9EB51E-6ABB-4D0C-A15F-E1D7FDBAE470}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {6A9EB51E-6ABB-4D0C-A15F-E1D7FDBAE470}.Debug|Any CPU.Build.0 = Debug|Any CPU + {6A9EB51E-6ABB-4D0C-A15F-E1D7FDBAE470}.Debug|arm.ActiveCfg = Debug|Any CPU + {6A9EB51E-6ABB-4D0C-A15F-E1D7FDBAE470}.Debug|arm64.ActiveCfg = Debug|Any CPU + {6A9EB51E-6ABB-4D0C-A15F-E1D7FDBAE470}.Debug|x64.ActiveCfg = Debug|Any CPU + {6A9EB51E-6ABB-4D0C-A15F-E1D7FDBAE470}.Debug|x64.Build.0 = Debug|Any CPU + {6A9EB51E-6ABB-4D0C-A15F-E1D7FDBAE470}.Debug|x86.ActiveCfg = Debug|Any CPU + {6A9EB51E-6ABB-4D0C-A15F-E1D7FDBAE470}.Debug|x86.Build.0 = Debug|Any CPU + {6A9EB51E-6ABB-4D0C-A15F-E1D7FDBAE470}.Release|Any CPU.ActiveCfg = Release|Any CPU + {6A9EB51E-6ABB-4D0C-A15F-E1D7FDBAE470}.Release|Any CPU.Build.0 = Release|Any CPU + {6A9EB51E-6ABB-4D0C-A15F-E1D7FDBAE470}.Release|arm.ActiveCfg = Release|Any CPU + {6A9EB51E-6ABB-4D0C-A15F-E1D7FDBAE470}.Release|arm64.ActiveCfg = Release|Any CPU + {6A9EB51E-6ABB-4D0C-A15F-E1D7FDBAE470}.Release|x64.ActiveCfg = Release|Any CPU + {6A9EB51E-6ABB-4D0C-A15F-E1D7FDBAE470}.Release|x64.Build.0 = Release|Any CPU + {6A9EB51E-6ABB-4D0C-A15F-E1D7FDBAE470}.Release|x86.ActiveCfg = Release|Any CPU + {6A9EB51E-6ABB-4D0C-A15F-E1D7FDBAE470}.Release|x86.Build.0 = Release|Any CPU + {6A9EB51E-6ABB-4D0C-A15F-E1D7FDBAE470}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {6A9EB51E-6ABB-4D0C-A15F-E1D7FDBAE470}.Checked|arm.ActiveCfg = Debug|Any CPU + {6A9EB51E-6ABB-4D0C-A15F-E1D7FDBAE470}.Checked|arm64.ActiveCfg = Debug|Any CPU + {6A9EB51E-6ABB-4D0C-A15F-E1D7FDBAE470}.Checked|x64.ActiveCfg = Debug|Any CPU + {6A9EB51E-6ABB-4D0C-A15F-E1D7FDBAE470}.Checked|x86.ActiveCfg = Debug|Any CPU {56B120CF-EBB5-4422-A7B5-5216FE4F71E3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {56B120CF-EBB5-4422-A7B5-5216FE4F71E3}.Debug|Any CPU.Build.0 = Debug|Any CPU {56B120CF-EBB5-4422-A7B5-5216FE4F71E3}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -785,6 +808,7 @@ Global {E93A6617-A6C4-4886-BADB-4D52690ACE8E} = {ED3F0225-44AC-415A-80C8-18D9CAD10A64} {0269FFAF-E680-4BC8-A1B4-0333D77911BC} = {CAB63FAF-D862-451E-84FF-115A7DABB4CA} {F18C3460-7F92-4570-9DE9-32B3C3DA6DA8} = {CAB63FAF-D862-451E-84FF-115A7DABB4CA} + {6A9EB51E-6ABB-4D0C-A15F-E1D7FDBAE470} = {CAB63FAF-D862-451E-84FF-115A7DABB4CA} {56B120CF-EBB5-4422-A7B5-5216FE4F71E3} = {CAB63FAF-D862-451E-84FF-115A7DABB4CA} {C0FDA629-485A-4795-80D1-BC228F610163} = {CAB63FAF-D862-451E-84FF-115A7DABB4CA} {CABF1BE7-C382-4121-96C3-B25A18CC31B6} = {A118A4EF-D9D1-4AC9-B0A6-C7A2A15A63C5} diff --git a/src/libraries/System.Diagnostics.TextWriterTraceListener/System.Diagnostics.TextWriterTraceListener.sln b/src/libraries/System.Diagnostics.TextWriterTraceListener/System.Diagnostics.TextWriterTraceListener.sln index f9aea7ef82c..32ad820b384 100644 --- a/src/libraries/System.Diagnostics.TextWriterTraceListener/System.Diagnostics.TextWriterTraceListener.sln +++ b/src/libraries/System.Diagnostics.TextWriterTraceListener/System.Diagnostics.TextWriterTraceListener.sln @@ -23,6 +23,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ObjectModel", "..\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{9CA3FA95-F36D-457B-BA7C-5D1F94A4C7B9}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{CCCACA79-267B-4454-B6DB-48959836DF7F}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{FA37050B-F735-43A3-A1AF-94BC06D88E1A}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{1E5E7A69-E4B6-44ED-BABB-327C2F32830B}" @@ -109,6 +111,10 @@ Global {9CA3FA95-F36D-457B-BA7C-5D1F94A4C7B9}.Debug|Any CPU.Build.0 = Debug|Any CPU {9CA3FA95-F36D-457B-BA7C-5D1F94A4C7B9}.Release|Any CPU.ActiveCfg = Release|Any CPU {9CA3FA95-F36D-457B-BA7C-5D1F94A4C7B9}.Release|Any CPU.Build.0 = Release|Any CPU + {CCCACA79-267B-4454-B6DB-48959836DF7F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {CCCACA79-267B-4454-B6DB-48959836DF7F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {CCCACA79-267B-4454-B6DB-48959836DF7F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {CCCACA79-267B-4454-B6DB-48959836DF7F}.Release|Any CPU.Build.0 = Release|Any CPU {FA37050B-F735-43A3-A1AF-94BC06D88E1A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {FA37050B-F735-43A3-A1AF-94BC06D88E1A}.Debug|Any CPU.Build.0 = Debug|Any CPU {FA37050B-F735-43A3-A1AF-94BC06D88E1A}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -159,6 +165,7 @@ Global {7176D984-0BB0-4266-8D51-28562F5EFA02} = {261ED6BF-3867-4A06-B9A3-4973BCAB5621} {6D2D27DE-9BFF-4ABA-B520-D1C81AA9A847} = {AA9494D5-6DB3-4A88-B219-13746C6BC2AD} {9CA3FA95-F36D-457B-BA7C-5D1F94A4C7B9} = {4F17E201-98A0-44A6-8B34-BF3A4B5B5EA8} + {CCCACA79-267B-4454-B6DB-48959836DF7F} = {4F17E201-98A0-44A6-8B34-BF3A4B5B5EA8} {FA37050B-F735-43A3-A1AF-94BC06D88E1A} = {4F17E201-98A0-44A6-8B34-BF3A4B5B5EA8} {1E5E7A69-E4B6-44ED-BABB-327C2F32830B} = {4F17E201-98A0-44A6-8B34-BF3A4B5B5EA8} {8662AAE6-3C70-42C7-9FD0-AB204DFD6B9C} = {71027792-71B9-4E55-BCF3-88B01F6957CB} diff --git a/src/libraries/System.Diagnostics.TextWriterTraceListener/src/System/Diagnostics/XmlWriterTraceListener.cs b/src/libraries/System.Diagnostics.TextWriterTraceListener/src/System/Diagnostics/XmlWriterTraceListener.cs index e5b72a51d41..068d68e3656 100644 --- a/src/libraries/System.Diagnostics.TextWriterTraceListener/src/System/Diagnostics/XmlWriterTraceListener.cs +++ b/src/libraries/System.Diagnostics.TextWriterTraceListener/src/System/Diagnostics/XmlWriterTraceListener.cs @@ -250,7 +250,7 @@ private void WriteEndHeader() string? processName = s_processName; if (processName is null) { - if (OperatingSystem.IsBrowser()) // Process isn't supported on Browser + if (OperatingSystem.IsBrowser() || OperatingSystem.IsWasi() ) // Process isn't supported on Browser { processName = string.Empty; } diff --git a/src/libraries/System.Diagnostics.TraceSource/System.Diagnostics.TraceSource.sln b/src/libraries/System.Diagnostics.TraceSource/System.Diagnostics.TraceSource.sln index 2ee4c7c5430..72de0beffe3 100644 --- a/src/libraries/System.Diagnostics.TraceSource/System.Diagnostics.TraceSource.sln +++ b/src/libraries/System.Diagnostics.TraceSource/System.Diagnostics.TraceSource.sln @@ -49,6 +49,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", ". EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.Uri", "..\System.Private.Uri\src\System.Private.Uri.csproj", "{4DAA5CFC-C59D-4C1B-A12A-BC9863F38C0C}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{042F07D4-B4C7-4272-B4D1-674ABFA3D23C}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{2F5DA438-6CBA-42AA-818A-64C633A56D55}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{A17B970B-41B2-4C78-BA05-2B954357E46A}" @@ -652,6 +654,27 @@ Global {4DAA5CFC-C59D-4C1B-A12A-BC9863F38C0C}.Checked|arm64.ActiveCfg = Debug|Any CPU {4DAA5CFC-C59D-4C1B-A12A-BC9863F38C0C}.Checked|x64.ActiveCfg = Debug|Any CPU {4DAA5CFC-C59D-4C1B-A12A-BC9863F38C0C}.Checked|x86.ActiveCfg = Debug|Any CPU + {042F07D4-B4C7-4272-B4D1-674ABFA3D23C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {042F07D4-B4C7-4272-B4D1-674ABFA3D23C}.Debug|Any CPU.Build.0 = Debug|Any CPU + {042F07D4-B4C7-4272-B4D1-674ABFA3D23C}.Debug|arm.ActiveCfg = Debug|Any CPU + {042F07D4-B4C7-4272-B4D1-674ABFA3D23C}.Debug|arm64.ActiveCfg = Debug|Any CPU + {042F07D4-B4C7-4272-B4D1-674ABFA3D23C}.Debug|x64.ActiveCfg = Debug|Any CPU + {042F07D4-B4C7-4272-B4D1-674ABFA3D23C}.Debug|x64.Build.0 = Debug|Any CPU + {042F07D4-B4C7-4272-B4D1-674ABFA3D23C}.Debug|x86.ActiveCfg = Debug|Any CPU + {042F07D4-B4C7-4272-B4D1-674ABFA3D23C}.Debug|x86.Build.0 = Debug|Any CPU + {042F07D4-B4C7-4272-B4D1-674ABFA3D23C}.Release|Any CPU.ActiveCfg = Release|Any CPU + {042F07D4-B4C7-4272-B4D1-674ABFA3D23C}.Release|Any CPU.Build.0 = Release|Any CPU + {042F07D4-B4C7-4272-B4D1-674ABFA3D23C}.Release|arm.ActiveCfg = Release|Any CPU + {042F07D4-B4C7-4272-B4D1-674ABFA3D23C}.Release|arm64.ActiveCfg = Release|Any CPU + {042F07D4-B4C7-4272-B4D1-674ABFA3D23C}.Release|x64.ActiveCfg = Release|Any CPU + {042F07D4-B4C7-4272-B4D1-674ABFA3D23C}.Release|x64.Build.0 = Release|Any CPU + {042F07D4-B4C7-4272-B4D1-674ABFA3D23C}.Release|x86.ActiveCfg = Release|Any CPU + {042F07D4-B4C7-4272-B4D1-674ABFA3D23C}.Release|x86.Build.0 = Release|Any CPU + {042F07D4-B4C7-4272-B4D1-674ABFA3D23C}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {042F07D4-B4C7-4272-B4D1-674ABFA3D23C}.Checked|arm.ActiveCfg = Debug|Any CPU + {042F07D4-B4C7-4272-B4D1-674ABFA3D23C}.Checked|arm64.ActiveCfg = Debug|Any CPU + {042F07D4-B4C7-4272-B4D1-674ABFA3D23C}.Checked|x64.ActiveCfg = Debug|Any CPU + {042F07D4-B4C7-4272-B4D1-674ABFA3D23C}.Checked|x86.ActiveCfg = Debug|Any CPU {2F5DA438-6CBA-42AA-818A-64C633A56D55}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {2F5DA438-6CBA-42AA-818A-64C633A56D55}.Debug|Any CPU.Build.0 = Debug|Any CPU {2F5DA438-6CBA-42AA-818A-64C633A56D55}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -1049,6 +1072,7 @@ Global {7D404296-72F5-4F99-931F-73791FAB3E14} = {1826CD8D-A5E3-4C8E-A49A-E746D9682B87} {8D689F55-88E3-4EF3-9554-9230409A63FB} = {1826CD8D-A5E3-4C8E-A49A-E746D9682B87} {8EAD8906-AF4E-42CA-983E-28CFE2224AEE} = {BDABB39C-A9FF-4A9B-8BA2-EF873C5EEB16} + {042F07D4-B4C7-4272-B4D1-674ABFA3D23C} = {BDABB39C-A9FF-4A9B-8BA2-EF873C5EEB16} {2F5DA438-6CBA-42AA-818A-64C633A56D55} = {BDABB39C-A9FF-4A9B-8BA2-EF873C5EEB16} {A17B970B-41B2-4C78-BA05-2B954357E46A} = {BDABB39C-A9FF-4A9B-8BA2-EF873C5EEB16} {1F63C04C-C7DE-46AF-8430-36C3EAE5F222} = {85C7EB8C-C328-4212-90E1-4B0EAB0ED429} diff --git a/src/libraries/System.Diagnostics.Tracing/System.Diagnostics.Tracing.sln b/src/libraries/System.Diagnostics.Tracing/System.Diagnostics.Tracing.sln index e0ce9b4d567..4a968d00980 100644 --- a/src/libraries/System.Diagnostics.Tracing/System.Diagnostics.Tracing.sln +++ b/src/libraries/System.Diagnostics.Tracing/System.Diagnostics.Tracing.sln @@ -13,6 +13,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib.Gene EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\System.Private.CoreLib\ref\System.Private.CoreLib.csproj", "{79F03506-0B08-46BB-B99D-ABDBA8CFFFAC}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{E63E321F-F9E7-4ADB-9640-134289B914BC}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{7D67652E-7840-42AF-A830-F9A336AD8CBE}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{38416350-0E7B-4201-8B7E-3FA80FCFA81A}" @@ -220,6 +222,27 @@ Global {79F03506-0B08-46BB-B99D-ABDBA8CFFFAC}.Checked|arm64.ActiveCfg = Debug|Any CPU {79F03506-0B08-46BB-B99D-ABDBA8CFFFAC}.Checked|x64.ActiveCfg = Debug|Any CPU {79F03506-0B08-46BB-B99D-ABDBA8CFFFAC}.Checked|x86.ActiveCfg = Debug|Any CPU + {E63E321F-F9E7-4ADB-9640-134289B914BC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E63E321F-F9E7-4ADB-9640-134289B914BC}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E63E321F-F9E7-4ADB-9640-134289B914BC}.Debug|arm.ActiveCfg = Debug|Any CPU + {E63E321F-F9E7-4ADB-9640-134289B914BC}.Debug|arm64.ActiveCfg = Debug|Any CPU + {E63E321F-F9E7-4ADB-9640-134289B914BC}.Debug|x64.ActiveCfg = Debug|Any CPU + {E63E321F-F9E7-4ADB-9640-134289B914BC}.Debug|x64.Build.0 = Debug|Any CPU + {E63E321F-F9E7-4ADB-9640-134289B914BC}.Debug|x86.ActiveCfg = Debug|Any CPU + {E63E321F-F9E7-4ADB-9640-134289B914BC}.Debug|x86.Build.0 = Debug|Any CPU + {E63E321F-F9E7-4ADB-9640-134289B914BC}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E63E321F-F9E7-4ADB-9640-134289B914BC}.Release|Any CPU.Build.0 = Release|Any CPU + {E63E321F-F9E7-4ADB-9640-134289B914BC}.Release|arm.ActiveCfg = Release|Any CPU + {E63E321F-F9E7-4ADB-9640-134289B914BC}.Release|arm64.ActiveCfg = Release|Any CPU + {E63E321F-F9E7-4ADB-9640-134289B914BC}.Release|x64.ActiveCfg = Release|Any CPU + {E63E321F-F9E7-4ADB-9640-134289B914BC}.Release|x64.Build.0 = Release|Any CPU + {E63E321F-F9E7-4ADB-9640-134289B914BC}.Release|x86.ActiveCfg = Release|Any CPU + {E63E321F-F9E7-4ADB-9640-134289B914BC}.Release|x86.Build.0 = Release|Any CPU + {E63E321F-F9E7-4ADB-9640-134289B914BC}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {E63E321F-F9E7-4ADB-9640-134289B914BC}.Checked|arm.ActiveCfg = Debug|Any CPU + {E63E321F-F9E7-4ADB-9640-134289B914BC}.Checked|arm64.ActiveCfg = Debug|Any CPU + {E63E321F-F9E7-4ADB-9640-134289B914BC}.Checked|x64.ActiveCfg = Debug|Any CPU + {E63E321F-F9E7-4ADB-9640-134289B914BC}.Checked|x86.ActiveCfg = Debug|Any CPU {7D67652E-7840-42AF-A830-F9A336AD8CBE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {7D67652E-7840-42AF-A830-F9A336AD8CBE}.Debug|Any CPU.Build.0 = Debug|Any CPU {7D67652E-7840-42AF-A830-F9A336AD8CBE}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -401,6 +424,7 @@ Global {79F03506-0B08-46BB-B99D-ABDBA8CFFFAC} = {61AC03AE-7090-458C-A3AB-5A4CCFF6AD08} {58E24DB7-4207-49F8-BC73-A665A2A961A6} = {61AC03AE-7090-458C-A3AB-5A4CCFF6AD08} {3969DA9E-6C7D-421D-ABCC-BD02DFA36DA4} = {F2FD3769-35C6-481A-AF35-9BDDEE550B54} + {E63E321F-F9E7-4ADB-9640-134289B914BC} = {F2FD3769-35C6-481A-AF35-9BDDEE550B54} {7D67652E-7840-42AF-A830-F9A336AD8CBE} = {F2FD3769-35C6-481A-AF35-9BDDEE550B54} {38416350-0E7B-4201-8B7E-3FA80FCFA81A} = {F2FD3769-35C6-481A-AF35-9BDDEE550B54} {F0C042E4-53F3-4661-93DA-D9223C2A650B} = {E44548BC-2CFB-47A3-B98A-1D5754ADCFA7} diff --git a/src/libraries/System.Diagnostics.Tracing/tests/BasicEventSourceTest/TestUtilities.cs b/src/libraries/System.Diagnostics.Tracing/tests/BasicEventSourceTest/TestUtilities.cs index 78c978be345..9de8946d927 100644 --- a/src/libraries/System.Diagnostics.Tracing/tests/BasicEventSourceTest/TestUtilities.cs +++ b/src/libraries/System.Diagnostics.Tracing/tests/BasicEventSourceTest/TestUtilities.cs @@ -32,6 +32,7 @@ public static void CheckNoEventSourcesRunning(string message = "") eventSource.Name != "Microsoft-Windows-DotNETRuntime" && eventSource.Name != "System.Runtime" && eventSource.Name != "System.Diagnostics.Metrics" && + eventSource.Name != "Microsoft-Diagnostics-DiagnosticSource" && // event source from xunit runner eventSource.Name != "xUnit.TestEventSource" && diff --git a/src/libraries/System.DirectoryServices.AccountManagement/System.DirectoryServices.AccountManagement.sln b/src/libraries/System.DirectoryServices.AccountManagement/System.DirectoryServices.AccountManagement.sln index fffd05baa7b..4bef8249f7d 100644 --- a/src/libraries/System.DirectoryServices.AccountManagement/System.DirectoryServices.AccountManagement.sln +++ b/src/libraries/System.DirectoryServices.AccountManagement/System.DirectoryServices.AccountManagement.sln @@ -45,6 +45,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.Uri", "..\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{57A5675F-7D0F-4C43-8677-9AB0C1EC62F3}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{89758E2E-214E-4B34-9E8E-EE5AB8BA39CC}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{083BBAF9-356A-4C4B-B928-EB2DAF8D251F}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{052330E1-08F5-4AC3-987D-4C601D640414}" @@ -604,6 +606,27 @@ Global {57A5675F-7D0F-4C43-8677-9AB0C1EC62F3}.Checked|arm64.ActiveCfg = Debug|Any CPU {57A5675F-7D0F-4C43-8677-9AB0C1EC62F3}.Checked|x64.ActiveCfg = Debug|Any CPU {57A5675F-7D0F-4C43-8677-9AB0C1EC62F3}.Checked|x86.ActiveCfg = Debug|Any CPU + {89758E2E-214E-4B34-9E8E-EE5AB8BA39CC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {89758E2E-214E-4B34-9E8E-EE5AB8BA39CC}.Debug|Any CPU.Build.0 = Debug|Any CPU + {89758E2E-214E-4B34-9E8E-EE5AB8BA39CC}.Debug|arm.ActiveCfg = Debug|Any CPU + {89758E2E-214E-4B34-9E8E-EE5AB8BA39CC}.Debug|arm64.ActiveCfg = Debug|Any CPU + {89758E2E-214E-4B34-9E8E-EE5AB8BA39CC}.Debug|x64.ActiveCfg = Debug|Any CPU + {89758E2E-214E-4B34-9E8E-EE5AB8BA39CC}.Debug|x64.Build.0 = Debug|Any CPU + {89758E2E-214E-4B34-9E8E-EE5AB8BA39CC}.Debug|x86.ActiveCfg = Debug|Any CPU + {89758E2E-214E-4B34-9E8E-EE5AB8BA39CC}.Debug|x86.Build.0 = Debug|Any CPU + {89758E2E-214E-4B34-9E8E-EE5AB8BA39CC}.Release|Any CPU.ActiveCfg = Release|Any CPU + {89758E2E-214E-4B34-9E8E-EE5AB8BA39CC}.Release|Any CPU.Build.0 = Release|Any CPU + {89758E2E-214E-4B34-9E8E-EE5AB8BA39CC}.Release|arm.ActiveCfg = Release|Any CPU + {89758E2E-214E-4B34-9E8E-EE5AB8BA39CC}.Release|arm64.ActiveCfg = Release|Any CPU + {89758E2E-214E-4B34-9E8E-EE5AB8BA39CC}.Release|x64.ActiveCfg = Release|Any CPU + {89758E2E-214E-4B34-9E8E-EE5AB8BA39CC}.Release|x64.Build.0 = Release|Any CPU + {89758E2E-214E-4B34-9E8E-EE5AB8BA39CC}.Release|x86.ActiveCfg = Release|Any CPU + {89758E2E-214E-4B34-9E8E-EE5AB8BA39CC}.Release|x86.Build.0 = Release|Any CPU + {89758E2E-214E-4B34-9E8E-EE5AB8BA39CC}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {89758E2E-214E-4B34-9E8E-EE5AB8BA39CC}.Checked|arm.ActiveCfg = Debug|Any CPU + {89758E2E-214E-4B34-9E8E-EE5AB8BA39CC}.Checked|arm64.ActiveCfg = Debug|Any CPU + {89758E2E-214E-4B34-9E8E-EE5AB8BA39CC}.Checked|x64.ActiveCfg = Debug|Any CPU + {89758E2E-214E-4B34-9E8E-EE5AB8BA39CC}.Checked|x86.ActiveCfg = Debug|Any CPU {083BBAF9-356A-4C4B-B928-EB2DAF8D251F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {083BBAF9-356A-4C4B-B928-EB2DAF8D251F}.Debug|Any CPU.Build.0 = Debug|Any CPU {083BBAF9-356A-4C4B-B928-EB2DAF8D251F}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -977,6 +1000,7 @@ Global {CDF9EADE-78CA-4775-8961-D52E066432C9} = {51C4F716-E3A7-4DBC-BC81-CAC8D2D33F14} {87EEC1DB-F423-49B7-BC50-7FFAF68EB099} = {CBDB0A5C-FDD0-4B00-8840-D40E4D6B17DB} {57A5675F-7D0F-4C43-8677-9AB0C1EC62F3} = {CBDB0A5C-FDD0-4B00-8840-D40E4D6B17DB} + {89758E2E-214E-4B34-9E8E-EE5AB8BA39CC} = {CBDB0A5C-FDD0-4B00-8840-D40E4D6B17DB} {083BBAF9-356A-4C4B-B928-EB2DAF8D251F} = {CBDB0A5C-FDD0-4B00-8840-D40E4D6B17DB} {052330E1-08F5-4AC3-987D-4C601D640414} = {CBDB0A5C-FDD0-4B00-8840-D40E4D6B17DB} {6FBAC850-1A4D-4906-B24D-EF89EB925152} = {BD4D4F5A-FF81-4994-80EB-A1B05E553822} diff --git a/src/libraries/System.DirectoryServices.Protocols/System.DirectoryServices.Protocols.sln b/src/libraries/System.DirectoryServices.Protocols/System.DirectoryServices.Protocols.sln index e98e45de653..361002a5705 100644 --- a/src/libraries/System.DirectoryServices.Protocols/System.DirectoryServices.Protocols.sln +++ b/src/libraries/System.DirectoryServices.Protocols/System.DirectoryServices.Protocols.sln @@ -21,6 +21,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", ". EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.Uri", "..\System.Private.Uri\src\System.Private.Uri.csproj", "{6CCAD93E-1888-4610-8EB8-7043B7C61AE8}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{B2F75D33-2833-4D9B-9FD6-95C53803B388}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{2C3750CD-EEE9-4452-B901-AF3084E6B9B2}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{8AC2B9D8-7C86-4F20-9E4C-369ACE927BF5}" @@ -322,6 +324,27 @@ Global {6CCAD93E-1888-4610-8EB8-7043B7C61AE8}.Checked|arm64.ActiveCfg = Debug|Any CPU {6CCAD93E-1888-4610-8EB8-7043B7C61AE8}.Checked|x64.ActiveCfg = Debug|Any CPU {6CCAD93E-1888-4610-8EB8-7043B7C61AE8}.Checked|x86.ActiveCfg = Debug|Any CPU + {B2F75D33-2833-4D9B-9FD6-95C53803B388}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {B2F75D33-2833-4D9B-9FD6-95C53803B388}.Debug|Any CPU.Build.0 = Debug|Any CPU + {B2F75D33-2833-4D9B-9FD6-95C53803B388}.Debug|arm.ActiveCfg = Debug|Any CPU + {B2F75D33-2833-4D9B-9FD6-95C53803B388}.Debug|arm64.ActiveCfg = Debug|Any CPU + {B2F75D33-2833-4D9B-9FD6-95C53803B388}.Debug|x64.ActiveCfg = Debug|Any CPU + {B2F75D33-2833-4D9B-9FD6-95C53803B388}.Debug|x64.Build.0 = Debug|Any CPU + {B2F75D33-2833-4D9B-9FD6-95C53803B388}.Debug|x86.ActiveCfg = Debug|Any CPU + {B2F75D33-2833-4D9B-9FD6-95C53803B388}.Debug|x86.Build.0 = Debug|Any CPU + {B2F75D33-2833-4D9B-9FD6-95C53803B388}.Release|Any CPU.ActiveCfg = Release|Any CPU + {B2F75D33-2833-4D9B-9FD6-95C53803B388}.Release|Any CPU.Build.0 = Release|Any CPU + {B2F75D33-2833-4D9B-9FD6-95C53803B388}.Release|arm.ActiveCfg = Release|Any CPU + {B2F75D33-2833-4D9B-9FD6-95C53803B388}.Release|arm64.ActiveCfg = Release|Any CPU + {B2F75D33-2833-4D9B-9FD6-95C53803B388}.Release|x64.ActiveCfg = Release|Any CPU + {B2F75D33-2833-4D9B-9FD6-95C53803B388}.Release|x64.Build.0 = Release|Any CPU + {B2F75D33-2833-4D9B-9FD6-95C53803B388}.Release|x86.ActiveCfg = Release|Any CPU + {B2F75D33-2833-4D9B-9FD6-95C53803B388}.Release|x86.Build.0 = Release|Any CPU + {B2F75D33-2833-4D9B-9FD6-95C53803B388}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {B2F75D33-2833-4D9B-9FD6-95C53803B388}.Checked|arm.ActiveCfg = Debug|Any CPU + {B2F75D33-2833-4D9B-9FD6-95C53803B388}.Checked|arm64.ActiveCfg = Debug|Any CPU + {B2F75D33-2833-4D9B-9FD6-95C53803B388}.Checked|x64.ActiveCfg = Debug|Any CPU + {B2F75D33-2833-4D9B-9FD6-95C53803B388}.Checked|x86.ActiveCfg = Debug|Any CPU {2C3750CD-EEE9-4452-B901-AF3084E6B9B2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {2C3750CD-EEE9-4452-B901-AF3084E6B9B2}.Debug|Any CPU.Build.0 = Debug|Any CPU {2C3750CD-EEE9-4452-B901-AF3084E6B9B2}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -617,6 +640,7 @@ Global {493BCA01-A5FC-4C5A-9E85-A0E23E3CD425} = {FF4142E3-375C-4658-A1FD-F4C895F7B7B5} {AC53B586-F702-4B0C-94A9-A6F066FDC4C1} = {FF4142E3-375C-4658-A1FD-F4C895F7B7B5} {A5D41312-C3C2-4153-AB58-EE8717C8D379} = {6BC70A1F-00D5-482D-9603-DD6C6E84AE4B} + {B2F75D33-2833-4D9B-9FD6-95C53803B388} = {6BC70A1F-00D5-482D-9603-DD6C6E84AE4B} {2C3750CD-EEE9-4452-B901-AF3084E6B9B2} = {6BC70A1F-00D5-482D-9603-DD6C6E84AE4B} {8AC2B9D8-7C86-4F20-9E4C-369ACE927BF5} = {6BC70A1F-00D5-482D-9603-DD6C6E84AE4B} {28574109-6A9B-47FF-88A7-D5EEDB4B17C3} = {D969D172-A67B-4C3D-A79B-2B1E0EE05E22} diff --git a/src/libraries/System.DirectoryServices.Protocols/src/System/DirectoryServices/Protocols/Interop/LdapPal.Linux.cs b/src/libraries/System.DirectoryServices.Protocols/src/System/DirectoryServices/Protocols/Interop/LdapPal.Linux.cs index 15b3cd86eff..f364b8e44e1 100644 --- a/src/libraries/System.DirectoryServices.Protocols/src/System/DirectoryServices/Protocols/Interop/LdapPal.Linux.cs +++ b/src/libraries/System.DirectoryServices.Protocols/src/System/DirectoryServices/Protocols/Interop/LdapPal.Linux.cs @@ -128,7 +128,7 @@ internal static unsafe int BindToDirectory(ConnectionHandle ld, string who, stri passwordPtr = LdapPal.StringToPtr(passwd); BerVal passwordBerval = new BerVal { - bv_len = MemoryMarshal.CreateReadOnlySpanFromNullTerminated((byte*)passwordPtr).Length, + bv_len = new CLong(MemoryMarshal.CreateReadOnlySpanFromNullTerminated((byte*)passwordPtr).Length), bv_val = passwordPtr, }; diff --git a/src/libraries/System.DirectoryServices.Protocols/src/System/DirectoryServices/Protocols/Interop/SafeHandles.Linux.cs b/src/libraries/System.DirectoryServices.Protocols/src/System/DirectoryServices/Protocols/Interop/SafeHandles.Linux.cs index 24d660de645..70d25cb99f2 100644 --- a/src/libraries/System.DirectoryServices.Protocols/src/System/DirectoryServices/Protocols/Interop/SafeHandles.Linux.cs +++ b/src/libraries/System.DirectoryServices.Protocols/src/System/DirectoryServices/Protocols/Interop/SafeHandles.Linux.cs @@ -65,7 +65,7 @@ internal SafeBerHandle(BerVal value) : base(true) // In Linux if bv_val is null ber_init will segFault instead of returning IntPtr.Zero. // In Linux if bv_len is 0 ber_init returns a valid pointer which will then fail when trying to use it, // so we fail early by throwing exception if this is the case. - if (value.bv_val == IntPtr.Zero || value.bv_len == 0) + if (value.bv_val == IntPtr.Zero || value.bv_len.Value == 0) { throw new BerConversionException(); } diff --git a/src/libraries/System.DirectoryServices.Protocols/src/System/DirectoryServices/Protocols/common/BerConverter.cs b/src/libraries/System.DirectoryServices.Protocols/src/System/DirectoryServices/Protocols/common/BerConverter.cs index 13f7b8b0963..a0d09e27129 100644 --- a/src/libraries/System.DirectoryServices.Protocols/src/System/DirectoryServices/Protocols/common/BerConverter.cs +++ b/src/libraries/System.DirectoryServices.Protocols/src/System/DirectoryServices/Protocols/common/BerConverter.cs @@ -269,15 +269,15 @@ public static byte[] Encode(string format, params object[] value) Marshal.PtrToStructure(flattenptr, binaryValue); } - if (binaryValue == null || binaryValue.bv_len == 0) + if (binaryValue == null || binaryValue.bv_len.Value == 0) { encodingResult = Array.Empty(); } else { - encodingResult = new byte[binaryValue.bv_len]; + encodingResult = new byte[binaryValue.bv_len.Value]; - Marshal.Copy(binaryValue.bv_val, encodingResult, 0, binaryValue.bv_len); + Marshal.Copy(binaryValue.bv_val, encodingResult, 0, (int)binaryValue.bv_len.Value); } } finally @@ -315,12 +315,12 @@ internal static object[] TryDecode(string format, byte[] value, out bool decodeS if (value == null) { - berValue.bv_len = 0; + berValue.bv_len = new CLong(0); berValue.bv_val = IntPtr.Zero; } else { - berValue.bv_len = value.Length; + berValue.bv_len = new CLong(value.Length); berValue.bv_val = Marshal.AllocHGlobal(value.Length); Marshal.Copy(value, 0, berValue.bv_val, value.Length); } @@ -328,127 +328,126 @@ internal static object[] TryDecode(string format, byte[] value, out bool decodeS try { berElement = new SafeBerHandle(berValue); - } - finally - { - if (berValue.bv_val != IntPtr.Zero) - Marshal.FreeHGlobal(berValue.bv_val); - } - - int error; - - for (int formatCount = 0; formatCount < format.Length; formatCount++) - { - char fmt = format[formatCount]; - if (fmt == '{' || fmt == '}' || fmt == '[' || fmt == ']' || fmt == 'n' || fmt == 'x') + int error; + for (int formatCount = 0; formatCount < format.Length; formatCount++) { - error = BerPal.ScanNext(berElement, new string(fmt, 1)); - - if (BerPal.IsBerDecodeError(error)) - Debug.WriteLine("ber_scanf for {, }, [, ], n or x failed"); - } - else if (fmt == 'i' || fmt == 'e' || fmt == 'b') - { - int result = 0; - error = BerPal.ScanNextInt(berElement, new string(fmt, 1), ref result); + char fmt = format[formatCount]; + if (fmt == '{' || fmt == '}' || fmt == '[' || fmt == ']' || fmt == 'n' || fmt == 'x') + { + error = BerPal.ScanNext(berElement, new string(fmt, 1)); - if (!BerPal.IsBerDecodeError(error)) + if (BerPal.IsBerDecodeError(error)) + Debug.WriteLine("ber_scanf for {, }, [, ], n or x failed"); + } + else if (fmt == 'i' || fmt == 'e' || fmt == 'b') { - if (fmt == 'b') + int result = 0; + error = BerPal.ScanNextInt(berElement, new string(fmt, 1), ref result); + + if (!BerPal.IsBerDecodeError(error)) { - // should return a bool - bool boolResult; - if (result == 0) - boolResult = false; + if (fmt == 'b') + { + // should return a bool + bool boolResult; + if (result == 0) + boolResult = false; + else + boolResult = true; + resultList.Add(boolResult); + } else - boolResult = true; - resultList.Add(boolResult); + { + resultList.Add(result); + } } else + Debug.WriteLine("ber_scanf for format character 'i', 'e' or 'b' failed"); + } + else if (fmt == 'a') + { + // return a string + byte[] byteArray = DecodingByteArrayHelper(berElement, 'O', out error); + if (!BerPal.IsBerDecodeError(error)) { - resultList.Add(result); + string s = null; + if (byteArray != null) + s = utf8Encoder.GetString(byteArray); + + resultList.Add(s); } } - else - Debug.WriteLine("ber_scanf for format character 'i', 'e' or 'b' failed"); - } - else if (fmt == 'a') - { - // return a string - byte[] byteArray = DecodingByteArrayHelper(berElement, 'O', out error); - if (!BerPal.IsBerDecodeError(error)) + else if (fmt == 'O') { - string s = null; - if (byteArray != null) - s = utf8Encoder.GetString(byteArray); - - resultList.Add(s); + // return BerVal + byte[] byteArray = DecodingByteArrayHelper(berElement, fmt, out error); + if (!BerPal.IsBerDecodeError(error)) + { + // add result to the list + resultList.Add(byteArray); + } } - } - else if (fmt == 'O') - { - // return BerVal - byte[] byteArray = DecodingByteArrayHelper(berElement, fmt, out error); - if (!BerPal.IsBerDecodeError(error)) + else if (fmt == 'B') { - // add result to the list - resultList.Add(byteArray); + error = DecodeBitStringHelper(resultList, berElement); } - } - else if (fmt == 'B') - { - error = DecodeBitStringHelper(resultList, berElement); - } - else if (fmt == 'v') - { - //null terminate strings - byte[][] byteArrayresult; - string[] stringArray = null; - - byteArrayresult = DecodingMultiByteArrayHelper(berElement, 'V', out error); - if (!BerPal.IsBerDecodeError(error)) + else if (fmt == 'v') { - if (byteArrayresult != null) + //null terminate strings + byte[][] byteArrayresult; + string[] stringArray = null; + + byteArrayresult = DecodingMultiByteArrayHelper(berElement, 'V', out error); + if (!BerPal.IsBerDecodeError(error)) { - stringArray = new string[byteArrayresult.Length]; - for (int i = 0; i < byteArrayresult.Length; i++) + if (byteArrayresult != null) { - if (byteArrayresult[i] == null) - { - stringArray[i] = null; - } - else + stringArray = new string[byteArrayresult.Length]; + for (int i = 0; i < byteArrayresult.Length; i++) { - stringArray[i] = utf8Encoder.GetString(byteArrayresult[i]); + if (byteArrayresult[i] == null) + { + stringArray[i] = null; + } + else + { + stringArray[i] = utf8Encoder.GetString(byteArrayresult[i]); + } } } - } - resultList.Add(stringArray); + resultList.Add(stringArray); + } } - } - else if (fmt == 'V') - { - byte[][] result; + else if (fmt == 'V') + { + byte[][] result; - result = DecodingMultiByteArrayHelper(berElement, fmt, out error); - if (!BerPal.IsBerDecodeError(error)) + result = DecodingMultiByteArrayHelper(berElement, fmt, out error); + if (!BerPal.IsBerDecodeError(error)) + { + resultList.Add(result); + } + } + else { - resultList.Add(result); + Debug.WriteLine("Format string contains undefined character\n"); + throw new ArgumentException(SR.BerConverterUndefineChar); } - } - else - { - Debug.WriteLine("Format string contains undefined character\n"); - throw new ArgumentException(SR.BerConverterUndefineChar); - } - if (BerPal.IsBerDecodeError(error)) - { - // decode failed, just return - return decodeResult; + if (BerPal.IsBerDecodeError(error)) + { + // decode failed, just return + return decodeResult; + } } } + finally + { + if (berValue.bv_val != IntPtr.Zero) + Marshal.FreeHGlobal(berValue.bv_val); + berElement?.Dispose(); + } decodeResult = new object[resultList.Count]; for (int count = 0; count < resultList.Count; count++) @@ -469,12 +468,12 @@ private static int EncodingByteArrayHelper(SafeBerHandle berElement, byte[] temp { IntPtr tmp = Marshal.AllocHGlobal(tempValue.Length); Marshal.Copy(tempValue, 0, tmp, tempValue.Length); - HGlobalMemHandle memHandle = new HGlobalMemHandle(tmp); + using HGlobalMemHandle memHandle = new HGlobalMemHandle(tmp); error = BerPal.PrintByteArray(berElement, new string(fmt, 1), memHandle, (uint)tempValue.Length, tag); } else { - HGlobalMemHandle memHandle = new HGlobalMemHandle(HGlobalMemHandle._dummyPointer); + using HGlobalMemHandle memHandle = new HGlobalMemHandle(HGlobalMemHandle._dummyPointer); error = BerPal.PrintByteArray(berElement, new string(fmt, 1), memHandle, 0, tag); } @@ -499,8 +498,8 @@ private static byte[] DecodingByteArrayHelper(SafeBerHandle berElement, char fmt { Marshal.PtrToStructure(result, binaryValue); - byteArray = new byte[binaryValue.bv_len]; - Marshal.Copy(binaryValue.bv_val, byteArray, 0, binaryValue.bv_len); + byteArray = new byte[binaryValue.bv_len.Value]; + Marshal.Copy(binaryValue.bv_val, byteArray, 0, (int)binaryValue.bv_len.Value); } } else @@ -540,7 +539,7 @@ private static unsafe int EncodingMultiByteArrayHelper(SafeBerHandle berElement, if (byteArray != null) { - managedBervalArray[i].bv_len = byteArray.Length; + managedBervalArray[i].bv_len = new CLong(byteArray.Length); managedBervalArray[i].bv_val = Marshal.AllocHGlobal(byteArray.Length); Marshal.Copy(byteArray, 0, managedBervalArray[i].bv_val, byteArray.Length); } @@ -607,8 +606,8 @@ private static byte[][] DecodingMultiByteArrayHelper(SafeBerHandle berElement, c BerVal ber = new BerVal(); Marshal.PtrToStructure(tempPtr, ber); - byte[] berArray = new byte[ber.bv_len]; - Marshal.Copy(ber.bv_val, berArray, 0, ber.bv_len); + byte[] berArray = new byte[ber.bv_len.Value]; + Marshal.Copy(ber.bv_val, berArray, 0, (int)ber.bv_len.Value); binaryList.Add(berArray); diff --git a/src/libraries/System.DirectoryServices.Protocols/src/System/DirectoryServices/Protocols/common/DirectoryControl.cs b/src/libraries/System.DirectoryServices.Protocols/src/System/DirectoryServices/Protocols/common/DirectoryControl.cs index f47bc50318b..ba0f714b2b0 100644 --- a/src/libraries/System.DirectoryServices.Protocols/src/System/DirectoryServices/Protocols/common/DirectoryControl.cs +++ b/src/libraries/System.DirectoryServices.Protocols/src/System/DirectoryServices/Protocols/common/DirectoryControl.cs @@ -756,8 +756,8 @@ public override unsafe byte[] GetValue() _directoryControlValue = null; if (value != null) { - _directoryControlValue = new byte[value.bv_len]; - Marshal.Copy(value.bv_val, _directoryControlValue, 0, value.bv_len); + _directoryControlValue = new byte[value.bv_len.Value]; + Marshal.Copy(value.bv_val, _directoryControlValue, 0, (int)value.bv_len.Value); } } finally diff --git a/src/libraries/System.DirectoryServices.Protocols/src/System/DirectoryServices/Protocols/ldap/LdapConnection.cs b/src/libraries/System.DirectoryServices.Protocols/src/System/DirectoryServices/Protocols/ldap/LdapConnection.cs index 4be0407a9ee..1125bfd568d 100644 --- a/src/libraries/System.DirectoryServices.Protocols/src/System/DirectoryServices/Protocols/ldap/LdapConnection.cs +++ b/src/libraries/System.DirectoryServices.Protocols/src/System/DirectoryServices/Protocols/ldap/LdapConnection.cs @@ -629,7 +629,7 @@ private unsafe int SendRequestHelper(DirectoryRequest request, ref int messageID berValuePtr = new BerVal { - bv_len = byteArray.Length, + bv_len = new CLong(byteArray.Length), bv_val = Marshal.AllocHGlobal(byteArray.Length) }; Marshal.Copy(byteArray, 0, berValuePtr.bv_val, byteArray.Length); @@ -695,7 +695,7 @@ private unsafe int SendRequestHelper(DirectoryRequest request, ref int messageID { berValuePtr = new BerVal() { - bv_len = val.Length, + bv_len = new CLong(val.Length), bv_val = Marshal.AllocHGlobal(val.Length) }; Marshal.Copy(val, 0, berValuePtr.bv_val, val.Length); @@ -1222,7 +1222,7 @@ internal static LdapControl[] BuildControlArray(DirectoryControlCollection contr // Get the control type. ldctl_oid = LdapPal.StringToPtr(((DirectoryControl)controlList[i]).Type), - // Get the control cricality. + // Get the control criticality. ldctl_iscritical = ((DirectoryControl)controlList[i]).IsCritical }; @@ -1234,7 +1234,7 @@ internal static LdapControl[] BuildControlArray(DirectoryControlCollection contr // Treat the control value as null. managedControls[i].ldctl_value = new BerVal { - bv_len = 0, + bv_len = new CLong(0), bv_val = IntPtr.Zero }; } @@ -1242,10 +1242,10 @@ internal static LdapControl[] BuildControlArray(DirectoryControlCollection contr { managedControls[i].ldctl_value = new BerVal { - bv_len = byteControlValue.Length, + bv_len = new CLong(byteControlValue.Length), bv_val = Marshal.AllocHGlobal(sizeof(byte) * byteControlValue.Length) }; - Marshal.Copy(byteControlValue, 0, managedControls[i].ldctl_value.bv_val, managedControls[i].ldctl_value.bv_len); + Marshal.Copy(byteControlValue, 0, managedControls[i].ldctl_value.bv_val, (int)managedControls[i].ldctl_value.bv_len.Value); } } } @@ -1330,13 +1330,13 @@ internal static unsafe LdapMod[] BuildAttributes(CollectionBase directoryAttribu berValues[j] = new BerVal() { - bv_len = byteArray.Length, + bv_len = new CLong(byteArray.Length), bv_val = Marshal.AllocHGlobal(byteArray.Length) }; // need to free the memory allocated on the heap when we are done ptrToFree.Add(berValues[j].bv_val); - Marshal.Copy(byteArray, 0, berValues[j].bv_val, berValues[j].bv_len); + Marshal.Copy(byteArray, 0, berValues[j].bv_val, (int)berValues[j].bv_len.Value); } } @@ -1485,10 +1485,10 @@ internal async ValueTask ConstructResponseAsync(int messageId { val = new BerVal(); Marshal.PtrToStructure(requestValue, val); - if (val.bv_len != 0 && val.bv_val != IntPtr.Zero) + if (val.bv_len.Value != 0 && val.bv_val != IntPtr.Zero) { - requestValueArray = new byte[val.bv_len]; - Marshal.Copy(val.bv_val, requestValueArray, 0, val.bv_len); + requestValueArray = new byte[val.bv_len.Value]; + Marshal.Copy(val.bv_val, requestValueArray, 0, (int)val.bv_len.Value); } } @@ -1806,10 +1806,10 @@ internal DirectoryAttribute ConstructAttribute(IntPtr entryMessage, IntPtr attri BerVal bervalue = new BerVal(); Marshal.PtrToStructure(tempPtr, bervalue); byte[] byteArray; - if (bervalue.bv_len > 0 && bervalue.bv_val != IntPtr.Zero) + if (bervalue.bv_len.Value > 0 && bervalue.bv_val != IntPtr.Zero) { - byteArray = new byte[bervalue.bv_len]; - Marshal.Copy(bervalue.bv_val, byteArray, 0, bervalue.bv_len); + byteArray = new byte[bervalue.bv_len.Value]; + Marshal.Copy(bervalue.bv_val, byteArray, 0, (int)bervalue.bv_len.Value); attribute.Add(byteArray); } @@ -1944,8 +1944,8 @@ private static DirectoryControl ConstructControl(IntPtr controlPtr) Debug.Assert(control.ldctl_oid != IntPtr.Zero); string controlType = LdapPal.PtrToString(control.ldctl_oid); - byte[] bytes = new byte[control.ldctl_value.bv_len]; - Marshal.Copy(control.ldctl_value.bv_val, bytes, 0, control.ldctl_value.bv_len); + byte[] bytes = new byte[control.ldctl_value.bv_len.Value]; + Marshal.Copy(control.ldctl_value.bv_val, bytes, 0, (int)control.ldctl_value.bv_len.Value); bool criticality = control.ldctl_iscritical; diff --git a/src/libraries/System.DirectoryServices/System.DirectoryServices.sln b/src/libraries/System.DirectoryServices/System.DirectoryServices.sln index e75fc76cc22..d62ca6e591a 100644 --- a/src/libraries/System.DirectoryServices/System.DirectoryServices.sln +++ b/src/libraries/System.DirectoryServices/System.DirectoryServices.sln @@ -17,6 +17,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", ". EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.Uri", "..\System.Private.Uri\src\System.Private.Uri.csproj", "{8323FADF-3D4E-46EE-8CA8-45C523142B77}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{5A10330E-EF63-46EF-BB92-58914011D493}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{5AB39023-05D5-48A2-9414-C289ECB1C13B}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{29CA2D73-E756-4A81-A0A3-733C771FB0AB}" @@ -276,6 +278,27 @@ Global {8323FADF-3D4E-46EE-8CA8-45C523142B77}.Checked|arm64.ActiveCfg = Debug|Any CPU {8323FADF-3D4E-46EE-8CA8-45C523142B77}.Checked|x64.ActiveCfg = Debug|Any CPU {8323FADF-3D4E-46EE-8CA8-45C523142B77}.Checked|x86.ActiveCfg = Debug|Any CPU + {5A10330E-EF63-46EF-BB92-58914011D493}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {5A10330E-EF63-46EF-BB92-58914011D493}.Debug|Any CPU.Build.0 = Debug|Any CPU + {5A10330E-EF63-46EF-BB92-58914011D493}.Debug|arm.ActiveCfg = Debug|Any CPU + {5A10330E-EF63-46EF-BB92-58914011D493}.Debug|arm64.ActiveCfg = Debug|Any CPU + {5A10330E-EF63-46EF-BB92-58914011D493}.Debug|x64.ActiveCfg = Debug|Any CPU + {5A10330E-EF63-46EF-BB92-58914011D493}.Debug|x64.Build.0 = Debug|Any CPU + {5A10330E-EF63-46EF-BB92-58914011D493}.Debug|x86.ActiveCfg = Debug|Any CPU + {5A10330E-EF63-46EF-BB92-58914011D493}.Debug|x86.Build.0 = Debug|Any CPU + {5A10330E-EF63-46EF-BB92-58914011D493}.Release|Any CPU.ActiveCfg = Release|Any CPU + {5A10330E-EF63-46EF-BB92-58914011D493}.Release|Any CPU.Build.0 = Release|Any CPU + {5A10330E-EF63-46EF-BB92-58914011D493}.Release|arm.ActiveCfg = Release|Any CPU + {5A10330E-EF63-46EF-BB92-58914011D493}.Release|arm64.ActiveCfg = Release|Any CPU + {5A10330E-EF63-46EF-BB92-58914011D493}.Release|x64.ActiveCfg = Release|Any CPU + {5A10330E-EF63-46EF-BB92-58914011D493}.Release|x64.Build.0 = Release|Any CPU + {5A10330E-EF63-46EF-BB92-58914011D493}.Release|x86.ActiveCfg = Release|Any CPU + {5A10330E-EF63-46EF-BB92-58914011D493}.Release|x86.Build.0 = Release|Any CPU + {5A10330E-EF63-46EF-BB92-58914011D493}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {5A10330E-EF63-46EF-BB92-58914011D493}.Checked|arm.ActiveCfg = Debug|Any CPU + {5A10330E-EF63-46EF-BB92-58914011D493}.Checked|arm64.ActiveCfg = Debug|Any CPU + {5A10330E-EF63-46EF-BB92-58914011D493}.Checked|x64.ActiveCfg = Debug|Any CPU + {5A10330E-EF63-46EF-BB92-58914011D493}.Checked|x86.ActiveCfg = Debug|Any CPU {5AB39023-05D5-48A2-9414-C289ECB1C13B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {5AB39023-05D5-48A2-9414-C289ECB1C13B}.Debug|Any CPU.Build.0 = Debug|Any CPU {5AB39023-05D5-48A2-9414-C289ECB1C13B}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -569,6 +592,7 @@ Global {C40C15E4-8060-4295-9B8F-E04F94BFDA2B} = {902318E3-C881-4BB3-8EEA-FC24A836B5AE} {169CCBAE-5490-4409-9CC7-48850ABA1BE8} = {902318E3-C881-4BB3-8EEA-FC24A836B5AE} {2929F1C6-A103-4211-A318-96EEE83DD713} = {C1A58B90-FE26-4840-9D69-60DFC77BF485} + {5A10330E-EF63-46EF-BB92-58914011D493} = {C1A58B90-FE26-4840-9D69-60DFC77BF485} {5AB39023-05D5-48A2-9414-C289ECB1C13B} = {C1A58B90-FE26-4840-9D69-60DFC77BF485} {29CA2D73-E756-4A81-A0A3-733C771FB0AB} = {C1A58B90-FE26-4840-9D69-60DFC77BF485} {15F34F54-7854-457C-BD9E-E65E14553832} = {0FD62E14-039A-4678-B5A2-00DAE2900BE3} diff --git a/src/libraries/System.Drawing.Primitives/System.Drawing.Primitives.sln b/src/libraries/System.Drawing.Primitives/System.Drawing.Primitives.sln index 3e450533260..6e1b2180f08 100644 --- a/src/libraries/System.Drawing.Primitives/System.Drawing.Primitives.sln +++ b/src/libraries/System.Drawing.Primitives/System.Drawing.Primitives.sln @@ -1,8 +1,4 @@ - -Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio Version 17 -VisualStudioVersion = 17.11.35111.106 -MinimumVisualStudioVersion = 10.0.40219.1 +Microsoft Visual Studio Solution File, Format Version 12.00 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{39205290-06C5-468E-B5C9-D9C5737909EE}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Collections.NonGeneric", "..\System.Collections.NonGeneric\ref\System.Collections.NonGeneric.csproj", "{4B06D595-C5B5-49E3-BC5D-7CA55B52D91B}" @@ -25,6 +21,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ObjectModel", "..\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{F06CCE8D-0066-4B17-8EF0-162AE711F6D8}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{5C33B8AB-A77F-4367-83E9-510EFD485AFD}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{315E574D-6A26-4A89-83B5-1C948F3C83D2}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{9ECCC771-064F-403E-8E0E-7B049AAFAD36}" @@ -43,17 +41,17 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Mono.Linker", "..\..\tools\ EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{B004DC3D-DA89-4C76-8D15-327CCDB6D7C0}" EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ref", "ref", "{F2D0660B-B4A3-4039-A47D-63F9D1CE19B6}" -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{722DCDC1-7510-4B50-93F4-51E5FF833B2A}" +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ref", "ref", "{5CB40A8A-59D5-4E57-8F9A-D716C5BDFDC7}" EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "gen", "gen", "{8349AD04-5979-4347-A869-7F76B043453E}" +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{D99A011B-F48D-4E22-9C5B-050294758522}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "gen", "gen", "{1ACFEEFC-7E61-483E-9CAF-1EB2DFC11558}" EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{D99A011B-F48D-4E22-9C5B-050294758522}" +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "gen", "tools\gen", "{D8669D87-9F35-4BF2-9804-3185765963B2}" EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ref", "ref", "{5CB40A8A-59D5-4E57-8F9A-D716C5BDFDC7}" +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "tools\src", "{251A272E-EF06-4D9A-AAE9-B669DA537B83}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ref", "tools\ref", "{E91ABA28-1197-4C8D-995A-9CEB1686660C}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tools", "tools", "{0205F064-E9AB-408E-BC47-D1EB62C753C7}" EndProject @@ -107,6 +105,10 @@ Global {F06CCE8D-0066-4B17-8EF0-162AE711F6D8}.Debug|Any CPU.Build.0 = Debug|Any CPU {F06CCE8D-0066-4B17-8EF0-162AE711F6D8}.Release|Any CPU.ActiveCfg = Release|Any CPU {F06CCE8D-0066-4B17-8EF0-162AE711F6D8}.Release|Any CPU.Build.0 = Release|Any CPU + {5C33B8AB-A77F-4367-83E9-510EFD485AFD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {5C33B8AB-A77F-4367-83E9-510EFD485AFD}.Debug|Any CPU.Build.0 = Debug|Any CPU + {5C33B8AB-A77F-4367-83E9-510EFD485AFD}.Release|Any CPU.ActiveCfg = Release|Any CPU + {5C33B8AB-A77F-4367-83E9-510EFD485AFD}.Release|Any CPU.Build.0 = Release|Any CPU {315E574D-6A26-4A89-83B5-1C948F3C83D2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {315E574D-6A26-4A89-83B5-1C948F3C83D2}.Debug|Any CPU.Build.0 = Debug|Any CPU {315E574D-6A26-4A89-83B5-1C948F3C83D2}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -145,33 +147,30 @@ Global EndGlobalSection GlobalSection(NestedProjects) = preSolution {39205290-06C5-468E-B5C9-D9C5737909EE} = {B004DC3D-DA89-4C76-8D15-327CCDB6D7C0} - {4B06D595-C5B5-49E3-BC5D-7CA55B52D91B} = {F2D0660B-B4A3-4039-A47D-63F9D1CE19B6} - {6ED31F56-EBDB-4E4D-A6D5-8F6078B1A241} = {F2D0660B-B4A3-4039-A47D-63F9D1CE19B6} - {9D080C1F-6334-4C14-BABF-D0D9132C0D83} = {F2D0660B-B4A3-4039-A47D-63F9D1CE19B6} - {F92BFBC7-A148-44D5-A977-01926068615D} = {F2D0660B-B4A3-4039-A47D-63F9D1CE19B6} - {D2E753F4-34A3-4641-9C0F-53539147CCF2} = {F2D0660B-B4A3-4039-A47D-63F9D1CE19B6} - {80A68643-0E37-4525-BF06-F50C3BF7B867} = {722DCDC1-7510-4B50-93F4-51E5FF833B2A} {515B6C1E-757F-497E-9707-37B5822FFC9A} = {B004DC3D-DA89-4C76-8D15-327CCDB6D7C0} - {731DA2F5-004D-46F0-8751-4945163E8DF4} = {F2D0660B-B4A3-4039-A47D-63F9D1CE19B6} - {D8C6E8A8-4E73-42CD-A310-C63B64844A4C} = {F2D0660B-B4A3-4039-A47D-63F9D1CE19B6} - {F06CCE8D-0066-4B17-8EF0-162AE711F6D8} = {8349AD04-5979-4347-A869-7F76B043453E} - {315E574D-6A26-4A89-83B5-1C948F3C83D2} = {8349AD04-5979-4347-A869-7F76B043453E} - {9ECCC771-064F-403E-8E0E-7B049AAFAD36} = {8349AD04-5979-4347-A869-7F76B043453E} - {FD462F99-C9F6-4D3E-B080-F5E337E8F2F8} = {F2D0660B-B4A3-4039-A47D-63F9D1CE19B6} - {D5E974B9-EB58-4D32-A4F4-C31559436DEA} = {1ACFEEFC-7E61-483E-9CAF-1EB2DFC11558} - {D2D8DF0A-836A-4521-A9F5-349F91E87046} = {1ACFEEFC-7E61-483E-9CAF-1EB2DFC11558} - {198C17DB-F65F-4165-996B-128E3123A6CF} = {D99A011B-F48D-4E22-9C5B-050294758522} - {A92D7FC7-E3A9-4260-8F25-7FCF3AA900DC} = {D99A011B-F48D-4E22-9C5B-050294758522} - {0A6457CF-5932-44F6-9983-978FA163B3A5} = {5CB40A8A-59D5-4E57-8F9A-D716C5BDFDC7} - {1ACFEEFC-7E61-483E-9CAF-1EB2DFC11558} = {0205F064-E9AB-408E-BC47-D1EB62C753C7} - {D99A011B-F48D-4E22-9C5B-050294758522} = {0205F064-E9AB-408E-BC47-D1EB62C753C7} - {5CB40A8A-59D5-4E57-8F9A-D716C5BDFDC7} = {0205F064-E9AB-408E-BC47-D1EB62C753C7} + {4B06D595-C5B5-49E3-BC5D-7CA55B52D91B} = {5CB40A8A-59D5-4E57-8F9A-D716C5BDFDC7} + {6ED31F56-EBDB-4E4D-A6D5-8F6078B1A241} = {5CB40A8A-59D5-4E57-8F9A-D716C5BDFDC7} + {9D080C1F-6334-4C14-BABF-D0D9132C0D83} = {5CB40A8A-59D5-4E57-8F9A-D716C5BDFDC7} + {F92BFBC7-A148-44D5-A977-01926068615D} = {5CB40A8A-59D5-4E57-8F9A-D716C5BDFDC7} + {D2E753F4-34A3-4641-9C0F-53539147CCF2} = {5CB40A8A-59D5-4E57-8F9A-D716C5BDFDC7} + {731DA2F5-004D-46F0-8751-4945163E8DF4} = {5CB40A8A-59D5-4E57-8F9A-D716C5BDFDC7} + {D8C6E8A8-4E73-42CD-A310-C63B64844A4C} = {5CB40A8A-59D5-4E57-8F9A-D716C5BDFDC7} + {FD462F99-C9F6-4D3E-B080-F5E337E8F2F8} = {5CB40A8A-59D5-4E57-8F9A-D716C5BDFDC7} + {80A68643-0E37-4525-BF06-F50C3BF7B867} = {D99A011B-F48D-4E22-9C5B-050294758522} + {F06CCE8D-0066-4B17-8EF0-162AE711F6D8} = {1ACFEEFC-7E61-483E-9CAF-1EB2DFC11558} + {5C33B8AB-A77F-4367-83E9-510EFD485AFD} = {1ACFEEFC-7E61-483E-9CAF-1EB2DFC11558} + {315E574D-6A26-4A89-83B5-1C948F3C83D2} = {1ACFEEFC-7E61-483E-9CAF-1EB2DFC11558} + {9ECCC771-064F-403E-8E0E-7B049AAFAD36} = {1ACFEEFC-7E61-483E-9CAF-1EB2DFC11558} + {D5E974B9-EB58-4D32-A4F4-C31559436DEA} = {D8669D87-9F35-4BF2-9804-3185765963B2} + {D2D8DF0A-836A-4521-A9F5-349F91E87046} = {D8669D87-9F35-4BF2-9804-3185765963B2} + {D8669D87-9F35-4BF2-9804-3185765963B2} = {0205F064-E9AB-408E-BC47-D1EB62C753C7} + {198C17DB-F65F-4165-996B-128E3123A6CF} = {251A272E-EF06-4D9A-AAE9-B669DA537B83} + {A92D7FC7-E3A9-4260-8F25-7FCF3AA900DC} = {251A272E-EF06-4D9A-AAE9-B669DA537B83} + {251A272E-EF06-4D9A-AAE9-B669DA537B83} = {0205F064-E9AB-408E-BC47-D1EB62C753C7} + {0A6457CF-5932-44F6-9983-978FA163B3A5} = {E91ABA28-1197-4C8D-995A-9CEB1686660C} + {E91ABA28-1197-4C8D-995A-9CEB1686660C} = {0205F064-E9AB-408E-BC47-D1EB62C753C7} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {E2DD25F1-FA29-41D5-AB37-65DDC6A49304} EndGlobalSection - GlobalSection(SharedMSBuildProjectFiles) = preSolution - ..\..\tools\illink\src\ILLink.Shared\ILLink.Shared.projitems*{a92d7fc7-e3a9-4260-8f25-7fcf3aa900dc}*SharedItemsImports = 5 - ..\..\tools\illink\src\ILLink.Shared\ILLink.Shared.projitems*{d2d8df0a-836a-4521-a9f5-349f91e87046}*SharedItemsImports = 5 - EndGlobalSection EndGlobal diff --git a/src/libraries/System.Formats.Asn1/System.Formats.Asn1.sln b/src/libraries/System.Formats.Asn1/System.Formats.Asn1.sln index b3abf901cb5..69a91217a39 100644 --- a/src/libraries/System.Formats.Asn1/System.Formats.Asn1.sln +++ b/src/libraries/System.Formats.Asn1/System.Formats.Asn1.sln @@ -19,6 +19,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.Metadata" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{DC4205D2-3644-46E8-86A5-FE23B0BD5EA9}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{E09F99EF-8F2B-4FEA-B95F-7106EE43693F}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{078ADF8D-48B1-45A9-913E-20362B63590A}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{B64227A9-23C4-4B99-A5E0-7028CA40FF32}" @@ -99,6 +101,10 @@ Global {DC4205D2-3644-46E8-86A5-FE23B0BD5EA9}.Debug|Any CPU.Build.0 = Debug|Any CPU {DC4205D2-3644-46E8-86A5-FE23B0BD5EA9}.Release|Any CPU.ActiveCfg = Release|Any CPU {DC4205D2-3644-46E8-86A5-FE23B0BD5EA9}.Release|Any CPU.Build.0 = Release|Any CPU + {E09F99EF-8F2B-4FEA-B95F-7106EE43693F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E09F99EF-8F2B-4FEA-B95F-7106EE43693F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E09F99EF-8F2B-4FEA-B95F-7106EE43693F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E09F99EF-8F2B-4FEA-B95F-7106EE43693F}.Release|Any CPU.Build.0 = Release|Any CPU {078ADF8D-48B1-45A9-913E-20362B63590A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {078ADF8D-48B1-45A9-913E-20362B63590A}.Debug|Any CPU.Build.0 = Debug|Any CPU {078ADF8D-48B1-45A9-913E-20362B63590A}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -152,6 +158,7 @@ Global {A078A4EB-27E8-42B1-BD44-3807732A4560} = {7D4FCCCB-BD58-4ABE-A98D-140A5B303DF6} {0E49FF32-6CC1-42B0-AF30-25098C7DA18F} = {7D4FCCCB-BD58-4ABE-A98D-140A5B303DF6} {DC4205D2-3644-46E8-86A5-FE23B0BD5EA9} = {425CDAF9-11CA-4C58-B6D4-0CB644481EF9} + {E09F99EF-8F2B-4FEA-B95F-7106EE43693F} = {425CDAF9-11CA-4C58-B6D4-0CB644481EF9} {078ADF8D-48B1-45A9-913E-20362B63590A} = {425CDAF9-11CA-4C58-B6D4-0CB644481EF9} {B64227A9-23C4-4B99-A5E0-7028CA40FF32} = {425CDAF9-11CA-4C58-B6D4-0CB644481EF9} {96D3AF6F-D491-40AA-B199-FA9DB7E5BF6D} = {80A9A052-B4F2-414A-B741-5E7F1850928D} diff --git a/src/libraries/System.Formats.Asn1/ref/System.Formats.Asn1.cs b/src/libraries/System.Formats.Asn1/ref/System.Formats.Asn1.cs index f2705610069..4d32662ed89 100644 --- a/src/libraries/System.Formats.Asn1/ref/System.Formats.Asn1.cs +++ b/src/libraries/System.Formats.Asn1/ref/System.Formats.Asn1.cs @@ -158,6 +158,10 @@ public void CopyTo(System.Formats.Asn1.AsnWriter destination) { } public int Encode(System.Span destination) { throw null; } public bool EncodedValueEquals(System.Formats.Asn1.AsnWriter other) { throw null; } public bool EncodedValueEquals(System.ReadOnlySpan other) { throw null; } +#if NET9_0_OR_GREATER + public TReturn Encode(System.Func, TReturn> encodeCallback) { throw null; } + public TReturn Encode(TState state, System.Func, TReturn> encodeCallback) where TState : allows ref struct { throw null; } +#endif public int GetEncodedLength() { throw null; } public void PopOctetString(System.Formats.Asn1.Asn1Tag? tag = default(System.Formats.Asn1.Asn1Tag?)) { } public void PopSequence(System.Formats.Asn1.Asn1Tag? tag = default(System.Formats.Asn1.Asn1Tag?)) { } diff --git a/src/libraries/System.Formats.Asn1/src/PACKAGE.md b/src/libraries/System.Formats.Asn1/src/PACKAGE.md new file mode 100644 index 00000000000..78675956df2 --- /dev/null +++ b/src/libraries/System.Formats.Asn1/src/PACKAGE.md @@ -0,0 +1,132 @@ +## About + + + +Provides functionality for parsing, encoding, and decoding data using Abstract Syntax Notation One (ASN.1). +ASN.1 is a standard interface description language for defining data structures that can be serialized and deserialized in a cross-platform way. + +## Key Features + + + +* Parse ASN.1 data into .NET types. +* Encode .NET types into ASN.1 format. +* Support for BER, CER, DER: Handles Basic Encoding Rules (BER), Canonical Encoding Rules (CER), and Distinguished Encoding Rules (DER). + +## How to Use + + + +Parsing ASN.1 data: + +```csharp +using System.Formats.Asn1; +using System.Numerics; + +// Sample ASN.1 encoded data (DER format) +byte[] asn1Data = [0x30, 0x09, 0x02, 0x01, 0x01, 0x02, 0x01, 0x02, 0x02, 0x01, 0x03]; + +// Create an AsnReader to parse the data +AsnReader reader = new(asn1Data, AsnEncodingRules.DER); + +// Parse the sequence +AsnReader sequenceReader = reader.ReadSequence(); + +// Read integers from the sequence +BigInteger firstInt = sequenceReader.ReadInteger(); +BigInteger secondInt = sequenceReader.ReadInteger(); +BigInteger thirdInt = sequenceReader.ReadInteger(); + +Console.WriteLine($"First integer: {firstInt}"); +Console.WriteLine($"Second integer: {secondInt}"); +Console.WriteLine($"Third integer: {thirdInt}"); + +// First integer: 1 +// Second integer: 2 +// Third integer: 3 +``` + +Decoding ASN.1 data using `AsnDecoder`: + +```csharp +using System.Formats.Asn1; +using System.Numerics; +using System.Text; + +// Sample ASN.1 encoded data +byte[] booleanData = [0x01, 0x01, 0xFF]; // BOOLEAN TRUE +byte[] integerData = [0x02, 0x01, 0x05]; // INTEGER 5 +byte[] octetStringData = [0x04, 0x03, 0x41, 0x42, 0x43]; // OCTET STRING "ABC" +byte[] objectIdentifierData = [0x06, 0x03, 0x2A, 0x03, 0x04]; // OBJECT IDENTIFIER 1.2.3.4 +byte[] utf8StringData = [0x0C, 0x05, 0x48, 0x65, 0x6C, 0x6C, 0x6F]; // UTF8String "Hello" + +int bytesConsumed; + +bool booleanValue = AsnDecoder.ReadBoolean(booleanData, AsnEncodingRules.DER, out bytesConsumed); +Console.WriteLine($"Decoded BOOLEAN value: {booleanValue}, Bytes consumed: {bytesConsumed}"); +// Decoded BOOLEAN value: True, Bytes consumed: 3 + +BigInteger integerValue = AsnDecoder.ReadInteger(integerData, AsnEncodingRules.DER, out bytesConsumed); +Console.WriteLine($"Decoded INTEGER value: {integerValue}, Bytes consumed: {bytesConsumed}"); +// Decoded INTEGER value: 5, Bytes consumed: 3 + +byte[] octetStringValue = AsnDecoder.ReadOctetString(octetStringData, AsnEncodingRules.DER, out bytesConsumed); +Console.WriteLine($"Decoded OCTET STRING value: {Encoding.ASCII.GetString(octetStringValue)}, Bytes consumed: {bytesConsumed}"); +// Decoded OCTET STRING value: ABC, Bytes consumed: 5 + +string objectIdentifierValue = AsnDecoder.ReadObjectIdentifier(objectIdentifierData, AsnEncodingRules.DER, out bytesConsumed); +Console.WriteLine($"Decoded OBJECT IDENTIFIER value: {objectIdentifierValue}, Bytes consumed: {bytesConsumed}"); +// Decoded OBJECT IDENTIFIER value: 1.2.3.4, Bytes consumed: 5 + +string utf8StringValue = AsnDecoder.ReadCharacterString(utf8StringData, AsnEncodingRules.DER, UniversalTagNumber.UTF8String, out bytesConsumed); +Console.WriteLine($"Decoded UTF8String value: {utf8StringValue}, Bytes consumed: {bytesConsumed}"); +// Decoded UTF8String value: Hello, Bytes consumed: 7 +``` + +Encoding ASN.1 data: + +```csharp +// Create an AsnWriter to encode data +AsnWriter writer = new(AsnEncodingRules.DER); + +// Create a scope for the sequence +using (AsnWriter.Scope scope = writer.PushSequence()) +{ + // Write integers to the sequence + writer.WriteInteger(1); + writer.WriteInteger(2); + writer.WriteInteger(3); +} + +// Get the encoded data +byte[] encodedData = writer.Encode(); + +Console.WriteLine($"Encoded ASN.1 Data: {BitConverter.ToString(encodedData)}"); + +// Encoded ASN.1 Data: 30-09-02-01-01-02-01-02-02-01-03 +``` + +## Main Types + + + +The main types provided by this library are: + +* `System.Formats.Asn1.AsnReader` +* `System.Formats.Asn1.AsnWriter` +* `System.Formats.Asn1.AsnDecoder` +* `System.Formats.Asn1.AsnEncodingRules` + +## Additional Documentation + + + +* [API documentation](https://learn.microsoft.com/dotnet/api/system.formats.asn1) +* [X.680 - Abstract Syntax Notation One (ASN.1): Specification of basic notation](https://www.itu.int/rec/T-REC-X.680) +* [X.690 - ASN.1 encoding rules: Specification of Basic Encoding Rules (BER), Canonical Encoding Rules (CER) and Distinguished Encoding Rules (DER)](https://www.itu.int/rec/T-REC-X.690) + +## Feedback & Contributing + + + +System.Formats.Asn1 is released as open source under the [MIT license](https://licenses.nuget.org/MIT). Bug reports and contributions are welcome at [the GitHub repository](https://github.com/dotnet/runtime). diff --git a/src/libraries/System.Formats.Asn1/src/Resources/Strings.resx b/src/libraries/System.Formats.Asn1/src/Resources/Strings.resx index c05cd4bee55..e21d5453c80 100644 --- a/src/libraries/System.Formats.Asn1/src/Resources/Strings.resx +++ b/src/libraries/System.Formats.Asn1/src/Resources/Strings.resx @@ -105,6 +105,9 @@ Encode cannot be called while a Sequence, Set-Of, or Octet String is still open. + + The AsnWriter cannot be written to while performing the Encode callback. + Cannot pop the requested tag as it is not currently in progress. diff --git a/src/libraries/System.Formats.Asn1/src/System.Formats.Asn1.csproj b/src/libraries/System.Formats.Asn1/src/System.Formats.Asn1.csproj index cf8d4bcbc11..f8e68ec8d9a 100644 --- a/src/libraries/System.Formats.Asn1/src/System.Formats.Asn1.csproj +++ b/src/libraries/System.Formats.Asn1/src/System.Formats.Asn1.csproj @@ -6,13 +6,7 @@ $(DefineConstants);CP_NO_ZEROMEMORY false true - Provides classes that can read and write the ASN.1 BER, CER, and DER data formats. - -Commonly Used Types: -System.Formats.Asn1.AsnReader -System.Formats.Asn1.AsnWriter - - false + Provides classes that can read and write the ASN.1 BER, CER, and DER data formats. diff --git a/src/libraries/System.Formats.Asn1/src/System/Formats/Asn1/AsnWriter.cs b/src/libraries/System.Formats.Asn1/src/System/Formats/Asn1/AsnWriter.cs index 4a724870586..e7c4015cacc 100644 --- a/src/libraries/System.Formats.Asn1/src/System/Formats/Asn1/AsnWriter.cs +++ b/src/libraries/System.Formats.Asn1/src/System/Formats/Asn1/AsnWriter.cs @@ -20,6 +20,9 @@ public sealed partial class AsnWriter private byte[] _buffer = null!; private int _offset; private Stack? _nestingStack; +#if NET9_0_OR_GREATER + private int _encodeDepth; +#endif /// /// Gets the encoding rules in use by this writer. @@ -78,6 +81,13 @@ public AsnWriter(AsnEncodingRules ruleSet, int initialCapacity) : this(ruleSet) /// public void Reset() { +#if NET9_0_OR_GREATER + if (_encodeDepth != 0) + { + throw new InvalidOperationException(SR.AsnWriter_ModifyingWhileEncoding); + } +#endif + if (_offset > 0) { Debug.Assert(_buffer != null); @@ -199,6 +209,87 @@ public byte[] Encode() return _buffer.AsSpan(0, _offset).ToArray(); } +#if NET9_0_OR_GREATER + /// + /// Provides the encoded representation of the data to the specified callback. + /// + /// + /// The callback that receives the encoded data. + /// + /// + /// The type of the return value. + /// + /// + /// Returns the value returned from . + /// + /// + /// is . + /// + /// + /// A or has not been closed via + /// or . + /// + public TReturn Encode(Func, TReturn> encodeCallback) + { + if (encodeCallback is null) + throw new ArgumentNullException(nameof(encodeCallback)); + + try + { + _encodeDepth = checked(_encodeDepth + 1); + ReadOnlySpan encoded = EncodeAsSpan(); + return encodeCallback(encoded); + } + finally + { + _encodeDepth--; + } + } + + /// + /// Provides the encoded representation of the data to the specified callback. + /// + /// + /// The callback that receives the encoded data. + /// + /// + /// The state to pass to . + /// + /// + /// The type of the state. + /// + /// + /// The type of the return value. + /// + /// + /// Returns the value returned from . + /// + /// + /// is . + /// + /// + /// A or has not been closed via + /// or . + /// + public TReturn Encode(TState state, Func, TReturn> encodeCallback) + where TState : allows ref struct + { + if (encodeCallback is null) + throw new ArgumentNullException(nameof(encodeCallback)); + + try + { + _encodeDepth = checked(_encodeDepth + 1); + ReadOnlySpan encoded = EncodeAsSpan(); + return encodeCallback(state, encoded); + } + finally + { + _encodeDepth--; + } + } +#endif + private ReadOnlySpan EncodeAsSpan() { if ((_nestingStack?.Count ?? 0) != 0) @@ -265,6 +356,13 @@ private void EnsureWriteCapacity(int pendingCount) throw new OverflowException(); } +#if NET9_0_OR_GREATER + if (_encodeDepth != 0) + { + throw new InvalidOperationException(SR.AsnWriter_ModifyingWhileEncoding); + } +#endif + if (_buffer == null || _buffer.Length - _offset < pendingCount) { #if CHECK_ACCURATE_ENSURE diff --git a/src/libraries/System.Formats.Asn1/tests/Writer/Asn1WriterTests.cs b/src/libraries/System.Formats.Asn1/tests/Writer/Asn1WriterTests.cs index 2a205b05534..f3d437ce366 100644 --- a/src/libraries/System.Formats.Asn1/tests/Writer/Asn1WriterTests.cs +++ b/src/libraries/System.Formats.Asn1/tests/Writer/Asn1WriterTests.cs @@ -16,6 +16,18 @@ internal static void Verify(AsnWriter writer, string expectedHex) Assert.Equal(expectedHex, encoded.ByteArrayToHex()); Assert.Equal(expectedSize, encoded.Length); +#if NET9_0_OR_GREATER + string hexEncoded = writer.Encode(Convert.ToHexString); + Assert.Equal(expectedHex, hexEncoded); + + object state = new(); + hexEncoded = writer.Encode(state, (object callbackState, ReadOnlySpan encoded) => { + Assert.Same(state, callbackState); + return Convert.ToHexString(encoded); + }); + Assert.Equal(expectedHex, hexEncoded); +#endif + // Now verify TryEncode's boundary conditions. byte[] encoded2 = new byte[encoded.Length + 3]; encoded2[0] = 255; diff --git a/src/libraries/System.Formats.Asn1/tests/Writer/PushPopSetOf.cs b/src/libraries/System.Formats.Asn1/tests/Writer/PushPopSetOf.cs index b35eb838a51..858b0d3c2d7 100644 --- a/src/libraries/System.Formats.Asn1/tests/Writer/PushPopSetOf.cs +++ b/src/libraries/System.Formats.Asn1/tests/Writer/PushPopSetOf.cs @@ -465,6 +465,18 @@ public static void CannotEncodeWhileUnbalanced(AsnEncodingRules ruleSet, bool cu Assert.Throws(() => writer.TryEncode(buf, out written)); Assert.Throws(() => writer.EncodedValueEquals(buf)); Assert.Equal(-5, written); + +#if NET9_0_OR_GREATER + Assert.Throws(() => writer.Encode(_ => { + Assert.Fail("Callback should not have been called."); + return null; + })); + + Assert.Throws(() => writer.Encode(null, (_, _) => { + Assert.Fail("Callback should not have been called."); + return null; + })); +#endif } [Theory] diff --git a/src/libraries/System.Formats.Asn1/tests/Writer/SimpleWriterTests.cs b/src/libraries/System.Formats.Asn1/tests/Writer/SimpleWriterTests.cs index 7ef466a40b5..b644da12ea8 100644 --- a/src/libraries/System.Formats.Asn1/tests/Writer/SimpleWriterTests.cs +++ b/src/libraries/System.Formats.Asn1/tests/Writer/SimpleWriterTests.cs @@ -49,6 +49,18 @@ public static void EncodeEmpty(AsnEncodingRules ruleSet) Assert.Equal(0, written); Assert.True(writer.EncodedValueEquals(ReadOnlySpan.Empty)); +#if NET9_0_OR_GREATER + writer.Encode(encoded => { + Assert.Equal(0, encoded.Length); + return null; + }); + + writer.Encode(null, (_, encoded) => { + Assert.Equal(0, encoded.Length); + return null; + }); +#endif + Span negativeTest = stackalloc byte[] { 5, 0 }; Assert.False(writer.EncodedValueEquals(negativeTest)); } @@ -235,6 +247,38 @@ public static void InitialCapacity_ResizeBlockAligns() Assert.Equal(1024, buffer?.Length); } +#if NET9_0_OR_GREATER + [Fact] + public static void Encode_Callback_NoModifications() + { + AsnWriter writer = new AsnWriter(AsnEncodingRules.DER); + + writer.Encode(writer, static (writer, encoded) => + { + writer.Encode(writer, static (writer, encoded) => + { + Assert.Throws(() => writer.WriteNull()); + return (object)null; + }); + + Assert.Throws(() => writer.WriteNull()); + return (object)null; + }); + + writer.Encode(writer, static (writer, encoded) => + { + writer.Encode(writer, static (writer, encoded) => + { + Assert.Throws(() => writer.Reset()); + return (object)null; + }); + + Assert.Throws(() => writer.Reset()); + return (object)null; + }); + } +#endif + private static byte[]? PeekRawBuffer(AsnWriter writer) { FieldInfo bufField = typeof(AsnWriter).GetField("_buffer", BindingFlags.Instance | BindingFlags.NonPublic); diff --git a/src/libraries/System.Formats.Cbor/System.Formats.Cbor.sln b/src/libraries/System.Formats.Cbor/System.Formats.Cbor.sln index e302481c9c8..f1983cd2798 100644 --- a/src/libraries/System.Formats.Cbor/System.Formats.Cbor.sln +++ b/src/libraries/System.Formats.Cbor/System.Formats.Cbor.sln @@ -9,7 +9,7 @@ Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "System.Formats.Cbor.Tests.D EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Formats.Cbor.Tests", "tests\System.Formats.Cbor.Tests.csproj", "{29879823-0A6F-44A0-B0A5-D90DEC23E4EF}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{1A5762F8-12A3-4731-BF4A-186FA9697828}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{E5ECE160-16E7-4601-B170-9BBA3911FAF3}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{B054CCD9-E0FD-4F93-B8BC-DD1631B99F69}" EndProject @@ -65,10 +65,10 @@ Global {29879823-0A6F-44A0-B0A5-D90DEC23E4EF}.Debug|Any CPU.Build.0 = Debug|Any CPU {29879823-0A6F-44A0-B0A5-D90DEC23E4EF}.Release|Any CPU.ActiveCfg = Release|Any CPU {29879823-0A6F-44A0-B0A5-D90DEC23E4EF}.Release|Any CPU.Build.0 = Release|Any CPU - {1A5762F8-12A3-4731-BF4A-186FA9697828}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {1A5762F8-12A3-4731-BF4A-186FA9697828}.Debug|Any CPU.Build.0 = Debug|Any CPU - {1A5762F8-12A3-4731-BF4A-186FA9697828}.Release|Any CPU.ActiveCfg = Release|Any CPU - {1A5762F8-12A3-4731-BF4A-186FA9697828}.Release|Any CPU.Build.0 = Release|Any CPU + {E5ECE160-16E7-4601-B170-9BBA3911FAF3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E5ECE160-16E7-4601-B170-9BBA3911FAF3}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E5ECE160-16E7-4601-B170-9BBA3911FAF3}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E5ECE160-16E7-4601-B170-9BBA3911FAF3}.Release|Any CPU.Build.0 = Release|Any CPU {B054CCD9-E0FD-4F93-B8BC-DD1631B99F69}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {B054CCD9-E0FD-4F93-B8BC-DD1631B99F69}.Debug|Any CPU.Build.0 = Debug|Any CPU {B054CCD9-E0FD-4F93-B8BC-DD1631B99F69}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -103,7 +103,7 @@ Global {29879823-0A6F-44A0-B0A5-D90DEC23E4EF} = {172C0706-C81F-4DDD-A4B8-52B28481FD67} {259A1DB6-EF7E-4D45-96EF-035E0605BB55} = {46BA9FAE-9204-455A-BB2D-518E5B5C3E4C} {8D8A522D-D363-4594-81BF-0EB16C0B4713} = {B9017269-3067-4CD3-B1E7-2EA25BCE9F79} - {1A5762F8-12A3-4731-BF4A-186FA9697828} = {F186B21D-7138-458B-AEB8-1C1B9711D005} + {E5ECE160-16E7-4601-B170-9BBA3911FAF3} = {F186B21D-7138-458B-AEB8-1C1B9711D005} {B054CCD9-E0FD-4F93-B8BC-DD1631B99F69} = {F186B21D-7138-458B-AEB8-1C1B9711D005} {84164104-008B-4B08-99B4-025D410F6B9D} = {3C74B1FB-DF39-4A3D-A51F-74DA04E09F48} {5071CA6E-644A-4404-85AA-9DD2DA9BEAFC} = {3C74B1FB-DF39-4A3D-A51F-74DA04E09F48} diff --git a/src/libraries/System.Formats.Cbor/src/System/Formats/Cbor/Reader/CborReader.Integer.cs b/src/libraries/System.Formats.Cbor/src/System/Formats/Cbor/Reader/CborReader.Integer.cs index 6ad6760f56e..6c663974a81 100644 --- a/src/libraries/System.Formats.Cbor/src/System/Formats/Cbor/Reader/CborReader.Integer.cs +++ b/src/libraries/System.Formats.Cbor/src/System/Formats/Cbor/Reader/CborReader.Integer.cs @@ -82,7 +82,7 @@ public ulong ReadUInt64() /// Reads the next data item as a CBOR negative integer representation (major type 1). /// An unsigned integer denoting -1 minus the integer. /// The next data item does not have the correct major type. - /// The encoded integer is out of range for + /// The encoded integer is out of range for . /// The next value has an invalid CBOR encoding. /// -or- /// There was an unexpected end of CBOR encoding data. diff --git a/src/libraries/System.Formats.Nrbf/System.Formats.Nrbf.sln b/src/libraries/System.Formats.Nrbf/System.Formats.Nrbf.sln index 82d0e5bf223..5956f28d411 100644 --- a/src/libraries/System.Formats.Nrbf/System.Formats.Nrbf.sln +++ b/src/libraries/System.Formats.Nrbf/System.Formats.Nrbf.sln @@ -19,6 +19,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.Metadata" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{0519337E-2E95-4A85-BEB6-C2D50718AF16}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{5F90BB03-5F0C-4ABD-8CB2-A378364E3FB0}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{8D234E09-CFBE-44BE-9DC2-879470DC28D8}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{FDC49880-E342-4DB2-B4B0-57ED6A0B22DE}" @@ -97,6 +99,10 @@ Global {0519337E-2E95-4A85-BEB6-C2D50718AF16}.Debug|Any CPU.Build.0 = Debug|Any CPU {0519337E-2E95-4A85-BEB6-C2D50718AF16}.Release|Any CPU.ActiveCfg = Release|Any CPU {0519337E-2E95-4A85-BEB6-C2D50718AF16}.Release|Any CPU.Build.0 = Release|Any CPU + {5F90BB03-5F0C-4ABD-8CB2-A378364E3FB0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {5F90BB03-5F0C-4ABD-8CB2-A378364E3FB0}.Debug|Any CPU.Build.0 = Debug|Any CPU + {5F90BB03-5F0C-4ABD-8CB2-A378364E3FB0}.Release|Any CPU.ActiveCfg = Release|Any CPU + {5F90BB03-5F0C-4ABD-8CB2-A378364E3FB0}.Release|Any CPU.Build.0 = Release|Any CPU {8D234E09-CFBE-44BE-9DC2-879470DC28D8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {8D234E09-CFBE-44BE-9DC2-879470DC28D8}.Debug|Any CPU.Build.0 = Debug|Any CPU {8D234E09-CFBE-44BE-9DC2-879470DC28D8}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -145,6 +151,7 @@ Global {E23A8E5A-9975-4ABE-BE54-B02328207F37} = {8721A077-F840-4316-9D8A-6E48B3D5EA03} {81874804-7D0E-42F9-87BB-4D34AE68E852} = {8721A077-F840-4316-9D8A-6E48B3D5EA03} {0519337E-2E95-4A85-BEB6-C2D50718AF16} = {2E857EA7-0B6D-4F6D-9959-FB9C69CA62C4} + {5F90BB03-5F0C-4ABD-8CB2-A378364E3FB0} = {2E857EA7-0B6D-4F6D-9959-FB9C69CA62C4} {8D234E09-CFBE-44BE-9DC2-879470DC28D8} = {2E857EA7-0B6D-4F6D-9959-FB9C69CA62C4} {FDC49880-E342-4DB2-B4B0-57ED6A0B22DE} = {2E857EA7-0B6D-4F6D-9959-FB9C69CA62C4} {31070168-7AF4-4DE6-8B02-827A3BC1A2F4} = {AF4CBC17-76E5-4E6E-929E-2A4EC83B8FF1} diff --git a/src/libraries/System.Formats.Nrbf/ref/System.Formats.Nrbf.Experimental.cs b/src/libraries/System.Formats.Nrbf/ref/System.Formats.Nrbf.Experimental.cs new file mode 100644 index 00000000000..7c8b580a721 --- /dev/null +++ b/src/libraries/System.Formats.Nrbf/ref/System.Formats.Nrbf.Experimental.cs @@ -0,0 +1,4 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +[assembly: System.Diagnostics.CodeAnalysis.ExperimentalAttribute("SYSLIB5005", UrlFormat = "https://aka.ms/dotnet-warnings/{0}")] diff --git a/src/libraries/System.Formats.Nrbf/ref/System.Formats.Nrbf.cs b/src/libraries/System.Formats.Nrbf/ref/System.Formats.Nrbf.cs index 8e12cf7c371..d7a6e01a723 100644 --- a/src/libraries/System.Formats.Nrbf/ref/System.Formats.Nrbf.cs +++ b/src/libraries/System.Formats.Nrbf/ref/System.Formats.Nrbf.cs @@ -11,6 +11,7 @@ public abstract partial class ArrayRecord : System.Formats.Nrbf.SerializationRec internal ArrayRecord() { } public override System.Formats.Nrbf.SerializationRecordId Id { get { throw null; } } public abstract System.ReadOnlySpan Lengths { get; } + public virtual long FlattenedLength { get; } public int Rank { get { throw null; } } [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("The code for an array of the specified type might not be available.")] public System.Array GetArray(System.Type expectedArrayType, bool allowNulls = true) { throw null; } diff --git a/src/libraries/System.Formats.Nrbf/ref/System.Formats.Nrbf.csproj b/src/libraries/System.Formats.Nrbf/ref/System.Formats.Nrbf.csproj index 0d64bbf0a72..092064146e4 100644 --- a/src/libraries/System.Formats.Nrbf/ref/System.Formats.Nrbf.csproj +++ b/src/libraries/System.Formats.Nrbf/ref/System.Formats.Nrbf.csproj @@ -12,6 +12,11 @@ + + + + diff --git a/src/libraries/System.Formats.Nrbf/src/AssemblyInfo.cs b/src/libraries/System.Formats.Nrbf/src/AssemblyInfo.cs new file mode 100644 index 00000000000..d976cf786d9 --- /dev/null +++ b/src/libraries/System.Formats.Nrbf/src/AssemblyInfo.cs @@ -0,0 +1,7 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Diagnostics.CodeAnalysis; + +[assembly: Experimental(Experimentals.NrbfDecoderDiagId, UrlFormat = Experimentals.SharedUrlFormat)] diff --git a/src/libraries/System.Formats.Nrbf/src/PACKAGE.md b/src/libraries/System.Formats.Nrbf/src/PACKAGE.md new file mode 100644 index 00000000000..c3014593588 --- /dev/null +++ b/src/libraries/System.Formats.Nrbf/src/PACKAGE.md @@ -0,0 +1,87 @@ +## About + + + +`System.Formats.Nrbf` exposes only one component: [NrbfDecoder](https://learn.microsoft.com/dotnet/api/system.formats.nrbf.nrbfdecoder): a stateless, forward-only decoder class that can decode .NET Remoting Binary Format (NRBF) binary data from a **stream**. + +You can think of [NrbfDecoder](https://learn.microsoft.com/en-us/dotnet/api/system.formats.nrbf.nrbfdecoder) as being the equivalent of using a JSON/XML reader without the deserializer. + +**Note:** The 9.0.0 release of the `System.Formats.Nrbf` package is marked `[Experimental]` as the API shape is subject to change in the next major release. Even with the experimental annotation, the package is officially supported. Using the APIs from this package will produce a build warning with diagnostic ID `SYSLIB5005`. The diagnostic can be suppressed with the acknowledgement that the API shape is subject to change in the next major release. + +## How to Use + +The NRBF payload consists of serialization records that represent the serialized objects and their metadata. To read the whole payload and get the root record, you need to call one of the [NrbfDecoder.Decode](https://learn.microsoft.com/dotnet/api/system.formats.nrbf.nrbfdecoder.decode) methods. + +The `Decode` method returns a [SerializationRecord](https://learn.microsoft.com/dotnet/api/system.formats.nrbf.serializationrecord) instance. `SerializationRecord` is an abstract class that represents the serialization record and provides three properties: [Id](https://learn.microsoft.com/dotnet/api/system.formats.nrbf.serializationrecord.id), [RecordType](https://learn.microsoft.com/dotnet/api/system.formats.nrbf.serializationrecord.recordtype), and [TypeName](https://learn.microsoft.com/dotnet/api/system.formats.nrbf.serializationrecord.typename). It exposes one method, [TypeNameMatches](https://learn.microsoft.com/dotnet/api/system.formats.nrbf.serializationrecord.typenamematches), which compares the type name read from the payload (and exposed via `TypeName` property) against the specified type. This method ignores assembly names, so you don't need to worry about type forwarding and assembly versioning. It also does not consider member names or their types (because getting this information would require type loading). + +```csharp +using System.Formats.Nrbf; + +public class Sample +{ + public int Integer; + public string? Text; + public byte[]? ArrayOfBytes; + public Sample? ClassInstance; +} + +ClassRecord rootRecord = NrbfDecoder.DecodeClassRecord(payload); +Sample output = new() +{ + // using the dedicated methods to read primitive values + Integer = rootRecord.GetInt32(nameof(Sample.Integer)), + Text = rootRecord.GetString(nameof(Sample.Text)), + // using dedicated method to read an array of bytes + ArrayOfBytes = ((SZArrayRecord)rootRecord.GetArrayRecord(nameof(Sample.ArrayOfBytes))).GetArray(), + // using GetClassRecord to read a class record + ClassInstance = new() + { + Text = rootRecord + .GetClassRecord(nameof(Sample.ClassInstance))! + .GetString(nameof(Sample.Text)) + } +}; +``` + +## Main Types + + + +There are more than a dozen different serialization [record types](https://learn.microsoft.com/openspecs/windows_protocols/ms-nrbf). This library provides a set of abstractions, so you only need to learn a few of them: + +- [`PrimitiveTypeRecord`](https://learn.microsoft.com/dotnet/api/system.formats.nrbf.primitivetyperecord-1): describes all primitive types natively supported by the NRBF (`string`, `bool`, `byte`, `sbyte`, `char`, `short`, `ushort`, `int`, `uint`, `long`, `ulong`, `float`, `double`, `decimal`, `TimeSpan`, and `DateTime`). + - Exposes the value via the `Value` property. + - `PrimitiveTypeRecord` derives from the non-generic [PrimitiveTypeRecord](https://learn.microsoft.com/dotnet/api/system.formats.nrbf.primitivetyperecord), which also exposes a [Value](https://learn.microsoft.com/dotnet/api/system.formats.nrbf.primitivetyperecord.value) property. But on the base class, the value is returned as `object` (which introduces boxing for value types). +- [ClassRecord](https://learn.microsoft.com/dotnet/api/system.formats.nrbf.classrecord): describes all `class` and `struct` besides the aforementioned primitive types. +- [ArrayRecord](https://learn.microsoft.com/dotnet/api/system.formats.nrbf.arrayrecord): describes all array records, including jagged and multi-dimensional arrays. +- [`SZArrayRecord`](https://learn.microsoft.com/dotnet/api/system.formats.nrbf.szarrayrecord-1): describes single-dimensional, zero-indexed array records, where `T` can be either a primitive type or a `ClassRecord`. + +```csharp +SerializationRecord rootObject = NrbfDecoder.Decode(payload); // payload is a Stream + +if (rootObject is PrimitiveTypeRecord primitiveRecord) +{ + Console.WriteLine($"It was a primitive value: '{primitiveRecord.Value}'"); +} +else if (rootObject is ClassRecord classRecord) +{ + Console.WriteLine($"It was a class record of '{classRecord.TypeName.AssemblyQualifiedName}' type name."); +} +else if (rootObject is SZArrayRecord arrayOfBytes) +{ + Console.WriteLine($"It was an array of `{arrayOfBytes.Length}`-many bytes."); +} +``` + +## Additional Documentation + + + +* [API documentation](https://learn.microsoft.com/dotnet/api/system.formats.nrbf) +* [BinaryFormatter migration guide: Read BinaryFormatter (NRBF) payloads](https://learn.microsoft.com/dotnet/standard/serialization/binaryformatter-migration-guide/read-nrbf-payloads) + +## Feedback & Contributing + + + +System.Formats.Nrbf is released as open source under the [MIT license](https://licenses.nuget.org/MIT). Bug reports and contributions are welcome at [the GitHub repository](https://github.com/dotnet/runtime). diff --git a/src/libraries/System.Formats.Nrbf/src/Resources/Strings.resx b/src/libraries/System.Formats.Nrbf/src/Resources/Strings.resx index 22ce2808f24..c6085fff723 100644 --- a/src/libraries/System.Formats.Nrbf/src/Resources/Strings.resx +++ b/src/libraries/System.Formats.Nrbf/src/Resources/Strings.resx @@ -126,26 +126,23 @@ Unexpected Null Record count. - - The serialized array length ({0}) was larger than the configured limit {1}. - {0} Record Type is not supported by design. - Member reference was pointing to a record of unexpected type. + Invalid member reference. - Invalid type name: `{0}`. + Invalid type name. Expected the array to be of type {0}, but its element type was {1}. - Invalid type or assembly name: `{0},{1}`. + Invalid type or assembly name. - Duplicate member name: `{0}`. + Duplicate member name. Stream does not support seeking. @@ -159,4 +156,13 @@ Only arrays with zero offsets are supported. + + Invalid assembly name. + + + Invalid format. + + + A surrogate character was read. + \ No newline at end of file diff --git a/src/libraries/System.Formats.Nrbf/src/System.Formats.Nrbf.csproj b/src/libraries/System.Formats.Nrbf/src/System.Formats.Nrbf.csproj index c6fa4c07adf..b75e1fb6408 100644 --- a/src/libraries/System.Formats.Nrbf/src/System.Formats.Nrbf.csproj +++ b/src/libraries/System.Formats.Nrbf/src/System.Formats.Nrbf.csproj @@ -5,19 +5,22 @@ true false true - Provides a safe reader for .NET Remoting Binary Format (NRBF) payloads. - -Commonly Used Types: -System.Formats.Nrbf.NrbfDecoder true - - false + true + + + + + + diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/AllowedRecordType.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/AllowedRecordType.cs index 8a3b3046105..063a2430782 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/AllowedRecordType.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/AllowedRecordType.cs @@ -3,6 +3,9 @@ namespace System.Formats.Nrbf; +// See [MS-NRBF] Sec. 2.7 for more information. +// https://learn.microsoft.com/openspecs/windows_protocols/ms-nrbf/ca3ad2bc-777b-413a-a72a-9ba6ced76bc3 + [Flags] internal enum AllowedRecordTypes : uint { diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArrayInfo.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArrayInfo.cs index e8b28825888..da03a459f35 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArrayInfo.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArrayInfo.cs @@ -13,22 +13,26 @@ namespace System.Formats.Nrbf; /// /// ArrayInfo structures are described in [MS-NRBF] 2.4.2.1. /// -[DebuggerDisplay("Length={Length}, {ArrayType}, rank={Rank}")] +[DebuggerDisplay("{ArrayType}, rank={Rank}")] internal readonly struct ArrayInfo { - internal const int MaxArrayLength = 2147483591; // Array.MaxLength +#if NET8_0_OR_GREATER + internal static int MaxArrayLength => Array.MaxLength; // dynamic lookup in case the value changes in a future runtime +#else + internal const int MaxArrayLength = 2147483591; // hardcode legacy Array.MaxLength for downlevel runtimes +#endif internal ArrayInfo(SerializationRecordId id, long totalElementsCount, BinaryArrayType arrayType = BinaryArrayType.Single, int rank = 1) { Id = id; - TotalElementsCount = totalElementsCount; + FlattenedLength = totalElementsCount; ArrayType = arrayType; Rank = rank; } internal SerializationRecordId Id { get; } - internal long TotalElementsCount { get; } + internal long FlattenedLength { get; } internal BinaryArrayType ArrayType { get; } @@ -36,8 +40,8 @@ internal ArrayInfo(SerializationRecordId id, long totalElementsCount, BinaryArra internal int GetSZArrayLength() { - Debug.Assert(TotalElementsCount <= MaxArrayLength); - return (int)TotalElementsCount; + Debug.Assert(FlattenedLength <= MaxArrayLength); + return (int)FlattenedLength; } internal static ArrayInfo Decode(BinaryReader reader) @@ -47,7 +51,7 @@ internal static int ParseValidArrayLength(BinaryReader reader) { int length = reader.ReadInt32(); - if (length is < 0 or > MaxArrayLength) + if (length < 0 || length > MaxArrayLength) { ThrowHelper.ThrowInvalidValue(length); } diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArrayOfClassesRecord.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArrayOfClassesRecord.cs index 46e066bd39d..f345292c693 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArrayOfClassesRecord.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArrayOfClassesRecord.cs @@ -4,6 +4,7 @@ using System.Collections.Generic; using System.Reflection.Metadata; using System.Formats.Nrbf.Utils; +using System.Diagnostics; namespace System.Formats.Nrbf; @@ -54,6 +55,7 @@ public override TypeName TypeName } int nullCount = ((NullsRecord)actual).NullCount; + Debug.Assert(nullCount > 0, "All implementations of NullsRecord are expected to return a positive value for NullCount."); do { result[resultIndex++] = null; @@ -63,6 +65,8 @@ public override TypeName TypeName } } + Debug.Assert(resultIndex == result.Length, "We should have traversed the entirety of the newly created array."); + return result; } diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArrayRecord.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArrayRecord.cs index ddfd91a29fb..237b7b72a27 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArrayRecord.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArrayRecord.cs @@ -18,7 +18,7 @@ public abstract class ArrayRecord : SerializationRecord private protected ArrayRecord(ArrayInfo arrayInfo) { ArrayInfo = arrayInfo; - ValuesToRead = arrayInfo.TotalElementsCount; + ValuesToRead = arrayInfo.FlattenedLength; } /// @@ -27,6 +27,12 @@ private protected ArrayRecord(ArrayInfo arrayInfo) /// A buffer of integers that represent the number of elements in every dimension. public abstract ReadOnlySpan Lengths { get; } + /// + /// When overridden in a derived class, gets the total number of all elements in every dimension. + /// + /// A number that represent the total number of all elements in every dimension. + public virtual long FlattenedLength => ArrayInfo.FlattenedLength; + /// /// Gets the rank of the array. /// @@ -44,7 +50,12 @@ private protected ArrayRecord(ArrayInfo arrayInfo) internal long ValuesToRead { get; private protected set; } - private protected ArrayInfo ArrayInfo { get; } + internal ArrayInfo ArrayInfo { get; } + + internal bool IsJagged + => ArrayInfo.ArrayType == BinaryArrayType.Jagged + // It is possible to have binary array records have an element type of array without being marked as jagged. + || TypeName.GetElementType().IsArray; /// /// Allocates an array and fills it with the data provided in the serialized records (in case of primitive types like or ) or the serialized records themselves. diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArraySingleObjectRecord.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArraySingleObjectRecord.cs index de77d3e0f84..d0276ff3782 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArraySingleObjectRecord.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArraySingleObjectRecord.cs @@ -5,6 +5,7 @@ using System.IO; using System.Reflection.Metadata; using System.Formats.Nrbf.Utils; +using System.Diagnostics; namespace System.Formats.Nrbf; @@ -16,14 +17,12 @@ namespace System.Formats.Nrbf; /// internal sealed class ArraySingleObjectRecord : SZArrayRecord { - private static TypeName? s_typeName; - private ArraySingleObjectRecord(ArrayInfo arrayInfo) : base(arrayInfo) => Records = []; public override SerializationRecordType RecordType => SerializationRecordType.ArraySingleObject; public override TypeName TypeName - => s_typeName ??= TypeName.Parse(("System.Object[], " + TypeNameExtensions.CoreLibAssemblyName).AsSpan()); + => TypeNameHelpers.GetPrimitiveSZArrayTypeName(TypeNameHelpers.ObjectPrimitiveType); private List Records { get; } @@ -35,13 +34,15 @@ public override TypeName TypeName { object?[] values = new object?[Length]; - for (int recordIndex = 0, valueIndex = 0; recordIndex < Records.Count; recordIndex++) + int valueIndex = 0; + for (int recordIndex = 0; recordIndex < Records.Count; recordIndex++) { SerializationRecord record = Records[recordIndex]; int nullCount = record is NullsRecord nullsRecord ? nullsRecord.NullCount : 0; if (nullCount == 0) { + // "new object[] { }" is special cased because it allows for storing reference to itself. values[valueIndex++] = record is MemberReferenceRecord referenceRecord && referenceRecord.Reference.Equals(Id) ? values // a reference to self, and a way to get StackOverflow exception ;) : record.GetValue(); @@ -61,6 +62,8 @@ public override TypeName TypeName while (nullCount > 0); } + Debug.Assert(valueIndex == values.Length, "We should have traversed the entirety of the newly created array."); + return values; } diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArraySinglePrimitiveRecord.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArraySinglePrimitiveRecord.cs index a09ca6b7e48..a13507b9701 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArraySinglePrimitiveRecord.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArraySinglePrimitiveRecord.cs @@ -24,8 +24,6 @@ namespace System.Formats.Nrbf; internal sealed class ArraySinglePrimitiveRecord : SZArrayRecord where T : unmanaged { - private static TypeName? s_typeName; - internal ArraySinglePrimitiveRecord(ArrayInfo arrayInfo, IReadOnlyList values) : base(arrayInfo) { Values = values; @@ -35,8 +33,7 @@ internal ArraySinglePrimitiveRecord(ArrayInfo arrayInfo, IReadOnlyList values public override SerializationRecordType RecordType => SerializationRecordType.ArraySinglePrimitive; /// - public override TypeName TypeName - => s_typeName ??= TypeName.Parse((typeof(T[]).FullName + "," + TypeNameExtensions.CoreLibAssemblyName).AsSpan()); + public override TypeName TypeName => TypeNameHelpers.GetPrimitiveSZArrayTypeName(TypeNameHelpers.GetPrimitiveType()); internal IReadOnlyList Values { get; } @@ -44,17 +41,9 @@ public override TypeName TypeName public override T[] GetArray(bool allowNulls = true) => (T[])(_arrayNullsNotAllowed ??= (Values is T[] array ? array : Values.ToArray())); - internal override (AllowedRecordTypes allowed, PrimitiveType primitiveType) GetAllowedRecordType() - { - Debug.Fail("GetAllowedRecordType should never be called on ArraySinglePrimitiveRecord"); - throw new InvalidOperationException(); - } + internal override (AllowedRecordTypes allowed, PrimitiveType primitiveType) GetAllowedRecordType() => throw new InvalidOperationException(); - private protected override void AddValue(object value) - { - Debug.Fail("AddValue should never be called on ArraySinglePrimitiveRecord"); - throw new InvalidOperationException(); - } + private protected override void AddValue(object value) => throw new InvalidOperationException(); internal static IReadOnlyList DecodePrimitiveTypes(BinaryReader reader, int count) { @@ -64,8 +53,32 @@ internal static IReadOnlyList DecodePrimitiveTypes(BinaryReader reader, int c return (List)(object)DecodeDecimals(reader, count); } + // char[] has a unique representation in NRBF streams. Typical strings are transcoded + // to UTF-8 and prefixed with the number of bytes in the UTF-8 representation. char[] + // is also serialized as UTF-8, but it is instead prefixed with the number of chars + // in the UTF-16 representation, not the number of bytes in the UTF-8 representation. + // This number doesn't directly precede the UTF-8 contents in the NRBF stream; it's + // instead contained within the ArrayInfo structure (passed to this method as the + // 'count' argument). + // + // The practical consequence of this is that we don't actually know how many UTF-8 + // bytes we need to consume in order to ensure we've read 'count' chars. We know that + // an n-length UTF-16 string turns into somewhere between [n .. 3n] UTF-8 bytes. + // The best we can do is that when reading an n-element char[], we'll ensure that + // there are at least n bytes remaining in the input stream. We'll still need to + // account for that even with this check, we might hit EOF before fully populating + // the char[]. But from a safety perspective, it does appropriately limit our + // allocations to be proportional to the amount of data present in the input stream, + // which is a sufficient defense against DoS. + long requiredBytes = count; - if (typeof(T) != typeof(char)) // the input is UTF8 + if (typeof(T) == typeof(DateTime) || typeof(T) == typeof(TimeSpan)) + { + // We can't assume DateTime as represented by the runtime is 8 bytes. + // The only assumption we can make is that it's 8 bytes on the wire. + requiredBytes *= 8; + } + else if (typeof(T) != typeof(char)) { requiredBytes *= Unsafe.SizeOf(); } @@ -88,7 +101,11 @@ internal static IReadOnlyList DecodePrimitiveTypes(BinaryReader reader, int c } else if (typeof(T) == typeof(char)) { - return (T[])(object)reader.ReadChars(count); + return (T[])(object)reader.ParseChars(count); + } + else if (typeof(T) == typeof(TimeSpan) || typeof(T) == typeof(DateTime)) + { + return DecodeTime(reader, count); } // It's safe to pre-allocate, as we have ensured there is enough bytes in the stream. @@ -97,7 +114,7 @@ internal static IReadOnlyList DecodePrimitiveTypes(BinaryReader reader, int c #if NET reader.BaseStream.ReadExactly(resultAsBytes); #else - byte[] bytes = ArrayPool.Shared.Rent(Math.Min(count * Unsafe.SizeOf(), 256_000)); + byte[] bytes = ArrayPool.Shared.Rent((int)Math.Min(requiredBytes, 256_000)); while (!resultAsBytes.IsEmpty) { @@ -141,8 +158,7 @@ internal static IReadOnlyList DecodePrimitiveTypes(BinaryReader reader, int c } #endif } - else if (typeof(T) == typeof(long) || typeof(T) == typeof(ulong) || typeof(T) == typeof(double) - || typeof(T) == typeof(DateTime) || typeof(T) == typeof(TimeSpan)) + else if (typeof(T) == typeof(long) || typeof(T) == typeof(ulong) || typeof(T) == typeof(double)) { Span span = MemoryMarshal.Cast(result); #if NET @@ -156,37 +172,62 @@ internal static IReadOnlyList DecodePrimitiveTypes(BinaryReader reader, int c } } + if (typeof(T) == typeof(bool)) + { + // See DontCastBytesToBooleans test to see what could go wrong. + bool[] booleans = (bool[])(object)result; + resultAsBytes = MemoryMarshal.AsBytes(result); + for (int i = 0; i < booleans.Length; i++) + { + // We don't use the bool array to get the value, as an optimizing compiler or JIT could elide this. + if (resultAsBytes[i] != 0) // it can be any byte different than 0 + { + booleans[i] = true; // set it to 1 in explicit way + } + } + } + return result; } private static List DecodeDecimals(BinaryReader reader, int count) { List values = new(); -#if NET - Span buffer = stackalloc byte[256]; for (int i = 0; i < count; i++) { - int stringLength = reader.Read7BitEncodedInt(); - if (!(stringLength > 0 && stringLength <= buffer.Length)) - { - ThrowHelper.ThrowInvalidValue(stringLength); - } - - reader.BaseStream.ReadExactly(buffer.Slice(0, stringLength)); - - values.Add(decimal.Parse(buffer.Slice(0, stringLength), CultureInfo.InvariantCulture)); + values.Add(reader.ParseDecimal()); } -#else - for (int i = 0; i < count; i++) + return values; + } + + private static T[] DecodeTime(BinaryReader reader, int count) + { + T[] values = new T[count]; + for (int i = 0; i < values.Length; i++) { - values.Add(decimal.Parse(reader.ReadString(), CultureInfo.InvariantCulture)); + if (typeof(T) == typeof(DateTime)) + { + values[i] = (T)(object)Utils.BinaryReaderExtensions.CreateDateTimeFromData(reader.ReadUInt64()); + } + else if (typeof(T) == typeof(TimeSpan)) + { + values[i] = (T)(object)new TimeSpan(reader.ReadInt64()); + } + else + { + throw new InvalidOperationException(); + } } -#endif + return values; } private static List DecodeFromNonSeekableStream(BinaryReader reader, int count) { + // The count arg could originate from untrusted input, so we shouldn't + // pass it as-is to the ctor's capacity arg. We'll instead rely on + // List.Add's O(1) amortization to keep the entire loop O(count). + List values = new List(Math.Min(count, 4)); for (int i = 0; i < count; i++) { @@ -204,7 +245,7 @@ private static List DecodeFromNonSeekableStream(BinaryReader reader, int coun } else if (typeof(T) == typeof(char)) { - values.Add((T)(object)reader.ReadChar()); + values.Add((T)(object)reader.ParseChar()); } else if (typeof(T) == typeof(short)) { @@ -240,14 +281,16 @@ private static List DecodeFromNonSeekableStream(BinaryReader reader, int coun } else if (typeof(T) == typeof(DateTime)) { - values.Add((T)(object)Utils.BinaryReaderExtensions.CreateDateTimeFromData(reader.ReadInt64())); + values.Add((T)(object)Utils.BinaryReaderExtensions.CreateDateTimeFromData(reader.ReadUInt64())); } - else + else if (typeof(T) == typeof(TimeSpan)) { - Debug.Assert(typeof(T) == typeof(TimeSpan)); - values.Add((T)(object)new TimeSpan(reader.ReadInt64())); } + else + { + throw new InvalidOperationException(); + } } return values; diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArraySingleStringRecord.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArraySingleStringRecord.cs index 4d7f5ace476..42b9eadd97b 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArraySingleStringRecord.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ArraySingleStringRecord.cs @@ -5,6 +5,7 @@ using System.IO; using System.Reflection.Metadata; using System.Formats.Nrbf.Utils; +using System.Diagnostics; namespace System.Formats.Nrbf; @@ -16,15 +17,12 @@ namespace System.Formats.Nrbf; /// internal sealed class ArraySingleStringRecord : SZArrayRecord { - private static TypeName? s_typeName; - private ArraySingleStringRecord(ArrayInfo arrayInfo) : base(arrayInfo) => Records = []; public override SerializationRecordType RecordType => SerializationRecordType.ArraySingleString; /// - public override TypeName TypeName - => s_typeName ??= TypeName.Parse(("System.String[], " + TypeNameExtensions.CoreLibAssemblyName).AsSpan()); + public override TypeName TypeName => TypeNameHelpers.GetPrimitiveSZArrayTypeName(TypeNameHelpers.StringPrimitiveType); private List Records { get; } @@ -50,7 +48,8 @@ internal override (AllowedRecordTypes allowed, PrimitiveType primitiveType) GetA { string?[] values = new string?[Length]; - for (int recordIndex = 0, valueIndex = 0; recordIndex < Records.Count; recordIndex++) + int valueIndex = 0; + for (int recordIndex = 0; recordIndex < Records.Count; recordIndex++) { SerializationRecord record = Records[recordIndex]; @@ -76,6 +75,7 @@ record = memberReference.GetReferencedRecord(); } int nullCount = ((NullsRecord)record).NullCount; + Debug.Assert(nullCount > 0, "All implementations of NullsRecord are expected to return a positive value for NullCount."); do { values[valueIndex++] = null; @@ -84,6 +84,8 @@ record = memberReference.GetReferencedRecord(); while (nullCount > 0); } + Debug.Assert(valueIndex == values.Length, "We should have traversed the entirety of the newly created array."); + return values; } } diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/BinaryArrayRecord.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/BinaryArrayRecord.cs index 0c7e04e840a..41b1f73f035 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/BinaryArrayRecord.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/BinaryArrayRecord.cs @@ -6,6 +6,7 @@ using System.IO; using System.Reflection.Metadata; using System.Formats.Nrbf.Utils; +using System.Diagnostics; namespace System.Formats.Nrbf; @@ -27,12 +28,15 @@ internal sealed class BinaryArrayRecord : ArrayRecord ]; private TypeName? _typeName; + private long _totalElementsCount; private BinaryArrayRecord(ArrayInfo arrayInfo, MemberTypeInfo memberTypeInfo) : base(arrayInfo) { MemberTypeInfo = memberTypeInfo; Values = []; + // We need to parse all elements of the jagged array to obtain total elements count. + _totalElementsCount = -1; } public override SerializationRecordType RecordType => SerializationRecordType.BinaryArray; @@ -40,6 +44,22 @@ private BinaryArrayRecord(ArrayInfo arrayInfo, MemberTypeInfo memberTypeInfo) /// public override ReadOnlySpan Lengths => new int[1] { Length }; + /// + public override long FlattenedLength + { + get + { + if (_totalElementsCount < 0) + { + _totalElementsCount = IsJagged + ? GetJaggedArrayFlattenedLength(this) + : ArrayInfo.FlattenedLength; + } + + return _totalElementsCount; + } + } + public override TypeName TypeName => _typeName ??= MemberTypeInfo.GetArrayTypeName(ArrayInfo); @@ -84,6 +104,10 @@ private protected override Array Deserialize(Type arrayType, bool allowNulls) case SerializationRecordType.ArraySinglePrimitive: case SerializationRecordType.ArraySingleObject: case SerializationRecordType.ArraySingleString: + + // Recursion depth is bounded by the depth of arrayType, which is + // a trustworthy Type instance. Don't need to worry about stack overflow. + ArrayRecord nestedArrayRecord = (ArrayRecord)record; Array nestedArray = nestedArrayRecord.GetArray(actualElementType, allowNulls); array.SetValue(nestedArray, resultIndex++); @@ -97,6 +121,7 @@ private protected override Array Deserialize(Type arrayType, bool allowNulls) } int nullCount = ((NullsRecord)item).NullCount; + Debug.Assert(nullCount > 0, "All implementations of NullsRecord are expected to return a positive value for NullCount."); do { array.SetValue(null, resultIndex++); @@ -110,6 +135,8 @@ private protected override Array Deserialize(Type arrayType, bool allowNulls) } } + Debug.Assert(resultIndex == array.Length, "We should have traversed the entirety of the newly created array."); + return array; } @@ -122,6 +149,7 @@ internal static ArrayRecord Decode(BinaryReader reader, RecordMap recordMap, Pay bool isRectangular = arrayType is BinaryArrayType.Rectangular; // It is an arbitrary limit in the current CoreCLR type loader. + // Don't change this value without reviewing the loop a few lines below. const int MaxSupportedArrayRank = 32; if (rank < 1 || rank > MaxSupportedArrayRank @@ -132,18 +160,26 @@ internal static ArrayRecord Decode(BinaryReader reader, RecordMap recordMap, Pay } int[] lengths = new int[rank]; // adversary-controlled, but acceptable since upper limit of 32 - long totalElementCount = 1; + long totalElementCount = 1; // to avoid integer overflow during the multiplication below for (int i = 0; i < lengths.Length; i++) { lengths[i] = ArrayInfo.ParseValidArrayLength(reader); totalElementCount *= lengths[i]; - if (totalElementCount > uint.MaxValue) + // n.b. This forbids "new T[Array.MaxLength, Array.MaxLength, Array.MaxLength, ..., 0]" + // but allows "new T[0, Array.MaxLength, Array.MaxLength, Array.MaxLength, ...]". But + // that's the same behavior that newarr and Array.CreateInstance exhibit, so at least + // we're consistent. + + if (totalElementCount > ArrayInfo.MaxArrayLength) { ThrowHelper.ThrowInvalidValue(lengths[i]); // max array size exceeded } } + // Per BinaryReaderExtensions.ReadArrayType, we do not support nonzero offsets, so + // we don't need to read the NRBF stream 'LowerBounds' field here. + MemberTypeInfo memberTypeInfo = MemberTypeInfo.Decode(reader, 1, options, recordMap); ArrayInfo arrayInfo = new(objectId, totalElementCount, arrayType, rank); @@ -157,6 +193,65 @@ internal static ArrayRecord Decode(BinaryReader reader, RecordMap recordMap, Pay : new BinaryArrayRecord(arrayInfo, memberTypeInfo); } + private static long GetJaggedArrayFlattenedLength(BinaryArrayRecord jaggedArrayRecord) + { + long result = 0; + Queue? jaggedArrayRecords = null; + + do + { + if (jaggedArrayRecords is not null) + { + jaggedArrayRecord = jaggedArrayRecords.Dequeue(); + } + + Debug.Assert(jaggedArrayRecord.IsJagged); + + // In theory somebody could create a payload that would represent + // a very nested array with total elements count > long.MaxValue. + // That is why this method is using checked arithmetic. + result = checked(result + jaggedArrayRecord.Length); // count the arrays themselves + + foreach (object value in jaggedArrayRecord.Values) + { + if (value is not SerializationRecord record) + { + continue; + } + + if (record.RecordType == SerializationRecordType.MemberReference) + { + record = ((MemberReferenceRecord)record).GetReferencedRecord(); + } + + switch (record.RecordType) + { + case SerializationRecordType.ArraySinglePrimitive: + case SerializationRecordType.ArraySingleObject: + case SerializationRecordType.ArraySingleString: + case SerializationRecordType.BinaryArray: + ArrayRecord nestedArrayRecord = (ArrayRecord)record; + if (nestedArrayRecord.IsJagged) + { + (jaggedArrayRecords ??= new()).Enqueue((BinaryArrayRecord)nestedArrayRecord); + } + else + { + // Don't call nestedArrayRecord.FlattenedLength to avoid any potential recursion, + // just call nestedArrayRecord.ArrayInfo.FlattenedLength that returns pre-computed value. + result = checked(result + nestedArrayRecord.ArrayInfo.FlattenedLength); + } + break; + default: + break; + } + } + } + while (jaggedArrayRecords is not null && jaggedArrayRecords.Count > 0); + + return result; + } + private protected override void AddValue(object value) => Values.Add(value); internal override (AllowedRecordTypes allowed, PrimitiveType primitiveType) GetAllowedRecordType() @@ -186,6 +281,9 @@ private static Type MapElementType(Type arrayType, out bool isClassRecord) Type elementType = arrayType; int arrayNestingDepth = 0; + // Loop iteration counts are bound by the nesting depth of arrayType, + // which is a trustworthy input. No DoS concerns. + while (elementType.IsArray) { elementType = elementType.GetElementType()!; diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/BinaryLibraryRecord.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/BinaryLibraryRecord.cs index d7a92293fdd..b723d8083e4 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/BinaryLibraryRecord.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/BinaryLibraryRecord.cs @@ -2,6 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. using System.Diagnostics; +using System.Formats.Nrbf.Utils; using System.IO; using System.Reflection.Metadata; @@ -15,7 +16,13 @@ namespace System.Formats.Nrbf; /// internal sealed class BinaryLibraryRecord : SerializationRecord { - private BinaryLibraryRecord(SerializationRecordId libraryId, string libraryName) + private BinaryLibraryRecord(SerializationRecordId libraryId, string rawLibraryName) + { + Id = libraryId; + RawLibraryName = rawLibraryName; + } + + private BinaryLibraryRecord(SerializationRecordId libraryId, AssemblyNameInfo libraryName) { Id = libraryId; LibraryName = libraryName; @@ -23,20 +30,29 @@ private BinaryLibraryRecord(SerializationRecordId libraryId, string libraryName) public override SerializationRecordType RecordType => SerializationRecordType.BinaryLibrary; - public override TypeName TypeName - { - get - { - Debug.Fail("TypeName should never be called on BinaryLibraryRecord"); - return TypeName.Parse(nameof(BinaryLibraryRecord).AsSpan()); - } - } + public override TypeName TypeName => TypeName.Parse(nameof(BinaryLibraryRecord).AsSpan()); + + internal string? RawLibraryName { get; } - internal string LibraryName { get; } + internal AssemblyNameInfo? LibraryName { get; } /// public override SerializationRecordId Id { get; } - internal static BinaryLibraryRecord Decode(BinaryReader reader) - => new(SerializationRecordId.Decode(reader), reader.ReadString()); + internal static BinaryLibraryRecord Decode(BinaryReader reader, PayloadOptions options) + { + SerializationRecordId id = SerializationRecordId.Decode(reader); + string rawName = reader.ReadString(); + + if (AssemblyNameInfo.TryParse(rawName.AsSpan(), out AssemblyNameInfo? assemblyNameInfo)) + { + return new BinaryLibraryRecord(id, assemblyNameInfo); + } + else if (!options.UndoTruncatedTypeNames) + { + ThrowHelper.ThrowInvalidAssemblyName(); + } + + return new BinaryLibraryRecord(id, rawName); + } } diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ClassInfo.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ClassInfo.cs index 75340b72a4f..a1cb7b47fb5 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ClassInfo.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ClassInfo.cs @@ -50,7 +50,8 @@ internal static ClassInfo Decode(BinaryReader reader) // Use Dictionary instead of List so that searching for member IDs by name // is O(n) instead of O(m * n), where m = memberCount and n = memberNameLength, - // in degenerate cases. + // in degenerate cases. Since memberCount may be hostile, don't allow it to be + // used as the initial capacity in the collection instance. Dictionary memberNames = new(StringComparer.Ordinal); for (int i = 0; i < memberCount; i++) { @@ -70,7 +71,7 @@ internal static ClassInfo Decode(BinaryReader reader) continue; } #endif - throw new SerializationException(SR.Format(SR.Serialization_DuplicateMemberName, memberName)); + ThrowHelper.ThrowDuplicateMemberName(); } return new ClassInfo(id, typeName, memberNames); diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ClassRecord.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ClassRecord.cs index 04a60dea40b..1d61bee3b23 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ClassRecord.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ClassRecord.cs @@ -40,15 +40,13 @@ private protected ClassRecord(ClassInfo classInfo, MemberTypeInfo memberTypeInfo internal List MemberValues { get; } /// - /// Checks if member of given name was present in the payload. + /// Checks if the member with the given name was present in the payload. /// /// The name of the member. /// if it was present, otherwise . /// - /// - /// It's recommended to use this method when dealing with payload that may contain + /// It's recommended to use this method when dealing with payload that might contain /// different versions of the same type. - /// /// public bool HasMember(string memberName) => ClassInfo.MemberNames.ContainsKey(memberName); @@ -57,8 +55,8 @@ private protected ClassRecord(ClassInfo classInfo, MemberTypeInfo memberTypeInfo /// /// The name of the member. /// The value. - /// does not refer to a known member. You can use to check if given member exists. - /// Member of such name has value of a different type. + /// does not refer to a known member. You can use to check if a given member exists. + /// The member with the specified name has a value of a different type. public ClassRecord? GetClassRecord(string memberName) => GetMember(memberName); /// @@ -95,10 +93,10 @@ private protected ClassRecord(ClassInfo classInfo, MemberTypeInfo memberTypeInfo public DateTime GetDateTime(string memberName) => GetMember(memberName); /// - /// For primitive types like , or returns their value. + /// For primitive types like , , or , returns their value. /// For nulls, returns a null. /// For other types that are not arrays, returns an instance of . - /// For single-dimensional arrays returns where the generic type is the primitive type or . + /// For single-dimensional arrays, returns where the generic type is the primitive type or . /// For jagged and multi-dimensional arrays, returns an instance of . /// /// @@ -112,7 +110,7 @@ private protected ClassRecord(ClassInfo classInfo, MemberTypeInfo memberTypeInfo /// /// The name of the field. /// The serialization record, which can be any of , - /// , or . + /// , , or . /// /// does not refer to a known member. You can use to check if given member exists. /// The specified member is not a , but just a raw primitive value. diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ClassTypeInfo.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ClassTypeInfo.cs index 6a9e9d7b90a..dd5ee0e5bdf 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ClassTypeInfo.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ClassTypeInfo.cs @@ -9,7 +9,7 @@ namespace System.Formats.Nrbf; /// -/// Identifies a class by it's name and library id. +/// Identifies a class by its name and library id. /// /// /// ClassTypeInfo structures are described in [MS-NRBF] 2.1.1.8. @@ -26,7 +26,7 @@ internal static ClassTypeInfo Decode(BinaryReader reader, PayloadOptions options string rawName = reader.ReadString(); SerializationRecordId libraryId = SerializationRecordId.Decode(reader); - BinaryLibraryRecord library = (BinaryLibraryRecord)recordMap[libraryId]; + BinaryLibraryRecord library = recordMap.GetRecord(libraryId); return new ClassTypeInfo(rawName.ParseNonSystemClassRecordTypeName(library, options)); } diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ClassWithIdRecord.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ClassWithIdRecord.cs index e18033524d1..c643d3ce8c8 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ClassWithIdRecord.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ClassWithIdRecord.cs @@ -34,10 +34,7 @@ internal static ClassWithIdRecord Decode( SerializationRecordId id = SerializationRecordId.Decode(reader); SerializationRecordId metadataId = SerializationRecordId.Decode(reader); - if (recordMap[metadataId] is not ClassRecord referencedRecord) - { - throw new SerializationException(SR.Serialization_InvalidReference); - } + ClassRecord referencedRecord = recordMap.GetRecord(metadataId); return new ClassWithIdRecord(id, referencedRecord); } diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ClassWithMembersAndTypesRecord.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ClassWithMembersAndTypesRecord.cs index 117e5e90ef6..d6d8c122d3e 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ClassWithMembersAndTypesRecord.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/ClassWithMembersAndTypesRecord.cs @@ -27,7 +27,7 @@ internal static ClassWithMembersAndTypesRecord Decode(BinaryReader reader, Recor MemberTypeInfo memberTypeInfo = MemberTypeInfo.Decode(reader, classInfo.MemberNames.Count, options, recordMap); SerializationRecordId libraryId = SerializationRecordId.Decode(reader); - BinaryLibraryRecord library = (BinaryLibraryRecord)recordMap[libraryId]; + BinaryLibraryRecord library = recordMap.GetRecord(libraryId); classInfo.LoadTypeName(library, options); return new ClassWithMembersAndTypesRecord(classInfo, memberTypeInfo); diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/MemberReferenceRecord.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/MemberReferenceRecord.cs index 162cf0b1d5c..14bd4e7ff1f 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/MemberReferenceRecord.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/MemberReferenceRecord.cs @@ -38,5 +38,5 @@ private MemberReferenceRecord(SerializationRecordId reference, RecordMap recordM internal static MemberReferenceRecord Decode(BinaryReader reader, RecordMap recordMap) => new(SerializationRecordId.Decode(reader), recordMap); - internal SerializationRecord GetReferencedRecord() => RecordMap[Reference]; + internal SerializationRecord GetReferencedRecord() => RecordMap.GetRecord(Reference); } diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/MemberTypeInfo.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/MemberTypeInfo.cs index 9e6c2445877..57e47a02eec 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/MemberTypeInfo.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/MemberTypeInfo.cs @@ -53,10 +53,14 @@ internal static MemberTypeInfo Decode(BinaryReader reader, int count, PayloadOpt case BinaryType.Class: info[i] = (type, ClassTypeInfo.Decode(reader, options, recordMap)); break; - default: - // Other types have no additional data. - Debug.Assert(type is BinaryType.String or BinaryType.ObjectArray or BinaryType.StringArray or BinaryType.Object); + case BinaryType.String: + case BinaryType.StringArray: + case BinaryType.Object: + case BinaryType.ObjectArray: + // These types have no additional data. break; + default: + throw new InvalidOperationException(); } } @@ -97,7 +101,8 @@ internal static MemberTypeInfo Decode(BinaryReader reader, int count, PayloadOpt BinaryType.PrimitiveArray => (PrimitiveArray, default), BinaryType.Class => (NonSystemClass, default), BinaryType.SystemClass => (SystemClass, default), - _ => (ObjectArray, default) + BinaryType.ObjectArray => (ObjectArray, default), + _ => throw new InvalidOperationException() }; } @@ -105,7 +110,7 @@ internal bool ShouldBeRepresentedAsArrayOfClassRecords() { // This library tries to minimize the number of concepts the users need to learn to use it. // Since SZArrays are most common, it provides an SZArrayRecord abstraction. - // Every other array (jagged, multi-dimensional etc) is represented using SZArrayRecord. + // Every other array (jagged, multi-dimensional etc) is represented using ArrayRecord. // The goal of this method is to determine whether given array can be represented as SZArrayRecord. (BinaryType binaryType, object? additionalInfo) = Infos[0]; @@ -142,63 +147,26 @@ internal TypeName GetArrayTypeName(ArrayInfo arrayInfo) { (BinaryType binaryType, object? additionalInfo) = Infos[0]; - switch (binaryType) + TypeName elementTypeName = binaryType switch { - case BinaryType.String: - return typeof(string).BuildCoreLibArrayTypeName(arrayInfo.Rank); - case BinaryType.StringArray: - return typeof(string[]).BuildCoreLibArrayTypeName(arrayInfo.Rank); - case BinaryType.Object: - return typeof(object).BuildCoreLibArrayTypeName(arrayInfo.Rank); - case BinaryType.ObjectArray: - return typeof(object[]).BuildCoreLibArrayTypeName(arrayInfo.Rank); - case BinaryType.Primitive: - Type primitiveType = ((PrimitiveType)additionalInfo!) switch - { - PrimitiveType.Boolean => typeof(bool), - PrimitiveType.Byte => typeof(byte), - PrimitiveType.Char => typeof(char), - PrimitiveType.Decimal => typeof(decimal), - PrimitiveType.Double => typeof(double), - PrimitiveType.Int16 => typeof(short), - PrimitiveType.Int32 => typeof(int), - PrimitiveType.Int64 => typeof(long), - PrimitiveType.SByte => typeof(sbyte), - PrimitiveType.Single => typeof(float), - PrimitiveType.TimeSpan => typeof(TimeSpan), - PrimitiveType.DateTime => typeof(DateTime), - PrimitiveType.UInt16 => typeof(ushort), - PrimitiveType.UInt32 => typeof(uint), - _ => typeof(ulong), - }; - - return primitiveType.BuildCoreLibArrayTypeName(arrayInfo.Rank); - case BinaryType.PrimitiveArray: - Type primitiveArrayType = ((PrimitiveType)additionalInfo!) switch - { - PrimitiveType.Boolean => typeof(bool[]), - PrimitiveType.Byte => typeof(byte[]), - PrimitiveType.Char => typeof(char[]), - PrimitiveType.Decimal => typeof(decimal[]), - PrimitiveType.Double => typeof(double[]), - PrimitiveType.Int16 => typeof(short[]), - PrimitiveType.Int32 => typeof(int[]), - PrimitiveType.Int64 => typeof(long[]), - PrimitiveType.SByte => typeof(sbyte[]), - PrimitiveType.Single => typeof(float[]), - PrimitiveType.TimeSpan => typeof(TimeSpan[]), - PrimitiveType.DateTime => typeof(DateTime[]), - PrimitiveType.UInt16 => typeof(ushort[]), - PrimitiveType.UInt32 => typeof(uint[]), - _ => typeof(ulong[]), - }; - - return primitiveArrayType.BuildCoreLibArrayTypeName(arrayInfo.Rank); - case BinaryType.SystemClass: - return ((TypeName)additionalInfo!).BuildArrayTypeName(arrayInfo.Rank); - default: - Debug.Assert(binaryType is BinaryType.Class, "The parsers should reject other inputs"); - return (((ClassTypeInfo)additionalInfo!).TypeName).BuildArrayTypeName(arrayInfo.Rank); - } + BinaryType.String => TypeNameHelpers.GetPrimitiveTypeName(TypeNameHelpers.StringPrimitiveType), + BinaryType.StringArray => TypeNameHelpers.GetPrimitiveSZArrayTypeName(TypeNameHelpers.StringPrimitiveType), + BinaryType.Primitive => TypeNameHelpers.GetPrimitiveTypeName((PrimitiveType)additionalInfo!), + BinaryType.PrimitiveArray => TypeNameHelpers.GetPrimitiveSZArrayTypeName((PrimitiveType)additionalInfo!), + BinaryType.Object => TypeNameHelpers.GetPrimitiveTypeName(TypeNameHelpers.ObjectPrimitiveType), + BinaryType.ObjectArray => TypeNameHelpers.GetPrimitiveSZArrayTypeName(TypeNameHelpers.ObjectPrimitiveType), + BinaryType.SystemClass => (TypeName)additionalInfo!, + BinaryType.Class => ((ClassTypeInfo)additionalInfo!).TypeName, + _ => throw new InvalidOperationException() + }; + + // In general, arrayRank == 1 may have two different meanings: + // - [] is a single-dimensional array with a zero lower bound (SZArray), + // - [*] is a single-dimensional array with an arbitrary lower bound (variable bound array). + // Variable bound arrays are not supported by design, so in our case it's always SZArray. + // That is why we don't call TypeName.MakeArrayTypeName(1) because it would create [*] instead of [] name. + return arrayInfo.Rank == 1 + ? elementTypeName.MakeSZArrayTypeName() + : elementTypeName.MakeArrayTypeName(arrayInfo.Rank); } } diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/MessageEndRecord.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/MessageEndRecord.cs index 7cb28224a89..62c7d57b3fa 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/MessageEndRecord.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/MessageEndRecord.cs @@ -24,12 +24,5 @@ private MessageEndRecord() public override SerializationRecordId Id => SerializationRecordId.NoId; - public override TypeName TypeName - { - get - { - Debug.Fail("TypeName should never be called on MessageEndRecord"); - return TypeName.Parse(nameof(MessageEndRecord).AsSpan()); - } - } + public override TypeName TypeName => TypeName.Parse(nameof(MessageEndRecord).AsSpan()); } diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/NextInfo.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/NextInfo.cs index a01a25e6004..08b1f53dca6 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/NextInfo.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/NextInfo.cs @@ -27,7 +27,5 @@ internal NextInfo(AllowedRecordTypes allowed, SerializationRecord parent, internal PrimitiveType PrimitiveType { get; } internal NextInfo With(AllowedRecordTypes allowed, PrimitiveType primitiveType) - => allowed == Allowed && primitiveType == PrimitiveType - ? this // previous record was of the same type - : new(allowed, Parent, Stack, primitiveType); + => new(allowed, Parent, Stack, primitiveType); } diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/NrbfDecoder.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/NrbfDecoder.cs index 43db53fd159..02411578fb7 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/NrbfDecoder.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/NrbfDecoder.cs @@ -22,31 +22,32 @@ public static class NrbfDecoder // The header consists of: // - a byte that describes the record type (SerializationRecordType.SerializedStreamHeader) // - four 32 bit integers: - // - root Id (every value is valid) + // - root Id (every value except of 0 is valid) // - header Id (value is ignored) // - major version, it has to be equal 1. // - minor version, it has to be equal 0. private static ReadOnlySpan HeaderSuffix => [1, 0, 0, 0, 0, 0, 0, 0]; /// - /// Checks if given buffer starts with NRBF payload header. + /// Checks if the given buffer starts with the NRBF payload header. /// /// The buffer to inspect. - /// if it starts with NRBF payload header; otherwise, . + /// if the buffer starts with the NRBF payload header; otherwise, . public static bool StartsWithPayloadHeader(ReadOnlySpan bytes) => bytes.Length >= SerializedStreamHeaderRecord.Size && bytes[0] == (byte)SerializationRecordType.SerializedStreamHeader && bytes.Slice(SerializedStreamHeaderRecord.Size - HeaderSuffix.Length, HeaderSuffix.Length).SequenceEqual(HeaderSuffix); /// - /// Checks if given stream starts with NRBF payload header. + /// Checks if the given stream starts with the NRBF payload header. /// /// The stream to inspect. The stream must be both readable and seekable. - /// if it starts with NRBF payload header; otherwise, . + /// if the stream starts with the NRBF payload header; otherwise, . /// is . /// The stream does not support reading or seeking. /// The stream was closed. - /// When this method returns, will be restored to its original position. + /// An I/O error occurred. + /// When this method returns, is restored to its original position. public static bool StartsWithPayloadHeader(Stream stream) { #if NET @@ -68,28 +69,22 @@ public static bool StartsWithPayloadHeader(Stream stream) return false; } - try + byte[] buffer = new byte[SerializedStreamHeaderRecord.Size]; + int offset = 0; + while (offset < buffer.Length) { -#if NET - Span buffer = stackalloc byte[SerializedStreamHeaderRecord.Size]; - stream.ReadExactly(buffer); -#else - byte[] buffer = new byte[SerializedStreamHeaderRecord.Size]; - int offset = 0; - while (offset < buffer.Length) + int read = stream.Read(buffer, offset, buffer.Length - offset); + if (read == 0) { - int read = stream.Read(buffer, offset, buffer.Length - offset); - if (read == 0) - throw new EndOfStreamException(); - offset += read; + stream.Position = beginning; + return false; } -#endif - return StartsWithPayloadHeader(buffer); - } - finally - { - stream.Position = beginning; + offset += read; } + + bool result = StartsWithPayloadHeader(buffer); + stream.Position = beginning; + return result; } /// @@ -103,19 +98,20 @@ public static bool StartsWithPayloadHeader(Stream stream) /// /// A that represents the root object. /// It can be either , - /// a or an . + /// a , or an . /// is . /// does not support reading or is already closed. - /// Reading from encounters invalid NRBF data. + /// Reading from encountered invalid NRBF data. + /// An I/O error occurred. /// - /// Reading from encounters not supported records. - /// For example, arrays with non-zero offset or not supported record types + /// Reading from encountered unsupported records, + /// for example, arrays with non-zero offset or unsupported record types /// (, , - /// or ). + /// , or ). /// /// Reading from - /// encounters an invalid UTF8 sequence. - /// The end of the stream is reached before reading record. + /// encountered an invalid UTF8 sequence. + /// The end of the stream was reached before reading record. public static SerializationRecord Decode(Stream payload, PayloadOptions? options = default, bool leaveOpen = false) => Decode(payload, out _, options, leaveOpen); @@ -142,7 +138,14 @@ public static SerializationRecord Decode(Stream payload, out IReadOnlyDictionary #endif using BinaryReader reader = new(payload, ThrowOnInvalidUtf8Encoding, leaveOpen: leaveOpen); - return Decode(reader, options ?? new(), out recordMap); + try + { + return Decode(reader, options ?? new(), out recordMap); + } + catch (FormatException) // can be thrown by various BinaryReader methods + { + throw new SerializationException(SR.Serialization_InvalidFormat); + } } /// @@ -213,12 +216,7 @@ private static SerializationRecord Decode(BinaryReader reader, PayloadOptions op private static SerializationRecord DecodeNext(BinaryReader reader, RecordMap recordMap, AllowedRecordTypes allowed, PayloadOptions options, out SerializationRecordType recordType) { - byte nextByte = reader.ReadByte(); - if (((uint)allowed & (1u << nextByte)) == 0) - { - ThrowHelper.ThrowForUnexpectedRecordType(nextByte); - } - recordType = (SerializationRecordType)nextByte; + recordType = reader.ReadSerializationRecordType(allowed); SerializationRecord record = recordType switch { @@ -226,7 +224,7 @@ private static SerializationRecord DecodeNext(BinaryReader reader, RecordMap rec SerializationRecordType.ArraySinglePrimitive => DecodeArraySinglePrimitiveRecord(reader), SerializationRecordType.ArraySingleString => ArraySingleStringRecord.Decode(reader), SerializationRecordType.BinaryArray => BinaryArrayRecord.Decode(reader, recordMap, options), - SerializationRecordType.BinaryLibrary => BinaryLibraryRecord.Decode(reader), + SerializationRecordType.BinaryLibrary => BinaryLibraryRecord.Decode(reader, options), SerializationRecordType.BinaryObjectString => BinaryObjectStringRecord.Decode(reader), SerializationRecordType.ClassWithId => ClassWithIdRecord.Decode(reader, recordMap), SerializationRecordType.ClassWithMembersAndTypes => ClassWithMembersAndTypesRecord.Decode(reader, recordMap, options), @@ -237,7 +235,8 @@ private static SerializationRecord DecodeNext(BinaryReader reader, RecordMap rec SerializationRecordType.ObjectNullMultiple => ObjectNullMultipleRecord.Decode(reader), SerializationRecordType.ObjectNullMultiple256 => ObjectNullMultiple256Record.Decode(reader), SerializationRecordType.SerializedStreamHeader => SerializedStreamHeaderRecord.Decode(reader), - _ => SystemClassWithMembersAndTypesRecord.Decode(reader, recordMap, options), + SerializationRecordType.SystemClassWithMembersAndTypes => SystemClassWithMembersAndTypesRecord.Decode(reader, recordMap, options), + _ => throw new InvalidOperationException() }; recordMap.Add(record); @@ -254,7 +253,7 @@ private static SerializationRecord DecodeMemberPrimitiveTypedRecord(BinaryReader PrimitiveType.Boolean => new MemberPrimitiveTypedRecord(reader.ReadBoolean()), PrimitiveType.Byte => new MemberPrimitiveTypedRecord(reader.ReadByte()), PrimitiveType.SByte => new MemberPrimitiveTypedRecord(reader.ReadSByte()), - PrimitiveType.Char => new MemberPrimitiveTypedRecord(reader.ReadChar()), + PrimitiveType.Char => new MemberPrimitiveTypedRecord(reader.ParseChar()), PrimitiveType.Int16 => new MemberPrimitiveTypedRecord(reader.ReadInt16()), PrimitiveType.UInt16 => new MemberPrimitiveTypedRecord(reader.ReadUInt16()), PrimitiveType.Int32 => new MemberPrimitiveTypedRecord(reader.ReadInt32()), @@ -263,10 +262,10 @@ private static SerializationRecord DecodeMemberPrimitiveTypedRecord(BinaryReader PrimitiveType.UInt64 => new MemberPrimitiveTypedRecord(reader.ReadUInt64()), PrimitiveType.Single => new MemberPrimitiveTypedRecord(reader.ReadSingle()), PrimitiveType.Double => new MemberPrimitiveTypedRecord(reader.ReadDouble()), - PrimitiveType.Decimal => new MemberPrimitiveTypedRecord(decimal.Parse(reader.ReadString(), CultureInfo.InvariantCulture)), - PrimitiveType.DateTime => new MemberPrimitiveTypedRecord(Utils.BinaryReaderExtensions.CreateDateTimeFromData(reader.ReadInt64())), - // String is handled with a record, never on it's own - _ => new MemberPrimitiveTypedRecord(new TimeSpan(reader.ReadInt64())), + PrimitiveType.Decimal => new MemberPrimitiveTypedRecord(reader.ParseDecimal()), + PrimitiveType.DateTime => new MemberPrimitiveTypedRecord(Utils.BinaryReaderExtensions.CreateDateTimeFromData(reader.ReadUInt64())), + PrimitiveType.TimeSpan => new MemberPrimitiveTypedRecord(new TimeSpan(reader.ReadInt64())), + _ => throw new InvalidOperationException() }; } @@ -291,7 +290,8 @@ private static SerializationRecord DecodeArraySinglePrimitiveRecord(BinaryReader PrimitiveType.Double => Decode(info, reader), PrimitiveType.Decimal => Decode(info, reader), PrimitiveType.DateTime => Decode(info, reader), - _ => Decode(info, reader), + PrimitiveType.TimeSpan => Decode(info, reader), + _ => throw new InvalidOperationException() }; static SerializationRecord Decode(ArrayInfo info, BinaryReader reader) where T : unmanaged diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/NullsRecord.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/NullsRecord.cs index d3d859c193a..9c11db4307c 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/NullsRecord.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/NullsRecord.cs @@ -12,12 +12,5 @@ internal abstract class NullsRecord : SerializationRecord public override SerializationRecordId Id => SerializationRecordId.NoId; - public override TypeName TypeName - { - get - { - Debug.Fail($"TypeName should never be called on {GetType().Name}"); - return TypeName.Parse(GetType().Name.AsSpan()); - } - } + public override TypeName TypeName => TypeName.Parse(GetType().Name.AsSpan()); } diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/PayloadOptions.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/PayloadOptions.cs index 60d1aafcc52..66faa55107a 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/PayloadOptions.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/PayloadOptions.cs @@ -16,7 +16,7 @@ public sealed class PayloadOptions public PayloadOptions() { } /// - /// Configuration options for parsing instances. + /// Gets or sets configuration options for parsing instances. /// public TypeNameParseOptions? TypeNameParseOptions { get; set; } @@ -25,10 +25,17 @@ public PayloadOptions() { } /// /// if truncated type names should be reassembled; otherwise, . /// + /// /// Example: /// TypeName: "Namespace.TypeName`1[[Namespace.GenericArgName" /// LibraryName: "AssemblyName]]" /// Is combined into "Namespace.TypeName`1[[Namespace.GenericArgName, AssemblyName]]" + /// + /// + /// Setting this to can render susceptible to Denial of Service + /// attacks when parsing or handling malicious input. + /// + /// The default value is . /// public bool UndoTruncatedTypeNames { get; set; } } diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/PrimitiveType.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/PrimitiveType.cs index 9ddb9179518..f2e696e6a90 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/PrimitiveType.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/PrimitiveType.cs @@ -11,10 +11,6 @@ namespace System.Formats.Nrbf; /// internal enum PrimitiveType : byte { - /// - /// Used internally to express no value - /// - None = 0, Boolean = 1, Byte = 2, Char = 3, @@ -30,7 +26,19 @@ internal enum PrimitiveType : byte DateTime = 13, UInt16 = 14, UInt32 = 15, - UInt64 = 16, - Null = 17, - String = 18 + UInt64 = 16 + // This internal enum no longer contains Null and String as they were always illegal: + // - In case of BinaryArray (NRBF 2.4.3.1): + // "If the BinaryTypeEnum value is Primitive, the PrimitiveTypeEnumeration + // value in AdditionalTypeInfo MUST NOT be Null (17) or String (18)." + // - In case of MemberPrimitiveTyped (NRBF 2.5.1): + // "PrimitiveTypeEnum (1 byte): A PrimitiveTypeEnumeration + // value that specifies the Primitive Type of data that is being transmitted. + // This field MUST NOT contain a value of 17 (Null) or 18 (String)." + // - In case of ArraySinglePrimitive (NRBF 2.4.3.3): + // "A PrimitiveTypeEnumeration value that identifies the Primitive Type + // of the items of the Array. The value MUST NOT be 17 (Null) or 18 (String)." + // - In case of MemberTypeInfo (NRBF 2.3.1.2): + // "When the BinaryTypeEnum value is Primitive, the PrimitiveTypeEnumeration + // value in AdditionalInfo MUST NOT be Null (17) or String (18)." } diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/PrimitiveTypeRecord.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/PrimitiveTypeRecord.cs index 39e0794658c..86733370760 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/PrimitiveTypeRecord.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/PrimitiveTypeRecord.cs @@ -15,7 +15,7 @@ namespace System.Formats.Nrbf; /// , , , /// , , , , /// , , , -/// and . +/// , and . /// /// Other serialization records are represented with or . /// diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/PrimitiveTypeRecordOfT.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/PrimitiveTypeRecordOfT.cs index 72ef801e61e..ceef8c3e7f2 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/PrimitiveTypeRecordOfT.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/PrimitiveTypeRecordOfT.cs @@ -18,15 +18,13 @@ namespace System.Formats.Nrbf; /// , , , /// , , , , /// , , , -/// and . +/// , and . /// /// Other serialization records are represented with or . /// [DebuggerDisplay("{Value}")] public abstract class PrimitiveTypeRecord : PrimitiveTypeRecord { - private static TypeName? s_typeName; - private protected PrimitiveTypeRecord(T value) => Value = value; /// @@ -36,8 +34,7 @@ public abstract class PrimitiveTypeRecord : PrimitiveTypeRecord public new T Value { get; } /// - public override TypeName TypeName - => s_typeName ??= TypeName.Parse(typeof(T).FullName.AsSpan()).WithCoreLibAssemblyName(); + public override TypeName TypeName => TypeNameHelpers.GetPrimitiveTypeName(TypeNameHelpers.GetPrimitiveType()); internal override object? GetValue() => Value; } diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/RecordMap.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/RecordMap.cs index a25ab508f5d..eafcbf93249 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/RecordMap.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/RecordMap.cs @@ -56,14 +56,15 @@ internal void Add(SerializationRecord record) return; } #endif - throw new SerializationException(SR.Format(SR.Serialization_DuplicateSerializationRecordId, record.Id)); + throw new SerializationException(SR.Format(SR.Serialization_DuplicateSerializationRecordId, record.Id._id)); } } } internal SerializationRecord GetRootRecord(SerializedStreamHeaderRecord header) { - SerializationRecord rootRecord = _map[header.RootId]; + SerializationRecord rootRecord = GetRecord(header.RootId); + if (rootRecord is SystemClassWithMembersAndTypesRecord systemClass) { // update the record map, so it's visible also to those who access it via Id @@ -72,4 +73,14 @@ internal SerializationRecord GetRootRecord(SerializedStreamHeaderRecord header) return rootRecord; } + + internal SerializationRecord GetRecord(SerializationRecordId recordId) + => _map.TryGetValue(recordId, out SerializationRecord? record) + ? record + : throw new SerializationException(SR.Serialization_InvalidReference); + + internal T GetRecord(SerializationRecordId recordId) where T : SerializationRecord + => _map.TryGetValue(recordId, out SerializationRecord? record) && record is T casted + ? casted + : throw new SerializationException(SR.Serialization_InvalidReference); } diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/RectangularArrayRecord.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/RectangularArrayRecord.cs index de3c6d67185..f64dde36163 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/RectangularArrayRecord.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/RectangularArrayRecord.cs @@ -8,13 +8,14 @@ using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Formats.Nrbf.Utils; +using System.Diagnostics; namespace System.Formats.Nrbf; internal sealed class RectangularArrayRecord : ArrayRecord { private readonly int[] _lengths; - private readonly ICollection _values; + private readonly List _values; private TypeName? _typeName; private RectangularArrayRecord(Type elementType, ArrayInfo arrayInfo, @@ -24,18 +25,8 @@ private RectangularArrayRecord(Type elementType, ArrayInfo arrayInfo, MemberTypeInfo = memberTypeInfo; _lengths = lengths; - // A List can hold as many objects as an array, so for multi-dimensional arrays - // with more elements than Array.MaxLength we use LinkedList. - // Testing that many elements takes a LOT of time, so to ensure that both code paths are tested, - // we always use LinkedList code path for Debug builds. -#if DEBUG - _values = new LinkedList(); -#else - _values = arrayInfo.TotalElementsCount <= ArrayInfo.MaxArrayLength - ? new List(canPreAllocate ? arrayInfo.GetSZArrayLength() : Math.Min(4, arrayInfo.GetSZArrayLength())) - : new LinkedList(); -#endif - + // ArrayInfo.GetSZArrayLength ensures to return a value <= Array.MaxLength + _values = new List(canPreAllocate ? arrayInfo.GetSZArrayLength() : Math.Min(4, arrayInfo.GetSZArrayLength())); } public override SerializationRecordType RecordType => SerializationRecordType.BinaryArray; @@ -65,10 +56,12 @@ private protected override Array Deserialize(Type arrayType, bool allowNulls) #if !NET8_0_OR_GREATER int[] indices = new int[_lengths.Length]; + nuint numElementsWritten = 0; // only for debugging; not used in release builds foreach (object value in _values) { result.SetValue(GetActualValue(value), indices); + numElementsWritten++; int dimension = indices.Length - 1; while (dimension >= 0) @@ -88,6 +81,9 @@ private protected override Array Deserialize(Type arrayType, bool allowNulls) } } + Debug.Assert(numElementsWritten == (uint)_values.Count, "We should have traversed the entirety of the source values collection."); + Debug.Assert(numElementsWritten == (ulong)result.LongLength, "We should have traversed the entirety of the destination array."); + return result; #else // Idea from Array.CoreCLR that maps an array of int indices into @@ -108,6 +104,7 @@ private protected override Array Deserialize(Type arrayType, bool allowNulls) else if (ElementType == typeof(TimeSpan)) CopyTo(_values, result); else if (ElementType == typeof(DateTime)) CopyTo(_values, result); else if (ElementType == typeof(decimal)) CopyTo(_values, result); + else throw new InvalidOperationException(); } else { @@ -116,7 +113,7 @@ private protected override Array Deserialize(Type arrayType, bool allowNulls) return result; - static void CopyTo(ICollection list, Array array) + static void CopyTo(List list, Array array) { ref byte arrayDataRef = ref MemoryMarshal.GetArrayDataReference(array); ref T firstElementRef = ref Unsafe.As(ref arrayDataRef); @@ -127,6 +124,8 @@ static void CopyTo(ICollection list, Array array) targetElement = (T)GetActualValue(value)!; flattenedIndex++; } + + Debug.Assert(flattenedIndex == (ulong)array.LongLength, "We should have traversed the entirety of the array."); } #endif } @@ -167,7 +166,7 @@ internal static RectangularArrayRecord Create(BinaryReader reader, ArrayInfo arr PrimitiveType.Boolean => sizeof(bool), PrimitiveType.Byte => sizeof(byte), PrimitiveType.SByte => sizeof(sbyte), - PrimitiveType.Char => sizeof(byte), // it's UTF8 + PrimitiveType.Char => sizeof(byte), // it's UTF8 (see comment below) PrimitiveType.Int16 => sizeof(short), PrimitiveType.UInt16 => sizeof(ushort), PrimitiveType.Int32 => sizeof(int), @@ -176,12 +175,29 @@ internal static RectangularArrayRecord Create(BinaryReader reader, ArrayInfo arr PrimitiveType.Int64 => sizeof(long), PrimitiveType.UInt64 => sizeof(ulong), PrimitiveType.Double => sizeof(double), - _ => -1 + PrimitiveType.TimeSpan => sizeof(ulong), + PrimitiveType.DateTime => sizeof(ulong), + PrimitiveType.Decimal => -1, // represented as variable-length string + _ => throw new InvalidOperationException() }; if (sizeOfSingleValue > 0) { - long size = arrayInfo.TotalElementsCount * sizeOfSingleValue; + // NRBF encodes rectangular char[,,,...] by converting each standalone UTF-16 code point into + // its UTF-8 encoding. This means that surrogate code points (including adjacent surrogate + // pairs) occurring within a char[,,,...] cannot be encoded by NRBF. BinaryReader will detect + // that they're ill-formed and reject them on read. + // + // Per the comment in ArraySinglePrimitiveRecord.DecodePrimitiveTypes, we'll assume best-case + // encoding where 1 UTF-16 char encodes as a single UTF-8 byte, even though this might lead + // to encountering an EOF if we realize later that we actually need to read more bytes in + // order to fully populate the char[,,,...] array. Any such allocation is still linearly + // proportional to the length of the incoming payload, so it's not a DoS vector. + // The multiplication below is guaranteed not to overflow because FlattenedLength is bounded + // to <= Array.MaxLength (see BinaryArrayRecord.Decode) and sizeOfSingleValue is at most 8. + Debug.Assert(arrayInfo.FlattenedLength >= 0 && arrayInfo.FlattenedLength <= long.MaxValue / sizeOfSingleValue); + + long size = arrayInfo.FlattenedLength * sizeOfSingleValue; bool? isDataAvailable = reader.IsDataAvailable(size); if (isDataAvailable.HasValue) { @@ -215,7 +231,8 @@ private static Type MapPrimitive(PrimitiveType primitiveType) PrimitiveType.DateTime => typeof(DateTime), PrimitiveType.UInt16 => typeof(ushort), PrimitiveType.UInt32 => typeof(uint), - _ => typeof(ulong) + PrimitiveType.UInt64 => typeof(ulong), + _ => throw new InvalidOperationException() }; private static Type MapPrimitiveArray(PrimitiveType primitiveType) @@ -235,7 +252,8 @@ private static Type MapPrimitiveArray(PrimitiveType primitiveType) PrimitiveType.DateTime => typeof(DateTime[]), PrimitiveType.UInt16 => typeof(ushort[]), PrimitiveType.UInt32 => typeof(uint[]), - _ => typeof(ulong[]), + PrimitiveType.UInt64 => typeof(ulong[]), + _ => throw new InvalidOperationException() }; private static object? GetActualValue(object value) diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/SerializationRecord.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/SerializationRecord.cs index 751a932d8f8..43c51d2f864 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/SerializationRecord.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/SerializationRecord.cs @@ -13,7 +13,7 @@ namespace System.Formats.Nrbf; /// /// /// Every instance returned to the end user can be either , -/// a or an . +/// a , or an . /// /// [DebuggerDisplay("{RecordType}, {Id}")] @@ -49,8 +49,21 @@ internal SerializationRecord() // others can't derive from this type /// This method does NOT take into account member names or their types. /// /// The type to compare against. - /// if the serialized type name match provided type; otherwise, . - public bool TypeNameMatches(Type type) => Matches(type, TypeName); + /// if the serialized type name matches the provided type; otherwise, . + /// is . + public bool TypeNameMatches(Type type) + { +#if NET + ArgumentNullException.ThrowIfNull(type); +#else + if (type is null) + { + throw new ArgumentNullException(nameof(type)); + } +#endif + + return Matches(type, TypeName); + } private static bool Matches(Type type, TypeName typeName) { @@ -61,10 +74,38 @@ private static bool Matches(Type type, TypeName typeName) return false; } + // The TypeName.FullName property getter is recursive and backed by potentially hostile + // input. See comments in that property getter for more information, including what defenses + // are in place to prevent attacks. + // + // Note that the equality comparison below is worst-case O(n) since the adversary could ensure + // that only the last char differs. Even if the strings have equal contents, we should still + // expect the comparison to take O(n) time since RuntimeType.FullName and TypeName.FullName + // will never reference the same string instance with current runtime implementations. + // + // Since a call to Matches could take place within a loop, and since TypeName.FullName could + // be arbitrarily long (it's attacker-controlled and the NRBF protocol allows backtracking via + // the ClassWithId record, providing a form of compression), this presents opportunity + // for an algorithmic complexity attack, where a (2 * l)-length payload has an l-length type + // name and an array with l elements, resulting in O(l^2) total work factor. Protection against + // such attack is provided by the fact that the System.Type object is fully under the app's + // control and is assumed to be trusted and a reasonable length. This brings the cumulative loop + // work factor back down to O(l * RuntimeType.FullName), which is acceptable. + // + // The above statement assumes that "(string)m == (string)n" has worst-case complexity + // O(min(m.Length, n.Length)). This is not stated in string's public docs, but it is + // a guaranteed behavior for all built-in Ordinal string comparisons. + // At first, check the non-allocating properties for mismatch. if (type.IsArray != typeName.IsArray || type.IsConstructedGenericType != typeName.IsConstructedGenericType || type.IsNested != typeName.IsNested - || (type.IsArray && type.GetArrayRank() != typeName.GetArrayRank())) + || (type.IsArray && type.GetArrayRank() != typeName.GetArrayRank()) +#if NET + || type.IsSZArray != typeName.IsSZArray // int[] vs int[*] +#else + || (type.IsArray && type.Name != typeName.Name) +#endif + ) { return false; } @@ -107,15 +148,20 @@ private static bool Matches(Type type, TypeName typeName) } /// - /// Gets the primitive, string or null record value. + /// Gets the primitive, string, or null record value. /// For reference records, it returns the referenced record. /// For other records, it returns the records themselves. /// + /// + /// Overrides of this method should take care not to allow + /// the introduction of cycles, even in the face of adversarial + /// edges in the object graph. + /// internal virtual object? GetValue() => this; internal virtual void HandleNextRecord(SerializationRecord nextRecord, NextInfo info) - => Debug.Fail($"HandleNextRecord should not have been called for '{GetType().Name}'"); + => throw new InvalidOperationException(); internal virtual void HandleNextValue(object value, NextInfo info) - => Debug.Fail($"HandleNextValue should not have been called for '{GetType().Name}'"); + => throw new InvalidOperationException(); } diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/SerializationRecordId.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/SerializationRecordId.cs index 7f51525e6e1..a8318cb72d1 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/SerializationRecordId.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/SerializationRecordId.cs @@ -3,6 +3,7 @@ using System; using System.Collections.Generic; +using System.Diagnostics; using System.Formats.Nrbf.Utils; using System.IO; using System.Linq; @@ -15,6 +16,7 @@ namespace System.Formats.Nrbf; /// /// The ID of . /// +[DebuggerDisplay("{_id}")] public readonly struct SerializationRecordId : IEquatable { #pragma warning disable CS0649 // the default value is used on purpose @@ -29,6 +31,15 @@ internal static SerializationRecordId Decode(BinaryReader reader) { int id = reader.ReadInt32(); + // Many object ids are required to be positive. See: + // - https://learn.microsoft.com/openspecs/windows_protocols/ms-nrbf/8fac763f-e46d-43a1-b360-80eb83d2c5fb + // - https://learn.microsoft.com/openspecs/windows_protocols/ms-nrbf/eb503ca5-e1f6-4271-a7ee-c4ca38d07996 + // - https://learn.microsoft.com/openspecs/windows_protocols/ms-nrbf/7fcf30e1-4ad4-4410-8f1a-901a4a1ea832 (for library id) + // + // Exception: https://learn.microsoft.com/openspecs/windows_protocols/ms-nrbf/0a192be0-58a1-41d0-8a54-9c91db0ab7bf may be negative + // The problem is that input generated with FormatterTypeStyle.XsdString ends up generating negative Ids anyway. + // That information is not reflected in payload in anyway, so we just always allow for negative Ids. + if (id == 0) { ThrowHelper.ThrowInvalidValue(id); diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/SerializationRecordType.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/SerializationRecordType.cs index 57760b8a377..1fc1236a94b 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/SerializationRecordType.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/SerializationRecordType.cs @@ -4,8 +4,11 @@ namespace System.Formats.Nrbf; /// -/// Record type. +/// Specifies record types. /// +/// +/// SerializationRecordType enumeration is described in [MS-NRBF] 2.1.2.1. +/// public enum SerializationRecordType { /// @@ -22,16 +25,16 @@ public enum SerializationRecordType /// Not supported by design. SystemClassWithMembers, /// - /// A class information with source library, but without type info. + /// Class information with source library, but without type info. /// /// Not supported by design. ClassWithMembers, /// - /// A system class information with type info. + /// System class information with type info. /// SystemClassWithMembersAndTypes, /// - /// A class information with type info and the source library. + /// Class information with type info and the source library. /// ClassWithMembersAndTypes, /// @@ -67,7 +70,7 @@ public enum SerializationRecordType /// ObjectNullMultiple256, /// - /// Multiple . + /// Multiple values. /// ObjectNullMultiple, /// @@ -88,7 +91,7 @@ public enum SerializationRecordType /// Not supported by design. MethodCall = 21, /// - /// An information returned by a remote method. + /// Information returned by a remote method. /// /// Not supported by design. MethodReturn diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/SerializedStreamHeaderRecord.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/SerializedStreamHeaderRecord.cs index 4757958fcb7..b21ff8ca237 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/SerializedStreamHeaderRecord.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/SerializedStreamHeaderRecord.cs @@ -24,14 +24,8 @@ internal sealed class SerializedStreamHeaderRecord : SerializationRecord public override SerializationRecordType RecordType => SerializationRecordType.SerializedStreamHeader; - public override TypeName TypeName - { - get - { - Debug.Fail("TypeName should never be called on SerializedStreamHeaderRecord"); - return TypeName.Parse(nameof(SerializedStreamHeaderRecord).AsSpan()); - } - } + public override TypeName TypeName => TypeName.Parse(nameof(SerializedStreamHeaderRecord).AsSpan()); + public override SerializationRecordId Id => SerializationRecordId.NoId; internal SerializationRecordId RootId { get; } diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/SystemClassWithMembersAndTypesRecord.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/SystemClassWithMembersAndTypesRecord.cs index 93095bc32b0..ccecc2246e8 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/SystemClassWithMembersAndTypesRecord.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/SystemClassWithMembersAndTypesRecord.cs @@ -38,6 +38,11 @@ internal override (AllowedRecordTypes allowed, PrimitiveType primitiveType) GetN // to get a single primitive value! internal SerializationRecord TryToMapToUserFriendly() { + if (!TypeName.IsSimple) + { + return this; + } + if (MemberValues.Count == 1) { if (HasMember("m_value")) @@ -45,18 +50,18 @@ internal SerializationRecord TryToMapToUserFriendly() return MemberValues[0] switch { // there can be a value match, but no TypeName match - bool value when TypeName.FullName == typeof(bool).FullName => Create(value), - byte value when TypeName.FullName == typeof(byte).FullName => Create(value), - sbyte value when TypeName.FullName == typeof(sbyte).FullName => Create(value), - char value when TypeName.FullName == typeof(char).FullName => Create(value), - short value when TypeName.FullName == typeof(short).FullName => Create(value), - ushort value when TypeName.FullName == typeof(ushort).FullName => Create(value), - int value when TypeName.FullName == typeof(int).FullName => Create(value), - uint value when TypeName.FullName == typeof(uint).FullName => Create(value), - long value when TypeName.FullName == typeof(long).FullName => Create(value), - ulong value when TypeName.FullName == typeof(ulong).FullName => Create(value), - float value when TypeName.FullName == typeof(float).FullName => Create(value), - double value when TypeName.FullName == typeof(double).FullName => Create(value), + bool value when TypeNameMatches(typeof(bool)) => Create(value), + byte value when TypeNameMatches(typeof(byte)) => Create(value), + sbyte value when TypeNameMatches(typeof(sbyte)) => Create(value), + char value when TypeNameMatches(typeof(char)) => Create(value), + short value when TypeNameMatches(typeof(short)) => Create(value), + ushort value when TypeNameMatches(typeof(ushort)) => Create(value), + int value when TypeNameMatches(typeof(int)) => Create(value), + uint value when TypeNameMatches(typeof(uint)) => Create(value), + long value when TypeNameMatches(typeof(long)) => Create(value), + ulong value when TypeNameMatches(typeof(ulong)) => Create(value), + float value when TypeNameMatches(typeof(float)) => Create(value), + double value when TypeNameMatches(typeof(double)) => Create(value), _ => this }; } @@ -65,34 +70,35 @@ internal SerializationRecord TryToMapToUserFriendly() return MemberValues[0] switch { // there can be a value match, but no TypeName match - long value when TypeName.FullName == typeof(IntPtr).FullName => Create(new IntPtr(value)), - ulong value when TypeName.FullName == typeof(UIntPtr).FullName => Create(new UIntPtr(value)), + long value when TypeNameMatches(typeof(IntPtr)) => Create(new IntPtr(value)), + ulong value when TypeNameMatches(typeof(UIntPtr)) => Create(new UIntPtr(value)), _ => this }; } - else if (HasMember("_ticks") && MemberValues[0] is long ticks && TypeName.FullName == typeof(TimeSpan).FullName) + else if (HasMember("_ticks") && GetRawValue("_ticks") is long ticks && TypeNameMatches(typeof(TimeSpan))) { return Create(new TimeSpan(ticks)); } } else if (MemberValues.Count == 2 && HasMember("ticks") && HasMember("dateData") - && MemberValues[0] is long value && MemberValues[1] is ulong + && GetRawValue("ticks") is long && GetRawValue("dateData") is ulong dateData && TypeNameMatches(typeof(DateTime))) { - return Create(Utils.BinaryReaderExtensions.CreateDateTimeFromData(value)); + return Create(Utils.BinaryReaderExtensions.CreateDateTimeFromData(dateData)); } - else if(MemberValues.Count == 4 + else if (MemberValues.Count == 4 && HasMember("lo") && HasMember("mid") && HasMember("hi") && HasMember("flags") - && MemberValues[0] is int && MemberValues[1] is int && MemberValues[2] is int && MemberValues[3] is int + && GetRawValue("lo") is int lo && GetRawValue("mid") is int mid + && GetRawValue("hi") is int hi && GetRawValue("flags") is int flags && TypeNameMatches(typeof(decimal))) { int[] bits = [ - GetInt32("lo"), - GetInt32("mid"), - GetInt32("hi"), - GetInt32("flags") + lo, + mid, + hi, + flags ]; return Create(new decimal(bits)); diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/Utils/BinaryReaderExtensions.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/Utils/BinaryReaderExtensions.cs index 73759a7a22d..d5baa09dbd8 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/Utils/BinaryReaderExtensions.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/Utils/BinaryReaderExtensions.cs @@ -1,18 +1,41 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System.Diagnostics; using System.Globalization; using System.IO; +using System.Reflection; using System.Reflection.Metadata; using System.Runtime.CompilerServices; using System.Runtime.Serialization; +using System.Threading; namespace System.Formats.Nrbf.Utils; internal static class BinaryReaderExtensions { + private static object? s_baseAmbiguousDstDateTime; + + internal static SerializationRecordType ReadSerializationRecordType(this BinaryReader reader, AllowedRecordTypes allowed) + { + byte nextByte = reader.ReadByte(); + if (nextByte > (byte)SerializationRecordType.MethodReturn // MethodReturn is the last defined value. + || (nextByte > (byte)SerializationRecordType.ArraySingleString && nextByte < (byte)SerializationRecordType.MethodCall) // not part of the spec + || ((uint)allowed & (1u << nextByte)) == 0) // valid, but not allowed + { + ThrowHelper.ThrowForUnexpectedRecordType(nextByte); + } + + return (SerializationRecordType)nextByte; + } + internal static BinaryArrayType ReadArrayType(this BinaryReader reader) { + // To simplify the behavior and security review of the BinaryArrayRecord type, we + // do not support reading non-zero-offset arrays. If this should change in the + // future, the BinaryArrayRecord.Decode method and supporting infrastructure + // will need re-review. + byte arrayType = reader.ReadByte(); // Rectangular is the last defined value. if (arrayType > (byte)BinaryArrayType.Rectangular) @@ -43,8 +66,8 @@ internal static BinaryType ReadBinaryType(this BinaryReader reader) internal static PrimitiveType ReadPrimitiveType(this BinaryReader reader) { byte primitiveType = reader.ReadByte(); - // String is the last defined value, 4 is not used at all. - if (primitiveType is 4 or > (byte)PrimitiveType.String) + // Boolean is the first valid value (1), UInt64 (16) is the last one. 4 is not used at all. + if (primitiveType is 4 or < (byte)PrimitiveType.Boolean or > (byte)PrimitiveType.UInt64) { ThrowHelper.ThrowInvalidValue(primitiveType); } @@ -60,7 +83,7 @@ internal static object ReadPrimitiveValue(this BinaryReader reader, PrimitiveTyp PrimitiveType.Boolean => reader.ReadBoolean(), PrimitiveType.Byte => reader.ReadByte(), PrimitiveType.SByte => reader.ReadSByte(), - PrimitiveType.Char => reader.ReadChar(), + PrimitiveType.Char => reader.ParseChar(), PrimitiveType.Int16 => reader.ReadInt16(), PrimitiveType.UInt16 => reader.ReadUInt16(), PrimitiveType.Int32 => reader.ReadInt32(), @@ -69,41 +92,130 @@ internal static object ReadPrimitiveValue(this BinaryReader reader, PrimitiveTyp PrimitiveType.UInt64 => reader.ReadUInt64(), PrimitiveType.Single => reader.ReadSingle(), PrimitiveType.Double => reader.ReadDouble(), - PrimitiveType.Decimal => decimal.Parse(reader.ReadString(), CultureInfo.InvariantCulture), - PrimitiveType.DateTime => CreateDateTimeFromData(reader.ReadInt64()), - _ => new TimeSpan(reader.ReadInt64()), + PrimitiveType.Decimal => reader.ParseDecimal(), + PrimitiveType.DateTime => CreateDateTimeFromData(reader.ReadUInt64()), + PrimitiveType.TimeSpan => new TimeSpan(reader.ReadInt64()), + _ => throw new InvalidOperationException(), }; - // TODO: fix https://github.com/dotnet/runtime/issues/102826 + // BinaryFormatter serializes decimals as strings and we can't BinaryReader.ReadDecimal. + internal static decimal ParseDecimal(this BinaryReader reader) + { + // The spec (MS NRBF 2.1.1.6, https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-nrbf/10b218f5-9b2b-4947-b4b7-07725a2c8127) + // says that the length of LengthPrefixedString must be of optimal size (using as few bytes as possible). + // BinaryReader.ReadString does not enforce that and we are OK with that, + // as it takes care of handling multiple edge cases and we don't want to re-implement it. + + string text = reader.ReadString(); + if (!decimal.TryParse(text, NumberStyles.Number, CultureInfo.InvariantCulture, out decimal result)) + { + ThrowHelper.ThrowInvalidFormat(); + } + + return result; + } + + internal static char ParseChar(this BinaryReader reader) + { + try + { + return reader.ReadChar(); + } + catch (ArgumentException) // A surrogate character was read. + { + throw new SerializationException(SR.Serialization_SurrogateCharacter); + } + } + + internal static char[] ParseChars(this BinaryReader reader, int count) + { + char[]? result; + try + { + result = reader.ReadChars(count); + } + catch (ArgumentException) // A surrogate character was read. + { + throw new SerializationException(SR.Serialization_SurrogateCharacter); + } + + if (result.Length != count) + { + // We might hit EOF before fully reading the requested + // number of chars. This means that ReadChars(count) could return a char[] with + // *fewer* than 'count' elements. + ThrowHelper.ThrowEndOfStreamException(); + } + + return result; + } + /// /// Creates a object from raw data with validation. /// - /// was invalid. - internal static DateTime CreateDateTimeFromData(long data) + /// was invalid. + internal static DateTime CreateDateTimeFromData(ulong dateData) { - // Copied from System.Runtime.Serialization.Formatters.Binary.BinaryParser - - // Use DateTime's public constructor to validate the input, but we - // can't return that result as it strips off the kind. To address - // that, store the value directly into a DateTime via an unsafe cast. - // See BinaryFormatterWriter.WriteDateTime for details. + ulong ticks = dateData & 0x3FFFFFFF_FFFFFFFFUL; + DateTimeKind kind = (DateTimeKind)(dateData >> 62); try { - const long TicksMask = 0x3FFFFFFFFFFFFFFF; - _ = new DateTime(data & TicksMask); + return ((uint)kind <= (uint)DateTimeKind.Local) ? new DateTime((long)ticks, kind) : CreateFromAmbiguousDst(ticks); } catch (ArgumentException ex) { - // Bad data throw new SerializationException(ex.Message, ex); } - return Unsafe.As(ref data); + [MethodImpl(MethodImplOptions.NoInlining)] + static DateTime CreateFromAmbiguousDst(ulong ticks) + { + // There's no public API to create a DateTime from an ambiguous DST, and we + // can't use private reflection to access undocumented .NET Framework APIs. + // However, the ISerializable pattern *is* a documented protocol, so we can + // use DateTime's serialization ctor to create a zero-tick "ambiguous" instance, + // then keep reusing it as the base to which we can add our tick offsets. + + if (s_baseAmbiguousDstDateTime is not DateTime baseDateTime) + { +#pragma warning disable SYSLIB0050 // Type or member is obsolete + SerializationInfo si = new(typeof(DateTime), new FormatterConverter()); + // We don't know the value of "ticks", so we don't specify it. + // If the code somehow runs on a very old runtime that does not know the concept of "dateData" + // (it should not be possible as the library targets .NET Standard 2.0) + // the ctor is going to throw rather than silently return an invalid value. + si.AddValue("dateData", 0xC0000000_00000000UL); // new value (serialized as ulong) + +#if NET + baseDateTime = CallPrivateSerializationConstructor(si, new StreamingContext(StreamingContextStates.All)); +#else + ConstructorInfo ci = typeof(DateTime).GetConstructor( + BindingFlags.Instance | BindingFlags.NonPublic, + binder: null, + new Type[] { typeof(SerializationInfo), typeof(StreamingContext) }, + modifiers: null); + + baseDateTime = (DateTime)ci.Invoke(new object[] { si, new StreamingContext(StreamingContextStates.All) }); +#endif + +#pragma warning restore SYSLIB0050 // Type or member is obsolete + Volatile.Write(ref s_baseAmbiguousDstDateTime, baseDateTime); // it's ok if two threads race here + } + + return baseDateTime.AddTicks((long)ticks); + } + +#if NET + [UnsafeAccessor(UnsafeAccessorKind.Constructor)] + extern static DateTime CallPrivateSerializationConstructor(SerializationInfo si, StreamingContext ct); +#endif } internal static bool? IsDataAvailable(this BinaryReader reader, long requiredBytes) { + Debug.Assert(requiredBytes >= 0); + if (!reader.BaseStream.CanSeek) { return null; diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/Utils/ThrowHelper.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/Utils/ThrowHelper.cs index de543f2e098..ac8c861e5d1 100644 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/Utils/ThrowHelper.cs +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/Utils/ThrowHelper.cs @@ -6,23 +6,34 @@ namespace System.Formats.Nrbf.Utils; +// The exception messages do not contain member/type/assembly names on purpose, +// as it's most likely corrupted/tampered/malicious data. internal static class ThrowHelper { - internal static void ThrowInvalidValue(object value) + internal static void ThrowDuplicateMemberName() + => throw new SerializationException(SR.Serialization_DuplicateMemberName); + + internal static void ThrowInvalidValue(int value) => throw new SerializationException(SR.Format(SR.Serialization_InvalidValue, value)); internal static void ThrowInvalidReference() => throw new SerializationException(SR.Serialization_InvalidReference); + internal static void ThrowInvalidTypeName() + => throw new SerializationException(SR.Serialization_InvalidTypeName); + internal static void ThrowUnexpectedNullRecordCount() => throw new SerializationException(SR.Serialization_UnexpectedNullRecordCount); - internal static void ThrowMaxArrayLength(long limit, long actual) - => throw new SerializationException(SR.Format(SR.Serialization_MaxArrayLength, actual, limit)); - internal static void ThrowArrayContainedNulls() => throw new SerializationException(SR.Serialization_ArrayContainedNulls); + internal static void ThrowInvalidAssemblyName() + => throw new SerializationException(SR.Serialization_InvalidAssemblyName); + + internal static void ThrowInvalidFormat() + => throw new SerializationException(SR.Serialization_InvalidFormat); + internal static void ThrowEndOfStreamException() => throw new EndOfStreamException(); diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/Utils/TypeNameExtensions.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/Utils/TypeNameExtensions.cs deleted file mode 100644 index 017f4597bfc..00000000000 --- a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/Utils/TypeNameExtensions.cs +++ /dev/null @@ -1,112 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Buffers; -using System.Diagnostics; -using System.Reflection.Metadata; -using System.Runtime.CompilerServices; -using System.Runtime.Serialization; -using System.Text; - -namespace System.Formats.Nrbf.Utils; - -internal static class TypeNameExtensions -{ - internal const string CoreLibAssemblyName = "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"; - - internal static TypeName ParseNonSystemClassRecordTypeName(this string rawName, BinaryLibraryRecord libraryRecord, PayloadOptions payloadOptions) - { - // Combining type and library name has two goals: - // 1. Handle truncated generic type names that may be present in resources. - // 2. Improve perf by parsing only once. - ArraySegment assemblyQualifiedName = GetAssemblyQualifiedName(rawName, libraryRecord.LibraryName); - TypeName.TryParse(assemblyQualifiedName.AsSpan(), out TypeName? typeName, payloadOptions.TypeNameParseOptions); - ArrayPool.Shared.Return(assemblyQualifiedName.Array!); - - if (typeName is null || (typeName.AssemblyName is null && !payloadOptions.UndoTruncatedTypeNames)) - { - throw new SerializationException(SR.Format(SR.Serialization_InvalidTypeOrAssemblyName, rawName, libraryRecord.LibraryName)); - } - - if (typeName.AssemblyName is null && payloadOptions.UndoTruncatedTypeNames) - { - // Sample invalid input that could lead us here: - // TypeName: System.Collections.Generic.List`1[[System.String - // LibraryName: 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]] - // Since the flag is ON, we know it's mangling and we provide missing information. - typeName = typeName.WithCoreLibAssemblyName(); - } - - return typeName; - } - - internal static TypeName ParseSystemRecordTypeName(this string rawName, PayloadOptions payloadOptions) - { - ArraySegment assemblyQualifiedName = GetAssemblyQualifiedName(rawName, - CoreLibAssemblyName); // We know it's a System Record, so we set the LibraryName to CoreLib - - TypeName.TryParse(assemblyQualifiedName.AsSpan(), out TypeName? typeName, payloadOptions.TypeNameParseOptions); - ArrayPool.Shared.Return(assemblyQualifiedName.Array!); - - return typeName ?? throw new SerializationException(SR.Format(SR.Serialization_InvalidTypeName, rawName)); - } - - internal static TypeName WithCoreLibAssemblyName(this TypeName systemType) - => systemType.WithAssemblyName(CoreLibAssemblyName); - - internal static TypeName WithAssemblyName(this TypeName typeName, string assemblyName) - { - // For ClassWithMembersAndTypesRecord, the TypeName and LibraryName and provided separately, - // and the LibraryName may not be known when parsing TypeName. - // For SystemClassWithMembersAndTypesRecord, the LibraryName is not provided, it's always mscorlib. - // Ideally, we would just create TypeName with new AssemblyNameInfo. - // This will be possible once https://github.com/dotnet/runtime/issues/102263 is done. - - ArraySegment assemblyQualifiedName = GetAssemblyQualifiedName(typeName.FullName, assemblyName); - TypeName result = TypeName.Parse(assemblyQualifiedName.AsSpan()); - ArrayPool.Shared.Return(assemblyQualifiedName.Array!); - - return result; - } - - internal static TypeName BuildCoreLibArrayTypeName(this Type type, int arrayRank) - { - ArraySegment assemblyQualifiedName = GetAssemblyQualifiedName(type.FullName!, CoreLibAssemblyName, arrayRank); - TypeName result = TypeName.Parse(assemblyQualifiedName.AsSpan()); - ArrayPool.Shared.Return(assemblyQualifiedName.Array!); - - return result; - } - - internal static TypeName BuildArrayTypeName(this TypeName typeName, int arrayRank) - { - ArraySegment assemblyQualifiedName = GetAssemblyQualifiedName(typeName.FullName, typeName.AssemblyName!.FullName, arrayRank); - TypeName result = TypeName.Parse(assemblyQualifiedName.AsSpan()); - ArrayPool.Shared.Return(assemblyQualifiedName.Array!); - - return result; - } - - private static ArraySegment GetAssemblyQualifiedName(string typeName, string libraryName, int arrayRank = 0) - { - int arrayLength = arrayRank != 0 ? 2 + arrayRank - 1 : 0; - int length = typeName.Length + arrayLength + 1 + libraryName.Length; - - char[] rented = ArrayPool.Shared.Rent(length); - - typeName.AsSpan().CopyTo(rented); - if (arrayRank != 0) - { - rented[typeName.Length] = '['; - for (int i = 1; i < arrayRank; i++) - { - rented[typeName.Length + i] = ','; - } - rented[typeName.Length + arrayLength - 1] = ']'; - } - rented[typeName.Length + arrayLength] = ','; - libraryName.AsSpan().CopyTo(rented.AsSpan(typeName.Length + arrayLength + 1)); - - return new ArraySegment(rented, 0, length); - } -} diff --git a/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/Utils/TypeNameHelpers.cs b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/Utils/TypeNameHelpers.cs new file mode 100644 index 00000000000..a2fba1b52ec --- /dev/null +++ b/src/libraries/System.Formats.Nrbf/src/System/Formats/Nrbf/Utils/TypeNameHelpers.cs @@ -0,0 +1,217 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Buffers; +using System.Diagnostics; +using System.Reflection.Metadata; +using System.Runtime.CompilerServices; +using System.Runtime.Serialization; +using System.Text; + +namespace System.Formats.Nrbf.Utils; + +internal static class TypeNameHelpers +{ + // PrimitiveType does not define Object, IntPtr or UIntPtr. + internal const PrimitiveType StringPrimitiveType = (PrimitiveType)18; + internal const PrimitiveType ObjectPrimitiveType = (PrimitiveType)19; + internal const PrimitiveType IntPtrPrimitiveType = (PrimitiveType)20; + internal const PrimitiveType UIntPtrPrimitiveType = (PrimitiveType)21; + private static readonly TypeName?[] s_primitiveTypeNames = new TypeName?[(int)UIntPtrPrimitiveType + 1]; + private static readonly TypeName?[] s_primitiveSZArrayTypeNames = new TypeName?[(int)UIntPtrPrimitiveType + 1]; + private static AssemblyNameInfo? s_coreLibAssemblyName; + + internal static TypeName GetPrimitiveTypeName(PrimitiveType primitiveType) + { + TypeName? typeName = s_primitiveTypeNames[(int)primitiveType]; + if (typeName is null) + { + string fullName = primitiveType switch + { + PrimitiveType.Boolean => "System.Boolean", + PrimitiveType.Byte => "System.Byte", + PrimitiveType.SByte => "System.SByte", + PrimitiveType.Char => "System.Char", + PrimitiveType.Int16 => "System.Int16", + PrimitiveType.UInt16 => "System.UInt16", + PrimitiveType.Int32 => "System.Int32", + PrimitiveType.UInt32 => "System.UInt32", + PrimitiveType.Int64 => "System.Int64", + PrimitiveType.UInt64 => "System.UInt64", + PrimitiveType.Single => "System.Single", + PrimitiveType.Double => "System.Double", + PrimitiveType.Decimal => "System.Decimal", + PrimitiveType.TimeSpan => "System.TimeSpan", + PrimitiveType.DateTime => "System.DateTime", + StringPrimitiveType => "System.String", + ObjectPrimitiveType => "System.Object", + IntPtrPrimitiveType => "System.IntPtr", + UIntPtrPrimitiveType => "System.UIntPtr", + _ => throw new InvalidOperationException() + }; + + s_primitiveTypeNames[(int)primitiveType] = typeName = TypeName.Parse(fullName.AsSpan()).WithCoreLibAssemblyName(); + } + return typeName; + } + + internal static TypeName GetPrimitiveSZArrayTypeName(PrimitiveType primitiveType) + { + TypeName? typeName = s_primitiveSZArrayTypeNames[(int)primitiveType]; + if (typeName is null) + { + s_primitiveSZArrayTypeNames[(int)primitiveType] = typeName = GetPrimitiveTypeName(primitiveType).MakeSZArrayTypeName(); + } + return typeName; + } + + internal static PrimitiveType GetPrimitiveType() + { + if (typeof(T) == typeof(bool)) + return PrimitiveType.Boolean; + else if (typeof(T) == typeof(byte)) + return PrimitiveType.Byte; + else if (typeof(T) == typeof(sbyte)) + return PrimitiveType.SByte; + else if (typeof(T) == typeof(char)) + return PrimitiveType.Char; + else if (typeof(T) == typeof(short)) + return PrimitiveType.Int16; + else if (typeof(T) == typeof(ushort)) + return PrimitiveType.UInt16; + else if (typeof(T) == typeof(int)) + return PrimitiveType.Int32; + else if (typeof(T) == typeof(uint)) + return PrimitiveType.UInt32; + else if (typeof(T) == typeof(long)) + return PrimitiveType.Int64; + else if (typeof(T) == typeof(ulong)) + return PrimitiveType.UInt64; + else if (typeof(T) == typeof(float)) + return PrimitiveType.Single; + else if (typeof(T) == typeof(double)) + return PrimitiveType.Double; + else if (typeof(T) == typeof(decimal)) + return PrimitiveType.Decimal; + else if (typeof(T) == typeof(DateTime)) + return PrimitiveType.DateTime; + else if (typeof(T) == typeof(TimeSpan)) + return PrimitiveType.TimeSpan; + else if (typeof(T) == typeof(string)) + return StringPrimitiveType; + else if (typeof(T) == typeof(IntPtr)) + return IntPtrPrimitiveType; + else if (typeof(T) == typeof(UIntPtr)) + return UIntPtrPrimitiveType; + else + throw new InvalidOperationException(); + } + + internal static TypeName ParseNonSystemClassRecordTypeName(this string rawName, BinaryLibraryRecord libraryRecord, PayloadOptions payloadOptions) + { + if (libraryRecord.LibraryName is not null) + { + return ParseWithoutAssemblyName(rawName, payloadOptions).With(libraryRecord.LibraryName); + } + + Debug.Assert(payloadOptions.UndoTruncatedTypeNames); + Debug.Assert(libraryRecord.RawLibraryName is not null); + + // This is potentially a DoS vector, as somebody could submit: + // [1] BinaryLibraryRecord = + // [2] ClassRecord (lib = [1]) + // [3] ClassRecord (lib = [1]) + // ... + // [n] ClassRecord (lib = [1]) + // + // Which means somebody submits a payload of length O(long + n) and tricks us into + // performing O(long * n) work. For this reason, we have marked the UndoTruncatedTypeNames + // property as "keep this disabled unless you trust the input." + + // Combining type and library allows us for handling truncated generic type names that may be present in resources. + ArraySegment assemblyQualifiedName = RentAssemblyQualifiedName(rawName, libraryRecord.RawLibraryName); + TypeName.TryParse(assemblyQualifiedName.AsSpan(), out TypeName? typeName, payloadOptions.TypeNameParseOptions); + ArrayPool.Shared.Return(assemblyQualifiedName.Array!); + + if (typeName is null) + { + throw new SerializationException(SR.Serialization_InvalidTypeOrAssemblyName); + } + + if (typeName.AssemblyName is null) + { + // Sample invalid input that could lead us here: + // TypeName: System.Collections.Generic.List`1[[System.String + // LibraryName: 'mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]] + // Since the flag is ON, we know it's mangling and we provide missing information. + typeName = typeName.WithCoreLibAssemblyName(); + } + + return typeName; + } + + internal static TypeName ParseSystemRecordTypeName(this string rawName, PayloadOptions payloadOptions) + => ParseWithoutAssemblyName(rawName, payloadOptions) + .WithCoreLibAssemblyName(); // We know it's a System Record, so we set the LibraryName to CoreLib + + internal static TypeName WithCoreLibAssemblyName(this TypeName systemType) + => systemType.With(s_coreLibAssemblyName ??= AssemblyNameInfo.Parse("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089".AsSpan())); + + private static TypeName With(this TypeName typeName, AssemblyNameInfo assemblyName) + { + // This is a recursive method over potentially hostile TypeName arguments. + // We assume the complexity of the TypeName arg was appropriately bounded. + // See comment in TypeName.FullName property getter for more info. + + if (!typeName.IsSimple) + { + if (typeName.IsArray) + { + TypeName newElementType = typeName.GetElementType().With(assemblyName); + + return typeName.IsSZArray + ? newElementType.MakeSZArrayTypeName() + : newElementType.MakeArrayTypeName(typeName.GetArrayRank()); + } + else if (typeName.IsConstructedGenericType) + { + TypeName newGenericTypeDefinition = typeName.GetGenericTypeDefinition().With(assemblyName); + + // We don't change the assembly name of generic arguments on purpose. + return newGenericTypeDefinition.MakeGenericTypeName(typeName.GetGenericArguments()); + } + else + { + // BinaryFormatter can not serialize pointers or references. + ThrowHelper.ThrowInvalidTypeName(); + } + } + + return typeName.WithAssemblyName(assemblyName); + } + + private static TypeName ParseWithoutAssemblyName(string rawName, PayloadOptions payloadOptions) + { + if (!TypeName.TryParse(rawName.AsSpan(), out TypeName? typeName, payloadOptions.TypeNameParseOptions) + || typeName.AssemblyName is not null) // the type and library names should be provided separately + { + throw new SerializationException(SR.Format(SR.Serialization_InvalidTypeName, rawName)); + } + + return typeName; + } + + // Complexity is O(typeName.Length + libraryName.Length) + private static ArraySegment RentAssemblyQualifiedName(string typeName, string libraryName) + { + int length = typeName.Length + 1 + libraryName.Length; + + char[] rented = ArrayPool.Shared.Rent(length); + + typeName.AsSpan().CopyTo(rented); + rented[typeName.Length] = ','; + libraryName.AsSpan().CopyTo(rented.AsSpan(typeName.Length + 1)); + + return new ArraySegment(rented, 0, length); + } +} diff --git a/src/libraries/System.Formats.Nrbf/tests/ArraySinglePrimitiveRecordTests.cs b/src/libraries/System.Formats.Nrbf/tests/ArraySinglePrimitiveRecordTests.cs index d4a4b5b3c69..49d523088a8 100644 --- a/src/libraries/System.Formats.Nrbf/tests/ArraySinglePrimitiveRecordTests.cs +++ b/src/libraries/System.Formats.Nrbf/tests/ArraySinglePrimitiveRecordTests.cs @@ -3,6 +3,8 @@ using System.Collections.Generic; using System.IO; +using System.Runtime.Serialization; +using System.Text; using Xunit; namespace System.Formats.Nrbf.Tests; @@ -24,6 +26,51 @@ public static IEnumerable GetCanReadArrayOfAnySizeArgs() } } + [Fact] + public void DontCastBytesToBooleans() + { + using MemoryStream stream = new(); + BinaryWriter writer = new(stream, Encoding.UTF8); + + WriteSerializedStreamHeader(writer); + writer.Write((byte)SerializationRecordType.ArraySinglePrimitive); + writer.Write(1); // object ID + writer.Write(2); // length + writer.Write((byte)PrimitiveType.Boolean); // element type + writer.Write((byte)0x01); + writer.Write((byte)0x02); + writer.Write((byte)SerializationRecordType.MessageEnd); + stream.Position = 0; + + SZArrayRecord serializationRecord = (SZArrayRecord)NrbfDecoder.Decode(stream); + + bool[] bools = serializationRecord.GetArray(); + bool a = bools[0]; + Assert.True(a); + bool b = bools[1]; + Assert.True(b); + bool c = a && b; + Assert.True(c); + } + + [Fact] + public void DontCastBytesToDateTimes() + { + using MemoryStream stream = new(); + BinaryWriter writer = new(stream, Encoding.UTF8); + + WriteSerializedStreamHeader(writer); + writer.Write((byte)SerializationRecordType.ArraySinglePrimitive); + writer.Write(1); // object ID + writer.Write(1); // length + writer.Write((byte)PrimitiveType.DateTime); // element type + writer.Write(ulong.MaxValue); // un-representable DateTime + writer.Write((byte)SerializationRecordType.MessageEnd); + stream.Position = 0; + + Assert.Throws(() => NrbfDecoder.Decode(stream)); + } + [Theory] [MemberData(nameof(GetCanReadArrayOfAnySizeArgs))] public void CanReadArrayOfAnySize_Bool(int size, bool canSeek) => Test(size, canSeek); @@ -94,6 +141,7 @@ private void Test(int size, bool canSeek) SZArrayRecord arrayRecord = (SZArrayRecord)NrbfDecoder.Decode(stream); Assert.Equal(size, arrayRecord.Length); + Assert.Equal(size, arrayRecord.FlattenedLength); T?[] output = arrayRecord.GetArray(); Assert.Equal(input, output); Assert.Same(output, arrayRecord.GetArray()); diff --git a/src/libraries/System.Formats.Nrbf/tests/AttackTests.cs b/src/libraries/System.Formats.Nrbf/tests/AttackTests.cs index d9f7ac05811..fe780d94698 100644 --- a/src/libraries/System.Formats.Nrbf/tests/AttackTests.cs +++ b/src/libraries/System.Formats.Nrbf/tests/AttackTests.cs @@ -154,7 +154,7 @@ public void ArraysOfBytesAreNotBeingPreAllocated() writer.Write((byte)SerializationRecordType.ArraySinglePrimitive); writer.Write(1); // object ID writer.Write(Array.MaxLength); // length - writer.Write((byte)2); // PrimitiveType.Byte + writer.Write((byte)PrimitiveType.Byte); writer.Write((byte)SerializationRecordType.MessageEnd); stream.Position = 0; diff --git a/src/libraries/System.Formats.Nrbf/tests/EdgeCaseTests.cs b/src/libraries/System.Formats.Nrbf/tests/EdgeCaseTests.cs index b443eba5ed4..f091d47ded8 100644 --- a/src/libraries/System.Formats.Nrbf/tests/EdgeCaseTests.cs +++ b/src/libraries/System.Formats.Nrbf/tests/EdgeCaseTests.cs @@ -1,4 +1,5 @@ -using System.IO; +using System.Collections.Generic; +using System.IO; using System.Runtime.Serialization.Formatters; using System.Runtime.Serialization.Formatters.Binary; using Microsoft.DotNet.XUnitExtensions; @@ -103,4 +104,44 @@ public void FormatterTypeStyleOtherThanTypesAlwaysAreNotSupportedByDesign(Format Assert.Throws(() => NrbfDecoder.Decode(ms)); } + + public static IEnumerable CanReadAllKindsOfDateTimes_Arguments + { + get + { + yield return new object[] { new DateTime(1990, 11, 24, 0, 0, 0, DateTimeKind.Local) }; + yield return new object[] { new DateTime(1990, 11, 25, 0, 0, 0, DateTimeKind.Utc) }; + yield return new object[] { new DateTime(1990, 11, 26, 0, 0, 0, DateTimeKind.Unspecified) }; + } + } + + [Theory] + [MemberData(nameof(CanReadAllKindsOfDateTimes_Arguments))] + public void CanReadAllKindsOfDateTimes_DateTimeIsTheRootRecord(DateTime input) + { + using MemoryStream stream = Serialize(input); + + PrimitiveTypeRecord dateTimeRecord = (PrimitiveTypeRecord)NrbfDecoder.Decode(stream); + + Assert.Equal(input.Ticks, dateTimeRecord.Value.Ticks); + Assert.Equal(input.Kind, dateTimeRecord.Value.Kind); + } + + [Serializable] + public class ClassWithDateTime + { + public DateTime Value; + } + + [Theory] + [MemberData(nameof(CanReadAllKindsOfDateTimes_Arguments))] + public void CanReadAllKindsOfDateTimes_DateTimeIsMemberOfTheRootRecord(DateTime input) + { + using MemoryStream stream = Serialize(new ClassWithDateTime() { Value = input }); + + ClassRecord classRecord = NrbfDecoder.DecodeClassRecord(stream); + + Assert.Equal(input.Ticks, classRecord.GetDateTime(nameof(ClassWithDateTime.Value)).Ticks); + Assert.Equal(input.Kind, classRecord.GetDateTime(nameof(ClassWithDateTime.Value)).Kind); + } } diff --git a/src/libraries/System.Formats.Nrbf/tests/InvalidInputTests.cs b/src/libraries/System.Formats.Nrbf/tests/InvalidInputTests.cs index bc134350eb7..6acb44d0369 100644 --- a/src/libraries/System.Formats.Nrbf/tests/InvalidInputTests.cs +++ b/src/libraries/System.Formats.Nrbf/tests/InvalidInputTests.cs @@ -426,7 +426,10 @@ public static IEnumerable ThrowsForInvalidPrimitiveType_Arguments() { foreach (byte binaryType in new byte[] { (byte)0 /* BinaryType.Primitive */, (byte)7 /* BinaryType.PrimitiveArray */ }) { + yield return new object[] { recordType, binaryType, (byte)0 }; // value not used by the spec yield return new object[] { recordType, binaryType, (byte)4 }; // value not used by the spec + yield return new object[] { recordType, binaryType, (byte)17 }; // used by the spec, but illegal in given context + yield return new object[] { recordType, binaryType, (byte)18 }; // used by the spec, but illegal in given context yield return new object[] { recordType, binaryType, (byte)19 }; } } @@ -478,4 +481,125 @@ public void ThrowsOnInvalidArrayType() stream.Position = 0; Assert.Throws(() => NrbfDecoder.Decode(stream)); } + + [Theory] + [InlineData(18, typeof(NotSupportedException))] // not part of the spec, but still less than max allowed value (22) + [InlineData(19, typeof(NotSupportedException))] // same as above + [InlineData(20, typeof(NotSupportedException))] // same as above + [InlineData(23, typeof(SerializationException))] // not part of the spec and more than max allowed value (22) + [InlineData(64, typeof(SerializationException))] // same as above but also matches AllowedRecordTypes.SerializedStreamHeader + public void InvalidSerializationRecordType(byte recordType, Type expectedException) + { + using MemoryStream stream = new(); + BinaryWriter writer = new(stream, Encoding.UTF8); + + WriteSerializedStreamHeader(writer); + writer.Write(recordType); // SerializationRecordType + writer.Write((byte)SerializationRecordType.MessageEnd); + + stream.Position = 0; + + Assert.Throws(expectedException, () => NrbfDecoder.Decode(stream)); + } + + [Fact] + public void MissingRootRecord() + { + const int RootRecordId = 1; + using MemoryStream stream = new(); + BinaryWriter writer = new(stream, Encoding.UTF8); + + WriteSerializedStreamHeader(writer, rootId: RootRecordId); + writer.Write((byte)SerializationRecordType.BinaryObjectString); + writer.Write(RootRecordId + 1); // a different ID + writer.Write("theString"); + writer.Write((byte)SerializationRecordType.MessageEnd); + + stream.Position = 0; + + Assert.Throws(() => NrbfDecoder.Decode(stream)); + } + + [Fact] + public void Invalid7BitEncodedStringLength() + { + // The highest bit of the last byte is set (so it's invalid). + byte[] invalidLength = [byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue]; + + using MemoryStream stream = new(); + BinaryWriter writer = new(stream, Encoding.UTF8); + + WriteSerializedStreamHeader(writer); + writer.Write((byte)SerializationRecordType.BinaryObjectString); + writer.Write(1); // root record Id + writer.Write(invalidLength); // the length prefix + writer.Write(Encoding.UTF8.GetBytes("theString")); + writer.Write((byte)SerializationRecordType.MessageEnd); + + stream.Position = 0; + + Assert.Throws(() => NrbfDecoder.Decode(stream)); + } + + [Theory] + [InlineData("79228162514264337593543950336")] // invalid format (decimal.MaxValue + 1) + [InlineData("1111111111111111111111111111111111111111111111111")] // overflow + public void InvalidDecimal(string textRepresentation) + { + using MemoryStream stream = new(); + BinaryWriter writer = new(stream, Encoding.UTF8); + + WriteSerializedStreamHeader(writer); + writer.Write((byte)SerializationRecordType.SystemClassWithMembersAndTypes); + writer.Write(1); // root record Id + writer.Write("ClassWithDecimalField"); // type name + writer.Write(1); // member count + writer.Write("memberName"); + writer.Write((byte)BinaryType.Primitive); + writer.Write((byte)PrimitiveType.Decimal); + writer.Write(textRepresentation); + writer.Write((byte)SerializationRecordType.MessageEnd); + + stream.Position = 0; + + Assert.Throws(() => NrbfDecoder.Decode(stream)); + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public void SurrogateCharacters(bool array) + { + using MemoryStream stream = new(); + BinaryWriter writer = new(stream, Encoding.UTF8); + + WriteSerializedStreamHeader(writer); + writer.Write((byte)SerializationRecordType.SystemClassWithMembersAndTypes); + writer.Write(1); // root record Id + writer.Write("ClassWithCharField"); // type name + writer.Write(1); // member count + writer.Write("memberName"); + + if (array) + { + writer.Write((byte)BinaryType.PrimitiveArray); + writer.Write((byte)PrimitiveType.Char); + writer.Write((byte)SerializationRecordType.ArraySinglePrimitive); + writer.Write(2); // array record Id + writer.Write(1); // array length + writer.Write((byte)PrimitiveType.Char); + } + else + { + writer.Write((byte)BinaryType.Primitive); + writer.Write((byte)PrimitiveType.Char); + } + + writer.Write((byte)0xC0); // a surrogate character + writer.Write((byte)SerializationRecordType.MessageEnd); + + stream.Position = 0; + + Assert.Throws(() => NrbfDecoder.Decode(stream)); + } } diff --git a/src/libraries/System.Formats.Nrbf/tests/JaggedArraysTests.cs b/src/libraries/System.Formats.Nrbf/tests/JaggedArraysTests.cs index a72c3227c1e..8bb844ff76a 100644 --- a/src/libraries/System.Formats.Nrbf/tests/JaggedArraysTests.cs +++ b/src/libraries/System.Formats.Nrbf/tests/JaggedArraysTests.cs @@ -1,4 +1,5 @@ using System.Formats.Nrbf.Utils; +using System.IO; using System.Linq; using Xunit; @@ -6,29 +7,91 @@ namespace System.Formats.Nrbf.Tests; public class JaggedArraysTests : ReadTests { - [Fact] - public void CanReadJaggedArraysOfPrimitiveTypes_2D() + [Theory] + [InlineData(true)] + [InlineData(false)] + public void CanReadJaggedArraysOfPrimitiveTypes_2D(bool useReferences) { int[][] input = new int[7][]; + int[] same = [1, 2, 3]; for (int i = 0; i < input.Length; i++) { - input[i] = [i, i, i]; + input[i] = useReferences + ? same // reuse the same object (represented as a single record that is referenced multiple times) + : [i, i, i]; // create new array } var arrayRecord = (ArrayRecord)NrbfDecoder.Decode(Serialize(input)); Verify(input, arrayRecord); Assert.Equal(input, arrayRecord.GetArray(input.GetType())); + Assert.Equal(input.Length + input.Length * 3, arrayRecord.FlattenedLength); + } + + [Theory] + [InlineData(1)] // SerializationRecordType.ObjectNull + [InlineData(200)] // SerializationRecordType.ObjectNullMultiple256 + [InlineData(10_000)] // SerializationRecordType.ObjectNullMultiple + public void FlattenedLengthIncludesNullArrays(int nullCount) + { + int[][] input = new int[nullCount][]; + + var arrayRecord = (ArrayRecord)NrbfDecoder.Decode(Serialize(input)); + + Verify(input, arrayRecord); + Assert.Equal(input, arrayRecord.GetArray(input.GetType())); + Assert.Equal(nullCount, arrayRecord.FlattenedLength); + } + + [Fact] + public void ItIsPossibleToHaveBinaryArrayRecordsHaveAnElementTypeOfArrayWithoutBeingMarkedAsJagged() + { + int[][][] input = new int[3][][]; + long totalElementsCount = 0; + for (int i = 0; i < input.Length; i++) + { + input[i] = new int[4][]; + totalElementsCount++; // count the arrays themselves + + for (int j = 0; j < input[i].Length; j++) + { + input[i][j] = [i, j, 0, 1, 2]; + totalElementsCount += input[i][j].Length; + totalElementsCount++; // count the arrays themselves + } + } + + byte[] serialized = Serialize(input).ToArray(); + const int ArrayTypeByteIndex = + sizeof(byte) + sizeof(int) * 4 + // stream header + sizeof(byte) + // SerializationRecordType.BinaryArray + sizeof(int); // SerializationRecordId + + Assert.Equal((byte)BinaryArrayType.Jagged, serialized[ArrayTypeByteIndex]); + + // change the reported array type + serialized[ArrayTypeByteIndex] = (byte)BinaryArrayType.Single; + + var arrayRecord = (ArrayRecord)NrbfDecoder.Decode(new MemoryStream(serialized)); + + Verify(input, arrayRecord); + Assert.Equal(input, arrayRecord.GetArray(input.GetType())); + Assert.Equal(3 + 3 * 4 + 3 * 4 * 5, totalElementsCount); + Assert.Equal(totalElementsCount, arrayRecord.FlattenedLength); } [Fact] public void CanReadJaggedArraysOfPrimitiveTypes_3D() { int[][][] input = new int[7][][]; + long totalElementsCount = 0; for (int i = 0; i < input.Length; i++) { + totalElementsCount++; // count the arrays themselves input[i] = new int[1][]; + totalElementsCount++; // count the arrays themselves input[i][0] = [i, i, i]; + totalElementsCount += input[i][0].Length; } var arrayRecord = (ArrayRecord)NrbfDecoder.Decode(Serialize(input)); @@ -36,6 +99,8 @@ public void CanReadJaggedArraysOfPrimitiveTypes_3D() Verify(input, arrayRecord); Assert.Equal(input, arrayRecord.GetArray(input.GetType())); Assert.Equal(1, arrayRecord.Rank); + Assert.Equal(7 + 7 * 1 + 7 * 1 * 3, totalElementsCount); + Assert.Equal(totalElementsCount, arrayRecord.FlattenedLength); } [Fact] @@ -60,6 +125,7 @@ public void CanReadJaggedArrayOfRectangularArrays() Verify(input, arrayRecord); Assert.Equal(input, arrayRecord.GetArray(input.GetType())); Assert.Equal(1, arrayRecord.Rank); + Assert.Equal(input.Length + input.Length * 3 * 3, arrayRecord.FlattenedLength); } [Fact] @@ -75,6 +141,7 @@ public void CanReadJaggedArraysOfStrings() Verify(input, arrayRecord); Assert.Equal(input, arrayRecord.GetArray(input.GetType())); + Assert.Equal(input.Length + input.Length * 3, arrayRecord.FlattenedLength); } [Fact] @@ -90,6 +157,7 @@ public void CanReadJaggedArraysOfObjects() Verify(input, arrayRecord); Assert.Equal(input, arrayRecord.GetArray(input.GetType())); + Assert.Equal(input.Length + input.Length * 3, arrayRecord.FlattenedLength); } [Serializable] @@ -102,14 +170,18 @@ public class ComplexType public void CanReadJaggedArraysOfComplexTypes() { ComplexType[][] input = new ComplexType[3][]; + long totalElementsCount = 0; for (int i = 0; i < input.Length; i++) { input[i] = Enumerable.Range(0, i + 1).Select(j => new ComplexType { SomeField = j }).ToArray(); + totalElementsCount += input[i].Length; + totalElementsCount++; // count the arrays themselves } var arrayRecord = (ArrayRecord)NrbfDecoder.Decode(Serialize(input)); Verify(input, arrayRecord); + Assert.Equal(totalElementsCount, arrayRecord.FlattenedLength); var output = (ClassRecord?[][])arrayRecord.GetArray(input.GetType()); for (int i = 0; i < input.Length; i++) { diff --git a/src/libraries/System.Formats.Nrbf/tests/ReadTests.cs b/src/libraries/System.Formats.Nrbf/tests/ReadTests.cs index b9bee7d881a..0c7bd2045fa 100644 --- a/src/libraries/System.Formats.Nrbf/tests/ReadTests.cs +++ b/src/libraries/System.Formats.Nrbf/tests/ReadTests.cs @@ -45,10 +45,10 @@ protected static BinaryFormatter CreateBinaryFormatter() }; #pragma warning restore SYSLIB0011 // Type or member is obsolete - protected static void WriteSerializedStreamHeader(BinaryWriter writer, int major = 1, int minor = 0) + protected static void WriteSerializedStreamHeader(BinaryWriter writer, int major = 1, int minor = 0, int rootId = 1) { writer.Write((byte)SerializationRecordType.SerializedStreamHeader); - writer.Write(1); // root ID + writer.Write(rootId); // root ID writer.Write(1); // header ID writer.Write(major); // major version writer.Write(minor); // minor version diff --git a/src/libraries/System.Formats.Nrbf/tests/RectangularArraysTests.cs b/src/libraries/System.Formats.Nrbf/tests/RectangularArraysTests.cs index 25e7bb5a4d5..3191d57ba80 100644 --- a/src/libraries/System.Formats.Nrbf/tests/RectangularArraysTests.cs +++ b/src/libraries/System.Formats.Nrbf/tests/RectangularArraysTests.cs @@ -223,10 +223,13 @@ public void CanReadRectangularArraysOfComplexTypes_3D() internal static void Verify(Array input, ArrayRecord arrayRecord) { Assert.Equal(input.Rank, arrayRecord.Lengths.Length); + long totalElementsCount = 1; for (int i = 0; i < input.Rank; i++) { Assert.Equal(input.GetLength(i), arrayRecord.Lengths[i]); + totalElementsCount *= input.GetLength(i); } + Assert.Equal(totalElementsCount, arrayRecord.FlattenedLength); Assert.Equal(input.GetType().FullName, arrayRecord.TypeName.FullName); Assert.Equal(input.GetType().GetAssemblyNameIncludingTypeForwards(), arrayRecord.TypeName.AssemblyName!.FullName); } diff --git a/src/libraries/System.Formats.Nrbf/tests/System.Formats.Nrbf.Tests.csproj b/src/libraries/System.Formats.Nrbf/tests/System.Formats.Nrbf.Tests.csproj index 513d152362e..9bf2f51fcce 100644 --- a/src/libraries/System.Formats.Nrbf/tests/System.Formats.Nrbf.Tests.csproj +++ b/src/libraries/System.Formats.Nrbf/tests/System.Formats.Nrbf.Tests.csproj @@ -3,10 +3,14 @@ $(NetCoreAppCurrent);$(NetFrameworkMinimum) true + + $(NoWarn);SYSLIB5005 + + @@ -15,11 +19,14 @@ - + - + - + + diff --git a/src/libraries/System.Formats.Nrbf/tests/TypeMatchTests.cs b/src/libraries/System.Formats.Nrbf/tests/TypeMatchTests.cs index 7bf48eab616..e0827c1225b 100644 --- a/src/libraries/System.Formats.Nrbf/tests/TypeMatchTests.cs +++ b/src/libraries/System.Formats.Nrbf/tests/TypeMatchTests.cs @@ -73,6 +73,34 @@ public void CanRecognizeGenericSystemTypes() Verify(new Dictionary>>()); } + [Fact] + public void ThrowsForNullType() + { + List input = new List(); + + SerializationRecord record = NrbfDecoder.Decode(Serialize(input)); + + Assert.Throws(() => record.TypeNameMatches(type: null)); + } + + [Fact] + public void TakesCustomOffsetsIntoAccount() + { + int[] input = [1, 2, 3]; + + SerializationRecord record = NrbfDecoder.Decode(Serialize(input)); + + Assert.True(record.TypeNameMatches(typeof(int[]))); + + Type nonSzArray = typeof(int).Assembly.GetType("System.Int32[*]"); +#if NET + Assert.False(nonSzArray.IsSZArray); + Assert.True(nonSzArray.IsVariableBoundArray); +#endif + Assert.Equal(1, nonSzArray.GetArrayRank()); + Assert.False(record.TypeNameMatches(nonSzArray)); + } + [Fact] public void TakesGenericTypeDefinitionIntoAccount() { @@ -302,6 +330,12 @@ private static void Verify(T input) where T : notnull Assert.True(one.TypeNameMatches(typeof(T))); + Assert.Equal(typeof(T).GetTypeFullNameIncludingTypeForwards(), one.TypeName.FullName); + if (typeof(T) != typeof(TimeSpan)) // TimeSpan is missing type forwards + { + Assert.Equal(typeof(T).GetAssemblyNameIncludingTypeForwards(), one.TypeName.AssemblyName!.FullName); + } + foreach (Type type in PrimitiveTypes) { Assert.Equal(typeof(T) == type, one.TypeNameMatches(type)); diff --git a/src/libraries/System.Formats.Tar/System.Formats.Tar.sln b/src/libraries/System.Formats.Tar/System.Formats.Tar.sln index 3c8a2aacb8f..74f14355741 100644 --- a/src/libraries/System.Formats.Tar/System.Formats.Tar.sln +++ b/src/libraries/System.Formats.Tar/System.Formats.Tar.sln @@ -13,6 +13,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Formats.Tar.Tests", EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{00477EA4-C3E5-48A9-8CA8-8CCF689E0DB4}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{CD3A1327-8C67-4370-AC34-033065330F3F}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{E89FEF3E-E0B9-41C4-A51C-9759AD1A3B69}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{50E6D5FD-0E06-4D07-966E-C28E5448A1D3}" @@ -79,6 +81,10 @@ Global {00477EA4-C3E5-48A9-8CA8-8CCF689E0DB4}.Debug|Any CPU.Build.0 = Debug|Any CPU {00477EA4-C3E5-48A9-8CA8-8CCF689E0DB4}.Release|Any CPU.ActiveCfg = Release|Any CPU {00477EA4-C3E5-48A9-8CA8-8CCF689E0DB4}.Release|Any CPU.Build.0 = Release|Any CPU + {CD3A1327-8C67-4370-AC34-033065330F3F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {CD3A1327-8C67-4370-AC34-033065330F3F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {CD3A1327-8C67-4370-AC34-033065330F3F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {CD3A1327-8C67-4370-AC34-033065330F3F}.Release|Any CPU.Build.0 = Release|Any CPU {E89FEF3E-E0B9-41C4-A51C-9759AD1A3B69}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {E89FEF3E-E0B9-41C4-A51C-9759AD1A3B69}.Debug|Any CPU.Build.0 = Debug|Any CPU {E89FEF3E-E0B9-41C4-A51C-9759AD1A3B69}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -124,6 +130,7 @@ Global {A00011A0-E609-4A49-B893-EBFC72C98707} = {9BE8AFF4-D37B-49AF-AFD3-A15E514AC8AE} {9F751C2B-56DD-4604-A3F3-568627F8C006} = {55A8C7E4-925C-4F21-B68B-CEFC19137A4B} {00477EA4-C3E5-48A9-8CA8-8CCF689E0DB4} = {0345BAA8-92BC-4499-B550-21AC44910FD2} + {CD3A1327-8C67-4370-AC34-033065330F3F} = {0345BAA8-92BC-4499-B550-21AC44910FD2} {E89FEF3E-E0B9-41C4-A51C-9759AD1A3B69} = {0345BAA8-92BC-4499-B550-21AC44910FD2} {50E6D5FD-0E06-4D07-966E-C28E5448A1D3} = {0345BAA8-92BC-4499-B550-21AC44910FD2} {AFEE875F-22C7-46AE-B28F-AF5C05CA0BA5} = {07E13495-DC86-43BF-9E64-2CEA381D892D} diff --git a/src/libraries/System.Formats.Tar/src/System/Formats/Tar/TarHeader.Write.cs b/src/libraries/System.Formats.Tar/src/System/Formats/Tar/TarHeader.Write.cs index 81d90e1d7be..fcc5d22cde6 100644 --- a/src/libraries/System.Formats.Tar/src/System/Formats/Tar/TarHeader.Write.cs +++ b/src/libraries/System.Formats.Tar/src/System/Formats/Tar/TarHeader.Write.cs @@ -629,7 +629,7 @@ private int WriteCommonFields(Span buffer, TarEntryType actualEntryType) checksum += FormatNumeric(_gid, buffer.Slice(FieldLocations.Gid, FieldLengths.Gid)); } - if (_size > 0) + if (_dataStream != null && _size >= 0) { checksum += FormatNumeric(_size, buffer.Slice(FieldLocations.Size, FieldLengths.Size)); } diff --git a/src/libraries/System.Formats.Tar/tests/TarWriter/TarWriter.Tests.cs b/src/libraries/System.Formats.Tar/tests/TarWriter/TarWriter.Tests.cs index b46816844b4..cb65c0e6d16 100644 --- a/src/libraries/System.Formats.Tar/tests/TarWriter/TarWriter.Tests.cs +++ b/src/libraries/System.Formats.Tar/tests/TarWriter/TarWriter.Tests.cs @@ -2,6 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. using System.IO; +using System.Linq; using Xunit; namespace System.Formats.Tar.Tests @@ -350,5 +351,20 @@ private int GetChecksumForFormatSpecificFields(TarEntry entry, TarEntryFormat fo // Gnu BlockDevice: 623 + 1004 + 686 + 1142 = 3455 return checksum; } + + [Fact] + void Verify_Size_RegularFile_Empty() + { + using MemoryStream emptyData = new(0); + using MemoryStream output = new(); + using TarWriter archive = new(output, TarEntryFormat.Pax); + PaxTarEntry te = new(TarEntryType.RegularFile, "zero_size") + { DataStream = emptyData }; + archive.WriteEntry(te); + var sizeBuffer = output.GetBuffer()[1148..(1148 + 12)]; + // we expect ocal zeros + byte[] expected = [0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0]; + Assert.True(sizeBuffer.SequenceEqual(expected)); + } } } diff --git a/src/libraries/System.IO.Compression.Brotli/Directory.Build.props b/src/libraries/System.IO.Compression.Brotli/Directory.Build.props index f3f5769f936..76ee806bc1a 100644 --- a/src/libraries/System.IO.Compression.Brotli/Directory.Build.props +++ b/src/libraries/System.IO.Compression.Brotli/Directory.Build.props @@ -3,6 +3,6 @@ ECMA true - browser + browser;wasi \ No newline at end of file diff --git a/src/libraries/System.IO.Compression.Brotli/System.IO.Compression.Brotli.sln b/src/libraries/System.IO.Compression.Brotli/System.IO.Compression.Brotli.sln index 4c9b9c7bd4b..e72eb7bcd74 100644 --- a/src/libraries/System.IO.Compression.Brotli/System.IO.Compression.Brotli.sln +++ b/src/libraries/System.IO.Compression.Brotli/System.IO.Compression.Brotli.sln @@ -13,6 +13,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.IO.Compression", ".. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{A97A0A66-F03A-439B-A943-6F0A8DFD6029}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{1F5EEA50-437A-43CD-AC7C-560D14F57716}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{43B12013-5509-43BB-9173-2CFE43B135AA}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{2AA8D3E7-D2E4-49E8-AE94-461CE261B1BF}" @@ -79,6 +81,10 @@ Global {A97A0A66-F03A-439B-A943-6F0A8DFD6029}.Debug|Any CPU.Build.0 = Debug|Any CPU {A97A0A66-F03A-439B-A943-6F0A8DFD6029}.Release|Any CPU.ActiveCfg = Release|Any CPU {A97A0A66-F03A-439B-A943-6F0A8DFD6029}.Release|Any CPU.Build.0 = Release|Any CPU + {1F5EEA50-437A-43CD-AC7C-560D14F57716}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {1F5EEA50-437A-43CD-AC7C-560D14F57716}.Debug|Any CPU.Build.0 = Debug|Any CPU + {1F5EEA50-437A-43CD-AC7C-560D14F57716}.Release|Any CPU.ActiveCfg = Release|Any CPU + {1F5EEA50-437A-43CD-AC7C-560D14F57716}.Release|Any CPU.Build.0 = Release|Any CPU {43B12013-5509-43BB-9173-2CFE43B135AA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {43B12013-5509-43BB-9173-2CFE43B135AA}.Debug|Any CPU.Build.0 = Debug|Any CPU {43B12013-5509-43BB-9173-2CFE43B135AA}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -124,6 +130,7 @@ Global {129FE4AC-D499-4900-9505-DDAE214B1FF7} = {1BC1DCD5-DECC-4712-8539-56E6D71A17FF} {C2A30FF0-54C2-461B-BF16-5DC610F54B52} = {D7FE73BB-2F95-42D3-9392-FBAD87A73436} {A97A0A66-F03A-439B-A943-6F0A8DFD6029} = {4F867226-2107-455D-B378-2FC08BD3F064} + {1F5EEA50-437A-43CD-AC7C-560D14F57716} = {4F867226-2107-455D-B378-2FC08BD3F064} {43B12013-5509-43BB-9173-2CFE43B135AA} = {4F867226-2107-455D-B378-2FC08BD3F064} {2AA8D3E7-D2E4-49E8-AE94-461CE261B1BF} = {4F867226-2107-455D-B378-2FC08BD3F064} {79891BE8-C29A-4986-8228-300F7974A2B9} = {F5CDB2C5-3D4F-4052-8B52-6F5517F18F11} diff --git a/src/libraries/System.IO.Compression.Brotli/tests/System.IO.Compression.Brotli.Tests.csproj b/src/libraries/System.IO.Compression.Brotli/tests/System.IO.Compression.Brotli.Tests.csproj index 167caaaa6bc..936e3768a0e 100644 --- a/src/libraries/System.IO.Compression.Brotli/tests/System.IO.Compression.Brotli.Tests.csproj +++ b/src/libraries/System.IO.Compression.Brotli/tests/System.IO.Compression.Brotli.Tests.csproj @@ -27,6 +27,8 @@ + diff --git a/src/libraries/System.IO.Compression.ZipFile/System.IO.Compression.ZipFile.sln b/src/libraries/System.IO.Compression.ZipFile/System.IO.Compression.ZipFile.sln index 91bba42be1d..4b67efeb75d 100644 --- a/src/libraries/System.IO.Compression.ZipFile/System.IO.Compression.ZipFile.sln +++ b/src/libraries/System.IO.Compression.ZipFile/System.IO.Compression.ZipFile.sln @@ -11,6 +11,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.IO.Compression", ".. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{96882887-EDCB-474D-95DB-D510FF90B3A1}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{F48A8952-05EC-4BF0-8E50-9F711F695CE3}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{AE18A377-AAE7-488B-A873-8463A2706BC0}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{5DC533A5-D0F0-488B-81C2-7AD7546528DD}" @@ -73,6 +75,10 @@ Global {96882887-EDCB-474D-95DB-D510FF90B3A1}.Debug|Any CPU.Build.0 = Debug|Any CPU {96882887-EDCB-474D-95DB-D510FF90B3A1}.Release|Any CPU.ActiveCfg = Release|Any CPU {96882887-EDCB-474D-95DB-D510FF90B3A1}.Release|Any CPU.Build.0 = Release|Any CPU + {F48A8952-05EC-4BF0-8E50-9F711F695CE3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F48A8952-05EC-4BF0-8E50-9F711F695CE3}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F48A8952-05EC-4BF0-8E50-9F711F695CE3}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F48A8952-05EC-4BF0-8E50-9F711F695CE3}.Release|Any CPU.Build.0 = Release|Any CPU {AE18A377-AAE7-488B-A873-8463A2706BC0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {AE18A377-AAE7-488B-A873-8463A2706BC0}.Debug|Any CPU.Build.0 = Debug|Any CPU {AE18A377-AAE7-488B-A873-8463A2706BC0}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -117,6 +123,7 @@ Global {E181A932-A6F9-4D04-B5ED-82514F484E2E} = {A8BAE96C-3EAD-4E68-BBB0-A4854F386CC4} {A3C36A2F-2586-43DF-B39C-A9D14DF8524E} = {5C592E59-B3F3-4743-BC80-F5C799B16B74} {96882887-EDCB-474D-95DB-D510FF90B3A1} = {82C30050-0689-4C48-AA32-E7137F0417DC} + {F48A8952-05EC-4BF0-8E50-9F711F695CE3} = {82C30050-0689-4C48-AA32-E7137F0417DC} {AE18A377-AAE7-488B-A873-8463A2706BC0} = {82C30050-0689-4C48-AA32-E7137F0417DC} {5DC533A5-D0F0-488B-81C2-7AD7546528DD} = {82C30050-0689-4C48-AA32-E7137F0417DC} {43762C19-7FFE-4C19-B642-099B51FEF039} = {5514616F-E12B-4057-9897-E4302DEA379B} diff --git a/src/libraries/System.IO.Compression/System.IO.Compression.sln b/src/libraries/System.IO.Compression/System.IO.Compression.sln index dc980dd95d8..e30ab5d5be0 100644 --- a/src/libraries/System.IO.Compression/System.IO.Compression.sln +++ b/src/libraries/System.IO.Compression/System.IO.Compression.sln @@ -11,6 +11,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.IO.Compression.Tests EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{6CD1A771-F838-4F58-A174-203C02644EDE}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{0C920E27-5F89-42F9-AC79-2D8B886F7C1A}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{77B12FDD-F00D-4EA0-A802-2A0C12D0CE96}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{9A07A277-2896-48FC-8A20-5E290069B07D}" @@ -73,6 +75,10 @@ Global {6CD1A771-F838-4F58-A174-203C02644EDE}.Debug|Any CPU.Build.0 = Debug|Any CPU {6CD1A771-F838-4F58-A174-203C02644EDE}.Release|Any CPU.ActiveCfg = Release|Any CPU {6CD1A771-F838-4F58-A174-203C02644EDE}.Release|Any CPU.Build.0 = Release|Any CPU + {0C920E27-5F89-42F9-AC79-2D8B886F7C1A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {0C920E27-5F89-42F9-AC79-2D8B886F7C1A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {0C920E27-5F89-42F9-AC79-2D8B886F7C1A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {0C920E27-5F89-42F9-AC79-2D8B886F7C1A}.Release|Any CPU.Build.0 = Release|Any CPU {77B12FDD-F00D-4EA0-A802-2A0C12D0CE96}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {77B12FDD-F00D-4EA0-A802-2A0C12D0CE96}.Debug|Any CPU.Build.0 = Debug|Any CPU {77B12FDD-F00D-4EA0-A802-2A0C12D0CE96}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -117,6 +123,7 @@ Global {BB89CCB0-227A-480D-B6D4-91D680278211} = {350F6B1E-B006-4EA5-BA9E-41F57FF84FF1} {ED776381-E13D-4A0B-ACB4-74C5A784BD25} = {8541C42E-9FC4-4077-B828-720BD028F1F5} {6CD1A771-F838-4F58-A174-203C02644EDE} = {BA616F42-6B1E-4333-9698-C39EA13AEEA2} + {0C920E27-5F89-42F9-AC79-2D8B886F7C1A} = {BA616F42-6B1E-4333-9698-C39EA13AEEA2} {77B12FDD-F00D-4EA0-A802-2A0C12D0CE96} = {BA616F42-6B1E-4333-9698-C39EA13AEEA2} {9A07A277-2896-48FC-8A20-5E290069B07D} = {BA616F42-6B1E-4333-9698-C39EA13AEEA2} {A51CB0A3-A6A1-402E-B3AF-E6293EE28FB8} = {D61359E8-8A03-4D16-BC52-32FFE3D0974A} diff --git a/src/libraries/System.IO.Compression/src/System.IO.Compression.csproj b/src/libraries/System.IO.Compression/src/System.IO.Compression.csproj index 208844b5d67..9292ec1f46d 100644 --- a/src/libraries/System.IO.Compression/src/System.IO.Compression.csproj +++ b/src/libraries/System.IO.Compression/src/System.IO.Compression.csproj @@ -35,6 +35,8 @@ + diff --git a/src/libraries/System.IO.Compression/tests/CompressionStreamUnitTests.Deflate.cs b/src/libraries/System.IO.Compression/tests/CompressionStreamUnitTests.Deflate.cs index 9c25d5e5483..d91a243b907 100644 --- a/src/libraries/System.IO.Compression/tests/CompressionStreamUnitTests.Deflate.cs +++ b/src/libraries/System.IO.Compression/tests/CompressionStreamUnitTests.Deflate.cs @@ -219,12 +219,5 @@ public override Task WriteAsync(byte[] buffer, int offset, int count, Cancellati return base.WriteAsync(buffer, offset, count, cancellationToken); } } - - [Theory] - [MemberData(nameof(UncompressedTestFilesZLib))] - public async Task ZLibCompressionLevel_SizeInOrder(string testFile) - { - await CompressionLevel_SizeInOrderBase(testFile); - } } } diff --git a/src/libraries/System.IO.Compression/tests/CompressionStreamUnitTests.Gzip.cs b/src/libraries/System.IO.Compression/tests/CompressionStreamUnitTests.Gzip.cs index 9fabd3dc31a..9919b2c819a 100644 --- a/src/libraries/System.IO.Compression/tests/CompressionStreamUnitTests.Gzip.cs +++ b/src/libraries/System.IO.Compression/tests/CompressionStreamUnitTests.Gzip.cs @@ -441,12 +441,5 @@ public override Task WriteAsync(byte[] buffer, int offset, int count, Cancellati return base.WriteAsync(buffer, offset, count, cancellationToken); } } - - [Theory] - [MemberData(nameof(UncompressedTestFilesZLib))] - public async Task ZLibCompressionLevel_SizeInOrder(string testFile) - { - await CompressionLevel_SizeInOrderBase(testFile); - } } } diff --git a/src/libraries/System.IO.Compression/tests/CompressionStreamUnitTests.ZLib.cs b/src/libraries/System.IO.Compression/tests/CompressionStreamUnitTests.ZLib.cs index ea868cdcf1f..bed459833e1 100644 --- a/src/libraries/System.IO.Compression/tests/CompressionStreamUnitTests.ZLib.cs +++ b/src/libraries/System.IO.Compression/tests/CompressionStreamUnitTests.ZLib.cs @@ -150,12 +150,5 @@ public void StreamTruncation_IsDetected(TestScenario testScenario) } }, testScenario.ToString()).Dispose(); } - - [Theory] - [MemberData(nameof(UncompressedTestFilesZLib))] - public async Task ZLibCompressionLevel_SizeInOrder(string testFile) - { - await CompressionLevel_SizeInOrderBase(testFile); - } } } diff --git a/src/libraries/System.IO.Compression/tests/System.IO.Compression.Tests.csproj b/src/libraries/System.IO.Compression/tests/System.IO.Compression.Tests.csproj index be6e981939a..286ffea2850 100644 --- a/src/libraries/System.IO.Compression/tests/System.IO.Compression.Tests.csproj +++ b/src/libraries/System.IO.Compression/tests/System.IO.Compression.Tests.csproj @@ -35,6 +35,8 @@ + diff --git a/src/libraries/System.IO.FileSystem.AccessControl/System.IO.FileSystem.AccessControl.sln b/src/libraries/System.IO.FileSystem.AccessControl/System.IO.FileSystem.AccessControl.sln index a49ca6dcd0b..3119cba036f 100644 --- a/src/libraries/System.IO.FileSystem.AccessControl/System.IO.FileSystem.AccessControl.sln +++ b/src/libraries/System.IO.FileSystem.AccessControl/System.IO.FileSystem.AccessControl.sln @@ -25,6 +25,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.Uri", "..\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{974F81BC-FDCE-404E-B8D7-12A48E27F005}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{D8D60AFF-4A6F-4860-826C-45FB3A2B3942}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{4E815F64-6F9A-485D-825D-930830F7EABB}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{E939A1C0-31C6-4EA6-9020-ADDE06272528}" @@ -374,6 +376,27 @@ Global {974F81BC-FDCE-404E-B8D7-12A48E27F005}.Checked|arm64.ActiveCfg = Debug|Any CPU {974F81BC-FDCE-404E-B8D7-12A48E27F005}.Checked|x64.ActiveCfg = Debug|Any CPU {974F81BC-FDCE-404E-B8D7-12A48E27F005}.Checked|x86.ActiveCfg = Debug|Any CPU + {D8D60AFF-4A6F-4860-826C-45FB3A2B3942}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D8D60AFF-4A6F-4860-826C-45FB3A2B3942}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D8D60AFF-4A6F-4860-826C-45FB3A2B3942}.Debug|arm.ActiveCfg = Debug|Any CPU + {D8D60AFF-4A6F-4860-826C-45FB3A2B3942}.Debug|arm64.ActiveCfg = Debug|Any CPU + {D8D60AFF-4A6F-4860-826C-45FB3A2B3942}.Debug|x64.ActiveCfg = Debug|Any CPU + {D8D60AFF-4A6F-4860-826C-45FB3A2B3942}.Debug|x64.Build.0 = Debug|Any CPU + {D8D60AFF-4A6F-4860-826C-45FB3A2B3942}.Debug|x86.ActiveCfg = Debug|Any CPU + {D8D60AFF-4A6F-4860-826C-45FB3A2B3942}.Debug|x86.Build.0 = Debug|Any CPU + {D8D60AFF-4A6F-4860-826C-45FB3A2B3942}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D8D60AFF-4A6F-4860-826C-45FB3A2B3942}.Release|Any CPU.Build.0 = Release|Any CPU + {D8D60AFF-4A6F-4860-826C-45FB3A2B3942}.Release|arm.ActiveCfg = Release|Any CPU + {D8D60AFF-4A6F-4860-826C-45FB3A2B3942}.Release|arm64.ActiveCfg = Release|Any CPU + {D8D60AFF-4A6F-4860-826C-45FB3A2B3942}.Release|x64.ActiveCfg = Release|Any CPU + {D8D60AFF-4A6F-4860-826C-45FB3A2B3942}.Release|x64.Build.0 = Release|Any CPU + {D8D60AFF-4A6F-4860-826C-45FB3A2B3942}.Release|x86.ActiveCfg = Release|Any CPU + {D8D60AFF-4A6F-4860-826C-45FB3A2B3942}.Release|x86.Build.0 = Release|Any CPU + {D8D60AFF-4A6F-4860-826C-45FB3A2B3942}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {D8D60AFF-4A6F-4860-826C-45FB3A2B3942}.Checked|arm.ActiveCfg = Debug|Any CPU + {D8D60AFF-4A6F-4860-826C-45FB3A2B3942}.Checked|arm64.ActiveCfg = Debug|Any CPU + {D8D60AFF-4A6F-4860-826C-45FB3A2B3942}.Checked|x64.ActiveCfg = Debug|Any CPU + {D8D60AFF-4A6F-4860-826C-45FB3A2B3942}.Checked|x86.ActiveCfg = Debug|Any CPU {4E815F64-6F9A-485D-825D-930830F7EABB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {4E815F64-6F9A-485D-825D-930830F7EABB}.Debug|Any CPU.Build.0 = Debug|Any CPU {4E815F64-6F9A-485D-825D-930830F7EABB}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -737,6 +760,7 @@ Global {F33F1171-273A-4BC3-B138-25E5E7118186} = {27A6AAE3-D2A8-4C35-8A90-2B8E23AD8094} {0A653F6C-C75E-47C4-85F9-5C1013E381D7} = {7227D008-BBBE-48D0-979B-9BC483BA7E60} {974F81BC-FDCE-404E-B8D7-12A48E27F005} = {7227D008-BBBE-48D0-979B-9BC483BA7E60} + {D8D60AFF-4A6F-4860-826C-45FB3A2B3942} = {7227D008-BBBE-48D0-979B-9BC483BA7E60} {4E815F64-6F9A-485D-825D-930830F7EABB} = {7227D008-BBBE-48D0-979B-9BC483BA7E60} {E939A1C0-31C6-4EA6-9020-ADDE06272528} = {7227D008-BBBE-48D0-979B-9BC483BA7E60} {46DF5480-1E6D-4F0A-A93E-25833F1C598E} = {55C6D9AC-165E-4CD8-B1CE-898F8A2040C3} diff --git a/src/libraries/System.IO.FileSystem.DriveInfo/System.IO.FileSystem.DriveInfo.sln b/src/libraries/System.IO.FileSystem.DriveInfo/System.IO.FileSystem.DriveInfo.sln index 21280f2adf0..50797050feb 100644 --- a/src/libraries/System.IO.FileSystem.DriveInfo/System.IO.FileSystem.DriveInfo.sln +++ b/src/libraries/System.IO.FileSystem.DriveInfo/System.IO.FileSystem.DriveInfo.sln @@ -9,6 +9,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.IO.FileSystem.DriveI EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{08499DD2-78CA-48DD-A58A-90DEC1958826}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{D26A1328-86A1-420E-AC54-353FDE95A8C7}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{FBEEAA13-A404-4BB5-AE41-098F2D9B4E15}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{B9E98144-5561-4CED-BC68-93021B390983}" @@ -67,6 +69,10 @@ Global {08499DD2-78CA-48DD-A58A-90DEC1958826}.Debug|Any CPU.Build.0 = Debug|Any CPU {08499DD2-78CA-48DD-A58A-90DEC1958826}.Release|Any CPU.ActiveCfg = Release|Any CPU {08499DD2-78CA-48DD-A58A-90DEC1958826}.Release|Any CPU.Build.0 = Release|Any CPU + {D26A1328-86A1-420E-AC54-353FDE95A8C7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D26A1328-86A1-420E-AC54-353FDE95A8C7}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D26A1328-86A1-420E-AC54-353FDE95A8C7}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D26A1328-86A1-420E-AC54-353FDE95A8C7}.Release|Any CPU.Build.0 = Release|Any CPU {FBEEAA13-A404-4BB5-AE41-098F2D9B4E15}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {FBEEAA13-A404-4BB5-AE41-098F2D9B4E15}.Debug|Any CPU.Build.0 = Debug|Any CPU {FBEEAA13-A404-4BB5-AE41-098F2D9B4E15}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -110,6 +116,7 @@ Global {C84193AC-A010-4A92-9B72-4F8C75CF7389} = {4626E870-1F74-4ED4-AF80-DDDD42DEF47E} {03A51C60-B41B-409B-97AA-4084042C78D7} = {F20F7286-4DFA-42EE-947B-8ABC6B7E088F} {08499DD2-78CA-48DD-A58A-90DEC1958826} = {9BFF66A7-7077-4C69-BAB7-5FE6E2D9DBBC} + {D26A1328-86A1-420E-AC54-353FDE95A8C7} = {9BFF66A7-7077-4C69-BAB7-5FE6E2D9DBBC} {FBEEAA13-A404-4BB5-AE41-098F2D9B4E15} = {9BFF66A7-7077-4C69-BAB7-5FE6E2D9DBBC} {B9E98144-5561-4CED-BC68-93021B390983} = {9BFF66A7-7077-4C69-BAB7-5FE6E2D9DBBC} {C0BEFD2A-1FF5-4EA5-8E9D-02CD6D5205E2} = {B939865D-DC8A-4B55-91C7-DA3F2DDD2252} diff --git a/src/libraries/System.IO.FileSystem.Watcher/Directory.Build.props b/src/libraries/System.IO.FileSystem.Watcher/Directory.Build.props index c581a9ef9e5..a07e665d16a 100644 --- a/src/libraries/System.IO.FileSystem.Watcher/Directory.Build.props +++ b/src/libraries/System.IO.FileSystem.Watcher/Directory.Build.props @@ -3,7 +3,7 @@ Microsoft true - browser;ios;tvos + browser;wasi;ios;tvos maccatalyst \ No newline at end of file diff --git a/src/libraries/System.IO.FileSystem.Watcher/System.IO.FileSystem.Watcher.sln b/src/libraries/System.IO.FileSystem.Watcher/System.IO.FileSystem.Watcher.sln index 6bc617eeb4d..24a28e8a7c1 100644 --- a/src/libraries/System.IO.FileSystem.Watcher/System.IO.FileSystem.Watcher.sln +++ b/src/libraries/System.IO.FileSystem.Watcher/System.IO.FileSystem.Watcher.sln @@ -19,6 +19,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ObjectModel", "..\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{D310E128-E5D5-458F-8255-03D8304772A8}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{0F99E9C2-0F25-410E-B40D-2B89B59D5466}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{B0C17840-DF58-49D8-9501-D2F1398E3BE4}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{DB80E810-8B37-4116-9835-889E16FEC389}" @@ -97,6 +99,10 @@ Global {D310E128-E5D5-458F-8255-03D8304772A8}.Debug|Any CPU.Build.0 = Debug|Any CPU {D310E128-E5D5-458F-8255-03D8304772A8}.Release|Any CPU.ActiveCfg = Release|Any CPU {D310E128-E5D5-458F-8255-03D8304772A8}.Release|Any CPU.Build.0 = Release|Any CPU + {0F99E9C2-0F25-410E-B40D-2B89B59D5466}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {0F99E9C2-0F25-410E-B40D-2B89B59D5466}.Debug|Any CPU.Build.0 = Debug|Any CPU + {0F99E9C2-0F25-410E-B40D-2B89B59D5466}.Release|Any CPU.ActiveCfg = Release|Any CPU + {0F99E9C2-0F25-410E-B40D-2B89B59D5466}.Release|Any CPU.Build.0 = Release|Any CPU {B0C17840-DF58-49D8-9501-D2F1398E3BE4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {B0C17840-DF58-49D8-9501-D2F1398E3BE4}.Debug|Any CPU.Build.0 = Debug|Any CPU {B0C17840-DF58-49D8-9501-D2F1398E3BE4}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -145,6 +151,7 @@ Global {11864EE6-ADBD-417F-9D7C-58D4057F6A65} = {FB3E732D-C87B-41E9-ADC2-C2D84B87D04F} {310BA7DB-1A9E-46E1-B414-606474FFFFFA} = {BCDF2178-959A-48C9-B26D-18E62C80199C} {D310E128-E5D5-458F-8255-03D8304772A8} = {1C8EC715-29EB-40DF-A78F-35636153B267} + {0F99E9C2-0F25-410E-B40D-2B89B59D5466} = {1C8EC715-29EB-40DF-A78F-35636153B267} {B0C17840-DF58-49D8-9501-D2F1398E3BE4} = {1C8EC715-29EB-40DF-A78F-35636153B267} {DB80E810-8B37-4116-9835-889E16FEC389} = {1C8EC715-29EB-40DF-A78F-35636153B267} {387AA89D-B62A-4B06-8C0E-AAD444DE15C0} = {D43DD0C3-AA26-40DF-97AE-289CAC95C9C8} diff --git a/src/libraries/System.IO.Hashing/System.IO.Hashing.sln b/src/libraries/System.IO.Hashing/System.IO.Hashing.sln index ce6293aa826..59d4e9fcc58 100644 --- a/src/libraries/System.IO.Hashing/System.IO.Hashing.sln +++ b/src/libraries/System.IO.Hashing/System.IO.Hashing.sln @@ -7,7 +7,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.IO.Hashing", "src\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.IO.Hashing.Tests", "tests\System.IO.Hashing.Tests.csproj", "{2E6DAC1B-9054-40AF-AF72-4C2DD7BD9294}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{0EBDAC1E-7132-406B-96B4-F8875A689C99}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{99F5947A-580E-4B37-9F0B-6EB038904921}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{A60C1BBE-8CD7-4B6A-AD3C-FF1209857C39}" EndProject @@ -59,10 +59,10 @@ Global {2E6DAC1B-9054-40AF-AF72-4C2DD7BD9294}.Debug|Any CPU.Build.0 = Debug|Any CPU {2E6DAC1B-9054-40AF-AF72-4C2DD7BD9294}.Release|Any CPU.ActiveCfg = Release|Any CPU {2E6DAC1B-9054-40AF-AF72-4C2DD7BD9294}.Release|Any CPU.Build.0 = Release|Any CPU - {0EBDAC1E-7132-406B-96B4-F8875A689C99}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {0EBDAC1E-7132-406B-96B4-F8875A689C99}.Debug|Any CPU.Build.0 = Debug|Any CPU - {0EBDAC1E-7132-406B-96B4-F8875A689C99}.Release|Any CPU.ActiveCfg = Release|Any CPU - {0EBDAC1E-7132-406B-96B4-F8875A689C99}.Release|Any CPU.Build.0 = Release|Any CPU + {99F5947A-580E-4B37-9F0B-6EB038904921}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {99F5947A-580E-4B37-9F0B-6EB038904921}.Debug|Any CPU.Build.0 = Debug|Any CPU + {99F5947A-580E-4B37-9F0B-6EB038904921}.Release|Any CPU.ActiveCfg = Release|Any CPU + {99F5947A-580E-4B37-9F0B-6EB038904921}.Release|Any CPU.Build.0 = Release|Any CPU {A60C1BBE-8CD7-4B6A-AD3C-FF1209857C39}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {A60C1BBE-8CD7-4B6A-AD3C-FF1209857C39}.Debug|Any CPU.Build.0 = Debug|Any CPU {A60C1BBE-8CD7-4B6A-AD3C-FF1209857C39}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -96,7 +96,7 @@ Global {2E6DAC1B-9054-40AF-AF72-4C2DD7BD9294} = {1E78399D-326B-4C9F-B8A9-A7E684EEA349} {259A1DB6-EF7E-4D45-96EF-035E0605BB55} = {46BA9FAE-9204-455A-BB2D-518E5B5C3E4C} {A078A4EB-27E8-42B1-BD44-3807732A4560} = {F2826BE8-9FA1-40C8-8FD4-E98A4644733E} - {0EBDAC1E-7132-406B-96B4-F8875A689C99} = {26D7BA38-5978-4423-814C-0C8D9F38C1A3} + {99F5947A-580E-4B37-9F0B-6EB038904921} = {26D7BA38-5978-4423-814C-0C8D9F38C1A3} {A60C1BBE-8CD7-4B6A-AD3C-FF1209857C39} = {26D7BA38-5978-4423-814C-0C8D9F38C1A3} {14F46F30-1D5F-4FB6-B946-0E01BA52F8D9} = {7AB7C77C-0497-4E3D-B2A2-AC9D9CAE73E8} {724E5FDF-D03B-402C-870E-70E44E02F904} = {7AB7C77C-0497-4E3D-B2A2-AC9D9CAE73E8} diff --git a/src/libraries/System.IO.IsolatedStorage/Directory.Build.props b/src/libraries/System.IO.IsolatedStorage/Directory.Build.props index ce244cbea56..58979d42f06 100644 --- a/src/libraries/System.IO.IsolatedStorage/Directory.Build.props +++ b/src/libraries/System.IO.IsolatedStorage/Directory.Build.props @@ -3,6 +3,6 @@ Microsoft true - browser + browser;wasi \ No newline at end of file diff --git a/src/libraries/System.IO.IsolatedStorage/System.IO.IsolatedStorage.sln b/src/libraries/System.IO.IsolatedStorage/System.IO.IsolatedStorage.sln index 280bc8c08f5..f70ff4023c3 100644 --- a/src/libraries/System.IO.IsolatedStorage/System.IO.IsolatedStorage.sln +++ b/src/libraries/System.IO.IsolatedStorage/System.IO.IsolatedStorage.sln @@ -21,6 +21,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", ". EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.Uri", "..\System.Private.Uri\src\System.Private.Uri.csproj", "{77530357-B4AC-4879-850C-CD4231AA707F}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{3040CB65-0B82-4D08-83CE-3C24B3D4C87A}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{CB45B17E-7E90-4687-B5CB-697D761FAF8C}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{4DAA9EA7-245F-45D6-8061-010F7AA64752}" @@ -322,6 +324,27 @@ Global {77530357-B4AC-4879-850C-CD4231AA707F}.Checked|arm64.ActiveCfg = Debug|Any CPU {77530357-B4AC-4879-850C-CD4231AA707F}.Checked|x64.ActiveCfg = Debug|Any CPU {77530357-B4AC-4879-850C-CD4231AA707F}.Checked|x86.ActiveCfg = Debug|Any CPU + {3040CB65-0B82-4D08-83CE-3C24B3D4C87A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {3040CB65-0B82-4D08-83CE-3C24B3D4C87A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {3040CB65-0B82-4D08-83CE-3C24B3D4C87A}.Debug|arm.ActiveCfg = Debug|Any CPU + {3040CB65-0B82-4D08-83CE-3C24B3D4C87A}.Debug|arm64.ActiveCfg = Debug|Any CPU + {3040CB65-0B82-4D08-83CE-3C24B3D4C87A}.Debug|x64.ActiveCfg = Debug|Any CPU + {3040CB65-0B82-4D08-83CE-3C24B3D4C87A}.Debug|x64.Build.0 = Debug|Any CPU + {3040CB65-0B82-4D08-83CE-3C24B3D4C87A}.Debug|x86.ActiveCfg = Debug|Any CPU + {3040CB65-0B82-4D08-83CE-3C24B3D4C87A}.Debug|x86.Build.0 = Debug|Any CPU + {3040CB65-0B82-4D08-83CE-3C24B3D4C87A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {3040CB65-0B82-4D08-83CE-3C24B3D4C87A}.Release|Any CPU.Build.0 = Release|Any CPU + {3040CB65-0B82-4D08-83CE-3C24B3D4C87A}.Release|arm.ActiveCfg = Release|Any CPU + {3040CB65-0B82-4D08-83CE-3C24B3D4C87A}.Release|arm64.ActiveCfg = Release|Any CPU + {3040CB65-0B82-4D08-83CE-3C24B3D4C87A}.Release|x64.ActiveCfg = Release|Any CPU + {3040CB65-0B82-4D08-83CE-3C24B3D4C87A}.Release|x64.Build.0 = Release|Any CPU + {3040CB65-0B82-4D08-83CE-3C24B3D4C87A}.Release|x86.ActiveCfg = Release|Any CPU + {3040CB65-0B82-4D08-83CE-3C24B3D4C87A}.Release|x86.Build.0 = Release|Any CPU + {3040CB65-0B82-4D08-83CE-3C24B3D4C87A}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {3040CB65-0B82-4D08-83CE-3C24B3D4C87A}.Checked|arm.ActiveCfg = Debug|Any CPU + {3040CB65-0B82-4D08-83CE-3C24B3D4C87A}.Checked|arm64.ActiveCfg = Debug|Any CPU + {3040CB65-0B82-4D08-83CE-3C24B3D4C87A}.Checked|x64.ActiveCfg = Debug|Any CPU + {3040CB65-0B82-4D08-83CE-3C24B3D4C87A}.Checked|x86.ActiveCfg = Debug|Any CPU {CB45B17E-7E90-4687-B5CB-697D761FAF8C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {CB45B17E-7E90-4687-B5CB-697D761FAF8C}.Debug|Any CPU.Build.0 = Debug|Any CPU {CB45B17E-7E90-4687-B5CB-697D761FAF8C}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -617,6 +640,7 @@ Global {94E1FBF3-D07E-42CC-BDE9-195068C29632} = {CBCF137A-F5AD-4CCC-8888-F4B30426B5DE} {57DD5F0B-1CEE-4B33-9955-5CE4893EEFEA} = {CBCF137A-F5AD-4CCC-8888-F4B30426B5DE} {15DD6643-975E-47DC-83F2-5A734CA8C027} = {3424E375-E1DA-46BA-91D2-E1EA86BAF98F} + {3040CB65-0B82-4D08-83CE-3C24B3D4C87A} = {3424E375-E1DA-46BA-91D2-E1EA86BAF98F} {CB45B17E-7E90-4687-B5CB-697D761FAF8C} = {3424E375-E1DA-46BA-91D2-E1EA86BAF98F} {4DAA9EA7-245F-45D6-8061-010F7AA64752} = {3424E375-E1DA-46BA-91D2-E1EA86BAF98F} {877446C1-0835-444C-A210-45B0F55E03B6} = {A7BCEB40-DA50-4D87-8D82-FD5DEEB85C6F} diff --git a/src/libraries/System.IO.IsolatedStorage/tests/System.IO.IsolatedStorage.Tests.csproj b/src/libraries/System.IO.IsolatedStorage/tests/System.IO.IsolatedStorage.Tests.csproj index b14e54de417..0424a4615a0 100644 --- a/src/libraries/System.IO.IsolatedStorage/tests/System.IO.IsolatedStorage.Tests.csproj +++ b/src/libraries/System.IO.IsolatedStorage/tests/System.IO.IsolatedStorage.Tests.csproj @@ -1,6 +1,6 @@ - $(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-unix;$(NetCoreAppCurrent)-browser;$(NetCoreAppCurrent)-maccatalyst;$(NetCoreAppCurrent)-ios;$(NetCoreAppCurrent)-tvos;$(NetCoreAppCurrent)-android + $(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-unix;$(NetCoreAppCurrent)-browser;$(NetCoreAppCurrent)-wasi;$(NetCoreAppCurrent)-maccatalyst;$(NetCoreAppCurrent)-ios;$(NetCoreAppCurrent)-tvos;$(NetCoreAppCurrent)-android true diff --git a/src/libraries/System.IO.MemoryMappedFiles/System.IO.MemoryMappedFiles.sln b/src/libraries/System.IO.MemoryMappedFiles/System.IO.MemoryMappedFiles.sln index 40578971dac..296815d18a4 100644 --- a/src/libraries/System.IO.MemoryMappedFiles/System.IO.MemoryMappedFiles.sln +++ b/src/libraries/System.IO.MemoryMappedFiles/System.IO.MemoryMappedFiles.sln @@ -13,6 +13,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.IO.MemoryMappedFiles EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{C96C1E8C-7C96-42F8-ABEB-0D17B44F203E}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{069C90AA-EA5C-4112-A964-91F2F617BA62}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{08C7C81E-76EF-49D1-A9AA-CB2E0AB6A913}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{3D0ED921-30AE-4D7C-BFE7-CC4BD0CE9B40}" @@ -81,6 +83,10 @@ Global {C96C1E8C-7C96-42F8-ABEB-0D17B44F203E}.Debug|Any CPU.Build.0 = Debug|Any CPU {C96C1E8C-7C96-42F8-ABEB-0D17B44F203E}.Release|Any CPU.ActiveCfg = Release|Any CPU {C96C1E8C-7C96-42F8-ABEB-0D17B44F203E}.Release|Any CPU.Build.0 = Release|Any CPU + {069C90AA-EA5C-4112-A964-91F2F617BA62}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {069C90AA-EA5C-4112-A964-91F2F617BA62}.Debug|Any CPU.Build.0 = Debug|Any CPU + {069C90AA-EA5C-4112-A964-91F2F617BA62}.Release|Any CPU.ActiveCfg = Release|Any CPU + {069C90AA-EA5C-4112-A964-91F2F617BA62}.Release|Any CPU.Build.0 = Release|Any CPU {08C7C81E-76EF-49D1-A9AA-CB2E0AB6A913}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {08C7C81E-76EF-49D1-A9AA-CB2E0AB6A913}.Debug|Any CPU.Build.0 = Debug|Any CPU {08C7C81E-76EF-49D1-A9AA-CB2E0AB6A913}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -131,6 +137,7 @@ Global {50241163-53A9-458C-9012-2F17E0CAA201} = {E91F427C-6CD7-496B-B4E8-D837CB8B96F8} {4A95E6CD-A466-46BC-A6C7-C65DA45B3388} = {7CDB9185-B436-4B6A-91A2-DD2C30BB49D9} {C96C1E8C-7C96-42F8-ABEB-0D17B44F203E} = {AF9FF36B-5C67-40C3-9BC4-5C8FE09956E2} + {069C90AA-EA5C-4112-A964-91F2F617BA62} = {AF9FF36B-5C67-40C3-9BC4-5C8FE09956E2} {08C7C81E-76EF-49D1-A9AA-CB2E0AB6A913} = {AF9FF36B-5C67-40C3-9BC4-5C8FE09956E2} {3D0ED921-30AE-4D7C-BFE7-CC4BD0CE9B40} = {AF9FF36B-5C67-40C3-9BC4-5C8FE09956E2} {C29327C1-7EF9-4D77-968E-F4AAC9310454} = {615FBB6B-8AEC-4964-9EEB-C79D543B693D} diff --git a/src/libraries/System.IO.MemoryMappedFiles/src/System.IO.MemoryMappedFiles.csproj b/src/libraries/System.IO.MemoryMappedFiles/src/System.IO.MemoryMappedFiles.csproj index 8c7cd9cfdda..1710a652f6d 100644 --- a/src/libraries/System.IO.MemoryMappedFiles/src/System.IO.MemoryMappedFiles.csproj +++ b/src/libraries/System.IO.MemoryMappedFiles/src/System.IO.MemoryMappedFiles.csproj @@ -1,7 +1,7 @@ - $(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-unix;$(NetCoreAppCurrent)-browser;$(NetCoreAppCurrent) + $(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-unix;$(NetCoreAppCurrent)-browser;$(NetCoreAppCurrent)-wasi;$(NetCoreAppCurrent) true false @@ -86,11 +86,13 @@ - + + + diff --git a/src/libraries/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/MemoryMappedFile.Unix.cs b/src/libraries/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/MemoryMappedFile.Unix.cs index 2c49129705d..ae9e24c5722 100644 --- a/src/libraries/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/MemoryMappedFile.Unix.cs +++ b/src/libraries/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/MemoryMappedFile.Unix.cs @@ -162,11 +162,13 @@ private static FileAccess TranslateProtectionsToFileAccess(Interop.Sys.MemoryMap private static SafeFileHandle CreateSharedBackingObject(Interop.Sys.MemoryMappedProtections protections, long capacity, HandleInheritability inheritability) { - return CreateSharedBackingObjectUsingMemory(protections, capacity, inheritability) - ?? CreateSharedBackingObjectUsingFile(protections, capacity, inheritability); + return Interop.Sys.IsMemfdSupported ? + CreateSharedBackingObjectUsingMemoryMemfdCreate(protections, capacity, inheritability) : + CreateSharedBackingObjectUsingMemoryShmOpen(protections, capacity, inheritability) + ?? CreateSharedBackingObjectUsingFile(protections, capacity, inheritability); } - private static SafeFileHandle? CreateSharedBackingObjectUsingMemory( + private static SafeFileHandle? CreateSharedBackingObjectUsingMemoryShmOpen( Interop.Sys.MemoryMappedProtections protections, long capacity, HandleInheritability inheritability) { // Determine the flags to use when creating the shared memory object @@ -244,27 +246,66 @@ private static SafeFileHandle CreateSharedBackingObject(Interop.Sys.MemoryMapped fd.Dispose(); throw; } + } + + private static string GenerateMapName() + { + // macOS shm_open documentation says that the sys-call can fail with ENAMETOOLONG if the name exceeds SHM_NAME_MAX characters. + // The problem is that SHM_NAME_MAX is not defined anywhere and is not consistent amongst macOS versions (arm64 vs x64 for example). + // It was reported in 2008 (https://lists.apple.com/archives/xcode-users/2008/Apr/msg00523.html), + // but considered to be by design (http://web.archive.org/web/20140109200632/http://lists.apple.com/archives/darwin-development/2003/Mar/msg00244.html). + // According to https://github.com/qt/qtbase/blob/1ed449e168af133184633d174fd7339a13d1d595/src/corelib/kernel/qsharedmemory.cpp#L53-L56 the actual value is 30. + // Some other OSS libs use 32 (we did as well, but it was not enough) or 31, but we prefer 30 just to be extra safe. + const int MaxNameLength = 30; + // The POSIX shared memory object name must begin with '/'. After that we just want something short (30) and unique. + const string NamePrefix = "/dotnet_"; + return string.Create(MaxNameLength, 0, (span, state) => + { + Span guid = stackalloc char[32]; + Guid.NewGuid().TryFormat(guid, out int charsWritten, "N"); + Debug.Assert(charsWritten == 32); + NamePrefix.CopyTo(span); + guid.Slice(0, MaxNameLength - NamePrefix.Length).CopyTo(span.Slice(NamePrefix.Length)); + Debug.Assert(Encoding.UTF8.GetByteCount(span) <= MaxNameLength); // the standard uses Utf8 + }); + } + + private static SafeFileHandle CreateSharedBackingObjectUsingMemoryMemfdCreate( + Interop.Sys.MemoryMappedProtections protections, long capacity, HandleInheritability inheritability) + { + int isReadonly = ((protections & Interop.Sys.MemoryMappedProtections.PROT_READ) != 0 && + (protections & Interop.Sys.MemoryMappedProtections.PROT_WRITE) == 0) ? 1 : 0; - static string GenerateMapName() + SafeFileHandle fd = Interop.Sys.MemfdCreate(GenerateMapName(), isReadonly); + if (fd.IsInvalid) { - // macOS shm_open documentation says that the sys-call can fail with ENAMETOOLONG if the name exceeds SHM_NAME_MAX characters. - // The problem is that SHM_NAME_MAX is not defined anywhere and is not consistent amongst macOS versions (arm64 vs x64 for example). - // It was reported in 2008 (https://lists.apple.com/archives/xcode-users/2008/Apr/msg00523.html), - // but considered to be by design (http://web.archive.org/web/20140109200632/http://lists.apple.com/archives/darwin-development/2003/Mar/msg00244.html). - // According to https://github.com/qt/qtbase/blob/1ed449e168af133184633d174fd7339a13d1d595/src/corelib/kernel/qsharedmemory.cpp#L53-L56 the actual value is 30. - // Some other OSS libs use 32 (we did as well, but it was not enough) or 31, but we prefer 30 just to be extra safe. - const int MaxNameLength = 30; - // The POSIX shared memory object name must begin with '/'. After that we just want something short (30) and unique. - const string NamePrefix = "/dotnet_"; - return string.Create(MaxNameLength, 0, (span, state) => + Interop.ErrorInfo errorInfo = Interop.Sys.GetLastErrorInfo(); + fd.Dispose(); + + throw Interop.GetExceptionForIoErrno(errorInfo); + } + + try + { + // Give it the right capacity. We do this directly with ftruncate rather + // than via FileStream.SetLength after the FileStream is created because, on some systems, + // lseek fails on shared memory objects, causing the FileStream to think it's unseekable, + // causing it to preemptively throw from SetLength. + Interop.CheckIo(Interop.Sys.FTruncate(fd, capacity)); + + // SystemNative_MemfdCreate sets CLOEXEC implicitly. If the inheritability requested is Inheritable, remove CLOEXEC. + if (inheritability == HandleInheritability.Inheritable && + Interop.Sys.Fcntl.SetFD(fd, 0) == -1) { - Span guid = stackalloc char[32]; - Guid.NewGuid().TryFormat(guid, out int charsWritten, "N"); - Debug.Assert(charsWritten == 32); - NamePrefix.CopyTo(span); - guid.Slice(0, MaxNameLength - NamePrefix.Length).CopyTo(span.Slice(NamePrefix.Length)); - Debug.Assert(Encoding.UTF8.GetByteCount(span) <= MaxNameLength); // the standard uses Utf8 - }); + throw Interop.GetExceptionForIoErrno(Interop.Sys.GetLastErrorInfo()); + } + + return fd; + } + catch + { + fd.Dispose(); + throw; } } diff --git a/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedFilesTestsBase.Unix.cs b/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedFilesTestsBase.Unix.cs index a985621a958..f9d3cc58d86 100644 --- a/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedFilesTestsBase.Unix.cs +++ b/src/libraries/System.IO.MemoryMappedFiles/tests/MemoryMappedFilesTestsBase.Unix.cs @@ -14,7 +14,7 @@ public abstract partial class MemoryMappedFilesTestBase : FileCleanupTestBase /// Gets the system's page size. protected static Lazy s_pageSize = new Lazy(() => { - if (OperatingSystem.IsBrowser()) + if (OperatingSystem.IsBrowser() || OperatingSystem.IsWasi()) return Environment.SystemPageSize; int pageSize; diff --git a/src/libraries/System.IO.Packaging/System.IO.Packaging.sln b/src/libraries/System.IO.Packaging/System.IO.Packaging.sln index b0b39fab297..684122b7aa4 100644 --- a/src/libraries/System.IO.Packaging/System.IO.Packaging.sln +++ b/src/libraries/System.IO.Packaging/System.IO.Packaging.sln @@ -7,7 +7,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.IO.Packaging", "src\ EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.IO.Packaging.Tests", "tests\System.IO.Packaging.Tests.csproj", "{588B83D6-132B-4399-B31E-4B40CD9CCAE6}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{E58B740D-A353-4D96-857F-0C6898A0BAAB}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{E4981CD0-F5CA-43B7-ACB5-626F27DD3D12}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{5C4BD3D4-565A-4DB3-9AA7-13C0D52B1EE0}" EndProject @@ -59,10 +59,10 @@ Global {588B83D6-132B-4399-B31E-4B40CD9CCAE6}.Debug|Any CPU.Build.0 = Debug|Any CPU {588B83D6-132B-4399-B31E-4B40CD9CCAE6}.Release|Any CPU.ActiveCfg = Release|Any CPU {588B83D6-132B-4399-B31E-4B40CD9CCAE6}.Release|Any CPU.Build.0 = Release|Any CPU - {E58B740D-A353-4D96-857F-0C6898A0BAAB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {E58B740D-A353-4D96-857F-0C6898A0BAAB}.Debug|Any CPU.Build.0 = Debug|Any CPU - {E58B740D-A353-4D96-857F-0C6898A0BAAB}.Release|Any CPU.ActiveCfg = Release|Any CPU - {E58B740D-A353-4D96-857F-0C6898A0BAAB}.Release|Any CPU.Build.0 = Release|Any CPU + {E4981CD0-F5CA-43B7-ACB5-626F27DD3D12}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E4981CD0-F5CA-43B7-ACB5-626F27DD3D12}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E4981CD0-F5CA-43B7-ACB5-626F27DD3D12}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E4981CD0-F5CA-43B7-ACB5-626F27DD3D12}.Release|Any CPU.Build.0 = Release|Any CPU {5C4BD3D4-565A-4DB3-9AA7-13C0D52B1EE0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {5C4BD3D4-565A-4DB3-9AA7-13C0D52B1EE0}.Debug|Any CPU.Build.0 = Debug|Any CPU {5C4BD3D4-565A-4DB3-9AA7-13C0D52B1EE0}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -96,7 +96,7 @@ Global {588B83D6-132B-4399-B31E-4B40CD9CCAE6} = {CDE13DDC-F9E2-4C5F-9379-26E3273B7270} {6EF662E4-9A1E-4DAC-A04B-A1461BB6CA28} = {A31F533C-5EA6-4E97-91B1-C298BE0060E0} {C553FA20-C4C0-48A2-B841-12F2F860E21F} = {A767928D-1A4C-4513-9FF6-CB395D45B6A8} - {E58B740D-A353-4D96-857F-0C6898A0BAAB} = {89942E1D-4F98-4CEF-B275-8A30127462BE} + {E4981CD0-F5CA-43B7-ACB5-626F27DD3D12} = {89942E1D-4F98-4CEF-B275-8A30127462BE} {5C4BD3D4-565A-4DB3-9AA7-13C0D52B1EE0} = {89942E1D-4F98-4CEF-B275-8A30127462BE} {030B7BEE-4BBF-4DDC-B78B-8E9B580E76E9} = {1B2237D8-B3D9-4C88-80C0-35893455C02B} {881F49D0-05B7-4D4C-9E06-C13F5A3B64B7} = {1B2237D8-B3D9-4C88-80C0-35893455C02B} diff --git a/src/libraries/System.IO.Pipelines/System.IO.Pipelines.sln b/src/libraries/System.IO.Pipelines/System.IO.Pipelines.sln index 833b789c6ea..f4fd61e1e72 100644 --- a/src/libraries/System.IO.Pipelines/System.IO.Pipelines.sln +++ b/src/libraries/System.IO.Pipelines/System.IO.Pipelines.sln @@ -11,7 +11,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.IO.Pipelines.Tests", EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Memory", "..\System.Memory\ref\System.Memory.csproj", "{A453B9A0-D2AD-4415-A0B7-0A79C0C637C8}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{EB66BC9F-8895-494C-81CD-5F64A7DA1D4D}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{0785E684-36FD-45EF-84B1-A5A5271D9751}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{1A609A5A-8D99-4849-AF21-BB7510070C49}" EndProject @@ -73,10 +73,10 @@ Global {A453B9A0-D2AD-4415-A0B7-0A79C0C637C8}.Debug|Any CPU.Build.0 = Debug|Any CPU {A453B9A0-D2AD-4415-A0B7-0A79C0C637C8}.Release|Any CPU.ActiveCfg = Release|Any CPU {A453B9A0-D2AD-4415-A0B7-0A79C0C637C8}.Release|Any CPU.Build.0 = Release|Any CPU - {EB66BC9F-8895-494C-81CD-5F64A7DA1D4D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {EB66BC9F-8895-494C-81CD-5F64A7DA1D4D}.Debug|Any CPU.Build.0 = Debug|Any CPU - {EB66BC9F-8895-494C-81CD-5F64A7DA1D4D}.Release|Any CPU.ActiveCfg = Release|Any CPU - {EB66BC9F-8895-494C-81CD-5F64A7DA1D4D}.Release|Any CPU.Build.0 = Release|Any CPU + {0785E684-36FD-45EF-84B1-A5A5271D9751}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {0785E684-36FD-45EF-84B1-A5A5271D9751}.Debug|Any CPU.Build.0 = Debug|Any CPU + {0785E684-36FD-45EF-84B1-A5A5271D9751}.Release|Any CPU.ActiveCfg = Release|Any CPU + {0785E684-36FD-45EF-84B1-A5A5271D9751}.Release|Any CPU.Build.0 = Release|Any CPU {1A609A5A-8D99-4849-AF21-BB7510070C49}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {1A609A5A-8D99-4849-AF21-BB7510070C49}.Debug|Any CPU.Build.0 = Debug|Any CPU {1A609A5A-8D99-4849-AF21-BB7510070C49}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -117,7 +117,7 @@ Global {A453B9A0-D2AD-4415-A0B7-0A79C0C637C8} = {BC2B926D-1416-4330-A62B-EC48667E0E7B} {AC7D4EB1-8E47-47A8-AB05-99E9640B9020} = {BC2B926D-1416-4330-A62B-EC48667E0E7B} {1DD520A2-ED75-4889-848E-DBDC7BE41873} = {0F960DB3-8D87-4D62-BF68-75299FED62F7} - {EB66BC9F-8895-494C-81CD-5F64A7DA1D4D} = {68B6BB77-1325-4BD7-95B1-67ECA89889E8} + {0785E684-36FD-45EF-84B1-A5A5271D9751} = {68B6BB77-1325-4BD7-95B1-67ECA89889E8} {1A609A5A-8D99-4849-AF21-BB7510070C49} = {68B6BB77-1325-4BD7-95B1-67ECA89889E8} {364A0F25-54E3-4B0B-A2E9-123621F19374} = {826BB2FE-0019-4404-A783-6381E099773C} {48BF97DB-A17B-4A8A-9EC4-1650B5517789} = {826BB2FE-0019-4404-A783-6381E099773C} diff --git a/src/libraries/System.IO.Pipes.AccessControl/System.IO.Pipes.AccessControl.sln b/src/libraries/System.IO.Pipes.AccessControl/System.IO.Pipes.AccessControl.sln index 9e3ced82944..1896069ecd2 100644 --- a/src/libraries/System.IO.Pipes.AccessControl/System.IO.Pipes.AccessControl.sln +++ b/src/libraries/System.IO.Pipes.AccessControl/System.IO.Pipes.AccessControl.sln @@ -15,6 +15,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.IO.Pipes", "..\Syste EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{E49FBD77-BB9C-4912-99F8-9E8DB0D17A35}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{6E2431B0-CBB4-447D-BF2C-E20F5F8BF030}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{49F9208B-CEFC-402E-815C-2CF64FD0C85C}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{123AF6E1-60BF-4360-9010-885AB140205F}" @@ -91,6 +93,10 @@ Global {E49FBD77-BB9C-4912-99F8-9E8DB0D17A35}.Debug|Any CPU.Build.0 = Debug|Any CPU {E49FBD77-BB9C-4912-99F8-9E8DB0D17A35}.Release|Any CPU.ActiveCfg = Release|Any CPU {E49FBD77-BB9C-4912-99F8-9E8DB0D17A35}.Release|Any CPU.Build.0 = Release|Any CPU + {6E2431B0-CBB4-447D-BF2C-E20F5F8BF030}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {6E2431B0-CBB4-447D-BF2C-E20F5F8BF030}.Debug|Any CPU.Build.0 = Debug|Any CPU + {6E2431B0-CBB4-447D-BF2C-E20F5F8BF030}.Release|Any CPU.ActiveCfg = Release|Any CPU + {6E2431B0-CBB4-447D-BF2C-E20F5F8BF030}.Release|Any CPU.Build.0 = Release|Any CPU {49F9208B-CEFC-402E-815C-2CF64FD0C85C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {49F9208B-CEFC-402E-815C-2CF64FD0C85C}.Debug|Any CPU.Build.0 = Debug|Any CPU {49F9208B-CEFC-402E-815C-2CF64FD0C85C}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -152,6 +158,7 @@ Global {B6731AC0-E4F2-4E6C-B6DF-63EF396FCB71} = {F8E1D6D4-F8BF-4B79-8E2B-49BFE4145670} {5AE837A0-E966-41E5-9230-0830BB3E727F} = {F8E1D6D4-F8BF-4B79-8E2B-49BFE4145670} {E49FBD77-BB9C-4912-99F8-9E8DB0D17A35} = {EB85C209-FC5D-455A-8BFE-E7B0D9CC48E8} + {6E2431B0-CBB4-447D-BF2C-E20F5F8BF030} = {EB85C209-FC5D-455A-8BFE-E7B0D9CC48E8} {49F9208B-CEFC-402E-815C-2CF64FD0C85C} = {EB85C209-FC5D-455A-8BFE-E7B0D9CC48E8} {123AF6E1-60BF-4360-9010-885AB140205F} = {EB85C209-FC5D-455A-8BFE-E7B0D9CC48E8} {3922D31C-0F73-4E87-BE10-72BF6AF73494} = {BF96303B-6A5C-4F00-B364-8F8ED50D1C75} diff --git a/src/libraries/System.IO.Pipes/Directory.Build.props b/src/libraries/System.IO.Pipes/Directory.Build.props index ce244cbea56..58979d42f06 100644 --- a/src/libraries/System.IO.Pipes/Directory.Build.props +++ b/src/libraries/System.IO.Pipes/Directory.Build.props @@ -3,6 +3,6 @@ Microsoft true - browser + browser;wasi \ No newline at end of file diff --git a/src/libraries/System.IO.Pipes/System.IO.Pipes.sln b/src/libraries/System.IO.Pipes/System.IO.Pipes.sln index ec2bb79cff8..695cd2f1a77 100644 --- a/src/libraries/System.IO.Pipes/System.IO.Pipes.sln +++ b/src/libraries/System.IO.Pipes/System.IO.Pipes.sln @@ -51,6 +51,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.Uri", "..\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{A7AC5643-2743-47AC-9284-718EB5466963}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{7B1E0E70-F63B-4471-9542-4102AADD78E3}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{C1B1DCD9-30B9-4E17-A049-A04DCED30D14}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{D5A2648A-7BA3-4157-9DBF-D7B7D9B937EA}" @@ -673,6 +675,27 @@ Global {A7AC5643-2743-47AC-9284-718EB5466963}.Checked|arm64.ActiveCfg = Debug|Any CPU {A7AC5643-2743-47AC-9284-718EB5466963}.Checked|x64.ActiveCfg = Debug|Any CPU {A7AC5643-2743-47AC-9284-718EB5466963}.Checked|x86.ActiveCfg = Debug|Any CPU + {7B1E0E70-F63B-4471-9542-4102AADD78E3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {7B1E0E70-F63B-4471-9542-4102AADD78E3}.Debug|Any CPU.Build.0 = Debug|Any CPU + {7B1E0E70-F63B-4471-9542-4102AADD78E3}.Debug|arm.ActiveCfg = Debug|Any CPU + {7B1E0E70-F63B-4471-9542-4102AADD78E3}.Debug|arm64.ActiveCfg = Debug|Any CPU + {7B1E0E70-F63B-4471-9542-4102AADD78E3}.Debug|x64.ActiveCfg = Debug|Any CPU + {7B1E0E70-F63B-4471-9542-4102AADD78E3}.Debug|x64.Build.0 = Debug|Any CPU + {7B1E0E70-F63B-4471-9542-4102AADD78E3}.Debug|x86.ActiveCfg = Debug|Any CPU + {7B1E0E70-F63B-4471-9542-4102AADD78E3}.Debug|x86.Build.0 = Debug|Any CPU + {7B1E0E70-F63B-4471-9542-4102AADD78E3}.Release|Any CPU.ActiveCfg = Release|Any CPU + {7B1E0E70-F63B-4471-9542-4102AADD78E3}.Release|Any CPU.Build.0 = Release|Any CPU + {7B1E0E70-F63B-4471-9542-4102AADD78E3}.Release|arm.ActiveCfg = Release|Any CPU + {7B1E0E70-F63B-4471-9542-4102AADD78E3}.Release|arm64.ActiveCfg = Release|Any CPU + {7B1E0E70-F63B-4471-9542-4102AADD78E3}.Release|x64.ActiveCfg = Release|Any CPU + {7B1E0E70-F63B-4471-9542-4102AADD78E3}.Release|x64.Build.0 = Release|Any CPU + {7B1E0E70-F63B-4471-9542-4102AADD78E3}.Release|x86.ActiveCfg = Release|Any CPU + {7B1E0E70-F63B-4471-9542-4102AADD78E3}.Release|x86.Build.0 = Release|Any CPU + {7B1E0E70-F63B-4471-9542-4102AADD78E3}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {7B1E0E70-F63B-4471-9542-4102AADD78E3}.Checked|arm.ActiveCfg = Debug|Any CPU + {7B1E0E70-F63B-4471-9542-4102AADD78E3}.Checked|arm64.ActiveCfg = Debug|Any CPU + {7B1E0E70-F63B-4471-9542-4102AADD78E3}.Checked|x64.ActiveCfg = Debug|Any CPU + {7B1E0E70-F63B-4471-9542-4102AADD78E3}.Checked|x86.ActiveCfg = Debug|Any CPU {C1B1DCD9-30B9-4E17-A049-A04DCED30D14}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {C1B1DCD9-30B9-4E17-A049-A04DCED30D14}.Debug|Any CPU.Build.0 = Debug|Any CPU {C1B1DCD9-30B9-4E17-A049-A04DCED30D14}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -1049,6 +1072,7 @@ Global {724E9C4C-A140-4815-88A4-2934BD67574F} = {B64B7581-6925-4823-B7AF-97FBC53A4146} {B5971A04-44AC-404D-8A58-F85C61F53244} = {FE4693B5-3585-4555-BABA-A8BE2AA9C85E} {A7AC5643-2743-47AC-9284-718EB5466963} = {FE4693B5-3585-4555-BABA-A8BE2AA9C85E} + {7B1E0E70-F63B-4471-9542-4102AADD78E3} = {FE4693B5-3585-4555-BABA-A8BE2AA9C85E} {C1B1DCD9-30B9-4E17-A049-A04DCED30D14} = {FE4693B5-3585-4555-BABA-A8BE2AA9C85E} {D5A2648A-7BA3-4157-9DBF-D7B7D9B937EA} = {FE4693B5-3585-4555-BABA-A8BE2AA9C85E} {965BE455-6D8C-43F7-9C0F-22C223D680ED} = {022B84D6-4F09-4371-9611-16DC2C968CBF} diff --git a/src/libraries/System.IO.Ports/System.IO.Ports.sln b/src/libraries/System.IO.Ports/System.IO.Ports.sln index fe2d90999b1..56ce01ae1be 100644 --- a/src/libraries/System.IO.Ports/System.IO.Ports.sln +++ b/src/libraries/System.IO.Ports/System.IO.Ports.sln @@ -43,6 +43,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.IO.Ports.Tests", "te EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{28396A85-9215-4366-A582-B03BB13A60DD}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{9863BCB5-F48F-4C2D-B9B5-2653194D8F05}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{AAB67274-550C-40C2-92EA-38C12CC2060F}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{094F1156-D8B8-420C-945C-B74E1454B6E5}" @@ -173,6 +175,10 @@ Global {28396A85-9215-4366-A582-B03BB13A60DD}.Debug|Any CPU.Build.0 = Debug|Any CPU {28396A85-9215-4366-A582-B03BB13A60DD}.Release|Any CPU.ActiveCfg = Release|Any CPU {28396A85-9215-4366-A582-B03BB13A60DD}.Release|Any CPU.Build.0 = Release|Any CPU + {9863BCB5-F48F-4C2D-B9B5-2653194D8F05}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {9863BCB5-F48F-4C2D-B9B5-2653194D8F05}.Debug|Any CPU.Build.0 = Debug|Any CPU + {9863BCB5-F48F-4C2D-B9B5-2653194D8F05}.Release|Any CPU.ActiveCfg = Release|Any CPU + {9863BCB5-F48F-4C2D-B9B5-2653194D8F05}.Release|Any CPU.Build.0 = Release|Any CPU {AAB67274-550C-40C2-92EA-38C12CC2060F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {AAB67274-550C-40C2-92EA-38C12CC2060F}.Debug|Any CPU.Build.0 = Debug|Any CPU {AAB67274-550C-40C2-92EA-38C12CC2060F}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -243,6 +249,7 @@ Global {0EA6D26C-165C-46EB-9734-0E240BCBAB4F} = {88B0C0E7-B79E-4DFD-9A65-C3F506507924} {08EC7EC2-BAE3-4E9D-AD50-14DBFFBC4154} = {88B0C0E7-B79E-4DFD-9A65-C3F506507924} {28396A85-9215-4366-A582-B03BB13A60DD} = {B86A1AC4-AE98-45BB-8548-2C369188D58A} + {9863BCB5-F48F-4C2D-B9B5-2653194D8F05} = {B86A1AC4-AE98-45BB-8548-2C369188D58A} {AAB67274-550C-40C2-92EA-38C12CC2060F} = {B86A1AC4-AE98-45BB-8548-2C369188D58A} {094F1156-D8B8-420C-945C-B74E1454B6E5} = {B86A1AC4-AE98-45BB-8548-2C369188D58A} {3A90724E-B199-4B0A-BB38-FA926A100A6A} = {B33FCFE9-427F-4E06-BE22-E168E76CF56C} diff --git a/src/libraries/System.IO.Ports/pkg/runtime.native.System.IO.Ports.props b/src/libraries/System.IO.Ports/pkg/runtime.native.System.IO.Ports.props index f065856b06f..93530393486 100644 --- a/src/libraries/System.IO.Ports/pkg/runtime.native.System.IO.Ports.props +++ b/src/libraries/System.IO.Ports/pkg/runtime.native.System.IO.Ports.props @@ -17,12 +17,30 @@ $(MSBuildThisFileDirectory)../src/PACKAGE.md + + + + + + + + + + + + + + GetDynamicMemberNames() { throw null; } } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Creating a call site may require dynamic code generation.")] public abstract partial class DynamicMetaObjectBinder : System.Runtime.CompilerServices.CallSiteBinder { protected DynamicMetaObjectBinder() { } @@ -109,6 +115,7 @@ protected DynamicMetaObjectBinder() { } public System.Dynamic.DynamicMetaObject Defer(params System.Dynamic.DynamicMetaObject[] args) { throw null; } public System.Linq.Expressions.Expression GetUpdateExpression(System.Type type) { throw null; } } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Creating a call site may require dynamic code generation.")] public partial class DynamicObject : System.Dynamic.IDynamicMetaObjectProvider { protected DynamicObject() { } @@ -149,6 +156,7 @@ event System.ComponentModel.PropertyChangedEventHandler? System.ComponentModel.I System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; } System.Dynamic.DynamicMetaObject System.Dynamic.IDynamicMetaObjectProvider.GetMetaObject(System.Linq.Expressions.Expression parameter) { throw null; } } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Creating a call site may require dynamic code generation.")] public abstract partial class GetIndexBinder : System.Dynamic.DynamicMetaObjectBinder { protected GetIndexBinder(System.Dynamic.CallInfo callInfo) { } @@ -158,6 +166,7 @@ protected GetIndexBinder(System.Dynamic.CallInfo callInfo) { } public System.Dynamic.DynamicMetaObject FallbackGetIndex(System.Dynamic.DynamicMetaObject target, System.Dynamic.DynamicMetaObject[] indexes) { throw null; } public abstract System.Dynamic.DynamicMetaObject FallbackGetIndex(System.Dynamic.DynamicMetaObject target, System.Dynamic.DynamicMetaObject[] indexes, System.Dynamic.DynamicMetaObject? errorSuggestion); } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Creating a call site may require dynamic code generation.")] public abstract partial class GetMemberBinder : System.Dynamic.DynamicMetaObjectBinder { protected GetMemberBinder(string name, bool ignoreCase) { } @@ -176,6 +185,7 @@ public partial interface IInvokeOnGetBinder { bool InvokeOnGet { get; } } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Creating a call site may require dynamic code generation.")] public abstract partial class InvokeBinder : System.Dynamic.DynamicMetaObjectBinder { protected InvokeBinder(System.Dynamic.CallInfo callInfo) { } @@ -185,6 +195,7 @@ protected InvokeBinder(System.Dynamic.CallInfo callInfo) { } public System.Dynamic.DynamicMetaObject FallbackInvoke(System.Dynamic.DynamicMetaObject target, System.Dynamic.DynamicMetaObject[] args) { throw null; } public abstract System.Dynamic.DynamicMetaObject FallbackInvoke(System.Dynamic.DynamicMetaObject target, System.Dynamic.DynamicMetaObject[] args, System.Dynamic.DynamicMetaObject? errorSuggestion); } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Creating a call site may require dynamic code generation.")] public abstract partial class InvokeMemberBinder : System.Dynamic.DynamicMetaObjectBinder { protected InvokeMemberBinder(string name, bool ignoreCase, System.Dynamic.CallInfo callInfo) { } @@ -197,6 +208,7 @@ protected InvokeMemberBinder(string name, bool ignoreCase, System.Dynamic.CallIn public System.Dynamic.DynamicMetaObject FallbackInvokeMember(System.Dynamic.DynamicMetaObject target, System.Dynamic.DynamicMetaObject[] args) { throw null; } public abstract System.Dynamic.DynamicMetaObject FallbackInvokeMember(System.Dynamic.DynamicMetaObject target, System.Dynamic.DynamicMetaObject[] args, System.Dynamic.DynamicMetaObject? errorSuggestion); } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Creating a call site may require dynamic code generation.")] public abstract partial class SetIndexBinder : System.Dynamic.DynamicMetaObjectBinder { protected SetIndexBinder(System.Dynamic.CallInfo callInfo) { } @@ -206,6 +218,7 @@ protected SetIndexBinder(System.Dynamic.CallInfo callInfo) { } public System.Dynamic.DynamicMetaObject FallbackSetIndex(System.Dynamic.DynamicMetaObject target, System.Dynamic.DynamicMetaObject[] indexes, System.Dynamic.DynamicMetaObject value) { throw null; } public abstract System.Dynamic.DynamicMetaObject FallbackSetIndex(System.Dynamic.DynamicMetaObject target, System.Dynamic.DynamicMetaObject[] indexes, System.Dynamic.DynamicMetaObject value, System.Dynamic.DynamicMetaObject? errorSuggestion); } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Creating a call site may require dynamic code generation.")] public abstract partial class SetMemberBinder : System.Dynamic.DynamicMetaObjectBinder { protected SetMemberBinder(string name, bool ignoreCase) { } @@ -216,6 +229,7 @@ protected SetMemberBinder(string name, bool ignoreCase) { } public System.Dynamic.DynamicMetaObject FallbackSetMember(System.Dynamic.DynamicMetaObject target, System.Dynamic.DynamicMetaObject value) { throw null; } public abstract System.Dynamic.DynamicMetaObject FallbackSetMember(System.Dynamic.DynamicMetaObject target, System.Dynamic.DynamicMetaObject value, System.Dynamic.DynamicMetaObject? errorSuggestion); } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Creating a call site may require dynamic code generation.")] public abstract partial class UnaryOperationBinder : System.Dynamic.DynamicMetaObjectBinder { protected UnaryOperationBinder(System.Linq.Expressions.ExpressionType operation) { } @@ -337,12 +351,19 @@ internal DynamicExpression() { } int System.Linq.Expressions.IArgumentProvider.ArgumentCount { get { throw null; } } public override System.Type Type { get { throw null; } } protected internal override System.Linq.Expressions.Expression Accept(System.Linq.Expressions.ExpressionVisitor visitor) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static new System.Linq.Expressions.DynamicExpression Dynamic(System.Runtime.CompilerServices.CallSiteBinder binder, System.Type returnType, System.Collections.Generic.IEnumerable arguments) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static new System.Linq.Expressions.DynamicExpression Dynamic(System.Runtime.CompilerServices.CallSiteBinder binder, System.Type returnType, System.Linq.Expressions.Expression arg0) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static new System.Linq.Expressions.DynamicExpression Dynamic(System.Runtime.CompilerServices.CallSiteBinder binder, System.Type returnType, System.Linq.Expressions.Expression arg0, System.Linq.Expressions.Expression arg1) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static new System.Linq.Expressions.DynamicExpression Dynamic(System.Runtime.CompilerServices.CallSiteBinder binder, System.Type returnType, System.Linq.Expressions.Expression arg0, System.Linq.Expressions.Expression arg1, System.Linq.Expressions.Expression arg2) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static new System.Linq.Expressions.DynamicExpression Dynamic(System.Runtime.CompilerServices.CallSiteBinder binder, System.Type returnType, System.Linq.Expressions.Expression arg0, System.Linq.Expressions.Expression arg1, System.Linq.Expressions.Expression arg2, System.Linq.Expressions.Expression arg3) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static new System.Linq.Expressions.DynamicExpression Dynamic(System.Runtime.CompilerServices.CallSiteBinder binder, System.Type returnType, params System.Linq.Expressions.Expression[] arguments) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static new System.Linq.Expressions.DynamicExpression MakeDynamic(System.Type delegateType, System.Runtime.CompilerServices.CallSiteBinder binder, System.Collections.Generic.IEnumerable? arguments) { throw null; } public static new System.Linq.Expressions.DynamicExpression MakeDynamic(System.Type delegateType, System.Runtime.CompilerServices.CallSiteBinder binder, System.Linq.Expressions.Expression arg0) { throw null; } public static new System.Linq.Expressions.DynamicExpression MakeDynamic(System.Type delegateType, System.Runtime.CompilerServices.CallSiteBinder binder, System.Linq.Expressions.Expression arg0, System.Linq.Expressions.Expression arg1) { throw null; } @@ -426,6 +447,7 @@ protected Expression(System.Linq.Expressions.ExpressionType nodeType, System.Typ public static System.Linq.Expressions.MethodCallExpression Call(System.Linq.Expressions.Expression? instance, System.Reflection.MethodInfo method, System.Linq.Expressions.Expression arg0, System.Linq.Expressions.Expression arg1) { throw null; } public static System.Linq.Expressions.MethodCallExpression Call(System.Linq.Expressions.Expression? instance, System.Reflection.MethodInfo method, System.Linq.Expressions.Expression arg0, System.Linq.Expressions.Expression arg1, System.Linq.Expressions.Expression arg2) { throw null; } public static System.Linq.Expressions.MethodCallExpression Call(System.Linq.Expressions.Expression? instance, System.Reflection.MethodInfo method, params System.Linq.Expressions.Expression[]? arguments) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Calling a generic method requires dynamic code generation. This can be suppressed if the method is not generic.")] [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Creating Expressions requires unreferenced code because the members being referenced by the Expression may be trimmed.")] public static System.Linq.Expressions.MethodCallExpression Call(System.Linq.Expressions.Expression instance, string methodName, System.Type[]? typeArguments, params System.Linq.Expressions.Expression[]? arguments) { throw null; } public static System.Linq.Expressions.MethodCallExpression Call(System.Reflection.MethodInfo method, System.Collections.Generic.IEnumerable? arguments) { throw null; } @@ -435,6 +457,7 @@ protected Expression(System.Linq.Expressions.ExpressionType nodeType, System.Typ public static System.Linq.Expressions.MethodCallExpression Call(System.Reflection.MethodInfo method, System.Linq.Expressions.Expression arg0, System.Linq.Expressions.Expression arg1, System.Linq.Expressions.Expression arg2, System.Linq.Expressions.Expression arg3) { throw null; } public static System.Linq.Expressions.MethodCallExpression Call(System.Reflection.MethodInfo method, System.Linq.Expressions.Expression arg0, System.Linq.Expressions.Expression arg1, System.Linq.Expressions.Expression arg2, System.Linq.Expressions.Expression arg3, System.Linq.Expressions.Expression arg4) { throw null; } public static System.Linq.Expressions.MethodCallExpression Call(System.Reflection.MethodInfo method, params System.Linq.Expressions.Expression[]? arguments) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Calling a generic method requires dynamic code generation. This can be suppressed if the method is not generic.")] [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Calling a generic method cannot be statically analyzed. It's not possible to guarantee the availability of requirements of the generic method. This can be suppressed if the method is not generic.")] public static System.Linq.Expressions.MethodCallExpression Call([System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicMethods | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)] System.Type type, string methodName, System.Type[]? typeArguments, params System.Linq.Expressions.Expression[]? arguments) { throw null; } public static System.Linq.Expressions.CatchBlock Catch(System.Linq.Expressions.ParameterExpression variable, System.Linq.Expressions.Expression body) { throw null; } @@ -463,11 +486,17 @@ protected Expression(System.Linq.Expressions.ExpressionType nodeType, System.Typ public static System.Linq.Expressions.BinaryExpression DivideAssign(System.Linq.Expressions.Expression left, System.Linq.Expressions.Expression right) { throw null; } public static System.Linq.Expressions.BinaryExpression DivideAssign(System.Linq.Expressions.Expression left, System.Linq.Expressions.Expression right, System.Reflection.MethodInfo? method) { throw null; } public static System.Linq.Expressions.BinaryExpression DivideAssign(System.Linq.Expressions.Expression left, System.Linq.Expressions.Expression right, System.Reflection.MethodInfo? method, System.Linq.Expressions.LambdaExpression? conversion) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static System.Linq.Expressions.DynamicExpression Dynamic(System.Runtime.CompilerServices.CallSiteBinder binder, System.Type returnType, System.Collections.Generic.IEnumerable arguments) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static System.Linq.Expressions.DynamicExpression Dynamic(System.Runtime.CompilerServices.CallSiteBinder binder, System.Type returnType, System.Linq.Expressions.Expression arg0) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static System.Linq.Expressions.DynamicExpression Dynamic(System.Runtime.CompilerServices.CallSiteBinder binder, System.Type returnType, System.Linq.Expressions.Expression arg0, System.Linq.Expressions.Expression arg1) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static System.Linq.Expressions.DynamicExpression Dynamic(System.Runtime.CompilerServices.CallSiteBinder binder, System.Type returnType, System.Linq.Expressions.Expression arg0, System.Linq.Expressions.Expression arg1, System.Linq.Expressions.Expression arg2) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static System.Linq.Expressions.DynamicExpression Dynamic(System.Runtime.CompilerServices.CallSiteBinder binder, System.Type returnType, System.Linq.Expressions.Expression arg0, System.Linq.Expressions.Expression arg1, System.Linq.Expressions.Expression arg2, System.Linq.Expressions.Expression arg3) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static System.Linq.Expressions.DynamicExpression Dynamic(System.Runtime.CompilerServices.CallSiteBinder binder, System.Type returnType, params System.Linq.Expressions.Expression[] arguments) { throw null; } public static System.Linq.Expressions.ElementInit ElementInit(System.Reflection.MethodInfo addMethod, System.Collections.Generic.IEnumerable arguments) { throw null; } public static System.Linq.Expressions.ElementInit ElementInit(System.Reflection.MethodInfo addMethod, params System.Linq.Expressions.Expression[] arguments) { throw null; } @@ -483,8 +512,11 @@ protected Expression(System.Linq.Expressions.ExpressionType nodeType, System.Typ [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Creating Expressions requires unreferenced code because the members being referenced by the Expression may be trimmed.")] public static System.Linq.Expressions.MemberExpression Field(System.Linq.Expressions.Expression expression, string fieldName) { throw null; } public static System.Linq.Expressions.MemberExpression Field(System.Linq.Expressions.Expression? expression, [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicFields | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields)] System.Type type, string fieldName) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static System.Type GetActionType(params System.Type[]? typeArgs) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static System.Type GetDelegateType(params System.Type[] typeArgs) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static System.Type GetFuncType(params System.Type[]? typeArgs) { throw null; } public static System.Linq.Expressions.GotoExpression Goto(System.Linq.Expressions.LabelTarget target) { throw null; } public static System.Linq.Expressions.GotoExpression Goto(System.Linq.Expressions.LabelTarget target, System.Linq.Expressions.Expression? value) { throw null; } @@ -510,11 +542,17 @@ protected Expression(System.Linq.Expressions.ExpressionType nodeType, System.Typ public static System.Linq.Expressions.LabelTarget Label(string? name) { throw null; } public static System.Linq.Expressions.LabelTarget Label(System.Type type) { throw null; } public static System.Linq.Expressions.LabelTarget Label(System.Type type, string? name) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static System.Linq.Expressions.LambdaExpression Lambda(System.Linq.Expressions.Expression body, bool tailCall, System.Collections.Generic.IEnumerable? parameters) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static System.Linq.Expressions.LambdaExpression Lambda(System.Linq.Expressions.Expression body, bool tailCall, params System.Linq.Expressions.ParameterExpression[]? parameters) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static System.Linq.Expressions.LambdaExpression Lambda(System.Linq.Expressions.Expression body, System.Collections.Generic.IEnumerable? parameters) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static System.Linq.Expressions.LambdaExpression Lambda(System.Linq.Expressions.Expression body, params System.Linq.Expressions.ParameterExpression[]? parameters) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static System.Linq.Expressions.LambdaExpression Lambda(System.Linq.Expressions.Expression body, string? name, bool tailCall, System.Collections.Generic.IEnumerable? parameters) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static System.Linq.Expressions.LambdaExpression Lambda(System.Linq.Expressions.Expression body, string? name, System.Collections.Generic.IEnumerable? parameters) { throw null; } public static System.Linq.Expressions.LambdaExpression Lambda(System.Type delegateType, System.Linq.Expressions.Expression body, bool tailCall, System.Collections.Generic.IEnumerable? parameters) { throw null; } public static System.Linq.Expressions.LambdaExpression Lambda(System.Type delegateType, System.Linq.Expressions.Expression body, bool tailCall, params System.Linq.Expressions.ParameterExpression[]? parameters) { throw null; } @@ -544,13 +582,17 @@ protected Expression(System.Linq.Expressions.ExpressionType nodeType, System.Typ [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("The Property metadata or other accessor may be trimmed.")] public static System.Linq.Expressions.MemberListBinding ListBind(System.Reflection.MethodInfo propertyAccessor, params System.Linq.Expressions.ElementInit[] initializers) { throw null; } public static System.Linq.Expressions.ListInitExpression ListInit(System.Linq.Expressions.NewExpression newExpression, System.Collections.Generic.IEnumerable initializers) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Calling a generic method requires dynamic code generation. This can be suppressed if the method is not generic.")] [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Creating Expressions requires unreferenced code because the members being referenced by the Expression may be trimmed.")] public static System.Linq.Expressions.ListInitExpression ListInit(System.Linq.Expressions.NewExpression newExpression, System.Collections.Generic.IEnumerable initializers) { throw null; } public static System.Linq.Expressions.ListInitExpression ListInit(System.Linq.Expressions.NewExpression newExpression, params System.Linq.Expressions.ElementInit[] initializers) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Calling a generic method requires dynamic code generation. This can be suppressed if the method is not generic.")] [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Creating Expressions requires unreferenced code because the members being referenced by the Expression may be trimmed.")] public static System.Linq.Expressions.ListInitExpression ListInit(System.Linq.Expressions.NewExpression newExpression, params System.Linq.Expressions.Expression[] initializers) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Calling a generic method requires dynamic code generation. This can be suppressed if the method is not generic.")] [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Creating Expressions requires unreferenced code because the members being referenced by the Expression may be trimmed.")] public static System.Linq.Expressions.ListInitExpression ListInit(System.Linq.Expressions.NewExpression newExpression, System.Reflection.MethodInfo? addMethod, System.Collections.Generic.IEnumerable initializers) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Calling a generic method requires dynamic code generation. This can be suppressed if the method is not generic.")] [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("Creating Expressions requires unreferenced code because the members being referenced by the Expression may be trimmed.")] public static System.Linq.Expressions.ListInitExpression ListInit(System.Linq.Expressions.NewExpression newExpression, System.Reflection.MethodInfo? addMethod, params System.Linq.Expressions.Expression[] initializers) { throw null; } public static System.Linq.Expressions.LoopExpression Loop(System.Linq.Expressions.Expression body) { throw null; } @@ -560,11 +602,17 @@ protected Expression(System.Linq.Expressions.ExpressionType nodeType, System.Typ public static System.Linq.Expressions.BinaryExpression MakeBinary(System.Linq.Expressions.ExpressionType binaryType, System.Linq.Expressions.Expression left, System.Linq.Expressions.Expression right, bool liftToNull, System.Reflection.MethodInfo? method) { throw null; } public static System.Linq.Expressions.BinaryExpression MakeBinary(System.Linq.Expressions.ExpressionType binaryType, System.Linq.Expressions.Expression left, System.Linq.Expressions.Expression right, bool liftToNull, System.Reflection.MethodInfo? method, System.Linq.Expressions.LambdaExpression? conversion) { throw null; } public static System.Linq.Expressions.CatchBlock MakeCatchBlock(System.Type type, System.Linq.Expressions.ParameterExpression? variable, System.Linq.Expressions.Expression body, System.Linq.Expressions.Expression? filter) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static System.Linq.Expressions.DynamicExpression MakeDynamic(System.Type delegateType, System.Runtime.CompilerServices.CallSiteBinder binder, System.Collections.Generic.IEnumerable? arguments) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static System.Linq.Expressions.DynamicExpression MakeDynamic(System.Type delegateType, System.Runtime.CompilerServices.CallSiteBinder binder, System.Linq.Expressions.Expression arg0) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static System.Linq.Expressions.DynamicExpression MakeDynamic(System.Type delegateType, System.Runtime.CompilerServices.CallSiteBinder binder, System.Linq.Expressions.Expression arg0, System.Linq.Expressions.Expression arg1) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static System.Linq.Expressions.DynamicExpression MakeDynamic(System.Type delegateType, System.Runtime.CompilerServices.CallSiteBinder binder, System.Linq.Expressions.Expression arg0, System.Linq.Expressions.Expression arg1, System.Linq.Expressions.Expression arg2) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static System.Linq.Expressions.DynamicExpression MakeDynamic(System.Type delegateType, System.Runtime.CompilerServices.CallSiteBinder binder, System.Linq.Expressions.Expression arg0, System.Linq.Expressions.Expression arg1, System.Linq.Expressions.Expression arg2, System.Linq.Expressions.Expression arg3) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static System.Linq.Expressions.DynamicExpression MakeDynamic(System.Type delegateType, System.Runtime.CompilerServices.CallSiteBinder binder, params System.Linq.Expressions.Expression[]? arguments) { throw null; } public static System.Linq.Expressions.GotoExpression MakeGoto(System.Linq.Expressions.GotoExpressionKind kind, System.Linq.Expressions.LabelTarget target, System.Linq.Expressions.Expression? value, System.Type type) { throw null; } public static System.Linq.Expressions.IndexExpression MakeIndex(System.Linq.Expressions.Expression instance, System.Reflection.PropertyInfo? indexer, System.Collections.Generic.IEnumerable? arguments) { throw null; } @@ -607,13 +655,13 @@ protected Expression(System.Linq.Expressions.ExpressionType nodeType, System.Typ public static System.Linq.Expressions.NewExpression New(System.Reflection.ConstructorInfo constructor, System.Collections.Generic.IEnumerable? arguments, params System.Reflection.MemberInfo[]? members) { throw null; } public static System.Linq.Expressions.NewExpression New(System.Reflection.ConstructorInfo constructor, params System.Linq.Expressions.Expression[]? arguments) { throw null; } public static System.Linq.Expressions.NewExpression New([System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicConstructors | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicConstructors)] System.Type type) { throw null; } - [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating arrays at runtime requires dynamic code generation.")] + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Creating arrays at runtime requires dynamic code generation.")] public static System.Linq.Expressions.NewArrayExpression NewArrayBounds(System.Type type, System.Collections.Generic.IEnumerable bounds) { throw null; } - [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating arrays at runtime requires dynamic code generation.")] + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Creating arrays at runtime requires dynamic code generation.")] public static System.Linq.Expressions.NewArrayExpression NewArrayBounds(System.Type type, params System.Linq.Expressions.Expression[] bounds) { throw null; } - [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating arrays at runtime requires dynamic code generation.")] + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Creating arrays at runtime requires dynamic code generation.")] public static System.Linq.Expressions.NewArrayExpression NewArrayInit(System.Type type, System.Collections.Generic.IEnumerable initializers) { throw null; } - [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating arrays at runtime requires dynamic code generation.")] + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Creating arrays at runtime requires dynamic code generation.")] public static System.Linq.Expressions.NewArrayExpression NewArrayInit(System.Type type, params System.Linq.Expressions.Expression[] initializers) { throw null; } public static System.Linq.Expressions.UnaryExpression Not(System.Linq.Expressions.Expression expression) { throw null; } public static System.Linq.Expressions.UnaryExpression Not(System.Linq.Expressions.Expression expression, System.Reflection.MethodInfo? method) { throw null; } @@ -703,7 +751,9 @@ protected Expression(System.Linq.Expressions.ExpressionType nodeType, System.Typ public static System.Linq.Expressions.TryExpression TryCatchFinally(System.Linq.Expressions.Expression body, System.Linq.Expressions.Expression? @finally, params System.Linq.Expressions.CatchBlock[]? handlers) { throw null; } public static System.Linq.Expressions.TryExpression TryFault(System.Linq.Expressions.Expression body, System.Linq.Expressions.Expression? fault) { throw null; } public static System.Linq.Expressions.TryExpression TryFinally(System.Linq.Expressions.Expression body, System.Linq.Expressions.Expression? @finally) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static bool TryGetActionType(System.Type[] typeArgs, [System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] out System.Type? actionType) { throw null; } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Delegate creation requires dynamic code generation.")] public static bool TryGetFuncType(System.Type[] typeArgs, [System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] out System.Type? funcType) { throw null; } public static System.Linq.Expressions.UnaryExpression TypeAs(System.Linq.Expressions.Expression expression, System.Type type) { throw null; } public static System.Linq.Expressions.TypeBinaryExpression TypeEqual(System.Linq.Expressions.Expression expression, System.Type type) { throw null; } @@ -1032,7 +1082,7 @@ internal MethodCallExpression() { } System.Linq.Expressions.Expression System.Linq.Expressions.IArgumentProvider.GetArgument(int index) { throw null; } public System.Linq.Expressions.MethodCallExpression Update(System.Linq.Expressions.Expression? @object, System.Collections.Generic.IEnumerable? arguments) { throw null; } } - [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Creating arrays at runtime requires dynamic code generation.")] + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Creating arrays at runtime requires dynamic code generation.")] public partial class NewArrayExpression : System.Linq.Expressions.Expression { internal NewArrayExpression() { } @@ -1162,6 +1212,7 @@ public partial class CallSite : System.Runtime.CompilerServices.CallSite wher internal CallSite() { } public T Target; public T Update { get { throw null; } } + [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("Creating arrays at runtime requires dynamic code generation.")] public static System.Runtime.CompilerServices.CallSite Create(System.Runtime.CompilerServices.CallSiteBinder binder) { throw null; } } public abstract partial class DebugInfoGenerator diff --git a/src/libraries/System.Linq.Expressions/src/CompatibilitySuppressions.xml b/src/libraries/System.Linq.Expressions/src/CompatibilitySuppressions.xml index 2524d0e9645..d43c6bf4e77 100644 --- a/src/libraries/System.Linq.Expressions/src/CompatibilitySuppressions.xml +++ b/src/libraries/System.Linq.Expressions/src/CompatibilitySuppressions.xml @@ -97,312 +97,6 @@ ref/net9.0/System.Linq.Expressions.dll lib/net9.0/System.Linq.Expressions.dll - - CP0016 - M:System.Linq.Expressions.DynamicExpression.Dynamic(System.Runtime.CompilerServices.CallSiteBinder,System.Type,System.Collections.Generic.IEnumerable{System.Linq.Expressions.Expression}):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.DynamicExpression.Dynamic(System.Runtime.CompilerServices.CallSiteBinder,System.Type,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.DynamicExpression.Dynamic(System.Runtime.CompilerServices.CallSiteBinder,System.Type,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.DynamicExpression.Dynamic(System.Runtime.CompilerServices.CallSiteBinder,System.Type,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.DynamicExpression.Dynamic(System.Runtime.CompilerServices.CallSiteBinder,System.Type,System.Linq.Expressions.Expression):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.DynamicExpression.Dynamic(System.Runtime.CompilerServices.CallSiteBinder,System.Type,System.Linq.Expressions.Expression[]):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.DynamicExpression.MakeDynamic(System.Type,System.Runtime.CompilerServices.CallSiteBinder,System.Collections.Generic.IEnumerable{System.Linq.Expressions.Expression}):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.Call(System.Linq.Expressions.Expression,System.String,System.Type[],System.Linq.Expressions.Expression[]):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.Call(System.Type,System.String,System.Type[],System.Linq.Expressions.Expression[]):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.Dynamic(System.Runtime.CompilerServices.CallSiteBinder,System.Type,System.Collections.Generic.IEnumerable{System.Linq.Expressions.Expression}):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.Dynamic(System.Runtime.CompilerServices.CallSiteBinder,System.Type,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.Dynamic(System.Runtime.CompilerServices.CallSiteBinder,System.Type,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.Dynamic(System.Runtime.CompilerServices.CallSiteBinder,System.Type,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.Dynamic(System.Runtime.CompilerServices.CallSiteBinder,System.Type,System.Linq.Expressions.Expression):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.Dynamic(System.Runtime.CompilerServices.CallSiteBinder,System.Type,System.Linq.Expressions.Expression[]):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.GetActionType(System.Type[]):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.GetDelegateType(System.Type[]):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.GetFuncType(System.Type[]):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.Lambda(System.Linq.Expressions.Expression,System.Boolean,System.Collections.Generic.IEnumerable{System.Linq.Expressions.ParameterExpression}):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.Lambda(System.Linq.Expressions.Expression,System.Boolean,System.Linq.Expressions.ParameterExpression[]):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.Lambda(System.Linq.Expressions.Expression,System.Collections.Generic.IEnumerable{System.Linq.Expressions.ParameterExpression}):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.Lambda(System.Linq.Expressions.Expression,System.Linq.Expressions.ParameterExpression[]):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.Lambda(System.Linq.Expressions.Expression,System.String,System.Boolean,System.Collections.Generic.IEnumerable{System.Linq.Expressions.ParameterExpression}):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.Lambda(System.Linq.Expressions.Expression,System.String,System.Collections.Generic.IEnumerable{System.Linq.Expressions.ParameterExpression}):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.ListInit(System.Linq.Expressions.NewExpression,System.Collections.Generic.IEnumerable{System.Linq.Expressions.Expression}):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.ListInit(System.Linq.Expressions.NewExpression,System.Linq.Expressions.Expression[]):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.ListInit(System.Linq.Expressions.NewExpression,System.Reflection.MethodInfo,System.Collections.Generic.IEnumerable{System.Linq.Expressions.Expression}):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.ListInit(System.Linq.Expressions.NewExpression,System.Reflection.MethodInfo,System.Linq.Expressions.Expression[]):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.MakeDynamic(System.Type,System.Runtime.CompilerServices.CallSiteBinder,System.Collections.Generic.IEnumerable{System.Linq.Expressions.Expression}):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.MakeDynamic(System.Type,System.Runtime.CompilerServices.CallSiteBinder,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.MakeDynamic(System.Type,System.Runtime.CompilerServices.CallSiteBinder,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.MakeDynamic(System.Type,System.Runtime.CompilerServices.CallSiteBinder,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.MakeDynamic(System.Type,System.Runtime.CompilerServices.CallSiteBinder,System.Linq.Expressions.Expression):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.MakeDynamic(System.Type,System.Runtime.CompilerServices.CallSiteBinder,System.Linq.Expressions.Expression[]):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.TryGetActionType(System.Type[],System.Type@):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Linq.Expressions.Expression.TryGetFuncType(System.Type[],System.Type@):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - M:System.Runtime.CompilerServices.CallSite`1.Create(System.Runtime.CompilerServices.CallSiteBinder):[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - T:System.Dynamic.BinaryOperationBinder:[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - T:System.Dynamic.ConvertBinder:[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - T:System.Dynamic.CreateInstanceBinder:[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - T:System.Dynamic.DeleteIndexBinder:[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - T:System.Dynamic.DeleteMemberBinder:[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - T:System.Dynamic.DynamicMetaObjectBinder:[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - T:System.Dynamic.DynamicObject:[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - T:System.Dynamic.GetIndexBinder:[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - T:System.Dynamic.GetMemberBinder:[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - T:System.Dynamic.InvokeBinder:[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - T:System.Dynamic.InvokeMemberBinder:[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - T:System.Dynamic.SetIndexBinder:[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - T:System.Dynamic.SetMemberBinder:[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - - - CP0016 - T:System.Dynamic.UnaryOperationBinder:[T:System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute] - ref/net9.0/System.Linq.Expressions.dll - lib/net9.0/System.Linq.Expressions.dll - CP0020 M:System.Linq.Expressions.DynamicExpressionVisitor.#ctor diff --git a/src/libraries/System.Linq.Expressions/src/ILLink/ILLink.Substitutions.xml b/src/libraries/System.Linq.Expressions/src/ILLink/ILLink.Substitutions.xml deleted file mode 100644 index b64cc2d765d..00000000000 --- a/src/libraries/System.Linq.Expressions/src/ILLink/ILLink.Substitutions.xml +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/src/libraries/System.Linq.Expressions/src/System.Linq.Expressions.csproj b/src/libraries/System.Linq.Expressions/src/System.Linq.Expressions.csproj index 66a070211dd..d06dd2cabb1 100644 --- a/src/libraries/System.Linq.Expressions/src/System.Linq.Expressions.csproj +++ b/src/libraries/System.Linq.Expressions/src/System.Linq.Expressions.csproj @@ -12,10 +12,6 @@ false - - - - diff --git a/src/libraries/System.Linq.Expressions/src/System/Dynamic/Utils/DelegateHelpers.cs b/src/libraries/System.Linq.Expressions/src/System/Dynamic/Utils/DelegateHelpers.cs index c90f2bdad70..ef812058dc5 100644 --- a/src/libraries/System.Linq.Expressions/src/System/Dynamic/Utils/DelegateHelpers.cs +++ b/src/libraries/System.Linq.Expressions/src/System/Dynamic/Utils/DelegateHelpers.cs @@ -13,7 +13,7 @@ namespace System.Dynamic.Utils { internal static class DelegateHelpers { - // This can be flipped to false using feature switches at publishing time + [FeatureSwitchDefinition("System.Linq.Expressions.CanEmitObjectArrayDelegate")] internal static bool CanEmitObjectArrayDelegate => true; // Separate class so that the it can be trimmed away and doesn't get conflated diff --git a/src/libraries/System.Linq.Parallel/System.Linq.Parallel.sln b/src/libraries/System.Linq.Parallel/System.Linq.Parallel.sln index 08fbf921798..789d9a8c286 100644 --- a/src/libraries/System.Linq.Parallel/System.Linq.Parallel.sln +++ b/src/libraries/System.Linq.Parallel/System.Linq.Parallel.sln @@ -13,7 +13,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Linq.Parallel.Tests" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Linq", "..\System.Linq\ref\System.Linq.csproj", "{7FD74561-E291-4A05-888B-B32022C97F7E}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{775CCE4D-79E3-4D13-8C57-1FEDA8F7B773}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{AA0E6606-6276-4E22-872E-20F58E825021}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{CE258E72-5765-46B4-8B93-59D11F91FAE1}" EndProject @@ -79,10 +79,10 @@ Global {7FD74561-E291-4A05-888B-B32022C97F7E}.Debug|Any CPU.Build.0 = Debug|Any CPU {7FD74561-E291-4A05-888B-B32022C97F7E}.Release|Any CPU.ActiveCfg = Release|Any CPU {7FD74561-E291-4A05-888B-B32022C97F7E}.Release|Any CPU.Build.0 = Release|Any CPU - {775CCE4D-79E3-4D13-8C57-1FEDA8F7B773}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {775CCE4D-79E3-4D13-8C57-1FEDA8F7B773}.Debug|Any CPU.Build.0 = Debug|Any CPU - {775CCE4D-79E3-4D13-8C57-1FEDA8F7B773}.Release|Any CPU.ActiveCfg = Release|Any CPU - {775CCE4D-79E3-4D13-8C57-1FEDA8F7B773}.Release|Any CPU.Build.0 = Release|Any CPU + {AA0E6606-6276-4E22-872E-20F58E825021}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {AA0E6606-6276-4E22-872E-20F58E825021}.Debug|Any CPU.Build.0 = Debug|Any CPU + {AA0E6606-6276-4E22-872E-20F58E825021}.Release|Any CPU.ActiveCfg = Release|Any CPU + {AA0E6606-6276-4E22-872E-20F58E825021}.Release|Any CPU.Build.0 = Release|Any CPU {CE258E72-5765-46B4-8B93-59D11F91FAE1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {CE258E72-5765-46B4-8B93-59D11F91FAE1}.Debug|Any CPU.Build.0 = Debug|Any CPU {CE258E72-5765-46B4-8B93-59D11F91FAE1}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -124,7 +124,7 @@ Global {7FD74561-E291-4A05-888B-B32022C97F7E} = {20F9AEA0-7D11-4282-81E0-274CDF39D2DA} {4B17E9F9-77EB-4FC4-A3A2-7901FFC4663D} = {20F9AEA0-7D11-4282-81E0-274CDF39D2DA} {CDF79D0D-248D-48A5-A698-00D34FBA64E1} = {4E48C076-587B-43F6-81C7-3362BDC8D1D8} - {775CCE4D-79E3-4D13-8C57-1FEDA8F7B773} = {B2591C6D-F523-4C15-9E29-2E2E01ACB2C4} + {AA0E6606-6276-4E22-872E-20F58E825021} = {B2591C6D-F523-4C15-9E29-2E2E01ACB2C4} {CE258E72-5765-46B4-8B93-59D11F91FAE1} = {B2591C6D-F523-4C15-9E29-2E2E01ACB2C4} {CC4666B6-A079-48EE-8078-BA9244F3EA08} = {B1497F09-0CB7-4FCA-BAE4-0D12C4C686B6} {6C6B3DE0-1C4F-4D47-B2AD-55E229E88C2B} = {B1497F09-0CB7-4FCA-BAE4-0D12C4C686B6} diff --git a/src/libraries/System.Linq.Parallel/src/System/Linq/ParallelEnumerable.cs b/src/libraries/System.Linq.Parallel/src/System/Linq/ParallelEnumerable.cs index 55ef371ea04..9f3dc2674aa 100644 --- a/src/libraries/System.Linq.Parallel/src/System/Linq/ParallelEnumerable.cs +++ b/src/libraries/System.Linq.Parallel/src/System/Linq/ParallelEnumerable.cs @@ -66,7 +66,7 @@ public static class ParallelEnumerable // be executed in parallel, but will retain PLINQ semantics (exceptions wrapped as aggregates, etc). #if !FEATURE_WASM_MANAGED_THREADS [System.Runtime.Versioning.SupportedOSPlatformGuard("browser")] - internal static bool SinglePartitionMode => OperatingSystem.IsBrowser(); + internal static bool SinglePartitionMode => OperatingSystem.IsBrowser() || OperatingSystem.IsWasi(); #else internal static bool SinglePartitionMode => false; #endif diff --git a/src/libraries/System.Linq.Queryable/System.Linq.Queryable.sln b/src/libraries/System.Linq.Queryable/System.Linq.Queryable.sln index 7c9594815cd..88763438a61 100644 --- a/src/libraries/System.Linq.Queryable/System.Linq.Queryable.sln +++ b/src/libraries/System.Linq.Queryable/System.Linq.Queryable.sln @@ -15,7 +15,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Linq", "..\System.Li EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ObjectModel", "..\System.ObjectModel\ref\System.ObjectModel.csproj", "{5990688C-797A-4A3A-9DFE-729443E60EA6}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{D100FF6C-66B4-43A9-AB3E-80E8B3D87A7F}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{D1414B0D-A1C8-412D-9635-F24991B152E8}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{ACFE06FC-0223-4F8F-88B9-AE977B9BEB30}" EndProject @@ -85,10 +85,10 @@ Global {5990688C-797A-4A3A-9DFE-729443E60EA6}.Debug|Any CPU.Build.0 = Debug|Any CPU {5990688C-797A-4A3A-9DFE-729443E60EA6}.Release|Any CPU.ActiveCfg = Release|Any CPU {5990688C-797A-4A3A-9DFE-729443E60EA6}.Release|Any CPU.Build.0 = Release|Any CPU - {D100FF6C-66B4-43A9-AB3E-80E8B3D87A7F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {D100FF6C-66B4-43A9-AB3E-80E8B3D87A7F}.Debug|Any CPU.Build.0 = Debug|Any CPU - {D100FF6C-66B4-43A9-AB3E-80E8B3D87A7F}.Release|Any CPU.ActiveCfg = Release|Any CPU - {D100FF6C-66B4-43A9-AB3E-80E8B3D87A7F}.Release|Any CPU.Build.0 = Release|Any CPU + {D1414B0D-A1C8-412D-9635-F24991B152E8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D1414B0D-A1C8-412D-9635-F24991B152E8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D1414B0D-A1C8-412D-9635-F24991B152E8}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D1414B0D-A1C8-412D-9635-F24991B152E8}.Release|Any CPU.Build.0 = Release|Any CPU {ACFE06FC-0223-4F8F-88B9-AE977B9BEB30}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {ACFE06FC-0223-4F8F-88B9-AE977B9BEB30}.Debug|Any CPU.Build.0 = Debug|Any CPU {ACFE06FC-0223-4F8F-88B9-AE977B9BEB30}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -131,7 +131,7 @@ Global {5990688C-797A-4A3A-9DFE-729443E60EA6} = {4175E0A1-D5C1-470E-8F0A-EB05DED9B1F4} {12AF1EDA-A597-4DEE-A91F-6E784B8D7555} = {4175E0A1-D5C1-470E-8F0A-EB05DED9B1F4} {EC9BDC43-2701-4942-AFAC-FED0555B60C9} = {E6F704C7-2418-4ADC-90E6-9C6570EF57BB} - {D100FF6C-66B4-43A9-AB3E-80E8B3D87A7F} = {D124A349-76C6-4FD9-AE3F-D0B674D03CB3} + {D1414B0D-A1C8-412D-9635-F24991B152E8} = {D124A349-76C6-4FD9-AE3F-D0B674D03CB3} {ACFE06FC-0223-4F8F-88B9-AE977B9BEB30} = {D124A349-76C6-4FD9-AE3F-D0B674D03CB3} {0FBF7E3D-C30D-414A-AA92-B28A7AF0AAC9} = {14F93B64-3755-4118-B88A-D2D1E49F4692} {FA61FF7E-9F19-4B5C-A78B-39491154D2A9} = {14F93B64-3755-4118-B88A-D2D1E49F4692} diff --git a/src/libraries/System.Linq.Queryable/src/System/Linq/Queryable.cs b/src/libraries/System.Linq.Queryable/src/System/Linq/Queryable.cs index a717d80b6c0..5914012df62 100644 --- a/src/libraries/System.Linq.Queryable/src/System/Linq/Queryable.cs +++ b/src/libraries/System.Linq.Queryable/src/System/Linq/Queryable.cs @@ -929,6 +929,7 @@ public static IQueryable UnionBy(this IQueryableReturn index and the associated item. /// The type of the elements of . /// An to return an element from. + /// An enumerable that incorporates each element index into a tuple. /// is . [DynamicDependency("Index`1", typeof(Enumerable))] public static IQueryable<(int Index, TSource Item)> Index(this IQueryable source) @@ -2352,6 +2353,22 @@ public static TResult Aggregate(this IQueryable + /// Applies an accumulator function over a sequence, grouping results by key. + /// + /// The type of the elements of . + /// The type of the key returned by . + /// The type of the accumulator value. + /// An to aggregate over. + /// A function to extract the key for each element. + /// The initial accumulator value. + /// An accumulator function to be invoked on each element. + /// An to compare keys with. + /// An enumerable containing the aggregates corresponding to each key deriving from . + /// + /// This method is comparable to the methods + /// where each grouping is being aggregated into a single value as opposed to allocating a collection for each group. + /// [DynamicDependency("AggregateBy`3", typeof(Enumerable))] public static IQueryable> AggregateBy(this IQueryable source, Expression> keySelector, TAccumulate seed, Expression> func, IEqualityComparer? keyComparer = null) where TKey : notnull { @@ -2366,6 +2383,22 @@ public static IQueryable> AggregateBy)))); } + /// + /// Applies an accumulator function over a sequence, grouping results by key. + /// + /// The type of the elements of . + /// The type of the key returned by . + /// The type of the accumulator value. + /// An to aggregate over. + /// A function to extract the key for each element. + /// A factory for the initial accumulator value. + /// An accumulator function to be invoked on each element. + /// An to compare keys with. + /// An enumerable containing the aggregates corresponding to each key deriving from . + /// + /// This method is comparable to the methods + /// where each grouping is being aggregated into a single value as opposed to allocating a collection for each group. + /// [DynamicDependency("AggregateBy`3", typeof(Enumerable))] public static IQueryable> AggregateBy(this IQueryable source, Expression> keySelector, Expression> seedSelector, Expression> func, IEqualityComparer? keyComparer = null) where TKey : notnull { diff --git a/src/libraries/System.Linq/System.Linq.sln b/src/libraries/System.Linq/System.Linq.sln index f34d3b9dc6e..178f029a3f7 100644 --- a/src/libraries/System.Linq/System.Linq.sln +++ b/src/libraries/System.Linq/System.Linq.sln @@ -11,6 +11,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Linq.Tests", "tests\ EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{9A13A12F-C924-43AF-94AF-6F1B33582D27}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{C026F4C2-949D-4F73-845B-0D78993A83B0}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{4BEC631E-B5FD-453F-82A0-C95C461798EA}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{C8F0459C-15D5-4624-8CE4-E93ADF96A28C}" @@ -73,6 +75,10 @@ Global {9A13A12F-C924-43AF-94AF-6F1B33582D27}.Debug|Any CPU.Build.0 = Debug|Any CPU {9A13A12F-C924-43AF-94AF-6F1B33582D27}.Release|Any CPU.ActiveCfg = Release|Any CPU {9A13A12F-C924-43AF-94AF-6F1B33582D27}.Release|Any CPU.Build.0 = Release|Any CPU + {C026F4C2-949D-4F73-845B-0D78993A83B0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {C026F4C2-949D-4F73-845B-0D78993A83B0}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C026F4C2-949D-4F73-845B-0D78993A83B0}.Release|Any CPU.ActiveCfg = Release|Any CPU + {C026F4C2-949D-4F73-845B-0D78993A83B0}.Release|Any CPU.Build.0 = Release|Any CPU {4BEC631E-B5FD-453F-82A0-C95C461798EA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {4BEC631E-B5FD-453F-82A0-C95C461798EA}.Debug|Any CPU.Build.0 = Debug|Any CPU {4BEC631E-B5FD-453F-82A0-C95C461798EA}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -117,6 +123,7 @@ Global {D3160C37-FC48-4907-8F4A-F584ED12B275} = {18C4E23D-AB0F-45E5-A6A1-A741F6462E85} {14B966BB-CE23-4432-ADBB-89974389AC1D} = {F8F69023-9ACD-4979-A710-39D16377AEEE} {9A13A12F-C924-43AF-94AF-6F1B33582D27} = {34793393-0347-438D-A832-2476F33C1BE3} + {C026F4C2-949D-4F73-845B-0D78993A83B0} = {34793393-0347-438D-A832-2476F33C1BE3} {4BEC631E-B5FD-453F-82A0-C95C461798EA} = {34793393-0347-438D-A832-2476F33C1BE3} {C8F0459C-15D5-4624-8CE4-E93ADF96A28C} = {34793393-0347-438D-A832-2476F33C1BE3} {E0CA3ED5-EE6C-4F7C-BCE7-EFB1D64A9CD1} = {3EC69C1A-F3A3-4057-8DB0-D2ECD915AD5A} diff --git a/src/libraries/System.Linq/src/System.Linq.csproj b/src/libraries/System.Linq/src/System.Linq.csproj index 68b88631587..79c10444f48 100644 --- a/src/libraries/System.Linq/src/System.Linq.csproj +++ b/src/libraries/System.Linq/src/System.Linq.csproj @@ -1,7 +1,7 @@ - $(NetCoreAppCurrent);$(NetCoreAppCurrent)-browser;$(NetCoreAppCurrent)-android;$(NetCoreAppCurrent)-ios;$(NetCoreAppCurrent)-tvos + $(NetCoreAppCurrent);$(NetCoreAppCurrent)-browser;$(NetCoreAppCurrent)-wasi;$(NetCoreAppCurrent)-android;$(NetCoreAppCurrent)-ios;$(NetCoreAppCurrent)-tvos false diff --git a/src/libraries/System.Linq/src/System/Linq/AggregateBy.cs b/src/libraries/System.Linq/src/System/Linq/AggregateBy.cs index e73b646ca40..054b1272db1 100644 --- a/src/libraries/System.Linq/src/System/Linq/AggregateBy.cs +++ b/src/libraries/System.Linq/src/System/Linq/AggregateBy.cs @@ -8,6 +8,22 @@ namespace System.Linq { public static partial class Enumerable { + /// + /// Applies an accumulator function over a sequence, grouping results by key. + /// + /// The type of the elements of . + /// The type of the key returned by . + /// The type of the accumulator value. + /// An to aggregate over. + /// A function to extract the key for each element. + /// The initial accumulator value. + /// An accumulator function to be invoked on each element. + /// An to compare keys with. + /// An enumerable containing the aggregates corresponding to each key deriving from . + /// + /// This method is comparable to the methods + /// where each grouping is being aggregated into a single value as opposed to allocating a collection for each group. + /// public static IEnumerable> AggregateBy( this IEnumerable source, Func keySelector, @@ -36,6 +52,22 @@ public static IEnumerable> AggregateBy + /// Applies an accumulator function over a sequence, grouping results by key. + /// + /// The type of the elements of . + /// The type of the key returned by . + /// The type of the accumulator value. + /// An to aggregate over. + /// A function to extract the key for each element. + /// A factory for the initial accumulator value. + /// An accumulator function to be invoked on each element. + /// An to compare keys with. + /// An enumerable containing the aggregates corresponding to each key deriving from . + /// + /// This method is comparable to the methods + /// where each grouping is being aggregated into a single value as opposed to allocating a collection for each group. + /// public static IEnumerable> AggregateBy( this IEnumerable source, Func keySelector, diff --git a/src/libraries/System.Linq/src/System/Linq/CountBy.cs b/src/libraries/System.Linq/src/System/Linq/CountBy.cs index bc03e9adafa..43b450f309c 100644 --- a/src/libraries/System.Linq/src/System/Linq/CountBy.cs +++ b/src/libraries/System.Linq/src/System/Linq/CountBy.cs @@ -8,6 +8,15 @@ namespace System.Linq { public static partial class Enumerable { + /// + /// Returns the count of elements in the source sequence grouped by key. + /// + /// The type of elements of . + /// The type of the key returned by . + /// A sequence that contains elements to be counted. + /// A function to extract the key for each element. + /// An to compare keys with. + /// An enumerable containing the frequencies of each key occurrence in . public static IEnumerable> CountBy(this IEnumerable source, Func keySelector, IEqualityComparer? keyComparer = null) where TKey : notnull { if (source is null) diff --git a/src/libraries/System.Linq/src/System/Linq/Index.cs b/src/libraries/System.Linq/src/System/Linq/Index.cs index 49339b03d1a..4cc6ea11a14 100644 --- a/src/libraries/System.Linq/src/System/Linq/Index.cs +++ b/src/libraries/System.Linq/src/System/Linq/Index.cs @@ -10,6 +10,7 @@ public static partial class Enumerable /// Returns an enumerable that incorporates the element's index into a tuple. /// The type of the elements of . /// The source enumerable providing the elements. + /// An enumerable that incorporates each element index into a tuple. /// is . public static IEnumerable<(int Index, TSource Item)> Index(this IEnumerable source) { diff --git a/src/libraries/System.Management/System.Management.sln b/src/libraries/System.Management/System.Management.sln index 781dabe5c10..4f52e53d602 100644 --- a/src/libraries/System.Management/System.Management.sln +++ b/src/libraries/System.Management/System.Management.sln @@ -11,7 +11,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Management", "src\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Management.Tests", "tests\System.Management.Tests.csproj", "{7113AE59-F125-4378-B93A-9C5C1450B306}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{8A7BDD6F-B220-4FDD-BC2A-A909A7C01D61}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{57FCFB85-2AFF-41EF-B5BC-D29E1FB4F201}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{AEECC1B0-80B3-4DD2-A309-76E4CF12310E}" EndProject @@ -71,10 +71,10 @@ Global {7113AE59-F125-4378-B93A-9C5C1450B306}.Debug|Any CPU.Build.0 = Debug|Any CPU {7113AE59-F125-4378-B93A-9C5C1450B306}.Release|Any CPU.ActiveCfg = Release|Any CPU {7113AE59-F125-4378-B93A-9C5C1450B306}.Release|Any CPU.Build.0 = Release|Any CPU - {8A7BDD6F-B220-4FDD-BC2A-A909A7C01D61}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {8A7BDD6F-B220-4FDD-BC2A-A909A7C01D61}.Debug|Any CPU.Build.0 = Debug|Any CPU - {8A7BDD6F-B220-4FDD-BC2A-A909A7C01D61}.Release|Any CPU.ActiveCfg = Release|Any CPU - {8A7BDD6F-B220-4FDD-BC2A-A909A7C01D61}.Release|Any CPU.Build.0 = Release|Any CPU + {57FCFB85-2AFF-41EF-B5BC-D29E1FB4F201}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {57FCFB85-2AFF-41EF-B5BC-D29E1FB4F201}.Debug|Any CPU.Build.0 = Debug|Any CPU + {57FCFB85-2AFF-41EF-B5BC-D29E1FB4F201}.Release|Any CPU.ActiveCfg = Release|Any CPU + {57FCFB85-2AFF-41EF-B5BC-D29E1FB4F201}.Release|Any CPU.Build.0 = Release|Any CPU {AEECC1B0-80B3-4DD2-A309-76E4CF12310E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {AEECC1B0-80B3-4DD2-A309-76E4CF12310E}.Debug|Any CPU.Build.0 = Debug|Any CPU {AEECC1B0-80B3-4DD2-A309-76E4CF12310E}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -110,7 +110,7 @@ Global {12233594-0AC7-45C7-B4E7-8DAF161A299E} = {441745A2-6E7F-48B9-8C9D-A48E0171B3A5} {7B9EB977-908A-43CB-B2FB-E4E34373F3BF} = {6DC74D98-13B5-4230-87B4-ED3162AFC233} {D31C6457-B81D-4503-938B-93877DDDBDB5} = {6DC74D98-13B5-4230-87B4-ED3162AFC233} - {8A7BDD6F-B220-4FDD-BC2A-A909A7C01D61} = {64360DAC-C8F2-4231-A678-CCEFD683949D} + {57FCFB85-2AFF-41EF-B5BC-D29E1FB4F201} = {64360DAC-C8F2-4231-A678-CCEFD683949D} {AEECC1B0-80B3-4DD2-A309-76E4CF12310E} = {64360DAC-C8F2-4231-A678-CCEFD683949D} {AEFFA5B2-1429-4523-91F4-21ACB4B2506B} = {FE18DE22-5111-48B6-BC70-AC9F1F1D8F33} {BDFF48AD-B58E-4448-AA89-9DC66D31E4E7} = {FE18DE22-5111-48B6-BC70-AC9F1F1D8F33} diff --git a/src/libraries/System.Memory.Data/System.Memory.Data.sln b/src/libraries/System.Memory.Data/System.Memory.Data.sln index 9cb35fe7088..e378d83803d 100644 --- a/src/libraries/System.Memory.Data/System.Memory.Data.sln +++ b/src/libraries/System.Memory.Data/System.Memory.Data.sln @@ -21,6 +21,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Memory", "..\System. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{372BA3FC-446E-4AD2-9125-1BE0890C1D43}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{844753B8-21CA-4C12-A8AB-24A584682A01}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{D42EA0B4-9775-46FD-BAEC-FCE96172FCF4}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{3B738A97-60C4-40EC-B38B-E41C38C18616}" @@ -119,6 +121,10 @@ Global {372BA3FC-446E-4AD2-9125-1BE0890C1D43}.Debug|Any CPU.Build.0 = Debug|Any CPU {372BA3FC-446E-4AD2-9125-1BE0890C1D43}.Release|Any CPU.ActiveCfg = Release|Any CPU {372BA3FC-446E-4AD2-9125-1BE0890C1D43}.Release|Any CPU.Build.0 = Release|Any CPU + {844753B8-21CA-4C12-A8AB-24A584682A01}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {844753B8-21CA-4C12-A8AB-24A584682A01}.Debug|Any CPU.Build.0 = Debug|Any CPU + {844753B8-21CA-4C12-A8AB-24A584682A01}.Release|Any CPU.ActiveCfg = Release|Any CPU + {844753B8-21CA-4C12-A8AB-24A584682A01}.Release|Any CPU.Build.0 = Release|Any CPU {D42EA0B4-9775-46FD-BAEC-FCE96172FCF4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {D42EA0B4-9775-46FD-BAEC-FCE96172FCF4}.Debug|Any CPU.Build.0 = Debug|Any CPU {D42EA0B4-9775-46FD-BAEC-FCE96172FCF4}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -204,6 +210,7 @@ Global {B137F36F-56CB-46B0-ABDD-B80C82494696} = {E6AF8CEE-6550-4190-97D4-D51C5B114919} {1D93DCD8-BF67-4FB5-A25A-7837F230B173} = {E6AF8CEE-6550-4190-97D4-D51C5B114919} {372BA3FC-446E-4AD2-9125-1BE0890C1D43} = {839FCC67-5EA8-4A07-B5D4-9E1DF0B3BE76} + {844753B8-21CA-4C12-A8AB-24A584682A01} = {839FCC67-5EA8-4A07-B5D4-9E1DF0B3BE76} {D42EA0B4-9775-46FD-BAEC-FCE96172FCF4} = {839FCC67-5EA8-4A07-B5D4-9E1DF0B3BE76} {3B738A97-60C4-40EC-B38B-E41C38C18616} = {839FCC67-5EA8-4A07-B5D4-9E1DF0B3BE76} {898AC186-6BE8-4266-954D-DFFF3EE6C428} = {839FCC67-5EA8-4A07-B5D4-9E1DF0B3BE76} diff --git a/src/libraries/System.Memory.Data/src/System.Memory.Data.csproj b/src/libraries/System.Memory.Data/src/System.Memory.Data.csproj index efa9f3460ba..e221d3ef351 100644 --- a/src/libraries/System.Memory.Data/src/System.Memory.Data.csproj +++ b/src/libraries/System.Memory.Data/src/System.Memory.Data.csproj @@ -23,7 +23,7 @@ System.BinaryData - + diff --git a/src/libraries/System.Memory/System.Memory.sln b/src/libraries/System.Memory/System.Memory.sln index 9d5e4920369..110f4b5ff5a 100644 --- a/src/libraries/System.Memory/System.Memory.sln +++ b/src/libraries/System.Memory/System.Memory.sln @@ -13,6 +13,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib.Gene EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\System.Private.CoreLib\ref\System.Private.CoreLib.csproj", "{D0EEF7E0-BD51-4C39-AF4F-DD583D01AEBE}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{CD9555AC-02D9-4A9B-ABF9-905531FF96FA}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{84AD7BF6-D76C-4BEE-9879-5A23150DD3F7}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{DA7CEED7-1A86-4221-B4AD-4307AB83A31F}" @@ -220,6 +222,27 @@ Global {D0EEF7E0-BD51-4C39-AF4F-DD583D01AEBE}.Checked|arm64.ActiveCfg = Debug|Any CPU {D0EEF7E0-BD51-4C39-AF4F-DD583D01AEBE}.Checked|x64.ActiveCfg = Debug|Any CPU {D0EEF7E0-BD51-4C39-AF4F-DD583D01AEBE}.Checked|x86.ActiveCfg = Debug|Any CPU + {CD9555AC-02D9-4A9B-ABF9-905531FF96FA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {CD9555AC-02D9-4A9B-ABF9-905531FF96FA}.Debug|Any CPU.Build.0 = Debug|Any CPU + {CD9555AC-02D9-4A9B-ABF9-905531FF96FA}.Debug|arm.ActiveCfg = Debug|Any CPU + {CD9555AC-02D9-4A9B-ABF9-905531FF96FA}.Debug|arm64.ActiveCfg = Debug|Any CPU + {CD9555AC-02D9-4A9B-ABF9-905531FF96FA}.Debug|x64.ActiveCfg = Debug|Any CPU + {CD9555AC-02D9-4A9B-ABF9-905531FF96FA}.Debug|x64.Build.0 = Debug|Any CPU + {CD9555AC-02D9-4A9B-ABF9-905531FF96FA}.Debug|x86.ActiveCfg = Debug|Any CPU + {CD9555AC-02D9-4A9B-ABF9-905531FF96FA}.Debug|x86.Build.0 = Debug|Any CPU + {CD9555AC-02D9-4A9B-ABF9-905531FF96FA}.Release|Any CPU.ActiveCfg = Release|Any CPU + {CD9555AC-02D9-4A9B-ABF9-905531FF96FA}.Release|Any CPU.Build.0 = Release|Any CPU + {CD9555AC-02D9-4A9B-ABF9-905531FF96FA}.Release|arm.ActiveCfg = Release|Any CPU + {CD9555AC-02D9-4A9B-ABF9-905531FF96FA}.Release|arm64.ActiveCfg = Release|Any CPU + {CD9555AC-02D9-4A9B-ABF9-905531FF96FA}.Release|x64.ActiveCfg = Release|Any CPU + {CD9555AC-02D9-4A9B-ABF9-905531FF96FA}.Release|x64.Build.0 = Release|Any CPU + {CD9555AC-02D9-4A9B-ABF9-905531FF96FA}.Release|x86.ActiveCfg = Release|Any CPU + {CD9555AC-02D9-4A9B-ABF9-905531FF96FA}.Release|x86.Build.0 = Release|Any CPU + {CD9555AC-02D9-4A9B-ABF9-905531FF96FA}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {CD9555AC-02D9-4A9B-ABF9-905531FF96FA}.Checked|arm.ActiveCfg = Debug|Any CPU + {CD9555AC-02D9-4A9B-ABF9-905531FF96FA}.Checked|arm64.ActiveCfg = Debug|Any CPU + {CD9555AC-02D9-4A9B-ABF9-905531FF96FA}.Checked|x64.ActiveCfg = Debug|Any CPU + {CD9555AC-02D9-4A9B-ABF9-905531FF96FA}.Checked|x86.ActiveCfg = Debug|Any CPU {84AD7BF6-D76C-4BEE-9879-5A23150DD3F7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {84AD7BF6-D76C-4BEE-9879-5A23150DD3F7}.Debug|Any CPU.Build.0 = Debug|Any CPU {84AD7BF6-D76C-4BEE-9879-5A23150DD3F7}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -401,6 +424,7 @@ Global {D0EEF7E0-BD51-4C39-AF4F-DD583D01AEBE} = {7212FBCF-E89D-4065-9DCE-D5F7E5D3EF1D} {B773D664-C00B-4DB3-823B-947576EE7A46} = {7212FBCF-E89D-4065-9DCE-D5F7E5D3EF1D} {EFF00253-633C-4D2F-86EE-F40C721F6A68} = {2BEB1A89-DD2D-42BD-95DD-89860A0C9663} + {CD9555AC-02D9-4A9B-ABF9-905531FF96FA} = {2BEB1A89-DD2D-42BD-95DD-89860A0C9663} {84AD7BF6-D76C-4BEE-9879-5A23150DD3F7} = {2BEB1A89-DD2D-42BD-95DD-89860A0C9663} {DA7CEED7-1A86-4221-B4AD-4307AB83A31F} = {2BEB1A89-DD2D-42BD-95DD-89860A0C9663} {9EB7CD91-D219-46C8-BBC2-946F783464FD} = {24985D32-AECC-4F31-A921-294FA81577F1} diff --git a/src/libraries/System.Memory/ref/System.Memory.Forwards.cs b/src/libraries/System.Memory/ref/System.Memory.Forwards.cs index e79102cfcd3..88d911fa08d 100644 --- a/src/libraries/System.Memory/ref/System.Memory.Forwards.cs +++ b/src/libraries/System.Memory/ref/System.Memory.Forwards.cs @@ -11,3 +11,4 @@ [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Buffers.MemoryManager<>))] [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Buffers.OperationStatus))] [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Buffers.Text.Base64))] +[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Runtime.InteropServices.MemoryMarshal))] diff --git a/src/libraries/System.Memory/ref/System.Memory.cs b/src/libraries/System.Memory/ref/System.Memory.cs index bc4e19712a3..f7b1f5f48d0 100644 --- a/src/libraries/System.Memory/ref/System.Memory.cs +++ b/src/libraries/System.Memory/ref/System.Memory.cs @@ -700,39 +700,6 @@ public static partial class Utf8Parser public static bool TryParse(System.ReadOnlySpan source, out ulong value, out int bytesConsumed, char standardFormat = '\0') { throw null; } } } -namespace System.Runtime.InteropServices -{ - public static partial class MemoryMarshal - { - public static System.ReadOnlySpan AsBytes(System.ReadOnlySpan span) where T : struct { throw null; } - public static System.Span AsBytes(System.Span span) where T : struct { throw null; } - public static System.Memory AsMemory(System.ReadOnlyMemory memory) { throw null; } - public static ref readonly T AsRef(System.ReadOnlySpan span) where T : struct { throw null; } - public static ref T AsRef(System.Span span) where T : struct { throw null; } - public static System.ReadOnlySpan Cast(System.ReadOnlySpan span) where TFrom : struct where TTo : struct { throw null; } - public static System.Span Cast(System.Span span) where TFrom : struct where TTo : struct { throw null; } - public static System.Memory CreateFromPinnedArray(T[]? array, int start, int length) { throw null; } - public static System.ReadOnlySpan CreateReadOnlySpan(scoped ref readonly T reference, int length) { throw null; } - [System.CLSCompliant(false)] - public static unsafe ReadOnlySpan CreateReadOnlySpanFromNullTerminated(byte* value) { throw null; } - [System.CLSCompliant(false)] - public static unsafe ReadOnlySpan CreateReadOnlySpanFromNullTerminated(char* value) { throw null; } - public static System.Span CreateSpan(scoped ref T reference, int length) { throw null; } - public static ref T GetArrayDataReference(T[] array) { throw null; } - public static ref byte GetArrayDataReference(System.Array array) { throw null; } - public static ref T GetReference(System.ReadOnlySpan span) { throw null; } - public static ref T GetReference(System.Span span) { throw null; } - public static T Read(System.ReadOnlySpan source) where T : struct { throw null; } - public static System.Collections.Generic.IEnumerable ToEnumerable(System.ReadOnlyMemory memory) { throw null; } - public static bool TryGetArray(System.ReadOnlyMemory memory, out System.ArraySegment segment) { throw null; } - public static bool TryGetMemoryManager(System.ReadOnlyMemory memory, [System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] out TManager? manager) where TManager : System.Buffers.MemoryManager { throw null; } - public static bool TryGetMemoryManager(System.ReadOnlyMemory memory, [System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] out TManager? manager, out int start, out int length) where TManager : System.Buffers.MemoryManager { throw null; } - public static bool TryGetString(System.ReadOnlyMemory memory, [System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] out string? text, out int start, out int length) { throw null; } - public static bool TryRead(System.ReadOnlySpan source, out T value) where T : struct { throw null; } - public static bool TryWrite(System.Span destination, in T value) where T : struct { throw null; } - public static void Write(System.Span destination, in T value) where T : struct { } - } -} namespace System.Text { public ref partial struct SpanLineEnumerator diff --git a/src/libraries/System.Memory/src/System/Buffers/ReadOnlySequence.cs b/src/libraries/System.Memory/src/System/Buffers/ReadOnlySequence.cs index 549f8edd628..ab91256f3ad 100644 --- a/src/libraries/System.Memory/src/System/Buffers/ReadOnlySequence.cs +++ b/src/libraries/System.Memory/src/System/Buffers/ReadOnlySequence.cs @@ -652,7 +652,6 @@ private enum SequenceType Array = 0x1, MemoryManager = 0x2, String = 0x3, - Empty = 0x4 } } diff --git a/src/libraries/System.Memory/tests/Base64/Base64ValidationUnitTests.cs b/src/libraries/System.Memory/tests/Base64/Base64ValidationUnitTests.cs index 62b978c60c5..f95399ae420 100644 --- a/src/libraries/System.Memory/tests/Base64/Base64ValidationUnitTests.cs +++ b/src/libraries/System.Memory/tests/Base64/Base64ValidationUnitTests.cs @@ -9,6 +9,29 @@ namespace System.Buffers.Text.Tests { public class Base64ValidationUnitTests : Base64TestBase { + [Theory] + [InlineData("= ")] + [InlineData("= =")] + [InlineData("+ +=")] + [InlineData("A=")] + [InlineData("A==")] + [InlineData("44==")] + [InlineData(" A==")] + [InlineData("AAAAA ==")] + [InlineData("\tLLLL\t=\r")] + [InlineData("6066=")] + [InlineData("6066==")] + [InlineData("SM==")] + [InlineData("SM =")] + [InlineData("s\rEs\r\r==")] + public void BasicValidationEdgeCaseScenario(string base64UrlText) + { + Assert.False(Base64.IsValid(base64UrlText.AsSpan(), out int decodedLength)); + Assert.Equal(0, decodedLength); + Span dest = new byte[Base64.GetMaxDecodedFromUtf8Length(base64UrlText.Length)]; + Assert.Equal(OperationStatus.InvalidData, Base64.DecodeFromUtf8(base64UrlText.ToUtf8Span(), dest, out _, out _)); + } + [Fact] public void BasicValidationBytes() { diff --git a/src/libraries/System.Memory/tests/Base64Url/Base64UrlValidationUnitTests.cs b/src/libraries/System.Memory/tests/Base64Url/Base64UrlValidationUnitTests.cs index 0ee3abcd915..092d45d2370 100644 --- a/src/libraries/System.Memory/tests/Base64Url/Base64UrlValidationUnitTests.cs +++ b/src/libraries/System.Memory/tests/Base64Url/Base64UrlValidationUnitTests.cs @@ -10,6 +10,7 @@ namespace System.Buffers.Text.Tests public class Base64UrlValidationUnitTests : Base64TestBase { [Theory] + [InlineData("=")] [InlineData("==")] [InlineData("-%")] [InlineData("A=")] @@ -19,10 +20,17 @@ public class Base64UrlValidationUnitTests : Base64TestBase [InlineData("AAAAA ==")] [InlineData("\tLLLL\t=\r")] [InlineData("6066=")] + [InlineData("6066==")] + [InlineData("SM==")] + [InlineData("SM=")] + [InlineData("sEs==")] + [InlineData("s\rEs\r\r==")] public void BasicValidationEdgeCaseScenario(string base64UrlText) { Assert.False(Base64Url.IsValid(base64UrlText.AsSpan(), out int decodedLength)); Assert.Equal(0, decodedLength); + Span dest = new byte[Base64Url.GetMaxDecodedLength(base64UrlText.Length)]; + Assert.Equal(OperationStatus.InvalidData, Base64Url.DecodeFromChars(base64UrlText.AsSpan(), dest, out _, out _)); } [Fact] @@ -258,6 +266,10 @@ public void ValidateWithPaddingReturnsCorrectCountChars(string utf8WithByteToBeI Assert.True(Base64Url.IsValid(utf8BytesWithByteToBeIgnored)); Assert.True(Base64Url.IsValid(utf8BytesWithByteToBeIgnored, out int decodedLength)); Assert.Equal(expectedLength, decodedLength); + + Span dest = new byte[Base64Url.GetMaxDecodedLength(utf8WithByteToBeIgnored.Length)]; + Assert.Equal(OperationStatus.Done, Base64Url.DecodeFromChars(utf8WithByteToBeIgnored.AsSpan(), dest, out _, out decodedLength)); + Assert.Equal(expectedLength, decodedLength); } [Theory] diff --git a/src/libraries/System.Memory/tests/Span/SearchValues.cs b/src/libraries/System.Memory/tests/Span/SearchValues.cs index 8f39a95bd3c..00e9c71e3df 100644 --- a/src/libraries/System.Memory/tests/Span/SearchValues.cs +++ b/src/libraries/System.Memory/tests/Span/SearchValues.cs @@ -35,6 +35,8 @@ public static IEnumerable Values_MemberData() "abcd", "aeio", "aeiou", + "Aabc", + "Aabcd", "abceiou", "123456789", "123456789123", @@ -82,6 +84,11 @@ public static IEnumerable Values_MemberData() { yield return Pair(value); yield return Pair('a' + value); + yield return Pair('\0' + value); + yield return Pair('\u0001' + value); + yield return Pair('\u00FE' + value); + yield return Pair('\u00FF' + value); + yield return Pair('\uFF00' + value); // Test some more duplicates if (value.Length > 0) diff --git a/src/libraries/System.Net.Http.Json/System.Net.Http.Json.sln b/src/libraries/System.Net.Http.Json/System.Net.Http.Json.sln index 33cdd49b0a4..a338288a388 100644 --- a/src/libraries/System.Net.Http.Json/System.Net.Http.Json.sln +++ b/src/libraries/System.Net.Http.Json/System.Net.Http.Json.sln @@ -39,6 +39,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Net.Sockets", "..\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{760BA8DB-B9A0-4B6D-AF5D-EE3FF92B1A70}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{29C9BBA7-7D49-40DE-9BFD-07515E8BD1C4}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{4AED92A2-8DEB-41B4-862D-8B779FA1CFCE}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{E1A1EC7C-3257-46EB-8DBC-DE8DAB3F4F4F}" @@ -179,6 +181,10 @@ Global {760BA8DB-B9A0-4B6D-AF5D-EE3FF92B1A70}.Debug|Any CPU.Build.0 = Debug|Any CPU {760BA8DB-B9A0-4B6D-AF5D-EE3FF92B1A70}.Release|Any CPU.ActiveCfg = Release|Any CPU {760BA8DB-B9A0-4B6D-AF5D-EE3FF92B1A70}.Release|Any CPU.Build.0 = Release|Any CPU + {29C9BBA7-7D49-40DE-9BFD-07515E8BD1C4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {29C9BBA7-7D49-40DE-9BFD-07515E8BD1C4}.Debug|Any CPU.Build.0 = Debug|Any CPU + {29C9BBA7-7D49-40DE-9BFD-07515E8BD1C4}.Release|Any CPU.ActiveCfg = Release|Any CPU + {29C9BBA7-7D49-40DE-9BFD-07515E8BD1C4}.Release|Any CPU.Build.0 = Release|Any CPU {4AED92A2-8DEB-41B4-862D-8B779FA1CFCE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {4AED92A2-8DEB-41B4-862D-8B779FA1CFCE}.Debug|Any CPU.Build.0 = Debug|Any CPU {4AED92A2-8DEB-41B4-862D-8B779FA1CFCE}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -288,6 +294,7 @@ Global {1A9E7E5D-B340-4677-8745-2811F07148C6} = {945B0700-C720-4775-B9E4-6A27DAA90190} {EA992513-9CA4-4DEB-B0EE-A8FD0252B451} = {945B0700-C720-4775-B9E4-6A27DAA90190} {760BA8DB-B9A0-4B6D-AF5D-EE3FF92B1A70} = {5A418E02-B18A-41F1-9D4F-1BD6CB51F63C} + {29C9BBA7-7D49-40DE-9BFD-07515E8BD1C4} = {5A418E02-B18A-41F1-9D4F-1BD6CB51F63C} {4AED92A2-8DEB-41B4-862D-8B779FA1CFCE} = {5A418E02-B18A-41F1-9D4F-1BD6CB51F63C} {E1A1EC7C-3257-46EB-8DBC-DE8DAB3F4F4F} = {5A418E02-B18A-41F1-9D4F-1BD6CB51F63C} {E277B012-C6EE-4032-9E80-C1EE3BAD7F51} = {5A418E02-B18A-41F1-9D4F-1BD6CB51F63C} diff --git a/src/libraries/System.Net.Http.Json/src/System.Net.Http.Json.csproj b/src/libraries/System.Net.Http.Json/src/System.Net.Http.Json.csproj index ef01da51d13..b8908f4fde1 100644 --- a/src/libraries/System.Net.Http.Json/src/System.Net.Http.Json.csproj +++ b/src/libraries/System.Net.Http.Json/src/System.Net.Http.Json.csproj @@ -48,15 +48,17 @@ System.Net.Http.Json.JsonContent - + + + diff --git a/src/libraries/System.Net.Http.Json/tests/FunctionalTests/System.Net.Http.Json.Functional.Tests.csproj b/src/libraries/System.Net.Http.Json/tests/FunctionalTests/System.Net.Http.Json.Functional.Tests.csproj index 00096666999..63cf0a7b97f 100644 --- a/src/libraries/System.Net.Http.Json/tests/FunctionalTests/System.Net.Http.Json.Functional.Tests.csproj +++ b/src/libraries/System.Net.Http.Json/tests/FunctionalTests/System.Net.Http.Json.Functional.Tests.csproj @@ -3,7 +3,6 @@ $(NetCoreAppCurrent);$(NetFrameworkCurrent) true - $(NoWarn);SYSLIB0057 @@ -33,6 +32,7 @@ + diff --git a/src/libraries/System.Net.Http.WinHttpHandler/System.Net.Http.WinHttpHandler.sln b/src/libraries/System.Net.Http.WinHttpHandler/System.Net.Http.WinHttpHandler.sln index 8b01f967729..109fdc765e7 100644 --- a/src/libraries/System.Net.Http.WinHttpHandler/System.Net.Http.WinHttpHandler.sln +++ b/src/libraries/System.Net.Http.WinHttpHandler/System.Net.Http.WinHttpHandler.sln @@ -47,6 +47,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Net.Sockets", "..\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{24F441D1-9CF5-4A92-AC7D-BDC05C6CCB57}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{CCC1E786-C627-458D-97AD-08D29D533619}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{8B4CF65D-B325-4ED8-B853-C22F12997836}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{834ECDE7-4B5D-4DBD-8BCA-98343A99179F}" @@ -203,6 +205,10 @@ Global {24F441D1-9CF5-4A92-AC7D-BDC05C6CCB57}.Debug|Any CPU.Build.0 = Debug|Any CPU {24F441D1-9CF5-4A92-AC7D-BDC05C6CCB57}.Release|Any CPU.ActiveCfg = Release|Any CPU {24F441D1-9CF5-4A92-AC7D-BDC05C6CCB57}.Release|Any CPU.Build.0 = Release|Any CPU + {CCC1E786-C627-458D-97AD-08D29D533619}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {CCC1E786-C627-458D-97AD-08D29D533619}.Debug|Any CPU.Build.0 = Debug|Any CPU + {CCC1E786-C627-458D-97AD-08D29D533619}.Release|Any CPU.ActiveCfg = Release|Any CPU + {CCC1E786-C627-458D-97AD-08D29D533619}.Release|Any CPU.Build.0 = Release|Any CPU {8B4CF65D-B325-4ED8-B853-C22F12997836}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {8B4CF65D-B325-4ED8-B853-C22F12997836}.Debug|Any CPU.Build.0 = Debug|Any CPU {8B4CF65D-B325-4ED8-B853-C22F12997836}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -316,6 +322,7 @@ Global {2C7E9759-DB91-46DD-AE83-446973893D48} = {2F9A243D-B060-4BB2-A9E1-A9CB861328D9} {8ABBBDC5-48A1-43BA-A629-AE58C35318AA} = {2F9A243D-B060-4BB2-A9E1-A9CB861328D9} {24F441D1-9CF5-4A92-AC7D-BDC05C6CCB57} = {B8C52E24-376F-4E8D-AA8A-62E25C161863} + {CCC1E786-C627-458D-97AD-08D29D533619} = {B8C52E24-376F-4E8D-AA8A-62E25C161863} {8B4CF65D-B325-4ED8-B853-C22F12997836} = {B8C52E24-376F-4E8D-AA8A-62E25C161863} {834ECDE7-4B5D-4DBD-8BCA-98343A99179F} = {B8C52E24-376F-4E8D-AA8A-62E25C161863} {F37B0EB9-2882-42F9-88DE-BB55AD9DCA5D} = {B8C52E24-376F-4E8D-AA8A-62E25C161863} diff --git a/src/libraries/System.Net.Http.WinHttpHandler/tests/FunctionalTests/System.Net.Http.WinHttpHandler.Functional.Tests.csproj b/src/libraries/System.Net.Http.WinHttpHandler/tests/FunctionalTests/System.Net.Http.WinHttpHandler.Functional.Tests.csproj index 7640a70f87b..f25614ada92 100644 --- a/src/libraries/System.Net.Http.WinHttpHandler/tests/FunctionalTests/System.Net.Http.WinHttpHandler.Functional.Tests.csproj +++ b/src/libraries/System.Net.Http.WinHttpHandler/tests/FunctionalTests/System.Net.Http.WinHttpHandler.Functional.Tests.csproj @@ -4,7 +4,6 @@ true $(DefineConstants);WINHTTPHANDLER_TEST true - $(NoWarn);SYSLIB0057 + diff --git a/src/libraries/System.Net.Http.WinHttpHandler/tests/UnitTests/ClientCertificateHelper.cs b/src/libraries/System.Net.Http.WinHttpHandler/tests/UnitTests/ClientCertificateHelper.cs index d59febe8bca..542b8fd1bb7 100644 --- a/src/libraries/System.Net.Http.WinHttpHandler/tests/UnitTests/ClientCertificateHelper.cs +++ b/src/libraries/System.Net.Http.WinHttpHandler/tests/UnitTests/ClientCertificateHelper.cs @@ -11,7 +11,7 @@ namespace System.Net.Http.WinHttpHandlerUnitTests public class ClientCertificateHelper { private readonly X509Certificate2 _cert_KeyUsageIncludesDigitalSignature_EKUIncludesClientAuth_PrivateKey = - new X509Certificate2( + X509CertificateLoader.LoadPkcs12( Convert.FromBase64String( // [SuppressMessage("Microsoft.Security", "CS002:SecretInNextLine", Justification="Suppression approved. Unit test dummy certificate.")] @"MIIKTgIBAzCCCgoGCSqGSIb3DQEHAaCCCfsEggn3MIIJ8zCCBgwGCSqGSIb3DQEHAaCCBf0EggX5 @@ -64,7 +64,7 @@ public class ClientCertificateHelper "password"); private readonly X509Certificate2 _cert_KeyUsageMissingDigitalSignature_EKUIncludesClientAuth_PrivateKey = - new X509Certificate2( + X509CertificateLoader.LoadPkcs12( Convert.FromBase64String( // [SuppressMessage("Microsoft.Security", "CS002:SecretInNextLine", Justification="Suppression approved. Unit test dummy certificate.")] @"MIIKTgIBAzCCCgoGCSqGSIb3DQEHAaCCCfsEggn3MIIJ8zCCBgwGCSqGSIb3DQEHAaCCBf0EggX5 @@ -117,7 +117,7 @@ public class ClientCertificateHelper "password"); private readonly X509Certificate2 _cert_KeyUsageIncludesDigitalSignature_EKUMissingClientAuth_PrivateKey = - new X509Certificate2( + X509CertificateLoader.LoadPkcs12( Convert.FromBase64String( // [SuppressMessage("Microsoft.Security", "CS002:SecretInNextLine", Justification="Suppression approved. Dummy certificate for testing.")] @"MIIKRgIBAzCCCgIGCSqGSIb3DQEHAaCCCfMEggnvMIIJ6zCCBgQGCSqGSIb3DQEHAaCCBfUEggXx @@ -170,7 +170,7 @@ public class ClientCertificateHelper "password"); private readonly X509Certificate2 _cert_KeyUsageIncludesDigitalSignature_NoEKU_PrivateKey = - new X509Certificate2( + X509CertificateLoader.LoadPkcs12( Convert.FromBase64String( // [SuppressMessage("Microsoft.Security", "CS002:SecretInNextLine", Justification="Suppression approved. Dummy certificate for testing.")] @"MIIKPgIBAzCCCfoGCSqGSIb3DQEHAaCCCesEggnnMIIJ4zCCBgwGCSqGSIb3DQEHAaCCBf0EggX5 @@ -223,7 +223,7 @@ public class ClientCertificateHelper "password"); private readonly X509Certificate2 _cert_KeyUsageIncludesDigitalSignature_EKUIncludesClientAuth_NoPrivateKey = - new X509Certificate2( + X509CertificateLoader.LoadCertificate( Convert.FromBase64String( // [SuppressMessage("Microsoft.Security", "CS002:SecretInNextLine", Justification="Suppression approved. Dummy certificate for testing.")] @"MIIDFjCCAf6gAwIBAgIQTm8+EF94L4FJ0nBFl5LICzANBgkqhkiG9w0BAQsFADAb diff --git a/src/libraries/System.Net.Http.WinHttpHandler/tests/UnitTests/System.Net.Http.WinHttpHandler.Unit.Tests.csproj b/src/libraries/System.Net.Http.WinHttpHandler/tests/UnitTests/System.Net.Http.WinHttpHandler.Unit.Tests.csproj index f8b72896871..988c1cc1014 100644 --- a/src/libraries/System.Net.Http.WinHttpHandler/tests/UnitTests/System.Net.Http.WinHttpHandler.Unit.Tests.csproj +++ b/src/libraries/System.Net.Http.WinHttpHandler/tests/UnitTests/System.Net.Http.WinHttpHandler.Unit.Tests.csproj @@ -1,6 +1,6 @@ - $(NoWarn);0436;SYSLIB0057 + $(NoWarn);0436 true ../../src/Resources/Strings.resx $(NetCoreAppCurrent)-windows diff --git a/src/libraries/System.Net.Http/System.Net.Http.sln b/src/libraries/System.Net.Http/System.Net.Http.sln index e367915f11f..47badafabfc 100644 --- a/src/libraries/System.Net.Http/System.Net.Http.sln +++ b/src/libraries/System.Net.Http/System.Net.Http.sln @@ -63,6 +63,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Runtime.InteropServi EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{FC847978-9218-451E-BD07-910E11D59AD1}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{F91866FB-CC5E-44BB-A764-EC32D7B325D4}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{98AA859A-14F1-465D-80D6-343A4075CC7B}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{786ED1A9-1EFF-4BC4-A833-E680D9960F72}" @@ -811,6 +813,27 @@ Global {FC847978-9218-451E-BD07-910E11D59AD1}.Checked|arm64.ActiveCfg = Debug|Any CPU {FC847978-9218-451E-BD07-910E11D59AD1}.Checked|x64.ActiveCfg = Debug|Any CPU {FC847978-9218-451E-BD07-910E11D59AD1}.Checked|x86.ActiveCfg = Debug|Any CPU + {F91866FB-CC5E-44BB-A764-EC32D7B325D4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F91866FB-CC5E-44BB-A764-EC32D7B325D4}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F91866FB-CC5E-44BB-A764-EC32D7B325D4}.Debug|arm.ActiveCfg = Debug|Any CPU + {F91866FB-CC5E-44BB-A764-EC32D7B325D4}.Debug|arm64.ActiveCfg = Debug|Any CPU + {F91866FB-CC5E-44BB-A764-EC32D7B325D4}.Debug|x64.ActiveCfg = Debug|Any CPU + {F91866FB-CC5E-44BB-A764-EC32D7B325D4}.Debug|x64.Build.0 = Debug|Any CPU + {F91866FB-CC5E-44BB-A764-EC32D7B325D4}.Debug|x86.ActiveCfg = Debug|Any CPU + {F91866FB-CC5E-44BB-A764-EC32D7B325D4}.Debug|x86.Build.0 = Debug|Any CPU + {F91866FB-CC5E-44BB-A764-EC32D7B325D4}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F91866FB-CC5E-44BB-A764-EC32D7B325D4}.Release|Any CPU.Build.0 = Release|Any CPU + {F91866FB-CC5E-44BB-A764-EC32D7B325D4}.Release|arm.ActiveCfg = Release|Any CPU + {F91866FB-CC5E-44BB-A764-EC32D7B325D4}.Release|arm64.ActiveCfg = Release|Any CPU + {F91866FB-CC5E-44BB-A764-EC32D7B325D4}.Release|x64.ActiveCfg = Release|Any CPU + {F91866FB-CC5E-44BB-A764-EC32D7B325D4}.Release|x64.Build.0 = Release|Any CPU + {F91866FB-CC5E-44BB-A764-EC32D7B325D4}.Release|x86.ActiveCfg = Release|Any CPU + {F91866FB-CC5E-44BB-A764-EC32D7B325D4}.Release|x86.Build.0 = Release|Any CPU + {F91866FB-CC5E-44BB-A764-EC32D7B325D4}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {F91866FB-CC5E-44BB-A764-EC32D7B325D4}.Checked|arm.ActiveCfg = Debug|Any CPU + {F91866FB-CC5E-44BB-A764-EC32D7B325D4}.Checked|arm64.ActiveCfg = Debug|Any CPU + {F91866FB-CC5E-44BB-A764-EC32D7B325D4}.Checked|x64.ActiveCfg = Debug|Any CPU + {F91866FB-CC5E-44BB-A764-EC32D7B325D4}.Checked|x86.ActiveCfg = Debug|Any CPU {98AA859A-14F1-465D-80D6-343A4075CC7B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {98AA859A-14F1-465D-80D6-343A4075CC7B}.Debug|Any CPU.Build.0 = Debug|Any CPU {98AA859A-14F1-465D-80D6-343A4075CC7B}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -1193,6 +1216,7 @@ Global {8371A98E-13A9-41BD-99AF-BBF9E67BBE0A} = {7841027C-6B57-4756-A757-8B19ECA0D9C7} {17069DE3-C00A-4A4C-9FAF-557F2E8A6197} = {7841027C-6B57-4756-A757-8B19ECA0D9C7} {FC847978-9218-451E-BD07-910E11D59AD1} = {7841027C-6B57-4756-A757-8B19ECA0D9C7} + {F91866FB-CC5E-44BB-A764-EC32D7B325D4} = {7841027C-6B57-4756-A757-8B19ECA0D9C7} {98AA859A-14F1-465D-80D6-343A4075CC7B} = {7841027C-6B57-4756-A757-8B19ECA0D9C7} {786ED1A9-1EFF-4BC4-A833-E680D9960F72} = {7841027C-6B57-4756-A757-8B19ECA0D9C7} {AA699427-03F4-4247-A537-0BFB872BD177} = {6A8E1C6E-AED3-4791-8A4E-2F984E96C675} diff --git a/src/libraries/System.Net.Http/src/ILLink/ILLink.Substitutions.mobile.xml b/src/libraries/System.Net.Http/src/ILLink/ILLink.Substitutions.mobile.xml deleted file mode 100644 index 208bba9a30a..00000000000 --- a/src/libraries/System.Net.Http/src/ILLink/ILLink.Substitutions.mobile.xml +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - - - diff --git a/src/libraries/System.Net.Http/src/System.Net.Http.csproj b/src/libraries/System.Net.Http/src/System.Net.Http.csproj index 03e55dc3b04..1363b6aa04a 100644 --- a/src/libraries/System.Net.Http/src/System.Net.Http.csproj +++ b/src/libraries/System.Net.Http/src/System.Net.Http.csproj @@ -24,19 +24,10 @@ true - - - $(DefineConstants);NATIVE_AOT - - - - - - @@ -175,7 +166,7 @@ - + @@ -333,13 +324,13 @@ - + - + @@ -416,7 +407,7 @@ Link="Common\System\Runtime\ExceptionServices\ExceptionStackTrace.cs" /> - + - + @@ -461,21 +452,29 @@ Link="Common\System\Net\Http\HttpHandlerDefaults.cs" /> - - - + + + + + + + + + + - - - - - - - - - - + + + + + + + + + + @@ -498,7 +497,7 @@ - + @@ -506,15 +505,16 @@ + - + - + diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/GlobalHttpSettings.cs b/src/libraries/System.Net.Http/src/System/Net/Http/GlobalHttpSettings.cs index 72c9a4a3fc5..e314957414b 100644 --- a/src/libraries/System.Net.Http/src/System/Net/Http/GlobalHttpSettings.cs +++ b/src/libraries/System.Net.Http/src/System/Net/Http/GlobalHttpSettings.cs @@ -23,7 +23,7 @@ internal static class DiagnosticsHandler internal static class SocketsHttpHandler { -#if !BROWSER +#if !TARGET_BROWSER && !TARGET_WASI // Default to allowing HTTP/2, but enable that to be overridden by an // AppContext switch, or by an environment variable being set to false/0. public static bool AllowHttp2 { get; } = RuntimeSettingParser.QueryRuntimeSettingSwitch( diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/Headers/KnownHeaders.cs b/src/libraries/System.Net.Http/src/System/Net/Http/Headers/KnownHeaders.cs index ac819868f77..1b412481a3b 100644 --- a/src/libraries/System.Net.Http/src/System/Net/Http/Headers/KnownHeaders.cs +++ b/src/libraries/System.Net.Http/src/System/Net/Http/Headers/KnownHeaders.cs @@ -108,7 +108,7 @@ internal static class KnownHeaders public static readonly KnownHeader XUACompatible = new KnownHeader("X-UA-Compatible"); public static readonly KnownHeader XXssProtection = new KnownHeader("X-XSS-Protection", HttpHeaderType.Custom, null, new string[] { "0", "1", "1; mode=block" }); -#if TARGET_BROWSER +#if TARGET_BROWSER || TARGET_WASI private static HttpHeaderParser? GetAltSvcHeaderParser() => null; // Allow for the AltSvcHeaderParser to be trimmed on Browser since Alt-Svc is only for SocketsHttpHandler, which isn't used on Browser. #else private static AltSvcHeaderParser? GetAltSvcHeaderParser() => AltSvcHeaderParser.Parser; diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/HttpClientHandler.AnyMobile.cs b/src/libraries/System.Net.Http/src/System/Net/Http/HttpClientHandler.AnyMobile.cs index a8f7613b7e0..6037df88bef 100644 --- a/src/libraries/System.Net.Http/src/System/Net/Http/HttpClientHandler.AnyMobile.cs +++ b/src/libraries/System.Net.Http/src/System/Net/Http/HttpClientHandler.AnyMobile.cs @@ -789,6 +789,7 @@ private void ThrowForModifiedManagedSslOptionsIfStarted() _socketHandler!.SslOptions = _socketHandler!.SslOptions; } + [FeatureSwitchDefinition("System.Net.Http.UseNativeHttpHandler")] private static bool IsNativeHandlerEnabled => RuntimeSettingParser.QueryRuntimeSettingSwitch( "System.Net.Http.UseNativeHttpHandler", false); diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/HttpClientHandler.cs b/src/libraries/System.Net.Http/src/System/Net/Http/HttpClientHandler.cs index 02c333177ba..afba32455bc 100644 --- a/src/libraries/System.Net.Http/src/System/Net/Http/HttpClientHandler.cs +++ b/src/libraries/System.Net.Http/src/System/Net/Http/HttpClientHandler.cs @@ -10,8 +10,7 @@ using System.Threading; using System.Threading.Tasks; using System.Diagnostics.Metrics; -// TODO-LLVM: This is not upstreamable and should be deleted when https://github.com/dotnet/runtimelab/pull/2614 is merged -#if TARGET_WASI && !NATIVE_AOT +#if TARGET_WASI using System.Diagnostics; using System.Net.Http.Metrics; using HttpHandlerType = System.Net.Http.WasiHttpHandler; @@ -29,8 +28,7 @@ public partial class HttpClientHandler : HttpMessageHandler { private readonly HttpHandlerType _underlyingHandler; -// TODO-LLVM: This is not upstreamable and !NATIVE_AOT should be reverted when https://github.com/dotnet/runtimelab/pull/2614 is merged -#if TARGET_BROWSER || (TARGET_WASI && !NATIVE_AOT) +#if TARGET_BROWSER || TARGET_WASI private IMeterFactory? _meterFactory; private HttpMessageHandler? _firstHandler; // DiagnosticsHandler or MetricsHandler, depending on global configuration. @@ -100,8 +98,7 @@ protected override void Dispose(bool disposing) [CLSCompliant(false)] public IMeterFactory? MeterFactory { -// TODO-LLVM: This is not upstreamable and !NATIVE_AOT should be reverted when https://github.com/dotnet/runtimelab/pull/2614 is merged -#if TARGET_BROWSER || (TARGET_WASI && !NATIVE_AOT) +#if TARGET_BROWSER || TARGET_WASI get => _meterFactory; set { diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/HttpProtocolException.cs b/src/libraries/System.Net.Http/src/System/Net/Http/HttpProtocolException.cs index e61ecba6305..1314f9e3458 100644 --- a/src/libraries/System.Net.Http/src/System/Net/Http/HttpProtocolException.cs +++ b/src/libraries/System.Net.Http/src/System/Net/Http/HttpProtocolException.cs @@ -35,7 +35,7 @@ public HttpProtocolException(long errorCode, string message, Exception? innerExc /// public long ErrorCode { get; } -#if !TARGET_BROWSER +#if !TARGET_BROWSER && !TARGET_WASI internal static HttpProtocolException CreateHttp2StreamException(Http2ProtocolErrorCode protocolError) { string message = SR.Format(SR.net_http_http2_stream_error, GetName(protocolError), ((int)protocolError).ToString("x")); diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/SocketsHttpHandler.cs b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/SocketsHttpHandler.cs index 172bca3be17..6c0a8208508 100644 --- a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/SocketsHttpHandler.cs +++ b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/SocketsHttpHandler.cs @@ -36,7 +36,7 @@ private void CheckDisposedOrStarted() /// Gets a value that indicates whether the handler is supported on the current platform. /// [UnsupportedOSPlatformGuard("browser")] - public static bool IsSupported => !(OperatingSystem.IsBrowser() || OperatingSystem.IsWasi()); + public static bool IsSupported => !OperatingSystem.IsBrowser() && !OperatingSystem.IsWasi(); public bool UseCookies { diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/SystemProxyInfo.Wasi.cs b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/SystemProxyInfo.Wasi.cs new file mode 100644 index 00000000000..845223cdf32 --- /dev/null +++ b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/SystemProxyInfo.Wasi.cs @@ -0,0 +1,10 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace System.Net.Http +{ + internal static partial class SystemProxyInfo + { + public static IWebProxy Proxy => new HttpNoProxy(); + } +} diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttp.cs b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttp.cs index 67ec0a4b7c8..f527ad573b8 100644 --- a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttp.cs +++ b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttp.cs @@ -1,4 +1,4 @@ -// Generated by `wit-bindgen` 0.29.0. DO NOT EDIT! +// Generated by `wit-bindgen` 0.32.0. DO NOT EDIT! // #nullable enable using System; diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpHandler.cs b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpHandler.cs index dcccb989910..bf3cc3132ba 100644 --- a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpHandler.cs +++ b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpHandler.cs @@ -12,15 +12,165 @@ using System.Threading; using System.Threading.Tasks; using WasiHttpWorld; -using WasiHttpWorld.wit.imports.wasi.http.v0_2_1; -using WasiHttpWorld.wit.imports.wasi.io.v0_2_1; +using WasiHttpWorld.wit.imports.wasi.http.v0_2_0; +using WasiHttpWorld.wit.imports.wasi.io.v0_2_0; +using static WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes; namespace System.Net.Http { + // on top of https://github.com/WebAssembly/wasi-http/blob/main/wit/types.wit + internal sealed class WasiRequestWrapper : IDisposable + { + private WasiOutputStream? wasiOutputStream; // disposal could be made earlier from this instance's Dispose + private WasiInputStream? incomingStream; // disposal could be made earlier from this instance's Dispose + private FutureIncomingResponse? future; // owned by this instance + private bool isDisposed; + + public async Task SendRequestAsync(HttpRequestMessage request, CancellationToken cancellationToken) + { + if (request.RequestUri is null) + { + throw new ArgumentException(); + } + + try + { + var requestHeaders = WasiHttpInterop.ConvertRequestHeaders(request); + var outgoingRequest = new OutgoingRequest(requestHeaders); // passing requestHeaders ownership + outgoingRequest.SetMethod(WasiHttpInterop.ConvertMethod(request.Method)); + outgoingRequest.SetScheme(WasiHttpInterop.ConvertScheme(request.RequestUri)); + outgoingRequest.SetAuthority(WasiHttpInterop.ConvertAuthority(request.RequestUri)); + outgoingRequest.SetPathWithQuery(request.RequestUri.PathAndQuery); + +#pragma warning disable CS4014 // intentionaly not awaited + SendContent(request.Content, outgoingRequest, cancellationToken); +#pragma warning restore CS4014 + + future = OutgoingHandlerInterop.Handle(outgoingRequest, null); + + using var incomingResponse = await SendRequest(cancellationToken).ConfigureAwait(false); + + ObjectDisposedException.ThrowIf(isDisposed, this); + cancellationToken.ThrowIfCancellationRequested(); + + var response = new HttpResponseMessage((HttpStatusCode)incomingResponse.Status()); + response.RequestMessage = request; + + // request body could be still streaming after response headers are received and started streaming response + // we will leave scope of this method + // we need to pass the ownership of the request and this wrapper to the response (via response content stream) + // unless we know that we are not streaming anymore + incomingStream = new WasiInputStream(this, incomingResponse.Consume());// passing self ownership, passing body ownership + response.Content = new StreamContent(incomingStream); // passing incomingStream ownership to SendAsync() caller + WasiHttpInterop.ConvertResponseHeaders(incomingResponse, response); + + return response; + } + catch (WitException e) + { + throw new HttpRequestException(WasiHttpInterop.ErrorCodeToString((ErrorCode)e.Value), e); + } + catch (Exception) + { + throw; + } + } + + private async Task SendRequest(CancellationToken cancellationToken) + { + try + { + while (true) + { + var response = (Result, None>?)future!.Get(); + if (response.HasValue) + { + var result = response.Value.AsOk; + + if (result.IsOk) + { + return result.AsOk; + } + else + { + throw new HttpRequestException(WasiHttpInterop.ErrorCodeToString(result.AsErr)); + } + } + else + { + await WasiHttpInterop.RegisterWasiPollable(future.Subscribe(), cancellationToken).ConfigureAwait(false); + } + } + } + catch (OperationCanceledException oce) + { + if (cancellationToken.IsCancellationRequested) + { + Http.CancellationHelper.ThrowIfCancellationRequested(oce, cancellationToken); + } + throw; + } + } + + public async Task SendContent(HttpContent? content, OutgoingRequest outgoingRequest, CancellationToken cancellationToken) + { + if (content is not null) + { + wasiOutputStream = new WasiOutputStream(outgoingRequest.Body()); // passing body ownership + await content.CopyToAsync(wasiOutputStream, cancellationToken).ConfigureAwait(false); + wasiOutputStream.Close(); + } + } + + ~WasiRequestWrapper() + { + Dispose(); + GC.SuppressFinalize(this); + } + + public void Dispose() + { + if (!isDisposed) + { + isDisposed = true; + wasiOutputStream?.Dispose(); + incomingStream?.Dispose(); + future?.Dispose(); + } + } + } + internal sealed class WasiHttpHandler : HttpMessageHandler { + public const bool SupportsAutomaticDecompression = false; + public const bool SupportsProxy = false; + public const bool SupportsRedirectConfiguration = false; + + private Dictionary? _properties; + public IDictionary Properties => _properties ??= new Dictionary(); + + protected internal override async Task SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) + { + var wasiRequest = new WasiRequestWrapper(); + try + { + return await wasiRequest.SendRequestAsync(request, cancellationToken).ConfigureAwait(false); + } + catch + { + // if there was exception or cancellation, we need to dispose the request + // otherwise it will be disposed by the response + wasiRequest.Dispose(); + throw; + } + } + #region PlatformNotSupported #pragma warning disable CA1822 + + internal ClientCertificateOption ClientCertificateOptions; + + public bool UseCookies { get => throw new PlatformNotSupportedException(); @@ -99,17 +249,6 @@ public bool AllowAutoRedirect set => throw new PlatformNotSupportedException(); } #pragma warning restore CA1822 - #endregion - - internal ClientCertificateOption ClientCertificateOptions; - - public const bool SupportsAutomaticDecompression = false; - public const bool SupportsProxy = false; - public const bool SupportsRedirectConfiguration = false; - - private Dictionary? _properties; - public IDictionary Properties => - _properties ??= new Dictionary(); protected internal override HttpResponseMessage Send( HttpRequestMessage request, @@ -119,631 +258,6 @@ CancellationToken cancellationToken throw new PlatformNotSupportedException(); } - protected internal override async Task SendAsync( - HttpRequestMessage request, - CancellationToken cancellationToken - ) - { - if (request.RequestUri is null) - { - throw new ArgumentException(); - } - - var requestMethod = request.Method.ToString(); - var uri = request.RequestUri; - - ITypes.Method method; - switch (requestMethod) - { - case "": - case "GET": - method = ITypes.Method.get(); - break; - case "HEAD": - method = ITypes.Method.head(); - break; - case "POST": - method = ITypes.Method.post(); - break; - case "PUT": - method = ITypes.Method.put(); - break; - case "DELETE": - method = ITypes.Method.delete(); - break; - case "CONNECT": - method = ITypes.Method.connect(); - break; - case "OPTIONS": - method = ITypes.Method.options(); - break; - case "TRACE": - method = ITypes.Method.trace(); - break; - case "PATCH": - method = ITypes.Method.patch(); - break; - default: - method = ITypes.Method.other(requestMethod); - break; - } - - ITypes.Scheme scheme; - switch (uri.Scheme) - { - case "": - case "http": - scheme = ITypes.Scheme.http(); - break; - case "https": - scheme = ITypes.Scheme.https(); - break; - default: - scheme = ITypes.Scheme.other(uri.Scheme); - break; - } - - string authority; - if (uri.Authority.Length == 0) - { - // `wasi:http/outgoing-handler` requires a non-empty authority, - // so we set one here: - if (scheme.Tag == ITypes.Scheme.HTTPS) - { - authority = ":443"; - } - else - { - authority = ":80"; - } - } - else - { - authority = uri.Authority; - } - - var headers = new List<(string, byte[])>(); - foreach (var pair in request.Headers) - { - foreach (var value in pair.Value) - { - headers.Add((pair.Key, Encoding.UTF8.GetBytes(value))); - } - } - if (request.Content is not null) - { - foreach (var pair in request.Content.Headers) - { - foreach (var value in pair.Value) - { - headers.Add((pair.Key, Encoding.UTF8.GetBytes(value))); - } - } - } - - var outgoingRequest = new ITypes.OutgoingRequest(ITypes.Fields.FromList(headers)); - outgoingRequest.SetMethod(method); - outgoingRequest.SetScheme(scheme); - outgoingRequest.SetAuthority(authority); - outgoingRequest.SetPathWithQuery(uri.PathAndQuery); - - var outgoingStream = new OutputStream(outgoingRequest.Body()); - - Func> sendContent = async () => - { - await SendContentAsync(request.Content, outgoingStream).ConfigureAwait(false); - return null; - }; - - // Concurrently send the request and the content stream, allowing - // the server to start sending a response before it's received the - // entire request body. - var incomingResponse = ( - await Task.WhenAll( - new Task[] - { - SendRequestAsync(outgoingRequest), - sendContent() - } - ) - .ConfigureAwait(false) - )[0]; - - if (incomingResponse is null) - { - // Shouldn't be possible, since `SendRequestAsync` always - // returns a non-null value. - throw new Exception("unreachable code"); - } - - var response = new HttpResponseMessage((HttpStatusCode)incomingResponse.Status()); - var responseHeaders = incomingResponse.Headers().Entries(); - response.Content = new StreamContent(new InputStream(incomingResponse.Consume())); - foreach ((var key, var value) in responseHeaders) - { - var valueString = Encoding.UTF8.GetString(value); - if ( - HeaderDescriptor.TryGet(key, out HeaderDescriptor descriptor) - && (descriptor.HeaderType & HttpHeaderType.Content) != 0 - ) - { - response.Content.Headers.Add(key, valueString); - } - else - { - response.Headers.Add(key, valueString); - } - } - - return response; - } - - private static async Task SendRequestAsync( - ITypes.OutgoingRequest request - ) - { - ITypes.FutureIncomingResponse future; - try - { - future = OutgoingHandlerInterop.Handle(request, null); - } - catch (WasiHttpWorld.WitException e) - { - var message = ErrorCodeToString((ITypes.ErrorCode)e.Value); - throw new Exception($"Request Error: {message}"); - } - - while (true) - { - var response = future.Get(); - if (response is not null) - { - var result = ( - (Result, None>)response - ).AsOk; - - if (result.IsOk) - { - return result.AsOk; - } - else - { - var message = ErrorCodeToString(result.AsErr); - throw new Exception($"Request Error: {message}"); - } - } - else - { - await RegisterWasiPollable(future.Subscribe()).ConfigureAwait(false); - } - } - } - - private static string ErrorCodeToString(ITypes.ErrorCode code) - { - // TODO: include payload data in result where applicable - switch (code.Tag) - { - case ITypes.ErrorCode.DNS_TIMEOUT: - return "DNS_TIMEOUT"; - - case ITypes.ErrorCode.DNS_ERROR: - return "DNS_ERROR"; - - case ITypes.ErrorCode.DESTINATION_NOT_FOUND: - return "DESTINATION_NOT_FOUND"; - - case ITypes.ErrorCode.DESTINATION_UNAVAILABLE: - return "DESTINATION_UNAVAILABLE"; - - case ITypes.ErrorCode.DESTINATION_IP_PROHIBITED: - return "DESTINATION_IP_PROHIBITED"; - - case ITypes.ErrorCode.DESTINATION_IP_UNROUTABLE: - return "DESTINATION_IP_UNROUTABLE"; - - case ITypes.ErrorCode.CONNECTION_REFUSED: - return "CONNECTION_REFUSED"; - - case ITypes.ErrorCode.CONNECTION_TERMINATED: - return "CONNECTION_TERMINATED"; - - case ITypes.ErrorCode.CONNECTION_TIMEOUT: - return "CONNECTION_TIMEOUT"; - - case ITypes.ErrorCode.CONNECTION_READ_TIMEOUT: - return "CONNECTION_READ_TIMEOUT"; - - case ITypes.ErrorCode.CONNECTION_WRITE_TIMEOUT: - return "CONNECTION_WRITE_TIMEOUT"; - - case ITypes.ErrorCode.CONNECTION_LIMIT_REACHED: - return "CONNECTION_LIMIT_REACHED"; - - case ITypes.ErrorCode.TLS_PROTOCOL_ERROR: - return "TLS_PROTOCOL_ERROR"; - - case ITypes.ErrorCode.TLS_CERTIFICATE_ERROR: - return "TLS_CERTIFICATE_ERROR"; - - case ITypes.ErrorCode.TLS_ALERT_RECEIVED: - return "TLS_ALERT_RECEIVED"; - - case ITypes.ErrorCode.HTTP_REQUEST_DENIED: - return "HTTP_REQUEST_DENIED"; - - case ITypes.ErrorCode.HTTP_REQUEST_LENGTH_REQUIRED: - return "HTTP_REQUEST_LENGTH_REQUIRED"; - - case ITypes.ErrorCode.HTTP_REQUEST_BODY_SIZE: - return "HTTP_REQUEST_BODY_SIZE"; - - case ITypes.ErrorCode.HTTP_REQUEST_METHOD_INVALID: - return "HTTP_REQUEST_METHOD_INVALID"; - - case ITypes.ErrorCode.HTTP_REQUEST_URI_INVALID: - return "HTTP_REQUEST_URI_INVALID"; - - case ITypes.ErrorCode.HTTP_REQUEST_URI_TOO_LONG: - return "HTTP_REQUEST_URI_TOO_LONG"; - - case ITypes.ErrorCode.HTTP_REQUEST_HEADER_SECTION_SIZE: - return "HTTP_REQUEST_HEADER_SECTION_SIZE"; - - case ITypes.ErrorCode.HTTP_REQUEST_HEADER_SIZE: - return "HTTP_REQUEST_HEADER_SIZE"; - - case ITypes.ErrorCode.HTTP_REQUEST_TRAILER_SECTION_SIZE: - return "HTTP_REQUEST_TRAILER_SECTION_SIZE"; - - case ITypes.ErrorCode.HTTP_REQUEST_TRAILER_SIZE: - return "HTTP_REQUEST_TRAILER_SIZE"; - - case ITypes.ErrorCode.HTTP_RESPONSE_INCOMPLETE: - return "HTTP_RESPONSE_INCOMPLETE"; - - case ITypes.ErrorCode.HTTP_RESPONSE_HEADER_SECTION_SIZE: - return "HTTP_RESPONSE_HEADER_SECTION_SIZE"; - - case ITypes.ErrorCode.HTTP_RESPONSE_HEADER_SIZE: - return "HTTP_RESPONSE_HEADER_SIZE"; - - case ITypes.ErrorCode.HTTP_RESPONSE_BODY_SIZE: - return "HTTP_RESPONSE_BODY_SIZE"; - - case ITypes.ErrorCode.HTTP_RESPONSE_TRAILER_SECTION_SIZE: - return "HTTP_RESPONSE_TRAILER_SECTION_SIZE"; - - case ITypes.ErrorCode.HTTP_RESPONSE_TRAILER_SIZE: - return "HTTP_RESPONSE_TRAILER_SIZE"; - - case ITypes.ErrorCode.HTTP_RESPONSE_TRANSFER_CODING: - return "HTTP_RESPONSE_TRANSFER_CODING"; - - case ITypes.ErrorCode.HTTP_RESPONSE_CONTENT_CODING: - return "HTTP_RESPONSE_CONTENT_CODING"; - - case ITypes.ErrorCode.HTTP_RESPONSE_TIMEOUT: - return "HTTP_RESPONSE_TIMEOUT"; - - case ITypes.ErrorCode.HTTP_UPGRADE_FAILED: - return "HTTP_UPGRADE_FAILED"; - - case ITypes.ErrorCode.HTTP_PROTOCOL_ERROR: - return "HTTP_PROTOCOL_ERROR"; - - case ITypes.ErrorCode.LOOP_DETECTED: - return "LOOP_DETECTED"; - - case ITypes.ErrorCode.CONFIGURATION_ERROR: - return "CONFIGURATION_ERROR"; - - case ITypes.ErrorCode.INTERNAL_ERROR: - return "INTERNAL_ERROR"; - - default: - return $"{code.Tag}"; - } - } - - private static async Task SendContentAsync(HttpContent? content, Stream stream) - { - try - { - if (content is not null) - { - await content.CopyToAsync(stream).ConfigureAwait(false); - } - } - finally - { - stream.Dispose(); - } - } - - private static Task RegisterWasiPollable(IPoll.Pollable pollable) - { - var handle = pollable.Handle; - - // this will effectively neutralize Dispose() of the Pollable() - // because in the CoreLib we create another instance, which will dispose it - pollable.Handle = 0; - GC.SuppressFinalize(pollable); - - return CallRegisterWasiPollableHandle((Thread)null!, handle); - - } - - [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "RegisterWasiPollableHandle")] - private static extern Task CallRegisterWasiPollableHandle(Thread t, int handle); - - private sealed class InputStream : Stream - { - private ITypes.IncomingBody body; - private IStreams.InputStream stream; - private int offset; - private byte[]? buffer; - private bool closed; - - public InputStream(ITypes.IncomingBody body) - { - this.body = body; - this.stream = body.Stream(); - } - - ~InputStream() - { - Dispose(false); - } - - public override bool CanRead => true; - public override bool CanWrite => false; - public override bool CanSeek => false; - public override long Length => throw new NotImplementedException(); - public override long Position - { - get => throw new NotImplementedException(); - set => throw new NotImplementedException(); - } - - protected override void Dispose(bool disposing) - { - stream.Dispose(); - ITypes.IncomingBody.Finish(body); - } - - public override long Seek(long offset, SeekOrigin origin) - { - throw new NotImplementedException(); - } - - public override void Flush() - { - // ignore - } - - public override void SetLength(long length) - { - throw new NotImplementedException(); - } - - public override int Read(byte[] buffer, int offset, int length) - { - throw new NotImplementedException(); - } - - public override void Write(byte[] buffer, int offset, int length) - { - throw new NotImplementedException(); - } - - public override async Task ReadAsync( - byte[] bytes, - int offset, - int length, - CancellationToken cancellationToken - ) - { - // TODO: handle `cancellationToken` - while (true) - { - if (closed) - { - return 0; - } - else if (this.buffer == null) - { - try - { - // TODO: should we add a special case to the bindings generator - // to allow passing a buffer to IStreams.InputStream.Read and - // avoid the extra copy? - var result = stream.Read(16 * 1024); - var buffer = result; - if (buffer.Length == 0) - { - await RegisterWasiPollable(stream.Subscribe()) - .ConfigureAwait(false); - } - else - { - this.buffer = buffer; - this.offset = 0; - } - } - catch (WitException e) - { - if (((IStreams.StreamError)e.Value).Tag == IStreams.StreamError.CLOSED) - { - closed = true; - return 0; - } - else - { - throw e; - } - } - } - else - { - var min = Math.Min(this.buffer.Length - this.offset, length); - Array.Copy(this.buffer, this.offset, bytes, offset, min); - if (min < buffer.Length - this.offset) - { - this.offset += min; - } - else - { - this.buffer = null; - } - return min; - } - } - } - - public override async ValueTask ReadAsync( - Memory buffer, - CancellationToken cancellationToken = default - ) - { - // TODO: avoid copy when possible and use ArrayPool when not - var dst = new byte[buffer.Length]; - // We disable "CA1835: Prefer the memory-based overloads of - // ReadAsync/WriteAsync methods in stream-based classes" for - // now, since `ReadyAsync(byte[], int, int, CancellationToken)` - // is where the implementation currently resides, but we should - // revisit this if/when `wit-bindgen` learns to generate - // memory-based bindings. -#pragma warning disable CA1835 - var result = await ReadAsync(dst, 0, buffer.Length, cancellationToken) - .ConfigureAwait(false); -#pragma warning restore CA1835 - new ReadOnlySpan(dst, 0, result).CopyTo(buffer.Span); - return result; - } - } - - private sealed class OutputStream : Stream - { - private ITypes.OutgoingBody body; - private IStreams.OutputStream stream; - - public OutputStream(ITypes.OutgoingBody body) - { - this.body = body; - this.stream = body.Write(); - } - - ~OutputStream() - { - Dispose(false); - } - - public override bool CanRead => false; - public override bool CanWrite => true; - public override bool CanSeek => false; - public override long Length => throw new NotImplementedException(); - public override long Position - { - get => throw new NotImplementedException(); - set => throw new NotImplementedException(); - } - - protected override void Dispose(bool disposing) - { - stream.Dispose(); - ITypes.OutgoingBody.Finish(body, null); - } - - public override long Seek(long offset, SeekOrigin origin) - { - throw new NotImplementedException(); - } - - public override void Flush() - { - // ignore - // - // Note that flushing a `wasi:io/streams/output-stream` is an - // asynchronous operation, so it's not clear how we would - // implement it here instead of taking care of it as part of - // `WriteAsync`. - } - - public override void SetLength(long length) - { - throw new NotImplementedException(); - } - - public override int Read(byte[] buffer, int offset, int length) - { - throw new NotImplementedException(); - } - - public override void Write(byte[] buffer, int offset, int length) - { - throw new NotImplementedException(); - } - - public override async Task WriteAsync( - byte[] bytes, - int offset, - int length, - CancellationToken cancellationToken - ) - { - var limit = offset + length; - var flushing = false; - while (true) - { - var count = (int)stream.CheckWrite(); - if (count == 0) - { - await RegisterWasiPollable(stream.Subscribe()).ConfigureAwait(false); - } - else if (offset == limit) - { - if (flushing) - { - return; - } - else - { - stream.Flush(); - flushing = true; - } - } - else - { - var min = Math.Min(count, limit - offset); - if (offset == 0 && min == bytes.Length) - { - stream.Write(bytes); - } - else - { - // TODO: is there a more efficient option than copying here? - // Do we need to change the binding generator to accept - // e.g. `Span`s? - var copy = new byte[min]; - Array.Copy(bytes, offset, copy, 0, min); - stream.Write(copy); - } - offset += min; - } - } - } - - public override ValueTask WriteAsync( - ReadOnlyMemory buffer, - CancellationToken cancellationToken = default - ) - { - // TODO: avoid copy when possible and use ArrayPool when not - var copy = new byte[buffer.Length]; - buffer.Span.CopyTo(copy); - return new ValueTask(WriteAsync(copy, 0, buffer.Length, cancellationToken)); - } - } + #endregion } } diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpInterop.cs b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpInterop.cs new file mode 100644 index 00000000000..c99f3281492 --- /dev/null +++ b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpInterop.cs @@ -0,0 +1,313 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; +using System.Net.Http.Headers; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices.Marshalling; +using System.Text; +using System.Threading; +using System.Threading.Tasks; +using WasiHttpWorld; +using WasiHttpWorld.wit.imports.wasi.http.v0_2_0; +using WasiHttpWorld.wit.imports.wasi.io.v0_2_0; +using static WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes; +using static WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams; + +namespace System.Net.Http +{ + internal static class WasiHttpInterop + { + public static Task RegisterWasiPollable(IPoll.Pollable pollable, CancellationToken cancellationToken) + { + var handle = pollable.Handle; + + // this will effectively neutralize Dispose() of the Pollable() + // because in the CoreLib we create another instance, which will dispose it + pollable.Handle = 0; + GC.SuppressFinalize(pollable); + + return CallRegisterWasiPollableHandle((Thread)null!, handle, true, cancellationToken); + + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "RegisterWasiPollableHandle")] + static extern Task CallRegisterWasiPollableHandle(Thread t, int handle, bool ownsPollable, CancellationToken cancellationToken); + } + + public static Method ConvertMethod(HttpMethod requestMethod) + { + Method method; + switch (requestMethod.Method) + { + case "": + case "GET": + method = Method.get(); + break; + case "HEAD": + method = Method.head(); + break; + case "POST": + method = Method.post(); + break; + case "PUT": + method = Method.put(); + break; + case "DELETE": + method = Method.delete(); + break; + case "CONNECT": + method = Method.connect(); + break; + case "OPTIONS": + method = Method.options(); + break; + case "TRACE": + method = Method.trace(); + break; + case "PATCH": + method = Method.patch(); + break; + default: + method = Method.other(requestMethod.Method); + break; + } + return method; + } + + public static Scheme ConvertScheme(Uri uri) + { + Scheme scheme; + switch (uri.Scheme) + { + case "": + case "http": + scheme = Scheme.http(); + break; + case "https": + scheme = Scheme.https(); + break; + default: + scheme = Scheme.other(uri.Scheme); + break; + } + return scheme; + } + + public static string ConvertAuthority(Uri uri) + { + // `wasi:http/outgoing-handler` requires a non-empty authority, + // so we set one here: + if (string.IsNullOrEmpty(uri.Authority)) + { + if (uri.Scheme == "https") + { + return ":443"; + } + else + { + return ":80"; + } + } + else + { + return uri.Authority; + } + } + + public static Fields ConvertRequestHeaders(HttpRequestMessage request) + { + var headers = new List<(string, byte[])>(); + foreach (var pair in request.Headers) + { + foreach (var value in pair.Value) + { + headers.Add((pair.Key, Encoding.UTF8.GetBytes(value))); + } + } + if (request.Content is not null) + { + foreach (var pair in request.Content.Headers) + { + foreach (var value in pair.Value) + { + headers.Add((pair.Key, Encoding.UTF8.GetBytes(value))); + } + } + } + try + { + return Fields.FromList(headers); + } + catch (WitException e) + { + var error = HeaderErrorToString((HeaderError)e.Value); + throw new HttpRequestException($"Header validation error: {error}"); + } + } + + private static string HeaderErrorToString(HeaderError error) + { + switch (error.Tag) + { + case ITypes.HeaderError.INVALID_SYNTAX: + return "INVALID_SYNTAX"; + case ITypes.HeaderError.FORBIDDEN: + return "FORBIDDEN"; + case ITypes.HeaderError.IMMUTABLE: + return "IMMUTABLE"; + default: + return $"{error.Tag}"; + } + } + + public static void ConvertResponseHeaders(IncomingResponse incomingResponse, HttpResponseMessage response) + { + using var headers = incomingResponse.Headers(); + foreach ((var key, var value) in headers.Entries()) + { + var valueString = Encoding.UTF8.GetString(value); + if (IsContentHeader(key)) + { + response.Content.Headers.Add(key, valueString); + } + else + { + response.Headers.Add(key, valueString); + } + } + } + + private static bool IsContentHeader(string headerName) + { + return HeaderDescriptor.TryGet(headerName, out HeaderDescriptor descriptor) && (descriptor.HeaderType & HttpHeaderType.Content) != 0; + } + + public static string ErrorCodeToString(ErrorCode code) + { + // TODO: include payload data in result where applicable + switch (code.Tag) + { + case ErrorCode.DNS_TIMEOUT: + return "DNS_TIMEOUT"; + + case ErrorCode.DNS_ERROR: + return "DNS_ERROR"; + + case ErrorCode.DESTINATION_NOT_FOUND: + return "DESTINATION_NOT_FOUND"; + + case ErrorCode.DESTINATION_UNAVAILABLE: + return "DESTINATION_UNAVAILABLE"; + + case ErrorCode.DESTINATION_IP_PROHIBITED: + return "DESTINATION_IP_PROHIBITED"; + + case ErrorCode.DESTINATION_IP_UNROUTABLE: + return "DESTINATION_IP_UNROUTABLE"; + + case ErrorCode.CONNECTION_REFUSED: + return "CONNECTION_REFUSED"; + + case ErrorCode.CONNECTION_TERMINATED: + return "CONNECTION_TERMINATED"; + + case ErrorCode.CONNECTION_TIMEOUT: + return "CONNECTION_TIMEOUT"; + + case ErrorCode.CONNECTION_READ_TIMEOUT: + return "CONNECTION_READ_TIMEOUT"; + + case ErrorCode.CONNECTION_WRITE_TIMEOUT: + return "CONNECTION_WRITE_TIMEOUT"; + + case ErrorCode.CONNECTION_LIMIT_REACHED: + return "CONNECTION_LIMIT_REACHED"; + + case ErrorCode.TLS_PROTOCOL_ERROR: + return "TLS_PROTOCOL_ERROR"; + + case ErrorCode.TLS_CERTIFICATE_ERROR: + return "TLS_CERTIFICATE_ERROR"; + + case ErrorCode.TLS_ALERT_RECEIVED: + return "TLS_ALERT_RECEIVED"; + + case ErrorCode.HTTP_REQUEST_DENIED: + return "HTTP_REQUEST_DENIED"; + + case ErrorCode.HTTP_REQUEST_LENGTH_REQUIRED: + return "HTTP_REQUEST_LENGTH_REQUIRED"; + + case ErrorCode.HTTP_REQUEST_BODY_SIZE: + return "HTTP_REQUEST_BODY_SIZE"; + + case ErrorCode.HTTP_REQUEST_METHOD_INVALID: + return "HTTP_REQUEST_METHOD_INVALID"; + + case ErrorCode.HTTP_REQUEST_URI_INVALID: + return "HTTP_REQUEST_URI_INVALID"; + + case ErrorCode.HTTP_REQUEST_URI_TOO_LONG: + return "HTTP_REQUEST_URI_TOO_LONG"; + + case ErrorCode.HTTP_REQUEST_HEADER_SECTION_SIZE: + return "HTTP_REQUEST_HEADER_SECTION_SIZE"; + + case ErrorCode.HTTP_REQUEST_HEADER_SIZE: + return "HTTP_REQUEST_HEADER_SIZE"; + + case ErrorCode.HTTP_REQUEST_TRAILER_SECTION_SIZE: + return "HTTP_REQUEST_TRAILER_SECTION_SIZE"; + + case ErrorCode.HTTP_REQUEST_TRAILER_SIZE: + return "HTTP_REQUEST_TRAILER_SIZE"; + + case ErrorCode.HTTP_RESPONSE_INCOMPLETE: + return "HTTP_RESPONSE_INCOMPLETE"; + + case ErrorCode.HTTP_RESPONSE_HEADER_SECTION_SIZE: + return "HTTP_RESPONSE_HEADER_SECTION_SIZE"; + + case ErrorCode.HTTP_RESPONSE_HEADER_SIZE: + return "HTTP_RESPONSE_HEADER_SIZE"; + + case ErrorCode.HTTP_RESPONSE_BODY_SIZE: + return "HTTP_RESPONSE_BODY_SIZE"; + + case ErrorCode.HTTP_RESPONSE_TRAILER_SECTION_SIZE: + return "HTTP_RESPONSE_TRAILER_SECTION_SIZE"; + + case ErrorCode.HTTP_RESPONSE_TRAILER_SIZE: + return "HTTP_RESPONSE_TRAILER_SIZE"; + + case ErrorCode.HTTP_RESPONSE_TRANSFER_CODING: + return "HTTP_RESPONSE_TRANSFER_CODING"; + + case ErrorCode.HTTP_RESPONSE_CONTENT_CODING: + return "HTTP_RESPONSE_CONTENT_CODING"; + + case ErrorCode.HTTP_RESPONSE_TIMEOUT: + return "HTTP_RESPONSE_TIMEOUT"; + + case ErrorCode.HTTP_UPGRADE_FAILED: + return "HTTP_UPGRADE_FAILED"; + + case ErrorCode.HTTP_PROTOCOL_ERROR: + return "HTTP_PROTOCOL_ERROR"; + + case ErrorCode.LOOP_DETECTED: + return "LOOP_DETECTED"; + + case ErrorCode.CONFIGURATION_ERROR: + return "CONFIGURATION_ERROR"; + + case ErrorCode.INTERNAL_ERROR: + return "INTERNAL_ERROR"; + + default: + return $"{code.Tag}"; + } + } + } +} diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.clocks.v0_2_1.MonotonicClockInterop.cs b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.clocks.v0_2_0.MonotonicClockInterop.cs similarity index 76% rename from src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.clocks.v0_2_1.MonotonicClockInterop.cs rename to src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.clocks.v0_2_0.MonotonicClockInterop.cs index 1de0ee2b247..6357b932c87 100644 --- a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.clocks.v0_2_1.MonotonicClockInterop.cs +++ b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.clocks.v0_2_0.MonotonicClockInterop.cs @@ -1,4 +1,4 @@ -// Generated by `wit-bindgen` 0.29.0. DO NOT EDIT! +// Generated by `wit-bindgen` 0.32.0. DO NOT EDIT! // #nullable enable @@ -11,13 +11,13 @@ using System.Diagnostics; using System.Diagnostics.CodeAnalysis; -namespace WasiHttpWorld.wit.imports.wasi.clocks.v0_2_1 +namespace WasiHttpWorld.wit.imports.wasi.clocks.v0_2_0 { internal static class MonotonicClockInterop { internal static class NowWasmInterop { - [DllImport("wasi:clocks/monotonic-clock@0.2.1", EntryPoint = "now"), WasmImportLinkage] + [DllImport("wasi:clocks/monotonic-clock@0.2.0", EntryPoint = "now"), WasmImportLinkage] internal static extern long wasmImportNow(); } @@ -32,7 +32,7 @@ internal static unsafe ulong Now() internal static class ResolutionWasmInterop { - [DllImport("wasi:clocks/monotonic-clock@0.2.1", EntryPoint = "resolution"), WasmImportLinkage] + [DllImport("wasi:clocks/monotonic-clock@0.2.0", EntryPoint = "resolution"), WasmImportLinkage] internal static extern long wasmImportResolution(); } @@ -47,15 +47,15 @@ internal static unsafe ulong Resolution() internal static class SubscribeInstantWasmInterop { - [DllImport("wasi:clocks/monotonic-clock@0.2.1", EntryPoint = "subscribe-instant"), WasmImportLinkage] + [DllImport("wasi:clocks/monotonic-clock@0.2.0", EntryPoint = "subscribe-instant"), WasmImportLinkage] internal static extern int wasmImportSubscribeInstant(long p0); } - internal static unsafe global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IPoll.Pollable SubscribeInstant(ulong when) + internal static unsafe global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable SubscribeInstant(ulong when) { var result = SubscribeInstantWasmInterop.wasmImportSubscribeInstant(unchecked((long)(when))); - var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IPoll.Pollable(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IPoll.Pollable.THandle(result)); + var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable.THandle(result)); return resource; //TODO: free alloc handle (interopString) if exists @@ -63,15 +63,15 @@ internal static class SubscribeInstantWasmInterop internal static class SubscribeDurationWasmInterop { - [DllImport("wasi:clocks/monotonic-clock@0.2.1", EntryPoint = "subscribe-duration"), WasmImportLinkage] + [DllImport("wasi:clocks/monotonic-clock@0.2.0", EntryPoint = "subscribe-duration"), WasmImportLinkage] internal static extern int wasmImportSubscribeDuration(long p0); } - internal static unsafe global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IPoll.Pollable SubscribeDuration(ulong when) + internal static unsafe global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable SubscribeDuration(ulong when) { var result = SubscribeDurationWasmInterop.wasmImportSubscribeDuration(unchecked((long)(when))); - var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IPoll.Pollable(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IPoll.Pollable.THandle(result)); + var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable.THandle(result)); return resource; //TODO: free alloc handle (interopString) if exists diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.cs b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.cs similarity index 90% rename from src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.cs rename to src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.cs index ed00640bb85..ffc6bab2b2f 100644 --- a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.cs +++ b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.cs @@ -1,4 +1,4 @@ -// Generated by `wit-bindgen` 0.29.0. DO NOT EDIT! +// Generated by `wit-bindgen` 0.32.0. DO NOT EDIT! // #nullable enable @@ -11,7 +11,7 @@ using System.Diagnostics; using System.Diagnostics.CodeAnalysis; -namespace WasiHttpWorld.wit.imports.wasi.http.v0_2_1; +namespace WasiHttpWorld.wit.imports.wasi.http.v0_2_0; internal interface ITypes { @@ -605,26 +605,21 @@ internal Fields(THandle handle) { public void Dispose() { Dispose(true); - GC.SuppressFinalize(this); } - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[resource-drop]fields"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[resource-drop]fields"), WasmImportLinkage] private static extern void wasmImportResourceDrop(int p0); protected virtual void Dispose(bool disposing) { - if (Handle != 0) { + if (disposing && Handle != 0) { wasmImportResourceDrop(Handle); Handle = 0; } } - ~Fields() { - Dispose(false); - } - internal static class ConstructorWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[constructor]fields"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[constructor]fields"), WasmImportLinkage] internal static extern int wasmImportConstructor(); } @@ -639,12 +634,12 @@ internal unsafe Fields() internal static class FromListWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[static]fields.from-list"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[static]fields.from-list"), WasmImportLinkage] internal static extern void wasmImportFromList(nint p0, int p1, nint p2); } - internal static unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields FromList(List<(string, byte[])> entries) + internal static unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields FromList(List<(string, byte[])> entries) { byte[] buffer0 = new byte[16 * entries.Count]; @@ -673,40 +668,40 @@ internal static class FromListWasmInterop var ptr = (nint)retAreaByte0; FromListWasmInterop.wasmImportFromList((int)address, entries.Count, ptr); - Result lifted11; + Result lifted11; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 4), 4)))); + var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 4), 4)))); - lifted11 = Result.ok(resource); + lifted11 = Result.ok(resource); break; } case 1: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.HeaderError lifted; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.HeaderError lifted; switch (new Span((void*)(ptr + 4), 1)[0]) { case 0: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.HeaderError.invalidSyntax(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.HeaderError.invalidSyntax(); break; } case 1: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.HeaderError.forbidden(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.HeaderError.forbidden(); break; } case 2: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.HeaderError.immutable(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.HeaderError.immutable(); break; } default: throw new ArgumentException($"invalid discriminant: {new Span((void*)(ptr + 4), 1)[0]}"); } - lifted11 = Result.err(lifted); + lifted11 = Result.err(lifted); break; } @@ -726,7 +721,7 @@ internal static class FromListWasmInterop internal static class GetWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]fields.get"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]fields.get"), WasmImportLinkage] internal static extern void wasmImportGet(int p0, nint p1, int p2, nint p3); } @@ -761,7 +756,7 @@ internal unsafe List Get(string name) internal static class HasWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]fields.has"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]fields.has"), WasmImportLinkage] internal static extern int wasmImportHas(int p0, nint p1, int p2); } @@ -780,7 +775,7 @@ internal unsafe bool Has(string name) internal static class SetWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]fields.set"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]fields.set"), WasmImportLinkage] internal static extern void wasmImportSet(int p0, nint p1, int p2, nint p3, int p4, nint p5); } @@ -813,39 +808,39 @@ internal unsafe void Set(string name, List value) var ptr = (nint)retAreaByte0; SetWasmInterop.wasmImportSet(handle, interopString.ToInt32(), lengthresult, (int)address, value.Count, ptr); - Result lifted11; + Result lifted11; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - lifted11 = Result.ok(new global::WasiHttpWorld.None()); + lifted11 = Result.ok(new global::WasiHttpWorld.None()); break; } case 1: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.HeaderError lifted; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.HeaderError lifted; switch (new Span((void*)(ptr + 1), 1)[0]) { case 0: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.HeaderError.invalidSyntax(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.HeaderError.invalidSyntax(); break; } case 1: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.HeaderError.forbidden(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.HeaderError.forbidden(); break; } case 2: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.HeaderError.immutable(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.HeaderError.immutable(); break; } default: throw new ArgumentException($"invalid discriminant: {new Span((void*)(ptr + 1), 1)[0]}"); } - lifted11 = Result.err(lifted); + lifted11 = Result.err(lifted); break; } @@ -865,7 +860,7 @@ internal unsafe void Set(string name, List value) internal static class DeleteWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]fields.delete"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]fields.delete"), WasmImportLinkage] internal static extern void wasmImportDelete(int p0, nint p1, int p2, nint p3); } @@ -883,39 +878,39 @@ internal unsafe void Delete(string name) var ptr = (nint)retAreaByte0; DeleteWasmInterop.wasmImportDelete(handle, interopString.ToInt32(), lengthresult, ptr); - Result lifted8; + Result lifted8; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - lifted8 = Result.ok(new global::WasiHttpWorld.None()); + lifted8 = Result.ok(new global::WasiHttpWorld.None()); break; } case 1: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.HeaderError lifted; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.HeaderError lifted; switch (new Span((void*)(ptr + 1), 1)[0]) { case 0: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.HeaderError.invalidSyntax(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.HeaderError.invalidSyntax(); break; } case 1: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.HeaderError.forbidden(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.HeaderError.forbidden(); break; } case 2: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.HeaderError.immutable(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.HeaderError.immutable(); break; } default: throw new ArgumentException($"invalid discriminant: {new Span((void*)(ptr + 1), 1)[0]}"); } - lifted8 = Result.err(lifted); + lifted8 = Result.err(lifted); break; } @@ -934,7 +929,7 @@ internal unsafe void Delete(string name) internal static class AppendWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]fields.append"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]fields.append"), WasmImportLinkage] internal static extern void wasmImportAppend(int p0, nint p1, int p2, nint p3, int p4, nint p5); } @@ -955,39 +950,39 @@ internal unsafe void Append(string name, byte[] value) var ptr = (nint)retAreaByte0; AppendWasmInterop.wasmImportAppend(handle, interopString.ToInt32(), lengthresult, (int)buffer, (value).Length, ptr); - Result lifted8; + Result lifted8; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - lifted8 = Result.ok(new global::WasiHttpWorld.None()); + lifted8 = Result.ok(new global::WasiHttpWorld.None()); break; } case 1: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.HeaderError lifted; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.HeaderError lifted; switch (new Span((void*)(ptr + 1), 1)[0]) { case 0: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.HeaderError.invalidSyntax(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.HeaderError.invalidSyntax(); break; } case 1: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.HeaderError.forbidden(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.HeaderError.forbidden(); break; } case 2: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.HeaderError.immutable(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.HeaderError.immutable(); break; } default: throw new ArgumentException($"invalid discriminant: {new Span((void*)(ptr + 1), 1)[0]}"); } - lifted8 = Result.err(lifted); + lifted8 = Result.err(lifted); break; } @@ -1006,7 +1001,7 @@ internal unsafe void Append(string name, byte[] value) internal static class EntriesWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]fields.entries"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]fields.entries"), WasmImportLinkage] internal static extern void wasmImportEntries(int p0, nint p1); } @@ -1039,16 +1034,16 @@ internal static class EntriesWasmInterop internal static class CloneWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]fields.clone"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]fields.clone"), WasmImportLinkage] internal static extern int wasmImportClone(int p0); } - internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields Clone() + internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields Clone() { var handle = this.Handle; var result = CloneWasmInterop.wasmImportClone(handle); - var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields.THandle(result)); + var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields.THandle(result)); return resource; //TODO: free alloc handle (interopString) if exists @@ -1071,31 +1066,26 @@ internal IncomingRequest(THandle handle) { public void Dispose() { Dispose(true); - GC.SuppressFinalize(this); } - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[resource-drop]incoming-request"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[resource-drop]incoming-request"), WasmImportLinkage] private static extern void wasmImportResourceDrop(int p0); protected virtual void Dispose(bool disposing) { - if (Handle != 0) { + if (disposing && Handle != 0) { wasmImportResourceDrop(Handle); Handle = 0; } } - ~IncomingRequest() { - Dispose(false); - } - internal static class MethodWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]incoming-request.method"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]incoming-request.method"), WasmImportLinkage] internal static extern void wasmImportMethod(int p0, nint p1); } - internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method Method() + internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method Method() { var handle = this.Handle; @@ -1105,57 +1095,57 @@ internal static class MethodWasmInterop var ptr = (nint)retAreaByte0; MethodWasmInterop.wasmImportMethod(handle, ptr); - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method lifted; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method lifted; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method.get(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method.get(); break; } case 1: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method.head(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method.head(); break; } case 2: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method.post(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method.post(); break; } case 3: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method.put(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method.put(); break; } case 4: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method.delete(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method.delete(); break; } case 5: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method.connect(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method.connect(); break; } case 6: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method.options(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method.options(); break; } case 7: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method.trace(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method.trace(); break; } case 8: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method.patch(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method.patch(); break; } case 9: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method.other(Encoding.UTF8.GetString((byte*)BitConverter.ToInt32(new Span((void*)(ptr + 4), 4)), BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)))); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method.other(Encoding.UTF8.GetString((byte*)BitConverter.ToInt32(new Span((void*)(ptr + 4), 4)), BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)))); break; } @@ -1169,7 +1159,7 @@ internal static class MethodWasmInterop internal static class PathWithQueryWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]incoming-request.path-with-query"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]incoming-request.path-with-query"), WasmImportLinkage] internal static extern void wasmImportPathWithQuery(int p0, nint p1); } @@ -1208,12 +1198,12 @@ internal static class PathWithQueryWasmInterop internal static class SchemeWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]incoming-request.scheme"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]incoming-request.scheme"), WasmImportLinkage] internal static extern void wasmImportScheme(int p0, nint p1); } - internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Scheme? Scheme() + internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Scheme? Scheme() { var handle = this.Handle; @@ -1223,7 +1213,7 @@ internal static class SchemeWasmInterop var ptr = (nint)retAreaByte0; SchemeWasmInterop.wasmImportScheme(handle, ptr); - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Scheme? lifted8; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Scheme? lifted8; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { @@ -1233,22 +1223,22 @@ internal static class SchemeWasmInterop case 1: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Scheme lifted; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Scheme lifted; switch (new Span((void*)(ptr + 4), 1)[0]) { case 0: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Scheme.http(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Scheme.http(); break; } case 1: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Scheme.https(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Scheme.https(); break; } case 2: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Scheme.other(Encoding.UTF8.GetString((byte*)BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)), BitConverter.ToInt32(new Span((void*)(ptr + 12), 4)))); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Scheme.other(Encoding.UTF8.GetString((byte*)BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)), BitConverter.ToInt32(new Span((void*)(ptr + 12), 4)))); break; } @@ -1269,7 +1259,7 @@ internal static class SchemeWasmInterop internal static class AuthorityWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]incoming-request.authority"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]incoming-request.authority"), WasmImportLinkage] internal static extern void wasmImportAuthority(int p0, nint p1); } @@ -1308,16 +1298,16 @@ internal static class AuthorityWasmInterop internal static class HeadersWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]incoming-request.headers"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]incoming-request.headers"), WasmImportLinkage] internal static extern int wasmImportHeaders(int p0); } - internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields Headers() + internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields Headers() { var handle = this.Handle; var result = HeadersWasmInterop.wasmImportHeaders(handle); - var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields.THandle(result)); + var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields.THandle(result)); return resource; //TODO: free alloc handle (interopString) if exists @@ -1325,12 +1315,12 @@ internal static class HeadersWasmInterop internal static class ConsumeWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]incoming-request.consume"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]incoming-request.consume"), WasmImportLinkage] internal static extern void wasmImportConsume(int p0, nint p1); } - internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.IncomingBody Consume() + internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.IncomingBody Consume() { var handle = this.Handle; @@ -1340,18 +1330,18 @@ internal static class ConsumeWasmInterop var ptr = (nint)retAreaByte0; ConsumeWasmInterop.wasmImportConsume(handle, ptr); - Result lifted; + Result lifted; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.IncomingBody(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.IncomingBody.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 4), 4)))); + var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.IncomingBody(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.IncomingBody.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 4), 4)))); - lifted = Result.ok(resource); + lifted = Result.ok(resource); break; } case 1: { - lifted = Result.err(new global::WasiHttpWorld.None()); + lifted = Result.err(new global::WasiHttpWorld.None()); break; } @@ -1385,31 +1375,26 @@ internal OutgoingRequest(THandle handle) { public void Dispose() { Dispose(true); - GC.SuppressFinalize(this); } - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[resource-drop]outgoing-request"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[resource-drop]outgoing-request"), WasmImportLinkage] private static extern void wasmImportResourceDrop(int p0); protected virtual void Dispose(bool disposing) { - if (Handle != 0) { + if (disposing && Handle != 0) { wasmImportResourceDrop(Handle); Handle = 0; } } - ~OutgoingRequest() { - Dispose(false); - } - internal static class ConstructorWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[constructor]outgoing-request"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[constructor]outgoing-request"), WasmImportLinkage] internal static extern int wasmImportConstructor(int p0); } - internal unsafe OutgoingRequest(global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields headers) + internal unsafe OutgoingRequest(global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields headers) { var handle = headers.Handle; headers.Handle = 0; @@ -1421,12 +1406,12 @@ internal unsafe OutgoingRequest(global::WasiHttpWorld.wit.imports.wasi.http.v internal static class BodyWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]outgoing-request.body"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]outgoing-request.body"), WasmImportLinkage] internal static extern void wasmImportBody(int p0, nint p1); } - internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.OutgoingBody Body() + internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.OutgoingBody Body() { var handle = this.Handle; @@ -1436,18 +1421,18 @@ internal static class BodyWasmInterop var ptr = (nint)retAreaByte0; BodyWasmInterop.wasmImportBody(handle, ptr); - Result lifted; + Result lifted; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.OutgoingBody(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.OutgoingBody.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 4), 4)))); + var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.OutgoingBody(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.OutgoingBody.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 4), 4)))); - lifted = Result.ok(resource); + lifted = Result.ok(resource); break; } case 1: { - lifted = Result.err(new global::WasiHttpWorld.None()); + lifted = Result.err(new global::WasiHttpWorld.None()); break; } @@ -1466,12 +1451,12 @@ internal static class BodyWasmInterop internal static class MethodWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]outgoing-request.method"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]outgoing-request.method"), WasmImportLinkage] internal static extern void wasmImportMethod(int p0, nint p1); } - internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method Method() + internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method Method() { var handle = this.Handle; @@ -1481,57 +1466,57 @@ internal static class MethodWasmInterop var ptr = (nint)retAreaByte0; MethodWasmInterop.wasmImportMethod(handle, ptr); - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method lifted; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method lifted; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method.get(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method.get(); break; } case 1: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method.head(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method.head(); break; } case 2: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method.post(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method.post(); break; } case 3: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method.put(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method.put(); break; } case 4: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method.delete(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method.delete(); break; } case 5: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method.connect(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method.connect(); break; } case 6: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method.options(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method.options(); break; } case 7: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method.trace(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method.trace(); break; } case 8: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method.patch(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method.patch(); break; } case 9: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method.other(Encoding.UTF8.GetString((byte*)BitConverter.ToInt32(new Span((void*)(ptr + 4), 4)), BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)))); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method.other(Encoding.UTF8.GetString((byte*)BitConverter.ToInt32(new Span((void*)(ptr + 4), 4)), BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)))); break; } @@ -1545,12 +1530,12 @@ internal static class MethodWasmInterop internal static class SetMethodWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]outgoing-request.set-method"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]outgoing-request.set-method"), WasmImportLinkage] internal static extern int wasmImportSetMethod(int p0, int p1, nint p2, int p3); } - internal unsafe void SetMethod(global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Method method) + internal unsafe void SetMethod(global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Method method) { var handle = this.Handle; @@ -1676,7 +1661,7 @@ internal unsafe void SetMethod(global::WasiHttpWorld.wit.imports.wasi.http.v0_ internal static class PathWithQueryWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]outgoing-request.path-with-query"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]outgoing-request.path-with-query"), WasmImportLinkage] internal static extern void wasmImportPathWithQuery(int p0, nint p1); } @@ -1715,7 +1700,7 @@ internal static class PathWithQueryWasmInterop internal static class SetPathWithQueryWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]outgoing-request.set-path-with-query"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]outgoing-request.set-path-with-query"), WasmImportLinkage] internal static extern int wasmImportSetPathWithQuery(int p0, int p1, nint p2, int p3); } @@ -1775,12 +1760,12 @@ internal unsafe void SetPathWithQuery(string? pathWithQuery) internal static class SchemeWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]outgoing-request.scheme"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]outgoing-request.scheme"), WasmImportLinkage] internal static extern void wasmImportScheme(int p0, nint p1); } - internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Scheme? Scheme() + internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Scheme? Scheme() { var handle = this.Handle; @@ -1790,7 +1775,7 @@ internal static class SchemeWasmInterop var ptr = (nint)retAreaByte0; SchemeWasmInterop.wasmImportScheme(handle, ptr); - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Scheme? lifted8; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Scheme? lifted8; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { @@ -1800,22 +1785,22 @@ internal static class SchemeWasmInterop case 1: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Scheme lifted; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Scheme lifted; switch (new Span((void*)(ptr + 4), 1)[0]) { case 0: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Scheme.http(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Scheme.http(); break; } case 1: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Scheme.https(); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Scheme.https(); break; } case 2: { - lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Scheme.other(Encoding.UTF8.GetString((byte*)BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)), BitConverter.ToInt32(new Span((void*)(ptr + 12), 4)))); + lifted = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Scheme.other(Encoding.UTF8.GetString((byte*)BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)), BitConverter.ToInt32(new Span((void*)(ptr + 12), 4)))); break; } @@ -1836,12 +1821,12 @@ internal static class SchemeWasmInterop internal static class SetSchemeWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]outgoing-request.set-scheme"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]outgoing-request.set-scheme"), WasmImportLinkage] internal static extern int wasmImportSetScheme(int p0, int p1, int p2, nint p3, int p4); } - internal unsafe void SetScheme(global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Scheme? scheme) + internal unsafe void SetScheme(global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Scheme? scheme) { var handle = this.Handle; @@ -1851,7 +1836,7 @@ internal unsafe void SetScheme(global::WasiHttpWorld.wit.imports.wasi.http.v0_ int lowered17; if (scheme != null) { - var payload2 = (global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Scheme) scheme; + var payload2 = (global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Scheme) scheme; int lowered; nint lowered12; @@ -1933,7 +1918,7 @@ internal unsafe void SetScheme(global::WasiHttpWorld.wit.imports.wasi.http.v0_ internal static class AuthorityWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]outgoing-request.authority"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]outgoing-request.authority"), WasmImportLinkage] internal static extern void wasmImportAuthority(int p0, nint p1); } @@ -1972,7 +1957,7 @@ internal static class AuthorityWasmInterop internal static class SetAuthorityWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]outgoing-request.set-authority"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]outgoing-request.set-authority"), WasmImportLinkage] internal static extern int wasmImportSetAuthority(int p0, int p1, nint p2, int p3); } @@ -2032,16 +2017,16 @@ internal unsafe void SetAuthority(string? authority) internal static class HeadersWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]outgoing-request.headers"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]outgoing-request.headers"), WasmImportLinkage] internal static extern int wasmImportHeaders(int p0); } - internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields Headers() + internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields Headers() { var handle = this.Handle; var result = HeadersWasmInterop.wasmImportHeaders(handle); - var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields.THandle(result)); + var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields.THandle(result)); return resource; //TODO: free alloc handle (interopString) if exists @@ -2069,26 +2054,21 @@ internal RequestOptions(THandle handle) { public void Dispose() { Dispose(true); - GC.SuppressFinalize(this); } - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[resource-drop]request-options"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[resource-drop]request-options"), WasmImportLinkage] private static extern void wasmImportResourceDrop(int p0); protected virtual void Dispose(bool disposing) { - if (Handle != 0) { + if (disposing && Handle != 0) { wasmImportResourceDrop(Handle); Handle = 0; } } - ~RequestOptions() { - Dispose(false); - } - internal static class ConstructorWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[constructor]request-options"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[constructor]request-options"), WasmImportLinkage] internal static extern int wasmImportConstructor(); } @@ -2103,7 +2083,7 @@ internal unsafe RequestOptions() internal static class ConnectTimeoutWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]request-options.connect-timeout"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]request-options.connect-timeout"), WasmImportLinkage] internal static extern void wasmImportConnectTimeout(int p0, nint p1); } @@ -2142,7 +2122,7 @@ internal static class ConnectTimeoutWasmInterop internal static class SetConnectTimeoutWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]request-options.set-connect-timeout"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]request-options.set-connect-timeout"), WasmImportLinkage] internal static extern int wasmImportSetConnectTimeout(int p0, int p1, long p2); } @@ -2196,7 +2176,7 @@ internal unsafe void SetConnectTimeout(ulong? duration) internal static class FirstByteTimeoutWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]request-options.first-byte-timeout"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]request-options.first-byte-timeout"), WasmImportLinkage] internal static extern void wasmImportFirstByteTimeout(int p0, nint p1); } @@ -2235,7 +2215,7 @@ internal static class FirstByteTimeoutWasmInterop internal static class SetFirstByteTimeoutWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]request-options.set-first-byte-timeout"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]request-options.set-first-byte-timeout"), WasmImportLinkage] internal static extern int wasmImportSetFirstByteTimeout(int p0, int p1, long p2); } @@ -2289,7 +2269,7 @@ internal unsafe void SetFirstByteTimeout(ulong? duration) internal static class BetweenBytesTimeoutWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]request-options.between-bytes-timeout"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]request-options.between-bytes-timeout"), WasmImportLinkage] internal static extern void wasmImportBetweenBytesTimeout(int p0, nint p1); } @@ -2328,7 +2308,7 @@ internal static class BetweenBytesTimeoutWasmInterop internal static class SetBetweenBytesTimeoutWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]request-options.set-between-bytes-timeout"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]request-options.set-between-bytes-timeout"), WasmImportLinkage] internal static extern int wasmImportSetBetweenBytesTimeout(int p0, int p1, long p2); } @@ -2401,31 +2381,26 @@ internal ResponseOutparam(THandle handle) { public void Dispose() { Dispose(true); - GC.SuppressFinalize(this); } - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[resource-drop]response-outparam"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[resource-drop]response-outparam"), WasmImportLinkage] private static extern void wasmImportResourceDrop(int p0); protected virtual void Dispose(bool disposing) { - if (Handle != 0) { + if (disposing && Handle != 0) { wasmImportResourceDrop(Handle); Handle = 0; } } - ~ResponseOutparam() { - Dispose(false); - } - internal static class SetWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[static]response-outparam.set"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[static]response-outparam.set"), WasmImportLinkage] internal static extern void wasmImportSet(int p0, int p1, int p2, int p3, long p4, nint p5, nint p6, int p7, int p8); } - internal static unsafe void Set(global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ResponseOutparam param, Result response) + internal static unsafe void Set(global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ResponseOutparam param, Result response) { var handle = param.Handle; param.Handle = 0; @@ -2441,7 +2416,7 @@ internal static unsafe void Set(global::WasiHttpWorld.wit.imports.wasi.http.v0_ switch (response.Tag) { case 0: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.OutgoingResponse payload = response.AsOk; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.OutgoingResponse payload = response.AsOk; var handle0 = payload.Handle; payload.Handle = 0; @@ -2457,7 +2432,7 @@ internal static unsafe void Set(global::WasiHttpWorld.wit.imports.wasi.http.v0_ break; } case 1: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode payload3 = response.AsErr; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode payload3 = response.AsErr; int lowered325; int lowered326; @@ -2481,7 +2456,7 @@ internal static unsafe void Set(global::WasiHttpWorld.wit.imports.wasi.http.v0_ break; } case 1: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.DnsErrorPayload payload9 = payload3.AsDnsError; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.DnsErrorPayload payload9 = payload3.AsDnsError; int lowered; nint lowered16; @@ -2676,7 +2651,7 @@ internal static unsafe void Set(global::WasiHttpWorld.wit.imports.wasi.http.v0_ break; } case 14: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.TlsAlertReceivedPayload payload64 = payload3.AsTlsAlertReceived; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.TlsAlertReceivedPayload payload64 = payload3.AsTlsAlertReceived; int lowered71; int lowered72; @@ -2845,7 +2820,7 @@ internal static unsafe void Set(global::WasiHttpWorld.wit.imports.wasi.http.v0_ break; } case 22: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload? payload123 = payload3.AsHttpRequestHeaderSize; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload? payload123 = payload3.AsHttpRequestHeaderSize; int lowered149; int lowered150; @@ -2855,7 +2830,7 @@ internal static unsafe void Set(global::WasiHttpWorld.wit.imports.wasi.http.v0_ int lowered154; if (payload123 != null) { - var payload129 = (global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload) payload123; + var payload129 = (global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload) payload123; int lowered138; nint lowered139; @@ -2953,7 +2928,7 @@ internal static unsafe void Set(global::WasiHttpWorld.wit.imports.wasi.http.v0_ break; } case 24: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload payload168 = payload3.AsHttpRequestTrailerSize; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload payload168 = payload3.AsHttpRequestTrailerSize; int lowered177; nint lowered178; @@ -3045,7 +3020,7 @@ internal static unsafe void Set(global::WasiHttpWorld.wit.imports.wasi.http.v0_ break; } case 27: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload payload204 = payload3.AsHttpResponseHeaderSize; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload payload204 = payload3.AsHttpResponseHeaderSize; int lowered213; nint lowered214; @@ -3154,7 +3129,7 @@ internal static unsafe void Set(global::WasiHttpWorld.wit.imports.wasi.http.v0_ break; } case 30: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload payload248 = payload3.AsHttpResponseTrailerSize; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload payload248 = payload3.AsHttpResponseTrailerSize; int lowered257; nint lowered258; @@ -3409,26 +3384,21 @@ internal IncomingResponse(THandle handle) { public void Dispose() { Dispose(true); - GC.SuppressFinalize(this); } - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[resource-drop]incoming-response"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[resource-drop]incoming-response"), WasmImportLinkage] private static extern void wasmImportResourceDrop(int p0); protected virtual void Dispose(bool disposing) { - if (Handle != 0) { + if (disposing && Handle != 0) { wasmImportResourceDrop(Handle); Handle = 0; } } - ~IncomingResponse() { - Dispose(false); - } - internal static class StatusWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]incoming-response.status"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]incoming-response.status"), WasmImportLinkage] internal static extern int wasmImportStatus(int p0); } @@ -3444,16 +3414,16 @@ internal unsafe ushort Status() internal static class HeadersWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]incoming-response.headers"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]incoming-response.headers"), WasmImportLinkage] internal static extern int wasmImportHeaders(int p0); } - internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields Headers() + internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields Headers() { var handle = this.Handle; var result = HeadersWasmInterop.wasmImportHeaders(handle); - var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields.THandle(result)); + var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields.THandle(result)); return resource; //TODO: free alloc handle (interopString) if exists @@ -3461,12 +3431,12 @@ internal static class HeadersWasmInterop internal static class ConsumeWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]incoming-response.consume"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]incoming-response.consume"), WasmImportLinkage] internal static extern void wasmImportConsume(int p0, nint p1); } - internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.IncomingBody Consume() + internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.IncomingBody Consume() { var handle = this.Handle; @@ -3476,18 +3446,18 @@ internal static class ConsumeWasmInterop var ptr = (nint)retAreaByte0; ConsumeWasmInterop.wasmImportConsume(handle, ptr); - Result lifted; + Result lifted; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.IncomingBody(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.IncomingBody.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 4), 4)))); + var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.IncomingBody(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.IncomingBody.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 4), 4)))); - lifted = Result.ok(resource); + lifted = Result.ok(resource); break; } case 1: { - lifted = Result.err(new global::WasiHttpWorld.None()); + lifted = Result.err(new global::WasiHttpWorld.None()); break; } @@ -3528,31 +3498,26 @@ internal IncomingBody(THandle handle) { public void Dispose() { Dispose(true); - GC.SuppressFinalize(this); } - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[resource-drop]incoming-body"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[resource-drop]incoming-body"), WasmImportLinkage] private static extern void wasmImportResourceDrop(int p0); protected virtual void Dispose(bool disposing) { - if (Handle != 0) { + if (disposing && Handle != 0) { wasmImportResourceDrop(Handle); Handle = 0; } } - ~IncomingBody() { - Dispose(false); - } - internal static class StreamWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]incoming-body.stream"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]incoming-body.stream"), WasmImportLinkage] internal static extern void wasmImportStream(int p0, nint p1); } - internal unsafe global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.InputStream Stream() + internal unsafe global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.InputStream Stream() { var handle = this.Handle; @@ -3562,18 +3527,18 @@ internal static class StreamWasmInterop var ptr = (nint)retAreaByte0; StreamWasmInterop.wasmImportStream(handle, ptr); - Result lifted; + Result lifted; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.InputStream(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.InputStream.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 4), 4)))); + var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.InputStream(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.InputStream.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 4), 4)))); - lifted = Result.ok(resource); + lifted = Result.ok(resource); break; } case 1: { - lifted = Result.err(new global::WasiHttpWorld.None()); + lifted = Result.err(new global::WasiHttpWorld.None()); break; } @@ -3592,17 +3557,17 @@ internal static class StreamWasmInterop internal static class FinishWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[static]incoming-body.finish"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[static]incoming-body.finish"), WasmImportLinkage] internal static extern int wasmImportFinish(int p0); } - internal static unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FutureTrailers Finish(global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.IncomingBody @this) + internal static unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FutureTrailers Finish(global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.IncomingBody @this) { var handle = @this.Handle; @this.Handle = 0; var result = FinishWasmInterop.wasmImportFinish(handle); - var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FutureTrailers(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FutureTrailers.THandle(result)); + var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FutureTrailers(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FutureTrailers.THandle(result)); return resource; //TODO: free alloc handle (interopString) if exists @@ -3611,7 +3576,7 @@ internal static class FinishWasmInterop } /** - * Represents a future which may eventually return trailers, or an error. + * Represents a future which may eventaully return trailers, or an error. * * In the case that the incoming HTTP Request or Response did not have any * trailers, this future will resolve to the empty set of trailers once the @@ -3629,35 +3594,30 @@ internal FutureTrailers(THandle handle) { public void Dispose() { Dispose(true); - GC.SuppressFinalize(this); } - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[resource-drop]future-trailers"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[resource-drop]future-trailers"), WasmImportLinkage] private static extern void wasmImportResourceDrop(int p0); protected virtual void Dispose(bool disposing) { - if (Handle != 0) { + if (disposing && Handle != 0) { wasmImportResourceDrop(Handle); Handle = 0; } } - ~FutureTrailers() { - Dispose(false); - } - internal static class SubscribeWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]future-trailers.subscribe"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]future-trailers.subscribe"), WasmImportLinkage] internal static extern int wasmImportSubscribe(int p0); } - internal unsafe global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IPoll.Pollable Subscribe() + internal unsafe global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable Subscribe() { var handle = this.Handle; var result = SubscribeWasmInterop.wasmImportSubscribe(handle); - var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IPoll.Pollable(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IPoll.Pollable.THandle(result)); + var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable.THandle(result)); return resource; //TODO: free alloc handle (interopString) if exists @@ -3665,12 +3625,12 @@ internal static class SubscribeWasmInterop internal static class GetWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]future-trailers.get"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]future-trailers.get"), WasmImportLinkage] internal static extern void wasmImportGet(int p0, nint p1); } - internal unsafe Result, None>? Get() + internal unsafe Result, None>? Get() { var handle = this.Handle; @@ -3680,7 +3640,7 @@ internal static class GetWasmInterop var ptr = (nint)retAreaByte0; GetWasmInterop.wasmImportGet(handle, ptr); - Result, None>? lifted205; + Result, None>? lifted205; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { @@ -3690,17 +3650,17 @@ internal static class GetWasmInterop case 1: { - Result, None> lifted204; + Result, None> lifted204; switch (new Span((void*)(ptr + 8), 1)[0]) { case 0: { - Result lifted201; + Result lifted201; switch (new Span((void*)(ptr + 16), 1)[0]) { case 0: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields? lifted; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields? lifted; switch (new Span((void*)(ptr + 24), 1)[0]) { case 0: { @@ -3709,7 +3669,7 @@ internal static class GetWasmInterop } case 1: { - var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 28), 4)))); + var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 28), 4)))); lifted = resource; break; @@ -3718,17 +3678,17 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 24), 1)[0])); } - lifted201 = Result.ok(lifted); + lifted201 = Result.ok(lifted); break; } case 1: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode lifted200; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode lifted200; switch (new Span((void*)(ptr + 24), 1)[0]) { case 0: { - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.dnsTimeout(); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.dnsTimeout(); break; } case 1: { @@ -3767,68 +3727,68 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 44), 1)[0])); } - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.dnsError(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.DnsErrorPayload ( + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.dnsError(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.DnsErrorPayload ( lifted20, lifted25)); break; } case 2: { - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.destinationNotFound(); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.destinationNotFound(); break; } case 3: { - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.destinationUnavailable(); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.destinationUnavailable(); break; } case 4: { - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.destinationIpProhibited(); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.destinationIpProhibited(); break; } case 5: { - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.destinationIpUnroutable(); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.destinationIpUnroutable(); break; } case 6: { - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionRefused(); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionRefused(); break; } case 7: { - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionTerminated(); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionTerminated(); break; } case 8: { - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionTimeout(); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionTimeout(); break; } case 9: { - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionReadTimeout(); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionReadTimeout(); break; } case 10: { - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionWriteTimeout(); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionWriteTimeout(); break; } case 11: { - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionLimitReached(); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionLimitReached(); break; } case 12: { - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.tlsProtocolError(); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.tlsProtocolError(); break; } case 13: { - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.tlsCertificateError(); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.tlsCertificateError(); break; } case 14: { @@ -3867,18 +3827,18 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 36), 1)[0])); } - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.tlsAlertReceived(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.TlsAlertReceivedPayload ( + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.tlsAlertReceived(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.TlsAlertReceivedPayload ( lifted56, lifted61)); break; } case 15: { - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestDenied(); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestDenied(); break; } case 16: { - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestLengthRequired(); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestLengthRequired(); break; } case 17: { @@ -3900,22 +3860,22 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 32), 1)[0])); } - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestBodySize(lifted72); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestBodySize(lifted72); break; } case 18: { - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestMethodInvalid(); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestMethodInvalid(); break; } case 19: { - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestUriInvalid(); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestUriInvalid(); break; } case 20: { - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestUriTooLong(); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestUriTooLong(); break; } case 21: { @@ -3937,12 +3897,12 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 32), 1)[0])); } - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestHeaderSectionSize(lifted85); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestHeaderSectionSize(lifted85); break; } case 22: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload? lifted102; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload? lifted102; switch (new Span((void*)(ptr + 32), 1)[0]) { case 0: { @@ -3986,7 +3946,7 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 48), 1)[0])); } - lifted102 = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload ( + lifted102 = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload ( lifted96, lifted101); break; } @@ -3994,7 +3954,7 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 32), 1)[0])); } - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestHeaderSize(lifted102); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestHeaderSize(lifted102); break; } case 23: { @@ -4016,7 +3976,7 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 32), 1)[0])); } - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestTrailerSectionSize(lifted109); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestTrailerSectionSize(lifted109); break; } case 24: { @@ -4055,13 +4015,13 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 44), 1)[0])); } - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestTrailerSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload ( + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestTrailerSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload ( lifted116, lifted121)); break; } case 25: { - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseIncomplete(); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseIncomplete(); break; } case 26: { @@ -4083,7 +4043,7 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 32), 1)[0])); } - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseHeaderSectionSize(lifted130); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseHeaderSectionSize(lifted130); break; } case 27: { @@ -4122,7 +4082,7 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 44), 1)[0])); } - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseHeaderSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload ( + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseHeaderSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload ( lifted137, lifted142)); break; } @@ -4145,7 +4105,7 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 32), 1)[0])); } - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseBodySize(lifted149); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseBodySize(lifted149); break; } case 29: { @@ -4167,7 +4127,7 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 32), 1)[0])); } - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseTrailerSectionSize(lifted156); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseTrailerSectionSize(lifted156); break; } case 30: { @@ -4206,7 +4166,7 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 44), 1)[0])); } - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseTrailerSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload ( + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseTrailerSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload ( lifted163, lifted168)); break; } @@ -4229,7 +4189,7 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 32), 1)[0])); } - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseTransferCoding(lifted175); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseTransferCoding(lifted175); break; } case 32: { @@ -4251,32 +4211,32 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 32), 1)[0])); } - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseContentCoding(lifted182); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseContentCoding(lifted182); break; } case 33: { - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseTimeout(); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseTimeout(); break; } case 34: { - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpUpgradeFailed(); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpUpgradeFailed(); break; } case 35: { - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpProtocolError(); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpProtocolError(); break; } case 36: { - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.loopDetected(); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.loopDetected(); break; } case 37: { - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.configurationError(); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.configurationError(); break; } case 38: { @@ -4298,26 +4258,26 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 32), 1)[0])); } - lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.internalError(lifted199); + lifted200 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.internalError(lifted199); break; } default: throw new ArgumentException($"invalid discriminant: {new Span((void*)(ptr + 24), 1)[0]}"); } - lifted201 = Result.err(lifted200); + lifted201 = Result.err(lifted200); break; } default: throw new ArgumentException($"invalid discriminant: {new Span((void*)(ptr + 16), 1)[0]}"); } - lifted204 = Result, None>.ok(lifted201); + lifted204 = Result, None>.ok(lifted201); break; } case 1: { - lifted204 = Result, None>.err(new global::WasiHttpWorld.None()); + lifted204 = Result, None>.err(new global::WasiHttpWorld.None()); break; } @@ -4353,31 +4313,26 @@ internal OutgoingResponse(THandle handle) { public void Dispose() { Dispose(true); - GC.SuppressFinalize(this); } - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[resource-drop]outgoing-response"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[resource-drop]outgoing-response"), WasmImportLinkage] private static extern void wasmImportResourceDrop(int p0); protected virtual void Dispose(bool disposing) { - if (Handle != 0) { + if (disposing && Handle != 0) { wasmImportResourceDrop(Handle); Handle = 0; } } - ~OutgoingResponse() { - Dispose(false); - } - internal static class ConstructorWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[constructor]outgoing-response"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[constructor]outgoing-response"), WasmImportLinkage] internal static extern int wasmImportConstructor(int p0); } - internal unsafe OutgoingResponse(global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields headers) + internal unsafe OutgoingResponse(global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields headers) { var handle = headers.Handle; headers.Handle = 0; @@ -4389,7 +4344,7 @@ internal unsafe OutgoingResponse(global::WasiHttpWorld.wit.imports.wasi.http. internal static class StatusCodeWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]outgoing-response.status-code"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]outgoing-response.status-code"), WasmImportLinkage] internal static extern int wasmImportStatusCode(int p0); } @@ -4405,7 +4360,7 @@ internal unsafe ushort StatusCode() internal static class SetStatusCodeWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]outgoing-response.set-status-code"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]outgoing-response.set-status-code"), WasmImportLinkage] internal static extern int wasmImportSetStatusCode(int p0, int p1); } @@ -4443,16 +4398,16 @@ internal unsafe void SetStatusCode(ushort statusCode) internal static class HeadersWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]outgoing-response.headers"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]outgoing-response.headers"), WasmImportLinkage] internal static extern int wasmImportHeaders(int p0); } - internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields Headers() + internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields Headers() { var handle = this.Handle; var result = HeadersWasmInterop.wasmImportHeaders(handle); - var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields.THandle(result)); + var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields.THandle(result)); return resource; //TODO: free alloc handle (interopString) if exists @@ -4460,12 +4415,12 @@ internal static class HeadersWasmInterop internal static class BodyWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]outgoing-response.body"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]outgoing-response.body"), WasmImportLinkage] internal static extern void wasmImportBody(int p0, nint p1); } - internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.OutgoingBody Body() + internal unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.OutgoingBody Body() { var handle = this.Handle; @@ -4475,18 +4430,18 @@ internal static class BodyWasmInterop var ptr = (nint)retAreaByte0; BodyWasmInterop.wasmImportBody(handle, ptr); - Result lifted; + Result lifted; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.OutgoingBody(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.OutgoingBody.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 4), 4)))); + var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.OutgoingBody(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.OutgoingBody.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 4), 4)))); - lifted = Result.ok(resource); + lifted = Result.ok(resource); break; } case 1: { - lifted = Result.err(new global::WasiHttpWorld.None()); + lifted = Result.err(new global::WasiHttpWorld.None()); break; } @@ -4518,7 +4473,7 @@ internal static class BodyWasmInterop * * If the user code drops this resource, as opposed to calling the static * method `finish`, the implementation should treat the body as incomplete, - * and that an error has occurred. The implementation should propagate this + * and that an error has occured. The implementation should propogate this * error to the HTTP protocol by whatever means it has available, * including: corrupting the body on the wire, aborting the associated * Request, or sending a late status code for the Response. @@ -4535,31 +4490,26 @@ internal OutgoingBody(THandle handle) { public void Dispose() { Dispose(true); - GC.SuppressFinalize(this); } - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[resource-drop]outgoing-body"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[resource-drop]outgoing-body"), WasmImportLinkage] private static extern void wasmImportResourceDrop(int p0); protected virtual void Dispose(bool disposing) { - if (Handle != 0) { + if (disposing && Handle != 0) { wasmImportResourceDrop(Handle); Handle = 0; } } - ~OutgoingBody() { - Dispose(false); - } - internal static class WriteWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]outgoing-body.write"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]outgoing-body.write"), WasmImportLinkage] internal static extern void wasmImportWrite(int p0, nint p1); } - internal unsafe global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.OutputStream Write() + internal unsafe global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.OutputStream Write() { var handle = this.Handle; @@ -4569,18 +4519,18 @@ internal static class WriteWasmInterop var ptr = (nint)retAreaByte0; WriteWasmInterop.wasmImportWrite(handle, ptr); - Result lifted; + Result lifted; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.OutputStream(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.OutputStream.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 4), 4)))); + var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.OutputStream(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.OutputStream.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 4), 4)))); - lifted = Result.ok(resource); + lifted = Result.ok(resource); break; } case 1: { - lifted = Result.err(new global::WasiHttpWorld.None()); + lifted = Result.err(new global::WasiHttpWorld.None()); break; } @@ -4599,12 +4549,12 @@ internal static class WriteWasmInterop internal static class FinishWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[static]outgoing-body.finish"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[static]outgoing-body.finish"), WasmImportLinkage] internal static extern void wasmImportFinish(int p0, int p1, int p2, nint p3); } - internal static unsafe void Finish(global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.OutgoingBody @this, global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields? trailers) + internal static unsafe void Finish(global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.OutgoingBody @this, global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields? trailers) { var handle = @this.Handle; @this.Handle = 0; @@ -4613,7 +4563,7 @@ internal static unsafe void Finish(global::WasiHttpWorld.wit.imports.wasi.http. int lowered4; if (trailers != null) { - var payload2 = (global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.Fields) trailers; + var payload2 = (global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.Fields) trailers; var handle3 = payload2.Handle; payload2.Handle = 0; @@ -4633,22 +4583,22 @@ internal static unsafe void Finish(global::WasiHttpWorld.wit.imports.wasi.http. var ptr = (nint)retAreaByte0; FinishWasmInterop.wasmImportFinish(handle, lowered, lowered4, ptr); - Result lifted197; + Result lifted197; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - lifted197 = Result.ok(new global::WasiHttpWorld.None()); + lifted197 = Result.ok(new global::WasiHttpWorld.None()); break; } case 1: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode lifted196; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode lifted196; switch (new Span((void*)(ptr + 8), 1)[0]) { case 0: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.dnsTimeout(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.dnsTimeout(); break; } case 1: { @@ -4687,68 +4637,68 @@ internal static unsafe void Finish(global::WasiHttpWorld.wit.imports.wasi.http. default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 28), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.dnsError(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.DnsErrorPayload ( + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.dnsError(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.DnsErrorPayload ( lifted, lifted21)); break; } case 2: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.destinationNotFound(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.destinationNotFound(); break; } case 3: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.destinationUnavailable(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.destinationUnavailable(); break; } case 4: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.destinationIpProhibited(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.destinationIpProhibited(); break; } case 5: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.destinationIpUnroutable(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.destinationIpUnroutable(); break; } case 6: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionRefused(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionRefused(); break; } case 7: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionTerminated(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionTerminated(); break; } case 8: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionTimeout(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionTimeout(); break; } case 9: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionReadTimeout(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionReadTimeout(); break; } case 10: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionWriteTimeout(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionWriteTimeout(); break; } case 11: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionLimitReached(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionLimitReached(); break; } case 12: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.tlsProtocolError(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.tlsProtocolError(); break; } case 13: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.tlsCertificateError(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.tlsCertificateError(); break; } case 14: { @@ -4787,18 +4737,18 @@ internal static unsafe void Finish(global::WasiHttpWorld.wit.imports.wasi.http. default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 20), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.tlsAlertReceived(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.TlsAlertReceivedPayload ( + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.tlsAlertReceived(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.TlsAlertReceivedPayload ( lifted52, lifted57)); break; } case 15: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestDenied(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestDenied(); break; } case 16: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestLengthRequired(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestLengthRequired(); break; } case 17: { @@ -4820,22 +4770,22 @@ internal static unsafe void Finish(global::WasiHttpWorld.wit.imports.wasi.http. default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestBodySize(lifted68); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestBodySize(lifted68); break; } case 18: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestMethodInvalid(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestMethodInvalid(); break; } case 19: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestUriInvalid(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestUriInvalid(); break; } case 20: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestUriTooLong(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestUriTooLong(); break; } case 21: { @@ -4857,12 +4807,12 @@ internal static unsafe void Finish(global::WasiHttpWorld.wit.imports.wasi.http. default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestHeaderSectionSize(lifted81); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestHeaderSectionSize(lifted81); break; } case 22: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload? lifted98; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload? lifted98; switch (new Span((void*)(ptr + 16), 1)[0]) { case 0: { @@ -4906,7 +4856,7 @@ internal static unsafe void Finish(global::WasiHttpWorld.wit.imports.wasi.http. default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 32), 1)[0])); } - lifted98 = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload ( + lifted98 = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload ( lifted92, lifted97); break; } @@ -4914,7 +4864,7 @@ internal static unsafe void Finish(global::WasiHttpWorld.wit.imports.wasi.http. default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestHeaderSize(lifted98); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestHeaderSize(lifted98); break; } case 23: { @@ -4936,7 +4886,7 @@ internal static unsafe void Finish(global::WasiHttpWorld.wit.imports.wasi.http. default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestTrailerSectionSize(lifted105); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestTrailerSectionSize(lifted105); break; } case 24: { @@ -4975,13 +4925,13 @@ internal static unsafe void Finish(global::WasiHttpWorld.wit.imports.wasi.http. default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 28), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestTrailerSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload ( + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestTrailerSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload ( lifted112, lifted117)); break; } case 25: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseIncomplete(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseIncomplete(); break; } case 26: { @@ -5003,7 +4953,7 @@ internal static unsafe void Finish(global::WasiHttpWorld.wit.imports.wasi.http. default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseHeaderSectionSize(lifted126); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseHeaderSectionSize(lifted126); break; } case 27: { @@ -5042,7 +4992,7 @@ internal static unsafe void Finish(global::WasiHttpWorld.wit.imports.wasi.http. default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 28), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseHeaderSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload ( + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseHeaderSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload ( lifted133, lifted138)); break; } @@ -5065,7 +5015,7 @@ internal static unsafe void Finish(global::WasiHttpWorld.wit.imports.wasi.http. default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseBodySize(lifted145); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseBodySize(lifted145); break; } case 29: { @@ -5087,7 +5037,7 @@ internal static unsafe void Finish(global::WasiHttpWorld.wit.imports.wasi.http. default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseTrailerSectionSize(lifted152); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseTrailerSectionSize(lifted152); break; } case 30: { @@ -5126,7 +5076,7 @@ internal static unsafe void Finish(global::WasiHttpWorld.wit.imports.wasi.http. default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 28), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseTrailerSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload ( + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseTrailerSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload ( lifted159, lifted164)); break; } @@ -5149,7 +5099,7 @@ internal static unsafe void Finish(global::WasiHttpWorld.wit.imports.wasi.http. default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseTransferCoding(lifted171); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseTransferCoding(lifted171); break; } case 32: { @@ -5171,32 +5121,32 @@ internal static unsafe void Finish(global::WasiHttpWorld.wit.imports.wasi.http. default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseContentCoding(lifted178); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseContentCoding(lifted178); break; } case 33: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseTimeout(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseTimeout(); break; } case 34: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpUpgradeFailed(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpUpgradeFailed(); break; } case 35: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpProtocolError(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpProtocolError(); break; } case 36: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.loopDetected(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.loopDetected(); break; } case 37: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.configurationError(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.configurationError(); break; } case 38: { @@ -5218,14 +5168,14 @@ internal static unsafe void Finish(global::WasiHttpWorld.wit.imports.wasi.http. default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.internalError(lifted195); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.internalError(lifted195); break; } default: throw new ArgumentException($"invalid discriminant: {new Span((void*)(ptr + 8), 1)[0]}"); } - lifted197 = Result.err(lifted196); + lifted197 = Result.err(lifted196); break; } @@ -5245,7 +5195,7 @@ internal static unsafe void Finish(global::WasiHttpWorld.wit.imports.wasi.http. } /** - * Represents a future which may eventually return an incoming HTTP + * Represents a future which may eventaully return an incoming HTTP * Response, or an error. * * This resource is returned by the `wasi:http/outgoing-handler` interface to @@ -5263,35 +5213,30 @@ internal FutureIncomingResponse(THandle handle) { public void Dispose() { Dispose(true); - GC.SuppressFinalize(this); } - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[resource-drop]future-incoming-response"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[resource-drop]future-incoming-response"), WasmImportLinkage] private static extern void wasmImportResourceDrop(int p0); protected virtual void Dispose(bool disposing) { - if (Handle != 0) { + if (disposing && Handle != 0) { wasmImportResourceDrop(Handle); Handle = 0; } } - ~FutureIncomingResponse() { - Dispose(false); - } - internal static class SubscribeWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]future-incoming-response.subscribe"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]future-incoming-response.subscribe"), WasmImportLinkage] internal static extern int wasmImportSubscribe(int p0); } - internal unsafe global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IPoll.Pollable Subscribe() + internal unsafe global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable Subscribe() { var handle = this.Handle; var result = SubscribeWasmInterop.wasmImportSubscribe(handle); - var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IPoll.Pollable(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IPoll.Pollable.THandle(result)); + var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable.THandle(result)); return resource; //TODO: free alloc handle (interopString) if exists @@ -5299,12 +5244,12 @@ internal static class SubscribeWasmInterop internal static class GetWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "[method]future-incoming-response.get"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "[method]future-incoming-response.get"), WasmImportLinkage] internal static extern void wasmImportGet(int p0, nint p1); } - internal unsafe Result, None>? Get() + internal unsafe Result, None>? Get() { var handle = this.Handle; @@ -5314,7 +5259,7 @@ internal static class GetWasmInterop var ptr = (nint)retAreaByte0; GetWasmInterop.wasmImportGet(handle, ptr); - Result, None>? lifted200; + Result, None>? lifted200; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { @@ -5324,28 +5269,28 @@ internal static class GetWasmInterop case 1: { - Result, None> lifted199; + Result, None> lifted199; switch (new Span((void*)(ptr + 8), 1)[0]) { case 0: { - Result lifted196; + Result lifted196; switch (new Span((void*)(ptr + 16), 1)[0]) { case 0: { - var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.IncomingResponse(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.IncomingResponse.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 24), 4)))); + var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.IncomingResponse(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.IncomingResponse.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 24), 4)))); - lifted196 = Result.ok(resource); + lifted196 = Result.ok(resource); break; } case 1: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode lifted195; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode lifted195; switch (new Span((void*)(ptr + 24), 1)[0]) { case 0: { - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.dnsTimeout(); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.dnsTimeout(); break; } case 1: { @@ -5384,68 +5329,68 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 44), 1)[0])); } - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.dnsError(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.DnsErrorPayload ( + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.dnsError(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.DnsErrorPayload ( lifted, lifted20)); break; } case 2: { - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.destinationNotFound(); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.destinationNotFound(); break; } case 3: { - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.destinationUnavailable(); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.destinationUnavailable(); break; } case 4: { - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.destinationIpProhibited(); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.destinationIpProhibited(); break; } case 5: { - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.destinationIpUnroutable(); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.destinationIpUnroutable(); break; } case 6: { - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionRefused(); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionRefused(); break; } case 7: { - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionTerminated(); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionTerminated(); break; } case 8: { - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionTimeout(); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionTimeout(); break; } case 9: { - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionReadTimeout(); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionReadTimeout(); break; } case 10: { - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionWriteTimeout(); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionWriteTimeout(); break; } case 11: { - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionLimitReached(); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionLimitReached(); break; } case 12: { - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.tlsProtocolError(); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.tlsProtocolError(); break; } case 13: { - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.tlsCertificateError(); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.tlsCertificateError(); break; } case 14: { @@ -5484,18 +5429,18 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 36), 1)[0])); } - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.tlsAlertReceived(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.TlsAlertReceivedPayload ( + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.tlsAlertReceived(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.TlsAlertReceivedPayload ( lifted51, lifted56)); break; } case 15: { - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestDenied(); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestDenied(); break; } case 16: { - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestLengthRequired(); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestLengthRequired(); break; } case 17: { @@ -5517,22 +5462,22 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 32), 1)[0])); } - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestBodySize(lifted67); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestBodySize(lifted67); break; } case 18: { - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestMethodInvalid(); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestMethodInvalid(); break; } case 19: { - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestUriInvalid(); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestUriInvalid(); break; } case 20: { - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestUriTooLong(); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestUriTooLong(); break; } case 21: { @@ -5554,12 +5499,12 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 32), 1)[0])); } - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestHeaderSectionSize(lifted80); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestHeaderSectionSize(lifted80); break; } case 22: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload? lifted97; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload? lifted97; switch (new Span((void*)(ptr + 32), 1)[0]) { case 0: { @@ -5603,7 +5548,7 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 48), 1)[0])); } - lifted97 = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload ( + lifted97 = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload ( lifted91, lifted96); break; } @@ -5611,7 +5556,7 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 32), 1)[0])); } - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestHeaderSize(lifted97); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestHeaderSize(lifted97); break; } case 23: { @@ -5633,7 +5578,7 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 32), 1)[0])); } - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestTrailerSectionSize(lifted104); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestTrailerSectionSize(lifted104); break; } case 24: { @@ -5672,13 +5617,13 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 44), 1)[0])); } - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestTrailerSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload ( + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestTrailerSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload ( lifted111, lifted116)); break; } case 25: { - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseIncomplete(); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseIncomplete(); break; } case 26: { @@ -5700,7 +5645,7 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 32), 1)[0])); } - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseHeaderSectionSize(lifted125); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseHeaderSectionSize(lifted125); break; } case 27: { @@ -5739,7 +5684,7 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 44), 1)[0])); } - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseHeaderSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload ( + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseHeaderSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload ( lifted132, lifted137)); break; } @@ -5762,7 +5707,7 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 32), 1)[0])); } - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseBodySize(lifted144); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseBodySize(lifted144); break; } case 29: { @@ -5784,7 +5729,7 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 32), 1)[0])); } - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseTrailerSectionSize(lifted151); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseTrailerSectionSize(lifted151); break; } case 30: { @@ -5823,7 +5768,7 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 44), 1)[0])); } - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseTrailerSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload ( + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseTrailerSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload ( lifted158, lifted163)); break; } @@ -5846,7 +5791,7 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 32), 1)[0])); } - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseTransferCoding(lifted170); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseTransferCoding(lifted170); break; } case 32: { @@ -5868,32 +5813,32 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 32), 1)[0])); } - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseContentCoding(lifted177); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseContentCoding(lifted177); break; } case 33: { - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseTimeout(); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseTimeout(); break; } case 34: { - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpUpgradeFailed(); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpUpgradeFailed(); break; } case 35: { - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpProtocolError(); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpProtocolError(); break; } case 36: { - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.loopDetected(); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.loopDetected(); break; } case 37: { - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.configurationError(); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.configurationError(); break; } case 38: { @@ -5915,26 +5860,26 @@ internal static class GetWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 32), 1)[0])); } - lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.internalError(lifted194); + lifted195 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.internalError(lifted194); break; } default: throw new ArgumentException($"invalid discriminant: {new Span((void*)(ptr + 24), 1)[0]}"); } - lifted196 = Result.err(lifted195); + lifted196 = Result.err(lifted195); break; } default: throw new ArgumentException($"invalid discriminant: {new Span((void*)(ptr + 16), 1)[0]}"); } - lifted199 = Result, None>.ok(lifted196); + lifted199 = Result, None>.ok(lifted196); break; } case 1: { - lifted199 = Result, None>.err(new global::WasiHttpWorld.None()); + lifted199 = Result, None>.err(new global::WasiHttpWorld.None()); break; } diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.http.v0_2_1.OutgoingHandlerInterop.cs b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.http.v0_2_0.OutgoingHandlerInterop.cs similarity index 87% rename from src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.http.v0_2_1.OutgoingHandlerInterop.cs rename to src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.http.v0_2_0.OutgoingHandlerInterop.cs index 10aba859a4b..2d24c51b3ae 100644 --- a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.http.v0_2_1.OutgoingHandlerInterop.cs +++ b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.http.v0_2_0.OutgoingHandlerInterop.cs @@ -1,4 +1,4 @@ -// Generated by `wit-bindgen` 0.29.0. DO NOT EDIT! +// Generated by `wit-bindgen` 0.32.0. DO NOT EDIT! // #nullable enable @@ -11,18 +11,18 @@ using System.Diagnostics; using System.Diagnostics.CodeAnalysis; -namespace WasiHttpWorld.wit.imports.wasi.http.v0_2_1 +namespace WasiHttpWorld.wit.imports.wasi.http.v0_2_0 { internal static class OutgoingHandlerInterop { internal static class HandleWasmInterop { - [DllImport("wasi:http/outgoing-handler@0.2.1", EntryPoint = "handle"), WasmImportLinkage] + [DllImport("wasi:http/outgoing-handler@0.2.0", EntryPoint = "handle"), WasmImportLinkage] internal static extern void wasmImportHandle(int p0, int p1, int p2, nint p3); } - internal static unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FutureIncomingResponse Handle(global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.OutgoingRequest request, global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.RequestOptions? options) + internal static unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FutureIncomingResponse Handle(global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.OutgoingRequest request, global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.RequestOptions? options) { var handle = request.Handle; request.Handle = 0; @@ -31,7 +31,7 @@ internal static class HandleWasmInterop int lowered4; if (options != null) { - var payload2 = (global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.RequestOptions) options; + var payload2 = (global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.RequestOptions) options; var handle3 = payload2.Handle; payload2.Handle = 0; @@ -51,23 +51,23 @@ internal static class HandleWasmInterop var ptr = (nint)retAreaByte0; HandleWasmInterop.wasmImportHandle(handle, lowered, lowered4, ptr); - Result lifted197; + Result lifted197; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FutureIncomingResponse(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FutureIncomingResponse.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)))); + var resource = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FutureIncomingResponse(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FutureIncomingResponse.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)))); - lifted197 = Result.ok(resource); + lifted197 = Result.ok(resource); break; } case 1: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode lifted196; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode lifted196; switch (new Span((void*)(ptr + 8), 1)[0]) { case 0: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.dnsTimeout(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.dnsTimeout(); break; } case 1: { @@ -106,68 +106,68 @@ internal static class HandleWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 28), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.dnsError(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.DnsErrorPayload ( + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.dnsError(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.DnsErrorPayload ( lifted, lifted21)); break; } case 2: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.destinationNotFound(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.destinationNotFound(); break; } case 3: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.destinationUnavailable(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.destinationUnavailable(); break; } case 4: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.destinationIpProhibited(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.destinationIpProhibited(); break; } case 5: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.destinationIpUnroutable(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.destinationIpUnroutable(); break; } case 6: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionRefused(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionRefused(); break; } case 7: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionTerminated(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionTerminated(); break; } case 8: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionTimeout(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionTimeout(); break; } case 9: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionReadTimeout(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionReadTimeout(); break; } case 10: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionWriteTimeout(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionWriteTimeout(); break; } case 11: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionLimitReached(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionLimitReached(); break; } case 12: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.tlsProtocolError(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.tlsProtocolError(); break; } case 13: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.tlsCertificateError(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.tlsCertificateError(); break; } case 14: { @@ -206,18 +206,18 @@ internal static class HandleWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 20), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.tlsAlertReceived(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.TlsAlertReceivedPayload ( + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.tlsAlertReceived(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.TlsAlertReceivedPayload ( lifted52, lifted57)); break; } case 15: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestDenied(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestDenied(); break; } case 16: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestLengthRequired(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestLengthRequired(); break; } case 17: { @@ -239,22 +239,22 @@ internal static class HandleWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestBodySize(lifted68); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestBodySize(lifted68); break; } case 18: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestMethodInvalid(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestMethodInvalid(); break; } case 19: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestUriInvalid(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestUriInvalid(); break; } case 20: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestUriTooLong(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestUriTooLong(); break; } case 21: { @@ -276,12 +276,12 @@ internal static class HandleWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestHeaderSectionSize(lifted81); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestHeaderSectionSize(lifted81); break; } case 22: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload? lifted98; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload? lifted98; switch (new Span((void*)(ptr + 16), 1)[0]) { case 0: { @@ -325,7 +325,7 @@ internal static class HandleWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 32), 1)[0])); } - lifted98 = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload ( + lifted98 = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload ( lifted92, lifted97); break; } @@ -333,7 +333,7 @@ internal static class HandleWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestHeaderSize(lifted98); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestHeaderSize(lifted98); break; } case 23: { @@ -355,7 +355,7 @@ internal static class HandleWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestTrailerSectionSize(lifted105); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestTrailerSectionSize(lifted105); break; } case 24: { @@ -394,13 +394,13 @@ internal static class HandleWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 28), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestTrailerSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload ( + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestTrailerSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload ( lifted112, lifted117)); break; } case 25: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseIncomplete(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseIncomplete(); break; } case 26: { @@ -422,7 +422,7 @@ internal static class HandleWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseHeaderSectionSize(lifted126); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseHeaderSectionSize(lifted126); break; } case 27: { @@ -461,7 +461,7 @@ internal static class HandleWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 28), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseHeaderSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload ( + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseHeaderSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload ( lifted133, lifted138)); break; } @@ -484,7 +484,7 @@ internal static class HandleWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseBodySize(lifted145); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseBodySize(lifted145); break; } case 29: { @@ -506,7 +506,7 @@ internal static class HandleWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseTrailerSectionSize(lifted152); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseTrailerSectionSize(lifted152); break; } case 30: { @@ -545,7 +545,7 @@ internal static class HandleWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 28), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseTrailerSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload ( + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseTrailerSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload ( lifted159, lifted164)); break; } @@ -568,7 +568,7 @@ internal static class HandleWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseTransferCoding(lifted171); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseTransferCoding(lifted171); break; } case 32: { @@ -590,32 +590,32 @@ internal static class HandleWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseContentCoding(lifted178); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseContentCoding(lifted178); break; } case 33: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseTimeout(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseTimeout(); break; } case 34: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpUpgradeFailed(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpUpgradeFailed(); break; } case 35: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpProtocolError(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpProtocolError(); break; } case 36: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.loopDetected(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.loopDetected(); break; } case 37: { - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.configurationError(); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.configurationError(); break; } case 38: { @@ -637,14 +637,14 @@ internal static class HandleWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.internalError(lifted195); + lifted196 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.internalError(lifted195); break; } default: throw new ArgumentException($"invalid discriminant: {new Span((void*)(ptr + 8), 1)[0]}"); } - lifted197 = Result.err(lifted196); + lifted197 = Result.err(lifted196); break; } diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.http.v0_2_1.TypesInterop.cs b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.http.v0_2_0.TypesInterop.cs similarity index 89% rename from src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.http.v0_2_1.TypesInterop.cs rename to src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.http.v0_2_0.TypesInterop.cs index 121f6cfdd50..f4505e864af 100644 --- a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.http.v0_2_1.TypesInterop.cs +++ b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.http.v0_2_0.TypesInterop.cs @@ -1,4 +1,4 @@ -// Generated by `wit-bindgen` 0.29.0. DO NOT EDIT! +// Generated by `wit-bindgen` 0.32.0. DO NOT EDIT! // #nullable enable @@ -11,18 +11,18 @@ using System.Diagnostics; using System.Diagnostics.CodeAnalysis; -namespace WasiHttpWorld.wit.imports.wasi.http.v0_2_1 +namespace WasiHttpWorld.wit.imports.wasi.http.v0_2_0 { internal static class TypesInterop { internal static class HttpErrorCodeWasmInterop { - [DllImport("wasi:http/types@0.2.1", EntryPoint = "http-error-code"), WasmImportLinkage] + [DllImport("wasi:http/types@0.2.0", EntryPoint = "http-error-code"), WasmImportLinkage] internal static extern void wasmImportHttpErrorCode(int p0, nint p1); } - internal static unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode? HttpErrorCode(global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error err) + internal static unsafe global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode? HttpErrorCode(global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error err) { var handle = err.Handle; @@ -32,7 +32,7 @@ internal static class HttpErrorCodeWasmInterop var ptr = (nint)retAreaByte0; HttpErrorCodeWasmInterop.wasmImportHttpErrorCode(handle, ptr); - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode? lifted190; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode? lifted190; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { @@ -42,12 +42,12 @@ internal static class HttpErrorCodeWasmInterop case 1: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode lifted189; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode lifted189; switch (new Span((void*)(ptr + 8), 1)[0]) { case 0: { - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.dnsTimeout(); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.dnsTimeout(); break; } case 1: { @@ -86,68 +86,68 @@ internal static class HttpErrorCodeWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 28), 1)[0])); } - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.dnsError(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.DnsErrorPayload ( + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.dnsError(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.DnsErrorPayload ( lifted, lifted14)); break; } case 2: { - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.destinationNotFound(); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.destinationNotFound(); break; } case 3: { - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.destinationUnavailable(); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.destinationUnavailable(); break; } case 4: { - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.destinationIpProhibited(); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.destinationIpProhibited(); break; } case 5: { - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.destinationIpUnroutable(); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.destinationIpUnroutable(); break; } case 6: { - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionRefused(); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionRefused(); break; } case 7: { - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionTerminated(); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionTerminated(); break; } case 8: { - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionTimeout(); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionTimeout(); break; } case 9: { - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionReadTimeout(); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionReadTimeout(); break; } case 10: { - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionWriteTimeout(); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionWriteTimeout(); break; } case 11: { - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.connectionLimitReached(); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.connectionLimitReached(); break; } case 12: { - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.tlsProtocolError(); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.tlsProtocolError(); break; } case 13: { - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.tlsCertificateError(); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.tlsCertificateError(); break; } case 14: { @@ -186,18 +186,18 @@ internal static class HttpErrorCodeWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 20), 1)[0])); } - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.tlsAlertReceived(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.TlsAlertReceivedPayload ( + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.tlsAlertReceived(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.TlsAlertReceivedPayload ( lifted45, lifted50)); break; } case 15: { - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestDenied(); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestDenied(); break; } case 16: { - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestLengthRequired(); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestLengthRequired(); break; } case 17: { @@ -219,22 +219,22 @@ internal static class HttpErrorCodeWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestBodySize(lifted61); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestBodySize(lifted61); break; } case 18: { - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestMethodInvalid(); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestMethodInvalid(); break; } case 19: { - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestUriInvalid(); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestUriInvalid(); break; } case 20: { - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestUriTooLong(); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestUriTooLong(); break; } case 21: { @@ -256,12 +256,12 @@ internal static class HttpErrorCodeWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestHeaderSectionSize(lifted74); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestHeaderSectionSize(lifted74); break; } case 22: { - global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload? lifted91; + global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload? lifted91; switch (new Span((void*)(ptr + 16), 1)[0]) { case 0: { @@ -305,7 +305,7 @@ internal static class HttpErrorCodeWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 32), 1)[0])); } - lifted91 = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload ( + lifted91 = new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload ( lifted85, lifted90); break; } @@ -313,7 +313,7 @@ internal static class HttpErrorCodeWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestHeaderSize(lifted91); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestHeaderSize(lifted91); break; } case 23: { @@ -335,7 +335,7 @@ internal static class HttpErrorCodeWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestTrailerSectionSize(lifted98); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestTrailerSectionSize(lifted98); break; } case 24: { @@ -374,13 +374,13 @@ internal static class HttpErrorCodeWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 28), 1)[0])); } - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpRequestTrailerSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload ( + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpRequestTrailerSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload ( lifted105, lifted110)); break; } case 25: { - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseIncomplete(); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseIncomplete(); break; } case 26: { @@ -402,7 +402,7 @@ internal static class HttpErrorCodeWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseHeaderSectionSize(lifted119); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseHeaderSectionSize(lifted119); break; } case 27: { @@ -441,7 +441,7 @@ internal static class HttpErrorCodeWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 28), 1)[0])); } - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseHeaderSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload ( + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseHeaderSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload ( lifted126, lifted131)); break; } @@ -464,7 +464,7 @@ internal static class HttpErrorCodeWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseBodySize(lifted138); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseBodySize(lifted138); break; } case 29: { @@ -486,7 +486,7 @@ internal static class HttpErrorCodeWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseTrailerSectionSize(lifted145); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseTrailerSectionSize(lifted145); break; } case 30: { @@ -525,7 +525,7 @@ internal static class HttpErrorCodeWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 28), 1)[0])); } - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseTrailerSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.FieldSizePayload ( + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseTrailerSize(new global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.FieldSizePayload ( lifted152, lifted157)); break; } @@ -548,7 +548,7 @@ internal static class HttpErrorCodeWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseTransferCoding(lifted164); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseTransferCoding(lifted164); break; } case 32: { @@ -570,32 +570,32 @@ internal static class HttpErrorCodeWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseContentCoding(lifted171); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseContentCoding(lifted171); break; } case 33: { - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpResponseTimeout(); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpResponseTimeout(); break; } case 34: { - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpUpgradeFailed(); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpUpgradeFailed(); break; } case 35: { - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.httpProtocolError(); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.httpProtocolError(); break; } case 36: { - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.loopDetected(); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.loopDetected(); break; } case 37: { - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.configurationError(); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.configurationError(); break; } case 38: { @@ -617,7 +617,7 @@ internal static class HttpErrorCodeWasmInterop default: throw new ArgumentException("invalid discriminant: " + (new Span((void*)(ptr + 16), 1)[0])); } - lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_1.ITypes.ErrorCode.internalError(lifted188); + lifted189 = global::WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes.ErrorCode.internalError(lifted188); break; } diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_1.ErrorInterop.cs b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_0.ErrorInterop.cs similarity index 76% rename from src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_1.ErrorInterop.cs rename to src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_0.ErrorInterop.cs index 2c3246555fc..1e1f0b474f7 100644 --- a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_1.ErrorInterop.cs +++ b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_0.ErrorInterop.cs @@ -1,4 +1,4 @@ -// Generated by `wit-bindgen` 0.29.0. DO NOT EDIT! +// Generated by `wit-bindgen` 0.32.0. DO NOT EDIT! // #nullable enable @@ -11,7 +11,7 @@ using System.Diagnostics; using System.Diagnostics.CodeAnalysis; -namespace WasiHttpWorld.wit.imports.wasi.io.v0_2_1 +namespace WasiHttpWorld.wit.imports.wasi.io.v0_2_0 { internal static class ErrorInterop { diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.cs b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.cs similarity index 75% rename from src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.cs rename to src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.cs index 3621e1c1fd3..b756be5ca46 100644 --- a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.cs +++ b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.cs @@ -1,4 +1,4 @@ -// Generated by `wit-bindgen` 0.29.0. DO NOT EDIT! +// Generated by `wit-bindgen` 0.32.0. DO NOT EDIT! // #nullable enable @@ -11,7 +11,7 @@ using System.Diagnostics; using System.Diagnostics.CodeAnalysis; -namespace WasiHttpWorld.wit.imports.wasi.io.v0_2_1; +namespace WasiHttpWorld.wit.imports.wasi.io.v0_2_0; internal interface IError { @@ -25,11 +25,13 @@ internal interface IError { * `wasi:io/streams/stream-error` type. * * To provide more specific error information, other interfaces may - * offer functions to "downcast" this error into more specific types. For example, - * errors returned from streams derived from filesystem types can be described using - * the filesystem's own error-code type. This is done using the function - * `wasi:filesystem/types/filesystem-error-code`, which takes a `borrow<error>` - * parameter and returns an `option<wasi:filesystem/types/error-code>`. + * provide functions to further "downcast" this error into more specific + * error information. For example, `error`s returned in streams derived + * from filesystem types to be described using the filesystem's own + * error-code type, using the function + * `wasi:filesystem/types/filesystem-error-code`, which takes a parameter + * `borrow<error>` and returns + * `option<wasi:filesystem/types/error-code>`. * * The set of functions which can "downcast" an `error` into a more * concrete type is open. @@ -46,26 +48,21 @@ internal Error(THandle handle) { public void Dispose() { Dispose(true); - GC.SuppressFinalize(this); } - [DllImport("wasi:io/error@0.2.1", EntryPoint = "[resource-drop]error"), WasmImportLinkage] + [DllImport("wasi:io/error@0.2.0", EntryPoint = "[resource-drop]error"), WasmImportLinkage] private static extern void wasmImportResourceDrop(int p0); protected virtual void Dispose(bool disposing) { - if (Handle != 0) { + if (disposing && Handle != 0) { wasmImportResourceDrop(Handle); Handle = 0; } } - ~Error() { - Dispose(false); - } - internal static class ToDebugStringWasmInterop { - [DllImport("wasi:io/error@0.2.1", EntryPoint = "[method]error.to-debug-string"), WasmImportLinkage] + [DllImport("wasi:io/error@0.2.0", EntryPoint = "[method]error.to-debug-string"), WasmImportLinkage] internal static extern void wasmImportToDebugString(int p0, nint p1); } diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IPoll.cs b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IPoll.cs similarity index 80% rename from src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IPoll.cs rename to src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IPoll.cs index 0c4559fe841..0f40463e5cd 100644 --- a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IPoll.cs +++ b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IPoll.cs @@ -1,4 +1,4 @@ -// Generated by `wit-bindgen` 0.29.0. DO NOT EDIT! +// Generated by `wit-bindgen` 0.32.0. DO NOT EDIT! // #nullable enable @@ -11,7 +11,7 @@ using System.Diagnostics; using System.Diagnostics.CodeAnalysis; -namespace WasiHttpWorld.wit.imports.wasi.io.v0_2_1; +namespace WasiHttpWorld.wit.imports.wasi.io.v0_2_0; internal interface IPoll { @@ -30,26 +30,21 @@ internal Pollable(THandle handle) { public void Dispose() { Dispose(true); - GC.SuppressFinalize(this); } - [DllImport("wasi:io/poll@0.2.1", EntryPoint = "[resource-drop]pollable"), WasmImportLinkage] + [DllImport("wasi:io/poll@0.2.0", EntryPoint = "[resource-drop]pollable"), WasmImportLinkage] private static extern void wasmImportResourceDrop(int p0); protected virtual void Dispose(bool disposing) { - if (Handle != 0) { + if (disposing && Handle != 0) { wasmImportResourceDrop(Handle); Handle = 0; } } - ~Pollable() { - Dispose(false); - } - internal static class ReadyWasmInterop { - [DllImport("wasi:io/poll@0.2.1", EntryPoint = "[method]pollable.ready"), WasmImportLinkage] + [DllImport("wasi:io/poll@0.2.0", EntryPoint = "[method]pollable.ready"), WasmImportLinkage] internal static extern int wasmImportReady(int p0); } @@ -65,7 +60,7 @@ internal unsafe bool Ready() internal static class BlockWasmInterop { - [DllImport("wasi:io/poll@0.2.1", EntryPoint = "[method]pollable.block"), WasmImportLinkage] + [DllImport("wasi:io/poll@0.2.0", EntryPoint = "[method]pollable.block"), WasmImportLinkage] internal static extern void wasmImportBlock(int p0); } diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.cs b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.cs similarity index 81% rename from src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.cs rename to src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.cs index ab775cbfeb0..650ebe41d3a 100644 --- a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.cs +++ b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.cs @@ -1,4 +1,4 @@ -// Generated by `wit-bindgen` 0.29.0. DO NOT EDIT! +// Generated by `wit-bindgen` 0.32.0. DO NOT EDIT! // #nullable enable @@ -11,7 +11,7 @@ using System.Diagnostics; using System.Diagnostics.CodeAnalysis; -namespace WasiHttpWorld.wit.imports.wasi.io.v0_2_1; +namespace WasiHttpWorld.wit.imports.wasi.io.v0_2_0; internal interface IStreams { @@ -28,7 +28,7 @@ private StreamError(byte tag, object? value) { this.value = value; } - internal static StreamError lastOperationFailed(global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error lastOperationFailed) { + internal static StreamError lastOperationFailed(global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error lastOperationFailed) { return new StreamError(LAST_OPERATION_FAILED, lastOperationFailed); } @@ -36,12 +36,12 @@ internal static StreamError closed() { return new StreamError(CLOSED, null); } - internal global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error AsLastOperationFailed + internal global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error AsLastOperationFailed { get { if (Tag == LAST_OPERATION_FAILED) - return (global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error)value!; + return (global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error)value!; else throw new ArgumentException("expected LAST_OPERATION_FAILED, got " + Tag); } @@ -73,26 +73,21 @@ internal InputStream(THandle handle) { public void Dispose() { Dispose(true); - GC.SuppressFinalize(this); } - [DllImport("wasi:io/streams@0.2.1", EntryPoint = "[resource-drop]input-stream"), WasmImportLinkage] + [DllImport("wasi:io/streams@0.2.0", EntryPoint = "[resource-drop]input-stream"), WasmImportLinkage] private static extern void wasmImportResourceDrop(int p0); protected virtual void Dispose(bool disposing) { - if (Handle != 0) { + if (disposing && Handle != 0) { wasmImportResourceDrop(Handle); Handle = 0; } } - ~InputStream() { - Dispose(false); - } - internal static class ReadWasmInterop { - [DllImport("wasi:io/streams@0.2.1", EntryPoint = "[method]input-stream.read"), WasmImportLinkage] + [DllImport("wasi:io/streams@0.2.0", EntryPoint = "[method]input-stream.read"), WasmImportLinkage] internal static extern void wasmImportRead(int p0, long p1, nint p2); } @@ -107,7 +102,7 @@ internal unsafe byte[] Read(ulong len) var ptr = (nint)retAreaByte0; ReadWasmInterop.wasmImportRead(handle, unchecked((long)(len)), ptr); - Result lifted6; + Result lifted6; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { @@ -115,30 +110,30 @@ internal unsafe byte[] Read(ulong len) var array = new byte[BitConverter.ToInt32(new Span((void*)(ptr + 8), 4))]; new Span((void*)(BitConverter.ToInt32(new Span((void*)(ptr + 4), 4))), BitConverter.ToInt32(new Span((void*)(ptr + 8), 4))).CopyTo(new Span(array)); - lifted6 = Result.ok(array); + lifted6 = Result.ok(array); break; } case 1: { - global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError lifted; + global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError lifted; switch (new Span((void*)(ptr + 4), 1)[0]) { case 0: { - var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)))); + var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)))); - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.lastOperationFailed(resource); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.lastOperationFailed(resource); break; } case 1: { - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.closed(); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.closed(); break; } default: throw new ArgumentException($"invalid discriminant: {new Span((void*)(ptr + 4), 1)[0]}"); } - lifted6 = Result.err(lifted); + lifted6 = Result.err(lifted); break; } @@ -157,7 +152,7 @@ internal unsafe byte[] Read(ulong len) internal static class BlockingReadWasmInterop { - [DllImport("wasi:io/streams@0.2.1", EntryPoint = "[method]input-stream.blocking-read"), WasmImportLinkage] + [DllImport("wasi:io/streams@0.2.0", EntryPoint = "[method]input-stream.blocking-read"), WasmImportLinkage] internal static extern void wasmImportBlockingRead(int p0, long p1, nint p2); } @@ -172,7 +167,7 @@ internal unsafe byte[] BlockingRead(ulong len) var ptr = (nint)retAreaByte0; BlockingReadWasmInterop.wasmImportBlockingRead(handle, unchecked((long)(len)), ptr); - Result lifted6; + Result lifted6; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { @@ -180,30 +175,30 @@ internal unsafe byte[] BlockingRead(ulong len) var array = new byte[BitConverter.ToInt32(new Span((void*)(ptr + 8), 4))]; new Span((void*)(BitConverter.ToInt32(new Span((void*)(ptr + 4), 4))), BitConverter.ToInt32(new Span((void*)(ptr + 8), 4))).CopyTo(new Span(array)); - lifted6 = Result.ok(array); + lifted6 = Result.ok(array); break; } case 1: { - global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError lifted; + global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError lifted; switch (new Span((void*)(ptr + 4), 1)[0]) { case 0: { - var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)))); + var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)))); - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.lastOperationFailed(resource); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.lastOperationFailed(resource); break; } case 1: { - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.closed(); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.closed(); break; } default: throw new ArgumentException($"invalid discriminant: {new Span((void*)(ptr + 4), 1)[0]}"); } - lifted6 = Result.err(lifted); + lifted6 = Result.err(lifted); break; } @@ -222,7 +217,7 @@ internal unsafe byte[] BlockingRead(ulong len) internal static class SkipWasmInterop { - [DllImport("wasi:io/streams@0.2.1", EntryPoint = "[method]input-stream.skip"), WasmImportLinkage] + [DllImport("wasi:io/streams@0.2.0", EntryPoint = "[method]input-stream.skip"), WasmImportLinkage] internal static extern void wasmImportSkip(int p0, long p1, nint p2); } @@ -237,35 +232,35 @@ internal unsafe ulong Skip(ulong len) var ptr = (nint)retAreaByte0; SkipWasmInterop.wasmImportSkip(handle, unchecked((long)(len)), ptr); - Result lifted6; + Result lifted6; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - lifted6 = Result.ok(unchecked((ulong)(BitConverter.ToInt64(new Span((void*)(ptr + 8), 8))))); + lifted6 = Result.ok(unchecked((ulong)(BitConverter.ToInt64(new Span((void*)(ptr + 8), 8))))); break; } case 1: { - global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError lifted; + global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError lifted; switch (new Span((void*)(ptr + 8), 1)[0]) { case 0: { - var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 12), 4)))); + var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 12), 4)))); - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.lastOperationFailed(resource); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.lastOperationFailed(resource); break; } case 1: { - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.closed(); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.closed(); break; } default: throw new ArgumentException($"invalid discriminant: {new Span((void*)(ptr + 8), 1)[0]}"); } - lifted6 = Result.err(lifted); + lifted6 = Result.err(lifted); break; } @@ -284,7 +279,7 @@ internal unsafe ulong Skip(ulong len) internal static class BlockingSkipWasmInterop { - [DllImport("wasi:io/streams@0.2.1", EntryPoint = "[method]input-stream.blocking-skip"), WasmImportLinkage] + [DllImport("wasi:io/streams@0.2.0", EntryPoint = "[method]input-stream.blocking-skip"), WasmImportLinkage] internal static extern void wasmImportBlockingSkip(int p0, long p1, nint p2); } @@ -299,35 +294,35 @@ internal unsafe ulong BlockingSkip(ulong len) var ptr = (nint)retAreaByte0; BlockingSkipWasmInterop.wasmImportBlockingSkip(handle, unchecked((long)(len)), ptr); - Result lifted6; + Result lifted6; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - lifted6 = Result.ok(unchecked((ulong)(BitConverter.ToInt64(new Span((void*)(ptr + 8), 8))))); + lifted6 = Result.ok(unchecked((ulong)(BitConverter.ToInt64(new Span((void*)(ptr + 8), 8))))); break; } case 1: { - global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError lifted; + global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError lifted; switch (new Span((void*)(ptr + 8), 1)[0]) { case 0: { - var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 12), 4)))); + var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 12), 4)))); - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.lastOperationFailed(resource); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.lastOperationFailed(resource); break; } case 1: { - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.closed(); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.closed(); break; } default: throw new ArgumentException($"invalid discriminant: {new Span((void*)(ptr + 8), 1)[0]}"); } - lifted6 = Result.err(lifted); + lifted6 = Result.err(lifted); break; } @@ -346,16 +341,16 @@ internal unsafe ulong BlockingSkip(ulong len) internal static class SubscribeWasmInterop { - [DllImport("wasi:io/streams@0.2.1", EntryPoint = "[method]input-stream.subscribe"), WasmImportLinkage] + [DllImport("wasi:io/streams@0.2.0", EntryPoint = "[method]input-stream.subscribe"), WasmImportLinkage] internal static extern int wasmImportSubscribe(int p0); } - internal unsafe global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IPoll.Pollable Subscribe() + internal unsafe global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable Subscribe() { var handle = this.Handle; var result = SubscribeWasmInterop.wasmImportSubscribe(handle); - var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IPoll.Pollable(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IPoll.Pollable.THandle(result)); + var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable.THandle(result)); return resource; //TODO: free alloc handle (interopString) if exists @@ -372,10 +367,6 @@ internal static class SubscribeWasmInterop * promptly, which could even be zero. To wait for the stream to be ready to * accept data, the `subscribe` function to obtain a `pollable` which can be * polled for using `wasi:io/poll`. - * - * Dropping an `output-stream` while there's still an active write in - * progress may result in the data being lost. Before dropping the stream, - * be sure to fully flush your writes. */ internal class OutputStream: IDisposable { @@ -389,26 +380,21 @@ internal OutputStream(THandle handle) { public void Dispose() { Dispose(true); - GC.SuppressFinalize(this); } - [DllImport("wasi:io/streams@0.2.1", EntryPoint = "[resource-drop]output-stream"), WasmImportLinkage] + [DllImport("wasi:io/streams@0.2.0", EntryPoint = "[resource-drop]output-stream"), WasmImportLinkage] private static extern void wasmImportResourceDrop(int p0); protected virtual void Dispose(bool disposing) { - if (Handle != 0) { + if (disposing && Handle != 0) { wasmImportResourceDrop(Handle); Handle = 0; } } - ~OutputStream() { - Dispose(false); - } - internal static class CheckWriteWasmInterop { - [DllImport("wasi:io/streams@0.2.1", EntryPoint = "[method]output-stream.check-write"), WasmImportLinkage] + [DllImport("wasi:io/streams@0.2.0", EntryPoint = "[method]output-stream.check-write"), WasmImportLinkage] internal static extern void wasmImportCheckWrite(int p0, nint p1); } @@ -423,35 +409,35 @@ internal unsafe ulong CheckWrite() var ptr = (nint)retAreaByte0; CheckWriteWasmInterop.wasmImportCheckWrite(handle, ptr); - Result lifted6; + Result lifted6; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - lifted6 = Result.ok(unchecked((ulong)(BitConverter.ToInt64(new Span((void*)(ptr + 8), 8))))); + lifted6 = Result.ok(unchecked((ulong)(BitConverter.ToInt64(new Span((void*)(ptr + 8), 8))))); break; } case 1: { - global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError lifted; + global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError lifted; switch (new Span((void*)(ptr + 8), 1)[0]) { case 0: { - var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 12), 4)))); + var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 12), 4)))); - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.lastOperationFailed(resource); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.lastOperationFailed(resource); break; } case 1: { - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.closed(); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.closed(); break; } default: throw new ArgumentException($"invalid discriminant: {new Span((void*)(ptr + 8), 1)[0]}"); } - lifted6 = Result.err(lifted); + lifted6 = Result.err(lifted); break; } @@ -470,7 +456,7 @@ internal unsafe ulong CheckWrite() internal static class WriteWasmInterop { - [DllImport("wasi:io/streams@0.2.1", EntryPoint = "[method]output-stream.write"), WasmImportLinkage] + [DllImport("wasi:io/streams@0.2.0", EntryPoint = "[method]output-stream.write"), WasmImportLinkage] internal static extern void wasmImportWrite(int p0, nint p1, int p2, nint p3); } @@ -488,35 +474,35 @@ internal unsafe void Write(byte[] contents) var ptr = (nint)retAreaByte0; WriteWasmInterop.wasmImportWrite(handle, (int)buffer, (contents).Length, ptr); - Result lifted6; + Result lifted6; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - lifted6 = Result.ok(new global::WasiHttpWorld.None()); + lifted6 = Result.ok(new global::WasiHttpWorld.None()); break; } case 1: { - global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError lifted; + global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError lifted; switch (new Span((void*)(ptr + 4), 1)[0]) { case 0: { - var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)))); + var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)))); - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.lastOperationFailed(resource); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.lastOperationFailed(resource); break; } case 1: { - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.closed(); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.closed(); break; } default: throw new ArgumentException($"invalid discriminant: {new Span((void*)(ptr + 4), 1)[0]}"); } - lifted6 = Result.err(lifted); + lifted6 = Result.err(lifted); break; } @@ -535,7 +521,7 @@ internal unsafe void Write(byte[] contents) internal static class BlockingWriteAndFlushWasmInterop { - [DllImport("wasi:io/streams@0.2.1", EntryPoint = "[method]output-stream.blocking-write-and-flush"), WasmImportLinkage] + [DllImport("wasi:io/streams@0.2.0", EntryPoint = "[method]output-stream.blocking-write-and-flush"), WasmImportLinkage] internal static extern void wasmImportBlockingWriteAndFlush(int p0, nint p1, int p2, nint p3); } @@ -553,35 +539,35 @@ internal unsafe void BlockingWriteAndFlush(byte[] contents) var ptr = (nint)retAreaByte0; BlockingWriteAndFlushWasmInterop.wasmImportBlockingWriteAndFlush(handle, (int)buffer, (contents).Length, ptr); - Result lifted6; + Result lifted6; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - lifted6 = Result.ok(new global::WasiHttpWorld.None()); + lifted6 = Result.ok(new global::WasiHttpWorld.None()); break; } case 1: { - global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError lifted; + global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError lifted; switch (new Span((void*)(ptr + 4), 1)[0]) { case 0: { - var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)))); + var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)))); - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.lastOperationFailed(resource); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.lastOperationFailed(resource); break; } case 1: { - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.closed(); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.closed(); break; } default: throw new ArgumentException($"invalid discriminant: {new Span((void*)(ptr + 4), 1)[0]}"); } - lifted6 = Result.err(lifted); + lifted6 = Result.err(lifted); break; } @@ -600,7 +586,7 @@ internal unsafe void BlockingWriteAndFlush(byte[] contents) internal static class FlushWasmInterop { - [DllImport("wasi:io/streams@0.2.1", EntryPoint = "[method]output-stream.flush"), WasmImportLinkage] + [DllImport("wasi:io/streams@0.2.0", EntryPoint = "[method]output-stream.flush"), WasmImportLinkage] internal static extern void wasmImportFlush(int p0, nint p1); } @@ -615,35 +601,35 @@ internal unsafe void Flush() var ptr = (nint)retAreaByte0; FlushWasmInterop.wasmImportFlush(handle, ptr); - Result lifted6; + Result lifted6; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - lifted6 = Result.ok(new global::WasiHttpWorld.None()); + lifted6 = Result.ok(new global::WasiHttpWorld.None()); break; } case 1: { - global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError lifted; + global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError lifted; switch (new Span((void*)(ptr + 4), 1)[0]) { case 0: { - var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)))); + var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)))); - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.lastOperationFailed(resource); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.lastOperationFailed(resource); break; } case 1: { - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.closed(); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.closed(); break; } default: throw new ArgumentException($"invalid discriminant: {new Span((void*)(ptr + 4), 1)[0]}"); } - lifted6 = Result.err(lifted); + lifted6 = Result.err(lifted); break; } @@ -662,7 +648,7 @@ internal unsafe void Flush() internal static class BlockingFlushWasmInterop { - [DllImport("wasi:io/streams@0.2.1", EntryPoint = "[method]output-stream.blocking-flush"), WasmImportLinkage] + [DllImport("wasi:io/streams@0.2.0", EntryPoint = "[method]output-stream.blocking-flush"), WasmImportLinkage] internal static extern void wasmImportBlockingFlush(int p0, nint p1); } @@ -677,35 +663,35 @@ internal unsafe void BlockingFlush() var ptr = (nint)retAreaByte0; BlockingFlushWasmInterop.wasmImportBlockingFlush(handle, ptr); - Result lifted6; + Result lifted6; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - lifted6 = Result.ok(new global::WasiHttpWorld.None()); + lifted6 = Result.ok(new global::WasiHttpWorld.None()); break; } case 1: { - global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError lifted; + global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError lifted; switch (new Span((void*)(ptr + 4), 1)[0]) { case 0: { - var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)))); + var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)))); - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.lastOperationFailed(resource); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.lastOperationFailed(resource); break; } case 1: { - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.closed(); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.closed(); break; } default: throw new ArgumentException($"invalid discriminant: {new Span((void*)(ptr + 4), 1)[0]}"); } - lifted6 = Result.err(lifted); + lifted6 = Result.err(lifted); break; } @@ -724,16 +710,16 @@ internal unsafe void BlockingFlush() internal static class SubscribeWasmInterop { - [DllImport("wasi:io/streams@0.2.1", EntryPoint = "[method]output-stream.subscribe"), WasmImportLinkage] + [DllImport("wasi:io/streams@0.2.0", EntryPoint = "[method]output-stream.subscribe"), WasmImportLinkage] internal static extern int wasmImportSubscribe(int p0); } - internal unsafe global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IPoll.Pollable Subscribe() + internal unsafe global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable Subscribe() { var handle = this.Handle; var result = SubscribeWasmInterop.wasmImportSubscribe(handle); - var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IPoll.Pollable(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IPoll.Pollable.THandle(result)); + var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable.THandle(result)); return resource; //TODO: free alloc handle (interopString) if exists @@ -741,7 +727,7 @@ internal static class SubscribeWasmInterop internal static class WriteZeroesWasmInterop { - [DllImport("wasi:io/streams@0.2.1", EntryPoint = "[method]output-stream.write-zeroes"), WasmImportLinkage] + [DllImport("wasi:io/streams@0.2.0", EntryPoint = "[method]output-stream.write-zeroes"), WasmImportLinkage] internal static extern void wasmImportWriteZeroes(int p0, long p1, nint p2); } @@ -756,35 +742,35 @@ internal unsafe void WriteZeroes(ulong len) var ptr = (nint)retAreaByte0; WriteZeroesWasmInterop.wasmImportWriteZeroes(handle, unchecked((long)(len)), ptr); - Result lifted6; + Result lifted6; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - lifted6 = Result.ok(new global::WasiHttpWorld.None()); + lifted6 = Result.ok(new global::WasiHttpWorld.None()); break; } case 1: { - global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError lifted; + global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError lifted; switch (new Span((void*)(ptr + 4), 1)[0]) { case 0: { - var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)))); + var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)))); - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.lastOperationFailed(resource); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.lastOperationFailed(resource); break; } case 1: { - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.closed(); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.closed(); break; } default: throw new ArgumentException($"invalid discriminant: {new Span((void*)(ptr + 4), 1)[0]}"); } - lifted6 = Result.err(lifted); + lifted6 = Result.err(lifted); break; } @@ -803,7 +789,7 @@ internal unsafe void WriteZeroes(ulong len) internal static class BlockingWriteZeroesAndFlushWasmInterop { - [DllImport("wasi:io/streams@0.2.1", EntryPoint = "[method]output-stream.blocking-write-zeroes-and-flush"), WasmImportLinkage] + [DllImport("wasi:io/streams@0.2.0", EntryPoint = "[method]output-stream.blocking-write-zeroes-and-flush"), WasmImportLinkage] internal static extern void wasmImportBlockingWriteZeroesAndFlush(int p0, long p1, nint p2); } @@ -818,35 +804,35 @@ internal unsafe void BlockingWriteZeroesAndFlush(ulong len) var ptr = (nint)retAreaByte0; BlockingWriteZeroesAndFlushWasmInterop.wasmImportBlockingWriteZeroesAndFlush(handle, unchecked((long)(len)), ptr); - Result lifted6; + Result lifted6; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - lifted6 = Result.ok(new global::WasiHttpWorld.None()); + lifted6 = Result.ok(new global::WasiHttpWorld.None()); break; } case 1: { - global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError lifted; + global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError lifted; switch (new Span((void*)(ptr + 4), 1)[0]) { case 0: { - var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)))); + var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 8), 4)))); - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.lastOperationFailed(resource); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.lastOperationFailed(resource); break; } case 1: { - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.closed(); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.closed(); break; } default: throw new ArgumentException($"invalid discriminant: {new Span((void*)(ptr + 4), 1)[0]}"); } - lifted6 = Result.err(lifted); + lifted6 = Result.err(lifted); break; } @@ -865,12 +851,12 @@ internal unsafe void BlockingWriteZeroesAndFlush(ulong len) internal static class SpliceWasmInterop { - [DllImport("wasi:io/streams@0.2.1", EntryPoint = "[method]output-stream.splice"), WasmImportLinkage] + [DllImport("wasi:io/streams@0.2.0", EntryPoint = "[method]output-stream.splice"), WasmImportLinkage] internal static extern void wasmImportSplice(int p0, int p1, long p2, nint p3); } - internal unsafe ulong Splice(global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.InputStream src, ulong len) + internal unsafe ulong Splice(global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.InputStream src, ulong len) { var handle = this.Handle; var handle0 = src.Handle; @@ -881,35 +867,35 @@ internal unsafe ulong Splice(global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1. var ptr = (nint)retAreaByte0; SpliceWasmInterop.wasmImportSplice(handle, handle0, unchecked((long)(len)), ptr); - Result lifted7; + Result lifted7; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - lifted7 = Result.ok(unchecked((ulong)(BitConverter.ToInt64(new Span((void*)(ptr + 8), 8))))); + lifted7 = Result.ok(unchecked((ulong)(BitConverter.ToInt64(new Span((void*)(ptr + 8), 8))))); break; } case 1: { - global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError lifted; + global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError lifted; switch (new Span((void*)(ptr + 8), 1)[0]) { case 0: { - var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 12), 4)))); + var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 12), 4)))); - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.lastOperationFailed(resource); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.lastOperationFailed(resource); break; } case 1: { - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.closed(); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.closed(); break; } default: throw new ArgumentException($"invalid discriminant: {new Span((void*)(ptr + 8), 1)[0]}"); } - lifted7 = Result.err(lifted); + lifted7 = Result.err(lifted); break; } @@ -928,12 +914,12 @@ internal unsafe ulong Splice(global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1. internal static class BlockingSpliceWasmInterop { - [DllImport("wasi:io/streams@0.2.1", EntryPoint = "[method]output-stream.blocking-splice"), WasmImportLinkage] + [DllImport("wasi:io/streams@0.2.0", EntryPoint = "[method]output-stream.blocking-splice"), WasmImportLinkage] internal static extern void wasmImportBlockingSplice(int p0, int p1, long p2, nint p3); } - internal unsafe ulong BlockingSplice(global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.InputStream src, ulong len) + internal unsafe ulong BlockingSplice(global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.InputStream src, ulong len) { var handle = this.Handle; var handle0 = src.Handle; @@ -944,35 +930,35 @@ internal unsafe ulong BlockingSplice(global::WasiHttpWorld.wit.imports.wasi.io var ptr = (nint)retAreaByte0; BlockingSpliceWasmInterop.wasmImportBlockingSplice(handle, handle0, unchecked((long)(len)), ptr); - Result lifted7; + Result lifted7; switch (new Span((void*)(ptr + 0), 1)[0]) { case 0: { - lifted7 = Result.ok(unchecked((ulong)(BitConverter.ToInt64(new Span((void*)(ptr + 8), 8))))); + lifted7 = Result.ok(unchecked((ulong)(BitConverter.ToInt64(new Span((void*)(ptr + 8), 8))))); break; } case 1: { - global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError lifted; + global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError lifted; switch (new Span((void*)(ptr + 8), 1)[0]) { case 0: { - var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 12), 4)))); + var resource = new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error(new global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IError.Error.THandle(BitConverter.ToInt32(new Span((void*)(ptr + 12), 4)))); - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.lastOperationFailed(resource); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.lastOperationFailed(resource); break; } case 1: { - lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_1.IStreams.StreamError.closed(); + lifted = global::WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams.StreamError.closed(); break; } default: throw new ArgumentException($"invalid discriminant: {new Span((void*)(ptr + 8), 1)[0]}"); } - lifted7 = Result.err(lifted); + lifted7 = Result.err(lifted); break; } diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_1.PollInterop.cs b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_0.PollInterop.cs similarity index 86% rename from src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_1.PollInterop.cs rename to src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_0.PollInterop.cs index 4c48ffe69e2..77b82700cf5 100644 --- a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_1.PollInterop.cs +++ b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_0.PollInterop.cs @@ -1,4 +1,4 @@ -// Generated by `wit-bindgen` 0.29.0. DO NOT EDIT! +// Generated by `wit-bindgen` 0.32.0. DO NOT EDIT! // #nullable enable @@ -11,18 +11,18 @@ using System.Diagnostics; using System.Diagnostics.CodeAnalysis; -namespace WasiHttpWorld.wit.imports.wasi.io.v0_2_1 +namespace WasiHttpWorld.wit.imports.wasi.io.v0_2_0 { internal static class PollInterop { internal static class PollWasmInterop { - [DllImport("wasi:io/poll@0.2.1", EntryPoint = "poll"), WasmImportLinkage] + [DllImport("wasi:io/poll@0.2.0", EntryPoint = "poll"), WasmImportLinkage] internal static extern void wasmImportPoll(nint p0, int p1, nint p2); } - internal static unsafe uint[] Poll(List @in) + internal static unsafe uint[] Poll(List @in) { byte[] buffer = new byte[4 * @in.Count]; @@ -30,7 +30,7 @@ internal static unsafe uint[] Poll(List((void*)(basePtr + 0), 4), unchecked((int)handle)); diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_1.StreamsInterop.cs b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_0.StreamsInterop.cs similarity index 76% rename from src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_1.StreamsInterop.cs rename to src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_0.StreamsInterop.cs index 7d479e6b160..cd31c05f1bb 100644 --- a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_1.StreamsInterop.cs +++ b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld.wit.imports.wasi.io.v0_2_0.StreamsInterop.cs @@ -1,4 +1,4 @@ -// Generated by `wit-bindgen` 0.29.0. DO NOT EDIT! +// Generated by `wit-bindgen` 0.32.0. DO NOT EDIT! // #nullable enable @@ -11,7 +11,7 @@ using System.Diagnostics; using System.Diagnostics.CodeAnalysis; -namespace WasiHttpWorld.wit.imports.wasi.io.v0_2_1 +namespace WasiHttpWorld.wit.imports.wasi.io.v0_2_0 { internal static class StreamsInterop { diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld_component_type.wit b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld_component_type.wit index a2a7c4fbf2f..b6c30d48519 100644 --- a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld_component_type.wit +++ b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiHttpWorld_component_type.wit @@ -1,10 +1,10 @@ -package wasi:http@0.2.1; +package wasi:http@0.2.0; interface types { - use wasi:clocks/monotonic-clock@0.2.1.{duration}; - use wasi:io/streams@0.2.1.{input-stream, output-stream}; - use wasi:io/error@0.2.1.{error as io-error}; - use wasi:io/poll@0.2.1.{pollable}; + use wasi:clocks/monotonic-clock@0.2.0.{duration}; + use wasi:io/streams@0.2.0.{input-stream, output-stream}; + use wasi:io/error@0.2.0.{error as io-error}; + use wasi:io/poll@0.2.0.{pollable}; variant method { get, @@ -191,14 +191,14 @@ interface outgoing-handler { } world wasi-http { - import wasi:io/poll@0.2.1; - import wasi:clocks/monotonic-clock@0.2.1; - import wasi:io/error@0.2.1; - import wasi:io/streams@0.2.1; + import wasi:io/poll@0.2.0; + import wasi:clocks/monotonic-clock@0.2.0; + import wasi:io/error@0.2.0; + import wasi:io/streams@0.2.0; import types; import outgoing-handler; } -package wasi:io@0.2.1 { +package wasi:io@0.2.0 { interface poll { resource pollable { ready: func() -> bool; @@ -245,9 +245,9 @@ package wasi:io@0.2.1 { } -package wasi:clocks@0.2.1 { +package wasi:clocks@0.2.0 { interface monotonic-clock { - use wasi:io/poll@0.2.1.{pollable}; + use wasi:io/poll@0.2.0.{pollable}; type instant = u64; diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiInputStream.cs b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiInputStream.cs new file mode 100644 index 00000000000..5738da0b8a8 --- /dev/null +++ b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiInputStream.cs @@ -0,0 +1,197 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.IO; +using System.Threading; +using System.Threading.Tasks; +using WasiHttpWorld; +using WasiHttpWorld.wit.imports.wasi.http.v0_2_0; +using WasiHttpWorld.wit.imports.wasi.io.v0_2_0; +using static WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes; +using static WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams; + +namespace System.Net.Http +{ + // on top of https://github.com/WebAssembly/wasi-io/blob/main/wit/streams.wit + internal sealed class WasiInputStream : Stream + { + private WasiRequestWrapper wrapper; // owned by this instance + private IncomingBody body; // owned by this instance + private InputStream stream; // owned by this instance + + private int offset; + private byte[]? buffer; + private bool otherSideClosed; + internal bool isClosed; + + public override bool CanRead => true; + public override bool CanWrite => false; + public override bool CanSeek => false; + + public WasiInputStream(WasiRequestWrapper wrapper, IncomingBody body) + { + this.wrapper = wrapper; + this.body = body; + this.stream = body.Stream(); + } + + ~WasiInputStream() + { + Dispose(false); + } + + public override void Close() + { + if (!isClosed) + { + isClosed = true; + stream.Dispose(); + var futureTrailers = IncomingBody.Finish(body); // we just passed body ownership to Finish + futureTrailers.Dispose(); + } + base.Close(); + } + + protected override void Dispose(bool disposing) + { + if (!isClosed) + { + isClosed = true; + stream.Dispose(); + body.Dispose(); + } + + if (disposing) + { + // this helps with disposing WIT resources at the Close() time of this stream, instead of waiting for the GC + wrapper.Dispose(); + } + + base.Dispose(disposing); + } + + public override async Task ReadAsync( + byte[] bytes, + int offset, + int length, + CancellationToken cancellationToken + ) + { + ObjectDisposedException.ThrowIf(isClosed, this); + cancellationToken.ThrowIfCancellationRequested(); + while (true) + { + if (otherSideClosed) + { + return 0; + } + else if (this.buffer == null) + { + try + { + // TODO: should we add a special case to the bindings generator + // to allow passing a buffer to InputStream.Read and + // avoid the extra copy? + var result = stream.Read(16 * 1024); + var buffer = result; + if (buffer.Length == 0) + { + cancellationToken.ThrowIfCancellationRequested(); + await WasiHttpInterop.RegisterWasiPollable(stream.Subscribe(), cancellationToken).ConfigureAwait(false); + ObjectDisposedException.ThrowIf(isClosed, this); + } + else + { + this.buffer = buffer; + this.offset = 0; + } + } + catch (WitException e) + { + if (((StreamError)e.Value).Tag == StreamError.CLOSED) + { + otherSideClosed = true; + return 0; + } + else + { + // TODO translate error ? + throw; + } + } + } + else + { + var min = Math.Min(this.buffer.Length - this.offset, length); + Array.Copy(this.buffer, this.offset, bytes, offset, min); + if (min < buffer.Length - this.offset) + { + this.offset += min; + } + else + { + this.buffer = null; + } + return min; + } + } + } + + public override async ValueTask ReadAsync( + Memory buffer, + CancellationToken cancellationToken = default + ) + { + // TODO: avoid copy when possible and use ArrayPool when not + var dst = new byte[buffer.Length]; + // We disable "CA1835: Prefer the memory-based overloads of + // ReadAsync/WriteAsync methods in stream-based classes" for + // now, since `ReadyAsync(byte[], int, int, CancellationToken)` + // is where the implementation currently resides, but we should + // revisit this if/when `wit-bindgen` learns to generate + // memory-based bindings. +#pragma warning disable CA1835 + var result = await ReadAsync(dst, 0, buffer.Length, cancellationToken) + .ConfigureAwait(false); +#pragma warning restore CA1835 + new ReadOnlySpan(dst, 0, result).CopyTo(buffer.Span); + return result; + } + + #region PlatformNotSupported + + public override void Flush() + { + // ignore + } + + public override void SetLength(long length) + { + throw new PlatformNotSupportedException(); + } + + public override int Read(byte[] buffer, int offset, int length) + { + throw new PlatformNotSupportedException(); + } + + public override long Seek(long offset, SeekOrigin origin) + { + throw new PlatformNotSupportedException(); + } + + public override void Write(byte[] buffer, int offset, int length) + { + throw new PlatformNotSupportedException(); + } + + public override long Length => throw new PlatformNotSupportedException(); + public override long Position + { + get => throw new PlatformNotSupportedException(); + set => throw new PlatformNotSupportedException(); + } + + #endregion + } +} diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiOutputStream.cs b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiOutputStream.cs new file mode 100644 index 00000000000..43452d5d323 --- /dev/null +++ b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/WasiOutputStream.cs @@ -0,0 +1,162 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.IO; +using System.Threading; +using System.Threading.Tasks; +using WasiHttpWorld; +using WasiHttpWorld.wit.imports.wasi.http.v0_2_0; +using WasiHttpWorld.wit.imports.wasi.io.v0_2_0; +using static WasiHttpWorld.wit.imports.wasi.http.v0_2_0.ITypes; +using static WasiHttpWorld.wit.imports.wasi.io.v0_2_0.IStreams; + +namespace System.Net.Http +{ + // on top of https://github.com/WebAssembly/wasi-io/blob/main/wit/streams.wit + internal sealed class WasiOutputStream : Stream + { + private OutputStream stream; // owned by this instance + private OutgoingBody body; // owned by this instance + internal bool isClosed; + + public override bool CanRead => false; + public override bool CanWrite => true; + public override bool CanSeek => false; + + public WasiOutputStream(OutgoingBody body) + { + this.body = body; + this.stream = body.Write(); + } + + ~WasiOutputStream() + { + Dispose(false); + } + + public override void Close() + { + if (!isClosed) + { + isClosed = true; + stream.Dispose(); + OutgoingBody.Finish(body, null); + } + base.Close(); + } + + protected override void Dispose(bool disposing) + { + if (!isClosed) + { + isClosed = true; + stream.Dispose(); + body.Dispose(); + } + base.Dispose(disposing); + } + + public override async Task WriteAsync( + byte[] bytes, + int offset, + int length, + CancellationToken cancellationToken + ) + { + ObjectDisposedException.ThrowIf(isClosed, this); + var limit = offset + length; + var flushing = false; + while (true) + { + var count = (int)stream.CheckWrite(); + if (count == 0) + { + await WasiHttpInterop.RegisterWasiPollable(stream.Subscribe(), cancellationToken).ConfigureAwait(false); + ObjectDisposedException.ThrowIf(isClosed, this); + } + else if (offset == limit) + { + if (flushing) + { + return; + } + else + { + stream.Flush(); + flushing = true; + } + } + else + { + var min = Math.Min(count, limit - offset); + if (offset == 0 && min == bytes.Length) + { + stream.Write(bytes); + } + else + { + // TODO: is there a more efficient option than copying here? + // Do we need to change the binding generator to accept + // e.g. `Span`s? + var copy = new byte[min]; + Array.Copy(bytes, offset, copy, 0, min); + stream.Write(copy); + } + offset += min; + } + } + } + + public override ValueTask WriteAsync( + ReadOnlyMemory buffer, + CancellationToken cancellationToken = default + ) + { + // TODO: avoid copy when possible and use ArrayPool when not + var copy = new byte[buffer.Length]; + buffer.Span.CopyTo(copy); + return new ValueTask(WriteAsync(copy, 0, buffer.Length, cancellationToken)); + } + + #region PlatformNotSupported + + public override void Flush() + { + // ignore + // + // Note that flushing a `wasi:io/streams/output-stream` is an + // asynchronous operation, so it's not clear how we would + // implement it here instead of taking care of it as part of + // `WriteAsync`. + } + + public override long Seek(long offset, SeekOrigin origin) + { + throw new PlatformNotSupportedException(); + } + + public override void SetLength(long length) + { + throw new PlatformNotSupportedException(); + } + + public override int Read(byte[] buffer, int offset, int length) + { + throw new PlatformNotSupportedException(); + } + + public override void Write(byte[] buffer, int offset, int length) + { + throw new PlatformNotSupportedException(); + } + + public override long Length => throw new PlatformNotSupportedException(); + public override long Position + { + get => throw new PlatformNotSupportedException(); + set => throw new PlatformNotSupportedException(); + } + + #endregion + } +} diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/generate-wasi-http-bindings.ps1 b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/generate-wasi-http-bindings.ps1 new file mode 100644 index 00000000000..507dd1ada5f --- /dev/null +++ b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/generate-wasi-http-bindings.ps1 @@ -0,0 +1,22 @@ +# Prerequisites: +# powershell +# tar +# [cargo](https://rustup.rs/) +$ProgressPreference = 'SilentlyContinue' +$ErrorActionPreference='Stop' +$scriptpath = $MyInvocation.MyCommand.Path +$dir = Split-Path $scriptpath + +Push-Location $dir + + +cargo install --locked --no-default-features --features csharp --version 0.32.0 wit-bindgen-cli +Invoke-WebRequest -Uri https://github.com/WebAssembly/wasi-http/archive/refs/tags/v0.2.0.tar.gz -OutFile v0.2.0.tar.gz +tar xzf v0.2.0.tar.gz +cp world.wit wasi-http-0.2.0/wit/world.wit +wit-bindgen c-sharp -w wasi-http -r native-aot --internal wasi-http-0.2.0/wit +rm -r wasi-http-0.2.0 +rm v0.2.0.tar.gz +rm WasiHttpWorld_wasm_import_linkage_attribute.cs + +Pop-Location diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/generate-wasi-http-bindings.sh b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/generate-wasi-http-bindings.sh index f4bc2b72ef7..037645181dc 100644 --- a/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/generate-wasi-http-bindings.sh +++ b/src/libraries/System.Net.Http/src/System/Net/Http/WasiHttpHandler/generate-wasi-http-bindings.sh @@ -11,13 +11,9 @@ set -ex # [cargo](https://rustup.rs/) # [curl](https://curl.se/download.html) -cargo install --locked --no-default-features --features csharp --version 0.29.0 wit-bindgen-cli -curl -OL https://github.com/WebAssembly/wasi-http/archive/refs/tags/v0.2.1.tar.gz -tar xzf v0.2.1.tar.gz -cat >wasi-http-0.2.1/wit/world.wit < true; diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/ResponseStreamZeroByteReadTests.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/ResponseStreamZeroByteReadTests.cs index 74ab2087a75..8fe520464e5 100644 --- a/src/libraries/System.Net.Http/tests/FunctionalTests/ResponseStreamZeroByteReadTests.cs +++ b/src/libraries/System.Net.Http/tests/FunctionalTests/ResponseStreamZeroByteReadTests.cs @@ -181,7 +181,6 @@ public Http2ResponseStreamZeroByteReadTest(ITestOutputHelper output) : base(outp protected override Version UseVersion => HttpVersion.Version20; } - [Collection(nameof(DisableParallelization))] [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsQuicSupported))] public sealed class Http3ResponseStreamZeroByteReadTest : ResponseStreamZeroByteReadTestBase { diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/SocketsHttpHandlerTest.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/SocketsHttpHandlerTest.cs index 3db324fc692..7a82f848e78 100644 --- a/src/libraries/System.Net.Http/tests/FunctionalTests/SocketsHttpHandlerTest.cs +++ b/src/libraries/System.Net.Http/tests/FunctionalTests/SocketsHttpHandlerTest.cs @@ -292,7 +292,6 @@ public SocketsHttpHandler_DiagnosticsTest_Http2(ITestOutputHelper output) : base protected override Version UseVersion => HttpVersion.Version20; } - [Collection(nameof(DisableParallelization))] [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsQuicSupported))] public sealed class SocketsHttpHandler_DiagnosticsTest_Http3 : DiagnosticsTest { @@ -1710,7 +1709,6 @@ public SocketsHttpHandler_HttpClientHandler_MaxResponseHeadersLength_Http2(ITest protected override Version UseVersion => HttpVersion.Version20; } - [Collection(nameof(DisableParallelization))] [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsQuicSupported))] public sealed class SocketsHttpHandler_HttpClientHandler_MaxResponseHeadersLength_Http3 : SocketsHttpHandler_HttpClientHandler_MaxResponseHeadersLength { @@ -4090,7 +4088,6 @@ public SocketsHttpHandler_HttpClientHandler_Cancellation_Test_Http2(ITestOutputH protected override Version UseVersion => HttpVersion.Version20; } - [Collection(nameof(DisableParallelization))] [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsQuicSupported))] public sealed class SocketsHttpHandlerTest_HttpClientHandlerTest_Http3 : HttpClientHandlerTest { @@ -4098,7 +4095,6 @@ public SocketsHttpHandlerTest_HttpClientHandlerTest_Http3(ITestOutputHelper outp protected override Version UseVersion => HttpVersion.Version30; } - [Collection(nameof(DisableParallelization))] [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsQuicSupported))] public sealed class SocketsHttpHandlerTest_Cookies_Http3 : HttpClientHandlerTest_Cookies { @@ -4106,7 +4102,6 @@ public SocketsHttpHandlerTest_Cookies_Http3(ITestOutputHelper output) : base(out protected override Version UseVersion => HttpVersion.Version30; } - [Collection(nameof(DisableParallelization))] [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsQuicSupported))] public sealed class SocketsHttpHandlerTest_HttpClientHandlerTest_Headers_Http3 : HttpClientHandlerTest_Headers { @@ -4114,7 +4109,6 @@ public SocketsHttpHandlerTest_HttpClientHandlerTest_Headers_Http3(ITestOutputHel protected override Version UseVersion => HttpVersion.Version30; } - [Collection(nameof(DisableParallelization))] [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsQuicSupported))] public sealed class SocketsHttpHandler_HttpClientHandler_Cancellation_Test_Http3 : SocketsHttpHandler_Cancellation_Test { @@ -4122,7 +4116,6 @@ public SocketsHttpHandler_HttpClientHandler_Cancellation_Test_Http3(ITestOutputH protected override Version UseVersion => HttpVersion.Version30; } - [Collection(nameof(DisableParallelization))] [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsQuicSupported))] public sealed class SocketsHttpHandler_HttpClientHandler_AltSvc_Test_Http3 : HttpClientHandler_AltSvc_Test { @@ -4130,7 +4123,6 @@ public SocketsHttpHandler_HttpClientHandler_AltSvc_Test_Http3(ITestOutputHelper protected override Version UseVersion => HttpVersion.Version30; } - [Collection(nameof(DisableParallelization))] [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsQuicSupported))] public sealed class SocketsHttpHandler_HttpClientHandler_Finalization_Http3 : HttpClientHandler_Finalization_Test { @@ -4288,7 +4280,6 @@ public SocketsHttpHandler_RequestContentLengthMismatchTest_Http2(ITestOutputHelp protected override Version UseVersion => HttpVersion.Version20; } - [Collection(nameof(DisableParallelization))] [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsQuicSupported))] public sealed class SocketsHttpHandler_RequestContentLengthMismatchTest_Http3 : SocketsHttpHandler_RequestContentLengthMismatchTest { @@ -4465,7 +4456,6 @@ public SocketsHttpHandler_SocketsHttpHandler_SecurityTest_Http2(ITestOutputHelpe protected override Version UseVersion => HttpVersion.Version20; } - [Collection(nameof(DisableParallelization))] [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsQuicSupported))] public sealed class SocketsHttpHandler_SocketsHttpHandler_SecurityTest_Http3 : SocketsHttpHandler_SecurityTest { @@ -4594,7 +4584,6 @@ await Http11LoopbackServerFactory.Singleton.CreateClientAndServerAsync(async uri } } - [Collection(nameof(DisableParallelization))] [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsQuicSupported))] public sealed class SocketsHttpHandler_HttpRequestErrorTest_Http30 : SocketsHttpHandler_HttpRequestErrorTest { diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/System.Net.Http.Functional.Tests.csproj b/src/libraries/System.Net.Http/tests/FunctionalTests/System.Net.Http.Functional.Tests.csproj index 7ca899166bc..b14c7411169 100644 --- a/src/libraries/System.Net.Http/tests/FunctionalTests/System.Net.Http.Functional.Tests.csproj +++ b/src/libraries/System.Net.Http/tests/FunctionalTests/System.Net.Http.Functional.Tests.csproj @@ -9,7 +9,6 @@ $(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-linux;$(NetCoreAppCurrent)-android;$(NetCoreAppCurrent)-browser;$(NetCoreAppCurrent)-wasi;$(NetCoreAppCurrent)-osx true true - $(NoWarn);SYSLIB0057 @@ -33,6 +32,7 @@ WasmTestOnWasmtime $(DefineConstants);TARGET_WASI + true @@ -331,11 +331,9 @@ + - - - diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/TelemetryTest.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/TelemetryTest.cs index e5e1889b051..d709501455e 100644 --- a/src/libraries/System.Net.Http/tests/FunctionalTests/TelemetryTest.cs +++ b/src/libraries/System.Net.Http/tests/FunctionalTests/TelemetryTest.cs @@ -81,6 +81,8 @@ await RemoteExecutor.Invoke(static async (useVersionString, testMethod) => using var listener = new TestEventListener("System.Net.Http", EventLevel.Verbose, eventCounterInterval: 0.1d); listener.AddActivityTracking(); + await PrepareEventCountersAsync(listener); + bool buffersResponse = false; var events = new ConcurrentQueue<(EventWrittenEventArgs Event, Guid ActivityId)>(); Uri expectedUri = null; @@ -222,6 +224,8 @@ await RemoteExecutor.Invoke(static async (useVersionString, testMethod) => using var listener = new TestEventListener("System.Net.Http", EventLevel.Verbose, eventCounterInterval: 0.1d); listener.AddActivityTracking(); + await PrepareEventCountersAsync(listener); + var events = new ConcurrentQueue<(EventWrittenEventArgs Event, Guid ActivityId)>(); Uri expectedUri = null; await listener.RunWithCallbackAsync(e => events.Enqueue((e, e.ActivityId)), async () => @@ -335,6 +339,8 @@ await RemoteExecutor.Invoke(static async (useVersionString, testMethod) => using var listener = new TestEventListener("System.Net.Http", EventLevel.Verbose, eventCounterInterval: 0.1d); listener.AddActivityTracking(); + await PrepareEventCountersAsync(listener); + var events = new ConcurrentQueue<(EventWrittenEventArgs Event, Guid ActivityId)>(); Uri expectedUri = null; await listener.RunWithCallbackAsync(e => events.Enqueue((e, e.ActivityId)), async () => @@ -436,6 +442,8 @@ await RemoteExecutor.Invoke(static async (useVersionString, uriTail, expectedPat using var listener = new TestEventListener("System.Net.Http", EventLevel.Verbose, eventCounterInterval: 0.1d); listener.AddActivityTracking(); + await PrepareEventCountersAsync(listener); + var events = new ConcurrentQueue<(EventWrittenEventArgs Event, Guid ActivityId)>(); Uri expectedUri = null; await listener.RunWithCallbackAsync(e => events.Enqueue((e, e.ActivityId)), async () => @@ -540,7 +548,7 @@ private static void ValidateStartFailedStopEvents(ConcurrentQueue<(EventWrittenE } } - // The validation assumes that the connection id's are in range 0..(connectionCount-1) + // The validation assumes that the connection id's are in range 1..connectionCount protected static void ValidateConnectionEstablishedClosed(ConcurrentQueue<(EventWrittenEventArgs Event, Guid ActivityId)> events, Version version, Uri uri, int connectionCount = 1) { EventWrittenEventArgs[] connectionsEstablished = events.Select(e => e.Event).Where(e => e.EventName == "ConnectionEstablished").ToArray(); @@ -564,7 +572,7 @@ protected static void ValidateConnectionEstablishedClosed(ConcurrentQueue<(Event ip.Equals(IPAddress.Loopback) || ip.Equals(IPAddress.IPv6Loopback)); } - Assert.True(connectionIds.SetEquals(Enumerable.Range(0, connectionCount).Select(i => (long)i)), "ConnectionEstablished has logged an unexpected connectionId."); + Assert.True(connectionIds.SetEquals(Enumerable.Range(1, connectionCount).Select(i => (long)i)), "ConnectionEstablished has logged an unexpected connectionId."); EventWrittenEventArgs[] connectionsClosed = events.Select(e => e.Event).Where(e => e.EventName == "ConnectionClosed").ToArray(); Assert.Equal(connectionCount, connectionsClosed.Length); @@ -580,7 +588,7 @@ protected static void ValidateConnectionEstablishedClosed(ConcurrentQueue<(Event Assert.Empty(connectionIds); } - private static void ValidateRequestResponseStartStopEvents(ConcurrentQueue<(EventWrittenEventArgs Event, Guid ActivityId)> events, int? requestContentLength, int? responseContentLength, int count, long connectionId = 0) + private static void ValidateRequestResponseStartStopEvents(ConcurrentQueue<(EventWrittenEventArgs Event, Guid ActivityId)> events, int? requestContentLength, int? responseContentLength, int count) { (EventWrittenEventArgs Event, Guid ActivityId)[] requestHeadersStarts = events.Where(e => e.Event.EventName == "RequestHeadersStart").ToArray(); Assert.Equal(count, requestHeadersStarts.Length); @@ -589,7 +597,8 @@ private static void ValidateRequestResponseStartStopEvents(ConcurrentQueue<(Even EventWrittenEventArgs e = r.Event; Assert.Equal(1, e.Payload.Count); Assert.Equal("connectionId", e.PayloadNames.Single()); - Assert.Equal(connectionId, (long)e.Payload[0]); + // 1 instead of 0 to account for the request we made in PrepareEventCountersAsync. + Assert.Equal(1, (long)e.Payload[0]); }); (EventWrittenEventArgs Event, Guid ActivityId)[] requestHeadersStops = events.Where(e => e.Event.EventName == "RequestHeadersStop").ToArray(); @@ -652,6 +661,9 @@ private static void ValidateSameActivityIds((EventWrittenEventArgs Event, Guid A private static void ValidateEventCounters(ConcurrentQueue<(EventWrittenEventArgs Event, Guid ActivityId)> events, int requestCount, bool shouldHaveFailures, int versionMajor, bool requestLeftQueue = false) { + // Account for the request we made in PrepareEventCountersAsync. + requestCount++; + Dictionary eventCounters = events .Select(e => e.Event) .Where(e => e.EventName == "EventCounters") @@ -758,6 +770,8 @@ await RemoteExecutor.Invoke(static async (useVersionString) => using var listener = new TestEventListener("System.Net.Http", EventLevel.Verbose, eventCounterInterval: 0.1d); listener.AddActivityTracking(); + await PrepareEventCountersAsync(listener); + var events = new ConcurrentQueue<(EventWrittenEventArgs Event, Guid ActivityId)>(); Uri expectedUri = null; await listener.RunWithCallbackAsync(e => events.Enqueue((e, e.ActivityId)), async () => @@ -871,6 +885,9 @@ await RemoteExecutor.Invoke(static async (string useVersionString) => Version version = Version.Parse(useVersionString); using var listener = new TestEventListener("System.Net.Http", EventLevel.Verbose, eventCounterInterval: 0.1d); + + await PrepareEventCountersAsync(listener); + listener.AddActivityTracking(); var events = new ConcurrentQueue<(EventWrittenEventArgs Event, Guid ActivityId)>(); Uri expectedUri = null; @@ -932,6 +949,9 @@ await RemoteExecutor.Invoke(static async (useVersionString, uriTail, expectedUri using var listener = new TestEventListener("System.Net.Http", EventLevel.Verbose, eventCounterInterval: 0.1d); listener.AddActivityTracking(); + + await PrepareEventCountersAsync(listener); + var events = new ConcurrentQueue<(EventWrittenEventArgs Event, Guid ActivityId)>(); Uri expectedUri = null; @@ -986,6 +1006,9 @@ public void EventSource_Proxy_LogsIPAddress(bool useSsl) { using var listener = new TestEventListener("System.Net.Http", EventLevel.Verbose, eventCounterInterval: 0.1d); listener.AddActivityTracking(); + + await PrepareEventCountersAsync(listener); + var events = new ConcurrentQueue<(EventWrittenEventArgs Event, Guid ActivityId)>(); await listener.RunWithCallbackAsync(e => events.Enqueue((e, e.ActivityId)), async () => @@ -1040,6 +1063,30 @@ static bool IsRequestsStartedEventCounter(EventWrittenEventArgs e) return (string)dictionary["Name"] == "requests-started"; } } + + internal static async Task PrepareEventCountersAsync(TestEventListener listener) + { + // There is a race condition in EventSource where counters using IncrementingPollingCounter + // will drop increments that happened before the background timer thread first runs. + // See https://github.com/dotnet/runtime/issues/106268#issuecomment-2284626183. + // To workaround this issue, we ensure that the EventCounters timer is running before + // executing any of the interesting logic under test. + + var events = new ConcurrentQueue<(EventWrittenEventArgs Event, Guid ActivityId)>(); + + await listener.RunWithCallbackAsync(e => events.Enqueue((e, e.ActivityId)), async () => + { + await LoopbackServer.CreateClientAndServerAsync( + async uri => + { + using var client = new HttpClient(); + await client.GetStringAsync(uri); + }, + server => server.HandleRequestAsync()); + + await WaitForEventCountersAsync(events); + }); + } } public sealed class TelemetryTest_Http11 : TelemetryTest @@ -1057,6 +1104,8 @@ await RemoteExecutor.Invoke(async () => using var listener = new TestEventListener("System.Net.Http", EventLevel.Verbose, eventCounterInterval: 0.1d); listener.AddActivityTracking(); + await PrepareEventCountersAsync(listener); + var events = new ConcurrentQueue<(EventWrittenEventArgs Event, Guid ActivityId)>(); Uri expectedUri = null; await listener.RunWithCallbackAsync(e => events.Enqueue((e, e.ActivityId)), async () => @@ -1107,7 +1156,7 @@ async Task HandleConnectionAsync(GenericLoopbackConnection connection) EventWrittenEventArgs[] requestHeadersStart = events.Select(e => e.Event).Where(e => e.EventName == "RequestHeadersStart").ToArray(); Assert.Equal(NumParallelRequests, requestHeadersStart.Length); - HashSet connectionIds = new(Enumerable.Range(0, NumParallelRequests).Select(i => (long)i)); + HashSet connectionIds = new(Enumerable.Range(1, NumParallelRequests).Select(i => (long)i)); foreach (EventWrittenEventArgs e in requestHeadersStart) { long connectionId = (long)e.Payload.Single(); @@ -1125,7 +1174,6 @@ public sealed class TelemetryTest_Http20 : TelemetryTest public TelemetryTest_Http20(ITestOutputHelper output) : base(output) { } } - [Collection(nameof(DisableParallelization))] [ConditionalClass(typeof(HttpClientHandlerTestBase), nameof(IsQuicSupported))] public sealed class TelemetryTest_Http30 : TelemetryTest { diff --git a/src/libraries/System.Net.Http/tests/StressTests/HttpStress/run-docker-compose.ps1 b/src/libraries/System.Net.Http/tests/StressTests/HttpStress/run-docker-compose.ps1 index 2b16072e2e6..67e28756d9d 100755 --- a/src/libraries/System.Net.Http/tests/StressTests/HttpStress/run-docker-compose.ps1 +++ b/src/libraries/System.Net.Http/tests/StressTests/HttpStress/run-docker-compose.ps1 @@ -16,6 +16,14 @@ Param( $REPO_ROOT_DIR = $(git -C "$PSScriptRoot" rev-parse --show-toplevel) $COMPOSE_FILE = "$PSScriptRoot/docker-compose.yml" +# This is a workaround for an issue with 1es-windows-2022-open, which should be eventually removed. +# See comments in /eng/pipelines/libraries/stress/ssl.yml for more info. +$dockerComposeCmd = $env:DOCKER_COMPOSE_CMD +if (!(Test-Path $dockerComposeCmd)) +{ + $dockerComposeCmd = "docker-compose" +} + # Build runtime libraries and place in a docker image if ($buildCurrentLibraries) @@ -60,7 +68,7 @@ if ($useWindowsContainers) $originalErrorPreference = $ErrorActionPreference $ErrorActionPreference = 'Continue' try { - docker-compose --log-level DEBUG --file "$COMPOSE_FILE" build $BUILD_ARGS.Split() 2>&1 | ForEach-Object { "$_" } + & $dockerComposeCmd --log-level DEBUG --file "$COMPOSE_FILE" build $BUILD_ARGS.Split() 2>&1 | ForEach-Object { "$_" } if ($LASTEXITCODE -ne 0) { throw "docker-compose exited with error code $LASTEXITCODE" } @@ -89,5 +97,5 @@ if (!$buildOnly) $env:HTTPSTRESS_CLIENT_ARGS = $clientStressArgs $env:HTTPSTRESS_SERVER_ARGS = $serverStressArgs - docker-compose --file "$COMPOSE_FILE" up --abort-on-container-exit + & $dockerComposeCmd --file "$COMPOSE_FILE" up --abort-on-container-exit } diff --git a/src/libraries/System.Net.HttpListener/Directory.Build.props b/src/libraries/System.Net.HttpListener/Directory.Build.props index c843a6347ce..3a3d8f98324 100644 --- a/src/libraries/System.Net.HttpListener/Directory.Build.props +++ b/src/libraries/System.Net.HttpListener/Directory.Build.props @@ -2,6 +2,6 @@ true - browser + browser;wasi \ No newline at end of file diff --git a/src/libraries/System.Net.HttpListener/System.Net.HttpListener.sln b/src/libraries/System.Net.HttpListener/System.Net.HttpListener.sln index 379e66746af..fd9d7c3bf0f 100644 --- a/src/libraries/System.Net.HttpListener/System.Net.HttpListener.sln +++ b/src/libraries/System.Net.HttpListener/System.Net.HttpListener.sln @@ -35,6 +35,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ObjectModel", "..\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{E334C95C-CF2A-4E1A-BD1F-1C61A87CD703}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{3E15F1D6-3B7F-4476-9762-8A2FA08FB193}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{48A9D75A-BB0F-425F-A1B0-25741CB85E57}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{154F91AC-8E70-49E6-9C97-0DDBD50AFB56}" @@ -153,6 +155,10 @@ Global {E334C95C-CF2A-4E1A-BD1F-1C61A87CD703}.Debug|Any CPU.Build.0 = Debug|Any CPU {E334C95C-CF2A-4E1A-BD1F-1C61A87CD703}.Release|Any CPU.ActiveCfg = Release|Any CPU {E334C95C-CF2A-4E1A-BD1F-1C61A87CD703}.Release|Any CPU.Build.0 = Release|Any CPU + {3E15F1D6-3B7F-4476-9762-8A2FA08FB193}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {3E15F1D6-3B7F-4476-9762-8A2FA08FB193}.Debug|Any CPU.Build.0 = Debug|Any CPU + {3E15F1D6-3B7F-4476-9762-8A2FA08FB193}.Release|Any CPU.ActiveCfg = Release|Any CPU + {3E15F1D6-3B7F-4476-9762-8A2FA08FB193}.Release|Any CPU.Build.0 = Release|Any CPU {48A9D75A-BB0F-425F-A1B0-25741CB85E57}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {48A9D75A-BB0F-425F-A1B0-25741CB85E57}.Debug|Any CPU.Build.0 = Debug|Any CPU {48A9D75A-BB0F-425F-A1B0-25741CB85E57}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -229,6 +235,7 @@ Global {15D0602C-AE8A-4B74-AD03-884A04F438E5} = {A3A29B10-F45E-487B-A2A0-EA809B62AF9D} {706D27A6-E66A-4FF5-9E6A-EA1B8BC52FB2} = {633A5486-7617-411C-B724-172F4B4E3A4F} {E334C95C-CF2A-4E1A-BD1F-1C61A87CD703} = {D79781B1-8197-4641-9DE7-B9F22C71FBB9} + {3E15F1D6-3B7F-4476-9762-8A2FA08FB193} = {D79781B1-8197-4641-9DE7-B9F22C71FBB9} {48A9D75A-BB0F-425F-A1B0-25741CB85E57} = {D79781B1-8197-4641-9DE7-B9F22C71FBB9} {154F91AC-8E70-49E6-9C97-0DDBD50AFB56} = {D79781B1-8197-4641-9DE7-B9F22C71FBB9} {77A46CB6-B34E-4862-91A2-D03974CD99AA} = {F6945715-9534-4427-9DA8-83AE756B16A0} diff --git a/src/libraries/System.Net.Mail/Directory.Build.props b/src/libraries/System.Net.Mail/Directory.Build.props index 43dc3a2640b..129690e06bc 100644 --- a/src/libraries/System.Net.Mail/Directory.Build.props +++ b/src/libraries/System.Net.Mail/Directory.Build.props @@ -2,5 +2,7 @@ true + + wasi diff --git a/src/libraries/System.Net.Mail/System.Net.Mail.sln b/src/libraries/System.Net.Mail/System.Net.Mail.sln index 9d9f22adecf..7aa163ed4d7 100644 --- a/src/libraries/System.Net.Mail/System.Net.Mail.sln +++ b/src/libraries/System.Net.Mail/System.Net.Mail.sln @@ -39,6 +39,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ObjectModel", "..\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{628EF453-C5BA-437B-9467-A037E19C945E}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{0CEC2F4E-BCF4-4497-8F80-B82A5F21C2B7}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{34D84D8A-9D29-4ED5-B46D-A772E521E2CF}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{301EA337-1D9A-47EF-966B-0ED0568C569A}" @@ -171,6 +173,10 @@ Global {628EF453-C5BA-437B-9467-A037E19C945E}.Debug|Any CPU.Build.0 = Debug|Any CPU {628EF453-C5BA-437B-9467-A037E19C945E}.Release|Any CPU.ActiveCfg = Release|Any CPU {628EF453-C5BA-437B-9467-A037E19C945E}.Release|Any CPU.Build.0 = Release|Any CPU + {0CEC2F4E-BCF4-4497-8F80-B82A5F21C2B7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {0CEC2F4E-BCF4-4497-8F80-B82A5F21C2B7}.Debug|Any CPU.Build.0 = Debug|Any CPU + {0CEC2F4E-BCF4-4497-8F80-B82A5F21C2B7}.Release|Any CPU.ActiveCfg = Release|Any CPU + {0CEC2F4E-BCF4-4497-8F80-B82A5F21C2B7}.Release|Any CPU.Build.0 = Release|Any CPU {34D84D8A-9D29-4ED5-B46D-A772E521E2CF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {34D84D8A-9D29-4ED5-B46D-A772E521E2CF}.Debug|Any CPU.Build.0 = Debug|Any CPU {34D84D8A-9D29-4ED5-B46D-A772E521E2CF}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -264,6 +270,7 @@ Global {AF805BBD-C4A4-4D69-A911-D651E008C655} = {04FF7F43-59FD-4A9A-AFE4-12D16836981C} {8AE1AF68-EBDC-497B-A189-5B4C66FA57D8} = {04FF7F43-59FD-4A9A-AFE4-12D16836981C} {628EF453-C5BA-437B-9467-A037E19C945E} = {461D78A2-743F-40F0-B301-274F2687D84F} + {0CEC2F4E-BCF4-4497-8F80-B82A5F21C2B7} = {461D78A2-743F-40F0-B301-274F2687D84F} {34D84D8A-9D29-4ED5-B46D-A772E521E2CF} = {461D78A2-743F-40F0-B301-274F2687D84F} {301EA337-1D9A-47EF-966B-0ED0568C569A} = {461D78A2-743F-40F0-B301-274F2687D84F} {09BD8BD6-3778-4891-B739-4B04C280E62D} = {514636E4-391A-44B6-85BF-1D3BF7D2D129} diff --git a/src/libraries/System.Net.Mail/src/System.Net.Mail.csproj b/src/libraries/System.Net.Mail/src/System.Net.Mail.csproj index db37efc40b0..f79d691669c 100644 --- a/src/libraries/System.Net.Mail/src/System.Net.Mail.csproj +++ b/src/libraries/System.Net.Mail/src/System.Net.Mail.csproj @@ -1,7 +1,7 @@  - $(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-unix;$(NetCoreAppCurrent)-browser;$(NetCoreAppCurrent) + $(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-unix;$(NetCoreAppCurrent)-browser;$(NetCoreAppCurrent)-wasi;$(NetCoreAppCurrent) true false @@ -84,12 +84,12 @@ Link="Common\System\Obsoletions.cs" /> - - + + - + @@ -110,8 +110,6 @@ Link="Common\System\Net\DebugSafeHandleZeroOrMinusOneIsInvalid.cs" /> - true - $(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-unix;$(NetCoreAppCurrent)-browser;$(NetCoreAppCurrent)-osx;$(NetCoreAppCurrent)-ios;$(NetCoreAppCurrent)-android + $(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-unix;$(NetCoreAppCurrent)-browser;$(NetCoreAppCurrent)-wasi;$(NetCoreAppCurrent)-osx;$(NetCoreAppCurrent)-ios;$(NetCoreAppCurrent)-android true true true diff --git a/src/libraries/System.Net.Mail/tests/Unit/System.Net.Mail.Unit.Tests.csproj b/src/libraries/System.Net.Mail/tests/Unit/System.Net.Mail.Unit.Tests.csproj index f5e3e0f1eb4..888f2e47541 100644 --- a/src/libraries/System.Net.Mail/tests/Unit/System.Net.Mail.Unit.Tests.csproj +++ b/src/libraries/System.Net.Mail/tests/Unit/System.Net.Mail.Unit.Tests.csproj @@ -112,8 +112,6 @@ Link="ProductionCode\BufferBuilder.cs" /> - - + diff --git a/src/libraries/System.Net.NameResolution/System.Net.NameResolution.sln b/src/libraries/System.Net.NameResolution/System.Net.NameResolution.sln index e41d2d150b0..854bfc11ece 100644 --- a/src/libraries/System.Net.NameResolution/System.Net.NameResolution.sln +++ b/src/libraries/System.Net.NameResolution/System.Net.NameResolution.sln @@ -17,6 +17,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Net.Primitives", ".. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{3AE9C5DE-A09B-401F-B6B6-790854166871}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{181F6817-655A-434D-B656-8E807BE25CD1}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{FC0BD396-0280-434B-913B-A17D87892A78}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{A8357213-6A4D-463F-8364-70ED86147098}" @@ -93,6 +95,10 @@ Global {3AE9C5DE-A09B-401F-B6B6-790854166871}.Debug|Any CPU.Build.0 = Debug|Any CPU {3AE9C5DE-A09B-401F-B6B6-790854166871}.Release|Any CPU.ActiveCfg = Release|Any CPU {3AE9C5DE-A09B-401F-B6B6-790854166871}.Release|Any CPU.Build.0 = Release|Any CPU + {181F6817-655A-434D-B656-8E807BE25CD1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {181F6817-655A-434D-B656-8E807BE25CD1}.Debug|Any CPU.Build.0 = Debug|Any CPU + {181F6817-655A-434D-B656-8E807BE25CD1}.Release|Any CPU.ActiveCfg = Release|Any CPU + {181F6817-655A-434D-B656-8E807BE25CD1}.Release|Any CPU.Build.0 = Release|Any CPU {FC0BD396-0280-434B-913B-A17D87892A78}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {FC0BD396-0280-434B-913B-A17D87892A78}.Debug|Any CPU.Build.0 = Debug|Any CPU {FC0BD396-0280-434B-913B-A17D87892A78}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -145,6 +151,7 @@ Global {149A3A68-0124-42FF-BB87-EBEC6D035251} = {47DBE178-9476-4595-9C71-424D54314C2E} {CC5371F7-FCD9-4BDE-8639-6DD5F3B71175} = {3DDE175F-17B6-4F30-8AA6-04C0AEBF39D5} {3AE9C5DE-A09B-401F-B6B6-790854166871} = {851CDB4C-B092-466E-93BA-D554120B182B} + {181F6817-655A-434D-B656-8E807BE25CD1} = {851CDB4C-B092-466E-93BA-D554120B182B} {FC0BD396-0280-434B-913B-A17D87892A78} = {851CDB4C-B092-466E-93BA-D554120B182B} {A8357213-6A4D-463F-8364-70ED86147098} = {851CDB4C-B092-466E-93BA-D554120B182B} {85113E09-04F4-436C-BF0E-F49BAD412DF6} = {2B391C1C-2A28-4B3C-9441-724C5CE77C8D} diff --git a/src/libraries/System.Net.NameResolution/src/System.Net.NameResolution.csproj b/src/libraries/System.Net.NameResolution/src/System.Net.NameResolution.csproj index 5d97e2d711f..582fe6cc882 100644 --- a/src/libraries/System.Net.NameResolution/src/System.Net.NameResolution.csproj +++ b/src/libraries/System.Net.NameResolution/src/System.Net.NameResolution.csproj @@ -1,7 +1,7 @@ - $(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-unix;$(NetCoreAppCurrent)-browser;$(NetCoreAppCurrent) + $(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-unix;$(NetCoreAppCurrent)-browser;$(NetCoreAppCurrent)-wasi;$(NetCoreAppCurrent) true false @@ -16,7 +16,7 @@ - + @@ -80,6 +80,8 @@ Link="Common\Interop\CoreLib\Unix\Interop.Errors.cs" /> + + + + + + + + + + + + + + + + + + + diff --git a/src/libraries/System.Net.NameResolution/src/System/Net/Dns.cs b/src/libraries/System.Net.NameResolution/src/System/Net/Dns.cs index c8a526ccc4b..5bedc17d253 100644 --- a/src/libraries/System.Net.NameResolution/src/System/Net/Dns.cs +++ b/src/libraries/System.Net.NameResolution/src/System/Net/Dns.cs @@ -7,6 +7,7 @@ using System.Net.Sockets; using System.Threading; using System.Threading.Tasks; +using System.Runtime.Versioning; namespace System.Net { @@ -37,6 +38,8 @@ public static string GetHostName() public static IPHostEntry GetHostEntry(IPAddress address) { + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 + ArgumentNullException.ThrowIfNull(address); if (address.Equals(IPAddress.Any) || address.Equals(IPAddress.IPv6Any)) @@ -68,7 +71,7 @@ public static IPHostEntry GetHostEntry(string hostNameOrAddress, AddressFamily f // See if it's an IP Address. IPHostEntry ipHostEntry; - if (IPAddress.TryParse(hostNameOrAddress, out IPAddress? address)) + if (NameResolutionPal.SupportsGetNameInfo && IPAddress.TryParse(hostNameOrAddress, out IPAddress? address)) { if (address.Equals(IPAddress.Any) || address.Equals(IPAddress.IPv6Any)) { @@ -147,6 +150,8 @@ public static Task GetHostEntryAsync(string hostNameOrAddress, Addr public static Task GetHostEntryAsync(IPAddress address) { + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 + ArgumentNullException.ThrowIfNull(address); if (address.Equals(IPAddress.Any) || address.Equals(IPAddress.IPv6Any)) @@ -156,6 +161,8 @@ public static Task GetHostEntryAsync(IPAddress address) } return RunAsync(static (s, activity) => { + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 + IPHostEntry ipHostEntry = GetHostEntryCore((IPAddress)s, AddressFamily.Unspecified, activity); if (NetEventSource.Log.IsEnabled()) NetEventSource.Info((IPAddress)s, $"{ipHostEntry} with {ipHostEntry.AddressList.Length} entries"); return ipHostEntry; @@ -170,6 +177,8 @@ public static IAsyncResult BeginGetHostEntry(string hostNameOrAddress, AsyncCall public static IPHostEntry EndGetHostEntry(IAsyncResult asyncResult) { + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 + ArgumentNullException.ThrowIfNull(asyncResult); return TaskToAsyncResult.End(asyncResult); @@ -244,6 +253,8 @@ public static IAsyncResult BeginGetHostAddresses(string hostNameOrAddress, Async public static IPAddress[] EndGetHostAddresses(IAsyncResult asyncResult) { + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 + ArgumentNullException.ThrowIfNull(asyncResult); return TaskToAsyncResult.End(asyncResult); @@ -269,6 +280,8 @@ public static IAsyncResult BeginGetHostByName(string hostName, AsyncCallback? re [Obsolete("EndGetHostByName has been deprecated. Use EndGetHostEntry instead.")] public static IPHostEntry EndGetHostByName(IAsyncResult asyncResult) { + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 + ArgumentNullException.ThrowIfNull(asyncResult); return TaskToAsyncResult.End(asyncResult); @@ -277,6 +290,8 @@ public static IPHostEntry EndGetHostByName(IAsyncResult asyncResult) [Obsolete("GetHostByAddress has been deprecated. Use GetHostEntry instead.")] public static IPHostEntry GetHostByAddress(string address) { + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 + ArgumentNullException.ThrowIfNull(address); IPHostEntry ipHostEntry = GetHostEntryCore(IPAddress.Parse(address), AddressFamily.Unspecified); @@ -288,6 +303,8 @@ public static IPHostEntry GetHostByAddress(string address) [Obsolete("GetHostByAddress has been deprecated. Use GetHostEntry instead.")] public static IPHostEntry GetHostByAddress(IPAddress address) { + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 + ArgumentNullException.ThrowIfNull(address); IPHostEntry ipHostEntry = GetHostEntryCore(address, AddressFamily.Unspecified); @@ -303,7 +320,7 @@ public static IPHostEntry Resolve(string hostName) // See if it's an IP Address. IPHostEntry ipHostEntry; - if (IPAddress.TryParse(hostName, out IPAddress? address) && + if (NameResolutionPal.SupportsGetNameInfo && IPAddress.TryParse(hostName, out IPAddress? address) && (address.AddressFamily != AddressFamily.InterNetworkV6 || SocketProtocolSupportPal.OSSupportsIPv6)) { try @@ -332,6 +349,8 @@ public static IAsyncResult BeginResolve(string hostName, AsyncCallback? requestC [Obsolete("EndResolve has been deprecated. Use EndGetHostEntry instead.")] public static IPHostEntry EndResolve(IAsyncResult asyncResult) { + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 + IPHostEntry ipHostEntry; try @@ -414,6 +433,8 @@ private static IPAddress[] GetHostAddressesCore(IPAddress address, AddressFamily // Does internal IPAddress reverse and then forward lookups (for Legacy and current public methods). private static object GetHostEntryOrAddressesCore(IPAddress address, bool justAddresses, AddressFamily addressFamily, NameResolutionActivity? activityOrDefault = default) { + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 + // Try to get the data for the host from its address. // We need to call getnameinfo first, because getaddrinfo w/ the ipaddress string // will only return that address and not the full list. @@ -500,7 +521,7 @@ private static Task GetHostEntryOrAddressesCoreAsync(string hostName, bool justR object asyncState; // See if it's an IP Address. - if (IPAddress.TryParse(hostName, out IPAddress? ipAddress)) + if (NameResolutionPal.SupportsGetNameInfo && IPAddress.TryParse(hostName, out IPAddress? ipAddress)) { if (throwOnIIPAny && (ipAddress.Equals(IPAddress.Any) || ipAddress.Equals(IPAddress.IPv6Any))) { diff --git a/src/libraries/System.Net.NameResolution/src/System/Net/NameResolutionPal.Unix.cs b/src/libraries/System.Net.NameResolution/src/System/Net/NameResolutionPal.Unix.cs index 54ec640a3b0..c2924830c07 100644 --- a/src/libraries/System.Net.NameResolution/src/System/Net/NameResolutionPal.Unix.cs +++ b/src/libraries/System.Net.NameResolution/src/System/Net/NameResolutionPal.Unix.cs @@ -8,6 +8,7 @@ using System.Text; using System.Threading; using System.Threading.Tasks; +using System.Runtime.Versioning; namespace System.Net { @@ -15,6 +16,9 @@ internal static partial class NameResolutionPal { public const bool SupportsGetAddrInfoAsync = false; + [UnsupportedOSPlatformGuard("wasi")] + public static bool SupportsGetNameInfo => !OperatingSystem.IsWasi(); + #pragma warning disable IDE0060 internal static Task? GetAddrInfoAsync(string hostName, bool justAddresses, AddressFamily family, CancellationToken cancellationToken) => throw new NotSupportedException(); @@ -39,6 +43,9 @@ private static SocketError GetSocketErrorForNativeError(int error) return SocketError.HostNotFound; case (int)Interop.Sys.GetAddrInfoErrorFlags.EAI_MEMORY: throw new OutOfMemoryException(); + case (int)Interop.Sys.GetAddrInfoErrorFlags.EAI_SYSTEM: + Debug.Fail($"Unexpected error: {error} errno: {Interop.Sys.GetErrNo()}"); + return SocketError.SocketError; default: Debug.Fail($"Unexpected error: {error}"); return SocketError.SocketError; @@ -146,6 +153,8 @@ public static unsafe SocketError TryGetAddrInfo(string name, bool justAddresses, public static unsafe string? TryGetNameInfo(IPAddress addr, out SocketError socketError, out int nativeErrorCode) { + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 + byte* buffer = stackalloc byte[Interop.Sys.NI_MAXHOST + 1 /*for null*/]; byte isIPv6; diff --git a/src/libraries/System.Net.NameResolution/src/System/Net/NameResolutionPal.Windows.cs b/src/libraries/System.Net.NameResolution/src/System/Net/NameResolutionPal.Windows.cs index 72fc7685dff..a044e204612 100644 --- a/src/libraries/System.Net.NameResolution/src/System/Net/NameResolutionPal.Windows.cs +++ b/src/libraries/System.Net.NameResolution/src/System/Net/NameResolutionPal.Windows.cs @@ -9,6 +9,7 @@ using System.Threading; using System.Threading.Tasks; using Microsoft.Win32.SafeHandles; +using System.Runtime.Versioning; namespace System.Net { @@ -43,6 +44,8 @@ static void Initialize() } } + public const bool SupportsGetNameInfo = true; + public static unsafe SocketError TryGetAddrInfo(string name, bool justAddresses, AddressFamily addressFamily, out string? hostName, out string[] aliases, out IPAddress[] addresses, out int nativeErrorCode) { Interop.Winsock.EnsureInitialized(); diff --git a/src/libraries/System.Net.NameResolution/src/System/Net/NameResolutionTelemetry.cs b/src/libraries/System.Net.NameResolution/src/System/Net/NameResolutionTelemetry.cs index 07a252fbd25..defa4da9056 100644 --- a/src/libraries/System.Net.NameResolution/src/System/Net/NameResolutionTelemetry.cs +++ b/src/libraries/System.Net.NameResolution/src/System/Net/NameResolutionTelemetry.cs @@ -59,7 +59,7 @@ protected override void OnEventCommand(EventCommandEventArgs command) private void ResolutionFailed() => WriteEvent(ResolutionFailedEventId); [NonEvent] - public static bool AnyDiagnosticsEnabled() => Log.IsEnabled() || NameResolutionMetrics.IsEnabled() || NameResolutionActivity.IsTracingEnabled(); + public static bool AnyDiagnosticsEnabled() => !OperatingSystem.IsWasi() && (Log.IsEnabled() || NameResolutionMetrics.IsEnabled() || NameResolutionActivity.IsTracingEnabled()); [NonEvent] public NameResolutionActivity BeforeResolution(object hostNameOrAddress, long startingTimestamp = 0) @@ -91,6 +91,8 @@ public NameResolutionActivity BeforeResolution(object hostNameOrAddress, long st [NonEvent] public void AfterResolution(object hostNameOrAddress, in NameResolutionActivity activity, object? answer, Exception? exception = null) { + if (OperatingSystem.IsWasi()) return; + if (!activity.Stop(answer, exception, out TimeSpan duration)) { // We stopped the System.Diagnostics.Activity at this point and neither metrics nor EventSource is enabled. diff --git a/src/libraries/System.Net.NameResolution/tests/FunctionalTests/GetHostAddressesTest.cs b/src/libraries/System.Net.NameResolution/tests/FunctionalTests/GetHostAddressesTest.cs index 71820b8cc72..d1073db5d39 100644 --- a/src/libraries/System.Net.NameResolution/tests/FunctionalTests/GetHostAddressesTest.cs +++ b/src/libraries/System.Net.NameResolution/tests/FunctionalTests/GetHostAddressesTest.cs @@ -69,14 +69,14 @@ public async Task Dns_GetHostAddressesAsync_NullHost_Fail() await Assert.ThrowsAsync(() => Dns.GetHostAddressesAsync(null)); } - [Fact] + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))] public void DnsBeginGetHostAddresses_BadName_Throws() { IAsyncResult asyncObject = Dns.BeginGetHostAddresses("BadName", null, null); Assert.ThrowsAny(() => Dns.EndGetHostAddresses(asyncObject)); } - [Fact] + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))] public void DnsBeginGetHostAddresses_BadIpString_ReturnsAddress() { IAsyncResult asyncObject = Dns.BeginGetHostAddresses("0.0.1.1", null, null); @@ -86,7 +86,7 @@ public void DnsBeginGetHostAddresses_BadIpString_ReturnsAddress() Assert.Equal(IPAddress.Parse("0.0.1.1"), results[0]); } - [Fact] + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))] public void DnsBeginGetHostAddresses_MachineName_MatchesGetHostAddresses() { IAsyncResult asyncObject = Dns.BeginGetHostAddresses(TestSettings.LocalHost, null, null); diff --git a/src/libraries/System.Net.NameResolution/tests/FunctionalTests/GetHostByAddressTest.cs b/src/libraries/System.Net.NameResolution/tests/FunctionalTests/GetHostByAddressTest.cs index a9072c6506f..6a6b237b0d9 100644 --- a/src/libraries/System.Net.NameResolution/tests/FunctionalTests/GetHostByAddressTest.cs +++ b/src/libraries/System.Net.NameResolution/tests/FunctionalTests/GetHostByAddressTest.cs @@ -8,6 +8,7 @@ namespace System.Net.NameResolution.Tests { + [SkipOnPlatform(TestPlatforms.Wasi, "WASI has no getnameinfo")] public class GetHostByAddressTest { [Fact] diff --git a/src/libraries/System.Net.NameResolution/tests/FunctionalTests/GetHostByNameTest.cs b/src/libraries/System.Net.NameResolution/tests/FunctionalTests/GetHostByNameTest.cs index 56f52afb1b7..479a5cd39ac 100644 --- a/src/libraries/System.Net.NameResolution/tests/FunctionalTests/GetHostByNameTest.cs +++ b/src/libraries/System.Net.NameResolution/tests/FunctionalTests/GetHostByNameTest.cs @@ -19,7 +19,7 @@ public void DnsObsoleteBeginGetHostByName_BadName_Throws() Assert.ThrowsAny(() => Dns.EndGetHostByName(asyncObject)); } - [Fact] + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))] public void DnsObsoleteBeginGetHostByName_IPv4String_ReturnsOnlyGivenIP() { IAsyncResult asyncObject = Dns.BeginGetHostByName(IPAddress.Loopback.ToString(), null, null); @@ -106,6 +106,7 @@ public void DnsObsoleteGetHostByName_IPv6String_ReturnsOnlyGivenIP() [ActiveIssue("https://github.com/dotnet/runtime/issues/1488", TestPlatforms.OSX)] [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotArm64Process))] // [ActiveIssue("https://github.com/dotnet/runtime/issues/27622")] [ActiveIssue("https://github.com/dotnet/runtime/issues/51377", TestPlatforms.iOS | TestPlatforms.tvOS | TestPlatforms.MacCatalyst)] + [ActiveIssue("https://github.com/dotnet/runtime/issues/107339", TestPlatforms.Wasi)] public void DnsObsoleteGetHostByName_EmptyString_ReturnsHostName() { IPHostEntry entry = Dns.GetHostByName(""); diff --git a/src/libraries/System.Net.NameResolution/tests/FunctionalTests/GetHostEntryTest.cs b/src/libraries/System.Net.NameResolution/tests/FunctionalTests/GetHostEntryTest.cs index a4a7174897a..c4988cef816 100644 --- a/src/libraries/System.Net.NameResolution/tests/FunctionalTests/GetHostEntryTest.cs +++ b/src/libraries/System.Net.NameResolution/tests/FunctionalTests/GetHostEntryTest.cs @@ -148,10 +148,16 @@ public async Task Dns_GetHostEntry_NullStringHost_Fail() { Assert.Throws(() => Dns.GetHostEntry((string)null)); await Assert.ThrowsAsync(() => Dns.GetHostEntryAsync((string)null)); + } + + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))] + public async Task Dns_GetHostEntry_NullStringHost_Fail_Obsolete() + { await Assert.ThrowsAsync(() => Task.Factory.FromAsync(Dns.BeginGetHostEntry, Dns.EndGetHostEntry, (string)null, null)); } [Fact] + [SkipOnPlatform(TestPlatforms.Wasi, "WASI has no getnameinfo")] public async Task Dns_GetHostEntryAsync_NullIPAddressHost_Fail() { Assert.Throws(() => Dns.GetHostEntry((IPAddress)null)); @@ -168,6 +174,7 @@ public static IEnumerable GetInvalidAddresses() [Theory] [MemberData(nameof(GetInvalidAddresses))] + [SkipOnPlatform(TestPlatforms.Wasi, "WASI has no getnameinfo")] public async Task Dns_GetHostEntry_AnyIPAddress_Fail(IPAddress address) { Assert.Throws(() => Dns.GetHostEntry(address)); @@ -195,6 +202,7 @@ public async Task DnsGetHostEntry_MachineName_AllVariationsMatch() } [Fact] + [SkipOnPlatform(TestPlatforms.Wasi, "WASI has no getnameinfo")] public async Task DnsGetHostEntry_Loopback_AllVariationsMatch() { IPHostEntry syncResult = Dns.GetHostEntry(IPAddress.Loopback); @@ -216,6 +224,7 @@ public async Task DnsGetHostEntry_Loopback_AllVariationsMatch() [InlineData("Really.Long.Name.Over.One.Hundred.And.Twenty.Six.Chars.Eeeeeeeventualllllllly.I.Will.Get.To.The.Eeeee" + "eeeeend.Almost.There.Are.We.Really.Long.Name.Over.One.Hundred.And.Twenty.Six.Chars.Eeeeeeeventualll" + "llllly.I.Will.Get.To.The.Eeeeeeeeeend.Almost.There.Are")] // very long name but not too long + [ActiveIssue("https://github.com/dotnet/runtime/issues/107339", TestPlatforms.Wasi)] public async Task DnsGetHostEntry_BadName_ThrowsSocketException(string hostNameOrAddress) { Assert.ThrowsAny(() => Dns.GetHostEntry(hostNameOrAddress)); @@ -231,6 +240,14 @@ public async Task DnsGetHostEntry_BadName_ThrowsArgumentOutOfRangeException(stri { Assert.ThrowsAny(() => Dns.GetHostEntry(hostNameOrAddress)); await Assert.ThrowsAnyAsync(() => Dns.GetHostEntryAsync(hostNameOrAddress)); + } + + [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsThreadingSupported))] + [InlineData("Really.Long.Name.Over.One.Hundred.And.Twenty.Six.Chars.Eeeeeeeventualllllllly.I.Will.Get.To.The.Eeeee" + + "eeeeend.Almost.There.Are.We.Really.Long.Name.Over.One.Hundred.And.Twenty.Six.Chars.Eeeeeeeventualll" + + "llllly.I.Will.Get.To.The.Eeeeeeeeeend.Almost.There.Aret")] + public async Task DnsGetHostEntry_BadName_ThrowsArgumentOutOfRangeException_Obsolete(string hostNameOrAddress) + { await Assert.ThrowsAnyAsync(() => Task.Factory.FromAsync(Dns.BeginGetHostEntry, Dns.EndGetHostEntry, hostNameOrAddress, null)); } @@ -238,6 +255,7 @@ public async Task DnsGetHostEntry_BadName_ThrowsArgumentOutOfRangeException(stri [InlineData(0)] [InlineData(1)] [InlineData(2)] + [ActiveIssue("https://github.com/dotnet/runtime/issues/107339", TestPlatforms.Wasi)] public async Task DnsGetHostEntry_LocalHost_ReturnsFqdnAndLoopbackIPs(int mode) { IPHostEntry entry = mode switch @@ -259,6 +277,9 @@ public async Task DnsGetHostEntry_LocalHost_ReturnsFqdnAndLoopbackIPs(int mode) [InlineData(2)] public async Task DnsGetHostEntry_LoopbackIP_MatchesGetHostEntryLoopbackString(int mode) { + if (OperatingSystem.IsWasi() && mode == 2) + throw new SkipTestException("mode 2 is not supported on WASI"); + IPAddress address = IPAddress.Loopback; IPHostEntry ipEntry = mode switch diff --git a/src/libraries/System.Net.NameResolution/tests/FunctionalTests/LoggingTest.cs b/src/libraries/System.Net.NameResolution/tests/FunctionalTests/LoggingTest.cs index 920a5af60cf..43f3db17b3e 100644 --- a/src/libraries/System.Net.NameResolution/tests/FunctionalTests/LoggingTest.cs +++ b/src/libraries/System.Net.NameResolution/tests/FunctionalTests/LoggingTest.cs @@ -15,6 +15,7 @@ namespace System.Net.NameResolution.Tests using Configuration = System.Net.Test.Common.Configuration; [Collection(nameof(DisableParallelization))] + [SkipOnPlatform(TestPlatforms.Wasi, "WASI doesn't have event source yet")] public class LoggingTest { [Fact] diff --git a/src/libraries/System.Net.NameResolution/tests/FunctionalTests/MetricsTest.cs b/src/libraries/System.Net.NameResolution/tests/FunctionalTests/MetricsTest.cs index 0cafd974a4a..ebee4d90e8d 100644 --- a/src/libraries/System.Net.NameResolution/tests/FunctionalTests/MetricsTest.cs +++ b/src/libraries/System.Net.NameResolution/tests/FunctionalTests/MetricsTest.cs @@ -12,6 +12,7 @@ namespace System.Net.NameResolution.Tests { + [SkipOnPlatform(TestPlatforms.Wasi, "WASI doesn't have event source yet")] public class MetricsTest { private const string DnsLookupDuration = "dns.lookup.duration"; diff --git a/src/libraries/System.Net.NameResolution/tests/FunctionalTests/ResolveTest.cs b/src/libraries/System.Net.NameResolution/tests/FunctionalTests/ResolveTest.cs index 071e9927ee9..814ec5cc6c2 100644 --- a/src/libraries/System.Net.NameResolution/tests/FunctionalTests/ResolveTest.cs +++ b/src/libraries/System.Net.NameResolution/tests/FunctionalTests/ResolveTest.cs @@ -46,6 +46,7 @@ public void DnsObsoleteResolve_BadName_Throws() } [Fact] + [SkipOnPlatform(TestPlatforms.Wasi, "WASI has no getnameinfo")] public void DnsObsoleteResolve_BadIP_ReturnsIPasNameAndIP() { IPHostEntry entry = Dns.Resolve("0.0.1.1"); diff --git a/src/libraries/System.Net.NameResolution/tests/FunctionalTests/System.Net.NameResolution.Functional.Tests.csproj b/src/libraries/System.Net.NameResolution/tests/FunctionalTests/System.Net.NameResolution.Functional.Tests.csproj index 182e5d9eba1..9741c993ccd 100644 --- a/src/libraries/System.Net.NameResolution/tests/FunctionalTests/System.Net.NameResolution.Functional.Tests.csproj +++ b/src/libraries/System.Net.NameResolution/tests/FunctionalTests/System.Net.NameResolution.Functional.Tests.csproj @@ -1,9 +1,10 @@ - $(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-unix;$(NetCoreAppCurrent)-browser + $(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-unix;$(NetCoreAppCurrent)-browser;$(NetCoreAppCurrent)-wasi true true true + true diff --git a/src/libraries/System.Net.NameResolution/tests/FunctionalTests/TelemetryTest.cs b/src/libraries/System.Net.NameResolution/tests/FunctionalTests/TelemetryTest.cs index b88ad1188ae..3da29837205 100644 --- a/src/libraries/System.Net.NameResolution/tests/FunctionalTests/TelemetryTest.cs +++ b/src/libraries/System.Net.NameResolution/tests/FunctionalTests/TelemetryTest.cs @@ -12,6 +12,7 @@ namespace System.Net.NameResolution.Tests { + [SkipOnPlatform(TestPlatforms.Wasi, "WASI doesn't have event source yet")] public class TelemetryTest { [Fact] diff --git a/src/libraries/System.Net.NameResolution/tests/PalTests/NameResolutionPalTests.cs b/src/libraries/System.Net.NameResolution/tests/PalTests/NameResolutionPalTests.cs index 030f03c01ed..e4049b12919 100644 --- a/src/libraries/System.Net.NameResolution/tests/PalTests/NameResolutionPalTests.cs +++ b/src/libraries/System.Net.NameResolution/tests/PalTests/NameResolutionPalTests.cs @@ -61,6 +61,7 @@ private void LogUnixInfo() [Theory] [InlineData(false)] [InlineData(true)] + [ActiveIssue("https://github.com/dotnet/runtime/issues/107339", TestPlatforms.Wasi)] public void TryGetAddrInfo_LocalHost(bool justAddresses) { SocketError error = NameResolutionPal.TryGetAddrInfo("localhost", justAddresses, AddressFamily.Unspecified, out string hostName, out string[] aliases, out IPAddress[] addresses, out int nativeErrorCode); @@ -77,6 +78,7 @@ public void TryGetAddrInfo_LocalHost(bool justAddresses) [Theory] [InlineData(false)] [InlineData(true)] + [ActiveIssue("https://github.com/dotnet/runtime/issues/107339", TestPlatforms.Wasi)] public void TryGetAddrInfo_EmptyHost(bool justAddresses) { SocketError error = NameResolutionPal.TryGetAddrInfo("", justAddresses, AddressFamily.Unspecified, out string hostName, out string[] aliases, out IPAddress[] addresses, out int nativeErrorCode); @@ -151,6 +153,7 @@ public void TryGetAddrInfo_UnknownHost(bool justAddresses) } [Fact] + [SkipOnPlatform(TestPlatforms.Wasi, "WASI has no getnameinfo")] public void TryGetNameInfo_LocalHost_IPv4() { SocketError error; @@ -161,6 +164,7 @@ public void TryGetNameInfo_LocalHost_IPv4() } [ConditionalFact(nameof(Ipv6LocalHostNameLookupNotBrokenByNrpRule))] + [SkipOnPlatform(TestPlatforms.Wasi, "WASI has no getnameinfo")] public void TryGetNameInfo_LocalHost_IPv6() { SocketError error; @@ -176,6 +180,7 @@ public void TryGetNameInfo_LocalHost_IPv6() } [Fact] + [SkipOnPlatform(TestPlatforms.Wasi, "WASI has no getnameinfo")] public void TryGetAddrInfo_LocalHost_TryGetNameInfo() { SocketError error = NameResolutionPal.TryGetAddrInfo("localhost", justAddresses: false, AddressFamily.Unspecified, out string hostName, out string[] aliases, out IPAddress[] addresses, out int nativeErrorCode); @@ -247,6 +252,7 @@ public void TryGetAddrInfo_HostName_TryGetNameInfo() [Theory] [InlineData(false)] [InlineData(true)] + [SkipOnPlatform(TestPlatforms.Wasi, "WASI has no getnameinfo")] public void TryGetNameInfo_LocalHost_IPv4_TryGetAddrInfo(bool justAddresses) { string name = NameResolutionPal.TryGetNameInfo(new IPAddress(new byte[] { 127, 0, 0, 1 }), out SocketError error, out _); @@ -262,6 +268,7 @@ public void TryGetNameInfo_LocalHost_IPv4_TryGetAddrInfo(bool justAddresses) [ConditionalTheory(nameof(Ipv6LocalHostNameLookupNotBrokenByNrpRule))] [InlineData(false)] [InlineData(true)] + [SkipOnPlatform(TestPlatforms.Wasi, "WASI has no getnameinfo")] public void TryGetNameInfo_LocalHost_IPv6_TryGetAddrInfo(bool justAddresses) { SocketError error; diff --git a/src/libraries/System.Net.NameResolution/tests/PalTests/System.Net.NameResolution.Pal.Tests.csproj b/src/libraries/System.Net.NameResolution/tests/PalTests/System.Net.NameResolution.Pal.Tests.csproj index 6e08a5f973e..7daa5977519 100644 --- a/src/libraries/System.Net.NameResolution/tests/PalTests/System.Net.NameResolution.Pal.Tests.csproj +++ b/src/libraries/System.Net.NameResolution/tests/PalTests/System.Net.NameResolution.Pal.Tests.csproj @@ -2,8 +2,9 @@ true ../../src/Resources/Strings.resx - $(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-unix;$(NetCoreAppCurrent)-browser + $(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-unix;$(NetCoreAppCurrent)-browser;$(NetCoreAppCurrent)-wasi true + true @@ -71,7 +72,9 @@ - + + Microsoft true - browser + browser;wasi \ No newline at end of file diff --git a/src/libraries/System.Net.NetworkInformation/System.Net.NetworkInformation.sln b/src/libraries/System.Net.NetworkInformation/System.Net.NetworkInformation.sln index 570f1e0a406..5bba03b183a 100644 --- a/src/libraries/System.Net.NetworkInformation/System.Net.NetworkInformation.sln +++ b/src/libraries/System.Net.NetworkInformation/System.Net.NetworkInformation.sln @@ -15,6 +15,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Net.Primitives", ".. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{DDE2D5F1-C566-41EA-9482-E587A7DEF254}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{90869A63-ABF3-43BA-9546-03C94C168672}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{D6600B0A-FEE0-4D1E-B42F-88EB016403CF}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{1E0ED0DE-76B3-402F-8029-C432E638CE0C}" @@ -87,6 +89,10 @@ Global {DDE2D5F1-C566-41EA-9482-E587A7DEF254}.Debug|Any CPU.Build.0 = Debug|Any CPU {DDE2D5F1-C566-41EA-9482-E587A7DEF254}.Release|Any CPU.ActiveCfg = Release|Any CPU {DDE2D5F1-C566-41EA-9482-E587A7DEF254}.Release|Any CPU.Build.0 = Release|Any CPU + {90869A63-ABF3-43BA-9546-03C94C168672}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {90869A63-ABF3-43BA-9546-03C94C168672}.Debug|Any CPU.Build.0 = Debug|Any CPU + {90869A63-ABF3-43BA-9546-03C94C168672}.Release|Any CPU.ActiveCfg = Release|Any CPU + {90869A63-ABF3-43BA-9546-03C94C168672}.Release|Any CPU.Build.0 = Release|Any CPU {D6600B0A-FEE0-4D1E-B42F-88EB016403CF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {D6600B0A-FEE0-4D1E-B42F-88EB016403CF}.Debug|Any CPU.Build.0 = Debug|Any CPU {D6600B0A-FEE0-4D1E-B42F-88EB016403CF}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -138,6 +144,7 @@ Global {2F199597-D0CF-49F4-B6AC-136568ACA101} = {01C6C981-C56F-453F-B099-C8B9DF61CDEB} {062F1189-143C-456B-A439-D9C1BE2DD640} = {A3CAA996-BF7C-48EE-A03A-2B2F78D88D86} {DDE2D5F1-C566-41EA-9482-E587A7DEF254} = {575528E7-33D8-4375-8B5A-D88215FEE447} + {90869A63-ABF3-43BA-9546-03C94C168672} = {575528E7-33D8-4375-8B5A-D88215FEE447} {D6600B0A-FEE0-4D1E-B42F-88EB016403CF} = {575528E7-33D8-4375-8B5A-D88215FEE447} {1E0ED0DE-76B3-402F-8029-C432E638CE0C} = {575528E7-33D8-4375-8B5A-D88215FEE447} {76FE6990-FDCC-407C-A141-17333897C85A} = {38149F91-88CE-43C8-A78A-4677279A9CE6} diff --git a/src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/System.Net.NetworkInformation.Functional.Tests.csproj b/src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/System.Net.NetworkInformation.Functional.Tests.csproj index a9608bd8793..afefb7a4fde 100644 --- a/src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/System.Net.NetworkInformation.Functional.Tests.csproj +++ b/src/libraries/System.Net.NetworkInformation/tests/FunctionalTests/System.Net.NetworkInformation.Functional.Tests.csproj @@ -6,7 +6,6 @@ true $(DefineConstants);NETWORKINFORMATION_TEST true - $(NoWarn);SYSLIB0057 diff --git a/src/libraries/System.Net.Ping/Directory.Build.props b/src/libraries/System.Net.Ping/Directory.Build.props index ce244cbea56..58979d42f06 100644 --- a/src/libraries/System.Net.Ping/Directory.Build.props +++ b/src/libraries/System.Net.Ping/Directory.Build.props @@ -3,6 +3,6 @@ Microsoft true - browser + browser;wasi \ No newline at end of file diff --git a/src/libraries/System.Net.Ping/System.Net.Ping.sln b/src/libraries/System.Net.Ping/System.Net.Ping.sln index aea9d6c1b77..8b9599ff598 100644 --- a/src/libraries/System.Net.Ping/System.Net.Ping.sln +++ b/src/libraries/System.Net.Ping/System.Net.Ping.sln @@ -25,6 +25,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ObjectModel", "..\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{85E42E20-BD03-4417-8E0D-693CE3ED9BFE}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{7D03C7C5-C22D-4A32-BE0E-D85C51DABF35}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{26E69A05-FCF8-4D01-A93A-F97FE4B92D74}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{B59DB44D-8E1E-4F62-A223-E3AC71BB0370}" @@ -119,6 +121,10 @@ Global {85E42E20-BD03-4417-8E0D-693CE3ED9BFE}.Debug|Any CPU.Build.0 = Debug|Any CPU {85E42E20-BD03-4417-8E0D-693CE3ED9BFE}.Release|Any CPU.ActiveCfg = Release|Any CPU {85E42E20-BD03-4417-8E0D-693CE3ED9BFE}.Release|Any CPU.Build.0 = Release|Any CPU + {7D03C7C5-C22D-4A32-BE0E-D85C51DABF35}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {7D03C7C5-C22D-4A32-BE0E-D85C51DABF35}.Debug|Any CPU.Build.0 = Debug|Any CPU + {7D03C7C5-C22D-4A32-BE0E-D85C51DABF35}.Release|Any CPU.ActiveCfg = Release|Any CPU + {7D03C7C5-C22D-4A32-BE0E-D85C51DABF35}.Release|Any CPU.Build.0 = Release|Any CPU {26E69A05-FCF8-4D01-A93A-F97FE4B92D74}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {26E69A05-FCF8-4D01-A93A-F97FE4B92D74}.Debug|Any CPU.Build.0 = Debug|Any CPU {26E69A05-FCF8-4D01-A93A-F97FE4B92D74}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -180,6 +186,7 @@ Global {200D7714-61DF-490B-8A37-ABB93B3A2861} = {AAB0D01D-C3A4-4E09-9BFD-CBC737A3CA73} {65B08958-069E-4F8B-A996-2A987ACCAA49} = {A687595D-ACCE-4380-95B8-628F598C7229} {85E42E20-BD03-4417-8E0D-693CE3ED9BFE} = {D26792B6-6D00-4CC0-B60B-7028F377BD4F} + {7D03C7C5-C22D-4A32-BE0E-D85C51DABF35} = {D26792B6-6D00-4CC0-B60B-7028F377BD4F} {26E69A05-FCF8-4D01-A93A-F97FE4B92D74} = {D26792B6-6D00-4CC0-B60B-7028F377BD4F} {B59DB44D-8E1E-4F62-A223-E3AC71BB0370} = {D26792B6-6D00-4CC0-B60B-7028F377BD4F} {2C09100E-DBC4-4462-8D86-E429E2EC8C5C} = {8A7756DC-E949-418A-93A2-C4BE96CD25ED} diff --git a/src/libraries/System.Net.Primitives/System.Net.Primitives.sln b/src/libraries/System.Net.Primitives/System.Net.Primitives.sln index 9f96cbb4b55..f74544fad5d 100644 --- a/src/libraries/System.Net.Primitives/System.Net.Primitives.sln +++ b/src/libraries/System.Net.Primitives/System.Net.Primitives.sln @@ -17,6 +17,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Net.Primitives.UnitT EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{2F6BED4C-3D02-4D55-83FA-81F6368260C5}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{143F0F8A-34A5-410B-9F00-3E4965FFD5AE}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{780F4FEF-204D-4EE0-8072-884A9EF7FE9E}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{160E40E8-0148-4D87-86D2-1F1918BD36F0}" @@ -93,6 +95,10 @@ Global {2F6BED4C-3D02-4D55-83FA-81F6368260C5}.Debug|Any CPU.Build.0 = Debug|Any CPU {2F6BED4C-3D02-4D55-83FA-81F6368260C5}.Release|Any CPU.ActiveCfg = Release|Any CPU {2F6BED4C-3D02-4D55-83FA-81F6368260C5}.Release|Any CPU.Build.0 = Release|Any CPU + {143F0F8A-34A5-410B-9F00-3E4965FFD5AE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {143F0F8A-34A5-410B-9F00-3E4965FFD5AE}.Debug|Any CPU.Build.0 = Debug|Any CPU + {143F0F8A-34A5-410B-9F00-3E4965FFD5AE}.Release|Any CPU.ActiveCfg = Release|Any CPU + {143F0F8A-34A5-410B-9F00-3E4965FFD5AE}.Release|Any CPU.Build.0 = Release|Any CPU {780F4FEF-204D-4EE0-8072-884A9EF7FE9E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {780F4FEF-204D-4EE0-8072-884A9EF7FE9E}.Debug|Any CPU.Build.0 = Debug|Any CPU {780F4FEF-204D-4EE0-8072-884A9EF7FE9E}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -145,6 +151,7 @@ Global {B7492470-68D0-4938-8048-BBDD2EC2541E} = {212A5562-EFE7-4220-94EC-6B49C0A6DCEF} {08C53516-56AB-4D3B-B22F-7DC1B27EA7CE} = {97419593-C13A-4407-B489-1651C8D3E813} {2F6BED4C-3D02-4D55-83FA-81F6368260C5} = {6DD9FC21-AB33-4068-BC80-B4B89B7C99C9} + {143F0F8A-34A5-410B-9F00-3E4965FFD5AE} = {6DD9FC21-AB33-4068-BC80-B4B89B7C99C9} {780F4FEF-204D-4EE0-8072-884A9EF7FE9E} = {6DD9FC21-AB33-4068-BC80-B4B89B7C99C9} {160E40E8-0148-4D87-86D2-1F1918BD36F0} = {6DD9FC21-AB33-4068-BC80-B4B89B7C99C9} {BC5985B8-25E7-41FB-8D83-7D0A9960B90D} = {755EE99F-4EA2-4CB1-868F-3786B3553EE3} diff --git a/src/libraries/System.Net.Primitives/tests/PalTests/System.Net.Primitives.Pal.Tests.csproj b/src/libraries/System.Net.Primitives/tests/PalTests/System.Net.Primitives.Pal.Tests.csproj index 90fbc1e3d31..96dbbd4ce51 100644 --- a/src/libraries/System.Net.Primitives/tests/PalTests/System.Net.Primitives.Pal.Tests.csproj +++ b/src/libraries/System.Net.Primitives/tests/PalTests/System.Net.Primitives.Pal.Tests.csproj @@ -116,7 +116,7 @@ - + Version >= new Version(2, 3, 5); + internal static bool SupportsAsyncCertValidation => Version >= new Version(2, 4); internal static bool UsesSChannelBackend { get; } diff --git a/src/libraries/System.Net.Quic/src/System/Net/Quic/QuicConnection.cs b/src/libraries/System.Net.Quic/src/System/Net/Quic/QuicConnection.cs index f57fd7651c3..840e1bdac7b 100644 --- a/src/libraries/System.Net.Quic/src/System/Net/Quic/QuicConnection.cs +++ b/src/libraries/System.Net.Quic/src/System/Net/Quic/QuicConnection.cs @@ -8,6 +8,7 @@ using System.Runtime.ExceptionServices; using System.Runtime.InteropServices; using System.Runtime.Versioning; +using System.Security.Authentication; using System.Security.Cryptography.X509Certificates; using System.Threading; using System.Threading.Channels; @@ -213,6 +214,14 @@ static async ValueTask StartConnectAsync(QuicClientConnectionOpt /// Set when CONNECTED is received. /// private SslApplicationProtocol _negotiatedApplicationProtocol; + /// + /// Set when CONNECTED is received. + /// + private TlsCipherSuite _negotiatedCipherSuite; + /// + /// Set when CONNECTED is received. + /// + private SslProtocols _negotiatedSslProtocol; /// /// Will contain TLS secret after CONNECTED event is received and store it into SSLKEYLOGFILE. @@ -287,6 +296,17 @@ public X509Certificate? RemoteCertificate /// public SslApplicationProtocol NegotiatedApplicationProtocol => _negotiatedApplicationProtocol; + /// + /// Gets the cipher suite which was negotiated for this connection. + /// + [CLSCompliant(false)] + public TlsCipherSuite NegotiatedCipherSuite => _negotiatedCipherSuite; + + /// + /// Gets a value that indicates the security protocol used to authenticate this connection. + /// + public SslProtocols SslProtocol => _negotiatedSslProtocol; + /// public override string ToString() => _handle.ToString(); @@ -609,6 +629,15 @@ private unsafe int HandleEventConnected(ref CONNECTED_DATA data) { _negotiatedApplicationProtocol = new SslApplicationProtocol(new Span(data.NegotiatedAlpn, data.NegotiatedAlpnLength).ToArray()); + QUIC_HANDSHAKE_INFO info = MsQuicHelpers.GetMsQuicParameter(_handle, QUIC_PARAM_TLS_HANDSHAKE_INFO); + + // QUIC_CIPHER_SUITE and QUIC_TLS_PROTOCOL_VERSION use the same values as the corresponding TlsCipherSuite and SslProtocols members. + _negotiatedCipherSuite = (TlsCipherSuite)info.CipherSuite; + _negotiatedSslProtocol = (SslProtocols)info.TlsProtocolVersion; + + // currently only TLS 1.3 is defined for QUIC + Debug.Assert(_negotiatedSslProtocol == SslProtocols.Tls13, $"Unexpected TLS version {info.TlsProtocolVersion}"); + QuicAddr remoteAddress = MsQuicHelpers.GetMsQuicParameter(_handle, QUIC_PARAM_CONN_REMOTE_ADDRESS); _remoteEndPoint = MsQuicHelpers.QuicAddrToIPEndPoint(&remoteAddress); diff --git a/src/libraries/System.Net.Quic/tests/FunctionalTests/MsQuicInteropTests.cs b/src/libraries/System.Net.Quic/tests/FunctionalTests/MsQuicInteropTests.cs index 5ffd5b53510..91838d8fab3 100644 --- a/src/libraries/System.Net.Quic/tests/FunctionalTests/MsQuicInteropTests.cs +++ b/src/libraries/System.Net.Quic/tests/FunctionalTests/MsQuicInteropTests.cs @@ -70,5 +70,17 @@ public void QuicSettings_Equals_RespectsAllMembers() Assert.False(settings.Equals((QUIC_SETTINGS)boxed), $"Member {member.Name} is not compared."); } } + + [Fact] + public void MsQuicCipherSuites_MapTo_TlsCipherSuite() + { + foreach (QUIC_CIPHER_SUITE msQuicCipherSuite in Enum.GetValues()) + { + // both QUIC_CIPHER_SUITE and TlsCipherSuite members use the IANA identifiers of the TLS cipher suites, check that their values match + TlsCipherSuite cipherSuite = (TlsCipherSuite)msQuicCipherSuite; + // if same numerical value maps to the same enum member, the ToString() should be the same + Assert.Equal(msQuicCipherSuite.ToString(), cipherSuite.ToString()); + } + } } } diff --git a/src/libraries/System.Net.Quic/tests/FunctionalTests/MsQuicTests.cs b/src/libraries/System.Net.Quic/tests/FunctionalTests/MsQuicTests.cs index 2bcdad52c83..5e3b4403778 100644 --- a/src/libraries/System.Net.Quic/tests/FunctionalTests/MsQuicTests.cs +++ b/src/libraries/System.Net.Quic/tests/FunctionalTests/MsQuicTests.cs @@ -52,7 +52,6 @@ public class MsQuicTests : QuicTestBase, IClassFixture { private static byte[] s_data = "Hello world!"u8.ToArray(); readonly CertificateSetup _certificates; - static bool DoesNotSupportAsyncCertValidation => QuicTestCollection.MsQuicVersion < new Version(2, 4); public MsQuicTests(ITestOutputHelper output, CertificateSetup setup) : base(output) { @@ -354,7 +353,6 @@ public async Task UntrustedClientCertificateFails() } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/99074", typeof(MsQuicTests), nameof(DoesNotSupportAsyncCertValidation))] public async Task CertificateCallbackThrowPropagates() { using CancellationTokenSource cts = new CancellationTokenSource(PassingTestTimeout); diff --git a/src/libraries/System.Net.Quic/tests/FunctionalTests/QuicConnectionTests.cs b/src/libraries/System.Net.Quic/tests/FunctionalTests/QuicConnectionTests.cs index 10521e4abbc..f059f28d577 100644 --- a/src/libraries/System.Net.Quic/tests/FunctionalTests/QuicConnectionTests.cs +++ b/src/libraries/System.Net.Quic/tests/FunctionalTests/QuicConnectionTests.cs @@ -4,6 +4,8 @@ using System.Collections.Generic; using System.Linq; using System.Net.Sockets; +using System.Net.Security; +using System.Security.Authentication; using System.Security.Cryptography.X509Certificates; using System.Threading; using System.Threading.Tasks; @@ -49,8 +51,17 @@ public async Task TestConnect(IPAddress address) } Assert.Equal(ApplicationProtocol.ToString(), clientConnection.NegotiatedApplicationProtocol.ToString()); Assert.Equal(ApplicationProtocol.ToString(), serverConnection.NegotiatedApplicationProtocol.ToString()); + Assert.Equal(options.ClientAuthenticationOptions.TargetHost, clientConnection.TargetHostName); Assert.Equal(options.ClientAuthenticationOptions.TargetHost, serverConnection.TargetHostName); + + Assert.Equal(clientConnection.NegotiatedCipherSuite, serverConnection.NegotiatedCipherSuite); + Assert.True(clientConnection.NegotiatedCipherSuite == TlsCipherSuite.TLS_AES_128_GCM_SHA256 || + clientConnection.NegotiatedCipherSuite == TlsCipherSuite.TLS_AES_256_GCM_SHA384 || + clientConnection.NegotiatedCipherSuite == TlsCipherSuite.TLS_CHACHA20_POLY1305_SHA256); + + Assert.Equal(clientConnection.SslProtocol, serverConnection.SslProtocol); + Assert.Equal(SslProtocols.Tls13, clientConnection.SslProtocol); // only TLS 1.3 is defined for QUIC at the moment } private static async Task OpenAndUseStreamAsync(QuicConnection c) @@ -444,11 +455,13 @@ public async Task GetStreamCapacity_SumInvariant() { int maxStreamIndex = 0; const int Limit = 5; + SemaphoreSlim streamsAvailableFired = new SemaphoreSlim(0); var clientOptions = CreateQuicClientOptions(new IPEndPoint(0, 0)); clientOptions.StreamCapacityCallback = (connection, args) => { Interlocked.Add(ref maxStreamIndex, args.BidirectionalIncrement); + streamsAvailableFired.Release(); }; var listenerOptions = CreateQuicListenerOptions(); @@ -461,6 +474,10 @@ public async Task GetStreamCapacity_SumInvariant() (QuicConnection clientConnection, QuicConnection serverConnection) = await CreateConnectedQuicConnection(clientOptions, listenerOptions); + while (maxStreamIndex < Limit) + { + await streamsAvailableFired.WaitAsync().WaitAsync(PassingTestTimeout); + } Assert.Equal(Limit, maxStreamIndex); Queue<(QuicStream client, QuicStream server)> streams = new(); @@ -498,8 +515,11 @@ public async Task GetStreamCapacity_SumInvariant() } } - // give time to update the count - await Task.Delay(1000); + // wait for the callback + while (maxStreamIndex < 3 * Limit) + { + await streamsAvailableFired.WaitAsync().WaitAsync(PassingTestTimeout); + } // by now, we opened and closed 2 * Limit, and expect a budget of 'Limit' more Assert.Equal(3 * Limit, maxStreamIndex); diff --git a/src/libraries/System.Net.Quic/tests/FunctionalTests/QuicTestCollection.cs b/src/libraries/System.Net.Quic/tests/FunctionalTests/QuicTestCollection.cs index 3ee181108b4..699a41fcd10 100644 --- a/src/libraries/System.Net.Quic/tests/FunctionalTests/QuicTestCollection.cs +++ b/src/libraries/System.Net.Quic/tests/FunctionalTests/QuicTestCollection.cs @@ -14,7 +14,7 @@ namespace System.Net.Quic.Tests; -[CollectionDefinition(nameof(QuicTestCollection), DisableParallelization = true)] +[CollectionDefinition(nameof(QuicTestCollection))] public unsafe class QuicTestCollection : ICollectionFixture, IDisposable { public static bool IsSupported => QuicListener.IsSupported && QuicConnection.IsSupported; diff --git a/src/libraries/System.Net.Quic/tests/FunctionalTests/System.Net.Quic.Functional.Tests.csproj b/src/libraries/System.Net.Quic/tests/FunctionalTests/System.Net.Quic.Functional.Tests.csproj index e4b36b9dab6..3ac6d417fa0 100644 --- a/src/libraries/System.Net.Quic/tests/FunctionalTests/System.Net.Quic.Functional.Tests.csproj +++ b/src/libraries/System.Net.Quic/tests/FunctionalTests/System.Net.Quic.Functional.Tests.csproj @@ -5,7 +5,6 @@ $(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-linux;$(NetCoreAppCurrent)-osx true ../../src/Resources/Strings.resx - $(NoWarn);SYSLIB0057 diff --git a/src/libraries/System.Net.Requests/Directory.Build.props b/src/libraries/System.Net.Requests/Directory.Build.props index ce244cbea56..58979d42f06 100644 --- a/src/libraries/System.Net.Requests/Directory.Build.props +++ b/src/libraries/System.Net.Requests/Directory.Build.props @@ -3,6 +3,6 @@ Microsoft true - browser + browser;wasi \ No newline at end of file diff --git a/src/libraries/System.Net.Requests/System.Net.Requests.sln b/src/libraries/System.Net.Requests/System.Net.Requests.sln index fbbada2e9ad..df09a721888 100644 --- a/src/libraries/System.Net.Requests/System.Net.Requests.sln +++ b/src/libraries/System.Net.Requests/System.Net.Requests.sln @@ -35,6 +35,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ObjectModel", "..\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{BE1267C9-2847-4BD0-BBC9-B9ABEB567F08}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{5790F286-A285-474E-B1C6-13A60A2247B7}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{622D51A8-954A-401B-91FD-21E650F2DE46}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{CE27441A-4D2F-4A63-8D02-148A0C51CA47}" @@ -151,6 +153,10 @@ Global {BE1267C9-2847-4BD0-BBC9-B9ABEB567F08}.Debug|Any CPU.Build.0 = Debug|Any CPU {BE1267C9-2847-4BD0-BBC9-B9ABEB567F08}.Release|Any CPU.ActiveCfg = Release|Any CPU {BE1267C9-2847-4BD0-BBC9-B9ABEB567F08}.Release|Any CPU.Build.0 = Release|Any CPU + {5790F286-A285-474E-B1C6-13A60A2247B7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {5790F286-A285-474E-B1C6-13A60A2247B7}.Debug|Any CPU.Build.0 = Debug|Any CPU + {5790F286-A285-474E-B1C6-13A60A2247B7}.Release|Any CPU.ActiveCfg = Release|Any CPU + {5790F286-A285-474E-B1C6-13A60A2247B7}.Release|Any CPU.Build.0 = Release|Any CPU {622D51A8-954A-401B-91FD-21E650F2DE46}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {622D51A8-954A-401B-91FD-21E650F2DE46}.Debug|Any CPU.Build.0 = Debug|Any CPU {622D51A8-954A-401B-91FD-21E650F2DE46}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -222,6 +228,7 @@ Global {FECA1242-D76F-4CA0-A0E7-289209B2BCC0} = {DB20495E-C9F0-4640-85A6-ACEF17C21670} {CCD28DAE-FEF6-4732-A985-B814A95B3408} = {BE29C1CE-D2BC-43F8-9412-50F870CE5538} {BE1267C9-2847-4BD0-BBC9-B9ABEB567F08} = {BCB9D4DE-1EC1-4826-A80F-E4D2E960D98D} + {5790F286-A285-474E-B1C6-13A60A2247B7} = {BCB9D4DE-1EC1-4826-A80F-E4D2E960D98D} {622D51A8-954A-401B-91FD-21E650F2DE46} = {BCB9D4DE-1EC1-4826-A80F-E4D2E960D98D} {CE27441A-4D2F-4A63-8D02-148A0C51CA47} = {BCB9D4DE-1EC1-4826-A80F-E4D2E960D98D} {D865D8D5-7D19-4D98-BED2-3D7B4FC3C4B2} = {DC7F204D-9592-4EDD-9ED0-21B2BF53FA1F} diff --git a/src/libraries/System.Net.Requests/src/System.Net.Requests.csproj b/src/libraries/System.Net.Requests/src/System.Net.Requests.csproj index 46bda299d9a..9d879b250d9 100644 --- a/src/libraries/System.Net.Requests/src/System.Net.Requests.csproj +++ b/src/libraries/System.Net.Requests/src/System.Net.Requests.csproj @@ -81,8 +81,6 @@ Link="Common\System\Net\ContextAwareResult.cs" /> - - { - try - { - tlsStream.EndAuthenticateAsClient(ar); - NetworkStream = tlsStream; - this.ContinueCommandPipeline(); - } - catch (Exception e) + sslStream.BeginAuthenticateAsClient( + request.RequestUri.Host, + request.ClientCertificates, + (SslProtocols)ServicePointManager.SecurityProtocol, // enums use same values + ServicePointManager.CheckCertificateRevocationList, + ar => { - this.CloseSocket(); - this.InvokeRequestCallback(e); - } - }, null); + try + { + sslStream.EndAuthenticateAsClient(ar); + Stream = sslStream; + this.ContinueCommandPipeline(); + } + catch (Exception e) + { + this.CloseSocket(); + this.InvokeRequestCallback(e); + } + }, + null); return PipelineInstruction.Pause; } else { - tlsStream.AuthenticateAsClient(); - NetworkStream = tlsStream; + sslStream.AuthenticateAsClient( + request.RequestUri.Host, + request.ClientCertificates, + (SslProtocols)ServicePointManager.SecurityProtocol, // enums use same values + ServicePointManager.CheckCertificateRevocationList); + Stream = sslStream; } } +#pragma warning restore SYSLIB0014 // ServicePointManager is obsolete } // OR parse out the file size or file time, usually a result of sending SIZE/MDTM commands else if (status == FtpStatusCode.FileStatus) diff --git a/src/libraries/System.Net.Requests/src/System/Net/FtpDataStream.cs b/src/libraries/System.Net.Requests/src/System/Net/FtpDataStream.cs index 9cd8b06a610..129052a9713 100644 --- a/src/libraries/System.Net.Requests/src/System/Net/FtpDataStream.cs +++ b/src/libraries/System.Net.Requests/src/System/Net/FtpDataStream.cs @@ -2,6 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. using System.IO; +using System.Net.Security; using System.Net.Sockets; using System.Runtime.ExceptionServices; @@ -15,7 +16,8 @@ namespace System.Net internal sealed class FtpDataStream : Stream, ICloseEx { private readonly FtpWebRequest _request; - private readonly NetworkStream _networkStream; + private readonly Stream _stream; + private readonly NetworkStream _originalStream; private bool _writeable; private bool _readable; private bool _isFullyRead; @@ -23,7 +25,7 @@ internal sealed class FtpDataStream : Stream, ICloseEx private const int DefaultCloseTimeout = -1; - internal FtpDataStream(NetworkStream networkStream, FtpWebRequest request, TriState writeOnly) + internal FtpDataStream(Stream stream, NetworkStream originalStream, FtpWebRequest request, TriState writeOnly) { if (NetEventSource.Log.IsEnabled()) NetEventSource.Info(this); @@ -37,7 +39,8 @@ internal FtpDataStream(NetworkStream networkStream, FtpWebRequest request, TriSt { _writeable = false; } - _networkStream = networkStream; + _stream = stream; + _originalStream = originalStream; _request = request; } @@ -75,9 +78,9 @@ void ICloseEx.CloseEx(CloseExState closeState) try { if ((closeState & CloseExState.Abort) == 0) - _networkStream.Close(DefaultCloseTimeout); + _originalStream.Close(DefaultCloseTimeout); else - _networkStream.Close(0); + _originalStream.Close(0); } finally { @@ -125,7 +128,7 @@ public override bool CanSeek { get { - return _networkStream.CanSeek; + return _stream.CanSeek; } } @@ -141,7 +144,7 @@ public override long Length { get { - return _networkStream.Length; + return _stream.Length; } } @@ -149,12 +152,12 @@ public override long Position { get { - return _networkStream.Position; + return _stream.Position; } set { - _networkStream.Position = value; + _stream.Position = value; } } @@ -163,7 +166,7 @@ public override long Seek(long offset, SeekOrigin origin) CheckError(); try { - return _networkStream.Seek(offset, origin); + return _stream.Seek(offset, origin); } catch { @@ -178,7 +181,7 @@ public override int Read(byte[] buffer, int offset, int size) int readBytes; try { - readBytes = _networkStream.Read(buffer, offset, size); + readBytes = _stream.Read(buffer, offset, size); } catch { @@ -199,7 +202,7 @@ public override int Read(Span buffer) int readBytes; try { - readBytes = _networkStream.Read(buffer); + readBytes = _stream.Read(buffer); } catch { @@ -219,7 +222,7 @@ public override void Write(byte[] buffer, int offset, int size) CheckError(); try { - _networkStream.Write(buffer, offset, size); + _stream.Write(buffer, offset, size); } catch { @@ -233,7 +236,7 @@ public override void Write(ReadOnlySpan buffer) CheckError(); try { - _networkStream.Write(buffer); + _stream.Write(buffer); } catch { @@ -249,7 +252,7 @@ private void AsyncReadCallback(IAsyncResult ar) { try { - int readBytes = _networkStream.EndRead(ar); + int readBytes = _stream.EndRead(ar); if (readBytes == 0) { _isFullyRead = true; @@ -273,7 +276,7 @@ public override IAsyncResult BeginRead(byte[] buffer, int offset, int size, Asyn LazyAsyncResult userResult = new LazyAsyncResult(this, state, callback); try { - _networkStream.BeginRead(buffer, offset, size, new AsyncCallback(AsyncReadCallback), userResult); + _stream.BeginRead(buffer, offset, size, new AsyncCallback(AsyncReadCallback), userResult); } catch { @@ -307,7 +310,7 @@ public override IAsyncResult BeginWrite(byte[] buffer, int offset, int size, Asy CheckError(); try { - return _networkStream.BeginWrite(buffer, offset, size, callback, state); + return _stream.BeginWrite(buffer, offset, size, callback, state); } catch { @@ -320,7 +323,7 @@ public override void EndWrite(IAsyncResult asyncResult) { try { - _networkStream.EndWrite(asyncResult); + _stream.EndWrite(asyncResult); } finally { @@ -330,19 +333,19 @@ public override void EndWrite(IAsyncResult asyncResult) public override void Flush() { - _networkStream.Flush(); + _stream.Flush(); } public override void SetLength(long value) { - _networkStream.SetLength(value); + _stream.SetLength(value); } public override bool CanTimeout { get { - return _networkStream.CanTimeout; + return _stream.CanTimeout; } } @@ -350,11 +353,11 @@ public override int ReadTimeout { get { - return _networkStream.ReadTimeout; + return _stream.ReadTimeout; } set { - _networkStream.ReadTimeout = value; + _stream.ReadTimeout = value; } } @@ -362,18 +365,18 @@ public override int WriteTimeout { get { - return _networkStream.WriteTimeout; + return _stream.WriteTimeout; } set { - _networkStream.WriteTimeout = value; + _stream.WriteTimeout = value; } } internal void SetSocketTimeoutOption(int timeout) { - _networkStream.ReadTimeout = timeout; - _networkStream.WriteTimeout = timeout; + _stream.ReadTimeout = timeout; + _stream.WriteTimeout = timeout; } } } diff --git a/src/libraries/System.Net.Requests/src/System/Net/NetworkStreamWrapper.cs b/src/libraries/System.Net.Requests/src/System/Net/NetworkStreamWrapper.cs index 134c773d74a..3d8b4e2604f 100644 --- a/src/libraries/System.Net.Requests/src/System/Net/NetworkStreamWrapper.cs +++ b/src/libraries/System.Net.Requests/src/System/Net/NetworkStreamWrapper.cs @@ -1,7 +1,9 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System.Diagnostics; using System.IO; +using System.Net.Security; using System.Net.Sockets; using System.Threading; using System.Threading.Tasks; @@ -11,6 +13,7 @@ namespace System.Net internal class NetworkStreamWrapper : Stream { private NetworkStream _networkStream; + private SslStream? _sslStream; internal NetworkStreamWrapper(NetworkStream stream) { @@ -21,7 +24,7 @@ protected bool UsingSecureStream { get { - return (_networkStream is TlsStream); + return _sslStream != null; } } @@ -41,15 +44,17 @@ internal Socket Socket } } - internal NetworkStream NetworkStream + internal Stream Stream { get { - return _networkStream; + return (Stream?)_sslStream ?? _networkStream; } set { - _networkStream = value; + // The setter is only used to upgrade to secure connection by wrapping the _networkStream + Debug.Assert(value is SslStream, "Expected SslStream"); + _sslStream = (SslStream)value; } } @@ -57,7 +62,7 @@ public override bool CanRead { get { - return _networkStream.CanRead; + return Stream.CanRead; } } @@ -65,7 +70,7 @@ public override bool CanSeek { get { - return _networkStream.CanSeek; + return Stream.CanSeek; } } @@ -73,7 +78,7 @@ public override bool CanWrite { get { - return _networkStream.CanWrite; + return Stream.CanWrite; } } @@ -81,7 +86,7 @@ public override bool CanTimeout { get { - return _networkStream.CanTimeout; + return Stream.CanTimeout; } } @@ -89,11 +94,11 @@ public override int ReadTimeout { get { - return _networkStream.ReadTimeout; + return Stream.ReadTimeout; } set { - _networkStream.ReadTimeout = value; + Stream.ReadTimeout = value; } } @@ -101,11 +106,11 @@ public override int WriteTimeout { get { - return _networkStream.WriteTimeout; + return Stream.WriteTimeout; } set { - _networkStream.WriteTimeout = value; + Stream.WriteTimeout = value; } } @@ -113,7 +118,7 @@ public override long Length { get { - return _networkStream.Length; + return Stream.Length; } } @@ -121,27 +126,27 @@ public override long Position { get { - return _networkStream.Position; + return Stream.Position; } set { - _networkStream.Position = value; + Stream.Position = value; } } public override long Seek(long offset, SeekOrigin origin) { - return _networkStream.Seek(offset, origin); + return Stream.Seek(offset, origin); } public override int Read(byte[] buffer, int offset, int size) { - return _networkStream.Read(buffer, offset, size); + return Stream.Read(buffer, offset, size); } public override void Write(byte[] buffer, int offset, int size) { - _networkStream.Write(buffer, offset, size); + Stream.Write(buffer, offset, size); } protected override void Dispose(bool disposing) @@ -162,7 +167,7 @@ protected override void Dispose(bool disposing) internal void CloseSocket() { - _networkStream.Close(); + Stream.Close(); } public void Close(int timeout) @@ -172,63 +177,63 @@ public void Close(int timeout) public override IAsyncResult BeginRead(byte[] buffer, int offset, int size, AsyncCallback? callback, object? state) { - return _networkStream.BeginRead(buffer, offset, size, callback, state); + return Stream.BeginRead(buffer, offset, size, callback, state); } public override int EndRead(IAsyncResult asyncResult) { - return _networkStream.EndRead(asyncResult); + return Stream.EndRead(asyncResult); } public override Task ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) { - return _networkStream.ReadAsync(buffer, offset, count, cancellationToken); + return Stream.ReadAsync(buffer, offset, count, cancellationToken); } public override ValueTask ReadAsync(Memory buffer, CancellationToken cancellationToken = default) { - return _networkStream.ReadAsync(buffer, cancellationToken); + return Stream.ReadAsync(buffer, cancellationToken); } public override IAsyncResult BeginWrite(byte[] buffer, int offset, int size, AsyncCallback? callback, object? state) { - return _networkStream.BeginWrite(buffer, offset, size, callback, state); + return Stream.BeginWrite(buffer, offset, size, callback, state); } public override void EndWrite(IAsyncResult asyncResult) { - _networkStream.EndWrite(asyncResult); + Stream.EndWrite(asyncResult); } public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) { - return _networkStream.WriteAsync(buffer, offset, count, cancellationToken); + return Stream.WriteAsync(buffer, offset, count, cancellationToken); } public override ValueTask WriteAsync(ReadOnlyMemory buffer, CancellationToken cancellationToken = default) { - return _networkStream.WriteAsync(buffer, cancellationToken); + return Stream.WriteAsync(buffer, cancellationToken); } public override void Flush() { - _networkStream.Flush(); + Stream.Flush(); } public override Task FlushAsync(CancellationToken cancellationToken) { - return _networkStream.FlushAsync(cancellationToken); + return Stream.FlushAsync(cancellationToken); } public override void SetLength(long value) { - _networkStream.SetLength(value); + Stream.SetLength(value); } internal void SetSocketTimeoutOption(int timeout) { - _networkStream.ReadTimeout = timeout; - _networkStream.WriteTimeout = timeout; + Stream.ReadTimeout = timeout; + Stream.WriteTimeout = timeout; } } } // System.Net diff --git a/src/libraries/System.Net.Requests/tests/System.Net.Requests.Tests.csproj b/src/libraries/System.Net.Requests/tests/System.Net.Requests.Tests.csproj index a1574b47b66..4beb82617ee 100644 --- a/src/libraries/System.Net.Requests/tests/System.Net.Requests.Tests.csproj +++ b/src/libraries/System.Net.Requests/tests/System.Net.Requests.Tests.csproj @@ -6,7 +6,7 @@ $(DefineConstants);NETSTANDARD true - $(NoWarn);SYSLIB0014;SYSLIB0057 + $(NoWarn);SYSLIB0014 true true @@ -53,5 +53,9 @@ + + diff --git a/src/libraries/System.Net.Security/Directory.Build.props b/src/libraries/System.Net.Security/Directory.Build.props index ce244cbea56..58979d42f06 100644 --- a/src/libraries/System.Net.Security/Directory.Build.props +++ b/src/libraries/System.Net.Security/Directory.Build.props @@ -3,6 +3,6 @@ Microsoft true - browser + browser;wasi \ No newline at end of file diff --git a/src/libraries/System.Net.Security/System.Net.Security.sln b/src/libraries/System.Net.Security/System.Net.Security.sln index 6eb84cc7b74..e85f252d876 100644 --- a/src/libraries/System.Net.Security/System.Net.Security.sln +++ b/src/libraries/System.Net.Security/System.Net.Security.sln @@ -29,6 +29,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Net.Security.Unit.Te EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{756F6023-9F34-4E0E-8D9D-A561BFB8BFF8}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{579FB25B-DEA0-4A9A-A641-6431B7E38FA8}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{F492B006-8C7C-471C-90C4-08C6A28F250A}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{BBF8C38F-E4A7-42E3-AEEB-8A2D08E9FF7E}" @@ -139,6 +141,10 @@ Global {756F6023-9F34-4E0E-8D9D-A561BFB8BFF8}.Debug|Any CPU.Build.0 = Debug|Any CPU {756F6023-9F34-4E0E-8D9D-A561BFB8BFF8}.Release|Any CPU.ActiveCfg = Release|Any CPU {756F6023-9F34-4E0E-8D9D-A561BFB8BFF8}.Release|Any CPU.Build.0 = Release|Any CPU + {579FB25B-DEA0-4A9A-A641-6431B7E38FA8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {579FB25B-DEA0-4A9A-A641-6431B7E38FA8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {579FB25B-DEA0-4A9A-A641-6431B7E38FA8}.Release|Any CPU.ActiveCfg = Release|Any CPU + {579FB25B-DEA0-4A9A-A641-6431B7E38FA8}.Release|Any CPU.Build.0 = Release|Any CPU {F492B006-8C7C-471C-90C4-08C6A28F250A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {F492B006-8C7C-471C-90C4-08C6A28F250A}.Debug|Any CPU.Build.0 = Debug|Any CPU {F492B006-8C7C-471C-90C4-08C6A28F250A}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -222,6 +228,7 @@ Global {20F20695-DB18-47EB-A005-AA432ADCF865} = {70E29C1C-AC9B-4E71-AB74-9906EF973EBF} {80F5CE39-D33D-4CDD-ACD2-FA7597B6CBB1} = {70E29C1C-AC9B-4E71-AB74-9906EF973EBF} {756F6023-9F34-4E0E-8D9D-A561BFB8BFF8} = {29A8D8F5-27EF-44B7-8C71-FC4E2D10EBBA} + {579FB25B-DEA0-4A9A-A641-6431B7E38FA8} = {29A8D8F5-27EF-44B7-8C71-FC4E2D10EBBA} {F492B006-8C7C-471C-90C4-08C6A28F250A} = {29A8D8F5-27EF-44B7-8C71-FC4E2D10EBBA} {BBF8C38F-E4A7-42E3-AEEB-8A2D08E9FF7E} = {29A8D8F5-27EF-44B7-8C71-FC4E2D10EBBA} {BBC4D81D-C03E-455A-A294-0EC91581AC61} = {3E6CB661-AA4C-477E-8747-2D2852A5B3C4} diff --git a/src/libraries/System.Net.Security/src/ILLink/ILLink.Substitutions.xml b/src/libraries/System.Net.Security/src/ILLink/ILLink.Substitutions.xml deleted file mode 100644 index 8c56e81a9bb..00000000000 --- a/src/libraries/System.Net.Security/src/ILLink/ILLink.Substitutions.xml +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/src/libraries/System.Net.Security/src/System.Net.Security.csproj b/src/libraries/System.Net.Security/src/System.Net.Security.csproj index 37d2d52b4f4..ecf71f7c0f5 100644 --- a/src/libraries/System.Net.Security/src/System.Net.Security.csproj +++ b/src/libraries/System.Net.Security/src/System.Net.Security.csproj @@ -295,7 +295,6 @@ - diff --git a/src/libraries/System.Net.Security/src/System/Net/NegotiateAuthenticationPal.Unix.cs b/src/libraries/System.Net.Security/src/System/Net/NegotiateAuthenticationPal.Unix.cs index e1735a65a6f..77c3a3454b1 100644 --- a/src/libraries/System.Net.Security/src/System/Net/NegotiateAuthenticationPal.Unix.cs +++ b/src/libraries/System.Net.Security/src/System/Net/NegotiateAuthenticationPal.Unix.cs @@ -21,6 +21,8 @@ internal partial class NegotiateAuthenticationPal { private static readonly Lazy _hasSystemNetSecurityNative = new Lazy(CheckHasSystemNetSecurityNative); internal static bool HasSystemNetSecurityNative => _hasSystemNetSecurityNative.Value; + + [FeatureSwitchDefinition("System.Net.Security.UseManagedNtlm")] private static bool UseManagedNtlm { get; } = AppContext.TryGetSwitch("System.Net.Security.UseManagedNtlm", out bool useManagedNtlm) ? useManagedNtlm : diff --git a/src/libraries/System.Net.Security/src/System/Net/NegotiateAuthenticationPal.Windows.cs b/src/libraries/System.Net.Security/src/System/Net/NegotiateAuthenticationPal.Windows.cs index 226b57ef3e0..8e86d3dc91c 100644 --- a/src/libraries/System.Net.Security/src/System/Net/NegotiateAuthenticationPal.Windows.cs +++ b/src/libraries/System.Net.Security/src/System/Net/NegotiateAuthenticationPal.Windows.cs @@ -587,8 +587,7 @@ public override unsafe void GetMIC(ReadOnlySpan message, IBufferWriter SslStream_StreamToStream_Authentication_Succ using (X509Certificate2 clientCert = Configuration.Certificates.GetClientCertificate()) { yield return new object[] { new X509Certificate2(serverCert), new X509Certificate2(clientCert) }; +#pragma warning disable SYSLIB0057 // Test case is explicitly testing X509Certificate instances. yield return new object[] { new X509Certificate(serverCert.Export(X509ContentType.Pfx), (string)null), new X509Certificate(clientCert.Export(X509ContentType.Pfx), (string)null) }; +#pragma warning restore SYSLIB0057 } } diff --git a/src/libraries/System.Net.Security/tests/FunctionalTests/System.Net.Security.Tests.csproj b/src/libraries/System.Net.Security/tests/FunctionalTests/System.Net.Security.Tests.csproj index 41577cfe249..6fca6cd05e3 100644 --- a/src/libraries/System.Net.Security/tests/FunctionalTests/System.Net.Security.Tests.csproj +++ b/src/libraries/System.Net.Security/tests/FunctionalTests/System.Net.Security.Tests.csproj @@ -6,7 +6,6 @@ true true true - $(NoWarn);SYSLIB0057 @@ -165,5 +164,9 @@ + + diff --git a/src/libraries/System.Net.Security/tests/FunctionalTests/TelemetryTest.cs b/src/libraries/System.Net.Security/tests/FunctionalTests/TelemetryTest.cs index 393c62140d5..667bc13ad38 100644 --- a/src/libraries/System.Net.Security/tests/FunctionalTests/TelemetryTest.cs +++ b/src/libraries/System.Net.Security/tests/FunctionalTests/TelemetryTest.cs @@ -126,6 +126,8 @@ await RemoteExecutor.Invoke(async () => using var listener = new TestEventListener("System.Net.Security", EventLevel.Verbose, eventCounterInterval: 0.1d); listener.AddActivityTracking(); + await PrepareEventCountersAsync(listener); + var events = new ConcurrentQueue<(EventWrittenEventArgs Event, Guid ActivityId)>(); await listener.RunWithCallbackAsync(e => { @@ -184,6 +186,7 @@ await listener.RunWithCallbackAsync(e => [OuterLoop] [ConditionalFact(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))] + [SkipOnPlatform(TestPlatforms.iOS | TestPlatforms.tvOS, "X509 certificate store is not supported on iOS or tvOS.")] // Match SslStream_StreamToStream_Authentication_Success public static async Task EventSource_UnsuccessfulHandshake_LogsStartFailureStop() { await RemoteExecutor.Invoke(async () => @@ -191,6 +194,8 @@ await RemoteExecutor.Invoke(async () => using var listener = new TestEventListener("System.Net.Security", EventLevel.Verbose, eventCounterInterval: 0.1d); listener.AddActivityTracking(); + await PrepareEventCountersAsync(listener); + var events = new ConcurrentQueue<(EventWrittenEventArgs Event, Guid ActivityId)>(); await listener.RunWithCallbackAsync(e => { @@ -279,7 +284,8 @@ private static void VerifyEventCounters(ConcurrentQueue<(EventWrittenEventArgs E .ToDictionary(p => p.Key, p => p.ToArray()); Assert.True(eventCounters.TryGetValue("total-tls-handshakes", out double[] totalHandshakes)); - Assert.Equal(2, totalHandshakes[^1]); + // 4 instead of 2 to account for the handshake we made in PrepareEventCountersAsync. + Assert.Equal(4, totalHandshakes[^1]); Assert.True(eventCounters.TryGetValue("tls-handshake-rate", out double[] handshakeRate)); Assert.Contains(handshakeRate, r => r > 0); @@ -352,5 +358,24 @@ static bool IsTlsHandshakeRateEventCounter(EventWrittenEventArgs e) return (string)dictionary["Name"] == "tls-handshake-rate"; } } + + private static async Task PrepareEventCountersAsync(TestEventListener listener) + { + // There is a race condition in EventSource where counters using IncrementingPollingCounter + // will drop increments that happened before the background timer thread first runs. + // See https://github.com/dotnet/runtime/issues/106268#issuecomment-2284626183. + // To workaround this issue, we ensure that the EventCounters timer is running before + // executing any of the interesting logic under test. + + var events = new ConcurrentQueue<(EventWrittenEventArgs Event, Guid ActivityId)>(); + + await listener.RunWithCallbackAsync(e => events.Enqueue((e, e.ActivityId)), async () => + { + var test = new SslStreamStreamToStreamTest_Async(); + await test.SslStream_StreamToStream_Authentication_Success(); + + await WaitForEventCountersAsync(events); + }); + } } } diff --git a/src/libraries/System.Net.Security/tests/UnitTests/SslAuthenticationOptionsTests.cs b/src/libraries/System.Net.Security/tests/UnitTests/SslAuthenticationOptionsTests.cs index f1ce91870d8..b7e9d29d9dd 100644 --- a/src/libraries/System.Net.Security/tests/UnitTests/SslAuthenticationOptionsTests.cs +++ b/src/libraries/System.Net.Security/tests/UnitTests/SslAuthenticationOptionsTests.cs @@ -109,7 +109,9 @@ public void ServerCertificate_Get_Set_Succeeds() _serverOptions.ServerCertificate = null; Assert.Null(_serverOptions.ServerCertificate); +#pragma warning disable SYSLIB0057 X509Certificate cert = new X509Certificate2(stackalloc byte[0]); +#pragma warning restore SYSLIB0057 _serverOptions.ServerCertificate = cert; Assert.Equal(cert, _serverOptions.ServerCertificate); diff --git a/src/libraries/System.Net.Security/tests/UnitTests/System.Net.Security.Unit.Tests.csproj b/src/libraries/System.Net.Security/tests/UnitTests/System.Net.Security.Unit.Tests.csproj index d6a5bc1eb22..d35de6d843f 100644 --- a/src/libraries/System.Net.Security/tests/UnitTests/System.Net.Security.Unit.Tests.csproj +++ b/src/libraries/System.Net.Security/tests/UnitTests/System.Net.Security.Unit.Tests.csproj @@ -9,7 +9,7 @@ --> $(NoWarn);436 - $(NoWarn);3021;SYSLIB0057 + $(NoWarn);3021 $(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-unix;$(NetCoreAppCurrent)-browser;$(NetCoreAppCurrent)-osx;$(NetCoreAppCurrent)-ios;$(NetCoreAppCurrent)-android true diff --git a/src/libraries/System.Net.ServerSentEvents/System.Net.ServerSentEvents.sln b/src/libraries/System.Net.ServerSentEvents/System.Net.ServerSentEvents.sln index 2886ac6101c..4458b9fbda4 100644 --- a/src/libraries/System.Net.ServerSentEvents/System.Net.ServerSentEvents.sln +++ b/src/libraries/System.Net.ServerSentEvents/System.Net.ServerSentEvents.sln @@ -9,7 +9,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Net.ServerSentEvents EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Net.ServerSentEvents.Tests", "tests\System.Net.ServerSentEvents.Tests.csproj", "{804B5D44-05A3-491E-A6AB-35C592E6703E}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{33029DED-2918-452F-833E-F506330D9E72}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{1D75DFDD-AE1C-46E6-8EF9-36D34FFB3629}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{CD89F5C5-432A-47EC-AF48-B9F87B7D19DA}" EndProject @@ -65,10 +65,10 @@ Global {804B5D44-05A3-491E-A6AB-35C592E6703E}.Debug|Any CPU.Build.0 = Debug|Any CPU {804B5D44-05A3-491E-A6AB-35C592E6703E}.Release|Any CPU.ActiveCfg = Release|Any CPU {804B5D44-05A3-491E-A6AB-35C592E6703E}.Release|Any CPU.Build.0 = Release|Any CPU - {33029DED-2918-452F-833E-F506330D9E72}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {33029DED-2918-452F-833E-F506330D9E72}.Debug|Any CPU.Build.0 = Debug|Any CPU - {33029DED-2918-452F-833E-F506330D9E72}.Release|Any CPU.ActiveCfg = Release|Any CPU - {33029DED-2918-452F-833E-F506330D9E72}.Release|Any CPU.Build.0 = Release|Any CPU + {1D75DFDD-AE1C-46E6-8EF9-36D34FFB3629}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {1D75DFDD-AE1C-46E6-8EF9-36D34FFB3629}.Debug|Any CPU.Build.0 = Debug|Any CPU + {1D75DFDD-AE1C-46E6-8EF9-36D34FFB3629}.Release|Any CPU.ActiveCfg = Release|Any CPU + {1D75DFDD-AE1C-46E6-8EF9-36D34FFB3629}.Release|Any CPU.Build.0 = Release|Any CPU {CD89F5C5-432A-47EC-AF48-B9F87B7D19DA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {CD89F5C5-432A-47EC-AF48-B9F87B7D19DA}.Debug|Any CPU.Build.0 = Debug|Any CPU {CD89F5C5-432A-47EC-AF48-B9F87B7D19DA}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -103,7 +103,7 @@ Global {6805DD08-6B8B-410D-B1D7-B89D5AB74249} = {D908DCBE-EFA4-4CCA-9A1C-AEB48D59C504} {ACDB56AF-7B9F-4762-9764-D6FF09118D09} = {D908DCBE-EFA4-4CCA-9A1C-AEB48D59C504} {ACB7E0BF-015F-43DC-A2F5-85506173B223} = {E6AF8CEE-6550-4190-97D4-D51C5B114919} - {33029DED-2918-452F-833E-F506330D9E72} = {704CC916-D4A9-48AF-99ED-9A155CD6E799} + {1D75DFDD-AE1C-46E6-8EF9-36D34FFB3629} = {704CC916-D4A9-48AF-99ED-9A155CD6E799} {CD89F5C5-432A-47EC-AF48-B9F87B7D19DA} = {704CC916-D4A9-48AF-99ED-9A155CD6E799} {53CEE09C-60EC-40E9-BB8C-C2C1223A1FD0} = {C83F4479-3081-4407-B7F9-20EE839BB75C} {B65038BE-C7FC-4B81-9ACA-54D9794556A4} = {C83F4479-3081-4407-B7F9-20EE839BB75C} diff --git a/src/libraries/System.Net.ServerSentEvents/src/System/Net/ServerSentEvents/SseParser.cs b/src/libraries/System.Net.ServerSentEvents/src/System/Net/ServerSentEvents/SseParser.cs index 26543247aac..d25a10a4ec5 100644 --- a/src/libraries/System.Net.ServerSentEvents/src/System/Net/ServerSentEvents/SseParser.cs +++ b/src/libraries/System.Net.ServerSentEvents/src/System/Net/ServerSentEvents/SseParser.cs @@ -17,7 +17,7 @@ public static class SseParser /// Creates a parser for parsing a of server-sent events into a sequence of values. /// The stream containing the data to parse. /// - /// The enumerable of strings, which may be enumerated synchronously or asynchronously. The strings + /// The enumerable of strings, which can be enumerated synchronously or asynchronously. The strings /// are decoded from the UTF8-encoded bytes of the payload of each event. /// /// is null. @@ -32,9 +32,8 @@ public static SseParser Create(Stream sseStream) => /// Specifies the type of data in each event. /// The stream containing the data to parse. /// The parser to use to transform each payload of bytes into a data element. - /// The enumerable, which may be enumerated synchronously or asynchronously. - /// is null. - /// is null. + /// The enumerable, which can be enumerated synchronously or asynchronously. + /// or is null. public static SseParser Create(Stream sseStream, SseItemParser itemParser) => new SseParser( sseStream ?? throw new ArgumentNullException(nameof(sseStream)), diff --git a/src/libraries/System.Net.ServerSentEvents/tests/System.Net.ServerSentEvents.Tests.csproj b/src/libraries/System.Net.ServerSentEvents/tests/System.Net.ServerSentEvents.Tests.csproj index e2b3d73610d..ca685119d3d 100644 --- a/src/libraries/System.Net.ServerSentEvents/tests/System.Net.ServerSentEvents.Tests.csproj +++ b/src/libraries/System.Net.ServerSentEvents/tests/System.Net.ServerSentEvents.Tests.csproj @@ -10,10 +10,11 @@ + - + diff --git a/src/libraries/System.Net.Sockets/Directory.Build.props b/src/libraries/System.Net.Sockets/Directory.Build.props index ce244cbea56..bc799605d32 100644 --- a/src/libraries/System.Net.Sockets/Directory.Build.props +++ b/src/libraries/System.Net.Sockets/Directory.Build.props @@ -3,6 +3,7 @@ Microsoft true - browser + + browser;wasi \ No newline at end of file diff --git a/src/libraries/System.Net.Sockets/System.Net.Sockets.sln b/src/libraries/System.Net.Sockets/System.Net.Sockets.sln index edac3bf4a63..71ed686fe97 100644 --- a/src/libraries/System.Net.Sockets/System.Net.Sockets.sln +++ b/src/libraries/System.Net.Sockets/System.Net.Sockets.sln @@ -17,6 +17,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Net.Sockets.Tests", EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{85782EDD-90A7-4600-89EB-4E2C0AAAD446}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{B338EB04-67CE-4AD0-A691-A93194B871EF}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{0CAE4AA4-2C81-4CA4-978A-F86DD25FA338}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{3DD27643-568B-4BA1-82F2-FACFC8365836}" @@ -93,6 +95,10 @@ Global {85782EDD-90A7-4600-89EB-4E2C0AAAD446}.Debug|Any CPU.Build.0 = Debug|Any CPU {85782EDD-90A7-4600-89EB-4E2C0AAAD446}.Release|Any CPU.ActiveCfg = Release|Any CPU {85782EDD-90A7-4600-89EB-4E2C0AAAD446}.Release|Any CPU.Build.0 = Release|Any CPU + {B338EB04-67CE-4AD0-A691-A93194B871EF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {B338EB04-67CE-4AD0-A691-A93194B871EF}.Debug|Any CPU.Build.0 = Debug|Any CPU + {B338EB04-67CE-4AD0-A691-A93194B871EF}.Release|Any CPU.ActiveCfg = Release|Any CPU + {B338EB04-67CE-4AD0-A691-A93194B871EF}.Release|Any CPU.Build.0 = Release|Any CPU {0CAE4AA4-2C81-4CA4-978A-F86DD25FA338}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {0CAE4AA4-2C81-4CA4-978A-F86DD25FA338}.Debug|Any CPU.Build.0 = Debug|Any CPU {0CAE4AA4-2C81-4CA4-978A-F86DD25FA338}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -145,6 +151,7 @@ Global {F7A848B6-8307-4702-AEEE-20223FB73F29} = {FC5FEA3E-33B9-4AEE-8E41-367BB73182EF} {FD313302-FE04-414E-8A62-3BC8894115C1} = {2C7108F0-035E-44A5-8451-FE9535F53D43} {85782EDD-90A7-4600-89EB-4E2C0AAAD446} = {51E336C9-CFE7-4459-B407-FD5D9E760D85} + {B338EB04-67CE-4AD0-A691-A93194B871EF} = {51E336C9-CFE7-4459-B407-FD5D9E760D85} {0CAE4AA4-2C81-4CA4-978A-F86DD25FA338} = {51E336C9-CFE7-4459-B407-FD5D9E760D85} {3DD27643-568B-4BA1-82F2-FACFC8365836} = {51E336C9-CFE7-4459-B407-FD5D9E760D85} {FA256A4B-476D-4BCA-8E62-C2A11DF778CE} = {CCBA19A8-17AB-402A-96E6-A1C92784EAC2} diff --git a/src/libraries/System.Net.WebClient/Directory.Build.props b/src/libraries/System.Net.WebClient/Directory.Build.props index c843a6347ce..3a3d8f98324 100644 --- a/src/libraries/System.Net.WebClient/Directory.Build.props +++ b/src/libraries/System.Net.WebClient/Directory.Build.props @@ -2,6 +2,6 @@ true - browser + browser;wasi \ No newline at end of file diff --git a/src/libraries/System.Net.WebClient/System.Net.WebClient.sln b/src/libraries/System.Net.WebClient/System.Net.WebClient.sln index 15bf0c83ad1..ad17627dfbd 100644 --- a/src/libraries/System.Net.WebClient/System.Net.WebClient.sln +++ b/src/libraries/System.Net.WebClient/System.Net.WebClient.sln @@ -35,7 +35,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Net.WebHeaderCollect EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ObjectModel", "..\System.ObjectModel\ref\System.ObjectModel.csproj", "{4432D817-DE4F-4E6B-8269-B20D0B83EC95}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{992323BD-CC20-4630-AFD2-1483726305B8}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{641D46A6-8E51-488E-84F3-7DECF484FF76}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{B1389C0F-EAEB-4E1A-AA8F-8A3CED861A2D}" EndProject @@ -153,10 +153,10 @@ Global {4432D817-DE4F-4E6B-8269-B20D0B83EC95}.Debug|Any CPU.Build.0 = Debug|Any CPU {4432D817-DE4F-4E6B-8269-B20D0B83EC95}.Release|Any CPU.ActiveCfg = Release|Any CPU {4432D817-DE4F-4E6B-8269-B20D0B83EC95}.Release|Any CPU.Build.0 = Release|Any CPU - {992323BD-CC20-4630-AFD2-1483726305B8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {992323BD-CC20-4630-AFD2-1483726305B8}.Debug|Any CPU.Build.0 = Debug|Any CPU - {992323BD-CC20-4630-AFD2-1483726305B8}.Release|Any CPU.ActiveCfg = Release|Any CPU - {992323BD-CC20-4630-AFD2-1483726305B8}.Release|Any CPU.Build.0 = Release|Any CPU + {641D46A6-8E51-488E-84F3-7DECF484FF76}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {641D46A6-8E51-488E-84F3-7DECF484FF76}.Debug|Any CPU.Build.0 = Debug|Any CPU + {641D46A6-8E51-488E-84F3-7DECF484FF76}.Release|Any CPU.ActiveCfg = Release|Any CPU + {641D46A6-8E51-488E-84F3-7DECF484FF76}.Release|Any CPU.Build.0 = Release|Any CPU {B1389C0F-EAEB-4E1A-AA8F-8A3CED861A2D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {B1389C0F-EAEB-4E1A-AA8F-8A3CED861A2D}.Debug|Any CPU.Build.0 = Debug|Any CPU {B1389C0F-EAEB-4E1A-AA8F-8A3CED861A2D}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -229,7 +229,7 @@ Global {ADBF4DA3-5649-4DC4-85DF-9488FD184E88} = {33D25EB4-FCAA-41F3-B411-5946DEF7CEFE} {1E3C8397-415C-46A7-B1BE-890F6FBEF34F} = {33D25EB4-FCAA-41F3-B411-5946DEF7CEFE} {18F1E6CD-3568-4042-9EC3-6430FD60EC3A} = {ECCD7E4F-3B41-4CEA-AF93-152825598039} - {992323BD-CC20-4630-AFD2-1483726305B8} = {EBEFBFED-2B7D-4133-8D79-0F61D6E8A085} + {641D46A6-8E51-488E-84F3-7DECF484FF76} = {EBEFBFED-2B7D-4133-8D79-0F61D6E8A085} {B1389C0F-EAEB-4E1A-AA8F-8A3CED861A2D} = {EBEFBFED-2B7D-4133-8D79-0F61D6E8A085} {E2C1D03D-DA79-4F28-9FF5-C8A5A94332B9} = {8AA84E5D-09EF-4E56-ACFD-6150B5B59EE6} {5FC31AED-6A64-4CA0-B629-49FBA725843D} = {8AA84E5D-09EF-4E56-ACFD-6150B5B59EE6} diff --git a/src/libraries/System.Net.WebClient/tests/System.Net.WebClient.Tests.csproj b/src/libraries/System.Net.WebClient/tests/System.Net.WebClient.Tests.csproj index 73cbbc5ce31..e4d983d6e59 100644 --- a/src/libraries/System.Net.WebClient/tests/System.Net.WebClient.Tests.csproj +++ b/src/libraries/System.Net.WebClient/tests/System.Net.WebClient.Tests.csproj @@ -3,7 +3,7 @@ $(NetCoreAppCurrent) $(DefineConstants);NETSTANDARD - $(NoWarn);SYSLIB0014;SYSLIB0057 + $(NoWarn);SYSLIB0014 true diff --git a/src/libraries/System.Net.WebHeaderCollection/System.Net.WebHeaderCollection.sln b/src/libraries/System.Net.WebHeaderCollection/System.Net.WebHeaderCollection.sln index 9d5e3fc2a18..f9982350c91 100644 --- a/src/libraries/System.Net.WebHeaderCollection/System.Net.WebHeaderCollection.sln +++ b/src/libraries/System.Net.WebHeaderCollection/System.Net.WebHeaderCollection.sln @@ -19,7 +19,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Net.WebHeaderCollect EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ObjectModel", "..\System.ObjectModel\ref\System.ObjectModel.csproj", "{62CCF61C-C41C-4B29-9C69-51659AE1EC38}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{A17EB996-964B-4D9F-9859-3DECA2EB9169}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{2A038AB8-8AA6-43F9-BA40-5B410D3DB1CF}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{7987D82C-3F1E-4B4B-B405-08AFD062C7EE}" EndProject @@ -97,10 +97,10 @@ Global {62CCF61C-C41C-4B29-9C69-51659AE1EC38}.Debug|Any CPU.Build.0 = Debug|Any CPU {62CCF61C-C41C-4B29-9C69-51659AE1EC38}.Release|Any CPU.ActiveCfg = Release|Any CPU {62CCF61C-C41C-4B29-9C69-51659AE1EC38}.Release|Any CPU.Build.0 = Release|Any CPU - {A17EB996-964B-4D9F-9859-3DECA2EB9169}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {A17EB996-964B-4D9F-9859-3DECA2EB9169}.Debug|Any CPU.Build.0 = Debug|Any CPU - {A17EB996-964B-4D9F-9859-3DECA2EB9169}.Release|Any CPU.ActiveCfg = Release|Any CPU - {A17EB996-964B-4D9F-9859-3DECA2EB9169}.Release|Any CPU.Build.0 = Release|Any CPU + {2A038AB8-8AA6-43F9-BA40-5B410D3DB1CF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {2A038AB8-8AA6-43F9-BA40-5B410D3DB1CF}.Debug|Any CPU.Build.0 = Debug|Any CPU + {2A038AB8-8AA6-43F9-BA40-5B410D3DB1CF}.Release|Any CPU.ActiveCfg = Release|Any CPU + {2A038AB8-8AA6-43F9-BA40-5B410D3DB1CF}.Release|Any CPU.Build.0 = Release|Any CPU {7987D82C-3F1E-4B4B-B405-08AFD062C7EE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {7987D82C-3F1E-4B4B-B405-08AFD062C7EE}.Debug|Any CPU.Build.0 = Debug|Any CPU {7987D82C-3F1E-4B4B-B405-08AFD062C7EE}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -145,7 +145,7 @@ Global {62CCF61C-C41C-4B29-9C69-51659AE1EC38} = {28B0EDC8-886B-4811-BC62-6FEC32A9E80A} {A7FD80C3-CF4A-4FD5-B649-0056EC7E019C} = {28B0EDC8-886B-4811-BC62-6FEC32A9E80A} {0C54036A-68E7-4D87-AE77-72279D8DC116} = {0F494C94-E4F3-4171-B171-BBB07EF645BE} - {A17EB996-964B-4D9F-9859-3DECA2EB9169} = {7A189071-7ABF-4420-B91C-8ED1DF536EA3} + {2A038AB8-8AA6-43F9-BA40-5B410D3DB1CF} = {7A189071-7ABF-4420-B91C-8ED1DF536EA3} {7987D82C-3F1E-4B4B-B405-08AFD062C7EE} = {7A189071-7ABF-4420-B91C-8ED1DF536EA3} {F7CAF25F-94A6-47B9-8602-0B6DD26A29B6} = {A9F23EA5-5E5B-4887-B2F2-CDFCC7A7CE80} {4CD3B31F-ED1C-4F7E-B75D-79E83185BC33} = {A9F23EA5-5E5B-4887-B2F2-CDFCC7A7CE80} diff --git a/src/libraries/System.Net.WebProxy/System.Net.WebProxy.sln b/src/libraries/System.Net.WebProxy/System.Net.WebProxy.sln index 97b7d711d14..5b1c59f5c10 100644 --- a/src/libraries/System.Net.WebProxy/System.Net.WebProxy.sln +++ b/src/libraries/System.Net.WebProxy/System.Net.WebProxy.sln @@ -19,7 +19,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.Emit.ILGe EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.Primitives", "..\System.Reflection.Primitives\ref\System.Reflection.Primitives.csproj", "{A2B38983-1FFA-4D21-B5EF-39016FEC0535}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{2331FB61-25D7-4954-8289-D0CD834FBF4E}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{428ABE93-EF7F-42B2-8E38-B14303C47A88}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{5B219FB9-034D-4A72-976D-B9ED8412DAD3}" EndProject @@ -101,10 +101,10 @@ Global {A2B38983-1FFA-4D21-B5EF-39016FEC0535}.Debug|Any CPU.Build.0 = Debug|Any CPU {A2B38983-1FFA-4D21-B5EF-39016FEC0535}.Release|Any CPU.ActiveCfg = Release|Any CPU {A2B38983-1FFA-4D21-B5EF-39016FEC0535}.Release|Any CPU.Build.0 = Release|Any CPU - {2331FB61-25D7-4954-8289-D0CD834FBF4E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {2331FB61-25D7-4954-8289-D0CD834FBF4E}.Debug|Any CPU.Build.0 = Debug|Any CPU - {2331FB61-25D7-4954-8289-D0CD834FBF4E}.Release|Any CPU.ActiveCfg = Release|Any CPU - {2331FB61-25D7-4954-8289-D0CD834FBF4E}.Release|Any CPU.Build.0 = Release|Any CPU + {428ABE93-EF7F-42B2-8E38-B14303C47A88}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {428ABE93-EF7F-42B2-8E38-B14303C47A88}.Debug|Any CPU.Build.0 = Debug|Any CPU + {428ABE93-EF7F-42B2-8E38-B14303C47A88}.Release|Any CPU.ActiveCfg = Release|Any CPU + {428ABE93-EF7F-42B2-8E38-B14303C47A88}.Release|Any CPU.Build.0 = Release|Any CPU {5B219FB9-034D-4A72-976D-B9ED8412DAD3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {5B219FB9-034D-4A72-976D-B9ED8412DAD3}.Debug|Any CPU.Build.0 = Debug|Any CPU {5B219FB9-034D-4A72-976D-B9ED8412DAD3}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -159,7 +159,7 @@ Global {11CF89EE-5675-4121-B825-44FFD9FD7FA7} = {5A286671-85EC-4D44-9777-9ED685F78B6C} {F372B1EA-6CB0-47A2-9178-657AF81238BC} = {5A286671-85EC-4D44-9777-9ED685F78B6C} {C841B625-5802-40BE-850C-FA935E3D6E9A} = {B5211952-F905-4BE8-A3CF-25F393F5E506} - {2331FB61-25D7-4954-8289-D0CD834FBF4E} = {5EE792D4-BBEA-43B7-B822-ED01F9F39343} + {428ABE93-EF7F-42B2-8E38-B14303C47A88} = {5EE792D4-BBEA-43B7-B822-ED01F9F39343} {5B219FB9-034D-4A72-976D-B9ED8412DAD3} = {5EE792D4-BBEA-43B7-B822-ED01F9F39343} {9F4F8154-997B-4FEA-887D-BCB76253FDBC} = {76832F3D-F8F9-4A19-85BE-489D9E1C6362} {8D49F54F-B39E-4AEB-BC3F-CEA035241259} = {76832F3D-F8F9-4A19-85BE-489D9E1C6362} diff --git a/src/libraries/System.Net.WebProxy/src/System.Net.WebProxy.csproj b/src/libraries/System.Net.WebProxy/src/System.Net.WebProxy.csproj index ef670932cb9..f23c6072c4d 100644 --- a/src/libraries/System.Net.WebProxy/src/System.Net.WebProxy.csproj +++ b/src/libraries/System.Net.WebProxy/src/System.Net.WebProxy.csproj @@ -1,7 +1,7 @@ - $(NetCoreAppCurrent);$(NetCoreAppCurrent)-browser + $(NetCoreAppCurrent);$(NetCoreAppCurrent)-browser;$(NetCoreAppCurrent)-wasi true false @@ -10,8 +10,8 @@ - - + + diff --git a/src/libraries/System.Net.WebProxy/src/System/Net/WebProxy.NonBrowser.cs b/src/libraries/System.Net.WebProxy/src/System/Net/WebProxy.NonWasm.cs similarity index 100% rename from src/libraries/System.Net.WebProxy/src/System/Net/WebProxy.NonBrowser.cs rename to src/libraries/System.Net.WebProxy/src/System/Net/WebProxy.NonWasm.cs diff --git a/src/libraries/System.Net.WebProxy/src/System/Net/WebProxy.Browser.cs b/src/libraries/System.Net.WebProxy/src/System/Net/WebProxy.Wasm.cs similarity index 100% rename from src/libraries/System.Net.WebProxy/src/System/Net/WebProxy.Browser.cs rename to src/libraries/System.Net.WebProxy/src/System/Net/WebProxy.Wasm.cs diff --git a/src/libraries/System.Net.WebSockets.Client/System.Net.WebSockets.Client.sln b/src/libraries/System.Net.WebSockets.Client/System.Net.WebSockets.Client.sln index 46a6ff8b220..11923e8b1b1 100644 --- a/src/libraries/System.Net.WebSockets.Client/System.Net.WebSockets.Client.sln +++ b/src/libraries/System.Net.WebSockets.Client/System.Net.WebSockets.Client.sln @@ -55,6 +55,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Runtime.InteropServi EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Runtime.InteropServices.JavaScript", "..\System.Runtime.InteropServices.JavaScript\src\System.Runtime.InteropServices.JavaScript.csproj", "{61BC8746-42CB-452E-AF4B-A2555C1DAB2F}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{4F8ABE5C-1400-481D-96E5-5D922713BB72}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{7A0C1B6C-0439-4A1F-95CC-67F04A9657FE}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{6659E37B-9C84-4815-9CAB-19F367D3D66D}" @@ -719,6 +721,27 @@ Global {61BC8746-42CB-452E-AF4B-A2555C1DAB2F}.Checked|arm64.ActiveCfg = Debug|Any CPU {61BC8746-42CB-452E-AF4B-A2555C1DAB2F}.Checked|x64.ActiveCfg = Debug|Any CPU {61BC8746-42CB-452E-AF4B-A2555C1DAB2F}.Checked|x86.ActiveCfg = Debug|Any CPU + {4F8ABE5C-1400-481D-96E5-5D922713BB72}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {4F8ABE5C-1400-481D-96E5-5D922713BB72}.Debug|Any CPU.Build.0 = Debug|Any CPU + {4F8ABE5C-1400-481D-96E5-5D922713BB72}.Debug|arm.ActiveCfg = Debug|Any CPU + {4F8ABE5C-1400-481D-96E5-5D922713BB72}.Debug|arm64.ActiveCfg = Debug|Any CPU + {4F8ABE5C-1400-481D-96E5-5D922713BB72}.Debug|x64.ActiveCfg = Debug|Any CPU + {4F8ABE5C-1400-481D-96E5-5D922713BB72}.Debug|x64.Build.0 = Debug|Any CPU + {4F8ABE5C-1400-481D-96E5-5D922713BB72}.Debug|x86.ActiveCfg = Debug|Any CPU + {4F8ABE5C-1400-481D-96E5-5D922713BB72}.Debug|x86.Build.0 = Debug|Any CPU + {4F8ABE5C-1400-481D-96E5-5D922713BB72}.Release|Any CPU.ActiveCfg = Release|Any CPU + {4F8ABE5C-1400-481D-96E5-5D922713BB72}.Release|Any CPU.Build.0 = Release|Any CPU + {4F8ABE5C-1400-481D-96E5-5D922713BB72}.Release|arm.ActiveCfg = Release|Any CPU + {4F8ABE5C-1400-481D-96E5-5D922713BB72}.Release|arm64.ActiveCfg = Release|Any CPU + {4F8ABE5C-1400-481D-96E5-5D922713BB72}.Release|x64.ActiveCfg = Release|Any CPU + {4F8ABE5C-1400-481D-96E5-5D922713BB72}.Release|x64.Build.0 = Release|Any CPU + {4F8ABE5C-1400-481D-96E5-5D922713BB72}.Release|x86.ActiveCfg = Release|Any CPU + {4F8ABE5C-1400-481D-96E5-5D922713BB72}.Release|x86.Build.0 = Release|Any CPU + {4F8ABE5C-1400-481D-96E5-5D922713BB72}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {4F8ABE5C-1400-481D-96E5-5D922713BB72}.Checked|arm.ActiveCfg = Debug|Any CPU + {4F8ABE5C-1400-481D-96E5-5D922713BB72}.Checked|arm64.ActiveCfg = Debug|Any CPU + {4F8ABE5C-1400-481D-96E5-5D922713BB72}.Checked|x64.ActiveCfg = Debug|Any CPU + {4F8ABE5C-1400-481D-96E5-5D922713BB72}.Checked|x86.ActiveCfg = Debug|Any CPU {7A0C1B6C-0439-4A1F-95CC-67F04A9657FE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {7A0C1B6C-0439-4A1F-95CC-67F04A9657FE}.Debug|Any CPU.Build.0 = Debug|Any CPU {7A0C1B6C-0439-4A1F-95CC-67F04A9657FE}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -1097,6 +1120,7 @@ Global {D6014E91-2DAB-4459-B94A-F1B85EF1D422} = {A0314AC5-E490-4A6A-B946-8B9A21A2FA05} {1EB7F21B-0ED8-426F-B4A0-150BA26B4E64} = {58925E96-1A39-4E29-ACB4-4C4DAB81F60A} {5C036B23-44E0-4F0D-9CE3-DE29E66DFE7E} = {58925E96-1A39-4E29-ACB4-4C4DAB81F60A} + {4F8ABE5C-1400-481D-96E5-5D922713BB72} = {58925E96-1A39-4E29-ACB4-4C4DAB81F60A} {7A0C1B6C-0439-4A1F-95CC-67F04A9657FE} = {58925E96-1A39-4E29-ACB4-4C4DAB81F60A} {6659E37B-9C84-4815-9CAB-19F367D3D66D} = {58925E96-1A39-4E29-ACB4-4C4DAB81F60A} {619B12CC-42E2-472F-9934-BBCEE34BDAD2} = {78DF8970-30DA-4E8C-8ECE-15935940ACD8} diff --git a/src/libraries/System.Net.WebSockets.Client/src/System.Net.WebSockets.Client.csproj b/src/libraries/System.Net.WebSockets.Client/src/System.Net.WebSockets.Client.csproj index 8265edd7e93..3b68c3da977 100644 --- a/src/libraries/System.Net.WebSockets.Client/src/System.Net.WebSockets.Client.csproj +++ b/src/libraries/System.Net.WebSockets.Client/src/System.Net.WebSockets.Client.csproj @@ -4,6 +4,8 @@ $(NetCoreAppCurrent);$(NetCoreAppCurrent)-browser True false + + wasi diff --git a/src/libraries/System.Net.WebSockets.Client/tests/System.Net.WebSockets.Client.Tests.csproj b/src/libraries/System.Net.WebSockets.Client/tests/System.Net.WebSockets.Client.Tests.csproj index af3355cd701..e2918a20b55 100644 --- a/src/libraries/System.Net.WebSockets.Client/tests/System.Net.WebSockets.Client.Tests.csproj +++ b/src/libraries/System.Net.WebSockets.Client/tests/System.Net.WebSockets.Client.Tests.csproj @@ -5,7 +5,6 @@ ../src/Resources/Strings.resx $(NetCoreAppCurrent);$(NetCoreAppCurrent)-browser $(DefineConstants);NETSTANDARD - $(NoWarn);SYSLIB0057 diff --git a/src/libraries/System.Net.WebSockets.Client/tests/wasm/System.Net.WebSockets.Client.Wasm.Tests.csproj b/src/libraries/System.Net.WebSockets.Client/tests/wasm/System.Net.WebSockets.Client.Wasm.Tests.csproj index 296136cf1c2..cd8f38fab54 100644 --- a/src/libraries/System.Net.WebSockets.Client/tests/wasm/System.Net.WebSockets.Client.Wasm.Tests.csproj +++ b/src/libraries/System.Net.WebSockets.Client/tests/wasm/System.Net.WebSockets.Client.Wasm.Tests.csproj @@ -34,12 +34,14 @@ Link="Common\System\Net\Configuration.WebSockets.cs" /> + - + diff --git a/src/libraries/System.Net.WebSockets/System.Net.WebSockets.sln b/src/libraries/System.Net.WebSockets/System.Net.WebSockets.sln index 0c22fe29c74..6d4b2fdc5b4 100644 --- a/src/libraries/System.Net.WebSockets/System.Net.WebSockets.sln +++ b/src/libraries/System.Net.WebSockets/System.Net.WebSockets.sln @@ -25,6 +25,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ObjectModel", "..\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{F98FE3DF-F166-41AA-826D-72318ECC3427}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{BD781F63-5B93-42F6-A72B-02C2E70481F5}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{B59FA95B-262E-4580-AB36-37DB5E16917A}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{41157B1B-46DE-4775-8490-2FF9D9E8E4CA}" @@ -117,6 +119,10 @@ Global {F98FE3DF-F166-41AA-826D-72318ECC3427}.Debug|Any CPU.Build.0 = Debug|Any CPU {F98FE3DF-F166-41AA-826D-72318ECC3427}.Release|Any CPU.ActiveCfg = Release|Any CPU {F98FE3DF-F166-41AA-826D-72318ECC3427}.Release|Any CPU.Build.0 = Release|Any CPU + {BD781F63-5B93-42F6-A72B-02C2E70481F5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {BD781F63-5B93-42F6-A72B-02C2E70481F5}.Debug|Any CPU.Build.0 = Debug|Any CPU + {BD781F63-5B93-42F6-A72B-02C2E70481F5}.Release|Any CPU.ActiveCfg = Release|Any CPU + {BD781F63-5B93-42F6-A72B-02C2E70481F5}.Release|Any CPU.Build.0 = Release|Any CPU {B59FA95B-262E-4580-AB36-37DB5E16917A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {B59FA95B-262E-4580-AB36-37DB5E16917A}.Debug|Any CPU.Build.0 = Debug|Any CPU {B59FA95B-262E-4580-AB36-37DB5E16917A}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -173,6 +179,7 @@ Global {9F9335A3-0158-4A00-8CB0-F8E9CAC21AA1} = {B31191C3-543F-486D-8273-506BD0717B38} {D701D3C7-0CCD-4245-97C4-A90F3972DFDC} = {4518E3A1-BCE4-49EE-99C3-DD68D0420E36} {F98FE3DF-F166-41AA-826D-72318ECC3427} = {CA82EA7A-B4F6-4A96-A7B1-A6646E51586E} + {BD781F63-5B93-42F6-A72B-02C2E70481F5} = {CA82EA7A-B4F6-4A96-A7B1-A6646E51586E} {B59FA95B-262E-4580-AB36-37DB5E16917A} = {CA82EA7A-B4F6-4A96-A7B1-A6646E51586E} {41157B1B-46DE-4775-8490-2FF9D9E8E4CA} = {CA82EA7A-B4F6-4A96-A7B1-A6646E51586E} {9674A6B1-2CE4-49BC-BE80-E99944AA2065} = {4218D708-7D8F-40D1-AF86-9AC654EFF211} diff --git a/src/libraries/System.Net.WebSockets/src/System.Net.WebSockets.csproj b/src/libraries/System.Net.WebSockets/src/System.Net.WebSockets.csproj index 177e95dacee..c02ed3fa73d 100644 --- a/src/libraries/System.Net.WebSockets/src/System.Net.WebSockets.csproj +++ b/src/libraries/System.Net.WebSockets/src/System.Net.WebSockets.csproj @@ -18,6 +18,7 @@ + @@ -31,12 +32,15 @@ + + = 0 ? Task.CompletedTask : - Contended(cancellationToken); + + if (cancellationToken.IsCancellationRequested) + { + return Task.FromCanceled(cancellationToken); + } + + int gate = Interlocked.Decrement(ref _gate); + if (gate >= 0) + { + return Task.CompletedTask; + } + + if (NetEventSource.Log.IsEnabled()) NetEventSource.Trace(this, $"Waiting to enter, queue length {-gate}"); + + return Contended(cancellationToken); // Everything that follows is the equivalent of: // return _sem.WaitAsync(cancellationToken); @@ -66,8 +77,6 @@ public Task EnterAsync(CancellationToken cancellationToken) Task Contended(CancellationToken cancellationToken) { - if (NetEventSource.Log.IsEnabled()) NetEventSource.MutexContended(this, _gate); - var w = new Waiter(this); // We need to register for cancellation before storing the waiter into the list. @@ -178,18 +187,18 @@ static void OnCancellation(object? state, CancellationToken cancellationToken) /// The caller must logically own the mutex. This is not validated. public void Exit() { - if (Interlocked.Increment(ref _gate) < 1) + // This is the equivalent of: + // _sem.Release(); + // if _sem were to be constructed as `new SemaphoreSlim(0)`. + int gate = Interlocked.Increment(ref _gate); + if (gate < 1) { - // This is the equivalent of: - // _sem.Release(); - // if _sem were to be constructed as `new SemaphoreSlim(0)`. + if (NetEventSource.Log.IsEnabled()) NetEventSource.Trace(this, $"Unblocking next waiter on exit, remaining queue length {-_gate}", nameof(Exit)); Contended(); } void Contended() { - if (NetEventSource.Log.IsEnabled()) NetEventSource.MutexContended(this, _gate); - Waiter? w; lock (SyncObj) { diff --git a/src/libraries/System.Net.WebSockets/src/System/Net/WebSockets/ManagedWebSocket.KeepAlive.cs b/src/libraries/System.Net.WebSockets/src/System/Net/WebSockets/ManagedWebSocket.KeepAlive.cs index c9ff393cb71..4e38c4fc100 100644 --- a/src/libraries/System.Net.WebSockets/src/System/Net/WebSockets/ManagedWebSocket.KeepAlive.cs +++ b/src/libraries/System.Net.WebSockets/src/System/Net/WebSockets/ManagedWebSocket.KeepAlive.cs @@ -1,7 +1,6 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System.Buffers; using System.Buffers.Binary; using System.Diagnostics; using System.Runtime.ExceptionServices; @@ -13,8 +12,6 @@ namespace System.Net.WebSockets internal sealed partial class ManagedWebSocket : WebSocket { private bool IsUnsolicitedPongKeepAlive => _keepAlivePingState is null; - private static bool IsValidSendState(WebSocketState state) => Array.IndexOf(s_validSendStates, state) != -1; - private static bool IsValidReceiveState(WebSocketState state) => Array.IndexOf(s_validReceiveStates, state) != -1; private void HeartBeat() { @@ -36,11 +33,11 @@ private void UnsolicitedPongHeartBeat() TrySendKeepAliveFrameAsync(MessageOpcode.Pong)); } - private ValueTask TrySendKeepAliveFrameAsync(MessageOpcode opcode, ReadOnlyMemory? payload = null) + private ValueTask TrySendKeepAliveFrameAsync(MessageOpcode opcode, ReadOnlyMemory payload = default) { - Debug.Assert(opcode is MessageOpcode.Pong || !IsUnsolicitedPongKeepAlive && opcode is MessageOpcode.Ping); + Debug.Assert((opcode is MessageOpcode.Pong) || (!IsUnsolicitedPongKeepAlive && opcode is MessageOpcode.Ping)); - if (!IsValidSendState(_state)) + if (!WebSocketStateHelper.IsValidSendState(_state)) { if (NetEventSource.Log.IsEnabled()) NetEventSource.Trace(this, $"Cannot send keep-alive frame in {nameof(_state)}={_state}"); @@ -48,9 +45,7 @@ private ValueTask TrySendKeepAliveFrameAsync(MessageOpcode opcode, ReadOnlyMemor return ValueTask.CompletedTask; } - payload ??= ReadOnlyMemory.Empty; - - return SendFrameAsync(opcode, endOfMessage: true, disableCompression: true, payload.Value, CancellationToken.None); + return SendFrameAsync(opcode, endOfMessage: true, disableCompression: true, payload, CancellationToken.None); } private void KeepAlivePingHeartBeat() @@ -76,7 +71,7 @@ private void KeepAlivePingHeartBeat() if (_keepAlivePingState.PingSent) { - if (Environment.TickCount64 > _keepAlivePingState.PingTimeoutTimestamp) + if (now > _keepAlivePingState.PingTimeoutTimestamp) { if (NetEventSource.Log.IsEnabled()) { @@ -92,7 +87,7 @@ private void KeepAlivePingHeartBeat() } else { - if (Environment.TickCount64 > _keepAlivePingState.NextPingRequestTimestamp) + if (now > _keepAlivePingState.NextPingRequestTimestamp) { _keepAlivePingState.OnNextPingRequestCore(); // we are holding the lock shouldSendPing = true; @@ -119,18 +114,12 @@ private async ValueTask SendPingAsync(long pingPayload) { Debug.Assert(_keepAlivePingState != null); - byte[] pingPayloadBuffer = ArrayPool.Shared.Rent(sizeof(long)); + byte[] pingPayloadBuffer = new byte[sizeof(long)]; BinaryPrimitives.WriteInt64BigEndian(pingPayloadBuffer, pingPayload); - try - { - await TrySendKeepAliveFrameAsync(MessageOpcode.Ping, pingPayloadBuffer.AsMemory(0, sizeof(long))).ConfigureAwait(false); - if (NetEventSource.Log.IsEnabled()) NetEventSource.KeepAlivePingSent(this, pingPayload); - } - finally - { - ArrayPool.Shared.Return(pingPayloadBuffer); - } + await TrySendKeepAliveFrameAsync(MessageOpcode.Ping, pingPayloadBuffer).ConfigureAwait(false); + + if (NetEventSource.Log.IsEnabled()) NetEventSource.KeepAlivePingSent(this, pingPayload); } // "Observe" either a ValueTask result, or any exception, ignoring it diff --git a/src/libraries/System.Net.WebSockets/src/System/Net/WebSockets/ManagedWebSocket.cs b/src/libraries/System.Net.WebSockets/src/System/Net/WebSockets/ManagedWebSocket.cs index 8a26a4c29e2..f40da1cb06e 100644 --- a/src/libraries/System.Net.WebSockets/src/System/Net/WebSockets/ManagedWebSocket.cs +++ b/src/libraries/System.Net.WebSockets/src/System/Net/WebSockets/ManagedWebSocket.cs @@ -32,15 +32,6 @@ internal sealed partial class ManagedWebSocket : WebSocket /// Encoding for the payload of text messages: UTF-8 encoding that throws if invalid bytes are discovered, per the RFC. private static readonly UTF8Encoding s_textEncoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true); - /// Valid states to be in when calling SendAsync. - private static readonly WebSocketState[] s_validSendStates = { WebSocketState.Open, WebSocketState.CloseReceived }; - /// Valid states to be in when calling ReceiveAsync. - private static readonly WebSocketState[] s_validReceiveStates = { WebSocketState.Open, WebSocketState.CloseSent }; - /// Valid states to be in when calling CloseOutputAsync. - private static readonly WebSocketState[] s_validCloseOutputStates = { WebSocketState.Open, WebSocketState.CloseReceived }; - /// Valid states to be in when calling CloseAsync. - private static readonly WebSocketState[] s_validCloseStates = { WebSocketState.Open, WebSocketState.CloseReceived, WebSocketState.CloseSent }; - /// The maximum size in bytes of a message frame header that includes mask bytes. internal const int MaxMessageHeaderLength = 14; /// The maximum size of a control message payload. @@ -337,7 +328,7 @@ public override ValueTask SendAsync(ReadOnlyMemory buffer, WebSocketMessag try { - ThrowIfInvalidState(s_validSendStates); + ThrowIfInvalidState(WebSocketStateHelper.ValidSendStates); } catch (Exception exc) { @@ -377,7 +368,7 @@ public override Task ReceiveAsync(ArraySegment buf try { - ThrowIfInvalidState(s_validReceiveStates); + ThrowIfInvalidState(WebSocketStateHelper.ValidReceiveStates); return ReceiveAsyncPrivate(buffer, cancellationToken).AsTask(); } @@ -394,7 +385,7 @@ public override ValueTask ReceiveAsync(Memory try { - ThrowIfInvalidState(s_validReceiveStates); + ThrowIfInvalidState(WebSocketStateHelper.ValidReceiveStates); return ReceiveAsyncPrivate(buffer, cancellationToken); } @@ -413,7 +404,7 @@ public override Task CloseAsync(WebSocketCloseStatus closeStatus, string? status try { - ThrowIfInvalidState(s_validCloseStates); + ThrowIfInvalidState(WebSocketStateHelper.ValidCloseStates); } catch (Exception exc) { @@ -436,7 +427,7 @@ private async Task CloseOutputAsyncCore(WebSocketCloseStatus closeStatus, string { if (NetEventSource.Log.IsEnabled()) NetEventSource.Trace(this); - ThrowIfInvalidState(s_validCloseOutputStates); + ThrowIfInvalidState(WebSocketStateHelper.ValidCloseOutputStates); await SendCloseFrameAsync(closeStatus, statusDescription, cancellationToken).ConfigureAwait(false); @@ -1737,9 +1728,9 @@ private void ThrowIfOperationInProgress(bool operationCompleted, [CallerMemberNa cancellationToken); } - private void ThrowIfDisposed() => ThrowIfInvalidState(); + private void ThrowIfDisposed() => ThrowIfInvalidState(validStates: ManagedWebSocketStates.All); - private void ThrowIfInvalidState(WebSocketState[]? validStates = null) + private void ThrowIfInvalidState(ManagedWebSocketStates validStates) { bool disposed = _disposed; WebSocketState state = _state; @@ -1758,7 +1749,7 @@ private void ThrowIfInvalidState(WebSocketState[]? validStates = null) if (NetEventSource.Log.IsEnabled()) NetEventSource.Trace(this, $"_state={state}, _disposed={disposed}, _keepAlivePingState.Exception={keepAliveException}"); - WebSocketValidate.ThrowIfInvalidState(state, disposed, keepAliveException, validStates); + WebSocketStateHelper.ThrowIfInvalidState(state, disposed, keepAliveException, validStates); } // From https://github.com/aspnet/WebSockets/blob/aa63e27fce2e9202698053620679a9a1059b501e/src/Microsoft.AspNetCore.WebSockets.Protocol/Utilities.cs#L75 diff --git a/src/libraries/System.Net.WebSockets/src/System/Net/WebSockets/ManagedWebSocketStates.cs b/src/libraries/System.Net.WebSockets/src/System/Net/WebSockets/ManagedWebSocketStates.cs new file mode 100644 index 00000000000..1ad4cb20129 --- /dev/null +++ b/src/libraries/System.Net.WebSockets/src/System/Net/WebSockets/ManagedWebSocketStates.cs @@ -0,0 +1,21 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace System.Net.WebSockets +{ + [Flags] + internal enum ManagedWebSocketStates + { + None = 0, + + // WebSocketState.None = 0 -- this state is invalid for the managed implementation + // WebSocketState.Connecting = 1 -- this state is invalid for the managed implementation + Open = 0x04, // WebSocketState.Open = 2 + CloseSent = 0x08, // WebSocketState.CloseSent = 3 + CloseReceived = 0x10, // WebSocketState.CloseReceived = 4 + Closed = 0x20, // WebSocketState.Closed = 5 + Aborted = 0x40, // WebSocketState.Aborted = 6 + + All = Open | CloseSent | CloseReceived | Closed | Aborted + } +} diff --git a/src/libraries/System.Net.WebSockets/src/System/Net/WebSockets/NetEventSource.WebSockets.cs b/src/libraries/System.Net.WebSockets/src/System/Net/WebSockets/NetEventSource.WebSockets.cs index d0977fb7670..fceeadd862d 100644 --- a/src/libraries/System.Net.WebSockets/src/System/Net/WebSockets/NetEventSource.WebSockets.cs +++ b/src/libraries/System.Net.WebSockets/src/System/Net/WebSockets/NetEventSource.WebSockets.cs @@ -34,7 +34,6 @@ internal sealed partial class NetEventSource private const int MutexEnterId = SendStopId + 1; private const int MutexExitId = MutexEnterId + 1; - private const int MutexContendedId = MutexExitId + 1; // // Keep-Alive @@ -185,10 +184,6 @@ private void MutexEnter(string objName, string memberName) => private void MutexExit(string objName, string memberName) => WriteEvent(MutexExitId, objName, memberName); - [Event(MutexContendedId, Keywords = Keywords.Debug, Level = EventLevel.Verbose)] - private void MutexContended(string objName, string memberName, int queueLength) => - WriteEvent(MutexContendedId, objName, memberName, queueLength); - [NonEvent] public static void MutexEntered(object? obj, [CallerMemberName] string? memberName = null) { @@ -203,13 +198,6 @@ public static void MutexExited(object? obj, [CallerMemberName] string? memberNam Log.MutexExit(IdOf(obj), memberName ?? MissingMember); } - [NonEvent] - public static void MutexContended(object? obj, int gateValue, [CallerMemberName] string? memberName = null) - { - Debug.Assert(Log.IsEnabled()); - Log.MutexContended(IdOf(obj), memberName ?? MissingMember, -gateValue); - } - // // WriteEvent overloads // diff --git a/src/libraries/System.Net.WebSockets/src/System/Net/WebSockets/WebSocketStateHelper.cs b/src/libraries/System.Net.WebSockets/src/System/Net/WebSockets/WebSocketStateHelper.cs new file mode 100644 index 00000000000..1de3e3333ab --- /dev/null +++ b/src/libraries/System.Net.WebSockets/src/System/Net/WebSockets/WebSocketStateHelper.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; + +namespace System.Net.WebSockets +{ + internal static class WebSocketStateHelper + { + /// Valid states to be in when calling SendAsync. + internal const ManagedWebSocketStates ValidSendStates = ManagedWebSocketStates.Open | ManagedWebSocketStates.CloseReceived; + /// Valid states to be in when calling ReceiveAsync. + internal const ManagedWebSocketStates ValidReceiveStates = ManagedWebSocketStates.Open | ManagedWebSocketStates.CloseSent; + /// Valid states to be in when calling CloseOutputAsync. + internal const ManagedWebSocketStates ValidCloseOutputStates = ManagedWebSocketStates.Open | ManagedWebSocketStates.CloseReceived; + /// Valid states to be in when calling CloseAsync. + internal const ManagedWebSocketStates ValidCloseStates = ManagedWebSocketStates.Open | ManagedWebSocketStates.CloseReceived | ManagedWebSocketStates.CloseSent; + + internal static bool IsValidSendState(WebSocketState state) => ValidSendStates.HasFlag(ToFlag(state)); + + internal static void ThrowIfInvalidState(WebSocketState currentState, bool isDisposed, Exception? innerException, ManagedWebSocketStates validStates) + { + ManagedWebSocketStates state = ToFlag(currentState); + + if ((state & validStates) == 0) + { + string invalidStateMessage = SR.Format( + SR.net_WebSockets_InvalidState, currentState, validStates); + + throw new WebSocketException(WebSocketError.InvalidState, invalidStateMessage, innerException); + } + + if (innerException is not null) + { + Debug.Assert(state == ManagedWebSocketStates.Aborted); + throw new OperationCanceledException(nameof(WebSocketState.Aborted), innerException); + } + + // Ordering is important to maintain .NET 4.5 WebSocket implementation exception behavior. + ObjectDisposedException.ThrowIf(isDisposed, typeof(WebSocket)); + } + + private static ManagedWebSocketStates ToFlag(WebSocketState value) + { + ManagedWebSocketStates flag = (ManagedWebSocketStates)(1 << (int)value); + Debug.Assert(Enum.IsDefined(flag)); + return flag; + } + } +} diff --git a/src/libraries/System.Numerics.Tensors/System.Numerics.Tensors.sln b/src/libraries/System.Numerics.Tensors/System.Numerics.Tensors.sln index 0afa9da9f3c..cb5cf60398d 100644 --- a/src/libraries/System.Numerics.Tensors/System.Numerics.Tensors.sln +++ b/src/libraries/System.Numerics.Tensors/System.Numerics.Tensors.sln @@ -11,7 +11,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Numerics.Tensors.Net EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Numerics.Tensors.Tests", "tests\System.Numerics.Tensors.Tests.csproj", "{4AF6A02D-82C8-4898-9EDF-01F107C25061}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{4588351F-4233-4957-B84C-7F8E22B8888A}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{D9283CC0-07E1-417A-B73C-223F3EB7A277}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{DB954E01-898A-4FE2-A3AA-180D041AB08F}" EndProject @@ -71,10 +71,10 @@ Global {4AF6A02D-82C8-4898-9EDF-01F107C25061}.Debug|Any CPU.Build.0 = Debug|Any CPU {4AF6A02D-82C8-4898-9EDF-01F107C25061}.Release|Any CPU.ActiveCfg = Release|Any CPU {4AF6A02D-82C8-4898-9EDF-01F107C25061}.Release|Any CPU.Build.0 = Release|Any CPU - {4588351F-4233-4957-B84C-7F8E22B8888A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {4588351F-4233-4957-B84C-7F8E22B8888A}.Debug|Any CPU.Build.0 = Debug|Any CPU - {4588351F-4233-4957-B84C-7F8E22B8888A}.Release|Any CPU.ActiveCfg = Release|Any CPU - {4588351F-4233-4957-B84C-7F8E22B8888A}.Release|Any CPU.Build.0 = Release|Any CPU + {D9283CC0-07E1-417A-B73C-223F3EB7A277}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D9283CC0-07E1-417A-B73C-223F3EB7A277}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D9283CC0-07E1-417A-B73C-223F3EB7A277}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D9283CC0-07E1-417A-B73C-223F3EB7A277}.Release|Any CPU.Build.0 = Release|Any CPU {DB954E01-898A-4FE2-A3AA-180D041AB08F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {DB954E01-898A-4FE2-A3AA-180D041AB08F}.Debug|Any CPU.Build.0 = Debug|Any CPU {DB954E01-898A-4FE2-A3AA-180D041AB08F}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -110,7 +110,7 @@ Global {1578185F-C4FA-4866-936B-E62AAEDD03B7} = {DF0561A1-3AB8-4B51-AFB4-392EE1DD6247} {848DD000-3D22-4A25-A9D9-05AFF857A116} = {DF0561A1-3AB8-4B51-AFB4-392EE1DD6247} {21CB448A-3882-4337-B416-D1A3E0BCFFC5} = {7AC4B2C7-A55C-4C4F-9B02-77F5CBFFF4AB} - {4588351F-4233-4957-B84C-7F8E22B8888A} = {841A2FA4-A95F-4612-A8B9-AD2EF769BC71} + {D9283CC0-07E1-417A-B73C-223F3EB7A277} = {841A2FA4-A95F-4612-A8B9-AD2EF769BC71} {DB954E01-898A-4FE2-A3AA-180D041AB08F} = {841A2FA4-A95F-4612-A8B9-AD2EF769BC71} {04FC0651-B9D0-448A-A28B-11B1D4A897F4} = {A21C99E7-E22B-470E-BF48-56B00AFE3D34} {683A7D28-CC55-4375-848D-E659075ECEE4} = {A21C99E7-E22B-470E-BF48-56B00AFE3D34} diff --git a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs index 9a4b08633db..c3a9f5be9ee 100644 --- a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs +++ b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.netcore.cs @@ -299,7 +299,7 @@ public static void BroadcastTo(this System.Numerics.Tensors.Tensor source, public static bool GreaterThanAny(in System.Numerics.Tensors.ReadOnlyTensorSpan x, T y) where T : System.Numerics.IComparisonOperators { throw null; } public static bool GreaterThanAny(T x, in System.Numerics.Tensors.ReadOnlyTensorSpan y) where T : System.Numerics.IComparisonOperators { throw null; } public static bool GreaterThanOrEqualAll(in System.Numerics.Tensors.ReadOnlyTensorSpan x, in System.Numerics.Tensors.ReadOnlyTensorSpan y) where T : System.Numerics.IComparisonOperators { throw null; } - public static bool GreaterThanOrEqualAll(in System.Numerics.Tensors.ReadOnlyTensorSpan s, T y) where T : System.Numerics.IComparisonOperators { throw null; } + public static bool GreaterThanOrEqualAll(in System.Numerics.Tensors.ReadOnlyTensorSpan x, T y) where T : System.Numerics.IComparisonOperators { throw null; } public static bool GreaterThanOrEqualAll(T x, in System.Numerics.Tensors.ReadOnlyTensorSpan y) where T : System.Numerics.IComparisonOperators { throw null; } public static bool GreaterThanOrEqualAny(in System.Numerics.Tensors.ReadOnlyTensorSpan x, in System.Numerics.Tensors.ReadOnlyTensorSpan y) where T : System.Numerics.IComparisonOperators { throw null; } public static bool GreaterThanOrEqualAny(in System.Numerics.Tensors.ReadOnlyTensorSpan x, T y) where T : System.Numerics.IComparisonOperators { throw null; } @@ -333,16 +333,16 @@ public static void BroadcastTo(this System.Numerics.Tensors.Tensor source, public static System.Numerics.Tensors.Tensor LeadingZeroCount(in System.Numerics.Tensors.ReadOnlyTensorSpan x) where T : System.Numerics.IBinaryInteger { throw null; } public static ref readonly System.Numerics.Tensors.TensorSpan LeadingZeroCount(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan x, in System.Numerics.Tensors.TensorSpan destination) where T : System.Numerics.IBinaryInteger { throw null; } public static bool LessThanAll(in System.Numerics.Tensors.ReadOnlyTensorSpan x, in System.Numerics.Tensors.ReadOnlyTensorSpan y) where T : System.Numerics.IComparisonOperators { throw null; } - public static bool LessThanAll(in System.Numerics.Tensors.ReadOnlyTensorSpan f, T x) where T : System.Numerics.IComparisonOperators { throw null; } + public static bool LessThanAll(in System.Numerics.Tensors.ReadOnlyTensorSpan x, T y) where T : System.Numerics.IComparisonOperators { throw null; } public static bool LessThanAll(T x, in System.Numerics.Tensors.ReadOnlyTensorSpan y) where T : System.Numerics.IComparisonOperators { throw null; } public static bool LessThanAny(in System.Numerics.Tensors.ReadOnlyTensorSpan x, in System.Numerics.Tensors.ReadOnlyTensorSpan y) where T : System.Numerics.IComparisonOperators { throw null; } - public static bool LessThanAny(in System.Numerics.Tensors.ReadOnlyTensorSpan f, T x) where T : System.Numerics.IComparisonOperators { throw null; } + public static bool LessThanAny(in System.Numerics.Tensors.ReadOnlyTensorSpan x, T y) where T : System.Numerics.IComparisonOperators { throw null; } public static bool LessThanAny(T x, in System.Numerics.Tensors.ReadOnlyTensorSpan y) where T : System.Numerics.IComparisonOperators { throw null; } public static bool LessThanOrEqualAll(in System.Numerics.Tensors.ReadOnlyTensorSpan x, in System.Numerics.Tensors.ReadOnlyTensorSpan y) where T : System.Numerics.IComparisonOperators { throw null; } - public static bool LessThanOrEqualAll(in System.Numerics.Tensors.ReadOnlyTensorSpan f, T x) where T : System.Numerics.IComparisonOperators { throw null; } + public static bool LessThanOrEqualAll(in System.Numerics.Tensors.ReadOnlyTensorSpan x, T y) where T : System.Numerics.IComparisonOperators { throw null; } public static bool LessThanOrEqualAll(T x, in System.Numerics.Tensors.ReadOnlyTensorSpan y) where T : System.Numerics.IComparisonOperators { throw null; } public static bool LessThanOrEqualAny(in System.Numerics.Tensors.ReadOnlyTensorSpan x, in System.Numerics.Tensors.ReadOnlyTensorSpan y) where T : System.Numerics.IComparisonOperators { throw null; } - public static bool LessThanOrEqualAny(in System.Numerics.Tensors.ReadOnlyTensorSpan f, T x) where T : System.Numerics.IComparisonOperators { throw null; } + public static bool LessThanOrEqualAny(in System.Numerics.Tensors.ReadOnlyTensorSpan x, T y) where T : System.Numerics.IComparisonOperators { throw null; } public static bool LessThanOrEqualAny(T x, in System.Numerics.Tensors.ReadOnlyTensorSpan y) where T : System.Numerics.IComparisonOperators { throw null; } public static System.Numerics.Tensors.Tensor LessThanOrEqual(in System.Numerics.Tensors.ReadOnlyTensorSpan x, in System.Numerics.Tensors.ReadOnlyTensorSpan y) where T : System.Numerics.IComparisonOperators { throw null; } public static ref readonly System.Numerics.Tensors.TensorSpan LessThanOrEqual(scoped in System.Numerics.Tensors.ReadOnlyTensorSpan x, scoped in System.Numerics.Tensors.ReadOnlyTensorSpan y, in System.Numerics.Tensors.TensorSpan destination) where T : System.Numerics.IComparisonOperators { throw null; } diff --git a/src/libraries/System.Numerics.Tensors/src/Properties/InternalVisibleTo.cs b/src/libraries/System.Numerics.Tensors/src/Properties/InternalVisibleTo.cs new file mode 100644 index 00000000000..8858b4b76a8 --- /dev/null +++ b/src/libraries/System.Numerics.Tensors/src/Properties/InternalVisibleTo.cs @@ -0,0 +1,6 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Runtime.CompilerServices; + +[assembly: InternalsVisibleTo("System.Numerics.Tensors.Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001004b86c4cb78549b34bab61a3b1800e23bfeb5b3ec390074041536a7e3cbd97f5f04cf0f857155a8928eaa29ebfd11cfbbad3ba70efea7bda3226c6a8d370a4cd303f714486b6ebc225985a638471e6ef571cc92a4613c00b8fa65d61ccee0cbe5f36330c9a01f4183559f1bef24cc2917c6d913e3a541333a1d05d9bed22b38cb")] diff --git a/src/libraries/System.Numerics.Tensors/src/Resources/Strings.resx b/src/libraries/System.Numerics.Tensors/src/Resources/Strings.resx index 7fc5ad881af..4c22326d25b 100644 --- a/src/libraries/System.Numerics.Tensors/src/Resources/Strings.resx +++ b/src/libraries/System.Numerics.Tensors/src/Resources/Strings.resx @@ -198,8 +198,8 @@ When no ranges are specified the values tensor must be equal in size as the input tensor. - - Shapes are not broadcast compatible. + + Lengths are not broadcast compatible. The number of splits must perfectly divide the dimension. @@ -228,4 +228,4 @@ All tensors must have the same shape. - + \ No newline at end of file diff --git a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj index 3221f6231ac..454a1ce98fb 100644 --- a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj +++ b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj @@ -6,12 +6,12 @@ true Provides support for operating over tensors. ReferenceAssemblyExclusions.txt - true $(NoWarn);SYSLIB5001 + diff --git a/src/libraries/System.Numerics.Tensors/src/System/NIndex.cs b/src/libraries/System.Numerics.Tensors/src/System/NIndex.cs index ab14d2ed80c..e2d2cfef635 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/NIndex.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/NIndex.cs @@ -7,7 +7,7 @@ namespace System.Buffers { - /// Represent a type can be used to index a collection either from the start or the end. + /// Represents a type that can be used to index a collection either from the start or the end. /// /// /// int[] someArray = new int[5] { 1, 2, 3, 4, 5 } ; @@ -19,11 +19,11 @@ namespace System.Buffers { private readonly nint _value; - /// Construct an NIndex using a value and indicating if the NIndex is from the start or from the end. - /// The index value. it has to be zero or positive number. - /// Indicating if the index is from the start or from the end. + /// Constructs an using an index value and a Boolean that indicates if the is from the start or from the end. + /// The index value. It must be greater than or equal to zero. + /// if the index is from the start; if it's from the end. /// - /// If the NIndex constructed from the end, index value 1 means pointing at the last element and index value 0 means pointing at beyond last element. + /// If the NIndex constructed from the end, an index value of 1 points at the last element and an index value of 0 points beyond the last element. /// [MethodImpl(MethodImplOptions.AggressiveInlining)] public NIndex(nint value, bool fromEnd = false) @@ -39,10 +39,10 @@ public NIndex(nint value, bool fromEnd = false) _value = value; } - /// Construct a from a + /// Constructs an from an . /// The to create the from. /// - /// If the NIndex constructed from the end, index value 1 means pointing at the last element and index value 0 means pointing at beyond last element. + /// If the NIndex constructed from the end, an index value of 1 points at the last element and an index value of 0 points beyond the last element. /// [MethodImpl(MethodImplOptions.AggressiveInlining)] public NIndex(Index index) @@ -59,13 +59,13 @@ private NIndex(nint value) _value = value; } - /// Create an NIndex pointing at first element. + /// Creates an that points at the first element. public static NIndex Start => new NIndex((nint)0); - /// Create an NIndex pointing at beyond last element. + /// Creates an that points beyond the last element. public static NIndex End => new NIndex((nint)~0); - /// Create an NIndex from the start at the position indicated by the value. + /// Creates an from the start at the specified position. /// The index value from the start. [MethodImpl(MethodImplOptions.AggressiveInlining)] public static NIndex FromStart(nint value) @@ -78,7 +78,7 @@ public static NIndex FromStart(nint value) return new NIndex(value); } - /// Create an NIndex from the end at the position indicated by the value. + /// Creates an NIndex from the end at the specified position. /// The index value from the end. [MethodImpl(MethodImplOptions.AggressiveInlining)] public static NIndex FromEnd(nint value) @@ -91,12 +91,19 @@ public static NIndex FromEnd(nint value) return new NIndex(~value); } -#pragma warning disable 1591 // TODO: Document this API. https://github.com/dotnet/runtime/issues/105981 + /// + /// Converts the to an . + /// + /// The converted Index. public Index ToIndex() => checked((Index)this); + + /// + /// Converts the to an without doing bounds checks. + /// + /// The converted Index. public Index ToIndexUnchecked() => (Index)this; -#pragma warning restore 1591 - /// Returns the NIndex value. + /// Gets the value. public nint Value { get @@ -108,16 +115,16 @@ public nint Value } } - /// Indicates whether the NIndex is from the start or the end. + /// Gets a value that indicates whether the is from the start or the end. public bool IsFromEnd => _value < 0; - /// Calculate the offset from the start using the giving collection length. - /// The length of the collection that the NIndex will be used with. length has to be a positive value + /// Calculates the offset from the start using the given collection length. + /// The length of the collection that the NIndex will be used with. Must be a positive value. /// - /// For performance reason, we don't validate the input length parameter and the returned offset value against negative values. - /// we don't validate either the returned offset is greater than the input length. - /// It is expected NIndex will be used with collections which always have non negative length/count. If the returned offset is negative and - /// then used to NIndex a collection will get out of range exception which will be same affect as the validation. + /// For performance reasons, the input length argument and the returned offset value aren't validated against negative values. + /// Also, the returned offset might be greater than the input length. + /// It is expected will be used with collections that always have a non-negative length/count. If the returned offset is negative and + /// then used to a collection, an is thrown, which has the same effect as the validation. /// [MethodImpl(MethodImplOptions.AggressiveInlining)] public nint GetOffset(nint length) @@ -134,27 +141,27 @@ public nint GetOffset(nint length) return offset; } - /// Indicates whether the current NIndex object is equal to another object of the same type. - /// An object to compare with this object + /// Compares the current NIndex object to another object of the same type for equality. + /// An object to compare with this object. public override bool Equals([NotNullWhen(true)] object? value) => value is NIndex other && _value == other._value; - /// Indicates whether the current NIndex object is equal to another NIndex object. - /// An object to compare with this object + /// Compares the current object to another object for equality. + /// An object to compare with this object. public bool Equals(NIndex other) => _value == other._value; /// Returns the hash code for this instance. public override int GetHashCode() => _value.GetHashCode(); - /// Converts integer number to an NIndex. + /// Converts an integer number to an NIndex. public static implicit operator NIndex(nint value) => FromStart(value); - /// Converts native integer number to an NIndex. + /// Converts a native integer number to an NIndex. public static implicit operator NIndex(Index value) => new NIndex(value); - /// Converts a to an ."/> + /// Converts an to an . public static explicit operator Index(NIndex value) => new Index((int)value.Value, value.IsFromEnd); - /// Converts a to an ."/> + /// Converts an to an . public static explicit operator checked Index(NIndex value) => new Index(checked((int)value.Value), value.IsFromEnd); /// Converts the value of the current NIndex object to its equivalent string representation. diff --git a/src/libraries/System.Numerics.Tensors/src/System/NRange.cs b/src/libraries/System.Numerics.Tensors/src/System/NRange.cs index 48211d5a4ee..43e0ff9c565 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/NRange.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/NRange.cs @@ -7,7 +7,7 @@ namespace System.Buffers { - /// Represent a range that has start and end indices. + /// Represents a range that has start and end indices. /// /// /// int[] someArray = new int[5] { 1, 2, 3, 4, 5 }; @@ -18,15 +18,15 @@ namespace System.Buffers [Experimental(Experimentals.TensorTDiagId, UrlFormat = Experimentals.SharedUrlFormat)] public readonly struct NRange : IEquatable { - /// Represent the inclusive start NIndex of the NRange. + /// Gets the inclusive start NIndex of the NRange. public NIndex Start { get; } - /// Represent the exclusive end NIndex of the NRange. + /// Gets the exclusive end NIndex of the NRange. public NIndex End { get; } - /// Construct an NRange object using the start and end NIndexes. - /// Represent the inclusive start NIndex of the NRange. - /// Represent the exclusive end NIndex of the NRange. + /// Constructs an object using the start and end . + /// The inclusive start of the . + /// The exclusive end of the . public NRange(NIndex start, NIndex end) { Start = start; @@ -34,7 +34,7 @@ public NRange(NIndex start, NIndex end) } /// - /// Construct a object using a . + /// Constructs an object using a . /// /// The to use. public NRange(Range range) @@ -43,15 +43,15 @@ public NRange(Range range) End = range.End; } - /// Indicates whether the current NRange object is equal to another object of the same type. - /// An object to compare with this object + /// Compares the current object to another object of the same type for equality. + /// An object to compare with this object. public override bool Equals([NotNullWhen(true)] object? value) => value is NRange r && r.Start.Equals(Start) && r.End.Equals(End); - /// Indicates whether the current NRange object is equal to another NRange object. - /// An object to compare with this object + /// Compares the current object to another object for equality. + /// An object to compare with this object. public bool Equals(NRange other) => other.Start.Equals(Start) && other.End.Equals(End); /// Returns the hash code for this instance. @@ -89,21 +89,21 @@ public override string ToString() return new string(span.Slice(0, pos)); } - /// Create an NRange object starting from start NIndex to the end of the collection. + /// Creates an object starting from start to the end of the collection. public static NRange StartAt(NIndex start) => new NRange(start, NIndex.End); - /// Create an NRange object starting from first element in the collection to the end NIndex. + /// Creates an object starting from first element in the collection to the end . public static NRange EndAt(NIndex end) => new NRange(NIndex.Start, end); - /// Create an NRange object starting from first element to the end. + /// Creates an NRange object starting from first element to the end. public static NRange All => new NRange(NIndex.Start, NIndex.End); - /// Calculate the start offset and length of NRange object using a collection length. - /// The length of the collection that the NRange will be used with. length has to be a positive value. + /// Calculates the start offset and length of the object using a collection length. + /// The length of the collection that the will be used with. Must be a positive value. /// - /// For performance reason, we don't validate the input length parameter against negative values. - /// It is expected NRange will be used with collections which always have non negative length/count. - /// We validate the NRange is inside the length scope though. + /// For performance reasons, the input length parameter isn't validated against negative values. + /// It's expected NRange will be used with collections that always have a non-negative length/count. + /// The is validated to be inside the length scope, however. /// [MethodImpl(MethodImplOptions.AggressiveInlining)] public (nint Offset, nint Length) GetOffsetAndLength(nint length) @@ -121,14 +121,34 @@ public override string ToString() private static void ThrowArgumentOutOfRangeException() => throw new ArgumentOutOfRangeException("length"); -#pragma warning disable 1591 // TODO: Document this API. https://github.com/dotnet/runtime/issues/105981 + /// + /// Implicitly converts a to an . + /// + /// public static implicit operator NRange(Range range) => new NRange(range.Start, range.End); + /// + /// Explicitly converts an to a without doing bounds checks. + /// + /// to convert. public static explicit operator Range(NRange value) => new Range((Index)value.Start, (Index)value.End); + + /// + /// Explicitly converts an to a . + /// + /// to convert. public static explicit operator checked Range(NRange value) => new Range(checked((Index)value.Start), checked((Index)value.End)); + /// + /// Converts a to a . + /// + /// The converted Range. public Range ToRange() => new Range(checked((Index)Start), checked((Index)End)); + + /// + /// Converts a to a without doing bounds checks. + /// + /// The converted Range. public Range ToRangeUnchecked() => new Range((Index)Start, (Index)End); -#pragma warning restore 1591 } } diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.Single.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.Single.cs index 96150e89108..f0b59524f2f 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.Single.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.Single.cs @@ -140,7 +140,7 @@ public static void AddMultiply(ReadOnlySpan x, float y, ReadOnlySpan, the result stored into the corresponding destination location is also NaN. /// /// - /// The angles in x must be in radians. Use or multiply by /180 to convert degrees to radians. + /// The angles in x must be in radians. Use or multiply by /180 to convert degrees to radians. /// /// /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different @@ -819,7 +819,7 @@ public static void Sigmoid(ReadOnlySpan x, Span destination) /// the corresponding destination location is set to that value. /// /// - /// The angles in x must be in radians. Use or multiply by /180 to convert degrees to radians. + /// The angles in x must be in radians. Use or multiply by /180 to convert degrees to radians. /// /// /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different @@ -972,7 +972,7 @@ public static float SumOfSquares(ReadOnlySpan x) => /// If a value is equal to , the corresponding destination location is set to NaN. /// /// - /// The angles in x must be in radians. Use or multiply by /180 to convert degrees to radians. + /// The angles in x must be in radians. Use or multiply by /180 to convert degrees to radians. /// /// /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Common/TensorPrimitives.IAggregationOperator.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Common/TensorPrimitives.IAggregationOperator.cs index df03ad1634d..1c8d215bd13 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Common/TensorPrimitives.IAggregationOperator.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Common/TensorPrimitives.IAggregationOperator.cs @@ -141,9 +141,12 @@ static T Vectorized128(ref T xRef, nuint remainder) // We need to the ensure the underlying data can be aligned and only align // it if it can. It is possible we have an unaligned ref, in which case we - // can never achieve the required SIMD alignment. + // can never achieve the required SIMD alignment. This cannot be done for + // float or double since that changes how results compound together. - bool canAlign = ((nuint)xPtr % (nuint)sizeof(T)) == 0; + bool canAlign = (typeof(T) != typeof(float)) && + (typeof(T) != typeof(double)) && + ((nuint)xPtr % (nuint)sizeof(T)) == 0; if (canAlign) { @@ -156,11 +159,20 @@ static T Vectorized128(ref T xRef, nuint remainder) misalignment = ((uint)sizeof(Vector128) - ((nuint)xPtr % (uint)sizeof(Vector128))) / (uint)sizeof(T); xPtr += misalignment; - Debug.Assert(((nuint)xPtr % (uint)sizeof(Vector128)) == 0); remainder -= misalignment; } + else + { + // We can't align, but this also means we're processing the full data from beg + // so account for that to ensure we don't double process and include them in the + // aggregate twice. + + misalignment = (uint)Vector128.Count; + xPtr += misalignment; + remainder -= misalignment; + } Vector128 vector1; Vector128 vector2; @@ -310,9 +322,12 @@ static T Vectorized256(ref T xRef, nuint remainder) // We need to the ensure the underlying data can be aligned and only align // it if it can. It is possible we have an unaligned ref, in which case we - // can never achieve the required SIMD alignment. + // can never achieve the required SIMD alignment. This cannot be done for + // float or double since that changes how results compound together. - bool canAlign = ((nuint)xPtr % (nuint)sizeof(T)) == 0; + bool canAlign = (typeof(T) != typeof(float)) && + (typeof(T) != typeof(double)) && + ((nuint)xPtr % (nuint)sizeof(T)) == 0; if (canAlign) { @@ -330,6 +345,16 @@ static T Vectorized256(ref T xRef, nuint remainder) remainder -= misalignment; } + else + { + // We can't align, but this also means we're processing the full data from beg + // so account for that to ensure we don't double process and include them in the + // aggregate twice. + + misalignment = (uint)Vector256.Count; + xPtr += misalignment; + remainder -= misalignment; + } Vector256 vector1; Vector256 vector2; @@ -479,9 +504,12 @@ static T Vectorized512(ref T xRef, nuint remainder) // We need to the ensure the underlying data can be aligned and only align // it if it can. It is possible we have an unaligned ref, in which case we - // can never achieve the required SIMD alignment. + // can never achieve the required SIMD alignment. This cannot be done for + // float or double since that changes how results compound together. - bool canAlign = ((nuint)xPtr % (nuint)sizeof(T)) == 0; + bool canAlign = (typeof(T) != typeof(float)) && + (typeof(T) != typeof(double)) && + ((nuint)xPtr % (nuint)sizeof(T)) == 0; if (canAlign) { @@ -499,6 +527,16 @@ static T Vectorized512(ref T xRef, nuint remainder) remainder -= misalignment; } + else + { + // We can't align, but this also means we're processing the full data from beg + // so account for that to ensure we don't double process and include them in the + // aggregate twice. + + misalignment = (uint)Vector512.Count; + xPtr += misalignment; + remainder -= misalignment; + } Vector512 vector1; Vector512 vector2; @@ -1227,9 +1265,12 @@ static T Vectorized128(ref T xRef, ref T yRef, nuint remainder) // We need to the ensure the underlying data can be aligned and only align // it if it can. It is possible we have an unaligned ref, in which case we - // can never achieve the required SIMD alignment. + // can never achieve the required SIMD alignment. This cannot be done for + // float or double since that changes how results compound together. - bool canAlign = ((nuint)xPtr % (nuint)sizeof(T)) == 0; + bool canAlign = (typeof(T) != typeof(float)) && + (typeof(T) != typeof(double)) && + ((nuint)xPtr % (nuint)sizeof(T)) == 0; if (canAlign) { @@ -1248,6 +1289,19 @@ static T Vectorized128(ref T xRef, ref T yRef, nuint remainder) remainder -= misalignment; } + else + { + // We can't align, but this also means we're processing the full data from beg + // so account for that to ensure we don't double process and include them in the + // aggregate twice. + + misalignment = (uint)Vector128.Count; + + xPtr += misalignment; + yPtr += misalignment; + + remainder -= misalignment; + } Vector128 vector1; Vector128 vector2; @@ -1418,9 +1472,12 @@ static T Vectorized256(ref T xRef, ref T yRef, nuint remainder) // We need to the ensure the underlying data can be aligned and only align // it if it can. It is possible we have an unaligned ref, in which case we - // can never achieve the required SIMD alignment. + // can never achieve the required SIMD alignment. This cannot be done for + // float or double since that changes how results compound together. - bool canAlign = ((nuint)xPtr % (nuint)sizeof(T)) == 0; + bool canAlign = (typeof(T) != typeof(float)) && + (typeof(T) != typeof(double)) && + ((nuint)xPtr % (nuint)sizeof(T)) == 0; if (canAlign) { @@ -1439,6 +1496,19 @@ static T Vectorized256(ref T xRef, ref T yRef, nuint remainder) remainder -= misalignment; } + else + { + // We can't align, but this also means we're processing the full data from beg + // so account for that to ensure we don't double process and include them in the + // aggregate twice. + + misalignment = (uint)Vector256.Count; + + xPtr += misalignment; + yPtr += misalignment; + + remainder -= misalignment; + } Vector256 vector1; Vector256 vector2; @@ -1609,9 +1679,12 @@ static T Vectorized512(ref T xRef, ref T yRef, nuint remainder) // We need to the ensure the underlying data can be aligned and only align // it if it can. It is possible we have an unaligned ref, in which case we - // can never achieve the required SIMD alignment. + // can never achieve the required SIMD alignment. This cannot be done for + // float or double since that changes how results compound together. - bool canAlign = ((nuint)xPtr % (nuint)sizeof(T)) == 0; + bool canAlign = (typeof(T) != typeof(float)) && + (typeof(T) != typeof(double)) && + ((nuint)xPtr % (nuint)sizeof(T)) == 0; if (canAlign) { @@ -1630,6 +1703,19 @@ static T Vectorized512(ref T xRef, ref T yRef, nuint remainder) remainder -= misalignment; } + else + { + // We can't align, but this also means we're processing the full data from beg + // so account for that to ensure we don't double process and include them in the + // aggregate twice. + + misalignment = (uint)Vector512.Count; + + xPtr += misalignment; + yPtr += misalignment; + + remainder -= misalignment; + } Vector512 vector1; Vector512 vector2; diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/IReadOnlyTensor.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/IReadOnlyTensor.cs index 16319b224c1..9d42fa96d3f 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/IReadOnlyTensor.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/IReadOnlyTensor.cs @@ -5,46 +5,152 @@ using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; -#pragma warning disable 1591 // TODO: Document this API. https://github.com/dotnet/runtime/issues/105981 - namespace System.Numerics.Tensors { + /// + /// Represents a read-only tensor. + /// + /// The type that implements this interface. + /// The element type. [Experimental(Experimentals.TensorTDiagId, UrlFormat = Experimentals.SharedUrlFormat)] public interface IReadOnlyTensor : IEnumerable where TSelf : IReadOnlyTensor { + /// + /// Gets an empty tensor. + /// static abstract TSelf? Empty { get; } + /// + /// Gets a value that indicates whether the collection is currently empty. + /// bool IsEmpty { get; } + + /// + /// Gets a value that indicates whether the underlying buffer is pinned. + /// bool IsPinned { get; } + + /// + /// Gets the number of elements in the tensor. + /// nint FlattenedLength { get; } + + /// + /// Gets the number of dimensions in the tensor. + /// int Rank { get; } + /// + /// Gets the value at the specified indexes. + /// + /// The indexes to be used. T this[params scoped ReadOnlySpan indexes] { get; } + + /// + /// Gets the value at the specified indexes. + /// + /// The indexes to be used. T this[params scoped ReadOnlySpan indexes] { get; } + + /// + /// Gets the values at the specified ranges. + /// + /// The ranges to be used. TSelf this[params scoped ReadOnlySpan ranges] { get; } + /// + /// Creates a read-only tensor span for the entire underlying buffer. + /// + /// The converted . ReadOnlyTensorSpan AsReadOnlyTensorSpan(); + + /// + /// Creates a read-only tensor span for the specified start indexes. + /// + /// The start locations to be used. + /// The converted . ReadOnlyTensorSpan AsReadOnlyTensorSpan(params scoped ReadOnlySpan start); + + /// + /// Creates a read-only tensor span for the specified start indexes. + /// + /// The started indexes to be used. + /// The converted . ReadOnlyTensorSpan AsReadOnlyTensorSpan(params scoped ReadOnlySpan startIndex); + + /// + /// Creates a read-only tensor span for the specified ranges. + /// + /// The ranges to be used. + /// The converted . ReadOnlyTensorSpan AsReadOnlyTensorSpan(params scoped ReadOnlySpan range); + /// + /// Copies the tensor to the specified destination. The destination tensor must be equal to or larger than the source tensor. + /// + /// The destination span where the data should be copied to. void CopyTo(scoped TensorSpan destination); + + /// + /// Flattens the tensor to the specified destination. The destination span must be equal to or larger than the number of elements in the source tensor. + /// + /// The destination span where the data should be flattened to. void FlattenTo(scoped Span destination); + /// + /// Gets the length of each dimension in the tensor. + /// [UnscopedRef] ReadOnlySpan Lengths { get; } + /// + /// Gets the stride of each dimension in the tensor. + /// [UnscopedRef] ReadOnlySpan Strides { get; } + /// + /// Returns a reference to the 0th element of the tensor. If the tensor is empty, returns . + /// + /// + /// This method can be used for pinning and is required to support the use of the tensor within a fixed statement. + /// ref readonly T GetPinnableReference(); + + /// + /// Slices the tensor using the specified start indexes. + /// + /// The start locations to be used. + /// The sliced tensor. TSelf Slice(params scoped ReadOnlySpan start); + + /// + /// Slices the tensor using the specified start indexes. + /// + /// The start indexes to be used. + /// The sliced tensor. TSelf Slice(params scoped ReadOnlySpan startIndex); + + /// + /// Slices the tensor using the specified ranges. + /// + /// The ranges to be used. + /// The sliced tensor. TSelf Slice(params scoped ReadOnlySpan range); + + /// + /// Tries to copy the tensor to the specified destination. The destination tensor must be equal to or larger than the source tensor. + /// + /// The destination span where the data should be copied to. + /// if the copy succeeded, otherwise. bool TryCopyTo(scoped TensorSpan destination); + + /// + /// Tries to flatten the tensor to the specified destination. The destination span must be equal to or larger than the number of elements in the source tensor. + /// + /// The destination span where the data should be flattened to. + /// if the flatten succeeded, otherwise. bool TryFlattenTo(scoped Span destination); } } - -#pragma warning restore 1591 diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ITensor.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ITensor.cs index 3a6ee32d03d..eba3af96f69 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ITensor.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ITensor.cs @@ -4,10 +4,13 @@ using System.Buffers; using System.Diagnostics.CodeAnalysis; -#pragma warning disable 1591 // TODO: Document this API. https://github.com/dotnet/runtime/issues/105981 - namespace System.Numerics.Tensors { + /// + /// Represents a tensor. + /// + /// The type that implements this interface. + /// The element type. [Experimental(Experimentals.TensorTDiagId, UrlFormat = Experimentals.SharedUrlFormat)] public interface ITensor : IReadOnlyTensor @@ -17,27 +20,119 @@ public interface ITensor // It looks like C#/.NET currently hits limitations here as it believes TSelf and T could be the same type // Ideally we could annotate it such that they cannot be the same type and no conflicts would exist + /// + /// Creates a new tensor with the specified lengths. + /// + /// The lengths of each dimension. + /// to pin the underlying buffer. The default is . + /// + /// If is true the underlying buffer is created permanently pinned, otherwise the underlying buffer is not pinned. + /// The underlying buffer is initialized to default values. + /// static abstract TSelf Create(scoped ReadOnlySpan lengths, bool pinned = false); + + /// + /// Creates a new tensor with the specified lengths and strides. + /// + /// The lengths of each dimension. + /// The strides of each dimension. + /// to pin the underlying buffer. The default is . + /// + /// If is true the underlying buffer is created permanently pinned, otherwise the underlying buffer is not pinned. + /// The underlying buffer is initialized to default values. + /// static abstract TSelf Create(scoped ReadOnlySpan lengths, scoped ReadOnlySpan strides, bool pinned = false); + /// + /// Creates a new tensor with the specified lengths and strides. + /// + /// The lengths of each dimension. + /// to pin the underlying buffer. The default is . + /// + /// If is true the underlying buffer is created permanently pinned, otherwise the underlying buffer is not pinned. + /// The underlying buffer is not initialized. + /// static abstract TSelf CreateUninitialized(scoped ReadOnlySpan lengths, bool pinned = false); + + /// + /// Creates a new tensor with the specified lengths and strides. If is true the underlying buffer is + /// created permanently pinned, otherwise the underlying buffer is not pinned. The underlying buffer is not initialized. + /// + /// The lengths of each dimension. + /// The strides of each dimension. + /// to pin the underlying buffer. The default is . + /// + /// If is true the underlying buffer is created permanently pinned, otherwise the underlying buffer is not pinned. + /// The underlying buffer is not initialized. + /// static abstract TSelf CreateUninitialized(scoped ReadOnlySpan lengths, scoped ReadOnlySpan strides, bool pinned = false); + /// + /// Gets a value that idicates whether the collection is read-only. + /// bool IsReadOnly { get; } + /// + /// Gets the value at the specified indexes. + /// + /// The indexes to use. new T this[params scoped ReadOnlySpan indexes] { get; set; } + + /// + /// Gets the value at the specified indexes. + /// + /// The indexes to use. new T this[params scoped ReadOnlySpan indexes] { get; set; } + + /// + /// Gets the values at the specified ranges. + /// + /// The ranges to be used. new TSelf this[params scoped ReadOnlySpan ranges] { get; set; } + /// + /// Creates a tensor span for the entire underlying buffer. + /// + /// The converted . TensorSpan AsTensorSpan(); + + /// + /// Creates a tensor span for the specified start indexes. + /// + /// The start locations to be used. + /// The converted . TensorSpan AsTensorSpan(params scoped ReadOnlySpan start); + + /// + /// Creates a tensor span for the specified start indexes. + /// + /// The start indexes to be used. + /// The converted . TensorSpan AsTensorSpan(params scoped ReadOnlySpan startIndex); + + /// + /// Creates a tensor span for the specified ranges. + /// + /// The ranges to be used. + /// The converted . TensorSpan AsTensorSpan(params scoped ReadOnlySpan range); + /// + /// Clears the tensor. + /// void Clear(); + + /// + /// Fills the contents of this tensor with the given value. + /// void Fill(T value); + + /// + /// Returns a reference to the 0th element of the tensor. If the tensor is empty, returns . + /// + /// + /// This method can be used for pinning and is required to support the use of the tensor within a fixed statement. + /// new ref T GetPinnableReference(); } } - -#pragma warning restore 1591 diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ReadOnlyTensorSpan.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ReadOnlyTensorSpan.cs index b3cfe8d808d..f26c25b4e3f 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ReadOnlyTensorSpan.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/ReadOnlyTensorSpan.cs @@ -7,7 +7,6 @@ using System.Linq; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; -using static System.Runtime.InteropServices.JavaScript.JSType; using EditorBrowsableAttribute = System.ComponentModel.EditorBrowsableAttribute; using EditorBrowsableState = System.ComponentModel.EditorBrowsableState; @@ -16,7 +15,7 @@ namespace System.Numerics.Tensors { /// - /// ReadOnlyTensorSpan represents a contiguous region of arbitrary memory. Unlike arrays, it can point to either managed + /// Represents a contiguous region of arbitrary memory. Unlike arrays, it can point to either managed /// or native memory, or to memory allocated on the stack. It is type-safe and memory-safe. /// [DebuggerTypeProxy(typeof(TensorSpanDebugView<>))] @@ -34,7 +33,7 @@ public readonly ref struct ReadOnlyTensorSpan /// /// The target array. /// Returns default when is null. - /// Thrown when is covariant and array's type is not exactly T[]. + /// is covariant and its type is not exactly T[]. public ReadOnlyTensorSpan(T[]? array) : this(array, 0, [array?.Length ?? 0], []) { } @@ -45,12 +44,11 @@ public ReadOnlyTensorSpan(T[]? array) : this(array, 0, [array?.Length ?? 0], []) /// /// The target array. /// The index at which to begin the span. - /// The lengths of the dimensions. If default is provided its assumed to have 1 dimension with a length equal to the length of the data. - /// The strides of each dimension. If default or span of length 0 is provided then strides will be automatically calculated. + /// The lengths of the dimensions. If default is provided, it's assumed to have one dimension with a length equal to the length of the data. + /// The strides of each dimension. If default or span of length 0 is provided, then strides will be automatically calculated. /// Returns default when is null. - /// Thrown when is covariant and array's type is not exactly T[]. - /// - /// Thrown when the specified or end index is not in the range (<0 or >FlattenedLength). + /// is covariant and its type is not exactly T[]. + /// The specified or end index is not in the range (<0 or >FlattenedLength). /// public ReadOnlyTensorSpan(T[]? array, Index startIndex, scoped ReadOnlySpan lengths, scoped ReadOnlySpan strides) : this(array, startIndex.GetOffset(array?.Length ?? 0), lengths, strides) @@ -63,10 +61,10 @@ public ReadOnlyTensorSpan(T[]? array, Index startIndex, scoped ReadOnlySpan /// The target array. /// The index at which to begin the span. - /// The lengths of the dimensions. If default is provided its assumed to have 1 dimension with a length equal to the length of the data. - /// The strides of each dimension. If default or span of length 0 is provided then strides will be automatically calculated. + /// The lengths of the dimensions. If default is provided, it's assumed to have one dimension with a length equal to the length of the data. + /// The strides of each dimension. If default or span of length 0 is provided, then strides will be automatically calculated. /// Returns default when is null. - /// Thrown when is covariant and array's type is not exactly T[]. + /// is covariant and its type is not exactly T[]. /// /// Thrown when the specified or end index is not in the range (<0 or >FlattenedLength). /// @@ -84,6 +82,7 @@ public ReadOnlyTensorSpan(T[]? array, int start, scoped ReadOnlySpan lengt this = default; return; // returns default } + if (!typeof(T).IsValueType && array.GetType() != typeof(T[])) ThrowHelper.ThrowArrayTypeMismatchException(); @@ -116,11 +115,10 @@ public ReadOnlyTensorSpan(ReadOnlySpan span) : this(span, [span.Length], []) /// /// Creates a new over the provided using the specified lengths and strides. - /// If the strides are not provided, they will be automatically calculated. /// /// The target span. /// The lengths of each dimension. - /// The strides for each dimension. Will be automatically calculated if not provided. + /// The strides for each dimension. The strides will be automatically calculated if not provided. public ReadOnlyTensorSpan(ReadOnlySpan span, scoped ReadOnlySpan lengths, scoped ReadOnlySpan strides) { if (lengths.IsEmpty) @@ -131,7 +129,7 @@ public ReadOnlyTensorSpan(ReadOnlySpan span, scoped ReadOnlySpan length strides = strides.IsEmpty ? (ReadOnlySpan)TensorSpanHelpers.CalculateStrides(lengths, linearLength) : strides; TensorSpanHelpers.ValidateStrides(strides, lengths); nint maxElements = TensorSpanHelpers.ComputeMaxLinearIndex(strides, lengths); - if (maxElements >= span.Length && span.Length != 0) + if (span.IsEmpty ? maxElements != 0 : maxElements >= span.Length) ThrowHelper.ThrowArgument_InvalidStridesAndLengths(); _shape = new TensorShape(span.Length, lengths, strides); @@ -147,12 +145,11 @@ public ReadOnlyTensorSpan(Array? array) : this(array, ReadOnlySpan.Empty, a /// /// Creates a new over the provided using the specified start offsets, lengths, and strides. - /// If the strides are not provided, they will be automatically calculated. /// /// The target array. /// The starting offset for each dimension. /// The lengths of each dimension. - /// The strides for each dimension. Will be automatically calculated if not provided. + /// The strides for each dimension. This strides will be automatically calculated if not provided. public ReadOnlyTensorSpan(Array? array, scoped ReadOnlySpan start, scoped ReadOnlySpan lengths, scoped ReadOnlySpan strides) { if (lengths.IsEmpty && array != null) @@ -166,7 +163,7 @@ public ReadOnlyTensorSpan(Array? array, scoped ReadOnlySpan start, scoped R this = default; return; // returns default } - if (!typeof(T).IsValueType && array.GetType() != typeof(T[])) + if (array.GetType().GetElementType() != typeof(T)) ThrowHelper.ThrowArrayTypeMismatchException(); strides = strides.IsEmpty ? (ReadOnlySpan)TensorSpanHelpers.CalculateStrides(lengths, linearLength) : strides; @@ -192,12 +189,11 @@ public ReadOnlyTensorSpan(Array? array, scoped ReadOnlySpan start, scoped R /// /// Creates a new over the provided using the specified start offsets, lengths, and strides. - /// If the strides are not provided, they will be automatically calculated. /// /// The target array. /// The starting offset for each dimension. /// The lengths of each dimension. - /// The strides for each dimension. Will be automatically calculated if not provided. + /// The strides for each dimension. The strides will be automatically calculated if not provided. public ReadOnlyTensorSpan(Array? array, scoped ReadOnlySpan startIndex, scoped ReadOnlySpan lengths, scoped ReadOnlySpan strides) { if (lengths.IsEmpty && array != null) @@ -211,7 +207,7 @@ public ReadOnlyTensorSpan(Array? array, scoped ReadOnlySpan startIndex, this = default; return; // returns default } - if (!typeof(T).IsValueType && array.GetType() != typeof(T[])) + if (array.GetType().GetElementType() != typeof(T)) ThrowHelper.ThrowArrayTypeMismatchException(); strides = strides.IsEmpty ? (ReadOnlySpan)TensorSpanHelpers.CalculateStrides(lengths, linearLength) : strides; @@ -236,30 +232,34 @@ public ReadOnlyTensorSpan(Array? array, scoped ReadOnlySpan startIndex, } /// - /// Creates a new span over the target unmanaged buffer. Clearly this - /// is quite dangerous the length is not checked. - /// But if this creation is correct, then all subsequent uses are correct. + /// Creates a new span over the target unmanaged buffer. /// - /// An unmanaged data to memory. + /// An unmanaged data that points to memory. /// The number of elements the unmanaged memory can hold. + /// + /// This constructor is quite dangerous, because the length is not checked. + /// But if this creation is correct, then all subsequent uses are correct. + /// [CLSCompliant(false)] public unsafe ReadOnlyTensorSpan(T* data, nint dataLength) : this(data, dataLength, [dataLength], []) { } /// - /// Creates a new span over the target unmanaged buffer. Clearly this - /// is quite dangerous, because the length is not checked. - /// But if this creation is correct, then all subsequent uses are correct. + /// Creates a new span over the target unmanaged buffer. /// - /// An unmanaged data to memory. + /// An unmanaged data that points to memory. /// The number of elements the unmanaged memory can hold. - /// The lengths of the dimensions. If default is provided its assumed to have 1 dimension with a length equal to the length of the data. - /// The lengths of the strides. If nothing is provided it figures out the default stride configuration. + /// The lengths of the dimensions. If default is provided, it's assumed to have one dimension with a length equal to the length of the data. + /// The lengths of the strides. If nothing is provided, it figures out the default stride configuration. /// - /// Thrown when is reference type or contains pointers and hence cannot be stored in unmanaged memory. + /// is a reference type or contains pointers and hence cannot be stored in unmanaged memory. /// /// - /// Thrown when the specified length is negative. + /// The specified length is negative. /// + /// + /// This constructor is quite dangerous, because the length is not checked. + /// But if this creation is correct, then all subsequent uses are correct. + /// [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] public unsafe ReadOnlyTensorSpan(T* data, nint dataLength, scoped ReadOnlySpan lengths, scoped ReadOnlySpan strides) @@ -301,7 +301,7 @@ internal ReadOnlyTensorSpan(ref T reference, scoped ReadOnlySpan lengths, /// /// /// - /// Thrown when any index is less than 0 or any index is greater than or equal to FlattenedLength + /// Any index is less than 0 or any index is greater than or equal to FlattenedLength. /// public ref readonly T this[params scoped ReadOnlySpan indexes] { @@ -325,7 +325,7 @@ public ref readonly T this[params scoped ReadOnlySpan indexes] /// /// /// - /// Thrown when any index is less than 0 or any index is greater than or equal to FlattenedLength + /// Any index is less than 0 or any index is greater than or equal to FlattenedLength. /// public ref readonly T this[params scoped ReadOnlySpan indexes] { @@ -348,7 +348,7 @@ public ref readonly T this[params scoped ReadOnlySpan indexes] /// /// /// - /// Thrown when any index is less than 0 or any index is greater than or equal to FlattenedLength + /// Any index is less than 0 or any index is greater than or equal to FlattenedLength. /// public ReadOnlyTensorSpan this[params scoped ReadOnlySpan ranges] { @@ -362,7 +362,7 @@ public ReadOnlyTensorSpan this[params scoped ReadOnlySpan ranges] } /// - /// The number of items in the span. + /// Gets the number of items in the span. /// public nint FlattenedLength => _shape.FlattenedLength; @@ -379,25 +379,25 @@ public ReadOnlyTensorSpan this[params scoped ReadOnlySpan ranges] public ReadOnlySpan Lengths => _shape.Lengths; /// - /// Gets the rank, aka the number of dimensions, of this . + /// Gets the rank, or number of dimensions, of this . /// public int Rank => Lengths.Length; /// - /// Gets the strides of this + /// Gets the strides of this . /// [UnscopedRef] public ReadOnlySpan Strides => _shape.Strides; /// - /// Returns false if left and right point at the same memory and have the same length. Note that - /// this does *not* check to see if the *contents* are equal. + /// Compares the given spans and returns false if left and right point at the same memory and have the same length. + /// This opertor does *not* check to see if the *contents* are equal. /// public static bool operator !=(ReadOnlyTensorSpan left, ReadOnlyTensorSpan right) => !(left == right); /// - /// Returns true if left and right point at the same memory and have the same length. Note that - /// this does *not* check to see if the *contents* are equal. + /// Compares the given spans and returns true if left and right point at the same memory and have the same length. + /// This operator does *not* check to see if the *contents* are equal. /// public static bool operator ==(ReadOnlyTensorSpan left, ReadOnlyTensorSpan right) => left._shape.FlattenedLength == right._shape.FlattenedLength && @@ -406,10 +406,10 @@ public ReadOnlyTensorSpan this[params scoped ReadOnlySpan ranges] Unsafe.AreSame(ref left._reference, ref right._reference); /// - /// This method is not supported as spans cannot be boxed. To compare two spans, use operator==. + /// This method is not supported as spans cannot be boxed. To compare two spans, use operator ==. /// /// - /// Always thrown by this method. + /// In all cases. /// #pragma warning disable CS0809 // Obsolete member overrides non-obsolete member [Obsolete("Equals() on ReadOnlyTensorSpan will always throw an exception. Use the equality operator instead.")] @@ -421,7 +421,7 @@ public override bool Equals(object? obj) => /// This method is not supported as spans cannot be boxed. /// /// - /// Always thrown by this method. + /// In all cases. /// [Obsolete("GetHashCode() on ReadOnlyTensorSpan will always throw an exception.")] [EditorBrowsable(EditorBrowsableState.Never)] @@ -459,7 +459,7 @@ public ref struct Enumerator /// The total item count. private nint _items; - /// Initialize the enumerator. + /// Initializes the enumerator. /// The span to enumerate. [MethodImpl(MethodImplOptions.AggressiveInlining)] internal Enumerator(ReadOnlyTensorSpan span) @@ -492,8 +492,10 @@ public ref readonly T Current /// /// Returns a reference to the 0th element of the ReadOnlyTensorSpan. If the ReadOnlyTensorSpan is empty, returns null reference. - /// It can be used for pinning and is required to support the use of span within a fixed statement. /// + /// + /// This method can be used for pinning and is required to support the use of span within a fixed statement. + /// [EditorBrowsable(EditorBrowsableState.Never)] public ref readonly T GetPinnableReference() { @@ -505,12 +507,12 @@ public ref readonly T GetPinnableReference() /// /// Copies the contents of this read-only span into destination span. If the source - /// and destinations overlap, this method behaves as if the original values in + /// and destinations overlap, this method behaves as if the original values are in /// a temporary location before the destination is overwritten. /// /// The span to copy items into. /// - /// Thrown when the destination ReadOnlyTensorSpan is shorter than the source ReadOnlyTensorSpan. + /// The destination ReadOnlyTensorSpan is shorter than the source ReadOnlyTensorSpan. /// [MethodImpl(MethodImplOptions.AggressiveInlining)] public void CopyTo(scoped TensorSpan destination) @@ -525,14 +527,14 @@ public void CopyTo(scoped TensorSpan destination) if (Rank > TensorShape.MaxInlineRank) { curIndexesArray = ArrayPool.Shared.Rent(Rank); - curIndexes = curIndexesArray; - curIndexes = curIndexes.Slice(0, Rank); + curIndexes = curIndexesArray.AsSpan(0, Rank); } else { curIndexesArray = null; curIndexes = stackalloc nint[Rank]; } + curIndexes.Clear(); nint copiedValues = 0; TensorSpan slice = destination.Slice(_shape.Lengths); @@ -554,13 +556,14 @@ public void CopyTo(scoped TensorSpan destination) } /// - /// Copies the contents of this read-only span into destination span. If the source - /// and destinations overlap, this method behaves as if the original values in - /// a temporary location before the destination is overwritten. + /// Copies the contents of this read-only span into destination span. /// - /// If the destination span is shorter than the source span, this method - /// return false and no data is written to the destination. + /// if the copy succeeded; if the destination span is shorter than the source span and no data is written to the destination. /// The span to copy items into. + /// + /// If the source and destinations overlap, this method behaves as if + /// the original values are in a temporary location before the destination is overwritten. + /// public bool TryCopyTo(scoped TensorSpan destination) { bool retVal = false; @@ -572,14 +575,14 @@ public bool TryCopyTo(scoped TensorSpan destination) if (Rank > TensorShape.MaxInlineRank) { curIndexesArray = ArrayPool.Shared.Rent(Rank); - curIndexes = curIndexesArray; - curIndexes = curIndexes.Slice(0, Rank); + curIndexes = curIndexesArray.AsSpan(0, Rank); } else { curIndexesArray = null; curIndexes = stackalloc nint[Rank]; } + curIndexes.Clear(); nint copiedValues = 0; TensorSpan slice = destination.Slice(_shape.Lengths); @@ -599,10 +602,10 @@ public bool TryCopyTo(scoped TensorSpan destination) return retVal; } - //public static explicit operator TensorSpan(Array? array); -#pragma warning disable 1591 // TODO: Document this API. https://github.com/dotnet/runtime/issues/105981 + /// + /// Defines an implicit conversion of an array to a . + /// public static implicit operator ReadOnlyTensorSpan(T[]? array) => new ReadOnlyTensorSpan(array); -#pragma warning restore 1591 /// /// Returns a with the name of the type and the number of elements. @@ -614,8 +617,7 @@ public bool TryCopyTo(scoped TensorSpan destination) /// /// The indexes for the slice. /// - /// - /// Thrown when any index is less than 0 or any index is greater than or equal to FlattenedLength + /// Any index is less than 0 or greater than or equal to FlattenedLength. /// public ReadOnlyTensorSpan Slice(params scoped ReadOnlySpan indexes) { @@ -630,8 +632,8 @@ public ReadOnlyTensorSpan Slice(params scoped ReadOnlySpan indexes) /// /// Takes in the lengths of the dimensions and slices according to them. /// - /// The dimension lengths - /// A based on the provided + /// The dimension lengths. + /// A based on the provided . internal ReadOnlyTensorSpan Slice(scoped ReadOnlySpan lengths) { NRange[] ranges = new NRange[lengths.Length]; @@ -643,44 +645,68 @@ internal ReadOnlyTensorSpan Slice(scoped ReadOnlySpan lengths) } /// - /// Forms a slice out of the given span + /// Forms a slice out of the given span. /// - /// The ranges for the slice - /// A based on the provided + /// The ranges for the slice. + /// A based on the provided . public ReadOnlyTensorSpan Slice(params scoped ReadOnlySpan ranges) { if (ranges.Length != Lengths.Length) throw new ArgumentOutOfRangeException(nameof(ranges), "Number of dimensions to slice does not equal the number of dimensions in the span"); + ReadOnlyTensorSpan toReturn; scoped Span lengths; scoped Span offsets; + nint[]? lengthsArray; + nint[]? offsetsArray; if (Rank > TensorShape.MaxInlineRank) { - lengths = stackalloc nint[Rank]; - offsets = stackalloc nint[Rank]; + lengthsArray = ArrayPool.Shared.Rent(Rank); + lengths = lengthsArray.AsSpan(0, Rank); + + offsetsArray = ArrayPool.Shared.Rent(Rank); + offsets = offsetsArray.AsSpan(0, Rank); } else { - lengths = new nint[Rank]; - offsets = new nint[Rank]; + lengths = stackalloc nint[Rank]; + offsets = stackalloc nint[Rank]; + + lengthsArray = null; + offsetsArray = null; } + lengths.Clear(); + offsets.Clear(); for (int i = 0; i < ranges.Length; i++) { (offsets[i], lengths[i]) = ranges[i].GetOffsetAndLength(Lengths[i]); } + // FlattenedLength is computed everytime so using a local to cache the value. + nint flattenedLength = FlattenedLength; nint index = 0; - for (int i = 0; i < offsets.Length; i++) + + if (flattenedLength != 0) { - index += Strides[i] * (offsets[i]); + for (int i = 0; i < offsets.Length; i++) + { + index += Strides[i] * (offsets[i]); + } } - if (index >= _shape._memoryLength || index < 0) + if ((index >= _shape._memoryLength || index < 0) && flattenedLength != 0) ThrowHelper.ThrowIndexOutOfRangeException(); - return new ReadOnlyTensorSpan(ref Unsafe.Add(ref _reference, index), lengths, _shape.Strides, _shape._memoryLength - index); + toReturn = new ReadOnlyTensorSpan(ref Unsafe.Add(ref _reference, index), lengths, _shape.Strides, _shape._memoryLength - index); + + if (offsetsArray != null) + ArrayPool.Shared.Return(offsetsArray); + if (lengthsArray != null) + ArrayPool.Shared.Return(lengthsArray); + + return toReturn; } /// @@ -697,14 +723,14 @@ public bool TryFlattenTo(scoped Span destination) if (Rank > TensorShape.MaxInlineRank) { curIndexesArray = ArrayPool.Shared.Rent(Rank); - curIndexes = curIndexesArray; - curIndexes = curIndexes.Slice(0, Rank); + curIndexes = curIndexesArray.AsSpan(0, Rank); } else { curIndexesArray = null; curIndexes = stackalloc nint[Rank]; } + curIndexes.Clear(); nint copiedValues = 0; while (copiedValues < _shape.FlattenedLength) @@ -738,14 +764,14 @@ public void FlattenTo(scoped Span destination) if (Rank > TensorShape.MaxInlineRank) { curIndexesArray = ArrayPool.Shared.Rent(Rank); - curIndexes = curIndexesArray; - curIndexes = curIndexes.Slice(0, Rank); + curIndexes = curIndexesArray.AsSpan(0, Rank); } else { curIndexesArray = null; curIndexes = stackalloc nint[Rank]; } + curIndexes.Clear(); nint copiedValues = 0; while (copiedValues < _shape.FlattenedLength) diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.Factory.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.Factory.cs index 373567e119c..1e3904fb750 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.Factory.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.Factory.cs @@ -12,6 +12,9 @@ namespace System.Numerics.Tensors { + /// + /// Provides methods for creating tensors. + /// public static partial class Tensor { /// @@ -175,7 +178,14 @@ public static Tensor CreateUninitialized(scoped ReadOnlySpan lengths return new Tensor(values, lengths, strides, pinned); } -#pragma warning disable 1591 // TODO: Document this API. https://github.com/dotnet/runtime/issues/105981 + /// + /// Fills the given with random data in a Gaussian normal distribution. + /// can optionally be provided for seeding. + /// + /// The element type. + /// The destination where the data will be stored. + /// to provide random seeding. Defaults to if not provided. + /// public static ref readonly TensorSpan FillGaussianNormalDistribution(in TensorSpan destination, Random? random = null) where T : IFloatingPoint { Span span = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape._memoryLength); @@ -185,6 +195,14 @@ public static ref readonly TensorSpan FillGaussianNormalDistribution(in Te return ref destination; } + /// + /// Fills the given with random data in a uniform distribution. + /// can optionally be provided for seeding. + /// + /// The element type. + /// The destination where the data will be stored. + /// to provide random seeding. Defaults to if not provided. + /// public static ref readonly TensorSpan FillUniformDistribution(in TensorSpan destination, Random? random = null) where T : IFloatingPoint { Span span = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape._memoryLength); @@ -194,6 +212,5 @@ public static ref readonly TensorSpan FillUniformDistribution(in TensorSpa return ref destination; } -#pragma warning restore 1591 } } diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs index 76434215704..81c22de5fcf 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/Tensor.cs @@ -18,11 +18,12 @@ namespace System.Numerics.Tensors { + /// + /// Represents a tensor. + /// [Experimental(Experimentals.TensorTDiagId, UrlFormat = Experimentals.SharedUrlFormat)] -#pragma warning disable 1591 // TODO: Document this API. https://github.com/dotnet/runtime/issues/105981 public sealed class Tensor : ITensor, T> -#pragma warning restore 1591 { /// A byref or a native ptr. internal readonly T[] _values; @@ -367,13 +368,20 @@ public Tensor this[Tensor filter] } } -#pragma warning disable 1591 // TODO: Document this API. https://github.com/dotnet/runtime/issues/105981 + /// + /// Defines an implicit conversion of an array to a . + /// public static implicit operator Tensor(T[] array) => new Tensor(array, [array.Length]); + /// + /// Defines an implicit conversion of a to a . + /// public static implicit operator TensorSpan(Tensor value) => new TensorSpan(ref MemoryMarshal.GetArrayDataReference(value._values), value._lengths, value._strides, value._flattenedLength); + /// + /// Defines an implicit conversion of a to a . + /// public static implicit operator ReadOnlyTensorSpan(Tensor value) => new ReadOnlyTensorSpan(ref MemoryMarshal.GetArrayDataReference(value._values), value._lengths, value._strides, value.FlattenedLength); -#pragma warning restore 1591 /// /// Converts this to a pointing to the same backing memory."/> @@ -618,12 +626,15 @@ public void Dispose() } // REVIEW: PENDING API REVIEW TO DETERMINE IMPLEMENTATION -#pragma warning disable 1591 // TODO: Document this API. https://github.com/dotnet/runtime/issues/105981 + /// + /// Gets the hash code for the . + /// + /// The hash code of the tensor. + /// In all cases. public override int GetHashCode() { throw new NotImplementedException(); } -#pragma warning restore 1591 /// /// Get a string representation of the tensor. diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorExtensions.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorExtensions.cs index ac925475a27..911da9a560e 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorExtensions.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorExtensions.cs @@ -18,10 +18,11 @@ namespace System.Numerics.Tensors { + /// + /// Provides methods for tensor operations. + /// [Experimental(Experimentals.TensorTDiagId, UrlFormat = Experimentals.SharedUrlFormat)] -#pragma warning disable 1591 // TODO: Document this API. https://github.com/dotnet/runtime/issues/105981 public static partial class Tensor -#pragma warning restore 1591 { #region AsReadOnlySpan /// @@ -55,7 +56,7 @@ public static T Average(scoped in ReadOnlyTensorSpan x) where T : IFloatingPoint { T sum = Sum(x); - return T.CreateChecked(sum / T.CreateChecked(x._shape._memoryLength)); + return T.CreateChecked(sum / T.CreateChecked(x.FlattenedLength)); } #endregion @@ -98,7 +99,7 @@ public static void BroadcastTo(this Tensor source, in TensorSpan destin { nint[] newSize = Tensor.GetSmallestBroadcastableLengths(source.Lengths, destination.Lengths); if (!destination.Lengths.SequenceEqual(newSize)) - ThrowHelper.ThrowArgument_ShapesNotBroadcastCompatible(); + ThrowHelper.ThrowArgument_LengthsNotBroadcastCompatible(); ReadOnlyTensorSpan intermediate = LazyBroadcast(source, newSize); intermediate.FlattenTo(MemoryMarshal.CreateSpan(ref destination._reference, (int)destination.FlattenedLength)); @@ -113,7 +114,7 @@ public static void BroadcastTo(in this TensorSpan source, in TensorSpan { nint[] newSize = Tensor.GetSmallestBroadcastableLengths(source.Lengths, destination.Lengths); if (!destination.Lengths.SequenceEqual(newSize)) - ThrowHelper.ThrowArgument_ShapesNotBroadcastCompatible(); + ThrowHelper.ThrowArgument_LengthsNotBroadcastCompatible(); ReadOnlyTensorSpan intermediate = LazyBroadcast(source, newSize); intermediate.FlattenTo(MemoryMarshal.CreateSpan(ref destination._reference, (int)destination.FlattenedLength)); @@ -128,7 +129,7 @@ public static void BroadcastTo(in this ReadOnlyTensorSpan source, in Tenso { nint[] newSize = Tensor.GetSmallestBroadcastableLengths(source.Lengths, destination.Lengths); if (!destination.Lengths.SequenceEqual(newSize)) - ThrowHelper.ThrowArgument_ShapesNotBroadcastCompatible(); + ThrowHelper.ThrowArgument_LengthsNotBroadcastCompatible(); ReadOnlyTensorSpan intermediate = LazyBroadcast(source, newSize); intermediate.FlattenTo(MemoryMarshal.CreateSpan(ref destination._reference, (int)destination.FlattenedLength)); @@ -149,7 +150,7 @@ internal static TensorSpan LazyBroadcast(in TensorSpan input, ReadOnlyS return new TensorSpan(ref input._reference, shape, input.Strides, input._shape._memoryLength); if (!TensorHelpers.IsBroadcastableTo(input.Lengths, shape)) - ThrowHelper.ThrowArgument_ShapesNotBroadcastCompatible(); + ThrowHelper.ThrowArgument_LengthsNotBroadcastCompatible(); nint newSize = TensorSpanHelpers.CalculateTotalLength(shape); @@ -192,7 +193,7 @@ internal static ReadOnlyTensorSpan LazyBroadcast(in ReadOnlyTensorSpan return new TensorSpan(ref input._reference, shape, input.Strides, input._shape._memoryLength); if (!TensorHelpers.IsBroadcastableTo(input.Lengths, shape)) - ThrowHelper.ThrowArgument_ShapesNotBroadcastCompatible(); + ThrowHelper.ThrowArgument_LengthsNotBroadcastCompatible(); nint newSize = TensorSpanHelpers.CalculateTotalLength(shape); @@ -235,7 +236,7 @@ internal static Tensor LazyBroadcast(Tensor input, ReadOnlySpan l return new Tensor(input._values, lengths, false); if (!TensorHelpers.IsBroadcastableTo(input.Lengths, lengths)) - ThrowHelper.ThrowArgument_ShapesNotBroadcastCompatible(); + ThrowHelper.ThrowArgument_LengthsNotBroadcastCompatible(); nint newSize = TensorSpanHelpers.CalculateTotalLength(lengths); @@ -394,16 +395,18 @@ public static ref readonly TensorSpan ConcatenateOnDimension(int dimension scoped Span curIndex; nint[]? curIndexArray; - if (tensors[0].Rank > 6) + if (tensors[0].Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(tensors[0].Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, tensors[0].Rank); } else { curIndexArray = null; curIndex = stackalloc nint[tensors[0].Rank]; } + curIndex.Clear(); + nint srcIndex; nint copyLength; @@ -498,16 +501,17 @@ public static ref readonly TensorSpan Equals(scoped in ReadOnlyTensorSp scoped Span curIndex; nint[]? curIndexArray; - if (right.Rank > 6) + if (right.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(right.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, right.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[right.Rank]; } + curIndex.Clear(); for (int i = 0; i < left.FlattenedLength; i++) { @@ -553,16 +557,17 @@ public static ref readonly TensorSpan Equals(scoped in ReadOnlyTensorSp scoped Span curIndex; nint[]? curIndexArray; - if (x.Rank > 6) + if (x.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(x.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, x.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[x.Rank]; } + curIndex.Clear(); for (int i = 0; i < x.FlattenedLength; i++) { @@ -597,16 +602,17 @@ public static bool EqualsAll(in ReadOnlyTensorSpan x, in ReadOnlyTensorSpa scoped Span curIndex; nint[]? curIndexArray; - if (broadcastedLeft.Rank > 6) + if (broadcastedLeft.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(broadcastedRight.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, broadcastedRight.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[broadcastedRight.Rank]; } + curIndex.Clear(); for (int i = 0; i < broadcastedLeft.FlattenedLength; i++) { @@ -635,16 +641,17 @@ public static bool EqualsAll(in ReadOnlyTensorSpan x, T y) scoped Span curIndex; nint[]? curIndexArray; - if (x.Rank > 6) + if (x.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(x.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, x.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[x.Rank]; } + curIndex.Clear(); for (int i = 0; i < x.FlattenedLength; i++) { @@ -679,16 +686,17 @@ public static bool EqualsAny(in ReadOnlyTensorSpan x, in ReadOnlyTensorSpa scoped Span curIndex; nint[]? curIndexArray; - if (broadcastedRight.Lengths.Length > 6) + if (broadcastedRight.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(broadcastedRight.Lengths.Length); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, broadcastedRight.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[broadcastedRight.Lengths.Length]; } + curIndex.Clear(); for (int i = 0; i < broadcastedLeft.FlattenedLength; i++) { @@ -717,16 +725,17 @@ public static bool EqualsAny(in ReadOnlyTensorSpan x, T y) scoped Span curIndex; nint[]? curIndexArray; - if (x.Rank > 6) + if (x.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(x.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, x.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[x.Rank]; } + curIndex.Clear(); for (int i = 0; i < x.FlattenedLength; i++) { @@ -863,16 +872,17 @@ public static ref readonly TensorSpan GreaterThan(scoped in ReadOnlyTen scoped Span curIndex; nint[]? curIndexArray; - if (right.Rank > 6) + if (right.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(right.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, right.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[right.Rank]; } + curIndex.Clear(); for (int i = 0; i < left.FlattenedLength; i++) { @@ -922,16 +932,17 @@ public static ref readonly TensorSpan GreaterThan(scoped in ReadOnlyTen scoped Span curIndex; nint[]? curIndexArray; - if (x.Rank > 6) + if (x.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(x.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, x.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[x.Rank]; } + curIndex.Clear(); for (int i = 0; i < x.FlattenedLength; i++) { @@ -981,16 +992,17 @@ public static ref readonly TensorSpan GreaterThan(T x, scoped in ReadOn scoped Span curIndex; nint[]? curIndexArray; - if (y.Rank > 6) + if (y.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(y.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, y.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[y.Rank]; } + curIndex.Clear(); for (int i = 0; i < y.FlattenedLength; i++) { @@ -1069,16 +1081,17 @@ public static ref readonly TensorSpan GreaterThanOrEqual(scoped in Read scoped Span curIndex; nint[]? curIndexArray; - if (right.Rank > 6) + if (right.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(right.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, right.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[right.Rank]; } + curIndex.Clear(); for (int i = 0; i < left.FlattenedLength; i++) { @@ -1128,16 +1141,17 @@ public static ref readonly TensorSpan GreaterThanOrEqual(scoped in Read scoped Span curIndex; nint[]? curIndexArray; - if (x.Rank > 6) + if (x.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(x.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, x.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[x.Rank]; } + curIndex.Clear(); for (int i = 0; i < x.FlattenedLength; i++) { @@ -1187,16 +1201,17 @@ public static ref readonly TensorSpan GreaterThanOrEqual(T x, scoped in scoped Span curIndex; nint[]? curIndexArray; - if (y.Rank > 6) + if (y.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(y.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, y.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[y.Rank]; } + curIndex.Clear(); for (int i = 0; i < y.FlattenedLength; i++) { @@ -1230,16 +1245,17 @@ public static bool GreaterThanAny(in ReadOnlyTensorSpan x, in ReadOnlyTens scoped Span curIndex; nint[]? curIndexArray; - if (broadcastedRight.Lengths.Length > 6) + if (broadcastedRight.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(broadcastedRight.Lengths.Length); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, broadcastedRight.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[broadcastedRight.Lengths.Length]; } + curIndex.Clear(); for (int i = 0; i < broadcastedLeft.FlattenedLength; i++) { @@ -1268,16 +1284,17 @@ public static bool GreaterThanAny(in ReadOnlyTensorSpan x, T y) scoped Span curIndex; nint[]? curIndexArray; - if (x.Rank > 6) + if (x.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(x.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, x.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[x.Rank]; } + curIndex.Clear(); for (int i = 0; i < x.FlattenedLength; i++) { @@ -1306,16 +1323,17 @@ public static bool GreaterThanAny(T x, in ReadOnlyTensorSpan y) scoped Span curIndex; nint[]? curIndexArray; - if (y.Rank > 6) + if (y.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(y.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, y.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[y.Rank]; } + curIndex.Clear(); for (int i = 0; i < y.FlattenedLength; i++) { @@ -1350,16 +1368,17 @@ public static bool GreaterThanOrEqualAny(in ReadOnlyTensorSpan x, in ReadO scoped Span curIndex; nint[]? curIndexArray; - if (broadcastedRight.Lengths.Length > 6) + if (broadcastedRight.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(broadcastedRight.Lengths.Length); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, broadcastedRight.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[broadcastedRight.Lengths.Length]; } + curIndex.Clear(); for (int i = 0; i < broadcastedLeft.FlattenedLength; i++) { @@ -1388,16 +1407,17 @@ public static bool GreaterThanOrEqualAny(in ReadOnlyTensorSpan x, T y) scoped Span curIndex; nint[]? curIndexArray; - if (x.Rank > 6) + if (x.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(x.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, x.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[x.Rank]; } + curIndex.Clear(); for (int i = 0; i < x.FlattenedLength; i++) { @@ -1426,16 +1446,17 @@ public static bool GreaterThanOrEqualAny(T x, in ReadOnlyTensorSpan y) scoped Span curIndex; nint[]? curIndexArray; - if (y.Rank > 6) + if (y.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(y.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, y.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[y.Rank]; } + curIndex.Clear(); for (int i = 0; i < y.FlattenedLength; i++) { @@ -1471,16 +1492,17 @@ public static bool GreaterThanAll(in ReadOnlyTensorSpan x, in ReadOnlyTens scoped Span curIndex; nint[]? curIndexArray; - if (broadcastedLeft.Rank > 6) + if (broadcastedLeft.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(broadcastedRight.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, broadcastedRight.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[broadcastedRight.Rank]; } + curIndex.Clear(); for (int i = 0; i < broadcastedLeft.FlattenedLength; i++) { @@ -1509,16 +1531,17 @@ public static bool GreaterThanAll(in ReadOnlyTensorSpan x, T y) scoped Span curIndex; nint[]? curIndexArray; - if (x.Rank > 6) + if (x.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(x.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, x.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[x.Rank]; } + curIndex.Clear(); for (int i = 0; i < x.FlattenedLength; i++) { @@ -1547,16 +1570,17 @@ public static bool GreaterThanAll(T x, in ReadOnlyTensorSpan y) scoped Span curIndex; nint[]? curIndexArray; - if (y.Rank > 6) + if (y.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(y.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, y.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[y.Rank]; } + curIndex.Clear(); for (int i = 0; i < y.FlattenedLength; i++) { @@ -1592,16 +1616,17 @@ public static bool GreaterThanOrEqualAll(in ReadOnlyTensorSpan x, in ReadO scoped Span curIndex; nint[]? curIndexArray; - if (broadcastedLeft.Rank > 6) + if (broadcastedLeft.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(broadcastedRight.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, broadcastedRight.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[broadcastedRight.Rank]; } + curIndex.Clear(); for (int i = 0; i < broadcastedLeft.FlattenedLength; i++) { @@ -1617,35 +1642,36 @@ public static bool GreaterThanOrEqualAll(in ReadOnlyTensorSpan x, in ReadO } /// - /// Compares the elements of two to see if all elements of are greater than . + /// Compares the elements of two to see if all elements of are greater than . /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared. - /// It returns a where the value is true if all elements in are greater than . + /// It returns a where the value is true if all elements in are greater than . /// - /// First to compare. + /// First to compare. /// Second to compare against. - /// where the value is true if all elements in are greater than . - public static bool GreaterThanOrEqualAll(in ReadOnlyTensorSpan s, T y) + /// where the value is true if all elements in are greater than . + public static bool GreaterThanOrEqualAll(in ReadOnlyTensorSpan x, T y) where T : IComparisonOperators { scoped Span curIndex; nint[]? curIndexArray; - if (s.Rank > 6) + if (x.Rank > TensorShape.MaxInlineRank) { - curIndexArray = ArrayPool.Shared.Rent(s.Rank); - curIndex = curIndexArray; + curIndexArray = ArrayPool.Shared.Rent(x.Rank); + curIndex = curIndexArray.AsSpan(0, x.Rank); } else { curIndexArray = null; - curIndex = stackalloc nint[s.Rank]; + curIndex = stackalloc nint[x.Rank]; } + curIndex.Clear(); - for (int i = 0; i < s.FlattenedLength; i++) + for (int i = 0; i < x.FlattenedLength; i++) { - if (s[curIndex] < y) + if (x[curIndex] < y) return false; - TensorSpanHelpers.AdjustIndexes(s.Rank - 1, 1, curIndex, s.Lengths); + TensorSpanHelpers.AdjustIndexes(x.Rank - 1, 1, curIndex, x.Lengths); } if (curIndexArray != null) @@ -1668,16 +1694,17 @@ public static bool GreaterThanOrEqualAll(T x, in ReadOnlyTensorSpan y) scoped Span curIndex; nint[]? curIndexArray; - if (y.Rank > 6) + if (y.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(y.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, y.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[y.Rank]; } + curIndex.Clear(); for (int i = 0; i < y.FlattenedLength; i++) { @@ -1757,16 +1784,17 @@ public static ref readonly TensorSpan LessThan(scoped in ReadOnlyTensor scoped Span curIndex; nint[]? curIndexArray; - if (right.Rank > 6) + if (right.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(right.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, right.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[right.Rank]; } + curIndex.Clear(); for (int i = 0; i < left.FlattenedLength; i++) { @@ -1816,16 +1844,17 @@ public static ref readonly TensorSpan LessThan(scoped in ReadOnlyTensor scoped Span curIndex; nint[]? curIndexArray; - if (x.Rank > 6) + if (x.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(x.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, x.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[x.Rank]; } + curIndex.Clear(); for (int i = 0; i < x.FlattenedLength; i++) { @@ -1875,16 +1904,17 @@ public static ref readonly TensorSpan LessThan(T x, scoped in ReadOnlyT scoped Span curIndex; nint[]? curIndexArray; - if (y.Rank > 6) + if (y.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(y.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, y.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[y.Rank]; } + curIndex.Clear(); for (int i = 0; i < y.FlattenedLength; i++) { @@ -1963,16 +1993,17 @@ public static ref readonly TensorSpan LessThanOrEqual(scoped in ReadOnl scoped Span curIndex; nint[]? curIndexArray; - if (right.Rank > 6) + if (right.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(right.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, right.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[right.Rank]; } + curIndex.Clear(); for (int i = 0; i < left.FlattenedLength; i++) { @@ -2022,16 +2053,17 @@ public static ref readonly TensorSpan LessThanOrEqual(scoped in ReadOnl scoped Span curIndex; nint[]? curIndexArray; - if (x.Rank > 6) + if (x.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(x.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, x.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[x.Rank]; } + curIndex.Clear(); for (int i = 0; i < x.FlattenedLength; i++) { @@ -2081,16 +2113,17 @@ public static ref readonly TensorSpan LessThanOrEqual(T x, scoped in Re scoped Span curIndex; nint[]? curIndexArray; - if (y.Rank > 6) + if (y.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(y.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, y.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[y.Rank]; } + curIndex.Clear(); for (int i = 0; i < y.FlattenedLength; i++) { @@ -2125,16 +2158,17 @@ public static bool LessThanAny(in ReadOnlyTensorSpan x, in ReadOnlyTensorS scoped Span curIndex; nint[]? curIndexArray; - if (broadcastedRight.Lengths.Length > 6) + if (broadcastedRight.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(broadcastedRight.Lengths.Length); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, broadcastedRight.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[broadcastedRight.Lengths.Length]; } + curIndex.Clear(); for (int i = 0; i < broadcastedLeft.FlattenedLength; i++) { @@ -2150,35 +2184,36 @@ public static bool LessThanAny(in ReadOnlyTensorSpan x, in ReadOnlyTensorS } /// - /// Compares the elements of two to see if any elements of are less than . + /// Compares the elements of two to see if any elements of are less than . /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared. - /// It returns a where the value is true if any elements in are less than . + /// It returns a where the value is true if any elements in are less than . /// - /// First to compare. - /// Second value to compare against. - /// where the value is true if any elements in are less than . - public static bool LessThanAny(in ReadOnlyTensorSpan f, T x) + /// First to compare. + /// Second value to compare against. + /// where the value is true if any elements in are less than . + public static bool LessThanAny(in ReadOnlyTensorSpan x, T y) where T : IComparisonOperators { scoped Span curIndex; nint[]? curIndexArray; - if (f.Rank > 6) + if (x.Rank > TensorShape.MaxInlineRank) { - curIndexArray = ArrayPool.Shared.Rent(f.Rank); - curIndex = curIndexArray; + curIndexArray = ArrayPool.Shared.Rent(x.Rank); + curIndex = curIndexArray.AsSpan(0, x.Rank); } else { curIndexArray = null; - curIndex = stackalloc nint[f.Rank]; + curIndex = stackalloc nint[x.Rank]; } + curIndex.Clear(); - for (int i = 0; i < f.FlattenedLength; i++) + for (int i = 0; i < x.FlattenedLength; i++) { - if (f[curIndex] < x) + if (x[curIndex] < y) return true; - TensorSpanHelpers.AdjustIndexes(f.Rank - 1, 1, curIndex, f.Lengths); + TensorSpanHelpers.AdjustIndexes(x.Rank - 1, 1, curIndex, x.Lengths); } if (curIndexArray != null) @@ -2201,16 +2236,17 @@ public static bool LessThanAny(T x, in ReadOnlyTensorSpan y) scoped Span curIndex; nint[]? curIndexArray; - if (y.Rank > 6) + if (y.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(y.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, y.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[y.Rank]; } + curIndex.Clear(); for (int i = 0; i < y.FlattenedLength; i++) { @@ -2246,16 +2282,17 @@ public static bool LessThanOrEqualAny(in ReadOnlyTensorSpan x, in ReadOnly scoped Span curIndex; nint[]? curIndexArray; - if (broadcastedRight.Lengths.Length > 6) + if (broadcastedRight.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(broadcastedRight.Lengths.Length); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, broadcastedRight.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[broadcastedRight.Lengths.Length]; } + curIndex.Clear(); for (int i = 0; i < broadcastedLeft.FlattenedLength; i++) { @@ -2271,35 +2308,36 @@ public static bool LessThanOrEqualAny(in ReadOnlyTensorSpan x, in ReadOnly } /// - /// Compares the elements of two to see if any elements of are less than . + /// Compares the elements of two to see if any elements of are less than . /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared. - /// It returns a where the value is true if any elements in are less than . + /// It returns a where the value is true if any elements in are less than . /// - /// First to compare. - /// Second value to compare against. - /// where the value is true if any elements in are less than . - public static bool LessThanOrEqualAny(in ReadOnlyTensorSpan f, T x) + /// First to compare. + /// Second value to compare against. + /// where the value is true if any elements in are less than . + public static bool LessThanOrEqualAny(in ReadOnlyTensorSpan x, T y) where T : IComparisonOperators { scoped Span curIndex; nint[]? curIndexArray; - if (f.Rank > 6) + if (x.Rank > TensorShape.MaxInlineRank) { - curIndexArray = ArrayPool.Shared.Rent(f.Rank); - curIndex = curIndexArray; + curIndexArray = ArrayPool.Shared.Rent(x.Rank); + curIndex = curIndexArray.AsSpan(0, x.Rank); } else { curIndexArray = null; - curIndex = stackalloc nint[f.Rank]; + curIndex = stackalloc nint[x.Rank]; } + curIndex.Clear(); - for (int i = 0; i < f.FlattenedLength; i++) + for (int i = 0; i < x.FlattenedLength; i++) { - if (f[curIndex] <= x) + if (x[curIndex] <= y) return true; - TensorSpanHelpers.AdjustIndexes(f.Rank - 1, 1, curIndex, f.Lengths); + TensorSpanHelpers.AdjustIndexes(x.Rank - 1, 1, curIndex, x.Lengths); } if (curIndexArray != null) @@ -2322,16 +2360,17 @@ public static bool LessThanOrEqualAny(T x, in ReadOnlyTensorSpan y) scoped Span curIndex; nint[]? curIndexArray; - if (y.Rank > 6) + if (y.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(y.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, y.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[y.Rank]; } + curIndex.Clear(); for (int i = 0; i <= y.FlattenedLength; i++) { @@ -2366,16 +2405,17 @@ public static bool LessThanAll(in ReadOnlyTensorSpan x, in ReadOnlyTensorS scoped Span curIndex; nint[]? curIndexArray; - if (broadcastedRight.Lengths.Length > 6) + if (broadcastedRight.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(broadcastedRight.Lengths.Length); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, broadcastedRight.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[broadcastedRight.Lengths.Length]; } + curIndex.Clear(); for (int i = 0; i < broadcastedLeft.FlattenedLength; i++) { @@ -2391,35 +2431,36 @@ public static bool LessThanAll(in ReadOnlyTensorSpan x, in ReadOnlyTensorS } /// - /// Compares the elements of two to see if all elements of are less than . + /// Compares the elements of two to see if all elements of are less than . /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared. - /// It returns a where the value is true if all elements in are less than . + /// It returns a where the value is true if all elements in are less than . /// - /// First to compare. - /// Second value to compare against. - /// where the value is true if all elements in are less than . - public static bool LessThanAll(in ReadOnlyTensorSpan f, T x) + /// First to compare. + /// Second value to compare against. + /// where the value is true if all elements in are less than . + public static bool LessThanAll(in ReadOnlyTensorSpan x, T y) where T : IComparisonOperators { scoped Span curIndex; nint[]? curIndexArray; - if (f.Rank > 6) + if (x.Rank > TensorShape.MaxInlineRank) { - curIndexArray = ArrayPool.Shared.Rent(f.Rank); - curIndex = curIndexArray; + curIndexArray = ArrayPool.Shared.Rent(x.Rank); + curIndex = curIndexArray.AsSpan(0, x.Rank); } else { curIndexArray = null; - curIndex = stackalloc nint[f.Rank]; + curIndex = stackalloc nint[x.Rank]; } + curIndex.Clear(); - for (int i = 0; i < f.FlattenedLength; i++) + for (int i = 0; i < x.FlattenedLength; i++) { - if (f[curIndex] >= x) + if (x[curIndex] >= y) return false; - TensorSpanHelpers.AdjustIndexes(f.Rank - 1, 1, curIndex, f.Lengths); + TensorSpanHelpers.AdjustIndexes(x.Rank - 1, 1, curIndex, x.Lengths); } if (curIndexArray != null) @@ -2442,16 +2483,17 @@ public static bool LessThanAll(T x, in ReadOnlyTensorSpan y) scoped Span curIndex; nint[]? curIndexArray; - if (y.Rank > 6) + if (y.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(y.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, y.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[y.Rank]; } + curIndex.Clear(); for (int i = 0; i < y.FlattenedLength; i++) { @@ -2486,16 +2528,17 @@ public static bool LessThanOrEqualAll(in ReadOnlyTensorSpan x, in ReadOnly scoped Span curIndex; nint[]? curIndexArray; - if (broadcastedRight.Lengths.Length > 6) + if (broadcastedRight.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(broadcastedRight.Lengths.Length); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, broadcastedRight.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[broadcastedRight.Lengths.Length]; } + curIndex.Clear(); for (int i = 0; i < broadcastedLeft.FlattenedLength; i++) { @@ -2511,35 +2554,36 @@ public static bool LessThanOrEqualAll(in ReadOnlyTensorSpan x, in ReadOnly } /// - /// Compares the elements of two to see if all elements of are less than . + /// Compares the elements of two to see if all elements of are less than . /// If the shapes are not the same, the tensors are broadcasted to the smallest broadcastable size before they are compared. - /// It returns a where the value is true if all elements in are less than . + /// It returns a where the value is true if all elements in are less than . /// - /// First to compare. - /// Second value to compare against. - /// where the value is true if all elements in are less than . - public static bool LessThanOrEqualAll(in ReadOnlyTensorSpan f, T x) + /// First to compare. + /// Second value to compare against. + /// where the value is true if all elements in are less than . + public static bool LessThanOrEqualAll(in ReadOnlyTensorSpan x, T y) where T : IComparisonOperators { scoped Span curIndex; nint[]? curIndexArray; - if (f.Rank > 6) + if (x.Rank > TensorShape.MaxInlineRank) { - curIndexArray = ArrayPool.Shared.Rent(f.Rank); - curIndex = curIndexArray; + curIndexArray = ArrayPool.Shared.Rent(x.Rank); + curIndex = curIndexArray.AsSpan(0, x.Rank); } else { curIndexArray = null; - curIndex = stackalloc nint[f.Rank]; + curIndex = stackalloc nint[x.Rank]; } + curIndex.Clear(); - for (int i = 0; i < f.FlattenedLength; i++) + for (int i = 0; i < x.FlattenedLength; i++) { - if (f[curIndex] > x) + if (x[curIndex] > y) return false; - TensorSpanHelpers.AdjustIndexes(f.Rank - 1, 1, curIndex, f.Lengths); + TensorSpanHelpers.AdjustIndexes(x.Rank - 1, 1, curIndex, x.Lengths); } if (curIndexArray != null) @@ -2562,16 +2606,17 @@ public static bool LessThanOrEqualAll(T x, in ReadOnlyTensorSpan y) scoped Span curIndex; nint[]? curIndexArray; - if (y.Rank > 6) + if (y.Rank > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(y.Rank); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, y.Rank); } else { curIndexArray = null; curIndex = stackalloc nint[y.Rank]; } + curIndex.Clear(); for (int i = 0; i < y.FlattenedLength; i++) { @@ -2636,9 +2681,12 @@ public static Tensor PermuteDimensions(this Tensor tensor, params ReadO if (outTensor.Rank > 6) { indicesArray = ArrayPool.Shared.Rent(outTensor.Rank); - indexes = indicesArray; + indexes = indicesArray.AsSpan(0, outTensor.Rank); + indexes.Clear(); + permutedIndicesArray = ArrayPool.Shared.Rent(outTensor.Rank); - permutedIndices = permutedIndicesArray; + permutedIndices = permutedIndicesArray.AsSpan(0, outTensor.Rank); + permutedIndices.Clear(); } else { @@ -2916,9 +2964,12 @@ public static ref readonly TensorSpan ReverseDimension(scoped in ReadOnlyT if (tensor.Rank > 6) { oIndicesArray = ArrayPool.Shared.Rent(tensor.Rank); - oIndices = oIndicesArray; + oIndices = oIndicesArray.AsSpan(0, tensor.Rank); + oIndices.Clear(); + iIndicesArray = ArrayPool.Shared.Rent(tensor.Rank); - iIndices = iIndicesArray; + iIndices = iIndicesArray.AsSpan(0, tensor.Rank); + iIndices.Clear(); } else { @@ -3050,9 +3101,12 @@ public static Tensor[] Split(scoped in ReadOnlyTensorSpan tensor, int s if (tensor.Rank > 6) { oIndicesArray = ArrayPool.Shared.Rent(tensor.Rank); - oIndices = oIndicesArray; + oIndices = oIndicesArray.AsSpan(0, tensor.Rank); + oIndices.Clear(); + iIndicesArray = ArrayPool.Shared.Rent(tensor.Rank); - iIndices = iIndicesArray; + iIndices = iIndicesArray.AsSpan(0, tensor.Rank); + iIndices.Clear(); } else { @@ -3386,7 +3440,8 @@ public static string ToString(this in ReadOnlyTensorSpan tensor, params Re if (tensor.Rank > 6) { curIndexesArray = ArrayPool.Shared.Rent(tensor.Rank); - curIndexes = curIndexesArray; + curIndexes = curIndexesArray.AsSpan(0, tensor.Rank); + curIndexes.Clear(); } else { @@ -4233,7 +4288,7 @@ public static ref readonly TensorSpan ConvertChecked(scoped in where TFrom : IEquatable, IEqualityOperators, INumberBase where TTo : INumberBase { - return ref TensorPrimitivesHelperTFromSpanInTToSpanOut(source, destination, TensorPrimitives.ConvertChecked); + return ref TensorPrimitivesHelperSpanInSpanOut(source, destination, TensorPrimitives.ConvertChecked); } #endregion @@ -4263,7 +4318,7 @@ public static ref readonly TensorSpan ConvertSaturating(scoped where TFrom : IEquatable, IEqualityOperators, INumberBase where TTo : INumberBase { - return ref TensorPrimitivesHelperTFromSpanInTToSpanOut(source, destination, TensorPrimitives.ConvertSaturating); + return ref TensorPrimitivesHelperSpanInSpanOut(source, destination, TensorPrimitives.ConvertSaturating); } #endregion @@ -4293,7 +4348,7 @@ public static ref readonly TensorSpan ConvertTruncating(scoped where TFrom : IEquatable, IEqualityOperators, INumberBase where TTo : INumberBase { - return ref TensorPrimitivesHelperTFromSpanInTToSpanOut(source, destination, TensorPrimitives.ConvertTruncating); + return ref TensorPrimitivesHelperSpanInSpanOut(source, destination, TensorPrimitives.ConvertTruncating); } #endregion @@ -4499,7 +4554,7 @@ public static ref readonly TensorSpan CosineSimilarity(scoped in ReadOnlyT /// This method effectively computes .CosPi([i]). /// /// - /// The angles in x must be in radians. Use or multiply by .Pi/180 to convert degrees to radians. + /// The angles in x must be in radians. Use or multiply by .Pi/180 to convert degrees to radians. /// /// /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different @@ -4522,7 +4577,7 @@ public static Tensor CosPi(in ReadOnlyTensorSpan x) /// This method effectively computes .CosPi([i]). /// /// - /// The angles in x must be in radians. Use or multiply by .Pi/180 to convert degrees to radians. + /// The angles in x must be in radians. Use or multiply by .Pi/180 to convert degrees to radians. /// /// /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different @@ -4963,7 +5018,7 @@ public static Tensor ILogB(in ReadOnlyTensorSpan x) public static ref readonly TensorSpan ILogB(scoped in ReadOnlyTensorSpan x, in TensorSpan destination) where T : IFloatingPointIeee754 { - return ref TensorPrimitivesHelperSpanInIntSpanOut(x, destination, TensorPrimitives.ILogB); + return ref TensorPrimitivesHelperSpanInSpanOut(x, destination, TensorPrimitives.ILogB); } #endregion @@ -5823,8 +5878,7 @@ public static ref readonly TensorSpan Negate(scoped in ReadOnlyTensorSpan< public static T Norm(scoped in ReadOnlyTensorSpan x) where T : IRootFunctions { - ReadOnlySpan span = MemoryMarshal.CreateSpan(ref x._reference, (int)x._shape._memoryLength); - return TensorPrimitives.Norm(span); + return TensorPrimitivesHelperSpanInTOut(x, TensorPrimitives.Norm); } #endregion @@ -6422,8 +6476,7 @@ public static ref readonly TensorSpan Subtract(scoped in ReadOnlyTensorSpa public static T Sum(scoped in ReadOnlyTensorSpan x) where T : IAdditionOperators, IAdditiveIdentity { - ReadOnlySpan span = MemoryMarshal.CreateSpan(ref x._reference, (int)x._shape._memoryLength); - return TensorPrimitives.Sum(span); + return TensorPrimitivesHelperSpanInTOut(x, TensorPrimitives.Sum); } #endregion @@ -6589,11 +6642,17 @@ public static ref readonly TensorSpan Xor(scoped in ReadOnlyTensorSpan } #endregion -#pragma warning disable 1591 // TODO: Document this API. https://github.com/dotnet/runtime/issues/105981 + /// + /// Gets the smallest broadcastable lengths for two shapes. + /// + /// The first shape to broadcast. + /// The second shape to broadcast. + /// The smallest lengths these shapes can be broadcast to. + /// The lengths of and are not broadcast compatible. public static nint[] GetSmallestBroadcastableLengths(ReadOnlySpan shape1, ReadOnlySpan shape2) { if (!TensorHelpers.IsBroadcastableTo(shape1, shape2)) - throw new Exception("Lengths are not broadcast compatible"); + ThrowHelper.ThrowArgument_LengthsNotBroadcastCompatible(); nint[] intermediateShape = TensorHelpers.GetIntermediateShape(shape1, shape2.Length); for (int i = 1; i <= shape1.Length; i++) @@ -6607,10 +6666,9 @@ public static nint[] GetSmallestBroadcastableLengths(ReadOnlySpan shape1, return intermediateShape; } -#pragma warning restore 1591 #region TensorPrimitivesHelpers - private delegate void PerformCalculationSpanInSpanOut(ReadOnlySpan input, Span output); + private delegate void PerformCalculationSpanInSpanOut(ReadOnlySpan input, Span output); private delegate void PerformCalculationSpanInTInSpanOut(ReadOnlySpan input, T value, Span output); @@ -6618,37 +6676,36 @@ public static nint[] GetSmallestBroadcastableLengths(ReadOnlySpan shape1, private delegate void PerformCalculationTwoSpanInSpanOut(ReadOnlySpan input, ReadOnlySpan inputTwo, Span output); - private delegate void PerformCalculationTFromSpanInTToSpanOut(ReadOnlySpan input, Span output) - where TFrom : INumberBase - where TTo : INumberBase; - private delegate T PerformCalculationTwoSpanInTOut(ReadOnlySpan input, ReadOnlySpan inputTwo); - private delegate void PerformCalculationSpanInIntSpanOut(ReadOnlySpan input, Span output); - private delegate T PerformCalculationSpanInTOut(ReadOnlySpan input); private static T TensorPrimitivesHelperSpanInTOut(scoped in ReadOnlyTensorSpan input, PerformCalculationSpanInTOut performCalculation) { - ReadOnlySpan span = MemoryMarshal.CreateSpan(ref input._reference, (int)input._shape._memoryLength); - return performCalculation(span); - } - - private static ref readonly TensorSpan TensorPrimitivesHelperSpanInIntSpanOut(scoped in ReadOnlyTensorSpan input, in TensorSpan destination, PerformCalculationSpanInIntSpanOut performCalculation) - { - ReadOnlySpan span = MemoryMarshal.CreateSpan(ref input._reference, (int)input._shape._memoryLength); - Span data = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape._memoryLength); - performCalculation(span, data); - return ref destination; + if (TensorHelpers.IsContiguousAndDense(input)) + { + ReadOnlySpan span = MemoryMarshal.CreateSpan(ref input._reference, (int)input._shape.FlattenedLength); + return performCalculation(span); + } + // Flattening needs to happen + else + { + // TODO: Can optimize this to not need to realize the broadcasts + // That will need to be done on a per method basis. + nint flattenedLength = input.FlattenedLength; + T[] flattened = new T[flattenedLength]; + input.FlattenTo(flattened); + return performCalculation(flattened); + } } private static T TensorPrimitivesHelperTwoSpanInTOut(scoped in ReadOnlyTensorSpan left, scoped in ReadOnlyTensorSpan right, PerformCalculationTwoSpanInTOut performCalculation) { // If sizes are the same. - if (TensorHelpers.AreLengthsTheSame(left, right) && TensorHelpers.IsUnderlyingStorageSameSize(left, right)) + if (TensorHelpers.IsContiguousAndDense(left) && TensorHelpers.IsContiguousAndDense(right) && TensorHelpers.AreLengthsTheSame(left, right)) { - ReadOnlySpan span = MemoryMarshal.CreateSpan(ref left._reference, (int)left._shape._memoryLength); - ReadOnlySpan rspan = MemoryMarshal.CreateSpan(ref right._reference, (int)right._shape._memoryLength); + ReadOnlySpan span = MemoryMarshal.CreateSpan(ref left._reference, (int)left._shape.FlattenedLength); + ReadOnlySpan rspan = MemoryMarshal.CreateSpan(ref right._reference, (int)right._shape.FlattenedLength); return performCalculation(span, rspan); } // Broadcasting needs to happen. @@ -6659,6 +6716,8 @@ private static T TensorPrimitivesHelperTwoSpanInTOut(scoped in ReadOnlyTensor // 2 - One tensor has row contiguous memory and the right has column contiguous memory (i.e. a 1x5 and a 5x1) // Because we are returning a single T though we need to actual realize the broadcasts at this point to perform the calculations. + // TODO: Can optimize this to not need to realize the broadcasts + // That will need to be done on a per method basis. nint[] newLengths = Tensor.GetSmallestBroadcastableLengths(left.Lengths, right.Lengths); nint newLength = TensorSpanHelpers.CalculateTotalLength(newLengths); TensorSpan broadcastedLeft = new TensorSpan(new T[newLength], newLengths, ReadOnlySpan.Empty); @@ -6672,59 +6731,177 @@ private static T TensorPrimitivesHelperTwoSpanInTOut(scoped in ReadOnlyTensor } } - private static ref readonly TensorSpan TensorPrimitivesHelperSpanInSpanOut(scoped in ReadOnlyTensorSpan input, in TensorSpan destination, PerformCalculationSpanInSpanOut performCalculation) + private static ref readonly TensorSpan TensorPrimitivesHelperSpanInSpanOut(scoped in ReadOnlyTensorSpan input, in TensorSpan destination, PerformCalculationSpanInSpanOut performCalculation) { - if (destination._shape._memoryLength < input._shape._memoryLength) + // Make sure destination has enough memory + if (destination._shape._memoryLength < input._shape.FlattenedLength) ThrowHelper.ThrowArgumentException_DestinationTooShort(); - ReadOnlySpan span = MemoryMarshal.CreateSpan(ref input._reference, (int)input._shape._memoryLength); - Span ospan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape._memoryLength); - performCalculation(span, ospan); + // Make sure destination shape works with input shape + TensorSpan slicedDestination = destination.Slice(input._shape.Lengths); + + Span destinationSpan; + ReadOnlySpan inputSpan; + + // Memory is contiguous for both input and destination + if (TensorHelpers.IsContiguousAndDense(input) && TensorHelpers.IsContiguousAndDense(slicedDestination)) + { + inputSpan = MemoryMarshal.CreateSpan(ref input._reference, (int)input._shape.FlattenedLength); + destinationSpan = MemoryMarshal.CreateSpan(ref slicedDestination._reference, (int)slicedDestination._shape.FlattenedLength); + performCalculation(inputSpan, destinationSpan); + } + else + { + scoped Span curIndex; + nint[]? curIndexArray; + if (input.Lengths.Length > TensorShape.MaxInlineRank) + { + curIndexArray = ArrayPool.Shared.Rent(input.Lengths.Length); + curIndex = curIndexArray.AsSpan(0, input.Rank); + } + else + { + curIndexArray = null; + curIndex = stackalloc nint[input.Lengths.Length]; + } + curIndex.Clear(); + + int copiedValues = 0; + nint rowLength = input.Lengths[^1]; + + while (copiedValues < slicedDestination.FlattenedLength) + { + inputSpan = MemoryMarshal.CreateReadOnlySpan(in input[curIndex], (int)rowLength); + destinationSpan = MemoryMarshal.CreateSpan(ref slicedDestination[curIndex], (int)rowLength); + performCalculation(inputSpan, destinationSpan); + copiedValues += (int)rowLength; + TensorSpanHelpers.AdjustIndexes(input.Rank - 2, 1, curIndex, input.Lengths); + } + + if (curIndexArray != null) + ArrayPool.Shared.Return(curIndexArray); + } + return ref destination; } private static ref readonly TensorSpan TensorPrimitivesHelperSpanInTInSpanOut(scoped in ReadOnlyTensorSpan input, T value, in TensorSpan destination, PerformCalculationSpanInTInSpanOut performCalculation) { - if (destination._shape._memoryLength < input._shape._memoryLength) + if (destination._shape._memoryLength < input._shape.FlattenedLength) ThrowHelper.ThrowArgumentException_DestinationTooShort(); - ReadOnlySpan span = MemoryMarshal.CreateSpan(ref input._reference, (int)input._shape._memoryLength); - Span ospan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape._memoryLength); - performCalculation(span, value, ospan); + // Make sure destination shape works with input shape + TensorSpan slicedDestination = destination.Slice(input._shape.Lengths); + + ReadOnlySpan inputSpan; + Span destinationSpan; + + if (TensorHelpers.IsContiguousAndDense(input) && TensorHelpers.IsContiguousAndDense(slicedDestination)) + { + inputSpan = MemoryMarshal.CreateSpan(ref input._reference, (int)input.FlattenedLength); + destinationSpan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination.FlattenedLength); + performCalculation(inputSpan, value, destinationSpan); + } + else + { + scoped Span curIndex; + nint[]? curIndexArray; + if (input.Lengths.Length > TensorShape.MaxInlineRank) + { + curIndexArray = ArrayPool.Shared.Rent(input.Lengths.Length); + curIndex = curIndexArray.AsSpan(0, input.Rank); + } + else + { + curIndexArray = null; + curIndex = stackalloc nint[input.Lengths.Length]; + } + curIndex.Clear(); + + int copiedValues = 0; + nint rowLength = input.Lengths[^1]; + + while (copiedValues < slicedDestination.FlattenedLength) + { + inputSpan = MemoryMarshal.CreateReadOnlySpan(in input[curIndex], (int)rowLength); + destinationSpan = MemoryMarshal.CreateSpan(ref slicedDestination[curIndex], (int)rowLength); + performCalculation(inputSpan, value, destinationSpan); + copiedValues += (int)rowLength; + TensorSpanHelpers.AdjustIndexes(input.Rank - 2, 1, curIndex, input.Lengths); + } + + if (curIndexArray != null) + ArrayPool.Shared.Return(curIndexArray); + } + return ref destination; } private static ref readonly TensorSpan TensorPrimitivesHelperTInSpanInSpanOut(T value, scoped in ReadOnlyTensorSpan input, in TensorSpan destination, PerformCalculationTInSpanInSpanOut performCalculation) { - if (destination._shape._memoryLength < input._shape._memoryLength) + if (destination._shape._memoryLength < input._shape.FlattenedLength) ThrowHelper.ThrowArgumentException_DestinationTooShort(); - ReadOnlySpan span = MemoryMarshal.CreateSpan(ref input._reference, (int)input._shape._memoryLength); - Span ospan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape._memoryLength); - performCalculation(value, span, ospan); - return ref destination; - } + // Make sure destination shape works with input shape + TensorSpan slicedDestination = destination.Slice(input._shape.Lengths); + + ReadOnlySpan inputSpan; + Span destinationSpan; + + if (TensorHelpers.IsContiguousAndDense(input) && TensorHelpers.IsContiguousAndDense(slicedDestination)) + { + inputSpan = MemoryMarshal.CreateSpan(ref input._reference, (int)input._shape._memoryLength); + destinationSpan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape._memoryLength); + performCalculation(value, inputSpan, destinationSpan); + } + else + { + scoped Span curIndex; + nint[]? curIndexArray; + if (input.Lengths.Length > TensorShape.MaxInlineRank) + { + curIndexArray = ArrayPool.Shared.Rent(input.Lengths.Length); + curIndex = curIndexArray.AsSpan(0, input.Rank); + } + else + { + curIndexArray = null; + curIndex = stackalloc nint[input.Lengths.Length]; + } + curIndex.Clear(); + + int copiedValues = 0; + nint rowLength = input.Lengths[^1]; + + while (copiedValues < slicedDestination.FlattenedLength) + { + inputSpan = MemoryMarshal.CreateReadOnlySpan(in input[curIndex], (int)rowLength); + destinationSpan = MemoryMarshal.CreateSpan(ref slicedDestination[curIndex], (int)rowLength); + performCalculation(value, inputSpan, destinationSpan); + copiedValues += (int)rowLength; + TensorSpanHelpers.AdjustIndexes(input.Rank - 2, 1, curIndex, input.Lengths); + } + + if (curIndexArray != null) + ArrayPool.Shared.Return(curIndexArray); + } - private static ref readonly TensorSpan TensorPrimitivesHelperTFromSpanInTToSpanOut(scoped in ReadOnlyTensorSpan input, in TensorSpan destination, PerformCalculationTFromSpanInTToSpanOut performCalculation) - where TFrom : IEquatable, IEqualityOperators, INumberBase - where TTo : INumberBase - { - ReadOnlySpan span = MemoryMarshal.CreateSpan(ref input._reference, (int)input._shape._memoryLength); - Span ospan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape._memoryLength); - performCalculation(span, ospan); return ref destination; } private static ref readonly TensorSpan TensorPrimitivesHelperTwoSpanInSpanOut(scoped in ReadOnlyTensorSpan left, scoped in ReadOnlyTensorSpan right, in TensorSpan destination, PerformCalculationTwoSpanInSpanOut performCalculation) { - // If sizes are the same. - if (TensorHelpers.AreLengthsTheSame(left, right) && TensorHelpers.IsUnderlyingStorageSameSize(left, right)) + nint[] newSize = Tensor.GetSmallestBroadcastableLengths(left.Lengths, right.Lengths); + + TensorSpan slicedDestination = destination.Slice(newSize); + + // If sizes are the same and memory is contiguous for all tensors + if (TensorHelpers.AreLengthsTheSame(left, right) && TensorHelpers.IsUnderlyingStorageSameSize(left, right) && TensorHelpers.IsContiguousAndDense(left) + && TensorHelpers.IsContiguousAndDense(right) && TensorHelpers.IsContiguousAndDense(slicedDestination)) { - if (!TensorHelpers.IsUnderlyingStorageSameSize(left, destination)) - ThrowHelper.ThrowArgument_DestinationTooShort(); - ReadOnlySpan span = MemoryMarshal.CreateSpan(ref left._reference, (int)left._shape._memoryLength); - ReadOnlySpan rspan = MemoryMarshal.CreateSpan(ref right._reference, (int)right._shape._memoryLength); - Span ospan = MemoryMarshal.CreateSpan(ref destination._reference, (int)destination._shape._memoryLength); + ReadOnlySpan span = MemoryMarshal.CreateSpan(ref left._reference, left._shape._memoryLength <= left.FlattenedLength ? (int)left._shape._memoryLength : (int)left.FlattenedLength); + ReadOnlySpan rspan = MemoryMarshal.CreateSpan(ref right._reference, right._shape._memoryLength <= right.FlattenedLength ? (int)right._shape._memoryLength : (int)right.FlattenedLength); + Span ospan = MemoryMarshal.CreateSpan(ref slicedDestination._reference, (int)slicedDestination._shape._memoryLength); performCalculation(span, rspan, ospan); return ref destination; } @@ -6735,12 +6912,8 @@ private static ref readonly TensorSpan TensorPrimitivesHelperTwoSpanInSpanOut // 1 - Both tensors have row contiguous memory (i.e. a 1x5 being broadcast to a 5x5) // 2 - One tensor has row contiguous memory and the right has column contiguous memory (i.e. a 1x5 and a 5x1) - nint[] newSize = Tensor.GetSmallestBroadcastableLengths(left.Lengths, right.Lengths); - ReadOnlyTensorSpan broadcastedLeft = Tensor.LazyBroadcast(left, newSize); ReadOnlyTensorSpan broadcastedRight = Tensor.LazyBroadcast(right, newSize); - if (!destination.Lengths.SequenceEqual(newSize) || destination._shape._memoryLength < broadcastedLeft.FlattenedLength) - ThrowHelper.ThrowArgument_ShapesNotBroadcastCompatible(); nint rowLength = newSize[^1]; Span ospan; @@ -6749,25 +6922,40 @@ private static ref readonly TensorSpan TensorPrimitivesHelperTwoSpanInSpanOut scoped Span curIndex; nint[]? curIndexArray; - if (newSize.Length > 6) + if (newSize.Length > TensorShape.MaxInlineRank) { curIndexArray = ArrayPool.Shared.Rent(newSize.Length); - curIndex = curIndexArray; + curIndex = curIndexArray.AsSpan(0, newSize.Length); } else { curIndexArray = null; curIndex = stackalloc nint[newSize.Length]; } + curIndex.Clear(); int outputOffset = 0; - // ADD IN CASE WHERE NEITHER ARE ROW CONTIGUOUS + // neither row contiguous + if (broadcastedLeft.Strides[^1] == 0 && broadcastedRight.Strides[^1] == 0) + { + Span buffer2 = new T[rowLength]; + + while (outputOffset < slicedDestination.FlattenedLength) + { + ospan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref slicedDestination._reference, TensorSpanHelpers.ComputeLinearIndex(curIndex, slicedDestination.Strides, slicedDestination.Lengths)), (int)rowLength); + buffer.Fill(broadcastedLeft[curIndex]); + buffer2.Fill(broadcastedRight[curIndex]); + performCalculation(buffer, buffer2, ospan); + outputOffset += (int)rowLength; + TensorSpanHelpers.AdjustIndexes(broadcastedLeft.Rank - 2, 1, curIndex, broadcastedLeft.Lengths); + } + } // tensor not row contiguous - if (broadcastedLeft.Strides[^1] == 0) + else if (broadcastedLeft.Strides[^1] == 0) { - while (outputOffset < destination.FlattenedLength) + while (outputOffset < slicedDestination.FlattenedLength) { - ospan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref destination._reference, outputOffset), (int)rowLength); + ospan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref slicedDestination._reference, TensorSpanHelpers.ComputeLinearIndex(curIndex, slicedDestination.Strides, slicedDestination.Lengths)), (int)rowLength); buffer.Fill(broadcastedLeft[curIndex]); ispan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref broadcastedRight._reference, TensorSpanHelpers.ComputeLinearIndex(curIndex, broadcastedRight.Strides, broadcastedRight.Lengths)), (int)rowLength); performCalculation(buffer, ispan, ospan); @@ -6778,9 +6966,9 @@ private static ref readonly TensorSpan TensorPrimitivesHelperTwoSpanInSpanOut // right not row contiguous else if (broadcastedRight.Strides[^1] == 0) { - while (outputOffset < destination.FlattenedLength) + while (outputOffset < slicedDestination.FlattenedLength) { - ospan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref destination._reference, outputOffset), (int)rowLength); + ospan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref slicedDestination._reference, TensorSpanHelpers.ComputeLinearIndex(curIndex, slicedDestination.Strides, slicedDestination.Lengths)), (int)rowLength); buffer.Fill(broadcastedRight[curIndex]); ispan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref broadcastedLeft._reference, TensorSpanHelpers.ComputeLinearIndex(curIndex, broadcastedLeft.Strides, broadcastedLeft.Lengths)), (int)rowLength); performCalculation(ispan, buffer, ospan); @@ -6792,9 +6980,9 @@ private static ref readonly TensorSpan TensorPrimitivesHelperTwoSpanInSpanOut else { Span rspan; - while (outputOffset < destination.FlattenedLength) + while (outputOffset < slicedDestination.FlattenedLength) { - ospan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref destination._reference, outputOffset), (int)rowLength); + ospan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref slicedDestination._reference, TensorSpanHelpers.ComputeLinearIndex(curIndex, slicedDestination.Strides, slicedDestination.Lengths)), (int)rowLength); ispan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref broadcastedLeft._reference, TensorSpanHelpers.ComputeLinearIndex(curIndex, broadcastedLeft.Strides, broadcastedLeft.Lengths)), (int)rowLength); rspan = MemoryMarshal.CreateSpan(ref Unsafe.Add(ref broadcastedRight._reference, TensorSpanHelpers.ComputeLinearIndex(curIndex, broadcastedRight.Strides, broadcastedRight.Lengths)), (int)rowLength); performCalculation(ispan, rspan, ospan); diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorHelpers.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorHelpers.cs index 163075ce5c1..c169c082af4 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorHelpers.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorHelpers.cs @@ -97,6 +97,21 @@ internal static bool AreLengthsTheSame(scoped in ReadOnlyTensorSpan tensor internal static bool AreLengthsTheSame(ReadOnlySpan lengths1, ReadOnlySpan lengths2) => lengths1.SequenceEqual(lengths2); + internal static bool IsContiguousAndDense(scoped in ReadOnlyTensorSpan tensor) + { + // Right most dimension must be 1 for a dense tensor. + if (tensor._shape.Strides[^1] != 1) + return false; + + // For other dimensions, the stride must be equal to the product of the dimensions to the right. + for (int i = tensor._shape._rank - 2; i >= 0; i--) + { + if (tensor._shape.Strides[i] != TensorPrimitives.Product(tensor.Lengths.Slice(i + 1, tensor.Lengths.Length - i - 1))) + return false; + } + return true; + } + internal static void PermuteIndices(Span indices, Span permutedIndices, ReadOnlySpan permutation) { for (int i = 0; i < indices.Length; i++) diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Cos.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Cos.cs index ff706d02fd7..2f69c41da2d 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Cos.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Cos.cs @@ -18,7 +18,7 @@ public static partial class TensorPrimitives /// This method effectively computes [i] = .Cos([i]). /// /// - /// The angles in x must be in radians. Use or multiply by .Pi/180 to convert degrees to radians. + /// The angles in x must be in radians. Use or multiply by .Pi/180 to convert degrees to radians. /// /// /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.CosPi.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.CosPi.cs index 2db142d2f72..e94b35e0cd9 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.CosPi.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.CosPi.cs @@ -18,7 +18,7 @@ public static partial class TensorPrimitives /// This method effectively computes [i] = .CosPi([i]). /// /// - /// The angles in x must be in radians. Use or multiply by .Pi/180 to convert degrees to radians. + /// The angles in x must be in radians. Use or multiply by .Pi/180 to convert degrees to radians. /// /// /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Cosh.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Cosh.cs index 2047ee6a26f..b53374657c9 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Cosh.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Cosh.cs @@ -22,7 +22,7 @@ public static partial class TensorPrimitives /// If a value is equal to , the result stored into the corresponding destination location is also NaN. /// /// - /// The angles in x must be in radians. Use or multiply by .Pi/180 to convert degrees to radians. + /// The angles in x must be in radians. Use or multiply by .Pi/180 to convert degrees to radians. /// /// /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Divide.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Divide.cs index 64a238face2..3ab2b1b8923 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Divide.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Divide.cs @@ -69,7 +69,8 @@ public static void Divide(T x, ReadOnlySpan y, Span destination) /// x / y internal readonly struct DivideOperator : IBinaryOperator where T : IDivisionOperators { - public static bool Vectorizable => true; + public static bool Vectorizable => typeof(T) == typeof(float) + || typeof(T) == typeof(double); public static T Invoke(T x, T y) => x / y; public static Vector128 Invoke(Vector128 x, Vector128 y) => x / y; public static Vector256 Invoke(Vector256 x, Vector256 y) => x / y; diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Exp.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Exp.cs index 1147ec5bea5..c89ad270742 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Exp.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Exp.cs @@ -157,9 +157,6 @@ public static Vector512 Invoke(Vector512 x) private const ulong V_ARG_MAX = 0x40862000_00000000; private const ulong V_DP64_BIAS = 1023; - private const double V_EXPF_MIN = -709.782712893384; - private const double V_EXPF_MAX = +709.782712893384; - private const double V_EXPF_HUGE = 6755399441055744; private const double V_TBL_LN2 = 1.4426950408889634; @@ -183,155 +180,145 @@ public static Vector512 Invoke(Vector512 x) public static Vector128 Invoke(Vector128 x) { - // x * (64.0 / ln(2)) - Vector128 z = x * Vector128.Create(V_TBL_LN2); - - Vector128 dn = z + Vector128.Create(V_EXPF_HUGE); + // Check if -709 < vx < 709 + if (Vector128.LessThanOrEqualAll(Vector128.Abs(x).AsUInt64(), Vector128.Create(V_ARG_MAX))) + { + // x * (64.0 / ln(2)) + Vector128 z = x * Vector128.Create(V_TBL_LN2); - // n = (int)z - Vector128 n = dn.AsUInt64(); + Vector128 dn = z + Vector128.Create(V_EXPF_HUGE); - // dn = (double)n - dn -= Vector128.Create(V_EXPF_HUGE); + // n = (int)z + Vector128 n = dn.AsUInt64(); - // r = x - (dn * (ln(2) / 64)) - // where ln(2) / 64 is split into Head and Tail values - Vector128 r = x - (dn * Vector128.Create(V_LN2_HEAD)) - (dn * Vector128.Create(V_LN2_TAIL)); + // dn = (double)n + dn -= Vector128.Create(V_EXPF_HUGE); - Vector128 r2 = r * r; - Vector128 r4 = r2 * r2; - Vector128 r8 = r4 * r4; + // r = x - (dn * (ln(2) / 64)) + // where ln(2) / 64 is split into Head and Tail values + Vector128 r = x - (dn * Vector128.Create(V_LN2_HEAD)) - (dn * Vector128.Create(V_LN2_TAIL)); - // Compute polynomial - Vector128 poly = ((Vector128.Create(C12) * r + Vector128.Create(C11)) * r2 + - Vector128.Create(C10) * r + Vector128.Create(C9)) * r8 + - ((Vector128.Create(C8) * r + Vector128.Create(C7)) * r2 + - (Vector128.Create(C6) * r + Vector128.Create(C5))) * r4 + - ((Vector128.Create(C4) * r + Vector128.Create(C3)) * r2 + (r + Vector128.One)); + Vector128 r2 = r * r; + Vector128 r4 = r2 * r2; + Vector128 r8 = r4 * r4; - // m = (n - j) / 64 - // result = polynomial * 2^m - Vector128 ret = poly * ((n + Vector128.Create(V_DP64_BIAS)) << 52).AsDouble(); + // Compute polynomial + Vector128 poly = ((Vector128.Create(C12) * r + Vector128.Create(C11)) * r2 + + Vector128.Create(C10) * r + Vector128.Create(C9)) * r8 + + ((Vector128.Create(C8) * r + Vector128.Create(C7)) * r2 + + (Vector128.Create(C6) * r + Vector128.Create(C5))) * r4 + + ((Vector128.Create(C4) * r + Vector128.Create(C3)) * r2 + (r + Vector128.One)); - // Check if -709 < vx < 709 - if (Vector128.GreaterThanAny(Vector128.Abs(x).AsUInt64(), Vector128.Create(V_ARG_MAX))) + // m = (n - j) / 64 + // result = polynomial * 2^m + return poly * ((n + Vector128.Create(V_DP64_BIAS)) << 52).AsDouble(); + } + else { - // (x > V_EXPF_MAX) ? double.PositiveInfinity : x - Vector128 infinityMask = Vector128.GreaterThan(x, Vector128.Create(V_EXPF_MAX)); - - ret = Vector128.ConditionalSelect( - infinityMask, - Vector128.Create(double.PositiveInfinity), - ret - ); + return ScalarFallback(x); - // (x < V_EXPF_MIN) ? 0 : x - ret = Vector128.AndNot(ret, Vector128.LessThan(x, Vector128.Create(V_EXPF_MIN))); + static Vector128 ScalarFallback(Vector128 x) => + Vector128.Create(Math.Exp(x.GetElement(0)), + Math.Exp(x.GetElement(1))); } - - return ret; } public static Vector256 Invoke(Vector256 x) { - // x * (64.0 / ln(2)) - Vector256 z = x * Vector256.Create(V_TBL_LN2); - - Vector256 dn = z + Vector256.Create(V_EXPF_HUGE); + // Check if -709 < vx < 709 + if (Vector256.LessThanOrEqualAll(Vector256.Abs(x).AsUInt64(), Vector256.Create(V_ARG_MAX))) + { + // x * (64.0 / ln(2)) + Vector256 z = x * Vector256.Create(V_TBL_LN2); - // n = (int)z - Vector256 n = dn.AsUInt64(); + Vector256 dn = z + Vector256.Create(V_EXPF_HUGE); - // dn = (double)n - dn -= Vector256.Create(V_EXPF_HUGE); + // n = (int)z + Vector256 n = dn.AsUInt64(); - // r = x - (dn * (ln(2) / 64)) - // where ln(2) / 64 is split into Head and Tail values - Vector256 r = x - (dn * Vector256.Create(V_LN2_HEAD)) - (dn * Vector256.Create(V_LN2_TAIL)); + // dn = (double)n + dn -= Vector256.Create(V_EXPF_HUGE); - Vector256 r2 = r * r; - Vector256 r4 = r2 * r2; - Vector256 r8 = r4 * r4; + // r = x - (dn * (ln(2) / 64)) + // where ln(2) / 64 is split into Head and Tail values + Vector256 r = x - (dn * Vector256.Create(V_LN2_HEAD)) - (dn * Vector256.Create(V_LN2_TAIL)); - // Compute polynomial - Vector256 poly = ((Vector256.Create(C12) * r + Vector256.Create(C11)) * r2 + - Vector256.Create(C10) * r + Vector256.Create(C9)) * r8 + - ((Vector256.Create(C8) * r + Vector256.Create(C7)) * r2 + - (Vector256.Create(C6) * r + Vector256.Create(C5))) * r4 + - ((Vector256.Create(C4) * r + Vector256.Create(C3)) * r2 + (r + Vector256.One)); + Vector256 r2 = r * r; + Vector256 r4 = r2 * r2; + Vector256 r8 = r4 * r4; - // m = (n - j) / 64 - // result = polynomial * 2^m - Vector256 ret = poly * ((n + Vector256.Create(V_DP64_BIAS)) << 52).AsDouble(); + // Compute polynomial + Vector256 poly = ((Vector256.Create(C12) * r + Vector256.Create(C11)) * r2 + + Vector256.Create(C10) * r + Vector256.Create(C9)) * r8 + + ((Vector256.Create(C8) * r + Vector256.Create(C7)) * r2 + + (Vector256.Create(C6) * r + Vector256.Create(C5))) * r4 + + ((Vector256.Create(C4) * r + Vector256.Create(C3)) * r2 + (r + Vector256.One)); - // Check if -709 < vx < 709 - if (Vector256.GreaterThanAny(Vector256.Abs(x).AsUInt64(), Vector256.Create(V_ARG_MAX))) + // m = (n - j) / 64 + // result = polynomial * 2^m + return poly * ((n + Vector256.Create(V_DP64_BIAS)) << 52).AsDouble(); + } + else { - // (x > V_EXPF_MAX) ? double.PositiveInfinity : x - Vector256 infinityMask = Vector256.GreaterThan(x, Vector256.Create(V_EXPF_MAX)); + return ScalarFallback(x); - ret = Vector256.ConditionalSelect( - infinityMask, - Vector256.Create(double.PositiveInfinity), - ret - ); - - // (x < V_EXPF_MIN) ? 0 : x - ret = Vector256.AndNot(ret, Vector256.LessThan(x, Vector256.Create(V_EXPF_MIN))); + static Vector256 ScalarFallback(Vector256 x) => + Vector256.Create(Math.Exp(x.GetElement(0)), + Math.Exp(x.GetElement(1)), + Math.Exp(x.GetElement(2)), + Math.Exp(x.GetElement(3))); } - - return ret; } public static Vector512 Invoke(Vector512 x) { - // x * (64.0 / ln(2)) - Vector512 z = x * Vector512.Create(V_TBL_LN2); - - Vector512 dn = z + Vector512.Create(V_EXPF_HUGE); + // Check if -709 < vx < 709 + if (Vector512.LessThanOrEqualAll(Vector512.Abs(x).AsUInt64(), Vector512.Create(V_ARG_MAX))) + { + // x * (64.0 / ln(2)) + Vector512 z = x * Vector512.Create(V_TBL_LN2); - // n = (int)z - Vector512 n = dn.AsUInt64(); + Vector512 dn = z + Vector512.Create(V_EXPF_HUGE); - // dn = (double)n - dn -= Vector512.Create(V_EXPF_HUGE); + // n = (int)z + Vector512 n = dn.AsUInt64(); - // r = x - (dn * (ln(2) / 64)) - // where ln(2) / 64 is split into Head and Tail values - Vector512 r = x - (dn * Vector512.Create(V_LN2_HEAD)) - (dn * Vector512.Create(V_LN2_TAIL)); + // dn = (double)n + dn -= Vector512.Create(V_EXPF_HUGE); - Vector512 r2 = r * r; - Vector512 r4 = r2 * r2; - Vector512 r8 = r4 * r4; + // r = x - (dn * (ln(2) / 64)) + // where ln(2) / 64 is split into Head and Tail values + Vector512 r = x - (dn * Vector512.Create(V_LN2_HEAD)) - (dn * Vector512.Create(V_LN2_TAIL)); - // Compute polynomial - Vector512 poly = ((Vector512.Create(C12) * r + Vector512.Create(C11)) * r2 + - Vector512.Create(C10) * r + Vector512.Create(C9)) * r8 + - ((Vector512.Create(C8) * r + Vector512.Create(C7)) * r2 + - (Vector512.Create(C6) * r + Vector512.Create(C5))) * r4 + - ((Vector512.Create(C4) * r + Vector512.Create(C3)) * r2 + (r + Vector512.One)); + Vector512 r2 = r * r; + Vector512 r4 = r2 * r2; + Vector512 r8 = r4 * r4; - // m = (n - j) / 64 - // result = polynomial * 2^m - Vector512 ret = poly * ((n + Vector512.Create(V_DP64_BIAS)) << 52).AsDouble(); + // Compute polynomial + Vector512 poly = ((Vector512.Create(C12) * r + Vector512.Create(C11)) * r2 + + Vector512.Create(C10) * r + Vector512.Create(C9)) * r8 + + ((Vector512.Create(C8) * r + Vector512.Create(C7)) * r2 + + (Vector512.Create(C6) * r + Vector512.Create(C5))) * r4 + + ((Vector512.Create(C4) * r + Vector512.Create(C3)) * r2 + (r + Vector512.One)); - // Check if -709 < vx < 709 - if (Vector512.GreaterThanAny(Vector512.Abs(x).AsUInt64(), Vector512.Create(V_ARG_MAX))) + // m = (n - j) / 64 + // result = polynomial * 2^m + return poly * ((n + Vector512.Create(V_DP64_BIAS)) << 52).AsDouble(); + } + else { - // (x > V_EXPF_MAX) ? double.PositiveInfinity : x - Vector512 infinityMask = Vector512.GreaterThan(x, Vector512.Create(V_EXPF_MAX)); - - ret = Vector512.ConditionalSelect( - infinityMask, - Vector512.Create(double.PositiveInfinity), - ret - ); - - // (x < V_EXPF_MIN) ? 0 : x - ret = Vector512.AndNot(ret, Vector512.LessThan(x, Vector512.Create(V_EXPF_MIN))); + return ScalarFallback(x); + + static Vector512 ScalarFallback(Vector512 x) => + Vector512.Create(Math.Exp(x.GetElement(0)), + Math.Exp(x.GetElement(1)), + Math.Exp(x.GetElement(2)), + Math.Exp(x.GetElement(3)), + Math.Exp(x.GetElement(4)), + Math.Exp(x.GetElement(5)), + Math.Exp(x.GetElement(6)), + Math.Exp(x.GetElement(7))); } - - return ret; } } diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Sin.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Sin.cs index 02c249f9437..335ef083363 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Sin.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Sin.cs @@ -18,7 +18,7 @@ public static partial class TensorPrimitives /// This method effectively computes [i] = .Sin([i]). /// /// - /// The angles in x must be in radians. Use or multiply by .Pi/180 to convert degrees to radians. + /// The angles in x must be in radians. Use or multiply by .Pi/180 to convert degrees to radians. /// /// /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.SinPi.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.SinPi.cs index 2b6d86fa8ca..13ce30c2c15 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.SinPi.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.SinPi.cs @@ -18,7 +18,7 @@ public static partial class TensorPrimitives /// This method effectively computes [i] = .SinPi([i]). /// /// - /// The angles in x must be in radians. Use or multiply by .Pi/180 to convert degrees to radians. + /// The angles in x must be in radians. Use or multiply by .Pi/180 to convert degrees to radians. /// /// /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Sinh.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Sinh.cs index a154e3d9edc..076fd6842be 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Sinh.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Sinh.cs @@ -22,7 +22,7 @@ public static partial class TensorPrimitives /// the corresponding destination location is set to that value. /// /// - /// The angles in x must be in radians. Use or multiply by .Pi / 180 to convert degrees to radians. + /// The angles in x must be in radians. Use or multiply by .Pi / 180 to convert degrees to radians. /// /// /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Tan.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Tan.cs index 926bca5221a..9df5742e2b0 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Tan.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Tan.cs @@ -18,7 +18,7 @@ public static partial class TensorPrimitives /// This method effectively computes [i] = .Tan([i]). /// /// - /// The angles in x must be in radians. Use or multiply by .Pi/180 to convert degrees to radians. + /// The angles in x must be in radians. Use or multiply by .Pi/180 to convert degrees to radians. /// /// /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.TanPi.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.TanPi.cs index 962dba7c185..067f0075a39 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.TanPi.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.TanPi.cs @@ -17,7 +17,7 @@ public static partial class TensorPrimitives /// This method effectively computes [i] = .TanPi([i]). /// /// - /// The angles in x must be in radians. Use or multiply by .Pi/180 to convert degrees to radians. + /// The angles in x must be in radians. Use or multiply by .Pi/180 to convert degrees to radians. /// /// /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Tanh.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Tanh.cs index 7ac7d9b3761..5bee3f47eb5 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Tanh.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorPrimitives.Tanh.cs @@ -22,7 +22,7 @@ public static partial class TensorPrimitives /// If a value is equal to , the corresponding destination location is set to NaN. /// /// - /// The angles in x must be in radians. Use or multiply by .Pi / 180 to convert degrees to radians. + /// The angles in x must be in radians. Use or multiply by .Pi / 180 to convert degrees to radians. /// /// /// This method may call into the underlying C runtime or employ instructions specific to the current architecture. Exact results may differ between different diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpan.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpan.cs index 5c52cc68dc2..f951c842986 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpan.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpan.cs @@ -7,7 +7,6 @@ using System.Linq; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; -using static System.Runtime.InteropServices.JavaScript.JSType; using EditorBrowsableAttribute = System.ComponentModel.EditorBrowsableAttribute; using EditorBrowsableState = System.ComponentModel.EditorBrowsableState; @@ -16,7 +15,7 @@ namespace System.Numerics.Tensors { /// - /// TensorSpan represents a contiguous region of arbitrary memory. Unlike arrays, it can point to either managed + /// Represents a contiguous region of arbitrary memory. Unlike arrays, it can point to either managed /// or native memory, or to memory allocated on the stack. It is type-safe and memory-safe. /// [DebuggerTypeProxy(typeof(TensorSpanDebugView<>))] @@ -34,7 +33,7 @@ public readonly ref struct TensorSpan /// /// The target array. /// Returns default when is null. - /// Thrown when is covariant and array's type is not exactly T[]. + /// is covariant and its type is not exactly T[]. [MethodImpl(MethodImplOptions.AggressiveInlining)] public TensorSpan(T[]? array) : this(array, 0, [array?.Length ?? 0], []) { @@ -46,12 +45,12 @@ public TensorSpan(T[]? array) : this(array, 0, [array?.Length ?? 0], []) /// /// The target array. /// The index at which to begin the span. - /// The lengths of the dimensions. If default is provided its assumed to have 1 dimension with a length equal to the length of the data. - /// The strides of each dimension. If default or span of length 0 is provided then strides will be automatically calculated. + /// The lengths of the dimensions. If default is provided, it's assumed to have one dimension with a length equal to the length of the data. + /// The strides of each dimension. If default or span of length 0 is provided, then strides will be automatically calculated. /// Returns default when is null. - /// Thrown when is covariant and array's type is not exactly T[]. + /// is covariant and its type is not exactly T[]. /// - /// Thrown when the specified or end index is not in the range (<0 or >FlattenedLength). + /// The specified or end index is not in the range (<0 or >FlattenedLength). /// public TensorSpan(T[]? array, Index startIndex, scoped ReadOnlySpan lengths, scoped ReadOnlySpan strides) : this(array, startIndex.GetOffset(array?.Length ?? 0), lengths, strides) @@ -64,12 +63,12 @@ public TensorSpan(T[]? array, Index startIndex, scoped ReadOnlySpan length /// /// The target array. /// The index at which to begin the span. - /// The lengths of the dimensions. If default is provided its assumed to have 1 dimension with a length equal to the length of the data. - /// The strides of each dimension. If default or span of length 0 is provided then strides will be automatically calculated. + /// The lengths of the dimensions. If default is provided, it's assumed to have one dimension with a length equal to the length of the data. + /// The strides of each dimension. If default or span of length 0 is provided, then strides will be automatically calculated. /// Returns default when is null. - /// Thrown when is covariant and array's type is not exactly T[]. + /// is covariant and its type is not exactly T[]. /// - /// Thrown when the specified or end index is not in the range (<0 or >FlattenedLength). + /// The specified or end index is not in the range (<0 or >FlattenedLength). /// [MethodImpl(MethodImplOptions.AggressiveInlining)] public TensorSpan(T[]? array, int start, scoped ReadOnlySpan lengths, scoped ReadOnlySpan strides) @@ -85,6 +84,7 @@ public TensorSpan(T[]? array, int start, scoped ReadOnlySpan lengths, scop this = default; return; // returns default } + if (!typeof(T).IsValueType && array.GetType() != typeof(T[])) ThrowHelper.ThrowArrayTypeMismatchException(); @@ -117,11 +117,10 @@ public TensorSpan(Span span) : this(span, [span.Length], []) { } /// /// Creates a new over the provided using the specified lengths and strides. - /// If the strides are not provided, they will be automatically calculated. /// /// The target span. /// The lengths of each dimension. - /// The strides for each dimension. Will be automatically calculated if not provided. + /// The strides for each dimension. The strides will be automatically calculated if not provided. public TensorSpan(Span span, scoped ReadOnlySpan lengths, scoped ReadOnlySpan strides) { if (lengths.IsEmpty) @@ -133,7 +132,7 @@ public TensorSpan(Span span, scoped ReadOnlySpan lengths, scoped ReadOn TensorSpanHelpers.ValidateStrides(strides, lengths); nint maxElements = TensorSpanHelpers.ComputeMaxLinearIndex(strides, lengths); - if (maxElements >= span.Length && span.Length != 0) + if (span.IsEmpty ? maxElements != 0 : maxElements >= span.Length) ThrowHelper.ThrowArgument_InvalidStridesAndLengths(); _shape = new TensorShape(span.Length, lengths, strides); @@ -149,12 +148,11 @@ public TensorSpan(Array? array) : this(array, ReadOnlySpan.Empty, array == /// /// Creates a new over the provided using the specified start offsets, lengths, and strides. - /// If the strides are not provided, they will be automatically calculated. /// /// The target array. /// The starting offset for each dimension. /// The lengths of each dimension. - /// The strides for each dimension. Will be automatically calculated if not provided. + /// The strides for each dimension. The strides will be automatically calculated if not provided. public TensorSpan(Array? array, scoped ReadOnlySpan start, scoped ReadOnlySpan lengths, scoped ReadOnlySpan strides) { if (lengths.IsEmpty && array != null) @@ -169,7 +167,7 @@ public TensorSpan(Array? array, scoped ReadOnlySpan start, scoped ReadOnlyS this = default; return; // returns default } - if (!typeof(T).IsValueType && array.GetType() != typeof(T[])) + if (array.GetType().GetElementType() != typeof(T)) ThrowHelper.ThrowArrayTypeMismatchException(); strides = strides.IsEmpty ? (ReadOnlySpan)TensorSpanHelpers.CalculateStrides(lengths, linearLength) : strides; @@ -195,12 +193,11 @@ public TensorSpan(Array? array, scoped ReadOnlySpan start, scoped ReadOnlyS /// /// Creates a new over the provided using the specified start offsets, lengths, and strides. - /// If the strides are not provided, they will be automatically calculated. /// /// The target array. /// The starting offset for each dimension. /// The lengths of each dimension. - /// The strides for each dimension. Will be automatically calculated if not provided. + /// The strides for each dimension. The strides will be automatically calculated if not provided. public TensorSpan(Array? array, scoped ReadOnlySpan startIndex, scoped ReadOnlySpan lengths, scoped ReadOnlySpan strides) { if (lengths.IsEmpty && array != null) @@ -216,7 +213,7 @@ public TensorSpan(Array? array, scoped ReadOnlySpan startIndex, scoped R this = default; return; // returns default } - if (!typeof(T).IsValueType && array.GetType() != typeof(T[])) + if (array.GetType().GetElementType() != typeof(T)) ThrowHelper.ThrowArrayTypeMismatchException(); nint startOffset = TensorSpanHelpers.ComputeStartOffsetSystemArray(array, startIndex); @@ -238,30 +235,34 @@ public TensorSpan(Array? array, scoped ReadOnlySpan startIndex, scoped R } /// - /// Creates a new span over the target unmanaged buffer. Clearly this - /// is quite dangerous the length is not checked. - /// But if this creation is correct, then all subsequent uses are correct. + /// Creates a new span over the target unmanaged buffer. /// - /// An unmanaged data to memory. + /// An unmanaged data that points to memory. /// The number of elements the unmanaged memory can hold. + /// + /// This constructor is quite dangerous, because the length is not checked. + /// But if this creation is correct, then all subsequent uses are correct. + /// [CLSCompliant(false)] public unsafe TensorSpan(T* data, nint dataLength) : this(data, dataLength, [dataLength], []) { } /// - /// Creates a new span over the target unmanaged buffer. Clearly this - /// is quite dangerous, because the length is not checked. - /// But if this creation is correct, then all subsequent uses are correct. + /// Creates a new span over the target unmanaged buffer. /// - /// An unmanaged data to memory. + /// An unmanaged data that points to memory. /// The number of elements the unmanaged memory can hold. - /// The lengths of the dimensions. If default is provided its assumed to have 1 dimension with a length equal to the length of the data. - /// The lengths of the strides. If nothing is provided it figures out the default stride configuration. + /// The lengths of the dimensions. If default is provided, it's assumed to have one dimension with a length equal to the length of the data. + /// The lengths of the strides. If nothing is provided, it figures out the default stride configuration. /// - /// Thrown when is reference type or contains pointers and hence cannot be stored in unmanaged memory. + /// is a reference type or contains pointers and hence cannot be stored in unmanaged memory. /// /// - /// Thrown when the specified length is negative. + /// The specified length is negative. /// + /// + /// This constructor is quite dangerous, because the length is not checked. + /// But if this creation is correct, then all subsequent uses are correct. + /// [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] public unsafe TensorSpan(T* data, nint dataLength, scoped ReadOnlySpan lengths, scoped ReadOnlySpan strides) @@ -304,7 +305,7 @@ internal TensorSpan(ref T reference, scoped ReadOnlySpan lengths, scoped R /// /// /// - /// Thrown when any index is less than 0 or any index is greater than or equal to FlattenedLength + /// Any index is less than 0 or greater than or equal to FlattenedLength. /// public ref T this[params scoped ReadOnlySpan indexes] { @@ -328,7 +329,7 @@ public ref T this[params scoped ReadOnlySpan indexes] /// /// /// - /// Thrown when any index is less than 0 or any index is greater than or equal to FlattenedLength + /// Any index is less than 0 or greater than or equal to FlattenedLength. /// public ref T this[params scoped ReadOnlySpan indexes] { @@ -353,7 +354,7 @@ public ref T this[params scoped ReadOnlySpan indexes] /// /// /// - /// Thrown when any index is less than 0 or any index is greater than or equal to FlattenedLength + /// Any index is less than 0 or greater than or equal to FlattenedLength. /// public TensorSpan this[params scoped ReadOnlySpan ranges] { @@ -397,14 +398,14 @@ public TensorSpan this[params scoped ReadOnlySpan ranges] public ReadOnlySpan Strides => _shape.Strides; /// - /// Returns false if left and right point at the same memory and have the same length. Note that - /// this does *not* check to see if the *contents* are equal. + /// Compares two spans and returns false if left and right point at the same memory and have the same length. + /// This operator does *not* check to see if the *contents* are equal. /// public static bool operator !=(TensorSpan left, TensorSpan right) => !(left == right); /// - /// Returns true if left and right point at the same memory and have the same length. Note that - /// this does *not* check to see if the *contents* are equal. + /// Compares two spans and returns true if left and right point at the same memory and have the same length. + /// This operator does *not* check to see if the *contents* are equal. /// public static bool operator ==(TensorSpan left, TensorSpan right) => left._shape.FlattenedLength == right._shape.FlattenedLength && @@ -414,10 +415,10 @@ public TensorSpan this[params scoped ReadOnlySpan ranges] Unsafe.AreSame(ref left._reference, ref right._reference); /// - /// This method is not supported as spans cannot be boxed. To compare two spans, use operator==. + /// This method is not supported as spans cannot be boxed. To compare two spans, use operator ==. /// /// - /// Always thrown by this method. + /// In all cases. /// [Obsolete("Equals() on TensorSpan will always throw an exception. Use the equality operator instead.")] [EditorBrowsable(EditorBrowsableState.Never)] @@ -428,7 +429,7 @@ public override bool Equals(object? obj) => /// This method is not supported as spans cannot be boxed. /// /// - /// Always thrown by this method. + /// In all cases. /// [Obsolete("GetHashCode() on TensorSpan will always throw an exception.")] [EditorBrowsable(EditorBrowsableState.Never)] @@ -509,14 +510,14 @@ public void Clear() if (Rank > TensorShape.MaxInlineRank) { curIndexesArray = ArrayPool.Shared.Rent(Rank); - curIndexes = curIndexesArray; - curIndexes = curIndexes.Slice(0, Rank); + curIndexes = curIndexesArray.AsSpan(0, Rank); } else { curIndexesArray = null; curIndexes = stackalloc nint[Rank]; } + curIndexes.Clear(); nint clearedValues = 0; while (clearedValues < _shape.FlattenedLength) @@ -538,12 +539,12 @@ public void Fill(T value) /// /// Copies the contents of this span into destination span. If the source - /// and destinations overlap, this method behaves as if the original values in + /// and destinations overlap, this method behaves as if the original values are in /// a temporary location before the destination is overwritten. /// /// The span to copy items into. /// - /// Thrown when the destination TensorSpan is shorter than the source Span. + /// The destination TensorSpan is shorter than the source Span. /// [MethodImpl(MethodImplOptions.AggressiveInlining)] public void CopyTo(scoped TensorSpan destination) @@ -559,14 +560,14 @@ public void CopyTo(scoped TensorSpan destination) if (Rank > TensorShape.MaxInlineRank) { curIndexesArray = ArrayPool.Shared.Rent(Rank); - curIndexes = curIndexesArray; - curIndexes = curIndexes.Slice(0, Rank); + curIndexes = curIndexesArray.AsSpan(0, Rank); } else { curIndexesArray = null; curIndexes = stackalloc nint[Rank]; } + curIndexes.Clear(); nint copiedValues = 0; TensorSpan slice = destination.Slice(_shape.Lengths); @@ -585,7 +586,7 @@ public void CopyTo(scoped TensorSpan destination) /// /// Copies the contents of this span into destination span. If the source - /// and destinations overlap, this method behaves as if the original values in + /// and destinations overlap, this method behaves as if the original values are in /// a temporary location before the destination is overwritten. /// /// The span to copy items into. @@ -602,14 +603,14 @@ public bool TryCopyTo(scoped TensorSpan destination) if (Rank > TensorShape.MaxInlineRank) { curIndexesArray = ArrayPool.Shared.Rent(Rank); - curIndexes = curIndexesArray; - curIndexes = curIndexes.Slice(0, Rank); + curIndexes = curIndexesArray.AsSpan(0, Rank); } else { curIndexesArray = null; curIndexes = stackalloc nint[Rank]; } + curIndexes.Clear(); nint copiedValues = 0; TensorSpan slice = destination.Slice(_shape.Lengths); @@ -628,13 +629,13 @@ public bool TryCopyTo(scoped TensorSpan destination) return retVal; } - //public static explicit operator TensorSpan(Array? array); -#pragma warning disable 1591 // TODO: Document this API. https://github.com/dotnet/runtime/issues/105981 + /// + /// Implicitly converts an array to a . + /// public static implicit operator TensorSpan(T[]? array) => new TensorSpan(array); -#pragma warning restore 1591 /// - /// Defines an implicit conversion of a to a + /// Implicitly converts a to a /// public static implicit operator ReadOnlyTensorSpan(TensorSpan span) => new ReadOnlyTensorSpan(ref span._reference, span._shape.Lengths, span._shape.Strides, span._shape._memoryLength); @@ -651,7 +652,7 @@ public static implicit operator ReadOnlyTensorSpan(TensorSpan span) => /// The indexes for the slice. /// /// - /// Thrown when any index is less than 0 or any index is greater than or equal to FlattenedLength + /// Any index is less than 0 or greater than or equal to FlattenedLength. /// public TensorSpan Slice(params scoped ReadOnlySpan indexes) { @@ -664,10 +665,10 @@ public TensorSpan Slice(params scoped ReadOnlySpan indexes) } /// - /// Takes in the lengths of the dimensions and slices according to them. + /// Slices a span according to the provided lengths of the dimensions. /// - /// The dimension lengths - /// A based on the provided + /// The dimension lengths. + /// A based on the provided . internal TensorSpan Slice(params scoped ReadOnlySpan lengths) { NRange[] ranges = new NRange[lengths.Length]; @@ -679,47 +680,69 @@ internal TensorSpan Slice(params scoped ReadOnlySpan lengths) } /// - /// Forms a slice out of the given span + /// Forms a slice out of the given span. /// - /// The ranges for the slice - /// A based on the provided + /// The ranges for the slice. + /// A based on the provided . [MethodImpl(MethodImplOptions.AggressiveInlining)] public TensorSpan Slice(params scoped ReadOnlySpan ranges) { if (ranges.Length != Lengths.Length) ThrowHelper.ThrowIndexOutOfRangeException(); + TensorSpan toReturn; scoped Span lengths; scoped Span offsets; + nint[]? lengthsArray; + nint[]? offsetsArray; if (Rank > TensorShape.MaxInlineRank) { - lengths = stackalloc nint[Rank]; - offsets = stackalloc nint[Rank]; + lengthsArray = ArrayPool.Shared.Rent(Rank); + lengths = lengthsArray.AsSpan(0, Rank); + + offsetsArray = ArrayPool.Shared.Rent(Rank); + offsets = offsetsArray.AsSpan(0, Rank); } else { - lengths = new nint[Rank]; - offsets = new nint[Rank]; + lengths = stackalloc nint[Rank]; + offsets = stackalloc nint[Rank]; + + lengthsArray = null; + offsetsArray = null; } + lengths.Clear(); + offsets.Clear(); for (int i = 0; i < ranges.Length; i++) { (offsets[i], lengths[i]) = ranges[i].GetOffsetAndLength(Lengths[i]); } + // When we have an empty Tensor and someone wants to slice all of it, we should return an empty Tensor. + // FlattenedLength is computed everytime so using a local to cache the value. + nint flattenedLength = FlattenedLength; nint index = 0; - for (int i = 0; i < offsets.Length; i++) - { - if (offsets[i] < 0 || offsets[i] >= Lengths[i]) - ThrowHelper.ThrowIndexOutOfRangeException(); - index += Strides[i] * (offsets[i]); + if (flattenedLength != 0) + { + for (int i = 0; i < offsets.Length; i++) + { + index += Strides[i] * (offsets[i]); + } } - if (index >= _shape._memoryLength || index < 0) + if ((index >= _shape._memoryLength || index < 0) && flattenedLength != 0) ThrowHelper.ThrowIndexOutOfRangeException(); - return new TensorSpan(ref Unsafe.Add(ref _reference, index), lengths, _shape.Strides, _shape._memoryLength - index); + toReturn = new TensorSpan(ref Unsafe.Add(ref _reference, index), lengths, _shape.Strides, _shape._memoryLength - index); + + if (offsetsArray != null) + ArrayPool.Shared.Return(offsetsArray); + if (lengthsArray != null) + ArrayPool.Shared.Return(lengthsArray); + + return toReturn; } /// @@ -754,14 +777,14 @@ public void FlattenTo(scoped Span destination) if (Rank > TensorShape.MaxInlineRank) { curIndexesArray = ArrayPool.Shared.Rent(Rank); - curIndexes = curIndexesArray; - curIndexes = curIndexes.Slice(0, Rank); + curIndexes = curIndexesArray.AsSpan(0, Rank); } else { curIndexesArray = null; curIndexes = stackalloc nint[Rank]; } + curIndexes.Clear(); nint copiedValues = 0; while (copiedValues < _shape.FlattenedLength) diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpanHelpers.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpanHelpers.cs index d84b1130c96..b16d4172f8b 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpanHelpers.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netcore/TensorSpanHelpers.cs @@ -2,11 +2,8 @@ // The .NET Foundation licenses this file to you under the MIT license. using System.Buffers; -using System.Collections.Specialized; using System.Diagnostics; using System.Diagnostics.CodeAnalysis; -using System.Linq; -using System.Reflection; using System.Runtime.CompilerServices; namespace System.Numerics.Tensors @@ -193,7 +190,8 @@ public static nint ComputeLinearIndex(ReadOnlySpan indexes, ReadOnlySpan public static void ValidateStrides(ReadOnlySpan strides, ReadOnlySpan lengths) { - Debug.Assert(strides.Length == lengths.Length); + if (strides.Length != lengths.Length) + ThrowHelper.ThrowArgument_InvalidStridesAndLengths(); if (strides.Length == 0) return; diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netstandard/TensorPrimitives.Single.netstandard.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netstandard/TensorPrimitives.Single.netstandard.cs index c9474cb470f..563080bf742 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netstandard/TensorPrimitives.Single.netstandard.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/netstandard/TensorPrimitives.Single.netstandard.cs @@ -175,28 +175,15 @@ static float Vectorized(ref float xRef, nuint remainder, TTransformOperator tran { float* xPtr = px; - // We need to the ensure the underlying data can be aligned and only align - // it if it can. It is possible we have an unaligned ref, in which case we - // can never achieve the required SIMD alignment. + // Unlike many other vectorization algorithms, we cannot align for aggregation + // because that changes how results compound together and can cause a significant + // difference in the output. This also means we're processing the full data from beg + // so account for that to ensure we don't double process and include them in the + // aggregate twice. - bool canAlign = ((nuint)(xPtr) % sizeof(float)) == 0; - - if (canAlign) - { - // Compute by how many elements we're misaligned and adjust the pointers accordingly - // - // Noting that we are only actually aligning dPtr. This is because unaligned stores - // are more expensive than unaligned loads and aligning both is significantly more - // complex. - - misalignment = ((uint)(sizeof(Vector)) - ((nuint)(xPtr) % (uint)(sizeof(Vector)))) / sizeof(float); - - xPtr += misalignment; - - Debug.Assert(((nuint)(xPtr) % (uint)(sizeof(Vector))) == 0); - - remainder -= misalignment; - } + misalignment = (uint)Vector.Count; + xPtr += misalignment; + remainder -= misalignment; Vector vector1; Vector vector2; @@ -480,29 +467,18 @@ static float Vectorized(ref float xRef, ref float yRef, nuint remainder, TBinary float* xPtr = px; float* yPtr = py; - // We need to the ensure the underlying data can be aligned and only align - // it if it can. It is possible we have an unaligned ref, in which case we - // can never achieve the required SIMD alignment. - - bool canAlign = ((nuint)(xPtr) % sizeof(float)) == 0; - - if (canAlign) - { - // Compute by how many elements we're misaligned and adjust the pointers accordingly - // - // Noting that we are only actually aligning dPtr. This is because unaligned stores - // are more expensive than unaligned loads and aligning both is significantly more - // complex. - - misalignment = ((uint)(sizeof(Vector)) - ((nuint)(xPtr) % (uint)(sizeof(Vector)))) / sizeof(float); + // Unlike many other vectorization algorithms, we cannot align for aggregation + // because that changes how results compound together and can cause a significant + // difference in the output. This also means we're processing the full data from beg + // so account for that to ensure we don't double process and include them in the + // aggregate twice. - xPtr += misalignment; - yPtr += misalignment; + misalignment = (uint)Vector.Count; - Debug.Assert(((nuint)(xPtr) % (uint)(sizeof(Vector))) == 0); + xPtr += misalignment; + yPtr += misalignment; - remainder -= misalignment; - } + remainder -= misalignment; Vector vector1; Vector vector2; diff --git a/src/libraries/System.Numerics.Tensors/src/System/ThrowHelper.cs b/src/libraries/System.Numerics.Tensors/src/System/ThrowHelper.cs index 4ccdb305b59..6fc32bae555 100644 --- a/src/libraries/System.Numerics.Tensors/src/System/ThrowHelper.cs +++ b/src/libraries/System.Numerics.Tensors/src/System/ThrowHelper.cs @@ -98,9 +98,9 @@ public static void ThrowArgument_SetSliceInvalidShapes(string? paramNames) } [DoesNotReturn] - public static void ThrowArgument_ShapesNotBroadcastCompatible() + public static void ThrowArgument_LengthsNotBroadcastCompatible() { - throw new ArgumentException(SR.ThrowArgument_ShapesNotBroadcastCompatible); + throw new ArgumentException(SR.ThrowArgument_LengthsNotBroadcastCompatible); } [DoesNotReturn] diff --git a/src/libraries/System.Numerics.Tensors/tests/Helpers.cs b/src/libraries/System.Numerics.Tensors/tests/Helpers.cs index d5574561464..4ea2988e6f4 100644 --- a/src/libraries/System.Numerics.Tensors/tests/Helpers.cs +++ b/src/libraries/System.Numerics.Tensors/tests/Helpers.cs @@ -14,7 +14,9 @@ public static class Helpers public static IEnumerable TensorLengthsIncluding0 => Enumerable.Range(0, 257); public static IEnumerable TensorLengths => Enumerable.Range(1, 256); - public static IEnumerable TensorShapes => [[1], [2], [10], [1,1], [1,2], [2,2], [5, 5], [2, 2, 2], [5, 5, 5], [3, 3, 3, 3], [4, 4, 4, 4, 4], [1, 2, 3, 4, 5, 6, 7]]; + public static IEnumerable TensorShapes => [[1], [2], [10], [1, 1], [1, 2], [2, 2], [5, 5], [2, 2, 2], [5, 5, 5], [3, 3, 3, 3], [4, 4, 4, 4, 4], [1, 2, 3, 4, 5, 6, 7, 1, 2]]; + public static nint[][] TensorSliceShapes => [[1], [1], [5], [1, 1], [1, 1], [1, 2], [3, 3], [2, 2, 1], [5, 3, 5], [3, 2, 1, 3], [4, 3, 2, 1, 2], [1, 2, 2, 2, 2, 1, 1, 1, 1]]; + public static nint[][] TensorSliceShapesForBroadcast => [[1], [1], [1], [1, 1], [1, 1], [1, 2], [1, 1], [2, 2, 1], [1, 5, 5], [3, 1, 1, 3], [4, 1, 4, 1, 4], [1, 2, 1, 4, 1, 1, 7, 1, 1]]; // Tolerances taken from testing in the scalar math routines: // cf. https://github.com/dotnet/runtime/blob/89f7ad3b276fb0b48f20cb4e8408bdce85c2b415/src/libraries/System.Runtime/tests/System.Runtime.Extensions.Tests/System/Math.cs diff --git a/src/libraries/System.Numerics.Tensors/tests/ReadOnlyTensorSpanTests.cs b/src/libraries/System.Numerics.Tensors/tests/ReadOnlyTensorSpanTests.cs index e5e4a8c60bd..0a80defb885 100644 --- a/src/libraries/System.Numerics.Tensors/tests/ReadOnlyTensorSpanTests.cs +++ b/src/libraries/System.Numerics.Tensors/tests/ReadOnlyTensorSpanTests.cs @@ -16,6 +16,12 @@ public class ReadOnlyTensorSpanTests [Fact] public static void ReadOnlyTensorSpanSystemArrayConstructorTests() { + // When using System.Array constructor make sure the type of the array matches T[] + Assert.Throws(() => new TensorSpan(array: new[] { 1 })); + + string[] stringArray = { "a", "b", "c" }; + Assert.Throws(() => new TensorSpan(array: stringArray)); + // Make sure basic T[,] constructor works int[,] a = new int[,] { { 91, 92, -93, 94 } }; scoped ReadOnlyTensorSpan spanInt = new ReadOnlyTensorSpan(a); @@ -224,6 +230,11 @@ public static void ReadOnlyTensorSpanSystemArrayConstructorTests() [Fact] public static void ReadOnlyTensorSpanArrayConstructorTests() { + // Make sure exception is thrown if lengths and strides would let you go past the end of the array + Assert.Throws(() => new TensorSpan(new double[0], lengths: new IntPtr[] { 2 }, strides: new IntPtr[] { 1 })); + Assert.Throws(() => new TensorSpan(new double[1], lengths: new IntPtr[] { 2 }, strides: new IntPtr[] { 1 })); + Assert.Throws(() => new TensorSpan(new double[2], lengths: new IntPtr[] { 2 }, strides: new IntPtr[] { 2 })); + // Make sure basic T[] constructor works int[] a = { 91, 92, -93, 94 }; scoped ReadOnlyTensorSpan spanInt = new ReadOnlyTensorSpan(a); @@ -979,6 +990,52 @@ public static void ReadOnlyTensorSpanTryCopyTest() [Fact] public static void ReadOnlyTensorSpanSliceTest() { + // Make sure slicing an empty TensorSpan works + TensorSpan emptyTensorSpan = new TensorSpan(Array.Empty()).Slice(new NRange[] { .. }); + Assert.Equal([0], emptyTensorSpan.Lengths); + Assert.Equal(1, emptyTensorSpan.Rank); + Assert.Equal(0, emptyTensorSpan.FlattenedLength); + + // Make sure slicing a multi-dimensional empty TensorSpan works + int[,] empty2dArray = new int[2, 0]; + emptyTensorSpan = new TensorSpan(empty2dArray); + TensorSpan slicedEmptyTensorSpan = emptyTensorSpan.Slice(new NRange[] { .., .. }); + Assert.Equal([2, 0], slicedEmptyTensorSpan.Lengths); + Assert.Equal(2, slicedEmptyTensorSpan.Rank); + Assert.Equal(0, slicedEmptyTensorSpan.FlattenedLength); + + slicedEmptyTensorSpan = emptyTensorSpan.Slice(new NRange[] { 0..1, .. }); + Assert.Equal([1, 0], slicedEmptyTensorSpan.Lengths); + Assert.Equal(2, slicedEmptyTensorSpan.Rank); + Assert.Equal(0, slicedEmptyTensorSpan.FlattenedLength); + + // Make sure slicing a multi-dimensional empty TensorSpan works + int[,,,] empty4dArray = new int[2, 5, 1, 0]; + emptyTensorSpan = new TensorSpan(empty4dArray); + slicedEmptyTensorSpan = emptyTensorSpan.Slice(new NRange[] { .., .., .., .. }); + Assert.Equal([2, 5, 1, 0], slicedEmptyTensorSpan.Lengths); + Assert.Equal(4, slicedEmptyTensorSpan.Rank); + Assert.Equal(0, slicedEmptyTensorSpan.FlattenedLength); + + emptyTensorSpan = new TensorSpan(empty4dArray); + slicedEmptyTensorSpan = emptyTensorSpan.Slice(new NRange[] { 0..1, .., .., .. }); + Assert.Equal([1, 5, 1, 0], slicedEmptyTensorSpan.Lengths); + Assert.Equal(4, slicedEmptyTensorSpan.Rank); + Assert.Equal(0, slicedEmptyTensorSpan.FlattenedLength); + + emptyTensorSpan = new TensorSpan(empty4dArray); + slicedEmptyTensorSpan = emptyTensorSpan.Slice(new NRange[] { 0..1, 2..3, .., .. }); + Assert.Equal([1, 1, 1, 0], slicedEmptyTensorSpan.Lengths); + Assert.Equal(4, slicedEmptyTensorSpan.Rank); + Assert.Equal(0, slicedEmptyTensorSpan.FlattenedLength); + + empty4dArray = new int[2, 0, 1, 5]; + emptyTensorSpan = new TensorSpan(empty4dArray); + slicedEmptyTensorSpan = emptyTensorSpan.Slice(new NRange[] { .., .., .., .. }); + Assert.Equal([2, 0, 1, 5], slicedEmptyTensorSpan.Lengths); + Assert.Equal(4, slicedEmptyTensorSpan.Rank); + Assert.Equal(0, slicedEmptyTensorSpan.FlattenedLength); + int[] a = [1, 2, 3, 4, 5, 6, 7, 8, 9]; int[] results = new int[9]; ReadOnlyTensorSpan spanInt = a.AsTensorSpan(3, 3); diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.cs b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.cs index 278ab39938b..920ed00af7e 100644 --- a/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.cs +++ b/src/libraries/System.Numerics.Tensors/tests/TensorPrimitivesTests.cs @@ -163,9 +163,17 @@ protected T NextRandom(T avoid) /// the value is stored into a random position in , and the original /// value is subsequently restored. /// - protected void RunForEachSpecialValue(Action action, BoundedMemory x) + protected void RunForEachSpecialValue(Action action, BoundedMemory x) => + RunForEachSpecialValue(action, x, GetSpecialValues()); + + /// + /// Runs the specified action for each special value. Before the action is invoked, + /// the value is stored into a random position in , and the original + /// value is subsequently restored. + /// + protected void RunForEachSpecialValue(Action action, BoundedMemory x, IEnumerable specialValues) { - Assert.All(GetSpecialValues(), value => + Assert.All(specialValues, value => { int pos = Random.Next(x.Length); T orig = x[pos]; @@ -1021,6 +1029,17 @@ public void Exp_SpecialValues() using BoundedMemory x = CreateAndFillTensor(tensorLength); using BoundedMemory destination = CreateTensor(tensorLength); + T[] additionalSpecialValues = + [ + typeof(T) == typeof(float) ? (T)(object)-709.7f : + typeof(T) == typeof(double) ? (T)(object)-709.7 : + default, + + typeof(T) == typeof(float) ? (T)(object)709.7f : + typeof(T) == typeof(double) ? (T)(object)709.7 : + default, + ]; + RunForEachSpecialValue(() => { Exp(x, destination); @@ -1028,7 +1047,7 @@ public void Exp_SpecialValues() { AssertEqualTolerance(Exp(x[i]), destination[i]); } - }, x); + }, x, GetSpecialValues().Concat(additionalSpecialValues)); }); } diff --git a/src/libraries/System.Numerics.Tensors/tests/TensorSpanTests.cs b/src/libraries/System.Numerics.Tensors/tests/TensorSpanTests.cs index e43a7d55e7d..8427e8ede5d 100644 --- a/src/libraries/System.Numerics.Tensors/tests/TensorSpanTests.cs +++ b/src/libraries/System.Numerics.Tensors/tests/TensorSpanTests.cs @@ -4,6 +4,7 @@ using System.Buffers; using System.Collections.Generic; using System.Linq; +using System.Reflection; using System.Runtime.InteropServices; using Xunit; @@ -34,93 +35,179 @@ private static nint CalculateTotalLength(ReadOnlySpan lengths) return totalLength; } - public delegate void TensorPrimitivesSpanInSpanOut(ReadOnlySpan input, Span output); - public delegate ref readonly TensorSpan TensorSpanInSpanOut(scoped in ReadOnlyTensorSpan input, in TensorSpan destination); - public delegate ref readonly TensorSpan TensorSpanInSpanOutInPlace(in TensorSpan input); + public delegate void TensorPrimitivesSpanInSpanOut(ReadOnlySpan input, Span output); + public delegate ref readonly TensorSpan TensorSpanInSpanOut(scoped in ReadOnlyTensorSpan input, in TensorSpan destination); public static IEnumerable SpanInSpanOutData() { - yield return Create(TensorPrimitives.Abs, Tensor.Abs); - yield return Create(TensorPrimitives.Acos, Tensor.Acos); - yield return Create(TensorPrimitives.Acosh, Tensor.Acosh); - yield return Create(TensorPrimitives.AcosPi, Tensor.AcosPi); - yield return Create(TensorPrimitives.Asin, Tensor.Asin); - yield return Create(TensorPrimitives.Asinh, Tensor.Asinh); - yield return Create(TensorPrimitives.AsinPi, Tensor.AsinPi); - yield return Create(TensorPrimitives.Atan, Tensor.Atan); - yield return Create(TensorPrimitives.Atanh, Tensor.Atanh); - yield return Create(TensorPrimitives.AtanPi, Tensor.AtanPi); - yield return Create(TensorPrimitives.Cbrt, Tensor.Cbrt); - yield return Create(TensorPrimitives.Ceiling, Tensor.Ceiling); - yield return Create(TensorPrimitives.Cos, Tensor.Cos); - yield return Create(TensorPrimitives.Cosh, Tensor.Cosh); - yield return Create(TensorPrimitives.CosPi, Tensor.CosPi); - yield return Create(TensorPrimitives.DegreesToRadians, Tensor.DegreesToRadians); - yield return Create(TensorPrimitives.Exp, Tensor.Exp); - yield return Create(TensorPrimitives.Exp10, Tensor.Exp10); - yield return Create(TensorPrimitives.Exp10M1, Tensor.Exp10M1); - yield return Create(TensorPrimitives.Exp2, Tensor.Exp2); - yield return Create(TensorPrimitives.Exp2M1, Tensor.Exp2M1); - yield return Create(TensorPrimitives.ExpM1, Tensor.ExpM1); - yield return Create(TensorPrimitives.Floor, Tensor.Floor); - yield return Create(TensorPrimitives.LeadingZeroCount, Tensor.LeadingZeroCount); - yield return Create(TensorPrimitives.Log, Tensor.Log); - yield return Create(TensorPrimitives.Log10, Tensor.Log10); - yield return Create(TensorPrimitives.Log10P1, Tensor.Log10P1); - yield return Create(TensorPrimitives.Log2, Tensor.Log2); - yield return Create(TensorPrimitives.Log2P1, Tensor.Log2P1); - yield return Create(TensorPrimitives.LogP1, Tensor.LogP1); - yield return Create(TensorPrimitives.Negate, Tensor.Negate); - yield return Create(TensorPrimitives.OnesComplement, Tensor.OnesComplement); - yield return Create(TensorPrimitives.PopCount, Tensor.PopCount); - yield return Create(TensorPrimitives.RadiansToDegrees, Tensor.RadiansToDegrees); - yield return Create(TensorPrimitives.Reciprocal, Tensor.Reciprocal); - yield return Create(TensorPrimitives.Round, Tensor.Round); - yield return Create(TensorPrimitives.Sigmoid, Tensor.Sigmoid); - yield return Create(TensorPrimitives.Sin, Tensor.Sin); - yield return Create(TensorPrimitives.Sinh, Tensor.Sinh); - yield return Create(TensorPrimitives.SinPi, Tensor.SinPi); - yield return Create(TensorPrimitives.SoftMax, Tensor.SoftMax); - yield return Create(TensorPrimitives.Sqrt, Tensor.Sqrt); - yield return Create(TensorPrimitives.Tan, Tensor.Tan); - yield return Create(TensorPrimitives.Tanh, Tensor.Tanh); - yield return Create(TensorPrimitives.TanPi, Tensor.TanPi); - yield return Create(TensorPrimitives.Truncate, Tensor.Truncate); - - static object[] Create(TensorPrimitivesSpanInSpanOut tensorPrimitivesMethod, TensorSpanInSpanOut tensorOperation) + yield return Create(TensorPrimitives.Abs, Tensor.Abs); + yield return Create(TensorPrimitives.Acos, Tensor.Acos); + yield return Create(TensorPrimitives.Acosh, Tensor.Acosh); + yield return Create(TensorPrimitives.AcosPi, Tensor.AcosPi); + yield return Create(TensorPrimitives.Asin, Tensor.Asin); + yield return Create(TensorPrimitives.Asinh, Tensor.Asinh); + yield return Create(TensorPrimitives.AsinPi, Tensor.AsinPi); + yield return Create(TensorPrimitives.Atan, Tensor.Atan); + yield return Create(TensorPrimitives.Atanh, Tensor.Atanh); + yield return Create(TensorPrimitives.AtanPi, Tensor.AtanPi); + yield return Create(TensorPrimitives.Cbrt, Tensor.Cbrt); + yield return Create(TensorPrimitives.Ceiling, Tensor.Ceiling); + yield return Create(TensorPrimitives.Cos, Tensor.Cos); + yield return Create(TensorPrimitives.Cosh, Tensor.Cosh); + yield return Create(TensorPrimitives.CosPi, Tensor.CosPi); + yield return Create(TensorPrimitives.DegreesToRadians, Tensor.DegreesToRadians); + yield return Create(TensorPrimitives.Exp, Tensor.Exp); + yield return Create(TensorPrimitives.Exp10, Tensor.Exp10); + yield return Create(TensorPrimitives.Exp10M1, Tensor.Exp10M1); + yield return Create(TensorPrimitives.Exp2, Tensor.Exp2); + yield return Create(TensorPrimitives.Exp2M1, Tensor.Exp2M1); + yield return Create(TensorPrimitives.ExpM1, Tensor.ExpM1); + yield return Create(TensorPrimitives.Floor, Tensor.Floor); + yield return Create(TensorPrimitives.LeadingZeroCount, Tensor.LeadingZeroCount); + yield return Create(TensorPrimitives.Log, Tensor.Log); + yield return Create(TensorPrimitives.Log10, Tensor.Log10); + yield return Create(TensorPrimitives.Log10P1, Tensor.Log10P1); + yield return Create(TensorPrimitives.Log2, Tensor.Log2); + yield return Create(TensorPrimitives.Log2P1, Tensor.Log2P1); + yield return Create(TensorPrimitives.LogP1, Tensor.LogP1); + yield return Create(TensorPrimitives.Negate, Tensor.Negate); + yield return Create(TensorPrimitives.OnesComplement, Tensor.OnesComplement); + yield return Create(TensorPrimitives.PopCount, Tensor.PopCount); + yield return Create(TensorPrimitives.RadiansToDegrees, Tensor.RadiansToDegrees); + yield return Create(TensorPrimitives.Reciprocal, Tensor.Reciprocal); + yield return Create(TensorPrimitives.Round, Tensor.Round); + yield return Create(TensorPrimitives.Sigmoid, Tensor.Sigmoid); + yield return Create(TensorPrimitives.Sin, Tensor.Sin); + yield return Create(TensorPrimitives.Sinh, Tensor.Sinh); + yield return Create(TensorPrimitives.SinPi, Tensor.SinPi); + yield return Create(TensorPrimitives.SoftMax, Tensor.SoftMax); + yield return Create(TensorPrimitives.Sqrt, Tensor.Sqrt); + yield return Create(TensorPrimitives.Tan, Tensor.Tan); + yield return Create(TensorPrimitives.Tanh, Tensor.Tanh); + yield return Create(TensorPrimitives.TanPi, Tensor.TanPi); + yield return Create(TensorPrimitives.Truncate, Tensor.Truncate); + yield return Create(TensorPrimitives.ILogB, Tensor.ILogB); + yield return Create(TensorPrimitives.ConvertChecked, Tensor.ConvertChecked); + yield return Create(TensorPrimitives.ConvertSaturating, Tensor.ConvertSaturating); + yield return Create(TensorPrimitives.ConvertTruncating, Tensor.ConvertTruncating); + + static object[] Create(TensorPrimitivesSpanInSpanOut tensorPrimitivesMethod, TensorSpanInSpanOut tensorOperation) => new object[] { tensorPrimitivesMethod, tensorOperation }; } [Theory, MemberData(nameof(SpanInSpanOutData))] - public void TensorExtensionsSpanInSpanOut(TensorPrimitivesSpanInSpanOut tensorPrimitivesOperation, TensorSpanInSpanOut tensorOperation) - where T : INumberBase + public void TensorExtensionsSpanInSpanOut(TensorPrimitivesSpanInSpanOut tensorPrimitivesOperation, TensorSpanInSpanOut tensorOperation) + where TIn : INumberBase + where TOut: INumber { - Assert.All(Helpers.TensorShapes, tensorLength => + Assert.All(Helpers.TensorShapes, (tensorLength, index) => { nint length = CalculateTotalLength(tensorLength); - T[] data = new T[length]; - T[] data2 = new T[length]; - T[] expectedOutput = new T[length]; - FillTensor(data); - TensorSpan x = Tensor.Create(data, tensorLength, []); - TensorSpan destination = Tensor.Create(data2, tensorLength, []); - tensorPrimitivesOperation((ReadOnlySpan)data, expectedOutput); - TensorSpan results = tensorOperation(x, destination); + TIn[] data = new TIn[length]; + TOut[] data2 = new TOut[length]; + TOut[] expectedOutput = new TOut[length]; + + FillTensor(data); + TensorSpan x = Tensor.Create(data, tensorLength, []); + TensorSpan destination = Tensor.Create(data2, tensorLength, []); + tensorPrimitivesOperation((ReadOnlySpan)data, expectedOutput); + TensorSpan tensorResults = tensorOperation(x, destination); - Assert.Equal(tensorLength, results.Lengths); + Assert.Equal(tensorLength, tensorResults.Lengths); nint[] startingIndex = new nint[tensorLength.Length]; // the "Return" value - ReadOnlySpan span = MemoryMarshal.CreateSpan(ref results[startingIndex], (int)length); + ReadOnlySpan span = MemoryMarshal.CreateSpan(ref tensorResults[startingIndex], (int)length); // the "destination" value - ReadOnlySpan destSpan = MemoryMarshal.CreateSpan(ref destination[startingIndex], (int)length); + ReadOnlySpan destSpan = MemoryMarshal.CreateSpan(ref destination[startingIndex], (int)length); for (int i = 0; i < data.Length; i++) { Assert.Equal(expectedOutput[i], span[i]); Assert.Equal(expectedOutput[i], destSpan[i]); } + + // Now test if the source is sliced to be smaller then the destination that the destination is also sliced + // to the correct size. + NRange[] sliceLengths = Helpers.TensorSliceShapes[index].Select(i => new NRange(0, i)).ToArray(); + nint sliceFlattenedLength = CalculateTotalLength(Helpers.TensorSliceShapes[index]); + x = x.Slice(sliceLengths); + TIn[] sliceData = new TIn[sliceFlattenedLength]; + x.FlattenTo(sliceData); + expectedOutput = new TOut[sliceFlattenedLength]; + + if (TensorHelpers.IsContiguousAndDense(x)) + { + tensorPrimitivesOperation((ReadOnlySpan)sliceData, expectedOutput); + } + else + { + int rowLength = (int)Helpers.TensorSliceShapes[index][^1]; + for (int i = 0; i < sliceData.Length; i+= rowLength) + { + tensorPrimitivesOperation(((ReadOnlySpan)sliceData).Slice(i, rowLength), ((Span)expectedOutput).Slice(i, rowLength)); + } + + } + + tensorResults = tensorOperation(x, destination); + + // tensorResults lengths will still be the original tensorLength and not equal to the sliced length since that happened internally/automatically + Assert.Equal(tensorLength, tensorResults.Lengths); + + TensorSpan.Enumerator destEnum = destination.Slice(sliceLengths).GetEnumerator(); + TensorSpan.Enumerator tensorResultsEnum = tensorResults.Slice(sliceLengths).GetEnumerator(); + bool destEnumMove; + bool tensorResultsEnumMove; + + for (int i = 0; i < expectedOutput.Length; i++) + { + destEnumMove = destEnum.MoveNext(); + tensorResultsEnumMove = tensorResultsEnum.MoveNext(); + + Assert.True(destEnumMove); + Assert.True(tensorResultsEnumMove); + Assert.Equal(expectedOutput[i], destEnum.Current); + Assert.Equal(expectedOutput[i], tensorResultsEnum.Current); + } + + // Now test if the source and destination are sliced (so neither is continuous) it works correctly. + destination = destination.Slice(sliceLengths); + x.FlattenTo(sliceData); + expectedOutput = new TOut[sliceFlattenedLength]; + + if (TensorHelpers.IsContiguousAndDense(x)) + { + tensorPrimitivesOperation((ReadOnlySpan)sliceData, expectedOutput); + } + else + { + int rowLength = (int)Helpers.TensorSliceShapes[index][^1]; + for (int i = 0; i < sliceData.Length; i += rowLength) + { + tensorPrimitivesOperation(((ReadOnlySpan)sliceData).Slice(i, rowLength), ((Span)expectedOutput).Slice(i, rowLength)); + } + + } + + tensorResults = tensorOperation(x, destination); + + Assert.Equal(Helpers.TensorSliceShapes[index], tensorResults.Lengths); + + destEnum = destination.GetEnumerator(); + tensorResultsEnum = tensorResults.GetEnumerator(); + + for (int i = 0; i < expectedOutput.Length; i++) + { + destEnumMove = destEnum.MoveNext(); + tensorResultsEnumMove = tensorResultsEnum.MoveNext(); + + Assert.True(destEnumMove); + Assert.True(tensorResultsEnumMove); + Assert.Equal(expectedOutput[i], destEnum.Current); + Assert.Equal(expectedOutput[i], tensorResultsEnum.Current); + } }); } @@ -146,7 +233,7 @@ static object[] Create(TensorPrimitivesSpanInTOut tensorPrimitivesMethod, public void TensorExtensionsSpanInTOut(TensorPrimitivesSpanInTOut tensorPrimitivesOperation, TensorSpanInTOut tensorOperation) where T : INumberBase { - Assert.All(Helpers.TensorShapes, tensorLength => + Assert.All(Helpers.TensorShapes, (tensorLength, index) => { nint length = CalculateTotalLength(tensorLength); T[] data = new T[length]; @@ -157,6 +244,40 @@ public void TensorExtensionsSpanInTOut(TensorPrimitivesSpanInTOut tensorPr T results = tensorOperation(x); Assert.Equal(expectedOutput, results); + + float[] testData = [49.788437f, 32.736755f, -0.25761032f, -46.402596f, 4.5581512f, 21.813591f, 44.976646f, 12.691814f, -44.188023f, 40.35988f, -6.999405f, 4.713642f, 5.274975f, 21.312515f, -12.536407f, -34.888573f, -1.90839f, 28.734451f, -38.64155f, -28.840702f, 7.373543f, 18.600182f, 26.007828f, 0.71430206f, -6.8293495f, -13.327972f, -25.149017f, 9.331852f, 40.87751f, 28.321632f, 42.918175f, 25.213333f, -41.392017f, 36.727768f, 26.49012f, 3.8807983f, 24.933182f, -43.050568f, -42.6283f, 18.01947f, -47.62874f, -49.94487f, -1.036602f, -37.086433f, 32.77098f, -12.903477f, -45.100212f, -20.596504f, 33.67714f, 46.864395f, 44.437485f, -44.092155f, 37.122124f, 25.220505f, 41.994873f, -13.3394165f, -28.193134f, -21.329712f, -36.623306f, 3.3981133f, -26.475079f, 16.339478f, -44.07065f, 36.321762f, -24.63433f, 28.652397f, 4.096817f, 33.29615f, -2.3503838f, -7.509815f, 42.943604f, -32.52115f, -0.20326233f, 29.554626f, 18.044052f]; + nint[] testLengths = [5, 3, 5]; + Tensor testTensor = Tensor.Create(testData, testLengths, []); + float[] testSliceData = new float[75]; + testTensor.FlattenTo(testSliceData); + float testExpectedOutput = TensorPrimitives.Sum((ReadOnlySpan)testSliceData); + float testResults = Tensor.Sum(testTensor); + + + // Now test if the source is sliced to be non contiguous that it still gives expected result. + NRange[] sliceLengths = Helpers.TensorSliceShapes[index].Select(i => new NRange(0, i)).ToArray(); + nint sliceFlattenedLength = CalculateTotalLength(Helpers.TensorSliceShapes[index]); + x = x.Slice(sliceLengths); + T[] sliceData = new T[sliceFlattenedLength]; + x.FlattenTo(sliceData); + + IEnumerator enumerator = x.GetEnumerator(); + bool cont = enumerator.MoveNext(); + ReadOnlySpan span = MemoryMarshal.CreateSpan(ref x.AsReadOnlyTensorSpan()._reference, (int)x.FlattenedLength); + int i = 0; + Assert.True(span.SequenceEqual(sliceData)); + while (cont) + { + Assert.Equal(sliceData[i], enumerator.Current); + Assert.Equal(span[i], enumerator.Current); + Assert.Equal(span[i], sliceData[i++]); + cont = enumerator.MoveNext(); + } + + expectedOutput = tensorPrimitivesOperation((ReadOnlySpan)sliceData); + results = tensorOperation(x); + + Assert.Equal(expectedOutput, results); }); } @@ -184,9 +305,9 @@ static object[] Create(TensorPrimitivesTwoSpanInSpanOut tensorPrimitivesMe public void TensorExtensionsTwoSpanInSpanOut(TensorPrimitivesTwoSpanInSpanOut tensorPrimitivesOperation, TensorTwoSpanInSpanOut tensorOperation) where T : INumberBase { - Assert.All(Helpers.TensorShapes, tensorLength => + Assert.All(Helpers.TensorShapes, (tensorLengths, index) => { - nint length = CalculateTotalLength(tensorLength); + nint length = CalculateTotalLength(tensorLengths); T[] data1 = new T[length]; T[] data2 = new T[length]; T[] destData = new T[length]; @@ -194,14 +315,17 @@ public void TensorExtensionsTwoSpanInSpanOut(TensorPrimitivesTwoSpanInSpanOut FillTensor(data1); FillTensor(data2); - TensorSpan x = Tensor.Create(data1, tensorLength, []); - TensorSpan y = Tensor.Create(data2, tensorLength, []); - TensorSpan destination = Tensor.Create(destData, tensorLength, []); + + + // First test when everything is exact sizes + TensorSpan x = Tensor.Create(data1, tensorLengths, []); + TensorSpan y = Tensor.Create(data2, tensorLengths, []); + TensorSpan destination = Tensor.Create(destData, tensorLengths, []); tensorPrimitivesOperation((ReadOnlySpan)data1, data2, expectedOutput); TensorSpan results = tensorOperation(x, y, destination); - Assert.Equal(tensorLength, results.Lengths); - nint[] startingIndex = new nint[tensorLength.Length]; + Assert.Equal(tensorLengths, results.Lengths); + nint[] startingIndex = new nint[tensorLengths.Length]; // the "Return" value ReadOnlySpan span = MemoryMarshal.CreateSpan(ref results[startingIndex], (int)length); // the "destination" value @@ -212,6 +336,148 @@ public void TensorExtensionsTwoSpanInSpanOut(TensorPrimitivesTwoSpanInSpanOut Assert.Equal(expectedOutput[i], span[i]); Assert.Equal(expectedOutput[i], destSpan[i]); } + + // Now test when both sources are exact sizes but destination is too large and gets sliced internally. + nint[] tempLengths = tensorLengths.Select(i => i + 1).ToArray(); + T[] tempDestData = new T[CalculateTotalLength(tempLengths)]; + destination = Tensor.Create(tempDestData, tempLengths, []); + results = tensorOperation(x, y, destination); + + // Since the slice was internal the result lengths will be the extra large size. + Assert.Equal(tempLengths, results.Lengths); + startingIndex = new nint[tensorLengths.Length]; + + TensorSpan.Enumerator destEnum = destination.Slice(tensorLengths).GetEnumerator(); + TensorSpan.Enumerator tensorResultsEnum = results.Slice(tensorLengths).GetEnumerator(); + bool destEnumMove; + bool tensorResultsEnumMove; + + for (int i = 0; i < expectedOutput.Length; i++) + { + destEnumMove = destEnum.MoveNext(); + tensorResultsEnumMove = tensorResultsEnum.MoveNext(); + + Assert.True(destEnumMove); + Assert.True(tensorResultsEnumMove); + Assert.Equal(expectedOutput[i], destEnum.Current); + Assert.Equal(expectedOutput[i], tensorResultsEnum.Current); + } + + // Now test if the first source is sliced to be smaller than the second (but is broadcast compatible) that broadcasting happens). + int rowLength = (int)Helpers.TensorSliceShapesForBroadcast[index][^1]; + + NRange[] sliceLengths = Helpers.TensorSliceShapesForBroadcast[index].Select(i => new NRange(0, i)).ToArray(); + nint sliceFlattenedLength = CalculateTotalLength(Helpers.TensorSliceShapesForBroadcast[index]); + destination = destination.Slice(tensorLengths); + x.Slice(sliceLengths).BroadcastTo(x); + x.FlattenTo(data1); + + if (TensorHelpers.IsContiguousAndDense(x.Slice(sliceLengths)) && TensorHelpers.IsContiguousAndDense(y)) + { + tensorPrimitivesOperation((ReadOnlySpan)data1, data2, expectedOutput); + } + else + { + for (int i = 0; i < data1.Length; i += rowLength) + { + tensorPrimitivesOperation(((ReadOnlySpan)data1).Slice(i, rowLength), ((ReadOnlySpan)data2).Slice(i, rowLength), ((Span)expectedOutput).Slice(i, rowLength)); + } + + } + + results = tensorOperation(x.Slice(sliceLengths), y, destination); + + // results lengths will still be the original tensorLength + Assert.Equal(tensorLengths, results.Lengths); + + destEnum = destination.GetEnumerator(); + tensorResultsEnum = results.GetEnumerator(); + + for (int i = 0; i < expectedOutput.Length; i++) + { + destEnumMove = destEnum.MoveNext(); + tensorResultsEnumMove = tensorResultsEnum.MoveNext(); + + Assert.True(destEnumMove); + Assert.True(tensorResultsEnumMove); + Assert.Equal(expectedOutput[i], destEnum.Current); + Assert.Equal(expectedOutput[i], tensorResultsEnum.Current); + } + + // Now test if the second source is sliced to be smaller than the first (but is broadcast compatible) that broadcasting happens). + y.Slice(sliceLengths).BroadcastTo(y); + y.FlattenTo(data2); + + if (TensorHelpers.IsContiguousAndDense(x) && TensorHelpers.IsContiguousAndDense(y.Slice(sliceLengths))) + { + tensorPrimitivesOperation((ReadOnlySpan)data1, data2, expectedOutput); + } + else + { + for (int i = 0; i < data2.Length; i += rowLength) + { + tensorPrimitivesOperation(((ReadOnlySpan)data1).Slice(i, rowLength), ((ReadOnlySpan)data2).Slice(i, rowLength), ((Span)expectedOutput).Slice(i, rowLength)); + } + + } + + results = tensorOperation(x, y.Slice(sliceLengths), destination); + + // results lengths will still be the original tensorLength + Assert.Equal(tensorLengths, results.Lengths); + + destEnum = destination.GetEnumerator(); + tensorResultsEnum = results.GetEnumerator(); + + for (int i = 0; i < expectedOutput.Length; i++) + { + destEnumMove = destEnum.MoveNext(); + tensorResultsEnumMove = tensorResultsEnum.MoveNext(); + + Assert.True(destEnumMove); + Assert.True(tensorResultsEnumMove); + Assert.Equal(expectedOutput[i], destEnum.Current); + Assert.Equal(expectedOutput[i], tensorResultsEnum.Current); + } + + // Now test if both sources are sliced to be smaller than the destination that the destination will be sliced automatically + T[] sliceData1 = new T[sliceFlattenedLength]; + T[] sliceData2 = new T[sliceFlattenedLength]; + expectedOutput = new T[sliceFlattenedLength]; + + x.Slice(sliceLengths).FlattenTo(sliceData1); + y.Slice(sliceLengths).FlattenTo(sliceData2); + + if (TensorHelpers.IsContiguousAndDense(x.Slice(sliceLengths)) && TensorHelpers.IsContiguousAndDense(y.Slice(sliceLengths))) + { + tensorPrimitivesOperation((ReadOnlySpan)sliceData1, sliceData2, expectedOutput); + } + else + { + for (int i = 0; i < sliceData1.Length; i += rowLength) + { + tensorPrimitivesOperation(((ReadOnlySpan)sliceData1).Slice(i, rowLength), ((ReadOnlySpan)sliceData2).Slice(i, rowLength), ((Span)expectedOutput).Slice(i, rowLength)); + } + + } + + results = tensorOperation(x.Slice(sliceLengths), y.Slice(sliceLengths), destination); + + Assert.Equal(tensorLengths, results.Lengths); + + destEnum = destination.Slice(sliceLengths).GetEnumerator(); + tensorResultsEnum = results.Slice(sliceLengths).GetEnumerator(); + + for (int i = 0; i < expectedOutput.Length; i++) + { + destEnumMove = destEnum.MoveNext(); + tensorResultsEnumMove = tensorResultsEnum.MoveNext(); + + Assert.True(destEnumMove); + Assert.True(tensorResultsEnumMove); + Assert.Equal(expectedOutput[i], destEnum.Current); + Assert.Equal(expectedOutput[i], tensorResultsEnum.Current); + } }); } @@ -226,15 +492,18 @@ static object[] Create(TensorPrimitivesTwoSpanInTOut tensorPrimitivesMetho => new object[] { tensorPrimitivesMethod, tensorOperation }; } + [ActiveIssue("https://github.com/dotnet/runtime/issues/107254")] [Theory, MemberData(nameof(TwoSpanInFloatOutData))] public void TensorExtensionsTwoSpanInFloatOut(TensorPrimitivesTwoSpanInTOut tensorPrimitivesOperation, TensorTwoSpanInTOut tensorOperation) where T : INumberBase { - Assert.All(Helpers.TensorShapes, tensorLength => + Assert.All(Helpers.TensorShapes, (tensorLength, index) => { nint length = CalculateTotalLength(tensorLength); T[] data1 = new T[length]; T[] data2 = new T[length]; + T[] broadcastData1 = new T[length]; + T[] broadcastData2 = new T[length]; FillTensor(data1); FillTensor(data2); @@ -244,6 +513,43 @@ public void TensorExtensionsTwoSpanInFloatOut(TensorPrimitivesTwoSpanInTOut new NRange(0, i)).ToArray(); + TensorSpan broadcastX = Tensor.Create(broadcastData1, tensorLength, []); + x.Slice(sliceLengths).BroadcastTo(broadcastX); + TensorSpan.Enumerator enumerator = broadcastX.GetEnumerator(); + bool cont = enumerator.MoveNext(); + int i = 0; + while (cont) + { + Assert.Equal(broadcastData1[i++], enumerator.Current); + cont = enumerator.MoveNext(); + } + + expectedOutput = tensorPrimitivesOperation((ReadOnlySpan)broadcastData1, data2); + results = tensorOperation(x.Slice(sliceLengths), y); + + Assert.Equal(expectedOutput, results); + + // Now test if the second source is sliced to be non contiguous that it still gives expected result. + + TensorSpan broadcastY = Tensor.Create(broadcastData2, tensorLength, []); + y.Slice(sliceLengths).BroadcastTo(broadcastY); + + enumerator = broadcastY.GetEnumerator(); + cont = enumerator.MoveNext(); + i = 0; + while (cont) + { + Assert.Equal(broadcastData2[i++], enumerator.Current); + cont = enumerator.MoveNext(); + } + + expectedOutput = tensorPrimitivesOperation((ReadOnlySpan)data1, broadcastData2); + results = tensorOperation(x, y.Slice(sliceLengths)); + + Assert.Equal(expectedOutput, results); }); } @@ -252,6 +558,12 @@ public void TensorExtensionsTwoSpanInFloatOut(TensorPrimitivesTwoSpanInTOut(() => new TensorSpan(array: new[] { 1 })); + + string[] stringArray = { "a", "b", "c" }; + Assert.Throws(() => new TensorSpan(array: stringArray)); + // Make sure basic T[,] constructor works int[,] a = new int[,] { { 91, 92, -93, 94 } }; scoped TensorSpan spanInt = new TensorSpan(a); @@ -460,6 +772,11 @@ public static void TensorSpanSystemArrayConstructorTests() [Fact] public static void TensorSpanArrayConstructorTests() { + // Make sure exception is thrown if lengths and strides would let you go past the end of the array + Assert.Throws(() => new TensorSpan(new double[0], lengths: new IntPtr[] { 2 }, strides: new IntPtr[] { 1 })); + Assert.Throws(() => new TensorSpan(new double[1], lengths: new IntPtr[] { 2 }, strides: new IntPtr[] { 1 })); + Assert.Throws(() => new TensorSpan(new double[2], lengths: new IntPtr[] { 2 }, strides: new IntPtr[] { 2 })); + // Make sure basic T[] constructor works int[] a = { 91, 92, -93, 94 }; scoped TensorSpan spanInt = new TensorSpan(a); @@ -1399,6 +1716,52 @@ public static void TensorSpanTryCopyTest() [Fact] public static void TensorSpanSliceTest() { + // Make sure slicing an empty TensorSpan works + TensorSpan emptyTensorSpan = new TensorSpan(Array.Empty()).Slice(new NRange[] { .. }); + Assert.Equal([0], emptyTensorSpan.Lengths); + Assert.Equal(1, emptyTensorSpan.Rank); + Assert.Equal(0, emptyTensorSpan.FlattenedLength); + + // Make sure slicing a multi-dimensional empty TensorSpan works + int[,] empty2dArray = new int[2, 0]; + emptyTensorSpan = new TensorSpan(empty2dArray); + TensorSpan slicedEmptyTensorSpan = emptyTensorSpan.Slice(new NRange[] { .. , .. }); + Assert.Equal([2, 0], slicedEmptyTensorSpan.Lengths); + Assert.Equal(2, slicedEmptyTensorSpan.Rank); + Assert.Equal(0, slicedEmptyTensorSpan.FlattenedLength); + + slicedEmptyTensorSpan = emptyTensorSpan.Slice(new NRange[] { 0..1, .. }); + Assert.Equal([1, 0], slicedEmptyTensorSpan.Lengths); + Assert.Equal(2, slicedEmptyTensorSpan.Rank); + Assert.Equal(0, slicedEmptyTensorSpan.FlattenedLength); + + // Make sure slicing a multi-dimensional empty TensorSpan works + int[,,,] empty4dArray = new int[2, 5, 1, 0]; + emptyTensorSpan = new TensorSpan(empty4dArray); + slicedEmptyTensorSpan = emptyTensorSpan.Slice(new NRange[] { .., .., .., .. }); + Assert.Equal([2, 5, 1, 0], slicedEmptyTensorSpan.Lengths); + Assert.Equal(4, slicedEmptyTensorSpan.Rank); + Assert.Equal(0, slicedEmptyTensorSpan.FlattenedLength); + + emptyTensorSpan = new TensorSpan(empty4dArray); + slicedEmptyTensorSpan = emptyTensorSpan.Slice(new NRange[] { 0..1, .., .., .. }); + Assert.Equal([1, 5, 1, 0], slicedEmptyTensorSpan.Lengths); + Assert.Equal(4, slicedEmptyTensorSpan.Rank); + Assert.Equal(0, slicedEmptyTensorSpan.FlattenedLength); + + emptyTensorSpan = new TensorSpan(empty4dArray); + slicedEmptyTensorSpan = emptyTensorSpan.Slice(new NRange[] { 0..1, 2..3, .., .. }); + Assert.Equal([1, 1, 1, 0], slicedEmptyTensorSpan.Lengths); + Assert.Equal(4, slicedEmptyTensorSpan.Rank); + Assert.Equal(0, slicedEmptyTensorSpan.FlattenedLength); + + empty4dArray = new int[2, 0, 1, 5]; + emptyTensorSpan = new TensorSpan(empty4dArray); + slicedEmptyTensorSpan = emptyTensorSpan.Slice(new NRange[] { .., .., .., .. }); + Assert.Equal([2, 0, 1, 5], slicedEmptyTensorSpan.Lengths); + Assert.Equal(4, slicedEmptyTensorSpan.Rank); + Assert.Equal(0, slicedEmptyTensorSpan.FlattenedLength); + int[] a = [1, 2, 3, 4, 5, 6, 7, 8, 9]; int[] results = new int[9]; TensorSpan spanInt = a.AsTensorSpan(3, 3); diff --git a/src/libraries/System.Numerics.Vectors/System.Numerics.Vectors.sln b/src/libraries/System.Numerics.Vectors/System.Numerics.Vectors.sln index a1508feb9fc..49af60742d2 100644 --- a/src/libraries/System.Numerics.Vectors/System.Numerics.Vectors.sln +++ b/src/libraries/System.Numerics.Vectors/System.Numerics.Vectors.sln @@ -13,6 +13,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib.Gene EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\System.Private.CoreLib\ref\System.Private.CoreLib.csproj", "{1542B12A-6A37-49F9-B87B-4B1BB1F689E4}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{7987679E-3BCF-4CFA-80A5-4C714B001AFB}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{547EC332-29FE-47A8-B477-4E19BE521235}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{F99EAF58-533E-4941-A0C5-5101309D8AB9}" @@ -220,6 +222,27 @@ Global {1542B12A-6A37-49F9-B87B-4B1BB1F689E4}.Checked|arm64.ActiveCfg = Debug|Any CPU {1542B12A-6A37-49F9-B87B-4B1BB1F689E4}.Checked|x64.ActiveCfg = Debug|Any CPU {1542B12A-6A37-49F9-B87B-4B1BB1F689E4}.Checked|x86.ActiveCfg = Debug|Any CPU + {7987679E-3BCF-4CFA-80A5-4C714B001AFB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {7987679E-3BCF-4CFA-80A5-4C714B001AFB}.Debug|Any CPU.Build.0 = Debug|Any CPU + {7987679E-3BCF-4CFA-80A5-4C714B001AFB}.Debug|arm.ActiveCfg = Debug|Any CPU + {7987679E-3BCF-4CFA-80A5-4C714B001AFB}.Debug|arm64.ActiveCfg = Debug|Any CPU + {7987679E-3BCF-4CFA-80A5-4C714B001AFB}.Debug|x64.ActiveCfg = Debug|Any CPU + {7987679E-3BCF-4CFA-80A5-4C714B001AFB}.Debug|x64.Build.0 = Debug|Any CPU + {7987679E-3BCF-4CFA-80A5-4C714B001AFB}.Debug|x86.ActiveCfg = Debug|Any CPU + {7987679E-3BCF-4CFA-80A5-4C714B001AFB}.Debug|x86.Build.0 = Debug|Any CPU + {7987679E-3BCF-4CFA-80A5-4C714B001AFB}.Release|Any CPU.ActiveCfg = Release|Any CPU + {7987679E-3BCF-4CFA-80A5-4C714B001AFB}.Release|Any CPU.Build.0 = Release|Any CPU + {7987679E-3BCF-4CFA-80A5-4C714B001AFB}.Release|arm.ActiveCfg = Release|Any CPU + {7987679E-3BCF-4CFA-80A5-4C714B001AFB}.Release|arm64.ActiveCfg = Release|Any CPU + {7987679E-3BCF-4CFA-80A5-4C714B001AFB}.Release|x64.ActiveCfg = Release|Any CPU + {7987679E-3BCF-4CFA-80A5-4C714B001AFB}.Release|x64.Build.0 = Release|Any CPU + {7987679E-3BCF-4CFA-80A5-4C714B001AFB}.Release|x86.ActiveCfg = Release|Any CPU + {7987679E-3BCF-4CFA-80A5-4C714B001AFB}.Release|x86.Build.0 = Release|Any CPU + {7987679E-3BCF-4CFA-80A5-4C714B001AFB}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {7987679E-3BCF-4CFA-80A5-4C714B001AFB}.Checked|arm.ActiveCfg = Debug|Any CPU + {7987679E-3BCF-4CFA-80A5-4C714B001AFB}.Checked|arm64.ActiveCfg = Debug|Any CPU + {7987679E-3BCF-4CFA-80A5-4C714B001AFB}.Checked|x64.ActiveCfg = Debug|Any CPU + {7987679E-3BCF-4CFA-80A5-4C714B001AFB}.Checked|x86.ActiveCfg = Debug|Any CPU {547EC332-29FE-47A8-B477-4E19BE521235}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {547EC332-29FE-47A8-B477-4E19BE521235}.Debug|Any CPU.Build.0 = Debug|Any CPU {547EC332-29FE-47A8-B477-4E19BE521235}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -401,6 +424,7 @@ Global {1542B12A-6A37-49F9-B87B-4B1BB1F689E4} = {ED90FF1C-59D4-4AB0-860E-2872ECA1BFEC} {728E34E5-10B0-4181-940B-EB3FB7784DFA} = {ED90FF1C-59D4-4AB0-860E-2872ECA1BFEC} {88F4A78E-4EF9-4EB6-995E-CD24152C4704} = {38837FDE-8CFE-4676-B3CE-48165E0FD6CF} + {7987679E-3BCF-4CFA-80A5-4C714B001AFB} = {38837FDE-8CFE-4676-B3CE-48165E0FD6CF} {547EC332-29FE-47A8-B477-4E19BE521235} = {38837FDE-8CFE-4676-B3CE-48165E0FD6CF} {F99EAF58-533E-4941-A0C5-5101309D8AB9} = {38837FDE-8CFE-4676-B3CE-48165E0FD6CF} {49B6B26B-CEC6-4EE8-8177-47891A85518A} = {06497322-6B9A-48E6-BEA8-C96362AD7180} diff --git a/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs b/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs index 822bb136dff..28ed4f701d4 100644 --- a/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs +++ b/src/libraries/System.Numerics.Vectors/tests/GenericVectorTests.cs @@ -52,7 +52,6 @@ static GenericVectorTests() } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/81785", TestPlatforms.Browser)] public unsafe void IsHardwareAcceleratedTest() { MethodInfo methodInfo = typeof(Vector).GetMethod("get_IsHardwareAccelerated"); @@ -1094,10 +1093,8 @@ private void TestToString(string format, IFormatProvider provider) where T : [Fact] public void AdditionInt64() { TestAddition(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void AdditionSingle() { TestAddition(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void AdditionDouble() { TestAddition(); } private void TestAddition() where T : struct, INumber { @@ -1161,10 +1158,8 @@ private void TestAdditionOverflow() where T : struct, INumber [Fact] public void SubtractionInt64() { TestSubtraction(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void SubtractionSingle() { TestSubtraction(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void SubtractionDouble() { TestSubtraction(); } private void TestSubtraction() where T : struct, INumber { @@ -1228,10 +1223,8 @@ private void TestSubtractionOverflow() where T : struct, INumber [Fact] public void MultiplicationInt64() { TestMultiplication(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void MultiplicationSingle() { TestMultiplication(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void MultiplicationDouble() { TestMultiplication(); } private void TestMultiplication() where T : struct, INumber { @@ -1272,11 +1265,9 @@ private void TestMultiplication() where T : struct, INumber [ActiveIssue("https://github.com/dotnet/runtime/issues/67893", TestPlatforms.tvOS)] public void MultiplicationWithScalarInt64() { TestMultiplicationWithScalar(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] [ActiveIssue("https://github.com/dotnet/runtime/issues/67893", TestPlatforms.tvOS)] public void MultiplicationWithScalarSingle() { TestMultiplicationWithScalar(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] [ActiveIssue("https://github.com/dotnet/runtime/issues/67893", TestPlatforms.tvOS)] public void MultiplicationWithScalarDouble() { TestMultiplicationWithScalar(); } private void TestMultiplicationWithScalar() where T : struct, INumber @@ -1318,10 +1309,8 @@ private void TestMultiplicationWithScalar() where T : struct, INumber [Fact] public void DivisionInt64() { TestDivision(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void DivisionSingle() { TestDivision(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void DivisionDouble() { TestDivision(); } private void TestDivision() where T : struct, INumber { @@ -1388,11 +1377,9 @@ private void TestDivisionByZeroException() where T : struct public void DivisionWithScalarInt64() { TestDivisionWithScalar(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void DivisionWithScalarSingle() { TestDivisionWithScalar(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void DivisionWithScalarDouble() { TestDivisionWithScalar(); } private void TestDivisionWithScalar() where T : struct, INumber @@ -1460,10 +1447,8 @@ private void TestDivisionWithScalarByZeroException() where T : struct, INumbe [Fact] public void UnaryMinusInt64() { TestUnaryMinus(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void UnaryMinusSingle() { TestUnaryMinus(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void UnaryMinusDouble() { TestUnaryMinus(); } private void TestUnaryMinus() where T : struct, INumber { @@ -1850,10 +1835,8 @@ private void TestShiftRightLogical() where T : unmanaged, IBinaryInteger [Fact] public void VectorGreaterThanInt64() { TestVectorGreaterThan(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void VectorGreaterThanSingle() { TestVectorGreaterThan(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void VectorGreaterThanDouble() { TestVectorGreaterThan(); } private void TestVectorGreaterThan() where T : struct, INumber { @@ -1889,10 +1872,8 @@ private void TestVectorGreaterThan() where T : struct, INumber [Fact] public void GreaterThanOrEqualInt64() { TestVectorGreaterThanOrEqual(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void GreaterThanOrEqualSingle() { TestVectorGreaterThanOrEqual(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void GreaterThanOrEqualDouble() { TestVectorGreaterThanOrEqual(); } private void TestVectorGreaterThanOrEqual() where T : struct, INumber { @@ -2144,10 +2125,8 @@ private void TestVectorGreaterThanOrEqualAll() where T : struct [Fact] public void LessThanInt64() { TestVectorLessThan(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void LessThanSingle() { TestVectorLessThan(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void LessThanDouble() { TestVectorLessThan(); } private void TestVectorLessThan() where T : struct, INumber { @@ -2183,10 +2162,8 @@ private void TestVectorLessThan() where T : struct, INumber [Fact] public void LessThanOrEqualInt64() { TestVectorLessThanOrEqual(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void LessThanOrEqualSingle() { TestVectorLessThanOrEqual(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void LessThanOrEqualDouble() { TestVectorLessThanOrEqual(); } private void TestVectorLessThanOrEqual() where T : struct, INumber { @@ -2222,10 +2199,8 @@ private void TestVectorLessThanOrEqual() where T : struct, INumber [Fact] public void LessThanAnyInt64() { TestVectorLessThanAny(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void LessThanAnySingle() { TestVectorLessThanAny(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void LessThanAnyDouble() { TestVectorLessThanAny(); } private void TestVectorLessThanAny() where T : struct, INumber { @@ -2550,10 +2525,8 @@ private void TestVectorEqualsAll() where T : struct, INumber [Fact] public void ConditionalSelectInt64() { TestConditionalSelect(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void ConditionalSelectSingle() { TestConditionalSelect(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void ConditionalSelectDouble() { TestConditionalSelect(); } private void TestConditionalSelect() where T : struct, INumber { @@ -2604,10 +2577,8 @@ private void TestConditionalSelect() where T : struct, INumber [Fact] public void DotProductInt64() { TestDotProduct(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void DotProductSingle() { TestDotProduct(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void DotProductDouble() { TestDotProduct(); } private void TestDotProduct() where T : struct, INumber { @@ -2642,10 +2613,8 @@ private void TestDotProduct() where T : struct, INumber [Fact] public void MaxInt64() { TestMax(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void MaxSingle() { TestMax(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void MaxDouble() { TestMax(); } private void TestMax() where T : struct, INumber { @@ -2680,10 +2649,8 @@ private void TestMax() where T : struct, INumber [Fact] public void MinInt64() { TestMin(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void MinSingle() { TestMin(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void MinDouble() { TestMin(); } private void TestMin() where T : struct, INumber { @@ -2718,10 +2685,8 @@ private void TestMin() where T : struct, INumber [Fact] public void SquareRootInt64() { TestSquareRoot(-1); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void SquareRootSingle() { TestSquareRoot(6); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void SquareRootDouble() { TestSquareRoot(15); } private void TestSquareRoot(int precision = -1) where T : struct, INumber, IEquatable { @@ -2814,10 +2779,8 @@ public void FloorDouble() [Fact] public void AbsInt64() { TestAbs(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void AbsSingle() { TestAbs(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void AbsDouble() { TestAbs(); } private void TestAbs() where T : struct, INumber { @@ -2854,10 +2817,8 @@ private void TestAbs() where T : struct, INumber [Fact] public void MultiplicationReflectionInt64() { TestMultiplicationReflection(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void MultiplicationReflectionSingle() { TestMultiplicationReflection(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void MultiplicationReflectionDouble() { TestMultiplicationReflection(); } private void TestMultiplicationReflection() where T : struct, INumber { @@ -2893,10 +2854,8 @@ private void TestMultiplicationReflection() where T : struct, INumber [Fact] public void AdditionReflectionInt64() { TestAdditionReflection(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void AdditionReflectionSingle() { TestAdditionReflection(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void AdditionReflectionDouble() { TestAdditionReflection(); } private void TestAdditionReflection() where T : struct, INumber { @@ -2932,10 +2891,8 @@ private void TestAdditionReflection() where T : struct, INumber [Fact] public void DivisionReflectionInt64() { TestDivisionReflection(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void DivisionReflectionSingle() { TestDivisionReflection(); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/60347", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsX86Process))] public void DivisionReflectionDouble() { TestDivisionReflection(); } private void TestDivisionReflection() where T : struct, INumber { diff --git a/src/libraries/System.ObjectModel/System.ObjectModel.sln b/src/libraries/System.ObjectModel/System.ObjectModel.sln index 1576c836f68..b4414fcbaf6 100644 --- a/src/libraries/System.ObjectModel/System.ObjectModel.sln +++ b/src/libraries/System.ObjectModel/System.ObjectModel.sln @@ -9,7 +9,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ObjectModel", "src\S EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ObjectModel.Tests", "tests\System.ObjectModel.Tests.csproj", "{9DB5C0B8-959E-4B0A-99A6-88452FD3C10C}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{A42FE6C9-59F1-43E7-AD34-802F13254284}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{C04DBAFC-0FC2-4483-B4D5-DE94EC737938}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{A62E47A3-C3A7-421A-B3E6-2DD578A50781}" EndProject @@ -67,10 +67,10 @@ Global {9DB5C0B8-959E-4B0A-99A6-88452FD3C10C}.Debug|Any CPU.Build.0 = Debug|Any CPU {9DB5C0B8-959E-4B0A-99A6-88452FD3C10C}.Release|Any CPU.ActiveCfg = Release|Any CPU {9DB5C0B8-959E-4B0A-99A6-88452FD3C10C}.Release|Any CPU.Build.0 = Release|Any CPU - {A42FE6C9-59F1-43E7-AD34-802F13254284}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {A42FE6C9-59F1-43E7-AD34-802F13254284}.Debug|Any CPU.Build.0 = Debug|Any CPU - {A42FE6C9-59F1-43E7-AD34-802F13254284}.Release|Any CPU.ActiveCfg = Release|Any CPU - {A42FE6C9-59F1-43E7-AD34-802F13254284}.Release|Any CPU.Build.0 = Release|Any CPU + {C04DBAFC-0FC2-4483-B4D5-DE94EC737938}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {C04DBAFC-0FC2-4483-B4D5-DE94EC737938}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C04DBAFC-0FC2-4483-B4D5-DE94EC737938}.Release|Any CPU.ActiveCfg = Release|Any CPU + {C04DBAFC-0FC2-4483-B4D5-DE94EC737938}.Release|Any CPU.Build.0 = Release|Any CPU {A62E47A3-C3A7-421A-B3E6-2DD578A50781}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {A62E47A3-C3A7-421A-B3E6-2DD578A50781}.Debug|Any CPU.Build.0 = Debug|Any CPU {A62E47A3-C3A7-421A-B3E6-2DD578A50781}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -110,7 +110,7 @@ Global {E13B9A3B-BA99-4FA3-9959-B95E14DCB9BC} = {2E5C2B29-721D-4DDF-985F-81CA593E4F42} {5BC772EA-32FF-4918-844E-CC61F30042EE} = {2E5C2B29-721D-4DDF-985F-81CA593E4F42} {583024EB-8FC7-45E3-9C37-85BE43FBD28A} = {35DDEBAA-829C-43C1-BB49-29A11589D22D} - {A42FE6C9-59F1-43E7-AD34-802F13254284} = {0534B176-48FC-4F4D-9D44-ADD06237B038} + {C04DBAFC-0FC2-4483-B4D5-DE94EC737938} = {0534B176-48FC-4F4D-9D44-ADD06237B038} {A62E47A3-C3A7-421A-B3E6-2DD578A50781} = {0534B176-48FC-4F4D-9D44-ADD06237B038} {D4EF791E-CB42-486C-846B-8943EF22F2B4} = {8279B20A-0105-4A9F-8CFE-02666847838C} {70E2D108-F236-4419-AE0F-DAFF44CB455A} = {8279B20A-0105-4A9F-8CFE-02666847838C} diff --git a/src/libraries/System.ObjectModel/tests/System.ObjectModel.Tests.csproj b/src/libraries/System.ObjectModel/tests/System.ObjectModel.Tests.csproj index f015015de4d..617a923fbde 100644 --- a/src/libraries/System.ObjectModel/tests/System.ObjectModel.Tests.csproj +++ b/src/libraries/System.ObjectModel/tests/System.ObjectModel.Tests.csproj @@ -42,5 +42,10 @@ + + + diff --git a/src/libraries/System.ObjectModel/tests/TrimmingTests/System.ObjectModel.TrimmingTests.proj b/src/libraries/System.ObjectModel/tests/TrimmingTests/System.ObjectModel.TrimmingTests.proj index da4a46f2ae1..2218182b4ab 100644 --- a/src/libraries/System.ObjectModel/tests/TrimmingTests/System.ObjectModel.TrimmingTests.proj +++ b/src/libraries/System.ObjectModel/tests/TrimmingTests/System.ObjectModel.TrimmingTests.proj @@ -1,5 +1,15 @@ + + + _DefaultValueAttributeSupport + + + _DefaultValueAttributeSupport + + + + diff --git a/src/libraries/System.Private.CoreLib/src/CompatibilitySuppressions.xml b/src/libraries/System.Private.CoreLib/src/CompatibilitySuppressions.xml index 6ee3efba01f..413297c1857 100644 --- a/src/libraries/System.Private.CoreLib/src/CompatibilitySuppressions.xml +++ b/src/libraries/System.Private.CoreLib/src/CompatibilitySuppressions.xml @@ -5,10 +5,6 @@ CP0001 T:Internal.Console - - CP0001 - T:System.Runtime.CompilerServices.ICastable - CP0002 F:System.Resources.ResourceManager.BaseNameField diff --git a/src/libraries/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.OSX.xml b/src/libraries/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.OSX.xml deleted file mode 100644 index 3b747687397..00000000000 --- a/src/libraries/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.OSX.xml +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/src/libraries/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.Shared.xml b/src/libraries/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.Shared.xml index 465c0d5f87b..1dfb1d930c5 100644 --- a/src/libraries/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.Shared.xml +++ b/src/libraries/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.Shared.xml @@ -1,15 +1,11 @@ - - - - @@ -20,27 +16,11 @@ - - - - - - - - - - - - - - - - diff --git a/src/libraries/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.Windows.xml b/src/libraries/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.Windows.xml deleted file mode 100644 index 29c26957ff6..00000000000 --- a/src/libraries/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.Windows.xml +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - - - diff --git a/src/libraries/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs b/src/libraries/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs new file mode 100644 index 00000000000..a10e8c0cb2f --- /dev/null +++ b/src/libraries/System.Private.CoreLib/src/Internal/Runtime/CompilerHelpers/ThrowHelpers.cs @@ -0,0 +1,100 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +namespace Internal.Runtime.CompilerHelpers +{ + [StackTraceHidden] + [DebuggerStepThrough] + internal static unsafe partial class ThrowHelpers + { + [DoesNotReturn] + [DebuggerHidden] + internal static void ThrowNullReferenceException() + { + throw new NullReferenceException(); + } + + [DoesNotReturn] + [DebuggerHidden] + internal static void ThrowArgumentException() + { + throw new ArgumentException(); + } + + [DoesNotReturn] + [DebuggerHidden] + internal static void ThrowArgumentOutOfRangeException() + { + throw new ArgumentOutOfRangeException(); + } + + [DoesNotReturn] + [DebuggerHidden] + internal static void ThrowDivideByZeroException() + { + throw new DivideByZeroException(); + } + + [DoesNotReturn] + [DebuggerHidden] + internal static void ThrowIndexOutOfRangeException() + { + throw new IndexOutOfRangeException(); + } + + [DoesNotReturn] + [DebuggerHidden] + internal static void ThrowOverflowException() + { + throw new OverflowException(); + } + + [DoesNotReturn] + [DebuggerHidden] + internal static void ThrowPlatformNotSupportedException() + { + throw new PlatformNotSupportedException(); + } + + [DoesNotReturn] + [DebuggerHidden] + internal static void ThrowNotImplementedException() + { + throw new NotImplementedException(); + } + + [DoesNotReturn] + [DebuggerHidden] + internal static void ThrowArrayTypeMismatchException() + { + throw new ArrayTypeMismatchException(); + } + + [DoesNotReturn] + [DebuggerHidden] + internal static void ThrowNotSupportedException() + { + throw new NotSupportedException(); + } + + [DoesNotReturn] + [DebuggerHidden] + internal static void ThrowTypeNotSupportedException() + { + throw new NotSupportedException(SR.Arg_TypeNotSupported); + } + + [DoesNotReturn] + [DebuggerHidden] + internal static void ThrowVerificationException(int ilOffset) + { + throw new System.Security.VerificationException(); + } + } +} diff --git a/src/libraries/System.Private.CoreLib/src/Internal/Runtime/InteropServices/ComponentActivator.cs b/src/libraries/System.Private.CoreLib/src/Internal/Runtime/InteropServices/ComponentActivator.cs index 0fef70a8c2a..dee00844a55 100644 --- a/src/libraries/System.Private.CoreLib/src/Internal/Runtime/InteropServices/ComponentActivator.cs +++ b/src/libraries/System.Private.CoreLib/src/Internal/Runtime/InteropServices/ComponentActivator.cs @@ -29,6 +29,7 @@ internal static partial class ComponentActivator // To indicate the specific error when IsSupported is false private const int HostFeatureDisabled = unchecked((int)0x800080a7); + [FeatureSwitchDefinition("System.Runtime.InteropServices.EnableConsumingManagedCodeFromNativeHosting")] private static bool IsSupported { get; } = InitializeIsSupported(); private static bool InitializeIsSupported() => AppContext.TryGetSwitch("System.Runtime.InteropServices.EnableConsumingManagedCodeFromNativeHosting", out bool isSupported) ? isSupported : true; @@ -66,6 +67,9 @@ public static unsafe int LoadAssemblyAndGetFunctionPointer(IntPtr assemblyPathNa IntPtr reserved, IntPtr functionHandle) { + if (functionHandle != IntPtr.Zero) + *(IntPtr*)functionHandle = 0; + if (!IsSupported) return HostFeatureDisabled; @@ -228,6 +232,9 @@ public static unsafe int GetFunctionPointer(IntPtr typeNameNative, IntPtr reserved, IntPtr functionHandle) { + if (functionHandle != IntPtr.Zero) + *(IntPtr*)functionHandle = 0; + if (!IsSupported) { #if CORECLR diff --git a/src/libraries/System.Private.CoreLib/src/Microsoft/Win32/SafeHandles/SafeFileHandle.Unix.cs b/src/libraries/System.Private.CoreLib/src/Microsoft/Win32/SafeHandles/SafeFileHandle.Unix.cs index 4029e70cef2..476af77370b 100644 --- a/src/libraries/System.Private.CoreLib/src/Microsoft/Win32/SafeHandles/SafeFileHandle.Unix.cs +++ b/src/libraries/System.Private.CoreLib/src/Microsoft/Win32/SafeHandles/SafeFileHandle.Unix.cs @@ -34,7 +34,7 @@ public sealed partial class SafeFileHandle : SafeHandleZeroOrMinusOneIsInvalid UnixFileMode.OtherRead | UnixFileMode.OtherWrite; - internal static bool DisableFileLocking { get; } = OperatingSystem.IsBrowser() // #40065: Emscripten does not support file locking + internal static bool DisableFileLocking { get; } = OperatingSystem.IsBrowser() || OperatingSystem.IsWasi()// #40065: Emscripten does not support file locking || AppContextConfigHelper.GetBooleanConfig("System.IO.DisableFileLocking", "DOTNET_SYSTEM_IO_DISABLEFILELOCKING", defaultValue: false); // not using bool? as it's not thread safe diff --git a/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx b/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx index 413995326c9..379251af33c 100644 --- a/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx +++ b/src/libraries/System.Private.CoreLib/src/Resources/Strings.resx @@ -4340,4 +4340,19 @@ Only array or span of primitive or enum types can be initialized from static data. + + CriticalHandle derived types cannot be stored in Variants. + + + SafeHandle derived types cannot be stored in Variants. + + + Method's type signature is not Interop compatible. + + + The method returned a COM Variant type that is not Interop compatible. + + + VariantWrappers cannot be stored in Variants. + diff --git a/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems b/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems index f266e5e6155..f2923753ea2 100644 --- a/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems +++ b/src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems @@ -22,6 +22,7 @@ true true true + true $(DefineConstants);BIGENDIAN @@ -58,9 +59,7 @@ - - @@ -71,6 +70,7 @@ + @@ -854,7 +854,6 @@ - @@ -2098,9 +2097,6 @@ Common\Interop\Windows\OleAut32\Interop.SysFreeString.cs - - Common\Interop\Windows\OleAut32\Interop.VariantChangeTypeEx.cs - Common\Interop\Windows\Ole32\Interop.CLSIDFromProgID.cs @@ -2803,8 +2799,8 @@ - - - + + + \ No newline at end of file diff --git a/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Base64Url/Base64UrlValidator.cs b/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Base64Url/Base64UrlValidator.cs index bc95ab0f054..3cd8bf5c679 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Base64Url/Base64UrlValidator.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Base64Url/Base64UrlValidator.cs @@ -1,8 +1,8 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System.Diagnostics; using System.Runtime.CompilerServices; -using static System.Buffers.Text.Base64Helper; namespace System.Buffers.Text { @@ -94,33 +94,33 @@ public bool ValidateAndDecodeLength(char lastChar, int length, int paddingCount, [MethodImpl(MethodImplOptions.AggressiveInlining)] public bool ValidateAndDecodeLength(byte lastChar, int length, int paddingCount, out int decodedLength) { - // Padding is optional for Base64Url, so need to account remainder. If remainder is 1, then it's invalid. -#if NET - (uint whole, uint remainder) = uint.DivRem((uint)(length), 4); - if (remainder == 1 || (remainder > 1 && (remainder - paddingCount == 1 || paddingCount == remainder))) - { - decodedLength = 0; - return false; - } - - decodedLength = (int)((whole * 3) + (remainder > 0 ? remainder - 1 : 0) - paddingCount); -#else + // Padding is optional for Base64Url, so need to account remainder. int remainder = (int)((uint)length % 4); - if (remainder == 1 || (remainder > 1 && (remainder - paddingCount == 1 || paddingCount == remainder))) + + if (paddingCount != 0) { - decodedLength = 0; - return false; + length -= paddingCount; + remainder = (int)((uint)length % 4); + + // if there is a padding, there should be remainder and the sum of remainder and padding should not exceed 4 + if (remainder == 0 || remainder + paddingCount > 4) + { + decodedLength = 0; + return false; + } } - decodedLength = (length >> 2) * 3 + (remainder > 0 ? remainder - 1 : 0) - paddingCount; -#endif - int decoded = default(Base64DecoderByte).DecodingMap[lastChar]; - if (((remainder == 3 || paddingCount == 1) && (decoded & 0x03) != 0) || - ((remainder == 2 || paddingCount == 2) && (decoded & 0x0F) != 0)) + decodedLength = (length >> 2) * 3 + (remainder > 0 ? remainder - 1 : 0); + + if (remainder > 0) { - // unused lower bits are not 0, reject input - decodedLength = 0; - return false; + int decoded = default(Base64UrlDecoderByte).DecodingMap[lastChar]; + switch (remainder) + { + case 1: return false; // 1 byte is not decodable => invalid. + case 2: return ((decoded & 0x0F) == 0); // if unused lower 4 bits are set to 0 + case 3: return ((decoded & 0x03) == 0); // if unused lower 2 bits are set to 0 + } } return true; diff --git a/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Utf8Parser/Utf8Parser.Boolean.cs b/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Utf8Parser/Utf8Parser.Boolean.cs index b19cee4e43e..da378c06b7d 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Utf8Parser/Utf8Parser.Boolean.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Buffers/Text/Utf8Parser/Utf8Parser.Boolean.cs @@ -12,16 +12,14 @@ public static partial class Utf8Parser /// /// The Utf8 string to parse /// Receives the parsed value - /// On a successful parse, receives the length in bytes of the substring that was parsed - /// Expected format of the Utf8 string + /// On a successful parse, receives the length in bytes of the substring that was parsed. + /// Expected format of the Utf8 string. Supported formats are 'G', 'l', and default. /// /// true for success. "bytesConsumed" contains the length in bytes of the substring that was parsed. /// false if the string was not syntactically valid or an overflow or underflow occurred. "bytesConsumed" is set to 0. /// /// - /// Formats supported: - /// G (default) True/False - /// l true/false + /// The parsing is case insensitive. The format parameter is validated to ensure it is supported; however, all supported formats are treated identically. /// /// /// System.FormatException if the format is not valid for this data type. diff --git a/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/Dictionary.cs b/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/Dictionary.cs index c7c17490268..c890bbed83c 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/Dictionary.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/Dictionary.cs @@ -745,6 +745,7 @@ internal static IAlternateEqualityComparer GetAlternateComp /// When this method returns, contains the value associated with the specified key, if the key is found; /// otherwise, the default value for the type of the value parameter. /// + /// if an entry was found; otherwise, . /// is . public bool TryGetValue(TAlternateKey key, [MaybeNullWhen(false)] out TValue value) { @@ -769,6 +770,7 @@ public bool TryGetValue(TAlternateKey key, [MaybeNullWhen(false)] out TValue val /// When this method returns, contains the value associated with the specified key, if the key is found; /// otherwise, the default value for the type of the value parameter. /// + /// if an entry was found; otherwise, . /// is . public bool TryGetValue(TAlternateKey key, [MaybeNullWhen(false)] out TKey actualKey, [MaybeNullWhen(false)] out TValue value) { diff --git a/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/HashSet.cs b/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/HashSet.cs index 621af08d72a..f39fe93b134 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/HashSet.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/HashSet.cs @@ -69,7 +69,7 @@ public HashSet(IEqualityComparer? comparer) // We use a non-randomized comparer for improved perf, falling back to a randomized comparer if the // hash buckets become unbalanced. if (typeof(T) == typeof(string) && - NonRandomizedStringEqualityComparer.GetStringComparer(_comparer!) is IEqualityComparer stringComparer) + NonRandomizedStringEqualityComparer.GetStringComparer(_comparer) is IEqualityComparer stringComparer) { _comparer = (IEqualityComparer)stringComparer; } @@ -92,7 +92,7 @@ public HashSet(IEnumerable collection, IEqualityComparer? comparer) : this ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection); } - if (collection is HashSet otherAsHashSet && EqualityComparersAreEqual(this, otherAsHashSet)) + if (collection is HashSet otherAsHashSet && EffectiveEqualityComparersAreEqual(this, otherAsHashSet)) { ConstructFrom(otherAsHashSet); } @@ -145,6 +145,8 @@ protected HashSet(SerializationInfo info, StreamingContext context) /// Initializes the HashSet from another HashSet with the same element type and equality comparer. private void ConstructFrom(HashSet source) { + Debug.Assert(EffectiveEqualityComparersAreEqual(this, source), "must use identical effective comparers."); + if (source.Count == 0) { // As well as short-circuiting on the rest of the work done, @@ -1250,6 +1252,11 @@ public IEqualityComparer Comparer } } + /// + /// Similar to but surfaces the actual comparer being used to hash entries. + /// + internal IEqualityComparer EffectiveComparer => _comparer ?? EqualityComparer.Default; + /// Ensures that this hash set can hold the specified number of elements without growing. public int EnsureCapacity(int capacity) { @@ -1768,7 +1775,13 @@ private unsafe void SymmetricExceptWithEnumerable(IEnumerable other) /// internal static bool EqualityComparersAreEqual(HashSet set1, HashSet set2) => set1.Comparer.Equals(set2.Comparer); -#endregion + /// + /// Checks if effective equality comparers are equal. This is used for algorithms that + /// require that both collections use identical hashing implementations for their entries. + /// + internal static bool EffectiveEqualityComparersAreEqual(HashSet set1, HashSet set2) => set1.EffectiveComparer.Equals(set2.EffectiveComparer); + + #endregion private struct Entry { diff --git a/src/libraries/System.Private.CoreLib/src/System/Convert.cs b/src/libraries/System.Private.CoreLib/src/System/Convert.cs index a0c74422853..8bf81152991 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Convert.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Convert.cs @@ -2999,7 +2999,7 @@ public static OperationStatus FromHexString(ReadOnlySpan source, Span source, Span /// Initializes a new instance of the class, specifying the ID that the compiler will use diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/StackTrace.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/StackTrace.cs index 7fdfef8f6d3..8bf344f4e73 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/StackTrace.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/StackTrace.cs @@ -17,6 +17,7 @@ namespace System.Diagnostics /// public partial class StackTrace { + [FeatureSwitchDefinition("System.Diagnostics.StackTrace.IsSupported")] internal static bool IsSupported { get; } = InitializeIsSupported(); private static bool InitializeIsSupported() => diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventSource.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventSource.cs index 3edb4ad9d54..0b727874ddc 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventSource.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/EventSource.cs @@ -224,12 +224,77 @@ internal sealed class EventSourceAutoGenerateAttribute : Attribute [DynamicallyAccessedMembers(ManifestMemberTypes)] public partial class EventSource : IDisposable { + // private instance state + private string m_name = null!; // My friendly name (privided in ctor) + internal int m_id; // A small integer that is unique to this instance. + private Guid m_guid; // GUID representing the ETW eventSource to the OS. + internal volatile EventMetadata[]? m_eventData; // None per-event data + private volatile byte[]? m_rawManifest; // Bytes to send out representing the event schema + + private EventHandler? m_eventCommandExecuted; + + private readonly EventSourceSettings m_config; // configuration information + + private bool m_eventSourceDisposed; // has Dispose been called. + + // Enabling bits + private bool m_eventSourceEnabled; // am I enabled (any of my events are enabled for any dispatcher) + internal EventLevel m_level; // highest level enabled by any output dispatcher + internal EventKeywords m_matchAnyKeyword; // the logical OR of all levels enabled by any output dispatcher (zero is a special case) meaning 'all keywords' + + // Dispatching state + internal volatile EventDispatcher? m_Dispatchers; // Linked list of code:EventDispatchers we write the data to (we also do ETW specially) + private volatile OverrideEventProvider m_etwProvider = null!; // This hooks up ETW commands to our 'OnEventCommand' callback +#if FEATURE_PERFTRACING + private object? m_createEventLock; + private IntPtr m_writeEventStringEventHandle = IntPtr.Zero; + private volatile OverrideEventProvider m_eventPipeProvider = null!; +#endif + private bool m_completelyInited; // The EventSource constructor has returned without exception. + private Exception? m_constructionException; // If there was an exception construction, this is it + private byte m_outOfBandMessageCount; // The number of out of band messages sent (we throttle them + private EventCommandEventArgs? m_deferredCommands; // If we get commands before we are fully we store them here and run the when we are fully inited. + + private string[]? m_traits; // Used to implement GetTraits + + [ThreadStatic] + private static byte m_EventSourceExceptionRecurenceCount; // current recursion count inside ThrowEventSourceException + internal volatile ulong[]? m_channelData; + + // We use a single instance of ActivityTracker for all EventSources instances to allow correlation between multiple event providers. + // We have m_activityTracker field simply because instance field is more efficient than static field fetch. + private ActivityTracker m_activityTracker = null!; + internal const string ActivityStartSuffix = "Start"; + internal const string ActivityStopSuffix = "Stop"; + + // This switch controls an opt-in, off-by-default mechanism for allowing multiple EventSources to have the same + // name and by extension GUID. This is not considered a mainline scenario and is explicitly intended as a release + // valve for users that make heavy use of AssemblyLoadContext and experience exceptions from EventSource. + // This does not solve any issues that might arise from this configuration. For instance: + // + // * If multiple manifest-mode EventSources have the same name/GUID, it is ambiguous which manifest should be used by an ETW parser. + // This can result in events being incorrectly parse. The data will still be there, but EventTrace (or other libraries) won't + // know how to parse it. + // * Potential issues in parsing self-describing EventSources that use the same name/GUID, event name, and payload type from the same AssemblyLoadContext + // but have different event IDs set. + // + // Most users should not turn this on. + internal const string DuplicateSourceNamesSwitch = "System.Diagnostics.Tracing.EventSource.AllowDuplicateSourceNames"; + private static readonly bool AllowDuplicateSourceNames = AppContext.TryGetSwitch(DuplicateSourceNamesSwitch, out bool isEnabled) ? isEnabled : false; + + [FeatureSwitchDefinition("System.Diagnostics.Tracing.EventSource.IsSupported")] internal static bool IsSupported { get; } = InitializeIsSupported(); private static bool InitializeIsSupported() => AppContext.TryGetSwitch("System.Diagnostics.Tracing.EventSource.IsSupported", out bool isSupported) ? isSupported : true; + [FeatureSwitchDefinition("System.Diagnostics.Metrics.Meter.IsSupported")] + internal static bool IsMeterSupported { get; } = InitializeIsMeterSupported(); + + private static bool InitializeIsMeterSupported() => + AppContext.TryGetSwitch("System.Diagnostics.Metrics.Meter.IsSupported", out bool isSupported) ? isSupported : true; + #if FEATURE_EVENTSOURCE_XPLAT #pragma warning disable CA1823 // field is used to keep listener alive private static readonly EventListener? persistent_Xplat_Listener = IsSupported ? XplatEventLogger.InitializePersistentListener() : null; @@ -1603,7 +1668,7 @@ private unsafe void Initialize(Guid eventSourceGuid, string eventSourceName, str // Register the provider with ETW Func eventSourceFactory = () => this; - OverrideEventProvider? etwProvider = TryGetPreregisteredEtwProvider(eventSourceGuid); + OverrideEventProvider? etwProvider = EventSourceInitHelper.TryGetPreregisteredEtwProvider(eventSourceGuid); if(etwProvider == null) { etwProvider = new OverrideEventProvider(eventSourceFactory, EventProviderType.ETW); @@ -1627,7 +1692,7 @@ private unsafe void Initialize(Guid eventSourceGuid, string eventSourceName, str #if FEATURE_PERFTRACING // Register the provider with EventPipe - OverrideEventProvider? eventPipeProvider = TryGetPreregisteredEventPipeProvider(eventSourceName); + OverrideEventProvider? eventPipeProvider = EventSourceInitHelper.TryGetPreregisteredEventPipeProvider(eventSourceName); if (eventPipeProvider == null) { eventPipeProvider = new OverrideEventProvider(eventSourceFactory, EventProviderType.EventPipe); @@ -2402,7 +2467,7 @@ internal static EventOpcode GetOpcodeWithDefault(EventOpcode opcode, string? eve /// /// This class lets us hook the 'OnEventCommand' from the eventSource. /// - private sealed class OverrideEventProvider : EventProvider + internal sealed class OverrideEventProvider : EventProvider { public OverrideEventProvider(Func eventSourceFactory, EventProviderType providerType) : base(providerType) @@ -3831,15 +3896,28 @@ internal static void InitializeDefaultEventSources() // Functionally we could preregister NativeRuntimeEventSource and RuntimeEventSource as well, but it may not provide // much benefit. The main benefit for MetricsEventSource is that the app may never use it and it defers // pulling the System.Diagnostics.DiagnosticSource assembly into the process until it is needed. - if (AppContext.TryGetSwitch("System.Diagnostics.Metrics.Meter.IsSupported", out bool isSupported) ? isSupported : true) + if (IsMeterSupported) { const string name = "System.Diagnostics.Metrics"; Guid id = new Guid("20752bc4-c151-50f5-f27b-df92d8af5a61"); - PreregisterEventProviders(id, name, GetMetricsEventSource); + EventSourceInitHelper.PreregisterEventProviders(id, name, EventSourceInitHelper.GetMetricsEventSource); } } +#endregion + } + + // This type is logically just more static EventSource functionality but it needs to be a separate class + // to ensure that the IL linker can remove unused methods in it. Methods defined within the EventSource type + // are never removed because EventSource has the potential to reflect over its own members. + internal static class EventSourceInitHelper + { + private static List> s_preregisteredEventSourceFactories = new List>(); + private static readonly Dictionary s_preregisteredEtwProviders = new Dictionary(); +#if FEATURE_PERFTRACING + private static readonly Dictionary s_preregisteredEventPipeProviders = new Dictionary(); +#endif - private static EventSource? GetMetricsEventSource() + internal static EventSource? GetMetricsEventSource() { Type? metricsEventSourceType = Type.GetType( "System.Diagnostics.Metrics.MetricsEventSource, System.Diagnostics.DiagnosticSource", @@ -3859,7 +3937,7 @@ internal static void InitializeDefaultEventSources() // Pre-registration creates and registers an EventProvider prior to the EventSource being constructed. // If a tracing session is started using the provider then the EventSource will be constructed on demand. - private static unsafe void PreregisterEventProviders(Guid id, string name, Func eventSourceFactory) + internal static unsafe void PreregisterEventProviders(Guid id, string name, Func eventSourceFactory) { // NOTE: Pre-registration has some minor limitations and variations to normal EventSource behavior: // 1. Instead of delivering OnEventCommand callbacks during the EventSource constructor it may deliver them after @@ -3877,7 +3955,7 @@ private static unsafe void PreregisterEventProviders(Guid id, string name, Func< { s_preregisteredEventSourceFactories.Add(eventSourceFactory); - OverrideEventProvider etwProvider = new OverrideEventProvider(eventSourceFactory, EventProviderType.ETW); + EventSource.OverrideEventProvider etwProvider = new EventSource.OverrideEventProvider(eventSourceFactory, EventProviderType.ETW); etwProvider.Register(id, name); #if TARGET_WINDOWS byte[] providerMetadata = Statics.MetadataForString(name, 0, 0, 0); @@ -3895,7 +3973,7 @@ private static unsafe void PreregisterEventProviders(Guid id, string name, Func< } #if FEATURE_PERFTRACING - OverrideEventProvider eventPipeProvider = new OverrideEventProvider(eventSourceFactory, EventProviderType.EventPipe); + EventSource.OverrideEventProvider eventPipeProvider = new EventSource.OverrideEventProvider(eventSourceFactory, EventProviderType.EventPipe); eventPipeProvider.Register(id, name); lock (s_preregisteredEventPipeProviders) { @@ -3923,7 +4001,7 @@ internal static void EnsurePreregisteredEventSourcesExist() // the list as long as we still guarantee they get initialized in the near future and reported to the // same EventListener.OnEventSourceCreated() callback. Func[] factories; - lock(s_preregisteredEventSourceFactories) + lock (s_preregisteredEventSourceFactories) { factories = s_preregisteredEventSourceFactories.ToArray(); s_preregisteredEventSourceFactories.Clear(); @@ -3934,92 +4012,25 @@ internal static void EnsurePreregisteredEventSourcesExist() } } - private static List> s_preregisteredEventSourceFactories = new List>(); - - private static OverrideEventProvider? TryGetPreregisteredEtwProvider(Guid id) + internal static EventSource.OverrideEventProvider? TryGetPreregisteredEtwProvider(Guid id) { lock (s_preregisteredEtwProviders) { - s_preregisteredEtwProviders.Remove(id, out OverrideEventProvider? provider); + s_preregisteredEtwProviders.Remove(id, out EventSource.OverrideEventProvider? provider); return provider; } } - private static readonly Dictionary s_preregisteredEtwProviders = new Dictionary(); - #if FEATURE_PERFTRACING - private static OverrideEventProvider? TryGetPreregisteredEventPipeProvider(string name) + internal static EventSource.OverrideEventProvider? TryGetPreregisteredEventPipeProvider(string name) { lock (s_preregisteredEventPipeProviders) { - s_preregisteredEventPipeProviders.Remove(name, out OverrideEventProvider? provider); + s_preregisteredEventPipeProviders.Remove(name, out EventSource.OverrideEventProvider? provider); return provider; } } - - private static readonly Dictionary s_preregisteredEventPipeProviders = new Dictionary(); #endif - - // private instance state - private string m_name = null!; // My friendly name (privided in ctor) - internal int m_id; // A small integer that is unique to this instance. - private Guid m_guid; // GUID representing the ETW eventSource to the OS. - internal volatile EventMetadata[]? m_eventData; // None per-event data - private volatile byte[]? m_rawManifest; // Bytes to send out representing the event schema - - private EventHandler? m_eventCommandExecuted; - - private readonly EventSourceSettings m_config; // configuration information - - private bool m_eventSourceDisposed; // has Dispose been called. - - // Enabling bits - private bool m_eventSourceEnabled; // am I enabled (any of my events are enabled for any dispatcher) - internal EventLevel m_level; // highest level enabled by any output dispatcher - internal EventKeywords m_matchAnyKeyword; // the logical OR of all levels enabled by any output dispatcher (zero is a special case) meaning 'all keywords' - - // Dispatching state - internal volatile EventDispatcher? m_Dispatchers; // Linked list of code:EventDispatchers we write the data to (we also do ETW specially) - private volatile OverrideEventProvider m_etwProvider = null!; // This hooks up ETW commands to our 'OnEventCommand' callback -#if FEATURE_PERFTRACING - private object? m_createEventLock; - private IntPtr m_writeEventStringEventHandle = IntPtr.Zero; - private volatile OverrideEventProvider m_eventPipeProvider = null!; -#endif - private bool m_completelyInited; // The EventSource constructor has returned without exception. - private Exception? m_constructionException; // If there was an exception construction, this is it - private byte m_outOfBandMessageCount; // The number of out of band messages sent (we throttle them - private EventCommandEventArgs? m_deferredCommands; // If we get commands before we are fully we store them here and run the when we are fully inited. - - private string[]? m_traits; // Used to implement GetTraits - - [ThreadStatic] - private static byte m_EventSourceExceptionRecurenceCount; // current recursion count inside ThrowEventSourceException - - internal volatile ulong[]? m_channelData; - - // We use a single instance of ActivityTracker for all EventSources instances to allow correlation between multiple event providers. - // We have m_activityTracker field simply because instance field is more efficient than static field fetch. - private ActivityTracker m_activityTracker = null!; - internal const string ActivityStartSuffix = "Start"; - internal const string ActivityStopSuffix = "Stop"; - - // This switch controls an opt-in, off-by-default mechanism for allowing multiple EventSources to have the same - // name and by extension GUID. This is not considered a mainline scenario and is explicitly intended as a release - // valve for users that make heavy use of AssemblyLoadContext and experience exceptions from EventSource. - // This does not solve any issues that might arise from this configuration. For instance: - // - // * If multiple manifest-mode EventSources have the same name/GUID, it is ambiguous which manifest should be used by an ETW parser. - // This can result in events being incorrectly parse. The data will still be there, but EventTrace (or other libraries) won't - // know how to parse it. - // * Potential issues in parsing self-describing EventSources that use the same name/GUID, event name, and payload type from the same AssemblyLoadContext - // but have different event IDs set. - // - // Most users should not turn this on. - internal const string DuplicateSourceNamesSwitch = "System.Diagnostics.Tracing.EventSource.AllowDuplicateSourceNames"; - private static readonly bool AllowDuplicateSourceNames = AppContext.TryGetSwitch(DuplicateSourceNamesSwitch, out bool isEnabled) ? isEnabled : false; - -#endregion } /// @@ -4580,7 +4591,7 @@ private void CallBackForExistingEventSources(bool addToListenersList, EventHandl { // Pre-registered EventSources may not have been constructed yet but we need to do so now to ensure they are // reported to the EventListener. - EventSource.EnsurePreregisteredEventSourcesExist(); + EventSourceInitHelper.EnsurePreregisteredEventSourcesExist(); lock (EventListenersLock) { diff --git a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Internal.cs b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Internal.cs index 7e9368dd3e9..660d65b367e 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Internal.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Diagnostics/Tracing/NativeRuntimeEventSource.Threading.NativeSinks.Internal.cs @@ -10,17 +10,6 @@ namespace System.Diagnostics.Tracing // It contains the runtime specific interop to native event sinks. internal sealed partial class NativeRuntimeEventSource : EventSource { -#if NATIVEAOT - // We don't have these keywords defined from the genRuntimeEventSources.py, so we need to manually define them here. - public static partial class Keywords - { - public const EventKeywords ContentionKeyword = (EventKeywords)0x4000; - public const EventKeywords ThreadingKeyword = (EventKeywords)0x10000; - public const EventKeywords ThreadTransferKeyword = (EventKeywords)0x80000000; - public const EventKeywords WaitHandleKeyword = (EventKeywords)0x40000000000; - } -#endif - [NonEvent] [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "NativeRuntimeEventSource_LogContentionLockCreated")] private static partial void LogContentionLockCreated(nint LockID, nint AssociatedObjectID, ushort ClrInstanceID); diff --git a/src/libraries/System.Private.CoreLib/src/System/Enum.cs b/src/libraries/System.Private.CoreLib/src/System/Enum.cs index 052b4b22c89..f559948df33 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Enum.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Enum.cs @@ -2214,8 +2214,8 @@ public static object ToObject(Type enumType, object value) valueType = valueType.GetEnumUnderlyingType(); } - if (valueType == typeof(nint)) ToObject(enumType, (nint)value); - if (valueType == typeof(nuint)) ToObject(enumType, (nuint)value); + if (valueType == typeof(nint)) return ToObject(enumType, (nint)value); + if (valueType == typeof(nuint)) return ToObject(enumType, (nuint)value); throw new ArgumentException(SR.Arg_MustBeEnumBaseTypeOrEnum, nameof(value)); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Environment.SunOS.cs b/src/libraries/System.Private.CoreLib/src/System/Environment.SunOS.cs index 84199a3d306..fb7ff75cb2e 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Environment.SunOS.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Environment.SunOS.cs @@ -8,6 +8,6 @@ namespace System public static partial class Environment { public static long WorkingSet => - (long)(Interop.procfs.TryReadProcessStatusInfo(Interop.procfs.ProcPid.Self, out Interop.procfs.ProcessStatusInfo status) ? status.ResidentSetSize : 0); + (long)(Interop.procfs.TryReadProcessStatusInfo(ProcessId, out Interop.procfs.ProcessStatusInfo status) ? status.ResidentSetSize : 0); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Globalization/ChineseLunisolarCalendar.cs b/src/libraries/System.Private.CoreLib/src/System/Globalization/ChineseLunisolarCalendar.cs index 91a1c422a55..b0bfe21ca00 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Globalization/ChineseLunisolarCalendar.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Globalization/ChineseLunisolarCalendar.cs @@ -195,7 +195,7 @@ public class ChineseLunisolarCalendar : EastAsianLunisolarCalendar 2054 */ { 00, 02, 08, 0b0110010010110000 }, /* 29 30 30 29 29 30 29 29 30 29 30 30 354 2055 */ { 06, 01, 28, 0b0110101001010000 }, /* 29 30 30 29 30 29 30 29 29 30 29 30 29 383 2056 */ { 00, 02, 15, 0b1110101001010000 }, /* 30 30 30 29 30 29 30 29 29 30 29 30 355 -2057 */ { 00, 02, 04, 0b0110101010100000 }, /* 29 30 30 29 30 29 30 29 30 29 30 29 354 +2057 */ { 00, 02, 04, 0b0110101100100000 }, /* 29 30 30 29 30 29 30 30 29 29 30 29 354 2058 */ { 04, 01, 24, 0b1010101101100000 }, /* 30 29 30 29 30 29 30 30 29 30 30 29 29 384 2059 */ { 00, 02, 12, 0b1010101011100000 }, /* 30 29 30 29 30 29 30 29 30 30 30 29 355 2060 */ { 00, 02, 02, 0b1001001011100000 }, /* 30 29 29 30 29 29 30 29 30 30 30 29 354 diff --git a/src/libraries/System.Private.CoreLib/src/System/Globalization/CompareInfo.cs b/src/libraries/System.Private.CoreLib/src/System/Globalization/CompareInfo.cs index 729fe7d4383..f60a8fa1655 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Globalization/CompareInfo.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Globalization/CompareInfo.cs @@ -1057,6 +1057,12 @@ private unsafe int IndexOf(ReadOnlySpan source, ReadOnlySpan value, { Debug.Assert(matchLengthPtr != null); *matchLengthPtr = 0; +#if TARGET_BROWSER || TARGET_MACCATALYST || TARGET_IOS || TARGET_TVOS + if (GlobalizationMode.Hybrid) + { + throw new PlatformNotSupportedException(SR.PlatformNotSupported_HybridGlobalizationWithMatchLength); + } +#endif int retVal = 0; diff --git a/src/libraries/System.Private.CoreLib/src/System/Globalization/GlobalizationMode.Unix.cs b/src/libraries/System.Private.CoreLib/src/System/Globalization/GlobalizationMode.Unix.cs index df937e56e34..edc529fba01 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Globalization/GlobalizationMode.Unix.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Globalization/GlobalizationMode.Unix.cs @@ -38,7 +38,7 @@ static Settings() private static string GetIcuLoadFailureMessage() { // These strings can't go into resources, because a resource lookup requires globalization, which requires ICU - if (OperatingSystem.IsBrowser() || OperatingSystem.IsAndroid() || + if (OperatingSystem.IsBrowser() || OperatingSystem.IsWasi() || OperatingSystem.IsAndroid() || OperatingSystem.IsIOS() || OperatingSystem.IsTvOS() || OperatingSystem.IsWatchOS()) { return "Unable to load required ICU Globalization data. Please see https://aka.ms/dotnet-missing-libicu for more information"; diff --git a/src/libraries/System.Private.CoreLib/src/System/Globalization/InvariantModeCasing.cs b/src/libraries/System.Private.CoreLib/src/System/Globalization/InvariantModeCasing.cs index 809b42ac74c..5c6dfadf073 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Globalization/InvariantModeCasing.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Globalization/InvariantModeCasing.cs @@ -215,7 +215,7 @@ internal static int CompareStringIgnoreCase(ref char strA, int lengthA, ref char continue; } - return (int)codePointA - (int)codePointB; + return (int)aUpper - (int)bUpper; } return lengthA - lengthB; diff --git a/src/libraries/System.Private.CoreLib/src/System/Globalization/Normalization.Icu.cs b/src/libraries/System.Private.CoreLib/src/System/Globalization/Normalization.Icu.cs index 20ef88d4401..6ef9df95aa7 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Globalization/Normalization.Icu.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Globalization/Normalization.Icu.cs @@ -118,7 +118,7 @@ private static void ValidateArguments(string strInput, NormalizationForm normali { Debug.Assert(strInput != null); - if (OperatingSystem.IsBrowser() && (normalizationForm == NormalizationForm.FormKC || normalizationForm == NormalizationForm.FormKD)) + if ((OperatingSystem.IsBrowser() || OperatingSystem.IsWasi())&& (normalizationForm == NormalizationForm.FormKC || normalizationForm == NormalizationForm.FormKD)) { // Browser's ICU doesn't contain data needed for FormKC and FormKD throw new PlatformNotSupportedException(); diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/BinaryReader.cs b/src/libraries/System.Private.CoreLib/src/System/IO/BinaryReader.cs index 37e0d1ffebf..5a8bba6a6d2 100644 --- a/src/libraries/System.Private.CoreLib/src/System/IO/BinaryReader.cs +++ b/src/libraries/System.Private.CoreLib/src/System/IO/BinaryReader.cs @@ -453,6 +453,22 @@ public virtual byte[] ReadBytes(int count) return result; } + /// + /// Reads bytes from the current stream and advances the position within the stream until the is filled. + /// + /// + /// When is empty, this read operation will be completed without waiting for available data in the stream. + /// + /// A region of memory. When this method returns, the contents of this region are replaced by the bytes read from the current stream. + /// The stream is closed. + /// An I/O error occurred. + /// The end of the stream is reached before filling the . + public virtual void ReadExactly(Span buffer) + { + ThrowIfDisposed(); + _stream.ReadExactly(buffer); + } + private ReadOnlySpan InternalRead(Span buffer) { Debug.Assert(buffer.Length != 1, "length of 1 should use ReadByte."); diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/File.cs b/src/libraries/System.Private.CoreLib/src/System/IO/File.cs index 9f047635046..87f0bae4734 100644 --- a/src/libraries/System.Private.CoreLib/src/System/IO/File.cs +++ b/src/libraries/System.Private.CoreLib/src/System/IO/File.cs @@ -819,6 +819,7 @@ public static void AppendAllBytes(string path, ReadOnlySpan bytes) /// The file to append to. /// The bytes to append to the file. /// The token to monitor for cancellation requests. The default value is . + /// A task that represents the asynchronous append operation. /// is null. /// is null. /// is empty. @@ -837,6 +838,7 @@ public static Task AppendAllBytesAsync(string path, byte[] bytes, CancellationTo /// The file to append to. /// The bytes to append to the file. /// The token to monitor for cancellation requests. The default value is . + /// A task that represents the asynchronous append operation. /// is null. /// is empty. /// The cancellation token was canceled. This exception is stored into the returned task. diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/FileStream.cs b/src/libraries/System.Private.CoreLib/src/System/IO/FileStream.cs index a7f6aaecb5b..cee3482ea93 100644 --- a/src/libraries/System.Private.CoreLib/src/System/IO/FileStream.cs +++ b/src/libraries/System.Private.CoreLib/src/System/IO/FileStream.cs @@ -536,6 +536,7 @@ public override void CopyTo(Stream destination, int bufferSize) _strategy.CopyTo(destination, bufferSize); } + /// public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken) { ValidateCopyToArguments(destination, bufferSize); diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/Stream.cs b/src/libraries/System.Private.CoreLib/src/System/IO/Stream.cs index 1af85eed92d..4a4c00efd30 100644 --- a/src/libraries/System.Private.CoreLib/src/System/IO/Stream.cs +++ b/src/libraries/System.Private.CoreLib/src/System/IO/Stream.cs @@ -11,7 +11,7 @@ namespace System.IO { - public abstract class Stream : MarshalByRefObject, IDisposable, IAsyncDisposable + public abstract partial class Stream : MarshalByRefObject, IDisposable, IAsyncDisposable { public static readonly Stream Null = new NullStream(); @@ -447,14 +447,6 @@ private async ValueTask ReadAtLeastAsyncCore(Memory buffer, int minim return totalRead; } - [Intrinsic] - [MethodImpl(MethodImplOptions.InternalCall)] - private extern bool HasOverriddenBeginEndRead(); - - [Intrinsic] - [MethodImpl(MethodImplOptions.InternalCall)] - private extern bool HasOverriddenBeginEndWrite(); - private Task BeginEndReadAsync(byte[] buffer, int offset, int count) { if (!HasOverriddenBeginEndRead()) diff --git a/src/libraries/System.Private.CoreLib/src/System/IO/StreamWriter.cs b/src/libraries/System.Private.CoreLib/src/System/IO/StreamWriter.cs index 58efa18407c..dd026313384 100644 --- a/src/libraries/System.Private.CoreLib/src/System/IO/StreamWriter.cs +++ b/src/libraries/System.Private.CoreLib/src/System/IO/StreamWriter.cs @@ -77,7 +77,7 @@ public StreamWriter(Stream stream) { } - public StreamWriter(Stream stream, Encoding encoding) + public StreamWriter(Stream stream, Encoding? encoding) : this(stream, encoding, DefaultBufferSize, false) { } @@ -86,7 +86,7 @@ public StreamWriter(Stream stream, Encoding encoding) // character encoding is set by encoding and the buffer size, // in number of 16-bit characters, is set by bufferSize. // - public StreamWriter(Stream stream, Encoding encoding, int bufferSize) + public StreamWriter(Stream stream, Encoding? encoding, int bufferSize) : this(stream, encoding, bufferSize, false) { } @@ -140,13 +140,13 @@ public StreamWriter(string path, bool append) { } - public StreamWriter(string path, bool append, Encoding encoding) + public StreamWriter(string path, bool append, Encoding? encoding) : this(path, append, encoding, DefaultBufferSize) { } - public StreamWriter(string path, bool append, Encoding encoding, int bufferSize) : - this(ValidateArgsAndOpenPath(path, append, encoding, bufferSize), encoding, bufferSize, leaveOpen: false) + public StreamWriter(string path, bool append, Encoding? encoding, int bufferSize) : + this(ValidateArgsAndOpenPath(path, append, bufferSize), encoding, bufferSize, leaveOpen: false) { } @@ -155,8 +155,8 @@ public StreamWriter(string path, FileStreamOptions options) { } - public StreamWriter(string path, Encoding encoding, FileStreamOptions options) - : this(ValidateArgsAndOpenPath(path, encoding, options), encoding, DefaultFileStreamBufferSize) + public StreamWriter(string path, Encoding? encoding, FileStreamOptions options) + : this(ValidateArgsAndOpenPath(path, options), encoding, DefaultFileStreamBufferSize) { } @@ -169,10 +169,9 @@ private StreamWriter() _charBuffer = Array.Empty(); } - private static FileStream ValidateArgsAndOpenPath(string path, Encoding encoding, FileStreamOptions options) + private static FileStream ValidateArgsAndOpenPath(string path, FileStreamOptions options) { ArgumentException.ThrowIfNullOrEmpty(path); - ArgumentNullException.ThrowIfNull(encoding); ArgumentNullException.ThrowIfNull(options); if ((options.Access & FileAccess.Write) == 0) { @@ -182,10 +181,9 @@ private static FileStream ValidateArgsAndOpenPath(string path, Encoding encoding return new FileStream(path, options); } - private static FileStream ValidateArgsAndOpenPath(string path, bool append, Encoding encoding, int bufferSize) + private static FileStream ValidateArgsAndOpenPath(string path, bool append, int bufferSize) { ArgumentException.ThrowIfNullOrEmpty(path); - ArgumentNullException.ThrowIfNull(encoding); ArgumentOutOfRangeException.ThrowIfNegativeOrZero(bufferSize); return new FileStream(path, append ? FileMode.Append : FileMode.Create, FileAccess.Write, FileShare.Read, DefaultFileStreamBufferSize); diff --git a/src/libraries/System.Private.CoreLib/src/System/Int128.cs b/src/libraries/System.Private.CoreLib/src/System/Int128.cs index 7a69db71674..241c1c39e71 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Int128.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Int128.cs @@ -425,7 +425,7 @@ public static explicit operator checked ulong(Int128 value) /// The value to convert. /// converted to a . [CLSCompliant(false)] - public static explicit operator UInt128(Int128 value) => Unsafe.BitCast(value); + public static explicit operator UInt128(Int128 value) => new UInt128(value._upper, value._lower); /// Explicitly converts a 128-bit signed integer to a value, throwing an overflow exception for any values that fall outside the representable range. /// The value to convert. @@ -438,7 +438,7 @@ public static explicit operator checked UInt128(Int128 value) { ThrowHelper.ThrowOverflowException(); } - return Unsafe.BitCast(value); + return new UInt128(value._upper, value._lower); } /// Explicitly converts a 128-bit signed integer to a value. diff --git a/src/libraries/System.Private.CoreLib/src/System/LocalAppContextSwitches.cs b/src/libraries/System.Private.CoreLib/src/System/LocalAppContextSwitches.cs index 1e6e67af54b..7392f64bd80 100644 --- a/src/libraries/System.Private.CoreLib/src/System/LocalAppContextSwitches.cs +++ b/src/libraries/System.Private.CoreLib/src/System/LocalAppContextSwitches.cs @@ -1,6 +1,7 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System.Diagnostics.CodeAnalysis; using System.Runtime.CompilerServices; namespace System @@ -8,6 +9,7 @@ namespace System internal static partial class LocalAppContextSwitches { private static int s_enableUnsafeUTF7Encoding; + [FeatureSwitchDefinition("System.Text.Encoding.EnableUnsafeUTF7Encoding")] public static bool EnableUnsafeUTF7Encoding { [MethodImpl(MethodImplOptions.AggressiveInlining)] diff --git a/src/libraries/System.Private.CoreLib/src/System/MathF.cs b/src/libraries/System.Private.CoreLib/src/System/MathF.cs index 31e74906022..2d1e6e4eda4 100644 --- a/src/libraries/System.Private.CoreLib/src/System/MathF.cs +++ b/src/libraries/System.Private.CoreLib/src/System/MathF.cs @@ -309,8 +309,8 @@ public static float MinMagnitude(float x, float y) /// The number whose reciprocal is to be estimated. /// An estimate of the reciprocal of . /// - /// On x86/x64 hardware this may use the RCPSS instruction which has a maximum relative error of 1.5 * 2^-12. - /// On ARM64 hardware this may use the FRECPE instruction which performs a single Newton-Raphson iteration. + /// On x86/x64 hardware, this may use the RCPSS instruction, which has a maximum relative error of 1.5 * 2^-12. + /// On ARM64 hardware, this may use the FRECPE instruction, which performs a single Newton-Raphson iteration. /// On hardware without specialized support, this may just return 1.0 / x. /// [Intrinsic] @@ -327,8 +327,8 @@ public static float ReciprocalEstimate(float x) /// The number whose reciprocal square root is to be estimated. /// An estimate of the reciprocal square root . /// - /// On x86/x64 hardware this may use the RSQRTSS instruction which has a maximum relative error of 1.5 * 2^-12. - /// On ARM64 hardware this may use the FRSQRTE instruction which performs a single Newton-Raphson iteration. + /// On x86/x64 hardware, this may use the RSQRTSS instruction, which has a maximum relative error of 1.5 * 2^-12. + /// On ARM64 hardware, this may use the FRSQRTE instruction, which performs a single Newton-Raphson iteration. /// On hardware without specialized support, this may just return 1.0 / Sqrt(x). /// [Intrinsic] diff --git a/src/libraries/System.Private.CoreLib/src/System/Number.Parsing.cs b/src/libraries/System.Private.CoreLib/src/System/Number.Parsing.cs index f15712bf5fe..bb80ebd3ff6 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Number.Parsing.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Number.Parsing.cs @@ -120,7 +120,7 @@ private static unsafe bool TryNumberBufferToBinaryInteger(ref NumberBu int i = number.Scale; - if ((i > TInteger.MaxDigitCount) || (i < number.DigitsCount) || (!TInteger.IsSigned && number.IsNegative)) + if ((i > TInteger.MaxDigitCount) || (i < number.DigitsCount) || (!TInteger.IsSigned && number.IsNegative) || number.HasNonZeroTail) { return false; } diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Matrix3x2.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Matrix3x2.cs index bc7fa66d7f7..0c84691bce6 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Numerics/Matrix3x2.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/Matrix3x2.cs @@ -161,7 +161,7 @@ public Vector2 Translation /// Negates the specified matrix by multiplying all its values by -1. /// The matrix to negate. /// The negated matrix. - /// + /// [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Matrix3x2 operator -(Matrix3x2 value) => (-value.AsImpl()).AsM3x2(); diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Quaternion.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Quaternion.cs index b54bb0c3609..5c5389993c8 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Numerics/Quaternion.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/Quaternion.cs @@ -82,7 +82,7 @@ public float this[int index] /// Gets a value that indicates whether the current instance is the identity quaternion. /// if the current instance is the identity quaternion; otherwise, . - /// + /// public readonly bool IsIdentity => this == Identity; /// Adds each element in one quaternion with its corresponding element in a second quaternion. diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/TotalOrderIeee754Comparer.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/TotalOrderIeee754Comparer.cs index 77c33c4e04d..dca39f67536 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Numerics/TotalOrderIeee754Comparer.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/TotalOrderIeee754Comparer.cs @@ -226,8 +226,13 @@ public int GetHashCode([DisallowNull] T obj) public bool Equals(TotalOrderIeee754Comparer other) => true; + /// Determines whether this instance and a specified object are equal. + /// The object to compare with the current instance. + /// true if the current instance and are equal; otherwise, false. If is null, the method returns false. public override bool Equals([NotNullWhen(true)] object? obj) => obj is TotalOrderIeee754Comparer; + /// Returns the hash code for this instance. + /// The hash code. public override int GetHashCode() => EqualityComparer.Default.GetHashCode(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector.cs index 69b8ddaac3d..821aae27da8 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector.cs @@ -90,102 +90,102 @@ public static Vector As(this Vector vector) #endif } - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the input vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector AsVectorByte(Vector value) => value.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the input vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector AsVectorDouble(Vector value) => value.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the input vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector AsVectorInt16(Vector value) => value.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the input vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector AsVectorInt32(Vector value) => value.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the input vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector AsVectorInt64(Vector value) => value.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the input vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector AsVectorNInt(Vector value) => value.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the input vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static Vector AsVectorNUInt(Vector value) => value.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the input vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static Vector AsVectorSByte(Vector value) => value.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the input vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector AsVectorSingle(Vector value) => value.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the input vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static Vector AsVectorUInt16(Vector value) => value.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the input vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static Vector AsVectorUInt32(Vector value) => value.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the input vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] @@ -195,7 +195,7 @@ public static Vector As(this Vector vector) /// The vector to bitwise-and with . /// The vector to bitwise-and with . /// The type of the elements in the vector. - /// The bitwise-and of and . + /// The bitwise-and of and . [Intrinsic] public static Vector BitwiseAnd(Vector left, Vector right) => left & right; @@ -203,7 +203,7 @@ public static Vector As(this Vector vector) /// The vector to bitwise-or with . /// The vector to bitwise-or with . /// The type of the elements in the vector. - /// The bitwise-or of and . + /// The bitwise-or of and . [Intrinsic] public static Vector BitwiseOr(Vector left, Vector right) => left | right; @@ -321,7 +321,7 @@ public static Vector ClampNative(Vector value, Vector min, Vector [Intrinsic] public static Vector ConditionalSelect(Vector condition, Vector left, Vector right) => ConditionalSelect(condition.As(), left, right); - /// Converts a to a . + /// Converts a to a . /// The vector to convert. /// The converted vector. [Intrinsic] @@ -340,7 +340,7 @@ public static Vector ConvertToDouble(Vector value) } } - /// Converts a to a . + /// Converts a to a . /// The vector to convert. /// The converted vector. [Intrinsic] @@ -360,7 +360,7 @@ public static Vector ConvertToDouble(Vector value) } } - /// Converts a to a using saturation on overflow. + /// Converts a to a using saturation on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -377,7 +377,7 @@ public static Vector ConvertToInt32(Vector value) return result; } - /// Converts a to a using platform specific behavior on overflow. + /// Converts a to a using platform specific behavior on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -394,7 +394,7 @@ public static Vector ConvertToInt32Native(Vector value) return result; } - /// Converts a to a using saturation on overflow. + /// Converts a to a using saturation on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -411,7 +411,7 @@ public static Vector ConvertToInt64(Vector value) return result; } - /// Converts a to a using platform specific behavior on overflow. + /// Converts a to a using platform specific behavior on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -428,7 +428,7 @@ public static Vector ConvertToInt64Native(Vector value) return result; } - /// Converts a to a . + /// Converts a to a . /// The vector to convert. /// The converted vector. [Intrinsic] @@ -445,7 +445,7 @@ public static Vector ConvertToSingle(Vector value) return result; } - /// Converts a to a . + /// Converts a to a . /// The vector to convert. /// The converted vector. [Intrinsic] @@ -465,7 +465,7 @@ public static Vector ConvertToSingle(Vector value) } } - /// Converts a to a using saturation on overflow. + /// Converts a to a using saturation on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -483,7 +483,7 @@ public static Vector ConvertToUInt32(Vector value) return result; } - /// Converts a to a using platform specific behavior on overflow. + /// Converts a to a using platform specific behavior on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -501,7 +501,7 @@ public static Vector ConvertToUInt32Native(Vector value) return result; } - /// Converts a to a using saturation on overflow. + /// Converts a to a using saturation on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -519,7 +519,7 @@ public static Vector ConvertToUInt64(Vector value) return result; } - /// Converts a to a using platform specific behavior on overflow. + /// Converts a to a using platform specific behavior on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -943,14 +943,14 @@ public static Vector Floor(Vector value) return result; } - /// Computes ( * ) + , rounded as one ternary operation. + /// Computes ( * ) + , rounded as one ternary operation. /// The vector to be multiplied with . /// The vector to be multiplied with . /// The vector to be added to the result of multiplied by . - /// ( * ) + , rounded as one ternary operation. + /// ( * ) + , rounded as one ternary operation. /// - /// This computes ( * ) as if to infinite precision, adds to that result as if to infinite precision, and finally rounds to the nearest representable value. - /// This differs from the non-fused sequence which would compute ( * ) as if to infinite precision, round the result to the nearest representable value, add to the rounded result as if to infinite precision, and finally round to the nearest representable value. + /// This computes ( * ) as if to infinite precision, adds to that result as if to infinite precision, and finally rounds to the nearest representable value. + /// This differs from the non-fused sequence which would compute ( * ) as if to infinite precision, round the result to the nearest representable value, add to the rounded result as if to infinite precision, and finally round to the nearest representable value. /// [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -967,14 +967,14 @@ public static Vector FusedMultiplyAdd(Vector left, VectorComputes ( * ) + , rounded as one ternary operation. + /// Computes ( * ) + , rounded as one ternary operation. /// The vector to be multiplied with . /// The vector to be multiplied with . /// The vector to be added to the result of multiplied by . - /// ( * ) + , rounded as one ternary operation. + /// ( * ) + , rounded as one ternary operation. /// - /// This computes ( * ) as if to infinite precision, adds to that result as if to infinite precision, and finally rounds to the nearest representable value. - /// This differs from the non-fused sequence which would compute ( * ) as if to infinite precision, round the result to the nearest representable value, add to the rounded result as if to infinite precision, and finally round to the nearest representable value. + /// This computes ( * ) as if to infinite precision, adds to that result as if to infinite precision, and finally rounds to the nearest representable value. + /// This differs from the non-fused sequence which would compute ( * ) as if to infinite precision, round the result to the nearest representable value, add to the rounded result as if to infinite precision, and finally round to the nearest representable value. /// [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -1997,10 +1997,10 @@ public static Vector MultiplyAddEstimate(Vector left, VectorNarrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector Narrow(Vector low, Vector high) @@ -2022,10 +2022,10 @@ public static Vector Narrow(Vector low, Vector high) return result; } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -2048,10 +2048,10 @@ public static Vector Narrow(Vector low, Vector high) return result; } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector Narrow(Vector low, Vector high) @@ -2073,10 +2073,10 @@ public static Vector Narrow(Vector low, Vector high) return result; } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector Narrow(Vector low, Vector high) @@ -2098,10 +2098,10 @@ public static Vector Narrow(Vector low, Vector high) return result; } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -2124,10 +2124,10 @@ public static Vector Narrow(Vector low, Vector high) return result; } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -2150,10 +2150,10 @@ public static Vector Narrow(Vector low, Vector high) return result; } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -2715,49 +2715,49 @@ internal static Vector Truncate(Vector vector) [Intrinsic] public static Vector Truncate(Vector vector) => Truncate(vector); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [MethodImpl(MethodImplOptions.AggressiveInlining)] internal static (Vector Lower, Vector Upper) Widen(Vector source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [MethodImpl(MethodImplOptions.AggressiveInlining)] internal static (Vector Lower, Vector Upper) Widen(Vector source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [MethodImpl(MethodImplOptions.AggressiveInlining)] internal static (Vector Lower, Vector Upper) Widen(Vector source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [MethodImpl(MethodImplOptions.AggressiveInlining)] internal static (Vector Lower, Vector Upper) Widen(Vector source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [MethodImpl(MethodImplOptions.AggressiveInlining)] internal static (Vector Lower, Vector Upper) Widen(Vector source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [MethodImpl(MethodImplOptions.AggressiveInlining)] internal static (Vector Lower, Vector Upper) Widen(Vector source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [MethodImpl(MethodImplOptions.AggressiveInlining)] internal static (Vector Lower, Vector Upper) Widen(Vector source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A vector that will contain the widened result of the lower half of . /// A vector that will contain the widened result of the upper half of . @@ -2769,7 +2769,7 @@ public static void Widen(Vector source, out Vector low, out Vector high = WidenUpper(source); } - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A vector that will contain the widened result of the lower half of . /// A vector that will contain the widened result of the upper half of . @@ -2780,7 +2780,7 @@ public static void Widen(Vector source, out Vector low, out VectorWidens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A vector that will contain the widened result of the lower half of . /// A vector that will contain the widened result of the upper half of . @@ -2791,7 +2791,7 @@ public static void Widen(Vector source, out Vector low, out VectorWidens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A vector that will contain the widened result of the lower half of . /// A vector that will contain the widened result of the upper half of . @@ -2803,7 +2803,7 @@ public static void Widen(Vector source, out Vector low, out Vector high = WidenUpper(source); } - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A vector that will contain the widened result of the lower half of . /// A vector that will contain the widened result of the upper half of . @@ -2814,7 +2814,7 @@ public static void Widen(Vector source, out Vector low, out Vecto high = WidenUpper(source); } - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A vector that will contain the widened result of the lower half of . /// A vector that will contain the widened result of the upper half of . @@ -2826,7 +2826,7 @@ public static void Widen(Vector source, out Vector low, out Vector high = WidenUpper(source); } - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A vector that will contain the widened result of the lower half of . /// A vector that will contain the widened result of the upper half of . @@ -2838,7 +2838,7 @@ public static void Widen(Vector source, out Vector low, out Vector< high = WidenUpper(source); } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -2857,7 +2857,7 @@ public static Vector WidenLower(Vector source) return lower; } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -2875,7 +2875,7 @@ public static Vector WidenLower(Vector source) return lower; } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -2893,7 +2893,7 @@ public static Vector WidenLower(Vector source) return lower; } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -2912,7 +2912,7 @@ public static Vector WidenLower(Vector source) return lower; } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -2930,7 +2930,7 @@ public static Vector WidenLower(Vector source) return lower; } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -2949,7 +2949,7 @@ public static Vector WidenLower(Vector source) return lower; } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -2968,7 +2968,7 @@ public static Vector WidenLower(Vector source) return lower; } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -2987,7 +2987,7 @@ public static Vector WidenUpper(Vector source) return upper; } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3005,7 +3005,7 @@ public static Vector WidenUpper(Vector source) return upper; } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3023,7 +3023,7 @@ public static Vector WidenUpper(Vector source) return upper; } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3042,7 +3042,7 @@ public static Vector WidenUpper(Vector source) return upper; } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3060,7 +3060,7 @@ public static Vector WidenUpper(Vector source) return upper; } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3079,7 +3079,7 @@ public static Vector WidenUpper(Vector source) return upper; } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector2.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector2.cs index e51501d5102..6459b56effe 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector2.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector2.cs @@ -692,14 +692,14 @@ public readonly bool TryCopyTo(Span destination) /// Returns the length of the vector. /// The vector's length. - /// + /// [Intrinsic] public readonly float Length() => float.Sqrt(LengthSquared()); /// Returns the length of the vector squared. /// The vector's length squared. /// This operation offers better performance than a call to the method. - /// + /// [Intrinsic] public readonly float LengthSquared() => Dot(this, this); diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector3.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector3.cs index bc81131e20a..c69b274f0d7 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector3.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector3.cs @@ -725,14 +725,14 @@ public readonly bool TryCopyTo(Span destination) /// Returns the length of this vector object. /// The vector's length. - /// + /// [Intrinsic] public readonly float Length() => float.Sqrt(LengthSquared()); /// Returns the length of the vector squared. /// The vector's length squared. /// This operation offers better performance than a call to the method. - /// + /// [Intrinsic] public readonly float LengthSquared() => Dot(this, this); diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector4.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector4.cs index 8dbd1a07f67..2137d2c8f48 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector4.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector4.cs @@ -723,14 +723,14 @@ public static Vector4 Transform(Vector4 value, Quaternion rotation) /// Returns the length of this vector object. /// The vector's length. - /// + /// [Intrinsic] public readonly float Length() => float.Sqrt(LengthSquared()); /// Returns the length of the vector squared. /// The vector's length squared. /// This operation offers better performance than a call to the method. - /// + /// [Intrinsic] public readonly float LengthSquared() => Dot(this, this); diff --git a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector_1.cs b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector_1.cs index e6cb7e1d4d4..389527d8ae0 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector_1.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Numerics/Vector_1.cs @@ -243,7 +243,7 @@ public T this[int index] /// Computes the bitwise-and of two vectors. /// The vector to bitwise-and with . /// The vector to bitwise-and with . - /// The bitwise-and of and . + /// The bitwise-and of and . [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector operator &(Vector left, Vector right) @@ -266,7 +266,7 @@ public T this[int index] /// Computes the bitwise-or of two vectors. /// The vector to bitwise-or with . /// The vector to bitwise-or with . - /// The bitwise-or of and . + /// The bitwise-or of and . [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector operator |(Vector left, Vector right) @@ -365,90 +365,90 @@ public T this[int index] return result.As(); } - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static explicit operator Vector(Vector value) => value.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static explicit operator Vector(Vector value) => value.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static explicit operator Vector(Vector value) => value.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static explicit operator Vector(Vector value) => value.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static explicit operator Vector(Vector value) => value.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static explicit operator Vector(Vector value) => value.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static explicit operator Vector(Vector value) => value.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static explicit operator Vector(Vector value) => value.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static explicit operator Vector(Vector value) => value.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static explicit operator Vector(Vector value) => value.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static explicit operator Vector(Vector value) => value.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] diff --git a/src/libraries/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.cs b/src/libraries/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.cs index 9e36505b390..04ab8e7ee08 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.cs @@ -4,7 +4,6 @@ using System.Diagnostics; using System.Diagnostics.CodeAnalysis; using System.Reflection.Metadata; -using System.Text; namespace System.Reflection.Metadata { @@ -12,8 +11,6 @@ internal struct TypeNameParseOptions { public TypeNameParseOptions() { } #pragma warning disable CA1822 // Mark members as static - // CoreLib does not enforce any limits - public bool IsMaxDepthExceeded(int _) => false; public int MaxNodes { get diff --git a/src/libraries/System.Private.CoreLib/src/System/Resources/ResourceReader.cs b/src/libraries/System.Private.CoreLib/src/System/Resources/ResourceReader.cs index 582c072efeb..af37166b8cb 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Resources/ResourceReader.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Resources/ResourceReader.cs @@ -140,6 +140,7 @@ public sealed partial class ReadResources(); } + [FeatureSwitchDefinition("System.Resources.ResourceManager.AllowCustomResourceTypes")] internal static bool AllowCustomResourceTypes { get; } = AppContext.TryGetSwitch("System.Resources.ResourceManager.AllowCustomResourceTypes", out bool allowReflection) ? allowReflection : true; public void Close() diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/ConfiguredCancelableAsyncEnumerable.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/ConfiguredCancelableAsyncEnumerable.cs index 67d8f15dbe5..c874d3fc1f4 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/ConfiguredCancelableAsyncEnumerable.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/ConfiguredCancelableAsyncEnumerable.cs @@ -23,7 +23,7 @@ internal ConfiguredCancelableAsyncEnumerable(IAsyncEnumerable enumerable, boo } /// Configures how awaits on the tasks returned from an async iteration will be performed. - /// Whether to capture and marshal back to the current context. + /// to capture and marshal back to the current context; otherwise, . /// The configured enumerable. /// This will replace any previous value set by for this iteration. public ConfiguredCancelableAsyncEnumerable ConfigureAwait(bool continueOnCapturedContext) => diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/ICastable.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/ICastable.cs deleted file mode 100644 index ae117637668..00000000000 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/ICastable.cs +++ /dev/null @@ -1,60 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Diagnostics.CodeAnalysis; - -namespace System.Runtime.CompilerServices -{ - /// - /// Support for dynamic interface casting. Specifically implementing this interface on a type will allow the - /// type to support interfaces (for the purposes of casting and interface dispatch) that do not appear in its - /// interface map. - /// - public interface ICastable - { - // This is called if casting this object to the given interface type would otherwise fail. Casting - // here means the IL isinst and castclass instructions in the case where they are given an interface - // type as the target type. - // - // A return value of true indicates the cast is valid. - // - // If false is returned when this is called as part of a castclass then the usual InvalidCastException - // will be thrown unless an alternate exception is assigned to the castError output parameter. This - // parameter is ignored on successful casts or during the evaluation of an isinst (which returns null - // rather than throwing on error). - // - // No exception should be thrown from this method (it will cause unpredictable effects, including the - // possibility of an immediate failfast). - // - // The results of this call are not cached, so it is advisable to provide a performant implementation. - // - // The results of this call should be invariant for the same class, interface type pair. That is - // because this is the only guard placed before an interface invocation at runtime. If a type decides - // it no longer wants to implement a given interface it has no way to synchronize with callers that - // have already cached this relationship and can invoke directly via the interface pointer. - bool IsInstanceOfInterface(RuntimeTypeHandle interfaceType, [NotNullWhen(true)] out Exception? castError); - - // This is called as part of the interface dispatch mechanism when the dispatcher logic cannot find - // the given interface type in the interface map of this object. - // - // It allows the implementor to return an alternate class type which does implement the interface. The - // interface lookup shall be performed again on this type (failure to find the interface this time - // resulting in a fail fast) and the corresponding implemented method on that class called instead. - // - // Naturally, since the call is dispatched to a method on a class which does not match the type of the - // this pointer, extreme care must be taken in the implementation of the interface methods of this - // surrogate type. - // - // No exception should be thrown from this method (it will cause unpredictable effects, including the - // possibility of an immediate failfast). - // - // There is no error path defined here. By construction all interface dispatches will already have - // been verified via the castclass/isinst mechanism (and thus a call to IsInstanceOfInterface above) - // so this method is expected to succeed in all cases. The contract for interface dispatch does not - // include any errors from the infrastructure, of which this is a part. - // - // The results of this lookup are cached so computation of the result is not as perf-sensitive as - // IsInstanceOfInterface. - RuntimeTypeHandle GetImplType(RuntimeTypeHandle interfaceType); - } -} diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/StackAllocatedBox.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/StackAllocatedBox.cs index 868edb18c15..33f2131edd1 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/StackAllocatedBox.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/StackAllocatedBox.cs @@ -7,7 +7,7 @@ namespace System.Runtime.CompilerServices { [NonVersionable] - [StructLayout(LayoutKind.Sequential)] + [StructLayout(LayoutKind.Sequential, Pack = 1)] internal unsafe struct StackAllocatedBox { // These fields are only accessed from jitted code diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshalling/ComVariant.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshalling/ComVariant.cs index 1abac3537a1..ee44d496071 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshalling/ComVariant.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshalling/ComVariant.cs @@ -255,7 +255,9 @@ public unsafe void Dispose() /// When does not directly correspond to a variant type. public static ComVariant Create([DisallowNull] T value) { - Unsafe.SkipInit(out ComVariant variant); + // Although unused bits of native VARIANT is undefined, our managed test + // for Marshal.GetNativeVariantForObject asserts for its whole content. + ComVariant variant = default; if (typeof(T) == typeof(DBNull)) { variant = Null; @@ -393,7 +395,7 @@ public static unsafe ComVariant CreateRaw(VarEnum vt, T rawValue) throw new PlatformNotSupportedException(SR.ComVariant_SafeArray_PlatformNotSupported); } - Unsafe.SkipInit(out ComVariant value); + ComVariant value = default; value.VarType = vt; value.GetRawDataRef() = (vt, sizeof(T)) switch { diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.PlatformNotSupported.cs index 8e25d807ff9..1e78b13e8a2 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.PlatformNotSupported.cs @@ -6,9 +6,7 @@ namespace System.Runtime.Intrinsics.Arm { - /// - /// This class provides access to the ARM AdvSIMD hardware instructions via intrinsics - /// + /// Provides access to the ARM AdvSIMD hardware instructions via intrinsics. [CLSCompliant(false)] #if SYSTEM_PRIVATE_CORELIB public @@ -28,128 +26,129 @@ internal AdvSimd() { } // public static new bool IsSupported { [Intrinsic] get { return false; } } // // /// - // /// float32x2_t vmla_f32 (float32x2_t a, float32x2_t b, float32x2_t c) - // /// A32: VMLA.F32 Dd, Dn, Dm + // /// float32x2_t vmla_f32 (float32x2_t a, float32x2_t b, float32x2_t c) + // /// A32: VMLA.F32 Dd, Dn, Dm // /// // public static Vector64 MultiplyAdd(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } // // /// - // /// float32x4_t vmlaq_f32 (float32x4_t a, float32x4_t b, float32x4_t c) - // /// A32: VMLA.F32 Qd, Qn, Qm + // /// float32x4_t vmlaq_f32 (float32x4_t a, float32x4_t b, float32x4_t c) + // /// A32: VMLA.F32 Qd, Qn, Qm // /// // public static Vector128 MultiplyAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } // // /// - // /// float32x2_t vmla_n_f32 (float32x2_t a, float32x2_t b, float32_t c) - // /// A32: VMLA.F32 Dd, Dn, Dm[0] + // /// float32x2_t vmla_n_f32 (float32x2_t a, float32x2_t b, float32_t c) + // /// A32: VMLA.F32 Dd, Dn, Dm[0] // /// // public static Vector64 MultiplyAddByScalar(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } // // /// - // /// float32x4_t vmlaq_n_f32 (float32x4_t a, float32x4_t b, float32_t c) - // /// A32: VMLA.F32 Qd, Qn, Dm[0] + // /// float32x4_t vmlaq_n_f32 (float32x4_t a, float32x4_t b, float32_t c) + // /// A32: VMLA.F32 Qd, Qn, Dm[0] // /// // public static Vector128 MultiplyAddByScalar(Vector128 addend, Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } // // /// - // /// float32x2_t vmla_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane) - // /// A32: VMLA.F32 Dd, Dn, Dm[lane] + // /// float32x2_t vmla_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane) + // /// A32: VMLA.F32 Dd, Dn, Dm[lane] // /// // public static Vector64 MultiplyAddBySelectedScalar(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } // // /// - // /// float32x2_t vmla_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane) - // /// A32: VMLA.F32 Dd, Dn, Dm[lane] + // /// float32x2_t vmla_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane) + // /// A32: VMLA.F32 Dd, Dn, Dm[lane] // /// // public static Vector64 MultiplyAddBySelectedScalar(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } // // /// - // /// float32x4_t vmlaq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane) - // /// A32: VMLA.F32 Qd, Qn, Dm[lane] + // /// float32x4_t vmlaq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane) + // /// A32: VMLA.F32 Qd, Qn, Dm[lane] // /// // public static Vector128 MultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } // // /// - // /// float32x4_t vmlaq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane) - // /// A32: VMLA.F32 Qd, Qn, Dm[lane] + // /// float32x4_t vmlaq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane) + // /// A32: VMLA.F32 Qd, Qn, Dm[lane] // /// // public static Vector128 MultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } // // /// - // /// float64x1_t vmla_f64 (float64x1_t a, float64x1_t b, float64x1_t c) - // /// A32: VMLA.F64 Dd, Dn, Dm + // /// float64x1_t vmla_f64 (float64x1_t a, float64x1_t b, float64x1_t c) + // /// A32: VMLA.F64 Dd, Dn, Dm // /// // public static Vector64 MultiplyAddScalar(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } // // /// - // /// float32_t vmlas_f32 (float32_t a, float32_t b, float32_t c) - // /// A32: VMLA.F32 Sd, Sn, Sm - // /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + // /// float32_t vmlas_f32 (float32_t a, float32_t b, float32_t c) + // /// A32: VMLA.F32 Sd, Sn, Sm + // /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. // /// // public static Vector64 MultiplyAddScalar(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } // // /// - // /// float32x2_t vmls_f32 (float32x2_t a, float32x2_t b, float32x2_t c) - // /// A32: VMLS.F32 Dd, Dn, Dm + // /// float32x2_t vmls_f32 (float32x2_t a, float32x2_t b, float32x2_t c) + // /// A32: VMLS.F32 Dd, Dn, Dm // /// // public static Vector64 MultiplySubtract(Vector64 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } // // /// - // /// float32x4_t vmlsq_f32 (float32x4_t a, float32x4_t b, float32x4_t c) - // /// A32: VMLS.F32 Qd, Qn, Qm + // /// float32x4_t vmlsq_f32 (float32x4_t a, float32x4_t b, float32x4_t c) + // /// A32: VMLS.F32 Qd, Qn, Qm // /// // public static Vector128 MultiplySubtract(Vector128 minuend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } // // /// - // /// float32x2_t vmls_n_f32 (float32x2_t a, float32x2_t b, float32_t c) - // /// A32: VMLS.F32 Dd, Dn, Dm[0] + // /// float32x2_t vmls_n_f32 (float32x2_t a, float32x2_t b, float32_t c) + // /// A32: VMLS.F32 Dd, Dn, Dm[0] // /// // public static Vector64 MultiplySubtractByScalar(Vector64 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } // // /// - // /// float32x4_t vmlsq_n_f32 (float32x4_t a, float32x4_t b, float32_t c) - // /// A32: VMLS.F32 Qd, Qn, Dm[0] + // /// float32x4_t vmlsq_n_f32 (float32x4_t a, float32x4_t b, float32_t c) + // /// A32: VMLS.F32 Qd, Qn, Dm[0] // /// // public static Vector128 MultiplySubtractByScalar(Vector128 minuend, Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } // // /// - // /// float32x2_t vmls_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane) - // /// A32: VMLS.F32 Dd, Dn, Dm[lane] + // /// float32x2_t vmls_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane) + // /// A32: VMLS.F32 Dd, Dn, Dm[lane] // /// // public static Vector64 MultiplySubtractBySelectedScalar(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } // // /// - // /// float32x2_t vmls_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane) - // /// A32: VMLS.F32 Dd, Dn, Dm[lane] + // /// float32x2_t vmls_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane) + // /// A32: VMLS.F32 Dd, Dn, Dm[lane] // /// // public static Vector64 MultiplySubtractBySelectedScalar(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } // // /// - // /// float32x4_t vmlsq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane) - // /// A32: VMLS.F32 Qd, Qn, Dm[lane] + // /// float32x4_t vmlsq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane) + // /// A32: VMLS.F32 Qd, Qn, Dm[lane] // /// // public static Vector128 MultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } // // /// - // /// float32x4_t vmlsq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane) - // /// A32: VMLS.F32 Qd, Qn, Dm[lane] + // /// float32x4_t vmlsq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane) + // /// A32: VMLS.F32 Qd, Qn, Dm[lane] // /// // public static Vector128 MultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } // // /// - // /// float64x1_t vmls_f64 (float64x1_t a, float64x1_t b, float64x1_t c) - // /// A32: VMLS.F64 Dd, Dn, Dm + // /// float64x1_t vmls_f64 (float64x1_t a, float64x1_t b, float64x1_t c) + // /// A32: VMLS.F64 Dd, Dn, Dm // /// // public static Vector64 MultiplySubtractScalar(Vector64 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } // // /// - // /// float32_t vmlss_f32 (float32_t a, float32_t b, float32_t c) - // /// A32: VMLS.F32 Sd, Sn, Sm - // /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + // /// float32_t vmlss_f32 (float32_t a, float32_t b, float32_t c) + // /// A32: VMLS.F32 Sd, Sn, Sm + // /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. // /// // public static Vector64 MultiplySubtractScalar(Vector64 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } // } + /// Provides access to the ARM AdvSIMD hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class Arm64 : ArmBase.Arm64 { internal Arm64() { } @@ -157,17014 +156,16158 @@ internal Arm64() { } public static new bool IsSupported { [Intrinsic] get { return false; } } /// - /// float64x2_t vabsq_f64 (float64x2_t a) - /// A64: FABS Vd.2D, Vn.2D + /// float64x2_t vabsq_f64 (float64x2_t a) + /// A64: FABS Vd.2D, Vn.2D /// public static Vector128 Abs(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vabsq_s64 (int64x2_t a) - /// A64: ABS Vd.2D, Vn.2D + /// int64x2_t vabsq_s64 (int64x2_t a) + /// A64: ABS Vd.2D, Vn.2D /// public static Vector128 Abs(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqabsq_s64 (int64x2_t a) - /// A64: SQABS Vd.2D, Vn.2D + /// int64x2_t vqabsq_s64 (int64x2_t a) + /// A64: SQABS Vd.2D, Vn.2D /// public static Vector128 AbsSaturate(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int16_t vqabsh_s16 (int16_t a) - /// A64: SQABS Hd, Hn + /// int16_t vqabsh_s16 (int16_t a) + /// A64: SQABS Hd, Hn /// public static Vector64 AbsSaturateScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqabss_s32 (int32_t a) - /// A64: SQABS Sd, Sn + /// int32_t vqabss_s32 (int32_t a) + /// A64: SQABS Sd, Sn /// public static Vector64 AbsSaturateScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int64_t vqabsd_s64 (int64_t a) - /// A64: SQABS Dd, Dn + /// int64_t vqabsd_s64 (int64_t a) + /// A64: SQABS Dd, Dn /// public static Vector64 AbsSaturateScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int8_t vqabsb_s8 (int8_t a) - /// A64: SQABS Bd, Bn + /// int8_t vqabsb_s8 (int8_t a) + /// A64: SQABS Bd, Bn /// public static Vector64 AbsSaturateScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vabs_s64 (int64x1_t a) - /// A64: ABS Dd, Dn + /// int64x1_t vabs_s64 (int64x1_t a) + /// A64: ABS Dd, Dn /// public static Vector64 AbsScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vcagtq_f64 (float64x2_t a, float64x2_t b) - /// A64: FACGT Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcagtq_f64 (float64x2_t a, float64x2_t b) + /// A64: FACGT Vd.2D, Vn.2D, Vm.2D /// public static Vector128 AbsoluteCompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vcagt_f64 (float64x1_t a, float64x1_t b) - /// A64: FACGT Dd, Dn, Dm + /// uint64x1_t vcagt_f64 (float64x1_t a, float64x1_t b) + /// A64: FACGT Dd, Dn, Dm /// public static Vector64 AbsoluteCompareGreaterThanScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vcagts_f32 (float32_t a, float32_t b) - /// A64: FACGT Sd, Sn, Sm + /// uint32_t vcagts_f32 (float32_t a, float32_t b) + /// A64: FACGT Sd, Sn, Sm /// public static Vector64 AbsoluteCompareGreaterThanScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vcageq_f64 (float64x2_t a, float64x2_t b) - /// A64: FACGE Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcageq_f64 (float64x2_t a, float64x2_t b) + /// A64: FACGE Vd.2D, Vn.2D, Vm.2D /// public static Vector128 AbsoluteCompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vcage_f64 (float64x1_t a, float64x1_t b) - /// A64: FACGE Dd, Dn, Dm + /// uint64x1_t vcage_f64 (float64x1_t a, float64x1_t b) + /// A64: FACGE Dd, Dn, Dm /// public static Vector64 AbsoluteCompareGreaterThanOrEqualScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vcages_f32 (float32_t a, float32_t b) - /// A64: FACGE Sd, Sn, Sm + /// uint32_t vcages_f32 (float32_t a, float32_t b) + /// A64: FACGE Sd, Sn, Sm /// public static Vector64 AbsoluteCompareGreaterThanOrEqualScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vcaltq_f64 (float64x2_t a, float64x2_t b) - /// A64: FACGT Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcaltq_f64 (float64x2_t a, float64x2_t b) + /// A64: FACGT Vd.2D, Vn.2D, Vm.2D /// public static Vector128 AbsoluteCompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vcalt_f64 (float64x1_t a, float64x1_t b) - /// A64: FACGT Dd, Dn, Dm + /// uint64x1_t vcalt_f64 (float64x1_t a, float64x1_t b) + /// A64: FACGT Dd, Dn, Dm /// public static Vector64 AbsoluteCompareLessThanScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vcalts_f32 (float32_t a, float32_t b) - /// A64: FACGT Sd, Sn, Sm + /// uint32_t vcalts_f32 (float32_t a, float32_t b) + /// A64: FACGT Sd, Sn, Sm /// public static Vector64 AbsoluteCompareLessThanScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vcaleq_f64 (float64x2_t a, float64x2_t b) - /// A64: FACGE Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcaleq_f64 (float64x2_t a, float64x2_t b) + /// A64: FACGE Vd.2D, Vn.2D, Vm.2D /// public static Vector128 AbsoluteCompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vcale_f64 (float64x1_t a, float64x1_t b) - /// A64: FACGE Dd, Dn, Dm + /// uint64x1_t vcale_f64 (float64x1_t a, float64x1_t b) + /// A64: FACGE Dd, Dn, Dm /// public static Vector64 AbsoluteCompareLessThanOrEqualScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vcales_f32 (float32_t a, float32_t b) - /// A64: FACGE Sd, Sn, Sm + /// uint32_t vcales_f32 (float32_t a, float32_t b) + /// A64: FACGE Sd, Sn, Sm /// public static Vector64 AbsoluteCompareLessThanOrEqualScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vabdq_f64 (float64x2_t a, float64x2_t b) - /// A64: FABD Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vabdq_f64 (float64x2_t a, float64x2_t b) + /// A64: FABD Vd.2D, Vn.2D, Vm.2D /// public static Vector128 AbsoluteDifference(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vabd_f64 (float64x1_t a, float64x1_t b) - /// A64: FABD Dd, Dn, Dm + /// float64x1_t vabd_f64 (float64x1_t a, float64x1_t b) + /// A64: FABD Dd, Dn, Dm /// public static Vector64 AbsoluteDifferenceScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32_t vabds_f32 (float32_t a, float32_t b) - /// A64: FABD Sd, Sn, Sm + /// float32_t vabds_f32 (float32_t a, float32_t b) + /// A64: FABD Sd, Sn, Sm /// public static Vector64 AbsoluteDifferenceScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vaddq_f64 (float64x2_t a, float64x2_t b) - /// A64: FADD Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vaddq_f64 (float64x2_t a, float64x2_t b) + /// A64: FADD Vd.2D, Vn.2D, Vm.2D /// public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vaddv_u8 (uint8x8_t a) - /// A64: ADDV Bd, Vn.8B + /// uint8_t vaddv_u8 (uint8x8_t a) + /// A64: ADDV Bd, Vn.8B /// public static Vector64 AddAcross(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int16_t vaddv_s16 (int16x4_t a) - /// A64: ADDV Hd, Vn.4H + /// int16_t vaddv_s16 (int16x4_t a) + /// A64: ADDV Hd, Vn.4H /// public static Vector64 AddAcross(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int8_t vaddv_s8 (int8x8_t a) - /// A64: ADDV Bd, Vn.8B + /// int8_t vaddv_s8 (int8x8_t a) + /// A64: ADDV Bd, Vn.8B /// public static Vector64 AddAcross(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vaddv_u16 (uint16x4_t a) - /// A64: ADDV Hd, Vn.4H + /// uint16_t vaddv_u16 (uint16x4_t a) + /// A64: ADDV Hd, Vn.4H /// public static Vector64 AddAcross(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vaddvq_u8 (uint8x16_t a) - /// A64: ADDV Bd, Vn.16B + /// uint8_t vaddvq_u8 (uint8x16_t a) + /// A64: ADDV Bd, Vn.16B /// public static Vector64 AddAcross(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int16_t vaddvq_s16 (int16x8_t a) - /// A64: ADDV Hd, Vn.8H + /// int16_t vaddvq_s16 (int16x8_t a) + /// A64: ADDV Hd, Vn.8H /// public static Vector64 AddAcross(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int32_t vaddvq_s32 (int32x4_t a) - /// A64: ADDV Sd, Vn.4S + /// int32_t vaddvq_s32 (int32x4_t a) + /// A64: ADDV Sd, Vn.4S /// public static Vector64 AddAcross(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int8_t vaddvq_s8 (int8x16_t a) - /// A64: ADDV Bd, Vn.16B + /// int8_t vaddvq_s8 (int8x16_t a) + /// A64: ADDV Bd, Vn.16B /// public static Vector64 AddAcross(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vaddvq_u16 (uint16x8_t a) - /// A64: ADDV Hd, Vn.8H + /// uint16_t vaddvq_u16 (uint16x8_t a) + /// A64: ADDV Hd, Vn.8H /// public static Vector64 AddAcross(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vaddvq_u32 (uint32x4_t a) - /// A64: ADDV Sd, Vn.4S + /// uint32_t vaddvq_u32 (uint32x4_t a) + /// A64: ADDV Sd, Vn.4S /// public static Vector64 AddAcross(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vaddlv_u8 (uint8x8_t a) - /// A64: UADDLV Hd, Vn.8B + /// uint16_t vaddlv_u8 (uint8x8_t a) + /// A64: UADDLV Hd, Vn.8B /// public static Vector64 AddAcrossWidening(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int32_t vaddlv_s16 (int16x4_t a) - /// A64: SADDLV Sd, Vn.4H + /// int32_t vaddlv_s16 (int16x4_t a) + /// A64: SADDLV Sd, Vn.4H /// public static Vector64 AddAcrossWidening(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int16_t vaddlv_s8 (int8x8_t a) - /// A64: SADDLV Hd, Vn.8B + /// int16_t vaddlv_s8 (int8x8_t a) + /// A64: SADDLV Hd, Vn.8B /// public static Vector64 AddAcrossWidening(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vaddlv_u16 (uint16x4_t a) - /// A64: UADDLV Sd, Vn.4H + /// uint32_t vaddlv_u16 (uint16x4_t a) + /// A64: UADDLV Sd, Vn.4H /// public static Vector64 AddAcrossWidening(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vaddlvq_u8 (uint8x16_t a) - /// A64: UADDLV Hd, Vn.16B + /// uint16_t vaddlvq_u8 (uint8x16_t a) + /// A64: UADDLV Hd, Vn.16B /// public static Vector64 AddAcrossWidening(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int32_t vaddlvq_s16 (int16x8_t a) - /// A64: SADDLV Sd, Vn.8H + /// int32_t vaddlvq_s16 (int16x8_t a) + /// A64: SADDLV Sd, Vn.8H /// public static Vector64 AddAcrossWidening(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int64_t vaddlvq_s32 (int32x4_t a) - /// A64: SADDLV Dd, Vn.4S + /// int64_t vaddlvq_s32 (int32x4_t a) + /// A64: SADDLV Dd, Vn.4S /// public static Vector64 AddAcrossWidening(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int16_t vaddlvq_s8 (int8x16_t a) - /// A64: SADDLV Hd, Vn.16B + /// int16_t vaddlvq_s8 (int8x16_t a) + /// A64: SADDLV Hd, Vn.16B /// public static Vector64 AddAcrossWidening(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vaddlvq_u16 (uint16x8_t a) - /// A64: UADDLV Sd, Vn.8H + /// uint32_t vaddlvq_u16 (uint16x8_t a) + /// A64: UADDLV Sd, Vn.8H /// public static Vector64 AddAcrossWidening(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint64_t vaddlvq_u32 (uint32x4_t a) - /// A64: UADDLV Dd, Vn.4S + /// uint64_t vaddlvq_u32 (uint32x4_t a) + /// A64: UADDLV Dd, Vn.4S /// public static Vector64 AddAcrossWidening(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vpaddq_u8 (uint8x16_t a, uint8x16_t b) - /// A64: ADDP Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vpaddq_u8 (uint8x16_t a, uint8x16_t b) + /// A64: ADDP Vd.16B, Vn.16B, Vm.16B /// public static Vector128 AddPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vpaddq_f64 (float64x2_t a, float64x2_t b) - /// A64: FADDP Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vpaddq_f64 (float64x2_t a, float64x2_t b) + /// A64: FADDP Vd.2D, Vn.2D, Vm.2D /// public static Vector128 AddPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vpaddq_s16 (int16x8_t a, int16x8_t b) - /// A64: ADDP Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vpaddq_s16 (int16x8_t a, int16x8_t b) + /// A64: ADDP Vd.8H, Vn.8H, Vm.8H /// public static Vector128 AddPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vpaddq_s32 (int32x4_t a, int32x4_t b) - /// A64: ADDP Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vpaddq_s32 (int32x4_t a, int32x4_t b) + /// A64: ADDP Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AddPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vpaddq_s64 (int64x2_t a, int64x2_t b) - /// A64: ADDP Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vpaddq_s64 (int64x2_t a, int64x2_t b) + /// A64: ADDP Vd.2D, Vn.2D, Vm.2D /// public static Vector128 AddPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vpaddq_s8 (int8x16_t a, int8x16_t b) - /// A64: ADDP Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vpaddq_s8 (int8x16_t a, int8x16_t b) + /// A64: ADDP Vd.16B, Vn.16B, Vm.16B /// public static Vector128 AddPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vpaddq_f32 (float32x4_t a, float32x4_t b) - /// A64: FADDP Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vpaddq_f32 (float32x4_t a, float32x4_t b) + /// A64: FADDP Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AddPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vpaddq_u16 (uint16x8_t a, uint16x8_t b) - /// A64: ADDP Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vpaddq_u16 (uint16x8_t a, uint16x8_t b) + /// A64: ADDP Vd.8H, Vn.8H, Vm.8H /// public static Vector128 AddPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vpaddq_u32 (uint32x4_t a, uint32x4_t b) - /// A64: ADDP Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vpaddq_u32 (uint32x4_t a, uint32x4_t b) + /// A64: ADDP Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AddPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vpaddq_u64 (uint64x2_t a, uint64x2_t b) - /// A64: ADDP Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vpaddq_u64 (uint64x2_t a, uint64x2_t b) + /// A64: ADDP Vd.2D, Vn.2D, Vm.2D /// public static Vector128 AddPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32_t vpadds_f32 (float32x2_t a) - /// A64: FADDP Sd, Vn.2S + /// float32_t vpadds_f32 (float32x2_t a) + /// A64: FADDP Sd, Vn.2S /// public static Vector64 AddPairwiseScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float64_t vpaddd_f64 (float64x2_t a) - /// A64: FADDP Dd, Vn.2D + /// float64_t vpaddd_f64 (float64x2_t a) + /// A64: FADDP Dd, Vn.2D /// public static Vector64 AddPairwiseScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int64_t vpaddd_s64 (int64x2_t a) - /// A64: ADDP Dd, Vn.2D + /// int64_t vpaddd_s64 (int64x2_t a) + /// A64: ADDP Dd, Vn.2D /// public static Vector64 AddPairwiseScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint64_t vpaddd_u64 (uint64x2_t a) - /// A64: ADDP Dd, Vn.2D + /// uint64_t vpaddd_u64 (uint64x2_t a) + /// A64: ADDP Dd, Vn.2D /// public static Vector64 AddPairwiseScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vsqadd_u8 (uint8x8_t a, int8x8_t b) - /// A64: USQADD Vd.8B, Vn.8B + /// uint8x8_t vsqadd_u8 (uint8x8_t a, int8x8_t b) + /// A64: USQADD Vd.8B, Vn.8B /// public static Vector64 AddSaturate(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vuqadd_s16 (int16x4_t a, uint16x4_t b) - /// A64: SUQADD Vd.4H, Vn.4H + /// int16x4_t vuqadd_s16 (int16x4_t a, uint16x4_t b) + /// A64: SUQADD Vd.4H, Vn.4H /// public static Vector64 AddSaturate(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vuqadd_s32 (int32x2_t a, uint32x2_t b) - /// A64: SUQADD Vd.2S, Vn.2S + /// int32x2_t vuqadd_s32 (int32x2_t a, uint32x2_t b) + /// A64: SUQADD Vd.2S, Vn.2S /// public static Vector64 AddSaturate(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vuqadd_s8 (int8x8_t a, uint8x8_t b) - /// A64: SUQADD Vd.8B, Vn.8B + /// int8x8_t vuqadd_s8 (int8x8_t a, uint8x8_t b) + /// A64: SUQADD Vd.8B, Vn.8B /// public static Vector64 AddSaturate(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vsqadd_u16 (uint16x4_t a, int16x4_t b) - /// A64: USQADD Vd.4H, Vn.4H + /// uint16x4_t vsqadd_u16 (uint16x4_t a, int16x4_t b) + /// A64: USQADD Vd.4H, Vn.4H /// public static Vector64 AddSaturate(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vsqadd_u32 (uint32x2_t a, int32x2_t b) - /// A64: USQADD Vd.2S, Vn.2S + /// uint32x2_t vsqadd_u32 (uint32x2_t a, int32x2_t b) + /// A64: USQADD Vd.2S, Vn.2S /// public static Vector64 AddSaturate(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vsqaddq_u8 (uint8x16_t a, int8x16_t b) - /// A64: USQADD Vd.16B, Vn.16B + /// uint8x16_t vsqaddq_u8 (uint8x16_t a, int8x16_t b) + /// A64: USQADD Vd.16B, Vn.16B /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vuqaddq_s16 (int16x8_t a, uint16x8_t b) - /// A64: SUQADD Vd.8H, Vn.8H + /// int16x8_t vuqaddq_s16 (int16x8_t a, uint16x8_t b) + /// A64: SUQADD Vd.8H, Vn.8H /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vuqaddq_s32 (int32x4_t a, uint32x4_t b) - /// A64: SUQADD Vd.4S, Vn.4S + /// int32x4_t vuqaddq_s32 (int32x4_t a, uint32x4_t b) + /// A64: SUQADD Vd.4S, Vn.4S /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vuqaddq_s64 (int64x2_t a, uint64x2_t b) - /// A64: SUQADD Vd.2D, Vn.2D + /// int64x2_t vuqaddq_s64 (int64x2_t a, uint64x2_t b) + /// A64: SUQADD Vd.2D, Vn.2D /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vuqaddq_s8 (int8x16_t a, uint8x16_t b) - /// A64: SUQADD Vd.16B, Vn.16B + /// int8x16_t vuqaddq_s8 (int8x16_t a, uint8x16_t b) + /// A64: SUQADD Vd.16B, Vn.16B /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vsqaddq_u16 (uint16x8_t a, int16x8_t b) - /// A64: USQADD Vd.8H, Vn.8H + /// uint16x8_t vsqaddq_u16 (uint16x8_t a, int16x8_t b) + /// A64: USQADD Vd.8H, Vn.8H /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vsqaddq_u32 (uint32x4_t a, int32x4_t b) - /// A64: USQADD Vd.4S, Vn.4S + /// uint32x4_t vsqaddq_u32 (uint32x4_t a, int32x4_t b) + /// A64: USQADD Vd.4S, Vn.4S /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vsqaddq_u64 (uint64x2_t a, int64x2_t b) - /// A64: USQADD Vd.2D, Vn.2D + /// uint64x2_t vsqaddq_u64 (uint64x2_t a, int64x2_t b) + /// A64: USQADD Vd.2D, Vn.2D /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vqaddb_u8 (uint8_t a, uint8_t b) - /// A64: UQADD Bd, Bn, Bm + /// uint8_t vqaddb_u8 (uint8_t a, uint8_t b) + /// A64: UQADD Bd, Bn, Bm /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vsqaddb_u8 (uint8_t a, int8_t b) - /// A64: USQADD Bd, Bn + /// uint8_t vsqaddb_u8 (uint8_t a, int8_t b) + /// A64: USQADD Bd, Bn /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16_t vqaddh_s16 (int16_t a, int16_t b) - /// A64: SQADD Hd, Hn, Hm + /// int16_t vqaddh_s16 (int16_t a, int16_t b) + /// A64: SQADD Hd, Hn, Hm /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16_t vuqaddh_s16 (int16_t a, uint16_t b) - /// A64: SUQADD Hd, Hn + /// int16_t vuqaddh_s16 (int16_t a, uint16_t b) + /// A64: SUQADD Hd, Hn /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqadds_s32 (int32_t a, int32_t b) - /// A64: SQADD Sd, Sn, Sm + /// int32_t vqadds_s32 (int32_t a, int32_t b) + /// A64: SQADD Sd, Sn, Sm /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32_t vuqadds_s32 (int32_t a, uint32_t b) - /// A64: SUQADD Sd, Sn + /// int32_t vuqadds_s32 (int32_t a, uint32_t b) + /// A64: SUQADD Sd, Sn /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vuqadd_s64 (int64x1_t a, uint64x1_t b) - /// A64: SUQADD Dd, Dn + /// int64x1_t vuqadd_s64 (int64x1_t a, uint64x1_t b) + /// A64: SUQADD Dd, Dn /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8_t vqaddb_s8 (int8_t a, int8_t b) - /// A64: SQADD Bd, Bn, Bm + /// int8_t vqaddb_s8 (int8_t a, int8_t b) + /// A64: SQADD Bd, Bn, Bm /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8_t vuqaddb_s8 (int8_t a, uint8_t b) - /// A64: SUQADD Bd, Bn + /// int8_t vuqaddb_s8 (int8_t a, uint8_t b) + /// A64: SUQADD Bd, Bn /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vqaddh_u16 (uint16_t a, uint16_t b) - /// A64: UQADD Hd, Hn, Hm + /// uint16_t vqaddh_u16 (uint16_t a, uint16_t b) + /// A64: UQADD Hd, Hn, Hm /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vsqaddh_u16 (uint16_t a, int16_t b) - /// A64: USQADD Hd, Hn + /// uint16_t vsqaddh_u16 (uint16_t a, int16_t b) + /// A64: USQADD Hd, Hn /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vqadds_u32 (uint32_t a, uint32_t b) - /// A64: UQADD Sd, Sn, Sm + /// uint32_t vqadds_u32 (uint32_t a, uint32_t b) + /// A64: UQADD Sd, Sn, Sm /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vsqadds_u32 (uint32_t a, int32_t b) - /// A64: USQADD Sd, Sn + /// uint32_t vsqadds_u32 (uint32_t a, int32_t b) + /// A64: USQADD Sd, Sn /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vsqadd_u64 (uint64x1_t a, int64x1_t b) - /// A64: USQADD Dd, Dn + /// uint64x1_t vsqadd_u64 (uint64x1_t a, int64x1_t b) + /// A64: USQADD Dd, Dn /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vrndpq_f64 (float64x2_t a) - /// A64: FRINTP Vd.2D, Vn.2D + /// float64x2_t vrndpq_f64 (float64x2_t a) + /// A64: FRINTP Vd.2D, Vn.2D /// public static Vector128 Ceiling(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vceqq_f64 (float64x2_t a, float64x2_t b) - /// A64: FCMEQ Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vceqq_f64 (float64x2_t a, float64x2_t b) + /// A64: FCMEQ Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vceqq_s64 (int64x2_t a, int64x2_t b) - /// A64: CMEQ Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vceqq_s64 (int64x2_t a, int64x2_t b) + /// A64: CMEQ Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vceqq_u64 (uint64x2_t a, uint64x2_t b) - /// A64: CMEQ Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vceqq_u64 (uint64x2_t a, uint64x2_t b) + /// A64: CMEQ Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vceq_f64 (float64x1_t a, float64x1_t b) - /// A64: FCMEQ Dd, Dn, Dm + /// uint64x1_t vceq_f64 (float64x1_t a, float64x1_t b) + /// A64: FCMEQ Dd, Dn, Dm /// public static Vector64 CompareEqualScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vceq_s64 (int64x1_t a, int64x1_t b) - /// A64: CMEQ Dd, Dn, Dm + /// uint64x1_t vceq_s64 (int64x1_t a, int64x1_t b) + /// A64: CMEQ Dd, Dn, Dm /// public static Vector64 CompareEqualScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vceqs_f32 (float32_t a, float32_t b) - /// A64: FCMEQ Sd, Sn, Sm + /// uint32_t vceqs_f32 (float32_t a, float32_t b) + /// A64: FCMEQ Sd, Sn, Sm /// public static Vector64 CompareEqualScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vceq_u64 (uint64x1_t a, uint64x1_t b) - /// A64: CMEQ Dd, Dn, Dm + /// uint64x1_t vceq_u64 (uint64x1_t a, uint64x1_t b) + /// A64: CMEQ Dd, Dn, Dm /// public static Vector64 CompareEqualScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vcgtq_f64 (float64x2_t a, float64x2_t b) - /// A64: FCMGT Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcgtq_f64 (float64x2_t a, float64x2_t b) + /// A64: FCMGT Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vcgtq_s64 (int64x2_t a, int64x2_t b) - /// A64: CMGT Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcgtq_s64 (int64x2_t a, int64x2_t b) + /// A64: CMGT Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vcgtq_u64 (uint64x2_t a, uint64x2_t b) - /// A64: CMHI Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcgtq_u64 (uint64x2_t a, uint64x2_t b) + /// A64: CMHI Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vcgt_f64 (float64x1_t a, float64x1_t b) - /// A64: FCMGT Dd, Dn, Dm + /// uint64x1_t vcgt_f64 (float64x1_t a, float64x1_t b) + /// A64: FCMGT Dd, Dn, Dm /// public static Vector64 CompareGreaterThanScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vcgt_s64 (int64x1_t a, int64x1_t b) - /// A64: CMGT Dd, Dn, Dm + /// uint64x1_t vcgt_s64 (int64x1_t a, int64x1_t b) + /// A64: CMGT Dd, Dn, Dm /// public static Vector64 CompareGreaterThanScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vcgts_f32 (float32_t a, float32_t b) - /// A64: FCMGT Sd, Sn, Sm + /// uint32_t vcgts_f32 (float32_t a, float32_t b) + /// A64: FCMGT Sd, Sn, Sm /// public static Vector64 CompareGreaterThanScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vcgt_u64 (uint64x1_t a, uint64x1_t b) - /// A64: CMHI Dd, Dn, Dm + /// uint64x1_t vcgt_u64 (uint64x1_t a, uint64x1_t b) + /// A64: CMHI Dd, Dn, Dm /// public static Vector64 CompareGreaterThanScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vcgeq_f64 (float64x2_t a, float64x2_t b) - /// A64: FCMGE Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcgeq_f64 (float64x2_t a, float64x2_t b) + /// A64: FCMGE Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vcgeq_s64 (int64x2_t a, int64x2_t b) - /// A64: CMGE Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcgeq_s64 (int64x2_t a, int64x2_t b) + /// A64: CMGE Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vcgeq_u64 (uint64x2_t a, uint64x2_t b) - /// A64: CMHS Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcgeq_u64 (uint64x2_t a, uint64x2_t b) + /// A64: CMHS Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vcge_f64 (float64x1_t a, float64x1_t b) - /// A64: FCMGE Dd, Dn, Dm + /// uint64x1_t vcge_f64 (float64x1_t a, float64x1_t b) + /// A64: FCMGE Dd, Dn, Dm /// public static Vector64 CompareGreaterThanOrEqualScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vcge_s64 (int64x1_t a, int64x1_t b) - /// A64: CMGE Dd, Dn, Dm + /// uint64x1_t vcge_s64 (int64x1_t a, int64x1_t b) + /// A64: CMGE Dd, Dn, Dm /// public static Vector64 CompareGreaterThanOrEqualScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vcges_f32 (float32_t a, float32_t b) - /// A64: FCMGE Sd, Sn, Sm + /// uint32_t vcges_f32 (float32_t a, float32_t b) + /// A64: FCMGE Sd, Sn, Sm /// public static Vector64 CompareGreaterThanOrEqualScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vcge_u64 (uint64x1_t a, uint64x1_t b) - /// A64: CMHS Dd, Dn, Dm + /// uint64x1_t vcge_u64 (uint64x1_t a, uint64x1_t b) + /// A64: CMHS Dd, Dn, Dm /// public static Vector64 CompareGreaterThanOrEqualScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vcltq_f64 (float64x2_t a, float64x2_t b) - /// A64: FCMGT Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcltq_f64 (float64x2_t a, float64x2_t b) + /// A64: FCMGT Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vcltq_s64 (int64x2_t a, int64x2_t b) - /// A64: CMGT Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcltq_s64 (int64x2_t a, int64x2_t b) + /// A64: CMGT Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vcltq_u64 (uint64x2_t a, uint64x2_t b) - /// A64: CMHI Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcltq_u64 (uint64x2_t a, uint64x2_t b) + /// A64: CMHI Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vclt_f64 (float64x1_t a, float64x1_t b) - /// A64: FCMGT Dd, Dn, Dm + /// uint64x1_t vclt_f64 (float64x1_t a, float64x1_t b) + /// A64: FCMGT Dd, Dn, Dm /// public static Vector64 CompareLessThanScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vclt_s64 (int64x1_t a, int64x1_t b) - /// A64: CMGT Dd, Dn, Dm + /// uint64x1_t vclt_s64 (int64x1_t a, int64x1_t b) + /// A64: CMGT Dd, Dn, Dm /// public static Vector64 CompareLessThanScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vclts_f32 (float32_t a, float32_t b) - /// A64: FCMGT Sd, Sn, Sm + /// uint32_t vclts_f32 (float32_t a, float32_t b) + /// A64: FCMGT Sd, Sn, Sm /// public static Vector64 CompareLessThanScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vclt_u64 (uint64x1_t a, uint64x1_t b) - /// A64: CMHI Dd, Dn, Dm + /// uint64x1_t vclt_u64 (uint64x1_t a, uint64x1_t b) + /// A64: CMHI Dd, Dn, Dm /// public static Vector64 CompareLessThanScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vcleq_f64 (float64x2_t a, float64x2_t b) - /// A64: FCMGE Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcleq_f64 (float64x2_t a, float64x2_t b) + /// A64: FCMGE Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vcleq_s64 (int64x2_t a, int64x2_t b) - /// A64: CMGE Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcleq_s64 (int64x2_t a, int64x2_t b) + /// A64: CMGE Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vcleq_u64 (uint64x2_t a, uint64x2_t b) - /// A64: CMHS Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcleq_u64 (uint64x2_t a, uint64x2_t b) + /// A64: CMHS Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vcle_f64 (float64x1_t a, float64x1_t b) - /// A64: FCMGE Dd, Dn, Dm + /// uint64x1_t vcle_f64 (float64x1_t a, float64x1_t b) + /// A64: FCMGE Dd, Dn, Dm /// public static Vector64 CompareLessThanOrEqualScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vcle_s64 (int64x1_t a, int64x1_t b) - /// A64: CMGE Dd, Dn, Dm + /// uint64x1_t vcle_s64 (int64x1_t a, int64x1_t b) + /// A64: CMGE Dd, Dn, Dm /// public static Vector64 CompareLessThanOrEqualScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vcles_f32 (float32_t a, float32_t b) - /// A64: FCMGE Sd, Sn, Sm + /// uint32_t vcles_f32 (float32_t a, float32_t b) + /// A64: FCMGE Sd, Sn, Sm /// public static Vector64 CompareLessThanOrEqualScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vcle_u64 (uint64x1_t a, uint64x1_t b) - /// A64: CMHS Dd, Dn, Dm + /// uint64x1_t vcle_u64 (uint64x1_t a, uint64x1_t b) + /// A64: CMHS Dd, Dn, Dm /// public static Vector64 CompareLessThanOrEqualScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vtstq_f64 (float64x2_t a, float64x2_t b) - /// A64: CMTST Vd.2D, Vn.2D, Vm.2D - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// uint64x2_t vtstq_f64 (float64x2_t a, float64x2_t b) + /// A64: CMTST Vd.2D, Vn.2D, Vm.2D + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 CompareTest(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vtstq_s64 (int64x2_t a, int64x2_t b) - /// A64: CMTST Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vtstq_s64 (int64x2_t a, int64x2_t b) + /// A64: CMTST Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareTest(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vtstq_u64 (uint64x2_t a, uint64x2_t b) - /// A64: CMTST Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vtstq_u64 (uint64x2_t a, uint64x2_t b) + /// A64: CMTST Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareTest(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vtst_f64 (float64x1_t a, float64x1_t b) - /// A64: CMTST Dd, Dn, Dm - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// uint64x1_t vtst_f64 (float64x1_t a, float64x1_t b) + /// A64: CMTST Dd, Dn, Dm + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 CompareTestScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vtst_s64 (int64x1_t a, int64x1_t b) - /// A64: CMTST Dd, Dn, Dm + /// uint64x1_t vtst_s64 (int64x1_t a, int64x1_t b) + /// A64: CMTST Dd, Dn, Dm /// public static Vector64 CompareTestScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vtst_u64 (uint64x1_t a, uint64x1_t b) - /// A64: CMTST Dd, Dn, Dm + /// uint64x1_t vtst_u64 (uint64x1_t a, uint64x1_t b) + /// A64: CMTST Dd, Dn, Dm /// public static Vector64 CompareTestScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vcvt_f64_f32 (float32x2_t a) - /// A64: FCVTL Vd.2D, Vn.2S + /// float64x2_t vcvt_f64_f32 (float32x2_t a) + /// A64: FCVTL Vd.2D, Vn.2S /// public static Vector128 ConvertToDouble(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vcvtq_f64_s64 (int64x2_t a) - /// A64: SCVTF Vd.2D, Vn.2D + /// float64x2_t vcvtq_f64_s64 (int64x2_t a) + /// A64: SCVTF Vd.2D, Vn.2D /// public static Vector128 ConvertToDouble(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vcvtq_f64_u64 (uint64x2_t a) - /// A64: UCVTF Vd.2D, Vn.2D + /// float64x2_t vcvtq_f64_u64 (uint64x2_t a) + /// A64: UCVTF Vd.2D, Vn.2D /// public static Vector128 ConvertToDouble(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vcvt_f64_s64 (int64x1_t a) - /// A64: SCVTF Dd, Dn + /// float64x1_t vcvt_f64_s64 (int64x1_t a) + /// A64: SCVTF Dd, Dn /// public static Vector64 ConvertToDoubleScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vcvt_f64_u64 (uint64x1_t a) - /// A64: UCVTF Dd, Dn + /// float64x1_t vcvt_f64_u64 (uint64x1_t a) + /// A64: UCVTF Dd, Dn /// public static Vector64 ConvertToDoubleScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vcvt_high_f64_f32 (float32x4_t a) - /// A64: FCVTL2 Vd.2D, Vn.4S + /// float64x2_t vcvt_high_f64_f32 (float32x4_t a) + /// A64: FCVTL2 Vd.2D, Vn.4S /// public static Vector128 ConvertToDoubleUpper(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vcvtaq_s64_f64 (float64x2_t a) - /// A64: FCVTAS Vd.2D, Vn.2D + /// int64x2_t vcvtaq_s64_f64 (float64x2_t a) + /// A64: FCVTAS Vd.2D, Vn.2D /// public static Vector128 ConvertToInt64RoundAwayFromZero(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vcvta_s64_f64 (float64x1_t a) - /// A64: FCVTAS Dd, Dn + /// int64x1_t vcvta_s64_f64 (float64x1_t a) + /// A64: FCVTAS Dd, Dn /// public static Vector64 ConvertToInt64RoundAwayFromZeroScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vcvtnq_s64_f64 (float64x2_t a) - /// A64: FCVTNS Vd.2D, Vn.2D + /// int64x2_t vcvtnq_s64_f64 (float64x2_t a) + /// A64: FCVTNS Vd.2D, Vn.2D /// public static Vector128 ConvertToInt64RoundToEven(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vcvtn_s64_f64 (float64x1_t a) - /// A64: FCVTNS Dd, Dn + /// int64x1_t vcvtn_s64_f64 (float64x1_t a) + /// A64: FCVTNS Dd, Dn /// public static Vector64 ConvertToInt64RoundToEvenScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vcvtmq_s64_f64 (float64x2_t a) - /// A64: FCVTMS Vd.2D, Vn.2D + /// int64x2_t vcvtmq_s64_f64 (float64x2_t a) + /// A64: FCVTMS Vd.2D, Vn.2D /// public static Vector128 ConvertToInt64RoundToNegativeInfinity(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vcvtm_s64_f64 (float64x1_t a) - /// A64: FCVTMS Dd, Dn + /// int64x1_t vcvtm_s64_f64 (float64x1_t a) + /// A64: FCVTMS Dd, Dn /// public static Vector64 ConvertToInt64RoundToNegativeInfinityScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vcvtpq_s64_f64 (float64x2_t a) - /// A64: FCVTPS Vd.2D, Vn.2D + /// int64x2_t vcvtpq_s64_f64 (float64x2_t a) + /// A64: FCVTPS Vd.2D, Vn.2D /// public static Vector128 ConvertToInt64RoundToPositiveInfinity(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vcvtp_s64_f64 (float64x1_t a) - /// A64: FCVTPS Dd, Dn + /// int64x1_t vcvtp_s64_f64 (float64x1_t a) + /// A64: FCVTPS Dd, Dn /// public static Vector64 ConvertToInt64RoundToPositiveInfinityScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vcvtq_s64_f64 (float64x2_t a) - /// A64: FCVTZS Vd.2D, Vn.2D + /// int64x2_t vcvtq_s64_f64 (float64x2_t a) + /// A64: FCVTZS Vd.2D, Vn.2D /// public static Vector128 ConvertToInt64RoundToZero(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vcvt_s64_f64 (float64x1_t a) - /// A64: FCVTZS Dd, Dn + /// int64x1_t vcvt_s64_f64 (float64x1_t a) + /// A64: FCVTZS Dd, Dn /// public static Vector64 ConvertToInt64RoundToZeroScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vcvt_f32_f64 (float64x2_t a) - /// A64: FCVTN Vd.2S, Vn.2D + /// float32x2_t vcvt_f32_f64 (float64x2_t a) + /// A64: FCVTN Vd.2S, Vn.2D /// public static Vector64 ConvertToSingleLower(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vcvtx_f32_f64 (float64x2_t a) - /// A64: FCVTXN Vd.2S, Vn.2D + /// float32x2_t vcvtx_f32_f64 (float64x2_t a) + /// A64: FCVTXN Vd.2S, Vn.2D /// public static Vector64 ConvertToSingleRoundToOddLower(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vcvtx_high_f32_f64 (float32x2_t r, float64x2_t a) - /// A64: FCVTXN2 Vd.4S, Vn.2D + /// float32x4_t vcvtx_high_f32_f64 (float32x2_t r, float64x2_t a) + /// A64: FCVTXN2 Vd.4S, Vn.2D /// public static Vector128 ConvertToSingleRoundToOddUpper(Vector64 lower, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vcvt_high_f32_f64 (float32x2_t r, float64x2_t a) - /// A64: FCVTN2 Vd.4S, Vn.2D + /// float32x4_t vcvt_high_f32_f64 (float32x2_t r, float64x2_t a) + /// A64: FCVTN2 Vd.4S, Vn.2D /// public static Vector128 ConvertToSingleUpper(Vector64 lower, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vcvtaq_u64_f64 (float64x2_t a) - /// A64: FCVTAU Vd.2D, Vn.2D + /// uint64x2_t vcvtaq_u64_f64 (float64x2_t a) + /// A64: FCVTAU Vd.2D, Vn.2D /// public static Vector128 ConvertToUInt64RoundAwayFromZero(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vcvta_u64_f64 (float64x1_t a) - /// A64: FCVTAU Dd, Dn + /// uint64x1_t vcvta_u64_f64 (float64x1_t a) + /// A64: FCVTAU Dd, Dn /// public static Vector64 ConvertToUInt64RoundAwayFromZeroScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vcvtnq_u64_f64 (float64x2_t a) - /// A64: FCVTNU Vd.2D, Vn.2D + /// uint64x2_t vcvtnq_u64_f64 (float64x2_t a) + /// A64: FCVTNU Vd.2D, Vn.2D /// public static Vector128 ConvertToUInt64RoundToEven(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vcvtn_u64_f64 (float64x1_t a) - /// A64: FCVTNU Dd, Dn + /// uint64x1_t vcvtn_u64_f64 (float64x1_t a) + /// A64: FCVTNU Dd, Dn /// public static Vector64 ConvertToUInt64RoundToEvenScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vcvtmq_u64_f64 (float64x2_t a) - /// A64: FCVTMU Vd.2D, Vn.2D + /// uint64x2_t vcvtmq_u64_f64 (float64x2_t a) + /// A64: FCVTMU Vd.2D, Vn.2D /// public static Vector128 ConvertToUInt64RoundToNegativeInfinity(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vcvtm_u64_f64 (float64x1_t a) - /// A64: FCVTMU Dd, Dn + /// uint64x1_t vcvtm_u64_f64 (float64x1_t a) + /// A64: FCVTMU Dd, Dn /// public static Vector64 ConvertToUInt64RoundToNegativeInfinityScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vcvtpq_u64_f64 (float64x2_t a) - /// A64: FCVTPU Vd.2D, Vn.2D + /// uint64x2_t vcvtpq_u64_f64 (float64x2_t a) + /// A64: FCVTPU Vd.2D, Vn.2D /// public static Vector128 ConvertToUInt64RoundToPositiveInfinity(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vcvtp_u64_f64 (float64x1_t a) - /// A64: FCVTPU Dd, Dn + /// uint64x1_t vcvtp_u64_f64 (float64x1_t a) + /// A64: FCVTPU Dd, Dn /// public static Vector64 ConvertToUInt64RoundToPositiveInfinityScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vcvtq_u64_f64 (float64x2_t a) - /// A64: FCVTZU Vd.2D, Vn.2D + /// uint64x2_t vcvtq_u64_f64 (float64x2_t a) + /// A64: FCVTZU Vd.2D, Vn.2D /// public static Vector128 ConvertToUInt64RoundToZero(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vcvt_u64_f64 (float64x1_t a) - /// A64: FCVTZU Dd, Dn + /// uint64x1_t vcvt_u64_f64 (float64x1_t a) + /// A64: FCVTZU Dd, Dn /// public static Vector64 ConvertToUInt64RoundToZeroScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vdiv_f32 (float32x2_t a, float32x2_t b) - /// A64: FDIV Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vdiv_f32 (float32x2_t a, float32x2_t b) + /// A64: FDIV Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Divide(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vdivq_f64 (float64x2_t a, float64x2_t b) - /// A64: FDIV Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vdivq_f64 (float64x2_t a, float64x2_t b) + /// A64: FDIV Vd.2D, Vn.2D, Vm.2D /// public static Vector128 Divide(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vdivq_f32 (float32x4_t a, float32x4_t b) - /// A64: FDIV Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vdivq_f32 (float32x4_t a, float32x4_t b) + /// A64: FDIV Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Divide(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vdupq_laneq_f64 (float64x2_t vec, const int lane) - /// A64: DUP Vd.2D, Vn.D[index] + /// float64x2_t vdupq_laneq_f64 (float64x2_t vec, const int lane) + /// A64: DUP Vd.2D, Vn.D[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector128 value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vdupq_laneq_s64 (int64x2_t vec, const int lane) - /// A64: DUP Vd.2D, Vn.D[index] + /// int64x2_t vdupq_laneq_s64 (int64x2_t vec, const int lane) + /// A64: DUP Vd.2D, Vn.D[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector128 value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vdupq_laneq_u64 (uint64x2_t vec, const int lane) - /// A64: DUP Vd.2D, Vn.D[index] + /// uint64x2_t vdupq_laneq_u64 (uint64x2_t vec, const int lane) + /// A64: DUP Vd.2D, Vn.D[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector128 value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vdupq_n_f64 (float64_t value) - /// A64: DUP Vd.2D, Vn.D[0] + /// float64x2_t vdupq_n_f64 (float64_t value) + /// A64: DUP Vd.2D, Vn.D[0] /// public static Vector128 DuplicateToVector128(double value) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vdupq_n_s64 (int64_t value) - /// A64: DUP Vd.2D, Rn + /// int64x2_t vdupq_n_s64 (int64_t value) + /// A64: DUP Vd.2D, Rn /// public static Vector128 DuplicateToVector128(long value) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vdupq_n_s64 (uint64_t value) - /// A64: DUP Vd.2D, Rn + /// uint64x2_t vdupq_n_s64 (uint64_t value) + /// A64: DUP Vd.2D, Rn /// public static Vector128 DuplicateToVector128(ulong value) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vqmovnh_u16 (uint16_t a) - /// A64: UQXTN Bd, Hn + /// uint8_t vqmovnh_u16 (uint16_t a) + /// A64: UQXTN Bd, Hn /// public static Vector64 ExtractNarrowingSaturateScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int16_t vqmovns_s32 (int32_t a) - /// A64: SQXTN Hd, Sn + /// int16_t vqmovns_s32 (int32_t a) + /// A64: SQXTN Hd, Sn /// public static Vector64 ExtractNarrowingSaturateScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqmovnd_s64 (int64_t a) - /// A64: SQXTN Sd, Dn + /// int32_t vqmovnd_s64 (int64_t a) + /// A64: SQXTN Sd, Dn /// public static Vector64 ExtractNarrowingSaturateScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int8_t vqmovnh_s16 (int16_t a) - /// A64: SQXTN Bd, Hn + /// int8_t vqmovnh_s16 (int16_t a) + /// A64: SQXTN Bd, Hn /// public static Vector64 ExtractNarrowingSaturateScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vqmovns_u32 (uint32_t a) - /// A64: UQXTN Hd, Sn + /// uint16_t vqmovns_u32 (uint32_t a) + /// A64: UQXTN Hd, Sn /// public static Vector64 ExtractNarrowingSaturateScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vqmovnd_u64 (uint64_t a) - /// A64: UQXTN Sd, Dn + /// uint32_t vqmovnd_u64 (uint64_t a) + /// A64: UQXTN Sd, Dn /// public static Vector64 ExtractNarrowingSaturateScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vqmovunh_s16 (int16_t a) - /// A64: SQXTUN Bd, Hn + /// uint8_t vqmovunh_s16 (int16_t a) + /// A64: SQXTUN Bd, Hn /// public static Vector64 ExtractNarrowingSaturateUnsignedScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vqmovuns_s32 (int32_t a) - /// A64: SQXTUN Hd, Sn + /// uint16_t vqmovuns_s32 (int32_t a) + /// A64: SQXTUN Hd, Sn /// public static Vector64 ExtractNarrowingSaturateUnsignedScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vqmovund_s64 (int64_t a) - /// A64: SQXTUN Sd, Dn + /// uint32_t vqmovund_s64 (int64_t a) + /// A64: SQXTUN Sd, Dn /// public static Vector64 ExtractNarrowingSaturateUnsignedScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vrndmq_f64 (float64x2_t a) - /// A64: FRINTM Vd.2D, Vn.2D + /// float64x2_t vrndmq_f64 (float64x2_t a) + /// A64: FRINTM Vd.2D, Vn.2D /// public static Vector128 Floor(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vfmaq_f64 (float64x2_t a, float64x2_t b, float64x2_t c) - /// A64: FMLA Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vfmaq_f64 (float64x2_t a, float64x2_t b, float64x2_t c) + /// A64: FMLA Vd.2D, Vn.2D, Vm.2D /// public static Vector128 FusedMultiplyAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vfma_n_f32 (float32x2_t a, float32x2_t b, float32_t n) - /// A64: FMLA Vd.2S, Vn.2S, Vm.S[0] + /// float32x2_t vfma_n_f32 (float32x2_t a, float32x2_t b, float32_t n) + /// A64: FMLA Vd.2S, Vn.2S, Vm.S[0] /// public static Vector64 FusedMultiplyAddByScalar(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vfmaq_n_f64 (float64x2_t a, float64x2_t b, float64_t n) - /// A64: FMLA Vd.2D, Vn.2D, Vm.D[0] + /// float64x2_t vfmaq_n_f64 (float64x2_t a, float64x2_t b, float64_t n) + /// A64: FMLA Vd.2D, Vn.2D, Vm.D[0] /// public static Vector128 FusedMultiplyAddByScalar(Vector128 addend, Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vfmaq_n_f32 (float32x4_t a, float32x4_t b, float32_t n) - /// A64: FMLA Vd.4S, Vn.4S, Vm.S[0] + /// float32x4_t vfmaq_n_f32 (float32x4_t a, float32x4_t b, float32_t n) + /// A64: FMLA Vd.4S, Vn.4S, Vm.S[0] /// public static Vector128 FusedMultiplyAddByScalar(Vector128 addend, Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vfma_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane) - /// A64: FMLA Vd.2S, Vn.2S, Vm.S[lane] + /// float32x2_t vfma_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane) + /// A64: FMLA Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 FusedMultiplyAddBySelectedScalar(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vfma_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane) - /// A64: FMLA Vd.2S, Vn.2S, Vm.S[lane] + /// float32x2_t vfma_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane) + /// A64: FMLA Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 FusedMultiplyAddBySelectedScalar(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vfmaq_laneq_f64 (float64x2_t a, float64x2_t b, float64x2_t v, const int lane) - /// A64: FMLA Vd.2D, Vn.2D, Vm.D[lane] + /// float64x2_t vfmaq_laneq_f64 (float64x2_t a, float64x2_t b, float64x2_t v, const int lane) + /// A64: FMLA Vd.2D, Vn.2D, Vm.D[lane] /// public static Vector128 FusedMultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vfmaq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane) - /// A64: FMLA Vd.4S, Vn.4S, Vm.S[lane] + /// float32x4_t vfmaq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane) + /// A64: FMLA Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 FusedMultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vfmaq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane) - /// A64: FMLA Vd.4S, Vn.4S, Vm.S[lane] + /// float32x4_t vfmaq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane) + /// A64: FMLA Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 FusedMultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float64_t vfmad_laneq_f64 (float64_t a, float64_t b, float64x2_t v, const int lane) - /// A64: FMLA Dd, Dn, Vm.D[lane] + /// float64_t vfmad_laneq_f64 (float64_t a, float64_t b, float64x2_t v, const int lane) + /// A64: FMLA Dd, Dn, Vm.D[lane] /// public static Vector64 FusedMultiplyAddScalarBySelectedScalar(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float32_t vfmas_lane_f32 (float32_t a, float32_t b, float32x2_t v, const int lane) - /// A64: FMLA Sd, Sn, Vm.S[lane] + /// float32_t vfmas_lane_f32 (float32_t a, float32_t b, float32x2_t v, const int lane) + /// A64: FMLA Sd, Sn, Vm.S[lane] /// public static Vector64 FusedMultiplyAddScalarBySelectedScalar(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float32_t vfmas_laneq_f32 (float32_t a, float32_t b, float32x4_t v, const int lane) - /// A64: FMLA Sd, Sn, Vm.S[lane] + /// float32_t vfmas_laneq_f32 (float32_t a, float32_t b, float32x4_t v, const int lane) + /// A64: FMLA Sd, Sn, Vm.S[lane] /// public static Vector64 FusedMultiplyAddScalarBySelectedScalar(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vfmsq_f64 (float64x2_t a, float64x2_t b, float64x2_t c) - /// A64: FMLS Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vfmsq_f64 (float64x2_t a, float64x2_t b, float64x2_t c) + /// A64: FMLS Vd.2D, Vn.2D, Vm.2D /// public static Vector128 FusedMultiplySubtract(Vector128 minuend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vfms_n_f32 (float32x2_t a, float32x2_t b, float32_t n) - /// A64: FMLS Vd.2S, Vn.2S, Vm.S[0] + /// float32x2_t vfms_n_f32 (float32x2_t a, float32x2_t b, float32_t n) + /// A64: FMLS Vd.2S, Vn.2S, Vm.S[0] /// public static Vector64 FusedMultiplySubtractByScalar(Vector64 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vfmsq_n_f64 (float64x2_t a, float64x2_t b, float64_t n) - /// A64: FMLS Vd.2D, Vn.2D, Vm.D[0] + /// float64x2_t vfmsq_n_f64 (float64x2_t a, float64x2_t b, float64_t n) + /// A64: FMLS Vd.2D, Vn.2D, Vm.D[0] /// public static Vector128 FusedMultiplySubtractByScalar(Vector128 minuend, Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vfmsq_n_f32 (float32x4_t a, float32x4_t b, float32_t n) - /// A64: FMLS Vd.4S, Vn.4S, Vm.S[0] + /// float32x4_t vfmsq_n_f32 (float32x4_t a, float32x4_t b, float32_t n) + /// A64: FMLS Vd.4S, Vn.4S, Vm.S[0] /// public static Vector128 FusedMultiplySubtractByScalar(Vector128 minuend, Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vfms_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane) - /// A64: FMLS Vd.2S, Vn.2S, Vm.S[lane] + /// float32x2_t vfms_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane) + /// A64: FMLS Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 FusedMultiplySubtractBySelectedScalar(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vfms_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane) - /// A64: FMLS Vd.2S, Vn.2S, Vm.S[lane] + /// float32x2_t vfms_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane) + /// A64: FMLS Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 FusedMultiplySubtractBySelectedScalar(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vfmsq_laneq_f64 (float64x2_t a, float64x2_t b, float64x2_t v, const int lane) - /// A64: FMLS Vd.2D, Vn.2D, Vm.D[lane] + /// float64x2_t vfmsq_laneq_f64 (float64x2_t a, float64x2_t b, float64x2_t v, const int lane) + /// A64: FMLS Vd.2D, Vn.2D, Vm.D[lane] /// public static Vector128 FusedMultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vfmsq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane) - /// A64: FMLS Vd.4S, Vn.4S, Vm.S[lane] + /// float32x4_t vfmsq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane) + /// A64: FMLS Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 FusedMultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vfmsq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane) - /// A64: FMLS Vd.4S, Vn.4S, Vm.S[lane] + /// float32x4_t vfmsq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane) + /// A64: FMLS Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 FusedMultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float64_t vfmsd_laneq_f64 (float64_t a, float64_t b, float64x2_t v, const int lane) - /// A64: FMLS Dd, Dn, Vm.D[lane] + /// float64_t vfmsd_laneq_f64 (float64_t a, float64_t b, float64x2_t v, const int lane) + /// A64: FMLS Dd, Dn, Vm.D[lane] /// public static Vector64 FusedMultiplySubtractScalarBySelectedScalar(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float32_t vfmss_lane_f32 (float32_t a, float32_t b, float32x2_t v, const int lane) - /// A64: FMLS Sd, Sn, Vm.S[lane] + /// float32_t vfmss_lane_f32 (float32_t a, float32_t b, float32x2_t v, const int lane) + /// A64: FMLS Sd, Sn, Vm.S[lane] /// public static Vector64 FusedMultiplySubtractScalarBySelectedScalar(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float32_t vfmss_laneq_f32 (float32_t a, float32_t b, float32x4_t v, const int lane) - /// A64: FMLS Sd, Sn, Vm.S[lane] + /// float32_t vfmss_laneq_f32 (float32_t a, float32_t b, float32x4_t v, const int lane) + /// A64: FMLS Sd, Sn, Vm.S[lane] /// public static Vector64 FusedMultiplySubtractScalarBySelectedScalar(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vcopy_lane_u8 (uint8x8_t a, const int lane1, uint8x8_t b, const int lane2) - /// A64: INS Vd.B[lane1], Vn.B[lane2] + /// uint8x8_t vcopy_lane_u8 (uint8x8_t a, const int lane1, uint8x8_t b, const int lane2) + /// A64: INS Vd.B[lane1], Vn.B[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vcopy_laneq_u8 (uint8x8_t a, const int lane1, uint8x16_t b, const int lane2) - /// A64: INS Vd.B[lane1], Vn.B[lane2] + /// uint8x8_t vcopy_laneq_u8 (uint8x8_t a, const int lane1, uint8x16_t b, const int lane2) + /// A64: INS Vd.B[lane1], Vn.B[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(15))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vcopy_lane_s16 (int16x4_t a, const int lane1, int16x4_t b, const int lane2) - /// A64: INS Vd.H[lane1], Vn.H[lane2] + /// int16x4_t vcopy_lane_s16 (int16x4_t a, const int lane1, int16x4_t b, const int lane2) + /// A64: INS Vd.H[lane1], Vn.H[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vcopy_laneq_s16 (int16x4_t a, const int lane1, int16x8_t b, const int lane2) - /// A64: INS Vd.H[lane1], Vn.H[lane2] + /// int16x4_t vcopy_laneq_s16 (int16x4_t a, const int lane1, int16x8_t b, const int lane2) + /// A64: INS Vd.H[lane1], Vn.H[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vcopy_lane_s32 (int32x2_t a, const int lane1, int32x2_t b, const int lane2) - /// A64: INS Vd.S[lane1], Vn.S[lane2] + /// int32x2_t vcopy_lane_s32 (int32x2_t a, const int lane1, int32x2_t b, const int lane2) + /// A64: INS Vd.S[lane1], Vn.S[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vcopy_laneq_s32 (int32x2_t a, const int lane1, int32x4_t b, const int lane2) - /// A64: INS Vd.S[lane1], Vn.S[lane2] + /// int32x2_t vcopy_laneq_s32 (int32x2_t a, const int lane1, int32x4_t b, const int lane2) + /// A64: INS Vd.S[lane1], Vn.S[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vcopy_lane_s8 (int8x8_t a, const int lane1, int8x8_t b, const int lane2) - /// A64: INS Vd.B[lane1], Vn.B[lane2] + /// int8x8_t vcopy_lane_s8 (int8x8_t a, const int lane1, int8x8_t b, const int lane2) + /// A64: INS Vd.B[lane1], Vn.B[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vcopy_laneq_s8 (int8x8_t a, const int lane1, int8x16_t b, const int lane2) - /// A64: INS Vd.B[lane1], Vn.B[lane2] + /// int8x8_t vcopy_laneq_s8 (int8x8_t a, const int lane1, int8x16_t b, const int lane2) + /// A64: INS Vd.B[lane1], Vn.B[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(15))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vcopy_lane_f32 (float32x2_t a, const int lane1, float32x2_t b, const int lane2) - /// A64: INS Vd.S[lane1], Vn.S[lane2] + /// float32x2_t vcopy_lane_f32 (float32x2_t a, const int lane1, float32x2_t b, const int lane2) + /// A64: INS Vd.S[lane1], Vn.S[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vcopy_laneq_f32 (float32x2_t a, const int lane1, float32x4_t b, const int lane2) - /// A64: INS Vd.S[lane1], Vn.S[lane2] + /// float32x2_t vcopy_laneq_f32 (float32x2_t a, const int lane1, float32x4_t b, const int lane2) + /// A64: INS Vd.S[lane1], Vn.S[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vcopy_lane_u16 (uint16x4_t a, const int lane1, uint16x4_t b, const int lane2) - /// A64: INS Vd.H[lane1], Vn.H[lane2] + /// uint16x4_t vcopy_lane_u16 (uint16x4_t a, const int lane1, uint16x4_t b, const int lane2) + /// A64: INS Vd.H[lane1], Vn.H[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vcopy_laneq_u16 (uint16x4_t a, const int lane1, uint16x8_t b, const int lane2) - /// A64: INS Vd.H[lane1], Vn.H[lane2] + /// uint16x4_t vcopy_laneq_u16 (uint16x4_t a, const int lane1, uint16x8_t b, const int lane2) + /// A64: INS Vd.H[lane1], Vn.H[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vcopy_lane_u32 (uint32x2_t a, const int lane1, uint32x2_t b, const int lane2) - /// A64: INS Vd.S[lane1], Vn.S[lane2] + /// uint32x2_t vcopy_lane_u32 (uint32x2_t a, const int lane1, uint32x2_t b, const int lane2) + /// A64: INS Vd.S[lane1], Vn.S[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vcopy_laneq_u32 (uint32x2_t a, const int lane1, uint32x4_t b, const int lane2) - /// A64: INS Vd.S[lane1], Vn.S[lane2] + /// uint32x2_t vcopy_laneq_u32 (uint32x2_t a, const int lane1, uint32x4_t b, const int lane2) + /// A64: INS Vd.S[lane1], Vn.S[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vcopyq_lane_u8 (uint8x16_t a, const int lane1, uint8x8_t b, const int lane2) - /// A64: INS Vd.B[lane1], Vn.B[lane2] + /// uint8x16_t vcopyq_lane_u8 (uint8x16_t a, const int lane1, uint8x8_t b, const int lane2) + /// A64: INS Vd.B[lane1], Vn.B[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(15))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vcopyq_laneq_u8 (uint8x16_t a, const int lane1, uint8x16_t b, const int lane2) - /// A64: INS Vd.B[lane1], Vn.B[lane2] + /// uint8x16_t vcopyq_laneq_u8 (uint8x16_t a, const int lane1, uint8x16_t b, const int lane2) + /// A64: INS Vd.B[lane1], Vn.B[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(15))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(15))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vcopyq_laneq_f64 (float64x2_t a, const int lane1, float64x2_t b, const int lane2) - /// A64: INS Vd.D[lane1], Vn.D[lane2] + /// float64x2_t vcopyq_laneq_f64 (float64x2_t a, const int lane1, float64x2_t b, const int lane2) + /// A64: INS Vd.D[lane1], Vn.D[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vcopyq_lane_s16 (int16x8_t a, const int lane1, int16x4_t b, const int lane2) - /// A64: INS Vd.H[lane1], Vn.H[lane2] + /// int16x8_t vcopyq_lane_s16 (int16x8_t a, const int lane1, int16x4_t b, const int lane2) + /// A64: INS Vd.H[lane1], Vn.H[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vcopyq_laneq_s16 (int16x8_t a, const int lane1, int16x8_t b, const int lane2) - /// A64: INS Vd.H[lane1], Vn.H[lane2] + /// int16x8_t vcopyq_laneq_s16 (int16x8_t a, const int lane1, int16x8_t b, const int lane2) + /// A64: INS Vd.H[lane1], Vn.H[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vcopyq_lane_s32 (int32x4_t a, const int lane1, int32x2_t b, const int lane2) - /// A64: INS Vd.S[lane1], Vn.S[lane2] + /// int32x4_t vcopyq_lane_s32 (int32x4_t a, const int lane1, int32x2_t b, const int lane2) + /// A64: INS Vd.S[lane1], Vn.S[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vcopyq_laneq_s32 (int32x4_t a, const int lane1, int32x4_t b, const int lane2) - /// A64: INS Vd.S[lane1], Vn.S[lane2] + /// int32x4_t vcopyq_laneq_s32 (int32x4_t a, const int lane1, int32x4_t b, const int lane2) + /// A64: INS Vd.S[lane1], Vn.S[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vcopyq_laneq_s64 (int64x2_t a, const int lane1, int64x2_t b, const int lane2) - /// A64: INS Vd.D[lane1], Vn.D[lane2] + /// int64x2_t vcopyq_laneq_s64 (int64x2_t a, const int lane1, int64x2_t b, const int lane2) + /// A64: INS Vd.D[lane1], Vn.D[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vcopyq_lane_s8 (int8x16_t a, const int lane1, int8x8_t b, const int lane2) - /// A64: INS Vd.B[lane1], Vn.B[lane2] + /// int8x16_t vcopyq_lane_s8 (int8x16_t a, const int lane1, int8x8_t b, const int lane2) + /// A64: INS Vd.B[lane1], Vn.B[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(15))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vcopyq_laneq_s8 (int8x16_t a, const int lane1, int8x16_t b, const int lane2) - /// A64: INS Vd.B[lane1], Vn.B[lane2] + /// int8x16_t vcopyq_laneq_s8 (int8x16_t a, const int lane1, int8x16_t b, const int lane2) + /// A64: INS Vd.B[lane1], Vn.B[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(15))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(15))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vcopyq_lane_f32 (float32x4_t a, const int lane1, float32x2_t b, const int lane2) - /// A64: INS Vd.S[lane1], Vn.S[lane2] + /// float32x4_t vcopyq_lane_f32 (float32x4_t a, const int lane1, float32x2_t b, const int lane2) + /// A64: INS Vd.S[lane1], Vn.S[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vcopyq_laneq_f32 (float32x4_t a, const int lane1, float32x4_t b, const int lane2) - /// A64: INS Vd.S[lane1], Vn.S[lane2] + /// float32x4_t vcopyq_laneq_f32 (float32x4_t a, const int lane1, float32x4_t b, const int lane2) + /// A64: INS Vd.S[lane1], Vn.S[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vcopyq_lane_u16 (uint16x8_t a, const int lane1, uint16x4_t b, const int lane2) - /// A64: INS Vd.H[lane1], Vn.H[lane2] + /// uint16x8_t vcopyq_lane_u16 (uint16x8_t a, const int lane1, uint16x4_t b, const int lane2) + /// A64: INS Vd.H[lane1], Vn.H[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vcopyq_laneq_u16 (uint16x8_t a, const int lane1, uint16x8_t b, const int lane2) - /// A64: INS Vd.H[lane1], Vn.H[lane2] + /// uint16x8_t vcopyq_laneq_u16 (uint16x8_t a, const int lane1, uint16x8_t b, const int lane2) + /// A64: INS Vd.H[lane1], Vn.H[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vcopyq_lane_u32 (uint32x4_t a, const int lane1, uint32x2_t b, const int lane2) - /// A64: INS Vd.S[lane1], Vn.S[lane2] + /// uint32x4_t vcopyq_lane_u32 (uint32x4_t a, const int lane1, uint32x2_t b, const int lane2) + /// A64: INS Vd.S[lane1], Vn.S[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vcopyq_laneq_u32 (uint32x4_t a, const int lane1, uint32x4_t b, const int lane2) - /// A64: INS Vd.S[lane1], Vn.S[lane2] + /// uint32x4_t vcopyq_laneq_u32 (uint32x4_t a, const int lane1, uint32x4_t b, const int lane2) + /// A64: INS Vd.S[lane1], Vn.S[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vcopyq_laneq_u64 (uint64x2_t a, const int lane1, uint64x2_t b, const int lane2) - /// A64: INS Vd.D[lane1], Vn.D[lane2] + /// uint64x2_t vcopyq_laneq_u64 (uint64x2_t a, const int lane1, uint64x2_t b, const int lane2) + /// A64: INS Vd.D[lane1], Vn.D[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.16B, Vn+1.16B }[Vm], [Xn] - /// + /// A64: LD2 { Vn.16B, Vn+1.16B }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndInsertScalar((Vector128, Vector128) values, [ConstantExpected(Max = (byte)(15))] byte index, byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.16B, Vn+1.16B }[Vm], [Xn] - /// + /// A64: LD2 { Vn.16B, Vn+1.16B }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndInsertScalar((Vector128, Vector128) values, [ConstantExpected(Max = (byte)(15))] byte index, sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.8H, Vn+1.8H }[Vm], [Xn] - /// + /// A64: LD2 { Vn.8H, Vn+1.8H }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndInsertScalar((Vector128, Vector128) values, [ConstantExpected(Max = (byte)(7))] byte index, short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.8H, Vn+1.8H }[Vm], [Xn] - /// + /// A64: LD2 { Vn.8H, Vn+1.8H }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndInsertScalar((Vector128, Vector128) values, [ConstantExpected(Max = (byte)(7))] byte index, ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.4S, Vn+1.4S }[Vm], [Xn] - /// + /// A64: LD2 { Vn.4S, Vn+1.4S }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndInsertScalar((Vector128, Vector128) values, [ConstantExpected(Max = (byte)(3))] byte index, int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.4S, Vn+1.4S }[Vm], [Xn] - /// + /// A64: LD2 { Vn.4S, Vn+1.4S }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndInsertScalar((Vector128, Vector128) values, [ConstantExpected(Max = (byte)(3))] byte index, uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.2D, Vn+1.2D }[Vm], [Xn] - /// + /// A64: LD2 { Vn.2D, Vn+1.2D }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndInsertScalar((Vector128, Vector128) values, [ConstantExpected(Max = (byte)(1))] byte index, long* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.2D, Vn+1.2D }[Vm], [Xn] - /// + /// A64: LD2 { Vn.2D, Vn+1.2D }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndInsertScalar((Vector128, Vector128) values, [ConstantExpected(Max = (byte)(1))] byte index, ulong* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.4S, Vn+1.4S }[Vm], [Xn] - /// + /// A64: LD2 { Vn.4S, Vn+1.4S }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndInsertScalar((Vector128, Vector128) values, [ConstantExpected(Max = (byte)(3))] byte index, float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.2D, Vn+1.2D }[Vm], [Xn] - /// + /// A64: LD2 { Vn.2D, Vn+1.2D }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndInsertScalar((Vector128, Vector128) values, [ConstantExpected(Max = (byte)(1))] byte index, double* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.16B, Vn+1.16B, Vn+2.16B }[Vm], [Xn] - /// + /// A64: LD3 { Vn.16B, Vn+1.16B, Vn+2.16B }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndInsertScalar((Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(15))] byte index, byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.16B, Vn+1.16B, Vn+2.16B }[Vm], [Xn] - /// + /// A64: LD3 { Vn.16B, Vn+1.16B, Vn+2.16B }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndInsertScalar((Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(15))] byte index, sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.8H, Vn+1.8H, Vn+2.8H }[Vm], [Xn] - /// + /// A64: LD3 { Vn.8H, Vn+1.8H, Vn+2.8H }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndInsertScalar((Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(7))] byte index, short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.8H, Vn+1.8H, Vn+2.8H }[Vm], [Xn] - /// + /// A64: LD3 { Vn.8H, Vn+1.8H, Vn+2.8H }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndInsertScalar((Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(7))] byte index, ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }[Vm], [Xn] - /// + /// A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndInsertScalar((Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(3))] byte index, int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }[Vm], [Xn] - /// + /// A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndInsertScalar((Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(3))] byte index, uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }[Vm], [Xn] - /// + /// A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndInsertScalar((Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(1))] byte index, long* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }[Vm], [Xn] - /// + /// A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndInsertScalar((Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(1))] byte index, ulong* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }[Vm], [Xn] - /// + /// A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndInsertScalar((Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(3))] byte index, float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }[Vm], [Xn] - /// + /// A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndInsertScalar((Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(1))] byte index, double* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }[Vm], [Xn] - /// + /// A64: LD4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndInsertScalar((Vector128, Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(15))] byte index, byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }[Vm], [Xn] - /// + /// A64: LD4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndInsertScalar((Vector128, Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(15))] byte index, sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }[Vm], [Xn] - /// + /// A64: LD4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndInsertScalar((Vector128, Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(7))] byte index, short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }[Vm], [Xn] - /// + /// A64: LD4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndInsertScalar((Vector128, Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(7))] byte index, ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }[Vm], [Xn] - /// + /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndInsertScalar((Vector128, Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(3))] byte index, int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }[Vm], [Xn] - /// + /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndInsertScalar((Vector128, Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(3))] byte index, uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }[Vm], [Xn] - /// + /// A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndInsertScalar((Vector128, Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(1))] byte index, long* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }[Vm], [Xn] - /// + /// A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndInsertScalar((Vector128, Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(1))] byte index, ulong* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }[Vm], [Xn] - /// + /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndInsertScalar((Vector128, Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(3))] byte index, float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }[Vm], [Xn] - /// + /// A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndInsertScalar((Vector128, Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(1))] byte index, double* address) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vld1q_dup_f64 (float64_t const * ptr) - /// A64: LD1R { Vt.2D }, [Xn] + /// float64x2_t vld1q_dup_f64 (float64_t const * ptr) + /// A64: LD1R { Vt.2D }, [Xn] /// public static unsafe Vector128 LoadAndReplicateToVector128(double* address) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vld1q_dup_s64 (int64_t const * ptr) - /// A64: LD1R { Vt.2D }, [Xn] + /// int64x2_t vld1q_dup_s64 (int64_t const * ptr) + /// A64: LD1R { Vt.2D }, [Xn] /// public static unsafe Vector128 LoadAndReplicateToVector128(long* address) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vld1q_dup_u64 (uint64_t const * ptr) - /// A64: LD1R { Vt.2D }, [Xn] + /// uint64x2_t vld1q_dup_u64 (uint64_t const * ptr) + /// A64: LD1R { Vt.2D }, [Xn] /// public static unsafe Vector128 LoadAndReplicateToVector128(ulong* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2R { Vn.16B, Vn+1.16B }, [Xn] - /// + /// A64: LD2R { Vn.16B, Vn+1.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndReplicateToVector128x2(byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2R { Vn.16B, Vn+1.16B }, [Xn] - /// + /// A64: LD2R { Vn.16B, Vn+1.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndReplicateToVector128x2(sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2R { Vn.8H, Vn+1.8H }, [Xn] - /// + /// A64: LD2R { Vn.8H, Vn+1.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndReplicateToVector128x2(short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2R { Vn.8H, Vn+1.8H }, [Xn] - /// + /// A64: LD2R { Vn.8H, Vn+1.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndReplicateToVector128x2(ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2R { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: LD2R { Vn.4S, Vn+1.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndReplicateToVector128x2(int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2R { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: LD2R { Vn.4S, Vn+1.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndReplicateToVector128x2(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2R { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: LD2R { Vn.2D, Vn+1.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndReplicateToVector128x2(long* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2R { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: LD2R { Vn.2D, Vn+1.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndReplicateToVector128x2(ulong* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2R { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: LD2R { Vn.4S, Vn+1.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndReplicateToVector128x2(float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2R { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: LD2R { Vn.2D, Vn+1.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndReplicateToVector128x2(double* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3R { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] - /// + /// A64: LD3R { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndReplicateToVector128x3(byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3R { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] - /// + /// A64: LD3R { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndReplicateToVector128x3(sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3R { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] - /// + /// A64: LD3R { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndReplicateToVector128x3(short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3R { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] - /// + /// A64: LD3R { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndReplicateToVector128x3(ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3R { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: LD3R { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndReplicateToVector128x3(int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3R { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: LD3R { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndReplicateToVector128x3(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3R { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: LD3R { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndReplicateToVector128x3(long* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3R { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: LD3R { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndReplicateToVector128x3(ulong* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3R { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: LD3R { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndReplicateToVector128x3(float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3R { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: LD3R { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndReplicateToVector128x3(double* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4R { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] - /// + /// A64: LD4R { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndReplicateToVector128x4(byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4R { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] - /// + /// A64: LD4R { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndReplicateToVector128x4(sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4R { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] - /// + /// A64: LD4R { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndReplicateToVector128x4(short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4R { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] - /// + /// A64: LD4R { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndReplicateToVector128x4(ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4R { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: LD4R { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndReplicateToVector128x4(int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4R { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: LD4R { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndReplicateToVector128x4(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4R { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: LD4R { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndReplicateToVector128x4(long* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4R { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: LD4R { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndReplicateToVector128x4(ulong* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4R { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: LD4R { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndReplicateToVector128x4(float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4R { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: LD4R { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndReplicateToVector128x4(double* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDP Dt1, Dt2, [Xn] - /// + /// A64: LDP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64(byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDP Dt1, Dt2, [Xn] - /// + /// A64: LDP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64(double* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDP Dt1, Dt2, [Xn] - /// + /// A64: LDP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64(short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDP Dt1, Dt2, [Xn] - /// + /// A64: LDP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64(int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDP Dt1, Dt2, [Xn] - /// + /// A64: LDP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64(long* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDP Dt1, Dt2, [Xn] - /// + /// A64: LDP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64(sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDP Dt1, Dt2, [Xn] - /// + /// A64: LDP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64(float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDP Dt1, Dt2, [Xn] - /// + /// A64: LDP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64(ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDP Dt1, Dt2, [Xn] - /// + /// A64: LDP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDP Dt1, Dt2, [Xn] - /// + /// A64: LDP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64(ulong* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDP St1, St2, [Xn] - /// + /// A64: LDP St1, St2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairScalarVector64(int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDP St1, St2, [Xn] - /// + /// A64: LDP St1, St2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairScalarVector64(float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDP St1, St2, [Xn] - /// + /// A64: LDP St1, St2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairScalarVector64(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDP Qt1, Qt2, [Xn] - /// + /// A64: LDP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128(byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDP Qt1, Qt2, [Xn] - /// + /// A64: LDP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128(double* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDP Qt1, Qt2, [Xn] - /// + /// A64: LDP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128(short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDP Qt1, Qt2, [Xn] - /// + /// A64: LDP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128(int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDP Qt1, Qt2, [Xn] - /// + /// A64: LDP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128(long* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDP Qt1, Qt2, [Xn] - /// + /// A64: LDP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128(sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDP Qt1, Qt2, [Xn] - /// + /// A64: LDP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128(float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDP Qt1, Qt2, [Xn] - /// + /// A64: LDP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128(ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDP Qt1, Qt2, [Xn] - /// + /// A64: LDP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDP Qt1, Qt2, [Xn] - /// + /// A64: LDP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128(ulong* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDNP Dt1, Dt2, [Xn] - /// + /// A64: LDNP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64NonTemporal(byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDNP Dt1, Dt2, [Xn] - /// + /// A64: LDNP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64NonTemporal(double* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDNP Dt1, Dt2, [Xn] - /// + /// A64: LDNP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64NonTemporal(short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDNP Dt1, Dt2, [Xn] - /// + /// A64: LDNP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64NonTemporal(int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDNP Dt1, Dt2, [Xn] - /// + /// A64: LDNP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64NonTemporal(long* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDNP Dt1, Dt2, [Xn] - /// + /// A64: LDNP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64NonTemporal(sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDNP Dt1, Dt2, [Xn] - /// + /// A64: LDNP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64NonTemporal(float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDNP Dt1, Dt2, [Xn] - /// + /// A64: LDNP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64NonTemporal(ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDNP Dt1, Dt2, [Xn] - /// + /// A64: LDNP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64NonTemporal(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDNP Dt1, Dt2, [Xn] - /// + /// A64: LDNP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64NonTemporal(ulong* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDNP St1, St2, [Xn] - /// + /// A64: LDNP St1, St2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairScalarVector64NonTemporal(int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDNP St1, St2, [Xn] - /// + /// A64: LDNP St1, St2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairScalarVector64NonTemporal(float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDNP St1, St2, [Xn] - /// + /// A64: LDNP St1, St2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairScalarVector64NonTemporal(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDNP Qt1, Qt2, [Xn] - /// + /// A64: LDNP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128NonTemporal(byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDNP Qt1, Qt2, [Xn] - /// + /// A64: LDNP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128NonTemporal(double* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDNP Qt1, Qt2, [Xn] - /// + /// A64: LDNP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128NonTemporal(short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDNP Qt1, Qt2, [Xn] - /// + /// A64: LDNP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128NonTemporal(int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDNP Qt1, Qt2, [Xn] - /// + /// A64: LDNP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128NonTemporal(long* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDNP Qt1, Qt2, [Xn] - /// + /// A64: LDNP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128NonTemporal(sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDNP Qt1, Qt2, [Xn] - /// + /// A64: LDNP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128NonTemporal(float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDNP Qt1, Qt2, [Xn] - /// + /// A64: LDNP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128NonTemporal(ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDNP Qt1, Qt2, [Xn] - /// + /// A64: LDNP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128NonTemporal(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LDNP Qt1, Qt2, [Xn] - /// + /// A64: LDNP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128NonTemporal(ulong* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.16B, Vn+1.16B }, [Xn] - /// + /// A64: LD2 { Vn.16B, Vn+1.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128AndUnzip(byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.16B, Vn+1.16B }, [Xn] - /// + /// A64: LD2 { Vn.16B, Vn+1.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128AndUnzip(sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.8H, Vn+1.8H }, [Xn] - /// + /// A64: LD2 { Vn.8H, Vn+1.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128AndUnzip(short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.8H, Vn+1.8H }, [Xn] - /// + /// A64: LD2 { Vn.8H, Vn+1.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128AndUnzip(ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: LD2 { Vn.4S, Vn+1.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128AndUnzip(int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: LD2 { Vn.4S, Vn+1.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128AndUnzip(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: LD2 { Vn.2D, Vn+1.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128AndUnzip(long* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: LD2 { Vn.2D, Vn+1.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128AndUnzip(ulong* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: LD2 { Vn.4S, Vn+1.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128AndUnzip(float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: LD2 { Vn.2D, Vn+1.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128AndUnzip(double* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] - /// + /// A64: LD3 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128AndUnzip(byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] - /// + /// A64: LD3 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128AndUnzip(sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] - /// + /// A64: LD3 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128AndUnzip(short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] - /// + /// A64: LD3 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128AndUnzip(ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128AndUnzip(int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128AndUnzip(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128AndUnzip(long* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128AndUnzip(ulong* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128AndUnzip(float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128AndUnzip(double* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] - /// + /// A64: LD4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128AndUnzip(byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] - /// + /// A64: LD4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128AndUnzip(sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] - /// + /// A64: LD4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128AndUnzip(short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] - /// + /// A64: LD4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128AndUnzip(ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128AndUnzip(int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128AndUnzip(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128AndUnzip(long* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128AndUnzip(ulong* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128AndUnzip(float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128AndUnzip(double* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.16B, Vn+1.16B }, [Xn] - /// + /// A64: LD1 { Vn.16B, Vn+1.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128(byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.16B, Vn+1.16B }, [Xn] - /// + /// A64: LD1 { Vn.16B, Vn+1.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128(sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.8H, Vn+1.8H }, [Xn] - /// + /// A64: LD1 { Vn.8H, Vn+1.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128(short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.8H, Vn+1.8H }, [Xn] - /// + /// A64: LD1 { Vn.8H, Vn+1.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128(ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: LD1 { Vn.4S, Vn+1.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128(int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: LD1 { Vn.4S, Vn+1.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: LD1 { Vn.2D, Vn+1.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128(long* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: LD1 { Vn.2D, Vn+1.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128(ulong* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: LD1 { Vn.4S, Vn+1.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128(float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: LD1 { Vn.2D, Vn+1.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128(double* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] - /// + /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128(byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] - /// + /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128(sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] - /// + /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128(short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] - /// + /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128(ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128(int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128(long* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128(ulong* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128(float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128(double* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] - /// + /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128(byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] - /// + /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128(sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] - /// + /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128(short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] - /// + /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128(ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128(int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128(long* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D}, [Xn] - /// + /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D}, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128(ulong* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128(float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128(double* address) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vmaxq_f64 (float64x2_t a, float64x2_t b) - /// A64: FMAX Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vmaxq_f64 (float64x2_t a, float64x2_t b) + /// A64: FMAX Vd.2D, Vn.2D, Vm.2D /// public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vmaxv_u8 (uint8x8_t a) - /// A64: UMAXV Bd, Vn.8B + /// uint8_t vmaxv_u8 (uint8x8_t a) + /// A64: UMAXV Bd, Vn.8B /// public static Vector64 MaxAcross(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int16_t vmaxv_s16 (int16x4_t a) - /// A64: SMAXV Hd, Vn.4H + /// int16_t vmaxv_s16 (int16x4_t a) + /// A64: SMAXV Hd, Vn.4H /// public static Vector64 MaxAcross(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int8_t vmaxv_s8 (int8x8_t a) - /// A64: SMAXV Bd, Vn.8B + /// int8_t vmaxv_s8 (int8x8_t a) + /// A64: SMAXV Bd, Vn.8B /// public static Vector64 MaxAcross(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vmaxv_u16 (uint16x4_t a) - /// A64: UMAXV Hd, Vn.4H + /// uint16_t vmaxv_u16 (uint16x4_t a) + /// A64: UMAXV Hd, Vn.4H /// public static Vector64 MaxAcross(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vmaxvq_u8 (uint8x16_t a) - /// A64: UMAXV Bd, Vn.16B + /// uint8_t vmaxvq_u8 (uint8x16_t a) + /// A64: UMAXV Bd, Vn.16B /// public static Vector64 MaxAcross(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int16_t vmaxvq_s16 (int16x8_t a) - /// A64: SMAXV Hd, Vn.8H + /// int16_t vmaxvq_s16 (int16x8_t a) + /// A64: SMAXV Hd, Vn.8H /// public static Vector64 MaxAcross(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int32_t vmaxvq_s32 (int32x4_t a) - /// A64: SMAXV Sd, Vn.4S + /// int32_t vmaxvq_s32 (int32x4_t a) + /// A64: SMAXV Sd, Vn.4S /// public static Vector64 MaxAcross(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int8_t vmaxvq_s8 (int8x16_t a) - /// A64: SMAXV Bd, Vn.16B + /// int8_t vmaxvq_s8 (int8x16_t a) + /// A64: SMAXV Bd, Vn.16B /// public static Vector64 MaxAcross(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float32_t vmaxvq_f32 (float32x4_t a) - /// A64: FMAXV Sd, Vn.4S + /// float32_t vmaxvq_f32 (float32x4_t a) + /// A64: FMAXV Sd, Vn.4S /// public static Vector64 MaxAcross(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vmaxvq_u16 (uint16x8_t a) - /// A64: UMAXV Hd, Vn.8H + /// uint16_t vmaxvq_u16 (uint16x8_t a) + /// A64: UMAXV Hd, Vn.8H /// public static Vector64 MaxAcross(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vmaxvq_u32 (uint32x4_t a) - /// A64: UMAXV Sd, Vn.4S + /// uint32_t vmaxvq_u32 (uint32x4_t a) + /// A64: UMAXV Sd, Vn.4S /// public static Vector64 MaxAcross(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vmaxnmq_f64 (float64x2_t a, float64x2_t b) - /// A64: FMAXNM Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vmaxnmq_f64 (float64x2_t a, float64x2_t b) + /// A64: FMAXNM Vd.2D, Vn.2D, Vm.2D /// public static Vector128 MaxNumber(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32_t vmaxnmvq_f32 (float32x4_t a) - /// A64: FMAXNMV Sd, Vn.4S + /// float32_t vmaxnmvq_f32 (float32x4_t a) + /// A64: FMAXNMV Sd, Vn.4S /// public static Vector64 MaxNumberAcross(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vpmaxnm_f32 (float32x2_t a, float32x2_t b) - /// A64: FMAXNMP Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vpmaxnm_f32 (float32x2_t a, float32x2_t b) + /// A64: FMAXNMP Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MaxNumberPairwise(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vpmaxnmq_f64 (float64x2_t a, float64x2_t b) - /// A64: FMAXNMP Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vpmaxnmq_f64 (float64x2_t a, float64x2_t b) + /// A64: FMAXNMP Vd.2D, Vn.2D, Vm.2D /// public static Vector128 MaxNumberPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vpmaxnmq_f32 (float32x4_t a, float32x4_t b) - /// A64: FMAXNMP Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vpmaxnmq_f32 (float32x4_t a, float32x4_t b) + /// A64: FMAXNMP Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MaxNumberPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32_t vpmaxnms_f32 (float32x2_t a) - /// A64: FMAXNMP Sd, Vn.2S + /// float32_t vpmaxnms_f32 (float32x2_t a) + /// A64: FMAXNMP Sd, Vn.2S /// public static Vector64 MaxNumberPairwiseScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float64_t vpmaxnmqd_f64 (float64x2_t a) - /// A64: FMAXNMP Dd, Vn.2D + /// float64_t vpmaxnmqd_f64 (float64x2_t a) + /// A64: FMAXNMP Dd, Vn.2D /// public static Vector64 MaxNumberPairwiseScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vpmaxq_u8 (uint8x16_t a, uint8x16_t b) - /// A64: UMAXP Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vpmaxq_u8 (uint8x16_t a, uint8x16_t b) + /// A64: UMAXP Vd.16B, Vn.16B, Vm.16B /// public static Vector128 MaxPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vpmaxq_f64 (float64x2_t a, float64x2_t b) - /// A64: FMAXP Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vpmaxq_f64 (float64x2_t a, float64x2_t b) + /// A64: FMAXP Vd.2D, Vn.2D, Vm.2D /// public static Vector128 MaxPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vpmaxq_s16 (int16x8_t a, int16x8_t b) - /// A64: SMAXP Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vpmaxq_s16 (int16x8_t a, int16x8_t b) + /// A64: SMAXP Vd.8H, Vn.8H, Vm.8H /// public static Vector128 MaxPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vpmaxq_s32 (int32x4_t a, int32x4_t b) - /// A64: SMAXP Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vpmaxq_s32 (int32x4_t a, int32x4_t b) + /// A64: SMAXP Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MaxPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vpmaxq_s8 (int8x16_t a, int8x16_t b) - /// A64: SMAXP Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vpmaxq_s8 (int8x16_t a, int8x16_t b) + /// A64: SMAXP Vd.16B, Vn.16B, Vm.16B /// public static Vector128 MaxPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vpmaxq_f32 (float32x4_t a, float32x4_t b) - /// A64: FMAXP Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vpmaxq_f32 (float32x4_t a, float32x4_t b) + /// A64: FMAXP Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MaxPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vpmaxq_u16 (uint16x8_t a, uint16x8_t b) - /// A64: UMAXP Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vpmaxq_u16 (uint16x8_t a, uint16x8_t b) + /// A64: UMAXP Vd.8H, Vn.8H, Vm.8H /// public static Vector128 MaxPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vpmaxq_u32 (uint32x4_t a, uint32x4_t b) - /// A64: UMAXP Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vpmaxq_u32 (uint32x4_t a, uint32x4_t b) + /// A64: UMAXP Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MaxPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32_t vpmaxs_f32 (float32x2_t a) - /// A64: FMAXP Sd, Vn.2S + /// float32_t vpmaxs_f32 (float32x2_t a) + /// A64: FMAXP Sd, Vn.2S /// public static Vector64 MaxPairwiseScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float64_t vpmaxqd_f64 (float64x2_t a) - /// A64: FMAXP Dd, Vn.2D + /// float64_t vpmaxqd_f64 (float64x2_t a) + /// A64: FMAXP Dd, Vn.2D /// public static Vector64 MaxPairwiseScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vmax_f64 (float64x1_t a, float64x1_t b) - /// A64: FMAX Dd, Dn, Dm + /// float64x1_t vmax_f64 (float64x1_t a, float64x1_t b) + /// A64: FMAX Dd, Dn, Dm /// public static Vector64 MaxScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32_t vmaxs_f32 (float32_t a, float32_t b) - /// A64: FMAX Sd, Sn, Sm - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vmaxs_f32 (float32_t a, float32_t b) + /// A64: FMAX Sd, Sn, Sm + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 MaxScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vminq_f64 (float64x2_t a, float64x2_t b) - /// A64: FMIN Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vminq_f64 (float64x2_t a, float64x2_t b) + /// A64: FMIN Vd.2D, Vn.2D, Vm.2D /// public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vminv_u8 (uint8x8_t a) - /// A64: UMINV Bd, Vn.8B + /// uint8_t vminv_u8 (uint8x8_t a) + /// A64: UMINV Bd, Vn.8B /// public static Vector64 MinAcross(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int16_t vminv_s16 (int16x4_t a) - /// A64: SMINV Hd, Vn.4H + /// int16_t vminv_s16 (int16x4_t a) + /// A64: SMINV Hd, Vn.4H /// public static Vector64 MinAcross(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int8_t vminv_s8 (int8x8_t a) - /// A64: SMINV Bd, Vn.8B + /// int8_t vminv_s8 (int8x8_t a) + /// A64: SMINV Bd, Vn.8B /// public static Vector64 MinAcross(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vminv_u16 (uint16x4_t a) - /// A64: UMINV Hd, Vn.4H + /// uint16_t vminv_u16 (uint16x4_t a) + /// A64: UMINV Hd, Vn.4H /// public static Vector64 MinAcross(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vminvq_u8 (uint8x16_t a) - /// A64: UMINV Bd, Vn.16B + /// uint8_t vminvq_u8 (uint8x16_t a) + /// A64: UMINV Bd, Vn.16B /// public static Vector64 MinAcross(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int16_t vminvq_s16 (int16x8_t a) - /// A64: SMINV Hd, Vn.8H + /// int16_t vminvq_s16 (int16x8_t a) + /// A64: SMINV Hd, Vn.8H /// public static Vector64 MinAcross(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int32_t vaddvq_s32 (int32x4_t a) - /// A64: SMINV Sd, Vn.4S + /// int32_t vaddvq_s32 (int32x4_t a) + /// A64: SMINV Sd, Vn.4S /// public static Vector64 MinAcross(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int8_t vminvq_s8 (int8x16_t a) - /// A64: SMINV Bd, Vn.16B + /// int8_t vminvq_s8 (int8x16_t a) + /// A64: SMINV Bd, Vn.16B /// public static Vector64 MinAcross(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float32_t vminvq_f32 (float32x4_t a) - /// A64: FMINV Sd, Vn.4S + /// float32_t vminvq_f32 (float32x4_t a) + /// A64: FMINV Sd, Vn.4S /// public static Vector64 MinAcross(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vminvq_u16 (uint16x8_t a) - /// A64: UMINV Hd, Vn.8H + /// uint16_t vminvq_u16 (uint16x8_t a) + /// A64: UMINV Hd, Vn.8H /// public static Vector64 MinAcross(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vminvq_u32 (uint32x4_t a) - /// A64: UMINV Sd, Vn.4S + /// uint32_t vminvq_u32 (uint32x4_t a) + /// A64: UMINV Sd, Vn.4S /// public static Vector64 MinAcross(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vminnmq_f64 (float64x2_t a, float64x2_t b) - /// A64: FMINNM Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vminnmq_f64 (float64x2_t a, float64x2_t b) + /// A64: FMINNM Vd.2D, Vn.2D, Vm.2D /// public static Vector128 MinNumber(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32_t vminnmvq_f32 (float32x4_t a) - /// A64: FMINNMV Sd, Vn.4S + /// float32_t vminnmvq_f32 (float32x4_t a) + /// A64: FMINNMV Sd, Vn.4S /// public static Vector64 MinNumberAcross(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vpminnm_f32 (float32x2_t a, float32x2_t b) - /// A64: FMINNMP Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vpminnm_f32 (float32x2_t a, float32x2_t b) + /// A64: FMINNMP Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MinNumberPairwise(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vpminnmq_f64 (float64x2_t a, float64x2_t b) - /// A64: FMINNMP Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vpminnmq_f64 (float64x2_t a, float64x2_t b) + /// A64: FMINNMP Vd.2D, Vn.2D, Vm.2D /// public static Vector128 MinNumberPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vpminnmq_f32 (float32x4_t a, float32x4_t b) - /// A64: FMINNMP Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vpminnmq_f32 (float32x4_t a, float32x4_t b) + /// A64: FMINNMP Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MinNumberPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32_t vpminnms_f32 (float32x2_t a) - /// A64: FMINNMP Sd, Vn.2S + /// float32_t vpminnms_f32 (float32x2_t a) + /// A64: FMINNMP Sd, Vn.2S /// public static Vector64 MinNumberPairwiseScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float64_t vpminnmqd_f64 (float64x2_t a) - /// A64: FMINNMP Dd, Vn.2D + /// float64_t vpminnmqd_f64 (float64x2_t a) + /// A64: FMINNMP Dd, Vn.2D /// public static Vector64 MinNumberPairwiseScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vpminq_u8 (uint8x16_t a, uint8x16_t b) - /// A64: UMINP Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vpminq_u8 (uint8x16_t a, uint8x16_t b) + /// A64: UMINP Vd.16B, Vn.16B, Vm.16B /// public static Vector128 MinPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vpminq_f64 (float64x2_t a, float64x2_t b) - /// A64: FMINP Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vpminq_f64 (float64x2_t a, float64x2_t b) + /// A64: FMINP Vd.2D, Vn.2D, Vm.2D /// public static Vector128 MinPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vpminq_s16 (int16x8_t a, int16x8_t b) - /// A64: SMINP Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vpminq_s16 (int16x8_t a, int16x8_t b) + /// A64: SMINP Vd.8H, Vn.8H, Vm.8H /// public static Vector128 MinPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vpminq_s32 (int32x4_t a, int32x4_t b) - /// A64: SMINP Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vpminq_s32 (int32x4_t a, int32x4_t b) + /// A64: SMINP Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MinPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vpminq_s8 (int8x16_t a, int8x16_t b) - /// A64: SMINP Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vpminq_s8 (int8x16_t a, int8x16_t b) + /// A64: SMINP Vd.16B, Vn.16B, Vm.16B /// public static Vector128 MinPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vpminq_f32 (float32x4_t a, float32x4_t b) - /// A64: FMINP Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vpminq_f32 (float32x4_t a, float32x4_t b) + /// A64: FMINP Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MinPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vpminq_u16 (uint16x8_t a, uint16x8_t b) - /// A64: UMINP Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vpminq_u16 (uint16x8_t a, uint16x8_t b) + /// A64: UMINP Vd.8H, Vn.8H, Vm.8H /// public static Vector128 MinPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vpminq_u32 (uint32x4_t a, uint32x4_t b) - /// A64: UMINP Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vpminq_u32 (uint32x4_t a, uint32x4_t b) + /// A64: UMINP Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MinPairwise(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32_t vpmins_f32 (float32x2_t a) - /// A64: FMINP Sd, Vn.2S + /// float32_t vpmins_f32 (float32x2_t a) + /// A64: FMINP Sd, Vn.2S /// public static Vector64 MinPairwiseScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float64_t vpminqd_f64 (float64x2_t a) - /// A64: FMINP Dd, Vn.2D + /// float64_t vpminqd_f64 (float64x2_t a) + /// A64: FMINP Dd, Vn.2D /// public static Vector64 MinPairwiseScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vmin_f64 (float64x1_t a, float64x1_t b) - /// A64: FMIN Dd, Dn, Dm + /// float64x1_t vmin_f64 (float64x1_t a, float64x1_t b) + /// A64: FMIN Dd, Dn, Dm /// public static Vector64 MinScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32_t vmins_f32 (float32_t a, float32_t b) - /// A64: FMIN Sd, Sn, Sm - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vmins_f32 (float32_t a, float32_t b) + /// A64: FMIN Sd, Sn, Sm + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 MinScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vmulq_f64 (float64x2_t a, float64x2_t b) - /// A64: FMUL Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vmulq_f64 (float64x2_t a, float64x2_t b) + /// A64: FMUL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 Multiply(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vmulq_n_f64 (float64x2_t a, float64_t b) - /// A64: FMUL Vd.2D, Vn.2D, Vm.D[0] + /// float64x2_t vmulq_n_f64 (float64x2_t a, float64_t b) + /// A64: FMUL Vd.2D, Vn.2D, Vm.D[0] /// public static Vector128 MultiplyByScalar(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vmulq_laneq_f64 (float64x2_t a, float64x2_t v, const int lane) - /// A64: FMUL Vd.2D, Vn.2D, Vm.D[lane] + /// float64x2_t vmulq_laneq_f64 (float64x2_t a, float64x2_t v, const int lane) + /// A64: FMUL Vd.2D, Vn.2D, Vm.D[lane] /// public static Vector128 MultiplyBySelectedScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16_t vqdmulhh_s16 (int16_t a, int16_t b) - /// A64: SQDMULH Hd, Hn, Hm + /// int16_t vqdmulhh_s16 (int16_t a, int16_t b) + /// A64: SQDMULH Hd, Hn, Hm /// public static Vector64 MultiplyDoublingSaturateHighScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqdmulhs_s32 (int32_t a, int32_t b) - /// A64: SQDMULH Sd, Sn, Sm + /// int32_t vqdmulhs_s32 (int32_t a, int32_t b) + /// A64: SQDMULH Sd, Sn, Sm /// public static Vector64 MultiplyDoublingSaturateHighScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16_t vqdmulhh_lane_s16 (int16_t a, int16x4_t v, const int lane) - /// A64: SQDMULH Hd, Hn, Vm.H[lane] + /// int16_t vqdmulhh_lane_s16 (int16_t a, int16x4_t v, const int lane) + /// A64: SQDMULH Hd, Hn, Vm.H[lane] /// public static Vector64 MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16_t vqdmulhh_laneq_s16 (int16_t a, int16x8_t v, const int lane) - /// A64: SQDMULH Hd, Hn, Vm.H[lane] + /// int16_t vqdmulhh_laneq_s16 (int16_t a, int16x8_t v, const int lane) + /// A64: SQDMULH Hd, Hn, Vm.H[lane] /// public static Vector64 MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqdmulhs_lane_s32 (int32_t a, int32x2_t v, const int lane) - /// A64: SQDMULH Sd, Sn, Vm.S[lane] + /// int32_t vqdmulhs_lane_s32 (int32_t a, int32x2_t v, const int lane) + /// A64: SQDMULH Sd, Sn, Vm.S[lane] /// public static Vector64 MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqdmulhs_laneq_s32 (int32_t a, int32x4_t v, const int lane) - /// A64: SQDMULH Sd, Sn, Vm.S[lane] + /// int32_t vqdmulhs_laneq_s32 (int32_t a, int32x4_t v, const int lane) + /// A64: SQDMULH Sd, Sn, Vm.S[lane] /// public static Vector64 MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqdmlalh_s16 (int32_t a, int16_t b, int16_t c) - /// A64: SQDMLAL Sd, Hn, Hm + /// int32_t vqdmlalh_s16 (int32_t a, int16_t b, int16_t c) + /// A64: SQDMLAL Sd, Hn, Hm /// public static Vector64 MultiplyDoublingWideningAndAddSaturateScalar(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64_t vqdmlals_s32 (int64_t a, int32_t b, int32_t c) - /// A64: SQDMLAL Dd, Sn, Sm + /// int64_t vqdmlals_s32 (int64_t a, int32_t b, int32_t c) + /// A64: SQDMLAL Dd, Sn, Sm /// public static Vector64 MultiplyDoublingWideningAndAddSaturateScalar(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqdmlslh_s16 (int32_t a, int16_t b, int16_t c) - /// A64: SQDMLSL Sd, Hn, Hm + /// int32_t vqdmlslh_s16 (int32_t a, int16_t b, int16_t c) + /// A64: SQDMLSL Sd, Hn, Hm /// public static Vector64 MultiplyDoublingWideningAndSubtractSaturateScalar(Vector64 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64_t vqdmlsls_s32 (int64_t a, int32_t b, int32_t c) - /// A64: SQDMLSL Dd, Sn, Sm + /// int64_t vqdmlsls_s32 (int64_t a, int32_t b, int32_t c) + /// A64: SQDMLSL Dd, Sn, Sm /// public static Vector64 MultiplyDoublingWideningAndSubtractSaturateScalar(Vector64 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqdmullh_s16 (int16_t a, int16_t b) - /// A64: SQDMULL Sd, Hn, Hm + /// int32_t vqdmullh_s16 (int16_t a, int16_t b) + /// A64: SQDMULL Sd, Hn, Hm /// public static Vector64 MultiplyDoublingWideningSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64_t vqdmulls_s32 (int32_t a, int32_t b) - /// A64: SQDMULL Dd, Sn, Sm + /// int64_t vqdmulls_s32 (int32_t a, int32_t b) + /// A64: SQDMULL Dd, Sn, Sm /// public static Vector64 MultiplyDoublingWideningSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqdmullh_lane_s16 (int16_t a, int16x4_t v, const int lane) - /// A64: SQDMULL Sd, Hn, Vm.H[lane] + /// int32_t vqdmullh_lane_s16 (int16_t a, int16x4_t v, const int lane) + /// A64: SQDMULL Sd, Hn, Vm.H[lane] /// public static Vector64 MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqdmullh_laneq_s16 (int16_t a, int16x8_t v, const int lane) - /// A64: SQDMULL Sd, Hn, Vm.H[lane] + /// int32_t vqdmullh_laneq_s16 (int16_t a, int16x8_t v, const int lane) + /// A64: SQDMULL Sd, Hn, Vm.H[lane] /// public static Vector64 MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64_t vqdmulls_lane_s32 (int32_t a, int32x2_t v, const int lane) - /// A64: SQDMULL Dd, Sn, Vm.S[lane] + /// int64_t vqdmulls_lane_s32 (int32_t a, int32x2_t v, const int lane) + /// A64: SQDMULL Dd, Sn, Vm.S[lane] /// public static Vector64 MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64_t vqdmulls_laneq_s32 (int32_t a, int32x4_t v, const int lane) - /// A64: SQDMULL Dd, Sn, Vm.S[lane] + /// int64_t vqdmulls_laneq_s32 (int32_t a, int32x4_t v, const int lane) + /// A64: SQDMULL Dd, Sn, Vm.S[lane] /// public static Vector64 MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqdmlalh_lane_s16 (int32_t a, int16_t b, int16x4_t v, const int lane) - /// A64: SQDMLAL Sd, Hn, Vm.H[lane] + /// int32_t vqdmlalh_lane_s16 (int32_t a, int16_t b, int16x4_t v, const int lane) + /// A64: SQDMLAL Sd, Hn, Vm.H[lane] /// public static Vector64 MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqdmlalh_laneq_s16 (int32_t a, int16_t b, int16x8_t v, const int lane) - /// A64: SQDMLAL Sd, Hn, Vm.H[lane] + /// int32_t vqdmlalh_laneq_s16 (int32_t a, int16_t b, int16x8_t v, const int lane) + /// A64: SQDMLAL Sd, Hn, Vm.H[lane] /// public static Vector64 MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64_t vqdmlals_lane_s32 (int64_t a, int32_t b, int32x2_t v, const int lane) - /// A64: SQDMLAL Dd, Sn, Vm.S[lane] + /// int64_t vqdmlals_lane_s32 (int64_t a, int32_t b, int32x2_t v, const int lane) + /// A64: SQDMLAL Dd, Sn, Vm.S[lane] /// public static Vector64 MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64_t vqdmlals_laneq_s32 (int64_t a, int32_t b, int32x4_t v, const int lane) - /// A64: SQDMLAL Dd, Sn, Vm.S[lane] + /// int64_t vqdmlals_laneq_s32 (int64_t a, int32_t b, int32x4_t v, const int lane) + /// A64: SQDMLAL Dd, Sn, Vm.S[lane] /// public static Vector64 MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqdmlslh_lane_s16 (int32_t a, int16_t b, int16x4_t v, const int lane) - /// A64: SQDMLSL Sd, Hn, Vm.H[lane] + /// int32_t vqdmlslh_lane_s16 (int32_t a, int16_t b, int16x4_t v, const int lane) + /// A64: SQDMLSL Sd, Hn, Vm.H[lane] /// public static Vector64 MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqdmlslh_laneq_s16 (int32_t a, int16_t b, int16x8_t v, const int lane) - /// A64: SQDMLSL Sd, Hn, Vm.H[lane] + /// int32_t vqdmlslh_laneq_s16 (int32_t a, int16_t b, int16x8_t v, const int lane) + /// A64: SQDMLSL Sd, Hn, Vm.H[lane] /// public static Vector64 MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64_t vqdmlsls_lane_s32 (int64_t a, int32_t b, int32x2_t v, const int lane) - /// A64: SQDMLSL Dd, Sn, Vm.S[lane] + /// int64_t vqdmlsls_lane_s32 (int64_t a, int32_t b, int32x2_t v, const int lane) + /// A64: SQDMLSL Dd, Sn, Vm.S[lane] /// public static Vector64 MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64_t vqdmlsls_laneq_s32 (int64_t a, int32_t b, int32x4_t v, const int lane) - /// A64: SQDMLSL Dd, Sn, Vm.S[lane] + /// int64_t vqdmlsls_laneq_s32 (int64_t a, int32_t b, int32x4_t v, const int lane) + /// A64: SQDMLSL Dd, Sn, Vm.S[lane] /// public static Vector64 MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vmulx_f32 (float32x2_t a, float32x2_t b) - /// A64: FMULX Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vmulx_f32 (float32x2_t a, float32x2_t b) + /// A64: FMULX Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MultiplyExtended(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vmulxq_f64 (float64x2_t a, float64x2_t b) - /// A64: FMULX Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vmulxq_f64 (float64x2_t a, float64x2_t b) + /// A64: FMULX Vd.2D, Vn.2D, Vm.2D /// public static Vector128 MultiplyExtended(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vmulxq_f32 (float32x4_t a, float32x4_t b) - /// A64: FMULX Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vmulxq_f32 (float32x4_t a, float32x4_t b) + /// A64: FMULX Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MultiplyExtended(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vmulxq_lane_f64 (float64x2_t a, float64x1_t v, const int lane) - /// A64: FMULX Vd.2D, Vn.2D, Vm.D[0] + /// float64x2_t vmulxq_lane_f64 (float64x2_t a, float64x1_t v, const int lane) + /// A64: FMULX Vd.2D, Vn.2D, Vm.D[0] /// public static Vector128 MultiplyExtendedByScalar(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vmulx_lane_f32 (float32x2_t a, float32x2_t v, const int lane) - /// A64: FMULX Vd.2S, Vn.2S, Vm.S[lane] + /// float32x2_t vmulx_lane_f32 (float32x2_t a, float32x2_t v, const int lane) + /// A64: FMULX Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyExtendedBySelectedScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vmulx_laneq_f32 (float32x2_t a, float32x4_t v, const int lane) - /// A64: FMULX Vd.2S, Vn.2S, Vm.S[lane] + /// float32x2_t vmulx_laneq_f32 (float32x2_t a, float32x4_t v, const int lane) + /// A64: FMULX Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyExtendedBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vmulxq_laneq_f64 (float64x2_t a, float64x2_t v, const int lane) - /// A64: FMULX Vd.2D, Vn.2D, Vm.D[lane] + /// float64x2_t vmulxq_laneq_f64 (float64x2_t a, float64x2_t v, const int lane) + /// A64: FMULX Vd.2D, Vn.2D, Vm.D[lane] /// public static Vector128 MultiplyExtendedBySelectedScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vmulxq_lane_f32 (float32x4_t a, float32x2_t v, const int lane) - /// A64: FMULX Vd.4S, Vn.4S, Vm.S[lane] + /// float32x4_t vmulxq_lane_f32 (float32x4_t a, float32x2_t v, const int lane) + /// A64: FMULX Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyExtendedBySelectedScalar(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vmulxq_laneq_f32 (float32x4_t a, float32x4_t v, const int lane) - /// A64: FMULX Vd.4S, Vn.4S, Vm.S[lane] + /// float32x4_t vmulxq_laneq_f32 (float32x4_t a, float32x4_t v, const int lane) + /// A64: FMULX Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyExtendedBySelectedScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vmulx_f64 (float64x1_t a, float64x1_t b) - /// A64: FMULX Dd, Dn, Dm + /// float64x1_t vmulx_f64 (float64x1_t a, float64x1_t b) + /// A64: FMULX Dd, Dn, Dm /// public static Vector64 MultiplyExtendedScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32_t vmulxs_f32 (float32_t a, float32_t b) - /// A64: FMULX Sd, Sn, Sm + /// float32_t vmulxs_f32 (float32_t a, float32_t b) + /// A64: FMULX Sd, Sn, Sm /// public static Vector64 MultiplyExtendedScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64_t vmulxd_laneq_f64 (float64_t a, float64x2_t v, const int lane) - /// A64: FMULX Dd, Dn, Vm.D[lane] + /// float64_t vmulxd_laneq_f64 (float64_t a, float64x2_t v, const int lane) + /// A64: FMULX Dd, Dn, Vm.D[lane] /// public static Vector64 MultiplyExtendedScalarBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float32_t vmulxs_lane_f32 (float32_t a, float32x2_t v, const int lane) - /// A64: FMULX Sd, Sn, Vm.S[lane] + /// float32_t vmulxs_lane_f32 (float32_t a, float32x2_t v, const int lane) + /// A64: FMULX Sd, Sn, Vm.S[lane] /// public static Vector64 MultiplyExtendedScalarBySelectedScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float32_t vmulxs_laneq_f32 (float32_t a, float32x4_t v, const int lane) - /// A64: FMULX Sd, Sn, Vm.S[lane] + /// float32_t vmulxs_laneq_f32 (float32_t a, float32x4_t v, const int lane) + /// A64: FMULX Sd, Sn, Vm.S[lane] /// public static Vector64 MultiplyExtendedScalarBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16_t vqrdmulhh_s16 (int16_t a, int16_t b) - /// A64: SQRDMULH Hd, Hn, Hm + /// int16_t vqrdmulhh_s16 (int16_t a, int16_t b) + /// A64: SQRDMULH Hd, Hn, Hm /// public static Vector64 MultiplyRoundedDoublingSaturateHighScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqrdmulhs_s32 (int32_t a, int32_t b) - /// A64: SQRDMULH Sd, Sn, Sm + /// int32_t vqrdmulhs_s32 (int32_t a, int32_t b) + /// A64: SQRDMULH Sd, Sn, Sm /// public static Vector64 MultiplyRoundedDoublingSaturateHighScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16_t vqrdmulhh_lane_s16 (int16_t a, int16x4_t v, const int lane) - /// A64: SQRDMULH Hd, Hn, Vm.H[lane] + /// int16_t vqrdmulhh_lane_s16 (int16_t a, int16x4_t v, const int lane) + /// A64: SQRDMULH Hd, Hn, Vm.H[lane] /// public static Vector64 MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16_t vqrdmulhh_laneq_s16 (int16_t a, int16x8_t v, const int lane) - /// A64: SQRDMULH Hd, Hn, Vm.H[lane] + /// int16_t vqrdmulhh_laneq_s16 (int16_t a, int16x8_t v, const int lane) + /// A64: SQRDMULH Hd, Hn, Vm.H[lane] /// public static Vector64 MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqrdmulhs_lane_s32 (int32_t a, int32x2_t v, const int lane) - /// A64: SQRDMULH Sd, Sn, Vm.S[lane] + /// int32_t vqrdmulhs_lane_s32 (int32_t a, int32x2_t v, const int lane) + /// A64: SQRDMULH Sd, Sn, Vm.S[lane] /// public static Vector64 MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqrdmulhs_laneq_s32 (int32_t a, int32x4_t v, const int lane) - /// A64: SQRDMULH Sd, Sn, Vm.S[lane] + /// int32_t vqrdmulhs_laneq_s32 (int32_t a, int32x4_t v, const int lane) + /// A64: SQRDMULH Sd, Sn, Vm.S[lane] /// public static Vector64 MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float64_t vmuld_laneq_f64 (float64_t a, float64x2_t v, const int lane) - /// A64: FMUL Dd, Dn, Vm.D[lane] + /// float64_t vmuld_laneq_f64 (float64_t a, float64x2_t v, const int lane) + /// A64: FMUL Dd, Dn, Vm.D[lane] /// public static Vector64 MultiplyScalarBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vnegq_f64 (float64x2_t a) - /// A64: FNEG Vd.2D, Vn.2D + /// float64x2_t vnegq_f64 (float64x2_t a) + /// A64: FNEG Vd.2D, Vn.2D /// public static Vector128 Negate(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vnegq_s64 (int64x2_t a) - /// A64: NEG Vd.2D, Vn.2D + /// int64x2_t vnegq_s64 (int64x2_t a) + /// A64: NEG Vd.2D, Vn.2D /// public static Vector128 Negate(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqnegq_s64 (int64x2_t a) - /// A64: SQNEG Vd.2D, Vn.2D + /// int64x2_t vqnegq_s64 (int64x2_t a) + /// A64: SQNEG Vd.2D, Vn.2D /// public static Vector128 NegateSaturate(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int16_t vqnegh_s16 (int16_t a) - /// A64: SQNEG Hd, Hn + /// int16_t vqnegh_s16 (int16_t a) + /// A64: SQNEG Hd, Hn /// public static Vector64 NegateSaturateScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqnegs_s32 (int32_t a) - /// A64: SQNEG Sd, Sn + /// int32_t vqnegs_s32 (int32_t a) + /// A64: SQNEG Sd, Sn /// public static Vector64 NegateSaturateScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int64_t vqnegd_s64 (int64_t a) - /// A64: SQNEG Dd, Dn + /// int64_t vqnegd_s64 (int64_t a) + /// A64: SQNEG Dd, Dn /// public static Vector64 NegateSaturateScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int8_t vqnegb_s8 (int8_t a) - /// A64: SQNEG Bd, Bn + /// int8_t vqnegb_s8 (int8_t a) + /// A64: SQNEG Bd, Bn /// public static Vector64 NegateSaturateScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vneg_s64 (int64x1_t a) - /// A64: NEG Dd, Dn + /// int64x1_t vneg_s64 (int64x1_t a) + /// A64: NEG Dd, Dn /// public static Vector64 NegateScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vrecpeq_f64 (float64x2_t a) - /// A64: FRECPE Vd.2D, Vn.2D + /// float64x2_t vrecpeq_f64 (float64x2_t a) + /// A64: FRECPE Vd.2D, Vn.2D /// public static Vector128 ReciprocalEstimate(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vrecpe_f64 (float64x1_t a) - /// A64: FRECPE Dd, Dn + /// float64x1_t vrecpe_f64 (float64x1_t a) + /// A64: FRECPE Dd, Dn /// public static Vector64 ReciprocalEstimateScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32_t vrecpes_f32 (float32_t a) - /// A64: FRECPE Sd, Sn + /// float32_t vrecpes_f32 (float32_t a) + /// A64: FRECPE Sd, Sn /// public static Vector64 ReciprocalEstimateScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float64_t vrecpxd_f64 (float64_t a) - /// A64: FRECPX Dd, Dn + /// float64_t vrecpxd_f64 (float64_t a) + /// A64: FRECPX Dd, Dn /// public static Vector64 ReciprocalExponentScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32_t vrecpxs_f32 (float32_t a) - /// A64: FRECPX Sd, Sn + /// float32_t vrecpxs_f32 (float32_t a) + /// A64: FRECPX Sd, Sn /// public static Vector64 ReciprocalExponentScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vrsqrteq_f64 (float64x2_t a) - /// A64: FRSQRTE Vd.2D, Vn.2D + /// float64x2_t vrsqrteq_f64 (float64x2_t a) + /// A64: FRSQRTE Vd.2D, Vn.2D /// public static Vector128 ReciprocalSquareRootEstimate(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vrsqrte_f64 (float64x1_t a) - /// A64: FRSQRTE Dd, Dn + /// float64x1_t vrsqrte_f64 (float64x1_t a) + /// A64: FRSQRTE Dd, Dn /// public static Vector64 ReciprocalSquareRootEstimateScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32_t vrsqrtes_f32 (float32_t a) - /// A64: FRSQRTE Sd, Sn + /// float32_t vrsqrtes_f32 (float32_t a) + /// A64: FRSQRTE Sd, Sn /// public static Vector64 ReciprocalSquareRootEstimateScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vrsqrtsq_f64 (float64x2_t a, float64x2_t b) - /// A64: FRSQRTS Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vrsqrtsq_f64 (float64x2_t a, float64x2_t b) + /// A64: FRSQRTS Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ReciprocalSquareRootStep(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vrsqrts_f64 (float64x1_t a, float64x1_t b) - /// A64: FRSQRTS Dd, Dn, Dm + /// float64x1_t vrsqrts_f64 (float64x1_t a, float64x1_t b) + /// A64: FRSQRTS Dd, Dn, Dm /// public static Vector64 ReciprocalSquareRootStepScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32_t vrsqrtss_f32 (float32_t a, float32_t b) - /// A64: FRSQRTS Sd, Sn, Sm + /// float32_t vrsqrtss_f32 (float32_t a, float32_t b) + /// A64: FRSQRTS Sd, Sn, Sm /// public static Vector64 ReciprocalSquareRootStepScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vrecpsq_f64 (float64x2_t a, float64x2_t b) - /// A64: FRECPS Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vrecpsq_f64 (float64x2_t a, float64x2_t b) + /// A64: FRECPS Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ReciprocalStep(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vrecps_f64 (float64x1_t a, float64x1_t b) - /// A64: FRECPS Dd, Dn, Dm + /// float64x1_t vrecps_f64 (float64x1_t a, float64x1_t b) + /// A64: FRECPS Dd, Dn, Dm /// public static Vector64 ReciprocalStepScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32_t vrecpss_f32 (float32_t a, float32_t b) - /// A64: FRECPS Sd, Sn, Sm + /// float32_t vrecpss_f32 (float32_t a, float32_t b) + /// A64: FRECPS Sd, Sn, Sm /// public static Vector64 ReciprocalStepScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vrndaq_f64 (float64x2_t a) - /// A64: FRINTA Vd.2D, Vn.2D + /// float64x2_t vrndaq_f64 (float64x2_t a) + /// A64: FRINTA Vd.2D, Vn.2D /// public static Vector128 RoundAwayFromZero(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vrndnq_f64 (float64x2_t a) - /// A64: FRINTN Vd.2D, Vn.2D + /// float64x2_t vrndnq_f64 (float64x2_t a) + /// A64: FRINTN Vd.2D, Vn.2D /// public static Vector128 RoundToNearest(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vrndmq_f64 (float64x2_t a) - /// A64: FRINTM Vd.2D, Vn.2D + /// float64x2_t vrndmq_f64 (float64x2_t a) + /// A64: FRINTM Vd.2D, Vn.2D /// public static Vector128 RoundToNegativeInfinity(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vrndpq_f64 (float64x2_t a) - /// A64: FRINTP Vd.2D, Vn.2D + /// float64x2_t vrndpq_f64 (float64x2_t a) + /// A64: FRINTP Vd.2D, Vn.2D /// public static Vector128 RoundToPositiveInfinity(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vrndq_f64 (float64x2_t a) - /// A64: FRINTZ Vd.2D, Vn.2D + /// float64x2_t vrndq_f64 (float64x2_t a) + /// A64: FRINTZ Vd.2D, Vn.2D /// public static Vector128 RoundToZero(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int16_t vqrshlh_s16 (int16_t a, int16_t b) - /// A64: SQRSHL Hd, Hn, Hm + /// int16_t vqrshlh_s16 (int16_t a, int16_t b) + /// A64: SQRSHL Hd, Hn, Hm /// public static Vector64 ShiftArithmeticRoundedSaturateScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqrshls_s32 (int32_t a, int32_t b) - /// A64: SQRSHL Sd, Sn, Sm + /// int32_t vqrshls_s32 (int32_t a, int32_t b) + /// A64: SQRSHL Sd, Sn, Sm /// public static Vector64 ShiftArithmeticRoundedSaturateScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// int8_t vqrshlb_s8 (int8_t a, int8_t b) - /// A64: SQRSHL Bd, Bn, Bm + /// int8_t vqrshlb_s8 (int8_t a, int8_t b) + /// A64: SQRSHL Bd, Bn, Bm /// public static Vector64 ShiftArithmeticRoundedSaturateScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// int16_t vqshlh_s16 (int16_t a, int16_t b) - /// A64: SQSHL Hd, Hn, Hm + /// int16_t vqshlh_s16 (int16_t a, int16_t b) + /// A64: SQSHL Hd, Hn, Hm /// public static Vector64 ShiftArithmeticSaturateScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqshls_s32 (int32_t a, int32_t b) - /// A64: SQSHL Sd, Sn, Sm + /// int32_t vqshls_s32 (int32_t a, int32_t b) + /// A64: SQSHL Sd, Sn, Sm /// public static Vector64 ShiftArithmeticSaturateScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// int8_t vqshlb_s8 (int8_t a, int8_t b) - /// A64: SQSHL Bd, Bn, Bm + /// int8_t vqshlb_s8 (int8_t a, int8_t b) + /// A64: SQSHL Bd, Bn, Bm /// public static Vector64 ShiftArithmeticSaturateScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vqshlb_n_u8 (uint8_t a, const int n) - /// A64: UQSHL Bd, Bn, #n + /// uint8_t vqshlb_n_u8 (uint8_t a, const int n) + /// A64: UQSHL Bd, Bn, #n /// public static Vector64 ShiftLeftLogicalSaturateScalar(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int16_t vqshlh_n_s16 (int16_t a, const int n) - /// A64: SQSHL Hd, Hn, #n + /// int16_t vqshlh_n_s16 (int16_t a, const int n) + /// A64: SQSHL Hd, Hn, #n /// public static Vector64 ShiftLeftLogicalSaturateScalar(Vector64 value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqshls_n_s32 (int32_t a, const int n) - /// A64: SQSHL Sd, Sn, #n + /// int32_t vqshls_n_s32 (int32_t a, const int n) + /// A64: SQSHL Sd, Sn, #n /// public static Vector64 ShiftLeftLogicalSaturateScalar(Vector64 value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int8_t vqshlb_n_s8 (int8_t a, const int n) - /// A64: SQSHL Bd, Bn, #n + /// int8_t vqshlb_n_s8 (int8_t a, const int n) + /// A64: SQSHL Bd, Bn, #n /// public static Vector64 ShiftLeftLogicalSaturateScalar(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vqshlh_n_u16 (uint16_t a, const int n) - /// A64: UQSHL Hd, Hn, #n + /// uint16_t vqshlh_n_u16 (uint16_t a, const int n) + /// A64: UQSHL Hd, Hn, #n /// public static Vector64 ShiftLeftLogicalSaturateScalar(Vector64 value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vqshls_n_u32 (uint32_t a, const int n) - /// A64: UQSHL Sd, Sn, #n + /// uint32_t vqshls_n_u32 (uint32_t a, const int n) + /// A64: UQSHL Sd, Sn, #n /// public static Vector64 ShiftLeftLogicalSaturateScalar(Vector64 value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vqshluh_n_s16 (int16_t a, const int n) - /// A64: SQSHLU Hd, Hn, #n + /// uint16_t vqshluh_n_s16 (int16_t a, const int n) + /// A64: SQSHLU Hd, Hn, #n /// public static Vector64 ShiftLeftLogicalSaturateUnsignedScalar(Vector64 value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vqshlus_n_s32 (int32_t a, const int n) - /// A64: SQSHLU Sd, Sn, #n + /// uint32_t vqshlus_n_s32 (int32_t a, const int n) + /// A64: SQSHLU Sd, Sn, #n /// public static Vector64 ShiftLeftLogicalSaturateUnsignedScalar(Vector64 value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vqshlub_n_s8 (int8_t a, const int n) - /// A64: SQSHLU Bd, Bn, #n + /// uint8_t vqshlub_n_s8 (int8_t a, const int n) + /// A64: SQSHLU Bd, Bn, #n /// public static Vector64 ShiftLeftLogicalSaturateUnsignedScalar(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vqrshlb_u8 (uint8_t a, int8_t b) - /// A64: UQRSHL Bd, Bn, Bm + /// uint8_t vqrshlb_u8 (uint8_t a, int8_t b) + /// A64: UQRSHL Bd, Bn, Bm /// public static Vector64 ShiftLogicalRoundedSaturateScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vqrshlh_u16 (uint16_t a, int16_t b) - /// A64: UQRSHL Hd, Hn, Hm + /// uint16_t vqrshlh_u16 (uint16_t a, int16_t b) + /// A64: UQRSHL Hd, Hn, Hm /// public static Vector64 ShiftLogicalRoundedSaturateScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vqrshls_u32 (uint32_t a, int32_t b) - /// A64: UQRSHL Sd, Sn, Sm + /// uint32_t vqrshls_u32 (uint32_t a, int32_t b) + /// A64: UQRSHL Sd, Sn, Sm /// public static Vector64 ShiftLogicalRoundedSaturateScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vqrshlb_u8 (uint8_t a, int8_t b) - /// A64: UQRSHL Bd, Bn, Bm + /// uint8_t vqrshlb_u8 (uint8_t a, int8_t b) + /// A64: UQRSHL Bd, Bn, Bm /// public static Vector64 ShiftLogicalRoundedSaturateScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vqrshlh_u16 (uint16_t a, int16_t b) - /// A64: UQRSHL Hd, Hn, Hm + /// uint16_t vqrshlh_u16 (uint16_t a, int16_t b) + /// A64: UQRSHL Hd, Hn, Hm /// public static Vector64 ShiftLogicalRoundedSaturateScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vqrshls_u32 (uint32_t a, int32_t b) - /// A64: UQRSHL Sd, Sn, Sm + /// uint32_t vqrshls_u32 (uint32_t a, int32_t b) + /// A64: UQRSHL Sd, Sn, Sm /// public static Vector64 ShiftLogicalRoundedSaturateScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vqshlb_u8 (uint8_t a, int8_t b) - /// A64: UQSHL Bd, Bn, Bm + /// uint8_t vqshlb_u8 (uint8_t a, int8_t b) + /// A64: UQSHL Bd, Bn, Bm /// public static Vector64 ShiftLogicalSaturateScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vqshlh_u16 (uint16_t a, int16_t b) - /// A64: UQSHL Hd, Hn, Hm + /// uint16_t vqshlh_u16 (uint16_t a, int16_t b) + /// A64: UQSHL Hd, Hn, Hm /// public static Vector64 ShiftLogicalSaturateScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vqshls_u32 (uint32_t a, int32_t b) - /// A64: UQSHL Sd, Sn, Sm + /// uint32_t vqshls_u32 (uint32_t a, int32_t b) + /// A64: UQSHL Sd, Sn, Sm /// public static Vector64 ShiftLogicalSaturateScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vqshlb_u8 (uint8_t a, int8_t b) - /// A64: UQSHL Bd, Bn, Bm + /// uint8_t vqshlb_u8 (uint8_t a, int8_t b) + /// A64: UQSHL Bd, Bn, Bm /// public static Vector64 ShiftLogicalSaturateScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vqshlh_u16 (uint16_t a, int16_t b) - /// A64: UQSHL Hd, Hn, Hm + /// uint16_t vqshlh_u16 (uint16_t a, int16_t b) + /// A64: UQSHL Hd, Hn, Hm /// public static Vector64 ShiftLogicalSaturateScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vqshls_u32 (uint32_t a, int32_t b) - /// A64: UQSHL Sd, Sn, Sm + /// uint32_t vqshls_u32 (uint32_t a, int32_t b) + /// A64: UQSHL Sd, Sn, Sm /// public static Vector64 ShiftLogicalSaturateScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// int16_t vqshrns_n_s32 (int32_t a, const int n) - /// A64: SQSHRN Hd, Sn, #n + /// int16_t vqshrns_n_s32 (int32_t a, const int n) + /// A64: SQSHRN Hd, Sn, #n /// public static Vector64 ShiftRightArithmeticNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqshrnd_n_s64 (int64_t a, const int n) - /// A64: SQSHRN Sd, Dn, #n + /// int32_t vqshrnd_n_s64 (int64_t a, const int n) + /// A64: SQSHRN Sd, Dn, #n /// public static Vector64 ShiftRightArithmeticNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int8_t vqshrnh_n_s16 (int16_t a, const int n) - /// A64: SQSHRN Bd, Hn, #n + /// int8_t vqshrnh_n_s16 (int16_t a, const int n) + /// A64: SQSHRN Bd, Hn, #n /// public static Vector64 ShiftRightArithmeticNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vqshrunh_n_s16 (int16_t a, const int n) - /// A64: SQSHRUN Bd, Hn, #n + /// uint8_t vqshrunh_n_s16 (int16_t a, const int n) + /// A64: SQSHRUN Bd, Hn, #n /// public static Vector64 ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vqshruns_n_s32 (int32_t a, const int n) - /// A64: SQSHRUN Hd, Sn, #n + /// uint16_t vqshruns_n_s32 (int32_t a, const int n) + /// A64: SQSHRUN Hd, Sn, #n /// public static Vector64 ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vqshrund_n_s64 (int64_t a, const int n) - /// A64: SQSHRUN Sd, Dn, #n + /// uint32_t vqshrund_n_s64 (int64_t a, const int n) + /// A64: SQSHRUN Sd, Dn, #n /// public static Vector64 ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int16_t vqrshrns_n_s32 (int32_t a, const int n) - /// A64: SQRSHRN Hd, Sn, #n + /// int16_t vqrshrns_n_s32 (int32_t a, const int n) + /// A64: SQRSHRN Hd, Sn, #n /// public static Vector64 ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqrshrnd_n_s64 (int64_t a, const int n) - /// A64: SQRSHRN Sd, Dn, #n + /// int32_t vqrshrnd_n_s64 (int64_t a, const int n) + /// A64: SQRSHRN Sd, Dn, #n /// public static Vector64 ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int8_t vqrshrnh_n_s16 (int16_t a, const int n) - /// A64: SQRSHRN Bd, Hn, #n + /// int8_t vqrshrnh_n_s16 (int16_t a, const int n) + /// A64: SQRSHRN Bd, Hn, #n /// public static Vector64 ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vqrshrunh_n_s16 (int16_t a, const int n) - /// A64: SQRSHRUN Bd, Hn, #n + /// uint8_t vqrshrunh_n_s16 (int16_t a, const int n) + /// A64: SQRSHRUN Bd, Hn, #n /// public static Vector64 ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vqrshruns_n_s32 (int32_t a, const int n) - /// A64: SQRSHRUN Hd, Sn, #n + /// uint16_t vqrshruns_n_s32 (int32_t a, const int n) + /// A64: SQRSHRUN Hd, Sn, #n /// public static Vector64 ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vqrshrund_n_s64 (int64_t a, const int n) - /// A64: SQRSHRUN Sd, Dn, #n + /// uint32_t vqrshrund_n_s64 (int64_t a, const int n) + /// A64: SQRSHRUN Sd, Dn, #n /// public static Vector64 ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vqshrnh_n_u16 (uint16_t a, const int n) - /// A64: UQSHRN Bd, Hn, #n + /// uint8_t vqshrnh_n_u16 (uint16_t a, const int n) + /// A64: UQSHRN Bd, Hn, #n /// public static Vector64 ShiftRightLogicalNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vqshrns_n_u32 (uint32_t a, const int n) - /// A64: UQSHRN Hd, Sn, #n + /// uint16_t vqshrns_n_u32 (uint32_t a, const int n) + /// A64: UQSHRN Hd, Sn, #n /// public static Vector64 ShiftRightLogicalNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vqshrnd_n_u64 (uint64_t a, const int n) - /// A64: UQSHRN Sd, Dn, #n + /// uint32_t vqshrnd_n_u64 (uint64_t a, const int n) + /// A64: UQSHRN Sd, Dn, #n /// public static Vector64 ShiftRightLogicalNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vqshrnh_n_u16 (uint16_t a, const int n) - /// A64: UQSHRN Bd, Hn, #n + /// uint8_t vqshrnh_n_u16 (uint16_t a, const int n) + /// A64: UQSHRN Bd, Hn, #n /// public static Vector64 ShiftRightLogicalNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vqshrns_n_u32 (uint32_t a, const int n) - /// A64: UQSHRN Hd, Sn, #n + /// uint16_t vqshrns_n_u32 (uint32_t a, const int n) + /// A64: UQSHRN Hd, Sn, #n /// public static Vector64 ShiftRightLogicalNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vqshrnd_n_u64 (uint64_t a, const int n) - /// A64: UQSHRN Sd, Dn, #n + /// uint32_t vqshrnd_n_u64 (uint64_t a, const int n) + /// A64: UQSHRN Sd, Dn, #n /// public static Vector64 ShiftRightLogicalNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vqrshrnh_n_u16 (uint16_t a, const int n) - /// A64: UQRSHRN Bd, Hn, #n + /// uint8_t vqrshrnh_n_u16 (uint16_t a, const int n) + /// A64: UQRSHRN Bd, Hn, #n /// public static Vector64 ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vqrshrns_n_u32 (uint32_t a, const int n) - /// A64: UQRSHRN Hd, Sn, #n + /// uint16_t vqrshrns_n_u32 (uint32_t a, const int n) + /// A64: UQRSHRN Hd, Sn, #n /// [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)] public static Vector64 ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vqrshrnd_n_u64 (uint64_t a, const int n) - /// A64: UQRSHRN Sd, Dn, #n + /// uint32_t vqrshrnd_n_u64 (uint64_t a, const int n) + /// A64: UQRSHRN Sd, Dn, #n /// [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)] public static Vector64 ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vqrshrnh_n_u16 (uint16_t a, const int n) - /// A64: UQRSHRN Bd, Hn, #n + /// uint8_t vqrshrnh_n_u16 (uint16_t a, const int n) + /// A64: UQRSHRN Bd, Hn, #n /// [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)] public static Vector64 ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vqrshrns_n_u32 (uint32_t a, const int n) - /// A64: UQRSHRN Hd, Sn, #n + /// uint16_t vqrshrns_n_u32 (uint32_t a, const int n) + /// A64: UQRSHRN Hd, Sn, #n /// public static Vector64 ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vqrshrnd_n_u64 (uint64_t a, const int n) - /// A64: UQRSHRN Sd, Dn, #n + /// uint32_t vqrshrnd_n_u64 (uint64_t a, const int n) + /// A64: UQRSHRN Sd, Dn, #n /// public static Vector64 ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vsqrt_f32 (float32x2_t a) - /// A64: FSQRT Vd.2S, Vn.2S + /// float32x2_t vsqrt_f32 (float32x2_t a) + /// A64: FSQRT Vd.2S, Vn.2S /// public static Vector64 Sqrt(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vsqrtq_f64 (float64x2_t a) - /// A64: FSQRT Vd.2D, Vn.2D + /// float64x2_t vsqrtq_f64 (float64x2_t a) + /// A64: FSQRT Vd.2D, Vn.2D /// public static Vector128 Sqrt(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vsqrtq_f32 (float32x4_t a) - /// A64: FSQRT Vd.4S, Vn.4S + /// float32x4_t vsqrtq_f32 (float32x4_t a) + /// A64: FSQRT Vd.4S, Vn.4S /// public static Vector128 Sqrt(Vector128 value) { throw new PlatformNotSupportedException(); } - /// - /// A64: STP Dt1, Dt2, [Xn] - /// + /// A64: STP Dt1, Dt2, [Xn] public static unsafe void StorePair(byte* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STP Dt1, Dt2, [Xn] - /// + /// A64: STP Dt1, Dt2, [Xn] public static unsafe void StorePair(double* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STP Dt1, Dt2, [Xn] - /// + /// A64: STP Dt1, Dt2, [Xn] public static unsafe void StorePair(short* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STP Dt1, Dt2, [Xn] - /// + /// A64: STP Dt1, Dt2, [Xn] public static unsafe void StorePair(int* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STP Dt1, Dt2, [Xn] - /// + /// A64: STP Dt1, Dt2, [Xn] public static unsafe void StorePair(long* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STP Dt1, Dt2, [Xn] - /// + /// A64: STP Dt1, Dt2, [Xn] public static unsafe void StorePair(sbyte* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STP Dt1, Dt2, [Xn] - /// + /// A64: STP Dt1, Dt2, [Xn] public static unsafe void StorePair(float* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STP Dt1, Dt2, [Xn] - /// + /// A64: STP Dt1, Dt2, [Xn] public static unsafe void StorePair(ushort* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STP Dt1, Dt2, [Xn] - /// + /// A64: STP Dt1, Dt2, [Xn] public static unsafe void StorePair(uint* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STP Dt1, Dt2, [Xn] - /// + /// A64: STP Dt1, Dt2, [Xn] public static unsafe void StorePair(ulong* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STP Qt1, Qt2, [Xn] - /// + /// A64: STP Qt1, Qt2, [Xn] public static unsafe void StorePair(byte* address, Vector128 value1, Vector128 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STP Qt1, Qt2, [Xn] - /// + /// A64: STP Qt1, Qt2, [Xn] public static unsafe void StorePair(double* address, Vector128 value1, Vector128 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STP Qt1, Qt2, [Xn] - /// + /// A64: STP Qt1, Qt2, [Xn] public static unsafe void StorePair(short* address, Vector128 value1, Vector128 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STP Qt1, Qt2, [Xn] - /// + /// A64: STP Qt1, Qt2, [Xn] public static unsafe void StorePair(int* address, Vector128 value1, Vector128 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STP Qt1, Qt2, [Xn] - /// + /// A64: STP Qt1, Qt2, [Xn] public static unsafe void StorePair(long* address, Vector128 value1, Vector128 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STP Qt1, Qt2, [Xn] - /// + /// A64: STP Qt1, Qt2, [Xn] public static unsafe void StorePair(sbyte* address, Vector128 value1, Vector128 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STP Qt1, Qt2, [Xn] - /// + /// A64: STP Qt1, Qt2, [Xn] public static unsafe void StorePair(float* address, Vector128 value1, Vector128 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STP Qt1, Qt2, [Xn] - /// + /// A64: STP Qt1, Qt2, [Xn] public static unsafe void StorePair(ushort* address, Vector128 value1, Vector128 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STP Qt1, Qt2, [Xn] - /// + /// A64: STP Qt1, Qt2, [Xn] public static unsafe void StorePair(uint* address, Vector128 value1, Vector128 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STP Qt1, Qt2, [Xn] - /// + /// A64: STP Qt1, Qt2, [Xn] public static unsafe void StorePair(ulong* address, Vector128 value1, Vector128 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STNP Dt1, Dt2, [Xn] - /// + /// A64: STNP Dt1, Dt2, [Xn] public static unsafe void StorePairNonTemporal(byte* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STNP Dt1, Dt2, [Xn] - /// + /// A64: STNP Dt1, Dt2, [Xn] public static unsafe void StorePairNonTemporal(double* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STNP Dt1, Dt2, [Xn] - /// + /// A64: STNP Dt1, Dt2, [Xn] public static unsafe void StorePairNonTemporal(short* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STNP Dt1, Dt2, [Xn] - /// + /// A64: STNP Dt1, Dt2, [Xn] public static unsafe void StorePairNonTemporal(int* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STNP Dt1, Dt2, [Xn] - /// + /// A64: STNP Dt1, Dt2, [Xn] public static unsafe void StorePairNonTemporal(long* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STNP Dt1, Dt2, [Xn] - /// + /// A64: STNP Dt1, Dt2, [Xn] public static unsafe void StorePairNonTemporal(sbyte* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STNP Dt1, Dt2, [Xn] - /// + /// A64: STNP Dt1, Dt2, [Xn] public static unsafe void StorePairNonTemporal(float* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STNP Dt1, Dt2, [Xn] - /// + /// A64: STNP Dt1, Dt2, [Xn] public static unsafe void StorePairNonTemporal(ushort* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STNP Dt1, Dt2, [Xn] - /// + /// A64: STNP Dt1, Dt2, [Xn] public static unsafe void StorePairNonTemporal(uint* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STNP Dt1, Dt2, [Xn] - /// + /// A64: STNP Dt1, Dt2, [Xn] public static unsafe void StorePairNonTemporal(ulong* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STNP Qt1, Qt2, [Xn] - /// + /// A64: STNP Qt1, Qt2, [Xn] public static unsafe void StorePairNonTemporal(byte* address, Vector128 value1, Vector128 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STNP Qt1, Qt2, [Xn] - /// + /// A64: STNP Qt1, Qt2, [Xn] public static unsafe void StorePairNonTemporal(double* address, Vector128 value1, Vector128 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STNP Qt1, Qt2, [Xn] - /// + /// A64: STNP Qt1, Qt2, [Xn] public static unsafe void StorePairNonTemporal(short* address, Vector128 value1, Vector128 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STNP Qt1, Qt2, [Xn] - /// + /// A64: STNP Qt1, Qt2, [Xn] public static unsafe void StorePairNonTemporal(int* address, Vector128 value1, Vector128 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STNP Qt1, Qt2, [Xn] - /// + /// A64: STNP Qt1, Qt2, [Xn] public static unsafe void StorePairNonTemporal(long* address, Vector128 value1, Vector128 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STNP Qt1, Qt2, [Xn] - /// + /// A64: STNP Qt1, Qt2, [Xn] public static unsafe void StorePairNonTemporal(sbyte* address, Vector128 value1, Vector128 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STNP Qt1, Qt2, [Xn] - /// + /// A64: STNP Qt1, Qt2, [Xn] public static unsafe void StorePairNonTemporal(float* address, Vector128 value1, Vector128 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STNP Qt1, Qt2, [Xn] - /// + /// A64: STNP Qt1, Qt2, [Xn] public static unsafe void StorePairNonTemporal(ushort* address, Vector128 value1, Vector128 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STNP Qt1, Qt2, [Xn] - /// + /// A64: STNP Qt1, Qt2, [Xn] public static unsafe void StorePairNonTemporal(uint* address, Vector128 value1, Vector128 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STNP Qt1, Qt2, [Xn] - /// + /// A64: STNP Qt1, Qt2, [Xn] public static unsafe void StorePairNonTemporal(ulong* address, Vector128 value1, Vector128 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STP St1, St2, [Xn] - /// + /// A64: STP St1, St2, [Xn] public static unsafe void StorePairScalar(int* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STP St1, St2, [Xn] - /// + /// A64: STP St1, St2, [Xn] public static unsafe void StorePairScalar(float* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STP St1, St2, [Xn] - /// + /// A64: STP St1, St2, [Xn] public static unsafe void StorePairScalar(uint* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STNP St1, St2, [Xn] - /// + /// A64: STNP St1, St2, [Xn] public static unsafe void StorePairScalarNonTemporal(int* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STNP St1, St2, [Xn] - /// + /// A64: STNP St1, St2, [Xn] public static unsafe void StorePairScalarNonTemporal(float* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } - /// - /// A64: STNP St1, St2, [Xn] - /// + /// A64: STNP St1, St2, [Xn] public static unsafe void StorePairScalarNonTemporal(uint* address, Vector64 value1, Vector64 value2) { throw new PlatformNotSupportedException(); } /// - /// void vst2_lane_s8 (int8_t * ptr, int8x16x2_t val, const int lane) - /// A64: ST2 { Vt.16B, Vt+1.16B }[index], [Xn] + /// void vst2_lane_s8 (int8_t * ptr, int8x16x2_t val, const int lane) + /// A64: ST2 { Vt.16B, Vt+1.16B }[index], [Xn] /// public static unsafe void StoreSelectedScalar(byte* address, (Vector128 value1, Vector128 value2) value, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst2_lane_s8 (int8_t * ptr, int8x16x2_t val, const int lane) - /// A64: ST2 { Vt.16B, Vt+1.16B }[index], [Xn] + /// void vst2_lane_s8 (int8_t * ptr, int8x16x2_t val, const int lane) + /// A64: ST2 { Vt.16B, Vt+1.16B }[index], [Xn] /// public static unsafe void StoreSelectedScalar(sbyte* address, (Vector128 value1, Vector128 value2) value, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst2_lane_s16 (int16_t * ptr, int16x8x2_t val, const int lane) - /// A64: ST2 { Vt.8H, Vt+1.8H }[index], [Xn] + /// void vst2_lane_s16 (int16_t * ptr, int16x8x2_t val, const int lane) + /// A64: ST2 { Vt.8H, Vt+1.8H }[index], [Xn] /// public static unsafe void StoreSelectedScalar(short* address, (Vector128 value1, Vector128 value2) value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst2_lane_s16 (int16_t * ptr, int16x8x2_t val, const int lane) - /// A64: ST2 { Vt.8H, Vt+1.8H }[index], [Xn] + /// void vst2_lane_s16 (int16_t * ptr, int16x8x2_t val, const int lane) + /// A64: ST2 { Vt.8H, Vt+1.8H }[index], [Xn] /// public static unsafe void StoreSelectedScalar(ushort* address, (Vector128 value1, Vector128 value2) value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst2_lane_s32 (int32_t * ptr, int32x4x2_t val, const int lane) - /// A64: ST2 { Vt.4S, Vt+1.4S }[index], [Xn] + /// void vst2_lane_s32 (int32_t * ptr, int32x4x2_t val, const int lane) + /// A64: ST2 { Vt.4S, Vt+1.4S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(int* address, (Vector128 value1, Vector128 value2) value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst2_lane_s32 (int32_t * ptr, int32x4x2_t val, const int lane) - /// A64: ST2 { Vt.4S, Vt+1.4S }[index], [Xn] + /// void vst2_lane_s32 (int32_t * ptr, int32x4x2_t val, const int lane) + /// A64: ST2 { Vt.4S, Vt+1.4S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(uint* address, (Vector128 value1, Vector128 value2) value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vt.2D, Vt+1.2D }[index], [Xn] - /// + /// A64: ST2 { Vt.2D, Vt+1.2D }[index], [Xn] public static unsafe void StoreSelectedScalar(long* address, (Vector128 value1, Vector128 value2) value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vt.2D, Vt+1.2D }[index], [Xn] - /// + /// A64: ST2 { Vt.2D, Vt+1.2D }[index], [Xn] public static unsafe void StoreSelectedScalar(ulong* address, (Vector128 value1, Vector128 value2) value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst2_lane_f32 (float32_t * ptr, float32x2x2_t val, const int lane) - /// A64: ST2 { Vt.4S, Vt+1.4S }[index], [Xn] + /// void vst2_lane_f32 (float32_t * ptr, float32x2x2_t val, const int lane) + /// A64: ST2 { Vt.4S, Vt+1.4S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(float* address, (Vector128 value1, Vector128 value2) value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vt.2D, Vt+1.2D }[index], [Xn] - /// + /// A64: ST2 { Vt.2D, Vt+1.2D }[index], [Xn] public static unsafe void StoreSelectedScalar(double* address, (Vector128 value1, Vector128 value2) value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst3_lane_s8 (int8_t * ptr, int8x16x3_t val, const int lane) - /// A64: ST3 { Vt.16B, Vt+1.16B, Vt+2.16B }[index], [Xn] + /// void vst3_lane_s8 (int8_t * ptr, int8x16x3_t val, const int lane) + /// A64: ST3 { Vt.16B, Vt+1.16B, Vt+2.16B }[index], [Xn] /// public static unsafe void StoreSelectedScalar(byte* address, (Vector128 value1, Vector128 value2, Vector128 value3) value, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst3_lane_s8 (int8_t * ptr, int8x16x3_t val, const int lane) - /// A64: ST3 { Vt.16B, Vt+1.16B, Vt+2.16B }[index], [Xn] + /// void vst3_lane_s8 (int8_t * ptr, int8x16x3_t val, const int lane) + /// A64: ST3 { Vt.16B, Vt+1.16B, Vt+2.16B }[index], [Xn] /// public static unsafe void StoreSelectedScalar(sbyte* address, (Vector128 value1, Vector128 value2, Vector128 value3) value, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst3_lane_s16 (int16_t * ptr, int16x8x3_t val, const int lane) - /// A64: ST3 { Vt.8H, Vt+1.8H, Vt+2.8H }[index], [Xn] + /// void vst3_lane_s16 (int16_t * ptr, int16x8x3_t val, const int lane) + /// A64: ST3 { Vt.8H, Vt+1.8H, Vt+2.8H }[index], [Xn] /// public static unsafe void StoreSelectedScalar(short* address, (Vector128 value1, Vector128 value2, Vector128 value3) value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst3_lane_s16 (int16_t * ptr, int16x8x3_t val, const int lane) - /// A64: ST3 { Vt.8H, Vt+1.8H, Vt+2.8H }[index], [Xn] + /// void vst3_lane_s16 (int16_t * ptr, int16x8x3_t val, const int lane) + /// A64: ST3 { Vt.8H, Vt+1.8H, Vt+2.8H }[index], [Xn] /// public static unsafe void StoreSelectedScalar(ushort* address, (Vector128 value1, Vector128 value2, Vector128 value3) value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst3_lane_s32 (int32_t * ptr, int32x4x3_t val, const int lane) - /// A64: ST3 { Vt.4S, Vt+1.4S, Vt+2.4S }[index], [Xn] + /// void vst3_lane_s32 (int32_t * ptr, int32x4x3_t val, const int lane) + /// A64: ST3 { Vt.4S, Vt+1.4S, Vt+2.4S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(int* address, (Vector128 value1, Vector128 value2, Vector128 value3) value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst3_lane_s32 (int32_t * ptr, int32x4x3_t val, const int lane) - /// A64: ST3 { Vt.4S, Vt+1.4S, Vt+2.4S }[index], [Xn] + /// void vst3_lane_s32 (int32_t * ptr, int32x4x3_t val, const int lane) + /// A64: ST3 { Vt.4S, Vt+1.4S, Vt+2.4S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(uint* address, (Vector128 value1, Vector128 value2, Vector128 value3) value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vt.2D, Vt+1.2D, Vt+2.2D }[index], [Xn] - /// + /// A64: ST3 { Vt.2D, Vt+1.2D, Vt+2.2D }[index], [Xn] public static unsafe void StoreSelectedScalar(long* address, (Vector128 value1, Vector128 value2, Vector128 value3) value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vt.2D, Vt+1.2D, Vt+2.2D }[index], [Xn] - /// + /// A64: ST3 { Vt.2D, Vt+1.2D, Vt+2.2D }[index], [Xn] public static unsafe void StoreSelectedScalar(ulong* address, (Vector128 value1, Vector128 value2, Vector128 value3) value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst3_lane_f32 (float32_t * ptr, float32x2x3_t val, const int lane) - /// A64: ST3 { Vt.4S, Vt+1.4S, Vt+2.4S }[index], [Xn] + /// void vst3_lane_f32 (float32_t * ptr, float32x2x3_t val, const int lane) + /// A64: ST3 { Vt.4S, Vt+1.4S, Vt+2.4S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(float* address, (Vector128 value1, Vector128 value2, Vector128 value3) value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vt.2D, Vt+1.2D, Vt+2.2D }[index], [Xn] - /// + /// A64: ST3 { Vt.2D, Vt+1.2D, Vt+2.2D }[index], [Xn] public static unsafe void StoreSelectedScalar(double* address, (Vector128 value1, Vector128 value2, Vector128 value3) value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst4_lane_s8 (int8_t * ptr, int8x16x4_t val, const int lane) - /// A64: ST4 { Vt.16B, Vt+1.16B, Vt+2.16B, Vt+3.16B }[index], [Xn] + /// void vst4_lane_s8 (int8_t * ptr, int8x16x4_t val, const int lane) + /// A64: ST4 { Vt.16B, Vt+1.16B, Vt+2.16B, Vt+3.16B }[index], [Xn] /// public static unsafe void StoreSelectedScalar(byte* address, (Vector128 value1, Vector128 value2, Vector128 value3, Vector128 value4) value, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst4_lane_s8 (int8_t * ptr, int8x16x4_t val, const int lane) - /// A64: ST4 { Vt.16B, Vt+1.16B, Vt+2.16B, Vt+3.16B }[index], [Xn] + /// void vst4_lane_s8 (int8_t * ptr, int8x16x4_t val, const int lane) + /// A64: ST4 { Vt.16B, Vt+1.16B, Vt+2.16B, Vt+3.16B }[index], [Xn] /// public static unsafe void StoreSelectedScalar(sbyte* address, (Vector128 value1, Vector128 value2, Vector128 value3, Vector128 value4) value, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst4_lane_s16 (int16_t * ptr, int16x8x4_t val, const int lane) - /// A64: ST4 { Vt.8H, Vt+1.8H, Vt+2.8H, Vt+3.8H }[index], [Xn] + /// void vst4_lane_s16 (int16_t * ptr, int16x8x4_t val, const int lane) + /// A64: ST4 { Vt.8H, Vt+1.8H, Vt+2.8H, Vt+3.8H }[index], [Xn] /// public static unsafe void StoreSelectedScalar(short* address, (Vector128 value1, Vector128 value2, Vector128 value3, Vector128 value4) value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst4_lane_s16 (int16_t * ptr, int16x8x4_t val, const int lane) - /// A64: ST4 { Vt.8H, Vt+1.8H, Vt+2.8H, Vt+3.8H }[index], [Xn] + /// void vst4_lane_s16 (int16_t * ptr, int16x8x4_t val, const int lane) + /// A64: ST4 { Vt.8H, Vt+1.8H, Vt+2.8H, Vt+3.8H }[index], [Xn] /// public static unsafe void StoreSelectedScalar(ushort* address, (Vector128 value1, Vector128 value2, Vector128 value3, Vector128 value4) value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst4_lane_s32 (int32_t * ptr, int32x4x4_t val, const int lane) - /// A64: ST4 { Vt.4S, Vt+1.4S, Vt+2.4S, Vt+3.4S }[index], [Xn] + /// void vst4_lane_s32 (int32_t * ptr, int32x4x4_t val, const int lane) + /// A64: ST4 { Vt.4S, Vt+1.4S, Vt+2.4S, Vt+3.4S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(int* address, (Vector128 value1, Vector128 value2, Vector128 value3, Vector128 value4) value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst4_lane_s32 (int32_t * ptr, int32x4x4_t val, const int lane) - /// A64: ST4 { Vt.4S, Vt+1.4S, Vt+2.4S, Vt+3.4S }[index], [Xn] + /// void vst4_lane_s32 (int32_t * ptr, int32x4x4_t val, const int lane) + /// A64: ST4 { Vt.4S, Vt+1.4S, Vt+2.4S, Vt+3.4S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(uint* address, (Vector128 value1, Vector128 value2, Vector128 value3, Vector128 value4) value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vt.2D, Vt+1.2D, Vt+2.2D, Vt+3.2D }[index], [Xn] - /// + /// A64: ST4 { Vt.2D, Vt+1.2D, Vt+2.2D, Vt+3.2D }[index], [Xn] public static unsafe void StoreSelectedScalar(long* address, (Vector128 value1, Vector128 value2, Vector128 value3, Vector128 value4) value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vt.2D, Vt+1.2D, Vt+2.2D, Vt+3.2D }[index], [Xn] - /// + /// A64: ST4 { Vt.2D, Vt+1.2D, Vt+2.2D, Vt+3.2D }[index], [Xn] public static unsafe void StoreSelectedScalar(ulong* address, (Vector128 value1, Vector128 value2, Vector128 value3, Vector128 value4) value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst4_lane_f32 (float32_t * ptr, float32x2x4_t val, const int lane) - /// A64: ST4 { Vt.4S, Vt+1.4S, Vt+2.4S, Vt+3.4S }[index], [Xn] + /// void vst4_lane_f32 (float32_t * ptr, float32x2x4_t val, const int lane) + /// A64: ST4 { Vt.4S, Vt+1.4S, Vt+2.4S, Vt+3.4S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(float* address, (Vector128 value1, Vector128 value2, Vector128 value3, Vector128 value4) value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vt.2D, Vt+1.2D, Vt+2.2D, Vt+3.2D }[index], [Xn] - /// + /// A64: ST4 { Vt.2D, Vt+1.2D, Vt+2.2D, Vt+3.2D }[index], [Xn] public static unsafe void StoreSelectedScalar(double* address, (Vector128 value1, Vector128 value2, Vector128 value3, Vector128 value4) value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vn.16B, Vn+1.16B }, [Xn] - /// + /// A64: ST2 { Vn.16B, Vn+1.16B }, [Xn] public static unsafe void StoreVectorAndZip(byte* address, (Vector128 Value1, Vector128 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vn.16B, Vn+1.16B }, [Xn] - /// + /// A64: ST2 { Vn.16B, Vn+1.16B }, [Xn] public static unsafe void StoreVectorAndZip(sbyte* address, (Vector128 Value1, Vector128 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vn.8H, Vn+1.8H }, [Xn] - /// + /// A64: ST2 { Vn.8H, Vn+1.8H }, [Xn] public static unsafe void StoreVectorAndZip(short* address, (Vector128 Value1, Vector128 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vn.8H, Vn+1.8H }, [Xn] - /// + /// A64: ST2 { Vn.8H, Vn+1.8H }, [Xn] public static unsafe void StoreVectorAndZip(ushort* address, (Vector128 Value1, Vector128 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: ST2 { Vn.4S, Vn+1.4S }, [Xn] public static unsafe void StoreVectorAndZip(int* address, (Vector128 Value1, Vector128 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: ST2 { Vn.4S, Vn+1.4S }, [Xn] public static unsafe void StoreVectorAndZip(uint* address, (Vector128 Value1, Vector128 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: ST2 { Vn.2D, Vn+1.2D }, [Xn] public static unsafe void StoreVectorAndZip(long* address, (Vector128 Value1, Vector128 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: ST2 { Vn.2D, Vn+1.2D }, [Xn] public static unsafe void StoreVectorAndZip(ulong* address, (Vector128 Value1, Vector128 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: ST2 { Vn.4S, Vn+1.4S }, [Xn] public static unsafe void StoreVectorAndZip(float* address, (Vector128 Value1, Vector128 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: ST2 { Vn.2D, Vn+1.2D }, [Xn] public static unsafe void StoreVectorAndZip(double* address, (Vector128 Value1, Vector128 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] - /// + /// A64: ST3 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] public static unsafe void StoreVectorAndZip(byte* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] - /// + /// A64: ST3 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] public static unsafe void StoreVectorAndZip(sbyte* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] - /// + /// A64: ST3 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] public static unsafe void StoreVectorAndZip(short* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] - /// + /// A64: ST3 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] public static unsafe void StoreVectorAndZip(ushort* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: ST3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe void StoreVectorAndZip(int* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: ST3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe void StoreVectorAndZip(uint* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: ST3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe void StoreVectorAndZip(long* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: ST3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe void StoreVectorAndZip(ulong* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: ST3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe void StoreVectorAndZip(float* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: ST3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe void StoreVectorAndZip(double* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] - /// + /// A64: ST4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] public static unsafe void StoreVectorAndZip(byte* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] - /// + /// A64: ST4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] public static unsafe void StoreVectorAndZip(sbyte* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] - /// + /// A64: ST4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] public static unsafe void StoreVectorAndZip(short* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] - /// + /// A64: ST4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] public static unsafe void StoreVectorAndZip(ushort* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: ST4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe void StoreVectorAndZip(int* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: ST4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe void StoreVectorAndZip(uint* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: ST4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe void StoreVectorAndZip(long* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: ST4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe void StoreVectorAndZip(ulong* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: ST4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe void StoreVectorAndZip(float* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: ST4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe void StoreVectorAndZip(double* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.16B, Vn+1.16B }, [Xn] - /// + /// A64: ST1 { Vn.16B, Vn+1.16B }, [Xn] public static unsafe void Store(byte* address, (Vector128 Value1, Vector128 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.16B, Vn+1.16B }, [Xn] - /// + /// A64: ST1 { Vn.16B, Vn+1.16B }, [Xn] public static unsafe void Store(sbyte* address, (Vector128 Value1, Vector128 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.8H, Vn+1.8H }, [Xn] - /// + /// A64: ST1 { Vn.8H, Vn+1.8H }, [Xn] public static unsafe void Store(short* address, (Vector128 Value1, Vector128 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.8H, Vn+1.8H }, [Xn] - /// + /// A64: ST1 { Vn.8H, Vn+1.8H }, [Xn] public static unsafe void Store(ushort* address, (Vector128 Value1, Vector128 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: ST1 { Vn.4S, Vn+1.4S }, [Xn] public static unsafe void Store(int* address, (Vector128 Value1, Vector128 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: ST1 { Vn.4S, Vn+1.4S }, [Xn] public static unsafe void Store(uint* address, (Vector128 Value1, Vector128 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: ST1 { Vn.2D, Vn+1.2D }, [Xn] public static unsafe void Store(long* address, (Vector128 Value1, Vector128 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: ST1 { Vn.2D, Vn+1.2D }, [Xn] public static unsafe void Store(ulong* address, (Vector128 Value1, Vector128 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: ST1 { Vn.4S, Vn+1.4S }, [Xn] public static unsafe void Store(float* address, (Vector128 Value1, Vector128 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: ST1 { Vn.2D, Vn+1.2D }, [Xn] public static unsafe void Store(double* address, (Vector128 Value1, Vector128 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] - /// + /// A64: ST1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] public static unsafe void Store(byte* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] - /// + /// A64: ST1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] public static unsafe void Store(sbyte* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] - /// + /// A64: ST1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] public static unsafe void Store(short* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] - /// + /// A64: ST1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] public static unsafe void Store(ushort* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe void Store(int* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe void Store(uint* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe void Store(long* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe void Store(ulong* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe void Store(float* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe void Store(double* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] - /// + /// A64: ST1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] public static unsafe void Store(byte* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] - /// + /// A64: ST1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] public static unsafe void Store(sbyte* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] - /// + /// A64: ST1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] public static unsafe void Store(short* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] - /// + /// A64: ST1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] public static unsafe void Store(ushort* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe void Store(int* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe void Store(uint* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe void Store(long* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe void Store(ulong* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe void Store(float* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe void Store(double* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vsubq_f64 (float64x2_t a, float64x2_t b) - /// A64: FSUB Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vsubq_f64 (float64x2_t a, float64x2_t b) + /// A64: FSUB Vd.2D, Vn.2D, Vm.2D /// public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vqsubb_u8 (uint8_t a, uint8_t b) - /// A64: UQSUB Bd, Bn, Bm + /// uint8_t vqsubb_u8 (uint8_t a, uint8_t b) + /// A64: UQSUB Bd, Bn, Bm /// public static Vector64 SubtractSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16_t vqsubh_s16 (int16_t a, int16_t b) - /// A64: SQSUB Hd, Hn, Hm + /// int16_t vqsubh_s16 (int16_t a, int16_t b) + /// A64: SQSUB Hd, Hn, Hm /// public static Vector64 SubtractSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqsubs_s32 (int32_t a, int32_t b) - /// A64: SQSUB Sd, Sn, Sm + /// int32_t vqsubs_s32 (int32_t a, int32_t b) + /// A64: SQSUB Sd, Sn, Sm /// public static Vector64 SubtractSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8_t vqsubb_s8 (int8_t a, int8_t b) - /// A64: SQSUB Bd, Bn, Bm + /// int8_t vqsubb_s8 (int8_t a, int8_t b) + /// A64: SQSUB Bd, Bn, Bm /// public static Vector64 SubtractSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vqsubh_u16 (uint16_t a, uint16_t b) - /// A64: UQSUB Hd, Hn, Hm + /// uint16_t vqsubh_u16 (uint16_t a, uint16_t b) + /// A64: UQSUB Hd, Hn, Hm /// public static Vector64 SubtractSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vqsubs_u32 (uint32_t a, uint32_t b) - /// A64: UQSUB Sd, Sn, Sm + /// uint32_t vqsubs_u32 (uint32_t a, uint32_t b) + /// A64: UQSUB Sd, Sn, Sm /// public static Vector64 SubtractSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vrbit_u8 (uint8x8_t a) - /// A64: RBIT Vd.8B, Vn.8B + /// uint8x8_t vrbit_u8 (uint8x8_t a) + /// A64: RBIT Vd.8B, Vn.8B /// public static Vector64 ReverseElementBits(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vrbit_s8 (int8x8_t a) - /// A64: RBIT Vd.8B, Vn.8B + /// int8x8_t vrbit_s8 (int8x8_t a) + /// A64: RBIT Vd.8B, Vn.8B /// public static Vector64 ReverseElementBits(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vrbitq_u8 (uint8x16_t a) - /// A64: RBIT Vd.16B, Vn.16B + /// uint8x16_t vrbitq_u8 (uint8x16_t a) + /// A64: RBIT Vd.16B, Vn.16B /// public static Vector128 ReverseElementBits(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vrbitq_s8 (int8x16_t a) - /// A64: RBIT Vd.16B, Vn.16B + /// int8x16_t vrbitq_s8 (int8x16_t a) + /// A64: RBIT Vd.16B, Vn.16B /// public static Vector128 ReverseElementBits(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vtrn1_u8(uint8x8_t a, uint8x8_t b) - /// A64: TRN1 Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vtrn1_u8(uint8x8_t a, uint8x8_t b) + /// A64: TRN1 Vd.8B, Vn.8B, Vm.8B /// public static Vector64 TransposeEven(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vtrn1_s16(int16x4_t a, int16x4_t b) - /// A64: TRN1 Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vtrn1_s16(int16x4_t a, int16x4_t b) + /// A64: TRN1 Vd.4H, Vn.4H, Vm.4H /// public static Vector64 TransposeEven(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vtrn1_s32(int32x2_t a, int32x2_t b) - /// A64: TRN1 Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vtrn1_s32(int32x2_t a, int32x2_t b) + /// A64: TRN1 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 TransposeEven(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vtrn1_s8(int8x8_t a, int8x8_t b) - /// A64: TRN1 Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vtrn1_s8(int8x8_t a, int8x8_t b) + /// A64: TRN1 Vd.8B, Vn.8B, Vm.8B /// public static Vector64 TransposeEven(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vtrn1_f32(float32x2_t a, float32x2_t b) - /// A64: TRN1 Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vtrn1_f32(float32x2_t a, float32x2_t b) + /// A64: TRN1 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 TransposeEven(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vtrn1_u16(uint16x4_t a, uint16x4_t b) - /// A64: TRN1 Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vtrn1_u16(uint16x4_t a, uint16x4_t b) + /// A64: TRN1 Vd.4H, Vn.4H, Vm.4H /// public static Vector64 TransposeEven(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vtrn1_u32(uint32x2_t a, uint32x2_t b) - /// A64: TRN1 Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vtrn1_u32(uint32x2_t a, uint32x2_t b) + /// A64: TRN1 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 TransposeEven(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vtrn1q_u8(uint8x16_t a, uint8x16_t b) - /// A64: TRN1 Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vtrn1q_u8(uint8x16_t a, uint8x16_t b) + /// A64: TRN1 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 TransposeEven(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vtrn1q_f64(float64x2_t a, float64x2_t b) - /// A64: TRN1 Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vtrn1q_f64(float64x2_t a, float64x2_t b) + /// A64: TRN1 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 TransposeEven(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vtrn1q_s16(int16x8_t a, int16x8_t b) - /// A64: TRN1 Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vtrn1q_s16(int16x8_t a, int16x8_t b) + /// A64: TRN1 Vd.8H, Vn.8H, Vm.8H /// public static Vector128 TransposeEven(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vtrn1q_s32(int32x4_t a, int32x4_t b) - /// A64: TRN1 Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vtrn1q_s32(int32x4_t a, int32x4_t b) + /// A64: TRN1 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 TransposeEven(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vtrn1q_s64(int64x2_t a, int64x2_t b) - /// A64: TRN1 Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vtrn1q_s64(int64x2_t a, int64x2_t b) + /// A64: TRN1 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 TransposeEven(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vtrn1q_u8(int8x16_t a, int8x16_t b) - /// A64: TRN1 Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vtrn1q_u8(int8x16_t a, int8x16_t b) + /// A64: TRN1 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 TransposeEven(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vtrn1q_f32(float32x4_t a, float32x4_t b) - /// A64: TRN1 Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vtrn1q_f32(float32x4_t a, float32x4_t b) + /// A64: TRN1 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 TransposeEven(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vtrn1q_u16(uint16x8_t a, uint16x8_t b) - /// A64: TRN1 Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vtrn1q_u16(uint16x8_t a, uint16x8_t b) + /// A64: TRN1 Vd.8H, Vn.8H, Vm.8H /// public static Vector128 TransposeEven(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vtrn1q_u32(uint32x4_t a, uint32x4_t b) - /// A64: TRN1 Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vtrn1q_u32(uint32x4_t a, uint32x4_t b) + /// A64: TRN1 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 TransposeEven(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vtrn1q_u64(uint64x2_t a, uint64x2_t b) - /// A64: TRN1 Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vtrn1q_u64(uint64x2_t a, uint64x2_t b) + /// A64: TRN1 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 TransposeEven(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vtrn2_u8(uint8x8_t a, uint8x8_t b) - /// A64: TRN2 Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vtrn2_u8(uint8x8_t a, uint8x8_t b) + /// A64: TRN2 Vd.8B, Vn.8B, Vm.8B /// public static Vector64 TransposeOdd(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vtrn2_s16(int16x4_t a, int16x4_t b) - /// A64: TRN2 Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vtrn2_s16(int16x4_t a, int16x4_t b) + /// A64: TRN2 Vd.4H, Vn.4H, Vm.4H /// public static Vector64 TransposeOdd(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vtrn2_s32(int32x2_t a, int32x2_t b) - /// A64: TRN2 Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vtrn2_s32(int32x2_t a, int32x2_t b) + /// A64: TRN2 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 TransposeOdd(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vtrn2_s8(int8x8_t a, int8x8_t b) - /// A64: TRN2 Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vtrn2_s8(int8x8_t a, int8x8_t b) + /// A64: TRN2 Vd.8B, Vn.8B, Vm.8B /// public static Vector64 TransposeOdd(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vtrn2_f32(float32x2_t a, float32x2_t b) - /// A64: TRN2 Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vtrn2_f32(float32x2_t a, float32x2_t b) + /// A64: TRN2 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 TransposeOdd(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vtrn2_u16(uint16x4_t a, uint16x4_t b) - /// A64: TRN2 Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vtrn2_u16(uint16x4_t a, uint16x4_t b) + /// A64: TRN2 Vd.4H, Vn.4H, Vm.4H /// public static Vector64 TransposeOdd(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vtrn2_u32(uint32x2_t a, uint32x2_t b) - /// A64: TRN2 Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vtrn2_u32(uint32x2_t a, uint32x2_t b) + /// A64: TRN2 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 TransposeOdd(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vtrn2q_u8(uint8x16_t a, uint8x16_t b) - /// A64: TRN2 Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vtrn2q_u8(uint8x16_t a, uint8x16_t b) + /// A64: TRN2 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 TransposeOdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vtrn2q_f64(float64x2_t a, float64x2_t b) - /// A64: TRN2 Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vtrn2q_f64(float64x2_t a, float64x2_t b) + /// A64: TRN2 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 TransposeOdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vtrn2q_s16(int16x8_t a, int16x8_t b) - /// A64: TRN2 Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vtrn2q_s16(int16x8_t a, int16x8_t b) + /// A64: TRN2 Vd.8H, Vn.8H, Vm.8H /// public static Vector128 TransposeOdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vtrn2q_s32(int32x4_t a, int32x4_t b) - /// A64: TRN2 Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vtrn2q_s32(int32x4_t a, int32x4_t b) + /// A64: TRN2 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 TransposeOdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vtrn2q_s64(int64x2_t a, int64x2_t b) - /// A64: TRN2 Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vtrn2q_s64(int64x2_t a, int64x2_t b) + /// A64: TRN2 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 TransposeOdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vtrn2q_u8(int8x16_t a, int8x16_t b) - /// A64: TRN2 Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vtrn2q_u8(int8x16_t a, int8x16_t b) + /// A64: TRN2 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 TransposeOdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vtrn2q_f32(float32x4_t a, float32x4_t b) - /// A64: TRN2 Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vtrn2q_f32(float32x4_t a, float32x4_t b) + /// A64: TRN2 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 TransposeOdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vtrn2q_u16(uint16x8_t a, uint16x8_t b) - /// A64: TRN2 Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vtrn2q_u16(uint16x8_t a, uint16x8_t b) + /// A64: TRN2 Vd.8H, Vn.8H, Vm.8H /// public static Vector128 TransposeOdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vtrn2q_u32(uint32x4_t a, uint32x4_t b) - /// A64: TRN2 Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vtrn2q_u32(uint32x4_t a, uint32x4_t b) + /// A64: TRN2 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 TransposeOdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vtrn2q_u64(uint64x2_t a, uint64x2_t b) - /// A64: TRN2 Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vtrn2q_u64(uint64x2_t a, uint64x2_t b) + /// A64: TRN2 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 TransposeOdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vuzp1_u8(uint8x8_t a, uint8x8_t b) - /// A64: UZP1 Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vuzp1_u8(uint8x8_t a, uint8x8_t b) + /// A64: UZP1 Vd.8B, Vn.8B, Vm.8B /// public static Vector64 UnzipEven(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vuzp1_s16(int16x4_t a, int16x4_t b) - /// A64: UZP1 Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vuzp1_s16(int16x4_t a, int16x4_t b) + /// A64: UZP1 Vd.4H, Vn.4H, Vm.4H /// public static Vector64 UnzipEven(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vuzp1_s32(int32x2_t a, int32x2_t b) - /// A64: UZP1 Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vuzp1_s32(int32x2_t a, int32x2_t b) + /// A64: UZP1 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 UnzipEven(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vuzp1_s8(int8x8_t a, int8x8_t b) - /// A64: UZP1 Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vuzp1_s8(int8x8_t a, int8x8_t b) + /// A64: UZP1 Vd.8B, Vn.8B, Vm.8B /// public static Vector64 UnzipEven(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vuzp1_f32(float32x2_t a, float32x2_t b) - /// A64: UZP1 Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vuzp1_f32(float32x2_t a, float32x2_t b) + /// A64: UZP1 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 UnzipEven(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vuzp1_u16(uint16x4_t a, uint16x4_t b) - /// A64: UZP1 Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vuzp1_u16(uint16x4_t a, uint16x4_t b) + /// A64: UZP1 Vd.4H, Vn.4H, Vm.4H /// public static Vector64 UnzipEven(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vuzp1_u32(uint32x2_t a, uint32x2_t b) - /// A64: UZP1 Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vuzp1_u32(uint32x2_t a, uint32x2_t b) + /// A64: UZP1 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 UnzipEven(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vuzp1q_u8(uint8x16_t a, uint8x16_t b) - /// A64: UZP1 Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vuzp1q_u8(uint8x16_t a, uint8x16_t b) + /// A64: UZP1 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 UnzipEven(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vuzp1q_f64(float64x2_t a, float64x2_t b) - /// A64: UZP1 Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vuzp1q_f64(float64x2_t a, float64x2_t b) + /// A64: UZP1 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 UnzipEven(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vuzp1q_s16(int16x8_t a, int16x8_t b) - /// A64: UZP1 Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vuzp1q_s16(int16x8_t a, int16x8_t b) + /// A64: UZP1 Vd.8H, Vn.8H, Vm.8H /// public static Vector128 UnzipEven(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vuzp1q_s32(int32x4_t a, int32x4_t b) - /// A64: UZP1 Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vuzp1q_s32(int32x4_t a, int32x4_t b) + /// A64: UZP1 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 UnzipEven(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vuzp1q_s64(int64x2_t a, int64x2_t b) - /// A64: UZP1 Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vuzp1q_s64(int64x2_t a, int64x2_t b) + /// A64: UZP1 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 UnzipEven(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vuzp1q_u8(int8x16_t a, int8x16_t b) - /// A64: UZP1 Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vuzp1q_u8(int8x16_t a, int8x16_t b) + /// A64: UZP1 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 UnzipEven(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vuzp1q_f32(float32x4_t a, float32x4_t b) - /// A64: UZP1 Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vuzp1q_f32(float32x4_t a, float32x4_t b) + /// A64: UZP1 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 UnzipEven(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vuzp1q_u16(uint16x8_t a, uint16x8_t b) - /// A64: UZP1 Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vuzp1q_u16(uint16x8_t a, uint16x8_t b) + /// A64: UZP1 Vd.8H, Vn.8H, Vm.8H /// public static Vector128 UnzipEven(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vuzp1q_u32(uint32x4_t a, uint32x4_t b) - /// A64: UZP1 Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vuzp1q_u32(uint32x4_t a, uint32x4_t b) + /// A64: UZP1 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 UnzipEven(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vuzp1q_u64(uint64x2_t a, uint64x2_t b) - /// A64: UZP1 Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vuzp1q_u64(uint64x2_t a, uint64x2_t b) + /// A64: UZP1 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 UnzipEven(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vuzp2_u8(uint8x8_t a, uint8x8_t b) - /// A64: UZP2 Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vuzp2_u8(uint8x8_t a, uint8x8_t b) + /// A64: UZP2 Vd.8B, Vn.8B, Vm.8B /// public static Vector64 UnzipOdd(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vuzp2_s16(int16x4_t a, int16x4_t b) - /// A64: UZP2 Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vuzp2_s16(int16x4_t a, int16x4_t b) + /// A64: UZP2 Vd.4H, Vn.4H, Vm.4H /// public static Vector64 UnzipOdd(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vuzp2_s32(int32x2_t a, int32x2_t b) - /// A64: UZP2 Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vuzp2_s32(int32x2_t a, int32x2_t b) + /// A64: UZP2 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 UnzipOdd(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vuzp2_s8(int8x8_t a, int8x8_t b) - /// A64: UZP2 Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vuzp2_s8(int8x8_t a, int8x8_t b) + /// A64: UZP2 Vd.8B, Vn.8B, Vm.8B /// public static Vector64 UnzipOdd(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vuzp2_f32(float32x2_t a, float32x2_t b) - /// A64: UZP2 Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vuzp2_f32(float32x2_t a, float32x2_t b) + /// A64: UZP2 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 UnzipOdd(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vuzp2_u16(uint16x4_t a, uint16x4_t b) - /// A64: UZP2 Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vuzp2_u16(uint16x4_t a, uint16x4_t b) + /// A64: UZP2 Vd.4H, Vn.4H, Vm.4H /// public static Vector64 UnzipOdd(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vuzp2_u32(uint32x2_t a, uint32x2_t b) - /// A64: UZP2 Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vuzp2_u32(uint32x2_t a, uint32x2_t b) + /// A64: UZP2 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 UnzipOdd(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vuzp2q_u8(uint8x16_t a, uint8x16_t b) - /// A64: UZP2 Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vuzp2q_u8(uint8x16_t a, uint8x16_t b) + /// A64: UZP2 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 UnzipOdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vuzp2q_f64(float64x2_t a, float64x2_t b) - /// A64: UZP2 Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vuzp2q_f64(float64x2_t a, float64x2_t b) + /// A64: UZP2 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 UnzipOdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vuzp2q_s16(int16x8_t a, int16x8_t b) - /// A64: UZP2 Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vuzp2q_s16(int16x8_t a, int16x8_t b) + /// A64: UZP2 Vd.8H, Vn.8H, Vm.8H /// public static Vector128 UnzipOdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vuzp2q_s32(int32x4_t a, int32x4_t b) - /// A64: UZP2 Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vuzp2q_s32(int32x4_t a, int32x4_t b) + /// A64: UZP2 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 UnzipOdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vuzp2q_s64(int64x2_t a, int64x2_t b) - /// A64: UZP2 Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vuzp2q_s64(int64x2_t a, int64x2_t b) + /// A64: UZP2 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 UnzipOdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vuzp2q_u8(int8x16_t a, int8x16_t b) - /// A64: UZP2 Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vuzp2q_u8(int8x16_t a, int8x16_t b) + /// A64: UZP2 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 UnzipOdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vuzp2q_f32(float32x4_t a, float32x4_t b) - /// A64: UZP2 Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vuzp2q_f32(float32x4_t a, float32x4_t b) + /// A64: UZP2 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 UnzipOdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vuzp2q_u16(uint16x8_t a, uint16x8_t b) - /// A64: UZP2 Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vuzp2q_u16(uint16x8_t a, uint16x8_t b) + /// A64: UZP2 Vd.8H, Vn.8H, Vm.8H /// public static Vector128 UnzipOdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vuzp2q_u32(uint32x4_t a, uint32x4_t b) - /// A64: UZP2 Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vuzp2q_u32(uint32x4_t a, uint32x4_t b) + /// A64: UZP2 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 UnzipOdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vuzp2q_u64(uint64x2_t a, uint64x2_t b) - /// A64: UZP2 Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vuzp2q_u64(uint64x2_t a, uint64x2_t b) + /// A64: UZP2 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 UnzipOdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vqvtbl1q_u8(uint8x16_t t, uint8x16_t idx) - /// A64: TBL Vd.16B, {Vn.16B}, Vm.16B + /// uint8x16_t vqvtbl1q_u8(uint8x16_t t, uint8x16_t idx) + /// A64: TBL Vd.16B, {Vn.16B}, Vm.16B /// public static Vector128 VectorTableLookup(Vector128 table, Vector128 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vqvtbl1q_s8(int8x16_t t, uint8x16_t idx) - /// A64: TBL Vd.16B, {Vn.16B}, Vm.16B + /// int8x16_t vqvtbl1q_s8(int8x16_t t, uint8x16_t idx) + /// A64: TBL Vd.16B, {Vn.16B}, Vm.16B /// public static Vector128 VectorTableLookup(Vector128 table, Vector128 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vqtbl2q_u8(uint8x16x2_t t, uint8x16_t idx) - /// A64: TBL Vd.16B, {Vn.16B, Vn+1.16B}, Vm.16B + /// uint8x16_t vqtbl2q_u8(uint8x16x2_t t, uint8x16_t idx) + /// A64: TBL Vd.16B, {Vn.16B, Vn+1.16B}, Vm.16B /// public static Vector128 VectorTableLookup((Vector128, Vector128) table, Vector128 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vqtbl2q_s8(int8x16x2_t t, uint8x16_t idx) - /// A64: TBL Vd.16B, {Vn.16B, Vn+1.16B}, Vm.16B + /// int8x16_t vqtbl2q_s8(int8x16x2_t t, uint8x16_t idx) + /// A64: TBL Vd.16B, {Vn.16B, Vn+1.16B}, Vm.16B /// public static Vector128 VectorTableLookup((Vector128, Vector128) table, Vector128 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vqtbl3q_u8(uint8x16x3_t t, uint8x16_t idx) - /// A64: TBL Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.16B + /// uint8x16_t vqtbl3q_u8(uint8x16x3_t t, uint8x16_t idx) + /// A64: TBL Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.16B /// public static Vector128 VectorTableLookup((Vector128, Vector128, Vector128) table, Vector128 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vqtbl3q_s8(int8x16x3_t t, uint8x16_t idx) - /// A64: TBL Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.16B + /// int8x16_t vqtbl3q_s8(int8x16x3_t t, uint8x16_t idx) + /// A64: TBL Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.16B /// public static Vector128 VectorTableLookup((Vector128, Vector128, Vector128) table, Vector128 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vqtbl4q_u8(uint8x16x4_t t, uint8x16_t idx) - /// A64: TBL Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.16B + /// uint8x16_t vqtbl4q_u8(uint8x16x4_t t, uint8x16_t idx) + /// A64: TBL Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.16B /// public static Vector128 VectorTableLookup((Vector128, Vector128, Vector128, Vector128) table, Vector128 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vqtbl4q_s8(int8x16x4_t t, uint8x16_t idx) - /// A64: TBL Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.16B + /// int8x16_t vqtbl4q_s8(int8x16x4_t t, uint8x16_t idx) + /// A64: TBL Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.16B /// public static Vector128 VectorTableLookup((Vector128, Vector128, Vector128, Vector128) table, Vector128 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vqvtbx1q_u8(uint8x16_t r, int8x16_t t, uint8x16_t idx) - /// A64: TBX Vd.16B, {Vn.16B}, Vm.16B + /// uint8x16_t vqvtbx1q_u8(uint8x16_t r, int8x16_t t, uint8x16_t idx) + /// A64: TBX Vd.16B, {Vn.16B}, Vm.16B /// public static Vector128 VectorTableLookupExtension(Vector128 defaultValues, Vector128 table, Vector128 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vqvtbx1q_s8(int8x16_t r, int8x16_t t, uint8x16_t idx) - /// A64: TBX Vd.16B, {Vn.16B}, Vm.16B + /// int8x16_t vqvtbx1q_s8(int8x16_t r, int8x16_t t, uint8x16_t idx) + /// A64: TBX Vd.16B, {Vn.16B}, Vm.16B /// public static Vector128 VectorTableLookupExtension(Vector128 defaultValues, Vector128 table, Vector128 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vqtbx2q_u8(uint8x16x2_t t, uint8x16_t idx) - /// A64: TBX Vd.16B, {Vn.16B, Vn+1.16B}, Vm.16B + /// uint8x16_t vqtbx2q_u8(uint8x16x2_t t, uint8x16_t idx) + /// A64: TBX Vd.16B, {Vn.16B, Vn+1.16B}, Vm.16B /// public static Vector128 VectorTableLookupExtension(Vector128 defaultValues, (Vector128, Vector128) table, Vector128 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vqtbx2q_s8(int8x16x2_t t, uint8x16_t idx) - /// A64: TBX Vd.16B, {Vn.16B, Vn+1.16B}, Vm.16B + /// int8x16_t vqtbx2q_s8(int8x16x2_t t, uint8x16_t idx) + /// A64: TBX Vd.16B, {Vn.16B, Vn+1.16B}, Vm.16B /// public static Vector128 VectorTableLookupExtension(Vector128 defaultValues, (Vector128, Vector128) table, Vector128 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vqtbx3q_u8(uint8x16x3_t t, uint8x16_t idx) - /// A64: TBX Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.16B + /// uint8x16_t vqtbx3q_u8(uint8x16x3_t t, uint8x16_t idx) + /// A64: TBX Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.16B /// public static Vector128 VectorTableLookupExtension(Vector128 defaultValues, (Vector128, Vector128, Vector128) table, Vector128 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vqtbx3q_s8(int8x16x3_t t, uint8x16_t idx) - /// A64: TBX Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.16B + /// int8x16_t vqtbx3q_s8(int8x16x3_t t, uint8x16_t idx) + /// A64: TBX Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.16B /// public static Vector128 VectorTableLookupExtension(Vector128 defaultValues, (Vector128, Vector128, Vector128) table, Vector128 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vqtbx4q_u8(uint8x16x4_t t, uint8x16_t idx) - /// A64: TBX Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.16B + /// uint8x16_t vqtbx4q_u8(uint8x16x4_t t, uint8x16_t idx) + /// A64: TBX Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.16B /// public static Vector128 VectorTableLookupExtension(Vector128 defaultValues, (Vector128, Vector128, Vector128, Vector128) table, Vector128 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vqtbx4q_s8(int8x16x4_t t, uint8x16_t idx) - /// A64: TBX Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.16B + /// int8x16_t vqtbx4q_s8(int8x16x4_t t, uint8x16_t idx) + /// A64: TBX Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.16B /// public static Vector128 VectorTableLookupExtension(Vector128 defaultValues, (Vector128, Vector128, Vector128, Vector128) table, Vector128 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vzip2_u8(uint8x8_t a, uint8x8_t b) - /// A64: ZIP2 Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vzip2_u8(uint8x8_t a, uint8x8_t b) + /// A64: ZIP2 Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ZipHigh(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vzip2_s16(int16x4_t a, int16x4_t b) - /// A64: ZIP2 Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vzip2_s16(int16x4_t a, int16x4_t b) + /// A64: ZIP2 Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ZipHigh(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vzip2_s32(int32x2_t a, int32x2_t b) - /// A64: ZIP2 Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vzip2_s32(int32x2_t a, int32x2_t b) + /// A64: ZIP2 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ZipHigh(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vzip2_s8(int8x8_t a, int8x8_t b) - /// A64: ZIP2 Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vzip2_s8(int8x8_t a, int8x8_t b) + /// A64: ZIP2 Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ZipHigh(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vzip2_f32(float32x2_t a, float32x2_t b) - /// A64: ZIP2 Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vzip2_f32(float32x2_t a, float32x2_t b) + /// A64: ZIP2 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ZipHigh(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vzip2_u16(uint16x4_t a, uint16x4_t b) - /// A64: ZIP2 Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vzip2_u16(uint16x4_t a, uint16x4_t b) + /// A64: ZIP2 Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ZipHigh(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vzip2_u32(uint32x2_t a, uint32x2_t b) - /// A64: ZIP2 Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vzip2_u32(uint32x2_t a, uint32x2_t b) + /// A64: ZIP2 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ZipHigh(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vzip2q_u8(uint8x16_t a, uint8x16_t b) - /// A64: ZIP2 Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vzip2q_u8(uint8x16_t a, uint8x16_t b) + /// A64: ZIP2 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ZipHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vzip2q_f64(float64x2_t a, float64x2_t b) - /// A64: ZIP2 Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vzip2q_f64(float64x2_t a, float64x2_t b) + /// A64: ZIP2 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ZipHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vzip2q_s16(int16x8_t a, int16x8_t b) - /// A64: ZIP2 Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vzip2q_s16(int16x8_t a, int16x8_t b) + /// A64: ZIP2 Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ZipHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vzip2q_s32(int32x4_t a, int32x4_t b) - /// A64: ZIP2 Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vzip2q_s32(int32x4_t a, int32x4_t b) + /// A64: ZIP2 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ZipHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vzip2q_s64(int64x2_t a, int64x2_t b) - /// A64: ZIP2 Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vzip2q_s64(int64x2_t a, int64x2_t b) + /// A64: ZIP2 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ZipHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vzip2q_u8(int8x16_t a, int8x16_t b) - /// A64: ZIP2 Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vzip2q_u8(int8x16_t a, int8x16_t b) + /// A64: ZIP2 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ZipHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vzip2q_f32(float32x4_t a, float32x4_t b) - /// A64: ZIP2 Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vzip2q_f32(float32x4_t a, float32x4_t b) + /// A64: ZIP2 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ZipHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vzip2q_u16(uint16x8_t a, uint16x8_t b) - /// A64: ZIP2 Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vzip2q_u16(uint16x8_t a, uint16x8_t b) + /// A64: ZIP2 Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ZipHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vzip2q_u32(uint32x4_t a, uint32x4_t b) - /// A64: ZIP2 Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vzip2q_u32(uint32x4_t a, uint32x4_t b) + /// A64: ZIP2 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ZipHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vzip2q_u64(uint64x2_t a, uint64x2_t b) - /// A64: ZIP2 Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vzip2q_u64(uint64x2_t a, uint64x2_t b) + /// A64: ZIP2 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ZipHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vzip1_u8(uint8x8_t a, uint8x8_t b) - /// A64: ZIP1 Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vzip1_u8(uint8x8_t a, uint8x8_t b) + /// A64: ZIP1 Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ZipLow(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vzip1_s16(int16x4_t a, int16x4_t b) - /// A64: ZIP1 Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vzip1_s16(int16x4_t a, int16x4_t b) + /// A64: ZIP1 Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ZipLow(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vzip1_s32(int32x2_t a, int32x2_t b) - /// A64: ZIP1 Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vzip1_s32(int32x2_t a, int32x2_t b) + /// A64: ZIP1 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ZipLow(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vzip1_s8(int8x8_t a, int8x8_t b) - /// A64: ZIP1 Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vzip1_s8(int8x8_t a, int8x8_t b) + /// A64: ZIP1 Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ZipLow(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vzip1_f32(float32x2_t a, float32x2_t b) - /// A64: ZIP1 Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vzip1_f32(float32x2_t a, float32x2_t b) + /// A64: ZIP1 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ZipLow(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vzip1_u16(uint16x4_t a, uint16x4_t b) - /// A64: ZIP1 Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vzip1_u16(uint16x4_t a, uint16x4_t b) + /// A64: ZIP1 Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ZipLow(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vzip1_u32(uint32x2_t a, uint32x2_t b) - /// A64: ZIP1 Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vzip1_u32(uint32x2_t a, uint32x2_t b) + /// A64: ZIP1 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ZipLow(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vzip1q_u8(uint8x16_t a, uint8x16_t b) - /// A64: ZIP1 Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vzip1q_u8(uint8x16_t a, uint8x16_t b) + /// A64: ZIP1 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ZipLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vzip1q_f64(float64x2_t a, float64x2_t b) - /// A64: ZIP1 Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vzip1q_f64(float64x2_t a, float64x2_t b) + /// A64: ZIP1 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ZipLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vzip1q_s16(int16x8_t a, int16x8_t b) - /// A64: ZIP1 Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vzip1q_s16(int16x8_t a, int16x8_t b) + /// A64: ZIP1 Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ZipLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vzip1q_s32(int32x4_t a, int32x4_t b) - /// A64: ZIP1 Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vzip1q_s32(int32x4_t a, int32x4_t b) + /// A64: ZIP1 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ZipLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vzip1q_s64(int64x2_t a, int64x2_t b) - /// A64: ZIP1 Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vzip1q_s64(int64x2_t a, int64x2_t b) + /// A64: ZIP1 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ZipLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vzip1q_u8(int8x16_t a, int8x16_t b) - /// A64: ZIP1 Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vzip1q_u8(int8x16_t a, int8x16_t b) + /// A64: ZIP1 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ZipLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vzip1q_f32(float32x4_t a, float32x4_t b) - /// A64: ZIP1 Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vzip1q_f32(float32x4_t a, float32x4_t b) + /// A64: ZIP1 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ZipLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vzip1q_u16(uint16x8_t a, uint16x8_t b) - /// A64: ZIP1 Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vzip1q_u16(uint16x8_t a, uint16x8_t b) + /// A64: ZIP1 Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ZipLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vzip1q_u32(uint32x4_t a, uint32x4_t b) - /// A64: ZIP1 Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vzip1q_u32(uint32x4_t a, uint32x4_t b) + /// A64: ZIP1 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ZipLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vzip1q_u64(uint64x2_t a, uint64x2_t b) - /// A64: ZIP1 Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vzip1q_u64(uint64x2_t a, uint64x2_t b) + /// A64: ZIP1 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ZipLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } } /// - /// int16x4_t vabs_s16 (int16x4_t a) - /// A32: VABS.S16 Dd, Dm - /// A64: ABS Vd.4H, Vn.4H + /// int16x4_t vabs_s16 (int16x4_t a) + /// A32: VABS.S16 Dd, Dm + /// A64: ABS Vd.4H, Vn.4H /// public static Vector64 Abs(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vabs_s32 (int32x2_t a) - /// A32: VABS.S32 Dd, Dm - /// A64: ABS Vd.2S, Vn.2S + /// int32x2_t vabs_s32 (int32x2_t a) + /// A32: VABS.S32 Dd, Dm + /// A64: ABS Vd.2S, Vn.2S /// public static Vector64 Abs(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vabs_s8 (int8x8_t a) - /// A32: VABS.S8 Dd, Dm - /// A64: ABS Vd.8B, Vn.8B + /// int8x8_t vabs_s8 (int8x8_t a) + /// A32: VABS.S8 Dd, Dm + /// A64: ABS Vd.8B, Vn.8B /// public static Vector64 Abs(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vabs_f32 (float32x2_t a) - /// A32: VABS.F32 Dd, Dm - /// A64: FABS Vd.2S, Vn.2S + /// float32x2_t vabs_f32 (float32x2_t a) + /// A32: VABS.F32 Dd, Dm + /// A64: FABS Vd.2S, Vn.2S /// public static Vector64 Abs(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vabsq_s16 (int16x8_t a) - /// A32: VABS.S16 Qd, Qm - /// A64: ABS Vd.8H, Vn.8H + /// int16x8_t vabsq_s16 (int16x8_t a) + /// A32: VABS.S16 Qd, Qm + /// A64: ABS Vd.8H, Vn.8H /// public static Vector128 Abs(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vabsq_s32 (int32x4_t a) - /// A32: VABS.S32 Qd, Qm - /// A64: ABS Vd.4S, Vn.4S + /// int32x4_t vabsq_s32 (int32x4_t a) + /// A32: VABS.S32 Qd, Qm + /// A64: ABS Vd.4S, Vn.4S /// public static Vector128 Abs(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vabsq_s8 (int8x16_t a) - /// A32: VABS.S8 Qd, Qm - /// A64: ABS Vd.16B, Vn.16B + /// int8x16_t vabsq_s8 (int8x16_t a) + /// A32: VABS.S8 Qd, Qm + /// A64: ABS Vd.16B, Vn.16B /// public static Vector128 Abs(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vabsq_f32 (float32x4_t a) - /// A32: VABS.F32 Qd, Qm - /// A64: FABS Vd.4S, Vn.4S + /// float32x4_t vabsq_f32 (float32x4_t a) + /// A32: VABS.F32 Qd, Qm + /// A64: FABS Vd.4S, Vn.4S /// public static Vector128 Abs(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vqabs_s16 (int16x4_t a) - /// A32: VQABS.S16 Dd, Dm - /// A64: SQABS Vd.4H, Vn.4H + /// int16x4_t vqabs_s16 (int16x4_t a) + /// A32: VQABS.S16 Dd, Dm + /// A64: SQABS Vd.4H, Vn.4H /// public static Vector64 AbsSaturate(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vqabs_s32 (int32x2_t a) - /// A32: VQABS.S32 Dd, Dm - /// A64: SQABS Vd.2S, Vn.2S + /// int32x2_t vqabs_s32 (int32x2_t a) + /// A32: VQABS.S32 Dd, Dm + /// A64: SQABS Vd.2S, Vn.2S /// public static Vector64 AbsSaturate(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vqabs_s8 (int8x8_t a) - /// A32: VQABS.S8 Dd, Dm - /// A64: SQABS Vd.8B, Vn.8B + /// int8x8_t vqabs_s8 (int8x8_t a) + /// A32: VQABS.S8 Dd, Dm + /// A64: SQABS Vd.8B, Vn.8B /// public static Vector64 AbsSaturate(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vqabsq_s16 (int16x8_t a) - /// A32: VQABS.S16 Qd, Qm - /// A64: SQABS Vd.8H, Vn.8H + /// int16x8_t vqabsq_s16 (int16x8_t a) + /// A32: VQABS.S16 Qd, Qm + /// A64: SQABS Vd.8H, Vn.8H /// public static Vector128 AbsSaturate(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqabsq_s32 (int32x4_t a) - /// A32: VQABS.S32 Qd, Qm - /// A64: SQABS Vd.4S, Vn.4S + /// int32x4_t vqabsq_s32 (int32x4_t a) + /// A32: VQABS.S32 Qd, Qm + /// A64: SQABS Vd.4S, Vn.4S /// public static Vector128 AbsSaturate(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vqabsq_s8 (int8x16_t a) - /// A32: VQABS.S8 Qd, Qm - /// A64: SQABS Vd.16B, Vn.16B + /// int8x16_t vqabsq_s8 (int8x16_t a) + /// A32: VQABS.S8 Qd, Qm + /// A64: SQABS Vd.16B, Vn.16B /// public static Vector128 AbsSaturate(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vabs_f64 (float64x1_t a) - /// A32: VABS.F64 Dd, Dm - /// A64: FABS Dd, Dn + /// float64x1_t vabs_f64 (float64x1_t a) + /// A32: VABS.F64 Dd, Dm + /// A64: FABS Dd, Dn /// public static Vector64 AbsScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32_t vabss_f32 (float32_t a) - /// A32: VABS.F32 Sd, Sm - /// A64: FABS Sd, Sn - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vabss_f32 (float32_t a) + /// A32: VABS.F32 Sd, Sm + /// A64: FABS Sd, Sn + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 AbsScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vcagt_f32 (float32x2_t a, float32x2_t b) - /// A32: VACGT.F32 Dd, Dn, Dm - /// A64: FACGT Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcagt_f32 (float32x2_t a, float32x2_t b) + /// A32: VACGT.F32 Dd, Dn, Dm + /// A64: FACGT Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AbsoluteCompareGreaterThan(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vcagtq_f32 (float32x4_t a, float32x4_t b) - /// A32: VACGT.F32 Qd, Qn, Qm - /// A64: FACGT Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcagtq_f32 (float32x4_t a, float32x4_t b) + /// A32: VACGT.F32 Qd, Qn, Qm + /// A64: FACGT Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AbsoluteCompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vcage_f32 (float32x2_t a, float32x2_t b) - /// A32: VACGE.F32 Dd, Dn, Dm - /// A64: FACGE Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcage_f32 (float32x2_t a, float32x2_t b) + /// A32: VACGE.F32 Dd, Dn, Dm + /// A64: FACGE Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AbsoluteCompareGreaterThanOrEqual(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vcageq_f32 (float32x4_t a, float32x4_t b) - /// A32: VACGE.F32 Qd, Qn, Qm - /// A64: FACGE Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcageq_f32 (float32x4_t a, float32x4_t b) + /// A32: VACGE.F32 Qd, Qn, Qm + /// A64: FACGE Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AbsoluteCompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vcalt_f32 (float32x2_t a, float32x2_t b) - /// A32: VACLT.F32 Dd, Dn, Dm - /// A64: FACGT Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcalt_f32 (float32x2_t a, float32x2_t b) + /// A32: VACLT.F32 Dd, Dn, Dm + /// A64: FACGT Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AbsoluteCompareLessThan(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vcaltq_f32 (float32x4_t a, float32x4_t b) - /// A32: VACLT.F32 Qd, Qn, Qm - /// A64: FACGT Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcaltq_f32 (float32x4_t a, float32x4_t b) + /// A32: VACLT.F32 Qd, Qn, Qm + /// A64: FACGT Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AbsoluteCompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vcale_f32 (float32x2_t a, float32x2_t b) - /// A32: VACLE.F32 Dd, Dn, Dm - /// A64: FACGE Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcale_f32 (float32x2_t a, float32x2_t b) + /// A32: VACLE.F32 Dd, Dn, Dm + /// A64: FACGE Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AbsoluteCompareLessThanOrEqual(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vcaleq_f32 (float32x4_t a, float32x4_t b) - /// A32: VACLE.F32 Qd, Qn, Qm - /// A64: FACGE Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcaleq_f32 (float32x4_t a, float32x4_t b) + /// A32: VACLE.F32 Qd, Qn, Qm + /// A64: FACGE Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AbsoluteCompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vabd_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VABD.U8 Dd, Dn, Dm - /// A64: UABD Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vabd_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VABD.U8 Dd, Dn, Dm + /// A64: UABD Vd.8B, Vn.8B, Vm.8B /// public static Vector64 AbsoluteDifference(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vabd_s16 (int16x4_t a, int16x4_t b) - /// A32: VABD.S16 Dd, Dn, Dm - /// A64: SABD Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vabd_s16 (int16x4_t a, int16x4_t b) + /// A32: VABD.S16 Dd, Dn, Dm + /// A64: SABD Vd.4H, Vn.4H, Vm.4H /// public static Vector64 AbsoluteDifference(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vabd_s32 (int32x2_t a, int32x2_t b) - /// A32: VABD.S32 Dd, Dn, Dm - /// A64: SABD Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vabd_s32 (int32x2_t a, int32x2_t b) + /// A32: VABD.S32 Dd, Dn, Dm + /// A64: SABD Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AbsoluteDifference(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vabd_s8 (int8x8_t a, int8x8_t b) - /// A32: VABD.S8 Dd, Dn, Dm - /// A64: SABD Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vabd_s8 (int8x8_t a, int8x8_t b) + /// A32: VABD.S8 Dd, Dn, Dm + /// A64: SABD Vd.8B, Vn.8B, Vm.8B /// public static Vector64 AbsoluteDifference(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vabd_f32 (float32x2_t a, float32x2_t b) - /// A32: VABD.F32 Dd, Dn, Dm - /// A64: FABD Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vabd_f32 (float32x2_t a, float32x2_t b) + /// A32: VABD.F32 Dd, Dn, Dm + /// A64: FABD Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AbsoluteDifference(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vabd_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VABD.U16 Dd, Dn, Dm - /// A64: UABD Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vabd_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VABD.U16 Dd, Dn, Dm + /// A64: UABD Vd.4H, Vn.4H, Vm.4H /// public static Vector64 AbsoluteDifference(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vabd_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VABD.U32 Dd, Dn, Dm - /// A64: UABD Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vabd_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VABD.U32 Dd, Dn, Dm + /// A64: UABD Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AbsoluteDifference(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vabdq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VABD.U8 Qd, Qn, Qm - /// A64: UABD Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vabdq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VABD.U8 Qd, Qn, Qm + /// A64: UABD Vd.16B, Vn.16B, Vm.16B /// public static Vector128 AbsoluteDifference(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vabdq_s16 (int16x8_t a, int16x8_t b) - /// A32: VABD.S16 Qd, Qn, Qm - /// A64: SABD Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vabdq_s16 (int16x8_t a, int16x8_t b) + /// A32: VABD.S16 Qd, Qn, Qm + /// A64: SABD Vd.8H, Vn.8H, Vm.8H /// public static Vector128 AbsoluteDifference(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vabdq_s32 (int32x4_t a, int32x4_t b) - /// A32: VABD.S32 Qd, Qn, Qm - /// A64: SABD Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vabdq_s32 (int32x4_t a, int32x4_t b) + /// A32: VABD.S32 Qd, Qn, Qm + /// A64: SABD Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AbsoluteDifference(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vabdq_s8 (int8x16_t a, int8x16_t b) - /// A32: VABD.S8 Qd, Qn, Qm - /// A64: SABD Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vabdq_s8 (int8x16_t a, int8x16_t b) + /// A32: VABD.S8 Qd, Qn, Qm + /// A64: SABD Vd.16B, Vn.16B, Vm.16B /// public static Vector128 AbsoluteDifference(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vabdq_f32 (float32x4_t a, float32x4_t b) - /// A32: VABD.F32 Qd, Qn, Qm - /// A64: FABD Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vabdq_f32 (float32x4_t a, float32x4_t b) + /// A32: VABD.F32 Qd, Qn, Qm + /// A64: FABD Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AbsoluteDifference(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vabdq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VABD.U16 Qd, Qn, Qm - /// A64: UABD Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vabdq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VABD.U16 Qd, Qn, Qm + /// A64: UABD Vd.8H, Vn.8H, Vm.8H /// public static Vector128 AbsoluteDifference(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vabdq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VABD.U32 Qd, Qn, Qm - /// A64: UABD Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vabdq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VABD.U32 Qd, Qn, Qm + /// A64: UABD Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AbsoluteDifference(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vaba_u8 (uint8x8_t a, uint8x8_t b, uint8x8_t c) - /// A32: VABA.U8 Dd, Dn, Dm - /// A64: UABA Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vaba_u8 (uint8x8_t a, uint8x8_t b, uint8x8_t c) + /// A32: VABA.U8 Dd, Dn, Dm + /// A64: UABA Vd.8B, Vn.8B, Vm.8B /// public static Vector64 AbsoluteDifferenceAdd(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vaba_s16 (int16x4_t a, int16x4_t b, int16x4_t c) - /// A32: VABA.S16 Dd, Dn, Dm - /// A64: SABA Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vaba_s16 (int16x4_t a, int16x4_t b, int16x4_t c) + /// A32: VABA.S16 Dd, Dn, Dm + /// A64: SABA Vd.4H, Vn.4H, Vm.4H /// public static Vector64 AbsoluteDifferenceAdd(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vaba_s32 (int32x2_t a, int32x2_t b, int32x2_t c) - /// A32: VABA.S32 Dd, Dn, Dm - /// A64: SABA Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vaba_s32 (int32x2_t a, int32x2_t b, int32x2_t c) + /// A32: VABA.S32 Dd, Dn, Dm + /// A64: SABA Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AbsoluteDifferenceAdd(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vaba_s8 (int8x8_t a, int8x8_t b, int8x8_t c) - /// A32: VABA.S8 Dd, Dn, Dm - /// A64: SABA Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vaba_s8 (int8x8_t a, int8x8_t b, int8x8_t c) + /// A32: VABA.S8 Dd, Dn, Dm + /// A64: SABA Vd.8B, Vn.8B, Vm.8B /// public static Vector64 AbsoluteDifferenceAdd(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vaba_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t c) - /// A32: VABA.U16 Dd, Dn, Dm - /// A64: UABA Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vaba_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t c) + /// A32: VABA.U16 Dd, Dn, Dm + /// A64: UABA Vd.4H, Vn.4H, Vm.4H /// public static Vector64 AbsoluteDifferenceAdd(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vaba_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t c) - /// A32: VABA.U32 Dd, Dn, Dm - /// A64: UABA Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vaba_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t c) + /// A32: VABA.U32 Dd, Dn, Dm + /// A64: UABA Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AbsoluteDifferenceAdd(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vabaq_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c) - /// A32: VABA.U8 Qd, Qn, Qm - /// A64: UABA Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vabaq_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c) + /// A32: VABA.U8 Qd, Qn, Qm + /// A64: UABA Vd.16B, Vn.16B, Vm.16B /// public static Vector128 AbsoluteDifferenceAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vabaq_s16 (int16x8_t a, int16x8_t b, int16x8_t c) - /// A32: VABA.S16 Qd, Qn, Qm - /// A64: SABA Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vabaq_s16 (int16x8_t a, int16x8_t b, int16x8_t c) + /// A32: VABA.S16 Qd, Qn, Qm + /// A64: SABA Vd.8H, Vn.8H, Vm.8H /// public static Vector128 AbsoluteDifferenceAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vabaq_s32 (int32x4_t a, int32x4_t b, int32x4_t c) - /// A32: VABA.S32 Qd, Qn, Qm - /// A64: SABA Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vabaq_s32 (int32x4_t a, int32x4_t b, int32x4_t c) + /// A32: VABA.S32 Qd, Qn, Qm + /// A64: SABA Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AbsoluteDifferenceAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vabaq_s8 (int8x16_t a, int8x16_t b, int8x16_t c) - /// A32: VABA.S8 Qd, Qn, Qm - /// A64: SABA Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vabaq_s8 (int8x16_t a, int8x16_t b, int8x16_t c) + /// A32: VABA.S8 Qd, Qn, Qm + /// A64: SABA Vd.16B, Vn.16B, Vm.16B /// public static Vector128 AbsoluteDifferenceAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vabaq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c) - /// A32: VABA.U16 Qd, Qn, Qm - /// A64: UABA Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vabaq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c) + /// A32: VABA.U16 Qd, Qn, Qm + /// A64: UABA Vd.8H, Vn.8H, Vm.8H /// public static Vector128 AbsoluteDifferenceAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vabaq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c) - /// A32: VABA.U32 Qd, Qn, Qm - /// A64: UABA Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vabaq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c) + /// A32: VABA.U32 Qd, Qn, Qm + /// A64: UABA Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AbsoluteDifferenceAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vabdl_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VABDL.U8 Qd, Dn, Dm - /// A64: UABDL Vd.8H, Vn.8B, Vm.8B + /// uint16x8_t vabdl_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VABDL.U8 Qd, Dn, Dm + /// A64: UABDL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 AbsoluteDifferenceWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vabdl_s16 (int16x4_t a, int16x4_t b) - /// A32: VABDL.S16 Qd, Dn, Dm - /// A64: SABDL Vd.4S, Vn.4H, Vm.4H + /// int32x4_t vabdl_s16 (int16x4_t a, int16x4_t b) + /// A32: VABDL.S16 Qd, Dn, Dm + /// A64: SABDL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 AbsoluteDifferenceWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vabdl_s32 (int32x2_t a, int32x2_t b) - /// A32: VABDL.S32 Qd, Dn, Dm - /// A64: SABDL Vd.2D, Vn.2S, Vm.2S + /// int64x2_t vabdl_s32 (int32x2_t a, int32x2_t b) + /// A32: VABDL.S32 Qd, Dn, Dm + /// A64: SABDL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 AbsoluteDifferenceWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vabdl_s8 (int8x8_t a, int8x8_t b) - /// A32: VABDL.S8 Qd, Dn, Dm - /// A64: SABDL Vd.8H, Vn.8B, Vm.8B + /// int16x8_t vabdl_s8 (int8x8_t a, int8x8_t b) + /// A32: VABDL.S8 Qd, Dn, Dm + /// A64: SABDL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 AbsoluteDifferenceWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vabdl_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VABDL.U16 Qd, Dn, Dm - /// A64: UABDL Vd.4S, Vn.4H, Vm.4H + /// uint32x4_t vabdl_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VABDL.U16 Qd, Dn, Dm + /// A64: UABDL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 AbsoluteDifferenceWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vabdl_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VABDL.U32 Qd, Dn, Dm - /// A64: UABDL Vd.2D, Vn.2S, Vm.2S + /// uint64x2_t vabdl_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VABDL.U32 Qd, Dn, Dm + /// A64: UABDL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 AbsoluteDifferenceWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vabal_u8 (uint16x8_t a, uint8x8_t b, uint8x8_t c) - /// A32: VABAL.U8 Qd, Dn, Dm - /// A64: UABAL Vd.8H, Vn.8B, Vm.8B + /// uint16x8_t vabal_u8 (uint16x8_t a, uint8x8_t b, uint8x8_t c) + /// A32: VABAL.U8 Qd, Dn, Dm + /// A64: UABAL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 AbsoluteDifferenceWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vabal_s16 (int32x4_t a, int16x4_t b, int16x4_t c) - /// A32: VABAL.S16 Qd, Dn, Dm - /// A64: SABAL Vd.4S, Vn.4H, Vm.4H + /// int32x4_t vabal_s16 (int32x4_t a, int16x4_t b, int16x4_t c) + /// A32: VABAL.S16 Qd, Dn, Dm + /// A64: SABAL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 AbsoluteDifferenceWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vabal_s32 (int64x2_t a, int32x2_t b, int32x2_t c) - /// A32: VABAL.S32 Qd, Dn, Dm - /// A64: SABAL Vd.2D, Vn.2S, Vm.2S + /// int64x2_t vabal_s32 (int64x2_t a, int32x2_t b, int32x2_t c) + /// A32: VABAL.S32 Qd, Dn, Dm + /// A64: SABAL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 AbsoluteDifferenceWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vabal_s8 (int16x8_t a, int8x8_t b, int8x8_t c) - /// A32: VABAL.S8 Qd, Dn, Dm - /// A64: SABAL Vd.8H, Vn.8B, Vm.8B + /// int16x8_t vabal_s8 (int16x8_t a, int8x8_t b, int8x8_t c) + /// A32: VABAL.S8 Qd, Dn, Dm + /// A64: SABAL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 AbsoluteDifferenceWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vabal_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t c) - /// A32: VABAL.U16 Qd, Dn, Dm - /// A64: UABAL Vd.4S, Vn.4H, Vm.4H + /// uint32x4_t vabal_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t c) + /// A32: VABAL.U16 Qd, Dn, Dm + /// A64: UABAL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 AbsoluteDifferenceWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vabal_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t c) - /// A32: VABAL.U32 Qd, Dn, Dm - /// A64: UABAL Vd.2D, Vn.2S, Vm.2S + /// uint64x2_t vabal_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t c) + /// A32: VABAL.U32 Qd, Dn, Dm + /// A64: UABAL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 AbsoluteDifferenceWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vabdl_high_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VABDL.U8 Qd, Dn+1, Dm+1 - /// A64: UABDL2 Vd.8H, Vn.16B, Vm.16B + /// uint16x8_t vabdl_high_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VABDL.U8 Qd, Dn+1, Dm+1 + /// A64: UABDL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 AbsoluteDifferenceWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vabdl_high_s16 (int16x8_t a, int16x8_t b) - /// A32: VABDL.S16 Qd, Dn+1, Dm+1 - /// A64: SABDL2 Vd.4S, Vn.8H, Vm.8H + /// int32x4_t vabdl_high_s16 (int16x8_t a, int16x8_t b) + /// A32: VABDL.S16 Qd, Dn+1, Dm+1 + /// A64: SABDL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 AbsoluteDifferenceWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vabdl_high_s32 (int32x4_t a, int32x4_t b) - /// A32: VABDL.S32 Qd, Dn+1, Dm+1 - /// A64: SABDL2 Vd.2D, Vn.4S, Vm.4S + /// int64x2_t vabdl_high_s32 (int32x4_t a, int32x4_t b) + /// A32: VABDL.S32 Qd, Dn+1, Dm+1 + /// A64: SABDL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 AbsoluteDifferenceWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vabdl_high_s8 (int8x16_t a, int8x16_t b) - /// A32: VABDL.S8 Qd, Dn+1, Dm+1 - /// A64: SABDL2 Vd.8H, Vn.16B, Vm.16B + /// int16x8_t vabdl_high_s8 (int8x16_t a, int8x16_t b) + /// A32: VABDL.S8 Qd, Dn+1, Dm+1 + /// A64: SABDL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 AbsoluteDifferenceWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vabdl_high_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VABDL.U16 Qd, Dn+1, Dm+1 - /// A64: UABDL2 Vd.4S, Vn.8H, Vm.8H + /// uint32x4_t vabdl_high_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VABDL.U16 Qd, Dn+1, Dm+1 + /// A64: UABDL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 AbsoluteDifferenceWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vabdl_high_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VABDL.U32 Qd, Dn+1, Dm+1 - /// A64: UABDL2 Vd.2D, Vn.4S, Vm.4S + /// uint64x2_t vabdl_high_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VABDL.U32 Qd, Dn+1, Dm+1 + /// A64: UABDL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 AbsoluteDifferenceWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vabal_high_u8 (uint16x8_t a, uint8x16_t b, uint8x16_t c) - /// A32: VABAL.U8 Qd, Dn+1, Dm+1 - /// A64: UABAL2 Vd.8H, Vn.16B, Vm.16B + /// uint16x8_t vabal_high_u8 (uint16x8_t a, uint8x16_t b, uint8x16_t c) + /// A32: VABAL.U8 Qd, Dn+1, Dm+1 + /// A64: UABAL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 AbsoluteDifferenceWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vabal_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c) - /// A32: VABAL.S16 Qd, Dn+1, Dm+1 - /// A64: SABAL2 Vd.4S, Vn.8H, Vm.8H + /// int32x4_t vabal_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c) + /// A32: VABAL.S16 Qd, Dn+1, Dm+1 + /// A64: SABAL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 AbsoluteDifferenceWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vabal_high_s32 (int64x2_t a, int32x4_t b, int32x4_t c) - /// A32: VABAL.S32 Qd, Dn+1, Dm+1 - /// A64: SABAL2 Vd.2D, Vn.4S, Vm.4S + /// int64x2_t vabal_high_s32 (int64x2_t a, int32x4_t b, int32x4_t c) + /// A32: VABAL.S32 Qd, Dn+1, Dm+1 + /// A64: SABAL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 AbsoluteDifferenceWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vabal_high_s8 (int16x8_t a, int8x16_t b, int8x16_t c) - /// A32: VABAL.S8 Qd, Dn+1, Dm+1 - /// A64: SABAL2 Vd.8H, Vn.16B, Vm.16B + /// int16x8_t vabal_high_s8 (int16x8_t a, int8x16_t b, int8x16_t c) + /// A32: VABAL.S8 Qd, Dn+1, Dm+1 + /// A64: SABAL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 AbsoluteDifferenceWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vabal_high_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t c) - /// A32: VABAL.U16 Qd, Dn+1, Dm+1 - /// A64: UABAL2 Vd.4S, Vn.8H, Vm.8H + /// uint32x4_t vabal_high_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t c) + /// A32: VABAL.U16 Qd, Dn+1, Dm+1 + /// A64: UABAL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 AbsoluteDifferenceWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vabal_high_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t c) - /// A32: VABAL.U32 Qd, Dn+1, Dm+1 - /// A64: UABAL2 Vd.2D, Vn.4S, Vm.4S + /// uint64x2_t vabal_high_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t c) + /// A32: VABAL.U32 Qd, Dn+1, Dm+1 + /// A64: UABAL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 AbsoluteDifferenceWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vadd_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VADD.I8 Dd, Dn, Dm - /// A64: ADD Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vadd_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VADD.I8 Dd, Dn, Dm + /// A64: ADD Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Add(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vadd_s16 (int16x4_t a, int16x4_t b) - /// A32: VADD.I16 Dd, Dn, Dm - /// A64: ADD Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vadd_s16 (int16x4_t a, int16x4_t b) + /// A32: VADD.I16 Dd, Dn, Dm + /// A64: ADD Vd.4H, Vn.4H, Vm.4H /// public static Vector64 Add(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vadd_s32 (int32x2_t a, int32x2_t b) - /// A32: VADD.I32 Dd, Dn, Dm - /// A64: ADD Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vadd_s32 (int32x2_t a, int32x2_t b) + /// A32: VADD.I32 Dd, Dn, Dm + /// A64: ADD Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Add(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vadd_s8 (int8x8_t a, int8x8_t b) - /// A32: VADD.I8 Dd, Dn, Dm - /// A64: ADD Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vadd_s8 (int8x8_t a, int8x8_t b) + /// A32: VADD.I8 Dd, Dn, Dm + /// A64: ADD Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Add(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vadd_f32 (float32x2_t a, float32x2_t b) - /// A32: VADD.F32 Dd, Dn, Dm - /// A64: FADD Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vadd_f32 (float32x2_t a, float32x2_t b) + /// A32: VADD.F32 Dd, Dn, Dm + /// A64: FADD Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Add(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vadd_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VADD.I16 Dd, Dn, Dm - /// A64: ADD Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vadd_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VADD.I16 Dd, Dn, Dm + /// A64: ADD Vd.4H, Vn.4H, Vm.4H /// public static Vector64 Add(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vadd_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VADD.I32 Dd, Dn, Dm - /// A64: ADD Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vadd_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VADD.I32 Dd, Dn, Dm + /// A64: ADD Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Add(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vaddq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VADD.I8 Qd, Qn, Qm - /// A64: ADD Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vaddq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VADD.I8 Qd, Qn, Qm + /// A64: ADD Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vaddq_s16 (int16x8_t a, int16x8_t b) - /// A32: VADD.I16 Qd, Qn, Qm - /// A64: ADD Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vaddq_s16 (int16x8_t a, int16x8_t b) + /// A32: VADD.I16 Qd, Qn, Qm + /// A64: ADD Vd.8H, Vn.8H, Vm.8H /// public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vaddq_s32 (int32x4_t a, int32x4_t b) - /// A32: VADD.I32 Qd, Qn, Qm - /// A64: ADD Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vaddq_s32 (int32x4_t a, int32x4_t b) + /// A32: VADD.I32 Qd, Qn, Qm + /// A64: ADD Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vaddq_s64 (int64x2_t a, int64x2_t b) - /// A32: VADD.I64 Qd, Qn, Qm - /// A64: ADD Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vaddq_s64 (int64x2_t a, int64x2_t b) + /// A32: VADD.I64 Qd, Qn, Qm + /// A64: ADD Vd.2D, Vn.2D, Vm.2D /// public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vaddq_s8 (int8x16_t a, int8x16_t b) - /// A32: VADD.I8 Qd, Qn, Qm - /// A64: ADD Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vaddq_s8 (int8x16_t a, int8x16_t b) + /// A32: VADD.I8 Qd, Qn, Qm + /// A64: ADD Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vaddq_f32 (float32x4_t a, float32x4_t b) - /// A32: VADD.F32 Qd, Qn, Qm - /// A64: FADD Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vaddq_f32 (float32x4_t a, float32x4_t b) + /// A32: VADD.F32 Qd, Qn, Qm + /// A64: FADD Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vaddq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VADD.I16 Qd, Qn, Qm - /// A64: ADD Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vaddq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VADD.I16 Qd, Qn, Qm + /// A64: ADD Vd.8H, Vn.8H, Vm.8H /// public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vaddq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VADD.I32 Qd, Qn, Qm - /// A64: ADD Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vaddq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VADD.I32 Qd, Qn, Qm + /// A64: ADD Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vaddq_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VADD.I64 Qd, Qn, Qm - /// A64: ADD Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vaddq_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VADD.I64 Qd, Qn, Qm + /// A64: ADD Vd.2D, Vn.2D, Vm.2D /// public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vaddhn_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VADDHN.I16 Dd, Qn, Qm - /// A64: ADDHN Vd.8B, Vn.8H, Vm.8H + /// uint8x8_t vaddhn_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VADDHN.I16 Dd, Qn, Qm + /// A64: ADDHN Vd.8B, Vn.8H, Vm.8H /// public static Vector64 AddHighNarrowingLower(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vaddhn_s32 (int32x4_t a, int32x4_t b) - /// A32: VADDHN.I32 Dd, Qn, Qm - /// A64: ADDHN Vd.4H, Vn.4S, Vm.4S + /// int16x4_t vaddhn_s32 (int32x4_t a, int32x4_t b) + /// A32: VADDHN.I32 Dd, Qn, Qm + /// A64: ADDHN Vd.4H, Vn.4S, Vm.4S /// public static Vector64 AddHighNarrowingLower(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vaddhn_s64 (int64x2_t a, int64x2_t b) - /// A32: VADDHN.I64 Dd, Qn, Qm - /// A64: ADDHN Vd.2S, Vn.2D, Vm.2D + /// int32x2_t vaddhn_s64 (int64x2_t a, int64x2_t b) + /// A32: VADDHN.I64 Dd, Qn, Qm + /// A64: ADDHN Vd.2S, Vn.2D, Vm.2D /// public static Vector64 AddHighNarrowingLower(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vaddhn_s16 (int16x8_t a, int16x8_t b) - /// A32: VADDHN.I16 Dd, Qn, Qm - /// A64: ADDHN Vd.8B, Vn.8H, Vm.8H + /// int8x8_t vaddhn_s16 (int16x8_t a, int16x8_t b) + /// A32: VADDHN.I16 Dd, Qn, Qm + /// A64: ADDHN Vd.8B, Vn.8H, Vm.8H /// public static Vector64 AddHighNarrowingLower(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vaddhn_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VADDHN.I32 Dd, Qn, Qm - /// A64: ADDHN Vd.4H, Vn.4S, Vm.4S + /// uint16x4_t vaddhn_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VADDHN.I32 Dd, Qn, Qm + /// A64: ADDHN Vd.4H, Vn.4S, Vm.4S /// public static Vector64 AddHighNarrowingLower(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vaddhn_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VADDHN.I64 Dd, Qn, Qm - /// A64: ADDHN Vd.2S, Vn.2D, Vm.2D + /// uint32x2_t vaddhn_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VADDHN.I64 Dd, Qn, Qm + /// A64: ADDHN Vd.2S, Vn.2D, Vm.2D /// public static Vector64 AddHighNarrowingLower(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vaddhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b) - /// A32: VADDHN.I16 Dd+1, Qn, Qm - /// A64: ADDHN2 Vd.16B, Vn.8H, Vm.8H + /// uint8x16_t vaddhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b) + /// A32: VADDHN.I16 Dd+1, Qn, Qm + /// A64: ADDHN2 Vd.16B, Vn.8H, Vm.8H /// public static Vector128 AddHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vaddhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b) - /// A32: VADDHN.I32 Dd+1, Qn, Qm - /// A64: ADDHN2 Vd.8H, Vn.4S, Vm.4S + /// int16x8_t vaddhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b) + /// A32: VADDHN.I32 Dd+1, Qn, Qm + /// A64: ADDHN2 Vd.8H, Vn.4S, Vm.4S /// public static Vector128 AddHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vaddhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b) - /// A32: VADDHN.I64 Dd+1, Qn, Qm - /// A64: ADDHN2 Vd.4S, Vn.2D, Vm.2D + /// int32x4_t vaddhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b) + /// A32: VADDHN.I64 Dd+1, Qn, Qm + /// A64: ADDHN2 Vd.4S, Vn.2D, Vm.2D /// public static Vector128 AddHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vaddhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b) - /// A32: VADDHN.I16 Dd+1, Qn, Qm - /// A64: ADDHN2 Vd.16B, Vn.8H, Vm.8H + /// int8x16_t vaddhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b) + /// A32: VADDHN.I16 Dd+1, Qn, Qm + /// A64: ADDHN2 Vd.16B, Vn.8H, Vm.8H /// public static Vector128 AddHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vaddhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b) - /// A32: VADDHN.I32 Dd+1, Qn, Qm - /// A64: ADDHN2 Vd.8H, Vn.4S, Vm.4S + /// uint16x8_t vaddhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b) + /// A32: VADDHN.I32 Dd+1, Qn, Qm + /// A64: ADDHN2 Vd.8H, Vn.4S, Vm.4S /// public static Vector128 AddHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vaddhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b) - /// A32: VADDHN.I64 Dd+1, Qn, Qm - /// A64: ADDHN2 Vd.4S, Vn.2D, Vm.2D + /// uint32x4_t vaddhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b) + /// A32: VADDHN.I64 Dd+1, Qn, Qm + /// A64: ADDHN2 Vd.4S, Vn.2D, Vm.2D /// public static Vector128 AddHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vpadd_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VPADD.I8 Dd, Dn, Dm - /// A64: ADDP Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vpadd_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VPADD.I8 Dd, Dn, Dm + /// A64: ADDP Vd.8B, Vn.8B, Vm.8B /// public static Vector64 AddPairwise(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vpadd_s16 (int16x4_t a, int16x4_t b) - /// A32: VPADD.I16 Dd, Dn, Dm - /// A64: ADDP Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vpadd_s16 (int16x4_t a, int16x4_t b) + /// A32: VPADD.I16 Dd, Dn, Dm + /// A64: ADDP Vd.4H, Vn.4H, Vm.4H /// public static Vector64 AddPairwise(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vpadd_s32 (int32x2_t a, int32x2_t b) - /// A32: VPADD.I32 Dd, Dn, Dm - /// A64: ADDP Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vpadd_s32 (int32x2_t a, int32x2_t b) + /// A32: VPADD.I32 Dd, Dn, Dm + /// A64: ADDP Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AddPairwise(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vpadd_s8 (int8x8_t a, int8x8_t b) - /// A32: VPADD.I8 Dd, Dn, Dm - /// A64: ADDP Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vpadd_s8 (int8x8_t a, int8x8_t b) + /// A32: VPADD.I8 Dd, Dn, Dm + /// A64: ADDP Vd.8B, Vn.8B, Vm.8B /// public static Vector64 AddPairwise(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vpadd_f32 (float32x2_t a, float32x2_t b) - /// A32: VPADD.F32 Dd, Dn, Dm - /// A64: FADDP Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vpadd_f32 (float32x2_t a, float32x2_t b) + /// A32: VPADD.F32 Dd, Dn, Dm + /// A64: FADDP Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AddPairwise(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vpadd_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VPADD.I16 Dd, Dn, Dm - /// A64: ADDP Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vpadd_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VPADD.I16 Dd, Dn, Dm + /// A64: ADDP Vd.4H, Vn.4H, Vm.4H /// public static Vector64 AddPairwise(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vpadd_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VPADD.I32 Dd, Dn, Dm - /// A64: ADDP Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vpadd_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VPADD.I32 Dd, Dn, Dm + /// A64: ADDP Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AddPairwise(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vpaddl_u8 (uint8x8_t a) - /// A32: VPADDL.U8 Dd, Dm - /// A64: UADDLP Vd.4H, Vn.8B + /// uint16x4_t vpaddl_u8 (uint8x8_t a) + /// A32: VPADDL.U8 Dd, Dm + /// A64: UADDLP Vd.4H, Vn.8B /// public static Vector64 AddPairwiseWidening(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vpaddl_s16 (int16x4_t a) - /// A32: VPADDL.S16 Dd, Dm - /// A64: SADDLP Vd.2S, Vn.4H + /// int32x2_t vpaddl_s16 (int16x4_t a) + /// A32: VPADDL.S16 Dd, Dm + /// A64: SADDLP Vd.2S, Vn.4H /// public static Vector64 AddPairwiseWidening(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vpaddl_s8 (int8x8_t a) - /// A32: VPADDL.S8 Dd, Dm - /// A64: SADDLP Vd.4H, Vn.8B + /// int16x4_t vpaddl_s8 (int8x8_t a) + /// A32: VPADDL.S8 Dd, Dm + /// A64: SADDLP Vd.4H, Vn.8B /// public static Vector64 AddPairwiseWidening(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vpaddl_u16 (uint16x4_t a) - /// A32: VPADDL.U16 Dd, Dm - /// A64: UADDLP Vd.2S, Vn.4H + /// uint32x2_t vpaddl_u16 (uint16x4_t a) + /// A32: VPADDL.U16 Dd, Dm + /// A64: UADDLP Vd.2S, Vn.4H /// public static Vector64 AddPairwiseWidening(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vpaddlq_u8 (uint8x16_t a) - /// A32: VPADDL.U8 Qd, Qm - /// A64: UADDLP Vd.8H, Vn.16B + /// uint16x8_t vpaddlq_u8 (uint8x16_t a) + /// A32: VPADDL.U8 Qd, Qm + /// A64: UADDLP Vd.8H, Vn.16B /// public static Vector128 AddPairwiseWidening(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vpaddlq_s16 (int16x8_t a) - /// A32: VPADDL.S16 Qd, Qm - /// A64: SADDLP Vd.4S, Vn.8H + /// int32x4_t vpaddlq_s16 (int16x8_t a) + /// A32: VPADDL.S16 Qd, Qm + /// A64: SADDLP Vd.4S, Vn.8H /// public static Vector128 AddPairwiseWidening(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vpaddlq_s32 (int32x4_t a) - /// A32: VPADDL.S32 Qd, Qm - /// A64: SADDLP Vd.2D, Vn.4S + /// int64x2_t vpaddlq_s32 (int32x4_t a) + /// A32: VPADDL.S32 Qd, Qm + /// A64: SADDLP Vd.2D, Vn.4S /// public static Vector128 AddPairwiseWidening(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vpaddlq_s8 (int8x16_t a) - /// A32: VPADDL.S8 Qd, Qm - /// A64: SADDLP Vd.8H, Vn.16B + /// int16x8_t vpaddlq_s8 (int8x16_t a) + /// A32: VPADDL.S8 Qd, Qm + /// A64: SADDLP Vd.8H, Vn.16B /// public static Vector128 AddPairwiseWidening(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vpaddlq_u16 (uint16x8_t a) - /// A32: VPADDL.U16 Qd, Qm - /// A64: UADDLP Vd.4S, Vn.8H + /// uint32x4_t vpaddlq_u16 (uint16x8_t a) + /// A32: VPADDL.U16 Qd, Qm + /// A64: UADDLP Vd.4S, Vn.8H /// public static Vector128 AddPairwiseWidening(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vpaddlq_u32 (uint32x4_t a) - /// A32: VPADDL.U32 Qd, Qm - /// A64: UADDLP Vd.2D, Vn.4S + /// uint64x2_t vpaddlq_u32 (uint32x4_t a) + /// A32: VPADDL.U32 Qd, Qm + /// A64: UADDLP Vd.2D, Vn.4S /// public static Vector128 AddPairwiseWidening(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vpadal_u8 (uint16x4_t a, uint8x8_t b) - /// A32: VPADAL.U8 Dd, Dm - /// A64: UADALP Vd.4H, Vn.8B + /// uint16x4_t vpadal_u8 (uint16x4_t a, uint8x8_t b) + /// A32: VPADAL.U8 Dd, Dm + /// A64: UADALP Vd.4H, Vn.8B /// public static Vector64 AddPairwiseWideningAndAdd(Vector64 addend, Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vpadal_s16 (int32x2_t a, int16x4_t b) - /// A32: VPADAL.S16 Dd, Dm - /// A64: SADALP Vd.2S, Vn.4H + /// int32x2_t vpadal_s16 (int32x2_t a, int16x4_t b) + /// A32: VPADAL.S16 Dd, Dm + /// A64: SADALP Vd.2S, Vn.4H /// public static Vector64 AddPairwiseWideningAndAdd(Vector64 addend, Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vpadal_s8 (int16x4_t a, int8x8_t b) - /// A32: VPADAL.S8 Dd, Dm - /// A64: SADALP Vd.4H, Vn.8B + /// int16x4_t vpadal_s8 (int16x4_t a, int8x8_t b) + /// A32: VPADAL.S8 Dd, Dm + /// A64: SADALP Vd.4H, Vn.8B /// public static Vector64 AddPairwiseWideningAndAdd(Vector64 addend, Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vpadal_u16 (uint32x2_t a, uint16x4_t b) - /// A32: VPADAL.U16 Dd, Dm - /// A64: UADALP Vd.2S, Vn.4H + /// uint32x2_t vpadal_u16 (uint32x2_t a, uint16x4_t b) + /// A32: VPADAL.U16 Dd, Dm + /// A64: UADALP Vd.2S, Vn.4H /// public static Vector64 AddPairwiseWideningAndAdd(Vector64 addend, Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vpadalq_u8 (uint16x8_t a, uint8x16_t b) - /// A32: VPADAL.U8 Qd, Qm - /// A64: UADALP Vd.8H, Vn.16B + /// uint16x8_t vpadalq_u8 (uint16x8_t a, uint8x16_t b) + /// A32: VPADAL.U8 Qd, Qm + /// A64: UADALP Vd.8H, Vn.16B /// public static Vector128 AddPairwiseWideningAndAdd(Vector128 addend, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vpadalq_s16 (int32x4_t a, int16x8_t b) - /// A32: VPADAL.S16 Qd, Qm - /// A64: SADALP Vd.4S, Vn.8H + /// int32x4_t vpadalq_s16 (int32x4_t a, int16x8_t b) + /// A32: VPADAL.S16 Qd, Qm + /// A64: SADALP Vd.4S, Vn.8H /// public static Vector128 AddPairwiseWideningAndAdd(Vector128 addend, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vpadalq_s32 (int64x2_t a, int32x4_t b) - /// A32: VPADAL.S32 Qd, Qm - /// A64: SADALP Vd.2D, Vn.4S + /// int64x2_t vpadalq_s32 (int64x2_t a, int32x4_t b) + /// A32: VPADAL.S32 Qd, Qm + /// A64: SADALP Vd.2D, Vn.4S /// public static Vector128 AddPairwiseWideningAndAdd(Vector128 addend, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vpadalq_s8 (int16x8_t a, int8x16_t b) - /// A32: VPADAL.S8 Qd, Qm - /// A64: SADALP Vd.8H, Vn.16B + /// int16x8_t vpadalq_s8 (int16x8_t a, int8x16_t b) + /// A32: VPADAL.S8 Qd, Qm + /// A64: SADALP Vd.8H, Vn.16B /// public static Vector128 AddPairwiseWideningAndAdd(Vector128 addend, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vpadalq_u16 (uint32x4_t a, uint16x8_t b) - /// A32: VPADAL.U16 Qd, Qm - /// A64: UADALP Vd.4S, Vn.8H + /// uint32x4_t vpadalq_u16 (uint32x4_t a, uint16x8_t b) + /// A32: VPADAL.U16 Qd, Qm + /// A64: UADALP Vd.4S, Vn.8H /// public static Vector128 AddPairwiseWideningAndAdd(Vector128 addend, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vpadalq_u32 (uint64x2_t a, uint32x4_t b) - /// A32: VPADAL.U32 Qd, Qm - /// A64: UADALP Vd.2D, Vn.4S + /// uint64x2_t vpadalq_u32 (uint64x2_t a, uint32x4_t b) + /// A32: VPADAL.U32 Qd, Qm + /// A64: UADALP Vd.2D, Vn.4S /// public static Vector128 AddPairwiseWideningAndAdd(Vector128 addend, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vpadal_s32 (int64x1_t a, int32x2_t b) - /// A32: VPADAL.S32 Dd, Dm - /// A64: SADALP Vd.1D, Vn.2S + /// int64x1_t vpadal_s32 (int64x1_t a, int32x2_t b) + /// A32: VPADAL.S32 Dd, Dm + /// A64: SADALP Vd.1D, Vn.2S /// public static Vector64 AddPairwiseWideningAndAddScalar(Vector64 addend, Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vpadal_u32 (uint64x1_t a, uint32x2_t b) - /// A32: VPADAL.U32 Dd, Dm - /// A64: UADALP Vd.1D, Vn.2S + /// uint64x1_t vpadal_u32 (uint64x1_t a, uint32x2_t b) + /// A32: VPADAL.U32 Dd, Dm + /// A64: UADALP Vd.1D, Vn.2S /// public static Vector64 AddPairwiseWideningAndAddScalar(Vector64 addend, Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vpaddl_s32 (int32x2_t a) - /// A32: VPADDL.S32 Dd, Dm - /// A64: SADDLP Dd, Vn.2S + /// int64x1_t vpaddl_s32 (int32x2_t a) + /// A32: VPADDL.S32 Dd, Dm + /// A64: SADDLP Dd, Vn.2S /// public static Vector64 AddPairwiseWideningScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vpaddl_u32 (uint32x2_t a) - /// A32: VPADDL.U32 Dd, Dm - /// A64: UADDLP Dd, Vn.2S + /// uint64x1_t vpaddl_u32 (uint32x2_t a) + /// A32: VPADDL.U32 Dd, Dm + /// A64: UADDLP Dd, Vn.2S /// public static Vector64 AddPairwiseWideningScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vraddhn_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VRADDHN.I16 Dd, Qn, Qm - /// A64: RADDHN Vd.8B, Vn.8H, Vm.8H + /// uint8x8_t vraddhn_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VRADDHN.I16 Dd, Qn, Qm + /// A64: RADDHN Vd.8B, Vn.8H, Vm.8H /// public static Vector64 AddRoundedHighNarrowingLower(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vraddhn_s32 (int32x4_t a, int32x4_t b) - /// A32: VRADDHN.I32 Dd, Qn, Qm - /// A64: RADDHN Vd.4H, Vn.4S, Vm.4S + /// int16x4_t vraddhn_s32 (int32x4_t a, int32x4_t b) + /// A32: VRADDHN.I32 Dd, Qn, Qm + /// A64: RADDHN Vd.4H, Vn.4S, Vm.4S /// public static Vector64 AddRoundedHighNarrowingLower(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vraddhn_s64 (int64x2_t a, int64x2_t b) - /// A32: VRADDHN.I64 Dd, Qn, Qm - /// A64: RADDHN Vd.2S, Vn.2D, Vm.2D + /// int32x2_t vraddhn_s64 (int64x2_t a, int64x2_t b) + /// A32: VRADDHN.I64 Dd, Qn, Qm + /// A64: RADDHN Vd.2S, Vn.2D, Vm.2D /// public static Vector64 AddRoundedHighNarrowingLower(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vraddhn_s16 (int16x8_t a, int16x8_t b) - /// A32: VRADDHN.I16 Dd, Qn, Qm - /// A64: RADDHN Vd.8B, Vn.8H, Vm.8H + /// int8x8_t vraddhn_s16 (int16x8_t a, int16x8_t b) + /// A32: VRADDHN.I16 Dd, Qn, Qm + /// A64: RADDHN Vd.8B, Vn.8H, Vm.8H /// public static Vector64 AddRoundedHighNarrowingLower(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vraddhn_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VRADDHN.I32 Dd, Qn, Qm - /// A64: RADDHN Vd.4H, Vn.4S, Vm.4S + /// uint16x4_t vraddhn_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VRADDHN.I32 Dd, Qn, Qm + /// A64: RADDHN Vd.4H, Vn.4S, Vm.4S /// public static Vector64 AddRoundedHighNarrowingLower(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vraddhn_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VRADDHN.I64 Dd, Qn, Qm - /// A64: RADDHN Vd.2S, Vn.2D, Vm.2D + /// uint32x2_t vraddhn_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VRADDHN.I64 Dd, Qn, Qm + /// A64: RADDHN Vd.2S, Vn.2D, Vm.2D /// public static Vector64 AddRoundedHighNarrowingLower(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vraddhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b) - /// A32: VRADDHN.I16 Dd+1, Qn, Qm - /// A64: RADDHN2 Vd.16B, Vn.8H, Vm.8H + /// uint8x16_t vraddhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b) + /// A32: VRADDHN.I16 Dd+1, Qn, Qm + /// A64: RADDHN2 Vd.16B, Vn.8H, Vm.8H /// public static Vector128 AddRoundedHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vraddhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b) - /// A32: VRADDHN.I32 Dd+1, Qn, Qm - /// A64: RADDHN2 Vd.8H, Vn.4S, Vm.4S + /// int16x8_t vraddhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b) + /// A32: VRADDHN.I32 Dd+1, Qn, Qm + /// A64: RADDHN2 Vd.8H, Vn.4S, Vm.4S /// public static Vector128 AddRoundedHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vraddhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b) - /// A32: VRADDHN.I64 Dd+1, Qn, Qm - /// A64: RADDHN2 Vd.4S, Vn.2D, Vm.2D + /// int32x4_t vraddhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b) + /// A32: VRADDHN.I64 Dd+1, Qn, Qm + /// A64: RADDHN2 Vd.4S, Vn.2D, Vm.2D /// public static Vector128 AddRoundedHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vraddhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b) - /// A32: VRADDHN.I16 Dd+1, Qn, Qm - /// A64: RADDHN2 Vd.16B, Vn.8H, Vm.8H + /// int8x16_t vraddhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b) + /// A32: VRADDHN.I16 Dd+1, Qn, Qm + /// A64: RADDHN2 Vd.16B, Vn.8H, Vm.8H /// public static Vector128 AddRoundedHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vraddhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b) - /// A32: VRADDHN.I32 Dd+1, Qn, Qm - /// A64: RADDHN2 Vd.8H, Vn.4S, Vm.4S + /// uint16x8_t vraddhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b) + /// A32: VRADDHN.I32 Dd+1, Qn, Qm + /// A64: RADDHN2 Vd.8H, Vn.4S, Vm.4S /// public static Vector128 AddRoundedHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vraddhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b) - /// A32: VRADDHN.I64 Dd+1, Qn, Qm - /// A64: RADDHN2 Vd.4S, Vn.2D, Vm.2D + /// uint32x4_t vraddhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b) + /// A32: VRADDHN.I64 Dd+1, Qn, Qm + /// A64: RADDHN2 Vd.4S, Vn.2D, Vm.2D /// public static Vector128 AddRoundedHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vqadd_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VQADD.U8 Dd, Dn, Dm - /// A64: UQADD Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vqadd_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VQADD.U8 Dd, Dn, Dm + /// A64: UQADD Vd.8B, Vn.8B, Vm.8B /// public static Vector64 AddSaturate(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vqadd_s16 (int16x4_t a, int16x4_t b) - /// A32: VQADD.S16 Dd, Dn, Dm - /// A64: SQADD Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vqadd_s16 (int16x4_t a, int16x4_t b) + /// A32: VQADD.S16 Dd, Dn, Dm + /// A64: SQADD Vd.4H, Vn.4H, Vm.4H /// public static Vector64 AddSaturate(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vqadd_s32 (int32x2_t a, int32x2_t b) - /// A32: VQADD.S32 Dd, Dn, Dm - /// A64: SQADD Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vqadd_s32 (int32x2_t a, int32x2_t b) + /// A32: VQADD.S32 Dd, Dn, Dm + /// A64: SQADD Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AddSaturate(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vqadd_s8 (int8x8_t a, int8x8_t b) - /// A32: VQADD.S8 Dd, Dn, Dm - /// A64: SQADD Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vqadd_s8 (int8x8_t a, int8x8_t b) + /// A32: VQADD.S8 Dd, Dn, Dm + /// A64: SQADD Vd.8B, Vn.8B, Vm.8B /// public static Vector64 AddSaturate(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vqadd_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VQADD.U16 Dd, Dn, Dm - /// A64: UQADD Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vqadd_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VQADD.U16 Dd, Dn, Dm + /// A64: UQADD Vd.4H, Vn.4H, Vm.4H /// public static Vector64 AddSaturate(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vqadd_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VQADD.U32 Dd, Dn, Dm - /// A64: UQADD Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vqadd_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VQADD.U32 Dd, Dn, Dm + /// A64: UQADD Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AddSaturate(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vqaddq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VQADD.U8 Qd, Qn, Qm - /// A64: UQADD Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vqaddq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VQADD.U8 Qd, Qn, Qm + /// A64: UQADD Vd.16B, Vn.16B, Vm.16B /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vqaddq_s16 (int16x8_t a, int16x8_t b) - /// A32: VQADD.S16 Qd, Qn, Qm - /// A64: SQADD Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vqaddq_s16 (int16x8_t a, int16x8_t b) + /// A32: VQADD.S16 Qd, Qn, Qm + /// A64: SQADD Vd.8H, Vn.8H, Vm.8H /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqaddq_s32 (int32x4_t a, int32x4_t b) - /// A32: VQADD.S32 Qd, Qn, Qm - /// A64: SQADD Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vqaddq_s32 (int32x4_t a, int32x4_t b) + /// A32: VQADD.S32 Qd, Qn, Qm + /// A64: SQADD Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqaddq_s64 (int64x2_t a, int64x2_t b) - /// A32: VQADD.S64 Qd, Qn, Qm - /// A64: SQADD Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vqaddq_s64 (int64x2_t a, int64x2_t b) + /// A32: VQADD.S64 Qd, Qn, Qm + /// A64: SQADD Vd.2D, Vn.2D, Vm.2D /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vqaddq_s8 (int8x16_t a, int8x16_t b) - /// A32: VQADD.S8 Qd, Qn, Qm - /// A64: SQADD Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vqaddq_s8 (int8x16_t a, int8x16_t b) + /// A32: VQADD.S8 Qd, Qn, Qm + /// A64: SQADD Vd.16B, Vn.16B, Vm.16B /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vqaddq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VQADD.U16 Qd, Qn, Qm - /// A64: UQADD Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vqaddq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VQADD.U16 Qd, Qn, Qm + /// A64: UQADD Vd.8H, Vn.8H, Vm.8H /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vqaddq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VQADD.U32 Qd, Qn, Qm - /// A64: UQADD Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vqaddq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VQADD.U32 Qd, Qn, Qm + /// A64: UQADD Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vqaddq_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VQADD.U64 Qd, Qn, Qm - /// A64: UQADD Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vqaddq_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VQADD.U64 Qd, Qn, Qm + /// A64: UQADD Vd.2D, Vn.2D, Vm.2D /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vqadd_s64 (int64x1_t a, int64x1_t b) - /// A32: VQADD.S64 Dd, Dn, Dm - /// A64: SQADD Dd, Dn, Dm + /// int64x1_t vqadd_s64 (int64x1_t a, int64x1_t b) + /// A32: VQADD.S64 Dd, Dn, Dm + /// A64: SQADD Dd, Dn, Dm /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vqadd_u64 (uint64x1_t a, uint64x1_t b) - /// A32: VQADD.U64 Dd, Dn, Dm - /// A64: UQADD Dd, Dn, Dm + /// uint64x1_t vqadd_u64 (uint64x1_t a, uint64x1_t b) + /// A32: VQADD.U64 Dd, Dn, Dm + /// A64: UQADD Dd, Dn, Dm /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vadd_f64 (float64x1_t a, float64x1_t b) - /// A32: VADD.F64 Dd, Dn, Dm - /// A64: FADD Dd, Dn, Dm + /// float64x1_t vadd_f64 (float64x1_t a, float64x1_t b) + /// A32: VADD.F64 Dd, Dn, Dm + /// A64: FADD Dd, Dn, Dm /// public static Vector64 AddScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vadd_s64 (int64x1_t a, int64x1_t b) - /// A32: VADD.I64 Dd, Dn, Dm - /// A64: ADD Dd, Dn, Dm + /// int64x1_t vadd_s64 (int64x1_t a, int64x1_t b) + /// A32: VADD.I64 Dd, Dn, Dm + /// A64: ADD Dd, Dn, Dm /// public static Vector64 AddScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32_t vadds_f32 (float32_t a, float32_t b) - /// A32: VADD.F32 Sd, Sn, Sm - /// A64: FADD Sd, Sn, Sm - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vadds_f32 (float32_t a, float32_t b) + /// A32: VADD.F32 Sd, Sn, Sm + /// A64: FADD Sd, Sn, Sm + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 AddScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vadd_u64 (uint64x1_t a, uint64x1_t b) - /// A32: VADD.I64 Dd, Dn, Dm - /// A64: ADD Dd, Dn, Dm + /// uint64x1_t vadd_u64 (uint64x1_t a, uint64x1_t b) + /// A32: VADD.I64 Dd, Dn, Dm + /// A64: ADD Dd, Dn, Dm /// public static Vector64 AddScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vaddl_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VADDL.U8 Qd, Dn, Dm - /// A64: UADDL Vd.8H, Vn.8B, Vm.8B + /// uint16x8_t vaddl_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VADDL.U8 Qd, Dn, Dm + /// A64: UADDL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 AddWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vaddl_s16 (int16x4_t a, int16x4_t b) - /// A32: VADDL.S16 Qd, Dn, Dm - /// A64: SADDL Vd.4S, Vn.4H, Vm.4H + /// int32x4_t vaddl_s16 (int16x4_t a, int16x4_t b) + /// A32: VADDL.S16 Qd, Dn, Dm + /// A64: SADDL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 AddWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vaddl_s32 (int32x2_t a, int32x2_t b) - /// A32: VADDL.S32 Qd, Dn, Dm - /// A64: SADDL Vd.2D, Vn.2S, Vm.2S + /// int64x2_t vaddl_s32 (int32x2_t a, int32x2_t b) + /// A32: VADDL.S32 Qd, Dn, Dm + /// A64: SADDL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 AddWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vaddl_s8 (int8x8_t a, int8x8_t b) - /// A32: VADDL.S8 Qd, Dn, Dm - /// A64: SADDL Vd.8H, Vn.8B, Vm.8B + /// int16x8_t vaddl_s8 (int8x8_t a, int8x8_t b) + /// A32: VADDL.S8 Qd, Dn, Dm + /// A64: SADDL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 AddWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vaddl_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VADDL.U16 Qd, Dn, Dm - /// A64: UADDL Vd.4S, Vn.4H, Vm.4H + /// uint32x4_t vaddl_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VADDL.U16 Qd, Dn, Dm + /// A64: UADDL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 AddWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vaddl_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VADDL.U32 Qd, Dn, Dm - /// A64: UADDL Vd.2D, Vn.2S, Vm.2S + /// uint64x2_t vaddl_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VADDL.U32 Qd, Dn, Dm + /// A64: UADDL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 AddWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vaddw_s8 (int16x8_t a, int8x8_t b) - /// A32: VADDW.S8 Qd, Qn, Dm - /// A64: SADDW Vd.8H, Vn.8H, Vm.8B + /// int16x8_t vaddw_s8 (int16x8_t a, int8x8_t b) + /// A32: VADDW.S8 Qd, Qn, Dm + /// A64: SADDW Vd.8H, Vn.8H, Vm.8B /// public static Vector128 AddWideningLower(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vaddw_s16 (int32x4_t a, int16x4_t b) - /// A32: VADDW.S16 Qd, Qn, Dm - /// A64: SADDW Vd.4S, Vn.4S, Vm.4H + /// int32x4_t vaddw_s16 (int32x4_t a, int16x4_t b) + /// A32: VADDW.S16 Qd, Qn, Dm + /// A64: SADDW Vd.4S, Vn.4S, Vm.4H /// public static Vector128 AddWideningLower(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vaddw_s32 (int64x2_t a, int32x2_t b) - /// A32: VADDW.S32 Qd, Qn, Dm - /// A64: SADDW Vd.2D, Vn.2D, Vm.2S + /// int64x2_t vaddw_s32 (int64x2_t a, int32x2_t b) + /// A32: VADDW.S32 Qd, Qn, Dm + /// A64: SADDW Vd.2D, Vn.2D, Vm.2S /// public static Vector128 AddWideningLower(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vaddw_u8 (uint16x8_t a, uint8x8_t b) - /// A32: VADDW.U8 Qd, Qn, Dm - /// A64: UADDW Vd.8H, Vn.8H, Vm.8B + /// uint16x8_t vaddw_u8 (uint16x8_t a, uint8x8_t b) + /// A32: VADDW.U8 Qd, Qn, Dm + /// A64: UADDW Vd.8H, Vn.8H, Vm.8B /// public static Vector128 AddWideningLower(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vaddw_u16 (uint32x4_t a, uint16x4_t b) - /// A32: VADDW.U16 Qd, Qn, Dm - /// A64: UADDW Vd.4S, Vn.4S, Vm.4H + /// uint32x4_t vaddw_u16 (uint32x4_t a, uint16x4_t b) + /// A32: VADDW.U16 Qd, Qn, Dm + /// A64: UADDW Vd.4S, Vn.4S, Vm.4H /// public static Vector128 AddWideningLower(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vaddw_u32 (uint64x2_t a, uint32x2_t b) - /// A32: VADDW.U32 Qd, Qn, Dm - /// A64: UADDW Vd.2D, Vn.2D, Vm.2S + /// uint64x2_t vaddw_u32 (uint64x2_t a, uint32x2_t b) + /// A32: VADDW.U32 Qd, Qn, Dm + /// A64: UADDW Vd.2D, Vn.2D, Vm.2S /// public static Vector128 AddWideningLower(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vaddl_high_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VADDL.U8 Qd, Dn+1, Dm+1 - /// A64: UADDL2 Vd.8H, Vn.16B, Vm.16B + /// uint16x8_t vaddl_high_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VADDL.U8 Qd, Dn+1, Dm+1 + /// A64: UADDL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 AddWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vaddl_high_s16 (int16x8_t a, int16x8_t b) - /// A32: VADDL.S16 Qd, Dn+1, Dm+1 - /// A64: SADDL2 Vd.4S, Vn.8H, Vm.8H + /// int32x4_t vaddl_high_s16 (int16x8_t a, int16x8_t b) + /// A32: VADDL.S16 Qd, Dn+1, Dm+1 + /// A64: SADDL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 AddWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vaddw_high_s8 (int16x8_t a, int8x16_t b) - /// A32: VADDW.S8 Qd, Qn, Dm+1 - /// A64: SADDW2 Vd.8H, Vn.8H, Vm.16B + /// int16x8_t vaddw_high_s8 (int16x8_t a, int8x16_t b) + /// A32: VADDW.S8 Qd, Qn, Dm+1 + /// A64: SADDW2 Vd.8H, Vn.8H, Vm.16B /// public static Vector128 AddWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vaddw_high_s16 (int32x4_t a, int16x8_t b) - /// A32: VADDW.S16 Qd, Qn, Dm+1 - /// A64: SADDW2 Vd.4S, Vn.4S, Vm.8H + /// int32x4_t vaddw_high_s16 (int32x4_t a, int16x8_t b) + /// A32: VADDW.S16 Qd, Qn, Dm+1 + /// A64: SADDW2 Vd.4S, Vn.4S, Vm.8H /// public static Vector128 AddWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vaddl_high_s32 (int32x4_t a, int32x4_t b) - /// A32: VADDL.S32 Qd, Dn+1, Dm+1 - /// A64: SADDL2 Vd.2D, Vn.4S, Vm.4S + /// int64x2_t vaddl_high_s32 (int32x4_t a, int32x4_t b) + /// A32: VADDL.S32 Qd, Dn+1, Dm+1 + /// A64: SADDL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 AddWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vaddw_high_s32 (int64x2_t a, int32x4_t b) - /// A32: VADDW.S32 Qd, Qn, Dm+1 - /// A64: SADDW2 Vd.2D, Vn.2D, Vm.4S + /// int64x2_t vaddw_high_s32 (int64x2_t a, int32x4_t b) + /// A32: VADDW.S32 Qd, Qn, Dm+1 + /// A64: SADDW2 Vd.2D, Vn.2D, Vm.4S /// public static Vector128 AddWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vaddl_high_s8 (int8x16_t a, int8x16_t b) - /// A32: VADDL.S8 Qd, Dn+1, Dm+1 - /// A64: SADDL2 Vd.8H, Vn.16B, Vm.16B + /// int16x8_t vaddl_high_s8 (int8x16_t a, int8x16_t b) + /// A32: VADDL.S8 Qd, Dn+1, Dm+1 + /// A64: SADDL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 AddWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vaddw_high_u8 (uint16x8_t a, uint8x16_t b) - /// A32: VADDW.U8 Qd, Qn, Dm+1 - /// A64: UADDW2 Vd.8H, Vn.8H, Vm.16B + /// uint16x8_t vaddw_high_u8 (uint16x8_t a, uint8x16_t b) + /// A32: VADDW.U8 Qd, Qn, Dm+1 + /// A64: UADDW2 Vd.8H, Vn.8H, Vm.16B /// public static Vector128 AddWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vaddl_high_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VADDL.U16 Qd, Dn+1, Dm+1 - /// A64: UADDL2 Vd.4S, Vn.8H, Vm.8H + /// uint32x4_t vaddl_high_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VADDL.U16 Qd, Dn+1, Dm+1 + /// A64: UADDL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 AddWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vaddw_high_u16 (uint32x4_t a, uint16x8_t b) - /// A32: VADDW.U16 Qd, Qn, Dm+1 - /// A64: UADDW2 Vd.4S, Vn.4S, Vm.8H + /// uint32x4_t vaddw_high_u16 (uint32x4_t a, uint16x8_t b) + /// A32: VADDW.U16 Qd, Qn, Dm+1 + /// A64: UADDW2 Vd.4S, Vn.4S, Vm.8H /// public static Vector128 AddWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vaddl_high_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VADDL.U32 Qd, Dn+1, Dm+1 - /// A64: UADDL2 Vd.2D, Vn.4S, Vm.4S + /// uint64x2_t vaddl_high_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VADDL.U32 Qd, Dn+1, Dm+1 + /// A64: UADDL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 AddWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vaddw_high_u32 (uint64x2_t a, uint32x4_t b) - /// A32: VADDW.U32 Qd, Qn, Dm+1 - /// A64: UADDW2 Vd.2D, Vn.2D, Vm.4S + /// uint64x2_t vaddw_high_u32 (uint64x2_t a, uint32x4_t b) + /// A32: VADDW.U32 Qd, Qn, Dm+1 + /// A64: UADDW2 Vd.2D, Vn.2D, Vm.4S /// public static Vector128 AddWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vand_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VAND Dd, Dn, Dm - /// A64: AND Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vand_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VAND Dd, Dn, Dm + /// A64: AND Vd.8B, Vn.8B, Vm.8B /// public static Vector64 And(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vand_f64 (float64x1_t a, float64x1_t b) - /// A32: VAND Dd, Dn, Dm - /// A64: AND Vd.8B, Vn.8B, Vm.8B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x1_t vand_f64 (float64x1_t a, float64x1_t b) + /// A32: VAND Dd, Dn, Dm + /// A64: AND Vd.8B, Vn.8B, Vm.8B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 And(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vand_s16 (int16x4_t a, int16x4_t b) - /// A32: VAND Dd, Dn, Dm - /// A64: AND Vd.8B, Vn.8B, Vm.8B + /// int16x4_t vand_s16 (int16x4_t a, int16x4_t b) + /// A32: VAND Dd, Dn, Dm + /// A64: AND Vd.8B, Vn.8B, Vm.8B /// public static Vector64 And(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vand_s32 (int32x2_t a, int32x2_t b) - /// A32: VAND Dd, Dn, Dm - /// A64: AND Vd.8B, Vn.8B, Vm.8B + /// int32x2_t vand_s32 (int32x2_t a, int32x2_t b) + /// A32: VAND Dd, Dn, Dm + /// A64: AND Vd.8B, Vn.8B, Vm.8B /// public static Vector64 And(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vand_s64 (int64x1_t a, int64x1_t b) - /// A32: VAND Dd, Dn, Dm - /// A64: AND Vd.8B, Vn.8B, Vm.8B + /// int64x1_t vand_s64 (int64x1_t a, int64x1_t b) + /// A32: VAND Dd, Dn, Dm + /// A64: AND Vd.8B, Vn.8B, Vm.8B /// public static Vector64 And(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vand_s8 (int8x8_t a, int8x8_t b) - /// A32: VAND Dd, Dn, Dm - /// A64: AND Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vand_s8 (int8x8_t a, int8x8_t b) + /// A32: VAND Dd, Dn, Dm + /// A64: AND Vd.8B, Vn.8B, Vm.8B /// public static Vector64 And(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vand_f32 (float32x2_t a, float32x2_t b) - /// A32: VAND Dd, Dn, Dm - /// A64: AND Vd.8B, Vn.8B, Vm.8B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32x2_t vand_f32 (float32x2_t a, float32x2_t b) + /// A32: VAND Dd, Dn, Dm + /// A64: AND Vd.8B, Vn.8B, Vm.8B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 And(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vand_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VAND Dd, Dn, Dm - /// A64: AND Vd.8B, Vn.8B, Vm.8B + /// uint16x4_t vand_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VAND Dd, Dn, Dm + /// A64: AND Vd.8B, Vn.8B, Vm.8B /// public static Vector64 And(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vand_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VAND Dd, Dn, Dm - /// A64: AND Vd.8B, Vn.8B, Vm.8B + /// uint32x2_t vand_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VAND Dd, Dn, Dm + /// A64: AND Vd.8B, Vn.8B, Vm.8B /// public static Vector64 And(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vand_u64 (uint64x1_t a, uint64x1_t b) - /// A32: VAND Dd, Dn, Dm - /// A64: AND Vd.8B, Vn.8B, Vm.8B + /// uint64x1_t vand_u64 (uint64x1_t a, uint64x1_t b) + /// A32: VAND Dd, Dn, Dm + /// A64: AND Vd.8B, Vn.8B, Vm.8B /// public static Vector64 And(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vandq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VAND Qd, Qn, Qm - /// A64: AND Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vandq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VAND Qd, Qn, Qm + /// A64: AND Vd.16B, Vn.16B, Vm.16B /// public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vandq_f64 (float64x2_t a, float64x2_t b) - /// A32: VAND Qd, Qn, Qm - /// A64: AND Vd.16B, Vn.16B, Vm.16B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x2_t vandq_f64 (float64x2_t a, float64x2_t b) + /// A32: VAND Qd, Qn, Qm + /// A64: AND Vd.16B, Vn.16B, Vm.16B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vandq_s16 (int16x8_t a, int16x8_t b) - /// A32: VAND Qd, Qn, Qm - /// A64: AND Vd.16B, Vn.16B, Vm.16B + /// int16x8_t vandq_s16 (int16x8_t a, int16x8_t b) + /// A32: VAND Qd, Qn, Qm + /// A64: AND Vd.16B, Vn.16B, Vm.16B /// public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vandq_s32 (int32x4_t a, int32x4_t b) - /// A32: VAND Qd, Qn, Qm - /// A64: AND Vd.16B, Vn.16B, Vm.16B + /// int32x4_t vandq_s32 (int32x4_t a, int32x4_t b) + /// A32: VAND Qd, Qn, Qm + /// A64: AND Vd.16B, Vn.16B, Vm.16B /// public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vandq_s64 (int64x2_t a, int64x2_t b) - /// A32: VAND Qd, Qn, Qm - /// A64: AND Vd.16B, Vn.16B, Vm.16B + /// int64x2_t vandq_s64 (int64x2_t a, int64x2_t b) + /// A32: VAND Qd, Qn, Qm + /// A64: AND Vd.16B, Vn.16B, Vm.16B /// public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vandq_s8 (int8x16_t a, int8x16_t b) - /// A32: VAND Qd, Qn, Qm - /// A64: AND Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vandq_s8 (int8x16_t a, int8x16_t b) + /// A32: VAND Qd, Qn, Qm + /// A64: AND Vd.16B, Vn.16B, Vm.16B /// public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vandq_f32 (float32x4_t a, float32x4_t b) - /// A32: VAND Qd, Qn, Qm - /// A64: AND Vd.16B, Vn.16B, Vm.16B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32x4_t vandq_f32 (float32x4_t a, float32x4_t b) + /// A32: VAND Qd, Qn, Qm + /// A64: AND Vd.16B, Vn.16B, Vm.16B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vandq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VAND Qd, Qn, Qm - /// A64: AND Vd.16B, Vn.16B, Vm.16B + /// uint16x8_t vandq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VAND Qd, Qn, Qm + /// A64: AND Vd.16B, Vn.16B, Vm.16B /// public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vandq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VAND Qd, Qn, Qm - /// A64: AND Vd.16B, Vn.16B, Vm.16B + /// uint32x4_t vandq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VAND Qd, Qn, Qm + /// A64: AND Vd.16B, Vn.16B, Vm.16B /// public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vandq_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VAND Qd, Qn, Qm - /// A64: AND Vd.16B, Vn.16B, Vm.16B + /// uint64x2_t vandq_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VAND Qd, Qn, Qm + /// A64: AND Vd.16B, Vn.16B, Vm.16B /// public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vbic_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VBIC Dd, Dn, Dm - /// A64: BIC Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vbic_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VBIC Dd, Dn, Dm + /// A64: BIC Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseClear(Vector64 value, Vector64 mask) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vbic_f64 (float64x1_t a, float64x1_t b) - /// A32: VBIC Dd, Dn, Dm - /// A64: BIC Vd.8B, Vn.8B, Vm.8B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x1_t vbic_f64 (float64x1_t a, float64x1_t b) + /// A32: VBIC Dd, Dn, Dm + /// A64: BIC Vd.8B, Vn.8B, Vm.8B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 BitwiseClear(Vector64 value, Vector64 mask) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vbic_s16 (int16x4_t a, int16x4_t b) - /// A32: VBIC Dd, Dn, Dm - /// A64: BIC Vd.8B, Vn.8B, Vm.8B + /// int16x4_t vbic_s16 (int16x4_t a, int16x4_t b) + /// A32: VBIC Dd, Dn, Dm + /// A64: BIC Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseClear(Vector64 value, Vector64 mask) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vbic_s32 (int32x2_t a, int32x2_t b) - /// A32: VBIC Dd, Dn, Dm - /// A64: BIC Vd.8B, Vn.8B, Vm.8B + /// int32x2_t vbic_s32 (int32x2_t a, int32x2_t b) + /// A32: VBIC Dd, Dn, Dm + /// A64: BIC Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseClear(Vector64 value, Vector64 mask) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vbic_s64 (int64x1_t a, int64x1_t b) - /// A32: VBIC Dd, Dn, Dm - /// A64: BIC Vd.8B, Vn.8B, Vm.8B + /// int64x1_t vbic_s64 (int64x1_t a, int64x1_t b) + /// A32: VBIC Dd, Dn, Dm + /// A64: BIC Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseClear(Vector64 value, Vector64 mask) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vbic_s8 (int8x8_t a, int8x8_t b) - /// A32: VBIC Dd, Dn, Dm - /// A64: BIC Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vbic_s8 (int8x8_t a, int8x8_t b) + /// A32: VBIC Dd, Dn, Dm + /// A64: BIC Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseClear(Vector64 value, Vector64 mask) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vbic_f32 (float32x2_t a, float32x2_t b) - /// A32: VBIC Dd, Dn, Dm - /// A64: BIC Vd.8B, Vn.8B, Vm.8B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32x2_t vbic_f32 (float32x2_t a, float32x2_t b) + /// A32: VBIC Dd, Dn, Dm + /// A64: BIC Vd.8B, Vn.8B, Vm.8B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 BitwiseClear(Vector64 value, Vector64 mask) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vbic_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VBIC Dd, Dn, Dm - /// A64: BIC Vd.8B, Vn.8B, Vm.8B + /// uint16x4_t vbic_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VBIC Dd, Dn, Dm + /// A64: BIC Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseClear(Vector64 value, Vector64 mask) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vbic_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VBIC Dd, Dn, Dm - /// A64: BIC Vd.8B, Vn.8B, Vm.8B + /// uint32x2_t vbic_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VBIC Dd, Dn, Dm + /// A64: BIC Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseClear(Vector64 value, Vector64 mask) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vbic_u64 (uint64x1_t a, uint64x1_t b) - /// A32: VBIC Dd, Dn, Dm - /// A64: BIC Vd.8B, Vn.8B, Vm.8B + /// uint64x1_t vbic_u64 (uint64x1_t a, uint64x1_t b) + /// A32: VBIC Dd, Dn, Dm + /// A64: BIC Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseClear(Vector64 value, Vector64 mask) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vbicq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VBIC Qd, Qn, Qm - /// A64: BIC Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vbicq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VBIC Qd, Qn, Qm + /// A64: BIC Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseClear(Vector128 value, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vbicq_f64 (float64x2_t a, float64x2_t b) - /// A32: VBIC Qd, Qn, Qm - /// A64: BIC Vd.16B, Vn.16B, Vm.16B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x2_t vbicq_f64 (float64x2_t a, float64x2_t b) + /// A32: VBIC Qd, Qn, Qm + /// A64: BIC Vd.16B, Vn.16B, Vm.16B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 BitwiseClear(Vector128 value, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vbicq_s16 (int16x8_t a, int16x8_t b) - /// A32: VBIC Qd, Qn, Qm - /// A64: BIC Vd.16B, Vn.16B, Vm.16B + /// int16x8_t vbicq_s16 (int16x8_t a, int16x8_t b) + /// A32: VBIC Qd, Qn, Qm + /// A64: BIC Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseClear(Vector128 value, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vbicq_s32 (int32x4_t a, int32x4_t b) - /// A32: VBIC Qd, Qn, Qm - /// A64: BIC Vd.16B, Vn.16B, Vm.16B + /// int32x4_t vbicq_s32 (int32x4_t a, int32x4_t b) + /// A32: VBIC Qd, Qn, Qm + /// A64: BIC Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseClear(Vector128 value, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vbicq_s64 (int64x2_t a, int64x2_t b) - /// A32: VBIC Qd, Qn, Qm - /// A64: BIC Vd.16B, Vn.16B, Vm.16B + /// int64x2_t vbicq_s64 (int64x2_t a, int64x2_t b) + /// A32: VBIC Qd, Qn, Qm + /// A64: BIC Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseClear(Vector128 value, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vbicq_s8 (int8x16_t a, int8x16_t b) - /// A32: VBIC Qd, Qn, Qm - /// A64: BIC Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vbicq_s8 (int8x16_t a, int8x16_t b) + /// A32: VBIC Qd, Qn, Qm + /// A64: BIC Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseClear(Vector128 value, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vbicq_f32 (float32x4_t a, float32x4_t b) - /// A32: VBIC Qd, Qn, Qm - /// A64: BIC Vd.16B, Vn.16B, Vm.16B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32x4_t vbicq_f32 (float32x4_t a, float32x4_t b) + /// A32: VBIC Qd, Qn, Qm + /// A64: BIC Vd.16B, Vn.16B, Vm.16B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 BitwiseClear(Vector128 value, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vbicq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VBIC Qd, Qn, Qm - /// A64: BIC Vd.16B, Vn.16B, Vm.16B + /// uint16x8_t vbicq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VBIC Qd, Qn, Qm + /// A64: BIC Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseClear(Vector128 value, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vbicq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VBIC Qd, Qn, Qm - /// A64: BIC Vd.16B, Vn.16B, Vm.16B + /// uint32x4_t vbicq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VBIC Qd, Qn, Qm + /// A64: BIC Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseClear(Vector128 value, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vbicq_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VBIC Qd, Qn, Qm - /// A64: BIC Vd.16B, Vn.16B, Vm.16B + /// uint64x2_t vbicq_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VBIC Qd, Qn, Qm + /// A64: BIC Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseClear(Vector128 value, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vbsl_u8 (uint8x8_t a, uint8x8_t b, uint8x8_t c) - /// A32: VBSL Dd, Dn, Dm - /// A64: BSL Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vbsl_u8 (uint8x8_t a, uint8x8_t b, uint8x8_t c) + /// A32: VBSL Dd, Dn, Dm + /// A64: BSL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseSelect(Vector64 select, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vbsl_f64 (uint64x1_t a, float64x1_t b, float64x1_t c) - /// A32: VBSL Dd, Dn, Dm - /// A64: BSL Vd.8B, Vn.8B, Vm.8B + /// float64x1_t vbsl_f64 (uint64x1_t a, float64x1_t b, float64x1_t c) + /// A32: VBSL Dd, Dn, Dm + /// A64: BSL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseSelect(Vector64 select, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vbsl_s16 (uint16x4_t a, int16x4_t b, int16x4_t c) - /// A32: VBSL Dd, Dn, Dm - /// A64: BSL Vd.8B, Vn.8B, Vm.8B + /// int16x4_t vbsl_s16 (uint16x4_t a, int16x4_t b, int16x4_t c) + /// A32: VBSL Dd, Dn, Dm + /// A64: BSL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseSelect(Vector64 select, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vbsl_s32 (uint32x2_t a, int32x2_t b, int32x2_t c) - /// A32: VBSL Dd, Dn, Dm - /// A64: BSL Vd.8B, Vn.8B, Vm.8B + /// int32x2_t vbsl_s32 (uint32x2_t a, int32x2_t b, int32x2_t c) + /// A32: VBSL Dd, Dn, Dm + /// A64: BSL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseSelect(Vector64 select, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vbsl_s64 (uint64x1_t a, int64x1_t b, int64x1_t c) - /// A32: VBSL Dd, Dn, Dm - /// A64: BSL Vd.8B, Vn.8B, Vm.8B + /// int64x1_t vbsl_s64 (uint64x1_t a, int64x1_t b, int64x1_t c) + /// A32: VBSL Dd, Dn, Dm + /// A64: BSL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseSelect(Vector64 select, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vbsl_s8 (uint8x8_t a, int8x8_t b, int8x8_t c) - /// A32: VBSL Dd, Dn, Dm - /// A64: BSL Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vbsl_s8 (uint8x8_t a, int8x8_t b, int8x8_t c) + /// A32: VBSL Dd, Dn, Dm + /// A64: BSL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseSelect(Vector64 select, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vbsl_f32 (uint32x2_t a, float32x2_t b, float32x2_t c) - /// A32: VBSL Dd, Dn, Dm - /// A64: BSL Vd.8B, Vn.8B, Vm.8B + /// float32x2_t vbsl_f32 (uint32x2_t a, float32x2_t b, float32x2_t c) + /// A32: VBSL Dd, Dn, Dm + /// A64: BSL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseSelect(Vector64 select, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vbsl_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t c) - /// A32: VBSL Dd, Dn, Dm - /// A64: BSL Vd.8B, Vn.8B, Vm.8B + /// uint16x4_t vbsl_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t c) + /// A32: VBSL Dd, Dn, Dm + /// A64: BSL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseSelect(Vector64 select, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vbsl_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t c) - /// A32: VBSL Dd, Dn, Dm - /// A64: BSL Vd.8B, Vn.8B, Vm.8B + /// uint32x2_t vbsl_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t c) + /// A32: VBSL Dd, Dn, Dm + /// A64: BSL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseSelect(Vector64 select, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vbsl_u64 (uint64x1_t a, uint64x1_t b, uint64x1_t c) - /// A32: VBSL Dd, Dn, Dm - /// A64: BSL Vd.8B, Vn.8B, Vm.8B + /// uint64x1_t vbsl_u64 (uint64x1_t a, uint64x1_t b, uint64x1_t c) + /// A32: VBSL Dd, Dn, Dm + /// A64: BSL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseSelect(Vector64 select, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vbslq_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c) - /// A32: VBSL Qd, Qn, Qm - /// A64: BSL Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vbslq_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c) + /// A32: VBSL Qd, Qn, Qm + /// A64: BSL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseSelect(Vector128 select, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vbslq_f64 (uint64x2_t a, float64x2_t b, float64x2_t c) - /// A32: VBSL Qd, Qn, Qm - /// A64: BSL Vd.16B, Vn.16B, Vm.16B + /// float64x2_t vbslq_f64 (uint64x2_t a, float64x2_t b, float64x2_t c) + /// A32: VBSL Qd, Qn, Qm + /// A64: BSL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseSelect(Vector128 select, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vbslq_s16 (uint16x8_t a, int16x8_t b, int16x8_t c) - /// A32: VBSL Qd, Qn, Qm - /// A64: BSL Vd.16B, Vn.16B, Vm.16B + /// int16x8_t vbslq_s16 (uint16x8_t a, int16x8_t b, int16x8_t c) + /// A32: VBSL Qd, Qn, Qm + /// A64: BSL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseSelect(Vector128 select, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vbslq_s32 (uint32x4_t a, int32x4_t b, int32x4_t c) - /// A32: VBSL Qd, Qn, Qm - /// A64: BSL Vd.16B, Vn.16B, Vm.16B + /// int32x4_t vbslq_s32 (uint32x4_t a, int32x4_t b, int32x4_t c) + /// A32: VBSL Qd, Qn, Qm + /// A64: BSL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseSelect(Vector128 select, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vbslq_s64 (uint64x2_t a, int64x2_t b, int64x2_t c) - /// A32: VBSL Qd, Qn, Qm - /// A64: BSL Vd.16B, Vn.16B, Vm.16B + /// int64x2_t vbslq_s64 (uint64x2_t a, int64x2_t b, int64x2_t c) + /// A32: VBSL Qd, Qn, Qm + /// A64: BSL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseSelect(Vector128 select, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vbslq_s8 (uint8x16_t a, int8x16_t b, int8x16_t c) - /// A32: VBSL Qd, Qn, Qm - /// A64: BSL Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vbslq_s8 (uint8x16_t a, int8x16_t b, int8x16_t c) + /// A32: VBSL Qd, Qn, Qm + /// A64: BSL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseSelect(Vector128 select, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vbslq_f32 (uint32x4_t a, float32x4_t b, float32x4_t c) - /// A32: VBSL Qd, Qn, Qm - /// A64: BSL Vd.16B, Vn.16B, Vm.16B + /// float32x4_t vbslq_f32 (uint32x4_t a, float32x4_t b, float32x4_t c) + /// A32: VBSL Qd, Qn, Qm + /// A64: BSL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseSelect(Vector128 select, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vbslq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c) - /// A32: VBSL Qd, Qn, Qm - /// A64: BSL Vd.16B, Vn.16B, Vm.16B + /// uint16x8_t vbslq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c) + /// A32: VBSL Qd, Qn, Qm + /// A64: BSL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseSelect(Vector128 select, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vbslq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c) - /// A32: VBSL Qd, Qn, Qm - /// A64: BSL Vd.16B, Vn.16B, Vm.16B + /// uint32x4_t vbslq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c) + /// A32: VBSL Qd, Qn, Qm + /// A64: BSL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseSelect(Vector128 select, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vbslq_u64 (uint64x2_t a, uint64x2_t b, uint64x2_t c) - /// A32: VBSL Qd, Qn, Qm - /// A64: BSL Vd.16B, Vn.16B, Vm.16B + /// uint64x2_t vbslq_u64 (uint64x2_t a, uint64x2_t b, uint64x2_t c) + /// A32: VBSL Qd, Qn, Qm + /// A64: BSL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseSelect(Vector128 select, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vrndp_f32 (float32x2_t a) - /// A32: VRINTP.F32 Dd, Dm - /// A64: FRINTP Vd.2S, Vn.2S + /// float32x2_t vrndp_f32 (float32x2_t a) + /// A32: VRINTP.F32 Dd, Dm + /// A64: FRINTP Vd.2S, Vn.2S /// public static Vector64 Ceiling(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vrndpq_f32 (float32x4_t a) - /// A32: VRINTP.F32 Qd, Qm - /// A64: FRINTP Vd.4S, Vn.4S + /// float32x4_t vrndpq_f32 (float32x4_t a) + /// A32: VRINTP.F32 Qd, Qm + /// A64: FRINTP Vd.4S, Vn.4S /// public static Vector128 Ceiling(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vrndp_f64 (float64x1_t a) - /// A32: VRINTP.F64 Dd, Dm - /// A64: FRINTP Dd, Dn + /// float64x1_t vrndp_f64 (float64x1_t a) + /// A32: VRINTP.F64 Dd, Dm + /// A64: FRINTP Dd, Dn /// public static Vector64 CeilingScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32_t vrndps_f32 (float32_t a) - /// A32: VRINTP.F32 Sd, Sm - /// A64: FRINTP Sd, Sn - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vrndps_f32 (float32_t a) + /// A32: VRINTP.F32 Sd, Sm + /// A64: FRINTP Sd, Sn + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 CeilingScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vceq_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VCEQ.I8 Dd, Dn, Dm - /// A64: CMEQ Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vceq_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VCEQ.I8 Dd, Dn, Dm + /// A64: CMEQ Vd.8B, Vn.8B, Vm.8B /// public static Vector64 CompareEqual(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vceq_s16 (int16x4_t a, int16x4_t b) - /// A32: VCEQ.I16 Dd, Dn, Dm - /// A64: CMEQ Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vceq_s16 (int16x4_t a, int16x4_t b) + /// A32: VCEQ.I16 Dd, Dn, Dm + /// A64: CMEQ Vd.4H, Vn.4H, Vm.4H /// public static Vector64 CompareEqual(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vceq_s32 (int32x2_t a, int32x2_t b) - /// A32: VCEQ.I32 Dd, Dn, Dm - /// A64: CMEQ Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vceq_s32 (int32x2_t a, int32x2_t b) + /// A32: VCEQ.I32 Dd, Dn, Dm + /// A64: CMEQ Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareEqual(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vceq_s8 (int8x8_t a, int8x8_t b) - /// A32: VCEQ.I8 Dd, Dn, Dm - /// A64: CMEQ Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vceq_s8 (int8x8_t a, int8x8_t b) + /// A32: VCEQ.I8 Dd, Dn, Dm + /// A64: CMEQ Vd.8B, Vn.8B, Vm.8B /// public static Vector64 CompareEqual(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vceq_f32 (float32x2_t a, float32x2_t b) - /// A32: VCEQ.F32 Dd, Dn, Dm - /// A64: FCMEQ Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vceq_f32 (float32x2_t a, float32x2_t b) + /// A32: VCEQ.F32 Dd, Dn, Dm + /// A64: FCMEQ Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareEqual(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vceq_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VCEQ.I16 Dd, Dn, Dm - /// A64: CMEQ Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vceq_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VCEQ.I16 Dd, Dn, Dm + /// A64: CMEQ Vd.4H, Vn.4H, Vm.4H /// public static Vector64 CompareEqual(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vceq_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VCEQ.I32 Dd, Dn, Dm - /// A64: CMEQ Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vceq_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VCEQ.I32 Dd, Dn, Dm + /// A64: CMEQ Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareEqual(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vceqq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VCEQ.I8 Qd, Qn, Qm - /// A64: CMEQ Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vceqq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VCEQ.I8 Qd, Qn, Qm + /// A64: CMEQ Vd.16B, Vn.16B, Vm.16B /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vceqq_s16 (int16x8_t a, int16x8_t b) - /// A32: VCEQ.I16 Qd, Qn, Qm - /// A64: CMEQ Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vceqq_s16 (int16x8_t a, int16x8_t b) + /// A32: VCEQ.I16 Qd, Qn, Qm + /// A64: CMEQ Vd.8H, Vn.8H, Vm.8H /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vceqq_s32 (int32x4_t a, int32x4_t b) - /// A32: VCEQ.I32 Qd, Qn, Qm - /// A64: CMEQ Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vceqq_s32 (int32x4_t a, int32x4_t b) + /// A32: VCEQ.I32 Qd, Qn, Qm + /// A64: CMEQ Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vceqq_s8 (int8x16_t a, int8x16_t b) - /// A32: VCEQ.I8 Qd, Qn, Qm - /// A64: CMEQ Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vceqq_s8 (int8x16_t a, int8x16_t b) + /// A32: VCEQ.I8 Qd, Qn, Qm + /// A64: CMEQ Vd.16B, Vn.16B, Vm.16B /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vceqq_f32 (float32x4_t a, float32x4_t b) - /// A32: VCEQ.F32 Qd, Qn, Qm - /// A64: FCMEQ Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vceqq_f32 (float32x4_t a, float32x4_t b) + /// A32: VCEQ.F32 Qd, Qn, Qm + /// A64: FCMEQ Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vceqq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VCEQ.I16 Qd, Qn, Qm - /// A64: CMEQ Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vceqq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VCEQ.I16 Qd, Qn, Qm + /// A64: CMEQ Vd.8H, Vn.8H, Vm.8H /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vceqq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VCEQ.I32 Qd, Qn, Qm - /// A64: CMEQ Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vceqq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VCEQ.I32 Qd, Qn, Qm + /// A64: CMEQ Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vcgt_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VCGT.U8 Dd, Dn, Dm - /// A64: CMHI Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vcgt_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VCGT.U8 Dd, Dn, Dm + /// A64: CMHI Vd.8B, Vn.8B, Vm.8B /// public static Vector64 CompareGreaterThan(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vcgt_s16 (int16x4_t a, int16x4_t b) - /// A32: VCGT.S16 Dd, Dn, Dm - /// A64: CMGT Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vcgt_s16 (int16x4_t a, int16x4_t b) + /// A32: VCGT.S16 Dd, Dn, Dm + /// A64: CMGT Vd.4H, Vn.4H, Vm.4H /// public static Vector64 CompareGreaterThan(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vcgt_s32 (int32x2_t a, int32x2_t b) - /// A32: VCGT.S32 Dd, Dn, Dm - /// A64: CMGT Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcgt_s32 (int32x2_t a, int32x2_t b) + /// A32: VCGT.S32 Dd, Dn, Dm + /// A64: CMGT Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareGreaterThan(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vcgt_s8 (int8x8_t a, int8x8_t b) - /// A32: VCGT.S8 Dd, Dn, Dm - /// A64: CMGT Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vcgt_s8 (int8x8_t a, int8x8_t b) + /// A32: VCGT.S8 Dd, Dn, Dm + /// A64: CMGT Vd.8B, Vn.8B, Vm.8B /// public static Vector64 CompareGreaterThan(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vcgt_f32 (float32x2_t a, float32x2_t b) - /// A32: VCGT.F32 Dd, Dn, Dm - /// A64: FCMGT Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcgt_f32 (float32x2_t a, float32x2_t b) + /// A32: VCGT.F32 Dd, Dn, Dm + /// A64: FCMGT Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareGreaterThan(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vcgt_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VCGT.U16 Dd, Dn, Dm - /// A64: CMHI Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vcgt_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VCGT.U16 Dd, Dn, Dm + /// A64: CMHI Vd.4H, Vn.4H, Vm.4H /// public static Vector64 CompareGreaterThan(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vcgt_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VCGT.U32 Dd, Dn, Dm - /// A64: CMHI Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcgt_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VCGT.U32 Dd, Dn, Dm + /// A64: CMHI Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareGreaterThan(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vcgtq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VCGT.U8 Qd, Qn, Qm - /// A64: CMHI Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vcgtq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VCGT.U8 Qd, Qn, Qm + /// A64: CMHI Vd.16B, Vn.16B, Vm.16B /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vcgtq_s16 (int16x8_t a, int16x8_t b) - /// A32: VCGT.S16 Qd, Qn, Qm - /// A64: CMGT Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vcgtq_s16 (int16x8_t a, int16x8_t b) + /// A32: VCGT.S16 Qd, Qn, Qm + /// A64: CMGT Vd.8H, Vn.8H, Vm.8H /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vcgtq_s32 (int32x4_t a, int32x4_t b) - /// A32: VCGT.S32 Qd, Qn, Qm - /// A64: CMGT Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcgtq_s32 (int32x4_t a, int32x4_t b) + /// A32: VCGT.S32 Qd, Qn, Qm + /// A64: CMGT Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vcgtq_s8 (int8x16_t a, int8x16_t b) - /// A32: VCGT.S8 Qd, Qn, Qm - /// A64: CMGT Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vcgtq_s8 (int8x16_t a, int8x16_t b) + /// A32: VCGT.S8 Qd, Qn, Qm + /// A64: CMGT Vd.16B, Vn.16B, Vm.16B /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vcgtq_f32 (float32x4_t a, float32x4_t b) - /// A32: VCGT.F32 Qd, Qn, Qm - /// A64: FCMGT Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcgtq_f32 (float32x4_t a, float32x4_t b) + /// A32: VCGT.F32 Qd, Qn, Qm + /// A64: FCMGT Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vcgtq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VCGT.U16 Qd, Qn, Qm - /// A64: CMHI Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vcgtq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VCGT.U16 Qd, Qn, Qm + /// A64: CMHI Vd.8H, Vn.8H, Vm.8H /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vcgtq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VCGT.U32 Qd, Qn, Qm - /// A64: CMHI Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcgtq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VCGT.U32 Qd, Qn, Qm + /// A64: CMHI Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vcge_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VCGE.U8 Dd, Dn, Dm - /// A64: CMHS Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vcge_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VCGE.U8 Dd, Dn, Dm + /// A64: CMHS Vd.8B, Vn.8B, Vm.8B /// public static Vector64 CompareGreaterThanOrEqual(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vcge_s16 (int16x4_t a, int16x4_t b) - /// A32: VCGE.S16 Dd, Dn, Dm - /// A64: CMGE Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vcge_s16 (int16x4_t a, int16x4_t b) + /// A32: VCGE.S16 Dd, Dn, Dm + /// A64: CMGE Vd.4H, Vn.4H, Vm.4H /// public static Vector64 CompareGreaterThanOrEqual(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vcge_s32 (int32x2_t a, int32x2_t b) - /// A32: VCGE.S32 Dd, Dn, Dm - /// A64: CMGE Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcge_s32 (int32x2_t a, int32x2_t b) + /// A32: VCGE.S32 Dd, Dn, Dm + /// A64: CMGE Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareGreaterThanOrEqual(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vcge_s8 (int8x8_t a, int8x8_t b) - /// A32: VCGE.S8 Dd, Dn, Dm - /// A64: CMGE Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vcge_s8 (int8x8_t a, int8x8_t b) + /// A32: VCGE.S8 Dd, Dn, Dm + /// A64: CMGE Vd.8B, Vn.8B, Vm.8B /// public static Vector64 CompareGreaterThanOrEqual(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vcge_f32 (float32x2_t a, float32x2_t b) - /// A32: VCGE.F32 Dd, Dn, Dm - /// A64: FCMGE Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcge_f32 (float32x2_t a, float32x2_t b) + /// A32: VCGE.F32 Dd, Dn, Dm + /// A64: FCMGE Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareGreaterThanOrEqual(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vcge_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VCGE.U16 Dd, Dn, Dm - /// A64: CMHS Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vcge_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VCGE.U16 Dd, Dn, Dm + /// A64: CMHS Vd.4H, Vn.4H, Vm.4H /// public static Vector64 CompareGreaterThanOrEqual(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vcge_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VCGE.U32 Dd, Dn, Dm - /// A64: CMHS Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcge_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VCGE.U32 Dd, Dn, Dm + /// A64: CMHS Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareGreaterThanOrEqual(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vcgeq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VCGE.U8 Qd, Qn, Qm - /// A64: CMHS Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vcgeq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VCGE.U8 Qd, Qn, Qm + /// A64: CMHS Vd.16B, Vn.16B, Vm.16B /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vcgeq_s16 (int16x8_t a, int16x8_t b) - /// A32: VCGE.S16 Qd, Qn, Qm - /// A64: CMGE Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vcgeq_s16 (int16x8_t a, int16x8_t b) + /// A32: VCGE.S16 Qd, Qn, Qm + /// A64: CMGE Vd.8H, Vn.8H, Vm.8H /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vcgeq_s32 (int32x4_t a, int32x4_t b) - /// A32: VCGE.S32 Qd, Qn, Qm - /// A64: CMGE Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcgeq_s32 (int32x4_t a, int32x4_t b) + /// A32: VCGE.S32 Qd, Qn, Qm + /// A64: CMGE Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vcgeq_s8 (int8x16_t a, int8x16_t b) - /// A32: VCGE.S8 Qd, Qn, Qm - /// A64: CMGE Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vcgeq_s8 (int8x16_t a, int8x16_t b) + /// A32: VCGE.S8 Qd, Qn, Qm + /// A64: CMGE Vd.16B, Vn.16B, Vm.16B /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vcgeq_f32 (float32x4_t a, float32x4_t b) - /// A32: VCGE.F32 Qd, Qn, Qm - /// A64: FCMGE Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcgeq_f32 (float32x4_t a, float32x4_t b) + /// A32: VCGE.F32 Qd, Qn, Qm + /// A64: FCMGE Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vcgeq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VCGE.U16 Qd, Qn, Qm - /// A64: CMHS Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vcgeq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VCGE.U16 Qd, Qn, Qm + /// A64: CMHS Vd.8H, Vn.8H, Vm.8H /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vcgeq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VCGE.U32 Qd, Qn, Qm - /// A64: CMHS Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcgeq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VCGE.U32 Qd, Qn, Qm + /// A64: CMHS Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vclt_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VCLT.U8 Dd, Dn, Dm - /// A64: CMHI Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vclt_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VCLT.U8 Dd, Dn, Dm + /// A64: CMHI Vd.8B, Vn.8B, Vm.8B /// public static Vector64 CompareLessThan(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vclt_s16 (int16x4_t a, int16x4_t b) - /// A32: VCLT.S16 Dd, Dn, Dm - /// A64: CMGT Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vclt_s16 (int16x4_t a, int16x4_t b) + /// A32: VCLT.S16 Dd, Dn, Dm + /// A64: CMGT Vd.4H, Vn.4H, Vm.4H /// public static Vector64 CompareLessThan(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vclt_s32 (int32x2_t a, int32x2_t b) - /// A32: VCLT.S32 Dd, Dn, Dm - /// A64: CMGT Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vclt_s32 (int32x2_t a, int32x2_t b) + /// A32: VCLT.S32 Dd, Dn, Dm + /// A64: CMGT Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareLessThan(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vclt_s8 (int8x8_t a, int8x8_t b) - /// A32: VCLT.S8 Dd, Dn, Dm - /// A64: CMGT Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vclt_s8 (int8x8_t a, int8x8_t b) + /// A32: VCLT.S8 Dd, Dn, Dm + /// A64: CMGT Vd.8B, Vn.8B, Vm.8B /// public static Vector64 CompareLessThan(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vclt_f32 (float32x2_t a, float32x2_t b) - /// A32: VCLT.F32 Dd, Dn, Dm - /// A64: FCMGT Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vclt_f32 (float32x2_t a, float32x2_t b) + /// A32: VCLT.F32 Dd, Dn, Dm + /// A64: FCMGT Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareLessThan(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vclt_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VCLT.U16 Dd, Dn, Dm - /// A64: CMHI Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vclt_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VCLT.U16 Dd, Dn, Dm + /// A64: CMHI Vd.4H, Vn.4H, Vm.4H /// public static Vector64 CompareLessThan(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vclt_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VCLT.U32 Dd, Dn, Dm - /// A64: CMHI Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vclt_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VCLT.U32 Dd, Dn, Dm + /// A64: CMHI Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareLessThan(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vcltq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VCLT.U8 Qd, Qn, Qm - /// A64: CMHI Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vcltq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VCLT.U8 Qd, Qn, Qm + /// A64: CMHI Vd.16B, Vn.16B, Vm.16B /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vcltq_s16 (int16x8_t a, int16x8_t b) - /// A32: VCLT.S16 Qd, Qn, Qm - /// A64: CMGT Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vcltq_s16 (int16x8_t a, int16x8_t b) + /// A32: VCLT.S16 Qd, Qn, Qm + /// A64: CMGT Vd.8H, Vn.8H, Vm.8H /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vcltq_s32 (int32x4_t a, int32x4_t b) - /// A32: VCLT.S32 Qd, Qn, Qm - /// A64: CMGT Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcltq_s32 (int32x4_t a, int32x4_t b) + /// A32: VCLT.S32 Qd, Qn, Qm + /// A64: CMGT Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vcltq_s8 (int8x16_t a, int8x16_t b) - /// A32: VCLT.S8 Qd, Qn, Qm - /// A64: CMGT Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vcltq_s8 (int8x16_t a, int8x16_t b) + /// A32: VCLT.S8 Qd, Qn, Qm + /// A64: CMGT Vd.16B, Vn.16B, Vm.16B /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vcltq_f32 (float32x4_t a, float32x4_t b) - /// A32: VCLT.F32 Qd, Qn, Qm - /// A64: FCMGT Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcltq_f32 (float32x4_t a, float32x4_t b) + /// A32: VCLT.F32 Qd, Qn, Qm + /// A64: FCMGT Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vcltq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VCLT.U16 Qd, Qn, Qm - /// A64: CMHI Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vcltq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VCLT.U16 Qd, Qn, Qm + /// A64: CMHI Vd.8H, Vn.8H, Vm.8H /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vcltq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VCLT.U32 Qd, Qn, Qm - /// A64: CMHI Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcltq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VCLT.U32 Qd, Qn, Qm + /// A64: CMHI Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vcle_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VCLE.U8 Dd, Dn, Dm - /// A64: CMHS Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vcle_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VCLE.U8 Dd, Dn, Dm + /// A64: CMHS Vd.8B, Vn.8B, Vm.8B /// public static Vector64 CompareLessThanOrEqual(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vcle_s16 (int16x4_t a, int16x4_t b) - /// A32: VCLE.S16 Dd, Dn, Dm - /// A64: CMGE Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vcle_s16 (int16x4_t a, int16x4_t b) + /// A32: VCLE.S16 Dd, Dn, Dm + /// A64: CMGE Vd.4H, Vn.4H, Vm.4H /// public static Vector64 CompareLessThanOrEqual(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vcle_s32 (int32x2_t a, int32x2_t b) - /// A32: VCLE.S32 Dd, Dn, Dm - /// A64: CMGE Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcle_s32 (int32x2_t a, int32x2_t b) + /// A32: VCLE.S32 Dd, Dn, Dm + /// A64: CMGE Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareLessThanOrEqual(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vcle_s8 (int8x8_t a, int8x8_t b) - /// A32: VCLE.S8 Dd, Dn, Dm - /// A64: CMGE Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vcle_s8 (int8x8_t a, int8x8_t b) + /// A32: VCLE.S8 Dd, Dn, Dm + /// A64: CMGE Vd.8B, Vn.8B, Vm.8B /// public static Vector64 CompareLessThanOrEqual(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vcle_f32 (float32x2_t a, float32x2_t b) - /// A32: VCLE.F32 Dd, Dn, Dm - /// A64: FCMGE Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcle_f32 (float32x2_t a, float32x2_t b) + /// A32: VCLE.F32 Dd, Dn, Dm + /// A64: FCMGE Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareLessThanOrEqual(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vcle_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VCLE.U16 Dd, Dn, Dm - /// A64: CMHS Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vcle_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VCLE.U16 Dd, Dn, Dm + /// A64: CMHS Vd.4H, Vn.4H, Vm.4H /// public static Vector64 CompareLessThanOrEqual(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vcle_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VCLE.U32 Dd, Dn, Dm - /// A64: CMHS Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcle_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VCLE.U32 Dd, Dn, Dm + /// A64: CMHS Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareLessThanOrEqual(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vcleq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VCLE.U8 Qd, Qn, Qm - /// A64: CMHS Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vcleq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VCLE.U8 Qd, Qn, Qm + /// A64: CMHS Vd.16B, Vn.16B, Vm.16B /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vcleq_s16 (int16x8_t a, int16x8_t b) - /// A32: VCLE.S16 Qd, Qn, Qm - /// A64: CMGE Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vcleq_s16 (int16x8_t a, int16x8_t b) + /// A32: VCLE.S16 Qd, Qn, Qm + /// A64: CMGE Vd.8H, Vn.8H, Vm.8H /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vcleq_s32 (int32x4_t a, int32x4_t b) - /// A32: VCLE.S32 Qd, Qn, Qm - /// A64: CMGE Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcleq_s32 (int32x4_t a, int32x4_t b) + /// A32: VCLE.S32 Qd, Qn, Qm + /// A64: CMGE Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vcleq_s8 (int8x16_t a, int8x16_t b) - /// A32: VCLE.S8 Qd, Qn, Qm - /// A64: CMGE Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vcleq_s8 (int8x16_t a, int8x16_t b) + /// A32: VCLE.S8 Qd, Qn, Qm + /// A64: CMGE Vd.16B, Vn.16B, Vm.16B /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vcleq_f32 (float32x4_t a, float32x4_t b) - /// A32: VCLE.F32 Qd, Qn, Qm - /// A64: FCMGE Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcleq_f32 (float32x4_t a, float32x4_t b) + /// A32: VCLE.F32 Qd, Qn, Qm + /// A64: FCMGE Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vcleq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VCLE.U16 Qd, Qn, Qm - /// A64: CMHS Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vcleq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VCLE.U16 Qd, Qn, Qm + /// A64: CMHS Vd.8H, Vn.8H, Vm.8H /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vcleq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VCLE.U32 Qd, Qn, Qm - /// A64: CMHS Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcleq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VCLE.U32 Qd, Qn, Qm + /// A64: CMHS Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vtst_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VTST.8 Dd, Dn, Dm - /// A64: CMTST Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vtst_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VTST.8 Dd, Dn, Dm + /// A64: CMTST Vd.8B, Vn.8B, Vm.8B /// public static Vector64 CompareTest(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vtst_s16 (int16x4_t a, int16x4_t b) - /// A32: VTST.16 Dd, Dn, Dm - /// A64: CMTST Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vtst_s16 (int16x4_t a, int16x4_t b) + /// A32: VTST.16 Dd, Dn, Dm + /// A64: CMTST Vd.4H, Vn.4H, Vm.4H /// public static Vector64 CompareTest(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vtst_s32 (int32x2_t a, int32x2_t b) - /// A32: VTST.32 Dd, Dn, Dm - /// A64: CMTST Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vtst_s32 (int32x2_t a, int32x2_t b) + /// A32: VTST.32 Dd, Dn, Dm + /// A64: CMTST Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareTest(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vtst_s8 (int8x8_t a, int8x8_t b) - /// A32: VTST.8 Dd, Dn, Dm - /// A64: CMTST Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vtst_s8 (int8x8_t a, int8x8_t b) + /// A32: VTST.8 Dd, Dn, Dm + /// A64: CMTST Vd.8B, Vn.8B, Vm.8B /// public static Vector64 CompareTest(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vtst_f32 (float32x2_t a, float32x2_t b) - /// A32: VTST.32 Dd, Dn, Dm - /// A64: CMTST Vd.2S, Vn.2S, Vm.2S - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// uint32x2_t vtst_f32 (float32x2_t a, float32x2_t b) + /// A32: VTST.32 Dd, Dn, Dm + /// A64: CMTST Vd.2S, Vn.2S, Vm.2S + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 CompareTest(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vtst_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VTST.16 Dd, Dn, Dm - /// A64: CMTST Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vtst_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VTST.16 Dd, Dn, Dm + /// A64: CMTST Vd.4H, Vn.4H, Vm.4H /// public static Vector64 CompareTest(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vtst_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VTST.32 Dd, Dn, Dm - /// A64: CMTST Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vtst_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VTST.32 Dd, Dn, Dm + /// A64: CMTST Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareTest(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vtstq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VTST.8 Qd, Qn, Qm - /// A64: CMTST Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vtstq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VTST.8 Qd, Qn, Qm + /// A64: CMTST Vd.16B, Vn.16B, Vm.16B /// public static Vector128 CompareTest(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vtstq_s16 (int16x8_t a, int16x8_t b) - /// A32: VTST.16 Qd, Qn, Qm - /// A64: CMTST Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vtstq_s16 (int16x8_t a, int16x8_t b) + /// A32: VTST.16 Qd, Qn, Qm + /// A64: CMTST Vd.8H, Vn.8H, Vm.8H /// public static Vector128 CompareTest(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vtstq_s32 (int32x4_t a, int32x4_t b) - /// A32: VTST.32 Qd, Qn, Qm - /// A64: CMTST Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vtstq_s32 (int32x4_t a, int32x4_t b) + /// A32: VTST.32 Qd, Qn, Qm + /// A64: CMTST Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareTest(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vtstq_s8 (int8x16_t a, int8x16_t b) - /// A32: VTST.8 Qd, Qn, Qm - /// A64: CMTST Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vtstq_s8 (int8x16_t a, int8x16_t b) + /// A32: VTST.8 Qd, Qn, Qm + /// A64: CMTST Vd.16B, Vn.16B, Vm.16B /// public static Vector128 CompareTest(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vtstq_f32 (float32x4_t a, float32x4_t b) - /// A32: VTST.32 Qd, Qn, Qm - /// A64: CMTST Vd.4S, Vn.4S, Vm.4S - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// uint32x4_t vtstq_f32 (float32x4_t a, float32x4_t b) + /// A32: VTST.32 Qd, Qn, Qm + /// A64: CMTST Vd.4S, Vn.4S, Vm.4S + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 CompareTest(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vtstq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VTST.16 Qd, Qn, Qm - /// A64: CMTST Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vtstq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VTST.16 Qd, Qn, Qm + /// A64: CMTST Vd.8H, Vn.8H, Vm.8H /// public static Vector128 CompareTest(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vtstq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VTST.32 Qd, Qn, Qm - /// A64: CMTST Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vtstq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VTST.32 Qd, Qn, Qm + /// A64: CMTST Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareTest(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vcvta_s32_f32 (float32x2_t a) - /// A32: VCVTA.S32.F32 Dd, Dm - /// A64: FCVTAS Vd.2S, Vn.2S + /// int32x2_t vcvta_s32_f32 (float32x2_t a) + /// A32: VCVTA.S32.F32 Dd, Dm + /// A64: FCVTAS Vd.2S, Vn.2S /// public static Vector64 ConvertToInt32RoundAwayFromZero(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vcvtaq_s32_f32 (float32x4_t a) - /// A32: VCVTA.S32.F32 Qd, Qm - /// A64: FCVTAS Vd.4S, Vn.4S + /// int32x4_t vcvtaq_s32_f32 (float32x4_t a) + /// A32: VCVTA.S32.F32 Qd, Qm + /// A64: FCVTAS Vd.4S, Vn.4S /// public static Vector128 ConvertToInt32RoundAwayFromZero(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int32_t vcvtas_s32_f32 (float32_t a) - /// A32: VCVTA.S32.F32 Sd, Sm - /// A64: FCVTAS Sd, Sn + /// int32_t vcvtas_s32_f32 (float32_t a) + /// A32: VCVTA.S32.F32 Sd, Sm + /// A64: FCVTAS Sd, Sn /// public static Vector64 ConvertToInt32RoundAwayFromZeroScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vcvtn_s32_f32 (float32x2_t a) - /// A32: VCVTN.S32.F32 Dd, Dm - /// A64: FCVTNS Vd.2S, Vn.2S + /// int32x2_t vcvtn_s32_f32 (float32x2_t a) + /// A32: VCVTN.S32.F32 Dd, Dm + /// A64: FCVTNS Vd.2S, Vn.2S /// public static Vector64 ConvertToInt32RoundToEven(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vcvtnq_s32_f32 (float32x4_t a) - /// A32: VCVTN.S32.F32 Qd, Qm - /// A64: FCVTNS Vd.4S, Vn.4S + /// int32x4_t vcvtnq_s32_f32 (float32x4_t a) + /// A32: VCVTN.S32.F32 Qd, Qm + /// A64: FCVTNS Vd.4S, Vn.4S /// public static Vector128 ConvertToInt32RoundToEven(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int32_t vcvtns_s32_f32 (float32_t a) - /// A32: VCVTN.S32.F32 Sd, Sm - /// A64: FCVTNS Sd, Sn + /// int32_t vcvtns_s32_f32 (float32_t a) + /// A32: VCVTN.S32.F32 Sd, Sm + /// A64: FCVTNS Sd, Sn /// public static Vector64 ConvertToInt32RoundToEvenScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vcvtm_s32_f32 (float32x2_t a) - /// A32: VCVTM.S32.F32 Dd, Dm - /// A64: FCVTMS Vd.2S, Vn.2S + /// int32x2_t vcvtm_s32_f32 (float32x2_t a) + /// A32: VCVTM.S32.F32 Dd, Dm + /// A64: FCVTMS Vd.2S, Vn.2S /// public static Vector64 ConvertToInt32RoundToNegativeInfinity(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vcvtmq_s32_f32 (float32x4_t a) - /// A32: VCVTM.S32.F32 Qd, Qm - /// A64: FCVTMS Vd.4S, Vn.4S + /// int32x4_t vcvtmq_s32_f32 (float32x4_t a) + /// A32: VCVTM.S32.F32 Qd, Qm + /// A64: FCVTMS Vd.4S, Vn.4S /// public static Vector128 ConvertToInt32RoundToNegativeInfinity(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int32_t vcvtms_s32_f32 (float32_t a) - /// A32: VCVTM.S32.F32 Sd, Sm - /// A64: FCVTMS Sd, Sn + /// int32_t vcvtms_s32_f32 (float32_t a) + /// A32: VCVTM.S32.F32 Sd, Sm + /// A64: FCVTMS Sd, Sn /// public static Vector64 ConvertToInt32RoundToNegativeInfinityScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vcvtp_s32_f32 (float32x2_t a) - /// A32: VCVTP.S32.F32 Dd, Dm - /// A64: FCVTPS Vd.2S, Vn.2S + /// int32x2_t vcvtp_s32_f32 (float32x2_t a) + /// A32: VCVTP.S32.F32 Dd, Dm + /// A64: FCVTPS Vd.2S, Vn.2S /// public static Vector64 ConvertToInt32RoundToPositiveInfinity(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vcvtpq_s32_f32 (float32x4_t a) - /// A32: VCVTP.S32.F32 Qd, Qm - /// A64: FCVTPS Vd.4S, Vn.4S + /// int32x4_t vcvtpq_s32_f32 (float32x4_t a) + /// A32: VCVTP.S32.F32 Qd, Qm + /// A64: FCVTPS Vd.4S, Vn.4S /// public static Vector128 ConvertToInt32RoundToPositiveInfinity(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int32_t vcvtps_s32_f32 (float32_t a) - /// A32: VCVTP.S32.F32 Sd, Sm - /// A64: FCVTPS Sd, Sn + /// int32_t vcvtps_s32_f32 (float32_t a) + /// A32: VCVTP.S32.F32 Sd, Sm + /// A64: FCVTPS Sd, Sn /// public static Vector64 ConvertToInt32RoundToPositiveInfinityScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vcvt_s32_f32 (float32x2_t a) - /// A32: VCVT.S32.F32 Dd, Dm - /// A64: FCVTZS Vd.2S, Vn.2S + /// int32x2_t vcvt_s32_f32 (float32x2_t a) + /// A32: VCVT.S32.F32 Dd, Dm + /// A64: FCVTZS Vd.2S, Vn.2S /// public static Vector64 ConvertToInt32RoundToZero(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vcvtq_s32_f32 (float32x4_t a) - /// A32: VCVT.S32.F32 Qd, Qm - /// A64: FCVTZS Vd.4S, Vn.4S + /// int32x4_t vcvtq_s32_f32 (float32x4_t a) + /// A32: VCVT.S32.F32 Qd, Qm + /// A64: FCVTZS Vd.4S, Vn.4S /// public static Vector128 ConvertToInt32RoundToZero(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int32_t vcvts_s32_f32 (float32_t a) - /// A32: VCVT.S32.F32 Sd, Sm - /// A64: FCVTZS Sd, Sn + /// int32_t vcvts_s32_f32 (float32_t a) + /// A32: VCVT.S32.F32 Sd, Sm + /// A64: FCVTZS Sd, Sn /// public static Vector64 ConvertToInt32RoundToZeroScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vcvt_f32_s32 (int32x2_t a) - /// A32: VCVT.F32.S32 Dd, Dm - /// A64: SCVTF Vd.2S, Vn.2S + /// float32x2_t vcvt_f32_s32 (int32x2_t a) + /// A32: VCVT.F32.S32 Dd, Dm + /// A64: SCVTF Vd.2S, Vn.2S /// public static Vector64 ConvertToSingle(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vcvt_f32_u32 (uint32x2_t a) - /// A32: VCVT.F32.U32 Dd, Dm - /// A64: UCVTF Vd.2S, Vn.2S + /// float32x2_t vcvt_f32_u32 (uint32x2_t a) + /// A32: VCVT.F32.U32 Dd, Dm + /// A64: UCVTF Vd.2S, Vn.2S /// public static Vector64 ConvertToSingle(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vcvtq_f32_s32 (int32x4_t a) - /// A32: VCVT.F32.S32 Qd, Qm - /// A64: SCVTF Vd.4S, Vn.4S + /// float32x4_t vcvtq_f32_s32 (int32x4_t a) + /// A32: VCVT.F32.S32 Qd, Qm + /// A64: SCVTF Vd.4S, Vn.4S /// public static Vector128 ConvertToSingle(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vcvtq_f32_u32 (uint32x4_t a) - /// A32: VCVT.F32.U32 Qd, Qm - /// A64: UCVTF Vd.4S, Vn.4S + /// float32x4_t vcvtq_f32_u32 (uint32x4_t a) + /// A32: VCVT.F32.U32 Qd, Qm + /// A64: UCVTF Vd.4S, Vn.4S /// public static Vector128 ConvertToSingle(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float32_t vcvts_f32_s32 (int32_t a) - /// A32: VCVT.F32.S32 Sd, Sm - /// A64: SCVTF Sd, Sn + /// float32_t vcvts_f32_s32 (int32_t a) + /// A32: VCVT.F32.S32 Sd, Sm + /// A64: SCVTF Sd, Sn /// public static Vector64 ConvertToSingleScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32_t vcvts_f32_u32 (uint32_t a) - /// A32: VCVT.F32.U32 Sd, Sm - /// A64: UCVTF Sd, Sn + /// float32_t vcvts_f32_u32 (uint32_t a) + /// A32: VCVT.F32.U32 Sd, Sm + /// A64: UCVTF Sd, Sn /// public static Vector64 ConvertToSingleScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vcvta_u32_f32 (float32x2_t a) - /// A32: VCVTA.U32.F32 Dd, Dm - /// A64: FCVTAU Vd.2S, Vn.2S + /// uint32x2_t vcvta_u32_f32 (float32x2_t a) + /// A32: VCVTA.U32.F32 Dd, Dm + /// A64: FCVTAU Vd.2S, Vn.2S /// public static Vector64 ConvertToUInt32RoundAwayFromZero(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vcvtaq_u32_f32 (float32x4_t a) - /// A32: VCVTA.U32.F32 Qd, Qm - /// A64: FCVTAU Vd.4S, Vn.4S + /// uint32x4_t vcvtaq_u32_f32 (float32x4_t a) + /// A32: VCVTA.U32.F32 Qd, Qm + /// A64: FCVTAU Vd.4S, Vn.4S /// public static Vector128 ConvertToUInt32RoundAwayFromZero(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vcvtas_u32_f32 (float32_t a) - /// A32: VCVTA.U32.F32 Sd, Sm - /// A64: FCVTAU Sd, Sn + /// uint32_t vcvtas_u32_f32 (float32_t a) + /// A32: VCVTA.U32.F32 Sd, Sm + /// A64: FCVTAU Sd, Sn /// public static Vector64 ConvertToUInt32RoundAwayFromZeroScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vcvtn_u32_f32 (float32x2_t a) - /// A32: VCVTN.U32.F32 Dd, Dm - /// A64: FCVTNU Vd.2S, Vn.2S + /// uint32x2_t vcvtn_u32_f32 (float32x2_t a) + /// A32: VCVTN.U32.F32 Dd, Dm + /// A64: FCVTNU Vd.2S, Vn.2S /// public static Vector64 ConvertToUInt32RoundToEven(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vcvtnq_u32_f32 (float32x4_t a) - /// A32: VCVTN.U32.F32 Qd, Qm - /// A64: FCVTNU Vd.4S, Vn.4S + /// uint32x4_t vcvtnq_u32_f32 (float32x4_t a) + /// A32: VCVTN.U32.F32 Qd, Qm + /// A64: FCVTNU Vd.4S, Vn.4S /// public static Vector128 ConvertToUInt32RoundToEven(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vcvtns_u32_f32 (float32_t a) - /// A32: VCVTN.U32.F32 Sd, Sm - /// A64: FCVTNU Sd, Sn + /// uint32_t vcvtns_u32_f32 (float32_t a) + /// A32: VCVTN.U32.F32 Sd, Sm + /// A64: FCVTNU Sd, Sn /// public static Vector64 ConvertToUInt32RoundToEvenScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vcvtm_u32_f32 (float32x2_t a) - /// A32: VCVTM.U32.F32 Dd, Dm - /// A64: FCVTMU Vd.2S, Vn.2S + /// uint32x2_t vcvtm_u32_f32 (float32x2_t a) + /// A32: VCVTM.U32.F32 Dd, Dm + /// A64: FCVTMU Vd.2S, Vn.2S /// public static Vector64 ConvertToUInt32RoundToNegativeInfinity(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vcvtmq_u32_f32 (float32x4_t a) - /// A32: VCVTM.U32.F32 Qd, Qm - /// A64: FCVTMU Vd.4S, Vn.4S + /// uint32x4_t vcvtmq_u32_f32 (float32x4_t a) + /// A32: VCVTM.U32.F32 Qd, Qm + /// A64: FCVTMU Vd.4S, Vn.4S /// public static Vector128 ConvertToUInt32RoundToNegativeInfinity(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vcvtms_u32_f32 (float32_t a) - /// A32: VCVTM.U32.F32 Sd, Sm - /// A64: FCVTMU Sd, Sn + /// uint32_t vcvtms_u32_f32 (float32_t a) + /// A32: VCVTM.U32.F32 Sd, Sm + /// A64: FCVTMU Sd, Sn /// public static Vector64 ConvertToUInt32RoundToNegativeInfinityScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vcvtp_u32_f32 (float32x2_t a) - /// A32: VCVTP.U32.F32 Dd, Dm - /// A64: FCVTPU Vd.2S, Vn.2S + /// uint32x2_t vcvtp_u32_f32 (float32x2_t a) + /// A32: VCVTP.U32.F32 Dd, Dm + /// A64: FCVTPU Vd.2S, Vn.2S /// public static Vector64 ConvertToUInt32RoundToPositiveInfinity(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vcvtpq_u32_f32 (float32x4_t a) - /// A32: VCVTP.U32.F32 Qd, Qm - /// A64: FCVTPU Vd.4S, Vn.4S + /// uint32x4_t vcvtpq_u32_f32 (float32x4_t a) + /// A32: VCVTP.U32.F32 Qd, Qm + /// A64: FCVTPU Vd.4S, Vn.4S /// public static Vector128 ConvertToUInt32RoundToPositiveInfinity(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vcvtps_u32_f32 (float32_t a) - /// A32: VCVTP.U32.F32 Sd, Sm - /// A64: FCVTPU Sd, Sn + /// uint32_t vcvtps_u32_f32 (float32_t a) + /// A32: VCVTP.U32.F32 Sd, Sm + /// A64: FCVTPU Sd, Sn /// public static Vector64 ConvertToUInt32RoundToPositiveInfinityScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vcvt_u32_f32 (float32x2_t a) - /// A32: VCVT.U32.F32 Dd, Dm - /// A64: FCVTZU Vd.2S, Vn.2S + /// uint32x2_t vcvt_u32_f32 (float32x2_t a) + /// A32: VCVT.U32.F32 Dd, Dm + /// A64: FCVTZU Vd.2S, Vn.2S /// public static Vector64 ConvertToUInt32RoundToZero(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vcvtq_u32_f32 (float32x4_t a) - /// A32: VCVT.U32.F32 Qd, Qm - /// A64: FCVTZU Vd.4S, Vn.4S + /// uint32x4_t vcvtq_u32_f32 (float32x4_t a) + /// A32: VCVT.U32.F32 Qd, Qm + /// A64: FCVTZU Vd.4S, Vn.4S /// public static Vector128 ConvertToUInt32RoundToZero(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vcvts_u32_f32 (float32_t a) - /// A32: VCVT.U32.F32 Sd, Sm - /// A64: FCVTZU Sd, Sn + /// uint32_t vcvts_u32_f32 (float32_t a) + /// A32: VCVT.U32.F32 Sd, Sm + /// A64: FCVTZU Sd, Sn /// public static Vector64 ConvertToUInt32RoundToZeroScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vdiv_f64 (float64x1_t a, float64x1_t b) - /// A32: VDIV.F64 Dd, Dn, Dm - /// A64: FDIV Dd, Dn, Dm + /// float64x1_t vdiv_f64 (float64x1_t a, float64x1_t b) + /// A32: VDIV.F64 Dd, Dn, Dm + /// A64: FDIV Dd, Dn, Dm /// public static Vector64 DivideScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32_t vdivs_f32 (float32_t a, float32_t b) - /// A32: VDIV.F32 Sd, Sn, Sm - /// A64: FDIV Sd, Sn, Sm - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vdivs_f32 (float32_t a, float32_t b) + /// A32: VDIV.F32 Sd, Sn, Sm + /// A64: FDIV Sd, Sn, Sm + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 DivideScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vdup_lane_u8 (uint8x8_t vec, const int lane) - /// A32: VDUP.8 Dd, Dm[index] - /// A64: DUP Vd.8B, Vn.B[index] + /// uint8x8_t vdup_lane_u8 (uint8x8_t vec, const int lane) + /// A32: VDUP.8 Dd, Dm[index] + /// A64: DUP Vd.8B, Vn.B[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vdup_lane_s16 (int16x4_t vec, const int lane) - /// A32: VDUP.16 Dd, Dm[index] - /// A64: DUP Vd.4H, Vn.H[index] + /// int16x4_t vdup_lane_s16 (int16x4_t vec, const int lane) + /// A32: VDUP.16 Dd, Dm[index] + /// A64: DUP Vd.4H, Vn.H[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector64 value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vdup_lane_s32 (int32x2_t vec, const int lane) - /// A32: VDUP.32 Dd, Dm[index] - /// A64: DUP Vd.2S, Vn.S[index] + /// int32x2_t vdup_lane_s32 (int32x2_t vec, const int lane) + /// A32: VDUP.32 Dd, Dm[index] + /// A64: DUP Vd.2S, Vn.S[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector64 value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vdup_lane_f32 (float32x2_t vec, const int lane) - /// A32: VDUP.32 Dd, Dm[index] - /// A64: DUP Vd.2S, Vn.S[index] + /// float32x2_t vdup_lane_f32 (float32x2_t vec, const int lane) + /// A32: VDUP.32 Dd, Dm[index] + /// A64: DUP Vd.2S, Vn.S[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector64 value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vdup_lane_s8 (int8x8_t vec, const int lane) - /// A32: VDUP.8 Dd, Dm[index] - /// A64: DUP Vd.8B, Vn.B[index] + /// int8x8_t vdup_lane_s8 (int8x8_t vec, const int lane) + /// A32: VDUP.8 Dd, Dm[index] + /// A64: DUP Vd.8B, Vn.B[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vdup_lane_u16 (uint16x4_t vec, const int lane) - /// A32: VDUP.16 Dd, Dm[index] - /// A64: DUP Vd.4H, Vn.H[index] + /// uint16x4_t vdup_lane_u16 (uint16x4_t vec, const int lane) + /// A32: VDUP.16 Dd, Dm[index] + /// A64: DUP Vd.4H, Vn.H[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector64 value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vdup_lane_u32 (uint32x2_t vec, const int lane) - /// A32: VDUP.32 Dd, Dm[index] - /// A64: DUP Vd.2S, Vn.S[index] + /// uint32x2_t vdup_lane_u32 (uint32x2_t vec, const int lane) + /// A32: VDUP.32 Dd, Dm[index] + /// A64: DUP Vd.2S, Vn.S[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector64 value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vdup_laneq_u8 (uint8x16_t vec, const int lane) - /// A32: VDUP.8 Dd, Dm[index] - /// A64: DUP Vd.8B, Vn.B[index] + /// uint8x8_t vdup_laneq_u8 (uint8x16_t vec, const int lane) + /// A32: VDUP.8 Dd, Dm[index] + /// A64: DUP Vd.8B, Vn.B[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vdup_laneq_s16 (int16x8_t vec, const int lane) - /// A32: VDUP.16 Dd, Dm[index] - /// A64: DUP Vd.4H, Vn.H[index] + /// int16x4_t vdup_laneq_s16 (int16x8_t vec, const int lane) + /// A32: VDUP.16 Dd, Dm[index] + /// A64: DUP Vd.4H, Vn.H[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vdup_laneq_s32 (int32x4_t vec, const int lane) - /// A32: VDUP.32 Dd, Dm[index] - /// A64: DUP Vd.2S, Vn.S[index] + /// int32x2_t vdup_laneq_s32 (int32x4_t vec, const int lane) + /// A32: VDUP.32 Dd, Dm[index] + /// A64: DUP Vd.2S, Vn.S[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vdup_laneq_f32 (float32x4_t vec, const int lane) - /// A32: VDUP.32 Dd, Dm[index] - /// A64: DUP Vd.2S, Vn.S[index] + /// float32x2_t vdup_laneq_f32 (float32x4_t vec, const int lane) + /// A32: VDUP.32 Dd, Dm[index] + /// A64: DUP Vd.2S, Vn.S[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vdup_laneq_s8 (int8x16_t vec, const int lane) - /// A32: VDUP.8 Dd, Dm[index] - /// A64: DUP Vd.8B, Vn.B[index] + /// int8x8_t vdup_laneq_s8 (int8x16_t vec, const int lane) + /// A32: VDUP.8 Dd, Dm[index] + /// A64: DUP Vd.8B, Vn.B[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vdup_laneq_u16 (uint16x8_t vec, const int lane) - /// A32: VDUP.16 Dd, Dm[index] - /// A64: DUP Vd.4H, Vn.H[index] + /// uint16x4_t vdup_laneq_u16 (uint16x8_t vec, const int lane) + /// A32: VDUP.16 Dd, Dm[index] + /// A64: DUP Vd.4H, Vn.H[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vdup_laneq_u32 (uint32x4_t vec, const int lane) - /// A32: VDUP.32 Dd, Dm[index] - /// A64: DUP Vd.2S, Vn.S[index] + /// uint32x2_t vdup_laneq_u32 (uint32x4_t vec, const int lane) + /// A32: VDUP.32 Dd, Dm[index] + /// A64: DUP Vd.2S, Vn.S[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vdupq_lane_u8 (uint8x8_t vec, const int lane) - /// A32: VDUP.8 Qd, Dm[index] - /// A64: DUP Vd.16B, Vn.B[index] + /// uint8x16_t vdupq_lane_u8 (uint8x8_t vec, const int lane) + /// A32: VDUP.8 Qd, Dm[index] + /// A64: DUP Vd.16B, Vn.B[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vdupq_lane_s16 (int16x4_t vec, const int lane) - /// A32: VDUP.16 Qd, Dm[index] - /// A64: DUP Vd.8H, Vn.H[index] + /// int16x8_t vdupq_lane_s16 (int16x4_t vec, const int lane) + /// A32: VDUP.16 Qd, Dm[index] + /// A64: DUP Vd.8H, Vn.H[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector64 value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vdupq_lane_s32 (int32x2_t vec, const int lane) - /// A32: VDUP.32 Qd, Dm[index] - /// A64: DUP Vd.4S, Vn.S[index] + /// int32x4_t vdupq_lane_s32 (int32x2_t vec, const int lane) + /// A32: VDUP.32 Qd, Dm[index] + /// A64: DUP Vd.4S, Vn.S[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector64 value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vdupq_lane_f32 (float32x2_t vec, const int lane) - /// A32: VDUP.32 Qd, Dm[index] - /// A64: DUP Vd.4S, Vn.S[index] + /// float32x4_t vdupq_lane_f32 (float32x2_t vec, const int lane) + /// A32: VDUP.32 Qd, Dm[index] + /// A64: DUP Vd.4S, Vn.S[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector64 value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vdupq_lane_s8 (int8x8_t vec, const int lane) - /// A32: VDUP.8 Qd, Dm[index] - /// A64: DUP Vd.16B, Vn.B[index] + /// int8x16_t vdupq_lane_s8 (int8x8_t vec, const int lane) + /// A32: VDUP.8 Qd, Dm[index] + /// A64: DUP Vd.16B, Vn.B[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vdupq_lane_u16 (uint16x4_t vec, const int lane) - /// A32: VDUP.16 Qd, Dm[index] - /// A64: DUP Vd.8H, Vn.H[index] + /// uint16x8_t vdupq_lane_u16 (uint16x4_t vec, const int lane) + /// A32: VDUP.16 Qd, Dm[index] + /// A64: DUP Vd.8H, Vn.H[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector64 value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vdupq_lane_u32 (uint32x2_t vec, const int lane) - /// A32: VDUP.32 Qd, Dm[index] - /// A64: DUP Vd.4S, Vn.S[index] + /// uint32x4_t vdupq_lane_u32 (uint32x2_t vec, const int lane) + /// A32: VDUP.32 Qd, Dm[index] + /// A64: DUP Vd.4S, Vn.S[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector64 value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vdupq_lane_u8 (uint8x16_t vec, const int lane) - /// A32: VDUP.8 Qd, Dm[index] - /// A64: DUP Vd.16B, Vn.B[index] + /// uint8x16_t vdupq_lane_u8 (uint8x16_t vec, const int lane) + /// A32: VDUP.8 Qd, Dm[index] + /// A64: DUP Vd.16B, Vn.B[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vdupq_lane_s16 (int16x8_t vec, const int lane) - /// A32: VDUP.16 Qd, Dm[index] - /// A64: DUP Vd.8H, Vn.H[index] + /// int16x8_t vdupq_lane_s16 (int16x8_t vec, const int lane) + /// A32: VDUP.16 Qd, Dm[index] + /// A64: DUP Vd.8H, Vn.H[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vdupq_lane_s32 (int32x4_t vec, const int lane) - /// A32: VDUP.32 Qd, Dm[index] - /// A64: DUP Vd.4S, Vn.S[index] + /// int32x4_t vdupq_lane_s32 (int32x4_t vec, const int lane) + /// A32: VDUP.32 Qd, Dm[index] + /// A64: DUP Vd.4S, Vn.S[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vdupq_lane_f32 (float32x4_t vec, const int lane) - /// A32: VDUP.32 Qd, Dm[index] - /// A64: DUP Vd.4S, Vn.S[index] + /// float32x4_t vdupq_lane_f32 (float32x4_t vec, const int lane) + /// A32: VDUP.32 Qd, Dm[index] + /// A64: DUP Vd.4S, Vn.S[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vdupq_lane_s8 (int8x16_t vec, const int lane) - /// A32: VDUP.8 Qd, Dm[index] - /// A64: DUP Vd.16B, Vn.B[index] + /// int8x16_t vdupq_lane_s8 (int8x16_t vec, const int lane) + /// A32: VDUP.8 Qd, Dm[index] + /// A64: DUP Vd.16B, Vn.B[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vdupq_lane_u16 (uint16x8_t vec, const int lane) - /// A32: VDUP.16 Qd, Dm[index] - /// A64: DUP Vd.8H, Vn.H[index] + /// uint16x8_t vdupq_lane_u16 (uint16x8_t vec, const int lane) + /// A32: VDUP.16 Qd, Dm[index] + /// A64: DUP Vd.8H, Vn.H[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vdupq_lane_u32 (uint32x4_t vec, const int lane) - /// A32: VDUP.32 Qd, Dm[index] - /// A64: DUP Vd.4S, Vn.S[index] + /// uint32x4_t vdupq_lane_u32 (uint32x4_t vec, const int lane) + /// A32: VDUP.32 Qd, Dm[index] + /// A64: DUP Vd.4S, Vn.S[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vdup_n_u8 (uint8_t value) - /// A32: VDUP.8 Dd, Rt - /// A64: DUP Vd.8B, Rn + /// uint8x8_t vdup_n_u8 (uint8_t value) + /// A32: VDUP.8 Dd, Rt + /// A64: DUP Vd.8B, Rn /// public static Vector64 DuplicateToVector64(byte value) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vdup_n_s16 (int16_t value) - /// A32: VDUP.16 Dd, Rt - /// A64: DUP Vd.4H, Rn + /// int16x4_t vdup_n_s16 (int16_t value) + /// A32: VDUP.16 Dd, Rt + /// A64: DUP Vd.4H, Rn /// public static Vector64 DuplicateToVector64(short value) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vdup_n_s32 (int32_t value) - /// A32: VDUP.32 Dd, Rt - /// A64: DUP Vd.2S, Rn + /// int32x2_t vdup_n_s32 (int32_t value) + /// A32: VDUP.32 Dd, Rt + /// A64: DUP Vd.2S, Rn /// public static Vector64 DuplicateToVector64(int value) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vdup_n_s8 (int8_t value) - /// A32: VDUP.8 Dd, Rt - /// A64: DUP Vd.8B, Rn + /// int8x8_t vdup_n_s8 (int8_t value) + /// A32: VDUP.8 Dd, Rt + /// A64: DUP Vd.8B, Rn /// public static Vector64 DuplicateToVector64(sbyte value) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vdup_n_f32 (float32_t value) - /// A32: VDUP Dd, Dm[0] - /// A64: DUP Vd.2S, Vn.S[0] + /// float32x2_t vdup_n_f32 (float32_t value) + /// A32: VDUP Dd, Dm[0] + /// A64: DUP Vd.2S, Vn.S[0] /// public static Vector64 DuplicateToVector64(float value) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vdup_n_u16 (uint16_t value) - /// A32: VDUP.16 Dd, Rt - /// A64: DUP Vd.4H, Rn + /// uint16x4_t vdup_n_u16 (uint16_t value) + /// A32: VDUP.16 Dd, Rt + /// A64: DUP Vd.4H, Rn /// public static Vector64 DuplicateToVector64(ushort value) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vdup_n_u32 (uint32_t value) - /// A32: VDUP.32 Dd, Rt - /// A64: DUP Vd.2S, Rn + /// uint32x2_t vdup_n_u32 (uint32_t value) + /// A32: VDUP.32 Dd, Rt + /// A64: DUP Vd.2S, Rn /// public static Vector64 DuplicateToVector64(uint value) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vdupq_n_u8 (uint8_t value) - /// A32: VDUP.8 Qd, Rt - /// A64: DUP Vd.16B, Rn + /// uint8x16_t vdupq_n_u8 (uint8_t value) + /// A32: VDUP.8 Qd, Rt + /// A64: DUP Vd.16B, Rn /// public static Vector128 DuplicateToVector128(byte value) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vdupq_n_s16 (int16_t value) - /// A32: VDUP.16 Qd, Rt - /// A64: DUP Vd.8H, Rn + /// int16x8_t vdupq_n_s16 (int16_t value) + /// A32: VDUP.16 Qd, Rt + /// A64: DUP Vd.8H, Rn /// public static Vector128 DuplicateToVector128(short value) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vdupq_n_s32 (int32_t value) - /// A32: VDUP.32 Qd, Rt - /// A64: DUP Vd.4S, Rn + /// int32x4_t vdupq_n_s32 (int32_t value) + /// A32: VDUP.32 Qd, Rt + /// A64: DUP Vd.4S, Rn /// public static Vector128 DuplicateToVector128(int value) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vdupq_n_s8 (int8_t value) - /// A32: VDUP.8 Qd, Rt - /// A64: DUP Vd.16B, Rn + /// int8x16_t vdupq_n_s8 (int8_t value) + /// A32: VDUP.8 Qd, Rt + /// A64: DUP Vd.16B, Rn /// public static Vector128 DuplicateToVector128(sbyte value) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vdupq_n_f32 (float32_t value) - /// A32: VDUP Qd, Dm[0] - /// A64: DUP Vd.4S, Vn.S[0] + /// float32x4_t vdupq_n_f32 (float32_t value) + /// A32: VDUP Qd, Dm[0] + /// A64: DUP Vd.4S, Vn.S[0] /// public static Vector128 DuplicateToVector128(float value) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vdupq_n_u16 (uint16_t value) - /// A32: VDUP.16 Qd, Rt - /// A64: DUP Vd.8H, Rn + /// uint16x8_t vdupq_n_u16 (uint16_t value) + /// A32: VDUP.16 Qd, Rt + /// A64: DUP Vd.8H, Rn /// public static Vector128 DuplicateToVector128(ushort value) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vdupq_n_u32 (uint32_t value) - /// A32: VDUP.32 Qd, Rt - /// A64: DUP Vd.4S, Rn + /// uint32x4_t vdupq_n_u32 (uint32_t value) + /// A32: VDUP.32 Qd, Rt + /// A64: DUP Vd.4S, Rn /// public static Vector128 DuplicateToVector128(uint value) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vget_lane_u8 (uint8x8_t v, const int lane) - /// A32: VMOV.U8 Rt, Dn[lane] - /// A64: UMOV Wd, Vn.B[lane] + /// uint8_t vget_lane_u8 (uint8x8_t v, const int lane) + /// A32: VMOV.U8 Rt, Dn[lane] + /// A64: UMOV Wd, Vn.B[lane] /// public static byte Extract(Vector64 vector, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int16_t vget_lane_s16 (int16x4_t v, const int lane) - /// A32: VMOV.S16 Rt, Dn[lane] - /// A64: SMOV Wd, Vn.H[lane] + /// int16_t vget_lane_s16 (int16x4_t v, const int lane) + /// A32: VMOV.S16 Rt, Dn[lane] + /// A64: SMOV Wd, Vn.H[lane] /// public static short Extract(Vector64 vector, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int32_t vget_lane_s32 (int32x2_t v, const int lane) - /// A32: VMOV.32 Rt, Dn[lane] - /// A64: SMOV Wd, Vn.S[lane] + /// int32_t vget_lane_s32 (int32x2_t v, const int lane) + /// A32: VMOV.32 Rt, Dn[lane] + /// A64: SMOV Wd, Vn.S[lane] /// public static int Extract(Vector64 vector, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int8_t vget_lane_s8 (int8x8_t v, const int lane) - /// A32: VMOV.S8 Rt, Dn[lane] - /// A64: SMOV Wd, Vn.B[lane] + /// int8_t vget_lane_s8 (int8x8_t v, const int lane) + /// A32: VMOV.S8 Rt, Dn[lane] + /// A64: SMOV Wd, Vn.B[lane] /// public static sbyte Extract(Vector64 vector, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// float32_t vget_lane_f32 (float32x2_t v, const int lane) - /// A32: VMOV.F32 Sd, Sm - /// A64: DUP Sd, Vn.S[lane] + /// float32_t vget_lane_f32 (float32x2_t v, const int lane) + /// A32: VMOV.F32 Sd, Sm + /// A64: DUP Sd, Vn.S[lane] /// public static float Extract(Vector64 vector, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vget_lane_u16 (uint16x4_t v, const int lane) - /// A32: VMOV.U16 Rt, Dn[lane] - /// A64: UMOV Wd, Vn.H[lane] + /// uint16_t vget_lane_u16 (uint16x4_t v, const int lane) + /// A32: VMOV.U16 Rt, Dn[lane] + /// A64: UMOV Wd, Vn.H[lane] /// public static ushort Extract(Vector64 vector, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vget_lane_u32 (uint32x2_t v, const int lane) - /// A32: VMOV.32 Rt, Dn[lane] - /// A64: UMOV Wd, Vn.S[lane] + /// uint32_t vget_lane_u32 (uint32x2_t v, const int lane) + /// A32: VMOV.32 Rt, Dn[lane] + /// A64: UMOV Wd, Vn.S[lane] /// public static uint Extract(Vector64 vector, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint8_t vgetq_lane_u8 (uint8x16_t v, const int lane) - /// A32: VMOV.U8 Rt, Dn[lane] - /// A64: UMOV Wd, Vn.B[lane] + /// uint8_t vgetq_lane_u8 (uint8x16_t v, const int lane) + /// A32: VMOV.U8 Rt, Dn[lane] + /// A64: UMOV Wd, Vn.B[lane] /// public static byte Extract(Vector128 vector, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); } /// - /// float64_t vgetq_lane_f64 (float64x2_t v, const int lane) - /// A32: VMOV.F64 Dd, Dm - /// A64: DUP Dd, Vn.D[lane] + /// float64_t vgetq_lane_f64 (float64x2_t v, const int lane) + /// A32: VMOV.F64 Dd, Dm + /// A64: DUP Dd, Vn.D[lane] /// public static double Extract(Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int16_t vgetq_lane_s16 (int16x8_t v, const int lane) - /// A32: VMOV.S16 Rt, Dn[lane] - /// A64: SMOV Wd, Vn.H[lane] + /// int16_t vgetq_lane_s16 (int16x8_t v, const int lane) + /// A32: VMOV.S16 Rt, Dn[lane] + /// A64: SMOV Wd, Vn.H[lane] /// public static short Extract(Vector128 vector, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int32_t vgetq_lane_s32 (int32x4_t v, const int lane) - /// A32: VMOV.32 Rt, Dn[lane] - /// A64: SMOV Wd, Vn.S[lane] + /// int32_t vgetq_lane_s32 (int32x4_t v, const int lane) + /// A32: VMOV.32 Rt, Dn[lane] + /// A64: SMOV Wd, Vn.S[lane] /// public static int Extract(Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int64_t vgetq_lane_s64 (int64x2_t v, const int lane) - /// A32: VMOV Rt, Rt2, Dm - /// A64: UMOV Xd, Vn.D[lane] + /// int64_t vgetq_lane_s64 (int64x2_t v, const int lane) + /// A32: VMOV Rt, Rt2, Dm + /// A64: UMOV Xd, Vn.D[lane] /// public static long Extract(Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int8_t vgetq_lane_s8 (int8x16_t v, const int lane) - /// A32: VMOV.S8 Rt, Dn[lane] - /// A64: SMOV Wd, Vn.B[lane] + /// int8_t vgetq_lane_s8 (int8x16_t v, const int lane) + /// A32: VMOV.S8 Rt, Dn[lane] + /// A64: SMOV Wd, Vn.B[lane] /// public static sbyte Extract(Vector128 vector, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); } /// - /// float32_t vgetq_lane_f32 (float32x4_t v, const int lane) - /// A32: VMOV.F32 Sd, Sm - /// A64: DUP Sd, Vn.S[lane] + /// float32_t vgetq_lane_f32 (float32x4_t v, const int lane) + /// A32: VMOV.F32 Sd, Sm + /// A64: DUP Sd, Vn.S[lane] /// public static float Extract(Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint16_t vgetq_lane_u16 (uint16x8_t v, const int lane) - /// A32: VMOV.U16 Rt, Dn[lane] - /// A64: UMOV Wd, Vn.H[lane] + /// uint16_t vgetq_lane_u16 (uint16x8_t v, const int lane) + /// A32: VMOV.U16 Rt, Dn[lane] + /// A64: UMOV Wd, Vn.H[lane] /// public static ushort Extract(Vector128 vector, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint32_t vgetq_lane_u32 (uint32x4_t v, const int lane) - /// A32: VMOV.32 Rt, Dn[lane] - /// A64: UMOV Wd, Vn.S[lane] + /// uint32_t vgetq_lane_u32 (uint32x4_t v, const int lane) + /// A32: VMOV.32 Rt, Dn[lane] + /// A64: UMOV Wd, Vn.S[lane] /// public static uint Extract(Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint64_t vgetq_lane_u64 (uint64x2_t v, const int lane) - /// A32: VMOV Rt, Rt2, Dm - /// A64: UMOV Xd, Vn.D[lane] + /// uint64_t vgetq_lane_u64 (uint64x2_t v, const int lane) + /// A32: VMOV Rt, Rt2, Dm + /// A64: UMOV Xd, Vn.D[lane] /// public static ulong Extract(Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vmovn_u16 (uint16x8_t a) - /// A32: VMOVN.I16 Dd, Qm - /// A64: XTN Vd.8B, Vn.8H + /// uint8x8_t vmovn_u16 (uint16x8_t a) + /// A32: VMOVN.I16 Dd, Qm + /// A64: XTN Vd.8B, Vn.8H /// public static Vector64 ExtractNarrowingLower(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vmovn_s32 (int32x4_t a) - /// A32: VMOVN.I32 Dd, Qm - /// A64: XTN Vd.4H, Vn.4S + /// int16x4_t vmovn_s32 (int32x4_t a) + /// A32: VMOVN.I32 Dd, Qm + /// A64: XTN Vd.4H, Vn.4S /// public static Vector64 ExtractNarrowingLower(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vmovn_s64 (int64x2_t a) - /// A32: VMOVN.I64 Dd, Qm - /// A64: XTN Vd.2S, Vn.2D + /// int32x2_t vmovn_s64 (int64x2_t a) + /// A32: VMOVN.I64 Dd, Qm + /// A64: XTN Vd.2S, Vn.2D /// public static Vector64 ExtractNarrowingLower(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vmovn_s16 (int16x8_t a) - /// A32: VMOVN.I16 Dd, Qm - /// A64: XTN Vd.8B, Vn.8H + /// int8x8_t vmovn_s16 (int16x8_t a) + /// A32: VMOVN.I16 Dd, Qm + /// A64: XTN Vd.8B, Vn.8H /// public static Vector64 ExtractNarrowingLower(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vmovn_u32 (uint32x4_t a) - /// A32: VMOVN.I32 Dd, Qm - /// A64: XTN Vd.4H, Vn.4S + /// uint16x4_t vmovn_u32 (uint32x4_t a) + /// A32: VMOVN.I32 Dd, Qm + /// A64: XTN Vd.4H, Vn.4S /// public static Vector64 ExtractNarrowingLower(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vmovn_u64 (uint64x2_t a) - /// A32: VMOVN.I64 Dd, Qm - /// A64: XTN Vd.2S, Vn.2D + /// uint32x2_t vmovn_u64 (uint64x2_t a) + /// A32: VMOVN.I64 Dd, Qm + /// A64: XTN Vd.2S, Vn.2D /// public static Vector64 ExtractNarrowingLower(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vqmovn_u16 (uint16x8_t a) - /// A32: VQMOVN.U16 Dd, Qm - /// A64: UQXTN Vd.8B, Vn.8H + /// uint8x8_t vqmovn_u16 (uint16x8_t a) + /// A32: VQMOVN.U16 Dd, Qm + /// A64: UQXTN Vd.8B, Vn.8H /// public static Vector64 ExtractNarrowingSaturateLower(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vqmovn_s32 (int32x4_t a) - /// A32: VQMOVN.S32 Dd, Qm - /// A64: SQXTN Vd.4H, Vn.4S + /// int16x4_t vqmovn_s32 (int32x4_t a) + /// A32: VQMOVN.S32 Dd, Qm + /// A64: SQXTN Vd.4H, Vn.4S /// public static Vector64 ExtractNarrowingSaturateLower(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vqmovn_s64 (int64x2_t a) - /// A32: VQMOVN.S64 Dd, Qm - /// A64: SQXTN Vd.2S, Vn.2D + /// int32x2_t vqmovn_s64 (int64x2_t a) + /// A32: VQMOVN.S64 Dd, Qm + /// A64: SQXTN Vd.2S, Vn.2D /// public static Vector64 ExtractNarrowingSaturateLower(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vqmovn_s16 (int16x8_t a) - /// A32: VQMOVN.S16 Dd, Qm - /// A64: SQXTN Vd.8B, Vn.8H + /// int8x8_t vqmovn_s16 (int16x8_t a) + /// A32: VQMOVN.S16 Dd, Qm + /// A64: SQXTN Vd.8B, Vn.8H /// public static Vector64 ExtractNarrowingSaturateLower(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vqmovn_u32 (uint32x4_t a) - /// A32: VQMOVN.U32 Dd, Qm - /// A64: UQXTN Vd.4H, Vn.4S + /// uint16x4_t vqmovn_u32 (uint32x4_t a) + /// A32: VQMOVN.U32 Dd, Qm + /// A64: UQXTN Vd.4H, Vn.4S /// public static Vector64 ExtractNarrowingSaturateLower(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vqmovn_u64 (uint64x2_t a) - /// A32: VQMOVN.U64 Dd, Qm - /// A64: UQXTN Vd.2S, Vn.2D + /// uint32x2_t vqmovn_u64 (uint64x2_t a) + /// A32: VQMOVN.U64 Dd, Qm + /// A64: UQXTN Vd.2S, Vn.2D /// public static Vector64 ExtractNarrowingSaturateLower(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vqmovun_s16 (int16x8_t a) - /// A32: VQMOVUN.S16 Dd, Qm - /// A64: SQXTUN Vd.8B, Vn.8H + /// uint8x8_t vqmovun_s16 (int16x8_t a) + /// A32: VQMOVUN.S16 Dd, Qm + /// A64: SQXTUN Vd.8B, Vn.8H /// public static Vector64 ExtractNarrowingSaturateUnsignedLower(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vqmovun_s32 (int32x4_t a) - /// A32: VQMOVUN.S32 Dd, Qm - /// A64: SQXTUN Vd.4H, Vn.4S + /// uint16x4_t vqmovun_s32 (int32x4_t a) + /// A32: VQMOVUN.S32 Dd, Qm + /// A64: SQXTUN Vd.4H, Vn.4S /// public static Vector64 ExtractNarrowingSaturateUnsignedLower(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vqmovun_s64 (int64x2_t a) - /// A32: VQMOVUN.S64 Dd, Qm - /// A64: SQXTUN Vd.2S, Vn.2D + /// uint32x2_t vqmovun_s64 (int64x2_t a) + /// A32: VQMOVUN.S64 Dd, Qm + /// A64: SQXTUN Vd.2S, Vn.2D /// public static Vector64 ExtractNarrowingSaturateUnsignedLower(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vqmovun_high_s16 (uint8x8_t r, int16x8_t a) - /// A32: VQMOVUN.S16 Dd+1, Qm - /// A64: SQXTUN2 Vd.16B, Vn.8H + /// uint8x16_t vqmovun_high_s16 (uint8x8_t r, int16x8_t a) + /// A32: VQMOVUN.S16 Dd+1, Qm + /// A64: SQXTUN2 Vd.16B, Vn.8H /// public static Vector128 ExtractNarrowingSaturateUnsignedUpper(Vector64 lower, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vqmovun_high_s32 (uint16x4_t r, int32x4_t a) - /// A32: VQMOVUN.S32 Dd+1, Qm - /// A64: SQXTUN2 Vd.8H, Vn.4S + /// uint16x8_t vqmovun_high_s32 (uint16x4_t r, int32x4_t a) + /// A32: VQMOVUN.S32 Dd+1, Qm + /// A64: SQXTUN2 Vd.8H, Vn.4S /// public static Vector128 ExtractNarrowingSaturateUnsignedUpper(Vector64 lower, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vqmovun_high_s64 (uint32x2_t r, int64x2_t a) - /// A32: VQMOVUN.S64 Dd+1, Qm - /// A64: SQXTUN2 Vd.4S, Vn.2D + /// uint32x4_t vqmovun_high_s64 (uint32x2_t r, int64x2_t a) + /// A32: VQMOVUN.S64 Dd+1, Qm + /// A64: SQXTUN2 Vd.4S, Vn.2D /// public static Vector128 ExtractNarrowingSaturateUnsignedUpper(Vector64 lower, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vqmovn_high_u16 (uint8x8_t r, uint16x8_t a) - /// A32: VQMOVN.U16 Dd+1, Qm - /// A64: UQXTN2 Vd.16B, Vn.8H + /// uint8x16_t vqmovn_high_u16 (uint8x8_t r, uint16x8_t a) + /// A32: VQMOVN.U16 Dd+1, Qm + /// A64: UQXTN2 Vd.16B, Vn.8H /// public static Vector128 ExtractNarrowingSaturateUpper(Vector64 lower, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vqmovn_high_s32 (int16x4_t r, int32x4_t a) - /// A32: VQMOVN.S32 Dd+1, Qm - /// A64: SQXTN2 Vd.8H, Vn.4S + /// int16x8_t vqmovn_high_s32 (int16x4_t r, int32x4_t a) + /// A32: VQMOVN.S32 Dd+1, Qm + /// A64: SQXTN2 Vd.8H, Vn.4S /// public static Vector128 ExtractNarrowingSaturateUpper(Vector64 lower, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqmovn_high_s64 (int32x2_t r, int64x2_t a) - /// A32: VQMOVN.S64 Dd+1, Qm - /// A64: SQXTN2 Vd.4S, Vn.2D + /// int32x4_t vqmovn_high_s64 (int32x2_t r, int64x2_t a) + /// A32: VQMOVN.S64 Dd+1, Qm + /// A64: SQXTN2 Vd.4S, Vn.2D /// public static Vector128 ExtractNarrowingSaturateUpper(Vector64 lower, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vqmovn_high_s16 (int8x8_t r, int16x8_t a) - /// A32: VQMOVN.S16 Dd+1, Qm - /// A64: SQXTN2 Vd.16B, Vn.8H + /// int8x16_t vqmovn_high_s16 (int8x8_t r, int16x8_t a) + /// A32: VQMOVN.S16 Dd+1, Qm + /// A64: SQXTN2 Vd.16B, Vn.8H /// public static Vector128 ExtractNarrowingSaturateUpper(Vector64 lower, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vqmovn_high_u32 (uint16x4_t r, uint32x4_t a) - /// A32: VQMOVN.U32 Dd+1, Qm - /// A64: UQXTN2 Vd.8H, Vn.4S + /// uint16x8_t vqmovn_high_u32 (uint16x4_t r, uint32x4_t a) + /// A32: VQMOVN.U32 Dd+1, Qm + /// A64: UQXTN2 Vd.8H, Vn.4S /// public static Vector128 ExtractNarrowingSaturateUpper(Vector64 lower, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vqmovn_high_u64 (uint32x2_t r, uint64x2_t a) - /// A32: VQMOVN.U64 Dd+1, Qm - /// A64: UQXTN2 Vd.4S, Vn.2D + /// uint32x4_t vqmovn_high_u64 (uint32x2_t r, uint64x2_t a) + /// A32: VQMOVN.U64 Dd+1, Qm + /// A64: UQXTN2 Vd.4S, Vn.2D /// public static Vector128 ExtractNarrowingSaturateUpper(Vector64 lower, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vmovn_high_u16 (uint8x8_t r, uint16x8_t a) - /// A32: VMOVN.I16 Dd+1, Qm - /// A64: XTN2 Vd.16B, Vn.8H + /// uint8x16_t vmovn_high_u16 (uint8x8_t r, uint16x8_t a) + /// A32: VMOVN.I16 Dd+1, Qm + /// A64: XTN2 Vd.16B, Vn.8H /// public static Vector128 ExtractNarrowingUpper(Vector64 lower, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vmovn_high_s32 (int16x4_t r, int32x4_t a) - /// A32: VMOVN.I32 Dd+1, Qm - /// A64: XTN2 Vd.8H, Vn.4S + /// int16x8_t vmovn_high_s32 (int16x4_t r, int32x4_t a) + /// A32: VMOVN.I32 Dd+1, Qm + /// A64: XTN2 Vd.8H, Vn.4S /// public static Vector128 ExtractNarrowingUpper(Vector64 lower, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmovn_high_s64 (int32x2_t r, int64x2_t a) - /// A32: VMOVN.I64 Dd+1, Qm - /// A64: XTN2 Vd.4S, Vn.2D + /// int32x4_t vmovn_high_s64 (int32x2_t r, int64x2_t a) + /// A32: VMOVN.I64 Dd+1, Qm + /// A64: XTN2 Vd.4S, Vn.2D /// public static Vector128 ExtractNarrowingUpper(Vector64 lower, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vmovn_high_s16 (int8x8_t r, int16x8_t a) - /// A32: VMOVN.I16 Dd+1, Qm - /// A64: XTN2 Vd.16B, Vn.8H + /// int8x16_t vmovn_high_s16 (int8x8_t r, int16x8_t a) + /// A32: VMOVN.I16 Dd+1, Qm + /// A64: XTN2 Vd.16B, Vn.8H /// public static Vector128 ExtractNarrowingUpper(Vector64 lower, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmovn_high_u32 (uint16x4_t r, uint32x4_t a) - /// A32: VMOVN.I32 Dd+1, Qm - /// A64: XTN2 Vd.8H, Vn.4S + /// uint16x8_t vmovn_high_u32 (uint16x4_t r, uint32x4_t a) + /// A32: VMOVN.I32 Dd+1, Qm + /// A64: XTN2 Vd.8H, Vn.4S /// public static Vector128 ExtractNarrowingUpper(Vector64 lower, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmovn_high_u64 (uint32x2_t r, uint64x2_t a) - /// A32: VMOVN.I64 Dd+1, Qm - /// A64: XTN2 Vd.4S, Vn.2D + /// uint32x4_t vmovn_high_u64 (uint32x2_t r, uint64x2_t a) + /// A32: VMOVN.I64 Dd+1, Qm + /// A64: XTN2 Vd.4S, Vn.2D /// public static Vector128 ExtractNarrowingUpper(Vector64 lower, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vext_s8 (uint8x8_t a, uint8x8_t b, const int n) - /// A32: VEXT.8 Dd, Dn, Dm, #n - /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #n + /// uint8x8_t vext_s8 (uint8x8_t a, uint8x8_t b, const int n) + /// A32: VEXT.8 Dd, Dn, Dm, #n + /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #n /// public static Vector64 ExtractVector64(Vector64 upper, Vector64 lower, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vext_s16 (int16x4_t a, int16x4_t b, const int n) - /// A32: VEXT.8 Dd, Dn, Dm, #(n*2) - /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*2) + /// int16x4_t vext_s16 (int16x4_t a, int16x4_t b, const int n) + /// A32: VEXT.8 Dd, Dn, Dm, #(n*2) + /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*2) /// public static Vector64 ExtractVector64(Vector64 upper, Vector64 lower, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vext_s32 (int32x2_t a, int32x2_t b, const int n) - /// A32: VEXT.8 Dd, Dn, Dm, #(n*4) - /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*4) + /// int32x2_t vext_s32 (int32x2_t a, int32x2_t b, const int n) + /// A32: VEXT.8 Dd, Dn, Dm, #(n*4) + /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*4) /// public static Vector64 ExtractVector64(Vector64 upper, Vector64 lower, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vext_s8 (int8x8_t a, int8x8_t b, const int n) - /// A32: VEXT.8 Dd, Dn, Dm, #n - /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #n + /// int8x8_t vext_s8 (int8x8_t a, int8x8_t b, const int n) + /// A32: VEXT.8 Dd, Dn, Dm, #n + /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #n /// public static Vector64 ExtractVector64(Vector64 upper, Vector64 lower, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vext_f32 (float32x2_t a, float32x2_t b, const int n) - /// A32: VEXT.8 Dd, Dn, Dm, #(n*4) - /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*4) + /// float32x2_t vext_f32 (float32x2_t a, float32x2_t b, const int n) + /// A32: VEXT.8 Dd, Dn, Dm, #(n*4) + /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*4) /// public static Vector64 ExtractVector64(Vector64 upper, Vector64 lower, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vext_s16 (uint16x4_t a, uint16x4_t b, const int n) - /// A32: VEXT.8 Dd, Dn, Dm, #(n*2) - /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*2) + /// uint16x4_t vext_s16 (uint16x4_t a, uint16x4_t b, const int n) + /// A32: VEXT.8 Dd, Dn, Dm, #(n*2) + /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*2) /// public static Vector64 ExtractVector64(Vector64 upper, Vector64 lower, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vext_s32 (uint32x2_t a, uint32x2_t b, const int n) - /// A32: VEXT.8 Dd, Dn, Dm, #(n*4) - /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*4) + /// uint32x2_t vext_s32 (uint32x2_t a, uint32x2_t b, const int n) + /// A32: VEXT.8 Dd, Dn, Dm, #(n*4) + /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*4) /// public static Vector64 ExtractVector64(Vector64 upper, Vector64 lower, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vextq_s8 (uint8x16_t a, uint8x16_t b, const int n) - /// A32: VEXT.8 Qd, Qn, Qm, #n - /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #n + /// uint8x16_t vextq_s8 (uint8x16_t a, uint8x16_t b, const int n) + /// A32: VEXT.8 Qd, Qn, Qm, #n + /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #n /// public static Vector128 ExtractVector128(Vector128 upper, Vector128 lower, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vextq_f64 (float64x2_t a, float64x2_t b, const int n) - /// A32: VEXT.8 Qd, Qn, Qm, #(n*8) - /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*8) + /// float64x2_t vextq_f64 (float64x2_t a, float64x2_t b, const int n) + /// A32: VEXT.8 Qd, Qn, Qm, #(n*8) + /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*8) /// public static Vector128 ExtractVector128(Vector128 upper, Vector128 lower, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vextq_s16 (int16x8_t a, int16x8_t b, const int n) - /// A32: VEXT.8 Qd, Qn, Qm, #(n*2) - /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*2) + /// int16x8_t vextq_s16 (int16x8_t a, int16x8_t b, const int n) + /// A32: VEXT.8 Qd, Qn, Qm, #(n*2) + /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*2) /// public static Vector128 ExtractVector128(Vector128 upper, Vector128 lower, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vextq_s32 (int32x4_t a, int32x4_t b, const int n) - /// A32: VEXT.8 Qd, Qn, Qm, #(n*4) - /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*4) + /// int32x4_t vextq_s32 (int32x4_t a, int32x4_t b, const int n) + /// A32: VEXT.8 Qd, Qn, Qm, #(n*4) + /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*4) /// public static Vector128 ExtractVector128(Vector128 upper, Vector128 lower, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vextq_s64 (int64x2_t a, int64x2_t b, const int n) - /// A32: VEXT.8 Qd, Qn, Qm, #(n*8) - /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*8) + /// int64x2_t vextq_s64 (int64x2_t a, int64x2_t b, const int n) + /// A32: VEXT.8 Qd, Qn, Qm, #(n*8) + /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*8) /// public static Vector128 ExtractVector128(Vector128 upper, Vector128 lower, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vextq_s8 (int8x16_t a, int8x16_t b, const int n) - /// A32: VEXT.8 Qd, Qn, Qm, #n - /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #n + /// int8x16_t vextq_s8 (int8x16_t a, int8x16_t b, const int n) + /// A32: VEXT.8 Qd, Qn, Qm, #n + /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #n /// public static Vector128 ExtractVector128(Vector128 upper, Vector128 lower, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vextq_f32 (float32x4_t a, float32x4_t b, const int n) - /// A32: VEXT.8 Qd, Qn, Qm, #(n*4) - /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*4) + /// float32x4_t vextq_f32 (float32x4_t a, float32x4_t b, const int n) + /// A32: VEXT.8 Qd, Qn, Qm, #(n*4) + /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*4) /// public static Vector128 ExtractVector128(Vector128 upper, Vector128 lower, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vextq_s16 (uint16x8_t a, uint16x8_t b, const int n) - /// A32: VEXT.8 Qd, Qn, Qm, #(n*2) - /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*2) + /// uint16x8_t vextq_s16 (uint16x8_t a, uint16x8_t b, const int n) + /// A32: VEXT.8 Qd, Qn, Qm, #(n*2) + /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*2) /// public static Vector128 ExtractVector128(Vector128 upper, Vector128 lower, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vextq_s32 (uint32x4_t a, uint32x4_t b, const int n) - /// A32: VEXT.8 Qd, Qn, Qm, #(n*4) - /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*4) + /// uint32x4_t vextq_s32 (uint32x4_t a, uint32x4_t b, const int n) + /// A32: VEXT.8 Qd, Qn, Qm, #(n*4) + /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*4) /// public static Vector128 ExtractVector128(Vector128 upper, Vector128 lower, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vextq_s64 (uint64x2_t a, uint64x2_t b, const int n) - /// A32: VEXT.8 Qd, Qn, Qm, #(n*8) - /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*8) + /// uint64x2_t vextq_s64 (uint64x2_t a, uint64x2_t b, const int n) + /// A32: VEXT.8 Qd, Qn, Qm, #(n*8) + /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*8) /// public static Vector128 ExtractVector128(Vector128 upper, Vector128 lower, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vrndm_f32 (float32x2_t a) - /// A32: VRINTM.F32 Dd, Dm - /// A64: FRINTM Vd.2S, Vn.2S + /// float32x2_t vrndm_f32 (float32x2_t a) + /// A32: VRINTM.F32 Dd, Dm + /// A64: FRINTM Vd.2S, Vn.2S /// public static Vector64 Floor(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vrndmq_f32 (float32x4_t a) - /// A32: VRINTM.F32 Qd, Qm - /// A64: FRINTM Vd.4S, Vn.4S + /// float32x4_t vrndmq_f32 (float32x4_t a) + /// A32: VRINTM.F32 Qd, Qm + /// A64: FRINTM Vd.4S, Vn.4S /// public static Vector128 Floor(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vrndm_f64 (float64x1_t a) - /// A32: VRINTM.F64 Dd, Dm - /// A64: FRINTM Dd, Dn + /// float64x1_t vrndm_f64 (float64x1_t a) + /// A32: VRINTM.F64 Dd, Dm + /// A64: FRINTM Dd, Dn /// public static Vector64 FloorScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32_t vrndms_f32 (float32_t a) - /// A32: VRINTM.F32 Sd, Sm - /// A64: FRINTM Sd, Sn - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vrndms_f32 (float32_t a) + /// A32: VRINTM.F32 Sd, Sm + /// A64: FRINTM Sd, Sn + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 FloorScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vhadd_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VHADD.U8 Dd, Dn, Dm - /// A64: UHADD Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vhadd_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VHADD.U8 Dd, Dn, Dm + /// A64: UHADD Vd.8B, Vn.8B, Vm.8B /// public static Vector64 FusedAddHalving(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vhadd_s16 (int16x4_t a, int16x4_t b) - /// A32: VHADD.S16 Dd, Dn, Dm - /// A64: SHADD Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vhadd_s16 (int16x4_t a, int16x4_t b) + /// A32: VHADD.S16 Dd, Dn, Dm + /// A64: SHADD Vd.4H, Vn.4H, Vm.4H /// public static Vector64 FusedAddHalving(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vhadd_s32 (int32x2_t a, int32x2_t b) - /// A32: VHADD.S32 Dd, Dn, Dm - /// A64: SHADD Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vhadd_s32 (int32x2_t a, int32x2_t b) + /// A32: VHADD.S32 Dd, Dn, Dm + /// A64: SHADD Vd.2S, Vn.2S, Vm.2S /// public static Vector64 FusedAddHalving(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vhadd_s8 (int8x8_t a, int8x8_t b) - /// A32: VHADD.S8 Dd, Dn, Dm - /// A64: SHADD Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vhadd_s8 (int8x8_t a, int8x8_t b) + /// A32: VHADD.S8 Dd, Dn, Dm + /// A64: SHADD Vd.8B, Vn.8B, Vm.8B /// public static Vector64 FusedAddHalving(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vhadd_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VHADD.U16 Dd, Dn, Dm - /// A64: UHADD Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vhadd_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VHADD.U16 Dd, Dn, Dm + /// A64: UHADD Vd.4H, Vn.4H, Vm.4H /// public static Vector64 FusedAddHalving(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vhadd_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VHADD.U32 Dd, Dn, Dm - /// A64: UHADD Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vhadd_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VHADD.U32 Dd, Dn, Dm + /// A64: UHADD Vd.2S, Vn.2S, Vm.2S /// public static Vector64 FusedAddHalving(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vhaddq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VHADD.U8 Qd, Qn, Qm - /// A64: UHADD Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vhaddq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VHADD.U8 Qd, Qn, Qm + /// A64: UHADD Vd.16B, Vn.16B, Vm.16B /// public static Vector128 FusedAddHalving(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vhaddq_s16 (int16x8_t a, int16x8_t b) - /// A32: VHADD.S16 Qd, Qn, Qm - /// A64: SHADD Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vhaddq_s16 (int16x8_t a, int16x8_t b) + /// A32: VHADD.S16 Qd, Qn, Qm + /// A64: SHADD Vd.8H, Vn.8H, Vm.8H /// public static Vector128 FusedAddHalving(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vhaddq_s32 (int32x4_t a, int32x4_t b) - /// A32: VHADD.S32 Qd, Qn, Qm - /// A64: SHADD Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vhaddq_s32 (int32x4_t a, int32x4_t b) + /// A32: VHADD.S32 Qd, Qn, Qm + /// A64: SHADD Vd.4S, Vn.4S, Vm.4S /// public static Vector128 FusedAddHalving(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vhaddq_s8 (int8x16_t a, int8x16_t b) - /// A32: VHADD.S8 Qd, Qn, Qm - /// A64: SHADD Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vhaddq_s8 (int8x16_t a, int8x16_t b) + /// A32: VHADD.S8 Qd, Qn, Qm + /// A64: SHADD Vd.16B, Vn.16B, Vm.16B /// public static Vector128 FusedAddHalving(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vhaddq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VHADD.U16 Qd, Qn, Qm - /// A64: UHADD Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vhaddq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VHADD.U16 Qd, Qn, Qm + /// A64: UHADD Vd.8H, Vn.8H, Vm.8H /// public static Vector128 FusedAddHalving(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vhaddq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VHADD.U32 Qd, Qn, Qm - /// A64: UHADD Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vhaddq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VHADD.U32 Qd, Qn, Qm + /// A64: UHADD Vd.4S, Vn.4S, Vm.4S /// public static Vector128 FusedAddHalving(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vrhadd_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VRHADD.U8 Dd, Dn, Dm - /// A64: URHADD Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vrhadd_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VRHADD.U8 Dd, Dn, Dm + /// A64: URHADD Vd.8B, Vn.8B, Vm.8B /// public static Vector64 FusedAddRoundedHalving(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vrhadd_s16 (int16x4_t a, int16x4_t b) - /// A32: VRHADD.S16 Dd, Dn, Dm - /// A64: SRHADD Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vrhadd_s16 (int16x4_t a, int16x4_t b) + /// A32: VRHADD.S16 Dd, Dn, Dm + /// A64: SRHADD Vd.4H, Vn.4H, Vm.4H /// public static Vector64 FusedAddRoundedHalving(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vrhadd_s32 (int32x2_t a, int32x2_t b) - /// A32: VRHADD.S32 Dd, Dn, Dm - /// A64: SRHADD Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vrhadd_s32 (int32x2_t a, int32x2_t b) + /// A32: VRHADD.S32 Dd, Dn, Dm + /// A64: SRHADD Vd.2S, Vn.2S, Vm.2S /// public static Vector64 FusedAddRoundedHalving(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vrhadd_s8 (int8x8_t a, int8x8_t b) - /// A32: VRHADD.S8 Dd, Dn, Dm - /// A64: SRHADD Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vrhadd_s8 (int8x8_t a, int8x8_t b) + /// A32: VRHADD.S8 Dd, Dn, Dm + /// A64: SRHADD Vd.8B, Vn.8B, Vm.8B /// public static Vector64 FusedAddRoundedHalving(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vrhadd_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VRHADD.U16 Dd, Dn, Dm - /// A64: URHADD Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vrhadd_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VRHADD.U16 Dd, Dn, Dm + /// A64: URHADD Vd.4H, Vn.4H, Vm.4H /// public static Vector64 FusedAddRoundedHalving(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vrhadd_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VRHADD.U32 Dd, Dn, Dm - /// A64: URHADD Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vrhadd_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VRHADD.U32 Dd, Dn, Dm + /// A64: URHADD Vd.2S, Vn.2S, Vm.2S /// public static Vector64 FusedAddRoundedHalving(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vrhaddq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VRHADD.U8 Qd, Qn, Qm - /// A64: URHADD Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vrhaddq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VRHADD.U8 Qd, Qn, Qm + /// A64: URHADD Vd.16B, Vn.16B, Vm.16B /// public static Vector128 FusedAddRoundedHalving(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vrhaddq_s16 (int16x8_t a, int16x8_t b) - /// A32: VRHADD.S16 Qd, Qn, Qm - /// A64: SRHADD Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vrhaddq_s16 (int16x8_t a, int16x8_t b) + /// A32: VRHADD.S16 Qd, Qn, Qm + /// A64: SRHADD Vd.8H, Vn.8H, Vm.8H /// public static Vector128 FusedAddRoundedHalving(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vrhaddq_s32 (int32x4_t a, int32x4_t b) - /// A32: VRHADD.S32 Qd, Qn, Qm - /// A64: SRHADD Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vrhaddq_s32 (int32x4_t a, int32x4_t b) + /// A32: VRHADD.S32 Qd, Qn, Qm + /// A64: SRHADD Vd.4S, Vn.4S, Vm.4S /// public static Vector128 FusedAddRoundedHalving(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vrhaddq_s8 (int8x16_t a, int8x16_t b) - /// A32: VRHADD.S8 Qd, Qn, Qm - /// A64: SRHADD Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vrhaddq_s8 (int8x16_t a, int8x16_t b) + /// A32: VRHADD.S8 Qd, Qn, Qm + /// A64: SRHADD Vd.16B, Vn.16B, Vm.16B /// public static Vector128 FusedAddRoundedHalving(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vrhaddq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VRHADD.U16 Qd, Qn, Qm - /// A64: URHADD Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vrhaddq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VRHADD.U16 Qd, Qn, Qm + /// A64: URHADD Vd.8H, Vn.8H, Vm.8H /// public static Vector128 FusedAddRoundedHalving(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vrhaddq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VRHADD.U32 Qd, Qn, Qm - /// A64: URHADD Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vrhaddq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VRHADD.U32 Qd, Qn, Qm + /// A64: URHADD Vd.4S, Vn.4S, Vm.4S /// public static Vector128 FusedAddRoundedHalving(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vfma_f32 (float32x2_t a, float32x2_t b, float32x2_t c) - /// A32: VFMA.F32 Dd, Dn, Dm - /// A64: FMLA Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vfma_f32 (float32x2_t a, float32x2_t b, float32x2_t c) + /// A32: VFMA.F32 Dd, Dn, Dm + /// A64: FMLA Vd.2S, Vn.2S, Vm.2S /// public static Vector64 FusedMultiplyAdd(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vfmaq_f32 (float32x4_t a, float32x4_t b, float32x4_t c) - /// A32: VFMA.F32 Qd, Qn, Qm - /// A64: FMLA Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vfmaq_f32 (float32x4_t a, float32x4_t b, float32x4_t c) + /// A32: VFMA.F32 Qd, Qn, Qm + /// A64: FMLA Vd.4S, Vn.4S, Vm.4S /// public static Vector128 FusedMultiplyAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vfnma_f64 (float64x1_t a, float64x1_t b, float64x1_t c) - /// A32: VFNMA.F64 Dd, Dn, Dm - /// A64: FNMADD Dd, Dn, Dm, Da - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x1_t vfnma_f64 (float64x1_t a, float64x1_t b, float64x1_t c) + /// A32: VFNMA.F64 Dd, Dn, Dm + /// A64: FNMADD Dd, Dn, Dm, Da + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 FusedMultiplyAddNegatedScalar(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32_t vfnmas_f32 (float32_t a, float32_t b, float32_t c) - /// A32: VFNMA.F32 Sd, Sn, Sm - /// A64: FNMADD Sd, Sn, Sm, Sa - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vfnmas_f32 (float32_t a, float32_t b, float32_t c) + /// A32: VFNMA.F32 Sd, Sn, Sm + /// A64: FNMADD Sd, Sn, Sm, Sa + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 FusedMultiplyAddNegatedScalar(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vfma_f64 (float64x1_t a, float64x1_t b, float64x1_t c) - /// A32: VFMA.F64 Dd, Dn, Dm - /// A64: FMADD Dd, Dn, Dm, Da + /// float64x1_t vfma_f64 (float64x1_t a, float64x1_t b, float64x1_t c) + /// A32: VFMA.F64 Dd, Dn, Dm + /// A64: FMADD Dd, Dn, Dm, Da /// public static Vector64 FusedMultiplyAddScalar(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32_t vfmas_f32 (float32_t a, float32_t b, float32_t c) - /// A32: VFMA.F32 Sd, Sn, Sm - /// A64: FMADD Sd, Sn, Sm, Sa - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vfmas_f32 (float32_t a, float32_t b, float32_t c) + /// A32: VFMA.F32 Sd, Sn, Sm + /// A64: FMADD Sd, Sn, Sm, Sa + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 FusedMultiplyAddScalar(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vfms_f32 (float32x2_t a, float32x2_t b, float32x2_t c) - /// A32: VFMS.F32 Dd, Dn, Dm - /// A64: FMLS Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vfms_f32 (float32x2_t a, float32x2_t b, float32x2_t c) + /// A32: VFMS.F32 Dd, Dn, Dm + /// A64: FMLS Vd.2S, Vn.2S, Vm.2S /// public static Vector64 FusedMultiplySubtract(Vector64 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vfmsq_f32 (float32x4_t a, float32x4_t b, float32x4_t c) - /// A32: VFMS.F32 Qd, Qn, Qm - /// A64: FMLS Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vfmsq_f32 (float32x4_t a, float32x4_t b, float32x4_t c) + /// A32: VFMS.F32 Qd, Qn, Qm + /// A64: FMLS Vd.4S, Vn.4S, Vm.4S /// public static Vector128 FusedMultiplySubtract(Vector128 minuend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vfnms_f64 (float64x1_t a, float64x1_t b, float64x1_t c) - /// A32: VFNMS.F64 Dd, Dn, Dm - /// A64: FNMSUB Dd, Dn, Dm, Da - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x1_t vfnms_f64 (float64x1_t a, float64x1_t b, float64x1_t c) + /// A32: VFNMS.F64 Dd, Dn, Dm + /// A64: FNMSUB Dd, Dn, Dm, Da + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 FusedMultiplySubtractNegatedScalar(Vector64 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32_t vfnmss_f32 (float32_t a, float32_t b, float32_t c) - /// A32: VFNMS.F32 Sd, Sn, Sm - /// A64: FNMSUB Sd, Sn, Sm, Sa - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vfnmss_f32 (float32_t a, float32_t b, float32_t c) + /// A32: VFNMS.F32 Sd, Sn, Sm + /// A64: FNMSUB Sd, Sn, Sm, Sa + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 FusedMultiplySubtractNegatedScalar(Vector64 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vfms_f64 (float64x1_t a, float64x1_t b, float64x1_t c) - /// A32: VFMS.F64 Dd, Dn, Dm - /// A64: FMSUB Dd, Dn, Dm, Da + /// float64x1_t vfms_f64 (float64x1_t a, float64x1_t b, float64x1_t c) + /// A32: VFMS.F64 Dd, Dn, Dm + /// A64: FMSUB Dd, Dn, Dm, Da /// public static Vector64 FusedMultiplySubtractScalar(Vector64 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32_t vfmss_f32 (float32_t a, float32_t b, float32_t c) - /// A32: VFMS.F32 Sd, Sn, Sm - /// A64: FMSUB Sd, Sn, Sm, Sa - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vfmss_f32 (float32_t a, float32_t b, float32_t c) + /// A32: VFMS.F32 Sd, Sn, Sm + /// A64: FMSUB Sd, Sn, Sm, Sa + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 FusedMultiplySubtractScalar(Vector64 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vhsub_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VHSUB.U8 Dd, Dn, Dm - /// A64: UHSUB Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vhsub_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VHSUB.U8 Dd, Dn, Dm + /// A64: UHSUB Vd.8B, Vn.8B, Vm.8B /// public static Vector64 FusedSubtractHalving(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vhsub_s16 (int16x4_t a, int16x4_t b) - /// A32: VHSUB.S16 Dd, Dn, Dm - /// A64: SHSUB Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vhsub_s16 (int16x4_t a, int16x4_t b) + /// A32: VHSUB.S16 Dd, Dn, Dm + /// A64: SHSUB Vd.4H, Vn.4H, Vm.4H /// public static Vector64 FusedSubtractHalving(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vhsub_s32 (int32x2_t a, int32x2_t b) - /// A32: VHSUB.S32 Dd, Dn, Dm - /// A64: SHSUB Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vhsub_s32 (int32x2_t a, int32x2_t b) + /// A32: VHSUB.S32 Dd, Dn, Dm + /// A64: SHSUB Vd.2S, Vn.2S, Vm.2S /// public static Vector64 FusedSubtractHalving(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vhsub_s8 (int8x8_t a, int8x8_t b) - /// A32: VHSUB.S8 Dd, Dn, Dm - /// A64: SHSUB Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vhsub_s8 (int8x8_t a, int8x8_t b) + /// A32: VHSUB.S8 Dd, Dn, Dm + /// A64: SHSUB Vd.8B, Vn.8B, Vm.8B /// public static Vector64 FusedSubtractHalving(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vhsub_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VHSUB.U16 Dd, Dn, Dm - /// A64: UHSUB Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vhsub_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VHSUB.U16 Dd, Dn, Dm + /// A64: UHSUB Vd.4H, Vn.4H, Vm.4H /// public static Vector64 FusedSubtractHalving(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vhsub_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VHSUB.U32 Dd, Dn, Dm - /// A64: UHSUB Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vhsub_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VHSUB.U32 Dd, Dn, Dm + /// A64: UHSUB Vd.2S, Vn.2S, Vm.2S /// public static Vector64 FusedSubtractHalving(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vhsubq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VHSUB.U8 Qd, Qn, Qm - /// A64: UHSUB Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vhsubq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VHSUB.U8 Qd, Qn, Qm + /// A64: UHSUB Vd.16B, Vn.16B, Vm.16B /// public static Vector128 FusedSubtractHalving(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vhsubq_s16 (int16x8_t a, int16x8_t b) - /// A32: VHSUB.S16 Qd, Qn, Qm - /// A64: SHSUB Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vhsubq_s16 (int16x8_t a, int16x8_t b) + /// A32: VHSUB.S16 Qd, Qn, Qm + /// A64: SHSUB Vd.8H, Vn.8H, Vm.8H /// public static Vector128 FusedSubtractHalving(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vhsubq_s32 (int32x4_t a, int32x4_t b) - /// A32: VHSUB.S32 Qd, Qn, Qm - /// A64: SHSUB Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vhsubq_s32 (int32x4_t a, int32x4_t b) + /// A32: VHSUB.S32 Qd, Qn, Qm + /// A64: SHSUB Vd.4S, Vn.4S, Vm.4S /// public static Vector128 FusedSubtractHalving(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vhsubq_s8 (int8x16_t a, int8x16_t b) - /// A32: VHSUB.S8 Qd, Qn, Qm - /// A64: SHSUB Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vhsubq_s8 (int8x16_t a, int8x16_t b) + /// A32: VHSUB.S8 Qd, Qn, Qm + /// A64: SHSUB Vd.16B, Vn.16B, Vm.16B /// public static Vector128 FusedSubtractHalving(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vhsubq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VHSUB.U16 Qd, Qn, Qm - /// A64: UHSUB Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vhsubq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VHSUB.U16 Qd, Qn, Qm + /// A64: UHSUB Vd.8H, Vn.8H, Vm.8H /// public static Vector128 FusedSubtractHalving(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vhsubq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VHSUB.U32 Qd, Qn, Qm - /// A64: UHSUB Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vhsubq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VHSUB.U32 Qd, Qn, Qm + /// A64: UHSUB Vd.4S, Vn.4S, Vm.4S /// public static Vector128 FusedSubtractHalving(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vset_lane_u8 (uint8_t a, uint8x8_t v, const int lane) - /// A32: VMOV.8 Dd[lane], Rt - /// A64: INS Vd.B[lane], Wn + /// uint8x8_t vset_lane_u8 (uint8_t a, uint8x8_t v, const int lane) + /// A32: VMOV.8 Dd[lane], Rt + /// A64: INS Vd.B[lane], Wn /// public static Vector64 Insert(Vector64 vector, [ConstantExpected(Max = (byte)(7))] byte index, byte data) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vset_lane_s16 (int16_t a, int16x4_t v, const int lane) - /// A32: VMOV.16 Dd[lane], Rt - /// A64: INS Vd.H[lane], Wn + /// int16x4_t vset_lane_s16 (int16_t a, int16x4_t v, const int lane) + /// A32: VMOV.16 Dd[lane], Rt + /// A64: INS Vd.H[lane], Wn /// public static Vector64 Insert(Vector64 vector, [ConstantExpected(Max = (byte)(3))] byte index, short data) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vset_lane_s32 (int32_t a, int32x2_t v, const int lane) - /// A32: VMOV.32 Dd[lane], Rt - /// A64: INS Vd.S[lane], Wn + /// int32x2_t vset_lane_s32 (int32_t a, int32x2_t v, const int lane) + /// A32: VMOV.32 Dd[lane], Rt + /// A64: INS Vd.S[lane], Wn /// public static Vector64 Insert(Vector64 vector, [ConstantExpected(Max = (byte)(1))] byte index, int data) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vset_lane_s8 (int8_t a, int8x8_t v, const int lane) - /// A32: VMOV.8 Dd[lane], Rt - /// A64: INS Vd.B[lane], Wn + /// int8x8_t vset_lane_s8 (int8_t a, int8x8_t v, const int lane) + /// A32: VMOV.8 Dd[lane], Rt + /// A64: INS Vd.B[lane], Wn /// public static Vector64 Insert(Vector64 vector, [ConstantExpected(Max = (byte)(7))] byte index, sbyte data) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vset_lane_f32 (float32_t a, float32x2_t v, const int lane) - /// A32: VMOV.F32 Sd, Sm - /// A64: INS Vd.S[lane], Vn.S[0] + /// float32x2_t vset_lane_f32 (float32_t a, float32x2_t v, const int lane) + /// A32: VMOV.F32 Sd, Sm + /// A64: INS Vd.S[lane], Vn.S[0] /// public static Vector64 Insert(Vector64 vector, [ConstantExpected(Max = (byte)(1))] byte index, float data) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vset_lane_u16 (uint16_t a, uint16x4_t v, const int lane) - /// A32: VMOV.16 Dd[lane], Rt - /// A64: INS Vd.H[lane], Wn + /// uint16x4_t vset_lane_u16 (uint16_t a, uint16x4_t v, const int lane) + /// A32: VMOV.16 Dd[lane], Rt + /// A64: INS Vd.H[lane], Wn /// public static Vector64 Insert(Vector64 vector, [ConstantExpected(Max = (byte)(3))] byte index, ushort data) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vset_lane_u32 (uint32_t a, uint32x2_t v, const int lane) - /// A32: VMOV.32 Dd[lane], Rt - /// A64: INS Vd.S[lane], Wn + /// uint32x2_t vset_lane_u32 (uint32_t a, uint32x2_t v, const int lane) + /// A32: VMOV.32 Dd[lane], Rt + /// A64: INS Vd.S[lane], Wn /// public static Vector64 Insert(Vector64 vector, [ConstantExpected(Max = (byte)(1))] byte index, uint data) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vsetq_lane_u8 (uint8_t a, uint8x16_t v, const int lane) - /// A32: VMOV.8 Dd[lane], Rt - /// A64: INS Vd.B[lane], Wn + /// uint8x16_t vsetq_lane_u8 (uint8_t a, uint8x16_t v, const int lane) + /// A32: VMOV.8 Dd[lane], Rt + /// A64: INS Vd.B[lane], Wn /// public static Vector128 Insert(Vector128 vector, [ConstantExpected(Max = (byte)(15))] byte index, byte data) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vsetq_lane_f64 (float64_t a, float64x2_t v, const int lane) - /// A32: VMOV.F64 Dd, Dm - /// A64: INS Vd.D[lane], Vn.D[0] + /// float64x2_t vsetq_lane_f64 (float64_t a, float64x2_t v, const int lane) + /// A32: VMOV.F64 Dd, Dm + /// A64: INS Vd.D[lane], Vn.D[0] /// public static Vector128 Insert(Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte index, double data) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vsetq_lane_s16 (int16_t a, int16x8_t v, const int lane) - /// A32: VMOV.16 Dd[lane], Rt - /// A64: INS Vd.H[lane], Wn + /// int16x8_t vsetq_lane_s16 (int16_t a, int16x8_t v, const int lane) + /// A32: VMOV.16 Dd[lane], Rt + /// A64: INS Vd.H[lane], Wn /// public static Vector128 Insert(Vector128 vector, [ConstantExpected(Max = (byte)(7))] byte index, short data) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vsetq_lane_s32 (int32_t a, int32x4_t v, const int lane) - /// A32: VMOV.32 Dd[lane], Rt - /// A64: INS Vd.S[lane], Wn + /// int32x4_t vsetq_lane_s32 (int32_t a, int32x4_t v, const int lane) + /// A32: VMOV.32 Dd[lane], Rt + /// A64: INS Vd.S[lane], Wn /// public static Vector128 Insert(Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index, int data) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vsetq_lane_s64 (int64_t a, int64x2_t v, const int lane) - /// A32: VMOV.64 Dd, Rt, Rt2 - /// A64: INS Vd.D[lane], Xn + /// int64x2_t vsetq_lane_s64 (int64_t a, int64x2_t v, const int lane) + /// A32: VMOV.64 Dd, Rt, Rt2 + /// A64: INS Vd.D[lane], Xn /// public static Vector128 Insert(Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte index, long data) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vsetq_lane_s8 (int8_t a, int8x16_t v, const int lane) - /// A32: VMOV.8 Dd[lane], Rt - /// A64: INS Vd.B[lane], Wn + /// int8x16_t vsetq_lane_s8 (int8_t a, int8x16_t v, const int lane) + /// A32: VMOV.8 Dd[lane], Rt + /// A64: INS Vd.B[lane], Wn /// public static Vector128 Insert(Vector128 vector, [ConstantExpected(Max = (byte)(15))] byte index, sbyte data) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vsetq_lane_f32 (float32_t a, float32x4_t v, const int lane) - /// A32: VMOV.F32 Sd, Sm - /// A64: INS Vd.S[lane], Vn.S[0] + /// float32x4_t vsetq_lane_f32 (float32_t a, float32x4_t v, const int lane) + /// A32: VMOV.F32 Sd, Sm + /// A64: INS Vd.S[lane], Vn.S[0] /// public static Vector128 Insert(Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index, float data) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vsetq_lane_u16 (uint16_t a, uint16x8_t v, const int lane) - /// A32: VMOV.16 Dd[lane], Rt - /// A64: INS Vd.H[lane], Wn + /// uint16x8_t vsetq_lane_u16 (uint16_t a, uint16x8_t v, const int lane) + /// A32: VMOV.16 Dd[lane], Rt + /// A64: INS Vd.H[lane], Wn /// public static Vector128 Insert(Vector128 vector, [ConstantExpected(Max = (byte)(7))] byte index, ushort data) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vsetq_lane_u32 (uint32_t a, uint32x4_t v, const int lane) - /// A32: VMOV.32 Dd[lane], Rt - /// A64: INS Vd.S[lane], Wn + /// uint32x4_t vsetq_lane_u32 (uint32_t a, uint32x4_t v, const int lane) + /// A32: VMOV.32 Dd[lane], Rt + /// A64: INS Vd.S[lane], Wn /// public static Vector128 Insert(Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index, uint data) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vsetq_lane_u64 (uint64_t a, uint64x2_t v, const int lane) - /// A32: VMOV.64 Dd, Rt, Rt2 - /// A64: INS Vd.D[lane], Xn + /// uint64x2_t vsetq_lane_u64 (uint64_t a, uint64x2_t v, const int lane) + /// A32: VMOV.64 Dd, Rt, Rt2 + /// A64: INS Vd.D[lane], Xn /// public static Vector128 Insert(Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte index, ulong data) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vcopyq_lane_f64 (float64x2_t a, const int lane1, float64x1_t b, const int lane2) - /// A32: VMOV.F64 Dd, Dm - /// A64: INS Vd.D[lane1], Vn.D[0] + /// float64x2_t vcopyq_lane_f64 (float64x2_t a, const int lane1, float64x1_t b, const int lane2) + /// A32: VMOV.F64 Dd, Dm + /// A64: INS Vd.D[lane1], Vn.D[0] /// public static Vector128 InsertScalar(Vector128 result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vcopyq_lane_s64 (int64x2_t a, const int lane1, int64x1_t b, const int lane2) - /// A32: VMOV Dd, Dm - /// A64: INS Vd.D[lane1], Vn.D[0] + /// int64x2_t vcopyq_lane_s64 (int64x2_t a, const int lane1, int64x1_t b, const int lane2) + /// A32: VMOV Dd, Dm + /// A64: INS Vd.D[lane1], Vn.D[0] /// public static Vector128 InsertScalar(Vector128 result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vcopyq_lane_u64 (uint64x2_t a, const int lane1, uint64x1_t b, const int lane2) - /// A32: VMOV Dd, Dm - /// A64: INS Vd.D[lane1], Vn.D[0] + /// uint64x2_t vcopyq_lane_u64 (uint64x2_t a, const int lane1, uint64x1_t b, const int lane2) + /// A32: VMOV Dd, Dm + /// A64: INS Vd.D[lane1], Vn.D[0] /// public static Vector128 InsertScalar(Vector128 result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vcls_s16 (int16x4_t a) - /// A32: VCLS.S16 Dd, Dm - /// A64: CLS Vd.4H, Vn.4H + /// int16x4_t vcls_s16 (int16x4_t a) + /// A32: VCLS.S16 Dd, Dm + /// A64: CLS Vd.4H, Vn.4H /// public static Vector64 LeadingSignCount(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vcls_s32 (int32x2_t a) - /// A32: VCLS.S32 Dd, Dm - /// A64: CLS Vd.2S, Vn.2S + /// int32x2_t vcls_s32 (int32x2_t a) + /// A32: VCLS.S32 Dd, Dm + /// A64: CLS Vd.2S, Vn.2S /// public static Vector64 LeadingSignCount(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vcls_s8 (int8x8_t a) - /// A32: VCLS.S8 Dd, Dm - /// A64: CLS Vd.8B, Vn.8B + /// int8x8_t vcls_s8 (int8x8_t a) + /// A32: VCLS.S8 Dd, Dm + /// A64: CLS Vd.8B, Vn.8B /// public static Vector64 LeadingSignCount(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vclsq_s16 (int16x8_t a) - /// A32: VCLS.S16 Qd, Qm - /// A64: CLS Vd.8H, Vn.8H + /// int16x8_t vclsq_s16 (int16x8_t a) + /// A32: VCLS.S16 Qd, Qm + /// A64: CLS Vd.8H, Vn.8H /// public static Vector128 LeadingSignCount(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vclsq_s32 (int32x4_t a) - /// A32: VCLS.S32 Qd, Qm - /// A64: CLS Vd.4S, Vn.4S + /// int32x4_t vclsq_s32 (int32x4_t a) + /// A32: VCLS.S32 Qd, Qm + /// A64: CLS Vd.4S, Vn.4S /// public static Vector128 LeadingSignCount(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vclsq_s8 (int8x16_t a) - /// A32: VCLS.S8 Qd, Qm - /// A64: CLS Vd.16B, Vn.16B + /// int8x16_t vclsq_s8 (int8x16_t a) + /// A32: VCLS.S8 Qd, Qm + /// A64: CLS Vd.16B, Vn.16B /// public static Vector128 LeadingSignCount(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vclz_u8 (uint8x8_t a) - /// A32: VCLZ.I8 Dd, Dm - /// A64: CLZ Vd.8B, Vn.8B + /// uint8x8_t vclz_u8 (uint8x8_t a) + /// A32: VCLZ.I8 Dd, Dm + /// A64: CLZ Vd.8B, Vn.8B /// public static Vector64 LeadingZeroCount(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vclz_s16 (int16x4_t a) - /// A32: VCLZ.I16 Dd, Dm - /// A64: CLZ Vd.4H, Vn.4H + /// int16x4_t vclz_s16 (int16x4_t a) + /// A32: VCLZ.I16 Dd, Dm + /// A64: CLZ Vd.4H, Vn.4H /// public static Vector64 LeadingZeroCount(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vclz_s32 (int32x2_t a) - /// A32: VCLZ.I32 Dd, Dm - /// A64: CLZ Vd.2S, Vn.2S + /// int32x2_t vclz_s32 (int32x2_t a) + /// A32: VCLZ.I32 Dd, Dm + /// A64: CLZ Vd.2S, Vn.2S /// public static Vector64 LeadingZeroCount(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vclz_s8 (int8x8_t a) - /// A32: VCLZ.I8 Dd, Dm - /// A64: CLZ Vd.8B, Vn.8B + /// int8x8_t vclz_s8 (int8x8_t a) + /// A32: VCLZ.I8 Dd, Dm + /// A64: CLZ Vd.8B, Vn.8B /// public static Vector64 LeadingZeroCount(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vclz_u16 (uint16x4_t a) - /// A32: VCLZ.I16 Dd, Dm - /// A64: CLZ Vd.4H, Vn.4H + /// uint16x4_t vclz_u16 (uint16x4_t a) + /// A32: VCLZ.I16 Dd, Dm + /// A64: CLZ Vd.4H, Vn.4H /// public static Vector64 LeadingZeroCount(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vclz_u32 (uint32x2_t a) - /// A32: VCLZ.I32 Dd, Dm - /// A64: CLZ Vd.2S, Vn.2S + /// uint32x2_t vclz_u32 (uint32x2_t a) + /// A32: VCLZ.I32 Dd, Dm + /// A64: CLZ Vd.2S, Vn.2S /// public static Vector64 LeadingZeroCount(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vclzq_u8 (uint8x16_t a) - /// A32: VCLZ.I8 Qd, Qm - /// A64: CLZ Vd.16B, Vn.16B + /// uint8x16_t vclzq_u8 (uint8x16_t a) + /// A32: VCLZ.I8 Qd, Qm + /// A64: CLZ Vd.16B, Vn.16B /// public static Vector128 LeadingZeroCount(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vclzq_s16 (int16x8_t a) - /// A32: VCLZ.I16 Qd, Qm - /// A64: CLZ Vd.8H, Vn.8H + /// int16x8_t vclzq_s16 (int16x8_t a) + /// A32: VCLZ.I16 Qd, Qm + /// A64: CLZ Vd.8H, Vn.8H /// public static Vector128 LeadingZeroCount(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vclzq_s32 (int32x4_t a) - /// A32: VCLZ.I32 Qd, Qm - /// A64: CLZ Vd.4S, Vn.4S + /// int32x4_t vclzq_s32 (int32x4_t a) + /// A32: VCLZ.I32 Qd, Qm + /// A64: CLZ Vd.4S, Vn.4S /// public static Vector128 LeadingZeroCount(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vclzq_s8 (int8x16_t a) - /// A32: VCLZ.I8 Qd, Qm - /// A64: CLZ Vd.16B, Vn.16B + /// int8x16_t vclzq_s8 (int8x16_t a) + /// A32: VCLZ.I8 Qd, Qm + /// A64: CLZ Vd.16B, Vn.16B /// public static Vector128 LeadingZeroCount(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vclzq_u16 (uint16x8_t a) - /// A32: VCLZ.I16 Qd, Qm - /// A64: CLZ Vd.8H, Vn.8H + /// uint16x8_t vclzq_u16 (uint16x8_t a) + /// A32: VCLZ.I16 Qd, Qm + /// A64: CLZ Vd.8H, Vn.8H /// public static Vector128 LeadingZeroCount(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vclzq_u32 (uint32x4_t a) - /// A32: VCLZ.I32 Qd, Qm - /// A64: CLZ Vd.4S, Vn.4S + /// uint32x4_t vclzq_u32 (uint32x4_t a) + /// A32: VCLZ.I32 Qd, Qm + /// A64: CLZ Vd.4S, Vn.4S /// public static Vector128 LeadingZeroCount(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vld1_lane_u8 (uint8_t const * ptr, uint8x8_t src, const int lane) - /// A32: VLD1.8 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.B }[index], [Xn] + /// uint8x8_t vld1_lane_u8 (uint8_t const * ptr, uint8x8_t src, const int lane) + /// A32: VLD1.8 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.B }[index], [Xn] /// public static unsafe Vector64 LoadAndInsertScalar(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte index, byte* address) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vld1_lane_s16 (int16_t const * ptr, int16x4_t src, const int lane) - /// A32: VLD1.16 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.H }[index], [Xn] + /// int16x4_t vld1_lane_s16 (int16_t const * ptr, int16x4_t src, const int lane) + /// A32: VLD1.16 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.H }[index], [Xn] /// public static unsafe Vector64 LoadAndInsertScalar(Vector64 value, [ConstantExpected(Max = (byte)(3))] byte index, short* address) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vld1_lane_s32 (int32_t const * ptr, int32x2_t src, const int lane) - /// A32: VLD1.32 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.S }[index], [Xn] + /// int32x2_t vld1_lane_s32 (int32_t const * ptr, int32x2_t src, const int lane) + /// A32: VLD1.32 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.S }[index], [Xn] /// public static unsafe Vector64 LoadAndInsertScalar(Vector64 value, [ConstantExpected(Max = (byte)(1))] byte index, int* address) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vld1_lane_s8 (int8_t const * ptr, int8x8_t src, const int lane) - /// A32: VLD1.8 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.B }[index], [Xn] + /// int8x8_t vld1_lane_s8 (int8_t const * ptr, int8x8_t src, const int lane) + /// A32: VLD1.8 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.B }[index], [Xn] /// public static unsafe Vector64 LoadAndInsertScalar(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte index, sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vld1_lane_f32 (float32_t const * ptr, float32x2_t src, const int lane) - /// A32: VLD1.32 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.S }[index], [Xn] + /// float32x2_t vld1_lane_f32 (float32_t const * ptr, float32x2_t src, const int lane) + /// A32: VLD1.32 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.S }[index], [Xn] /// public static unsafe Vector64 LoadAndInsertScalar(Vector64 value, [ConstantExpected(Max = (byte)(1))] byte index, float* address) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vld1_lane_u16 (uint16_t const * ptr, uint16x4_t src, const int lane) - /// A32: VLD1.16 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.H }[index], [Xn] + /// uint16x4_t vld1_lane_u16 (uint16_t const * ptr, uint16x4_t src, const int lane) + /// A32: VLD1.16 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.H }[index], [Xn] /// public static unsafe Vector64 LoadAndInsertScalar(Vector64 value, [ConstantExpected(Max = (byte)(3))] byte index, ushort* address) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vld1_lane_u32 (uint32_t const * ptr, uint32x2_t src, const int lane) - /// A32: VLD1.32 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.S }[index], [Xn] + /// uint32x2_t vld1_lane_u32 (uint32_t const * ptr, uint32x2_t src, const int lane) + /// A32: VLD1.32 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.S }[index], [Xn] /// public static unsafe Vector64 LoadAndInsertScalar(Vector64 value, [ConstantExpected(Max = (byte)(1))] byte index, uint* address) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vld1q_lane_u8 (uint8_t const * ptr, uint8x16_t src, const int lane) - /// A32: VLD1.8 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.B }[index], [Xn] + /// uint8x16_t vld1q_lane_u8 (uint8_t const * ptr, uint8x16_t src, const int lane) + /// A32: VLD1.8 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.B }[index], [Xn] /// public static unsafe Vector128 LoadAndInsertScalar(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte index, byte* address) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vld1q_lane_f64 (float64_t const * ptr, float64x2_t src, const int lane) - /// A32: VLDR.64 Dd, [Rn] - /// A64: LD1 { Vt.D }[index], [Xn] + /// float64x2_t vld1q_lane_f64 (float64_t const * ptr, float64x2_t src, const int lane) + /// A32: VLDR.64 Dd, [Rn] + /// A64: LD1 { Vt.D }[index], [Xn] /// public static unsafe Vector128 LoadAndInsertScalar(Vector128 value, [ConstantExpected(Max = (byte)(1))] byte index, double* address) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vld1q_lane_s16 (int16_t const * ptr, int16x8_t src, const int lane) - /// A32: VLD1.16 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.H }[index], [Xn] + /// int16x8_t vld1q_lane_s16 (int16_t const * ptr, int16x8_t src, const int lane) + /// A32: VLD1.16 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.H }[index], [Xn] /// public static unsafe Vector128 LoadAndInsertScalar(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte index, short* address) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vld1q_lane_s32 (int32_t const * ptr, int32x4_t src, const int lane) - /// A32: VLD1.32 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.S }[index], [Xn] + /// int32x4_t vld1q_lane_s32 (int32_t const * ptr, int32x4_t src, const int lane) + /// A32: VLD1.32 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.S }[index], [Xn] /// public static unsafe Vector128 LoadAndInsertScalar(Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index, int* address) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vld1q_lane_s64 (int64_t const * ptr, int64x2_t src, const int lane) - /// A32: VLDR.64 Dd, [Rn] - /// A64: LD1 { Vt.D }[index], [Xn] + /// int64x2_t vld1q_lane_s64 (int64_t const * ptr, int64x2_t src, const int lane) + /// A32: VLDR.64 Dd, [Rn] + /// A64: LD1 { Vt.D }[index], [Xn] /// public static unsafe Vector128 LoadAndInsertScalar(Vector128 value, [ConstantExpected(Max = (byte)(1))] byte index, long* address) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vld1q_lane_s8 (int8_t const * ptr, int8x16_t src, const int lane) - /// A32: VLD1.8 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.B }[index], [Xn] + /// int8x16_t vld1q_lane_s8 (int8_t const * ptr, int8x16_t src, const int lane) + /// A32: VLD1.8 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.B }[index], [Xn] /// public static unsafe Vector128 LoadAndInsertScalar(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte index, sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vld1q_lane_f32 (float32_t const * ptr, float32x4_t src, const int lane) - /// A32: VLD1.32 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.S }[index], [Xn] + /// float32x4_t vld1q_lane_f32 (float32_t const * ptr, float32x4_t src, const int lane) + /// A32: VLD1.32 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.S }[index], [Xn] /// public static unsafe Vector128 LoadAndInsertScalar(Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index, float* address) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vld1q_lane_u16 (uint16_t const * ptr, uint16x8_t src, const int lane) - /// A32: VLD1.16 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.H }[index], [Xn] + /// uint16x8_t vld1q_lane_u16 (uint16_t const * ptr, uint16x8_t src, const int lane) + /// A32: VLD1.16 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.H }[index], [Xn] /// public static unsafe Vector128 LoadAndInsertScalar(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte index, ushort* address) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vld1q_lane_u32 (uint32_t const * ptr, uint32x4_t src, const int lane) - /// A32: VLD1.32 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.S }[index], [Xn] + /// uint32x4_t vld1q_lane_u32 (uint32_t const * ptr, uint32x4_t src, const int lane) + /// A32: VLD1.32 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.S }[index], [Xn] /// public static unsafe Vector128 LoadAndInsertScalar(Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index, uint* address) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vld1q_lane_u64 (uint64_t const * ptr, uint64x2_t src, const int lane) - /// A32: VLDR.64 Dd, [Rn] - /// A64: LD1 { Vt.D }[index], [Xn] + /// uint64x2_t vld1q_lane_u64 (uint64_t const * ptr, uint64x2_t src, const int lane) + /// A32: VLDR.64 Dd, [Rn] + /// A64: LD1 { Vt.D }[index], [Xn] /// public static unsafe Vector128 LoadAndInsertScalar(Vector128 value, [ConstantExpected(Max = (byte)(1))] byte index, ulong* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.8B, Vn+1.8B }[Vm], [Xn] - /// + /// A64: LD2 { Vn.8B, Vn+1.8B }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndInsertScalar((Vector64, Vector64) values, [ConstantExpected(Max = (byte)(7))] byte index, byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.8B, Vn+1.8B }[Vm], [Xn] - /// + /// A64: LD2 { Vn.8B, Vn+1.8B }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndInsertScalar((Vector64, Vector64) values, [ConstantExpected(Max = (byte)(7))] byte index, sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.4H, Vn+1.4H }[Vm], [Xn] - /// + /// A64: LD2 { Vn.4H, Vn+1.4H }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndInsertScalar((Vector64, Vector64) values, [ConstantExpected(Max = (byte)(3))] byte index, short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.4H, Vn+1.4H }[Vm], [Xn] - /// + /// A64: LD2 { Vn.4H, Vn+1.4H }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndInsertScalar((Vector64, Vector64) values, [ConstantExpected(Max = (byte)(3))] byte index, ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.2S, Vn+1.2S }[Vm], [Xn] - /// + /// A64: LD2 { Vn.2S, Vn+1.2S }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndInsertScalar((Vector64, Vector64) values, [ConstantExpected(Max = (byte)(1))] byte index, int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.2S, Vn+1.2S }[Vm], [Xn] - /// + /// A64: LD2 { Vn.2S, Vn+1.2S }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndInsertScalar((Vector64, Vector64) values, [ConstantExpected(Max = (byte)(1))] byte index, uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.2S, Vn+1.2S }[Vm], [Xn] - /// + /// A64: LD2 { Vn.2S, Vn+1.2S }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndInsertScalar((Vector64, Vector64) values, [ConstantExpected(Max = (byte)(1))] byte index, float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.8B, Vn+1.8B, Vn+2.8B }[Vm], [Xn] - /// + /// A64: LD3 { Vn.8B, Vn+1.8B, Vn+2.8B }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndInsertScalar((Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(7))] byte index, byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.8B, Vn+1.8B, Vn+2.8B }[Vm], [Xn] - /// + /// A64: LD3 { Vn.8B, Vn+1.8B, Vn+2.8B }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndInsertScalar((Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(7))] byte index, sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.4H, Vn+1.4H, Vn+2.4H }[Vm], [Xn] - /// + /// A64: LD3 { Vn.4H, Vn+1.4H, Vn+2.4H }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndInsertScalar((Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(3))] byte index, short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.4H, Vn+1.4H, Vn+2.4H }[Vm], [Xn] - /// + /// A64: LD3 { Vn.4H, Vn+1.4H, Vn+2.4H }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndInsertScalar((Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(3))] byte index, ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }[Vm], [Xn] - /// + /// A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndInsertScalar((Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(1))] byte index, int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }[Vm], [Xn] - /// + /// A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndInsertScalar((Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(1))] byte index, uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }[Vm], [Xn] - /// + /// A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndInsertScalar((Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(1))] byte index, float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }[Vm], [Xn] - /// + /// A64: LD4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndInsertScalar((Vector64, Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(7))] byte index, byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }[Vm], [Xn] - /// + /// A64: LD4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndInsertScalar((Vector64, Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(7))] byte index, sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }[Vm], [Xn] - /// + /// A64: LD4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndInsertScalar((Vector64, Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(3))] byte index, short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }[Vm], [Xn] - /// + /// A64: LD4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndInsertScalar((Vector64, Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(3))] byte index, ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }[Vm], [Xn] - /// + /// A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndInsertScalar((Vector64, Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(1))] byte index, int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }[Vm], [Xn] - /// + /// A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndInsertScalar((Vector64, Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(1))] byte index, uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }[Vm], [Xn] - /// + /// A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndInsertScalar((Vector64, Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(1))] byte index, float* address) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vld1_dup_u8 (uint8_t const * ptr) - /// A32: VLD1.8 { Dd[] }, [Rn] - /// A64: LD1R { Vt.8B }, [Xn] + /// uint8x8_t vld1_dup_u8 (uint8_t const * ptr) + /// A32: VLD1.8 { Dd[] }, [Rn] + /// A64: LD1R { Vt.8B }, [Xn] /// public static unsafe Vector64 LoadAndReplicateToVector64(byte* address) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vld1_dup_s16 (int16_t const * ptr) - /// A32: VLD1.16 { Dd[] }, [Rn] - /// A64: LD1R { Vt.4H }, [Xn] + /// int16x4_t vld1_dup_s16 (int16_t const * ptr) + /// A32: VLD1.16 { Dd[] }, [Rn] + /// A64: LD1R { Vt.4H }, [Xn] /// public static unsafe Vector64 LoadAndReplicateToVector64(short* address) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vld1_dup_s32 (int32_t const * ptr) - /// A32: VLD1.32 { Dd[] }, [Rn] - /// A64: LD1R { Vt.2S }, [Xn] + /// int32x2_t vld1_dup_s32 (int32_t const * ptr) + /// A32: VLD1.32 { Dd[] }, [Rn] + /// A64: LD1R { Vt.2S }, [Xn] /// public static unsafe Vector64 LoadAndReplicateToVector64(int* address) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vld1_dup_s8 (int8_t const * ptr) - /// A32: VLD1.8 { Dd[] }, [Rn] - /// A64: LD1R { Vt.8B }, [Xn] + /// int8x8_t vld1_dup_s8 (int8_t const * ptr) + /// A32: VLD1.8 { Dd[] }, [Rn] + /// A64: LD1R { Vt.8B }, [Xn] /// public static unsafe Vector64 LoadAndReplicateToVector64(sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vld1_dup_f32 (float32_t const * ptr) - /// A32: VLD1.32 { Dd[] }, [Rn] - /// A64: LD1R { Vt.2S }, [Xn] + /// float32x2_t vld1_dup_f32 (float32_t const * ptr) + /// A32: VLD1.32 { Dd[] }, [Rn] + /// A64: LD1R { Vt.2S }, [Xn] /// public static unsafe Vector64 LoadAndReplicateToVector64(float* address) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vld1_dup_u16 (uint16_t const * ptr) - /// A32: VLD1.16 { Dd[] }, [Rn] - /// A64: LD1R { Vt.4H }, [Xn] + /// uint16x4_t vld1_dup_u16 (uint16_t const * ptr) + /// A32: VLD1.16 { Dd[] }, [Rn] + /// A64: LD1R { Vt.4H }, [Xn] /// public static unsafe Vector64 LoadAndReplicateToVector64(ushort* address) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vld1_dup_u32 (uint32_t const * ptr) - /// A32: VLD1.32 { Dd[] }, [Rn] - /// A64: LD1R { Vt.2S }, [Xn] + /// uint32x2_t vld1_dup_u32 (uint32_t const * ptr) + /// A32: VLD1.32 { Dd[] }, [Rn] + /// A64: LD1R { Vt.2S }, [Xn] /// public static unsafe Vector64 LoadAndReplicateToVector64(uint* address) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vld1q_dup_u8 (uint8_t const * ptr) - /// A32: VLD1.8 { Dd[], Dd+1[] }, [Rn] - /// A64: LD1R { Vt.16B }, [Xn] + /// uint8x16_t vld1q_dup_u8 (uint8_t const * ptr) + /// A32: VLD1.8 { Dd[], Dd+1[] }, [Rn] + /// A64: LD1R { Vt.16B }, [Xn] /// public static unsafe Vector128 LoadAndReplicateToVector128(byte* address) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vld1q_dup_s16 (int16_t const * ptr) - /// A32: VLD1.16 { Dd[], Dd+1[] }, [Rn] - /// A64: LD1R { Vt.8H }, [Xn] + /// int16x8_t vld1q_dup_s16 (int16_t const * ptr) + /// A32: VLD1.16 { Dd[], Dd+1[] }, [Rn] + /// A64: LD1R { Vt.8H }, [Xn] /// public static unsafe Vector128 LoadAndReplicateToVector128(short* address) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vld1q_dup_s32 (int32_t const * ptr) - /// A32: VLD1.32 { Dd[], Dd+1[] }, [Rn] - /// A64: LD1R { Vt.4S }, [Xn] + /// int32x4_t vld1q_dup_s32 (int32_t const * ptr) + /// A32: VLD1.32 { Dd[], Dd+1[] }, [Rn] + /// A64: LD1R { Vt.4S }, [Xn] /// public static unsafe Vector128 LoadAndReplicateToVector128(int* address) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vld1q_dup_s8 (int8_t const * ptr) - /// A32: VLD1.8 { Dd[], Dd+1[] }, [Rn] - /// A64: LD1R { Vt.16B }, [Xn] + /// int8x16_t vld1q_dup_s8 (int8_t const * ptr) + /// A32: VLD1.8 { Dd[], Dd+1[] }, [Rn] + /// A64: LD1R { Vt.16B }, [Xn] /// public static unsafe Vector128 LoadAndReplicateToVector128(sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vld1q_dup_f32 (float32_t const * ptr) - /// A32: VLD1.32 { Dd[], Dd+1[] }, [Rn] - /// A64: LD1R { Vt.4S }, [Xn] + /// float32x4_t vld1q_dup_f32 (float32_t const * ptr) + /// A32: VLD1.32 { Dd[], Dd+1[] }, [Rn] + /// A64: LD1R { Vt.4S }, [Xn] /// public static unsafe Vector128 LoadAndReplicateToVector128(float* address) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vld1q_dup_u16 (uint16_t const * ptr) - /// A32: VLD1.16 { Dd[], Dd+1[] }, [Rn] - /// A64: LD1R { Vt.8H }, [Xn] + /// uint16x8_t vld1q_dup_u16 (uint16_t const * ptr) + /// A32: VLD1.16 { Dd[], Dd+1[] }, [Rn] + /// A64: LD1R { Vt.8H }, [Xn] /// public static unsafe Vector128 LoadAndReplicateToVector128(ushort* address) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vld1q_dup_u32 (uint32_t const * ptr) - /// A32: VLD1.32 { Dd[], Dd+1[] }, [Rn] - /// A64: LD1R { Vt.4S }, [Xn] + /// uint32x4_t vld1q_dup_u32 (uint32_t const * ptr) + /// A32: VLD1.32 { Dd[], Dd+1[] }, [Rn] + /// A64: LD1R { Vt.4S }, [Xn] /// public static unsafe Vector128 LoadAndReplicateToVector128(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2R { Vn.8B, Vn+1.8B }, [Xn] - /// + /// A64: LD2R { Vn.8B, Vn+1.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndReplicateToVector64x2(byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2R { Vn.8B, Vn+1.8B }, [Xn] - /// + /// A64: LD2R { Vn.8B, Vn+1.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndReplicateToVector64x2(sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2R { Vn.4H, Vn+1.4H }, [Xn] - /// + /// A64: LD2R { Vn.4H, Vn+1.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndReplicateToVector64x2(short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2R { Vn.4H, Vn+1.4H }, [Xn] - /// + /// A64: LD2R { Vn.4H, Vn+1.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndReplicateToVector64x2(ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2R { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: LD2R { Vn.2S, Vn+1.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndReplicateToVector64x2(int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2R { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: LD2R { Vn.2S, Vn+1.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndReplicateToVector64x2(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2R { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: LD2R { Vn.2S, Vn+1.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndReplicateToVector64x2(float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3R { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] - /// + /// A64: LD3R { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndReplicateToVector64x3(byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3R { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] - /// + /// A64: LD3R { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndReplicateToVector64x3(sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3R { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] - /// + /// A64: LD3R { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndReplicateToVector64x3(short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3R { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] - /// + /// A64: LD3R { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndReplicateToVector64x3(ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3R { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: LD3R { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndReplicateToVector64x3(int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3R { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: LD3R { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndReplicateToVector64x3(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3R { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: LD3R { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndReplicateToVector64x3(float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4R { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] - /// + /// A64: LD4R { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndReplicateToVector64x4(byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4R { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] - /// + /// A64: LD4R { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndReplicateToVector64x4(sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4R { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] - /// + /// A64: LD4R { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndReplicateToVector64x4(short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4R { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] - /// + /// A64: LD4R { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndReplicateToVector64x4(ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4R { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: LD4R { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndReplicateToVector64x4(int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4R { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: LD4R { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndReplicateToVector64x4(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4R { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: LD4R { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndReplicateToVector64x4(float* address) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vld1_u8 (uint8_t const * ptr) - /// A32: VLD1.8 Dd, [Rn] - /// A64: LD1 Vt.8B, [Xn] + /// uint8x8_t vld1_u8 (uint8_t const * ptr) + /// A32: VLD1.8 Dd, [Rn] + /// A64: LD1 Vt.8B, [Xn] /// public static unsafe Vector64 LoadVector64(byte* address) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vld1_f64 (float64_t const * ptr) - /// A32: VLD1.64 Dd, [Rn] - /// A64: LD1 Vt.1D, [Xn] + /// float64x1_t vld1_f64 (float64_t const * ptr) + /// A32: VLD1.64 Dd, [Rn] + /// A64: LD1 Vt.1D, [Xn] /// public static unsafe Vector64 LoadVector64(double* address) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vld1_s16 (int16_t const * ptr) - /// A32: VLD1.16 Dd, [Rn] - /// A64: LD1 Vt.4H, [Xn] + /// int16x4_t vld1_s16 (int16_t const * ptr) + /// A32: VLD1.16 Dd, [Rn] + /// A64: LD1 Vt.4H, [Xn] /// public static unsafe Vector64 LoadVector64(short* address) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vld1_s32 (int32_t const * ptr) - /// A32: VLD1.32 Dd, [Rn] - /// A64: LD1 Vt.2S, [Xn] + /// int32x2_t vld1_s32 (int32_t const * ptr) + /// A32: VLD1.32 Dd, [Rn] + /// A64: LD1 Vt.2S, [Xn] /// public static unsafe Vector64 LoadVector64(int* address) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vld1_s64 (int64_t const * ptr) - /// A32: VLD1.64 Dd, [Rn] - /// A64: LD1 Vt.1D, [Xn] + /// int64x1_t vld1_s64 (int64_t const * ptr) + /// A32: VLD1.64 Dd, [Rn] + /// A64: LD1 Vt.1D, [Xn] /// public static unsafe Vector64 LoadVector64(long* address) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vld1_s8 (int8_t const * ptr) - /// A32: VLD1.8 Dd, [Rn] - /// A64: LD1 Vt.8B, [Xn] + /// int8x8_t vld1_s8 (int8_t const * ptr) + /// A32: VLD1.8 Dd, [Rn] + /// A64: LD1 Vt.8B, [Xn] /// public static unsafe Vector64 LoadVector64(sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vld1_f32 (float32_t const * ptr) - /// A32: VLD1.32 Dd, [Rn] - /// A64: LD1 Vt.2S, [Xn] + /// float32x2_t vld1_f32 (float32_t const * ptr) + /// A32: VLD1.32 Dd, [Rn] + /// A64: LD1 Vt.2S, [Xn] /// public static unsafe Vector64 LoadVector64(float* address) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vld1_u16 (uint16_t const * ptr) - /// A32: VLD1.16 Dd, [Rn] - /// A64: LD1 Vt.4H, [Xn] + /// uint16x4_t vld1_u16 (uint16_t const * ptr) + /// A32: VLD1.16 Dd, [Rn] + /// A64: LD1 Vt.4H, [Xn] /// public static unsafe Vector64 LoadVector64(ushort* address) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vld1_u32 (uint32_t const * ptr) - /// A32: VLD1.32 Dd, [Rn] - /// A64: LD1 Vt.2S, [Xn] + /// uint32x2_t vld1_u32 (uint32_t const * ptr) + /// A32: VLD1.32 Dd, [Rn] + /// A64: LD1 Vt.2S, [Xn] /// public static unsafe Vector64 LoadVector64(uint* address) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vld1_u64 (uint64_t const * ptr) - /// A32: VLD1.64 Dd, [Rn] - /// A64: LD1 Vt.1D, [Xn] + /// uint64x1_t vld1_u64 (uint64_t const * ptr) + /// A32: VLD1.64 Dd, [Rn] + /// A64: LD1 Vt.1D, [Xn] /// public static unsafe Vector64 LoadVector64(ulong* address) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vld1q_u8 (uint8_t const * ptr) - /// A32: VLD1.8 Dd, Dd+1, [Rn] - /// A64: LD1 Vt.16B, [Xn] + /// uint8x16_t vld1q_u8 (uint8_t const * ptr) + /// A32: VLD1.8 Dd, Dd+1, [Rn] + /// A64: LD1 Vt.16B, [Xn] /// public static unsafe Vector128 LoadVector128(byte* address) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vld1q_f64 (float64_t const * ptr) - /// A32: VLD1.64 Dd, Dd+1, [Rn] - /// A64: LD1 Vt.2D, [Xn] + /// float64x2_t vld1q_f64 (float64_t const * ptr) + /// A32: VLD1.64 Dd, Dd+1, [Rn] + /// A64: LD1 Vt.2D, [Xn] /// public static unsafe Vector128 LoadVector128(double* address) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vld1q_s16 (int16_t const * ptr) - /// A32: VLD1.16 Dd, Dd+1, [Rn] - /// A64: LD1 Vt.8H, [Xn] + /// int16x8_t vld1q_s16 (int16_t const * ptr) + /// A32: VLD1.16 Dd, Dd+1, [Rn] + /// A64: LD1 Vt.8H, [Xn] /// public static unsafe Vector128 LoadVector128(short* address) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vld1q_s32 (int32_t const * ptr) - /// A32: VLD1.32 Dd, Dd+1, [Rn] - /// A64: LD1 Vt.4S, [Xn] + /// int32x4_t vld1q_s32 (int32_t const * ptr) + /// A32: VLD1.32 Dd, Dd+1, [Rn] + /// A64: LD1 Vt.4S, [Xn] /// public static unsafe Vector128 LoadVector128(int* address) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vld1q_s64 (int64_t const * ptr) - /// A32: VLD1.64 Dd, Dd+1, [Rn] - /// A64: LD1 Vt.2D, [Xn] + /// int64x2_t vld1q_s64 (int64_t const * ptr) + /// A32: VLD1.64 Dd, Dd+1, [Rn] + /// A64: LD1 Vt.2D, [Xn] /// public static unsafe Vector128 LoadVector128(long* address) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vld1q_s8 (int8_t const * ptr) - /// A32: VLD1.8 Dd, Dd+1, [Rn] - /// A64: LD1 Vt.16B, [Xn] + /// int8x16_t vld1q_s8 (int8_t const * ptr) + /// A32: VLD1.8 Dd, Dd+1, [Rn] + /// A64: LD1 Vt.16B, [Xn] /// public static unsafe Vector128 LoadVector128(sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vld1q_f32 (float32_t const * ptr) - /// A32: VLD1.32 Dd, Dd+1, [Rn] - /// A64: LD1 Vt.4S, [Xn] + /// float32x4_t vld1q_f32 (float32_t const * ptr) + /// A32: VLD1.32 Dd, Dd+1, [Rn] + /// A64: LD1 Vt.4S, [Xn] /// public static unsafe Vector128 LoadVector128(float* address) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vld1q_s16 (uint16_t const * ptr) - /// A32: VLD1.16 Dd, Dd+1, [Rn] - /// A64: LD1 Vt.8H, [Xn] + /// uint16x8_t vld1q_s16 (uint16_t const * ptr) + /// A32: VLD1.16 Dd, Dd+1, [Rn] + /// A64: LD1 Vt.8H, [Xn] /// public static unsafe Vector128 LoadVector128(ushort* address) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vld1q_s32 (uint32_t const * ptr) - /// A32: VLD1.32 Dd, Dd+1, [Rn] - /// A64: LD1 Vt.4S, [Xn] + /// uint32x4_t vld1q_s32 (uint32_t const * ptr) + /// A32: VLD1.32 Dd, Dd+1, [Rn] + /// A64: LD1 Vt.4S, [Xn] /// public static unsafe Vector128 LoadVector128(uint* address) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vld1q_u64 (uint64_t const * ptr) - /// A32: VLD1.64 Dd, Dd+1, [Rn] - /// A64: LD1 Vt.2D, [Xn] + /// uint64x2_t vld1q_u64 (uint64_t const * ptr) + /// A32: VLD1.64 Dd, Dd+1, [Rn] + /// A64: LD1 Vt.2D, [Xn] /// public static unsafe Vector128 LoadVector128(ulong* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.8B, Vn+1.8B }, [Xn] - /// + /// A64: LD2 { Vn.8B, Vn+1.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64AndUnzip(byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.8B, Vn+1.8B }, [Xn] - /// + /// A64: LD2 { Vn.8B, Vn+1.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64AndUnzip(sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.4H, Vn+1.4H }, [Xn] - /// + /// A64: LD2 { Vn.4H, Vn+1.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64AndUnzip(short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.4H, Vn+1.4H }, [Xn] - /// + /// A64: LD2 { Vn.4H, Vn+1.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64AndUnzip(ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: LD2 { Vn.2S, Vn+1.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64AndUnzip(int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: LD2 { Vn.2S, Vn+1.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64AndUnzip(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD2 { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: LD2 { Vn.2S, Vn+1.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64AndUnzip(float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] - /// + /// A64: LD3 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64AndUnzip(byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] - /// + /// A64: LD3 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64AndUnzip(sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] - /// + /// A64: LD3 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64AndUnzip(short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] - /// + /// A64: LD3 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64AndUnzip(ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64AndUnzip(int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64AndUnzip(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64AndUnzip(float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] - /// + /// A64: LD4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64AndUnzip(byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] - /// + /// A64: LD4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64AndUnzip(sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] - /// + /// A64: LD4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64AndUnzip(short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] - /// + /// A64: LD4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64AndUnzip(ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64AndUnzip(int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64AndUnzip(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.2S }, [Xn] - /// + /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64AndUnzip(float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.8B, Vn+1.8B }, [Xn] - /// + /// A64: LD1 { Vn.8B, Vn+1.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64(byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.8B, Vn+1.8B }, [Xn] - /// + /// A64: LD1 { Vn.8B, Vn+1.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64(sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.4H, Vn+1.4H }, [Xn] - /// + /// A64: LD1 { Vn.4H, Vn+1.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64(short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.4H, Vn+1.4H }, [Xn] - /// + /// A64: LD1 { Vn.4H, Vn+1.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64(ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: LD1 { Vn.2S, Vn+1.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64(int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: LD1 { Vn.2S, Vn+1.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: LD1 { Vn.2S, Vn+1.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64(float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] - /// + /// A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64(byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] - /// + /// A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64(sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] - /// + /// A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64(short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] - /// + /// A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64(ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64(int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64(float* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] - /// + /// A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64(byte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] - /// + /// A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64(sbyte* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] - /// + /// A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64(short* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] - /// + /// A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64(ushort* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64(int* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64(uint* address) { throw new PlatformNotSupportedException(); } - /// - /// A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64(float* address) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vmax_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VMAX.U8 Dd, Dn, Dm - /// A64: UMAX Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vmax_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VMAX.U8 Dd, Dn, Dm + /// A64: UMAX Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Max(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vmax_s16 (int16x4_t a, int16x4_t b) - /// A32: VMAX.S16 Dd, Dn, Dm - /// A64: SMAX Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vmax_s16 (int16x4_t a, int16x4_t b) + /// A32: VMAX.S16 Dd, Dn, Dm + /// A64: SMAX Vd.4H, Vn.4H, Vm.4H /// public static Vector64 Max(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vmax_s32 (int32x2_t a, int32x2_t b) - /// A32: VMAX.S32 Dd, Dn, Dm - /// A64: SMAX Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vmax_s32 (int32x2_t a, int32x2_t b) + /// A32: VMAX.S32 Dd, Dn, Dm + /// A64: SMAX Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Max(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vmax_s8 (int8x8_t a, int8x8_t b) - /// A32: VMAX.S8 Dd, Dn, Dm - /// A64: SMAX Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vmax_s8 (int8x8_t a, int8x8_t b) + /// A32: VMAX.S8 Dd, Dn, Dm + /// A64: SMAX Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Max(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vmax_f32 (float32x2_t a, float32x2_t b) - /// A32: VMAX.F32 Dd, Dn, Dm - /// A64: FMAX Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vmax_f32 (float32x2_t a, float32x2_t b) + /// A32: VMAX.F32 Dd, Dn, Dm + /// A64: FMAX Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Max(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vmax_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VMAX.U16 Dd, Dn, Dm - /// A64: UMAX Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vmax_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VMAX.U16 Dd, Dn, Dm + /// A64: UMAX Vd.4H, Vn.4H, Vm.4H /// public static Vector64 Max(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vmax_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VMAX.U32 Dd, Dn, Dm - /// A64: UMAX Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vmax_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VMAX.U32 Dd, Dn, Dm + /// A64: UMAX Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Max(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vmaxq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VMAX.U8 Qd, Qn, Qm - /// A64: UMAX Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vmaxq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VMAX.U8 Qd, Qn, Qm + /// A64: UMAX Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vmaxq_s16 (int16x8_t a, int16x8_t b) - /// A32: VMAX.S16 Qd, Qn, Qm - /// A64: SMAX Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vmaxq_s16 (int16x8_t a, int16x8_t b) + /// A32: VMAX.S16 Qd, Qn, Qm + /// A64: SMAX Vd.8H, Vn.8H, Vm.8H /// public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmaxq_s32 (int32x4_t a, int32x4_t b) - /// A32: VMAX.S32 Qd, Qn, Qm - /// A64: SMAX Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vmaxq_s32 (int32x4_t a, int32x4_t b) + /// A32: VMAX.S32 Qd, Qn, Qm + /// A64: SMAX Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vmaxq_s8 (int8x16_t a, int8x16_t b) - /// A32: VMAX.S8 Qd, Qn, Qm - /// A64: SMAX Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vmaxq_s8 (int8x16_t a, int8x16_t b) + /// A32: VMAX.S8 Qd, Qn, Qm + /// A64: SMAX Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vmaxq_f32 (float32x4_t a, float32x4_t b) - /// A32: VMAX.F32 Qd, Qn, Qm - /// A64: FMAX Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vmaxq_f32 (float32x4_t a, float32x4_t b) + /// A32: VMAX.F32 Qd, Qn, Qm + /// A64: FMAX Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmaxq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VMAX.U16 Qd, Qn, Qm - /// A64: UMAX Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vmaxq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VMAX.U16 Qd, Qn, Qm + /// A64: UMAX Vd.8H, Vn.8H, Vm.8H /// public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmaxq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VMAX.U32 Qd, Qn, Qm - /// A64: UMAX Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vmaxq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VMAX.U32 Qd, Qn, Qm + /// A64: UMAX Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vmaxnm_f32 (float32x2_t a, float32x2_t b) - /// A32: VMAXNM.F32 Dd, Dn, Dm - /// A64: FMAXNM Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vmaxnm_f32 (float32x2_t a, float32x2_t b) + /// A32: VMAXNM.F32 Dd, Dn, Dm + /// A64: FMAXNM Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MaxNumber(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vmaxnmq_f32 (float32x4_t a, float32x4_t b) - /// A32: VMAXNM.F32 Qd, Qn, Qm - /// A64: FMAXNM Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vmaxnmq_f32 (float32x4_t a, float32x4_t b) + /// A32: VMAXNM.F32 Qd, Qn, Qm + /// A64: FMAXNM Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MaxNumber(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vmaxnm_f64 (float64x1_t a, float64x1_t b) - /// A32: VMAXNM.F64 Dd, Dn, Dm - /// A64: FMAXNM Dd, Dn, Dm + /// float64x1_t vmaxnm_f64 (float64x1_t a, float64x1_t b) + /// A32: VMAXNM.F64 Dd, Dn, Dm + /// A64: FMAXNM Dd, Dn, Dm /// public static Vector64 MaxNumberScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32_t vmaxnms_f32 (float32_t a, float32_t b) - /// A32: VMAXNM.F32 Sd, Sn, Sm - /// A64: FMAXNM Sd, Sn, Sm + /// float32_t vmaxnms_f32 (float32_t a, float32_t b) + /// A32: VMAXNM.F32 Sd, Sn, Sm + /// A64: FMAXNM Sd, Sn, Sm /// public static Vector64 MaxNumberScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vpmax_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VPMAX.U8 Dd, Dn, Dm - /// A64: UMAXP Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vpmax_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VPMAX.U8 Dd, Dn, Dm + /// A64: UMAXP Vd.8B, Vn.8B, Vm.8B /// public static Vector64 MaxPairwise(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vpmax_s16 (int16x4_t a, int16x4_t b) - /// A32: VPMAX.S16 Dd, Dn, Dm - /// A64: SMAXP Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vpmax_s16 (int16x4_t a, int16x4_t b) + /// A32: VPMAX.S16 Dd, Dn, Dm + /// A64: SMAXP Vd.4H, Vn.4H, Vm.4H /// public static Vector64 MaxPairwise(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vpmax_s32 (int32x2_t a, int32x2_t b) - /// A32: VPMAX.S32 Dd, Dn, Dm - /// A64: SMAXP Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vpmax_s32 (int32x2_t a, int32x2_t b) + /// A32: VPMAX.S32 Dd, Dn, Dm + /// A64: SMAXP Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MaxPairwise(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vpmax_s8 (int8x8_t a, int8x8_t b) - /// A32: VPMAX.S8 Dd, Dn, Dm - /// A64: SMAXP Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vpmax_s8 (int8x8_t a, int8x8_t b) + /// A32: VPMAX.S8 Dd, Dn, Dm + /// A64: SMAXP Vd.8B, Vn.8B, Vm.8B /// public static Vector64 MaxPairwise(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vpmax_f32 (float32x2_t a, float32x2_t b) - /// A32: VPMAX.F32 Dd, Dn, Dm - /// A64: FMAXP Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vpmax_f32 (float32x2_t a, float32x2_t b) + /// A32: VPMAX.F32 Dd, Dn, Dm + /// A64: FMAXP Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MaxPairwise(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vpmax_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VPMAX.U16 Dd, Dn, Dm - /// A64: UMAXP Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vpmax_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VPMAX.U16 Dd, Dn, Dm + /// A64: UMAXP Vd.4H, Vn.4H, Vm.4H /// public static Vector64 MaxPairwise(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vpmax_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VPMAX.U32 Dd, Dn, Dm - /// A64: UMAXP Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vpmax_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VPMAX.U32 Dd, Dn, Dm + /// A64: UMAXP Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MaxPairwise(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vmin_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VMIN.U8 Dd, Dn, Dm - /// A64: UMIN Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vmin_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VMIN.U8 Dd, Dn, Dm + /// A64: UMIN Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Min(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vmin_s16 (int16x4_t a, int16x4_t b) - /// A32: VMIN.S16 Dd, Dn, Dm - /// A64: SMIN Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vmin_s16 (int16x4_t a, int16x4_t b) + /// A32: VMIN.S16 Dd, Dn, Dm + /// A64: SMIN Vd.4H, Vn.4H, Vm.4H /// public static Vector64 Min(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vmin_s32 (int32x2_t a, int32x2_t b) - /// A32: VMIN.S32 Dd, Dn, Dm - /// A64: SMIN Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vmin_s32 (int32x2_t a, int32x2_t b) + /// A32: VMIN.S32 Dd, Dn, Dm + /// A64: SMIN Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Min(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vmin_s8 (int8x8_t a, int8x8_t b) - /// A32: VMIN.S8 Dd, Dn, Dm - /// A64: SMIN Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vmin_s8 (int8x8_t a, int8x8_t b) + /// A32: VMIN.S8 Dd, Dn, Dm + /// A64: SMIN Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Min(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vmin_f32 (float32x2_t a, float32x2_t b) - /// A32: VMIN.F32 Dd, Dn, Dm - /// A64: FMIN Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vmin_f32 (float32x2_t a, float32x2_t b) + /// A32: VMIN.F32 Dd, Dn, Dm + /// A64: FMIN Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Min(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vmin_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VMIN.U16 Dd, Dn, Dm - /// A64: UMIN Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vmin_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VMIN.U16 Dd, Dn, Dm + /// A64: UMIN Vd.4H, Vn.4H, Vm.4H /// public static Vector64 Min(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vmin_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VMIN.U32 Dd, Dn, Dm - /// A64: UMIN Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vmin_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VMIN.U32 Dd, Dn, Dm + /// A64: UMIN Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Min(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vminq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VMIN.U8 Qd, Qn, Qm - /// A64: UMIN Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vminq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VMIN.U8 Qd, Qn, Qm + /// A64: UMIN Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vminq_s16 (int16x8_t a, int16x8_t b) - /// A32: VMIN.S16 Qd, Qn, Qm - /// A64: SMIN Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vminq_s16 (int16x8_t a, int16x8_t b) + /// A32: VMIN.S16 Qd, Qn, Qm + /// A64: SMIN Vd.8H, Vn.8H, Vm.8H /// public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vminq_s32 (int32x4_t a, int32x4_t b) - /// A32: VMIN.S32 Qd, Qn, Qm - /// A64: SMIN Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vminq_s32 (int32x4_t a, int32x4_t b) + /// A32: VMIN.S32 Qd, Qn, Qm + /// A64: SMIN Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vminq_s8 (int8x16_t a, int8x16_t b) - /// A32: VMIN.S8 Qd, Qn, Qm - /// A64: SMIN Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vminq_s8 (int8x16_t a, int8x16_t b) + /// A32: VMIN.S8 Qd, Qn, Qm + /// A64: SMIN Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vminq_f32 (float32x4_t a, float32x4_t b) - /// A32: VMIN.F32 Qd, Qn, Qm - /// A64: FMIN Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vminq_f32 (float32x4_t a, float32x4_t b) + /// A32: VMIN.F32 Qd, Qn, Qm + /// A64: FMIN Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vminq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VMIN.U16 Qd, Qn, Qm - /// A64: UMIN Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vminq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VMIN.U16 Qd, Qn, Qm + /// A64: UMIN Vd.8H, Vn.8H, Vm.8H /// public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vminq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VMIN.U32 Qd, Qn, Qm - /// A64: UMIN Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vminq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VMIN.U32 Qd, Qn, Qm + /// A64: UMIN Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vminnm_f32 (float32x2_t a, float32x2_t b) - /// A32: VMINNM.F32 Dd, Dn, Dm - /// A64: FMINNM Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vminnm_f32 (float32x2_t a, float32x2_t b) + /// A32: VMINNM.F32 Dd, Dn, Dm + /// A64: FMINNM Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MinNumber(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vminnmq_f32 (float32x4_t a, float32x4_t b) - /// A32: VMINNM.F32 Qd, Qn, Qm - /// A64: FMINNM Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vminnmq_f32 (float32x4_t a, float32x4_t b) + /// A32: VMINNM.F32 Qd, Qn, Qm + /// A64: FMINNM Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MinNumber(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vminnm_f64 (float64x1_t a, float64x1_t b) - /// A32: VMINNM.F64 Dd, Dn, Dm - /// A64: FMINNM Dd, Dn, Dm + /// float64x1_t vminnm_f64 (float64x1_t a, float64x1_t b) + /// A32: VMINNM.F64 Dd, Dn, Dm + /// A64: FMINNM Dd, Dn, Dm /// public static Vector64 MinNumberScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32_t vminnms_f32 (float32_t a, float32_t b) - /// A32: VMINNM.F32 Sd, Sn, Sm - /// A64: FMINNM Sd, Sn, Sm + /// float32_t vminnms_f32 (float32_t a, float32_t b) + /// A32: VMINNM.F32 Sd, Sn, Sm + /// A64: FMINNM Sd, Sn, Sm /// public static Vector64 MinNumberScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vpmin_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VPMIN.U8 Dd, Dn, Dm - /// A64: UMINP Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vpmin_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VPMIN.U8 Dd, Dn, Dm + /// A64: UMINP Vd.8B, Vn.8B, Vm.8B /// public static Vector64 MinPairwise(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vpmin_s16 (int16x4_t a, int16x4_t b) - /// A32: VPMIN.S16 Dd, Dn, Dm - /// A64: SMINP Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vpmin_s16 (int16x4_t a, int16x4_t b) + /// A32: VPMIN.S16 Dd, Dn, Dm + /// A64: SMINP Vd.4H, Vn.4H, Vm.4H /// public static Vector64 MinPairwise(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vpmin_s32 (int32x2_t a, int32x2_t b) - /// A32: VPMIN.S32 Dd, Dn, Dm - /// A64: SMINP Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vpmin_s32 (int32x2_t a, int32x2_t b) + /// A32: VPMIN.S32 Dd, Dn, Dm + /// A64: SMINP Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MinPairwise(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vpmin_s8 (int8x8_t a, int8x8_t b) - /// A32: VPMIN.S8 Dd, Dn, Dm - /// A64: SMINP Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vpmin_s8 (int8x8_t a, int8x8_t b) + /// A32: VPMIN.S8 Dd, Dn, Dm + /// A64: SMINP Vd.8B, Vn.8B, Vm.8B /// public static Vector64 MinPairwise(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vpmin_f32 (float32x2_t a, float32x2_t b) - /// A32: VPMIN.F32 Dd, Dn, Dm - /// A64: FMINP Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vpmin_f32 (float32x2_t a, float32x2_t b) + /// A32: VPMIN.F32 Dd, Dn, Dm + /// A64: FMINP Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MinPairwise(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vpmin_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VPMIN.U16 Dd, Dn, Dm - /// A64: UMINP Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vpmin_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VPMIN.U16 Dd, Dn, Dm + /// A64: UMINP Vd.4H, Vn.4H, Vm.4H /// public static Vector64 MinPairwise(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vpmin_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VPMIN.U32 Dd, Dn, Dm - /// A64: UMINP Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vpmin_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VPMIN.U32 Dd, Dn, Dm + /// A64: UMINP Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MinPairwise(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vmul_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VMUL.I8 Dd, Dn, Dm - /// A64: MUL Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vmul_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VMUL.I8 Dd, Dn, Dm + /// A64: MUL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Multiply(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vmul_s16 (int16x4_t a, int16x4_t b) - /// A32: VMUL.I16 Dd, Dn, Dm - /// A64: MUL Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vmul_s16 (int16x4_t a, int16x4_t b) + /// A32: VMUL.I16 Dd, Dn, Dm + /// A64: MUL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 Multiply(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vmul_s32 (int32x2_t a, int32x2_t b) - /// A32: VMUL.I32 Dd, Dn, Dm - /// A64: MUL Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vmul_s32 (int32x2_t a, int32x2_t b) + /// A32: VMUL.I32 Dd, Dn, Dm + /// A64: MUL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Multiply(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vmul_s8 (int8x8_t a, int8x8_t b) - /// A32: VMUL.I8 Dd, Dn, Dm - /// A64: MUL Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vmul_s8 (int8x8_t a, int8x8_t b) + /// A32: VMUL.I8 Dd, Dn, Dm + /// A64: MUL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Multiply(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vmul_f32 (float32x2_t a, float32x2_t b) - /// A32: VMUL.F32 Dd, Dn, Dm - /// A64: FMUL Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vmul_f32 (float32x2_t a, float32x2_t b) + /// A32: VMUL.F32 Dd, Dn, Dm + /// A64: FMUL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Multiply(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vmul_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VMUL.I16 Dd, Dn, Dm - /// A64: MUL Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vmul_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VMUL.I16 Dd, Dn, Dm + /// A64: MUL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 Multiply(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vmul_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VMUL.I32 Dd, Dn, Dm - /// A64: MUL Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vmul_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VMUL.I32 Dd, Dn, Dm + /// A64: MUL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Multiply(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vmulq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VMUL.I8 Qd, Qn, Qm - /// A64: MUL Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vmulq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VMUL.I8 Qd, Qn, Qm + /// A64: MUL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Multiply(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vmulq_s16 (int16x8_t a, int16x8_t b) - /// A32: VMUL.I16 Qd, Qn, Qm - /// A64: MUL Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vmulq_s16 (int16x8_t a, int16x8_t b) + /// A32: VMUL.I16 Qd, Qn, Qm + /// A64: MUL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 Multiply(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmulq_s32 (int32x4_t a, int32x4_t b) - /// A32: VMUL.I32 Qd, Qn, Qm - /// A64: MUL Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vmulq_s32 (int32x4_t a, int32x4_t b) + /// A32: VMUL.I32 Qd, Qn, Qm + /// A64: MUL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Multiply(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vmulq_s8 (int8x16_t a, int8x16_t b) - /// A32: VMUL.I8 Qd, Qn, Qm - /// A64: MUL Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vmulq_s8 (int8x16_t a, int8x16_t b) + /// A32: VMUL.I8 Qd, Qn, Qm + /// A64: MUL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Multiply(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vmulq_f32 (float32x4_t a, float32x4_t b) - /// A32: VMUL.F32 Qd, Qn, Qm - /// A64: FMUL Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vmulq_f32 (float32x4_t a, float32x4_t b) + /// A32: VMUL.F32 Qd, Qn, Qm + /// A64: FMUL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Multiply(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmulq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VMUL.I16 Qd, Qn, Qm - /// A64: MUL Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vmulq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VMUL.I16 Qd, Qn, Qm + /// A64: MUL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 Multiply(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmulq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VMUL.I32 Qd, Qn, Qm - /// A64: MUL Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vmulq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VMUL.I32 Qd, Qn, Qm + /// A64: MUL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Multiply(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vmla_u8 (uint8x8_t a, uint8x8_t b, uint8x8_t c) - /// A32: VMLA.I8 Dd, Dn, Dm - /// A64: MLA Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vmla_u8 (uint8x8_t a, uint8x8_t b, uint8x8_t c) + /// A32: VMLA.I8 Dd, Dn, Dm + /// A64: MLA Vd.8B, Vn.8B, Vm.8B /// public static Vector64 MultiplyAdd(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vmla_s16 (int16x4_t a, int16x4_t b, int16x4_t c) - /// A32: VMLA.I16 Dd, Dn, Dm - /// A64: MLA Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vmla_s16 (int16x4_t a, int16x4_t b, int16x4_t c) + /// A32: VMLA.I16 Dd, Dn, Dm + /// A64: MLA Vd.4H, Vn.4H, Vm.4H /// public static Vector64 MultiplyAdd(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vmla_s32 (int32x2_t a, int32x2_t b, int32x2_t c) - /// A32: VMLA.I32 Dd, Dn, Dm - /// A64: MLA Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vmla_s32 (int32x2_t a, int32x2_t b, int32x2_t c) + /// A32: VMLA.I32 Dd, Dn, Dm + /// A64: MLA Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MultiplyAdd(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vmla_s8 (int8x8_t a, int8x8_t b, int8x8_t c) - /// A32: VMLA.I8 Dd, Dn, Dm - /// A64: MLA Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vmla_s8 (int8x8_t a, int8x8_t b, int8x8_t c) + /// A32: VMLA.I8 Dd, Dn, Dm + /// A64: MLA Vd.8B, Vn.8B, Vm.8B /// public static Vector64 MultiplyAdd(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vmla_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t c) - /// A32: VMLA.I16 Dd, Dn, Dm - /// A64: MLA Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vmla_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t c) + /// A32: VMLA.I16 Dd, Dn, Dm + /// A64: MLA Vd.4H, Vn.4H, Vm.4H /// public static Vector64 MultiplyAdd(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vmla_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t c) - /// A32: VMLA.I32 Dd, Dn, Dm - /// A64: MLA Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vmla_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t c) + /// A32: VMLA.I32 Dd, Dn, Dm + /// A64: MLA Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MultiplyAdd(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vmlaq_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c) - /// A32: VMLA.I8 Qd, Qn, Qm - /// A64: MLA Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vmlaq_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c) + /// A32: VMLA.I8 Qd, Qn, Qm + /// A64: MLA Vd.16B, Vn.16B, Vm.16B /// public static Vector128 MultiplyAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vmlaq_s16 (int16x8_t a, int16x8_t b, int16x8_t c) - /// A32: VMLA.I16 Qd, Qn, Qm - /// A64: MLA Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vmlaq_s16 (int16x8_t a, int16x8_t b, int16x8_t c) + /// A32: VMLA.I16 Qd, Qn, Qm + /// A64: MLA Vd.8H, Vn.8H, Vm.8H /// public static Vector128 MultiplyAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmlaq_s32 (int32x4_t a, int32x4_t b, int32x4_t c) - /// A32: VMLA.I32 Qd, Qn, Qm - /// A64: MLA Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vmlaq_s32 (int32x4_t a, int32x4_t b, int32x4_t c) + /// A32: VMLA.I32 Qd, Qn, Qm + /// A64: MLA Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MultiplyAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vmlaq_s8 (int8x16_t a, int8x16_t b, int8x16_t c) - /// A32: VMLA.I8 Qd, Qn, Qm - /// A64: MLA Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vmlaq_s8 (int8x16_t a, int8x16_t b, int8x16_t c) + /// A32: VMLA.I8 Qd, Qn, Qm + /// A64: MLA Vd.16B, Vn.16B, Vm.16B /// public static Vector128 MultiplyAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmlaq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c) - /// A32: VMLA.I16 Qd, Qn, Qm - /// A64: MLA Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vmlaq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c) + /// A32: VMLA.I16 Qd, Qn, Qm + /// A64: MLA Vd.8H, Vn.8H, Vm.8H /// public static Vector128 MultiplyAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmlaq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c) - /// A32: VMLA.I32 Qd, Qn, Qm - /// A64: MLA Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vmlaq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c) + /// A32: VMLA.I32 Qd, Qn, Qm + /// A64: MLA Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MultiplyAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vmla_n_s16 (int16x4_t a, int16x4_t b, int16_t c) - /// A32: VMLA.I16 Dd, Dn, Dm[0] - /// A64: MLA Vd.4H, Vn.4H, Vm.H[0] + /// int16x4_t vmla_n_s16 (int16x4_t a, int16x4_t b, int16_t c) + /// A32: VMLA.I16 Dd, Dn, Dm[0] + /// A64: MLA Vd.4H, Vn.4H, Vm.H[0] /// public static Vector64 MultiplyAddByScalar(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vmla_n_s32 (int32x2_t a, int32x2_t b, int32_t c) - /// A32: VMLA.I32 Dd, Dn, Dm[0] - /// A64: MLA Vd.2S, Vn.2S, Vm.S[0] + /// int32x2_t vmla_n_s32 (int32x2_t a, int32x2_t b, int32_t c) + /// A32: VMLA.I32 Dd, Dn, Dm[0] + /// A64: MLA Vd.2S, Vn.2S, Vm.S[0] /// public static Vector64 MultiplyAddByScalar(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vmla_n_u16 (uint16x4_t a, uint16x4_t b, uint16_t c) - /// A32: VMLA.I16 Dd, Dn, Dm[0] - /// A64: MLA Vd.4H, Vn.4H, Vm.H[0] + /// uint16x4_t vmla_n_u16 (uint16x4_t a, uint16x4_t b, uint16_t c) + /// A32: VMLA.I16 Dd, Dn, Dm[0] + /// A64: MLA Vd.4H, Vn.4H, Vm.H[0] /// public static Vector64 MultiplyAddByScalar(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vmla_n_u32 (uint32x2_t a, uint32x2_t b, uint32_t c) - /// A32: VMLA.I32 Dd, Dn, Dm[0] - /// A64: MLA Vd.2S, Vn.2S, Vm.S[0] + /// uint32x2_t vmla_n_u32 (uint32x2_t a, uint32x2_t b, uint32_t c) + /// A32: VMLA.I32 Dd, Dn, Dm[0] + /// A64: MLA Vd.2S, Vn.2S, Vm.S[0] /// public static Vector64 MultiplyAddByScalar(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vmlaq_n_s16 (int16x8_t a, int16x8_t b, int16_t c) - /// A32: VMLA.I16 Qd, Qn, Dm[0] - /// A64: MLA Vd.8H, Vn.8H, Vm.H[0] + /// int16x8_t vmlaq_n_s16 (int16x8_t a, int16x8_t b, int16_t c) + /// A32: VMLA.I16 Qd, Qn, Dm[0] + /// A64: MLA Vd.8H, Vn.8H, Vm.H[0] /// public static Vector128 MultiplyAddByScalar(Vector128 addend, Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmlaq_n_s32 (int32x4_t a, int32x4_t b, int32_t c) - /// A32: VMLA.I32 Qd, Qn, Dm[0] - /// A64: MLA Vd.4S, Vn.4S, Vm.S[0] + /// int32x4_t vmlaq_n_s32 (int32x4_t a, int32x4_t b, int32_t c) + /// A32: VMLA.I32 Qd, Qn, Dm[0] + /// A64: MLA Vd.4S, Vn.4S, Vm.S[0] /// public static Vector128 MultiplyAddByScalar(Vector128 addend, Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmlaq_n_u16 (uint16x8_t a, uint16x8_t b, uint16_t c) - /// A32: VMLA.I16 Qd, Qn, Dm[0] - /// A64: MLA Vd.8H, Vn.8H, Vm.H[0] + /// uint16x8_t vmlaq_n_u16 (uint16x8_t a, uint16x8_t b, uint16_t c) + /// A32: VMLA.I16 Qd, Qn, Dm[0] + /// A64: MLA Vd.8H, Vn.8H, Vm.H[0] /// public static Vector128 MultiplyAddByScalar(Vector128 addend, Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmlaq_n_u32 (uint32x4_t a, uint32x4_t b, uint32_t c) - /// A32: VMLA.I32 Qd, Qn, Dm[0] - /// A64: MLA Vd.4S, Vn.4S, Vm.S[0] + /// uint32x4_t vmlaq_n_u32 (uint32x4_t a, uint32x4_t b, uint32_t c) + /// A32: VMLA.I32 Qd, Qn, Dm[0] + /// A64: MLA Vd.4S, Vn.4S, Vm.S[0] /// public static Vector128 MultiplyAddByScalar(Vector128 addend, Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vmla_lane_s16 (int16x4_t a, int16x4_t b, int16x4_t v, const int lane) - /// A32: VMLA.I16 Dd, Dn, Dm[lane] - /// A64: MLA Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vmla_lane_s16 (int16x4_t a, int16x4_t b, int16x4_t v, const int lane) + /// A32: VMLA.I16 Dd, Dn, Dm[lane] + /// A64: MLA Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyAddBySelectedScalar(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vmla_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane) - /// A32: VMLA.I16 Dd, Dn, Dm[lane] - /// A64: MLA Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vmla_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane) + /// A32: VMLA.I16 Dd, Dn, Dm[lane] + /// A64: MLA Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyAddBySelectedScalar(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vmla_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane) - /// A32: VMLA.I32 Dd, Dn, Dm[lane] - /// A64: MLA Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vmla_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane) + /// A32: VMLA.I32 Dd, Dn, Dm[lane] + /// A64: MLA Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyAddBySelectedScalar(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vmla_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane) - /// A32: VMLA.I32 Dd, Dn, Dm[lane] - /// A64: MLA Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vmla_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane) + /// A32: VMLA.I32 Dd, Dn, Dm[lane] + /// A64: MLA Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyAddBySelectedScalar(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vmla_lane_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t v, const int lane) - /// A32: VMLA.I16 Dd, Dn, Dm[lane] - /// A64: MLA Vd.4H, Vn.4H, Vm.H[lane] + /// uint16x4_t vmla_lane_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t v, const int lane) + /// A32: VMLA.I16 Dd, Dn, Dm[lane] + /// A64: MLA Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyAddBySelectedScalar(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vmla_laneq_u16 (uint16x4_t a, uint16x4_t b, uint16x8_t v, const int lane) - /// A32: VMLA.I16 Dd, Dn, Dm[lane] - /// A64: MLA Vd.4H, Vn.4H, Vm.H[lane] + /// uint16x4_t vmla_laneq_u16 (uint16x4_t a, uint16x4_t b, uint16x8_t v, const int lane) + /// A32: VMLA.I16 Dd, Dn, Dm[lane] + /// A64: MLA Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyAddBySelectedScalar(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vmla_lane_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t v, const int lane) - /// A32: VMLA.I32 Dd, Dn, Dm[lane] - /// A64: MLA Vd.2S, Vn.2S, Vm.S[lane] + /// uint32x2_t vmla_lane_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t v, const int lane) + /// A32: VMLA.I32 Dd, Dn, Dm[lane] + /// A64: MLA Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyAddBySelectedScalar(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vmla_laneq_u32 (uint32x2_t a, uint32x2_t b, uint32x4_t v, const int lane) - /// A32: VMLA.I32 Dd, Dn, Dm[lane] - /// A64: MLA Vd.2S, Vn.2S, Vm.S[lane] + /// uint32x2_t vmla_laneq_u32 (uint32x2_t a, uint32x2_t b, uint32x4_t v, const int lane) + /// A32: VMLA.I32 Dd, Dn, Dm[lane] + /// A64: MLA Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyAddBySelectedScalar(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vmlaq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane) - /// A32: VMLA.I16 Qd, Qn, Dm[lane] - /// A64: MLA Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vmlaq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane) + /// A32: VMLA.I16 Qd, Qn, Dm[lane] + /// A64: MLA Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vmlaq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane) - /// A32: VMLA.I16 Qd, Qn, Dm[lane] - /// A64: MLA Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vmlaq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane) + /// A32: VMLA.I16 Qd, Qn, Dm[lane] + /// A64: MLA Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmlaq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane) - /// A32: VMLA.I32 Qd, Qn, Dm[lane] - /// A64: MLA Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vmlaq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane) + /// A32: VMLA.I32 Qd, Qn, Dm[lane] + /// A64: MLA Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmlaq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane) - /// A32: VMLA.I32 Qd, Qn, Dm[lane] - /// A64: MLA Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vmlaq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane) + /// A32: VMLA.I32 Qd, Qn, Dm[lane] + /// A64: MLA Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmlaq_lane_u16 (uint16x8_t a, uint16x8_t b, uint16x4_t v, const int lane) - /// A32: VMLA.I16 Qd, Qn, Dm[lane] - /// A64: MLA Vd.8H, Vn.8H, Vm.H[lane] + /// uint16x8_t vmlaq_lane_u16 (uint16x8_t a, uint16x8_t b, uint16x4_t v, const int lane) + /// A32: VMLA.I16 Qd, Qn, Dm[lane] + /// A64: MLA Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmlaq_laneq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t v, const int lane) - /// A32: VMLA.I16 Qd, Qn, Dm[lane] - /// A64: MLA Vd.8H, Vn.8H, Vm.H[lane] + /// uint16x8_t vmlaq_laneq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t v, const int lane) + /// A32: VMLA.I16 Qd, Qn, Dm[lane] + /// A64: MLA Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmlaq_lane_u32 (uint32x4_t a, uint32x4_t b, uint32x2_t v, const int lane) - /// A32: VMLA.I32 Qd, Qn, Dm[lane] - /// A64: MLA Vd.4S, Vn.4S, Vm.S[lane] + /// uint32x4_t vmlaq_lane_u32 (uint32x4_t a, uint32x4_t b, uint32x2_t v, const int lane) + /// A32: VMLA.I32 Qd, Qn, Dm[lane] + /// A64: MLA Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmlaq_laneq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t v, const int lane) - /// A32: VMLA.I32 Qd, Qn, Dm[lane] - /// A64: MLA Vd.4S, Vn.4S, Vm.S[lane] + /// uint32x4_t vmlaq_laneq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t v, const int lane) + /// A32: VMLA.I32 Qd, Qn, Dm[lane] + /// A64: MLA Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vmul_n_s16 (int16x4_t a, int16_t b) - /// A32: VMUL.I16 Dd, Dn, Dm[0] - /// A64: MUL Vd.4H, Vn.4H, Vm.H[0] + /// int16x4_t vmul_n_s16 (int16x4_t a, int16_t b) + /// A32: VMUL.I16 Dd, Dn, Dm[0] + /// A64: MUL Vd.4H, Vn.4H, Vm.H[0] /// public static Vector64 MultiplyByScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vmul_n_s32 (int32x2_t a, int32_t b) - /// A32: VMUL.I32 Dd, Dn, Dm[0] - /// A64: MUL Vd.2S, Vn.2S, Vm.S[0] + /// int32x2_t vmul_n_s32 (int32x2_t a, int32_t b) + /// A32: VMUL.I32 Dd, Dn, Dm[0] + /// A64: MUL Vd.2S, Vn.2S, Vm.S[0] /// public static Vector64 MultiplyByScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vmul_n_f32 (float32x2_t a, float32_t b) - /// A32: VMUL.F32 Dd, Dn, Dm[0] - /// A64: FMUL Vd.2S, Vn.2S, Vm.S[0] + /// float32x2_t vmul_n_f32 (float32x2_t a, float32_t b) + /// A32: VMUL.F32 Dd, Dn, Dm[0] + /// A64: FMUL Vd.2S, Vn.2S, Vm.S[0] /// public static Vector64 MultiplyByScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vmul_n_u16 (uint16x4_t a, uint16_t b) - /// A32: VMUL.I16 Dd, Dn, Dm[0] - /// A64: MUL Vd.4H, Vn.4H, Vm.H[0] + /// uint16x4_t vmul_n_u16 (uint16x4_t a, uint16_t b) + /// A32: VMUL.I16 Dd, Dn, Dm[0] + /// A64: MUL Vd.4H, Vn.4H, Vm.H[0] /// public static Vector64 MultiplyByScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vmul_n_u32 (uint32x2_t a, uint32_t b) - /// A32: VMUL.I32 Dd, Dn, Dm[0] - /// A64: MUL Vd.2S, Vn.2S, Vm.S[0] + /// uint32x2_t vmul_n_u32 (uint32x2_t a, uint32_t b) + /// A32: VMUL.I32 Dd, Dn, Dm[0] + /// A64: MUL Vd.2S, Vn.2S, Vm.S[0] /// public static Vector64 MultiplyByScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vmulq_n_s16 (int16x8_t a, int16_t b) - /// A32: VMUL.I16 Qd, Qn, Dm[0] - /// A64: MUL Vd.8H, Vn.8H, Vm.H[0] + /// int16x8_t vmulq_n_s16 (int16x8_t a, int16_t b) + /// A32: VMUL.I16 Qd, Qn, Dm[0] + /// A64: MUL Vd.8H, Vn.8H, Vm.H[0] /// public static Vector128 MultiplyByScalar(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmulq_n_s32 (int32x4_t a, int32_t b) - /// A32: VMUL.I32 Qd, Qn, Dm[0] - /// A64: MUL Vd.4S, Vn.4S, Vm.S[0] + /// int32x4_t vmulq_n_s32 (int32x4_t a, int32_t b) + /// A32: VMUL.I32 Qd, Qn, Dm[0] + /// A64: MUL Vd.4S, Vn.4S, Vm.S[0] /// public static Vector128 MultiplyByScalar(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vmulq_n_f32 (float32x4_t a, float32_t b) - /// A32: VMUL.F32 Qd, Qn, Dm[0] - /// A64: FMUL Vd.4S, Vn.4S, Vm.S[0] + /// float32x4_t vmulq_n_f32 (float32x4_t a, float32_t b) + /// A32: VMUL.F32 Qd, Qn, Dm[0] + /// A64: FMUL Vd.4S, Vn.4S, Vm.S[0] /// public static Vector128 MultiplyByScalar(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmulq_n_u16 (uint16x8_t a, uint16_t b) - /// A32: VMUL.I16 Qd, Qn, Dm[0] - /// A64: MUL Vd.8H, Vn.8H, Vm.H[0] + /// uint16x8_t vmulq_n_u16 (uint16x8_t a, uint16_t b) + /// A32: VMUL.I16 Qd, Qn, Dm[0] + /// A64: MUL Vd.8H, Vn.8H, Vm.H[0] /// public static Vector128 MultiplyByScalar(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmulq_n_u32 (uint32x4_t a, uint32_t b) - /// A32: VMUL.I32 Qd, Qn, Dm[0] - /// A64: MUL Vd.4S, Vn.4S, Vm.S[0] + /// uint32x4_t vmulq_n_u32 (uint32x4_t a, uint32_t b) + /// A32: VMUL.I32 Qd, Qn, Dm[0] + /// A64: MUL Vd.4S, Vn.4S, Vm.S[0] /// public static Vector128 MultiplyByScalar(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vmul_lane_s16 (int16x4_t a, int16x4_t v, const int lane) - /// A32: VMUL.I16 Dd, Dn, Dm[lane] - /// A64: MUL Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vmul_lane_s16 (int16x4_t a, int16x4_t v, const int lane) + /// A32: VMUL.I16 Dd, Dn, Dm[lane] + /// A64: MUL Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyBySelectedScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vmul_laneq_s16 (int16x4_t a, int16x8_t v, const int lane) - /// A32: VMUL.I16 Dd, Dn, Dm[lane] - /// A64: MUL Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vmul_laneq_s16 (int16x4_t a, int16x8_t v, const int lane) + /// A32: VMUL.I16 Dd, Dn, Dm[lane] + /// A64: MUL Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vmul_lane_s32 (int32x2_t a, int32x2_t v, const int lane) - /// A32: VMUL.I32 Dd, Dn, Dm[lane] - /// A64: MUL Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vmul_lane_s32 (int32x2_t a, int32x2_t v, const int lane) + /// A32: VMUL.I32 Dd, Dn, Dm[lane] + /// A64: MUL Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyBySelectedScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vmul_laneq_s32 (int32x2_t a, int32x4_t v, const int lane) - /// A32: VMUL.I32 Dd, Dn, Dm[lane] - /// A64: MUL Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vmul_laneq_s32 (int32x2_t a, int32x4_t v, const int lane) + /// A32: VMUL.I32 Dd, Dn, Dm[lane] + /// A64: MUL Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vmul_lane_f32 (float32x2_t a, float32x2_t v, const int lane) - /// A32: VMUL.F32 Dd, Dn, Dm[lane] - /// A64: FMUL Vd.2S, Vn.2S, Vm.S[lane] + /// float32x2_t vmul_lane_f32 (float32x2_t a, float32x2_t v, const int lane) + /// A32: VMUL.F32 Dd, Dn, Dm[lane] + /// A64: FMUL Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyBySelectedScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vmul_laneq_f32 (float32x2_t a, float32x4_t v, const int lane) - /// A32: VMUL.F32 Dd, Dn, Dm[lane] - /// A64: FMUL Vd.2S, Vn.2S, Vm.S[lane] + /// float32x2_t vmul_laneq_f32 (float32x2_t a, float32x4_t v, const int lane) + /// A32: VMUL.F32 Dd, Dn, Dm[lane] + /// A64: FMUL Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vmul_lane_u16 (uint16x4_t a, uint16x4_t v, const int lane) - /// A32: VMUL.I16 Dd, Dn, Dm[lane] - /// A64: MUL Vd.4H, Vn.4H, Vm.H[lane] + /// uint16x4_t vmul_lane_u16 (uint16x4_t a, uint16x4_t v, const int lane) + /// A32: VMUL.I16 Dd, Dn, Dm[lane] + /// A64: MUL Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyBySelectedScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vmul_laneq_u16 (uint16x4_t a, uint16x8_t v, const int lane) - /// A32: VMUL.I16 Dd, Dn, Dm[lane] - /// A64: MUL Vd.4H, Vn.4H, Vm.H[lane] + /// uint16x4_t vmul_laneq_u16 (uint16x4_t a, uint16x8_t v, const int lane) + /// A32: VMUL.I16 Dd, Dn, Dm[lane] + /// A64: MUL Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vmul_lane_u32 (uint32x2_t a, uint32x2_t v, const int lane) - /// A32: VMUL.I32 Dd, Dn, Dm[lane] - /// A64: MUL Vd.2S, Vn.2S, Vm.S[lane] + /// uint32x2_t vmul_lane_u32 (uint32x2_t a, uint32x2_t v, const int lane) + /// A32: VMUL.I32 Dd, Dn, Dm[lane] + /// A64: MUL Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyBySelectedScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vmul_laneq_u32 (uint32x2_t a, uint32x4_t v, const int lane) - /// A32: VMUL.I32 Dd, Dn, Dm[lane] - /// A64: MUL Vd.2S, Vn.2S, Vm.S[lane] + /// uint32x2_t vmul_laneq_u32 (uint32x2_t a, uint32x4_t v, const int lane) + /// A32: VMUL.I32 Dd, Dn, Dm[lane] + /// A64: MUL Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vmulq_lane_s16 (int16x8_t a, int16x4_t v, const int lane) - /// A32: VMUL.I16 Qd, Qn, Dm[lane] - /// A64: MUL Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vmulq_lane_s16 (int16x8_t a, int16x4_t v, const int lane) + /// A32: VMUL.I16 Qd, Qn, Dm[lane] + /// A64: MUL Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalar(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vmulq_laneq_s16 (int16x8_t a, int16x8_t v, const int lane) - /// A32: VMUL.I16 Qd, Qn, Dm[lane] - /// A64: MUL Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vmulq_laneq_s16 (int16x8_t a, int16x8_t v, const int lane) + /// A32: VMUL.I16 Qd, Qn, Dm[lane] + /// A64: MUL Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmulq_lane_s32 (int32x4_t a, int32x2_t v, const int lane) - /// A32: VMUL.I32 Qd, Qn, Dm[lane] - /// A64: MUL Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vmulq_lane_s32 (int32x4_t a, int32x2_t v, const int lane) + /// A32: VMUL.I32 Qd, Qn, Dm[lane] + /// A64: MUL Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalar(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmulq_laneq_s32 (int32x4_t a, int32x4_t v, const int lane) - /// A32: VMUL.I32 Qd, Qn, Dm[lane] - /// A64: MUL Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vmulq_laneq_s32 (int32x4_t a, int32x4_t v, const int lane) + /// A32: VMUL.I32 Qd, Qn, Dm[lane] + /// A64: MUL Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vmulq_lane_f32 (float32x4_t a, float32x2_t v, const int lane) - /// A32: VMUL.F32 Qd, Qn, Dm[lane] - /// A64: FMUL Vd.4S, Vn.4S, Vm.S[lane] + /// float32x4_t vmulq_lane_f32 (float32x4_t a, float32x2_t v, const int lane) + /// A32: VMUL.F32 Qd, Qn, Dm[lane] + /// A64: FMUL Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalar(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vmulq_laneq_f32 (float32x4_t a, float32x4_t v, const int lane) - /// A32: VMUL.F32 Qd, Qn, Dm[lane] - /// A64: FMUL Vd.4S, Vn.4S, Vm.S[lane] + /// float32x4_t vmulq_laneq_f32 (float32x4_t a, float32x4_t v, const int lane) + /// A32: VMUL.F32 Qd, Qn, Dm[lane] + /// A64: FMUL Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmulq_lane_u16 (uint16x8_t a, uint16x4_t v, const int lane) - /// A32: VMUL.I16 Qd, Qn, Dm[lane] - /// A64: MUL Vd.8H, Vn.8H, Vm.H[lane] + /// uint16x8_t vmulq_lane_u16 (uint16x8_t a, uint16x4_t v, const int lane) + /// A32: VMUL.I16 Qd, Qn, Dm[lane] + /// A64: MUL Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalar(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmulq_laneq_u16 (uint16x8_t a, uint16x8_t v, const int lane) - /// A32: VMUL.I16 Qd, Qn, Dm[lane] - /// A64: MUL Vd.8H, Vn.8H, Vm.H[lane] + /// uint16x8_t vmulq_laneq_u16 (uint16x8_t a, uint16x8_t v, const int lane) + /// A32: VMUL.I16 Qd, Qn, Dm[lane] + /// A64: MUL Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmulq_lane_u32 (uint32x4_t a, uint32x2_t v, const int lane) - /// A32: VMUL.I32 Qd, Qn, Dm[lane] - /// A64: MUL Vd.4S, Vn.4S, Vm.S[lane] + /// uint32x4_t vmulq_lane_u32 (uint32x4_t a, uint32x2_t v, const int lane) + /// A32: VMUL.I32 Qd, Qn, Dm[lane] + /// A64: MUL Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalar(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmulq_laneq_u32 (uint32x4_t a, uint32x4_t v, const int lane) - /// A32: VMUL.I32 Qd, Qn, Dm[lane] - /// A64: MUL Vd.4S, Vn.4S, Vm.S[lane] + /// uint32x4_t vmulq_laneq_u32 (uint32x4_t a, uint32x4_t v, const int lane) + /// A32: VMUL.I32 Qd, Qn, Dm[lane] + /// A64: MUL Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmull_lane_s16 (int16x4_t a, int16x4_t v, const int lane) - /// A32: VMULL.S16 Qd, Dn, Dm[lane] - /// A64: SMULL Vd.4S, Vn.4H, Vm.H[lane] + /// int32x4_t vmull_lane_s16 (int16x4_t a, int16x4_t v, const int lane) + /// A32: VMULL.S16 Qd, Dn, Dm[lane] + /// A64: SMULL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLower(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmull_laneq_s16 (int16x4_t a, int16x8_t v, const int lane) - /// A32: VMULL.S16 Qd, Dn, Dm[lane] - /// A64: SMULL Vd.4S, Vn.4H, Vm.H[lane] + /// int32x4_t vmull_laneq_s16 (int16x4_t a, int16x8_t v, const int lane) + /// A32: VMULL.S16 Qd, Dn, Dm[lane] + /// A64: SMULL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLower(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vmull_lane_s32 (int32x2_t a, int32x2_t v, const int lane) - /// A32: VMULL.S32 Qd, Dn, Dm[lane] - /// A64: SMULL Vd.2D, Vn.2S, Vm.S[lane] + /// int64x2_t vmull_lane_s32 (int32x2_t a, int32x2_t v, const int lane) + /// A32: VMULL.S32 Qd, Dn, Dm[lane] + /// A64: SMULL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLower(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vmull_laneq_s32 (int32x2_t a, int32x4_t v, const int lane) - /// A32: VMULL.S32 Qd, Dn, Dm[lane] - /// A64: SMULL Vd.2D, Vn.2S, Vm.S[lane] + /// int64x2_t vmull_laneq_s32 (int32x2_t a, int32x4_t v, const int lane) + /// A32: VMULL.S32 Qd, Dn, Dm[lane] + /// A64: SMULL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLower(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmull_lane_u16 (uint16x4_t a, uint16x4_t v, const int lane) - /// A32: VMULL.U16 Qd, Dn, Dm[lane] - /// A64: UMULL Vd.4S, Vn.4H, Vm.H[lane] + /// uint32x4_t vmull_lane_u16 (uint16x4_t a, uint16x4_t v, const int lane) + /// A32: VMULL.U16 Qd, Dn, Dm[lane] + /// A64: UMULL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLower(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmull_laneq_u16 (uint16x4_t a, uint16x8_t v, const int lane) - /// A32: VMULL.U16 Qd, Dn, Dm[lane] - /// A64: UMULL Vd.4S, Vn.4H, Vm.H[lane] + /// uint32x4_t vmull_laneq_u16 (uint16x4_t a, uint16x8_t v, const int lane) + /// A32: VMULL.U16 Qd, Dn, Dm[lane] + /// A64: UMULL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLower(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vmull_lane_u32 (uint32x2_t a, uint32x2_t v, const int lane) - /// A32: VMULL.U32 Qd, Dn, Dm[lane] - /// A64: UMULL Vd.2D, Vn.2S, Vm.S[lane] + /// uint64x2_t vmull_lane_u32 (uint32x2_t a, uint32x2_t v, const int lane) + /// A32: VMULL.U32 Qd, Dn, Dm[lane] + /// A64: UMULL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLower(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vmull_laneq_u32 (uint32x2_t a, uint32x4_t v, const int lane) - /// A32: VMULL.U32 Qd, Dn, Dm[lane] - /// A64: UMULL Vd.2D, Vn.2S, Vm.S[lane] + /// uint64x2_t vmull_laneq_u32 (uint32x2_t a, uint32x4_t v, const int lane) + /// A32: VMULL.U32 Qd, Dn, Dm[lane] + /// A64: UMULL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLower(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmlal_lane_s16 (int32x4_t a, int16x4_t b, int16x4_t v, const int lane) - /// A32: VMLAL.S16 Qd, Dn, Dm[lane] - /// A64: SMLAL Vd.4S, Vn.4H, Vm.H[lane] + /// int32x4_t vmlal_lane_s16 (int32x4_t a, int16x4_t b, int16x4_t v, const int lane) + /// A32: VMLAL.S16 Qd, Dn, Dm[lane] + /// A64: SMLAL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmlal_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane) - /// A32: VMLAL.S16 Qd, Dn, Dm[lane] - /// A64: SMLAL Vd.4S, Vn.4H, Vm.H[lane] + /// int32x4_t vmlal_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane) + /// A32: VMLAL.S16 Qd, Dn, Dm[lane] + /// A64: SMLAL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vmlal_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane) - /// A32: VMLAL.S32 Qd, Dn, Dm[lane] - /// A64: SMLAL Vd.2D, Vn.2S, Vm.S[lane] + /// int64x2_t vmlal_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane) + /// A32: VMLAL.S32 Qd, Dn, Dm[lane] + /// A64: SMLAL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vmlal_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane) - /// A32: VMLAL.S32 Qd, Dn, Dm[lane] - /// A64: SMLAL Vd.2D, Vn.2S, Vm.S[lane] + /// int64x2_t vmlal_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane) + /// A32: VMLAL.S32 Qd, Dn, Dm[lane] + /// A64: SMLAL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmlal_lane_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t v, const int lane) - /// A32: VMLAL.U16 Qd, Dn, Dm[lane] - /// A64: UMLAL Vd.4S, Vn.4H, Vm.H[lane] + /// uint32x4_t vmlal_lane_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t v, const int lane) + /// A32: VMLAL.U16 Qd, Dn, Dm[lane] + /// A64: UMLAL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmlal_laneq_u16 (uint32x4_t a, uint16x4_t b, uint16x8_t v, const int lane) - /// A32: VMLAL.U16 Qd, Dn, Dm[lane] - /// A64: UMLAL Vd.4S, Vn.4H, Vm.H[lane] + /// uint32x4_t vmlal_laneq_u16 (uint32x4_t a, uint16x4_t b, uint16x8_t v, const int lane) + /// A32: VMLAL.U16 Qd, Dn, Dm[lane] + /// A64: UMLAL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vmlal_lane_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t v, const int lane) - /// A32: VMLAL.U32 Qd, Dn, Dm[lane] - /// A64: UMLAL Vd.2D, Vn.2S, Vm.S[lane] + /// uint64x2_t vmlal_lane_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t v, const int lane) + /// A32: VMLAL.U32 Qd, Dn, Dm[lane] + /// A64: UMLAL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vmlal_laneq_u32 (uint64x2_t a, uint32x2_t b, uint32x4_t v, const int lane) - /// A32: VMLAL.U32 Qd, Dn, Dm[lane] - /// A64: UMLAL Vd.2D, Vn.2S, Vm.S[lane] + /// uint64x2_t vmlal_laneq_u32 (uint64x2_t a, uint32x2_t b, uint32x4_t v, const int lane) + /// A32: VMLAL.U32 Qd, Dn, Dm[lane] + /// A64: UMLAL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmlsl_lane_s16 (int32x4_t a, int16x4_t b, int16x4_t v, const int lane) - /// A32: VMLSL.S16 Qd, Dn, Dm[lane] - /// A64: SMLSL Vd.4S, Vn.4H, Vm.H[lane] + /// int32x4_t vmlsl_lane_s16 (int32x4_t a, int16x4_t b, int16x4_t v, const int lane) + /// A32: VMLSL.S16 Qd, Dn, Dm[lane] + /// A64: SMLSL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmlsl_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane) - /// A32: VMLSL.S16 Qd, Dn, Dm[lane] - /// A64: SMLSL Vd.4S, Vn.4H, Vm.H[lane] + /// int32x4_t vmlsl_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane) + /// A32: VMLSL.S16 Qd, Dn, Dm[lane] + /// A64: SMLSL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vmlsl_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane) - /// A32: VMLSL.S32 Qd, Dn, Dm[lane] - /// A64: SMLSL Vd.2D, Vn.2S, Vm.S[lane] + /// int64x2_t vmlsl_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane) + /// A32: VMLSL.S32 Qd, Dn, Dm[lane] + /// A64: SMLSL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vmlsl_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane) - /// A32: VMLSL.S32 Qd, Dn, Dm[lane] - /// A64: SMLSL Vd.2D, Vn.2S, Vm.S[lane] + /// int64x2_t vmlsl_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane) + /// A32: VMLSL.S32 Qd, Dn, Dm[lane] + /// A64: SMLSL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmlsl_lane_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t v, const int lane) - /// A32: VMLSL.U16 Qd, Dn, Dm[lane] - /// A64: UMLSL Vd.4S, Vn.4H, Vm.H[lane] + /// uint32x4_t vmlsl_lane_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t v, const int lane) + /// A32: VMLSL.U16 Qd, Dn, Dm[lane] + /// A64: UMLSL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmlsl_laneq_u16 (uint32x4_t a, uint16x4_t b, uint16x8_t v, const int lane) - /// A32: VMLSL.U16 Qd, Dn, Dm[lane] - /// A64: UMLSL Vd.4S, Vn.4H, Vm.H[lane] + /// uint32x4_t vmlsl_laneq_u16 (uint32x4_t a, uint16x4_t b, uint16x8_t v, const int lane) + /// A32: VMLSL.U16 Qd, Dn, Dm[lane] + /// A64: UMLSL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vmlsl_lane_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t v, const int lane) - /// A32: VMLSL.U32 Qd, Dn, Dm[lane] - /// A64: UMLSL Vd.2D, Vn.2S, Vm.S[lane] + /// uint64x2_t vmlsl_lane_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t v, const int lane) + /// A32: VMLSL.U32 Qd, Dn, Dm[lane] + /// A64: UMLSL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vmlsl_laneq_u32 (uint64x2_t a, uint32x2_t b, uint32x4_t v, const int lane) - /// A32: VMLSL.U32 Qd, Dn, Dm[lane] - /// A64: UMLSL Vd.2D, Vn.2S, Vm.S[lane] + /// uint64x2_t vmlsl_laneq_u32 (uint64x2_t a, uint32x2_t b, uint32x4_t v, const int lane) + /// A32: VMLSL.U32 Qd, Dn, Dm[lane] + /// A64: UMLSL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmull_high_lane_s16 (int16x8_t a, int16x4_t v, const int lane) - /// A32: VMULL.S16 Qd, Dn+1, Dm[lane] - /// A64: SMULL2 Vd.4S, Vn.8H, Vm.H[lane] + /// int32x4_t vmull_high_lane_s16 (int16x8_t a, int16x4_t v, const int lane) + /// A32: VMULL.S16 Qd, Dn+1, Dm[lane] + /// A64: SMULL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpper(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmull_high_laneq_s16 (int16x8_t a, int16x8_t v, const int lane) - /// A32: VMULL.S16 Qd, Dn+1, Dm[lane] - /// A64: SMULL2 Vd.4S, Vn.8H, Vm.H[lane] + /// int32x4_t vmull_high_laneq_s16 (int16x8_t a, int16x8_t v, const int lane) + /// A32: VMULL.S16 Qd, Dn+1, Dm[lane] + /// A64: SMULL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpper(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vmull_high_lane_s32 (int32x4_t a, int32x2_t v, const int lane) - /// A32: VMULL.S32 Qd, Dn+1, Dm[lane] - /// A64: SMULL2 Vd.2D, Vn.4S, Vm.S[lane] + /// int64x2_t vmull_high_lane_s32 (int32x4_t a, int32x2_t v, const int lane) + /// A32: VMULL.S32 Qd, Dn+1, Dm[lane] + /// A64: SMULL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpper(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vmull_high_laneq_s32 (int32x4_t a, int32x4_t v, const int lane) - /// A32: VMULL.S32 Qd, Dn+1, Dm[lane] - /// A64: SMULL2 Vd.2D, Vn.4S, Vm.S[lane] + /// int64x2_t vmull_high_laneq_s32 (int32x4_t a, int32x4_t v, const int lane) + /// A32: VMULL.S32 Qd, Dn+1, Dm[lane] + /// A64: SMULL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpper(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmull_high_lane_u16 (uint16x8_t a, uint16x4_t v, const int lane) - /// A32: VMULL.U16 Qd, Dn+1, Dm[lane] - /// A64: UMULL2 Vd.4S, Vn.8H, Vm.H[lane] + /// uint32x4_t vmull_high_lane_u16 (uint16x8_t a, uint16x4_t v, const int lane) + /// A32: VMULL.U16 Qd, Dn+1, Dm[lane] + /// A64: UMULL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpper(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmull_high_laneq_u16 (uint16x8_t a, uint16x8_t v, const int lane) - /// A32: VMULL.U16 Qd, Dn+1, Dm[lane] - /// A64: UMULL2 Vd.4S, Vn.8H, Vm.H[lane] + /// uint32x4_t vmull_high_laneq_u16 (uint16x8_t a, uint16x8_t v, const int lane) + /// A32: VMULL.U16 Qd, Dn+1, Dm[lane] + /// A64: UMULL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpper(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vmull_high_lane_u32 (uint32x4_t a, uint32x2_t v, const int lane) - /// A32: VMULL.U32 Qd, Dn+1, Dm[lane] - /// A64: UMULL2 Vd.2D, Vn.4S, Vm.S[lane] + /// uint64x2_t vmull_high_lane_u32 (uint32x4_t a, uint32x2_t v, const int lane) + /// A32: VMULL.U32 Qd, Dn+1, Dm[lane] + /// A64: UMULL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpper(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vmull_high_laneq_u32 (uint32x4_t a, uint32x4_t v, const int lane) - /// A32: VMULL.U32 Qd, Dn+1, Dm[lane] - /// A64: UMULL2 Vd.2D, Vn.4S, Vm.S[lane] + /// uint64x2_t vmull_high_laneq_u32 (uint32x4_t a, uint32x4_t v, const int lane) + /// A32: VMULL.U32 Qd, Dn+1, Dm[lane] + /// A64: UMULL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpper(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmlal_high_lane_s16 (int32x4_t a, int16x8_t b, int16x4_t v, const int lane) - /// A32: VMLAL.S16 Qd, Dn+1, Dm[lane] - /// A64: SMLAL2 Vd.4S, Vn.8H, Vm.H[lane] + /// int32x4_t vmlal_high_lane_s16 (int32x4_t a, int16x8_t b, int16x4_t v, const int lane) + /// A32: VMLAL.S16 Qd, Dn+1, Dm[lane] + /// A64: SMLAL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmlal_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane) - /// A32: VMLAL.S16 Qd, Dn+1, Dm[lane] - /// A64: SMLAL2 Vd.4S, Vn.8H, Vm.H[lane] + /// int32x4_t vmlal_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane) + /// A32: VMLAL.S16 Qd, Dn+1, Dm[lane] + /// A64: SMLAL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vmlal_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane) - /// A32: VMLAL.S32 Qd, Dn+1, Dm[lane] - /// A64: SMLAL2 Vd.2D, Vn.4S, Vm.S[lane] + /// int64x2_t vmlal_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane) + /// A32: VMLAL.S32 Qd, Dn+1, Dm[lane] + /// A64: SMLAL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vmlal_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane) - /// A32: VMLAL.S32 Qd, Dn+1, Dm[lane] - /// A64: SMLAL2 Vd.2D, Vn.4S, Vm.S[lane] + /// int64x2_t vmlal_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane) + /// A32: VMLAL.S32 Qd, Dn+1, Dm[lane] + /// A64: SMLAL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmlal_high_lane_u16 (uint32x4_t a, uint16x8_t b, uint16x4_t v, const int lane) - /// A32: VMLAL.U16 Qd, Dn+1, Dm[lane] - /// A64: UMLAL2 Vd.4S, Vn.8H, Vm.H[lane] + /// uint32x4_t vmlal_high_lane_u16 (uint32x4_t a, uint16x8_t b, uint16x4_t v, const int lane) + /// A32: VMLAL.U16 Qd, Dn+1, Dm[lane] + /// A64: UMLAL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmlal_high_laneq_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t v, const int lane) - /// A32: VMLAL.U16 Qd, Dn+1, Dm[lane] - /// A64: UMLAL2 Vd.4S, Vn.8H, Vm.H[lane] + /// uint32x4_t vmlal_high_laneq_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t v, const int lane) + /// A32: VMLAL.U16 Qd, Dn+1, Dm[lane] + /// A64: UMLAL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vmlal_high_lane_u32 (uint64x2_t a, uint32x4_t b, uint32x2_t v, const int lane) - /// A32: VMLAL.U32 Qd, Dn+1, Dm[lane] - /// A64: UMLAL2 Vd.2D, Vn.4S, Vm.S[lane] + /// uint64x2_t vmlal_high_lane_u32 (uint64x2_t a, uint32x4_t b, uint32x2_t v, const int lane) + /// A32: VMLAL.U32 Qd, Dn+1, Dm[lane] + /// A64: UMLAL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vmlal_high_laneq_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t v, const int lane) - /// A32: VMLAL.U32 Qd, Dn+1, Dm[lane] - /// A64: UMLAL2 Vd.2D, Vn.4S, Vm.S[lane] + /// uint64x2_t vmlal_high_laneq_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t v, const int lane) + /// A32: VMLAL.U32 Qd, Dn+1, Dm[lane] + /// A64: UMLAL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmlsl_high_lane_s16 (int32x4_t a, int16x8_t b, int16x4_t v, const int lane) - /// A32: VMLSL.S16 Qd, Dn+1, Dm[lane] - /// A64: SMLSL2 Vd.4S, Vn.8H, Vm.H[lane] + /// int32x4_t vmlsl_high_lane_s16 (int32x4_t a, int16x8_t b, int16x4_t v, const int lane) + /// A32: VMLSL.S16 Qd, Dn+1, Dm[lane] + /// A64: SMLSL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmlsl_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane) - /// A32: VMLSL.S16 Qd, Dn+1, Dm[lane] - /// A64: SMLSL2 Vd.4S, Vn.8H, Vm.H[lane] + /// int32x4_t vmlsl_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane) + /// A32: VMLSL.S16 Qd, Dn+1, Dm[lane] + /// A64: SMLSL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vmlsl_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane) - /// A32: VMLSL.S32 Qd, Dn+1, Dm[lane] - /// A64: SMLSL2 Vd.2D, Vn.4S, Vm.S[lane] + /// int64x2_t vmlsl_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane) + /// A32: VMLSL.S32 Qd, Dn+1, Dm[lane] + /// A64: SMLSL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vmlsl_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane) - /// A32: VMLSL.S32 Qd, Dn+1, Dm[lane] - /// A64: SMLSL2 Vd.2D, Vn.4S, Vm.S[lane] + /// int64x2_t vmlsl_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane) + /// A32: VMLSL.S32 Qd, Dn+1, Dm[lane] + /// A64: SMLSL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmlsl_high_lane_u16 (uint32x4_t a, uint16x8_t b, uint16x4_t v, const int lane) - /// A32: VMLSL.U16 Qd, Dn+1, Dm[lane] - /// A64: UMLSL2 Vd.4S, Vn.8H, Vm.H[lane] + /// uint32x4_t vmlsl_high_lane_u16 (uint32x4_t a, uint16x8_t b, uint16x4_t v, const int lane) + /// A32: VMLSL.U16 Qd, Dn+1, Dm[lane] + /// A64: UMLSL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmlsl_high_laneq_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t v, const int lane) - /// A32: VMLSL.U16 Qd, Dn+1, Dm[lane] - /// A64: UMLSL2 Vd.4S, Vn.8H, Vm.H[lane] + /// uint32x4_t vmlsl_high_laneq_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t v, const int lane) + /// A32: VMLSL.U16 Qd, Dn+1, Dm[lane] + /// A64: UMLSL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vmlsl_high_lane_u32 (uint64x2_t a, uint32x4_t b, uint32x2_t v, const int lane) - /// A32: VMLSL.U32 Qd, Dn+1, Dm[lane] - /// A64: UMLSL2 Vd.2D, Vn.4S, Vm.S[lane] + /// uint64x2_t vmlsl_high_lane_u32 (uint64x2_t a, uint32x4_t b, uint32x2_t v, const int lane) + /// A32: VMLSL.U32 Qd, Dn+1, Dm[lane] + /// A64: UMLSL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vmlsl_high_laneq_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t v, const int lane) - /// A32: VMLSL.U32 Qd, Dn+1, Dm[lane] - /// A64: UMLSL2 Vd.2D, Vn.4S, Vm.S[lane] + /// uint64x2_t vmlsl_high_laneq_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t v, const int lane) + /// A32: VMLSL.U32 Qd, Dn+1, Dm[lane] + /// A64: UMLSL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vqdmulh_n_s16 (int16x4_t a, int16_t b) - /// A32: VQDMULH.S16 Dd, Dn, Dm[0] - /// A64: SQDMULH Vd.4H, Vn.4H, Vm.H[0] + /// int16x4_t vqdmulh_n_s16 (int16x4_t a, int16_t b) + /// A32: VQDMULH.S16 Dd, Dn, Dm[0] + /// A64: SQDMULH Vd.4H, Vn.4H, Vm.H[0] /// public static Vector64 MultiplyDoublingByScalarSaturateHigh(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vqdmulh_n_s32 (int32x2_t a, int32_t b) - /// A32: VQDMULH.S32 Dd, Dn, Dm[0] - /// A64: SQDMULH Vd.2S, Vn.2S, Vm.S[0] + /// int32x2_t vqdmulh_n_s32 (int32x2_t a, int32_t b) + /// A32: VQDMULH.S32 Dd, Dn, Dm[0] + /// A64: SQDMULH Vd.2S, Vn.2S, Vm.S[0] /// public static Vector64 MultiplyDoublingByScalarSaturateHigh(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vqdmulhq_n_s16 (int16x8_t a, int16_t b) - /// A32: VQDMULH.S16 Qd, Qn, Dm[0] - /// A64: SQDMULH Vd.8H, Vn.8H, Vm.H[0] + /// int16x8_t vqdmulhq_n_s16 (int16x8_t a, int16_t b) + /// A32: VQDMULH.S16 Qd, Qn, Dm[0] + /// A64: SQDMULH Vd.8H, Vn.8H, Vm.H[0] /// public static Vector128 MultiplyDoublingByScalarSaturateHigh(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmulhq_n_s32 (int32x4_t a, int32_t b) - /// A32: VQDMULH.S32 Qd, Qn, Dm[0] - /// A64: SQDMULH Vd.4S, Vn.4S, Vm.S[0] + /// int32x4_t vqdmulhq_n_s32 (int32x4_t a, int32_t b) + /// A32: VQDMULH.S32 Qd, Qn, Dm[0] + /// A64: SQDMULH Vd.4S, Vn.4S, Vm.S[0] /// public static Vector128 MultiplyDoublingByScalarSaturateHigh(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vqdmulh_lane_s16 (int16x4_t a, int16x4_t v, const int lane) - /// A32: VQDMULH.S16 Dd, Dn, Dm[lane] - /// A64: SQDMULH Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vqdmulh_lane_s16 (int16x4_t a, int16x4_t v, const int lane) + /// A32: VQDMULH.S16 Dd, Dn, Dm[lane] + /// A64: SQDMULH Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyDoublingBySelectedScalarSaturateHigh(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vqdmulh_laneq_s16 (int16x4_t a, int16x8_t v, const int lane) - /// A32: VQDMULH.S16 Dd, Dn, Dm[lane] - /// A64: SQDMULH Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vqdmulh_laneq_s16 (int16x4_t a, int16x8_t v, const int lane) + /// A32: VQDMULH.S16 Dd, Dn, Dm[lane] + /// A64: SQDMULH Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyDoublingBySelectedScalarSaturateHigh(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vqdmulh_lane_s32 (int32x2_t a, int32x2_t v, const int lane) - /// A32: VQDMULH.S32 Dd, Dn, Dm[lane] - /// A64: SQDMULH Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vqdmulh_lane_s32 (int32x2_t a, int32x2_t v, const int lane) + /// A32: VQDMULH.S32 Dd, Dn, Dm[lane] + /// A64: SQDMULH Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyDoublingBySelectedScalarSaturateHigh(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vqdmulh_laneq_s32 (int32x2_t a, int32x4_t v, const int lane) - /// A32: VQDMULH.S32 Dd, Dn, Dm[lane] - /// A64: SQDMULH Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vqdmulh_laneq_s32 (int32x2_t a, int32x4_t v, const int lane) + /// A32: VQDMULH.S32 Dd, Dn, Dm[lane] + /// A64: SQDMULH Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyDoublingBySelectedScalarSaturateHigh(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vqdmulhq_lane_s16 (int16x8_t a, int16x4_t v, const int lane) - /// A32: VQDMULH.S16 Qd, Qn, Dm[lane] - /// A64: SQDMULH Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vqdmulhq_lane_s16 (int16x8_t a, int16x4_t v, const int lane) + /// A32: VQDMULH.S16 Qd, Qn, Dm[lane] + /// A64: SQDMULH Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyDoublingBySelectedScalarSaturateHigh(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vqdmulhq_laneq_s16 (int16x8_t a, int16x8_t v, const int lane) - /// A32: VQDMULH.S16 Qd, Qn, Dm[lane] - /// A64: SQDMULH Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vqdmulhq_laneq_s16 (int16x8_t a, int16x8_t v, const int lane) + /// A32: VQDMULH.S16 Qd, Qn, Dm[lane] + /// A64: SQDMULH Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyDoublingBySelectedScalarSaturateHigh(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmulhq_lane_s32 (int32x4_t a, int32x2_t v, const int lane) - /// A32: VQDMULH.S32 Qd, Qn, Dm[lane] - /// A64: SQDMULH Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vqdmulhq_lane_s32 (int32x4_t a, int32x2_t v, const int lane) + /// A32: VQDMULH.S32 Qd, Qn, Dm[lane] + /// A64: SQDMULH Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyDoublingBySelectedScalarSaturateHigh(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmulhq_laneq_s32 (int32x4_t a, int32x4_t v, const int lane) - /// A32: VQDMULH.S32 Qd, Qn, Dm[lane] - /// A64: SQDMULH Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vqdmulhq_laneq_s32 (int32x4_t a, int32x4_t v, const int lane) + /// A32: VQDMULH.S32 Qd, Qn, Dm[lane] + /// A64: SQDMULH Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyDoublingBySelectedScalarSaturateHigh(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vqdmulh_s16 (int16x4_t a, int16x4_t b) - /// A32: VQDMULH.S16 Dd, Dn, Dm - /// A64: SQDMULH Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vqdmulh_s16 (int16x4_t a, int16x4_t b) + /// A32: VQDMULH.S16 Dd, Dn, Dm + /// A64: SQDMULH Vd.4H, Vn.4H, Vm.4H /// public static Vector64 MultiplyDoublingSaturateHigh(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vqdmulh_s32 (int32x2_t a, int32x2_t b) - /// A32: VQDMULH.S32 Dd, Dn, Dm - /// A64: SQDMULH Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vqdmulh_s32 (int32x2_t a, int32x2_t b) + /// A32: VQDMULH.S32 Dd, Dn, Dm + /// A64: SQDMULH Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MultiplyDoublingSaturateHigh(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vqdmulhq_s16 (int16x8_t a, int16x8_t b) - /// A32: VQDMULH.S16 Qd, Qn, Qm - /// A64: SQDMULH Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vqdmulhq_s16 (int16x8_t a, int16x8_t b) + /// A32: VQDMULH.S16 Qd, Qn, Qm + /// A64: SQDMULH Vd.8H, Vn.8H, Vm.8H /// public static Vector128 MultiplyDoublingSaturateHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmulhq_s32 (int32x4_t a, int32x4_t b) - /// A32: VQDMULH.S32 Qd, Qn, Qm - /// A64: SQDMULH Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vqdmulhq_s32 (int32x4_t a, int32x4_t b) + /// A32: VQDMULH.S32 Qd, Qn, Qm + /// A64: SQDMULH Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MultiplyDoublingSaturateHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmlal_s16 (int32x4_t a, int16x4_t b, int16x4_t c) - /// A32: VQDMLAL.S16 Qd, Dn, Dm - /// A64: SQDMLAL Vd.4S, Vn.4H, Vm.4H + /// int32x4_t vqdmlal_s16 (int32x4_t a, int16x4_t b, int16x4_t c) + /// A32: VQDMLAL.S16 Qd, Dn, Dm + /// A64: SQDMLAL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 MultiplyDoublingWideningLowerAndAddSaturate(Vector128 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqdmlal_s32 (int64x2_t a, int32x2_t b, int32x2_t c) - /// A32: VQDMLAL.S32 Qd, Dn, Dm - /// A64: SQDMLAL Vd.2D, Vn.2S, Vm.2S + /// int64x2_t vqdmlal_s32 (int64x2_t a, int32x2_t b, int32x2_t c) + /// A32: VQDMLAL.S32 Qd, Dn, Dm + /// A64: SQDMLAL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 MultiplyDoublingWideningLowerAndAddSaturate(Vector128 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmlsl_s16 (int32x4_t a, int16x4_t b, int16x4_t c) - /// A32: VQDMLSL.S16 Qd, Dn, Dm - /// A64: SQDMLSL Vd.4S, Vn.4H, Vm.4H + /// int32x4_t vqdmlsl_s16 (int32x4_t a, int16x4_t b, int16x4_t c) + /// A32: VQDMLSL.S16 Qd, Dn, Dm + /// A64: SQDMLSL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 MultiplyDoublingWideningLowerAndSubtractSaturate(Vector128 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqdmlsl_s32 (int64x2_t a, int32x2_t b, int32x2_t c) - /// A32: VQDMLSL.S32 Qd, Dn, Dm - /// A64: SQDMLSL Vd.2D, Vn.2S, Vm.2S + /// int64x2_t vqdmlsl_s32 (int64x2_t a, int32x2_t b, int32x2_t c) + /// A32: VQDMLSL.S32 Qd, Dn, Dm + /// A64: SQDMLSL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 MultiplyDoublingWideningLowerAndSubtractSaturate(Vector128 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmlal_n_s16 (int32x4_t a, int16x4_t b, int16_t c) - /// A32: VQDMLAL.S16 Qd, Dn, Dm[0] - /// A64: SQDMLAL Vd.4S, Vn.4H, Vm.H[0] + /// int32x4_t vqdmlal_n_s16 (int32x4_t a, int16x4_t b, int16_t c) + /// A32: VQDMLAL.S16 Qd, Dn, Dm[0] + /// A64: SQDMLAL Vd.4S, Vn.4H, Vm.H[0] /// public static Vector128 MultiplyDoublingWideningLowerByScalarAndAddSaturate(Vector128 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqdmlal_n_s32 (int64x2_t a, int32x2_t b, int32_t c) - /// A32: VQDMLAL.S32 Qd, Dn, Dm[0] - /// A64: SQDMLAL Vd.2D, Vn.2S, Vm.S[0] + /// int64x2_t vqdmlal_n_s32 (int64x2_t a, int32x2_t b, int32_t c) + /// A32: VQDMLAL.S32 Qd, Dn, Dm[0] + /// A64: SQDMLAL Vd.2D, Vn.2S, Vm.S[0] /// public static Vector128 MultiplyDoublingWideningLowerByScalarAndAddSaturate(Vector128 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmlsl_n_s16 (int32x4_t a, int16x4_t b, int16_t c) - /// A32: VQDMLSL.S16 Qd, Dn, Dm[0] - /// A64: SQDMLSL Vd.4S, Vn.4H, Vm.H[0] + /// int32x4_t vqdmlsl_n_s16 (int32x4_t a, int16x4_t b, int16_t c) + /// A32: VQDMLSL.S16 Qd, Dn, Dm[0] + /// A64: SQDMLSL Vd.4S, Vn.4H, Vm.H[0] /// public static Vector128 MultiplyDoublingWideningLowerByScalarAndSubtractSaturate(Vector128 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqdmlsl_n_s32 (int64x2_t a, int32x2_t b, int32_t c) - /// A32: VQDMLSL.S32 Qd, Dn, Dm[0] - /// A64: SQDMLSL Vd.2D, Vn.2S, Vm.S[0] + /// int64x2_t vqdmlsl_n_s32 (int64x2_t a, int32x2_t b, int32_t c) + /// A32: VQDMLSL.S32 Qd, Dn, Dm[0] + /// A64: SQDMLSL Vd.2D, Vn.2S, Vm.S[0] /// public static Vector128 MultiplyDoublingWideningLowerByScalarAndSubtractSaturate(Vector128 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmlal_lane_s16 (int32x4_t a, int16x4_t b, int16x4_t v, const int lane) - /// A32: VQDMLAL.S16 Qd, Dn, Dm[lane] - /// A64: SQDMLAL Vd.4S, Vn.4H, Vm.H[lane] + /// int32x4_t vqdmlal_lane_s16 (int32x4_t a, int16x4_t b, int16x4_t v, const int lane) + /// A32: VQDMLAL.S16 Qd, Dn, Dm[lane] + /// A64: SQDMLAL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmlal_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane) - /// A32: VQDMLAL.S16 Qd, Dn, Dm[lane] - /// A64: SQDMLAL Vd.4S, Vn.4H, Vm.H[lane] + /// int32x4_t vqdmlal_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane) + /// A32: VQDMLAL.S16 Qd, Dn, Dm[lane] + /// A64: SQDMLAL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqdmlal_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane) - /// A32: VQDMLAL.S32 Qd, Dn, Dm[lane] - /// A64: SQDMLAL Vd.2D, Vn.2S, Vm.S[lane] + /// int64x2_t vqdmlal_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane) + /// A32: VQDMLAL.S32 Qd, Dn, Dm[lane] + /// A64: SQDMLAL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqdmlal_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane) - /// A32: VQDMLAL.S32 Qd, Dn, Dm[lane] - /// A64: SQDMLAL Vd.2D, Vn.2S, Vm.S[lane] + /// int64x2_t vqdmlal_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane) + /// A32: VQDMLAL.S32 Qd, Dn, Dm[lane] + /// A64: SQDMLAL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmlsl_lane_s16 (int32x4_t a, int16x4_t b, int16x4_t v, const int lane) - /// A32: VQDMLSL.S16 Qd, Dn, Dm[lane] - /// A64: SQDMLSL Vd.4S, Vn.4H, Vm.H[lane] + /// int32x4_t vqdmlsl_lane_s16 (int32x4_t a, int16x4_t b, int16x4_t v, const int lane) + /// A32: VQDMLSL.S16 Qd, Dn, Dm[lane] + /// A64: SQDMLSL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmlsl_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane) - /// A32: VQDMLSL.S16 Qd, Dn, Dm[lane] - /// A64: SQDMLSL Vd.4S, Vn.4H, Vm.H[lane] + /// int32x4_t vqdmlsl_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane) + /// A32: VQDMLSL.S16 Qd, Dn, Dm[lane] + /// A64: SQDMLSL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqdmlsl_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane) - /// A32: VQDMLSL.S32 Qd, Dn, Dm[lane] - /// A64: SQDMLSL Vd.2D, Vn.2S, Vm.S[lane] + /// int64x2_t vqdmlsl_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane) + /// A32: VQDMLSL.S32 Qd, Dn, Dm[lane] + /// A64: SQDMLSL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqdmlsl_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane) - /// A32: VQDMLSL.S32 Qd, Dn, Dm[lane] - /// A64: SQDMLSL Vd.2D, Vn.2S, Vm.S[lane] + /// int64x2_t vqdmlsl_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane) + /// A32: VQDMLSL.S32 Qd, Dn, Dm[lane] + /// A64: SQDMLSL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmull_s16 (int16x4_t a, int16x4_t b) - /// A32: VQDMULL.S16 Qd, Dn, Dm - /// A64: SQDMULL Vd.4S, Vn.4H, Vm.4H + /// int32x4_t vqdmull_s16 (int16x4_t a, int16x4_t b) + /// A32: VQDMULL.S16 Qd, Dn, Dm + /// A64: SQDMULL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 MultiplyDoublingWideningSaturateLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqdmull_s32 (int32x2_t a, int32x2_t b) - /// A32: VQDMULL.S32 Qd, Dn, Dm - /// A64: SQDMULL Vd.2D, Vn.2S, Vm.2S + /// int64x2_t vqdmull_s32 (int32x2_t a, int32x2_t b) + /// A32: VQDMULL.S32 Qd, Dn, Dm + /// A64: SQDMULL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 MultiplyDoublingWideningSaturateLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmull_n_s16 (int16x4_t a, int16_t b) - /// A32: VQDMULL.S16 Qd, Dn, Dm[0] - /// A64: SQDMULL Vd.4S, Vn.4H, Vm.H[0] + /// int32x4_t vqdmull_n_s16 (int16x4_t a, int16_t b) + /// A32: VQDMULL.S16 Qd, Dn, Dm[0] + /// A64: SQDMULL Vd.4S, Vn.4H, Vm.H[0] /// public static Vector128 MultiplyDoublingWideningSaturateLowerByScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqdmull_n_s32 (int32x2_t a, int32_t b) - /// A32: VQDMULL.S32 Qd, Dn, Dm[0] - /// A64: SQDMULL Vd.2D, Vn.2S, Vm.S[0] + /// int64x2_t vqdmull_n_s32 (int32x2_t a, int32_t b) + /// A32: VQDMULL.S32 Qd, Dn, Dm[0] + /// A64: SQDMULL Vd.2D, Vn.2S, Vm.S[0] /// public static Vector128 MultiplyDoublingWideningSaturateLowerByScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmull_lane_s16 (int16x4_t a, int16x4_t v, const int lane) - /// A32: VQDMULL.S16 Qd, Dn, Dm[lane] - /// A64: SQDMULL Vd.4S, Vn.4H, Vm.H[lane] + /// int32x4_t vqdmull_lane_s16 (int16x4_t a, int16x4_t v, const int lane) + /// A32: VQDMULL.S16 Qd, Dn, Dm[lane] + /// A64: SQDMULL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmull_laneq_s16 (int16x4_t a, int16x8_t v, const int lane) - /// A32: VQDMULL.S16 Qd, Dn, Dm[lane] - /// A64: SQDMULL Vd.4S, Vn.4H, Vm.H[lane] + /// int32x4_t vqdmull_laneq_s16 (int16x4_t a, int16x8_t v, const int lane) + /// A32: VQDMULL.S16 Qd, Dn, Dm[lane] + /// A64: SQDMULL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqdmull_lane_s32 (int32x2_t a, int32x2_t v, const int lane) - /// A32: VQDMULL.S32 Qd, Dn, Dm[lane] - /// A64: SQDMULL Vd.2D, Vn.2S, Vm.S[lane] + /// int64x2_t vqdmull_lane_s32 (int32x2_t a, int32x2_t v, const int lane) + /// A32: VQDMULL.S32 Qd, Dn, Dm[lane] + /// A64: SQDMULL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqdmull_laneq_s32 (int32x2_t a, int32x4_t v, const int lane) - /// A32: VQDMULL.S32 Qd, Dn, Dm[lane] - /// A64: SQDMULL Vd.2D, Vn.2S, Vm.S[lane] + /// int64x2_t vqdmull_laneq_s32 (int32x2_t a, int32x4_t v, const int lane) + /// A32: VQDMULL.S32 Qd, Dn, Dm[lane] + /// A64: SQDMULL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmull_high_s16 (int16x8_t a, int16x8_t b) - /// A32: VQDMULL.S16 Qd, Dn+1, Dm+1 - /// A64: SQDMULL2 Vd.4S, Vn.8H, Vm.8H + /// int32x4_t vqdmull_high_s16 (int16x8_t a, int16x8_t b) + /// A32: VQDMULL.S16 Qd, Dn+1, Dm+1 + /// A64: SQDMULL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 MultiplyDoublingWideningSaturateUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqdmull_high_s32 (int32x4_t a, int32x4_t b) - /// A32: VQDMULL.S32 Qd, Dn+1, Dm+1 - /// A64: SQDMULL2 Vd.2D, Vn.4S, Vm.4S + /// int64x2_t vqdmull_high_s32 (int32x4_t a, int32x4_t b) + /// A32: VQDMULL.S32 Qd, Dn+1, Dm+1 + /// A64: SQDMULL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 MultiplyDoublingWideningSaturateUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmull_high_n_s16 (int16x8_t a, int16_t b) - /// A32: VQDMULL.S16 Qd, Dn+1, Dm[0] - /// A64: SQDMULL2 Vd.4S, Vn.8H, Vm.H[0] + /// int32x4_t vqdmull_high_n_s16 (int16x8_t a, int16_t b) + /// A32: VQDMULL.S16 Qd, Dn+1, Dm[0] + /// A64: SQDMULL2 Vd.4S, Vn.8H, Vm.H[0] /// public static Vector128 MultiplyDoublingWideningSaturateUpperByScalar(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqdmull_high_n_s32 (int32x4_t a, int32_t b) - /// A32: VQDMULL.S32 Qd, Dn+1, Dm[0] - /// A64: SQDMULL2 Vd.2D, Vn.4S, Vm.S[0] + /// int64x2_t vqdmull_high_n_s32 (int32x4_t a, int32_t b) + /// A32: VQDMULL.S32 Qd, Dn+1, Dm[0] + /// A64: SQDMULL2 Vd.2D, Vn.4S, Vm.S[0] /// public static Vector128 MultiplyDoublingWideningSaturateUpperByScalar(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmull_high_lane_s16 (int16x8_t a, int16x4_t v, const int lane) - /// A32: VQDMULL.S16 Qd, Dn+1, Dm[lane] - /// A64: SQDMULL2 Vd.4S, Vn.8H, Vm.H[lane] + /// int32x4_t vqdmull_high_lane_s16 (int16x8_t a, int16x4_t v, const int lane) + /// A32: VQDMULL.S16 Qd, Dn+1, Dm[lane] + /// A64: SQDMULL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmull_high_laneq_s16 (int16x8_t a, int16x8_t v, const int lane) - /// A32: VQDMULL.S16 Qd, Dn+1, Dm[lane] - /// A64: SQDMULL2 Vd.4S, Vn.8H, Vm.H[lane] + /// int32x4_t vqdmull_high_laneq_s16 (int16x8_t a, int16x8_t v, const int lane) + /// A32: VQDMULL.S16 Qd, Dn+1, Dm[lane] + /// A64: SQDMULL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqdmull_high_lane_s32 (int32x4_t a, int32x2_t v, const int lane) - /// A32: VQDMULL.S32 Qd, Dn+1, Dm[lane] - /// A64: SQDMULL2 Vd.2D, Vn.4S, Vm.S[lane] + /// int64x2_t vqdmull_high_lane_s32 (int32x4_t a, int32x2_t v, const int lane) + /// A32: VQDMULL.S32 Qd, Dn+1, Dm[lane] + /// A64: SQDMULL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqdmull_high_laneq_s32 (int32x4_t a, int32x4_t v, const int lane) - /// A32: VQDMULL.S32 Qd, Dn+1, Dm[lane] - /// A64: SQDMULL2 Vd.2D, Vn.4S, Vm.S[lane] + /// int64x2_t vqdmull_high_laneq_s32 (int32x4_t a, int32x4_t v, const int lane) + /// A32: VQDMULL.S32 Qd, Dn+1, Dm[lane] + /// A64: SQDMULL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmlal_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c) - /// A32: VQDMLAL.S16 Qd, Dn+1, Dm+1 - /// A64: SQDMLAL2 Vd.4S, Vn.8H, Vm.8H + /// int32x4_t vqdmlal_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c) + /// A32: VQDMLAL.S16 Qd, Dn+1, Dm+1 + /// A64: SQDMLAL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 MultiplyDoublingWideningUpperAndAddSaturate(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqdmlal_high_s32 (int64x2_t a, int32x4_t b, int32x4_t c) - /// A32: VQDMLAL.S32 Qd, Dn+1, Dm+1 - /// A64: SQDMLAL2 Vd.2D, Vn.4S, Vm.4S + /// int64x2_t vqdmlal_high_s32 (int64x2_t a, int32x4_t b, int32x4_t c) + /// A32: VQDMLAL.S32 Qd, Dn+1, Dm+1 + /// A64: SQDMLAL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 MultiplyDoublingWideningUpperAndAddSaturate(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmlsl_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c) - /// A32: VQDMLSL.S16 Qd, Dn+1, Dm+1 - /// A64: SQDMLSL2 Vd.4S, Vn.8H, Vm.8H + /// int32x4_t vqdmlsl_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c) + /// A32: VQDMLSL.S16 Qd, Dn+1, Dm+1 + /// A64: SQDMLSL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 MultiplyDoublingWideningUpperAndSubtractSaturate(Vector128 minuend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqdmlsl_high_s32 (int64x2_t a, int32x4_t b, int32x4_t c) - /// A32: VQDMLSL.S32 Qd, Dn+1, Dm+1 - /// A64: SQDMLSL2 Vd.2D, Vn.4S, Vm.4S + /// int64x2_t vqdmlsl_high_s32 (int64x2_t a, int32x4_t b, int32x4_t c) + /// A32: VQDMLSL.S32 Qd, Dn+1, Dm+1 + /// A64: SQDMLSL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 MultiplyDoublingWideningUpperAndSubtractSaturate(Vector128 minuend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmlal_high_n_s16 (int32x4_t a, int16x8_t b, int16_t c) - /// A32: VQDMLAL.S16 Qd, Dn+1, Dm[0] - /// A64: SQDMLAL2 Vd.4S, Vn.8H, Vm.H[0] + /// int32x4_t vqdmlal_high_n_s16 (int32x4_t a, int16x8_t b, int16_t c) + /// A32: VQDMLAL.S16 Qd, Dn+1, Dm[0] + /// A64: SQDMLAL2 Vd.4S, Vn.8H, Vm.H[0] /// public static Vector128 MultiplyDoublingWideningUpperByScalarAndAddSaturate(Vector128 addend, Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqdmlal_high_n_s32 (int64x2_t a, int32x4_t b, int32_t c) - /// A32: VQDMLAL.S32 Qd, Dn+1, Dm[0] - /// A64: SQDMLAL2 Vd.2D, Vn.4S, Vm.S[0] + /// int64x2_t vqdmlal_high_n_s32 (int64x2_t a, int32x4_t b, int32_t c) + /// A32: VQDMLAL.S32 Qd, Dn+1, Dm[0] + /// A64: SQDMLAL2 Vd.2D, Vn.4S, Vm.S[0] /// public static Vector128 MultiplyDoublingWideningUpperByScalarAndAddSaturate(Vector128 addend, Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmlsl_high_n_s16 (int32x4_t a, int16x8_t b, int16_t c) - /// A32: VQDMLSL.S16 Qd, Dn+1, Dm[0] - /// A64: SQDMLSL2 Vd.4S, Vn.8H, Vm.H[0] + /// int32x4_t vqdmlsl_high_n_s16 (int32x4_t a, int16x8_t b, int16_t c) + /// A32: VQDMLSL.S16 Qd, Dn+1, Dm[0] + /// A64: SQDMLSL2 Vd.4S, Vn.8H, Vm.H[0] /// public static Vector128 MultiplyDoublingWideningUpperByScalarAndSubtractSaturate(Vector128 minuend, Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqdmlsl_high_n_s32 (int64x2_t a, int32x4_t b, int32_t c) - /// A32: VQDMLSL.S32 Qd, Dn+1, Dm[0] - /// A64: SQDMLSL2 Vd.2D, Vn.4S, Vm.S[0] + /// int64x2_t vqdmlsl_high_n_s32 (int64x2_t a, int32x4_t b, int32_t c) + /// A32: VQDMLSL.S32 Qd, Dn+1, Dm[0] + /// A64: SQDMLSL2 Vd.2D, Vn.4S, Vm.S[0] /// public static Vector128 MultiplyDoublingWideningUpperByScalarAndSubtractSaturate(Vector128 minuend, Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmlal_high_lane_s16 (int32x4_t a, int16x8_t b, int16x4_t v, const int lane) - /// A32: VQDMLAL.S16 Qd, Dn+1, Dm[lane] - /// A64: SQDMLAL2 Vd.4S, Vn.8H, Vm.H[lane] + /// int32x4_t vqdmlal_high_lane_s16 (int32x4_t a, int16x8_t b, int16x4_t v, const int lane) + /// A32: VQDMLAL.S16 Qd, Dn+1, Dm[lane] + /// A64: SQDMLAL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmlal_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane) - /// A32: VQDMLAL.S16 Qd, Dn+1, Dm[lane] - /// A64: SQDMLAL2 Vd.4S, Vn.8H, Vm.H[lane] + /// int32x4_t vqdmlal_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane) + /// A32: VQDMLAL.S16 Qd, Dn+1, Dm[lane] + /// A64: SQDMLAL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqdmlal_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane) - /// A32: VQDMLAL.S32 Qd, Dn+1, Dm[lane] - /// A64: SQDMLAL2 Vd.2D, Vn.4S, Vm.S[lane] + /// int64x2_t vqdmlal_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane) + /// A32: VQDMLAL.S32 Qd, Dn+1, Dm[lane] + /// A64: SQDMLAL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqdmlal_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane) - /// A32: VQDMLAL.S32 Qd, Dn+1, Dm[lane] - /// A64: SQDMLAL2 Vd.2D, Vn.4S, Vm.S[lane] + /// int64x2_t vqdmlal_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane) + /// A32: VQDMLAL.S32 Qd, Dn+1, Dm[lane] + /// A64: SQDMLAL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmlsl_high_lane_s16 (int32x4_t a, int16x8_t b, int16x4_t v, const int lane) - /// A32: VQDMLSL.S16 Qd, Dn+1, Dm[lane] - /// A64: SQDMLSL2 Vd.4S, Vn.8H, Vm.H[lane] + /// int32x4_t vqdmlsl_high_lane_s16 (int32x4_t a, int16x8_t b, int16x4_t v, const int lane) + /// A32: VQDMLSL.S16 Qd, Dn+1, Dm[lane] + /// A64: SQDMLSL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqdmlsl_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane) - /// A32: VQDMLSL.S16 Qd, Dn+1, Dm[lane] - /// A64: SQDMLSL2 Vd.4S, Vn.8H, Vm.H[lane] + /// int32x4_t vqdmlsl_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane) + /// A32: VQDMLSL.S16 Qd, Dn+1, Dm[lane] + /// A64: SQDMLSL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqdmlsl_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane) - /// A32: VQDMLSL.S32 Qd, Dn+1, Dm[lane] - /// A64: SQDMLSL2 Vd.2D, Vn.4S, Vm.S[lane] + /// int64x2_t vqdmlsl_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane) + /// A32: VQDMLSL.S32 Qd, Dn+1, Dm[lane] + /// A64: SQDMLSL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqdmlsl_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane) - /// A32: VQDMLSL.S32 Qd, Dn+1, Dm[lane] - /// A64: SQDMLSL2 Vd.2D, Vn.4S, Vm.S[lane] + /// int64x2_t vqdmlsl_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane) + /// A32: VQDMLSL.S32 Qd, Dn+1, Dm[lane] + /// A64: SQDMLSL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vqrdmulh_n_s16 (int16x4_t a, int16_t b) - /// A32: VQRDMULH.S16 Dd, Dn, Dm[0] - /// A64: SQRDMULH Vd.4H, Vn.4H, Vm.H[0] + /// int16x4_t vqrdmulh_n_s16 (int16x4_t a, int16_t b) + /// A32: VQRDMULH.S16 Dd, Dn, Dm[0] + /// A64: SQRDMULH Vd.4H, Vn.4H, Vm.H[0] /// public static Vector64 MultiplyRoundedDoublingByScalarSaturateHigh(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vqrdmulh_n_s32 (int32x2_t a, int32_t b) - /// A32: VQRDMULH.S32 Dd, Dn, Dm[0] - /// A64: SQRDMULH Vd.2S, Vn.2S, Vm.S[0] + /// int32x2_t vqrdmulh_n_s32 (int32x2_t a, int32_t b) + /// A32: VQRDMULH.S32 Dd, Dn, Dm[0] + /// A64: SQRDMULH Vd.2S, Vn.2S, Vm.S[0] /// public static Vector64 MultiplyRoundedDoublingByScalarSaturateHigh(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vqrdmulhq_n_s16 (int16x8_t a, int16_t b) - /// A32: VQRDMULH.S16 Qd, Qn, Dm[0] - /// A64: SQRDMULH Vd.8H, Vn.8H, Vm.H[0] + /// int16x8_t vqrdmulhq_n_s16 (int16x8_t a, int16_t b) + /// A32: VQRDMULH.S16 Qd, Qn, Dm[0] + /// A64: SQRDMULH Vd.8H, Vn.8H, Vm.H[0] /// public static Vector128 MultiplyRoundedDoublingByScalarSaturateHigh(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqrdmulhq_n_s32 (int32x4_t a, int32_t b) - /// A32: VQRDMULH.S32 Qd, Qn, Dm[0] - /// A64: SQRDMULH Vd.4S, Vn.4S, Vm.S[0] + /// int32x4_t vqrdmulhq_n_s32 (int32x4_t a, int32_t b) + /// A32: VQRDMULH.S32 Qd, Qn, Dm[0] + /// A64: SQRDMULH Vd.4S, Vn.4S, Vm.S[0] /// public static Vector128 MultiplyRoundedDoublingByScalarSaturateHigh(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vqrdmulh_lane_s16 (int16x4_t a, int16x4_t v, const int lane) - /// A32: VQRDMULH.S16 Dd, Dn, Dm[lane] - /// A64: SQRDMULH Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vqrdmulh_lane_s16 (int16x4_t a, int16x4_t v, const int lane) + /// A32: VQRDMULH.S16 Dd, Dn, Dm[lane] + /// A64: SQRDMULH Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vqrdmulh_laneq_s16 (int16x4_t a, int16x8_t v, const int lane) - /// A32: VQRDMULH.S16 Dd, Dn, Dm[lane] - /// A64: SQRDMULH Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vqrdmulh_laneq_s16 (int16x4_t a, int16x8_t v, const int lane) + /// A32: VQRDMULH.S16 Dd, Dn, Dm[lane] + /// A64: SQRDMULH Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vqrdmulh_lane_s32 (int32x2_t a, int32x2_t v, const int lane) - /// A32: VQRDMULH.S32 Dd, Dn, Dm[lane] - /// A64: SQRDMULH Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vqrdmulh_lane_s32 (int32x2_t a, int32x2_t v, const int lane) + /// A32: VQRDMULH.S32 Dd, Dn, Dm[lane] + /// A64: SQRDMULH Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vqrdmulh_laneq_s32 (int32x2_t a, int32x4_t v, const int lane) - /// A32: VQRDMULH.S32 Dd, Dn, Dm[lane] - /// A64: SQRDMULH Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vqrdmulh_laneq_s32 (int32x2_t a, int32x4_t v, const int lane) + /// A32: VQRDMULH.S32 Dd, Dn, Dm[lane] + /// A64: SQRDMULH Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vqrdmulhq_lane_s16 (int16x8_t a, int16x4_t v, const int lane) - /// A32: VQRDMULH.S16 Qd, Qn, Dm[lane] - /// A64: SQRDMULH Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vqrdmulhq_lane_s16 (int16x8_t a, int16x4_t v, const int lane) + /// A32: VQRDMULH.S16 Qd, Qn, Dm[lane] + /// A64: SQRDMULH Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vqrdmulhq_laneq_s16 (int16x8_t a, int16x8_t v, const int lane) - /// A32: VQRDMULH.S16 Qd, Qn, Dm[lane] - /// A64: SQRDMULH Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vqrdmulhq_laneq_s16 (int16x8_t a, int16x8_t v, const int lane) + /// A32: VQRDMULH.S16 Qd, Qn, Dm[lane] + /// A64: SQRDMULH Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqrdmulhq_lane_s32 (int32x4_t a, int32x2_t v, const int lane) - /// A32: VQRDMULH.S32 Qd, Qn, Dm[lane] - /// A64: SQRDMULH Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vqrdmulhq_lane_s32 (int32x4_t a, int32x2_t v, const int lane) + /// A32: VQRDMULH.S32 Qd, Qn, Dm[lane] + /// A64: SQRDMULH Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqrdmulhq_laneq_s32 (int32x4_t a, int32x4_t v, const int lane) - /// A32: VQRDMULH.S32 Qd, Qn, Dm[lane] - /// A64: SQRDMULH Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vqrdmulhq_laneq_s32 (int32x4_t a, int32x4_t v, const int lane) + /// A32: VQRDMULH.S32 Qd, Qn, Dm[lane] + /// A64: SQRDMULH Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vqrdmulh_s16 (int16x4_t a, int16x4_t b) - /// A32: VQRDMULH.S16 Dd, Dn, Dm - /// A64: SQRDMULH Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vqrdmulh_s16 (int16x4_t a, int16x4_t b) + /// A32: VQRDMULH.S16 Dd, Dn, Dm + /// A64: SQRDMULH Vd.4H, Vn.4H, Vm.4H /// public static Vector64 MultiplyRoundedDoublingSaturateHigh(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vqrdmulh_s32 (int32x2_t a, int32x2_t b) - /// A32: VQRDMULH.S32 Dd, Dn, Dm - /// A64: SQRDMULH Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vqrdmulh_s32 (int32x2_t a, int32x2_t b) + /// A32: VQRDMULH.S32 Dd, Dn, Dm + /// A64: SQRDMULH Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MultiplyRoundedDoublingSaturateHigh(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vqrdmulhq_s16 (int16x8_t a, int16x8_t b) - /// A32: VQRDMULH.S16 Qd, Qn, Qm - /// A64: SQRDMULH Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vqrdmulhq_s16 (int16x8_t a, int16x8_t b) + /// A32: VQRDMULH.S16 Qd, Qn, Qm + /// A64: SQRDMULH Vd.8H, Vn.8H, Vm.8H /// public static Vector128 MultiplyRoundedDoublingSaturateHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqrdmulhq_s32 (int32x4_t a, int32x4_t b) - /// A32: VQRDMULH.S32 Qd, Qn, Qm - /// A64: SQRDMULH Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vqrdmulhq_s32 (int32x4_t a, int32x4_t b) + /// A32: VQRDMULH.S32 Qd, Qn, Qm + /// A64: SQRDMULH Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MultiplyRoundedDoublingSaturateHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vmul_f64 (float64x1_t a, float64x1_t b) - /// A32: VMUL.F64 Dd, Dn, Dm - /// A64: FMUL Dd, Dn, Dm + /// float64x1_t vmul_f64 (float64x1_t a, float64x1_t b) + /// A32: VMUL.F64 Dd, Dn, Dm + /// A64: FMUL Dd, Dn, Dm /// public static Vector64 MultiplyScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32_t vmuls_f32 (float32_t a, float32_t b) - /// A32: VMUL.F32 Sd, Sn, Sm - /// A64: FMUL Sd, Sn, Sm - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vmuls_f32 (float32_t a, float32_t b) + /// A32: VMUL.F32 Sd, Sn, Sm + /// A64: FMUL Sd, Sn, Sm + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 MultiplyScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32_t vmuls_lane_f32 (float32_t a, float32x2_t v, const int lane) - /// A32: VMUL.F32 Sd, Sn, Dm[lane] - /// A64: FMUL Sd, Sn, Vm.S[lane] + /// float32_t vmuls_lane_f32 (float32_t a, float32x2_t v, const int lane) + /// A32: VMUL.F32 Sd, Sn, Dm[lane] + /// A64: FMUL Sd, Sn, Vm.S[lane] /// public static Vector64 MultiplyScalarBySelectedScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// float32_t vmuls_laneq_f32 (float32_t a, float32x4_t v, const int lane) - /// A32: VMUL.F32 Sd, Sn, Dm[lane] - /// A64: FMUL Sd, Sn, Vm.S[lane] + /// float32_t vmuls_laneq_f32 (float32_t a, float32x4_t v, const int lane) + /// A32: VMUL.F32 Sd, Sn, Dm[lane] + /// A64: FMUL Sd, Sn, Vm.S[lane] /// public static Vector64 MultiplyScalarBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vmls_u8 (uint8x8_t a, uint8x8_t b, uint8x8_t c) - /// A32: VMLS.I8 Dd, Dn, Dm - /// A64: MLS Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vmls_u8 (uint8x8_t a, uint8x8_t b, uint8x8_t c) + /// A32: VMLS.I8 Dd, Dn, Dm + /// A64: MLS Vd.8B, Vn.8B, Vm.8B /// public static Vector64 MultiplySubtract(Vector64 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vmls_s16 (int16x4_t a, int16x4_t b, int16x4_t c) - /// A32: VMLS.I16 Dd, Dn, Dm - /// A64: MLS Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vmls_s16 (int16x4_t a, int16x4_t b, int16x4_t c) + /// A32: VMLS.I16 Dd, Dn, Dm + /// A64: MLS Vd.4H, Vn.4H, Vm.4H /// public static Vector64 MultiplySubtract(Vector64 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vmls_s32 (int32x2_t a, int32x2_t b, int32x2_t c) - /// A32: VMLS.I32 Dd, Dn, Dm - /// A64: MLS Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vmls_s32 (int32x2_t a, int32x2_t b, int32x2_t c) + /// A32: VMLS.I32 Dd, Dn, Dm + /// A64: MLS Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MultiplySubtract(Vector64 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vmls_s8 (int8x8_t a, int8x8_t b, int8x8_t c) - /// A32: VMLS.I8 Dd, Dn, Dm - /// A64: MLS Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vmls_s8 (int8x8_t a, int8x8_t b, int8x8_t c) + /// A32: VMLS.I8 Dd, Dn, Dm + /// A64: MLS Vd.8B, Vn.8B, Vm.8B /// public static Vector64 MultiplySubtract(Vector64 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vmls_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t c) - /// A32: VMLS.I16 Dd, Dn, Dm - /// A64: MLS Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vmls_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t c) + /// A32: VMLS.I16 Dd, Dn, Dm + /// A64: MLS Vd.4H, Vn.4H, Vm.4H /// public static Vector64 MultiplySubtract(Vector64 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vmls_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t c) - /// A32: VMLS.I32 Dd, Dn, Dm - /// A64: MLS Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vmls_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t c) + /// A32: VMLS.I32 Dd, Dn, Dm + /// A64: MLS Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MultiplySubtract(Vector64 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vmlsq_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c) - /// A32: VMLS.I8 Qd, Qn, Qm - /// A64: MLS Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vmlsq_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c) + /// A32: VMLS.I8 Qd, Qn, Qm + /// A64: MLS Vd.16B, Vn.16B, Vm.16B /// public static Vector128 MultiplySubtract(Vector128 minuend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vmlsq_s16 (int16x8_t a, int16x8_t b, int16x8_t c) - /// A32: VMLS.I16 Qd, Qn, Qm - /// A64: MLS Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vmlsq_s16 (int16x8_t a, int16x8_t b, int16x8_t c) + /// A32: VMLS.I16 Qd, Qn, Qm + /// A64: MLS Vd.8H, Vn.8H, Vm.8H /// public static Vector128 MultiplySubtract(Vector128 minuend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmlsq_s32 (int32x4_t a, int32x4_t b, int32x4_t c) - /// A32: VMLS.I32 Qd, Qn, Qm - /// A64: MLS Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vmlsq_s32 (int32x4_t a, int32x4_t b, int32x4_t c) + /// A32: VMLS.I32 Qd, Qn, Qm + /// A64: MLS Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MultiplySubtract(Vector128 minuend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vmlsq_s8 (int8x16_t a, int8x16_t b, int8x16_t c) - /// A32: VMLS.I8 Qd, Qn, Qm - /// A64: MLS Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vmlsq_s8 (int8x16_t a, int8x16_t b, int8x16_t c) + /// A32: VMLS.I8 Qd, Qn, Qm + /// A64: MLS Vd.16B, Vn.16B, Vm.16B /// public static Vector128 MultiplySubtract(Vector128 minuend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmlsq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c) - /// A32: VMLS.I16 Qd, Qn, Qm - /// A64: MLS Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vmlsq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c) + /// A32: VMLS.I16 Qd, Qn, Qm + /// A64: MLS Vd.8H, Vn.8H, Vm.8H /// public static Vector128 MultiplySubtract(Vector128 minuend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmlsq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c) - /// A32: VMLS.I32 Qd, Qn, Qm - /// A64: MLS Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vmlsq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c) + /// A32: VMLS.I32 Qd, Qn, Qm + /// A64: MLS Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MultiplySubtract(Vector128 minuend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vmls_n_s16 (int16x4_t a, int16x4_t b, int16_t c) - /// A32: VMLS.I16 Dd, Dn, Dm[0] - /// A64: MLS Vd.4H, Vn.4H, Vm.H[0] + /// int16x4_t vmls_n_s16 (int16x4_t a, int16x4_t b, int16_t c) + /// A32: VMLS.I16 Dd, Dn, Dm[0] + /// A64: MLS Vd.4H, Vn.4H, Vm.H[0] /// public static Vector64 MultiplySubtractByScalar(Vector64 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vmls_n_s32 (int32x2_t a, int32x2_t b, int32_t c) - /// A32: VMLS.I32 Dd, Dn, Dm[0] - /// A64: MLS Vd.2S, Vn.2S, Vm.S[0] + /// int32x2_t vmls_n_s32 (int32x2_t a, int32x2_t b, int32_t c) + /// A32: VMLS.I32 Dd, Dn, Dm[0] + /// A64: MLS Vd.2S, Vn.2S, Vm.S[0] /// public static Vector64 MultiplySubtractByScalar(Vector64 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vmls_n_u16 (uint16x4_t a, uint16x4_t b, uint16_t c) - /// A32: VMLS.I16 Dd, Dn, Dm[0] - /// A64: MLS Vd.4H, Vn.4H, Vm.H[0] + /// uint16x4_t vmls_n_u16 (uint16x4_t a, uint16x4_t b, uint16_t c) + /// A32: VMLS.I16 Dd, Dn, Dm[0] + /// A64: MLS Vd.4H, Vn.4H, Vm.H[0] /// public static Vector64 MultiplySubtractByScalar(Vector64 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vmls_n_u32 (uint32x2_t a, uint32x2_t b, uint32_t c) - /// A32: VMLS.I32 Dd, Dn, Dm[0] - /// A64: MLS Vd.2S, Vn.2S, Vm.S[0] + /// uint32x2_t vmls_n_u32 (uint32x2_t a, uint32x2_t b, uint32_t c) + /// A32: VMLS.I32 Dd, Dn, Dm[0] + /// A64: MLS Vd.2S, Vn.2S, Vm.S[0] /// public static Vector64 MultiplySubtractByScalar(Vector64 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vmlsq_n_s16 (int16x8_t a, int16x8_t b, int16_t c) - /// A32: VMLS.I16 Qd, Qn, Dm[0] - /// A64: MLS Vd.8H, Vn.8H, Vm.H[0] + /// int16x8_t vmlsq_n_s16 (int16x8_t a, int16x8_t b, int16_t c) + /// A32: VMLS.I16 Qd, Qn, Dm[0] + /// A64: MLS Vd.8H, Vn.8H, Vm.H[0] /// public static Vector128 MultiplySubtractByScalar(Vector128 minuend, Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmlsq_n_s32 (int32x4_t a, int32x4_t b, int32_t c) - /// A32: VMLS.I32 Qd, Qn, Dm[0] - /// A64: MLS Vd.4S, Vn.4S, Vm.S[0] + /// int32x4_t vmlsq_n_s32 (int32x4_t a, int32x4_t b, int32_t c) + /// A32: VMLS.I32 Qd, Qn, Dm[0] + /// A64: MLS Vd.4S, Vn.4S, Vm.S[0] /// public static Vector128 MultiplySubtractByScalar(Vector128 minuend, Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmlsq_n_u16 (uint16x8_t a, uint16x8_t b, uint16_t c) - /// A32: VMLS.I16 Qd, Qn, Dm[0] - /// A64: MLS Vd.8H, Vn.8H, Vm.H[0] + /// uint16x8_t vmlsq_n_u16 (uint16x8_t a, uint16x8_t b, uint16_t c) + /// A32: VMLS.I16 Qd, Qn, Dm[0] + /// A64: MLS Vd.8H, Vn.8H, Vm.H[0] /// public static Vector128 MultiplySubtractByScalar(Vector128 minuend, Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmlsq_n_u32 (uint32x4_t a, uint32x4_t b, uint32_t c) - /// A32: VMLS.I32 Qd, Qn, Dm[0] - /// A64: MLS Vd.4S, Vn.4S, Vm.S[0] + /// uint32x4_t vmlsq_n_u32 (uint32x4_t a, uint32x4_t b, uint32_t c) + /// A32: VMLS.I32 Qd, Qn, Dm[0] + /// A64: MLS Vd.4S, Vn.4S, Vm.S[0] /// public static Vector128 MultiplySubtractByScalar(Vector128 minuend, Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vmls_lane_s16 (int16x4_t a, int16x4_t b, int16x4_t v, const int lane) - /// A32: VMLS.I16 Dd, Dn, Dm[lane] - /// A64: MLS Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vmls_lane_s16 (int16x4_t a, int16x4_t b, int16x4_t v, const int lane) + /// A32: VMLS.I16 Dd, Dn, Dm[lane] + /// A64: MLS Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplySubtractBySelectedScalar(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vmls_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane) - /// A32: VMLS.I16 Dd, Dn, Dm[lane] - /// A64: MLS Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vmls_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane) + /// A32: VMLS.I16 Dd, Dn, Dm[lane] + /// A64: MLS Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplySubtractBySelectedScalar(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vmls_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane) - /// A32: VMLS.I32 Dd, Dn, Dm[lane] - /// A64: MLS Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vmls_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane) + /// A32: VMLS.I32 Dd, Dn, Dm[lane] + /// A64: MLS Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplySubtractBySelectedScalar(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vmls_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane) - /// A32: VMLS.I32 Dd, Dn, Dm[lane] - /// A64: MLS Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vmls_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane) + /// A32: VMLS.I32 Dd, Dn, Dm[lane] + /// A64: MLS Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplySubtractBySelectedScalar(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vmls_lane_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t v, const int lane) - /// A32: VMLS.I16 Dd, Dn, Dm[lane] - /// A64: MLS Vd.4H, Vn.4H, Vm.H[lane] + /// uint16x4_t vmls_lane_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t v, const int lane) + /// A32: VMLS.I16 Dd, Dn, Dm[lane] + /// A64: MLS Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplySubtractBySelectedScalar(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vmls_laneq_u16 (uint16x4_t a, uint16x4_t b, uint16x8_t v, const int lane) - /// A32: VMLS.I16 Dd, Dn, Dm[lane] - /// A64: MLS Vd.4H, Vn.4H, Vm.H[lane] + /// uint16x4_t vmls_laneq_u16 (uint16x4_t a, uint16x4_t b, uint16x8_t v, const int lane) + /// A32: VMLS.I16 Dd, Dn, Dm[lane] + /// A64: MLS Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplySubtractBySelectedScalar(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vmls_lane_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t v, const int lane) - /// A32: VMLS.I32 Dd, Dn, Dm[lane] - /// A64: MLS Vd.2S, Vn.2S, Vm.S[lane] + /// uint32x2_t vmls_lane_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t v, const int lane) + /// A32: VMLS.I32 Dd, Dn, Dm[lane] + /// A64: MLS Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplySubtractBySelectedScalar(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vmls_laneq_u32 (uint32x2_t a, uint32x2_t b, uint32x4_t v, const int lane) - /// A32: VMLS.I32 Dd, Dn, Dm[lane] - /// A64: MLS Vd.2S, Vn.2S, Vm.S[lane] + /// uint32x2_t vmls_laneq_u32 (uint32x2_t a, uint32x2_t b, uint32x4_t v, const int lane) + /// A32: VMLS.I32 Dd, Dn, Dm[lane] + /// A64: MLS Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplySubtractBySelectedScalar(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vmlsq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane) - /// A32: VMLS.I16 Qd, Qn, Dm[lane] - /// A64: MLS Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vmlsq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane) + /// A32: VMLS.I16 Qd, Qn, Dm[lane] + /// A64: MLS Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vmlsq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane) - /// A32: VMLS.I16 Qd, Qn, Dm[lane] - /// A64: MLS Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vmlsq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane) + /// A32: VMLS.I16 Qd, Qn, Dm[lane] + /// A64: MLS Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmlsq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane) - /// A32: VMLS.I32 Qd, Qn, Dm[lane] - /// A64: MLS Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vmlsq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane) + /// A32: VMLS.I32 Qd, Qn, Dm[lane] + /// A64: MLS Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmlsq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane) - /// A32: VMLS.I32 Qd, Qn, Dm[lane] - /// A64: MLS Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vmlsq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane) + /// A32: VMLS.I32 Qd, Qn, Dm[lane] + /// A64: MLS Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmlsq_lane_u16 (uint16x8_t a, uint16x8_t b, uint16x4_t v, const int lane) - /// A32: VMLS.I16 Qd, Qn, Dm[lane] - /// A64: MLS Vd.8H, Vn.8H, Vm.H[lane] + /// uint16x8_t vmlsq_lane_u16 (uint16x8_t a, uint16x8_t b, uint16x4_t v, const int lane) + /// A32: VMLS.I16 Qd, Qn, Dm[lane] + /// A64: MLS Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmlsq_laneq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t v, const int lane) - /// A32: VMLS.I16 Qd, Qn, Dm[lane] - /// A64: MLS Vd.8H, Vn.8H, Vm.H[lane] + /// uint16x8_t vmlsq_laneq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t v, const int lane) + /// A32: VMLS.I16 Qd, Qn, Dm[lane] + /// A64: MLS Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmlsq_lane_u32 (uint32x4_t a, uint32x4_t b, uint32x2_t v, const int lane) - /// A32: VMLS.I32 Qd, Qn, Dm[lane] - /// A64: MLS Vd.4S, Vn.4S, Vm.S[lane] + /// uint32x4_t vmlsq_lane_u32 (uint32x4_t a, uint32x4_t b, uint32x2_t v, const int lane) + /// A32: VMLS.I32 Qd, Qn, Dm[lane] + /// A64: MLS Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmlsq_laneq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t v, const int lane) - /// A32: VMLS.I32 Qd, Qn, Dm[lane] - /// A64: MLS Vd.4S, Vn.4S, Vm.S[lane] + /// uint32x4_t vmlsq_laneq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t v, const int lane) + /// A32: VMLS.I32 Qd, Qn, Dm[lane] + /// A64: MLS Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmull_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VMULL.U8 Qd, Dn, Dm - /// A64: UMULL Vd.8H, Vn.8B, Vm.8B + /// uint16x8_t vmull_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VMULL.U8 Qd, Dn, Dm + /// A64: UMULL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 MultiplyWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmull_s16 (int16x4_t a, int16x4_t b) - /// A32: VMULL.S16 Qd, Dn, Dm - /// A64: SMULL Vd.4S, Vn.4H, Vm.4H + /// int32x4_t vmull_s16 (int16x4_t a, int16x4_t b) + /// A32: VMULL.S16 Qd, Dn, Dm + /// A64: SMULL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 MultiplyWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vmull_s32 (int32x2_t a, int32x2_t b) - /// A32: VMULL.S32 Qd, Dn, Dm - /// A64: SMULL Vd.2D, Vn.2S, Vm.2S + /// int64x2_t vmull_s32 (int32x2_t a, int32x2_t b) + /// A32: VMULL.S32 Qd, Dn, Dm + /// A64: SMULL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 MultiplyWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vmull_s8 (int8x8_t a, int8x8_t b) - /// A32: VMULL.S8 Qd, Dn, Dm - /// A64: SMULL Vd.8H, Vn.8B, Vm.8B + /// int16x8_t vmull_s8 (int8x8_t a, int8x8_t b) + /// A32: VMULL.S8 Qd, Dn, Dm + /// A64: SMULL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 MultiplyWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmull_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VMULL.U16 Qd, Dn, Dm - /// A64: UMULL Vd.4S, Vn.4H, Vm.4H + /// uint32x4_t vmull_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VMULL.U16 Qd, Dn, Dm + /// A64: UMULL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 MultiplyWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vmull_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VMULL.U32 Qd, Dn, Dm - /// A64: UMULL Vd.2D, Vn.2S, Vm.2S + /// uint64x2_t vmull_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VMULL.U32 Qd, Dn, Dm + /// A64: UMULL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 MultiplyWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmlal_u8 (uint16x8_t a, uint8x8_t b, uint8x8_t c) - /// A32: VMLAL.U8 Qd, Dn, Dm - /// A64: UMLAL Vd.8H, Vn.8B, Vm.8B + /// uint16x8_t vmlal_u8 (uint16x8_t a, uint8x8_t b, uint8x8_t c) + /// A32: VMLAL.U8 Qd, Dn, Dm + /// A64: UMLAL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 MultiplyWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmlal_s16 (int32x4_t a, int16x4_t b, int16x4_t c) - /// A32: VMLAL.S16 Qd, Dn, Dm - /// A64: SMLAL Vd.4S, Vn.4H, Vm.4H + /// int32x4_t vmlal_s16 (int32x4_t a, int16x4_t b, int16x4_t c) + /// A32: VMLAL.S16 Qd, Dn, Dm + /// A64: SMLAL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 MultiplyWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vmlal_s32 (int64x2_t a, int32x2_t b, int32x2_t c) - /// A32: VMLAL.S32 Qd, Dn, Dm - /// A64: SMLAL Vd.2D, Vn.2S, Vm.2S + /// int64x2_t vmlal_s32 (int64x2_t a, int32x2_t b, int32x2_t c) + /// A32: VMLAL.S32 Qd, Dn, Dm + /// A64: SMLAL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 MultiplyWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vmlal_s8 (int16x8_t a, int8x8_t b, int8x8_t c) - /// A32: VMLAL.S8 Qd, Dn, Dm - /// A64: SMLAL Vd.8H, Vn.8B, Vm.8B + /// int16x8_t vmlal_s8 (int16x8_t a, int8x8_t b, int8x8_t c) + /// A32: VMLAL.S8 Qd, Dn, Dm + /// A64: SMLAL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 MultiplyWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmlal_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t c) - /// A32: VMLAL.U16 Qd, Dn, Dm - /// A64: UMLAL Vd.4S, Vn.4H, Vm.4H + /// uint32x4_t vmlal_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t c) + /// A32: VMLAL.U16 Qd, Dn, Dm + /// A64: UMLAL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 MultiplyWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vmlal_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t c) - /// A32: VMLAL.U32 Qd, Dn, Dm - /// A64: UMLAL Vd.2D, Vn.2S, Vm.2S + /// uint64x2_t vmlal_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t c) + /// A32: VMLAL.U32 Qd, Dn, Dm + /// A64: UMLAL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 MultiplyWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmlsl_u8 (uint16x8_t a, uint8x8_t b, uint8x8_t c) - /// A32: VMLSL.U8 Qd, Dn, Dm - /// A64: UMLSL Vd.8H, Vn.8B, Vm.8B + /// uint16x8_t vmlsl_u8 (uint16x8_t a, uint8x8_t b, uint8x8_t c) + /// A32: VMLSL.U8 Qd, Dn, Dm + /// A64: UMLSL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 MultiplyWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmlsl_s16 (int32x4_t a, int16x4_t b, int16x4_t c) - /// A32: VMLSL.S16 Qd, Dn, Dm - /// A64: SMLSL Vd.4S, Vn.4H, Vm.4H + /// int32x4_t vmlsl_s16 (int32x4_t a, int16x4_t b, int16x4_t c) + /// A32: VMLSL.S16 Qd, Dn, Dm + /// A64: SMLSL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 MultiplyWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vmlsl_s32 (int64x2_t a, int32x2_t b, int32x2_t c) - /// A32: VMLSL.S32 Qd, Dn, Dm - /// A64: SMLSL Vd.2D, Vn.2S, Vm.2S + /// int64x2_t vmlsl_s32 (int64x2_t a, int32x2_t b, int32x2_t c) + /// A32: VMLSL.S32 Qd, Dn, Dm + /// A64: SMLSL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 MultiplyWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vmlsl_s8 (int16x8_t a, int8x8_t b, int8x8_t c) - /// A32: VMLSL.S8 Qd, Dn, Dm - /// A64: SMLSL Vd.8H, Vn.8B, Vm.8B + /// int16x8_t vmlsl_s8 (int16x8_t a, int8x8_t b, int8x8_t c) + /// A32: VMLSL.S8 Qd, Dn, Dm + /// A64: SMLSL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 MultiplyWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmlsl_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t c) - /// A32: VMLSL.U16 Qd, Dn, Dm - /// A64: UMLSL Vd.4S, Vn.4H, Vm.4H + /// uint32x4_t vmlsl_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t c) + /// A32: VMLSL.U16 Qd, Dn, Dm + /// A64: UMLSL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 MultiplyWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vmlsl_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t c) - /// A32: VMLSL.U32 Qd, Dn, Dm - /// A64: UMLSL Vd.2D, Vn.2S, Vm.2S + /// uint64x2_t vmlsl_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t c) + /// A32: VMLSL.U32 Qd, Dn, Dm + /// A64: UMLSL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 MultiplyWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmull_high_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VMULL.U8 Qd, Dn+1, Dm+1 - /// A64: UMULL2 Vd.8H, Vn.16B, Vm.16B + /// uint16x8_t vmull_high_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VMULL.U8 Qd, Dn+1, Dm+1 + /// A64: UMULL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 MultiplyWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmull_high_s16 (int16x8_t a, int16x8_t b) - /// A32: VMULL.S16 Qd, Dn+1, Dm+1 - /// A64: SMULL2 Vd.4S, Vn.8H, Vm.8H + /// int32x4_t vmull_high_s16 (int16x8_t a, int16x8_t b) + /// A32: VMULL.S16 Qd, Dn+1, Dm+1 + /// A64: SMULL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 MultiplyWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vmull_high_s32 (int32x4_t a, int32x4_t b) - /// A32: VMULL.S32 Qd, Dn+1, Dm+1 - /// A64: SMULL2 Vd.2D, Vn.4S, Vm.4S + /// int64x2_t vmull_high_s32 (int32x4_t a, int32x4_t b) + /// A32: VMULL.S32 Qd, Dn+1, Dm+1 + /// A64: SMULL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 MultiplyWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vmull_high_s8 (int8x16_t a, int8x16_t b) - /// A32: VMULL.S8 Qd, Dn+1, Dm+1 - /// A64: SMULL2 Vd.8H, Vn.16B, Vm.16B + /// int16x8_t vmull_high_s8 (int8x16_t a, int8x16_t b) + /// A32: VMULL.S8 Qd, Dn+1, Dm+1 + /// A64: SMULL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 MultiplyWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmull_high_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VMULL.U16 Qd, Dn+1, Dm+1 - /// A64: UMULL2 Vd.4S, Vn.8H, Vm.8H + /// uint32x4_t vmull_high_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VMULL.U16 Qd, Dn+1, Dm+1 + /// A64: UMULL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 MultiplyWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vmull_high_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VMULL.U32 Qd, Dn+1, Dm+1 - /// A64: UMULL2 Vd.2D, Vn.4S, Vm.4S + /// uint64x2_t vmull_high_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VMULL.U32 Qd, Dn+1, Dm+1 + /// A64: UMULL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 MultiplyWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmlal_high_u8 (uint16x8_t a, uint8x16_t b, uint8x16_t c) - /// A32: VMLAL.U8 Qd, Dn+1, Dm+1 - /// A64: UMLAL2 Vd.8H, Vn.16B, Vm.16B + /// uint16x8_t vmlal_high_u8 (uint16x8_t a, uint8x16_t b, uint8x16_t c) + /// A32: VMLAL.U8 Qd, Dn+1, Dm+1 + /// A64: UMLAL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 MultiplyWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmlal_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c) - /// A32: VMLAL.S16 Qd, Dn+1, Dm+1 - /// A64: SMLAL2 Vd.4S, Vn.8H, Vm.8H + /// int32x4_t vmlal_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c) + /// A32: VMLAL.S16 Qd, Dn+1, Dm+1 + /// A64: SMLAL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 MultiplyWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vmlal_high_s32 (int64x2_t a, int32x4_t b, int32x4_t c) - /// A32: VMLAL.S32 Qd, Dn+1, Dm+1 - /// A64: SMLAL2 Vd.2D, Vn.4S, Vm.4S + /// int64x2_t vmlal_high_s32 (int64x2_t a, int32x4_t b, int32x4_t c) + /// A32: VMLAL.S32 Qd, Dn+1, Dm+1 + /// A64: SMLAL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 MultiplyWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vmlal_high_s8 (int16x8_t a, int8x16_t b, int8x16_t c) - /// A32: VMLAL.S8 Qd, Dn+1, Dm+1 - /// A64: SMLAL2 Vd.8H, Vn.16B, Vm.16B + /// int16x8_t vmlal_high_s8 (int16x8_t a, int8x16_t b, int8x16_t c) + /// A32: VMLAL.S8 Qd, Dn+1, Dm+1 + /// A64: SMLAL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 MultiplyWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmlal_high_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t c) - /// A32: VMLAL.U16 Qd, Dn+1, Dm+1 - /// A64: UMLAL2 Vd.4S, Vn.8H, Vm.8H + /// uint32x4_t vmlal_high_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t c) + /// A32: VMLAL.U16 Qd, Dn+1, Dm+1 + /// A64: UMLAL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 MultiplyWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vmlal_high_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t c) - /// A32: VMLAL.U32 Qd, Dn+1, Dm+1 - /// A64: UMLAL2 Vd.2D, Vn.4S, Vm.4S + /// uint64x2_t vmlal_high_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t c) + /// A32: VMLAL.U32 Qd, Dn+1, Dm+1 + /// A64: UMLAL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 MultiplyWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmlsl_high_u8 (uint16x8_t a, uint8x16_t b, uint8x16_t c) - /// A32: VMLSL.U8 Qd, Dn+1, Dm+1 - /// A64: UMLSL2 Vd.8H, Vn.16B, Vm.16B + /// uint16x8_t vmlsl_high_u8 (uint16x8_t a, uint8x16_t b, uint8x16_t c) + /// A32: VMLSL.U8 Qd, Dn+1, Dm+1 + /// A64: UMLSL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 MultiplyWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmlsl_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c) - /// A32: VMLSL.S16 Qd, Dn+1, Dm+1 - /// A64: SMLSL2 Vd.4S, Vn.8H, Vm.8H + /// int32x4_t vmlsl_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c) + /// A32: VMLSL.S16 Qd, Dn+1, Dm+1 + /// A64: SMLSL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 MultiplyWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vmlsl_high_s32 (int64x2_t a, int32x4_t b, int32x4_t c) - /// A32: VMLSL.S32 Qd, Dn+1, Dm+1 - /// A64: SMLSL2 Vd.2D, Vn.4S, Vm.4S + /// int64x2_t vmlsl_high_s32 (int64x2_t a, int32x4_t b, int32x4_t c) + /// A32: VMLSL.S32 Qd, Dn+1, Dm+1 + /// A64: SMLSL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 MultiplyWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vmlsl_high_s8 (int16x8_t a, int8x16_t b, int8x16_t c) - /// A32: VMLSL.S8 Qd, Dn+1, Dm+1 - /// A64: SMLSL2 Vd.8H, Vn.16B, Vm.16B + /// int16x8_t vmlsl_high_s8 (int16x8_t a, int8x16_t b, int8x16_t c) + /// A32: VMLSL.S8 Qd, Dn+1, Dm+1 + /// A64: SMLSL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 MultiplyWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmlsl_high_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t c) - /// A32: VMLSL.U16 Qd, Dn+1, Dm+1 - /// A64: UMLSL2 Vd.4S, Vn.8H, Vm.8H + /// uint32x4_t vmlsl_high_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t c) + /// A32: VMLSL.U16 Qd, Dn+1, Dm+1 + /// A64: UMLSL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 MultiplyWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vmlsl_high_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t c) - /// A32: VMLSL.U32 Qd, Dn+1, Dm+1 - /// A64: UMLSL2 Vd.2D, Vn.4S, Vm.4S + /// uint64x2_t vmlsl_high_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t c) + /// A32: VMLSL.U32 Qd, Dn+1, Dm+1 + /// A64: UMLSL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 MultiplyWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vneg_s16 (int16x4_t a) - /// A32: VNEG.S16 Dd, Dm - /// A64: NEG Vd.4H, Vn.4H + /// int16x4_t vneg_s16 (int16x4_t a) + /// A32: VNEG.S16 Dd, Dm + /// A64: NEG Vd.4H, Vn.4H /// public static Vector64 Negate(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vneg_s32 (int32x2_t a) - /// A32: VNEG.S32 Dd, Dm - /// A64: NEG Vd.2S, Vn.2S + /// int32x2_t vneg_s32 (int32x2_t a) + /// A32: VNEG.S32 Dd, Dm + /// A64: NEG Vd.2S, Vn.2S /// public static Vector64 Negate(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vneg_s8 (int8x8_t a) - /// A32: VNEG.S8 Dd, Dm - /// A64: NEG Vd.8B, Vn.8B + /// int8x8_t vneg_s8 (int8x8_t a) + /// A32: VNEG.S8 Dd, Dm + /// A64: NEG Vd.8B, Vn.8B /// public static Vector64 Negate(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vneg_f32 (float32x2_t a) - /// A32: VNEG.F32 Dd, Dm - /// A64: FNEG Vd.2S, Vn.2S + /// float32x2_t vneg_f32 (float32x2_t a) + /// A32: VNEG.F32 Dd, Dm + /// A64: FNEG Vd.2S, Vn.2S /// public static Vector64 Negate(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vnegq_s16 (int16x8_t a) - /// A32: VNEG.S16 Qd, Qm - /// A64: NEG Vd.8H, Vn.8H + /// int16x8_t vnegq_s16 (int16x8_t a) + /// A32: VNEG.S16 Qd, Qm + /// A64: NEG Vd.8H, Vn.8H /// public static Vector128 Negate(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vnegq_s32 (int32x4_t a) - /// A32: VNEG.S32 Qd, Qm - /// A64: NEG Vd.4S, Vn.4S + /// int32x4_t vnegq_s32 (int32x4_t a) + /// A32: VNEG.S32 Qd, Qm + /// A64: NEG Vd.4S, Vn.4S /// public static Vector128 Negate(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vnegq_s8 (int8x16_t a) - /// A32: VNEG.S8 Qd, Qm - /// A64: NEG Vd.16B, Vn.16B + /// int8x16_t vnegq_s8 (int8x16_t a) + /// A32: VNEG.S8 Qd, Qm + /// A64: NEG Vd.16B, Vn.16B /// public static Vector128 Negate(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vnegq_f32 (float32x4_t a) - /// A32: VNEG.F32 Qd, Qm - /// A64: FNEG Vd.4S, Vn.4S + /// float32x4_t vnegq_f32 (float32x4_t a) + /// A32: VNEG.F32 Qd, Qm + /// A64: FNEG Vd.4S, Vn.4S /// public static Vector128 Negate(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vqneg_s16 (int16x4_t a) - /// A32: VQNEG.S16 Dd, Dm - /// A64: SQNEG Vd.4H, Vn.4H + /// int16x4_t vqneg_s16 (int16x4_t a) + /// A32: VQNEG.S16 Dd, Dm + /// A64: SQNEG Vd.4H, Vn.4H /// public static Vector64 NegateSaturate(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vqneg_s32 (int32x2_t a) - /// A32: VQNEG.S32 Dd, Dm - /// A64: SQNEG Vd.2S, Vn.2S + /// int32x2_t vqneg_s32 (int32x2_t a) + /// A32: VQNEG.S32 Dd, Dm + /// A64: SQNEG Vd.2S, Vn.2S /// public static Vector64 NegateSaturate(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vqneg_s8 (int8x8_t a) - /// A32: VQNEG.S8 Dd, Dm - /// A64: SQNEG Vd.8B, Vn.8B + /// int8x8_t vqneg_s8 (int8x8_t a) + /// A32: VQNEG.S8 Dd, Dm + /// A64: SQNEG Vd.8B, Vn.8B /// public static Vector64 NegateSaturate(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vqnegq_s16 (int16x8_t a) - /// A32: VQNEG.S16 Qd, Qm - /// A64: SQNEG Vd.8H, Vn.8H + /// int16x8_t vqnegq_s16 (int16x8_t a) + /// A32: VQNEG.S16 Qd, Qm + /// A64: SQNEG Vd.8H, Vn.8H /// public static Vector128 NegateSaturate(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqnegq_s32 (int32x4_t a) - /// A32: VQNEG.S32 Qd, Qm - /// A64: SQNEG Vd.4S, Vn.4S + /// int32x4_t vqnegq_s32 (int32x4_t a) + /// A32: VQNEG.S32 Qd, Qm + /// A64: SQNEG Vd.4S, Vn.4S /// public static Vector128 NegateSaturate(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vqnegq_s8 (int8x16_t a) - /// A32: VQNEG.S8 Qd, Qm - /// A64: SQNEG Vd.16B, Vn.16B + /// int8x16_t vqnegq_s8 (int8x16_t a) + /// A32: VQNEG.S8 Qd, Qm + /// A64: SQNEG Vd.16B, Vn.16B /// public static Vector128 NegateSaturate(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vneg_f64 (float64x1_t a) - /// A32: VNEG.F64 Dd, Dm - /// A64: FNEG Dd, Dn + /// float64x1_t vneg_f64 (float64x1_t a) + /// A32: VNEG.F64 Dd, Dm + /// A64: FNEG Dd, Dn /// public static Vector64 NegateScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32_t vnegs_f32 (float32_t a) - /// A32: VNEG.F32 Sd, Sm - /// A64: FNEG Sd, Sn - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vnegs_f32 (float32_t a) + /// A32: VNEG.F32 Sd, Sm + /// A64: FNEG Sd, Sn + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 NegateScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vmvn_u8 (uint8x8_t a) - /// A32: VMVN Dd, Dm - /// A64: MVN Vd.8B, Vn.8B + /// uint8x8_t vmvn_u8 (uint8x8_t a) + /// A32: VMVN Dd, Dm + /// A64: MVN Vd.8B, Vn.8B /// public static Vector64 Not(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vmvn_f64 (float64x1_t a) - /// A32: VMVN Dd, Dm - /// A64: MVN Vd.8B, Vn.8B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x1_t vmvn_f64 (float64x1_t a) + /// A32: VMVN Dd, Dm + /// A64: MVN Vd.8B, Vn.8B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 Not(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vmvn_s16 (int16x4_t a) - /// A32: VMVN Dd, Dm - /// A64: MVN Vd.8B, Vn.8B + /// int16x4_t vmvn_s16 (int16x4_t a) + /// A32: VMVN Dd, Dm + /// A64: MVN Vd.8B, Vn.8B /// public static Vector64 Not(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vmvn_s32 (int32x2_t a) - /// A32: VMVN Dd, Dm - /// A64: MVN Vd.8B, Vn.8B + /// int32x2_t vmvn_s32 (int32x2_t a) + /// A32: VMVN Dd, Dm + /// A64: MVN Vd.8B, Vn.8B /// public static Vector64 Not(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vmvn_s64 (int64x1_t a) - /// A32: VMVN Dd, Dm - /// A64: MVN Vd.8B, Vn.8B + /// int64x1_t vmvn_s64 (int64x1_t a) + /// A32: VMVN Dd, Dm + /// A64: MVN Vd.8B, Vn.8B /// public static Vector64 Not(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vmvn_s8 (int8x8_t a) - /// A32: VMVN Dd, Dm - /// A64: MVN Vd.8B, Vn.8B + /// int8x8_t vmvn_s8 (int8x8_t a) + /// A32: VMVN Dd, Dm + /// A64: MVN Vd.8B, Vn.8B /// public static Vector64 Not(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vmvn_f32 (float32x2_t a) - /// A32: VMVN Dd, Dm - /// A64: MVN Vd.8B, Vn.8B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32x2_t vmvn_f32 (float32x2_t a) + /// A32: VMVN Dd, Dm + /// A64: MVN Vd.8B, Vn.8B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 Not(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vmvn_u16 (uint16x4_t a) - /// A32: VMVN Dd, Dm - /// A64: MVN Vd.8B, Vn.8B + /// uint16x4_t vmvn_u16 (uint16x4_t a) + /// A32: VMVN Dd, Dm + /// A64: MVN Vd.8B, Vn.8B /// public static Vector64 Not(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vmvn_u32 (uint32x2_t a) - /// A32: VMVN Dd, Dm - /// A64: MVN Vd.8B, Vn.8B + /// uint32x2_t vmvn_u32 (uint32x2_t a) + /// A32: VMVN Dd, Dm + /// A64: MVN Vd.8B, Vn.8B /// public static Vector64 Not(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vmvn_u64 (uint64x1_t a) - /// A32: VMVN Dd, Dm - /// A64: MVN Vd.8B, Vn.8B + /// uint64x1_t vmvn_u64 (uint64x1_t a) + /// A32: VMVN Dd, Dm + /// A64: MVN Vd.8B, Vn.8B /// public static Vector64 Not(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vmvnq_u8 (uint8x16_t a) - /// A32: VMVN Qd, Qm - /// A64: MVN Vd.16B, Vn.16B + /// uint8x16_t vmvnq_u8 (uint8x16_t a) + /// A32: VMVN Qd, Qm + /// A64: MVN Vd.16B, Vn.16B /// public static Vector128 Not(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vmvnq_f64 (float64x2_t a) - /// A32: VMVN Qd, Qm - /// A64: MVN Vd.16B, Vn.16B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x2_t vmvnq_f64 (float64x2_t a) + /// A32: VMVN Qd, Qm + /// A64: MVN Vd.16B, Vn.16B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 Not(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vmvnq_s16 (int16x8_t a) - /// A32: VMVN Qd, Qm - /// A64: MVN Vd.16B, Vn.16B + /// int16x8_t vmvnq_s16 (int16x8_t a) + /// A32: VMVN Qd, Qm + /// A64: MVN Vd.16B, Vn.16B /// public static Vector128 Not(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmvnq_s32 (int32x4_t a) - /// A32: VMVN Qd, Qm - /// A64: MVN Vd.16B, Vn.16B + /// int32x4_t vmvnq_s32 (int32x4_t a) + /// A32: VMVN Qd, Qm + /// A64: MVN Vd.16B, Vn.16B /// public static Vector128 Not(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vmvnq_s64 (int64x2_t a) - /// A32: VMVN Qd, Qm - /// A64: MVN Vd.16B, Vn.16B + /// int64x2_t vmvnq_s64 (int64x2_t a) + /// A32: VMVN Qd, Qm + /// A64: MVN Vd.16B, Vn.16B /// public static Vector128 Not(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vmvnq_s8 (int8x16_t a) - /// A32: VMVN Qd, Qm - /// A64: MVN Vd.16B, Vn.16B + /// int8x16_t vmvnq_s8 (int8x16_t a) + /// A32: VMVN Qd, Qm + /// A64: MVN Vd.16B, Vn.16B /// public static Vector128 Not(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vmvnq_f32 (float32x4_t a) - /// A32: VMVN Qd, Qm - /// A64: MVN Vd.16B, Vn.16B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32x4_t vmvnq_f32 (float32x4_t a) + /// A32: VMVN Qd, Qm + /// A64: MVN Vd.16B, Vn.16B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 Not(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmvnq_u16 (uint16x8_t a) - /// A32: VMVN Qd, Qm - /// A64: MVN Vd.16B, Vn.16B + /// uint16x8_t vmvnq_u16 (uint16x8_t a) + /// A32: VMVN Qd, Qm + /// A64: MVN Vd.16B, Vn.16B /// public static Vector128 Not(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmvnq_u32 (uint32x4_t a) - /// A32: VMVN Qd, Qm - /// A64: MVN Vd.16B, Vn.16B + /// uint32x4_t vmvnq_u32 (uint32x4_t a) + /// A32: VMVN Qd, Qm + /// A64: MVN Vd.16B, Vn.16B /// public static Vector128 Not(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vmvnq_u64 (uint64x2_t a) - /// A32: VMVN Qd, Qm - /// A64: MVN Vd.16B, Vn.16B + /// uint64x2_t vmvnq_u64 (uint64x2_t a) + /// A32: VMVN Qd, Qm + /// A64: MVN Vd.16B, Vn.16B /// public static Vector128 Not(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vorr_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VORR Dd, Dn, Dm - /// A64: ORR Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vorr_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VORR Dd, Dn, Dm + /// A64: ORR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Or(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vorr_f64 (float64x1_t a, float64x1_t b) - /// A32: VORR Dd, Dn, Dm - /// A64: ORR Vd.8B, Vn.8B, Vm.8B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x1_t vorr_f64 (float64x1_t a, float64x1_t b) + /// A32: VORR Dd, Dn, Dm + /// A64: ORR Vd.8B, Vn.8B, Vm.8B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 Or(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vorr_s16 (int16x4_t a, int16x4_t b) - /// A32: VORR Dd, Dn, Dm - /// A64: ORR Vd.8B, Vn.8B, Vm.8B + /// int16x4_t vorr_s16 (int16x4_t a, int16x4_t b) + /// A32: VORR Dd, Dn, Dm + /// A64: ORR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Or(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vorr_s32 (int32x2_t a, int32x2_t b) - /// A32: VORR Dd, Dn, Dm - /// A64: ORR Vd.8B, Vn.8B, Vm.8B + /// int32x2_t vorr_s32 (int32x2_t a, int32x2_t b) + /// A32: VORR Dd, Dn, Dm + /// A64: ORR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Or(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vorr_s64 (int64x1_t a, int64x1_t b) - /// A32: VORR Dd, Dn, Dm - /// A64: ORR Vd.8B, Vn.8B, Vm.8B + /// int64x1_t vorr_s64 (int64x1_t a, int64x1_t b) + /// A32: VORR Dd, Dn, Dm + /// A64: ORR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Or(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vorr_s8 (int8x8_t a, int8x8_t b) - /// A32: VORR Dd, Dn, Dm - /// A64: ORR Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vorr_s8 (int8x8_t a, int8x8_t b) + /// A32: VORR Dd, Dn, Dm + /// A64: ORR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Or(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vorr_f32 (float32x2_t a, float32x2_t b) - /// A32: VORR Dd, Dn, Dm - /// A64: ORR Vd.8B, Vn.8B, Vm.8B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32x2_t vorr_f32 (float32x2_t a, float32x2_t b) + /// A32: VORR Dd, Dn, Dm + /// A64: ORR Vd.8B, Vn.8B, Vm.8B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 Or(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vorr_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VORR Dd, Dn, Dm - /// A64: ORR Vd.8B, Vn.8B, Vm.8B + /// uint16x4_t vorr_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VORR Dd, Dn, Dm + /// A64: ORR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Or(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vorr_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VORR Dd, Dn, Dm - /// A64: ORR Vd.8B, Vn.8B, Vm.8B + /// uint32x2_t vorr_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VORR Dd, Dn, Dm + /// A64: ORR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Or(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vorr_u64 (uint64x1_t a, uint64x1_t b) - /// A32: VORR Dd, Dn, Dm - /// A64: ORR Vd.8B, Vn.8B, Vm.8B + /// uint64x1_t vorr_u64 (uint64x1_t a, uint64x1_t b) + /// A32: VORR Dd, Dn, Dm + /// A64: ORR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Or(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vorrq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VORR Qd, Qn, Qm - /// A64: ORR Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vorrq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VORR Qd, Qn, Qm + /// A64: ORR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vorrq_f64 (float64x2_t a, float64x2_t b) - /// A32: VORR Qd, Qn, Qm - /// A64: ORR Vd.16B, Vn.16B, Vm.16B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x2_t vorrq_f64 (float64x2_t a, float64x2_t b) + /// A32: VORR Qd, Qn, Qm + /// A64: ORR Vd.16B, Vn.16B, Vm.16B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vorrq_s16 (int16x8_t a, int16x8_t b) - /// A32: VORR Qd, Qn, Qm - /// A64: ORR Vd.16B, Vn.16B, Vm.16B + /// int16x8_t vorrq_s16 (int16x8_t a, int16x8_t b) + /// A32: VORR Qd, Qn, Qm + /// A64: ORR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vorrq_s32 (int32x4_t a, int32x4_t b) - /// A32: VORR Qd, Qn, Qm - /// A64: ORR Vd.16B, Vn.16B, Vm.16B + /// int32x4_t vorrq_s32 (int32x4_t a, int32x4_t b) + /// A32: VORR Qd, Qn, Qm + /// A64: ORR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vorrq_s64 (int64x2_t a, int64x2_t b) - /// A32: VORR Qd, Qn, Qm - /// A64: ORR Vd.16B, Vn.16B, Vm.16B + /// int64x2_t vorrq_s64 (int64x2_t a, int64x2_t b) + /// A32: VORR Qd, Qn, Qm + /// A64: ORR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vorrq_s8 (int8x16_t a, int8x16_t b) - /// A32: VORR Qd, Qn, Qm - /// A64: ORR Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vorrq_s8 (int8x16_t a, int8x16_t b) + /// A32: VORR Qd, Qn, Qm + /// A64: ORR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vorrq_f32 (float32x4_t a, float32x4_t b) - /// A32: VORR Qd, Qn, Qm - /// A64: ORR Vd.16B, Vn.16B, Vm.16B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32x4_t vorrq_f32 (float32x4_t a, float32x4_t b) + /// A32: VORR Qd, Qn, Qm + /// A64: ORR Vd.16B, Vn.16B, Vm.16B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vorrq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VORR Qd, Qn, Qm - /// A64: ORR Vd.16B, Vn.16B, Vm.16B + /// uint16x8_t vorrq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VORR Qd, Qn, Qm + /// A64: ORR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vorrq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VORR Qd, Qn, Qm - /// A64: ORR Vd.16B, Vn.16B, Vm.16B + /// uint32x4_t vorrq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VORR Qd, Qn, Qm + /// A64: ORR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vorrq_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VORR Qd, Qn, Qm - /// A64: ORR Vd.16B, Vn.16B, Vm.16B + /// uint64x2_t vorrq_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VORR Qd, Qn, Qm + /// A64: ORR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vorn_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VORN Dd, Dn, Dm - /// A64: ORN Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vorn_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VORN Dd, Dn, Dm + /// A64: ORN Vd.8B, Vn.8B, Vm.8B /// public static Vector64 OrNot(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vorn_f64 (float64x1_t a, float64x1_t b) - /// A32: VORN Dd, Dn, Dm - /// A64: ORN Vd.8B, Vn.8B, Vm.8B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x1_t vorn_f64 (float64x1_t a, float64x1_t b) + /// A32: VORN Dd, Dn, Dm + /// A64: ORN Vd.8B, Vn.8B, Vm.8B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 OrNot(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vorn_s16 (int16x4_t a, int16x4_t b) - /// A32: VORN Dd, Dn, Dm - /// A64: ORN Vd.8B, Vn.8B, Vm.8B + /// int16x4_t vorn_s16 (int16x4_t a, int16x4_t b) + /// A32: VORN Dd, Dn, Dm + /// A64: ORN Vd.8B, Vn.8B, Vm.8B /// public static Vector64 OrNot(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vorn_s32 (int32x2_t a, int32x2_t b) - /// A32: VORN Dd, Dn, Dm - /// A64: ORN Vd.8B, Vn.8B, Vm.8B + /// int32x2_t vorn_s32 (int32x2_t a, int32x2_t b) + /// A32: VORN Dd, Dn, Dm + /// A64: ORN Vd.8B, Vn.8B, Vm.8B /// public static Vector64 OrNot(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vorn_s64 (int64x1_t a, int64x1_t b) - /// A32: VORN Dd, Dn, Dm - /// A64: ORN Vd.8B, Vn.8B, Vm.8B + /// int64x1_t vorn_s64 (int64x1_t a, int64x1_t b) + /// A32: VORN Dd, Dn, Dm + /// A64: ORN Vd.8B, Vn.8B, Vm.8B /// public static Vector64 OrNot(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vorn_s8 (int8x8_t a, int8x8_t b) - /// A32: VORN Dd, Dn, Dm - /// A64: ORN Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vorn_s8 (int8x8_t a, int8x8_t b) + /// A32: VORN Dd, Dn, Dm + /// A64: ORN Vd.8B, Vn.8B, Vm.8B /// public static Vector64 OrNot(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vorn_f32 (float32x2_t a, float32x2_t b) - /// A32: VORN Dd, Dn, Dm - /// A64: ORN Vd.8B, Vn.8B, Vm.8B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32x2_t vorn_f32 (float32x2_t a, float32x2_t b) + /// A32: VORN Dd, Dn, Dm + /// A64: ORN Vd.8B, Vn.8B, Vm.8B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 OrNot(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vorn_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VORN Dd, Dn, Dm - /// A64: ORN Vd.8B, Vn.8B, Vm.8B + /// uint16x4_t vorn_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VORN Dd, Dn, Dm + /// A64: ORN Vd.8B, Vn.8B, Vm.8B /// public static Vector64 OrNot(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vorn_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VORN Dd, Dn, Dm - /// A64: ORN Vd.8B, Vn.8B, Vm.8B + /// uint32x2_t vorn_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VORN Dd, Dn, Dm + /// A64: ORN Vd.8B, Vn.8B, Vm.8B /// public static Vector64 OrNot(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vorn_u64 (uint64x1_t a, uint64x1_t b) - /// A32: VORN Dd, Dn, Dm - /// A64: ORN Vd.8B, Vn.8B, Vm.8B + /// uint64x1_t vorn_u64 (uint64x1_t a, uint64x1_t b) + /// A32: VORN Dd, Dn, Dm + /// A64: ORN Vd.8B, Vn.8B, Vm.8B /// public static Vector64 OrNot(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vornq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VORN Qd, Qn, Qm - /// A64: ORN Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vornq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VORN Qd, Qn, Qm + /// A64: ORN Vd.16B, Vn.16B, Vm.16B /// public static Vector128 OrNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t vornq_f64 (float64x2_t a, float64x2_t b) - /// A32: VORN Qd, Qn, Qm - /// A64: ORN Vd.16B, Vn.16B, Vm.16B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x2_t vornq_f64 (float64x2_t a, float64x2_t b) + /// A32: VORN Qd, Qn, Qm + /// A64: ORN Vd.16B, Vn.16B, Vm.16B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 OrNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vornq_s16 (int16x8_t a, int16x8_t b) - /// A32: VORN Qd, Qn, Qm - /// A64: ORN Vd.16B, Vn.16B, Vm.16B + /// int16x8_t vornq_s16 (int16x8_t a, int16x8_t b) + /// A32: VORN Qd, Qn, Qm + /// A64: ORN Vd.16B, Vn.16B, Vm.16B /// public static Vector128 OrNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vornq_s32 (int32x4_t a, int32x4_t b) - /// A32: VORN Qd, Qn, Qm - /// A64: ORN Vd.16B, Vn.16B, Vm.16B + /// int32x4_t vornq_s32 (int32x4_t a, int32x4_t b) + /// A32: VORN Qd, Qn, Qm + /// A64: ORN Vd.16B, Vn.16B, Vm.16B /// public static Vector128 OrNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vornq_s64 (int64x2_t a, int64x2_t b) - /// A32: VORN Qd, Qn, Qm - /// A64: ORN Vd.16B, Vn.16B, Vm.16B + /// int64x2_t vornq_s64 (int64x2_t a, int64x2_t b) + /// A32: VORN Qd, Qn, Qm + /// A64: ORN Vd.16B, Vn.16B, Vm.16B /// public static Vector128 OrNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vornq_s8 (int8x16_t a, int8x16_t b) - /// A32: VORN Qd, Qn, Qm - /// A64: ORN Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vornq_s8 (int8x16_t a, int8x16_t b) + /// A32: VORN Qd, Qn, Qm + /// A64: ORN Vd.16B, Vn.16B, Vm.16B /// public static Vector128 OrNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vornq_f32 (float32x4_t a, float32x4_t b) - /// A32: VORN Qd, Qn, Qm - /// A64: ORN Vd.16B, Vn.16B, Vm.16B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32x4_t vornq_f32 (float32x4_t a, float32x4_t b) + /// A32: VORN Qd, Qn, Qm + /// A64: ORN Vd.16B, Vn.16B, Vm.16B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 OrNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vornq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VORN Qd, Qn, Qm - /// A64: ORN Vd.16B, Vn.16B, Vm.16B + /// uint16x8_t vornq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VORN Qd, Qn, Qm + /// A64: ORN Vd.16B, Vn.16B, Vm.16B /// public static Vector128 OrNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vornq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VORN Qd, Qn, Qm - /// A64: ORN Vd.16B, Vn.16B, Vm.16B + /// uint32x4_t vornq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VORN Qd, Qn, Qm + /// A64: ORN Vd.16B, Vn.16B, Vm.16B /// public static Vector128 OrNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vornq_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VORN Qd, Qn, Qm - /// A64: ORN Vd.16B, Vn.16B, Vm.16B + /// uint64x2_t vornq_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VORN Qd, Qn, Qm + /// A64: ORN Vd.16B, Vn.16B, Vm.16B /// public static Vector128 OrNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// poly8x8_t vmul_p8 (poly8x8_t a, poly8x8_t b) - /// A32: VMUL.P8 Dd, Dn, Dm - /// A64: PMUL Vd.8B, Vn.8B, Vm.8B + /// poly8x8_t vmul_p8 (poly8x8_t a, poly8x8_t b) + /// A32: VMUL.P8 Dd, Dn, Dm + /// A64: PMUL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 PolynomialMultiply(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// poly8x8_t vmul_p8 (poly8x8_t a, poly8x8_t b) - /// A32: VMUL.P8 Dd, Dn, Dm - /// A64: PMUL Vd.8B, Vn.8B, Vm.8B + /// poly8x8_t vmul_p8 (poly8x8_t a, poly8x8_t b) + /// A32: VMUL.P8 Dd, Dn, Dm + /// A64: PMUL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 PolynomialMultiply(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// poly8x16_t vmulq_p8 (poly8x16_t a, poly8x16_t b) - /// A32: VMUL.P8 Qd, Qn, Qm - /// A64: PMUL Vd.16B, Vn.16B, Vm.16B + /// poly8x16_t vmulq_p8 (poly8x16_t a, poly8x16_t b) + /// A32: VMUL.P8 Qd, Qn, Qm + /// A64: PMUL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 PolynomialMultiply(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// poly8x16_t vmulq_p8 (poly8x16_t a, poly8x16_t b) - /// A32: VMUL.P8 Qd, Qn, Qm - /// A64: PMUL Vd.16B, Vn.16B, Vm.16B + /// poly8x16_t vmulq_p8 (poly8x16_t a, poly8x16_t b) + /// A32: VMUL.P8 Qd, Qn, Qm + /// A64: PMUL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 PolynomialMultiply(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// poly16x8_t vmull_p8 (poly8x8_t a, poly8x8_t b) - /// A32: VMULL.P8 Qd, Dn, Dm - /// A64: PMULL Vd.16B, Vn.8B, Vm.8B + /// poly16x8_t vmull_p8 (poly8x8_t a, poly8x8_t b) + /// A32: VMULL.P8 Qd, Dn, Dm + /// A64: PMULL Vd.16B, Vn.8B, Vm.8B /// public static Vector128 PolynomialMultiplyWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// poly16x8_t vmull_p8 (poly8x8_t a, poly8x8_t b) - /// A32: VMULL.P8 Qd, Dn, Dm - /// A64: PMULL Vd.16B, Vn.8B, Vm.8B + /// poly16x8_t vmull_p8 (poly8x8_t a, poly8x8_t b) + /// A32: VMULL.P8 Qd, Dn, Dm + /// A64: PMULL Vd.16B, Vn.8B, Vm.8B /// public static Vector128 PolynomialMultiplyWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// poly16x8_t vmull_high_p8 (poly8x16_t a, poly8x16_t b) - /// A32: VMULL.P8 Qd, Dn+1, Dm+1 - /// A64: PMULL2 Vd.16B, Vn.16B, Vm.16B + /// poly16x8_t vmull_high_p8 (poly8x16_t a, poly8x16_t b) + /// A32: VMULL.P8 Qd, Dn+1, Dm+1 + /// A64: PMULL2 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 PolynomialMultiplyWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// poly16x8_t vmull_high_p8 (poly8x16_t a, poly8x16_t b) - /// A32: VMULL.P8 Qd, Dn+1, Dm+1 - /// A64: PMULL2 Vd.16B, Vn.16B, Vm.16B + /// poly16x8_t vmull_high_p8 (poly8x16_t a, poly8x16_t b) + /// A32: VMULL.P8 Qd, Dn+1, Dm+1 + /// A64: PMULL2 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 PolynomialMultiplyWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vcnt_u8 (uint8x8_t a) - /// A32: VCNT.I8 Dd, Dm - /// A64: CNT Vd.8B, Vn.8B + /// uint8x8_t vcnt_u8 (uint8x8_t a) + /// A32: VCNT.I8 Dd, Dm + /// A64: CNT Vd.8B, Vn.8B /// public static Vector64 PopCount(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vcnt_s8 (int8x8_t a) - /// A32: VCNT.I8 Dd, Dm - /// A64: CNT Vd.8B, Vn.8B + /// int8x8_t vcnt_s8 (int8x8_t a) + /// A32: VCNT.I8 Dd, Dm + /// A64: CNT Vd.8B, Vn.8B /// public static Vector64 PopCount(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vcntq_u8 (uint8x16_t a) - /// A32: VCNT.I8 Qd, Qm - /// A64: CNT Vd.16B, Vn.16B + /// uint8x16_t vcntq_u8 (uint8x16_t a) + /// A32: VCNT.I8 Qd, Qm + /// A64: CNT Vd.16B, Vn.16B /// public static Vector128 PopCount(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vcntq_s8 (int8x16_t a) - /// A32: VCNT.I8 Qd, Qm - /// A64: CNT Vd.16B, Vn.16B + /// int8x16_t vcntq_s8 (int8x16_t a) + /// A32: VCNT.I8 Qd, Qm + /// A64: CNT Vd.16B, Vn.16B /// public static Vector128 PopCount(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vrecpe_f32 (float32x2_t a) - /// A32: VRECPE.F32 Dd, Dm - /// A64: FRECPE Vd.2S, Vn.2S + /// float32x2_t vrecpe_f32 (float32x2_t a) + /// A32: VRECPE.F32 Dd, Dm + /// A64: FRECPE Vd.2S, Vn.2S /// public static Vector64 ReciprocalEstimate(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vrecpe_u32 (uint32x2_t a) - /// A32: VRECPE.U32 Dd, Dm - /// A64: URECPE Vd.2S, Vn.2S + /// uint32x2_t vrecpe_u32 (uint32x2_t a) + /// A32: VRECPE.U32 Dd, Dm + /// A64: URECPE Vd.2S, Vn.2S /// public static Vector64 ReciprocalEstimate(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vrecpeq_f32 (float32x4_t a) - /// A32: VRECPE.F32 Qd, Qm - /// A64: FRECPE Vd.4S, Vn.4S + /// float32x4_t vrecpeq_f32 (float32x4_t a) + /// A32: VRECPE.F32 Qd, Qm + /// A64: FRECPE Vd.4S, Vn.4S /// public static Vector128 ReciprocalEstimate(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vrecpeq_u32 (uint32x4_t a) - /// A32: VRECPE.U32 Qd, Qm - /// A64: URECPE Vd.4S, Vn.4S + /// uint32x4_t vrecpeq_u32 (uint32x4_t a) + /// A32: VRECPE.U32 Qd, Qm + /// A64: URECPE Vd.4S, Vn.4S /// public static Vector128 ReciprocalEstimate(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vrsqrte_f32 (float32x2_t a) - /// A32: VRSQRTE.F32 Dd, Dm - /// A64: FRSQRTE Vd.2S, Vn.2S + /// float32x2_t vrsqrte_f32 (float32x2_t a) + /// A32: VRSQRTE.F32 Dd, Dm + /// A64: FRSQRTE Vd.2S, Vn.2S /// public static Vector64 ReciprocalSquareRootEstimate(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vrsqrte_u32 (uint32x2_t a) - /// A32: VRSQRTE.U32 Dd, Dm - /// A64: URSQRTE Vd.2S, Vn.2S + /// uint32x2_t vrsqrte_u32 (uint32x2_t a) + /// A32: VRSQRTE.U32 Dd, Dm + /// A64: URSQRTE Vd.2S, Vn.2S /// public static Vector64 ReciprocalSquareRootEstimate(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vrsqrteq_f32 (float32x4_t a) - /// A32: VRSQRTE.F32 Qd, Qm - /// A64: FRSQRTE Vd.4S, Vn.4S + /// float32x4_t vrsqrteq_f32 (float32x4_t a) + /// A32: VRSQRTE.F32 Qd, Qm + /// A64: FRSQRTE Vd.4S, Vn.4S /// public static Vector128 ReciprocalSquareRootEstimate(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vrsqrteq_u32 (uint32x4_t a) - /// A32: VRSQRTE.U32 Qd, Qm - /// A64: URSQRTE Vd.4S, Vn.4S + /// uint32x4_t vrsqrteq_u32 (uint32x4_t a) + /// A32: VRSQRTE.U32 Qd, Qm + /// A64: URSQRTE Vd.4S, Vn.4S /// public static Vector128 ReciprocalSquareRootEstimate(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vrsqrts_f32 (float32x2_t a, float32x2_t b) - /// A32: VRSQRTS.F32 Dd, Dn, Dm - /// A64: FRSQRTS Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vrsqrts_f32 (float32x2_t a, float32x2_t b) + /// A32: VRSQRTS.F32 Dd, Dn, Dm + /// A64: FRSQRTS Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ReciprocalSquareRootStep(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vrsqrtsq_f32 (float32x4_t a, float32x4_t b) - /// A32: VRSQRTS.F32 Qd, Qn, Qm - /// A64: FRSQRTS Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vrsqrtsq_f32 (float32x4_t a, float32x4_t b) + /// A32: VRSQRTS.F32 Qd, Qn, Qm + /// A64: FRSQRTS Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ReciprocalSquareRootStep(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vrecps_f32 (float32x2_t a, float32x2_t b) - /// A32: VRECPS.F32 Dd, Dn, Dm - /// A64: FRECPS Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vrecps_f32 (float32x2_t a, float32x2_t b) + /// A32: VRECPS.F32 Dd, Dn, Dm + /// A64: FRECPS Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ReciprocalStep(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vrecpsq_f32 (float32x4_t a, float32x4_t b) - /// A32: VRECPS.F32 Qd, Qn, Qm - /// A64: FRECPS Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vrecpsq_f32 (float32x4_t a, float32x4_t b) + /// A32: VRECPS.F32 Qd, Qn, Qm + /// A64: FRECPS Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ReciprocalStep(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vrev32_s16 (int16x4_t vec) - /// A32: VREV32.16 Dd, Dm - /// A64: REV32 Vd.4H, Vn.4H + /// int16x4_t vrev32_s16 (int16x4_t vec) + /// A32: VREV32.16 Dd, Dm + /// A64: REV32 Vd.4H, Vn.4H /// public static Vector64 ReverseElement16(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vrev64_s16 (int16x4_t vec) - /// A32: VREV64.16 Dd, Dm - /// A64: REV64 Vd.4H, Vn.4H + /// int16x4_t vrev64_s16 (int16x4_t vec) + /// A32: VREV64.16 Dd, Dm + /// A64: REV64 Vd.4H, Vn.4H /// public static Vector64 ReverseElement16(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vrev32_u16 (uint16x4_t vec) - /// A32: VREV32.16 Dd, Dm - /// A64: REV32 Vd.4H, Vn.4H + /// uint16x4_t vrev32_u16 (uint16x4_t vec) + /// A32: VREV32.16 Dd, Dm + /// A64: REV32 Vd.4H, Vn.4H /// public static Vector64 ReverseElement16(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vrev64_u16 (uint16x4_t vec) - /// A32: VREV64.16 Dd, Dm - /// A64: REV64 Vd.4H, Vn.4H + /// uint16x4_t vrev64_u16 (uint16x4_t vec) + /// A32: VREV64.16 Dd, Dm + /// A64: REV64 Vd.4H, Vn.4H /// public static Vector64 ReverseElement16(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vrev32q_s16 (int16x8_t vec) - /// A32: VREV32.16 Qd, Qm - /// A64: REV32 Vd.8H, Vn.8H + /// int16x8_t vrev32q_s16 (int16x8_t vec) + /// A32: VREV32.16 Qd, Qm + /// A64: REV32 Vd.8H, Vn.8H /// public static Vector128 ReverseElement16(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vrev64q_s16 (int16x8_t vec) - /// A32: VREV64.16 Qd, Qm - /// A64: REV64 Vd.8H, Vn.8H + /// int16x8_t vrev64q_s16 (int16x8_t vec) + /// A32: VREV64.16 Qd, Qm + /// A64: REV64 Vd.8H, Vn.8H /// public static Vector128 ReverseElement16(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vrev32q_u16 (uint16x8_t vec) - /// A32: VREV32.16 Qd, Qm - /// A64: REV32 Vd.8H, Vn.8H + /// uint16x8_t vrev32q_u16 (uint16x8_t vec) + /// A32: VREV32.16 Qd, Qm + /// A64: REV32 Vd.8H, Vn.8H /// public static Vector128 ReverseElement16(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vrev64q_u16 (uint16x8_t vec) - /// A32: VREV64.16 Qd, Qm - /// A64: REV64 Vd.8H, Vn.8H + /// uint16x8_t vrev64q_u16 (uint16x8_t vec) + /// A32: VREV64.16 Qd, Qm + /// A64: REV64 Vd.8H, Vn.8H /// public static Vector128 ReverseElement16(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vrev64_s32 (int32x2_t vec) - /// A32: VREV64.32 Dd, Dm - /// A64: REV64 Vd.2S, Vn.2S + /// int32x2_t vrev64_s32 (int32x2_t vec) + /// A32: VREV64.32 Dd, Dm + /// A64: REV64 Vd.2S, Vn.2S /// public static Vector64 ReverseElement32(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vrev64_u32 (uint32x2_t vec) - /// A32: VREV64.32 Dd, Dm - /// A64: REV64 Vd.2S, Vn.2S + /// uint32x2_t vrev64_u32 (uint32x2_t vec) + /// A32: VREV64.32 Dd, Dm + /// A64: REV64 Vd.2S, Vn.2S /// public static Vector64 ReverseElement32(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vrev64q_s32 (int32x4_t vec) - /// A32: VREV64.32 Qd, Qm - /// A64: REV64 Vd.4S, Vn.4S + /// int32x4_t vrev64q_s32 (int32x4_t vec) + /// A32: VREV64.32 Qd, Qm + /// A64: REV64 Vd.4S, Vn.4S /// public static Vector128 ReverseElement32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vrev64q_u32 (uint32x4_t vec) - /// A32: VREV64.32 Qd, Qm - /// A64: REV64 Vd.4S, Vn.4S + /// uint32x4_t vrev64q_u32 (uint32x4_t vec) + /// A32: VREV64.32 Qd, Qm + /// A64: REV64 Vd.4S, Vn.4S /// public static Vector128 ReverseElement32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vrev16_s8 (int8x8_t vec) - /// A32: VREV16.8 Dd, Dm - /// A64: REV16 Vd.8B, Vn.8B + /// int8x8_t vrev16_s8 (int8x8_t vec) + /// A32: VREV16.8 Dd, Dm + /// A64: REV16 Vd.8B, Vn.8B /// public static Vector64 ReverseElement8(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vrev32_s8 (int8x8_t vec) - /// A32: VREV32.8 Dd, Dm - /// A64: REV32 Vd.8B, Vn.8B + /// int8x8_t vrev32_s8 (int8x8_t vec) + /// A32: VREV32.8 Dd, Dm + /// A64: REV32 Vd.8B, Vn.8B /// public static Vector64 ReverseElement8(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vrev64_s8 (int8x8_t vec) - /// A32: VREV64.8 Dd, Dm - /// A64: REV64 Vd.8B, Vn.8B + /// int8x8_t vrev64_s8 (int8x8_t vec) + /// A32: VREV64.8 Dd, Dm + /// A64: REV64 Vd.8B, Vn.8B /// public static Vector64 ReverseElement8(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vrev16_u8 (uint8x8_t vec) - /// A32: VREV16.8 Dd, Dm - /// A64: REV16 Vd.8B, Vn.8B + /// uint8x8_t vrev16_u8 (uint8x8_t vec) + /// A32: VREV16.8 Dd, Dm + /// A64: REV16 Vd.8B, Vn.8B /// public static Vector64 ReverseElement8(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vrev32_u8 (uint8x8_t vec) - /// A32: VREV32.8 Dd, Dm - /// A64: REV32 Vd.8B, Vn.8B + /// uint8x8_t vrev32_u8 (uint8x8_t vec) + /// A32: VREV32.8 Dd, Dm + /// A64: REV32 Vd.8B, Vn.8B /// public static Vector64 ReverseElement8(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vrev64_u8 (uint8x8_t vec) - /// A32: VREV64.8 Dd, Dm - /// A64: REV64 Vd.8B, Vn.8B + /// uint8x8_t vrev64_u8 (uint8x8_t vec) + /// A32: VREV64.8 Dd, Dm + /// A64: REV64 Vd.8B, Vn.8B /// public static Vector64 ReverseElement8(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vrev16q_s8 (int8x16_t vec) - /// A32: VREV16.8 Qd, Qm - /// A64: REV16 Vd.16B, Vn.16B + /// int8x16_t vrev16q_s8 (int8x16_t vec) + /// A32: VREV16.8 Qd, Qm + /// A64: REV16 Vd.16B, Vn.16B /// public static Vector128 ReverseElement8(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vrev32q_s8 (int8x16_t vec) - /// A32: VREV32.8 Qd, Qm - /// A64: REV32 Vd.16B, Vn.16B + /// int8x16_t vrev32q_s8 (int8x16_t vec) + /// A32: VREV32.8 Qd, Qm + /// A64: REV32 Vd.16B, Vn.16B /// public static Vector128 ReverseElement8(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vrev64q_s8 (int8x16_t vec) - /// A32: VREV64.8 Qd, Qm - /// A64: REV64 Vd.16B, Vn.16B + /// int8x16_t vrev64q_s8 (int8x16_t vec) + /// A32: VREV64.8 Qd, Qm + /// A64: REV64 Vd.16B, Vn.16B /// public static Vector128 ReverseElement8(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vrev16q_u8 (uint8x16_t vec) - /// A32: VREV16.8 Qd, Qm - /// A64: REV16 Vd.16B, Vn.16B + /// uint8x16_t vrev16q_u8 (uint8x16_t vec) + /// A32: VREV16.8 Qd, Qm + /// A64: REV16 Vd.16B, Vn.16B /// public static Vector128 ReverseElement8(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vrev32q_u8 (uint8x16_t vec) - /// A32: VREV32.8 Qd, Qm - /// A64: REV32 Vd.16B, Vn.16B + /// uint8x16_t vrev32q_u8 (uint8x16_t vec) + /// A32: VREV32.8 Qd, Qm + /// A64: REV32 Vd.16B, Vn.16B /// public static Vector128 ReverseElement8(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vrev64q_u8 (uint8x16_t vec) - /// A32: VREV64.8 Qd, Qm - /// A64: REV64 Vd.16B, Vn.16B + /// uint8x16_t vrev64q_u8 (uint8x16_t vec) + /// A32: VREV64.8 Qd, Qm + /// A64: REV64 Vd.16B, Vn.16B /// public static Vector128 ReverseElement8(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vrnda_f32 (float32x2_t a) - /// A32: VRINTA.F32 Dd, Dm - /// A64: FRINTA Vd.2S, Vn.2S + /// float32x2_t vrnda_f32 (float32x2_t a) + /// A32: VRINTA.F32 Dd, Dm + /// A64: FRINTA Vd.2S, Vn.2S /// public static Vector64 RoundAwayFromZero(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vrndaq_f32 (float32x4_t a) - /// A32: VRINTA.F32 Qd, Qm - /// A64: FRINTA Vd.4S, Vn.4S + /// float32x4_t vrndaq_f32 (float32x4_t a) + /// A32: VRINTA.F32 Qd, Qm + /// A64: FRINTA Vd.4S, Vn.4S /// public static Vector128 RoundAwayFromZero(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vrnda_f64 (float64x1_t a) - /// A32: VRINTA.F64 Dd, Dm - /// A64: FRINTA Dd, Dn + /// float64x1_t vrnda_f64 (float64x1_t a) + /// A32: VRINTA.F64 Dd, Dm + /// A64: FRINTA Dd, Dn /// public static Vector64 RoundAwayFromZeroScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32_t vrndas_f32 (float32_t a) - /// A32: VRINTA.F32 Sd, Sm - /// A64: FRINTA Sd, Sn - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vrndas_f32 (float32_t a) + /// A32: VRINTA.F32 Sd, Sm + /// A64: FRINTA Sd, Sn + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 RoundAwayFromZeroScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vrndn_f32 (float32x2_t a) - /// A32: VRINTN.F32 Dd, Dm - /// A64: FRINTN Vd.2S, Vn.2S + /// float32x2_t vrndn_f32 (float32x2_t a) + /// A32: VRINTN.F32 Dd, Dm + /// A64: FRINTN Vd.2S, Vn.2S /// public static Vector64 RoundToNearest(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vrndnq_f32 (float32x4_t a) - /// A32: VRINTN.F32 Qd, Qm - /// A64: FRINTN Vd.4S, Vn.4S + /// float32x4_t vrndnq_f32 (float32x4_t a) + /// A32: VRINTN.F32 Qd, Qm + /// A64: FRINTN Vd.4S, Vn.4S /// public static Vector128 RoundToNearest(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vrndn_f64 (float64x1_t a) - /// A32: VRINTN.F64 Dd, Dm - /// A64: FRINTN Dd, Dn + /// float64x1_t vrndn_f64 (float64x1_t a) + /// A32: VRINTN.F64 Dd, Dm + /// A64: FRINTN Dd, Dn /// public static Vector64 RoundToNearestScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32_t vrndns_f32 (float32_t a) - /// A32: VRINTN.F32 Sd, Sm - /// A64: FRINTN Sd, Sn - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vrndns_f32 (float32_t a) + /// A32: VRINTN.F32 Sd, Sm + /// A64: FRINTN Sd, Sn + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 RoundToNearestScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vrndm_f32 (float32x2_t a) - /// A32: VRINTM.F32 Dd, Dm - /// A64: FRINTM Vd.2S, Vn.2S + /// float32x2_t vrndm_f32 (float32x2_t a) + /// A32: VRINTM.F32 Dd, Dm + /// A64: FRINTM Vd.2S, Vn.2S /// public static Vector64 RoundToNegativeInfinity(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vrndmq_f32 (float32x4_t a) - /// A32: VRINTM.F32 Qd, Qm - /// A64: FRINTM Vd.4S, Vn.4S + /// float32x4_t vrndmq_f32 (float32x4_t a) + /// A32: VRINTM.F32 Qd, Qm + /// A64: FRINTM Vd.4S, Vn.4S /// public static Vector128 RoundToNegativeInfinity(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vrndm_f64 (float64x1_t a) - /// A32: VRINTM.F64 Dd, Dm - /// A64: FRINTM Dd, Dn + /// float64x1_t vrndm_f64 (float64x1_t a) + /// A32: VRINTM.F64 Dd, Dm + /// A64: FRINTM Dd, Dn /// public static Vector64 RoundToNegativeInfinityScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32_t vrndms_f32 (float32_t a) - /// A32: VRINTM.F32 Sd, Sm - /// A64: FRINTM Sd, Sn - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vrndms_f32 (float32_t a) + /// A32: VRINTM.F32 Sd, Sm + /// A64: FRINTM Sd, Sn + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 RoundToNegativeInfinityScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vrndp_f32 (float32x2_t a) - /// A32: VRINTP.F32 Dd, Dm - /// A64: FRINTP Vd.2S, Vn.2S + /// float32x2_t vrndp_f32 (float32x2_t a) + /// A32: VRINTP.F32 Dd, Dm + /// A64: FRINTP Vd.2S, Vn.2S /// public static Vector64 RoundToPositiveInfinity(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vrndpq_f32 (float32x4_t a) - /// A32: VRINTP.F32 Qd, Qm - /// A64: FRINTP Vd.4S, Vn.4S + /// float32x4_t vrndpq_f32 (float32x4_t a) + /// A32: VRINTP.F32 Qd, Qm + /// A64: FRINTP Vd.4S, Vn.4S /// public static Vector128 RoundToPositiveInfinity(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vrndp_f64 (float64x1_t a) - /// A32: VRINTP.F64 Dd, Dm - /// A64: FRINTP Dd, Dn + /// float64x1_t vrndp_f64 (float64x1_t a) + /// A32: VRINTP.F64 Dd, Dm + /// A64: FRINTP Dd, Dn /// public static Vector64 RoundToPositiveInfinityScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32_t vrndps_f32 (float32_t a) - /// A32: VRINTP.F32 Sd, Sm - /// A64: FRINTP Sd, Sn - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vrndps_f32 (float32_t a) + /// A32: VRINTP.F32 Sd, Sm + /// A64: FRINTP Sd, Sn + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 RoundToPositiveInfinityScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vrnd_f32 (float32x2_t a) - /// A32: VRINTZ.F32 Dd, Dm - /// A64: FRINTZ Vd.2S, Vn.2S + /// float32x2_t vrnd_f32 (float32x2_t a) + /// A32: VRINTZ.F32 Dd, Dm + /// A64: FRINTZ Vd.2S, Vn.2S /// public static Vector64 RoundToZero(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vrndq_f32 (float32x4_t a) - /// A32: VRINTZ.F32 Qd, Qm - /// A64: FRINTZ Vd.4S, Vn.4S + /// float32x4_t vrndq_f32 (float32x4_t a) + /// A32: VRINTZ.F32 Qd, Qm + /// A64: FRINTZ Vd.4S, Vn.4S /// public static Vector128 RoundToZero(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vrnd_f64 (float64x1_t a) - /// A32: VRINTZ.F64 Dd, Dm - /// A64: FRINTZ Dd, Dn + /// float64x1_t vrnd_f64 (float64x1_t a) + /// A32: VRINTZ.F64 Dd, Dm + /// A64: FRINTZ Dd, Dn /// public static Vector64 RoundToZeroScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32_t vrnds_f32 (float32_t a) - /// A32: VRINTZ.F32 Sd, Sm - /// A64: FRINTZ Sd, Sn - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vrnds_f32 (float32_t a) + /// A32: VRINTZ.F32 Sd, Sm + /// A64: FRINTZ Sd, Sn + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 RoundToZeroScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vshl_s16 (int16x4_t a, int16x4_t b) - /// A32: VSHL.S16 Dd, Dn, Dm - /// A64: SSHL Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vshl_s16 (int16x4_t a, int16x4_t b) + /// A32: VSHL.S16 Dd, Dn, Dm + /// A64: SSHL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ShiftArithmetic(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vshl_s32 (int32x2_t a, int32x2_t b) - /// A32: VSHL.S32 Dd, Dn, Dm - /// A64: SSHL Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vshl_s32 (int32x2_t a, int32x2_t b) + /// A32: VSHL.S32 Dd, Dn, Dm + /// A64: SSHL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ShiftArithmetic(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vshl_s8 (int8x8_t a, int8x8_t b) - /// A32: VSHL.S8 Dd, Dn, Dm - /// A64: SSHL Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vshl_s8 (int8x8_t a, int8x8_t b) + /// A32: VSHL.S8 Dd, Dn, Dm + /// A64: SSHL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ShiftArithmetic(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vshlq_s16 (int16x8_t a, int16x8_t b) - /// A32: VSHL.S16 Qd, Qn, Qm - /// A64: SSHL Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vshlq_s16 (int16x8_t a, int16x8_t b) + /// A32: VSHL.S16 Qd, Qn, Qm + /// A64: SSHL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ShiftArithmetic(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vshlq_s32 (int32x4_t a, int32x4_t b) - /// A32: VSHL.S32 Qd, Qn, Qm - /// A64: SSHL Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vshlq_s32 (int32x4_t a, int32x4_t b) + /// A32: VSHL.S32 Qd, Qn, Qm + /// A64: SSHL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ShiftArithmetic(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vshlq_s64 (int64x2_t a, int64x2_t b) - /// A32: VSHL.S64 Qd, Qn, Qm - /// A64: SSHL Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vshlq_s64 (int64x2_t a, int64x2_t b) + /// A32: VSHL.S64 Qd, Qn, Qm + /// A64: SSHL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ShiftArithmetic(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vshlq_s8 (int8x16_t a, int8x16_t b) - /// A32: VSHL.S8 Qd, Qn, Qm - /// A64: SSHL Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vshlq_s8 (int8x16_t a, int8x16_t b) + /// A32: VSHL.S8 Qd, Qn, Qm + /// A64: SSHL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ShiftArithmetic(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vrshl_s16 (int16x4_t a, int16x4_t b) - /// A32: VRSHL.S16 Dd, Dn, Dm - /// A64: SRSHL Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vrshl_s16 (int16x4_t a, int16x4_t b) + /// A32: VRSHL.S16 Dd, Dn, Dm + /// A64: SRSHL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ShiftArithmeticRounded(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vrshl_s32 (int32x2_t a, int32x2_t b) - /// A32: VRSHL.S32 Dd, Dn, Dm - /// A64: SRSHL Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vrshl_s32 (int32x2_t a, int32x2_t b) + /// A32: VRSHL.S32 Dd, Dn, Dm + /// A64: SRSHL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ShiftArithmeticRounded(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vrshl_s8 (int8x8_t a, int8x8_t b) - /// A32: VRSHL.S8 Dd, Dn, Dm - /// A64: SRSHL Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vrshl_s8 (int8x8_t a, int8x8_t b) + /// A32: VRSHL.S8 Dd, Dn, Dm + /// A64: SRSHL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ShiftArithmeticRounded(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vrshlq_s16 (int16x8_t a, int16x8_t b) - /// A32: VRSHL.S16 Qd, Qn, Qm - /// A64: SRSHL Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vrshlq_s16 (int16x8_t a, int16x8_t b) + /// A32: VRSHL.S16 Qd, Qn, Qm + /// A64: SRSHL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ShiftArithmeticRounded(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vrshlq_s32 (int32x4_t a, int32x4_t b) - /// A32: VRSHL.S32 Qd, Qn, Qm - /// A64: SRSHL Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vrshlq_s32 (int32x4_t a, int32x4_t b) + /// A32: VRSHL.S32 Qd, Qn, Qm + /// A64: SRSHL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ShiftArithmeticRounded(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vrshlq_s64 (int64x2_t a, int64x2_t b) - /// A32: VRSHL.S64 Qd, Qn, Qm - /// A64: SRSHL Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vrshlq_s64 (int64x2_t a, int64x2_t b) + /// A32: VRSHL.S64 Qd, Qn, Qm + /// A64: SRSHL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ShiftArithmeticRounded(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vrshlq_s8 (int8x16_t a, int8x16_t b) - /// A32: VRSHL.S8 Qd, Qn, Qm - /// A64: SRSHL Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vrshlq_s8 (int8x16_t a, int8x16_t b) + /// A32: VRSHL.S8 Qd, Qn, Qm + /// A64: SRSHL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ShiftArithmeticRounded(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vqrshl_s16 (int16x4_t a, int16x4_t b) - /// A32: VQRSHL.S16 Dd, Dn, Dm - /// A64: SQRSHL Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vqrshl_s16 (int16x4_t a, int16x4_t b) + /// A32: VQRSHL.S16 Dd, Dn, Dm + /// A64: SQRSHL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ShiftArithmeticRoundedSaturate(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vqrshl_s32 (int32x2_t a, int32x2_t b) - /// A32: VQRSHL.S32 Dd, Dn, Dm - /// A64: SQRSHL Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vqrshl_s32 (int32x2_t a, int32x2_t b) + /// A32: VQRSHL.S32 Dd, Dn, Dm + /// A64: SQRSHL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ShiftArithmeticRoundedSaturate(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vqrshl_s8 (int8x8_t a, int8x8_t b) - /// A32: VQRSHL.S8 Dd, Dn, Dm - /// A64: SQRSHL Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vqrshl_s8 (int8x8_t a, int8x8_t b) + /// A32: VQRSHL.S8 Dd, Dn, Dm + /// A64: SQRSHL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ShiftArithmeticRoundedSaturate(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vqrshlq_s16 (int16x8_t a, int16x8_t b) - /// A32: VQRSHL.S16 Qd, Qn, Qm - /// A64: SQRSHL Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vqrshlq_s16 (int16x8_t a, int16x8_t b) + /// A32: VQRSHL.S16 Qd, Qn, Qm + /// A64: SQRSHL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ShiftArithmeticRoundedSaturate(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqrshlq_s32 (int32x4_t a, int32x4_t b) - /// A32: VQRSHL.S32 Qd, Qn, Qm - /// A64: SQRSHL Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vqrshlq_s32 (int32x4_t a, int32x4_t b) + /// A32: VQRSHL.S32 Qd, Qn, Qm + /// A64: SQRSHL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ShiftArithmeticRoundedSaturate(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqrshlq_s64 (int64x2_t a, int64x2_t b) - /// A32: VQRSHL.S64 Qd, Qn, Qm - /// A64: SQRSHL Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vqrshlq_s64 (int64x2_t a, int64x2_t b) + /// A32: VQRSHL.S64 Qd, Qn, Qm + /// A64: SQRSHL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ShiftArithmeticRoundedSaturate(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vqrshlq_s8 (int8x16_t a, int8x16_t b) - /// A32: VQRSHL.S8 Qd, Qn, Qm - /// A64: SQRSHL Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vqrshlq_s8 (int8x16_t a, int8x16_t b) + /// A32: VQRSHL.S8 Qd, Qn, Qm + /// A64: SQRSHL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ShiftArithmeticRoundedSaturate(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vqrshl_s64 (int64x1_t a, int64x1_t b) - /// A32: VQRSHL.S64 Dd, Dn, Dm - /// A64: SQRSHL Dd, Dn, Dm + /// int64x1_t vqrshl_s64 (int64x1_t a, int64x1_t b) + /// A32: VQRSHL.S64 Dd, Dn, Dm + /// A64: SQRSHL Dd, Dn, Dm /// public static Vector64 ShiftArithmeticRoundedSaturateScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vrshl_s64 (int64x1_t a, int64x1_t b) - /// A32: VRSHL.S64 Dd, Dn, Dm - /// A64: SRSHL Dd, Dn, Dm + /// int64x1_t vrshl_s64 (int64x1_t a, int64x1_t b) + /// A32: VRSHL.S64 Dd, Dn, Dm + /// A64: SRSHL Dd, Dn, Dm /// public static Vector64 ShiftArithmeticRoundedScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vqshl_s16 (int16x4_t a, int16x4_t b) - /// A32: VQSHL.S16 Dd, Dn, Dm - /// A64: SQSHL Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vqshl_s16 (int16x4_t a, int16x4_t b) + /// A32: VQSHL.S16 Dd, Dn, Dm + /// A64: SQSHL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ShiftArithmeticSaturate(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vqshl_s32 (int32x2_t a, int32x2_t b) - /// A32: VQSHL.S32 Dd, Dn, Dm - /// A64: SQSHL Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vqshl_s32 (int32x2_t a, int32x2_t b) + /// A32: VQSHL.S32 Dd, Dn, Dm + /// A64: SQSHL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ShiftArithmeticSaturate(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vqshl_s8 (int8x8_t a, int8x8_t b) - /// A32: VQSHL.S8 Dd, Dn, Dm - /// A64: SQSHL Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vqshl_s8 (int8x8_t a, int8x8_t b) + /// A32: VQSHL.S8 Dd, Dn, Dm + /// A64: SQSHL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ShiftArithmeticSaturate(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vqshlq_s16 (int16x8_t a, int16x8_t b) - /// A32: VQSHL.S16 Qd, Qn, Qm - /// A64: SQSHL Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vqshlq_s16 (int16x8_t a, int16x8_t b) + /// A32: VQSHL.S16 Qd, Qn, Qm + /// A64: SQSHL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ShiftArithmeticSaturate(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqshlq_s32 (int32x4_t a, int32x4_t b) - /// A32: VQSHL.S32 Qd, Qn, Qm - /// A64: SQSHL Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vqshlq_s32 (int32x4_t a, int32x4_t b) + /// A32: VQSHL.S32 Qd, Qn, Qm + /// A64: SQSHL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ShiftArithmeticSaturate(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqshlq_s64 (int64x2_t a, int64x2_t b) - /// A32: VQSHL.S64 Qd, Qn, Qm - /// A64: SQSHL Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vqshlq_s64 (int64x2_t a, int64x2_t b) + /// A32: VQSHL.S64 Qd, Qn, Qm + /// A64: SQSHL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ShiftArithmeticSaturate(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vqshlq_s8 (int8x16_t a, int8x16_t b) - /// A32: VQSHL.S8 Qd, Qn, Qm - /// A64: SQSHL Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vqshlq_s8 (int8x16_t a, int8x16_t b) + /// A32: VQSHL.S8 Qd, Qn, Qm + /// A64: SQSHL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ShiftArithmeticSaturate(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vqshl_s64 (int64x1_t a, int64x1_t b) - /// A32: VQSHL.S64 Dd, Dn, Dm - /// A64: SQSHL Dd, Dn, Dm + /// int64x1_t vqshl_s64 (int64x1_t a, int64x1_t b) + /// A32: VQSHL.S64 Dd, Dn, Dm + /// A64: SQSHL Dd, Dn, Dm /// public static Vector64 ShiftArithmeticSaturateScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vshl_s64 (int64x1_t a, int64x1_t b) - /// A32: VSHL.S64 Dd, Dn, Dm - /// A64: SSHL Dd, Dn, Dm + /// int64x1_t vshl_s64 (int64x1_t a, int64x1_t b) + /// A32: VSHL.S64 Dd, Dn, Dm + /// A64: SSHL Dd, Dn, Dm /// public static Vector64 ShiftArithmeticScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vsli_n_u8(uint8x8_t a, uint8x8_t b, __builtin_constant_p(n)) - /// A32: VSLI.8 Dd, Dm, #n - /// A64: SLI Vd.8B, Vn.8B, #n + /// uint8x8_t vsli_n_u8(uint8x8_t a, uint8x8_t b, __builtin_constant_p(n)) + /// A32: VSLI.8 Dd, Dm, #n + /// A64: SLI Vd.8B, Vn.8B, #n /// public static Vector64 ShiftLeftAndInsert(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(7))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vsli_n_s16(int16x4_t a, int16x4_t b, __builtin_constant_p(n)) - /// A32: VSLI.16 Dd, Dm, #n - /// A64: SLI Vd.4H, Vn.4H, #n + /// int16x4_t vsli_n_s16(int16x4_t a, int16x4_t b, __builtin_constant_p(n)) + /// A32: VSLI.16 Dd, Dm, #n + /// A64: SLI Vd.4H, Vn.4H, #n /// public static Vector64 ShiftLeftAndInsert(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vsli_n_s32(int32x2_t a, int32x2_t b, __builtin_constant_p(n)) - /// A32: VSLI.32 Dd, Dm, #n - /// A64: SLI Vd.2S, Vn.2S, #n + /// int32x2_t vsli_n_s32(int32x2_t a, int32x2_t b, __builtin_constant_p(n)) + /// A32: VSLI.32 Dd, Dm, #n + /// A64: SLI Vd.2S, Vn.2S, #n /// public static Vector64 ShiftLeftAndInsert(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vsli_n_s8(int8x8_t a, int8x8_t b, __builtin_constant_p(n)) - /// A32: VSLI.8 Dd, Dm, #n - /// A64: SLI Vd.8B, Vn.8B, #n + /// int8x8_t vsli_n_s8(int8x8_t a, int8x8_t b, __builtin_constant_p(n)) + /// A32: VSLI.8 Dd, Dm, #n + /// A64: SLI Vd.8B, Vn.8B, #n /// public static Vector64 ShiftLeftAndInsert(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(7))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vsli_n_u16(uint16x4_t a, uint16x4_t b, __builtin_constant_p(n)) - /// A32: VSLI.16 Dd, Dm, #n - /// A64: SLI Vd.4H, Vn.4H, #n + /// uint16x4_t vsli_n_u16(uint16x4_t a, uint16x4_t b, __builtin_constant_p(n)) + /// A32: VSLI.16 Dd, Dm, #n + /// A64: SLI Vd.4H, Vn.4H, #n /// public static Vector64 ShiftLeftAndInsert(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vsli_n_u32(uint32x2_t a, uint32x2_t b, __builtin_constant_p(n)) - /// A32: VSLI.32 Dd, Dm, #n - /// A64: SLI Vd.2S, Vn.2S, #n + /// uint32x2_t vsli_n_u32(uint32x2_t a, uint32x2_t b, __builtin_constant_p(n)) + /// A32: VSLI.32 Dd, Dm, #n + /// A64: SLI Vd.2S, Vn.2S, #n /// public static Vector64 ShiftLeftAndInsert(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vsliq_n_u8(uint8x16_t a, uint8x16_t b, __builtin_constant_p(n)) - /// A32: VSLI.8 Qd, Qm, #n - /// A64: SLI Vd.16B, Vn.16B, #n + /// uint8x16_t vsliq_n_u8(uint8x16_t a, uint8x16_t b, __builtin_constant_p(n)) + /// A32: VSLI.8 Qd, Qm, #n + /// A64: SLI Vd.16B, Vn.16B, #n /// public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vsliq_n_s16(int16x8_t a, int16x8_t b, __builtin_constant_p(n)) - /// A32: VSLI.16 Qd, Qm, #n - /// A64: SLI Vd.8H, Vn.8H, #n + /// int16x8_t vsliq_n_s16(int16x8_t a, int16x8_t b, __builtin_constant_p(n)) + /// A32: VSLI.16 Qd, Qm, #n + /// A64: SLI Vd.8H, Vn.8H, #n /// public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vsliq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n)) - /// A32: VSLI.32 Qd, Qm, #n - /// A64: SLI Vd.4S, Vn.4S, #n + /// int32x4_t vsliq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n)) + /// A32: VSLI.32 Qd, Qm, #n + /// A64: SLI Vd.4S, Vn.4S, #n /// public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vsliq_n_s64(int64x2_t a, int64x2_t b, __builtin_constant_p(n)) - /// A32: VSLI.64 Qd, Qm, #n - /// A64: SLI Vd.2D, Vn.2D, #n + /// int64x2_t vsliq_n_s64(int64x2_t a, int64x2_t b, __builtin_constant_p(n)) + /// A32: VSLI.64 Qd, Qm, #n + /// A64: SLI Vd.2D, Vn.2D, #n /// public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vsliq_n_s8(int8x16_t a, int8x16_t b, __builtin_constant_p(n)) - /// A32: VSLI.8 Qd, Qm, #n - /// A64: SLI Vd.16B, Vn.16B, #n + /// int8x16_t vsliq_n_s8(int8x16_t a, int8x16_t b, __builtin_constant_p(n)) + /// A32: VSLI.8 Qd, Qm, #n + /// A64: SLI Vd.16B, Vn.16B, #n /// public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vsliq_n_u16(uint16x8_t a, uint16x8_t b, __builtin_constant_p(n)) - /// A32: VSLI.16 Qd, Qm, #n - /// A64: SLI Vd.8H, Vn.8H, #n + /// uint16x8_t vsliq_n_u16(uint16x8_t a, uint16x8_t b, __builtin_constant_p(n)) + /// A32: VSLI.16 Qd, Qm, #n + /// A64: SLI Vd.8H, Vn.8H, #n /// public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(15))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vsliq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n)) - /// A32: VSLI.32 Qd, Qm, #n - /// A64: SLI Vd.4S, Vn.4S, #n + /// uint32x4_t vsliq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n)) + /// A32: VSLI.32 Qd, Qm, #n + /// A64: SLI Vd.4S, Vn.4S, #n /// public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(31))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vsliq_n_u64(uint64x2_t a, uint64x2_t b, __builtin_constant_p(n)) - /// A32: VSLI.64 Qd, Qm, #n - /// A64: SLI Vd.2D, Vn.2D, #n + /// uint64x2_t vsliq_n_u64(uint64x2_t a, uint64x2_t b, __builtin_constant_p(n)) + /// A32: VSLI.64 Qd, Qm, #n + /// A64: SLI Vd.2D, Vn.2D, #n /// public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// int64_t vslid_n_s64(int64_t a, int64_t b, __builtin_constant_p(n)) - /// A32: VSLI.64 Dd, Dm, #n - /// A64: SLI Dd, Dn, #n + /// int64_t vslid_n_s64(int64_t a, int64_t b, __builtin_constant_p(n)) + /// A32: VSLI.64 Dd, Dm, #n + /// A64: SLI Dd, Dn, #n /// public static Vector64 ShiftLeftAndInsertScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// uint64_t vslid_n_u64(uint64_t a, uint64_t b, __builtin_constant_p(n)) - /// A32: VSLI.64 Dd, Dm, #n - /// A64: SLI Dd, Dn, #n + /// uint64_t vslid_n_u64(uint64_t a, uint64_t b, __builtin_constant_p(n)) + /// A32: VSLI.64 Dd, Dm, #n + /// A64: SLI Dd, Dn, #n /// public static Vector64 ShiftLeftAndInsertScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(63))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vshl_n_u8 (uint8x8_t a, const int n) - /// A32: VSHL.I8 Dd, Dm, #n - /// A64: SHL Vd.8B, Vn.8B, #n + /// uint8x8_t vshl_n_u8 (uint8x8_t a, const int n) + /// A32: VSHL.I8 Dd, Dm, #n + /// A64: SHL Vd.8B, Vn.8B, #n /// public static Vector64 ShiftLeftLogical(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vshl_n_s16 (int16x4_t a, const int n) - /// A32: VSHL.I16 Dd, Dm, #n - /// A64: SHL Vd.4H, Vn.4H, #n + /// int16x4_t vshl_n_s16 (int16x4_t a, const int n) + /// A32: VSHL.I16 Dd, Dm, #n + /// A64: SHL Vd.4H, Vn.4H, #n /// public static Vector64 ShiftLeftLogical(Vector64 value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vshl_n_s32 (int32x2_t a, const int n) - /// A32: VSHL.I32 Dd, Dm, #n - /// A64: SHL Vd.2S, Vn.2S, #n + /// int32x2_t vshl_n_s32 (int32x2_t a, const int n) + /// A32: VSHL.I32 Dd, Dm, #n + /// A64: SHL Vd.2S, Vn.2S, #n /// public static Vector64 ShiftLeftLogical(Vector64 value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vshl_n_s8 (int8x8_t a, const int n) - /// A32: VSHL.I8 Dd, Dm, #n - /// A64: SHL Vd.8B, Vn.8B, #n + /// int8x8_t vshl_n_s8 (int8x8_t a, const int n) + /// A32: VSHL.I8 Dd, Dm, #n + /// A64: SHL Vd.8B, Vn.8B, #n /// public static Vector64 ShiftLeftLogical(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vshl_n_u16 (uint16x4_t a, const int n) - /// A32: VSHL.I16 Dd, Dm, #n - /// A64: SHL Vd.4H, Vn.4H, #n + /// uint16x4_t vshl_n_u16 (uint16x4_t a, const int n) + /// A32: VSHL.I16 Dd, Dm, #n + /// A64: SHL Vd.4H, Vn.4H, #n /// public static Vector64 ShiftLeftLogical(Vector64 value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vshl_n_u32 (uint32x2_t a, const int n) - /// A32: VSHL.I32 Dd, Dm, #n - /// A64: SHL Vd.2S, Vn.2S, #n + /// uint32x2_t vshl_n_u32 (uint32x2_t a, const int n) + /// A32: VSHL.I32 Dd, Dm, #n + /// A64: SHL Vd.2S, Vn.2S, #n /// public static Vector64 ShiftLeftLogical(Vector64 value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vshlq_n_u8 (uint8x16_t a, const int n) - /// A32: VSHL.I8 Qd, Qm, #n - /// A64: SHL Vd.16B, Vn.16B, #n + /// uint8x16_t vshlq_n_u8 (uint8x16_t a, const int n) + /// A32: VSHL.I8 Qd, Qm, #n + /// A64: SHL Vd.16B, Vn.16B, #n /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vshlq_n_s16 (int16x8_t a, const int n) - /// A32: VSHL.I16 Qd, Qm, #n - /// A64: SHL Vd.8H, Vn.8H, #n + /// int16x8_t vshlq_n_s16 (int16x8_t a, const int n) + /// A32: VSHL.I16 Qd, Qm, #n + /// A64: SHL Vd.8H, Vn.8H, #n /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vshlq_n_s64 (int64x2_t a, const int n) - /// A32: VSHL.I64 Qd, Qm, #n - /// A64: SHL Vd.2D, Vn.2D, #n + /// int64x2_t vshlq_n_s64 (int64x2_t a, const int n) + /// A32: VSHL.I64 Qd, Qm, #n + /// A64: SHL Vd.2D, Vn.2D, #n /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vshlq_n_s8 (int8x16_t a, const int n) - /// A32: VSHL.I8 Qd, Qm, #n - /// A64: SHL Vd.16B, Vn.16B, #n + /// int8x16_t vshlq_n_s8 (int8x16_t a, const int n) + /// A32: VSHL.I8 Qd, Qm, #n + /// A64: SHL Vd.16B, Vn.16B, #n /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vshlq_n_u16 (uint16x8_t a, const int n) - /// A32: VSHL.I16 Qd, Qm, #n - /// A64: SHL Vd.8H, Vn.8H, #n + /// uint16x8_t vshlq_n_u16 (uint16x8_t a, const int n) + /// A32: VSHL.I16 Qd, Qm, #n + /// A64: SHL Vd.8H, Vn.8H, #n /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vshlq_n_u32 (uint32x4_t a, const int n) - /// A32: VSHL.I32 Qd, Qm, #n - /// A64: SHL Vd.4S, Vn.4S, #n + /// uint32x4_t vshlq_n_u32 (uint32x4_t a, const int n) + /// A32: VSHL.I32 Qd, Qm, #n + /// A64: SHL Vd.4S, Vn.4S, #n /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vshlq_n_u64 (uint64x2_t a, const int n) - /// A32: VSHL.I64 Qd, Qm, #n - /// A64: SHL Vd.2D, Vn.2D, #n + /// uint64x2_t vshlq_n_u64 (uint64x2_t a, const int n) + /// A32: VSHL.I64 Qd, Qm, #n + /// A64: SHL Vd.2D, Vn.2D, #n /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vqshl_n_u8 (uint8x8_t a, const int n) - /// A32: VQSHL.U8 Dd, Dm, #n - /// A64: UQSHL Vd.8B, Vn.8B, #n + /// uint8x8_t vqshl_n_u8 (uint8x8_t a, const int n) + /// A32: VQSHL.U8 Dd, Dm, #n + /// A64: UQSHL Vd.8B, Vn.8B, #n /// public static Vector64 ShiftLeftLogicalSaturate(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vqshl_n_s16 (int16x4_t a, const int n) - /// A32: VQSHL.S16 Dd, Dm, #n - /// A64: SQSHL Vd.4H, Vn.4H, #n + /// int16x4_t vqshl_n_s16 (int16x4_t a, const int n) + /// A32: VQSHL.S16 Dd, Dm, #n + /// A64: SQSHL Vd.4H, Vn.4H, #n /// public static Vector64 ShiftLeftLogicalSaturate(Vector64 value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vqshl_n_s32 (int32x2_t a, const int n) - /// A32: VQSHL.S32 Dd, Dm, #n - /// A64: SQSHL Vd.2S, Vn.2S, #n + /// int32x2_t vqshl_n_s32 (int32x2_t a, const int n) + /// A32: VQSHL.S32 Dd, Dm, #n + /// A64: SQSHL Vd.2S, Vn.2S, #n /// public static Vector64 ShiftLeftLogicalSaturate(Vector64 value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vqshl_n_s8 (int8x8_t a, const int n) - /// A32: VQSHL.S8 Dd, Dm, #n - /// A64: SQSHL Vd.8B, Vn.8B, #n + /// int8x8_t vqshl_n_s8 (int8x8_t a, const int n) + /// A32: VQSHL.S8 Dd, Dm, #n + /// A64: SQSHL Vd.8B, Vn.8B, #n /// public static Vector64 ShiftLeftLogicalSaturate(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vqshl_n_u16 (uint16x4_t a, const int n) - /// A32: VQSHL.U16 Dd, Dm, #n - /// A64: UQSHL Vd.4H, Vn.4H, #n + /// uint16x4_t vqshl_n_u16 (uint16x4_t a, const int n) + /// A32: VQSHL.U16 Dd, Dm, #n + /// A64: UQSHL Vd.4H, Vn.4H, #n /// public static Vector64 ShiftLeftLogicalSaturate(Vector64 value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vqshl_n_u32 (uint32x2_t a, const int n) - /// A32: VQSHL.U32 Dd, Dm, #n - /// A64: UQSHL Vd.2S, Vn.2S, #n + /// uint32x2_t vqshl_n_u32 (uint32x2_t a, const int n) + /// A32: VQSHL.U32 Dd, Dm, #n + /// A64: UQSHL Vd.2S, Vn.2S, #n /// public static Vector64 ShiftLeftLogicalSaturate(Vector64 value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vqshlq_n_u8 (uint8x16_t a, const int n) - /// A32: VQSHL.U8 Qd, Qm, #n - /// A64: UQSHL Vd.16B, Vn.16B, #n + /// uint8x16_t vqshlq_n_u8 (uint8x16_t a, const int n) + /// A32: VQSHL.U8 Qd, Qm, #n + /// A64: UQSHL Vd.16B, Vn.16B, #n /// public static Vector128 ShiftLeftLogicalSaturate(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vqshlq_n_s16 (int16x8_t a, const int n) - /// A32: VQSHL.S16 Qd, Qm, #n - /// A64: SQSHL Vd.8H, Vn.8H, #n + /// int16x8_t vqshlq_n_s16 (int16x8_t a, const int n) + /// A32: VQSHL.S16 Qd, Qm, #n + /// A64: SQSHL Vd.8H, Vn.8H, #n /// public static Vector128 ShiftLeftLogicalSaturate(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqshlq_n_s32 (int32x4_t a, const int n) - /// A32: VQSHL.S32 Qd, Qm, #n - /// A64: SQSHL Vd.4S, Vn.4S, #n + /// int32x4_t vqshlq_n_s32 (int32x4_t a, const int n) + /// A32: VQSHL.S32 Qd, Qm, #n + /// A64: SQSHL Vd.4S, Vn.4S, #n /// public static Vector128 ShiftLeftLogicalSaturate(Vector128 value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqshlq_n_s64 (int64x2_t a, const int n) - /// A32: VQSHL.S64 Qd, Qm, #n - /// A64: SQSHL Vd.2D, Vn.2D, #n + /// int64x2_t vqshlq_n_s64 (int64x2_t a, const int n) + /// A32: VQSHL.S64 Qd, Qm, #n + /// A64: SQSHL Vd.2D, Vn.2D, #n /// public static Vector128 ShiftLeftLogicalSaturate(Vector128 value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vqshlq_n_s8 (int8x16_t a, const int n) - /// A32: VQSHL.S8 Qd, Qm, #n - /// A64: SQSHL Vd.16B, Vn.16B, #n + /// int8x16_t vqshlq_n_s8 (int8x16_t a, const int n) + /// A32: VQSHL.S8 Qd, Qm, #n + /// A64: SQSHL Vd.16B, Vn.16B, #n /// public static Vector128 ShiftLeftLogicalSaturate(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vqshlq_n_u16 (uint16x8_t a, const int n) - /// A32: VQSHL.U16 Qd, Qm, #n - /// A64: UQSHL Vd.8H, Vn.8H, #n + /// uint16x8_t vqshlq_n_u16 (uint16x8_t a, const int n) + /// A32: VQSHL.U16 Qd, Qm, #n + /// A64: UQSHL Vd.8H, Vn.8H, #n /// public static Vector128 ShiftLeftLogicalSaturate(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vqshlq_n_u32 (uint32x4_t a, const int n) - /// A32: VQSHL.U32 Qd, Qm, #n - /// A64: UQSHL Vd.4S, Vn.4S, #n + /// uint32x4_t vqshlq_n_u32 (uint32x4_t a, const int n) + /// A32: VQSHL.U32 Qd, Qm, #n + /// A64: UQSHL Vd.4S, Vn.4S, #n /// public static Vector128 ShiftLeftLogicalSaturate(Vector128 value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vqshlq_n_u64 (uint64x2_t a, const int n) - /// A32: VQSHL.U64 Qd, Qm, #n - /// A64: UQSHL Vd.2D, Vn.2D, #n + /// uint64x2_t vqshlq_n_u64 (uint64x2_t a, const int n) + /// A32: VQSHL.U64 Qd, Qm, #n + /// A64: UQSHL Vd.2D, Vn.2D, #n /// public static Vector128 ShiftLeftLogicalSaturate(Vector128 value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vqshl_n_s64 (int64x1_t a, const int n) - /// A32: VQSHL.S64 Dd, Dm, #n - /// A64: SQSHL Dd, Dn, #n + /// int64x1_t vqshl_n_s64 (int64x1_t a, const int n) + /// A32: VQSHL.S64 Dd, Dm, #n + /// A64: SQSHL Dd, Dn, #n /// public static Vector64 ShiftLeftLogicalSaturateScalar(Vector64 value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vqshl_n_u64 (uint64x1_t a, const int n) - /// A32: VQSHL.U64 Dd, Dm, #n - /// A64: UQSHL Dd, Dn, #n + /// uint64x1_t vqshl_n_u64 (uint64x1_t a, const int n) + /// A32: VQSHL.U64 Dd, Dm, #n + /// A64: UQSHL Dd, Dn, #n /// public static Vector64 ShiftLeftLogicalSaturateScalar(Vector64 value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vqshlu_n_s16 (int16x4_t a, const int n) - /// A32: VQSHLU.S16 Dd, Dm, #n - /// A64: SQSHLU Vd.4H, Vn.4H, #n + /// uint16x4_t vqshlu_n_s16 (int16x4_t a, const int n) + /// A32: VQSHLU.S16 Dd, Dm, #n + /// A64: SQSHLU Vd.4H, Vn.4H, #n /// public static Vector64 ShiftLeftLogicalSaturateUnsigned(Vector64 value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vqshlu_n_s32 (int32x2_t a, const int n) - /// A32: VQSHLU.S32 Dd, Dm, #n - /// A64: SQSHLU Vd.2S, Vn.2S, #n + /// uint32x2_t vqshlu_n_s32 (int32x2_t a, const int n) + /// A32: VQSHLU.S32 Dd, Dm, #n + /// A64: SQSHLU Vd.2S, Vn.2S, #n /// public static Vector64 ShiftLeftLogicalSaturateUnsigned(Vector64 value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vqshlu_n_s8 (int8x8_t a, const int n) - /// A32: VQSHLU.S8 Dd, Dm, #n - /// A64: SQSHLU Vd.8B, Vn.8B, #n + /// uint8x8_t vqshlu_n_s8 (int8x8_t a, const int n) + /// A32: VQSHLU.S8 Dd, Dm, #n + /// A64: SQSHLU Vd.8B, Vn.8B, #n /// public static Vector64 ShiftLeftLogicalSaturateUnsigned(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vqshluq_n_s16 (int16x8_t a, const int n) - /// A32: VQSHLU.S16 Qd, Qm, #n - /// A64: SQSHLU Vd.8H, Vn.8H, #n + /// uint16x8_t vqshluq_n_s16 (int16x8_t a, const int n) + /// A32: VQSHLU.S16 Qd, Qm, #n + /// A64: SQSHLU Vd.8H, Vn.8H, #n /// public static Vector128 ShiftLeftLogicalSaturateUnsigned(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vqshluq_n_s32 (int32x4_t a, const int n) - /// A32: VQSHLU.S32 Qd, Qm, #n - /// A64: SQSHLU Vd.4S, Vn.4S, #n + /// uint32x4_t vqshluq_n_s32 (int32x4_t a, const int n) + /// A32: VQSHLU.S32 Qd, Qm, #n + /// A64: SQSHLU Vd.4S, Vn.4S, #n /// public static Vector128 ShiftLeftLogicalSaturateUnsigned(Vector128 value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vqshluq_n_s64 (int64x2_t a, const int n) - /// A32: VQSHLU.S64 Qd, Qm, #n - /// A64: SQSHLU Vd.2D, Vn.2D, #n + /// uint64x2_t vqshluq_n_s64 (int64x2_t a, const int n) + /// A32: VQSHLU.S64 Qd, Qm, #n + /// A64: SQSHLU Vd.2D, Vn.2D, #n /// public static Vector128 ShiftLeftLogicalSaturateUnsigned(Vector128 value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vqshluq_n_s8 (int8x16_t a, const int n) - /// A32: VQSHLU.S8 Qd, Qm, #n - /// A64: SQSHLU Vd.16B, Vn.16B, #n + /// uint8x16_t vqshluq_n_s8 (int8x16_t a, const int n) + /// A32: VQSHLU.S8 Qd, Qm, #n + /// A64: SQSHLU Vd.16B, Vn.16B, #n /// public static Vector128 ShiftLeftLogicalSaturateUnsigned(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vqshlu_n_s64 (int64x1_t a, const int n) - /// A32: VQSHLU.S64 Dd, Dm, #n - /// A64: SQSHLU Dd, Dn, #n + /// uint64x1_t vqshlu_n_s64 (int64x1_t a, const int n) + /// A32: VQSHLU.S64 Dd, Dm, #n + /// A64: SQSHLU Dd, Dn, #n /// public static Vector64 ShiftLeftLogicalSaturateUnsignedScalar(Vector64 value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vshl_n_s64 (int64x1_t a, const int n) - /// A32: VSHL.I64 Dd, Dm, #n - /// A64: SHL Dd, Dn, #n + /// int64x1_t vshl_n_s64 (int64x1_t a, const int n) + /// A32: VSHL.I64 Dd, Dm, #n + /// A64: SHL Dd, Dn, #n /// public static Vector64 ShiftLeftLogicalScalar(Vector64 value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vshl_n_u64 (uint64x1_t a, const int n) - /// A32: VSHL.I64 Dd, Dm, #n - /// A64: SHL Dd, Dn, #n + /// uint64x1_t vshl_n_u64 (uint64x1_t a, const int n) + /// A32: VSHL.I64 Dd, Dm, #n + /// A64: SHL Dd, Dn, #n /// public static Vector64 ShiftLeftLogicalScalar(Vector64 value, [ConstantExpected(Max = (byte)(63))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vshll_n_u8 (uint8x8_t a, const int n) - /// A32: VSHLL.U8 Qd, Dm, #n - /// A64: USHLL Vd.8H, Vn.8B, #n + /// uint16x8_t vshll_n_u8 (uint8x8_t a, const int n) + /// A32: VSHLL.U8 Qd, Dm, #n + /// A64: USHLL Vd.8H, Vn.8B, #n /// public static Vector128 ShiftLeftLogicalWideningLower(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vshll_n_s16 (int16x4_t a, const int n) - /// A32: VSHLL.S16 Qd, Dm, #n - /// A64: SSHLL Vd.4S, Vn.4H, #n + /// int32x4_t vshll_n_s16 (int16x4_t a, const int n) + /// A32: VSHLL.S16 Qd, Dm, #n + /// A64: SSHLL Vd.4S, Vn.4H, #n /// public static Vector128 ShiftLeftLogicalWideningLower(Vector64 value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vshll_n_s32 (int32x2_t a, const int n) - /// A32: VSHLL.S32 Qd, Dm, #n - /// A64: SSHLL Vd.2D, Vn.2S, #n + /// int64x2_t vshll_n_s32 (int32x2_t a, const int n) + /// A32: VSHLL.S32 Qd, Dm, #n + /// A64: SSHLL Vd.2D, Vn.2S, #n /// public static Vector128 ShiftLeftLogicalWideningLower(Vector64 value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vshll_n_s8 (int8x8_t a, const int n) - /// A32: VSHLL.S8 Qd, Dm, #n - /// A64: SSHLL Vd.8H, Vn.8B, #n + /// int16x8_t vshll_n_s8 (int8x8_t a, const int n) + /// A32: VSHLL.S8 Qd, Dm, #n + /// A64: SSHLL Vd.8H, Vn.8B, #n /// public static Vector128 ShiftLeftLogicalWideningLower(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vshll_n_u16 (uint16x4_t a, const int n) - /// A32: VSHLL.U16 Qd, Dm, #n - /// A64: USHLL Vd.4S, Vn.4H, #n + /// uint32x4_t vshll_n_u16 (uint16x4_t a, const int n) + /// A32: VSHLL.U16 Qd, Dm, #n + /// A64: USHLL Vd.4S, Vn.4H, #n /// public static Vector128 ShiftLeftLogicalWideningLower(Vector64 value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vshll_n_u32 (uint32x2_t a, const int n) - /// A32: VSHLL.U32 Qd, Dm, #n - /// A64: USHLL Vd.2D, Vn.2S, #n + /// uint64x2_t vshll_n_u32 (uint32x2_t a, const int n) + /// A32: VSHLL.U32 Qd, Dm, #n + /// A64: USHLL Vd.2D, Vn.2S, #n /// public static Vector128 ShiftLeftLogicalWideningLower(Vector64 value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vshll_high_n_u8 (uint8x16_t a, const int n) - /// A32: VSHLL.U8 Qd, Dm+1, #n - /// A64: USHLL2 Vd.8H, Vn.16B, #n + /// uint16x8_t vshll_high_n_u8 (uint8x16_t a, const int n) + /// A32: VSHLL.U8 Qd, Dm+1, #n + /// A64: USHLL2 Vd.8H, Vn.16B, #n /// public static Vector128 ShiftLeftLogicalWideningUpper(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vshll_high_n_s16 (int16x8_t a, const int n) - /// A32: VSHLL.S16 Qd, Dm+1, #n - /// A64: SSHLL2 Vd.4S, Vn.8H, #n + /// int32x4_t vshll_high_n_s16 (int16x8_t a, const int n) + /// A32: VSHLL.S16 Qd, Dm+1, #n + /// A64: SSHLL2 Vd.4S, Vn.8H, #n /// public static Vector128 ShiftLeftLogicalWideningUpper(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vshll_high_n_s32 (int32x4_t a, const int n) - /// A32: VSHLL.S32 Qd, Dm+1, #n - /// A64: SSHLL2 Vd.2D, Vn.4S, #n + /// int64x2_t vshll_high_n_s32 (int32x4_t a, const int n) + /// A32: VSHLL.S32 Qd, Dm+1, #n + /// A64: SSHLL2 Vd.2D, Vn.4S, #n /// public static Vector128 ShiftLeftLogicalWideningUpper(Vector128 value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vshll_high_n_s8 (int8x16_t a, const int n) - /// A32: VSHLL.S8 Qd, Dm+1, #n - /// A64: SSHLL2 Vd.8H, Vn.16B, #n + /// int16x8_t vshll_high_n_s8 (int8x16_t a, const int n) + /// A32: VSHLL.S8 Qd, Dm+1, #n + /// A64: SSHLL2 Vd.8H, Vn.16B, #n /// public static Vector128 ShiftLeftLogicalWideningUpper(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vshll_high_n_u16 (uint16x8_t a, const int n) - /// A32: VSHLL.U16 Qd, Dm+1, #n - /// A64: USHLL2 Vd.4S, Vn.8H, #n + /// uint32x4_t vshll_high_n_u16 (uint16x8_t a, const int n) + /// A32: VSHLL.U16 Qd, Dm+1, #n + /// A64: USHLL2 Vd.4S, Vn.8H, #n /// public static Vector128 ShiftLeftLogicalWideningUpper(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vshll_high_n_u32 (uint32x4_t a, const int n) - /// A32: VSHLL.U32 Qd, Dm+1, #n - /// A64: USHLL2 Vd.2D, Vn.4S, #n + /// uint64x2_t vshll_high_n_u32 (uint32x4_t a, const int n) + /// A32: VSHLL.U32 Qd, Dm+1, #n + /// A64: USHLL2 Vd.2D, Vn.4S, #n /// public static Vector128 ShiftLeftLogicalWideningUpper(Vector128 value, [ConstantExpected(Max = (byte)(31))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vshl_u8 (uint8x8_t a, int8x8_t b) - /// A32: VSHL.U8 Dd, Dn, Dm - /// A64: USHL Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vshl_u8 (uint8x8_t a, int8x8_t b) + /// A32: VSHL.U8 Dd, Dn, Dm + /// A64: USHL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ShiftLogical(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vshl_u16 (uint16x4_t a, int16x4_t b) - /// A32: VSHL.U16 Dd, Dn, Dm - /// A64: USHL Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vshl_u16 (uint16x4_t a, int16x4_t b) + /// A32: VSHL.U16 Dd, Dn, Dm + /// A64: USHL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ShiftLogical(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vshl_u32 (uint32x2_t a, int32x2_t b) - /// A32: VSHL.U32 Dd, Dn, Dm - /// A64: USHL Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vshl_u32 (uint32x2_t a, int32x2_t b) + /// A32: VSHL.U32 Dd, Dn, Dm + /// A64: USHL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ShiftLogical(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vshl_u8 (uint8x8_t a, int8x8_t b) - /// A32: VSHL.U8 Dd, Dn, Dm - /// A64: USHL Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vshl_u8 (uint8x8_t a, int8x8_t b) + /// A32: VSHL.U8 Dd, Dn, Dm + /// A64: USHL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ShiftLogical(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vshl_u16 (uint16x4_t a, int16x4_t b) - /// A32: VSHL.U16 Dd, Dn, Dm - /// A64: USHL Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vshl_u16 (uint16x4_t a, int16x4_t b) + /// A32: VSHL.U16 Dd, Dn, Dm + /// A64: USHL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ShiftLogical(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vshl_u32 (uint32x2_t a, int32x2_t b) - /// A32: VSHL.U32 Dd, Dn, Dm - /// A64: USHL Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vshl_u32 (uint32x2_t a, int32x2_t b) + /// A32: VSHL.U32 Dd, Dn, Dm + /// A64: USHL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ShiftLogical(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vshlq_u8 (uint8x16_t a, int8x16_t b) - /// A32: VSHL.U8 Qd, Qn, Qm - /// A64: USHL Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vshlq_u8 (uint8x16_t a, int8x16_t b) + /// A32: VSHL.U8 Qd, Qn, Qm + /// A64: USHL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ShiftLogical(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vshlq_u16 (uint16x8_t a, int16x8_t b) - /// A32: VSHL.U16 Qd, Qn, Qm - /// A64: USHL Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vshlq_u16 (uint16x8_t a, int16x8_t b) + /// A32: VSHL.U16 Qd, Qn, Qm + /// A64: USHL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ShiftLogical(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vshlq_u32 (uint32x4_t a, int32x4_t b) - /// A32: VSHL.U32 Qd, Qn, Qm - /// A64: USHL Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vshlq_u32 (uint32x4_t a, int32x4_t b) + /// A32: VSHL.U32 Qd, Qn, Qm + /// A64: USHL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ShiftLogical(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vshlq_u64 (uint64x2_t a, int64x2_t b) - /// A32: VSHL.U64 Qd, Qn, Qm - /// A64: USHL Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vshlq_u64 (uint64x2_t a, int64x2_t b) + /// A32: VSHL.U64 Qd, Qn, Qm + /// A64: USHL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ShiftLogical(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vshlq_u8 (uint8x16_t a, int8x16_t b) - /// A32: VSHL.U8 Qd, Qn, Qm - /// A64: USHL Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vshlq_u8 (uint8x16_t a, int8x16_t b) + /// A32: VSHL.U8 Qd, Qn, Qm + /// A64: USHL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ShiftLogical(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vshlq_u16 (uint16x8_t a, int16x8_t b) - /// A32: VSHL.U16 Qd, Qn, Qm - /// A64: USHL Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vshlq_u16 (uint16x8_t a, int16x8_t b) + /// A32: VSHL.U16 Qd, Qn, Qm + /// A64: USHL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ShiftLogical(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vshlq_u32 (uint32x4_t a, int32x4_t b) - /// A32: VSHL.U32 Qd, Qn, Qm - /// A64: USHL Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vshlq_u32 (uint32x4_t a, int32x4_t b) + /// A32: VSHL.U32 Qd, Qn, Qm + /// A64: USHL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ShiftLogical(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vshlq_u64 (uint64x2_t a, int64x2_t b) - /// A32: VSHL.U64 Qd, Qn, Qm - /// A64: USHL Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vshlq_u64 (uint64x2_t a, int64x2_t b) + /// A32: VSHL.U64 Qd, Qn, Qm + /// A64: USHL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ShiftLogical(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vrshl_u8 (uint8x8_t a, int8x8_t b) - /// A32: VRSHL.U8 Dd, Dn, Dm - /// A64: URSHL Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vrshl_u8 (uint8x8_t a, int8x8_t b) + /// A32: VRSHL.U8 Dd, Dn, Dm + /// A64: URSHL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ShiftLogicalRounded(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vrshl_u16 (uint16x4_t a, int16x4_t b) - /// A32: VRSHL.U16 Dd, Dn, Dm - /// A64: URSHL Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vrshl_u16 (uint16x4_t a, int16x4_t b) + /// A32: VRSHL.U16 Dd, Dn, Dm + /// A64: URSHL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ShiftLogicalRounded(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vrshl_u32 (uint32x2_t a, int32x2_t b) - /// A32: VRSHL.U32 Dd, Dn, Dm - /// A64: URSHL Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vrshl_u32 (uint32x2_t a, int32x2_t b) + /// A32: VRSHL.U32 Dd, Dn, Dm + /// A64: URSHL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ShiftLogicalRounded(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vrshl_u8 (uint8x8_t a, int8x8_t b) - /// A32: VRSHL.U8 Dd, Dn, Dm - /// A64: URSHL Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vrshl_u8 (uint8x8_t a, int8x8_t b) + /// A32: VRSHL.U8 Dd, Dn, Dm + /// A64: URSHL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ShiftLogicalRounded(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vrshl_u16 (uint16x4_t a, int16x4_t b) - /// A32: VRSHL.U16 Dd, Dn, Dm - /// A64: URSHL Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vrshl_u16 (uint16x4_t a, int16x4_t b) + /// A32: VRSHL.U16 Dd, Dn, Dm + /// A64: URSHL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ShiftLogicalRounded(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vrshl_u32 (uint32x2_t a, int32x2_t b) - /// A32: VRSHL.U32 Dd, Dn, Dm - /// A64: URSHL Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vrshl_u32 (uint32x2_t a, int32x2_t b) + /// A32: VRSHL.U32 Dd, Dn, Dm + /// A64: URSHL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ShiftLogicalRounded(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vrshlq_u8 (uint8x16_t a, int8x16_t b) - /// A32: VRSHL.U8 Qd, Qn, Qm - /// A64: URSHL Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vrshlq_u8 (uint8x16_t a, int8x16_t b) + /// A32: VRSHL.U8 Qd, Qn, Qm + /// A64: URSHL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ShiftLogicalRounded(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vrshlq_u16 (uint16x8_t a, int16x8_t b) - /// A32: VRSHL.U16 Qd, Qn, Qm - /// A64: URSHL Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vrshlq_u16 (uint16x8_t a, int16x8_t b) + /// A32: VRSHL.U16 Qd, Qn, Qm + /// A64: URSHL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ShiftLogicalRounded(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vrshlq_u32 (uint32x4_t a, int32x4_t b) - /// A32: VRSHL.U32 Qd, Qn, Qm - /// A64: URSHL Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vrshlq_u32 (uint32x4_t a, int32x4_t b) + /// A32: VRSHL.U32 Qd, Qn, Qm + /// A64: URSHL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ShiftLogicalRounded(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vrshlq_u64 (uint64x2_t a, int64x2_t b) - /// A32: VRSHL.U64 Qd, Qn, Qm - /// A64: URSHL Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vrshlq_u64 (uint64x2_t a, int64x2_t b) + /// A32: VRSHL.U64 Qd, Qn, Qm + /// A64: URSHL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ShiftLogicalRounded(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vrshlq_u8 (uint8x16_t a, int8x16_t b) - /// A32: VRSHL.U8 Qd, Qn, Qm - /// A64: URSHL Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vrshlq_u8 (uint8x16_t a, int8x16_t b) + /// A32: VRSHL.U8 Qd, Qn, Qm + /// A64: URSHL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ShiftLogicalRounded(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vrshlq_u16 (uint16x8_t a, int16x8_t b) - /// A32: VRSHL.U16 Qd, Qn, Qm - /// A64: URSHL Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vrshlq_u16 (uint16x8_t a, int16x8_t b) + /// A32: VRSHL.U16 Qd, Qn, Qm + /// A64: URSHL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ShiftLogicalRounded(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vrshlq_u32 (uint32x4_t a, int32x4_t b) - /// A32: VRSHL.U32 Qd, Qn, Qm - /// A64: URSHL Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vrshlq_u32 (uint32x4_t a, int32x4_t b) + /// A32: VRSHL.U32 Qd, Qn, Qm + /// A64: URSHL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ShiftLogicalRounded(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vrshlq_u64 (uint64x2_t a, int64x2_t b) - /// A32: VRSHL.U64 Qd, Qn, Qm - /// A64: URSHL Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vrshlq_u64 (uint64x2_t a, int64x2_t b) + /// A32: VRSHL.U64 Qd, Qn, Qm + /// A64: URSHL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ShiftLogicalRounded(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vqrshl_u8 (uint8x8_t a, int8x8_t b) - /// A32: VQRSHL.U8 Dd, Dn, Dm - /// A64: UQRSHL Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vqrshl_u8 (uint8x8_t a, int8x8_t b) + /// A32: VQRSHL.U8 Dd, Dn, Dm + /// A64: UQRSHL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ShiftLogicalRoundedSaturate(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vqrshl_u16 (uint16x4_t a, int16x4_t b) - /// A32: VQRSHL.U16 Dd, Dn, Dm - /// A64: UQRSHL Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vqrshl_u16 (uint16x4_t a, int16x4_t b) + /// A32: VQRSHL.U16 Dd, Dn, Dm + /// A64: UQRSHL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ShiftLogicalRoundedSaturate(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vqrshl_u32 (uint32x2_t a, int32x2_t b) - /// A32: VQRSHL.U32 Dd, Dn, Dm - /// A64: UQRSHL Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vqrshl_u32 (uint32x2_t a, int32x2_t b) + /// A32: VQRSHL.U32 Dd, Dn, Dm + /// A64: UQRSHL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ShiftLogicalRoundedSaturate(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vqrshl_u8 (uint8x8_t a, int8x8_t b) - /// A32: VQRSHL.U8 Dd, Dn, Dm - /// A64: UQRSHL Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vqrshl_u8 (uint8x8_t a, int8x8_t b) + /// A32: VQRSHL.U8 Dd, Dn, Dm + /// A64: UQRSHL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ShiftLogicalRoundedSaturate(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vqrshl_u16 (uint16x4_t a, int16x4_t b) - /// A32: VQRSHL.U16 Dd, Dn, Dm - /// A64: UQRSHL Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vqrshl_u16 (uint16x4_t a, int16x4_t b) + /// A32: VQRSHL.U16 Dd, Dn, Dm + /// A64: UQRSHL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ShiftLogicalRoundedSaturate(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vqrshl_u32 (uint32x2_t a, int32x2_t b) - /// A32: VQRSHL.U32 Dd, Dn, Dm - /// A64: UQRSHL Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vqrshl_u32 (uint32x2_t a, int32x2_t b) + /// A32: VQRSHL.U32 Dd, Dn, Dm + /// A64: UQRSHL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ShiftLogicalRoundedSaturate(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vqrshlq_u8 (uint8x16_t a, int8x16_t b) - /// A32: VQRSHL.U8 Qd, Qn, Qm - /// A64: UQRSHL Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vqrshlq_u8 (uint8x16_t a, int8x16_t b) + /// A32: VQRSHL.U8 Qd, Qn, Qm + /// A64: UQRSHL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ShiftLogicalRoundedSaturate(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vqrshlq_u16 (uint16x8_t a, int16x8_t b) - /// A32: VQRSHL.U16 Qd, Qn, Qm - /// A64: UQRSHL Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vqrshlq_u16 (uint16x8_t a, int16x8_t b) + /// A32: VQRSHL.U16 Qd, Qn, Qm + /// A64: UQRSHL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ShiftLogicalRoundedSaturate(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vqrshlq_u32 (uint32x4_t a, int32x4_t b) - /// A32: VQRSHL.U32 Qd, Qn, Qm - /// A64: UQRSHL Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vqrshlq_u32 (uint32x4_t a, int32x4_t b) + /// A32: VQRSHL.U32 Qd, Qn, Qm + /// A64: UQRSHL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ShiftLogicalRoundedSaturate(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vqrshlq_u64 (uint64x2_t a, int64x2_t b) - /// A32: VQRSHL.U64 Qd, Qn, Qm - /// A64: UQRSHL Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vqrshlq_u64 (uint64x2_t a, int64x2_t b) + /// A32: VQRSHL.U64 Qd, Qn, Qm + /// A64: UQRSHL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ShiftLogicalRoundedSaturate(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vqrshlq_u8 (uint8x16_t a, int8x16_t b) - /// A32: VQRSHL.U8 Qd, Qn, Qm - /// A64: UQRSHL Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vqrshlq_u8 (uint8x16_t a, int8x16_t b) + /// A32: VQRSHL.U8 Qd, Qn, Qm + /// A64: UQRSHL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ShiftLogicalRoundedSaturate(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vqrshlq_u16 (uint16x8_t a, int16x8_t b) - /// A32: VQRSHL.U16 Qd, Qn, Qm - /// A64: UQRSHL Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vqrshlq_u16 (uint16x8_t a, int16x8_t b) + /// A32: VQRSHL.U16 Qd, Qn, Qm + /// A64: UQRSHL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ShiftLogicalRoundedSaturate(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vqrshlq_u32 (uint32x4_t a, int32x4_t b) - /// A32: VQRSHL.U32 Qd, Qn, Qm - /// A64: UQRSHL Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vqrshlq_u32 (uint32x4_t a, int32x4_t b) + /// A32: VQRSHL.U32 Qd, Qn, Qm + /// A64: UQRSHL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ShiftLogicalRoundedSaturate(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vqrshlq_u64 (uint64x2_t a, int64x2_t b) - /// A32: VQRSHL.U64 Qd, Qn, Qm - /// A64: UQRSHL Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vqrshlq_u64 (uint64x2_t a, int64x2_t b) + /// A32: VQRSHL.U64 Qd, Qn, Qm + /// A64: UQRSHL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ShiftLogicalRoundedSaturate(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vqrshl_u64 (uint64x1_t a, int64x1_t b) - /// A32: VQRSHL.U64 Dd, Dn, Dm - /// A64: UQRSHL Dd, Dn, Dm + /// uint64x1_t vqrshl_u64 (uint64x1_t a, int64x1_t b) + /// A32: VQRSHL.U64 Dd, Dn, Dm + /// A64: UQRSHL Dd, Dn, Dm /// public static Vector64 ShiftLogicalRoundedSaturateScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vqrshl_u64 (uint64x1_t a, int64x1_t b) - /// A32: VQRSHL.U64 Dd, Dn, Dm - /// A64: UQRSHL Dd, Dn, Dm + /// uint64x1_t vqrshl_u64 (uint64x1_t a, int64x1_t b) + /// A32: VQRSHL.U64 Dd, Dn, Dm + /// A64: UQRSHL Dd, Dn, Dm /// public static Vector64 ShiftLogicalRoundedSaturateScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vrshl_u64 (uint64x1_t a, int64x1_t b) - /// A32: VRSHL.U64 Dd, Dn, Dm - /// A64: URSHL Dd, Dn, Dm + /// uint64x1_t vrshl_u64 (uint64x1_t a, int64x1_t b) + /// A32: VRSHL.U64 Dd, Dn, Dm + /// A64: URSHL Dd, Dn, Dm /// public static Vector64 ShiftLogicalRoundedScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vrshl_u64 (uint64x1_t a, int64x1_t b) - /// A32: VRSHL.U64 Dd, Dn, Dm - /// A64: URSHL Dd, Dn, Dm + /// uint64x1_t vrshl_u64 (uint64x1_t a, int64x1_t b) + /// A32: VRSHL.U64 Dd, Dn, Dm + /// A64: URSHL Dd, Dn, Dm /// public static Vector64 ShiftLogicalRoundedScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vqshl_u8 (uint8x8_t a, int8x8_t b) - /// A32: VQSHL.U8 Dd, Dn, Dm - /// A64: UQSHL Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vqshl_u8 (uint8x8_t a, int8x8_t b) + /// A32: VQSHL.U8 Dd, Dn, Dm + /// A64: UQSHL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ShiftLogicalSaturate(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vqshl_u16 (uint16x4_t a, int16x4_t b) - /// A32: VQSHL.U16 Dd, Dn, Dm - /// A64: UQSHL Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vqshl_u16 (uint16x4_t a, int16x4_t b) + /// A32: VQSHL.U16 Dd, Dn, Dm + /// A64: UQSHL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ShiftLogicalSaturate(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vqshl_u32 (uint32x2_t a, int32x2_t b) - /// A32: VQSHL.U32 Dd, Dn, Dm - /// A64: UQSHL Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vqshl_u32 (uint32x2_t a, int32x2_t b) + /// A32: VQSHL.U32 Dd, Dn, Dm + /// A64: UQSHL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ShiftLogicalSaturate(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vqshl_u8 (uint8x8_t a, int8x8_t b) - /// A32: VQSHL.U8 Dd, Dn, Dm - /// A64: UQSHL Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vqshl_u8 (uint8x8_t a, int8x8_t b) + /// A32: VQSHL.U8 Dd, Dn, Dm + /// A64: UQSHL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ShiftLogicalSaturate(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vqshl_u16 (uint16x4_t a, int16x4_t b) - /// A32: VQSHL.U16 Dd, Dn, Dm - /// A64: UQSHL Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vqshl_u16 (uint16x4_t a, int16x4_t b) + /// A32: VQSHL.U16 Dd, Dn, Dm + /// A64: UQSHL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ShiftLogicalSaturate(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vqshl_u32 (uint32x2_t a, int32x2_t b) - /// A32: VQSHL.U32 Dd, Dn, Dm - /// A64: UQSHL Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vqshl_u32 (uint32x2_t a, int32x2_t b) + /// A32: VQSHL.U32 Dd, Dn, Dm + /// A64: UQSHL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ShiftLogicalSaturate(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vqshlq_u8 (uint8x16_t a, int8x16_t b) - /// A32: VQSHL.U8 Qd, Qn, Qm - /// A64: UQSHL Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vqshlq_u8 (uint8x16_t a, int8x16_t b) + /// A32: VQSHL.U8 Qd, Qn, Qm + /// A64: UQSHL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ShiftLogicalSaturate(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vqshlq_u16 (uint16x8_t a, int16x8_t b) - /// A32: VQSHL.U16 Qd, Qn, Qm - /// A64: UQSHL Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vqshlq_u16 (uint16x8_t a, int16x8_t b) + /// A32: VQSHL.U16 Qd, Qn, Qm + /// A64: UQSHL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ShiftLogicalSaturate(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vqshlq_u32 (uint32x4_t a, int32x4_t b) - /// A32: VQSHL.U32 Qd, Qn, Qm - /// A64: UQSHL Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vqshlq_u32 (uint32x4_t a, int32x4_t b) + /// A32: VQSHL.U32 Qd, Qn, Qm + /// A64: UQSHL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ShiftLogicalSaturate(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vqshlq_u64 (uint64x2_t a, int64x2_t b) - /// A32: VQSHL.U64 Qd, Qn, Qm - /// A64: UQSHL Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vqshlq_u64 (uint64x2_t a, int64x2_t b) + /// A32: VQSHL.U64 Qd, Qn, Qm + /// A64: UQSHL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ShiftLogicalSaturate(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vqshlq_u8 (uint8x16_t a, int8x16_t b) - /// A32: VQSHL.U8 Qd, Qn, Qm - /// A64: UQSHL Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vqshlq_u8 (uint8x16_t a, int8x16_t b) + /// A32: VQSHL.U8 Qd, Qn, Qm + /// A64: UQSHL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ShiftLogicalSaturate(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vqshlq_u16 (uint16x8_t a, int16x8_t b) - /// A32: VQSHL.U16 Qd, Qn, Qm - /// A64: UQSHL Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vqshlq_u16 (uint16x8_t a, int16x8_t b) + /// A32: VQSHL.U16 Qd, Qn, Qm + /// A64: UQSHL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ShiftLogicalSaturate(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vqshlq_u32 (uint32x4_t a, int32x4_t b) - /// A32: VQSHL.U32 Qd, Qn, Qm - /// A64: UQSHL Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vqshlq_u32 (uint32x4_t a, int32x4_t b) + /// A32: VQSHL.U32 Qd, Qn, Qm + /// A64: UQSHL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ShiftLogicalSaturate(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vqshlq_u64 (uint64x2_t a, int64x2_t b) - /// A32: VQSHL.U64 Qd, Qn, Qm - /// A64: UQSHL Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vqshlq_u64 (uint64x2_t a, int64x2_t b) + /// A32: VQSHL.U64 Qd, Qn, Qm + /// A64: UQSHL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ShiftLogicalSaturate(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vqshl_u64 (uint64x1_t a, int64x1_t b) - /// A32: VQSHL.U64 Dd, Dn, Dm - /// A64: UQSHL Dd, Dn, Dm + /// uint64x1_t vqshl_u64 (uint64x1_t a, int64x1_t b) + /// A32: VQSHL.U64 Dd, Dn, Dm + /// A64: UQSHL Dd, Dn, Dm /// public static Vector64 ShiftLogicalSaturateScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vqshl_u64 (uint64x1_t a, int64x1_t b) - /// A32: VQSHL.U64 Dd, Dn, Dm - /// A64: UQSHL Dd, Dn, Dm + /// uint64x1_t vqshl_u64 (uint64x1_t a, int64x1_t b) + /// A32: VQSHL.U64 Dd, Dn, Dm + /// A64: UQSHL Dd, Dn, Dm /// public static Vector64 ShiftLogicalSaturateScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vshl_u64 (uint64x1_t a, int64x1_t b) - /// A32: VSHL.U64 Dd, Dn, Dm - /// A64: USHL Dd, Dn, Dm + /// uint64x1_t vshl_u64 (uint64x1_t a, int64x1_t b) + /// A32: VSHL.U64 Dd, Dn, Dm + /// A64: USHL Dd, Dn, Dm /// public static Vector64 ShiftLogicalScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vshl_u64 (uint64x1_t a, int64x1_t b) - /// A32: VSHL.U64 Dd, Dn, Dm - /// A64: USHL Dd, Dn, Dm + /// uint64x1_t vshl_u64 (uint64x1_t a, int64x1_t b) + /// A32: VSHL.U64 Dd, Dn, Dm + /// A64: USHL Dd, Dn, Dm /// public static Vector64 ShiftLogicalScalar(Vector64 value, Vector64 count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vsri_n_u8(uint8x8_t a, uint8x8_t b, __builtin_constant_p(n)) - /// A32: VSRI.8 Dd, Dm, #n - /// A64: SRI Vd.8B, Vn.8B, #n + /// uint8x8_t vsri_n_u8(uint8x8_t a, uint8x8_t b, __builtin_constant_p(n)) + /// A32: VSRI.8 Dd, Dm, #n + /// A64: SRI Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, [ConstantExpected(Min = 1, Max = (byte)(8))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vsri_n_s16(int16x4_t a, int16x4_t b, __builtin_constant_p(n)) - /// A32: VSRI.16 Dd, Dm, #n - /// A64: SRI Vd.4H, Vn.4H, #n + /// int16x4_t vsri_n_s16(int16x4_t a, int16x4_t b, __builtin_constant_p(n)) + /// A32: VSRI.16 Dd, Dm, #n + /// A64: SRI Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, [ConstantExpected(Min = 1, Max = (byte)(16))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vsri_n_s32(int32x2_t a, int32x2_t b, __builtin_constant_p(n)) - /// A32: VSRI.32 Dd, Dm, #n - /// A64: SRI Vd.2S, Vn.2S, #n + /// int32x2_t vsri_n_s32(int32x2_t a, int32x2_t b, __builtin_constant_p(n)) + /// A32: VSRI.32 Dd, Dm, #n + /// A64: SRI Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, [ConstantExpected(Min = 1, Max = (byte)(32))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vsri_n_s8(int8x8_t a, int8x8_t b, __builtin_constant_p(n)) - /// A32: VSRI.8 Dd, Dm, #n - /// A64: SRI Vd.8B, Vn.8B, #n + /// int8x8_t vsri_n_s8(int8x8_t a, int8x8_t b, __builtin_constant_p(n)) + /// A32: VSRI.8 Dd, Dm, #n + /// A64: SRI Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, [ConstantExpected(Min = 1, Max = (byte)(8))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vsri_n_u16(uint16x4_t a, uint16x4_t b, __builtin_constant_p(n)) - /// A32: VSRI.16 Dd, Dm, #n - /// A64: SRI Vd.4H, Vn.4H, #n + /// uint16x4_t vsri_n_u16(uint16x4_t a, uint16x4_t b, __builtin_constant_p(n)) + /// A32: VSRI.16 Dd, Dm, #n + /// A64: SRI Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, [ConstantExpected(Min = 1, Max = (byte)(16))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vsri_n_u32(uint32x2_t a, uint32x2_t b, __builtin_constant_p(n)) - /// A32: VSRI.32 Dd, Dm, #n - /// A64: SRI Vd.2S, Vn.2S, #n + /// uint32x2_t vsri_n_u32(uint32x2_t a, uint32x2_t b, __builtin_constant_p(n)) + /// A32: VSRI.32 Dd, Dm, #n + /// A64: SRI Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, [ConstantExpected(Min = 1, Max = (byte)(32))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vsriq_n_u8(uint8x16_t a, uint8x16_t b, __builtin_constant_p(n)) - /// A32: VSRI.8 Qd, Qm, #n - /// A64: SRI Vd.16B, Vn.16B, #n + /// uint8x16_t vsriq_n_u8(uint8x16_t a, uint8x16_t b, __builtin_constant_p(n)) + /// A32: VSRI.8 Qd, Qm, #n + /// A64: SRI Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Min = 1, Max = (byte)(8))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vsriq_n_s16(int16x8_t a, int16x8_t b, __builtin_constant_p(n)) - /// A32: VSRI.16 Qd, Qm, #n - /// A64: SRI Vd.8H, Vn.8H, #n + /// int16x8_t vsriq_n_s16(int16x8_t a, int16x8_t b, __builtin_constant_p(n)) + /// A32: VSRI.16 Qd, Qm, #n + /// A64: SRI Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Min = 1, Max = (byte)(16))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vsriq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n)) - /// A32: VSRI.32 Qd, Qm, #n - /// A64: SRI Vd.4S, Vn.4S, #n + /// int32x4_t vsriq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n)) + /// A32: VSRI.32 Qd, Qm, #n + /// A64: SRI Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Min = 1, Max = (byte)(32))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vsriq_n_s64(int64x2_t a, int64x2_t b, __builtin_constant_p(n)) - /// A32: VSRI.64 Qd, Qm, #n - /// A64: SRI Vd.2D, Vn.2D, #n + /// int64x2_t vsriq_n_s64(int64x2_t a, int64x2_t b, __builtin_constant_p(n)) + /// A32: VSRI.64 Qd, Qm, #n + /// A64: SRI Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vsriq_n_s8(int8x16_t a, int8x16_t b, __builtin_constant_p(n)) - /// A32: VSRI.8 Qd, Qm, #n - /// A64: SRI Vd.16B, Vn.16B, #n + /// int8x16_t vsriq_n_s8(int8x16_t a, int8x16_t b, __builtin_constant_p(n)) + /// A32: VSRI.8 Qd, Qm, #n + /// A64: SRI Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Min = 1, Max = (byte)(8))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vsriq_n_u16(uint16x8_t a, uint16x8_t b, __builtin_constant_p(n)) - /// A32: VSRI.16 Qd, Qm, #n - /// A64: SRI Vd.8H, Vn.8H, #n + /// uint16x8_t vsriq_n_u16(uint16x8_t a, uint16x8_t b, __builtin_constant_p(n)) + /// A32: VSRI.16 Qd, Qm, #n + /// A64: SRI Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Min = 1, Max = (byte)(16))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vsriq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n)) - /// A32: VSRI.32 Qd, Qm, #n - /// A64: SRI Vd.4S, Vn.4S, #n + /// uint32x4_t vsriq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n)) + /// A32: VSRI.32 Qd, Qm, #n + /// A64: SRI Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Min = 1, Max = (byte)(32))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vsriq_n_u64(uint64x2_t a, uint64x2_t b, __builtin_constant_p(n)) - /// A32: VSRI.64 Qd, Qm, #n - /// A64: SRI Vd.2D, Vn.2D, #n + /// uint64x2_t vsriq_n_u64(uint64x2_t a, uint64x2_t b, __builtin_constant_p(n)) + /// A32: VSRI.64 Qd, Qm, #n + /// A64: SRI Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// int64_t vsrid_n_s64(int64_t a, int64_t b, __builtin_constant_p(n)) - /// A32: VSRI.64 Dd, Dm, #n - /// A64: SRI Dd, Dn, #n + /// int64_t vsrid_n_s64(int64_t a, int64_t b, __builtin_constant_p(n)) + /// A32: VSRI.64 Dd, Dm, #n + /// A64: SRI Dd, Dn, #n /// public static Vector64 ShiftRightAndInsertScalar(Vector64 left, Vector64 right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// uint64_t vsrid_n_u64(uint64_t a, uint64_t b, __builtin_constant_p(n)) - /// A32: VSRI.64 Dd, Dm, #n - /// A64: SRI Dd, Dn, #n + /// uint64_t vsrid_n_u64(uint64_t a, uint64_t b, __builtin_constant_p(n)) + /// A32: VSRI.64 Dd, Dm, #n + /// A64: SRI Dd, Dn, #n /// public static Vector64 ShiftRightAndInsertScalar(Vector64 left, Vector64 right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vshr_n_s16 (int16x4_t a, const int n) - /// A32: VSHR.S16 Dd, Dm, #n - /// A64: SSHR Vd.4H, Vn.4H, #n + /// int16x4_t vshr_n_s16 (int16x4_t a, const int n) + /// A32: VSHR.S16 Dd, Dm, #n + /// A64: SSHR Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightArithmetic(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vshr_n_s32 (int32x2_t a, const int n) - /// A32: VSHR.S32 Dd, Dm, #n - /// A64: SSHR Vd.2S, Vn.2S, #n + /// int32x2_t vshr_n_s32 (int32x2_t a, const int n) + /// A32: VSHR.S32 Dd, Dm, #n + /// A64: SSHR Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightArithmetic(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vshr_n_s8 (int8x8_t a, const int n) - /// A32: VSHR.S8 Dd, Dm, #n - /// A64: SSHR Vd.8B, Vn.8B, #n + /// int8x8_t vshr_n_s8 (int8x8_t a, const int n) + /// A32: VSHR.S8 Dd, Dm, #n + /// A64: SSHR Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightArithmetic(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vshrq_n_s16 (int16x8_t a, const int n) - /// A32: VSHR.S16 Qd, Qm, #n - /// A64: SSHR Vd.8H, Vn.8H, #n + /// int16x8_t vshrq_n_s16 (int16x8_t a, const int n) + /// A32: VSHR.S16 Qd, Qm, #n + /// A64: SSHR Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightArithmetic(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vshrq_n_s32 (int32x4_t a, const int n) - /// A32: VSHR.S32 Qd, Qm, #n - /// A64: SSHR Vd.4S, Vn.4S, #n + /// int32x4_t vshrq_n_s32 (int32x4_t a, const int n) + /// A32: VSHR.S32 Qd, Qm, #n + /// A64: SSHR Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightArithmetic(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vshrq_n_s64 (int64x2_t a, const int n) - /// A32: VSHR.S64 Qd, Qm, #n - /// A64: SSHR Vd.2D, Vn.2D, #n + /// int64x2_t vshrq_n_s64 (int64x2_t a, const int n) + /// A32: VSHR.S64 Qd, Qm, #n + /// A64: SSHR Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightArithmetic(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vshrq_n_s8 (int8x16_t a, const int n) - /// A32: VSHR.S8 Qd, Qm, #n - /// A64: SSHR Vd.16B, Vn.16B, #n + /// int8x16_t vshrq_n_s8 (int8x16_t a, const int n) + /// A32: VSHR.S8 Qd, Qm, #n + /// A64: SSHR Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightArithmetic(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vsra_n_s16 (int16x4_t a, int16x4_t b, const int n) - /// A32: VSRA.S16 Dd, Dm, #n - /// A64: SSRA Vd.4H, Vn.4H, #n + /// int16x4_t vsra_n_s16 (int16x4_t a, int16x4_t b, const int n) + /// A32: VSRA.S16 Dd, Dm, #n + /// A64: SSRA Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightArithmeticAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vsra_n_s32 (int32x2_t a, int32x2_t b, const int n) - /// A32: VSRA.S32 Dd, Dm, #n - /// A64: SSRA Vd.2S, Vn.2S, #n + /// int32x2_t vsra_n_s32 (int32x2_t a, int32x2_t b, const int n) + /// A32: VSRA.S32 Dd, Dm, #n + /// A64: SSRA Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightArithmeticAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vsra_n_s8 (int8x8_t a, int8x8_t b, const int n) - /// A32: VSRA.S8 Dd, Dm, #n - /// A64: SSRA Vd.8B, Vn.8B, #n + /// int8x8_t vsra_n_s8 (int8x8_t a, int8x8_t b, const int n) + /// A32: VSRA.S8 Dd, Dm, #n + /// A64: SSRA Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightArithmeticAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vsraq_n_s16 (int16x8_t a, int16x8_t b, const int n) - /// A32: VSRA.S16 Qd, Qm, #n - /// A64: SSRA Vd.8H, Vn.8H, #n + /// int16x8_t vsraq_n_s16 (int16x8_t a, int16x8_t b, const int n) + /// A32: VSRA.S16 Qd, Qm, #n + /// A64: SSRA Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightArithmeticAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vsraq_n_s32 (int32x4_t a, int32x4_t b, const int n) - /// A32: VSRA.S32 Qd, Qm, #n - /// A64: SSRA Vd.4S, Vn.4S, #n + /// int32x4_t vsraq_n_s32 (int32x4_t a, int32x4_t b, const int n) + /// A32: VSRA.S32 Qd, Qm, #n + /// A64: SSRA Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightArithmeticAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vsraq_n_s64 (int64x2_t a, int64x2_t b, const int n) - /// A32: VSRA.S64 Qd, Qm, #n - /// A64: SSRA Vd.2D, Vn.2D, #n + /// int64x2_t vsraq_n_s64 (int64x2_t a, int64x2_t b, const int n) + /// A32: VSRA.S64 Qd, Qm, #n + /// A64: SSRA Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightArithmeticAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vsraq_n_s8 (int8x16_t a, int8x16_t b, const int n) - /// A32: VSRA.S8 Qd, Qm, #n - /// A64: SSRA Vd.16B, Vn.16B, #n + /// int8x16_t vsraq_n_s8 (int8x16_t a, int8x16_t b, const int n) + /// A32: VSRA.S8 Qd, Qm, #n + /// A64: SSRA Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightArithmeticAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vsra_n_s64 (int64x1_t a, int64x1_t b, const int n) - /// A32: VSRA.S64 Dd, Dm, #n - /// A64: SSRA Dd, Dn, #n + /// int64x1_t vsra_n_s64 (int64x1_t a, int64x1_t b, const int n) + /// A32: VSRA.S64 Dd, Dm, #n + /// A64: SSRA Dd, Dn, #n /// public static Vector64 ShiftRightArithmeticAddScalar(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vqshrn_n_s32 (int32x4_t a, const int n) - /// A32: VQSHRN.S32 Dd, Qm, #n - /// A64: SQSHRN Vd.4H, Vn.4S, #n + /// int16x4_t vqshrn_n_s32 (int32x4_t a, const int n) + /// A32: VQSHRN.S32 Dd, Qm, #n + /// A64: SQSHRN Vd.4H, Vn.4S, #n /// public static Vector64 ShiftRightArithmeticNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vqshrn_n_s64 (int64x2_t a, const int n) - /// A32: VQSHRN.S64 Dd, Qm, #n - /// A64: SQSHRN Vd.2S, Vn.2D, #n + /// int32x2_t vqshrn_n_s64 (int64x2_t a, const int n) + /// A32: VQSHRN.S64 Dd, Qm, #n + /// A64: SQSHRN Vd.2S, Vn.2D, #n /// public static Vector64 ShiftRightArithmeticNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vqshrn_n_s16 (int16x8_t a, const int n) - /// A32: VQSHRN.S16 Dd, Qm, #n - /// A64: SQSHRN Vd.8B, Vn.8H, #n + /// int8x8_t vqshrn_n_s16 (int16x8_t a, const int n) + /// A32: VQSHRN.S16 Dd, Qm, #n + /// A64: SQSHRN Vd.8B, Vn.8H, #n /// public static Vector64 ShiftRightArithmeticNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vqshrun_n_s16 (int16x8_t a, const int n) - /// A32: VQSHRUN.S16 Dd, Qm, #n - /// A64: SQSHRUN Vd.8B, Vn.8H, #n + /// uint8x8_t vqshrun_n_s16 (int16x8_t a, const int n) + /// A32: VQSHRUN.S16 Dd, Qm, #n + /// A64: SQSHRUN Vd.8B, Vn.8H, #n /// public static Vector64 ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vqshrun_n_s32 (int32x4_t a, const int n) - /// A32: VQSHRUN.S32 Dd, Qm, #n - /// A64: SQSHRUN Vd.4H, Vn.4S, #n + /// uint16x4_t vqshrun_n_s32 (int32x4_t a, const int n) + /// A32: VQSHRUN.S32 Dd, Qm, #n + /// A64: SQSHRUN Vd.4H, Vn.4S, #n /// public static Vector64 ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vqshrun_n_s64 (int64x2_t a, const int n) - /// A32: VQSHRUN.S64 Dd, Qm, #n - /// A64: SQSHRUN Vd.2S, Vn.2D, #n + /// uint32x2_t vqshrun_n_s64 (int64x2_t a, const int n) + /// A32: VQSHRUN.S64 Dd, Qm, #n + /// A64: SQSHRUN Vd.2S, Vn.2D, #n /// public static Vector64 ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vqshrun_high_n_s16 (uint8x8_t r, int16x8_t a, const int n) - /// A32: VQSHRUN.S16 Dd+1, Dn, #n - /// A64: SQSHRUN2 Vd.16B, Vn.8H, #n + /// uint8x16_t vqshrun_high_n_s16 (uint8x8_t r, int16x8_t a, const int n) + /// A32: VQSHRUN.S16 Dd+1, Dn, #n + /// A64: SQSHRUN2 Vd.16B, Vn.8H, #n /// public static Vector128 ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vqshrun_high_n_s32 (uint16x4_t r, int32x4_t a, const int n) - /// A32: VQSHRUN.S32 Dd+1, Dn, #n - /// A64: SQSHRUN2 Vd.8H, Vn.4S, #n + /// uint16x8_t vqshrun_high_n_s32 (uint16x4_t r, int32x4_t a, const int n) + /// A32: VQSHRUN.S32 Dd+1, Dn, #n + /// A64: SQSHRUN2 Vd.8H, Vn.4S, #n /// public static Vector128 ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vqshrun_high_n_s64 (uint32x2_t r, int64x2_t a, const int n) - /// A32: VQSHRUN.S64 Dd+1, Dn, #n - /// A64: SQSHRUN2 Vd.4S, Vn.2D, #n + /// uint32x4_t vqshrun_high_n_s64 (uint32x2_t r, int64x2_t a, const int n) + /// A32: VQSHRUN.S64 Dd+1, Dn, #n + /// A64: SQSHRUN2 Vd.4S, Vn.2D, #n /// public static Vector128 ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vqshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n) - /// A32: VQSHRN.S32 Dd+1, Qm, #n - /// A64: SQSHRN2 Vd.8H, Vn.4S, #n + /// int16x8_t vqshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n) + /// A32: VQSHRN.S32 Dd+1, Qm, #n + /// A64: SQSHRN2 Vd.8H, Vn.4S, #n /// public static Vector128 ShiftRightArithmeticNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n) - /// A32: VQSHRN.S64 Dd+1, Qm, #n - /// A64: SQSHRN2 Vd.4S, Vn.2D, #n + /// int32x4_t vqshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n) + /// A32: VQSHRN.S64 Dd+1, Qm, #n + /// A64: SQSHRN2 Vd.4S, Vn.2D, #n /// public static Vector128 ShiftRightArithmeticNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vqshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n) - /// A32: VQSHRN.S16 Dd+1, Qm, #n - /// A64: SQSHRN2 Vd.16B, Vn.8H, #n + /// int8x16_t vqshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n) + /// A32: VQSHRN.S16 Dd+1, Qm, #n + /// A64: SQSHRN2 Vd.16B, Vn.8H, #n /// public static Vector128 ShiftRightArithmeticNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vrshr_n_s16 (int16x4_t a, const int n) - /// A32: VRSHR.S16 Dd, Dm, #n - /// A64: SRSHR Vd.4H, Vn.4H, #n + /// int16x4_t vrshr_n_s16 (int16x4_t a, const int n) + /// A32: VRSHR.S16 Dd, Dm, #n + /// A64: SRSHR Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightArithmeticRounded(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vrshr_n_s32 (int32x2_t a, const int n) - /// A32: VRSHR.S32 Dd, Dm, #n - /// A64: SRSHR Vd.2S, Vn.2S, #n + /// int32x2_t vrshr_n_s32 (int32x2_t a, const int n) + /// A32: VRSHR.S32 Dd, Dm, #n + /// A64: SRSHR Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightArithmeticRounded(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vrshr_n_s8 (int8x8_t a, const int n) - /// A32: VRSHR.S8 Dd, Dm, #n - /// A64: SRSHR Vd.8B, Vn.8B, #n + /// int8x8_t vrshr_n_s8 (int8x8_t a, const int n) + /// A32: VRSHR.S8 Dd, Dm, #n + /// A64: SRSHR Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightArithmeticRounded(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vrshrq_n_s16 (int16x8_t a, const int n) - /// A32: VRSHR.S16 Qd, Qm, #n - /// A64: SRSHR Vd.8H, Vn.8H, #n + /// int16x8_t vrshrq_n_s16 (int16x8_t a, const int n) + /// A32: VRSHR.S16 Qd, Qm, #n + /// A64: SRSHR Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightArithmeticRounded(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vrshrq_n_s32 (int32x4_t a, const int n) - /// A32: VRSHR.S32 Qd, Qm, #n - /// A64: SRSHR Vd.4S, Vn.4S, #n + /// int32x4_t vrshrq_n_s32 (int32x4_t a, const int n) + /// A32: VRSHR.S32 Qd, Qm, #n + /// A64: SRSHR Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightArithmeticRounded(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vrshrq_n_s64 (int64x2_t a, const int n) - /// A32: VRSHR.S64 Qd, Qm, #n - /// A64: SRSHR Vd.2D, Vn.2D, #n + /// int64x2_t vrshrq_n_s64 (int64x2_t a, const int n) + /// A32: VRSHR.S64 Qd, Qm, #n + /// A64: SRSHR Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightArithmeticRounded(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vrshrq_n_s8 (int8x16_t a, const int n) - /// A32: VRSHR.S8 Qd, Qm, #n - /// A64: SRSHR Vd.16B, Vn.16B, #n + /// int8x16_t vrshrq_n_s8 (int8x16_t a, const int n) + /// A32: VRSHR.S8 Qd, Qm, #n + /// A64: SRSHR Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightArithmeticRounded(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vrsra_n_s16 (int16x4_t a, int16x4_t b, const int n) - /// A32: VRSRA.S16 Dd, Dm, #n - /// A64: SRSRA Vd.4H, Vn.4H, #n + /// int16x4_t vrsra_n_s16 (int16x4_t a, int16x4_t b, const int n) + /// A32: VRSRA.S16 Dd, Dm, #n + /// A64: SRSRA Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightArithmeticRoundedAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vrsra_n_s32 (int32x2_t a, int32x2_t b, const int n) - /// A32: VRSRA.S32 Dd, Dm, #n - /// A64: SRSRA Vd.2S, Vn.2S, #n + /// int32x2_t vrsra_n_s32 (int32x2_t a, int32x2_t b, const int n) + /// A32: VRSRA.S32 Dd, Dm, #n + /// A64: SRSRA Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightArithmeticRoundedAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vrsra_n_s8 (int8x8_t a, int8x8_t b, const int n) - /// A32: VRSRA.S8 Dd, Dm, #n - /// A64: SRSRA Vd.8B, Vn.8B, #n + /// int8x8_t vrsra_n_s8 (int8x8_t a, int8x8_t b, const int n) + /// A32: VRSRA.S8 Dd, Dm, #n + /// A64: SRSRA Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightArithmeticRoundedAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vrsraq_n_s16 (int16x8_t a, int16x8_t b, const int n) - /// A32: VRSRA.S16 Qd, Qm, #n - /// A64: SRSRA Vd.8H, Vn.8H, #n + /// int16x8_t vrsraq_n_s16 (int16x8_t a, int16x8_t b, const int n) + /// A32: VRSRA.S16 Qd, Qm, #n + /// A64: SRSRA Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightArithmeticRoundedAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vrsraq_n_s32 (int32x4_t a, int32x4_t b, const int n) - /// A32: VRSRA.S32 Qd, Qm, #n - /// A64: SRSRA Vd.4S, Vn.4S, #n + /// int32x4_t vrsraq_n_s32 (int32x4_t a, int32x4_t b, const int n) + /// A32: VRSRA.S32 Qd, Qm, #n + /// A64: SRSRA Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightArithmeticRoundedAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vrsraq_n_s64 (int64x2_t a, int64x2_t b, const int n) - /// A32: VRSRA.S64 Qd, Qm, #n - /// A64: SRSRA Vd.2D, Vn.2D, #n + /// int64x2_t vrsraq_n_s64 (int64x2_t a, int64x2_t b, const int n) + /// A32: VRSRA.S64 Qd, Qm, #n + /// A64: SRSRA Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightArithmeticRoundedAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vrsraq_n_s8 (int8x16_t a, int8x16_t b, const int n) - /// A32: VRSRA.S8 Qd, Qm, #n - /// A64: SRSRA Vd.16B, Vn.16B, #n + /// int8x16_t vrsraq_n_s8 (int8x16_t a, int8x16_t b, const int n) + /// A32: VRSRA.S8 Qd, Qm, #n + /// A64: SRSRA Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightArithmeticRoundedAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vrsra_n_s64 (int64x1_t a, int64x1_t b, const int n) - /// A32: VRSRA.S64 Dd, Dm, #n - /// A64: SRSRA Dd, Dn, #n + /// int64x1_t vrsra_n_s64 (int64x1_t a, int64x1_t b, const int n) + /// A32: VRSRA.S64 Dd, Dm, #n + /// A64: SRSRA Dd, Dn, #n /// public static Vector64 ShiftRightArithmeticRoundedAddScalar(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vqrshrn_n_s32 (int32x4_t a, const int n) - /// A32: VQRSHRN.S32 Dd, Qm, #n - /// A64: SQRSHRN Vd.4H, Vn.4S, #n + /// int16x4_t vqrshrn_n_s32 (int32x4_t a, const int n) + /// A32: VQRSHRN.S32 Dd, Qm, #n + /// A64: SQRSHRN Vd.4H, Vn.4S, #n /// public static Vector64 ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vqrshrn_n_s64 (int64x2_t a, const int n) - /// A32: VQRSHRN.S64 Dd, Qm, #n - /// A64: SQRSHRN Vd.2S, Vn.2D, #n + /// int32x2_t vqrshrn_n_s64 (int64x2_t a, const int n) + /// A32: VQRSHRN.S64 Dd, Qm, #n + /// A64: SQRSHRN Vd.2S, Vn.2D, #n /// public static Vector64 ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vqrshrn_n_s16 (int16x8_t a, const int n) - /// A32: VQRSHRN.S16 Dd, Qm, #n - /// A64: SQRSHRN Vd.8B, Vn.8H, #n + /// int8x8_t vqrshrn_n_s16 (int16x8_t a, const int n) + /// A32: VQRSHRN.S16 Dd, Qm, #n + /// A64: SQRSHRN Vd.8B, Vn.8H, #n /// public static Vector64 ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vqrshrun_n_s16 (int16x8_t a, const int n) - /// A32: VQRSHRUN.S16 Dd, Qm, #n - /// A64: SQRSHRUN Vd.8B, Vn.8H, #n + /// uint8x8_t vqrshrun_n_s16 (int16x8_t a, const int n) + /// A32: VQRSHRUN.S16 Dd, Qm, #n + /// A64: SQRSHRUN Vd.8B, Vn.8H, #n /// public static Vector64 ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vqrshrun_n_s32 (int32x4_t a, const int n) - /// A32: VQRSHRUN.S32 Dd, Qm, #n - /// A64: SQRSHRUN Vd.4H, Vn.4S, #n + /// uint16x4_t vqrshrun_n_s32 (int32x4_t a, const int n) + /// A32: VQRSHRUN.S32 Dd, Qm, #n + /// A64: SQRSHRUN Vd.4H, Vn.4S, #n /// public static Vector64 ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vqrshrun_n_s64 (int64x2_t a, const int n) - /// A32: VQRSHRUN.S64 Dd, Qm, #n - /// A64: SQRSHRUN Vd.2S, Vn.2D, #n + /// uint32x2_t vqrshrun_n_s64 (int64x2_t a, const int n) + /// A32: VQRSHRUN.S64 Dd, Qm, #n + /// A64: SQRSHRUN Vd.2S, Vn.2D, #n /// public static Vector64 ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vqrshrun_high_n_s16 (uint8x8_t r, int16x8_t a, const int n) - /// A32: VQRSHRUN.S16 Dd+1, Dn, #n - /// A64: SQRSHRUN2 Vd.16B, Vn.8H, #n + /// uint8x16_t vqrshrun_high_n_s16 (uint8x8_t r, int16x8_t a, const int n) + /// A32: VQRSHRUN.S16 Dd+1, Dn, #n + /// A64: SQRSHRUN2 Vd.16B, Vn.8H, #n /// public static Vector128 ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vqrshrun_high_n_s32 (uint16x4_t r, int32x4_t a, const int n) - /// A32: VQRSHRUN.S32 Dd+1, Dn, #n - /// A64: SQRSHRUN2 Vd.8H, Vn.4S, #n + /// uint16x8_t vqrshrun_high_n_s32 (uint16x4_t r, int32x4_t a, const int n) + /// A32: VQRSHRUN.S32 Dd+1, Dn, #n + /// A64: SQRSHRUN2 Vd.8H, Vn.4S, #n /// public static Vector128 ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vqrshrun_high_n_s64 (uint32x2_t r, int64x2_t a, const int n) - /// A32: VQRSHRUN.S64 Dd+1, Dn, #n - /// A64: SQRSHRUN2 Vd.4S, Vn.2D, #n + /// uint32x4_t vqrshrun_high_n_s64 (uint32x2_t r, int64x2_t a, const int n) + /// A32: VQRSHRUN.S64 Dd+1, Dn, #n + /// A64: SQRSHRUN2 Vd.4S, Vn.2D, #n /// public static Vector128 ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vqrshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n) - /// A32: VQRSHRN.S32 Dd+1, Dn, #n - /// A64: SQRSHRN2 Vd.8H, Vn.4S, #n + /// int16x8_t vqrshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n) + /// A32: VQRSHRN.S32 Dd+1, Dn, #n + /// A64: SQRSHRN2 Vd.8H, Vn.4S, #n /// public static Vector128 ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqrshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n) - /// A32: VQRSHRN.S64 Dd+1, Dn, #n - /// A64: SQRSHRN2 Vd.4S, Vn.2D, #n + /// int32x4_t vqrshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n) + /// A32: VQRSHRN.S64 Dd+1, Dn, #n + /// A64: SQRSHRN2 Vd.4S, Vn.2D, #n /// public static Vector128 ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vqrshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n) - /// A32: VQRSHRN.S16 Dd+1, Dn, #n - /// A64: SQRSHRN2 Vd.16B, Vn.8H, #n + /// int8x16_t vqrshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n) + /// A32: VQRSHRN.S16 Dd+1, Dn, #n + /// A64: SQRSHRN2 Vd.16B, Vn.8H, #n /// public static Vector128 ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vrshr_n_s64 (int64x1_t a, const int n) - /// A32: VRSHR.S64 Dd, Dm, #n - /// A64: SRSHR Dd, Dn, #n + /// int64x1_t vrshr_n_s64 (int64x1_t a, const int n) + /// A32: VRSHR.S64 Dd, Dm, #n + /// A64: SRSHR Dd, Dn, #n /// public static Vector64 ShiftRightArithmeticRoundedScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vshr_n_s64 (int64x1_t a, const int n) - /// A32: VSHR.S64 Dd, Dm, #n - /// A64: SSHR Dd, Dn, #n + /// int64x1_t vshr_n_s64 (int64x1_t a, const int n) + /// A32: VSHR.S64 Dd, Dm, #n + /// A64: SSHR Dd, Dn, #n /// public static Vector64 ShiftRightArithmeticScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vshr_n_u8 (uint8x8_t a, const int n) - /// A32: VSHR.U8 Dd, Dm, #n - /// A64: USHR Vd.8B, Vn.8B, #n + /// uint8x8_t vshr_n_u8 (uint8x8_t a, const int n) + /// A32: VSHR.U8 Dd, Dm, #n + /// A64: USHR Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightLogical(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vshr_n_u16 (uint16x4_t a, const int n) - /// A32: VSHR.U16 Dd, Dm, #n - /// A64: USHR Vd.4H, Vn.4H, #n + /// uint16x4_t vshr_n_u16 (uint16x4_t a, const int n) + /// A32: VSHR.U16 Dd, Dm, #n + /// A64: USHR Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightLogical(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vshr_n_u32 (uint32x2_t a, const int n) - /// A32: VSHR.U32 Dd, Dm, #n - /// A64: USHR Vd.2S, Vn.2S, #n + /// uint32x2_t vshr_n_u32 (uint32x2_t a, const int n) + /// A32: VSHR.U32 Dd, Dm, #n + /// A64: USHR Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightLogical(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vshr_n_u8 (uint8x8_t a, const int n) - /// A32: VSHR.U8 Dd, Dm, #n - /// A64: USHR Vd.8B, Vn.8B, #n + /// uint8x8_t vshr_n_u8 (uint8x8_t a, const int n) + /// A32: VSHR.U8 Dd, Dm, #n + /// A64: USHR Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightLogical(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vshr_n_u16 (uint16x4_t a, const int n) - /// A32: VSHR.U16 Dd, Dm, #n - /// A64: USHR Vd.4H, Vn.4H, #n + /// uint16x4_t vshr_n_u16 (uint16x4_t a, const int n) + /// A32: VSHR.U16 Dd, Dm, #n + /// A64: USHR Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightLogical(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vshr_n_u32 (uint32x2_t a, const int n) - /// A32: VSHR.U32 Dd, Dm, #n - /// A64: USHR Vd.2S, Vn.2S, #n + /// uint32x2_t vshr_n_u32 (uint32x2_t a, const int n) + /// A32: VSHR.U32 Dd, Dm, #n + /// A64: USHR Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightLogical(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vshrq_n_u8 (uint8x16_t a, const int n) - /// A32: VSHR.U8 Qd, Qm, #n - /// A64: USHR Vd.16B, Vn.16B, #n + /// uint8x16_t vshrq_n_u8 (uint8x16_t a, const int n) + /// A32: VSHR.U8 Qd, Qm, #n + /// A64: USHR Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vshrq_n_u16 (uint16x8_t a, const int n) - /// A32: VSHR.U16 Qd, Qm, #n - /// A64: USHR Vd.8H, Vn.8H, #n + /// uint16x8_t vshrq_n_u16 (uint16x8_t a, const int n) + /// A32: VSHR.U16 Qd, Qm, #n + /// A64: USHR Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vshrq_n_u32 (uint32x4_t a, const int n) - /// A32: VSHR.U32 Qd, Qm, #n - /// A64: USHR Vd.4S, Vn.4S, #n + /// uint32x4_t vshrq_n_u32 (uint32x4_t a, const int n) + /// A32: VSHR.U32 Qd, Qm, #n + /// A64: USHR Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vshrq_n_u64 (uint64x2_t a, const int n) - /// A32: VSHR.U64 Qd, Qm, #n - /// A64: USHR Vd.2D, Vn.2D, #n + /// uint64x2_t vshrq_n_u64 (uint64x2_t a, const int n) + /// A32: VSHR.U64 Qd, Qm, #n + /// A64: USHR Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vshrq_n_u8 (uint8x16_t a, const int n) - /// A32: VSHR.U8 Qd, Qm, #n - /// A64: USHR Vd.16B, Vn.16B, #n + /// uint8x16_t vshrq_n_u8 (uint8x16_t a, const int n) + /// A32: VSHR.U8 Qd, Qm, #n + /// A64: USHR Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vshrq_n_u16 (uint16x8_t a, const int n) - /// A32: VSHR.U16 Qd, Qm, #n - /// A64: USHR Vd.8H, Vn.8H, #n + /// uint16x8_t vshrq_n_u16 (uint16x8_t a, const int n) + /// A32: VSHR.U16 Qd, Qm, #n + /// A64: USHR Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vshrq_n_u32 (uint32x4_t a, const int n) - /// A32: VSHR.U32 Qd, Qm, #n - /// A64: USHR Vd.4S, Vn.4S, #n + /// uint32x4_t vshrq_n_u32 (uint32x4_t a, const int n) + /// A32: VSHR.U32 Qd, Qm, #n + /// A64: USHR Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vshrq_n_u64 (uint64x2_t a, const int n) - /// A32: VSHR.U64 Qd, Qm, #n - /// A64: USHR Vd.2D, Vn.2D, #n + /// uint64x2_t vshrq_n_u64 (uint64x2_t a, const int n) + /// A32: VSHR.U64 Qd, Qm, #n + /// A64: USHR Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n) - /// A32: VSRA.U8 Dd, Dm, #n - /// A64: USRA Vd.8B, Vn.8B, #n + /// uint8x8_t vsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n) + /// A32: VSRA.U8 Dd, Dm, #n + /// A64: USRA Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightLogicalAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n) - /// A32: VSRA.U16 Dd, Dm, #n - /// A64: USRA Vd.4H, Vn.4H, #n + /// uint16x4_t vsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n) + /// A32: VSRA.U16 Dd, Dm, #n + /// A64: USRA Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightLogicalAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n) - /// A32: VSRA.U32 Dd, Dm, #n - /// A64: USRA Vd.2S, Vn.2S, #n + /// uint32x2_t vsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n) + /// A32: VSRA.U32 Dd, Dm, #n + /// A64: USRA Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightLogicalAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n) - /// A32: VSRA.U8 Dd, Dm, #n - /// A64: USRA Vd.8B, Vn.8B, #n + /// uint8x8_t vsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n) + /// A32: VSRA.U8 Dd, Dm, #n + /// A64: USRA Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightLogicalAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n) - /// A32: VSRA.U16 Dd, Dm, #n - /// A64: USRA Vd.4H, Vn.4H, #n + /// uint16x4_t vsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n) + /// A32: VSRA.U16 Dd, Dm, #n + /// A64: USRA Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightLogicalAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n) - /// A32: VSRA.U32 Dd, Dm, #n - /// A64: USRA Vd.2S, Vn.2S, #n + /// uint32x2_t vsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n) + /// A32: VSRA.U32 Dd, Dm, #n + /// A64: USRA Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightLogicalAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n) - /// A32: VSRA.U8 Qd, Qm, #n - /// A64: USRA Vd.16B, Vn.16B, #n + /// uint8x16_t vsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n) + /// A32: VSRA.U8 Qd, Qm, #n + /// A64: USRA Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightLogicalAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n) - /// A32: VSRA.U16 Qd, Qm, #n - /// A64: USRA Vd.8H, Vn.8H, #n + /// uint16x8_t vsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n) + /// A32: VSRA.U16 Qd, Qm, #n + /// A64: USRA Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightLogicalAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n) - /// A32: VSRA.U32 Qd, Qm, #n - /// A64: USRA Vd.4S, Vn.4S, #n + /// uint32x4_t vsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n) + /// A32: VSRA.U32 Qd, Qm, #n + /// A64: USRA Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightLogicalAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n) - /// A32: VSRA.U64 Qd, Qm, #n - /// A64: USRA Vd.2D, Vn.2D, #n + /// uint64x2_t vsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n) + /// A32: VSRA.U64 Qd, Qm, #n + /// A64: USRA Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightLogicalAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n) - /// A32: VSRA.U8 Qd, Qm, #n - /// A64: USRA Vd.16B, Vn.16B, #n + /// uint8x16_t vsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n) + /// A32: VSRA.U8 Qd, Qm, #n + /// A64: USRA Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightLogicalAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n) - /// A32: VSRA.U16 Qd, Qm, #n - /// A64: USRA Vd.8H, Vn.8H, #n + /// uint16x8_t vsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n) + /// A32: VSRA.U16 Qd, Qm, #n + /// A64: USRA Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightLogicalAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n) - /// A32: VSRA.U32 Qd, Qm, #n - /// A64: USRA Vd.4S, Vn.4S, #n + /// uint32x4_t vsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n) + /// A32: VSRA.U32 Qd, Qm, #n + /// A64: USRA Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightLogicalAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n) - /// A32: VSRA.U64 Qd, Qm, #n - /// A64: USRA Vd.2D, Vn.2D, #n + /// uint64x2_t vsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n) + /// A32: VSRA.U64 Qd, Qm, #n + /// A64: USRA Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightLogicalAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n) - /// A32: VSRA.U64 Dd, Dm, #n - /// A64: USRA Dd, Dn, #n + /// uint64x1_t vsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n) + /// A32: VSRA.U64 Dd, Dm, #n + /// A64: USRA Dd, Dn, #n /// public static Vector64 ShiftRightLogicalAddScalar(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n) - /// A32: VSRA.U64 Dd, Dm, #n - /// A64: USRA Dd, Dn, #n + /// uint64x1_t vsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n) + /// A32: VSRA.U64 Dd, Dm, #n + /// A64: USRA Dd, Dn, #n /// public static Vector64 ShiftRightLogicalAddScalar(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vshrn_n_u16 (uint16x8_t a, const int n) - /// A32: VSHRN.I16 Dd, Qm, #n - /// A64: SHRN Vd.8B, Vn.8H, #n + /// uint8x8_t vshrn_n_u16 (uint16x8_t a, const int n) + /// A32: VSHRN.I16 Dd, Qm, #n + /// A64: SHRN Vd.8B, Vn.8H, #n /// public static Vector64 ShiftRightLogicalNarrowingLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vshrn_n_s32 (int32x4_t a, const int n) - /// A32: VSHRN.I32 Dd, Qm, #n - /// A64: SHRN Vd.4H, Vn.4S, #n + /// int16x4_t vshrn_n_s32 (int32x4_t a, const int n) + /// A32: VSHRN.I32 Dd, Qm, #n + /// A64: SHRN Vd.4H, Vn.4S, #n /// public static Vector64 ShiftRightLogicalNarrowingLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vshrn_n_s64 (int64x2_t a, const int n) - /// A32: VSHRN.I64 Dd, Qm, #n - /// A64: SHRN Vd.2S, Vn.2D, #n + /// int32x2_t vshrn_n_s64 (int64x2_t a, const int n) + /// A32: VSHRN.I64 Dd, Qm, #n + /// A64: SHRN Vd.2S, Vn.2D, #n /// public static Vector64 ShiftRightLogicalNarrowingLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vshrn_n_s16 (int16x8_t a, const int n) - /// A32: VSHRN.I16 Dd, Qm, #n - /// A64: SHRN Vd.8B, Vn.8H, #n + /// int8x8_t vshrn_n_s16 (int16x8_t a, const int n) + /// A32: VSHRN.I16 Dd, Qm, #n + /// A64: SHRN Vd.8B, Vn.8H, #n /// public static Vector64 ShiftRightLogicalNarrowingLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vshrn_n_u32 (uint32x4_t a, const int n) - /// A32: VSHRN.I32 Dd, Qm, #n - /// A64: SHRN Vd.4H, Vn.4S, #n + /// uint16x4_t vshrn_n_u32 (uint32x4_t a, const int n) + /// A32: VSHRN.I32 Dd, Qm, #n + /// A64: SHRN Vd.4H, Vn.4S, #n /// public static Vector64 ShiftRightLogicalNarrowingLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vshrn_n_u64 (uint64x2_t a, const int n) - /// A32: VSHRN.I64 Dd, Qm, #n - /// A64: SHRN Vd.2S, Vn.2D, #n + /// uint32x2_t vshrn_n_u64 (uint64x2_t a, const int n) + /// A32: VSHRN.I64 Dd, Qm, #n + /// A64: SHRN Vd.2S, Vn.2D, #n /// public static Vector64 ShiftRightLogicalNarrowingLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vqshrn_n_u16 (uint16x8_t a, const int n) - /// A32: VQSHRN.U16 Dd, Qm, #n - /// A64: UQSHRN Vd.8B, Vn.8H, #n + /// uint8x8_t vqshrn_n_u16 (uint16x8_t a, const int n) + /// A32: VQSHRN.U16 Dd, Qm, #n + /// A64: UQSHRN Vd.8B, Vn.8H, #n /// public static Vector64 ShiftRightLogicalNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vqshrn_n_u32 (uint32x4_t a, const int n) - /// A32: VQSHRN.U32 Dd, Qm, #n - /// A64: UQSHRN Vd.4H, Vn.4S, #n + /// uint16x4_t vqshrn_n_u32 (uint32x4_t a, const int n) + /// A32: VQSHRN.U32 Dd, Qm, #n + /// A64: UQSHRN Vd.4H, Vn.4S, #n /// public static Vector64 ShiftRightLogicalNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vqshrn_n_u64 (uint64x2_t a, const int n) - /// A32: VQSHRN.U64 Dd, Qm, #n - /// A64: UQSHRN Vd.2S, Vn.2D, #n + /// uint32x2_t vqshrn_n_u64 (uint64x2_t a, const int n) + /// A32: VQSHRN.U64 Dd, Qm, #n + /// A64: UQSHRN Vd.2S, Vn.2D, #n /// public static Vector64 ShiftRightLogicalNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vqshrn_n_u16 (uint16x8_t a, const int n) - /// A32: VQSHRN.U16 Dd, Qm, #n - /// A64: UQSHRN Vd.8B, Vn.8H, #n + /// uint8x8_t vqshrn_n_u16 (uint16x8_t a, const int n) + /// A32: VQSHRN.U16 Dd, Qm, #n + /// A64: UQSHRN Vd.8B, Vn.8H, #n /// public static Vector64 ShiftRightLogicalNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vqshrn_n_u32 (uint32x4_t a, const int n) - /// A32: VQSHRN.U32 Dd, Qm, #n - /// A64: UQSHRN Vd.4H, Vn.4S, #n + /// uint16x4_t vqshrn_n_u32 (uint32x4_t a, const int n) + /// A32: VQSHRN.U32 Dd, Qm, #n + /// A64: UQSHRN Vd.4H, Vn.4S, #n /// public static Vector64 ShiftRightLogicalNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vqshrn_n_u64 (uint64x2_t a, const int n) - /// A32: VQSHRN.U64 Dd, Qm, #n - /// A64: UQSHRN Vd.2S, Vn.2D, #n + /// uint32x2_t vqshrn_n_u64 (uint64x2_t a, const int n) + /// A32: VQSHRN.U64 Dd, Qm, #n + /// A64: UQSHRN Vd.2S, Vn.2D, #n /// public static Vector64 ShiftRightLogicalNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vqshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n) - /// A32: VQSHRN.U16 Dd+1, Qm, #n - /// A64: UQSHRN2 Vd.16B, Vn.8H, #n + /// uint8x16_t vqshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n) + /// A32: VQSHRN.U16 Dd+1, Qm, #n + /// A64: UQSHRN2 Vd.16B, Vn.8H, #n /// public static Vector128 ShiftRightLogicalNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vqshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n) - /// A32: VQSHRN.U32 Dd+1, Qm, #n - /// A64: UQSHRN2 Vd.8H, Vn.4S, #n + /// uint16x8_t vqshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n) + /// A32: VQSHRN.U32 Dd+1, Qm, #n + /// A64: UQSHRN2 Vd.8H, Vn.4S, #n /// public static Vector128 ShiftRightLogicalNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vqshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n) - /// A32: VQSHRN.U64 Dd+1, Qm, #n - /// A64: UQSHRN2 Vd.4S, Vn.2D, #n + /// uint32x4_t vqshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n) + /// A32: VQSHRN.U64 Dd+1, Qm, #n + /// A64: UQSHRN2 Vd.4S, Vn.2D, #n /// public static Vector128 ShiftRightLogicalNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vqshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n) - /// A32: VQSHRN.U16 Dd+1, Qm, #n - /// A64: UQSHRN2 Vd.16B, Vn.8H, #n + /// uint8x16_t vqshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n) + /// A32: VQSHRN.U16 Dd+1, Qm, #n + /// A64: UQSHRN2 Vd.16B, Vn.8H, #n /// public static Vector128 ShiftRightLogicalNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vqshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n) - /// A32: VQSHRN.U32 Dd+1, Qm, #n - /// A64: UQSHRN2 Vd.8H, Vn.4S, #n + /// uint16x8_t vqshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n) + /// A32: VQSHRN.U32 Dd+1, Qm, #n + /// A64: UQSHRN2 Vd.8H, Vn.4S, #n /// public static Vector128 ShiftRightLogicalNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vqshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n) - /// A32: VQSHRN.U64 Dd+1, Qm, #n - /// A64: UQSHRN2 Vd.4S, Vn.2D, #n + /// uint32x4_t vqshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n) + /// A32: VQSHRN.U64 Dd+1, Qm, #n + /// A64: UQSHRN2 Vd.4S, Vn.2D, #n /// public static Vector128 ShiftRightLogicalNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n) - /// A32: VSHRN.I16 Dd+1, Qm, #n - /// A64: SHRN2 Vd.16B, Vn.8H, #n + /// uint8x16_t vshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n) + /// A32: VSHRN.I16 Dd+1, Qm, #n + /// A64: SHRN2 Vd.16B, Vn.8H, #n /// public static Vector128 ShiftRightLogicalNarrowingUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n) - /// A32: VSHRN.I32 Dd+1, Qm, #n - /// A64: SHRN2 Vd.8H, Vn.4S, #n + /// int16x8_t vshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n) + /// A32: VSHRN.I32 Dd+1, Qm, #n + /// A64: SHRN2 Vd.8H, Vn.4S, #n /// public static Vector128 ShiftRightLogicalNarrowingUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n) - /// A32: VSHRN.I64 Dd+1, Qm, #n - /// A64: SHRN2 Vd.4S, Vn.2D, #n + /// int32x4_t vshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n) + /// A32: VSHRN.I64 Dd+1, Qm, #n + /// A64: SHRN2 Vd.4S, Vn.2D, #n /// public static Vector128 ShiftRightLogicalNarrowingUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n) - /// A32: VSHRN.I16 Dd+1, Qm, #n - /// A64: SHRN2 Vd.16B, Vn.8H, #n + /// int8x16_t vshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n) + /// A32: VSHRN.I16 Dd+1, Qm, #n + /// A64: SHRN2 Vd.16B, Vn.8H, #n /// public static Vector128 ShiftRightLogicalNarrowingUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n) - /// A32: VSHRN.I32 Dd+1, Qm, #n - /// A64: SHRN2 Vd.8H, Vn.4S, #n + /// uint16x8_t vshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n) + /// A32: VSHRN.I32 Dd+1, Qm, #n + /// A64: SHRN2 Vd.8H, Vn.4S, #n /// public static Vector128 ShiftRightLogicalNarrowingUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n) - /// A32: VSHRN.I64 Dd+1, Qm, #n - /// A64: SHRN2 Vd.4S, Vn.2D, #n + /// uint32x4_t vshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n) + /// A32: VSHRN.I64 Dd+1, Qm, #n + /// A64: SHRN2 Vd.4S, Vn.2D, #n /// public static Vector128 ShiftRightLogicalNarrowingUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vrshr_n_u8 (uint8x8_t a, const int n) - /// A32: VRSHR.U8 Dd, Dm, #n - /// A64: URSHR Vd.8B, Vn.8B, #n + /// uint8x8_t vrshr_n_u8 (uint8x8_t a, const int n) + /// A32: VRSHR.U8 Dd, Dm, #n + /// A64: URSHR Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightLogicalRounded(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vrshr_n_u16 (uint16x4_t a, const int n) - /// A32: VRSHR.U16 Dd, Dm, #n - /// A64: URSHR Vd.4H, Vn.4H, #n + /// uint16x4_t vrshr_n_u16 (uint16x4_t a, const int n) + /// A32: VRSHR.U16 Dd, Dm, #n + /// A64: URSHR Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightLogicalRounded(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vrshr_n_u32 (uint32x2_t a, const int n) - /// A32: VRSHR.U32 Dd, Dm, #n - /// A64: URSHR Vd.2S, Vn.2S, #n + /// uint32x2_t vrshr_n_u32 (uint32x2_t a, const int n) + /// A32: VRSHR.U32 Dd, Dm, #n + /// A64: URSHR Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightLogicalRounded(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vrshr_n_u8 (uint8x8_t a, const int n) - /// A32: VRSHR.U8 Dd, Dm, #n - /// A64: URSHR Vd.8B, Vn.8B, #n + /// uint8x8_t vrshr_n_u8 (uint8x8_t a, const int n) + /// A32: VRSHR.U8 Dd, Dm, #n + /// A64: URSHR Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightLogicalRounded(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vrshr_n_u16 (uint16x4_t a, const int n) - /// A32: VRSHR.U16 Dd, Dm, #n - /// A64: URSHR Vd.4H, Vn.4H, #n + /// uint16x4_t vrshr_n_u16 (uint16x4_t a, const int n) + /// A32: VRSHR.U16 Dd, Dm, #n + /// A64: URSHR Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightLogicalRounded(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vrshr_n_u32 (uint32x2_t a, const int n) - /// A32: VRSHR.U32 Dd, Dm, #n - /// A64: URSHR Vd.2S, Vn.2S, #n + /// uint32x2_t vrshr_n_u32 (uint32x2_t a, const int n) + /// A32: VRSHR.U32 Dd, Dm, #n + /// A64: URSHR Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightLogicalRounded(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vrshrq_n_u8 (uint8x16_t a, const int n) - /// A32: VRSHR.U8 Qd, Qm, #n - /// A64: URSHR Vd.16B, Vn.16B, #n + /// uint8x16_t vrshrq_n_u8 (uint8x16_t a, const int n) + /// A32: VRSHR.U8 Qd, Qm, #n + /// A64: URSHR Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightLogicalRounded(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vrshrq_n_u16 (uint16x8_t a, const int n) - /// A32: VRSHR.U16 Qd, Qm, #n - /// A64: URSHR Vd.8H, Vn.8H, #n + /// uint16x8_t vrshrq_n_u16 (uint16x8_t a, const int n) + /// A32: VRSHR.U16 Qd, Qm, #n + /// A64: URSHR Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightLogicalRounded(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vrshrq_n_u32 (uint32x4_t a, const int n) - /// A32: VRSHR.U32 Qd, Qm, #n - /// A64: URSHR Vd.4S, Vn.4S, #n + /// uint32x4_t vrshrq_n_u32 (uint32x4_t a, const int n) + /// A32: VRSHR.U32 Qd, Qm, #n + /// A64: URSHR Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightLogicalRounded(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vrshrq_n_u64 (uint64x2_t a, const int n) - /// A32: VRSHR.U64 Qd, Qm, #n - /// A64: URSHR Vd.2D, Vn.2D, #n + /// uint64x2_t vrshrq_n_u64 (uint64x2_t a, const int n) + /// A32: VRSHR.U64 Qd, Qm, #n + /// A64: URSHR Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightLogicalRounded(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vrshrq_n_u8 (uint8x16_t a, const int n) - /// A32: VRSHR.U8 Qd, Qm, #n - /// A64: URSHR Vd.16B, Vn.16B, #n + /// uint8x16_t vrshrq_n_u8 (uint8x16_t a, const int n) + /// A32: VRSHR.U8 Qd, Qm, #n + /// A64: URSHR Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightLogicalRounded(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vrshrq_n_u16 (uint16x8_t a, const int n) - /// A32: VRSHR.U16 Qd, Qm, #n - /// A64: URSHR Vd.8H, Vn.8H, #n + /// uint16x8_t vrshrq_n_u16 (uint16x8_t a, const int n) + /// A32: VRSHR.U16 Qd, Qm, #n + /// A64: URSHR Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightLogicalRounded(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vrshrq_n_u32 (uint32x4_t a, const int n) - /// A32: VRSHR.U32 Qd, Qm, #n - /// A64: URSHR Vd.4S, Vn.4S, #n + /// uint32x4_t vrshrq_n_u32 (uint32x4_t a, const int n) + /// A32: VRSHR.U32 Qd, Qm, #n + /// A64: URSHR Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightLogicalRounded(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vrshrq_n_u64 (uint64x2_t a, const int n) - /// A32: VRSHR.U64 Qd, Qm, #n - /// A64: URSHR Vd.2D, Vn.2D, #n + /// uint64x2_t vrshrq_n_u64 (uint64x2_t a, const int n) + /// A32: VRSHR.U64 Qd, Qm, #n + /// A64: URSHR Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightLogicalRounded(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vrsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n) - /// A32: VRSRA.U8 Dd, Dm, #n - /// A64: URSRA Vd.8B, Vn.8B, #n + /// uint8x8_t vrsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n) + /// A32: VRSRA.U8 Dd, Dm, #n + /// A64: URSRA Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightLogicalRoundedAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vrsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n) - /// A32: VRSRA.U16 Dd, Dm, #n - /// A64: URSRA Vd.4H, Vn.4H, #n + /// uint16x4_t vrsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n) + /// A32: VRSRA.U16 Dd, Dm, #n + /// A64: URSRA Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightLogicalRoundedAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vrsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n) - /// A32: VRSRA.U32 Dd, Dm, #n - /// A64: URSRA Vd.2S, Vn.2S, #n + /// uint32x2_t vrsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n) + /// A32: VRSRA.U32 Dd, Dm, #n + /// A64: URSRA Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightLogicalRoundedAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vrsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n) - /// A32: VRSRA.U8 Dd, Dm, #n - /// A64: URSRA Vd.8B, Vn.8B, #n + /// uint8x8_t vrsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n) + /// A32: VRSRA.U8 Dd, Dm, #n + /// A64: URSRA Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightLogicalRoundedAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vrsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n) - /// A32: VRSRA.U16 Dd, Dm, #n - /// A64: URSRA Vd.4H, Vn.4H, #n + /// uint16x4_t vrsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n) + /// A32: VRSRA.U16 Dd, Dm, #n + /// A64: URSRA Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightLogicalRoundedAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vrsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n) - /// A32: VRSRA.U32 Dd, Dm, #n - /// A64: URSRA Vd.2S, Vn.2S, #n + /// uint32x2_t vrsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n) + /// A32: VRSRA.U32 Dd, Dm, #n + /// A64: URSRA Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightLogicalRoundedAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vrsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n) - /// A32: VRSRA.U8 Qd, Qm, #n - /// A64: URSRA Vd.16B, Vn.16B, #n + /// uint8x16_t vrsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n) + /// A32: VRSRA.U8 Qd, Qm, #n + /// A64: URSRA Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightLogicalRoundedAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vrsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n) - /// A32: VRSRA.U16 Qd, Qm, #n - /// A64: URSRA Vd.8H, Vn.8H, #n + /// uint16x8_t vrsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n) + /// A32: VRSRA.U16 Qd, Qm, #n + /// A64: URSRA Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightLogicalRoundedAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vrsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n) - /// A32: VRSRA.U32 Qd, Qm, #n - /// A64: URSRA Vd.4S, Vn.4S, #n + /// uint32x4_t vrsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n) + /// A32: VRSRA.U32 Qd, Qm, #n + /// A64: URSRA Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightLogicalRoundedAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vrsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n) - /// A32: VRSRA.U64 Qd, Qm, #n - /// A64: URSRA Vd.2D, Vn.2D, #n + /// uint64x2_t vrsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n) + /// A32: VRSRA.U64 Qd, Qm, #n + /// A64: URSRA Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightLogicalRoundedAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vrsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n) - /// A32: VRSRA.U8 Qd, Qm, #n - /// A64: URSRA Vd.16B, Vn.16B, #n + /// uint8x16_t vrsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n) + /// A32: VRSRA.U8 Qd, Qm, #n + /// A64: URSRA Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightLogicalRoundedAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vrsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n) - /// A32: VRSRA.U16 Qd, Qm, #n - /// A64: URSRA Vd.8H, Vn.8H, #n + /// uint16x8_t vrsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n) + /// A32: VRSRA.U16 Qd, Qm, #n + /// A64: URSRA Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightLogicalRoundedAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vrsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n) - /// A32: VRSRA.U32 Qd, Qm, #n - /// A64: URSRA Vd.4S, Vn.4S, #n + /// uint32x4_t vrsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n) + /// A32: VRSRA.U32 Qd, Qm, #n + /// A64: URSRA Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightLogicalRoundedAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vrsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n) - /// A32: VRSRA.U64 Qd, Qm, #n - /// A64: URSRA Vd.2D, Vn.2D, #n + /// uint64x2_t vrsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n) + /// A32: VRSRA.U64 Qd, Qm, #n + /// A64: URSRA Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightLogicalRoundedAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vrsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n) - /// A32: VRSRA.U64 Dd, Dm, #n - /// A64: URSRA Dd, Dn, #n + /// uint64x1_t vrsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n) + /// A32: VRSRA.U64 Dd, Dm, #n + /// A64: URSRA Dd, Dn, #n /// public static Vector64 ShiftRightLogicalRoundedAddScalar(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vrsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n) - /// A32: VRSRA.U64 Dd, Dm, #n - /// A64: URSRA Dd, Dn, #n + /// uint64x1_t vrsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n) + /// A32: VRSRA.U64 Dd, Dm, #n + /// A64: URSRA Dd, Dn, #n /// public static Vector64 ShiftRightLogicalRoundedAddScalar(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vrshrn_n_u16 (uint16x8_t a, const int n) - /// A32: VRSHRN.I16 Dd, Qm, #n - /// A64: RSHRN Vd.8B, Vn.8H, #n + /// uint8x8_t vrshrn_n_u16 (uint16x8_t a, const int n) + /// A32: VRSHRN.I16 Dd, Qm, #n + /// A64: RSHRN Vd.8B, Vn.8H, #n /// public static Vector64 ShiftRightLogicalRoundedNarrowingLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vrshrn_n_s32 (int32x4_t a, const int n) - /// A32: VRSHRN.I32 Dd, Qm, #n - /// A64: RSHRN Vd.4H, Vn.4S, #n + /// int16x4_t vrshrn_n_s32 (int32x4_t a, const int n) + /// A32: VRSHRN.I32 Dd, Qm, #n + /// A64: RSHRN Vd.4H, Vn.4S, #n /// public static Vector64 ShiftRightLogicalRoundedNarrowingLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vrshrn_n_s64 (int64x2_t a, const int n) - /// A32: VRSHRN.I64 Dd, Qm, #n - /// A64: RSHRN Vd.2S, Vn.2D, #n + /// int32x2_t vrshrn_n_s64 (int64x2_t a, const int n) + /// A32: VRSHRN.I64 Dd, Qm, #n + /// A64: RSHRN Vd.2S, Vn.2D, #n /// public static Vector64 ShiftRightLogicalRoundedNarrowingLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vrshrn_n_s16 (int16x8_t a, const int n) - /// A32: VRSHRN.I16 Dd, Qm, #n - /// A64: RSHRN Vd.8B, Vn.8H, #n + /// int8x8_t vrshrn_n_s16 (int16x8_t a, const int n) + /// A32: VRSHRN.I16 Dd, Qm, #n + /// A64: RSHRN Vd.8B, Vn.8H, #n /// public static Vector64 ShiftRightLogicalRoundedNarrowingLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vrshrn_n_u32 (uint32x4_t a, const int n) - /// A32: VRSHRN.I32 Dd, Qm, #n - /// A64: RSHRN Vd.4H, Vn.4S, #n + /// uint16x4_t vrshrn_n_u32 (uint32x4_t a, const int n) + /// A32: VRSHRN.I32 Dd, Qm, #n + /// A64: RSHRN Vd.4H, Vn.4S, #n /// public static Vector64 ShiftRightLogicalRoundedNarrowingLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vrshrn_n_u64 (uint64x2_t a, const int n) - /// A32: VRSHRN.I64 Dd, Qm, #n - /// A64: RSHRN Vd.2S, Vn.2D, #n + /// uint32x2_t vrshrn_n_u64 (uint64x2_t a, const int n) + /// A32: VRSHRN.I64 Dd, Qm, #n + /// A64: RSHRN Vd.2S, Vn.2D, #n /// public static Vector64 ShiftRightLogicalRoundedNarrowingLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vqrshrn_n_u16 (uint16x8_t a, const int n) - /// A32: VQRSHRN.U16 Dd, Qm, #n - /// A64: UQRSHRN Vd.8B, Vn.8H, #n + /// uint8x8_t vqrshrn_n_u16 (uint16x8_t a, const int n) + /// A32: VQRSHRN.U16 Dd, Qm, #n + /// A64: UQRSHRN Vd.8B, Vn.8H, #n /// public static Vector64 ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vqrshrn_n_u32 (uint32x4_t a, const int n) - /// A32: VQRSHRN.U32 Dd, Qm, #n - /// A64: UQRSHRN Vd.4H, Vn.4S, #n + /// uint16x4_t vqrshrn_n_u32 (uint32x4_t a, const int n) + /// A32: VQRSHRN.U32 Dd, Qm, #n + /// A64: UQRSHRN Vd.4H, Vn.4S, #n /// [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)] public static Vector64 ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vqrshrn_n_u64 (uint64x2_t a, const int n) - /// A32: VQRSHRN.U64 Dd, Qm, #n - /// A64: UQRSHRN Vd.2S, Vn.2D, #n + /// uint32x2_t vqrshrn_n_u64 (uint64x2_t a, const int n) + /// A32: VQRSHRN.U64 Dd, Qm, #n + /// A64: UQRSHRN Vd.2S, Vn.2D, #n /// [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)] public static Vector64 ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vqrshrn_n_u16 (uint16x8_t a, const int n) - /// A32: VQRSHRN.U16 Dd, Qm, #n - /// A64: UQRSHRN Vd.8B, Vn.8H, #n + /// uint8x8_t vqrshrn_n_u16 (uint16x8_t a, const int n) + /// A32: VQRSHRN.U16 Dd, Qm, #n + /// A64: UQRSHRN Vd.8B, Vn.8H, #n /// [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)] public static Vector64 ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vqrshrn_n_u32 (uint32x4_t a, const int n) - /// A32: VQRSHRN.U32 Dd, Qm, #n - /// A64: UQRSHRN Vd.4H, Vn.4S, #n + /// uint16x4_t vqrshrn_n_u32 (uint32x4_t a, const int n) + /// A32: VQRSHRN.U32 Dd, Qm, #n + /// A64: UQRSHRN Vd.4H, Vn.4S, #n /// public static Vector64 ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vqrshrn_n_u64 (uint64x2_t a, const int n) - /// A32: VQRSHRN.U64 Dd, Qm, #n - /// A64: UQRSHRN Vd.2S, Vn.2D, #n + /// uint32x2_t vqrshrn_n_u64 (uint64x2_t a, const int n) + /// A32: VQRSHRN.U64 Dd, Qm, #n + /// A64: UQRSHRN Vd.2S, Vn.2D, #n /// public static Vector64 ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vqrshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n) - /// A32: VQRSHRN.U16 Dd+1, Dn, #n - /// A64: UQRSHRN2 Vd.16B, Vn.8H, #n + /// uint8x16_t vqrshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n) + /// A32: VQRSHRN.U16 Dd+1, Dn, #n + /// A64: UQRSHRN2 Vd.16B, Vn.8H, #n /// public static Vector128 ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vqrshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n) - /// A32: VQRSHRN.U32 Dd+1, Dn, #n - /// A64: UQRSHRN2 Vd.8H, Vn.4S, #n + /// uint16x8_t vqrshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n) + /// A32: VQRSHRN.U32 Dd+1, Dn, #n + /// A64: UQRSHRN2 Vd.8H, Vn.4S, #n /// [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)] public static Vector128 ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vqrshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n) - /// A32: VQRSHRN.U64 Dd+1, Dn, #n - /// A64: UQRSHRN2 Vd.4S, Vn.2D, #n + /// uint32x4_t vqrshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n) + /// A32: VQRSHRN.U64 Dd+1, Dn, #n + /// A64: UQRSHRN2 Vd.4S, Vn.2D, #n /// [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)] public static Vector128 ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vqrshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n) - /// A32: VQRSHRN.U16 Dd+1, Dn, #n - /// A64: UQRSHRN2 Vd.16B, Vn.8H, #n + /// uint8x16_t vqrshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n) + /// A32: VQRSHRN.U16 Dd+1, Dn, #n + /// A64: UQRSHRN2 Vd.16B, Vn.8H, #n /// [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)] public static Vector128 ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vqrshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n) - /// A32: VQRSHRN.U32 Dd+1, Dn, #n - /// A64: UQRSHRN2 Vd.8H, Vn.4S, #n + /// uint16x8_t vqrshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n) + /// A32: VQRSHRN.U32 Dd+1, Dn, #n + /// A64: UQRSHRN2 Vd.8H, Vn.4S, #n /// public static Vector128 ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vqrshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n) - /// A32: VQRSHRN.U64 Dd+1, Dn, #n - /// A64: UQRSHRN2 Vd.4S, Vn.2D, #n + /// uint32x4_t vqrshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n) + /// A32: VQRSHRN.U64 Dd+1, Dn, #n + /// A64: UQRSHRN2 Vd.4S, Vn.2D, #n /// public static Vector128 ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vrshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n) - /// A32: VRSHRN.I16 Dd+1, Qm, #n - /// A64: RSHRN2 Vd.16B, Vn.8H, #n + /// uint8x16_t vrshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n) + /// A32: VRSHRN.I16 Dd+1, Qm, #n + /// A64: RSHRN2 Vd.16B, Vn.8H, #n /// public static Vector128 ShiftRightLogicalRoundedNarrowingUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vrshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n) - /// A32: VRSHRN.I32 Dd+1, Qm, #n - /// A64: RSHRN2 Vd.8H, Vn.4S, #n + /// int16x8_t vrshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n) + /// A32: VRSHRN.I32 Dd+1, Qm, #n + /// A64: RSHRN2 Vd.8H, Vn.4S, #n /// public static Vector128 ShiftRightLogicalRoundedNarrowingUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vrshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n) - /// A32: VRSHRN.I64 Dd+1, Qm, #n - /// A64: RSHRN2 Vd.4S, Vn.2D, #n + /// int32x4_t vrshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n) + /// A32: VRSHRN.I64 Dd+1, Qm, #n + /// A64: RSHRN2 Vd.4S, Vn.2D, #n /// public static Vector128 ShiftRightLogicalRoundedNarrowingUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vrshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n) - /// A32: VRSHRN.I16 Dd+1, Qm, #n - /// A64: RSHRN2 Vd.16B, Vn.8H, #n + /// int8x16_t vrshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n) + /// A32: VRSHRN.I16 Dd+1, Qm, #n + /// A64: RSHRN2 Vd.16B, Vn.8H, #n /// public static Vector128 ShiftRightLogicalRoundedNarrowingUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vrshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n) - /// A32: VRSHRN.I32 Dd+1, Qm, #n - /// A64: RSHRN2 Vd.8H, Vn.4S, #n + /// uint16x8_t vrshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n) + /// A32: VRSHRN.I32 Dd+1, Qm, #n + /// A64: RSHRN2 Vd.8H, Vn.4S, #n /// public static Vector128 ShiftRightLogicalRoundedNarrowingUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vrshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n) - /// A32: VRSHRN.I64 Dd+1, Qm, #n - /// A64: RSHRN2 Vd.4S, Vn.2D, #n + /// uint32x4_t vrshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n) + /// A32: VRSHRN.I64 Dd+1, Qm, #n + /// A64: RSHRN2 Vd.4S, Vn.2D, #n /// public static Vector128 ShiftRightLogicalRoundedNarrowingUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vrshr_n_u64 (uint64x1_t a, const int n) - /// A32: VRSHR.U64 Dd, Dm, #n - /// A64: URSHR Dd, Dn, #n + /// uint64x1_t vrshr_n_u64 (uint64x1_t a, const int n) + /// A32: VRSHR.U64 Dd, Dm, #n + /// A64: URSHR Dd, Dn, #n /// public static Vector64 ShiftRightLogicalRoundedScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vrshr_n_u64 (uint64x1_t a, const int n) - /// A32: VRSHR.U64 Dd, Dm, #n - /// A64: URSHR Dd, Dn, #n + /// uint64x1_t vrshr_n_u64 (uint64x1_t a, const int n) + /// A32: VRSHR.U64 Dd, Dm, #n + /// A64: URSHR Dd, Dn, #n /// public static Vector64 ShiftRightLogicalRoundedScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vshr_n_u64 (uint64x1_t a, const int n) - /// A32: VSHR.U64 Dd, Dm, #n - /// A64: USHR Dd, Dn, #n + /// uint64x1_t vshr_n_u64 (uint64x1_t a, const int n) + /// A32: VSHR.U64 Dd, Dm, #n + /// A64: USHR Dd, Dn, #n /// public static Vector64 ShiftRightLogicalScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vshr_n_u64 (uint64x1_t a, const int n) - /// A32: VSHR.U64 Dd, Dm, #n - /// A64: USHR Dd, Dn, #n + /// uint64x1_t vshr_n_u64 (uint64x1_t a, const int n) + /// A32: VSHR.U64 Dd, Dm, #n + /// A64: USHR Dd, Dn, #n /// public static Vector64 ShiftRightLogicalScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmovl_s16 (int16x4_t a) - /// A32: VMOVL.S16 Qd, Dm - /// A64: SXTL Vd.4S, Vn.4H + /// int32x4_t vmovl_s16 (int16x4_t a) + /// A32: VMOVL.S16 Qd, Dm + /// A64: SXTL Vd.4S, Vn.4H /// public static Vector128 SignExtendWideningLower(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vmovl_s32 (int32x2_t a) - /// A32: VMOVL.S32 Qd, Dm - /// A64: SXTL Vd.2D, Vn.2S + /// int64x2_t vmovl_s32 (int32x2_t a) + /// A32: VMOVL.S32 Qd, Dm + /// A64: SXTL Vd.2D, Vn.2S /// public static Vector128 SignExtendWideningLower(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vmovl_s8 (int8x8_t a) - /// A32: VMOVL.S8 Qd, Dm - /// A64: SXTL Vd.8H, Vn.8B + /// int16x8_t vmovl_s8 (int8x8_t a) + /// A32: VMOVL.S8 Qd, Dm + /// A64: SXTL Vd.8H, Vn.8B /// public static Vector128 SignExtendWideningLower(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vmovl_high_s16 (int16x8_t a) - /// A32: VMOVL.S16 Qd, Dm+1 - /// A64: SXTL2 Vd.4S, Vn.8H + /// int32x4_t vmovl_high_s16 (int16x8_t a) + /// A32: VMOVL.S16 Qd, Dm+1 + /// A64: SXTL2 Vd.4S, Vn.8H /// public static Vector128 SignExtendWideningUpper(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vmovl_high_s32 (int32x4_t a) - /// A32: VMOVL.S32 Qd, Dm+1 - /// A64: SXTL2 Vd.2D, Vn.4S + /// int64x2_t vmovl_high_s32 (int32x4_t a) + /// A32: VMOVL.S32 Qd, Dm+1 + /// A64: SXTL2 Vd.2D, Vn.4S /// public static Vector128 SignExtendWideningUpper(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vmovl_high_s8 (int8x16_t a) - /// A32: VMOVL.S8 Qd, Dm+1 - /// A64: SXTL2 Vd.8H, Vn.16B + /// int16x8_t vmovl_high_s8 (int8x16_t a) + /// A32: VMOVL.S8 Qd, Dm+1 + /// A64: SXTL2 Vd.8H, Vn.16B /// public static Vector128 SignExtendWideningUpper(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vsqrt_f64 (float64x1_t a) - /// A32: VSQRT.F64 Dd, Dm - /// A64: FSQRT Dd, Dn + /// float64x1_t vsqrt_f64 (float64x1_t a) + /// A32: VSQRT.F64 Dd, Dm + /// A64: FSQRT Dd, Dn /// public static Vector64 SqrtScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// float32_t vsqrts_f32 (float32_t a) - /// A32: VSQRT.F32 Sd, Sm - /// A64: FSQRT Sd, Sn - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vsqrts_f32 (float32_t a) + /// A32: VSQRT.F32 Sd, Sm + /// A64: FSQRT Sd, Sn + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 SqrtScalar(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// void vst1_u8 (uint8_t * ptr, uint8x8_t val) - /// A32: VST1.8 { Dd }, [Rn] - /// A64: ST1 { Vt.8B }, [Xn] + /// void vst1_u8 (uint8_t * ptr, uint8x8_t val) + /// A32: VST1.8 { Dd }, [Rn] + /// A64: ST1 { Vt.8B }, [Xn] /// public static unsafe void Store(byte* address, Vector64 source) { throw new PlatformNotSupportedException(); } /// - /// void vst1_f64 (float64_t * ptr, float64x1_t val) - /// A32: VST1.64 { Dd }, [Rn] - /// A64: ST1 { Vt.1D }, [Xn] + /// void vst1_f64 (float64_t * ptr, float64x1_t val) + /// A32: VST1.64 { Dd }, [Rn] + /// A64: ST1 { Vt.1D }, [Xn] /// public static unsafe void Store(double* address, Vector64 source) { throw new PlatformNotSupportedException(); } /// - /// void vst1_s16 (int16_t * ptr, int16x4_t val) - /// A32: VST1.16 { Dd }, [Rn] - /// A64: ST1 {Vt.4H }, [Xn] + /// void vst1_s16 (int16_t * ptr, int16x4_t val) + /// A32: VST1.16 { Dd }, [Rn] + /// A64: ST1 {Vt.4H }, [Xn] /// public static unsafe void Store(short* address, Vector64 source) { throw new PlatformNotSupportedException(); } /// - /// void vst1_s32 (int32_t * ptr, int32x2_t val) - /// A32: VST1.32 { Dd }, [Rn] - /// A64: ST1 { Vt.2S }, [Xn] + /// void vst1_s32 (int32_t * ptr, int32x2_t val) + /// A32: VST1.32 { Dd }, [Rn] + /// A64: ST1 { Vt.2S }, [Xn] /// public static unsafe void Store(int* address, Vector64 source) { throw new PlatformNotSupportedException(); } /// - /// void vst1_s64 (int64_t * ptr, int64x1_t val) - /// A32: VST1.64 { Dd }, [Rn] - /// A64: ST1 { Vt.1D }, [Xn] + /// void vst1_s64 (int64_t * ptr, int64x1_t val) + /// A32: VST1.64 { Dd }, [Rn] + /// A64: ST1 { Vt.1D }, [Xn] /// public static unsafe void Store(long* address, Vector64 source) { throw new PlatformNotSupportedException(); } /// - /// void vst1_s8 (int8_t * ptr, int8x8_t val) - /// A32: VST1.8 { Dd }, [Rn] - /// A64: ST1 { Vt.8B }, [Xn] + /// void vst1_s8 (int8_t * ptr, int8x8_t val) + /// A32: VST1.8 { Dd }, [Rn] + /// A64: ST1 { Vt.8B }, [Xn] /// public static unsafe void Store(sbyte* address, Vector64 source) { throw new PlatformNotSupportedException(); } /// - /// void vst1_f32 (float32_t * ptr, float32x2_t val) - /// A32: VST1.32 { Dd }, [Rn] - /// A64: ST1 { Vt.2S }, [Xn] + /// void vst1_f32 (float32_t * ptr, float32x2_t val) + /// A32: VST1.32 { Dd }, [Rn] + /// A64: ST1 { Vt.2S }, [Xn] /// public static unsafe void Store(float* address, Vector64 source) { throw new PlatformNotSupportedException(); } /// - /// void vst1_u16 (uint16_t * ptr, uint16x4_t val) - /// A32: VST1.16 { Dd }, [Rn] - /// A64: ST1 { Vt.4H }, [Xn] + /// void vst1_u16 (uint16_t * ptr, uint16x4_t val) + /// A32: VST1.16 { Dd }, [Rn] + /// A64: ST1 { Vt.4H }, [Xn] /// public static unsafe void Store(ushort* address, Vector64 source) { throw new PlatformNotSupportedException(); } /// - /// void vst1_u32 (uint32_t * ptr, uint32x2_t val) - /// A32: VST1.32 { Dd }, [Rn] - /// A64: ST1 { Vt.2S }, [Xn] + /// void vst1_u32 (uint32_t * ptr, uint32x2_t val) + /// A32: VST1.32 { Dd }, [Rn] + /// A64: ST1 { Vt.2S }, [Xn] /// public static unsafe void Store(uint* address, Vector64 source) { throw new PlatformNotSupportedException(); } /// - /// void vst1_u64 (uint64_t * ptr, uint64x1_t val) - /// A32: VST1.64 { Dd }, [Rn] - /// A64: ST1 { Vt.1D }, [Xn] + /// void vst1_u64 (uint64_t * ptr, uint64x1_t val) + /// A32: VST1.64 { Dd }, [Rn] + /// A64: ST1 { Vt.1D }, [Xn] /// public static unsafe void Store(ulong* address, Vector64 source) { throw new PlatformNotSupportedException(); } /// - /// void vst1q_u8 (uint8_t * ptr, uint8x16_t val) - /// A32: VST1.8 { Dd, Dd+1 }, [Rn] - /// A64: ST1 { Vt.16B }, [Xn] + /// void vst1q_u8 (uint8_t * ptr, uint8x16_t val) + /// A32: VST1.8 { Dd, Dd+1 }, [Rn] + /// A64: ST1 { Vt.16B }, [Xn] /// public static unsafe void Store(byte* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void vst1q_f64 (float64_t * ptr, float64x2_t val) - /// A32: VST1.64 { Dd, Dd+1 }, [Rn] - /// A64: ST1 { Vt.2D }, [Xn] + /// void vst1q_f64 (float64_t * ptr, float64x2_t val) + /// A32: VST1.64 { Dd, Dd+1 }, [Rn] + /// A64: ST1 { Vt.2D }, [Xn] /// public static unsafe void Store(double* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void vst1q_s16 (int16_t * ptr, int16x8_t val) - /// A32: VST1.16 { Dd, Dd+1 }, [Rn] - /// A64: ST1 { Vt.8H }, [Xn] + /// void vst1q_s16 (int16_t * ptr, int16x8_t val) + /// A32: VST1.16 { Dd, Dd+1 }, [Rn] + /// A64: ST1 { Vt.8H }, [Xn] /// public static unsafe void Store(short* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void vst1q_s32 (int32_t * ptr, int32x4_t val) - /// A32: VST1.32 { Dd, Dd+1 }, [Rn] - /// A64: ST1 { Vt.4S }, [Xn] + /// void vst1q_s32 (int32_t * ptr, int32x4_t val) + /// A32: VST1.32 { Dd, Dd+1 }, [Rn] + /// A64: ST1 { Vt.4S }, [Xn] /// public static unsafe void Store(int* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void vst1q_s64 (int64_t * ptr, int64x2_t val) - /// A32: VST1.64 { Dd, Dd+1 }, [Rn] - /// A64: ST1 { Vt.2D }, [Xn] + /// void vst1q_s64 (int64_t * ptr, int64x2_t val) + /// A32: VST1.64 { Dd, Dd+1 }, [Rn] + /// A64: ST1 { Vt.2D }, [Xn] /// public static unsafe void Store(long* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void vst1q_s8 (int8_t * ptr, int8x16_t val) - /// A32: VST1.8 { Dd, Dd+1 }, [Rn] - /// A64: ST1 { Vt.16B }, [Xn] + /// void vst1q_s8 (int8_t * ptr, int8x16_t val) + /// A32: VST1.8 { Dd, Dd+1 }, [Rn] + /// A64: ST1 { Vt.16B }, [Xn] /// public static unsafe void Store(sbyte* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void vst1q_f32 (float32_t * ptr, float32x4_t val) - /// A32: VST1.32 { Dd, Dd+1 }, [Rn] - /// A64: ST1 { Vt.4S }, [Xn] + /// void vst1q_f32 (float32_t * ptr, float32x4_t val) + /// A32: VST1.32 { Dd, Dd+1 }, [Rn] + /// A64: ST1 { Vt.4S }, [Xn] /// public static unsafe void Store(float* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void vst1q_u16 (uint16_t * ptr, uint16x8_t val) - /// A32: VST1.16 { Dd, Dd+1 }, [Rn] - /// A64: ST1 { Vt.8H }, [Xn] + /// void vst1q_u16 (uint16_t * ptr, uint16x8_t val) + /// A32: VST1.16 { Dd, Dd+1 }, [Rn] + /// A64: ST1 { Vt.8H }, [Xn] /// public static unsafe void Store(ushort* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void vst1q_u32 (uint32_t * ptr, uint32x4_t val) - /// A32: VST1.32 { Dd, Dd+1 }, [Rn] - /// A64: ST1 { Vt.4S }, [Xn] + /// void vst1q_u32 (uint32_t * ptr, uint32x4_t val) + /// A32: VST1.32 { Dd, Dd+1 }, [Rn] + /// A64: ST1 { Vt.4S }, [Xn] /// public static unsafe void Store(uint* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void vst1q_u64 (uint64_t * ptr, uint64x2_t val) - /// A32: VST1.64 { Dd, Dd+1 }, [Rn] - /// A64: ST1 { Vt.2D }, [Xn] + /// void vst1q_u64 (uint64_t * ptr, uint64x2_t val) + /// A32: VST1.64 { Dd, Dd+1 }, [Rn] + /// A64: ST1 { Vt.2D }, [Xn] /// public static unsafe void Store(ulong* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void vst1_lane_u8 (uint8_t * ptr, uint8x8_t val, const int lane) - /// A32: VST1.8 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.B }[index], [Xn] + /// void vst1_lane_u8 (uint8_t * ptr, uint8x8_t val, const int lane) + /// A32: VST1.8 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.B }[index], [Xn] /// public static unsafe void StoreSelectedScalar(byte* address, Vector64 value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst1_lane_s16 (int16_t * ptr, int16x4_t val, const int lane) - /// A32: VST1.16 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.H }[index], [Xn] + /// void vst1_lane_s16 (int16_t * ptr, int16x4_t val, const int lane) + /// A32: VST1.16 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.H }[index], [Xn] /// public static unsafe void StoreSelectedScalar(short* address, Vector64 value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst1_lane_s32 (int32_t * ptr, int32x2_t val, const int lane) - /// A32: VST1.32 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.S }[index], [Xn] + /// void vst1_lane_s32 (int32_t * ptr, int32x2_t val, const int lane) + /// A32: VST1.32 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(int* address, Vector64 value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst1_lane_s8 (int8_t * ptr, int8x8_t val, const int lane) - /// A32: VST1.8 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.B }[index], [Xn] + /// void vst1_lane_s8 (int8_t * ptr, int8x8_t val, const int lane) + /// A32: VST1.8 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.B }[index], [Xn] /// public static unsafe void StoreSelectedScalar(sbyte* address, Vector64 value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst1_lane_f32 (float32_t * ptr, float32x2_t val, const int lane) - /// A32: VST1.32 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.S }[index], [Xn] + /// void vst1_lane_f32 (float32_t * ptr, float32x2_t val, const int lane) + /// A32: VST1.32 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(float* address, Vector64 value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst1_lane_u16 (uint16_t * ptr, uint16x4_t val, const int lane) - /// A32: VST1.16 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.H }[index], [Xn] + /// void vst1_lane_u16 (uint16_t * ptr, uint16x4_t val, const int lane) + /// A32: VST1.16 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.H }[index], [Xn] /// public static unsafe void StoreSelectedScalar(ushort* address, Vector64 value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst1_lane_u32 (uint32_t * ptr, uint32x2_t val, const int lane) - /// A32: VST1.32 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.S }[index], [Xn] + /// void vst1_lane_u32 (uint32_t * ptr, uint32x2_t val, const int lane) + /// A32: VST1.32 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(uint* address, Vector64 value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst1q_lane_u8 (uint8_t * ptr, uint8x16_t val, const int lane) - /// A32: VST1.8 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.B }[index], [Xn] + /// void vst1q_lane_u8 (uint8_t * ptr, uint8x16_t val, const int lane) + /// A32: VST1.8 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.B }[index], [Xn] /// public static unsafe void StoreSelectedScalar(byte* address, Vector128 value, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst1q_lane_f64 (float64_t * ptr, float64x2_t val, const int lane) - /// A32: VSTR.64 Dd, [Rn] - /// A64: ST1 { Vt.D }[index], [Xn] + /// void vst1q_lane_f64 (float64_t * ptr, float64x2_t val, const int lane) + /// A32: VSTR.64 Dd, [Rn] + /// A64: ST1 { Vt.D }[index], [Xn] /// public static unsafe void StoreSelectedScalar(double* address, Vector128 value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst1q_lane_s16 (int16_t * ptr, int16x8_t val, const int lane) - /// A32: VST1.16 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.H }[index], [Xn] + /// void vst1q_lane_s16 (int16_t * ptr, int16x8_t val, const int lane) + /// A32: VST1.16 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.H }[index], [Xn] /// public static unsafe void StoreSelectedScalar(short* address, Vector128 value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst1q_lane_s32 (int32_t * ptr, int32x4_t val, const int lane) - /// A32: VST1.32 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.S }[index], [Xn] + /// void vst1q_lane_s32 (int32_t * ptr, int32x4_t val, const int lane) + /// A32: VST1.32 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(int* address, Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst1q_lane_s64 (int64_t * ptr, int64x2_t val, const int lane) - /// A32: VSTR.64 Dd, [Rn] - /// A64: ST1 { Vt.D }[index], [Xn] + /// void vst1q_lane_s64 (int64_t * ptr, int64x2_t val, const int lane) + /// A32: VSTR.64 Dd, [Rn] + /// A64: ST1 { Vt.D }[index], [Xn] /// public static unsafe void StoreSelectedScalar(long* address, Vector128 value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst1q_lane_s8 (int8_t * ptr, int8x16_t val, const int lane) - /// A32: VST1.8 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.B }[index], [Xn] + /// void vst1q_lane_s8 (int8_t * ptr, int8x16_t val, const int lane) + /// A32: VST1.8 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.B }[index], [Xn] /// public static unsafe void StoreSelectedScalar(sbyte* address, Vector128 value, [ConstantExpected(Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst1q_lane_f32 (float32_t * ptr, float32x4_t val, const int lane) - /// A32: VST1.32 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.S }[index], [Xn] + /// void vst1q_lane_f32 (float32_t * ptr, float32x4_t val, const int lane) + /// A32: VST1.32 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(float* address, Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst1q_lane_u16 (uint16_t * ptr, uint16x8_t val, const int lane) - /// A32: VST1.16 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.H }[index], [Xn] + /// void vst1q_lane_u16 (uint16_t * ptr, uint16x8_t val, const int lane) + /// A32: VST1.16 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.H }[index], [Xn] /// public static unsafe void StoreSelectedScalar(ushort* address, Vector128 value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst1q_lane_u32 (uint32_t * ptr, uint32x4_t val, const int lane) - /// A32: VST1.32 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.S }[index], [Xn] + /// void vst1q_lane_u32 (uint32_t * ptr, uint32x4_t val, const int lane) + /// A32: VST1.32 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(uint* address, Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } /// - /// void vst1q_lane_u64 (uint64_t * ptr, uint64x2_t val, const int lane) - /// A32: VSTR.64 Dd, [Rn] - /// A64: ST1 { Vt.D }[index], [Xn] + /// void vst1q_lane_u64 (uint64_t * ptr, uint64x2_t val, const int lane) + /// A32: VSTR.64 Dd, [Rn] + /// A64: ST1 { Vt.D }[index], [Xn] /// public static unsafe void StoreSelectedScalar(ulong* address, Vector128 value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vt.8B, Vt+1.8B }[index], [Xn] - /// + /// A64: ST2 { Vt.8B, Vt+1.8B }[index], [Xn] public static unsafe void StoreSelectedScalar(byte* address, (Vector64 value1, Vector64 value2) value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vt.8B, Vt+1.8B }[index], [Xn] - /// + /// A64: ST2 { Vt.8B, Vt+1.8B }[index], [Xn] public static unsafe void StoreSelectedScalar(sbyte* address, (Vector64 value1, Vector64 value2) value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vt.4H, Vt+1.4H }[index], [Xn] - /// + /// A64: ST2 { Vt.4H, Vt+1.4H }[index], [Xn] public static unsafe void StoreSelectedScalar(short* address, (Vector64 value1, Vector64 value2) value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vt.4H, Vt+1.4H }[index], [Xn] - /// + /// A64: ST2 { Vt.4H, Vt+1.4H }[index], [Xn] public static unsafe void StoreSelectedScalar(ushort* address, (Vector64 value1, Vector64 value2) value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vt.2S, Vt+1.2S }[index], [Xn] - /// + /// A64: ST2 { Vt.2S, Vt+1.2S }[index], [Xn] public static unsafe void StoreSelectedScalar(int* address, (Vector64 value1, Vector64 value2) value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vt.2S, Vt+1.2S }[index], [Xn] - /// + /// A64: ST2 { Vt.2S, Vt+1.2S }[index], [Xn] public static unsafe void StoreSelectedScalar(uint* address, (Vector64 value1, Vector64 value2) value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vt.2S, Vt+1.2S }[index], [Xn] - /// + /// A64: ST2 { Vt.2S, Vt+1.2S }[index], [Xn] public static unsafe void StoreSelectedScalar(float* address, (Vector64 value1, Vector64 value2) value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vt.8B, Vt+1.8B, Vt+2.8B }[index], [Xn] - /// + /// A64: ST3 { Vt.8B, Vt+1.8B, Vt+2.8B }[index], [Xn] public static unsafe void StoreSelectedScalar(byte* address, (Vector64 value1, Vector64 value2, Vector64 value3) value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vt.8B, Vt+1.8B, Vt+2.8B }[index], [Xn] - /// + /// A64: ST3 { Vt.8B, Vt+1.8B, Vt+2.8B }[index], [Xn] public static unsafe void StoreSelectedScalar(sbyte* address, (Vector64 value1, Vector64 value2, Vector64 value3) value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vt.4H, Vt+1.4H, Vt+2.4H }[index], [Xn] - /// + /// A64: ST3 { Vt.4H, Vt+1.4H, Vt+2.4H }[index], [Xn] public static unsafe void StoreSelectedScalar(short* address, (Vector64 value1, Vector64 value2, Vector64 value3) value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vt.4H, Vt+1.4H, Vt+2.4H }[index], [Xn] - /// + /// A64: ST3 { Vt.4H, Vt+1.4H, Vt+2.4H }[index], [Xn] public static unsafe void StoreSelectedScalar(ushort* address, (Vector64 value1, Vector64 value2, Vector64 value3) value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vt.2S, Vt+1.2S, Vt+2.2S }[index], [Xn] - /// + /// A64: ST3 { Vt.2S, Vt+1.2S, Vt+2.2S }[index], [Xn] public static unsafe void StoreSelectedScalar(int* address, (Vector64 value1, Vector64 value2, Vector64 value3) value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vt.2S, Vt+1.2S, Vt+2.2S }[index], [Xn] - /// + /// A64: ST3 { Vt.2S, Vt+1.2S, Vt+2.2S }[index], [Xn] public static unsafe void StoreSelectedScalar(uint* address, (Vector64 value1, Vector64 value2, Vector64 value3) value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vt.2S, Vt+1.2S, Vt+2.2S }[index], [Xn] - /// + /// A64: ST2 { Vt.2S, Vt+1.2S, Vt+2.2S }[index], [Xn] public static unsafe void StoreSelectedScalar(float* address, (Vector64 value1, Vector64 value2, Vector64 value3) value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vt.8B, Vt+1.8B, Vt+2.8B, Vt+3.8B }[index], [Xn] - /// + /// A64: ST4 { Vt.8B, Vt+1.8B, Vt+2.8B, Vt+3.8B }[index], [Xn] public static unsafe void StoreSelectedScalar(byte* address, (Vector64 value1, Vector64 value2, Vector64 value3, Vector64 value4) value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vt.8B, Vt+1.8B, Vt+2.8B, Vt+3.8B }[index], [Xn] - /// + /// A64: ST4 { Vt.8B, Vt+1.8B, Vt+2.8B, Vt+3.8B }[index], [Xn] public static unsafe void StoreSelectedScalar(sbyte* address, (Vector64 value1, Vector64 value2, Vector64 value3, Vector64 value4) value, [ConstantExpected(Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vt.4H, Vt+1.4H, Vt+2.4H, Vt+3.4H }[index], [Xn] - /// + /// A64: ST4 { Vt.4H, Vt+1.4H, Vt+2.4H, Vt+3.4H }[index], [Xn] public static unsafe void StoreSelectedScalar(short* address, (Vector64 value1, Vector64 value2, Vector64 value3, Vector64 value4) value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vt.4H, Vt+1.4H, Vt+2.4H, Vt+3.4H }[index], [Xn] - /// + /// A64: ST4 { Vt.4H, Vt+1.4H, Vt+2.4H, Vt+3.4H }[index], [Xn] public static unsafe void StoreSelectedScalar(ushort* address, (Vector64 value1, Vector64 value2, Vector64 value3, Vector64 value4) value, [ConstantExpected(Max = (byte)(3))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vt.2S, Vt+1.2S, Vt+2.2S, Vt+3.2S }[index], [Xn] - /// + /// A64: ST4 { Vt.2S, Vt+1.2S, Vt+2.2S, Vt+3.2S }[index], [Xn] public static unsafe void StoreSelectedScalar(int* address, (Vector64 value1, Vector64 value2, Vector64 value3, Vector64 value4) value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vt.2S, Vt+1.2S, Vt+2.2S, Vt+3.2S }[index], [Xn] - /// + /// A64: ST4 { Vt.2S, Vt+1.2S, Vt+2.2S, Vt+3.2S }[index], [Xn] public static unsafe void StoreSelectedScalar(uint* address, (Vector64 value1, Vector64 value2, Vector64 value3, Vector64 value4) value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vt.2S, Vt+1.2S, Vt+2.2S, Vt+3.2S }[index], [Xn] - /// + /// A64: ST4 { Vt.2S, Vt+1.2S, Vt+2.2S, Vt+3.2S }[index], [Xn] public static unsafe void StoreSelectedScalar(float* address, (Vector64 value1, Vector64 value2, Vector64 value3, Vector64 value4) value, [ConstantExpected(Max = (byte)(1))] byte index) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vn.8B, Vn+1.8B }, [Xn] - /// + /// A64: ST2 { Vn.8B, Vn+1.8B }, [Xn] public static unsafe void StoreVectorAndZip(byte* address, (Vector64 Value1, Vector64 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vn.8B, Vn+1.8B }, [Xn] - /// + /// A64: ST2 { Vn.8B, Vn+1.8B }, [Xn] public static unsafe void StoreVectorAndZip(sbyte* address, (Vector64 Value1, Vector64 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vn.4H, Vn+1.4H }, [Xn] - /// + /// A64: ST2 { Vn.4H, Vn+1.4H }, [Xn] public static unsafe void StoreVectorAndZip(short* address, (Vector64 Value1, Vector64 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vn.4H, Vn+1.4H }, [Xn] - /// + /// A64: ST2 { Vn.4H, Vn+1.4H }, [Xn] public static unsafe void StoreVectorAndZip(ushort* address, (Vector64 Value1, Vector64 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: ST2 { Vn.2S, Vn+1.2S }, [Xn] public static unsafe void StoreVectorAndZip(int* address, (Vector64 Value1, Vector64 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: ST2 { Vn.2S, Vn+1.2S }, [Xn] public static unsafe void StoreVectorAndZip(uint* address, (Vector64 Value1, Vector64 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST2 { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: ST2 { Vn.2S, Vn+1.2S }, [Xn] public static unsafe void StoreVectorAndZip(float* address, (Vector64 Value1, Vector64 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] - /// + /// A64: ST3 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] public static unsafe void StoreVectorAndZip(byte* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] - /// + /// A64: ST3 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] public static unsafe void StoreVectorAndZip(sbyte* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] - /// + /// A64: ST3 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] public static unsafe void StoreVectorAndZip(short* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] - /// + /// A64: ST3 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] public static unsafe void StoreVectorAndZip(ushort* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: ST3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe void StoreVectorAndZip(int* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: ST3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe void StoreVectorAndZip(uint* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: ST3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe void StoreVectorAndZip(float* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] - /// + /// A64: ST4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] public static unsafe void StoreVectorAndZip(byte* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] - /// + /// A64: ST4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] public static unsafe void StoreVectorAndZip(sbyte* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] - /// + /// A64: ST4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] public static unsafe void StoreVectorAndZip(short* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] - /// + /// A64: ST4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] public static unsafe void StoreVectorAndZip(ushort* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: ST4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe void StoreVectorAndZip(int* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: ST4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe void StoreVectorAndZip(uint* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: ST4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe void StoreVectorAndZip(float* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.8B, Vn+1.8B }, [Xn] - /// + /// A64: ST1 { Vn.8B, Vn+1.8B }, [Xn] public static unsafe void Store(byte* address, (Vector64 Value1, Vector64 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.8B, Vn+1.8B }, [Xn] - /// + /// A64: ST1 { Vn.8B, Vn+1.8B }, [Xn] public static unsafe void Store(sbyte* address, (Vector64 Value1, Vector64 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.4H, Vn+1.4H }, [Xn] - /// + /// A64: ST1 { Vn.4H, Vn+1.4H }, [Xn] public static unsafe void Store(short* address, (Vector64 Value1, Vector64 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.4H, Vn+1.4H }, [Xn] - /// + /// A64: ST1 { Vn.4H, Vn+1.4H }, [Xn] public static unsafe void Store(ushort* address, (Vector64 Value1, Vector64 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: ST1 { Vn.2S, Vn+1.2S }, [Xn] public static unsafe void Store(int* address, (Vector64 Value1, Vector64 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: ST1 { Vn.2S, Vn+1.2S }, [Xn] public static unsafe void Store(uint* address, (Vector64 Value1, Vector64 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: ST1 { Vn.2S, Vn+1.2S }, [Xn] public static unsafe void Store(float* address, (Vector64 Value1, Vector64 Value2) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] - /// + /// A64: ST1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] public static unsafe void Store(byte* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] - /// + /// A64: ST1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] public static unsafe void Store(sbyte* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] - /// + /// A64: ST1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] public static unsafe void Store(short* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] - /// + /// A64: ST1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] public static unsafe void Store(ushort* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe void Store(int* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe void Store(uint* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe void Store(float* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] - /// + /// A64: ST1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] public static unsafe void Store(byte* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] - /// + /// A64: ST1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] public static unsafe void Store(sbyte* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] - /// + /// A64: ST1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] public static unsafe void Store(short* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] - /// + /// A64: ST1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] public static unsafe void Store(ushort* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe void Store(int* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe void Store(uint* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) { throw new PlatformNotSupportedException(); } - /// - /// A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe void Store(float* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vsub_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VSUB.I8 Dd, Dn, Dm - /// A64: SUB Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vsub_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VSUB.I8 Dd, Dn, Dm + /// A64: SUB Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Subtract(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vsub_s16 (int16x4_t a, int16x4_t b) - /// A32: VSUB.I16 Dd, Dn, Dm - /// A64: SUB Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vsub_s16 (int16x4_t a, int16x4_t b) + /// A32: VSUB.I16 Dd, Dn, Dm + /// A64: SUB Vd.4H, Vn.4H, Vm.4H /// public static Vector64 Subtract(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vsub_s32 (int32x2_t a, int32x2_t b) - /// A32: VSUB.I32 Dd, Dn, Dm - /// A64: SUB Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vsub_s32 (int32x2_t a, int32x2_t b) + /// A32: VSUB.I32 Dd, Dn, Dm + /// A64: SUB Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Subtract(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vsub_s8 (int8x8_t a, int8x8_t b) - /// A32: VSUB.I8 Dd, Dn, Dm - /// A64: SUB Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vsub_s8 (int8x8_t a, int8x8_t b) + /// A32: VSUB.I8 Dd, Dn, Dm + /// A64: SUB Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Subtract(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t vsub_f32 (float32x2_t a, float32x2_t b) - /// A32: VSUB.F32 Dd, Dn, Dm - /// A64: FSUB Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vsub_f32 (float32x2_t a, float32x2_t b) + /// A32: VSUB.F32 Dd, Dn, Dm + /// A64: FSUB Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Subtract(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vsub_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VSUB.I16 Dd, Dn, Dm - /// A64: SUB Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vsub_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VSUB.I16 Dd, Dn, Dm + /// A64: SUB Vd.4H, Vn.4H, Vm.4H /// public static Vector64 Subtract(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vsub_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VSUB.I32 Dd, Dn, Dm - /// A64: SUB Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vsub_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VSUB.I32 Dd, Dn, Dm + /// A64: SUB Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Subtract(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vsubq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VSUB.I8 Qd, Qn, Qm - /// A64: SUB Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vsubq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VSUB.I8 Qd, Qn, Qm + /// A64: SUB Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vsubq_s16 (int16x8_t a, int16x8_t b) - /// A32: VSUB.I16 Qd, Qn, Qm - /// A64: SUB Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vsubq_s16 (int16x8_t a, int16x8_t b) + /// A32: VSUB.I16 Qd, Qn, Qm + /// A64: SUB Vd.8H, Vn.8H, Vm.8H /// public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vsubq_s32 (int32x4_t a, int32x4_t b) - /// A32: VSUB.I32 Qd, Qn, Qm - /// A64: SUB Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vsubq_s32 (int32x4_t a, int32x4_t b) + /// A32: VSUB.I32 Qd, Qn, Qm + /// A64: SUB Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vsubq_s64 (int64x2_t a, int64x2_t b) - /// A32: VSUB.I64 Qd, Qn, Qm - /// A64: SUB Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vsubq_s64 (int64x2_t a, int64x2_t b) + /// A32: VSUB.I64 Qd, Qn, Qm + /// A64: SUB Vd.2D, Vn.2D, Vm.2D /// public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vsubq_s8 (int8x16_t a, int8x16_t b) - /// A32: VSUB.I8 Qd, Qn, Qm - /// A64: SUB Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vsubq_s8 (int8x16_t a, int8x16_t b) + /// A32: VSUB.I8 Qd, Qn, Qm + /// A64: SUB Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t vsubq_f32 (float32x4_t a, float32x4_t b) - /// A32: VSUB.F32 Qd, Qn, Qm - /// A64: FSUB Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vsubq_f32 (float32x4_t a, float32x4_t b) + /// A32: VSUB.F32 Qd, Qn, Qm + /// A64: FSUB Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vsubq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VSUB.I16 Qd, Qn, Qm - /// A64: SUB Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vsubq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VSUB.I16 Qd, Qn, Qm + /// A64: SUB Vd.8H, Vn.8H, Vm.8H /// public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vsubq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VSUB.I32 Qd, Qn, Qm - /// A64: SUB Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vsubq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VSUB.I32 Qd, Qn, Qm + /// A64: SUB Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vsubq_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VSUB.I64 Qd, Qn, Qm - /// A64: SUB Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vsubq_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VSUB.I64 Qd, Qn, Qm + /// A64: SUB Vd.2D, Vn.2D, Vm.2D /// public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vsubhn_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VSUBHN.I16 Dd, Qn, Qm - /// A64: SUBHN Vd.8B, Vn.8H, Vm.8H + /// uint8x8_t vsubhn_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VSUBHN.I16 Dd, Qn, Qm + /// A64: SUBHN Vd.8B, Vn.8H, Vm.8H /// public static Vector64 SubtractHighNarrowingLower(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vsubhn_s32 (int32x4_t a, int32x4_t b) - /// A32: VSUBHN.I32 Dd, Qn, Qm - /// A64: SUBHN Vd.4H, Vn.4S, Vm.4S + /// int16x4_t vsubhn_s32 (int32x4_t a, int32x4_t b) + /// A32: VSUBHN.I32 Dd, Qn, Qm + /// A64: SUBHN Vd.4H, Vn.4S, Vm.4S /// public static Vector64 SubtractHighNarrowingLower(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vsubhn_s64 (int64x2_t a, int64x2_t b) - /// A32: VSUBHN.I64 Dd, Qn, Qm - /// A64: SUBHN Vd.2S, Vn.2D, Vm.2D + /// int32x2_t vsubhn_s64 (int64x2_t a, int64x2_t b) + /// A32: VSUBHN.I64 Dd, Qn, Qm + /// A64: SUBHN Vd.2S, Vn.2D, Vm.2D /// public static Vector64 SubtractHighNarrowingLower(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vsubhn_s16 (int16x8_t a, int16x8_t b) - /// A32: VSUBHN.I16 Dd, Qn, Qm - /// A64: SUBHN Vd.8B, Vn.8H, Vm.8H + /// int8x8_t vsubhn_s16 (int16x8_t a, int16x8_t b) + /// A32: VSUBHN.I16 Dd, Qn, Qm + /// A64: SUBHN Vd.8B, Vn.8H, Vm.8H /// public static Vector64 SubtractHighNarrowingLower(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vsubhn_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VSUBHN.I32 Dd, Qn, Qm - /// A64: SUBHN Vd.4H, Vn.4S, Vm.4S + /// uint16x4_t vsubhn_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VSUBHN.I32 Dd, Qn, Qm + /// A64: SUBHN Vd.4H, Vn.4S, Vm.4S /// public static Vector64 SubtractHighNarrowingLower(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vsubhn_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VSUBHN.I64 Dd, Qn, Qm - /// A64: SUBHN Vd.2S, Vn.2D, Vm.2D + /// uint32x2_t vsubhn_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VSUBHN.I64 Dd, Qn, Qm + /// A64: SUBHN Vd.2S, Vn.2D, Vm.2D /// public static Vector64 SubtractHighNarrowingLower(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vsubhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b) - /// A32: VSUBHN.I16 Dd+1, Qn, Qm - /// A64: SUBHN2 Vd.16B, Vn.8H, Vm.8H + /// uint8x16_t vsubhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b) + /// A32: VSUBHN.I16 Dd+1, Qn, Qm + /// A64: SUBHN2 Vd.16B, Vn.8H, Vm.8H /// public static Vector128 SubtractHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vsubhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b) - /// A32: VSUBHN.I32 Dd+1, Qn, Qm - /// A64: SUBHN2 Vd.8H, Vn.4S, Vm.4S + /// int16x8_t vsubhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b) + /// A32: VSUBHN.I32 Dd+1, Qn, Qm + /// A64: SUBHN2 Vd.8H, Vn.4S, Vm.4S /// public static Vector128 SubtractHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vsubhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b) - /// A32: VSUBHN.I64 Dd+1, Qn, Qm - /// A64: SUBHN2 Vd.4S, Vn.2D, Vm.2D + /// int32x4_t vsubhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b) + /// A32: VSUBHN.I64 Dd+1, Qn, Qm + /// A64: SUBHN2 Vd.4S, Vn.2D, Vm.2D /// public static Vector128 SubtractHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vsubhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b) - /// A32: VSUBHN.I16 Dd+1, Qn, Qm - /// A64: SUBHN2 Vd.16B, Vn.8H, Vm.8H + /// int8x16_t vsubhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b) + /// A32: VSUBHN.I16 Dd+1, Qn, Qm + /// A64: SUBHN2 Vd.16B, Vn.8H, Vm.8H /// public static Vector128 SubtractHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vsubhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b) - /// A32: VSUBHN.I32 Dd+1, Qn, Qm - /// A64: SUBHN2 Vd.8H, Vn.4S, Vm.4S + /// uint16x8_t vsubhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b) + /// A32: VSUBHN.I32 Dd+1, Qn, Qm + /// A64: SUBHN2 Vd.8H, Vn.4S, Vm.4S /// public static Vector128 SubtractHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vsubhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b) - /// A32: VSUBHN.I64 Dd+1, Qn, Qm - /// A64: SUBHN2 Vd.4S, Vn.2D, Vm.2D + /// uint32x4_t vsubhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b) + /// A32: VSUBHN.I64 Dd+1, Qn, Qm + /// A64: SUBHN2 Vd.4S, Vn.2D, Vm.2D /// public static Vector128 SubtractHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vrsubhn_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VRSUBHN.I16 Dd, Qn, Qm - /// A64: RSUBHN Vd.8B, Vn.8H, Vm.8H + /// uint8x8_t vrsubhn_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VRSUBHN.I16 Dd, Qn, Qm + /// A64: RSUBHN Vd.8B, Vn.8H, Vm.8H /// public static Vector64 SubtractRoundedHighNarrowingLower(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vrsubhn_s32 (int32x4_t a, int32x4_t b) - /// A32: VRSUBHN.I32 Dd, Qn, Qm - /// A64: RSUBHN Vd.4H, Vn.4S, Vm.4S + /// int16x4_t vrsubhn_s32 (int32x4_t a, int32x4_t b) + /// A32: VRSUBHN.I32 Dd, Qn, Qm + /// A64: RSUBHN Vd.4H, Vn.4S, Vm.4S /// public static Vector64 SubtractRoundedHighNarrowingLower(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vrsubhn_s64 (int64x2_t a, int64x2_t b) - /// A32: VRSUBHN.I64 Dd, Qn, Qm - /// A64: RSUBHN Vd.2S, Vn.2D, Vm.2D + /// int32x2_t vrsubhn_s64 (int64x2_t a, int64x2_t b) + /// A32: VRSUBHN.I64 Dd, Qn, Qm + /// A64: RSUBHN Vd.2S, Vn.2D, Vm.2D /// public static Vector64 SubtractRoundedHighNarrowingLower(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vrsubhn_s16 (int16x8_t a, int16x8_t b) - /// A32: VRSUBHN.I16 Dd, Qn, Qm - /// A64: RSUBHN Vd.8B, Vn.8H, Vm.8H + /// int8x8_t vrsubhn_s16 (int16x8_t a, int16x8_t b) + /// A32: VRSUBHN.I16 Dd, Qn, Qm + /// A64: RSUBHN Vd.8B, Vn.8H, Vm.8H /// public static Vector64 SubtractRoundedHighNarrowingLower(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vrsubhn_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VRSUBHN.I32 Dd, Qn, Qm - /// A64: RSUBHN Vd.4H, Vn.4S, Vm.4S + /// uint16x4_t vrsubhn_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VRSUBHN.I32 Dd, Qn, Qm + /// A64: RSUBHN Vd.4H, Vn.4S, Vm.4S /// public static Vector64 SubtractRoundedHighNarrowingLower(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vrsubhn_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VRSUBHN.I64 Dd, Qn, Qm - /// A64: RSUBHN Vd.2S, Vn.2D, Vm.2D + /// uint32x2_t vrsubhn_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VRSUBHN.I64 Dd, Qn, Qm + /// A64: RSUBHN Vd.2S, Vn.2D, Vm.2D /// public static Vector64 SubtractRoundedHighNarrowingLower(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vrsubhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b) - /// A32: VRSUBHN.I16 Dd+1, Qn, Qm - /// A64: RSUBHN2 Vd.16B, Vn.8H, Vm.8H + /// uint8x16_t vrsubhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b) + /// A32: VRSUBHN.I16 Dd+1, Qn, Qm + /// A64: RSUBHN2 Vd.16B, Vn.8H, Vm.8H /// public static Vector128 SubtractRoundedHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vrsubhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b) - /// A32: VRSUBHN.I32 Dd+1, Qn, Qm - /// A64: RSUBHN2 Vd.8H, Vn.4S, Vm.4S + /// int16x8_t vrsubhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b) + /// A32: VRSUBHN.I32 Dd+1, Qn, Qm + /// A64: RSUBHN2 Vd.8H, Vn.4S, Vm.4S /// public static Vector128 SubtractRoundedHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vrsubhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b) - /// A32: VRSUBHN.I64 Dd+1, Qn, Qm - /// A64: RSUBHN2 Vd.4S, Vn.2D, Vm.2D + /// int32x4_t vrsubhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b) + /// A32: VRSUBHN.I64 Dd+1, Qn, Qm + /// A64: RSUBHN2 Vd.4S, Vn.2D, Vm.2D /// public static Vector128 SubtractRoundedHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vrsubhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b) - /// A32: VRSUBHN.I16 Dd+1, Qn, Qm - /// A64: RSUBHN2 Vd.16B, Vn.8H, Vm.8H + /// int8x16_t vrsubhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b) + /// A32: VRSUBHN.I16 Dd+1, Qn, Qm + /// A64: RSUBHN2 Vd.16B, Vn.8H, Vm.8H /// public static Vector128 SubtractRoundedHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vrsubhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b) - /// A32: VRSUBHN.I32 Dd+1, Qn, Qm - /// A64: RSUBHN2 Vd.8H, Vn.4S, Vm.4S + /// uint16x8_t vrsubhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b) + /// A32: VRSUBHN.I32 Dd+1, Qn, Qm + /// A64: RSUBHN2 Vd.8H, Vn.4S, Vm.4S /// public static Vector128 SubtractRoundedHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vrsubhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b) - /// A32: VRSUBHN.I64 Dd+1, Qn, Qm - /// A64: RSUBHN2 Vd.4S, Vn.2D, Vm.2D + /// uint32x4_t vrsubhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b) + /// A32: VRSUBHN.I64 Dd+1, Qn, Qm + /// A64: RSUBHN2 Vd.4S, Vn.2D, Vm.2D /// public static Vector128 SubtractRoundedHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vqsub_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VQSUB.U8 Dd, Dn, Dm - /// A64: UQSUB Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vqsub_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VQSUB.U8 Dd, Dn, Dm + /// A64: UQSUB Vd.8B, Vn.8B, Vm.8B /// public static Vector64 SubtractSaturate(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vqsub_s16 (int16x4_t a, int16x4_t b) - /// A32: VQSUB.S16 Dd, Dn, Dm - /// A64: SQSUB Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vqsub_s16 (int16x4_t a, int16x4_t b) + /// A32: VQSUB.S16 Dd, Dn, Dm + /// A64: SQSUB Vd.4H, Vn.4H, Vm.4H /// public static Vector64 SubtractSaturate(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vqsub_s32 (int32x2_t a, int32x2_t b) - /// A32: VQSUB.S32 Dd, Dn, Dm - /// A64: SQSUB Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vqsub_s32 (int32x2_t a, int32x2_t b) + /// A32: VQSUB.S32 Dd, Dn, Dm + /// A64: SQSUB Vd.2S, Vn.2S, Vm.2S /// public static Vector64 SubtractSaturate(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vqsub_s8 (int8x8_t a, int8x8_t b) - /// A32: VQSUB.S8 Dd, Dn, Dm - /// A64: SQSUB Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vqsub_s8 (int8x8_t a, int8x8_t b) + /// A32: VQSUB.S8 Dd, Dn, Dm + /// A64: SQSUB Vd.8B, Vn.8B, Vm.8B /// public static Vector64 SubtractSaturate(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t vqsub_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VQSUB.U16 Dd, Dn, Dm - /// A64: UQSUB Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vqsub_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VQSUB.U16 Dd, Dn, Dm + /// A64: UQSUB Vd.4H, Vn.4H, Vm.4H /// public static Vector64 SubtractSaturate(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vqsub_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VQSUB.U32 Dd, Dn, Dm - /// A64: UQSUB Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vqsub_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VQSUB.U32 Dd, Dn, Dm + /// A64: UQSUB Vd.2S, Vn.2S, Vm.2S /// public static Vector64 SubtractSaturate(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vqsubq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VQSUB.U8 Qd, Qn, Qm - /// A64: UQSUB Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vqsubq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VQSUB.U8 Qd, Qn, Qm + /// A64: UQSUB Vd.16B, Vn.16B, Vm.16B /// public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vqsubq_s16 (int16x8_t a, int16x8_t b) - /// A32: VQSUB.S16 Qd, Qn, Qm - /// A64: SQSUB Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vqsubq_s16 (int16x8_t a, int16x8_t b) + /// A32: VQSUB.S16 Qd, Qn, Qm + /// A64: SQSUB Vd.8H, Vn.8H, Vm.8H /// public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqsubq_s32 (int32x4_t a, int32x4_t b) - /// A32: VQSUB.S32 Qd, Qn, Qm - /// A64: SQSUB Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vqsubq_s32 (int32x4_t a, int32x4_t b) + /// A32: VQSUB.S32 Qd, Qn, Qm + /// A64: SQSUB Vd.4S, Vn.4S, Vm.4S /// public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vqsubq_s64 (int64x2_t a, int64x2_t b) - /// A32: VQSUB.S64 Qd, Qn, Qm - /// A64: SQSUB Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vqsubq_s64 (int64x2_t a, int64x2_t b) + /// A32: VQSUB.S64 Qd, Qn, Qm + /// A64: SQSUB Vd.2D, Vn.2D, Vm.2D /// public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t vqsubq_s8 (int8x16_t a, int8x16_t b) - /// A32: VQSUB.S8 Qd, Qn, Qm - /// A64: SQSUB Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vqsubq_s8 (int8x16_t a, int8x16_t b) + /// A32: VQSUB.S8 Qd, Qn, Qm + /// A64: SQSUB Vd.16B, Vn.16B, Vm.16B /// public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vqsubq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VQSUB.U16 Qd, Qn, Qm - /// A64: UQSUB Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vqsubq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VQSUB.U16 Qd, Qn, Qm + /// A64: UQSUB Vd.8H, Vn.8H, Vm.8H /// public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vqsubq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VQSUB.U32 Qd, Qn, Qm - /// A64: UQSUB Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vqsubq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VQSUB.U32 Qd, Qn, Qm + /// A64: UQSUB Vd.4S, Vn.4S, Vm.4S /// public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vqsubq_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VQSUB.U64 Qd, Qn, Qm - /// A64: UQSUB Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vqsubq_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VQSUB.U64 Qd, Qn, Qm + /// A64: UQSUB Vd.2D, Vn.2D, Vm.2D /// public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vqsub_s64 (int64x1_t a, int64x1_t b) - /// A32: VQSUB.S64 Dd, Dn, Dm - /// A64: SQSUB Dd, Dn, Dm + /// int64x1_t vqsub_s64 (int64x1_t a, int64x1_t b) + /// A32: VQSUB.S64 Dd, Dn, Dm + /// A64: SQSUB Dd, Dn, Dm /// public static Vector64 SubtractSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vqsub_u64 (uint64x1_t a, uint64x1_t b) - /// A32: VQSUB.U64 Dd, Dn, Dm - /// A64: UQSUB Dd, Dn, Dm + /// uint64x1_t vqsub_u64 (uint64x1_t a, uint64x1_t b) + /// A32: VQSUB.U64 Dd, Dn, Dm + /// A64: UQSUB Dd, Dn, Dm /// public static Vector64 SubtractSaturateScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t vsub_f64 (float64x1_t a, float64x1_t b) - /// A32: VSUB.F64 Dd, Dn, Dm - /// A64: FSUB Dd, Dn, Dm + /// float64x1_t vsub_f64 (float64x1_t a, float64x1_t b) + /// A32: VSUB.F64 Dd, Dn, Dm + /// A64: FSUB Dd, Dn, Dm /// public static Vector64 SubtractScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t vsub_s64 (int64x1_t a, int64x1_t b) - /// A32: VSUB.I64 Dd, Dn, Dm - /// A64: SUB Dd, Dn, Dm + /// int64x1_t vsub_s64 (int64x1_t a, int64x1_t b) + /// A32: VSUB.I64 Dd, Dn, Dm + /// A64: SUB Dd, Dn, Dm /// public static Vector64 SubtractScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32_t vsubs_f32 (float32_t a, float32_t b) - /// A32: VSUB.F32 Sd, Sn, Sm - /// A64: FSUB Sd, Sn, Sm - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vsubs_f32 (float32_t a, float32_t b) + /// A32: VSUB.F32 Sd, Sn, Sm + /// A64: FSUB Sd, Sn, Sm + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 SubtractScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t vsub_u64 (uint64x1_t a, uint64x1_t b) - /// A32: VSUB.I64 Dd, Dn, Dm - /// A64: SUB Dd, Dn, Dm + /// uint64x1_t vsub_u64 (uint64x1_t a, uint64x1_t b) + /// A32: VSUB.I64 Dd, Dn, Dm + /// A64: SUB Dd, Dn, Dm /// public static Vector64 SubtractScalar(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vsubl_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VSUBL.U8 Qd, Dn, Dm - /// A64: USUBL Vd.8H, Vn.8B, Vm.8B + /// uint16x8_t vsubl_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VSUBL.U8 Qd, Dn, Dm + /// A64: USUBL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 SubtractWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vsubl_s16 (int16x4_t a, int16x4_t b) - /// A32: VSUBL.S16 Qd, Dn, Dm - /// A64: SSUBL Vd.4S, Vn.4H, Vm.4H + /// int32x4_t vsubl_s16 (int16x4_t a, int16x4_t b) + /// A32: VSUBL.S16 Qd, Dn, Dm + /// A64: SSUBL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 SubtractWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vsubl_s32 (int32x2_t a, int32x2_t b) - /// A32: VSUBL.S32 Qd, Dn, Dm - /// A64: SSUBL Vd.2D, Vn.2S, Vm.2S + /// int64x2_t vsubl_s32 (int32x2_t a, int32x2_t b) + /// A32: VSUBL.S32 Qd, Dn, Dm + /// A64: SSUBL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 SubtractWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vsubl_s8 (int8x8_t a, int8x8_t b) - /// A32: VSUBL.S8 Qd, Dn, Dm - /// A64: SSUBL Vd.8H, Vn.8B, Vm.8B + /// int16x8_t vsubl_s8 (int8x8_t a, int8x8_t b) + /// A32: VSUBL.S8 Qd, Dn, Dm + /// A64: SSUBL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 SubtractWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vsubl_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VSUBL.U16 Qd, Dn, Dm - /// A64: USUBL Vd.4S, Vn.4H, Vm.4H + /// uint32x4_t vsubl_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VSUBL.U16 Qd, Dn, Dm + /// A64: USUBL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 SubtractWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vsubl_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VSUBL.U32 Qd, Dn, Dm - /// A64: USUBL Vd.2D, Vn.2S, Vm.2S + /// uint64x2_t vsubl_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VSUBL.U32 Qd, Dn, Dm + /// A64: USUBL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 SubtractWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vsubw_s8 (int16x8_t a, int8x8_t b) - /// A32: VSUBW.S8 Qd, Qn, Dm - /// A64: SSUBW Vd.8H, Vn.8H, Vm.8B + /// int16x8_t vsubw_s8 (int16x8_t a, int8x8_t b) + /// A32: VSUBW.S8 Qd, Qn, Dm + /// A64: SSUBW Vd.8H, Vn.8H, Vm.8B /// public static Vector128 SubtractWideningLower(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vsubw_s16 (int32x4_t a, int16x4_t b) - /// A32: VSUBW.S16 Qd, Qn, Dm - /// A64: SSUBW Vd.4S, Vn.4S, Vm.4H + /// int32x4_t vsubw_s16 (int32x4_t a, int16x4_t b) + /// A32: VSUBW.S16 Qd, Qn, Dm + /// A64: SSUBW Vd.4S, Vn.4S, Vm.4H /// public static Vector128 SubtractWideningLower(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vsubw_s32 (int64x2_t a, int32x2_t b) - /// A32: VSUBW.S32 Qd, Qn, Dm - /// A64: SSUBW Vd.2D, Vn.2D, Vm.2S + /// int64x2_t vsubw_s32 (int64x2_t a, int32x2_t b) + /// A32: VSUBW.S32 Qd, Qn, Dm + /// A64: SSUBW Vd.2D, Vn.2D, Vm.2S /// public static Vector128 SubtractWideningLower(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vsubw_u8 (uint16x8_t a, uint8x8_t b) - /// A32: VSUBW.U8 Qd, Qn, Dm - /// A64: USUBW Vd.8H, Vn.8H, Vm.8B + /// uint16x8_t vsubw_u8 (uint16x8_t a, uint8x8_t b) + /// A32: VSUBW.U8 Qd, Qn, Dm + /// A64: USUBW Vd.8H, Vn.8H, Vm.8B /// public static Vector128 SubtractWideningLower(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vsubw_u16 (uint32x4_t a, uint16x4_t b) - /// A32: VSUBW.U16 Qd, Qn, Dm - /// A64: USUBW Vd.4S, Vn.4S, Vm.4H + /// uint32x4_t vsubw_u16 (uint32x4_t a, uint16x4_t b) + /// A32: VSUBW.U16 Qd, Qn, Dm + /// A64: USUBW Vd.4S, Vn.4S, Vm.4H /// public static Vector128 SubtractWideningLower(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vsubw_u32 (uint64x2_t a, uint32x2_t b) - /// A32: VSUBW.U32 Qd, Qn, Dm - /// A64: USUBW Vd.2D, Vn.2D, Vm.2S + /// uint64x2_t vsubw_u32 (uint64x2_t a, uint32x2_t b) + /// A32: VSUBW.U32 Qd, Qn, Dm + /// A64: USUBW Vd.2D, Vn.2D, Vm.2S /// public static Vector128 SubtractWideningLower(Vector128 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vsubl_high_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VSUBL.U8 Qd, Dn+1, Dm+1 - /// A64: USUBL2 Vd.8H, Vn.16B, Vm.16B + /// uint16x8_t vsubl_high_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VSUBL.U8 Qd, Dn+1, Dm+1 + /// A64: USUBL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 SubtractWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vsubl_high_s16 (int16x8_t a, int16x8_t b) - /// A32: VSUBL.S16 Qd, Dn+1, Dm+1 - /// A64: SSUBL2 Vd.4S, Vn.8H, Vm.8H + /// int32x4_t vsubl_high_s16 (int16x8_t a, int16x8_t b) + /// A32: VSUBL.S16 Qd, Dn+1, Dm+1 + /// A64: SSUBL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 SubtractWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vsubw_high_s8 (int16x8_t a, int8x16_t b) - /// A32: VSUBW.S8 Qd, Qn, Dm+1 - /// A64: SSUBW2 Vd.8H, Vn.8H, Vm.16B + /// int16x8_t vsubw_high_s8 (int16x8_t a, int8x16_t b) + /// A32: VSUBW.S8 Qd, Qn, Dm+1 + /// A64: SSUBW2 Vd.8H, Vn.8H, Vm.16B /// public static Vector128 SubtractWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vsubw_high_s16 (int32x4_t a, int16x8_t b) - /// A32: VSUBW.S16 Qd, Qn, Dm+1 - /// A64: SSUBW2 Vd.4S, Vn.4S, Vm.8H + /// int32x4_t vsubw_high_s16 (int32x4_t a, int16x8_t b) + /// A32: VSUBW.S16 Qd, Qn, Dm+1 + /// A64: SSUBW2 Vd.4S, Vn.4S, Vm.8H /// public static Vector128 SubtractWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vsubl_high_s32 (int32x4_t a, int32x4_t b) - /// A32: VSUBL.S32 Qd, Dn+1, Dm+1 - /// A64: SSUBL2 Vd.2D, Vn.4S, Vm.4S + /// int64x2_t vsubl_high_s32 (int32x4_t a, int32x4_t b) + /// A32: VSUBL.S32 Qd, Dn+1, Dm+1 + /// A64: SSUBL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 SubtractWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t vsubw_high_s32 (int64x2_t a, int32x4_t b) - /// A32: VSUBW.S32 Qd, Qn, Dm+1 - /// A64: SSUBW2 Vd.2D, Vn.2D, Vm.4S + /// int64x2_t vsubw_high_s32 (int64x2_t a, int32x4_t b) + /// A32: VSUBW.S32 Qd, Qn, Dm+1 + /// A64: SSUBW2 Vd.2D, Vn.2D, Vm.4S /// public static Vector128 SubtractWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vsubl_high_s8 (int8x16_t a, int8x16_t b) - /// A32: VSUBL.S8 Qd, Dn+1, Dm+1 - /// A64: SSUBL2 Vd.8H, Vn.16B, Vm.16B + /// int16x8_t vsubl_high_s8 (int8x16_t a, int8x16_t b) + /// A32: VSUBL.S8 Qd, Dn+1, Dm+1 + /// A64: SSUBL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 SubtractWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vsubw_high_u8 (uint16x8_t a, uint8x16_t b) - /// A32: VSUBW.U8 Qd, Qn, Dm+1 - /// A64: USUBW2 Vd.8H, Vn.8H, Vm.16B + /// uint16x8_t vsubw_high_u8 (uint16x8_t a, uint8x16_t b) + /// A32: VSUBW.U8 Qd, Qn, Dm+1 + /// A64: USUBW2 Vd.8H, Vn.8H, Vm.16B /// public static Vector128 SubtractWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vsubl_high_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VSUBL.U16 Qd, Dn+1, Dm+1 - /// A64: USUBL2 Vd.4S, Vn.8H, Vm.8H + /// uint32x4_t vsubl_high_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VSUBL.U16 Qd, Dn+1, Dm+1 + /// A64: USUBL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 SubtractWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vsubw_high_u16 (uint32x4_t a, uint16x8_t b) - /// A32: VSUBW.U16 Qd, Qn, Dm+1 - /// A64: USUBW2 Vd.4S, Vn.4S, Vm.8H + /// uint32x4_t vsubw_high_u16 (uint32x4_t a, uint16x8_t b) + /// A32: VSUBW.U16 Qd, Qn, Dm+1 + /// A64: USUBW2 Vd.4S, Vn.4S, Vm.8H /// public static Vector128 SubtractWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vsubl_high_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VSUBL.U32 Qd, Dn+1, Dm+1 - /// A64: USUBL2 Vd.2D, Vn.4S, Vm.4S + /// uint64x2_t vsubl_high_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VSUBL.U32 Qd, Dn+1, Dm+1 + /// A64: USUBL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 SubtractWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vsubw_high_u32 (uint64x2_t a, uint32x4_t b) - /// A32: VSUBW.U32 Qd, Qn, Dm+1 - /// A64: USUBW2 Vd.2D, Vn.2D, Vm.4S + /// uint64x2_t vsubw_high_u32 (uint64x2_t a, uint32x4_t b) + /// A32: VSUBW.U32 Qd, Qn, Dm+1 + /// A64: USUBW2 Vd.2D, Vn.2D, Vm.4S /// public static Vector128 SubtractWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vqvtbl1_u8(uint8x16_t t, uint8x8_t idx) - /// A32: VTBL Dd, {Dn, Dn+1}, Dm - /// A64: TBL Vd.8B, {Vn.16B}, Vm.8B + /// uint8x8_t vqvtbl1_u8(uint8x16_t t, uint8x8_t idx) + /// A32: VTBL Dd, {Dn, Dn+1}, Dm + /// A64: TBL Vd.8B, {Vn.16B}, Vm.8B /// public static Vector64 VectorTableLookup(Vector128 table, Vector64 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vqvtbl1_s8(int8x16_t t, uint8x8_t idx) - /// A32: VTBL Dd, {Dn, Dn+1}, Dm - /// A64: TBL Vd.8B, {Vn.16B}, Vm.8B + /// int8x8_t vqvtbl1_s8(int8x16_t t, uint8x8_t idx) + /// A32: VTBL Dd, {Dn, Dn+1}, Dm + /// A64: TBL Vd.8B, {Vn.16B}, Vm.8B /// public static Vector64 VectorTableLookup(Vector128 table, Vector64 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vqtbl2q_u8(uint8x16x2_t t, uint8x8_t idx) - /// A64: TBL Vd.8B, {Vn.16B, Vn+1.16B}, Vm.8B + /// uint8x8_t vqtbl2q_u8(uint8x16x2_t t, uint8x8_t idx) + /// A64: TBL Vd.8B, {Vn.16B, Vn+1.16B}, Vm.8B /// public static Vector64 VectorTableLookup((Vector128, Vector128) table, Vector64 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vqtbl2q_u8(int8x16x2_t t, uint8x8_t idx) - /// A64: TBL Vd.8B, {Vn.16B, Vn+1.16B}, Vm.8B + /// int8x8_t vqtbl2q_u8(int8x16x2_t t, uint8x8_t idx) + /// A64: TBL Vd.8B, {Vn.16B, Vn+1.16B}, Vm.8B /// public static Vector64 VectorTableLookup((Vector128, Vector128) table, Vector64 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vqtbl3q_u8(uint8x16x3_t t, uint8x8_t idx) - /// A64: TBL Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.8B + /// uint8x8_t vqtbl3q_u8(uint8x16x3_t t, uint8x8_t idx) + /// A64: TBL Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.8B /// public static Vector64 VectorTableLookup((Vector128, Vector128, Vector128) table, Vector64 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vqtbl3q_u8(int8x16x3_t t, uint8x8_t idx) - /// A64: TBL Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.8B + /// int8x8_t vqtbl3q_u8(int8x16x3_t t, uint8x8_t idx) + /// A64: TBL Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.8B /// public static Vector64 VectorTableLookup((Vector128, Vector128, Vector128) table, Vector64 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vqtbl4q_u8(uint8x16x4_t t, uint8x8_t idx) - /// A64: TBL Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.8B + /// uint8x8_t vqtbl4q_u8(uint8x16x4_t t, uint8x8_t idx) + /// A64: TBL Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.8B /// public static Vector64 VectorTableLookup((Vector128, Vector128, Vector128, Vector128) table, Vector64 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vqtbl4q_u8(int8x16x4_t t, uint8x8_t idx) - /// A64: TBL Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.8B + /// int8x8_t vqtbl4q_u8(int8x16x4_t t, uint8x8_t idx) + /// A64: TBL Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.8B /// public static Vector64 VectorTableLookup((Vector128, Vector128, Vector128, Vector128) table, Vector64 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vqvtbx1_u8(uint8x8_t r, uint8x16_t t, uint8x8_t idx) - /// A32: VTBX Dd, {Dn, Dn+1}, Dm - /// A64: TBX Vd.8B, {Vn.16B}, Vm.8B + /// uint8x8_t vqvtbx1_u8(uint8x8_t r, uint8x16_t t, uint8x8_t idx) + /// A32: VTBX Dd, {Dn, Dn+1}, Dm + /// A64: TBX Vd.8B, {Vn.16B}, Vm.8B /// public static Vector64 VectorTableLookupExtension(Vector64 defaultValues, Vector128 table, Vector64 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vqvtbx1_s8(int8x8_t r, int8x16_t t, uint8x8_t idx) - /// A32: VTBX Dd, {Dn, Dn+1}, Dm - /// A64: TBX Vd.8B, {Vn.16B}, Vm.8B + /// int8x8_t vqvtbx1_s8(int8x8_t r, int8x16_t t, uint8x8_t idx) + /// A32: VTBX Dd, {Dn, Dn+1}, Dm + /// A64: TBX Vd.8B, {Vn.16B}, Vm.8B /// public static Vector64 VectorTableLookupExtension(Vector64 defaultValues, Vector128 table, Vector64 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vqtbx2q_u8(uint8x16x2_t t, uint8x8_t idx) - /// A64: TBX Vd.8B, {Vn.16B, Vn+1.16B}, Vm.8B + /// uint8x8_t vqtbx2q_u8(uint8x16x2_t t, uint8x8_t idx) + /// A64: TBX Vd.8B, {Vn.16B, Vn+1.16B}, Vm.8B /// public static Vector64 VectorTableLookupExtension(Vector64 defaultValues, (Vector128, Vector128) table, Vector64 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vqtbx2q_u8(int8x16x2_t t, uint8x8_t idx) - /// A64: TBX Vd.8B, {Vn.16B, Vn+1.16B}, Vm.8B + /// int8x8_t vqtbx2q_u8(int8x16x2_t t, uint8x8_t idx) + /// A64: TBX Vd.8B, {Vn.16B, Vn+1.16B}, Vm.8B /// public static Vector64 VectorTableLookupExtension(Vector64 defaultValues, (Vector128, Vector128) table, Vector64 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vqtbx3q_u8(uint8x16x3_t t, uint8x8_t idx) - /// A64: TBX Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.8B + /// uint8x8_t vqtbx3q_u8(uint8x16x3_t t, uint8x8_t idx) + /// A64: TBX Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.8B /// public static Vector64 VectorTableLookupExtension(Vector64 defaultValues, (Vector128, Vector128, Vector128) table, Vector64 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vqtbx3q_u8(int8x16x3_t t, uint8x8_t idx) - /// A64: TBX Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.8B + /// int8x8_t vqtbx3q_u8(int8x16x3_t t, uint8x8_t idx) + /// A64: TBX Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.8B /// public static Vector64 VectorTableLookupExtension(Vector64 defaultValues, (Vector128, Vector128, Vector128) table, Vector64 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t vqtbx4q_u8(uint8x16x4_t t, uint8x8_t idx) - /// A64: TBX Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.8B + /// uint8x8_t vqtbx4q_u8(uint8x16x4_t t, uint8x8_t idx) + /// A64: TBX Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.8B /// public static Vector64 VectorTableLookupExtension(Vector64 defaultValues, (Vector128, Vector128, Vector128, Vector128) table, Vector64 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t vqtbx4q_u8(int8x16x4_t t, uint8x8_t idx) - /// A64: TBX Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.8B + /// int8x8_t vqtbx4q_u8(int8x16x4_t t, uint8x8_t idx) + /// A64: TBX Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.8B /// public static Vector64 VectorTableLookupExtension(Vector64 defaultValues, (Vector128, Vector128, Vector128, Vector128) table, Vector64 byteIndexes) { throw new PlatformNotSupportedException(); } /// - /// uint8x8_t veor_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VEOR Dd, Dn, Dm - /// A64: EOR Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t veor_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VEOR Dd, Dn, Dm + /// A64: EOR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Xor(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float64x1_t veor_f64 (float64x1_t a, float64x1_t b) - /// A32: VEOR Dd, Dn, Dm - /// A64: EOR Vd.8B, Vn.8B, Vm.8B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x1_t veor_f64 (float64x1_t a, float64x1_t b) + /// A32: VEOR Dd, Dn, Dm + /// A64: EOR Vd.8B, Vn.8B, Vm.8B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 Xor(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t veor_s16 (int16x4_t a, int16x4_t b) - /// A32: VEOR Dd, Dn, Dm - /// A64: EOR Vd.8B, Vn.8B, Vm.8B + /// int16x4_t veor_s16 (int16x4_t a, int16x4_t b) + /// A32: VEOR Dd, Dn, Dm + /// A64: EOR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Xor(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t veor_s32 (int32x2_t a, int32x2_t b) - /// A32: VEOR Dd, Dn, Dm - /// A64: EOR Vd.8B, Vn.8B, Vm.8B + /// int32x2_t veor_s32 (int32x2_t a, int32x2_t b) + /// A32: VEOR Dd, Dn, Dm + /// A64: EOR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Xor(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int64x1_t veor_s64 (int64x1_t a, int64x1_t b) - /// A32: VEOR Dd, Dn, Dm - /// A64: EOR Vd.8B, Vn.8B, Vm.8B + /// int64x1_t veor_s64 (int64x1_t a, int64x1_t b) + /// A32: VEOR Dd, Dn, Dm + /// A64: EOR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Xor(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int8x8_t veor_s8 (int8x8_t a, int8x8_t b) - /// A32: VEOR Dd, Dn, Dm - /// A64: EOR Vd.8B, Vn.8B, Vm.8B + /// int8x8_t veor_s8 (int8x8_t a, int8x8_t b) + /// A32: VEOR Dd, Dn, Dm + /// A64: EOR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Xor(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// float32x2_t veor_f32 (float32x2_t a, float32x2_t b) - /// A32: VEOR Dd, Dn, Dm - /// A64: EOR Vd.8B, Vn.8B, Vm.8B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32x2_t veor_f32 (float32x2_t a, float32x2_t b) + /// A32: VEOR Dd, Dn, Dm + /// A64: EOR Vd.8B, Vn.8B, Vm.8B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 Xor(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x4_t veor_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VEOR Dd, Dn, Dm - /// A64: EOR Vd.8B, Vn.8B, Vm.8B + /// uint16x4_t veor_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VEOR Dd, Dn, Dm + /// A64: EOR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Xor(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t veor_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VEOR Dd, Dn, Dm - /// A64: EOR Vd.8B, Vn.8B, Vm.8B + /// uint32x2_t veor_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VEOR Dd, Dn, Dm + /// A64: EOR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Xor(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x1_t veor_u64 (uint64x1_t a, uint64x1_t b) - /// A32: VEOR Dd, Dn, Dm - /// A64: EOR Vd.8B, Vn.8B, Vm.8B + /// uint64x1_t veor_u64 (uint64x1_t a, uint64x1_t b) + /// A32: VEOR Dd, Dn, Dm + /// A64: EOR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Xor(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t veorq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VEOR Qd, Qn, Qm - /// A64: EOR Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t veorq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VEOR Qd, Qn, Qm + /// A64: EOR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float64x2_t veorq_f64 (float64x2_t a, float64x2_t b) - /// A32: VEOR Qd, Qn, Qm - /// A64: EOR Vd.16B, Vn.16B, Vm.16B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x2_t veorq_f64 (float64x2_t a, float64x2_t b) + /// A32: VEOR Qd, Qn, Qm + /// A64: EOR Vd.16B, Vn.16B, Vm.16B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t veorq_s16 (int16x8_t a, int16x8_t b) - /// A32: VEOR Qd, Qn, Qm - /// A64: EOR Vd.16B, Vn.16B, Vm.16B + /// int16x8_t veorq_s16 (int16x8_t a, int16x8_t b) + /// A32: VEOR Qd, Qn, Qm + /// A64: EOR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t veorq_s32 (int32x4_t a, int32x4_t b) - /// A32: VEOR Qd, Qn, Qm - /// A64: EOR Vd.16B, Vn.16B, Vm.16B + /// int32x4_t veorq_s32 (int32x4_t a, int32x4_t b) + /// A32: VEOR Qd, Qn, Qm + /// A64: EOR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int64x2_t veorq_s64 (int64x2_t a, int64x2_t b) - /// A32: VEOR Qd, Qn, Qm - /// A64: EOR Vd.16B, Vn.16B, Vm.16B + /// int64x2_t veorq_s64 (int64x2_t a, int64x2_t b) + /// A32: VEOR Qd, Qn, Qm + /// A64: EOR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int8x16_t veorq_s8 (int8x16_t a, int8x16_t b) - /// A32: VEOR Qd, Qn, Qm - /// A64: EOR Vd.16B, Vn.16B, Vm.16B + /// int8x16_t veorq_s8 (int8x16_t a, int8x16_t b) + /// A32: VEOR Qd, Qn, Qm + /// A64: EOR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// float32x4_t veorq_f32 (float32x4_t a, float32x4_t b) - /// A32: VEOR Qd, Qn, Qm - /// A64: EOR Vd.16B, Vn.16B, Vm.16B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32x4_t veorq_f32 (float32x4_t a, float32x4_t b) + /// A32: VEOR Qd, Qn, Qm + /// A64: EOR Vd.16B, Vn.16B, Vm.16B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t veorq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VEOR Qd, Qn, Qm - /// A64: EOR Vd.16B, Vn.16B, Vm.16B + /// uint16x8_t veorq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VEOR Qd, Qn, Qm + /// A64: EOR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t veorq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VEOR Qd, Qn, Qm - /// A64: EOR Vd.16B, Vn.16B, Vm.16B + /// uint32x4_t veorq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VEOR Qd, Qn, Qm + /// A64: EOR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t veorq_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VEOR Qd, Qn, Qm - /// A64: EOR Vd.16B, Vn.16B, Vm.16B + /// uint64x2_t veorq_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VEOR Qd, Qn, Qm + /// A64: EOR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmovl_u8 (uint8x8_t a) - /// A32: VMOVL.U8 Qd, Dm - /// A64: UXTL Vd.8H, Vn.8B + /// uint16x8_t vmovl_u8 (uint8x8_t a) + /// A32: VMOVL.U8 Qd, Dm + /// A64: UXTL Vd.8H, Vn.8B /// public static Vector128 ZeroExtendWideningLower(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmovl_u16 (uint16x4_t a) - /// A32: VMOVL.U16 Qd, Dm - /// A64: UXTL Vd.4S, Vn.4H + /// uint32x4_t vmovl_u16 (uint16x4_t a) + /// A32: VMOVL.U16 Qd, Dm + /// A64: UXTL Vd.4S, Vn.4H /// public static Vector128 ZeroExtendWideningLower(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vmovl_u32 (uint32x2_t a) - /// A32: VMOVL.U32 Qd, Dm - /// A64: UXTL Vd.2D, Vn.2S + /// uint64x2_t vmovl_u32 (uint32x2_t a) + /// A32: VMOVL.U32 Qd, Dm + /// A64: UXTL Vd.2D, Vn.2S /// public static Vector128 ZeroExtendWideningLower(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmovl_u8 (uint8x8_t a) - /// A32: VMOVL.U8 Qd, Dm - /// A64: UXTL Vd.8H, Vn.8B + /// uint16x8_t vmovl_u8 (uint8x8_t a) + /// A32: VMOVL.U8 Qd, Dm + /// A64: UXTL Vd.8H, Vn.8B /// public static Vector128 ZeroExtendWideningLower(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmovl_u16 (uint16x4_t a) - /// A32: VMOVL.U16 Qd, Dm - /// A64: UXTL Vd.4S, Vn.4H + /// uint32x4_t vmovl_u16 (uint16x4_t a) + /// A32: VMOVL.U16 Qd, Dm + /// A64: UXTL Vd.4S, Vn.4H /// public static Vector128 ZeroExtendWideningLower(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vmovl_u32 (uint32x2_t a) - /// A32: VMOVL.U32 Qd, Dm - /// A64: UXTL Vd.2D, Vn.2S + /// uint64x2_t vmovl_u32 (uint32x2_t a) + /// A32: VMOVL.U32 Qd, Dm + /// A64: UXTL Vd.2D, Vn.2S /// public static Vector128 ZeroExtendWideningLower(Vector64 value) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmovl_high_u8 (uint8x16_t a) - /// A32: VMOVL.U8 Qd, Dm+1 - /// A64: UXTL2 Vd.8H, Vn.16B + /// uint16x8_t vmovl_high_u8 (uint8x16_t a) + /// A32: VMOVL.U8 Qd, Dm+1 + /// A64: UXTL2 Vd.8H, Vn.16B /// public static Vector128 ZeroExtendWideningUpper(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmovl_high_u16 (uint16x8_t a) - /// A32: VMOVL.U16 Qd, Dm+1 - /// A64: UXTL2 Vd.4S, Vn.8H + /// uint32x4_t vmovl_high_u16 (uint16x8_t a) + /// A32: VMOVL.U16 Qd, Dm+1 + /// A64: UXTL2 Vd.4S, Vn.8H /// public static Vector128 ZeroExtendWideningUpper(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vmovl_high_u32 (uint32x4_t a) - /// A32: VMOVL.U32 Qd, Dm+1 - /// A64: UXTL2 Vd.2D, Vn.4S + /// uint64x2_t vmovl_high_u32 (uint32x4_t a) + /// A32: VMOVL.U32 Qd, Dm+1 + /// A64: UXTL2 Vd.2D, Vn.4S /// public static Vector128 ZeroExtendWideningUpper(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint16x8_t vmovl_high_u8 (uint8x16_t a) - /// A32: VMOVL.U8 Qd, Dm+1 - /// A64: UXTL2 Vd.8H, Vn.16B + /// uint16x8_t vmovl_high_u8 (uint8x16_t a) + /// A32: VMOVL.U8 Qd, Dm+1 + /// A64: UXTL2 Vd.8H, Vn.16B /// public static Vector128 ZeroExtendWideningUpper(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vmovl_high_u16 (uint16x8_t a) - /// A32: VMOVL.U16 Qd, Dm+1 - /// A64: UXTL2 Vd.4S, Vn.8H + /// uint32x4_t vmovl_high_u16 (uint16x8_t a) + /// A32: VMOVL.U16 Qd, Dm+1 + /// A64: UXTL2 Vd.4S, Vn.8H /// public static Vector128 ZeroExtendWideningUpper(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint64x2_t vmovl_high_u32 (uint32x4_t a) - /// A32: VMOVL.U32 Qd, Dm+1 - /// A64: UXTL2 Vd.2D, Vn.4S + /// uint64x2_t vmovl_high_u32 (uint32x4_t a) + /// A32: VMOVL.U32 Qd, Dm+1 + /// A64: UXTL2 Vd.2D, Vn.4S /// public static Vector128 ZeroExtendWideningUpper(Vector128 value) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.cs index 12801b08902..3bb907d6dea 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.cs @@ -6,15 +6,16 @@ namespace System.Runtime.Intrinsics.Arm { - /// - /// This class provides access to the ARM AdvSIMD hardware instructions via intrinsics - /// + /// Provides access to the ARM AdvSIMD hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class AdvSimd : ArmBase { internal AdvSimd() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } // [Intrinsic] @@ -25,17144 +26,16292 @@ internal AdvSimd() { } // public static new bool IsSupported { get => IsSupported; } // // /// - // /// float32x2_t vmla_f32 (float32x2_t a, float32x2_t b, float32x2_t c) - // /// A32: VMLA.F32 Dd, Dn, Dm + // /// float32x2_t vmla_f32 (float32x2_t a, float32x2_t b, float32x2_t c) + // /// A32: VMLA.F32 Dd, Dn, Dm // /// // public static Vector64 MultiplyAdd(Vector64 addend, Vector64 left, Vector64 right) => MultiplyAdd(addend, left, right); // // /// - // /// float32x4_t vmlaq_f32 (float32x4_t a, float32x4_t b, float32x4_t c) - // /// A32: VMLA.F32 Qd, Qn, Qm + // /// float32x4_t vmlaq_f32 (float32x4_t a, float32x4_t b, float32x4_t c) + // /// A32: VMLA.F32 Qd, Qn, Qm // /// // public static Vector128 MultiplyAdd(Vector128 addend, Vector128 left, Vector128 right) => MultiplyAdd(addend, left, right); // // /// - // /// float32x2_t vmla_n_f32 (float32x2_t a, float32x2_t b, float32_t c) - // /// A32: VMLA.F32 Dd, Dn, Dm[0] + // /// float32x2_t vmla_n_f32 (float32x2_t a, float32x2_t b, float32_t c) + // /// A32: VMLA.F32 Dd, Dn, Dm[0] // /// // public static Vector64 MultiplyAddByScalar(Vector64 addend, Vector64 left, Vector64 right) => MultiplyAddByScalar(addend, left, right); // // /// - // /// float32x4_t vmlaq_n_f32 (float32x4_t a, float32x4_t b, float32_t c) - // /// A32: VMLA.F32 Qd, Qn, Dm[0] + // /// float32x4_t vmlaq_n_f32 (float32x4_t a, float32x4_t b, float32_t c) + // /// A32: VMLA.F32 Qd, Qn, Dm[0] // /// // public static Vector128 MultiplyAddByScalar(Vector128 addend, Vector128 left, Vector64 right) => MultiplyAddByScalar(addend, left, right); // // /// - // /// float32x2_t vmla_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane) - // /// A32: VMLA.F32 Dd, Dn, Dm[lane] + // /// float32x2_t vmla_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane) + // /// A32: VMLA.F32 Dd, Dn, Dm[lane] // /// // public static Vector64 MultiplyAddBySelectedScalar(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex); // // /// - // /// float32x2_t vmla_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane) - // /// A32: VMLA.F32 Dd, Dn, Dm[lane] + // /// float32x2_t vmla_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane) + // /// A32: VMLA.F32 Dd, Dn, Dm[lane] // /// // public static Vector64 MultiplyAddBySelectedScalar(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex); // // /// - // /// float32x4_t vmlaq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane) - // /// A32: VMLA.F32 Qd, Qn, Dm[lane] + // /// float32x4_t vmlaq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane) + // /// A32: VMLA.F32 Qd, Qn, Dm[lane] // /// // public static Vector128 MultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex); // // /// - // /// float32x4_t vmlaq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane) - // /// A32: VMLA.F32 Qd, Qn, Dm[lane] + // /// float32x4_t vmlaq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane) + // /// A32: VMLA.F32 Qd, Qn, Dm[lane] // /// // public static Vector128 MultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex); // // /// - // /// float64x1_t vmla_f64 (float64x1_t a, float64x1_t b, float64x1_t c) - // /// A32: VMLA.F64 Dd, Dn, Dm + // /// float64x1_t vmla_f64 (float64x1_t a, float64x1_t b, float64x1_t c) + // /// A32: VMLA.F64 Dd, Dn, Dm // /// // public static Vector64 MultiplyAddScalar(Vector64 addend, Vector64 left, Vector64 right) => MultiplyAddScalar(addend, left, right); // // /// - // /// float32_t vmlas_f32 (float32_t a, float32_t b, float32_t c) - // /// A32: VMLA.F32 Sd, Sn, Sm - // /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + // /// float32_t vmlas_f32 (float32_t a, float32_t b, float32_t c) + // /// A32: VMLA.F32 Sd, Sn, Sm + // /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. // /// // public static Vector64 MultiplyAddScalar(Vector64 addend, Vector64 left, Vector64 right) => MultiplyAddScalar(addend, left, right); // // /// - // /// float32x2_t vmls_f32 (float32x2_t a, float32x2_t b, float32x2_t c) - // /// A32: VMLS.F32 Dd, Dn, Dm + // /// float32x2_t vmls_f32 (float32x2_t a, float32x2_t b, float32x2_t c) + // /// A32: VMLS.F32 Dd, Dn, Dm // /// // public static Vector64 MultiplySubtract(Vector64 minuend, Vector64 left, Vector64 right) => MultiplySubtract(minuend, left, right); // // /// - // /// float32x4_t vmlsq_f32 (float32x4_t a, float32x4_t b, float32x4_t c) - // /// A32: VMLS.F32 Qd, Qn, Qm + // /// float32x4_t vmlsq_f32 (float32x4_t a, float32x4_t b, float32x4_t c) + // /// A32: VMLS.F32 Qd, Qn, Qm // /// // public static Vector128 MultiplySubtract(Vector128 minuend, Vector128 left, Vector128 right) => MultiplySubtract(minuend, left, right); // // /// - // /// float32x2_t vmls_n_f32 (float32x2_t a, float32x2_t b, float32_t c) - // /// A32: VMLS.F32 Dd, Dn, Dm[0] + // /// float32x2_t vmls_n_f32 (float32x2_t a, float32x2_t b, float32_t c) + // /// A32: VMLS.F32 Dd, Dn, Dm[0] // /// // public static Vector64 MultiplySubtractByScalar(Vector64 minuend, Vector64 left, Vector64 right) => MultiplySubtractByScalar(minuend, left, right); // // /// - // /// float32x4_t vmlsq_n_f32 (float32x4_t a, float32x4_t b, float32_t c) - // /// A32: VMLS.F32 Qd, Qn, Dm[0] + // /// float32x4_t vmlsq_n_f32 (float32x4_t a, float32x4_t b, float32_t c) + // /// A32: VMLS.F32 Qd, Qn, Dm[0] // /// // public static Vector128 MultiplySubtractByScalar(Vector128 minuend, Vector128 left, Vector64 right) => MultiplySubtractByScalar(minuend, left, right); // // /// - // /// float32x2_t vmls_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane) - // /// A32: VMLS.F32 Dd, Dn, Dm[lane] + // /// float32x2_t vmls_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane) + // /// A32: VMLS.F32 Dd, Dn, Dm[lane] // /// // public static Vector64 MultiplySubtractBySelectedScalar(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); // // /// - // /// float32x2_t vmls_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane) - // /// A32: VMLS.F32 Dd, Dn, Dm[lane] + // /// float32x2_t vmls_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane) + // /// A32: VMLS.F32 Dd, Dn, Dm[lane] // /// // public static Vector64 MultiplySubtractBySelectedScalar(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); // // /// - // /// float32x4_t vmlsq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane) - // /// A32: VMLS.F32 Qd, Qn, Dm[lane] + // /// float32x4_t vmlsq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane) + // /// A32: VMLS.F32 Qd, Qn, Dm[lane] // /// // public static Vector128 MultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); // // /// - // /// float32x4_t vmlsq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane) - // /// A32: VMLS.F32 Qd, Qn, Dm[lane] + // /// float32x4_t vmlsq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane) + // /// A32: VMLS.F32 Qd, Qn, Dm[lane] // /// // public static Vector128 MultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); // // /// - // /// float64x1_t vmls_f64 (float64x1_t a, float64x1_t b, float64x1_t c) - // /// A32: VMLS.F64 Dd, Dn, Dm + // /// float64x1_t vmls_f64 (float64x1_t a, float64x1_t b, float64x1_t c) + // /// A32: VMLS.F64 Dd, Dn, Dm // /// // public static Vector64 MultiplySubtractScalar(Vector64 minuend, Vector64 left, Vector64 right) => MultiplySubtractScalar(minuend, left, right); // // /// - // /// float32_t vmlss_f32 (float32_t a, float32_t b, float32_t c) - // /// A32: VMLS.F32 Sd, Sn, Sm - // /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + // /// float32_t vmlss_f32 (float32_t a, float32_t b, float32_t c) + // /// A32: VMLS.F32 Sd, Sn, Sm + // /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. // /// // public static Vector64 MultiplySubtractScalar(Vector64 minuend, Vector64 left, Vector64 right) => MultiplySubtractScalar(minuend, left, right); // } + /// Provides access to the ARM AdvSIMD hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class Arm64 : ArmBase.Arm64 { internal Arm64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } /// - /// float64x2_t vabsq_f64 (float64x2_t a) - /// A64: FABS Vd.2D, Vn.2D + /// float64x2_t vabsq_f64 (float64x2_t a) + /// A64: FABS Vd.2D, Vn.2D /// public static Vector128 Abs(Vector128 value) => Abs(value); /// - /// int64x2_t vabsq_s64 (int64x2_t a) - /// A64: ABS Vd.2D, Vn.2D + /// int64x2_t vabsq_s64 (int64x2_t a) + /// A64: ABS Vd.2D, Vn.2D /// public static Vector128 Abs(Vector128 value) => Abs(value); /// - /// int64x2_t vqabsq_s64 (int64x2_t a) - /// A64: SQABS Vd.2D, Vn.2D + /// int64x2_t vqabsq_s64 (int64x2_t a) + /// A64: SQABS Vd.2D, Vn.2D /// public static Vector128 AbsSaturate(Vector128 value) => AbsSaturate(value); /// - /// int16_t vqabsh_s16 (int16_t a) - /// A64: SQABS Hd, Hn + /// int16_t vqabsh_s16 (int16_t a) + /// A64: SQABS Hd, Hn /// public static Vector64 AbsSaturateScalar(Vector64 value) => AbsSaturateScalar(value); /// - /// int32_t vqabss_s32 (int32_t a) - /// A64: SQABS Sd, Sn + /// int32_t vqabss_s32 (int32_t a) + /// A64: SQABS Sd, Sn /// public static Vector64 AbsSaturateScalar(Vector64 value) => AbsSaturateScalar(value); /// - /// int64_t vqabsd_s64 (int64_t a) - /// A64: SQABS Dd, Dn + /// int64_t vqabsd_s64 (int64_t a) + /// A64: SQABS Dd, Dn /// public static Vector64 AbsSaturateScalar(Vector64 value) => AbsSaturateScalar(value); /// - /// int8_t vqabsb_s8 (int8_t a) - /// A64: SQABS Bd, Bn + /// int8_t vqabsb_s8 (int8_t a) + /// A64: SQABS Bd, Bn /// public static Vector64 AbsSaturateScalar(Vector64 value) => AbsSaturateScalar(value); /// - /// int64x1_t vabs_s64 (int64x1_t a) - /// A64: ABS Dd, Dn + /// int64x1_t vabs_s64 (int64x1_t a) + /// A64: ABS Dd, Dn /// public static Vector64 AbsScalar(Vector64 value) => AbsScalar(value); /// - /// uint64x2_t vcagtq_f64 (float64x2_t a, float64x2_t b) - /// A64: FACGT Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcagtq_f64 (float64x2_t a, float64x2_t b) + /// A64: FACGT Vd.2D, Vn.2D, Vm.2D /// public static Vector128 AbsoluteCompareGreaterThan(Vector128 left, Vector128 right) => AbsoluteCompareGreaterThan(left, right); /// - /// uint64x1_t vcagt_f64 (float64x1_t a, float64x1_t b) - /// A64: FACGT Dd, Dn, Dm + /// uint64x1_t vcagt_f64 (float64x1_t a, float64x1_t b) + /// A64: FACGT Dd, Dn, Dm /// public static Vector64 AbsoluteCompareGreaterThanScalar(Vector64 left, Vector64 right) => AbsoluteCompareGreaterThanScalar(left, right); /// - /// uint32_t vcagts_f32 (float32_t a, float32_t b) - /// A64: FACGT Sd, Sn, Sm + /// uint32_t vcagts_f32 (float32_t a, float32_t b) + /// A64: FACGT Sd, Sn, Sm /// public static Vector64 AbsoluteCompareGreaterThanScalar(Vector64 left, Vector64 right) => AbsoluteCompareGreaterThanScalar(left, right); /// - /// uint64x2_t vcageq_f64 (float64x2_t a, float64x2_t b) - /// A64: FACGE Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcageq_f64 (float64x2_t a, float64x2_t b) + /// A64: FACGE Vd.2D, Vn.2D, Vm.2D /// public static Vector128 AbsoluteCompareGreaterThanOrEqual(Vector128 left, Vector128 right) => AbsoluteCompareGreaterThanOrEqual(left, right); /// - /// uint64x1_t vcage_f64 (float64x1_t a, float64x1_t b) - /// A64: FACGE Dd, Dn, Dm + /// uint64x1_t vcage_f64 (float64x1_t a, float64x1_t b) + /// A64: FACGE Dd, Dn, Dm /// public static Vector64 AbsoluteCompareGreaterThanOrEqualScalar(Vector64 left, Vector64 right) => AbsoluteCompareGreaterThanOrEqualScalar(left, right); /// - /// uint32_t vcages_f32 (float32_t a, float32_t b) - /// A64: FACGE Sd, Sn, Sm + /// uint32_t vcages_f32 (float32_t a, float32_t b) + /// A64: FACGE Sd, Sn, Sm /// public static Vector64 AbsoluteCompareGreaterThanOrEqualScalar(Vector64 left, Vector64 right) => AbsoluteCompareGreaterThanOrEqualScalar(left, right); /// - /// uint64x2_t vcaltq_f64 (float64x2_t a, float64x2_t b) - /// A64: FACGT Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcaltq_f64 (float64x2_t a, float64x2_t b) + /// A64: FACGT Vd.2D, Vn.2D, Vm.2D /// public static Vector128 AbsoluteCompareLessThan(Vector128 left, Vector128 right) => AbsoluteCompareLessThan(left, right); /// - /// uint64x1_t vcalt_f64 (float64x1_t a, float64x1_t b) - /// A64: FACGT Dd, Dn, Dm + /// uint64x1_t vcalt_f64 (float64x1_t a, float64x1_t b) + /// A64: FACGT Dd, Dn, Dm /// public static Vector64 AbsoluteCompareLessThanScalar(Vector64 left, Vector64 right) => AbsoluteCompareLessThanScalar(left, right); /// - /// uint32_t vcalts_f32 (float32_t a, float32_t b) - /// A64: FACGT Sd, Sn, Sm + /// uint32_t vcalts_f32 (float32_t a, float32_t b) + /// A64: FACGT Sd, Sn, Sm /// public static Vector64 AbsoluteCompareLessThanScalar(Vector64 left, Vector64 right) => AbsoluteCompareLessThanScalar(left, right); /// - /// uint64x2_t vcaleq_f64 (float64x2_t a, float64x2_t b) - /// A64: FACGE Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcaleq_f64 (float64x2_t a, float64x2_t b) + /// A64: FACGE Vd.2D, Vn.2D, Vm.2D /// public static Vector128 AbsoluteCompareLessThanOrEqual(Vector128 left, Vector128 right) => AbsoluteCompareLessThanOrEqual(left, right); /// - /// uint64x1_t vcale_f64 (float64x1_t a, float64x1_t b) - /// A64: FACGE Dd, Dn, Dm + /// uint64x1_t vcale_f64 (float64x1_t a, float64x1_t b) + /// A64: FACGE Dd, Dn, Dm /// public static Vector64 AbsoluteCompareLessThanOrEqualScalar(Vector64 left, Vector64 right) => AbsoluteCompareLessThanOrEqualScalar(left, right); /// - /// uint32_t vcales_f32 (float32_t a, float32_t b) - /// A64: FACGE Sd, Sn, Sm + /// uint32_t vcales_f32 (float32_t a, float32_t b) + /// A64: FACGE Sd, Sn, Sm /// public static Vector64 AbsoluteCompareLessThanOrEqualScalar(Vector64 left, Vector64 right) => AbsoluteCompareLessThanOrEqualScalar(left, right); /// - /// float64x2_t vabdq_f64 (float64x2_t a, float64x2_t b) - /// A64: FABD Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vabdq_f64 (float64x2_t a, float64x2_t b) + /// A64: FABD Vd.2D, Vn.2D, Vm.2D /// public static Vector128 AbsoluteDifference(Vector128 left, Vector128 right) => AbsoluteDifference(left, right); /// - /// float64x1_t vabd_f64 (float64x1_t a, float64x1_t b) - /// A64: FABD Dd, Dn, Dm + /// float64x1_t vabd_f64 (float64x1_t a, float64x1_t b) + /// A64: FABD Dd, Dn, Dm /// public static Vector64 AbsoluteDifferenceScalar(Vector64 left, Vector64 right) => AbsoluteDifferenceScalar(left, right); /// - /// float32_t vabds_f32 (float32_t a, float32_t b) - /// A64: FABD Sd, Sn, Sm + /// float32_t vabds_f32 (float32_t a, float32_t b) + /// A64: FABD Sd, Sn, Sm /// public static Vector64 AbsoluteDifferenceScalar(Vector64 left, Vector64 right) => AbsoluteDifferenceScalar(left, right); /// - /// float64x2_t vaddq_f64 (float64x2_t a, float64x2_t b) - /// A64: FADD Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vaddq_f64 (float64x2_t a, float64x2_t b) + /// A64: FADD Vd.2D, Vn.2D, Vm.2D /// public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// - /// uint8_t vaddv_u8 (uint8x8_t a) - /// A64: ADDV Bd, Vn.8B + /// uint8_t vaddv_u8 (uint8x8_t a) + /// A64: ADDV Bd, Vn.8B /// public static Vector64 AddAcross(Vector64 value) => AddAcross(value); /// - /// int16_t vaddv_s16 (int16x4_t a) - /// A64: ADDV Hd, Vn.4H + /// int16_t vaddv_s16 (int16x4_t a) + /// A64: ADDV Hd, Vn.4H /// public static Vector64 AddAcross(Vector64 value) => AddAcross(value); /// - /// int8_t vaddv_s8 (int8x8_t a) - /// A64: ADDV Bd, Vn.8B + /// int8_t vaddv_s8 (int8x8_t a) + /// A64: ADDV Bd, Vn.8B /// public static Vector64 AddAcross(Vector64 value) => AddAcross(value); /// - /// uint16_t vaddv_u16 (uint16x4_t a) - /// A64: ADDV Hd, Vn.4H + /// uint16_t vaddv_u16 (uint16x4_t a) + /// A64: ADDV Hd, Vn.4H /// public static Vector64 AddAcross(Vector64 value) => AddAcross(value); /// - /// uint8_t vaddvq_u8 (uint8x16_t a) - /// A64: ADDV Bd, Vn.16B + /// uint8_t vaddvq_u8 (uint8x16_t a) + /// A64: ADDV Bd, Vn.16B /// public static Vector64 AddAcross(Vector128 value) => AddAcross(value); /// - /// int16_t vaddvq_s16 (int16x8_t a) - /// A64: ADDV Hd, Vn.8H + /// int16_t vaddvq_s16 (int16x8_t a) + /// A64: ADDV Hd, Vn.8H /// public static Vector64 AddAcross(Vector128 value) => AddAcross(value); /// - /// int32_t vaddvq_s32 (int32x4_t a) - /// A64: ADDV Sd, Vn.4S + /// int32_t vaddvq_s32 (int32x4_t a) + /// A64: ADDV Sd, Vn.4S /// public static Vector64 AddAcross(Vector128 value) => AddAcross(value); /// - /// int8_t vaddvq_s8 (int8x16_t a) - /// A64: ADDV Bd, Vn.16B + /// int8_t vaddvq_s8 (int8x16_t a) + /// A64: ADDV Bd, Vn.16B /// public static Vector64 AddAcross(Vector128 value) => AddAcross(value); /// - /// uint16_t vaddvq_u16 (uint16x8_t a) - /// A64: ADDV Hd, Vn.8H + /// uint16_t vaddvq_u16 (uint16x8_t a) + /// A64: ADDV Hd, Vn.8H /// public static Vector64 AddAcross(Vector128 value) => AddAcross(value); /// - /// uint32_t vaddvq_u32 (uint32x4_t a) - /// A64: ADDV Sd, Vn.4S + /// uint32_t vaddvq_u32 (uint32x4_t a) + /// A64: ADDV Sd, Vn.4S /// public static Vector64 AddAcross(Vector128 value) => AddAcross(value); /// - /// uint16_t vaddlv_u8 (uint8x8_t a) - /// A64: UADDLV Hd, Vn.8B + /// uint16_t vaddlv_u8 (uint8x8_t a) + /// A64: UADDLV Hd, Vn.8B /// public static Vector64 AddAcrossWidening(Vector64 value) => AddAcrossWidening(value); /// - /// int32_t vaddlv_s16 (int16x4_t a) - /// A64: SADDLV Sd, Vn.4H + /// int32_t vaddlv_s16 (int16x4_t a) + /// A64: SADDLV Sd, Vn.4H /// public static Vector64 AddAcrossWidening(Vector64 value) => AddAcrossWidening(value); /// - /// int16_t vaddlv_s8 (int8x8_t a) - /// A64: SADDLV Hd, Vn.8B + /// int16_t vaddlv_s8 (int8x8_t a) + /// A64: SADDLV Hd, Vn.8B /// public static Vector64 AddAcrossWidening(Vector64 value) => AddAcrossWidening(value); /// - /// uint32_t vaddlv_u16 (uint16x4_t a) - /// A64: UADDLV Sd, Vn.4H + /// uint32_t vaddlv_u16 (uint16x4_t a) + /// A64: UADDLV Sd, Vn.4H /// public static Vector64 AddAcrossWidening(Vector64 value) => AddAcrossWidening(value); /// - /// uint16_t vaddlvq_u8 (uint8x16_t a) - /// A64: UADDLV Hd, Vn.16B + /// uint16_t vaddlvq_u8 (uint8x16_t a) + /// A64: UADDLV Hd, Vn.16B /// public static Vector64 AddAcrossWidening(Vector128 value) => AddAcrossWidening(value); /// - /// int32_t vaddlvq_s16 (int16x8_t a) - /// A64: SADDLV Sd, Vn.8H + /// int32_t vaddlvq_s16 (int16x8_t a) + /// A64: SADDLV Sd, Vn.8H /// public static Vector64 AddAcrossWidening(Vector128 value) => AddAcrossWidening(value); /// - /// int64_t vaddlvq_s32 (int32x4_t a) - /// A64: SADDLV Dd, Vn.4S + /// int64_t vaddlvq_s32 (int32x4_t a) + /// A64: SADDLV Dd, Vn.4S /// public static Vector64 AddAcrossWidening(Vector128 value) => AddAcrossWidening(value); /// - /// int16_t vaddlvq_s8 (int8x16_t a) - /// A64: SADDLV Hd, Vn.16B + /// int16_t vaddlvq_s8 (int8x16_t a) + /// A64: SADDLV Hd, Vn.16B /// public static Vector64 AddAcrossWidening(Vector128 value) => AddAcrossWidening(value); /// - /// uint32_t vaddlvq_u16 (uint16x8_t a) - /// A64: UADDLV Sd, Vn.8H + /// uint32_t vaddlvq_u16 (uint16x8_t a) + /// A64: UADDLV Sd, Vn.8H /// public static Vector64 AddAcrossWidening(Vector128 value) => AddAcrossWidening(value); /// - /// uint64_t vaddlvq_u32 (uint32x4_t a) - /// A64: UADDLV Dd, Vn.4S + /// uint64_t vaddlvq_u32 (uint32x4_t a) + /// A64: UADDLV Dd, Vn.4S /// public static Vector64 AddAcrossWidening(Vector128 value) => AddAcrossWidening(value); /// - /// uint8x16_t vpaddq_u8 (uint8x16_t a, uint8x16_t b) - /// A64: ADDP Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vpaddq_u8 (uint8x16_t a, uint8x16_t b) + /// A64: ADDP Vd.16B, Vn.16B, Vm.16B /// public static Vector128 AddPairwise(Vector128 left, Vector128 right) => AddPairwise(left, right); /// - /// float64x2_t vpaddq_f64 (float64x2_t a, float64x2_t b) - /// A64: FADDP Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vpaddq_f64 (float64x2_t a, float64x2_t b) + /// A64: FADDP Vd.2D, Vn.2D, Vm.2D /// public static Vector128 AddPairwise(Vector128 left, Vector128 right) => AddPairwise(left, right); /// - /// int16x8_t vpaddq_s16 (int16x8_t a, int16x8_t b) - /// A64: ADDP Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vpaddq_s16 (int16x8_t a, int16x8_t b) + /// A64: ADDP Vd.8H, Vn.8H, Vm.8H /// public static Vector128 AddPairwise(Vector128 left, Vector128 right) => AddPairwise(left, right); /// - /// int32x4_t vpaddq_s32 (int32x4_t a, int32x4_t b) - /// A64: ADDP Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vpaddq_s32 (int32x4_t a, int32x4_t b) + /// A64: ADDP Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AddPairwise(Vector128 left, Vector128 right) => AddPairwise(left, right); /// - /// int64x2_t vpaddq_s64 (int64x2_t a, int64x2_t b) - /// A64: ADDP Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vpaddq_s64 (int64x2_t a, int64x2_t b) + /// A64: ADDP Vd.2D, Vn.2D, Vm.2D /// public static Vector128 AddPairwise(Vector128 left, Vector128 right) => AddPairwise(left, right); /// - /// int8x16_t vpaddq_s8 (int8x16_t a, int8x16_t b) - /// A64: ADDP Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vpaddq_s8 (int8x16_t a, int8x16_t b) + /// A64: ADDP Vd.16B, Vn.16B, Vm.16B /// public static Vector128 AddPairwise(Vector128 left, Vector128 right) => AddPairwise(left, right); /// - /// float32x4_t vpaddq_f32 (float32x4_t a, float32x4_t b) - /// A64: FADDP Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vpaddq_f32 (float32x4_t a, float32x4_t b) + /// A64: FADDP Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AddPairwise(Vector128 left, Vector128 right) => AddPairwise(left, right); /// - /// uint16x8_t vpaddq_u16 (uint16x8_t a, uint16x8_t b) - /// A64: ADDP Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vpaddq_u16 (uint16x8_t a, uint16x8_t b) + /// A64: ADDP Vd.8H, Vn.8H, Vm.8H /// public static Vector128 AddPairwise(Vector128 left, Vector128 right) => AddPairwise(left, right); /// - /// uint32x4_t vpaddq_u32 (uint32x4_t a, uint32x4_t b) - /// A64: ADDP Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vpaddq_u32 (uint32x4_t a, uint32x4_t b) + /// A64: ADDP Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AddPairwise(Vector128 left, Vector128 right) => AddPairwise(left, right); /// - /// uint64x2_t vpaddq_u64 (uint64x2_t a, uint64x2_t b) - /// A64: ADDP Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vpaddq_u64 (uint64x2_t a, uint64x2_t b) + /// A64: ADDP Vd.2D, Vn.2D, Vm.2D /// public static Vector128 AddPairwise(Vector128 left, Vector128 right) => AddPairwise(left, right); /// - /// float32_t vpadds_f32 (float32x2_t a) - /// A64: FADDP Sd, Vn.2S + /// float32_t vpadds_f32 (float32x2_t a) + /// A64: FADDP Sd, Vn.2S /// public static Vector64 AddPairwiseScalar(Vector64 value) => AddPairwiseScalar(value); /// - /// float64_t vpaddd_f64 (float64x2_t a) - /// A64: FADDP Dd, Vn.2D + /// float64_t vpaddd_f64 (float64x2_t a) + /// A64: FADDP Dd, Vn.2D /// public static Vector64 AddPairwiseScalar(Vector128 value) => AddPairwiseScalar(value); /// - /// int64_t vpaddd_s64 (int64x2_t a) - /// A64: ADDP Dd, Vn.2D + /// int64_t vpaddd_s64 (int64x2_t a) + /// A64: ADDP Dd, Vn.2D /// public static Vector64 AddPairwiseScalar(Vector128 value) => AddPairwiseScalar(value); /// - /// uint64_t vpaddd_u64 (uint64x2_t a) - /// A64: ADDP Dd, Vn.2D + /// uint64_t vpaddd_u64 (uint64x2_t a) + /// A64: ADDP Dd, Vn.2D /// public static Vector64 AddPairwiseScalar(Vector128 value) => AddPairwiseScalar(value); /// - /// uint8x8_t vsqadd_u8 (uint8x8_t a, int8x8_t b) - /// A64: USQADD Vd.8B, Vn.8B + /// uint8x8_t vsqadd_u8 (uint8x8_t a, int8x8_t b) + /// A64: USQADD Vd.8B, Vn.8B /// public static Vector64 AddSaturate(Vector64 left, Vector64 right) => AddSaturate(left, right); /// - /// int16x4_t vuqadd_s16 (int16x4_t a, uint16x4_t b) - /// A64: SUQADD Vd.4H, Vn.4H + /// int16x4_t vuqadd_s16 (int16x4_t a, uint16x4_t b) + /// A64: SUQADD Vd.4H, Vn.4H /// public static Vector64 AddSaturate(Vector64 left, Vector64 right) => AddSaturate(left, right); /// - /// int32x2_t vuqadd_s32 (int32x2_t a, uint32x2_t b) - /// A64: SUQADD Vd.2S, Vn.2S + /// int32x2_t vuqadd_s32 (int32x2_t a, uint32x2_t b) + /// A64: SUQADD Vd.2S, Vn.2S /// public static Vector64 AddSaturate(Vector64 left, Vector64 right) => AddSaturate(left, right); /// - /// int8x8_t vuqadd_s8 (int8x8_t a, uint8x8_t b) - /// A64: SUQADD Vd.8B, Vn.8B + /// int8x8_t vuqadd_s8 (int8x8_t a, uint8x8_t b) + /// A64: SUQADD Vd.8B, Vn.8B /// public static Vector64 AddSaturate(Vector64 left, Vector64 right) => AddSaturate(left, right); /// - /// uint16x4_t vsqadd_u16 (uint16x4_t a, int16x4_t b) - /// A64: USQADD Vd.4H, Vn.4H + /// uint16x4_t vsqadd_u16 (uint16x4_t a, int16x4_t b) + /// A64: USQADD Vd.4H, Vn.4H /// public static Vector64 AddSaturate(Vector64 left, Vector64 right) => AddSaturate(left, right); /// - /// uint32x2_t vsqadd_u32 (uint32x2_t a, int32x2_t b) - /// A64: USQADD Vd.2S, Vn.2S + /// uint32x2_t vsqadd_u32 (uint32x2_t a, int32x2_t b) + /// A64: USQADD Vd.2S, Vn.2S /// public static Vector64 AddSaturate(Vector64 left, Vector64 right) => AddSaturate(left, right); /// - /// uint8x16_t vsqaddq_u8 (uint8x16_t a, int8x16_t b) - /// A64: USQADD Vd.16B, Vn.16B + /// uint8x16_t vsqaddq_u8 (uint8x16_t a, int8x16_t b) + /// A64: USQADD Vd.16B, Vn.16B /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); /// - /// int16x8_t vuqaddq_s16 (int16x8_t a, uint16x8_t b) - /// A64: SUQADD Vd.8H, Vn.8H + /// int16x8_t vuqaddq_s16 (int16x8_t a, uint16x8_t b) + /// A64: SUQADD Vd.8H, Vn.8H /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); /// - /// int32x4_t vuqaddq_s32 (int32x4_t a, uint32x4_t b) - /// A64: SUQADD Vd.4S, Vn.4S + /// int32x4_t vuqaddq_s32 (int32x4_t a, uint32x4_t b) + /// A64: SUQADD Vd.4S, Vn.4S /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); /// - /// int64x2_t vuqaddq_s64 (int64x2_t a, uint64x2_t b) - /// A64: SUQADD Vd.2D, Vn.2D + /// int64x2_t vuqaddq_s64 (int64x2_t a, uint64x2_t b) + /// A64: SUQADD Vd.2D, Vn.2D /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); /// - /// int8x16_t vuqaddq_s8 (int8x16_t a, uint8x16_t b) - /// A64: SUQADD Vd.16B, Vn.16B + /// int8x16_t vuqaddq_s8 (int8x16_t a, uint8x16_t b) + /// A64: SUQADD Vd.16B, Vn.16B /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); /// - /// uint16x8_t vsqaddq_u16 (uint16x8_t a, int16x8_t b) - /// A64: USQADD Vd.8H, Vn.8H + /// uint16x8_t vsqaddq_u16 (uint16x8_t a, int16x8_t b) + /// A64: USQADD Vd.8H, Vn.8H /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); /// - /// uint32x4_t vsqaddq_u32 (uint32x4_t a, int32x4_t b) - /// A64: USQADD Vd.4S, Vn.4S + /// uint32x4_t vsqaddq_u32 (uint32x4_t a, int32x4_t b) + /// A64: USQADD Vd.4S, Vn.4S /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); /// - /// uint64x2_t vsqaddq_u64 (uint64x2_t a, int64x2_t b) - /// A64: USQADD Vd.2D, Vn.2D + /// uint64x2_t vsqaddq_u64 (uint64x2_t a, int64x2_t b) + /// A64: USQADD Vd.2D, Vn.2D /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); /// - /// uint8_t vqaddb_u8 (uint8_t a, uint8_t b) - /// A64: UQADD Bd, Bn, Bm + /// uint8_t vqaddb_u8 (uint8_t a, uint8_t b) + /// A64: UQADD Bd, Bn, Bm /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) => AddSaturateScalar(left, right); /// - /// uint8_t vsqaddb_u8 (uint8_t a, int8_t b) - /// A64: USQADD Bd, Bn + /// uint8_t vsqaddb_u8 (uint8_t a, int8_t b) + /// A64: USQADD Bd, Bn /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) => AddSaturateScalar(left, right); /// - /// int16_t vqaddh_s16 (int16_t a, int16_t b) - /// A64: SQADD Hd, Hn, Hm + /// int16_t vqaddh_s16 (int16_t a, int16_t b) + /// A64: SQADD Hd, Hn, Hm /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) => AddSaturateScalar(left, right); /// - /// int16_t vuqaddh_s16 (int16_t a, uint16_t b) - /// A64: SUQADD Hd, Hn + /// int16_t vuqaddh_s16 (int16_t a, uint16_t b) + /// A64: SUQADD Hd, Hn /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) => AddSaturateScalar(left, right); /// - /// int32_t vqadds_s32 (int32_t a, int32_t b) - /// A64: SQADD Sd, Sn, Sm + /// int32_t vqadds_s32 (int32_t a, int32_t b) + /// A64: SQADD Sd, Sn, Sm /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) => AddSaturateScalar(left, right); /// - /// int32_t vuqadds_s32 (int32_t a, uint32_t b) - /// A64: SUQADD Sd, Sn + /// int32_t vuqadds_s32 (int32_t a, uint32_t b) + /// A64: SUQADD Sd, Sn /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) => AddSaturateScalar(left, right); /// - /// int64x1_t vuqadd_s64 (int64x1_t a, uint64x1_t b) - /// A64: SUQADD Dd, Dn + /// int64x1_t vuqadd_s64 (int64x1_t a, uint64x1_t b) + /// A64: SUQADD Dd, Dn /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) => AddSaturateScalar(left, right); /// - /// int8_t vqaddb_s8 (int8_t a, int8_t b) - /// A64: SQADD Bd, Bn, Bm + /// int8_t vqaddb_s8 (int8_t a, int8_t b) + /// A64: SQADD Bd, Bn, Bm /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) => AddSaturateScalar(left, right); /// - /// int8_t vuqaddb_s8 (int8_t a, uint8_t b) - /// A64: SUQADD Bd, Bn + /// int8_t vuqaddb_s8 (int8_t a, uint8_t b) + /// A64: SUQADD Bd, Bn /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) => AddSaturateScalar(left, right); /// - /// uint16_t vqaddh_u16 (uint16_t a, uint16_t b) - /// A64: UQADD Hd, Hn, Hm + /// uint16_t vqaddh_u16 (uint16_t a, uint16_t b) + /// A64: UQADD Hd, Hn, Hm /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) => AddSaturateScalar(left, right); /// - /// uint16_t vsqaddh_u16 (uint16_t a, int16_t b) - /// A64: USQADD Hd, Hn + /// uint16_t vsqaddh_u16 (uint16_t a, int16_t b) + /// A64: USQADD Hd, Hn /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) => AddSaturateScalar(left, right); /// - /// uint32_t vqadds_u32 (uint32_t a, uint32_t b) - /// A64: UQADD Sd, Sn, Sm + /// uint32_t vqadds_u32 (uint32_t a, uint32_t b) + /// A64: UQADD Sd, Sn, Sm /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) => AddSaturateScalar(left, right); /// - /// uint32_t vsqadds_u32 (uint32_t a, int32_t b) - /// A64: USQADD Sd, Sn + /// uint32_t vsqadds_u32 (uint32_t a, int32_t b) + /// A64: USQADD Sd, Sn /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) => AddSaturateScalar(left, right); /// - /// uint64x1_t vsqadd_u64 (uint64x1_t a, int64x1_t b) - /// A64: USQADD Dd, Dn + /// uint64x1_t vsqadd_u64 (uint64x1_t a, int64x1_t b) + /// A64: USQADD Dd, Dn /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) => AddSaturateScalar(left, right); /// - /// float64x2_t vrndpq_f64 (float64x2_t a) - /// A64: FRINTP Vd.2D, Vn.2D + /// float64x2_t vrndpq_f64 (float64x2_t a) + /// A64: FRINTP Vd.2D, Vn.2D /// public static Vector128 Ceiling(Vector128 value) => Ceiling(value); /// - /// uint64x2_t vceqq_f64 (float64x2_t a, float64x2_t b) - /// A64: FCMEQ Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vceqq_f64 (float64x2_t a, float64x2_t b) + /// A64: FCMEQ Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// - /// uint64x2_t vceqq_s64 (int64x2_t a, int64x2_t b) - /// A64: CMEQ Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vceqq_s64 (int64x2_t a, int64x2_t b) + /// A64: CMEQ Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// - /// uint64x2_t vceqq_u64 (uint64x2_t a, uint64x2_t b) - /// A64: CMEQ Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vceqq_u64 (uint64x2_t a, uint64x2_t b) + /// A64: CMEQ Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// - /// uint64x1_t vceq_f64 (float64x1_t a, float64x1_t b) - /// A64: FCMEQ Dd, Dn, Dm + /// uint64x1_t vceq_f64 (float64x1_t a, float64x1_t b) + /// A64: FCMEQ Dd, Dn, Dm /// public static Vector64 CompareEqualScalar(Vector64 left, Vector64 right) => CompareEqualScalar(left, right); /// - /// uint64x1_t vceq_s64 (int64x1_t a, int64x1_t b) - /// A64: CMEQ Dd, Dn, Dm + /// uint64x1_t vceq_s64 (int64x1_t a, int64x1_t b) + /// A64: CMEQ Dd, Dn, Dm /// public static Vector64 CompareEqualScalar(Vector64 left, Vector64 right) => CompareEqualScalar(left, right); /// - /// uint32_t vceqs_f32 (float32_t a, float32_t b) - /// A64: FCMEQ Sd, Sn, Sm + /// uint32_t vceqs_f32 (float32_t a, float32_t b) + /// A64: FCMEQ Sd, Sn, Sm /// public static Vector64 CompareEqualScalar(Vector64 left, Vector64 right) => CompareEqualScalar(left, right); /// - /// uint64x1_t vceq_u64 (uint64x1_t a, uint64x1_t b) - /// A64: CMEQ Dd, Dn, Dm + /// uint64x1_t vceq_u64 (uint64x1_t a, uint64x1_t b) + /// A64: CMEQ Dd, Dn, Dm /// public static Vector64 CompareEqualScalar(Vector64 left, Vector64 right) => CompareEqualScalar(left, right); /// - /// uint64x2_t vcgtq_f64 (float64x2_t a, float64x2_t b) - /// A64: FCMGT Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcgtq_f64 (float64x2_t a, float64x2_t b) + /// A64: FCMGT Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// - /// uint64x2_t vcgtq_s64 (int64x2_t a, int64x2_t b) - /// A64: CMGT Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcgtq_s64 (int64x2_t a, int64x2_t b) + /// A64: CMGT Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// - /// uint64x2_t vcgtq_u64 (uint64x2_t a, uint64x2_t b) - /// A64: CMHI Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcgtq_u64 (uint64x2_t a, uint64x2_t b) + /// A64: CMHI Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// - /// uint64x1_t vcgt_f64 (float64x1_t a, float64x1_t b) - /// A64: FCMGT Dd, Dn, Dm + /// uint64x1_t vcgt_f64 (float64x1_t a, float64x1_t b) + /// A64: FCMGT Dd, Dn, Dm /// public static Vector64 CompareGreaterThanScalar(Vector64 left, Vector64 right) => CompareGreaterThanScalar(left, right); /// - /// uint64x1_t vcgt_s64 (int64x1_t a, int64x1_t b) - /// A64: CMGT Dd, Dn, Dm + /// uint64x1_t vcgt_s64 (int64x1_t a, int64x1_t b) + /// A64: CMGT Dd, Dn, Dm /// public static Vector64 CompareGreaterThanScalar(Vector64 left, Vector64 right) => CompareGreaterThanScalar(left, right); /// - /// uint32_t vcgts_f32 (float32_t a, float32_t b) - /// A64: FCMGT Sd, Sn, Sm + /// uint32_t vcgts_f32 (float32_t a, float32_t b) + /// A64: FCMGT Sd, Sn, Sm /// public static Vector64 CompareGreaterThanScalar(Vector64 left, Vector64 right) => CompareGreaterThanScalar(left, right); /// - /// uint64x1_t vcgt_u64 (uint64x1_t a, uint64x1_t b) - /// A64: CMHI Dd, Dn, Dm + /// uint64x1_t vcgt_u64 (uint64x1_t a, uint64x1_t b) + /// A64: CMHI Dd, Dn, Dm /// public static Vector64 CompareGreaterThanScalar(Vector64 left, Vector64 right) => CompareGreaterThanScalar(left, right); /// - /// uint64x2_t vcgeq_f64 (float64x2_t a, float64x2_t b) - /// A64: FCMGE Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcgeq_f64 (float64x2_t a, float64x2_t b) + /// A64: FCMGE Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// uint64x2_t vcgeq_s64 (int64x2_t a, int64x2_t b) - /// A64: CMGE Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcgeq_s64 (int64x2_t a, int64x2_t b) + /// A64: CMGE Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// uint64x2_t vcgeq_u64 (uint64x2_t a, uint64x2_t b) - /// A64: CMHS Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcgeq_u64 (uint64x2_t a, uint64x2_t b) + /// A64: CMHS Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// uint64x1_t vcge_f64 (float64x1_t a, float64x1_t b) - /// A64: FCMGE Dd, Dn, Dm + /// uint64x1_t vcge_f64 (float64x1_t a, float64x1_t b) + /// A64: FCMGE Dd, Dn, Dm /// public static Vector64 CompareGreaterThanOrEqualScalar(Vector64 left, Vector64 right) => CompareGreaterThanOrEqualScalar(left, right); /// - /// uint64x1_t vcge_s64 (int64x1_t a, int64x1_t b) - /// A64: CMGE Dd, Dn, Dm + /// uint64x1_t vcge_s64 (int64x1_t a, int64x1_t b) + /// A64: CMGE Dd, Dn, Dm /// public static Vector64 CompareGreaterThanOrEqualScalar(Vector64 left, Vector64 right) => CompareGreaterThanOrEqualScalar(left, right); /// - /// uint32_t vcges_f32 (float32_t a, float32_t b) - /// A64: FCMGE Sd, Sn, Sm + /// uint32_t vcges_f32 (float32_t a, float32_t b) + /// A64: FCMGE Sd, Sn, Sm /// public static Vector64 CompareGreaterThanOrEqualScalar(Vector64 left, Vector64 right) => CompareGreaterThanOrEqualScalar(left, right); /// - /// uint64x1_t vcge_u64 (uint64x1_t a, uint64x1_t b) - /// A64: CMHS Dd, Dn, Dm + /// uint64x1_t vcge_u64 (uint64x1_t a, uint64x1_t b) + /// A64: CMHS Dd, Dn, Dm /// public static Vector64 CompareGreaterThanOrEqualScalar(Vector64 left, Vector64 right) => CompareGreaterThanOrEqualScalar(left, right); /// - /// uint64x2_t vcltq_f64 (float64x2_t a, float64x2_t b) - /// A64: FCMGT Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcltq_f64 (float64x2_t a, float64x2_t b) + /// A64: FCMGT Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// uint64x2_t vcltq_s64 (int64x2_t a, int64x2_t b) - /// A64: CMGT Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcltq_s64 (int64x2_t a, int64x2_t b) + /// A64: CMGT Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// uint64x2_t vcltq_u64 (uint64x2_t a, uint64x2_t b) - /// A64: CMHI Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcltq_u64 (uint64x2_t a, uint64x2_t b) + /// A64: CMHI Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// uint64x1_t vclt_f64 (float64x1_t a, float64x1_t b) - /// A64: FCMGT Dd, Dn, Dm + /// uint64x1_t vclt_f64 (float64x1_t a, float64x1_t b) + /// A64: FCMGT Dd, Dn, Dm /// public static Vector64 CompareLessThanScalar(Vector64 left, Vector64 right) => CompareLessThanScalar(left, right); /// - /// uint64x1_t vclt_s64 (int64x1_t a, int64x1_t b) - /// A64: CMGT Dd, Dn, Dm + /// uint64x1_t vclt_s64 (int64x1_t a, int64x1_t b) + /// A64: CMGT Dd, Dn, Dm /// public static Vector64 CompareLessThanScalar(Vector64 left, Vector64 right) => CompareLessThanScalar(left, right); /// - /// uint32_t vclts_f32 (float32_t a, float32_t b) - /// A64: FCMGT Sd, Sn, Sm + /// uint32_t vclts_f32 (float32_t a, float32_t b) + /// A64: FCMGT Sd, Sn, Sm /// public static Vector64 CompareLessThanScalar(Vector64 left, Vector64 right) => CompareLessThanScalar(left, right); /// - /// uint64x1_t vclt_u64 (uint64x1_t a, uint64x1_t b) - /// A64: CMHI Dd, Dn, Dm + /// uint64x1_t vclt_u64 (uint64x1_t a, uint64x1_t b) + /// A64: CMHI Dd, Dn, Dm /// public static Vector64 CompareLessThanScalar(Vector64 left, Vector64 right) => CompareLessThanScalar(left, right); /// - /// uint64x2_t vcleq_f64 (float64x2_t a, float64x2_t b) - /// A64: FCMGE Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcleq_f64 (float64x2_t a, float64x2_t b) + /// A64: FCMGE Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// uint64x2_t vcleq_s64 (int64x2_t a, int64x2_t b) - /// A64: CMGE Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcleq_s64 (int64x2_t a, int64x2_t b) + /// A64: CMGE Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// uint64x2_t vcleq_u64 (uint64x2_t a, uint64x2_t b) - /// A64: CMHS Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vcleq_u64 (uint64x2_t a, uint64x2_t b) + /// A64: CMHS Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// uint64x1_t vcle_f64 (float64x1_t a, float64x1_t b) - /// A64: FCMGE Dd, Dn, Dm + /// uint64x1_t vcle_f64 (float64x1_t a, float64x1_t b) + /// A64: FCMGE Dd, Dn, Dm /// public static Vector64 CompareLessThanOrEqualScalar(Vector64 left, Vector64 right) => CompareLessThanOrEqualScalar(left, right); /// - /// uint64x1_t vcle_s64 (int64x1_t a, int64x1_t b) - /// A64: CMGE Dd, Dn, Dm + /// uint64x1_t vcle_s64 (int64x1_t a, int64x1_t b) + /// A64: CMGE Dd, Dn, Dm /// public static Vector64 CompareLessThanOrEqualScalar(Vector64 left, Vector64 right) => CompareLessThanOrEqualScalar(left, right); /// - /// uint32_t vcles_f32 (float32_t a, float32_t b) - /// A64: FCMGE Sd, Sn, Sm + /// uint32_t vcles_f32 (float32_t a, float32_t b) + /// A64: FCMGE Sd, Sn, Sm /// public static Vector64 CompareLessThanOrEqualScalar(Vector64 left, Vector64 right) => CompareLessThanOrEqualScalar(left, right); /// - /// uint64x1_t vcle_u64 (uint64x1_t a, uint64x1_t b) - /// A64: CMHS Dd, Dn, Dm + /// uint64x1_t vcle_u64 (uint64x1_t a, uint64x1_t b) + /// A64: CMHS Dd, Dn, Dm /// public static Vector64 CompareLessThanOrEqualScalar(Vector64 left, Vector64 right) => CompareLessThanOrEqualScalar(left, right); /// - /// uint64x2_t vtstq_f64 (float64x2_t a, float64x2_t b) - /// A64: CMTST Vd.2D, Vn.2D, Vm.2D - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// uint64x2_t vtstq_f64 (float64x2_t a, float64x2_t b) + /// A64: CMTST Vd.2D, Vn.2D, Vm.2D + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 CompareTest(Vector128 left, Vector128 right) => CompareTest(left, right); /// - /// uint64x2_t vtstq_s64 (int64x2_t a, int64x2_t b) - /// A64: CMTST Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vtstq_s64 (int64x2_t a, int64x2_t b) + /// A64: CMTST Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareTest(Vector128 left, Vector128 right) => CompareTest(left, right); /// - /// uint64x2_t vtstq_u64 (uint64x2_t a, uint64x2_t b) - /// A64: CMTST Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vtstq_u64 (uint64x2_t a, uint64x2_t b) + /// A64: CMTST Vd.2D, Vn.2D, Vm.2D /// public static Vector128 CompareTest(Vector128 left, Vector128 right) => CompareTest(left, right); /// - /// uint64x1_t vtst_f64 (float64x1_t a, float64x1_t b) - /// A64: CMTST Dd, Dn, Dm - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// uint64x1_t vtst_f64 (float64x1_t a, float64x1_t b) + /// A64: CMTST Dd, Dn, Dm + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 CompareTestScalar(Vector64 left, Vector64 right) => CompareTestScalar(left, right); /// - /// uint64x1_t vtst_s64 (int64x1_t a, int64x1_t b) - /// A64: CMTST Dd, Dn, Dm + /// uint64x1_t vtst_s64 (int64x1_t a, int64x1_t b) + /// A64: CMTST Dd, Dn, Dm /// public static Vector64 CompareTestScalar(Vector64 left, Vector64 right) => CompareTestScalar(left, right); /// - /// uint64x1_t vtst_u64 (uint64x1_t a, uint64x1_t b) - /// A64: CMTST Dd, Dn, Dm + /// uint64x1_t vtst_u64 (uint64x1_t a, uint64x1_t b) + /// A64: CMTST Dd, Dn, Dm /// public static Vector64 CompareTestScalar(Vector64 left, Vector64 right) => CompareTestScalar(left, right); /// - /// float64x2_t vcvt_f64_f32 (float32x2_t a) - /// A64: FCVTL Vd.2D, Vn.2S + /// float64x2_t vcvt_f64_f32 (float32x2_t a) + /// A64: FCVTL Vd.2D, Vn.2S /// public static Vector128 ConvertToDouble(Vector64 value) => ConvertToDouble(value); /// - /// float64x2_t vcvtq_f64_s64 (int64x2_t a) - /// A64: SCVTF Vd.2D, Vn.2D + /// float64x2_t vcvtq_f64_s64 (int64x2_t a) + /// A64: SCVTF Vd.2D, Vn.2D /// public static Vector128 ConvertToDouble(Vector128 value) => ConvertToDouble(value); /// - /// float64x2_t vcvtq_f64_u64 (uint64x2_t a) - /// A64: UCVTF Vd.2D, Vn.2D + /// float64x2_t vcvtq_f64_u64 (uint64x2_t a) + /// A64: UCVTF Vd.2D, Vn.2D /// public static Vector128 ConvertToDouble(Vector128 value) => ConvertToDouble(value); /// - /// float64x1_t vcvt_f64_s64 (int64x1_t a) - /// A64: SCVTF Dd, Dn + /// float64x1_t vcvt_f64_s64 (int64x1_t a) + /// A64: SCVTF Dd, Dn /// public static Vector64 ConvertToDoubleScalar(Vector64 value) => ConvertToDoubleScalar(value); /// - /// float64x1_t vcvt_f64_u64 (uint64x1_t a) - /// A64: UCVTF Dd, Dn + /// float64x1_t vcvt_f64_u64 (uint64x1_t a) + /// A64: UCVTF Dd, Dn /// public static Vector64 ConvertToDoubleScalar(Vector64 value) => ConvertToDoubleScalar(value); /// - /// float64x2_t vcvt_high_f64_f32 (float32x4_t a) - /// A64: FCVTL2 Vd.2D, Vn.4S + /// float64x2_t vcvt_high_f64_f32 (float32x4_t a) + /// A64: FCVTL2 Vd.2D, Vn.4S /// public static Vector128 ConvertToDoubleUpper(Vector128 value) => ConvertToDoubleUpper(value); /// - /// int64x2_t vcvtaq_s64_f64 (float64x2_t a) - /// A64: FCVTAS Vd.2D, Vn.2D + /// int64x2_t vcvtaq_s64_f64 (float64x2_t a) + /// A64: FCVTAS Vd.2D, Vn.2D /// public static Vector128 ConvertToInt64RoundAwayFromZero(Vector128 value) => ConvertToInt64RoundAwayFromZero(value); /// - /// int64x1_t vcvta_s64_f64 (float64x1_t a) - /// A64: FCVTAS Dd, Dn + /// int64x1_t vcvta_s64_f64 (float64x1_t a) + /// A64: FCVTAS Dd, Dn /// public static Vector64 ConvertToInt64RoundAwayFromZeroScalar(Vector64 value) => ConvertToInt64RoundAwayFromZeroScalar(value); /// - /// int64x2_t vcvtnq_s64_f64 (float64x2_t a) - /// A64: FCVTNS Vd.2D, Vn.2D + /// int64x2_t vcvtnq_s64_f64 (float64x2_t a) + /// A64: FCVTNS Vd.2D, Vn.2D /// public static Vector128 ConvertToInt64RoundToEven(Vector128 value) => ConvertToInt64RoundToEven(value); /// - /// int64x1_t vcvtn_s64_f64 (float64x1_t a) - /// A64: FCVTNS Dd, Dn + /// int64x1_t vcvtn_s64_f64 (float64x1_t a) + /// A64: FCVTNS Dd, Dn /// public static Vector64 ConvertToInt64RoundToEvenScalar(Vector64 value) => ConvertToInt64RoundToEvenScalar(value); /// - /// int64x2_t vcvtmq_s64_f64 (float64x2_t a) - /// A64: FCVTMS Vd.2D, Vn.2D + /// int64x2_t vcvtmq_s64_f64 (float64x2_t a) + /// A64: FCVTMS Vd.2D, Vn.2D /// public static Vector128 ConvertToInt64RoundToNegativeInfinity(Vector128 value) => ConvertToInt64RoundToNegativeInfinity(value); /// - /// int64x1_t vcvtm_s64_f64 (float64x1_t a) - /// A64: FCVTMS Dd, Dn + /// int64x1_t vcvtm_s64_f64 (float64x1_t a) + /// A64: FCVTMS Dd, Dn /// public static Vector64 ConvertToInt64RoundToNegativeInfinityScalar(Vector64 value) => ConvertToInt64RoundToNegativeInfinityScalar(value); /// - /// int64x2_t vcvtpq_s64_f64 (float64x2_t a) - /// A64: FCVTPS Vd.2D, Vn.2D + /// int64x2_t vcvtpq_s64_f64 (float64x2_t a) + /// A64: FCVTPS Vd.2D, Vn.2D /// public static Vector128 ConvertToInt64RoundToPositiveInfinity(Vector128 value) => ConvertToInt64RoundToPositiveInfinity(value); /// - /// int64x1_t vcvtp_s64_f64 (float64x1_t a) - /// A64: FCVTPS Dd, Dn + /// int64x1_t vcvtp_s64_f64 (float64x1_t a) + /// A64: FCVTPS Dd, Dn /// public static Vector64 ConvertToInt64RoundToPositiveInfinityScalar(Vector64 value) => ConvertToInt64RoundToPositiveInfinityScalar(value); /// - /// int64x2_t vcvtq_s64_f64 (float64x2_t a) - /// A64: FCVTZS Vd.2D, Vn.2D + /// int64x2_t vcvtq_s64_f64 (float64x2_t a) + /// A64: FCVTZS Vd.2D, Vn.2D /// public static Vector128 ConvertToInt64RoundToZero(Vector128 value) => ConvertToInt64RoundToZero(value); /// - /// int64x1_t vcvt_s64_f64 (float64x1_t a) - /// A64: FCVTZS Dd, Dn + /// int64x1_t vcvt_s64_f64 (float64x1_t a) + /// A64: FCVTZS Dd, Dn /// public static Vector64 ConvertToInt64RoundToZeroScalar(Vector64 value) => ConvertToInt64RoundToZeroScalar(value); /// - /// float32x2_t vcvt_f32_f64 (float64x2_t a) - /// A64: FCVTN Vd.2S, Vn.2D + /// float32x2_t vcvt_f32_f64 (float64x2_t a) + /// A64: FCVTN Vd.2S, Vn.2D /// public static Vector64 ConvertToSingleLower(Vector128 value) => ConvertToSingleLower(value); /// - /// float32x2_t vcvtx_f32_f64 (float64x2_t a) - /// A64: FCVTXN Vd.2S, Vn.2D + /// float32x2_t vcvtx_f32_f64 (float64x2_t a) + /// A64: FCVTXN Vd.2S, Vn.2D /// public static Vector64 ConvertToSingleRoundToOddLower(Vector128 value) => ConvertToSingleRoundToOddLower(value); /// - /// float32x4_t vcvtx_high_f32_f64 (float32x2_t r, float64x2_t a) - /// A64: FCVTXN2 Vd.4S, Vn.2D + /// float32x4_t vcvtx_high_f32_f64 (float32x2_t r, float64x2_t a) + /// A64: FCVTXN2 Vd.4S, Vn.2D /// public static Vector128 ConvertToSingleRoundToOddUpper(Vector64 lower, Vector128 value) => ConvertToSingleRoundToOddUpper(lower, value); /// - /// float32x4_t vcvt_high_f32_f64 (float32x2_t r, float64x2_t a) - /// A64: FCVTN2 Vd.4S, Vn.2D + /// float32x4_t vcvt_high_f32_f64 (float32x2_t r, float64x2_t a) + /// A64: FCVTN2 Vd.4S, Vn.2D /// public static Vector128 ConvertToSingleUpper(Vector64 lower, Vector128 value) => ConvertToSingleUpper(lower, value); /// - /// uint64x2_t vcvtaq_u64_f64 (float64x2_t a) - /// A64: FCVTAU Vd.2D, Vn.2D + /// uint64x2_t vcvtaq_u64_f64 (float64x2_t a) + /// A64: FCVTAU Vd.2D, Vn.2D /// public static Vector128 ConvertToUInt64RoundAwayFromZero(Vector128 value) => ConvertToUInt64RoundAwayFromZero(value); /// - /// uint64x1_t vcvta_u64_f64 (float64x1_t a) - /// A64: FCVTAU Dd, Dn + /// uint64x1_t vcvta_u64_f64 (float64x1_t a) + /// A64: FCVTAU Dd, Dn /// public static Vector64 ConvertToUInt64RoundAwayFromZeroScalar(Vector64 value) => ConvertToUInt64RoundAwayFromZeroScalar(value); /// - /// uint64x2_t vcvtnq_u64_f64 (float64x2_t a) - /// A64: FCVTNU Vd.2D, Vn.2D + /// uint64x2_t vcvtnq_u64_f64 (float64x2_t a) + /// A64: FCVTNU Vd.2D, Vn.2D /// public static Vector128 ConvertToUInt64RoundToEven(Vector128 value) => ConvertToUInt64RoundToEven(value); /// - /// uint64x1_t vcvtn_u64_f64 (float64x1_t a) - /// A64: FCVTNU Dd, Dn + /// uint64x1_t vcvtn_u64_f64 (float64x1_t a) + /// A64: FCVTNU Dd, Dn /// public static Vector64 ConvertToUInt64RoundToEvenScalar(Vector64 value) => ConvertToUInt64RoundToEvenScalar(value); /// - /// uint64x2_t vcvtmq_u64_f64 (float64x2_t a) - /// A64: FCVTMU Vd.2D, Vn.2D + /// uint64x2_t vcvtmq_u64_f64 (float64x2_t a) + /// A64: FCVTMU Vd.2D, Vn.2D /// public static Vector128 ConvertToUInt64RoundToNegativeInfinity(Vector128 value) => ConvertToUInt64RoundToNegativeInfinity(value); /// - /// uint64x1_t vcvtm_u64_f64 (float64x1_t a) - /// A64: FCVTMU Dd, Dn + /// uint64x1_t vcvtm_u64_f64 (float64x1_t a) + /// A64: FCVTMU Dd, Dn /// public static Vector64 ConvertToUInt64RoundToNegativeInfinityScalar(Vector64 value) => ConvertToUInt64RoundToNegativeInfinityScalar(value); /// - /// uint64x2_t vcvtpq_u64_f64 (float64x2_t a) - /// A64: FCVTPU Vd.2D, Vn.2D + /// uint64x2_t vcvtpq_u64_f64 (float64x2_t a) + /// A64: FCVTPU Vd.2D, Vn.2D /// public static Vector128 ConvertToUInt64RoundToPositiveInfinity(Vector128 value) => ConvertToUInt64RoundToPositiveInfinity(value); /// - /// uint64x1_t vcvtp_u64_f64 (float64x1_t a) - /// A64: FCVTPU Dd, Dn + /// uint64x1_t vcvtp_u64_f64 (float64x1_t a) + /// A64: FCVTPU Dd, Dn /// public static Vector64 ConvertToUInt64RoundToPositiveInfinityScalar(Vector64 value) => ConvertToUInt64RoundToPositiveInfinityScalar(value); /// - /// uint64x2_t vcvtq_u64_f64 (float64x2_t a) - /// A64: FCVTZU Vd.2D, Vn.2D + /// uint64x2_t vcvtq_u64_f64 (float64x2_t a) + /// A64: FCVTZU Vd.2D, Vn.2D /// public static Vector128 ConvertToUInt64RoundToZero(Vector128 value) => ConvertToUInt64RoundToZero(value); /// - /// uint64x1_t vcvt_u64_f64 (float64x1_t a) - /// A64: FCVTZU Dd, Dn + /// uint64x1_t vcvt_u64_f64 (float64x1_t a) + /// A64: FCVTZU Dd, Dn /// public static Vector64 ConvertToUInt64RoundToZeroScalar(Vector64 value) => ConvertToUInt64RoundToZeroScalar(value); /// - /// float32x2_t vdiv_f32 (float32x2_t a, float32x2_t b) - /// A64: FDIV Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vdiv_f32 (float32x2_t a, float32x2_t b) + /// A64: FDIV Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Divide(Vector64 left, Vector64 right) => Divide(left, right); /// - /// float64x2_t vdivq_f64 (float64x2_t a, float64x2_t b) - /// A64: FDIV Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vdivq_f64 (float64x2_t a, float64x2_t b) + /// A64: FDIV Vd.2D, Vn.2D, Vm.2D /// public static Vector128 Divide(Vector128 left, Vector128 right) => Divide(left, right); /// - /// float32x4_t vdivq_f32 (float32x4_t a, float32x4_t b) - /// A64: FDIV Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vdivq_f32 (float32x4_t a, float32x4_t b) + /// A64: FDIV Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Divide(Vector128 left, Vector128 right) => Divide(left, right); /// - /// float64x2_t vdupq_laneq_f64 (float64x2_t vec, const int lane) - /// A64: DUP Vd.2D, Vn.D[index] + /// float64x2_t vdupq_laneq_f64 (float64x2_t vec, const int lane) + /// A64: DUP Vd.2D, Vn.D[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector128 value, [ConstantExpected(Max = (byte)(1))] byte index) => DuplicateSelectedScalarToVector128(value, index); /// - /// int64x2_t vdupq_laneq_s64 (int64x2_t vec, const int lane) - /// A64: DUP Vd.2D, Vn.D[index] + /// int64x2_t vdupq_laneq_s64 (int64x2_t vec, const int lane) + /// A64: DUP Vd.2D, Vn.D[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector128 value, [ConstantExpected(Max = (byte)(1))] byte index) => DuplicateSelectedScalarToVector128(value, index); /// - /// uint64x2_t vdupq_laneq_u64 (uint64x2_t vec, const int lane) - /// A64: DUP Vd.2D, Vn.D[index] + /// uint64x2_t vdupq_laneq_u64 (uint64x2_t vec, const int lane) + /// A64: DUP Vd.2D, Vn.D[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector128 value, [ConstantExpected(Max = (byte)(1))] byte index) => DuplicateSelectedScalarToVector128(value, index); /// - /// float64x2_t vdupq_n_f64 (float64_t value) - /// A64: DUP Vd.2D, Vn.D[0] + /// float64x2_t vdupq_n_f64 (float64_t value) + /// A64: DUP Vd.2D, Vn.D[0] /// public static Vector128 DuplicateToVector128(double value) => DuplicateToVector128(value); /// - /// int64x2_t vdupq_n_s64 (int64_t value) - /// A64: DUP Vd.2D, Rn + /// int64x2_t vdupq_n_s64 (int64_t value) + /// A64: DUP Vd.2D, Rn /// public static Vector128 DuplicateToVector128(long value) => DuplicateToVector128(value); /// - /// uint64x2_t vdupq_n_s64 (uint64_t value) - /// A64: DUP Vd.2D, Rn + /// uint64x2_t vdupq_n_s64 (uint64_t value) + /// A64: DUP Vd.2D, Rn /// public static Vector128 DuplicateToVector128(ulong value) => DuplicateToVector128(value); /// - /// uint8_t vqmovnh_u16 (uint16_t a) - /// A64: UQXTN Bd, Hn + /// uint8_t vqmovnh_u16 (uint16_t a) + /// A64: UQXTN Bd, Hn /// public static Vector64 ExtractNarrowingSaturateScalar(Vector64 value) => ExtractNarrowingSaturateScalar(value); /// - /// int16_t vqmovns_s32 (int32_t a) - /// A64: SQXTN Hd, Sn + /// int16_t vqmovns_s32 (int32_t a) + /// A64: SQXTN Hd, Sn /// public static Vector64 ExtractNarrowingSaturateScalar(Vector64 value) => ExtractNarrowingSaturateScalar(value); /// - /// int32_t vqmovnd_s64 (int64_t a) - /// A64: SQXTN Sd, Dn + /// int32_t vqmovnd_s64 (int64_t a) + /// A64: SQXTN Sd, Dn /// public static Vector64 ExtractNarrowingSaturateScalar(Vector64 value) => ExtractNarrowingSaturateScalar(value); /// - /// int8_t vqmovnh_s16 (int16_t a) - /// A64: SQXTN Bd, Hn + /// int8_t vqmovnh_s16 (int16_t a) + /// A64: SQXTN Bd, Hn /// public static Vector64 ExtractNarrowingSaturateScalar(Vector64 value) => ExtractNarrowingSaturateScalar(value); /// - /// uint16_t vqmovns_u32 (uint32_t a) - /// A64: UQXTN Hd, Sn + /// uint16_t vqmovns_u32 (uint32_t a) + /// A64: UQXTN Hd, Sn /// public static Vector64 ExtractNarrowingSaturateScalar(Vector64 value) => ExtractNarrowingSaturateScalar(value); /// - /// uint32_t vqmovnd_u64 (uint64_t a) - /// A64: UQXTN Sd, Dn + /// uint32_t vqmovnd_u64 (uint64_t a) + /// A64: UQXTN Sd, Dn /// public static Vector64 ExtractNarrowingSaturateScalar(Vector64 value) => ExtractNarrowingSaturateScalar(value); /// - /// uint8_t vqmovunh_s16 (int16_t a) - /// A64: SQXTUN Bd, Hn + /// uint8_t vqmovunh_s16 (int16_t a) + /// A64: SQXTUN Bd, Hn /// public static Vector64 ExtractNarrowingSaturateUnsignedScalar(Vector64 value) => ExtractNarrowingSaturateUnsignedScalar(value); /// - /// uint16_t vqmovuns_s32 (int32_t a) - /// A64: SQXTUN Hd, Sn + /// uint16_t vqmovuns_s32 (int32_t a) + /// A64: SQXTUN Hd, Sn /// public static Vector64 ExtractNarrowingSaturateUnsignedScalar(Vector64 value) => ExtractNarrowingSaturateUnsignedScalar(value); /// - /// uint32_t vqmovund_s64 (int64_t a) - /// A64: SQXTUN Sd, Dn + /// uint32_t vqmovund_s64 (int64_t a) + /// A64: SQXTUN Sd, Dn /// public static Vector64 ExtractNarrowingSaturateUnsignedScalar(Vector64 value) => ExtractNarrowingSaturateUnsignedScalar(value); /// - /// float64x2_t vrndmq_f64 (float64x2_t a) - /// A64: FRINTM Vd.2D, Vn.2D + /// float64x2_t vrndmq_f64 (float64x2_t a) + /// A64: FRINTM Vd.2D, Vn.2D /// public static Vector128 Floor(Vector128 value) => Floor(value); /// - /// float64x2_t vfmaq_f64 (float64x2_t a, float64x2_t b, float64x2_t c) - /// A64: FMLA Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vfmaq_f64 (float64x2_t a, float64x2_t b, float64x2_t c) + /// A64: FMLA Vd.2D, Vn.2D, Vm.2D /// public static Vector128 FusedMultiplyAdd(Vector128 addend, Vector128 left, Vector128 right) => FusedMultiplyAdd(addend, left, right); /// - /// float32x2_t vfma_n_f32 (float32x2_t a, float32x2_t b, float32_t n) - /// A64: FMLA Vd.2S, Vn.2S, Vm.S[0] + /// float32x2_t vfma_n_f32 (float32x2_t a, float32x2_t b, float32_t n) + /// A64: FMLA Vd.2S, Vn.2S, Vm.S[0] /// public static Vector64 FusedMultiplyAddByScalar(Vector64 addend, Vector64 left, Vector64 right) => FusedMultiplyAddByScalar(addend, left, right); /// - /// float64x2_t vfmaq_n_f64 (float64x2_t a, float64x2_t b, float64_t n) - /// A64: FMLA Vd.2D, Vn.2D, Vm.D[0] + /// float64x2_t vfmaq_n_f64 (float64x2_t a, float64x2_t b, float64_t n) + /// A64: FMLA Vd.2D, Vn.2D, Vm.D[0] /// public static Vector128 FusedMultiplyAddByScalar(Vector128 addend, Vector128 left, Vector64 right) => FusedMultiplyAddByScalar(addend, left, right); /// - /// float32x4_t vfmaq_n_f32 (float32x4_t a, float32x4_t b, float32_t n) - /// A64: FMLA Vd.4S, Vn.4S, Vm.S[0] + /// float32x4_t vfmaq_n_f32 (float32x4_t a, float32x4_t b, float32_t n) + /// A64: FMLA Vd.4S, Vn.4S, Vm.S[0] /// public static Vector128 FusedMultiplyAddByScalar(Vector128 addend, Vector128 left, Vector64 right) => FusedMultiplyAddByScalar(addend, left, right); /// - /// float32x2_t vfma_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane) - /// A64: FMLA Vd.2S, Vn.2S, Vm.S[lane] + /// float32x2_t vfma_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane) + /// A64: FMLA Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 FusedMultiplyAddBySelectedScalar(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => FusedMultiplyAddBySelectedScalar(addend, left, right, rightIndex); /// - /// float32x2_t vfma_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane) - /// A64: FMLA Vd.2S, Vn.2S, Vm.S[lane] + /// float32x2_t vfma_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane) + /// A64: FMLA Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 FusedMultiplyAddBySelectedScalar(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => FusedMultiplyAddBySelectedScalar(addend, left, right, rightIndex); /// - /// float64x2_t vfmaq_laneq_f64 (float64x2_t a, float64x2_t b, float64x2_t v, const int lane) - /// A64: FMLA Vd.2D, Vn.2D, Vm.D[lane] + /// float64x2_t vfmaq_laneq_f64 (float64x2_t a, float64x2_t b, float64x2_t v, const int lane) + /// A64: FMLA Vd.2D, Vn.2D, Vm.D[lane] /// public static Vector128 FusedMultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => FusedMultiplyAddBySelectedScalar(addend, left, right, rightIndex); /// - /// float32x4_t vfmaq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane) - /// A64: FMLA Vd.4S, Vn.4S, Vm.S[lane] + /// float32x4_t vfmaq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane) + /// A64: FMLA Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 FusedMultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => FusedMultiplyAddBySelectedScalar(addend, left, right, rightIndex); /// - /// float32x4_t vfmaq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane) - /// A64: FMLA Vd.4S, Vn.4S, Vm.S[lane] + /// float32x4_t vfmaq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane) + /// A64: FMLA Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 FusedMultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => FusedMultiplyAddBySelectedScalar(addend, left, right, rightIndex); /// - /// float64_t vfmad_laneq_f64 (float64_t a, float64_t b, float64x2_t v, const int lane) - /// A64: FMLA Dd, Dn, Vm.D[lane] + /// float64_t vfmad_laneq_f64 (float64_t a, float64_t b, float64x2_t v, const int lane) + /// A64: FMLA Dd, Dn, Vm.D[lane] /// public static Vector64 FusedMultiplyAddScalarBySelectedScalar(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => FusedMultiplyAddScalarBySelectedScalar(addend, left, right, rightIndex); /// - /// float32_t vfmas_lane_f32 (float32_t a, float32_t b, float32x2_t v, const int lane) - /// A64: FMLA Sd, Sn, Vm.S[lane] + /// float32_t vfmas_lane_f32 (float32_t a, float32_t b, float32x2_t v, const int lane) + /// A64: FMLA Sd, Sn, Vm.S[lane] /// public static Vector64 FusedMultiplyAddScalarBySelectedScalar(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => FusedMultiplyAddScalarBySelectedScalar(addend, left, right, rightIndex); /// - /// float32_t vfmas_laneq_f32 (float32_t a, float32_t b, float32x4_t v, const int lane) - /// A64: FMLA Sd, Sn, Vm.S[lane] + /// float32_t vfmas_laneq_f32 (float32_t a, float32_t b, float32x4_t v, const int lane) + /// A64: FMLA Sd, Sn, Vm.S[lane] /// public static Vector64 FusedMultiplyAddScalarBySelectedScalar(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => FusedMultiplyAddScalarBySelectedScalar(addend, left, right, rightIndex); /// - /// float64x2_t vfmsq_f64 (float64x2_t a, float64x2_t b, float64x2_t c) - /// A64: FMLS Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vfmsq_f64 (float64x2_t a, float64x2_t b, float64x2_t c) + /// A64: FMLS Vd.2D, Vn.2D, Vm.2D /// public static Vector128 FusedMultiplySubtract(Vector128 minuend, Vector128 left, Vector128 right) => FusedMultiplySubtract(minuend, left, right); /// - /// float32x2_t vfms_n_f32 (float32x2_t a, float32x2_t b, float32_t n) - /// A64: FMLS Vd.2S, Vn.2S, Vm.S[0] + /// float32x2_t vfms_n_f32 (float32x2_t a, float32x2_t b, float32_t n) + /// A64: FMLS Vd.2S, Vn.2S, Vm.S[0] /// public static Vector64 FusedMultiplySubtractByScalar(Vector64 minuend, Vector64 left, Vector64 right) => FusedMultiplySubtractByScalar(minuend, left, right); /// - /// float64x2_t vfmsq_n_f64 (float64x2_t a, float64x2_t b, float64_t n) - /// A64: FMLS Vd.2D, Vn.2D, Vm.D[0] + /// float64x2_t vfmsq_n_f64 (float64x2_t a, float64x2_t b, float64_t n) + /// A64: FMLS Vd.2D, Vn.2D, Vm.D[0] /// public static Vector128 FusedMultiplySubtractByScalar(Vector128 minuend, Vector128 left, Vector64 right) => FusedMultiplySubtractByScalar(minuend, left, right); /// - /// float32x4_t vfmsq_n_f32 (float32x4_t a, float32x4_t b, float32_t n) - /// A64: FMLS Vd.4S, Vn.4S, Vm.S[0] + /// float32x4_t vfmsq_n_f32 (float32x4_t a, float32x4_t b, float32_t n) + /// A64: FMLS Vd.4S, Vn.4S, Vm.S[0] /// public static Vector128 FusedMultiplySubtractByScalar(Vector128 minuend, Vector128 left, Vector64 right) => FusedMultiplySubtractByScalar(minuend, left, right); /// - /// float32x2_t vfms_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane) - /// A64: FMLS Vd.2S, Vn.2S, Vm.S[lane] + /// float32x2_t vfms_lane_f32 (float32x2_t a, float32x2_t b, float32x2_t v, const int lane) + /// A64: FMLS Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 FusedMultiplySubtractBySelectedScalar(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => FusedMultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); /// - /// float32x2_t vfms_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane) - /// A64: FMLS Vd.2S, Vn.2S, Vm.S[lane] + /// float32x2_t vfms_laneq_f32 (float32x2_t a, float32x2_t b, float32x4_t v, const int lane) + /// A64: FMLS Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 FusedMultiplySubtractBySelectedScalar(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => FusedMultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); /// - /// float64x2_t vfmsq_laneq_f64 (float64x2_t a, float64x2_t b, float64x2_t v, const int lane) - /// A64: FMLS Vd.2D, Vn.2D, Vm.D[lane] + /// float64x2_t vfmsq_laneq_f64 (float64x2_t a, float64x2_t b, float64x2_t v, const int lane) + /// A64: FMLS Vd.2D, Vn.2D, Vm.D[lane] /// public static Vector128 FusedMultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => FusedMultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); /// - /// float32x4_t vfmsq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane) - /// A64: FMLS Vd.4S, Vn.4S, Vm.S[lane] + /// float32x4_t vfmsq_lane_f32 (float32x4_t a, float32x4_t b, float32x2_t v, const int lane) + /// A64: FMLS Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 FusedMultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => FusedMultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); /// - /// float32x4_t vfmsq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane) - /// A64: FMLS Vd.4S, Vn.4S, Vm.S[lane] + /// float32x4_t vfmsq_laneq_f32 (float32x4_t a, float32x4_t b, float32x4_t v, const int lane) + /// A64: FMLS Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 FusedMultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => FusedMultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); /// - /// float64_t vfmsd_laneq_f64 (float64_t a, float64_t b, float64x2_t v, const int lane) - /// A64: FMLS Dd, Dn, Vm.D[lane] + /// float64_t vfmsd_laneq_f64 (float64_t a, float64_t b, float64x2_t v, const int lane) + /// A64: FMLS Dd, Dn, Vm.D[lane] /// public static Vector64 FusedMultiplySubtractScalarBySelectedScalar(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => FusedMultiplySubtractScalarBySelectedScalar(minuend, left, right, rightIndex); /// - /// float32_t vfmss_lane_f32 (float32_t a, float32_t b, float32x2_t v, const int lane) - /// A64: FMLS Sd, Sn, Vm.S[lane] + /// float32_t vfmss_lane_f32 (float32_t a, float32_t b, float32x2_t v, const int lane) + /// A64: FMLS Sd, Sn, Vm.S[lane] /// public static Vector64 FusedMultiplySubtractScalarBySelectedScalar(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => FusedMultiplySubtractScalarBySelectedScalar(minuend, left, right, rightIndex); /// - /// float32_t vfmss_laneq_f32 (float32_t a, float32_t b, float32x4_t v, const int lane) - /// A64: FMLS Sd, Sn, Vm.S[lane] + /// float32_t vfmss_laneq_f32 (float32_t a, float32_t b, float32x4_t v, const int lane) + /// A64: FMLS Sd, Sn, Vm.S[lane] /// public static Vector64 FusedMultiplySubtractScalarBySelectedScalar(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => FusedMultiplySubtractScalarBySelectedScalar(minuend, left, right, rightIndex); /// - /// uint8x8_t vcopy_lane_u8 (uint8x8_t a, const int lane1, uint8x8_t b, const int lane2) - /// A64: INS Vd.B[lane1], Vn.B[lane2] + /// uint8x8_t vcopy_lane_u8 (uint8x8_t a, const int lane1, uint8x8_t b, const int lane2) + /// A64: INS Vd.B[lane1], Vn.B[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// uint8x8_t vcopy_laneq_u8 (uint8x8_t a, const int lane1, uint8x16_t b, const int lane2) - /// A64: INS Vd.B[lane1], Vn.B[lane2] + /// uint8x8_t vcopy_laneq_u8 (uint8x8_t a, const int lane1, uint8x16_t b, const int lane2) + /// A64: INS Vd.B[lane1], Vn.B[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(15))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// int16x4_t vcopy_lane_s16 (int16x4_t a, const int lane1, int16x4_t b, const int lane2) - /// A64: INS Vd.H[lane1], Vn.H[lane2] + /// int16x4_t vcopy_lane_s16 (int16x4_t a, const int lane1, int16x4_t b, const int lane2) + /// A64: INS Vd.H[lane1], Vn.H[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// int16x4_t vcopy_laneq_s16 (int16x4_t a, const int lane1, int16x8_t b, const int lane2) - /// A64: INS Vd.H[lane1], Vn.H[lane2] + /// int16x4_t vcopy_laneq_s16 (int16x4_t a, const int lane1, int16x8_t b, const int lane2) + /// A64: INS Vd.H[lane1], Vn.H[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// int32x2_t vcopy_lane_s32 (int32x2_t a, const int lane1, int32x2_t b, const int lane2) - /// A64: INS Vd.S[lane1], Vn.S[lane2] + /// int32x2_t vcopy_lane_s32 (int32x2_t a, const int lane1, int32x2_t b, const int lane2) + /// A64: INS Vd.S[lane1], Vn.S[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// int32x2_t vcopy_laneq_s32 (int32x2_t a, const int lane1, int32x4_t b, const int lane2) - /// A64: INS Vd.S[lane1], Vn.S[lane2] + /// int32x2_t vcopy_laneq_s32 (int32x2_t a, const int lane1, int32x4_t b, const int lane2) + /// A64: INS Vd.S[lane1], Vn.S[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// int8x8_t vcopy_lane_s8 (int8x8_t a, const int lane1, int8x8_t b, const int lane2) - /// A64: INS Vd.B[lane1], Vn.B[lane2] + /// int8x8_t vcopy_lane_s8 (int8x8_t a, const int lane1, int8x8_t b, const int lane2) + /// A64: INS Vd.B[lane1], Vn.B[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// int8x8_t vcopy_laneq_s8 (int8x8_t a, const int lane1, int8x16_t b, const int lane2) - /// A64: INS Vd.B[lane1], Vn.B[lane2] + /// int8x8_t vcopy_laneq_s8 (int8x8_t a, const int lane1, int8x16_t b, const int lane2) + /// A64: INS Vd.B[lane1], Vn.B[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(15))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// float32x2_t vcopy_lane_f32 (float32x2_t a, const int lane1, float32x2_t b, const int lane2) - /// A64: INS Vd.S[lane1], Vn.S[lane2] + /// float32x2_t vcopy_lane_f32 (float32x2_t a, const int lane1, float32x2_t b, const int lane2) + /// A64: INS Vd.S[lane1], Vn.S[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// float32x2_t vcopy_laneq_f32 (float32x2_t a, const int lane1, float32x4_t b, const int lane2) - /// A64: INS Vd.S[lane1], Vn.S[lane2] + /// float32x2_t vcopy_laneq_f32 (float32x2_t a, const int lane1, float32x4_t b, const int lane2) + /// A64: INS Vd.S[lane1], Vn.S[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// uint16x4_t vcopy_lane_u16 (uint16x4_t a, const int lane1, uint16x4_t b, const int lane2) - /// A64: INS Vd.H[lane1], Vn.H[lane2] + /// uint16x4_t vcopy_lane_u16 (uint16x4_t a, const int lane1, uint16x4_t b, const int lane2) + /// A64: INS Vd.H[lane1], Vn.H[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// uint16x4_t vcopy_laneq_u16 (uint16x4_t a, const int lane1, uint16x8_t b, const int lane2) - /// A64: INS Vd.H[lane1], Vn.H[lane2] + /// uint16x4_t vcopy_laneq_u16 (uint16x4_t a, const int lane1, uint16x8_t b, const int lane2) + /// A64: INS Vd.H[lane1], Vn.H[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// uint32x2_t vcopy_lane_u32 (uint32x2_t a, const int lane1, uint32x2_t b, const int lane2) - /// A64: INS Vd.S[lane1], Vn.S[lane2] + /// uint32x2_t vcopy_lane_u32 (uint32x2_t a, const int lane1, uint32x2_t b, const int lane2) + /// A64: INS Vd.S[lane1], Vn.S[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// uint32x2_t vcopy_laneq_u32 (uint32x2_t a, const int lane1, uint32x4_t b, const int lane2) - /// A64: INS Vd.S[lane1], Vn.S[lane2] + /// uint32x2_t vcopy_laneq_u32 (uint32x2_t a, const int lane1, uint32x4_t b, const int lane2) + /// A64: INS Vd.S[lane1], Vn.S[lane2] /// public static Vector64 InsertSelectedScalar(Vector64 result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// uint8x16_t vcopyq_lane_u8 (uint8x16_t a, const int lane1, uint8x8_t b, const int lane2) - /// A64: INS Vd.B[lane1], Vn.B[lane2] + /// uint8x16_t vcopyq_lane_u8 (uint8x16_t a, const int lane1, uint8x8_t b, const int lane2) + /// A64: INS Vd.B[lane1], Vn.B[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(15))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// uint8x16_t vcopyq_laneq_u8 (uint8x16_t a, const int lane1, uint8x16_t b, const int lane2) - /// A64: INS Vd.B[lane1], Vn.B[lane2] + /// uint8x16_t vcopyq_laneq_u8 (uint8x16_t a, const int lane1, uint8x16_t b, const int lane2) + /// A64: INS Vd.B[lane1], Vn.B[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(15))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(15))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// float64x2_t vcopyq_laneq_f64 (float64x2_t a, const int lane1, float64x2_t b, const int lane2) - /// A64: INS Vd.D[lane1], Vn.D[lane2] + /// float64x2_t vcopyq_laneq_f64 (float64x2_t a, const int lane1, float64x2_t b, const int lane2) + /// A64: INS Vd.D[lane1], Vn.D[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// int16x8_t vcopyq_lane_s16 (int16x8_t a, const int lane1, int16x4_t b, const int lane2) - /// A64: INS Vd.H[lane1], Vn.H[lane2] + /// int16x8_t vcopyq_lane_s16 (int16x8_t a, const int lane1, int16x4_t b, const int lane2) + /// A64: INS Vd.H[lane1], Vn.H[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// int16x8_t vcopyq_laneq_s16 (int16x8_t a, const int lane1, int16x8_t b, const int lane2) - /// A64: INS Vd.H[lane1], Vn.H[lane2] + /// int16x8_t vcopyq_laneq_s16 (int16x8_t a, const int lane1, int16x8_t b, const int lane2) + /// A64: INS Vd.H[lane1], Vn.H[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// int32x4_t vcopyq_lane_s32 (int32x4_t a, const int lane1, int32x2_t b, const int lane2) - /// A64: INS Vd.S[lane1], Vn.S[lane2] + /// int32x4_t vcopyq_lane_s32 (int32x4_t a, const int lane1, int32x2_t b, const int lane2) + /// A64: INS Vd.S[lane1], Vn.S[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// int32x4_t vcopyq_laneq_s32 (int32x4_t a, const int lane1, int32x4_t b, const int lane2) - /// A64: INS Vd.S[lane1], Vn.S[lane2] + /// int32x4_t vcopyq_laneq_s32 (int32x4_t a, const int lane1, int32x4_t b, const int lane2) + /// A64: INS Vd.S[lane1], Vn.S[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// int64x2_t vcopyq_laneq_s64 (int64x2_t a, const int lane1, int64x2_t b, const int lane2) - /// A64: INS Vd.D[lane1], Vn.D[lane2] + /// int64x2_t vcopyq_laneq_s64 (int64x2_t a, const int lane1, int64x2_t b, const int lane2) + /// A64: INS Vd.D[lane1], Vn.D[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// int8x16_t vcopyq_lane_s8 (int8x16_t a, const int lane1, int8x8_t b, const int lane2) - /// A64: INS Vd.B[lane1], Vn.B[lane2] + /// int8x16_t vcopyq_lane_s8 (int8x16_t a, const int lane1, int8x8_t b, const int lane2) + /// A64: INS Vd.B[lane1], Vn.B[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(15))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// int8x16_t vcopyq_laneq_s8 (int8x16_t a, const int lane1, int8x16_t b, const int lane2) - /// A64: INS Vd.B[lane1], Vn.B[lane2] + /// int8x16_t vcopyq_laneq_s8 (int8x16_t a, const int lane1, int8x16_t b, const int lane2) + /// A64: INS Vd.B[lane1], Vn.B[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(15))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(15))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// float32x4_t vcopyq_lane_f32 (float32x4_t a, const int lane1, float32x2_t b, const int lane2) - /// A64: INS Vd.S[lane1], Vn.S[lane2] + /// float32x4_t vcopyq_lane_f32 (float32x4_t a, const int lane1, float32x2_t b, const int lane2) + /// A64: INS Vd.S[lane1], Vn.S[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// float32x4_t vcopyq_laneq_f32 (float32x4_t a, const int lane1, float32x4_t b, const int lane2) - /// A64: INS Vd.S[lane1], Vn.S[lane2] + /// float32x4_t vcopyq_laneq_f32 (float32x4_t a, const int lane1, float32x4_t b, const int lane2) + /// A64: INS Vd.S[lane1], Vn.S[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// uint16x8_t vcopyq_lane_u16 (uint16x8_t a, const int lane1, uint16x4_t b, const int lane2) - /// A64: INS Vd.H[lane1], Vn.H[lane2] + /// uint16x8_t vcopyq_lane_u16 (uint16x8_t a, const int lane1, uint16x4_t b, const int lane2) + /// A64: INS Vd.H[lane1], Vn.H[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// uint16x8_t vcopyq_laneq_u16 (uint16x8_t a, const int lane1, uint16x8_t b, const int lane2) - /// A64: INS Vd.H[lane1], Vn.H[lane2] + /// uint16x8_t vcopyq_laneq_u16 (uint16x8_t a, const int lane1, uint16x8_t b, const int lane2) + /// A64: INS Vd.H[lane1], Vn.H[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(7))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(7))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// uint32x4_t vcopyq_lane_u32 (uint32x4_t a, const int lane1, uint32x2_t b, const int lane2) - /// A64: INS Vd.S[lane1], Vn.S[lane2] + /// uint32x4_t vcopyq_lane_u32 (uint32x4_t a, const int lane1, uint32x2_t b, const int lane2) + /// A64: INS Vd.S[lane1], Vn.S[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector64 value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// uint32x4_t vcopyq_laneq_u32 (uint32x4_t a, const int lane1, uint32x4_t b, const int lane2) - /// A64: INS Vd.S[lane1], Vn.S[lane2] + /// uint32x4_t vcopyq_laneq_u32 (uint32x4_t a, const int lane1, uint32x4_t b, const int lane2) + /// A64: INS Vd.S[lane1], Vn.S[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(3))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(3))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); /// - /// uint64x2_t vcopyq_laneq_u64 (uint64x2_t a, const int lane1, uint64x2_t b, const int lane2) - /// A64: INS Vd.D[lane1], Vn.D[lane2] + /// uint64x2_t vcopyq_laneq_u64 (uint64x2_t a, const int lane1, uint64x2_t b, const int lane2) + /// A64: INS Vd.D[lane1], Vn.D[lane2] /// public static Vector128 InsertSelectedScalar(Vector128 result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector128 value, [ConstantExpected(Max = (byte)(1))] byte valueIndex) => Insert(result, resultIndex, Extract(value, valueIndex)); - /// - /// A64: LD2 { Vn.16B, Vn+1.16B }[Vm], [Xn] - /// + /// A64: LD2 { Vn.16B, Vn+1.16B }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndInsertScalar((Vector128, Vector128) values, [ConstantExpected(Max = (byte)(15))] byte index, byte* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD2 { Vn.16B, Vn+1.16B }[Vm], [Xn] - /// + /// A64: LD2 { Vn.16B, Vn+1.16B }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndInsertScalar((Vector128, Vector128) values, [ConstantExpected(Max = (byte)(15))] byte index, sbyte* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD2 { Vn.8H, Vn+1.8H }[Vm], [Xn] - /// + /// A64: LD2 { Vn.8H, Vn+1.8H }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndInsertScalar((Vector128, Vector128) values, [ConstantExpected(Max = (byte)(7))] byte index, short* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD2 { Vn.8H, Vn+1.8H }[Vm], [Xn] - /// + /// A64: LD2 { Vn.8H, Vn+1.8H }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndInsertScalar((Vector128, Vector128) values, [ConstantExpected(Max = (byte)(7))] byte index, ushort* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD2 { Vn.4S, Vn+1.4S }[Vm], [Xn] - /// + /// A64: LD2 { Vn.4S, Vn+1.4S }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndInsertScalar((Vector128, Vector128) values, [ConstantExpected(Max = (byte)(3))] byte index, int* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD2 { Vn.4S, Vn+1.4S }[Vm], [Xn] - /// + /// A64: LD2 { Vn.4S, Vn+1.4S }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndInsertScalar((Vector128, Vector128) values, [ConstantExpected(Max = (byte)(3))] byte index, uint* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD2 { Vn.2D, Vn+1.2D }[Vm], [Xn] - /// + /// A64: LD2 { Vn.2D, Vn+1.2D }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndInsertScalar((Vector128, Vector128) values, [ConstantExpected(Max = (byte)(1))] byte index, long* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD2 { Vn.2D, Vn+1.2D }[Vm], [Xn] - /// + /// A64: LD2 { Vn.2D, Vn+1.2D }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndInsertScalar((Vector128, Vector128) values, [ConstantExpected(Max = (byte)(1))] byte index, ulong* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD2 { Vn.4S, Vn+1.4S }[Vm], [Xn] - /// + /// A64: LD2 { Vn.4S, Vn+1.4S }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndInsertScalar((Vector128, Vector128) values, [ConstantExpected(Max = (byte)(3))] byte index, float* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD2 { Vn.2D, Vn+1.2D }[Vm], [Xn] - /// + /// A64: LD2 { Vn.2D, Vn+1.2D }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndInsertScalar((Vector128, Vector128) values, [ConstantExpected(Max = (byte)(1))] byte index, double* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD3 { Vn.16B, Vn+1.16B, Vn+2.16B }[Vm], [Xn] - /// + /// A64: LD3 { Vn.16B, Vn+1.16B, Vn+2.16B }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndInsertScalar((Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(15))] byte index, byte* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD3 { Vn.16B, Vn+1.16B, Vn+2.16B }[Vm], [Xn] - /// + /// A64: LD3 { Vn.16B, Vn+1.16B, Vn+2.16B }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndInsertScalar((Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(15))] byte index, sbyte* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD3 { Vn.8H, Vn+1.8H, Vn+2.8H }[Vm], [Xn] - /// + /// A64: LD3 { Vn.8H, Vn+1.8H, Vn+2.8H }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndInsertScalar((Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(7))] byte index, short* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD3 { Vn.8H, Vn+1.8H, Vn+2.8H }[Vm], [Xn] - /// + /// A64: LD3 { Vn.8H, Vn+1.8H, Vn+2.8H }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndInsertScalar((Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(7))] byte index, ushort* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }[Vm], [Xn] - /// + /// A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndInsertScalar((Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(3))] byte index, int* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }[Vm], [Xn] - /// + /// A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndInsertScalar((Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(3))] byte index, uint* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }[Vm], [Xn] - /// + /// A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndInsertScalar((Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(1))] byte index, long* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }[Vm], [Xn] - /// + /// A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndInsertScalar((Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(1))] byte index, ulong* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }[Vm], [Xn] - /// + /// A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndInsertScalar((Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(3))] byte index, float* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }[Vm], [Xn] - /// + /// A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndInsertScalar((Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(1))] byte index, double* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }[Vm], [Xn] - /// + /// A64: LD4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndInsertScalar((Vector128, Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(15))] byte index, byte* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }[Vm], [Xn] - /// + /// A64: LD4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndInsertScalar((Vector128, Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(15))] byte index, sbyte* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }[Vm], [Xn] - /// + /// A64: LD4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndInsertScalar((Vector128, Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(7))] byte index, short* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }[Vm], [Xn] - /// + /// A64: LD4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndInsertScalar((Vector128, Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(7))] byte index, ushort* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }[Vm], [Xn] - /// + /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndInsertScalar((Vector128, Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(3))] byte index, int* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }[Vm], [Xn] - /// + /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndInsertScalar((Vector128, Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(3))] byte index, uint* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }[Vm], [Xn] - /// + /// A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndInsertScalar((Vector128, Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(1))] byte index, long* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }[Vm], [Xn] - /// + /// A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndInsertScalar((Vector128, Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(1))] byte index, ulong* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }[Vm], [Xn] - /// + /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndInsertScalar((Vector128, Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(3))] byte index, float* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }[Vm], [Xn] - /// + /// A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }[Vm], [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndInsertScalar((Vector128, Vector128, Vector128, Vector128) values, [ConstantExpected(Max = (byte)(1))] byte index, double* address) => LoadAndInsertScalar(values, index, address); /// - /// float64x2_t vld1q_dup_f64 (float64_t const * ptr) - /// A64: LD1R { Vt.2D }, [Xn] + /// float64x2_t vld1q_dup_f64 (float64_t const * ptr) + /// A64: LD1R { Vt.2D }, [Xn] /// public static unsafe Vector128 LoadAndReplicateToVector128(double* address) => LoadAndReplicateToVector128(address); /// - /// int64x2_t vld1q_dup_s64 (int64_t const * ptr) - /// A64: LD1R { Vt.2D }, [Xn] + /// int64x2_t vld1q_dup_s64 (int64_t const * ptr) + /// A64: LD1R { Vt.2D }, [Xn] /// public static unsafe Vector128 LoadAndReplicateToVector128(long* address) => LoadAndReplicateToVector128(address); /// - /// uint64x2_t vld1q_dup_u64 (uint64_t const * ptr) - /// A64: LD1R { Vt.2D }, [Xn] + /// uint64x2_t vld1q_dup_u64 (uint64_t const * ptr) + /// A64: LD1R { Vt.2D }, [Xn] /// public static unsafe Vector128 LoadAndReplicateToVector128(ulong* address) => LoadAndReplicateToVector128(address); - /// - /// A64: LD2R { Vn.16B, Vn+1.16B }, [Xn] - /// + /// A64: LD2R { Vn.16B, Vn+1.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndReplicateToVector128x2(byte* address) => LoadAndReplicateToVector128x2(address); - /// - /// A64: LD2R { Vn.16B, Vn+1.16B }, [Xn] - /// + /// A64: LD2R { Vn.16B, Vn+1.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndReplicateToVector128x2(sbyte* address) => LoadAndReplicateToVector128x2(address); - /// - /// A64: LD2R { Vn.8H, Vn+1.8H }, [Xn] - /// + /// A64: LD2R { Vn.8H, Vn+1.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndReplicateToVector128x2(short* address) => LoadAndReplicateToVector128x2(address); - /// - /// A64: LD2R { Vn.8H, Vn+1.8H }, [Xn] - /// + /// A64: LD2R { Vn.8H, Vn+1.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndReplicateToVector128x2(ushort* address) => LoadAndReplicateToVector128x2(address); - /// - /// A64: LD2R { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: LD2R { Vn.4S, Vn+1.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndReplicateToVector128x2(int* address) => LoadAndReplicateToVector128x2(address); - /// - /// A64: LD2R { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: LD2R { Vn.4S, Vn+1.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndReplicateToVector128x2(uint* address) => LoadAndReplicateToVector128x2(address); - /// - /// A64: LD2R { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: LD2R { Vn.2D, Vn+1.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndReplicateToVector128x2(long* address) => LoadAndReplicateToVector128x2(address); - /// - /// A64: LD2R { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: LD2R { Vn.2D, Vn+1.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndReplicateToVector128x2(ulong* address) => LoadAndReplicateToVector128x2(address); - /// - /// A64: LD2R { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: LD2R { Vn.4S, Vn+1.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndReplicateToVector128x2(float* address) => LoadAndReplicateToVector128x2(address); - /// - /// A64: LD2R { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: LD2R { Vn.2D, Vn+1.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadAndReplicateToVector128x2(double* address) => LoadAndReplicateToVector128x2(address); - /// - /// A64: LD3R { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] - /// + /// A64: LD3R { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndReplicateToVector128x3(byte* address) => LoadAndReplicateToVector128x3(address); - /// - /// A64: LD3R { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] - /// + /// A64: LD3R { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndReplicateToVector128x3(sbyte* address) => LoadAndReplicateToVector128x3(address); - /// - /// A64: LD3R { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] - /// + /// A64: LD3R { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndReplicateToVector128x3(short* address) => LoadAndReplicateToVector128x3(address); - /// - /// A64: LD3R { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] - /// + /// A64: LD3R { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndReplicateToVector128x3(ushort* address) => LoadAndReplicateToVector128x3(address); - /// - /// A64: LD3R { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: LD3R { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndReplicateToVector128x3(int* address) => LoadAndReplicateToVector128x3(address); - /// - /// A64: LD3R { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: LD3R { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndReplicateToVector128x3(uint* address) => LoadAndReplicateToVector128x3(address); - /// - /// A64: LD3R { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: LD3R { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndReplicateToVector128x3(long* address) => LoadAndReplicateToVector128x3(address); - /// - /// A64: LD3R { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: LD3R { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndReplicateToVector128x3(ulong* address) => LoadAndReplicateToVector128x3(address); - /// - /// A64: LD3R { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: LD3R { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndReplicateToVector128x3(float* address) => LoadAndReplicateToVector128x3(address); - /// - /// A64: LD3R { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: LD3R { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadAndReplicateToVector128x3(double* address) => LoadAndReplicateToVector128x3(address); - /// - /// A64: LD4R { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] - /// + /// A64: LD4R { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndReplicateToVector128x4(byte* address) => LoadAndReplicateToVector128x4(address); - /// - /// A64: LD4R { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] - /// + /// A64: LD4R { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndReplicateToVector128x4(sbyte* address) => LoadAndReplicateToVector128x4(address); - /// - /// A64: LD4R { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] - /// + /// A64: LD4R { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndReplicateToVector128x4(short* address) => LoadAndReplicateToVector128x4(address); - /// - /// A64: LD4R { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] - /// + /// A64: LD4R { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndReplicateToVector128x4(ushort* address) => LoadAndReplicateToVector128x4(address); - /// - /// A64: LD4R { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: LD4R { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndReplicateToVector128x4(int* address) => LoadAndReplicateToVector128x4(address); - /// - /// A64: LD4R { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: LD4R { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndReplicateToVector128x4(uint* address) => LoadAndReplicateToVector128x4(address); - /// - /// A64: LD4R { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: LD4R { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndReplicateToVector128x4(long* address) => LoadAndReplicateToVector128x4(address); - /// - /// A64: LD4R { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: LD4R { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndReplicateToVector128x4(ulong* address) => LoadAndReplicateToVector128x4(address); - /// - /// A64: LD4R { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: LD4R { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndReplicateToVector128x4(float* address) => LoadAndReplicateToVector128x4(address); - /// - /// A64: LD4R { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: LD4R { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadAndReplicateToVector128x4(double* address) => LoadAndReplicateToVector128x4(address); - /// - /// A64: LDP Dt1, Dt2, [Xn] - /// + /// A64: LDP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64(byte* address) => LoadPairVector64(address); - /// - /// A64: LDP Dt1, Dt2, [Xn] - /// + /// A64: LDP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64(double* address) => LoadPairVector64(address); - /// - /// A64: LDP Dt1, Dt2, [Xn] - /// + /// A64: LDP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64(short* address) => LoadPairVector64(address); - /// - /// A64: LDP Dt1, Dt2, [Xn] - /// + /// A64: LDP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64(int* address) => LoadPairVector64(address); - /// - /// A64: LDP Dt1, Dt2, [Xn] - /// + /// A64: LDP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64(long* address) => LoadPairVector64(address); - /// - /// A64: LDP Dt1, Dt2, [Xn] - /// + /// A64: LDP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64(sbyte* address) => LoadPairVector64(address); - /// - /// A64: LDP Dt1, Dt2, [Xn] - /// + /// A64: LDP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64(float* address) => LoadPairVector64(address); - /// - /// A64: LDP Dt1, Dt2, [Xn] - /// + /// A64: LDP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64(ushort* address) => LoadPairVector64(address); - /// - /// A64: LDP Dt1, Dt2, [Xn] - /// + /// A64: LDP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64(uint* address) => LoadPairVector64(address); - /// - /// A64: LDP Dt1, Dt2, [Xn] - /// + /// A64: LDP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64(ulong* address) => LoadPairVector64(address); - /// - /// A64: LDP St1, St2, [Xn] - /// + /// A64: LDP St1, St2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairScalarVector64(int* address) => LoadPairScalarVector64(address); - /// - /// A64: LDP St1, St2, [Xn] - /// + /// A64: LDP St1, St2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairScalarVector64(float* address) => LoadPairScalarVector64(address); - /// - /// A64: LDP St1, St2, [Xn] - /// + /// A64: LDP St1, St2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairScalarVector64(uint* address) => LoadPairScalarVector64(address); - /// - /// A64: LDP Qt1, Qt2, [Xn] - /// + /// A64: LDP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128(byte* address) => LoadPairVector128(address); - /// - /// A64: LDP Qt1, Qt2, [Xn] - /// + /// A64: LDP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128(double* address) => LoadPairVector128(address); - /// - /// A64: LDP Qt1, Qt2, [Xn] - /// + /// A64: LDP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128(short* address) => LoadPairVector128(address); - /// - /// A64: LDP Qt1, Qt2, [Xn] - /// + /// A64: LDP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128(int* address) => LoadPairVector128(address); - /// - /// A64: LDP Qt1, Qt2, [Xn] - /// + /// A64: LDP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128(long* address) => LoadPairVector128(address); - /// - /// A64: LDP Qt1, Qt2, [Xn] - /// + /// A64: LDP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128(sbyte* address) => LoadPairVector128(address); - /// - /// A64: LDP Qt1, Qt2, [Xn] - /// + /// A64: LDP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128(float* address) => LoadPairVector128(address); - /// - /// A64: LDP Qt1, Qt2, [Xn] - /// + /// A64: LDP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128(ushort* address) => LoadPairVector128(address); - /// - /// A64: LDP Qt1, Qt2, [Xn] - /// + /// A64: LDP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128(uint* address) => LoadPairVector128(address); - /// - /// A64: LDP Qt1, Qt2, [Xn] - /// + /// A64: LDP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128(ulong* address) => LoadPairVector128(address); - /// - /// A64: LDNP Dt1, Dt2, [Xn] - /// + /// A64: LDNP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64NonTemporal(byte* address) => LoadPairVector64NonTemporal(address); - /// - /// A64: LDNP Dt1, Dt2, [Xn] - /// + /// A64: LDNP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64NonTemporal(double* address) => LoadPairVector64NonTemporal(address); - /// - /// A64: LDNP Dt1, Dt2, [Xn] - /// + /// A64: LDNP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64NonTemporal(short* address) => LoadPairVector64NonTemporal(address); - /// - /// A64: LDNP Dt1, Dt2, [Xn] - /// + /// A64: LDNP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64NonTemporal(int* address) => LoadPairVector64NonTemporal(address); - /// - /// A64: LDNP Dt1, Dt2, [Xn] - /// + /// A64: LDNP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64NonTemporal(long* address) => LoadPairVector64NonTemporal(address); - /// - /// A64: LDNP Dt1, Dt2, [Xn] - /// + /// A64: LDNP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64NonTemporal(sbyte* address) => LoadPairVector64NonTemporal(address); - /// - /// A64: LDNP Dt1, Dt2, [Xn] - /// + /// A64: LDNP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64NonTemporal(float* address) => LoadPairVector64NonTemporal(address); - /// - /// A64: LDNP Dt1, Dt2, [Xn] - /// + /// A64: LDNP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64NonTemporal(ushort* address) => LoadPairVector64NonTemporal(address); - /// - /// A64: LDNP Dt1, Dt2, [Xn] - /// + /// A64: LDNP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64NonTemporal(uint* address) => LoadPairVector64NonTemporal(address); - /// - /// A64: LDNP Dt1, Dt2, [Xn] - /// + /// A64: LDNP Dt1, Dt2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairVector64NonTemporal(ulong* address) => LoadPairVector64NonTemporal(address); - /// - /// A64: LDNP St1, St2, [Xn] - /// + /// A64: LDNP St1, St2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairScalarVector64NonTemporal(int* address) => LoadPairScalarVector64NonTemporal(address); - /// - /// A64: LDNP St1, St2, [Xn] - /// + /// A64: LDNP St1, St2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairScalarVector64NonTemporal(float* address) => LoadPairScalarVector64NonTemporal(address); - /// - /// A64: LDNP St1, St2, [Xn] - /// + /// A64: LDNP St1, St2, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadPairScalarVector64NonTemporal(uint* address) => LoadPairScalarVector64NonTemporal(address); - /// - /// A64: LDNP Qt1, Qt2, [Xn] - /// + /// A64: LDNP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128NonTemporal(byte* address) => LoadPairVector128NonTemporal(address); - /// - /// A64: LDNP Qt1, Qt2, [Xn] - /// + /// A64: LDNP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128NonTemporal(double* address) => LoadPairVector128NonTemporal(address); - /// - /// A64: LDNP Qt1, Qt2, [Xn] - /// + /// A64: LDNP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128NonTemporal(short* address) => LoadPairVector128NonTemporal(address); - /// - /// A64: LDNP Qt1, Qt2, [Xn] - /// + /// A64: LDNP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128NonTemporal(int* address) => LoadPairVector128NonTemporal(address); - /// - /// A64: LDNP Qt1, Qt2, [Xn] - /// + /// A64: LDNP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128NonTemporal(long* address) => LoadPairVector128NonTemporal(address); - /// - /// A64: LDNP Qt1, Qt2, [Xn] - /// + /// A64: LDNP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128NonTemporal(sbyte* address) => LoadPairVector128NonTemporal(address); - /// - /// A64: LDNP Qt1, Qt2, [Xn] - /// + /// A64: LDNP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128NonTemporal(float* address) => LoadPairVector128NonTemporal(address); - /// - /// A64: LDNP Qt1, Qt2, [Xn] - /// + /// A64: LDNP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128NonTemporal(ushort* address) => LoadPairVector128NonTemporal(address); - /// - /// A64: LDNP Qt1, Qt2, [Xn] - /// + /// A64: LDNP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128NonTemporal(uint* address) => LoadPairVector128NonTemporal(address); - /// - /// A64: LDNP Qt1, Qt2, [Xn] - /// + /// A64: LDNP Qt1, Qt2, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128NonTemporal(ulong* address) => LoadPairVector128NonTemporal(address); - /// - /// A64: LD2 { Vn.16B, Vn+1.16B }, [Xn] - /// + /// A64: LD2 { Vn.16B, Vn+1.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128AndUnzip(byte* address) => Load2xVector128AndUnzip(address); - /// - /// A64: LD2 { Vn.16B, Vn+1.16B }, [Xn] - /// + /// A64: LD2 { Vn.16B, Vn+1.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128AndUnzip(sbyte* address) => Load2xVector128AndUnzip(address); - /// - /// A64: LD2 { Vn.8H, Vn+1.8H }, [Xn] - /// + /// A64: LD2 { Vn.8H, Vn+1.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128AndUnzip(short* address) => Load2xVector128AndUnzip(address); - /// - /// A64: LD2 { Vn.8H, Vn+1.8H }, [Xn] - /// + /// A64: LD2 { Vn.8H, Vn+1.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128AndUnzip(ushort* address) => Load2xVector128AndUnzip(address); - /// - /// A64: LD2 { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: LD2 { Vn.4S, Vn+1.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128AndUnzip(int* address) => Load2xVector128AndUnzip(address); - /// - /// A64: LD2 { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: LD2 { Vn.4S, Vn+1.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128AndUnzip(uint* address) => Load2xVector128AndUnzip(address); - /// - /// A64: LD2 { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: LD2 { Vn.2D, Vn+1.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128AndUnzip(long* address) => Load2xVector128AndUnzip(address); - /// - /// A64: LD2 { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: LD2 { Vn.2D, Vn+1.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128AndUnzip(ulong* address) => Load2xVector128AndUnzip(address); - /// - /// A64: LD2 { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: LD2 { Vn.4S, Vn+1.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128AndUnzip(float* address) => Load2xVector128AndUnzip(address); - /// - /// A64: LD2 { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: LD2 { Vn.2D, Vn+1.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128AndUnzip(double* address) => Load2xVector128AndUnzip(address); - /// - /// A64: LD3 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] - /// + /// A64: LD3 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128AndUnzip(byte* address) => Load3xVector128AndUnzip(address); - /// - /// A64: LD3 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] - /// + /// A64: LD3 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128AndUnzip(sbyte* address) => Load3xVector128AndUnzip(address); - /// - /// A64: LD3 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] - /// + /// A64: LD3 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128AndUnzip(short* address) => Load3xVector128AndUnzip(address); - /// - /// A64: LD3 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] - /// + /// A64: LD3 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128AndUnzip(ushort* address) => Load3xVector128AndUnzip(address); - /// - /// A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128AndUnzip(int* address) => Load3xVector128AndUnzip(address); - /// - /// A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128AndUnzip(uint* address) => Load3xVector128AndUnzip(address); - /// - /// A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128AndUnzip(long* address) => Load3xVector128AndUnzip(address); - /// - /// A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128AndUnzip(ulong* address) => Load3xVector128AndUnzip(address); - /// - /// A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: LD3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128AndUnzip(float* address) => Load3xVector128AndUnzip(address); - /// - /// A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: LD3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128AndUnzip(double* address) => Load3xVector128AndUnzip(address); - /// - /// A64: LD4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] - /// + /// A64: LD4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128AndUnzip(byte* address) => Load4xVector128AndUnzip(address); - /// - /// A64: LD4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] - /// + /// A64: LD4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128AndUnzip(sbyte* address) => Load4xVector128AndUnzip(address); - /// - /// A64: LD4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] - /// + /// A64: LD4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128AndUnzip(short* address) => Load4xVector128AndUnzip(address); - /// - /// A64: LD4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] - /// + /// A64: LD4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128AndUnzip(ushort* address) => Load4xVector128AndUnzip(address); - /// - /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128AndUnzip(int* address) => Load4xVector128AndUnzip(address); - /// - /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128AndUnzip(uint* address) => Load4xVector128AndUnzip(address); - /// - /// A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128AndUnzip(long* address) => Load4xVector128AndUnzip(address); - /// - /// A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128AndUnzip(ulong* address) => Load4xVector128AndUnzip(address); - /// - /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128AndUnzip(float* address) => Load4xVector128AndUnzip(address); - /// - /// A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: LD4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128AndUnzip(double* address) => Load4xVector128AndUnzip(address); - /// - /// A64: LD1 { Vn.16B, Vn+1.16B }, [Xn] - /// + /// A64: LD1 { Vn.16B, Vn+1.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128(byte* address) => Load2xVector128(address); - /// - /// A64: LD1 { Vn.16B, Vn+1.16B }, [Xn] - /// + /// A64: LD1 { Vn.16B, Vn+1.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128(sbyte* address) => Load2xVector128(address); - /// - /// A64: LD1 { Vn.8H, Vn+1.8H }, [Xn] - /// + /// A64: LD1 { Vn.8H, Vn+1.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128(short* address) => Load2xVector128(address); - /// - /// A64: LD1 { Vn.8H, Vn+1.8H }, [Xn] - /// + /// A64: LD1 { Vn.8H, Vn+1.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128(ushort* address) => Load2xVector128(address); - /// - /// A64: LD1 { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: LD1 { Vn.4S, Vn+1.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128(int* address) => Load2xVector128(address); - /// - /// A64: LD1 { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: LD1 { Vn.4S, Vn+1.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128(uint* address) => Load2xVector128(address); - /// - /// A64: LD1 { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: LD1 { Vn.2D, Vn+1.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128(long* address) => Load2xVector128(address); - /// - /// A64: LD1 { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: LD1 { Vn.2D, Vn+1.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128(ulong* address) => Load2xVector128(address); - /// - /// A64: LD1 { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: LD1 { Vn.4S, Vn+1.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128(float* address) => Load2xVector128(address); - /// - /// A64: LD1 { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: LD1 { Vn.2D, Vn+1.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2) Load2xVector128(double* address) => Load2xVector128(address); - /// - /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] - /// + /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128(byte* address) => Load3xVector128(address); - /// - /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] - /// + /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128(sbyte* address) => Load3xVector128(address); - /// - /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] - /// + /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128(short* address) => Load3xVector128(address); - /// - /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] - /// + /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128(ushort* address) => Load3xVector128(address); - /// - /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128(int* address) => Load3xVector128(address); - /// - /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128(uint* address) => Load3xVector128(address); - /// - /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128(long* address) => Load3xVector128(address); - /// - /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128(ulong* address) => Load3xVector128(address); - /// - /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128(float* address) => Load3xVector128(address); - /// - /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) Load3xVector128(double* address) => Load3xVector128(address); - /// - /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] - /// + /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128(byte* address) => Load4xVector128(address); - /// - /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] - /// + /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128(sbyte* address) => Load4xVector128(address); - /// - /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] - /// + /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128(short* address) => Load4xVector128(address); - /// - /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] - /// + /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128(ushort* address) => Load4xVector128(address); - /// - /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128(int* address) => Load4xVector128(address); - /// - /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128(uint* address) => Load4xVector128(address); - /// - /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128(long* address) => Load4xVector128(address); - /// - /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D}, [Xn] - /// + /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D}, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128(ulong* address) => Load4xVector128(address); - /// - /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128(float* address) => Load4xVector128(address); - /// - /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) Load4xVector128(double* address) => Load4xVector128(address); /// - /// float64x2_t vmaxq_f64 (float64x2_t a, float64x2_t b) - /// A64: FMAX Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vmaxq_f64 (float64x2_t a, float64x2_t b) + /// A64: FMAX Vd.2D, Vn.2D, Vm.2D /// public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// - /// uint8_t vmaxv_u8 (uint8x8_t a) - /// A64: UMAXV Bd, Vn.8B + /// uint8_t vmaxv_u8 (uint8x8_t a) + /// A64: UMAXV Bd, Vn.8B /// public static Vector64 MaxAcross(Vector64 value) => MaxAcross(value); /// - /// int16_t vmaxv_s16 (int16x4_t a) - /// A64: SMAXV Hd, Vn.4H + /// int16_t vmaxv_s16 (int16x4_t a) + /// A64: SMAXV Hd, Vn.4H /// public static Vector64 MaxAcross(Vector64 value) => MaxAcross(value); /// - /// int8_t vmaxv_s8 (int8x8_t a) - /// A64: SMAXV Bd, Vn.8B + /// int8_t vmaxv_s8 (int8x8_t a) + /// A64: SMAXV Bd, Vn.8B /// public static Vector64 MaxAcross(Vector64 value) => MaxAcross(value); /// - /// uint16_t vmaxv_u16 (uint16x4_t a) - /// A64: UMAXV Hd, Vn.4H + /// uint16_t vmaxv_u16 (uint16x4_t a) + /// A64: UMAXV Hd, Vn.4H /// public static Vector64 MaxAcross(Vector64 value) => MaxAcross(value); /// - /// uint8_t vmaxvq_u8 (uint8x16_t a) - /// A64: UMAXV Bd, Vn.16B + /// uint8_t vmaxvq_u8 (uint8x16_t a) + /// A64: UMAXV Bd, Vn.16B /// public static Vector64 MaxAcross(Vector128 value) => MaxAcross(value); /// - /// int16_t vmaxvq_s16 (int16x8_t a) - /// A64: SMAXV Hd, Vn.8H + /// int16_t vmaxvq_s16 (int16x8_t a) + /// A64: SMAXV Hd, Vn.8H /// public static Vector64 MaxAcross(Vector128 value) => MaxAcross(value); /// - /// int32_t vmaxvq_s32 (int32x4_t a) - /// A64: SMAXV Sd, Vn.4S + /// int32_t vmaxvq_s32 (int32x4_t a) + /// A64: SMAXV Sd, Vn.4S /// public static Vector64 MaxAcross(Vector128 value) => MaxAcross(value); /// - /// int8_t vmaxvq_s8 (int8x16_t a) - /// A64: SMAXV Bd, Vn.16B + /// int8_t vmaxvq_s8 (int8x16_t a) + /// A64: SMAXV Bd, Vn.16B /// public static Vector64 MaxAcross(Vector128 value) => MaxAcross(value); /// - /// float32_t vmaxvq_f32 (float32x4_t a) - /// A64: FMAXV Sd, Vn.4S + /// float32_t vmaxvq_f32 (float32x4_t a) + /// A64: FMAXV Sd, Vn.4S /// public static Vector64 MaxAcross(Vector128 value) => MaxAcross(value); /// - /// uint16_t vmaxvq_u16 (uint16x8_t a) - /// A64: UMAXV Hd, Vn.8H + /// uint16_t vmaxvq_u16 (uint16x8_t a) + /// A64: UMAXV Hd, Vn.8H /// public static Vector64 MaxAcross(Vector128 value) => MaxAcross(value); /// - /// uint32_t vmaxvq_u32 (uint32x4_t a) - /// A64: UMAXV Sd, Vn.4S + /// uint32_t vmaxvq_u32 (uint32x4_t a) + /// A64: UMAXV Sd, Vn.4S /// public static Vector64 MaxAcross(Vector128 value) => MaxAcross(value); /// - /// float64x2_t vmaxnmq_f64 (float64x2_t a, float64x2_t b) - /// A64: FMAXNM Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vmaxnmq_f64 (float64x2_t a, float64x2_t b) + /// A64: FMAXNM Vd.2D, Vn.2D, Vm.2D /// public static Vector128 MaxNumber(Vector128 left, Vector128 right) => MaxNumber(left, right); /// - /// float32_t vmaxnmvq_f32 (float32x4_t a) - /// A64: FMAXNMV Sd, Vn.4S + /// float32_t vmaxnmvq_f32 (float32x4_t a) + /// A64: FMAXNMV Sd, Vn.4S /// public static Vector64 MaxNumberAcross(Vector128 value) => MaxNumberAcross(value); /// - /// float32x2_t vpmaxnm_f32 (float32x2_t a, float32x2_t b) - /// A64: FMAXNMP Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vpmaxnm_f32 (float32x2_t a, float32x2_t b) + /// A64: FMAXNMP Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MaxNumberPairwise(Vector64 left, Vector64 right) => MaxNumberPairwise(left, right); /// - /// float64x2_t vpmaxnmq_f64 (float64x2_t a, float64x2_t b) - /// A64: FMAXNMP Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vpmaxnmq_f64 (float64x2_t a, float64x2_t b) + /// A64: FMAXNMP Vd.2D, Vn.2D, Vm.2D /// public static Vector128 MaxNumberPairwise(Vector128 left, Vector128 right) => MaxNumberPairwise(left, right); /// - /// float32x4_t vpmaxnmq_f32 (float32x4_t a, float32x4_t b) - /// A64: FMAXNMP Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vpmaxnmq_f32 (float32x4_t a, float32x4_t b) + /// A64: FMAXNMP Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MaxNumberPairwise(Vector128 left, Vector128 right) => MaxNumberPairwise(left, right); /// - /// float32_t vpmaxnms_f32 (float32x2_t a) - /// A64: FMAXNMP Sd, Vn.2S + /// float32_t vpmaxnms_f32 (float32x2_t a) + /// A64: FMAXNMP Sd, Vn.2S /// public static Vector64 MaxNumberPairwiseScalar(Vector64 value) => MaxNumberPairwiseScalar(value); /// - /// float64_t vpmaxnmqd_f64 (float64x2_t a) - /// A64: FMAXNMP Dd, Vn.2D + /// float64_t vpmaxnmqd_f64 (float64x2_t a) + /// A64: FMAXNMP Dd, Vn.2D /// public static Vector64 MaxNumberPairwiseScalar(Vector128 value) => MaxNumberPairwiseScalar(value); /// - /// uint8x16_t vpmaxq_u8 (uint8x16_t a, uint8x16_t b) - /// A64: UMAXP Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vpmaxq_u8 (uint8x16_t a, uint8x16_t b) + /// A64: UMAXP Vd.16B, Vn.16B, Vm.16B /// public static Vector128 MaxPairwise(Vector128 left, Vector128 right) => MaxPairwise(left, right); /// - /// float64x2_t vpmaxq_f64 (float64x2_t a, float64x2_t b) - /// A64: FMAXP Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vpmaxq_f64 (float64x2_t a, float64x2_t b) + /// A64: FMAXP Vd.2D, Vn.2D, Vm.2D /// public static Vector128 MaxPairwise(Vector128 left, Vector128 right) => MaxPairwise(left, right); /// - /// int16x8_t vpmaxq_s16 (int16x8_t a, int16x8_t b) - /// A64: SMAXP Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vpmaxq_s16 (int16x8_t a, int16x8_t b) + /// A64: SMAXP Vd.8H, Vn.8H, Vm.8H /// public static Vector128 MaxPairwise(Vector128 left, Vector128 right) => MaxPairwise(left, right); /// - /// int32x4_t vpmaxq_s32 (int32x4_t a, int32x4_t b) - /// A64: SMAXP Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vpmaxq_s32 (int32x4_t a, int32x4_t b) + /// A64: SMAXP Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MaxPairwise(Vector128 left, Vector128 right) => MaxPairwise(left, right); /// - /// int8x16_t vpmaxq_s8 (int8x16_t a, int8x16_t b) - /// A64: SMAXP Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vpmaxq_s8 (int8x16_t a, int8x16_t b) + /// A64: SMAXP Vd.16B, Vn.16B, Vm.16B /// public static Vector128 MaxPairwise(Vector128 left, Vector128 right) => MaxPairwise(left, right); /// - /// float32x4_t vpmaxq_f32 (float32x4_t a, float32x4_t b) - /// A64: FMAXP Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vpmaxq_f32 (float32x4_t a, float32x4_t b) + /// A64: FMAXP Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MaxPairwise(Vector128 left, Vector128 right) => MaxPairwise(left, right); /// - /// uint16x8_t vpmaxq_u16 (uint16x8_t a, uint16x8_t b) - /// A64: UMAXP Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vpmaxq_u16 (uint16x8_t a, uint16x8_t b) + /// A64: UMAXP Vd.8H, Vn.8H, Vm.8H /// public static Vector128 MaxPairwise(Vector128 left, Vector128 right) => MaxPairwise(left, right); /// - /// uint32x4_t vpmaxq_u32 (uint32x4_t a, uint32x4_t b) - /// A64: UMAXP Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vpmaxq_u32 (uint32x4_t a, uint32x4_t b) + /// A64: UMAXP Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MaxPairwise(Vector128 left, Vector128 right) => MaxPairwise(left, right); /// - /// float32_t vpmaxs_f32 (float32x2_t a) - /// A64: FMAXP Sd, Vn.2S + /// float32_t vpmaxs_f32 (float32x2_t a) + /// A64: FMAXP Sd, Vn.2S /// public static Vector64 MaxPairwiseScalar(Vector64 value) => MaxPairwiseScalar(value); /// - /// float64_t vpmaxqd_f64 (float64x2_t a) - /// A64: FMAXP Dd, Vn.2D + /// float64_t vpmaxqd_f64 (float64x2_t a) + /// A64: FMAXP Dd, Vn.2D /// public static Vector64 MaxPairwiseScalar(Vector128 value) => MaxPairwiseScalar(value); /// - /// float64x1_t vmax_f64 (float64x1_t a, float64x1_t b) - /// A64: FMAX Dd, Dn, Dm + /// float64x1_t vmax_f64 (float64x1_t a, float64x1_t b) + /// A64: FMAX Dd, Dn, Dm /// public static Vector64 MaxScalar(Vector64 left, Vector64 right) => MaxScalar(left, right); /// - /// float32_t vmaxs_f32 (float32_t a, float32_t b) - /// A64: FMAX Sd, Sn, Sm - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vmaxs_f32 (float32_t a, float32_t b) + /// A64: FMAX Sd, Sn, Sm + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 MaxScalar(Vector64 left, Vector64 right) => MaxScalar(left, right); /// - /// float64x2_t vminq_f64 (float64x2_t a, float64x2_t b) - /// A64: FMIN Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vminq_f64 (float64x2_t a, float64x2_t b) + /// A64: FMIN Vd.2D, Vn.2D, Vm.2D /// public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// - /// uint8_t vminv_u8 (uint8x8_t a) - /// A64: UMINV Bd, Vn.8B + /// uint8_t vminv_u8 (uint8x8_t a) + /// A64: UMINV Bd, Vn.8B /// public static Vector64 MinAcross(Vector64 value) => MinAcross(value); /// - /// int16_t vminv_s16 (int16x4_t a) - /// A64: SMINV Hd, Vn.4H + /// int16_t vminv_s16 (int16x4_t a) + /// A64: SMINV Hd, Vn.4H /// public static Vector64 MinAcross(Vector64 value) => MinAcross(value); /// - /// int8_t vminv_s8 (int8x8_t a) - /// A64: SMINV Bd, Vn.8B + /// int8_t vminv_s8 (int8x8_t a) + /// A64: SMINV Bd, Vn.8B /// public static Vector64 MinAcross(Vector64 value) => MinAcross(value); /// - /// uint16_t vminv_u16 (uint16x4_t a) - /// A64: UMINV Hd, Vn.4H + /// uint16_t vminv_u16 (uint16x4_t a) + /// A64: UMINV Hd, Vn.4H /// public static Vector64 MinAcross(Vector64 value) => MinAcross(value); /// - /// uint8_t vminvq_u8 (uint8x16_t a) - /// A64: UMINV Bd, Vn.16B + /// uint8_t vminvq_u8 (uint8x16_t a) + /// A64: UMINV Bd, Vn.16B /// public static Vector64 MinAcross(Vector128 value) => MinAcross(value); /// - /// int16_t vminvq_s16 (int16x8_t a) - /// A64: SMINV Hd, Vn.8H + /// int16_t vminvq_s16 (int16x8_t a) + /// A64: SMINV Hd, Vn.8H /// public static Vector64 MinAcross(Vector128 value) => MinAcross(value); /// - /// int32_t vaddvq_s32 (int32x4_t a) - /// A64: SMINV Sd, Vn.4S + /// int32_t vaddvq_s32 (int32x4_t a) + /// A64: SMINV Sd, Vn.4S /// public static Vector64 MinAcross(Vector128 value) => MinAcross(value); /// - /// int8_t vminvq_s8 (int8x16_t a) - /// A64: SMINV Bd, Vn.16B + /// int8_t vminvq_s8 (int8x16_t a) + /// A64: SMINV Bd, Vn.16B /// public static Vector64 MinAcross(Vector128 value) => MinAcross(value); /// - /// float32_t vminvq_f32 (float32x4_t a) - /// A64: FMINV Sd, Vn.4S + /// float32_t vminvq_f32 (float32x4_t a) + /// A64: FMINV Sd, Vn.4S /// public static Vector64 MinAcross(Vector128 value) => MinAcross(value); /// - /// uint16_t vminvq_u16 (uint16x8_t a) - /// A64: UMINV Hd, Vn.8H + /// uint16_t vminvq_u16 (uint16x8_t a) + /// A64: UMINV Hd, Vn.8H /// public static Vector64 MinAcross(Vector128 value) => MinAcross(value); /// - /// uint32_t vminvq_u32 (uint32x4_t a) - /// A64: UMINV Sd, Vn.4S + /// uint32_t vminvq_u32 (uint32x4_t a) + /// A64: UMINV Sd, Vn.4S /// public static Vector64 MinAcross(Vector128 value) => MinAcross(value); /// - /// float64x2_t vminnmq_f64 (float64x2_t a, float64x2_t b) - /// A64: FMINNM Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vminnmq_f64 (float64x2_t a, float64x2_t b) + /// A64: FMINNM Vd.2D, Vn.2D, Vm.2D /// public static Vector128 MinNumber(Vector128 left, Vector128 right) => MinNumber(left, right); /// - /// float32_t vminnmvq_f32 (float32x4_t a) - /// A64: FMINNMV Sd, Vn.4S + /// float32_t vminnmvq_f32 (float32x4_t a) + /// A64: FMINNMV Sd, Vn.4S /// public static Vector64 MinNumberAcross(Vector128 value) => MinNumberAcross(value); /// - /// float32x2_t vpminnm_f32 (float32x2_t a, float32x2_t b) - /// A64: FMINNMP Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vpminnm_f32 (float32x2_t a, float32x2_t b) + /// A64: FMINNMP Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MinNumberPairwise(Vector64 left, Vector64 right) => MinNumberPairwise(left, right); /// - /// float64x2_t vpminnmq_f64 (float64x2_t a, float64x2_t b) - /// A64: FMINNMP Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vpminnmq_f64 (float64x2_t a, float64x2_t b) + /// A64: FMINNMP Vd.2D, Vn.2D, Vm.2D /// public static Vector128 MinNumberPairwise(Vector128 left, Vector128 right) => MinNumberPairwise(left, right); /// - /// float32x4_t vpminnmq_f32 (float32x4_t a, float32x4_t b) - /// A64: FMINNMP Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vpminnmq_f32 (float32x4_t a, float32x4_t b) + /// A64: FMINNMP Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MinNumberPairwise(Vector128 left, Vector128 right) => MinNumberPairwise(left, right); /// - /// float32_t vpminnms_f32 (float32x2_t a) - /// A64: FMINNMP Sd, Vn.2S + /// float32_t vpminnms_f32 (float32x2_t a) + /// A64: FMINNMP Sd, Vn.2S /// public static Vector64 MinNumberPairwiseScalar(Vector64 value) => MinNumberPairwiseScalar(value); /// - /// float64_t vpminnmqd_f64 (float64x2_t a) - /// A64: FMINNMP Dd, Vn.2D + /// float64_t vpminnmqd_f64 (float64x2_t a) + /// A64: FMINNMP Dd, Vn.2D /// public static Vector64 MinNumberPairwiseScalar(Vector128 value) => MinNumberPairwiseScalar(value); /// - /// uint8x16_t vpminq_u8 (uint8x16_t a, uint8x16_t b) - /// A64: UMINP Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vpminq_u8 (uint8x16_t a, uint8x16_t b) + /// A64: UMINP Vd.16B, Vn.16B, Vm.16B /// public static Vector128 MinPairwise(Vector128 left, Vector128 right) => MinPairwise(left, right); /// - /// float64x2_t vpminq_f64 (float64x2_t a, float64x2_t b) - /// A64: FMINP Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vpminq_f64 (float64x2_t a, float64x2_t b) + /// A64: FMINP Vd.2D, Vn.2D, Vm.2D /// public static Vector128 MinPairwise(Vector128 left, Vector128 right) => MinPairwise(left, right); /// - /// int16x8_t vpminq_s16 (int16x8_t a, int16x8_t b) - /// A64: SMINP Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vpminq_s16 (int16x8_t a, int16x8_t b) + /// A64: SMINP Vd.8H, Vn.8H, Vm.8H /// public static Vector128 MinPairwise(Vector128 left, Vector128 right) => MinPairwise(left, right); /// - /// int32x4_t vpminq_s32 (int32x4_t a, int32x4_t b) - /// A64: SMINP Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vpminq_s32 (int32x4_t a, int32x4_t b) + /// A64: SMINP Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MinPairwise(Vector128 left, Vector128 right) => MinPairwise(left, right); /// - /// int8x16_t vpminq_s8 (int8x16_t a, int8x16_t b) - /// A64: SMINP Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vpminq_s8 (int8x16_t a, int8x16_t b) + /// A64: SMINP Vd.16B, Vn.16B, Vm.16B /// public static Vector128 MinPairwise(Vector128 left, Vector128 right) => MinPairwise(left, right); /// - /// float32x4_t vpminq_f32 (float32x4_t a, float32x4_t b) - /// A64: FMINP Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vpminq_f32 (float32x4_t a, float32x4_t b) + /// A64: FMINP Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MinPairwise(Vector128 left, Vector128 right) => MinPairwise(left, right); /// - /// uint16x8_t vpminq_u16 (uint16x8_t a, uint16x8_t b) - /// A64: UMINP Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vpminq_u16 (uint16x8_t a, uint16x8_t b) + /// A64: UMINP Vd.8H, Vn.8H, Vm.8H /// public static Vector128 MinPairwise(Vector128 left, Vector128 right) => MinPairwise(left, right); /// - /// uint32x4_t vpminq_u32 (uint32x4_t a, uint32x4_t b) - /// A64: UMINP Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vpminq_u32 (uint32x4_t a, uint32x4_t b) + /// A64: UMINP Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MinPairwise(Vector128 left, Vector128 right) => MinPairwise(left, right); /// - /// float32_t vpmins_f32 (float32x2_t a) - /// A64: FMINP Sd, Vn.2S + /// float32_t vpmins_f32 (float32x2_t a) + /// A64: FMINP Sd, Vn.2S /// public static Vector64 MinPairwiseScalar(Vector64 value) => MinPairwiseScalar(value); /// - /// float64_t vpminqd_f64 (float64x2_t a) - /// A64: FMINP Dd, Vn.2D + /// float64_t vpminqd_f64 (float64x2_t a) + /// A64: FMINP Dd, Vn.2D /// public static Vector64 MinPairwiseScalar(Vector128 value) => MinPairwiseScalar(value); /// - /// float64x1_t vmin_f64 (float64x1_t a, float64x1_t b) - /// A64: FMIN Dd, Dn, Dm + /// float64x1_t vmin_f64 (float64x1_t a, float64x1_t b) + /// A64: FMIN Dd, Dn, Dm /// public static Vector64 MinScalar(Vector64 left, Vector64 right) => MinScalar(left, right); /// - /// float32_t vmins_f32 (float32_t a, float32_t b) - /// A64: FMIN Sd, Sn, Sm - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vmins_f32 (float32_t a, float32_t b) + /// A64: FMIN Sd, Sn, Sm + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 MinScalar(Vector64 left, Vector64 right) => MinScalar(left, right); /// - /// float64x2_t vmulq_f64 (float64x2_t a, float64x2_t b) - /// A64: FMUL Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vmulq_f64 (float64x2_t a, float64x2_t b) + /// A64: FMUL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); /// - /// float64x2_t vmulq_n_f64 (float64x2_t a, float64_t b) - /// A64: FMUL Vd.2D, Vn.2D, Vm.D[0] + /// float64x2_t vmulq_n_f64 (float64x2_t a, float64_t b) + /// A64: FMUL Vd.2D, Vn.2D, Vm.D[0] /// public static Vector128 MultiplyByScalar(Vector128 left, Vector64 right) => MultiplyByScalar(left, right); /// - /// float64x2_t vmulq_laneq_f64 (float64x2_t a, float64x2_t v, const int lane) - /// A64: FMUL Vd.2D, Vn.2D, Vm.D[lane] + /// float64x2_t vmulq_laneq_f64 (float64x2_t a, float64x2_t v, const int lane) + /// A64: FMUL Vd.2D, Vn.2D, Vm.D[lane] /// public static Vector128 MultiplyBySelectedScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); /// - /// int16_t vqdmulhh_s16 (int16_t a, int16_t b) - /// A64: SQDMULH Hd, Hn, Hm + /// int16_t vqdmulhh_s16 (int16_t a, int16_t b) + /// A64: SQDMULH Hd, Hn, Hm /// public static Vector64 MultiplyDoublingSaturateHighScalar(Vector64 left, Vector64 right) => MultiplyDoublingSaturateHighScalar(left, right); /// - /// int32_t vqdmulhs_s32 (int32_t a, int32_t b) - /// A64: SQDMULH Sd, Sn, Sm + /// int32_t vqdmulhs_s32 (int32_t a, int32_t b) + /// A64: SQDMULH Sd, Sn, Sm /// public static Vector64 MultiplyDoublingSaturateHighScalar(Vector64 left, Vector64 right) => MultiplyDoublingSaturateHighScalar(left, right); /// - /// int16_t vqdmulhh_lane_s16 (int16_t a, int16x4_t v, const int lane) - /// A64: SQDMULH Hd, Hn, Vm.H[lane] + /// int16_t vqdmulhh_lane_s16 (int16_t a, int16x4_t v, const int lane) + /// A64: SQDMULH Hd, Hn, Vm.H[lane] /// public static Vector64 MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingScalarBySelectedScalarSaturateHigh(left, right, rightIndex); /// - /// int16_t vqdmulhh_laneq_s16 (int16_t a, int16x8_t v, const int lane) - /// A64: SQDMULH Hd, Hn, Vm.H[lane] + /// int16_t vqdmulhh_laneq_s16 (int16_t a, int16x8_t v, const int lane) + /// A64: SQDMULH Hd, Hn, Vm.H[lane] /// public static Vector64 MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyDoublingScalarBySelectedScalarSaturateHigh(left, right, rightIndex); /// - /// int32_t vqdmulhs_lane_s32 (int32_t a, int32x2_t v, const int lane) - /// A64: SQDMULH Sd, Sn, Vm.S[lane] + /// int32_t vqdmulhs_lane_s32 (int32_t a, int32x2_t v, const int lane) + /// A64: SQDMULH Sd, Sn, Vm.S[lane] /// public static Vector64 MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyDoublingScalarBySelectedScalarSaturateHigh(left, right, rightIndex); /// - /// int32_t vqdmulhs_laneq_s32 (int32_t a, int32x4_t v, const int lane) - /// A64: SQDMULH Sd, Sn, Vm.S[lane] + /// int32_t vqdmulhs_laneq_s32 (int32_t a, int32x4_t v, const int lane) + /// A64: SQDMULH Sd, Sn, Vm.S[lane] /// public static Vector64 MultiplyDoublingScalarBySelectedScalarSaturateHigh(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingScalarBySelectedScalarSaturateHigh(left, right, rightIndex); /// - /// int32_t vqdmlalh_s16 (int32_t a, int16_t b, int16_t c) - /// A64: SQDMLAL Sd, Hn, Hm + /// int32_t vqdmlalh_s16 (int32_t a, int16_t b, int16_t c) + /// A64: SQDMLAL Sd, Hn, Hm /// public static Vector64 MultiplyDoublingWideningAndAddSaturateScalar(Vector64 addend, Vector64 left, Vector64 right) => MultiplyDoublingWideningAndAddSaturateScalar(addend, left, right); /// - /// int64_t vqdmlals_s32 (int64_t a, int32_t b, int32_t c) - /// A64: SQDMLAL Dd, Sn, Sm + /// int64_t vqdmlals_s32 (int64_t a, int32_t b, int32_t c) + /// A64: SQDMLAL Dd, Sn, Sm /// public static Vector64 MultiplyDoublingWideningAndAddSaturateScalar(Vector64 addend, Vector64 left, Vector64 right) => MultiplyDoublingWideningAndAddSaturateScalar(addend, left, right); /// - /// int32_t vqdmlslh_s16 (int32_t a, int16_t b, int16_t c) - /// A64: SQDMLSL Sd, Hn, Hm + /// int32_t vqdmlslh_s16 (int32_t a, int16_t b, int16_t c) + /// A64: SQDMLSL Sd, Hn, Hm /// public static Vector64 MultiplyDoublingWideningAndSubtractSaturateScalar(Vector64 minuend, Vector64 left, Vector64 right) => MultiplyDoublingWideningAndSubtractSaturateScalar(minuend, left, right); /// - /// int64_t vqdmlsls_s32 (int64_t a, int32_t b, int32_t c) - /// A64: SQDMLSL Dd, Sn, Sm + /// int64_t vqdmlsls_s32 (int64_t a, int32_t b, int32_t c) + /// A64: SQDMLSL Dd, Sn, Sm /// public static Vector64 MultiplyDoublingWideningAndSubtractSaturateScalar(Vector64 minuend, Vector64 left, Vector64 right) => MultiplyDoublingWideningAndSubtractSaturateScalar(minuend, left, right); /// - /// int32_t vqdmullh_s16 (int16_t a, int16_t b) - /// A64: SQDMULL Sd, Hn, Hm + /// int32_t vqdmullh_s16 (int16_t a, int16_t b) + /// A64: SQDMULL Sd, Hn, Hm /// public static Vector64 MultiplyDoublingWideningSaturateScalar(Vector64 left, Vector64 right) => MultiplyDoublingWideningSaturateScalar(left, right); /// - /// int64_t vqdmulls_s32 (int32_t a, int32_t b) - /// A64: SQDMULL Dd, Sn, Sm + /// int64_t vqdmulls_s32 (int32_t a, int32_t b) + /// A64: SQDMULL Dd, Sn, Sm /// public static Vector64 MultiplyDoublingWideningSaturateScalar(Vector64 left, Vector64 right) => MultiplyDoublingWideningSaturateScalar(left, right); /// - /// int32_t vqdmullh_lane_s16 (int16_t a, int16x4_t v, const int lane) - /// A64: SQDMULL Sd, Hn, Vm.H[lane] + /// int32_t vqdmullh_lane_s16 (int16_t a, int16x4_t v, const int lane) + /// A64: SQDMULL Sd, Hn, Vm.H[lane] /// public static Vector64 MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningSaturateScalarBySelectedScalar(left, right, rightIndex); /// - /// int32_t vqdmullh_laneq_s16 (int16_t a, int16x8_t v, const int lane) - /// A64: SQDMULL Sd, Hn, Vm.H[lane] + /// int32_t vqdmullh_laneq_s16 (int16_t a, int16x8_t v, const int lane) + /// A64: SQDMULL Sd, Hn, Vm.H[lane] /// public static Vector64 MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyDoublingWideningSaturateScalarBySelectedScalar(left, right, rightIndex); /// - /// int64_t vqdmulls_lane_s32 (int32_t a, int32x2_t v, const int lane) - /// A64: SQDMULL Dd, Sn, Vm.S[lane] + /// int64_t vqdmulls_lane_s32 (int32_t a, int32x2_t v, const int lane) + /// A64: SQDMULL Dd, Sn, Vm.S[lane] /// public static Vector64 MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyDoublingWideningSaturateScalarBySelectedScalar(left, right, rightIndex); /// - /// int64_t vqdmulls_laneq_s32 (int32_t a, int32x4_t v, const int lane) - /// A64: SQDMULL Dd, Sn, Vm.S[lane] + /// int64_t vqdmulls_laneq_s32 (int32_t a, int32x4_t v, const int lane) + /// A64: SQDMULL Dd, Sn, Vm.S[lane] /// public static Vector64 MultiplyDoublingWideningSaturateScalarBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningSaturateScalarBySelectedScalar(left, right, rightIndex); /// - /// int32_t vqdmlalh_lane_s16 (int32_t a, int16_t b, int16x4_t v, const int lane) - /// A64: SQDMLAL Sd, Hn, Vm.H[lane] + /// int32_t vqdmlalh_lane_s16 (int32_t a, int16_t b, int16x4_t v, const int lane) + /// A64: SQDMLAL Sd, Hn, Vm.H[lane] /// public static Vector64 MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(addend, left, right, rightIndex); /// - /// int32_t vqdmlalh_laneq_s16 (int32_t a, int16_t b, int16x8_t v, const int lane) - /// A64: SQDMLAL Sd, Hn, Vm.H[lane] + /// int32_t vqdmlalh_laneq_s16 (int32_t a, int16_t b, int16x8_t v, const int lane) + /// A64: SQDMLAL Sd, Hn, Vm.H[lane] /// public static Vector64 MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(addend, left, right, rightIndex); /// - /// int64_t vqdmlals_lane_s32 (int64_t a, int32_t b, int32x2_t v, const int lane) - /// A64: SQDMLAL Dd, Sn, Vm.S[lane] + /// int64_t vqdmlals_lane_s32 (int64_t a, int32_t b, int32x2_t v, const int lane) + /// A64: SQDMLAL Dd, Sn, Vm.S[lane] /// public static Vector64 MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(addend, left, right, rightIndex); /// - /// int64_t vqdmlals_laneq_s32 (int64_t a, int32_t b, int32x4_t v, const int lane) - /// A64: SQDMLAL Dd, Sn, Vm.S[lane] + /// int64_t vqdmlals_laneq_s32 (int64_t a, int32_t b, int32x4_t v, const int lane) + /// A64: SQDMLAL Dd, Sn, Vm.S[lane] /// public static Vector64 MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningScalarBySelectedScalarAndAddSaturate(addend, left, right, rightIndex); /// - /// int32_t vqdmlslh_lane_s16 (int32_t a, int16_t b, int16x4_t v, const int lane) - /// A64: SQDMLSL Sd, Hn, Vm.H[lane] + /// int32_t vqdmlslh_lane_s16 (int32_t a, int16_t b, int16x4_t v, const int lane) + /// A64: SQDMLSL Sd, Hn, Vm.H[lane] /// public static Vector64 MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex); /// - /// int32_t vqdmlslh_laneq_s16 (int32_t a, int16_t b, int16x8_t v, const int lane) - /// A64: SQDMLSL Sd, Hn, Vm.H[lane] + /// int32_t vqdmlslh_laneq_s16 (int32_t a, int16_t b, int16x8_t v, const int lane) + /// A64: SQDMLSL Sd, Hn, Vm.H[lane] /// public static Vector64 MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex); /// - /// int64_t vqdmlsls_lane_s32 (int64_t a, int32_t b, int32x2_t v, const int lane) - /// A64: SQDMLSL Dd, Sn, Vm.S[lane] + /// int64_t vqdmlsls_lane_s32 (int64_t a, int32_t b, int32x2_t v, const int lane) + /// A64: SQDMLSL Dd, Sn, Vm.S[lane] /// public static Vector64 MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex); /// - /// int64_t vqdmlsls_laneq_s32 (int64_t a, int32_t b, int32x4_t v, const int lane) - /// A64: SQDMLSL Dd, Sn, Vm.S[lane] + /// int64_t vqdmlsls_laneq_s32 (int64_t a, int32_t b, int32x4_t v, const int lane) + /// A64: SQDMLSL Dd, Sn, Vm.S[lane] /// public static Vector64 MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningScalarBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex); /// - /// float32x2_t vmulx_f32 (float32x2_t a, float32x2_t b) - /// A64: FMULX Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vmulx_f32 (float32x2_t a, float32x2_t b) + /// A64: FMULX Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MultiplyExtended(Vector64 left, Vector64 right) => MultiplyExtended(left, right); /// - /// float64x2_t vmulxq_f64 (float64x2_t a, float64x2_t b) - /// A64: FMULX Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vmulxq_f64 (float64x2_t a, float64x2_t b) + /// A64: FMULX Vd.2D, Vn.2D, Vm.2D /// public static Vector128 MultiplyExtended(Vector128 left, Vector128 right) => MultiplyExtended(left, right); /// - /// float32x4_t vmulxq_f32 (float32x4_t a, float32x4_t b) - /// A64: FMULX Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vmulxq_f32 (float32x4_t a, float32x4_t b) + /// A64: FMULX Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MultiplyExtended(Vector128 left, Vector128 right) => MultiplyExtended(left, right); /// - /// float64x2_t vmulxq_lane_f64 (float64x2_t a, float64x1_t v, const int lane) - /// A64: FMULX Vd.2D, Vn.2D, Vm.D[0] + /// float64x2_t vmulxq_lane_f64 (float64x2_t a, float64x1_t v, const int lane) + /// A64: FMULX Vd.2D, Vn.2D, Vm.D[0] /// public static Vector128 MultiplyExtendedByScalar(Vector128 left, Vector64 right) => MultiplyExtendedByScalar(left, right); /// - /// float32x2_t vmulx_lane_f32 (float32x2_t a, float32x2_t v, const int lane) - /// A64: FMULX Vd.2S, Vn.2S, Vm.S[lane] + /// float32x2_t vmulx_lane_f32 (float32x2_t a, float32x2_t v, const int lane) + /// A64: FMULX Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyExtendedBySelectedScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyExtendedBySelectedScalar(left, right, rightIndex); /// - /// float32x2_t vmulx_laneq_f32 (float32x2_t a, float32x4_t v, const int lane) - /// A64: FMULX Vd.2S, Vn.2S, Vm.S[lane] + /// float32x2_t vmulx_laneq_f32 (float32x2_t a, float32x4_t v, const int lane) + /// A64: FMULX Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyExtendedBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyExtendedBySelectedScalar(left, right, rightIndex); /// - /// float64x2_t vmulxq_laneq_f64 (float64x2_t a, float64x2_t v, const int lane) - /// A64: FMULX Vd.2D, Vn.2D, Vm.D[lane] + /// float64x2_t vmulxq_laneq_f64 (float64x2_t a, float64x2_t v, const int lane) + /// A64: FMULX Vd.2D, Vn.2D, Vm.D[lane] /// public static Vector128 MultiplyExtendedBySelectedScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyExtendedBySelectedScalar(left, right, rightIndex); /// - /// float32x4_t vmulxq_lane_f32 (float32x4_t a, float32x2_t v, const int lane) - /// A64: FMULX Vd.4S, Vn.4S, Vm.S[lane] + /// float32x4_t vmulxq_lane_f32 (float32x4_t a, float32x2_t v, const int lane) + /// A64: FMULX Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyExtendedBySelectedScalar(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyExtendedBySelectedScalar(left, right, rightIndex); /// - /// float32x4_t vmulxq_laneq_f32 (float32x4_t a, float32x4_t v, const int lane) - /// A64: FMULX Vd.4S, Vn.4S, Vm.S[lane] + /// float32x4_t vmulxq_laneq_f32 (float32x4_t a, float32x4_t v, const int lane) + /// A64: FMULX Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyExtendedBySelectedScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyExtendedBySelectedScalar(left, right, rightIndex); /// - /// float64x1_t vmulx_f64 (float64x1_t a, float64x1_t b) - /// A64: FMULX Dd, Dn, Dm + /// float64x1_t vmulx_f64 (float64x1_t a, float64x1_t b) + /// A64: FMULX Dd, Dn, Dm /// public static Vector64 MultiplyExtendedScalar(Vector64 left, Vector64 right) => MultiplyExtendedScalar(left, right); /// - /// float32_t vmulxs_f32 (float32_t a, float32_t b) - /// A64: FMULX Sd, Sn, Sm + /// float32_t vmulxs_f32 (float32_t a, float32_t b) + /// A64: FMULX Sd, Sn, Sm /// public static Vector64 MultiplyExtendedScalar(Vector64 left, Vector64 right) => MultiplyExtendedScalar(left, right); /// - /// float64_t vmulxd_laneq_f64 (float64_t a, float64x2_t v, const int lane) - /// A64: FMULX Dd, Dn, Vm.D[lane] + /// float64_t vmulxd_laneq_f64 (float64_t a, float64x2_t v, const int lane) + /// A64: FMULX Dd, Dn, Vm.D[lane] /// public static Vector64 MultiplyExtendedScalarBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyExtendedScalarBySelectedScalar(left, right, rightIndex); /// - /// float32_t vmulxs_lane_f32 (float32_t a, float32x2_t v, const int lane) - /// A64: FMULX Sd, Sn, Vm.S[lane] + /// float32_t vmulxs_lane_f32 (float32_t a, float32x2_t v, const int lane) + /// A64: FMULX Sd, Sn, Vm.S[lane] /// public static Vector64 MultiplyExtendedScalarBySelectedScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyExtendedScalarBySelectedScalar(left, right, rightIndex); /// - /// float32_t vmulxs_laneq_f32 (float32_t a, float32x4_t v, const int lane) - /// A64: FMULX Sd, Sn, Vm.S[lane] + /// float32_t vmulxs_laneq_f32 (float32_t a, float32x4_t v, const int lane) + /// A64: FMULX Sd, Sn, Vm.S[lane] /// public static Vector64 MultiplyExtendedScalarBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyExtendedScalarBySelectedScalar(left, right, rightIndex); /// - /// int16_t vqrdmulhh_s16 (int16_t a, int16_t b) - /// A64: SQRDMULH Hd, Hn, Hm + /// int16_t vqrdmulhh_s16 (int16_t a, int16_t b) + /// A64: SQRDMULH Hd, Hn, Hm /// public static Vector64 MultiplyRoundedDoublingSaturateHighScalar(Vector64 left, Vector64 right) => MultiplyRoundedDoublingSaturateHighScalar(left, right); /// - /// int32_t vqrdmulhs_s32 (int32_t a, int32_t b) - /// A64: SQRDMULH Sd, Sn, Sm + /// int32_t vqrdmulhs_s32 (int32_t a, int32_t b) + /// A64: SQRDMULH Sd, Sn, Sm /// public static Vector64 MultiplyRoundedDoublingSaturateHighScalar(Vector64 left, Vector64 right) => MultiplyRoundedDoublingSaturateHighScalar(left, right); /// - /// int16_t vqrdmulhh_lane_s16 (int16_t a, int16x4_t v, const int lane) - /// A64: SQRDMULH Hd, Hn, Vm.H[lane] + /// int16_t vqrdmulhh_lane_s16 (int16_t a, int16x4_t v, const int lane) + /// A64: SQRDMULH Hd, Hn, Vm.H[lane] /// public static Vector64 MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(left, right, rightIndex); /// - /// int16_t vqrdmulhh_laneq_s16 (int16_t a, int16x8_t v, const int lane) - /// A64: SQRDMULH Hd, Hn, Vm.H[lane] + /// int16_t vqrdmulhh_laneq_s16 (int16_t a, int16x8_t v, const int lane) + /// A64: SQRDMULH Hd, Hn, Vm.H[lane] /// public static Vector64 MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(left, right, rightIndex); /// - /// int32_t vqrdmulhs_lane_s32 (int32_t a, int32x2_t v, const int lane) - /// A64: SQRDMULH Sd, Sn, Vm.S[lane] + /// int32_t vqrdmulhs_lane_s32 (int32_t a, int32x2_t v, const int lane) + /// A64: SQRDMULH Sd, Sn, Vm.S[lane] /// public static Vector64 MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(left, right, rightIndex); /// - /// int32_t vqrdmulhs_laneq_s32 (int32_t a, int32x4_t v, const int lane) - /// A64: SQRDMULH Sd, Sn, Vm.S[lane] + /// int32_t vqrdmulhs_laneq_s32 (int32_t a, int32x4_t v, const int lane) + /// A64: SQRDMULH Sd, Sn, Vm.S[lane] /// public static Vector64 MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarSaturateHigh(left, right, rightIndex); /// - /// float64_t vmuld_laneq_f64 (float64_t a, float64x2_t v, const int lane) - /// A64: FMUL Dd, Dn, Vm.D[lane] + /// float64_t vmuld_laneq_f64 (float64_t a, float64x2_t v, const int lane) + /// A64: FMUL Dd, Dn, Vm.D[lane] /// public static Vector64 MultiplyScalarBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyScalarBySelectedScalar(left, right, rightIndex); /// - /// float64x2_t vnegq_f64 (float64x2_t a) - /// A64: FNEG Vd.2D, Vn.2D + /// float64x2_t vnegq_f64 (float64x2_t a) + /// A64: FNEG Vd.2D, Vn.2D /// public static Vector128 Negate(Vector128 value) => Negate(value); /// - /// int64x2_t vnegq_s64 (int64x2_t a) - /// A64: NEG Vd.2D, Vn.2D + /// int64x2_t vnegq_s64 (int64x2_t a) + /// A64: NEG Vd.2D, Vn.2D /// public static Vector128 Negate(Vector128 value) => Negate(value); /// - /// int64x2_t vqnegq_s64 (int64x2_t a) - /// A64: SQNEG Vd.2D, Vn.2D + /// int64x2_t vqnegq_s64 (int64x2_t a) + /// A64: SQNEG Vd.2D, Vn.2D /// public static Vector128 NegateSaturate(Vector128 value) => NegateSaturate(value); /// - /// int16_t vqnegh_s16 (int16_t a) - /// A64: SQNEG Hd, Hn + /// int16_t vqnegh_s16 (int16_t a) + /// A64: SQNEG Hd, Hn /// public static Vector64 NegateSaturateScalar(Vector64 value) => NegateSaturateScalar(value); /// - /// int32_t vqnegs_s32 (int32_t a) - /// A64: SQNEG Sd, Sn + /// int32_t vqnegs_s32 (int32_t a) + /// A64: SQNEG Sd, Sn /// public static Vector64 NegateSaturateScalar(Vector64 value) => NegateSaturateScalar(value); /// - /// int64_t vqnegd_s64 (int64_t a) - /// A64: SQNEG Dd, Dn + /// int64_t vqnegd_s64 (int64_t a) + /// A64: SQNEG Dd, Dn /// public static Vector64 NegateSaturateScalar(Vector64 value) => NegateSaturateScalar(value); /// - /// int8_t vqnegb_s8 (int8_t a) - /// A64: SQNEG Bd, Bn + /// int8_t vqnegb_s8 (int8_t a) + /// A64: SQNEG Bd, Bn /// public static Vector64 NegateSaturateScalar(Vector64 value) => NegateSaturateScalar(value); /// - /// int64x1_t vneg_s64 (int64x1_t a) - /// A64: NEG Dd, Dn + /// int64x1_t vneg_s64 (int64x1_t a) + /// A64: NEG Dd, Dn /// public static Vector64 NegateScalar(Vector64 value) => NegateScalar(value); /// - /// float64x2_t vrecpeq_f64 (float64x2_t a) - /// A64: FRECPE Vd.2D, Vn.2D + /// float64x2_t vrecpeq_f64 (float64x2_t a) + /// A64: FRECPE Vd.2D, Vn.2D /// public static Vector128 ReciprocalEstimate(Vector128 value) => ReciprocalEstimate(value); /// - /// float64x1_t vrecpe_f64 (float64x1_t a) - /// A64: FRECPE Dd, Dn + /// float64x1_t vrecpe_f64 (float64x1_t a) + /// A64: FRECPE Dd, Dn /// public static Vector64 ReciprocalEstimateScalar(Vector64 value) => ReciprocalEstimateScalar(value); /// - /// float32_t vrecpes_f32 (float32_t a) - /// A64: FRECPE Sd, Sn + /// float32_t vrecpes_f32 (float32_t a) + /// A64: FRECPE Sd, Sn /// public static Vector64 ReciprocalEstimateScalar(Vector64 value) => ReciprocalEstimateScalar(value); /// - /// float64_t vrecpxd_f64 (float64_t a) - /// A64: FRECPX Dd, Dn + /// float64_t vrecpxd_f64 (float64_t a) + /// A64: FRECPX Dd, Dn /// public static Vector64 ReciprocalExponentScalar(Vector64 value) => ReciprocalExponentScalar(value); /// - /// float32_t vrecpxs_f32 (float32_t a) - /// A64: FRECPX Sd, Sn + /// float32_t vrecpxs_f32 (float32_t a) + /// A64: FRECPX Sd, Sn /// public static Vector64 ReciprocalExponentScalar(Vector64 value) => ReciprocalExponentScalar(value); /// - /// float64x2_t vrsqrteq_f64 (float64x2_t a) - /// A64: FRSQRTE Vd.2D, Vn.2D + /// float64x2_t vrsqrteq_f64 (float64x2_t a) + /// A64: FRSQRTE Vd.2D, Vn.2D /// public static Vector128 ReciprocalSquareRootEstimate(Vector128 value) => ReciprocalSquareRootEstimate(value); /// - /// float64x1_t vrsqrte_f64 (float64x1_t a) - /// A64: FRSQRTE Dd, Dn + /// float64x1_t vrsqrte_f64 (float64x1_t a) + /// A64: FRSQRTE Dd, Dn /// public static Vector64 ReciprocalSquareRootEstimateScalar(Vector64 value) => ReciprocalSquareRootEstimateScalar(value); /// - /// float32_t vrsqrtes_f32 (float32_t a) - /// A64: FRSQRTE Sd, Sn + /// float32_t vrsqrtes_f32 (float32_t a) + /// A64: FRSQRTE Sd, Sn /// public static Vector64 ReciprocalSquareRootEstimateScalar(Vector64 value) => ReciprocalSquareRootEstimateScalar(value); /// - /// float64x2_t vrsqrtsq_f64 (float64x2_t a, float64x2_t b) - /// A64: FRSQRTS Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vrsqrtsq_f64 (float64x2_t a, float64x2_t b) + /// A64: FRSQRTS Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ReciprocalSquareRootStep(Vector128 left, Vector128 right) => ReciprocalSquareRootStep(left, right); /// - /// float64x1_t vrsqrts_f64 (float64x1_t a, float64x1_t b) - /// A64: FRSQRTS Dd, Dn, Dm + /// float64x1_t vrsqrts_f64 (float64x1_t a, float64x1_t b) + /// A64: FRSQRTS Dd, Dn, Dm /// public static Vector64 ReciprocalSquareRootStepScalar(Vector64 left, Vector64 right) => ReciprocalSquareRootStepScalar(left, right); /// - /// float32_t vrsqrtss_f32 (float32_t a, float32_t b) - /// A64: FRSQRTS Sd, Sn, Sm + /// float32_t vrsqrtss_f32 (float32_t a, float32_t b) + /// A64: FRSQRTS Sd, Sn, Sm /// public static Vector64 ReciprocalSquareRootStepScalar(Vector64 left, Vector64 right) => ReciprocalSquareRootStepScalar(left, right); /// - /// float64x2_t vrecpsq_f64 (float64x2_t a, float64x2_t b) - /// A64: FRECPS Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vrecpsq_f64 (float64x2_t a, float64x2_t b) + /// A64: FRECPS Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ReciprocalStep(Vector128 left, Vector128 right) => ReciprocalStep(left, right); /// - /// float64x1_t vrecps_f64 (float64x1_t a, float64x1_t b) - /// A64: FRECPS Dd, Dn, Dm + /// float64x1_t vrecps_f64 (float64x1_t a, float64x1_t b) + /// A64: FRECPS Dd, Dn, Dm /// public static Vector64 ReciprocalStepScalar(Vector64 left, Vector64 right) => ReciprocalStepScalar(left, right); /// - /// float32_t vrecpss_f32 (float32_t a, float32_t b) - /// A64: FRECPS Sd, Sn, Sm + /// float32_t vrecpss_f32 (float32_t a, float32_t b) + /// A64: FRECPS Sd, Sn, Sm /// public static Vector64 ReciprocalStepScalar(Vector64 left, Vector64 right) => ReciprocalStepScalar(left, right); /// - /// float64x2_t vrndaq_f64 (float64x2_t a) - /// A64: FRINTA Vd.2D, Vn.2D + /// float64x2_t vrndaq_f64 (float64x2_t a) + /// A64: FRINTA Vd.2D, Vn.2D /// public static Vector128 RoundAwayFromZero(Vector128 value) => RoundAwayFromZero(value); /// - /// float64x2_t vrndnq_f64 (float64x2_t a) - /// A64: FRINTN Vd.2D, Vn.2D + /// float64x2_t vrndnq_f64 (float64x2_t a) + /// A64: FRINTN Vd.2D, Vn.2D /// public static Vector128 RoundToNearest(Vector128 value) => RoundToNearest(value); /// - /// float64x2_t vrndmq_f64 (float64x2_t a) - /// A64: FRINTM Vd.2D, Vn.2D + /// float64x2_t vrndmq_f64 (float64x2_t a) + /// A64: FRINTM Vd.2D, Vn.2D /// public static Vector128 RoundToNegativeInfinity(Vector128 value) => RoundToNegativeInfinity(value); /// - /// float64x2_t vrndpq_f64 (float64x2_t a) - /// A64: FRINTP Vd.2D, Vn.2D + /// float64x2_t vrndpq_f64 (float64x2_t a) + /// A64: FRINTP Vd.2D, Vn.2D /// public static Vector128 RoundToPositiveInfinity(Vector128 value) => RoundToPositiveInfinity(value); /// - /// float64x2_t vrndq_f64 (float64x2_t a) - /// A64: FRINTZ Vd.2D, Vn.2D + /// float64x2_t vrndq_f64 (float64x2_t a) + /// A64: FRINTZ Vd.2D, Vn.2D /// public static Vector128 RoundToZero(Vector128 value) => RoundToZero(value); /// - /// int16_t vqrshlh_s16 (int16_t a, int16_t b) - /// A64: SQRSHL Hd, Hn, Hm + /// int16_t vqrshlh_s16 (int16_t a, int16_t b) + /// A64: SQRSHL Hd, Hn, Hm /// public static Vector64 ShiftArithmeticRoundedSaturateScalar(Vector64 value, Vector64 count) => ShiftArithmeticRoundedSaturateScalar(value, count); /// - /// int32_t vqrshls_s32 (int32_t a, int32_t b) - /// A64: SQRSHL Sd, Sn, Sm + /// int32_t vqrshls_s32 (int32_t a, int32_t b) + /// A64: SQRSHL Sd, Sn, Sm /// public static Vector64 ShiftArithmeticRoundedSaturateScalar(Vector64 value, Vector64 count) => ShiftArithmeticRoundedSaturateScalar(value, count); /// - /// int8_t vqrshlb_s8 (int8_t a, int8_t b) - /// A64: SQRSHL Bd, Bn, Bm + /// int8_t vqrshlb_s8 (int8_t a, int8_t b) + /// A64: SQRSHL Bd, Bn, Bm /// public static Vector64 ShiftArithmeticRoundedSaturateScalar(Vector64 value, Vector64 count) => ShiftArithmeticRoundedSaturateScalar(value, count); /// - /// int16_t vqshlh_s16 (int16_t a, int16_t b) - /// A64: SQSHL Hd, Hn, Hm + /// int16_t vqshlh_s16 (int16_t a, int16_t b) + /// A64: SQSHL Hd, Hn, Hm /// public static Vector64 ShiftArithmeticSaturateScalar(Vector64 value, Vector64 count) => ShiftArithmeticSaturateScalar(value, count); /// - /// int32_t vqshls_s32 (int32_t a, int32_t b) - /// A64: SQSHL Sd, Sn, Sm + /// int32_t vqshls_s32 (int32_t a, int32_t b) + /// A64: SQSHL Sd, Sn, Sm /// public static Vector64 ShiftArithmeticSaturateScalar(Vector64 value, Vector64 count) => ShiftArithmeticSaturateScalar(value, count); /// - /// int8_t vqshlb_s8 (int8_t a, int8_t b) - /// A64: SQSHL Bd, Bn, Bm + /// int8_t vqshlb_s8 (int8_t a, int8_t b) + /// A64: SQSHL Bd, Bn, Bm /// public static Vector64 ShiftArithmeticSaturateScalar(Vector64 value, Vector64 count) => ShiftArithmeticSaturateScalar(value, count); /// - /// uint8_t vqshlb_n_u8 (uint8_t a, const int n) - /// A64: UQSHL Bd, Bn, #n + /// uint8_t vqshlb_n_u8 (uint8_t a, const int n) + /// A64: UQSHL Bd, Bn, #n /// public static Vector64 ShiftLeftLogicalSaturateScalar(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalSaturateScalar(value, count); /// - /// int16_t vqshlh_n_s16 (int16_t a, const int n) - /// A64: SQSHL Hd, Hn, #n + /// int16_t vqshlh_n_s16 (int16_t a, const int n) + /// A64: SQSHL Hd, Hn, #n /// public static Vector64 ShiftLeftLogicalSaturateScalar(Vector64 value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturateScalar(value, count); /// - /// int32_t vqshls_n_s32 (int32_t a, const int n) - /// A64: SQSHL Sd, Sn, #n + /// int32_t vqshls_n_s32 (int32_t a, const int n) + /// A64: SQSHL Sd, Sn, #n /// public static Vector64 ShiftLeftLogicalSaturateScalar(Vector64 value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalSaturateScalar(value, count); /// - /// int8_t vqshlb_n_s8 (int8_t a, const int n) - /// A64: SQSHL Bd, Bn, #n + /// int8_t vqshlb_n_s8 (int8_t a, const int n) + /// A64: SQSHL Bd, Bn, #n /// public static Vector64 ShiftLeftLogicalSaturateScalar(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalSaturateScalar(value, count); /// - /// uint16_t vqshlh_n_u16 (uint16_t a, const int n) - /// A64: UQSHL Hd, Hn, #n + /// uint16_t vqshlh_n_u16 (uint16_t a, const int n) + /// A64: UQSHL Hd, Hn, #n /// public static Vector64 ShiftLeftLogicalSaturateScalar(Vector64 value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturateScalar(value, count); /// - /// uint32_t vqshls_n_u32 (uint32_t a, const int n) - /// A64: UQSHL Sd, Sn, #n + /// uint32_t vqshls_n_u32 (uint32_t a, const int n) + /// A64: UQSHL Sd, Sn, #n /// public static Vector64 ShiftLeftLogicalSaturateScalar(Vector64 value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalSaturateScalar(value, count); /// - /// uint16_t vqshluh_n_s16 (int16_t a, const int n) - /// A64: SQSHLU Hd, Hn, #n + /// uint16_t vqshluh_n_s16 (int16_t a, const int n) + /// A64: SQSHLU Hd, Hn, #n /// public static Vector64 ShiftLeftLogicalSaturateUnsignedScalar(Vector64 value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturateUnsignedScalar(value, count); /// - /// uint32_t vqshlus_n_s32 (int32_t a, const int n) - /// A64: SQSHLU Sd, Sn, #n + /// uint32_t vqshlus_n_s32 (int32_t a, const int n) + /// A64: SQSHLU Sd, Sn, #n /// public static Vector64 ShiftLeftLogicalSaturateUnsignedScalar(Vector64 value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalSaturateUnsignedScalar(value, count); /// - /// uint8_t vqshlub_n_s8 (int8_t a, const int n) - /// A64: SQSHLU Bd, Bn, #n + /// uint8_t vqshlub_n_s8 (int8_t a, const int n) + /// A64: SQSHLU Bd, Bn, #n /// public static Vector64 ShiftLeftLogicalSaturateUnsignedScalar(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalSaturateUnsignedScalar(value, count); /// - /// uint8_t vqrshlb_u8 (uint8_t a, int8_t b) - /// A64: UQRSHL Bd, Bn, Bm + /// uint8_t vqrshlb_u8 (uint8_t a, int8_t b) + /// A64: UQRSHL Bd, Bn, Bm /// public static Vector64 ShiftLogicalRoundedSaturateScalar(Vector64 value, Vector64 count) => ShiftLogicalRoundedSaturateScalar(value, count); /// - /// uint16_t vqrshlh_u16 (uint16_t a, int16_t b) - /// A64: UQRSHL Hd, Hn, Hm + /// uint16_t vqrshlh_u16 (uint16_t a, int16_t b) + /// A64: UQRSHL Hd, Hn, Hm /// public static Vector64 ShiftLogicalRoundedSaturateScalar(Vector64 value, Vector64 count) => ShiftLogicalRoundedSaturateScalar(value, count); /// - /// uint32_t vqrshls_u32 (uint32_t a, int32_t b) - /// A64: UQRSHL Sd, Sn, Sm + /// uint32_t vqrshls_u32 (uint32_t a, int32_t b) + /// A64: UQRSHL Sd, Sn, Sm /// public static Vector64 ShiftLogicalRoundedSaturateScalar(Vector64 value, Vector64 count) => ShiftLogicalRoundedSaturateScalar(value, count); /// - /// uint8_t vqrshlb_u8 (uint8_t a, int8_t b) - /// A64: UQRSHL Bd, Bn, Bm + /// uint8_t vqrshlb_u8 (uint8_t a, int8_t b) + /// A64: UQRSHL Bd, Bn, Bm /// public static Vector64 ShiftLogicalRoundedSaturateScalar(Vector64 value, Vector64 count) => ShiftLogicalRoundedSaturateScalar(value, count); /// - /// uint16_t vqrshlh_u16 (uint16_t a, int16_t b) - /// A64: UQRSHL Hd, Hn, Hm + /// uint16_t vqrshlh_u16 (uint16_t a, int16_t b) + /// A64: UQRSHL Hd, Hn, Hm /// public static Vector64 ShiftLogicalRoundedSaturateScalar(Vector64 value, Vector64 count) => ShiftLogicalRoundedSaturateScalar(value, count); /// - /// uint32_t vqrshls_u32 (uint32_t a, int32_t b) - /// A64: UQRSHL Sd, Sn, Sm + /// uint32_t vqrshls_u32 (uint32_t a, int32_t b) + /// A64: UQRSHL Sd, Sn, Sm /// public static Vector64 ShiftLogicalRoundedSaturateScalar(Vector64 value, Vector64 count) => ShiftLogicalRoundedSaturateScalar(value, count); /// - /// uint8_t vqshlb_u8 (uint8_t a, int8_t b) - /// A64: UQSHL Bd, Bn, Bm + /// uint8_t vqshlb_u8 (uint8_t a, int8_t b) + /// A64: UQSHL Bd, Bn, Bm /// public static Vector64 ShiftLogicalSaturateScalar(Vector64 value, Vector64 count) => ShiftLogicalSaturateScalar(value, count); /// - /// uint16_t vqshlh_u16 (uint16_t a, int16_t b) - /// A64: UQSHL Hd, Hn, Hm + /// uint16_t vqshlh_u16 (uint16_t a, int16_t b) + /// A64: UQSHL Hd, Hn, Hm /// public static Vector64 ShiftLogicalSaturateScalar(Vector64 value, Vector64 count) => ShiftLogicalSaturateScalar(value, count); /// - /// uint32_t vqshls_u32 (uint32_t a, int32_t b) - /// A64: UQSHL Sd, Sn, Sm + /// uint32_t vqshls_u32 (uint32_t a, int32_t b) + /// A64: UQSHL Sd, Sn, Sm /// public static Vector64 ShiftLogicalSaturateScalar(Vector64 value, Vector64 count) => ShiftLogicalSaturateScalar(value, count); /// - /// uint8_t vqshlb_u8 (uint8_t a, int8_t b) - /// A64: UQSHL Bd, Bn, Bm + /// uint8_t vqshlb_u8 (uint8_t a, int8_t b) + /// A64: UQSHL Bd, Bn, Bm /// public static Vector64 ShiftLogicalSaturateScalar(Vector64 value, Vector64 count) => ShiftLogicalSaturateScalar(value, count); /// - /// uint16_t vqshlh_u16 (uint16_t a, int16_t b) - /// A64: UQSHL Hd, Hn, Hm + /// uint16_t vqshlh_u16 (uint16_t a, int16_t b) + /// A64: UQSHL Hd, Hn, Hm /// public static Vector64 ShiftLogicalSaturateScalar(Vector64 value, Vector64 count) => ShiftLogicalSaturateScalar(value, count); /// - /// uint32_t vqshls_u32 (uint32_t a, int32_t b) - /// A64: UQSHL Sd, Sn, Sm + /// uint32_t vqshls_u32 (uint32_t a, int32_t b) + /// A64: UQSHL Sd, Sn, Sm /// public static Vector64 ShiftLogicalSaturateScalar(Vector64 value, Vector64 count) => ShiftLogicalSaturateScalar(value, count); /// - /// int16_t vqshrns_n_s32 (int32_t a, const int n) - /// A64: SQSHRN Hd, Sn, #n + /// int16_t vqshrns_n_s32 (int32_t a, const int n) + /// A64: SQSHRN Hd, Sn, #n /// public static Vector64 ShiftRightArithmeticNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticNarrowingSaturateScalar(value, count); /// - /// int32_t vqshrnd_n_s64 (int64_t a, const int n) - /// A64: SQSHRN Sd, Dn, #n + /// int32_t vqshrnd_n_s64 (int64_t a, const int n) + /// A64: SQSHRN Sd, Dn, #n /// public static Vector64 ShiftRightArithmeticNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticNarrowingSaturateScalar(value, count); /// - /// int8_t vqshrnh_n_s16 (int16_t a, const int n) - /// A64: SQSHRN Bd, Hn, #n + /// int8_t vqshrnh_n_s16 (int16_t a, const int n) + /// A64: SQSHRN Bd, Hn, #n /// public static Vector64 ShiftRightArithmeticNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticNarrowingSaturateScalar(value, count); /// - /// uint8_t vqshrunh_n_s16 (int16_t a, const int n) - /// A64: SQSHRUN Bd, Hn, #n + /// uint8_t vqshrunh_n_s16 (int16_t a, const int n) + /// A64: SQSHRUN Bd, Hn, #n /// public static Vector64 ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedScalar(value, count); /// - /// uint16_t vqshruns_n_s32 (int32_t a, const int n) - /// A64: SQSHRUN Hd, Sn, #n + /// uint16_t vqshruns_n_s32 (int32_t a, const int n) + /// A64: SQSHRUN Hd, Sn, #n /// public static Vector64 ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedScalar(value, count); /// - /// uint32_t vqshrund_n_s64 (int64_t a, const int n) - /// A64: SQSHRUN Sd, Dn, #n + /// uint32_t vqshrund_n_s64 (int64_t a, const int n) + /// A64: SQSHRUN Sd, Dn, #n /// public static Vector64 ShiftRightArithmeticNarrowingSaturateUnsignedScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedScalar(value, count); /// - /// int16_t vqrshrns_n_s32 (int32_t a, const int n) - /// A64: SQRSHRN Hd, Sn, #n + /// int16_t vqrshrns_n_s32 (int32_t a, const int n) + /// A64: SQRSHRN Hd, Sn, #n /// public static Vector64 ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateScalar(value, count); /// - /// int32_t vqrshrnd_n_s64 (int64_t a, const int n) - /// A64: SQRSHRN Sd, Dn, #n + /// int32_t vqrshrnd_n_s64 (int64_t a, const int n) + /// A64: SQRSHRN Sd, Dn, #n /// public static Vector64 ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateScalar(value, count); /// - /// int8_t vqrshrnh_n_s16 (int16_t a, const int n) - /// A64: SQRSHRN Bd, Hn, #n + /// int8_t vqrshrnh_n_s16 (int16_t a, const int n) + /// A64: SQRSHRN Bd, Hn, #n /// public static Vector64 ShiftRightArithmeticRoundedNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateScalar(value, count); /// - /// uint8_t vqrshrunh_n_s16 (int16_t a, const int n) - /// A64: SQRSHRUN Bd, Hn, #n + /// uint8_t vqrshrunh_n_s16 (int16_t a, const int n) + /// A64: SQRSHRUN Bd, Hn, #n /// public static Vector64 ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(value, count); /// - /// uint16_t vqrshruns_n_s32 (int32_t a, const int n) - /// A64: SQRSHRUN Hd, Sn, #n + /// uint16_t vqrshruns_n_s32 (int32_t a, const int n) + /// A64: SQRSHRUN Hd, Sn, #n /// public static Vector64 ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(value, count); /// - /// uint32_t vqrshrund_n_s64 (int64_t a, const int n) - /// A64: SQRSHRUN Sd, Dn, #n + /// uint32_t vqrshrund_n_s64 (int64_t a, const int n) + /// A64: SQRSHRUN Sd, Dn, #n /// public static Vector64 ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedScalar(value, count); /// - /// uint8_t vqshrnh_n_u16 (uint16_t a, const int n) - /// A64: UQSHRN Bd, Hn, #n + /// uint8_t vqshrnh_n_u16 (uint16_t a, const int n) + /// A64: UQSHRN Bd, Hn, #n /// public static Vector64 ShiftRightLogicalNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalNarrowingSaturateScalar(value, count); /// - /// uint16_t vqshrns_n_u32 (uint32_t a, const int n) - /// A64: UQSHRN Hd, Sn, #n + /// uint16_t vqshrns_n_u32 (uint32_t a, const int n) + /// A64: UQSHRN Hd, Sn, #n /// public static Vector64 ShiftRightLogicalNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingSaturateScalar(value, count); /// - /// uint32_t vqshrnd_n_u64 (uint64_t a, const int n) - /// A64: UQSHRN Sd, Dn, #n + /// uint32_t vqshrnd_n_u64 (uint64_t a, const int n) + /// A64: UQSHRN Sd, Dn, #n /// public static Vector64 ShiftRightLogicalNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingSaturateScalar(value, count); /// - /// uint8_t vqshrnh_n_u16 (uint16_t a, const int n) - /// A64: UQSHRN Bd, Hn, #n + /// uint8_t vqshrnh_n_u16 (uint16_t a, const int n) + /// A64: UQSHRN Bd, Hn, #n /// public static Vector64 ShiftRightLogicalNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalNarrowingSaturateScalar(value, count); /// - /// uint16_t vqshrns_n_u32 (uint32_t a, const int n) - /// A64: UQSHRN Hd, Sn, #n + /// uint16_t vqshrns_n_u32 (uint32_t a, const int n) + /// A64: UQSHRN Hd, Sn, #n /// public static Vector64 ShiftRightLogicalNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingSaturateScalar(value, count); /// - /// uint32_t vqshrnd_n_u64 (uint64_t a, const int n) - /// A64: UQSHRN Sd, Dn, #n + /// uint32_t vqshrnd_n_u64 (uint64_t a, const int n) + /// A64: UQSHRN Sd, Dn, #n /// public static Vector64 ShiftRightLogicalNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingSaturateScalar(value, count); /// - /// uint8_t vqrshrnh_n_u16 (uint16_t a, const int n) - /// A64: UQRSHRN Bd, Hn, #n + /// uint8_t vqrshrnh_n_u16 (uint16_t a, const int n) + /// A64: UQRSHRN Bd, Hn, #n /// public static Vector64 ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count); /// - /// uint16_t vqrshrns_n_u32 (uint32_t a, const int n) - /// A64: UQRSHRN Hd, Sn, #n + /// uint16_t vqrshrns_n_u32 (uint32_t a, const int n) + /// A64: UQRSHRN Hd, Sn, #n /// [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)] public static Vector64 ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count); /// - /// uint32_t vqrshrnd_n_u64 (uint64_t a, const int n) - /// A64: UQRSHRN Sd, Dn, #n + /// uint32_t vqrshrnd_n_u64 (uint64_t a, const int n) + /// A64: UQRSHRN Sd, Dn, #n /// [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)] public static Vector64 ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count); /// - /// uint8_t vqrshrnh_n_u16 (uint16_t a, const int n) - /// A64: UQRSHRN Bd, Hn, #n + /// uint8_t vqrshrnh_n_u16 (uint16_t a, const int n) + /// A64: UQRSHRN Bd, Hn, #n /// [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)] public static Vector64 ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count); /// - /// uint16_t vqrshrns_n_u32 (uint32_t a, const int n) - /// A64: UQRSHRN Hd, Sn, #n + /// uint16_t vqrshrns_n_u32 (uint32_t a, const int n) + /// A64: UQRSHRN Hd, Sn, #n /// public static Vector64 ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count); /// - /// uint32_t vqrshrnd_n_u64 (uint64_t a, const int n) - /// A64: UQRSHRN Sd, Dn, #n + /// uint32_t vqrshrnd_n_u64 (uint64_t a, const int n) + /// A64: UQRSHRN Sd, Dn, #n /// public static Vector64 ShiftRightLogicalRoundedNarrowingSaturateScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateScalar(value, count); /// - /// float32x2_t vsqrt_f32 (float32x2_t a) - /// A64: FSQRT Vd.2S, Vn.2S + /// float32x2_t vsqrt_f32 (float32x2_t a) + /// A64: FSQRT Vd.2S, Vn.2S /// public static Vector64 Sqrt(Vector64 value) => Sqrt(value); /// - /// float64x2_t vsqrtq_f64 (float64x2_t a) - /// A64: FSQRT Vd.2D, Vn.2D + /// float64x2_t vsqrtq_f64 (float64x2_t a) + /// A64: FSQRT Vd.2D, Vn.2D /// public static Vector128 Sqrt(Vector128 value) => Sqrt(value); /// - /// float32x4_t vsqrtq_f32 (float32x4_t a) - /// A64: FSQRT Vd.4S, Vn.4S + /// float32x4_t vsqrtq_f32 (float32x4_t a) + /// A64: FSQRT Vd.4S, Vn.4S /// public static Vector128 Sqrt(Vector128 value) => Sqrt(value); - /// - /// A64: STP Dt1, Dt2, [Xn] - /// + /// A64: STP Dt1, Dt2, [Xn] public static unsafe void StorePair(byte* address, Vector64 value1, Vector64 value2) => StorePair(address, value1, value2); - /// - /// A64: STP Dt1, Dt2, [Xn] - /// + /// A64: STP Dt1, Dt2, [Xn] public static unsafe void StorePair(double* address, Vector64 value1, Vector64 value2) => StorePair(address, value1, value2); - /// - /// A64: STP Dt1, Dt2, [Xn] - /// + /// A64: STP Dt1, Dt2, [Xn] public static unsafe void StorePair(short* address, Vector64 value1, Vector64 value2) => StorePair(address, value1, value2); - /// - /// A64: STP Dt1, Dt2, [Xn] - /// + /// A64: STP Dt1, Dt2, [Xn] public static unsafe void StorePair(int* address, Vector64 value1, Vector64 value2) => StorePair(address, value1, value2); - /// - /// A64: STP Dt1, Dt2, [Xn] - /// + /// A64: STP Dt1, Dt2, [Xn] public static unsafe void StorePair(long* address, Vector64 value1, Vector64 value2) => StorePair(address, value1, value2); - /// - /// A64: STP Dt1, Dt2, [Xn] - /// + /// A64: STP Dt1, Dt2, [Xn] public static unsafe void StorePair(sbyte* address, Vector64 value1, Vector64 value2) => StorePair(address, value1, value2); - /// - /// A64: STP Dt1, Dt2, [Xn] - /// + /// A64: STP Dt1, Dt2, [Xn] public static unsafe void StorePair(float* address, Vector64 value1, Vector64 value2) => StorePair(address, value1, value2); - /// - /// A64: STP Dt1, Dt2, [Xn] - /// + /// A64: STP Dt1, Dt2, [Xn] public static unsafe void StorePair(ushort* address, Vector64 value1, Vector64 value2) => StorePair(address, value1, value2); - /// - /// A64: STP Dt1, Dt2, [Xn] - /// + /// A64: STP Dt1, Dt2, [Xn] public static unsafe void StorePair(uint* address, Vector64 value1, Vector64 value2) => StorePair(address, value1, value2); - /// - /// A64: STP Dt1, Dt2, [Xn] - /// + /// A64: STP Dt1, Dt2, [Xn] public static unsafe void StorePair(ulong* address, Vector64 value1, Vector64 value2) => StorePair(address, value1, value2); - /// - /// A64: STP Qt1, Qt2, [Xn] - /// + /// A64: STP Qt1, Qt2, [Xn] public static unsafe void StorePair(byte* address, Vector128 value1, Vector128 value2) => StorePair(address, value1, value2); - /// - /// A64: STP Qt1, Qt2, [Xn] - /// + /// A64: STP Qt1, Qt2, [Xn] public static unsafe void StorePair(double* address, Vector128 value1, Vector128 value2) => StorePair(address, value1, value2); - /// - /// A64: STP Qt1, Qt2, [Xn] - /// + /// A64: STP Qt1, Qt2, [Xn] public static unsafe void StorePair(short* address, Vector128 value1, Vector128 value2) => StorePair(address, value1, value2); - /// - /// A64: STP Qt1, Qt2, [Xn] - /// + /// A64: STP Qt1, Qt2, [Xn] public static unsafe void StorePair(int* address, Vector128 value1, Vector128 value2) => StorePair(address, value1, value2); - /// - /// A64: STP Qt1, Qt2, [Xn] - /// + /// A64: STP Qt1, Qt2, [Xn] public static unsafe void StorePair(long* address, Vector128 value1, Vector128 value2) => StorePair(address, value1, value2); - /// - /// A64: STP Qt1, Qt2, [Xn] - /// + /// A64: STP Qt1, Qt2, [Xn] public static unsafe void StorePair(sbyte* address, Vector128 value1, Vector128 value2) => StorePair(address, value1, value2); - /// - /// A64: STP Qt1, Qt2, [Xn] - /// + /// A64: STP Qt1, Qt2, [Xn] public static unsafe void StorePair(float* address, Vector128 value1, Vector128 value2) => StorePair(address, value1, value2); - /// - /// A64: STP Qt1, Qt2, [Xn] - /// + /// A64: STP Qt1, Qt2, [Xn] public static unsafe void StorePair(ushort* address, Vector128 value1, Vector128 value2) => StorePair(address, value1, value2); - /// - /// A64: STP Qt1, Qt2, [Xn] - /// + /// A64: STP Qt1, Qt2, [Xn] public static unsafe void StorePair(uint* address, Vector128 value1, Vector128 value2) => StorePair(address, value1, value2); - /// - /// A64: STP Qt1, Qt2, [Xn] - /// + /// A64: STP Qt1, Qt2, [Xn] public static unsafe void StorePair(ulong* address, Vector128 value1, Vector128 value2) => StorePair(address, value1, value2); - /// - /// A64: STNP Dt1, Dt2, [Xn] - /// + /// A64: STNP Dt1, Dt2, [Xn] public static unsafe void StorePairNonTemporal(byte* address, Vector64 value1, Vector64 value2) => StorePairNonTemporal(address, value1, value2); - /// - /// A64: STNP Dt1, Dt2, [Xn] - /// + /// A64: STNP Dt1, Dt2, [Xn] public static unsafe void StorePairNonTemporal(double* address, Vector64 value1, Vector64 value2) => StorePairNonTemporal(address, value1, value2); - /// - /// A64: STNP Dt1, Dt2, [Xn] - /// + /// A64: STNP Dt1, Dt2, [Xn] public static unsafe void StorePairNonTemporal(short* address, Vector64 value1, Vector64 value2) => StorePairNonTemporal(address, value1, value2); - /// - /// A64: STNP Dt1, Dt2, [Xn] - /// + /// A64: STNP Dt1, Dt2, [Xn] public static unsafe void StorePairNonTemporal(int* address, Vector64 value1, Vector64 value2) => StorePairNonTemporal(address, value1, value2); - /// - /// A64: STNP Dt1, Dt2, [Xn] - /// + /// A64: STNP Dt1, Dt2, [Xn] public static unsafe void StorePairNonTemporal(long* address, Vector64 value1, Vector64 value2) => StorePairNonTemporal(address, value1, value2); - /// - /// A64: STNP Dt1, Dt2, [Xn] - /// + /// A64: STNP Dt1, Dt2, [Xn] public static unsafe void StorePairNonTemporal(sbyte* address, Vector64 value1, Vector64 value2) => StorePairNonTemporal(address, value1, value2); - /// - /// A64: STNP Dt1, Dt2, [Xn] - /// + /// A64: STNP Dt1, Dt2, [Xn] public static unsafe void StorePairNonTemporal(float* address, Vector64 value1, Vector64 value2) => StorePairNonTemporal(address, value1, value2); - /// - /// A64: STNP Dt1, Dt2, [Xn] - /// + /// A64: STNP Dt1, Dt2, [Xn] public static unsafe void StorePairNonTemporal(ushort* address, Vector64 value1, Vector64 value2) => StorePairNonTemporal(address, value1, value2); - /// - /// A64: STNP Dt1, Dt2, [Xn] - /// + /// A64: STNP Dt1, Dt2, [Xn] public static unsafe void StorePairNonTemporal(uint* address, Vector64 value1, Vector64 value2) => StorePairNonTemporal(address, value1, value2); - /// - /// A64: STNP Dt1, Dt2, [Xn] - /// + /// A64: STNP Dt1, Dt2, [Xn] public static unsafe void StorePairNonTemporal(ulong* address, Vector64 value1, Vector64 value2) => StorePairNonTemporal(address, value1, value2); - /// - /// A64: STNP Qt1, Qt2, [Xn] - /// + /// A64: STNP Qt1, Qt2, [Xn] public static unsafe void StorePairNonTemporal(byte* address, Vector128 value1, Vector128 value2) => StorePairNonTemporal(address, value1, value2); - /// - /// A64: STNP Qt1, Qt2, [Xn] - /// + /// A64: STNP Qt1, Qt2, [Xn] public static unsafe void StorePairNonTemporal(double* address, Vector128 value1, Vector128 value2) => StorePairNonTemporal(address, value1, value2); - /// - /// A64: STNP Qt1, Qt2, [Xn] - /// + /// A64: STNP Qt1, Qt2, [Xn] public static unsafe void StorePairNonTemporal(short* address, Vector128 value1, Vector128 value2) => StorePairNonTemporal(address, value1, value2); - /// - /// A64: STNP Qt1, Qt2, [Xn] - /// + /// A64: STNP Qt1, Qt2, [Xn] public static unsafe void StorePairNonTemporal(int* address, Vector128 value1, Vector128 value2) => StorePairNonTemporal(address, value1, value2); - /// - /// A64: STNP Qt1, Qt2, [Xn] - /// + /// A64: STNP Qt1, Qt2, [Xn] public static unsafe void StorePairNonTemporal(long* address, Vector128 value1, Vector128 value2) => StorePairNonTemporal(address, value1, value2); - /// - /// A64: STNP Qt1, Qt2, [Xn] - /// + /// A64: STNP Qt1, Qt2, [Xn] public static unsafe void StorePairNonTemporal(sbyte* address, Vector128 value1, Vector128 value2) => StorePairNonTemporal(address, value1, value2); - /// - /// A64: STNP Qt1, Qt2, [Xn] - /// + /// A64: STNP Qt1, Qt2, [Xn] public static unsafe void StorePairNonTemporal(float* address, Vector128 value1, Vector128 value2) => StorePairNonTemporal(address, value1, value2); - /// - /// A64: STNP Qt1, Qt2, [Xn] - /// + /// A64: STNP Qt1, Qt2, [Xn] public static unsafe void StorePairNonTemporal(ushort* address, Vector128 value1, Vector128 value2) => StorePairNonTemporal(address, value1, value2); - /// - /// A64: STNP Qt1, Qt2, [Xn] - /// + /// A64: STNP Qt1, Qt2, [Xn] public static unsafe void StorePairNonTemporal(uint* address, Vector128 value1, Vector128 value2) => StorePairNonTemporal(address, value1, value2); - /// - /// A64: STNP Qt1, Qt2, [Xn] - /// + /// A64: STNP Qt1, Qt2, [Xn] public static unsafe void StorePairNonTemporal(ulong* address, Vector128 value1, Vector128 value2) => StorePairNonTemporal(address, value1, value2); - /// - /// A64: STP St1, St2, [Xn] - /// + /// A64: STP St1, St2, [Xn] public static unsafe void StorePairScalar(int* address, Vector64 value1, Vector64 value2) => StorePairScalar(address, value1, value2); - /// - /// A64: STP St1, St2, [Xn] - /// + /// A64: STP St1, St2, [Xn] public static unsafe void StorePairScalar(float* address, Vector64 value1, Vector64 value2) => StorePairScalar(address, value1, value2); - /// - /// A64: STP St1, St2, [Xn] - /// + /// A64: STP St1, St2, [Xn] public static unsafe void StorePairScalar(uint* address, Vector64 value1, Vector64 value2) => StorePairScalar(address, value1, value2); - /// - /// A64: STNP St1, St2, [Xn] - /// + /// A64: STNP St1, St2, [Xn] public static unsafe void StorePairScalarNonTemporal(int* address, Vector64 value1, Vector64 value2) => StorePairScalarNonTemporal(address, value1, value2); - /// - /// A64: STNP St1, St2, [Xn] - /// + /// A64: STNP St1, St2, [Xn] public static unsafe void StorePairScalarNonTemporal(float* address, Vector64 value1, Vector64 value2) => StorePairScalarNonTemporal(address, value1, value2); - /// - /// A64: STNP St1, St2, [Xn] - /// + /// A64: STNP St1, St2, [Xn] public static unsafe void StorePairScalarNonTemporal(uint* address, Vector64 value1, Vector64 value2) => StorePairScalarNonTemporal(address, value1, value2); /// - /// void vst2_lane_s8 (int8_t * ptr, int8x16x2_t val, const int lane) - /// A64: ST2 { Vt.16B, Vt+1.16B }[index], [Xn] + /// void vst2_lane_s8 (int8_t * ptr, int8x16x2_t val, const int lane) + /// A64: ST2 { Vt.16B, Vt+1.16B }[index], [Xn] /// public static unsafe void StoreSelectedScalar(byte* address, (Vector128 value1, Vector128 value2) value, [ConstantExpected(Max = (byte)(15))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst2_lane_s8 (int8_t * ptr, int8x16x2_t val, const int lane) - /// A64: ST2 { Vt.16B, Vt+1.16B }[index], [Xn] + /// void vst2_lane_s8 (int8_t * ptr, int8x16x2_t val, const int lane) + /// A64: ST2 { Vt.16B, Vt+1.16B }[index], [Xn] /// public static unsafe void StoreSelectedScalar(sbyte* address, (Vector128 value1, Vector128 value2) value, [ConstantExpected(Max = (byte)(15))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst2_lane_s16 (int16_t * ptr, int16x8x2_t val, const int lane) - /// A64: ST2 { Vt.8H, Vt+1.8H }[index], [Xn] + /// void vst2_lane_s16 (int16_t * ptr, int16x8x2_t val, const int lane) + /// A64: ST2 { Vt.8H, Vt+1.8H }[index], [Xn] /// public static unsafe void StoreSelectedScalar(short* address, (Vector128 value1, Vector128 value2) value, [ConstantExpected(Max = (byte)(7))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst2_lane_s16 (int16_t * ptr, int16x8x2_t val, const int lane) - /// A64: ST2 { Vt.8H, Vt+1.8H }[index], [Xn] + /// void vst2_lane_s16 (int16_t * ptr, int16x8x2_t val, const int lane) + /// A64: ST2 { Vt.8H, Vt+1.8H }[index], [Xn] /// public static unsafe void StoreSelectedScalar(ushort* address, (Vector128 value1, Vector128 value2) value, [ConstantExpected(Max = (byte)(7))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst2_lane_s32 (int32_t * ptr, int32x4x2_t val, const int lane) - /// A64: ST2 { Vt.4S, Vt+1.4S }[index], [Xn] + /// void vst2_lane_s32 (int32_t * ptr, int32x4x2_t val, const int lane) + /// A64: ST2 { Vt.4S, Vt+1.4S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(int* address, (Vector128 value1, Vector128 value2) value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst2_lane_s32 (int32_t * ptr, int32x4x2_t val, const int lane) - /// A64: ST2 { Vt.4S, Vt+1.4S }[index], [Xn] + /// void vst2_lane_s32 (int32_t * ptr, int32x4x2_t val, const int lane) + /// A64: ST2 { Vt.4S, Vt+1.4S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(uint* address, (Vector128 value1, Vector128 value2) value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST2 { Vt.2D, Vt+1.2D }[index], [Xn] - /// + /// A64: ST2 { Vt.2D, Vt+1.2D }[index], [Xn] public static unsafe void StoreSelectedScalar(long* address, (Vector128 value1, Vector128 value2) value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST2 { Vt.2D, Vt+1.2D }[index], [Xn] - /// + /// A64: ST2 { Vt.2D, Vt+1.2D }[index], [Xn] public static unsafe void StoreSelectedScalar(ulong* address, (Vector128 value1, Vector128 value2) value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst2_lane_f32 (float32_t * ptr, float32x2x2_t val, const int lane) - /// A64: ST2 { Vt.4S, Vt+1.4S }[index], [Xn] + /// void vst2_lane_f32 (float32_t * ptr, float32x2x2_t val, const int lane) + /// A64: ST2 { Vt.4S, Vt+1.4S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(float* address, (Vector128 value1, Vector128 value2) value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST2 { Vt.2D, Vt+1.2D }[index], [Xn] - /// + /// A64: ST2 { Vt.2D, Vt+1.2D }[index], [Xn] public static unsafe void StoreSelectedScalar(double* address, (Vector128 value1, Vector128 value2) value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst3_lane_s8 (int8_t * ptr, int8x16x3_t val, const int lane) - /// A64: ST3 { Vt.16B, Vt+1.16B, Vt+2.16B }[index], [Xn] + /// void vst3_lane_s8 (int8_t * ptr, int8x16x3_t val, const int lane) + /// A64: ST3 { Vt.16B, Vt+1.16B, Vt+2.16B }[index], [Xn] /// public static unsafe void StoreSelectedScalar(byte* address, (Vector128 value1, Vector128 value2, Vector128 value3) value, [ConstantExpected(Max = (byte)(15))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst3_lane_s8 (int8_t * ptr, int8x16x3_t val, const int lane) - /// A64: ST3 { Vt.16B, Vt+1.16B, Vt+2.16B }[index], [Xn] + /// void vst3_lane_s8 (int8_t * ptr, int8x16x3_t val, const int lane) + /// A64: ST3 { Vt.16B, Vt+1.16B, Vt+2.16B }[index], [Xn] /// public static unsafe void StoreSelectedScalar(sbyte* address, (Vector128 value1, Vector128 value2, Vector128 value3) value, [ConstantExpected(Max = (byte)(15))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst3_lane_s16 (int16_t * ptr, int16x8x3_t val, const int lane) - /// A64: ST3 { Vt.8H, Vt+1.8H, Vt+2.8H }[index], [Xn] + /// void vst3_lane_s16 (int16_t * ptr, int16x8x3_t val, const int lane) + /// A64: ST3 { Vt.8H, Vt+1.8H, Vt+2.8H }[index], [Xn] /// public static unsafe void StoreSelectedScalar(short* address, (Vector128 value1, Vector128 value2, Vector128 value3) value, [ConstantExpected(Max = (byte)(7))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst3_lane_s16 (int16_t * ptr, int16x8x3_t val, const int lane) - /// A64: ST3 { Vt.8H, Vt+1.8H, Vt+2.8H }[index], [Xn] + /// void vst3_lane_s16 (int16_t * ptr, int16x8x3_t val, const int lane) + /// A64: ST3 { Vt.8H, Vt+1.8H, Vt+2.8H }[index], [Xn] /// public static unsafe void StoreSelectedScalar(ushort* address, (Vector128 value1, Vector128 value2, Vector128 value3) value, [ConstantExpected(Max = (byte)(7))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst3_lane_s32 (int32_t * ptr, int32x4x3_t val, const int lane) - /// A64: ST3 { Vt.4S, Vt+1.4S, Vt+2.4S }[index], [Xn] + /// void vst3_lane_s32 (int32_t * ptr, int32x4x3_t val, const int lane) + /// A64: ST3 { Vt.4S, Vt+1.4S, Vt+2.4S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(int* address, (Vector128 value1, Vector128 value2, Vector128 value3) value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst3_lane_s32 (int32_t * ptr, int32x4x3_t val, const int lane) - /// A64: ST3 { Vt.4S, Vt+1.4S, Vt+2.4S }[index], [Xn] + /// void vst3_lane_s32 (int32_t * ptr, int32x4x3_t val, const int lane) + /// A64: ST3 { Vt.4S, Vt+1.4S, Vt+2.4S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(uint* address, (Vector128 value1, Vector128 value2, Vector128 value3) value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST3 { Vt.2D, Vt+1.2D, Vt+2.2D }[index], [Xn] - /// + /// A64: ST3 { Vt.2D, Vt+1.2D, Vt+2.2D }[index], [Xn] public static unsafe void StoreSelectedScalar(long* address, (Vector128 value1, Vector128 value2, Vector128 value3) value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST3 { Vt.2D, Vt+1.2D, Vt+2.2D }[index], [Xn] - /// + /// A64: ST3 { Vt.2D, Vt+1.2D, Vt+2.2D }[index], [Xn] public static unsafe void StoreSelectedScalar(ulong* address, (Vector128 value1, Vector128 value2, Vector128 value3) value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst3_lane_f32 (float32_t * ptr, float32x2x3_t val, const int lane) - /// A64: ST3 { Vt.4S, Vt+1.4S, Vt+2.4S }[index], [Xn] + /// void vst3_lane_f32 (float32_t * ptr, float32x2x3_t val, const int lane) + /// A64: ST3 { Vt.4S, Vt+1.4S, Vt+2.4S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(float* address, (Vector128 value1, Vector128 value2, Vector128 value3) value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST3 { Vt.2D, Vt+1.2D, Vt+2.2D }[index], [Xn] - /// + /// A64: ST3 { Vt.2D, Vt+1.2D, Vt+2.2D }[index], [Xn] public static unsafe void StoreSelectedScalar(double* address, (Vector128 value1, Vector128 value2, Vector128 value3) value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst4_lane_s8 (int8_t * ptr, int8x16x4_t val, const int lane) - /// A64: ST4 { Vt.16B, Vt+1.16B, Vt+2.16B, Vt+3.16B }[index], [Xn] + /// void vst4_lane_s8 (int8_t * ptr, int8x16x4_t val, const int lane) + /// A64: ST4 { Vt.16B, Vt+1.16B, Vt+2.16B, Vt+3.16B }[index], [Xn] /// public static unsafe void StoreSelectedScalar(byte* address, (Vector128 value1, Vector128 value2, Vector128 value3, Vector128 value4) value, [ConstantExpected(Max = (byte)(15))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst4_lane_s8 (int8_t * ptr, int8x16x4_t val, const int lane) - /// A64: ST4 { Vt.16B, Vt+1.16B, Vt+2.16B, Vt+3.16B }[index], [Xn] + /// void vst4_lane_s8 (int8_t * ptr, int8x16x4_t val, const int lane) + /// A64: ST4 { Vt.16B, Vt+1.16B, Vt+2.16B, Vt+3.16B }[index], [Xn] /// public static unsafe void StoreSelectedScalar(sbyte* address, (Vector128 value1, Vector128 value2, Vector128 value3, Vector128 value4) value, [ConstantExpected(Max = (byte)(15))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst4_lane_s16 (int16_t * ptr, int16x8x4_t val, const int lane) - /// A64: ST4 { Vt.8H, Vt+1.8H, Vt+2.8H, Vt+3.8H }[index], [Xn] + /// void vst4_lane_s16 (int16_t * ptr, int16x8x4_t val, const int lane) + /// A64: ST4 { Vt.8H, Vt+1.8H, Vt+2.8H, Vt+3.8H }[index], [Xn] /// public static unsafe void StoreSelectedScalar(short* address, (Vector128 value1, Vector128 value2, Vector128 value3, Vector128 value4) value, [ConstantExpected(Max = (byte)(7))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst4_lane_s16 (int16_t * ptr, int16x8x4_t val, const int lane) - /// A64: ST4 { Vt.8H, Vt+1.8H, Vt+2.8H, Vt+3.8H }[index], [Xn] + /// void vst4_lane_s16 (int16_t * ptr, int16x8x4_t val, const int lane) + /// A64: ST4 { Vt.8H, Vt+1.8H, Vt+2.8H, Vt+3.8H }[index], [Xn] /// public static unsafe void StoreSelectedScalar(ushort* address, (Vector128 value1, Vector128 value2, Vector128 value3, Vector128 value4) value, [ConstantExpected(Max = (byte)(7))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst4_lane_s32 (int32_t * ptr, int32x4x4_t val, const int lane) - /// A64: ST4 { Vt.4S, Vt+1.4S, Vt+2.4S, Vt+3.4S }[index], [Xn] + /// void vst4_lane_s32 (int32_t * ptr, int32x4x4_t val, const int lane) + /// A64: ST4 { Vt.4S, Vt+1.4S, Vt+2.4S, Vt+3.4S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(int* address, (Vector128 value1, Vector128 value2, Vector128 value3, Vector128 value4) value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst4_lane_s32 (int32_t * ptr, int32x4x4_t val, const int lane) - /// A64: ST4 { Vt.4S, Vt+1.4S, Vt+2.4S, Vt+3.4S }[index], [Xn] + /// void vst4_lane_s32 (int32_t * ptr, int32x4x4_t val, const int lane) + /// A64: ST4 { Vt.4S, Vt+1.4S, Vt+2.4S, Vt+3.4S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(uint* address, (Vector128 value1, Vector128 value2, Vector128 value3, Vector128 value4) value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST4 { Vt.2D, Vt+1.2D, Vt+2.2D, Vt+3.2D }[index], [Xn] - /// + /// A64: ST4 { Vt.2D, Vt+1.2D, Vt+2.2D, Vt+3.2D }[index], [Xn] public static unsafe void StoreSelectedScalar(long* address, (Vector128 value1, Vector128 value2, Vector128 value3, Vector128 value4) value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST4 { Vt.2D, Vt+1.2D, Vt+2.2D, Vt+3.2D }[index], [Xn] - /// + /// A64: ST4 { Vt.2D, Vt+1.2D, Vt+2.2D, Vt+3.2D }[index], [Xn] public static unsafe void StoreSelectedScalar(ulong* address, (Vector128 value1, Vector128 value2, Vector128 value3, Vector128 value4) value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst4_lane_f32 (float32_t * ptr, float32x2x4_t val, const int lane) - /// A64: ST4 { Vt.4S, Vt+1.4S, Vt+2.4S, Vt+3.4S }[index], [Xn] + /// void vst4_lane_f32 (float32_t * ptr, float32x2x4_t val, const int lane) + /// A64: ST4 { Vt.4S, Vt+1.4S, Vt+2.4S, Vt+3.4S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(float* address, (Vector128 value1, Vector128 value2, Vector128 value3, Vector128 value4) value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST4 { Vt.2D, Vt+1.2D, Vt+2.2D, Vt+3.2D }[index], [Xn] - /// + /// A64: ST4 { Vt.2D, Vt+1.2D, Vt+2.2D, Vt+3.2D }[index], [Xn] public static unsafe void StoreSelectedScalar(double* address, (Vector128 value1, Vector128 value2, Vector128 value3, Vector128 value4) value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST2 { Vn.16B, Vn+1.16B }, [Xn] - /// + /// A64: ST2 { Vn.16B, Vn+1.16B }, [Xn] public static unsafe void StoreVectorAndZip(byte* address, (Vector128 Value1, Vector128 Value2) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST2 { Vn.16B, Vn+1.16B }, [Xn] - /// + /// A64: ST2 { Vn.16B, Vn+1.16B }, [Xn] public static unsafe void StoreVectorAndZip(sbyte* address, (Vector128 Value1, Vector128 Value2) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST2 { Vn.8H, Vn+1.8H }, [Xn] - /// + /// A64: ST2 { Vn.8H, Vn+1.8H }, [Xn] public static unsafe void StoreVectorAndZip(short* address, (Vector128 Value1, Vector128 Value2) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST2 { Vn.8H, Vn+1.8H }, [Xn] - /// + /// A64: ST2 { Vn.8H, Vn+1.8H }, [Xn] public static unsafe void StoreVectorAndZip(ushort* address, (Vector128 Value1, Vector128 Value2) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST2 { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: ST2 { Vn.4S, Vn+1.4S }, [Xn] public static unsafe void StoreVectorAndZip(int* address, (Vector128 Value1, Vector128 Value2) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST2 { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: ST2 { Vn.4S, Vn+1.4S }, [Xn] public static unsafe void StoreVectorAndZip(uint* address, (Vector128 Value1, Vector128 Value2) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST2 { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: ST2 { Vn.2D, Vn+1.2D }, [Xn] public static unsafe void StoreVectorAndZip(long* address, (Vector128 Value1, Vector128 Value2) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST2 { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: ST2 { Vn.2D, Vn+1.2D }, [Xn] public static unsafe void StoreVectorAndZip(ulong* address, (Vector128 Value1, Vector128 Value2) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST2 { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: ST2 { Vn.4S, Vn+1.4S }, [Xn] public static unsafe void StoreVectorAndZip(float* address, (Vector128 Value1, Vector128 Value2) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST2 { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: ST2 { Vn.2D, Vn+1.2D }, [Xn] public static unsafe void StoreVectorAndZip(double* address, (Vector128 Value1, Vector128 Value2) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST3 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] - /// + /// A64: ST3 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] public static unsafe void StoreVectorAndZip(byte* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST3 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] - /// + /// A64: ST3 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] public static unsafe void StoreVectorAndZip(sbyte* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST3 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] - /// + /// A64: ST3 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] public static unsafe void StoreVectorAndZip(short* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST3 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] - /// + /// A64: ST3 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] public static unsafe void StoreVectorAndZip(ushort* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: ST3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe void StoreVectorAndZip(int* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: ST3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe void StoreVectorAndZip(uint* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: ST3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe void StoreVectorAndZip(long* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: ST3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe void StoreVectorAndZip(ulong* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: ST3 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe void StoreVectorAndZip(float* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: ST3 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe void StoreVectorAndZip(double* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] - /// + /// A64: ST4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] public static unsafe void StoreVectorAndZip(byte* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] - /// + /// A64: ST4 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] public static unsafe void StoreVectorAndZip(sbyte* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] - /// + /// A64: ST4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] public static unsafe void StoreVectorAndZip(short* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] - /// + /// A64: ST4 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] public static unsafe void StoreVectorAndZip(ushort* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: ST4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe void StoreVectorAndZip(int* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: ST4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe void StoreVectorAndZip(uint* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: ST4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe void StoreVectorAndZip(long* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: ST4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe void StoreVectorAndZip(ulong* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: ST4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe void StoreVectorAndZip(float* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: ST4 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe void StoreVectorAndZip(double* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST1 { Vn.16B, Vn+1.16B }, [Xn] - /// + /// A64: ST1 { Vn.16B, Vn+1.16B }, [Xn] public static unsafe void Store(byte* address, (Vector128 Value1, Vector128 Value2) value) => Store(address, value); - /// - /// A64: ST1 { Vn.16B, Vn+1.16B }, [Xn] - /// + /// A64: ST1 { Vn.16B, Vn+1.16B }, [Xn] public static unsafe void Store(sbyte* address, (Vector128 Value1, Vector128 Value2) value) => Store(address, value); - /// - /// A64: ST1 { Vn.8H, Vn+1.8H }, [Xn] - /// + /// A64: ST1 { Vn.8H, Vn+1.8H }, [Xn] public static unsafe void Store(short* address, (Vector128 Value1, Vector128 Value2) value) => Store(address, value); - /// - /// A64: ST1 { Vn.8H, Vn+1.8H }, [Xn] - /// + /// A64: ST1 { Vn.8H, Vn+1.8H }, [Xn] public static unsafe void Store(ushort* address, (Vector128 Value1, Vector128 Value2) value) => Store(address, value); - /// - /// A64: ST1 { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: ST1 { Vn.4S, Vn+1.4S }, [Xn] public static unsafe void Store(int* address, (Vector128 Value1, Vector128 Value2) value) => Store(address, value); - /// - /// A64: ST1 { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: ST1 { Vn.4S, Vn+1.4S }, [Xn] public static unsafe void Store(uint* address, (Vector128 Value1, Vector128 Value2) value) => Store(address, value); - /// - /// A64: ST1 { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: ST1 { Vn.2D, Vn+1.2D }, [Xn] public static unsafe void Store(long* address, (Vector128 Value1, Vector128 Value2) value) => Store(address, value); - /// - /// A64: ST1 { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: ST1 { Vn.2D, Vn+1.2D }, [Xn] public static unsafe void Store(ulong* address, (Vector128 Value1, Vector128 Value2) value) => Store(address, value); - /// - /// A64: ST1 { Vn.4S, Vn+1.4S }, [Xn] - /// + /// A64: ST1 { Vn.4S, Vn+1.4S }, [Xn] public static unsafe void Store(float* address, (Vector128 Value1, Vector128 Value2) value) => Store(address, value); - /// - /// A64: ST1 { Vn.2D, Vn+1.2D }, [Xn] - /// + /// A64: ST1 { Vn.2D, Vn+1.2D }, [Xn] public static unsafe void Store(double* address, (Vector128 Value1, Vector128 Value2) value) => Store(address, value); - /// - /// A64: ST1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] - /// + /// A64: ST1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] public static unsafe void Store(byte* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) => Store(address, value); - /// - /// A64: ST1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] - /// + /// A64: ST1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] public static unsafe void Store(sbyte* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) => Store(address, value); - /// - /// A64: ST1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] - /// + /// A64: ST1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] public static unsafe void Store(short* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) => Store(address, value); - /// - /// A64: ST1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] - /// + /// A64: ST1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] public static unsafe void Store(ushort* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) => Store(address, value); - /// - /// A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe void Store(int* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) => Store(address, value); - /// - /// A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe void Store(uint* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) => Store(address, value); - /// - /// A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe void Store(long* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) => Store(address, value); - /// - /// A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe void Store(ulong* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) => Store(address, value); - /// - /// A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] - /// + /// A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] public static unsafe void Store(float* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) => Store(address, value); - /// - /// A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] - /// + /// A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] public static unsafe void Store(double* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3) value) => Store(address, value); - /// - /// A64: ST1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] - /// + /// A64: ST1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] public static unsafe void Store(byte* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) => Store(address, value); - /// - /// A64: ST1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] - /// + /// A64: ST1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] public static unsafe void Store(sbyte* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) => Store(address, value); - /// - /// A64: ST1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] - /// + /// A64: ST1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] public static unsafe void Store(short* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) => Store(address, value); - /// - /// A64: ST1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] - /// + /// A64: ST1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] public static unsafe void Store(ushort* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) => Store(address, value); - /// - /// A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe void Store(int* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) => Store(address, value); - /// - /// A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe void Store(uint* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) => Store(address, value); - /// - /// A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe void Store(long* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) => Store(address, value); - /// - /// A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe void Store(ulong* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) => Store(address, value); - /// - /// A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] - /// + /// A64: ST1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] public static unsafe void Store(float* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) => Store(address, value); - /// - /// A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] - /// + /// A64: ST1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] public static unsafe void Store(double* address, (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) value) => Store(address, value); /// - /// float64x2_t vsubq_f64 (float64x2_t a, float64x2_t b) - /// A64: FSUB Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vsubq_f64 (float64x2_t a, float64x2_t b) + /// A64: FSUB Vd.2D, Vn.2D, Vm.2D /// public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// - /// uint8_t vqsubb_u8 (uint8_t a, uint8_t b) - /// A64: UQSUB Bd, Bn, Bm + /// uint8_t vqsubb_u8 (uint8_t a, uint8_t b) + /// A64: UQSUB Bd, Bn, Bm /// public static Vector64 SubtractSaturateScalar(Vector64 left, Vector64 right) => SubtractSaturateScalar(left, right); /// - /// int16_t vqsubh_s16 (int16_t a, int16_t b) - /// A64: SQSUB Hd, Hn, Hm + /// int16_t vqsubh_s16 (int16_t a, int16_t b) + /// A64: SQSUB Hd, Hn, Hm /// public static Vector64 SubtractSaturateScalar(Vector64 left, Vector64 right) => SubtractSaturateScalar(left, right); /// - /// int32_t vqsubs_s32 (int32_t a, int32_t b) - /// A64: SQSUB Sd, Sn, Sm + /// int32_t vqsubs_s32 (int32_t a, int32_t b) + /// A64: SQSUB Sd, Sn, Sm /// public static Vector64 SubtractSaturateScalar(Vector64 left, Vector64 right) => SubtractSaturateScalar(left, right); /// - /// int8_t vqsubb_s8 (int8_t a, int8_t b) - /// A64: SQSUB Bd, Bn, Bm + /// int8_t vqsubb_s8 (int8_t a, int8_t b) + /// A64: SQSUB Bd, Bn, Bm /// public static Vector64 SubtractSaturateScalar(Vector64 left, Vector64 right) => SubtractSaturateScalar(left, right); /// - /// uint16_t vqsubh_u16 (uint16_t a, uint16_t b) - /// A64: UQSUB Hd, Hn, Hm + /// uint16_t vqsubh_u16 (uint16_t a, uint16_t b) + /// A64: UQSUB Hd, Hn, Hm /// public static Vector64 SubtractSaturateScalar(Vector64 left, Vector64 right) => SubtractSaturateScalar(left, right); /// - /// uint32_t vqsubs_u32 (uint32_t a, uint32_t b) - /// A64: UQSUB Sd, Sn, Sm + /// uint32_t vqsubs_u32 (uint32_t a, uint32_t b) + /// A64: UQSUB Sd, Sn, Sm /// public static Vector64 SubtractSaturateScalar(Vector64 left, Vector64 right) => SubtractSaturateScalar(left, right); /// - /// uint8x8_t vrbit_u8 (uint8x8_t a) - /// A64: RBIT Vd.8B, Vn.8B + /// uint8x8_t vrbit_u8 (uint8x8_t a) + /// A64: RBIT Vd.8B, Vn.8B /// public static Vector64 ReverseElementBits(Vector64 value) => ReverseElementBits(value); /// - /// int8x8_t vrbit_s8 (int8x8_t a) - /// A64: RBIT Vd.8B, Vn.8B + /// int8x8_t vrbit_s8 (int8x8_t a) + /// A64: RBIT Vd.8B, Vn.8B /// public static Vector64 ReverseElementBits(Vector64 value) => ReverseElementBits(value); /// - /// uint8x16_t vrbitq_u8 (uint8x16_t a) - /// A64: RBIT Vd.16B, Vn.16B + /// uint8x16_t vrbitq_u8 (uint8x16_t a) + /// A64: RBIT Vd.16B, Vn.16B /// public static Vector128 ReverseElementBits(Vector128 value) => ReverseElementBits(value); /// - /// int8x16_t vrbitq_s8 (int8x16_t a) - /// A64: RBIT Vd.16B, Vn.16B + /// int8x16_t vrbitq_s8 (int8x16_t a) + /// A64: RBIT Vd.16B, Vn.16B /// public static Vector128 ReverseElementBits(Vector128 value) => ReverseElementBits(value); /// - /// uint8x8_t vtrn1_u8(uint8x8_t a, uint8x8_t b) - /// A64: TRN1 Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vtrn1_u8(uint8x8_t a, uint8x8_t b) + /// A64: TRN1 Vd.8B, Vn.8B, Vm.8B /// public static Vector64 TransposeEven(Vector64 left, Vector64 right) => TransposeEven(left, right); /// - /// int16x4_t vtrn1_s16(int16x4_t a, int16x4_t b) - /// A64: TRN1 Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vtrn1_s16(int16x4_t a, int16x4_t b) + /// A64: TRN1 Vd.4H, Vn.4H, Vm.4H /// public static Vector64 TransposeEven(Vector64 left, Vector64 right) => TransposeEven(left, right); /// - /// int32x2_t vtrn1_s32(int32x2_t a, int32x2_t b) - /// A64: TRN1 Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vtrn1_s32(int32x2_t a, int32x2_t b) + /// A64: TRN1 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 TransposeEven(Vector64 left, Vector64 right) => TransposeEven(left, right); /// - /// int8x8_t vtrn1_s8(int8x8_t a, int8x8_t b) - /// A64: TRN1 Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vtrn1_s8(int8x8_t a, int8x8_t b) + /// A64: TRN1 Vd.8B, Vn.8B, Vm.8B /// public static Vector64 TransposeEven(Vector64 left, Vector64 right) => TransposeEven(left, right); /// - /// float32x2_t vtrn1_f32(float32x2_t a, float32x2_t b) - /// A64: TRN1 Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vtrn1_f32(float32x2_t a, float32x2_t b) + /// A64: TRN1 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 TransposeEven(Vector64 left, Vector64 right) => TransposeEven(left, right); /// - /// uint16x4_t vtrn1_u16(uint16x4_t a, uint16x4_t b) - /// A64: TRN1 Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vtrn1_u16(uint16x4_t a, uint16x4_t b) + /// A64: TRN1 Vd.4H, Vn.4H, Vm.4H /// public static Vector64 TransposeEven(Vector64 left, Vector64 right) => TransposeEven(left, right); /// - /// uint32x2_t vtrn1_u32(uint32x2_t a, uint32x2_t b) - /// A64: TRN1 Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vtrn1_u32(uint32x2_t a, uint32x2_t b) + /// A64: TRN1 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 TransposeEven(Vector64 left, Vector64 right) => TransposeEven(left, right); /// - /// uint8x16_t vtrn1q_u8(uint8x16_t a, uint8x16_t b) - /// A64: TRN1 Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vtrn1q_u8(uint8x16_t a, uint8x16_t b) + /// A64: TRN1 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 TransposeEven(Vector128 left, Vector128 right) => TransposeEven(left, right); /// - /// float64x2_t vtrn1q_f64(float64x2_t a, float64x2_t b) - /// A64: TRN1 Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vtrn1q_f64(float64x2_t a, float64x2_t b) + /// A64: TRN1 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 TransposeEven(Vector128 left, Vector128 right) => TransposeEven(left, right); /// - /// int16x8_t vtrn1q_s16(int16x8_t a, int16x8_t b) - /// A64: TRN1 Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vtrn1q_s16(int16x8_t a, int16x8_t b) + /// A64: TRN1 Vd.8H, Vn.8H, Vm.8H /// public static Vector128 TransposeEven(Vector128 left, Vector128 right) => TransposeEven(left, right); /// - /// int32x4_t vtrn1q_s32(int32x4_t a, int32x4_t b) - /// A64: TRN1 Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vtrn1q_s32(int32x4_t a, int32x4_t b) + /// A64: TRN1 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 TransposeEven(Vector128 left, Vector128 right) => TransposeEven(left, right); /// - /// int64x2_t vtrn1q_s64(int64x2_t a, int64x2_t b) - /// A64: TRN1 Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vtrn1q_s64(int64x2_t a, int64x2_t b) + /// A64: TRN1 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 TransposeEven(Vector128 left, Vector128 right) => TransposeEven(left, right); /// - /// int8x16_t vtrn1q_u8(int8x16_t a, int8x16_t b) - /// A64: TRN1 Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vtrn1q_u8(int8x16_t a, int8x16_t b) + /// A64: TRN1 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 TransposeEven(Vector128 left, Vector128 right) => TransposeEven(left, right); /// - /// float32x4_t vtrn1q_f32(float32x4_t a, float32x4_t b) - /// A64: TRN1 Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vtrn1q_f32(float32x4_t a, float32x4_t b) + /// A64: TRN1 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 TransposeEven(Vector128 left, Vector128 right) => TransposeEven(left, right); /// - /// uint16x8_t vtrn1q_u16(uint16x8_t a, uint16x8_t b) - /// A64: TRN1 Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vtrn1q_u16(uint16x8_t a, uint16x8_t b) + /// A64: TRN1 Vd.8H, Vn.8H, Vm.8H /// public static Vector128 TransposeEven(Vector128 left, Vector128 right) => TransposeEven(left, right); /// - /// uint32x4_t vtrn1q_u32(uint32x4_t a, uint32x4_t b) - /// A64: TRN1 Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vtrn1q_u32(uint32x4_t a, uint32x4_t b) + /// A64: TRN1 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 TransposeEven(Vector128 left, Vector128 right) => TransposeEven(left, right); /// - /// uint64x2_t vtrn1q_u64(uint64x2_t a, uint64x2_t b) - /// A64: TRN1 Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vtrn1q_u64(uint64x2_t a, uint64x2_t b) + /// A64: TRN1 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 TransposeEven(Vector128 left, Vector128 right) => TransposeEven(left, right); /// - /// uint8x8_t vtrn2_u8(uint8x8_t a, uint8x8_t b) - /// A64: TRN2 Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vtrn2_u8(uint8x8_t a, uint8x8_t b) + /// A64: TRN2 Vd.8B, Vn.8B, Vm.8B /// public static Vector64 TransposeOdd(Vector64 left, Vector64 right) => TransposeOdd(left, right); /// - /// int16x4_t vtrn2_s16(int16x4_t a, int16x4_t b) - /// A64: TRN2 Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vtrn2_s16(int16x4_t a, int16x4_t b) + /// A64: TRN2 Vd.4H, Vn.4H, Vm.4H /// public static Vector64 TransposeOdd(Vector64 left, Vector64 right) => TransposeOdd(left, right); /// - /// int32x2_t vtrn2_s32(int32x2_t a, int32x2_t b) - /// A64: TRN2 Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vtrn2_s32(int32x2_t a, int32x2_t b) + /// A64: TRN2 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 TransposeOdd(Vector64 left, Vector64 right) => TransposeOdd(left, right); /// - /// int8x8_t vtrn2_s8(int8x8_t a, int8x8_t b) - /// A64: TRN2 Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vtrn2_s8(int8x8_t a, int8x8_t b) + /// A64: TRN2 Vd.8B, Vn.8B, Vm.8B /// public static Vector64 TransposeOdd(Vector64 left, Vector64 right) => TransposeOdd(left, right); /// - /// float32x2_t vtrn2_f32(float32x2_t a, float32x2_t b) - /// A64: TRN2 Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vtrn2_f32(float32x2_t a, float32x2_t b) + /// A64: TRN2 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 TransposeOdd(Vector64 left, Vector64 right) => TransposeOdd(left, right); /// - /// uint16x4_t vtrn2_u16(uint16x4_t a, uint16x4_t b) - /// A64: TRN2 Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vtrn2_u16(uint16x4_t a, uint16x4_t b) + /// A64: TRN2 Vd.4H, Vn.4H, Vm.4H /// public static Vector64 TransposeOdd(Vector64 left, Vector64 right) => TransposeOdd(left, right); /// - /// uint32x2_t vtrn2_u32(uint32x2_t a, uint32x2_t b) - /// A64: TRN2 Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vtrn2_u32(uint32x2_t a, uint32x2_t b) + /// A64: TRN2 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 TransposeOdd(Vector64 left, Vector64 right) => TransposeOdd(left, right); /// - /// uint8x16_t vtrn2q_u8(uint8x16_t a, uint8x16_t b) - /// A64: TRN2 Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vtrn2q_u8(uint8x16_t a, uint8x16_t b) + /// A64: TRN2 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 TransposeOdd(Vector128 left, Vector128 right) => TransposeOdd(left, right); /// - /// float64x2_t vtrn2q_f64(float64x2_t a, float64x2_t b) - /// A64: TRN2 Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vtrn2q_f64(float64x2_t a, float64x2_t b) + /// A64: TRN2 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 TransposeOdd(Vector128 left, Vector128 right) => TransposeOdd(left, right); /// - /// int16x8_t vtrn2q_s16(int16x8_t a, int16x8_t b) - /// A64: TRN2 Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vtrn2q_s16(int16x8_t a, int16x8_t b) + /// A64: TRN2 Vd.8H, Vn.8H, Vm.8H /// public static Vector128 TransposeOdd(Vector128 left, Vector128 right) => TransposeOdd(left, right); /// - /// int32x4_t vtrn2q_s32(int32x4_t a, int32x4_t b) - /// A64: TRN2 Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vtrn2q_s32(int32x4_t a, int32x4_t b) + /// A64: TRN2 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 TransposeOdd(Vector128 left, Vector128 right) => TransposeOdd(left, right); /// - /// int64x2_t vtrn2q_s64(int64x2_t a, int64x2_t b) - /// A64: TRN2 Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vtrn2q_s64(int64x2_t a, int64x2_t b) + /// A64: TRN2 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 TransposeOdd(Vector128 left, Vector128 right) => TransposeOdd(left, right); /// - /// int8x16_t vtrn2q_u8(int8x16_t a, int8x16_t b) - /// A64: TRN2 Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vtrn2q_u8(int8x16_t a, int8x16_t b) + /// A64: TRN2 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 TransposeOdd(Vector128 left, Vector128 right) => TransposeOdd(left, right); /// - /// float32x4_t vtrn2q_f32(float32x4_t a, float32x4_t b) - /// A64: TRN2 Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vtrn2q_f32(float32x4_t a, float32x4_t b) + /// A64: TRN2 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 TransposeOdd(Vector128 left, Vector128 right) => TransposeOdd(left, right); /// - /// uint16x8_t vtrn2q_u16(uint16x8_t a, uint16x8_t b) - /// A64: TRN2 Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vtrn2q_u16(uint16x8_t a, uint16x8_t b) + /// A64: TRN2 Vd.8H, Vn.8H, Vm.8H /// public static Vector128 TransposeOdd(Vector128 left, Vector128 right) => TransposeOdd(left, right); /// - /// uint32x4_t vtrn2q_u32(uint32x4_t a, uint32x4_t b) - /// A64: TRN2 Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vtrn2q_u32(uint32x4_t a, uint32x4_t b) + /// A64: TRN2 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 TransposeOdd(Vector128 left, Vector128 right) => TransposeOdd(left, right); /// - /// uint64x2_t vtrn2q_u64(uint64x2_t a, uint64x2_t b) - /// A64: TRN2 Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vtrn2q_u64(uint64x2_t a, uint64x2_t b) + /// A64: TRN2 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 TransposeOdd(Vector128 left, Vector128 right) => TransposeOdd(left, right); /// - /// uint8x8_t vuzp1_u8(uint8x8_t a, uint8x8_t b) - /// A64: UZP1 Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vuzp1_u8(uint8x8_t a, uint8x8_t b) + /// A64: UZP1 Vd.8B, Vn.8B, Vm.8B /// public static Vector64 UnzipEven(Vector64 left, Vector64 right) => UnzipEven(left, right); /// - /// int16x4_t vuzp1_s16(int16x4_t a, int16x4_t b) - /// A64: UZP1 Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vuzp1_s16(int16x4_t a, int16x4_t b) + /// A64: UZP1 Vd.4H, Vn.4H, Vm.4H /// public static Vector64 UnzipEven(Vector64 left, Vector64 right) => UnzipEven(left, right); /// - /// int32x2_t vuzp1_s32(int32x2_t a, int32x2_t b) - /// A64: UZP1 Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vuzp1_s32(int32x2_t a, int32x2_t b) + /// A64: UZP1 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 UnzipEven(Vector64 left, Vector64 right) => UnzipEven(left, right); /// - /// int8x8_t vuzp1_s8(int8x8_t a, int8x8_t b) - /// A64: UZP1 Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vuzp1_s8(int8x8_t a, int8x8_t b) + /// A64: UZP1 Vd.8B, Vn.8B, Vm.8B /// public static Vector64 UnzipEven(Vector64 left, Vector64 right) => UnzipEven(left, right); /// - /// float32x2_t vuzp1_f32(float32x2_t a, float32x2_t b) - /// A64: UZP1 Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vuzp1_f32(float32x2_t a, float32x2_t b) + /// A64: UZP1 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 UnzipEven(Vector64 left, Vector64 right) => UnzipEven(left, right); /// - /// uint16x4_t vuzp1_u16(uint16x4_t a, uint16x4_t b) - /// A64: UZP1 Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vuzp1_u16(uint16x4_t a, uint16x4_t b) + /// A64: UZP1 Vd.4H, Vn.4H, Vm.4H /// public static Vector64 UnzipEven(Vector64 left, Vector64 right) => UnzipEven(left, right); /// - /// uint32x2_t vuzp1_u32(uint32x2_t a, uint32x2_t b) - /// A64: UZP1 Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vuzp1_u32(uint32x2_t a, uint32x2_t b) + /// A64: UZP1 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 UnzipEven(Vector64 left, Vector64 right) => UnzipEven(left, right); /// - /// uint8x16_t vuzp1q_u8(uint8x16_t a, uint8x16_t b) - /// A64: UZP1 Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vuzp1q_u8(uint8x16_t a, uint8x16_t b) + /// A64: UZP1 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 UnzipEven(Vector128 left, Vector128 right) => UnzipEven(left, right); /// - /// float64x2_t vuzp1q_f64(float64x2_t a, float64x2_t b) - /// A64: UZP1 Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vuzp1q_f64(float64x2_t a, float64x2_t b) + /// A64: UZP1 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 UnzipEven(Vector128 left, Vector128 right) => UnzipEven(left, right); /// - /// int16x8_t vuzp1q_s16(int16x8_t a, int16x8_t b) - /// A64: UZP1 Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vuzp1q_s16(int16x8_t a, int16x8_t b) + /// A64: UZP1 Vd.8H, Vn.8H, Vm.8H /// public static Vector128 UnzipEven(Vector128 left, Vector128 right) => UnzipEven(left, right); /// - /// int32x4_t vuzp1q_s32(int32x4_t a, int32x4_t b) - /// A64: UZP1 Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vuzp1q_s32(int32x4_t a, int32x4_t b) + /// A64: UZP1 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 UnzipEven(Vector128 left, Vector128 right) => UnzipEven(left, right); /// - /// int64x2_t vuzp1q_s64(int64x2_t a, int64x2_t b) - /// A64: UZP1 Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vuzp1q_s64(int64x2_t a, int64x2_t b) + /// A64: UZP1 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 UnzipEven(Vector128 left, Vector128 right) => UnzipEven(left, right); /// - /// int8x16_t vuzp1q_u8(int8x16_t a, int8x16_t b) - /// A64: UZP1 Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vuzp1q_u8(int8x16_t a, int8x16_t b) + /// A64: UZP1 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 UnzipEven(Vector128 left, Vector128 right) => UnzipEven(left, right); /// - /// float32x4_t vuzp1q_f32(float32x4_t a, float32x4_t b) - /// A64: UZP1 Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vuzp1q_f32(float32x4_t a, float32x4_t b) + /// A64: UZP1 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 UnzipEven(Vector128 left, Vector128 right) => UnzipEven(left, right); /// - /// uint16x8_t vuzp1q_u16(uint16x8_t a, uint16x8_t b) - /// A64: UZP1 Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vuzp1q_u16(uint16x8_t a, uint16x8_t b) + /// A64: UZP1 Vd.8H, Vn.8H, Vm.8H /// public static Vector128 UnzipEven(Vector128 left, Vector128 right) => UnzipEven(left, right); /// - /// uint32x4_t vuzp1q_u32(uint32x4_t a, uint32x4_t b) - /// A64: UZP1 Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vuzp1q_u32(uint32x4_t a, uint32x4_t b) + /// A64: UZP1 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 UnzipEven(Vector128 left, Vector128 right) => UnzipEven(left, right); /// - /// uint64x2_t vuzp1q_u64(uint64x2_t a, uint64x2_t b) - /// A64: UZP1 Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vuzp1q_u64(uint64x2_t a, uint64x2_t b) + /// A64: UZP1 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 UnzipEven(Vector128 left, Vector128 right) => UnzipEven(left, right); /// - /// uint8x8_t vuzp2_u8(uint8x8_t a, uint8x8_t b) - /// A64: UZP2 Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vuzp2_u8(uint8x8_t a, uint8x8_t b) + /// A64: UZP2 Vd.8B, Vn.8B, Vm.8B /// public static Vector64 UnzipOdd(Vector64 left, Vector64 right) => UnzipOdd(left, right); /// - /// int16x4_t vuzp2_s16(int16x4_t a, int16x4_t b) - /// A64: UZP2 Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vuzp2_s16(int16x4_t a, int16x4_t b) + /// A64: UZP2 Vd.4H, Vn.4H, Vm.4H /// public static Vector64 UnzipOdd(Vector64 left, Vector64 right) => UnzipOdd(left, right); /// - /// int32x2_t vuzp2_s32(int32x2_t a, int32x2_t b) - /// A64: UZP2 Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vuzp2_s32(int32x2_t a, int32x2_t b) + /// A64: UZP2 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 UnzipOdd(Vector64 left, Vector64 right) => UnzipOdd(left, right); /// - /// int8x8_t vuzp2_s8(int8x8_t a, int8x8_t b) - /// A64: UZP2 Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vuzp2_s8(int8x8_t a, int8x8_t b) + /// A64: UZP2 Vd.8B, Vn.8B, Vm.8B /// public static Vector64 UnzipOdd(Vector64 left, Vector64 right) => UnzipOdd(left, right); /// - /// float32x2_t vuzp2_f32(float32x2_t a, float32x2_t b) - /// A64: UZP2 Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vuzp2_f32(float32x2_t a, float32x2_t b) + /// A64: UZP2 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 UnzipOdd(Vector64 left, Vector64 right) => UnzipOdd(left, right); /// - /// uint16x4_t vuzp2_u16(uint16x4_t a, uint16x4_t b) - /// A64: UZP2 Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vuzp2_u16(uint16x4_t a, uint16x4_t b) + /// A64: UZP2 Vd.4H, Vn.4H, Vm.4H /// public static Vector64 UnzipOdd(Vector64 left, Vector64 right) => UnzipOdd(left, right); /// - /// uint32x2_t vuzp2_u32(uint32x2_t a, uint32x2_t b) - /// A64: UZP2 Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vuzp2_u32(uint32x2_t a, uint32x2_t b) + /// A64: UZP2 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 UnzipOdd(Vector64 left, Vector64 right) => UnzipOdd(left, right); /// - /// uint8x16_t vuzp2q_u8(uint8x16_t a, uint8x16_t b) - /// A64: UZP2 Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vuzp2q_u8(uint8x16_t a, uint8x16_t b) + /// A64: UZP2 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 UnzipOdd(Vector128 left, Vector128 right) => UnzipOdd(left, right); /// - /// float64x2_t vuzp2q_f64(float64x2_t a, float64x2_t b) - /// A64: UZP2 Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vuzp2q_f64(float64x2_t a, float64x2_t b) + /// A64: UZP2 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 UnzipOdd(Vector128 left, Vector128 right) => UnzipOdd(left, right); /// - /// int16x8_t vuzp2q_s16(int16x8_t a, int16x8_t b) - /// A64: UZP2 Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vuzp2q_s16(int16x8_t a, int16x8_t b) + /// A64: UZP2 Vd.8H, Vn.8H, Vm.8H /// public static Vector128 UnzipOdd(Vector128 left, Vector128 right) => UnzipOdd(left, right); /// - /// int32x4_t vuzp2q_s32(int32x4_t a, int32x4_t b) - /// A64: UZP2 Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vuzp2q_s32(int32x4_t a, int32x4_t b) + /// A64: UZP2 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 UnzipOdd(Vector128 left, Vector128 right) => UnzipOdd(left, right); /// - /// int64x2_t vuzp2q_s64(int64x2_t a, int64x2_t b) - /// A64: UZP2 Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vuzp2q_s64(int64x2_t a, int64x2_t b) + /// A64: UZP2 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 UnzipOdd(Vector128 left, Vector128 right) => UnzipOdd(left, right); /// - /// int8x16_t vuzp2q_u8(int8x16_t a, int8x16_t b) - /// A64: UZP2 Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vuzp2q_u8(int8x16_t a, int8x16_t b) + /// A64: UZP2 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 UnzipOdd(Vector128 left, Vector128 right) => UnzipOdd(left, right); /// - /// float32x4_t vuzp2q_f32(float32x4_t a, float32x4_t b) - /// A64: UZP2 Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vuzp2q_f32(float32x4_t a, float32x4_t b) + /// A64: UZP2 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 UnzipOdd(Vector128 left, Vector128 right) => UnzipOdd(left, right); /// - /// uint16x8_t vuzp2q_u16(uint16x8_t a, uint16x8_t b) - /// A64: UZP2 Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vuzp2q_u16(uint16x8_t a, uint16x8_t b) + /// A64: UZP2 Vd.8H, Vn.8H, Vm.8H /// public static Vector128 UnzipOdd(Vector128 left, Vector128 right) => UnzipOdd(left, right); /// - /// uint32x4_t vuzp2q_u32(uint32x4_t a, uint32x4_t b) - /// A64: UZP2 Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vuzp2q_u32(uint32x4_t a, uint32x4_t b) + /// A64: UZP2 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 UnzipOdd(Vector128 left, Vector128 right) => UnzipOdd(left, right); /// - /// uint64x2_t vuzp2q_u64(uint64x2_t a, uint64x2_t b) - /// A64: UZP2 Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vuzp2q_u64(uint64x2_t a, uint64x2_t b) + /// A64: UZP2 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 UnzipOdd(Vector128 left, Vector128 right) => UnzipOdd(left, right); /// - /// uint8x16_t vqvtbl1q_u8(uint8x16_t t, uint8x16_t idx) - /// A64: TBL Vd.16B, {Vn.16B}, Vm.16B + /// uint8x16_t vqvtbl1q_u8(uint8x16_t t, uint8x16_t idx) + /// A64: TBL Vd.16B, {Vn.16B}, Vm.16B /// public static Vector128 VectorTableLookup(Vector128 table, Vector128 byteIndexes) => VectorTableLookup(table, byteIndexes); /// - /// int8x16_t vqvtbl1q_s8(int8x16_t t, uint8x16_t idx) - /// A64: TBL Vd.16B, {Vn.16B}, Vm.16B + /// int8x16_t vqvtbl1q_s8(int8x16_t t, uint8x16_t idx) + /// A64: TBL Vd.16B, {Vn.16B}, Vm.16B /// public static Vector128 VectorTableLookup(Vector128 table, Vector128 byteIndexes) => VectorTableLookup(table, byteIndexes); /// - /// uint8x16_t vqtbl2q_u8(uint8x16x2_t t, uint8x16_t idx) - /// A64: TBL Vd.16B, {Vn.16B, Vn+1.16B}, Vm.16B + /// uint8x16_t vqtbl2q_u8(uint8x16x2_t t, uint8x16_t idx) + /// A64: TBL Vd.16B, {Vn.16B, Vn+1.16B}, Vm.16B /// public static Vector128 VectorTableLookup((Vector128, Vector128) table, Vector128 byteIndexes) => VectorTableLookup(table, byteIndexes); /// - /// int8x16_t vqtbl2q_s8(int8x16x2_t t, uint8x16_t idx) - /// A64: TBL Vd.16B, {Vn.16B, Vn+1.16B}, Vm.16B + /// int8x16_t vqtbl2q_s8(int8x16x2_t t, uint8x16_t idx) + /// A64: TBL Vd.16B, {Vn.16B, Vn+1.16B}, Vm.16B /// public static Vector128 VectorTableLookup((Vector128, Vector128) table, Vector128 byteIndexes) => VectorTableLookup(table, byteIndexes); /// - /// uint8x16_t vqtbl3q_u8(uint8x16x3_t t, uint8x16_t idx) - /// A64: TBL Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.16B + /// uint8x16_t vqtbl3q_u8(uint8x16x3_t t, uint8x16_t idx) + /// A64: TBL Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.16B /// public static Vector128 VectorTableLookup((Vector128, Vector128, Vector128) table, Vector128 byteIndexes) => VectorTableLookup(table, byteIndexes); /// - /// int8x16_t vqtbl3q_s8(int8x16x3_t t, uint8x16_t idx) - /// A64: TBL Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.16B + /// int8x16_t vqtbl3q_s8(int8x16x3_t t, uint8x16_t idx) + /// A64: TBL Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.16B /// public static Vector128 VectorTableLookup((Vector128, Vector128, Vector128) table, Vector128 byteIndexes) => VectorTableLookup(table, byteIndexes); /// - /// uint8x16_t vqtbl4q_u8(uint8x16x4_t t, uint8x16_t idx) - /// A64: TBL Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.16B + /// uint8x16_t vqtbl4q_u8(uint8x16x4_t t, uint8x16_t idx) + /// A64: TBL Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.16B /// public static Vector128 VectorTableLookup((Vector128, Vector128, Vector128, Vector128) table, Vector128 byteIndexes) => VectorTableLookup(table, byteIndexes); /// - /// int8x16_t vqtbl4q_s8(int8x16x4_t t, uint8x16_t idx) - /// A64: TBL Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.16B + /// int8x16_t vqtbl4q_s8(int8x16x4_t t, uint8x16_t idx) + /// A64: TBL Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.16B /// public static Vector128 VectorTableLookup((Vector128, Vector128, Vector128, Vector128) table, Vector128 byteIndexes) => VectorTableLookup(table, byteIndexes); /// - /// uint8x16_t vqvtbx1q_u8(uint8x16_t r, int8x16_t t, uint8x16_t idx) - /// A64: TBX Vd.16B, {Vn.16B}, Vm.16B + /// uint8x16_t vqvtbx1q_u8(uint8x16_t r, int8x16_t t, uint8x16_t idx) + /// A64: TBX Vd.16B, {Vn.16B}, Vm.16B /// public static Vector128 VectorTableLookupExtension(Vector128 defaultValues, Vector128 table, Vector128 byteIndexes) => VectorTableLookupExtension(defaultValues, table, byteIndexes); /// - /// int8x16_t vqvtbx1q_s8(int8x16_t r, int8x16_t t, uint8x16_t idx) - /// A64: TBX Vd.16B, {Vn.16B}, Vm.16B + /// int8x16_t vqvtbx1q_s8(int8x16_t r, int8x16_t t, uint8x16_t idx) + /// A64: TBX Vd.16B, {Vn.16B}, Vm.16B /// public static Vector128 VectorTableLookupExtension(Vector128 defaultValues, Vector128 table, Vector128 byteIndexes) => VectorTableLookupExtension(defaultValues, table, byteIndexes); /// - /// uint8x16_t vqtbx2q_u8(uint8x16x2_t t, uint8x16_t idx) - /// A64: TBX Vd.16B, {Vn.16B, Vn+1.16B}, Vm.16B + /// uint8x16_t vqtbx2q_u8(uint8x16x2_t t, uint8x16_t idx) + /// A64: TBX Vd.16B, {Vn.16B, Vn+1.16B}, Vm.16B /// public static Vector128 VectorTableLookupExtension(Vector128 defaultValues, (Vector128, Vector128) table, Vector128 byteIndexes) => VectorTableLookupExtension(defaultValues, table, byteIndexes); /// - /// int8x16_t vqtbx2q_s8(int8x16x2_t t, uint8x16_t idx) - /// A64: TBX Vd.16B, {Vn.16B, Vn+1.16B}, Vm.16B + /// int8x16_t vqtbx2q_s8(int8x16x2_t t, uint8x16_t idx) + /// A64: TBX Vd.16B, {Vn.16B, Vn+1.16B}, Vm.16B /// public static Vector128 VectorTableLookupExtension(Vector128 defaultValues, (Vector128, Vector128) table, Vector128 byteIndexes) => VectorTableLookupExtension(defaultValues, table, byteIndexes); /// - /// uint8x16_t vqtbx3q_u8(uint8x16x3_t t, uint8x16_t idx) - /// A64: TBX Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.16B + /// uint8x16_t vqtbx3q_u8(uint8x16x3_t t, uint8x16_t idx) + /// A64: TBX Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.16B /// public static Vector128 VectorTableLookupExtension(Vector128 defaultValues, (Vector128, Vector128, Vector128) table, Vector128 byteIndexes) => VectorTableLookupExtension(defaultValues, table, byteIndexes); /// - /// int8x16_t vqtbx3q_s8(int8x16x3_t t, uint8x16_t idx) - /// A64: TBX Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.16B + /// int8x16_t vqtbx3q_s8(int8x16x3_t t, uint8x16_t idx) + /// A64: TBX Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.16B /// public static Vector128 VectorTableLookupExtension(Vector128 defaultValues, (Vector128, Vector128, Vector128) table, Vector128 byteIndexes) => VectorTableLookupExtension(defaultValues, table, byteIndexes); /// - /// uint8x16_t vqtbx4q_u8(uint8x16x4_t t, uint8x16_t idx) - /// A64: TBX Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.16B + /// uint8x16_t vqtbx4q_u8(uint8x16x4_t t, uint8x16_t idx) + /// A64: TBX Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.16B /// public static Vector128 VectorTableLookupExtension(Vector128 defaultValues, (Vector128, Vector128, Vector128, Vector128) table, Vector128 byteIndexes) => VectorTableLookupExtension(defaultValues, table, byteIndexes); /// - /// int8x16_t vqtbx4q_s8(int8x16x4_t t, uint8x16_t idx) - /// A64: TBX Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.16B + /// int8x16_t vqtbx4q_s8(int8x16x4_t t, uint8x16_t idx) + /// A64: TBX Vd.16B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.16B /// public static Vector128 VectorTableLookupExtension(Vector128 defaultValues, (Vector128, Vector128, Vector128, Vector128) table, Vector128 byteIndexes) => VectorTableLookupExtension(defaultValues, table, byteIndexes); /// - /// uint8x8_t vzip2_u8(uint8x8_t a, uint8x8_t b) - /// A64: ZIP2 Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vzip2_u8(uint8x8_t a, uint8x8_t b) + /// A64: ZIP2 Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ZipHigh(Vector64 left, Vector64 right) => ZipHigh(left, right); /// - /// int16x4_t vzip2_s16(int16x4_t a, int16x4_t b) - /// A64: ZIP2 Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vzip2_s16(int16x4_t a, int16x4_t b) + /// A64: ZIP2 Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ZipHigh(Vector64 left, Vector64 right) => ZipHigh(left, right); /// - /// int32x2_t vzip2_s32(int32x2_t a, int32x2_t b) - /// A64: ZIP2 Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vzip2_s32(int32x2_t a, int32x2_t b) + /// A64: ZIP2 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ZipHigh(Vector64 left, Vector64 right) => ZipHigh(left, right); /// - /// int8x8_t vzip2_s8(int8x8_t a, int8x8_t b) - /// A64: ZIP2 Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vzip2_s8(int8x8_t a, int8x8_t b) + /// A64: ZIP2 Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ZipHigh(Vector64 left, Vector64 right) => ZipHigh(left, right); /// - /// float32x2_t vzip2_f32(float32x2_t a, float32x2_t b) - /// A64: ZIP2 Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vzip2_f32(float32x2_t a, float32x2_t b) + /// A64: ZIP2 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ZipHigh(Vector64 left, Vector64 right) => ZipHigh(left, right); /// - /// uint16x4_t vzip2_u16(uint16x4_t a, uint16x4_t b) - /// A64: ZIP2 Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vzip2_u16(uint16x4_t a, uint16x4_t b) + /// A64: ZIP2 Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ZipHigh(Vector64 left, Vector64 right) => ZipHigh(left, right); /// - /// uint32x2_t vzip2_u32(uint32x2_t a, uint32x2_t b) - /// A64: ZIP2 Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vzip2_u32(uint32x2_t a, uint32x2_t b) + /// A64: ZIP2 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ZipHigh(Vector64 left, Vector64 right) => ZipHigh(left, right); /// - /// uint8x16_t vzip2q_u8(uint8x16_t a, uint8x16_t b) - /// A64: ZIP2 Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vzip2q_u8(uint8x16_t a, uint8x16_t b) + /// A64: ZIP2 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ZipHigh(Vector128 left, Vector128 right) => ZipHigh(left, right); /// - /// float64x2_t vzip2q_f64(float64x2_t a, float64x2_t b) - /// A64: ZIP2 Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vzip2q_f64(float64x2_t a, float64x2_t b) + /// A64: ZIP2 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ZipHigh(Vector128 left, Vector128 right) => ZipHigh(left, right); /// - /// int16x8_t vzip2q_s16(int16x8_t a, int16x8_t b) - /// A64: ZIP2 Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vzip2q_s16(int16x8_t a, int16x8_t b) + /// A64: ZIP2 Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ZipHigh(Vector128 left, Vector128 right) => ZipHigh(left, right); /// - /// int32x4_t vzip2q_s32(int32x4_t a, int32x4_t b) - /// A64: ZIP2 Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vzip2q_s32(int32x4_t a, int32x4_t b) + /// A64: ZIP2 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ZipHigh(Vector128 left, Vector128 right) => ZipHigh(left, right); /// - /// int64x2_t vzip2q_s64(int64x2_t a, int64x2_t b) - /// A64: ZIP2 Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vzip2q_s64(int64x2_t a, int64x2_t b) + /// A64: ZIP2 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ZipHigh(Vector128 left, Vector128 right) => ZipHigh(left, right); /// - /// int8x16_t vzip2q_u8(int8x16_t a, int8x16_t b) - /// A64: ZIP2 Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vzip2q_u8(int8x16_t a, int8x16_t b) + /// A64: ZIP2 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ZipHigh(Vector128 left, Vector128 right) => ZipHigh(left, right); /// - /// float32x4_t vzip2q_f32(float32x4_t a, float32x4_t b) - /// A64: ZIP2 Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vzip2q_f32(float32x4_t a, float32x4_t b) + /// A64: ZIP2 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ZipHigh(Vector128 left, Vector128 right) => ZipHigh(left, right); /// - /// uint16x8_t vzip2q_u16(uint16x8_t a, uint16x8_t b) - /// A64: ZIP2 Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vzip2q_u16(uint16x8_t a, uint16x8_t b) + /// A64: ZIP2 Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ZipHigh(Vector128 left, Vector128 right) => ZipHigh(left, right); /// - /// uint32x4_t vzip2q_u32(uint32x4_t a, uint32x4_t b) - /// A64: ZIP2 Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vzip2q_u32(uint32x4_t a, uint32x4_t b) + /// A64: ZIP2 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ZipHigh(Vector128 left, Vector128 right) => ZipHigh(left, right); /// - /// uint64x2_t vzip2q_u64(uint64x2_t a, uint64x2_t b) - /// A64: ZIP2 Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vzip2q_u64(uint64x2_t a, uint64x2_t b) + /// A64: ZIP2 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ZipHigh(Vector128 left, Vector128 right) => ZipHigh(left, right); /// - /// uint8x8_t vzip1_u8(uint8x8_t a, uint8x8_t b) - /// A64: ZIP1 Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vzip1_u8(uint8x8_t a, uint8x8_t b) + /// A64: ZIP1 Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ZipLow(Vector64 left, Vector64 right) => ZipLow(left, right); /// - /// int16x4_t vzip1_s16(int16x4_t a, int16x4_t b) - /// A64: ZIP1 Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vzip1_s16(int16x4_t a, int16x4_t b) + /// A64: ZIP1 Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ZipLow(Vector64 left, Vector64 right) => ZipLow(left, right); /// - /// int32x2_t vzip1_s32(int32x2_t a, int32x2_t b) - /// A64: ZIP1 Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vzip1_s32(int32x2_t a, int32x2_t b) + /// A64: ZIP1 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ZipLow(Vector64 left, Vector64 right) => ZipLow(left, right); /// - /// int8x8_t vzip1_s8(int8x8_t a, int8x8_t b) - /// A64: ZIP1 Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vzip1_s8(int8x8_t a, int8x8_t b) + /// A64: ZIP1 Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ZipLow(Vector64 left, Vector64 right) => ZipLow(left, right); /// - /// float32x2_t vzip1_f32(float32x2_t a, float32x2_t b) - /// A64: ZIP1 Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vzip1_f32(float32x2_t a, float32x2_t b) + /// A64: ZIP1 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ZipLow(Vector64 left, Vector64 right) => ZipLow(left, right); /// - /// uint16x4_t vzip1_u16(uint16x4_t a, uint16x4_t b) - /// A64: ZIP1 Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vzip1_u16(uint16x4_t a, uint16x4_t b) + /// A64: ZIP1 Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ZipLow(Vector64 left, Vector64 right) => ZipLow(left, right); /// - /// uint32x2_t vzip1_u32(uint32x2_t a, uint32x2_t b) - /// A64: ZIP1 Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vzip1_u32(uint32x2_t a, uint32x2_t b) + /// A64: ZIP1 Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ZipLow(Vector64 left, Vector64 right) => ZipLow(left, right); /// - /// uint8x16_t vzip1q_u8(uint8x16_t a, uint8x16_t b) - /// A64: ZIP1 Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vzip1q_u8(uint8x16_t a, uint8x16_t b) + /// A64: ZIP1 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ZipLow(Vector128 left, Vector128 right) => ZipLow(left, right); /// - /// float64x2_t vzip1q_f64(float64x2_t a, float64x2_t b) - /// A64: ZIP1 Vd.2D, Vn.2D, Vm.2D + /// float64x2_t vzip1q_f64(float64x2_t a, float64x2_t b) + /// A64: ZIP1 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ZipLow(Vector128 left, Vector128 right) => ZipLow(left, right); /// - /// int16x8_t vzip1q_s16(int16x8_t a, int16x8_t b) - /// A64: ZIP1 Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vzip1q_s16(int16x8_t a, int16x8_t b) + /// A64: ZIP1 Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ZipLow(Vector128 left, Vector128 right) => ZipLow(left, right); /// - /// int32x4_t vzip1q_s32(int32x4_t a, int32x4_t b) - /// A64: ZIP1 Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vzip1q_s32(int32x4_t a, int32x4_t b) + /// A64: ZIP1 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ZipLow(Vector128 left, Vector128 right) => ZipLow(left, right); /// - /// int64x2_t vzip1q_s64(int64x2_t a, int64x2_t b) - /// A64: ZIP1 Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vzip1q_s64(int64x2_t a, int64x2_t b) + /// A64: ZIP1 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ZipLow(Vector128 left, Vector128 right) => ZipLow(left, right); /// - /// int8x16_t vzip1q_u8(int8x16_t a, int8x16_t b) - /// A64: ZIP1 Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vzip1q_u8(int8x16_t a, int8x16_t b) + /// A64: ZIP1 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ZipLow(Vector128 left, Vector128 right) => ZipLow(left, right); /// - /// float32x4_t vzip1q_f32(float32x4_t a, float32x4_t b) - /// A64: ZIP1 Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vzip1q_f32(float32x4_t a, float32x4_t b) + /// A64: ZIP1 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ZipLow(Vector128 left, Vector128 right) => ZipLow(left, right); /// - /// uint16x8_t vzip1q_u16(uint16x8_t a, uint16x8_t b) - /// A64: ZIP1 Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vzip1q_u16(uint16x8_t a, uint16x8_t b) + /// A64: ZIP1 Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ZipLow(Vector128 left, Vector128 right) => ZipLow(left, right); /// - /// uint32x4_t vzip1q_u32(uint32x4_t a, uint32x4_t b) - /// A64: ZIP1 Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vzip1q_u32(uint32x4_t a, uint32x4_t b) + /// A64: ZIP1 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ZipLow(Vector128 left, Vector128 right) => ZipLow(left, right); /// - /// uint64x2_t vzip1q_u64(uint64x2_t a, uint64x2_t b) - /// A64: ZIP1 Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vzip1q_u64(uint64x2_t a, uint64x2_t b) + /// A64: ZIP1 Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ZipLow(Vector128 left, Vector128 right) => ZipLow(left, right); } /// - /// int16x4_t vabs_s16 (int16x4_t a) - /// A32: VABS.S16 Dd, Dm - /// A64: ABS Vd.4H, Vn.4H + /// int16x4_t vabs_s16 (int16x4_t a) + /// A32: VABS.S16 Dd, Dm + /// A64: ABS Vd.4H, Vn.4H /// public static Vector64 Abs(Vector64 value) => Abs(value); /// - /// int32x2_t vabs_s32 (int32x2_t a) - /// A32: VABS.S32 Dd, Dm - /// A64: ABS Vd.2S, Vn.2S + /// int32x2_t vabs_s32 (int32x2_t a) + /// A32: VABS.S32 Dd, Dm + /// A64: ABS Vd.2S, Vn.2S /// public static Vector64 Abs(Vector64 value) => Abs(value); /// - /// int8x8_t vabs_s8 (int8x8_t a) - /// A32: VABS.S8 Dd, Dm - /// A64: ABS Vd.8B, Vn.8B + /// int8x8_t vabs_s8 (int8x8_t a) + /// A32: VABS.S8 Dd, Dm + /// A64: ABS Vd.8B, Vn.8B /// public static Vector64 Abs(Vector64 value) => Abs(value); /// - /// float32x2_t vabs_f32 (float32x2_t a) - /// A32: VABS.F32 Dd, Dm - /// A64: FABS Vd.2S, Vn.2S + /// float32x2_t vabs_f32 (float32x2_t a) + /// A32: VABS.F32 Dd, Dm + /// A64: FABS Vd.2S, Vn.2S /// public static Vector64 Abs(Vector64 value) => Abs(value); /// - /// int16x8_t vabsq_s16 (int16x8_t a) - /// A32: VABS.S16 Qd, Qm - /// A64: ABS Vd.8H, Vn.8H + /// int16x8_t vabsq_s16 (int16x8_t a) + /// A32: VABS.S16 Qd, Qm + /// A64: ABS Vd.8H, Vn.8H /// public static Vector128 Abs(Vector128 value) => Abs(value); /// - /// int32x4_t vabsq_s32 (int32x4_t a) - /// A32: VABS.S32 Qd, Qm - /// A64: ABS Vd.4S, Vn.4S + /// int32x4_t vabsq_s32 (int32x4_t a) + /// A32: VABS.S32 Qd, Qm + /// A64: ABS Vd.4S, Vn.4S /// public static Vector128 Abs(Vector128 value) => Abs(value); /// - /// int8x16_t vabsq_s8 (int8x16_t a) - /// A32: VABS.S8 Qd, Qm - /// A64: ABS Vd.16B, Vn.16B + /// int8x16_t vabsq_s8 (int8x16_t a) + /// A32: VABS.S8 Qd, Qm + /// A64: ABS Vd.16B, Vn.16B /// public static Vector128 Abs(Vector128 value) => Abs(value); /// - /// float32x4_t vabsq_f32 (float32x4_t a) - /// A32: VABS.F32 Qd, Qm - /// A64: FABS Vd.4S, Vn.4S + /// float32x4_t vabsq_f32 (float32x4_t a) + /// A32: VABS.F32 Qd, Qm + /// A64: FABS Vd.4S, Vn.4S /// public static Vector128 Abs(Vector128 value) => Abs(value); /// - /// int16x4_t vqabs_s16 (int16x4_t a) - /// A32: VQABS.S16 Dd, Dm - /// A64: SQABS Vd.4H, Vn.4H + /// int16x4_t vqabs_s16 (int16x4_t a) + /// A32: VQABS.S16 Dd, Dm + /// A64: SQABS Vd.4H, Vn.4H /// public static Vector64 AbsSaturate(Vector64 value) => AbsSaturate(value); /// - /// int32x2_t vqabs_s32 (int32x2_t a) - /// A32: VQABS.S32 Dd, Dm - /// A64: SQABS Vd.2S, Vn.2S + /// int32x2_t vqabs_s32 (int32x2_t a) + /// A32: VQABS.S32 Dd, Dm + /// A64: SQABS Vd.2S, Vn.2S /// public static Vector64 AbsSaturate(Vector64 value) => AbsSaturate(value); /// - /// int8x8_t vqabs_s8 (int8x8_t a) - /// A32: VQABS.S8 Dd, Dm - /// A64: SQABS Vd.8B, Vn.8B + /// int8x8_t vqabs_s8 (int8x8_t a) + /// A32: VQABS.S8 Dd, Dm + /// A64: SQABS Vd.8B, Vn.8B /// public static Vector64 AbsSaturate(Vector64 value) => AbsSaturate(value); /// - /// int16x8_t vqabsq_s16 (int16x8_t a) - /// A32: VQABS.S16 Qd, Qm - /// A64: SQABS Vd.8H, Vn.8H + /// int16x8_t vqabsq_s16 (int16x8_t a) + /// A32: VQABS.S16 Qd, Qm + /// A64: SQABS Vd.8H, Vn.8H /// public static Vector128 AbsSaturate(Vector128 value) => AbsSaturate(value); /// - /// int32x4_t vqabsq_s32 (int32x4_t a) - /// A32: VQABS.S32 Qd, Qm - /// A64: SQABS Vd.4S, Vn.4S + /// int32x4_t vqabsq_s32 (int32x4_t a) + /// A32: VQABS.S32 Qd, Qm + /// A64: SQABS Vd.4S, Vn.4S /// public static Vector128 AbsSaturate(Vector128 value) => AbsSaturate(value); /// - /// int8x16_t vqabsq_s8 (int8x16_t a) - /// A32: VQABS.S8 Qd, Qm - /// A64: SQABS Vd.16B, Vn.16B + /// int8x16_t vqabsq_s8 (int8x16_t a) + /// A32: VQABS.S8 Qd, Qm + /// A64: SQABS Vd.16B, Vn.16B /// public static Vector128 AbsSaturate(Vector128 value) => AbsSaturate(value); /// - /// float64x1_t vabs_f64 (float64x1_t a) - /// A32: VABS.F64 Dd, Dm - /// A64: FABS Dd, Dn + /// float64x1_t vabs_f64 (float64x1_t a) + /// A32: VABS.F64 Dd, Dm + /// A64: FABS Dd, Dn /// public static Vector64 AbsScalar(Vector64 value) => AbsScalar(value); /// - /// float32_t vabss_f32 (float32_t a) - /// A32: VABS.F32 Sd, Sm - /// A64: FABS Sd, Sn - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vabss_f32 (float32_t a) + /// A32: VABS.F32 Sd, Sm + /// A64: FABS Sd, Sn + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 AbsScalar(Vector64 value) => AbsScalar(value); /// - /// uint32x2_t vcagt_f32 (float32x2_t a, float32x2_t b) - /// A32: VACGT.F32 Dd, Dn, Dm - /// A64: FACGT Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcagt_f32 (float32x2_t a, float32x2_t b) + /// A32: VACGT.F32 Dd, Dn, Dm + /// A64: FACGT Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AbsoluteCompareGreaterThan(Vector64 left, Vector64 right) => AbsoluteCompareGreaterThan(left, right); /// - /// uint32x4_t vcagtq_f32 (float32x4_t a, float32x4_t b) - /// A32: VACGT.F32 Qd, Qn, Qm - /// A64: FACGT Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcagtq_f32 (float32x4_t a, float32x4_t b) + /// A32: VACGT.F32 Qd, Qn, Qm + /// A64: FACGT Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AbsoluteCompareGreaterThan(Vector128 left, Vector128 right) => AbsoluteCompareGreaterThan(left, right); /// - /// uint32x2_t vcage_f32 (float32x2_t a, float32x2_t b) - /// A32: VACGE.F32 Dd, Dn, Dm - /// A64: FACGE Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcage_f32 (float32x2_t a, float32x2_t b) + /// A32: VACGE.F32 Dd, Dn, Dm + /// A64: FACGE Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AbsoluteCompareGreaterThanOrEqual(Vector64 left, Vector64 right) => AbsoluteCompareGreaterThanOrEqual(left, right); /// - /// uint32x4_t vcageq_f32 (float32x4_t a, float32x4_t b) - /// A32: VACGE.F32 Qd, Qn, Qm - /// A64: FACGE Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcageq_f32 (float32x4_t a, float32x4_t b) + /// A32: VACGE.F32 Qd, Qn, Qm + /// A64: FACGE Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AbsoluteCompareGreaterThanOrEqual(Vector128 left, Vector128 right) => AbsoluteCompareGreaterThanOrEqual(left, right); /// - /// uint32x2_t vcalt_f32 (float32x2_t a, float32x2_t b) - /// A32: VACLT.F32 Dd, Dn, Dm - /// A64: FACGT Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcalt_f32 (float32x2_t a, float32x2_t b) + /// A32: VACLT.F32 Dd, Dn, Dm + /// A64: FACGT Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AbsoluteCompareLessThan(Vector64 left, Vector64 right) => AbsoluteCompareLessThan(left, right); /// - /// uint32x4_t vcaltq_f32 (float32x4_t a, float32x4_t b) - /// A32: VACLT.F32 Qd, Qn, Qm - /// A64: FACGT Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcaltq_f32 (float32x4_t a, float32x4_t b) + /// A32: VACLT.F32 Qd, Qn, Qm + /// A64: FACGT Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AbsoluteCompareLessThan(Vector128 left, Vector128 right) => AbsoluteCompareLessThan(left, right); /// - /// uint32x2_t vcale_f32 (float32x2_t a, float32x2_t b) - /// A32: VACLE.F32 Dd, Dn, Dm - /// A64: FACGE Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcale_f32 (float32x2_t a, float32x2_t b) + /// A32: VACLE.F32 Dd, Dn, Dm + /// A64: FACGE Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AbsoluteCompareLessThanOrEqual(Vector64 left, Vector64 right) => AbsoluteCompareLessThanOrEqual(left, right); /// - /// uint32x4_t vcaleq_f32 (float32x4_t a, float32x4_t b) - /// A32: VACLE.F32 Qd, Qn, Qm - /// A64: FACGE Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcaleq_f32 (float32x4_t a, float32x4_t b) + /// A32: VACLE.F32 Qd, Qn, Qm + /// A64: FACGE Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AbsoluteCompareLessThanOrEqual(Vector128 left, Vector128 right) => AbsoluteCompareLessThanOrEqual(left, right); /// - /// uint8x8_t vabd_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VABD.U8 Dd, Dn, Dm - /// A64: UABD Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vabd_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VABD.U8 Dd, Dn, Dm + /// A64: UABD Vd.8B, Vn.8B, Vm.8B /// public static Vector64 AbsoluteDifference(Vector64 left, Vector64 right) => AbsoluteDifference(left, right); /// - /// int16x4_t vabd_s16 (int16x4_t a, int16x4_t b) - /// A32: VABD.S16 Dd, Dn, Dm - /// A64: SABD Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vabd_s16 (int16x4_t a, int16x4_t b) + /// A32: VABD.S16 Dd, Dn, Dm + /// A64: SABD Vd.4H, Vn.4H, Vm.4H /// public static Vector64 AbsoluteDifference(Vector64 left, Vector64 right) => AbsoluteDifference(left, right); /// - /// int32x2_t vabd_s32 (int32x2_t a, int32x2_t b) - /// A32: VABD.S32 Dd, Dn, Dm - /// A64: SABD Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vabd_s32 (int32x2_t a, int32x2_t b) + /// A32: VABD.S32 Dd, Dn, Dm + /// A64: SABD Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AbsoluteDifference(Vector64 left, Vector64 right) => AbsoluteDifference(left, right); /// - /// int8x8_t vabd_s8 (int8x8_t a, int8x8_t b) - /// A32: VABD.S8 Dd, Dn, Dm - /// A64: SABD Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vabd_s8 (int8x8_t a, int8x8_t b) + /// A32: VABD.S8 Dd, Dn, Dm + /// A64: SABD Vd.8B, Vn.8B, Vm.8B /// public static Vector64 AbsoluteDifference(Vector64 left, Vector64 right) => AbsoluteDifference(left, right); /// - /// float32x2_t vabd_f32 (float32x2_t a, float32x2_t b) - /// A32: VABD.F32 Dd, Dn, Dm - /// A64: FABD Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vabd_f32 (float32x2_t a, float32x2_t b) + /// A32: VABD.F32 Dd, Dn, Dm + /// A64: FABD Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AbsoluteDifference(Vector64 left, Vector64 right) => AbsoluteDifference(left, right); /// - /// uint16x4_t vabd_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VABD.U16 Dd, Dn, Dm - /// A64: UABD Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vabd_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VABD.U16 Dd, Dn, Dm + /// A64: UABD Vd.4H, Vn.4H, Vm.4H /// public static Vector64 AbsoluteDifference(Vector64 left, Vector64 right) => AbsoluteDifference(left, right); /// - /// uint32x2_t vabd_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VABD.U32 Dd, Dn, Dm - /// A64: UABD Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vabd_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VABD.U32 Dd, Dn, Dm + /// A64: UABD Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AbsoluteDifference(Vector64 left, Vector64 right) => AbsoluteDifference(left, right); /// - /// uint8x16_t vabdq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VABD.U8 Qd, Qn, Qm - /// A64: UABD Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vabdq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VABD.U8 Qd, Qn, Qm + /// A64: UABD Vd.16B, Vn.16B, Vm.16B /// public static Vector128 AbsoluteDifference(Vector128 left, Vector128 right) => AbsoluteDifference(left, right); /// - /// int16x8_t vabdq_s16 (int16x8_t a, int16x8_t b) - /// A32: VABD.S16 Qd, Qn, Qm - /// A64: SABD Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vabdq_s16 (int16x8_t a, int16x8_t b) + /// A32: VABD.S16 Qd, Qn, Qm + /// A64: SABD Vd.8H, Vn.8H, Vm.8H /// public static Vector128 AbsoluteDifference(Vector128 left, Vector128 right) => AbsoluteDifference(left, right); /// - /// int32x4_t vabdq_s32 (int32x4_t a, int32x4_t b) - /// A32: VABD.S32 Qd, Qn, Qm - /// A64: SABD Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vabdq_s32 (int32x4_t a, int32x4_t b) + /// A32: VABD.S32 Qd, Qn, Qm + /// A64: SABD Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AbsoluteDifference(Vector128 left, Vector128 right) => AbsoluteDifference(left, right); /// - /// int8x16_t vabdq_s8 (int8x16_t a, int8x16_t b) - /// A32: VABD.S8 Qd, Qn, Qm - /// A64: SABD Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vabdq_s8 (int8x16_t a, int8x16_t b) + /// A32: VABD.S8 Qd, Qn, Qm + /// A64: SABD Vd.16B, Vn.16B, Vm.16B /// public static Vector128 AbsoluteDifference(Vector128 left, Vector128 right) => AbsoluteDifference(left, right); /// - /// float32x4_t vabdq_f32 (float32x4_t a, float32x4_t b) - /// A32: VABD.F32 Qd, Qn, Qm - /// A64: FABD Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vabdq_f32 (float32x4_t a, float32x4_t b) + /// A32: VABD.F32 Qd, Qn, Qm + /// A64: FABD Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AbsoluteDifference(Vector128 left, Vector128 right) => AbsoluteDifference(left, right); /// - /// uint16x8_t vabdq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VABD.U16 Qd, Qn, Qm - /// A64: UABD Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vabdq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VABD.U16 Qd, Qn, Qm + /// A64: UABD Vd.8H, Vn.8H, Vm.8H /// public static Vector128 AbsoluteDifference(Vector128 left, Vector128 right) => AbsoluteDifference(left, right); /// - /// uint32x4_t vabdq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VABD.U32 Qd, Qn, Qm - /// A64: UABD Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vabdq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VABD.U32 Qd, Qn, Qm + /// A64: UABD Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AbsoluteDifference(Vector128 left, Vector128 right) => AbsoluteDifference(left, right); /// - /// uint8x8_t vaba_u8 (uint8x8_t a, uint8x8_t b, uint8x8_t c) - /// A32: VABA.U8 Dd, Dn, Dm - /// A64: UABA Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vaba_u8 (uint8x8_t a, uint8x8_t b, uint8x8_t c) + /// A32: VABA.U8 Dd, Dn, Dm + /// A64: UABA Vd.8B, Vn.8B, Vm.8B /// public static Vector64 AbsoluteDifferenceAdd(Vector64 addend, Vector64 left, Vector64 right) => AbsoluteDifferenceAdd(addend, left, right); /// - /// int16x4_t vaba_s16 (int16x4_t a, int16x4_t b, int16x4_t c) - /// A32: VABA.S16 Dd, Dn, Dm - /// A64: SABA Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vaba_s16 (int16x4_t a, int16x4_t b, int16x4_t c) + /// A32: VABA.S16 Dd, Dn, Dm + /// A64: SABA Vd.4H, Vn.4H, Vm.4H /// public static Vector64 AbsoluteDifferenceAdd(Vector64 addend, Vector64 left, Vector64 right) => AbsoluteDifferenceAdd(addend, left, right); /// - /// int32x2_t vaba_s32 (int32x2_t a, int32x2_t b, int32x2_t c) - /// A32: VABA.S32 Dd, Dn, Dm - /// A64: SABA Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vaba_s32 (int32x2_t a, int32x2_t b, int32x2_t c) + /// A32: VABA.S32 Dd, Dn, Dm + /// A64: SABA Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AbsoluteDifferenceAdd(Vector64 addend, Vector64 left, Vector64 right) => AbsoluteDifferenceAdd(addend, left, right); /// - /// int8x8_t vaba_s8 (int8x8_t a, int8x8_t b, int8x8_t c) - /// A32: VABA.S8 Dd, Dn, Dm - /// A64: SABA Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vaba_s8 (int8x8_t a, int8x8_t b, int8x8_t c) + /// A32: VABA.S8 Dd, Dn, Dm + /// A64: SABA Vd.8B, Vn.8B, Vm.8B /// public static Vector64 AbsoluteDifferenceAdd(Vector64 addend, Vector64 left, Vector64 right) => AbsoluteDifferenceAdd(addend, left, right); /// - /// uint16x4_t vaba_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t c) - /// A32: VABA.U16 Dd, Dn, Dm - /// A64: UABA Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vaba_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t c) + /// A32: VABA.U16 Dd, Dn, Dm + /// A64: UABA Vd.4H, Vn.4H, Vm.4H /// public static Vector64 AbsoluteDifferenceAdd(Vector64 addend, Vector64 left, Vector64 right) => AbsoluteDifferenceAdd(addend, left, right); /// - /// uint32x2_t vaba_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t c) - /// A32: VABA.U32 Dd, Dn, Dm - /// A64: UABA Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vaba_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t c) + /// A32: VABA.U32 Dd, Dn, Dm + /// A64: UABA Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AbsoluteDifferenceAdd(Vector64 addend, Vector64 left, Vector64 right) => AbsoluteDifferenceAdd(addend, left, right); /// - /// uint8x16_t vabaq_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c) - /// A32: VABA.U8 Qd, Qn, Qm - /// A64: UABA Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vabaq_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c) + /// A32: VABA.U8 Qd, Qn, Qm + /// A64: UABA Vd.16B, Vn.16B, Vm.16B /// public static Vector128 AbsoluteDifferenceAdd(Vector128 addend, Vector128 left, Vector128 right) => AbsoluteDifferenceAdd(addend, left, right); /// - /// int16x8_t vabaq_s16 (int16x8_t a, int16x8_t b, int16x8_t c) - /// A32: VABA.S16 Qd, Qn, Qm - /// A64: SABA Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vabaq_s16 (int16x8_t a, int16x8_t b, int16x8_t c) + /// A32: VABA.S16 Qd, Qn, Qm + /// A64: SABA Vd.8H, Vn.8H, Vm.8H /// public static Vector128 AbsoluteDifferenceAdd(Vector128 addend, Vector128 left, Vector128 right) => AbsoluteDifferenceAdd(addend, left, right); /// - /// int32x4_t vabaq_s32 (int32x4_t a, int32x4_t b, int32x4_t c) - /// A32: VABA.S32 Qd, Qn, Qm - /// A64: SABA Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vabaq_s32 (int32x4_t a, int32x4_t b, int32x4_t c) + /// A32: VABA.S32 Qd, Qn, Qm + /// A64: SABA Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AbsoluteDifferenceAdd(Vector128 addend, Vector128 left, Vector128 right) => AbsoluteDifferenceAdd(addend, left, right); /// - /// int8x16_t vabaq_s8 (int8x16_t a, int8x16_t b, int8x16_t c) - /// A32: VABA.S8 Qd, Qn, Qm - /// A64: SABA Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vabaq_s8 (int8x16_t a, int8x16_t b, int8x16_t c) + /// A32: VABA.S8 Qd, Qn, Qm + /// A64: SABA Vd.16B, Vn.16B, Vm.16B /// public static Vector128 AbsoluteDifferenceAdd(Vector128 addend, Vector128 left, Vector128 right) => AbsoluteDifferenceAdd(addend, left, right); /// - /// uint16x8_t vabaq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c) - /// A32: VABA.U16 Qd, Qn, Qm - /// A64: UABA Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vabaq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c) + /// A32: VABA.U16 Qd, Qn, Qm + /// A64: UABA Vd.8H, Vn.8H, Vm.8H /// public static Vector128 AbsoluteDifferenceAdd(Vector128 addend, Vector128 left, Vector128 right) => AbsoluteDifferenceAdd(addend, left, right); /// - /// uint32x4_t vabaq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c) - /// A32: VABA.U32 Qd, Qn, Qm - /// A64: UABA Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vabaq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c) + /// A32: VABA.U32 Qd, Qn, Qm + /// A64: UABA Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AbsoluteDifferenceAdd(Vector128 addend, Vector128 left, Vector128 right) => AbsoluteDifferenceAdd(addend, left, right); /// - /// uint16x8_t vabdl_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VABDL.U8 Qd, Dn, Dm - /// A64: UABDL Vd.8H, Vn.8B, Vm.8B + /// uint16x8_t vabdl_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VABDL.U8 Qd, Dn, Dm + /// A64: UABDL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 AbsoluteDifferenceWideningLower(Vector64 left, Vector64 right) => AbsoluteDifferenceWideningLower(left, right); /// - /// int32x4_t vabdl_s16 (int16x4_t a, int16x4_t b) - /// A32: VABDL.S16 Qd, Dn, Dm - /// A64: SABDL Vd.4S, Vn.4H, Vm.4H + /// int32x4_t vabdl_s16 (int16x4_t a, int16x4_t b) + /// A32: VABDL.S16 Qd, Dn, Dm + /// A64: SABDL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 AbsoluteDifferenceWideningLower(Vector64 left, Vector64 right) => AbsoluteDifferenceWideningLower(left, right); /// - /// int64x2_t vabdl_s32 (int32x2_t a, int32x2_t b) - /// A32: VABDL.S32 Qd, Dn, Dm - /// A64: SABDL Vd.2D, Vn.2S, Vm.2S + /// int64x2_t vabdl_s32 (int32x2_t a, int32x2_t b) + /// A32: VABDL.S32 Qd, Dn, Dm + /// A64: SABDL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 AbsoluteDifferenceWideningLower(Vector64 left, Vector64 right) => AbsoluteDifferenceWideningLower(left, right); /// - /// int16x8_t vabdl_s8 (int8x8_t a, int8x8_t b) - /// A32: VABDL.S8 Qd, Dn, Dm - /// A64: SABDL Vd.8H, Vn.8B, Vm.8B + /// int16x8_t vabdl_s8 (int8x8_t a, int8x8_t b) + /// A32: VABDL.S8 Qd, Dn, Dm + /// A64: SABDL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 AbsoluteDifferenceWideningLower(Vector64 left, Vector64 right) => AbsoluteDifferenceWideningLower(left, right); /// - /// uint32x4_t vabdl_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VABDL.U16 Qd, Dn, Dm - /// A64: UABDL Vd.4S, Vn.4H, Vm.4H + /// uint32x4_t vabdl_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VABDL.U16 Qd, Dn, Dm + /// A64: UABDL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 AbsoluteDifferenceWideningLower(Vector64 left, Vector64 right) => AbsoluteDifferenceWideningLower(left, right); /// - /// uint64x2_t vabdl_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VABDL.U32 Qd, Dn, Dm - /// A64: UABDL Vd.2D, Vn.2S, Vm.2S + /// uint64x2_t vabdl_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VABDL.U32 Qd, Dn, Dm + /// A64: UABDL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 AbsoluteDifferenceWideningLower(Vector64 left, Vector64 right) => AbsoluteDifferenceWideningLower(left, right); /// - /// uint16x8_t vabal_u8 (uint16x8_t a, uint8x8_t b, uint8x8_t c) - /// A32: VABAL.U8 Qd, Dn, Dm - /// A64: UABAL Vd.8H, Vn.8B, Vm.8B + /// uint16x8_t vabal_u8 (uint16x8_t a, uint8x8_t b, uint8x8_t c) + /// A32: VABAL.U8 Qd, Dn, Dm + /// A64: UABAL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 AbsoluteDifferenceWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right) => AbsoluteDifferenceWideningLowerAndAdd(addend, left, right); /// - /// int32x4_t vabal_s16 (int32x4_t a, int16x4_t b, int16x4_t c) - /// A32: VABAL.S16 Qd, Dn, Dm - /// A64: SABAL Vd.4S, Vn.4H, Vm.4H + /// int32x4_t vabal_s16 (int32x4_t a, int16x4_t b, int16x4_t c) + /// A32: VABAL.S16 Qd, Dn, Dm + /// A64: SABAL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 AbsoluteDifferenceWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right) => AbsoluteDifferenceWideningLowerAndAdd(addend, left, right); /// - /// int64x2_t vabal_s32 (int64x2_t a, int32x2_t b, int32x2_t c) - /// A32: VABAL.S32 Qd, Dn, Dm - /// A64: SABAL Vd.2D, Vn.2S, Vm.2S + /// int64x2_t vabal_s32 (int64x2_t a, int32x2_t b, int32x2_t c) + /// A32: VABAL.S32 Qd, Dn, Dm + /// A64: SABAL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 AbsoluteDifferenceWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right) => AbsoluteDifferenceWideningLowerAndAdd(addend, left, right); /// - /// int16x8_t vabal_s8 (int16x8_t a, int8x8_t b, int8x8_t c) - /// A32: VABAL.S8 Qd, Dn, Dm - /// A64: SABAL Vd.8H, Vn.8B, Vm.8B + /// int16x8_t vabal_s8 (int16x8_t a, int8x8_t b, int8x8_t c) + /// A32: VABAL.S8 Qd, Dn, Dm + /// A64: SABAL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 AbsoluteDifferenceWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right) => AbsoluteDifferenceWideningLowerAndAdd(addend, left, right); /// - /// uint32x4_t vabal_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t c) - /// A32: VABAL.U16 Qd, Dn, Dm - /// A64: UABAL Vd.4S, Vn.4H, Vm.4H + /// uint32x4_t vabal_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t c) + /// A32: VABAL.U16 Qd, Dn, Dm + /// A64: UABAL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 AbsoluteDifferenceWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right) => AbsoluteDifferenceWideningLowerAndAdd(addend, left, right); /// - /// uint64x2_t vabal_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t c) - /// A32: VABAL.U32 Qd, Dn, Dm - /// A64: UABAL Vd.2D, Vn.2S, Vm.2S + /// uint64x2_t vabal_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t c) + /// A32: VABAL.U32 Qd, Dn, Dm + /// A64: UABAL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 AbsoluteDifferenceWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right) => AbsoluteDifferenceWideningLowerAndAdd(addend, left, right); /// - /// uint16x8_t vabdl_high_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VABDL.U8 Qd, Dn+1, Dm+1 - /// A64: UABDL2 Vd.8H, Vn.16B, Vm.16B + /// uint16x8_t vabdl_high_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VABDL.U8 Qd, Dn+1, Dm+1 + /// A64: UABDL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 AbsoluteDifferenceWideningUpper(Vector128 left, Vector128 right) => AbsoluteDifferenceWideningUpper(left, right); /// - /// int32x4_t vabdl_high_s16 (int16x8_t a, int16x8_t b) - /// A32: VABDL.S16 Qd, Dn+1, Dm+1 - /// A64: SABDL2 Vd.4S, Vn.8H, Vm.8H + /// int32x4_t vabdl_high_s16 (int16x8_t a, int16x8_t b) + /// A32: VABDL.S16 Qd, Dn+1, Dm+1 + /// A64: SABDL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 AbsoluteDifferenceWideningUpper(Vector128 left, Vector128 right) => AbsoluteDifferenceWideningUpper(left, right); /// - /// int64x2_t vabdl_high_s32 (int32x4_t a, int32x4_t b) - /// A32: VABDL.S32 Qd, Dn+1, Dm+1 - /// A64: SABDL2 Vd.2D, Vn.4S, Vm.4S + /// int64x2_t vabdl_high_s32 (int32x4_t a, int32x4_t b) + /// A32: VABDL.S32 Qd, Dn+1, Dm+1 + /// A64: SABDL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 AbsoluteDifferenceWideningUpper(Vector128 left, Vector128 right) => AbsoluteDifferenceWideningUpper(left, right); /// - /// int16x8_t vabdl_high_s8 (int8x16_t a, int8x16_t b) - /// A32: VABDL.S8 Qd, Dn+1, Dm+1 - /// A64: SABDL2 Vd.8H, Vn.16B, Vm.16B + /// int16x8_t vabdl_high_s8 (int8x16_t a, int8x16_t b) + /// A32: VABDL.S8 Qd, Dn+1, Dm+1 + /// A64: SABDL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 AbsoluteDifferenceWideningUpper(Vector128 left, Vector128 right) => AbsoluteDifferenceWideningUpper(left, right); /// - /// uint32x4_t vabdl_high_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VABDL.U16 Qd, Dn+1, Dm+1 - /// A64: UABDL2 Vd.4S, Vn.8H, Vm.8H + /// uint32x4_t vabdl_high_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VABDL.U16 Qd, Dn+1, Dm+1 + /// A64: UABDL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 AbsoluteDifferenceWideningUpper(Vector128 left, Vector128 right) => AbsoluteDifferenceWideningUpper(left, right); /// - /// uint64x2_t vabdl_high_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VABDL.U32 Qd, Dn+1, Dm+1 - /// A64: UABDL2 Vd.2D, Vn.4S, Vm.4S + /// uint64x2_t vabdl_high_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VABDL.U32 Qd, Dn+1, Dm+1 + /// A64: UABDL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 AbsoluteDifferenceWideningUpper(Vector128 left, Vector128 right) => AbsoluteDifferenceWideningUpper(left, right); /// - /// uint16x8_t vabal_high_u8 (uint16x8_t a, uint8x16_t b, uint8x16_t c) - /// A32: VABAL.U8 Qd, Dn+1, Dm+1 - /// A64: UABAL2 Vd.8H, Vn.16B, Vm.16B + /// uint16x8_t vabal_high_u8 (uint16x8_t a, uint8x16_t b, uint8x16_t c) + /// A32: VABAL.U8 Qd, Dn+1, Dm+1 + /// A64: UABAL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 AbsoluteDifferenceWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right) => AbsoluteDifferenceWideningUpperAndAdd(addend, left, right); /// - /// int32x4_t vabal_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c) - /// A32: VABAL.S16 Qd, Dn+1, Dm+1 - /// A64: SABAL2 Vd.4S, Vn.8H, Vm.8H + /// int32x4_t vabal_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c) + /// A32: VABAL.S16 Qd, Dn+1, Dm+1 + /// A64: SABAL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 AbsoluteDifferenceWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right) => AbsoluteDifferenceWideningUpperAndAdd(addend, left, right); /// - /// int64x2_t vabal_high_s32 (int64x2_t a, int32x4_t b, int32x4_t c) - /// A32: VABAL.S32 Qd, Dn+1, Dm+1 - /// A64: SABAL2 Vd.2D, Vn.4S, Vm.4S + /// int64x2_t vabal_high_s32 (int64x2_t a, int32x4_t b, int32x4_t c) + /// A32: VABAL.S32 Qd, Dn+1, Dm+1 + /// A64: SABAL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 AbsoluteDifferenceWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right) => AbsoluteDifferenceWideningUpperAndAdd(addend, left, right); /// - /// int16x8_t vabal_high_s8 (int16x8_t a, int8x16_t b, int8x16_t c) - /// A32: VABAL.S8 Qd, Dn+1, Dm+1 - /// A64: SABAL2 Vd.8H, Vn.16B, Vm.16B + /// int16x8_t vabal_high_s8 (int16x8_t a, int8x16_t b, int8x16_t c) + /// A32: VABAL.S8 Qd, Dn+1, Dm+1 + /// A64: SABAL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 AbsoluteDifferenceWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right) => AbsoluteDifferenceWideningUpperAndAdd(addend, left, right); /// - /// uint32x4_t vabal_high_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t c) - /// A32: VABAL.U16 Qd, Dn+1, Dm+1 - /// A64: UABAL2 Vd.4S, Vn.8H, Vm.8H + /// uint32x4_t vabal_high_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t c) + /// A32: VABAL.U16 Qd, Dn+1, Dm+1 + /// A64: UABAL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 AbsoluteDifferenceWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right) => AbsoluteDifferenceWideningUpperAndAdd(addend, left, right); /// - /// uint64x2_t vabal_high_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t c) - /// A32: VABAL.U32 Qd, Dn+1, Dm+1 - /// A64: UABAL2 Vd.2D, Vn.4S, Vm.4S + /// uint64x2_t vabal_high_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t c) + /// A32: VABAL.U32 Qd, Dn+1, Dm+1 + /// A64: UABAL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 AbsoluteDifferenceWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right) => AbsoluteDifferenceWideningUpperAndAdd(addend, left, right); /// - /// uint8x8_t vadd_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VADD.I8 Dd, Dn, Dm - /// A64: ADD Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vadd_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VADD.I8 Dd, Dn, Dm + /// A64: ADD Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Add(Vector64 left, Vector64 right) => Add(left, right); /// - /// int16x4_t vadd_s16 (int16x4_t a, int16x4_t b) - /// A32: VADD.I16 Dd, Dn, Dm - /// A64: ADD Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vadd_s16 (int16x4_t a, int16x4_t b) + /// A32: VADD.I16 Dd, Dn, Dm + /// A64: ADD Vd.4H, Vn.4H, Vm.4H /// public static Vector64 Add(Vector64 left, Vector64 right) => Add(left, right); /// - /// int32x2_t vadd_s32 (int32x2_t a, int32x2_t b) - /// A32: VADD.I32 Dd, Dn, Dm - /// A64: ADD Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vadd_s32 (int32x2_t a, int32x2_t b) + /// A32: VADD.I32 Dd, Dn, Dm + /// A64: ADD Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Add(Vector64 left, Vector64 right) => Add(left, right); /// - /// int8x8_t vadd_s8 (int8x8_t a, int8x8_t b) - /// A32: VADD.I8 Dd, Dn, Dm - /// A64: ADD Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vadd_s8 (int8x8_t a, int8x8_t b) + /// A32: VADD.I8 Dd, Dn, Dm + /// A64: ADD Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Add(Vector64 left, Vector64 right) => Add(left, right); /// - /// float32x2_t vadd_f32 (float32x2_t a, float32x2_t b) - /// A32: VADD.F32 Dd, Dn, Dm - /// A64: FADD Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vadd_f32 (float32x2_t a, float32x2_t b) + /// A32: VADD.F32 Dd, Dn, Dm + /// A64: FADD Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Add(Vector64 left, Vector64 right) => Add(left, right); /// - /// uint16x4_t vadd_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VADD.I16 Dd, Dn, Dm - /// A64: ADD Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vadd_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VADD.I16 Dd, Dn, Dm + /// A64: ADD Vd.4H, Vn.4H, Vm.4H /// public static Vector64 Add(Vector64 left, Vector64 right) => Add(left, right); /// - /// uint32x2_t vadd_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VADD.I32 Dd, Dn, Dm - /// A64: ADD Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vadd_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VADD.I32 Dd, Dn, Dm + /// A64: ADD Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Add(Vector64 left, Vector64 right) => Add(left, right); /// - /// uint8x16_t vaddq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VADD.I8 Qd, Qn, Qm - /// A64: ADD Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vaddq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VADD.I8 Qd, Qn, Qm + /// A64: ADD Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// - /// int16x8_t vaddq_s16 (int16x8_t a, int16x8_t b) - /// A32: VADD.I16 Qd, Qn, Qm - /// A64: ADD Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vaddq_s16 (int16x8_t a, int16x8_t b) + /// A32: VADD.I16 Qd, Qn, Qm + /// A64: ADD Vd.8H, Vn.8H, Vm.8H /// public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// - /// int32x4_t vaddq_s32 (int32x4_t a, int32x4_t b) - /// A32: VADD.I32 Qd, Qn, Qm - /// A64: ADD Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vaddq_s32 (int32x4_t a, int32x4_t b) + /// A32: VADD.I32 Qd, Qn, Qm + /// A64: ADD Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// - /// int64x2_t vaddq_s64 (int64x2_t a, int64x2_t b) - /// A32: VADD.I64 Qd, Qn, Qm - /// A64: ADD Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vaddq_s64 (int64x2_t a, int64x2_t b) + /// A32: VADD.I64 Qd, Qn, Qm + /// A64: ADD Vd.2D, Vn.2D, Vm.2D /// public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// - /// int8x16_t vaddq_s8 (int8x16_t a, int8x16_t b) - /// A32: VADD.I8 Qd, Qn, Qm - /// A64: ADD Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vaddq_s8 (int8x16_t a, int8x16_t b) + /// A32: VADD.I8 Qd, Qn, Qm + /// A64: ADD Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// - /// float32x4_t vaddq_f32 (float32x4_t a, float32x4_t b) - /// A32: VADD.F32 Qd, Qn, Qm - /// A64: FADD Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vaddq_f32 (float32x4_t a, float32x4_t b) + /// A32: VADD.F32 Qd, Qn, Qm + /// A64: FADD Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// - /// uint16x8_t vaddq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VADD.I16 Qd, Qn, Qm - /// A64: ADD Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vaddq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VADD.I16 Qd, Qn, Qm + /// A64: ADD Vd.8H, Vn.8H, Vm.8H /// public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// - /// uint32x4_t vaddq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VADD.I32 Qd, Qn, Qm - /// A64: ADD Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vaddq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VADD.I32 Qd, Qn, Qm + /// A64: ADD Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// - /// uint64x2_t vaddq_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VADD.I64 Qd, Qn, Qm - /// A64: ADD Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vaddq_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VADD.I64 Qd, Qn, Qm + /// A64: ADD Vd.2D, Vn.2D, Vm.2D /// public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// - /// uint8x8_t vaddhn_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VADDHN.I16 Dd, Qn, Qm - /// A64: ADDHN Vd.8B, Vn.8H, Vm.8H + /// uint8x8_t vaddhn_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VADDHN.I16 Dd, Qn, Qm + /// A64: ADDHN Vd.8B, Vn.8H, Vm.8H /// public static Vector64 AddHighNarrowingLower(Vector128 left, Vector128 right) => AddHighNarrowingLower(left, right); /// - /// int16x4_t vaddhn_s32 (int32x4_t a, int32x4_t b) - /// A32: VADDHN.I32 Dd, Qn, Qm - /// A64: ADDHN Vd.4H, Vn.4S, Vm.4S + /// int16x4_t vaddhn_s32 (int32x4_t a, int32x4_t b) + /// A32: VADDHN.I32 Dd, Qn, Qm + /// A64: ADDHN Vd.4H, Vn.4S, Vm.4S /// public static Vector64 AddHighNarrowingLower(Vector128 left, Vector128 right) => AddHighNarrowingLower(left, right); /// - /// int32x2_t vaddhn_s64 (int64x2_t a, int64x2_t b) - /// A32: VADDHN.I64 Dd, Qn, Qm - /// A64: ADDHN Vd.2S, Vn.2D, Vm.2D + /// int32x2_t vaddhn_s64 (int64x2_t a, int64x2_t b) + /// A32: VADDHN.I64 Dd, Qn, Qm + /// A64: ADDHN Vd.2S, Vn.2D, Vm.2D /// public static Vector64 AddHighNarrowingLower(Vector128 left, Vector128 right) => AddHighNarrowingLower(left, right); /// - /// int8x8_t vaddhn_s16 (int16x8_t a, int16x8_t b) - /// A32: VADDHN.I16 Dd, Qn, Qm - /// A64: ADDHN Vd.8B, Vn.8H, Vm.8H + /// int8x8_t vaddhn_s16 (int16x8_t a, int16x8_t b) + /// A32: VADDHN.I16 Dd, Qn, Qm + /// A64: ADDHN Vd.8B, Vn.8H, Vm.8H /// public static Vector64 AddHighNarrowingLower(Vector128 left, Vector128 right) => AddHighNarrowingLower(left, right); /// - /// uint16x4_t vaddhn_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VADDHN.I32 Dd, Qn, Qm - /// A64: ADDHN Vd.4H, Vn.4S, Vm.4S + /// uint16x4_t vaddhn_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VADDHN.I32 Dd, Qn, Qm + /// A64: ADDHN Vd.4H, Vn.4S, Vm.4S /// public static Vector64 AddHighNarrowingLower(Vector128 left, Vector128 right) => AddHighNarrowingLower(left, right); /// - /// uint32x2_t vaddhn_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VADDHN.I64 Dd, Qn, Qm - /// A64: ADDHN Vd.2S, Vn.2D, Vm.2D + /// uint32x2_t vaddhn_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VADDHN.I64 Dd, Qn, Qm + /// A64: ADDHN Vd.2S, Vn.2D, Vm.2D /// public static Vector64 AddHighNarrowingLower(Vector128 left, Vector128 right) => AddHighNarrowingLower(left, right); /// - /// uint8x16_t vaddhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b) - /// A32: VADDHN.I16 Dd+1, Qn, Qm - /// A64: ADDHN2 Vd.16B, Vn.8H, Vm.8H + /// uint8x16_t vaddhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b) + /// A32: VADDHN.I16 Dd+1, Qn, Qm + /// A64: ADDHN2 Vd.16B, Vn.8H, Vm.8H /// public static Vector128 AddHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) => AddHighNarrowingUpper(lower, left, right); /// - /// int16x8_t vaddhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b) - /// A32: VADDHN.I32 Dd+1, Qn, Qm - /// A64: ADDHN2 Vd.8H, Vn.4S, Vm.4S + /// int16x8_t vaddhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b) + /// A32: VADDHN.I32 Dd+1, Qn, Qm + /// A64: ADDHN2 Vd.8H, Vn.4S, Vm.4S /// public static Vector128 AddHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) => AddHighNarrowingUpper(lower, left, right); /// - /// int32x4_t vaddhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b) - /// A32: VADDHN.I64 Dd+1, Qn, Qm - /// A64: ADDHN2 Vd.4S, Vn.2D, Vm.2D + /// int32x4_t vaddhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b) + /// A32: VADDHN.I64 Dd+1, Qn, Qm + /// A64: ADDHN2 Vd.4S, Vn.2D, Vm.2D /// public static Vector128 AddHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) => AddHighNarrowingUpper(lower, left, right); /// - /// int8x16_t vaddhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b) - /// A32: VADDHN.I16 Dd+1, Qn, Qm - /// A64: ADDHN2 Vd.16B, Vn.8H, Vm.8H + /// int8x16_t vaddhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b) + /// A32: VADDHN.I16 Dd+1, Qn, Qm + /// A64: ADDHN2 Vd.16B, Vn.8H, Vm.8H /// public static Vector128 AddHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) => AddHighNarrowingUpper(lower, left, right); /// - /// uint16x8_t vaddhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b) - /// A32: VADDHN.I32 Dd+1, Qn, Qm - /// A64: ADDHN2 Vd.8H, Vn.4S, Vm.4S + /// uint16x8_t vaddhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b) + /// A32: VADDHN.I32 Dd+1, Qn, Qm + /// A64: ADDHN2 Vd.8H, Vn.4S, Vm.4S /// public static Vector128 AddHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) => AddHighNarrowingUpper(lower, left, right); /// - /// uint32x4_t vaddhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b) - /// A32: VADDHN.I64 Dd+1, Qn, Qm - /// A64: ADDHN2 Vd.4S, Vn.2D, Vm.2D + /// uint32x4_t vaddhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b) + /// A32: VADDHN.I64 Dd+1, Qn, Qm + /// A64: ADDHN2 Vd.4S, Vn.2D, Vm.2D /// public static Vector128 AddHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) => AddHighNarrowingUpper(lower, left, right); /// - /// uint8x8_t vpadd_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VPADD.I8 Dd, Dn, Dm - /// A64: ADDP Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vpadd_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VPADD.I8 Dd, Dn, Dm + /// A64: ADDP Vd.8B, Vn.8B, Vm.8B /// public static Vector64 AddPairwise(Vector64 left, Vector64 right) => AddPairwise(left, right); /// - /// int16x4_t vpadd_s16 (int16x4_t a, int16x4_t b) - /// A32: VPADD.I16 Dd, Dn, Dm - /// A64: ADDP Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vpadd_s16 (int16x4_t a, int16x4_t b) + /// A32: VPADD.I16 Dd, Dn, Dm + /// A64: ADDP Vd.4H, Vn.4H, Vm.4H /// public static Vector64 AddPairwise(Vector64 left, Vector64 right) => AddPairwise(left, right); /// - /// int32x2_t vpadd_s32 (int32x2_t a, int32x2_t b) - /// A32: VPADD.I32 Dd, Dn, Dm - /// A64: ADDP Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vpadd_s32 (int32x2_t a, int32x2_t b) + /// A32: VPADD.I32 Dd, Dn, Dm + /// A64: ADDP Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AddPairwise(Vector64 left, Vector64 right) => AddPairwise(left, right); /// - /// int8x8_t vpadd_s8 (int8x8_t a, int8x8_t b) - /// A32: VPADD.I8 Dd, Dn, Dm - /// A64: ADDP Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vpadd_s8 (int8x8_t a, int8x8_t b) + /// A32: VPADD.I8 Dd, Dn, Dm + /// A64: ADDP Vd.8B, Vn.8B, Vm.8B /// public static Vector64 AddPairwise(Vector64 left, Vector64 right) => AddPairwise(left, right); /// - /// float32x2_t vpadd_f32 (float32x2_t a, float32x2_t b) - /// A32: VPADD.F32 Dd, Dn, Dm - /// A64: FADDP Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vpadd_f32 (float32x2_t a, float32x2_t b) + /// A32: VPADD.F32 Dd, Dn, Dm + /// A64: FADDP Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AddPairwise(Vector64 left, Vector64 right) => AddPairwise(left, right); /// - /// uint16x4_t vpadd_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VPADD.I16 Dd, Dn, Dm - /// A64: ADDP Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vpadd_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VPADD.I16 Dd, Dn, Dm + /// A64: ADDP Vd.4H, Vn.4H, Vm.4H /// public static Vector64 AddPairwise(Vector64 left, Vector64 right) => AddPairwise(left, right); /// - /// uint32x2_t vpadd_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VPADD.I32 Dd, Dn, Dm - /// A64: ADDP Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vpadd_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VPADD.I32 Dd, Dn, Dm + /// A64: ADDP Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AddPairwise(Vector64 left, Vector64 right) => AddPairwise(left, right); /// - /// uint16x4_t vpaddl_u8 (uint8x8_t a) - /// A32: VPADDL.U8 Dd, Dm - /// A64: UADDLP Vd.4H, Vn.8B + /// uint16x4_t vpaddl_u8 (uint8x8_t a) + /// A32: VPADDL.U8 Dd, Dm + /// A64: UADDLP Vd.4H, Vn.8B /// public static Vector64 AddPairwiseWidening(Vector64 value) => AddPairwiseWidening(value); /// - /// int32x2_t vpaddl_s16 (int16x4_t a) - /// A32: VPADDL.S16 Dd, Dm - /// A64: SADDLP Vd.2S, Vn.4H + /// int32x2_t vpaddl_s16 (int16x4_t a) + /// A32: VPADDL.S16 Dd, Dm + /// A64: SADDLP Vd.2S, Vn.4H /// public static Vector64 AddPairwiseWidening(Vector64 value) => AddPairwiseWidening(value); /// - /// int16x4_t vpaddl_s8 (int8x8_t a) - /// A32: VPADDL.S8 Dd, Dm - /// A64: SADDLP Vd.4H, Vn.8B + /// int16x4_t vpaddl_s8 (int8x8_t a) + /// A32: VPADDL.S8 Dd, Dm + /// A64: SADDLP Vd.4H, Vn.8B /// public static Vector64 AddPairwiseWidening(Vector64 value) => AddPairwiseWidening(value); /// - /// uint32x2_t vpaddl_u16 (uint16x4_t a) - /// A32: VPADDL.U16 Dd, Dm - /// A64: UADDLP Vd.2S, Vn.4H + /// uint32x2_t vpaddl_u16 (uint16x4_t a) + /// A32: VPADDL.U16 Dd, Dm + /// A64: UADDLP Vd.2S, Vn.4H /// public static Vector64 AddPairwiseWidening(Vector64 value) => AddPairwiseWidening(value); /// - /// uint16x8_t vpaddlq_u8 (uint8x16_t a) - /// A32: VPADDL.U8 Qd, Qm - /// A64: UADDLP Vd.8H, Vn.16B + /// uint16x8_t vpaddlq_u8 (uint8x16_t a) + /// A32: VPADDL.U8 Qd, Qm + /// A64: UADDLP Vd.8H, Vn.16B /// public static Vector128 AddPairwiseWidening(Vector128 value) => AddPairwiseWidening(value); /// - /// int32x4_t vpaddlq_s16 (int16x8_t a) - /// A32: VPADDL.S16 Qd, Qm - /// A64: SADDLP Vd.4S, Vn.8H + /// int32x4_t vpaddlq_s16 (int16x8_t a) + /// A32: VPADDL.S16 Qd, Qm + /// A64: SADDLP Vd.4S, Vn.8H /// public static Vector128 AddPairwiseWidening(Vector128 value) => AddPairwiseWidening(value); /// - /// int64x2_t vpaddlq_s32 (int32x4_t a) - /// A32: VPADDL.S32 Qd, Qm - /// A64: SADDLP Vd.2D, Vn.4S + /// int64x2_t vpaddlq_s32 (int32x4_t a) + /// A32: VPADDL.S32 Qd, Qm + /// A64: SADDLP Vd.2D, Vn.4S /// public static Vector128 AddPairwiseWidening(Vector128 value) => AddPairwiseWidening(value); /// - /// int16x8_t vpaddlq_s8 (int8x16_t a) - /// A32: VPADDL.S8 Qd, Qm - /// A64: SADDLP Vd.8H, Vn.16B + /// int16x8_t vpaddlq_s8 (int8x16_t a) + /// A32: VPADDL.S8 Qd, Qm + /// A64: SADDLP Vd.8H, Vn.16B /// public static Vector128 AddPairwiseWidening(Vector128 value) => AddPairwiseWidening(value); /// - /// uint32x4_t vpaddlq_u16 (uint16x8_t a) - /// A32: VPADDL.U16 Qd, Qm - /// A64: UADDLP Vd.4S, Vn.8H + /// uint32x4_t vpaddlq_u16 (uint16x8_t a) + /// A32: VPADDL.U16 Qd, Qm + /// A64: UADDLP Vd.4S, Vn.8H /// public static Vector128 AddPairwiseWidening(Vector128 value) => AddPairwiseWidening(value); /// - /// uint64x2_t vpaddlq_u32 (uint32x4_t a) - /// A32: VPADDL.U32 Qd, Qm - /// A64: UADDLP Vd.2D, Vn.4S + /// uint64x2_t vpaddlq_u32 (uint32x4_t a) + /// A32: VPADDL.U32 Qd, Qm + /// A64: UADDLP Vd.2D, Vn.4S /// public static Vector128 AddPairwiseWidening(Vector128 value) => AddPairwiseWidening(value); /// - /// uint16x4_t vpadal_u8 (uint16x4_t a, uint8x8_t b) - /// A32: VPADAL.U8 Dd, Dm - /// A64: UADALP Vd.4H, Vn.8B + /// uint16x4_t vpadal_u8 (uint16x4_t a, uint8x8_t b) + /// A32: VPADAL.U8 Dd, Dm + /// A64: UADALP Vd.4H, Vn.8B /// public static Vector64 AddPairwiseWideningAndAdd(Vector64 addend, Vector64 value) => AddPairwiseWideningAndAdd(addend, value); /// - /// int32x2_t vpadal_s16 (int32x2_t a, int16x4_t b) - /// A32: VPADAL.S16 Dd, Dm - /// A64: SADALP Vd.2S, Vn.4H + /// int32x2_t vpadal_s16 (int32x2_t a, int16x4_t b) + /// A32: VPADAL.S16 Dd, Dm + /// A64: SADALP Vd.2S, Vn.4H /// public static Vector64 AddPairwiseWideningAndAdd(Vector64 addend, Vector64 value) => AddPairwiseWideningAndAdd(addend, value); /// - /// int16x4_t vpadal_s8 (int16x4_t a, int8x8_t b) - /// A32: VPADAL.S8 Dd, Dm - /// A64: SADALP Vd.4H, Vn.8B + /// int16x4_t vpadal_s8 (int16x4_t a, int8x8_t b) + /// A32: VPADAL.S8 Dd, Dm + /// A64: SADALP Vd.4H, Vn.8B /// public static Vector64 AddPairwiseWideningAndAdd(Vector64 addend, Vector64 value) => AddPairwiseWideningAndAdd(addend, value); /// - /// uint32x2_t vpadal_u16 (uint32x2_t a, uint16x4_t b) - /// A32: VPADAL.U16 Dd, Dm - /// A64: UADALP Vd.2S, Vn.4H + /// uint32x2_t vpadal_u16 (uint32x2_t a, uint16x4_t b) + /// A32: VPADAL.U16 Dd, Dm + /// A64: UADALP Vd.2S, Vn.4H /// public static Vector64 AddPairwiseWideningAndAdd(Vector64 addend, Vector64 value) => AddPairwiseWideningAndAdd(addend, value); /// - /// uint16x8_t vpadalq_u8 (uint16x8_t a, uint8x16_t b) - /// A32: VPADAL.U8 Qd, Qm - /// A64: UADALP Vd.8H, Vn.16B + /// uint16x8_t vpadalq_u8 (uint16x8_t a, uint8x16_t b) + /// A32: VPADAL.U8 Qd, Qm + /// A64: UADALP Vd.8H, Vn.16B /// public static Vector128 AddPairwiseWideningAndAdd(Vector128 addend, Vector128 value) => AddPairwiseWideningAndAdd(addend, value); /// - /// int32x4_t vpadalq_s16 (int32x4_t a, int16x8_t b) - /// A32: VPADAL.S16 Qd, Qm - /// A64: SADALP Vd.4S, Vn.8H + /// int32x4_t vpadalq_s16 (int32x4_t a, int16x8_t b) + /// A32: VPADAL.S16 Qd, Qm + /// A64: SADALP Vd.4S, Vn.8H /// public static Vector128 AddPairwiseWideningAndAdd(Vector128 addend, Vector128 value) => AddPairwiseWideningAndAdd(addend, value); /// - /// int64x2_t vpadalq_s32 (int64x2_t a, int32x4_t b) - /// A32: VPADAL.S32 Qd, Qm - /// A64: SADALP Vd.2D, Vn.4S + /// int64x2_t vpadalq_s32 (int64x2_t a, int32x4_t b) + /// A32: VPADAL.S32 Qd, Qm + /// A64: SADALP Vd.2D, Vn.4S /// public static Vector128 AddPairwiseWideningAndAdd(Vector128 addend, Vector128 value) => AddPairwiseWideningAndAdd(addend, value); /// - /// int16x8_t vpadalq_s8 (int16x8_t a, int8x16_t b) - /// A32: VPADAL.S8 Qd, Qm - /// A64: SADALP Vd.8H, Vn.16B + /// int16x8_t vpadalq_s8 (int16x8_t a, int8x16_t b) + /// A32: VPADAL.S8 Qd, Qm + /// A64: SADALP Vd.8H, Vn.16B /// public static Vector128 AddPairwiseWideningAndAdd(Vector128 addend, Vector128 value) => AddPairwiseWideningAndAdd(addend, value); /// - /// uint32x4_t vpadalq_u16 (uint32x4_t a, uint16x8_t b) - /// A32: VPADAL.U16 Qd, Qm - /// A64: UADALP Vd.4S, Vn.8H + /// uint32x4_t vpadalq_u16 (uint32x4_t a, uint16x8_t b) + /// A32: VPADAL.U16 Qd, Qm + /// A64: UADALP Vd.4S, Vn.8H /// public static Vector128 AddPairwiseWideningAndAdd(Vector128 addend, Vector128 value) => AddPairwiseWideningAndAdd(addend, value); /// - /// uint64x2_t vpadalq_u32 (uint64x2_t a, uint32x4_t b) - /// A32: VPADAL.U32 Qd, Qm - /// A64: UADALP Vd.2D, Vn.4S + /// uint64x2_t vpadalq_u32 (uint64x2_t a, uint32x4_t b) + /// A32: VPADAL.U32 Qd, Qm + /// A64: UADALP Vd.2D, Vn.4S /// public static Vector128 AddPairwiseWideningAndAdd(Vector128 addend, Vector128 value) => AddPairwiseWideningAndAdd(addend, value); /// - /// int64x1_t vpadal_s32 (int64x1_t a, int32x2_t b) - /// A32: VPADAL.S32 Dd, Dm - /// A64: SADALP Vd.1D, Vn.2S + /// int64x1_t vpadal_s32 (int64x1_t a, int32x2_t b) + /// A32: VPADAL.S32 Dd, Dm + /// A64: SADALP Vd.1D, Vn.2S /// public static Vector64 AddPairwiseWideningAndAddScalar(Vector64 addend, Vector64 value) => AddPairwiseWideningAndAddScalar(addend, value); /// - /// uint64x1_t vpadal_u32 (uint64x1_t a, uint32x2_t b) - /// A32: VPADAL.U32 Dd, Dm - /// A64: UADALP Vd.1D, Vn.2S + /// uint64x1_t vpadal_u32 (uint64x1_t a, uint32x2_t b) + /// A32: VPADAL.U32 Dd, Dm + /// A64: UADALP Vd.1D, Vn.2S /// public static Vector64 AddPairwiseWideningAndAddScalar(Vector64 addend, Vector64 value) => AddPairwiseWideningAndAddScalar(addend, value); /// - /// int64x1_t vpaddl_s32 (int32x2_t a) - /// A32: VPADDL.S32 Dd, Dm - /// A64: SADDLP Dd, Vn.2S + /// int64x1_t vpaddl_s32 (int32x2_t a) + /// A32: VPADDL.S32 Dd, Dm + /// A64: SADDLP Dd, Vn.2S /// public static Vector64 AddPairwiseWideningScalar(Vector64 value) => AddPairwiseWideningScalar(value); /// - /// uint64x1_t vpaddl_u32 (uint32x2_t a) - /// A32: VPADDL.U32 Dd, Dm - /// A64: UADDLP Dd, Vn.2S + /// uint64x1_t vpaddl_u32 (uint32x2_t a) + /// A32: VPADDL.U32 Dd, Dm + /// A64: UADDLP Dd, Vn.2S /// public static Vector64 AddPairwiseWideningScalar(Vector64 value) => AddPairwiseWideningScalar(value); /// - /// uint8x8_t vraddhn_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VRADDHN.I16 Dd, Qn, Qm - /// A64: RADDHN Vd.8B, Vn.8H, Vm.8H + /// uint8x8_t vraddhn_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VRADDHN.I16 Dd, Qn, Qm + /// A64: RADDHN Vd.8B, Vn.8H, Vm.8H /// public static Vector64 AddRoundedHighNarrowingLower(Vector128 left, Vector128 right) => AddRoundedHighNarrowingLower(left, right); /// - /// int16x4_t vraddhn_s32 (int32x4_t a, int32x4_t b) - /// A32: VRADDHN.I32 Dd, Qn, Qm - /// A64: RADDHN Vd.4H, Vn.4S, Vm.4S + /// int16x4_t vraddhn_s32 (int32x4_t a, int32x4_t b) + /// A32: VRADDHN.I32 Dd, Qn, Qm + /// A64: RADDHN Vd.4H, Vn.4S, Vm.4S /// public static Vector64 AddRoundedHighNarrowingLower(Vector128 left, Vector128 right) => AddRoundedHighNarrowingLower(left, right); /// - /// int32x2_t vraddhn_s64 (int64x2_t a, int64x2_t b) - /// A32: VRADDHN.I64 Dd, Qn, Qm - /// A64: RADDHN Vd.2S, Vn.2D, Vm.2D + /// int32x2_t vraddhn_s64 (int64x2_t a, int64x2_t b) + /// A32: VRADDHN.I64 Dd, Qn, Qm + /// A64: RADDHN Vd.2S, Vn.2D, Vm.2D /// public static Vector64 AddRoundedHighNarrowingLower(Vector128 left, Vector128 right) => AddRoundedHighNarrowingLower(left, right); /// - /// int8x8_t vraddhn_s16 (int16x8_t a, int16x8_t b) - /// A32: VRADDHN.I16 Dd, Qn, Qm - /// A64: RADDHN Vd.8B, Vn.8H, Vm.8H + /// int8x8_t vraddhn_s16 (int16x8_t a, int16x8_t b) + /// A32: VRADDHN.I16 Dd, Qn, Qm + /// A64: RADDHN Vd.8B, Vn.8H, Vm.8H /// public static Vector64 AddRoundedHighNarrowingLower(Vector128 left, Vector128 right) => AddRoundedHighNarrowingLower(left, right); /// - /// uint16x4_t vraddhn_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VRADDHN.I32 Dd, Qn, Qm - /// A64: RADDHN Vd.4H, Vn.4S, Vm.4S + /// uint16x4_t vraddhn_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VRADDHN.I32 Dd, Qn, Qm + /// A64: RADDHN Vd.4H, Vn.4S, Vm.4S /// public static Vector64 AddRoundedHighNarrowingLower(Vector128 left, Vector128 right) => AddRoundedHighNarrowingLower(left, right); /// - /// uint32x2_t vraddhn_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VRADDHN.I64 Dd, Qn, Qm - /// A64: RADDHN Vd.2S, Vn.2D, Vm.2D + /// uint32x2_t vraddhn_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VRADDHN.I64 Dd, Qn, Qm + /// A64: RADDHN Vd.2S, Vn.2D, Vm.2D /// public static Vector64 AddRoundedHighNarrowingLower(Vector128 left, Vector128 right) => AddRoundedHighNarrowingLower(left, right); /// - /// uint8x16_t vraddhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b) - /// A32: VRADDHN.I16 Dd+1, Qn, Qm - /// A64: RADDHN2 Vd.16B, Vn.8H, Vm.8H + /// uint8x16_t vraddhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b) + /// A32: VRADDHN.I16 Dd+1, Qn, Qm + /// A64: RADDHN2 Vd.16B, Vn.8H, Vm.8H /// public static Vector128 AddRoundedHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) => AddRoundedHighNarrowingUpper(lower, left, right); /// - /// int16x8_t vraddhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b) - /// A32: VRADDHN.I32 Dd+1, Qn, Qm - /// A64: RADDHN2 Vd.8H, Vn.4S, Vm.4S + /// int16x8_t vraddhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b) + /// A32: VRADDHN.I32 Dd+1, Qn, Qm + /// A64: RADDHN2 Vd.8H, Vn.4S, Vm.4S /// public static Vector128 AddRoundedHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) => AddRoundedHighNarrowingUpper(lower, left, right); /// - /// int32x4_t vraddhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b) - /// A32: VRADDHN.I64 Dd+1, Qn, Qm - /// A64: RADDHN2 Vd.4S, Vn.2D, Vm.2D + /// int32x4_t vraddhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b) + /// A32: VRADDHN.I64 Dd+1, Qn, Qm + /// A64: RADDHN2 Vd.4S, Vn.2D, Vm.2D /// public static Vector128 AddRoundedHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) => AddRoundedHighNarrowingUpper(lower, left, right); /// - /// int8x16_t vraddhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b) - /// A32: VRADDHN.I16 Dd+1, Qn, Qm - /// A64: RADDHN2 Vd.16B, Vn.8H, Vm.8H + /// int8x16_t vraddhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b) + /// A32: VRADDHN.I16 Dd+1, Qn, Qm + /// A64: RADDHN2 Vd.16B, Vn.8H, Vm.8H /// public static Vector128 AddRoundedHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) => AddRoundedHighNarrowingUpper(lower, left, right); /// - /// uint16x8_t vraddhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b) - /// A32: VRADDHN.I32 Dd+1, Qn, Qm - /// A64: RADDHN2 Vd.8H, Vn.4S, Vm.4S + /// uint16x8_t vraddhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b) + /// A32: VRADDHN.I32 Dd+1, Qn, Qm + /// A64: RADDHN2 Vd.8H, Vn.4S, Vm.4S /// public static Vector128 AddRoundedHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) => AddRoundedHighNarrowingUpper(lower, left, right); /// - /// uint32x4_t vraddhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b) - /// A32: VRADDHN.I64 Dd+1, Qn, Qm - /// A64: RADDHN2 Vd.4S, Vn.2D, Vm.2D + /// uint32x4_t vraddhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b) + /// A32: VRADDHN.I64 Dd+1, Qn, Qm + /// A64: RADDHN2 Vd.4S, Vn.2D, Vm.2D /// public static Vector128 AddRoundedHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) => AddRoundedHighNarrowingUpper(lower, left, right); /// - /// uint8x8_t vqadd_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VQADD.U8 Dd, Dn, Dm - /// A64: UQADD Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vqadd_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VQADD.U8 Dd, Dn, Dm + /// A64: UQADD Vd.8B, Vn.8B, Vm.8B /// public static Vector64 AddSaturate(Vector64 left, Vector64 right) => AddSaturate(left, right); /// - /// int16x4_t vqadd_s16 (int16x4_t a, int16x4_t b) - /// A32: VQADD.S16 Dd, Dn, Dm - /// A64: SQADD Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vqadd_s16 (int16x4_t a, int16x4_t b) + /// A32: VQADD.S16 Dd, Dn, Dm + /// A64: SQADD Vd.4H, Vn.4H, Vm.4H /// public static Vector64 AddSaturate(Vector64 left, Vector64 right) => AddSaturate(left, right); /// - /// int32x2_t vqadd_s32 (int32x2_t a, int32x2_t b) - /// A32: VQADD.S32 Dd, Dn, Dm - /// A64: SQADD Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vqadd_s32 (int32x2_t a, int32x2_t b) + /// A32: VQADD.S32 Dd, Dn, Dm + /// A64: SQADD Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AddSaturate(Vector64 left, Vector64 right) => AddSaturate(left, right); /// - /// int8x8_t vqadd_s8 (int8x8_t a, int8x8_t b) - /// A32: VQADD.S8 Dd, Dn, Dm - /// A64: SQADD Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vqadd_s8 (int8x8_t a, int8x8_t b) + /// A32: VQADD.S8 Dd, Dn, Dm + /// A64: SQADD Vd.8B, Vn.8B, Vm.8B /// public static Vector64 AddSaturate(Vector64 left, Vector64 right) => AddSaturate(left, right); /// - /// uint16x4_t vqadd_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VQADD.U16 Dd, Dn, Dm - /// A64: UQADD Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vqadd_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VQADD.U16 Dd, Dn, Dm + /// A64: UQADD Vd.4H, Vn.4H, Vm.4H /// public static Vector64 AddSaturate(Vector64 left, Vector64 right) => AddSaturate(left, right); /// - /// uint32x2_t vqadd_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VQADD.U32 Dd, Dn, Dm - /// A64: UQADD Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vqadd_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VQADD.U32 Dd, Dn, Dm + /// A64: UQADD Vd.2S, Vn.2S, Vm.2S /// public static Vector64 AddSaturate(Vector64 left, Vector64 right) => AddSaturate(left, right); /// - /// uint8x16_t vqaddq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VQADD.U8 Qd, Qn, Qm - /// A64: UQADD Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vqaddq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VQADD.U8 Qd, Qn, Qm + /// A64: UQADD Vd.16B, Vn.16B, Vm.16B /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); /// - /// int16x8_t vqaddq_s16 (int16x8_t a, int16x8_t b) - /// A32: VQADD.S16 Qd, Qn, Qm - /// A64: SQADD Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vqaddq_s16 (int16x8_t a, int16x8_t b) + /// A32: VQADD.S16 Qd, Qn, Qm + /// A64: SQADD Vd.8H, Vn.8H, Vm.8H /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); /// - /// int32x4_t vqaddq_s32 (int32x4_t a, int32x4_t b) - /// A32: VQADD.S32 Qd, Qn, Qm - /// A64: SQADD Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vqaddq_s32 (int32x4_t a, int32x4_t b) + /// A32: VQADD.S32 Qd, Qn, Qm + /// A64: SQADD Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); /// - /// int64x2_t vqaddq_s64 (int64x2_t a, int64x2_t b) - /// A32: VQADD.S64 Qd, Qn, Qm - /// A64: SQADD Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vqaddq_s64 (int64x2_t a, int64x2_t b) + /// A32: VQADD.S64 Qd, Qn, Qm + /// A64: SQADD Vd.2D, Vn.2D, Vm.2D /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); /// - /// int8x16_t vqaddq_s8 (int8x16_t a, int8x16_t b) - /// A32: VQADD.S8 Qd, Qn, Qm - /// A64: SQADD Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vqaddq_s8 (int8x16_t a, int8x16_t b) + /// A32: VQADD.S8 Qd, Qn, Qm + /// A64: SQADD Vd.16B, Vn.16B, Vm.16B /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); /// - /// uint16x8_t vqaddq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VQADD.U16 Qd, Qn, Qm - /// A64: UQADD Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vqaddq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VQADD.U16 Qd, Qn, Qm + /// A64: UQADD Vd.8H, Vn.8H, Vm.8H /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); /// - /// uint32x4_t vqaddq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VQADD.U32 Qd, Qn, Qm - /// A64: UQADD Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vqaddq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VQADD.U32 Qd, Qn, Qm + /// A64: UQADD Vd.4S, Vn.4S, Vm.4S /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); /// - /// uint64x2_t vqaddq_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VQADD.U64 Qd, Qn, Qm - /// A64: UQADD Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vqaddq_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VQADD.U64 Qd, Qn, Qm + /// A64: UQADD Vd.2D, Vn.2D, Vm.2D /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); /// - /// int64x1_t vqadd_s64 (int64x1_t a, int64x1_t b) - /// A32: VQADD.S64 Dd, Dn, Dm - /// A64: SQADD Dd, Dn, Dm + /// int64x1_t vqadd_s64 (int64x1_t a, int64x1_t b) + /// A32: VQADD.S64 Dd, Dn, Dm + /// A64: SQADD Dd, Dn, Dm /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) => AddSaturateScalar(left, right); /// - /// uint64x1_t vqadd_u64 (uint64x1_t a, uint64x1_t b) - /// A32: VQADD.U64 Dd, Dn, Dm - /// A64: UQADD Dd, Dn, Dm + /// uint64x1_t vqadd_u64 (uint64x1_t a, uint64x1_t b) + /// A32: VQADD.U64 Dd, Dn, Dm + /// A64: UQADD Dd, Dn, Dm /// public static Vector64 AddSaturateScalar(Vector64 left, Vector64 right) => AddSaturateScalar(left, right); /// - /// float64x1_t vadd_f64 (float64x1_t a, float64x1_t b) - /// A32: VADD.F64 Dd, Dn, Dm - /// A64: FADD Dd, Dn, Dm + /// float64x1_t vadd_f64 (float64x1_t a, float64x1_t b) + /// A32: VADD.F64 Dd, Dn, Dm + /// A64: FADD Dd, Dn, Dm /// public static Vector64 AddScalar(Vector64 left, Vector64 right) => AddScalar(left, right); /// - /// int64x1_t vadd_s64 (int64x1_t a, int64x1_t b) - /// A32: VADD.I64 Dd, Dn, Dm - /// A64: ADD Dd, Dn, Dm + /// int64x1_t vadd_s64 (int64x1_t a, int64x1_t b) + /// A32: VADD.I64 Dd, Dn, Dm + /// A64: ADD Dd, Dn, Dm /// public static Vector64 AddScalar(Vector64 left, Vector64 right) => AddScalar(left, right); /// - /// float32_t vadds_f32 (float32_t a, float32_t b) - /// A32: VADD.F32 Sd, Sn, Sm - /// A64: FADD Sd, Sn, Sm - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vadds_f32 (float32_t a, float32_t b) + /// A32: VADD.F32 Sd, Sn, Sm + /// A64: FADD Sd, Sn, Sm + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 AddScalar(Vector64 left, Vector64 right) => AddScalar(left, right); /// - /// uint64x1_t vadd_u64 (uint64x1_t a, uint64x1_t b) - /// A32: VADD.I64 Dd, Dn, Dm - /// A64: ADD Dd, Dn, Dm + /// uint64x1_t vadd_u64 (uint64x1_t a, uint64x1_t b) + /// A32: VADD.I64 Dd, Dn, Dm + /// A64: ADD Dd, Dn, Dm /// public static Vector64 AddScalar(Vector64 left, Vector64 right) => AddScalar(left, right); /// - /// uint16x8_t vaddl_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VADDL.U8 Qd, Dn, Dm - /// A64: UADDL Vd.8H, Vn.8B, Vm.8B + /// uint16x8_t vaddl_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VADDL.U8 Qd, Dn, Dm + /// A64: UADDL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 AddWideningLower(Vector64 left, Vector64 right) => AddWideningLower(left, right); /// - /// int32x4_t vaddl_s16 (int16x4_t a, int16x4_t b) - /// A32: VADDL.S16 Qd, Dn, Dm - /// A64: SADDL Vd.4S, Vn.4H, Vm.4H + /// int32x4_t vaddl_s16 (int16x4_t a, int16x4_t b) + /// A32: VADDL.S16 Qd, Dn, Dm + /// A64: SADDL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 AddWideningLower(Vector64 left, Vector64 right) => AddWideningLower(left, right); /// - /// int64x2_t vaddl_s32 (int32x2_t a, int32x2_t b) - /// A32: VADDL.S32 Qd, Dn, Dm - /// A64: SADDL Vd.2D, Vn.2S, Vm.2S + /// int64x2_t vaddl_s32 (int32x2_t a, int32x2_t b) + /// A32: VADDL.S32 Qd, Dn, Dm + /// A64: SADDL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 AddWideningLower(Vector64 left, Vector64 right) => AddWideningLower(left, right); /// - /// int16x8_t vaddl_s8 (int8x8_t a, int8x8_t b) - /// A32: VADDL.S8 Qd, Dn, Dm - /// A64: SADDL Vd.8H, Vn.8B, Vm.8B + /// int16x8_t vaddl_s8 (int8x8_t a, int8x8_t b) + /// A32: VADDL.S8 Qd, Dn, Dm + /// A64: SADDL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 AddWideningLower(Vector64 left, Vector64 right) => AddWideningLower(left, right); /// - /// uint32x4_t vaddl_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VADDL.U16 Qd, Dn, Dm - /// A64: UADDL Vd.4S, Vn.4H, Vm.4H + /// uint32x4_t vaddl_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VADDL.U16 Qd, Dn, Dm + /// A64: UADDL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 AddWideningLower(Vector64 left, Vector64 right) => AddWideningLower(left, right); /// - /// uint64x2_t vaddl_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VADDL.U32 Qd, Dn, Dm - /// A64: UADDL Vd.2D, Vn.2S, Vm.2S + /// uint64x2_t vaddl_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VADDL.U32 Qd, Dn, Dm + /// A64: UADDL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 AddWideningLower(Vector64 left, Vector64 right) => AddWideningLower(left, right); /// - /// int16x8_t vaddw_s8 (int16x8_t a, int8x8_t b) - /// A32: VADDW.S8 Qd, Qn, Dm - /// A64: SADDW Vd.8H, Vn.8H, Vm.8B + /// int16x8_t vaddw_s8 (int16x8_t a, int8x8_t b) + /// A32: VADDW.S8 Qd, Qn, Dm + /// A64: SADDW Vd.8H, Vn.8H, Vm.8B /// public static Vector128 AddWideningLower(Vector128 left, Vector64 right) => AddWideningLower(left, right); /// - /// int32x4_t vaddw_s16 (int32x4_t a, int16x4_t b) - /// A32: VADDW.S16 Qd, Qn, Dm - /// A64: SADDW Vd.4S, Vn.4S, Vm.4H + /// int32x4_t vaddw_s16 (int32x4_t a, int16x4_t b) + /// A32: VADDW.S16 Qd, Qn, Dm + /// A64: SADDW Vd.4S, Vn.4S, Vm.4H /// public static Vector128 AddWideningLower(Vector128 left, Vector64 right) => AddWideningLower(left, right); /// - /// int64x2_t vaddw_s32 (int64x2_t a, int32x2_t b) - /// A32: VADDW.S32 Qd, Qn, Dm - /// A64: SADDW Vd.2D, Vn.2D, Vm.2S + /// int64x2_t vaddw_s32 (int64x2_t a, int32x2_t b) + /// A32: VADDW.S32 Qd, Qn, Dm + /// A64: SADDW Vd.2D, Vn.2D, Vm.2S /// public static Vector128 AddWideningLower(Vector128 left, Vector64 right) => AddWideningLower(left, right); /// - /// uint16x8_t vaddw_u8 (uint16x8_t a, uint8x8_t b) - /// A32: VADDW.U8 Qd, Qn, Dm - /// A64: UADDW Vd.8H, Vn.8H, Vm.8B + /// uint16x8_t vaddw_u8 (uint16x8_t a, uint8x8_t b) + /// A32: VADDW.U8 Qd, Qn, Dm + /// A64: UADDW Vd.8H, Vn.8H, Vm.8B /// public static Vector128 AddWideningLower(Vector128 left, Vector64 right) => AddWideningLower(left, right); /// - /// uint32x4_t vaddw_u16 (uint32x4_t a, uint16x4_t b) - /// A32: VADDW.U16 Qd, Qn, Dm - /// A64: UADDW Vd.4S, Vn.4S, Vm.4H + /// uint32x4_t vaddw_u16 (uint32x4_t a, uint16x4_t b) + /// A32: VADDW.U16 Qd, Qn, Dm + /// A64: UADDW Vd.4S, Vn.4S, Vm.4H /// public static Vector128 AddWideningLower(Vector128 left, Vector64 right) => AddWideningLower(left, right); /// - /// uint64x2_t vaddw_u32 (uint64x2_t a, uint32x2_t b) - /// A32: VADDW.U32 Qd, Qn, Dm - /// A64: UADDW Vd.2D, Vn.2D, Vm.2S + /// uint64x2_t vaddw_u32 (uint64x2_t a, uint32x2_t b) + /// A32: VADDW.U32 Qd, Qn, Dm + /// A64: UADDW Vd.2D, Vn.2D, Vm.2S /// public static Vector128 AddWideningLower(Vector128 left, Vector64 right) => AddWideningLower(left, right); /// - /// uint16x8_t vaddl_high_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VADDL.U8 Qd, Dn+1, Dm+1 - /// A64: UADDL2 Vd.8H, Vn.16B, Vm.16B + /// uint16x8_t vaddl_high_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VADDL.U8 Qd, Dn+1, Dm+1 + /// A64: UADDL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 AddWideningUpper(Vector128 left, Vector128 right) => AddWideningUpper(left, right); /// - /// int32x4_t vaddl_high_s16 (int16x8_t a, int16x8_t b) - /// A32: VADDL.S16 Qd, Dn+1, Dm+1 - /// A64: SADDL2 Vd.4S, Vn.8H, Vm.8H + /// int32x4_t vaddl_high_s16 (int16x8_t a, int16x8_t b) + /// A32: VADDL.S16 Qd, Dn+1, Dm+1 + /// A64: SADDL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 AddWideningUpper(Vector128 left, Vector128 right) => AddWideningUpper(left, right); /// - /// int16x8_t vaddw_high_s8 (int16x8_t a, int8x16_t b) - /// A32: VADDW.S8 Qd, Qn, Dm+1 - /// A64: SADDW2 Vd.8H, Vn.8H, Vm.16B + /// int16x8_t vaddw_high_s8 (int16x8_t a, int8x16_t b) + /// A32: VADDW.S8 Qd, Qn, Dm+1 + /// A64: SADDW2 Vd.8H, Vn.8H, Vm.16B /// public static Vector128 AddWideningUpper(Vector128 left, Vector128 right) => AddWideningUpper(left, right); /// - /// int32x4_t vaddw_high_s16 (int32x4_t a, int16x8_t b) - /// A32: VADDW.S16 Qd, Qn, Dm+1 - /// A64: SADDW2 Vd.4S, Vn.4S, Vm.8H + /// int32x4_t vaddw_high_s16 (int32x4_t a, int16x8_t b) + /// A32: VADDW.S16 Qd, Qn, Dm+1 + /// A64: SADDW2 Vd.4S, Vn.4S, Vm.8H /// public static Vector128 AddWideningUpper(Vector128 left, Vector128 right) => AddWideningUpper(left, right); /// - /// int64x2_t vaddl_high_s32 (int32x4_t a, int32x4_t b) - /// A32: VADDL.S32 Qd, Dn+1, Dm+1 - /// A64: SADDL2 Vd.2D, Vn.4S, Vm.4S + /// int64x2_t vaddl_high_s32 (int32x4_t a, int32x4_t b) + /// A32: VADDL.S32 Qd, Dn+1, Dm+1 + /// A64: SADDL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 AddWideningUpper(Vector128 left, Vector128 right) => AddWideningUpper(left, right); /// - /// int64x2_t vaddw_high_s32 (int64x2_t a, int32x4_t b) - /// A32: VADDW.S32 Qd, Qn, Dm+1 - /// A64: SADDW2 Vd.2D, Vn.2D, Vm.4S + /// int64x2_t vaddw_high_s32 (int64x2_t a, int32x4_t b) + /// A32: VADDW.S32 Qd, Qn, Dm+1 + /// A64: SADDW2 Vd.2D, Vn.2D, Vm.4S /// public static Vector128 AddWideningUpper(Vector128 left, Vector128 right) => AddWideningUpper(left, right); /// - /// int16x8_t vaddl_high_s8 (int8x16_t a, int8x16_t b) - /// A32: VADDL.S8 Qd, Dn+1, Dm+1 - /// A64: SADDL2 Vd.8H, Vn.16B, Vm.16B + /// int16x8_t vaddl_high_s8 (int8x16_t a, int8x16_t b) + /// A32: VADDL.S8 Qd, Dn+1, Dm+1 + /// A64: SADDL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 AddWideningUpper(Vector128 left, Vector128 right) => AddWideningUpper(left, right); /// - /// uint16x8_t vaddw_high_u8 (uint16x8_t a, uint8x16_t b) - /// A32: VADDW.U8 Qd, Qn, Dm+1 - /// A64: UADDW2 Vd.8H, Vn.8H, Vm.16B + /// uint16x8_t vaddw_high_u8 (uint16x8_t a, uint8x16_t b) + /// A32: VADDW.U8 Qd, Qn, Dm+1 + /// A64: UADDW2 Vd.8H, Vn.8H, Vm.16B /// public static Vector128 AddWideningUpper(Vector128 left, Vector128 right) => AddWideningUpper(left, right); /// - /// uint32x4_t vaddl_high_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VADDL.U16 Qd, Dn+1, Dm+1 - /// A64: UADDL2 Vd.4S, Vn.8H, Vm.8H + /// uint32x4_t vaddl_high_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VADDL.U16 Qd, Dn+1, Dm+1 + /// A64: UADDL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 AddWideningUpper(Vector128 left, Vector128 right) => AddWideningUpper(left, right); /// - /// uint32x4_t vaddw_high_u16 (uint32x4_t a, uint16x8_t b) - /// A32: VADDW.U16 Qd, Qn, Dm+1 - /// A64: UADDW2 Vd.4S, Vn.4S, Vm.8H + /// uint32x4_t vaddw_high_u16 (uint32x4_t a, uint16x8_t b) + /// A32: VADDW.U16 Qd, Qn, Dm+1 + /// A64: UADDW2 Vd.4S, Vn.4S, Vm.8H /// public static Vector128 AddWideningUpper(Vector128 left, Vector128 right) => AddWideningUpper(left, right); /// - /// uint64x2_t vaddl_high_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VADDL.U32 Qd, Dn+1, Dm+1 - /// A64: UADDL2 Vd.2D, Vn.4S, Vm.4S + /// uint64x2_t vaddl_high_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VADDL.U32 Qd, Dn+1, Dm+1 + /// A64: UADDL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 AddWideningUpper(Vector128 left, Vector128 right) => AddWideningUpper(left, right); /// - /// uint64x2_t vaddw_high_u32 (uint64x2_t a, uint32x4_t b) - /// A32: VADDW.U32 Qd, Qn, Dm+1 - /// A64: UADDW2 Vd.2D, Vn.2D, Vm.4S + /// uint64x2_t vaddw_high_u32 (uint64x2_t a, uint32x4_t b) + /// A32: VADDW.U32 Qd, Qn, Dm+1 + /// A64: UADDW2 Vd.2D, Vn.2D, Vm.4S /// public static Vector128 AddWideningUpper(Vector128 left, Vector128 right) => AddWideningUpper(left, right); /// - /// uint8x8_t vand_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VAND Dd, Dn, Dm - /// A64: AND Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vand_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VAND Dd, Dn, Dm + /// A64: AND Vd.8B, Vn.8B, Vm.8B /// public static Vector64 And(Vector64 left, Vector64 right) => And(left, right); /// - /// float64x1_t vand_f64 (float64x1_t a, float64x1_t b) - /// A32: VAND Dd, Dn, Dm - /// A64: AND Vd.8B, Vn.8B, Vm.8B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x1_t vand_f64 (float64x1_t a, float64x1_t b) + /// A32: VAND Dd, Dn, Dm + /// A64: AND Vd.8B, Vn.8B, Vm.8B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 And(Vector64 left, Vector64 right) => And(left, right); /// - /// int16x4_t vand_s16 (int16x4_t a, int16x4_t b) - /// A32: VAND Dd, Dn, Dm - /// A64: AND Vd.8B, Vn.8B, Vm.8B + /// int16x4_t vand_s16 (int16x4_t a, int16x4_t b) + /// A32: VAND Dd, Dn, Dm + /// A64: AND Vd.8B, Vn.8B, Vm.8B /// public static Vector64 And(Vector64 left, Vector64 right) => And(left, right); /// - /// int32x2_t vand_s32 (int32x2_t a, int32x2_t b) - /// A32: VAND Dd, Dn, Dm - /// A64: AND Vd.8B, Vn.8B, Vm.8B + /// int32x2_t vand_s32 (int32x2_t a, int32x2_t b) + /// A32: VAND Dd, Dn, Dm + /// A64: AND Vd.8B, Vn.8B, Vm.8B /// public static Vector64 And(Vector64 left, Vector64 right) => And(left, right); /// - /// int64x1_t vand_s64 (int64x1_t a, int64x1_t b) - /// A32: VAND Dd, Dn, Dm - /// A64: AND Vd.8B, Vn.8B, Vm.8B + /// int64x1_t vand_s64 (int64x1_t a, int64x1_t b) + /// A32: VAND Dd, Dn, Dm + /// A64: AND Vd.8B, Vn.8B, Vm.8B /// public static Vector64 And(Vector64 left, Vector64 right) => And(left, right); /// - /// int8x8_t vand_s8 (int8x8_t a, int8x8_t b) - /// A32: VAND Dd, Dn, Dm - /// A64: AND Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vand_s8 (int8x8_t a, int8x8_t b) + /// A32: VAND Dd, Dn, Dm + /// A64: AND Vd.8B, Vn.8B, Vm.8B /// public static Vector64 And(Vector64 left, Vector64 right) => And(left, right); /// - /// float32x2_t vand_f32 (float32x2_t a, float32x2_t b) - /// A32: VAND Dd, Dn, Dm - /// A64: AND Vd.8B, Vn.8B, Vm.8B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32x2_t vand_f32 (float32x2_t a, float32x2_t b) + /// A32: VAND Dd, Dn, Dm + /// A64: AND Vd.8B, Vn.8B, Vm.8B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 And(Vector64 left, Vector64 right) => And(left, right); /// - /// uint16x4_t vand_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VAND Dd, Dn, Dm - /// A64: AND Vd.8B, Vn.8B, Vm.8B + /// uint16x4_t vand_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VAND Dd, Dn, Dm + /// A64: AND Vd.8B, Vn.8B, Vm.8B /// public static Vector64 And(Vector64 left, Vector64 right) => And(left, right); /// - /// uint32x2_t vand_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VAND Dd, Dn, Dm - /// A64: AND Vd.8B, Vn.8B, Vm.8B + /// uint32x2_t vand_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VAND Dd, Dn, Dm + /// A64: AND Vd.8B, Vn.8B, Vm.8B /// public static Vector64 And(Vector64 left, Vector64 right) => And(left, right); /// - /// uint64x1_t vand_u64 (uint64x1_t a, uint64x1_t b) - /// A32: VAND Dd, Dn, Dm - /// A64: AND Vd.8B, Vn.8B, Vm.8B + /// uint64x1_t vand_u64 (uint64x1_t a, uint64x1_t b) + /// A32: VAND Dd, Dn, Dm + /// A64: AND Vd.8B, Vn.8B, Vm.8B /// public static Vector64 And(Vector64 left, Vector64 right) => And(left, right); /// - /// uint8x16_t vandq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VAND Qd, Qn, Qm - /// A64: AND Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vandq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VAND Qd, Qn, Qm + /// A64: AND Vd.16B, Vn.16B, Vm.16B /// public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// - /// float64x2_t vandq_f64 (float64x2_t a, float64x2_t b) - /// A32: VAND Qd, Qn, Qm - /// A64: AND Vd.16B, Vn.16B, Vm.16B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x2_t vandq_f64 (float64x2_t a, float64x2_t b) + /// A32: VAND Qd, Qn, Qm + /// A64: AND Vd.16B, Vn.16B, Vm.16B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// - /// int16x8_t vandq_s16 (int16x8_t a, int16x8_t b) - /// A32: VAND Qd, Qn, Qm - /// A64: AND Vd.16B, Vn.16B, Vm.16B + /// int16x8_t vandq_s16 (int16x8_t a, int16x8_t b) + /// A32: VAND Qd, Qn, Qm + /// A64: AND Vd.16B, Vn.16B, Vm.16B /// public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// - /// int32x4_t vandq_s32 (int32x4_t a, int32x4_t b) - /// A32: VAND Qd, Qn, Qm - /// A64: AND Vd.16B, Vn.16B, Vm.16B + /// int32x4_t vandq_s32 (int32x4_t a, int32x4_t b) + /// A32: VAND Qd, Qn, Qm + /// A64: AND Vd.16B, Vn.16B, Vm.16B /// public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// - /// int64x2_t vandq_s64 (int64x2_t a, int64x2_t b) - /// A32: VAND Qd, Qn, Qm - /// A64: AND Vd.16B, Vn.16B, Vm.16B + /// int64x2_t vandq_s64 (int64x2_t a, int64x2_t b) + /// A32: VAND Qd, Qn, Qm + /// A64: AND Vd.16B, Vn.16B, Vm.16B /// public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// - /// int8x16_t vandq_s8 (int8x16_t a, int8x16_t b) - /// A32: VAND Qd, Qn, Qm - /// A64: AND Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vandq_s8 (int8x16_t a, int8x16_t b) + /// A32: VAND Qd, Qn, Qm + /// A64: AND Vd.16B, Vn.16B, Vm.16B /// public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// - /// float32x4_t vandq_f32 (float32x4_t a, float32x4_t b) - /// A32: VAND Qd, Qn, Qm - /// A64: AND Vd.16B, Vn.16B, Vm.16B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32x4_t vandq_f32 (float32x4_t a, float32x4_t b) + /// A32: VAND Qd, Qn, Qm + /// A64: AND Vd.16B, Vn.16B, Vm.16B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// - /// uint16x8_t vandq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VAND Qd, Qn, Qm - /// A64: AND Vd.16B, Vn.16B, Vm.16B + /// uint16x8_t vandq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VAND Qd, Qn, Qm + /// A64: AND Vd.16B, Vn.16B, Vm.16B /// public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// - /// uint32x4_t vandq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VAND Qd, Qn, Qm - /// A64: AND Vd.16B, Vn.16B, Vm.16B + /// uint32x4_t vandq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VAND Qd, Qn, Qm + /// A64: AND Vd.16B, Vn.16B, Vm.16B /// public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// - /// uint64x2_t vandq_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VAND Qd, Qn, Qm - /// A64: AND Vd.16B, Vn.16B, Vm.16B + /// uint64x2_t vandq_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VAND Qd, Qn, Qm + /// A64: AND Vd.16B, Vn.16B, Vm.16B /// public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// - /// uint8x8_t vbic_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VBIC Dd, Dn, Dm - /// A64: BIC Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vbic_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VBIC Dd, Dn, Dm + /// A64: BIC Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseClear(Vector64 value, Vector64 mask) => BitwiseClear(value, mask); /// - /// float64x1_t vbic_f64 (float64x1_t a, float64x1_t b) - /// A32: VBIC Dd, Dn, Dm - /// A64: BIC Vd.8B, Vn.8B, Vm.8B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x1_t vbic_f64 (float64x1_t a, float64x1_t b) + /// A32: VBIC Dd, Dn, Dm + /// A64: BIC Vd.8B, Vn.8B, Vm.8B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 BitwiseClear(Vector64 value, Vector64 mask) => BitwiseClear(value, mask); /// - /// int16x4_t vbic_s16 (int16x4_t a, int16x4_t b) - /// A32: VBIC Dd, Dn, Dm - /// A64: BIC Vd.8B, Vn.8B, Vm.8B + /// int16x4_t vbic_s16 (int16x4_t a, int16x4_t b) + /// A32: VBIC Dd, Dn, Dm + /// A64: BIC Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseClear(Vector64 value, Vector64 mask) => BitwiseClear(value, mask); /// - /// int32x2_t vbic_s32 (int32x2_t a, int32x2_t b) - /// A32: VBIC Dd, Dn, Dm - /// A64: BIC Vd.8B, Vn.8B, Vm.8B + /// int32x2_t vbic_s32 (int32x2_t a, int32x2_t b) + /// A32: VBIC Dd, Dn, Dm + /// A64: BIC Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseClear(Vector64 value, Vector64 mask) => BitwiseClear(value, mask); /// - /// int64x1_t vbic_s64 (int64x1_t a, int64x1_t b) - /// A32: VBIC Dd, Dn, Dm - /// A64: BIC Vd.8B, Vn.8B, Vm.8B + /// int64x1_t vbic_s64 (int64x1_t a, int64x1_t b) + /// A32: VBIC Dd, Dn, Dm + /// A64: BIC Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseClear(Vector64 value, Vector64 mask) => BitwiseClear(value, mask); /// - /// int8x8_t vbic_s8 (int8x8_t a, int8x8_t b) - /// A32: VBIC Dd, Dn, Dm - /// A64: BIC Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vbic_s8 (int8x8_t a, int8x8_t b) + /// A32: VBIC Dd, Dn, Dm + /// A64: BIC Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseClear(Vector64 value, Vector64 mask) => BitwiseClear(value, mask); /// - /// float32x2_t vbic_f32 (float32x2_t a, float32x2_t b) - /// A32: VBIC Dd, Dn, Dm - /// A64: BIC Vd.8B, Vn.8B, Vm.8B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32x2_t vbic_f32 (float32x2_t a, float32x2_t b) + /// A32: VBIC Dd, Dn, Dm + /// A64: BIC Vd.8B, Vn.8B, Vm.8B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 BitwiseClear(Vector64 value, Vector64 mask) => BitwiseClear(value, mask); /// - /// uint16x4_t vbic_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VBIC Dd, Dn, Dm - /// A64: BIC Vd.8B, Vn.8B, Vm.8B + /// uint16x4_t vbic_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VBIC Dd, Dn, Dm + /// A64: BIC Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseClear(Vector64 value, Vector64 mask) => BitwiseClear(value, mask); /// - /// uint32x2_t vbic_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VBIC Dd, Dn, Dm - /// A64: BIC Vd.8B, Vn.8B, Vm.8B + /// uint32x2_t vbic_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VBIC Dd, Dn, Dm + /// A64: BIC Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseClear(Vector64 value, Vector64 mask) => BitwiseClear(value, mask); /// - /// uint64x1_t vbic_u64 (uint64x1_t a, uint64x1_t b) - /// A32: VBIC Dd, Dn, Dm - /// A64: BIC Vd.8B, Vn.8B, Vm.8B + /// uint64x1_t vbic_u64 (uint64x1_t a, uint64x1_t b) + /// A32: VBIC Dd, Dn, Dm + /// A64: BIC Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseClear(Vector64 value, Vector64 mask) => BitwiseClear(value, mask); /// - /// uint8x16_t vbicq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VBIC Qd, Qn, Qm - /// A64: BIC Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vbicq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VBIC Qd, Qn, Qm + /// A64: BIC Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseClear(Vector128 value, Vector128 mask) => BitwiseClear(value, mask); /// - /// float64x2_t vbicq_f64 (float64x2_t a, float64x2_t b) - /// A32: VBIC Qd, Qn, Qm - /// A64: BIC Vd.16B, Vn.16B, Vm.16B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x2_t vbicq_f64 (float64x2_t a, float64x2_t b) + /// A32: VBIC Qd, Qn, Qm + /// A64: BIC Vd.16B, Vn.16B, Vm.16B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 BitwiseClear(Vector128 value, Vector128 mask) => BitwiseClear(value, mask); /// - /// int16x8_t vbicq_s16 (int16x8_t a, int16x8_t b) - /// A32: VBIC Qd, Qn, Qm - /// A64: BIC Vd.16B, Vn.16B, Vm.16B + /// int16x8_t vbicq_s16 (int16x8_t a, int16x8_t b) + /// A32: VBIC Qd, Qn, Qm + /// A64: BIC Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseClear(Vector128 value, Vector128 mask) => BitwiseClear(value, mask); /// - /// int32x4_t vbicq_s32 (int32x4_t a, int32x4_t b) - /// A32: VBIC Qd, Qn, Qm - /// A64: BIC Vd.16B, Vn.16B, Vm.16B + /// int32x4_t vbicq_s32 (int32x4_t a, int32x4_t b) + /// A32: VBIC Qd, Qn, Qm + /// A64: BIC Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseClear(Vector128 value, Vector128 mask) => BitwiseClear(value, mask); /// - /// int64x2_t vbicq_s64 (int64x2_t a, int64x2_t b) - /// A32: VBIC Qd, Qn, Qm - /// A64: BIC Vd.16B, Vn.16B, Vm.16B + /// int64x2_t vbicq_s64 (int64x2_t a, int64x2_t b) + /// A32: VBIC Qd, Qn, Qm + /// A64: BIC Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseClear(Vector128 value, Vector128 mask) => BitwiseClear(value, mask); /// - /// int8x16_t vbicq_s8 (int8x16_t a, int8x16_t b) - /// A32: VBIC Qd, Qn, Qm - /// A64: BIC Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vbicq_s8 (int8x16_t a, int8x16_t b) + /// A32: VBIC Qd, Qn, Qm + /// A64: BIC Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseClear(Vector128 value, Vector128 mask) => BitwiseClear(value, mask); /// - /// float32x4_t vbicq_f32 (float32x4_t a, float32x4_t b) - /// A32: VBIC Qd, Qn, Qm - /// A64: BIC Vd.16B, Vn.16B, Vm.16B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32x4_t vbicq_f32 (float32x4_t a, float32x4_t b) + /// A32: VBIC Qd, Qn, Qm + /// A64: BIC Vd.16B, Vn.16B, Vm.16B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 BitwiseClear(Vector128 value, Vector128 mask) => BitwiseClear(value, mask); /// - /// uint16x8_t vbicq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VBIC Qd, Qn, Qm - /// A64: BIC Vd.16B, Vn.16B, Vm.16B + /// uint16x8_t vbicq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VBIC Qd, Qn, Qm + /// A64: BIC Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseClear(Vector128 value, Vector128 mask) => BitwiseClear(value, mask); /// - /// uint32x4_t vbicq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VBIC Qd, Qn, Qm - /// A64: BIC Vd.16B, Vn.16B, Vm.16B + /// uint32x4_t vbicq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VBIC Qd, Qn, Qm + /// A64: BIC Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseClear(Vector128 value, Vector128 mask) => BitwiseClear(value, mask); /// - /// uint64x2_t vbicq_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VBIC Qd, Qn, Qm - /// A64: BIC Vd.16B, Vn.16B, Vm.16B + /// uint64x2_t vbicq_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VBIC Qd, Qn, Qm + /// A64: BIC Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseClear(Vector128 value, Vector128 mask) => BitwiseClear(value, mask); /// - /// uint8x8_t vbsl_u8 (uint8x8_t a, uint8x8_t b, uint8x8_t c) - /// A32: VBSL Dd, Dn, Dm - /// A64: BSL Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vbsl_u8 (uint8x8_t a, uint8x8_t b, uint8x8_t c) + /// A32: VBSL Dd, Dn, Dm + /// A64: BSL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseSelect(Vector64 select, Vector64 left, Vector64 right) => BitwiseSelect(select, left, right); /// - /// float64x1_t vbsl_f64 (uint64x1_t a, float64x1_t b, float64x1_t c) - /// A32: VBSL Dd, Dn, Dm - /// A64: BSL Vd.8B, Vn.8B, Vm.8B + /// float64x1_t vbsl_f64 (uint64x1_t a, float64x1_t b, float64x1_t c) + /// A32: VBSL Dd, Dn, Dm + /// A64: BSL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseSelect(Vector64 select, Vector64 left, Vector64 right) => BitwiseSelect(select, left, right); /// - /// int16x4_t vbsl_s16 (uint16x4_t a, int16x4_t b, int16x4_t c) - /// A32: VBSL Dd, Dn, Dm - /// A64: BSL Vd.8B, Vn.8B, Vm.8B + /// int16x4_t vbsl_s16 (uint16x4_t a, int16x4_t b, int16x4_t c) + /// A32: VBSL Dd, Dn, Dm + /// A64: BSL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseSelect(Vector64 select, Vector64 left, Vector64 right) => BitwiseSelect(select, left, right); /// - /// int32x2_t vbsl_s32 (uint32x2_t a, int32x2_t b, int32x2_t c) - /// A32: VBSL Dd, Dn, Dm - /// A64: BSL Vd.8B, Vn.8B, Vm.8B + /// int32x2_t vbsl_s32 (uint32x2_t a, int32x2_t b, int32x2_t c) + /// A32: VBSL Dd, Dn, Dm + /// A64: BSL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseSelect(Vector64 select, Vector64 left, Vector64 right) => BitwiseSelect(select, left, right); /// - /// int64x1_t vbsl_s64 (uint64x1_t a, int64x1_t b, int64x1_t c) - /// A32: VBSL Dd, Dn, Dm - /// A64: BSL Vd.8B, Vn.8B, Vm.8B + /// int64x1_t vbsl_s64 (uint64x1_t a, int64x1_t b, int64x1_t c) + /// A32: VBSL Dd, Dn, Dm + /// A64: BSL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseSelect(Vector64 select, Vector64 left, Vector64 right) => BitwiseSelect(select, left, right); /// - /// int8x8_t vbsl_s8 (uint8x8_t a, int8x8_t b, int8x8_t c) - /// A32: VBSL Dd, Dn, Dm - /// A64: BSL Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vbsl_s8 (uint8x8_t a, int8x8_t b, int8x8_t c) + /// A32: VBSL Dd, Dn, Dm + /// A64: BSL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseSelect(Vector64 select, Vector64 left, Vector64 right) => BitwiseSelect(select, left, right); /// - /// float32x2_t vbsl_f32 (uint32x2_t a, float32x2_t b, float32x2_t c) - /// A32: VBSL Dd, Dn, Dm - /// A64: BSL Vd.8B, Vn.8B, Vm.8B + /// float32x2_t vbsl_f32 (uint32x2_t a, float32x2_t b, float32x2_t c) + /// A32: VBSL Dd, Dn, Dm + /// A64: BSL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseSelect(Vector64 select, Vector64 left, Vector64 right) => BitwiseSelect(select, left, right); /// - /// uint16x4_t vbsl_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t c) - /// A32: VBSL Dd, Dn, Dm - /// A64: BSL Vd.8B, Vn.8B, Vm.8B + /// uint16x4_t vbsl_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t c) + /// A32: VBSL Dd, Dn, Dm + /// A64: BSL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseSelect(Vector64 select, Vector64 left, Vector64 right) => BitwiseSelect(select, left, right); /// - /// uint32x2_t vbsl_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t c) - /// A32: VBSL Dd, Dn, Dm - /// A64: BSL Vd.8B, Vn.8B, Vm.8B + /// uint32x2_t vbsl_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t c) + /// A32: VBSL Dd, Dn, Dm + /// A64: BSL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseSelect(Vector64 select, Vector64 left, Vector64 right) => BitwiseSelect(select, left, right); /// - /// uint64x1_t vbsl_u64 (uint64x1_t a, uint64x1_t b, uint64x1_t c) - /// A32: VBSL Dd, Dn, Dm - /// A64: BSL Vd.8B, Vn.8B, Vm.8B + /// uint64x1_t vbsl_u64 (uint64x1_t a, uint64x1_t b, uint64x1_t c) + /// A32: VBSL Dd, Dn, Dm + /// A64: BSL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 BitwiseSelect(Vector64 select, Vector64 left, Vector64 right) => BitwiseSelect(select, left, right); /// - /// uint8x16_t vbslq_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c) - /// A32: VBSL Qd, Qn, Qm - /// A64: BSL Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vbslq_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c) + /// A32: VBSL Qd, Qn, Qm + /// A64: BSL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseSelect(Vector128 select, Vector128 left, Vector128 right) => BitwiseSelect(select, left, right); /// - /// float64x2_t vbslq_f64 (uint64x2_t a, float64x2_t b, float64x2_t c) - /// A32: VBSL Qd, Qn, Qm - /// A64: BSL Vd.16B, Vn.16B, Vm.16B + /// float64x2_t vbslq_f64 (uint64x2_t a, float64x2_t b, float64x2_t c) + /// A32: VBSL Qd, Qn, Qm + /// A64: BSL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseSelect(Vector128 select, Vector128 left, Vector128 right) => BitwiseSelect(select, left, right); /// - /// int16x8_t vbslq_s16 (uint16x8_t a, int16x8_t b, int16x8_t c) - /// A32: VBSL Qd, Qn, Qm - /// A64: BSL Vd.16B, Vn.16B, Vm.16B + /// int16x8_t vbslq_s16 (uint16x8_t a, int16x8_t b, int16x8_t c) + /// A32: VBSL Qd, Qn, Qm + /// A64: BSL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseSelect(Vector128 select, Vector128 left, Vector128 right) => BitwiseSelect(select, left, right); /// - /// int32x4_t vbslq_s32 (uint32x4_t a, int32x4_t b, int32x4_t c) - /// A32: VBSL Qd, Qn, Qm - /// A64: BSL Vd.16B, Vn.16B, Vm.16B + /// int32x4_t vbslq_s32 (uint32x4_t a, int32x4_t b, int32x4_t c) + /// A32: VBSL Qd, Qn, Qm + /// A64: BSL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseSelect(Vector128 select, Vector128 left, Vector128 right) => BitwiseSelect(select, left, right); /// - /// int64x2_t vbslq_s64 (uint64x2_t a, int64x2_t b, int64x2_t c) - /// A32: VBSL Qd, Qn, Qm - /// A64: BSL Vd.16B, Vn.16B, Vm.16B + /// int64x2_t vbslq_s64 (uint64x2_t a, int64x2_t b, int64x2_t c) + /// A32: VBSL Qd, Qn, Qm + /// A64: BSL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseSelect(Vector128 select, Vector128 left, Vector128 right) => BitwiseSelect(select, left, right); /// - /// int8x16_t vbslq_s8 (uint8x16_t a, int8x16_t b, int8x16_t c) - /// A32: VBSL Qd, Qn, Qm - /// A64: BSL Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vbslq_s8 (uint8x16_t a, int8x16_t b, int8x16_t c) + /// A32: VBSL Qd, Qn, Qm + /// A64: BSL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseSelect(Vector128 select, Vector128 left, Vector128 right) => BitwiseSelect(select, left, right); /// - /// float32x4_t vbslq_f32 (uint32x4_t a, float32x4_t b, float32x4_t c) - /// A32: VBSL Qd, Qn, Qm - /// A64: BSL Vd.16B, Vn.16B, Vm.16B + /// float32x4_t vbslq_f32 (uint32x4_t a, float32x4_t b, float32x4_t c) + /// A32: VBSL Qd, Qn, Qm + /// A64: BSL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseSelect(Vector128 select, Vector128 left, Vector128 right) => BitwiseSelect(select, left, right); /// - /// uint16x8_t vbslq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c) - /// A32: VBSL Qd, Qn, Qm - /// A64: BSL Vd.16B, Vn.16B, Vm.16B + /// uint16x8_t vbslq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c) + /// A32: VBSL Qd, Qn, Qm + /// A64: BSL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseSelect(Vector128 select, Vector128 left, Vector128 right) => BitwiseSelect(select, left, right); /// - /// uint32x4_t vbslq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c) - /// A32: VBSL Qd, Qn, Qm - /// A64: BSL Vd.16B, Vn.16B, Vm.16B + /// uint32x4_t vbslq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c) + /// A32: VBSL Qd, Qn, Qm + /// A64: BSL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseSelect(Vector128 select, Vector128 left, Vector128 right) => BitwiseSelect(select, left, right); /// - /// uint64x2_t vbslq_u64 (uint64x2_t a, uint64x2_t b, uint64x2_t c) - /// A32: VBSL Qd, Qn, Qm - /// A64: BSL Vd.16B, Vn.16B, Vm.16B + /// uint64x2_t vbslq_u64 (uint64x2_t a, uint64x2_t b, uint64x2_t c) + /// A32: VBSL Qd, Qn, Qm + /// A64: BSL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 BitwiseSelect(Vector128 select, Vector128 left, Vector128 right) => BitwiseSelect(select, left, right); /// - /// float32x2_t vrndp_f32 (float32x2_t a) - /// A32: VRINTP.F32 Dd, Dm - /// A64: FRINTP Vd.2S, Vn.2S + /// float32x2_t vrndp_f32 (float32x2_t a) + /// A32: VRINTP.F32 Dd, Dm + /// A64: FRINTP Vd.2S, Vn.2S /// public static Vector64 Ceiling(Vector64 value) => Ceiling(value); /// - /// float32x4_t vrndpq_f32 (float32x4_t a) - /// A32: VRINTP.F32 Qd, Qm - /// A64: FRINTP Vd.4S, Vn.4S + /// float32x4_t vrndpq_f32 (float32x4_t a) + /// A32: VRINTP.F32 Qd, Qm + /// A64: FRINTP Vd.4S, Vn.4S /// public static Vector128 Ceiling(Vector128 value) => Ceiling(value); /// - /// float64x1_t vrndp_f64 (float64x1_t a) - /// A32: VRINTP.F64 Dd, Dm - /// A64: FRINTP Dd, Dn + /// float64x1_t vrndp_f64 (float64x1_t a) + /// A32: VRINTP.F64 Dd, Dm + /// A64: FRINTP Dd, Dn /// public static Vector64 CeilingScalar(Vector64 value) => CeilingScalar(value); /// - /// float32_t vrndps_f32 (float32_t a) - /// A32: VRINTP.F32 Sd, Sm - /// A64: FRINTP Sd, Sn - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vrndps_f32 (float32_t a) + /// A32: VRINTP.F32 Sd, Sm + /// A64: FRINTP Sd, Sn + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 CeilingScalar(Vector64 value) => CeilingScalar(value); /// - /// uint8x8_t vceq_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VCEQ.I8 Dd, Dn, Dm - /// A64: CMEQ Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vceq_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VCEQ.I8 Dd, Dn, Dm + /// A64: CMEQ Vd.8B, Vn.8B, Vm.8B /// public static Vector64 CompareEqual(Vector64 left, Vector64 right) => CompareEqual(left, right); /// - /// uint16x4_t vceq_s16 (int16x4_t a, int16x4_t b) - /// A32: VCEQ.I16 Dd, Dn, Dm - /// A64: CMEQ Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vceq_s16 (int16x4_t a, int16x4_t b) + /// A32: VCEQ.I16 Dd, Dn, Dm + /// A64: CMEQ Vd.4H, Vn.4H, Vm.4H /// public static Vector64 CompareEqual(Vector64 left, Vector64 right) => CompareEqual(left, right); /// - /// uint32x2_t vceq_s32 (int32x2_t a, int32x2_t b) - /// A32: VCEQ.I32 Dd, Dn, Dm - /// A64: CMEQ Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vceq_s32 (int32x2_t a, int32x2_t b) + /// A32: VCEQ.I32 Dd, Dn, Dm + /// A64: CMEQ Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareEqual(Vector64 left, Vector64 right) => CompareEqual(left, right); /// - /// uint8x8_t vceq_s8 (int8x8_t a, int8x8_t b) - /// A32: VCEQ.I8 Dd, Dn, Dm - /// A64: CMEQ Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vceq_s8 (int8x8_t a, int8x8_t b) + /// A32: VCEQ.I8 Dd, Dn, Dm + /// A64: CMEQ Vd.8B, Vn.8B, Vm.8B /// public static Vector64 CompareEqual(Vector64 left, Vector64 right) => CompareEqual(left, right); /// - /// uint32x2_t vceq_f32 (float32x2_t a, float32x2_t b) - /// A32: VCEQ.F32 Dd, Dn, Dm - /// A64: FCMEQ Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vceq_f32 (float32x2_t a, float32x2_t b) + /// A32: VCEQ.F32 Dd, Dn, Dm + /// A64: FCMEQ Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareEqual(Vector64 left, Vector64 right) => CompareEqual(left, right); /// - /// uint16x4_t vceq_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VCEQ.I16 Dd, Dn, Dm - /// A64: CMEQ Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vceq_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VCEQ.I16 Dd, Dn, Dm + /// A64: CMEQ Vd.4H, Vn.4H, Vm.4H /// public static Vector64 CompareEqual(Vector64 left, Vector64 right) => CompareEqual(left, right); /// - /// uint32x2_t vceq_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VCEQ.I32 Dd, Dn, Dm - /// A64: CMEQ Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vceq_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VCEQ.I32 Dd, Dn, Dm + /// A64: CMEQ Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareEqual(Vector64 left, Vector64 right) => CompareEqual(left, right); /// - /// uint8x16_t vceqq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VCEQ.I8 Qd, Qn, Qm - /// A64: CMEQ Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vceqq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VCEQ.I8 Qd, Qn, Qm + /// A64: CMEQ Vd.16B, Vn.16B, Vm.16B /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// - /// uint16x8_t vceqq_s16 (int16x8_t a, int16x8_t b) - /// A32: VCEQ.I16 Qd, Qn, Qm - /// A64: CMEQ Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vceqq_s16 (int16x8_t a, int16x8_t b) + /// A32: VCEQ.I16 Qd, Qn, Qm + /// A64: CMEQ Vd.8H, Vn.8H, Vm.8H /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// - /// uint32x4_t vceqq_s32 (int32x4_t a, int32x4_t b) - /// A32: VCEQ.I32 Qd, Qn, Qm - /// A64: CMEQ Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vceqq_s32 (int32x4_t a, int32x4_t b) + /// A32: VCEQ.I32 Qd, Qn, Qm + /// A64: CMEQ Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// - /// uint8x16_t vceqq_s8 (int8x16_t a, int8x16_t b) - /// A32: VCEQ.I8 Qd, Qn, Qm - /// A64: CMEQ Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vceqq_s8 (int8x16_t a, int8x16_t b) + /// A32: VCEQ.I8 Qd, Qn, Qm + /// A64: CMEQ Vd.16B, Vn.16B, Vm.16B /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// - /// uint32x4_t vceqq_f32 (float32x4_t a, float32x4_t b) - /// A32: VCEQ.F32 Qd, Qn, Qm - /// A64: FCMEQ Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vceqq_f32 (float32x4_t a, float32x4_t b) + /// A32: VCEQ.F32 Qd, Qn, Qm + /// A64: FCMEQ Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// - /// uint16x8_t vceqq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VCEQ.I16 Qd, Qn, Qm - /// A64: CMEQ Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vceqq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VCEQ.I16 Qd, Qn, Qm + /// A64: CMEQ Vd.8H, Vn.8H, Vm.8H /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// - /// uint32x4_t vceqq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VCEQ.I32 Qd, Qn, Qm - /// A64: CMEQ Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vceqq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VCEQ.I32 Qd, Qn, Qm + /// A64: CMEQ Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// - /// uint8x8_t vcgt_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VCGT.U8 Dd, Dn, Dm - /// A64: CMHI Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vcgt_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VCGT.U8 Dd, Dn, Dm + /// A64: CMHI Vd.8B, Vn.8B, Vm.8B /// public static Vector64 CompareGreaterThan(Vector64 left, Vector64 right) => CompareGreaterThan(left, right); /// - /// uint16x4_t vcgt_s16 (int16x4_t a, int16x4_t b) - /// A32: VCGT.S16 Dd, Dn, Dm - /// A64: CMGT Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vcgt_s16 (int16x4_t a, int16x4_t b) + /// A32: VCGT.S16 Dd, Dn, Dm + /// A64: CMGT Vd.4H, Vn.4H, Vm.4H /// public static Vector64 CompareGreaterThan(Vector64 left, Vector64 right) => CompareGreaterThan(left, right); /// - /// uint32x2_t vcgt_s32 (int32x2_t a, int32x2_t b) - /// A32: VCGT.S32 Dd, Dn, Dm - /// A64: CMGT Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcgt_s32 (int32x2_t a, int32x2_t b) + /// A32: VCGT.S32 Dd, Dn, Dm + /// A64: CMGT Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareGreaterThan(Vector64 left, Vector64 right) => CompareGreaterThan(left, right); /// - /// uint8x8_t vcgt_s8 (int8x8_t a, int8x8_t b) - /// A32: VCGT.S8 Dd, Dn, Dm - /// A64: CMGT Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vcgt_s8 (int8x8_t a, int8x8_t b) + /// A32: VCGT.S8 Dd, Dn, Dm + /// A64: CMGT Vd.8B, Vn.8B, Vm.8B /// public static Vector64 CompareGreaterThan(Vector64 left, Vector64 right) => CompareGreaterThan(left, right); /// - /// uint32x2_t vcgt_f32 (float32x2_t a, float32x2_t b) - /// A32: VCGT.F32 Dd, Dn, Dm - /// A64: FCMGT Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcgt_f32 (float32x2_t a, float32x2_t b) + /// A32: VCGT.F32 Dd, Dn, Dm + /// A64: FCMGT Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareGreaterThan(Vector64 left, Vector64 right) => CompareGreaterThan(left, right); /// - /// uint16x4_t vcgt_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VCGT.U16 Dd, Dn, Dm - /// A64: CMHI Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vcgt_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VCGT.U16 Dd, Dn, Dm + /// A64: CMHI Vd.4H, Vn.4H, Vm.4H /// public static Vector64 CompareGreaterThan(Vector64 left, Vector64 right) => CompareGreaterThan(left, right); /// - /// uint32x2_t vcgt_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VCGT.U32 Dd, Dn, Dm - /// A64: CMHI Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcgt_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VCGT.U32 Dd, Dn, Dm + /// A64: CMHI Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareGreaterThan(Vector64 left, Vector64 right) => CompareGreaterThan(left, right); /// - /// uint8x16_t vcgtq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VCGT.U8 Qd, Qn, Qm - /// A64: CMHI Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vcgtq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VCGT.U8 Qd, Qn, Qm + /// A64: CMHI Vd.16B, Vn.16B, Vm.16B /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// - /// uint16x8_t vcgtq_s16 (int16x8_t a, int16x8_t b) - /// A32: VCGT.S16 Qd, Qn, Qm - /// A64: CMGT Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vcgtq_s16 (int16x8_t a, int16x8_t b) + /// A32: VCGT.S16 Qd, Qn, Qm + /// A64: CMGT Vd.8H, Vn.8H, Vm.8H /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// - /// uint32x4_t vcgtq_s32 (int32x4_t a, int32x4_t b) - /// A32: VCGT.S32 Qd, Qn, Qm - /// A64: CMGT Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcgtq_s32 (int32x4_t a, int32x4_t b) + /// A32: VCGT.S32 Qd, Qn, Qm + /// A64: CMGT Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// - /// uint8x16_t vcgtq_s8 (int8x16_t a, int8x16_t b) - /// A32: VCGT.S8 Qd, Qn, Qm - /// A64: CMGT Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vcgtq_s8 (int8x16_t a, int8x16_t b) + /// A32: VCGT.S8 Qd, Qn, Qm + /// A64: CMGT Vd.16B, Vn.16B, Vm.16B /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// - /// uint32x4_t vcgtq_f32 (float32x4_t a, float32x4_t b) - /// A32: VCGT.F32 Qd, Qn, Qm - /// A64: FCMGT Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcgtq_f32 (float32x4_t a, float32x4_t b) + /// A32: VCGT.F32 Qd, Qn, Qm + /// A64: FCMGT Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// - /// uint16x8_t vcgtq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VCGT.U16 Qd, Qn, Qm - /// A64: CMHI Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vcgtq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VCGT.U16 Qd, Qn, Qm + /// A64: CMHI Vd.8H, Vn.8H, Vm.8H /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// - /// uint32x4_t vcgtq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VCGT.U32 Qd, Qn, Qm - /// A64: CMHI Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcgtq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VCGT.U32 Qd, Qn, Qm + /// A64: CMHI Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// - /// uint8x8_t vcge_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VCGE.U8 Dd, Dn, Dm - /// A64: CMHS Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vcge_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VCGE.U8 Dd, Dn, Dm + /// A64: CMHS Vd.8B, Vn.8B, Vm.8B /// public static Vector64 CompareGreaterThanOrEqual(Vector64 left, Vector64 right) => CompareGreaterThanOrEqual(left, right); /// - /// uint16x4_t vcge_s16 (int16x4_t a, int16x4_t b) - /// A32: VCGE.S16 Dd, Dn, Dm - /// A64: CMGE Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vcge_s16 (int16x4_t a, int16x4_t b) + /// A32: VCGE.S16 Dd, Dn, Dm + /// A64: CMGE Vd.4H, Vn.4H, Vm.4H /// public static Vector64 CompareGreaterThanOrEqual(Vector64 left, Vector64 right) => CompareGreaterThanOrEqual(left, right); /// - /// uint32x2_t vcge_s32 (int32x2_t a, int32x2_t b) - /// A32: VCGE.S32 Dd, Dn, Dm - /// A64: CMGE Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcge_s32 (int32x2_t a, int32x2_t b) + /// A32: VCGE.S32 Dd, Dn, Dm + /// A64: CMGE Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareGreaterThanOrEqual(Vector64 left, Vector64 right) => CompareGreaterThanOrEqual(left, right); /// - /// uint8x8_t vcge_s8 (int8x8_t a, int8x8_t b) - /// A32: VCGE.S8 Dd, Dn, Dm - /// A64: CMGE Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vcge_s8 (int8x8_t a, int8x8_t b) + /// A32: VCGE.S8 Dd, Dn, Dm + /// A64: CMGE Vd.8B, Vn.8B, Vm.8B /// public static Vector64 CompareGreaterThanOrEqual(Vector64 left, Vector64 right) => CompareGreaterThanOrEqual(left, right); /// - /// uint32x2_t vcge_f32 (float32x2_t a, float32x2_t b) - /// A32: VCGE.F32 Dd, Dn, Dm - /// A64: FCMGE Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcge_f32 (float32x2_t a, float32x2_t b) + /// A32: VCGE.F32 Dd, Dn, Dm + /// A64: FCMGE Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareGreaterThanOrEqual(Vector64 left, Vector64 right) => CompareGreaterThanOrEqual(left, right); /// - /// uint16x4_t vcge_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VCGE.U16 Dd, Dn, Dm - /// A64: CMHS Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vcge_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VCGE.U16 Dd, Dn, Dm + /// A64: CMHS Vd.4H, Vn.4H, Vm.4H /// public static Vector64 CompareGreaterThanOrEqual(Vector64 left, Vector64 right) => CompareGreaterThanOrEqual(left, right); /// - /// uint32x2_t vcge_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VCGE.U32 Dd, Dn, Dm - /// A64: CMHS Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcge_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VCGE.U32 Dd, Dn, Dm + /// A64: CMHS Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareGreaterThanOrEqual(Vector64 left, Vector64 right) => CompareGreaterThanOrEqual(left, right); /// - /// uint8x16_t vcgeq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VCGE.U8 Qd, Qn, Qm - /// A64: CMHS Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vcgeq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VCGE.U8 Qd, Qn, Qm + /// A64: CMHS Vd.16B, Vn.16B, Vm.16B /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// uint16x8_t vcgeq_s16 (int16x8_t a, int16x8_t b) - /// A32: VCGE.S16 Qd, Qn, Qm - /// A64: CMGE Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vcgeq_s16 (int16x8_t a, int16x8_t b) + /// A32: VCGE.S16 Qd, Qn, Qm + /// A64: CMGE Vd.8H, Vn.8H, Vm.8H /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// uint32x4_t vcgeq_s32 (int32x4_t a, int32x4_t b) - /// A32: VCGE.S32 Qd, Qn, Qm - /// A64: CMGE Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcgeq_s32 (int32x4_t a, int32x4_t b) + /// A32: VCGE.S32 Qd, Qn, Qm + /// A64: CMGE Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// uint8x16_t vcgeq_s8 (int8x16_t a, int8x16_t b) - /// A32: VCGE.S8 Qd, Qn, Qm - /// A64: CMGE Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vcgeq_s8 (int8x16_t a, int8x16_t b) + /// A32: VCGE.S8 Qd, Qn, Qm + /// A64: CMGE Vd.16B, Vn.16B, Vm.16B /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// uint32x4_t vcgeq_f32 (float32x4_t a, float32x4_t b) - /// A32: VCGE.F32 Qd, Qn, Qm - /// A64: FCMGE Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcgeq_f32 (float32x4_t a, float32x4_t b) + /// A32: VCGE.F32 Qd, Qn, Qm + /// A64: FCMGE Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// uint16x8_t vcgeq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VCGE.U16 Qd, Qn, Qm - /// A64: CMHS Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vcgeq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VCGE.U16 Qd, Qn, Qm + /// A64: CMHS Vd.8H, Vn.8H, Vm.8H /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// uint32x4_t vcgeq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VCGE.U32 Qd, Qn, Qm - /// A64: CMHS Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcgeq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VCGE.U32 Qd, Qn, Qm + /// A64: CMHS Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// uint8x8_t vclt_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VCLT.U8 Dd, Dn, Dm - /// A64: CMHI Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vclt_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VCLT.U8 Dd, Dn, Dm + /// A64: CMHI Vd.8B, Vn.8B, Vm.8B /// public static Vector64 CompareLessThan(Vector64 left, Vector64 right) => CompareLessThan(left, right); /// - /// uint16x4_t vclt_s16 (int16x4_t a, int16x4_t b) - /// A32: VCLT.S16 Dd, Dn, Dm - /// A64: CMGT Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vclt_s16 (int16x4_t a, int16x4_t b) + /// A32: VCLT.S16 Dd, Dn, Dm + /// A64: CMGT Vd.4H, Vn.4H, Vm.4H /// public static Vector64 CompareLessThan(Vector64 left, Vector64 right) => CompareLessThan(left, right); /// - /// uint32x2_t vclt_s32 (int32x2_t a, int32x2_t b) - /// A32: VCLT.S32 Dd, Dn, Dm - /// A64: CMGT Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vclt_s32 (int32x2_t a, int32x2_t b) + /// A32: VCLT.S32 Dd, Dn, Dm + /// A64: CMGT Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareLessThan(Vector64 left, Vector64 right) => CompareLessThan(left, right); /// - /// uint8x8_t vclt_s8 (int8x8_t a, int8x8_t b) - /// A32: VCLT.S8 Dd, Dn, Dm - /// A64: CMGT Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vclt_s8 (int8x8_t a, int8x8_t b) + /// A32: VCLT.S8 Dd, Dn, Dm + /// A64: CMGT Vd.8B, Vn.8B, Vm.8B /// public static Vector64 CompareLessThan(Vector64 left, Vector64 right) => CompareLessThan(left, right); /// - /// uint32x2_t vclt_f32 (float32x2_t a, float32x2_t b) - /// A32: VCLT.F32 Dd, Dn, Dm - /// A64: FCMGT Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vclt_f32 (float32x2_t a, float32x2_t b) + /// A32: VCLT.F32 Dd, Dn, Dm + /// A64: FCMGT Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareLessThan(Vector64 left, Vector64 right) => CompareLessThan(left, right); /// - /// uint16x4_t vclt_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VCLT.U16 Dd, Dn, Dm - /// A64: CMHI Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vclt_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VCLT.U16 Dd, Dn, Dm + /// A64: CMHI Vd.4H, Vn.4H, Vm.4H /// public static Vector64 CompareLessThan(Vector64 left, Vector64 right) => CompareLessThan(left, right); /// - /// uint32x2_t vclt_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VCLT.U32 Dd, Dn, Dm - /// A64: CMHI Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vclt_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VCLT.U32 Dd, Dn, Dm + /// A64: CMHI Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareLessThan(Vector64 left, Vector64 right) => CompareLessThan(left, right); /// - /// uint8x16_t vcltq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VCLT.U8 Qd, Qn, Qm - /// A64: CMHI Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vcltq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VCLT.U8 Qd, Qn, Qm + /// A64: CMHI Vd.16B, Vn.16B, Vm.16B /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// uint16x8_t vcltq_s16 (int16x8_t a, int16x8_t b) - /// A32: VCLT.S16 Qd, Qn, Qm - /// A64: CMGT Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vcltq_s16 (int16x8_t a, int16x8_t b) + /// A32: VCLT.S16 Qd, Qn, Qm + /// A64: CMGT Vd.8H, Vn.8H, Vm.8H /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// uint32x4_t vcltq_s32 (int32x4_t a, int32x4_t b) - /// A32: VCLT.S32 Qd, Qn, Qm - /// A64: CMGT Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcltq_s32 (int32x4_t a, int32x4_t b) + /// A32: VCLT.S32 Qd, Qn, Qm + /// A64: CMGT Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// uint8x16_t vcltq_s8 (int8x16_t a, int8x16_t b) - /// A32: VCLT.S8 Qd, Qn, Qm - /// A64: CMGT Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vcltq_s8 (int8x16_t a, int8x16_t b) + /// A32: VCLT.S8 Qd, Qn, Qm + /// A64: CMGT Vd.16B, Vn.16B, Vm.16B /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// uint32x4_t vcltq_f32 (float32x4_t a, float32x4_t b) - /// A32: VCLT.F32 Qd, Qn, Qm - /// A64: FCMGT Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcltq_f32 (float32x4_t a, float32x4_t b) + /// A32: VCLT.F32 Qd, Qn, Qm + /// A64: FCMGT Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// uint16x8_t vcltq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VCLT.U16 Qd, Qn, Qm - /// A64: CMHI Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vcltq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VCLT.U16 Qd, Qn, Qm + /// A64: CMHI Vd.8H, Vn.8H, Vm.8H /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// uint32x4_t vcltq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VCLT.U32 Qd, Qn, Qm - /// A64: CMHI Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcltq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VCLT.U32 Qd, Qn, Qm + /// A64: CMHI Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// uint8x8_t vcle_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VCLE.U8 Dd, Dn, Dm - /// A64: CMHS Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vcle_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VCLE.U8 Dd, Dn, Dm + /// A64: CMHS Vd.8B, Vn.8B, Vm.8B /// public static Vector64 CompareLessThanOrEqual(Vector64 left, Vector64 right) => CompareLessThanOrEqual(left, right); /// - /// uint16x4_t vcle_s16 (int16x4_t a, int16x4_t b) - /// A32: VCLE.S16 Dd, Dn, Dm - /// A64: CMGE Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vcle_s16 (int16x4_t a, int16x4_t b) + /// A32: VCLE.S16 Dd, Dn, Dm + /// A64: CMGE Vd.4H, Vn.4H, Vm.4H /// public static Vector64 CompareLessThanOrEqual(Vector64 left, Vector64 right) => CompareLessThanOrEqual(left, right); /// - /// uint32x2_t vcle_s32 (int32x2_t a, int32x2_t b) - /// A32: VCLE.S32 Dd, Dn, Dm - /// A64: CMGE Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcle_s32 (int32x2_t a, int32x2_t b) + /// A32: VCLE.S32 Dd, Dn, Dm + /// A64: CMGE Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareLessThanOrEqual(Vector64 left, Vector64 right) => CompareLessThanOrEqual(left, right); /// - /// uint8x8_t vcle_s8 (int8x8_t a, int8x8_t b) - /// A32: VCLE.S8 Dd, Dn, Dm - /// A64: CMGE Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vcle_s8 (int8x8_t a, int8x8_t b) + /// A32: VCLE.S8 Dd, Dn, Dm + /// A64: CMGE Vd.8B, Vn.8B, Vm.8B /// public static Vector64 CompareLessThanOrEqual(Vector64 left, Vector64 right) => CompareLessThanOrEqual(left, right); /// - /// uint32x2_t vcle_f32 (float32x2_t a, float32x2_t b) - /// A32: VCLE.F32 Dd, Dn, Dm - /// A64: FCMGE Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcle_f32 (float32x2_t a, float32x2_t b) + /// A32: VCLE.F32 Dd, Dn, Dm + /// A64: FCMGE Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareLessThanOrEqual(Vector64 left, Vector64 right) => CompareLessThanOrEqual(left, right); /// - /// uint16x4_t vcle_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VCLE.U16 Dd, Dn, Dm - /// A64: CMHS Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vcle_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VCLE.U16 Dd, Dn, Dm + /// A64: CMHS Vd.4H, Vn.4H, Vm.4H /// public static Vector64 CompareLessThanOrEqual(Vector64 left, Vector64 right) => CompareLessThanOrEqual(left, right); /// - /// uint32x2_t vcle_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VCLE.U32 Dd, Dn, Dm - /// A64: CMHS Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vcle_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VCLE.U32 Dd, Dn, Dm + /// A64: CMHS Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareLessThanOrEqual(Vector64 left, Vector64 right) => CompareLessThanOrEqual(left, right); /// - /// uint8x16_t vcleq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VCLE.U8 Qd, Qn, Qm - /// A64: CMHS Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vcleq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VCLE.U8 Qd, Qn, Qm + /// A64: CMHS Vd.16B, Vn.16B, Vm.16B /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// uint16x8_t vcleq_s16 (int16x8_t a, int16x8_t b) - /// A32: VCLE.S16 Qd, Qn, Qm - /// A64: CMGE Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vcleq_s16 (int16x8_t a, int16x8_t b) + /// A32: VCLE.S16 Qd, Qn, Qm + /// A64: CMGE Vd.8H, Vn.8H, Vm.8H /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// uint32x4_t vcleq_s32 (int32x4_t a, int32x4_t b) - /// A32: VCLE.S32 Qd, Qn, Qm - /// A64: CMGE Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcleq_s32 (int32x4_t a, int32x4_t b) + /// A32: VCLE.S32 Qd, Qn, Qm + /// A64: CMGE Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// uint8x16_t vcleq_s8 (int8x16_t a, int8x16_t b) - /// A32: VCLE.S8 Qd, Qn, Qm - /// A64: CMGE Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vcleq_s8 (int8x16_t a, int8x16_t b) + /// A32: VCLE.S8 Qd, Qn, Qm + /// A64: CMGE Vd.16B, Vn.16B, Vm.16B /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// uint32x4_t vcleq_f32 (float32x4_t a, float32x4_t b) - /// A32: VCLE.F32 Qd, Qn, Qm - /// A64: FCMGE Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcleq_f32 (float32x4_t a, float32x4_t b) + /// A32: VCLE.F32 Qd, Qn, Qm + /// A64: FCMGE Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// uint16x8_t vcleq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VCLE.U16 Qd, Qn, Qm - /// A64: CMHS Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vcleq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VCLE.U16 Qd, Qn, Qm + /// A64: CMHS Vd.8H, Vn.8H, Vm.8H /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// uint32x4_t vcleq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VCLE.U32 Qd, Qn, Qm - /// A64: CMHS Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vcleq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VCLE.U32 Qd, Qn, Qm + /// A64: CMHS Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// uint8x8_t vtst_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VTST.8 Dd, Dn, Dm - /// A64: CMTST Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vtst_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VTST.8 Dd, Dn, Dm + /// A64: CMTST Vd.8B, Vn.8B, Vm.8B /// public static Vector64 CompareTest(Vector64 left, Vector64 right) => CompareTest(left, right); /// - /// uint16x4_t vtst_s16 (int16x4_t a, int16x4_t b) - /// A32: VTST.16 Dd, Dn, Dm - /// A64: CMTST Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vtst_s16 (int16x4_t a, int16x4_t b) + /// A32: VTST.16 Dd, Dn, Dm + /// A64: CMTST Vd.4H, Vn.4H, Vm.4H /// public static Vector64 CompareTest(Vector64 left, Vector64 right) => CompareTest(left, right); /// - /// uint32x2_t vtst_s32 (int32x2_t a, int32x2_t b) - /// A32: VTST.32 Dd, Dn, Dm - /// A64: CMTST Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vtst_s32 (int32x2_t a, int32x2_t b) + /// A32: VTST.32 Dd, Dn, Dm + /// A64: CMTST Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareTest(Vector64 left, Vector64 right) => CompareTest(left, right); /// - /// uint8x8_t vtst_s8 (int8x8_t a, int8x8_t b) - /// A32: VTST.8 Dd, Dn, Dm - /// A64: CMTST Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vtst_s8 (int8x8_t a, int8x8_t b) + /// A32: VTST.8 Dd, Dn, Dm + /// A64: CMTST Vd.8B, Vn.8B, Vm.8B /// public static Vector64 CompareTest(Vector64 left, Vector64 right) => CompareTest(left, right); /// - /// uint32x2_t vtst_f32 (float32x2_t a, float32x2_t b) - /// A32: VTST.32 Dd, Dn, Dm - /// A64: CMTST Vd.2S, Vn.2S, Vm.2S - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// uint32x2_t vtst_f32 (float32x2_t a, float32x2_t b) + /// A32: VTST.32 Dd, Dn, Dm + /// A64: CMTST Vd.2S, Vn.2S, Vm.2S + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 CompareTest(Vector64 left, Vector64 right) => CompareTest(left, right); /// - /// uint16x4_t vtst_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VTST.16 Dd, Dn, Dm - /// A64: CMTST Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vtst_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VTST.16 Dd, Dn, Dm + /// A64: CMTST Vd.4H, Vn.4H, Vm.4H /// public static Vector64 CompareTest(Vector64 left, Vector64 right) => CompareTest(left, right); /// - /// uint32x2_t vtst_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VTST.32 Dd, Dn, Dm - /// A64: CMTST Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vtst_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VTST.32 Dd, Dn, Dm + /// A64: CMTST Vd.2S, Vn.2S, Vm.2S /// public static Vector64 CompareTest(Vector64 left, Vector64 right) => CompareTest(left, right); /// - /// uint8x16_t vtstq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VTST.8 Qd, Qn, Qm - /// A64: CMTST Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vtstq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VTST.8 Qd, Qn, Qm + /// A64: CMTST Vd.16B, Vn.16B, Vm.16B /// public static Vector128 CompareTest(Vector128 left, Vector128 right) => CompareTest(left, right); /// - /// uint16x8_t vtstq_s16 (int16x8_t a, int16x8_t b) - /// A32: VTST.16 Qd, Qn, Qm - /// A64: CMTST Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vtstq_s16 (int16x8_t a, int16x8_t b) + /// A32: VTST.16 Qd, Qn, Qm + /// A64: CMTST Vd.8H, Vn.8H, Vm.8H /// public static Vector128 CompareTest(Vector128 left, Vector128 right) => CompareTest(left, right); /// - /// uint32x4_t vtstq_s32 (int32x4_t a, int32x4_t b) - /// A32: VTST.32 Qd, Qn, Qm - /// A64: CMTST Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vtstq_s32 (int32x4_t a, int32x4_t b) + /// A32: VTST.32 Qd, Qn, Qm + /// A64: CMTST Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareTest(Vector128 left, Vector128 right) => CompareTest(left, right); /// - /// uint8x16_t vtstq_s8 (int8x16_t a, int8x16_t b) - /// A32: VTST.8 Qd, Qn, Qm - /// A64: CMTST Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vtstq_s8 (int8x16_t a, int8x16_t b) + /// A32: VTST.8 Qd, Qn, Qm + /// A64: CMTST Vd.16B, Vn.16B, Vm.16B /// public static Vector128 CompareTest(Vector128 left, Vector128 right) => CompareTest(left, right); /// - /// uint32x4_t vtstq_f32 (float32x4_t a, float32x4_t b) - /// A32: VTST.32 Qd, Qn, Qm - /// A64: CMTST Vd.4S, Vn.4S, Vm.4S - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// uint32x4_t vtstq_f32 (float32x4_t a, float32x4_t b) + /// A32: VTST.32 Qd, Qn, Qm + /// A64: CMTST Vd.4S, Vn.4S, Vm.4S + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 CompareTest(Vector128 left, Vector128 right) => CompareTest(left, right); /// - /// uint16x8_t vtstq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VTST.16 Qd, Qn, Qm - /// A64: CMTST Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vtstq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VTST.16 Qd, Qn, Qm + /// A64: CMTST Vd.8H, Vn.8H, Vm.8H /// public static Vector128 CompareTest(Vector128 left, Vector128 right) => CompareTest(left, right); /// - /// uint32x4_t vtstq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VTST.32 Qd, Qn, Qm - /// A64: CMTST Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vtstq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VTST.32 Qd, Qn, Qm + /// A64: CMTST Vd.4S, Vn.4S, Vm.4S /// public static Vector128 CompareTest(Vector128 left, Vector128 right) => CompareTest(left, right); /// - /// int32x2_t vcvta_s32_f32 (float32x2_t a) - /// A32: VCVTA.S32.F32 Dd, Dm - /// A64: FCVTAS Vd.2S, Vn.2S + /// int32x2_t vcvta_s32_f32 (float32x2_t a) + /// A32: VCVTA.S32.F32 Dd, Dm + /// A64: FCVTAS Vd.2S, Vn.2S /// public static Vector64 ConvertToInt32RoundAwayFromZero(Vector64 value) => ConvertToInt32RoundAwayFromZero(value); /// - /// int32x4_t vcvtaq_s32_f32 (float32x4_t a) - /// A32: VCVTA.S32.F32 Qd, Qm - /// A64: FCVTAS Vd.4S, Vn.4S + /// int32x4_t vcvtaq_s32_f32 (float32x4_t a) + /// A32: VCVTA.S32.F32 Qd, Qm + /// A64: FCVTAS Vd.4S, Vn.4S /// public static Vector128 ConvertToInt32RoundAwayFromZero(Vector128 value) => ConvertToInt32RoundAwayFromZero(value); /// - /// int32_t vcvtas_s32_f32 (float32_t a) - /// A32: VCVTA.S32.F32 Sd, Sm - /// A64: FCVTAS Sd, Sn + /// int32_t vcvtas_s32_f32 (float32_t a) + /// A32: VCVTA.S32.F32 Sd, Sm + /// A64: FCVTAS Sd, Sn /// public static Vector64 ConvertToInt32RoundAwayFromZeroScalar(Vector64 value) => ConvertToInt32RoundAwayFromZeroScalar(value); /// - /// int32x2_t vcvtn_s32_f32 (float32x2_t a) - /// A32: VCVTN.S32.F32 Dd, Dm - /// A64: FCVTNS Vd.2S, Vn.2S + /// int32x2_t vcvtn_s32_f32 (float32x2_t a) + /// A32: VCVTN.S32.F32 Dd, Dm + /// A64: FCVTNS Vd.2S, Vn.2S /// public static Vector64 ConvertToInt32RoundToEven(Vector64 value) => ConvertToInt32RoundToEven(value); /// - /// int32x4_t vcvtnq_s32_f32 (float32x4_t a) - /// A32: VCVTN.S32.F32 Qd, Qm - /// A64: FCVTNS Vd.4S, Vn.4S + /// int32x4_t vcvtnq_s32_f32 (float32x4_t a) + /// A32: VCVTN.S32.F32 Qd, Qm + /// A64: FCVTNS Vd.4S, Vn.4S /// public static Vector128 ConvertToInt32RoundToEven(Vector128 value) => ConvertToInt32RoundToEven(value); /// - /// int32_t vcvtns_s32_f32 (float32_t a) - /// A32: VCVTN.S32.F32 Sd, Sm - /// A64: FCVTNS Sd, Sn + /// int32_t vcvtns_s32_f32 (float32_t a) + /// A32: VCVTN.S32.F32 Sd, Sm + /// A64: FCVTNS Sd, Sn /// public static Vector64 ConvertToInt32RoundToEvenScalar(Vector64 value) => ConvertToInt32RoundToEvenScalar(value); /// - /// int32x2_t vcvtm_s32_f32 (float32x2_t a) - /// A32: VCVTM.S32.F32 Dd, Dm - /// A64: FCVTMS Vd.2S, Vn.2S + /// int32x2_t vcvtm_s32_f32 (float32x2_t a) + /// A32: VCVTM.S32.F32 Dd, Dm + /// A64: FCVTMS Vd.2S, Vn.2S /// public static Vector64 ConvertToInt32RoundToNegativeInfinity(Vector64 value) => ConvertToInt32RoundToNegativeInfinity(value); /// - /// int32x4_t vcvtmq_s32_f32 (float32x4_t a) - /// A32: VCVTM.S32.F32 Qd, Qm - /// A64: FCVTMS Vd.4S, Vn.4S + /// int32x4_t vcvtmq_s32_f32 (float32x4_t a) + /// A32: VCVTM.S32.F32 Qd, Qm + /// A64: FCVTMS Vd.4S, Vn.4S /// public static Vector128 ConvertToInt32RoundToNegativeInfinity(Vector128 value) => ConvertToInt32RoundToNegativeInfinity(value); /// - /// int32_t vcvtms_s32_f32 (float32_t a) - /// A32: VCVTM.S32.F32 Sd, Sm - /// A64: FCVTMS Sd, Sn + /// int32_t vcvtms_s32_f32 (float32_t a) + /// A32: VCVTM.S32.F32 Sd, Sm + /// A64: FCVTMS Sd, Sn /// public static Vector64 ConvertToInt32RoundToNegativeInfinityScalar(Vector64 value) => ConvertToInt32RoundToNegativeInfinityScalar(value); /// - /// int32x2_t vcvtp_s32_f32 (float32x2_t a) - /// A32: VCVTP.S32.F32 Dd, Dm - /// A64: FCVTPS Vd.2S, Vn.2S + /// int32x2_t vcvtp_s32_f32 (float32x2_t a) + /// A32: VCVTP.S32.F32 Dd, Dm + /// A64: FCVTPS Vd.2S, Vn.2S /// public static Vector64 ConvertToInt32RoundToPositiveInfinity(Vector64 value) => ConvertToInt32RoundToPositiveInfinity(value); /// - /// int32x4_t vcvtpq_s32_f32 (float32x4_t a) - /// A32: VCVTP.S32.F32 Qd, Qm - /// A64: FCVTPS Vd.4S, Vn.4S + /// int32x4_t vcvtpq_s32_f32 (float32x4_t a) + /// A32: VCVTP.S32.F32 Qd, Qm + /// A64: FCVTPS Vd.4S, Vn.4S /// public static Vector128 ConvertToInt32RoundToPositiveInfinity(Vector128 value) => ConvertToInt32RoundToPositiveInfinity(value); /// - /// int32_t vcvtps_s32_f32 (float32_t a) - /// A32: VCVTP.S32.F32 Sd, Sm - /// A64: FCVTPS Sd, Sn + /// int32_t vcvtps_s32_f32 (float32_t a) + /// A32: VCVTP.S32.F32 Sd, Sm + /// A64: FCVTPS Sd, Sn /// public static Vector64 ConvertToInt32RoundToPositiveInfinityScalar(Vector64 value) => ConvertToInt32RoundToPositiveInfinityScalar(value); /// - /// int32x2_t vcvt_s32_f32 (float32x2_t a) - /// A32: VCVT.S32.F32 Dd, Dm - /// A64: FCVTZS Vd.2S, Vn.2S + /// int32x2_t vcvt_s32_f32 (float32x2_t a) + /// A32: VCVT.S32.F32 Dd, Dm + /// A64: FCVTZS Vd.2S, Vn.2S /// public static Vector64 ConvertToInt32RoundToZero(Vector64 value) => ConvertToInt32RoundToZero(value); /// - /// int32x4_t vcvtq_s32_f32 (float32x4_t a) - /// A32: VCVT.S32.F32 Qd, Qm - /// A64: FCVTZS Vd.4S, Vn.4S + /// int32x4_t vcvtq_s32_f32 (float32x4_t a) + /// A32: VCVT.S32.F32 Qd, Qm + /// A64: FCVTZS Vd.4S, Vn.4S /// public static Vector128 ConvertToInt32RoundToZero(Vector128 value) => ConvertToInt32RoundToZero(value); /// - /// int32_t vcvts_s32_f32 (float32_t a) - /// A32: VCVT.S32.F32 Sd, Sm - /// A64: FCVTZS Sd, Sn + /// int32_t vcvts_s32_f32 (float32_t a) + /// A32: VCVT.S32.F32 Sd, Sm + /// A64: FCVTZS Sd, Sn /// public static Vector64 ConvertToInt32RoundToZeroScalar(Vector64 value) => ConvertToInt32RoundToZeroScalar(value); /// - /// float32x2_t vcvt_f32_s32 (int32x2_t a) - /// A32: VCVT.F32.S32 Dd, Dm - /// A64: SCVTF Vd.2S, Vn.2S + /// float32x2_t vcvt_f32_s32 (int32x2_t a) + /// A32: VCVT.F32.S32 Dd, Dm + /// A64: SCVTF Vd.2S, Vn.2S /// public static Vector64 ConvertToSingle(Vector64 value) => ConvertToSingle(value); /// - /// float32x2_t vcvt_f32_u32 (uint32x2_t a) - /// A32: VCVT.F32.U32 Dd, Dm - /// A64: UCVTF Vd.2S, Vn.2S + /// float32x2_t vcvt_f32_u32 (uint32x2_t a) + /// A32: VCVT.F32.U32 Dd, Dm + /// A64: UCVTF Vd.2S, Vn.2S /// public static Vector64 ConvertToSingle(Vector64 value) => ConvertToSingle(value); /// - /// float32x4_t vcvtq_f32_s32 (int32x4_t a) - /// A32: VCVT.F32.S32 Qd, Qm - /// A64: SCVTF Vd.4S, Vn.4S + /// float32x4_t vcvtq_f32_s32 (int32x4_t a) + /// A32: VCVT.F32.S32 Qd, Qm + /// A64: SCVTF Vd.4S, Vn.4S /// public static Vector128 ConvertToSingle(Vector128 value) => ConvertToSingle(value); /// - /// float32x4_t vcvtq_f32_u32 (uint32x4_t a) - /// A32: VCVT.F32.U32 Qd, Qm - /// A64: UCVTF Vd.4S, Vn.4S + /// float32x4_t vcvtq_f32_u32 (uint32x4_t a) + /// A32: VCVT.F32.U32 Qd, Qm + /// A64: UCVTF Vd.4S, Vn.4S /// public static Vector128 ConvertToSingle(Vector128 value) => ConvertToSingle(value); /// - /// float32_t vcvts_f32_s32 (int32_t a) - /// A32: VCVT.F32.S32 Sd, Sm - /// A64: SCVTF Sd, Sn + /// float32_t vcvts_f32_s32 (int32_t a) + /// A32: VCVT.F32.S32 Sd, Sm + /// A64: SCVTF Sd, Sn /// public static Vector64 ConvertToSingleScalar(Vector64 value) => ConvertToSingleScalar(value); /// - /// float32_t vcvts_f32_u32 (uint32_t a) - /// A32: VCVT.F32.U32 Sd, Sm - /// A64: UCVTF Sd, Sn + /// float32_t vcvts_f32_u32 (uint32_t a) + /// A32: VCVT.F32.U32 Sd, Sm + /// A64: UCVTF Sd, Sn /// public static Vector64 ConvertToSingleScalar(Vector64 value) => ConvertToSingleScalar(value); /// - /// uint32x2_t vcvta_u32_f32 (float32x2_t a) - /// A32: VCVTA.U32.F32 Dd, Dm - /// A64: FCVTAU Vd.2S, Vn.2S + /// uint32x2_t vcvta_u32_f32 (float32x2_t a) + /// A32: VCVTA.U32.F32 Dd, Dm + /// A64: FCVTAU Vd.2S, Vn.2S /// public static Vector64 ConvertToUInt32RoundAwayFromZero(Vector64 value) => ConvertToUInt32RoundAwayFromZero(value); /// - /// uint32x4_t vcvtaq_u32_f32 (float32x4_t a) - /// A32: VCVTA.U32.F32 Qd, Qm - /// A64: FCVTAU Vd.4S, Vn.4S + /// uint32x4_t vcvtaq_u32_f32 (float32x4_t a) + /// A32: VCVTA.U32.F32 Qd, Qm + /// A64: FCVTAU Vd.4S, Vn.4S /// public static Vector128 ConvertToUInt32RoundAwayFromZero(Vector128 value) => ConvertToUInt32RoundAwayFromZero(value); /// - /// uint32_t vcvtas_u32_f32 (float32_t a) - /// A32: VCVTA.U32.F32 Sd, Sm - /// A64: FCVTAU Sd, Sn + /// uint32_t vcvtas_u32_f32 (float32_t a) + /// A32: VCVTA.U32.F32 Sd, Sm + /// A64: FCVTAU Sd, Sn /// public static Vector64 ConvertToUInt32RoundAwayFromZeroScalar(Vector64 value) => ConvertToUInt32RoundAwayFromZeroScalar(value); /// - /// uint32x2_t vcvtn_u32_f32 (float32x2_t a) - /// A32: VCVTN.U32.F32 Dd, Dm - /// A64: FCVTNU Vd.2S, Vn.2S + /// uint32x2_t vcvtn_u32_f32 (float32x2_t a) + /// A32: VCVTN.U32.F32 Dd, Dm + /// A64: FCVTNU Vd.2S, Vn.2S /// public static Vector64 ConvertToUInt32RoundToEven(Vector64 value) => ConvertToUInt32RoundToEven(value); /// - /// uint32x4_t vcvtnq_u32_f32 (float32x4_t a) - /// A32: VCVTN.U32.F32 Qd, Qm - /// A64: FCVTNU Vd.4S, Vn.4S + /// uint32x4_t vcvtnq_u32_f32 (float32x4_t a) + /// A32: VCVTN.U32.F32 Qd, Qm + /// A64: FCVTNU Vd.4S, Vn.4S /// public static Vector128 ConvertToUInt32RoundToEven(Vector128 value) => ConvertToUInt32RoundToEven(value); /// - /// uint32_t vcvtns_u32_f32 (float32_t a) - /// A32: VCVTN.U32.F32 Sd, Sm - /// A64: FCVTNU Sd, Sn + /// uint32_t vcvtns_u32_f32 (float32_t a) + /// A32: VCVTN.U32.F32 Sd, Sm + /// A64: FCVTNU Sd, Sn /// public static Vector64 ConvertToUInt32RoundToEvenScalar(Vector64 value) => ConvertToUInt32RoundToEvenScalar(value); /// - /// uint32x2_t vcvtm_u32_f32 (float32x2_t a) - /// A32: VCVTM.U32.F32 Dd, Dm - /// A64: FCVTMU Vd.2S, Vn.2S + /// uint32x2_t vcvtm_u32_f32 (float32x2_t a) + /// A32: VCVTM.U32.F32 Dd, Dm + /// A64: FCVTMU Vd.2S, Vn.2S /// public static Vector64 ConvertToUInt32RoundToNegativeInfinity(Vector64 value) => ConvertToUInt32RoundToNegativeInfinity(value); /// - /// uint32x4_t vcvtmq_u32_f32 (float32x4_t a) - /// A32: VCVTM.U32.F32 Qd, Qm - /// A64: FCVTMU Vd.4S, Vn.4S + /// uint32x4_t vcvtmq_u32_f32 (float32x4_t a) + /// A32: VCVTM.U32.F32 Qd, Qm + /// A64: FCVTMU Vd.4S, Vn.4S /// public static Vector128 ConvertToUInt32RoundToNegativeInfinity(Vector128 value) => ConvertToUInt32RoundToNegativeInfinity(value); /// - /// uint32_t vcvtms_u32_f32 (float32_t a) - /// A32: VCVTM.U32.F32 Sd, Sm - /// A64: FCVTMU Sd, Sn + /// uint32_t vcvtms_u32_f32 (float32_t a) + /// A32: VCVTM.U32.F32 Sd, Sm + /// A64: FCVTMU Sd, Sn /// public static Vector64 ConvertToUInt32RoundToNegativeInfinityScalar(Vector64 value) => ConvertToUInt32RoundToNegativeInfinityScalar(value); /// - /// uint32x2_t vcvtp_u32_f32 (float32x2_t a) - /// A32: VCVTP.U32.F32 Dd, Dm - /// A64: FCVTPU Vd.2S, Vn.2S + /// uint32x2_t vcvtp_u32_f32 (float32x2_t a) + /// A32: VCVTP.U32.F32 Dd, Dm + /// A64: FCVTPU Vd.2S, Vn.2S /// public static Vector64 ConvertToUInt32RoundToPositiveInfinity(Vector64 value) => ConvertToUInt32RoundToPositiveInfinity(value); /// - /// uint32x4_t vcvtpq_u32_f32 (float32x4_t a) - /// A32: VCVTP.U32.F32 Qd, Qm - /// A64: FCVTPU Vd.4S, Vn.4S + /// uint32x4_t vcvtpq_u32_f32 (float32x4_t a) + /// A32: VCVTP.U32.F32 Qd, Qm + /// A64: FCVTPU Vd.4S, Vn.4S /// public static Vector128 ConvertToUInt32RoundToPositiveInfinity(Vector128 value) => ConvertToUInt32RoundToPositiveInfinity(value); /// - /// uint32_t vcvtps_u32_f32 (float32_t a) - /// A32: VCVTP.U32.F32 Sd, Sm - /// A64: FCVTPU Sd, Sn + /// uint32_t vcvtps_u32_f32 (float32_t a) + /// A32: VCVTP.U32.F32 Sd, Sm + /// A64: FCVTPU Sd, Sn /// public static Vector64 ConvertToUInt32RoundToPositiveInfinityScalar(Vector64 value) => ConvertToUInt32RoundToPositiveInfinityScalar(value); /// - /// uint32x2_t vcvt_u32_f32 (float32x2_t a) - /// A32: VCVT.U32.F32 Dd, Dm - /// A64: FCVTZU Vd.2S, Vn.2S + /// uint32x2_t vcvt_u32_f32 (float32x2_t a) + /// A32: VCVT.U32.F32 Dd, Dm + /// A64: FCVTZU Vd.2S, Vn.2S /// public static Vector64 ConvertToUInt32RoundToZero(Vector64 value) => ConvertToUInt32RoundToZero(value); /// - /// uint32x4_t vcvtq_u32_f32 (float32x4_t a) - /// A32: VCVT.U32.F32 Qd, Qm - /// A64: FCVTZU Vd.4S, Vn.4S + /// uint32x4_t vcvtq_u32_f32 (float32x4_t a) + /// A32: VCVT.U32.F32 Qd, Qm + /// A64: FCVTZU Vd.4S, Vn.4S /// public static Vector128 ConvertToUInt32RoundToZero(Vector128 value) => ConvertToUInt32RoundToZero(value); /// - /// uint32_t vcvts_u32_f32 (float32_t a) - /// A32: VCVT.U32.F32 Sd, Sm - /// A64: FCVTZU Sd, Sn + /// uint32_t vcvts_u32_f32 (float32_t a) + /// A32: VCVT.U32.F32 Sd, Sm + /// A64: FCVTZU Sd, Sn /// public static Vector64 ConvertToUInt32RoundToZeroScalar(Vector64 value) => ConvertToUInt32RoundToZeroScalar(value); /// - /// float64x1_t vdiv_f64 (float64x1_t a, float64x1_t b) - /// A32: VDIV.F64 Dd, Dn, Dm - /// A64: FDIV Dd, Dn, Dm + /// float64x1_t vdiv_f64 (float64x1_t a, float64x1_t b) + /// A32: VDIV.F64 Dd, Dn, Dm + /// A64: FDIV Dd, Dn, Dm /// public static Vector64 DivideScalar(Vector64 left, Vector64 right) => DivideScalar(left, right); /// - /// float32_t vdivs_f32 (float32_t a, float32_t b) - /// A32: VDIV.F32 Sd, Sn, Sm - /// A64: FDIV Sd, Sn, Sm - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vdivs_f32 (float32_t a, float32_t b) + /// A32: VDIV.F32 Sd, Sn, Sm + /// A64: FDIV Sd, Sn, Sm + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 DivideScalar(Vector64 left, Vector64 right) => DivideScalar(left, right); /// - /// uint8x8_t vdup_lane_u8 (uint8x8_t vec, const int lane) - /// A32: VDUP.8 Dd, Dm[index] - /// A64: DUP Vd.8B, Vn.B[index] + /// uint8x8_t vdup_lane_u8 (uint8x8_t vec, const int lane) + /// A32: VDUP.8 Dd, Dm[index] + /// A64: DUP Vd.8B, Vn.B[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte index) => DuplicateSelectedScalarToVector64(value, index); /// - /// int16x4_t vdup_lane_s16 (int16x4_t vec, const int lane) - /// A32: VDUP.16 Dd, Dm[index] - /// A64: DUP Vd.4H, Vn.H[index] + /// int16x4_t vdup_lane_s16 (int16x4_t vec, const int lane) + /// A32: VDUP.16 Dd, Dm[index] + /// A64: DUP Vd.4H, Vn.H[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector64 value, [ConstantExpected(Max = (byte)(3))] byte index) => DuplicateSelectedScalarToVector64(value, index); /// - /// int32x2_t vdup_lane_s32 (int32x2_t vec, const int lane) - /// A32: VDUP.32 Dd, Dm[index] - /// A64: DUP Vd.2S, Vn.S[index] + /// int32x2_t vdup_lane_s32 (int32x2_t vec, const int lane) + /// A32: VDUP.32 Dd, Dm[index] + /// A64: DUP Vd.2S, Vn.S[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector64 value, [ConstantExpected(Max = (byte)(1))] byte index) => DuplicateSelectedScalarToVector64(value, index); /// - /// float32x2_t vdup_lane_f32 (float32x2_t vec, const int lane) - /// A32: VDUP.32 Dd, Dm[index] - /// A64: DUP Vd.2S, Vn.S[index] + /// float32x2_t vdup_lane_f32 (float32x2_t vec, const int lane) + /// A32: VDUP.32 Dd, Dm[index] + /// A64: DUP Vd.2S, Vn.S[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector64 value, [ConstantExpected(Max = (byte)(1))] byte index) => DuplicateSelectedScalarToVector64(value, index); /// - /// int8x8_t vdup_lane_s8 (int8x8_t vec, const int lane) - /// A32: VDUP.8 Dd, Dm[index] - /// A64: DUP Vd.8B, Vn.B[index] + /// int8x8_t vdup_lane_s8 (int8x8_t vec, const int lane) + /// A32: VDUP.8 Dd, Dm[index] + /// A64: DUP Vd.8B, Vn.B[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte index) => DuplicateSelectedScalarToVector64(value, index); /// - /// uint16x4_t vdup_lane_u16 (uint16x4_t vec, const int lane) - /// A32: VDUP.16 Dd, Dm[index] - /// A64: DUP Vd.4H, Vn.H[index] + /// uint16x4_t vdup_lane_u16 (uint16x4_t vec, const int lane) + /// A32: VDUP.16 Dd, Dm[index] + /// A64: DUP Vd.4H, Vn.H[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector64 value, [ConstantExpected(Max = (byte)(3))] byte index) => DuplicateSelectedScalarToVector64(value, index); /// - /// uint32x2_t vdup_lane_u32 (uint32x2_t vec, const int lane) - /// A32: VDUP.32 Dd, Dm[index] - /// A64: DUP Vd.2S, Vn.S[index] + /// uint32x2_t vdup_lane_u32 (uint32x2_t vec, const int lane) + /// A32: VDUP.32 Dd, Dm[index] + /// A64: DUP Vd.2S, Vn.S[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector64 value, [ConstantExpected(Max = (byte)(1))] byte index) => DuplicateSelectedScalarToVector64(value, index); /// - /// uint8x8_t vdup_laneq_u8 (uint8x16_t vec, const int lane) - /// A32: VDUP.8 Dd, Dm[index] - /// A64: DUP Vd.8B, Vn.B[index] + /// uint8x8_t vdup_laneq_u8 (uint8x16_t vec, const int lane) + /// A32: VDUP.8 Dd, Dm[index] + /// A64: DUP Vd.8B, Vn.B[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte index) => DuplicateSelectedScalarToVector64(value, index); /// - /// int16x4_t vdup_laneq_s16 (int16x8_t vec, const int lane) - /// A32: VDUP.16 Dd, Dm[index] - /// A64: DUP Vd.4H, Vn.H[index] + /// int16x4_t vdup_laneq_s16 (int16x8_t vec, const int lane) + /// A32: VDUP.16 Dd, Dm[index] + /// A64: DUP Vd.4H, Vn.H[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte index) => DuplicateSelectedScalarToVector64(value, index); /// - /// int32x2_t vdup_laneq_s32 (int32x4_t vec, const int lane) - /// A32: VDUP.32 Dd, Dm[index] - /// A64: DUP Vd.2S, Vn.S[index] + /// int32x2_t vdup_laneq_s32 (int32x4_t vec, const int lane) + /// A32: VDUP.32 Dd, Dm[index] + /// A64: DUP Vd.2S, Vn.S[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index) => DuplicateSelectedScalarToVector64(value, index); /// - /// float32x2_t vdup_laneq_f32 (float32x4_t vec, const int lane) - /// A32: VDUP.32 Dd, Dm[index] - /// A64: DUP Vd.2S, Vn.S[index] + /// float32x2_t vdup_laneq_f32 (float32x4_t vec, const int lane) + /// A32: VDUP.32 Dd, Dm[index] + /// A64: DUP Vd.2S, Vn.S[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index) => DuplicateSelectedScalarToVector64(value, index); /// - /// int8x8_t vdup_laneq_s8 (int8x16_t vec, const int lane) - /// A32: VDUP.8 Dd, Dm[index] - /// A64: DUP Vd.8B, Vn.B[index] + /// int8x8_t vdup_laneq_s8 (int8x16_t vec, const int lane) + /// A32: VDUP.8 Dd, Dm[index] + /// A64: DUP Vd.8B, Vn.B[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte index) => DuplicateSelectedScalarToVector64(value, index); /// - /// uint16x4_t vdup_laneq_u16 (uint16x8_t vec, const int lane) - /// A32: VDUP.16 Dd, Dm[index] - /// A64: DUP Vd.4H, Vn.H[index] + /// uint16x4_t vdup_laneq_u16 (uint16x8_t vec, const int lane) + /// A32: VDUP.16 Dd, Dm[index] + /// A64: DUP Vd.4H, Vn.H[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte index) => DuplicateSelectedScalarToVector64(value, index); /// - /// uint32x2_t vdup_laneq_u32 (uint32x4_t vec, const int lane) - /// A32: VDUP.32 Dd, Dm[index] - /// A64: DUP Vd.2S, Vn.S[index] + /// uint32x2_t vdup_laneq_u32 (uint32x4_t vec, const int lane) + /// A32: VDUP.32 Dd, Dm[index] + /// A64: DUP Vd.2S, Vn.S[index] /// public static Vector64 DuplicateSelectedScalarToVector64(Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index) => DuplicateSelectedScalarToVector64(value, index); /// - /// uint8x16_t vdupq_lane_u8 (uint8x8_t vec, const int lane) - /// A32: VDUP.8 Qd, Dm[index] - /// A64: DUP Vd.16B, Vn.B[index] + /// uint8x16_t vdupq_lane_u8 (uint8x8_t vec, const int lane) + /// A32: VDUP.8 Qd, Dm[index] + /// A64: DUP Vd.16B, Vn.B[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte index) => DuplicateSelectedScalarToVector128(value, index); /// - /// int16x8_t vdupq_lane_s16 (int16x4_t vec, const int lane) - /// A32: VDUP.16 Qd, Dm[index] - /// A64: DUP Vd.8H, Vn.H[index] + /// int16x8_t vdupq_lane_s16 (int16x4_t vec, const int lane) + /// A32: VDUP.16 Qd, Dm[index] + /// A64: DUP Vd.8H, Vn.H[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector64 value, [ConstantExpected(Max = (byte)(3))] byte index) => DuplicateSelectedScalarToVector128(value, index); /// - /// int32x4_t vdupq_lane_s32 (int32x2_t vec, const int lane) - /// A32: VDUP.32 Qd, Dm[index] - /// A64: DUP Vd.4S, Vn.S[index] + /// int32x4_t vdupq_lane_s32 (int32x2_t vec, const int lane) + /// A32: VDUP.32 Qd, Dm[index] + /// A64: DUP Vd.4S, Vn.S[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector64 value, [ConstantExpected(Max = (byte)(1))] byte index) => DuplicateSelectedScalarToVector128(value, index); /// - /// float32x4_t vdupq_lane_f32 (float32x2_t vec, const int lane) - /// A32: VDUP.32 Qd, Dm[index] - /// A64: DUP Vd.4S, Vn.S[index] + /// float32x4_t vdupq_lane_f32 (float32x2_t vec, const int lane) + /// A32: VDUP.32 Qd, Dm[index] + /// A64: DUP Vd.4S, Vn.S[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector64 value, [ConstantExpected(Max = (byte)(1))] byte index) => DuplicateSelectedScalarToVector128(value, index); /// - /// int8x16_t vdupq_lane_s8 (int8x8_t vec, const int lane) - /// A32: VDUP.8 Qd, Dm[index] - /// A64: DUP Vd.16B, Vn.B[index] + /// int8x16_t vdupq_lane_s8 (int8x8_t vec, const int lane) + /// A32: VDUP.8 Qd, Dm[index] + /// A64: DUP Vd.16B, Vn.B[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte index) => DuplicateSelectedScalarToVector128(value, index); /// - /// uint16x8_t vdupq_lane_u16 (uint16x4_t vec, const int lane) - /// A32: VDUP.16 Qd, Dm[index] - /// A64: DUP Vd.8H, Vn.H[index] + /// uint16x8_t vdupq_lane_u16 (uint16x4_t vec, const int lane) + /// A32: VDUP.16 Qd, Dm[index] + /// A64: DUP Vd.8H, Vn.H[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector64 value, [ConstantExpected(Max = (byte)(3))] byte index) => DuplicateSelectedScalarToVector128(value, index); /// - /// uint32x4_t vdupq_lane_u32 (uint32x2_t vec, const int lane) - /// A32: VDUP.32 Qd, Dm[index] - /// A64: DUP Vd.4S, Vn.S[index] + /// uint32x4_t vdupq_lane_u32 (uint32x2_t vec, const int lane) + /// A32: VDUP.32 Qd, Dm[index] + /// A64: DUP Vd.4S, Vn.S[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector64 value, [ConstantExpected(Max = (byte)(1))] byte index) => DuplicateSelectedScalarToVector128(value, index); /// - /// uint8x16_t vdupq_lane_u8 (uint8x16_t vec, const int lane) - /// A32: VDUP.8 Qd, Dm[index] - /// A64: DUP Vd.16B, Vn.B[index] + /// uint8x16_t vdupq_lane_u8 (uint8x16_t vec, const int lane) + /// A32: VDUP.8 Qd, Dm[index] + /// A64: DUP Vd.16B, Vn.B[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte index) => DuplicateSelectedScalarToVector128(value, index); /// - /// int16x8_t vdupq_lane_s16 (int16x8_t vec, const int lane) - /// A32: VDUP.16 Qd, Dm[index] - /// A64: DUP Vd.8H, Vn.H[index] + /// int16x8_t vdupq_lane_s16 (int16x8_t vec, const int lane) + /// A32: VDUP.16 Qd, Dm[index] + /// A64: DUP Vd.8H, Vn.H[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte index) => DuplicateSelectedScalarToVector128(value, index); /// - /// int32x4_t vdupq_lane_s32 (int32x4_t vec, const int lane) - /// A32: VDUP.32 Qd, Dm[index] - /// A64: DUP Vd.4S, Vn.S[index] + /// int32x4_t vdupq_lane_s32 (int32x4_t vec, const int lane) + /// A32: VDUP.32 Qd, Dm[index] + /// A64: DUP Vd.4S, Vn.S[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index) => DuplicateSelectedScalarToVector128(value, index); /// - /// float32x4_t vdupq_lane_f32 (float32x4_t vec, const int lane) - /// A32: VDUP.32 Qd, Dm[index] - /// A64: DUP Vd.4S, Vn.S[index] + /// float32x4_t vdupq_lane_f32 (float32x4_t vec, const int lane) + /// A32: VDUP.32 Qd, Dm[index] + /// A64: DUP Vd.4S, Vn.S[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index) => DuplicateSelectedScalarToVector128(value, index); /// - /// int8x16_t vdupq_lane_s8 (int8x16_t vec, const int lane) - /// A32: VDUP.8 Qd, Dm[index] - /// A64: DUP Vd.16B, Vn.B[index] + /// int8x16_t vdupq_lane_s8 (int8x16_t vec, const int lane) + /// A32: VDUP.8 Qd, Dm[index] + /// A64: DUP Vd.16B, Vn.B[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte index) => DuplicateSelectedScalarToVector128(value, index); /// - /// uint16x8_t vdupq_lane_u16 (uint16x8_t vec, const int lane) - /// A32: VDUP.16 Qd, Dm[index] - /// A64: DUP Vd.8H, Vn.H[index] + /// uint16x8_t vdupq_lane_u16 (uint16x8_t vec, const int lane) + /// A32: VDUP.16 Qd, Dm[index] + /// A64: DUP Vd.8H, Vn.H[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte index) => DuplicateSelectedScalarToVector128(value, index); /// - /// uint32x4_t vdupq_lane_u32 (uint32x4_t vec, const int lane) - /// A32: VDUP.32 Qd, Dm[index] - /// A64: DUP Vd.4S, Vn.S[index] + /// uint32x4_t vdupq_lane_u32 (uint32x4_t vec, const int lane) + /// A32: VDUP.32 Qd, Dm[index] + /// A64: DUP Vd.4S, Vn.S[index] /// public static Vector128 DuplicateSelectedScalarToVector128(Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index) => DuplicateSelectedScalarToVector128(value, index); /// - /// uint8x8_t vdup_n_u8 (uint8_t value) - /// A32: VDUP.8 Dd, Rt - /// A64: DUP Vd.8B, Rn + /// uint8x8_t vdup_n_u8 (uint8_t value) + /// A32: VDUP.8 Dd, Rt + /// A64: DUP Vd.8B, Rn /// public static Vector64 DuplicateToVector64(byte value) => DuplicateToVector64(value); /// - /// int16x4_t vdup_n_s16 (int16_t value) - /// A32: VDUP.16 Dd, Rt - /// A64: DUP Vd.4H, Rn + /// int16x4_t vdup_n_s16 (int16_t value) + /// A32: VDUP.16 Dd, Rt + /// A64: DUP Vd.4H, Rn /// public static Vector64 DuplicateToVector64(short value) => DuplicateToVector64(value); /// - /// int32x2_t vdup_n_s32 (int32_t value) - /// A32: VDUP.32 Dd, Rt - /// A64: DUP Vd.2S, Rn + /// int32x2_t vdup_n_s32 (int32_t value) + /// A32: VDUP.32 Dd, Rt + /// A64: DUP Vd.2S, Rn /// public static Vector64 DuplicateToVector64(int value) => DuplicateToVector64(value); /// - /// int8x8_t vdup_n_s8 (int8_t value) - /// A32: VDUP.8 Dd, Rt - /// A64: DUP Vd.8B, Rn + /// int8x8_t vdup_n_s8 (int8_t value) + /// A32: VDUP.8 Dd, Rt + /// A64: DUP Vd.8B, Rn /// public static Vector64 DuplicateToVector64(sbyte value) => DuplicateToVector64(value); /// - /// float32x2_t vdup_n_f32 (float32_t value) - /// A32: VDUP Dd, Dm[0] - /// A64: DUP Vd.2S, Vn.S[0] + /// float32x2_t vdup_n_f32 (float32_t value) + /// A32: VDUP Dd, Dm[0] + /// A64: DUP Vd.2S, Vn.S[0] /// public static Vector64 DuplicateToVector64(float value) => DuplicateToVector64(value); /// - /// uint16x4_t vdup_n_u16 (uint16_t value) - /// A32: VDUP.16 Dd, Rt - /// A64: DUP Vd.4H, Rn + /// uint16x4_t vdup_n_u16 (uint16_t value) + /// A32: VDUP.16 Dd, Rt + /// A64: DUP Vd.4H, Rn /// public static Vector64 DuplicateToVector64(ushort value) => DuplicateToVector64(value); /// - /// uint32x2_t vdup_n_u32 (uint32_t value) - /// A32: VDUP.32 Dd, Rt - /// A64: DUP Vd.2S, Rn + /// uint32x2_t vdup_n_u32 (uint32_t value) + /// A32: VDUP.32 Dd, Rt + /// A64: DUP Vd.2S, Rn /// public static Vector64 DuplicateToVector64(uint value) => DuplicateToVector64(value); /// - /// uint8x16_t vdupq_n_u8 (uint8_t value) - /// A32: VDUP.8 Qd, Rt - /// A64: DUP Vd.16B, Rn + /// uint8x16_t vdupq_n_u8 (uint8_t value) + /// A32: VDUP.8 Qd, Rt + /// A64: DUP Vd.16B, Rn /// public static Vector128 DuplicateToVector128(byte value) => DuplicateToVector128(value); /// - /// int16x8_t vdupq_n_s16 (int16_t value) - /// A32: VDUP.16 Qd, Rt - /// A64: DUP Vd.8H, Rn + /// int16x8_t vdupq_n_s16 (int16_t value) + /// A32: VDUP.16 Qd, Rt + /// A64: DUP Vd.8H, Rn /// public static Vector128 DuplicateToVector128(short value) => DuplicateToVector128(value); /// - /// int32x4_t vdupq_n_s32 (int32_t value) - /// A32: VDUP.32 Qd, Rt - /// A64: DUP Vd.4S, Rn + /// int32x4_t vdupq_n_s32 (int32_t value) + /// A32: VDUP.32 Qd, Rt + /// A64: DUP Vd.4S, Rn /// public static Vector128 DuplicateToVector128(int value) => DuplicateToVector128(value); /// - /// int8x16_t vdupq_n_s8 (int8_t value) - /// A32: VDUP.8 Qd, Rt - /// A64: DUP Vd.16B, Rn + /// int8x16_t vdupq_n_s8 (int8_t value) + /// A32: VDUP.8 Qd, Rt + /// A64: DUP Vd.16B, Rn /// public static Vector128 DuplicateToVector128(sbyte value) => DuplicateToVector128(value); /// - /// float32x4_t vdupq_n_f32 (float32_t value) - /// A32: VDUP Qd, Dm[0] - /// A64: DUP Vd.4S, Vn.S[0] + /// float32x4_t vdupq_n_f32 (float32_t value) + /// A32: VDUP Qd, Dm[0] + /// A64: DUP Vd.4S, Vn.S[0] /// public static Vector128 DuplicateToVector128(float value) => DuplicateToVector128(value); /// - /// uint16x8_t vdupq_n_u16 (uint16_t value) - /// A32: VDUP.16 Qd, Rt - /// A64: DUP Vd.8H, Rn + /// uint16x8_t vdupq_n_u16 (uint16_t value) + /// A32: VDUP.16 Qd, Rt + /// A64: DUP Vd.8H, Rn /// public static Vector128 DuplicateToVector128(ushort value) => DuplicateToVector128(value); /// - /// uint32x4_t vdupq_n_u32 (uint32_t value) - /// A32: VDUP.32 Qd, Rt - /// A64: DUP Vd.4S, Rn + /// uint32x4_t vdupq_n_u32 (uint32_t value) + /// A32: VDUP.32 Qd, Rt + /// A64: DUP Vd.4S, Rn /// public static Vector128 DuplicateToVector128(uint value) => DuplicateToVector128(value); /// - /// uint8_t vget_lane_u8 (uint8x8_t v, const int lane) - /// A32: VMOV.U8 Rt, Dn[lane] - /// A64: UMOV Wd, Vn.B[lane] + /// uint8_t vget_lane_u8 (uint8x8_t v, const int lane) + /// A32: VMOV.U8 Rt, Dn[lane] + /// A64: UMOV Wd, Vn.B[lane] /// public static byte Extract(Vector64 vector, [ConstantExpected(Max = (byte)(7))] byte index) => Extract(vector, index); /// - /// int16_t vget_lane_s16 (int16x4_t v, const int lane) - /// A32: VMOV.S16 Rt, Dn[lane] - /// A64: SMOV Wd, Vn.H[lane] + /// int16_t vget_lane_s16 (int16x4_t v, const int lane) + /// A32: VMOV.S16 Rt, Dn[lane] + /// A64: SMOV Wd, Vn.H[lane] /// public static short Extract(Vector64 vector, [ConstantExpected(Max = (byte)(3))] byte index) => Extract(vector, index); /// - /// int32_t vget_lane_s32 (int32x2_t v, const int lane) - /// A32: VMOV.32 Rt, Dn[lane] - /// A64: SMOV Wd, Vn.S[lane] + /// int32_t vget_lane_s32 (int32x2_t v, const int lane) + /// A32: VMOV.32 Rt, Dn[lane] + /// A64: SMOV Wd, Vn.S[lane] /// public static int Extract(Vector64 vector, [ConstantExpected(Max = (byte)(1))] byte index) => Extract(vector, index); /// - /// int8_t vget_lane_s8 (int8x8_t v, const int lane) - /// A32: VMOV.S8 Rt, Dn[lane] - /// A64: SMOV Wd, Vn.B[lane] + /// int8_t vget_lane_s8 (int8x8_t v, const int lane) + /// A32: VMOV.S8 Rt, Dn[lane] + /// A64: SMOV Wd, Vn.B[lane] /// public static sbyte Extract(Vector64 vector, [ConstantExpected(Max = (byte)(7))] byte index) => Extract(vector, index); /// - /// float32_t vget_lane_f32 (float32x2_t v, const int lane) - /// A32: VMOV.F32 Sd, Sm - /// A64: DUP Sd, Vn.S[lane] + /// float32_t vget_lane_f32 (float32x2_t v, const int lane) + /// A32: VMOV.F32 Sd, Sm + /// A64: DUP Sd, Vn.S[lane] /// public static float Extract(Vector64 vector, [ConstantExpected(Max = (byte)(1))] byte index) => Extract(vector, index); /// - /// uint16_t vget_lane_u16 (uint16x4_t v, const int lane) - /// A32: VMOV.U16 Rt, Dn[lane] - /// A64: UMOV Wd, Vn.H[lane] + /// uint16_t vget_lane_u16 (uint16x4_t v, const int lane) + /// A32: VMOV.U16 Rt, Dn[lane] + /// A64: UMOV Wd, Vn.H[lane] /// public static ushort Extract(Vector64 vector, [ConstantExpected(Max = (byte)(3))] byte index) => Extract(vector, index); /// - /// uint32_t vget_lane_u32 (uint32x2_t v, const int lane) - /// A32: VMOV.32 Rt, Dn[lane] - /// A64: UMOV Wd, Vn.S[lane] + /// uint32_t vget_lane_u32 (uint32x2_t v, const int lane) + /// A32: VMOV.32 Rt, Dn[lane] + /// A64: UMOV Wd, Vn.S[lane] /// public static uint Extract(Vector64 vector, [ConstantExpected(Max = (byte)(1))] byte index) => Extract(vector, index); /// - /// uint8_t vgetq_lane_u8 (uint8x16_t v, const int lane) - /// A32: VMOV.U8 Rt, Dn[lane] - /// A64: UMOV Wd, Vn.B[lane] + /// uint8_t vgetq_lane_u8 (uint8x16_t v, const int lane) + /// A32: VMOV.U8 Rt, Dn[lane] + /// A64: UMOV Wd, Vn.B[lane] /// public static byte Extract(Vector128 vector, [ConstantExpected(Max = (byte)(15))] byte index) => Extract(vector, index); /// - /// float64_t vgetq_lane_f64 (float64x2_t v, const int lane) - /// A32: VMOV.F64 Dd, Dm - /// A64: DUP Dd, Vn.D[lane] + /// float64_t vgetq_lane_f64 (float64x2_t v, const int lane) + /// A32: VMOV.F64 Dd, Dm + /// A64: DUP Dd, Vn.D[lane] /// public static double Extract(Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte index) => Extract(vector, index); /// - /// int16_t vgetq_lane_s16 (int16x8_t v, const int lane) - /// A32: VMOV.S16 Rt, Dn[lane] - /// A64: SMOV Wd, Vn.H[lane] + /// int16_t vgetq_lane_s16 (int16x8_t v, const int lane) + /// A32: VMOV.S16 Rt, Dn[lane] + /// A64: SMOV Wd, Vn.H[lane] /// public static short Extract(Vector128 vector, [ConstantExpected(Max = (byte)(7))] byte index) => Extract(vector, index); /// - /// int32_t vgetq_lane_s32 (int32x4_t v, const int lane) - /// A32: VMOV.32 Rt, Dn[lane] - /// A64: SMOV Wd, Vn.S[lane] + /// int32_t vgetq_lane_s32 (int32x4_t v, const int lane) + /// A32: VMOV.32 Rt, Dn[lane] + /// A64: SMOV Wd, Vn.S[lane] /// public static int Extract(Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) => Extract(vector, index); /// - /// int64_t vgetq_lane_s64 (int64x2_t v, const int lane) - /// A32: VMOV Rt, Rt2, Dm - /// A64: UMOV Xd, Vn.D[lane] + /// int64_t vgetq_lane_s64 (int64x2_t v, const int lane) + /// A32: VMOV Rt, Rt2, Dm + /// A64: UMOV Xd, Vn.D[lane] /// public static long Extract(Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte index) => Extract(vector, index); /// - /// int8_t vgetq_lane_s8 (int8x16_t v, const int lane) - /// A32: VMOV.S8 Rt, Dn[lane] - /// A64: SMOV Wd, Vn.B[lane] + /// int8_t vgetq_lane_s8 (int8x16_t v, const int lane) + /// A32: VMOV.S8 Rt, Dn[lane] + /// A64: SMOV Wd, Vn.B[lane] /// public static sbyte Extract(Vector128 vector, [ConstantExpected(Max = (byte)(15))] byte index) => Extract(vector, index); /// - /// float32_t vgetq_lane_f32 (float32x4_t v, const int lane) - /// A32: VMOV.F32 Sd, Sm - /// A64: DUP Sd, Vn.S[lane] + /// float32_t vgetq_lane_f32 (float32x4_t v, const int lane) + /// A32: VMOV.F32 Sd, Sm + /// A64: DUP Sd, Vn.S[lane] /// public static float Extract(Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) => Extract(vector, index); /// - /// uint16_t vgetq_lane_u16 (uint16x8_t v, const int lane) - /// A32: VMOV.U16 Rt, Dn[lane] - /// A64: UMOV Wd, Vn.H[lane] + /// uint16_t vgetq_lane_u16 (uint16x8_t v, const int lane) + /// A32: VMOV.U16 Rt, Dn[lane] + /// A64: UMOV Wd, Vn.H[lane] /// public static ushort Extract(Vector128 vector, [ConstantExpected(Max = (byte)(7))] byte index) => Extract(vector, index); /// - /// uint32_t vgetq_lane_u32 (uint32x4_t v, const int lane) - /// A32: VMOV.32 Rt, Dn[lane] - /// A64: UMOV Wd, Vn.S[lane] + /// uint32_t vgetq_lane_u32 (uint32x4_t v, const int lane) + /// A32: VMOV.32 Rt, Dn[lane] + /// A64: UMOV Wd, Vn.S[lane] /// public static uint Extract(Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) => Extract(vector, index); /// - /// uint64_t vgetq_lane_u64 (uint64x2_t v, const int lane) - /// A32: VMOV Rt, Rt2, Dm - /// A64: UMOV Xd, Vn.D[lane] + /// uint64_t vgetq_lane_u64 (uint64x2_t v, const int lane) + /// A32: VMOV Rt, Rt2, Dm + /// A64: UMOV Xd, Vn.D[lane] /// public static ulong Extract(Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte index) => Extract(vector, index); /// - /// uint8x8_t vmovn_u16 (uint16x8_t a) - /// A32: VMOVN.I16 Dd, Qm - /// A64: XTN Vd.8B, Vn.8H + /// uint8x8_t vmovn_u16 (uint16x8_t a) + /// A32: VMOVN.I16 Dd, Qm + /// A64: XTN Vd.8B, Vn.8H /// public static Vector64 ExtractNarrowingLower(Vector128 value) => ExtractNarrowingLower(value); /// - /// int16x4_t vmovn_s32 (int32x4_t a) - /// A32: VMOVN.I32 Dd, Qm - /// A64: XTN Vd.4H, Vn.4S + /// int16x4_t vmovn_s32 (int32x4_t a) + /// A32: VMOVN.I32 Dd, Qm + /// A64: XTN Vd.4H, Vn.4S /// public static Vector64 ExtractNarrowingLower(Vector128 value) => ExtractNarrowingLower(value); /// - /// int32x2_t vmovn_s64 (int64x2_t a) - /// A32: VMOVN.I64 Dd, Qm - /// A64: XTN Vd.2S, Vn.2D + /// int32x2_t vmovn_s64 (int64x2_t a) + /// A32: VMOVN.I64 Dd, Qm + /// A64: XTN Vd.2S, Vn.2D /// public static Vector64 ExtractNarrowingLower(Vector128 value) => ExtractNarrowingLower(value); /// - /// int8x8_t vmovn_s16 (int16x8_t a) - /// A32: VMOVN.I16 Dd, Qm - /// A64: XTN Vd.8B, Vn.8H + /// int8x8_t vmovn_s16 (int16x8_t a) + /// A32: VMOVN.I16 Dd, Qm + /// A64: XTN Vd.8B, Vn.8H /// public static Vector64 ExtractNarrowingLower(Vector128 value) => ExtractNarrowingLower(value); /// - /// uint16x4_t vmovn_u32 (uint32x4_t a) - /// A32: VMOVN.I32 Dd, Qm - /// A64: XTN Vd.4H, Vn.4S + /// uint16x4_t vmovn_u32 (uint32x4_t a) + /// A32: VMOVN.I32 Dd, Qm + /// A64: XTN Vd.4H, Vn.4S /// public static Vector64 ExtractNarrowingLower(Vector128 value) => ExtractNarrowingLower(value); /// - /// uint32x2_t vmovn_u64 (uint64x2_t a) - /// A32: VMOVN.I64 Dd, Qm - /// A64: XTN Vd.2S, Vn.2D + /// uint32x2_t vmovn_u64 (uint64x2_t a) + /// A32: VMOVN.I64 Dd, Qm + /// A64: XTN Vd.2S, Vn.2D /// public static Vector64 ExtractNarrowingLower(Vector128 value) => ExtractNarrowingLower(value); /// - /// uint8x8_t vqmovn_u16 (uint16x8_t a) - /// A32: VQMOVN.U16 Dd, Qm - /// A64: UQXTN Vd.8B, Vn.8H + /// uint8x8_t vqmovn_u16 (uint16x8_t a) + /// A32: VQMOVN.U16 Dd, Qm + /// A64: UQXTN Vd.8B, Vn.8H /// public static Vector64 ExtractNarrowingSaturateLower(Vector128 value) => ExtractNarrowingSaturateLower(value); /// - /// int16x4_t vqmovn_s32 (int32x4_t a) - /// A32: VQMOVN.S32 Dd, Qm - /// A64: SQXTN Vd.4H, Vn.4S + /// int16x4_t vqmovn_s32 (int32x4_t a) + /// A32: VQMOVN.S32 Dd, Qm + /// A64: SQXTN Vd.4H, Vn.4S /// public static Vector64 ExtractNarrowingSaturateLower(Vector128 value) => ExtractNarrowingSaturateLower(value); /// - /// int32x2_t vqmovn_s64 (int64x2_t a) - /// A32: VQMOVN.S64 Dd, Qm - /// A64: SQXTN Vd.2S, Vn.2D + /// int32x2_t vqmovn_s64 (int64x2_t a) + /// A32: VQMOVN.S64 Dd, Qm + /// A64: SQXTN Vd.2S, Vn.2D /// public static Vector64 ExtractNarrowingSaturateLower(Vector128 value) => ExtractNarrowingSaturateLower(value); /// - /// int8x8_t vqmovn_s16 (int16x8_t a) - /// A32: VQMOVN.S16 Dd, Qm - /// A64: SQXTN Vd.8B, Vn.8H + /// int8x8_t vqmovn_s16 (int16x8_t a) + /// A32: VQMOVN.S16 Dd, Qm + /// A64: SQXTN Vd.8B, Vn.8H /// public static Vector64 ExtractNarrowingSaturateLower(Vector128 value) => ExtractNarrowingSaturateLower(value); /// - /// uint16x4_t vqmovn_u32 (uint32x4_t a) - /// A32: VQMOVN.U32 Dd, Qm - /// A64: UQXTN Vd.4H, Vn.4S + /// uint16x4_t vqmovn_u32 (uint32x4_t a) + /// A32: VQMOVN.U32 Dd, Qm + /// A64: UQXTN Vd.4H, Vn.4S /// public static Vector64 ExtractNarrowingSaturateLower(Vector128 value) => ExtractNarrowingSaturateLower(value); /// - /// uint32x2_t vqmovn_u64 (uint64x2_t a) - /// A32: VQMOVN.U64 Dd, Qm - /// A64: UQXTN Vd.2S, Vn.2D + /// uint32x2_t vqmovn_u64 (uint64x2_t a) + /// A32: VQMOVN.U64 Dd, Qm + /// A64: UQXTN Vd.2S, Vn.2D /// public static Vector64 ExtractNarrowingSaturateLower(Vector128 value) => ExtractNarrowingSaturateLower(value); /// - /// uint8x8_t vqmovun_s16 (int16x8_t a) - /// A32: VQMOVUN.S16 Dd, Qm - /// A64: SQXTUN Vd.8B, Vn.8H + /// uint8x8_t vqmovun_s16 (int16x8_t a) + /// A32: VQMOVUN.S16 Dd, Qm + /// A64: SQXTUN Vd.8B, Vn.8H /// public static Vector64 ExtractNarrowingSaturateUnsignedLower(Vector128 value) => ExtractNarrowingSaturateUnsignedLower(value); /// - /// uint16x4_t vqmovun_s32 (int32x4_t a) - /// A32: VQMOVUN.S32 Dd, Qm - /// A64: SQXTUN Vd.4H, Vn.4S + /// uint16x4_t vqmovun_s32 (int32x4_t a) + /// A32: VQMOVUN.S32 Dd, Qm + /// A64: SQXTUN Vd.4H, Vn.4S /// public static Vector64 ExtractNarrowingSaturateUnsignedLower(Vector128 value) => ExtractNarrowingSaturateUnsignedLower(value); /// - /// uint32x2_t vqmovun_s64 (int64x2_t a) - /// A32: VQMOVUN.S64 Dd, Qm - /// A64: SQXTUN Vd.2S, Vn.2D + /// uint32x2_t vqmovun_s64 (int64x2_t a) + /// A32: VQMOVUN.S64 Dd, Qm + /// A64: SQXTUN Vd.2S, Vn.2D /// public static Vector64 ExtractNarrowingSaturateUnsignedLower(Vector128 value) => ExtractNarrowingSaturateUnsignedLower(value); /// - /// uint8x16_t vqmovun_high_s16 (uint8x8_t r, int16x8_t a) - /// A32: VQMOVUN.S16 Dd+1, Qm - /// A64: SQXTUN2 Vd.16B, Vn.8H + /// uint8x16_t vqmovun_high_s16 (uint8x8_t r, int16x8_t a) + /// A32: VQMOVUN.S16 Dd+1, Qm + /// A64: SQXTUN2 Vd.16B, Vn.8H /// public static Vector128 ExtractNarrowingSaturateUnsignedUpper(Vector64 lower, Vector128 value) => ExtractNarrowingSaturateUnsignedUpper(lower, value); /// - /// uint16x8_t vqmovun_high_s32 (uint16x4_t r, int32x4_t a) - /// A32: VQMOVUN.S32 Dd+1, Qm - /// A64: SQXTUN2 Vd.8H, Vn.4S + /// uint16x8_t vqmovun_high_s32 (uint16x4_t r, int32x4_t a) + /// A32: VQMOVUN.S32 Dd+1, Qm + /// A64: SQXTUN2 Vd.8H, Vn.4S /// public static Vector128 ExtractNarrowingSaturateUnsignedUpper(Vector64 lower, Vector128 value) => ExtractNarrowingSaturateUnsignedUpper(lower, value); /// - /// uint32x4_t vqmovun_high_s64 (uint32x2_t r, int64x2_t a) - /// A32: VQMOVUN.S64 Dd+1, Qm - /// A64: SQXTUN2 Vd.4S, Vn.2D + /// uint32x4_t vqmovun_high_s64 (uint32x2_t r, int64x2_t a) + /// A32: VQMOVUN.S64 Dd+1, Qm + /// A64: SQXTUN2 Vd.4S, Vn.2D /// public static Vector128 ExtractNarrowingSaturateUnsignedUpper(Vector64 lower, Vector128 value) => ExtractNarrowingSaturateUnsignedUpper(lower, value); /// - /// uint8x16_t vqmovn_high_u16 (uint8x8_t r, uint16x8_t a) - /// A32: VQMOVN.U16 Dd+1, Qm - /// A64: UQXTN2 Vd.16B, Vn.8H + /// uint8x16_t vqmovn_high_u16 (uint8x8_t r, uint16x8_t a) + /// A32: VQMOVN.U16 Dd+1, Qm + /// A64: UQXTN2 Vd.16B, Vn.8H /// public static Vector128 ExtractNarrowingSaturateUpper(Vector64 lower, Vector128 value) => ExtractNarrowingSaturateUpper(lower, value); /// - /// int16x8_t vqmovn_high_s32 (int16x4_t r, int32x4_t a) - /// A32: VQMOVN.S32 Dd+1, Qm - /// A64: SQXTN2 Vd.8H, Vn.4S + /// int16x8_t vqmovn_high_s32 (int16x4_t r, int32x4_t a) + /// A32: VQMOVN.S32 Dd+1, Qm + /// A64: SQXTN2 Vd.8H, Vn.4S /// public static Vector128 ExtractNarrowingSaturateUpper(Vector64 lower, Vector128 value) => ExtractNarrowingSaturateUpper(lower, value); /// - /// int32x4_t vqmovn_high_s64 (int32x2_t r, int64x2_t a) - /// A32: VQMOVN.S64 Dd+1, Qm - /// A64: SQXTN2 Vd.4S, Vn.2D + /// int32x4_t vqmovn_high_s64 (int32x2_t r, int64x2_t a) + /// A32: VQMOVN.S64 Dd+1, Qm + /// A64: SQXTN2 Vd.4S, Vn.2D /// public static Vector128 ExtractNarrowingSaturateUpper(Vector64 lower, Vector128 value) => ExtractNarrowingSaturateUpper(lower, value); /// - /// int8x16_t vqmovn_high_s16 (int8x8_t r, int16x8_t a) - /// A32: VQMOVN.S16 Dd+1, Qm - /// A64: SQXTN2 Vd.16B, Vn.8H + /// int8x16_t vqmovn_high_s16 (int8x8_t r, int16x8_t a) + /// A32: VQMOVN.S16 Dd+1, Qm + /// A64: SQXTN2 Vd.16B, Vn.8H /// public static Vector128 ExtractNarrowingSaturateUpper(Vector64 lower, Vector128 value) => ExtractNarrowingSaturateUpper(lower, value); /// - /// uint16x8_t vqmovn_high_u32 (uint16x4_t r, uint32x4_t a) - /// A32: VQMOVN.U32 Dd+1, Qm - /// A64: UQXTN2 Vd.8H, Vn.4S + /// uint16x8_t vqmovn_high_u32 (uint16x4_t r, uint32x4_t a) + /// A32: VQMOVN.U32 Dd+1, Qm + /// A64: UQXTN2 Vd.8H, Vn.4S /// public static Vector128 ExtractNarrowingSaturateUpper(Vector64 lower, Vector128 value) => ExtractNarrowingSaturateUpper(lower, value); /// - /// uint32x4_t vqmovn_high_u64 (uint32x2_t r, uint64x2_t a) - /// A32: VQMOVN.U64 Dd+1, Qm - /// A64: UQXTN2 Vd.4S, Vn.2D + /// uint32x4_t vqmovn_high_u64 (uint32x2_t r, uint64x2_t a) + /// A32: VQMOVN.U64 Dd+1, Qm + /// A64: UQXTN2 Vd.4S, Vn.2D /// public static Vector128 ExtractNarrowingSaturateUpper(Vector64 lower, Vector128 value) => ExtractNarrowingSaturateUpper(lower, value); /// - /// uint8x16_t vmovn_high_u16 (uint8x8_t r, uint16x8_t a) - /// A32: VMOVN.I16 Dd+1, Qm - /// A64: XTN2 Vd.16B, Vn.8H + /// uint8x16_t vmovn_high_u16 (uint8x8_t r, uint16x8_t a) + /// A32: VMOVN.I16 Dd+1, Qm + /// A64: XTN2 Vd.16B, Vn.8H /// public static Vector128 ExtractNarrowingUpper(Vector64 lower, Vector128 value) => ExtractNarrowingUpper(lower, value); /// - /// int16x8_t vmovn_high_s32 (int16x4_t r, int32x4_t a) - /// A32: VMOVN.I32 Dd+1, Qm - /// A64: XTN2 Vd.8H, Vn.4S + /// int16x8_t vmovn_high_s32 (int16x4_t r, int32x4_t a) + /// A32: VMOVN.I32 Dd+1, Qm + /// A64: XTN2 Vd.8H, Vn.4S /// public static Vector128 ExtractNarrowingUpper(Vector64 lower, Vector128 value) => ExtractNarrowingUpper(lower, value); /// - /// int32x4_t vmovn_high_s64 (int32x2_t r, int64x2_t a) - /// A32: VMOVN.I64 Dd+1, Qm - /// A64: XTN2 Vd.4S, Vn.2D + /// int32x4_t vmovn_high_s64 (int32x2_t r, int64x2_t a) + /// A32: VMOVN.I64 Dd+1, Qm + /// A64: XTN2 Vd.4S, Vn.2D /// public static Vector128 ExtractNarrowingUpper(Vector64 lower, Vector128 value) => ExtractNarrowingUpper(lower, value); /// - /// int8x16_t vmovn_high_s16 (int8x8_t r, int16x8_t a) - /// A32: VMOVN.I16 Dd+1, Qm - /// A64: XTN2 Vd.16B, Vn.8H + /// int8x16_t vmovn_high_s16 (int8x8_t r, int16x8_t a) + /// A32: VMOVN.I16 Dd+1, Qm + /// A64: XTN2 Vd.16B, Vn.8H /// public static Vector128 ExtractNarrowingUpper(Vector64 lower, Vector128 value) => ExtractNarrowingUpper(lower, value); /// - /// uint16x8_t vmovn_high_u32 (uint16x4_t r, uint32x4_t a) - /// A32: VMOVN.I32 Dd+1, Qm - /// A64: XTN2 Vd.8H, Vn.4S + /// uint16x8_t vmovn_high_u32 (uint16x4_t r, uint32x4_t a) + /// A32: VMOVN.I32 Dd+1, Qm + /// A64: XTN2 Vd.8H, Vn.4S /// public static Vector128 ExtractNarrowingUpper(Vector64 lower, Vector128 value) => ExtractNarrowingUpper(lower, value); /// - /// uint32x4_t vmovn_high_u64 (uint32x2_t r, uint64x2_t a) - /// A32: VMOVN.I64 Dd+1, Qm - /// A64: XTN2 Vd.4S, Vn.2D + /// uint32x4_t vmovn_high_u64 (uint32x2_t r, uint64x2_t a) + /// A32: VMOVN.I64 Dd+1, Qm + /// A64: XTN2 Vd.4S, Vn.2D /// public static Vector128 ExtractNarrowingUpper(Vector64 lower, Vector128 value) => ExtractNarrowingUpper(lower, value); /// - /// uint8x8_t vext_s8 (uint8x8_t a, uint8x8_t b, const int n) - /// A32: VEXT.8 Dd, Dn, Dm, #n - /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #n + /// uint8x8_t vext_s8 (uint8x8_t a, uint8x8_t b, const int n) + /// A32: VEXT.8 Dd, Dn, Dm, #n + /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #n /// public static Vector64 ExtractVector64(Vector64 upper, Vector64 lower, [ConstantExpected(Max = (byte)(7))] byte index) => ExtractVector64(upper, lower, index); /// - /// int16x4_t vext_s16 (int16x4_t a, int16x4_t b, const int n) - /// A32: VEXT.8 Dd, Dn, Dm, #(n*2) - /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*2) + /// int16x4_t vext_s16 (int16x4_t a, int16x4_t b, const int n) + /// A32: VEXT.8 Dd, Dn, Dm, #(n*2) + /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*2) /// public static Vector64 ExtractVector64(Vector64 upper, Vector64 lower, [ConstantExpected(Max = (byte)(3))] byte index) => ExtractVector64(upper, lower, index); /// - /// int32x2_t vext_s32 (int32x2_t a, int32x2_t b, const int n) - /// A32: VEXT.8 Dd, Dn, Dm, #(n*4) - /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*4) + /// int32x2_t vext_s32 (int32x2_t a, int32x2_t b, const int n) + /// A32: VEXT.8 Dd, Dn, Dm, #(n*4) + /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*4) /// public static Vector64 ExtractVector64(Vector64 upper, Vector64 lower, [ConstantExpected(Max = (byte)(1))] byte index) => ExtractVector64(upper, lower, index); /// - /// int8x8_t vext_s8 (int8x8_t a, int8x8_t b, const int n) - /// A32: VEXT.8 Dd, Dn, Dm, #n - /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #n + /// int8x8_t vext_s8 (int8x8_t a, int8x8_t b, const int n) + /// A32: VEXT.8 Dd, Dn, Dm, #n + /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #n /// public static Vector64 ExtractVector64(Vector64 upper, Vector64 lower, [ConstantExpected(Max = (byte)(7))] byte index) => ExtractVector64(upper, lower, index); /// - /// float32x2_t vext_f32 (float32x2_t a, float32x2_t b, const int n) - /// A32: VEXT.8 Dd, Dn, Dm, #(n*4) - /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*4) + /// float32x2_t vext_f32 (float32x2_t a, float32x2_t b, const int n) + /// A32: VEXT.8 Dd, Dn, Dm, #(n*4) + /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*4) /// public static Vector64 ExtractVector64(Vector64 upper, Vector64 lower, [ConstantExpected(Max = (byte)(1))] byte index) => ExtractVector64(upper, lower, index); /// - /// uint16x4_t vext_s16 (uint16x4_t a, uint16x4_t b, const int n) - /// A32: VEXT.8 Dd, Dn, Dm, #(n*2) - /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*2) + /// uint16x4_t vext_s16 (uint16x4_t a, uint16x4_t b, const int n) + /// A32: VEXT.8 Dd, Dn, Dm, #(n*2) + /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*2) /// public static Vector64 ExtractVector64(Vector64 upper, Vector64 lower, [ConstantExpected(Max = (byte)(3))] byte index) => ExtractVector64(upper, lower, index); /// - /// uint32x2_t vext_s32 (uint32x2_t a, uint32x2_t b, const int n) - /// A32: VEXT.8 Dd, Dn, Dm, #(n*4) - /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*4) + /// uint32x2_t vext_s32 (uint32x2_t a, uint32x2_t b, const int n) + /// A32: VEXT.8 Dd, Dn, Dm, #(n*4) + /// A64: EXT Vd.8B, Vn.8B, Vm.8B, #(n*4) /// public static Vector64 ExtractVector64(Vector64 upper, Vector64 lower, [ConstantExpected(Max = (byte)(1))] byte index) => ExtractVector64(upper, lower, index); /// - /// uint8x16_t vextq_s8 (uint8x16_t a, uint8x16_t b, const int n) - /// A32: VEXT.8 Qd, Qn, Qm, #n - /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #n + /// uint8x16_t vextq_s8 (uint8x16_t a, uint8x16_t b, const int n) + /// A32: VEXT.8 Qd, Qn, Qm, #n + /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #n /// public static Vector128 ExtractVector128(Vector128 upper, Vector128 lower, [ConstantExpected(Max = (byte)(15))] byte index) => ExtractVector128(upper, lower, index); /// - /// float64x2_t vextq_f64 (float64x2_t a, float64x2_t b, const int n) - /// A32: VEXT.8 Qd, Qn, Qm, #(n*8) - /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*8) + /// float64x2_t vextq_f64 (float64x2_t a, float64x2_t b, const int n) + /// A32: VEXT.8 Qd, Qn, Qm, #(n*8) + /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*8) /// public static Vector128 ExtractVector128(Vector128 upper, Vector128 lower, [ConstantExpected(Max = (byte)(1))] byte index) => ExtractVector128(upper, lower, index); /// - /// int16x8_t vextq_s16 (int16x8_t a, int16x8_t b, const int n) - /// A32: VEXT.8 Qd, Qn, Qm, #(n*2) - /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*2) + /// int16x8_t vextq_s16 (int16x8_t a, int16x8_t b, const int n) + /// A32: VEXT.8 Qd, Qn, Qm, #(n*2) + /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*2) /// public static Vector128 ExtractVector128(Vector128 upper, Vector128 lower, [ConstantExpected(Max = (byte)(7))] byte index) => ExtractVector128(upper, lower, index); /// - /// int32x4_t vextq_s32 (int32x4_t a, int32x4_t b, const int n) - /// A32: VEXT.8 Qd, Qn, Qm, #(n*4) - /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*4) + /// int32x4_t vextq_s32 (int32x4_t a, int32x4_t b, const int n) + /// A32: VEXT.8 Qd, Qn, Qm, #(n*4) + /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*4) /// public static Vector128 ExtractVector128(Vector128 upper, Vector128 lower, [ConstantExpected(Max = (byte)(3))] byte index) => ExtractVector128(upper, lower, index); /// - /// int64x2_t vextq_s64 (int64x2_t a, int64x2_t b, const int n) - /// A32: VEXT.8 Qd, Qn, Qm, #(n*8) - /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*8) + /// int64x2_t vextq_s64 (int64x2_t a, int64x2_t b, const int n) + /// A32: VEXT.8 Qd, Qn, Qm, #(n*8) + /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*8) /// public static Vector128 ExtractVector128(Vector128 upper, Vector128 lower, [ConstantExpected(Max = (byte)(1))] byte index) => ExtractVector128(upper, lower, index); /// - /// int8x16_t vextq_s8 (int8x16_t a, int8x16_t b, const int n) - /// A32: VEXT.8 Qd, Qn, Qm, #n - /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #n + /// int8x16_t vextq_s8 (int8x16_t a, int8x16_t b, const int n) + /// A32: VEXT.8 Qd, Qn, Qm, #n + /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #n /// public static Vector128 ExtractVector128(Vector128 upper, Vector128 lower, [ConstantExpected(Max = (byte)(15))] byte index) => ExtractVector128(upper, lower, index); /// - /// float32x4_t vextq_f32 (float32x4_t a, float32x4_t b, const int n) - /// A32: VEXT.8 Qd, Qn, Qm, #(n*4) - /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*4) + /// float32x4_t vextq_f32 (float32x4_t a, float32x4_t b, const int n) + /// A32: VEXT.8 Qd, Qn, Qm, #(n*4) + /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*4) /// public static Vector128 ExtractVector128(Vector128 upper, Vector128 lower, [ConstantExpected(Max = (byte)(3))] byte index) => ExtractVector128(upper, lower, index); /// - /// uint16x8_t vextq_s16 (uint16x8_t a, uint16x8_t b, const int n) - /// A32: VEXT.8 Qd, Qn, Qm, #(n*2) - /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*2) + /// uint16x8_t vextq_s16 (uint16x8_t a, uint16x8_t b, const int n) + /// A32: VEXT.8 Qd, Qn, Qm, #(n*2) + /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*2) /// public static Vector128 ExtractVector128(Vector128 upper, Vector128 lower, [ConstantExpected(Max = (byte)(7))] byte index) => ExtractVector128(upper, lower, index); /// - /// uint32x4_t vextq_s32 (uint32x4_t a, uint32x4_t b, const int n) - /// A32: VEXT.8 Qd, Qn, Qm, #(n*4) - /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*4) + /// uint32x4_t vextq_s32 (uint32x4_t a, uint32x4_t b, const int n) + /// A32: VEXT.8 Qd, Qn, Qm, #(n*4) + /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*4) /// public static Vector128 ExtractVector128(Vector128 upper, Vector128 lower, [ConstantExpected(Max = (byte)(3))] byte index) => ExtractVector128(upper, lower, index); /// - /// uint64x2_t vextq_s64 (uint64x2_t a, uint64x2_t b, const int n) - /// A32: VEXT.8 Qd, Qn, Qm, #(n*8) - /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*8) + /// uint64x2_t vextq_s64 (uint64x2_t a, uint64x2_t b, const int n) + /// A32: VEXT.8 Qd, Qn, Qm, #(n*8) + /// A64: EXT Vd.16B, Vn.16B, Vm.16B, #(n*8) /// public static Vector128 ExtractVector128(Vector128 upper, Vector128 lower, [ConstantExpected(Max = (byte)(1))] byte index) => ExtractVector128(upper, lower, index); /// - /// float32x2_t vrndm_f32 (float32x2_t a) - /// A32: VRINTM.F32 Dd, Dm - /// A64: FRINTM Vd.2S, Vn.2S + /// float32x2_t vrndm_f32 (float32x2_t a) + /// A32: VRINTM.F32 Dd, Dm + /// A64: FRINTM Vd.2S, Vn.2S /// public static Vector64 Floor(Vector64 value) => Floor(value); /// - /// float32x4_t vrndmq_f32 (float32x4_t a) - /// A32: VRINTM.F32 Qd, Qm - /// A64: FRINTM Vd.4S, Vn.4S + /// float32x4_t vrndmq_f32 (float32x4_t a) + /// A32: VRINTM.F32 Qd, Qm + /// A64: FRINTM Vd.4S, Vn.4S /// public static Vector128 Floor(Vector128 value) => Floor(value); /// - /// float64x1_t vrndm_f64 (float64x1_t a) - /// A32: VRINTM.F64 Dd, Dm - /// A64: FRINTM Dd, Dn + /// float64x1_t vrndm_f64 (float64x1_t a) + /// A32: VRINTM.F64 Dd, Dm + /// A64: FRINTM Dd, Dn /// public static Vector64 FloorScalar(Vector64 value) => FloorScalar(value); /// - /// float32_t vrndms_f32 (float32_t a) - /// A32: VRINTM.F32 Sd, Sm - /// A64: FRINTM Sd, Sn - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vrndms_f32 (float32_t a) + /// A32: VRINTM.F32 Sd, Sm + /// A64: FRINTM Sd, Sn + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 FloorScalar(Vector64 value) => FloorScalar(value); /// - /// uint8x8_t vhadd_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VHADD.U8 Dd, Dn, Dm - /// A64: UHADD Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vhadd_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VHADD.U8 Dd, Dn, Dm + /// A64: UHADD Vd.8B, Vn.8B, Vm.8B /// public static Vector64 FusedAddHalving(Vector64 left, Vector64 right) => FusedAddHalving(left, right); /// - /// int16x4_t vhadd_s16 (int16x4_t a, int16x4_t b) - /// A32: VHADD.S16 Dd, Dn, Dm - /// A64: SHADD Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vhadd_s16 (int16x4_t a, int16x4_t b) + /// A32: VHADD.S16 Dd, Dn, Dm + /// A64: SHADD Vd.4H, Vn.4H, Vm.4H /// public static Vector64 FusedAddHalving(Vector64 left, Vector64 right) => FusedAddHalving(left, right); /// - /// int32x2_t vhadd_s32 (int32x2_t a, int32x2_t b) - /// A32: VHADD.S32 Dd, Dn, Dm - /// A64: SHADD Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vhadd_s32 (int32x2_t a, int32x2_t b) + /// A32: VHADD.S32 Dd, Dn, Dm + /// A64: SHADD Vd.2S, Vn.2S, Vm.2S /// public static Vector64 FusedAddHalving(Vector64 left, Vector64 right) => FusedAddHalving(left, right); /// - /// int8x8_t vhadd_s8 (int8x8_t a, int8x8_t b) - /// A32: VHADD.S8 Dd, Dn, Dm - /// A64: SHADD Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vhadd_s8 (int8x8_t a, int8x8_t b) + /// A32: VHADD.S8 Dd, Dn, Dm + /// A64: SHADD Vd.8B, Vn.8B, Vm.8B /// public static Vector64 FusedAddHalving(Vector64 left, Vector64 right) => FusedAddHalving(left, right); /// - /// uint16x4_t vhadd_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VHADD.U16 Dd, Dn, Dm - /// A64: UHADD Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vhadd_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VHADD.U16 Dd, Dn, Dm + /// A64: UHADD Vd.4H, Vn.4H, Vm.4H /// public static Vector64 FusedAddHalving(Vector64 left, Vector64 right) => FusedAddHalving(left, right); /// - /// uint32x2_t vhadd_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VHADD.U32 Dd, Dn, Dm - /// A64: UHADD Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vhadd_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VHADD.U32 Dd, Dn, Dm + /// A64: UHADD Vd.2S, Vn.2S, Vm.2S /// public static Vector64 FusedAddHalving(Vector64 left, Vector64 right) => FusedAddHalving(left, right); /// - /// uint8x16_t vhaddq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VHADD.U8 Qd, Qn, Qm - /// A64: UHADD Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vhaddq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VHADD.U8 Qd, Qn, Qm + /// A64: UHADD Vd.16B, Vn.16B, Vm.16B /// public static Vector128 FusedAddHalving(Vector128 left, Vector128 right) => FusedAddHalving(left, right); /// - /// int16x8_t vhaddq_s16 (int16x8_t a, int16x8_t b) - /// A32: VHADD.S16 Qd, Qn, Qm - /// A64: SHADD Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vhaddq_s16 (int16x8_t a, int16x8_t b) + /// A32: VHADD.S16 Qd, Qn, Qm + /// A64: SHADD Vd.8H, Vn.8H, Vm.8H /// public static Vector128 FusedAddHalving(Vector128 left, Vector128 right) => FusedAddHalving(left, right); /// - /// int32x4_t vhaddq_s32 (int32x4_t a, int32x4_t b) - /// A32: VHADD.S32 Qd, Qn, Qm - /// A64: SHADD Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vhaddq_s32 (int32x4_t a, int32x4_t b) + /// A32: VHADD.S32 Qd, Qn, Qm + /// A64: SHADD Vd.4S, Vn.4S, Vm.4S /// public static Vector128 FusedAddHalving(Vector128 left, Vector128 right) => FusedAddHalving(left, right); /// - /// int8x16_t vhaddq_s8 (int8x16_t a, int8x16_t b) - /// A32: VHADD.S8 Qd, Qn, Qm - /// A64: SHADD Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vhaddq_s8 (int8x16_t a, int8x16_t b) + /// A32: VHADD.S8 Qd, Qn, Qm + /// A64: SHADD Vd.16B, Vn.16B, Vm.16B /// public static Vector128 FusedAddHalving(Vector128 left, Vector128 right) => FusedAddHalving(left, right); /// - /// uint16x8_t vhaddq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VHADD.U16 Qd, Qn, Qm - /// A64: UHADD Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vhaddq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VHADD.U16 Qd, Qn, Qm + /// A64: UHADD Vd.8H, Vn.8H, Vm.8H /// public static Vector128 FusedAddHalving(Vector128 left, Vector128 right) => FusedAddHalving(left, right); /// - /// uint32x4_t vhaddq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VHADD.U32 Qd, Qn, Qm - /// A64: UHADD Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vhaddq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VHADD.U32 Qd, Qn, Qm + /// A64: UHADD Vd.4S, Vn.4S, Vm.4S /// public static Vector128 FusedAddHalving(Vector128 left, Vector128 right) => FusedAddHalving(left, right); /// - /// uint8x8_t vrhadd_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VRHADD.U8 Dd, Dn, Dm - /// A64: URHADD Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vrhadd_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VRHADD.U8 Dd, Dn, Dm + /// A64: URHADD Vd.8B, Vn.8B, Vm.8B /// public static Vector64 FusedAddRoundedHalving(Vector64 left, Vector64 right) => FusedAddRoundedHalving(left, right); /// - /// int16x4_t vrhadd_s16 (int16x4_t a, int16x4_t b) - /// A32: VRHADD.S16 Dd, Dn, Dm - /// A64: SRHADD Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vrhadd_s16 (int16x4_t a, int16x4_t b) + /// A32: VRHADD.S16 Dd, Dn, Dm + /// A64: SRHADD Vd.4H, Vn.4H, Vm.4H /// public static Vector64 FusedAddRoundedHalving(Vector64 left, Vector64 right) => FusedAddRoundedHalving(left, right); /// - /// int32x2_t vrhadd_s32 (int32x2_t a, int32x2_t b) - /// A32: VRHADD.S32 Dd, Dn, Dm - /// A64: SRHADD Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vrhadd_s32 (int32x2_t a, int32x2_t b) + /// A32: VRHADD.S32 Dd, Dn, Dm + /// A64: SRHADD Vd.2S, Vn.2S, Vm.2S /// public static Vector64 FusedAddRoundedHalving(Vector64 left, Vector64 right) => FusedAddRoundedHalving(left, right); /// - /// int8x8_t vrhadd_s8 (int8x8_t a, int8x8_t b) - /// A32: VRHADD.S8 Dd, Dn, Dm - /// A64: SRHADD Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vrhadd_s8 (int8x8_t a, int8x8_t b) + /// A32: VRHADD.S8 Dd, Dn, Dm + /// A64: SRHADD Vd.8B, Vn.8B, Vm.8B /// public static Vector64 FusedAddRoundedHalving(Vector64 left, Vector64 right) => FusedAddRoundedHalving(left, right); /// - /// uint16x4_t vrhadd_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VRHADD.U16 Dd, Dn, Dm - /// A64: URHADD Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vrhadd_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VRHADD.U16 Dd, Dn, Dm + /// A64: URHADD Vd.4H, Vn.4H, Vm.4H /// public static Vector64 FusedAddRoundedHalving(Vector64 left, Vector64 right) => FusedAddRoundedHalving(left, right); /// - /// uint32x2_t vrhadd_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VRHADD.U32 Dd, Dn, Dm - /// A64: URHADD Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vrhadd_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VRHADD.U32 Dd, Dn, Dm + /// A64: URHADD Vd.2S, Vn.2S, Vm.2S /// public static Vector64 FusedAddRoundedHalving(Vector64 left, Vector64 right) => FusedAddRoundedHalving(left, right); /// - /// uint8x16_t vrhaddq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VRHADD.U8 Qd, Qn, Qm - /// A64: URHADD Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vrhaddq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VRHADD.U8 Qd, Qn, Qm + /// A64: URHADD Vd.16B, Vn.16B, Vm.16B /// public static Vector128 FusedAddRoundedHalving(Vector128 left, Vector128 right) => FusedAddRoundedHalving(left, right); /// - /// int16x8_t vrhaddq_s16 (int16x8_t a, int16x8_t b) - /// A32: VRHADD.S16 Qd, Qn, Qm - /// A64: SRHADD Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vrhaddq_s16 (int16x8_t a, int16x8_t b) + /// A32: VRHADD.S16 Qd, Qn, Qm + /// A64: SRHADD Vd.8H, Vn.8H, Vm.8H /// public static Vector128 FusedAddRoundedHalving(Vector128 left, Vector128 right) => FusedAddRoundedHalving(left, right); /// - /// int32x4_t vrhaddq_s32 (int32x4_t a, int32x4_t b) - /// A32: VRHADD.S32 Qd, Qn, Qm - /// A64: SRHADD Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vrhaddq_s32 (int32x4_t a, int32x4_t b) + /// A32: VRHADD.S32 Qd, Qn, Qm + /// A64: SRHADD Vd.4S, Vn.4S, Vm.4S /// public static Vector128 FusedAddRoundedHalving(Vector128 left, Vector128 right) => FusedAddRoundedHalving(left, right); /// - /// int8x16_t vrhaddq_s8 (int8x16_t a, int8x16_t b) - /// A32: VRHADD.S8 Qd, Qn, Qm - /// A64: SRHADD Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vrhaddq_s8 (int8x16_t a, int8x16_t b) + /// A32: VRHADD.S8 Qd, Qn, Qm + /// A64: SRHADD Vd.16B, Vn.16B, Vm.16B /// public static Vector128 FusedAddRoundedHalving(Vector128 left, Vector128 right) => FusedAddRoundedHalving(left, right); /// - /// uint16x8_t vrhaddq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VRHADD.U16 Qd, Qn, Qm - /// A64: URHADD Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vrhaddq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VRHADD.U16 Qd, Qn, Qm + /// A64: URHADD Vd.8H, Vn.8H, Vm.8H /// public static Vector128 FusedAddRoundedHalving(Vector128 left, Vector128 right) => FusedAddRoundedHalving(left, right); /// - /// uint32x4_t vrhaddq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VRHADD.U32 Qd, Qn, Qm - /// A64: URHADD Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vrhaddq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VRHADD.U32 Qd, Qn, Qm + /// A64: URHADD Vd.4S, Vn.4S, Vm.4S /// public static Vector128 FusedAddRoundedHalving(Vector128 left, Vector128 right) => FusedAddRoundedHalving(left, right); /// - /// float32x2_t vfma_f32 (float32x2_t a, float32x2_t b, float32x2_t c) - /// A32: VFMA.F32 Dd, Dn, Dm - /// A64: FMLA Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vfma_f32 (float32x2_t a, float32x2_t b, float32x2_t c) + /// A32: VFMA.F32 Dd, Dn, Dm + /// A64: FMLA Vd.2S, Vn.2S, Vm.2S /// public static Vector64 FusedMultiplyAdd(Vector64 addend, Vector64 left, Vector64 right) => FusedMultiplyAdd(addend, left, right); /// - /// float32x4_t vfmaq_f32 (float32x4_t a, float32x4_t b, float32x4_t c) - /// A32: VFMA.F32 Qd, Qn, Qm - /// A64: FMLA Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vfmaq_f32 (float32x4_t a, float32x4_t b, float32x4_t c) + /// A32: VFMA.F32 Qd, Qn, Qm + /// A64: FMLA Vd.4S, Vn.4S, Vm.4S /// public static Vector128 FusedMultiplyAdd(Vector128 addend, Vector128 left, Vector128 right) => FusedMultiplyAdd(addend, left, right); /// - /// float64x1_t vfnma_f64 (float64x1_t a, float64x1_t b, float64x1_t c) - /// A32: VFNMA.F64 Dd, Dn, Dm - /// A64: FNMADD Dd, Dn, Dm, Da - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x1_t vfnma_f64 (float64x1_t a, float64x1_t b, float64x1_t c) + /// A32: VFNMA.F64 Dd, Dn, Dm + /// A64: FNMADD Dd, Dn, Dm, Da + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 FusedMultiplyAddNegatedScalar(Vector64 addend, Vector64 left, Vector64 right) => FusedMultiplyAddNegatedScalar(addend, left, right); /// - /// float32_t vfnmas_f32 (float32_t a, float32_t b, float32_t c) - /// A32: VFNMA.F32 Sd, Sn, Sm - /// A64: FNMADD Sd, Sn, Sm, Sa - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vfnmas_f32 (float32_t a, float32_t b, float32_t c) + /// A32: VFNMA.F32 Sd, Sn, Sm + /// A64: FNMADD Sd, Sn, Sm, Sa + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 FusedMultiplyAddNegatedScalar(Vector64 addend, Vector64 left, Vector64 right) => FusedMultiplyAddNegatedScalar(addend, left, right); /// - /// float64x1_t vfma_f64 (float64x1_t a, float64x1_t b, float64x1_t c) - /// A32: VFMA.F64 Dd, Dn, Dm - /// A64: FMADD Dd, Dn, Dm, Da + /// float64x1_t vfma_f64 (float64x1_t a, float64x1_t b, float64x1_t c) + /// A32: VFMA.F64 Dd, Dn, Dm + /// A64: FMADD Dd, Dn, Dm, Da /// public static Vector64 FusedMultiplyAddScalar(Vector64 addend, Vector64 left, Vector64 right) => FusedMultiplyAddScalar(addend, left, right); /// - /// float32_t vfmas_f32 (float32_t a, float32_t b, float32_t c) - /// A32: VFMA.F32 Sd, Sn, Sm - /// A64: FMADD Sd, Sn, Sm, Sa - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vfmas_f32 (float32_t a, float32_t b, float32_t c) + /// A32: VFMA.F32 Sd, Sn, Sm + /// A64: FMADD Sd, Sn, Sm, Sa + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 FusedMultiplyAddScalar(Vector64 addend, Vector64 left, Vector64 right) => FusedMultiplyAddScalar(addend, left, right); /// - /// float32x2_t vfms_f32 (float32x2_t a, float32x2_t b, float32x2_t c) - /// A32: VFMS.F32 Dd, Dn, Dm - /// A64: FMLS Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vfms_f32 (float32x2_t a, float32x2_t b, float32x2_t c) + /// A32: VFMS.F32 Dd, Dn, Dm + /// A64: FMLS Vd.2S, Vn.2S, Vm.2S /// public static Vector64 FusedMultiplySubtract(Vector64 minuend, Vector64 left, Vector64 right) => FusedMultiplySubtract(minuend, left, right); /// - /// float32x4_t vfmsq_f32 (float32x4_t a, float32x4_t b, float32x4_t c) - /// A32: VFMS.F32 Qd, Qn, Qm - /// A64: FMLS Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vfmsq_f32 (float32x4_t a, float32x4_t b, float32x4_t c) + /// A32: VFMS.F32 Qd, Qn, Qm + /// A64: FMLS Vd.4S, Vn.4S, Vm.4S /// public static Vector128 FusedMultiplySubtract(Vector128 minuend, Vector128 left, Vector128 right) => FusedMultiplySubtract(minuend, left, right); /// - /// float64x1_t vfnms_f64 (float64x1_t a, float64x1_t b, float64x1_t c) - /// A32: VFNMS.F64 Dd, Dn, Dm - /// A64: FNMSUB Dd, Dn, Dm, Da - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x1_t vfnms_f64 (float64x1_t a, float64x1_t b, float64x1_t c) + /// A32: VFNMS.F64 Dd, Dn, Dm + /// A64: FNMSUB Dd, Dn, Dm, Da + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 FusedMultiplySubtractNegatedScalar(Vector64 minuend, Vector64 left, Vector64 right) => FusedMultiplySubtractNegatedScalar(minuend, left, right); /// - /// float32_t vfnmss_f32 (float32_t a, float32_t b, float32_t c) - /// A32: VFNMS.F32 Sd, Sn, Sm - /// A64: FNMSUB Sd, Sn, Sm, Sa - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vfnmss_f32 (float32_t a, float32_t b, float32_t c) + /// A32: VFNMS.F32 Sd, Sn, Sm + /// A64: FNMSUB Sd, Sn, Sm, Sa + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 FusedMultiplySubtractNegatedScalar(Vector64 minuend, Vector64 left, Vector64 right) => FusedMultiplySubtractNegatedScalar(minuend, left, right); /// - /// float64x1_t vfms_f64 (float64x1_t a, float64x1_t b, float64x1_t c) - /// A32: VFMS.F64 Dd, Dn, Dm - /// A64: FMSUB Dd, Dn, Dm, Da + /// float64x1_t vfms_f64 (float64x1_t a, float64x1_t b, float64x1_t c) + /// A32: VFMS.F64 Dd, Dn, Dm + /// A64: FMSUB Dd, Dn, Dm, Da /// public static Vector64 FusedMultiplySubtractScalar(Vector64 minuend, Vector64 left, Vector64 right) => FusedMultiplySubtractScalar(minuend, left, right); /// - /// float32_t vfmss_f32 (float32_t a, float32_t b, float32_t c) - /// A32: VFMS.F32 Sd, Sn, Sm - /// A64: FMSUB Sd, Sn, Sm, Sa - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vfmss_f32 (float32_t a, float32_t b, float32_t c) + /// A32: VFMS.F32 Sd, Sn, Sm + /// A64: FMSUB Sd, Sn, Sm, Sa + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 FusedMultiplySubtractScalar(Vector64 minuend, Vector64 left, Vector64 right) => FusedMultiplySubtractScalar(minuend, left, right); /// - /// uint8x8_t vhsub_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VHSUB.U8 Dd, Dn, Dm - /// A64: UHSUB Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vhsub_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VHSUB.U8 Dd, Dn, Dm + /// A64: UHSUB Vd.8B, Vn.8B, Vm.8B /// public static Vector64 FusedSubtractHalving(Vector64 left, Vector64 right) => FusedSubtractHalving(left, right); /// - /// int16x4_t vhsub_s16 (int16x4_t a, int16x4_t b) - /// A32: VHSUB.S16 Dd, Dn, Dm - /// A64: SHSUB Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vhsub_s16 (int16x4_t a, int16x4_t b) + /// A32: VHSUB.S16 Dd, Dn, Dm + /// A64: SHSUB Vd.4H, Vn.4H, Vm.4H /// public static Vector64 FusedSubtractHalving(Vector64 left, Vector64 right) => FusedSubtractHalving(left, right); /// - /// int32x2_t vhsub_s32 (int32x2_t a, int32x2_t b) - /// A32: VHSUB.S32 Dd, Dn, Dm - /// A64: SHSUB Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vhsub_s32 (int32x2_t a, int32x2_t b) + /// A32: VHSUB.S32 Dd, Dn, Dm + /// A64: SHSUB Vd.2S, Vn.2S, Vm.2S /// public static Vector64 FusedSubtractHalving(Vector64 left, Vector64 right) => FusedSubtractHalving(left, right); /// - /// int8x8_t vhsub_s8 (int8x8_t a, int8x8_t b) - /// A32: VHSUB.S8 Dd, Dn, Dm - /// A64: SHSUB Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vhsub_s8 (int8x8_t a, int8x8_t b) + /// A32: VHSUB.S8 Dd, Dn, Dm + /// A64: SHSUB Vd.8B, Vn.8B, Vm.8B /// public static Vector64 FusedSubtractHalving(Vector64 left, Vector64 right) => FusedSubtractHalving(left, right); /// - /// uint16x4_t vhsub_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VHSUB.U16 Dd, Dn, Dm - /// A64: UHSUB Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vhsub_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VHSUB.U16 Dd, Dn, Dm + /// A64: UHSUB Vd.4H, Vn.4H, Vm.4H /// public static Vector64 FusedSubtractHalving(Vector64 left, Vector64 right) => FusedSubtractHalving(left, right); /// - /// uint32x2_t vhsub_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VHSUB.U32 Dd, Dn, Dm - /// A64: UHSUB Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vhsub_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VHSUB.U32 Dd, Dn, Dm + /// A64: UHSUB Vd.2S, Vn.2S, Vm.2S /// public static Vector64 FusedSubtractHalving(Vector64 left, Vector64 right) => FusedSubtractHalving(left, right); /// - /// uint8x16_t vhsubq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VHSUB.U8 Qd, Qn, Qm - /// A64: UHSUB Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vhsubq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VHSUB.U8 Qd, Qn, Qm + /// A64: UHSUB Vd.16B, Vn.16B, Vm.16B /// public static Vector128 FusedSubtractHalving(Vector128 left, Vector128 right) => FusedSubtractHalving(left, right); /// - /// int16x8_t vhsubq_s16 (int16x8_t a, int16x8_t b) - /// A32: VHSUB.S16 Qd, Qn, Qm - /// A64: SHSUB Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vhsubq_s16 (int16x8_t a, int16x8_t b) + /// A32: VHSUB.S16 Qd, Qn, Qm + /// A64: SHSUB Vd.8H, Vn.8H, Vm.8H /// public static Vector128 FusedSubtractHalving(Vector128 left, Vector128 right) => FusedSubtractHalving(left, right); /// - /// int32x4_t vhsubq_s32 (int32x4_t a, int32x4_t b) - /// A32: VHSUB.S32 Qd, Qn, Qm - /// A64: SHSUB Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vhsubq_s32 (int32x4_t a, int32x4_t b) + /// A32: VHSUB.S32 Qd, Qn, Qm + /// A64: SHSUB Vd.4S, Vn.4S, Vm.4S /// public static Vector128 FusedSubtractHalving(Vector128 left, Vector128 right) => FusedSubtractHalving(left, right); /// - /// int8x16_t vhsubq_s8 (int8x16_t a, int8x16_t b) - /// A32: VHSUB.S8 Qd, Qn, Qm - /// A64: SHSUB Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vhsubq_s8 (int8x16_t a, int8x16_t b) + /// A32: VHSUB.S8 Qd, Qn, Qm + /// A64: SHSUB Vd.16B, Vn.16B, Vm.16B /// public static Vector128 FusedSubtractHalving(Vector128 left, Vector128 right) => FusedSubtractHalving(left, right); /// - /// uint16x8_t vhsubq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VHSUB.U16 Qd, Qn, Qm - /// A64: UHSUB Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vhsubq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VHSUB.U16 Qd, Qn, Qm + /// A64: UHSUB Vd.8H, Vn.8H, Vm.8H /// public static Vector128 FusedSubtractHalving(Vector128 left, Vector128 right) => FusedSubtractHalving(left, right); /// - /// uint32x4_t vhsubq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VHSUB.U32 Qd, Qn, Qm - /// A64: UHSUB Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vhsubq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VHSUB.U32 Qd, Qn, Qm + /// A64: UHSUB Vd.4S, Vn.4S, Vm.4S /// public static Vector128 FusedSubtractHalving(Vector128 left, Vector128 right) => FusedSubtractHalving(left, right); /// - /// uint8x8_t vset_lane_u8 (uint8_t a, uint8x8_t v, const int lane) - /// A32: VMOV.8 Dd[lane], Rt - /// A64: INS Vd.B[lane], Wn + /// uint8x8_t vset_lane_u8 (uint8_t a, uint8x8_t v, const int lane) + /// A32: VMOV.8 Dd[lane], Rt + /// A64: INS Vd.B[lane], Wn /// public static Vector64 Insert(Vector64 vector, [ConstantExpected(Max = (byte)(7))] byte index, byte data) => Insert(vector, index, data); /// - /// int16x4_t vset_lane_s16 (int16_t a, int16x4_t v, const int lane) - /// A32: VMOV.16 Dd[lane], Rt - /// A64: INS Vd.H[lane], Wn + /// int16x4_t vset_lane_s16 (int16_t a, int16x4_t v, const int lane) + /// A32: VMOV.16 Dd[lane], Rt + /// A64: INS Vd.H[lane], Wn /// public static Vector64 Insert(Vector64 vector, [ConstantExpected(Max = (byte)(3))] byte index, short data) => Insert(vector, index, data); /// - /// int32x2_t vset_lane_s32 (int32_t a, int32x2_t v, const int lane) - /// A32: VMOV.32 Dd[lane], Rt - /// A64: INS Vd.S[lane], Wn + /// int32x2_t vset_lane_s32 (int32_t a, int32x2_t v, const int lane) + /// A32: VMOV.32 Dd[lane], Rt + /// A64: INS Vd.S[lane], Wn /// public static Vector64 Insert(Vector64 vector, [ConstantExpected(Max = (byte)(1))] byte index, int data) => Insert(vector, index, data); /// - /// int8x8_t vset_lane_s8 (int8_t a, int8x8_t v, const int lane) - /// A32: VMOV.8 Dd[lane], Rt - /// A64: INS Vd.B[lane], Wn + /// int8x8_t vset_lane_s8 (int8_t a, int8x8_t v, const int lane) + /// A32: VMOV.8 Dd[lane], Rt + /// A64: INS Vd.B[lane], Wn /// public static Vector64 Insert(Vector64 vector, [ConstantExpected(Max = (byte)(7))] byte index, sbyte data) => Insert(vector, index, data); /// - /// float32x2_t vset_lane_f32 (float32_t a, float32x2_t v, const int lane) - /// A32: VMOV.F32 Sd, Sm - /// A64: INS Vd.S[lane], Vn.S[0] + /// float32x2_t vset_lane_f32 (float32_t a, float32x2_t v, const int lane) + /// A32: VMOV.F32 Sd, Sm + /// A64: INS Vd.S[lane], Vn.S[0] /// public static Vector64 Insert(Vector64 vector, [ConstantExpected(Max = (byte)(1))] byte index, float data) => Insert(vector, index, data); /// - /// uint16x4_t vset_lane_u16 (uint16_t a, uint16x4_t v, const int lane) - /// A32: VMOV.16 Dd[lane], Rt - /// A64: INS Vd.H[lane], Wn + /// uint16x4_t vset_lane_u16 (uint16_t a, uint16x4_t v, const int lane) + /// A32: VMOV.16 Dd[lane], Rt + /// A64: INS Vd.H[lane], Wn /// public static Vector64 Insert(Vector64 vector, [ConstantExpected(Max = (byte)(3))] byte index, ushort data) => Insert(vector, index, data); /// - /// uint32x2_t vset_lane_u32 (uint32_t a, uint32x2_t v, const int lane) - /// A32: VMOV.32 Dd[lane], Rt - /// A64: INS Vd.S[lane], Wn + /// uint32x2_t vset_lane_u32 (uint32_t a, uint32x2_t v, const int lane) + /// A32: VMOV.32 Dd[lane], Rt + /// A64: INS Vd.S[lane], Wn /// public static Vector64 Insert(Vector64 vector, [ConstantExpected(Max = (byte)(1))] byte index, uint data) => Insert(vector, index, data); /// - /// uint8x16_t vsetq_lane_u8 (uint8_t a, uint8x16_t v, const int lane) - /// A32: VMOV.8 Dd[lane], Rt - /// A64: INS Vd.B[lane], Wn + /// uint8x16_t vsetq_lane_u8 (uint8_t a, uint8x16_t v, const int lane) + /// A32: VMOV.8 Dd[lane], Rt + /// A64: INS Vd.B[lane], Wn /// public static Vector128 Insert(Vector128 vector, [ConstantExpected(Max = (byte)(15))] byte index, byte data) => Insert(vector, index, data); /// - /// float64x2_t vsetq_lane_f64 (float64_t a, float64x2_t v, const int lane) - /// A32: VMOV.F64 Dd, Dm - /// A64: INS Vd.D[lane], Vn.D[0] + /// float64x2_t vsetq_lane_f64 (float64_t a, float64x2_t v, const int lane) + /// A32: VMOV.F64 Dd, Dm + /// A64: INS Vd.D[lane], Vn.D[0] /// public static Vector128 Insert(Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte index, double data) => Insert(vector, index, data); /// - /// int16x8_t vsetq_lane_s16 (int16_t a, int16x8_t v, const int lane) - /// A32: VMOV.16 Dd[lane], Rt - /// A64: INS Vd.H[lane], Wn + /// int16x8_t vsetq_lane_s16 (int16_t a, int16x8_t v, const int lane) + /// A32: VMOV.16 Dd[lane], Rt + /// A64: INS Vd.H[lane], Wn /// public static Vector128 Insert(Vector128 vector, [ConstantExpected(Max = (byte)(7))] byte index, short data) => Insert(vector, index, data); /// - /// int32x4_t vsetq_lane_s32 (int32_t a, int32x4_t v, const int lane) - /// A32: VMOV.32 Dd[lane], Rt - /// A64: INS Vd.S[lane], Wn + /// int32x4_t vsetq_lane_s32 (int32_t a, int32x4_t v, const int lane) + /// A32: VMOV.32 Dd[lane], Rt + /// A64: INS Vd.S[lane], Wn /// public static Vector128 Insert(Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index, int data) => Insert(vector, index, data); /// - /// int64x2_t vsetq_lane_s64 (int64_t a, int64x2_t v, const int lane) - /// A32: VMOV.64 Dd, Rt, Rt2 - /// A64: INS Vd.D[lane], Xn + /// int64x2_t vsetq_lane_s64 (int64_t a, int64x2_t v, const int lane) + /// A32: VMOV.64 Dd, Rt, Rt2 + /// A64: INS Vd.D[lane], Xn /// public static Vector128 Insert(Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte index, long data) => Insert(vector, index, data); /// - /// int8x16_t vsetq_lane_s8 (int8_t a, int8x16_t v, const int lane) - /// A32: VMOV.8 Dd[lane], Rt - /// A64: INS Vd.B[lane], Wn + /// int8x16_t vsetq_lane_s8 (int8_t a, int8x16_t v, const int lane) + /// A32: VMOV.8 Dd[lane], Rt + /// A64: INS Vd.B[lane], Wn /// public static Vector128 Insert(Vector128 vector, [ConstantExpected(Max = (byte)(15))] byte index, sbyte data) => Insert(vector, index, data); /// - /// float32x4_t vsetq_lane_f32 (float32_t a, float32x4_t v, const int lane) - /// A32: VMOV.F32 Sd, Sm - /// A64: INS Vd.S[lane], Vn.S[0] + /// float32x4_t vsetq_lane_f32 (float32_t a, float32x4_t v, const int lane) + /// A32: VMOV.F32 Sd, Sm + /// A64: INS Vd.S[lane], Vn.S[0] /// public static Vector128 Insert(Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index, float data) => Insert(vector, index, data); /// - /// uint16x8_t vsetq_lane_u16 (uint16_t a, uint16x8_t v, const int lane) - /// A32: VMOV.16 Dd[lane], Rt - /// A64: INS Vd.H[lane], Wn + /// uint16x8_t vsetq_lane_u16 (uint16_t a, uint16x8_t v, const int lane) + /// A32: VMOV.16 Dd[lane], Rt + /// A64: INS Vd.H[lane], Wn /// public static Vector128 Insert(Vector128 vector, [ConstantExpected(Max = (byte)(7))] byte index, ushort data) => Insert(vector, index, data); /// - /// uint32x4_t vsetq_lane_u32 (uint32_t a, uint32x4_t v, const int lane) - /// A32: VMOV.32 Dd[lane], Rt - /// A64: INS Vd.S[lane], Wn + /// uint32x4_t vsetq_lane_u32 (uint32_t a, uint32x4_t v, const int lane) + /// A32: VMOV.32 Dd[lane], Rt + /// A64: INS Vd.S[lane], Wn /// public static Vector128 Insert(Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index, uint data) => Insert(vector, index, data); /// - /// uint64x2_t vsetq_lane_u64 (uint64_t a, uint64x2_t v, const int lane) - /// A32: VMOV.64 Dd, Rt, Rt2 - /// A64: INS Vd.D[lane], Xn + /// uint64x2_t vsetq_lane_u64 (uint64_t a, uint64x2_t v, const int lane) + /// A32: VMOV.64 Dd, Rt, Rt2 + /// A64: INS Vd.D[lane], Xn /// public static Vector128 Insert(Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte index, ulong data) => Insert(vector, index, data); /// - /// float64x2_t vcopyq_lane_f64 (float64x2_t a, const int lane1, float64x1_t b, const int lane2) - /// A32: VMOV.F64 Dd, Dm - /// A64: INS Vd.D[lane1], Vn.D[0] + /// float64x2_t vcopyq_lane_f64 (float64x2_t a, const int lane1, float64x1_t b, const int lane2) + /// A32: VMOV.F64 Dd, Dm + /// A64: INS Vd.D[lane1], Vn.D[0] /// public static Vector128 InsertScalar(Vector128 result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector64 value) => InsertScalar(result, resultIndex, value); /// - /// int64x2_t vcopyq_lane_s64 (int64x2_t a, const int lane1, int64x1_t b, const int lane2) - /// A32: VMOV Dd, Dm - /// A64: INS Vd.D[lane1], Vn.D[0] + /// int64x2_t vcopyq_lane_s64 (int64x2_t a, const int lane1, int64x1_t b, const int lane2) + /// A32: VMOV Dd, Dm + /// A64: INS Vd.D[lane1], Vn.D[0] /// public static Vector128 InsertScalar(Vector128 result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector64 value) => InsertScalar(result, resultIndex, value); /// - /// uint64x2_t vcopyq_lane_u64 (uint64x2_t a, const int lane1, uint64x1_t b, const int lane2) - /// A32: VMOV Dd, Dm - /// A64: INS Vd.D[lane1], Vn.D[0] + /// uint64x2_t vcopyq_lane_u64 (uint64x2_t a, const int lane1, uint64x1_t b, const int lane2) + /// A32: VMOV Dd, Dm + /// A64: INS Vd.D[lane1], Vn.D[0] /// public static Vector128 InsertScalar(Vector128 result, [ConstantExpected(Max = (byte)(1))] byte resultIndex, Vector64 value) => InsertScalar(result, resultIndex, value); /// - /// int16x4_t vcls_s16 (int16x4_t a) - /// A32: VCLS.S16 Dd, Dm - /// A64: CLS Vd.4H, Vn.4H + /// int16x4_t vcls_s16 (int16x4_t a) + /// A32: VCLS.S16 Dd, Dm + /// A64: CLS Vd.4H, Vn.4H /// public static Vector64 LeadingSignCount(Vector64 value) => LeadingSignCount(value); /// - /// int32x2_t vcls_s32 (int32x2_t a) - /// A32: VCLS.S32 Dd, Dm - /// A64: CLS Vd.2S, Vn.2S + /// int32x2_t vcls_s32 (int32x2_t a) + /// A32: VCLS.S32 Dd, Dm + /// A64: CLS Vd.2S, Vn.2S /// public static Vector64 LeadingSignCount(Vector64 value) => LeadingSignCount(value); /// - /// int8x8_t vcls_s8 (int8x8_t a) - /// A32: VCLS.S8 Dd, Dm - /// A64: CLS Vd.8B, Vn.8B + /// int8x8_t vcls_s8 (int8x8_t a) + /// A32: VCLS.S8 Dd, Dm + /// A64: CLS Vd.8B, Vn.8B /// public static Vector64 LeadingSignCount(Vector64 value) => LeadingSignCount(value); /// - /// int16x8_t vclsq_s16 (int16x8_t a) - /// A32: VCLS.S16 Qd, Qm - /// A64: CLS Vd.8H, Vn.8H + /// int16x8_t vclsq_s16 (int16x8_t a) + /// A32: VCLS.S16 Qd, Qm + /// A64: CLS Vd.8H, Vn.8H /// public static Vector128 LeadingSignCount(Vector128 value) => LeadingSignCount(value); /// - /// int32x4_t vclsq_s32 (int32x4_t a) - /// A32: VCLS.S32 Qd, Qm - /// A64: CLS Vd.4S, Vn.4S + /// int32x4_t vclsq_s32 (int32x4_t a) + /// A32: VCLS.S32 Qd, Qm + /// A64: CLS Vd.4S, Vn.4S /// public static Vector128 LeadingSignCount(Vector128 value) => LeadingSignCount(value); /// - /// int8x16_t vclsq_s8 (int8x16_t a) - /// A32: VCLS.S8 Qd, Qm - /// A64: CLS Vd.16B, Vn.16B + /// int8x16_t vclsq_s8 (int8x16_t a) + /// A32: VCLS.S8 Qd, Qm + /// A64: CLS Vd.16B, Vn.16B /// public static Vector128 LeadingSignCount(Vector128 value) => LeadingSignCount(value); /// - /// uint8x8_t vclz_u8 (uint8x8_t a) - /// A32: VCLZ.I8 Dd, Dm - /// A64: CLZ Vd.8B, Vn.8B + /// uint8x8_t vclz_u8 (uint8x8_t a) + /// A32: VCLZ.I8 Dd, Dm + /// A64: CLZ Vd.8B, Vn.8B /// public static Vector64 LeadingZeroCount(Vector64 value) => LeadingZeroCount(value); /// - /// int16x4_t vclz_s16 (int16x4_t a) - /// A32: VCLZ.I16 Dd, Dm - /// A64: CLZ Vd.4H, Vn.4H + /// int16x4_t vclz_s16 (int16x4_t a) + /// A32: VCLZ.I16 Dd, Dm + /// A64: CLZ Vd.4H, Vn.4H /// public static Vector64 LeadingZeroCount(Vector64 value) => LeadingZeroCount(value); /// - /// int32x2_t vclz_s32 (int32x2_t a) - /// A32: VCLZ.I32 Dd, Dm - /// A64: CLZ Vd.2S, Vn.2S + /// int32x2_t vclz_s32 (int32x2_t a) + /// A32: VCLZ.I32 Dd, Dm + /// A64: CLZ Vd.2S, Vn.2S /// public static Vector64 LeadingZeroCount(Vector64 value) => LeadingZeroCount(value); /// - /// int8x8_t vclz_s8 (int8x8_t a) - /// A32: VCLZ.I8 Dd, Dm - /// A64: CLZ Vd.8B, Vn.8B + /// int8x8_t vclz_s8 (int8x8_t a) + /// A32: VCLZ.I8 Dd, Dm + /// A64: CLZ Vd.8B, Vn.8B /// public static Vector64 LeadingZeroCount(Vector64 value) => LeadingZeroCount(value); /// - /// uint16x4_t vclz_u16 (uint16x4_t a) - /// A32: VCLZ.I16 Dd, Dm - /// A64: CLZ Vd.4H, Vn.4H + /// uint16x4_t vclz_u16 (uint16x4_t a) + /// A32: VCLZ.I16 Dd, Dm + /// A64: CLZ Vd.4H, Vn.4H /// public static Vector64 LeadingZeroCount(Vector64 value) => LeadingZeroCount(value); /// - /// uint32x2_t vclz_u32 (uint32x2_t a) - /// A32: VCLZ.I32 Dd, Dm - /// A64: CLZ Vd.2S, Vn.2S + /// uint32x2_t vclz_u32 (uint32x2_t a) + /// A32: VCLZ.I32 Dd, Dm + /// A64: CLZ Vd.2S, Vn.2S /// public static Vector64 LeadingZeroCount(Vector64 value) => LeadingZeroCount(value); /// - /// uint8x16_t vclzq_u8 (uint8x16_t a) - /// A32: VCLZ.I8 Qd, Qm - /// A64: CLZ Vd.16B, Vn.16B + /// uint8x16_t vclzq_u8 (uint8x16_t a) + /// A32: VCLZ.I8 Qd, Qm + /// A64: CLZ Vd.16B, Vn.16B /// public static Vector128 LeadingZeroCount(Vector128 value) => LeadingZeroCount(value); /// - /// int16x8_t vclzq_s16 (int16x8_t a) - /// A32: VCLZ.I16 Qd, Qm - /// A64: CLZ Vd.8H, Vn.8H + /// int16x8_t vclzq_s16 (int16x8_t a) + /// A32: VCLZ.I16 Qd, Qm + /// A64: CLZ Vd.8H, Vn.8H /// public static Vector128 LeadingZeroCount(Vector128 value) => LeadingZeroCount(value); /// - /// int32x4_t vclzq_s32 (int32x4_t a) - /// A32: VCLZ.I32 Qd, Qm - /// A64: CLZ Vd.4S, Vn.4S + /// int32x4_t vclzq_s32 (int32x4_t a) + /// A32: VCLZ.I32 Qd, Qm + /// A64: CLZ Vd.4S, Vn.4S /// public static Vector128 LeadingZeroCount(Vector128 value) => LeadingZeroCount(value); /// - /// int8x16_t vclzq_s8 (int8x16_t a) - /// A32: VCLZ.I8 Qd, Qm - /// A64: CLZ Vd.16B, Vn.16B + /// int8x16_t vclzq_s8 (int8x16_t a) + /// A32: VCLZ.I8 Qd, Qm + /// A64: CLZ Vd.16B, Vn.16B /// public static Vector128 LeadingZeroCount(Vector128 value) => LeadingZeroCount(value); /// - /// uint16x8_t vclzq_u16 (uint16x8_t a) - /// A32: VCLZ.I16 Qd, Qm - /// A64: CLZ Vd.8H, Vn.8H + /// uint16x8_t vclzq_u16 (uint16x8_t a) + /// A32: VCLZ.I16 Qd, Qm + /// A64: CLZ Vd.8H, Vn.8H /// public static Vector128 LeadingZeroCount(Vector128 value) => LeadingZeroCount(value); /// - /// uint32x4_t vclzq_u32 (uint32x4_t a) - /// A32: VCLZ.I32 Qd, Qm - /// A64: CLZ Vd.4S, Vn.4S + /// uint32x4_t vclzq_u32 (uint32x4_t a) + /// A32: VCLZ.I32 Qd, Qm + /// A64: CLZ Vd.4S, Vn.4S /// public static Vector128 LeadingZeroCount(Vector128 value) => LeadingZeroCount(value); /// - /// uint8x8_t vld1_lane_u8 (uint8_t const * ptr, uint8x8_t src, const int lane) - /// A32: VLD1.8 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.B }[index], [Xn] + /// uint8x8_t vld1_lane_u8 (uint8_t const * ptr, uint8x8_t src, const int lane) + /// A32: VLD1.8 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.B }[index], [Xn] /// public static unsafe Vector64 LoadAndInsertScalar(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte index, byte* address) => LoadAndInsertScalar(value, index, address); /// - /// int16x4_t vld1_lane_s16 (int16_t const * ptr, int16x4_t src, const int lane) - /// A32: VLD1.16 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.H }[index], [Xn] + /// int16x4_t vld1_lane_s16 (int16_t const * ptr, int16x4_t src, const int lane) + /// A32: VLD1.16 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.H }[index], [Xn] /// public static unsafe Vector64 LoadAndInsertScalar(Vector64 value, [ConstantExpected(Max = (byte)(3))] byte index, short* address) => LoadAndInsertScalar(value, index, address); /// - /// int32x2_t vld1_lane_s32 (int32_t const * ptr, int32x2_t src, const int lane) - /// A32: VLD1.32 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.S }[index], [Xn] + /// int32x2_t vld1_lane_s32 (int32_t const * ptr, int32x2_t src, const int lane) + /// A32: VLD1.32 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.S }[index], [Xn] /// public static unsafe Vector64 LoadAndInsertScalar(Vector64 value, [ConstantExpected(Max = (byte)(1))] byte index, int* address) => LoadAndInsertScalar(value, index, address); /// - /// int8x8_t vld1_lane_s8 (int8_t const * ptr, int8x8_t src, const int lane) - /// A32: VLD1.8 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.B }[index], [Xn] + /// int8x8_t vld1_lane_s8 (int8_t const * ptr, int8x8_t src, const int lane) + /// A32: VLD1.8 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.B }[index], [Xn] /// public static unsafe Vector64 LoadAndInsertScalar(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte index, sbyte* address) => LoadAndInsertScalar(value, index, address); /// - /// float32x2_t vld1_lane_f32 (float32_t const * ptr, float32x2_t src, const int lane) - /// A32: VLD1.32 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.S }[index], [Xn] + /// float32x2_t vld1_lane_f32 (float32_t const * ptr, float32x2_t src, const int lane) + /// A32: VLD1.32 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.S }[index], [Xn] /// public static unsafe Vector64 LoadAndInsertScalar(Vector64 value, [ConstantExpected(Max = (byte)(1))] byte index, float* address) => LoadAndInsertScalar(value, index, address); /// - /// uint16x4_t vld1_lane_u16 (uint16_t const * ptr, uint16x4_t src, const int lane) - /// A32: VLD1.16 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.H }[index], [Xn] + /// uint16x4_t vld1_lane_u16 (uint16_t const * ptr, uint16x4_t src, const int lane) + /// A32: VLD1.16 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.H }[index], [Xn] /// public static unsafe Vector64 LoadAndInsertScalar(Vector64 value, [ConstantExpected(Max = (byte)(3))] byte index, ushort* address) => LoadAndInsertScalar(value, index, address); /// - /// uint32x2_t vld1_lane_u32 (uint32_t const * ptr, uint32x2_t src, const int lane) - /// A32: VLD1.32 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.S }[index], [Xn] + /// uint32x2_t vld1_lane_u32 (uint32_t const * ptr, uint32x2_t src, const int lane) + /// A32: VLD1.32 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.S }[index], [Xn] /// public static unsafe Vector64 LoadAndInsertScalar(Vector64 value, [ConstantExpected(Max = (byte)(1))] byte index, uint* address) => LoadAndInsertScalar(value, index, address); /// - /// uint8x16_t vld1q_lane_u8 (uint8_t const * ptr, uint8x16_t src, const int lane) - /// A32: VLD1.8 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.B }[index], [Xn] + /// uint8x16_t vld1q_lane_u8 (uint8_t const * ptr, uint8x16_t src, const int lane) + /// A32: VLD1.8 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.B }[index], [Xn] /// public static unsafe Vector128 LoadAndInsertScalar(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte index, byte* address) => LoadAndInsertScalar(value, index, address); /// - /// float64x2_t vld1q_lane_f64 (float64_t const * ptr, float64x2_t src, const int lane) - /// A32: VLDR.64 Dd, [Rn] - /// A64: LD1 { Vt.D }[index], [Xn] + /// float64x2_t vld1q_lane_f64 (float64_t const * ptr, float64x2_t src, const int lane) + /// A32: VLDR.64 Dd, [Rn] + /// A64: LD1 { Vt.D }[index], [Xn] /// public static unsafe Vector128 LoadAndInsertScalar(Vector128 value, [ConstantExpected(Max = (byte)(1))] byte index, double* address) => LoadAndInsertScalar(value, index, address); /// - /// int16x8_t vld1q_lane_s16 (int16_t const * ptr, int16x8_t src, const int lane) - /// A32: VLD1.16 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.H }[index], [Xn] + /// int16x8_t vld1q_lane_s16 (int16_t const * ptr, int16x8_t src, const int lane) + /// A32: VLD1.16 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.H }[index], [Xn] /// public static unsafe Vector128 LoadAndInsertScalar(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte index, short* address) => LoadAndInsertScalar(value, index, address); /// - /// int32x4_t vld1q_lane_s32 (int32_t const * ptr, int32x4_t src, const int lane) - /// A32: VLD1.32 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.S }[index], [Xn] + /// int32x4_t vld1q_lane_s32 (int32_t const * ptr, int32x4_t src, const int lane) + /// A32: VLD1.32 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.S }[index], [Xn] /// public static unsafe Vector128 LoadAndInsertScalar(Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index, int* address) => LoadAndInsertScalar(value, index, address); /// - /// int64x2_t vld1q_lane_s64 (int64_t const * ptr, int64x2_t src, const int lane) - /// A32: VLDR.64 Dd, [Rn] - /// A64: LD1 { Vt.D }[index], [Xn] + /// int64x2_t vld1q_lane_s64 (int64_t const * ptr, int64x2_t src, const int lane) + /// A32: VLDR.64 Dd, [Rn] + /// A64: LD1 { Vt.D }[index], [Xn] /// public static unsafe Vector128 LoadAndInsertScalar(Vector128 value, [ConstantExpected(Max = (byte)(1))] byte index, long* address) => LoadAndInsertScalar(value, index, address); /// - /// int8x16_t vld1q_lane_s8 (int8_t const * ptr, int8x16_t src, const int lane) - /// A32: VLD1.8 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.B }[index], [Xn] + /// int8x16_t vld1q_lane_s8 (int8_t const * ptr, int8x16_t src, const int lane) + /// A32: VLD1.8 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.B }[index], [Xn] /// public static unsafe Vector128 LoadAndInsertScalar(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte index, sbyte* address) => LoadAndInsertScalar(value, index, address); /// - /// float32x4_t vld1q_lane_f32 (float32_t const * ptr, float32x4_t src, const int lane) - /// A32: VLD1.32 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.S }[index], [Xn] + /// float32x4_t vld1q_lane_f32 (float32_t const * ptr, float32x4_t src, const int lane) + /// A32: VLD1.32 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.S }[index], [Xn] /// public static unsafe Vector128 LoadAndInsertScalar(Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index, float* address) => LoadAndInsertScalar(value, index, address); /// - /// uint16x8_t vld1q_lane_u16 (uint16_t const * ptr, uint16x8_t src, const int lane) - /// A32: VLD1.16 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.H }[index], [Xn] + /// uint16x8_t vld1q_lane_u16 (uint16_t const * ptr, uint16x8_t src, const int lane) + /// A32: VLD1.16 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.H }[index], [Xn] /// public static unsafe Vector128 LoadAndInsertScalar(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte index, ushort* address) => LoadAndInsertScalar(value, index, address); /// - /// uint32x4_t vld1q_lane_u32 (uint32_t const * ptr, uint32x4_t src, const int lane) - /// A32: VLD1.32 { Dd[index] }, [Rn] - /// A64: LD1 { Vt.S }[index], [Xn] + /// uint32x4_t vld1q_lane_u32 (uint32_t const * ptr, uint32x4_t src, const int lane) + /// A32: VLD1.32 { Dd[index] }, [Rn] + /// A64: LD1 { Vt.S }[index], [Xn] /// public static unsafe Vector128 LoadAndInsertScalar(Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index, uint* address) => LoadAndInsertScalar(value, index, address); /// - /// uint64x2_t vld1q_lane_u64 (uint64_t const * ptr, uint64x2_t src, const int lane) - /// A32: VLDR.64 Dd, [Rn] - /// A64: LD1 { Vt.D }[index], [Xn] + /// uint64x2_t vld1q_lane_u64 (uint64_t const * ptr, uint64x2_t src, const int lane) + /// A32: VLDR.64 Dd, [Rn] + /// A64: LD1 { Vt.D }[index], [Xn] /// public static unsafe Vector128 LoadAndInsertScalar(Vector128 value, [ConstantExpected(Max = (byte)(1))] byte index, ulong* address) => LoadAndInsertScalar(value, index, address); - /// - /// A64: LD2 { Vn.8B, Vn+1.8B }[Vm], [Xn] - /// + /// A64: LD2 { Vn.8B, Vn+1.8B }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndInsertScalar((Vector64, Vector64) values, [ConstantExpected(Max = (byte)(7))] byte index, byte* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD2 { Vn.8B, Vn+1.8B }[Vm], [Xn] - /// + /// A64: LD2 { Vn.8B, Vn+1.8B }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndInsertScalar((Vector64, Vector64) values, [ConstantExpected(Max = (byte)(7))] byte index, sbyte* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD2 { Vn.4H, Vn+1.4H }[Vm], [Xn] - /// + /// A64: LD2 { Vn.4H, Vn+1.4H }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndInsertScalar((Vector64, Vector64) values, [ConstantExpected(Max = (byte)(3))] byte index, short* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD2 { Vn.4H, Vn+1.4H }[Vm], [Xn] - /// + /// A64: LD2 { Vn.4H, Vn+1.4H }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndInsertScalar((Vector64, Vector64) values, [ConstantExpected(Max = (byte)(3))] byte index, ushort* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD2 { Vn.2S, Vn+1.2S }[Vm], [Xn] - /// + /// A64: LD2 { Vn.2S, Vn+1.2S }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndInsertScalar((Vector64, Vector64) values, [ConstantExpected(Max = (byte)(1))] byte index, int* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD2 { Vn.2S, Vn+1.2S }[Vm], [Xn] - /// + /// A64: LD2 { Vn.2S, Vn+1.2S }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndInsertScalar((Vector64, Vector64) values, [ConstantExpected(Max = (byte)(1))] byte index, uint* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD2 { Vn.2S, Vn+1.2S }[Vm], [Xn] - /// + /// A64: LD2 { Vn.2S, Vn+1.2S }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndInsertScalar((Vector64, Vector64) values, [ConstantExpected(Max = (byte)(1))] byte index, float* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD3 { Vn.8B, Vn+1.8B, Vn+2.8B }[Vm], [Xn] - /// + /// A64: LD3 { Vn.8B, Vn+1.8B, Vn+2.8B }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndInsertScalar((Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(7))] byte index, byte* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD3 { Vn.8B, Vn+1.8B, Vn+2.8B }[Vm], [Xn] - /// + /// A64: LD3 { Vn.8B, Vn+1.8B, Vn+2.8B }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndInsertScalar((Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(7))] byte index, sbyte* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD3 { Vn.4H, Vn+1.4H, Vn+2.4H }[Vm], [Xn] - /// + /// A64: LD3 { Vn.4H, Vn+1.4H, Vn+2.4H }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndInsertScalar((Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(3))] byte index, short* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD3 { Vn.4H, Vn+1.4H, Vn+2.4H }[Vm], [Xn] - /// + /// A64: LD3 { Vn.4H, Vn+1.4H, Vn+2.4H }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndInsertScalar((Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(3))] byte index, ushort* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }[Vm], [Xn] - /// + /// A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndInsertScalar((Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(1))] byte index, int* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }[Vm], [Xn] - /// + /// A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndInsertScalar((Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(1))] byte index, uint* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }[Vm], [Xn] - /// + /// A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndInsertScalar((Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(1))] byte index, float* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }[Vm], [Xn] - /// + /// A64: LD4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndInsertScalar((Vector64, Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(7))] byte index, byte* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }[Vm], [Xn] - /// + /// A64: LD4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndInsertScalar((Vector64, Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(7))] byte index, sbyte* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }[Vm], [Xn] - /// + /// A64: LD4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndInsertScalar((Vector64, Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(3))] byte index, short* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }[Vm], [Xn] - /// + /// A64: LD4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndInsertScalar((Vector64, Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(3))] byte index, ushort* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }[Vm], [Xn] - /// + /// A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndInsertScalar((Vector64, Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(1))] byte index, int* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }[Vm], [Xn] - /// + /// A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndInsertScalar((Vector64, Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(1))] byte index, uint* address) => LoadAndInsertScalar(values, index, address); - /// - /// A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }[Vm], [Xn] - /// + /// A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }[Vm], [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndInsertScalar((Vector64, Vector64, Vector64, Vector64) values, [ConstantExpected(Max = (byte)(1))] byte index, float* address) => LoadAndInsertScalar(values, index, address); /// - /// uint8x8_t vld1_dup_u8 (uint8_t const * ptr) - /// A32: VLD1.8 { Dd[] }, [Rn] - /// A64: LD1R { Vt.8B }, [Xn] + /// uint8x8_t vld1_dup_u8 (uint8_t const * ptr) + /// A32: VLD1.8 { Dd[] }, [Rn] + /// A64: LD1R { Vt.8B }, [Xn] /// public static unsafe Vector64 LoadAndReplicateToVector64(byte* address) => LoadAndReplicateToVector64(address); /// - /// int16x4_t vld1_dup_s16 (int16_t const * ptr) - /// A32: VLD1.16 { Dd[] }, [Rn] - /// A64: LD1R { Vt.4H }, [Xn] + /// int16x4_t vld1_dup_s16 (int16_t const * ptr) + /// A32: VLD1.16 { Dd[] }, [Rn] + /// A64: LD1R { Vt.4H }, [Xn] /// public static unsafe Vector64 LoadAndReplicateToVector64(short* address) => LoadAndReplicateToVector64(address); /// - /// int32x2_t vld1_dup_s32 (int32_t const * ptr) - /// A32: VLD1.32 { Dd[] }, [Rn] - /// A64: LD1R { Vt.2S }, [Xn] + /// int32x2_t vld1_dup_s32 (int32_t const * ptr) + /// A32: VLD1.32 { Dd[] }, [Rn] + /// A64: LD1R { Vt.2S }, [Xn] /// public static unsafe Vector64 LoadAndReplicateToVector64(int* address) => LoadAndReplicateToVector64(address); /// - /// int8x8_t vld1_dup_s8 (int8_t const * ptr) - /// A32: VLD1.8 { Dd[] }, [Rn] - /// A64: LD1R { Vt.8B }, [Xn] + /// int8x8_t vld1_dup_s8 (int8_t const * ptr) + /// A32: VLD1.8 { Dd[] }, [Rn] + /// A64: LD1R { Vt.8B }, [Xn] /// public static unsafe Vector64 LoadAndReplicateToVector64(sbyte* address) => LoadAndReplicateToVector64(address); /// - /// float32x2_t vld1_dup_f32 (float32_t const * ptr) - /// A32: VLD1.32 { Dd[] }, [Rn] - /// A64: LD1R { Vt.2S }, [Xn] + /// float32x2_t vld1_dup_f32 (float32_t const * ptr) + /// A32: VLD1.32 { Dd[] }, [Rn] + /// A64: LD1R { Vt.2S }, [Xn] /// public static unsafe Vector64 LoadAndReplicateToVector64(float* address) => LoadAndReplicateToVector64(address); /// - /// uint16x4_t vld1_dup_u16 (uint16_t const * ptr) - /// A32: VLD1.16 { Dd[] }, [Rn] - /// A64: LD1R { Vt.4H }, [Xn] + /// uint16x4_t vld1_dup_u16 (uint16_t const * ptr) + /// A32: VLD1.16 { Dd[] }, [Rn] + /// A64: LD1R { Vt.4H }, [Xn] /// public static unsafe Vector64 LoadAndReplicateToVector64(ushort* address) => LoadAndReplicateToVector64(address); /// - /// uint32x2_t vld1_dup_u32 (uint32_t const * ptr) - /// A32: VLD1.32 { Dd[] }, [Rn] - /// A64: LD1R { Vt.2S }, [Xn] + /// uint32x2_t vld1_dup_u32 (uint32_t const * ptr) + /// A32: VLD1.32 { Dd[] }, [Rn] + /// A64: LD1R { Vt.2S }, [Xn] /// public static unsafe Vector64 LoadAndReplicateToVector64(uint* address) => LoadAndReplicateToVector64(address); /// - /// uint8x16_t vld1q_dup_u8 (uint8_t const * ptr) - /// A32: VLD1.8 { Dd[], Dd+1[] }, [Rn] - /// A64: LD1R { Vt.16B }, [Xn] + /// uint8x16_t vld1q_dup_u8 (uint8_t const * ptr) + /// A32: VLD1.8 { Dd[], Dd+1[] }, [Rn] + /// A64: LD1R { Vt.16B }, [Xn] /// public static unsafe Vector128 LoadAndReplicateToVector128(byte* address) => LoadAndReplicateToVector128(address); /// - /// int16x8_t vld1q_dup_s16 (int16_t const * ptr) - /// A32: VLD1.16 { Dd[], Dd+1[] }, [Rn] - /// A64: LD1R { Vt.8H }, [Xn] + /// int16x8_t vld1q_dup_s16 (int16_t const * ptr) + /// A32: VLD1.16 { Dd[], Dd+1[] }, [Rn] + /// A64: LD1R { Vt.8H }, [Xn] /// public static unsafe Vector128 LoadAndReplicateToVector128(short* address) => LoadAndReplicateToVector128(address); /// - /// int32x4_t vld1q_dup_s32 (int32_t const * ptr) - /// A32: VLD1.32 { Dd[], Dd+1[] }, [Rn] - /// A64: LD1R { Vt.4S }, [Xn] + /// int32x4_t vld1q_dup_s32 (int32_t const * ptr) + /// A32: VLD1.32 { Dd[], Dd+1[] }, [Rn] + /// A64: LD1R { Vt.4S }, [Xn] /// public static unsafe Vector128 LoadAndReplicateToVector128(int* address) => LoadAndReplicateToVector128(address); /// - /// int8x16_t vld1q_dup_s8 (int8_t const * ptr) - /// A32: VLD1.8 { Dd[], Dd+1[] }, [Rn] - /// A64: LD1R { Vt.16B }, [Xn] + /// int8x16_t vld1q_dup_s8 (int8_t const * ptr) + /// A32: VLD1.8 { Dd[], Dd+1[] }, [Rn] + /// A64: LD1R { Vt.16B }, [Xn] /// public static unsafe Vector128 LoadAndReplicateToVector128(sbyte* address) => LoadAndReplicateToVector128(address); /// - /// float32x4_t vld1q_dup_f32 (float32_t const * ptr) - /// A32: VLD1.32 { Dd[], Dd+1[] }, [Rn] - /// A64: LD1R { Vt.4S }, [Xn] + /// float32x4_t vld1q_dup_f32 (float32_t const * ptr) + /// A32: VLD1.32 { Dd[], Dd+1[] }, [Rn] + /// A64: LD1R { Vt.4S }, [Xn] /// public static unsafe Vector128 LoadAndReplicateToVector128(float* address) => LoadAndReplicateToVector128(address); /// - /// uint16x8_t vld1q_dup_u16 (uint16_t const * ptr) - /// A32: VLD1.16 { Dd[], Dd+1[] }, [Rn] - /// A64: LD1R { Vt.8H }, [Xn] + /// uint16x8_t vld1q_dup_u16 (uint16_t const * ptr) + /// A32: VLD1.16 { Dd[], Dd+1[] }, [Rn] + /// A64: LD1R { Vt.8H }, [Xn] /// public static unsafe Vector128 LoadAndReplicateToVector128(ushort* address) => LoadAndReplicateToVector128(address); /// - /// uint32x4_t vld1q_dup_u32 (uint32_t const * ptr) - /// A32: VLD1.32 { Dd[], Dd+1[] }, [Rn] - /// A64: LD1R { Vt.4S }, [Xn] + /// uint32x4_t vld1q_dup_u32 (uint32_t const * ptr) + /// A32: VLD1.32 { Dd[], Dd+1[] }, [Rn] + /// A64: LD1R { Vt.4S }, [Xn] /// public static unsafe Vector128 LoadAndReplicateToVector128(uint* address) => LoadAndReplicateToVector128(address); - /// - /// A64: LD2R { Vn.8B, Vn+1.8B }, [Xn] - /// + /// A64: LD2R { Vn.8B, Vn+1.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndReplicateToVector64x2(byte* address) => LoadAndReplicateToVector64x2(address); - /// - /// A64: LD2R { Vn.8B, Vn+1.8B }, [Xn] - /// + /// A64: LD2R { Vn.8B, Vn+1.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndReplicateToVector64x2(sbyte* address) => LoadAndReplicateToVector64x2(address); - /// - /// A64: LD2R { Vn.4H, Vn+1.4H }, [Xn] - /// + /// A64: LD2R { Vn.4H, Vn+1.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndReplicateToVector64x2(short* address) => LoadAndReplicateToVector64x2(address); - /// - /// A64: LD2R { Vn.4H, Vn+1.4H }, [Xn] - /// + /// A64: LD2R { Vn.4H, Vn+1.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndReplicateToVector64x2(ushort* address) => LoadAndReplicateToVector64x2(address); - /// - /// A64: LD2R { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: LD2R { Vn.2S, Vn+1.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndReplicateToVector64x2(int* address) => LoadAndReplicateToVector64x2(address); - /// - /// A64: LD2R { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: LD2R { Vn.2S, Vn+1.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndReplicateToVector64x2(uint* address) => LoadAndReplicateToVector64x2(address); - /// - /// A64: LD2R { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: LD2R { Vn.2S, Vn+1.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) LoadAndReplicateToVector64x2(float* address) => LoadAndReplicateToVector64x2(address); - /// - /// A64: LD3R { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] - /// + /// A64: LD3R { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndReplicateToVector64x3(byte* address) => LoadAndReplicateToVector64x3(address); - /// - /// A64: LD3R { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] - /// + /// A64: LD3R { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndReplicateToVector64x3(sbyte* address) => LoadAndReplicateToVector64x3(address); - /// - /// A64: LD3R { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] - /// + /// A64: LD3R { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndReplicateToVector64x3(short* address) => LoadAndReplicateToVector64x3(address); - /// - /// A64: LD3R { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] - /// + /// A64: LD3R { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndReplicateToVector64x3(ushort* address) => LoadAndReplicateToVector64x3(address); - /// - /// A64: LD3R { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: LD3R { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndReplicateToVector64x3(int* address) => LoadAndReplicateToVector64x3(address); - /// - /// A64: LD3R { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: LD3R { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndReplicateToVector64x3(uint* address) => LoadAndReplicateToVector64x3(address); - /// - /// A64: LD3R { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: LD3R { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadAndReplicateToVector64x3(float* address) => LoadAndReplicateToVector64x3(address); - /// - /// A64: LD4R { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] - /// + /// A64: LD4R { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndReplicateToVector64x4(byte* address) => LoadAndReplicateToVector64x4(address); - /// - /// A64: LD4R { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] - /// + /// A64: LD4R { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndReplicateToVector64x4(sbyte* address) => LoadAndReplicateToVector64x4(address); - /// - /// A64: LD4R { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] - /// + /// A64: LD4R { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndReplicateToVector64x4(short* address) => LoadAndReplicateToVector64x4(address); - /// - /// A64: LD4R { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] - /// + /// A64: LD4R { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndReplicateToVector64x4(ushort* address) => LoadAndReplicateToVector64x4(address); - /// - /// A64: LD4R { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: LD4R { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndReplicateToVector64x4(int* address) => LoadAndReplicateToVector64x4(address); - /// - /// A64: LD4R { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: LD4R { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndReplicateToVector64x4(uint* address) => LoadAndReplicateToVector64x4(address); - /// - /// A64: LD4R { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: LD4R { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadAndReplicateToVector64x4(float* address) => LoadAndReplicateToVector64x4(address); /// - /// uint8x8_t vld1_u8 (uint8_t const * ptr) - /// A32: VLD1.8 Dd, [Rn] - /// A64: LD1 Vt.8B, [Xn] + /// uint8x8_t vld1_u8 (uint8_t const * ptr) + /// A32: VLD1.8 Dd, [Rn] + /// A64: LD1 Vt.8B, [Xn] /// public static unsafe Vector64 LoadVector64(byte* address) => LoadVector64(address); /// - /// float64x1_t vld1_f64 (float64_t const * ptr) - /// A32: VLD1.64 Dd, [Rn] - /// A64: LD1 Vt.1D, [Xn] + /// float64x1_t vld1_f64 (float64_t const * ptr) + /// A32: VLD1.64 Dd, [Rn] + /// A64: LD1 Vt.1D, [Xn] /// public static unsafe Vector64 LoadVector64(double* address) => LoadVector64(address); /// - /// int16x4_t vld1_s16 (int16_t const * ptr) - /// A32: VLD1.16 Dd, [Rn] - /// A64: LD1 Vt.4H, [Xn] + /// int16x4_t vld1_s16 (int16_t const * ptr) + /// A32: VLD1.16 Dd, [Rn] + /// A64: LD1 Vt.4H, [Xn] /// public static unsafe Vector64 LoadVector64(short* address) => LoadVector64(address); /// - /// int32x2_t vld1_s32 (int32_t const * ptr) - /// A32: VLD1.32 Dd, [Rn] - /// A64: LD1 Vt.2S, [Xn] + /// int32x2_t vld1_s32 (int32_t const * ptr) + /// A32: VLD1.32 Dd, [Rn] + /// A64: LD1 Vt.2S, [Xn] /// public static unsafe Vector64 LoadVector64(int* address) => LoadVector64(address); /// - /// int64x1_t vld1_s64 (int64_t const * ptr) - /// A32: VLD1.64 Dd, [Rn] - /// A64: LD1 Vt.1D, [Xn] + /// int64x1_t vld1_s64 (int64_t const * ptr) + /// A32: VLD1.64 Dd, [Rn] + /// A64: LD1 Vt.1D, [Xn] /// public static unsafe Vector64 LoadVector64(long* address) => LoadVector64(address); /// - /// int8x8_t vld1_s8 (int8_t const * ptr) - /// A32: VLD1.8 Dd, [Rn] - /// A64: LD1 Vt.8B, [Xn] + /// int8x8_t vld1_s8 (int8_t const * ptr) + /// A32: VLD1.8 Dd, [Rn] + /// A64: LD1 Vt.8B, [Xn] /// public static unsafe Vector64 LoadVector64(sbyte* address) => LoadVector64(address); /// - /// float32x2_t vld1_f32 (float32_t const * ptr) - /// A32: VLD1.32 Dd, [Rn] - /// A64: LD1 Vt.2S, [Xn] + /// float32x2_t vld1_f32 (float32_t const * ptr) + /// A32: VLD1.32 Dd, [Rn] + /// A64: LD1 Vt.2S, [Xn] /// public static unsafe Vector64 LoadVector64(float* address) => LoadVector64(address); /// - /// uint16x4_t vld1_u16 (uint16_t const * ptr) - /// A32: VLD1.16 Dd, [Rn] - /// A64: LD1 Vt.4H, [Xn] + /// uint16x4_t vld1_u16 (uint16_t const * ptr) + /// A32: VLD1.16 Dd, [Rn] + /// A64: LD1 Vt.4H, [Xn] /// public static unsafe Vector64 LoadVector64(ushort* address) => LoadVector64(address); /// - /// uint32x2_t vld1_u32 (uint32_t const * ptr) - /// A32: VLD1.32 Dd, [Rn] - /// A64: LD1 Vt.2S, [Xn] + /// uint32x2_t vld1_u32 (uint32_t const * ptr) + /// A32: VLD1.32 Dd, [Rn] + /// A64: LD1 Vt.2S, [Xn] /// public static unsafe Vector64 LoadVector64(uint* address) => LoadVector64(address); /// - /// uint64x1_t vld1_u64 (uint64_t const * ptr) - /// A32: VLD1.64 Dd, [Rn] - /// A64: LD1 Vt.1D, [Xn] + /// uint64x1_t vld1_u64 (uint64_t const * ptr) + /// A32: VLD1.64 Dd, [Rn] + /// A64: LD1 Vt.1D, [Xn] /// public static unsafe Vector64 LoadVector64(ulong* address) => LoadVector64(address); /// - /// uint8x16_t vld1q_u8 (uint8_t const * ptr) - /// A32: VLD1.8 Dd, Dd+1, [Rn] - /// A64: LD1 Vt.16B, [Xn] + /// uint8x16_t vld1q_u8 (uint8_t const * ptr) + /// A32: VLD1.8 Dd, Dd+1, [Rn] + /// A64: LD1 Vt.16B, [Xn] /// public static unsafe Vector128 LoadVector128(byte* address) => LoadVector128(address); /// - /// float64x2_t vld1q_f64 (float64_t const * ptr) - /// A32: VLD1.64 Dd, Dd+1, [Rn] - /// A64: LD1 Vt.2D, [Xn] + /// float64x2_t vld1q_f64 (float64_t const * ptr) + /// A32: VLD1.64 Dd, Dd+1, [Rn] + /// A64: LD1 Vt.2D, [Xn] /// public static unsafe Vector128 LoadVector128(double* address) => LoadVector128(address); /// - /// int16x8_t vld1q_s16 (int16_t const * ptr) - /// A32: VLD1.16 Dd, Dd+1, [Rn] - /// A64: LD1 Vt.8H, [Xn] + /// int16x8_t vld1q_s16 (int16_t const * ptr) + /// A32: VLD1.16 Dd, Dd+1, [Rn] + /// A64: LD1 Vt.8H, [Xn] /// public static unsafe Vector128 LoadVector128(short* address) => LoadVector128(address); /// - /// int32x4_t vld1q_s32 (int32_t const * ptr) - /// A32: VLD1.32 Dd, Dd+1, [Rn] - /// A64: LD1 Vt.4S, [Xn] + /// int32x4_t vld1q_s32 (int32_t const * ptr) + /// A32: VLD1.32 Dd, Dd+1, [Rn] + /// A64: LD1 Vt.4S, [Xn] /// public static unsafe Vector128 LoadVector128(int* address) => LoadVector128(address); /// - /// int64x2_t vld1q_s64 (int64_t const * ptr) - /// A32: VLD1.64 Dd, Dd+1, [Rn] - /// A64: LD1 Vt.2D, [Xn] + /// int64x2_t vld1q_s64 (int64_t const * ptr) + /// A32: VLD1.64 Dd, Dd+1, [Rn] + /// A64: LD1 Vt.2D, [Xn] /// public static unsafe Vector128 LoadVector128(long* address) => LoadVector128(address); /// - /// int8x16_t vld1q_s8 (int8_t const * ptr) - /// A32: VLD1.8 Dd, Dd+1, [Rn] - /// A64: LD1 Vt.16B, [Xn] + /// int8x16_t vld1q_s8 (int8_t const * ptr) + /// A32: VLD1.8 Dd, Dd+1, [Rn] + /// A64: LD1 Vt.16B, [Xn] /// public static unsafe Vector128 LoadVector128(sbyte* address) => LoadVector128(address); /// - /// float32x4_t vld1q_f32 (float32_t const * ptr) - /// A32: VLD1.32 Dd, Dd+1, [Rn] - /// A64: LD1 Vt.4S, [Xn] + /// float32x4_t vld1q_f32 (float32_t const * ptr) + /// A32: VLD1.32 Dd, Dd+1, [Rn] + /// A64: LD1 Vt.4S, [Xn] /// public static unsafe Vector128 LoadVector128(float* address) => LoadVector128(address); /// - /// uint16x8_t vld1q_s16 (uint16_t const * ptr) - /// A32: VLD1.16 Dd, Dd+1, [Rn] - /// A64: LD1 Vt.8H, [Xn] + /// uint16x8_t vld1q_s16 (uint16_t const * ptr) + /// A32: VLD1.16 Dd, Dd+1, [Rn] + /// A64: LD1 Vt.8H, [Xn] /// public static unsafe Vector128 LoadVector128(ushort* address) => LoadVector128(address); /// - /// uint32x4_t vld1q_s32 (uint32_t const * ptr) - /// A32: VLD1.32 Dd, Dd+1, [Rn] - /// A64: LD1 Vt.4S, [Xn] + /// uint32x4_t vld1q_s32 (uint32_t const * ptr) + /// A32: VLD1.32 Dd, Dd+1, [Rn] + /// A64: LD1 Vt.4S, [Xn] /// public static unsafe Vector128 LoadVector128(uint* address) => LoadVector128(address); /// - /// uint64x2_t vld1q_u64 (uint64_t const * ptr) - /// A32: VLD1.64 Dd, Dd+1, [Rn] - /// A64: LD1 Vt.2D, [Xn] + /// uint64x2_t vld1q_u64 (uint64_t const * ptr) + /// A32: VLD1.64 Dd, Dd+1, [Rn] + /// A64: LD1 Vt.2D, [Xn] /// public static unsafe Vector128 LoadVector128(ulong* address) => LoadVector128(address); - /// - /// A64: LD2 { Vn.8B, Vn+1.8B }, [Xn] - /// + /// A64: LD2 { Vn.8B, Vn+1.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64AndUnzip(byte* address) => Load2xVector64AndUnzip(address); - /// - /// A64: LD2 { Vn.8B, Vn+1.8B }, [Xn] - /// + /// A64: LD2 { Vn.8B, Vn+1.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64AndUnzip(sbyte* address) => Load2xVector64AndUnzip(address); - /// - /// A64: LD2 { Vn.4H, Vn+1.4H }, [Xn] - /// + /// A64: LD2 { Vn.4H, Vn+1.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64AndUnzip(short* address) => Load2xVector64AndUnzip(address); - /// - /// A64: LD2 { Vn.4H, Vn+1.4H }, [Xn] - /// + /// A64: LD2 { Vn.4H, Vn+1.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64AndUnzip(ushort* address) => Load2xVector64AndUnzip(address); - /// - /// A64: LD2 { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: LD2 { Vn.2S, Vn+1.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64AndUnzip(int* address) => Load2xVector64AndUnzip(address); - /// - /// A64: LD2 { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: LD2 { Vn.2S, Vn+1.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64AndUnzip(uint* address) => Load2xVector64AndUnzip(address); - /// - /// A64: LD2 { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: LD2 { Vn.2S, Vn+1.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64AndUnzip(float* address) => Load2xVector64AndUnzip(address); - /// - /// A64: LD3 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] - /// + /// A64: LD3 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64AndUnzip(byte* address) => Load3xVector64AndUnzip(address); - /// - /// A64: LD3 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] - /// + /// A64: LD3 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64AndUnzip(sbyte* address) => Load3xVector64AndUnzip(address); - /// - /// A64: LD3 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] - /// + /// A64: LD3 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64AndUnzip(short* address) => Load3xVector64AndUnzip(address); - /// - /// A64: LD3 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] - /// + /// A64: LD3 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64AndUnzip(ushort* address) => Load3xVector64AndUnzip(address); - /// - /// A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64AndUnzip(int* address) => Load3xVector64AndUnzip(address); - /// - /// A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64AndUnzip(uint* address) => Load3xVector64AndUnzip(address); - /// - /// A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: LD3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64AndUnzip(float* address) => Load3xVector64AndUnzip(address); - /// - /// A64: LD4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] - /// + /// A64: LD4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64AndUnzip(byte* address) => Load4xVector64AndUnzip(address); - /// - /// A64: LD4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] - /// + /// A64: LD4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64AndUnzip(sbyte* address) => Load4xVector64AndUnzip(address); - /// - /// A64: LD4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] - /// + /// A64: LD4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64AndUnzip(short* address) => Load4xVector64AndUnzip(address); - /// - /// A64: LD4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] - /// + /// A64: LD4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64AndUnzip(ushort* address) => Load4xVector64AndUnzip(address); - /// - /// A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64AndUnzip(int* address) => Load4xVector64AndUnzip(address); - /// - /// A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: LD4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64AndUnzip(uint* address) => Load4xVector64AndUnzip(address); - /// - /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.2S }, [Xn] - /// + /// A64: LD4 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64AndUnzip(float* address) => Load4xVector64AndUnzip(address); - /// - /// A64: LD1 { Vn.8B, Vn+1.8B }, [Xn] - /// + /// A64: LD1 { Vn.8B, Vn+1.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64(byte* address) => Load2xVector64(address); - /// - /// A64: LD1 { Vn.8B, Vn+1.8B }, [Xn] - /// + /// A64: LD1 { Vn.8B, Vn+1.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64(sbyte* address) => Load2xVector64(address); - /// - /// A64: LD1 { Vn.4H, Vn+1.4H }, [Xn] - /// + /// A64: LD1 { Vn.4H, Vn+1.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64(short* address) => Load2xVector64(address); - /// - /// A64: LD1 { Vn.4H, Vn+1.4H }, [Xn] - /// + /// A64: LD1 { Vn.4H, Vn+1.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64(ushort* address) => Load2xVector64(address); - /// - /// A64: LD1 { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: LD1 { Vn.2S, Vn+1.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64(int* address) => Load2xVector64(address); - /// - /// A64: LD1 { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: LD1 { Vn.2S, Vn+1.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64(uint* address) => Load2xVector64(address); - /// - /// A64: LD1 { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: LD1 { Vn.2S, Vn+1.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2) Load2xVector64(float* address) => Load2xVector64(address); - /// - /// A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] - /// + /// A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64(byte* address) => Load3xVector64(address); - /// - /// A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] - /// + /// A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64(sbyte* address) => Load3xVector64(address); - /// - /// A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] - /// + /// A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64(short* address) => Load3xVector64(address); - /// - /// A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] - /// + /// A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64(ushort* address) => Load3xVector64(address); - /// - /// A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64(int* address) => Load3xVector64(address); - /// - /// A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64(uint* address) => Load3xVector64(address); - /// - /// A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) Load3xVector64(float* address) => Load3xVector64(address); - /// - /// A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] - /// + /// A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64(byte* address) => Load4xVector64(address); - /// - /// A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] - /// + /// A64: LD1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64(sbyte* address) => Load4xVector64(address); - /// - /// A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] - /// + /// A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64(short* address) => Load4xVector64(address); - /// - /// A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] - /// + /// A64: LD1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64(ushort* address) => Load4xVector64(address); - /// - /// A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64(int* address) => Load4xVector64(address); - /// - /// A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64(uint* address) => Load4xVector64(address); - /// - /// A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: LD1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) Load4xVector64(float* address) => Load4xVector64(address); /// - /// uint8x8_t vmax_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VMAX.U8 Dd, Dn, Dm - /// A64: UMAX Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vmax_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VMAX.U8 Dd, Dn, Dm + /// A64: UMAX Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Max(Vector64 left, Vector64 right) => Max(left, right); /// - /// int16x4_t vmax_s16 (int16x4_t a, int16x4_t b) - /// A32: VMAX.S16 Dd, Dn, Dm - /// A64: SMAX Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vmax_s16 (int16x4_t a, int16x4_t b) + /// A32: VMAX.S16 Dd, Dn, Dm + /// A64: SMAX Vd.4H, Vn.4H, Vm.4H /// public static Vector64 Max(Vector64 left, Vector64 right) => Max(left, right); /// - /// int32x2_t vmax_s32 (int32x2_t a, int32x2_t b) - /// A32: VMAX.S32 Dd, Dn, Dm - /// A64: SMAX Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vmax_s32 (int32x2_t a, int32x2_t b) + /// A32: VMAX.S32 Dd, Dn, Dm + /// A64: SMAX Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Max(Vector64 left, Vector64 right) => Max(left, right); /// - /// int8x8_t vmax_s8 (int8x8_t a, int8x8_t b) - /// A32: VMAX.S8 Dd, Dn, Dm - /// A64: SMAX Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vmax_s8 (int8x8_t a, int8x8_t b) + /// A32: VMAX.S8 Dd, Dn, Dm + /// A64: SMAX Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Max(Vector64 left, Vector64 right) => Max(left, right); /// - /// float32x2_t vmax_f32 (float32x2_t a, float32x2_t b) - /// A32: VMAX.F32 Dd, Dn, Dm - /// A64: FMAX Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vmax_f32 (float32x2_t a, float32x2_t b) + /// A32: VMAX.F32 Dd, Dn, Dm + /// A64: FMAX Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Max(Vector64 left, Vector64 right) => Max(left, right); /// - /// uint16x4_t vmax_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VMAX.U16 Dd, Dn, Dm - /// A64: UMAX Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vmax_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VMAX.U16 Dd, Dn, Dm + /// A64: UMAX Vd.4H, Vn.4H, Vm.4H /// public static Vector64 Max(Vector64 left, Vector64 right) => Max(left, right); /// - /// uint32x2_t vmax_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VMAX.U32 Dd, Dn, Dm - /// A64: UMAX Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vmax_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VMAX.U32 Dd, Dn, Dm + /// A64: UMAX Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Max(Vector64 left, Vector64 right) => Max(left, right); /// - /// uint8x16_t vmaxq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VMAX.U8 Qd, Qn, Qm - /// A64: UMAX Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vmaxq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VMAX.U8 Qd, Qn, Qm + /// A64: UMAX Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// - /// int16x8_t vmaxq_s16 (int16x8_t a, int16x8_t b) - /// A32: VMAX.S16 Qd, Qn, Qm - /// A64: SMAX Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vmaxq_s16 (int16x8_t a, int16x8_t b) + /// A32: VMAX.S16 Qd, Qn, Qm + /// A64: SMAX Vd.8H, Vn.8H, Vm.8H /// public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// - /// int32x4_t vmaxq_s32 (int32x4_t a, int32x4_t b) - /// A32: VMAX.S32 Qd, Qn, Qm - /// A64: SMAX Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vmaxq_s32 (int32x4_t a, int32x4_t b) + /// A32: VMAX.S32 Qd, Qn, Qm + /// A64: SMAX Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// - /// int8x16_t vmaxq_s8 (int8x16_t a, int8x16_t b) - /// A32: VMAX.S8 Qd, Qn, Qm - /// A64: SMAX Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vmaxq_s8 (int8x16_t a, int8x16_t b) + /// A32: VMAX.S8 Qd, Qn, Qm + /// A64: SMAX Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// - /// float32x4_t vmaxq_f32 (float32x4_t a, float32x4_t b) - /// A32: VMAX.F32 Qd, Qn, Qm - /// A64: FMAX Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vmaxq_f32 (float32x4_t a, float32x4_t b) + /// A32: VMAX.F32 Qd, Qn, Qm + /// A64: FMAX Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// - /// uint16x8_t vmaxq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VMAX.U16 Qd, Qn, Qm - /// A64: UMAX Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vmaxq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VMAX.U16 Qd, Qn, Qm + /// A64: UMAX Vd.8H, Vn.8H, Vm.8H /// public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// - /// uint32x4_t vmaxq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VMAX.U32 Qd, Qn, Qm - /// A64: UMAX Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vmaxq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VMAX.U32 Qd, Qn, Qm + /// A64: UMAX Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// - /// float32x2_t vmaxnm_f32 (float32x2_t a, float32x2_t b) - /// A32: VMAXNM.F32 Dd, Dn, Dm - /// A64: FMAXNM Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vmaxnm_f32 (float32x2_t a, float32x2_t b) + /// A32: VMAXNM.F32 Dd, Dn, Dm + /// A64: FMAXNM Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MaxNumber(Vector64 left, Vector64 right) => MaxNumber(left, right); /// - /// float32x4_t vmaxnmq_f32 (float32x4_t a, float32x4_t b) - /// A32: VMAXNM.F32 Qd, Qn, Qm - /// A64: FMAXNM Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vmaxnmq_f32 (float32x4_t a, float32x4_t b) + /// A32: VMAXNM.F32 Qd, Qn, Qm + /// A64: FMAXNM Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MaxNumber(Vector128 left, Vector128 right) => MaxNumber(left, right); /// - /// float64x1_t vmaxnm_f64 (float64x1_t a, float64x1_t b) - /// A32: VMAXNM.F64 Dd, Dn, Dm - /// A64: FMAXNM Dd, Dn, Dm + /// float64x1_t vmaxnm_f64 (float64x1_t a, float64x1_t b) + /// A32: VMAXNM.F64 Dd, Dn, Dm + /// A64: FMAXNM Dd, Dn, Dm /// public static Vector64 MaxNumberScalar(Vector64 left, Vector64 right) => MaxNumberScalar(left, right); /// - /// float32_t vmaxnms_f32 (float32_t a, float32_t b) - /// A32: VMAXNM.F32 Sd, Sn, Sm - /// A64: FMAXNM Sd, Sn, Sm + /// float32_t vmaxnms_f32 (float32_t a, float32_t b) + /// A32: VMAXNM.F32 Sd, Sn, Sm + /// A64: FMAXNM Sd, Sn, Sm /// public static Vector64 MaxNumberScalar(Vector64 left, Vector64 right) => MaxNumberScalar(left, right); /// - /// uint8x8_t vpmax_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VPMAX.U8 Dd, Dn, Dm - /// A64: UMAXP Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vpmax_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VPMAX.U8 Dd, Dn, Dm + /// A64: UMAXP Vd.8B, Vn.8B, Vm.8B /// public static Vector64 MaxPairwise(Vector64 left, Vector64 right) => MaxPairwise(left, right); /// - /// int16x4_t vpmax_s16 (int16x4_t a, int16x4_t b) - /// A32: VPMAX.S16 Dd, Dn, Dm - /// A64: SMAXP Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vpmax_s16 (int16x4_t a, int16x4_t b) + /// A32: VPMAX.S16 Dd, Dn, Dm + /// A64: SMAXP Vd.4H, Vn.4H, Vm.4H /// public static Vector64 MaxPairwise(Vector64 left, Vector64 right) => MaxPairwise(left, right); /// - /// int32x2_t vpmax_s32 (int32x2_t a, int32x2_t b) - /// A32: VPMAX.S32 Dd, Dn, Dm - /// A64: SMAXP Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vpmax_s32 (int32x2_t a, int32x2_t b) + /// A32: VPMAX.S32 Dd, Dn, Dm + /// A64: SMAXP Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MaxPairwise(Vector64 left, Vector64 right) => MaxPairwise(left, right); /// - /// int8x8_t vpmax_s8 (int8x8_t a, int8x8_t b) - /// A32: VPMAX.S8 Dd, Dn, Dm - /// A64: SMAXP Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vpmax_s8 (int8x8_t a, int8x8_t b) + /// A32: VPMAX.S8 Dd, Dn, Dm + /// A64: SMAXP Vd.8B, Vn.8B, Vm.8B /// public static Vector64 MaxPairwise(Vector64 left, Vector64 right) => MaxPairwise(left, right); /// - /// float32x2_t vpmax_f32 (float32x2_t a, float32x2_t b) - /// A32: VPMAX.F32 Dd, Dn, Dm - /// A64: FMAXP Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vpmax_f32 (float32x2_t a, float32x2_t b) + /// A32: VPMAX.F32 Dd, Dn, Dm + /// A64: FMAXP Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MaxPairwise(Vector64 left, Vector64 right) => MaxPairwise(left, right); /// - /// uint16x4_t vpmax_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VPMAX.U16 Dd, Dn, Dm - /// A64: UMAXP Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vpmax_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VPMAX.U16 Dd, Dn, Dm + /// A64: UMAXP Vd.4H, Vn.4H, Vm.4H /// public static Vector64 MaxPairwise(Vector64 left, Vector64 right) => MaxPairwise(left, right); /// - /// uint32x2_t vpmax_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VPMAX.U32 Dd, Dn, Dm - /// A64: UMAXP Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vpmax_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VPMAX.U32 Dd, Dn, Dm + /// A64: UMAXP Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MaxPairwise(Vector64 left, Vector64 right) => MaxPairwise(left, right); /// - /// uint8x8_t vmin_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VMIN.U8 Dd, Dn, Dm - /// A64: UMIN Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vmin_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VMIN.U8 Dd, Dn, Dm + /// A64: UMIN Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Min(Vector64 left, Vector64 right) => Min(left, right); /// - /// int16x4_t vmin_s16 (int16x4_t a, int16x4_t b) - /// A32: VMIN.S16 Dd, Dn, Dm - /// A64: SMIN Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vmin_s16 (int16x4_t a, int16x4_t b) + /// A32: VMIN.S16 Dd, Dn, Dm + /// A64: SMIN Vd.4H, Vn.4H, Vm.4H /// public static Vector64 Min(Vector64 left, Vector64 right) => Min(left, right); /// - /// int32x2_t vmin_s32 (int32x2_t a, int32x2_t b) - /// A32: VMIN.S32 Dd, Dn, Dm - /// A64: SMIN Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vmin_s32 (int32x2_t a, int32x2_t b) + /// A32: VMIN.S32 Dd, Dn, Dm + /// A64: SMIN Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Min(Vector64 left, Vector64 right) => Min(left, right); /// - /// int8x8_t vmin_s8 (int8x8_t a, int8x8_t b) - /// A32: VMIN.S8 Dd, Dn, Dm - /// A64: SMIN Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vmin_s8 (int8x8_t a, int8x8_t b) + /// A32: VMIN.S8 Dd, Dn, Dm + /// A64: SMIN Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Min(Vector64 left, Vector64 right) => Min(left, right); /// - /// float32x2_t vmin_f32 (float32x2_t a, float32x2_t b) - /// A32: VMIN.F32 Dd, Dn, Dm - /// A64: FMIN Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vmin_f32 (float32x2_t a, float32x2_t b) + /// A32: VMIN.F32 Dd, Dn, Dm + /// A64: FMIN Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Min(Vector64 left, Vector64 right) => Min(left, right); /// - /// uint16x4_t vmin_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VMIN.U16 Dd, Dn, Dm - /// A64: UMIN Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vmin_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VMIN.U16 Dd, Dn, Dm + /// A64: UMIN Vd.4H, Vn.4H, Vm.4H /// public static Vector64 Min(Vector64 left, Vector64 right) => Min(left, right); /// - /// uint32x2_t vmin_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VMIN.U32 Dd, Dn, Dm - /// A64: UMIN Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vmin_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VMIN.U32 Dd, Dn, Dm + /// A64: UMIN Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Min(Vector64 left, Vector64 right) => Min(left, right); /// - /// uint8x16_t vminq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VMIN.U8 Qd, Qn, Qm - /// A64: UMIN Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vminq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VMIN.U8 Qd, Qn, Qm + /// A64: UMIN Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// - /// int16x8_t vminq_s16 (int16x8_t a, int16x8_t b) - /// A32: VMIN.S16 Qd, Qn, Qm - /// A64: SMIN Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vminq_s16 (int16x8_t a, int16x8_t b) + /// A32: VMIN.S16 Qd, Qn, Qm + /// A64: SMIN Vd.8H, Vn.8H, Vm.8H /// public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// - /// int32x4_t vminq_s32 (int32x4_t a, int32x4_t b) - /// A32: VMIN.S32 Qd, Qn, Qm - /// A64: SMIN Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vminq_s32 (int32x4_t a, int32x4_t b) + /// A32: VMIN.S32 Qd, Qn, Qm + /// A64: SMIN Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// - /// int8x16_t vminq_s8 (int8x16_t a, int8x16_t b) - /// A32: VMIN.S8 Qd, Qn, Qm - /// A64: SMIN Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vminq_s8 (int8x16_t a, int8x16_t b) + /// A32: VMIN.S8 Qd, Qn, Qm + /// A64: SMIN Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// - /// float32x4_t vminq_f32 (float32x4_t a, float32x4_t b) - /// A32: VMIN.F32 Qd, Qn, Qm - /// A64: FMIN Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vminq_f32 (float32x4_t a, float32x4_t b) + /// A32: VMIN.F32 Qd, Qn, Qm + /// A64: FMIN Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// - /// uint16x8_t vminq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VMIN.U16 Qd, Qn, Qm - /// A64: UMIN Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vminq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VMIN.U16 Qd, Qn, Qm + /// A64: UMIN Vd.8H, Vn.8H, Vm.8H /// public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// - /// uint32x4_t vminq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VMIN.U32 Qd, Qn, Qm - /// A64: UMIN Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vminq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VMIN.U32 Qd, Qn, Qm + /// A64: UMIN Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// - /// float32x2_t vminnm_f32 (float32x2_t a, float32x2_t b) - /// A32: VMINNM.F32 Dd, Dn, Dm - /// A64: FMINNM Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vminnm_f32 (float32x2_t a, float32x2_t b) + /// A32: VMINNM.F32 Dd, Dn, Dm + /// A64: FMINNM Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MinNumber(Vector64 left, Vector64 right) => MinNumber(left, right); /// - /// float32x4_t vminnmq_f32 (float32x4_t a, float32x4_t b) - /// A32: VMINNM.F32 Qd, Qn, Qm - /// A64: FMINNM Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vminnmq_f32 (float32x4_t a, float32x4_t b) + /// A32: VMINNM.F32 Qd, Qn, Qm + /// A64: FMINNM Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MinNumber(Vector128 left, Vector128 right) => MinNumber(left, right); /// - /// float64x1_t vminnm_f64 (float64x1_t a, float64x1_t b) - /// A32: VMINNM.F64 Dd, Dn, Dm - /// A64: FMINNM Dd, Dn, Dm + /// float64x1_t vminnm_f64 (float64x1_t a, float64x1_t b) + /// A32: VMINNM.F64 Dd, Dn, Dm + /// A64: FMINNM Dd, Dn, Dm /// public static Vector64 MinNumberScalar(Vector64 left, Vector64 right) => MinNumberScalar(left, right); /// - /// float32_t vminnms_f32 (float32_t a, float32_t b) - /// A32: VMINNM.F32 Sd, Sn, Sm - /// A64: FMINNM Sd, Sn, Sm + /// float32_t vminnms_f32 (float32_t a, float32_t b) + /// A32: VMINNM.F32 Sd, Sn, Sm + /// A64: FMINNM Sd, Sn, Sm /// public static Vector64 MinNumberScalar(Vector64 left, Vector64 right) => MinNumberScalar(left, right); /// - /// uint8x8_t vpmin_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VPMIN.U8 Dd, Dn, Dm - /// A64: UMINP Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vpmin_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VPMIN.U8 Dd, Dn, Dm + /// A64: UMINP Vd.8B, Vn.8B, Vm.8B /// public static Vector64 MinPairwise(Vector64 left, Vector64 right) => MinPairwise(left, right); /// - /// int16x4_t vpmin_s16 (int16x4_t a, int16x4_t b) - /// A32: VPMIN.S16 Dd, Dn, Dm - /// A64: SMINP Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vpmin_s16 (int16x4_t a, int16x4_t b) + /// A32: VPMIN.S16 Dd, Dn, Dm + /// A64: SMINP Vd.4H, Vn.4H, Vm.4H /// public static Vector64 MinPairwise(Vector64 left, Vector64 right) => MinPairwise(left, right); /// - /// int32x2_t vpmin_s32 (int32x2_t a, int32x2_t b) - /// A32: VPMIN.S32 Dd, Dn, Dm - /// A64: SMINP Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vpmin_s32 (int32x2_t a, int32x2_t b) + /// A32: VPMIN.S32 Dd, Dn, Dm + /// A64: SMINP Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MinPairwise(Vector64 left, Vector64 right) => MinPairwise(left, right); /// - /// int8x8_t vpmin_s8 (int8x8_t a, int8x8_t b) - /// A32: VPMIN.S8 Dd, Dn, Dm - /// A64: SMINP Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vpmin_s8 (int8x8_t a, int8x8_t b) + /// A32: VPMIN.S8 Dd, Dn, Dm + /// A64: SMINP Vd.8B, Vn.8B, Vm.8B /// public static Vector64 MinPairwise(Vector64 left, Vector64 right) => MinPairwise(left, right); /// - /// float32x2_t vpmin_f32 (float32x2_t a, float32x2_t b) - /// A32: VPMIN.F32 Dd, Dn, Dm - /// A64: FMINP Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vpmin_f32 (float32x2_t a, float32x2_t b) + /// A32: VPMIN.F32 Dd, Dn, Dm + /// A64: FMINP Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MinPairwise(Vector64 left, Vector64 right) => MinPairwise(left, right); /// - /// uint16x4_t vpmin_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VPMIN.U16 Dd, Dn, Dm - /// A64: UMINP Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vpmin_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VPMIN.U16 Dd, Dn, Dm + /// A64: UMINP Vd.4H, Vn.4H, Vm.4H /// public static Vector64 MinPairwise(Vector64 left, Vector64 right) => MinPairwise(left, right); /// - /// uint32x2_t vpmin_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VPMIN.U32 Dd, Dn, Dm - /// A64: UMINP Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vpmin_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VPMIN.U32 Dd, Dn, Dm + /// A64: UMINP Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MinPairwise(Vector64 left, Vector64 right) => MinPairwise(left, right); /// - /// uint8x8_t vmul_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VMUL.I8 Dd, Dn, Dm - /// A64: MUL Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vmul_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VMUL.I8 Dd, Dn, Dm + /// A64: MUL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Multiply(Vector64 left, Vector64 right) => Multiply(left, right); /// - /// int16x4_t vmul_s16 (int16x4_t a, int16x4_t b) - /// A32: VMUL.I16 Dd, Dn, Dm - /// A64: MUL Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vmul_s16 (int16x4_t a, int16x4_t b) + /// A32: VMUL.I16 Dd, Dn, Dm + /// A64: MUL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 Multiply(Vector64 left, Vector64 right) => Multiply(left, right); /// - /// int32x2_t vmul_s32 (int32x2_t a, int32x2_t b) - /// A32: VMUL.I32 Dd, Dn, Dm - /// A64: MUL Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vmul_s32 (int32x2_t a, int32x2_t b) + /// A32: VMUL.I32 Dd, Dn, Dm + /// A64: MUL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Multiply(Vector64 left, Vector64 right) => Multiply(left, right); /// - /// int8x8_t vmul_s8 (int8x8_t a, int8x8_t b) - /// A32: VMUL.I8 Dd, Dn, Dm - /// A64: MUL Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vmul_s8 (int8x8_t a, int8x8_t b) + /// A32: VMUL.I8 Dd, Dn, Dm + /// A64: MUL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Multiply(Vector64 left, Vector64 right) => Multiply(left, right); /// - /// float32x2_t vmul_f32 (float32x2_t a, float32x2_t b) - /// A32: VMUL.F32 Dd, Dn, Dm - /// A64: FMUL Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vmul_f32 (float32x2_t a, float32x2_t b) + /// A32: VMUL.F32 Dd, Dn, Dm + /// A64: FMUL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Multiply(Vector64 left, Vector64 right) => Multiply(left, right); /// - /// uint16x4_t vmul_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VMUL.I16 Dd, Dn, Dm - /// A64: MUL Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vmul_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VMUL.I16 Dd, Dn, Dm + /// A64: MUL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 Multiply(Vector64 left, Vector64 right) => Multiply(left, right); /// - /// uint32x2_t vmul_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VMUL.I32 Dd, Dn, Dm - /// A64: MUL Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vmul_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VMUL.I32 Dd, Dn, Dm + /// A64: MUL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Multiply(Vector64 left, Vector64 right) => Multiply(left, right); /// - /// uint8x16_t vmulq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VMUL.I8 Qd, Qn, Qm - /// A64: MUL Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vmulq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VMUL.I8 Qd, Qn, Qm + /// A64: MUL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); /// - /// int16x8_t vmulq_s16 (int16x8_t a, int16x8_t b) - /// A32: VMUL.I16 Qd, Qn, Qm - /// A64: MUL Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vmulq_s16 (int16x8_t a, int16x8_t b) + /// A32: VMUL.I16 Qd, Qn, Qm + /// A64: MUL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); /// - /// int32x4_t vmulq_s32 (int32x4_t a, int32x4_t b) - /// A32: VMUL.I32 Qd, Qn, Qm - /// A64: MUL Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vmulq_s32 (int32x4_t a, int32x4_t b) + /// A32: VMUL.I32 Qd, Qn, Qm + /// A64: MUL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); /// - /// int8x16_t vmulq_s8 (int8x16_t a, int8x16_t b) - /// A32: VMUL.I8 Qd, Qn, Qm - /// A64: MUL Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vmulq_s8 (int8x16_t a, int8x16_t b) + /// A32: VMUL.I8 Qd, Qn, Qm + /// A64: MUL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); /// - /// float32x4_t vmulq_f32 (float32x4_t a, float32x4_t b) - /// A32: VMUL.F32 Qd, Qn, Qm - /// A64: FMUL Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vmulq_f32 (float32x4_t a, float32x4_t b) + /// A32: VMUL.F32 Qd, Qn, Qm + /// A64: FMUL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); /// - /// uint16x8_t vmulq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VMUL.I16 Qd, Qn, Qm - /// A64: MUL Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vmulq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VMUL.I16 Qd, Qn, Qm + /// A64: MUL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); /// - /// uint32x4_t vmulq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VMUL.I32 Qd, Qn, Qm - /// A64: MUL Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vmulq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VMUL.I32 Qd, Qn, Qm + /// A64: MUL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); /// - /// uint8x8_t vmla_u8 (uint8x8_t a, uint8x8_t b, uint8x8_t c) - /// A32: VMLA.I8 Dd, Dn, Dm - /// A64: MLA Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vmla_u8 (uint8x8_t a, uint8x8_t b, uint8x8_t c) + /// A32: VMLA.I8 Dd, Dn, Dm + /// A64: MLA Vd.8B, Vn.8B, Vm.8B /// public static Vector64 MultiplyAdd(Vector64 addend, Vector64 left, Vector64 right) => MultiplyAdd(addend, left, right); /// - /// int16x4_t vmla_s16 (int16x4_t a, int16x4_t b, int16x4_t c) - /// A32: VMLA.I16 Dd, Dn, Dm - /// A64: MLA Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vmla_s16 (int16x4_t a, int16x4_t b, int16x4_t c) + /// A32: VMLA.I16 Dd, Dn, Dm + /// A64: MLA Vd.4H, Vn.4H, Vm.4H /// public static Vector64 MultiplyAdd(Vector64 addend, Vector64 left, Vector64 right) => MultiplyAdd(addend, left, right); /// - /// int32x2_t vmla_s32 (int32x2_t a, int32x2_t b, int32x2_t c) - /// A32: VMLA.I32 Dd, Dn, Dm - /// A64: MLA Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vmla_s32 (int32x2_t a, int32x2_t b, int32x2_t c) + /// A32: VMLA.I32 Dd, Dn, Dm + /// A64: MLA Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MultiplyAdd(Vector64 addend, Vector64 left, Vector64 right) => MultiplyAdd(addend, left, right); /// - /// int8x8_t vmla_s8 (int8x8_t a, int8x8_t b, int8x8_t c) - /// A32: VMLA.I8 Dd, Dn, Dm - /// A64: MLA Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vmla_s8 (int8x8_t a, int8x8_t b, int8x8_t c) + /// A32: VMLA.I8 Dd, Dn, Dm + /// A64: MLA Vd.8B, Vn.8B, Vm.8B /// public static Vector64 MultiplyAdd(Vector64 addend, Vector64 left, Vector64 right) => MultiplyAdd(addend, left, right); /// - /// uint16x4_t vmla_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t c) - /// A32: VMLA.I16 Dd, Dn, Dm - /// A64: MLA Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vmla_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t c) + /// A32: VMLA.I16 Dd, Dn, Dm + /// A64: MLA Vd.4H, Vn.4H, Vm.4H /// public static Vector64 MultiplyAdd(Vector64 addend, Vector64 left, Vector64 right) => MultiplyAdd(addend, left, right); /// - /// uint32x2_t vmla_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t c) - /// A32: VMLA.I32 Dd, Dn, Dm - /// A64: MLA Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vmla_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t c) + /// A32: VMLA.I32 Dd, Dn, Dm + /// A64: MLA Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MultiplyAdd(Vector64 addend, Vector64 left, Vector64 right) => MultiplyAdd(addend, left, right); /// - /// uint8x16_t vmlaq_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c) - /// A32: VMLA.I8 Qd, Qn, Qm - /// A64: MLA Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vmlaq_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c) + /// A32: VMLA.I8 Qd, Qn, Qm + /// A64: MLA Vd.16B, Vn.16B, Vm.16B /// public static Vector128 MultiplyAdd(Vector128 addend, Vector128 left, Vector128 right) => MultiplyAdd(addend, left, right); /// - /// int16x8_t vmlaq_s16 (int16x8_t a, int16x8_t b, int16x8_t c) - /// A32: VMLA.I16 Qd, Qn, Qm - /// A64: MLA Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vmlaq_s16 (int16x8_t a, int16x8_t b, int16x8_t c) + /// A32: VMLA.I16 Qd, Qn, Qm + /// A64: MLA Vd.8H, Vn.8H, Vm.8H /// public static Vector128 MultiplyAdd(Vector128 addend, Vector128 left, Vector128 right) => MultiplyAdd(addend, left, right); /// - /// int32x4_t vmlaq_s32 (int32x4_t a, int32x4_t b, int32x4_t c) - /// A32: VMLA.I32 Qd, Qn, Qm - /// A64: MLA Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vmlaq_s32 (int32x4_t a, int32x4_t b, int32x4_t c) + /// A32: VMLA.I32 Qd, Qn, Qm + /// A64: MLA Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MultiplyAdd(Vector128 addend, Vector128 left, Vector128 right) => MultiplyAdd(addend, left, right); /// - /// int8x16_t vmlaq_s8 (int8x16_t a, int8x16_t b, int8x16_t c) - /// A32: VMLA.I8 Qd, Qn, Qm - /// A64: MLA Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vmlaq_s8 (int8x16_t a, int8x16_t b, int8x16_t c) + /// A32: VMLA.I8 Qd, Qn, Qm + /// A64: MLA Vd.16B, Vn.16B, Vm.16B /// public static Vector128 MultiplyAdd(Vector128 addend, Vector128 left, Vector128 right) => MultiplyAdd(addend, left, right); /// - /// uint16x8_t vmlaq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c) - /// A32: VMLA.I16 Qd, Qn, Qm - /// A64: MLA Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vmlaq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c) + /// A32: VMLA.I16 Qd, Qn, Qm + /// A64: MLA Vd.8H, Vn.8H, Vm.8H /// public static Vector128 MultiplyAdd(Vector128 addend, Vector128 left, Vector128 right) => MultiplyAdd(addend, left, right); /// - /// uint32x4_t vmlaq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c) - /// A32: VMLA.I32 Qd, Qn, Qm - /// A64: MLA Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vmlaq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c) + /// A32: VMLA.I32 Qd, Qn, Qm + /// A64: MLA Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MultiplyAdd(Vector128 addend, Vector128 left, Vector128 right) => MultiplyAdd(addend, left, right); /// - /// int16x4_t vmla_n_s16 (int16x4_t a, int16x4_t b, int16_t c) - /// A32: VMLA.I16 Dd, Dn, Dm[0] - /// A64: MLA Vd.4H, Vn.4H, Vm.H[0] + /// int16x4_t vmla_n_s16 (int16x4_t a, int16x4_t b, int16_t c) + /// A32: VMLA.I16 Dd, Dn, Dm[0] + /// A64: MLA Vd.4H, Vn.4H, Vm.H[0] /// public static Vector64 MultiplyAddByScalar(Vector64 addend, Vector64 left, Vector64 right) => MultiplyAddByScalar(addend, left, right); /// - /// int32x2_t vmla_n_s32 (int32x2_t a, int32x2_t b, int32_t c) - /// A32: VMLA.I32 Dd, Dn, Dm[0] - /// A64: MLA Vd.2S, Vn.2S, Vm.S[0] + /// int32x2_t vmla_n_s32 (int32x2_t a, int32x2_t b, int32_t c) + /// A32: VMLA.I32 Dd, Dn, Dm[0] + /// A64: MLA Vd.2S, Vn.2S, Vm.S[0] /// public static Vector64 MultiplyAddByScalar(Vector64 addend, Vector64 left, Vector64 right) => MultiplyAddByScalar(addend, left, right); /// - /// uint16x4_t vmla_n_u16 (uint16x4_t a, uint16x4_t b, uint16_t c) - /// A32: VMLA.I16 Dd, Dn, Dm[0] - /// A64: MLA Vd.4H, Vn.4H, Vm.H[0] + /// uint16x4_t vmla_n_u16 (uint16x4_t a, uint16x4_t b, uint16_t c) + /// A32: VMLA.I16 Dd, Dn, Dm[0] + /// A64: MLA Vd.4H, Vn.4H, Vm.H[0] /// public static Vector64 MultiplyAddByScalar(Vector64 addend, Vector64 left, Vector64 right) => MultiplyAddByScalar(addend, left, right); /// - /// uint32x2_t vmla_n_u32 (uint32x2_t a, uint32x2_t b, uint32_t c) - /// A32: VMLA.I32 Dd, Dn, Dm[0] - /// A64: MLA Vd.2S, Vn.2S, Vm.S[0] + /// uint32x2_t vmla_n_u32 (uint32x2_t a, uint32x2_t b, uint32_t c) + /// A32: VMLA.I32 Dd, Dn, Dm[0] + /// A64: MLA Vd.2S, Vn.2S, Vm.S[0] /// public static Vector64 MultiplyAddByScalar(Vector64 addend, Vector64 left, Vector64 right) => MultiplyAddByScalar(addend, left, right); /// - /// int16x8_t vmlaq_n_s16 (int16x8_t a, int16x8_t b, int16_t c) - /// A32: VMLA.I16 Qd, Qn, Dm[0] - /// A64: MLA Vd.8H, Vn.8H, Vm.H[0] + /// int16x8_t vmlaq_n_s16 (int16x8_t a, int16x8_t b, int16_t c) + /// A32: VMLA.I16 Qd, Qn, Dm[0] + /// A64: MLA Vd.8H, Vn.8H, Vm.H[0] /// public static Vector128 MultiplyAddByScalar(Vector128 addend, Vector128 left, Vector64 right) => MultiplyAddByScalar(addend, left, right); /// - /// int32x4_t vmlaq_n_s32 (int32x4_t a, int32x4_t b, int32_t c) - /// A32: VMLA.I32 Qd, Qn, Dm[0] - /// A64: MLA Vd.4S, Vn.4S, Vm.S[0] + /// int32x4_t vmlaq_n_s32 (int32x4_t a, int32x4_t b, int32_t c) + /// A32: VMLA.I32 Qd, Qn, Dm[0] + /// A64: MLA Vd.4S, Vn.4S, Vm.S[0] /// public static Vector128 MultiplyAddByScalar(Vector128 addend, Vector128 left, Vector64 right) => MultiplyAddByScalar(addend, left, right); /// - /// uint16x8_t vmlaq_n_u16 (uint16x8_t a, uint16x8_t b, uint16_t c) - /// A32: VMLA.I16 Qd, Qn, Dm[0] - /// A64: MLA Vd.8H, Vn.8H, Vm.H[0] + /// uint16x8_t vmlaq_n_u16 (uint16x8_t a, uint16x8_t b, uint16_t c) + /// A32: VMLA.I16 Qd, Qn, Dm[0] + /// A64: MLA Vd.8H, Vn.8H, Vm.H[0] /// public static Vector128 MultiplyAddByScalar(Vector128 addend, Vector128 left, Vector64 right) => MultiplyAddByScalar(addend, left, right); /// - /// uint32x4_t vmlaq_n_u32 (uint32x4_t a, uint32x4_t b, uint32_t c) - /// A32: VMLA.I32 Qd, Qn, Dm[0] - /// A64: MLA Vd.4S, Vn.4S, Vm.S[0] + /// uint32x4_t vmlaq_n_u32 (uint32x4_t a, uint32x4_t b, uint32_t c) + /// A32: VMLA.I32 Qd, Qn, Dm[0] + /// A64: MLA Vd.4S, Vn.4S, Vm.S[0] /// public static Vector128 MultiplyAddByScalar(Vector128 addend, Vector128 left, Vector64 right) => MultiplyAddByScalar(addend, left, right); /// - /// int16x4_t vmla_lane_s16 (int16x4_t a, int16x4_t b, int16x4_t v, const int lane) - /// A32: VMLA.I16 Dd, Dn, Dm[lane] - /// A64: MLA Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vmla_lane_s16 (int16x4_t a, int16x4_t b, int16x4_t v, const int lane) + /// A32: VMLA.I16 Dd, Dn, Dm[lane] + /// A64: MLA Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyAddBySelectedScalar(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex); /// - /// int16x4_t vmla_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane) - /// A32: VMLA.I16 Dd, Dn, Dm[lane] - /// A64: MLA Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vmla_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane) + /// A32: VMLA.I16 Dd, Dn, Dm[lane] + /// A64: MLA Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyAddBySelectedScalar(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex); /// - /// int32x2_t vmla_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane) - /// A32: VMLA.I32 Dd, Dn, Dm[lane] - /// A64: MLA Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vmla_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane) + /// A32: VMLA.I32 Dd, Dn, Dm[lane] + /// A64: MLA Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyAddBySelectedScalar(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex); /// - /// int32x2_t vmla_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane) - /// A32: VMLA.I32 Dd, Dn, Dm[lane] - /// A64: MLA Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vmla_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane) + /// A32: VMLA.I32 Dd, Dn, Dm[lane] + /// A64: MLA Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyAddBySelectedScalar(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex); /// - /// uint16x4_t vmla_lane_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t v, const int lane) - /// A32: VMLA.I16 Dd, Dn, Dm[lane] - /// A64: MLA Vd.4H, Vn.4H, Vm.H[lane] + /// uint16x4_t vmla_lane_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t v, const int lane) + /// A32: VMLA.I16 Dd, Dn, Dm[lane] + /// A64: MLA Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyAddBySelectedScalar(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex); /// - /// uint16x4_t vmla_laneq_u16 (uint16x4_t a, uint16x4_t b, uint16x8_t v, const int lane) - /// A32: VMLA.I16 Dd, Dn, Dm[lane] - /// A64: MLA Vd.4H, Vn.4H, Vm.H[lane] + /// uint16x4_t vmla_laneq_u16 (uint16x4_t a, uint16x4_t b, uint16x8_t v, const int lane) + /// A32: VMLA.I16 Dd, Dn, Dm[lane] + /// A64: MLA Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyAddBySelectedScalar(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex); /// - /// uint32x2_t vmla_lane_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t v, const int lane) - /// A32: VMLA.I32 Dd, Dn, Dm[lane] - /// A64: MLA Vd.2S, Vn.2S, Vm.S[lane] + /// uint32x2_t vmla_lane_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t v, const int lane) + /// A32: VMLA.I32 Dd, Dn, Dm[lane] + /// A64: MLA Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyAddBySelectedScalar(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex); /// - /// uint32x2_t vmla_laneq_u32 (uint32x2_t a, uint32x2_t b, uint32x4_t v, const int lane) - /// A32: VMLA.I32 Dd, Dn, Dm[lane] - /// A64: MLA Vd.2S, Vn.2S, Vm.S[lane] + /// uint32x2_t vmla_laneq_u32 (uint32x2_t a, uint32x2_t b, uint32x4_t v, const int lane) + /// A32: VMLA.I32 Dd, Dn, Dm[lane] + /// A64: MLA Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyAddBySelectedScalar(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex); /// - /// int16x8_t vmlaq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane) - /// A32: VMLA.I16 Qd, Qn, Dm[lane] - /// A64: MLA Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vmlaq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane) + /// A32: VMLA.I16 Qd, Qn, Dm[lane] + /// A64: MLA Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex); /// - /// int16x8_t vmlaq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane) - /// A32: VMLA.I16 Qd, Qn, Dm[lane] - /// A64: MLA Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vmlaq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane) + /// A32: VMLA.I16 Qd, Qn, Dm[lane] + /// A64: MLA Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex); /// - /// int32x4_t vmlaq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane) - /// A32: VMLA.I32 Qd, Qn, Dm[lane] - /// A64: MLA Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vmlaq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane) + /// A32: VMLA.I32 Qd, Qn, Dm[lane] + /// A64: MLA Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex); /// - /// int32x4_t vmlaq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane) - /// A32: VMLA.I32 Qd, Qn, Dm[lane] - /// A64: MLA Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vmlaq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane) + /// A32: VMLA.I32 Qd, Qn, Dm[lane] + /// A64: MLA Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex); /// - /// uint16x8_t vmlaq_lane_u16 (uint16x8_t a, uint16x8_t b, uint16x4_t v, const int lane) - /// A32: VMLA.I16 Qd, Qn, Dm[lane] - /// A64: MLA Vd.8H, Vn.8H, Vm.H[lane] + /// uint16x8_t vmlaq_lane_u16 (uint16x8_t a, uint16x8_t b, uint16x4_t v, const int lane) + /// A32: VMLA.I16 Qd, Qn, Dm[lane] + /// A64: MLA Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex); /// - /// uint16x8_t vmlaq_laneq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t v, const int lane) - /// A32: VMLA.I16 Qd, Qn, Dm[lane] - /// A64: MLA Vd.8H, Vn.8H, Vm.H[lane] + /// uint16x8_t vmlaq_laneq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t v, const int lane) + /// A32: VMLA.I16 Qd, Qn, Dm[lane] + /// A64: MLA Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex); /// - /// uint32x4_t vmlaq_lane_u32 (uint32x4_t a, uint32x4_t b, uint32x2_t v, const int lane) - /// A32: VMLA.I32 Qd, Qn, Dm[lane] - /// A64: MLA Vd.4S, Vn.4S, Vm.S[lane] + /// uint32x4_t vmlaq_lane_u32 (uint32x4_t a, uint32x4_t b, uint32x2_t v, const int lane) + /// A32: VMLA.I32 Qd, Qn, Dm[lane] + /// A64: MLA Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex); /// - /// uint32x4_t vmlaq_laneq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t v, const int lane) - /// A32: VMLA.I32 Qd, Qn, Dm[lane] - /// A64: MLA Vd.4S, Vn.4S, Vm.S[lane] + /// uint32x4_t vmlaq_laneq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t v, const int lane) + /// A32: VMLA.I32 Qd, Qn, Dm[lane] + /// A64: MLA Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyAddBySelectedScalar(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyAddBySelectedScalar(addend, left, right, rightIndex); /// - /// int16x4_t vmul_n_s16 (int16x4_t a, int16_t b) - /// A32: VMUL.I16 Dd, Dn, Dm[0] - /// A64: MUL Vd.4H, Vn.4H, Vm.H[0] + /// int16x4_t vmul_n_s16 (int16x4_t a, int16_t b) + /// A32: VMUL.I16 Dd, Dn, Dm[0] + /// A64: MUL Vd.4H, Vn.4H, Vm.H[0] /// public static Vector64 MultiplyByScalar(Vector64 left, Vector64 right) => MultiplyByScalar(left, right); /// - /// int32x2_t vmul_n_s32 (int32x2_t a, int32_t b) - /// A32: VMUL.I32 Dd, Dn, Dm[0] - /// A64: MUL Vd.2S, Vn.2S, Vm.S[0] + /// int32x2_t vmul_n_s32 (int32x2_t a, int32_t b) + /// A32: VMUL.I32 Dd, Dn, Dm[0] + /// A64: MUL Vd.2S, Vn.2S, Vm.S[0] /// public static Vector64 MultiplyByScalar(Vector64 left, Vector64 right) => MultiplyByScalar(left, right); /// - /// float32x2_t vmul_n_f32 (float32x2_t a, float32_t b) - /// A32: VMUL.F32 Dd, Dn, Dm[0] - /// A64: FMUL Vd.2S, Vn.2S, Vm.S[0] + /// float32x2_t vmul_n_f32 (float32x2_t a, float32_t b) + /// A32: VMUL.F32 Dd, Dn, Dm[0] + /// A64: FMUL Vd.2S, Vn.2S, Vm.S[0] /// public static Vector64 MultiplyByScalar(Vector64 left, Vector64 right) => MultiplyByScalar(left, right); /// - /// uint16x4_t vmul_n_u16 (uint16x4_t a, uint16_t b) - /// A32: VMUL.I16 Dd, Dn, Dm[0] - /// A64: MUL Vd.4H, Vn.4H, Vm.H[0] + /// uint16x4_t vmul_n_u16 (uint16x4_t a, uint16_t b) + /// A32: VMUL.I16 Dd, Dn, Dm[0] + /// A64: MUL Vd.4H, Vn.4H, Vm.H[0] /// public static Vector64 MultiplyByScalar(Vector64 left, Vector64 right) => MultiplyByScalar(left, right); /// - /// uint32x2_t vmul_n_u32 (uint32x2_t a, uint32_t b) - /// A32: VMUL.I32 Dd, Dn, Dm[0] - /// A64: MUL Vd.2S, Vn.2S, Vm.S[0] + /// uint32x2_t vmul_n_u32 (uint32x2_t a, uint32_t b) + /// A32: VMUL.I32 Dd, Dn, Dm[0] + /// A64: MUL Vd.2S, Vn.2S, Vm.S[0] /// public static Vector64 MultiplyByScalar(Vector64 left, Vector64 right) => MultiplyByScalar(left, right); /// - /// int16x8_t vmulq_n_s16 (int16x8_t a, int16_t b) - /// A32: VMUL.I16 Qd, Qn, Dm[0] - /// A64: MUL Vd.8H, Vn.8H, Vm.H[0] + /// int16x8_t vmulq_n_s16 (int16x8_t a, int16_t b) + /// A32: VMUL.I16 Qd, Qn, Dm[0] + /// A64: MUL Vd.8H, Vn.8H, Vm.H[0] /// public static Vector128 MultiplyByScalar(Vector128 left, Vector64 right) => MultiplyByScalar(left, right); /// - /// int32x4_t vmulq_n_s32 (int32x4_t a, int32_t b) - /// A32: VMUL.I32 Qd, Qn, Dm[0] - /// A64: MUL Vd.4S, Vn.4S, Vm.S[0] + /// int32x4_t vmulq_n_s32 (int32x4_t a, int32_t b) + /// A32: VMUL.I32 Qd, Qn, Dm[0] + /// A64: MUL Vd.4S, Vn.4S, Vm.S[0] /// public static Vector128 MultiplyByScalar(Vector128 left, Vector64 right) => MultiplyByScalar(left, right); /// - /// float32x4_t vmulq_n_f32 (float32x4_t a, float32_t b) - /// A32: VMUL.F32 Qd, Qn, Dm[0] - /// A64: FMUL Vd.4S, Vn.4S, Vm.S[0] + /// float32x4_t vmulq_n_f32 (float32x4_t a, float32_t b) + /// A32: VMUL.F32 Qd, Qn, Dm[0] + /// A64: FMUL Vd.4S, Vn.4S, Vm.S[0] /// public static Vector128 MultiplyByScalar(Vector128 left, Vector64 right) => MultiplyByScalar(left, right); /// - /// uint16x8_t vmulq_n_u16 (uint16x8_t a, uint16_t b) - /// A32: VMUL.I16 Qd, Qn, Dm[0] - /// A64: MUL Vd.8H, Vn.8H, Vm.H[0] + /// uint16x8_t vmulq_n_u16 (uint16x8_t a, uint16_t b) + /// A32: VMUL.I16 Qd, Qn, Dm[0] + /// A64: MUL Vd.8H, Vn.8H, Vm.H[0] /// public static Vector128 MultiplyByScalar(Vector128 left, Vector64 right) => MultiplyByScalar(left, right); /// - /// uint32x4_t vmulq_n_u32 (uint32x4_t a, uint32_t b) - /// A32: VMUL.I32 Qd, Qn, Dm[0] - /// A64: MUL Vd.4S, Vn.4S, Vm.S[0] + /// uint32x4_t vmulq_n_u32 (uint32x4_t a, uint32_t b) + /// A32: VMUL.I32 Qd, Qn, Dm[0] + /// A64: MUL Vd.4S, Vn.4S, Vm.S[0] /// public static Vector128 MultiplyByScalar(Vector128 left, Vector64 right) => MultiplyByScalar(left, right); /// - /// int16x4_t vmul_lane_s16 (int16x4_t a, int16x4_t v, const int lane) - /// A32: VMUL.I16 Dd, Dn, Dm[lane] - /// A64: MUL Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vmul_lane_s16 (int16x4_t a, int16x4_t v, const int lane) + /// A32: VMUL.I16 Dd, Dn, Dm[lane] + /// A64: MUL Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyBySelectedScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); /// - /// int16x4_t vmul_laneq_s16 (int16x4_t a, int16x8_t v, const int lane) - /// A32: VMUL.I16 Dd, Dn, Dm[lane] - /// A64: MUL Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vmul_laneq_s16 (int16x4_t a, int16x8_t v, const int lane) + /// A32: VMUL.I16 Dd, Dn, Dm[lane] + /// A64: MUL Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); /// - /// int32x2_t vmul_lane_s32 (int32x2_t a, int32x2_t v, const int lane) - /// A32: VMUL.I32 Dd, Dn, Dm[lane] - /// A64: MUL Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vmul_lane_s32 (int32x2_t a, int32x2_t v, const int lane) + /// A32: VMUL.I32 Dd, Dn, Dm[lane] + /// A64: MUL Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyBySelectedScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); /// - /// int32x2_t vmul_laneq_s32 (int32x2_t a, int32x4_t v, const int lane) - /// A32: VMUL.I32 Dd, Dn, Dm[lane] - /// A64: MUL Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vmul_laneq_s32 (int32x2_t a, int32x4_t v, const int lane) + /// A32: VMUL.I32 Dd, Dn, Dm[lane] + /// A64: MUL Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); /// - /// float32x2_t vmul_lane_f32 (float32x2_t a, float32x2_t v, const int lane) - /// A32: VMUL.F32 Dd, Dn, Dm[lane] - /// A64: FMUL Vd.2S, Vn.2S, Vm.S[lane] + /// float32x2_t vmul_lane_f32 (float32x2_t a, float32x2_t v, const int lane) + /// A32: VMUL.F32 Dd, Dn, Dm[lane] + /// A64: FMUL Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyBySelectedScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); /// - /// float32x2_t vmul_laneq_f32 (float32x2_t a, float32x4_t v, const int lane) - /// A32: VMUL.F32 Dd, Dn, Dm[lane] - /// A64: FMUL Vd.2S, Vn.2S, Vm.S[lane] + /// float32x2_t vmul_laneq_f32 (float32x2_t a, float32x4_t v, const int lane) + /// A32: VMUL.F32 Dd, Dn, Dm[lane] + /// A64: FMUL Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); /// - /// uint16x4_t vmul_lane_u16 (uint16x4_t a, uint16x4_t v, const int lane) - /// A32: VMUL.I16 Dd, Dn, Dm[lane] - /// A64: MUL Vd.4H, Vn.4H, Vm.H[lane] + /// uint16x4_t vmul_lane_u16 (uint16x4_t a, uint16x4_t v, const int lane) + /// A32: VMUL.I16 Dd, Dn, Dm[lane] + /// A64: MUL Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyBySelectedScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); /// - /// uint16x4_t vmul_laneq_u16 (uint16x4_t a, uint16x8_t v, const int lane) - /// A32: VMUL.I16 Dd, Dn, Dm[lane] - /// A64: MUL Vd.4H, Vn.4H, Vm.H[lane] + /// uint16x4_t vmul_laneq_u16 (uint16x4_t a, uint16x8_t v, const int lane) + /// A32: VMUL.I16 Dd, Dn, Dm[lane] + /// A64: MUL Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); /// - /// uint32x2_t vmul_lane_u32 (uint32x2_t a, uint32x2_t v, const int lane) - /// A32: VMUL.I32 Dd, Dn, Dm[lane] - /// A64: MUL Vd.2S, Vn.2S, Vm.S[lane] + /// uint32x2_t vmul_lane_u32 (uint32x2_t a, uint32x2_t v, const int lane) + /// A32: VMUL.I32 Dd, Dn, Dm[lane] + /// A64: MUL Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyBySelectedScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); /// - /// uint32x2_t vmul_laneq_u32 (uint32x2_t a, uint32x4_t v, const int lane) - /// A32: VMUL.I32 Dd, Dn, Dm[lane] - /// A64: MUL Vd.2S, Vn.2S, Vm.S[lane] + /// uint32x2_t vmul_laneq_u32 (uint32x2_t a, uint32x4_t v, const int lane) + /// A32: VMUL.I32 Dd, Dn, Dm[lane] + /// A64: MUL Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); /// - /// int16x8_t vmulq_lane_s16 (int16x8_t a, int16x4_t v, const int lane) - /// A32: VMUL.I16 Qd, Qn, Dm[lane] - /// A64: MUL Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vmulq_lane_s16 (int16x8_t a, int16x4_t v, const int lane) + /// A32: VMUL.I16 Qd, Qn, Dm[lane] + /// A64: MUL Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalar(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); /// - /// int16x8_t vmulq_laneq_s16 (int16x8_t a, int16x8_t v, const int lane) - /// A32: VMUL.I16 Qd, Qn, Dm[lane] - /// A64: MUL Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vmulq_laneq_s16 (int16x8_t a, int16x8_t v, const int lane) + /// A32: VMUL.I16 Qd, Qn, Dm[lane] + /// A64: MUL Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); /// - /// int32x4_t vmulq_lane_s32 (int32x4_t a, int32x2_t v, const int lane) - /// A32: VMUL.I32 Qd, Qn, Dm[lane] - /// A64: MUL Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vmulq_lane_s32 (int32x4_t a, int32x2_t v, const int lane) + /// A32: VMUL.I32 Qd, Qn, Dm[lane] + /// A64: MUL Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalar(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); /// - /// int32x4_t vmulq_laneq_s32 (int32x4_t a, int32x4_t v, const int lane) - /// A32: VMUL.I32 Qd, Qn, Dm[lane] - /// A64: MUL Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vmulq_laneq_s32 (int32x4_t a, int32x4_t v, const int lane) + /// A32: VMUL.I32 Qd, Qn, Dm[lane] + /// A64: MUL Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); /// - /// float32x4_t vmulq_lane_f32 (float32x4_t a, float32x2_t v, const int lane) - /// A32: VMUL.F32 Qd, Qn, Dm[lane] - /// A64: FMUL Vd.4S, Vn.4S, Vm.S[lane] + /// float32x4_t vmulq_lane_f32 (float32x4_t a, float32x2_t v, const int lane) + /// A32: VMUL.F32 Qd, Qn, Dm[lane] + /// A64: FMUL Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalar(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); /// - /// float32x4_t vmulq_laneq_f32 (float32x4_t a, float32x4_t v, const int lane) - /// A32: VMUL.F32 Qd, Qn, Dm[lane] - /// A64: FMUL Vd.4S, Vn.4S, Vm.S[lane] + /// float32x4_t vmulq_laneq_f32 (float32x4_t a, float32x4_t v, const int lane) + /// A32: VMUL.F32 Qd, Qn, Dm[lane] + /// A64: FMUL Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); /// - /// uint16x8_t vmulq_lane_u16 (uint16x8_t a, uint16x4_t v, const int lane) - /// A32: VMUL.I16 Qd, Qn, Dm[lane] - /// A64: MUL Vd.8H, Vn.8H, Vm.H[lane] + /// uint16x8_t vmulq_lane_u16 (uint16x8_t a, uint16x4_t v, const int lane) + /// A32: VMUL.I16 Qd, Qn, Dm[lane] + /// A64: MUL Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalar(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); /// - /// uint16x8_t vmulq_laneq_u16 (uint16x8_t a, uint16x8_t v, const int lane) - /// A32: VMUL.I16 Qd, Qn, Dm[lane] - /// A64: MUL Vd.8H, Vn.8H, Vm.H[lane] + /// uint16x8_t vmulq_laneq_u16 (uint16x8_t a, uint16x8_t v, const int lane) + /// A32: VMUL.I16 Qd, Qn, Dm[lane] + /// A64: MUL Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); /// - /// uint32x4_t vmulq_lane_u32 (uint32x4_t a, uint32x2_t v, const int lane) - /// A32: VMUL.I32 Qd, Qn, Dm[lane] - /// A64: MUL Vd.4S, Vn.4S, Vm.S[lane] + /// uint32x4_t vmulq_lane_u32 (uint32x4_t a, uint32x2_t v, const int lane) + /// A32: VMUL.I32 Qd, Qn, Dm[lane] + /// A64: MUL Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalar(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); /// - /// uint32x4_t vmulq_laneq_u32 (uint32x4_t a, uint32x4_t v, const int lane) - /// A32: VMUL.I32 Qd, Qn, Dm[lane] - /// A64: MUL Vd.4S, Vn.4S, Vm.S[lane] + /// uint32x4_t vmulq_laneq_u32 (uint32x4_t a, uint32x4_t v, const int lane) + /// A32: VMUL.I32 Qd, Qn, Dm[lane] + /// A64: MUL Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); /// - /// int32x4_t vmull_lane_s16 (int16x4_t a, int16x4_t v, const int lane) - /// A32: VMULL.S16 Qd, Dn, Dm[lane] - /// A64: SMULL Vd.4S, Vn.4H, Vm.H[lane] + /// int32x4_t vmull_lane_s16 (int16x4_t a, int16x4_t v, const int lane) + /// A32: VMULL.S16 Qd, Dn, Dm[lane] + /// A64: SMULL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLower(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningLower(left, right, rightIndex); /// - /// int32x4_t vmull_laneq_s16 (int16x4_t a, int16x8_t v, const int lane) - /// A32: VMULL.S16 Qd, Dn, Dm[lane] - /// A64: SMULL Vd.4S, Vn.4H, Vm.H[lane] + /// int32x4_t vmull_laneq_s16 (int16x4_t a, int16x8_t v, const int lane) + /// A32: VMULL.S16 Qd, Dn, Dm[lane] + /// A64: SMULL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLower(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalarWideningLower(left, right, rightIndex); /// - /// int64x2_t vmull_lane_s32 (int32x2_t a, int32x2_t v, const int lane) - /// A32: VMULL.S32 Qd, Dn, Dm[lane] - /// A64: SMULL Vd.2D, Vn.2S, Vm.S[lane] + /// int64x2_t vmull_lane_s32 (int32x2_t a, int32x2_t v, const int lane) + /// A32: VMULL.S32 Qd, Dn, Dm[lane] + /// A64: SMULL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLower(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalarWideningLower(left, right, rightIndex); /// - /// int64x2_t vmull_laneq_s32 (int32x2_t a, int32x4_t v, const int lane) - /// A32: VMULL.S32 Qd, Dn, Dm[lane] - /// A64: SMULL Vd.2D, Vn.2S, Vm.S[lane] + /// int64x2_t vmull_laneq_s32 (int32x2_t a, int32x4_t v, const int lane) + /// A32: VMULL.S32 Qd, Dn, Dm[lane] + /// A64: SMULL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLower(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningLower(left, right, rightIndex); /// - /// uint32x4_t vmull_lane_u16 (uint16x4_t a, uint16x4_t v, const int lane) - /// A32: VMULL.U16 Qd, Dn, Dm[lane] - /// A64: UMULL Vd.4S, Vn.4H, Vm.H[lane] + /// uint32x4_t vmull_lane_u16 (uint16x4_t a, uint16x4_t v, const int lane) + /// A32: VMULL.U16 Qd, Dn, Dm[lane] + /// A64: UMULL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLower(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningLower(left, right, rightIndex); /// - /// uint32x4_t vmull_laneq_u16 (uint16x4_t a, uint16x8_t v, const int lane) - /// A32: VMULL.U16 Qd, Dn, Dm[lane] - /// A64: UMULL Vd.4S, Vn.4H, Vm.H[lane] + /// uint32x4_t vmull_laneq_u16 (uint16x4_t a, uint16x8_t v, const int lane) + /// A32: VMULL.U16 Qd, Dn, Dm[lane] + /// A64: UMULL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLower(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalarWideningLower(left, right, rightIndex); /// - /// uint64x2_t vmull_lane_u32 (uint32x2_t a, uint32x2_t v, const int lane) - /// A32: VMULL.U32 Qd, Dn, Dm[lane] - /// A64: UMULL Vd.2D, Vn.2S, Vm.S[lane] + /// uint64x2_t vmull_lane_u32 (uint32x2_t a, uint32x2_t v, const int lane) + /// A32: VMULL.U32 Qd, Dn, Dm[lane] + /// A64: UMULL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLower(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalarWideningLower(left, right, rightIndex); /// - /// uint64x2_t vmull_laneq_u32 (uint32x2_t a, uint32x4_t v, const int lane) - /// A32: VMULL.U32 Qd, Dn, Dm[lane] - /// A64: UMULL Vd.2D, Vn.2S, Vm.S[lane] + /// uint64x2_t vmull_laneq_u32 (uint32x2_t a, uint32x4_t v, const int lane) + /// A32: VMULL.U32 Qd, Dn, Dm[lane] + /// A64: UMULL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLower(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningLower(left, right, rightIndex); /// - /// int32x4_t vmlal_lane_s16 (int32x4_t a, int16x4_t b, int16x4_t v, const int lane) - /// A32: VMLAL.S16 Qd, Dn, Dm[lane] - /// A64: SMLAL Vd.4S, Vn.4H, Vm.H[lane] + /// int32x4_t vmlal_lane_s16 (int32x4_t a, int16x4_t b, int16x4_t v, const int lane) + /// A32: VMLAL.S16 Qd, Dn, Dm[lane] + /// A64: SMLAL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndAdd(addend, left, right, rightIndex); /// - /// int32x4_t vmlal_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane) - /// A32: VMLAL.S16 Qd, Dn, Dm[lane] - /// A64: SMLAL Vd.4S, Vn.4H, Vm.H[lane] + /// int32x4_t vmlal_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane) + /// A32: VMLAL.S16 Qd, Dn, Dm[lane] + /// A64: SMLAL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndAdd(addend, left, right, rightIndex); /// - /// int64x2_t vmlal_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane) - /// A32: VMLAL.S32 Qd, Dn, Dm[lane] - /// A64: SMLAL Vd.2D, Vn.2S, Vm.S[lane] + /// int64x2_t vmlal_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane) + /// A32: VMLAL.S32 Qd, Dn, Dm[lane] + /// A64: SMLAL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndAdd(addend, left, right, rightIndex); /// - /// int64x2_t vmlal_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane) - /// A32: VMLAL.S32 Qd, Dn, Dm[lane] - /// A64: SMLAL Vd.2D, Vn.2S, Vm.S[lane] + /// int64x2_t vmlal_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane) + /// A32: VMLAL.S32 Qd, Dn, Dm[lane] + /// A64: SMLAL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndAdd(addend, left, right, rightIndex); /// - /// uint32x4_t vmlal_lane_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t v, const int lane) - /// A32: VMLAL.U16 Qd, Dn, Dm[lane] - /// A64: UMLAL Vd.4S, Vn.4H, Vm.H[lane] + /// uint32x4_t vmlal_lane_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t v, const int lane) + /// A32: VMLAL.U16 Qd, Dn, Dm[lane] + /// A64: UMLAL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndAdd(addend, left, right, rightIndex); /// - /// uint32x4_t vmlal_laneq_u16 (uint32x4_t a, uint16x4_t b, uint16x8_t v, const int lane) - /// A32: VMLAL.U16 Qd, Dn, Dm[lane] - /// A64: UMLAL Vd.4S, Vn.4H, Vm.H[lane] + /// uint32x4_t vmlal_laneq_u16 (uint32x4_t a, uint16x4_t b, uint16x8_t v, const int lane) + /// A32: VMLAL.U16 Qd, Dn, Dm[lane] + /// A64: UMLAL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndAdd(addend, left, right, rightIndex); /// - /// uint64x2_t vmlal_lane_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t v, const int lane) - /// A32: VMLAL.U32 Qd, Dn, Dm[lane] - /// A64: UMLAL Vd.2D, Vn.2S, Vm.S[lane] + /// uint64x2_t vmlal_lane_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t v, const int lane) + /// A32: VMLAL.U32 Qd, Dn, Dm[lane] + /// A64: UMLAL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndAdd(addend, left, right, rightIndex); /// - /// uint64x2_t vmlal_laneq_u32 (uint64x2_t a, uint32x2_t b, uint32x4_t v, const int lane) - /// A32: VMLAL.U32 Qd, Dn, Dm[lane] - /// A64: UMLAL Vd.2D, Vn.2S, Vm.S[lane] + /// uint64x2_t vmlal_laneq_u32 (uint64x2_t a, uint32x2_t b, uint32x4_t v, const int lane) + /// A32: VMLAL.U32 Qd, Dn, Dm[lane] + /// A64: UMLAL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndAdd(addend, left, right, rightIndex); /// - /// int32x4_t vmlsl_lane_s16 (int32x4_t a, int16x4_t b, int16x4_t v, const int lane) - /// A32: VMLSL.S16 Qd, Dn, Dm[lane] - /// A64: SMLSL Vd.4S, Vn.4H, Vm.H[lane] + /// int32x4_t vmlsl_lane_s16 (int32x4_t a, int16x4_t b, int16x4_t v, const int lane) + /// A32: VMLSL.S16 Qd, Dn, Dm[lane] + /// A64: SMLSL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndSubtract(minuend, left, right, rightIndex); /// - /// int32x4_t vmlsl_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane) - /// A32: VMLSL.S16 Qd, Dn, Dm[lane] - /// A64: SMLSL Vd.4S, Vn.4H, Vm.H[lane] + /// int32x4_t vmlsl_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane) + /// A32: VMLSL.S16 Qd, Dn, Dm[lane] + /// A64: SMLSL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndSubtract(minuend, left, right, rightIndex); /// - /// int64x2_t vmlsl_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane) - /// A32: VMLSL.S32 Qd, Dn, Dm[lane] - /// A64: SMLSL Vd.2D, Vn.2S, Vm.S[lane] + /// int64x2_t vmlsl_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane) + /// A32: VMLSL.S32 Qd, Dn, Dm[lane] + /// A64: SMLSL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndSubtract(minuend, left, right, rightIndex); /// - /// int64x2_t vmlsl_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane) - /// A32: VMLSL.S32 Qd, Dn, Dm[lane] - /// A64: SMLSL Vd.2D, Vn.2S, Vm.S[lane] + /// int64x2_t vmlsl_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane) + /// A32: VMLSL.S32 Qd, Dn, Dm[lane] + /// A64: SMLSL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndSubtract(minuend, left, right, rightIndex); /// - /// uint32x4_t vmlsl_lane_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t v, const int lane) - /// A32: VMLSL.U16 Qd, Dn, Dm[lane] - /// A64: UMLSL Vd.4S, Vn.4H, Vm.H[lane] + /// uint32x4_t vmlsl_lane_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t v, const int lane) + /// A32: VMLSL.U16 Qd, Dn, Dm[lane] + /// A64: UMLSL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndSubtract(minuend, left, right, rightIndex); /// - /// uint32x4_t vmlsl_laneq_u16 (uint32x4_t a, uint16x4_t b, uint16x8_t v, const int lane) - /// A32: VMLSL.U16 Qd, Dn, Dm[lane] - /// A64: UMLSL Vd.4S, Vn.4H, Vm.H[lane] + /// uint32x4_t vmlsl_laneq_u16 (uint32x4_t a, uint16x4_t b, uint16x8_t v, const int lane) + /// A32: VMLSL.U16 Qd, Dn, Dm[lane] + /// A64: UMLSL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndSubtract(minuend, left, right, rightIndex); /// - /// uint64x2_t vmlsl_lane_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t v, const int lane) - /// A32: VMLSL.U32 Qd, Dn, Dm[lane] - /// A64: UMLSL Vd.2D, Vn.2S, Vm.S[lane] + /// uint64x2_t vmlsl_lane_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t v, const int lane) + /// A32: VMLSL.U32 Qd, Dn, Dm[lane] + /// A64: UMLSL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndSubtract(minuend, left, right, rightIndex); /// - /// uint64x2_t vmlsl_laneq_u32 (uint64x2_t a, uint32x2_t b, uint32x4_t v, const int lane) - /// A32: VMLSL.U32 Qd, Dn, Dm[lane] - /// A64: UMLSL Vd.2D, Vn.2S, Vm.S[lane] + /// uint64x2_t vmlsl_laneq_u32 (uint64x2_t a, uint32x2_t b, uint32x4_t v, const int lane) + /// A32: VMLSL.U32 Qd, Dn, Dm[lane] + /// A64: UMLSL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningLowerAndSubtract(minuend, left, right, rightIndex); /// - /// int32x4_t vmull_high_lane_s16 (int16x8_t a, int16x4_t v, const int lane) - /// A32: VMULL.S16 Qd, Dn+1, Dm[lane] - /// A64: SMULL2 Vd.4S, Vn.8H, Vm.H[lane] + /// int32x4_t vmull_high_lane_s16 (int16x8_t a, int16x4_t v, const int lane) + /// A32: VMULL.S16 Qd, Dn+1, Dm[lane] + /// A64: SMULL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpper(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningUpper(left, right, rightIndex); /// - /// int32x4_t vmull_high_laneq_s16 (int16x8_t a, int16x8_t v, const int lane) - /// A32: VMULL.S16 Qd, Dn+1, Dm[lane] - /// A64: SMULL2 Vd.4S, Vn.8H, Vm.H[lane] + /// int32x4_t vmull_high_laneq_s16 (int16x8_t a, int16x8_t v, const int lane) + /// A32: VMULL.S16 Qd, Dn+1, Dm[lane] + /// A64: SMULL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpper(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalarWideningUpper(left, right, rightIndex); /// - /// int64x2_t vmull_high_lane_s32 (int32x4_t a, int32x2_t v, const int lane) - /// A32: VMULL.S32 Qd, Dn+1, Dm[lane] - /// A64: SMULL2 Vd.2D, Vn.4S, Vm.S[lane] + /// int64x2_t vmull_high_lane_s32 (int32x4_t a, int32x2_t v, const int lane) + /// A32: VMULL.S32 Qd, Dn+1, Dm[lane] + /// A64: SMULL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpper(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalarWideningUpper(left, right, rightIndex); /// - /// int64x2_t vmull_high_laneq_s32 (int32x4_t a, int32x4_t v, const int lane) - /// A32: VMULL.S32 Qd, Dn+1, Dm[lane] - /// A64: SMULL2 Vd.2D, Vn.4S, Vm.S[lane] + /// int64x2_t vmull_high_laneq_s32 (int32x4_t a, int32x4_t v, const int lane) + /// A32: VMULL.S32 Qd, Dn+1, Dm[lane] + /// A64: SMULL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpper(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningUpper(left, right, rightIndex); /// - /// uint32x4_t vmull_high_lane_u16 (uint16x8_t a, uint16x4_t v, const int lane) - /// A32: VMULL.U16 Qd, Dn+1, Dm[lane] - /// A64: UMULL2 Vd.4S, Vn.8H, Vm.H[lane] + /// uint32x4_t vmull_high_lane_u16 (uint16x8_t a, uint16x4_t v, const int lane) + /// A32: VMULL.U16 Qd, Dn+1, Dm[lane] + /// A64: UMULL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpper(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningUpper(left, right, rightIndex); /// - /// uint32x4_t vmull_high_laneq_u16 (uint16x8_t a, uint16x8_t v, const int lane) - /// A32: VMULL.U16 Qd, Dn+1, Dm[lane] - /// A64: UMULL2 Vd.4S, Vn.8H, Vm.H[lane] + /// uint32x4_t vmull_high_laneq_u16 (uint16x8_t a, uint16x8_t v, const int lane) + /// A32: VMULL.U16 Qd, Dn+1, Dm[lane] + /// A64: UMULL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpper(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalarWideningUpper(left, right, rightIndex); /// - /// uint64x2_t vmull_high_lane_u32 (uint32x4_t a, uint32x2_t v, const int lane) - /// A32: VMULL.U32 Qd, Dn+1, Dm[lane] - /// A64: UMULL2 Vd.2D, Vn.4S, Vm.S[lane] + /// uint64x2_t vmull_high_lane_u32 (uint32x4_t a, uint32x2_t v, const int lane) + /// A32: VMULL.U32 Qd, Dn+1, Dm[lane] + /// A64: UMULL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpper(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalarWideningUpper(left, right, rightIndex); /// - /// uint64x2_t vmull_high_laneq_u32 (uint32x4_t a, uint32x4_t v, const int lane) - /// A32: VMULL.U32 Qd, Dn+1, Dm[lane] - /// A64: UMULL2 Vd.2D, Vn.4S, Vm.S[lane] + /// uint64x2_t vmull_high_laneq_u32 (uint32x4_t a, uint32x4_t v, const int lane) + /// A32: VMULL.U32 Qd, Dn+1, Dm[lane] + /// A64: UMULL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpper(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningUpper(left, right, rightIndex); /// - /// int32x4_t vmlal_high_lane_s16 (int32x4_t a, int16x8_t b, int16x4_t v, const int lane) - /// A32: VMLAL.S16 Qd, Dn+1, Dm[lane] - /// A64: SMLAL2 Vd.4S, Vn.8H, Vm.H[lane] + /// int32x4_t vmlal_high_lane_s16 (int32x4_t a, int16x8_t b, int16x4_t v, const int lane) + /// A32: VMLAL.S16 Qd, Dn+1, Dm[lane] + /// A64: SMLAL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndAdd(addend, left, right, rightIndex); /// - /// int32x4_t vmlal_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane) - /// A32: VMLAL.S16 Qd, Dn+1, Dm[lane] - /// A64: SMLAL2 Vd.4S, Vn.8H, Vm.H[lane] + /// int32x4_t vmlal_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane) + /// A32: VMLAL.S16 Qd, Dn+1, Dm[lane] + /// A64: SMLAL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndAdd(addend, left, right, rightIndex); /// - /// int64x2_t vmlal_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane) - /// A32: VMLAL.S32 Qd, Dn+1, Dm[lane] - /// A64: SMLAL2 Vd.2D, Vn.4S, Vm.S[lane] + /// int64x2_t vmlal_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane) + /// A32: VMLAL.S32 Qd, Dn+1, Dm[lane] + /// A64: SMLAL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndAdd(addend, left, right, rightIndex); /// - /// int64x2_t vmlal_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane) - /// A32: VMLAL.S32 Qd, Dn+1, Dm[lane] - /// A64: SMLAL2 Vd.2D, Vn.4S, Vm.S[lane] + /// int64x2_t vmlal_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane) + /// A32: VMLAL.S32 Qd, Dn+1, Dm[lane] + /// A64: SMLAL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndAdd(addend, left, right, rightIndex); /// - /// uint32x4_t vmlal_high_lane_u16 (uint32x4_t a, uint16x8_t b, uint16x4_t v, const int lane) - /// A32: VMLAL.U16 Qd, Dn+1, Dm[lane] - /// A64: UMLAL2 Vd.4S, Vn.8H, Vm.H[lane] + /// uint32x4_t vmlal_high_lane_u16 (uint32x4_t a, uint16x8_t b, uint16x4_t v, const int lane) + /// A32: VMLAL.U16 Qd, Dn+1, Dm[lane] + /// A64: UMLAL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndAdd(addend, left, right, rightIndex); /// - /// uint32x4_t vmlal_high_laneq_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t v, const int lane) - /// A32: VMLAL.U16 Qd, Dn+1, Dm[lane] - /// A64: UMLAL2 Vd.4S, Vn.8H, Vm.H[lane] + /// uint32x4_t vmlal_high_laneq_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t v, const int lane) + /// A32: VMLAL.U16 Qd, Dn+1, Dm[lane] + /// A64: UMLAL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndAdd(addend, left, right, rightIndex); /// - /// uint64x2_t vmlal_high_lane_u32 (uint64x2_t a, uint32x4_t b, uint32x2_t v, const int lane) - /// A32: VMLAL.U32 Qd, Dn+1, Dm[lane] - /// A64: UMLAL2 Vd.2D, Vn.4S, Vm.S[lane] + /// uint64x2_t vmlal_high_lane_u32 (uint64x2_t a, uint32x4_t b, uint32x2_t v, const int lane) + /// A32: VMLAL.U32 Qd, Dn+1, Dm[lane] + /// A64: UMLAL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndAdd(addend, left, right, rightIndex); /// - /// uint64x2_t vmlal_high_laneq_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t v, const int lane) - /// A32: VMLAL.U32 Qd, Dn+1, Dm[lane] - /// A64: UMLAL2 Vd.2D, Vn.4S, Vm.S[lane] + /// uint64x2_t vmlal_high_laneq_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t v, const int lane) + /// A32: VMLAL.U32 Qd, Dn+1, Dm[lane] + /// A64: UMLAL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndAdd(addend, left, right, rightIndex); /// - /// int32x4_t vmlsl_high_lane_s16 (int32x4_t a, int16x8_t b, int16x4_t v, const int lane) - /// A32: VMLSL.S16 Qd, Dn+1, Dm[lane] - /// A64: SMLSL2 Vd.4S, Vn.8H, Vm.H[lane] + /// int32x4_t vmlsl_high_lane_s16 (int32x4_t a, int16x8_t b, int16x4_t v, const int lane) + /// A32: VMLSL.S16 Qd, Dn+1, Dm[lane] + /// A64: SMLSL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndSubtract(minuend, left, right, rightIndex); /// - /// int32x4_t vmlsl_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane) - /// A32: VMLSL.S16 Qd, Dn+1, Dm[lane] - /// A64: SMLSL2 Vd.4S, Vn.8H, Vm.H[lane] + /// int32x4_t vmlsl_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane) + /// A32: VMLSL.S16 Qd, Dn+1, Dm[lane] + /// A64: SMLSL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndSubtract(minuend, left, right, rightIndex); /// - /// int64x2_t vmlsl_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane) - /// A32: VMLSL.S32 Qd, Dn+1, Dm[lane] - /// A64: SMLSL2 Vd.2D, Vn.4S, Vm.S[lane] + /// int64x2_t vmlsl_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane) + /// A32: VMLSL.S32 Qd, Dn+1, Dm[lane] + /// A64: SMLSL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndSubtract(minuend, left, right, rightIndex); /// - /// int64x2_t vmlsl_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane) - /// A32: VMLSL.S32 Qd, Dn+1, Dm[lane] - /// A64: SMLSL2 Vd.2D, Vn.4S, Vm.S[lane] + /// int64x2_t vmlsl_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane) + /// A32: VMLSL.S32 Qd, Dn+1, Dm[lane] + /// A64: SMLSL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndSubtract(minuend, left, right, rightIndex); /// - /// uint32x4_t vmlsl_high_lane_u16 (uint32x4_t a, uint16x8_t b, uint16x4_t v, const int lane) - /// A32: VMLSL.U16 Qd, Dn+1, Dm[lane] - /// A64: UMLSL2 Vd.4S, Vn.8H, Vm.H[lane] + /// uint32x4_t vmlsl_high_lane_u16 (uint32x4_t a, uint16x8_t b, uint16x4_t v, const int lane) + /// A32: VMLSL.U16 Qd, Dn+1, Dm[lane] + /// A64: UMLSL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndSubtract(minuend, left, right, rightIndex); /// - /// uint32x4_t vmlsl_high_laneq_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t v, const int lane) - /// A32: VMLSL.U16 Qd, Dn+1, Dm[lane] - /// A64: UMLSL2 Vd.4S, Vn.8H, Vm.H[lane] + /// uint32x4_t vmlsl_high_laneq_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t v, const int lane) + /// A32: VMLSL.U16 Qd, Dn+1, Dm[lane] + /// A64: UMLSL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndSubtract(minuend, left, right, rightIndex); /// - /// uint64x2_t vmlsl_high_lane_u32 (uint64x2_t a, uint32x4_t b, uint32x2_t v, const int lane) - /// A32: VMLSL.U32 Qd, Dn+1, Dm[lane] - /// A64: UMLSL2 Vd.2D, Vn.4S, Vm.S[lane] + /// uint64x2_t vmlsl_high_lane_u32 (uint64x2_t a, uint32x4_t b, uint32x2_t v, const int lane) + /// A32: VMLSL.U32 Qd, Dn+1, Dm[lane] + /// A64: UMLSL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndSubtract(minuend, left, right, rightIndex); /// - /// uint64x2_t vmlsl_high_laneq_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t v, const int lane) - /// A32: VMLSL.U32 Qd, Dn+1, Dm[lane] - /// A64: UMLSL2 Vd.2D, Vn.4S, Vm.S[lane] + /// uint64x2_t vmlsl_high_laneq_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t v, const int lane) + /// A32: VMLSL.U32 Qd, Dn+1, Dm[lane] + /// A64: UMLSL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyBySelectedScalarWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyBySelectedScalarWideningUpperAndSubtract(minuend, left, right, rightIndex); /// - /// int16x4_t vqdmulh_n_s16 (int16x4_t a, int16_t b) - /// A32: VQDMULH.S16 Dd, Dn, Dm[0] - /// A64: SQDMULH Vd.4H, Vn.4H, Vm.H[0] + /// int16x4_t vqdmulh_n_s16 (int16x4_t a, int16_t b) + /// A32: VQDMULH.S16 Dd, Dn, Dm[0] + /// A64: SQDMULH Vd.4H, Vn.4H, Vm.H[0] /// public static Vector64 MultiplyDoublingByScalarSaturateHigh(Vector64 left, Vector64 right) => MultiplyDoublingByScalarSaturateHigh(left, right); /// - /// int32x2_t vqdmulh_n_s32 (int32x2_t a, int32_t b) - /// A32: VQDMULH.S32 Dd, Dn, Dm[0] - /// A64: SQDMULH Vd.2S, Vn.2S, Vm.S[0] + /// int32x2_t vqdmulh_n_s32 (int32x2_t a, int32_t b) + /// A32: VQDMULH.S32 Dd, Dn, Dm[0] + /// A64: SQDMULH Vd.2S, Vn.2S, Vm.S[0] /// public static Vector64 MultiplyDoublingByScalarSaturateHigh(Vector64 left, Vector64 right) => MultiplyDoublingByScalarSaturateHigh(left, right); /// - /// int16x8_t vqdmulhq_n_s16 (int16x8_t a, int16_t b) - /// A32: VQDMULH.S16 Qd, Qn, Dm[0] - /// A64: SQDMULH Vd.8H, Vn.8H, Vm.H[0] + /// int16x8_t vqdmulhq_n_s16 (int16x8_t a, int16_t b) + /// A32: VQDMULH.S16 Qd, Qn, Dm[0] + /// A64: SQDMULH Vd.8H, Vn.8H, Vm.H[0] /// public static Vector128 MultiplyDoublingByScalarSaturateHigh(Vector128 left, Vector64 right) => MultiplyDoublingByScalarSaturateHigh(left, right); /// - /// int32x4_t vqdmulhq_n_s32 (int32x4_t a, int32_t b) - /// A32: VQDMULH.S32 Qd, Qn, Dm[0] - /// A64: SQDMULH Vd.4S, Vn.4S, Vm.S[0] + /// int32x4_t vqdmulhq_n_s32 (int32x4_t a, int32_t b) + /// A32: VQDMULH.S32 Qd, Qn, Dm[0] + /// A64: SQDMULH Vd.4S, Vn.4S, Vm.S[0] /// public static Vector128 MultiplyDoublingByScalarSaturateHigh(Vector128 left, Vector64 right) => MultiplyDoublingByScalarSaturateHigh(left, right); /// - /// int16x4_t vqdmulh_lane_s16 (int16x4_t a, int16x4_t v, const int lane) - /// A32: VQDMULH.S16 Dd, Dn, Dm[lane] - /// A64: SQDMULH Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vqdmulh_lane_s16 (int16x4_t a, int16x4_t v, const int lane) + /// A32: VQDMULH.S16 Dd, Dn, Dm[lane] + /// A64: SQDMULH Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyDoublingBySelectedScalarSaturateHigh(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingBySelectedScalarSaturateHigh(left, right, rightIndex); /// - /// int16x4_t vqdmulh_laneq_s16 (int16x4_t a, int16x8_t v, const int lane) - /// A32: VQDMULH.S16 Dd, Dn, Dm[lane] - /// A64: SQDMULH Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vqdmulh_laneq_s16 (int16x4_t a, int16x8_t v, const int lane) + /// A32: VQDMULH.S16 Dd, Dn, Dm[lane] + /// A64: SQDMULH Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyDoublingBySelectedScalarSaturateHigh(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyDoublingBySelectedScalarSaturateHigh(left, right, rightIndex); /// - /// int32x2_t vqdmulh_lane_s32 (int32x2_t a, int32x2_t v, const int lane) - /// A32: VQDMULH.S32 Dd, Dn, Dm[lane] - /// A64: SQDMULH Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vqdmulh_lane_s32 (int32x2_t a, int32x2_t v, const int lane) + /// A32: VQDMULH.S32 Dd, Dn, Dm[lane] + /// A64: SQDMULH Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyDoublingBySelectedScalarSaturateHigh(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyDoublingBySelectedScalarSaturateHigh(left, right, rightIndex); /// - /// int32x2_t vqdmulh_laneq_s32 (int32x2_t a, int32x4_t v, const int lane) - /// A32: VQDMULH.S32 Dd, Dn, Dm[lane] - /// A64: SQDMULH Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vqdmulh_laneq_s32 (int32x2_t a, int32x4_t v, const int lane) + /// A32: VQDMULH.S32 Dd, Dn, Dm[lane] + /// A64: SQDMULH Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyDoublingBySelectedScalarSaturateHigh(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingBySelectedScalarSaturateHigh(left, right, rightIndex); /// - /// int16x8_t vqdmulhq_lane_s16 (int16x8_t a, int16x4_t v, const int lane) - /// A32: VQDMULH.S16 Qd, Qn, Dm[lane] - /// A64: SQDMULH Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vqdmulhq_lane_s16 (int16x8_t a, int16x4_t v, const int lane) + /// A32: VQDMULH.S16 Qd, Qn, Dm[lane] + /// A64: SQDMULH Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyDoublingBySelectedScalarSaturateHigh(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingBySelectedScalarSaturateHigh(left, right, rightIndex); /// - /// int16x8_t vqdmulhq_laneq_s16 (int16x8_t a, int16x8_t v, const int lane) - /// A32: VQDMULH.S16 Qd, Qn, Dm[lane] - /// A64: SQDMULH Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vqdmulhq_laneq_s16 (int16x8_t a, int16x8_t v, const int lane) + /// A32: VQDMULH.S16 Qd, Qn, Dm[lane] + /// A64: SQDMULH Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyDoublingBySelectedScalarSaturateHigh(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyDoublingBySelectedScalarSaturateHigh(left, right, rightIndex); /// - /// int32x4_t vqdmulhq_lane_s32 (int32x4_t a, int32x2_t v, const int lane) - /// A32: VQDMULH.S32 Qd, Qn, Dm[lane] - /// A64: SQDMULH Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vqdmulhq_lane_s32 (int32x4_t a, int32x2_t v, const int lane) + /// A32: VQDMULH.S32 Qd, Qn, Dm[lane] + /// A64: SQDMULH Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyDoublingBySelectedScalarSaturateHigh(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyDoublingBySelectedScalarSaturateHigh(left, right, rightIndex); /// - /// int32x4_t vqdmulhq_laneq_s32 (int32x4_t a, int32x4_t v, const int lane) - /// A32: VQDMULH.S32 Qd, Qn, Dm[lane] - /// A64: SQDMULH Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vqdmulhq_laneq_s32 (int32x4_t a, int32x4_t v, const int lane) + /// A32: VQDMULH.S32 Qd, Qn, Dm[lane] + /// A64: SQDMULH Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyDoublingBySelectedScalarSaturateHigh(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingBySelectedScalarSaturateHigh(left, right, rightIndex); /// - /// int16x4_t vqdmulh_s16 (int16x4_t a, int16x4_t b) - /// A32: VQDMULH.S16 Dd, Dn, Dm - /// A64: SQDMULH Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vqdmulh_s16 (int16x4_t a, int16x4_t b) + /// A32: VQDMULH.S16 Dd, Dn, Dm + /// A64: SQDMULH Vd.4H, Vn.4H, Vm.4H /// public static Vector64 MultiplyDoublingSaturateHigh(Vector64 left, Vector64 right) => MultiplyDoublingSaturateHigh(left, right); /// - /// int32x2_t vqdmulh_s32 (int32x2_t a, int32x2_t b) - /// A32: VQDMULH.S32 Dd, Dn, Dm - /// A64: SQDMULH Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vqdmulh_s32 (int32x2_t a, int32x2_t b) + /// A32: VQDMULH.S32 Dd, Dn, Dm + /// A64: SQDMULH Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MultiplyDoublingSaturateHigh(Vector64 left, Vector64 right) => MultiplyDoublingSaturateHigh(left, right); /// - /// int16x8_t vqdmulhq_s16 (int16x8_t a, int16x8_t b) - /// A32: VQDMULH.S16 Qd, Qn, Qm - /// A64: SQDMULH Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vqdmulhq_s16 (int16x8_t a, int16x8_t b) + /// A32: VQDMULH.S16 Qd, Qn, Qm + /// A64: SQDMULH Vd.8H, Vn.8H, Vm.8H /// public static Vector128 MultiplyDoublingSaturateHigh(Vector128 left, Vector128 right) => MultiplyDoublingSaturateHigh(left, right); /// - /// int32x4_t vqdmulhq_s32 (int32x4_t a, int32x4_t b) - /// A32: VQDMULH.S32 Qd, Qn, Qm - /// A64: SQDMULH Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vqdmulhq_s32 (int32x4_t a, int32x4_t b) + /// A32: VQDMULH.S32 Qd, Qn, Qm + /// A64: SQDMULH Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MultiplyDoublingSaturateHigh(Vector128 left, Vector128 right) => MultiplyDoublingSaturateHigh(left, right); /// - /// int32x4_t vqdmlal_s16 (int32x4_t a, int16x4_t b, int16x4_t c) - /// A32: VQDMLAL.S16 Qd, Dn, Dm - /// A64: SQDMLAL Vd.4S, Vn.4H, Vm.4H + /// int32x4_t vqdmlal_s16 (int32x4_t a, int16x4_t b, int16x4_t c) + /// A32: VQDMLAL.S16 Qd, Dn, Dm + /// A64: SQDMLAL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 MultiplyDoublingWideningLowerAndAddSaturate(Vector128 addend, Vector64 left, Vector64 right) => MultiplyDoublingWideningLowerAndAddSaturate(addend, left, right); /// - /// int64x2_t vqdmlal_s32 (int64x2_t a, int32x2_t b, int32x2_t c) - /// A32: VQDMLAL.S32 Qd, Dn, Dm - /// A64: SQDMLAL Vd.2D, Vn.2S, Vm.2S + /// int64x2_t vqdmlal_s32 (int64x2_t a, int32x2_t b, int32x2_t c) + /// A32: VQDMLAL.S32 Qd, Dn, Dm + /// A64: SQDMLAL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 MultiplyDoublingWideningLowerAndAddSaturate(Vector128 addend, Vector64 left, Vector64 right) => MultiplyDoublingWideningLowerAndAddSaturate(addend, left, right); /// - /// int32x4_t vqdmlsl_s16 (int32x4_t a, int16x4_t b, int16x4_t c) - /// A32: VQDMLSL.S16 Qd, Dn, Dm - /// A64: SQDMLSL Vd.4S, Vn.4H, Vm.4H + /// int32x4_t vqdmlsl_s16 (int32x4_t a, int16x4_t b, int16x4_t c) + /// A32: VQDMLSL.S16 Qd, Dn, Dm + /// A64: SQDMLSL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 MultiplyDoublingWideningLowerAndSubtractSaturate(Vector128 minuend, Vector64 left, Vector64 right) => MultiplyDoublingWideningLowerAndSubtractSaturate(minuend, left, right); /// - /// int64x2_t vqdmlsl_s32 (int64x2_t a, int32x2_t b, int32x2_t c) - /// A32: VQDMLSL.S32 Qd, Dn, Dm - /// A64: SQDMLSL Vd.2D, Vn.2S, Vm.2S + /// int64x2_t vqdmlsl_s32 (int64x2_t a, int32x2_t b, int32x2_t c) + /// A32: VQDMLSL.S32 Qd, Dn, Dm + /// A64: SQDMLSL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 MultiplyDoublingWideningLowerAndSubtractSaturate(Vector128 minuend, Vector64 left, Vector64 right) => MultiplyDoublingWideningLowerAndSubtractSaturate(minuend, left, right); /// - /// int32x4_t vqdmlal_n_s16 (int32x4_t a, int16x4_t b, int16_t c) - /// A32: VQDMLAL.S16 Qd, Dn, Dm[0] - /// A64: SQDMLAL Vd.4S, Vn.4H, Vm.H[0] + /// int32x4_t vqdmlal_n_s16 (int32x4_t a, int16x4_t b, int16_t c) + /// A32: VQDMLAL.S16 Qd, Dn, Dm[0] + /// A64: SQDMLAL Vd.4S, Vn.4H, Vm.H[0] /// public static Vector128 MultiplyDoublingWideningLowerByScalarAndAddSaturate(Vector128 addend, Vector64 left, Vector64 right) => MultiplyDoublingWideningLowerByScalarAndAddSaturate(addend, left, right); /// - /// int64x2_t vqdmlal_n_s32 (int64x2_t a, int32x2_t b, int32_t c) - /// A32: VQDMLAL.S32 Qd, Dn, Dm[0] - /// A64: SQDMLAL Vd.2D, Vn.2S, Vm.S[0] + /// int64x2_t vqdmlal_n_s32 (int64x2_t a, int32x2_t b, int32_t c) + /// A32: VQDMLAL.S32 Qd, Dn, Dm[0] + /// A64: SQDMLAL Vd.2D, Vn.2S, Vm.S[0] /// public static Vector128 MultiplyDoublingWideningLowerByScalarAndAddSaturate(Vector128 addend, Vector64 left, Vector64 right) => MultiplyDoublingWideningLowerByScalarAndAddSaturate(addend, left, right); /// - /// int32x4_t vqdmlsl_n_s16 (int32x4_t a, int16x4_t b, int16_t c) - /// A32: VQDMLSL.S16 Qd, Dn, Dm[0] - /// A64: SQDMLSL Vd.4S, Vn.4H, Vm.H[0] + /// int32x4_t vqdmlsl_n_s16 (int32x4_t a, int16x4_t b, int16_t c) + /// A32: VQDMLSL.S16 Qd, Dn, Dm[0] + /// A64: SQDMLSL Vd.4S, Vn.4H, Vm.H[0] /// public static Vector128 MultiplyDoublingWideningLowerByScalarAndSubtractSaturate(Vector128 minuend, Vector64 left, Vector64 right) => MultiplyDoublingWideningLowerByScalarAndSubtractSaturate(minuend, left, right); /// - /// int64x2_t vqdmlsl_n_s32 (int64x2_t a, int32x2_t b, int32_t c) - /// A32: VQDMLSL.S32 Qd, Dn, Dm[0] - /// A64: SQDMLSL Vd.2D, Vn.2S, Vm.S[0] + /// int64x2_t vqdmlsl_n_s32 (int64x2_t a, int32x2_t b, int32_t c) + /// A32: VQDMLSL.S32 Qd, Dn, Dm[0] + /// A64: SQDMLSL Vd.2D, Vn.2S, Vm.S[0] /// public static Vector128 MultiplyDoublingWideningLowerByScalarAndSubtractSaturate(Vector128 minuend, Vector64 left, Vector64 right) => MultiplyDoublingWideningLowerByScalarAndSubtractSaturate(minuend, left, right); /// - /// int32x4_t vqdmlal_lane_s16 (int32x4_t a, int16x4_t b, int16x4_t v, const int lane) - /// A32: VQDMLAL.S16 Qd, Dn, Dm[lane] - /// A64: SQDMLAL Vd.4S, Vn.4H, Vm.H[lane] + /// int32x4_t vqdmlal_lane_s16 (int32x4_t a, int16x4_t b, int16x4_t v, const int lane) + /// A32: VQDMLAL.S16 Qd, Dn, Dm[lane] + /// A64: SQDMLAL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(addend, left, right, rightIndex); /// - /// int32x4_t vqdmlal_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane) - /// A32: VQDMLAL.S16 Qd, Dn, Dm[lane] - /// A64: SQDMLAL Vd.4S, Vn.4H, Vm.H[lane] + /// int32x4_t vqdmlal_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane) + /// A32: VQDMLAL.S16 Qd, Dn, Dm[lane] + /// A64: SQDMLAL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(addend, left, right, rightIndex); /// - /// int64x2_t vqdmlal_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane) - /// A32: VQDMLAL.S32 Qd, Dn, Dm[lane] - /// A64: SQDMLAL Vd.2D, Vn.2S, Vm.S[lane] + /// int64x2_t vqdmlal_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane) + /// A32: VQDMLAL.S32 Qd, Dn, Dm[lane] + /// A64: SQDMLAL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(addend, left, right, rightIndex); /// - /// int64x2_t vqdmlal_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane) - /// A32: VQDMLAL.S32 Qd, Dn, Dm[lane] - /// A64: SQDMLAL Vd.2D, Vn.2S, Vm.S[lane] + /// int64x2_t vqdmlal_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane) + /// A32: VQDMLAL.S32 Qd, Dn, Dm[lane] + /// A64: SQDMLAL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(Vector128 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningLowerBySelectedScalarAndAddSaturate(addend, left, right, rightIndex); /// - /// int32x4_t vqdmlsl_lane_s16 (int32x4_t a, int16x4_t b, int16x4_t v, const int lane) - /// A32: VQDMLSL.S16 Qd, Dn, Dm[lane] - /// A64: SQDMLSL Vd.4S, Vn.4H, Vm.H[lane] + /// int32x4_t vqdmlsl_lane_s16 (int32x4_t a, int16x4_t b, int16x4_t v, const int lane) + /// A32: VQDMLSL.S16 Qd, Dn, Dm[lane] + /// A64: SQDMLSL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex); /// - /// int32x4_t vqdmlsl_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane) - /// A32: VQDMLSL.S16 Qd, Dn, Dm[lane] - /// A64: SQDMLSL Vd.4S, Vn.4H, Vm.H[lane] + /// int32x4_t vqdmlsl_laneq_s16 (int32x4_t a, int16x4_t b, int16x8_t v, const int lane) + /// A32: VQDMLSL.S16 Qd, Dn, Dm[lane] + /// A64: SQDMLSL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex); /// - /// int64x2_t vqdmlsl_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane) - /// A32: VQDMLSL.S32 Qd, Dn, Dm[lane] - /// A64: SQDMLSL Vd.2D, Vn.2S, Vm.S[lane] + /// int64x2_t vqdmlsl_lane_s32 (int64x2_t a, int32x2_t b, int32x2_t v, const int lane) + /// A32: VQDMLSL.S32 Qd, Dn, Dm[lane] + /// A64: SQDMLSL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex); /// - /// int64x2_t vqdmlsl_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane) - /// A32: VQDMLSL.S32 Qd, Dn, Dm[lane] - /// A64: SQDMLSL Vd.2D, Vn.2S, Vm.S[lane] + /// int64x2_t vqdmlsl_laneq_s32 (int64x2_t a, int32x2_t b, int32x4_t v, const int lane) + /// A32: VQDMLSL.S32 Qd, Dn, Dm[lane] + /// A64: SQDMLSL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(Vector128 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningLowerBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex); /// - /// int32x4_t vqdmull_s16 (int16x4_t a, int16x4_t b) - /// A32: VQDMULL.S16 Qd, Dn, Dm - /// A64: SQDMULL Vd.4S, Vn.4H, Vm.4H + /// int32x4_t vqdmull_s16 (int16x4_t a, int16x4_t b) + /// A32: VQDMULL.S16 Qd, Dn, Dm + /// A64: SQDMULL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 MultiplyDoublingWideningSaturateLower(Vector64 left, Vector64 right) => MultiplyDoublingWideningSaturateLower(left, right); /// - /// int64x2_t vqdmull_s32 (int32x2_t a, int32x2_t b) - /// A32: VQDMULL.S32 Qd, Dn, Dm - /// A64: SQDMULL Vd.2D, Vn.2S, Vm.2S + /// int64x2_t vqdmull_s32 (int32x2_t a, int32x2_t b) + /// A32: VQDMULL.S32 Qd, Dn, Dm + /// A64: SQDMULL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 MultiplyDoublingWideningSaturateLower(Vector64 left, Vector64 right) => MultiplyDoublingWideningSaturateLower(left, right); /// - /// int32x4_t vqdmull_n_s16 (int16x4_t a, int16_t b) - /// A32: VQDMULL.S16 Qd, Dn, Dm[0] - /// A64: SQDMULL Vd.4S, Vn.4H, Vm.H[0] + /// int32x4_t vqdmull_n_s16 (int16x4_t a, int16_t b) + /// A32: VQDMULL.S16 Qd, Dn, Dm[0] + /// A64: SQDMULL Vd.4S, Vn.4H, Vm.H[0] /// public static Vector128 MultiplyDoublingWideningSaturateLowerByScalar(Vector64 left, Vector64 right) => MultiplyDoublingWideningSaturateLowerByScalar(left, right); /// - /// int64x2_t vqdmull_n_s32 (int32x2_t a, int32_t b) - /// A32: VQDMULL.S32 Qd, Dn, Dm[0] - /// A64: SQDMULL Vd.2D, Vn.2S, Vm.S[0] + /// int64x2_t vqdmull_n_s32 (int32x2_t a, int32_t b) + /// A32: VQDMULL.S32 Qd, Dn, Dm[0] + /// A64: SQDMULL Vd.2D, Vn.2S, Vm.S[0] /// public static Vector128 MultiplyDoublingWideningSaturateLowerByScalar(Vector64 left, Vector64 right) => MultiplyDoublingWideningSaturateLowerByScalar(left, right); /// - /// int32x4_t vqdmull_lane_s16 (int16x4_t a, int16x4_t v, const int lane) - /// A32: VQDMULL.S16 Qd, Dn, Dm[lane] - /// A64: SQDMULL Vd.4S, Vn.4H, Vm.H[lane] + /// int32x4_t vqdmull_lane_s16 (int16x4_t a, int16x4_t v, const int lane) + /// A32: VQDMULL.S16 Qd, Dn, Dm[lane] + /// A64: SQDMULL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningSaturateLowerBySelectedScalar(left, right, rightIndex); /// - /// int32x4_t vqdmull_laneq_s16 (int16x4_t a, int16x8_t v, const int lane) - /// A32: VQDMULL.S16 Qd, Dn, Dm[lane] - /// A64: SQDMULL Vd.4S, Vn.4H, Vm.H[lane] + /// int32x4_t vqdmull_laneq_s16 (int16x4_t a, int16x8_t v, const int lane) + /// A32: VQDMULL.S16 Qd, Dn, Dm[lane] + /// A64: SQDMULL Vd.4S, Vn.4H, Vm.H[lane] /// public static Vector128 MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyDoublingWideningSaturateLowerBySelectedScalar(left, right, rightIndex); /// - /// int64x2_t vqdmull_lane_s32 (int32x2_t a, int32x2_t v, const int lane) - /// A32: VQDMULL.S32 Qd, Dn, Dm[lane] - /// A64: SQDMULL Vd.2D, Vn.2S, Vm.S[lane] + /// int64x2_t vqdmull_lane_s32 (int32x2_t a, int32x2_t v, const int lane) + /// A32: VQDMULL.S32 Qd, Dn, Dm[lane] + /// A64: SQDMULL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyDoublingWideningSaturateLowerBySelectedScalar(left, right, rightIndex); /// - /// int64x2_t vqdmull_laneq_s32 (int32x2_t a, int32x4_t v, const int lane) - /// A32: VQDMULL.S32 Qd, Dn, Dm[lane] - /// A64: SQDMULL Vd.2D, Vn.2S, Vm.S[lane] + /// int64x2_t vqdmull_laneq_s32 (int32x2_t a, int32x4_t v, const int lane) + /// A32: VQDMULL.S32 Qd, Dn, Dm[lane] + /// A64: SQDMULL Vd.2D, Vn.2S, Vm.S[lane] /// public static Vector128 MultiplyDoublingWideningSaturateLowerBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningSaturateLowerBySelectedScalar(left, right, rightIndex); /// - /// int32x4_t vqdmull_high_s16 (int16x8_t a, int16x8_t b) - /// A32: VQDMULL.S16 Qd, Dn+1, Dm+1 - /// A64: SQDMULL2 Vd.4S, Vn.8H, Vm.8H + /// int32x4_t vqdmull_high_s16 (int16x8_t a, int16x8_t b) + /// A32: VQDMULL.S16 Qd, Dn+1, Dm+1 + /// A64: SQDMULL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 MultiplyDoublingWideningSaturateUpper(Vector128 left, Vector128 right) => MultiplyDoublingWideningSaturateUpper(left, right); /// - /// int64x2_t vqdmull_high_s32 (int32x4_t a, int32x4_t b) - /// A32: VQDMULL.S32 Qd, Dn+1, Dm+1 - /// A64: SQDMULL2 Vd.2D, Vn.4S, Vm.4S + /// int64x2_t vqdmull_high_s32 (int32x4_t a, int32x4_t b) + /// A32: VQDMULL.S32 Qd, Dn+1, Dm+1 + /// A64: SQDMULL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 MultiplyDoublingWideningSaturateUpper(Vector128 left, Vector128 right) => MultiplyDoublingWideningSaturateUpper(left, right); /// - /// int32x4_t vqdmull_high_n_s16 (int16x8_t a, int16_t b) - /// A32: VQDMULL.S16 Qd, Dn+1, Dm[0] - /// A64: SQDMULL2 Vd.4S, Vn.8H, Vm.H[0] + /// int32x4_t vqdmull_high_n_s16 (int16x8_t a, int16_t b) + /// A32: VQDMULL.S16 Qd, Dn+1, Dm[0] + /// A64: SQDMULL2 Vd.4S, Vn.8H, Vm.H[0] /// public static Vector128 MultiplyDoublingWideningSaturateUpperByScalar(Vector128 left, Vector64 right) => MultiplyDoublingWideningSaturateUpperByScalar(left, right); /// - /// int64x2_t vqdmull_high_n_s32 (int32x4_t a, int32_t b) - /// A32: VQDMULL.S32 Qd, Dn+1, Dm[0] - /// A64: SQDMULL2 Vd.2D, Vn.4S, Vm.S[0] + /// int64x2_t vqdmull_high_n_s32 (int32x4_t a, int32_t b) + /// A32: VQDMULL.S32 Qd, Dn+1, Dm[0] + /// A64: SQDMULL2 Vd.2D, Vn.4S, Vm.S[0] /// public static Vector128 MultiplyDoublingWideningSaturateUpperByScalar(Vector128 left, Vector64 right) => MultiplyDoublingWideningSaturateUpperByScalar(left, right); /// - /// int32x4_t vqdmull_high_lane_s16 (int16x8_t a, int16x4_t v, const int lane) - /// A32: VQDMULL.S16 Qd, Dn+1, Dm[lane] - /// A64: SQDMULL2 Vd.4S, Vn.8H, Vm.H[lane] + /// int32x4_t vqdmull_high_lane_s16 (int16x8_t a, int16x4_t v, const int lane) + /// A32: VQDMULL.S16 Qd, Dn+1, Dm[lane] + /// A64: SQDMULL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningSaturateUpperBySelectedScalar(left, right, rightIndex); /// - /// int32x4_t vqdmull_high_laneq_s16 (int16x8_t a, int16x8_t v, const int lane) - /// A32: VQDMULL.S16 Qd, Dn+1, Dm[lane] - /// A64: SQDMULL2 Vd.4S, Vn.8H, Vm.H[lane] + /// int32x4_t vqdmull_high_laneq_s16 (int16x8_t a, int16x8_t v, const int lane) + /// A32: VQDMULL.S16 Qd, Dn+1, Dm[lane] + /// A64: SQDMULL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyDoublingWideningSaturateUpperBySelectedScalar(left, right, rightIndex); /// - /// int64x2_t vqdmull_high_lane_s32 (int32x4_t a, int32x2_t v, const int lane) - /// A32: VQDMULL.S32 Qd, Dn+1, Dm[lane] - /// A64: SQDMULL2 Vd.2D, Vn.4S, Vm.S[lane] + /// int64x2_t vqdmull_high_lane_s32 (int32x4_t a, int32x2_t v, const int lane) + /// A32: VQDMULL.S32 Qd, Dn+1, Dm[lane] + /// A64: SQDMULL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyDoublingWideningSaturateUpperBySelectedScalar(left, right, rightIndex); /// - /// int64x2_t vqdmull_high_laneq_s32 (int32x4_t a, int32x4_t v, const int lane) - /// A32: VQDMULL.S32 Qd, Dn+1, Dm[lane] - /// A64: SQDMULL2 Vd.2D, Vn.4S, Vm.S[lane] + /// int64x2_t vqdmull_high_laneq_s32 (int32x4_t a, int32x4_t v, const int lane) + /// A32: VQDMULL.S32 Qd, Dn+1, Dm[lane] + /// A64: SQDMULL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyDoublingWideningSaturateUpperBySelectedScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningSaturateUpperBySelectedScalar(left, right, rightIndex); /// - /// int32x4_t vqdmlal_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c) - /// A32: VQDMLAL.S16 Qd, Dn+1, Dm+1 - /// A64: SQDMLAL2 Vd.4S, Vn.8H, Vm.8H + /// int32x4_t vqdmlal_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c) + /// A32: VQDMLAL.S16 Qd, Dn+1, Dm+1 + /// A64: SQDMLAL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 MultiplyDoublingWideningUpperAndAddSaturate(Vector128 addend, Vector128 left, Vector128 right) => MultiplyDoublingWideningUpperAndAddSaturate(addend, left, right); /// - /// int64x2_t vqdmlal_high_s32 (int64x2_t a, int32x4_t b, int32x4_t c) - /// A32: VQDMLAL.S32 Qd, Dn+1, Dm+1 - /// A64: SQDMLAL2 Vd.2D, Vn.4S, Vm.4S + /// int64x2_t vqdmlal_high_s32 (int64x2_t a, int32x4_t b, int32x4_t c) + /// A32: VQDMLAL.S32 Qd, Dn+1, Dm+1 + /// A64: SQDMLAL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 MultiplyDoublingWideningUpperAndAddSaturate(Vector128 addend, Vector128 left, Vector128 right) => MultiplyDoublingWideningUpperAndAddSaturate(addend, left, right); /// - /// int32x4_t vqdmlsl_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c) - /// A32: VQDMLSL.S16 Qd, Dn+1, Dm+1 - /// A64: SQDMLSL2 Vd.4S, Vn.8H, Vm.8H + /// int32x4_t vqdmlsl_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c) + /// A32: VQDMLSL.S16 Qd, Dn+1, Dm+1 + /// A64: SQDMLSL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 MultiplyDoublingWideningUpperAndSubtractSaturate(Vector128 minuend, Vector128 left, Vector128 right) => MultiplyDoublingWideningUpperAndSubtractSaturate(minuend, left, right); /// - /// int64x2_t vqdmlsl_high_s32 (int64x2_t a, int32x4_t b, int32x4_t c) - /// A32: VQDMLSL.S32 Qd, Dn+1, Dm+1 - /// A64: SQDMLSL2 Vd.2D, Vn.4S, Vm.4S + /// int64x2_t vqdmlsl_high_s32 (int64x2_t a, int32x4_t b, int32x4_t c) + /// A32: VQDMLSL.S32 Qd, Dn+1, Dm+1 + /// A64: SQDMLSL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 MultiplyDoublingWideningUpperAndSubtractSaturate(Vector128 minuend, Vector128 left, Vector128 right) => MultiplyDoublingWideningUpperAndSubtractSaturate(minuend, left, right); /// - /// int32x4_t vqdmlal_high_n_s16 (int32x4_t a, int16x8_t b, int16_t c) - /// A32: VQDMLAL.S16 Qd, Dn+1, Dm[0] - /// A64: SQDMLAL2 Vd.4S, Vn.8H, Vm.H[0] + /// int32x4_t vqdmlal_high_n_s16 (int32x4_t a, int16x8_t b, int16_t c) + /// A32: VQDMLAL.S16 Qd, Dn+1, Dm[0] + /// A64: SQDMLAL2 Vd.4S, Vn.8H, Vm.H[0] /// public static Vector128 MultiplyDoublingWideningUpperByScalarAndAddSaturate(Vector128 addend, Vector128 left, Vector64 right) => MultiplyDoublingWideningUpperByScalarAndAddSaturate(addend, left, right); /// - /// int64x2_t vqdmlal_high_n_s32 (int64x2_t a, int32x4_t b, int32_t c) - /// A32: VQDMLAL.S32 Qd, Dn+1, Dm[0] - /// A64: SQDMLAL2 Vd.2D, Vn.4S, Vm.S[0] + /// int64x2_t vqdmlal_high_n_s32 (int64x2_t a, int32x4_t b, int32_t c) + /// A32: VQDMLAL.S32 Qd, Dn+1, Dm[0] + /// A64: SQDMLAL2 Vd.2D, Vn.4S, Vm.S[0] /// public static Vector128 MultiplyDoublingWideningUpperByScalarAndAddSaturate(Vector128 addend, Vector128 left, Vector64 right) => MultiplyDoublingWideningUpperByScalarAndAddSaturate(addend, left, right); /// - /// int32x4_t vqdmlsl_high_n_s16 (int32x4_t a, int16x8_t b, int16_t c) - /// A32: VQDMLSL.S16 Qd, Dn+1, Dm[0] - /// A64: SQDMLSL2 Vd.4S, Vn.8H, Vm.H[0] + /// int32x4_t vqdmlsl_high_n_s16 (int32x4_t a, int16x8_t b, int16_t c) + /// A32: VQDMLSL.S16 Qd, Dn+1, Dm[0] + /// A64: SQDMLSL2 Vd.4S, Vn.8H, Vm.H[0] /// public static Vector128 MultiplyDoublingWideningUpperByScalarAndSubtractSaturate(Vector128 minuend, Vector128 left, Vector64 right) => MultiplyDoublingWideningUpperByScalarAndSubtractSaturate(minuend, left, right); /// - /// int64x2_t vqdmlsl_high_n_s32 (int64x2_t a, int32x4_t b, int32_t c) - /// A32: VQDMLSL.S32 Qd, Dn+1, Dm[0] - /// A64: SQDMLSL2 Vd.2D, Vn.4S, Vm.S[0] + /// int64x2_t vqdmlsl_high_n_s32 (int64x2_t a, int32x4_t b, int32_t c) + /// A32: VQDMLSL.S32 Qd, Dn+1, Dm[0] + /// A64: SQDMLSL2 Vd.2D, Vn.4S, Vm.S[0] /// public static Vector128 MultiplyDoublingWideningUpperByScalarAndSubtractSaturate(Vector128 minuend, Vector128 left, Vector64 right) => MultiplyDoublingWideningUpperByScalarAndSubtractSaturate(minuend, left, right); /// - /// int32x4_t vqdmlal_high_lane_s16 (int32x4_t a, int16x8_t b, int16x4_t v, const int lane) - /// A32: VQDMLAL.S16 Qd, Dn+1, Dm[lane] - /// A64: SQDMLAL2 Vd.4S, Vn.8H, Vm.H[lane] + /// int32x4_t vqdmlal_high_lane_s16 (int32x4_t a, int16x8_t b, int16x4_t v, const int lane) + /// A32: VQDMLAL.S16 Qd, Dn+1, Dm[lane] + /// A64: SQDMLAL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(addend, left, right, rightIndex); /// - /// int32x4_t vqdmlal_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane) - /// A32: VQDMLAL.S16 Qd, Dn+1, Dm[lane] - /// A64: SQDMLAL2 Vd.4S, Vn.8H, Vm.H[lane] + /// int32x4_t vqdmlal_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane) + /// A32: VQDMLAL.S16 Qd, Dn+1, Dm[lane] + /// A64: SQDMLAL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(addend, left, right, rightIndex); /// - /// int64x2_t vqdmlal_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane) - /// A32: VQDMLAL.S32 Qd, Dn+1, Dm[lane] - /// A64: SQDMLAL2 Vd.2D, Vn.4S, Vm.S[lane] + /// int64x2_t vqdmlal_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane) + /// A32: VQDMLAL.S32 Qd, Dn+1, Dm[lane] + /// A64: SQDMLAL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(addend, left, right, rightIndex); /// - /// int64x2_t vqdmlal_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane) - /// A32: VQDMLAL.S32 Qd, Dn+1, Dm[lane] - /// A64: SQDMLAL2 Vd.2D, Vn.4S, Vm.S[lane] + /// int64x2_t vqdmlal_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane) + /// A32: VQDMLAL.S32 Qd, Dn+1, Dm[lane] + /// A64: SQDMLAL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningUpperBySelectedScalarAndAddSaturate(addend, left, right, rightIndex); /// - /// int32x4_t vqdmlsl_high_lane_s16 (int32x4_t a, int16x8_t b, int16x4_t v, const int lane) - /// A32: VQDMLSL.S16 Qd, Dn+1, Dm[lane] - /// A64: SQDMLSL2 Vd.4S, Vn.8H, Vm.H[lane] + /// int32x4_t vqdmlsl_high_lane_s16 (int32x4_t a, int16x8_t b, int16x4_t v, const int lane) + /// A32: VQDMLSL.S16 Qd, Dn+1, Dm[lane] + /// A64: SQDMLSL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex); /// - /// int32x4_t vqdmlsl_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane) - /// A32: VQDMLSL.S16 Qd, Dn+1, Dm[lane] - /// A64: SQDMLSL2 Vd.4S, Vn.8H, Vm.H[lane] + /// int32x4_t vqdmlsl_high_laneq_s16 (int32x4_t a, int16x8_t b, int16x8_t v, const int lane) + /// A32: VQDMLSL.S16 Qd, Dn+1, Dm[lane] + /// A64: SQDMLSL2 Vd.4S, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex); /// - /// int64x2_t vqdmlsl_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane) - /// A32: VQDMLSL.S32 Qd, Dn+1, Dm[lane] - /// A64: SQDMLSL2 Vd.2D, Vn.4S, Vm.S[lane] + /// int64x2_t vqdmlsl_high_lane_s32 (int64x2_t a, int32x4_t b, int32x2_t v, const int lane) + /// A32: VQDMLSL.S32 Qd, Dn+1, Dm[lane] + /// A64: SQDMLSL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex); /// - /// int64x2_t vqdmlsl_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane) - /// A32: VQDMLSL.S32 Qd, Dn+1, Dm[lane] - /// A64: SQDMLSL2 Vd.2D, Vn.4S, Vm.S[lane] + /// int64x2_t vqdmlsl_high_laneq_s32 (int64x2_t a, int32x4_t b, int32x4_t v, const int lane) + /// A32: VQDMLSL.S32 Qd, Dn+1, Dm[lane] + /// A64: SQDMLSL2 Vd.2D, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyDoublingWideningUpperBySelectedScalarAndSubtractSaturate(minuend, left, right, rightIndex); /// - /// int16x4_t vqrdmulh_n_s16 (int16x4_t a, int16_t b) - /// A32: VQRDMULH.S16 Dd, Dn, Dm[0] - /// A64: SQRDMULH Vd.4H, Vn.4H, Vm.H[0] + /// int16x4_t vqrdmulh_n_s16 (int16x4_t a, int16_t b) + /// A32: VQRDMULH.S16 Dd, Dn, Dm[0] + /// A64: SQRDMULH Vd.4H, Vn.4H, Vm.H[0] /// public static Vector64 MultiplyRoundedDoublingByScalarSaturateHigh(Vector64 left, Vector64 right) => MultiplyRoundedDoublingByScalarSaturateHigh(left, right); /// - /// int32x2_t vqrdmulh_n_s32 (int32x2_t a, int32_t b) - /// A32: VQRDMULH.S32 Dd, Dn, Dm[0] - /// A64: SQRDMULH Vd.2S, Vn.2S, Vm.S[0] + /// int32x2_t vqrdmulh_n_s32 (int32x2_t a, int32_t b) + /// A32: VQRDMULH.S32 Dd, Dn, Dm[0] + /// A64: SQRDMULH Vd.2S, Vn.2S, Vm.S[0] /// public static Vector64 MultiplyRoundedDoublingByScalarSaturateHigh(Vector64 left, Vector64 right) => MultiplyRoundedDoublingByScalarSaturateHigh(left, right); /// - /// int16x8_t vqrdmulhq_n_s16 (int16x8_t a, int16_t b) - /// A32: VQRDMULH.S16 Qd, Qn, Dm[0] - /// A64: SQRDMULH Vd.8H, Vn.8H, Vm.H[0] + /// int16x8_t vqrdmulhq_n_s16 (int16x8_t a, int16_t b) + /// A32: VQRDMULH.S16 Qd, Qn, Dm[0] + /// A64: SQRDMULH Vd.8H, Vn.8H, Vm.H[0] /// public static Vector128 MultiplyRoundedDoublingByScalarSaturateHigh(Vector128 left, Vector64 right) => MultiplyRoundedDoublingByScalarSaturateHigh(left, right); /// - /// int32x4_t vqrdmulhq_n_s32 (int32x4_t a, int32_t b) - /// A32: VQRDMULH.S32 Qd, Qn, Dm[0] - /// A64: SQRDMULH Vd.4S, Vn.4S, Vm.S[0] + /// int32x4_t vqrdmulhq_n_s32 (int32x4_t a, int32_t b) + /// A32: VQRDMULH.S32 Qd, Qn, Dm[0] + /// A64: SQRDMULH Vd.4S, Vn.4S, Vm.S[0] /// public static Vector128 MultiplyRoundedDoublingByScalarSaturateHigh(Vector128 left, Vector64 right) => MultiplyRoundedDoublingByScalarSaturateHigh(left, right); /// - /// int16x4_t vqrdmulh_lane_s16 (int16x4_t a, int16x4_t v, const int lane) - /// A32: VQRDMULH.S16 Dd, Dn, Dm[lane] - /// A64: SQRDMULH Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vqrdmulh_lane_s16 (int16x4_t a, int16x4_t v, const int lane) + /// A32: VQRDMULH.S16 Dd, Dn, Dm[lane] + /// A64: SQRDMULH Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarSaturateHigh(left, right, rightIndex); /// - /// int16x4_t vqrdmulh_laneq_s16 (int16x4_t a, int16x8_t v, const int lane) - /// A32: VQRDMULH.S16 Dd, Dn, Dm[lane] - /// A64: SQRDMULH Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vqrdmulh_laneq_s16 (int16x4_t a, int16x8_t v, const int lane) + /// A32: VQRDMULH.S16 Dd, Dn, Dm[lane] + /// A64: SQRDMULH Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarSaturateHigh(left, right, rightIndex); /// - /// int32x2_t vqrdmulh_lane_s32 (int32x2_t a, int32x2_t v, const int lane) - /// A32: VQRDMULH.S32 Dd, Dn, Dm[lane] - /// A64: SQRDMULH Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vqrdmulh_lane_s32 (int32x2_t a, int32x2_t v, const int lane) + /// A32: VQRDMULH.S32 Dd, Dn, Dm[lane] + /// A64: SQRDMULH Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarSaturateHigh(left, right, rightIndex); /// - /// int32x2_t vqrdmulh_laneq_s32 (int32x2_t a, int32x4_t v, const int lane) - /// A32: VQRDMULH.S32 Dd, Dn, Dm[lane] - /// A64: SQRDMULH Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vqrdmulh_laneq_s32 (int32x2_t a, int32x4_t v, const int lane) + /// A32: VQRDMULH.S32 Dd, Dn, Dm[lane] + /// A64: SQRDMULH Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarSaturateHigh(left, right, rightIndex); /// - /// int16x8_t vqrdmulhq_lane_s16 (int16x8_t a, int16x4_t v, const int lane) - /// A32: VQRDMULH.S16 Qd, Qn, Dm[lane] - /// A64: SQRDMULH Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vqrdmulhq_lane_s16 (int16x8_t a, int16x4_t v, const int lane) + /// A32: VQRDMULH.S16 Qd, Qn, Dm[lane] + /// A64: SQRDMULH Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarSaturateHigh(left, right, rightIndex); /// - /// int16x8_t vqrdmulhq_laneq_s16 (int16x8_t a, int16x8_t v, const int lane) - /// A32: VQRDMULH.S16 Qd, Qn, Dm[lane] - /// A64: SQRDMULH Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vqrdmulhq_laneq_s16 (int16x8_t a, int16x8_t v, const int lane) + /// A32: VQRDMULH.S16 Qd, Qn, Dm[lane] + /// A64: SQRDMULH Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarSaturateHigh(left, right, rightIndex); /// - /// int32x4_t vqrdmulhq_lane_s32 (int32x4_t a, int32x2_t v, const int lane) - /// A32: VQRDMULH.S32 Qd, Qn, Dm[lane] - /// A64: SQRDMULH Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vqrdmulhq_lane_s32 (int32x4_t a, int32x2_t v, const int lane) + /// A32: VQRDMULH.S32 Qd, Qn, Dm[lane] + /// A64: SQRDMULH Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarSaturateHigh(left, right, rightIndex); /// - /// int32x4_t vqrdmulhq_laneq_s32 (int32x4_t a, int32x4_t v, const int lane) - /// A32: VQRDMULH.S32 Qd, Qn, Dm[lane] - /// A64: SQRDMULH Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vqrdmulhq_laneq_s32 (int32x4_t a, int32x4_t v, const int lane) + /// A32: VQRDMULH.S32 Qd, Qn, Dm[lane] + /// A64: SQRDMULH Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyRoundedDoublingBySelectedScalarSaturateHigh(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarSaturateHigh(left, right, rightIndex); /// - /// int16x4_t vqrdmulh_s16 (int16x4_t a, int16x4_t b) - /// A32: VQRDMULH.S16 Dd, Dn, Dm - /// A64: SQRDMULH Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vqrdmulh_s16 (int16x4_t a, int16x4_t b) + /// A32: VQRDMULH.S16 Dd, Dn, Dm + /// A64: SQRDMULH Vd.4H, Vn.4H, Vm.4H /// public static Vector64 MultiplyRoundedDoublingSaturateHigh(Vector64 left, Vector64 right) => MultiplyRoundedDoublingSaturateHigh(left, right); /// - /// int32x2_t vqrdmulh_s32 (int32x2_t a, int32x2_t b) - /// A32: VQRDMULH.S32 Dd, Dn, Dm - /// A64: SQRDMULH Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vqrdmulh_s32 (int32x2_t a, int32x2_t b) + /// A32: VQRDMULH.S32 Dd, Dn, Dm + /// A64: SQRDMULH Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MultiplyRoundedDoublingSaturateHigh(Vector64 left, Vector64 right) => MultiplyRoundedDoublingSaturateHigh(left, right); /// - /// int16x8_t vqrdmulhq_s16 (int16x8_t a, int16x8_t b) - /// A32: VQRDMULH.S16 Qd, Qn, Qm - /// A64: SQRDMULH Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vqrdmulhq_s16 (int16x8_t a, int16x8_t b) + /// A32: VQRDMULH.S16 Qd, Qn, Qm + /// A64: SQRDMULH Vd.8H, Vn.8H, Vm.8H /// public static Vector128 MultiplyRoundedDoublingSaturateHigh(Vector128 left, Vector128 right) => MultiplyRoundedDoublingSaturateHigh(left, right); /// - /// int32x4_t vqrdmulhq_s32 (int32x4_t a, int32x4_t b) - /// A32: VQRDMULH.S32 Qd, Qn, Qm - /// A64: SQRDMULH Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vqrdmulhq_s32 (int32x4_t a, int32x4_t b) + /// A32: VQRDMULH.S32 Qd, Qn, Qm + /// A64: SQRDMULH Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MultiplyRoundedDoublingSaturateHigh(Vector128 left, Vector128 right) => MultiplyRoundedDoublingSaturateHigh(left, right); /// - /// float64x1_t vmul_f64 (float64x1_t a, float64x1_t b) - /// A32: VMUL.F64 Dd, Dn, Dm - /// A64: FMUL Dd, Dn, Dm + /// float64x1_t vmul_f64 (float64x1_t a, float64x1_t b) + /// A32: VMUL.F64 Dd, Dn, Dm + /// A64: FMUL Dd, Dn, Dm /// public static Vector64 MultiplyScalar(Vector64 left, Vector64 right) => MultiplyScalar(left, right); /// - /// float32_t vmuls_f32 (float32_t a, float32_t b) - /// A32: VMUL.F32 Sd, Sn, Sm - /// A64: FMUL Sd, Sn, Sm - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vmuls_f32 (float32_t a, float32_t b) + /// A32: VMUL.F32 Sd, Sn, Sm + /// A64: FMUL Sd, Sn, Sm + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 MultiplyScalar(Vector64 left, Vector64 right) => MultiplyScalar(left, right); /// - /// float32_t vmuls_lane_f32 (float32_t a, float32x2_t v, const int lane) - /// A32: VMUL.F32 Sd, Sn, Dm[lane] - /// A64: FMUL Sd, Sn, Vm.S[lane] + /// float32_t vmuls_lane_f32 (float32_t a, float32x2_t v, const int lane) + /// A32: VMUL.F32 Sd, Sn, Dm[lane] + /// A64: FMUL Sd, Sn, Vm.S[lane] /// public static Vector64 MultiplyScalarBySelectedScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyScalarBySelectedScalar(left, right, rightIndex); /// - /// float32_t vmuls_laneq_f32 (float32_t a, float32x4_t v, const int lane) - /// A32: VMUL.F32 Sd, Sn, Dm[lane] - /// A64: FMUL Sd, Sn, Vm.S[lane] + /// float32_t vmuls_laneq_f32 (float32_t a, float32x4_t v, const int lane) + /// A32: VMUL.F32 Sd, Sn, Dm[lane] + /// A64: FMUL Sd, Sn, Vm.S[lane] /// public static Vector64 MultiplyScalarBySelectedScalar(Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyScalarBySelectedScalar(left, right, rightIndex); /// - /// uint8x8_t vmls_u8 (uint8x8_t a, uint8x8_t b, uint8x8_t c) - /// A32: VMLS.I8 Dd, Dn, Dm - /// A64: MLS Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vmls_u8 (uint8x8_t a, uint8x8_t b, uint8x8_t c) + /// A32: VMLS.I8 Dd, Dn, Dm + /// A64: MLS Vd.8B, Vn.8B, Vm.8B /// public static Vector64 MultiplySubtract(Vector64 minuend, Vector64 left, Vector64 right) => MultiplySubtract(minuend, left, right); /// - /// int16x4_t vmls_s16 (int16x4_t a, int16x4_t b, int16x4_t c) - /// A32: VMLS.I16 Dd, Dn, Dm - /// A64: MLS Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vmls_s16 (int16x4_t a, int16x4_t b, int16x4_t c) + /// A32: VMLS.I16 Dd, Dn, Dm + /// A64: MLS Vd.4H, Vn.4H, Vm.4H /// public static Vector64 MultiplySubtract(Vector64 minuend, Vector64 left, Vector64 right) => MultiplySubtract(minuend, left, right); /// - /// int32x2_t vmls_s32 (int32x2_t a, int32x2_t b, int32x2_t c) - /// A32: VMLS.I32 Dd, Dn, Dm - /// A64: MLS Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vmls_s32 (int32x2_t a, int32x2_t b, int32x2_t c) + /// A32: VMLS.I32 Dd, Dn, Dm + /// A64: MLS Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MultiplySubtract(Vector64 minuend, Vector64 left, Vector64 right) => MultiplySubtract(minuend, left, right); /// - /// int8x8_t vmls_s8 (int8x8_t a, int8x8_t b, int8x8_t c) - /// A32: VMLS.I8 Dd, Dn, Dm - /// A64: MLS Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vmls_s8 (int8x8_t a, int8x8_t b, int8x8_t c) + /// A32: VMLS.I8 Dd, Dn, Dm + /// A64: MLS Vd.8B, Vn.8B, Vm.8B /// public static Vector64 MultiplySubtract(Vector64 minuend, Vector64 left, Vector64 right) => MultiplySubtract(minuend, left, right); /// - /// uint16x4_t vmls_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t c) - /// A32: VMLS.I16 Dd, Dn, Dm - /// A64: MLS Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vmls_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t c) + /// A32: VMLS.I16 Dd, Dn, Dm + /// A64: MLS Vd.4H, Vn.4H, Vm.4H /// public static Vector64 MultiplySubtract(Vector64 minuend, Vector64 left, Vector64 right) => MultiplySubtract(minuend, left, right); /// - /// uint32x2_t vmls_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t c) - /// A32: VMLS.I32 Dd, Dn, Dm - /// A64: MLS Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vmls_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t c) + /// A32: VMLS.I32 Dd, Dn, Dm + /// A64: MLS Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MultiplySubtract(Vector64 minuend, Vector64 left, Vector64 right) => MultiplySubtract(minuend, left, right); /// - /// uint8x16_t vmlsq_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c) - /// A32: VMLS.I8 Qd, Qn, Qm - /// A64: MLS Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vmlsq_u8 (uint8x16_t a, uint8x16_t b, uint8x16_t c) + /// A32: VMLS.I8 Qd, Qn, Qm + /// A64: MLS Vd.16B, Vn.16B, Vm.16B /// public static Vector128 MultiplySubtract(Vector128 minuend, Vector128 left, Vector128 right) => MultiplySubtract(minuend, left, right); /// - /// int16x8_t vmlsq_s16 (int16x8_t a, int16x8_t b, int16x8_t c) - /// A32: VMLS.I16 Qd, Qn, Qm - /// A64: MLS Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vmlsq_s16 (int16x8_t a, int16x8_t b, int16x8_t c) + /// A32: VMLS.I16 Qd, Qn, Qm + /// A64: MLS Vd.8H, Vn.8H, Vm.8H /// public static Vector128 MultiplySubtract(Vector128 minuend, Vector128 left, Vector128 right) => MultiplySubtract(minuend, left, right); /// - /// int32x4_t vmlsq_s32 (int32x4_t a, int32x4_t b, int32x4_t c) - /// A32: VMLS.I32 Qd, Qn, Qm - /// A64: MLS Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vmlsq_s32 (int32x4_t a, int32x4_t b, int32x4_t c) + /// A32: VMLS.I32 Qd, Qn, Qm + /// A64: MLS Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MultiplySubtract(Vector128 minuend, Vector128 left, Vector128 right) => MultiplySubtract(minuend, left, right); /// - /// int8x16_t vmlsq_s8 (int8x16_t a, int8x16_t b, int8x16_t c) - /// A32: VMLS.I8 Qd, Qn, Qm - /// A64: MLS Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vmlsq_s8 (int8x16_t a, int8x16_t b, int8x16_t c) + /// A32: VMLS.I8 Qd, Qn, Qm + /// A64: MLS Vd.16B, Vn.16B, Vm.16B /// public static Vector128 MultiplySubtract(Vector128 minuend, Vector128 left, Vector128 right) => MultiplySubtract(minuend, left, right); /// - /// uint16x8_t vmlsq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c) - /// A32: VMLS.I16 Qd, Qn, Qm - /// A64: MLS Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vmlsq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t c) + /// A32: VMLS.I16 Qd, Qn, Qm + /// A64: MLS Vd.8H, Vn.8H, Vm.8H /// public static Vector128 MultiplySubtract(Vector128 minuend, Vector128 left, Vector128 right) => MultiplySubtract(minuend, left, right); /// - /// uint32x4_t vmlsq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c) - /// A32: VMLS.I32 Qd, Qn, Qm - /// A64: MLS Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vmlsq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t c) + /// A32: VMLS.I32 Qd, Qn, Qm + /// A64: MLS Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MultiplySubtract(Vector128 minuend, Vector128 left, Vector128 right) => MultiplySubtract(minuend, left, right); /// - /// int16x4_t vmls_n_s16 (int16x4_t a, int16x4_t b, int16_t c) - /// A32: VMLS.I16 Dd, Dn, Dm[0] - /// A64: MLS Vd.4H, Vn.4H, Vm.H[0] + /// int16x4_t vmls_n_s16 (int16x4_t a, int16x4_t b, int16_t c) + /// A32: VMLS.I16 Dd, Dn, Dm[0] + /// A64: MLS Vd.4H, Vn.4H, Vm.H[0] /// public static Vector64 MultiplySubtractByScalar(Vector64 minuend, Vector64 left, Vector64 right) => MultiplySubtractByScalar(minuend, left, right); /// - /// int32x2_t vmls_n_s32 (int32x2_t a, int32x2_t b, int32_t c) - /// A32: VMLS.I32 Dd, Dn, Dm[0] - /// A64: MLS Vd.2S, Vn.2S, Vm.S[0] + /// int32x2_t vmls_n_s32 (int32x2_t a, int32x2_t b, int32_t c) + /// A32: VMLS.I32 Dd, Dn, Dm[0] + /// A64: MLS Vd.2S, Vn.2S, Vm.S[0] /// public static Vector64 MultiplySubtractByScalar(Vector64 minuend, Vector64 left, Vector64 right) => MultiplySubtractByScalar(minuend, left, right); /// - /// uint16x4_t vmls_n_u16 (uint16x4_t a, uint16x4_t b, uint16_t c) - /// A32: VMLS.I16 Dd, Dn, Dm[0] - /// A64: MLS Vd.4H, Vn.4H, Vm.H[0] + /// uint16x4_t vmls_n_u16 (uint16x4_t a, uint16x4_t b, uint16_t c) + /// A32: VMLS.I16 Dd, Dn, Dm[0] + /// A64: MLS Vd.4H, Vn.4H, Vm.H[0] /// public static Vector64 MultiplySubtractByScalar(Vector64 minuend, Vector64 left, Vector64 right) => MultiplySubtractByScalar(minuend, left, right); /// - /// uint32x2_t vmls_n_u32 (uint32x2_t a, uint32x2_t b, uint32_t c) - /// A32: VMLS.I32 Dd, Dn, Dm[0] - /// A64: MLS Vd.2S, Vn.2S, Vm.S[0] + /// uint32x2_t vmls_n_u32 (uint32x2_t a, uint32x2_t b, uint32_t c) + /// A32: VMLS.I32 Dd, Dn, Dm[0] + /// A64: MLS Vd.2S, Vn.2S, Vm.S[0] /// public static Vector64 MultiplySubtractByScalar(Vector64 minuend, Vector64 left, Vector64 right) => MultiplySubtractByScalar(minuend, left, right); /// - /// int16x8_t vmlsq_n_s16 (int16x8_t a, int16x8_t b, int16_t c) - /// A32: VMLS.I16 Qd, Qn, Dm[0] - /// A64: MLS Vd.8H, Vn.8H, Vm.H[0] + /// int16x8_t vmlsq_n_s16 (int16x8_t a, int16x8_t b, int16_t c) + /// A32: VMLS.I16 Qd, Qn, Dm[0] + /// A64: MLS Vd.8H, Vn.8H, Vm.H[0] /// public static Vector128 MultiplySubtractByScalar(Vector128 minuend, Vector128 left, Vector64 right) => MultiplySubtractByScalar(minuend, left, right); /// - /// int32x4_t vmlsq_n_s32 (int32x4_t a, int32x4_t b, int32_t c) - /// A32: VMLS.I32 Qd, Qn, Dm[0] - /// A64: MLS Vd.4S, Vn.4S, Vm.S[0] + /// int32x4_t vmlsq_n_s32 (int32x4_t a, int32x4_t b, int32_t c) + /// A32: VMLS.I32 Qd, Qn, Dm[0] + /// A64: MLS Vd.4S, Vn.4S, Vm.S[0] /// public static Vector128 MultiplySubtractByScalar(Vector128 minuend, Vector128 left, Vector64 right) => MultiplySubtractByScalar(minuend, left, right); /// - /// uint16x8_t vmlsq_n_u16 (uint16x8_t a, uint16x8_t b, uint16_t c) - /// A32: VMLS.I16 Qd, Qn, Dm[0] - /// A64: MLS Vd.8H, Vn.8H, Vm.H[0] + /// uint16x8_t vmlsq_n_u16 (uint16x8_t a, uint16x8_t b, uint16_t c) + /// A32: VMLS.I16 Qd, Qn, Dm[0] + /// A64: MLS Vd.8H, Vn.8H, Vm.H[0] /// public static Vector128 MultiplySubtractByScalar(Vector128 minuend, Vector128 left, Vector64 right) => MultiplySubtractByScalar(minuend, left, right); /// - /// uint32x4_t vmlsq_n_u32 (uint32x4_t a, uint32x4_t b, uint32_t c) - /// A32: VMLS.I32 Qd, Qn, Dm[0] - /// A64: MLS Vd.4S, Vn.4S, Vm.S[0] + /// uint32x4_t vmlsq_n_u32 (uint32x4_t a, uint32x4_t b, uint32_t c) + /// A32: VMLS.I32 Qd, Qn, Dm[0] + /// A64: MLS Vd.4S, Vn.4S, Vm.S[0] /// public static Vector128 MultiplySubtractByScalar(Vector128 minuend, Vector128 left, Vector64 right) => MultiplySubtractByScalar(minuend, left, right); /// - /// int16x4_t vmls_lane_s16 (int16x4_t a, int16x4_t b, int16x4_t v, const int lane) - /// A32: VMLS.I16 Dd, Dn, Dm[lane] - /// A64: MLS Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vmls_lane_s16 (int16x4_t a, int16x4_t b, int16x4_t v, const int lane) + /// A32: VMLS.I16 Dd, Dn, Dm[lane] + /// A64: MLS Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplySubtractBySelectedScalar(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); /// - /// int16x4_t vmls_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane) - /// A32: VMLS.I16 Dd, Dn, Dm[lane] - /// A64: MLS Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vmls_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane) + /// A32: VMLS.I16 Dd, Dn, Dm[lane] + /// A64: MLS Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplySubtractBySelectedScalar(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); /// - /// int32x2_t vmls_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane) - /// A32: VMLS.I32 Dd, Dn, Dm[lane] - /// A64: MLS Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vmls_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane) + /// A32: VMLS.I32 Dd, Dn, Dm[lane] + /// A64: MLS Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplySubtractBySelectedScalar(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); /// - /// int32x2_t vmls_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane) - /// A32: VMLS.I32 Dd, Dn, Dm[lane] - /// A64: MLS Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vmls_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane) + /// A32: VMLS.I32 Dd, Dn, Dm[lane] + /// A64: MLS Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplySubtractBySelectedScalar(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); /// - /// uint16x4_t vmls_lane_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t v, const int lane) - /// A32: VMLS.I16 Dd, Dn, Dm[lane] - /// A64: MLS Vd.4H, Vn.4H, Vm.H[lane] + /// uint16x4_t vmls_lane_u16 (uint16x4_t a, uint16x4_t b, uint16x4_t v, const int lane) + /// A32: VMLS.I16 Dd, Dn, Dm[lane] + /// A64: MLS Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplySubtractBySelectedScalar(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); /// - /// uint16x4_t vmls_laneq_u16 (uint16x4_t a, uint16x4_t b, uint16x8_t v, const int lane) - /// A32: VMLS.I16 Dd, Dn, Dm[lane] - /// A64: MLS Vd.4H, Vn.4H, Vm.H[lane] + /// uint16x4_t vmls_laneq_u16 (uint16x4_t a, uint16x4_t b, uint16x8_t v, const int lane) + /// A32: VMLS.I16 Dd, Dn, Dm[lane] + /// A64: MLS Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplySubtractBySelectedScalar(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); /// - /// uint32x2_t vmls_lane_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t v, const int lane) - /// A32: VMLS.I32 Dd, Dn, Dm[lane] - /// A64: MLS Vd.2S, Vn.2S, Vm.S[lane] + /// uint32x2_t vmls_lane_u32 (uint32x2_t a, uint32x2_t b, uint32x2_t v, const int lane) + /// A32: VMLS.I32 Dd, Dn, Dm[lane] + /// A64: MLS Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplySubtractBySelectedScalar(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); /// - /// uint32x2_t vmls_laneq_u32 (uint32x2_t a, uint32x2_t b, uint32x4_t v, const int lane) - /// A32: VMLS.I32 Dd, Dn, Dm[lane] - /// A64: MLS Vd.2S, Vn.2S, Vm.S[lane] + /// uint32x2_t vmls_laneq_u32 (uint32x2_t a, uint32x2_t b, uint32x4_t v, const int lane) + /// A32: VMLS.I32 Dd, Dn, Dm[lane] + /// A64: MLS Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplySubtractBySelectedScalar(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); /// - /// int16x8_t vmlsq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane) - /// A32: VMLS.I16 Qd, Qn, Dm[lane] - /// A64: MLS Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vmlsq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane) + /// A32: VMLS.I16 Qd, Qn, Dm[lane] + /// A64: MLS Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); /// - /// int16x8_t vmlsq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane) - /// A32: VMLS.I16 Qd, Qn, Dm[lane] - /// A64: MLS Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vmlsq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane) + /// A32: VMLS.I16 Qd, Qn, Dm[lane] + /// A64: MLS Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); /// - /// int32x4_t vmlsq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane) - /// A32: VMLS.I32 Qd, Qn, Dm[lane] - /// A64: MLS Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vmlsq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane) + /// A32: VMLS.I32 Qd, Qn, Dm[lane] + /// A64: MLS Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); /// - /// int32x4_t vmlsq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane) - /// A32: VMLS.I32 Qd, Qn, Dm[lane] - /// A64: MLS Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vmlsq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane) + /// A32: VMLS.I32 Qd, Qn, Dm[lane] + /// A64: MLS Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); /// - /// uint16x8_t vmlsq_lane_u16 (uint16x8_t a, uint16x8_t b, uint16x4_t v, const int lane) - /// A32: VMLS.I16 Qd, Qn, Dm[lane] - /// A64: MLS Vd.8H, Vn.8H, Vm.H[lane] + /// uint16x8_t vmlsq_lane_u16 (uint16x8_t a, uint16x8_t b, uint16x4_t v, const int lane) + /// A32: VMLS.I16 Qd, Qn, Dm[lane] + /// A64: MLS Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); /// - /// uint16x8_t vmlsq_laneq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t v, const int lane) - /// A32: VMLS.I16 Qd, Qn, Dm[lane] - /// A64: MLS Vd.8H, Vn.8H, Vm.H[lane] + /// uint16x8_t vmlsq_laneq_u16 (uint16x8_t a, uint16x8_t b, uint16x8_t v, const int lane) + /// A32: VMLS.I16 Qd, Qn, Dm[lane] + /// A64: MLS Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); /// - /// uint32x4_t vmlsq_lane_u32 (uint32x4_t a, uint32x4_t b, uint32x2_t v, const int lane) - /// A32: VMLS.I32 Qd, Qn, Dm[lane] - /// A64: MLS Vd.4S, Vn.4S, Vm.S[lane] + /// uint32x4_t vmlsq_lane_u32 (uint32x4_t a, uint32x4_t b, uint32x2_t v, const int lane) + /// A32: VMLS.I32 Qd, Qn, Dm[lane] + /// A64: MLS Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); /// - /// uint32x4_t vmlsq_laneq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t v, const int lane) - /// A32: VMLS.I32 Qd, Qn, Dm[lane] - /// A64: MLS Vd.4S, Vn.4S, Vm.S[lane] + /// uint32x4_t vmlsq_laneq_u32 (uint32x4_t a, uint32x4_t b, uint32x4_t v, const int lane) + /// A32: VMLS.I32 Qd, Qn, Dm[lane] + /// A64: MLS Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplySubtractBySelectedScalar(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); /// - /// uint16x8_t vmull_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VMULL.U8 Qd, Dn, Dm - /// A64: UMULL Vd.8H, Vn.8B, Vm.8B + /// uint16x8_t vmull_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VMULL.U8 Qd, Dn, Dm + /// A64: UMULL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 MultiplyWideningLower(Vector64 left, Vector64 right) => MultiplyWideningLower(left, right); /// - /// int32x4_t vmull_s16 (int16x4_t a, int16x4_t b) - /// A32: VMULL.S16 Qd, Dn, Dm - /// A64: SMULL Vd.4S, Vn.4H, Vm.4H + /// int32x4_t vmull_s16 (int16x4_t a, int16x4_t b) + /// A32: VMULL.S16 Qd, Dn, Dm + /// A64: SMULL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 MultiplyWideningLower(Vector64 left, Vector64 right) => MultiplyWideningLower(left, right); /// - /// int64x2_t vmull_s32 (int32x2_t a, int32x2_t b) - /// A32: VMULL.S32 Qd, Dn, Dm - /// A64: SMULL Vd.2D, Vn.2S, Vm.2S + /// int64x2_t vmull_s32 (int32x2_t a, int32x2_t b) + /// A32: VMULL.S32 Qd, Dn, Dm + /// A64: SMULL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 MultiplyWideningLower(Vector64 left, Vector64 right) => MultiplyWideningLower(left, right); /// - /// int16x8_t vmull_s8 (int8x8_t a, int8x8_t b) - /// A32: VMULL.S8 Qd, Dn, Dm - /// A64: SMULL Vd.8H, Vn.8B, Vm.8B + /// int16x8_t vmull_s8 (int8x8_t a, int8x8_t b) + /// A32: VMULL.S8 Qd, Dn, Dm + /// A64: SMULL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 MultiplyWideningLower(Vector64 left, Vector64 right) => MultiplyWideningLower(left, right); /// - /// uint32x4_t vmull_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VMULL.U16 Qd, Dn, Dm - /// A64: UMULL Vd.4S, Vn.4H, Vm.4H + /// uint32x4_t vmull_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VMULL.U16 Qd, Dn, Dm + /// A64: UMULL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 MultiplyWideningLower(Vector64 left, Vector64 right) => MultiplyWideningLower(left, right); /// - /// uint64x2_t vmull_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VMULL.U32 Qd, Dn, Dm - /// A64: UMULL Vd.2D, Vn.2S, Vm.2S + /// uint64x2_t vmull_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VMULL.U32 Qd, Dn, Dm + /// A64: UMULL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 MultiplyWideningLower(Vector64 left, Vector64 right) => MultiplyWideningLower(left, right); /// - /// uint16x8_t vmlal_u8 (uint16x8_t a, uint8x8_t b, uint8x8_t c) - /// A32: VMLAL.U8 Qd, Dn, Dm - /// A64: UMLAL Vd.8H, Vn.8B, Vm.8B + /// uint16x8_t vmlal_u8 (uint16x8_t a, uint8x8_t b, uint8x8_t c) + /// A32: VMLAL.U8 Qd, Dn, Dm + /// A64: UMLAL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 MultiplyWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right) => MultiplyWideningLowerAndAdd(addend, left, right); /// - /// int32x4_t vmlal_s16 (int32x4_t a, int16x4_t b, int16x4_t c) - /// A32: VMLAL.S16 Qd, Dn, Dm - /// A64: SMLAL Vd.4S, Vn.4H, Vm.4H + /// int32x4_t vmlal_s16 (int32x4_t a, int16x4_t b, int16x4_t c) + /// A32: VMLAL.S16 Qd, Dn, Dm + /// A64: SMLAL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 MultiplyWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right) => MultiplyWideningLowerAndAdd(addend, left, right); /// - /// int64x2_t vmlal_s32 (int64x2_t a, int32x2_t b, int32x2_t c) - /// A32: VMLAL.S32 Qd, Dn, Dm - /// A64: SMLAL Vd.2D, Vn.2S, Vm.2S + /// int64x2_t vmlal_s32 (int64x2_t a, int32x2_t b, int32x2_t c) + /// A32: VMLAL.S32 Qd, Dn, Dm + /// A64: SMLAL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 MultiplyWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right) => MultiplyWideningLowerAndAdd(addend, left, right); /// - /// int16x8_t vmlal_s8 (int16x8_t a, int8x8_t b, int8x8_t c) - /// A32: VMLAL.S8 Qd, Dn, Dm - /// A64: SMLAL Vd.8H, Vn.8B, Vm.8B + /// int16x8_t vmlal_s8 (int16x8_t a, int8x8_t b, int8x8_t c) + /// A32: VMLAL.S8 Qd, Dn, Dm + /// A64: SMLAL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 MultiplyWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right) => MultiplyWideningLowerAndAdd(addend, left, right); /// - /// uint32x4_t vmlal_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t c) - /// A32: VMLAL.U16 Qd, Dn, Dm - /// A64: UMLAL Vd.4S, Vn.4H, Vm.4H + /// uint32x4_t vmlal_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t c) + /// A32: VMLAL.U16 Qd, Dn, Dm + /// A64: UMLAL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 MultiplyWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right) => MultiplyWideningLowerAndAdd(addend, left, right); /// - /// uint64x2_t vmlal_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t c) - /// A32: VMLAL.U32 Qd, Dn, Dm - /// A64: UMLAL Vd.2D, Vn.2S, Vm.2S + /// uint64x2_t vmlal_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t c) + /// A32: VMLAL.U32 Qd, Dn, Dm + /// A64: UMLAL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 MultiplyWideningLowerAndAdd(Vector128 addend, Vector64 left, Vector64 right) => MultiplyWideningLowerAndAdd(addend, left, right); /// - /// uint16x8_t vmlsl_u8 (uint16x8_t a, uint8x8_t b, uint8x8_t c) - /// A32: VMLSL.U8 Qd, Dn, Dm - /// A64: UMLSL Vd.8H, Vn.8B, Vm.8B + /// uint16x8_t vmlsl_u8 (uint16x8_t a, uint8x8_t b, uint8x8_t c) + /// A32: VMLSL.U8 Qd, Dn, Dm + /// A64: UMLSL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 MultiplyWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector64 right) => MultiplyWideningLowerAndSubtract(minuend, left, right); /// - /// int32x4_t vmlsl_s16 (int32x4_t a, int16x4_t b, int16x4_t c) - /// A32: VMLSL.S16 Qd, Dn, Dm - /// A64: SMLSL Vd.4S, Vn.4H, Vm.4H + /// int32x4_t vmlsl_s16 (int32x4_t a, int16x4_t b, int16x4_t c) + /// A32: VMLSL.S16 Qd, Dn, Dm + /// A64: SMLSL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 MultiplyWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector64 right) => MultiplyWideningLowerAndSubtract(minuend, left, right); /// - /// int64x2_t vmlsl_s32 (int64x2_t a, int32x2_t b, int32x2_t c) - /// A32: VMLSL.S32 Qd, Dn, Dm - /// A64: SMLSL Vd.2D, Vn.2S, Vm.2S + /// int64x2_t vmlsl_s32 (int64x2_t a, int32x2_t b, int32x2_t c) + /// A32: VMLSL.S32 Qd, Dn, Dm + /// A64: SMLSL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 MultiplyWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector64 right) => MultiplyWideningLowerAndSubtract(minuend, left, right); /// - /// int16x8_t vmlsl_s8 (int16x8_t a, int8x8_t b, int8x8_t c) - /// A32: VMLSL.S8 Qd, Dn, Dm - /// A64: SMLSL Vd.8H, Vn.8B, Vm.8B + /// int16x8_t vmlsl_s8 (int16x8_t a, int8x8_t b, int8x8_t c) + /// A32: VMLSL.S8 Qd, Dn, Dm + /// A64: SMLSL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 MultiplyWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector64 right) => MultiplyWideningLowerAndSubtract(minuend, left, right); /// - /// uint32x4_t vmlsl_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t c) - /// A32: VMLSL.U16 Qd, Dn, Dm - /// A64: UMLSL Vd.4S, Vn.4H, Vm.4H + /// uint32x4_t vmlsl_u16 (uint32x4_t a, uint16x4_t b, uint16x4_t c) + /// A32: VMLSL.U16 Qd, Dn, Dm + /// A64: UMLSL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 MultiplyWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector64 right) => MultiplyWideningLowerAndSubtract(minuend, left, right); /// - /// uint64x2_t vmlsl_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t c) - /// A32: VMLSL.U32 Qd, Dn, Dm - /// A64: UMLSL Vd.2D, Vn.2S, Vm.2S + /// uint64x2_t vmlsl_u32 (uint64x2_t a, uint32x2_t b, uint32x2_t c) + /// A32: VMLSL.U32 Qd, Dn, Dm + /// A64: UMLSL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 MultiplyWideningLowerAndSubtract(Vector128 minuend, Vector64 left, Vector64 right) => MultiplyWideningLowerAndSubtract(minuend, left, right); /// - /// uint16x8_t vmull_high_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VMULL.U8 Qd, Dn+1, Dm+1 - /// A64: UMULL2 Vd.8H, Vn.16B, Vm.16B + /// uint16x8_t vmull_high_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VMULL.U8 Qd, Dn+1, Dm+1 + /// A64: UMULL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 MultiplyWideningUpper(Vector128 left, Vector128 right) => MultiplyWideningUpper(left, right); /// - /// int32x4_t vmull_high_s16 (int16x8_t a, int16x8_t b) - /// A32: VMULL.S16 Qd, Dn+1, Dm+1 - /// A64: SMULL2 Vd.4S, Vn.8H, Vm.8H + /// int32x4_t vmull_high_s16 (int16x8_t a, int16x8_t b) + /// A32: VMULL.S16 Qd, Dn+1, Dm+1 + /// A64: SMULL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 MultiplyWideningUpper(Vector128 left, Vector128 right) => MultiplyWideningUpper(left, right); /// - /// int64x2_t vmull_high_s32 (int32x4_t a, int32x4_t b) - /// A32: VMULL.S32 Qd, Dn+1, Dm+1 - /// A64: SMULL2 Vd.2D, Vn.4S, Vm.4S + /// int64x2_t vmull_high_s32 (int32x4_t a, int32x4_t b) + /// A32: VMULL.S32 Qd, Dn+1, Dm+1 + /// A64: SMULL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 MultiplyWideningUpper(Vector128 left, Vector128 right) => MultiplyWideningUpper(left, right); /// - /// int16x8_t vmull_high_s8 (int8x16_t a, int8x16_t b) - /// A32: VMULL.S8 Qd, Dn+1, Dm+1 - /// A64: SMULL2 Vd.8H, Vn.16B, Vm.16B + /// int16x8_t vmull_high_s8 (int8x16_t a, int8x16_t b) + /// A32: VMULL.S8 Qd, Dn+1, Dm+1 + /// A64: SMULL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 MultiplyWideningUpper(Vector128 left, Vector128 right) => MultiplyWideningUpper(left, right); /// - /// uint32x4_t vmull_high_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VMULL.U16 Qd, Dn+1, Dm+1 - /// A64: UMULL2 Vd.4S, Vn.8H, Vm.8H + /// uint32x4_t vmull_high_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VMULL.U16 Qd, Dn+1, Dm+1 + /// A64: UMULL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 MultiplyWideningUpper(Vector128 left, Vector128 right) => MultiplyWideningUpper(left, right); /// - /// uint64x2_t vmull_high_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VMULL.U32 Qd, Dn+1, Dm+1 - /// A64: UMULL2 Vd.2D, Vn.4S, Vm.4S + /// uint64x2_t vmull_high_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VMULL.U32 Qd, Dn+1, Dm+1 + /// A64: UMULL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 MultiplyWideningUpper(Vector128 left, Vector128 right) => MultiplyWideningUpper(left, right); /// - /// uint16x8_t vmlal_high_u8 (uint16x8_t a, uint8x16_t b, uint8x16_t c) - /// A32: VMLAL.U8 Qd, Dn+1, Dm+1 - /// A64: UMLAL2 Vd.8H, Vn.16B, Vm.16B + /// uint16x8_t vmlal_high_u8 (uint16x8_t a, uint8x16_t b, uint8x16_t c) + /// A32: VMLAL.U8 Qd, Dn+1, Dm+1 + /// A64: UMLAL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 MultiplyWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right) => MultiplyWideningUpperAndAdd(addend, left, right); /// - /// int32x4_t vmlal_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c) - /// A32: VMLAL.S16 Qd, Dn+1, Dm+1 - /// A64: SMLAL2 Vd.4S, Vn.8H, Vm.8H + /// int32x4_t vmlal_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c) + /// A32: VMLAL.S16 Qd, Dn+1, Dm+1 + /// A64: SMLAL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 MultiplyWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right) => MultiplyWideningUpperAndAdd(addend, left, right); /// - /// int64x2_t vmlal_high_s32 (int64x2_t a, int32x4_t b, int32x4_t c) - /// A32: VMLAL.S32 Qd, Dn+1, Dm+1 - /// A64: SMLAL2 Vd.2D, Vn.4S, Vm.4S + /// int64x2_t vmlal_high_s32 (int64x2_t a, int32x4_t b, int32x4_t c) + /// A32: VMLAL.S32 Qd, Dn+1, Dm+1 + /// A64: SMLAL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 MultiplyWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right) => MultiplyWideningUpperAndAdd(addend, left, right); /// - /// int16x8_t vmlal_high_s8 (int16x8_t a, int8x16_t b, int8x16_t c) - /// A32: VMLAL.S8 Qd, Dn+1, Dm+1 - /// A64: SMLAL2 Vd.8H, Vn.16B, Vm.16B + /// int16x8_t vmlal_high_s8 (int16x8_t a, int8x16_t b, int8x16_t c) + /// A32: VMLAL.S8 Qd, Dn+1, Dm+1 + /// A64: SMLAL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 MultiplyWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right) => MultiplyWideningUpperAndAdd(addend, left, right); /// - /// uint32x4_t vmlal_high_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t c) - /// A32: VMLAL.U16 Qd, Dn+1, Dm+1 - /// A64: UMLAL2 Vd.4S, Vn.8H, Vm.8H + /// uint32x4_t vmlal_high_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t c) + /// A32: VMLAL.U16 Qd, Dn+1, Dm+1 + /// A64: UMLAL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 MultiplyWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right) => MultiplyWideningUpperAndAdd(addend, left, right); /// - /// uint64x2_t vmlal_high_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t c) - /// A32: VMLAL.U32 Qd, Dn+1, Dm+1 - /// A64: UMLAL2 Vd.2D, Vn.4S, Vm.4S + /// uint64x2_t vmlal_high_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t c) + /// A32: VMLAL.U32 Qd, Dn+1, Dm+1 + /// A64: UMLAL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 MultiplyWideningUpperAndAdd(Vector128 addend, Vector128 left, Vector128 right) => MultiplyWideningUpperAndAdd(addend, left, right); /// - /// uint16x8_t vmlsl_high_u8 (uint16x8_t a, uint8x16_t b, uint8x16_t c) - /// A32: VMLSL.U8 Qd, Dn+1, Dm+1 - /// A64: UMLSL2 Vd.8H, Vn.16B, Vm.16B + /// uint16x8_t vmlsl_high_u8 (uint16x8_t a, uint8x16_t b, uint8x16_t c) + /// A32: VMLSL.U8 Qd, Dn+1, Dm+1 + /// A64: UMLSL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 MultiplyWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector128 right) => MultiplyWideningUpperAndSubtract(minuend, left, right); /// - /// int32x4_t vmlsl_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c) - /// A32: VMLSL.S16 Qd, Dn+1, Dm+1 - /// A64: SMLSL2 Vd.4S, Vn.8H, Vm.8H + /// int32x4_t vmlsl_high_s16 (int32x4_t a, int16x8_t b, int16x8_t c) + /// A32: VMLSL.S16 Qd, Dn+1, Dm+1 + /// A64: SMLSL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 MultiplyWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector128 right) => MultiplyWideningUpperAndSubtract(minuend, left, right); /// - /// int64x2_t vmlsl_high_s32 (int64x2_t a, int32x4_t b, int32x4_t c) - /// A32: VMLSL.S32 Qd, Dn+1, Dm+1 - /// A64: SMLSL2 Vd.2D, Vn.4S, Vm.4S + /// int64x2_t vmlsl_high_s32 (int64x2_t a, int32x4_t b, int32x4_t c) + /// A32: VMLSL.S32 Qd, Dn+1, Dm+1 + /// A64: SMLSL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 MultiplyWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector128 right) => MultiplyWideningUpperAndSubtract(minuend, left, right); /// - /// int16x8_t vmlsl_high_s8 (int16x8_t a, int8x16_t b, int8x16_t c) - /// A32: VMLSL.S8 Qd, Dn+1, Dm+1 - /// A64: SMLSL2 Vd.8H, Vn.16B, Vm.16B + /// int16x8_t vmlsl_high_s8 (int16x8_t a, int8x16_t b, int8x16_t c) + /// A32: VMLSL.S8 Qd, Dn+1, Dm+1 + /// A64: SMLSL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 MultiplyWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector128 right) => MultiplyWideningUpperAndSubtract(minuend, left, right); /// - /// uint32x4_t vmlsl_high_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t c) - /// A32: VMLSL.U16 Qd, Dn+1, Dm+1 - /// A64: UMLSL2 Vd.4S, Vn.8H, Vm.8H + /// uint32x4_t vmlsl_high_u16 (uint32x4_t a, uint16x8_t b, uint16x8_t c) + /// A32: VMLSL.U16 Qd, Dn+1, Dm+1 + /// A64: UMLSL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 MultiplyWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector128 right) => MultiplyWideningUpperAndSubtract(minuend, left, right); /// - /// uint64x2_t vmlsl_high_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t c) - /// A32: VMLSL.U32 Qd, Dn+1, Dm+1 - /// A64: UMLSL2 Vd.2D, Vn.4S, Vm.4S + /// uint64x2_t vmlsl_high_u32 (uint64x2_t a, uint32x4_t b, uint32x4_t c) + /// A32: VMLSL.U32 Qd, Dn+1, Dm+1 + /// A64: UMLSL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 MultiplyWideningUpperAndSubtract(Vector128 minuend, Vector128 left, Vector128 right) => MultiplyWideningUpperAndSubtract(minuend, left, right); /// - /// int16x4_t vneg_s16 (int16x4_t a) - /// A32: VNEG.S16 Dd, Dm - /// A64: NEG Vd.4H, Vn.4H + /// int16x4_t vneg_s16 (int16x4_t a) + /// A32: VNEG.S16 Dd, Dm + /// A64: NEG Vd.4H, Vn.4H /// public static Vector64 Negate(Vector64 value) => Negate(value); /// - /// int32x2_t vneg_s32 (int32x2_t a) - /// A32: VNEG.S32 Dd, Dm - /// A64: NEG Vd.2S, Vn.2S + /// int32x2_t vneg_s32 (int32x2_t a) + /// A32: VNEG.S32 Dd, Dm + /// A64: NEG Vd.2S, Vn.2S /// public static Vector64 Negate(Vector64 value) => Negate(value); /// - /// int8x8_t vneg_s8 (int8x8_t a) - /// A32: VNEG.S8 Dd, Dm - /// A64: NEG Vd.8B, Vn.8B + /// int8x8_t vneg_s8 (int8x8_t a) + /// A32: VNEG.S8 Dd, Dm + /// A64: NEG Vd.8B, Vn.8B /// public static Vector64 Negate(Vector64 value) => Negate(value); /// - /// float32x2_t vneg_f32 (float32x2_t a) - /// A32: VNEG.F32 Dd, Dm - /// A64: FNEG Vd.2S, Vn.2S + /// float32x2_t vneg_f32 (float32x2_t a) + /// A32: VNEG.F32 Dd, Dm + /// A64: FNEG Vd.2S, Vn.2S /// public static Vector64 Negate(Vector64 value) => Negate(value); /// - /// int16x8_t vnegq_s16 (int16x8_t a) - /// A32: VNEG.S16 Qd, Qm - /// A64: NEG Vd.8H, Vn.8H + /// int16x8_t vnegq_s16 (int16x8_t a) + /// A32: VNEG.S16 Qd, Qm + /// A64: NEG Vd.8H, Vn.8H /// public static Vector128 Negate(Vector128 value) => Negate(value); /// - /// int32x4_t vnegq_s32 (int32x4_t a) - /// A32: VNEG.S32 Qd, Qm - /// A64: NEG Vd.4S, Vn.4S + /// int32x4_t vnegq_s32 (int32x4_t a) + /// A32: VNEG.S32 Qd, Qm + /// A64: NEG Vd.4S, Vn.4S /// public static Vector128 Negate(Vector128 value) => Negate(value); /// - /// int8x16_t vnegq_s8 (int8x16_t a) - /// A32: VNEG.S8 Qd, Qm - /// A64: NEG Vd.16B, Vn.16B + /// int8x16_t vnegq_s8 (int8x16_t a) + /// A32: VNEG.S8 Qd, Qm + /// A64: NEG Vd.16B, Vn.16B /// public static Vector128 Negate(Vector128 value) => Negate(value); /// - /// float32x4_t vnegq_f32 (float32x4_t a) - /// A32: VNEG.F32 Qd, Qm - /// A64: FNEG Vd.4S, Vn.4S + /// float32x4_t vnegq_f32 (float32x4_t a) + /// A32: VNEG.F32 Qd, Qm + /// A64: FNEG Vd.4S, Vn.4S /// public static Vector128 Negate(Vector128 value) => Negate(value); /// - /// int16x4_t vqneg_s16 (int16x4_t a) - /// A32: VQNEG.S16 Dd, Dm - /// A64: SQNEG Vd.4H, Vn.4H + /// int16x4_t vqneg_s16 (int16x4_t a) + /// A32: VQNEG.S16 Dd, Dm + /// A64: SQNEG Vd.4H, Vn.4H /// public static Vector64 NegateSaturate(Vector64 value) => NegateSaturate(value); /// - /// int32x2_t vqneg_s32 (int32x2_t a) - /// A32: VQNEG.S32 Dd, Dm - /// A64: SQNEG Vd.2S, Vn.2S + /// int32x2_t vqneg_s32 (int32x2_t a) + /// A32: VQNEG.S32 Dd, Dm + /// A64: SQNEG Vd.2S, Vn.2S /// public static Vector64 NegateSaturate(Vector64 value) => NegateSaturate(value); /// - /// int8x8_t vqneg_s8 (int8x8_t a) - /// A32: VQNEG.S8 Dd, Dm - /// A64: SQNEG Vd.8B, Vn.8B + /// int8x8_t vqneg_s8 (int8x8_t a) + /// A32: VQNEG.S8 Dd, Dm + /// A64: SQNEG Vd.8B, Vn.8B /// public static Vector64 NegateSaturate(Vector64 value) => NegateSaturate(value); /// - /// int16x8_t vqnegq_s16 (int16x8_t a) - /// A32: VQNEG.S16 Qd, Qm - /// A64: SQNEG Vd.8H, Vn.8H + /// int16x8_t vqnegq_s16 (int16x8_t a) + /// A32: VQNEG.S16 Qd, Qm + /// A64: SQNEG Vd.8H, Vn.8H /// public static Vector128 NegateSaturate(Vector128 value) => NegateSaturate(value); /// - /// int32x4_t vqnegq_s32 (int32x4_t a) - /// A32: VQNEG.S32 Qd, Qm - /// A64: SQNEG Vd.4S, Vn.4S + /// int32x4_t vqnegq_s32 (int32x4_t a) + /// A32: VQNEG.S32 Qd, Qm + /// A64: SQNEG Vd.4S, Vn.4S /// public static Vector128 NegateSaturate(Vector128 value) => NegateSaturate(value); /// - /// int8x16_t vqnegq_s8 (int8x16_t a) - /// A32: VQNEG.S8 Qd, Qm - /// A64: SQNEG Vd.16B, Vn.16B + /// int8x16_t vqnegq_s8 (int8x16_t a) + /// A32: VQNEG.S8 Qd, Qm + /// A64: SQNEG Vd.16B, Vn.16B /// public static Vector128 NegateSaturate(Vector128 value) => NegateSaturate(value); /// - /// float64x1_t vneg_f64 (float64x1_t a) - /// A32: VNEG.F64 Dd, Dm - /// A64: FNEG Dd, Dn + /// float64x1_t vneg_f64 (float64x1_t a) + /// A32: VNEG.F64 Dd, Dm + /// A64: FNEG Dd, Dn /// public static Vector64 NegateScalar(Vector64 value) => NegateScalar(value); /// - /// float32_t vnegs_f32 (float32_t a) - /// A32: VNEG.F32 Sd, Sm - /// A64: FNEG Sd, Sn - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vnegs_f32 (float32_t a) + /// A32: VNEG.F32 Sd, Sm + /// A64: FNEG Sd, Sn + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 NegateScalar(Vector64 value) => NegateScalar(value); /// - /// uint8x8_t vmvn_u8 (uint8x8_t a) - /// A32: VMVN Dd, Dm - /// A64: MVN Vd.8B, Vn.8B + /// uint8x8_t vmvn_u8 (uint8x8_t a) + /// A32: VMVN Dd, Dm + /// A64: MVN Vd.8B, Vn.8B /// public static Vector64 Not(Vector64 value) => Not(value); /// - /// float64x1_t vmvn_f64 (float64x1_t a) - /// A32: VMVN Dd, Dm - /// A64: MVN Vd.8B, Vn.8B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x1_t vmvn_f64 (float64x1_t a) + /// A32: VMVN Dd, Dm + /// A64: MVN Vd.8B, Vn.8B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 Not(Vector64 value) => Not(value); /// - /// int16x4_t vmvn_s16 (int16x4_t a) - /// A32: VMVN Dd, Dm - /// A64: MVN Vd.8B, Vn.8B + /// int16x4_t vmvn_s16 (int16x4_t a) + /// A32: VMVN Dd, Dm + /// A64: MVN Vd.8B, Vn.8B /// public static Vector64 Not(Vector64 value) => Not(value); /// - /// int32x2_t vmvn_s32 (int32x2_t a) - /// A32: VMVN Dd, Dm - /// A64: MVN Vd.8B, Vn.8B + /// int32x2_t vmvn_s32 (int32x2_t a) + /// A32: VMVN Dd, Dm + /// A64: MVN Vd.8B, Vn.8B /// public static Vector64 Not(Vector64 value) => Not(value); /// - /// int64x1_t vmvn_s64 (int64x1_t a) - /// A32: VMVN Dd, Dm - /// A64: MVN Vd.8B, Vn.8B + /// int64x1_t vmvn_s64 (int64x1_t a) + /// A32: VMVN Dd, Dm + /// A64: MVN Vd.8B, Vn.8B /// public static Vector64 Not(Vector64 value) => Not(value); /// - /// int8x8_t vmvn_s8 (int8x8_t a) - /// A32: VMVN Dd, Dm - /// A64: MVN Vd.8B, Vn.8B + /// int8x8_t vmvn_s8 (int8x8_t a) + /// A32: VMVN Dd, Dm + /// A64: MVN Vd.8B, Vn.8B /// public static Vector64 Not(Vector64 value) => Not(value); /// - /// float32x2_t vmvn_f32 (float32x2_t a) - /// A32: VMVN Dd, Dm - /// A64: MVN Vd.8B, Vn.8B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32x2_t vmvn_f32 (float32x2_t a) + /// A32: VMVN Dd, Dm + /// A64: MVN Vd.8B, Vn.8B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 Not(Vector64 value) => Not(value); /// - /// uint16x4_t vmvn_u16 (uint16x4_t a) - /// A32: VMVN Dd, Dm - /// A64: MVN Vd.8B, Vn.8B + /// uint16x4_t vmvn_u16 (uint16x4_t a) + /// A32: VMVN Dd, Dm + /// A64: MVN Vd.8B, Vn.8B /// public static Vector64 Not(Vector64 value) => Not(value); /// - /// uint32x2_t vmvn_u32 (uint32x2_t a) - /// A32: VMVN Dd, Dm - /// A64: MVN Vd.8B, Vn.8B + /// uint32x2_t vmvn_u32 (uint32x2_t a) + /// A32: VMVN Dd, Dm + /// A64: MVN Vd.8B, Vn.8B /// public static Vector64 Not(Vector64 value) => Not(value); /// - /// uint64x1_t vmvn_u64 (uint64x1_t a) - /// A32: VMVN Dd, Dm - /// A64: MVN Vd.8B, Vn.8B + /// uint64x1_t vmvn_u64 (uint64x1_t a) + /// A32: VMVN Dd, Dm + /// A64: MVN Vd.8B, Vn.8B /// public static Vector64 Not(Vector64 value) => Not(value); /// - /// uint8x16_t vmvnq_u8 (uint8x16_t a) - /// A32: VMVN Qd, Qm - /// A64: MVN Vd.16B, Vn.16B + /// uint8x16_t vmvnq_u8 (uint8x16_t a) + /// A32: VMVN Qd, Qm + /// A64: MVN Vd.16B, Vn.16B /// public static Vector128 Not(Vector128 value) => Not(value); /// - /// float64x2_t vmvnq_f64 (float64x2_t a) - /// A32: VMVN Qd, Qm - /// A64: MVN Vd.16B, Vn.16B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x2_t vmvnq_f64 (float64x2_t a) + /// A32: VMVN Qd, Qm + /// A64: MVN Vd.16B, Vn.16B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 Not(Vector128 value) => Not(value); /// - /// int16x8_t vmvnq_s16 (int16x8_t a) - /// A32: VMVN Qd, Qm - /// A64: MVN Vd.16B, Vn.16B + /// int16x8_t vmvnq_s16 (int16x8_t a) + /// A32: VMVN Qd, Qm + /// A64: MVN Vd.16B, Vn.16B /// public static Vector128 Not(Vector128 value) => Not(value); /// - /// int32x4_t vmvnq_s32 (int32x4_t a) - /// A32: VMVN Qd, Qm - /// A64: MVN Vd.16B, Vn.16B + /// int32x4_t vmvnq_s32 (int32x4_t a) + /// A32: VMVN Qd, Qm + /// A64: MVN Vd.16B, Vn.16B /// public static Vector128 Not(Vector128 value) => Not(value); /// - /// int64x2_t vmvnq_s64 (int64x2_t a) - /// A32: VMVN Qd, Qm - /// A64: MVN Vd.16B, Vn.16B + /// int64x2_t vmvnq_s64 (int64x2_t a) + /// A32: VMVN Qd, Qm + /// A64: MVN Vd.16B, Vn.16B /// public static Vector128 Not(Vector128 value) => Not(value); /// - /// int8x16_t vmvnq_s8 (int8x16_t a) - /// A32: VMVN Qd, Qm - /// A64: MVN Vd.16B, Vn.16B + /// int8x16_t vmvnq_s8 (int8x16_t a) + /// A32: VMVN Qd, Qm + /// A64: MVN Vd.16B, Vn.16B /// public static Vector128 Not(Vector128 value) => Not(value); /// - /// float32x4_t vmvnq_f32 (float32x4_t a) - /// A32: VMVN Qd, Qm - /// A64: MVN Vd.16B, Vn.16B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32x4_t vmvnq_f32 (float32x4_t a) + /// A32: VMVN Qd, Qm + /// A64: MVN Vd.16B, Vn.16B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 Not(Vector128 value) => Not(value); /// - /// uint16x8_t vmvnq_u16 (uint16x8_t a) - /// A32: VMVN Qd, Qm - /// A64: MVN Vd.16B, Vn.16B + /// uint16x8_t vmvnq_u16 (uint16x8_t a) + /// A32: VMVN Qd, Qm + /// A64: MVN Vd.16B, Vn.16B /// public static Vector128 Not(Vector128 value) => Not(value); /// - /// uint32x4_t vmvnq_u32 (uint32x4_t a) - /// A32: VMVN Qd, Qm - /// A64: MVN Vd.16B, Vn.16B + /// uint32x4_t vmvnq_u32 (uint32x4_t a) + /// A32: VMVN Qd, Qm + /// A64: MVN Vd.16B, Vn.16B /// public static Vector128 Not(Vector128 value) => Not(value); /// - /// uint64x2_t vmvnq_u64 (uint64x2_t a) - /// A32: VMVN Qd, Qm - /// A64: MVN Vd.16B, Vn.16B + /// uint64x2_t vmvnq_u64 (uint64x2_t a) + /// A32: VMVN Qd, Qm + /// A64: MVN Vd.16B, Vn.16B /// public static Vector128 Not(Vector128 value) => Not(value); /// - /// uint8x8_t vorr_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VORR Dd, Dn, Dm - /// A64: ORR Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vorr_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VORR Dd, Dn, Dm + /// A64: ORR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Or(Vector64 left, Vector64 right) => Or(left, right); /// - /// float64x1_t vorr_f64 (float64x1_t a, float64x1_t b) - /// A32: VORR Dd, Dn, Dm - /// A64: ORR Vd.8B, Vn.8B, Vm.8B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x1_t vorr_f64 (float64x1_t a, float64x1_t b) + /// A32: VORR Dd, Dn, Dm + /// A64: ORR Vd.8B, Vn.8B, Vm.8B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 Or(Vector64 left, Vector64 right) => Or(left, right); /// - /// int16x4_t vorr_s16 (int16x4_t a, int16x4_t b) - /// A32: VORR Dd, Dn, Dm - /// A64: ORR Vd.8B, Vn.8B, Vm.8B + /// int16x4_t vorr_s16 (int16x4_t a, int16x4_t b) + /// A32: VORR Dd, Dn, Dm + /// A64: ORR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Or(Vector64 left, Vector64 right) => Or(left, right); /// - /// int32x2_t vorr_s32 (int32x2_t a, int32x2_t b) - /// A32: VORR Dd, Dn, Dm - /// A64: ORR Vd.8B, Vn.8B, Vm.8B + /// int32x2_t vorr_s32 (int32x2_t a, int32x2_t b) + /// A32: VORR Dd, Dn, Dm + /// A64: ORR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Or(Vector64 left, Vector64 right) => Or(left, right); /// - /// int64x1_t vorr_s64 (int64x1_t a, int64x1_t b) - /// A32: VORR Dd, Dn, Dm - /// A64: ORR Vd.8B, Vn.8B, Vm.8B + /// int64x1_t vorr_s64 (int64x1_t a, int64x1_t b) + /// A32: VORR Dd, Dn, Dm + /// A64: ORR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Or(Vector64 left, Vector64 right) => Or(left, right); /// - /// int8x8_t vorr_s8 (int8x8_t a, int8x8_t b) - /// A32: VORR Dd, Dn, Dm - /// A64: ORR Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vorr_s8 (int8x8_t a, int8x8_t b) + /// A32: VORR Dd, Dn, Dm + /// A64: ORR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Or(Vector64 left, Vector64 right) => Or(left, right); /// - /// float32x2_t vorr_f32 (float32x2_t a, float32x2_t b) - /// A32: VORR Dd, Dn, Dm - /// A64: ORR Vd.8B, Vn.8B, Vm.8B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32x2_t vorr_f32 (float32x2_t a, float32x2_t b) + /// A32: VORR Dd, Dn, Dm + /// A64: ORR Vd.8B, Vn.8B, Vm.8B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 Or(Vector64 left, Vector64 right) => Or(left, right); /// - /// uint16x4_t vorr_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VORR Dd, Dn, Dm - /// A64: ORR Vd.8B, Vn.8B, Vm.8B + /// uint16x4_t vorr_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VORR Dd, Dn, Dm + /// A64: ORR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Or(Vector64 left, Vector64 right) => Or(left, right); /// - /// uint32x2_t vorr_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VORR Dd, Dn, Dm - /// A64: ORR Vd.8B, Vn.8B, Vm.8B + /// uint32x2_t vorr_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VORR Dd, Dn, Dm + /// A64: ORR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Or(Vector64 left, Vector64 right) => Or(left, right); /// - /// uint64x1_t vorr_u64 (uint64x1_t a, uint64x1_t b) - /// A32: VORR Dd, Dn, Dm - /// A64: ORR Vd.8B, Vn.8B, Vm.8B + /// uint64x1_t vorr_u64 (uint64x1_t a, uint64x1_t b) + /// A32: VORR Dd, Dn, Dm + /// A64: ORR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Or(Vector64 left, Vector64 right) => Or(left, right); /// - /// uint8x16_t vorrq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VORR Qd, Qn, Qm - /// A64: ORR Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vorrq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VORR Qd, Qn, Qm + /// A64: ORR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// - /// float64x2_t vorrq_f64 (float64x2_t a, float64x2_t b) - /// A32: VORR Qd, Qn, Qm - /// A64: ORR Vd.16B, Vn.16B, Vm.16B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x2_t vorrq_f64 (float64x2_t a, float64x2_t b) + /// A32: VORR Qd, Qn, Qm + /// A64: ORR Vd.16B, Vn.16B, Vm.16B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// - /// int16x8_t vorrq_s16 (int16x8_t a, int16x8_t b) - /// A32: VORR Qd, Qn, Qm - /// A64: ORR Vd.16B, Vn.16B, Vm.16B + /// int16x8_t vorrq_s16 (int16x8_t a, int16x8_t b) + /// A32: VORR Qd, Qn, Qm + /// A64: ORR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// - /// int32x4_t vorrq_s32 (int32x4_t a, int32x4_t b) - /// A32: VORR Qd, Qn, Qm - /// A64: ORR Vd.16B, Vn.16B, Vm.16B + /// int32x4_t vorrq_s32 (int32x4_t a, int32x4_t b) + /// A32: VORR Qd, Qn, Qm + /// A64: ORR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// - /// int64x2_t vorrq_s64 (int64x2_t a, int64x2_t b) - /// A32: VORR Qd, Qn, Qm - /// A64: ORR Vd.16B, Vn.16B, Vm.16B + /// int64x2_t vorrq_s64 (int64x2_t a, int64x2_t b) + /// A32: VORR Qd, Qn, Qm + /// A64: ORR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// - /// int8x16_t vorrq_s8 (int8x16_t a, int8x16_t b) - /// A32: VORR Qd, Qn, Qm - /// A64: ORR Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vorrq_s8 (int8x16_t a, int8x16_t b) + /// A32: VORR Qd, Qn, Qm + /// A64: ORR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// - /// float32x4_t vorrq_f32 (float32x4_t a, float32x4_t b) - /// A32: VORR Qd, Qn, Qm - /// A64: ORR Vd.16B, Vn.16B, Vm.16B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32x4_t vorrq_f32 (float32x4_t a, float32x4_t b) + /// A32: VORR Qd, Qn, Qm + /// A64: ORR Vd.16B, Vn.16B, Vm.16B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// - /// uint16x8_t vorrq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VORR Qd, Qn, Qm - /// A64: ORR Vd.16B, Vn.16B, Vm.16B + /// uint16x8_t vorrq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VORR Qd, Qn, Qm + /// A64: ORR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// - /// uint32x4_t vorrq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VORR Qd, Qn, Qm - /// A64: ORR Vd.16B, Vn.16B, Vm.16B + /// uint32x4_t vorrq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VORR Qd, Qn, Qm + /// A64: ORR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// - /// uint64x2_t vorrq_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VORR Qd, Qn, Qm - /// A64: ORR Vd.16B, Vn.16B, Vm.16B + /// uint64x2_t vorrq_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VORR Qd, Qn, Qm + /// A64: ORR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// - /// uint8x8_t vorn_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VORN Dd, Dn, Dm - /// A64: ORN Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vorn_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VORN Dd, Dn, Dm + /// A64: ORN Vd.8B, Vn.8B, Vm.8B /// public static Vector64 OrNot(Vector64 left, Vector64 right) => OrNot(left, right); /// - /// float64x1_t vorn_f64 (float64x1_t a, float64x1_t b) - /// A32: VORN Dd, Dn, Dm - /// A64: ORN Vd.8B, Vn.8B, Vm.8B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x1_t vorn_f64 (float64x1_t a, float64x1_t b) + /// A32: VORN Dd, Dn, Dm + /// A64: ORN Vd.8B, Vn.8B, Vm.8B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 OrNot(Vector64 left, Vector64 right) => OrNot(left, right); /// - /// int16x4_t vorn_s16 (int16x4_t a, int16x4_t b) - /// A32: VORN Dd, Dn, Dm - /// A64: ORN Vd.8B, Vn.8B, Vm.8B + /// int16x4_t vorn_s16 (int16x4_t a, int16x4_t b) + /// A32: VORN Dd, Dn, Dm + /// A64: ORN Vd.8B, Vn.8B, Vm.8B /// public static Vector64 OrNot(Vector64 left, Vector64 right) => OrNot(left, right); /// - /// int32x2_t vorn_s32 (int32x2_t a, int32x2_t b) - /// A32: VORN Dd, Dn, Dm - /// A64: ORN Vd.8B, Vn.8B, Vm.8B + /// int32x2_t vorn_s32 (int32x2_t a, int32x2_t b) + /// A32: VORN Dd, Dn, Dm + /// A64: ORN Vd.8B, Vn.8B, Vm.8B /// public static Vector64 OrNot(Vector64 left, Vector64 right) => OrNot(left, right); /// - /// int64x1_t vorn_s64 (int64x1_t a, int64x1_t b) - /// A32: VORN Dd, Dn, Dm - /// A64: ORN Vd.8B, Vn.8B, Vm.8B + /// int64x1_t vorn_s64 (int64x1_t a, int64x1_t b) + /// A32: VORN Dd, Dn, Dm + /// A64: ORN Vd.8B, Vn.8B, Vm.8B /// public static Vector64 OrNot(Vector64 left, Vector64 right) => OrNot(left, right); /// - /// int8x8_t vorn_s8 (int8x8_t a, int8x8_t b) - /// A32: VORN Dd, Dn, Dm - /// A64: ORN Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vorn_s8 (int8x8_t a, int8x8_t b) + /// A32: VORN Dd, Dn, Dm + /// A64: ORN Vd.8B, Vn.8B, Vm.8B /// public static Vector64 OrNot(Vector64 left, Vector64 right) => OrNot(left, right); /// - /// float32x2_t vorn_f32 (float32x2_t a, float32x2_t b) - /// A32: VORN Dd, Dn, Dm - /// A64: ORN Vd.8B, Vn.8B, Vm.8B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32x2_t vorn_f32 (float32x2_t a, float32x2_t b) + /// A32: VORN Dd, Dn, Dm + /// A64: ORN Vd.8B, Vn.8B, Vm.8B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 OrNot(Vector64 left, Vector64 right) => OrNot(left, right); /// - /// uint16x4_t vorn_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VORN Dd, Dn, Dm - /// A64: ORN Vd.8B, Vn.8B, Vm.8B + /// uint16x4_t vorn_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VORN Dd, Dn, Dm + /// A64: ORN Vd.8B, Vn.8B, Vm.8B /// public static Vector64 OrNot(Vector64 left, Vector64 right) => OrNot(left, right); /// - /// uint32x2_t vorn_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VORN Dd, Dn, Dm - /// A64: ORN Vd.8B, Vn.8B, Vm.8B + /// uint32x2_t vorn_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VORN Dd, Dn, Dm + /// A64: ORN Vd.8B, Vn.8B, Vm.8B /// public static Vector64 OrNot(Vector64 left, Vector64 right) => OrNot(left, right); /// - /// uint64x1_t vorn_u64 (uint64x1_t a, uint64x1_t b) - /// A32: VORN Dd, Dn, Dm - /// A64: ORN Vd.8B, Vn.8B, Vm.8B + /// uint64x1_t vorn_u64 (uint64x1_t a, uint64x1_t b) + /// A32: VORN Dd, Dn, Dm + /// A64: ORN Vd.8B, Vn.8B, Vm.8B /// public static Vector64 OrNot(Vector64 left, Vector64 right) => OrNot(left, right); /// - /// uint8x16_t vornq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VORN Qd, Qn, Qm - /// A64: ORN Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vornq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VORN Qd, Qn, Qm + /// A64: ORN Vd.16B, Vn.16B, Vm.16B /// public static Vector128 OrNot(Vector128 left, Vector128 right) => OrNot(left, right); /// - /// float64x2_t vornq_f64 (float64x2_t a, float64x2_t b) - /// A32: VORN Qd, Qn, Qm - /// A64: ORN Vd.16B, Vn.16B, Vm.16B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x2_t vornq_f64 (float64x2_t a, float64x2_t b) + /// A32: VORN Qd, Qn, Qm + /// A64: ORN Vd.16B, Vn.16B, Vm.16B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 OrNot(Vector128 left, Vector128 right) => OrNot(left, right); /// - /// int16x8_t vornq_s16 (int16x8_t a, int16x8_t b) - /// A32: VORN Qd, Qn, Qm - /// A64: ORN Vd.16B, Vn.16B, Vm.16B + /// int16x8_t vornq_s16 (int16x8_t a, int16x8_t b) + /// A32: VORN Qd, Qn, Qm + /// A64: ORN Vd.16B, Vn.16B, Vm.16B /// public static Vector128 OrNot(Vector128 left, Vector128 right) => OrNot(left, right); /// - /// int32x4_t vornq_s32 (int32x4_t a, int32x4_t b) - /// A32: VORN Qd, Qn, Qm - /// A64: ORN Vd.16B, Vn.16B, Vm.16B + /// int32x4_t vornq_s32 (int32x4_t a, int32x4_t b) + /// A32: VORN Qd, Qn, Qm + /// A64: ORN Vd.16B, Vn.16B, Vm.16B /// public static Vector128 OrNot(Vector128 left, Vector128 right) => OrNot(left, right); /// - /// int64x2_t vornq_s64 (int64x2_t a, int64x2_t b) - /// A32: VORN Qd, Qn, Qm - /// A64: ORN Vd.16B, Vn.16B, Vm.16B + /// int64x2_t vornq_s64 (int64x2_t a, int64x2_t b) + /// A32: VORN Qd, Qn, Qm + /// A64: ORN Vd.16B, Vn.16B, Vm.16B /// public static Vector128 OrNot(Vector128 left, Vector128 right) => OrNot(left, right); /// - /// int8x16_t vornq_s8 (int8x16_t a, int8x16_t b) - /// A32: VORN Qd, Qn, Qm - /// A64: ORN Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vornq_s8 (int8x16_t a, int8x16_t b) + /// A32: VORN Qd, Qn, Qm + /// A64: ORN Vd.16B, Vn.16B, Vm.16B /// public static Vector128 OrNot(Vector128 left, Vector128 right) => OrNot(left, right); /// - /// float32x4_t vornq_f32 (float32x4_t a, float32x4_t b) - /// A32: VORN Qd, Qn, Qm - /// A64: ORN Vd.16B, Vn.16B, Vm.16B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32x4_t vornq_f32 (float32x4_t a, float32x4_t b) + /// A32: VORN Qd, Qn, Qm + /// A64: ORN Vd.16B, Vn.16B, Vm.16B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 OrNot(Vector128 left, Vector128 right) => OrNot(left, right); /// - /// uint16x8_t vornq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VORN Qd, Qn, Qm - /// A64: ORN Vd.16B, Vn.16B, Vm.16B + /// uint16x8_t vornq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VORN Qd, Qn, Qm + /// A64: ORN Vd.16B, Vn.16B, Vm.16B /// public static Vector128 OrNot(Vector128 left, Vector128 right) => OrNot(left, right); /// - /// uint32x4_t vornq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VORN Qd, Qn, Qm - /// A64: ORN Vd.16B, Vn.16B, Vm.16B + /// uint32x4_t vornq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VORN Qd, Qn, Qm + /// A64: ORN Vd.16B, Vn.16B, Vm.16B /// public static Vector128 OrNot(Vector128 left, Vector128 right) => OrNot(left, right); /// - /// uint64x2_t vornq_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VORN Qd, Qn, Qm - /// A64: ORN Vd.16B, Vn.16B, Vm.16B + /// uint64x2_t vornq_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VORN Qd, Qn, Qm + /// A64: ORN Vd.16B, Vn.16B, Vm.16B /// public static Vector128 OrNot(Vector128 left, Vector128 right) => OrNot(left, right); /// - /// poly8x8_t vmul_p8 (poly8x8_t a, poly8x8_t b) - /// A32: VMUL.P8 Dd, Dn, Dm - /// A64: PMUL Vd.8B, Vn.8B, Vm.8B + /// poly8x8_t vmul_p8 (poly8x8_t a, poly8x8_t b) + /// A32: VMUL.P8 Dd, Dn, Dm + /// A64: PMUL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 PolynomialMultiply(Vector64 left, Vector64 right) => PolynomialMultiply(left, right); /// - /// poly8x8_t vmul_p8 (poly8x8_t a, poly8x8_t b) - /// A32: VMUL.P8 Dd, Dn, Dm - /// A64: PMUL Vd.8B, Vn.8B, Vm.8B + /// poly8x8_t vmul_p8 (poly8x8_t a, poly8x8_t b) + /// A32: VMUL.P8 Dd, Dn, Dm + /// A64: PMUL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 PolynomialMultiply(Vector64 left, Vector64 right) => PolynomialMultiply(left, right); /// - /// poly8x16_t vmulq_p8 (poly8x16_t a, poly8x16_t b) - /// A32: VMUL.P8 Qd, Qn, Qm - /// A64: PMUL Vd.16B, Vn.16B, Vm.16B + /// poly8x16_t vmulq_p8 (poly8x16_t a, poly8x16_t b) + /// A32: VMUL.P8 Qd, Qn, Qm + /// A64: PMUL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 PolynomialMultiply(Vector128 left, Vector128 right) => PolynomialMultiply(left, right); /// - /// poly8x16_t vmulq_p8 (poly8x16_t a, poly8x16_t b) - /// A32: VMUL.P8 Qd, Qn, Qm - /// A64: PMUL Vd.16B, Vn.16B, Vm.16B + /// poly8x16_t vmulq_p8 (poly8x16_t a, poly8x16_t b) + /// A32: VMUL.P8 Qd, Qn, Qm + /// A64: PMUL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 PolynomialMultiply(Vector128 left, Vector128 right) => PolynomialMultiply(left, right); /// - /// poly16x8_t vmull_p8 (poly8x8_t a, poly8x8_t b) - /// A32: VMULL.P8 Qd, Dn, Dm - /// A64: PMULL Vd.16B, Vn.8B, Vm.8B + /// poly16x8_t vmull_p8 (poly8x8_t a, poly8x8_t b) + /// A32: VMULL.P8 Qd, Dn, Dm + /// A64: PMULL Vd.16B, Vn.8B, Vm.8B /// public static Vector128 PolynomialMultiplyWideningLower(Vector64 left, Vector64 right) => PolynomialMultiplyWideningLower(left, right); /// - /// poly16x8_t vmull_p8 (poly8x8_t a, poly8x8_t b) - /// A32: VMULL.P8 Qd, Dn, Dm - /// A64: PMULL Vd.16B, Vn.8B, Vm.8B + /// poly16x8_t vmull_p8 (poly8x8_t a, poly8x8_t b) + /// A32: VMULL.P8 Qd, Dn, Dm + /// A64: PMULL Vd.16B, Vn.8B, Vm.8B /// public static Vector128 PolynomialMultiplyWideningLower(Vector64 left, Vector64 right) => PolynomialMultiplyWideningLower(left, right); /// - /// poly16x8_t vmull_high_p8 (poly8x16_t a, poly8x16_t b) - /// A32: VMULL.P8 Qd, Dn+1, Dm+1 - /// A64: PMULL2 Vd.16B, Vn.16B, Vm.16B + /// poly16x8_t vmull_high_p8 (poly8x16_t a, poly8x16_t b) + /// A32: VMULL.P8 Qd, Dn+1, Dm+1 + /// A64: PMULL2 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 PolynomialMultiplyWideningUpper(Vector128 left, Vector128 right) => PolynomialMultiplyWideningUpper(left, right); /// - /// poly16x8_t vmull_high_p8 (poly8x16_t a, poly8x16_t b) - /// A32: VMULL.P8 Qd, Dn+1, Dm+1 - /// A64: PMULL2 Vd.16B, Vn.16B, Vm.16B + /// poly16x8_t vmull_high_p8 (poly8x16_t a, poly8x16_t b) + /// A32: VMULL.P8 Qd, Dn+1, Dm+1 + /// A64: PMULL2 Vd.16B, Vn.16B, Vm.16B /// public static Vector128 PolynomialMultiplyWideningUpper(Vector128 left, Vector128 right) => PolynomialMultiplyWideningUpper(left, right); /// - /// uint8x8_t vcnt_u8 (uint8x8_t a) - /// A32: VCNT.I8 Dd, Dm - /// A64: CNT Vd.8B, Vn.8B + /// uint8x8_t vcnt_u8 (uint8x8_t a) + /// A32: VCNT.I8 Dd, Dm + /// A64: CNT Vd.8B, Vn.8B /// public static Vector64 PopCount(Vector64 value) => PopCount(value); /// - /// int8x8_t vcnt_s8 (int8x8_t a) - /// A32: VCNT.I8 Dd, Dm - /// A64: CNT Vd.8B, Vn.8B + /// int8x8_t vcnt_s8 (int8x8_t a) + /// A32: VCNT.I8 Dd, Dm + /// A64: CNT Vd.8B, Vn.8B /// public static Vector64 PopCount(Vector64 value) => PopCount(value); /// - /// uint8x16_t vcntq_u8 (uint8x16_t a) - /// A32: VCNT.I8 Qd, Qm - /// A64: CNT Vd.16B, Vn.16B + /// uint8x16_t vcntq_u8 (uint8x16_t a) + /// A32: VCNT.I8 Qd, Qm + /// A64: CNT Vd.16B, Vn.16B /// public static Vector128 PopCount(Vector128 value) => PopCount(value); /// - /// int8x16_t vcntq_s8 (int8x16_t a) - /// A32: VCNT.I8 Qd, Qm - /// A64: CNT Vd.16B, Vn.16B + /// int8x16_t vcntq_s8 (int8x16_t a) + /// A32: VCNT.I8 Qd, Qm + /// A64: CNT Vd.16B, Vn.16B /// public static Vector128 PopCount(Vector128 value) => PopCount(value); /// - /// float32x2_t vrecpe_f32 (float32x2_t a) - /// A32: VRECPE.F32 Dd, Dm - /// A64: FRECPE Vd.2S, Vn.2S + /// float32x2_t vrecpe_f32 (float32x2_t a) + /// A32: VRECPE.F32 Dd, Dm + /// A64: FRECPE Vd.2S, Vn.2S /// public static Vector64 ReciprocalEstimate(Vector64 value) => ReciprocalEstimate(value); /// - /// uint32x2_t vrecpe_u32 (uint32x2_t a) - /// A32: VRECPE.U32 Dd, Dm - /// A64: URECPE Vd.2S, Vn.2S + /// uint32x2_t vrecpe_u32 (uint32x2_t a) + /// A32: VRECPE.U32 Dd, Dm + /// A64: URECPE Vd.2S, Vn.2S /// public static Vector64 ReciprocalEstimate(Vector64 value) => ReciprocalEstimate(value); /// - /// float32x4_t vrecpeq_f32 (float32x4_t a) - /// A32: VRECPE.F32 Qd, Qm - /// A64: FRECPE Vd.4S, Vn.4S + /// float32x4_t vrecpeq_f32 (float32x4_t a) + /// A32: VRECPE.F32 Qd, Qm + /// A64: FRECPE Vd.4S, Vn.4S /// public static Vector128 ReciprocalEstimate(Vector128 value) => ReciprocalEstimate(value); /// - /// uint32x4_t vrecpeq_u32 (uint32x4_t a) - /// A32: VRECPE.U32 Qd, Qm - /// A64: URECPE Vd.4S, Vn.4S + /// uint32x4_t vrecpeq_u32 (uint32x4_t a) + /// A32: VRECPE.U32 Qd, Qm + /// A64: URECPE Vd.4S, Vn.4S /// public static Vector128 ReciprocalEstimate(Vector128 value) => ReciprocalEstimate(value); /// - /// float32x2_t vrsqrte_f32 (float32x2_t a) - /// A32: VRSQRTE.F32 Dd, Dm - /// A64: FRSQRTE Vd.2S, Vn.2S + /// float32x2_t vrsqrte_f32 (float32x2_t a) + /// A32: VRSQRTE.F32 Dd, Dm + /// A64: FRSQRTE Vd.2S, Vn.2S /// public static Vector64 ReciprocalSquareRootEstimate(Vector64 value) => ReciprocalSquareRootEstimate(value); /// - /// uint32x2_t vrsqrte_u32 (uint32x2_t a) - /// A32: VRSQRTE.U32 Dd, Dm - /// A64: URSQRTE Vd.2S, Vn.2S + /// uint32x2_t vrsqrte_u32 (uint32x2_t a) + /// A32: VRSQRTE.U32 Dd, Dm + /// A64: URSQRTE Vd.2S, Vn.2S /// public static Vector64 ReciprocalSquareRootEstimate(Vector64 value) => ReciprocalSquareRootEstimate(value); /// - /// float32x4_t vrsqrteq_f32 (float32x4_t a) - /// A32: VRSQRTE.F32 Qd, Qm - /// A64: FRSQRTE Vd.4S, Vn.4S + /// float32x4_t vrsqrteq_f32 (float32x4_t a) + /// A32: VRSQRTE.F32 Qd, Qm + /// A64: FRSQRTE Vd.4S, Vn.4S /// public static Vector128 ReciprocalSquareRootEstimate(Vector128 value) => ReciprocalSquareRootEstimate(value); /// - /// uint32x4_t vrsqrteq_u32 (uint32x4_t a) - /// A32: VRSQRTE.U32 Qd, Qm - /// A64: URSQRTE Vd.4S, Vn.4S + /// uint32x4_t vrsqrteq_u32 (uint32x4_t a) + /// A32: VRSQRTE.U32 Qd, Qm + /// A64: URSQRTE Vd.4S, Vn.4S /// public static Vector128 ReciprocalSquareRootEstimate(Vector128 value) => ReciprocalSquareRootEstimate(value); /// - /// float32x2_t vrsqrts_f32 (float32x2_t a, float32x2_t b) - /// A32: VRSQRTS.F32 Dd, Dn, Dm - /// A64: FRSQRTS Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vrsqrts_f32 (float32x2_t a, float32x2_t b) + /// A32: VRSQRTS.F32 Dd, Dn, Dm + /// A64: FRSQRTS Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ReciprocalSquareRootStep(Vector64 left, Vector64 right) => ReciprocalSquareRootStep(left, right); /// - /// float32x4_t vrsqrtsq_f32 (float32x4_t a, float32x4_t b) - /// A32: VRSQRTS.F32 Qd, Qn, Qm - /// A64: FRSQRTS Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vrsqrtsq_f32 (float32x4_t a, float32x4_t b) + /// A32: VRSQRTS.F32 Qd, Qn, Qm + /// A64: FRSQRTS Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ReciprocalSquareRootStep(Vector128 left, Vector128 right) => ReciprocalSquareRootStep(left, right); /// - /// float32x2_t vrecps_f32 (float32x2_t a, float32x2_t b) - /// A32: VRECPS.F32 Dd, Dn, Dm - /// A64: FRECPS Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vrecps_f32 (float32x2_t a, float32x2_t b) + /// A32: VRECPS.F32 Dd, Dn, Dm + /// A64: FRECPS Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ReciprocalStep(Vector64 left, Vector64 right) => ReciprocalStep(left, right); /// - /// float32x4_t vrecpsq_f32 (float32x4_t a, float32x4_t b) - /// A32: VRECPS.F32 Qd, Qn, Qm - /// A64: FRECPS Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vrecpsq_f32 (float32x4_t a, float32x4_t b) + /// A32: VRECPS.F32 Qd, Qn, Qm + /// A64: FRECPS Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ReciprocalStep(Vector128 left, Vector128 right) => ReciprocalStep(left, right); /// - /// int16x4_t vrev32_s16 (int16x4_t vec) - /// A32: VREV32.16 Dd, Dm - /// A64: REV32 Vd.4H, Vn.4H + /// int16x4_t vrev32_s16 (int16x4_t vec) + /// A32: VREV32.16 Dd, Dm + /// A64: REV32 Vd.4H, Vn.4H /// public static Vector64 ReverseElement16(Vector64 value) => ReverseElement16(value); /// - /// int16x4_t vrev64_s16 (int16x4_t vec) - /// A32: VREV64.16 Dd, Dm - /// A64: REV64 Vd.4H, Vn.4H + /// int16x4_t vrev64_s16 (int16x4_t vec) + /// A32: VREV64.16 Dd, Dm + /// A64: REV64 Vd.4H, Vn.4H /// public static Vector64 ReverseElement16(Vector64 value) => ReverseElement16(value); /// - /// uint16x4_t vrev32_u16 (uint16x4_t vec) - /// A32: VREV32.16 Dd, Dm - /// A64: REV32 Vd.4H, Vn.4H + /// uint16x4_t vrev32_u16 (uint16x4_t vec) + /// A32: VREV32.16 Dd, Dm + /// A64: REV32 Vd.4H, Vn.4H /// public static Vector64 ReverseElement16(Vector64 value) => ReverseElement16(value); /// - /// uint16x4_t vrev64_u16 (uint16x4_t vec) - /// A32: VREV64.16 Dd, Dm - /// A64: REV64 Vd.4H, Vn.4H + /// uint16x4_t vrev64_u16 (uint16x4_t vec) + /// A32: VREV64.16 Dd, Dm + /// A64: REV64 Vd.4H, Vn.4H /// public static Vector64 ReverseElement16(Vector64 value) => ReverseElement16(value); /// - /// int16x8_t vrev32q_s16 (int16x8_t vec) - /// A32: VREV32.16 Qd, Qm - /// A64: REV32 Vd.8H, Vn.8H + /// int16x8_t vrev32q_s16 (int16x8_t vec) + /// A32: VREV32.16 Qd, Qm + /// A64: REV32 Vd.8H, Vn.8H /// public static Vector128 ReverseElement16(Vector128 value) => ReverseElement16(value); /// - /// int16x8_t vrev64q_s16 (int16x8_t vec) - /// A32: VREV64.16 Qd, Qm - /// A64: REV64 Vd.8H, Vn.8H + /// int16x8_t vrev64q_s16 (int16x8_t vec) + /// A32: VREV64.16 Qd, Qm + /// A64: REV64 Vd.8H, Vn.8H /// public static Vector128 ReverseElement16(Vector128 value) => ReverseElement16(value); /// - /// uint16x8_t vrev32q_u16 (uint16x8_t vec) - /// A32: VREV32.16 Qd, Qm - /// A64: REV32 Vd.8H, Vn.8H + /// uint16x8_t vrev32q_u16 (uint16x8_t vec) + /// A32: VREV32.16 Qd, Qm + /// A64: REV32 Vd.8H, Vn.8H /// public static Vector128 ReverseElement16(Vector128 value) => ReverseElement16(value); /// - /// uint16x8_t vrev64q_u16 (uint16x8_t vec) - /// A32: VREV64.16 Qd, Qm - /// A64: REV64 Vd.8H, Vn.8H + /// uint16x8_t vrev64q_u16 (uint16x8_t vec) + /// A32: VREV64.16 Qd, Qm + /// A64: REV64 Vd.8H, Vn.8H /// public static Vector128 ReverseElement16(Vector128 value) => ReverseElement16(value); /// - /// int32x2_t vrev64_s32 (int32x2_t vec) - /// A32: VREV64.32 Dd, Dm - /// A64: REV64 Vd.2S, Vn.2S + /// int32x2_t vrev64_s32 (int32x2_t vec) + /// A32: VREV64.32 Dd, Dm + /// A64: REV64 Vd.2S, Vn.2S /// public static Vector64 ReverseElement32(Vector64 value) => ReverseElement32(value); /// - /// uint32x2_t vrev64_u32 (uint32x2_t vec) - /// A32: VREV64.32 Dd, Dm - /// A64: REV64 Vd.2S, Vn.2S + /// uint32x2_t vrev64_u32 (uint32x2_t vec) + /// A32: VREV64.32 Dd, Dm + /// A64: REV64 Vd.2S, Vn.2S /// public static Vector64 ReverseElement32(Vector64 value) => ReverseElement32(value); /// - /// int32x4_t vrev64q_s32 (int32x4_t vec) - /// A32: VREV64.32 Qd, Qm - /// A64: REV64 Vd.4S, Vn.4S + /// int32x4_t vrev64q_s32 (int32x4_t vec) + /// A32: VREV64.32 Qd, Qm + /// A64: REV64 Vd.4S, Vn.4S /// public static Vector128 ReverseElement32(Vector128 value) => ReverseElement32(value); /// - /// uint32x4_t vrev64q_u32 (uint32x4_t vec) - /// A32: VREV64.32 Qd, Qm - /// A64: REV64 Vd.4S, Vn.4S + /// uint32x4_t vrev64q_u32 (uint32x4_t vec) + /// A32: VREV64.32 Qd, Qm + /// A64: REV64 Vd.4S, Vn.4S /// public static Vector128 ReverseElement32(Vector128 value) => ReverseElement32(value); /// - /// int8x8_t vrev16_s8 (int8x8_t vec) - /// A32: VREV16.8 Dd, Dm - /// A64: REV16 Vd.8B, Vn.8B + /// int8x8_t vrev16_s8 (int8x8_t vec) + /// A32: VREV16.8 Dd, Dm + /// A64: REV16 Vd.8B, Vn.8B /// public static Vector64 ReverseElement8(Vector64 value) => ReverseElement8(value); /// - /// int8x8_t vrev32_s8 (int8x8_t vec) - /// A32: VREV32.8 Dd, Dm - /// A64: REV32 Vd.8B, Vn.8B + /// int8x8_t vrev32_s8 (int8x8_t vec) + /// A32: VREV32.8 Dd, Dm + /// A64: REV32 Vd.8B, Vn.8B /// public static Vector64 ReverseElement8(Vector64 value) => ReverseElement8(value); /// - /// int8x8_t vrev64_s8 (int8x8_t vec) - /// A32: VREV64.8 Dd, Dm - /// A64: REV64 Vd.8B, Vn.8B + /// int8x8_t vrev64_s8 (int8x8_t vec) + /// A32: VREV64.8 Dd, Dm + /// A64: REV64 Vd.8B, Vn.8B /// public static Vector64 ReverseElement8(Vector64 value) => ReverseElement8(value); /// - /// uint8x8_t vrev16_u8 (uint8x8_t vec) - /// A32: VREV16.8 Dd, Dm - /// A64: REV16 Vd.8B, Vn.8B + /// uint8x8_t vrev16_u8 (uint8x8_t vec) + /// A32: VREV16.8 Dd, Dm + /// A64: REV16 Vd.8B, Vn.8B /// public static Vector64 ReverseElement8(Vector64 value) => ReverseElement8(value); /// - /// uint8x8_t vrev32_u8 (uint8x8_t vec) - /// A32: VREV32.8 Dd, Dm - /// A64: REV32 Vd.8B, Vn.8B + /// uint8x8_t vrev32_u8 (uint8x8_t vec) + /// A32: VREV32.8 Dd, Dm + /// A64: REV32 Vd.8B, Vn.8B /// public static Vector64 ReverseElement8(Vector64 value) => ReverseElement8(value); /// - /// uint8x8_t vrev64_u8 (uint8x8_t vec) - /// A32: VREV64.8 Dd, Dm - /// A64: REV64 Vd.8B, Vn.8B + /// uint8x8_t vrev64_u8 (uint8x8_t vec) + /// A32: VREV64.8 Dd, Dm + /// A64: REV64 Vd.8B, Vn.8B /// public static Vector64 ReverseElement8(Vector64 value) => ReverseElement8(value); /// - /// int8x16_t vrev16q_s8 (int8x16_t vec) - /// A32: VREV16.8 Qd, Qm - /// A64: REV16 Vd.16B, Vn.16B + /// int8x16_t vrev16q_s8 (int8x16_t vec) + /// A32: VREV16.8 Qd, Qm + /// A64: REV16 Vd.16B, Vn.16B /// public static Vector128 ReverseElement8(Vector128 value) => ReverseElement8(value); /// - /// int8x16_t vrev32q_s8 (int8x16_t vec) - /// A32: VREV32.8 Qd, Qm - /// A64: REV32 Vd.16B, Vn.16B + /// int8x16_t vrev32q_s8 (int8x16_t vec) + /// A32: VREV32.8 Qd, Qm + /// A64: REV32 Vd.16B, Vn.16B /// public static Vector128 ReverseElement8(Vector128 value) => ReverseElement8(value); /// - /// int8x16_t vrev64q_s8 (int8x16_t vec) - /// A32: VREV64.8 Qd, Qm - /// A64: REV64 Vd.16B, Vn.16B + /// int8x16_t vrev64q_s8 (int8x16_t vec) + /// A32: VREV64.8 Qd, Qm + /// A64: REV64 Vd.16B, Vn.16B /// public static Vector128 ReverseElement8(Vector128 value) => ReverseElement8(value); /// - /// uint8x16_t vrev16q_u8 (uint8x16_t vec) - /// A32: VREV16.8 Qd, Qm - /// A64: REV16 Vd.16B, Vn.16B + /// uint8x16_t vrev16q_u8 (uint8x16_t vec) + /// A32: VREV16.8 Qd, Qm + /// A64: REV16 Vd.16B, Vn.16B /// public static Vector128 ReverseElement8(Vector128 value) => ReverseElement8(value); /// - /// uint8x16_t vrev32q_u8 (uint8x16_t vec) - /// A32: VREV32.8 Qd, Qm - /// A64: REV32 Vd.16B, Vn.16B + /// uint8x16_t vrev32q_u8 (uint8x16_t vec) + /// A32: VREV32.8 Qd, Qm + /// A64: REV32 Vd.16B, Vn.16B /// public static Vector128 ReverseElement8(Vector128 value) => ReverseElement8(value); /// - /// uint8x16_t vrev64q_u8 (uint8x16_t vec) - /// A32: VREV64.8 Qd, Qm - /// A64: REV64 Vd.16B, Vn.16B + /// uint8x16_t vrev64q_u8 (uint8x16_t vec) + /// A32: VREV64.8 Qd, Qm + /// A64: REV64 Vd.16B, Vn.16B /// public static Vector128 ReverseElement8(Vector128 value) => ReverseElement8(value); /// - /// float32x2_t vrnda_f32 (float32x2_t a) - /// A32: VRINTA.F32 Dd, Dm - /// A64: FRINTA Vd.2S, Vn.2S + /// float32x2_t vrnda_f32 (float32x2_t a) + /// A32: VRINTA.F32 Dd, Dm + /// A64: FRINTA Vd.2S, Vn.2S /// public static Vector64 RoundAwayFromZero(Vector64 value) => RoundAwayFromZero(value); /// - /// float32x4_t vrndaq_f32 (float32x4_t a) - /// A32: VRINTA.F32 Qd, Qm - /// A64: FRINTA Vd.4S, Vn.4S + /// float32x4_t vrndaq_f32 (float32x4_t a) + /// A32: VRINTA.F32 Qd, Qm + /// A64: FRINTA Vd.4S, Vn.4S /// public static Vector128 RoundAwayFromZero(Vector128 value) => RoundAwayFromZero(value); /// - /// float64x1_t vrnda_f64 (float64x1_t a) - /// A32: VRINTA.F64 Dd, Dm - /// A64: FRINTA Dd, Dn + /// float64x1_t vrnda_f64 (float64x1_t a) + /// A32: VRINTA.F64 Dd, Dm + /// A64: FRINTA Dd, Dn /// public static Vector64 RoundAwayFromZeroScalar(Vector64 value) => RoundAwayFromZeroScalar(value); /// - /// float32_t vrndas_f32 (float32_t a) - /// A32: VRINTA.F32 Sd, Sm - /// A64: FRINTA Sd, Sn - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vrndas_f32 (float32_t a) + /// A32: VRINTA.F32 Sd, Sm + /// A64: FRINTA Sd, Sn + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 RoundAwayFromZeroScalar(Vector64 value) => RoundAwayFromZeroScalar(value); /// - /// float32x2_t vrndn_f32 (float32x2_t a) - /// A32: VRINTN.F32 Dd, Dm - /// A64: FRINTN Vd.2S, Vn.2S + /// float32x2_t vrndn_f32 (float32x2_t a) + /// A32: VRINTN.F32 Dd, Dm + /// A64: FRINTN Vd.2S, Vn.2S /// public static Vector64 RoundToNearest(Vector64 value) => RoundToNearest(value); /// - /// float32x4_t vrndnq_f32 (float32x4_t a) - /// A32: VRINTN.F32 Qd, Qm - /// A64: FRINTN Vd.4S, Vn.4S + /// float32x4_t vrndnq_f32 (float32x4_t a) + /// A32: VRINTN.F32 Qd, Qm + /// A64: FRINTN Vd.4S, Vn.4S /// public static Vector128 RoundToNearest(Vector128 value) => RoundToNearest(value); /// - /// float64x1_t vrndn_f64 (float64x1_t a) - /// A32: VRINTN.F64 Dd, Dm - /// A64: FRINTN Dd, Dn + /// float64x1_t vrndn_f64 (float64x1_t a) + /// A32: VRINTN.F64 Dd, Dm + /// A64: FRINTN Dd, Dn /// public static Vector64 RoundToNearestScalar(Vector64 value) => RoundToNearestScalar(value); /// - /// float32_t vrndns_f32 (float32_t a) - /// A32: VRINTN.F32 Sd, Sm - /// A64: FRINTN Sd, Sn - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vrndns_f32 (float32_t a) + /// A32: VRINTN.F32 Sd, Sm + /// A64: FRINTN Sd, Sn + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 RoundToNearestScalar(Vector64 value) => RoundToNearestScalar(value); /// - /// float32x2_t vrndm_f32 (float32x2_t a) - /// A32: VRINTM.F32 Dd, Dm - /// A64: FRINTM Vd.2S, Vn.2S + /// float32x2_t vrndm_f32 (float32x2_t a) + /// A32: VRINTM.F32 Dd, Dm + /// A64: FRINTM Vd.2S, Vn.2S /// public static Vector64 RoundToNegativeInfinity(Vector64 value) => RoundToNegativeInfinity(value); /// - /// float32x4_t vrndmq_f32 (float32x4_t a) - /// A32: VRINTM.F32 Qd, Qm - /// A64: FRINTM Vd.4S, Vn.4S + /// float32x4_t vrndmq_f32 (float32x4_t a) + /// A32: VRINTM.F32 Qd, Qm + /// A64: FRINTM Vd.4S, Vn.4S /// public static Vector128 RoundToNegativeInfinity(Vector128 value) => RoundToNegativeInfinity(value); /// - /// float64x1_t vrndm_f64 (float64x1_t a) - /// A32: VRINTM.F64 Dd, Dm - /// A64: FRINTM Dd, Dn + /// float64x1_t vrndm_f64 (float64x1_t a) + /// A32: VRINTM.F64 Dd, Dm + /// A64: FRINTM Dd, Dn /// public static Vector64 RoundToNegativeInfinityScalar(Vector64 value) => RoundToNegativeInfinityScalar(value); /// - /// float32_t vrndms_f32 (float32_t a) - /// A32: VRINTM.F32 Sd, Sm - /// A64: FRINTM Sd, Sn - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vrndms_f32 (float32_t a) + /// A32: VRINTM.F32 Sd, Sm + /// A64: FRINTM Sd, Sn + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 RoundToNegativeInfinityScalar(Vector64 value) => RoundToNegativeInfinityScalar(value); /// - /// float32x2_t vrndp_f32 (float32x2_t a) - /// A32: VRINTP.F32 Dd, Dm - /// A64: FRINTP Vd.2S, Vn.2S + /// float32x2_t vrndp_f32 (float32x2_t a) + /// A32: VRINTP.F32 Dd, Dm + /// A64: FRINTP Vd.2S, Vn.2S /// public static Vector64 RoundToPositiveInfinity(Vector64 value) => RoundToPositiveInfinity(value); /// - /// float32x4_t vrndpq_f32 (float32x4_t a) - /// A32: VRINTP.F32 Qd, Qm - /// A64: FRINTP Vd.4S, Vn.4S + /// float32x4_t vrndpq_f32 (float32x4_t a) + /// A32: VRINTP.F32 Qd, Qm + /// A64: FRINTP Vd.4S, Vn.4S /// public static Vector128 RoundToPositiveInfinity(Vector128 value) => RoundToPositiveInfinity(value); /// - /// float64x1_t vrndp_f64 (float64x1_t a) - /// A32: VRINTP.F64 Dd, Dm - /// A64: FRINTP Dd, Dn + /// float64x1_t vrndp_f64 (float64x1_t a) + /// A32: VRINTP.F64 Dd, Dm + /// A64: FRINTP Dd, Dn /// public static Vector64 RoundToPositiveInfinityScalar(Vector64 value) => RoundToPositiveInfinityScalar(value); /// - /// float32_t vrndps_f32 (float32_t a) - /// A32: VRINTP.F32 Sd, Sm - /// A64: FRINTP Sd, Sn - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vrndps_f32 (float32_t a) + /// A32: VRINTP.F32 Sd, Sm + /// A64: FRINTP Sd, Sn + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 RoundToPositiveInfinityScalar(Vector64 value) => RoundToPositiveInfinityScalar(value); /// - /// float32x2_t vrnd_f32 (float32x2_t a) - /// A32: VRINTZ.F32 Dd, Dm - /// A64: FRINTZ Vd.2S, Vn.2S + /// float32x2_t vrnd_f32 (float32x2_t a) + /// A32: VRINTZ.F32 Dd, Dm + /// A64: FRINTZ Vd.2S, Vn.2S /// public static Vector64 RoundToZero(Vector64 value) => RoundToZero(value); /// - /// float32x4_t vrndq_f32 (float32x4_t a) - /// A32: VRINTZ.F32 Qd, Qm - /// A64: FRINTZ Vd.4S, Vn.4S + /// float32x4_t vrndq_f32 (float32x4_t a) + /// A32: VRINTZ.F32 Qd, Qm + /// A64: FRINTZ Vd.4S, Vn.4S /// public static Vector128 RoundToZero(Vector128 value) => RoundToZero(value); /// - /// float64x1_t vrnd_f64 (float64x1_t a) - /// A32: VRINTZ.F64 Dd, Dm - /// A64: FRINTZ Dd, Dn + /// float64x1_t vrnd_f64 (float64x1_t a) + /// A32: VRINTZ.F64 Dd, Dm + /// A64: FRINTZ Dd, Dn /// public static Vector64 RoundToZeroScalar(Vector64 value) => RoundToZeroScalar(value); /// - /// float32_t vrnds_f32 (float32_t a) - /// A32: VRINTZ.F32 Sd, Sm - /// A64: FRINTZ Sd, Sn - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vrnds_f32 (float32_t a) + /// A32: VRINTZ.F32 Sd, Sm + /// A64: FRINTZ Sd, Sn + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 RoundToZeroScalar(Vector64 value) => RoundToZeroScalar(value); /// - /// int16x4_t vshl_s16 (int16x4_t a, int16x4_t b) - /// A32: VSHL.S16 Dd, Dn, Dm - /// A64: SSHL Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vshl_s16 (int16x4_t a, int16x4_t b) + /// A32: VSHL.S16 Dd, Dn, Dm + /// A64: SSHL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ShiftArithmetic(Vector64 value, Vector64 count) => ShiftArithmetic(value, count); /// - /// int32x2_t vshl_s32 (int32x2_t a, int32x2_t b) - /// A32: VSHL.S32 Dd, Dn, Dm - /// A64: SSHL Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vshl_s32 (int32x2_t a, int32x2_t b) + /// A32: VSHL.S32 Dd, Dn, Dm + /// A64: SSHL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ShiftArithmetic(Vector64 value, Vector64 count) => ShiftArithmetic(value, count); /// - /// int8x8_t vshl_s8 (int8x8_t a, int8x8_t b) - /// A32: VSHL.S8 Dd, Dn, Dm - /// A64: SSHL Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vshl_s8 (int8x8_t a, int8x8_t b) + /// A32: VSHL.S8 Dd, Dn, Dm + /// A64: SSHL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ShiftArithmetic(Vector64 value, Vector64 count) => ShiftArithmetic(value, count); /// - /// int16x8_t vshlq_s16 (int16x8_t a, int16x8_t b) - /// A32: VSHL.S16 Qd, Qn, Qm - /// A64: SSHL Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vshlq_s16 (int16x8_t a, int16x8_t b) + /// A32: VSHL.S16 Qd, Qn, Qm + /// A64: SSHL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ShiftArithmetic(Vector128 value, Vector128 count) => ShiftArithmetic(value, count); /// - /// int32x4_t vshlq_s32 (int32x4_t a, int32x4_t b) - /// A32: VSHL.S32 Qd, Qn, Qm - /// A64: SSHL Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vshlq_s32 (int32x4_t a, int32x4_t b) + /// A32: VSHL.S32 Qd, Qn, Qm + /// A64: SSHL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ShiftArithmetic(Vector128 value, Vector128 count) => ShiftArithmetic(value, count); /// - /// int64x2_t vshlq_s64 (int64x2_t a, int64x2_t b) - /// A32: VSHL.S64 Qd, Qn, Qm - /// A64: SSHL Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vshlq_s64 (int64x2_t a, int64x2_t b) + /// A32: VSHL.S64 Qd, Qn, Qm + /// A64: SSHL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ShiftArithmetic(Vector128 value, Vector128 count) => ShiftArithmetic(value, count); /// - /// int8x16_t vshlq_s8 (int8x16_t a, int8x16_t b) - /// A32: VSHL.S8 Qd, Qn, Qm - /// A64: SSHL Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vshlq_s8 (int8x16_t a, int8x16_t b) + /// A32: VSHL.S8 Qd, Qn, Qm + /// A64: SSHL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ShiftArithmetic(Vector128 value, Vector128 count) => ShiftArithmetic(value, count); /// - /// int16x4_t vrshl_s16 (int16x4_t a, int16x4_t b) - /// A32: VRSHL.S16 Dd, Dn, Dm - /// A64: SRSHL Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vrshl_s16 (int16x4_t a, int16x4_t b) + /// A32: VRSHL.S16 Dd, Dn, Dm + /// A64: SRSHL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ShiftArithmeticRounded(Vector64 value, Vector64 count) => ShiftArithmeticRounded(value, count); /// - /// int32x2_t vrshl_s32 (int32x2_t a, int32x2_t b) - /// A32: VRSHL.S32 Dd, Dn, Dm - /// A64: SRSHL Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vrshl_s32 (int32x2_t a, int32x2_t b) + /// A32: VRSHL.S32 Dd, Dn, Dm + /// A64: SRSHL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ShiftArithmeticRounded(Vector64 value, Vector64 count) => ShiftArithmeticRounded(value, count); /// - /// int8x8_t vrshl_s8 (int8x8_t a, int8x8_t b) - /// A32: VRSHL.S8 Dd, Dn, Dm - /// A64: SRSHL Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vrshl_s8 (int8x8_t a, int8x8_t b) + /// A32: VRSHL.S8 Dd, Dn, Dm + /// A64: SRSHL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ShiftArithmeticRounded(Vector64 value, Vector64 count) => ShiftArithmeticRounded(value, count); /// - /// int16x8_t vrshlq_s16 (int16x8_t a, int16x8_t b) - /// A32: VRSHL.S16 Qd, Qn, Qm - /// A64: SRSHL Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vrshlq_s16 (int16x8_t a, int16x8_t b) + /// A32: VRSHL.S16 Qd, Qn, Qm + /// A64: SRSHL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ShiftArithmeticRounded(Vector128 value, Vector128 count) => ShiftArithmeticRounded(value, count); /// - /// int32x4_t vrshlq_s32 (int32x4_t a, int32x4_t b) - /// A32: VRSHL.S32 Qd, Qn, Qm - /// A64: SRSHL Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vrshlq_s32 (int32x4_t a, int32x4_t b) + /// A32: VRSHL.S32 Qd, Qn, Qm + /// A64: SRSHL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ShiftArithmeticRounded(Vector128 value, Vector128 count) => ShiftArithmeticRounded(value, count); /// - /// int64x2_t vrshlq_s64 (int64x2_t a, int64x2_t b) - /// A32: VRSHL.S64 Qd, Qn, Qm - /// A64: SRSHL Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vrshlq_s64 (int64x2_t a, int64x2_t b) + /// A32: VRSHL.S64 Qd, Qn, Qm + /// A64: SRSHL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ShiftArithmeticRounded(Vector128 value, Vector128 count) => ShiftArithmeticRounded(value, count); /// - /// int8x16_t vrshlq_s8 (int8x16_t a, int8x16_t b) - /// A32: VRSHL.S8 Qd, Qn, Qm - /// A64: SRSHL Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vrshlq_s8 (int8x16_t a, int8x16_t b) + /// A32: VRSHL.S8 Qd, Qn, Qm + /// A64: SRSHL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ShiftArithmeticRounded(Vector128 value, Vector128 count) => ShiftArithmeticRounded(value, count); /// - /// int16x4_t vqrshl_s16 (int16x4_t a, int16x4_t b) - /// A32: VQRSHL.S16 Dd, Dn, Dm - /// A64: SQRSHL Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vqrshl_s16 (int16x4_t a, int16x4_t b) + /// A32: VQRSHL.S16 Dd, Dn, Dm + /// A64: SQRSHL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ShiftArithmeticRoundedSaturate(Vector64 value, Vector64 count) => ShiftArithmeticRoundedSaturate(value, count); /// - /// int32x2_t vqrshl_s32 (int32x2_t a, int32x2_t b) - /// A32: VQRSHL.S32 Dd, Dn, Dm - /// A64: SQRSHL Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vqrshl_s32 (int32x2_t a, int32x2_t b) + /// A32: VQRSHL.S32 Dd, Dn, Dm + /// A64: SQRSHL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ShiftArithmeticRoundedSaturate(Vector64 value, Vector64 count) => ShiftArithmeticRoundedSaturate(value, count); /// - /// int8x8_t vqrshl_s8 (int8x8_t a, int8x8_t b) - /// A32: VQRSHL.S8 Dd, Dn, Dm - /// A64: SQRSHL Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vqrshl_s8 (int8x8_t a, int8x8_t b) + /// A32: VQRSHL.S8 Dd, Dn, Dm + /// A64: SQRSHL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ShiftArithmeticRoundedSaturate(Vector64 value, Vector64 count) => ShiftArithmeticRoundedSaturate(value, count); /// - /// int16x8_t vqrshlq_s16 (int16x8_t a, int16x8_t b) - /// A32: VQRSHL.S16 Qd, Qn, Qm - /// A64: SQRSHL Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vqrshlq_s16 (int16x8_t a, int16x8_t b) + /// A32: VQRSHL.S16 Qd, Qn, Qm + /// A64: SQRSHL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ShiftArithmeticRoundedSaturate(Vector128 value, Vector128 count) => ShiftArithmeticRoundedSaturate(value, count); /// - /// int32x4_t vqrshlq_s32 (int32x4_t a, int32x4_t b) - /// A32: VQRSHL.S32 Qd, Qn, Qm - /// A64: SQRSHL Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vqrshlq_s32 (int32x4_t a, int32x4_t b) + /// A32: VQRSHL.S32 Qd, Qn, Qm + /// A64: SQRSHL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ShiftArithmeticRoundedSaturate(Vector128 value, Vector128 count) => ShiftArithmeticRoundedSaturate(value, count); /// - /// int64x2_t vqrshlq_s64 (int64x2_t a, int64x2_t b) - /// A32: VQRSHL.S64 Qd, Qn, Qm - /// A64: SQRSHL Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vqrshlq_s64 (int64x2_t a, int64x2_t b) + /// A32: VQRSHL.S64 Qd, Qn, Qm + /// A64: SQRSHL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ShiftArithmeticRoundedSaturate(Vector128 value, Vector128 count) => ShiftArithmeticRoundedSaturate(value, count); /// - /// int8x16_t vqrshlq_s8 (int8x16_t a, int8x16_t b) - /// A32: VQRSHL.S8 Qd, Qn, Qm - /// A64: SQRSHL Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vqrshlq_s8 (int8x16_t a, int8x16_t b) + /// A32: VQRSHL.S8 Qd, Qn, Qm + /// A64: SQRSHL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ShiftArithmeticRoundedSaturate(Vector128 value, Vector128 count) => ShiftArithmeticRoundedSaturate(value, count); /// - /// int64x1_t vqrshl_s64 (int64x1_t a, int64x1_t b) - /// A32: VQRSHL.S64 Dd, Dn, Dm - /// A64: SQRSHL Dd, Dn, Dm + /// int64x1_t vqrshl_s64 (int64x1_t a, int64x1_t b) + /// A32: VQRSHL.S64 Dd, Dn, Dm + /// A64: SQRSHL Dd, Dn, Dm /// public static Vector64 ShiftArithmeticRoundedSaturateScalar(Vector64 value, Vector64 count) => ShiftArithmeticRoundedSaturateScalar(value, count); /// - /// int64x1_t vrshl_s64 (int64x1_t a, int64x1_t b) - /// A32: VRSHL.S64 Dd, Dn, Dm - /// A64: SRSHL Dd, Dn, Dm + /// int64x1_t vrshl_s64 (int64x1_t a, int64x1_t b) + /// A32: VRSHL.S64 Dd, Dn, Dm + /// A64: SRSHL Dd, Dn, Dm /// public static Vector64 ShiftArithmeticRoundedScalar(Vector64 value, Vector64 count) => ShiftArithmeticRoundedScalar(value, count); /// - /// int16x4_t vqshl_s16 (int16x4_t a, int16x4_t b) - /// A32: VQSHL.S16 Dd, Dn, Dm - /// A64: SQSHL Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vqshl_s16 (int16x4_t a, int16x4_t b) + /// A32: VQSHL.S16 Dd, Dn, Dm + /// A64: SQSHL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ShiftArithmeticSaturate(Vector64 value, Vector64 count) => ShiftArithmeticSaturate(value, count); /// - /// int32x2_t vqshl_s32 (int32x2_t a, int32x2_t b) - /// A32: VQSHL.S32 Dd, Dn, Dm - /// A64: SQSHL Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vqshl_s32 (int32x2_t a, int32x2_t b) + /// A32: VQSHL.S32 Dd, Dn, Dm + /// A64: SQSHL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ShiftArithmeticSaturate(Vector64 value, Vector64 count) => ShiftArithmeticSaturate(value, count); /// - /// int8x8_t vqshl_s8 (int8x8_t a, int8x8_t b) - /// A32: VQSHL.S8 Dd, Dn, Dm - /// A64: SQSHL Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vqshl_s8 (int8x8_t a, int8x8_t b) + /// A32: VQSHL.S8 Dd, Dn, Dm + /// A64: SQSHL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ShiftArithmeticSaturate(Vector64 value, Vector64 count) => ShiftArithmeticSaturate(value, count); /// - /// int16x8_t vqshlq_s16 (int16x8_t a, int16x8_t b) - /// A32: VQSHL.S16 Qd, Qn, Qm - /// A64: SQSHL Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vqshlq_s16 (int16x8_t a, int16x8_t b) + /// A32: VQSHL.S16 Qd, Qn, Qm + /// A64: SQSHL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ShiftArithmeticSaturate(Vector128 value, Vector128 count) => ShiftArithmeticSaturate(value, count); /// - /// int32x4_t vqshlq_s32 (int32x4_t a, int32x4_t b) - /// A32: VQSHL.S32 Qd, Qn, Qm - /// A64: SQSHL Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vqshlq_s32 (int32x4_t a, int32x4_t b) + /// A32: VQSHL.S32 Qd, Qn, Qm + /// A64: SQSHL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ShiftArithmeticSaturate(Vector128 value, Vector128 count) => ShiftArithmeticSaturate(value, count); /// - /// int64x2_t vqshlq_s64 (int64x2_t a, int64x2_t b) - /// A32: VQSHL.S64 Qd, Qn, Qm - /// A64: SQSHL Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vqshlq_s64 (int64x2_t a, int64x2_t b) + /// A32: VQSHL.S64 Qd, Qn, Qm + /// A64: SQSHL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ShiftArithmeticSaturate(Vector128 value, Vector128 count) => ShiftArithmeticSaturate(value, count); /// - /// int8x16_t vqshlq_s8 (int8x16_t a, int8x16_t b) - /// A32: VQSHL.S8 Qd, Qn, Qm - /// A64: SQSHL Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vqshlq_s8 (int8x16_t a, int8x16_t b) + /// A32: VQSHL.S8 Qd, Qn, Qm + /// A64: SQSHL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ShiftArithmeticSaturate(Vector128 value, Vector128 count) => ShiftArithmeticSaturate(value, count); /// - /// int64x1_t vqshl_s64 (int64x1_t a, int64x1_t b) - /// A32: VQSHL.S64 Dd, Dn, Dm - /// A64: SQSHL Dd, Dn, Dm + /// int64x1_t vqshl_s64 (int64x1_t a, int64x1_t b) + /// A32: VQSHL.S64 Dd, Dn, Dm + /// A64: SQSHL Dd, Dn, Dm /// public static Vector64 ShiftArithmeticSaturateScalar(Vector64 value, Vector64 count) => ShiftArithmeticSaturateScalar(value, count); /// - /// int64x1_t vshl_s64 (int64x1_t a, int64x1_t b) - /// A32: VSHL.S64 Dd, Dn, Dm - /// A64: SSHL Dd, Dn, Dm + /// int64x1_t vshl_s64 (int64x1_t a, int64x1_t b) + /// A32: VSHL.S64 Dd, Dn, Dm + /// A64: SSHL Dd, Dn, Dm /// public static Vector64 ShiftArithmeticScalar(Vector64 value, Vector64 count) => ShiftArithmeticScalar(value, count); /// - /// uint8x8_t vsli_n_u8(uint8x8_t a, uint8x8_t b, __builtin_constant_p(n)) - /// A32: VSLI.8 Dd, Dm, #n - /// A64: SLI Vd.8B, Vn.8B, #n + /// uint8x8_t vsli_n_u8(uint8x8_t a, uint8x8_t b, __builtin_constant_p(n)) + /// A32: VSLI.8 Dd, Dm, #n + /// A64: SLI Vd.8B, Vn.8B, #n /// public static Vector64 ShiftLeftAndInsert(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(7))] byte shift) => ShiftLeftAndInsert(left, right, shift); /// - /// int16x4_t vsli_n_s16(int16x4_t a, int16x4_t b, __builtin_constant_p(n)) - /// A32: VSLI.16 Dd, Dm, #n - /// A64: SLI Vd.4H, Vn.4H, #n + /// int16x4_t vsli_n_s16(int16x4_t a, int16x4_t b, __builtin_constant_p(n)) + /// A32: VSLI.16 Dd, Dm, #n + /// A64: SLI Vd.4H, Vn.4H, #n /// public static Vector64 ShiftLeftAndInsert(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftLeftAndInsert(left, right, shift); /// - /// int32x2_t vsli_n_s32(int32x2_t a, int32x2_t b, __builtin_constant_p(n)) - /// A32: VSLI.32 Dd, Dm, #n - /// A64: SLI Vd.2S, Vn.2S, #n + /// int32x2_t vsli_n_s32(int32x2_t a, int32x2_t b, __builtin_constant_p(n)) + /// A32: VSLI.32 Dd, Dm, #n + /// A64: SLI Vd.2S, Vn.2S, #n /// public static Vector64 ShiftLeftAndInsert(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftLeftAndInsert(left, right, shift); /// - /// int8x8_t vsli_n_s8(int8x8_t a, int8x8_t b, __builtin_constant_p(n)) - /// A32: VSLI.8 Dd, Dm, #n - /// A64: SLI Vd.8B, Vn.8B, #n + /// int8x8_t vsli_n_s8(int8x8_t a, int8x8_t b, __builtin_constant_p(n)) + /// A32: VSLI.8 Dd, Dm, #n + /// A64: SLI Vd.8B, Vn.8B, #n /// public static Vector64 ShiftLeftAndInsert(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(7))] byte shift) => ShiftLeftAndInsert(left, right, shift); /// - /// uint16x4_t vsli_n_u16(uint16x4_t a, uint16x4_t b, __builtin_constant_p(n)) - /// A32: VSLI.16 Dd, Dm, #n - /// A64: SLI Vd.4H, Vn.4H, #n + /// uint16x4_t vsli_n_u16(uint16x4_t a, uint16x4_t b, __builtin_constant_p(n)) + /// A32: VSLI.16 Dd, Dm, #n + /// A64: SLI Vd.4H, Vn.4H, #n /// public static Vector64 ShiftLeftAndInsert(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftLeftAndInsert(left, right, shift); /// - /// uint32x2_t vsli_n_u32(uint32x2_t a, uint32x2_t b, __builtin_constant_p(n)) - /// A32: VSLI.32 Dd, Dm, #n - /// A64: SLI Vd.2S, Vn.2S, #n + /// uint32x2_t vsli_n_u32(uint32x2_t a, uint32x2_t b, __builtin_constant_p(n)) + /// A32: VSLI.32 Dd, Dm, #n + /// A64: SLI Vd.2S, Vn.2S, #n /// public static Vector64 ShiftLeftAndInsert(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftLeftAndInsert(left, right, shift); /// - /// uint8x16_t vsliq_n_u8(uint8x16_t a, uint8x16_t b, __builtin_constant_p(n)) - /// A32: VSLI.8 Qd, Qm, #n - /// A64: SLI Vd.16B, Vn.16B, #n + /// uint8x16_t vsliq_n_u8(uint8x16_t a, uint8x16_t b, __builtin_constant_p(n)) + /// A32: VSLI.8 Qd, Qm, #n + /// A64: SLI Vd.16B, Vn.16B, #n /// public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte shift) => ShiftLeftAndInsert(left, right, shift); /// - /// int16x8_t vsliq_n_s16(int16x8_t a, int16x8_t b, __builtin_constant_p(n)) - /// A32: VSLI.16 Qd, Qm, #n - /// A64: SLI Vd.8H, Vn.8H, #n + /// int16x8_t vsliq_n_s16(int16x8_t a, int16x8_t b, __builtin_constant_p(n)) + /// A32: VSLI.16 Qd, Qm, #n + /// A64: SLI Vd.8H, Vn.8H, #n /// public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftLeftAndInsert(left, right, shift); /// - /// int32x4_t vsliq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n)) - /// A32: VSLI.32 Qd, Qm, #n - /// A64: SLI Vd.4S, Vn.4S, #n + /// int32x4_t vsliq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n)) + /// A32: VSLI.32 Qd, Qm, #n + /// A64: SLI Vd.4S, Vn.4S, #n /// public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftLeftAndInsert(left, right, shift); /// - /// int64x2_t vsliq_n_s64(int64x2_t a, int64x2_t b, __builtin_constant_p(n)) - /// A32: VSLI.64 Qd, Qm, #n - /// A64: SLI Vd.2D, Vn.2D, #n + /// int64x2_t vsliq_n_s64(int64x2_t a, int64x2_t b, __builtin_constant_p(n)) + /// A32: VSLI.64 Qd, Qm, #n + /// A64: SLI Vd.2D, Vn.2D, #n /// public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftLeftAndInsert(left, right, shift); /// - /// int8x16_t vsliq_n_s8(int8x16_t a, int8x16_t b, __builtin_constant_p(n)) - /// A32: VSLI.8 Qd, Qm, #n - /// A64: SLI Vd.16B, Vn.16B, #n + /// int8x16_t vsliq_n_s8(int8x16_t a, int8x16_t b, __builtin_constant_p(n)) + /// A32: VSLI.8 Qd, Qm, #n + /// A64: SLI Vd.16B, Vn.16B, #n /// public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte shift) => ShiftLeftAndInsert(left, right, shift); /// - /// uint16x8_t vsliq_n_u16(uint16x8_t a, uint16x8_t b, __builtin_constant_p(n)) - /// A32: VSLI.16 Qd, Qm, #n - /// A64: SLI Vd.8H, Vn.8H, #n + /// uint16x8_t vsliq_n_u16(uint16x8_t a, uint16x8_t b, __builtin_constant_p(n)) + /// A32: VSLI.16 Qd, Qm, #n + /// A64: SLI Vd.8H, Vn.8H, #n /// public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(15))] byte shift) => ShiftLeftAndInsert(left, right, shift); /// - /// uint32x4_t vsliq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n)) - /// A32: VSLI.32 Qd, Qm, #n - /// A64: SLI Vd.4S, Vn.4S, #n + /// uint32x4_t vsliq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n)) + /// A32: VSLI.32 Qd, Qm, #n + /// A64: SLI Vd.4S, Vn.4S, #n /// public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(31))] byte shift) => ShiftLeftAndInsert(left, right, shift); /// - /// uint64x2_t vsliq_n_u64(uint64x2_t a, uint64x2_t b, __builtin_constant_p(n)) - /// A32: VSLI.64 Qd, Qm, #n - /// A64: SLI Vd.2D, Vn.2D, #n + /// uint64x2_t vsliq_n_u64(uint64x2_t a, uint64x2_t b, __builtin_constant_p(n)) + /// A32: VSLI.64 Qd, Qm, #n + /// A64: SLI Vd.2D, Vn.2D, #n /// public static Vector128 ShiftLeftAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftLeftAndInsert(left, right, shift); /// - /// int64_t vslid_n_s64(int64_t a, int64_t b, __builtin_constant_p(n)) - /// A32: VSLI.64 Dd, Dm, #n - /// A64: SLI Dd, Dn, #n + /// int64_t vslid_n_s64(int64_t a, int64_t b, __builtin_constant_p(n)) + /// A32: VSLI.64 Dd, Dm, #n + /// A64: SLI Dd, Dn, #n /// public static Vector64 ShiftLeftAndInsertScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftLeftAndInsertScalar(left, right, shift); /// - /// uint64_t vslid_n_u64(uint64_t a, uint64_t b, __builtin_constant_p(n)) - /// A32: VSLI.64 Dd, Dm, #n - /// A64: SLI Dd, Dn, #n + /// uint64_t vslid_n_u64(uint64_t a, uint64_t b, __builtin_constant_p(n)) + /// A32: VSLI.64 Dd, Dm, #n + /// A64: SLI Dd, Dn, #n /// public static Vector64 ShiftLeftAndInsertScalar(Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(63))] byte shift) => ShiftLeftAndInsertScalar(left, right, shift); /// - /// uint8x8_t vshl_n_u8 (uint8x8_t a, const int n) - /// A32: VSHL.I8 Dd, Dm, #n - /// A64: SHL Vd.8B, Vn.8B, #n + /// uint8x8_t vshl_n_u8 (uint8x8_t a, const int n) + /// A32: VSHL.I8 Dd, Dm, #n + /// A64: SHL Vd.8B, Vn.8B, #n /// public static Vector64 ShiftLeftLogical(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogical(value, count); /// - /// int16x4_t vshl_n_s16 (int16x4_t a, const int n) - /// A32: VSHL.I16 Dd, Dm, #n - /// A64: SHL Vd.4H, Vn.4H, #n + /// int16x4_t vshl_n_s16 (int16x4_t a, const int n) + /// A32: VSHL.I16 Dd, Dm, #n + /// A64: SHL Vd.4H, Vn.4H, #n /// public static Vector64 ShiftLeftLogical(Vector64 value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogical(value, count); /// - /// int32x2_t vshl_n_s32 (int32x2_t a, const int n) - /// A32: VSHL.I32 Dd, Dm, #n - /// A64: SHL Vd.2S, Vn.2S, #n + /// int32x2_t vshl_n_s32 (int32x2_t a, const int n) + /// A32: VSHL.I32 Dd, Dm, #n + /// A64: SHL Vd.2S, Vn.2S, #n /// public static Vector64 ShiftLeftLogical(Vector64 value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogical(value, count); /// - /// int8x8_t vshl_n_s8 (int8x8_t a, const int n) - /// A32: VSHL.I8 Dd, Dm, #n - /// A64: SHL Vd.8B, Vn.8B, #n + /// int8x8_t vshl_n_s8 (int8x8_t a, const int n) + /// A32: VSHL.I8 Dd, Dm, #n + /// A64: SHL Vd.8B, Vn.8B, #n /// public static Vector64 ShiftLeftLogical(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogical(value, count); /// - /// uint16x4_t vshl_n_u16 (uint16x4_t a, const int n) - /// A32: VSHL.I16 Dd, Dm, #n - /// A64: SHL Vd.4H, Vn.4H, #n + /// uint16x4_t vshl_n_u16 (uint16x4_t a, const int n) + /// A32: VSHL.I16 Dd, Dm, #n + /// A64: SHL Vd.4H, Vn.4H, #n /// public static Vector64 ShiftLeftLogical(Vector64 value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogical(value, count); /// - /// uint32x2_t vshl_n_u32 (uint32x2_t a, const int n) - /// A32: VSHL.I32 Dd, Dm, #n - /// A64: SHL Vd.2S, Vn.2S, #n + /// uint32x2_t vshl_n_u32 (uint32x2_t a, const int n) + /// A32: VSHL.I32 Dd, Dm, #n + /// A64: SHL Vd.2S, Vn.2S, #n /// public static Vector64 ShiftLeftLogical(Vector64 value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogical(value, count); /// - /// uint8x16_t vshlq_n_u8 (uint8x16_t a, const int n) - /// A32: VSHL.I8 Qd, Qm, #n - /// A64: SHL Vd.16B, Vn.16B, #n + /// uint8x16_t vshlq_n_u8 (uint8x16_t a, const int n) + /// A32: VSHL.I8 Qd, Qm, #n + /// A64: SHL Vd.16B, Vn.16B, #n /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogical(value, count); /// - /// int16x8_t vshlq_n_s16 (int16x8_t a, const int n) - /// A32: VSHL.I16 Qd, Qm, #n - /// A64: SHL Vd.8H, Vn.8H, #n + /// int16x8_t vshlq_n_s16 (int16x8_t a, const int n) + /// A32: VSHL.I16 Qd, Qm, #n + /// A64: SHL Vd.8H, Vn.8H, #n /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogical(value, count); /// - /// int64x2_t vshlq_n_s64 (int64x2_t a, const int n) - /// A32: VSHL.I64 Qd, Qm, #n - /// A64: SHL Vd.2D, Vn.2D, #n + /// int64x2_t vshlq_n_s64 (int64x2_t a, const int n) + /// A32: VSHL.I64 Qd, Qm, #n + /// A64: SHL Vd.2D, Vn.2D, #n /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogical(value, count); /// - /// int8x16_t vshlq_n_s8 (int8x16_t a, const int n) - /// A32: VSHL.I8 Qd, Qm, #n - /// A64: SHL Vd.16B, Vn.16B, #n + /// int8x16_t vshlq_n_s8 (int8x16_t a, const int n) + /// A32: VSHL.I8 Qd, Qm, #n + /// A64: SHL Vd.16B, Vn.16B, #n /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogical(value, count); /// - /// uint16x8_t vshlq_n_u16 (uint16x8_t a, const int n) - /// A32: VSHL.I16 Qd, Qm, #n - /// A64: SHL Vd.8H, Vn.8H, #n + /// uint16x8_t vshlq_n_u16 (uint16x8_t a, const int n) + /// A32: VSHL.I16 Qd, Qm, #n + /// A64: SHL Vd.8H, Vn.8H, #n /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogical(value, count); /// - /// uint32x4_t vshlq_n_u32 (uint32x4_t a, const int n) - /// A32: VSHL.I32 Qd, Qm, #n - /// A64: SHL Vd.4S, Vn.4S, #n + /// uint32x4_t vshlq_n_u32 (uint32x4_t a, const int n) + /// A32: VSHL.I32 Qd, Qm, #n + /// A64: SHL Vd.4S, Vn.4S, #n /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogical(value, count); /// - /// uint64x2_t vshlq_n_u64 (uint64x2_t a, const int n) - /// A32: VSHL.I64 Qd, Qm, #n - /// A64: SHL Vd.2D, Vn.2D, #n + /// uint64x2_t vshlq_n_u64 (uint64x2_t a, const int n) + /// A32: VSHL.I64 Qd, Qm, #n + /// A64: SHL Vd.2D, Vn.2D, #n /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogical(value, count); /// - /// uint8x8_t vqshl_n_u8 (uint8x8_t a, const int n) - /// A32: VQSHL.U8 Dd, Dm, #n - /// A64: UQSHL Vd.8B, Vn.8B, #n + /// uint8x8_t vqshl_n_u8 (uint8x8_t a, const int n) + /// A32: VQSHL.U8 Dd, Dm, #n + /// A64: UQSHL Vd.8B, Vn.8B, #n /// public static Vector64 ShiftLeftLogicalSaturate(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalSaturate(value, count); /// - /// int16x4_t vqshl_n_s16 (int16x4_t a, const int n) - /// A32: VQSHL.S16 Dd, Dm, #n - /// A64: SQSHL Vd.4H, Vn.4H, #n + /// int16x4_t vqshl_n_s16 (int16x4_t a, const int n) + /// A32: VQSHL.S16 Dd, Dm, #n + /// A64: SQSHL Vd.4H, Vn.4H, #n /// public static Vector64 ShiftLeftLogicalSaturate(Vector64 value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturate(value, count); /// - /// int32x2_t vqshl_n_s32 (int32x2_t a, const int n) - /// A32: VQSHL.S32 Dd, Dm, #n - /// A64: SQSHL Vd.2S, Vn.2S, #n + /// int32x2_t vqshl_n_s32 (int32x2_t a, const int n) + /// A32: VQSHL.S32 Dd, Dm, #n + /// A64: SQSHL Vd.2S, Vn.2S, #n /// public static Vector64 ShiftLeftLogicalSaturate(Vector64 value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalSaturate(value, count); /// - /// int8x8_t vqshl_n_s8 (int8x8_t a, const int n) - /// A32: VQSHL.S8 Dd, Dm, #n - /// A64: SQSHL Vd.8B, Vn.8B, #n + /// int8x8_t vqshl_n_s8 (int8x8_t a, const int n) + /// A32: VQSHL.S8 Dd, Dm, #n + /// A64: SQSHL Vd.8B, Vn.8B, #n /// public static Vector64 ShiftLeftLogicalSaturate(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalSaturate(value, count); /// - /// uint16x4_t vqshl_n_u16 (uint16x4_t a, const int n) - /// A32: VQSHL.U16 Dd, Dm, #n - /// A64: UQSHL Vd.4H, Vn.4H, #n + /// uint16x4_t vqshl_n_u16 (uint16x4_t a, const int n) + /// A32: VQSHL.U16 Dd, Dm, #n + /// A64: UQSHL Vd.4H, Vn.4H, #n /// public static Vector64 ShiftLeftLogicalSaturate(Vector64 value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturate(value, count); /// - /// uint32x2_t vqshl_n_u32 (uint32x2_t a, const int n) - /// A32: VQSHL.U32 Dd, Dm, #n - /// A64: UQSHL Vd.2S, Vn.2S, #n + /// uint32x2_t vqshl_n_u32 (uint32x2_t a, const int n) + /// A32: VQSHL.U32 Dd, Dm, #n + /// A64: UQSHL Vd.2S, Vn.2S, #n /// public static Vector64 ShiftLeftLogicalSaturate(Vector64 value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalSaturate(value, count); /// - /// uint8x16_t vqshlq_n_u8 (uint8x16_t a, const int n) - /// A32: VQSHL.U8 Qd, Qm, #n - /// A64: UQSHL Vd.16B, Vn.16B, #n + /// uint8x16_t vqshlq_n_u8 (uint8x16_t a, const int n) + /// A32: VQSHL.U8 Qd, Qm, #n + /// A64: UQSHL Vd.16B, Vn.16B, #n /// public static Vector128 ShiftLeftLogicalSaturate(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalSaturate(value, count); /// - /// int16x8_t vqshlq_n_s16 (int16x8_t a, const int n) - /// A32: VQSHL.S16 Qd, Qm, #n - /// A64: SQSHL Vd.8H, Vn.8H, #n + /// int16x8_t vqshlq_n_s16 (int16x8_t a, const int n) + /// A32: VQSHL.S16 Qd, Qm, #n + /// A64: SQSHL Vd.8H, Vn.8H, #n /// public static Vector128 ShiftLeftLogicalSaturate(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturate(value, count); /// - /// int32x4_t vqshlq_n_s32 (int32x4_t a, const int n) - /// A32: VQSHL.S32 Qd, Qm, #n - /// A64: SQSHL Vd.4S, Vn.4S, #n + /// int32x4_t vqshlq_n_s32 (int32x4_t a, const int n) + /// A32: VQSHL.S32 Qd, Qm, #n + /// A64: SQSHL Vd.4S, Vn.4S, #n /// public static Vector128 ShiftLeftLogicalSaturate(Vector128 value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalSaturate(value, count); /// - /// int64x2_t vqshlq_n_s64 (int64x2_t a, const int n) - /// A32: VQSHL.S64 Qd, Qm, #n - /// A64: SQSHL Vd.2D, Vn.2D, #n + /// int64x2_t vqshlq_n_s64 (int64x2_t a, const int n) + /// A32: VQSHL.S64 Qd, Qm, #n + /// A64: SQSHL Vd.2D, Vn.2D, #n /// public static Vector128 ShiftLeftLogicalSaturate(Vector128 value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturate(value, count); /// - /// int8x16_t vqshlq_n_s8 (int8x16_t a, const int n) - /// A32: VQSHL.S8 Qd, Qm, #n - /// A64: SQSHL Vd.16B, Vn.16B, #n + /// int8x16_t vqshlq_n_s8 (int8x16_t a, const int n) + /// A32: VQSHL.S8 Qd, Qm, #n + /// A64: SQSHL Vd.16B, Vn.16B, #n /// public static Vector128 ShiftLeftLogicalSaturate(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalSaturate(value, count); /// - /// uint16x8_t vqshlq_n_u16 (uint16x8_t a, const int n) - /// A32: VQSHL.U16 Qd, Qm, #n - /// A64: UQSHL Vd.8H, Vn.8H, #n + /// uint16x8_t vqshlq_n_u16 (uint16x8_t a, const int n) + /// A32: VQSHL.U16 Qd, Qm, #n + /// A64: UQSHL Vd.8H, Vn.8H, #n /// public static Vector128 ShiftLeftLogicalSaturate(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturate(value, count); /// - /// uint32x4_t vqshlq_n_u32 (uint32x4_t a, const int n) - /// A32: VQSHL.U32 Qd, Qm, #n - /// A64: UQSHL Vd.4S, Vn.4S, #n + /// uint32x4_t vqshlq_n_u32 (uint32x4_t a, const int n) + /// A32: VQSHL.U32 Qd, Qm, #n + /// A64: UQSHL Vd.4S, Vn.4S, #n /// public static Vector128 ShiftLeftLogicalSaturate(Vector128 value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalSaturate(value, count); /// - /// uint64x2_t vqshlq_n_u64 (uint64x2_t a, const int n) - /// A32: VQSHL.U64 Qd, Qm, #n - /// A64: UQSHL Vd.2D, Vn.2D, #n + /// uint64x2_t vqshlq_n_u64 (uint64x2_t a, const int n) + /// A32: VQSHL.U64 Qd, Qm, #n + /// A64: UQSHL Vd.2D, Vn.2D, #n /// public static Vector128 ShiftLeftLogicalSaturate(Vector128 value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturate(value, count); /// - /// int64x1_t vqshl_n_s64 (int64x1_t a, const int n) - /// A32: VQSHL.S64 Dd, Dm, #n - /// A64: SQSHL Dd, Dn, #n + /// int64x1_t vqshl_n_s64 (int64x1_t a, const int n) + /// A32: VQSHL.S64 Dd, Dm, #n + /// A64: SQSHL Dd, Dn, #n /// public static Vector64 ShiftLeftLogicalSaturateScalar(Vector64 value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturateScalar(value, count); /// - /// uint64x1_t vqshl_n_u64 (uint64x1_t a, const int n) - /// A32: VQSHL.U64 Dd, Dm, #n - /// A64: UQSHL Dd, Dn, #n + /// uint64x1_t vqshl_n_u64 (uint64x1_t a, const int n) + /// A32: VQSHL.U64 Dd, Dm, #n + /// A64: UQSHL Dd, Dn, #n /// public static Vector64 ShiftLeftLogicalSaturateScalar(Vector64 value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturateScalar(value, count); /// - /// uint16x4_t vqshlu_n_s16 (int16x4_t a, const int n) - /// A32: VQSHLU.S16 Dd, Dm, #n - /// A64: SQSHLU Vd.4H, Vn.4H, #n + /// uint16x4_t vqshlu_n_s16 (int16x4_t a, const int n) + /// A32: VQSHLU.S16 Dd, Dm, #n + /// A64: SQSHLU Vd.4H, Vn.4H, #n /// public static Vector64 ShiftLeftLogicalSaturateUnsigned(Vector64 value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturateUnsigned(value, count); /// - /// uint32x2_t vqshlu_n_s32 (int32x2_t a, const int n) - /// A32: VQSHLU.S32 Dd, Dm, #n - /// A64: SQSHLU Vd.2S, Vn.2S, #n + /// uint32x2_t vqshlu_n_s32 (int32x2_t a, const int n) + /// A32: VQSHLU.S32 Dd, Dm, #n + /// A64: SQSHLU Vd.2S, Vn.2S, #n /// public static Vector64 ShiftLeftLogicalSaturateUnsigned(Vector64 value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalSaturateUnsigned(value, count); /// - /// uint8x8_t vqshlu_n_s8 (int8x8_t a, const int n) - /// A32: VQSHLU.S8 Dd, Dm, #n - /// A64: SQSHLU Vd.8B, Vn.8B, #n + /// uint8x8_t vqshlu_n_s8 (int8x8_t a, const int n) + /// A32: VQSHLU.S8 Dd, Dm, #n + /// A64: SQSHLU Vd.8B, Vn.8B, #n /// public static Vector64 ShiftLeftLogicalSaturateUnsigned(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalSaturateUnsigned(value, count); /// - /// uint16x8_t vqshluq_n_s16 (int16x8_t a, const int n) - /// A32: VQSHLU.S16 Qd, Qm, #n - /// A64: SQSHLU Vd.8H, Vn.8H, #n + /// uint16x8_t vqshluq_n_s16 (int16x8_t a, const int n) + /// A32: VQSHLU.S16 Qd, Qm, #n + /// A64: SQSHLU Vd.8H, Vn.8H, #n /// public static Vector128 ShiftLeftLogicalSaturateUnsigned(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalSaturateUnsigned(value, count); /// - /// uint32x4_t vqshluq_n_s32 (int32x4_t a, const int n) - /// A32: VQSHLU.S32 Qd, Qm, #n - /// A64: SQSHLU Vd.4S, Vn.4S, #n + /// uint32x4_t vqshluq_n_s32 (int32x4_t a, const int n) + /// A32: VQSHLU.S32 Qd, Qm, #n + /// A64: SQSHLU Vd.4S, Vn.4S, #n /// public static Vector128 ShiftLeftLogicalSaturateUnsigned(Vector128 value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalSaturateUnsigned(value, count); /// - /// uint64x2_t vqshluq_n_s64 (int64x2_t a, const int n) - /// A32: VQSHLU.S64 Qd, Qm, #n - /// A64: SQSHLU Vd.2D, Vn.2D, #n + /// uint64x2_t vqshluq_n_s64 (int64x2_t a, const int n) + /// A32: VQSHLU.S64 Qd, Qm, #n + /// A64: SQSHLU Vd.2D, Vn.2D, #n /// public static Vector128 ShiftLeftLogicalSaturateUnsigned(Vector128 value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturateUnsigned(value, count); /// - /// uint8x16_t vqshluq_n_s8 (int8x16_t a, const int n) - /// A32: VQSHLU.S8 Qd, Qm, #n - /// A64: SQSHLU Vd.16B, Vn.16B, #n + /// uint8x16_t vqshluq_n_s8 (int8x16_t a, const int n) + /// A32: VQSHLU.S8 Qd, Qm, #n + /// A64: SQSHLU Vd.16B, Vn.16B, #n /// public static Vector128 ShiftLeftLogicalSaturateUnsigned(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalSaturateUnsigned(value, count); /// - /// uint64x1_t vqshlu_n_s64 (int64x1_t a, const int n) - /// A32: VQSHLU.S64 Dd, Dm, #n - /// A64: SQSHLU Dd, Dn, #n + /// uint64x1_t vqshlu_n_s64 (int64x1_t a, const int n) + /// A32: VQSHLU.S64 Dd, Dm, #n + /// A64: SQSHLU Dd, Dn, #n /// public static Vector64 ShiftLeftLogicalSaturateUnsignedScalar(Vector64 value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalSaturateUnsignedScalar(value, count); /// - /// int64x1_t vshl_n_s64 (int64x1_t a, const int n) - /// A32: VSHL.I64 Dd, Dm, #n - /// A64: SHL Dd, Dn, #n + /// int64x1_t vshl_n_s64 (int64x1_t a, const int n) + /// A32: VSHL.I64 Dd, Dm, #n + /// A64: SHL Dd, Dn, #n /// public static Vector64 ShiftLeftLogicalScalar(Vector64 value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalScalar(value, count); /// - /// uint64x1_t vshl_n_u64 (uint64x1_t a, const int n) - /// A32: VSHL.I64 Dd, Dm, #n - /// A64: SHL Dd, Dn, #n + /// uint64x1_t vshl_n_u64 (uint64x1_t a, const int n) + /// A32: VSHL.I64 Dd, Dm, #n + /// A64: SHL Dd, Dn, #n /// public static Vector64 ShiftLeftLogicalScalar(Vector64 value, [ConstantExpected(Max = (byte)(63))] byte count) => ShiftLeftLogicalScalar(value, count); /// - /// uint16x8_t vshll_n_u8 (uint8x8_t a, const int n) - /// A32: VSHLL.U8 Qd, Dm, #n - /// A64: USHLL Vd.8H, Vn.8B, #n + /// uint16x8_t vshll_n_u8 (uint8x8_t a, const int n) + /// A32: VSHLL.U8 Qd, Dm, #n + /// A64: USHLL Vd.8H, Vn.8B, #n /// public static Vector128 ShiftLeftLogicalWideningLower(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalWideningLower(value, count); /// - /// int32x4_t vshll_n_s16 (int16x4_t a, const int n) - /// A32: VSHLL.S16 Qd, Dm, #n - /// A64: SSHLL Vd.4S, Vn.4H, #n + /// int32x4_t vshll_n_s16 (int16x4_t a, const int n) + /// A32: VSHLL.S16 Qd, Dm, #n + /// A64: SSHLL Vd.4S, Vn.4H, #n /// public static Vector128 ShiftLeftLogicalWideningLower(Vector64 value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalWideningLower(value, count); /// - /// int64x2_t vshll_n_s32 (int32x2_t a, const int n) - /// A32: VSHLL.S32 Qd, Dm, #n - /// A64: SSHLL Vd.2D, Vn.2S, #n + /// int64x2_t vshll_n_s32 (int32x2_t a, const int n) + /// A32: VSHLL.S32 Qd, Dm, #n + /// A64: SSHLL Vd.2D, Vn.2S, #n /// public static Vector128 ShiftLeftLogicalWideningLower(Vector64 value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalWideningLower(value, count); /// - /// int16x8_t vshll_n_s8 (int8x8_t a, const int n) - /// A32: VSHLL.S8 Qd, Dm, #n - /// A64: SSHLL Vd.8H, Vn.8B, #n + /// int16x8_t vshll_n_s8 (int8x8_t a, const int n) + /// A32: VSHLL.S8 Qd, Dm, #n + /// A64: SSHLL Vd.8H, Vn.8B, #n /// public static Vector128 ShiftLeftLogicalWideningLower(Vector64 value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalWideningLower(value, count); /// - /// uint32x4_t vshll_n_u16 (uint16x4_t a, const int n) - /// A32: VSHLL.U16 Qd, Dm, #n - /// A64: USHLL Vd.4S, Vn.4H, #n + /// uint32x4_t vshll_n_u16 (uint16x4_t a, const int n) + /// A32: VSHLL.U16 Qd, Dm, #n + /// A64: USHLL Vd.4S, Vn.4H, #n /// public static Vector128 ShiftLeftLogicalWideningLower(Vector64 value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalWideningLower(value, count); /// - /// uint64x2_t vshll_n_u32 (uint32x2_t a, const int n) - /// A32: VSHLL.U32 Qd, Dm, #n - /// A64: USHLL Vd.2D, Vn.2S, #n + /// uint64x2_t vshll_n_u32 (uint32x2_t a, const int n) + /// A32: VSHLL.U32 Qd, Dm, #n + /// A64: USHLL Vd.2D, Vn.2S, #n /// public static Vector128 ShiftLeftLogicalWideningLower(Vector64 value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalWideningLower(value, count); /// - /// uint16x8_t vshll_high_n_u8 (uint8x16_t a, const int n) - /// A32: VSHLL.U8 Qd, Dm+1, #n - /// A64: USHLL2 Vd.8H, Vn.16B, #n + /// uint16x8_t vshll_high_n_u8 (uint8x16_t a, const int n) + /// A32: VSHLL.U8 Qd, Dm+1, #n + /// A64: USHLL2 Vd.8H, Vn.16B, #n /// public static Vector128 ShiftLeftLogicalWideningUpper(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalWideningUpper(value, count); /// - /// int32x4_t vshll_high_n_s16 (int16x8_t a, const int n) - /// A32: VSHLL.S16 Qd, Dm+1, #n - /// A64: SSHLL2 Vd.4S, Vn.8H, #n + /// int32x4_t vshll_high_n_s16 (int16x8_t a, const int n) + /// A32: VSHLL.S16 Qd, Dm+1, #n + /// A64: SSHLL2 Vd.4S, Vn.8H, #n /// public static Vector128 ShiftLeftLogicalWideningUpper(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalWideningUpper(value, count); /// - /// int64x2_t vshll_high_n_s32 (int32x4_t a, const int n) - /// A32: VSHLL.S32 Qd, Dm+1, #n - /// A64: SSHLL2 Vd.2D, Vn.4S, #n + /// int64x2_t vshll_high_n_s32 (int32x4_t a, const int n) + /// A32: VSHLL.S32 Qd, Dm+1, #n + /// A64: SSHLL2 Vd.2D, Vn.4S, #n /// public static Vector128 ShiftLeftLogicalWideningUpper(Vector128 value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalWideningUpper(value, count); /// - /// int16x8_t vshll_high_n_s8 (int8x16_t a, const int n) - /// A32: VSHLL.S8 Qd, Dm+1, #n - /// A64: SSHLL2 Vd.8H, Vn.16B, #n + /// int16x8_t vshll_high_n_s8 (int8x16_t a, const int n) + /// A32: VSHLL.S8 Qd, Dm+1, #n + /// A64: SSHLL2 Vd.8H, Vn.16B, #n /// public static Vector128 ShiftLeftLogicalWideningUpper(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte count) => ShiftLeftLogicalWideningUpper(value, count); /// - /// uint32x4_t vshll_high_n_u16 (uint16x8_t a, const int n) - /// A32: VSHLL.U16 Qd, Dm+1, #n - /// A64: USHLL2 Vd.4S, Vn.8H, #n + /// uint32x4_t vshll_high_n_u16 (uint16x8_t a, const int n) + /// A32: VSHLL.U16 Qd, Dm+1, #n + /// A64: USHLL2 Vd.4S, Vn.8H, #n /// public static Vector128 ShiftLeftLogicalWideningUpper(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte count) => ShiftLeftLogicalWideningUpper(value, count); /// - /// uint64x2_t vshll_high_n_u32 (uint32x4_t a, const int n) - /// A32: VSHLL.U32 Qd, Dm+1, #n - /// A64: USHLL2 Vd.2D, Vn.4S, #n + /// uint64x2_t vshll_high_n_u32 (uint32x4_t a, const int n) + /// A32: VSHLL.U32 Qd, Dm+1, #n + /// A64: USHLL2 Vd.2D, Vn.4S, #n /// public static Vector128 ShiftLeftLogicalWideningUpper(Vector128 value, [ConstantExpected(Max = (byte)(31))] byte count) => ShiftLeftLogicalWideningUpper(value, count); /// - /// uint8x8_t vshl_u8 (uint8x8_t a, int8x8_t b) - /// A32: VSHL.U8 Dd, Dn, Dm - /// A64: USHL Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vshl_u8 (uint8x8_t a, int8x8_t b) + /// A32: VSHL.U8 Dd, Dn, Dm + /// A64: USHL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ShiftLogical(Vector64 value, Vector64 count) => ShiftLogical(value, count); /// - /// uint16x4_t vshl_u16 (uint16x4_t a, int16x4_t b) - /// A32: VSHL.U16 Dd, Dn, Dm - /// A64: USHL Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vshl_u16 (uint16x4_t a, int16x4_t b) + /// A32: VSHL.U16 Dd, Dn, Dm + /// A64: USHL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ShiftLogical(Vector64 value, Vector64 count) => ShiftLogical(value, count); /// - /// uint32x2_t vshl_u32 (uint32x2_t a, int32x2_t b) - /// A32: VSHL.U32 Dd, Dn, Dm - /// A64: USHL Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vshl_u32 (uint32x2_t a, int32x2_t b) + /// A32: VSHL.U32 Dd, Dn, Dm + /// A64: USHL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ShiftLogical(Vector64 value, Vector64 count) => ShiftLogical(value, count); /// - /// uint8x8_t vshl_u8 (uint8x8_t a, int8x8_t b) - /// A32: VSHL.U8 Dd, Dn, Dm - /// A64: USHL Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vshl_u8 (uint8x8_t a, int8x8_t b) + /// A32: VSHL.U8 Dd, Dn, Dm + /// A64: USHL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ShiftLogical(Vector64 value, Vector64 count) => ShiftLogical(value, count); /// - /// uint16x4_t vshl_u16 (uint16x4_t a, int16x4_t b) - /// A32: VSHL.U16 Dd, Dn, Dm - /// A64: USHL Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vshl_u16 (uint16x4_t a, int16x4_t b) + /// A32: VSHL.U16 Dd, Dn, Dm + /// A64: USHL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ShiftLogical(Vector64 value, Vector64 count) => ShiftLogical(value, count); /// - /// uint32x2_t vshl_u32 (uint32x2_t a, int32x2_t b) - /// A32: VSHL.U32 Dd, Dn, Dm - /// A64: USHL Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vshl_u32 (uint32x2_t a, int32x2_t b) + /// A32: VSHL.U32 Dd, Dn, Dm + /// A64: USHL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ShiftLogical(Vector64 value, Vector64 count) => ShiftLogical(value, count); /// - /// uint8x16_t vshlq_u8 (uint8x16_t a, int8x16_t b) - /// A32: VSHL.U8 Qd, Qn, Qm - /// A64: USHL Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vshlq_u8 (uint8x16_t a, int8x16_t b) + /// A32: VSHL.U8 Qd, Qn, Qm + /// A64: USHL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ShiftLogical(Vector128 value, Vector128 count) => ShiftLogical(value, count); /// - /// uint16x8_t vshlq_u16 (uint16x8_t a, int16x8_t b) - /// A32: VSHL.U16 Qd, Qn, Qm - /// A64: USHL Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vshlq_u16 (uint16x8_t a, int16x8_t b) + /// A32: VSHL.U16 Qd, Qn, Qm + /// A64: USHL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ShiftLogical(Vector128 value, Vector128 count) => ShiftLogical(value, count); /// - /// uint32x4_t vshlq_u32 (uint32x4_t a, int32x4_t b) - /// A32: VSHL.U32 Qd, Qn, Qm - /// A64: USHL Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vshlq_u32 (uint32x4_t a, int32x4_t b) + /// A32: VSHL.U32 Qd, Qn, Qm + /// A64: USHL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ShiftLogical(Vector128 value, Vector128 count) => ShiftLogical(value, count); /// - /// uint64x2_t vshlq_u64 (uint64x2_t a, int64x2_t b) - /// A32: VSHL.U64 Qd, Qn, Qm - /// A64: USHL Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vshlq_u64 (uint64x2_t a, int64x2_t b) + /// A32: VSHL.U64 Qd, Qn, Qm + /// A64: USHL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ShiftLogical(Vector128 value, Vector128 count) => ShiftLogical(value, count); /// - /// uint8x16_t vshlq_u8 (uint8x16_t a, int8x16_t b) - /// A32: VSHL.U8 Qd, Qn, Qm - /// A64: USHL Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vshlq_u8 (uint8x16_t a, int8x16_t b) + /// A32: VSHL.U8 Qd, Qn, Qm + /// A64: USHL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ShiftLogical(Vector128 value, Vector128 count) => ShiftLogical(value, count); /// - /// uint16x8_t vshlq_u16 (uint16x8_t a, int16x8_t b) - /// A32: VSHL.U16 Qd, Qn, Qm - /// A64: USHL Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vshlq_u16 (uint16x8_t a, int16x8_t b) + /// A32: VSHL.U16 Qd, Qn, Qm + /// A64: USHL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ShiftLogical(Vector128 value, Vector128 count) => ShiftLogical(value, count); /// - /// uint32x4_t vshlq_u32 (uint32x4_t a, int32x4_t b) - /// A32: VSHL.U32 Qd, Qn, Qm - /// A64: USHL Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vshlq_u32 (uint32x4_t a, int32x4_t b) + /// A32: VSHL.U32 Qd, Qn, Qm + /// A64: USHL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ShiftLogical(Vector128 value, Vector128 count) => ShiftLogical(value, count); /// - /// uint64x2_t vshlq_u64 (uint64x2_t a, int64x2_t b) - /// A32: VSHL.U64 Qd, Qn, Qm - /// A64: USHL Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vshlq_u64 (uint64x2_t a, int64x2_t b) + /// A32: VSHL.U64 Qd, Qn, Qm + /// A64: USHL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ShiftLogical(Vector128 value, Vector128 count) => ShiftLogical(value, count); /// - /// uint8x8_t vrshl_u8 (uint8x8_t a, int8x8_t b) - /// A32: VRSHL.U8 Dd, Dn, Dm - /// A64: URSHL Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vrshl_u8 (uint8x8_t a, int8x8_t b) + /// A32: VRSHL.U8 Dd, Dn, Dm + /// A64: URSHL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ShiftLogicalRounded(Vector64 value, Vector64 count) => ShiftLogicalRounded(value, count); /// - /// uint16x4_t vrshl_u16 (uint16x4_t a, int16x4_t b) - /// A32: VRSHL.U16 Dd, Dn, Dm - /// A64: URSHL Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vrshl_u16 (uint16x4_t a, int16x4_t b) + /// A32: VRSHL.U16 Dd, Dn, Dm + /// A64: URSHL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ShiftLogicalRounded(Vector64 value, Vector64 count) => ShiftLogicalRounded(value, count); /// - /// uint32x2_t vrshl_u32 (uint32x2_t a, int32x2_t b) - /// A32: VRSHL.U32 Dd, Dn, Dm - /// A64: URSHL Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vrshl_u32 (uint32x2_t a, int32x2_t b) + /// A32: VRSHL.U32 Dd, Dn, Dm + /// A64: URSHL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ShiftLogicalRounded(Vector64 value, Vector64 count) => ShiftLogicalRounded(value, count); /// - /// uint8x8_t vrshl_u8 (uint8x8_t a, int8x8_t b) - /// A32: VRSHL.U8 Dd, Dn, Dm - /// A64: URSHL Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vrshl_u8 (uint8x8_t a, int8x8_t b) + /// A32: VRSHL.U8 Dd, Dn, Dm + /// A64: URSHL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ShiftLogicalRounded(Vector64 value, Vector64 count) => ShiftLogicalRounded(value, count); /// - /// uint16x4_t vrshl_u16 (uint16x4_t a, int16x4_t b) - /// A32: VRSHL.U16 Dd, Dn, Dm - /// A64: URSHL Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vrshl_u16 (uint16x4_t a, int16x4_t b) + /// A32: VRSHL.U16 Dd, Dn, Dm + /// A64: URSHL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ShiftLogicalRounded(Vector64 value, Vector64 count) => ShiftLogicalRounded(value, count); /// - /// uint32x2_t vrshl_u32 (uint32x2_t a, int32x2_t b) - /// A32: VRSHL.U32 Dd, Dn, Dm - /// A64: URSHL Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vrshl_u32 (uint32x2_t a, int32x2_t b) + /// A32: VRSHL.U32 Dd, Dn, Dm + /// A64: URSHL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ShiftLogicalRounded(Vector64 value, Vector64 count) => ShiftLogicalRounded(value, count); /// - /// uint8x16_t vrshlq_u8 (uint8x16_t a, int8x16_t b) - /// A32: VRSHL.U8 Qd, Qn, Qm - /// A64: URSHL Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vrshlq_u8 (uint8x16_t a, int8x16_t b) + /// A32: VRSHL.U8 Qd, Qn, Qm + /// A64: URSHL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ShiftLogicalRounded(Vector128 value, Vector128 count) => ShiftLogicalRounded(value, count); /// - /// uint16x8_t vrshlq_u16 (uint16x8_t a, int16x8_t b) - /// A32: VRSHL.U16 Qd, Qn, Qm - /// A64: URSHL Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vrshlq_u16 (uint16x8_t a, int16x8_t b) + /// A32: VRSHL.U16 Qd, Qn, Qm + /// A64: URSHL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ShiftLogicalRounded(Vector128 value, Vector128 count) => ShiftLogicalRounded(value, count); /// - /// uint32x4_t vrshlq_u32 (uint32x4_t a, int32x4_t b) - /// A32: VRSHL.U32 Qd, Qn, Qm - /// A64: URSHL Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vrshlq_u32 (uint32x4_t a, int32x4_t b) + /// A32: VRSHL.U32 Qd, Qn, Qm + /// A64: URSHL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ShiftLogicalRounded(Vector128 value, Vector128 count) => ShiftLogicalRounded(value, count); /// - /// uint64x2_t vrshlq_u64 (uint64x2_t a, int64x2_t b) - /// A32: VRSHL.U64 Qd, Qn, Qm - /// A64: URSHL Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vrshlq_u64 (uint64x2_t a, int64x2_t b) + /// A32: VRSHL.U64 Qd, Qn, Qm + /// A64: URSHL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ShiftLogicalRounded(Vector128 value, Vector128 count) => ShiftLogicalRounded(value, count); /// - /// uint8x16_t vrshlq_u8 (uint8x16_t a, int8x16_t b) - /// A32: VRSHL.U8 Qd, Qn, Qm - /// A64: URSHL Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vrshlq_u8 (uint8x16_t a, int8x16_t b) + /// A32: VRSHL.U8 Qd, Qn, Qm + /// A64: URSHL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ShiftLogicalRounded(Vector128 value, Vector128 count) => ShiftLogicalRounded(value, count); /// - /// uint16x8_t vrshlq_u16 (uint16x8_t a, int16x8_t b) - /// A32: VRSHL.U16 Qd, Qn, Qm - /// A64: URSHL Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vrshlq_u16 (uint16x8_t a, int16x8_t b) + /// A32: VRSHL.U16 Qd, Qn, Qm + /// A64: URSHL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ShiftLogicalRounded(Vector128 value, Vector128 count) => ShiftLogicalRounded(value, count); /// - /// uint32x4_t vrshlq_u32 (uint32x4_t a, int32x4_t b) - /// A32: VRSHL.U32 Qd, Qn, Qm - /// A64: URSHL Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vrshlq_u32 (uint32x4_t a, int32x4_t b) + /// A32: VRSHL.U32 Qd, Qn, Qm + /// A64: URSHL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ShiftLogicalRounded(Vector128 value, Vector128 count) => ShiftLogicalRounded(value, count); /// - /// uint64x2_t vrshlq_u64 (uint64x2_t a, int64x2_t b) - /// A32: VRSHL.U64 Qd, Qn, Qm - /// A64: URSHL Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vrshlq_u64 (uint64x2_t a, int64x2_t b) + /// A32: VRSHL.U64 Qd, Qn, Qm + /// A64: URSHL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ShiftLogicalRounded(Vector128 value, Vector128 count) => ShiftLogicalRounded(value, count); /// - /// uint8x8_t vqrshl_u8 (uint8x8_t a, int8x8_t b) - /// A32: VQRSHL.U8 Dd, Dn, Dm - /// A64: UQRSHL Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vqrshl_u8 (uint8x8_t a, int8x8_t b) + /// A32: VQRSHL.U8 Dd, Dn, Dm + /// A64: UQRSHL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ShiftLogicalRoundedSaturate(Vector64 value, Vector64 count) => ShiftLogicalRoundedSaturate(value, count); /// - /// uint16x4_t vqrshl_u16 (uint16x4_t a, int16x4_t b) - /// A32: VQRSHL.U16 Dd, Dn, Dm - /// A64: UQRSHL Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vqrshl_u16 (uint16x4_t a, int16x4_t b) + /// A32: VQRSHL.U16 Dd, Dn, Dm + /// A64: UQRSHL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ShiftLogicalRoundedSaturate(Vector64 value, Vector64 count) => ShiftLogicalRoundedSaturate(value, count); /// - /// uint32x2_t vqrshl_u32 (uint32x2_t a, int32x2_t b) - /// A32: VQRSHL.U32 Dd, Dn, Dm - /// A64: UQRSHL Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vqrshl_u32 (uint32x2_t a, int32x2_t b) + /// A32: VQRSHL.U32 Dd, Dn, Dm + /// A64: UQRSHL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ShiftLogicalRoundedSaturate(Vector64 value, Vector64 count) => ShiftLogicalRoundedSaturate(value, count); /// - /// uint8x8_t vqrshl_u8 (uint8x8_t a, int8x8_t b) - /// A32: VQRSHL.U8 Dd, Dn, Dm - /// A64: UQRSHL Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vqrshl_u8 (uint8x8_t a, int8x8_t b) + /// A32: VQRSHL.U8 Dd, Dn, Dm + /// A64: UQRSHL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ShiftLogicalRoundedSaturate(Vector64 value, Vector64 count) => ShiftLogicalRoundedSaturate(value, count); /// - /// uint16x4_t vqrshl_u16 (uint16x4_t a, int16x4_t b) - /// A32: VQRSHL.U16 Dd, Dn, Dm - /// A64: UQRSHL Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vqrshl_u16 (uint16x4_t a, int16x4_t b) + /// A32: VQRSHL.U16 Dd, Dn, Dm + /// A64: UQRSHL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ShiftLogicalRoundedSaturate(Vector64 value, Vector64 count) => ShiftLogicalRoundedSaturate(value, count); /// - /// uint32x2_t vqrshl_u32 (uint32x2_t a, int32x2_t b) - /// A32: VQRSHL.U32 Dd, Dn, Dm - /// A64: UQRSHL Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vqrshl_u32 (uint32x2_t a, int32x2_t b) + /// A32: VQRSHL.U32 Dd, Dn, Dm + /// A64: UQRSHL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ShiftLogicalRoundedSaturate(Vector64 value, Vector64 count) => ShiftLogicalRoundedSaturate(value, count); /// - /// uint8x16_t vqrshlq_u8 (uint8x16_t a, int8x16_t b) - /// A32: VQRSHL.U8 Qd, Qn, Qm - /// A64: UQRSHL Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vqrshlq_u8 (uint8x16_t a, int8x16_t b) + /// A32: VQRSHL.U8 Qd, Qn, Qm + /// A64: UQRSHL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ShiftLogicalRoundedSaturate(Vector128 value, Vector128 count) => ShiftLogicalRoundedSaturate(value, count); /// - /// uint16x8_t vqrshlq_u16 (uint16x8_t a, int16x8_t b) - /// A32: VQRSHL.U16 Qd, Qn, Qm - /// A64: UQRSHL Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vqrshlq_u16 (uint16x8_t a, int16x8_t b) + /// A32: VQRSHL.U16 Qd, Qn, Qm + /// A64: UQRSHL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ShiftLogicalRoundedSaturate(Vector128 value, Vector128 count) => ShiftLogicalRoundedSaturate(value, count); /// - /// uint32x4_t vqrshlq_u32 (uint32x4_t a, int32x4_t b) - /// A32: VQRSHL.U32 Qd, Qn, Qm - /// A64: UQRSHL Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vqrshlq_u32 (uint32x4_t a, int32x4_t b) + /// A32: VQRSHL.U32 Qd, Qn, Qm + /// A64: UQRSHL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ShiftLogicalRoundedSaturate(Vector128 value, Vector128 count) => ShiftLogicalRoundedSaturate(value, count); /// - /// uint64x2_t vqrshlq_u64 (uint64x2_t a, int64x2_t b) - /// A32: VQRSHL.U64 Qd, Qn, Qm - /// A64: UQRSHL Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vqrshlq_u64 (uint64x2_t a, int64x2_t b) + /// A32: VQRSHL.U64 Qd, Qn, Qm + /// A64: UQRSHL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ShiftLogicalRoundedSaturate(Vector128 value, Vector128 count) => ShiftLogicalRoundedSaturate(value, count); /// - /// uint8x16_t vqrshlq_u8 (uint8x16_t a, int8x16_t b) - /// A32: VQRSHL.U8 Qd, Qn, Qm - /// A64: UQRSHL Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vqrshlq_u8 (uint8x16_t a, int8x16_t b) + /// A32: VQRSHL.U8 Qd, Qn, Qm + /// A64: UQRSHL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ShiftLogicalRoundedSaturate(Vector128 value, Vector128 count) => ShiftLogicalRoundedSaturate(value, count); /// - /// uint16x8_t vqrshlq_u16 (uint16x8_t a, int16x8_t b) - /// A32: VQRSHL.U16 Qd, Qn, Qm - /// A64: UQRSHL Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vqrshlq_u16 (uint16x8_t a, int16x8_t b) + /// A32: VQRSHL.U16 Qd, Qn, Qm + /// A64: UQRSHL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ShiftLogicalRoundedSaturate(Vector128 value, Vector128 count) => ShiftLogicalRoundedSaturate(value, count); /// - /// uint32x4_t vqrshlq_u32 (uint32x4_t a, int32x4_t b) - /// A32: VQRSHL.U32 Qd, Qn, Qm - /// A64: UQRSHL Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vqrshlq_u32 (uint32x4_t a, int32x4_t b) + /// A32: VQRSHL.U32 Qd, Qn, Qm + /// A64: UQRSHL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ShiftLogicalRoundedSaturate(Vector128 value, Vector128 count) => ShiftLogicalRoundedSaturate(value, count); /// - /// uint64x2_t vqrshlq_u64 (uint64x2_t a, int64x2_t b) - /// A32: VQRSHL.U64 Qd, Qn, Qm - /// A64: UQRSHL Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vqrshlq_u64 (uint64x2_t a, int64x2_t b) + /// A32: VQRSHL.U64 Qd, Qn, Qm + /// A64: UQRSHL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ShiftLogicalRoundedSaturate(Vector128 value, Vector128 count) => ShiftLogicalRoundedSaturate(value, count); /// - /// uint64x1_t vqrshl_u64 (uint64x1_t a, int64x1_t b) - /// A32: VQRSHL.U64 Dd, Dn, Dm - /// A64: UQRSHL Dd, Dn, Dm + /// uint64x1_t vqrshl_u64 (uint64x1_t a, int64x1_t b) + /// A32: VQRSHL.U64 Dd, Dn, Dm + /// A64: UQRSHL Dd, Dn, Dm /// public static Vector64 ShiftLogicalRoundedSaturateScalar(Vector64 value, Vector64 count) => ShiftLogicalRoundedSaturateScalar(value, count); /// - /// uint64x1_t vqrshl_u64 (uint64x1_t a, int64x1_t b) - /// A32: VQRSHL.U64 Dd, Dn, Dm - /// A64: UQRSHL Dd, Dn, Dm + /// uint64x1_t vqrshl_u64 (uint64x1_t a, int64x1_t b) + /// A32: VQRSHL.U64 Dd, Dn, Dm + /// A64: UQRSHL Dd, Dn, Dm /// public static Vector64 ShiftLogicalRoundedSaturateScalar(Vector64 value, Vector64 count) => ShiftLogicalRoundedSaturateScalar(value, count); /// - /// uint64x1_t vrshl_u64 (uint64x1_t a, int64x1_t b) - /// A32: VRSHL.U64 Dd, Dn, Dm - /// A64: URSHL Dd, Dn, Dm + /// uint64x1_t vrshl_u64 (uint64x1_t a, int64x1_t b) + /// A32: VRSHL.U64 Dd, Dn, Dm + /// A64: URSHL Dd, Dn, Dm /// public static Vector64 ShiftLogicalRoundedScalar(Vector64 value, Vector64 count) => ShiftLogicalRoundedScalar(value, count); /// - /// uint64x1_t vrshl_u64 (uint64x1_t a, int64x1_t b) - /// A32: VRSHL.U64 Dd, Dn, Dm - /// A64: URSHL Dd, Dn, Dm + /// uint64x1_t vrshl_u64 (uint64x1_t a, int64x1_t b) + /// A32: VRSHL.U64 Dd, Dn, Dm + /// A64: URSHL Dd, Dn, Dm /// public static Vector64 ShiftLogicalRoundedScalar(Vector64 value, Vector64 count) => ShiftLogicalRoundedScalar(value, count); /// - /// uint8x8_t vqshl_u8 (uint8x8_t a, int8x8_t b) - /// A32: VQSHL.U8 Dd, Dn, Dm - /// A64: UQSHL Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vqshl_u8 (uint8x8_t a, int8x8_t b) + /// A32: VQSHL.U8 Dd, Dn, Dm + /// A64: UQSHL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ShiftLogicalSaturate(Vector64 value, Vector64 count) => ShiftLogicalSaturate(value, count); /// - /// uint16x4_t vqshl_u16 (uint16x4_t a, int16x4_t b) - /// A32: VQSHL.U16 Dd, Dn, Dm - /// A64: UQSHL Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vqshl_u16 (uint16x4_t a, int16x4_t b) + /// A32: VQSHL.U16 Dd, Dn, Dm + /// A64: UQSHL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ShiftLogicalSaturate(Vector64 value, Vector64 count) => ShiftLogicalSaturate(value, count); /// - /// uint32x2_t vqshl_u32 (uint32x2_t a, int32x2_t b) - /// A32: VQSHL.U32 Dd, Dn, Dm - /// A64: UQSHL Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vqshl_u32 (uint32x2_t a, int32x2_t b) + /// A32: VQSHL.U32 Dd, Dn, Dm + /// A64: UQSHL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ShiftLogicalSaturate(Vector64 value, Vector64 count) => ShiftLogicalSaturate(value, count); /// - /// uint8x8_t vqshl_u8 (uint8x8_t a, int8x8_t b) - /// A32: VQSHL.U8 Dd, Dn, Dm - /// A64: UQSHL Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vqshl_u8 (uint8x8_t a, int8x8_t b) + /// A32: VQSHL.U8 Dd, Dn, Dm + /// A64: UQSHL Vd.8B, Vn.8B, Vm.8B /// public static Vector64 ShiftLogicalSaturate(Vector64 value, Vector64 count) => ShiftLogicalSaturate(value, count); /// - /// uint16x4_t vqshl_u16 (uint16x4_t a, int16x4_t b) - /// A32: VQSHL.U16 Dd, Dn, Dm - /// A64: UQSHL Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vqshl_u16 (uint16x4_t a, int16x4_t b) + /// A32: VQSHL.U16 Dd, Dn, Dm + /// A64: UQSHL Vd.4H, Vn.4H, Vm.4H /// public static Vector64 ShiftLogicalSaturate(Vector64 value, Vector64 count) => ShiftLogicalSaturate(value, count); /// - /// uint32x2_t vqshl_u32 (uint32x2_t a, int32x2_t b) - /// A32: VQSHL.U32 Dd, Dn, Dm - /// A64: UQSHL Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vqshl_u32 (uint32x2_t a, int32x2_t b) + /// A32: VQSHL.U32 Dd, Dn, Dm + /// A64: UQSHL Vd.2S, Vn.2S, Vm.2S /// public static Vector64 ShiftLogicalSaturate(Vector64 value, Vector64 count) => ShiftLogicalSaturate(value, count); /// - /// uint8x16_t vqshlq_u8 (uint8x16_t a, int8x16_t b) - /// A32: VQSHL.U8 Qd, Qn, Qm - /// A64: UQSHL Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vqshlq_u8 (uint8x16_t a, int8x16_t b) + /// A32: VQSHL.U8 Qd, Qn, Qm + /// A64: UQSHL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ShiftLogicalSaturate(Vector128 value, Vector128 count) => ShiftLogicalSaturate(value, count); /// - /// uint16x8_t vqshlq_u16 (uint16x8_t a, int16x8_t b) - /// A32: VQSHL.U16 Qd, Qn, Qm - /// A64: UQSHL Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vqshlq_u16 (uint16x8_t a, int16x8_t b) + /// A32: VQSHL.U16 Qd, Qn, Qm + /// A64: UQSHL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ShiftLogicalSaturate(Vector128 value, Vector128 count) => ShiftLogicalSaturate(value, count); /// - /// uint32x4_t vqshlq_u32 (uint32x4_t a, int32x4_t b) - /// A32: VQSHL.U32 Qd, Qn, Qm - /// A64: UQSHL Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vqshlq_u32 (uint32x4_t a, int32x4_t b) + /// A32: VQSHL.U32 Qd, Qn, Qm + /// A64: UQSHL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ShiftLogicalSaturate(Vector128 value, Vector128 count) => ShiftLogicalSaturate(value, count); /// - /// uint64x2_t vqshlq_u64 (uint64x2_t a, int64x2_t b) - /// A32: VQSHL.U64 Qd, Qn, Qm - /// A64: UQSHL Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vqshlq_u64 (uint64x2_t a, int64x2_t b) + /// A32: VQSHL.U64 Qd, Qn, Qm + /// A64: UQSHL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ShiftLogicalSaturate(Vector128 value, Vector128 count) => ShiftLogicalSaturate(value, count); /// - /// uint8x16_t vqshlq_u8 (uint8x16_t a, int8x16_t b) - /// A32: VQSHL.U8 Qd, Qn, Qm - /// A64: UQSHL Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vqshlq_u8 (uint8x16_t a, int8x16_t b) + /// A32: VQSHL.U8 Qd, Qn, Qm + /// A64: UQSHL Vd.16B, Vn.16B, Vm.16B /// public static Vector128 ShiftLogicalSaturate(Vector128 value, Vector128 count) => ShiftLogicalSaturate(value, count); /// - /// uint16x8_t vqshlq_u16 (uint16x8_t a, int16x8_t b) - /// A32: VQSHL.U16 Qd, Qn, Qm - /// A64: UQSHL Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vqshlq_u16 (uint16x8_t a, int16x8_t b) + /// A32: VQSHL.U16 Qd, Qn, Qm + /// A64: UQSHL Vd.8H, Vn.8H, Vm.8H /// public static Vector128 ShiftLogicalSaturate(Vector128 value, Vector128 count) => ShiftLogicalSaturate(value, count); /// - /// uint32x4_t vqshlq_u32 (uint32x4_t a, int32x4_t b) - /// A32: VQSHL.U32 Qd, Qn, Qm - /// A64: UQSHL Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vqshlq_u32 (uint32x4_t a, int32x4_t b) + /// A32: VQSHL.U32 Qd, Qn, Qm + /// A64: UQSHL Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ShiftLogicalSaturate(Vector128 value, Vector128 count) => ShiftLogicalSaturate(value, count); /// - /// uint64x2_t vqshlq_u64 (uint64x2_t a, int64x2_t b) - /// A32: VQSHL.U64 Qd, Qn, Qm - /// A64: UQSHL Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vqshlq_u64 (uint64x2_t a, int64x2_t b) + /// A32: VQSHL.U64 Qd, Qn, Qm + /// A64: UQSHL Vd.2D, Vn.2D, Vm.2D /// public static Vector128 ShiftLogicalSaturate(Vector128 value, Vector128 count) => ShiftLogicalSaturate(value, count); /// - /// uint64x1_t vqshl_u64 (uint64x1_t a, int64x1_t b) - /// A32: VQSHL.U64 Dd, Dn, Dm - /// A64: UQSHL Dd, Dn, Dm + /// uint64x1_t vqshl_u64 (uint64x1_t a, int64x1_t b) + /// A32: VQSHL.U64 Dd, Dn, Dm + /// A64: UQSHL Dd, Dn, Dm /// public static Vector64 ShiftLogicalSaturateScalar(Vector64 value, Vector64 count) => ShiftLogicalSaturateScalar(value, count); /// - /// uint64x1_t vqshl_u64 (uint64x1_t a, int64x1_t b) - /// A32: VQSHL.U64 Dd, Dn, Dm - /// A64: UQSHL Dd, Dn, Dm + /// uint64x1_t vqshl_u64 (uint64x1_t a, int64x1_t b) + /// A32: VQSHL.U64 Dd, Dn, Dm + /// A64: UQSHL Dd, Dn, Dm /// public static Vector64 ShiftLogicalSaturateScalar(Vector64 value, Vector64 count) => ShiftLogicalSaturateScalar(value, count); /// - /// uint64x1_t vshl_u64 (uint64x1_t a, int64x1_t b) - /// A32: VSHL.U64 Dd, Dn, Dm - /// A64: USHL Dd, Dn, Dm + /// uint64x1_t vshl_u64 (uint64x1_t a, int64x1_t b) + /// A32: VSHL.U64 Dd, Dn, Dm + /// A64: USHL Dd, Dn, Dm /// public static Vector64 ShiftLogicalScalar(Vector64 value, Vector64 count) => ShiftLogicalScalar(value, count); /// - /// uint64x1_t vshl_u64 (uint64x1_t a, int64x1_t b) - /// A32: VSHL.U64 Dd, Dn, Dm - /// A64: USHL Dd, Dn, Dm + /// uint64x1_t vshl_u64 (uint64x1_t a, int64x1_t b) + /// A32: VSHL.U64 Dd, Dn, Dm + /// A64: USHL Dd, Dn, Dm /// public static Vector64 ShiftLogicalScalar(Vector64 value, Vector64 count) => ShiftLogicalScalar(value, count); /// - /// uint8x8_t vsri_n_u8(uint8x8_t a, uint8x8_t b, __builtin_constant_p(n)) - /// A32: VSRI.8 Dd, Dm, #n - /// A64: SRI Vd.8B, Vn.8B, #n + /// uint8x8_t vsri_n_u8(uint8x8_t a, uint8x8_t b, __builtin_constant_p(n)) + /// A32: VSRI.8 Dd, Dm, #n + /// A64: SRI Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, [ConstantExpected(Min = 1, Max = (byte)(8))] byte shift) => ShiftRightAndInsert(left, right, shift); /// - /// int16x4_t vsri_n_s16(int16x4_t a, int16x4_t b, __builtin_constant_p(n)) - /// A32: VSRI.16 Dd, Dm, #n - /// A64: SRI Vd.4H, Vn.4H, #n + /// int16x4_t vsri_n_s16(int16x4_t a, int16x4_t b, __builtin_constant_p(n)) + /// A32: VSRI.16 Dd, Dm, #n + /// A64: SRI Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, [ConstantExpected(Min = 1, Max = (byte)(16))] byte shift) => ShiftRightAndInsert(left, right, shift); /// - /// int32x2_t vsri_n_s32(int32x2_t a, int32x2_t b, __builtin_constant_p(n)) - /// A32: VSRI.32 Dd, Dm, #n - /// A64: SRI Vd.2S, Vn.2S, #n + /// int32x2_t vsri_n_s32(int32x2_t a, int32x2_t b, __builtin_constant_p(n)) + /// A32: VSRI.32 Dd, Dm, #n + /// A64: SRI Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, [ConstantExpected(Min = 1, Max = (byte)(32))] byte shift) => ShiftRightAndInsert(left, right, shift); /// - /// int8x8_t vsri_n_s8(int8x8_t a, int8x8_t b, __builtin_constant_p(n)) - /// A32: VSRI.8 Dd, Dm, #n - /// A64: SRI Vd.8B, Vn.8B, #n + /// int8x8_t vsri_n_s8(int8x8_t a, int8x8_t b, __builtin_constant_p(n)) + /// A32: VSRI.8 Dd, Dm, #n + /// A64: SRI Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, [ConstantExpected(Min = 1, Max = (byte)(8))] byte shift) => ShiftRightAndInsert(left, right, shift); /// - /// uint16x4_t vsri_n_u16(uint16x4_t a, uint16x4_t b, __builtin_constant_p(n)) - /// A32: VSRI.16 Dd, Dm, #n - /// A64: SRI Vd.4H, Vn.4H, #n + /// uint16x4_t vsri_n_u16(uint16x4_t a, uint16x4_t b, __builtin_constant_p(n)) + /// A32: VSRI.16 Dd, Dm, #n + /// A64: SRI Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, [ConstantExpected(Min = 1, Max = (byte)(16))] byte shift) => ShiftRightAndInsert(left, right, shift); /// - /// uint32x2_t vsri_n_u32(uint32x2_t a, uint32x2_t b, __builtin_constant_p(n)) - /// A32: VSRI.32 Dd, Dm, #n - /// A64: SRI Vd.2S, Vn.2S, #n + /// uint32x2_t vsri_n_u32(uint32x2_t a, uint32x2_t b, __builtin_constant_p(n)) + /// A32: VSRI.32 Dd, Dm, #n + /// A64: SRI Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightAndInsert(Vector64 left, Vector64 right, [ConstantExpected(Min = 1, Max = (byte)(32))] byte shift) => ShiftRightAndInsert(left, right, shift); /// - /// uint8x16_t vsriq_n_u8(uint8x16_t a, uint8x16_t b, __builtin_constant_p(n)) - /// A32: VSRI.8 Qd, Qm, #n - /// A64: SRI Vd.16B, Vn.16B, #n + /// uint8x16_t vsriq_n_u8(uint8x16_t a, uint8x16_t b, __builtin_constant_p(n)) + /// A32: VSRI.8 Qd, Qm, #n + /// A64: SRI Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Min = 1, Max = (byte)(8))] byte shift) => ShiftRightAndInsert(left, right, shift); /// - /// int16x8_t vsriq_n_s16(int16x8_t a, int16x8_t b, __builtin_constant_p(n)) - /// A32: VSRI.16 Qd, Qm, #n - /// A64: SRI Vd.8H, Vn.8H, #n + /// int16x8_t vsriq_n_s16(int16x8_t a, int16x8_t b, __builtin_constant_p(n)) + /// A32: VSRI.16 Qd, Qm, #n + /// A64: SRI Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Min = 1, Max = (byte)(16))] byte shift) => ShiftRightAndInsert(left, right, shift); /// - /// int32x4_t vsriq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n)) - /// A32: VSRI.32 Qd, Qm, #n - /// A64: SRI Vd.4S, Vn.4S, #n + /// int32x4_t vsriq_n_s32(int32x4_t a, int32x4_t b, __builtin_constant_p(n)) + /// A32: VSRI.32 Qd, Qm, #n + /// A64: SRI Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Min = 1, Max = (byte)(32))] byte shift) => ShiftRightAndInsert(left, right, shift); /// - /// int64x2_t vsriq_n_s64(int64x2_t a, int64x2_t b, __builtin_constant_p(n)) - /// A32: VSRI.64 Qd, Qm, #n - /// A64: SRI Vd.2D, Vn.2D, #n + /// int64x2_t vsriq_n_s64(int64x2_t a, int64x2_t b, __builtin_constant_p(n)) + /// A32: VSRI.64 Qd, Qm, #n + /// A64: SRI Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) => ShiftRightAndInsert(left, right, shift); /// - /// int8x16_t vsriq_n_s8(int8x16_t a, int8x16_t b, __builtin_constant_p(n)) - /// A32: VSRI.8 Qd, Qm, #n - /// A64: SRI Vd.16B, Vn.16B, #n + /// int8x16_t vsriq_n_s8(int8x16_t a, int8x16_t b, __builtin_constant_p(n)) + /// A32: VSRI.8 Qd, Qm, #n + /// A64: SRI Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Min = 1, Max = (byte)(8))] byte shift) => ShiftRightAndInsert(left, right, shift); /// - /// uint16x8_t vsriq_n_u16(uint16x8_t a, uint16x8_t b, __builtin_constant_p(n)) - /// A32: VSRI.16 Qd, Qm, #n - /// A64: SRI Vd.8H, Vn.8H, #n + /// uint16x8_t vsriq_n_u16(uint16x8_t a, uint16x8_t b, __builtin_constant_p(n)) + /// A32: VSRI.16 Qd, Qm, #n + /// A64: SRI Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Min = 1, Max = (byte)(16))] byte shift) => ShiftRightAndInsert(left, right, shift); /// - /// uint32x4_t vsriq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n)) - /// A32: VSRI.32 Qd, Qm, #n - /// A64: SRI Vd.4S, Vn.4S, #n + /// uint32x4_t vsriq_n_u32(uint32x4_t a, uint32x4_t b, __builtin_constant_p(n)) + /// A32: VSRI.32 Qd, Qm, #n + /// A64: SRI Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Min = 1, Max = (byte)(32))] byte shift) => ShiftRightAndInsert(left, right, shift); /// - /// uint64x2_t vsriq_n_u64(uint64x2_t a, uint64x2_t b, __builtin_constant_p(n)) - /// A32: VSRI.64 Qd, Qm, #n - /// A64: SRI Vd.2D, Vn.2D, #n + /// uint64x2_t vsriq_n_u64(uint64x2_t a, uint64x2_t b, __builtin_constant_p(n)) + /// A32: VSRI.64 Qd, Qm, #n + /// A64: SRI Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightAndInsert(Vector128 left, Vector128 right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) => ShiftRightAndInsert(left, right, shift); /// - /// int64_t vsrid_n_s64(int64_t a, int64_t b, __builtin_constant_p(n)) - /// A32: VSRI.64 Dd, Dm, #n - /// A64: SRI Dd, Dn, #n + /// int64_t vsrid_n_s64(int64_t a, int64_t b, __builtin_constant_p(n)) + /// A32: VSRI.64 Dd, Dm, #n + /// A64: SRI Dd, Dn, #n /// public static Vector64 ShiftRightAndInsertScalar(Vector64 left, Vector64 right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) => ShiftRightAndInsertScalar(left, right, shift); /// - /// uint64_t vsrid_n_u64(uint64_t a, uint64_t b, __builtin_constant_p(n)) - /// A32: VSRI.64 Dd, Dm, #n - /// A64: SRI Dd, Dn, #n + /// uint64_t vsrid_n_u64(uint64_t a, uint64_t b, __builtin_constant_p(n)) + /// A32: VSRI.64 Dd, Dm, #n + /// A64: SRI Dd, Dn, #n /// public static Vector64 ShiftRightAndInsertScalar(Vector64 left, Vector64 right, [ConstantExpected(Min = 1, Max = (byte)(64))] byte shift) => ShiftRightAndInsertScalar(left, right, shift); /// - /// int16x4_t vshr_n_s16 (int16x4_t a, const int n) - /// A32: VSHR.S16 Dd, Dm, #n - /// A64: SSHR Vd.4H, Vn.4H, #n + /// int16x4_t vshr_n_s16 (int16x4_t a, const int n) + /// A32: VSHR.S16 Dd, Dm, #n + /// A64: SSHR Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightArithmetic(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmetic(value, count); /// - /// int32x2_t vshr_n_s32 (int32x2_t a, const int n) - /// A32: VSHR.S32 Dd, Dm, #n - /// A64: SSHR Vd.2S, Vn.2S, #n + /// int32x2_t vshr_n_s32 (int32x2_t a, const int n) + /// A32: VSHR.S32 Dd, Dm, #n + /// A64: SSHR Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightArithmetic(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmetic(value, count); /// - /// int8x8_t vshr_n_s8 (int8x8_t a, const int n) - /// A32: VSHR.S8 Dd, Dm, #n - /// A64: SSHR Vd.8B, Vn.8B, #n + /// int8x8_t vshr_n_s8 (int8x8_t a, const int n) + /// A32: VSHR.S8 Dd, Dm, #n + /// A64: SSHR Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightArithmetic(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmetic(value, count); /// - /// int16x8_t vshrq_n_s16 (int16x8_t a, const int n) - /// A32: VSHR.S16 Qd, Qm, #n - /// A64: SSHR Vd.8H, Vn.8H, #n + /// int16x8_t vshrq_n_s16 (int16x8_t a, const int n) + /// A32: VSHR.S16 Qd, Qm, #n + /// A64: SSHR Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightArithmetic(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmetic(value, count); /// - /// int32x4_t vshrq_n_s32 (int32x4_t a, const int n) - /// A32: VSHR.S32 Qd, Qm, #n - /// A64: SSHR Vd.4S, Vn.4S, #n + /// int32x4_t vshrq_n_s32 (int32x4_t a, const int n) + /// A32: VSHR.S32 Qd, Qm, #n + /// A64: SSHR Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightArithmetic(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmetic(value, count); /// - /// int64x2_t vshrq_n_s64 (int64x2_t a, const int n) - /// A32: VSHR.S64 Qd, Qm, #n - /// A64: SSHR Vd.2D, Vn.2D, #n + /// int64x2_t vshrq_n_s64 (int64x2_t a, const int n) + /// A32: VSHR.S64 Qd, Qm, #n + /// A64: SSHR Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightArithmetic(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmetic(value, count); /// - /// int8x16_t vshrq_n_s8 (int8x16_t a, const int n) - /// A32: VSHR.S8 Qd, Qm, #n - /// A64: SSHR Vd.16B, Vn.16B, #n + /// int8x16_t vshrq_n_s8 (int8x16_t a, const int n) + /// A32: VSHR.S8 Qd, Qm, #n + /// A64: SSHR Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightArithmetic(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmetic(value, count); /// - /// int16x4_t vsra_n_s16 (int16x4_t a, int16x4_t b, const int n) - /// A32: VSRA.S16 Dd, Dm, #n - /// A64: SSRA Vd.4H, Vn.4H, #n + /// int16x4_t vsra_n_s16 (int16x4_t a, int16x4_t b, const int n) + /// A32: VSRA.S16 Dd, Dm, #n + /// A64: SSRA Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightArithmeticAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticAdd(addend, value, count); /// - /// int32x2_t vsra_n_s32 (int32x2_t a, int32x2_t b, const int n) - /// A32: VSRA.S32 Dd, Dm, #n - /// A64: SSRA Vd.2S, Vn.2S, #n + /// int32x2_t vsra_n_s32 (int32x2_t a, int32x2_t b, const int n) + /// A32: VSRA.S32 Dd, Dm, #n + /// A64: SSRA Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightArithmeticAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticAdd(addend, value, count); /// - /// int8x8_t vsra_n_s8 (int8x8_t a, int8x8_t b, const int n) - /// A32: VSRA.S8 Dd, Dm, #n - /// A64: SSRA Vd.8B, Vn.8B, #n + /// int8x8_t vsra_n_s8 (int8x8_t a, int8x8_t b, const int n) + /// A32: VSRA.S8 Dd, Dm, #n + /// A64: SSRA Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightArithmeticAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticAdd(addend, value, count); /// - /// int16x8_t vsraq_n_s16 (int16x8_t a, int16x8_t b, const int n) - /// A32: VSRA.S16 Qd, Qm, #n - /// A64: SSRA Vd.8H, Vn.8H, #n + /// int16x8_t vsraq_n_s16 (int16x8_t a, int16x8_t b, const int n) + /// A32: VSRA.S16 Qd, Qm, #n + /// A64: SSRA Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightArithmeticAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticAdd(addend, value, count); /// - /// int32x4_t vsraq_n_s32 (int32x4_t a, int32x4_t b, const int n) - /// A32: VSRA.S32 Qd, Qm, #n - /// A64: SSRA Vd.4S, Vn.4S, #n + /// int32x4_t vsraq_n_s32 (int32x4_t a, int32x4_t b, const int n) + /// A32: VSRA.S32 Qd, Qm, #n + /// A64: SSRA Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightArithmeticAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticAdd(addend, value, count); /// - /// int64x2_t vsraq_n_s64 (int64x2_t a, int64x2_t b, const int n) - /// A32: VSRA.S64 Qd, Qm, #n - /// A64: SSRA Vd.2D, Vn.2D, #n + /// int64x2_t vsraq_n_s64 (int64x2_t a, int64x2_t b, const int n) + /// A32: VSRA.S64 Qd, Qm, #n + /// A64: SSRA Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightArithmeticAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticAdd(addend, value, count); /// - /// int8x16_t vsraq_n_s8 (int8x16_t a, int8x16_t b, const int n) - /// A32: VSRA.S8 Qd, Qm, #n - /// A64: SSRA Vd.16B, Vn.16B, #n + /// int8x16_t vsraq_n_s8 (int8x16_t a, int8x16_t b, const int n) + /// A32: VSRA.S8 Qd, Qm, #n + /// A64: SSRA Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightArithmeticAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticAdd(addend, value, count); /// - /// int64x1_t vsra_n_s64 (int64x1_t a, int64x1_t b, const int n) - /// A32: VSRA.S64 Dd, Dm, #n - /// A64: SSRA Dd, Dn, #n + /// int64x1_t vsra_n_s64 (int64x1_t a, int64x1_t b, const int n) + /// A32: VSRA.S64 Dd, Dm, #n + /// A64: SSRA Dd, Dn, #n /// public static Vector64 ShiftRightArithmeticAddScalar(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticAddScalar(addend, value, count); /// - /// int16x4_t vqshrn_n_s32 (int32x4_t a, const int n) - /// A32: VQSHRN.S32 Dd, Qm, #n - /// A64: SQSHRN Vd.4H, Vn.4S, #n + /// int16x4_t vqshrn_n_s32 (int32x4_t a, const int n) + /// A32: VQSHRN.S32 Dd, Qm, #n + /// A64: SQSHRN Vd.4H, Vn.4S, #n /// public static Vector64 ShiftRightArithmeticNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticNarrowingSaturateLower(value, count); /// - /// int32x2_t vqshrn_n_s64 (int64x2_t a, const int n) - /// A32: VQSHRN.S64 Dd, Qm, #n - /// A64: SQSHRN Vd.2S, Vn.2D, #n + /// int32x2_t vqshrn_n_s64 (int64x2_t a, const int n) + /// A32: VQSHRN.S64 Dd, Qm, #n + /// A64: SQSHRN Vd.2S, Vn.2D, #n /// public static Vector64 ShiftRightArithmeticNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticNarrowingSaturateLower(value, count); /// - /// int8x8_t vqshrn_n_s16 (int16x8_t a, const int n) - /// A32: VQSHRN.S16 Dd, Qm, #n - /// A64: SQSHRN Vd.8B, Vn.8H, #n + /// int8x8_t vqshrn_n_s16 (int16x8_t a, const int n) + /// A32: VQSHRN.S16 Dd, Qm, #n + /// A64: SQSHRN Vd.8B, Vn.8H, #n /// public static Vector64 ShiftRightArithmeticNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticNarrowingSaturateLower(value, count); /// - /// uint8x8_t vqshrun_n_s16 (int16x8_t a, const int n) - /// A32: VQSHRUN.S16 Dd, Qm, #n - /// A64: SQSHRUN Vd.8B, Vn.8H, #n + /// uint8x8_t vqshrun_n_s16 (int16x8_t a, const int n) + /// A32: VQSHRUN.S16 Dd, Qm, #n + /// A64: SQSHRUN Vd.8B, Vn.8H, #n /// public static Vector64 ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedLower(value, count); /// - /// uint16x4_t vqshrun_n_s32 (int32x4_t a, const int n) - /// A32: VQSHRUN.S32 Dd, Qm, #n - /// A64: SQSHRUN Vd.4H, Vn.4S, #n + /// uint16x4_t vqshrun_n_s32 (int32x4_t a, const int n) + /// A32: VQSHRUN.S32 Dd, Qm, #n + /// A64: SQSHRUN Vd.4H, Vn.4S, #n /// public static Vector64 ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedLower(value, count); /// - /// uint32x2_t vqshrun_n_s64 (int64x2_t a, const int n) - /// A32: VQSHRUN.S64 Dd, Qm, #n - /// A64: SQSHRUN Vd.2S, Vn.2D, #n + /// uint32x2_t vqshrun_n_s64 (int64x2_t a, const int n) + /// A32: VQSHRUN.S64 Dd, Qm, #n + /// A64: SQSHRUN Vd.2S, Vn.2D, #n /// public static Vector64 ShiftRightArithmeticNarrowingSaturateUnsignedLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedLower(value, count); /// - /// uint8x16_t vqshrun_high_n_s16 (uint8x8_t r, int16x8_t a, const int n) - /// A32: VQSHRUN.S16 Dd+1, Dn, #n - /// A64: SQSHRUN2 Vd.16B, Vn.8H, #n + /// uint8x16_t vqshrun_high_n_s16 (uint8x8_t r, int16x8_t a, const int n) + /// A32: VQSHRUN.S16 Dd+1, Dn, #n + /// A64: SQSHRUN2 Vd.16B, Vn.8H, #n /// public static Vector128 ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedUpper(lower, value, count); /// - /// uint16x8_t vqshrun_high_n_s32 (uint16x4_t r, int32x4_t a, const int n) - /// A32: VQSHRUN.S32 Dd+1, Dn, #n - /// A64: SQSHRUN2 Vd.8H, Vn.4S, #n + /// uint16x8_t vqshrun_high_n_s32 (uint16x4_t r, int32x4_t a, const int n) + /// A32: VQSHRUN.S32 Dd+1, Dn, #n + /// A64: SQSHRUN2 Vd.8H, Vn.4S, #n /// public static Vector128 ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedUpper(lower, value, count); /// - /// uint32x4_t vqshrun_high_n_s64 (uint32x2_t r, int64x2_t a, const int n) - /// A32: VQSHRUN.S64 Dd+1, Dn, #n - /// A64: SQSHRUN2 Vd.4S, Vn.2D, #n + /// uint32x4_t vqshrun_high_n_s64 (uint32x2_t r, int64x2_t a, const int n) + /// A32: VQSHRUN.S64 Dd+1, Dn, #n + /// A64: SQSHRUN2 Vd.4S, Vn.2D, #n /// public static Vector128 ShiftRightArithmeticNarrowingSaturateUnsignedUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticNarrowingSaturateUnsignedUpper(lower, value, count); /// - /// int16x8_t vqshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n) - /// A32: VQSHRN.S32 Dd+1, Qm, #n - /// A64: SQSHRN2 Vd.8H, Vn.4S, #n + /// int16x8_t vqshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n) + /// A32: VQSHRN.S32 Dd+1, Qm, #n + /// A64: SQSHRN2 Vd.8H, Vn.4S, #n /// public static Vector128 ShiftRightArithmeticNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticNarrowingSaturateUpper(lower, value, count); /// - /// int32x4_t vqshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n) - /// A32: VQSHRN.S64 Dd+1, Qm, #n - /// A64: SQSHRN2 Vd.4S, Vn.2D, #n + /// int32x4_t vqshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n) + /// A32: VQSHRN.S64 Dd+1, Qm, #n + /// A64: SQSHRN2 Vd.4S, Vn.2D, #n /// public static Vector128 ShiftRightArithmeticNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticNarrowingSaturateUpper(lower, value, count); /// - /// int8x16_t vqshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n) - /// A32: VQSHRN.S16 Dd+1, Qm, #n - /// A64: SQSHRN2 Vd.16B, Vn.8H, #n + /// int8x16_t vqshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n) + /// A32: VQSHRN.S16 Dd+1, Qm, #n + /// A64: SQSHRN2 Vd.16B, Vn.8H, #n /// public static Vector128 ShiftRightArithmeticNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticNarrowingSaturateUpper(lower, value, count); /// - /// int16x4_t vrshr_n_s16 (int16x4_t a, const int n) - /// A32: VRSHR.S16 Dd, Dm, #n - /// A64: SRSHR Vd.4H, Vn.4H, #n + /// int16x4_t vrshr_n_s16 (int16x4_t a, const int n) + /// A32: VRSHR.S16 Dd, Dm, #n + /// A64: SRSHR Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightArithmeticRounded(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRounded(value, count); /// - /// int32x2_t vrshr_n_s32 (int32x2_t a, const int n) - /// A32: VRSHR.S32 Dd, Dm, #n - /// A64: SRSHR Vd.2S, Vn.2S, #n + /// int32x2_t vrshr_n_s32 (int32x2_t a, const int n) + /// A32: VRSHR.S32 Dd, Dm, #n + /// A64: SRSHR Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightArithmeticRounded(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRounded(value, count); /// - /// int8x8_t vrshr_n_s8 (int8x8_t a, const int n) - /// A32: VRSHR.S8 Dd, Dm, #n - /// A64: SRSHR Vd.8B, Vn.8B, #n + /// int8x8_t vrshr_n_s8 (int8x8_t a, const int n) + /// A32: VRSHR.S8 Dd, Dm, #n + /// A64: SRSHR Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightArithmeticRounded(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRounded(value, count); /// - /// int16x8_t vrshrq_n_s16 (int16x8_t a, const int n) - /// A32: VRSHR.S16 Qd, Qm, #n - /// A64: SRSHR Vd.8H, Vn.8H, #n + /// int16x8_t vrshrq_n_s16 (int16x8_t a, const int n) + /// A32: VRSHR.S16 Qd, Qm, #n + /// A64: SRSHR Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightArithmeticRounded(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRounded(value, count); /// - /// int32x4_t vrshrq_n_s32 (int32x4_t a, const int n) - /// A32: VRSHR.S32 Qd, Qm, #n - /// A64: SRSHR Vd.4S, Vn.4S, #n + /// int32x4_t vrshrq_n_s32 (int32x4_t a, const int n) + /// A32: VRSHR.S32 Qd, Qm, #n + /// A64: SRSHR Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightArithmeticRounded(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRounded(value, count); /// - /// int64x2_t vrshrq_n_s64 (int64x2_t a, const int n) - /// A32: VRSHR.S64 Qd, Qm, #n - /// A64: SRSHR Vd.2D, Vn.2D, #n + /// int64x2_t vrshrq_n_s64 (int64x2_t a, const int n) + /// A32: VRSHR.S64 Qd, Qm, #n + /// A64: SRSHR Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightArithmeticRounded(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticRounded(value, count); /// - /// int8x16_t vrshrq_n_s8 (int8x16_t a, const int n) - /// A32: VRSHR.S8 Qd, Qm, #n - /// A64: SRSHR Vd.16B, Vn.16B, #n + /// int8x16_t vrshrq_n_s8 (int8x16_t a, const int n) + /// A32: VRSHR.S8 Qd, Qm, #n + /// A64: SRSHR Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightArithmeticRounded(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRounded(value, count); /// - /// int16x4_t vrsra_n_s16 (int16x4_t a, int16x4_t b, const int n) - /// A32: VRSRA.S16 Dd, Dm, #n - /// A64: SRSRA Vd.4H, Vn.4H, #n + /// int16x4_t vrsra_n_s16 (int16x4_t a, int16x4_t b, const int n) + /// A32: VRSRA.S16 Dd, Dm, #n + /// A64: SRSRA Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightArithmeticRoundedAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count); /// - /// int32x2_t vrsra_n_s32 (int32x2_t a, int32x2_t b, const int n) - /// A32: VRSRA.S32 Dd, Dm, #n - /// A64: SRSRA Vd.2S, Vn.2S, #n + /// int32x2_t vrsra_n_s32 (int32x2_t a, int32x2_t b, const int n) + /// A32: VRSRA.S32 Dd, Dm, #n + /// A64: SRSRA Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightArithmeticRoundedAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count); /// - /// int8x8_t vrsra_n_s8 (int8x8_t a, int8x8_t b, const int n) - /// A32: VRSRA.S8 Dd, Dm, #n - /// A64: SRSRA Vd.8B, Vn.8B, #n + /// int8x8_t vrsra_n_s8 (int8x8_t a, int8x8_t b, const int n) + /// A32: VRSRA.S8 Dd, Dm, #n + /// A64: SRSRA Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightArithmeticRoundedAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count); /// - /// int16x8_t vrsraq_n_s16 (int16x8_t a, int16x8_t b, const int n) - /// A32: VRSRA.S16 Qd, Qm, #n - /// A64: SRSRA Vd.8H, Vn.8H, #n + /// int16x8_t vrsraq_n_s16 (int16x8_t a, int16x8_t b, const int n) + /// A32: VRSRA.S16 Qd, Qm, #n + /// A64: SRSRA Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightArithmeticRoundedAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count); /// - /// int32x4_t vrsraq_n_s32 (int32x4_t a, int32x4_t b, const int n) - /// A32: VRSRA.S32 Qd, Qm, #n - /// A64: SRSRA Vd.4S, Vn.4S, #n + /// int32x4_t vrsraq_n_s32 (int32x4_t a, int32x4_t b, const int n) + /// A32: VRSRA.S32 Qd, Qm, #n + /// A64: SRSRA Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightArithmeticRoundedAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count); /// - /// int64x2_t vrsraq_n_s64 (int64x2_t a, int64x2_t b, const int n) - /// A32: VRSRA.S64 Qd, Qm, #n - /// A64: SRSRA Vd.2D, Vn.2D, #n + /// int64x2_t vrsraq_n_s64 (int64x2_t a, int64x2_t b, const int n) + /// A32: VRSRA.S64 Qd, Qm, #n + /// A64: SRSRA Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightArithmeticRoundedAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count); /// - /// int8x16_t vrsraq_n_s8 (int8x16_t a, int8x16_t b, const int n) - /// A32: VRSRA.S8 Qd, Qm, #n - /// A64: SRSRA Vd.16B, Vn.16B, #n + /// int8x16_t vrsraq_n_s8 (int8x16_t a, int8x16_t b, const int n) + /// A32: VRSRA.S8 Qd, Qm, #n + /// A64: SRSRA Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightArithmeticRoundedAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRoundedAdd(addend, value, count); /// - /// int64x1_t vrsra_n_s64 (int64x1_t a, int64x1_t b, const int n) - /// A32: VRSRA.S64 Dd, Dm, #n - /// A64: SRSRA Dd, Dn, #n + /// int64x1_t vrsra_n_s64 (int64x1_t a, int64x1_t b, const int n) + /// A32: VRSRA.S64 Dd, Dm, #n + /// A64: SRSRA Dd, Dn, #n /// public static Vector64 ShiftRightArithmeticRoundedAddScalar(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticRoundedAddScalar(addend, value, count); /// - /// int16x4_t vqrshrn_n_s32 (int32x4_t a, const int n) - /// A32: VQRSHRN.S32 Dd, Qm, #n - /// A64: SQRSHRN Vd.4H, Vn.4S, #n + /// int16x4_t vqrshrn_n_s32 (int32x4_t a, const int n) + /// A32: VQRSHRN.S32 Dd, Qm, #n + /// A64: SQRSHRN Vd.4H, Vn.4S, #n /// public static Vector64 ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateLower(value, count); /// - /// int32x2_t vqrshrn_n_s64 (int64x2_t a, const int n) - /// A32: VQRSHRN.S64 Dd, Qm, #n - /// A64: SQRSHRN Vd.2S, Vn.2D, #n + /// int32x2_t vqrshrn_n_s64 (int64x2_t a, const int n) + /// A32: VQRSHRN.S64 Dd, Qm, #n + /// A64: SQRSHRN Vd.2S, Vn.2D, #n /// public static Vector64 ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateLower(value, count); /// - /// int8x8_t vqrshrn_n_s16 (int16x8_t a, const int n) - /// A32: VQRSHRN.S16 Dd, Qm, #n - /// A64: SQRSHRN Vd.8B, Vn.8H, #n + /// int8x8_t vqrshrn_n_s16 (int16x8_t a, const int n) + /// A32: VQRSHRN.S16 Dd, Qm, #n + /// A64: SQRSHRN Vd.8B, Vn.8H, #n /// public static Vector64 ShiftRightArithmeticRoundedNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateLower(value, count); /// - /// uint8x8_t vqrshrun_n_s16 (int16x8_t a, const int n) - /// A32: VQRSHRUN.S16 Dd, Qm, #n - /// A64: SQRSHRUN Vd.8B, Vn.8H, #n + /// uint8x8_t vqrshrun_n_s16 (int16x8_t a, const int n) + /// A32: VQRSHRUN.S16 Dd, Qm, #n + /// A64: SQRSHRUN Vd.8B, Vn.8H, #n /// public static Vector64 ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(value, count); /// - /// uint16x4_t vqrshrun_n_s32 (int32x4_t a, const int n) - /// A32: VQRSHRUN.S32 Dd, Qm, #n - /// A64: SQRSHRUN Vd.4H, Vn.4S, #n + /// uint16x4_t vqrshrun_n_s32 (int32x4_t a, const int n) + /// A32: VQRSHRUN.S32 Dd, Qm, #n + /// A64: SQRSHRUN Vd.4H, Vn.4S, #n /// public static Vector64 ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(value, count); /// - /// uint32x2_t vqrshrun_n_s64 (int64x2_t a, const int n) - /// A32: VQRSHRUN.S64 Dd, Qm, #n - /// A64: SQRSHRUN Vd.2S, Vn.2D, #n + /// uint32x2_t vqrshrun_n_s64 (int64x2_t a, const int n) + /// A32: VQRSHRUN.S64 Dd, Qm, #n + /// A64: SQRSHRUN Vd.2S, Vn.2D, #n /// public static Vector64 ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedLower(value, count); /// - /// uint8x16_t vqrshrun_high_n_s16 (uint8x8_t r, int16x8_t a, const int n) - /// A32: VQRSHRUN.S16 Dd+1, Dn, #n - /// A64: SQRSHRUN2 Vd.16B, Vn.8H, #n + /// uint8x16_t vqrshrun_high_n_s16 (uint8x8_t r, int16x8_t a, const int n) + /// A32: VQRSHRUN.S16 Dd+1, Dn, #n + /// A64: SQRSHRUN2 Vd.16B, Vn.8H, #n /// public static Vector128 ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(lower, value, count); /// - /// uint16x8_t vqrshrun_high_n_s32 (uint16x4_t r, int32x4_t a, const int n) - /// A32: VQRSHRUN.S32 Dd+1, Dn, #n - /// A64: SQRSHRUN2 Vd.8H, Vn.4S, #n + /// uint16x8_t vqrshrun_high_n_s32 (uint16x4_t r, int32x4_t a, const int n) + /// A32: VQRSHRUN.S32 Dd+1, Dn, #n + /// A64: SQRSHRUN2 Vd.8H, Vn.4S, #n /// public static Vector128 ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(lower, value, count); /// - /// uint32x4_t vqrshrun_high_n_s64 (uint32x2_t r, int64x2_t a, const int n) - /// A32: VQRSHRUN.S64 Dd+1, Dn, #n - /// A64: SQRSHRUN2 Vd.4S, Vn.2D, #n + /// uint32x4_t vqrshrun_high_n_s64 (uint32x2_t r, int64x2_t a, const int n) + /// A32: VQRSHRUN.S64 Dd+1, Dn, #n + /// A64: SQRSHRUN2 Vd.4S, Vn.2D, #n /// public static Vector128 ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUnsignedUpper(lower, value, count); /// - /// int16x8_t vqrshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n) - /// A32: VQRSHRN.S32 Dd+1, Dn, #n - /// A64: SQRSHRN2 Vd.8H, Vn.4S, #n + /// int16x8_t vqrshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n) + /// A32: VQRSHRN.S32 Dd+1, Dn, #n + /// A64: SQRSHRN2 Vd.8H, Vn.4S, #n /// public static Vector128 ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUpper(lower, value, count); /// - /// int32x4_t vqrshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n) - /// A32: VQRSHRN.S64 Dd+1, Dn, #n - /// A64: SQRSHRN2 Vd.4S, Vn.2D, #n + /// int32x4_t vqrshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n) + /// A32: VQRSHRN.S64 Dd+1, Dn, #n + /// A64: SQRSHRN2 Vd.4S, Vn.2D, #n /// public static Vector128 ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUpper(lower, value, count); /// - /// int8x16_t vqrshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n) - /// A32: VQRSHRN.S16 Dd+1, Dn, #n - /// A64: SQRSHRN2 Vd.16B, Vn.8H, #n + /// int8x16_t vqrshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n) + /// A32: VQRSHRN.S16 Dd+1, Dn, #n + /// A64: SQRSHRN2 Vd.16B, Vn.8H, #n /// public static Vector128 ShiftRightArithmeticRoundedNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightArithmeticRoundedNarrowingSaturateUpper(lower, value, count); /// - /// int64x1_t vrshr_n_s64 (int64x1_t a, const int n) - /// A32: VRSHR.S64 Dd, Dm, #n - /// A64: SRSHR Dd, Dn, #n + /// int64x1_t vrshr_n_s64 (int64x1_t a, const int n) + /// A32: VRSHR.S64 Dd, Dm, #n + /// A64: SRSHR Dd, Dn, #n /// public static Vector64 ShiftRightArithmeticRoundedScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticRoundedScalar(value, count); /// - /// int64x1_t vshr_n_s64 (int64x1_t a, const int n) - /// A32: VSHR.S64 Dd, Dm, #n - /// A64: SSHR Dd, Dn, #n + /// int64x1_t vshr_n_s64 (int64x1_t a, const int n) + /// A32: VSHR.S64 Dd, Dm, #n + /// A64: SSHR Dd, Dn, #n /// public static Vector64 ShiftRightArithmeticScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightArithmeticScalar(value, count); /// - /// uint8x8_t vshr_n_u8 (uint8x8_t a, const int n) - /// A32: VSHR.U8 Dd, Dm, #n - /// A64: USHR Vd.8B, Vn.8B, #n + /// uint8x8_t vshr_n_u8 (uint8x8_t a, const int n) + /// A32: VSHR.U8 Dd, Dm, #n + /// A64: USHR Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightLogical(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogical(value, count); /// - /// uint16x4_t vshr_n_u16 (uint16x4_t a, const int n) - /// A32: VSHR.U16 Dd, Dm, #n - /// A64: USHR Vd.4H, Vn.4H, #n + /// uint16x4_t vshr_n_u16 (uint16x4_t a, const int n) + /// A32: VSHR.U16 Dd, Dm, #n + /// A64: USHR Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightLogical(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogical(value, count); /// - /// uint32x2_t vshr_n_u32 (uint32x2_t a, const int n) - /// A32: VSHR.U32 Dd, Dm, #n - /// A64: USHR Vd.2S, Vn.2S, #n + /// uint32x2_t vshr_n_u32 (uint32x2_t a, const int n) + /// A32: VSHR.U32 Dd, Dm, #n + /// A64: USHR Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightLogical(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogical(value, count); /// - /// uint8x8_t vshr_n_u8 (uint8x8_t a, const int n) - /// A32: VSHR.U8 Dd, Dm, #n - /// A64: USHR Vd.8B, Vn.8B, #n + /// uint8x8_t vshr_n_u8 (uint8x8_t a, const int n) + /// A32: VSHR.U8 Dd, Dm, #n + /// A64: USHR Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightLogical(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogical(value, count); /// - /// uint16x4_t vshr_n_u16 (uint16x4_t a, const int n) - /// A32: VSHR.U16 Dd, Dm, #n - /// A64: USHR Vd.4H, Vn.4H, #n + /// uint16x4_t vshr_n_u16 (uint16x4_t a, const int n) + /// A32: VSHR.U16 Dd, Dm, #n + /// A64: USHR Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightLogical(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogical(value, count); /// - /// uint32x2_t vshr_n_u32 (uint32x2_t a, const int n) - /// A32: VSHR.U32 Dd, Dm, #n - /// A64: USHR Vd.2S, Vn.2S, #n + /// uint32x2_t vshr_n_u32 (uint32x2_t a, const int n) + /// A32: VSHR.U32 Dd, Dm, #n + /// A64: USHR Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightLogical(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogical(value, count); /// - /// uint8x16_t vshrq_n_u8 (uint8x16_t a, const int n) - /// A32: VSHR.U8 Qd, Qm, #n - /// A64: USHR Vd.16B, Vn.16B, #n + /// uint8x16_t vshrq_n_u8 (uint8x16_t a, const int n) + /// A32: VSHR.U8 Qd, Qm, #n + /// A64: USHR Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogical(value, count); /// - /// uint16x8_t vshrq_n_u16 (uint16x8_t a, const int n) - /// A32: VSHR.U16 Qd, Qm, #n - /// A64: USHR Vd.8H, Vn.8H, #n + /// uint16x8_t vshrq_n_u16 (uint16x8_t a, const int n) + /// A32: VSHR.U16 Qd, Qm, #n + /// A64: USHR Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogical(value, count); /// - /// uint32x4_t vshrq_n_u32 (uint32x4_t a, const int n) - /// A32: VSHR.U32 Qd, Qm, #n - /// A64: USHR Vd.4S, Vn.4S, #n + /// uint32x4_t vshrq_n_u32 (uint32x4_t a, const int n) + /// A32: VSHR.U32 Qd, Qm, #n + /// A64: USHR Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogical(value, count); /// - /// uint64x2_t vshrq_n_u64 (uint64x2_t a, const int n) - /// A32: VSHR.U64 Qd, Qm, #n - /// A64: USHR Vd.2D, Vn.2D, #n + /// uint64x2_t vshrq_n_u64 (uint64x2_t a, const int n) + /// A32: VSHR.U64 Qd, Qm, #n + /// A64: USHR Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogical(value, count); /// - /// uint8x16_t vshrq_n_u8 (uint8x16_t a, const int n) - /// A32: VSHR.U8 Qd, Qm, #n - /// A64: USHR Vd.16B, Vn.16B, #n + /// uint8x16_t vshrq_n_u8 (uint8x16_t a, const int n) + /// A32: VSHR.U8 Qd, Qm, #n + /// A64: USHR Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogical(value, count); /// - /// uint16x8_t vshrq_n_u16 (uint16x8_t a, const int n) - /// A32: VSHR.U16 Qd, Qm, #n - /// A64: USHR Vd.8H, Vn.8H, #n + /// uint16x8_t vshrq_n_u16 (uint16x8_t a, const int n) + /// A32: VSHR.U16 Qd, Qm, #n + /// A64: USHR Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogical(value, count); /// - /// uint32x4_t vshrq_n_u32 (uint32x4_t a, const int n) - /// A32: VSHR.U32 Qd, Qm, #n - /// A64: USHR Vd.4S, Vn.4S, #n + /// uint32x4_t vshrq_n_u32 (uint32x4_t a, const int n) + /// A32: VSHR.U32 Qd, Qm, #n + /// A64: USHR Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogical(value, count); /// - /// uint64x2_t vshrq_n_u64 (uint64x2_t a, const int n) - /// A32: VSHR.U64 Qd, Qm, #n - /// A64: USHR Vd.2D, Vn.2D, #n + /// uint64x2_t vshrq_n_u64 (uint64x2_t a, const int n) + /// A32: VSHR.U64 Qd, Qm, #n + /// A64: USHR Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogical(value, count); /// - /// uint8x8_t vsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n) - /// A32: VSRA.U8 Dd, Dm, #n - /// A64: USRA Vd.8B, Vn.8B, #n + /// uint8x8_t vsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n) + /// A32: VSRA.U8 Dd, Dm, #n + /// A64: USRA Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightLogicalAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalAdd(addend, value, count); /// - /// uint16x4_t vsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n) - /// A32: VSRA.U16 Dd, Dm, #n - /// A64: USRA Vd.4H, Vn.4H, #n + /// uint16x4_t vsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n) + /// A32: VSRA.U16 Dd, Dm, #n + /// A64: USRA Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightLogicalAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalAdd(addend, value, count); /// - /// uint32x2_t vsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n) - /// A32: VSRA.U32 Dd, Dm, #n - /// A64: USRA Vd.2S, Vn.2S, #n + /// uint32x2_t vsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n) + /// A32: VSRA.U32 Dd, Dm, #n + /// A64: USRA Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightLogicalAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalAdd(addend, value, count); /// - /// uint8x8_t vsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n) - /// A32: VSRA.U8 Dd, Dm, #n - /// A64: USRA Vd.8B, Vn.8B, #n + /// uint8x8_t vsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n) + /// A32: VSRA.U8 Dd, Dm, #n + /// A64: USRA Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightLogicalAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalAdd(addend, value, count); /// - /// uint16x4_t vsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n) - /// A32: VSRA.U16 Dd, Dm, #n - /// A64: USRA Vd.4H, Vn.4H, #n + /// uint16x4_t vsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n) + /// A32: VSRA.U16 Dd, Dm, #n + /// A64: USRA Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightLogicalAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalAdd(addend, value, count); /// - /// uint32x2_t vsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n) - /// A32: VSRA.U32 Dd, Dm, #n - /// A64: USRA Vd.2S, Vn.2S, #n + /// uint32x2_t vsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n) + /// A32: VSRA.U32 Dd, Dm, #n + /// A64: USRA Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightLogicalAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalAdd(addend, value, count); /// - /// uint8x16_t vsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n) - /// A32: VSRA.U8 Qd, Qm, #n - /// A64: USRA Vd.16B, Vn.16B, #n + /// uint8x16_t vsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n) + /// A32: VSRA.U8 Qd, Qm, #n + /// A64: USRA Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightLogicalAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalAdd(addend, value, count); /// - /// uint16x8_t vsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n) - /// A32: VSRA.U16 Qd, Qm, #n - /// A64: USRA Vd.8H, Vn.8H, #n + /// uint16x8_t vsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n) + /// A32: VSRA.U16 Qd, Qm, #n + /// A64: USRA Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightLogicalAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalAdd(addend, value, count); /// - /// uint32x4_t vsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n) - /// A32: VSRA.U32 Qd, Qm, #n - /// A64: USRA Vd.4S, Vn.4S, #n + /// uint32x4_t vsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n) + /// A32: VSRA.U32 Qd, Qm, #n + /// A64: USRA Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightLogicalAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalAdd(addend, value, count); /// - /// uint64x2_t vsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n) - /// A32: VSRA.U64 Qd, Qm, #n - /// A64: USRA Vd.2D, Vn.2D, #n + /// uint64x2_t vsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n) + /// A32: VSRA.U64 Qd, Qm, #n + /// A64: USRA Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightLogicalAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalAdd(addend, value, count); /// - /// uint8x16_t vsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n) - /// A32: VSRA.U8 Qd, Qm, #n - /// A64: USRA Vd.16B, Vn.16B, #n + /// uint8x16_t vsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n) + /// A32: VSRA.U8 Qd, Qm, #n + /// A64: USRA Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightLogicalAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalAdd(addend, value, count); /// - /// uint16x8_t vsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n) - /// A32: VSRA.U16 Qd, Qm, #n - /// A64: USRA Vd.8H, Vn.8H, #n + /// uint16x8_t vsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n) + /// A32: VSRA.U16 Qd, Qm, #n + /// A64: USRA Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightLogicalAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalAdd(addend, value, count); /// - /// uint32x4_t vsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n) - /// A32: VSRA.U32 Qd, Qm, #n - /// A64: USRA Vd.4S, Vn.4S, #n + /// uint32x4_t vsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n) + /// A32: VSRA.U32 Qd, Qm, #n + /// A64: USRA Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightLogicalAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalAdd(addend, value, count); /// - /// uint64x2_t vsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n) - /// A32: VSRA.U64 Qd, Qm, #n - /// A64: USRA Vd.2D, Vn.2D, #n + /// uint64x2_t vsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n) + /// A32: VSRA.U64 Qd, Qm, #n + /// A64: USRA Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightLogicalAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalAdd(addend, value, count); /// - /// uint64x1_t vsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n) - /// A32: VSRA.U64 Dd, Dm, #n - /// A64: USRA Dd, Dn, #n + /// uint64x1_t vsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n) + /// A32: VSRA.U64 Dd, Dm, #n + /// A64: USRA Dd, Dn, #n /// public static Vector64 ShiftRightLogicalAddScalar(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalAddScalar(addend, value, count); /// - /// uint64x1_t vsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n) - /// A32: VSRA.U64 Dd, Dm, #n - /// A64: USRA Dd, Dn, #n + /// uint64x1_t vsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n) + /// A32: VSRA.U64 Dd, Dm, #n + /// A64: USRA Dd, Dn, #n /// public static Vector64 ShiftRightLogicalAddScalar(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalAddScalar(addend, value, count); /// - /// uint8x8_t vshrn_n_u16 (uint16x8_t a, const int n) - /// A32: VSHRN.I16 Dd, Qm, #n - /// A64: SHRN Vd.8B, Vn.8H, #n + /// uint8x8_t vshrn_n_u16 (uint16x8_t a, const int n) + /// A32: VSHRN.I16 Dd, Qm, #n + /// A64: SHRN Vd.8B, Vn.8H, #n /// public static Vector64 ShiftRightLogicalNarrowingLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalNarrowingLower(value, count); /// - /// int16x4_t vshrn_n_s32 (int32x4_t a, const int n) - /// A32: VSHRN.I32 Dd, Qm, #n - /// A64: SHRN Vd.4H, Vn.4S, #n + /// int16x4_t vshrn_n_s32 (int32x4_t a, const int n) + /// A32: VSHRN.I32 Dd, Qm, #n + /// A64: SHRN Vd.4H, Vn.4S, #n /// public static Vector64 ShiftRightLogicalNarrowingLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingLower(value, count); /// - /// int32x2_t vshrn_n_s64 (int64x2_t a, const int n) - /// A32: VSHRN.I64 Dd, Qm, #n - /// A64: SHRN Vd.2S, Vn.2D, #n + /// int32x2_t vshrn_n_s64 (int64x2_t a, const int n) + /// A32: VSHRN.I64 Dd, Qm, #n + /// A64: SHRN Vd.2S, Vn.2D, #n /// public static Vector64 ShiftRightLogicalNarrowingLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingLower(value, count); /// - /// int8x8_t vshrn_n_s16 (int16x8_t a, const int n) - /// A32: VSHRN.I16 Dd, Qm, #n - /// A64: SHRN Vd.8B, Vn.8H, #n + /// int8x8_t vshrn_n_s16 (int16x8_t a, const int n) + /// A32: VSHRN.I16 Dd, Qm, #n + /// A64: SHRN Vd.8B, Vn.8H, #n /// public static Vector64 ShiftRightLogicalNarrowingLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalNarrowingLower(value, count); /// - /// uint16x4_t vshrn_n_u32 (uint32x4_t a, const int n) - /// A32: VSHRN.I32 Dd, Qm, #n - /// A64: SHRN Vd.4H, Vn.4S, #n + /// uint16x4_t vshrn_n_u32 (uint32x4_t a, const int n) + /// A32: VSHRN.I32 Dd, Qm, #n + /// A64: SHRN Vd.4H, Vn.4S, #n /// public static Vector64 ShiftRightLogicalNarrowingLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingLower(value, count); /// - /// uint32x2_t vshrn_n_u64 (uint64x2_t a, const int n) - /// A32: VSHRN.I64 Dd, Qm, #n - /// A64: SHRN Vd.2S, Vn.2D, #n + /// uint32x2_t vshrn_n_u64 (uint64x2_t a, const int n) + /// A32: VSHRN.I64 Dd, Qm, #n + /// A64: SHRN Vd.2S, Vn.2D, #n /// public static Vector64 ShiftRightLogicalNarrowingLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingLower(value, count); /// - /// uint8x8_t vqshrn_n_u16 (uint16x8_t a, const int n) - /// A32: VQSHRN.U16 Dd, Qm, #n - /// A64: UQSHRN Vd.8B, Vn.8H, #n + /// uint8x8_t vqshrn_n_u16 (uint16x8_t a, const int n) + /// A32: VQSHRN.U16 Dd, Qm, #n + /// A64: UQSHRN Vd.8B, Vn.8H, #n /// public static Vector64 ShiftRightLogicalNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalNarrowingSaturateLower(value, count); /// - /// uint16x4_t vqshrn_n_u32 (uint32x4_t a, const int n) - /// A32: VQSHRN.U32 Dd, Qm, #n - /// A64: UQSHRN Vd.4H, Vn.4S, #n + /// uint16x4_t vqshrn_n_u32 (uint32x4_t a, const int n) + /// A32: VQSHRN.U32 Dd, Qm, #n + /// A64: UQSHRN Vd.4H, Vn.4S, #n /// public static Vector64 ShiftRightLogicalNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingSaturateLower(value, count); /// - /// uint32x2_t vqshrn_n_u64 (uint64x2_t a, const int n) - /// A32: VQSHRN.U64 Dd, Qm, #n - /// A64: UQSHRN Vd.2S, Vn.2D, #n + /// uint32x2_t vqshrn_n_u64 (uint64x2_t a, const int n) + /// A32: VQSHRN.U64 Dd, Qm, #n + /// A64: UQSHRN Vd.2S, Vn.2D, #n /// public static Vector64 ShiftRightLogicalNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingSaturateLower(value, count); /// - /// uint8x8_t vqshrn_n_u16 (uint16x8_t a, const int n) - /// A32: VQSHRN.U16 Dd, Qm, #n - /// A64: UQSHRN Vd.8B, Vn.8H, #n + /// uint8x8_t vqshrn_n_u16 (uint16x8_t a, const int n) + /// A32: VQSHRN.U16 Dd, Qm, #n + /// A64: UQSHRN Vd.8B, Vn.8H, #n /// public static Vector64 ShiftRightLogicalNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalNarrowingSaturateLower(value, count); /// - /// uint16x4_t vqshrn_n_u32 (uint32x4_t a, const int n) - /// A32: VQSHRN.U32 Dd, Qm, #n - /// A64: UQSHRN Vd.4H, Vn.4S, #n + /// uint16x4_t vqshrn_n_u32 (uint32x4_t a, const int n) + /// A32: VQSHRN.U32 Dd, Qm, #n + /// A64: UQSHRN Vd.4H, Vn.4S, #n /// public static Vector64 ShiftRightLogicalNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingSaturateLower(value, count); /// - /// uint32x2_t vqshrn_n_u64 (uint64x2_t a, const int n) - /// A32: VQSHRN.U64 Dd, Qm, #n - /// A64: UQSHRN Vd.2S, Vn.2D, #n + /// uint32x2_t vqshrn_n_u64 (uint64x2_t a, const int n) + /// A32: VQSHRN.U64 Dd, Qm, #n + /// A64: UQSHRN Vd.2S, Vn.2D, #n /// public static Vector64 ShiftRightLogicalNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingSaturateLower(value, count); /// - /// uint8x16_t vqshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n) - /// A32: VQSHRN.U16 Dd+1, Qm, #n - /// A64: UQSHRN2 Vd.16B, Vn.8H, #n + /// uint8x16_t vqshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n) + /// A32: VQSHRN.U16 Dd+1, Qm, #n + /// A64: UQSHRN2 Vd.16B, Vn.8H, #n /// public static Vector128 ShiftRightLogicalNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalNarrowingSaturateUpper(lower, value, count); /// - /// uint16x8_t vqshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n) - /// A32: VQSHRN.U32 Dd+1, Qm, #n - /// A64: UQSHRN2 Vd.8H, Vn.4S, #n + /// uint16x8_t vqshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n) + /// A32: VQSHRN.U32 Dd+1, Qm, #n + /// A64: UQSHRN2 Vd.8H, Vn.4S, #n /// public static Vector128 ShiftRightLogicalNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingSaturateUpper(lower, value, count); /// - /// uint32x4_t vqshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n) - /// A32: VQSHRN.U64 Dd+1, Qm, #n - /// A64: UQSHRN2 Vd.4S, Vn.2D, #n + /// uint32x4_t vqshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n) + /// A32: VQSHRN.U64 Dd+1, Qm, #n + /// A64: UQSHRN2 Vd.4S, Vn.2D, #n /// public static Vector128 ShiftRightLogicalNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingSaturateUpper(lower, value, count); /// - /// uint8x16_t vqshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n) - /// A32: VQSHRN.U16 Dd+1, Qm, #n - /// A64: UQSHRN2 Vd.16B, Vn.8H, #n + /// uint8x16_t vqshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n) + /// A32: VQSHRN.U16 Dd+1, Qm, #n + /// A64: UQSHRN2 Vd.16B, Vn.8H, #n /// public static Vector128 ShiftRightLogicalNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalNarrowingSaturateUpper(lower, value, count); /// - /// uint16x8_t vqshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n) - /// A32: VQSHRN.U32 Dd+1, Qm, #n - /// A64: UQSHRN2 Vd.8H, Vn.4S, #n + /// uint16x8_t vqshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n) + /// A32: VQSHRN.U32 Dd+1, Qm, #n + /// A64: UQSHRN2 Vd.8H, Vn.4S, #n /// public static Vector128 ShiftRightLogicalNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingSaturateUpper(lower, value, count); /// - /// uint32x4_t vqshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n) - /// A32: VQSHRN.U64 Dd+1, Qm, #n - /// A64: UQSHRN2 Vd.4S, Vn.2D, #n + /// uint32x4_t vqshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n) + /// A32: VQSHRN.U64 Dd+1, Qm, #n + /// A64: UQSHRN2 Vd.4S, Vn.2D, #n /// public static Vector128 ShiftRightLogicalNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingSaturateUpper(lower, value, count); /// - /// uint8x16_t vshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n) - /// A32: VSHRN.I16 Dd+1, Qm, #n - /// A64: SHRN2 Vd.16B, Vn.8H, #n + /// uint8x16_t vshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n) + /// A32: VSHRN.I16 Dd+1, Qm, #n + /// A64: SHRN2 Vd.16B, Vn.8H, #n /// public static Vector128 ShiftRightLogicalNarrowingUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalNarrowingUpper(lower, value, count); /// - /// int16x8_t vshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n) - /// A32: VSHRN.I32 Dd+1, Qm, #n - /// A64: SHRN2 Vd.8H, Vn.4S, #n + /// int16x8_t vshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n) + /// A32: VSHRN.I32 Dd+1, Qm, #n + /// A64: SHRN2 Vd.8H, Vn.4S, #n /// public static Vector128 ShiftRightLogicalNarrowingUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingUpper(lower, value, count); /// - /// int32x4_t vshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n) - /// A32: VSHRN.I64 Dd+1, Qm, #n - /// A64: SHRN2 Vd.4S, Vn.2D, #n + /// int32x4_t vshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n) + /// A32: VSHRN.I64 Dd+1, Qm, #n + /// A64: SHRN2 Vd.4S, Vn.2D, #n /// public static Vector128 ShiftRightLogicalNarrowingUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingUpper(lower, value, count); /// - /// int8x16_t vshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n) - /// A32: VSHRN.I16 Dd+1, Qm, #n - /// A64: SHRN2 Vd.16B, Vn.8H, #n + /// int8x16_t vshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n) + /// A32: VSHRN.I16 Dd+1, Qm, #n + /// A64: SHRN2 Vd.16B, Vn.8H, #n /// public static Vector128 ShiftRightLogicalNarrowingUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalNarrowingUpper(lower, value, count); /// - /// uint16x8_t vshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n) - /// A32: VSHRN.I32 Dd+1, Qm, #n - /// A64: SHRN2 Vd.8H, Vn.4S, #n + /// uint16x8_t vshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n) + /// A32: VSHRN.I32 Dd+1, Qm, #n + /// A64: SHRN2 Vd.8H, Vn.4S, #n /// public static Vector128 ShiftRightLogicalNarrowingUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalNarrowingUpper(lower, value, count); /// - /// uint32x4_t vshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n) - /// A32: VSHRN.I64 Dd+1, Qm, #n - /// A64: SHRN2 Vd.4S, Vn.2D, #n + /// uint32x4_t vshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n) + /// A32: VSHRN.I64 Dd+1, Qm, #n + /// A64: SHRN2 Vd.4S, Vn.2D, #n /// public static Vector128 ShiftRightLogicalNarrowingUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalNarrowingUpper(lower, value, count); /// - /// uint8x8_t vrshr_n_u8 (uint8x8_t a, const int n) - /// A32: VRSHR.U8 Dd, Dm, #n - /// A64: URSHR Vd.8B, Vn.8B, #n + /// uint8x8_t vrshr_n_u8 (uint8x8_t a, const int n) + /// A32: VRSHR.U8 Dd, Dm, #n + /// A64: URSHR Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightLogicalRounded(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRounded(value, count); /// - /// uint16x4_t vrshr_n_u16 (uint16x4_t a, const int n) - /// A32: VRSHR.U16 Dd, Dm, #n - /// A64: URSHR Vd.4H, Vn.4H, #n + /// uint16x4_t vrshr_n_u16 (uint16x4_t a, const int n) + /// A32: VRSHR.U16 Dd, Dm, #n + /// A64: URSHR Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightLogicalRounded(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRounded(value, count); /// - /// uint32x2_t vrshr_n_u32 (uint32x2_t a, const int n) - /// A32: VRSHR.U32 Dd, Dm, #n - /// A64: URSHR Vd.2S, Vn.2S, #n + /// uint32x2_t vrshr_n_u32 (uint32x2_t a, const int n) + /// A32: VRSHR.U32 Dd, Dm, #n + /// A64: URSHR Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightLogicalRounded(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRounded(value, count); /// - /// uint8x8_t vrshr_n_u8 (uint8x8_t a, const int n) - /// A32: VRSHR.U8 Dd, Dm, #n - /// A64: URSHR Vd.8B, Vn.8B, #n + /// uint8x8_t vrshr_n_u8 (uint8x8_t a, const int n) + /// A32: VRSHR.U8 Dd, Dm, #n + /// A64: URSHR Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightLogicalRounded(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRounded(value, count); /// - /// uint16x4_t vrshr_n_u16 (uint16x4_t a, const int n) - /// A32: VRSHR.U16 Dd, Dm, #n - /// A64: URSHR Vd.4H, Vn.4H, #n + /// uint16x4_t vrshr_n_u16 (uint16x4_t a, const int n) + /// A32: VRSHR.U16 Dd, Dm, #n + /// A64: URSHR Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightLogicalRounded(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRounded(value, count); /// - /// uint32x2_t vrshr_n_u32 (uint32x2_t a, const int n) - /// A32: VRSHR.U32 Dd, Dm, #n - /// A64: URSHR Vd.2S, Vn.2S, #n + /// uint32x2_t vrshr_n_u32 (uint32x2_t a, const int n) + /// A32: VRSHR.U32 Dd, Dm, #n + /// A64: URSHR Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightLogicalRounded(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRounded(value, count); /// - /// uint8x16_t vrshrq_n_u8 (uint8x16_t a, const int n) - /// A32: VRSHR.U8 Qd, Qm, #n - /// A64: URSHR Vd.16B, Vn.16B, #n + /// uint8x16_t vrshrq_n_u8 (uint8x16_t a, const int n) + /// A32: VRSHR.U8 Qd, Qm, #n + /// A64: URSHR Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightLogicalRounded(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRounded(value, count); /// - /// uint16x8_t vrshrq_n_u16 (uint16x8_t a, const int n) - /// A32: VRSHR.U16 Qd, Qm, #n - /// A64: URSHR Vd.8H, Vn.8H, #n + /// uint16x8_t vrshrq_n_u16 (uint16x8_t a, const int n) + /// A32: VRSHR.U16 Qd, Qm, #n + /// A64: URSHR Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightLogicalRounded(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRounded(value, count); /// - /// uint32x4_t vrshrq_n_u32 (uint32x4_t a, const int n) - /// A32: VRSHR.U32 Qd, Qm, #n - /// A64: URSHR Vd.4S, Vn.4S, #n + /// uint32x4_t vrshrq_n_u32 (uint32x4_t a, const int n) + /// A32: VRSHR.U32 Qd, Qm, #n + /// A64: URSHR Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightLogicalRounded(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRounded(value, count); /// - /// uint64x2_t vrshrq_n_u64 (uint64x2_t a, const int n) - /// A32: VRSHR.U64 Qd, Qm, #n - /// A64: URSHR Vd.2D, Vn.2D, #n + /// uint64x2_t vrshrq_n_u64 (uint64x2_t a, const int n) + /// A32: VRSHR.U64 Qd, Qm, #n + /// A64: URSHR Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightLogicalRounded(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRounded(value, count); /// - /// uint8x16_t vrshrq_n_u8 (uint8x16_t a, const int n) - /// A32: VRSHR.U8 Qd, Qm, #n - /// A64: URSHR Vd.16B, Vn.16B, #n + /// uint8x16_t vrshrq_n_u8 (uint8x16_t a, const int n) + /// A32: VRSHR.U8 Qd, Qm, #n + /// A64: URSHR Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightLogicalRounded(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRounded(value, count); /// - /// uint16x8_t vrshrq_n_u16 (uint16x8_t a, const int n) - /// A32: VRSHR.U16 Qd, Qm, #n - /// A64: URSHR Vd.8H, Vn.8H, #n + /// uint16x8_t vrshrq_n_u16 (uint16x8_t a, const int n) + /// A32: VRSHR.U16 Qd, Qm, #n + /// A64: URSHR Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightLogicalRounded(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRounded(value, count); /// - /// uint32x4_t vrshrq_n_u32 (uint32x4_t a, const int n) - /// A32: VRSHR.U32 Qd, Qm, #n - /// A64: URSHR Vd.4S, Vn.4S, #n + /// uint32x4_t vrshrq_n_u32 (uint32x4_t a, const int n) + /// A32: VRSHR.U32 Qd, Qm, #n + /// A64: URSHR Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightLogicalRounded(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRounded(value, count); /// - /// uint64x2_t vrshrq_n_u64 (uint64x2_t a, const int n) - /// A32: VRSHR.U64 Qd, Qm, #n - /// A64: URSHR Vd.2D, Vn.2D, #n + /// uint64x2_t vrshrq_n_u64 (uint64x2_t a, const int n) + /// A32: VRSHR.U64 Qd, Qm, #n + /// A64: URSHR Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightLogicalRounded(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRounded(value, count); /// - /// uint8x8_t vrsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n) - /// A32: VRSRA.U8 Dd, Dm, #n - /// A64: URSRA Vd.8B, Vn.8B, #n + /// uint8x8_t vrsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n) + /// A32: VRSRA.U8 Dd, Dm, #n + /// A64: URSRA Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightLogicalRoundedAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count); /// - /// uint16x4_t vrsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n) - /// A32: VRSRA.U16 Dd, Dm, #n - /// A64: URSRA Vd.4H, Vn.4H, #n + /// uint16x4_t vrsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n) + /// A32: VRSRA.U16 Dd, Dm, #n + /// A64: URSRA Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightLogicalRoundedAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count); /// - /// uint32x2_t vrsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n) - /// A32: VRSRA.U32 Dd, Dm, #n - /// A64: URSRA Vd.2S, Vn.2S, #n + /// uint32x2_t vrsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n) + /// A32: VRSRA.U32 Dd, Dm, #n + /// A64: URSRA Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightLogicalRoundedAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count); /// - /// uint8x8_t vrsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n) - /// A32: VRSRA.U8 Dd, Dm, #n - /// A64: URSRA Vd.8B, Vn.8B, #n + /// uint8x8_t vrsra_n_u8 (uint8x8_t a, uint8x8_t b, const int n) + /// A32: VRSRA.U8 Dd, Dm, #n + /// A64: URSRA Vd.8B, Vn.8B, #n /// public static Vector64 ShiftRightLogicalRoundedAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count); /// - /// uint16x4_t vrsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n) - /// A32: VRSRA.U16 Dd, Dm, #n - /// A64: URSRA Vd.4H, Vn.4H, #n + /// uint16x4_t vrsra_n_u16 (uint16x4_t a, uint16x4_t b, const int n) + /// A32: VRSRA.U16 Dd, Dm, #n + /// A64: URSRA Vd.4H, Vn.4H, #n /// public static Vector64 ShiftRightLogicalRoundedAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count); /// - /// uint32x2_t vrsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n) - /// A32: VRSRA.U32 Dd, Dm, #n - /// A64: URSRA Vd.2S, Vn.2S, #n + /// uint32x2_t vrsra_n_u32 (uint32x2_t a, uint32x2_t b, const int n) + /// A32: VRSRA.U32 Dd, Dm, #n + /// A64: URSRA Vd.2S, Vn.2S, #n /// public static Vector64 ShiftRightLogicalRoundedAdd(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count); /// - /// uint8x16_t vrsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n) - /// A32: VRSRA.U8 Qd, Qm, #n - /// A64: URSRA Vd.16B, Vn.16B, #n + /// uint8x16_t vrsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n) + /// A32: VRSRA.U8 Qd, Qm, #n + /// A64: URSRA Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightLogicalRoundedAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count); /// - /// uint16x8_t vrsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n) - /// A32: VRSRA.U16 Qd, Qm, #n - /// A64: URSRA Vd.8H, Vn.8H, #n + /// uint16x8_t vrsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n) + /// A32: VRSRA.U16 Qd, Qm, #n + /// A64: URSRA Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightLogicalRoundedAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count); /// - /// uint32x4_t vrsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n) - /// A32: VRSRA.U32 Qd, Qm, #n - /// A64: URSRA Vd.4S, Vn.4S, #n + /// uint32x4_t vrsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n) + /// A32: VRSRA.U32 Qd, Qm, #n + /// A64: URSRA Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightLogicalRoundedAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count); /// - /// uint64x2_t vrsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n) - /// A32: VRSRA.U64 Qd, Qm, #n - /// A64: URSRA Vd.2D, Vn.2D, #n + /// uint64x2_t vrsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n) + /// A32: VRSRA.U64 Qd, Qm, #n + /// A64: URSRA Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightLogicalRoundedAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count); /// - /// uint8x16_t vrsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n) - /// A32: VRSRA.U8 Qd, Qm, #n - /// A64: URSRA Vd.16B, Vn.16B, #n + /// uint8x16_t vrsraq_n_u8 (uint8x16_t a, uint8x16_t b, const int n) + /// A32: VRSRA.U8 Qd, Qm, #n + /// A64: URSRA Vd.16B, Vn.16B, #n /// public static Vector128 ShiftRightLogicalRoundedAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count); /// - /// uint16x8_t vrsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n) - /// A32: VRSRA.U16 Qd, Qm, #n - /// A64: URSRA Vd.8H, Vn.8H, #n + /// uint16x8_t vrsraq_n_u16 (uint16x8_t a, uint16x8_t b, const int n) + /// A32: VRSRA.U16 Qd, Qm, #n + /// A64: URSRA Vd.8H, Vn.8H, #n /// public static Vector128 ShiftRightLogicalRoundedAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count); /// - /// uint32x4_t vrsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n) - /// A32: VRSRA.U32 Qd, Qm, #n - /// A64: URSRA Vd.4S, Vn.4S, #n + /// uint32x4_t vrsraq_n_u32 (uint32x4_t a, uint32x4_t b, const int n) + /// A32: VRSRA.U32 Qd, Qm, #n + /// A64: URSRA Vd.4S, Vn.4S, #n /// public static Vector128 ShiftRightLogicalRoundedAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count); /// - /// uint64x2_t vrsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n) - /// A32: VRSRA.U64 Qd, Qm, #n - /// A64: URSRA Vd.2D, Vn.2D, #n + /// uint64x2_t vrsraq_n_u64 (uint64x2_t a, uint64x2_t b, const int n) + /// A32: VRSRA.U64 Qd, Qm, #n + /// A64: URSRA Vd.2D, Vn.2D, #n /// public static Vector128 ShiftRightLogicalRoundedAdd(Vector128 addend, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedAdd(addend, value, count); /// - /// uint64x1_t vrsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n) - /// A32: VRSRA.U64 Dd, Dm, #n - /// A64: URSRA Dd, Dn, #n + /// uint64x1_t vrsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n) + /// A32: VRSRA.U64 Dd, Dm, #n + /// A64: URSRA Dd, Dn, #n /// public static Vector64 ShiftRightLogicalRoundedAddScalar(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedAddScalar(addend, value, count); /// - /// uint64x1_t vrsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n) - /// A32: VRSRA.U64 Dd, Dm, #n - /// A64: URSRA Dd, Dn, #n + /// uint64x1_t vrsra_n_u64 (uint64x1_t a, uint64x1_t b, const int n) + /// A32: VRSRA.U64 Dd, Dm, #n + /// A64: URSRA Dd, Dn, #n /// public static Vector64 ShiftRightLogicalRoundedAddScalar(Vector64 addend, Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedAddScalar(addend, value, count); /// - /// uint8x8_t vrshrn_n_u16 (uint16x8_t a, const int n) - /// A32: VRSHRN.I16 Dd, Qm, #n - /// A64: RSHRN Vd.8B, Vn.8H, #n + /// uint8x8_t vrshrn_n_u16 (uint16x8_t a, const int n) + /// A32: VRSHRN.I16 Dd, Qm, #n + /// A64: RSHRN Vd.8B, Vn.8H, #n /// public static Vector64 ShiftRightLogicalRoundedNarrowingLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedNarrowingLower(value, count); /// - /// int16x4_t vrshrn_n_s32 (int32x4_t a, const int n) - /// A32: VRSHRN.I32 Dd, Qm, #n - /// A64: RSHRN Vd.4H, Vn.4S, #n + /// int16x4_t vrshrn_n_s32 (int32x4_t a, const int n) + /// A32: VRSHRN.I32 Dd, Qm, #n + /// A64: RSHRN Vd.4H, Vn.4S, #n /// public static Vector64 ShiftRightLogicalRoundedNarrowingLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingLower(value, count); /// - /// int32x2_t vrshrn_n_s64 (int64x2_t a, const int n) - /// A32: VRSHRN.I64 Dd, Qm, #n - /// A64: RSHRN Vd.2S, Vn.2D, #n + /// int32x2_t vrshrn_n_s64 (int64x2_t a, const int n) + /// A32: VRSHRN.I64 Dd, Qm, #n + /// A64: RSHRN Vd.2S, Vn.2D, #n /// public static Vector64 ShiftRightLogicalRoundedNarrowingLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingLower(value, count); /// - /// int8x8_t vrshrn_n_s16 (int16x8_t a, const int n) - /// A32: VRSHRN.I16 Dd, Qm, #n - /// A64: RSHRN Vd.8B, Vn.8H, #n + /// int8x8_t vrshrn_n_s16 (int16x8_t a, const int n) + /// A32: VRSHRN.I16 Dd, Qm, #n + /// A64: RSHRN Vd.8B, Vn.8H, #n /// public static Vector64 ShiftRightLogicalRoundedNarrowingLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedNarrowingLower(value, count); /// - /// uint16x4_t vrshrn_n_u32 (uint32x4_t a, const int n) - /// A32: VRSHRN.I32 Dd, Qm, #n - /// A64: RSHRN Vd.4H, Vn.4S, #n + /// uint16x4_t vrshrn_n_u32 (uint32x4_t a, const int n) + /// A32: VRSHRN.I32 Dd, Qm, #n + /// A64: RSHRN Vd.4H, Vn.4S, #n /// public static Vector64 ShiftRightLogicalRoundedNarrowingLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingLower(value, count); /// - /// uint32x2_t vrshrn_n_u64 (uint64x2_t a, const int n) - /// A32: VRSHRN.I64 Dd, Qm, #n - /// A64: RSHRN Vd.2S, Vn.2D, #n + /// uint32x2_t vrshrn_n_u64 (uint64x2_t a, const int n) + /// A32: VRSHRN.I64 Dd, Qm, #n + /// A64: RSHRN Vd.2S, Vn.2D, #n /// public static Vector64 ShiftRightLogicalRoundedNarrowingLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingLower(value, count); /// - /// uint8x8_t vqrshrn_n_u16 (uint16x8_t a, const int n) - /// A32: VQRSHRN.U16 Dd, Qm, #n - /// A64: UQRSHRN Vd.8B, Vn.8H, #n + /// uint8x8_t vqrshrn_n_u16 (uint16x8_t a, const int n) + /// A32: VQRSHRN.U16 Dd, Qm, #n + /// A64: UQRSHRN Vd.8B, Vn.8H, #n /// public static Vector64 ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, count); /// - /// uint16x4_t vqrshrn_n_u32 (uint32x4_t a, const int n) - /// A32: VQRSHRN.U32 Dd, Qm, #n - /// A64: UQRSHRN Vd.4H, Vn.4S, #n + /// uint16x4_t vqrshrn_n_u32 (uint32x4_t a, const int n) + /// A32: VQRSHRN.U32 Dd, Qm, #n + /// A64: UQRSHRN Vd.4H, Vn.4S, #n /// [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)] public static Vector64 ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, count); /// - /// uint32x2_t vqrshrn_n_u64 (uint64x2_t a, const int n) - /// A32: VQRSHRN.U64 Dd, Qm, #n - /// A64: UQRSHRN Vd.2S, Vn.2D, #n + /// uint32x2_t vqrshrn_n_u64 (uint64x2_t a, const int n) + /// A32: VQRSHRN.U64 Dd, Qm, #n + /// A64: UQRSHRN Vd.2S, Vn.2D, #n /// [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)] public static Vector64 ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, count); /// - /// uint8x8_t vqrshrn_n_u16 (uint16x8_t a, const int n) - /// A32: VQRSHRN.U16 Dd, Qm, #n - /// A64: UQRSHRN Vd.8B, Vn.8H, #n + /// uint8x8_t vqrshrn_n_u16 (uint16x8_t a, const int n) + /// A32: VQRSHRN.U16 Dd, Qm, #n + /// A64: UQRSHRN Vd.8B, Vn.8H, #n /// [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)] public static Vector64 ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, count); /// - /// uint16x4_t vqrshrn_n_u32 (uint32x4_t a, const int n) - /// A32: VQRSHRN.U32 Dd, Qm, #n - /// A64: UQRSHRN Vd.4H, Vn.4S, #n + /// uint16x4_t vqrshrn_n_u32 (uint32x4_t a, const int n) + /// A32: VQRSHRN.U32 Dd, Qm, #n + /// A64: UQRSHRN Vd.4H, Vn.4S, #n /// public static Vector64 ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, count); /// - /// uint32x2_t vqrshrn_n_u64 (uint64x2_t a, const int n) - /// A32: VQRSHRN.U64 Dd, Qm, #n - /// A64: UQRSHRN Vd.2S, Vn.2D, #n + /// uint32x2_t vqrshrn_n_u64 (uint64x2_t a, const int n) + /// A32: VQRSHRN.U64 Dd, Qm, #n + /// A64: UQRSHRN Vd.2S, Vn.2D, #n /// public static Vector64 ShiftRightLogicalRoundedNarrowingSaturateLower(Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateLower(value, count); /// - /// uint8x16_t vqrshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n) - /// A32: VQRSHRN.U16 Dd+1, Dn, #n - /// A64: UQRSHRN2 Vd.16B, Vn.8H, #n + /// uint8x16_t vqrshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n) + /// A32: VQRSHRN.U16 Dd+1, Dn, #n + /// A64: UQRSHRN2 Vd.16B, Vn.8H, #n /// public static Vector128 ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, value, count); /// - /// uint16x8_t vqrshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n) - /// A32: VQRSHRN.U32 Dd+1, Dn, #n - /// A64: UQRSHRN2 Vd.8H, Vn.4S, #n + /// uint16x8_t vqrshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n) + /// A32: VQRSHRN.U32 Dd+1, Dn, #n + /// A64: UQRSHRN2 Vd.8H, Vn.4S, #n /// [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)] public static Vector128 ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, value, count); /// - /// uint32x4_t vqrshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n) - /// A32: VQRSHRN.U64 Dd+1, Dn, #n - /// A64: UQRSHRN2 Vd.4S, Vn.2D, #n + /// uint32x4_t vqrshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n) + /// A32: VQRSHRN.U64 Dd+1, Dn, #n + /// A64: UQRSHRN2 Vd.4S, Vn.2D, #n /// [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)] public static Vector128 ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, value, count); /// - /// uint8x16_t vqrshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n) - /// A32: VQRSHRN.U16 Dd+1, Dn, #n - /// A64: UQRSHRN2 Vd.16B, Vn.8H, #n + /// uint8x16_t vqrshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n) + /// A32: VQRSHRN.U16 Dd+1, Dn, #n + /// A64: UQRSHRN2 Vd.16B, Vn.8H, #n /// [Obsolete(Obsoletions.ArmIntrinsicPerformsUnsignedOperationMessage, DiagnosticId = Obsoletions.ArmIntrinsicPerformsUnsignedOperationDiagId, UrlFormat = Obsoletions.SharedUrlFormat)] public static Vector128 ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, value, count); /// - /// uint16x8_t vqrshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n) - /// A32: VQRSHRN.U32 Dd+1, Dn, #n - /// A64: UQRSHRN2 Vd.8H, Vn.4S, #n + /// uint16x8_t vqrshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n) + /// A32: VQRSHRN.U32 Dd+1, Dn, #n + /// A64: UQRSHRN2 Vd.8H, Vn.4S, #n /// public static Vector128 ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, value, count); /// - /// uint32x4_t vqrshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n) - /// A32: VQRSHRN.U64 Dd+1, Dn, #n - /// A64: UQRSHRN2 Vd.4S, Vn.2D, #n + /// uint32x4_t vqrshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n) + /// A32: VQRSHRN.U64 Dd+1, Dn, #n + /// A64: UQRSHRN2 Vd.4S, Vn.2D, #n /// public static Vector128 ShiftRightLogicalRoundedNarrowingSaturateUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingSaturateUpper(lower, value, count); /// - /// uint8x16_t vrshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n) - /// A32: VRSHRN.I16 Dd+1, Qm, #n - /// A64: RSHRN2 Vd.16B, Vn.8H, #n + /// uint8x16_t vrshrn_high_n_u16 (uint8x8_t r, uint16x8_t a, const int n) + /// A32: VRSHRN.I16 Dd+1, Qm, #n + /// A64: RSHRN2 Vd.16B, Vn.8H, #n /// public static Vector128 ShiftRightLogicalRoundedNarrowingUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedNarrowingUpper(lower, value, count); /// - /// int16x8_t vrshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n) - /// A32: VRSHRN.I32 Dd+1, Qm, #n - /// A64: RSHRN2 Vd.8H, Vn.4S, #n + /// int16x8_t vrshrn_high_n_s32 (int16x4_t r, int32x4_t a, const int n) + /// A32: VRSHRN.I32 Dd+1, Qm, #n + /// A64: RSHRN2 Vd.8H, Vn.4S, #n /// public static Vector128 ShiftRightLogicalRoundedNarrowingUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingUpper(lower, value, count); /// - /// int32x4_t vrshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n) - /// A32: VRSHRN.I64 Dd+1, Qm, #n - /// A64: RSHRN2 Vd.4S, Vn.2D, #n + /// int32x4_t vrshrn_high_n_s64 (int32x2_t r, int64x2_t a, const int n) + /// A32: VRSHRN.I64 Dd+1, Qm, #n + /// A64: RSHRN2 Vd.4S, Vn.2D, #n /// public static Vector128 ShiftRightLogicalRoundedNarrowingUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingUpper(lower, value, count); /// - /// int8x16_t vrshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n) - /// A32: VRSHRN.I16 Dd+1, Qm, #n - /// A64: RSHRN2 Vd.16B, Vn.8H, #n + /// int8x16_t vrshrn_high_n_s16 (int8x8_t r, int16x8_t a, const int n) + /// A32: VRSHRN.I16 Dd+1, Qm, #n + /// A64: RSHRN2 Vd.16B, Vn.8H, #n /// public static Vector128 ShiftRightLogicalRoundedNarrowingUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte count) => ShiftRightLogicalRoundedNarrowingUpper(lower, value, count); /// - /// uint16x8_t vrshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n) - /// A32: VRSHRN.I32 Dd+1, Qm, #n - /// A64: RSHRN2 Vd.8H, Vn.4S, #n + /// uint16x8_t vrshrn_high_n_u32 (uint16x4_t r, uint32x4_t a, const int n) + /// A32: VRSHRN.I32 Dd+1, Qm, #n + /// A64: RSHRN2 Vd.8H, Vn.4S, #n /// public static Vector128 ShiftRightLogicalRoundedNarrowingUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte count) => ShiftRightLogicalRoundedNarrowingUpper(lower, value, count); /// - /// uint32x4_t vrshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n) - /// A32: VRSHRN.I64 Dd+1, Qm, #n - /// A64: RSHRN2 Vd.4S, Vn.2D, #n + /// uint32x4_t vrshrn_high_n_u64 (uint32x2_t r, uint64x2_t a, const int n) + /// A32: VRSHRN.I64 Dd+1, Qm, #n + /// A64: RSHRN2 Vd.4S, Vn.2D, #n /// public static Vector128 ShiftRightLogicalRoundedNarrowingUpper(Vector64 lower, Vector128 value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte count) => ShiftRightLogicalRoundedNarrowingUpper(lower, value, count); /// - /// uint64x1_t vrshr_n_u64 (uint64x1_t a, const int n) - /// A32: VRSHR.U64 Dd, Dm, #n - /// A64: URSHR Dd, Dn, #n + /// uint64x1_t vrshr_n_u64 (uint64x1_t a, const int n) + /// A32: VRSHR.U64 Dd, Dm, #n + /// A64: URSHR Dd, Dn, #n /// public static Vector64 ShiftRightLogicalRoundedScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedScalar(value, count); /// - /// uint64x1_t vrshr_n_u64 (uint64x1_t a, const int n) - /// A32: VRSHR.U64 Dd, Dm, #n - /// A64: URSHR Dd, Dn, #n + /// uint64x1_t vrshr_n_u64 (uint64x1_t a, const int n) + /// A32: VRSHR.U64 Dd, Dm, #n + /// A64: URSHR Dd, Dn, #n /// public static Vector64 ShiftRightLogicalRoundedScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalRoundedScalar(value, count); /// - /// uint64x1_t vshr_n_u64 (uint64x1_t a, const int n) - /// A32: VSHR.U64 Dd, Dm, #n - /// A64: USHR Dd, Dn, #n + /// uint64x1_t vshr_n_u64 (uint64x1_t a, const int n) + /// A32: VSHR.U64 Dd, Dm, #n + /// A64: USHR Dd, Dn, #n /// public static Vector64 ShiftRightLogicalScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalScalar(value, count); /// - /// uint64x1_t vshr_n_u64 (uint64x1_t a, const int n) - /// A32: VSHR.U64 Dd, Dm, #n - /// A64: USHR Dd, Dn, #n + /// uint64x1_t vshr_n_u64 (uint64x1_t a, const int n) + /// A32: VSHR.U64 Dd, Dm, #n + /// A64: USHR Dd, Dn, #n /// public static Vector64 ShiftRightLogicalScalar(Vector64 value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte count) => ShiftRightLogicalScalar(value, count); /// - /// int32x4_t vmovl_s16 (int16x4_t a) - /// A32: VMOVL.S16 Qd, Dm - /// A64: SXTL Vd.4S, Vn.4H + /// int32x4_t vmovl_s16 (int16x4_t a) + /// A32: VMOVL.S16 Qd, Dm + /// A64: SXTL Vd.4S, Vn.4H /// public static Vector128 SignExtendWideningLower(Vector64 value) => SignExtendWideningLower(value); /// - /// int64x2_t vmovl_s32 (int32x2_t a) - /// A32: VMOVL.S32 Qd, Dm - /// A64: SXTL Vd.2D, Vn.2S + /// int64x2_t vmovl_s32 (int32x2_t a) + /// A32: VMOVL.S32 Qd, Dm + /// A64: SXTL Vd.2D, Vn.2S /// public static Vector128 SignExtendWideningLower(Vector64 value) => SignExtendWideningLower(value); /// - /// int16x8_t vmovl_s8 (int8x8_t a) - /// A32: VMOVL.S8 Qd, Dm - /// A64: SXTL Vd.8H, Vn.8B + /// int16x8_t vmovl_s8 (int8x8_t a) + /// A32: VMOVL.S8 Qd, Dm + /// A64: SXTL Vd.8H, Vn.8B /// public static Vector128 SignExtendWideningLower(Vector64 value) => SignExtendWideningLower(value); /// - /// int32x4_t vmovl_high_s16 (int16x8_t a) - /// A32: VMOVL.S16 Qd, Dm+1 - /// A64: SXTL2 Vd.4S, Vn.8H + /// int32x4_t vmovl_high_s16 (int16x8_t a) + /// A32: VMOVL.S16 Qd, Dm+1 + /// A64: SXTL2 Vd.4S, Vn.8H /// public static Vector128 SignExtendWideningUpper(Vector128 value) => SignExtendWideningUpper(value); /// - /// int64x2_t vmovl_high_s32 (int32x4_t a) - /// A32: VMOVL.S32 Qd, Dm+1 - /// A64: SXTL2 Vd.2D, Vn.4S + /// int64x2_t vmovl_high_s32 (int32x4_t a) + /// A32: VMOVL.S32 Qd, Dm+1 + /// A64: SXTL2 Vd.2D, Vn.4S /// public static Vector128 SignExtendWideningUpper(Vector128 value) => SignExtendWideningUpper(value); /// - /// int16x8_t vmovl_high_s8 (int8x16_t a) - /// A32: VMOVL.S8 Qd, Dm+1 - /// A64: SXTL2 Vd.8H, Vn.16B + /// int16x8_t vmovl_high_s8 (int8x16_t a) + /// A32: VMOVL.S8 Qd, Dm+1 + /// A64: SXTL2 Vd.8H, Vn.16B /// public static Vector128 SignExtendWideningUpper(Vector128 value) => SignExtendWideningUpper(value); /// - /// float64x1_t vsqrt_f64 (float64x1_t a) - /// A32: VSQRT.F64 Dd, Dm - /// A64: FSQRT Dd, Dn + /// float64x1_t vsqrt_f64 (float64x1_t a) + /// A32: VSQRT.F64 Dd, Dm + /// A64: FSQRT Dd, Dn /// public static Vector64 SqrtScalar(Vector64 value) => SqrtScalar(value); /// - /// float32_t vsqrts_f32 (float32_t a) - /// A32: VSQRT.F32 Sd, Sm - /// A64: FSQRT Sd, Sn - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vsqrts_f32 (float32_t a) + /// A32: VSQRT.F32 Sd, Sm + /// A64: FSQRT Sd, Sn + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 SqrtScalar(Vector64 value) => SqrtScalar(value); /// - /// void vst1_u8 (uint8_t * ptr, uint8x8_t val) - /// A32: VST1.8 { Dd }, [Rn] - /// A64: ST1 { Vt.8B }, [Xn] + /// void vst1_u8 (uint8_t * ptr, uint8x8_t val) + /// A32: VST1.8 { Dd }, [Rn] + /// A64: ST1 { Vt.8B }, [Xn] /// public static unsafe void Store(byte* address, Vector64 source) => Store(address, source); /// - /// void vst1_f64 (float64_t * ptr, float64x1_t val) - /// A32: VST1.64 { Dd }, [Rn] - /// A64: ST1 { Vt.1D }, [Xn] + /// void vst1_f64 (float64_t * ptr, float64x1_t val) + /// A32: VST1.64 { Dd }, [Rn] + /// A64: ST1 { Vt.1D }, [Xn] /// public static unsafe void Store(double* address, Vector64 source) => Store(address, source); /// - /// void vst1_s16 (int16_t * ptr, int16x4_t val) - /// A32: VST1.16 { Dd }, [Rn] - /// A64: ST1 {Vt.4H }, [Xn] + /// void vst1_s16 (int16_t * ptr, int16x4_t val) + /// A32: VST1.16 { Dd }, [Rn] + /// A64: ST1 {Vt.4H }, [Xn] /// public static unsafe void Store(short* address, Vector64 source) => Store(address, source); /// - /// void vst1_s32 (int32_t * ptr, int32x2_t val) - /// A32: VST1.32 { Dd }, [Rn] - /// A64: ST1 { Vt.2S }, [Xn] + /// void vst1_s32 (int32_t * ptr, int32x2_t val) + /// A32: VST1.32 { Dd }, [Rn] + /// A64: ST1 { Vt.2S }, [Xn] /// public static unsafe void Store(int* address, Vector64 source) => Store(address, source); /// - /// void vst1_s64 (int64_t * ptr, int64x1_t val) - /// A32: VST1.64 { Dd }, [Rn] - /// A64: ST1 { Vt.1D }, [Xn] + /// void vst1_s64 (int64_t * ptr, int64x1_t val) + /// A32: VST1.64 { Dd }, [Rn] + /// A64: ST1 { Vt.1D }, [Xn] /// public static unsafe void Store(long* address, Vector64 source) => Store(address, source); /// - /// void vst1_s8 (int8_t * ptr, int8x8_t val) - /// A32: VST1.8 { Dd }, [Rn] - /// A64: ST1 { Vt.8B }, [Xn] + /// void vst1_s8 (int8_t * ptr, int8x8_t val) + /// A32: VST1.8 { Dd }, [Rn] + /// A64: ST1 { Vt.8B }, [Xn] /// public static unsafe void Store(sbyte* address, Vector64 source) => Store(address, source); /// - /// void vst1_f32 (float32_t * ptr, float32x2_t val) - /// A32: VST1.32 { Dd }, [Rn] - /// A64: ST1 { Vt.2S }, [Xn] + /// void vst1_f32 (float32_t * ptr, float32x2_t val) + /// A32: VST1.32 { Dd }, [Rn] + /// A64: ST1 { Vt.2S }, [Xn] /// public static unsafe void Store(float* address, Vector64 source) => Store(address, source); /// - /// void vst1_u16 (uint16_t * ptr, uint16x4_t val) - /// A32: VST1.16 { Dd }, [Rn] - /// A64: ST1 { Vt.4H }, [Xn] + /// void vst1_u16 (uint16_t * ptr, uint16x4_t val) + /// A32: VST1.16 { Dd }, [Rn] + /// A64: ST1 { Vt.4H }, [Xn] /// public static unsafe void Store(ushort* address, Vector64 source) => Store(address, source); /// - /// void vst1_u32 (uint32_t * ptr, uint32x2_t val) - /// A32: VST1.32 { Dd }, [Rn] - /// A64: ST1 { Vt.2S }, [Xn] + /// void vst1_u32 (uint32_t * ptr, uint32x2_t val) + /// A32: VST1.32 { Dd }, [Rn] + /// A64: ST1 { Vt.2S }, [Xn] /// public static unsafe void Store(uint* address, Vector64 source) => Store(address, source); /// - /// void vst1_u64 (uint64_t * ptr, uint64x1_t val) - /// A32: VST1.64 { Dd }, [Rn] - /// A64: ST1 { Vt.1D }, [Xn] + /// void vst1_u64 (uint64_t * ptr, uint64x1_t val) + /// A32: VST1.64 { Dd }, [Rn] + /// A64: ST1 { Vt.1D }, [Xn] /// public static unsafe void Store(ulong* address, Vector64 source) => Store(address, source); /// - /// void vst1q_u8 (uint8_t * ptr, uint8x16_t val) - /// A32: VST1.8 { Dd, Dd+1 }, [Rn] - /// A64: ST1 { Vt.16B }, [Xn] + /// void vst1q_u8 (uint8_t * ptr, uint8x16_t val) + /// A32: VST1.8 { Dd, Dd+1 }, [Rn] + /// A64: ST1 { Vt.16B }, [Xn] /// public static unsafe void Store(byte* address, Vector128 source) => Store(address, source); /// - /// void vst1q_f64 (float64_t * ptr, float64x2_t val) - /// A32: VST1.64 { Dd, Dd+1 }, [Rn] - /// A64: ST1 { Vt.2D }, [Xn] + /// void vst1q_f64 (float64_t * ptr, float64x2_t val) + /// A32: VST1.64 { Dd, Dd+1 }, [Rn] + /// A64: ST1 { Vt.2D }, [Xn] /// public static unsafe void Store(double* address, Vector128 source) => Store(address, source); /// - /// void vst1q_s16 (int16_t * ptr, int16x8_t val) - /// A32: VST1.16 { Dd, Dd+1 }, [Rn] - /// A64: ST1 { Vt.8H }, [Xn] + /// void vst1q_s16 (int16_t * ptr, int16x8_t val) + /// A32: VST1.16 { Dd, Dd+1 }, [Rn] + /// A64: ST1 { Vt.8H }, [Xn] /// public static unsafe void Store(short* address, Vector128 source) => Store(address, source); /// - /// void vst1q_s32 (int32_t * ptr, int32x4_t val) - /// A32: VST1.32 { Dd, Dd+1 }, [Rn] - /// A64: ST1 { Vt.4S }, [Xn] + /// void vst1q_s32 (int32_t * ptr, int32x4_t val) + /// A32: VST1.32 { Dd, Dd+1 }, [Rn] + /// A64: ST1 { Vt.4S }, [Xn] /// public static unsafe void Store(int* address, Vector128 source) => Store(address, source); /// - /// void vst1q_s64 (int64_t * ptr, int64x2_t val) - /// A32: VST1.64 { Dd, Dd+1 }, [Rn] - /// A64: ST1 { Vt.2D }, [Xn] + /// void vst1q_s64 (int64_t * ptr, int64x2_t val) + /// A32: VST1.64 { Dd, Dd+1 }, [Rn] + /// A64: ST1 { Vt.2D }, [Xn] /// public static unsafe void Store(long* address, Vector128 source) => Store(address, source); /// - /// void vst1q_s8 (int8_t * ptr, int8x16_t val) - /// A32: VST1.8 { Dd, Dd+1 }, [Rn] - /// A64: ST1 { Vt.16B }, [Xn] + /// void vst1q_s8 (int8_t * ptr, int8x16_t val) + /// A32: VST1.8 { Dd, Dd+1 }, [Rn] + /// A64: ST1 { Vt.16B }, [Xn] /// public static unsafe void Store(sbyte* address, Vector128 source) => Store(address, source); /// - /// void vst1q_f32 (float32_t * ptr, float32x4_t val) - /// A32: VST1.32 { Dd, Dd+1 }, [Rn] - /// A64: ST1 { Vt.4S }, [Xn] + /// void vst1q_f32 (float32_t * ptr, float32x4_t val) + /// A32: VST1.32 { Dd, Dd+1 }, [Rn] + /// A64: ST1 { Vt.4S }, [Xn] /// public static unsafe void Store(float* address, Vector128 source) => Store(address, source); /// - /// void vst1q_u16 (uint16_t * ptr, uint16x8_t val) - /// A32: VST1.16 { Dd, Dd+1 }, [Rn] - /// A64: ST1 { Vt.8H }, [Xn] + /// void vst1q_u16 (uint16_t * ptr, uint16x8_t val) + /// A32: VST1.16 { Dd, Dd+1 }, [Rn] + /// A64: ST1 { Vt.8H }, [Xn] /// public static unsafe void Store(ushort* address, Vector128 source) => Store(address, source); /// - /// void vst1q_u32 (uint32_t * ptr, uint32x4_t val) - /// A32: VST1.32 { Dd, Dd+1 }, [Rn] - /// A64: ST1 { Vt.4S }, [Xn] + /// void vst1q_u32 (uint32_t * ptr, uint32x4_t val) + /// A32: VST1.32 { Dd, Dd+1 }, [Rn] + /// A64: ST1 { Vt.4S }, [Xn] /// public static unsafe void Store(uint* address, Vector128 source) => Store(address, source); /// - /// void vst1q_u64 (uint64_t * ptr, uint64x2_t val) - /// A32: VST1.64 { Dd, Dd+1 }, [Rn] - /// A64: ST1 { Vt.2D }, [Xn] + /// void vst1q_u64 (uint64_t * ptr, uint64x2_t val) + /// A32: VST1.64 { Dd, Dd+1 }, [Rn] + /// A64: ST1 { Vt.2D }, [Xn] /// public static unsafe void Store(ulong* address, Vector128 source) => Store(address, source); /// - /// void vst1_lane_u8 (uint8_t * ptr, uint8x8_t val, const int lane) - /// A32: VST1.8 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.B }[index], [Xn] + /// void vst1_lane_u8 (uint8_t * ptr, uint8x8_t val, const int lane) + /// A32: VST1.8 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.B }[index], [Xn] /// public static unsafe void StoreSelectedScalar(byte* address, Vector64 value, [ConstantExpected(Max = (byte)(7))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst1_lane_s16 (int16_t * ptr, int16x4_t val, const int lane) - /// A32: VST1.16 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.H }[index], [Xn] + /// void vst1_lane_s16 (int16_t * ptr, int16x4_t val, const int lane) + /// A32: VST1.16 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.H }[index], [Xn] /// public static unsafe void StoreSelectedScalar(short* address, Vector64 value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst1_lane_s32 (int32_t * ptr, int32x2_t val, const int lane) - /// A32: VST1.32 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.S }[index], [Xn] + /// void vst1_lane_s32 (int32_t * ptr, int32x2_t val, const int lane) + /// A32: VST1.32 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(int* address, Vector64 value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst1_lane_s8 (int8_t * ptr, int8x8_t val, const int lane) - /// A32: VST1.8 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.B }[index], [Xn] + /// void vst1_lane_s8 (int8_t * ptr, int8x8_t val, const int lane) + /// A32: VST1.8 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.B }[index], [Xn] /// public static unsafe void StoreSelectedScalar(sbyte* address, Vector64 value, [ConstantExpected(Max = (byte)(7))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst1_lane_f32 (float32_t * ptr, float32x2_t val, const int lane) - /// A32: VST1.32 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.S }[index], [Xn] + /// void vst1_lane_f32 (float32_t * ptr, float32x2_t val, const int lane) + /// A32: VST1.32 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(float* address, Vector64 value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst1_lane_u16 (uint16_t * ptr, uint16x4_t val, const int lane) - /// A32: VST1.16 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.H }[index], [Xn] + /// void vst1_lane_u16 (uint16_t * ptr, uint16x4_t val, const int lane) + /// A32: VST1.16 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.H }[index], [Xn] /// public static unsafe void StoreSelectedScalar(ushort* address, Vector64 value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst1_lane_u32 (uint32_t * ptr, uint32x2_t val, const int lane) - /// A32: VST1.32 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.S }[index], [Xn] + /// void vst1_lane_u32 (uint32_t * ptr, uint32x2_t val, const int lane) + /// A32: VST1.32 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(uint* address, Vector64 value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst1q_lane_u8 (uint8_t * ptr, uint8x16_t val, const int lane) - /// A32: VST1.8 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.B }[index], [Xn] + /// void vst1q_lane_u8 (uint8_t * ptr, uint8x16_t val, const int lane) + /// A32: VST1.8 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.B }[index], [Xn] /// public static unsafe void StoreSelectedScalar(byte* address, Vector128 value, [ConstantExpected(Max = (byte)(15))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst1q_lane_f64 (float64_t * ptr, float64x2_t val, const int lane) - /// A32: VSTR.64 Dd, [Rn] - /// A64: ST1 { Vt.D }[index], [Xn] + /// void vst1q_lane_f64 (float64_t * ptr, float64x2_t val, const int lane) + /// A32: VSTR.64 Dd, [Rn] + /// A64: ST1 { Vt.D }[index], [Xn] /// public static unsafe void StoreSelectedScalar(double* address, Vector128 value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst1q_lane_s16 (int16_t * ptr, int16x8_t val, const int lane) - /// A32: VST1.16 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.H }[index], [Xn] + /// void vst1q_lane_s16 (int16_t * ptr, int16x8_t val, const int lane) + /// A32: VST1.16 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.H }[index], [Xn] /// public static unsafe void StoreSelectedScalar(short* address, Vector128 value, [ConstantExpected(Max = (byte)(7))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst1q_lane_s32 (int32_t * ptr, int32x4_t val, const int lane) - /// A32: VST1.32 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.S }[index], [Xn] + /// void vst1q_lane_s32 (int32_t * ptr, int32x4_t val, const int lane) + /// A32: VST1.32 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(int* address, Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst1q_lane_s64 (int64_t * ptr, int64x2_t val, const int lane) - /// A32: VSTR.64 Dd, [Rn] - /// A64: ST1 { Vt.D }[index], [Xn] + /// void vst1q_lane_s64 (int64_t * ptr, int64x2_t val, const int lane) + /// A32: VSTR.64 Dd, [Rn] + /// A64: ST1 { Vt.D }[index], [Xn] /// public static unsafe void StoreSelectedScalar(long* address, Vector128 value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst1q_lane_s8 (int8_t * ptr, int8x16_t val, const int lane) - /// A32: VST1.8 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.B }[index], [Xn] + /// void vst1q_lane_s8 (int8_t * ptr, int8x16_t val, const int lane) + /// A32: VST1.8 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.B }[index], [Xn] /// public static unsafe void StoreSelectedScalar(sbyte* address, Vector128 value, [ConstantExpected(Max = (byte)(15))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst1q_lane_f32 (float32_t * ptr, float32x4_t val, const int lane) - /// A32: VST1.32 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.S }[index], [Xn] + /// void vst1q_lane_f32 (float32_t * ptr, float32x4_t val, const int lane) + /// A32: VST1.32 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(float* address, Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst1q_lane_u16 (uint16_t * ptr, uint16x8_t val, const int lane) - /// A32: VST1.16 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.H }[index], [Xn] + /// void vst1q_lane_u16 (uint16_t * ptr, uint16x8_t val, const int lane) + /// A32: VST1.16 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.H }[index], [Xn] /// public static unsafe void StoreSelectedScalar(ushort* address, Vector128 value, [ConstantExpected(Max = (byte)(7))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst1q_lane_u32 (uint32_t * ptr, uint32x4_t val, const int lane) - /// A32: VST1.32 { Dd[index] }, [Rn] - /// A64: ST1 { Vt.S }[index], [Xn] + /// void vst1q_lane_u32 (uint32_t * ptr, uint32x4_t val, const int lane) + /// A32: VST1.32 { Dd[index] }, [Rn] + /// A64: ST1 { Vt.S }[index], [Xn] /// public static unsafe void StoreSelectedScalar(uint* address, Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index); /// - /// void vst1q_lane_u64 (uint64_t * ptr, uint64x2_t val, const int lane) - /// A32: VSTR.64 Dd, [Rn] - /// A64: ST1 { Vt.D }[index], [Xn] + /// void vst1q_lane_u64 (uint64_t * ptr, uint64x2_t val, const int lane) + /// A32: VSTR.64 Dd, [Rn] + /// A64: ST1 { Vt.D }[index], [Xn] /// public static unsafe void StoreSelectedScalar(ulong* address, Vector128 value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST2 { Vt.8B, Vt+1.8B }[index], [Xn] - /// + /// A64: ST2 { Vt.8B, Vt+1.8B }[index], [Xn] public static unsafe void StoreSelectedScalar(byte* address, (Vector64 value1, Vector64 value2) value, [ConstantExpected(Max = (byte)(7))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST2 { Vt.8B, Vt+1.8B }[index], [Xn] - /// + /// A64: ST2 { Vt.8B, Vt+1.8B }[index], [Xn] public static unsafe void StoreSelectedScalar(sbyte* address, (Vector64 value1, Vector64 value2) value, [ConstantExpected(Max = (byte)(7))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST2 { Vt.4H, Vt+1.4H }[index], [Xn] - /// + /// A64: ST2 { Vt.4H, Vt+1.4H }[index], [Xn] public static unsafe void StoreSelectedScalar(short* address, (Vector64 value1, Vector64 value2) value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST2 { Vt.4H, Vt+1.4H }[index], [Xn] - /// + /// A64: ST2 { Vt.4H, Vt+1.4H }[index], [Xn] public static unsafe void StoreSelectedScalar(ushort* address, (Vector64 value1, Vector64 value2) value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST2 { Vt.2S, Vt+1.2S }[index], [Xn] - /// + /// A64: ST2 { Vt.2S, Vt+1.2S }[index], [Xn] public static unsafe void StoreSelectedScalar(int* address, (Vector64 value1, Vector64 value2) value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST2 { Vt.2S, Vt+1.2S }[index], [Xn] - /// + /// A64: ST2 { Vt.2S, Vt+1.2S }[index], [Xn] public static unsafe void StoreSelectedScalar(uint* address, (Vector64 value1, Vector64 value2) value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST2 { Vt.2S, Vt+1.2S }[index], [Xn] - /// + /// A64: ST2 { Vt.2S, Vt+1.2S }[index], [Xn] public static unsafe void StoreSelectedScalar(float* address, (Vector64 value1, Vector64 value2) value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST3 { Vt.8B, Vt+1.8B, Vt+2.8B }[index], [Xn] - /// + /// A64: ST3 { Vt.8B, Vt+1.8B, Vt+2.8B }[index], [Xn] public static unsafe void StoreSelectedScalar(byte* address, (Vector64 value1, Vector64 value2, Vector64 value3) value, [ConstantExpected(Max = (byte)(7))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST3 { Vt.8B, Vt+1.8B, Vt+2.8B }[index], [Xn] - /// + /// A64: ST3 { Vt.8B, Vt+1.8B, Vt+2.8B }[index], [Xn] public static unsafe void StoreSelectedScalar(sbyte* address, (Vector64 value1, Vector64 value2, Vector64 value3) value, [ConstantExpected(Max = (byte)(7))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST3 { Vt.4H, Vt+1.4H, Vt+2.4H }[index], [Xn] - /// + /// A64: ST3 { Vt.4H, Vt+1.4H, Vt+2.4H }[index], [Xn] public static unsafe void StoreSelectedScalar(short* address, (Vector64 value1, Vector64 value2, Vector64 value3) value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST3 { Vt.4H, Vt+1.4H, Vt+2.4H }[index], [Xn] - /// + /// A64: ST3 { Vt.4H, Vt+1.4H, Vt+2.4H }[index], [Xn] public static unsafe void StoreSelectedScalar(ushort* address, (Vector64 value1, Vector64 value2, Vector64 value3) value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST3 { Vt.2S, Vt+1.2S, Vt+2.2S }[index], [Xn] - /// + /// A64: ST3 { Vt.2S, Vt+1.2S, Vt+2.2S }[index], [Xn] public static unsafe void StoreSelectedScalar(int* address, (Vector64 value1, Vector64 value2, Vector64 value3) value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST3 { Vt.2S, Vt+1.2S, Vt+2.2S }[index], [Xn] - /// + /// A64: ST3 { Vt.2S, Vt+1.2S, Vt+2.2S }[index], [Xn] public static unsafe void StoreSelectedScalar(uint* address, (Vector64 value1, Vector64 value2, Vector64 value3) value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST2 { Vt.2S, Vt+1.2S, Vt+2.2S }[index], [Xn] - /// + /// A64: ST2 { Vt.2S, Vt+1.2S, Vt+2.2S }[index], [Xn] public static unsafe void StoreSelectedScalar(float* address, (Vector64 value1, Vector64 value2, Vector64 value3) value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST4 { Vt.8B, Vt+1.8B, Vt+2.8B, Vt+3.8B }[index], [Xn] - /// + /// A64: ST4 { Vt.8B, Vt+1.8B, Vt+2.8B, Vt+3.8B }[index], [Xn] public static unsafe void StoreSelectedScalar(byte* address, (Vector64 value1, Vector64 value2, Vector64 value3, Vector64 value4) value, [ConstantExpected(Max = (byte)(7))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST4 { Vt.8B, Vt+1.8B, Vt+2.8B, Vt+3.8B }[index], [Xn] - /// + /// A64: ST4 { Vt.8B, Vt+1.8B, Vt+2.8B, Vt+3.8B }[index], [Xn] public static unsafe void StoreSelectedScalar(sbyte* address, (Vector64 value1, Vector64 value2, Vector64 value3, Vector64 value4) value, [ConstantExpected(Max = (byte)(7))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST4 { Vt.4H, Vt+1.4H, Vt+2.4H, Vt+3.4H }[index], [Xn] - /// + /// A64: ST4 { Vt.4H, Vt+1.4H, Vt+2.4H, Vt+3.4H }[index], [Xn] public static unsafe void StoreSelectedScalar(short* address, (Vector64 value1, Vector64 value2, Vector64 value3, Vector64 value4) value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST4 { Vt.4H, Vt+1.4H, Vt+2.4H, Vt+3.4H }[index], [Xn] - /// + /// A64: ST4 { Vt.4H, Vt+1.4H, Vt+2.4H, Vt+3.4H }[index], [Xn] public static unsafe void StoreSelectedScalar(ushort* address, (Vector64 value1, Vector64 value2, Vector64 value3, Vector64 value4) value, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST4 { Vt.2S, Vt+1.2S, Vt+2.2S, Vt+3.2S }[index], [Xn] - /// + /// A64: ST4 { Vt.2S, Vt+1.2S, Vt+2.2S, Vt+3.2S }[index], [Xn] public static unsafe void StoreSelectedScalar(int* address, (Vector64 value1, Vector64 value2, Vector64 value3, Vector64 value4) value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST4 { Vt.2S, Vt+1.2S, Vt+2.2S, Vt+3.2S }[index], [Xn] - /// + /// A64: ST4 { Vt.2S, Vt+1.2S, Vt+2.2S, Vt+3.2S }[index], [Xn] public static unsafe void StoreSelectedScalar(uint* address, (Vector64 value1, Vector64 value2, Vector64 value3, Vector64 value4) value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST4 { Vt.2S, Vt+1.2S, Vt+2.2S, Vt+3.2S }[index], [Xn] - /// + /// A64: ST4 { Vt.2S, Vt+1.2S, Vt+2.2S, Vt+3.2S }[index], [Xn] public static unsafe void StoreSelectedScalar(float* address, (Vector64 value1, Vector64 value2, Vector64 value3, Vector64 value4) value, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, value, index); - /// - /// A64: ST2 { Vn.8B, Vn+1.8B }, [Xn] - /// + /// A64: ST2 { Vn.8B, Vn+1.8B }, [Xn] public static unsafe void StoreVectorAndZip(byte* address, (Vector64 Value1, Vector64 Value2) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST2 { Vn.8B, Vn+1.8B }, [Xn] - /// + /// A64: ST2 { Vn.8B, Vn+1.8B }, [Xn] public static unsafe void StoreVectorAndZip(sbyte* address, (Vector64 Value1, Vector64 Value2) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST2 { Vn.4H, Vn+1.4H }, [Xn] - /// + /// A64: ST2 { Vn.4H, Vn+1.4H }, [Xn] public static unsafe void StoreVectorAndZip(short* address, (Vector64 Value1, Vector64 Value2) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST2 { Vn.4H, Vn+1.4H }, [Xn] - /// + /// A64: ST2 { Vn.4H, Vn+1.4H }, [Xn] public static unsafe void StoreVectorAndZip(ushort* address, (Vector64 Value1, Vector64 Value2) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST2 { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: ST2 { Vn.2S, Vn+1.2S }, [Xn] public static unsafe void StoreVectorAndZip(int* address, (Vector64 Value1, Vector64 Value2) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST2 { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: ST2 { Vn.2S, Vn+1.2S }, [Xn] public static unsafe void StoreVectorAndZip(uint* address, (Vector64 Value1, Vector64 Value2) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST2 { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: ST2 { Vn.2S, Vn+1.2S }, [Xn] public static unsafe void StoreVectorAndZip(float* address, (Vector64 Value1, Vector64 Value2) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST3 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] - /// + /// A64: ST3 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] public static unsafe void StoreVectorAndZip(byte* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST3 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] - /// + /// A64: ST3 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] public static unsafe void StoreVectorAndZip(sbyte* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST3 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] - /// + /// A64: ST3 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] public static unsafe void StoreVectorAndZip(short* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST3 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] - /// + /// A64: ST3 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] public static unsafe void StoreVectorAndZip(ushort* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: ST3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe void StoreVectorAndZip(int* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: ST3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe void StoreVectorAndZip(uint* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: ST3 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe void StoreVectorAndZip(float* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] - /// + /// A64: ST4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] public static unsafe void StoreVectorAndZip(byte* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] - /// + /// A64: ST4 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] public static unsafe void StoreVectorAndZip(sbyte* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] - /// + /// A64: ST4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] public static unsafe void StoreVectorAndZip(short* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] - /// + /// A64: ST4 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] public static unsafe void StoreVectorAndZip(ushort* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: ST4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe void StoreVectorAndZip(int* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: ST4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe void StoreVectorAndZip(uint* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: ST4 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe void StoreVectorAndZip(float* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) => StoreVectorAndZip(address, value); - /// - /// A64: ST1 { Vn.8B, Vn+1.8B }, [Xn] - /// + /// A64: ST1 { Vn.8B, Vn+1.8B }, [Xn] public static unsafe void Store(byte* address, (Vector64 Value1, Vector64 Value2) value) => Store(address, value); - /// - /// A64: ST1 { Vn.8B, Vn+1.8B }, [Xn] - /// + /// A64: ST1 { Vn.8B, Vn+1.8B }, [Xn] public static unsafe void Store(sbyte* address, (Vector64 Value1, Vector64 Value2) value) => Store(address, value); - /// - /// A64: ST1 { Vn.4H, Vn+1.4H }, [Xn] - /// + /// A64: ST1 { Vn.4H, Vn+1.4H }, [Xn] public static unsafe void Store(short* address, (Vector64 Value1, Vector64 Value2) value) => Store(address, value); - /// - /// A64: ST1 { Vn.4H, Vn+1.4H }, [Xn] - /// + /// A64: ST1 { Vn.4H, Vn+1.4H }, [Xn] public static unsafe void Store(ushort* address, (Vector64 Value1, Vector64 Value2) value) => Store(address, value); - /// - /// A64: ST1 { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: ST1 { Vn.2S, Vn+1.2S }, [Xn] public static unsafe void Store(int* address, (Vector64 Value1, Vector64 Value2) value) => Store(address, value); - /// - /// A64: ST1 { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: ST1 { Vn.2S, Vn+1.2S }, [Xn] public static unsafe void Store(uint* address, (Vector64 Value1, Vector64 Value2) value) => Store(address, value); - /// - /// A64: ST1 { Vn.2S, Vn+1.2S }, [Xn] - /// + /// A64: ST1 { Vn.2S, Vn+1.2S }, [Xn] public static unsafe void Store(float* address, (Vector64 Value1, Vector64 Value2) value) => Store(address, value); - /// - /// A64: ST1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] - /// + /// A64: ST1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] public static unsafe void Store(byte* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) => Store(address, value); - /// - /// A64: ST1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] - /// + /// A64: ST1 { Vn.8B, Vn+1.8B, Vn+2.8B }, [Xn] public static unsafe void Store(sbyte* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) => Store(address, value); - /// - /// A64: ST1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] - /// + /// A64: ST1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] public static unsafe void Store(short* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) => Store(address, value); - /// - /// A64: ST1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] - /// + /// A64: ST1 { Vn.4H, Vn+1.4H, Vn+2.4H }, [Xn] public static unsafe void Store(ushort* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) => Store(address, value); - /// - /// A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe void Store(int* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) => Store(address, value); - /// - /// A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe void Store(uint* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) => Store(address, value); - /// - /// A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] - /// + /// A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S }, [Xn] public static unsafe void Store(float* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3) value) => Store(address, value); - /// - /// A64: ST1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] - /// + /// A64: ST1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] public static unsafe void Store(byte* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) => Store(address, value); - /// - /// A64: ST1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] - /// + /// A64: ST1 { Vn.8B, Vn+1.8B, Vn+2.8B, Vn+3.8B }, [Xn] public static unsafe void Store(sbyte* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) => Store(address, value); - /// - /// A64: ST1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] - /// + /// A64: ST1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] public static unsafe void Store(short* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) => Store(address, value); - /// - /// A64: ST1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] - /// + /// A64: ST1 { Vn.4H, Vn+1.4H, Vn+2.4H, Vn+3.4H }, [Xn] public static unsafe void Store(ushort* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) => Store(address, value); - /// - /// A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe void Store(int* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) => Store(address, value); - /// - /// A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe void Store(uint* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) => Store(address, value); - /// - /// A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] - /// + /// A64: ST1 { Vn.2S, Vn+1.2S, Vn+2.2S, Vn+3.2S }, [Xn] public static unsafe void Store(float* address, (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) value) => Store(address, value); /// - /// uint8x8_t vsub_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VSUB.I8 Dd, Dn, Dm - /// A64: SUB Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vsub_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VSUB.I8 Dd, Dn, Dm + /// A64: SUB Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Subtract(Vector64 left, Vector64 right) => Subtract(left, right); /// - /// int16x4_t vsub_s16 (int16x4_t a, int16x4_t b) - /// A32: VSUB.I16 Dd, Dn, Dm - /// A64: SUB Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vsub_s16 (int16x4_t a, int16x4_t b) + /// A32: VSUB.I16 Dd, Dn, Dm + /// A64: SUB Vd.4H, Vn.4H, Vm.4H /// public static Vector64 Subtract(Vector64 left, Vector64 right) => Subtract(left, right); /// - /// int32x2_t vsub_s32 (int32x2_t a, int32x2_t b) - /// A32: VSUB.I32 Dd, Dn, Dm - /// A64: SUB Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vsub_s32 (int32x2_t a, int32x2_t b) + /// A32: VSUB.I32 Dd, Dn, Dm + /// A64: SUB Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Subtract(Vector64 left, Vector64 right) => Subtract(left, right); /// - /// int8x8_t vsub_s8 (int8x8_t a, int8x8_t b) - /// A32: VSUB.I8 Dd, Dn, Dm - /// A64: SUB Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vsub_s8 (int8x8_t a, int8x8_t b) + /// A32: VSUB.I8 Dd, Dn, Dm + /// A64: SUB Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Subtract(Vector64 left, Vector64 right) => Subtract(left, right); /// - /// float32x2_t vsub_f32 (float32x2_t a, float32x2_t b) - /// A32: VSUB.F32 Dd, Dn, Dm - /// A64: FSUB Vd.2S, Vn.2S, Vm.2S + /// float32x2_t vsub_f32 (float32x2_t a, float32x2_t b) + /// A32: VSUB.F32 Dd, Dn, Dm + /// A64: FSUB Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Subtract(Vector64 left, Vector64 right) => Subtract(left, right); /// - /// uint16x4_t vsub_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VSUB.I16 Dd, Dn, Dm - /// A64: SUB Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vsub_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VSUB.I16 Dd, Dn, Dm + /// A64: SUB Vd.4H, Vn.4H, Vm.4H /// public static Vector64 Subtract(Vector64 left, Vector64 right) => Subtract(left, right); /// - /// uint32x2_t vsub_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VSUB.I32 Dd, Dn, Dm - /// A64: SUB Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vsub_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VSUB.I32 Dd, Dn, Dm + /// A64: SUB Vd.2S, Vn.2S, Vm.2S /// public static Vector64 Subtract(Vector64 left, Vector64 right) => Subtract(left, right); /// - /// uint8x16_t vsubq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VSUB.I8 Qd, Qn, Qm - /// A64: SUB Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vsubq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VSUB.I8 Qd, Qn, Qm + /// A64: SUB Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// - /// int16x8_t vsubq_s16 (int16x8_t a, int16x8_t b) - /// A32: VSUB.I16 Qd, Qn, Qm - /// A64: SUB Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vsubq_s16 (int16x8_t a, int16x8_t b) + /// A32: VSUB.I16 Qd, Qn, Qm + /// A64: SUB Vd.8H, Vn.8H, Vm.8H /// public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// - /// int32x4_t vsubq_s32 (int32x4_t a, int32x4_t b) - /// A32: VSUB.I32 Qd, Qn, Qm - /// A64: SUB Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vsubq_s32 (int32x4_t a, int32x4_t b) + /// A32: VSUB.I32 Qd, Qn, Qm + /// A64: SUB Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// - /// int64x2_t vsubq_s64 (int64x2_t a, int64x2_t b) - /// A32: VSUB.I64 Qd, Qn, Qm - /// A64: SUB Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vsubq_s64 (int64x2_t a, int64x2_t b) + /// A32: VSUB.I64 Qd, Qn, Qm + /// A64: SUB Vd.2D, Vn.2D, Vm.2D /// public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// - /// int8x16_t vsubq_s8 (int8x16_t a, int8x16_t b) - /// A32: VSUB.I8 Qd, Qn, Qm - /// A64: SUB Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vsubq_s8 (int8x16_t a, int8x16_t b) + /// A32: VSUB.I8 Qd, Qn, Qm + /// A64: SUB Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// - /// float32x4_t vsubq_f32 (float32x4_t a, float32x4_t b) - /// A32: VSUB.F32 Qd, Qn, Qm - /// A64: FSUB Vd.4S, Vn.4S, Vm.4S + /// float32x4_t vsubq_f32 (float32x4_t a, float32x4_t b) + /// A32: VSUB.F32 Qd, Qn, Qm + /// A64: FSUB Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// - /// uint16x8_t vsubq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VSUB.I16 Qd, Qn, Qm - /// A64: SUB Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vsubq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VSUB.I16 Qd, Qn, Qm + /// A64: SUB Vd.8H, Vn.8H, Vm.8H /// public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// - /// uint32x4_t vsubq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VSUB.I32 Qd, Qn, Qm - /// A64: SUB Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vsubq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VSUB.I32 Qd, Qn, Qm + /// A64: SUB Vd.4S, Vn.4S, Vm.4S /// public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// - /// uint64x2_t vsubq_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VSUB.I64 Qd, Qn, Qm - /// A64: SUB Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vsubq_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VSUB.I64 Qd, Qn, Qm + /// A64: SUB Vd.2D, Vn.2D, Vm.2D /// public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// - /// uint8x8_t vsubhn_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VSUBHN.I16 Dd, Qn, Qm - /// A64: SUBHN Vd.8B, Vn.8H, Vm.8H + /// uint8x8_t vsubhn_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VSUBHN.I16 Dd, Qn, Qm + /// A64: SUBHN Vd.8B, Vn.8H, Vm.8H /// public static Vector64 SubtractHighNarrowingLower(Vector128 left, Vector128 right) => SubtractHighNarrowingLower(left, right); /// - /// int16x4_t vsubhn_s32 (int32x4_t a, int32x4_t b) - /// A32: VSUBHN.I32 Dd, Qn, Qm - /// A64: SUBHN Vd.4H, Vn.4S, Vm.4S + /// int16x4_t vsubhn_s32 (int32x4_t a, int32x4_t b) + /// A32: VSUBHN.I32 Dd, Qn, Qm + /// A64: SUBHN Vd.4H, Vn.4S, Vm.4S /// public static Vector64 SubtractHighNarrowingLower(Vector128 left, Vector128 right) => SubtractHighNarrowingLower(left, right); /// - /// int32x2_t vsubhn_s64 (int64x2_t a, int64x2_t b) - /// A32: VSUBHN.I64 Dd, Qn, Qm - /// A64: SUBHN Vd.2S, Vn.2D, Vm.2D + /// int32x2_t vsubhn_s64 (int64x2_t a, int64x2_t b) + /// A32: VSUBHN.I64 Dd, Qn, Qm + /// A64: SUBHN Vd.2S, Vn.2D, Vm.2D /// public static Vector64 SubtractHighNarrowingLower(Vector128 left, Vector128 right) => SubtractHighNarrowingLower(left, right); /// - /// int8x8_t vsubhn_s16 (int16x8_t a, int16x8_t b) - /// A32: VSUBHN.I16 Dd, Qn, Qm - /// A64: SUBHN Vd.8B, Vn.8H, Vm.8H + /// int8x8_t vsubhn_s16 (int16x8_t a, int16x8_t b) + /// A32: VSUBHN.I16 Dd, Qn, Qm + /// A64: SUBHN Vd.8B, Vn.8H, Vm.8H /// public static Vector64 SubtractHighNarrowingLower(Vector128 left, Vector128 right) => SubtractHighNarrowingLower(left, right); /// - /// uint16x4_t vsubhn_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VSUBHN.I32 Dd, Qn, Qm - /// A64: SUBHN Vd.4H, Vn.4S, Vm.4S + /// uint16x4_t vsubhn_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VSUBHN.I32 Dd, Qn, Qm + /// A64: SUBHN Vd.4H, Vn.4S, Vm.4S /// public static Vector64 SubtractHighNarrowingLower(Vector128 left, Vector128 right) => SubtractHighNarrowingLower(left, right); /// - /// uint32x2_t vsubhn_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VSUBHN.I64 Dd, Qn, Qm - /// A64: SUBHN Vd.2S, Vn.2D, Vm.2D + /// uint32x2_t vsubhn_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VSUBHN.I64 Dd, Qn, Qm + /// A64: SUBHN Vd.2S, Vn.2D, Vm.2D /// public static Vector64 SubtractHighNarrowingLower(Vector128 left, Vector128 right) => SubtractHighNarrowingLower(left, right); /// - /// uint8x16_t vsubhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b) - /// A32: VSUBHN.I16 Dd+1, Qn, Qm - /// A64: SUBHN2 Vd.16B, Vn.8H, Vm.8H + /// uint8x16_t vsubhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b) + /// A32: VSUBHN.I16 Dd+1, Qn, Qm + /// A64: SUBHN2 Vd.16B, Vn.8H, Vm.8H /// public static Vector128 SubtractHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) => SubtractHighNarrowingUpper(lower, left, right); /// - /// int16x8_t vsubhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b) - /// A32: VSUBHN.I32 Dd+1, Qn, Qm - /// A64: SUBHN2 Vd.8H, Vn.4S, Vm.4S + /// int16x8_t vsubhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b) + /// A32: VSUBHN.I32 Dd+1, Qn, Qm + /// A64: SUBHN2 Vd.8H, Vn.4S, Vm.4S /// public static Vector128 SubtractHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) => SubtractHighNarrowingUpper(lower, left, right); /// - /// int32x4_t vsubhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b) - /// A32: VSUBHN.I64 Dd+1, Qn, Qm - /// A64: SUBHN2 Vd.4S, Vn.2D, Vm.2D + /// int32x4_t vsubhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b) + /// A32: VSUBHN.I64 Dd+1, Qn, Qm + /// A64: SUBHN2 Vd.4S, Vn.2D, Vm.2D /// public static Vector128 SubtractHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) => SubtractHighNarrowingUpper(lower, left, right); /// - /// int8x16_t vsubhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b) - /// A32: VSUBHN.I16 Dd+1, Qn, Qm - /// A64: SUBHN2 Vd.16B, Vn.8H, Vm.8H + /// int8x16_t vsubhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b) + /// A32: VSUBHN.I16 Dd+1, Qn, Qm + /// A64: SUBHN2 Vd.16B, Vn.8H, Vm.8H /// public static Vector128 SubtractHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) => SubtractHighNarrowingUpper(lower, left, right); /// - /// uint16x8_t vsubhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b) - /// A32: VSUBHN.I32 Dd+1, Qn, Qm - /// A64: SUBHN2 Vd.8H, Vn.4S, Vm.4S + /// uint16x8_t vsubhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b) + /// A32: VSUBHN.I32 Dd+1, Qn, Qm + /// A64: SUBHN2 Vd.8H, Vn.4S, Vm.4S /// public static Vector128 SubtractHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) => SubtractHighNarrowingUpper(lower, left, right); /// - /// uint32x4_t vsubhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b) - /// A32: VSUBHN.I64 Dd+1, Qn, Qm - /// A64: SUBHN2 Vd.4S, Vn.2D, Vm.2D + /// uint32x4_t vsubhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b) + /// A32: VSUBHN.I64 Dd+1, Qn, Qm + /// A64: SUBHN2 Vd.4S, Vn.2D, Vm.2D /// public static Vector128 SubtractHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) => SubtractHighNarrowingUpper(lower, left, right); /// - /// uint8x8_t vrsubhn_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VRSUBHN.I16 Dd, Qn, Qm - /// A64: RSUBHN Vd.8B, Vn.8H, Vm.8H + /// uint8x8_t vrsubhn_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VRSUBHN.I16 Dd, Qn, Qm + /// A64: RSUBHN Vd.8B, Vn.8H, Vm.8H /// public static Vector64 SubtractRoundedHighNarrowingLower(Vector128 left, Vector128 right) => SubtractRoundedHighNarrowingLower(left, right); /// - /// int16x4_t vrsubhn_s32 (int32x4_t a, int32x4_t b) - /// A32: VRSUBHN.I32 Dd, Qn, Qm - /// A64: RSUBHN Vd.4H, Vn.4S, Vm.4S + /// int16x4_t vrsubhn_s32 (int32x4_t a, int32x4_t b) + /// A32: VRSUBHN.I32 Dd, Qn, Qm + /// A64: RSUBHN Vd.4H, Vn.4S, Vm.4S /// public static Vector64 SubtractRoundedHighNarrowingLower(Vector128 left, Vector128 right) => SubtractRoundedHighNarrowingLower(left, right); /// - /// int32x2_t vrsubhn_s64 (int64x2_t a, int64x2_t b) - /// A32: VRSUBHN.I64 Dd, Qn, Qm - /// A64: RSUBHN Vd.2S, Vn.2D, Vm.2D + /// int32x2_t vrsubhn_s64 (int64x2_t a, int64x2_t b) + /// A32: VRSUBHN.I64 Dd, Qn, Qm + /// A64: RSUBHN Vd.2S, Vn.2D, Vm.2D /// public static Vector64 SubtractRoundedHighNarrowingLower(Vector128 left, Vector128 right) => SubtractRoundedHighNarrowingLower(left, right); /// - /// int8x8_t vrsubhn_s16 (int16x8_t a, int16x8_t b) - /// A32: VRSUBHN.I16 Dd, Qn, Qm - /// A64: RSUBHN Vd.8B, Vn.8H, Vm.8H + /// int8x8_t vrsubhn_s16 (int16x8_t a, int16x8_t b) + /// A32: VRSUBHN.I16 Dd, Qn, Qm + /// A64: RSUBHN Vd.8B, Vn.8H, Vm.8H /// public static Vector64 SubtractRoundedHighNarrowingLower(Vector128 left, Vector128 right) => SubtractRoundedHighNarrowingLower(left, right); /// - /// uint16x4_t vrsubhn_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VRSUBHN.I32 Dd, Qn, Qm - /// A64: RSUBHN Vd.4H, Vn.4S, Vm.4S + /// uint16x4_t vrsubhn_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VRSUBHN.I32 Dd, Qn, Qm + /// A64: RSUBHN Vd.4H, Vn.4S, Vm.4S /// public static Vector64 SubtractRoundedHighNarrowingLower(Vector128 left, Vector128 right) => SubtractRoundedHighNarrowingLower(left, right); /// - /// uint32x2_t vrsubhn_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VRSUBHN.I64 Dd, Qn, Qm - /// A64: RSUBHN Vd.2S, Vn.2D, Vm.2D + /// uint32x2_t vrsubhn_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VRSUBHN.I64 Dd, Qn, Qm + /// A64: RSUBHN Vd.2S, Vn.2D, Vm.2D /// public static Vector64 SubtractRoundedHighNarrowingLower(Vector128 left, Vector128 right) => SubtractRoundedHighNarrowingLower(left, right); /// - /// uint8x16_t vrsubhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b) - /// A32: VRSUBHN.I16 Dd+1, Qn, Qm - /// A64: RSUBHN2 Vd.16B, Vn.8H, Vm.8H + /// uint8x16_t vrsubhn_high_u16 (uint8x8_t r, uint16x8_t a, uint16x8_t b) + /// A32: VRSUBHN.I16 Dd+1, Qn, Qm + /// A64: RSUBHN2 Vd.16B, Vn.8H, Vm.8H /// public static Vector128 SubtractRoundedHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) => SubtractRoundedHighNarrowingUpper(lower, left, right); /// - /// int16x8_t vrsubhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b) - /// A32: VRSUBHN.I32 Dd+1, Qn, Qm - /// A64: RSUBHN2 Vd.8H, Vn.4S, Vm.4S + /// int16x8_t vrsubhn_high_s32 (int16x4_t r, int32x4_t a, int32x4_t b) + /// A32: VRSUBHN.I32 Dd+1, Qn, Qm + /// A64: RSUBHN2 Vd.8H, Vn.4S, Vm.4S /// public static Vector128 SubtractRoundedHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) => SubtractRoundedHighNarrowingUpper(lower, left, right); /// - /// int32x4_t vrsubhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b) - /// A32: VRSUBHN.I64 Dd+1, Qn, Qm - /// A64: RSUBHN2 Vd.4S, Vn.2D, Vm.2D + /// int32x4_t vrsubhn_high_s64 (int32x2_t r, int64x2_t a, int64x2_t b) + /// A32: VRSUBHN.I64 Dd+1, Qn, Qm + /// A64: RSUBHN2 Vd.4S, Vn.2D, Vm.2D /// public static Vector128 SubtractRoundedHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) => SubtractRoundedHighNarrowingUpper(lower, left, right); /// - /// int8x16_t vrsubhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b) - /// A32: VRSUBHN.I16 Dd+1, Qn, Qm - /// A64: RSUBHN2 Vd.16B, Vn.8H, Vm.8H + /// int8x16_t vrsubhn_high_s16 (int8x8_t r, int16x8_t a, int16x8_t b) + /// A32: VRSUBHN.I16 Dd+1, Qn, Qm + /// A64: RSUBHN2 Vd.16B, Vn.8H, Vm.8H /// public static Vector128 SubtractRoundedHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) => SubtractRoundedHighNarrowingUpper(lower, left, right); /// - /// uint16x8_t vrsubhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b) - /// A32: VRSUBHN.I32 Dd+1, Qn, Qm - /// A64: RSUBHN2 Vd.8H, Vn.4S, Vm.4S + /// uint16x8_t vrsubhn_high_u32 (uint16x4_t r, uint32x4_t a, uint32x4_t b) + /// A32: VRSUBHN.I32 Dd+1, Qn, Qm + /// A64: RSUBHN2 Vd.8H, Vn.4S, Vm.4S /// public static Vector128 SubtractRoundedHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) => SubtractRoundedHighNarrowingUpper(lower, left, right); /// - /// uint32x4_t vrsubhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b) - /// A32: VRSUBHN.I64 Dd+1, Qn, Qm - /// A64: RSUBHN2 Vd.4S, Vn.2D, Vm.2D + /// uint32x4_t vrsubhn_high_u64 (uint32x2_t r, uint64x2_t a, uint64x2_t b) + /// A32: VRSUBHN.I64 Dd+1, Qn, Qm + /// A64: RSUBHN2 Vd.4S, Vn.2D, Vm.2D /// public static Vector128 SubtractRoundedHighNarrowingUpper(Vector64 lower, Vector128 left, Vector128 right) => SubtractRoundedHighNarrowingUpper(lower, left, right); /// - /// uint8x8_t vqsub_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VQSUB.U8 Dd, Dn, Dm - /// A64: UQSUB Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t vqsub_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VQSUB.U8 Dd, Dn, Dm + /// A64: UQSUB Vd.8B, Vn.8B, Vm.8B /// public static Vector64 SubtractSaturate(Vector64 left, Vector64 right) => SubtractSaturate(left, right); /// - /// int16x4_t vqsub_s16 (int16x4_t a, int16x4_t b) - /// A32: VQSUB.S16 Dd, Dn, Dm - /// A64: SQSUB Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vqsub_s16 (int16x4_t a, int16x4_t b) + /// A32: VQSUB.S16 Dd, Dn, Dm + /// A64: SQSUB Vd.4H, Vn.4H, Vm.4H /// public static Vector64 SubtractSaturate(Vector64 left, Vector64 right) => SubtractSaturate(left, right); /// - /// int32x2_t vqsub_s32 (int32x2_t a, int32x2_t b) - /// A32: VQSUB.S32 Dd, Dn, Dm - /// A64: SQSUB Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vqsub_s32 (int32x2_t a, int32x2_t b) + /// A32: VQSUB.S32 Dd, Dn, Dm + /// A64: SQSUB Vd.2S, Vn.2S, Vm.2S /// public static Vector64 SubtractSaturate(Vector64 left, Vector64 right) => SubtractSaturate(left, right); /// - /// int8x8_t vqsub_s8 (int8x8_t a, int8x8_t b) - /// A32: VQSUB.S8 Dd, Dn, Dm - /// A64: SQSUB Vd.8B, Vn.8B, Vm.8B + /// int8x8_t vqsub_s8 (int8x8_t a, int8x8_t b) + /// A32: VQSUB.S8 Dd, Dn, Dm + /// A64: SQSUB Vd.8B, Vn.8B, Vm.8B /// public static Vector64 SubtractSaturate(Vector64 left, Vector64 right) => SubtractSaturate(left, right); /// - /// uint16x4_t vqsub_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VQSUB.U16 Dd, Dn, Dm - /// A64: UQSUB Vd.4H, Vn.4H, Vm.4H + /// uint16x4_t vqsub_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VQSUB.U16 Dd, Dn, Dm + /// A64: UQSUB Vd.4H, Vn.4H, Vm.4H /// public static Vector64 SubtractSaturate(Vector64 left, Vector64 right) => SubtractSaturate(left, right); /// - /// uint32x2_t vqsub_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VQSUB.U32 Dd, Dn, Dm - /// A64: UQSUB Vd.2S, Vn.2S, Vm.2S + /// uint32x2_t vqsub_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VQSUB.U32 Dd, Dn, Dm + /// A64: UQSUB Vd.2S, Vn.2S, Vm.2S /// public static Vector64 SubtractSaturate(Vector64 left, Vector64 right) => SubtractSaturate(left, right); /// - /// uint8x16_t vqsubq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VQSUB.U8 Qd, Qn, Qm - /// A64: UQSUB Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t vqsubq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VQSUB.U8 Qd, Qn, Qm + /// A64: UQSUB Vd.16B, Vn.16B, Vm.16B /// public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) => SubtractSaturate(left, right); /// - /// int16x8_t vqsubq_s16 (int16x8_t a, int16x8_t b) - /// A32: VQSUB.S16 Qd, Qn, Qm - /// A64: SQSUB Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vqsubq_s16 (int16x8_t a, int16x8_t b) + /// A32: VQSUB.S16 Qd, Qn, Qm + /// A64: SQSUB Vd.8H, Vn.8H, Vm.8H /// public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) => SubtractSaturate(left, right); /// - /// int32x4_t vqsubq_s32 (int32x4_t a, int32x4_t b) - /// A32: VQSUB.S32 Qd, Qn, Qm - /// A64: SQSUB Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vqsubq_s32 (int32x4_t a, int32x4_t b) + /// A32: VQSUB.S32 Qd, Qn, Qm + /// A64: SQSUB Vd.4S, Vn.4S, Vm.4S /// public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) => SubtractSaturate(left, right); /// - /// int64x2_t vqsubq_s64 (int64x2_t a, int64x2_t b) - /// A32: VQSUB.S64 Qd, Qn, Qm - /// A64: SQSUB Vd.2D, Vn.2D, Vm.2D + /// int64x2_t vqsubq_s64 (int64x2_t a, int64x2_t b) + /// A32: VQSUB.S64 Qd, Qn, Qm + /// A64: SQSUB Vd.2D, Vn.2D, Vm.2D /// public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) => SubtractSaturate(left, right); /// - /// int8x16_t vqsubq_s8 (int8x16_t a, int8x16_t b) - /// A32: VQSUB.S8 Qd, Qn, Qm - /// A64: SQSUB Vd.16B, Vn.16B, Vm.16B + /// int8x16_t vqsubq_s8 (int8x16_t a, int8x16_t b) + /// A32: VQSUB.S8 Qd, Qn, Qm + /// A64: SQSUB Vd.16B, Vn.16B, Vm.16B /// public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) => SubtractSaturate(left, right); /// - /// uint16x8_t vqsubq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VQSUB.U16 Qd, Qn, Qm - /// A64: UQSUB Vd.8H, Vn.8H, Vm.8H + /// uint16x8_t vqsubq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VQSUB.U16 Qd, Qn, Qm + /// A64: UQSUB Vd.8H, Vn.8H, Vm.8H /// public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) => SubtractSaturate(left, right); /// - /// uint32x4_t vqsubq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VQSUB.U32 Qd, Qn, Qm - /// A64: UQSUB Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vqsubq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VQSUB.U32 Qd, Qn, Qm + /// A64: UQSUB Vd.4S, Vn.4S, Vm.4S /// public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) => SubtractSaturate(left, right); /// - /// uint64x2_t vqsubq_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VQSUB.U64 Qd, Qn, Qm - /// A64: UQSUB Vd.2D, Vn.2D, Vm.2D + /// uint64x2_t vqsubq_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VQSUB.U64 Qd, Qn, Qm + /// A64: UQSUB Vd.2D, Vn.2D, Vm.2D /// public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) => SubtractSaturate(left, right); /// - /// int64x1_t vqsub_s64 (int64x1_t a, int64x1_t b) - /// A32: VQSUB.S64 Dd, Dn, Dm - /// A64: SQSUB Dd, Dn, Dm + /// int64x1_t vqsub_s64 (int64x1_t a, int64x1_t b) + /// A32: VQSUB.S64 Dd, Dn, Dm + /// A64: SQSUB Dd, Dn, Dm /// public static Vector64 SubtractSaturateScalar(Vector64 left, Vector64 right) => SubtractSaturateScalar(left, right); /// - /// uint64x1_t vqsub_u64 (uint64x1_t a, uint64x1_t b) - /// A32: VQSUB.U64 Dd, Dn, Dm - /// A64: UQSUB Dd, Dn, Dm + /// uint64x1_t vqsub_u64 (uint64x1_t a, uint64x1_t b) + /// A32: VQSUB.U64 Dd, Dn, Dm + /// A64: UQSUB Dd, Dn, Dm /// public static Vector64 SubtractSaturateScalar(Vector64 left, Vector64 right) => SubtractSaturateScalar(left, right); /// - /// float64x1_t vsub_f64 (float64x1_t a, float64x1_t b) - /// A32: VSUB.F64 Dd, Dn, Dm - /// A64: FSUB Dd, Dn, Dm + /// float64x1_t vsub_f64 (float64x1_t a, float64x1_t b) + /// A32: VSUB.F64 Dd, Dn, Dm + /// A64: FSUB Dd, Dn, Dm /// public static Vector64 SubtractScalar(Vector64 left, Vector64 right) => SubtractScalar(left, right); /// - /// int64x1_t vsub_s64 (int64x1_t a, int64x1_t b) - /// A32: VSUB.I64 Dd, Dn, Dm - /// A64: SUB Dd, Dn, Dm + /// int64x1_t vsub_s64 (int64x1_t a, int64x1_t b) + /// A32: VSUB.I64 Dd, Dn, Dm + /// A64: SUB Dd, Dn, Dm /// public static Vector64 SubtractScalar(Vector64 left, Vector64 right) => SubtractScalar(left, right); /// - /// float32_t vsubs_f32 (float32_t a, float32_t b) - /// A32: VSUB.F32 Sd, Sn, Sm - /// A64: FSUB Sd, Sn, Sm - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32_t vsubs_f32 (float32_t a, float32_t b) + /// A32: VSUB.F32 Sd, Sn, Sm + /// A64: FSUB Sd, Sn, Sm + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 SubtractScalar(Vector64 left, Vector64 right) => SubtractScalar(left, right); /// - /// uint64x1_t vsub_u64 (uint64x1_t a, uint64x1_t b) - /// A32: VSUB.I64 Dd, Dn, Dm - /// A64: SUB Dd, Dn, Dm + /// uint64x1_t vsub_u64 (uint64x1_t a, uint64x1_t b) + /// A32: VSUB.I64 Dd, Dn, Dm + /// A64: SUB Dd, Dn, Dm /// public static Vector64 SubtractScalar(Vector64 left, Vector64 right) => SubtractScalar(left, right); /// - /// uint16x8_t vsubl_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VSUBL.U8 Qd, Dn, Dm - /// A64: USUBL Vd.8H, Vn.8B, Vm.8B + /// uint16x8_t vsubl_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VSUBL.U8 Qd, Dn, Dm + /// A64: USUBL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 SubtractWideningLower(Vector64 left, Vector64 right) => SubtractWideningLower(left, right); /// - /// int32x4_t vsubl_s16 (int16x4_t a, int16x4_t b) - /// A32: VSUBL.S16 Qd, Dn, Dm - /// A64: SSUBL Vd.4S, Vn.4H, Vm.4H + /// int32x4_t vsubl_s16 (int16x4_t a, int16x4_t b) + /// A32: VSUBL.S16 Qd, Dn, Dm + /// A64: SSUBL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 SubtractWideningLower(Vector64 left, Vector64 right) => SubtractWideningLower(left, right); /// - /// int64x2_t vsubl_s32 (int32x2_t a, int32x2_t b) - /// A32: VSUBL.S32 Qd, Dn, Dm - /// A64: SSUBL Vd.2D, Vn.2S, Vm.2S + /// int64x2_t vsubl_s32 (int32x2_t a, int32x2_t b) + /// A32: VSUBL.S32 Qd, Dn, Dm + /// A64: SSUBL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 SubtractWideningLower(Vector64 left, Vector64 right) => SubtractWideningLower(left, right); /// - /// int16x8_t vsubl_s8 (int8x8_t a, int8x8_t b) - /// A32: VSUBL.S8 Qd, Dn, Dm - /// A64: SSUBL Vd.8H, Vn.8B, Vm.8B + /// int16x8_t vsubl_s8 (int8x8_t a, int8x8_t b) + /// A32: VSUBL.S8 Qd, Dn, Dm + /// A64: SSUBL Vd.8H, Vn.8B, Vm.8B /// public static Vector128 SubtractWideningLower(Vector64 left, Vector64 right) => SubtractWideningLower(left, right); /// - /// uint32x4_t vsubl_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VSUBL.U16 Qd, Dn, Dm - /// A64: USUBL Vd.4S, Vn.4H, Vm.4H + /// uint32x4_t vsubl_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VSUBL.U16 Qd, Dn, Dm + /// A64: USUBL Vd.4S, Vn.4H, Vm.4H /// public static Vector128 SubtractWideningLower(Vector64 left, Vector64 right) => SubtractWideningLower(left, right); /// - /// uint64x2_t vsubl_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VSUBL.U32 Qd, Dn, Dm - /// A64: USUBL Vd.2D, Vn.2S, Vm.2S + /// uint64x2_t vsubl_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VSUBL.U32 Qd, Dn, Dm + /// A64: USUBL Vd.2D, Vn.2S, Vm.2S /// public static Vector128 SubtractWideningLower(Vector64 left, Vector64 right) => SubtractWideningLower(left, right); /// - /// int16x8_t vsubw_s8 (int16x8_t a, int8x8_t b) - /// A32: VSUBW.S8 Qd, Qn, Dm - /// A64: SSUBW Vd.8H, Vn.8H, Vm.8B + /// int16x8_t vsubw_s8 (int16x8_t a, int8x8_t b) + /// A32: VSUBW.S8 Qd, Qn, Dm + /// A64: SSUBW Vd.8H, Vn.8H, Vm.8B /// public static Vector128 SubtractWideningLower(Vector128 left, Vector64 right) => SubtractWideningLower(left, right); /// - /// int32x4_t vsubw_s16 (int32x4_t a, int16x4_t b) - /// A32: VSUBW.S16 Qd, Qn, Dm - /// A64: SSUBW Vd.4S, Vn.4S, Vm.4H + /// int32x4_t vsubw_s16 (int32x4_t a, int16x4_t b) + /// A32: VSUBW.S16 Qd, Qn, Dm + /// A64: SSUBW Vd.4S, Vn.4S, Vm.4H /// public static Vector128 SubtractWideningLower(Vector128 left, Vector64 right) => SubtractWideningLower(left, right); /// - /// int64x2_t vsubw_s32 (int64x2_t a, int32x2_t b) - /// A32: VSUBW.S32 Qd, Qn, Dm - /// A64: SSUBW Vd.2D, Vn.2D, Vm.2S + /// int64x2_t vsubw_s32 (int64x2_t a, int32x2_t b) + /// A32: VSUBW.S32 Qd, Qn, Dm + /// A64: SSUBW Vd.2D, Vn.2D, Vm.2S /// public static Vector128 SubtractWideningLower(Vector128 left, Vector64 right) => SubtractWideningLower(left, right); /// - /// uint16x8_t vsubw_u8 (uint16x8_t a, uint8x8_t b) - /// A32: VSUBW.U8 Qd, Qn, Dm - /// A64: USUBW Vd.8H, Vn.8H, Vm.8B + /// uint16x8_t vsubw_u8 (uint16x8_t a, uint8x8_t b) + /// A32: VSUBW.U8 Qd, Qn, Dm + /// A64: USUBW Vd.8H, Vn.8H, Vm.8B /// public static Vector128 SubtractWideningLower(Vector128 left, Vector64 right) => SubtractWideningLower(left, right); /// - /// uint32x4_t vsubw_u16 (uint32x4_t a, uint16x4_t b) - /// A32: VSUBW.U16 Qd, Qn, Dm - /// A64: USUBW Vd.4S, Vn.4S, Vm.4H + /// uint32x4_t vsubw_u16 (uint32x4_t a, uint16x4_t b) + /// A32: VSUBW.U16 Qd, Qn, Dm + /// A64: USUBW Vd.4S, Vn.4S, Vm.4H /// public static Vector128 SubtractWideningLower(Vector128 left, Vector64 right) => SubtractWideningLower(left, right); /// - /// uint64x2_t vsubw_u32 (uint64x2_t a, uint32x2_t b) - /// A32: VSUBW.U32 Qd, Qn, Dm - /// A64: USUBW Vd.2D, Vn.2D, Vm.2S + /// uint64x2_t vsubw_u32 (uint64x2_t a, uint32x2_t b) + /// A32: VSUBW.U32 Qd, Qn, Dm + /// A64: USUBW Vd.2D, Vn.2D, Vm.2S /// public static Vector128 SubtractWideningLower(Vector128 left, Vector64 right) => SubtractWideningLower(left, right); /// - /// uint16x8_t vsubl_high_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VSUBL.U8 Qd, Dn+1, Dm+1 - /// A64: USUBL2 Vd.8H, Vn.16B, Vm.16B + /// uint16x8_t vsubl_high_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VSUBL.U8 Qd, Dn+1, Dm+1 + /// A64: USUBL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 SubtractWideningUpper(Vector128 left, Vector128 right) => SubtractWideningUpper(left, right); /// - /// int32x4_t vsubl_high_s16 (int16x8_t a, int16x8_t b) - /// A32: VSUBL.S16 Qd, Dn+1, Dm+1 - /// A64: SSUBL2 Vd.4S, Vn.8H, Vm.8H + /// int32x4_t vsubl_high_s16 (int16x8_t a, int16x8_t b) + /// A32: VSUBL.S16 Qd, Dn+1, Dm+1 + /// A64: SSUBL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 SubtractWideningUpper(Vector128 left, Vector128 right) => SubtractWideningUpper(left, right); /// - /// int16x8_t vsubw_high_s8 (int16x8_t a, int8x16_t b) - /// A32: VSUBW.S8 Qd, Qn, Dm+1 - /// A64: SSUBW2 Vd.8H, Vn.8H, Vm.16B + /// int16x8_t vsubw_high_s8 (int16x8_t a, int8x16_t b) + /// A32: VSUBW.S8 Qd, Qn, Dm+1 + /// A64: SSUBW2 Vd.8H, Vn.8H, Vm.16B /// public static Vector128 SubtractWideningUpper(Vector128 left, Vector128 right) => SubtractWideningUpper(left, right); /// - /// int32x4_t vsubw_high_s16 (int32x4_t a, int16x8_t b) - /// A32: VSUBW.S16 Qd, Qn, Dm+1 - /// A64: SSUBW2 Vd.4S, Vn.4S, Vm.8H + /// int32x4_t vsubw_high_s16 (int32x4_t a, int16x8_t b) + /// A32: VSUBW.S16 Qd, Qn, Dm+1 + /// A64: SSUBW2 Vd.4S, Vn.4S, Vm.8H /// public static Vector128 SubtractWideningUpper(Vector128 left, Vector128 right) => SubtractWideningUpper(left, right); /// - /// int64x2_t vsubl_high_s32 (int32x4_t a, int32x4_t b) - /// A32: VSUBL.S32 Qd, Dn+1, Dm+1 - /// A64: SSUBL2 Vd.2D, Vn.4S, Vm.4S + /// int64x2_t vsubl_high_s32 (int32x4_t a, int32x4_t b) + /// A32: VSUBL.S32 Qd, Dn+1, Dm+1 + /// A64: SSUBL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 SubtractWideningUpper(Vector128 left, Vector128 right) => SubtractWideningUpper(left, right); /// - /// int64x2_t vsubw_high_s32 (int64x2_t a, int32x4_t b) - /// A32: VSUBW.S32 Qd, Qn, Dm+1 - /// A64: SSUBW2 Vd.2D, Vn.2D, Vm.4S + /// int64x2_t vsubw_high_s32 (int64x2_t a, int32x4_t b) + /// A32: VSUBW.S32 Qd, Qn, Dm+1 + /// A64: SSUBW2 Vd.2D, Vn.2D, Vm.4S /// public static Vector128 SubtractWideningUpper(Vector128 left, Vector128 right) => SubtractWideningUpper(left, right); /// - /// int16x8_t vsubl_high_s8 (int8x16_t a, int8x16_t b) - /// A32: VSUBL.S8 Qd, Dn+1, Dm+1 - /// A64: SSUBL2 Vd.8H, Vn.16B, Vm.16B + /// int16x8_t vsubl_high_s8 (int8x16_t a, int8x16_t b) + /// A32: VSUBL.S8 Qd, Dn+1, Dm+1 + /// A64: SSUBL2 Vd.8H, Vn.16B, Vm.16B /// public static Vector128 SubtractWideningUpper(Vector128 left, Vector128 right) => SubtractWideningUpper(left, right); /// - /// uint16x8_t vsubw_high_u8 (uint16x8_t a, uint8x16_t b) - /// A32: VSUBW.U8 Qd, Qn, Dm+1 - /// A64: USUBW2 Vd.8H, Vn.8H, Vm.16B + /// uint16x8_t vsubw_high_u8 (uint16x8_t a, uint8x16_t b) + /// A32: VSUBW.U8 Qd, Qn, Dm+1 + /// A64: USUBW2 Vd.8H, Vn.8H, Vm.16B /// public static Vector128 SubtractWideningUpper(Vector128 left, Vector128 right) => SubtractWideningUpper(left, right); /// - /// uint32x4_t vsubl_high_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VSUBL.U16 Qd, Dn+1, Dm+1 - /// A64: USUBL2 Vd.4S, Vn.8H, Vm.8H + /// uint32x4_t vsubl_high_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VSUBL.U16 Qd, Dn+1, Dm+1 + /// A64: USUBL2 Vd.4S, Vn.8H, Vm.8H /// public static Vector128 SubtractWideningUpper(Vector128 left, Vector128 right) => SubtractWideningUpper(left, right); /// - /// uint32x4_t vsubw_high_u16 (uint32x4_t a, uint16x8_t b) - /// A32: VSUBW.U16 Qd, Qn, Dm+1 - /// A64: USUBW2 Vd.4S, Vn.4S, Vm.8H + /// uint32x4_t vsubw_high_u16 (uint32x4_t a, uint16x8_t b) + /// A32: VSUBW.U16 Qd, Qn, Dm+1 + /// A64: USUBW2 Vd.4S, Vn.4S, Vm.8H /// public static Vector128 SubtractWideningUpper(Vector128 left, Vector128 right) => SubtractWideningUpper(left, right); /// - /// uint64x2_t vsubl_high_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VSUBL.U32 Qd, Dn+1, Dm+1 - /// A64: USUBL2 Vd.2D, Vn.4S, Vm.4S + /// uint64x2_t vsubl_high_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VSUBL.U32 Qd, Dn+1, Dm+1 + /// A64: USUBL2 Vd.2D, Vn.4S, Vm.4S /// public static Vector128 SubtractWideningUpper(Vector128 left, Vector128 right) => SubtractWideningUpper(left, right); /// - /// uint64x2_t vsubw_high_u32 (uint64x2_t a, uint32x4_t b) - /// A32: VSUBW.U32 Qd, Qn, Dm+1 - /// A64: USUBW2 Vd.2D, Vn.2D, Vm.4S + /// uint64x2_t vsubw_high_u32 (uint64x2_t a, uint32x4_t b) + /// A32: VSUBW.U32 Qd, Qn, Dm+1 + /// A64: USUBW2 Vd.2D, Vn.2D, Vm.4S /// public static Vector128 SubtractWideningUpper(Vector128 left, Vector128 right) => SubtractWideningUpper(left, right); /// - /// uint8x8_t vqvtbl1_u8(uint8x16_t t, uint8x8_t idx) - /// A32: VTBL Dd, {Dn, Dn+1}, Dm - /// A64: TBL Vd.8B, {Vn.16B}, Vm.8B + /// uint8x8_t vqvtbl1_u8(uint8x16_t t, uint8x8_t idx) + /// A32: VTBL Dd, {Dn, Dn+1}, Dm + /// A64: TBL Vd.8B, {Vn.16B}, Vm.8B /// public static Vector64 VectorTableLookup(Vector128 table, Vector64 byteIndexes) => VectorTableLookup(table, byteIndexes); /// - /// int8x8_t vqvtbl1_s8(int8x16_t t, uint8x8_t idx) - /// A32: VTBL Dd, {Dn, Dn+1}, Dm - /// A64: TBL Vd.8B, {Vn.16B}, Vm.8B + /// int8x8_t vqvtbl1_s8(int8x16_t t, uint8x8_t idx) + /// A32: VTBL Dd, {Dn, Dn+1}, Dm + /// A64: TBL Vd.8B, {Vn.16B}, Vm.8B /// public static Vector64 VectorTableLookup(Vector128 table, Vector64 byteIndexes) => VectorTableLookup(table, byteIndexes); /// - /// uint8x8_t vqtbl2q_u8(uint8x16x2_t t, uint8x8_t idx) - /// A64: TBL Vd.8B, {Vn.16B, Vn+1.16B}, Vm.8B + /// uint8x8_t vqtbl2q_u8(uint8x16x2_t t, uint8x8_t idx) + /// A64: TBL Vd.8B, {Vn.16B, Vn+1.16B}, Vm.8B /// public static Vector64 VectorTableLookup((Vector128, Vector128) table, Vector64 byteIndexes) => VectorTableLookup(table, byteIndexes); /// - /// int8x8_t vqtbl2q_u8(int8x16x2_t t, uint8x8_t idx) - /// A64: TBL Vd.8B, {Vn.16B, Vn+1.16B}, Vm.8B + /// int8x8_t vqtbl2q_u8(int8x16x2_t t, uint8x8_t idx) + /// A64: TBL Vd.8B, {Vn.16B, Vn+1.16B}, Vm.8B /// public static Vector64 VectorTableLookup((Vector128, Vector128) table, Vector64 byteIndexes) => VectorTableLookup(table, byteIndexes); /// - /// uint8x8_t vqtbl3q_u8(uint8x16x3_t t, uint8x8_t idx) - /// A64: TBL Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.8B + /// uint8x8_t vqtbl3q_u8(uint8x16x3_t t, uint8x8_t idx) + /// A64: TBL Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.8B /// public static Vector64 VectorTableLookup((Vector128, Vector128, Vector128) table, Vector64 byteIndexes) => VectorTableLookup(table, byteIndexes); /// - /// int8x8_t vqtbl3q_u8(int8x16x3_t t, uint8x8_t idx) - /// A64: TBL Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.8B + /// int8x8_t vqtbl3q_u8(int8x16x3_t t, uint8x8_t idx) + /// A64: TBL Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.8B /// public static Vector64 VectorTableLookup((Vector128, Vector128, Vector128) table, Vector64 byteIndexes) => VectorTableLookup(table, byteIndexes); /// - /// uint8x8_t vqtbl4q_u8(uint8x16x4_t t, uint8x8_t idx) - /// A64: TBL Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.8B + /// uint8x8_t vqtbl4q_u8(uint8x16x4_t t, uint8x8_t idx) + /// A64: TBL Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.8B /// public static Vector64 VectorTableLookup((Vector128, Vector128, Vector128, Vector128) table, Vector64 byteIndexes) => VectorTableLookup(table, byteIndexes); /// - /// int8x8_t vqtbl4q_u8(int8x16x4_t t, uint8x8_t idx) - /// A64: TBL Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.8B + /// int8x8_t vqtbl4q_u8(int8x16x4_t t, uint8x8_t idx) + /// A64: TBL Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.8B /// public static Vector64 VectorTableLookup((Vector128, Vector128, Vector128, Vector128) table, Vector64 byteIndexes) => VectorTableLookup(table, byteIndexes); /// - /// uint8x8_t vqvtbx1_u8(uint8x8_t r, uint8x16_t t, uint8x8_t idx) - /// A32: VTBX Dd, {Dn, Dn+1}, Dm - /// A64: TBX Vd.8B, {Vn.16B}, Vm.8B + /// uint8x8_t vqvtbx1_u8(uint8x8_t r, uint8x16_t t, uint8x8_t idx) + /// A32: VTBX Dd, {Dn, Dn+1}, Dm + /// A64: TBX Vd.8B, {Vn.16B}, Vm.8B /// public static Vector64 VectorTableLookupExtension(Vector64 defaultValues, Vector128 table, Vector64 byteIndexes) => VectorTableLookupExtension(defaultValues, table, byteIndexes); /// - /// int8x8_t vqvtbx1_s8(int8x8_t r, int8x16_t t, uint8x8_t idx) - /// A32: VTBX Dd, {Dn, Dn+1}, Dm - /// A64: TBX Vd.8B, {Vn.16B}, Vm.8B + /// int8x8_t vqvtbx1_s8(int8x8_t r, int8x16_t t, uint8x8_t idx) + /// A32: VTBX Dd, {Dn, Dn+1}, Dm + /// A64: TBX Vd.8B, {Vn.16B}, Vm.8B /// public static Vector64 VectorTableLookupExtension(Vector64 defaultValues, Vector128 table, Vector64 byteIndexes) => VectorTableLookupExtension(defaultValues, table, byteIndexes); /// - /// uint8x8_t vqtbx2q_u8(uint8x16x2_t t, uint8x8_t idx) - /// A64: TBX Vd.8B, {Vn.16B, Vn+1.16B}, Vm.8B + /// uint8x8_t vqtbx2q_u8(uint8x16x2_t t, uint8x8_t idx) + /// A64: TBX Vd.8B, {Vn.16B, Vn+1.16B}, Vm.8B /// public static Vector64 VectorTableLookupExtension(Vector64 defaultValues, (Vector128, Vector128) table, Vector64 byteIndexes) => VectorTableLookupExtension(defaultValues, table, byteIndexes); /// - /// int8x8_t vqtbx2q_u8(int8x16x2_t t, uint8x8_t idx) - /// A64: TBX Vd.8B, {Vn.16B, Vn+1.16B}, Vm.8B + /// int8x8_t vqtbx2q_u8(int8x16x2_t t, uint8x8_t idx) + /// A64: TBX Vd.8B, {Vn.16B, Vn+1.16B}, Vm.8B /// public static Vector64 VectorTableLookupExtension(Vector64 defaultValues, (Vector128, Vector128) table, Vector64 byteIndexes) => VectorTableLookupExtension(defaultValues, table, byteIndexes); /// - /// uint8x8_t vqtbx3q_u8(uint8x16x3_t t, uint8x8_t idx) - /// A64: TBX Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.8B + /// uint8x8_t vqtbx3q_u8(uint8x16x3_t t, uint8x8_t idx) + /// A64: TBX Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.8B /// public static Vector64 VectorTableLookupExtension(Vector64 defaultValues, (Vector128, Vector128, Vector128) table, Vector64 byteIndexes) => VectorTableLookupExtension(defaultValues, table, byteIndexes); /// - /// int8x8_t vqtbx3q_u8(int8x16x3_t t, uint8x8_t idx) - /// A64: TBX Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.8B + /// int8x8_t vqtbx3q_u8(int8x16x3_t t, uint8x8_t idx) + /// A64: TBX Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B}, Vm.8B /// public static Vector64 VectorTableLookupExtension(Vector64 defaultValues, (Vector128, Vector128, Vector128) table, Vector64 byteIndexes) => VectorTableLookupExtension(defaultValues, table, byteIndexes); /// - /// uint8x8_t vqtbx4q_u8(uint8x16x4_t t, uint8x8_t idx) - /// A64: TBX Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.8B + /// uint8x8_t vqtbx4q_u8(uint8x16x4_t t, uint8x8_t idx) + /// A64: TBX Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.8B /// public static Vector64 VectorTableLookupExtension(Vector64 defaultValues, (Vector128, Vector128, Vector128, Vector128) table, Vector64 byteIndexes) => VectorTableLookupExtension(defaultValues, table, byteIndexes); /// - /// int8x8_t vqtbx4q_u8(int8x16x4_t t, uint8x8_t idx) - /// A64: TBX Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.8B + /// int8x8_t vqtbx4q_u8(int8x16x4_t t, uint8x8_t idx) + /// A64: TBX Vd.8B, {Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B}, Vm.8B /// public static Vector64 VectorTableLookupExtension(Vector64 defaultValues, (Vector128, Vector128, Vector128, Vector128) table, Vector64 byteIndexes) => VectorTableLookupExtension(defaultValues, table, byteIndexes); /// - /// uint8x8_t veor_u8 (uint8x8_t a, uint8x8_t b) - /// A32: VEOR Dd, Dn, Dm - /// A64: EOR Vd.8B, Vn.8B, Vm.8B + /// uint8x8_t veor_u8 (uint8x8_t a, uint8x8_t b) + /// A32: VEOR Dd, Dn, Dm + /// A64: EOR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Xor(Vector64 left, Vector64 right) => Xor(left, right); /// - /// float64x1_t veor_f64 (float64x1_t a, float64x1_t b) - /// A32: VEOR Dd, Dn, Dm - /// A64: EOR Vd.8B, Vn.8B, Vm.8B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x1_t veor_f64 (float64x1_t a, float64x1_t b) + /// A32: VEOR Dd, Dn, Dm + /// A64: EOR Vd.8B, Vn.8B, Vm.8B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 Xor(Vector64 left, Vector64 right) => Xor(left, right); /// - /// int16x4_t veor_s16 (int16x4_t a, int16x4_t b) - /// A32: VEOR Dd, Dn, Dm - /// A64: EOR Vd.8B, Vn.8B, Vm.8B + /// int16x4_t veor_s16 (int16x4_t a, int16x4_t b) + /// A32: VEOR Dd, Dn, Dm + /// A64: EOR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Xor(Vector64 left, Vector64 right) => Xor(left, right); /// - /// int32x2_t veor_s32 (int32x2_t a, int32x2_t b) - /// A32: VEOR Dd, Dn, Dm - /// A64: EOR Vd.8B, Vn.8B, Vm.8B + /// int32x2_t veor_s32 (int32x2_t a, int32x2_t b) + /// A32: VEOR Dd, Dn, Dm + /// A64: EOR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Xor(Vector64 left, Vector64 right) => Xor(left, right); /// - /// int64x1_t veor_s64 (int64x1_t a, int64x1_t b) - /// A32: VEOR Dd, Dn, Dm - /// A64: EOR Vd.8B, Vn.8B, Vm.8B + /// int64x1_t veor_s64 (int64x1_t a, int64x1_t b) + /// A32: VEOR Dd, Dn, Dm + /// A64: EOR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Xor(Vector64 left, Vector64 right) => Xor(left, right); /// - /// int8x8_t veor_s8 (int8x8_t a, int8x8_t b) - /// A32: VEOR Dd, Dn, Dm - /// A64: EOR Vd.8B, Vn.8B, Vm.8B + /// int8x8_t veor_s8 (int8x8_t a, int8x8_t b) + /// A32: VEOR Dd, Dn, Dm + /// A64: EOR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Xor(Vector64 left, Vector64 right) => Xor(left, right); /// - /// float32x2_t veor_f32 (float32x2_t a, float32x2_t b) - /// A32: VEOR Dd, Dn, Dm - /// A64: EOR Vd.8B, Vn.8B, Vm.8B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32x2_t veor_f32 (float32x2_t a, float32x2_t b) + /// A32: VEOR Dd, Dn, Dm + /// A64: EOR Vd.8B, Vn.8B, Vm.8B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector64 Xor(Vector64 left, Vector64 right) => Xor(left, right); /// - /// uint16x4_t veor_u16 (uint16x4_t a, uint16x4_t b) - /// A32: VEOR Dd, Dn, Dm - /// A64: EOR Vd.8B, Vn.8B, Vm.8B + /// uint16x4_t veor_u16 (uint16x4_t a, uint16x4_t b) + /// A32: VEOR Dd, Dn, Dm + /// A64: EOR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Xor(Vector64 left, Vector64 right) => Xor(left, right); /// - /// uint32x2_t veor_u32 (uint32x2_t a, uint32x2_t b) - /// A32: VEOR Dd, Dn, Dm - /// A64: EOR Vd.8B, Vn.8B, Vm.8B + /// uint32x2_t veor_u32 (uint32x2_t a, uint32x2_t b) + /// A32: VEOR Dd, Dn, Dm + /// A64: EOR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Xor(Vector64 left, Vector64 right) => Xor(left, right); /// - /// uint64x1_t veor_u64 (uint64x1_t a, uint64x1_t b) - /// A32: VEOR Dd, Dn, Dm - /// A64: EOR Vd.8B, Vn.8B, Vm.8B + /// uint64x1_t veor_u64 (uint64x1_t a, uint64x1_t b) + /// A32: VEOR Dd, Dn, Dm + /// A64: EOR Vd.8B, Vn.8B, Vm.8B /// public static Vector64 Xor(Vector64 left, Vector64 right) => Xor(left, right); /// - /// uint8x16_t veorq_u8 (uint8x16_t a, uint8x16_t b) - /// A32: VEOR Qd, Qn, Qm - /// A64: EOR Vd.16B, Vn.16B, Vm.16B + /// uint8x16_t veorq_u8 (uint8x16_t a, uint8x16_t b) + /// A32: VEOR Qd, Qn, Qm + /// A64: EOR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// - /// float64x2_t veorq_f64 (float64x2_t a, float64x2_t b) - /// A32: VEOR Qd, Qn, Qm - /// A64: EOR Vd.16B, Vn.16B, Vm.16B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float64x2_t veorq_f64 (float64x2_t a, float64x2_t b) + /// A32: VEOR Qd, Qn, Qm + /// A64: EOR Vd.16B, Vn.16B, Vm.16B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// - /// int16x8_t veorq_s16 (int16x8_t a, int16x8_t b) - /// A32: VEOR Qd, Qn, Qm - /// A64: EOR Vd.16B, Vn.16B, Vm.16B + /// int16x8_t veorq_s16 (int16x8_t a, int16x8_t b) + /// A32: VEOR Qd, Qn, Qm + /// A64: EOR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// - /// int32x4_t veorq_s32 (int32x4_t a, int32x4_t b) - /// A32: VEOR Qd, Qn, Qm - /// A64: EOR Vd.16B, Vn.16B, Vm.16B + /// int32x4_t veorq_s32 (int32x4_t a, int32x4_t b) + /// A32: VEOR Qd, Qn, Qm + /// A64: EOR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// - /// int64x2_t veorq_s64 (int64x2_t a, int64x2_t b) - /// A32: VEOR Qd, Qn, Qm - /// A64: EOR Vd.16B, Vn.16B, Vm.16B + /// int64x2_t veorq_s64 (int64x2_t a, int64x2_t b) + /// A32: VEOR Qd, Qn, Qm + /// A64: EOR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// - /// int8x16_t veorq_s8 (int8x16_t a, int8x16_t b) - /// A32: VEOR Qd, Qn, Qm - /// A64: EOR Vd.16B, Vn.16B, Vm.16B + /// int8x16_t veorq_s8 (int8x16_t a, int8x16_t b) + /// A32: VEOR Qd, Qn, Qm + /// A64: EOR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// - /// float32x4_t veorq_f32 (float32x4_t a, float32x4_t b) - /// A32: VEOR Qd, Qn, Qm - /// A64: EOR Vd.16B, Vn.16B, Vm.16B - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// float32x4_t veorq_f32 (float32x4_t a, float32x4_t b) + /// A32: VEOR Qd, Qn, Qm + /// A64: EOR Vd.16B, Vn.16B, Vm.16B + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// - /// uint16x8_t veorq_u16 (uint16x8_t a, uint16x8_t b) - /// A32: VEOR Qd, Qn, Qm - /// A64: EOR Vd.16B, Vn.16B, Vm.16B + /// uint16x8_t veorq_u16 (uint16x8_t a, uint16x8_t b) + /// A32: VEOR Qd, Qn, Qm + /// A64: EOR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// - /// uint32x4_t veorq_u32 (uint32x4_t a, uint32x4_t b) - /// A32: VEOR Qd, Qn, Qm - /// A64: EOR Vd.16B, Vn.16B, Vm.16B + /// uint32x4_t veorq_u32 (uint32x4_t a, uint32x4_t b) + /// A32: VEOR Qd, Qn, Qm + /// A64: EOR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// - /// uint64x2_t veorq_u64 (uint64x2_t a, uint64x2_t b) - /// A32: VEOR Qd, Qn, Qm - /// A64: EOR Vd.16B, Vn.16B, Vm.16B + /// uint64x2_t veorq_u64 (uint64x2_t a, uint64x2_t b) + /// A32: VEOR Qd, Qn, Qm + /// A64: EOR Vd.16B, Vn.16B, Vm.16B /// public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// - /// uint16x8_t vmovl_u8 (uint8x8_t a) - /// A32: VMOVL.U8 Qd, Dm - /// A64: UXTL Vd.8H, Vn.8B + /// uint16x8_t vmovl_u8 (uint8x8_t a) + /// A32: VMOVL.U8 Qd, Dm + /// A64: UXTL Vd.8H, Vn.8B /// public static Vector128 ZeroExtendWideningLower(Vector64 value) => ZeroExtendWideningLower(value); /// - /// uint32x4_t vmovl_u16 (uint16x4_t a) - /// A32: VMOVL.U16 Qd, Dm - /// A64: UXTL Vd.4S, Vn.4H + /// uint32x4_t vmovl_u16 (uint16x4_t a) + /// A32: VMOVL.U16 Qd, Dm + /// A64: UXTL Vd.4S, Vn.4H /// public static Vector128 ZeroExtendWideningLower(Vector64 value) => ZeroExtendWideningLower(value); /// - /// uint64x2_t vmovl_u32 (uint32x2_t a) - /// A32: VMOVL.U32 Qd, Dm - /// A64: UXTL Vd.2D, Vn.2S + /// uint64x2_t vmovl_u32 (uint32x2_t a) + /// A32: VMOVL.U32 Qd, Dm + /// A64: UXTL Vd.2D, Vn.2S /// public static Vector128 ZeroExtendWideningLower(Vector64 value) => ZeroExtendWideningLower(value); /// - /// uint16x8_t vmovl_u8 (uint8x8_t a) - /// A32: VMOVL.U8 Qd, Dm - /// A64: UXTL Vd.8H, Vn.8B + /// uint16x8_t vmovl_u8 (uint8x8_t a) + /// A32: VMOVL.U8 Qd, Dm + /// A64: UXTL Vd.8H, Vn.8B /// public static Vector128 ZeroExtendWideningLower(Vector64 value) => ZeroExtendWideningLower(value); /// - /// uint32x4_t vmovl_u16 (uint16x4_t a) - /// A32: VMOVL.U16 Qd, Dm - /// A64: UXTL Vd.4S, Vn.4H + /// uint32x4_t vmovl_u16 (uint16x4_t a) + /// A32: VMOVL.U16 Qd, Dm + /// A64: UXTL Vd.4S, Vn.4H /// public static Vector128 ZeroExtendWideningLower(Vector64 value) => ZeroExtendWideningLower(value); /// - /// uint64x2_t vmovl_u32 (uint32x2_t a) - /// A32: VMOVL.U32 Qd, Dm - /// A64: UXTL Vd.2D, Vn.2S + /// uint64x2_t vmovl_u32 (uint32x2_t a) + /// A32: VMOVL.U32 Qd, Dm + /// A64: UXTL Vd.2D, Vn.2S /// public static Vector128 ZeroExtendWideningLower(Vector64 value) => ZeroExtendWideningLower(value); /// - /// uint16x8_t vmovl_high_u8 (uint8x16_t a) - /// A32: VMOVL.U8 Qd, Dm+1 - /// A64: UXTL2 Vd.8H, Vn.16B + /// uint16x8_t vmovl_high_u8 (uint8x16_t a) + /// A32: VMOVL.U8 Qd, Dm+1 + /// A64: UXTL2 Vd.8H, Vn.16B /// public static Vector128 ZeroExtendWideningUpper(Vector128 value) => ZeroExtendWideningUpper(value); /// - /// uint32x4_t vmovl_high_u16 (uint16x8_t a) - /// A32: VMOVL.U16 Qd, Dm+1 - /// A64: UXTL2 Vd.4S, Vn.8H + /// uint32x4_t vmovl_high_u16 (uint16x8_t a) + /// A32: VMOVL.U16 Qd, Dm+1 + /// A64: UXTL2 Vd.4S, Vn.8H /// public static Vector128 ZeroExtendWideningUpper(Vector128 value) => ZeroExtendWideningUpper(value); /// - /// uint64x2_t vmovl_high_u32 (uint32x4_t a) - /// A32: VMOVL.U32 Qd, Dm+1 - /// A64: UXTL2 Vd.2D, Vn.4S + /// uint64x2_t vmovl_high_u32 (uint32x4_t a) + /// A32: VMOVL.U32 Qd, Dm+1 + /// A64: UXTL2 Vd.2D, Vn.4S /// public static Vector128 ZeroExtendWideningUpper(Vector128 value) => ZeroExtendWideningUpper(value); /// - /// uint16x8_t vmovl_high_u8 (uint8x16_t a) - /// A32: VMOVL.U8 Qd, Dm+1 - /// A64: UXTL2 Vd.8H, Vn.16B + /// uint16x8_t vmovl_high_u8 (uint8x16_t a) + /// A32: VMOVL.U8 Qd, Dm+1 + /// A64: UXTL2 Vd.8H, Vn.16B /// public static Vector128 ZeroExtendWideningUpper(Vector128 value) => ZeroExtendWideningUpper(value); /// - /// uint32x4_t vmovl_high_u16 (uint16x8_t a) - /// A32: VMOVL.U16 Qd, Dm+1 - /// A64: UXTL2 Vd.4S, Vn.8H + /// uint32x4_t vmovl_high_u16 (uint16x8_t a) + /// A32: VMOVL.U16 Qd, Dm+1 + /// A64: UXTL2 Vd.4S, Vn.8H /// public static Vector128 ZeroExtendWideningUpper(Vector128 value) => ZeroExtendWideningUpper(value); /// - /// uint64x2_t vmovl_high_u32 (uint32x4_t a) - /// A32: VMOVL.U32 Qd, Dm+1 - /// A64: UXTL2 Vd.2D, Vn.4S + /// uint64x2_t vmovl_high_u32 (uint32x4_t a) + /// A32: VMOVL.U32 Qd, Dm+1 + /// A64: UXTL2 Vd.2D, Vn.4S /// public static Vector128 ZeroExtendWideningUpper(Vector128 value) => ZeroExtendWideningUpper(value); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Aes.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Aes.PlatformNotSupported.cs index d7117540d40..74d94270f56 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Aes.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Aes.PlatformNotSupported.cs @@ -5,76 +5,81 @@ namespace System.Runtime.Intrinsics.Arm { - /// - /// This class provides access to the ARM AES hardware instructions via intrinsics - /// + /// Provides access to the ARM AES hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Aes : ArmBase { internal Aes() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get => false; } + /// Provides access to the ARM AES hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class Arm64 : ArmBase.Arm64 { internal Arm64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } } /// - /// uint8x16_t vaesdq_u8 (uint8x16_t data, uint8x16_t key) - /// A32: AESD.8 Qd, Qm - /// A64: AESD Vd.16B, Vn.16B + /// uint8x16_t vaesdq_u8 (uint8x16_t data, uint8x16_t key) + /// A32: AESD.8 Qd, Qm + /// A64: AESD Vd.16B, Vn.16B /// public static Vector128 Decrypt(Vector128 value, Vector128 roundKey) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vaeseq_u8 (uint8x16_t data, uint8x16_t key) - /// A32: AESE.8 Qd, Qm - /// A64: AESE Vd.16B, Vn.16B + /// uint8x16_t vaeseq_u8 (uint8x16_t data, uint8x16_t key) + /// A32: AESE.8 Qd, Qm + /// A64: AESE Vd.16B, Vn.16B /// public static Vector128 Encrypt(Vector128 value, Vector128 roundKey) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vaesimcq_u8 (uint8x16_t data) - /// A32: AESIMC.8 Qd, Qm - /// A64: AESIMC Vd.16B, Vn.16B + /// uint8x16_t vaesimcq_u8 (uint8x16_t data) + /// A32: AESIMC.8 Qd, Qm + /// A64: AESIMC Vd.16B, Vn.16B /// public static Vector128 InverseMixColumns(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// uint8x16_t vaesmcq_u8 (uint8x16_t data) - /// A32: AESMC.8 Qd, Qm - /// A64: AESMC V>.16B, Vn.16B + /// uint8x16_t vaesmcq_u8 (uint8x16_t data) + /// A32: AESMC.8 Qd, Qm + /// A64: AESMC V>.16B, Vn.16B /// public static Vector128 MixColumns(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// poly128_t vmull_p64 (poly64_t a, poly64_t b) - /// A32: VMULL.P8 Qd, Dn, Dm - /// A64: PMULL Vd.1Q, Vn.1D, Vm.1D + /// poly128_t vmull_p64 (poly64_t a, poly64_t b) + /// A32: VMULL.P8 Qd, Dn, Dm + /// A64: PMULL Vd.1Q, Vn.1D, Vm.1D /// public static Vector128 PolynomialMultiplyWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// poly128_t vmull_p64 (poly64_t a, poly64_t b) - /// A32: VMULL.P8 Qd, Dn, Dm - /// A64: PMULL Vd.1Q, Vn.1D, Vm.1D + /// poly128_t vmull_p64 (poly64_t a, poly64_t b) + /// A32: VMULL.P8 Qd, Dn, Dm + /// A64: PMULL Vd.1Q, Vn.1D, Vm.1D /// public static Vector128 PolynomialMultiplyWideningLower(Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// poly128_t vmull_high_p64 (poly64x2_t a, poly64x2_t b) - /// A32: VMULL.P8 Qd, Dn+1, Dm+1 - /// A64: PMULL2 Vd.1Q, Vn.2D, Vm.2D + /// poly128_t vmull_high_p64 (poly64x2_t a, poly64x2_t b) + /// A32: VMULL.P8 Qd, Dn+1, Dm+1 + /// A64: PMULL2 Vd.1Q, Vn.2D, Vm.2D /// public static Vector128 PolynomialMultiplyWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// poly128_t vmull_high_p64 (poly64x2_t a, poly64x2_t b) - /// A32: VMULL.P8 Qd, Dn+1, Dm+1 - /// A64: PMULL2 Vd.1Q, Vn.2D, Vm.2D + /// poly128_t vmull_high_p64 (poly64x2_t a, poly64x2_t b) + /// A32: VMULL.P8 Qd, Dn+1, Dm+1 + /// A64: PMULL2 Vd.1Q, Vn.2D, Vm.2D /// public static Vector128 PolynomialMultiplyWideningUpper(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Aes.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Aes.cs index f7067a9a0fe..44cf461f00a 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Aes.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Aes.cs @@ -5,78 +5,83 @@ namespace System.Runtime.Intrinsics.Arm { - /// - /// This class provides access to the ARM AES hardware instructions via intrinsics - /// + /// Provides access to the ARM AES hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Aes : ArmBase { internal Aes() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the ARM AES hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class Arm64 : ArmBase.Arm64 { internal Arm64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } } /// - /// uint8x16_t vaesdq_u8 (uint8x16_t data, uint8x16_t key) - /// A32: AESD.8 Qd, Qm - /// A64: AESD Vd.16B, Vn.16B + /// uint8x16_t vaesdq_u8 (uint8x16_t data, uint8x16_t key) + /// A32: AESD.8 Qd, Qm + /// A64: AESD Vd.16B, Vn.16B /// public static Vector128 Decrypt(Vector128 value, Vector128 roundKey) => Decrypt(value, roundKey); /// - /// uint8x16_t vaeseq_u8 (uint8x16_t data, uint8x16_t key) - /// A32: AESE.8 Qd, Qm - /// A64: AESE Vd.16B, Vn.16B + /// uint8x16_t vaeseq_u8 (uint8x16_t data, uint8x16_t key) + /// A32: AESE.8 Qd, Qm + /// A64: AESE Vd.16B, Vn.16B /// public static Vector128 Encrypt(Vector128 value, Vector128 roundKey) => Encrypt(value, roundKey); /// - /// uint8x16_t vaesimcq_u8 (uint8x16_t data) - /// A32: AESIMC.8 Qd, Qm - /// A64: AESIMC Vd.16B, Vn.16B + /// uint8x16_t vaesimcq_u8 (uint8x16_t data) + /// A32: AESIMC.8 Qd, Qm + /// A64: AESIMC Vd.16B, Vn.16B /// public static Vector128 InverseMixColumns(Vector128 value) => InverseMixColumns(value); /// - /// uint8x16_t vaesmcq_u8 (uint8x16_t data) - /// A32: AESMC.8 Qd, Qm - /// A64: AESMC V>.16B, Vn.16B + /// uint8x16_t vaesmcq_u8 (uint8x16_t data) + /// A32: AESMC.8 Qd, Qm + /// A64: AESMC V>.16B, Vn.16B /// public static Vector128 MixColumns(Vector128 value) => MixColumns(value); /// - /// poly128_t vmull_p64 (poly64_t a, poly64_t b) - /// A32: VMULL.P8 Qd, Dn, Dm - /// A64: PMULL Vd.1Q, Vn.1D, Vm.1D + /// poly128_t vmull_p64 (poly64_t a, poly64_t b) + /// A32: VMULL.P8 Qd, Dn, Dm + /// A64: PMULL Vd.1Q, Vn.1D, Vm.1D /// public static Vector128 PolynomialMultiplyWideningLower(Vector64 left, Vector64 right) => PolynomialMultiplyWideningLower(left, right); /// - /// poly128_t vmull_p64 (poly64_t a, poly64_t b) - /// A32: VMULL.P8 Qd, Dn, Dm - /// A64: PMULL Vd.1Q, Vn.1D, Vm.1D + /// poly128_t vmull_p64 (poly64_t a, poly64_t b) + /// A32: VMULL.P8 Qd, Dn, Dm + /// A64: PMULL Vd.1Q, Vn.1D, Vm.1D /// public static Vector128 PolynomialMultiplyWideningLower(Vector64 left, Vector64 right) => PolynomialMultiplyWideningLower(left, right); /// - /// poly128_t vmull_high_p64 (poly64x2_t a, poly64x2_t b) - /// A32: VMULL.P8 Qd, Dn+1, Dm+1 - /// A64: PMULL2 Vd.1Q, Vn.2D, Vm.2D + /// poly128_t vmull_high_p64 (poly64x2_t a, poly64x2_t b) + /// A32: VMULL.P8 Qd, Dn+1, Dm+1 + /// A64: PMULL2 Vd.1Q, Vn.2D, Vm.2D /// public static Vector128 PolynomialMultiplyWideningUpper(Vector128 left, Vector128 right) => PolynomialMultiplyWideningUpper(left, right); /// - /// poly128_t vmull_high_p64 (poly64x2_t a, poly64x2_t b) - /// A32: VMULL.P8 Qd, Dn+1, Dm+1 - /// A64: PMULL2 Vd.1Q, Vn.2D, Vm.2D + /// poly128_t vmull_high_p64 (poly64x2_t a, poly64x2_t b) + /// A32: VMULL.P8 Qd, Dn+1, Dm+1 + /// A64: PMULL2 Vd.1Q, Vn.2D, Vm.2D /// public static Vector128 PolynomialMultiplyWideningUpper(Vector128 left, Vector128 right) => PolynomialMultiplyWideningUpper(left, right); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/ArmBase.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/ArmBase.PlatformNotSupported.cs index faafd1bb5f4..de1f3bcd43c 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/ArmBase.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/ArmBase.PlatformNotSupported.cs @@ -5,9 +5,7 @@ namespace System.Runtime.Intrinsics.Arm { - /// - /// This class provides access to the ARM base hardware instructions via intrinsics - /// + /// Provides access to the ARM base hardware instructions via intrinsics. [CLSCompliant(false)] #if SYSTEM_PRIVATE_CORELIB public @@ -18,82 +16,73 @@ abstract class ArmBase { internal ArmBase() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static bool IsSupported { [Intrinsic] get => false; } + /// Provides access to the ARM base hardware instructions, that are only available to 64-bit processes, via intrinsics. public abstract class Arm64 { internal Arm64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static bool IsSupported { [Intrinsic] get => false; } - /// - /// A64: CLS Wd, Wn - /// + /// A64: CLS Wd, Wn public static int LeadingSignCount(int value) { throw new PlatformNotSupportedException(); } - /// - /// A64: CLS Xd, Xn - /// + /// A64: CLS Xd, Xn public static int LeadingSignCount(long value) { throw new PlatformNotSupportedException(); } - /// - /// A64: CLZ Xd, Xn - /// + /// A64: CLZ Xd, Xn public static int LeadingZeroCount(long value) { throw new PlatformNotSupportedException(); } - /// - /// A64: CLZ Xd, Xn - /// + /// A64: CLZ Xd, Xn public static int LeadingZeroCount(ulong value) { throw new PlatformNotSupportedException(); } - /// - /// A64: SMULH Xd, Xn, Xm - /// + /// A64: SMULH Xd, Xn, Xm public static long MultiplyHigh(long left, long right) { throw new PlatformNotSupportedException(); } - /// - /// A64: UMULH Xd, Xn, Xm - /// + /// A64: UMULH Xd, Xn, Xm public static ulong MultiplyHigh(ulong left, ulong right) { throw new PlatformNotSupportedException(); } - /// - /// A64: RBIT Xd, Xn - /// + /// A64: RBIT Xd, Xn public static long ReverseElementBits(long value) { throw new PlatformNotSupportedException(); } - /// - /// A64: RBIT Xd, Xn - /// + /// A64: RBIT Xd, Xn public static ulong ReverseElementBits(ulong value) { throw new PlatformNotSupportedException(); } } /// - /// A32: CLZ Rd, Rm - /// A64: CLZ Wd, Wn + /// A32: CLZ Rd, Rm + /// A64: CLZ Wd, Wn /// public static int LeadingZeroCount(int value) { throw new PlatformNotSupportedException(); } /// - /// A32: CLZ Rd, Rm - /// A64: CLZ Wd, Wn + /// A32: CLZ Rd, Rm + /// A64: CLZ Wd, Wn /// public static int LeadingZeroCount(uint value) { throw new PlatformNotSupportedException(); } /// - /// A32: RBIT Rd, Rm - /// A64: RBIT Wd, Wn + /// A32: RBIT Rd, Rm + /// A64: RBIT Wd, Wn /// public static int ReverseElementBits(int value) { throw new PlatformNotSupportedException(); } /// - /// A32: RBIT Rd, Rm - /// A64: RBIT Wd, Wn + /// A32: RBIT Rd, Rm + /// A64: RBIT Wd, Wn /// public static uint ReverseElementBits(uint value) { throw new PlatformNotSupportedException(); } /// - /// A32: YIELD - /// A64: YIELD + /// A32: YIELD + /// A64: YIELD /// public static void Yield() { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/ArmBase.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/ArmBase.cs index dd378377f5c..570d8558309 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/ArmBase.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/ArmBase.cs @@ -5,92 +5,81 @@ namespace System.Runtime.Intrinsics.Arm { - /// - /// This class provides access to the ARM base hardware instructions via intrinsics - /// + /// Provides access to the ARM base hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class ArmBase { internal ArmBase() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static bool IsSupported { get => IsSupported; } + /// Provides access to the ARM base hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public abstract class Arm64 { internal Arm64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static bool IsSupported { get => IsSupported; } - /// - /// A64: CLS Wd, Wn - /// + /// A64: CLS Wd, Wn public static int LeadingSignCount(int value) => LeadingSignCount(value); - /// - /// A64: CLS Xd, Xn - /// + /// A64: CLS Xd, Xn public static int LeadingSignCount(long value) => LeadingSignCount(value); - /// - /// A64: CLZ Xd, Xn - /// + /// A64: CLZ Xd, Xn public static int LeadingZeroCount(long value) => LeadingZeroCount(value); - /// - /// A64: CLZ Xd, Xn - /// + /// A64: CLZ Xd, Xn public static int LeadingZeroCount(ulong value) => LeadingZeroCount(value); - /// - /// A64: SMULH Xd, Xn, Xm - /// + /// A64: SMULH Xd, Xn, Xm public static long MultiplyHigh(long left, long right) => MultiplyHigh(left, right); - /// - /// A64: UMULH Xd, Xn, Xm - /// + /// A64: UMULH Xd, Xn, Xm public static ulong MultiplyHigh(ulong left, ulong right) => MultiplyHigh(left, right); - /// - /// A64: RBIT Xd, Xn - /// + /// A64: RBIT Xd, Xn public static long ReverseElementBits(long value) => ReverseElementBits(value); - /// - /// A64: RBIT Xd, Xn - /// + /// A64: RBIT Xd, Xn public static ulong ReverseElementBits(ulong value) => ReverseElementBits(value); } /// - /// A32: CLZ Rd, Rm - /// A64: CLZ Wd, Wn + /// A32: CLZ Rd, Rm + /// A64: CLZ Wd, Wn /// public static int LeadingZeroCount(int value) => LeadingZeroCount(value); /// - /// A32: CLZ Rd, Rm - /// A64: CLZ Wd, Wn + /// A32: CLZ Rd, Rm + /// A64: CLZ Wd, Wn /// public static int LeadingZeroCount(uint value) => LeadingZeroCount(value); /// - /// A32: RBIT Rd, Rm - /// A64: RBIT Wd, Wn + /// A32: RBIT Rd, Rm + /// A64: RBIT Wd, Wn /// public static int ReverseElementBits(int value) => ReverseElementBits(value); /// - /// A32: RBIT Rd, Rm - /// A64: RBIT Wd, Wn + /// A32: RBIT Rd, Rm + /// A64: RBIT Wd, Wn /// public static uint ReverseElementBits(uint value) => ReverseElementBits(value); /// - /// A32: YIELD - /// A64: YIELD + /// A32: YIELD + /// A64: YIELD /// public static void Yield() => Yield(); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Crc32.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Crc32.PlatformNotSupported.cs index 3cc715faa36..e1cc0b5fa31 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Crc32.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Crc32.PlatformNotSupported.cs @@ -5,74 +5,79 @@ namespace System.Runtime.Intrinsics.Arm { - /// - /// This class provides access to the ARM Crc32 hardware instructions via intrinsics - /// + /// Provides access to the ARM Crc32 hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Crc32 : ArmBase { internal Crc32() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } + /// Provides access to the ARM Crc32 hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class Arm64 : ArmBase.Arm64 { internal Arm64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } /// - /// uint32_t __crc32d (uint32_t a, uint64_t b) - /// A64: CRC32X Wd, Wn, Xm + /// uint32_t __crc32d (uint32_t a, uint64_t b) + /// A64: CRC32X Wd, Wn, Xm /// public static uint ComputeCrc32(uint crc, ulong data) { throw new PlatformNotSupportedException(); } /// - /// uint32_t __crc32cd (uint32_t a, uint64_t b) - /// A64: CRC32CX Wd, Wn, Xm + /// uint32_t __crc32cd (uint32_t a, uint64_t b) + /// A64: CRC32CX Wd, Wn, Xm /// public static uint ComputeCrc32C(uint crc, ulong data) { throw new PlatformNotSupportedException(); } } /// - /// uint32_t __crc32b (uint32_t a, uint8_t b) - /// A32: CRC32B Rd, Rn, Rm - /// A64: CRC32B Wd, Wn, Wm + /// uint32_t __crc32b (uint32_t a, uint8_t b) + /// A32: CRC32B Rd, Rn, Rm + /// A64: CRC32B Wd, Wn, Wm /// public static uint ComputeCrc32(uint crc, byte data) { throw new PlatformNotSupportedException(); } /// - /// uint32_t __crc32h (uint32_t a, uint16_t b) - /// A32: CRC32H Rd, Rn, Rm - /// A64: CRC32H Wd, Wn, Wm + /// uint32_t __crc32h (uint32_t a, uint16_t b) + /// A32: CRC32H Rd, Rn, Rm + /// A64: CRC32H Wd, Wn, Wm /// public static uint ComputeCrc32(uint crc, ushort data) { throw new PlatformNotSupportedException(); } /// - /// uint32_t __crc32w (uint32_t a, uint32_t b) - /// A32: CRC32W Rd, Rn, Rm - /// A64: CRC32W Wd, Wn, Wm + /// uint32_t __crc32w (uint32_t a, uint32_t b) + /// A32: CRC32W Rd, Rn, Rm + /// A64: CRC32W Wd, Wn, Wm /// public static uint ComputeCrc32(uint crc, uint data) { throw new PlatformNotSupportedException(); } /// - /// uint32_t __crc32cb (uint32_t a, uint8_t b) - /// A32: CRC32CB Rd, Rn, Rm - /// A64: CRC32CB Wd, Wn, Wm + /// uint32_t __crc32cb (uint32_t a, uint8_t b) + /// A32: CRC32CB Rd, Rn, Rm + /// A64: CRC32CB Wd, Wn, Wm /// public static uint ComputeCrc32C(uint crc, byte data) { throw new PlatformNotSupportedException(); } /// - /// uint32_t __crc32ch (uint32_t a, uint16_t b) - /// A32: CRC32CH Rd, Rn, Rm - /// A64: CRC32CH Wd, Wn, Wm + /// uint32_t __crc32ch (uint32_t a, uint16_t b) + /// A32: CRC32CH Rd, Rn, Rm + /// A64: CRC32CH Wd, Wn, Wm /// public static uint ComputeCrc32C(uint crc, ushort data) { throw new PlatformNotSupportedException(); } /// - /// uint32_t __crc32cw (uint32_t a, uint32_t b) - /// A32: CRC32CW Rd, Rn, Rm - /// A64: CRC32CW Wd, Wn, Wm + /// uint32_t __crc32cw (uint32_t a, uint32_t b) + /// A32: CRC32CW Rd, Rn, Rm + /// A64: CRC32CW Wd, Wn, Wm /// public static uint ComputeCrc32C(uint crc, uint data) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Crc32.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Crc32.cs index 70677281415..8d51183f63f 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Crc32.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Crc32.cs @@ -5,76 +5,81 @@ namespace System.Runtime.Intrinsics.Arm { - /// - /// This class provides access to the ARM Crc32 hardware instructions via intrinsics - /// + /// Provides access to the ARM Crc32 hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Crc32 : ArmBase { internal Crc32() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the ARM Crc32 hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class Arm64 : ArmBase.Arm64 { internal Arm64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } /// - /// uint32_t __crc32d (uint32_t a, uint64_t b) - /// A64: CRC32X Wd, Wn, Xm + /// uint32_t __crc32d (uint32_t a, uint64_t b) + /// A64: CRC32X Wd, Wn, Xm /// public static uint ComputeCrc32(uint crc, ulong data) => ComputeCrc32(crc, data); /// - /// uint32_t __crc32cd (uint32_t a, uint64_t b) - /// A64: CRC32CX Wd, Wn, Xm + /// uint32_t __crc32cd (uint32_t a, uint64_t b) + /// A64: CRC32CX Wd, Wn, Xm /// public static uint ComputeCrc32C(uint crc, ulong data) => ComputeCrc32C(crc, data); } /// - /// uint32_t __crc32b (uint32_t a, uint8_t b) - /// A32: CRC32B Rd, Rn, Rm - /// A64: CRC32B Wd, Wn, Wm + /// uint32_t __crc32b (uint32_t a, uint8_t b) + /// A32: CRC32B Rd, Rn, Rm + /// A64: CRC32B Wd, Wn, Wm /// public static uint ComputeCrc32(uint crc, byte data) => ComputeCrc32(crc, data); /// - /// uint32_t __crc32h (uint32_t a, uint16_t b) - /// A32: CRC32H Rd, Rn, Rm - /// A64: CRC32H Wd, Wn, Wm + /// uint32_t __crc32h (uint32_t a, uint16_t b) + /// A32: CRC32H Rd, Rn, Rm + /// A64: CRC32H Wd, Wn, Wm /// public static uint ComputeCrc32(uint crc, ushort data) => ComputeCrc32(crc, data); /// - /// uint32_t __crc32w (uint32_t a, uint32_t b) - /// A32: CRC32W Rd, Rn, Rm - /// A64: CRC32W Wd, Wn, Wm + /// uint32_t __crc32w (uint32_t a, uint32_t b) + /// A32: CRC32W Rd, Rn, Rm + /// A64: CRC32W Wd, Wn, Wm /// public static uint ComputeCrc32(uint crc, uint data) => ComputeCrc32(crc, data); /// - /// uint32_t __crc32cb (uint32_t a, uint8_t b) - /// A32: CRC32CB Rd, Rn, Rm - /// A64: CRC32CB Wd, Wn, Wm + /// uint32_t __crc32cb (uint32_t a, uint8_t b) + /// A32: CRC32CB Rd, Rn, Rm + /// A64: CRC32CB Wd, Wn, Wm /// public static uint ComputeCrc32C(uint crc, byte data) => ComputeCrc32C(crc, data); /// - /// uint32_t __crc32ch (uint32_t a, uint16_t b) - /// A32: CRC32CH Rd, Rn, Rm - /// A64: CRC32CH Wd, Wn, Wm + /// uint32_t __crc32ch (uint32_t a, uint16_t b) + /// A32: CRC32CH Rd, Rn, Rm + /// A64: CRC32CH Wd, Wn, Wm /// public static uint ComputeCrc32C(uint crc, ushort data) => ComputeCrc32C(crc, data); /// - /// uint32_t __crc32cw (uint32_t a, uint32_t b) - /// A32: CRC32CW Rd, Rn, Rm - /// A64: CRC32CW Wd, Wn, Wm + /// uint32_t __crc32cw (uint32_t a, uint32_t b) + /// A32: CRC32CW Rd, Rn, Rm + /// A64: CRC32CW Wd, Wn, Wm /// public static uint ComputeCrc32C(uint crc, uint data) => ComputeCrc32C(crc, data); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Dp.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Dp.PlatformNotSupported.cs index d45ffb73266..6df0085c95d 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Dp.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Dp.PlatformNotSupported.cs @@ -6,104 +6,109 @@ namespace System.Runtime.Intrinsics.Arm { - /// - /// This class provides access to the ARMv8.2-DotProd hardware instructions via intrinsics - /// + /// Provides access to the ARMv8.2-DotProd hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Dp : AdvSimd { internal Dp() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get => false; } + /// Provides access to the ARMv8.2-DotProd hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class Arm64 : AdvSimd.Arm64 { internal Arm64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } } /// - /// int32x2_t vdot_s32 (int32x2_t r, int8x8_t a, int8x8_t b) - /// A32: VSDOT.S8 Dd, Dn, Dm - /// A64: SDOT Vd.2S, Vn.8B, Vm.8B + /// int32x2_t vdot_s32 (int32x2_t r, int8x8_t a, int8x8_t b) + /// A32: VSDOT.S8 Dd, Dn, Dm + /// A64: SDOT Vd.2S, Vn.8B, Vm.8B /// public static Vector64 DotProduct(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vdot_u32 (uint32x2_t r, uint8x8_t a, uint8x8_t b) - /// A32: VUDOT.U8 Dd, Dn, Dm - /// A64: UDOT Vd.2S, Vn.8B, Vm.8B + /// uint32x2_t vdot_u32 (uint32x2_t r, uint8x8_t a, uint8x8_t b) + /// A32: VUDOT.U8 Dd, Dn, Dm + /// A64: UDOT Vd.2S, Vn.8B, Vm.8B /// public static Vector64 DotProduct(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vdotq_s32 (int32x4_t r, int8x16_t a, int8x16_t b) - /// A32: VSDOT.S8 Qd, Qn, Qm - /// A64: SDOT Vd.4S, Vn.16B, Vm.16B + /// int32x4_t vdotq_s32 (int32x4_t r, int8x16_t a, int8x16_t b) + /// A32: VSDOT.S8 Qd, Qn, Qm + /// A64: SDOT Vd.4S, Vn.16B, Vm.16B /// public static Vector128 DotProduct(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vdotq_u32 (uint32x4_t r, uint8x16_t a, uint8x16_t b) - /// A32: VUDOT.U8 Qd, Qn, Qm - /// A64: UDOT Vd.4S, Vn.16B, Vm.16B + /// uint32x4_t vdotq_u32 (uint32x4_t r, uint8x16_t a, uint8x16_t b) + /// A32: VUDOT.U8 Qd, Qn, Qm + /// A64: UDOT Vd.4S, Vn.16B, Vm.16B /// public static Vector128 DotProduct(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vdot_lane_s32 (int32x2_t r, int8x8_t a, int8x8_t b, const int lane) - /// A32: VSDOT.S8 Dd, Dn, Dm[lane] - /// A64: SDOT Vd.2S, Vn.8B, Vm.4B[lane] + /// int32x2_t vdot_lane_s32 (int32x2_t r, int8x8_t a, int8x8_t b, const int lane) + /// A32: VSDOT.S8 Dd, Dn, Dm[lane] + /// A64: SDOT Vd.2S, Vn.8B, Vm.4B[lane] /// public static Vector64 DotProductBySelectedQuadruplet(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(7))] byte rightScaledIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vdot_laneq_s32 (int32x2_t r, int8x8_t a, int8x16_t b, const int lane) - /// A32: VSDOT.S8 Dd, Dn, Dm[lane] - /// A64: SDOT Vd.2S, Vn.8B, Vm.4B[lane] + /// int32x2_t vdot_laneq_s32 (int32x2_t r, int8x8_t a, int8x16_t b, const int lane) + /// A32: VSDOT.S8 Dd, Dn, Dm[lane] + /// A64: SDOT Vd.2S, Vn.8B, Vm.4B[lane] /// public static Vector64 DotProductBySelectedQuadruplet(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(15))] byte rightScaledIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vdot_lane_u32 (uint32x2_t r, uint8x8_t a, uint8x8_t b, const int lane) - /// A32: VUDOT.U8 Dd, Dn, Dm[lane] - /// A64: UDOT Vd.2S, Vn.8B, Vm.4B[lane] + /// uint32x2_t vdot_lane_u32 (uint32x2_t r, uint8x8_t a, uint8x8_t b, const int lane) + /// A32: VUDOT.U8 Dd, Dn, Dm[lane] + /// A64: UDOT Vd.2S, Vn.8B, Vm.4B[lane] /// public static Vector64 DotProductBySelectedQuadruplet(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(7))] byte rightScaledIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x2_t vdot_laneq_u32 (uint32x2_t r, uint8x8_t a, uint8x16_t b, const int lane) - /// A32: VUDOT.U8 Dd, Dn, Dm[lane] - /// A64: UDOT Vd.2S, Vn.8B, Vm.4B[lane] + /// uint32x2_t vdot_laneq_u32 (uint32x2_t r, uint8x8_t a, uint8x16_t b, const int lane) + /// A32: VUDOT.U8 Dd, Dn, Dm[lane] + /// A64: UDOT Vd.2S, Vn.8B, Vm.4B[lane] /// public static Vector64 DotProductBySelectedQuadruplet(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(15))] byte rightScaledIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vdotq_laneq_s32 (int32x4_t r, int8x16_t a, int8x16_t b, const int lane) - /// A32: VSDOT.S8 Qd, Qn, Dm[lane] - /// A64: SDOT Vd.4S, Vn.16B, Vm.4B[lane] + /// int32x4_t vdotq_laneq_s32 (int32x4_t r, int8x16_t a, int8x16_t b, const int lane) + /// A32: VSDOT.S8 Qd, Qn, Dm[lane] + /// A64: SDOT Vd.4S, Vn.16B, Vm.4B[lane] /// public static Vector128 DotProductBySelectedQuadruplet(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(15))] byte rightScaledIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vdotq_lane_s32 (int32x4_t r, int8x16_t a, int8x8_t b, const int lane) - /// A32: VSDOT.S8 Qd, Qn, Dm[lane] - /// A64: SDOT Vd.4S, Vn.16B, Vm.4B[lane] + /// int32x4_t vdotq_lane_s32 (int32x4_t r, int8x16_t a, int8x8_t b, const int lane) + /// A32: VSDOT.S8 Qd, Qn, Dm[lane] + /// A64: SDOT Vd.4S, Vn.16B, Vm.4B[lane] /// public static Vector128 DotProductBySelectedQuadruplet(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(7))] byte rightScaledIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vdotq_laneq_u32 (uint32x4_t r, uint8x16_t a, uint8x16_t b, const int lane) - /// A32: VUDOT.U8 Qd, Qn, Dm[lane] - /// A64: UDOT Vd.4S, Vn.16B, Vm.4B[lane] + /// uint32x4_t vdotq_laneq_u32 (uint32x4_t r, uint8x16_t a, uint8x16_t b, const int lane) + /// A32: VUDOT.U8 Qd, Qn, Dm[lane] + /// A64: UDOT Vd.4S, Vn.16B, Vm.4B[lane] /// public static Vector128 DotProductBySelectedQuadruplet(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(15))] byte rightScaledIndex) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vdotq_lane_u32 (uint32x4_t r, uint8x16_t a, uint8x8_t b, const int lane) - /// A32: VUDOT.U8 Qd, Qn, Dm[lane] - /// A64: UDOT Vd.4S, Vn.16B, Vm.4B[lane] + /// uint32x4_t vdotq_lane_u32 (uint32x4_t r, uint8x16_t a, uint8x8_t b, const int lane) + /// A32: VUDOT.U8 Qd, Qn, Dm[lane] + /// A64: UDOT Vd.4S, Vn.16B, Vm.4B[lane] /// public static Vector128 DotProductBySelectedQuadruplet(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(7))] byte rightScaledIndex) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Dp.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Dp.cs index 8732f856925..412b0017a2d 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Dp.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Dp.cs @@ -6,106 +6,111 @@ namespace System.Runtime.Intrinsics.Arm { - /// - /// This class provides access to the ARMv8.2-DotProd hardware instructions via intrinsics - /// + /// Provides access to the ARMv8.2-DotProd hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Dp : AdvSimd { internal Dp() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the ARMv8.2-DotProd hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class Arm64 : AdvSimd.Arm64 { internal Arm64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } } /// - /// int32x2_t vdot_s32 (int32x2_t r, int8x8_t a, int8x8_t b) - /// A32: VSDOT.S8 Dd, Dn, Dm - /// A64: SDOT Vd.2S, Vn.8B, Vm.8B + /// int32x2_t vdot_s32 (int32x2_t r, int8x8_t a, int8x8_t b) + /// A32: VSDOT.S8 Dd, Dn, Dm + /// A64: SDOT Vd.2S, Vn.8B, Vm.8B /// public static Vector64 DotProduct(Vector64 addend, Vector64 left, Vector64 right) => DotProduct(addend, left, right); /// - /// uint32x2_t vdot_u32 (uint32x2_t r, uint8x8_t a, uint8x8_t b) - /// A32: VUDOT.U8 Dd, Dn, Dm - /// A64: UDOT Vd.2S, Vn.8B, Vm.8B + /// uint32x2_t vdot_u32 (uint32x2_t r, uint8x8_t a, uint8x8_t b) + /// A32: VUDOT.U8 Dd, Dn, Dm + /// A64: UDOT Vd.2S, Vn.8B, Vm.8B /// public static Vector64 DotProduct(Vector64 addend, Vector64 left, Vector64 right) => DotProduct(addend, left, right); /// - /// int32x4_t vdotq_s32 (int32x4_t r, int8x16_t a, int8x16_t b) - /// A32: VSDOT.S8 Qd, Qn, Qm - /// A64: SDOT Vd.4S, Vn.16B, Vm.16B + /// int32x4_t vdotq_s32 (int32x4_t r, int8x16_t a, int8x16_t b) + /// A32: VSDOT.S8 Qd, Qn, Qm + /// A64: SDOT Vd.4S, Vn.16B, Vm.16B /// public static Vector128 DotProduct(Vector128 addend, Vector128 left, Vector128 right) => DotProduct(addend, left, right); /// - /// uint32x4_t vdotq_u32 (uint32x4_t r, uint8x16_t a, uint8x16_t b) - /// A32: VUDOT.U8 Qd, Qn, Qm - /// A64: UDOT Vd.4S, Vn.16B, Vm.16B + /// uint32x4_t vdotq_u32 (uint32x4_t r, uint8x16_t a, uint8x16_t b) + /// A32: VUDOT.U8 Qd, Qn, Qm + /// A64: UDOT Vd.4S, Vn.16B, Vm.16B /// public static Vector128 DotProduct(Vector128 addend, Vector128 left, Vector128 right) => DotProduct(addend, left, right); /// - /// int32x2_t vdot_lane_s32 (int32x2_t r, int8x8_t a, int8x8_t b, const int lane) - /// A32: VSDOT.S8 Dd, Dn, Dm[lane] - /// A64: SDOT Vd.2S, Vn.8B, Vm.4B[lane] + /// int32x2_t vdot_lane_s32 (int32x2_t r, int8x8_t a, int8x8_t b, const int lane) + /// A32: VSDOT.S8 Dd, Dn, Dm[lane] + /// A64: SDOT Vd.2S, Vn.8B, Vm.4B[lane] /// public static Vector64 DotProductBySelectedQuadruplet(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(7))] byte rightScaledIndex) => DotProductBySelectedQuadruplet(addend, left, right, rightScaledIndex); /// - /// int32x2_t vdot_laneq_s32 (int32x2_t r, int8x8_t a, int8x16_t b, const int lane) - /// A32: VSDOT.S8 Dd, Dn, Dm[lane] - /// A64: SDOT Vd.2S, Vn.8B, Vm.4B[lane] + /// int32x2_t vdot_laneq_s32 (int32x2_t r, int8x8_t a, int8x16_t b, const int lane) + /// A32: VSDOT.S8 Dd, Dn, Dm[lane] + /// A64: SDOT Vd.2S, Vn.8B, Vm.4B[lane] /// public static Vector64 DotProductBySelectedQuadruplet(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(15))] byte rightScaledIndex) => DotProductBySelectedQuadruplet(addend, left, right, rightScaledIndex); /// - /// uint32x2_t vdot_lane_u32 (uint32x2_t r, uint8x8_t a, uint8x8_t b, const int lane) - /// A32: VUDOT.U8 Dd, Dn, Dm[lane] - /// A64: UDOT Vd.2S, Vn.8B, Vm.4B[lane] + /// uint32x2_t vdot_lane_u32 (uint32x2_t r, uint8x8_t a, uint8x8_t b, const int lane) + /// A32: VUDOT.U8 Dd, Dn, Dm[lane] + /// A64: UDOT Vd.2S, Vn.8B, Vm.4B[lane] /// public static Vector64 DotProductBySelectedQuadruplet(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(7))] byte rightScaledIndex) => DotProductBySelectedQuadruplet(addend, left, right, rightScaledIndex); /// - /// uint32x2_t vdot_laneq_u32 (uint32x2_t r, uint8x8_t a, uint8x16_t b, const int lane) - /// A32: VUDOT.U8 Dd, Dn, Dm[lane] - /// A64: UDOT Vd.2S, Vn.8B, Vm.4B[lane] + /// uint32x2_t vdot_laneq_u32 (uint32x2_t r, uint8x8_t a, uint8x16_t b, const int lane) + /// A32: VUDOT.U8 Dd, Dn, Dm[lane] + /// A64: UDOT Vd.2S, Vn.8B, Vm.4B[lane] /// public static Vector64 DotProductBySelectedQuadruplet(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(15))] byte rightScaledIndex) => DotProductBySelectedQuadruplet(addend, left, right, rightScaledIndex); /// - /// int32x4_t vdotq_laneq_s32 (int32x4_t r, int8x16_t a, int8x16_t b, const int lane) - /// A32: VSDOT.S8 Qd, Qn, Dm[lane] - /// A64: SDOT Vd.4S, Vn.16B, Vm.4B[lane] + /// int32x4_t vdotq_laneq_s32 (int32x4_t r, int8x16_t a, int8x16_t b, const int lane) + /// A32: VSDOT.S8 Qd, Qn, Dm[lane] + /// A64: SDOT Vd.4S, Vn.16B, Vm.4B[lane] /// public static Vector128 DotProductBySelectedQuadruplet(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(15))] byte rightScaledIndex) => DotProductBySelectedQuadruplet(addend, left, right, rightScaledIndex); /// - /// int32x4_t vdotq_lane_s32 (int32x4_t r, int8x16_t a, int8x8_t b, const int lane) - /// A32: VSDOT.S8 Qd, Qn, Dm[lane] - /// A64: SDOT Vd.4S, Vn.16B, Vm.4B[lane] + /// int32x4_t vdotq_lane_s32 (int32x4_t r, int8x16_t a, int8x8_t b, const int lane) + /// A32: VSDOT.S8 Qd, Qn, Dm[lane] + /// A64: SDOT Vd.4S, Vn.16B, Vm.4B[lane] /// public static Vector128 DotProductBySelectedQuadruplet(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(7))] byte rightScaledIndex) => DotProductBySelectedQuadruplet(addend, left, right, rightScaledIndex); /// - /// uint32x4_t vdotq_laneq_u32 (uint32x4_t r, uint8x16_t a, uint8x16_t b, const int lane) - /// A32: VUDOT.U8 Qd, Qn, Dm[lane] - /// A64: UDOT Vd.4S, Vn.16B, Vm.4B[lane] + /// uint32x4_t vdotq_laneq_u32 (uint32x4_t r, uint8x16_t a, uint8x16_t b, const int lane) + /// A32: VUDOT.U8 Qd, Qn, Dm[lane] + /// A64: UDOT Vd.4S, Vn.16B, Vm.4B[lane] /// public static Vector128 DotProductBySelectedQuadruplet(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(15))] byte rightScaledIndex) => DotProductBySelectedQuadruplet(addend, left, right, rightScaledIndex); /// - /// uint32x4_t vdotq_lane_u32 (uint32x4_t r, uint8x16_t a, uint8x8_t b, const int lane) - /// A32: VUDOT.U8 Qd, Qn, Dm[lane] - /// A64: UDOT Vd.4S, Vn.16B, Vm.4B[lane] + /// uint32x4_t vdotq_lane_u32 (uint32x4_t r, uint8x16_t a, uint8x8_t b, const int lane) + /// A32: VUDOT.U8 Qd, Qn, Dm[lane] + /// A64: UDOT Vd.4S, Vn.16B, Vm.4B[lane] /// public static Vector128 DotProductBySelectedQuadruplet(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(7))] byte rightScaledIndex) => DotProductBySelectedQuadruplet(addend, left, right, rightScaledIndex); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Enums.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Enums.cs index 95013fa9904..b2dc3e15994 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Enums.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Enums.cs @@ -7,152 +7,94 @@ namespace System.Runtime.Intrinsics.Arm // Matches the field "pattern" within the Arm Architecture Reference Manual public enum SveMaskPattern : byte { - /// - /// POW2 - /// + /// POW2 LargestPowerOf2 = 0, // The largest power of 2. - /// - /// VL1 - /// + /// VL1 VectorCount1 = 1, // Exactly 1 element. - /// - /// VL2 - /// + /// VL2 VectorCount2 = 2, // Exactly 2 elements. - /// - /// VL3 - /// + /// VL3 VectorCount3 = 3, // Exactly 3 elements. - /// - /// VL4 - /// + /// VL4 VectorCount4 = 4, // Exactly 4 elements. - /// - /// VL5 - /// + /// VL5 VectorCount5 = 5, // Exactly 5 elements. - /// - /// VL6 - /// + /// VL6 VectorCount6 = 6, // Exactly 6 elements. - /// - /// VL7 - /// + /// VL7 VectorCount7 = 7, // Exactly 7 elements. - /// - /// VL8 - /// + /// VL8 VectorCount8 = 8, // Exactly 8 elements. - /// - /// VL16 - /// + /// VL16 VectorCount16 = 9, // Exactly 16 elements. - /// - /// VL32 - /// + /// VL32 VectorCount32 = 10, // Exactly 32 elements. - /// - /// VL64 - /// + /// VL64 VectorCount64 = 11, // Exactly 64 elements. - /// - /// VL128 - /// + /// VL128 VectorCount128 = 12, // Exactly 128 elements. - /// - /// VL256 - /// + /// VL256 VectorCount256 = 13, // Exactly 256 elements. - /// - /// MUL4 - /// + /// MUL4 LargestMultipleOf4 = 29, // The largest multiple of 4. - /// - /// MUL3 - /// + /// MUL3 LargestMultipleOf3 = 30, // The largest multiple of 3. - /// - /// ALL - /// + /// ALL All = 31 // All available (implicitly a multiple of two). } public enum SvePrefetchType : byte { - /// - /// PLDL1KEEP - /// + /// PLDL1KEEP LoadL1Temporal = 0, - /// - /// PLDL1STRM - /// + /// PLDL1STRM LoadL1NonTemporal = 1, - /// - /// PLDL2KEEP - /// + /// PLDL2KEEP LoadL2Temporal = 2, - /// - /// PLDL2STRM - /// + /// PLDL2STRM LoadL2NonTemporal = 3, - /// - /// PLDL3KEEP - /// + /// PLDL3KEEP LoadL3Temporal = 4, - /// - /// PLDL3STRM - /// + /// PLDL3STRM LoadL3NonTemporal = 5, - /// - /// PSTL1KEEP - /// + /// PSTL1KEEP StoreL1Temporal = 8, - /// - /// PSTL1STRM - /// + /// PSTL1STRM StoreL1NonTemporal = 9, - /// - /// PSTL2KEEP - /// + /// PSTL2KEEP StoreL2Temporal = 10, - /// - /// PSTL2STRM - /// + /// PSTL2STRM StoreL2NonTemporal = 11, - /// - /// PSTL3KEEP - /// + /// PSTL3KEEP StoreL3Temporal = 12, - /// - /// PSTL3STRM - /// + /// PSTL3STRM StoreL3NonTemporal = 13 }; } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Rdm.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Rdm.PlatformNotSupported.cs index 4d021f3f588..0864f9784b6 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Rdm.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Rdm.PlatformNotSupported.cs @@ -6,260 +6,265 @@ namespace System.Runtime.Intrinsics.Arm { - /// - /// This class provides access to the ARMv8.1-RDMA hardware instructions via intrinsics - /// + /// Provides access to the ARMv8.1-RDMA hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Rdm : AdvSimd { internal Rdm() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get => false; } + /// Provides access to the ARMv8.1-RDMA hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class Arm64 : AdvSimd.Arm64 { internal Arm64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } /// - /// int16_t vqrdmlahh_s16 (int16_t a, int16_t b, int16_t c) - /// A64: SQRDMLAH Hd, Hn, Hm + /// int16_t vqrdmlahh_s16 (int16_t a, int16_t b, int16_t c) + /// A64: SQRDMLAH Hd, Hn, Hm /// public static Vector64 MultiplyRoundedDoublingAndAddSaturateHighScalar(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqrdmlahs_s32 (int32_t a, int32_t b, int32_t c) - /// A64: SQRDMLAH Sd, Sn, Sm + /// int32_t vqrdmlahs_s32 (int32_t a, int32_t b, int32_t c) + /// A64: SQRDMLAH Sd, Sn, Sm /// public static Vector64 MultiplyRoundedDoublingAndAddSaturateHighScalar(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16_t vqrdmlshh_s16 (int16_t a, int16_t b, int16_t c) - /// A64: SQRDMLSH Hd, Hn, Hm + /// int16_t vqrdmlshh_s16 (int16_t a, int16_t b, int16_t c) + /// A64: SQRDMLSH Hd, Hn, Hm /// public static Vector64 MultiplyRoundedDoublingAndSubtractSaturateHighScalar(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqrdmlshs_s32 (int32_t a, int32_t b, int32_t c) - /// A64: SQRDMLSH Sd, Sn, Sm + /// int32_t vqrdmlshs_s32 (int32_t a, int32_t b, int32_t c) + /// A64: SQRDMLSH Sd, Sn, Sm /// public static Vector64 MultiplyRoundedDoublingAndSubtractSaturateHighScalar(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16_t vqrdmlahh_lane_s16 (int16_t a, int16_t b, int16x4_t v, const int lane) - /// A64: SQRDMLAH Hd, Hn, Vm.H[lane] + /// int16_t vqrdmlahh_lane_s16 (int16_t a, int16_t b, int16x4_t v, const int lane) + /// A64: SQRDMLAH Hd, Hn, Vm.H[lane] /// public static Vector64 MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16_t vqrdmlahh_laneq_s16 (int16_t a, int16_t b, int16x8_t v, const int lane) - /// A64: SQRDMLAH Hd, Hn, Vm.H[lane] + /// int16_t vqrdmlahh_laneq_s16 (int16_t a, int16_t b, int16x8_t v, const int lane) + /// A64: SQRDMLAH Hd, Hn, Vm.H[lane] /// public static Vector64 MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqrdmlahs_lane_s32 (int32_t a, int32_t b, int32x2_t v, const int lane) - /// A64: SQRDMLAH Sd, Sn, Vm.S[lane] + /// int32_t vqrdmlahs_lane_s32 (int32_t a, int32_t b, int32x2_t v, const int lane) + /// A64: SQRDMLAH Sd, Sn, Vm.S[lane] /// public static Vector64 MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqrdmlahs_laneq_s32 (int32_t a, int32_t b, int32x4_t v, const int lane) - /// A64: SQRDMLAH Sd, Sn, Vm.S[lane] + /// int32_t vqrdmlahs_laneq_s32 (int32_t a, int32_t b, int32x4_t v, const int lane) + /// A64: SQRDMLAH Sd, Sn, Vm.S[lane] /// public static Vector64 MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16_t vqrdmlshh_lane_s16 (int16_t a, int16_t b, int16x4_t v, const int lane) - /// A64: SQRDMLSH Hd, Hn, Vm.H[lane] + /// int16_t vqrdmlshh_lane_s16 (int16_t a, int16_t b, int16x4_t v, const int lane) + /// A64: SQRDMLSH Hd, Hn, Vm.H[lane] /// public static Vector64 MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16_t vqrdmlshh_laneq_s16 (int16_t a, int16_t b, int16x8_t v, const int lane) - /// A64: SQRDMLSH Hd, Hn, Vm.H[lane] + /// int16_t vqrdmlshh_laneq_s16 (int16_t a, int16_t b, int16x8_t v, const int lane) + /// A64: SQRDMLSH Hd, Hn, Vm.H[lane] /// public static Vector64 MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqrdmlshs_lane_s32 (int32_t a, int32_t b, int32x2_t v, const int lane) - /// A64: SQRDMLSH Sd, Sn, Vm.S[lane] + /// int32_t vqrdmlshs_lane_s32 (int32_t a, int32_t b, int32x2_t v, const int lane) + /// A64: SQRDMLSH Sd, Sn, Vm.S[lane] /// public static Vector64 MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32_t vqrdmlshs_laneq_s32 (int32_t a, int32_t b, int32x4_t v, const int lane) - /// A64: SQRDMLSH Sd, Sn, Vm.S[lane] + /// int32_t vqrdmlshs_laneq_s32 (int32_t a, int32_t b, int32x4_t v, const int lane) + /// A64: SQRDMLSH Sd, Sn, Vm.S[lane] /// public static Vector64 MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } } /// - /// int16x4_t vqrdmlah_s16 (int16x4_t a, int16x4_t b, int16x4_t c) - /// A32: VQRDMLAH.S16 Dd, Dn, Dm - /// A64: SQRDMLAH Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vqrdmlah_s16 (int16x4_t a, int16x4_t b, int16x4_t c) + /// A32: VQRDMLAH.S16 Dd, Dn, Dm + /// A64: SQRDMLAH Vd.4H, Vn.4H, Vm.4H /// public static Vector64 MultiplyRoundedDoublingAndAddSaturateHigh(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vqrdmlah_s32 (int32x2_t a, int32x2_t b, int32x2_t c) - /// A32: VQRDMLAH.S32 Dd, Dn, Dm - /// A64: SQRDMLAH Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vqrdmlah_s32 (int32x2_t a, int32x2_t b, int32x2_t c) + /// A32: VQRDMLAH.S32 Dd, Dn, Dm + /// A64: SQRDMLAH Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MultiplyRoundedDoublingAndAddSaturateHigh(Vector64 addend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vqrdmlahq_s16 (int16x8_t a, int16x8_t b, int16x8_t c) - /// A32: VQRDMLAH.S16 Qd, Qn, Qm - /// A64: SQRDMLAH Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vqrdmlahq_s16 (int16x8_t a, int16x8_t b, int16x8_t c) + /// A32: VQRDMLAH.S16 Qd, Qn, Qm + /// A64: SQRDMLAH Vd.8H, Vn.8H, Vm.8H /// public static Vector128 MultiplyRoundedDoublingAndAddSaturateHigh(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqrdmlahq_s32 (int32x4_t a, int32x4_t b, int32x4_t c) - /// A32: VQRDMLAH.S32 Qd, Qn, Qm - /// A64: SQRDMLAH Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vqrdmlahq_s32 (int32x4_t a, int32x4_t b, int32x4_t c) + /// A32: VQRDMLAH.S32 Qd, Qn, Qm + /// A64: SQRDMLAH Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MultiplyRoundedDoublingAndAddSaturateHigh(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vqrdmlsh_s16 (int16x4_t a, int16x4_t b, int16x4_t c) - /// A32: VQRDMLSH.S16 Dd, Dn, Dm - /// A64: SQRDMLSH Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vqrdmlsh_s16 (int16x4_t a, int16x4_t b, int16x4_t c) + /// A32: VQRDMLSH.S16 Dd, Dn, Dm + /// A64: SQRDMLSH Vd.4H, Vn.4H, Vm.4H /// public static Vector64 MultiplyRoundedDoublingAndSubtractSaturateHigh(Vector64 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vqrdmlsh_s32 (int32x2_t a, int32x2_t b, int32x2_t c) - /// A32: VQRDMLSH.S32 Dd, Dn, Dm - /// A64: SQRDMLSH Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vqrdmlsh_s32 (int32x2_t a, int32x2_t b, int32x2_t c) + /// A32: VQRDMLSH.S32 Dd, Dn, Dm + /// A64: SQRDMLSH Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MultiplyRoundedDoublingAndSubtractSaturateHigh(Vector64 minuend, Vector64 left, Vector64 right) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vqrdmlshq_s16 (int16x8_t a, int16x8_t b, int16x8_t c) - /// A32: VQRDMLSH.S16 Qd, Qn, Qm - /// A64: SQRDMLSH Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vqrdmlshq_s16 (int16x8_t a, int16x8_t b, int16x8_t c) + /// A32: VQRDMLSH.S16 Qd, Qn, Qm + /// A64: SQRDMLSH Vd.8H, Vn.8H, Vm.8H /// public static Vector128 MultiplyRoundedDoublingAndSubtractSaturateHigh(Vector128 minuend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqrdmlshq_s32 (int32x4_t a, int32x4_t b, int32x4_t c) - /// A32: VQRDMLSH.S32 Qd, Qn, Qm - /// A64: SQRDMLSH Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vqrdmlshq_s32 (int32x4_t a, int32x4_t b, int32x4_t c) + /// A32: VQRDMLSH.S32 Qd, Qn, Qm + /// A64: SQRDMLSH Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MultiplyRoundedDoublingAndSubtractSaturateHigh(Vector128 minuend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vqrdmlah_lane_s16 (int16x4_t a, int16x4_t b, int16x4_t v, const int lane) - /// A32: VQRDMLAH.S16 Dd, Dn, Dm[lane] - /// A64: SQRDMLAH Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vqrdmlah_lane_s16 (int16x4_t a, int16x4_t b, int16x4_t v, const int lane) + /// A32: VQRDMLAH.S16 Dd, Dn, Dm[lane] + /// A64: SQRDMLAH Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vqrdmlah_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane) - /// A32: VQRDMLAH.S16 Dd, Dn, Dm[lane] - /// A64: SQRDMLAH Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vqrdmlah_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane) + /// A32: VQRDMLAH.S16 Dd, Dn, Dm[lane] + /// A64: SQRDMLAH Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vqrdmlah_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane) - /// A32: VQRDMLAH.S32 Dd, Dn, Dm[lane] - /// A64: SQRDMLAH Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vqrdmlah_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane) + /// A32: VQRDMLAH.S32 Dd, Dn, Dm[lane] + /// A64: SQRDMLAH Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vqrdmlah_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane) - /// A32: VQRDMLAH.S32 Dd, Dn, Dm[lane] - /// A64: SQRDMLAH Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vqrdmlah_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane) + /// A32: VQRDMLAH.S32 Dd, Dn, Dm[lane] + /// A64: SQRDMLAH Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vqrdmlahq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane) - /// A32: VQRDMLAH.S16 Qd, Qn, Dm[lane] - /// A64: SQRDMLAH Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vqrdmlahq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane) + /// A32: VQRDMLAH.S16 Qd, Qn, Dm[lane] + /// A64: SQRDMLAH Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vqrdmlahq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane) - /// A32: VQRDMLAH.S16 Qd, Qn, Dm[lane] - /// A64: SQRDMLAH Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vqrdmlahq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane) + /// A32: VQRDMLAH.S16 Qd, Qn, Dm[lane] + /// A64: SQRDMLAH Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqrdmlahq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane) - /// A32: VQRDMLAH.S32 Qd, Qn, Dm[lane] - /// A64: SQRDMLAH Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vqrdmlahq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane) + /// A32: VQRDMLAH.S32 Qd, Qn, Dm[lane] + /// A64: SQRDMLAH Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqrdmlahq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane) - /// A32: VQRDMLAH.S32 Qd, Qn, Dm[lane] - /// A64: SQRDMLAH Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vqrdmlahq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane) + /// A32: VQRDMLAH.S32 Qd, Qn, Dm[lane] + /// A64: SQRDMLAH Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vqrdmlsh_lane_s16 (int16x4_t a, int16x4_t b, int16x4_t v, const int lane) - /// A32: VQRDMLSH.S16 Dd, Dn, Dm[lane] - /// A64: SQRDMLSH Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vqrdmlsh_lane_s16 (int16x4_t a, int16x4_t b, int16x4_t v, const int lane) + /// A32: VQRDMLSH.S16 Dd, Dn, Dm[lane] + /// A64: SQRDMLSH Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x4_t vqrdmlsh_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane) - /// A32: VQRDMLSH.S16 Dd, Dn, Dm[lane] - /// A64: SQRDMLSH Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vqrdmlsh_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane) + /// A32: VQRDMLSH.S16 Dd, Dn, Dm[lane] + /// A64: SQRDMLSH Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vqrdmlsh_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane) - /// A32: VQRDMLSH.S32 Dd, Dn, Dm[lane] - /// A64: SQRDMLSH Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vqrdmlsh_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane) + /// A32: VQRDMLSH.S32 Dd, Dn, Dm[lane] + /// A64: SQRDMLSH Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x2_t vqrdmlsh_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane) - /// A32: VQRDMLSH.S32 Dd, Dn, Dm[lane] - /// A64: SQRDMLSH Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vqrdmlsh_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane) + /// A32: VQRDMLSH.S32 Dd, Dn, Dm[lane] + /// A64: SQRDMLSH Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vqrdmlshq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane) - /// A32: VQRDMLSH.S16 Qd, Qn, Dm[lane] - /// A64: SQRDMLSH Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vqrdmlshq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane) + /// A32: VQRDMLSH.S16 Qd, Qn, Dm[lane] + /// A64: SQRDMLSH Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int16x8_t vqrdmlshq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane) - /// A32: VQRDMLSH.S16 Qd, Qn, Dm[lane] - /// A64: SQRDMLSH Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vqrdmlshq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane) + /// A32: VQRDMLSH.S16 Qd, Qn, Dm[lane] + /// A64: SQRDMLSH Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqrdmlshq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane) - /// A32: VQRDMLSH.S32 Qd, Qn, Dm[lane] - /// A64: SQRDMLSH Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vqrdmlshq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane) + /// A32: VQRDMLSH.S32 Qd, Qn, Dm[lane] + /// A64: SQRDMLSH Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// int32x4_t vqrdmlshq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane) - /// A32: VQRDMLSH.S32 Qd, Qn, Dm[lane] - /// A64: SQRDMLSH Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vqrdmlshq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane) + /// A32: VQRDMLSH.S32 Qd, Qn, Dm[lane] + /// A64: SQRDMLSH Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Rdm.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Rdm.cs index 200aaa9bcf2..ff6065fe2df 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Rdm.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Rdm.cs @@ -6,262 +6,267 @@ namespace System.Runtime.Intrinsics.Arm { - /// - /// This class provides access to the ARMv8.1-RDMA hardware instructions via intrinsics - /// + /// Provides access to the ARMv8.1-RDMA hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Rdm : AdvSimd { internal Rdm() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the ARMv8.1-RDMA hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class Arm64 : AdvSimd.Arm64 { internal Arm64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } /// - /// int16_t vqrdmlahh_s16 (int16_t a, int16_t b, int16_t c) - /// A64: SQRDMLAH Hd, Hn, Hm + /// int16_t vqrdmlahh_s16 (int16_t a, int16_t b, int16_t c) + /// A64: SQRDMLAH Hd, Hn, Hm /// public static Vector64 MultiplyRoundedDoublingAndAddSaturateHighScalar(Vector64 addend, Vector64 left, Vector64 right) => MultiplyRoundedDoublingAndAddSaturateHighScalar(addend, left, right); /// - /// int32_t vqrdmlahs_s32 (int32_t a, int32_t b, int32_t c) - /// A64: SQRDMLAH Sd, Sn, Sm + /// int32_t vqrdmlahs_s32 (int32_t a, int32_t b, int32_t c) + /// A64: SQRDMLAH Sd, Sn, Sm /// public static Vector64 MultiplyRoundedDoublingAndAddSaturateHighScalar(Vector64 addend, Vector64 left, Vector64 right) => MultiplyRoundedDoublingAndAddSaturateHighScalar(addend, left, right); /// - /// int16_t vqrdmlshh_s16 (int16_t a, int16_t b, int16_t c) - /// A64: SQRDMLSH Hd, Hn, Hm + /// int16_t vqrdmlshh_s16 (int16_t a, int16_t b, int16_t c) + /// A64: SQRDMLSH Hd, Hn, Hm /// public static Vector64 MultiplyRoundedDoublingAndSubtractSaturateHighScalar(Vector64 addend, Vector64 left, Vector64 right) => MultiplyRoundedDoublingAndSubtractSaturateHighScalar(addend, left, right); /// - /// int32_t vqrdmlshs_s32 (int32_t a, int32_t b, int32_t c) - /// A64: SQRDMLSH Sd, Sn, Sm + /// int32_t vqrdmlshs_s32 (int32_t a, int32_t b, int32_t c) + /// A64: SQRDMLSH Sd, Sn, Sm /// public static Vector64 MultiplyRoundedDoublingAndSubtractSaturateHighScalar(Vector64 addend, Vector64 left, Vector64 right) => MultiplyRoundedDoublingAndSubtractSaturateHighScalar(addend, left, right); /// - /// int16_t vqrdmlahh_lane_s16 (int16_t a, int16_t b, int16x4_t v, const int lane) - /// A64: SQRDMLAH Hd, Hn, Vm.H[lane] + /// int16_t vqrdmlahh_lane_s16 (int16_t a, int16_t b, int16x4_t v, const int lane) + /// A64: SQRDMLAH Hd, Hn, Vm.H[lane] /// public static Vector64 MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex); /// - /// int16_t vqrdmlahh_laneq_s16 (int16_t a, int16_t b, int16x8_t v, const int lane) - /// A64: SQRDMLAH Hd, Hn, Vm.H[lane] + /// int16_t vqrdmlahh_laneq_s16 (int16_t a, int16_t b, int16x8_t v, const int lane) + /// A64: SQRDMLAH Hd, Hn, Vm.H[lane] /// public static Vector64 MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex); /// - /// int32_t vqrdmlahs_lane_s32 (int32_t a, int32_t b, int32x2_t v, const int lane) - /// A64: SQRDMLAH Sd, Sn, Vm.S[lane] + /// int32_t vqrdmlahs_lane_s32 (int32_t a, int32_t b, int32x2_t v, const int lane) + /// A64: SQRDMLAH Sd, Sn, Vm.S[lane] /// public static Vector64 MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex); /// - /// int32_t vqrdmlahs_laneq_s32 (int32_t a, int32_t b, int32x4_t v, const int lane) - /// A64: SQRDMLAH Sd, Sn, Vm.S[lane] + /// int32_t vqrdmlahs_laneq_s32 (int32_t a, int32_t b, int32x4_t v, const int lane) + /// A64: SQRDMLAH Sd, Sn, Vm.S[lane] /// public static Vector64 MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex); /// - /// int16_t vqrdmlshh_lane_s16 (int16_t a, int16_t b, int16x4_t v, const int lane) - /// A64: SQRDMLSH Hd, Hn, Vm.H[lane] + /// int16_t vqrdmlshh_lane_s16 (int16_t a, int16_t b, int16x4_t v, const int lane) + /// A64: SQRDMLSH Hd, Hn, Vm.H[lane] /// public static Vector64 MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex); /// - /// int16_t vqrdmlshh_laneq_s16 (int16_t a, int16_t b, int16x8_t v, const int lane) - /// A64: SQRDMLSH Hd, Hn, Vm.H[lane] + /// int16_t vqrdmlshh_laneq_s16 (int16_t a, int16_t b, int16x8_t v, const int lane) + /// A64: SQRDMLSH Hd, Hn, Vm.H[lane] /// public static Vector64 MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex); /// - /// int32_t vqrdmlshs_lane_s32 (int32_t a, int32_t b, int32x2_t v, const int lane) - /// A64: SQRDMLSH Sd, Sn, Vm.S[lane] + /// int32_t vqrdmlshs_lane_s32 (int32_t a, int32_t b, int32x2_t v, const int lane) + /// A64: SQRDMLSH Sd, Sn, Vm.S[lane] /// public static Vector64 MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex); /// - /// int32_t vqrdmlshs_laneq_s32 (int32_t a, int32_t b, int32x4_t v, const int lane) - /// A64: SQRDMLSH Sd, Sn, Vm.S[lane] + /// int32_t vqrdmlshs_laneq_s32 (int32_t a, int32_t b, int32x4_t v, const int lane) + /// A64: SQRDMLSH Sd, Sn, Vm.S[lane] /// public static Vector64 MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingScalarBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex); } /// - /// int16x4_t vqrdmlah_s16 (int16x4_t a, int16x4_t b, int16x4_t c) - /// A32: VQRDMLAH.S16 Dd, Dn, Dm - /// A64: SQRDMLAH Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vqrdmlah_s16 (int16x4_t a, int16x4_t b, int16x4_t c) + /// A32: VQRDMLAH.S16 Dd, Dn, Dm + /// A64: SQRDMLAH Vd.4H, Vn.4H, Vm.4H /// public static Vector64 MultiplyRoundedDoublingAndAddSaturateHigh(Vector64 addend, Vector64 left, Vector64 right) => MultiplyRoundedDoublingAndAddSaturateHigh(addend, left, right); /// - /// int32x2_t vqrdmlah_s32 (int32x2_t a, int32x2_t b, int32x2_t c) - /// A32: VQRDMLAH.S32 Dd, Dn, Dm - /// A64: SQRDMLAH Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vqrdmlah_s32 (int32x2_t a, int32x2_t b, int32x2_t c) + /// A32: VQRDMLAH.S32 Dd, Dn, Dm + /// A64: SQRDMLAH Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MultiplyRoundedDoublingAndAddSaturateHigh(Vector64 addend, Vector64 left, Vector64 right) => MultiplyRoundedDoublingAndAddSaturateHigh(addend, left, right); /// - /// int16x8_t vqrdmlahq_s16 (int16x8_t a, int16x8_t b, int16x8_t c) - /// A32: VQRDMLAH.S16 Qd, Qn, Qm - /// A64: SQRDMLAH Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vqrdmlahq_s16 (int16x8_t a, int16x8_t b, int16x8_t c) + /// A32: VQRDMLAH.S16 Qd, Qn, Qm + /// A64: SQRDMLAH Vd.8H, Vn.8H, Vm.8H /// public static Vector128 MultiplyRoundedDoublingAndAddSaturateHigh(Vector128 addend, Vector128 left, Vector128 right) => MultiplyRoundedDoublingAndAddSaturateHigh(addend, left, right); /// - /// int32x4_t vqrdmlahq_s32 (int32x4_t a, int32x4_t b, int32x4_t c) - /// A32: VQRDMLAH.S32 Qd, Qn, Qm - /// A64: SQRDMLAH Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vqrdmlahq_s32 (int32x4_t a, int32x4_t b, int32x4_t c) + /// A32: VQRDMLAH.S32 Qd, Qn, Qm + /// A64: SQRDMLAH Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MultiplyRoundedDoublingAndAddSaturateHigh(Vector128 addend, Vector128 left, Vector128 right) => MultiplyRoundedDoublingAndAddSaturateHigh(addend, left, right); /// - /// int16x4_t vqrdmlsh_s16 (int16x4_t a, int16x4_t b, int16x4_t c) - /// A32: VQRDMLSH.S16 Dd, Dn, Dm - /// A64: SQRDMLSH Vd.4H, Vn.4H, Vm.4H + /// int16x4_t vqrdmlsh_s16 (int16x4_t a, int16x4_t b, int16x4_t c) + /// A32: VQRDMLSH.S16 Dd, Dn, Dm + /// A64: SQRDMLSH Vd.4H, Vn.4H, Vm.4H /// public static Vector64 MultiplyRoundedDoublingAndSubtractSaturateHigh(Vector64 minuend, Vector64 left, Vector64 right) => MultiplyRoundedDoublingAndSubtractSaturateHigh(minuend, left, right); /// - /// int32x2_t vqrdmlsh_s32 (int32x2_t a, int32x2_t b, int32x2_t c) - /// A32: VQRDMLSH.S32 Dd, Dn, Dm - /// A64: SQRDMLSH Vd.2S, Vn.2S, Vm.2S + /// int32x2_t vqrdmlsh_s32 (int32x2_t a, int32x2_t b, int32x2_t c) + /// A32: VQRDMLSH.S32 Dd, Dn, Dm + /// A64: SQRDMLSH Vd.2S, Vn.2S, Vm.2S /// public static Vector64 MultiplyRoundedDoublingAndSubtractSaturateHigh(Vector64 minuend, Vector64 left, Vector64 right) => MultiplyRoundedDoublingAndSubtractSaturateHigh(minuend, left, right); /// - /// int16x8_t vqrdmlshq_s16 (int16x8_t a, int16x8_t b, int16x8_t c) - /// A32: VQRDMLSH.S16 Qd, Qn, Qm - /// A64: SQRDMLSH Vd.8H, Vn.8H, Vm.8H + /// int16x8_t vqrdmlshq_s16 (int16x8_t a, int16x8_t b, int16x8_t c) + /// A32: VQRDMLSH.S16 Qd, Qn, Qm + /// A64: SQRDMLSH Vd.8H, Vn.8H, Vm.8H /// public static Vector128 MultiplyRoundedDoublingAndSubtractSaturateHigh(Vector128 minuend, Vector128 left, Vector128 right) => MultiplyRoundedDoublingAndSubtractSaturateHigh(minuend, left, right); /// - /// int32x4_t vqrdmlshq_s32 (int32x4_t a, int32x4_t b, int32x4_t c) - /// A32: VQRDMLSH.S32 Qd, Qn, Qm - /// A64: SQRDMLSH Vd.4S, Vn.4S, Vm.4S + /// int32x4_t vqrdmlshq_s32 (int32x4_t a, int32x4_t b, int32x4_t c) + /// A32: VQRDMLSH.S32 Qd, Qn, Qm + /// A64: SQRDMLSH Vd.4S, Vn.4S, Vm.4S /// public static Vector128 MultiplyRoundedDoublingAndSubtractSaturateHigh(Vector128 minuend, Vector128 left, Vector128 right) => MultiplyRoundedDoublingAndSubtractSaturateHigh(minuend, left, right); /// - /// int16x4_t vqrdmlah_lane_s16 (int16x4_t a, int16x4_t b, int16x4_t v, const int lane) - /// A32: VQRDMLAH.S16 Dd, Dn, Dm[lane] - /// A64: SQRDMLAH Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vqrdmlah_lane_s16 (int16x4_t a, int16x4_t b, int16x4_t v, const int lane) + /// A32: VQRDMLAH.S16 Dd, Dn, Dm[lane] + /// A64: SQRDMLAH Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex); /// - /// int16x4_t vqrdmlah_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane) - /// A32: VQRDMLAH.S16 Dd, Dn, Dm[lane] - /// A64: SQRDMLAH Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vqrdmlah_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane) + /// A32: VQRDMLAH.S16 Dd, Dn, Dm[lane] + /// A64: SQRDMLAH Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex); /// - /// int32x2_t vqrdmlah_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane) - /// A32: VQRDMLAH.S32 Dd, Dn, Dm[lane] - /// A64: SQRDMLAH Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vqrdmlah_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane) + /// A32: VQRDMLAH.S32 Dd, Dn, Dm[lane] + /// A64: SQRDMLAH Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64 addend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex); /// - /// int32x2_t vqrdmlah_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane) - /// A32: VQRDMLAH.S32 Dd, Dn, Dm[lane] - /// A64: SQRDMLAH Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vqrdmlah_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane) + /// A32: VQRDMLAH.S32 Dd, Dn, Dm[lane] + /// A64: SQRDMLAH Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector64 addend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex); /// - /// int16x8_t vqrdmlahq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane) - /// A32: VQRDMLAH.S16 Qd, Qn, Dm[lane] - /// A64: SQRDMLAH Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vqrdmlahq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane) + /// A32: VQRDMLAH.S16 Qd, Qn, Dm[lane] + /// A64: SQRDMLAH Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex); /// - /// int16x8_t vqrdmlahq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane) - /// A32: VQRDMLAH.S16 Qd, Qn, Dm[lane] - /// A64: SQRDMLAH Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vqrdmlahq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane) + /// A32: VQRDMLAH.S16 Qd, Qn, Dm[lane] + /// A64: SQRDMLAH Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex); /// - /// int32x4_t vqrdmlahq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane) - /// A32: VQRDMLAH.S32 Qd, Qn, Dm[lane] - /// A64: SQRDMLAH Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vqrdmlahq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane) + /// A32: VQRDMLAH.S32 Qd, Qn, Dm[lane] + /// A64: SQRDMLAH Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128 addend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex); /// - /// int32x4_t vqrdmlahq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane) - /// A32: VQRDMLAH.S32 Qd, Qn, Dm[lane] - /// A64: SQRDMLAH Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vqrdmlahq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane) + /// A32: VQRDMLAH.S32 Qd, Qn, Dm[lane] + /// A64: SQRDMLAH Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(Vector128 addend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndAddSaturateHigh(addend, left, right, rightIndex); /// - /// int16x4_t vqrdmlsh_lane_s16 (int16x4_t a, int16x4_t b, int16x4_t v, const int lane) - /// A32: VQRDMLSH.S16 Dd, Dn, Dm[lane] - /// A64: SQRDMLSH Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vqrdmlsh_lane_s16 (int16x4_t a, int16x4_t b, int16x4_t v, const int lane) + /// A32: VQRDMLSH.S16 Dd, Dn, Dm[lane] + /// A64: SQRDMLSH Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex); /// - /// int16x4_t vqrdmlsh_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane) - /// A32: VQRDMLSH.S16 Dd, Dn, Dm[lane] - /// A64: SQRDMLSH Vd.4H, Vn.4H, Vm.H[lane] + /// int16x4_t vqrdmlsh_laneq_s16 (int16x4_t a, int16x4_t b, int16x8_t v, const int lane) + /// A32: VQRDMLSH.S16 Dd, Dn, Dm[lane] + /// A64: SQRDMLSH Vd.4H, Vn.4H, Vm.H[lane] /// public static Vector64 MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex); /// - /// int32x2_t vqrdmlsh_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane) - /// A32: VQRDMLSH.S32 Dd, Dn, Dm[lane] - /// A64: SQRDMLSH Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vqrdmlsh_lane_s32 (int32x2_t a, int32x2_t b, int32x2_t v, const int lane) + /// A32: VQRDMLSH.S32 Dd, Dn, Dm[lane] + /// A64: SQRDMLSH Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64 minuend, Vector64 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex); /// - /// int32x2_t vqrdmlsh_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane) - /// A32: VQRDMLSH.S32 Dd, Dn, Dm[lane] - /// A64: SQRDMLSH Vd.2S, Vn.2S, Vm.S[lane] + /// int32x2_t vqrdmlsh_laneq_s32 (int32x2_t a, int32x2_t b, int32x4_t v, const int lane) + /// A32: VQRDMLSH.S32 Dd, Dn, Dm[lane] + /// A64: SQRDMLSH Vd.2S, Vn.2S, Vm.S[lane] /// public static Vector64 MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector64 minuend, Vector64 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex); /// - /// int16x8_t vqrdmlshq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane) - /// A32: VQRDMLSH.S16 Qd, Qn, Dm[lane] - /// A64: SQRDMLSH Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vqrdmlshq_lane_s16 (int16x8_t a, int16x8_t b, int16x4_t v, const int lane) + /// A32: VQRDMLSH.S16 Qd, Qn, Dm[lane] + /// A64: SQRDMLSH Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex); /// - /// int16x8_t vqrdmlshq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane) - /// A32: VQRDMLSH.S16 Qd, Qn, Dm[lane] - /// A64: SQRDMLSH Vd.8H, Vn.8H, Vm.H[lane] + /// int16x8_t vqrdmlshq_laneq_s16 (int16x8_t a, int16x8_t b, int16x8_t v, const int lane) + /// A32: VQRDMLSH.S16 Qd, Qn, Dm[lane] + /// A64: SQRDMLSH Vd.8H, Vn.8H, Vm.H[lane] /// public static Vector128 MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(7))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex); /// - /// int32x4_t vqrdmlshq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane) - /// A32: VQRDMLSH.S32 Qd, Qn, Dm[lane] - /// A64: SQRDMLSH Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vqrdmlshq_lane_s32 (int32x4_t a, int32x4_t b, int32x2_t v, const int lane) + /// A32: VQRDMLSH.S32 Qd, Qn, Dm[lane] + /// A64: SQRDMLSH Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128 minuend, Vector128 left, Vector64 right, [ConstantExpected(Max = (byte)(1))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex); /// - /// int32x4_t vqrdmlshq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane) - /// A32: VQRDMLSH.S32 Qd, Qn, Dm[lane] - /// A64: SQRDMLSH Vd.4S, Vn.4S, Vm.S[lane] + /// int32x4_t vqrdmlshq_laneq_s32 (int32x4_t a, int32x4_t b, int32x4_t v, const int lane) + /// A32: VQRDMLSH.S32 Qd, Qn, Dm[lane] + /// A64: SQRDMLSH Vd.4S, Vn.4S, Vm.S[lane] /// public static Vector128 MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(Vector128 minuend, Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(3))] byte rightIndex) => MultiplyRoundedDoublingBySelectedScalarAndSubtractSaturateHigh(minuend, left, right, rightIndex); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha1.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha1.PlatformNotSupported.cs index d56d7173ca8..c5e2465fa79 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha1.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha1.PlatformNotSupported.cs @@ -5,62 +5,67 @@ namespace System.Runtime.Intrinsics.Arm { - /// - /// This class provides access to the ARM SHA1 hardware instructions via intrinsics - /// + /// Provides access to the ARM SHA1 hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Sha1 : ArmBase { internal Sha1() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get => false; } + /// Provides access to the ARM SHA1 hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class Arm64 : ArmBase.Arm64 { internal Arm64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } } /// - /// uint32_t vsha1h_u32 (uint32_t hash_e) - /// A32: SHA1H.32 Qd, Qm - /// A64: SHA1H Sd, Sn + /// uint32_t vsha1h_u32 (uint32_t hash_e) + /// A32: SHA1H.32 Qd, Qm + /// A64: SHA1H Sd, Sn /// public static Vector64 FixedRotate(Vector64 hash_e) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vsha1cq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk) - /// A32: SHA1C.32 Qd, Qn, Qm - /// A64: SHA1C Qd, Sn, Vm.4S + /// uint32x4_t vsha1cq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk) + /// A32: SHA1C.32 Qd, Qn, Qm + /// A64: SHA1C Qd, Sn, Vm.4S /// public static Vector128 HashUpdateChoose(Vector128 hash_abcd, Vector64 hash_e, Vector128 wk) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vsha1mq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk) - /// A32: SHA1M.32 Qd, Qn, Qm - /// A64: SHA1M Qd, Sn, Vm.4S + /// uint32x4_t vsha1mq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk) + /// A32: SHA1M.32 Qd, Qn, Qm + /// A64: SHA1M Qd, Sn, Vm.4S /// public static Vector128 HashUpdateMajority(Vector128 hash_abcd, Vector64 hash_e, Vector128 wk) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vsha1pq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk) - /// A32: SHA1P.32 Qd, Qn, Qm - /// A64: SHA1P Qd, Sn, Vm.4S + /// uint32x4_t vsha1pq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk) + /// A32: SHA1P.32 Qd, Qn, Qm + /// A64: SHA1P Qd, Sn, Vm.4S /// public static Vector128 HashUpdateParity(Vector128 hash_abcd, Vector64 hash_e, Vector128 wk) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vsha1su0q_u32 (uint32x4_t w0_3, uint32x4_t w4_7, uint32x4_t w8_11) - /// A32: SHA1SU0.32 Qd, Qn, Qm - /// A64: SHA1SU0 Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vsha1su0q_u32 (uint32x4_t w0_3, uint32x4_t w4_7, uint32x4_t w8_11) + /// A32: SHA1SU0.32 Qd, Qn, Qm + /// A64: SHA1SU0 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ScheduleUpdate0(Vector128 w0_3, Vector128 w4_7, Vector128 w8_11) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vsha1su1q_u32 (uint32x4_t tw0_3, uint32x4_t w12_15) - /// A32: SHA1SU1.32 Qd, Qm - /// A64: SHA1SU1 Vd.4S, Vn.4S + /// uint32x4_t vsha1su1q_u32 (uint32x4_t tw0_3, uint32x4_t w12_15) + /// A32: SHA1SU1.32 Qd, Qm + /// A64: SHA1SU1 Vd.4S, Vn.4S /// public static Vector128 ScheduleUpdate1(Vector128 tw0_3, Vector128 w12_15) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha1.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha1.cs index 68e2e6292fe..eb09064d581 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha1.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha1.cs @@ -5,64 +5,69 @@ namespace System.Runtime.Intrinsics.Arm { - /// - /// This class provides access to the ARM SHA1 hardware instructions via intrinsics - /// + /// Provides access to the ARM SHA1 hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Sha1 : ArmBase { internal Sha1() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the ARM SHA1 hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class Arm64 : ArmBase.Arm64 { internal Arm64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } } /// - /// uint32_t vsha1h_u32 (uint32_t hash_e) - /// A32: SHA1H.32 Qd, Qm - /// A64: SHA1H Sd, Sn + /// uint32_t vsha1h_u32 (uint32_t hash_e) + /// A32: SHA1H.32 Qd, Qm + /// A64: SHA1H Sd, Sn /// public static Vector64 FixedRotate(Vector64 hash_e) => FixedRotate(hash_e); /// - /// uint32x4_t vsha1cq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk) - /// A32: SHA1C.32 Qd, Qn, Qm - /// A64: SHA1C Qd, Sn, Vm.4S + /// uint32x4_t vsha1cq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk) + /// A32: SHA1C.32 Qd, Qn, Qm + /// A64: SHA1C Qd, Sn, Vm.4S /// public static Vector128 HashUpdateChoose(Vector128 hash_abcd, Vector64 hash_e, Vector128 wk) => HashUpdateChoose(hash_abcd, hash_e, wk); /// - /// uint32x4_t vsha1mq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk) - /// A32: SHA1M.32 Qd, Qn, Qm - /// A64: SHA1M Qd, Sn, Vm.4S + /// uint32x4_t vsha1mq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk) + /// A32: SHA1M.32 Qd, Qn, Qm + /// A64: SHA1M Qd, Sn, Vm.4S /// public static Vector128 HashUpdateMajority(Vector128 hash_abcd, Vector64 hash_e, Vector128 wk) => HashUpdateMajority(hash_abcd, hash_e, wk); /// - /// uint32x4_t vsha1pq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk) - /// A32: SHA1P.32 Qd, Qn, Qm - /// A64: SHA1P Qd, Sn, Vm.4S + /// uint32x4_t vsha1pq_u32 (uint32x4_t hash_abcd, uint32_t hash_e, uint32x4_t wk) + /// A32: SHA1P.32 Qd, Qn, Qm + /// A64: SHA1P Qd, Sn, Vm.4S /// public static Vector128 HashUpdateParity(Vector128 hash_abcd, Vector64 hash_e, Vector128 wk) => HashUpdateParity(hash_abcd, hash_e, wk); /// - /// uint32x4_t vsha1su0q_u32 (uint32x4_t w0_3, uint32x4_t w4_7, uint32x4_t w8_11) - /// A32: SHA1SU0.32 Qd, Qn, Qm - /// A64: SHA1SU0 Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vsha1su0q_u32 (uint32x4_t w0_3, uint32x4_t w4_7, uint32x4_t w8_11) + /// A32: SHA1SU0.32 Qd, Qn, Qm + /// A64: SHA1SU0 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ScheduleUpdate0(Vector128 w0_3, Vector128 w4_7, Vector128 w8_11) => ScheduleUpdate0(w0_3, w4_7, w8_11); /// - /// uint32x4_t vsha1su1q_u32 (uint32x4_t tw0_3, uint32x4_t w12_15) - /// A32: SHA1SU1.32 Qd, Qm - /// A64: SHA1SU1 Vd.4S, Vn.4S + /// uint32x4_t vsha1su1q_u32 (uint32x4_t tw0_3, uint32x4_t w12_15) + /// A32: SHA1SU1.32 Qd, Qm + /// A64: SHA1SU1 Vd.4S, Vn.4S /// public static Vector128 ScheduleUpdate1(Vector128 tw0_3, Vector128 w12_15) => ScheduleUpdate1(tw0_3, w12_15); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha256.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha256.PlatformNotSupported.cs index 1869dfb3f6d..efa042dad90 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha256.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha256.PlatformNotSupported.cs @@ -5,48 +5,53 @@ namespace System.Runtime.Intrinsics.Arm { - /// - /// This class provides access to the ARM SHA256 hardware instructions via intrinsics - /// + /// Provides access to the ARM SHA256 hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Sha256 : ArmBase { internal Sha256() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get => false; } + /// Provides access to the ARM SHA256 hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class Arm64 : ArmBase.Arm64 { internal Arm64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } } /// - /// uint32x4_t vsha256hq_u32 (uint32x4_t hash_abcd, uint32x4_t hash_efgh, uint32x4_t wk) - /// A32: SHA256H.32 Qd, Qn, Qm - /// A64: SHA256H Qd, Qn, Vm.4S + /// uint32x4_t vsha256hq_u32 (uint32x4_t hash_abcd, uint32x4_t hash_efgh, uint32x4_t wk) + /// A32: SHA256H.32 Qd, Qn, Qm + /// A64: SHA256H Qd, Qn, Vm.4S /// public static Vector128 HashUpdate1(Vector128 hash_abcd, Vector128 hash_efgh, Vector128 wk) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vsha256h2q_u32 (uint32x4_t hash_efgh, uint32x4_t hash_abcd, uint32x4_t wk) - /// A32: SHA256H2.32 Qd, Qn, Qm - /// A64: SHA256H2 Qd, Qn, Vm.4S + /// uint32x4_t vsha256h2q_u32 (uint32x4_t hash_efgh, uint32x4_t hash_abcd, uint32x4_t wk) + /// A32: SHA256H2.32 Qd, Qn, Qm + /// A64: SHA256H2 Qd, Qn, Vm.4S /// public static Vector128 HashUpdate2(Vector128 hash_efgh, Vector128 hash_abcd, Vector128 wk) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vsha256su0q_u32 (uint32x4_t w0_3, uint32x4_t w4_7) - /// A32: SHA256SU0.32 Qd, Qm - /// A64: SHA256SU0 Vd.4S, Vn.4S + /// uint32x4_t vsha256su0q_u32 (uint32x4_t w0_3, uint32x4_t w4_7) + /// A32: SHA256SU0.32 Qd, Qm + /// A64: SHA256SU0 Vd.4S, Vn.4S /// public static Vector128 ScheduleUpdate0(Vector128 w0_3, Vector128 w4_7) { throw new PlatformNotSupportedException(); } /// - /// uint32x4_t vsha256su1q_u32 (uint32x4_t w0_3, uint32x4_t w8_11, uint32x4_t w12_15) - /// A32: SHA256SU1.32 Qd, Qn, Qm - /// A64: SHA256SU1 Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vsha256su1q_u32 (uint32x4_t w0_3, uint32x4_t w8_11, uint32x4_t w12_15) + /// A32: SHA256SU1.32 Qd, Qn, Qm + /// A64: SHA256SU1 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ScheduleUpdate1(Vector128 w0_3, Vector128 w8_11, Vector128 w12_15) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha256.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha256.cs index 44167055b40..035314f40e8 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha256.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sha256.cs @@ -5,50 +5,55 @@ namespace System.Runtime.Intrinsics.Arm { - /// - /// This class provides access to the ARM SHA256 hardware instructions via intrinsics - /// + /// Provides access to the ARM SHA256 hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Sha256 : ArmBase { internal Sha256() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the ARM SHA256 hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class Arm64 : ArmBase.Arm64 { internal Arm64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } } /// - /// uint32x4_t vsha256hq_u32 (uint32x4_t hash_abcd, uint32x4_t hash_efgh, uint32x4_t wk) - /// A32: SHA256H.32 Qd, Qn, Qm - /// A64: SHA256H Qd, Qn, Vm.4S + /// uint32x4_t vsha256hq_u32 (uint32x4_t hash_abcd, uint32x4_t hash_efgh, uint32x4_t wk) + /// A32: SHA256H.32 Qd, Qn, Qm + /// A64: SHA256H Qd, Qn, Vm.4S /// public static Vector128 HashUpdate1(Vector128 hash_abcd, Vector128 hash_efgh, Vector128 wk) => HashUpdate1(hash_abcd, hash_efgh, wk); /// - /// uint32x4_t vsha256h2q_u32 (uint32x4_t hash_efgh, uint32x4_t hash_abcd, uint32x4_t wk) - /// A32: SHA256H2.32 Qd, Qn, Qm - /// A64: SHA256H2 Qd, Qn, Vm.4S + /// uint32x4_t vsha256h2q_u32 (uint32x4_t hash_efgh, uint32x4_t hash_abcd, uint32x4_t wk) + /// A32: SHA256H2.32 Qd, Qn, Qm + /// A64: SHA256H2 Qd, Qn, Vm.4S /// public static Vector128 HashUpdate2(Vector128 hash_efgh, Vector128 hash_abcd, Vector128 wk) => HashUpdate2(hash_efgh, hash_abcd, wk); /// - /// uint32x4_t vsha256su0q_u32 (uint32x4_t w0_3, uint32x4_t w4_7) - /// A32: SHA256SU0.32 Qd, Qm - /// A64: SHA256SU0 Vd.4S, Vn.4S + /// uint32x4_t vsha256su0q_u32 (uint32x4_t w0_3, uint32x4_t w4_7) + /// A32: SHA256SU0.32 Qd, Qm + /// A64: SHA256SU0 Vd.4S, Vn.4S /// public static Vector128 ScheduleUpdate0(Vector128 w0_3, Vector128 w4_7) => ScheduleUpdate0(w0_3, w4_7); /// - /// uint32x4_t vsha256su1q_u32 (uint32x4_t w0_3, uint32x4_t w8_11, uint32x4_t w12_15) - /// A32: SHA256SU1.32 Qd, Qn, Qm - /// A64: SHA256SU1 Vd.4S, Vn.4S, Vm.4S + /// uint32x4_t vsha256su1q_u32 (uint32x4_t w0_3, uint32x4_t w8_11, uint32x4_t w12_15) + /// A32: SHA256SU1.32 Qd, Qn, Qm + /// A64: SHA256SU1 Vd.4S, Vn.4S, Vm.4S /// public static Vector128 ScheduleUpdate1(Vector128 w0_3, Vector128 w8_11, Vector128 w12_15) => ScheduleUpdate1(w0_3, w8_11, w12_15); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.PlatformNotSupported.cs index bcc541474ee..ae59a6fb4f8 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.PlatformNotSupported.cs @@ -8,9 +8,7 @@ namespace System.Runtime.Intrinsics.Arm { - /// - /// This class provides access to the ARM SVE hardware instructions via intrinsics - /// + /// Provides access to the ARM SVE hardware instructions via intrinsics. [CLSCompliant(false)] [Experimental(Experimentals.ArmSveDiagId, UrlFormat = Experimentals.SharedUrlFormat)] #if SYSTEM_PRIVATE_CORELIB @@ -22,12 +20,19 @@ abstract class Sve : AdvSimd { internal Sve() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } + /// Provides access to the ARM SVE hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class Arm64 : AdvSimd.Arm64 { internal Arm64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } } @@ -35,3200 +40,3170 @@ internal Arm64() { } // Absolute value /// - /// svfloat64_t svabs[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) - /// svfloat64_t svabs[_f64]_x(svbool_t pg, svfloat64_t op) - /// svfloat64_t svabs[_f64]_z(svbool_t pg, svfloat64_t op) - /// FABS Ztied.D, Pg/M, Zop.D - /// FABS Ztied.D, Pg/M, Ztied.D + /// svfloat64_t svabs[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) + /// svfloat64_t svabs[_f64]_x(svbool_t pg, svfloat64_t op) + /// svfloat64_t svabs[_f64]_z(svbool_t pg, svfloat64_t op) + /// FABS Ztied.D, Pg/M, Zop.D + /// FABS Ztied.D, Pg/M, Ztied.D /// - public static unsafe Vector Abs(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Abs(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svabs[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) - /// svint16_t svabs[_s16]_x(svbool_t pg, svint16_t op) - /// svint16_t svabs[_s16]_z(svbool_t pg, svint16_t op) - /// ABS Zresult.H, Pg/M, Zop.H + /// svint16_t svabs[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) + /// svint16_t svabs[_s16]_x(svbool_t pg, svint16_t op) + /// svint16_t svabs[_s16]_z(svbool_t pg, svint16_t op) + /// ABS Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector Abs(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Abs(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svabs[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) - /// svint32_t svabs[_s32]_x(svbool_t pg, svint32_t op) - /// svint32_t svabs[_s32]_z(svbool_t pg, svint32_t op) - /// ABS Zresult.S, Pg/M, Zop.S + /// svint32_t svabs[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) + /// svint32_t svabs[_s32]_x(svbool_t pg, svint32_t op) + /// svint32_t svabs[_s32]_z(svbool_t pg, svint32_t op) + /// ABS Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector Abs(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Abs(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svabs[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) - /// svint64_t svabs[_s64]_x(svbool_t pg, svint64_t op) - /// svint64_t svabs[_s64]_z(svbool_t pg, svint64_t op) - /// ABS Zresult.D, Pg/M, Zop.D + /// svint64_t svabs[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) + /// svint64_t svabs[_s64]_x(svbool_t pg, svint64_t op) + /// svint64_t svabs[_s64]_z(svbool_t pg, svint64_t op) + /// ABS Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector Abs(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Abs(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svabs[_s8]_m(svint8_t inactive, svbool_t pg, svint8_t op) - /// svint8_t svabs[_s8]_x(svbool_t pg, svint8_t op) - /// svint8_t svabs[_s8]_z(svbool_t pg, svint8_t op) - /// ABS Zresult.B, Pg/M, Zop.B + /// svint8_t svabs[_s8]_m(svint8_t inactive, svbool_t pg, svint8_t op) + /// svint8_t svabs[_s8]_x(svbool_t pg, svint8_t op) + /// svint8_t svabs[_s8]_z(svbool_t pg, svint8_t op) + /// ABS Zresult.B, Pg/M, Zop.B /// - public static unsafe Vector Abs(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Abs(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svabs[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) - /// svfloat32_t svabs[_f32]_x(svbool_t pg, svfloat32_t op) - /// svfloat32_t svabs[_f32]_z(svbool_t pg, svfloat32_t op) - /// FABS Zresult.S, Pg/M, Zop.S + /// svfloat32_t svabs[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) + /// svfloat32_t svabs[_f32]_x(svbool_t pg, svfloat32_t op) + /// svfloat32_t svabs[_f32]_z(svbool_t pg, svfloat32_t op) + /// FABS Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector Abs(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Abs(Vector value) { throw new PlatformNotSupportedException(); } // Absolute compare greater than /// - /// svbool_t svacgt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FACGT Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svacgt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FACGT Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector AbsoluteCompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AbsoluteCompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svacgt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FACGT Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svacgt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FACGT Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector AbsoluteCompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AbsoluteCompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Absolute compare greater than or equal to /// - /// svbool_t svacge[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FACGE Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svacge[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FACGE Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector AbsoluteCompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AbsoluteCompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svacge[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FACGE Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svacge[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FACGE Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector AbsoluteCompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AbsoluteCompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Absolute compare less than /// - /// svbool_t svaclt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FACLT Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svaclt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FACLT Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector AbsoluteCompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AbsoluteCompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svaclt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FACLT Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svaclt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FACLT Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector AbsoluteCompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AbsoluteCompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Absolute compare less than or equal to /// - /// svbool_t svacle[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FACLE Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svacle[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FACLE Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector AbsoluteCompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AbsoluteCompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svacle[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FACLE Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svacle[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FACLE Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector AbsoluteCompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AbsoluteCompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Absolute difference /// - /// svuint8_t svabd[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svabd[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// UABD Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// svuint8_t svabd[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svabd[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// UABD Ztied1.B, Pg/M, Ztied1.B, Zop2.B /// - public static unsafe Vector AbsoluteDifference(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AbsoluteDifference(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svabd[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svabd[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svabd[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FABD Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svfloat64_t svabd[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svabd[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svabd[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FABD Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector AbsoluteDifference(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AbsoluteDifference(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svabd[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svabd[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svabd[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) - /// SABD Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// svint16_t svabd[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svabd[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svabd[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) + /// SABD Ztied1.H, Pg/M, Ztied1.H, Zop2.H /// - public static unsafe Vector AbsoluteDifference(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AbsoluteDifference(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svabd[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svabd[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svabd[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) - /// SABD Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svint32_t svabd[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svabd[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svabd[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) + /// SABD Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector AbsoluteDifference(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AbsoluteDifference(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svabd[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svabd[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svabd[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) - /// SABD Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svint64_t svabd[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svabd[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svabd[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) + /// SABD Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector AbsoluteDifference(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AbsoluteDifference(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svabd[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svabd[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svabd[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) - /// SABD Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// svint8_t svabd[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svabd[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svabd[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) + /// SABD Ztied1.B, Pg/M, Ztied1.B, Zop2.B /// - public static unsafe Vector AbsoluteDifference(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AbsoluteDifference(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svabd[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svabd[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svabd[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FABD Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svfloat32_t svabd[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svabd[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svabd[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FABD Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector AbsoluteDifference(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AbsoluteDifference(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svabd[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svabd[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svabd[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// UABD Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// svuint16_t svabd[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svabd[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svabd[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// UABD Ztied1.H, Pg/M, Ztied1.H, Zop2.H /// - public static unsafe Vector AbsoluteDifference(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AbsoluteDifference(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svabd[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svabd[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svabd[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// UABD Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svuint32_t svabd[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svabd[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svabd[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// UABD Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector AbsoluteDifference(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AbsoluteDifference(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svabd[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svabd[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svabd[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// UABD Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svuint64_t svabd[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svabd[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svabd[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// UABD Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector AbsoluteDifference(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AbsoluteDifference(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Add /// - /// svuint8_t svadd[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svadd[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svadd[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// ADD Zresult.B, Zop1.B, Zop2.B + /// svuint8_t svadd[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svadd[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svadd[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// ADD Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector Add(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Add(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svadd[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svadd[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svadd[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FADD Zresult.D, Zop1.D, Zop2.D + /// svfloat64_t svadd[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svadd[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svadd[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FADD Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector Add(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Add(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svadd[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svadd[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svadd[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) - /// ADD Zresult.H, Zop1.H, Zop2.H + /// svint16_t svadd[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svadd[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svadd[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) + /// ADD Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector Add(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Add(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svadd[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svadd[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svadd[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) - /// ADD Zresult.S, Zop1.S, Zop2.S + /// svint32_t svadd[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svadd[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svadd[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) + /// ADD Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector Add(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Add(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svadd[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svadd[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svadd[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) - /// ADD Zresult.D, Zop1.D, Zop2.D + /// svint64_t svadd[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svadd[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svadd[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) + /// ADD Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector Add(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Add(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svadd[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svadd[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svadd[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) - /// ADD Zresult.B, Zop1.B, Zop2.B + /// svint8_t svadd[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svadd[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svadd[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) + /// ADD Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector Add(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Add(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svadd[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svadd[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svadd[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FADD Zresult.S, Zop1.S, Zop2.S + /// svfloat32_t svadd[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svadd[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svadd[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FADD Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector Add(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Add(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svadd[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svadd[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svadd[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// ADD Zresult.H, Zop1.H, Zop2.H + /// svuint16_t svadd[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svadd[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svadd[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// ADD Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector Add(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Add(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svadd[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svadd[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svadd[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// ADD Zresult.S, Zop1.S, Zop2.S + /// svuint32_t svadd[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svadd[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svadd[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// ADD Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector Add(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Add(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svadd[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svadd[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svadd[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// ADD Zresult.D, Zop1.D, Zop2.D + /// svuint64_t svadd[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svadd[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svadd[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// ADD Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector Add(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Add(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Add reduction /// - /// float64_t svaddv[_f64](svbool_t pg, svfloat64_t op) - /// FADDV Dresult, Pg, Zop.D + /// float64_t svaddv[_f64](svbool_t pg, svfloat64_t op) + /// FADDV Dresult, Pg, Zop.D /// - public static unsafe Vector AddAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector AddAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// int64_t svaddv[_s16](svbool_t pg, svint16_t op) - /// SADDV Dresult, Pg, Zop.H + /// int64_t svaddv[_s16](svbool_t pg, svint16_t op) + /// SADDV Dresult, Pg, Zop.H /// - public static unsafe Vector AddAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector AddAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// int64_t svaddv[_s32](svbool_t pg, svint32_t op) - /// SADDV Dresult, Pg, Zop.S + /// int64_t svaddv[_s32](svbool_t pg, svint32_t op) + /// SADDV Dresult, Pg, Zop.S /// - public static unsafe Vector AddAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector AddAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// int64_t svaddv[_s8](svbool_t pg, svint8_t op) - /// SADDV Dresult, Pg, Zop.B + /// int64_t svaddv[_s8](svbool_t pg, svint8_t op) + /// SADDV Dresult, Pg, Zop.B /// - public static unsafe Vector AddAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector AddAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// int64_t svaddv[_s64](svbool_t pg, svint64_t op) - /// UADDV Dresult, Pg, Zop.D + /// int64_t svaddv[_s64](svbool_t pg, svint64_t op) + /// UADDV Dresult, Pg, Zop.D /// - public static unsafe Vector AddAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector AddAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// float32_t svaddv[_f32](svbool_t pg, svfloat32_t op) - /// FADDV Sresult, Pg, Zop.S + /// float32_t svaddv[_f32](svbool_t pg, svfloat32_t op) + /// FADDV Sresult, Pg, Zop.S /// - public static unsafe Vector AddAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector AddAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svaddv[_u8](svbool_t pg, svuint8_t op) - /// UADDV Dresult, Pg, Zop.B + /// uint64_t svaddv[_u8](svbool_t pg, svuint8_t op) + /// UADDV Dresult, Pg, Zop.B /// - public static unsafe Vector AddAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector AddAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svaddv[_u16](svbool_t pg, svuint16_t op) - /// UADDV Dresult, Pg, Zop.H + /// uint64_t svaddv[_u16](svbool_t pg, svuint16_t op) + /// UADDV Dresult, Pg, Zop.H /// - public static unsafe Vector AddAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector AddAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svaddv[_u32](svbool_t pg, svuint32_t op) - /// UADDV Dresult, Pg, Zop.S + /// uint64_t svaddv[_u32](svbool_t pg, svuint32_t op) + /// UADDV Dresult, Pg, Zop.S /// - public static unsafe Vector AddAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector AddAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svaddv[_u64](svbool_t pg, svuint64_t op) - /// UADDV Dresult, Pg, Zop.D + /// uint64_t svaddv[_u64](svbool_t pg, svuint64_t op) + /// UADDV Dresult, Pg, Zop.D /// - public static unsafe Vector AddAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector AddAcross(Vector value) { throw new PlatformNotSupportedException(); } // Complex add with rotate /// - /// svfloat64_t svcadd[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2, uint64_t imm_rotation) - /// svfloat64_t svcadd[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2, uint64_t imm_rotation) - /// svfloat64_t svcadd[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2, uint64_t imm_rotation) - /// FCADD Ztied1.D, Pg/M, Ztied1.D, Zop2.D, #imm_rotation + /// svfloat64_t svcadd[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2, uint64_t imm_rotation) + /// svfloat64_t svcadd[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2, uint64_t imm_rotation) + /// svfloat64_t svcadd[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2, uint64_t imm_rotation) + /// FCADD Ztied1.D, Pg/M, Ztied1.D, Zop2.D, #imm_rotation /// - public static unsafe Vector AddRotateComplex(Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(1))] byte rotation) { throw new PlatformNotSupportedException(); } + public static Vector AddRotateComplex(Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(1))] byte rotation) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svcadd[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2, uint64_t imm_rotation) - /// svfloat32_t svcadd[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2, uint64_t imm_rotation) - /// svfloat32_t svcadd[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2, uint64_t imm_rotation) - /// FCADD Ztied1.S, Pg/M, Ztied1.S, Zop2.S, #imm_rotation - /// FCADD Ztied1.S, Pg/M, Ztied1.S, Zop2.S, #imm_rotation + /// svfloat32_t svcadd[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2, uint64_t imm_rotation) + /// svfloat32_t svcadd[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2, uint64_t imm_rotation) + /// svfloat32_t svcadd[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2, uint64_t imm_rotation) + /// FCADD Ztied1.S, Pg/M, Ztied1.S, Zop2.S, #imm_rotation + /// FCADD Ztied1.S, Pg/M, Ztied1.S, Zop2.S, #imm_rotation /// - public static unsafe Vector AddRotateComplex(Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(1))] byte rotation) { throw new PlatformNotSupportedException(); } + public static Vector AddRotateComplex(Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(1))] byte rotation) { throw new PlatformNotSupportedException(); } // Saturating add /// - /// svuint8_t svqadd[_u8](svuint8_t op1, svuint8_t op2) - /// UQADD Zresult.B, Zop1.B, Zop2.B + /// svuint8_t svqadd[_u8](svuint8_t op1, svuint8_t op2) + /// UQADD Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector AddSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AddSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svqadd[_s16](svint16_t op1, svint16_t op2) - /// SQADD Zresult.H, Zop1.H, Zop2.H + /// svint16_t svqadd[_s16](svint16_t op1, svint16_t op2) + /// SQADD Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector AddSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AddSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svqadd[_s32](svint32_t op1, svint32_t op2) - /// SQADD Zresult.S, Zop1.S, Zop2.S + /// svint32_t svqadd[_s32](svint32_t op1, svint32_t op2) + /// SQADD Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector AddSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AddSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svqadd[_s64](svint64_t op1, svint64_t op2) - /// SQADD Zresult.D, Zop1.D, Zop2.D + /// svint64_t svqadd[_s64](svint64_t op1, svint64_t op2) + /// SQADD Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector AddSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AddSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svqadd[_s8](svint8_t op1, svint8_t op2) - /// SQADD Zresult.B, Zop1.B, Zop2.B + /// svint8_t svqadd[_s8](svint8_t op1, svint8_t op2) + /// SQADD Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector AddSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AddSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svqadd[_u16](svuint16_t op1, svuint16_t op2) - /// UQADD Zresult.H, Zop1.H, Zop2.H + /// svuint16_t svqadd[_u16](svuint16_t op1, svuint16_t op2) + /// UQADD Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector AddSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AddSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svqadd[_u32](svuint32_t op1, svuint32_t op2) - /// UQADD Zresult.S, Zop1.S, Zop2.S + /// svuint32_t svqadd[_u32](svuint32_t op1, svuint32_t op2) + /// UQADD Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector AddSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AddSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svqadd[_u64](svuint64_t op1, svuint64_t op2) - /// UQADD Zresult.D, Zop1.D, Zop2.D + /// svuint64_t svqadd[_u64](svuint64_t op1, svuint64_t op2) + /// UQADD Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector AddSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector AddSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Add reduction (strictly-ordered) /// - /// float64_t svadda[_f64](svbool_t pg, float64_t initial, svfloat64_t op) - /// FADDA Dtied, Pg, Dtied, Zop.D + /// float64_t svadda[_f64](svbool_t pg, float64_t initial, svfloat64_t op) + /// FADDA Dtied, Pg, Dtied, Zop.D /// - public static unsafe Vector AddSequentialAcross(Vector initial, Vector value) { throw new PlatformNotSupportedException(); } + public static Vector AddSequentialAcross(Vector initial, Vector value) { throw new PlatformNotSupportedException(); } /// - /// float32_t svadda[_f32](svbool_t pg, float32_t initial, svfloat32_t op) - /// FADDA Stied, Pg, Stied, Zop.S + /// float32_t svadda[_f32](svbool_t pg, float32_t initial, svfloat32_t op) + /// FADDA Stied, Pg, Stied, Zop.S /// - public static unsafe Vector AddSequentialAcross(Vector initial, Vector value) { throw new PlatformNotSupportedException(); } + public static Vector AddSequentialAcross(Vector initial, Vector value) { throw new PlatformNotSupportedException(); } // Bitwise AND /// - /// svuint8_t svand[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svand[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svand[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// AND Zresult.D, Zop1.D, Zop2.D - /// svbool_t svand[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// AND Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svuint8_t svand[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svand[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svand[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// AND Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector And(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector And(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svand[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svand[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svand[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) - /// AND Zresult.D, Zop1.D, Zop2.D - /// svbool_t svand[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// AND Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svint16_t svand[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svand[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svand[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) + /// AND Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector And(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector And(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svand[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svand[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svand[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) - /// AND Zresult.D, Zop1.D, Zop2.D - /// svbool_t svand[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// AND Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svint32_t svand[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svand[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svand[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) + /// AND Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector And(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector And(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svand[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svand[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svand[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) - /// AND Zresult.D, Zop1.D, Zop2.D - /// svbool_t svand[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// AND Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svint64_t svand[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svand[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svand[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) + /// AND Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector And(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector And(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svand[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svand[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svand[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) - /// AND Zresult.D, Zop1.D, Zop2.D - /// svbool_t svand[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// AND Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svint8_t svand[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svand[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svand[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) + /// AND Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector And(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector And(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svand[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svand[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svand[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// AND Zresult.D, Zop1.D, Zop2.D - /// svbool_t svand[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// AND Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svuint16_t svand[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svand[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svand[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// AND Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector And(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector And(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svand[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svand[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svand[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// AND Zresult.D, Zop1.D, Zop2.D - /// svbool_t svand[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// AND Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svuint32_t svand[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svand[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svand[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// AND Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector And(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector And(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svand[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svand[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svand[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// AND Zresult.D, Zop1.D, Zop2.D - /// svbool_t svand[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// AND Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svuint64_t svand[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svand[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svand[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// AND Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector And(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector And(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Bitwise AND reduction to scalar /// - /// uint8_t svandv[_u8](svbool_t pg, svuint8_t op) - /// ANDV Bresult, Pg, Zop.B + /// uint8_t svandv[_u8](svbool_t pg, svuint8_t op) + /// ANDV Bresult, Pg, Zop.B /// - public static unsafe Vector AndAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector AndAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// int16_t svandv[_s16](svbool_t pg, svint16_t op) - /// ANDV Hresult, Pg, Zop.H + /// int16_t svandv[_s16](svbool_t pg, svint16_t op) + /// ANDV Hresult, Pg, Zop.H /// - public static unsafe Vector AndAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector AndAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// int32_t svandv[_s32](svbool_t pg, svint32_t op) - /// ANDV Sresult, Pg, Zop.S + /// int32_t svandv[_s32](svbool_t pg, svint32_t op) + /// ANDV Sresult, Pg, Zop.S /// - public static unsafe Vector AndAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector AndAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// int64_t svandv[_s64](svbool_t pg, svint64_t op) - /// ANDV Dresult, Pg, Zop.D + /// int64_t svandv[_s64](svbool_t pg, svint64_t op) + /// ANDV Dresult, Pg, Zop.D /// - public static unsafe Vector AndAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector AndAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// int8_t svandv[_s8](svbool_t pg, svint8_t op) - /// ANDV Bresult, Pg, Zop.B + /// int8_t svandv[_s8](svbool_t pg, svint8_t op) + /// ANDV Bresult, Pg, Zop.B /// - public static unsafe Vector AndAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector AndAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// uint16_t svandv[_u16](svbool_t pg, svuint16_t op) - /// ANDV Hresult, Pg, Zop.H + /// uint16_t svandv[_u16](svbool_t pg, svuint16_t op) + /// ANDV Hresult, Pg, Zop.H /// - public static unsafe Vector AndAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector AndAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// uint32_t svandv[_u32](svbool_t pg, svuint32_t op) - /// ANDV Sresult, Pg, Zop.S + /// uint32_t svandv[_u32](svbool_t pg, svuint32_t op) + /// ANDV Sresult, Pg, Zop.S /// - public static unsafe Vector AndAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector AndAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svandv[_u64](svbool_t pg, svuint64_t op) - /// ANDV Dresult, Pg, Zop.D + /// uint64_t svandv[_u64](svbool_t pg, svuint64_t op) + /// ANDV Dresult, Pg, Zop.D /// - public static unsafe Vector AndAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector AndAcross(Vector value) { throw new PlatformNotSupportedException(); } // Bitwise clear /// - /// svuint8_t svbic[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svbic[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svbic[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// BIC Ztied1.B, Pg/M, Ztied1.B, Zop2.B - /// BIC Zresult.D, Zop1.D, Zop2.D - /// svbool_t svbic[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BIC Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svuint8_t svbic[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svbic[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svbic[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// BIC Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// BIC Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector BitwiseClear(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector BitwiseClear(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svbic[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svbic[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svbic[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) - /// BIC Ztied1.H, Pg/M, Ztied1.H, Zop2.H - /// BIC Zresult.D, Zop1.D, Zop2.D - /// svbool_t svbic[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BIC Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svint16_t svbic[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svbic[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svbic[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) + /// BIC Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// BIC Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector BitwiseClear(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector BitwiseClear(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svbic[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svbic[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svbic[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) - /// BIC Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// BIC Zresult.D, Zop1.D, Zop2.D - /// svbool_t svbic[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BIC Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svint32_t svbic[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svbic[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svbic[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) + /// BIC Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// BIC Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector BitwiseClear(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector BitwiseClear(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svbic[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svbic[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svbic[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) - /// BIC Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// BIC Zresult.D, Zop1.D, Zop2.D - /// svbool_t svbic[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BIC Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svint64_t svbic[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svbic[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svbic[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) + /// BIC Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// BIC Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector BitwiseClear(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector BitwiseClear(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svbic[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svbic[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svbic[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) - /// BIC Ztied1.B, Pg/M, Ztied1.B, Zop2.B - /// BIC Zresult.D, Zop1.D, Zop2.D - /// svbool_t svbic[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BIC Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svint8_t svbic[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svbic[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svbic[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) + /// BIC Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// BIC Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector BitwiseClear(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector BitwiseClear(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svbic[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svbic[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svbic[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// BIC Ztied1.H, Pg/M, Ztied1.H, Zop2.H - /// BIC Zresult.D, Zop1.D, Zop2.D - /// svbool_t svbic[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BIC Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svuint16_t svbic[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svbic[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svbic[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// BIC Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// BIC Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector BitwiseClear(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector BitwiseClear(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svbic[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svbic[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svbic[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// BIC Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// BIC Zresult.D, Zop1.D, Zop2.D - /// svbool_t svbic[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BIC Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svuint32_t svbic[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svbic[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svbic[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// BIC Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// BIC Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector BitwiseClear(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector BitwiseClear(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svbic[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svbic[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svbic[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// BIC Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// BIC Zresult.D, Zop1.D, Zop2.D - /// svbool_t svbic[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BIC Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svuint64_t svbic[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svbic[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svbic[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// BIC Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// BIC Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector BitwiseClear(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector BitwiseClear(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Logically invert boolean condition /// - /// svuint8_t svcnot[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) - /// svuint8_t svcnot[_u8]_x(svbool_t pg, svuint8_t op) - /// svuint8_t svcnot[_u8]_z(svbool_t pg, svuint8_t op) - /// CNOT Zresult.B, Pg/M, Zop.B + /// svuint8_t svcnot[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) + /// svuint8_t svcnot[_u8]_x(svbool_t pg, svuint8_t op) + /// svuint8_t svcnot[_u8]_z(svbool_t pg, svuint8_t op) + /// CNOT Zresult.B, Pg/M, Zop.B /// - public static unsafe Vector BooleanNot(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector BooleanNot(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svcnot[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) - /// svint16_t svcnot[_s16]_x(svbool_t pg, svint16_t op) - /// svint16_t svcnot[_s16]_z(svbool_t pg, svint16_t op) - /// CNOT Zresult.H, Pg/M, Zop.H + /// svint16_t svcnot[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) + /// svint16_t svcnot[_s16]_x(svbool_t pg, svint16_t op) + /// svint16_t svcnot[_s16]_z(svbool_t pg, svint16_t op) + /// CNOT Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector BooleanNot(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector BooleanNot(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svcnot[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) - /// svint32_t svcnot[_s32]_x(svbool_t pg, svint32_t op) - /// svint32_t svcnot[_s32]_z(svbool_t pg, svint32_t op) - /// CNOT Zresult.S, Pg/M, Zop.S + /// svint32_t svcnot[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) + /// svint32_t svcnot[_s32]_x(svbool_t pg, svint32_t op) + /// svint32_t svcnot[_s32]_z(svbool_t pg, svint32_t op) + /// CNOT Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector BooleanNot(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector BooleanNot(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svcnot[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) - /// svint64_t svcnot[_s64]_x(svbool_t pg, svint64_t op) - /// svint64_t svcnot[_s64]_z(svbool_t pg, svint64_t op) - /// CNOT Zresult.D, Pg/M, Zop.D + /// svint64_t svcnot[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) + /// svint64_t svcnot[_s64]_x(svbool_t pg, svint64_t op) + /// svint64_t svcnot[_s64]_z(svbool_t pg, svint64_t op) + /// CNOT Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector BooleanNot(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector BooleanNot(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svcnot[_s8]_m(svint8_t inactive, svbool_t pg, svint8_t op) - /// svint8_t svcnot[_s8]_x(svbool_t pg, svint8_t op) - /// svint8_t svcnot[_s8]_z(svbool_t pg, svint8_t op) - /// CNOT Zresult.B, Pg/M, Zop.B + /// svint8_t svcnot[_s8]_m(svint8_t inactive, svbool_t pg, svint8_t op) + /// svint8_t svcnot[_s8]_x(svbool_t pg, svint8_t op) + /// svint8_t svcnot[_s8]_z(svbool_t pg, svint8_t op) + /// CNOT Zresult.B, Pg/M, Zop.B /// - public static unsafe Vector BooleanNot(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector BooleanNot(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svcnot[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) - /// svuint16_t svcnot[_u16]_x(svbool_t pg, svuint16_t op) - /// svuint16_t svcnot[_u16]_z(svbool_t pg, svuint16_t op) - /// CNOT Zresult.H, Pg/M, Zop.H + /// svuint16_t svcnot[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) + /// svuint16_t svcnot[_u16]_x(svbool_t pg, svuint16_t op) + /// svuint16_t svcnot[_u16]_z(svbool_t pg, svuint16_t op) + /// CNOT Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector BooleanNot(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector BooleanNot(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svcnot[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) - /// svuint32_t svcnot[_u32]_x(svbool_t pg, svuint32_t op) - /// svuint32_t svcnot[_u32]_z(svbool_t pg, svuint32_t op) - /// CNOT Zresult.S, Pg/M, Zop.S + /// svuint32_t svcnot[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) + /// svuint32_t svcnot[_u32]_x(svbool_t pg, svuint32_t op) + /// svuint32_t svcnot[_u32]_z(svbool_t pg, svuint32_t op) + /// CNOT Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector BooleanNot(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector BooleanNot(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svcnot[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) - /// svuint64_t svcnot[_u64]_x(svbool_t pg, svuint64_t op) - /// svuint64_t svcnot[_u64]_z(svbool_t pg, svuint64_t op) - /// CNOT Zresult.D, Pg/M, Zop.D + /// svuint64_t svcnot[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) + /// svuint64_t svcnot[_u64]_x(svbool_t pg, svuint64_t op) + /// svuint64_t svcnot[_u64]_z(svbool_t pg, svuint64_t op) + /// CNOT Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector BooleanNot(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector BooleanNot(Vector value) { throw new PlatformNotSupportedException(); } // Shuffle active elements of vector to the right and fill with zero /// - /// svfloat64_t svcompact[_f64](svbool_t pg, svfloat64_t op) - /// COMPACT Zresult.D, Pg, Zop.D + /// svfloat64_t svcompact[_f64](svbool_t pg, svfloat64_t op) + /// COMPACT Zresult.D, Pg, Zop.D /// - public static unsafe Vector Compact(Vector mask, Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Compact(Vector mask, Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svcompact[_s32](svbool_t pg, svint32_t op) - /// COMPACT Zresult.S, Pg, Zop.S + /// svint32_t svcompact[_s32](svbool_t pg, svint32_t op) + /// COMPACT Zresult.S, Pg, Zop.S /// - public static unsafe Vector Compact(Vector mask, Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Compact(Vector mask, Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svcompact[_s64](svbool_t pg, svint64_t op) - /// COMPACT Zresult.D, Pg, Zop.D + /// svint64_t svcompact[_s64](svbool_t pg, svint64_t op) + /// COMPACT Zresult.D, Pg, Zop.D /// - public static unsafe Vector Compact(Vector mask, Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Compact(Vector mask, Vector value) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svcompact[_f32](svbool_t pg, svfloat32_t op) - /// COMPACT Zresult.S, Pg, Zop.S + /// svfloat32_t svcompact[_f32](svbool_t pg, svfloat32_t op) + /// COMPACT Zresult.S, Pg, Zop.S /// - public static unsafe Vector Compact(Vector mask, Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Compact(Vector mask, Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svcompact[_u32](svbool_t pg, svuint32_t op) - /// COMPACT Zresult.S, Pg, Zop.S + /// svuint32_t svcompact[_u32](svbool_t pg, svuint32_t op) + /// COMPACT Zresult.S, Pg, Zop.S /// - public static unsafe Vector Compact(Vector mask, Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Compact(Vector mask, Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svcompact[_u64](svbool_t pg, svuint64_t op) - /// COMPACT Zresult.D, Pg, Zop.D + /// svuint64_t svcompact[_u64](svbool_t pg, svuint64_t op) + /// COMPACT Zresult.D, Pg, Zop.D /// - public static unsafe Vector Compact(Vector mask, Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Compact(Vector mask, Vector value) { throw new PlatformNotSupportedException(); } // Compare equal to /// - /// svbool_t svcmpeq[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) - /// CMPEQ Presult.B, Pg/Z, Zop1.B, Zop2.B + /// svbool_t svcmpeq[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) + /// CMPEQ Presult.B, Pg/Z, Zop1.B, Zop2.B /// - public static unsafe Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpeq[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FCMEQ Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpeq[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FCMEQ Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpeq[_s16](svbool_t pg, svint16_t op1, svint16_t op2) - /// CMPEQ Presult.H, Pg/Z, Zop1.H, Zop2.H + /// svbool_t svcmpeq[_s16](svbool_t pg, svint16_t op1, svint16_t op2) + /// CMPEQ Presult.H, Pg/Z, Zop1.H, Zop2.H /// - public static unsafe Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpeq_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) - /// CMPEQ Presult.H, Pg/Z, Zop1.H, Zop2.D + /// svbool_t svcmpeq_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) + /// CMPEQ Presult.H, Pg/Z, Zop1.H, Zop2.D /// - public static unsafe Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpeq[_s32](svbool_t pg, svint32_t op1, svint32_t op2) - /// CMPEQ Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpeq[_s32](svbool_t pg, svint32_t op1, svint32_t op2) + /// CMPEQ Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpeq_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) - /// CMPEQ Presult.S, Pg/Z, Zop1.S, Zop2.D + /// svbool_t svcmpeq_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) + /// CMPEQ Presult.S, Pg/Z, Zop1.S, Zop2.D /// - public static unsafe Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpeq[_s64](svbool_t pg, svint64_t op1, svint64_t op2) - /// CMPEQ Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpeq[_s64](svbool_t pg, svint64_t op1, svint64_t op2) + /// CMPEQ Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpeq[_s8](svbool_t pg, svint8_t op1, svint8_t op2) - /// CMPEQ Presult.B, Pg/Z, Zop1.B, Zop2.B + /// svbool_t svcmpeq[_s8](svbool_t pg, svint8_t op1, svint8_t op2) + /// CMPEQ Presult.B, Pg/Z, Zop1.B, Zop2.B /// - public static unsafe Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpeq_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) - /// CMPEQ Presult.B, Pg/Z, Zop1.B, Zop2.D + /// svbool_t svcmpeq_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) + /// CMPEQ Presult.B, Pg/Z, Zop1.B, Zop2.D /// - public static unsafe Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpeq[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FCMEQ Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpeq[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FCMEQ Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpeq[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) - /// CMPEQ Presult.H, Pg/Z, Zop1.H, Zop2.H + /// svbool_t svcmpeq[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) + /// CMPEQ Presult.H, Pg/Z, Zop1.H, Zop2.H /// - public static unsafe Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpeq[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) - /// CMPEQ Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpeq[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) + /// CMPEQ Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpeq[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) - /// CMPEQ Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpeq[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) + /// CMPEQ Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Compare greater than /// - /// svbool_t svcmpgt[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) - /// CMPHI Presult.B, Pg/Z, Zop1.B, Zop2.B + /// svbool_t svcmpgt[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) + /// CMPHI Presult.B, Pg/Z, Zop1.B, Zop2.B /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpgt_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) - /// CMPHI Presult.B, Pg/Z, Zop1.B, Zop2.D + /// svbool_t svcmpgt_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) + /// CMPHI Presult.B, Pg/Z, Zop1.B, Zop2.D /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpgt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FCMGT Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpgt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FCMGT Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpgt[_s16](svbool_t pg, svint16_t op1, svint16_t op2) - /// CMPGT Presult.H, Pg/Z, Zop1.H, Zop2.H + /// svbool_t svcmpgt[_s16](svbool_t pg, svint16_t op1, svint16_t op2) + /// CMPGT Presult.H, Pg/Z, Zop1.H, Zop2.H /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpgt_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) - /// CMPGT Presult.H, Pg/Z, Zop1.H, Zop2.D + /// svbool_t svcmpgt_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) + /// CMPGT Presult.H, Pg/Z, Zop1.H, Zop2.D /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpgt[_s32](svbool_t pg, svint32_t op1, svint32_t op2) - /// CMPGT Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpgt[_s32](svbool_t pg, svint32_t op1, svint32_t op2) + /// CMPGT Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpgt_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) - /// CMPGT Presult.S, Pg/Z, Zop1.S, Zop2.D + /// svbool_t svcmpgt_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) + /// CMPGT Presult.S, Pg/Z, Zop1.S, Zop2.D /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpgt[_s64](svbool_t pg, svint64_t op1, svint64_t op2) - /// CMPGT Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpgt[_s64](svbool_t pg, svint64_t op1, svint64_t op2) + /// CMPGT Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpgt[_s8](svbool_t pg, svint8_t op1, svint8_t op2) - /// CMPGT Presult.B, Pg/Z, Zop1.B, Zop2.B + /// svbool_t svcmpgt[_s8](svbool_t pg, svint8_t op1, svint8_t op2) + /// CMPGT Presult.B, Pg/Z, Zop1.B, Zop2.B /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpgt_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) - /// CMPGT Presult.B, Pg/Z, Zop1.B, Zop2.D + /// svbool_t svcmpgt_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) + /// CMPGT Presult.B, Pg/Z, Zop1.B, Zop2.D /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpgt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FCMGT Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpgt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FCMGT Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpgt[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) - /// CMPHI Presult.H, Pg/Z, Zop1.H, Zop2.H + /// svbool_t svcmpgt[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) + /// CMPHI Presult.H, Pg/Z, Zop1.H, Zop2.H /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpgt_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) - /// CMPHI Presult.H, Pg/Z, Zop1.H, Zop2.D + /// svbool_t svcmpgt_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) + /// CMPHI Presult.H, Pg/Z, Zop1.H, Zop2.D /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpgt[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) - /// CMPHI Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpgt[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) + /// CMPHI Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpgt_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) - /// CMPHI Presult.S, Pg/Z, Zop1.S, Zop2.D + /// svbool_t svcmpgt_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) + /// CMPHI Presult.S, Pg/Z, Zop1.S, Zop2.D /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpgt[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) - /// CMPHI Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpgt[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) + /// CMPHI Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Compare greater than or equal to /// - /// svbool_t svcmpge[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) - /// CMPHS Presult.B, Pg/Z, Zop1.B, Zop2.B + /// svbool_t svcmpge[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) + /// CMPHS Presult.B, Pg/Z, Zop1.B, Zop2.B /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpge_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) - /// CMPHS Presult.B, Pg/Z, Zop1.B, Zop2.D + /// svbool_t svcmpge_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) + /// CMPHS Presult.B, Pg/Z, Zop1.B, Zop2.D /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpge[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FCMGE Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpge[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FCMGE Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpge[_s16](svbool_t pg, svint16_t op1, svint16_t op2) - /// CMPGE Presult.H, Pg/Z, Zop1.H, Zop2.H + /// svbool_t svcmpge[_s16](svbool_t pg, svint16_t op1, svint16_t op2) + /// CMPGE Presult.H, Pg/Z, Zop1.H, Zop2.H /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpge_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) - /// CMPGE Presult.H, Pg/Z, Zop1.H, Zop2.D + /// svbool_t svcmpge_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) + /// CMPGE Presult.H, Pg/Z, Zop1.H, Zop2.D /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpge[_s32](svbool_t pg, svint32_t op1, svint32_t op2) - /// CMPGE Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpge[_s32](svbool_t pg, svint32_t op1, svint32_t op2) + /// CMPGE Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpge_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) - /// CMPGE Presult.S, Pg/Z, Zop1.S, Zop2.D + /// svbool_t svcmpge_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) + /// CMPGE Presult.S, Pg/Z, Zop1.S, Zop2.D /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpge[_s64](svbool_t pg, svint64_t op1, svint64_t op2) - /// CMPGE Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpge[_s64](svbool_t pg, svint64_t op1, svint64_t op2) + /// CMPGE Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpge[_s8](svbool_t pg, svint8_t op1, svint8_t op2) - /// CMPGE Presult.B, Pg/Z, Zop1.B, Zop2.B + /// svbool_t svcmpge[_s8](svbool_t pg, svint8_t op1, svint8_t op2) + /// CMPGE Presult.B, Pg/Z, Zop1.B, Zop2.B /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpge_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) - /// CMPGE Presult.B, Pg/Z, Zop1.B, Zop2.D + /// svbool_t svcmpge_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) + /// CMPGE Presult.B, Pg/Z, Zop1.B, Zop2.D /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpge[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FCMGE Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpge[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FCMGE Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpge[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) - /// CMPHS Presult.H, Pg/Z, Zop1.H, Zop2.H + /// svbool_t svcmpge[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) + /// CMPHS Presult.H, Pg/Z, Zop1.H, Zop2.H /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpge_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) - /// CMPHS Presult.H, Pg/Z, Zop1.H, Zop2.D + /// svbool_t svcmpge_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) + /// CMPHS Presult.H, Pg/Z, Zop1.H, Zop2.D /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpge[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) - /// CMPHS Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpge[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) + /// CMPHS Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpge_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) - /// CMPHS Presult.S, Pg/Z, Zop1.S, Zop2.D + /// svbool_t svcmpge_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) + /// CMPHS Presult.S, Pg/Z, Zop1.S, Zop2.D /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpge[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) - /// CMPHS Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpge[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) + /// CMPHS Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Compare less than /// - /// svbool_t svcmplt[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) - /// CMPHI Presult.B, Pg/Z, Zop2.B, Zop1.B + /// svbool_t svcmplt[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) + /// CMPHI Presult.B, Pg/Z, Zop2.B, Zop1.B /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmplt_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) - /// CMPLO Presult.B, Pg/Z, Zop1.B, Zop2.D + /// svbool_t svcmplt_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) + /// CMPLO Presult.B, Pg/Z, Zop1.B, Zop2.D /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmplt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FCMGT Presult.D, Pg/Z, Zop2.D, Zop1.D + /// svbool_t svcmplt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FCMGT Presult.D, Pg/Z, Zop2.D, Zop1.D /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmplt[_s16](svbool_t pg, svint16_t op1, svint16_t op2) - /// CMPGT Presult.H, Pg/Z, Zop2.H, Zop1.H + /// svbool_t svcmplt[_s16](svbool_t pg, svint16_t op1, svint16_t op2) + /// CMPGT Presult.H, Pg/Z, Zop2.H, Zop1.H /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmplt_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) - /// CMPLT Presult.H, Pg/Z, Zop1.H, Zop2.D + /// svbool_t svcmplt_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) + /// CMPLT Presult.H, Pg/Z, Zop1.H, Zop2.D /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmplt[_s32](svbool_t pg, svint32_t op1, svint32_t op2) - /// CMPGT Presult.S, Pg/Z, Zop2.S, Zop1.S + /// svbool_t svcmplt[_s32](svbool_t pg, svint32_t op1, svint32_t op2) + /// CMPGT Presult.S, Pg/Z, Zop2.S, Zop1.S /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmplt_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) - /// CMPLT Presult.S, Pg/Z, Zop1.S, Zop2.D + /// svbool_t svcmplt_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) + /// CMPLT Presult.S, Pg/Z, Zop1.S, Zop2.D /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmplt[_s64](svbool_t pg, svint64_t op1, svint64_t op2) - /// CMPGT Presult.D, Pg/Z, Zop2.D, Zop1.D + /// svbool_t svcmplt[_s64](svbool_t pg, svint64_t op1, svint64_t op2) + /// CMPGT Presult.D, Pg/Z, Zop2.D, Zop1.D /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmplt[_s8](svbool_t pg, svint8_t op1, svint8_t op2) - /// CMPGT Presult.B, Pg/Z, Zop2.B, Zop1.B + /// svbool_t svcmplt[_s8](svbool_t pg, svint8_t op1, svint8_t op2) + /// CMPGT Presult.B, Pg/Z, Zop2.B, Zop1.B /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmplt_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) - /// CMPLT Presult.B, Pg/Z, Zop1.B, Zop2.D + /// svbool_t svcmplt_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) + /// CMPLT Presult.B, Pg/Z, Zop1.B, Zop2.D /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmplt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FCMGT Presult.S, Pg/Z, Zop2.S, Zop1.S + /// svbool_t svcmplt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FCMGT Presult.S, Pg/Z, Zop2.S, Zop1.S /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmplt[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) - /// CMPHI Presult.H, Pg/Z, Zop2.H, Zop1.H + /// svbool_t svcmplt[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) + /// CMPHI Presult.H, Pg/Z, Zop2.H, Zop1.H /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmplt_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) - /// CMPLO Presult.H, Pg/Z, Zop1.H, Zop2.D + /// svbool_t svcmplt_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) + /// CMPLO Presult.H, Pg/Z, Zop1.H, Zop2.D /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmplt[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) - /// CMPHI Presult.S, Pg/Z, Zop2.S, Zop1.S + /// svbool_t svcmplt[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) + /// CMPHI Presult.S, Pg/Z, Zop2.S, Zop1.S /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmplt_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) - /// CMPLO Presult.S, Pg/Z, Zop1.S, Zop2.D + /// svbool_t svcmplt_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) + /// CMPLO Presult.S, Pg/Z, Zop1.S, Zop2.D /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmplt[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) - /// CMPHI Presult.D, Pg/Z, Zop2.D, Zop1.D + /// svbool_t svcmplt[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) + /// CMPHI Presult.D, Pg/Z, Zop2.D, Zop1.D /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThan(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Compare less than or equal to /// - /// svbool_t svcmple[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) - /// CMPHS Presult.B, Pg/Z, Zop2.B, Zop1.B + /// svbool_t svcmple[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) + /// CMPHS Presult.B, Pg/Z, Zop2.B, Zop1.B /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmple_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) - /// CMPLS Presult.B, Pg/Z, Zop1.B, Zop2.D + /// svbool_t svcmple_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) + /// CMPLS Presult.B, Pg/Z, Zop1.B, Zop2.D /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmple[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FCMGE Presult.D, Pg/Z, Zop2.D, Zop1.D + /// svbool_t svcmple[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FCMGE Presult.D, Pg/Z, Zop2.D, Zop1.D /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmple[_s16](svbool_t pg, svint16_t op1, svint16_t op2) - /// CMPGE Presult.H, Pg/Z, Zop2.H, Zop1.H + /// svbool_t svcmple[_s16](svbool_t pg, svint16_t op1, svint16_t op2) + /// CMPGE Presult.H, Pg/Z, Zop2.H, Zop1.H /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmple_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) - /// CMPLE Presult.H, Pg/Z, Zop1.H, Zop2.D + /// svbool_t svcmple_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) + /// CMPLE Presult.H, Pg/Z, Zop1.H, Zop2.D /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmple[_s32](svbool_t pg, svint32_t op1, svint32_t op2) - /// CMPGE Presult.S, Pg/Z, Zop2.S, Zop1.S + /// svbool_t svcmple[_s32](svbool_t pg, svint32_t op1, svint32_t op2) + /// CMPGE Presult.S, Pg/Z, Zop2.S, Zop1.S /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmple_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) - /// CMPLE Presult.S, Pg/Z, Zop1.S, Zop2.D + /// svbool_t svcmple_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) + /// CMPLE Presult.S, Pg/Z, Zop1.S, Zop2.D /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmple[_s64](svbool_t pg, svint64_t op1, svint64_t op2) - /// CMPGE Presult.D, Pg/Z, Zop2.D, Zop1.D + /// svbool_t svcmple[_s64](svbool_t pg, svint64_t op1, svint64_t op2) + /// CMPGE Presult.D, Pg/Z, Zop2.D, Zop1.D /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmple[_s8](svbool_t pg, svint8_t op1, svint8_t op2) - /// CMPGE Presult.B, Pg/Z, Zop2.B, Zop1.B + /// svbool_t svcmple[_s8](svbool_t pg, svint8_t op1, svint8_t op2) + /// CMPGE Presult.B, Pg/Z, Zop2.B, Zop1.B /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmple_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) - /// CMPLE Presult.B, Pg/Z, Zop1.B, Zop2.D + /// svbool_t svcmple_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) + /// CMPLE Presult.B, Pg/Z, Zop1.B, Zop2.D /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmple[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FCMGE Presult.S, Pg/Z, Zop2.S, Zop1.S + /// svbool_t svcmple[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FCMGE Presult.S, Pg/Z, Zop2.S, Zop1.S /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmple[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) - /// CMPHS Presult.H, Pg/Z, Zop2.H, Zop1.H + /// svbool_t svcmple[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) + /// CMPHS Presult.H, Pg/Z, Zop2.H, Zop1.H /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmple_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) - /// CMPLS Presult.H, Pg/Z, Zop1.H, Zop2.D + /// svbool_t svcmple_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) + /// CMPLS Presult.H, Pg/Z, Zop1.H, Zop2.D /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmple[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) - /// CMPHS Presult.S, Pg/Z, Zop2.S, Zop1.S + /// svbool_t svcmple[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) + /// CMPHS Presult.S, Pg/Z, Zop2.S, Zop1.S /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmple_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) - /// CMPLS Presult.S, Pg/Z, Zop1.S, Zop2.D + /// svbool_t svcmple_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) + /// CMPLS Presult.S, Pg/Z, Zop1.S, Zop2.D /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmple[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) - /// CMPHS Presult.D, Pg/Z, Zop2.D, Zop1.D + /// svbool_t svcmple[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) + /// CMPHS Presult.D, Pg/Z, Zop2.D, Zop1.D /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareLessThanOrEqual(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Compare not equal to /// - /// svbool_t svcmpne[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) - /// CMPNE Presult.B, Pg/Z, Zop1.B, Zop2.B + /// svbool_t svcmpne[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) + /// CMPNE Presult.B, Pg/Z, Zop1.B, Zop2.B /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpne[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FCMNE Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpne[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FCMNE Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpne[_s16](svbool_t pg, svint16_t op1, svint16_t op2) - /// CMPNE Presult.H, Pg/Z, Zop1.H, Zop2.H + /// svbool_t svcmpne[_s16](svbool_t pg, svint16_t op1, svint16_t op2) + /// CMPNE Presult.H, Pg/Z, Zop1.H, Zop2.H /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpne_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) - /// CMPNE Presult.H, Pg/Z, Zop1.H, Zop2.D + /// svbool_t svcmpne_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) + /// CMPNE Presult.H, Pg/Z, Zop1.H, Zop2.D /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpne[_s32](svbool_t pg, svint32_t op1, svint32_t op2) - /// CMPNE Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpne[_s32](svbool_t pg, svint32_t op1, svint32_t op2) + /// CMPNE Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpne_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) - /// CMPNE Presult.S, Pg/Z, Zop1.S, Zop2.D + /// svbool_t svcmpne_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) + /// CMPNE Presult.S, Pg/Z, Zop1.S, Zop2.D /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpne[_s64](svbool_t pg, svint64_t op1, svint64_t op2) - /// CMPNE Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpne[_s64](svbool_t pg, svint64_t op1, svint64_t op2) + /// CMPNE Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpne[_s8](svbool_t pg, svint8_t op1, svint8_t op2) - /// CMPNE Presult.B, Pg/Z, Zop1.B, Zop2.B + /// svbool_t svcmpne[_s8](svbool_t pg, svint8_t op1, svint8_t op2) + /// CMPNE Presult.B, Pg/Z, Zop1.B, Zop2.B /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpne_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) - /// CMPNE Presult.B, Pg/Z, Zop1.B, Zop2.D + /// svbool_t svcmpne_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) + /// CMPNE Presult.B, Pg/Z, Zop1.B, Zop2.D /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpne[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FCMNE Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpne[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FCMNE Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpne[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) - /// CMPNE Presult.H, Pg/Z, Zop1.H, Zop2.H + /// svbool_t svcmpne[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) + /// CMPNE Presult.H, Pg/Z, Zop1.H, Zop2.H /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpne[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) - /// CMPNE Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpne[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) + /// CMPNE Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpne[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) - /// CMPNE Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpne[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) + /// CMPNE Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareNotEqualTo(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Compare unordered with /// - /// svbool_t svcmpuo[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FCMUO Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpuo[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FCMUO Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareUnordered(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareUnordered(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svcmpuo[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FCMUO Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpuo[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FCMUO Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareUnordered(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CompareUnordered(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Compute vector addresses for 16-bit data /// - /// svuint32_t svadrh[_u32base]_[s32]index(svuint32_t bases, svint32_t indices) - /// ADR Zresult.S, [Zbases.S, Zindices.S, LSL #1] + /// svuint32_t svadrh[_u32base]_[s32]index(svuint32_t bases, svint32_t indices) + /// ADR Zresult.S, [Zbases.S, Zindices.S, LSL #1] /// - public static unsafe Vector Compute16BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector Compute16BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svadrh[_u32base]_[u32]index(svuint32_t bases, svuint32_t indices) - /// ADR Zresult.S, [Zbases.S, Zindices.S, LSL #1] + /// svuint32_t svadrh[_u32base]_[u32]index(svuint32_t bases, svuint32_t indices) + /// ADR Zresult.S, [Zbases.S, Zindices.S, LSL #1] /// - public static unsafe Vector Compute16BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector Compute16BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svadrh[_u64base]_[s64]index(svuint64_t bases, svint64_t indices) - /// ADR Zresult.D, [Zbases.D, Zindices.D, LSL #1] + /// svuint64_t svadrh[_u64base]_[s64]index(svuint64_t bases, svint64_t indices) + /// ADR Zresult.D, [Zbases.D, Zindices.D, LSL #1] /// - public static unsafe Vector Compute16BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector Compute16BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svadrh[_u64base]_[u64]index(svuint64_t bases, svuint64_t indices) - /// ADR Zresult.D, [Zbases.D, Zindices.D, LSL #1] + /// svuint64_t svadrh[_u64base]_[u64]index(svuint64_t bases, svuint64_t indices) + /// ADR Zresult.D, [Zbases.D, Zindices.D, LSL #1] /// - public static unsafe Vector Compute16BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector Compute16BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } // Compute vector addresses for 32-bit data /// - /// svuint32_t svadrw[_u32base]_[s32]index(svuint32_t bases, svint32_t indices) - /// ADR Zresult.S, [Zbases.S, Zindices.S, LSL #2] + /// svuint32_t svadrw[_u32base]_[s32]index(svuint32_t bases, svint32_t indices) + /// ADR Zresult.S, [Zbases.S, Zindices.S, LSL #2] /// - public static unsafe Vector Compute32BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector Compute32BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svadrw[_u32base]_[u32]index(svuint32_t bases, svuint32_t indices) - /// ADR Zresult.S, [Zbases.S, Zindices.S, LSL #2] + /// svuint32_t svadrw[_u32base]_[u32]index(svuint32_t bases, svuint32_t indices) + /// ADR Zresult.S, [Zbases.S, Zindices.S, LSL #2] /// - public static unsafe Vector Compute32BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector Compute32BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svadrw[_u64base]_[s64]index(svuint64_t bases, svint64_t indices) - /// ADR Zresult.D, [Zbases.D, Zindices.D, LSL #2] + /// svuint64_t svadrw[_u64base]_[s64]index(svuint64_t bases, svint64_t indices) + /// ADR Zresult.D, [Zbases.D, Zindices.D, LSL #2] /// - public static unsafe Vector Compute32BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector Compute32BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svadrw[_u64base]_[u64]index(svuint64_t bases, svuint64_t indices) - /// ADR Zresult.D, [Zbases.D, Zindices.D, LSL #2] + /// svuint64_t svadrw[_u64base]_[u64]index(svuint64_t bases, svuint64_t indices) + /// ADR Zresult.D, [Zbases.D, Zindices.D, LSL #2] /// - public static unsafe Vector Compute32BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector Compute32BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } // Compute vector addresses for 64-bit data /// - /// svuint32_t svadrd[_u32base]_[s32]index(svuint32_t bases, svint32_t indices) - /// ADR Zresult.S, [Zbases.S, Zindices.S, LSL #3] + /// svuint32_t svadrd[_u32base]_[s32]index(svuint32_t bases, svint32_t indices) + /// ADR Zresult.S, [Zbases.S, Zindices.S, LSL #3] /// - public static unsafe Vector Compute64BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector Compute64BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svadrd[_u32base]_[u32]index(svuint32_t bases, svuint32_t indices) - /// ADR Zresult.S, [Zbases.S, Zindices.S, LSL #3] + /// svuint32_t svadrd[_u32base]_[u32]index(svuint32_t bases, svuint32_t indices) + /// ADR Zresult.S, [Zbases.S, Zindices.S, LSL #3] /// - public static unsafe Vector Compute64BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector Compute64BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svadrd[_u64base]_[s64]index(svuint64_t bases, svint64_t indices) - /// ADR Zresult.D, [Zbases.D, Zindices.D, LSL #3] + /// svuint64_t svadrd[_u64base]_[s64]index(svuint64_t bases, svint64_t indices) + /// ADR Zresult.D, [Zbases.D, Zindices.D, LSL #3] /// - public static unsafe Vector Compute64BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector Compute64BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svadrd[_u64base]_[u64]index(svuint64_t bases, svuint64_t indices) - /// ADR Zresult.D, [Zbases.D, Zindices.D, LSL #3] + /// svuint64_t svadrd[_u64base]_[u64]index(svuint64_t bases, svuint64_t indices) + /// ADR Zresult.D, [Zbases.D, Zindices.D, LSL #3] /// - public static unsafe Vector Compute64BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector Compute64BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } // Compute vector addresses for 8-bit data /// - /// svuint32_t svadrb[_u32base]_[s32]offset(svuint32_t bases, svint32_t offsets) - /// ADR Zresult.S, [Zbases.S, Zoffsets.S] + /// svuint32_t svadrb[_u32base]_[s32]offset(svuint32_t bases, svint32_t offsets) + /// ADR Zresult.S, [Zbases.S, Zoffsets.S] /// - public static unsafe Vector Compute8BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector Compute8BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svadrb[_u32base]_[u32]offset(svuint32_t bases, svuint32_t offsets) - /// ADR Zresult.S, [Zbases.S, Zoffsets.S] + /// svuint32_t svadrb[_u32base]_[u32]offset(svuint32_t bases, svuint32_t offsets) + /// ADR Zresult.S, [Zbases.S, Zoffsets.S] /// - public static unsafe Vector Compute8BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector Compute8BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svadrb[_u64base]_[s64]offset(svuint64_t bases, svint64_t offsets) - /// ADR Zresult.D, [Zbases.D, Zoffsets.D] + /// svuint64_t svadrb[_u64base]_[s64]offset(svuint64_t bases, svint64_t offsets) + /// ADR Zresult.D, [Zbases.D, Zoffsets.D] /// - public static unsafe Vector Compute8BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector Compute8BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svadrb[_u64base]_[u64]offset(svuint64_t bases, svuint64_t offsets) - /// ADR Zresult.D, [Zbases.D, Zoffsets.D] + /// svuint64_t svadrb[_u64base]_[u64]offset(svuint64_t bases, svuint64_t offsets) + /// ADR Zresult.D, [Zbases.D, Zoffsets.D] /// - public static unsafe Vector Compute8BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector Compute8BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } // Conditionally extract element after last /// - /// svuint8_t svclasta[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) - /// CLASTA Btied, Pg, Btied, Zdata.B + /// svuint8_t svclasta[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) + /// CLASTA Btied, Pg, Btied, Zdata.B /// - public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } /// - /// uint8_t svclasta[_n_u8](svbool_t pg, uint8_t fallback, svuint8_t data) - /// CLASTA Wtied, Pg, Wtied, Zdata.B + /// uint8_t svclasta[_n_u8](svbool_t pg, uint8_t fallback, svuint8_t data) + /// CLASTA Wtied, Pg, Wtied, Zdata.B /// - public static unsafe byte ConditionalExtractAfterLastActiveElement(Vector mask, byte defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + public static byte ConditionalExtractAfterLastActiveElement(Vector mask, byte defaultValues, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svclasta[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) - /// CLASTA Dtied, Pg, Dtied, Zdata.D + /// svfloat64_t svclasta[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) + /// CLASTA Dtied, Pg, Dtied, Zdata.D /// - public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } /// - /// float64_t svclasta[_n_f64](svbool_t pg, float64_t fallback, svfloat64_t data) - /// CLASTA Dtied, Pg, Dtied, Zdata.D + /// float64_t svclasta[_n_f64](svbool_t pg, float64_t fallback, svfloat64_t data) + /// CLASTA Dtied, Pg, Dtied, Zdata.D /// - public static unsafe double ConditionalExtractAfterLastActiveElement(Vector mask, double defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + public static double ConditionalExtractAfterLastActiveElement(Vector mask, double defaultValues, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svclasta[_s16](svbool_t pg, svint16_t fallback, svint16_t data) - /// CLASTA Htied, Pg, Htied, Zdata.H + /// svint16_t svclasta[_s16](svbool_t pg, svint16_t fallback, svint16_t data) + /// CLASTA Htied, Pg, Htied, Zdata.H /// - public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } /// - /// int16_t svclasta[_n_s16](svbool_t pg, int16_t fallback, svint16_t data) - /// CLASTA Wtied, Pg, Wtied, Zdata.H + /// int16_t svclasta[_n_s16](svbool_t pg, int16_t fallback, svint16_t data) + /// CLASTA Wtied, Pg, Wtied, Zdata.H /// - public static unsafe short ConditionalExtractAfterLastActiveElement(Vector mask, short defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + public static short ConditionalExtractAfterLastActiveElement(Vector mask, short defaultValues, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svclasta[_s32](svbool_t pg, svint32_t fallback, svint32_t data) - /// CLASTA Stied, Pg, Stied, Zdata.S + /// svint32_t svclasta[_s32](svbool_t pg, svint32_t fallback, svint32_t data) + /// CLASTA Stied, Pg, Stied, Zdata.S /// - public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } /// - /// int32_t svclasta[_n_s32](svbool_t pg, int32_t fallback, svint32_t data) - /// CLASTA Wtied, Pg, Wtied, Zdata.S + /// int32_t svclasta[_n_s32](svbool_t pg, int32_t fallback, svint32_t data) + /// CLASTA Wtied, Pg, Wtied, Zdata.S /// - public static unsafe int ConditionalExtractAfterLastActiveElement(Vector mask, int defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + public static int ConditionalExtractAfterLastActiveElement(Vector mask, int defaultValues, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svclasta[_s64](svbool_t pg, svint64_t fallback, svint64_t data) - /// CLASTA Dtied, Pg, Dtied, Zdata.D + /// svint64_t svclasta[_s64](svbool_t pg, svint64_t fallback, svint64_t data) + /// CLASTA Dtied, Pg, Dtied, Zdata.D /// - public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } /// - /// int64_t svclasta[_n_s64](svbool_t pg, int64_t fallback, svint64_t data) - /// CLASTA Xtied, Pg, Xtied, Zdata.D + /// int64_t svclasta[_n_s64](svbool_t pg, int64_t fallback, svint64_t data) + /// CLASTA Xtied, Pg, Xtied, Zdata.D /// - public static unsafe long ConditionalExtractAfterLastActiveElement(Vector mask, long defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + public static long ConditionalExtractAfterLastActiveElement(Vector mask, long defaultValues, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svclasta[_s8](svbool_t pg, svint8_t fallback, svint8_t data) - /// CLASTA Btied, Pg, Btied, Zdata.B + /// svint8_t svclasta[_s8](svbool_t pg, svint8_t fallback, svint8_t data) + /// CLASTA Btied, Pg, Btied, Zdata.B /// - public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } /// - /// int8_t svclasta[_n_s8](svbool_t pg, int8_t fallback, svint8_t data) - /// CLASTA Wtied, Pg, Wtied, Zdata.B + /// int8_t svclasta[_n_s8](svbool_t pg, int8_t fallback, svint8_t data) + /// CLASTA Wtied, Pg, Wtied, Zdata.B /// - public static unsafe sbyte ConditionalExtractAfterLastActiveElement(Vector mask, sbyte defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + public static sbyte ConditionalExtractAfterLastActiveElement(Vector mask, sbyte defaultValues, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svclasta[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) - /// CLASTA Stied, Pg, Stied, Zdata.S + /// svfloat32_t svclasta[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) + /// CLASTA Stied, Pg, Stied, Zdata.S /// - public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } /// - /// float32_t svclasta[_n_f32](svbool_t pg, float32_t fallback, svfloat32_t data) - /// CLASTA Stied, Pg, Stied, Zdata.S + /// float32_t svclasta[_n_f32](svbool_t pg, float32_t fallback, svfloat32_t data) + /// CLASTA Stied, Pg, Stied, Zdata.S /// - public static unsafe float ConditionalExtractAfterLastActiveElement(Vector mask, float defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + public static float ConditionalExtractAfterLastActiveElement(Vector mask, float defaultValues, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svclasta[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) - /// CLASTA Htied, Pg, Htied, Zdata.H + /// svuint16_t svclasta[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) + /// CLASTA Htied, Pg, Htied, Zdata.H /// - public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } /// - /// uint16_t svclasta[_n_u16](svbool_t pg, uint16_t fallback, svuint16_t data) - /// CLASTA Wtied, Pg, Wtied, Zdata.H + /// uint16_t svclasta[_n_u16](svbool_t pg, uint16_t fallback, svuint16_t data) + /// CLASTA Wtied, Pg, Wtied, Zdata.H /// - public static unsafe ushort ConditionalExtractAfterLastActiveElement(Vector mask, ushort defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + public static ushort ConditionalExtractAfterLastActiveElement(Vector mask, ushort defaultValues, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svclasta[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) - /// CLASTA Stied, Pg, Stied, Zdata.S + /// svuint32_t svclasta[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) + /// CLASTA Stied, Pg, Stied, Zdata.S /// - public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } /// - /// uint32_t svclasta[_n_u32](svbool_t pg, uint32_t fallback, svuint32_t data) - /// CLASTA Wtied, Pg, Wtied, Zdata.S + /// uint32_t svclasta[_n_u32](svbool_t pg, uint32_t fallback, svuint32_t data) + /// CLASTA Wtied, Pg, Wtied, Zdata.S /// - public static unsafe uint ConditionalExtractAfterLastActiveElement(Vector mask, uint defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + public static uint ConditionalExtractAfterLastActiveElement(Vector mask, uint defaultValues, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svclasta[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) - /// CLASTA Dtied, Pg, Dtied, Zdata.D + /// svuint64_t svclasta[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) + /// CLASTA Dtied, Pg, Dtied, Zdata.D /// - public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svclasta[_n_u64](svbool_t pg, uint64_t fallback, svuint64_t data) - /// CLASTA Xtied, Pg, Xtied, Zdata.D + /// uint64_t svclasta[_n_u64](svbool_t pg, uint64_t fallback, svuint64_t data) + /// CLASTA Xtied, Pg, Xtied, Zdata.D /// - public static unsafe ulong ConditionalExtractAfterLastActiveElement(Vector mask, ulong defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + public static ulong ConditionalExtractAfterLastActiveElement(Vector mask, ulong defaultValues, Vector data) { throw new PlatformNotSupportedException(); } // Conditionally extract element after last /// - /// svuint8_t svclasta[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) - /// CLASTA Ztied.B, Pg, Ztied.B, Zdata.B + /// svuint8_t svclasta[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) + /// CLASTA Ztied.B, Pg, Ztied.B, Zdata.B /// - public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svclasta[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) - /// CLASTA Ztied.D, Pg, Ztied.D, Zdata.D + /// svfloat64_t svclasta[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) + /// CLASTA Ztied.D, Pg, Ztied.D, Zdata.D /// - public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svclasta[_s16](svbool_t pg, svint16_t fallback, svint16_t data) - /// CLASTA Ztied.H, Pg, Ztied.H, Zdata.H + /// svint16_t svclasta[_s16](svbool_t pg, svint16_t fallback, svint16_t data) + /// CLASTA Ztied.H, Pg, Ztied.H, Zdata.H /// - public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svclasta[_s32](svbool_t pg, svint32_t fallback, svint32_t data) - /// CLASTA Ztied.S, Pg, Ztied.S, Zdata.S + /// svint32_t svclasta[_s32](svbool_t pg, svint32_t fallback, svint32_t data) + /// CLASTA Ztied.S, Pg, Ztied.S, Zdata.S /// - public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svclasta[_s64](svbool_t pg, svint64_t fallback, svint64_t data) - /// CLASTA Ztied.D, Pg, Ztied.D, Zdata.D + /// svint64_t svclasta[_s64](svbool_t pg, svint64_t fallback, svint64_t data) + /// CLASTA Ztied.D, Pg, Ztied.D, Zdata.D /// - public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svclasta[_s8](svbool_t pg, svint8_t fallback, svint8_t data) - /// CLASTA Ztied.B, Pg, Ztied.B, Zdata.B + /// svint8_t svclasta[_s8](svbool_t pg, svint8_t fallback, svint8_t data) + /// CLASTA Ztied.B, Pg, Ztied.B, Zdata.B /// - public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svclasta[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) - /// CLASTA Ztied.S, Pg, Ztied.S, Zdata.S + /// svfloat32_t svclasta[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) + /// CLASTA Ztied.S, Pg, Ztied.S, Zdata.S /// - public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svclasta[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) - /// CLASTA Ztied.H, Pg, Ztied.H, Zdata.H + /// svuint16_t svclasta[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) + /// CLASTA Ztied.H, Pg, Ztied.H, Zdata.H /// - public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svclasta[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) - /// CLASTA Ztied.S, Pg, Ztied.S, Zdata.S + /// svuint32_t svclasta[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) + /// CLASTA Ztied.S, Pg, Ztied.S, Zdata.S /// - public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svclasta[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) - /// CLASTA Ztied.D, Pg, Ztied.D, Zdata.D + /// svuint64_t svclasta[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) + /// CLASTA Ztied.D, Pg, Ztied.D, Zdata.D /// - public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } // Conditionally extract last element /// - /// svuint8_t svclastb[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) - /// CLASTB Btied, Pg, Btied, Zdata.B + /// svuint8_t svclastb[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) + /// CLASTB Btied, Pg, Btied, Zdata.B /// - public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } /// - /// uint8_t svclastb[_n_u8](svbool_t pg, uint8_t fallback, svuint8_t data) - /// CLASTB Wtied, Pg, Wtied, Zdata.B + /// uint8_t svclastb[_n_u8](svbool_t pg, uint8_t fallback, svuint8_t data) + /// CLASTB Wtied, Pg, Wtied, Zdata.B /// - public static unsafe byte ConditionalExtractLastActiveElement(Vector mask, byte defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + public static byte ConditionalExtractLastActiveElement(Vector mask, byte defaultValues, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svclastb[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) - /// CLASTB Dtied, Pg, Dtied, Zdata.D + /// svfloat64_t svclastb[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) + /// CLASTB Dtied, Pg, Dtied, Zdata.D /// - public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } /// - /// float64_t svclastb[_n_f64](svbool_t pg, float64_t fallback, svfloat64_t data) - /// CLASTB Dtied, Pg, Dtied, Zdata.D + /// float64_t svclastb[_n_f64](svbool_t pg, float64_t fallback, svfloat64_t data) + /// CLASTB Dtied, Pg, Dtied, Zdata.D /// - public static unsafe double ConditionalExtractLastActiveElement(Vector mask, double defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + public static double ConditionalExtractLastActiveElement(Vector mask, double defaultValues, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svclastb[_s16](svbool_t pg, svint16_t fallback, svint16_t data) - /// CLASTB Htied, Pg, Htied, Zdata.H + /// svint16_t svclastb[_s16](svbool_t pg, svint16_t fallback, svint16_t data) + /// CLASTB Htied, Pg, Htied, Zdata.H /// - public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } /// - /// int16_t svclastb[_n_s16](svbool_t pg, int16_t fallback, svint16_t data) - /// CLASTB Wtied, Pg, Wtied, Zdata.H + /// int16_t svclastb[_n_s16](svbool_t pg, int16_t fallback, svint16_t data) + /// CLASTB Wtied, Pg, Wtied, Zdata.H /// - public static unsafe short ConditionalExtractLastActiveElement(Vector mask, short defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + public static short ConditionalExtractLastActiveElement(Vector mask, short defaultValues, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svclastb[_s32](svbool_t pg, svint32_t fallback, svint32_t data) - /// CLASTB Stied, Pg, Stied, Zdata.S + /// svint32_t svclastb[_s32](svbool_t pg, svint32_t fallback, svint32_t data) + /// CLASTB Stied, Pg, Stied, Zdata.S /// - public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } /// - /// int32_t svclastb[_n_s32](svbool_t pg, int32_t fallback, svint32_t data) - /// CLASTB Wtied, Pg, Wtied, Zdata.S + /// int32_t svclastb[_n_s32](svbool_t pg, int32_t fallback, svint32_t data) + /// CLASTB Wtied, Pg, Wtied, Zdata.S /// - public static unsafe int ConditionalExtractLastActiveElement(Vector mask, int defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + public static int ConditionalExtractLastActiveElement(Vector mask, int defaultValues, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svclastb[_s64](svbool_t pg, svint64_t fallback, svint64_t data) - /// CLASTB Dtied, Pg, Dtied, Zdata.D + /// svint64_t svclastb[_s64](svbool_t pg, svint64_t fallback, svint64_t data) + /// CLASTB Dtied, Pg, Dtied, Zdata.D /// - public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } /// - /// int64_t svclastb[_n_s64](svbool_t pg, int64_t fallback, svint64_t data) - /// CLASTB Xtied, Pg, Xtied, Zdata.D + /// int64_t svclastb[_n_s64](svbool_t pg, int64_t fallback, svint64_t data) + /// CLASTB Xtied, Pg, Xtied, Zdata.D /// - public static unsafe long ConditionalExtractLastActiveElement(Vector mask, long defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + public static long ConditionalExtractLastActiveElement(Vector mask, long defaultValues, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svclastb[_s8](svbool_t pg, svint8_t fallback, svint8_t data) - /// CLASTB Btied, Pg, Btied, Zdata.B + /// svint8_t svclastb[_s8](svbool_t pg, svint8_t fallback, svint8_t data) + /// CLASTB Btied, Pg, Btied, Zdata.B /// - public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } /// - /// int8_t svclastb[_n_s8](svbool_t pg, int8_t fallback, svint8_t data) - /// CLASTB Wtied, Pg, Wtied, Zdata.B + /// int8_t svclastb[_n_s8](svbool_t pg, int8_t fallback, svint8_t data) + /// CLASTB Wtied, Pg, Wtied, Zdata.B /// - public static unsafe sbyte ConditionalExtractLastActiveElement(Vector mask, sbyte defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + public static sbyte ConditionalExtractLastActiveElement(Vector mask, sbyte defaultValues, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svclastb[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) - /// CLASTB Stied, Pg, Stied, Zdata.S + /// svfloat32_t svclastb[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) + /// CLASTB Stied, Pg, Stied, Zdata.S /// - public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } /// - /// float32_t svclastb[_n_f32](svbool_t pg, float32_t fallback, svfloat32_t data) - /// CLASTB Stied, Pg, Stied, Zdata.S + /// float32_t svclastb[_n_f32](svbool_t pg, float32_t fallback, svfloat32_t data) + /// CLASTB Stied, Pg, Stied, Zdata.S /// - public static unsafe float ConditionalExtractLastActiveElement(Vector mask, float defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + public static float ConditionalExtractLastActiveElement(Vector mask, float defaultValues, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svclastb[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) - /// CLASTB Htied, Pg, Htied, Zdata.H + /// svuint16_t svclastb[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) + /// CLASTB Htied, Pg, Htied, Zdata.H /// - public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } /// - /// uint16_t svclastb[_n_u16](svbool_t pg, uint16_t fallback, svuint16_t data) - /// CLASTB Wtied, Pg, Wtied, Zdata.H + /// uint16_t svclastb[_n_u16](svbool_t pg, uint16_t fallback, svuint16_t data) + /// CLASTB Wtied, Pg, Wtied, Zdata.H /// - public static unsafe ushort ConditionalExtractLastActiveElement(Vector mask, ushort defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + public static ushort ConditionalExtractLastActiveElement(Vector mask, ushort defaultValues, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svclastb[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) - /// CLASTB Stied, Pg, Stied, Zdata.S + /// svuint32_t svclastb[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) + /// CLASTB Stied, Pg, Stied, Zdata.S /// - public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } /// - /// uint32_t svclastb[_n_u32](svbool_t pg, uint32_t fallback, svuint32_t data) - /// CLASTB Wtied, Pg, Wtied, Zdata.S + /// uint32_t svclastb[_n_u32](svbool_t pg, uint32_t fallback, svuint32_t data) + /// CLASTB Wtied, Pg, Wtied, Zdata.S /// - public static unsafe uint ConditionalExtractLastActiveElement(Vector mask, uint defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + public static uint ConditionalExtractLastActiveElement(Vector mask, uint defaultValues, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svclastb[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) - /// CLASTB Dtied, Pg, Dtied, Zdata.D + /// svuint64_t svclastb[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) + /// CLASTB Dtied, Pg, Dtied, Zdata.D /// - public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svclastb[_n_u64](svbool_t pg, uint64_t fallback, svuint64_t data) - /// CLASTB Xtied, Pg, Xtied, Zdata.D + /// uint64_t svclastb[_n_u64](svbool_t pg, uint64_t fallback, svuint64_t data) + /// CLASTB Xtied, Pg, Xtied, Zdata.D /// - public static unsafe ulong ConditionalExtractLastActiveElement(Vector mask, ulong defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + public static ulong ConditionalExtractLastActiveElement(Vector mask, ulong defaultValues, Vector data) { throw new PlatformNotSupportedException(); } // Conditionally extract last element /// - /// svuint8_t svclastb[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) - /// CLASTB Ztied.B, Pg, Ztied.B, Zdata.B + /// svuint8_t svclastb[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) + /// CLASTB Ztied.B, Pg, Ztied.B, Zdata.B /// - public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svclastb[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) - /// CLASTB Ztied.D, Pg, Ztied.D, Zdata.D + /// svfloat64_t svclastb[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) + /// CLASTB Ztied.D, Pg, Ztied.D, Zdata.D /// - public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svclastb[_s16](svbool_t pg, svint16_t fallback, svint16_t data) - /// CLASTB Ztied.H, Pg, Ztied.H, Zdata.H + /// svint16_t svclastb[_s16](svbool_t pg, svint16_t fallback, svint16_t data) + /// CLASTB Ztied.H, Pg, Ztied.H, Zdata.H /// - public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svclastb[_s32](svbool_t pg, svint32_t fallback, svint32_t data) - /// CLASTB Ztied.S, Pg, Ztied.S, Zdata.S + /// svint32_t svclastb[_s32](svbool_t pg, svint32_t fallback, svint32_t data) + /// CLASTB Ztied.S, Pg, Ztied.S, Zdata.S /// - public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svclastb[_s64](svbool_t pg, svint64_t fallback, svint64_t data) - /// CLASTB Ztied.D, Pg, Ztied.D, Zdata.D + /// svint64_t svclastb[_s64](svbool_t pg, svint64_t fallback, svint64_t data) + /// CLASTB Ztied.D, Pg, Ztied.D, Zdata.D /// - public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svclastb[_s8](svbool_t pg, svint8_t fallback, svint8_t data) - /// CLASTB Ztied.B, Pg, Ztied.B, Zdata.B + /// svint8_t svclastb[_s8](svbool_t pg, svint8_t fallback, svint8_t data) + /// CLASTB Ztied.B, Pg, Ztied.B, Zdata.B /// - public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svclastb[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) - /// CLASTB Ztied.S, Pg, Ztied.S, Zdata.S + /// svfloat32_t svclastb[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) + /// CLASTB Ztied.S, Pg, Ztied.S, Zdata.S /// - public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svclastb[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) - /// CLASTB Ztied.H, Pg, Ztied.H, Zdata.H + /// svuint16_t svclastb[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) + /// CLASTB Ztied.H, Pg, Ztied.H, Zdata.H /// - public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svclastb[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) - /// CLASTB Ztied.S, Pg, Ztied.S, Zdata.S + /// svuint32_t svclastb[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) + /// CLASTB Ztied.S, Pg, Ztied.S, Zdata.S /// - public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svclastb[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) - /// CLASTB Ztied.D, Pg, Ztied.D, Zdata.D + /// svuint64_t svclastb[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) + /// CLASTB Ztied.D, Pg, Ztied.D, Zdata.D /// - public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } // Conditionally select elements /// - /// svuint8_t svsel[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) - /// SEL Zresult.B, Pg, Zop1.B, Zop2.B + /// svuint8_t svsel[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) + /// SEL Zresult.B, Pg, Zop1.B, Zop2.B /// - public static unsafe Vector ConditionalSelect(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalSelect(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svsel[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// SEL Zresult.D, Pg, Zop1.D, Zop2.D + /// svfloat64_t svsel[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// SEL Zresult.D, Pg, Zop1.D, Zop2.D /// - public static unsafe Vector ConditionalSelect(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalSelect(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svsel[_s16](svbool_t pg, svint16_t op1, svint16_t op2) - /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) - /// SEL Zresult.H, Pg, Zop1.H, Zop2.H + /// svint16_t svsel[_s16](svbool_t pg, svint16_t op1, svint16_t op2) + /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) + /// SEL Zresult.H, Pg, Zop1.H, Zop2.H /// - public static unsafe Vector ConditionalSelect(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalSelect(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svsel[_s32](svbool_t pg, svint32_t op1, svint32_t op2) - /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) - /// SEL Zresult.S, Pg, Zop1.S, Zop2.S + /// svint32_t svsel[_s32](svbool_t pg, svint32_t op1, svint32_t op2) + /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) + /// SEL Zresult.S, Pg, Zop1.S, Zop2.S /// - public static unsafe Vector ConditionalSelect(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalSelect(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svsel[_s64](svbool_t pg, svint64_t op1, svint64_t op2) - /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) - /// SEL Zresult.D, Pg, Zop1.D, Zop2.D + /// svint64_t svsel[_s64](svbool_t pg, svint64_t op1, svint64_t op2) + /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) + /// SEL Zresult.D, Pg, Zop1.D, Zop2.D /// - public static unsafe Vector ConditionalSelect(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalSelect(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svsel[_s8](svbool_t pg, svint8_t op1, svint8_t op2) - /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) - /// SEL Zresult.B, Pg, Zop1.B, Zop2.B + /// svint8_t svsel[_s8](svbool_t pg, svint8_t op1, svint8_t op2) + /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) + /// SEL Zresult.B, Pg, Zop1.B, Zop2.B /// - public static unsafe Vector ConditionalSelect(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalSelect(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svsel[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// SEL Zresult.S, Pg, Zop1.S, Zop2.S + /// svfloat32_t svsel[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// SEL Zresult.S, Pg, Zop1.S, Zop2.S /// - public static unsafe Vector ConditionalSelect(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalSelect(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svsel[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) - /// SEL Zresult.H, Pg, Zop1.H, Zop2.H + /// svuint16_t svsel[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) + /// SEL Zresult.H, Pg, Zop1.H, Zop2.H /// - public static unsafe Vector ConditionalSelect(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalSelect(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svsel[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) - /// SEL Zresult.S, Pg, Zop1.S, Zop2.S + /// svuint32_t svsel[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) + /// SEL Zresult.S, Pg, Zop1.S, Zop2.S /// - public static unsafe Vector ConditionalSelect(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalSelect(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svsel[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) - /// SEL Zresult.D, Pg, Zop1.D, Zop2.D + /// svuint64_t svsel[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) + /// SEL Zresult.D, Pg, Zop1.D, Zop2.D /// - public static unsafe Vector ConditionalSelect(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ConditionalSelect(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Floating-point convert /// - /// svfloat64_t svcvt_f64[_s32]_m(svfloat64_t inactive, svbool_t pg, svint32_t op) - /// svfloat64_t svcvt_f64[_s32]_x(svbool_t pg, svint32_t op) - /// svfloat64_t svcvt_f64[_s32]_z(svbool_t pg, svint32_t op) - /// SCVTF Zresult.D, Pg/M, Zop.S + /// svfloat64_t svcvt_f64[_s32]_m(svfloat64_t inactive, svbool_t pg, svint32_t op) + /// svfloat64_t svcvt_f64[_s32]_x(svbool_t pg, svint32_t op) + /// svfloat64_t svcvt_f64[_s32]_z(svbool_t pg, svint32_t op) + /// SCVTF Zresult.D, Pg/M, Zop.S /// - public static unsafe Vector ConvertToDouble(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ConvertToDouble(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svcvt_f64[_s64]_m(svfloat64_t inactive, svbool_t pg, svint64_t op) - /// svfloat64_t svcvt_f64[_s64]_x(svbool_t pg, svint64_t op) - /// svfloat64_t svcvt_f64[_s64]_z(svbool_t pg, svint64_t op) - /// SCVTF Zresult.D, Pg/M, Zop.D + /// svfloat64_t svcvt_f64[_s64]_m(svfloat64_t inactive, svbool_t pg, svint64_t op) + /// svfloat64_t svcvt_f64[_s64]_x(svbool_t pg, svint64_t op) + /// svfloat64_t svcvt_f64[_s64]_z(svbool_t pg, svint64_t op) + /// SCVTF Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ConvertToDouble(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ConvertToDouble(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svcvt_f64[_f32]_m(svfloat64_t inactive, svbool_t pg, svfloat32_t op) - /// svfloat64_t svcvt_f64[_f32]_x(svbool_t pg, svfloat32_t op) - /// svfloat64_t svcvt_f64[_f32]_z(svbool_t pg, svfloat32_t op) - /// FCVT Zresult.D, Pg/M, Zop.S + /// svfloat64_t svcvt_f64[_f32]_m(svfloat64_t inactive, svbool_t pg, svfloat32_t op) + /// svfloat64_t svcvt_f64[_f32]_x(svbool_t pg, svfloat32_t op) + /// svfloat64_t svcvt_f64[_f32]_z(svbool_t pg, svfloat32_t op) + /// FCVT Zresult.D, Pg/M, Zop.S /// - public static unsafe Vector ConvertToDouble(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ConvertToDouble(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svcvt_f64[_u32]_m(svfloat64_t inactive, svbool_t pg, svuint32_t op) - /// svfloat64_t svcvt_f64[_u32]_x(svbool_t pg, svuint32_t op) - /// svfloat64_t svcvt_f64[_u32]_z(svbool_t pg, svuint32_t op) - /// UCVTF Zresult.D, Pg/M, Zop.S + /// svfloat64_t svcvt_f64[_u32]_m(svfloat64_t inactive, svbool_t pg, svuint32_t op) + /// svfloat64_t svcvt_f64[_u32]_x(svbool_t pg, svuint32_t op) + /// svfloat64_t svcvt_f64[_u32]_z(svbool_t pg, svuint32_t op) + /// UCVTF Zresult.D, Pg/M, Zop.S /// - public static unsafe Vector ConvertToDouble(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ConvertToDouble(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svcvt_f64[_u64]_m(svfloat64_t inactive, svbool_t pg, svuint64_t op) - /// svfloat64_t svcvt_f64[_u64]_x(svbool_t pg, svuint64_t op) - /// svfloat64_t svcvt_f64[_u64]_z(svbool_t pg, svuint64_t op) - /// UCVTF Zresult.D, Pg/M, Zop.D + /// svfloat64_t svcvt_f64[_u64]_m(svfloat64_t inactive, svbool_t pg, svuint64_t op) + /// svfloat64_t svcvt_f64[_u64]_x(svbool_t pg, svuint64_t op) + /// svfloat64_t svcvt_f64[_u64]_z(svbool_t pg, svuint64_t op) + /// UCVTF Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ConvertToDouble(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ConvertToDouble(Vector value) { throw new PlatformNotSupportedException(); } // Floating-point convert /// - /// svint32_t svcvt_s32[_f64]_m(svint32_t inactive, svbool_t pg, svfloat64_t op) - /// svint32_t svcvt_s32[_f64]_x(svbool_t pg, svfloat64_t op) - /// svint32_t svcvt_s32[_f64]_z(svbool_t pg, svfloat64_t op) - /// FCVTZS Zresult.S, Pg/M, Zop.D + /// svint32_t svcvt_s32[_f64]_m(svint32_t inactive, svbool_t pg, svfloat64_t op) + /// svint32_t svcvt_s32[_f64]_x(svbool_t pg, svfloat64_t op) + /// svint32_t svcvt_s32[_f64]_z(svbool_t pg, svfloat64_t op) + /// FCVTZS Zresult.S, Pg/M, Zop.D /// - public static unsafe Vector ConvertToInt32(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ConvertToInt32(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svcvt_s32[_f32]_m(svint32_t inactive, svbool_t pg, svfloat32_t op) - /// svint32_t svcvt_s32[_f32]_x(svbool_t pg, svfloat32_t op) - /// svint32_t svcvt_s32[_f32]_z(svbool_t pg, svfloat32_t op) - /// FCVTZS Zresult.S, Pg/M, Zop.S + /// svint32_t svcvt_s32[_f32]_m(svint32_t inactive, svbool_t pg, svfloat32_t op) + /// svint32_t svcvt_s32[_f32]_x(svbool_t pg, svfloat32_t op) + /// svint32_t svcvt_s32[_f32]_z(svbool_t pg, svfloat32_t op) + /// FCVTZS Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ConvertToInt32(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ConvertToInt32(Vector value) { throw new PlatformNotSupportedException(); } // Floating-point convert /// - /// svint64_t svcvt_s64[_f64]_m(svint64_t inactive, svbool_t pg, svfloat64_t op) - /// svint64_t svcvt_s64[_f64]_x(svbool_t pg, svfloat64_t op) - /// svint64_t svcvt_s64[_f64]_z(svbool_t pg, svfloat64_t op) - /// FCVTZS Zresult.D, Pg/M, Zop.D + /// svint64_t svcvt_s64[_f64]_m(svint64_t inactive, svbool_t pg, svfloat64_t op) + /// svint64_t svcvt_s64[_f64]_x(svbool_t pg, svfloat64_t op) + /// svint64_t svcvt_s64[_f64]_z(svbool_t pg, svfloat64_t op) + /// FCVTZS Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ConvertToInt64(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ConvertToInt64(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svcvt_s64[_f32]_m(svint64_t inactive, svbool_t pg, svfloat32_t op) - /// svint64_t svcvt_s64[_f32]_x(svbool_t pg, svfloat32_t op) - /// svint64_t svcvt_s64[_f32]_z(svbool_t pg, svfloat32_t op) - /// FCVTZS Zresult.D, Pg/M, Zop.S + /// svint64_t svcvt_s64[_f32]_m(svint64_t inactive, svbool_t pg, svfloat32_t op) + /// svint64_t svcvt_s64[_f32]_x(svbool_t pg, svfloat32_t op) + /// svint64_t svcvt_s64[_f32]_z(svbool_t pg, svfloat32_t op) + /// FCVTZS Zresult.D, Pg/M, Zop.S /// - public static unsafe Vector ConvertToInt64(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ConvertToInt64(Vector value) { throw new PlatformNotSupportedException(); } // Floating-point convert /// - /// svfloat32_t svcvt_f32[_f64]_m(svfloat32_t inactive, svbool_t pg, svfloat64_t op) - /// svfloat32_t svcvt_f32[_f64]_x(svbool_t pg, svfloat64_t op) - /// svfloat32_t svcvt_f32[_f64]_z(svbool_t pg, svfloat64_t op) - /// FCVT Zresult.S, Pg/M, Zop.D + /// svfloat32_t svcvt_f32[_f64]_m(svfloat32_t inactive, svbool_t pg, svfloat64_t op) + /// svfloat32_t svcvt_f32[_f64]_x(svbool_t pg, svfloat64_t op) + /// svfloat32_t svcvt_f32[_f64]_z(svbool_t pg, svfloat64_t op) + /// FCVT Zresult.S, Pg/M, Zop.D /// - public static unsafe Vector ConvertToSingle(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ConvertToSingle(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svcvt_f32[_s32]_m(svfloat32_t inactive, svbool_t pg, svint32_t op) - /// svfloat32_t svcvt_f32[_s32]_x(svbool_t pg, svint32_t op) - /// svfloat32_t svcvt_f32[_s32]_z(svbool_t pg, svint32_t op) - /// SCVTF Zresult.S, Pg/M, Zop.S + /// svfloat32_t svcvt_f32[_s32]_m(svfloat32_t inactive, svbool_t pg, svint32_t op) + /// svfloat32_t svcvt_f32[_s32]_x(svbool_t pg, svint32_t op) + /// svfloat32_t svcvt_f32[_s32]_z(svbool_t pg, svint32_t op) + /// SCVTF Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ConvertToSingle(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ConvertToSingle(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svcvt_f32[_s64]_m(svfloat32_t inactive, svbool_t pg, svint64_t op) - /// svfloat32_t svcvt_f32[_s64]_x(svbool_t pg, svint64_t op) - /// svfloat32_t svcvt_f32[_s64]_z(svbool_t pg, svint64_t op) - /// SCVTF Zresult.S, Pg/M, Zop.D + /// svfloat32_t svcvt_f32[_s64]_m(svfloat32_t inactive, svbool_t pg, svint64_t op) + /// svfloat32_t svcvt_f32[_s64]_x(svbool_t pg, svint64_t op) + /// svfloat32_t svcvt_f32[_s64]_z(svbool_t pg, svint64_t op) + /// SCVTF Zresult.S, Pg/M, Zop.D /// - public static unsafe Vector ConvertToSingle(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ConvertToSingle(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svcvt_f32[_u32]_m(svfloat32_t inactive, svbool_t pg, svuint32_t op) - /// svfloat32_t svcvt_f32[_u32]_x(svbool_t pg, svuint32_t op) - /// svfloat32_t svcvt_f32[_u32]_z(svbool_t pg, svuint32_t op) - /// UCVTF Zresult.S, Pg/M, Zop.S + /// svfloat32_t svcvt_f32[_u32]_m(svfloat32_t inactive, svbool_t pg, svuint32_t op) + /// svfloat32_t svcvt_f32[_u32]_x(svbool_t pg, svuint32_t op) + /// svfloat32_t svcvt_f32[_u32]_z(svbool_t pg, svuint32_t op) + /// UCVTF Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ConvertToSingle(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ConvertToSingle(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svcvt_f32[_u64]_m(svfloat32_t inactive, svbool_t pg, svuint64_t op) - /// svfloat32_t svcvt_f32[_u64]_x(svbool_t pg, svuint64_t op) - /// svfloat32_t svcvt_f32[_u64]_z(svbool_t pg, svuint64_t op) - /// UCVTF Zresult.S, Pg/M, Zop.D + /// svfloat32_t svcvt_f32[_u64]_m(svfloat32_t inactive, svbool_t pg, svuint64_t op) + /// svfloat32_t svcvt_f32[_u64]_x(svbool_t pg, svuint64_t op) + /// svfloat32_t svcvt_f32[_u64]_z(svbool_t pg, svuint64_t op) + /// UCVTF Zresult.S, Pg/M, Zop.D /// - public static unsafe Vector ConvertToSingle(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ConvertToSingle(Vector value) { throw new PlatformNotSupportedException(); } // Floating-point convert /// - /// svuint32_t svcvt_u32[_f64]_m(svuint32_t inactive, svbool_t pg, svfloat64_t op) - /// svuint32_t svcvt_u32[_f64]_x(svbool_t pg, svfloat64_t op) - /// svuint32_t svcvt_u32[_f64]_z(svbool_t pg, svfloat64_t op) - /// FCVTZU Zresult.S, Pg/M, Zop.D + /// svuint32_t svcvt_u32[_f64]_m(svuint32_t inactive, svbool_t pg, svfloat64_t op) + /// svuint32_t svcvt_u32[_f64]_x(svbool_t pg, svfloat64_t op) + /// svuint32_t svcvt_u32[_f64]_z(svbool_t pg, svfloat64_t op) + /// FCVTZU Zresult.S, Pg/M, Zop.D /// - public static unsafe Vector ConvertToUInt32(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ConvertToUInt32(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svcvt_u32[_f32]_m(svuint32_t inactive, svbool_t pg, svfloat32_t op) - /// svuint32_t svcvt_u32[_f32]_x(svbool_t pg, svfloat32_t op) - /// svuint32_t svcvt_u32[_f32]_z(svbool_t pg, svfloat32_t op) - /// FCVTZU Zresult.S, Pg/M, Zop.S + /// svuint32_t svcvt_u32[_f32]_m(svuint32_t inactive, svbool_t pg, svfloat32_t op) + /// svuint32_t svcvt_u32[_f32]_x(svbool_t pg, svfloat32_t op) + /// svuint32_t svcvt_u32[_f32]_z(svbool_t pg, svfloat32_t op) + /// FCVTZU Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ConvertToUInt32(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ConvertToUInt32(Vector value) { throw new PlatformNotSupportedException(); } // Floating-point convert /// - /// svuint64_t svcvt_u64[_f64]_m(svuint64_t inactive, svbool_t pg, svfloat64_t op) - /// svuint64_t svcvt_u64[_f64]_x(svbool_t pg, svfloat64_t op) - /// svuint64_t svcvt_u64[_f64]_z(svbool_t pg, svfloat64_t op) - /// FCVTZU Zresult.D, Pg/M, Zop.D + /// svuint64_t svcvt_u64[_f64]_m(svuint64_t inactive, svbool_t pg, svfloat64_t op) + /// svuint64_t svcvt_u64[_f64]_x(svbool_t pg, svfloat64_t op) + /// svuint64_t svcvt_u64[_f64]_z(svbool_t pg, svfloat64_t op) + /// FCVTZU Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ConvertToUInt64(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ConvertToUInt64(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svcvt_u64[_f32]_m(svuint64_t inactive, svbool_t pg, svfloat32_t op) - /// svuint64_t svcvt_u64[_f32]_x(svbool_t pg, svfloat32_t op) - /// svuint64_t svcvt_u64[_f32]_z(svbool_t pg, svfloat32_t op) - /// FCVTZU Zresult.D, Pg/M, Zop.S + /// svuint64_t svcvt_u64[_f32]_m(svuint64_t inactive, svbool_t pg, svfloat32_t op) + /// svuint64_t svcvt_u64[_f32]_x(svbool_t pg, svfloat32_t op) + /// svuint64_t svcvt_u64[_f32]_z(svbool_t pg, svfloat32_t op) + /// FCVTZU Zresult.D, Pg/M, Zop.S /// - public static unsafe Vector ConvertToUInt64(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ConvertToUInt64(Vector value) { throw new PlatformNotSupportedException(); } // Count the number of 16-bit elements in a vector /// - /// uint64_t svcnth_pat(enum svpattern pattern) - /// CNTH Xresult, pattern + /// uint64_t svcnth_pat(enum svpattern pattern) + /// CNTH Xresult, pattern /// - public static unsafe ulong Count16BitElements([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static ulong Count16BitElements([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } // Count the number of 32-bit elements in a vector /// - /// uint64_t svcntw_pat(enum svpattern pattern) - /// CNTW Xresult, pattern + /// uint64_t svcntw_pat(enum svpattern pattern) + /// CNTW Xresult, pattern /// - public static unsafe ulong Count32BitElements([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static ulong Count32BitElements([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } // Count the number of 64-bit elements in a vector /// - /// uint64_t svcntd_pat(enum svpattern pattern) - /// CNTD Xresult, pattern + /// uint64_t svcntd_pat(enum svpattern pattern) + /// CNTD Xresult, pattern /// - public static unsafe ulong Count64BitElements([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static ulong Count64BitElements([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } // Count the number of 8-bit elements in a vector /// - /// uint64_t svcntb_pat(enum svpattern pattern) - /// CNTB Xresult, pattern + /// uint64_t svcntb_pat(enum svpattern pattern) + /// CNTB Xresult, pattern /// - public static unsafe ulong Count8BitElements([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static ulong Count8BitElements([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } // Break after first true condition /// - /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) - /// BRKA Presult.B, Pg/Z, Pop.B + /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) + /// BRKA Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakAfterMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakAfterMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) - /// BRKA Presult.B, Pg/Z, Pop.B + /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) + /// BRKA Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakAfterMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakAfterMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) - /// BRKA Presult.B, Pg/Z, Pop.B + /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) + /// BRKA Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakAfterMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakAfterMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) - /// BRKA Presult.B, Pg/Z, Pop.B + /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) + /// BRKA Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakAfterMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakAfterMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) - /// BRKA Presult.B, Pg/Z, Pop.B + /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) + /// BRKA Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakAfterMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakAfterMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) - /// BRKA Presult.B, Pg/Z, Pop.B + /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) + /// BRKA Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakAfterMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakAfterMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) - /// BRKA Presult.B, Pg/Z, Pop.B + /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) + /// BRKA Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakAfterMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakAfterMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) - /// BRKA Presult.B, Pg/Z, Pop.B + /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) + /// BRKA Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakAfterMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakAfterMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } // Break after first true condition, propagating from previous partition /// - /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Break before first true condition /// - /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) - /// BRKB Presult.B, Pg/Z, Pop.B + /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) + /// BRKB Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) - /// BRKB Presult.B, Pg/Z, Pop.B + /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) + /// BRKB Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) - /// BRKB Presult.B, Pg/Z, Pop.B + /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) + /// BRKB Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) - /// BRKB Presult.B, Pg/Z, Pop.B + /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) + /// BRKB Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) - /// BRKB Presult.B, Pg/Z, Pop.B + /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) + /// BRKB Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) - /// BRKB Presult.B, Pg/Z, Pop.B + /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) + /// BRKB Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) - /// BRKB Presult.B, Pg/Z, Pop.B + /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) + /// BRKB Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) - /// BRKB Presult.B, Pg/Z, Pop.B + /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) + /// BRKB Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } // Break before first true condition, propagating from previous partition /// - /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Propagate break to next partition /// - /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B + /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B /// - public static unsafe Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B + /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B /// - public static unsafe Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B + /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B /// - public static unsafe Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B + /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B /// - public static unsafe Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B + /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B /// - public static unsafe Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B + /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B /// - public static unsafe Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B + /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B /// - public static unsafe Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B + /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B /// - public static unsafe Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) { throw new PlatformNotSupportedException(); } // Set all predicate elements to false /// - /// svbool_t svpfalse[_b]() - /// PFALSE Presult.B + /// svbool_t svpfalse[_b]() + /// PFALSE Presult.B /// - public static unsafe Vector CreateFalseMaskByte() { throw new PlatformNotSupportedException(); } + public static Vector CreateFalseMaskByte() { throw new PlatformNotSupportedException(); } // Set all predicate elements to false /// - /// svbool_t svpfalse[_b]() - /// PFALSE Presult.B + /// svbool_t svpfalse[_b]() + /// PFALSE Presult.B /// - public static unsafe Vector CreateFalseMaskDouble() { throw new PlatformNotSupportedException(); } + public static Vector CreateFalseMaskDouble() { throw new PlatformNotSupportedException(); } // Set all predicate elements to false /// - /// svbool_t svpfalse[_b]() - /// PFALSE Presult.B + /// svbool_t svpfalse[_b]() + /// PFALSE Presult.B /// - public static unsafe Vector CreateFalseMaskInt16() { throw new PlatformNotSupportedException(); } + public static Vector CreateFalseMaskInt16() { throw new PlatformNotSupportedException(); } // Set all predicate elements to false /// - /// svbool_t svpfalse[_b]() - /// PFALSE Presult.B + /// svbool_t svpfalse[_b]() + /// PFALSE Presult.B /// - public static unsafe Vector CreateFalseMaskInt32() { throw new PlatformNotSupportedException(); } + public static Vector CreateFalseMaskInt32() { throw new PlatformNotSupportedException(); } // Set all predicate elements to false /// - /// svbool_t svpfalse[_b]() - /// PFALSE Presult.B + /// svbool_t svpfalse[_b]() + /// PFALSE Presult.B /// - public static unsafe Vector CreateFalseMaskInt64() { throw new PlatformNotSupportedException(); } + public static Vector CreateFalseMaskInt64() { throw new PlatformNotSupportedException(); } // Set all predicate elements to false /// - /// svbool_t svpfalse[_b]() - /// PFALSE Presult.B + /// svbool_t svpfalse[_b]() + /// PFALSE Presult.B /// - public static unsafe Vector CreateFalseMaskSByte() { throw new PlatformNotSupportedException(); } + public static Vector CreateFalseMaskSByte() { throw new PlatformNotSupportedException(); } // Set all predicate elements to false /// - /// svbool_t svpfalse[_b]() - /// PFALSE Presult.B + /// svbool_t svpfalse[_b]() + /// PFALSE Presult.B /// - public static unsafe Vector CreateFalseMaskSingle() { throw new PlatformNotSupportedException(); } + public static Vector CreateFalseMaskSingle() { throw new PlatformNotSupportedException(); } // Set all predicate elements to false /// - /// svbool_t svpfalse[_b]() - /// PFALSE Presult.B + /// svbool_t svpfalse[_b]() + /// PFALSE Presult.B /// - public static unsafe Vector CreateFalseMaskUInt16() { throw new PlatformNotSupportedException(); } + public static Vector CreateFalseMaskUInt16() { throw new PlatformNotSupportedException(); } // Set all predicate elements to false /// - /// svbool_t svpfalse[_b]() - /// PFALSE Presult.B + /// svbool_t svpfalse[_b]() + /// PFALSE Presult.B /// - public static unsafe Vector CreateFalseMaskUInt32() { throw new PlatformNotSupportedException(); } + public static Vector CreateFalseMaskUInt32() { throw new PlatformNotSupportedException(); } // Set all predicate elements to false /// - /// svbool_t svpfalse[_b]() - /// PFALSE Presult.B + /// svbool_t svpfalse[_b]() + /// PFALSE Presult.B /// - public static unsafe Vector CreateFalseMaskUInt64() { throw new PlatformNotSupportedException(); } + public static Vector CreateFalseMaskUInt64() { throw new PlatformNotSupportedException(); } // Set the first active predicate element to true /// - /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) - /// PFIRST Ptied.B, Pg, Ptied.B + /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) + /// PFIRST Ptied.B, Pg, Ptied.B /// - public static unsafe Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) - /// PFIRST Ptied.B, Pg, Ptied.B + /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) + /// PFIRST Ptied.B, Pg, Ptied.B /// - public static unsafe Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) - /// PFIRST Ptied.B, Pg, Ptied.B + /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) + /// PFIRST Ptied.B, Pg, Ptied.B /// - public static unsafe Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) - /// PFIRST Ptied.B, Pg, Ptied.B + /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) + /// PFIRST Ptied.B, Pg, Ptied.B /// - public static unsafe Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) - /// PFIRST Ptied.B, Pg, Ptied.B + /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) + /// PFIRST Ptied.B, Pg, Ptied.B /// - public static unsafe Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) - /// PFIRST Ptied.B, Pg, Ptied.B + /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) + /// PFIRST Ptied.B, Pg, Ptied.B /// - public static unsafe Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) - /// PFIRST Ptied.B, Pg, Ptied.B + /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) + /// PFIRST Ptied.B, Pg, Ptied.B /// - public static unsafe Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) - /// PFIRST Ptied.B, Pg, Ptied.B + /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) + /// PFIRST Ptied.B, Pg, Ptied.B /// - public static unsafe Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } // Find next active predicate /// - /// svbool_t svpnext_b8(svbool_t pg, svbool_t op) - /// PNEXT Ptied.B, Pg, Ptied.B + /// svbool_t svpnext_b8(svbool_t pg, svbool_t op) + /// PNEXT Ptied.B, Pg, Ptied.B /// - public static unsafe Vector CreateMaskForNextActiveElement(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateMaskForNextActiveElement(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svpnext_b16(svbool_t pg, svbool_t op) - /// PNEXT Ptied.H, Pg, Ptied.H + /// svbool_t svpnext_b16(svbool_t pg, svbool_t op) + /// PNEXT Ptied.H, Pg, Ptied.H /// - public static unsafe Vector CreateMaskForNextActiveElement(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateMaskForNextActiveElement(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svpnext_b32(svbool_t pg, svbool_t op) - /// PNEXT Ptied.S, Pg, Ptied.S + /// svbool_t svpnext_b32(svbool_t pg, svbool_t op) + /// PNEXT Ptied.S, Pg, Ptied.S /// - public static unsafe Vector CreateMaskForNextActiveElement(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateMaskForNextActiveElement(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svpnext_b64(svbool_t pg, svbool_t op) - /// PNEXT Ptied.D, Pg, Ptied.D + /// svbool_t svpnext_b64(svbool_t pg, svbool_t op) + /// PNEXT Ptied.D, Pg, Ptied.D /// - public static unsafe Vector CreateMaskForNextActiveElement(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static Vector CreateMaskForNextActiveElement(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } // Set predicate elements to true /// - /// svbool_t svptrue_pat_b8(enum svpattern pattern) - /// PTRUE Presult.B, pattern + /// svbool_t svptrue_pat_b8(enum svpattern pattern) + /// PTRUE Presult.B, pattern /// - public static unsafe Vector CreateTrueMaskByte([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static Vector CreateTrueMaskByte([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } // Set predicate elements to true /// - /// svbool_t svptrue_pat_b8(enum svpattern pattern) - /// PTRUE Presult.B, pattern + /// svbool_t svptrue_pat_b8(enum svpattern pattern) + /// PTRUE Presult.B, pattern /// - public static unsafe Vector CreateTrueMaskDouble([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static Vector CreateTrueMaskDouble([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } // Set predicate elements to true /// - /// svbool_t svptrue_pat_b8(enum svpattern pattern) - /// PTRUE Presult.B, pattern + /// svbool_t svptrue_pat_b8(enum svpattern pattern) + /// PTRUE Presult.B, pattern /// - public static unsafe Vector CreateTrueMaskInt16([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static Vector CreateTrueMaskInt16([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } // Set predicate elements to true /// - /// svbool_t svptrue_pat_b8(enum svpattern pattern) - /// PTRUE Presult.B, pattern + /// svbool_t svptrue_pat_b8(enum svpattern pattern) + /// PTRUE Presult.B, pattern /// - public static unsafe Vector CreateTrueMaskInt32([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static Vector CreateTrueMaskInt32([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } // Set predicate elements to true /// - /// svbool_t svptrue_pat_b8(enum svpattern pattern) - /// PTRUE Presult.B, pattern + /// svbool_t svptrue_pat_b8(enum svpattern pattern) + /// PTRUE Presult.B, pattern /// - public static unsafe Vector CreateTrueMaskInt64([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static Vector CreateTrueMaskInt64([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } // Set predicate elements to true /// - /// svbool_t svptrue_pat_b8(enum svpattern pattern) - /// PTRUE Presult.B, pattern + /// svbool_t svptrue_pat_b8(enum svpattern pattern) + /// PTRUE Presult.B, pattern /// - public static unsafe Vector CreateTrueMaskSByte([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static Vector CreateTrueMaskSByte([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } // Set predicate elements to true /// - /// svbool_t svptrue_pat_b8(enum svpattern pattern) - /// PTRUE Presult.B, pattern + /// svbool_t svptrue_pat_b8(enum svpattern pattern) + /// PTRUE Presult.B, pattern /// - public static unsafe Vector CreateTrueMaskSingle([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static Vector CreateTrueMaskSingle([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } // Set predicate elements to true /// - /// svbool_t svptrue_pat_b16(enum svpattern pattern) - /// PTRUE Presult.H, pattern + /// svbool_t svptrue_pat_b16(enum svpattern pattern) + /// PTRUE Presult.H, pattern /// - public static unsafe Vector CreateTrueMaskUInt16([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static Vector CreateTrueMaskUInt16([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } // Set predicate elements to true /// - /// svbool_t svptrue_pat_b32(enum svpattern pattern) - /// PTRUE Presult.S, pattern + /// svbool_t svptrue_pat_b32(enum svpattern pattern) + /// PTRUE Presult.S, pattern /// - public static unsafe Vector CreateTrueMaskUInt32([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static Vector CreateTrueMaskUInt32([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } // Set predicate elements to true /// - /// svbool_t svptrue_pat_b64(enum svpattern pattern) - /// PTRUE Presult.D, pattern + /// svbool_t svptrue_pat_b64(enum svpattern pattern) + /// PTRUE Presult.D, pattern /// - public static unsafe Vector CreateTrueMaskUInt64([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static Vector CreateTrueMaskUInt64([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } // While incrementing scalar is less than /// - /// svbool_t svwhilelt_b16[_s32](int32_t op1, int32_t op2) - /// WHILELT Presult.H, Wop1, Wop2 + /// svbool_t svwhilelt_b16[_s32](int32_t op1, int32_t op2) + /// WHILELT Presult.H, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanMask16Bit(int left, int right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMask16Bit(int left, int right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svwhilelt_b16[_s64](int64_t op1, int64_t op2) - /// WHILELT Presult.H, Xop1, Xop2 + /// svbool_t svwhilelt_b16[_s64](int64_t op1, int64_t op2) + /// WHILELT Presult.H, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanMask16Bit(long left, long right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMask16Bit(long left, long right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svwhilelt_b16[_u32](uint32_t op1, uint32_t op2) - /// WHILELO Presult.H, Wop1, Wop2 + /// svbool_t svwhilelt_b16[_u32](uint32_t op1, uint32_t op2) + /// WHILELO Presult.H, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanMask16Bit(uint left, uint right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMask16Bit(uint left, uint right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svwhilelt_b16[_u64](uint64_t op1, uint64_t op2) - /// WHILELO Presult.H, Xop1, Xop2 + /// svbool_t svwhilelt_b16[_u64](uint64_t op1, uint64_t op2) + /// WHILELO Presult.H, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanMask16Bit(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMask16Bit(ulong left, ulong right) { throw new PlatformNotSupportedException(); } // While incrementing scalar is less than /// - /// svbool_t svwhilelt_b32[_s32](int32_t op1, int32_t op2) - /// WHILELT Presult.S, Wop1, Wop2 + /// svbool_t svwhilelt_b32[_s32](int32_t op1, int32_t op2) + /// WHILELT Presult.S, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanMask32Bit(int left, int right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMask32Bit(int left, int right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svwhilelt_b32[_s64](int64_t op1, int64_t op2) - /// WHILELT Presult.S, Xop1, Xop2 + /// svbool_t svwhilelt_b32[_s64](int64_t op1, int64_t op2) + /// WHILELT Presult.S, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanMask32Bit(long left, long right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMask32Bit(long left, long right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svwhilelt_b32[_u32](uint32_t op1, uint32_t op2) - /// WHILELO Presult.S, Wop1, Wop2 + /// svbool_t svwhilelt_b32[_u32](uint32_t op1, uint32_t op2) + /// WHILELO Presult.S, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanMask32Bit(uint left, uint right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMask32Bit(uint left, uint right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svwhilelt_b32[_u64](uint64_t op1, uint64_t op2) - /// WHILELO Presult.S, Xop1, Xop2 + /// svbool_t svwhilelt_b32[_u64](uint64_t op1, uint64_t op2) + /// WHILELO Presult.S, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanMask32Bit(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMask32Bit(ulong left, ulong right) { throw new PlatformNotSupportedException(); } // While incrementing scalar is less than /// - /// svbool_t svwhilelt_b64[_s32](int32_t op1, int32_t op2) - /// WHILELT Presult.D, Wop1, Wop2 + /// svbool_t svwhilelt_b64[_s32](int32_t op1, int32_t op2) + /// WHILELT Presult.D, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanMask64Bit(int left, int right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMask64Bit(int left, int right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svwhilelt_b64[_s64](int64_t op1, int64_t op2) - /// WHILELT Presult.D, Xop1, Xop2 + /// svbool_t svwhilelt_b64[_s64](int64_t op1, int64_t op2) + /// WHILELT Presult.D, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanMask64Bit(long left, long right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMask64Bit(long left, long right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svwhilelt_b64[_u32](uint32_t op1, uint32_t op2) - /// WHILELO Presult.D, Wop1, Wop2 + /// svbool_t svwhilelt_b64[_u32](uint32_t op1, uint32_t op2) + /// WHILELO Presult.D, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanMask64Bit(uint left, uint right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMask64Bit(uint left, uint right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svwhilelt_b64[_u64](uint64_t op1, uint64_t op2) - /// WHILELO Presult.D, Xop1, Xop2 + /// svbool_t svwhilelt_b64[_u64](uint64_t op1, uint64_t op2) + /// WHILELO Presult.D, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanMask64Bit(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMask64Bit(ulong left, ulong right) { throw new PlatformNotSupportedException(); } // While incrementing scalar is less than /// - /// svbool_t svwhilelt_b8[_s32](int32_t op1, int32_t op2) - /// WHILELT Presult.B, Wop1, Wop2 + /// svbool_t svwhilelt_b8[_s32](int32_t op1, int32_t op2) + /// WHILELT Presult.B, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanMask8Bit(int left, int right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMask8Bit(int left, int right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svwhilelt_b8[_s64](int64_t op1, int64_t op2) - /// WHILELT Presult.B, Xop1, Xop2 + /// svbool_t svwhilelt_b8[_s64](int64_t op1, int64_t op2) + /// WHILELT Presult.B, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanMask8Bit(long left, long right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMask8Bit(long left, long right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svwhilelt_b8[_u32](uint32_t op1, uint32_t op2) - /// WHILELO Presult.B, Wop1, Wop2 + /// svbool_t svwhilelt_b8[_u32](uint32_t op1, uint32_t op2) + /// WHILELO Presult.B, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanMask8Bit(uint left, uint right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMask8Bit(uint left, uint right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svwhilelt_b8[_u64](uint64_t op1, uint64_t op2) - /// WHILELO Presult.B, Xop1, Xop2 + /// svbool_t svwhilelt_b8[_u64](uint64_t op1, uint64_t op2) + /// WHILELO Presult.B, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanMask8Bit(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMask8Bit(ulong left, ulong right) { throw new PlatformNotSupportedException(); } // While incrementing scalar is less than or equal to /// - /// svbool_t svwhilele_b16[_s32](int32_t op1, int32_t op2) - /// WHILELE Presult.H, Wop1, Wop2 + /// svbool_t svwhilele_b16[_s32](int32_t op1, int32_t op2) + /// WHILELE Presult.H, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask16Bit(int left, int right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMask16Bit(int left, int right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svwhilele_b16[_s64](int64_t op1, int64_t op2) - /// WHILELE Presult.H, Xop1, Xop2 + /// svbool_t svwhilele_b16[_s64](int64_t op1, int64_t op2) + /// WHILELE Presult.H, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask16Bit(long left, long right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMask16Bit(long left, long right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svwhilele_b16[_u32](uint32_t op1, uint32_t op2) - /// WHILELS Presult.H, Wop1, Wop2 + /// svbool_t svwhilele_b16[_u32](uint32_t op1, uint32_t op2) + /// WHILELS Presult.H, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask16Bit(uint left, uint right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMask16Bit(uint left, uint right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svwhilele_b16[_u64](uint64_t op1, uint64_t op2) - /// WHILELS Presult.H, Xop1, Xop2 + /// svbool_t svwhilele_b16[_u64](uint64_t op1, uint64_t op2) + /// WHILELS Presult.H, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask16Bit(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMask16Bit(ulong left, ulong right) { throw new PlatformNotSupportedException(); } // While incrementing scalar is less than or equal to /// - /// svbool_t svwhilele_b32[_s32](int32_t op1, int32_t op2) - /// WHILELE Presult.S, Wop1, Wop2 + /// svbool_t svwhilele_b32[_s32](int32_t op1, int32_t op2) + /// WHILELE Presult.S, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask32Bit(int left, int right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMask32Bit(int left, int right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svwhilele_b32[_s64](int64_t op1, int64_t op2) - /// WHILELE Presult.S, Xop1, Xop2 + /// svbool_t svwhilele_b32[_s64](int64_t op1, int64_t op2) + /// WHILELE Presult.S, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask32Bit(long left, long right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMask32Bit(long left, long right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svwhilele_b32[_u32](uint32_t op1, uint32_t op2) - /// WHILELS Presult.S, Wop1, Wop2 + /// svbool_t svwhilele_b32[_u32](uint32_t op1, uint32_t op2) + /// WHILELS Presult.S, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask32Bit(uint left, uint right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMask32Bit(uint left, uint right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svwhilele_b32[_u64](uint64_t op1, uint64_t op2) - /// WHILELS Presult.S, Xop1, Xop2 + /// svbool_t svwhilele_b32[_u64](uint64_t op1, uint64_t op2) + /// WHILELS Presult.S, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask32Bit(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMask32Bit(ulong left, ulong right) { throw new PlatformNotSupportedException(); } // While incrementing scalar is less than or equal to /// - /// svbool_t svwhilele_b64[_s32](int32_t op1, int32_t op2) - /// WHILELE Presult.D, Wop1, Wop2 + /// svbool_t svwhilele_b64[_s32](int32_t op1, int32_t op2) + /// WHILELE Presult.D, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask64Bit(int left, int right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMask64Bit(int left, int right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svwhilele_b64[_s64](int64_t op1, int64_t op2) - /// WHILELE Presult.D, Xop1, Xop2 + /// svbool_t svwhilele_b64[_s64](int64_t op1, int64_t op2) + /// WHILELE Presult.D, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask64Bit(long left, long right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMask64Bit(long left, long right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svwhilele_b64[_u32](uint32_t op1, uint32_t op2) - /// WHILELS Presult.D, Wop1, Wop2 + /// svbool_t svwhilele_b64[_u32](uint32_t op1, uint32_t op2) + /// WHILELS Presult.D, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask64Bit(uint left, uint right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMask64Bit(uint left, uint right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svwhilele_b64[_u64](uint64_t op1, uint64_t op2) - /// WHILELS Presult.D, Xop1, Xop2 + /// svbool_t svwhilele_b64[_u64](uint64_t op1, uint64_t op2) + /// WHILELS Presult.D, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask64Bit(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMask64Bit(ulong left, ulong right) { throw new PlatformNotSupportedException(); } // While incrementing scalar is less than or equal to /// - /// svbool_t svwhilele_b8[_s32](int32_t op1, int32_t op2) - /// WHILELE Presult.B, Wop1, Wop2 + /// svbool_t svwhilele_b8[_s32](int32_t op1, int32_t op2) + /// WHILELE Presult.B, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask8Bit(int left, int right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMask8Bit(int left, int right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svwhilele_b8[_s64](int64_t op1, int64_t op2) - /// WHILELE Presult.B, Xop1, Xop2 + /// svbool_t svwhilele_b8[_s64](int64_t op1, int64_t op2) + /// WHILELE Presult.B, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask8Bit(long left, long right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMask8Bit(long left, long right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svwhilele_b8[_u32](uint32_t op1, uint32_t op2) - /// WHILELS Presult.B, Wop1, Wop2 + /// svbool_t svwhilele_b8[_u32](uint32_t op1, uint32_t op2) + /// WHILELS Presult.B, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask8Bit(uint left, uint right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMask8Bit(uint left, uint right) { throw new PlatformNotSupportedException(); } /// - /// svbool_t svwhilele_b8[_u64](uint64_t op1, uint64_t op2) - /// WHILELS Presult.B, Xop1, Xop2 + /// svbool_t svwhilele_b8[_u64](uint64_t op1, uint64_t op2) + /// WHILELS Presult.B, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask8Bit(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMask8Bit(ulong left, ulong right) { throw new PlatformNotSupportedException(); } // Divide /// - /// svfloat64_t svdiv[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svdiv[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svdiv[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FDIV Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svfloat64_t svdiv[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svdiv[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svdiv[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FDIV Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector Divide(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Divide(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svdiv[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svdiv[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svdiv[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FDIV Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svfloat32_t svdiv[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svdiv[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svdiv[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FDIV Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector Divide(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Divide(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Dot product /// - /// svint32_t svdot[_s32](svint32_t op1, svint8_t op2, svint8_t op3) - /// SDOT Ztied1.S, Zop2.B, Zop3.B + /// svint32_t svdot[_s32](svint32_t op1, svint8_t op2, svint8_t op3) + /// SDOT Ztied1.S, Zop2.B, Zop3.B /// - public static unsafe Vector DotProduct(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector DotProduct(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svdot[_s64](svint64_t op1, svint16_t op2, svint16_t op3) - /// SDOT Ztied1.D, Zop2.H, Zop3.H + /// svint64_t svdot[_s64](svint64_t op1, svint16_t op2, svint16_t op3) + /// SDOT Ztied1.D, Zop2.H, Zop3.H /// - public static unsafe Vector DotProduct(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector DotProduct(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svdot[_u32](svuint32_t op1, svuint8_t op2, svuint8_t op3) - /// UDOT Ztied1.S, Zop2.B, Zop3.B + /// svuint32_t svdot[_u32](svuint32_t op1, svuint8_t op2, svuint8_t op3) + /// UDOT Ztied1.S, Zop2.B, Zop3.B /// - public static unsafe Vector DotProduct(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector DotProduct(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svdot[_u64](svuint64_t op1, svuint16_t op2, svuint16_t op3) - /// UDOT Ztied1.D, Zop2.H, Zop3.H + /// svuint64_t svdot[_u64](svuint64_t op1, svuint16_t op2, svuint16_t op3) + /// UDOT Ztied1.D, Zop2.H, Zop3.H /// - public static unsafe Vector DotProduct(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector DotProduct(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Dot product /// - /// svint32_t svdot_lane[_s32](svint32_t op1, svint8_t op2, svint8_t op3, uint64_t imm_index) - /// SDOT Ztied1.S, Zop2.B, Zop3.B[imm_index] + /// svint32_t svdot_lane[_s32](svint32_t op1, svint8_t op2, svint8_t op3, uint64_t imm_index) + /// SDOT Ztied1.S, Zop2.B, Zop3.B[imm_index] /// - public static unsafe Vector DotProductBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected] byte rightIndex) { throw new PlatformNotSupportedException(); } + public static Vector DotProductBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svdot_lane[_s64](svint64_t op1, svint16_t op2, svint16_t op3, uint64_t imm_index) - /// SDOT Ztied1.D, Zop2.H, Zop3.H[imm_index] + /// svint64_t svdot_lane[_s64](svint64_t op1, svint16_t op2, svint16_t op3, uint64_t imm_index) + /// SDOT Ztied1.D, Zop2.H, Zop3.H[imm_index] /// - public static unsafe Vector DotProductBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected] byte rightIndex) { throw new PlatformNotSupportedException(); } + public static Vector DotProductBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svdot_lane[_u32](svuint32_t op1, svuint8_t op2, svuint8_t op3, uint64_t imm_index) - /// UDOT Ztied1.S, Zop2.B, Zop3.B[imm_index] + /// svuint32_t svdot_lane[_u32](svuint32_t op1, svuint8_t op2, svuint8_t op3, uint64_t imm_index) + /// UDOT Ztied1.S, Zop2.B, Zop3.B[imm_index] /// - public static unsafe Vector DotProductBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected] byte rightIndex) { throw new PlatformNotSupportedException(); } + public static Vector DotProductBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svdot_lane[_u64](svuint64_t op1, svuint16_t op2, svuint16_t op3, uint64_t imm_index) - /// UDOT Ztied1.D, Zop2.H, Zop3.H[imm_index] + /// svuint64_t svdot_lane[_u64](svuint64_t op1, svuint16_t op2, svuint16_t op3, uint64_t imm_index) + /// UDOT Ztied1.D, Zop2.H, Zop3.H[imm_index] /// - public static unsafe Vector DotProductBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected] byte rightIndex) { throw new PlatformNotSupportedException(); } + public static Vector DotProductBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected] byte rightIndex) { throw new PlatformNotSupportedException(); } // Broadcast a scalar value /// - /// svuint8_t svdup_lane[_u8](svuint8_t data, uint8_t index) - /// DUP Zresult.B, Zdata.B[index] + /// svuint8_t svdup_lane[_u8](svuint8_t data, uint8_t index) + /// DUP Zresult.B, Zdata.B[index] /// - public static unsafe Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(63))] byte index) { throw new PlatformNotSupportedException(); } + public static Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(63))] byte index) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svdup_lane[_f64](svfloat64_t data, uint64_t index) - /// DUP Zresult.D, Zdata.D[index] + /// svfloat64_t svdup_lane[_f64](svfloat64_t data, uint64_t index) + /// DUP Zresult.D, Zdata.D[index] /// - public static unsafe Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } + public static Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svdup_lane[_s16](svint16_t data, uint16_t index) - /// DUP Zresult.H, Zdata.H[index] + /// svint16_t svdup_lane[_s16](svint16_t data, uint16_t index) + /// DUP Zresult.H, Zdata.H[index] /// - public static unsafe Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(31))] byte index) { throw new PlatformNotSupportedException(); } + public static Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(31))] byte index) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svdup_lane[_s32](svint32_t data, uint32_t index) - /// DUP Zresult.S, Zdata.S[index] + /// svint32_t svdup_lane[_s32](svint32_t data, uint32_t index) + /// DUP Zresult.S, Zdata.S[index] /// - public static unsafe Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); } + public static Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svdup_lane[_s64](svint64_t data, uint64_t index) - /// DUP Zresult.D, Zdata.D[index] + /// svint64_t svdup_lane[_s64](svint64_t data, uint64_t index) + /// DUP Zresult.D, Zdata.D[index] /// - public static unsafe Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } + public static Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svdup_lane[_s8](svint8_t data, uint8_t index) - /// DUP Zresult.B, Zdata.B[index] + /// svint8_t svdup_lane[_s8](svint8_t data, uint8_t index) + /// DUP Zresult.B, Zdata.B[index] /// - public static unsafe Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(63))] byte index) { throw new PlatformNotSupportedException(); } + public static Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(63))] byte index) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svdup_lane[_f32](svfloat32_t data, uint32_t index) - /// DUP Zresult.S, Zdata.S[index] + /// svfloat32_t svdup_lane[_f32](svfloat32_t data, uint32_t index) + /// DUP Zresult.S, Zdata.S[index] /// - public static unsafe Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); } + public static Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svdup_lane[_u16](svuint16_t data, uint16_t index) - /// DUP Zresult.H, Zdata.H[index] + /// svuint16_t svdup_lane[_u16](svuint16_t data, uint16_t index) + /// DUP Zresult.H, Zdata.H[index] /// - public static unsafe Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(31))] byte index) { throw new PlatformNotSupportedException(); } + public static Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(31))] byte index) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svdup_lane[_u32](svuint32_t data, uint32_t index) - /// DUP Zresult.S, Zdata.S[index] + /// svuint32_t svdup_lane[_u32](svuint32_t data, uint32_t index) + /// DUP Zresult.S, Zdata.S[index] /// - public static unsafe Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); } + public static Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(15))] byte index) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svdup_lane[_u64](svuint64_t data, uint64_t index) - /// DUP Zresult.D, Zdata.D[index] + /// svuint64_t svdup_lane[_u64](svuint64_t data, uint64_t index) + /// DUP Zresult.D, Zdata.D[index] /// - public static unsafe Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } + public static Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(7))] byte index) { throw new PlatformNotSupportedException(); } /// - /// svuint8_t svext[_u8](svuint8_t op1, svuint8_t op2, uint64_t imm3) - /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 + /// svuint8_t svext[_u8](svuint8_t op1, svuint8_t op2, uint64_t imm3) + /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 /// - public static unsafe Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } + public static Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svext[_f64](svfloat64_t op1, svfloat64_t op2, uint64_t imm3) - /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 8 + /// svfloat64_t svext[_f64](svfloat64_t op1, svfloat64_t op2, uint64_t imm3) + /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 8 /// - public static unsafe Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } + public static Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svext[_s16](svint16_t op1, svint16_t op2, uint64_t imm3) - /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 2 + /// svint16_t svext[_s16](svint16_t op1, svint16_t op2, uint64_t imm3) + /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 2 /// - public static unsafe Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } + public static Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svext[_s32](svint32_t op1, svint32_t op2, uint64_t imm3) - /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 4 + /// svint32_t svext[_s32](svint32_t op1, svint32_t op2, uint64_t imm3) + /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 4 /// - public static unsafe Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } + public static Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svext[_s64](svint64_t op1, svint64_t op2, uint64_t imm3) - /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 8 + /// svint64_t svext[_s64](svint64_t op1, svint64_t op2, uint64_t imm3) + /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 8 /// - public static unsafe Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } + public static Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svext[_s8](svint8_t op1, svint8_t op2, uint64_t imm3) - /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 + /// svint8_t svext[_s8](svint8_t op1, svint8_t op2, uint64_t imm3) + /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 /// - public static unsafe Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } + public static Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svext[_f32](svfloat32_t op1, svfloat32_t op2, uint64_t imm3) - /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 4 + /// svfloat32_t svext[_f32](svfloat32_t op1, svfloat32_t op2, uint64_t imm3) + /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 4 /// - public static unsafe Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } + public static Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svext[_u16](svuint16_t op1, svuint16_t op2, uint64_t imm3) - /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 2 + /// svuint16_t svext[_u16](svuint16_t op1, svuint16_t op2, uint64_t imm3) + /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 2 /// - public static unsafe Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } + public static Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svext[_u32](svuint32_t op1, svuint32_t op2, uint64_t imm3) - /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 4 + /// svuint32_t svext[_u32](svuint32_t op1, svuint32_t op2, uint64_t imm3) + /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 4 /// - public static unsafe Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } + public static Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svext[_u64](svuint64_t op1, svuint64_t op2, uint64_t imm3) - /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 8 + /// svuint64_t svext[_u64](svuint64_t op1, svuint64_t op2, uint64_t imm3) + /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 8 /// - public static unsafe Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } + public static Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } // Floating-point exponential accelerator /// - /// svfloat64_t svexpa[_f64](svuint64_t op) - /// FEXPA Zresult.D, Zop.D + /// svfloat64_t svexpa[_f64](svuint64_t op) + /// FEXPA Zresult.D, Zop.D /// - public static unsafe Vector FloatingPointExponentialAccelerator(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector FloatingPointExponentialAccelerator(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svexpa[_f32](svuint32_t op) - /// FEXPA Zresult.S, Zop.S + /// svfloat32_t svexpa[_f32](svuint32_t op) + /// FEXPA Zresult.S, Zop.S /// - public static unsafe Vector FloatingPointExponentialAccelerator(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector FloatingPointExponentialAccelerator(Vector value) { throw new PlatformNotSupportedException(); } // Multiply-add, addend first /// - /// svfloat64_t svmla[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) - /// svfloat64_t svmla[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) - /// svfloat64_t svmla[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) - /// FMLA Ztied1.D, Pg/M, Zop2.D, Zop3.D + /// svfloat64_t svmla[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) + /// svfloat64_t svmla[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) + /// svfloat64_t svmla[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) + /// FMLA Ztied1.D, Pg/M, Zop2.D, Zop3.D /// - public static unsafe Vector FusedMultiplyAdd(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector FusedMultiplyAdd(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svmla[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) - /// svfloat32_t svmla[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) - /// svfloat32_t svmla[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) - /// FMLA Ztied1.S, Pg/M, Zop2.S, Zop3.S + /// svfloat32_t svmla[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) + /// svfloat32_t svmla[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) + /// svfloat32_t svmla[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) + /// FMLA Ztied1.S, Pg/M, Zop2.S, Zop3.S /// - public static unsafe Vector FusedMultiplyAdd(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector FusedMultiplyAdd(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Multiply-add, addend first /// - /// svfloat64_t svmla_lane[_f64](svfloat64_t op1, svfloat64_t op2, svfloat64_t op3, uint64_t imm_index) - /// FMLA Ztied1.D, Zop2.D, Zop3.D[imm_index] + /// svfloat64_t svmla_lane[_f64](svfloat64_t op1, svfloat64_t op2, svfloat64_t op3, uint64_t imm_index) + /// FMLA Ztied1.D, Zop2.D, Zop3.D[imm_index] /// - public static unsafe Vector FusedMultiplyAddBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected] byte rightIndex) { throw new PlatformNotSupportedException(); } + public static Vector FusedMultiplyAddBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svmla_lane[_f32](svfloat32_t op1, svfloat32_t op2, svfloat32_t op3, uint64_t imm_index) - /// FMLA Ztied1.S, Zop2.S, Zop3.S[imm_index] + /// svfloat32_t svmla_lane[_f32](svfloat32_t op1, svfloat32_t op2, svfloat32_t op3, uint64_t imm_index) + /// FMLA Ztied1.S, Zop2.S, Zop3.S[imm_index] /// - public static unsafe Vector FusedMultiplyAddBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected] byte rightIndex) { throw new PlatformNotSupportedException(); } + public static Vector FusedMultiplyAddBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected] byte rightIndex) { throw new PlatformNotSupportedException(); } // Negated multiply-add, addend first /// - /// svfloat64_t svnmla[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) - /// svfloat64_t svnmla[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) - /// svfloat64_t svnmla[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) - /// FNMLA Ztied1.D, Pg/M, Zop2.D, Zop3.D + /// svfloat64_t svnmla[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) + /// svfloat64_t svnmla[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) + /// svfloat64_t svnmla[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) + /// FNMLA Ztied1.D, Pg/M, Zop2.D, Zop3.D /// - public static unsafe Vector FusedMultiplyAddNegated(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector FusedMultiplyAddNegated(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svnmla[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) - /// svfloat32_t svnmla[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) - /// svfloat32_t svnmla[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) - /// FNMLA Ztied1.S, Pg/M, Zop2.S, Zop3.S + /// svfloat32_t svnmla[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) + /// svfloat32_t svnmla[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) + /// svfloat32_t svnmla[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) + /// FNMLA Ztied1.S, Pg/M, Zop2.S, Zop3.S /// - public static unsafe Vector FusedMultiplyAddNegated(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector FusedMultiplyAddNegated(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Multiply-subtract, minuend first /// - /// svfloat64_t svmls[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) - /// svfloat64_t svmls[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) - /// svfloat64_t svmls[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) - /// FMLS Ztied1.D, Pg/M, Zop2.D, Zop3.D + /// svfloat64_t svmls[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) + /// svfloat64_t svmls[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) + /// svfloat64_t svmls[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) + /// FMLS Ztied1.D, Pg/M, Zop2.D, Zop3.D /// - public static unsafe Vector FusedMultiplySubtract(Vector minuend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector FusedMultiplySubtract(Vector minuend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svmls[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) - /// svfloat32_t svmls[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) - /// svfloat32_t svmls[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) - /// FMLS Ztied1.S, Pg/M, Zop2.S, Zop3.S + /// svfloat32_t svmls[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) + /// svfloat32_t svmls[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) + /// svfloat32_t svmls[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) + /// FMLS Ztied1.S, Pg/M, Zop2.S, Zop3.S /// - public static unsafe Vector FusedMultiplySubtract(Vector minuend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector FusedMultiplySubtract(Vector minuend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Multiply-subtract, minuend first /// - /// svfloat64_t svmls_lane[_f64](svfloat64_t op1, svfloat64_t op2, svfloat64_t op3, uint64_t imm_index) - /// FMLS Ztied1.D, Zop2.D, Zop3.D[imm_index] + /// svfloat64_t svmls_lane[_f64](svfloat64_t op1, svfloat64_t op2, svfloat64_t op3, uint64_t imm_index) + /// FMLS Ztied1.D, Zop2.D, Zop3.D[imm_index] /// - public static unsafe Vector FusedMultiplySubtractBySelectedScalar(Vector minuend, Vector left, Vector right, [ConstantExpected] byte rightIndex) { throw new PlatformNotSupportedException(); } + public static Vector FusedMultiplySubtractBySelectedScalar(Vector minuend, Vector left, Vector right, [ConstantExpected] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svmls_lane[_f32](svfloat32_t op1, svfloat32_t op2, svfloat32_t op3, uint64_t imm_index) - /// FMLS Ztied1.S, Zop2.S, Zop3.S[imm_index] + /// svfloat32_t svmls_lane[_f32](svfloat32_t op1, svfloat32_t op2, svfloat32_t op3, uint64_t imm_index) + /// FMLS Ztied1.S, Zop2.S, Zop3.S[imm_index] /// - public static unsafe Vector FusedMultiplySubtractBySelectedScalar(Vector minuend, Vector left, Vector right, [ConstantExpected] byte rightIndex) { throw new PlatformNotSupportedException(); } + public static Vector FusedMultiplySubtractBySelectedScalar(Vector minuend, Vector left, Vector right, [ConstantExpected] byte rightIndex) { throw new PlatformNotSupportedException(); } // Negated multiply-subtract, minuend first /// - /// svfloat64_t svnmls[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) - /// svfloat64_t svnmls[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) - /// svfloat64_t svnmls[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) - /// FNMLS Ztied1.D, Pg/M, Zop2.D, Zop3.D + /// svfloat64_t svnmls[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) + /// svfloat64_t svnmls[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) + /// svfloat64_t svnmls[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) + /// FNMLS Ztied1.D, Pg/M, Zop2.D, Zop3.D /// - public static unsafe Vector FusedMultiplySubtractNegated(Vector minuend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector FusedMultiplySubtractNegated(Vector minuend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svnmls[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) - /// svfloat32_t svnmls[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) - /// svfloat32_t svnmls[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) - /// FNMLS Ztied1.S, Pg/M, Zop2.S, Zop3.S + /// svfloat32_t svnmls[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) + /// svfloat32_t svnmls[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) + /// svfloat32_t svnmls[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) + /// FNMLS Ztied1.S, Pg/M, Zop2.S, Zop3.S /// - public static unsafe Vector FusedMultiplySubtractNegated(Vector minuend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector FusedMultiplySubtractNegated(Vector minuend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Prefetch halfwords /// - /// void svprfh_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) - /// PRFH op, Pg, [Xbase, Zindices.S, SXTW #1] + /// void svprfh_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) + /// PRFH op, Pg, [Xbase, Zindices.S, SXTW #1] /// public static unsafe void GatherPrefetch16Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfh_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) - /// PRFH op, Pg, [Xbase, Zindices.D, LSL #1] + /// void svprfh_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) + /// PRFH op, Pg, [Xbase, Zindices.D, LSL #1] /// public static unsafe void GatherPrefetch16Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } - /// - /// void svprfh_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) - /// PRFH op, Pg, [Zbases.S, #0] - /// - public static unsafe void GatherPrefetch16Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } + // + // void svprfh_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) + // PRFH op, Pg, [Zbases.S, #0] + // + // Removed as per #103297 + // public static void GatherPrefetch16Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfh_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) - /// PRFH op, Pg, [Xbase, Zindices.S, UXTW #1] + /// void svprfh_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) + /// PRFH op, Pg, [Xbase, Zindices.S, UXTW #1] /// public static unsafe void GatherPrefetch16Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfh_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) - /// PRFH op, Pg, [Zbases.D, #0] + /// void svprfh_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) + /// PRFH op, Pg, [Zbases.D, #0] /// - public static unsafe void GatherPrefetch16Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } + public static void GatherPrefetch16Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfh_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) - /// PRFH op, Pg, [Xbase, Zindices.D, LSL #1] + /// void svprfh_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) + /// PRFH op, Pg, [Xbase, Zindices.D, LSL #1] /// public static unsafe void GatherPrefetch16Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfh_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) - /// PRFH op, Pg, [Xbase, Zindices.S, SXTW #1] + /// void svprfh_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) + /// PRFH op, Pg, [Xbase, Zindices.S, SXTW #1] /// public static unsafe void GatherPrefetch16Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfh_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) - /// PRFH op, Pg, [Xbase, Zindices.D, LSL #1] + /// void svprfh_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) + /// PRFH op, Pg, [Xbase, Zindices.D, LSL #1] /// public static unsafe void GatherPrefetch16Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } - /// - /// void svprfh_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) - /// PRFH op, Pg, [Zbases.S, #0] - /// - public static unsafe void GatherPrefetch16Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } + // + // void svprfh_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) + // PRFH op, Pg, [Zbases.S, #0] + // + // Removed as per #103297 + // public static void GatherPrefetch16Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfh_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) - /// PRFH op, Pg, [Xbase, Zindices.S, UXTW #1] + /// void svprfh_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) + /// PRFH op, Pg, [Xbase, Zindices.S, UXTW #1] /// public static unsafe void GatherPrefetch16Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfh_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) - /// PRFH op, Pg, [Zbases.D, #0] + /// void svprfh_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) + /// PRFH op, Pg, [Zbases.D, #0] /// - public static unsafe void GatherPrefetch16Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } + public static void GatherPrefetch16Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfh_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) - /// PRFH op, Pg, [Xbase, Zindices.D, LSL #1] + /// void svprfh_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) + /// PRFH op, Pg, [Xbase, Zindices.D, LSL #1] /// public static unsafe void GatherPrefetch16Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } @@ -3236,74 +3211,76 @@ internal Arm64() { } // Prefetch words /// - /// void svprfw_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) - /// PRFW op, Pg, [Xbase, Zindices.S, SXTW #2] + /// void svprfw_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) + /// PRFW op, Pg, [Xbase, Zindices.S, SXTW #2] /// public static unsafe void GatherPrefetch32Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfw_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) - /// PRFW op, Pg, [Xbase, Zindices.D, LSL #2] + /// void svprfw_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) + /// PRFW op, Pg, [Xbase, Zindices.D, LSL #2] /// public static unsafe void GatherPrefetch32Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } - /// - /// void svprfw_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) - /// PRFW op, Pg, [Zbases.S, #0] - /// - public static unsafe void GatherPrefetch32Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } + // + // void svprfw_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) + // PRFW op, Pg, [Zbases.S, #0] + // + // Removed as per #103297 + // public static void GatherPrefetch32Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfw_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) - /// PRFW op, Pg, [Xbase, Zindices.S, UXTW #2] + /// void svprfw_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) + /// PRFW op, Pg, [Xbase, Zindices.S, UXTW #2] /// public static unsafe void GatherPrefetch32Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfw_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) - /// PRFW op, Pg, [Zbases.D, #0] + /// void svprfw_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) + /// PRFW op, Pg, [Zbases.D, #0] /// - public static unsafe void GatherPrefetch32Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } + public static void GatherPrefetch32Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfw_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) - /// PRFW op, Pg, [Xbase, Zindices.D, LSL #2] + /// void svprfw_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) + /// PRFW op, Pg, [Xbase, Zindices.D, LSL #2] /// public static unsafe void GatherPrefetch32Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfw_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) - /// PRFW op, Pg, [Xbase, Zindices.S, SXTW #2] + /// void svprfw_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) + /// PRFW op, Pg, [Xbase, Zindices.S, SXTW #2] /// public static unsafe void GatherPrefetch32Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfw_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) - /// PRFW op, Pg, [Xbase, Zindices.D, LSL #2] + /// void svprfw_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) + /// PRFW op, Pg, [Xbase, Zindices.D, LSL #2] /// public static unsafe void GatherPrefetch32Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } - /// - /// void svprfw_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) - /// PRFW op, Pg, [Zbases.S, #0] - /// - public static unsafe void GatherPrefetch32Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } + // + // void svprfw_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) + // PRFW op, Pg, [Zbases.S, #0] + // + // Removed as per #103297 + // public static void GatherPrefetch32Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfw_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) - /// PRFW op, Pg, [Xbase, Zindices.S, UXTW #2] + /// void svprfw_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) + /// PRFW op, Pg, [Xbase, Zindices.S, UXTW #2] /// public static unsafe void GatherPrefetch32Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfw_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) - /// PRFW op, Pg, [Zbases.D, #0] + /// void svprfw_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) + /// PRFW op, Pg, [Zbases.D, #0] /// - public static unsafe void GatherPrefetch32Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } + public static void GatherPrefetch32Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfw_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) - /// PRFW op, Pg, [Xbase, Zindices.D, LSL #2] + /// void svprfw_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) + /// PRFW op, Pg, [Xbase, Zindices.D, LSL #2] /// public static unsafe void GatherPrefetch32Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } @@ -3311,74 +3288,76 @@ internal Arm64() { } // Prefetch doublewords /// - /// void svprfd_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) - /// PRFD op, Pg, [Xbase, Zindices.S, SXTW #3] + /// void svprfd_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) + /// PRFD op, Pg, [Xbase, Zindices.S, SXTW #3] /// public static unsafe void GatherPrefetch64Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfd_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) - /// PRFD op, Pg, [Xbase, Zindices.D, LSL #3] + /// void svprfd_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) + /// PRFD op, Pg, [Xbase, Zindices.D, LSL #3] /// public static unsafe void GatherPrefetch64Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } - /// - /// void svprfd_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) - /// PRFD op, Pg, [Zbases.S, #0] - /// - public static unsafe void GatherPrefetch64Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } + // + // void svprfd_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) + // PRFD op, Pg, [Zbases.S, #0] + // + // Removed as per #103297 + // public static void GatherPrefetch64Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfd_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) - /// PRFD op, Pg, [Xbase, Zindices.S, UXTW #3] + /// void svprfd_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) + /// PRFD op, Pg, [Xbase, Zindices.S, UXTW #3] /// public static unsafe void GatherPrefetch64Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfd_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) - /// PRFD op, Pg, [Zbases.D, #0] + /// void svprfd_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) + /// PRFD op, Pg, [Zbases.D, #0] /// - public static unsafe void GatherPrefetch64Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } + public static void GatherPrefetch64Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfd_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) - /// PRFD op, Pg, [Xbase, Zindices.D, LSL #3] + /// void svprfd_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) + /// PRFD op, Pg, [Xbase, Zindices.D, LSL #3] /// public static unsafe void GatherPrefetch64Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfd_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) - /// PRFD op, Pg, [Xbase, Zindices.S, SXTW #3] + /// void svprfd_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) + /// PRFD op, Pg, [Xbase, Zindices.S, SXTW #3] /// public static unsafe void GatherPrefetch64Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfd_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) - /// PRFD op, Pg, [Xbase, Zindices.D, LSL #3] + /// void svprfd_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) + /// PRFD op, Pg, [Xbase, Zindices.D, LSL #3] /// public static unsafe void GatherPrefetch64Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } - /// - /// void svprfd_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) - /// PRFD op, Pg, [Zbases.S, #0] - /// - public static unsafe void GatherPrefetch64Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } + // + // void svprfd_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) + // PRFD op, Pg, [Zbases.S, #0] + // + // Removed as per #103297 + // public static void GatherPrefetch64Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfd_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) - /// PRFD op, Pg, [Xbase, Zindices.S, UXTW #3] + /// void svprfd_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) + /// PRFD op, Pg, [Xbase, Zindices.S, UXTW #3] /// public static unsafe void GatherPrefetch64Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfd_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) - /// PRFD op, Pg, [Zbases.D, #0] + /// void svprfd_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) + /// PRFD op, Pg, [Zbases.D, #0] /// - public static unsafe void GatherPrefetch64Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } + public static void GatherPrefetch64Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfd_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) - /// PRFD op, Pg, [Xbase, Zindices.D, LSL #3] + /// void svprfd_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) + /// PRFD op, Pg, [Xbase, Zindices.D, LSL #3] /// public static unsafe void GatherPrefetch64Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } @@ -3386,74 +3365,76 @@ internal Arm64() { } // Prefetch bytes /// - /// void svprfb_gather_[s32]offset(svbool_t pg, const void *base, svint32_t offsets, enum svprfop op) - /// PRFB op, Pg, [Xbase, Zoffsets.S, SXTW] + /// void svprfb_gather_[s32]offset(svbool_t pg, const void *base, svint32_t offsets, enum svprfop op) + /// PRFB op, Pg, [Xbase, Zoffsets.S, SXTW] /// public static unsafe void GatherPrefetch8Bit(Vector mask, void* address, Vector offsets, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfb_gather_[s64]offset(svbool_t pg, const void *base, svint64_t offsets, enum svprfop op) - /// PRFB op, Pg, [Xbase, Zoffsets.D] + /// void svprfb_gather_[s64]offset(svbool_t pg, const void *base, svint64_t offsets, enum svprfop op) + /// PRFB op, Pg, [Xbase, Zoffsets.D] /// public static unsafe void GatherPrefetch8Bit(Vector mask, void* address, Vector offsets, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } - /// - /// void svprfb_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) - /// PRFB op, Pg, [Zbases.S, #0] - /// - public static unsafe void GatherPrefetch8Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } + // + // void svprfb_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) + // PRFB op, Pg, [Zbases.S, #0] + // + // Removed as per #103297 + // public static void GatherPrefetch8Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfb_gather_[u32]offset(svbool_t pg, const void *base, svuint32_t offsets, enum svprfop op) - /// PRFB op, Pg, [Xbase, Zoffsets.S, UXTW] + /// void svprfb_gather_[u32]offset(svbool_t pg, const void *base, svuint32_t offsets, enum svprfop op) + /// PRFB op, Pg, [Xbase, Zoffsets.S, UXTW] /// public static unsafe void GatherPrefetch8Bit(Vector mask, void* address, Vector offsets, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfb_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) - /// PRFB op, Pg, [Zbases.D, #0] + /// void svprfb_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) + /// PRFB op, Pg, [Zbases.D, #0] /// - public static unsafe void GatherPrefetch8Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } + public static void GatherPrefetch8Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfb_gather_[u64]offset(svbool_t pg, const void *base, svuint64_t offsets, enum svprfop op) - /// PRFB op, Pg, [Xbase, Zoffsets.D] + /// void svprfb_gather_[u64]offset(svbool_t pg, const void *base, svuint64_t offsets, enum svprfop op) + /// PRFB op, Pg, [Xbase, Zoffsets.D] /// public static unsafe void GatherPrefetch8Bit(Vector mask, void* address, Vector offsets, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfb_gather_[s32]offset(svbool_t pg, const void *base, svint32_t offsets, enum svprfop op) - /// PRFB op, Pg, [Xbase, Zoffsets.S, SXTW] + /// void svprfb_gather_[s32]offset(svbool_t pg, const void *base, svint32_t offsets, enum svprfop op) + /// PRFB op, Pg, [Xbase, Zoffsets.S, SXTW] /// public static unsafe void GatherPrefetch8Bit(Vector mask, void* address, Vector offsets, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfb_gather_[s64]offset(svbool_t pg, const void *base, svint64_t offsets, enum svprfop op) - /// PRFB op, Pg, [Xbase, Zoffsets.D] + /// void svprfb_gather_[s64]offset(svbool_t pg, const void *base, svint64_t offsets, enum svprfop op) + /// PRFB op, Pg, [Xbase, Zoffsets.D] /// public static unsafe void GatherPrefetch8Bit(Vector mask, void* address, Vector offsets, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } - /// - /// void svprfb_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) - /// PRFB op, Pg, [Zbases.S, #0] - /// - public static unsafe void GatherPrefetch8Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } + // + // void svprfb_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) + // PRFB op, Pg, [Zbases.S, #0] + // + // Removed as per #103297 + // public static void GatherPrefetch8Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfb_gather_[u32]offset(svbool_t pg, const void *base, svuint32_t offsets, enum svprfop op) - /// PRFB op, Pg, [Xbase, Zoffsets.S, UXTW] + /// void svprfb_gather_[u32]offset(svbool_t pg, const void *base, svuint32_t offsets, enum svprfop op) + /// PRFB op, Pg, [Xbase, Zoffsets.S, UXTW] /// public static unsafe void GatherPrefetch8Bit(Vector mask, void* address, Vector offsets, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfb_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) - /// PRFB op, Pg, [Zbases.D, #0] + /// void svprfb_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) + /// PRFB op, Pg, [Zbases.D, #0] /// - public static unsafe void GatherPrefetch8Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } + public static void GatherPrefetch8Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } /// - /// void svprfb_gather_[u64]offset(svbool_t pg, const void *base, svuint64_t offsets, enum svprfop op) - /// PRFB op, Pg, [Xbase, Zoffsets.D] + /// void svprfb_gather_[u64]offset(svbool_t pg, const void *base, svuint64_t offsets, enum svprfop op) + /// PRFB op, Pg, [Xbase, Zoffsets.D] /// public static unsafe void GatherPrefetch8Bit(Vector mask, void* address, Vector offsets, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } @@ -3461,26 +3442,26 @@ internal Arm64() { } // Unextended load /// - /// svfloat64_t svld1_gather_[s64]index[_f64](svbool_t pg, const float64_t *base, svint64_t indices) - /// LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] + /// svfloat64_t svld1_gather_[s64]index[_f64](svbool_t pg, const float64_t *base, svint64_t indices) + /// LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] /// public static unsafe Vector GatherVector(Vector mask, double* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svld1_gather[_u64base]_f64(svbool_t pg, svuint64_t bases) - /// LD1D Zresult.D, Pg/Z, [Zbases.D, #0] + /// svfloat64_t svld1_gather[_u64base]_f64(svbool_t pg, svuint64_t bases) + /// LD1D Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVector(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + public static Vector GatherVector(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svld1_gather_[u64]index[_f64](svbool_t pg, const float64_t *base, svuint64_t indices) - /// LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] + /// svfloat64_t svld1_gather_[u64]index[_f64](svbool_t pg, const float64_t *base, svuint64_t indices) + /// LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] /// public static unsafe Vector GatherVector(Vector mask, double* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svld1_gather_[s32]index[_s32](svbool_t pg, const int32_t *base, svint32_t indices) - /// LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2] + /// svint32_t svld1_gather_[s32]index[_s32](svbool_t pg, const int32_t *base, svint32_t indices) + /// LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2] /// public static unsafe Vector GatherVector(Vector mask, int* address, Vector indices) { throw new PlatformNotSupportedException(); } @@ -3489,35 +3470,35 @@ internal Arm64() { } // LD1W Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVector(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + // public static Vector GatherVector(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svld1_gather_[u32]index[_s32](svbool_t pg, const int32_t *base, svuint32_t indices) - /// LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2] + /// svint32_t svld1_gather_[u32]index[_s32](svbool_t pg, const int32_t *base, svuint32_t indices) + /// LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2] /// public static unsafe Vector GatherVector(Vector mask, int* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1_gather_[s64]index[_s64](svbool_t pg, const int64_t *base, svint64_t indices) - /// LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] + /// svint64_t svld1_gather_[s64]index[_s64](svbool_t pg, const int64_t *base, svint64_t indices) + /// LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] /// public static unsafe Vector GatherVector(Vector mask, long* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) - /// LD1D Zresult.D, Pg/Z, [Zbases.D, #0] + /// svint64_t svld1_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LD1D Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVector(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + public static Vector GatherVector(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1_gather_[u64]index[_s64](svbool_t pg, const int64_t *base, svuint64_t indices) - /// LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] + /// svint64_t svld1_gather_[u64]index[_s64](svbool_t pg, const int64_t *base, svuint64_t indices) + /// LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] /// public static unsafe Vector GatherVector(Vector mask, long* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svld1_gather_[s32]index[_f32](svbool_t pg, const float32_t *base, svint32_t indices) - /// LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2] + /// svfloat32_t svld1_gather_[s32]index[_f32](svbool_t pg, const float32_t *base, svint32_t indices) + /// LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2] /// public static unsafe Vector GatherVector(Vector mask, float* address, Vector indices) { throw new PlatformNotSupportedException(); } @@ -3526,17 +3507,17 @@ internal Arm64() { } // LD1W Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVector(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + // public static Vector GatherVector(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svld1_gather_[u32]index[_f32](svbool_t pg, const float32_t *base, svuint32_t indices) - /// LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2] + /// svfloat32_t svld1_gather_[u32]index[_f32](svbool_t pg, const float32_t *base, svuint32_t indices) + /// LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2] /// public static unsafe Vector GatherVector(Vector mask, float* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svld1_gather_[s32]index[_u32](svbool_t pg, const uint32_t *base, svint32_t indices) - /// LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2] + /// svuint32_t svld1_gather_[s32]index[_u32](svbool_t pg, const uint32_t *base, svint32_t indices) + /// LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2] /// public static unsafe Vector GatherVector(Vector mask, uint* address, Vector indices) { throw new PlatformNotSupportedException(); } @@ -3545,29 +3526,29 @@ internal Arm64() { } // LD1W Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVector(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + // public static Vector GatherVector(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svld1_gather_[u32]index[_u32](svbool_t pg, const uint32_t *base, svuint32_t indices) - /// LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2] + /// svuint32_t svld1_gather_[u32]index[_u32](svbool_t pg, const uint32_t *base, svuint32_t indices) + /// LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2] /// public static unsafe Vector GatherVector(Vector mask, uint* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1_gather_[s64]index[_u64](svbool_t pg, const uint64_t *base, svint64_t indices) - /// LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] + /// svuint64_t svld1_gather_[s64]index[_u64](svbool_t pg, const uint64_t *base, svint64_t indices) + /// LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] /// public static unsafe Vector GatherVector(Vector mask, ulong* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) - /// LD1D Zresult.D, Pg/Z, [Zbases.D, #0] + /// svuint64_t svld1_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LD1D Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVector(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + public static Vector GatherVector(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1_gather_[u64]index[_u64](svbool_t pg, const uint64_t *base, svuint64_t indices) - /// LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] + /// svuint64_t svld1_gather_[u64]index[_u64](svbool_t pg, const uint64_t *base, svuint64_t indices) + /// LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] /// public static unsafe Vector GatherVector(Vector mask, ulong* address, Vector indices) { throw new PlatformNotSupportedException(); } @@ -3575,8 +3556,8 @@ internal Arm64() { } // Load 8-bit data and zero-extend /// - /// svint32_t svld1ub_gather_[s32]offset_s32(svbool_t pg, const uint8_t *base, svint32_t offsets) - /// LD1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// svint32_t svld1ub_gather_[s32]offset_s32(svbool_t pg, const uint8_t *base, svint32_t offsets) + /// LD1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] /// public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, byte* address, Vector indices) { throw new PlatformNotSupportedException(); } @@ -3585,35 +3566,35 @@ internal Arm64() { } // LD1B Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + // public static Vector GatherVectorByteZeroExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svld1ub_gather_[u32]offset_s32(svbool_t pg, const uint8_t *base, svuint32_t offsets) - /// LD1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// svint32_t svld1ub_gather_[u32]offset_s32(svbool_t pg, const uint8_t *base, svuint32_t offsets) + /// LD1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] /// public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, byte* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1ub_gather_[s64]offset_s64(svbool_t pg, const uint8_t *base, svint64_t offsets) - /// LD1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1ub_gather_[s64]offset_s64(svbool_t pg, const uint8_t *base, svint64_t offsets) + /// LD1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, byte* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1ub_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) - /// LD1B Zresult.D, Pg/Z, [Zbases.D, #0] + /// svint64_t svld1ub_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LD1B Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + public static Vector GatherVectorByteZeroExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1ub_gather_[u64]offset_s64(svbool_t pg, const uint8_t *base, svuint64_t offsets) - /// LD1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1ub_gather_[u64]offset_s64(svbool_t pg, const uint8_t *base, svuint64_t offsets) + /// LD1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, byte* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svld1ub_gather_[s32]offset_u32(svbool_t pg, const uint8_t *base, svint32_t offsets) - /// LD1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// svuint32_t svld1ub_gather_[s32]offset_u32(svbool_t pg, const uint8_t *base, svint32_t offsets) + /// LD1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] /// public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, byte* address, Vector indices) { throw new PlatformNotSupportedException(); } @@ -3622,50 +3603,127 @@ internal Arm64() { } // LD1B Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + // public static Vector GatherVectorByteZeroExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svld1ub_gather_[u32]offset_u32(svbool_t pg, const uint8_t *base, svuint32_t offsets) - /// LD1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// svuint32_t svld1ub_gather_[u32]offset_u32(svbool_t pg, const uint8_t *base, svuint32_t offsets) + /// LD1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] /// public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, byte* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1ub_gather_[s64]offset_u64(svbool_t pg, const uint8_t *base, svint64_t offsets) - /// LD1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1ub_gather_[s64]offset_u64(svbool_t pg, const uint8_t *base, svint64_t offsets) + /// LD1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, byte* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1ub_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) - /// LD1B Zresult.D, Pg/Z, [Zbases.D, #0] + /// svuint64_t svld1ub_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LD1B Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + public static Vector GatherVectorByteZeroExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1ub_gather_[u64]offset_u64(svbool_t pg, const uint8_t *base, svuint64_t offsets) - /// LD1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1ub_gather_[u64]offset_u64(svbool_t pg, const uint8_t *base, svuint64_t offsets) + /// LD1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, byte* address, Vector indices) { throw new PlatformNotSupportedException(); } - // Unextended load, first-faulting + // Load 8-bit data and zero-extend, first-faulting + + /// + /// svint32_t svldff1ub_gather_[s32]offset_s32(svbool_t pg, const uint8_t *base, svint32_t offsets) + /// LDFF1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// + public static unsafe Vector GatherVectorByteZeroExtendFirstFaulting(Vector mask, byte* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + // + // svint32_t svldff1ub_gather[_u32base]_s32(svbool_t pg, svuint32_t bases) + // LDFF1B Zresult.S, Pg/Z, [Zbases.S, #0] + // + // Removed as per #103297 + // public static Vector GatherVectorByteZeroExtendFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + + /// + /// svint32_t svldff1ub_gather_[u32]offset_s32(svbool_t pg, const uint8_t *base, svuint32_t offsets) + /// LDFF1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// + public static unsafe Vector GatherVectorByteZeroExtendFirstFaulting(Vector mask, byte* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svldff1_gather_[s64]index[_f64](svbool_t pg, const float64_t *base, svint64_t indices) - /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] + /// svint64_t svldff1ub_gather_[s64]offset_s64(svbool_t pg, const uint8_t *base, svint64_t offsets) + /// LDFF1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorByteZeroExtendFirstFaulting(Vector mask, byte* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svldff1ub_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LDFF1B Zresult.D, Pg/Z, [Zbases.D, #0] + /// + public static Vector GatherVectorByteZeroExtendFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svldff1ub_gather_[u64]offset_s64(svbool_t pg, const uint8_t *base, svuint64_t offsets) + /// LDFF1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorByteZeroExtendFirstFaulting(Vector mask, byte* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svuint32_t svldff1ub_gather_[s32]offset_u32(svbool_t pg, const uint8_t *base, svint32_t offsets) + /// LDFF1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// + public static unsafe Vector GatherVectorByteZeroExtendFirstFaulting(Vector mask, byte* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + // + // svuint32_t svldff1ub_gather[_u32base]_u32(svbool_t pg, svuint32_t bases) + // LDFF1B Zresult.S, Pg/Z, [Zbases.S, #0] + // + // Removed as per #103297 + // public static Vector GatherVectorByteZeroExtendFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + + /// + /// svuint32_t svldff1ub_gather_[u32]offset_u32(svbool_t pg, const uint8_t *base, svuint32_t offsets) + /// LDFF1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// + public static unsafe Vector GatherVectorByteZeroExtendFirstFaulting(Vector mask, byte* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1ub_gather_[s64]offset_u64(svbool_t pg, const uint8_t *base, svint64_t offsets) + /// LDFF1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorByteZeroExtendFirstFaulting(Vector mask, byte* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1ub_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LDFF1B Zresult.D, Pg/Z, [Zbases.D, #0] + /// + public static Vector GatherVectorByteZeroExtendFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1ub_gather_[u64]offset_u64(svbool_t pg, const uint8_t *base, svuint64_t offsets) + /// LDFF1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorByteZeroExtendFirstFaulting(Vector mask, byte* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + + // Unextended load, first-faulting + + /// + /// svfloat64_t svldff1_gather_[s64]index[_f64](svbool_t pg, const float64_t *base, svint64_t indices) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] /// public static unsafe Vector GatherVectorFirstFaulting(Vector mask, double* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svldff1_gather[_u64base]_f64(svbool_t pg, svuint64_t bases) - /// LDFF1D Zresult.D, Pg/Z, [Zbases.D, #0] + /// svfloat64_t svldff1_gather[_u64base]_f64(svbool_t pg, svuint64_t bases) + /// LDFF1D Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + public static Vector GatherVectorFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svldff1_gather_[u64]index[_f64](svbool_t pg, const float64_t *base, svuint64_t indices) - /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] + /// svfloat64_t svldff1_gather_[u64]index[_f64](svbool_t pg, const float64_t *base, svuint64_t indices) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] /// public static unsafe Vector GatherVectorFirstFaulting(Vector mask, double* address, Vector indices) { throw new PlatformNotSupportedException(); } @@ -3674,41 +3732,41 @@ internal Arm64() { } // LDFF1W Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + // public static Vector GatherVectorFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svldff1_gather_[s32]index[_s32](svbool_t pg, const int32_t *base, svint32_t indices) - /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2] + /// svint32_t svldff1_gather_[s32]index[_s32](svbool_t pg, const int32_t *base, svint32_t indices) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2] /// public static unsafe Vector GatherVectorFirstFaulting(Vector mask, int* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svldff1_gather_[u32]index[_s32](svbool_t pg, const int32_t *base, svuint32_t indices) - /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2] + /// svint32_t svldff1_gather_[u32]index[_s32](svbool_t pg, const int32_t *base, svuint32_t indices) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2] /// public static unsafe Vector GatherVectorFirstFaulting(Vector mask, int* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svldff1_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) - /// LDFF1D Zresult.D, Pg/Z, [Zbases.D, #0] + /// svint64_t svldff1_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LDFF1D Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + public static Vector GatherVectorFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svldff1_gather_[s64]index[_s64](svbool_t pg, const int64_t *base, svint64_t indices) - /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] + /// svint64_t svldff1_gather_[s64]index[_s64](svbool_t pg, const int64_t *base, svint64_t indices) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] /// public static unsafe Vector GatherVectorFirstFaulting(Vector mask, long* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svldff1_gather_[u64]index[_s64](svbool_t pg, const int64_t *base, svuint64_t indices) - /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] + /// svint64_t svldff1_gather_[u64]index[_s64](svbool_t pg, const int64_t *base, svuint64_t indices) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] /// public static unsafe Vector GatherVectorFirstFaulting(Vector mask, long* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svldff1_gather_[s32]index[_f32](svbool_t pg, const float32_t *base, svint32_t indices) - /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2] + /// svfloat32_t svldff1_gather_[s32]index[_f32](svbool_t pg, const float32_t *base, svint32_t indices) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2] /// public static unsafe Vector GatherVectorFirstFaulting(Vector mask, float* address, Vector indices) { throw new PlatformNotSupportedException(); } @@ -3717,11 +3775,11 @@ internal Arm64() { } // LDFF1W Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + // public static Vector GatherVectorFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svldff1_gather_[u32]index[_f32](svbool_t pg, const float32_t *base, svuint32_t indices) - /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2] + /// svfloat32_t svldff1_gather_[u32]index[_f32](svbool_t pg, const float32_t *base, svuint32_t indices) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2] /// public static unsafe Vector GatherVectorFirstFaulting(Vector mask, float* address, Vector indices) { throw new PlatformNotSupportedException(); } @@ -3730,35 +3788,35 @@ internal Arm64() { } // LDFF1W Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + // public static Vector GatherVectorFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svldff1_gather_[s32]index[_u32](svbool_t pg, const uint32_t *base, svint32_t indices) - /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2] + /// svuint32_t svldff1_gather_[s32]index[_u32](svbool_t pg, const uint32_t *base, svint32_t indices) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2] /// public static unsafe Vector GatherVectorFirstFaulting(Vector mask, uint* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svldff1_gather_[u32]index[_u32](svbool_t pg, const uint32_t *base, svuint32_t indices) - /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2] + /// svuint32_t svldff1_gather_[u32]index[_u32](svbool_t pg, const uint32_t *base, svuint32_t indices) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2] /// public static unsafe Vector GatherVectorFirstFaulting(Vector mask, uint* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svldff1_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) - /// LDFF1D Zresult.D, Pg/Z, [Zbases.D, #0] + /// svuint64_t svldff1_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LDFF1D Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + public static Vector GatherVectorFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svldff1_gather_[s64]index[_u64](svbool_t pg, const uint64_t *base, svint64_t indices) - /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] + /// svuint64_t svldff1_gather_[s64]index[_u64](svbool_t pg, const uint64_t *base, svint64_t indices) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] /// public static unsafe Vector GatherVectorFirstFaulting(Vector mask, ulong* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svldff1_gather_[u64]index[_u64](svbool_t pg, const uint64_t *base, svuint64_t indices) - /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] + /// svuint64_t svldff1_gather_[u64]index[_u64](svbool_t pg, const uint64_t *base, svuint64_t indices) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] /// public static unsafe Vector GatherVectorFirstFaulting(Vector mask, ulong* address, Vector indices) { throw new PlatformNotSupportedException(); } @@ -3766,8 +3824,8 @@ internal Arm64() { } // Load 16-bit data and sign-extend /// - /// svint32_t svld1sh_gather_[s32]index_s32(svbool_t pg, const int16_t *base, svint32_t indices) - /// LD1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1] + /// svint32_t svld1sh_gather_[s32]index_s32(svbool_t pg, const int16_t *base, svint32_t indices) + /// LD1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1] /// public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, short* address, Vector indices) { throw new PlatformNotSupportedException(); } @@ -3776,35 +3834,35 @@ internal Arm64() { } // LD1SH Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + // public static Vector GatherVectorInt16SignExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svld1sh_gather_[u32]index_s32(svbool_t pg, const int16_t *base, svuint32_t indices) - /// LD1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1] + /// svint32_t svld1sh_gather_[u32]index_s32(svbool_t pg, const int16_t *base, svuint32_t indices) + /// LD1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1] /// public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, short* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1sh_gather_[s64]index_s64(svbool_t pg, const int16_t *base, svint64_t indices) - /// LD1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// svint64_t svld1sh_gather_[s64]index_s64(svbool_t pg, const int16_t *base, svint64_t indices) + /// LD1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] /// public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, short* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1sh_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) - /// LD1SH Zresult.D, Pg/Z, [Zbases.D, #0] + /// svint64_t svld1sh_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LD1SH Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + public static Vector GatherVectorInt16SignExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1sh_gather_[u64]index_s64(svbool_t pg, const int16_t *base, svuint64_t indices) - /// LD1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// svint64_t svld1sh_gather_[u64]index_s64(svbool_t pg, const int16_t *base, svuint64_t indices) + /// LD1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] /// public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, short* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svld1sh_gather_[s32]index_u32(svbool_t pg, const int16_t *base, svint32_t indices) - /// LD1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1] + /// svuint32_t svld1sh_gather_[s32]index_u32(svbool_t pg, const int16_t *base, svint32_t indices) + /// LD1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1] /// public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, short* address, Vector indices) { throw new PlatformNotSupportedException(); } @@ -3813,155 +3871,349 @@ internal Arm64() { } // LD1SH Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + // public static Vector GatherVectorInt16SignExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svld1sh_gather_[u32]index_u32(svbool_t pg, const int16_t *base, svuint32_t indices) - /// LD1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1] + /// svuint32_t svld1sh_gather_[u32]index_u32(svbool_t pg, const int16_t *base, svuint32_t indices) + /// LD1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1] /// public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, short* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1sh_gather_[s64]index_u64(svbool_t pg, const int16_t *base, svint64_t indices) - /// LD1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// svuint64_t svld1sh_gather_[s64]index_u64(svbool_t pg, const int16_t *base, svint64_t indices) + /// LD1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] /// public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, short* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1sh_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) - /// LD1SH Zresult.D, Pg/Z, [Zbases.D, #0] + /// svuint64_t svld1sh_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LD1SH Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + public static Vector GatherVectorInt16SignExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1sh_gather_[u64]index_u64(svbool_t pg, const int16_t *base, svuint64_t indices) - /// LD1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// svuint64_t svld1sh_gather_[u64]index_u64(svbool_t pg, const int16_t *base, svuint64_t indices) + /// LD1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] /// public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, short* address, Vector indices) { throw new PlatformNotSupportedException(); } - // Load 16-bit data and sign-extend + // Load 16-bit data and sign-extend, first-faulting + + /// + /// svint32_t svldff1sh_gather_[s32]index_s32(svbool_t pg, const int16_t *base, svint32_t indices) + /// LDFF1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1] + /// + public static unsafe Vector GatherVectorInt16SignExtendFirstFaulting(Vector mask, short* address, Vector indices) { throw new PlatformNotSupportedException(); } + + // + // svint32_t svldff1sh_gather[_u32base]_s32(svbool_t pg, svuint32_t bases) + // LDFF1SH Zresult.S, Pg/Z, [Zbases.S, #0] + // + // Removed as per #103297 + // public static Vector GatherVectorInt16SignExtendFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + + /// + /// svint32_t svldff1sh_gather_[u32]index_s32(svbool_t pg, const int16_t *base, svuint32_t indices) + /// LDFF1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1] + /// + public static unsafe Vector GatherVectorInt16SignExtendFirstFaulting(Vector mask, short* address, Vector indices) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svldff1sh_gather_[s64]index_s64(svbool_t pg, const int16_t *base, svint64_t indices) + /// LDFF1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// + public static unsafe Vector GatherVectorInt16SignExtendFirstFaulting(Vector mask, short* address, Vector indices) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svldff1sh_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LDFF1SH Zresult.D, Pg/Z, [Zbases.D, #0] + /// + public static Vector GatherVectorInt16SignExtendFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svldff1sh_gather_[u64]index_s64(svbool_t pg, const int16_t *base, svuint64_t indices) + /// LDFF1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// + public static unsafe Vector GatherVectorInt16SignExtendFirstFaulting(Vector mask, short* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svld1sh_gather_[s32]offset_s32(svbool_t pg, const int16_t *base, svint32_t offsets) - /// LD1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// svuint32_t svldff1sh_gather_[s32]index_u32(svbool_t pg, const int16_t *base, svint32_t indices) + /// LDFF1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1] + /// + public static unsafe Vector GatherVectorInt16SignExtendFirstFaulting(Vector mask, short* address, Vector indices) { throw new PlatformNotSupportedException(); } + + // + // svuint32_t svldff1sh_gather[_u32base]_u32(svbool_t pg, svuint32_t bases) + // LDFF1SH Zresult.S, Pg/Z, [Zbases.S, #0] + // + // Removed as per #103297 + // public static Vector GatherVectorInt16SignExtendFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + + /// + /// svuint32_t svldff1sh_gather_[u32]index_u32(svbool_t pg, const int16_t *base, svuint32_t indices) + /// LDFF1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1] + /// + public static unsafe Vector GatherVectorInt16SignExtendFirstFaulting(Vector mask, short* address, Vector indices) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1sh_gather_[s64]index_u64(svbool_t pg, const int16_t *base, svint64_t indices) + /// LDFF1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// + public static unsafe Vector GatherVectorInt16SignExtendFirstFaulting(Vector mask, short* address, Vector indices) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1sh_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LDFF1SH Zresult.D, Pg/Z, [Zbases.D, #0] + /// + public static Vector GatherVectorInt16SignExtendFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1sh_gather_[u64]index_u64(svbool_t pg, const int16_t *base, svuint64_t indices) + /// LDFF1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// + public static unsafe Vector GatherVectorInt16SignExtendFirstFaulting(Vector mask, short* address, Vector indices) { throw new PlatformNotSupportedException(); } + + + // Load 16-bit data and sign-extend + + /// + /// svint32_t svld1sh_gather_[s32]offset_s32(svbool_t pg, const int16_t *base, svint32_t offsets) + /// LD1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] /// public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtend(Vector mask, short* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svld1sh_gather_[u32]offset_s32(svbool_t pg, const int16_t *base, svuint32_t offsets) - /// LD1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// svint32_t svld1sh_gather_[u32]offset_s32(svbool_t pg, const int16_t *base, svuint32_t offsets) + /// LD1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] /// public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtend(Vector mask, short* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1sh_gather_[s64]offset_s64(svbool_t pg, const int16_t *base, svint64_t offsets) - /// LD1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1sh_gather_[s64]offset_s64(svbool_t pg, const int16_t *base, svint64_t offsets) + /// LD1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtend(Vector mask, short* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1sh_gather_[u64]offset_s64(svbool_t pg, const int16_t *base, svuint64_t offsets) - /// LD1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1sh_gather_[u64]offset_s64(svbool_t pg, const int16_t *base, svuint64_t offsets) + /// LD1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtend(Vector mask, short* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svld1sh_gather_[s32]offset_u32(svbool_t pg, const int16_t *base, svint32_t offsets) - /// LD1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// svuint32_t svld1sh_gather_[s32]offset_u32(svbool_t pg, const int16_t *base, svint32_t offsets) + /// LD1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] /// public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtend(Vector mask, short* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svld1sh_gather_[u32]offset_u32(svbool_t pg, const int16_t *base, svuint32_t offsets) - /// LD1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// svuint32_t svld1sh_gather_[u32]offset_u32(svbool_t pg, const int16_t *base, svuint32_t offsets) + /// LD1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] /// public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtend(Vector mask, short* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1sh_gather_[s64]offset_u64(svbool_t pg, const int16_t *base, svint64_t offsets) - /// LD1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1sh_gather_[s64]offset_u64(svbool_t pg, const int16_t *base, svint64_t offsets) + /// LD1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtend(Vector mask, short* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1sh_gather_[u64]offset_u64(svbool_t pg, const int16_t *base, svuint64_t offsets) - /// LD1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1sh_gather_[u64]offset_u64(svbool_t pg, const int16_t *base, svuint64_t offsets) + /// LD1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtend(Vector mask, short* address, Vector offsets) { throw new PlatformNotSupportedException(); } - // Load 32-bit data and sign-extend + // Load 16-bit data and sign-extend, first-faulting + + /// + /// svint32_t svldff1sh_gather_[s32]offset_s32(svbool_t pg, const int16_t *base, svint32_t offsets) + /// LDFF1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// + public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(Vector mask, short* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1sw_gather_[s64]index_s64(svbool_t pg, const int32_t *base, svint64_t indices) - /// LD1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// svint32_t svldff1sh_gather_[u32]offset_s32(svbool_t pg, const int16_t *base, svuint32_t offsets) + /// LDFF1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// + public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(Vector mask, short* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svldff1sh_gather_[s64]offset_s64(svbool_t pg, const int16_t *base, svint64_t offsets) + /// LDFF1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(Vector mask, short* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svldff1sh_gather_[u64]offset_s64(svbool_t pg, const int16_t *base, svuint64_t offsets) + /// LDFF1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(Vector mask, short* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svuint32_t svldff1sh_gather_[s32]offset_u32(svbool_t pg, const int16_t *base, svint32_t offsets) + /// LDFF1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// + public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(Vector mask, short* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svuint32_t svldff1sh_gather_[u32]offset_u32(svbool_t pg, const int16_t *base, svuint32_t offsets) + /// LDFF1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// + public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(Vector mask, short* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1sh_gather_[s64]offset_u64(svbool_t pg, const int16_t *base, svint64_t offsets) + /// LDFF1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(Vector mask, short* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1sh_gather_[u64]offset_u64(svbool_t pg, const int16_t *base, svuint64_t offsets) + /// LDFF1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(Vector mask, short* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + + // Load 32-bit data and sign-extend + + /// + /// svint64_t svld1sw_gather_[s64]index_s64(svbool_t pg, const int32_t *base, svint64_t indices) + /// LD1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] /// public static unsafe Vector GatherVectorInt32SignExtend(Vector mask, int* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1sw_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) - /// LD1SW Zresult.D, Pg/Z, [Zbases.D, #0] + /// svint64_t svld1sw_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LD1SW Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorInt32SignExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + public static Vector GatherVectorInt32SignExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1sw_gather_[u64]index_s64(svbool_t pg, const int32_t *base, svuint64_t indices) - /// LD1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// svint64_t svld1sw_gather_[u64]index_s64(svbool_t pg, const int32_t *base, svuint64_t indices) + /// LD1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] /// public static unsafe Vector GatherVectorInt32SignExtend(Vector mask, int* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1sw_gather_[s64]index_u64(svbool_t pg, const int32_t *base, svint64_t indices) - /// LD1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// svuint64_t svld1sw_gather_[s64]index_u64(svbool_t pg, const int32_t *base, svint64_t indices) + /// LD1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] /// public static unsafe Vector GatherVectorInt32SignExtend(Vector mask, int* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1sw_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) - /// LD1SW Zresult.D, Pg/Z, [Zbases.D, #0] + /// svuint64_t svld1sw_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LD1SW Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorInt32SignExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + public static Vector GatherVectorInt32SignExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1sw_gather_[u64]index_u64(svbool_t pg, const int32_t *base, svuint64_t indices) - /// LD1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// svuint64_t svld1sw_gather_[u64]index_u64(svbool_t pg, const int32_t *base, svuint64_t indices) + /// LD1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] /// public static unsafe Vector GatherVectorInt32SignExtend(Vector mask, int* address, Vector indices) { throw new PlatformNotSupportedException(); } - // Load 32-bit data and sign-extend + // Load 32-bit data and sign-extend, first-faulting + + /// + /// svint64_t svldff1sw_gather_[s64]index_s64(svbool_t pg, const int32_t *base, svint64_t indices) + /// LDFF1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// + public static unsafe Vector GatherVectorInt32SignExtendFirstFaulting(Vector mask, int* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1sw_gather_[s64]offset_s64(svbool_t pg, const int32_t *base, svint64_t offsets) - /// LD1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svldff1sw_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LDFF1SW Zresult.D, Pg/Z, [Zbases.D, #0] + /// + public static Vector GatherVectorInt32SignExtendFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svldff1sw_gather_[u64]index_s64(svbool_t pg, const int32_t *base, svuint64_t indices) + /// LDFF1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// + public static unsafe Vector GatherVectorInt32SignExtendFirstFaulting(Vector mask, int* address, Vector indices) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1sw_gather_[s64]index_u64(svbool_t pg, const int32_t *base, svint64_t indices) + /// LDFF1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// + public static unsafe Vector GatherVectorInt32SignExtendFirstFaulting(Vector mask, int* address, Vector indices) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1sw_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LDFF1SW Zresult.D, Pg/Z, [Zbases.D, #0] + /// + public static Vector GatherVectorInt32SignExtendFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1sw_gather_[u64]index_u64(svbool_t pg, const int32_t *base, svuint64_t indices) + /// LDFF1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// + public static unsafe Vector GatherVectorInt32SignExtendFirstFaulting(Vector mask, int* address, Vector indices) { throw new PlatformNotSupportedException(); } + + + // Load 32-bit data and sign-extend + + /// + /// svint64_t svld1sw_gather_[s64]offset_s64(svbool_t pg, const int32_t *base, svint64_t offsets) + /// LD1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorInt32WithByteOffsetsSignExtend(Vector mask, int* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1sw_gather_[u64]offset_s64(svbool_t pg, const int32_t *base, svuint64_t offsets) - /// LD1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1sw_gather_[u64]offset_s64(svbool_t pg, const int32_t *base, svuint64_t offsets) + /// LD1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorInt32WithByteOffsetsSignExtend(Vector mask, int* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1sw_gather_[s64]offset_u64(svbool_t pg, const int32_t *base, svint64_t offsets) - /// LD1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1sw_gather_[s64]offset_u64(svbool_t pg, const int32_t *base, svint64_t offsets) + /// LD1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorInt32WithByteOffsetsSignExtend(Vector mask, int* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1sw_gather_[u64]offset_u64(svbool_t pg, const int32_t *base, svuint64_t offsets) - /// LD1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1sw_gather_[u64]offset_u64(svbool_t pg, const int32_t *base, svuint64_t offsets) + /// LD1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorInt32WithByteOffsetsSignExtend(Vector mask, int* address, Vector offsets) { throw new PlatformNotSupportedException(); } - // Load 8-bit data and sign-extend + // Load 32-bit data and sign-extend, first-faulting + + /// + /// svint64_t svldff1sw_gather_[s64]offset_s64(svbool_t pg, const int32_t *base, svint64_t offsets) + /// LDFF1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorInt32WithByteOffsetsSignExtendFirstFaulting(Vector mask, int* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svldff1sw_gather_[u64]offset_s64(svbool_t pg, const int32_t *base, svuint64_t offsets) + /// LDFF1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorInt32WithByteOffsetsSignExtendFirstFaulting(Vector mask, int* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1sw_gather_[s64]offset_u64(svbool_t pg, const int32_t *base, svint64_t offsets) + /// LDFF1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorInt32WithByteOffsetsSignExtendFirstFaulting(Vector mask, int* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svld1sb_gather_[s32]offset_s32(svbool_t pg, const int8_t *base, svint32_t offsets) - /// LD1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// svuint64_t svldff1sw_gather_[u64]offset_u64(svbool_t pg, const int32_t *base, svuint64_t offsets) + /// LDFF1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorInt32WithByteOffsetsSignExtendFirstFaulting(Vector mask, int* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + + // Load 8-bit data and sign-extend + + /// + /// svint32_t svld1sb_gather_[s32]offset_s32(svbool_t pg, const int8_t *base, svint32_t offsets) + /// LD1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] /// public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, sbyte* address, Vector indices) { throw new PlatformNotSupportedException(); } @@ -3970,35 +4222,35 @@ internal Arm64() { } // LD1SB Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + // public static Vector GatherVectorSByteSignExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svld1sb_gather_[u32]offset_s32(svbool_t pg, const int8_t *base, svuint32_t offsets) - /// LD1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// svint32_t svld1sb_gather_[u32]offset_s32(svbool_t pg, const int8_t *base, svuint32_t offsets) + /// LD1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] /// public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, sbyte* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1sb_gather_[s64]offset_s64(svbool_t pg, const int8_t *base, svint64_t offsets) - /// LD1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1sb_gather_[s64]offset_s64(svbool_t pg, const int8_t *base, svint64_t offsets) + /// LD1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, sbyte* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1sb_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) - /// LD1SB Zresult.D, Pg/Z, [Zbases.D, #0] + /// svint64_t svld1sb_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LD1SB Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + public static Vector GatherVectorSByteSignExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1sb_gather_[u64]offset_s64(svbool_t pg, const int8_t *base, svuint64_t offsets) - /// LD1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1sb_gather_[u64]offset_s64(svbool_t pg, const int8_t *base, svuint64_t offsets) + /// LD1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, sbyte* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svld1sb_gather_[s32]offset_u32(svbool_t pg, const int8_t *base, svint32_t offsets) - /// LD1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// svuint32_t svld1sb_gather_[s32]offset_u32(svbool_t pg, const int8_t *base, svint32_t offsets) + /// LD1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] /// public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, sbyte* address, Vector indices) { throw new PlatformNotSupportedException(); } @@ -4007,89 +4259,217 @@ internal Arm64() { } // LD1SB Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + // public static Vector GatherVectorSByteSignExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svld1sb_gather_[u32]offset_u32(svbool_t pg, const int8_t *base, svuint32_t offsets) - /// LD1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// svuint32_t svld1sb_gather_[u32]offset_u32(svbool_t pg, const int8_t *base, svuint32_t offsets) + /// LD1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] /// public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, sbyte* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1sb_gather_[s64]offset_u64(svbool_t pg, const int8_t *base, svint64_t offsets) - /// LD1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1sb_gather_[s64]offset_u64(svbool_t pg, const int8_t *base, svint64_t offsets) + /// LD1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, sbyte* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1sb_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) - /// LD1SB Zresult.D, Pg/Z, [Zbases.D, #0] + /// svuint64_t svld1sb_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LD1SB Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + public static Vector GatherVectorSByteSignExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1sb_gather_[u64]offset_u64(svbool_t pg, const int8_t *base, svuint64_t offsets) - /// LD1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1sb_gather_[u64]offset_u64(svbool_t pg, const int8_t *base, svuint64_t offsets) + /// LD1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, sbyte* address, Vector indices) { throw new PlatformNotSupportedException(); } - // Load 16-bit data and zero-extend + // Load 8-bit data and sign-extend, first-faulting + + /// + /// svint32_t svldff1sb_gather_[s32]offset_s32(svbool_t pg, const int8_t *base, svint32_t offsets) + /// LDFF1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// + public static unsafe Vector GatherVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + // + // svint32_t svldff1sb_gather[_u32base]_s32(svbool_t pg, svuint32_t bases) + // LDFF1SB Zresult.S, Pg/Z, [Zbases.S, #0] + // + // Removed as per #103297 + // public static Vector GatherVectorSByteSignExtendFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + + /// + /// svint32_t svldff1sb_gather_[u32]offset_s32(svbool_t pg, const int8_t *base, svuint32_t offsets) + /// LDFF1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// + public static unsafe Vector GatherVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svldff1sb_gather_[s64]offset_s64(svbool_t pg, const int8_t *base, svint64_t offsets) + /// LDFF1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svldff1sb_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LDFF1SB Zresult.D, Pg/Z, [Zbases.D, #0] + /// + public static Vector GatherVectorSByteSignExtendFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svldff1sb_gather_[u64]offset_s64(svbool_t pg, const int8_t *base, svuint64_t offsets) + /// LDFF1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svuint32_t svldff1sb_gather_[s32]offset_u32(svbool_t pg, const int8_t *base, svint32_t offsets) + /// LDFF1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// + public static unsafe Vector GatherVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + // + // svuint32_t svldff1sb_gather[_u32base]_u32(svbool_t pg, svuint32_t bases) + // LDFF1SB Zresult.S, Pg/Z, [Zbases.S, #0] + // + // Removed as per #103297 + // public static Vector GatherVectorSByteSignExtendFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + + /// + /// svuint32_t svldff1sb_gather_[u32]offset_u32(svbool_t pg, const int8_t *base, svuint32_t offsets) + /// LDFF1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// + public static unsafe Vector GatherVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1sb_gather_[s64]offset_u64(svbool_t pg, const int8_t *base, svint64_t offsets) + /// LDFF1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1sb_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LDFF1SB Zresult.D, Pg/Z, [Zbases.D, #0] + /// + public static Vector GatherVectorSByteSignExtendFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svld1uh_gather_[s32]offset_s32(svbool_t pg, const uint16_t *base, svint32_t offsets) - /// LD1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// svuint64_t svldff1sb_gather_[u64]offset_u64(svbool_t pg, const int8_t *base, svuint64_t offsets) + /// LDFF1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + + // Load 16-bit data and zero-extend + + /// + /// svint32_t svld1uh_gather_[s32]offset_s32(svbool_t pg, const uint16_t *base, svint32_t offsets) + /// LD1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] /// public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtend(Vector mask, ushort* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svld1uh_gather_[u32]offset_s32(svbool_t pg, const uint16_t *base, svuint32_t offsets) - /// LD1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// svint32_t svld1uh_gather_[u32]offset_s32(svbool_t pg, const uint16_t *base, svuint32_t offsets) + /// LD1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] /// public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtend(Vector mask, ushort* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1uh_gather_[s64]offset_s64(svbool_t pg, const uint16_t *base, svint64_t offsets) - /// LD1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1uh_gather_[s64]offset_s64(svbool_t pg, const uint16_t *base, svint64_t offsets) + /// LD1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtend(Vector mask, ushort* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1uh_gather_[u64]offset_s64(svbool_t pg, const uint16_t *base, svuint64_t offsets) - /// LD1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1uh_gather_[u64]offset_s64(svbool_t pg, const uint16_t *base, svuint64_t offsets) + /// LD1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtend(Vector mask, ushort* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svld1uh_gather_[s32]offset_u32(svbool_t pg, const uint16_t *base, svint32_t offsets) - /// LD1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// svuint32_t svld1uh_gather_[s32]offset_u32(svbool_t pg, const uint16_t *base, svint32_t offsets) + /// LD1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] /// public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtend(Vector mask, ushort* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svld1uh_gather_[u32]offset_u32(svbool_t pg, const uint16_t *base, svuint32_t offsets) - /// LD1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// svuint32_t svld1uh_gather_[u32]offset_u32(svbool_t pg, const uint16_t *base, svuint32_t offsets) + /// LD1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] /// public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtend(Vector mask, ushort* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1uh_gather_[s64]offset_u64(svbool_t pg, const uint16_t *base, svint64_t offsets) - /// LD1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1uh_gather_[s64]offset_u64(svbool_t pg, const uint16_t *base, svint64_t offsets) + /// LD1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtend(Vector mask, ushort* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1uh_gather_[u64]offset_u64(svbool_t pg, const uint16_t *base, svuint64_t offsets) - /// LD1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1uh_gather_[u64]offset_u64(svbool_t pg, const uint16_t *base, svuint64_t offsets) + /// LD1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtend(Vector mask, ushort* address, Vector offsets) { throw new PlatformNotSupportedException(); } - // Load 16-bit data and zero-extend + // Load 16-bit data and zero-extend, first-faulting /// - /// svint32_t svld1uh_gather_[s32]index_s32(svbool_t pg, const uint16_t *base, svint32_t indices) - /// LD1H Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1] + /// svint32_t svldff1uh_gather_[s32]offset_s32(svbool_t pg, const uint16_t *base, svint32_t offsets) + /// LDFF1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// + public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(Vector mask, ushort* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svint32_t svldff1uh_gather_[u32]offset_s32(svbool_t pg, const uint16_t *base, svuint32_t offsets) + /// LDFF1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// + public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(Vector mask, ushort* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svldff1uh_gather_[s64]offset_s64(svbool_t pg, const uint16_t *base, svint64_t offsets) + /// LDFF1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(Vector mask, ushort* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svldff1uh_gather_[u64]offset_s64(svbool_t pg, const uint16_t *base, svuint64_t offsets) + /// LDFF1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(Vector mask, ushort* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svuint32_t svldff1uh_gather_[s32]offset_u32(svbool_t pg, const uint16_t *base, svint32_t offsets) + /// LDFF1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// + public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(Vector mask, ushort* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svuint32_t svldff1uh_gather_[u32]offset_u32(svbool_t pg, const uint16_t *base, svuint32_t offsets) + /// LDFF1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// + public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(Vector mask, ushort* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1uh_gather_[s64]offset_u64(svbool_t pg, const uint16_t *base, svint64_t offsets) + /// LDFF1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(Vector mask, ushort* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1uh_gather_[u64]offset_u64(svbool_t pg, const uint16_t *base, svuint64_t offsets) + /// LDFF1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(Vector mask, ushort* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + + // Load 16-bit data and zero-extend + + /// + /// svint32_t svld1uh_gather_[s32]index_s32(svbool_t pg, const uint16_t *base, svint32_t indices) + /// LD1H Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1] /// public static unsafe Vector GatherVectorUInt16ZeroExtend(Vector mask, ushort* address, Vector indices) { throw new PlatformNotSupportedException(); } @@ -4098,35 +4478,35 @@ internal Arm64() { } // LD1H Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorUInt16ZeroExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + // public static Vector GatherVectorUInt16ZeroExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svld1uh_gather_[u32]index_s32(svbool_t pg, const uint16_t *base, svuint32_t indices) - /// LD1H Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1] + /// svint32_t svld1uh_gather_[u32]index_s32(svbool_t pg, const uint16_t *base, svuint32_t indices) + /// LD1H Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1] /// public static unsafe Vector GatherVectorUInt16ZeroExtend(Vector mask, ushort* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1uh_gather_[s64]index_s64(svbool_t pg, const uint16_t *base, svint64_t indices) - /// LD1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// svint64_t svld1uh_gather_[s64]index_s64(svbool_t pg, const uint16_t *base, svint64_t indices) + /// LD1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] /// public static unsafe Vector GatherVectorUInt16ZeroExtend(Vector mask, ushort* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1uh_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) - /// LD1H Zresult.D, Pg/Z, [Zbases.D, #0] + /// svint64_t svld1uh_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LD1H Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorUInt16ZeroExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + public static Vector GatherVectorUInt16ZeroExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1uh_gather_[u64]index_s64(svbool_t pg, const uint16_t *base, svuint64_t indices) - /// LD1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// svint64_t svld1uh_gather_[u64]index_s64(svbool_t pg, const uint16_t *base, svuint64_t indices) + /// LD1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] /// public static unsafe Vector GatherVectorUInt16ZeroExtend(Vector mask, ushort* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svld1uh_gather_[s32]index_u32(svbool_t pg, const uint16_t *base, svint32_t indices) - /// LD1H Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1] + /// svuint32_t svld1uh_gather_[s32]index_u32(svbool_t pg, const uint16_t *base, svint32_t indices) + /// LD1H Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1] /// public static unsafe Vector GatherVectorUInt16ZeroExtend(Vector mask, ushort* address, Vector indices) { throw new PlatformNotSupportedException(); } @@ -4135,89 +4515,217 @@ internal Arm64() { } // LD1H Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorUInt16ZeroExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + // public static Vector GatherVectorUInt16ZeroExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svld1uh_gather_[u32]index_u32(svbool_t pg, const uint16_t *base, svuint32_t indices) - /// LD1H Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1] + /// svuint32_t svld1uh_gather_[u32]index_u32(svbool_t pg, const uint16_t *base, svuint32_t indices) + /// LD1H Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1] /// public static unsafe Vector GatherVectorUInt16ZeroExtend(Vector mask, ushort* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1uh_gather_[s64]index_u64(svbool_t pg, const uint16_t *base, svint64_t indices) - /// LD1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// svuint64_t svld1uh_gather_[s64]index_u64(svbool_t pg, const uint16_t *base, svint64_t indices) + /// LD1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] /// public static unsafe Vector GatherVectorUInt16ZeroExtend(Vector mask, ushort* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1uh_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) - /// LD1H Zresult.D, Pg/Z, [Zbases.D, #0] + /// svuint64_t svld1uh_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LD1H Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorUInt16ZeroExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + public static Vector GatherVectorUInt16ZeroExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1uh_gather_[u64]index_u64(svbool_t pg, const uint16_t *base, svuint64_t indices) - /// LD1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// svuint64_t svld1uh_gather_[u64]index_u64(svbool_t pg, const uint16_t *base, svuint64_t indices) + /// LD1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] /// public static unsafe Vector GatherVectorUInt16ZeroExtend(Vector mask, ushort* address, Vector indices) { throw new PlatformNotSupportedException(); } - // Load 32-bit data and zero-extend + // Load 16-bit data and zero-extend, first-faulting + + /// + /// svint32_t svldff1uh_gather_[s32]index_s32(svbool_t pg, const uint16_t *base, svint32_t indices) + /// LDFF1H Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1] + /// + public static unsafe Vector GatherVectorUInt16ZeroExtendFirstFaulting(Vector mask, ushort* address, Vector indices) { throw new PlatformNotSupportedException(); } + + // + // svint32_t svldff1uh_gather[_u32base]_s32(svbool_t pg, svuint32_t bases) + // LDFF1H Zresult.S, Pg/Z, [Zbases.S, #0] + // + // Removed as per #103297 + // public static Vector GatherVectorUInt16ZeroExtendFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + + /// + /// svint32_t svldff1uh_gather_[u32]index_s32(svbool_t pg, const uint16_t *base, svuint32_t indices) + /// LDFF1H Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1] + /// + public static unsafe Vector GatherVectorUInt16ZeroExtendFirstFaulting(Vector mask, ushort* address, Vector indices) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svldff1uh_gather_[s64]index_s64(svbool_t pg, const uint16_t *base, svint64_t indices) + /// LDFF1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// + public static unsafe Vector GatherVectorUInt16ZeroExtendFirstFaulting(Vector mask, ushort* address, Vector indices) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svldff1uh_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LDFF1H Zresult.D, Pg/Z, [Zbases.D, #0] + /// + public static Vector GatherVectorUInt16ZeroExtendFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svldff1uh_gather_[u64]index_s64(svbool_t pg, const uint16_t *base, svuint64_t indices) + /// LDFF1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// + public static unsafe Vector GatherVectorUInt16ZeroExtendFirstFaulting(Vector mask, ushort* address, Vector indices) { throw new PlatformNotSupportedException(); } + + /// + /// svuint32_t svldff1uh_gather_[s32]index_u32(svbool_t pg, const uint16_t *base, svint32_t indices) + /// LDFF1H Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1] + /// + public static unsafe Vector GatherVectorUInt16ZeroExtendFirstFaulting(Vector mask, ushort* address, Vector indices) { throw new PlatformNotSupportedException(); } + + // + // svuint32_t svldff1uh_gather[_u32base]_u32(svbool_t pg, svuint32_t bases) + // LDFF1H Zresult.S, Pg/Z, [Zbases.S, #0] + // + // Removed as per #103297 + // public static Vector GatherVectorUInt16ZeroExtendFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1uw_gather_[s64]offset_s64(svbool_t pg, const uint32_t *base, svint64_t offsets) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint32_t svldff1uh_gather_[u32]index_u32(svbool_t pg, const uint16_t *base, svuint32_t indices) + /// LDFF1H Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1] + /// + public static unsafe Vector GatherVectorUInt16ZeroExtendFirstFaulting(Vector mask, ushort* address, Vector indices) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1uh_gather_[s64]index_u64(svbool_t pg, const uint16_t *base, svint64_t indices) + /// LDFF1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// + public static unsafe Vector GatherVectorUInt16ZeroExtendFirstFaulting(Vector mask, ushort* address, Vector indices) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1uh_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LDFF1H Zresult.D, Pg/Z, [Zbases.D, #0] + /// + public static Vector GatherVectorUInt16ZeroExtendFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1uh_gather_[u64]index_u64(svbool_t pg, const uint16_t *base, svuint64_t indices) + /// LDFF1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// + public static unsafe Vector GatherVectorUInt16ZeroExtendFirstFaulting(Vector mask, ushort* address, Vector indices) { throw new PlatformNotSupportedException(); } + + + // Load 32-bit data and zero-extend + + /// + /// svint64_t svld1uw_gather_[s64]offset_s64(svbool_t pg, const uint32_t *base, svint64_t offsets) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtend(Vector mask, uint* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1uw_gather_[u64]offset_s64(svbool_t pg, const uint32_t *base, svuint64_t offsets) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1uw_gather_[u64]offset_s64(svbool_t pg, const uint32_t *base, svuint64_t offsets) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtend(Vector mask, uint* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1uw_gather_[s64]offset_s64(svbool_t pg, const uint32_t *base, svint64_t offsets) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1uw_gather_[s64]offset_s64(svbool_t pg, const uint32_t *base, svint64_t offsets) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtend(Vector mask, uint* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1uw_gather_[u64]offset_s64(svbool_t pg, const uint32_t *base, svuint64_t offsets) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1uw_gather_[u64]offset_s64(svbool_t pg, const uint32_t *base, svuint64_t offsets) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtend(Vector mask, uint* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1uw_gather_[s64]offset_u64(svbool_t pg, const uint32_t *base, svint64_t offsets) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1uw_gather_[s64]offset_u64(svbool_t pg, const uint32_t *base, svint64_t offsets) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtend(Vector mask, uint* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1uw_gather_[u64]offset_u64(svbool_t pg, const uint32_t *base, svuint64_t offsets) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1uw_gather_[u64]offset_u64(svbool_t pg, const uint32_t *base, svuint64_t offsets) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtend(Vector mask, uint* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1uw_gather_[s64]offset_u64(svbool_t pg, const uint32_t *base, svint64_t offsets) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1uw_gather_[s64]offset_u64(svbool_t pg, const uint32_t *base, svint64_t offsets) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtend(Vector mask, uint* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1uw_gather_[u64]offset_u64(svbool_t pg, const uint32_t *base, svuint64_t offsets) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1uw_gather_[u64]offset_u64(svbool_t pg, const uint32_t *base, svuint64_t offsets) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtend(Vector mask, uint* address, Vector offsets) { throw new PlatformNotSupportedException(); } - // Load 32-bit data and zero-extend + // Load 32-bit data and zero-extend, first-faulting + + /// + /// svint64_t svldff1uw_gather_[s64]offset_s64(svbool_t pg, const uint32_t *base, svint64_t offsets) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(Vector mask, uint* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svldff1uw_gather_[u64]offset_s64(svbool_t pg, const uint32_t *base, svuint64_t offsets) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(Vector mask, uint* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1uw_gather_[s64]index_s64(svbool_t pg, const uint32_t *base, svint64_t indices) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// svint64_t svldff1uw_gather_[s64]offset_s64(svbool_t pg, const uint32_t *base, svint64_t offsets) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(Vector mask, uint* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svldff1uw_gather_[u64]offset_s64(svbool_t pg, const uint32_t *base, svuint64_t offsets) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(Vector mask, uint* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1uw_gather_[s64]offset_u64(svbool_t pg, const uint32_t *base, svint64_t offsets) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(Vector mask, uint* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1uw_gather_[u64]offset_u64(svbool_t pg, const uint32_t *base, svuint64_t offsets) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(Vector mask, uint* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1uw_gather_[s64]offset_u64(svbool_t pg, const uint32_t *base, svint64_t offsets) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(Vector mask, uint* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1uw_gather_[u64]offset_u64(svbool_t pg, const uint32_t *base, svuint64_t offsets) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(Vector mask, uint* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + + // Load 32-bit data and zero-extend + + /// + /// svint64_t svld1uw_gather_[s64]index_s64(svbool_t pg, const uint32_t *base, svint64_t indices) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] /// public static unsafe Vector GatherVectorUInt32ZeroExtend(Vector mask, uint* address, Vector indices) { throw new PlatformNotSupportedException(); } @@ -4226,35 +4734,35 @@ internal Arm64() { } // LD1W Zresult.D, Pg/Z, [Zbases.D, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorUInt32ZeroExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + // public static Vector GatherVectorUInt32ZeroExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1uw_gather_[u64]index_s64(svbool_t pg, const uint32_t *base, svuint64_t indices) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// svint64_t svld1uw_gather_[u64]index_s64(svbool_t pg, const uint32_t *base, svuint64_t indices) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] /// public static unsafe Vector GatherVectorUInt32ZeroExtend(Vector mask, uint* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1uw_gather_[s64]index_s64(svbool_t pg, const uint32_t *base, svint64_t indices) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// svint64_t svld1uw_gather_[s64]index_s64(svbool_t pg, const uint32_t *base, svint64_t indices) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] /// public static unsafe Vector GatherVectorUInt32ZeroExtend(Vector mask, uint* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1uw_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) - /// LD1W Zresult.D, Pg/Z, [Zbases.D, #0] + /// svint64_t svld1uw_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LD1W Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorUInt32ZeroExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + public static Vector GatherVectorUInt32ZeroExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1uw_gather_[u64]index_s64(svbool_t pg, const uint32_t *base, svuint64_t indices) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// svint64_t svld1uw_gather_[u64]index_s64(svbool_t pg, const uint32_t *base, svuint64_t indices) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] /// public static unsafe Vector GatherVectorUInt32ZeroExtend(Vector mask, uint* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1uw_gather_[s64]index_u64(svbool_t pg, const uint32_t *base, svint64_t indices) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// svuint64_t svld1uw_gather_[s64]index_u64(svbool_t pg, const uint32_t *base, svint64_t indices) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] /// public static unsafe Vector GatherVectorUInt32ZeroExtend(Vector mask, uint* address, Vector indices) { throw new PlatformNotSupportedException(); } @@ -4263,104 +4771,256 @@ internal Arm64() { } // LD1W Zresult.D, Pg/Z, [Zbases.D, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorUInt32ZeroExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + // public static Vector GatherVectorUInt32ZeroExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1uw_gather_[u64]index_u64(svbool_t pg, const uint32_t *base, svuint64_t indices) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// svuint64_t svld1uw_gather_[u64]index_u64(svbool_t pg, const uint32_t *base, svuint64_t indices) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] /// public static unsafe Vector GatherVectorUInt32ZeroExtend(Vector mask, uint* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1uw_gather_[s64]index_u64(svbool_t pg, const uint32_t *base, svint64_t indices) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// svuint64_t svld1uw_gather_[s64]index_u64(svbool_t pg, const uint32_t *base, svint64_t indices) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] /// public static unsafe Vector GatherVectorUInt32ZeroExtend(Vector mask, uint* address, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1uw_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) - /// LD1W Zresult.D, Pg/Z, [Zbases.D, #0] + /// svuint64_t svld1uw_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LD1W Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorUInt32ZeroExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + public static Vector GatherVectorUInt32ZeroExtend(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1uw_gather_[u64]index_u64(svbool_t pg, const uint32_t *base, svuint64_t indices) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// svuint64_t svld1uw_gather_[u64]index_u64(svbool_t pg, const uint32_t *base, svuint64_t indices) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] /// public static unsafe Vector GatherVectorUInt32ZeroExtend(Vector mask, uint* address, Vector indices) { throw new PlatformNotSupportedException(); } - // Unextended load + // Load 32-bit data and zero-extend, first-faulting + + /// + /// svint64_t svldff1uw_gather_[s64]index_s64(svbool_t pg, const uint32_t *base, svint64_t indices) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// + public static unsafe Vector GatherVectorUInt32ZeroExtendFirstFaulting(Vector mask, uint* address, Vector indices) { throw new PlatformNotSupportedException(); } + + // + // svint64_t svldff1uw_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + // LDFF1W Zresult.D, Pg/Z, [Zbases.D, #0] + // + // Removed as per #103297 + // public static Vector GatherVectorUInt32ZeroExtendFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svldff1uw_gather_[u64]index_s64(svbool_t pg, const uint32_t *base, svuint64_t indices) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// + public static unsafe Vector GatherVectorUInt32ZeroExtendFirstFaulting(Vector mask, uint* address, Vector indices) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svldff1uw_gather_[s64]index_s64(svbool_t pg, const uint32_t *base, svint64_t indices) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// + public static unsafe Vector GatherVectorUInt32ZeroExtendFirstFaulting(Vector mask, uint* address, Vector indices) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svldff1uw_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LDFF1W Zresult.D, Pg/Z, [Zbases.D, #0] + /// + public static Vector GatherVectorUInt32ZeroExtendFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svldff1uw_gather_[u64]index_s64(svbool_t pg, const uint32_t *base, svuint64_t indices) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// + public static unsafe Vector GatherVectorUInt32ZeroExtendFirstFaulting(Vector mask, uint* address, Vector indices) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1uw_gather_[s64]index_u64(svbool_t pg, const uint32_t *base, svint64_t indices) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// + public static unsafe Vector GatherVectorUInt32ZeroExtendFirstFaulting(Vector mask, uint* address, Vector indices) { throw new PlatformNotSupportedException(); } + + // + // svuint64_t svldff1uw_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + // LDFF1W Zresult.D, Pg/Z, [Zbases.D, #0] + // + // Removed as per #103297 + // public static Vector GatherVectorUInt32ZeroExtendFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1uw_gather_[u64]index_u64(svbool_t pg, const uint32_t *base, svuint64_t indices) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// + public static unsafe Vector GatherVectorUInt32ZeroExtendFirstFaulting(Vector mask, uint* address, Vector indices) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1uw_gather_[s64]index_u64(svbool_t pg, const uint32_t *base, svint64_t indices) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// + public static unsafe Vector GatherVectorUInt32ZeroExtendFirstFaulting(Vector mask, uint* address, Vector indices) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1uw_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LDFF1W Zresult.D, Pg/Z, [Zbases.D, #0] + /// + public static Vector GatherVectorUInt32ZeroExtendFirstFaulting(Vector mask, Vector addresses) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1uw_gather_[u64]index_u64(svbool_t pg, const uint32_t *base, svuint64_t indices) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// + public static unsafe Vector GatherVectorUInt32ZeroExtendFirstFaulting(Vector mask, uint* address, Vector indices) { throw new PlatformNotSupportedException(); } + + + /// Unextended load, first-faulting + + /// + /// svfloat64_t svldff1_gather_[s64]offset[_f64](svbool_t pg, const float64_t *base, svint64_t offsets) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorWithByteOffsetFirstFaulting(Vector mask, double* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svfloat64_t svldff1_gather_[u64]offset[_f64](svbool_t pg, const float64_t *base, svuint64_t offsets) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorWithByteOffsetFirstFaulting(Vector mask, double* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svint32_t svldff1_gather_[s32]offset[_s32](svbool_t pg, const int32_t *base, svint32_t offsets) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// + public static unsafe Vector GatherVectorWithByteOffsetFirstFaulting(Vector mask, int* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svint32_t svldff1_gather_[u32]offset[_s32](svbool_t pg, const int32_t *base, svuint32_t offsets) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// + public static unsafe Vector GatherVectorWithByteOffsetFirstFaulting(Vector mask, int* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svldff1_gather_[s64]offset[_s64](svbool_t pg, const int64_t *base, svint64_t offsets) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorWithByteOffsetFirstFaulting(Vector mask, long* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svld1_gather_[s64]offset[_f64](svbool_t pg, const float64_t *base, svint64_t offsets) - /// LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svldff1_gather_[u64]offset[_s64](svbool_t pg, const int64_t *base, svuint64_t offsets) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorWithByteOffsetFirstFaulting(Vector mask, long* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svfloat32_t svldff1_gather_[s32]offset[_f32](svbool_t pg, const float32_t *base, svint32_t offsets) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// + public static unsafe Vector GatherVectorWithByteOffsetFirstFaulting(Vector mask, float* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svfloat32_t svldff1_gather_[u32]offset[_f32](svbool_t pg, const float32_t *base, svuint32_t offsets) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// + public static unsafe Vector GatherVectorWithByteOffsetFirstFaulting(Vector mask, float* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svuint32_t svldff1_gather_[s32]offset[_u32](svbool_t pg, const uint32_t *base, svint32_t offsets) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// + public static unsafe Vector GatherVectorWithByteOffsetFirstFaulting(Vector mask, uint* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svuint32_t svldff1_gather_[u32]offset[_u32](svbool_t pg, const uint32_t *base, svuint32_t offsets) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// + public static unsafe Vector GatherVectorWithByteOffsetFirstFaulting(Vector mask, uint* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1_gather_[s64]offset[_u64](svbool_t pg, const uint64_t *base, svint64_t offsets) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorWithByteOffsetFirstFaulting(Vector mask, ulong* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svldff1_gather_[u64]offset[_u64](svbool_t pg, const uint64_t *base, svuint64_t offsets) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorWithByteOffsetFirstFaulting(Vector mask, ulong* address, Vector offsets) { throw new PlatformNotSupportedException(); } + + + /// Unextended load + + /// + /// svfloat64_t svld1_gather_[s64]offset[_f64](svbool_t pg, const float64_t *base, svint64_t offsets) + /// LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorWithByteOffsets(Vector mask, double* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svld1_gather_[u64]offset[_f64](svbool_t pg, const float64_t *base, svuint64_t offsets) - /// LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svfloat64_t svld1_gather_[u64]offset[_f64](svbool_t pg, const float64_t *base, svuint64_t offsets) + /// LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorWithByteOffsets(Vector mask, double* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svld1_gather_[s32]offset[_s32](svbool_t pg, const int32_t *base, svint32_t offsets) - /// LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// svint32_t svld1_gather_[s32]offset[_s32](svbool_t pg, const int32_t *base, svint32_t offsets) + /// LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] /// public static unsafe Vector GatherVectorWithByteOffsets(Vector mask, int* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svld1_gather_[u32]offset[_s32](svbool_t pg, const int32_t *base, svuint32_t offsets) - /// LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// svint32_t svld1_gather_[u32]offset[_s32](svbool_t pg, const int32_t *base, svuint32_t offsets) + /// LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] /// public static unsafe Vector GatherVectorWithByteOffsets(Vector mask, int* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1_gather_[s64]offset[_s64](svbool_t pg, const int64_t *base, svint64_t offsets) - /// LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1_gather_[s64]offset[_s64](svbool_t pg, const int64_t *base, svint64_t offsets) + /// LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorWithByteOffsets(Vector mask, long* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1_gather_[u64]offset[_s64](svbool_t pg, const int64_t *base, svuint64_t offsets) - /// LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1_gather_[u64]offset[_s64](svbool_t pg, const int64_t *base, svuint64_t offsets) + /// LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorWithByteOffsets(Vector mask, long* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svld1_gather_[s32]offset[_f32](svbool_t pg, const float32_t *base, svint32_t offsets) - /// LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// svfloat32_t svld1_gather_[s32]offset[_f32](svbool_t pg, const float32_t *base, svint32_t offsets) + /// LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] /// public static unsafe Vector GatherVectorWithByteOffsets(Vector mask, float* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svld1_gather_[u32]offset[_f32](svbool_t pg, const float32_t *base, svuint32_t offsets) - /// LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// svfloat32_t svld1_gather_[u32]offset[_f32](svbool_t pg, const float32_t *base, svuint32_t offsets) + /// LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] /// public static unsafe Vector GatherVectorWithByteOffsets(Vector mask, float* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svld1_gather_[s32]offset[_u32](svbool_t pg, const uint32_t *base, svint32_t offsets) - /// LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// svuint32_t svld1_gather_[s32]offset[_u32](svbool_t pg, const uint32_t *base, svint32_t offsets) + /// LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] /// public static unsafe Vector GatherVectorWithByteOffsets(Vector mask, uint* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svld1_gather_[u32]offset[_u32](svbool_t pg, const uint32_t *base, svuint32_t offsets) - /// LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// svuint32_t svld1_gather_[u32]offset[_u32](svbool_t pg, const uint32_t *base, svuint32_t offsets) + /// LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] /// public static unsafe Vector GatherVectorWithByteOffsets(Vector mask, uint* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1_gather_[s64]offset[_u64](svbool_t pg, const uint64_t *base, svint64_t offsets) - /// LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1_gather_[s64]offset[_u64](svbool_t pg, const uint64_t *base, svint64_t offsets) + /// LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorWithByteOffsets(Vector mask, ulong* address, Vector offsets) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1_gather_[u64]offset[_u64](svbool_t pg, const uint64_t *base, svuint64_t offsets) - /// LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1_gather_[u64]offset[_u64](svbool_t pg, const uint64_t *base, svuint64_t offsets) + /// LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorWithByteOffsets(Vector mask, ulong* address, Vector offsets) { throw new PlatformNotSupportedException(); } @@ -4368,113 +5028,113 @@ internal Arm64() { } // Count set predicate bits /// - /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) - /// CNTP Xresult, Pg, Pop.B + /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) + /// CNTP Xresult, Pg, Pop.B /// - public static unsafe ulong GetActiveElementCount(Vector mask, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong GetActiveElementCount(Vector mask, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) - /// CNTP Xresult, Pg, Pop.B + /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) + /// CNTP Xresult, Pg, Pop.B /// - public static unsafe ulong GetActiveElementCount(Vector mask, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong GetActiveElementCount(Vector mask, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) - /// CNTP Xresult, Pg, Pop.B + /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) + /// CNTP Xresult, Pg, Pop.B /// - public static unsafe ulong GetActiveElementCount(Vector mask, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong GetActiveElementCount(Vector mask, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) - /// CNTP Xresult, Pg, Pop.B + /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) + /// CNTP Xresult, Pg, Pop.B /// - public static unsafe ulong GetActiveElementCount(Vector mask, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong GetActiveElementCount(Vector mask, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) - /// CNTP Xresult, Pg, Pop.B + /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) + /// CNTP Xresult, Pg, Pop.B /// - public static unsafe ulong GetActiveElementCount(Vector mask, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong GetActiveElementCount(Vector mask, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) - /// CNTP Xresult, Pg, Pop.B + /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) + /// CNTP Xresult, Pg, Pop.B /// - public static unsafe ulong GetActiveElementCount(Vector mask, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong GetActiveElementCount(Vector mask, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) - /// CNTP Xresult, Pg, Pop.B + /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) + /// CNTP Xresult, Pg, Pop.B /// - public static unsafe ulong GetActiveElementCount(Vector mask, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong GetActiveElementCount(Vector mask, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svcntp_b16(svbool_t pg, svbool_t op) - /// CNTP Xresult, Pg, Pop.H + /// uint64_t svcntp_b16(svbool_t pg, svbool_t op) + /// CNTP Xresult, Pg, Pop.H /// - public static unsafe ulong GetActiveElementCount(Vector mask, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong GetActiveElementCount(Vector mask, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svcntp_b32(svbool_t pg, svbool_t op) - /// CNTP Xresult, Pg, Pop.S + /// uint64_t svcntp_b32(svbool_t pg, svbool_t op) + /// CNTP Xresult, Pg, Pop.S /// - public static unsafe ulong GetActiveElementCount(Vector mask, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong GetActiveElementCount(Vector mask, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svcntp_b64(svbool_t pg, svbool_t op) - /// CNTP Xresult, Pg, Pop.D + /// uint64_t svcntp_b64(svbool_t pg, svbool_t op) + /// CNTP Xresult, Pg, Pop.D /// - public static unsafe ulong GetActiveElementCount(Vector mask, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong GetActiveElementCount(Vector mask, Vector from) { throw new PlatformNotSupportedException(); } // Read FFR, returning predicate of successfully loaded elements /// - /// svbool_t svrdffr() - /// RDFFR Presult.B + /// svbool_t svrdffr() + /// RDFFR Presult.B /// public static Vector GetFfrByte() { throw new PlatformNotSupportedException(); } /// - /// svbool_t svrdffr() - /// RDFFR Presult.B + /// svbool_t svrdffr() + /// RDFFR Presult.B /// public static Vector GetFfrInt16() { throw new PlatformNotSupportedException(); } /// - /// svbool_t svrdffr() - /// RDFFR Presult.B + /// svbool_t svrdffr() + /// RDFFR Presult.B /// public static Vector GetFfrInt32() { throw new PlatformNotSupportedException(); } /// - /// svbool_t svrdffr() - /// RDFFR Presult.B + /// svbool_t svrdffr() + /// RDFFR Presult.B /// public static Vector GetFfrInt64() { throw new PlatformNotSupportedException(); } /// - /// svbool_t svrdffr() - /// RDFFR Presult.B + /// svbool_t svrdffr() + /// RDFFR Presult.B /// public static Vector GetFfrSByte() { throw new PlatformNotSupportedException(); } /// - /// svbool_t svrdffr() - /// RDFFR Presult.B + /// svbool_t svrdffr() + /// RDFFR Presult.B /// public static Vector GetFfrUInt16() { throw new PlatformNotSupportedException(); } /// - /// svbool_t svrdffr() - /// RDFFR Presult.B + /// svbool_t svrdffr() + /// RDFFR Presult.B /// public static Vector GetFfrUInt32() { throw new PlatformNotSupportedException(); } /// - /// svbool_t svrdffr() - /// RDFFR Presult.B + /// svbool_t svrdffr() + /// RDFFR Presult.B /// public static Vector GetFfrUInt64() { throw new PlatformNotSupportedException(); } @@ -4482,247 +5142,247 @@ internal Arm64() { } // Insert scalar into shifted vector /// - /// svuint8_t svinsr[_n_u8](svuint8_t op1, uint8_t op2) - /// INSR Ztied1.B, Wop2 - /// INSR Ztied1.B, Bop2 + /// svuint8_t svinsr[_n_u8](svuint8_t op1, uint8_t op2) + /// INSR Ztied1.B, Wop2 + /// INSR Ztied1.B, Bop2 /// - public static unsafe Vector InsertIntoShiftedVector(Vector left, byte right) { throw new PlatformNotSupportedException(); } + public static Vector InsertIntoShiftedVector(Vector left, byte right) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svinsr[_n_f64](svfloat64_t op1, float64_t op2) - /// INSR Ztied1.D, Xop2 - /// INSR Ztied1.D, Dop2 + /// svfloat64_t svinsr[_n_f64](svfloat64_t op1, float64_t op2) + /// INSR Ztied1.D, Xop2 + /// INSR Ztied1.D, Dop2 /// - public static unsafe Vector InsertIntoShiftedVector(Vector left, double right) { throw new PlatformNotSupportedException(); } + public static Vector InsertIntoShiftedVector(Vector left, double right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svinsr[_n_s16](svint16_t op1, int16_t op2) - /// INSR Ztied1.H, Wop2 - /// INSR Ztied1.H, Hop2 + /// svint16_t svinsr[_n_s16](svint16_t op1, int16_t op2) + /// INSR Ztied1.H, Wop2 + /// INSR Ztied1.H, Hop2 /// - public static unsafe Vector InsertIntoShiftedVector(Vector left, short right) { throw new PlatformNotSupportedException(); } + public static Vector InsertIntoShiftedVector(Vector left, short right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svinsr[_n_s32](svint32_t op1, int32_t op2) - /// INSR Ztied1.S, Wop2 - /// INSR Ztied1.S, Sop2 + /// svint32_t svinsr[_n_s32](svint32_t op1, int32_t op2) + /// INSR Ztied1.S, Wop2 + /// INSR Ztied1.S, Sop2 /// - public static unsafe Vector InsertIntoShiftedVector(Vector left, int right) { throw new PlatformNotSupportedException(); } + public static Vector InsertIntoShiftedVector(Vector left, int right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svinsr[_n_s64](svint64_t op1, int64_t op2) - /// INSR Ztied1.D, Xop2 - /// INSR Ztied1.D, Dop2 + /// svint64_t svinsr[_n_s64](svint64_t op1, int64_t op2) + /// INSR Ztied1.D, Xop2 + /// INSR Ztied1.D, Dop2 /// - public static unsafe Vector InsertIntoShiftedVector(Vector left, long right) { throw new PlatformNotSupportedException(); } + public static Vector InsertIntoShiftedVector(Vector left, long right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svinsr[_n_s8](svint8_t op1, int8_t op2) - /// INSR Ztied1.B, Wop2 - /// INSR Ztied1.B, Bop2 + /// svint8_t svinsr[_n_s8](svint8_t op1, int8_t op2) + /// INSR Ztied1.B, Wop2 + /// INSR Ztied1.B, Bop2 /// - public static unsafe Vector InsertIntoShiftedVector(Vector left, sbyte right) { throw new PlatformNotSupportedException(); } + public static Vector InsertIntoShiftedVector(Vector left, sbyte right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svinsr[_n_f32](svfloat32_t op1, float32_t op2) - /// INSR Ztied1.S, Wop2 - /// INSR Ztied1.S, Sop2 + /// svfloat32_t svinsr[_n_f32](svfloat32_t op1, float32_t op2) + /// INSR Ztied1.S, Wop2 + /// INSR Ztied1.S, Sop2 /// - public static unsafe Vector InsertIntoShiftedVector(Vector left, float right) { throw new PlatformNotSupportedException(); } + public static Vector InsertIntoShiftedVector(Vector left, float right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svinsr[_n_u16](svuint16_t op1, uint16_t op2) - /// INSR Ztied1.H, Wop2 - /// INSR Ztied1.H, Hop2 + /// svuint16_t svinsr[_n_u16](svuint16_t op1, uint16_t op2) + /// INSR Ztied1.H, Wop2 + /// INSR Ztied1.H, Hop2 /// - public static unsafe Vector InsertIntoShiftedVector(Vector left, ushort right) { throw new PlatformNotSupportedException(); } + public static Vector InsertIntoShiftedVector(Vector left, ushort right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svinsr[_n_u32](svuint32_t op1, uint32_t op2) - /// INSR Ztied1.S, Wop2 - /// INSR Ztied1.S, Sop2 + /// svuint32_t svinsr[_n_u32](svuint32_t op1, uint32_t op2) + /// INSR Ztied1.S, Wop2 + /// INSR Ztied1.S, Sop2 /// - public static unsafe Vector InsertIntoShiftedVector(Vector left, uint right) { throw new PlatformNotSupportedException(); } + public static Vector InsertIntoShiftedVector(Vector left, uint right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svinsr[_n_u64](svuint64_t op1, uint64_t op2) - /// INSR Ztied1.D, Xop2 - /// INSR Ztied1.D, Dop2 + /// svuint64_t svinsr[_n_u64](svuint64_t op1, uint64_t op2) + /// INSR Ztied1.D, Xop2 + /// INSR Ztied1.D, Dop2 /// - public static unsafe Vector InsertIntoShiftedVector(Vector left, ulong right) { throw new PlatformNotSupportedException(); } + public static Vector InsertIntoShiftedVector(Vector left, ulong right) { throw new PlatformNotSupportedException(); } // Count leading sign bits /// - /// svuint8_t svcls[_s8]_m(svuint8_t inactive, svbool_t pg, svint8_t op) - /// svuint8_t svcls[_s8]_x(svbool_t pg, svint8_t op) - /// svuint8_t svcls[_s8]_z(svbool_t pg, svint8_t op) - /// CLS Zresult.B, Pg/M, Zop.B + /// svuint8_t svcls[_s8]_m(svuint8_t inactive, svbool_t pg, svint8_t op) + /// svuint8_t svcls[_s8]_x(svbool_t pg, svint8_t op) + /// svuint8_t svcls[_s8]_z(svbool_t pg, svint8_t op) + /// CLS Zresult.B, Pg/M, Zop.B /// - public static unsafe Vector LeadingSignCount(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector LeadingSignCount(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svcls[_s16]_m(svuint16_t inactive, svbool_t pg, svint16_t op) - /// svuint16_t svcls[_s16]_x(svbool_t pg, svint16_t op) - /// svuint16_t svcls[_s16]_z(svbool_t pg, svint16_t op) - /// CLS Zresult.H, Pg/M, Zop.H + /// svuint16_t svcls[_s16]_m(svuint16_t inactive, svbool_t pg, svint16_t op) + /// svuint16_t svcls[_s16]_x(svbool_t pg, svint16_t op) + /// svuint16_t svcls[_s16]_z(svbool_t pg, svint16_t op) + /// CLS Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector LeadingSignCount(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector LeadingSignCount(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svcls[_s32]_m(svuint32_t inactive, svbool_t pg, svint32_t op) - /// svuint32_t svcls[_s32]_x(svbool_t pg, svint32_t op) - /// svuint32_t svcls[_s32]_z(svbool_t pg, svint32_t op) - /// CLS Zresult.S, Pg/M, Zop.S + /// svuint32_t svcls[_s32]_m(svuint32_t inactive, svbool_t pg, svint32_t op) + /// svuint32_t svcls[_s32]_x(svbool_t pg, svint32_t op) + /// svuint32_t svcls[_s32]_z(svbool_t pg, svint32_t op) + /// CLS Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector LeadingSignCount(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector LeadingSignCount(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svcls[_s64]_m(svuint64_t inactive, svbool_t pg, svint64_t op) - /// svuint64_t svcls[_s64]_x(svbool_t pg, svint64_t op) - /// svuint64_t svcls[_s64]_z(svbool_t pg, svint64_t op) - /// CLS Zresult.D, Pg/M, Zop.D + /// svuint64_t svcls[_s64]_m(svuint64_t inactive, svbool_t pg, svint64_t op) + /// svuint64_t svcls[_s64]_x(svbool_t pg, svint64_t op) + /// svuint64_t svcls[_s64]_z(svbool_t pg, svint64_t op) + /// CLS Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector LeadingSignCount(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector LeadingSignCount(Vector value) { throw new PlatformNotSupportedException(); } // Count leading zero bits /// - /// svuint8_t svclz[_s8]_m(svuint8_t inactive, svbool_t pg, svint8_t op) - /// svuint8_t svclz[_s8]_x(svbool_t pg, svint8_t op) - /// svuint8_t svclz[_s8]_z(svbool_t pg, svint8_t op) - /// CLZ Zresult.B, Pg/M, Zop.B + /// svuint8_t svclz[_s8]_m(svuint8_t inactive, svbool_t pg, svint8_t op) + /// svuint8_t svclz[_s8]_x(svbool_t pg, svint8_t op) + /// svuint8_t svclz[_s8]_z(svbool_t pg, svint8_t op) + /// CLZ Zresult.B, Pg/M, Zop.B /// - public static unsafe Vector LeadingZeroCount(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector LeadingZeroCount(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint8_t svclz[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) - /// svuint8_t svclz[_u8]_x(svbool_t pg, svuint8_t op) - /// svuint8_t svclz[_u8]_z(svbool_t pg, svuint8_t op) - /// CLZ Zresult.B, Pg/M, Zop.B + /// svuint8_t svclz[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) + /// svuint8_t svclz[_u8]_x(svbool_t pg, svuint8_t op) + /// svuint8_t svclz[_u8]_z(svbool_t pg, svuint8_t op) + /// CLZ Zresult.B, Pg/M, Zop.B /// - public static unsafe Vector LeadingZeroCount(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector LeadingZeroCount(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svclz[_s16]_m(svuint16_t inactive, svbool_t pg, svint16_t op) - /// svuint16_t svclz[_s16]_x(svbool_t pg, svint16_t op) - /// svuint16_t svclz[_s16]_z(svbool_t pg, svint16_t op) - /// CLZ Zresult.H, Pg/M, Zop.H + /// svuint16_t svclz[_s16]_m(svuint16_t inactive, svbool_t pg, svint16_t op) + /// svuint16_t svclz[_s16]_x(svbool_t pg, svint16_t op) + /// svuint16_t svclz[_s16]_z(svbool_t pg, svint16_t op) + /// CLZ Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector LeadingZeroCount(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector LeadingZeroCount(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svclz[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) - /// svuint16_t svclz[_u16]_x(svbool_t pg, svuint16_t op) - /// svuint16_t svclz[_u16]_z(svbool_t pg, svuint16_t op) - /// CLZ Zresult.H, Pg/M, Zop.H + /// svuint16_t svclz[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) + /// svuint16_t svclz[_u16]_x(svbool_t pg, svuint16_t op) + /// svuint16_t svclz[_u16]_z(svbool_t pg, svuint16_t op) + /// CLZ Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector LeadingZeroCount(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector LeadingZeroCount(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svclz[_s32]_m(svuint32_t inactive, svbool_t pg, svint32_t op) - /// svuint32_t svclz[_s32]_x(svbool_t pg, svint32_t op) - /// svuint32_t svclz[_s32]_z(svbool_t pg, svint32_t op) - /// CLZ Zresult.S, Pg/M, Zop.S + /// svuint32_t svclz[_s32]_m(svuint32_t inactive, svbool_t pg, svint32_t op) + /// svuint32_t svclz[_s32]_x(svbool_t pg, svint32_t op) + /// svuint32_t svclz[_s32]_z(svbool_t pg, svint32_t op) + /// CLZ Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector LeadingZeroCount(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector LeadingZeroCount(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svclz[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) - /// svuint32_t svclz[_u32]_x(svbool_t pg, svuint32_t op) - /// svuint32_t svclz[_u32]_z(svbool_t pg, svuint32_t op) - /// CLZ Zresult.S, Pg/M, Zop.S + /// svuint32_t svclz[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) + /// svuint32_t svclz[_u32]_x(svbool_t pg, svuint32_t op) + /// svuint32_t svclz[_u32]_z(svbool_t pg, svuint32_t op) + /// CLZ Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector LeadingZeroCount(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector LeadingZeroCount(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svclz[_s64]_m(svuint64_t inactive, svbool_t pg, svint64_t op) - /// svuint64_t svclz[_s64]_x(svbool_t pg, svint64_t op) - /// svuint64_t svclz[_s64]_z(svbool_t pg, svint64_t op) - /// CLZ Zresult.D, Pg/M, Zop.D + /// svuint64_t svclz[_s64]_m(svuint64_t inactive, svbool_t pg, svint64_t op) + /// svuint64_t svclz[_s64]_x(svbool_t pg, svint64_t op) + /// svuint64_t svclz[_s64]_z(svbool_t pg, svint64_t op) + /// CLZ Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector LeadingZeroCount(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector LeadingZeroCount(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svclz[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) - /// svuint64_t svclz[_u64]_x(svbool_t pg, svuint64_t op) - /// svuint64_t svclz[_u64]_z(svbool_t pg, svuint64_t op) - /// CLZ Zresult.D, Pg/M, Zop.D + /// svuint64_t svclz[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) + /// svuint64_t svclz[_u64]_x(svbool_t pg, svuint64_t op) + /// svuint64_t svclz[_u64]_z(svbool_t pg, svuint64_t op) + /// CLZ Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector LeadingZeroCount(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector LeadingZeroCount(Vector value) { throw new PlatformNotSupportedException(); } // Unextended load /// - /// svuint8_t svld1[_u8](svbool_t pg, const uint8_t *base) - /// LD1B Zresult.B, Pg/Z, [Xarray, Xindex] - /// LD1B Zresult.B, Pg/Z, [Xbase, #0, MUL VL] + /// svuint8_t svld1[_u8](svbool_t pg, const uint8_t *base) + /// LD1B Zresult.B, Pg/Z, [Xarray, Xindex] + /// LD1B Zresult.B, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVector(Vector mask, byte* address) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svld1[_f64](svbool_t pg, const float64_t *base) - /// LD1D Zresult.D, Pg/Z, [Xarray, Xindex, LSL #3] - /// LD1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svfloat64_t svld1[_f64](svbool_t pg, const float64_t *base) + /// LD1D Zresult.D, Pg/Z, [Xarray, Xindex, LSL #3] + /// LD1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVector(Vector mask, double* address) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svld1[_s16](svbool_t pg, const int16_t *base) - /// LD1H Zresult.H, Pg/Z, [Xarray, Xindex, LSL #1] - /// LD1H Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svint16_t svld1[_s16](svbool_t pg, const int16_t *base) + /// LD1H Zresult.H, Pg/Z, [Xarray, Xindex, LSL #1] + /// LD1H Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVector(Vector mask, short* address) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svld1[_s32](svbool_t pg, const int32_t *base) - /// LD1W Zresult.S, Pg/Z, [Xarray, Xindex, LSL #2] - /// LD1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svint32_t svld1[_s32](svbool_t pg, const int32_t *base) + /// LD1W Zresult.S, Pg/Z, [Xarray, Xindex, LSL #2] + /// LD1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVector(Vector mask, int* address) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1[_s64](svbool_t pg, const int64_t *base) - /// LD1D Zresult.D, Pg/Z, [Xarray, Xindex, LSL #3] - /// LD1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svld1[_s64](svbool_t pg, const int64_t *base) + /// LD1D Zresult.D, Pg/Z, [Xarray, Xindex, LSL #3] + /// LD1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVector(Vector mask, long* address) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svld1[_s8](svbool_t pg, const int8_t *base) - /// LD1B Zresult.B, Pg/Z, [Xarray, Xindex] - /// LD1B Zresult.B, Pg/Z, [Xbase, #0, MUL VL] + /// svint8_t svld1[_s8](svbool_t pg, const int8_t *base) + /// LD1B Zresult.B, Pg/Z, [Xarray, Xindex] + /// LD1B Zresult.B, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVector(Vector mask, sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svld1[_f32](svbool_t pg, const float32_t *base) - /// LD1W Zresult.S, Pg/Z, [Xarray, Xindex, LSL #2] - /// LD1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svfloat32_t svld1[_f32](svbool_t pg, const float32_t *base) + /// LD1W Zresult.S, Pg/Z, [Xarray, Xindex, LSL #2] + /// LD1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVector(Vector mask, float* address) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svld1[_u16](svbool_t pg, const uint16_t *base) - /// LD1H Zresult.H, Pg/Z, [Xarray, Xindex, LSL #1] - /// LD1H Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svuint16_t svld1[_u16](svbool_t pg, const uint16_t *base) + /// LD1H Zresult.H, Pg/Z, [Xarray, Xindex, LSL #1] + /// LD1H Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVector(Vector mask, ushort* address) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svld1[_u32](svbool_t pg, const uint32_t *base) - /// LD1W Zresult.S, Pg/Z, [Xarray, Xindex, LSL #2] - /// LD1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32_t svld1[_u32](svbool_t pg, const uint32_t *base) + /// LD1W Zresult.S, Pg/Z, [Xarray, Xindex, LSL #2] + /// LD1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVector(Vector mask, uint* address) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1[_u64](svbool_t pg, const uint64_t *base) - /// LD1D Zresult.D, Pg/Z, [Xarray, Xindex, LSL #3] - /// LD1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svld1[_u64](svbool_t pg, const uint64_t *base) + /// LD1D Zresult.D, Pg/Z, [Xarray, Xindex, LSL #3] + /// LD1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVector(Vector mask, ulong* address) { throw new PlatformNotSupportedException(); } @@ -4730,62 +5390,62 @@ internal Arm64() { } // Load and replicate 128 bits of data /// - /// svuint8_t svld1rq[_u8](svbool_t pg, const uint8_t *base) - /// LD1RQB Zresult.B, Pg/Z, [Xbase, #0] + /// svuint8_t svld1rq[_u8](svbool_t pg, const uint8_t *base) + /// LD1RQB Zresult.B, Pg/Z, [Xbase, #0] /// public static unsafe Vector LoadVector128AndReplicateToVector(Vector mask, byte* address) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svld1rq[_f64](svbool_t pg, const float64_t *base) - /// LD1RQD Zresult.D, Pg/Z, [Xbase, #0] + /// svfloat64_t svld1rq[_f64](svbool_t pg, const float64_t *base) + /// LD1RQD Zresult.D, Pg/Z, [Xbase, #0] /// public static unsafe Vector LoadVector128AndReplicateToVector(Vector mask, double* address) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svld1rq[_s16](svbool_t pg, const int16_t *base) - /// LD1RQH Zresult.H, Pg/Z, [Xbase, #0] + /// svint16_t svld1rq[_s16](svbool_t pg, const int16_t *base) + /// LD1RQH Zresult.H, Pg/Z, [Xbase, #0] /// public static unsafe Vector LoadVector128AndReplicateToVector(Vector mask, short* address) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svld1rq[_s32](svbool_t pg, const int32_t *base) - /// LD1RQW Zresult.S, Pg/Z, [Xbase, #0] + /// svint32_t svld1rq[_s32](svbool_t pg, const int32_t *base) + /// LD1RQW Zresult.S, Pg/Z, [Xbase, #0] /// public static unsafe Vector LoadVector128AndReplicateToVector(Vector mask, int* address) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svld1rq[_s64](svbool_t pg, const int64_t *base) - /// LD1RQD Zresult.D, Pg/Z, [Xbase, #0] + /// svint64_t svld1rq[_s64](svbool_t pg, const int64_t *base) + /// LD1RQD Zresult.D, Pg/Z, [Xbase, #0] /// public static unsafe Vector LoadVector128AndReplicateToVector(Vector mask, long* address) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svld1rq[_s8](svbool_t pg, const int8_t *base) - /// LD1RQB Zresult.B, Pg/Z, [Xbase, #0] + /// svint8_t svld1rq[_s8](svbool_t pg, const int8_t *base) + /// LD1RQB Zresult.B, Pg/Z, [Xbase, #0] /// public static unsafe Vector LoadVector128AndReplicateToVector(Vector mask, sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svld1rq[_f32](svbool_t pg, const float32_t *base) - /// LD1RQW Zresult.S, Pg/Z, [Xbase, #0] + /// svfloat32_t svld1rq[_f32](svbool_t pg, const float32_t *base) + /// LD1RQW Zresult.S, Pg/Z, [Xbase, #0] /// public static unsafe Vector LoadVector128AndReplicateToVector(Vector mask, float* address) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svld1rq[_u16](svbool_t pg, const uint16_t *base) - /// LD1RQH Zresult.H, Pg/Z, [Xbase, #0] + /// svuint16_t svld1rq[_u16](svbool_t pg, const uint16_t *base) + /// LD1RQH Zresult.H, Pg/Z, [Xbase, #0] /// public static unsafe Vector LoadVector128AndReplicateToVector(Vector mask, ushort* address) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svld1rq[_u32](svbool_t pg, const uint32_t *base) - /// LD1RQW Zresult.S, Pg/Z, [Xbase, #0] + /// svuint32_t svld1rq[_u32](svbool_t pg, const uint32_t *base) + /// LD1RQW Zresult.S, Pg/Z, [Xbase, #0] /// public static unsafe Vector LoadVector128AndReplicateToVector(Vector mask, uint* address) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svld1rq[_u64](svbool_t pg, const uint64_t *base) - /// LD1RQD Zresult.D, Pg/Z, [Xbase, #0] + /// svuint64_t svld1rq[_u64](svbool_t pg, const uint64_t *base) + /// LD1RQD Zresult.D, Pg/Z, [Xbase, #0] /// public static unsafe Vector LoadVector128AndReplicateToVector(Vector mask, ulong* address) { throw new PlatformNotSupportedException(); } @@ -4793,8 +5453,8 @@ internal Arm64() { } // Load 8-bit data and zero-extend, non-faulting /// - /// svint16_t svldnf1ub_s16(svbool_t pg, const uint8_t *base) - /// LDNF1B Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svint16_t svldnf1ub_s16(svbool_t pg, const uint8_t *base) + /// LDNF1B Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorByteNonFaultingZeroExtendToInt16(byte* address) { throw new PlatformNotSupportedException(); } @@ -4802,8 +5462,8 @@ internal Arm64() { } // Load 8-bit data and zero-extend, non-faulting /// - /// svint32_t svldnf1ub_s32(svbool_t pg, const uint8_t *base) - /// LDNF1B Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svint32_t svldnf1ub_s32(svbool_t pg, const uint8_t *base) + /// LDNF1B Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorByteNonFaultingZeroExtendToInt32(byte* address) { throw new PlatformNotSupportedException(); } @@ -4811,8 +5471,8 @@ internal Arm64() { } // Load 8-bit data and zero-extend, non-faulting /// - /// svint64_t svldnf1ub_s64(svbool_t pg, const uint8_t *base) - /// LDNF1B Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svldnf1ub_s64(svbool_t pg, const uint8_t *base) + /// LDNF1B Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorByteNonFaultingZeroExtendToInt64(byte* address) { throw new PlatformNotSupportedException(); } @@ -4820,8 +5480,8 @@ internal Arm64() { } // Load 8-bit data and zero-extend, non-faulting /// - /// svuint16_t svldnf1ub_u16(svbool_t pg, const uint8_t *base) - /// LDNF1B Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svuint16_t svldnf1ub_u16(svbool_t pg, const uint8_t *base) + /// LDNF1B Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorByteNonFaultingZeroExtendToUInt16(byte* address) { throw new PlatformNotSupportedException(); } @@ -4829,8 +5489,8 @@ internal Arm64() { } // Load 8-bit data and zero-extend, non-faulting /// - /// svuint32_t svldnf1ub_u32(svbool_t pg, const uint8_t *base) - /// LDNF1B Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32_t svldnf1ub_u32(svbool_t pg, const uint8_t *base) + /// LDNF1B Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorByteNonFaultingZeroExtendToUInt32(byte* address) { throw new PlatformNotSupportedException(); } @@ -4838,45 +5498,45 @@ internal Arm64() { } // Load 8-bit data and zero-extend, non-faulting /// - /// svuint64_t svldnf1ub_u64(svbool_t pg, const uint8_t *base) - /// LDNF1B Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svldnf1ub_u64(svbool_t pg, const uint8_t *base) + /// LDNF1B Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorByteNonFaultingZeroExtendToUInt64(byte* address) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svldff1ub_s16(svbool_t pg, const uint8_t *base) - /// LDFF1B Zresult.H, Pg/Z, [Xbase, XZR] + /// svint16_t svldff1ub_s16(svbool_t pg, const uint8_t *base) + /// LDFF1B Zresult.H, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorByteZeroExtendFirstFaulting(Vector mask, byte* address) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svldff1ub_s32(svbool_t pg, const uint8_t *base) - /// LDFF1B Zresult.S, Pg/Z, [Xbase, XZR] + /// svint32_t svldff1ub_s32(svbool_t pg, const uint8_t *base) + /// LDFF1B Zresult.S, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorByteZeroExtendFirstFaulting(Vector mask, byte* address) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svldff1ub_s64(svbool_t pg, const uint8_t *base) - /// LDFF1B Zresult.D, Pg/Z, [Xbase, XZR] + /// svint64_t svldff1ub_s64(svbool_t pg, const uint8_t *base) + /// LDFF1B Zresult.D, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorByteZeroExtendFirstFaulting(Vector mask, byte* address) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svldff1ub_u16(svbool_t pg, const uint8_t *base) - /// LDFF1B Zresult.H, Pg/Z, [Xbase, XZR] + /// svuint16_t svldff1ub_u16(svbool_t pg, const uint8_t *base) + /// LDFF1B Zresult.H, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorByteZeroExtendFirstFaulting(Vector mask, byte* address) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svldff1ub_u32(svbool_t pg, const uint8_t *base) - /// LDFF1B Zresult.S, Pg/Z, [Xbase, XZR] + /// svuint32_t svldff1ub_u32(svbool_t pg, const uint8_t *base) + /// LDFF1B Zresult.S, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorByteZeroExtendFirstFaulting(Vector mask, byte* address) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svldff1ub_u64(svbool_t pg, const uint8_t *base) - /// LDFF1B Zresult.D, Pg/Z, [Xbase, XZR] + /// svuint64_t svldff1ub_u64(svbool_t pg, const uint8_t *base) + /// LDFF1B Zresult.D, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorByteZeroExtendFirstFaulting(Vector mask, byte* address) { throw new PlatformNotSupportedException(); } @@ -4884,8 +5544,8 @@ internal Arm64() { } // Load 8-bit data and zero-extend /// - /// svint16_t svld1ub_s16(svbool_t pg, const uint8_t *base) - /// LD1B Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svint16_t svld1ub_s16(svbool_t pg, const uint8_t *base) + /// LD1B Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorByteZeroExtendToInt16(Vector mask, byte* address) { throw new PlatformNotSupportedException(); } @@ -4893,8 +5553,8 @@ internal Arm64() { } // Load 8-bit data and zero-extend /// - /// svint32_t svld1ub_s32(svbool_t pg, const uint8_t *base) - /// LD1B Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svint32_t svld1ub_s32(svbool_t pg, const uint8_t *base) + /// LD1B Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorByteZeroExtendToInt32(Vector mask, byte* address) { throw new PlatformNotSupportedException(); } @@ -4902,8 +5562,8 @@ internal Arm64() { } // Load 8-bit data and zero-extend /// - /// svint64_t svld1ub_s64(svbool_t pg, const uint8_t *base) - /// LD1B Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svld1ub_s64(svbool_t pg, const uint8_t *base) + /// LD1B Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorByteZeroExtendToInt64(Vector mask, byte* address) { throw new PlatformNotSupportedException(); } @@ -4911,8 +5571,8 @@ internal Arm64() { } // Load 8-bit data and zero-extend /// - /// svuint16_t svld1ub_u16(svbool_t pg, const uint8_t *base) - /// LD1B Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svuint16_t svld1ub_u16(svbool_t pg, const uint8_t *base) + /// LD1B Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorByteZeroExtendToUInt16(Vector mask, byte* address) { throw new PlatformNotSupportedException(); } @@ -4920,8 +5580,8 @@ internal Arm64() { } // Load 8-bit data and zero-extend /// - /// svuint32_t svld1ub_u32(svbool_t pg, const uint8_t *base) - /// LD1B Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32_t svld1ub_u32(svbool_t pg, const uint8_t *base) + /// LD1B Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorByteZeroExtendToUInt32(Vector mask, byte* address) { throw new PlatformNotSupportedException(); } @@ -4929,8 +5589,8 @@ internal Arm64() { } // Load 8-bit data and zero-extend /// - /// svuint64_t svld1ub_u64(svbool_t pg, const uint8_t *base) - /// LD1B Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svld1ub_u64(svbool_t pg, const uint8_t *base) + /// LD1B Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorByteZeroExtendToUInt64(Vector mask, byte* address) { throw new PlatformNotSupportedException(); } @@ -4938,69 +5598,71 @@ internal Arm64() { } // Unextended load, first-faulting /// - /// svuint8_t svldff1[_u8](svbool_t pg, const uint8_t *base) - /// LDFF1B Zresult.B, Pg/Z, [Xbase, XZR] + /// svuint8_t svldff1[_u8](svbool_t pg, const uint8_t *base) + /// LDFF1B Zresult.B, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorFirstFaulting(Vector mask, byte* address) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svldff1[_f64](svbool_t pg, const float64_t *base) - /// LDFF1D Zresult.D, Pg/Z, [Xbase, XZR, LSL #3] + /// svfloat64_t svldff1[_f64](svbool_t pg, const float64_t *base) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, XZR, LSL #3] /// public static unsafe Vector LoadVectorFirstFaulting(Vector mask, double* address) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svldff1[_s16](svbool_t pg, const int16_t *base) - /// LDFF1H Zresult.H, Pg/Z, [Xbase, XZR, LSL #1] + /// svint16_t svldff1[_s16](svbool_t pg, const int16_t *base) + /// LDFF1H Zresult.H, Pg/Z, [Xbase, XZR, LSL #1] /// public static unsafe Vector LoadVectorFirstFaulting(Vector mask, short* address) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svldff1[_s32](svbool_t pg, const int32_t *base) - /// LDFF1W Zresult.S, Pg/Z, [Xbase, XZR, LSL #2] + /// svint32_t svldff1[_s32](svbool_t pg, const int32_t *base) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, XZR, LSL #2] /// public static unsafe Vector LoadVectorFirstFaulting(Vector mask, int* address) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svldff1[_s64](svbool_t pg, const int64_t *base) - /// LDFF1D Zresult.D, Pg/Z, [Xbase, XZR, LSL #3] + /// svint64_t svldff1[_s64](svbool_t pg, const int64_t *base) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, XZR, LSL #3] /// public static unsafe Vector LoadVectorFirstFaulting(Vector mask, long* address) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svldff1[_s8](svbool_t pg, const int8_t *base) - /// LDFF1B Zresult.B, Pg/Z, [Xbase, XZR] + /// svint8_t svldff1[_s8](svbool_t pg, const int8_t *base) + /// LDFF1B Zresult.B, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorFirstFaulting(Vector mask, sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svldff1[_f32](svbool_t pg, const float32_t *base) - /// LDFF1W Zresult.S, Pg/Z, [Xbase, XZR, LSL #2] + /// svfloat32_t svldff1[_f32](svbool_t pg, const float32_t *base) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, XZR, LSL #2] /// public static unsafe Vector LoadVectorFirstFaulting(Vector mask, float* address) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svldff1[_u16](svbool_t pg, const uint16_t *base) - /// LDFF1H Zresult.H, Pg/Z, [Xbase, XZR, LSL #1] + /// svuint16_t svldff1[_u16](svbool_t pg, const uint16_t *base) + /// LDFF1H Zresult.H, Pg/Z, [Xbase, XZR, LSL #1] /// public static unsafe Vector LoadVectorFirstFaulting(Vector mask, ushort* address) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svldff1[_u32](svbool_t pg, const uint32_t *base) - /// LDFF1W Zresult.S, Pg/Z, [Xbase, XZR, LSL #2] + /// svuint32_t svldff1[_u32](svbool_t pg, const uint32_t *base) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, XZR, LSL #2] /// public static unsafe Vector LoadVectorFirstFaulting(Vector mask, uint* address) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svldff1[_u64](svbool_t pg, const uint64_t *base) - /// LDFF1D Zresult.D, Pg/Z, [Xbase, XZR, LSL #3] + /// svuint64_t svldff1[_u64](svbool_t pg, const uint64_t *base) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, XZR, LSL #3] /// public static unsafe Vector LoadVectorFirstFaulting(Vector mask, ulong* address) { throw new PlatformNotSupportedException(); } + + // Load 16-bit data and sign-extend, non-faulting /// - /// svint32_t svldnf1sh_s32(svbool_t pg, const int16_t *base) - /// LDNF1SH Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svint32_t svldnf1sh_s32(svbool_t pg, const int16_t *base) + /// LDNF1SH Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorInt16NonFaultingSignExtendToInt32(short* address) { throw new PlatformNotSupportedException(); } @@ -5008,8 +5670,8 @@ internal Arm64() { } // Load 16-bit data and sign-extend, non-faulting /// - /// svint64_t svldnf1sh_s64(svbool_t pg, const int16_t *base) - /// LDNF1SH Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svldnf1sh_s64(svbool_t pg, const int16_t *base) + /// LDNF1SH Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorInt16NonFaultingSignExtendToInt64(short* address) { throw new PlatformNotSupportedException(); } @@ -5017,8 +5679,8 @@ internal Arm64() { } // Load 16-bit data and sign-extend, non-faulting /// - /// svuint32_t svldnf1sh_u32(svbool_t pg, const int16_t *base) - /// LDNF1SH Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32_t svldnf1sh_u32(svbool_t pg, const int16_t *base) + /// LDNF1SH Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorInt16NonFaultingSignExtendToUInt32(short* address) { throw new PlatformNotSupportedException(); } @@ -5026,35 +5688,35 @@ internal Arm64() { } // Load 16-bit data and sign-extend, non-faulting /// - /// svuint64_t svldnf1sh_u64(svbool_t pg, const int16_t *base) - /// LDNF1SH Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svldnf1sh_u64(svbool_t pg, const int16_t *base) + /// LDNF1SH Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorInt16NonFaultingSignExtendToUInt64(short* address) { throw new PlatformNotSupportedException(); } - /// Load 16-bit data and sign-extend, first-faulting + // Load 16-bit data and sign-extend, first-faulting /// - /// svint32_t svldff1sh_s32(svbool_t pg, const int16_t *base) - /// LDFF1SH Zresult.S, Pg/Z, [Xbase, XZR, LSL #1] + /// svint32_t svldff1sh_s32(svbool_t pg, const int16_t *base) + /// LDFF1SH Zresult.S, Pg/Z, [Xbase, XZR, LSL #1] /// public static unsafe Vector LoadVectorInt16SignExtendFirstFaulting(Vector mask, short* address) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svldff1sh_s64(svbool_t pg, const int16_t *base) - /// LDFF1SH Zresult.D, Pg/Z, [Xbase, XZR, LSL #1] + /// svint64_t svldff1sh_s64(svbool_t pg, const int16_t *base) + /// LDFF1SH Zresult.D, Pg/Z, [Xbase, XZR, LSL #1] /// public static unsafe Vector LoadVectorInt16SignExtendFirstFaulting(Vector mask, short* address) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svldff1sh_u32(svbool_t pg, const int16_t *base) - /// LDFF1SH Zresult.S, Pg/Z, [Xbase, XZR, LSL #1] + /// svuint32_t svldff1sh_u32(svbool_t pg, const int16_t *base) + /// LDFF1SH Zresult.S, Pg/Z, [Xbase, XZR, LSL #1] /// public static unsafe Vector LoadVectorInt16SignExtendFirstFaulting(Vector mask, short* address) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svldff1sh_u64(svbool_t pg, const int16_t *base) - /// LDFF1SH Zresult.D, Pg/Z, [Xbase, XZR, LSL #1] + /// svuint64_t svldff1sh_u64(svbool_t pg, const int16_t *base) + /// LDFF1SH Zresult.D, Pg/Z, [Xbase, XZR, LSL #1] /// public static unsafe Vector LoadVectorInt16SignExtendFirstFaulting(Vector mask, short* address) { throw new PlatformNotSupportedException(); } @@ -5062,8 +5724,8 @@ internal Arm64() { } // Load 16-bit data and sign-extend /// - /// svint32_t svld1sh_s32(svbool_t pg, const int16_t *base) - /// LD1SH Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svint32_t svld1sh_s32(svbool_t pg, const int16_t *base) + /// LD1SH Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorInt16SignExtendToInt32(Vector mask, short* address) { throw new PlatformNotSupportedException(); } @@ -5071,8 +5733,8 @@ internal Arm64() { } // Load 16-bit data and sign-extend /// - /// svint64_t svld1sh_s64(svbool_t pg, const int16_t *base) - /// LD1SH Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svld1sh_s64(svbool_t pg, const int16_t *base) + /// LD1SH Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorInt16SignExtendToInt64(Vector mask, short* address) { throw new PlatformNotSupportedException(); } @@ -5080,8 +5742,8 @@ internal Arm64() { } // Load 16-bit data and sign-extend /// - /// svuint32_t svld1sh_u32(svbool_t pg, const int16_t *base) - /// LD1SH Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32_t svld1sh_u32(svbool_t pg, const int16_t *base) + /// LD1SH Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorInt16SignExtendToUInt32(Vector mask, short* address) { throw new PlatformNotSupportedException(); } @@ -5089,8 +5751,8 @@ internal Arm64() { } // Load 16-bit data and sign-extend /// - /// svuint64_t svld1sh_u64(svbool_t pg, const int16_t *base) - /// LD1SH Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svld1sh_u64(svbool_t pg, const int16_t *base) + /// LD1SH Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorInt16SignExtendToUInt64(Vector mask, short* address) { throw new PlatformNotSupportedException(); } @@ -5098,8 +5760,8 @@ internal Arm64() { } // Load 32-bit data and sign-extend, non-faulting /// - /// svint64_t svldnf1sw_s64(svbool_t pg, const int32_t *base) - /// LDNF1SW Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svldnf1sw_s64(svbool_t pg, const int32_t *base) + /// LDNF1SW Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorInt32NonFaultingSignExtendToInt64(int* address) { throw new PlatformNotSupportedException(); } @@ -5107,23 +5769,23 @@ internal Arm64() { } // Load 32-bit data and sign-extend, non-faulting /// - /// svuint64_t svldnf1sw_u64(svbool_t pg, const int32_t *base) - /// LDNF1SW Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svldnf1sw_u64(svbool_t pg, const int32_t *base) + /// LDNF1SW Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorInt32NonFaultingSignExtendToUInt64(int* address) { throw new PlatformNotSupportedException(); } - /// Load 32-bit data and sign-extend, first-faulting + // Load 32-bit data and sign-extend, first-faulting /// - /// svint64_t svldff1sw_s64(svbool_t pg, const int32_t *base) - /// LDFF1SW Zresult.D, Pg/Z, [Xbase, XZR, LSL #2] + /// svint64_t svldff1sw_s64(svbool_t pg, const int32_t *base) + /// LDFF1SW Zresult.D, Pg/Z, [Xbase, XZR, LSL #2] /// public static unsafe Vector LoadVectorInt32SignExtendFirstFaulting(Vector mask, int* address) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svldff1sw_u64(svbool_t pg, const int32_t *base) - /// LDFF1SW Zresult.D, Pg/Z, [Xbase, XZR, LSL #2] + /// svuint64_t svldff1sw_u64(svbool_t pg, const int32_t *base) + /// LDFF1SW Zresult.D, Pg/Z, [Xbase, XZR, LSL #2] /// public static unsafe Vector LoadVectorInt32SignExtendFirstFaulting(Vector mask, int* address) { throw new PlatformNotSupportedException(); } @@ -5131,8 +5793,8 @@ internal Arm64() { } // Load 32-bit data and sign-extend /// - /// svint64_t svld1sw_s64(svbool_t pg, const int32_t *base) - /// LD1SW Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svld1sw_s64(svbool_t pg, const int32_t *base) + /// LD1SW Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorInt32SignExtendToInt64(Vector mask, int* address) { throw new PlatformNotSupportedException(); } @@ -5140,8 +5802,8 @@ internal Arm64() { } // Load 32-bit data and sign-extend /// - /// svuint64_t svld1sw_u64(svbool_t pg, const int32_t *base) - /// LD1SW Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svld1sw_u64(svbool_t pg, const int32_t *base) + /// LD1SW Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorInt32SignExtendToUInt64(Vector mask, int* address) { throw new PlatformNotSupportedException(); } @@ -5149,62 +5811,62 @@ internal Arm64() { } // Unextended load, non-faulting /// - /// svuint8_t svldnf1[_u8](svbool_t pg, const uint8_t *base) - /// LDNF1B Zresult.B, Pg/Z, [Xbase, #0, MUL VL] + /// svuint8_t svldnf1[_u8](svbool_t pg, const uint8_t *base) + /// LDNF1B Zresult.B, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonFaulting(byte* address) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svldnf1[_f64](svbool_t pg, const float64_t *base) - /// LDNF1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svfloat64_t svldnf1[_f64](svbool_t pg, const float64_t *base) + /// LDNF1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonFaulting(double* address) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svldnf1[_s16](svbool_t pg, const int16_t *base) - /// LDNF1H Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svint16_t svldnf1[_s16](svbool_t pg, const int16_t *base) + /// LDNF1H Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonFaulting(short* address) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svldnf1[_s32](svbool_t pg, const int32_t *base) - /// LDNF1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svint32_t svldnf1[_s32](svbool_t pg, const int32_t *base) + /// LDNF1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonFaulting(int* address) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svldnf1[_s64](svbool_t pg, const int64_t *base) - /// LDNF1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svldnf1[_s64](svbool_t pg, const int64_t *base) + /// LDNF1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonFaulting(long* address) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svldnf1[_s8](svbool_t pg, const int8_t *base) - /// LDNF1B Zresult.B, Pg/Z, [Xbase, #0, MUL VL] + /// svint8_t svldnf1[_s8](svbool_t pg, const int8_t *base) + /// LDNF1B Zresult.B, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonFaulting(sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svldnf1[_f32](svbool_t pg, const float32_t *base) - /// LDNF1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svfloat32_t svldnf1[_f32](svbool_t pg, const float32_t *base) + /// LDNF1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonFaulting(float* address) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svldnf1[_u16](svbool_t pg, const uint16_t *base) - /// LDNF1H Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svuint16_t svldnf1[_u16](svbool_t pg, const uint16_t *base) + /// LDNF1H Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonFaulting(ushort* address) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svldnf1[_u32](svbool_t pg, const uint32_t *base) - /// LDNF1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32_t svldnf1[_u32](svbool_t pg, const uint32_t *base) + /// LDNF1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonFaulting(uint* address) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svldnf1[_u64](svbool_t pg, const uint64_t *base) - /// LDNF1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svldnf1[_u64](svbool_t pg, const uint64_t *base) + /// LDNF1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonFaulting(ulong* address) { throw new PlatformNotSupportedException(); } @@ -5212,62 +5874,62 @@ internal Arm64() { } // Unextended load, non-temporal /// - /// svuint8_t svldnt1[_u8](svbool_t pg, const uint8_t *base) - /// LDNT1B Zresult.B, Pg/Z, [Xbase, #0, MUL VL] + /// svuint8_t svldnt1[_u8](svbool_t pg, const uint8_t *base) + /// LDNT1B Zresult.B, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonTemporal(Vector mask, byte* address) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svldnt1[_f64](svbool_t pg, const float64_t *base) - /// LDNT1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svfloat64_t svldnt1[_f64](svbool_t pg, const float64_t *base) + /// LDNT1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonTemporal(Vector mask, double* address) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svldnt1[_s16](svbool_t pg, const int16_t *base) - /// LDNT1H Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svint16_t svldnt1[_s16](svbool_t pg, const int16_t *base) + /// LDNT1H Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonTemporal(Vector mask, short* address) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svldnt1[_s32](svbool_t pg, const int32_t *base) - /// LDNT1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svint32_t svldnt1[_s32](svbool_t pg, const int32_t *base) + /// LDNT1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonTemporal(Vector mask, int* address) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svldnt1[_s64](svbool_t pg, const int64_t *base) - /// LDNT1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svldnt1[_s64](svbool_t pg, const int64_t *base) + /// LDNT1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonTemporal(Vector mask, long* address) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svldnt1[_s8](svbool_t pg, const int8_t *base) - /// LDNT1B Zresult.B, Pg/Z, [Xbase, #0, MUL VL] + /// svint8_t svldnt1[_s8](svbool_t pg, const int8_t *base) + /// LDNT1B Zresult.B, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonTemporal(Vector mask, sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svldnt1[_f32](svbool_t pg, const float32_t *base) - /// LDNT1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svfloat32_t svldnt1[_f32](svbool_t pg, const float32_t *base) + /// LDNT1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonTemporal(Vector mask, float* address) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svldnt1[_u16](svbool_t pg, const uint16_t *base) - /// LDNT1H Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svuint16_t svldnt1[_u16](svbool_t pg, const uint16_t *base) + /// LDNT1H Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonTemporal(Vector mask, ushort* address) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svldnt1[_u32](svbool_t pg, const uint32_t *base) - /// LDNT1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32_t svldnt1[_u32](svbool_t pg, const uint32_t *base) + /// LDNT1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonTemporal(Vector mask, uint* address) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svldnt1[_u64](svbool_t pg, const uint64_t *base) - /// LDNT1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svldnt1[_u64](svbool_t pg, const uint64_t *base) + /// LDNT1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonTemporal(Vector mask, ulong* address) { throw new PlatformNotSupportedException(); } @@ -5275,8 +5937,8 @@ internal Arm64() { } // Load 8-bit data and sign-extend, non-faulting /// - /// svint16_t svldnf1sb_s16(svbool_t pg, const int8_t *base) - /// LDNF1SB Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svint16_t svldnf1sb_s16(svbool_t pg, const int8_t *base) + /// LDNF1SB Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorSByteNonFaultingSignExtendToInt16(sbyte* address) { throw new PlatformNotSupportedException(); } @@ -5284,8 +5946,8 @@ internal Arm64() { } // Load 8-bit data and sign-extend, non-faulting /// - /// svint32_t svldnf1sb_s32(svbool_t pg, const int8_t *base) - /// LDNF1SB Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svint32_t svldnf1sb_s32(svbool_t pg, const int8_t *base) + /// LDNF1SB Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorSByteNonFaultingSignExtendToInt32(sbyte* address) { throw new PlatformNotSupportedException(); } @@ -5293,8 +5955,8 @@ internal Arm64() { } // Load 8-bit data and sign-extend, non-faulting /// - /// svint64_t svldnf1sb_s64(svbool_t pg, const int8_t *base) - /// LDNF1SB Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svldnf1sb_s64(svbool_t pg, const int8_t *base) + /// LDNF1SB Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorSByteNonFaultingSignExtendToInt64(sbyte* address) { throw new PlatformNotSupportedException(); } @@ -5302,8 +5964,8 @@ internal Arm64() { } // Load 8-bit data and sign-extend, non-faulting /// - /// svuint16_t svldnf1sb_u16(svbool_t pg, const int8_t *base) - /// LDNF1SB Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svuint16_t svldnf1sb_u16(svbool_t pg, const int8_t *base) + /// LDNF1SB Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorSByteNonFaultingSignExtendToUInt16(sbyte* address) { throw new PlatformNotSupportedException(); } @@ -5311,8 +5973,8 @@ internal Arm64() { } // Load 8-bit data and sign-extend, non-faulting /// - /// svuint32_t svldnf1sb_u32(svbool_t pg, const int8_t *base) - /// LDNF1SB Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32_t svldnf1sb_u32(svbool_t pg, const int8_t *base) + /// LDNF1SB Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorSByteNonFaultingSignExtendToUInt32(sbyte* address) { throw new PlatformNotSupportedException(); } @@ -5320,47 +5982,47 @@ internal Arm64() { } // Load 8-bit data and sign-extend, non-faulting /// - /// svuint64_t svldnf1sb_u64(svbool_t pg, const int8_t *base) - /// LDNF1SB Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svldnf1sb_u64(svbool_t pg, const int8_t *base) + /// LDNF1SB Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorSByteNonFaultingSignExtendToUInt64(sbyte* address) { throw new PlatformNotSupportedException(); } - /// Load 8-bit data and sign-extend, first-faulting + // Load 8-bit data and sign-extend, first-faulting /// - /// svint16_t svldff1sb_s16(svbool_t pg, const int8_t *base) - /// LDFF1SB Zresult.H, Pg/Z, [Xbase, XZR] + /// svint16_t svldff1sb_s16(svbool_t pg, const int8_t *base) + /// LDFF1SB Zresult.H, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svldff1sb_s32(svbool_t pg, const int8_t *base) - /// LDFF1SB Zresult.S, Pg/Z, [Xbase, XZR] + /// svint32_t svldff1sb_s32(svbool_t pg, const int8_t *base) + /// LDFF1SB Zresult.S, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svldff1sb_s64(svbool_t pg, const int8_t *base) - /// LDFF1SB Zresult.D, Pg/Z, [Xbase, XZR] + /// svint64_t svldff1sb_s64(svbool_t pg, const int8_t *base) + /// LDFF1SB Zresult.D, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svldff1sb_u16(svbool_t pg, const int8_t *base) - /// LDFF1SB Zresult.H, Pg/Z, [Xbase, XZR] + /// svuint16_t svldff1sb_u16(svbool_t pg, const int8_t *base) + /// LDFF1SB Zresult.H, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svldff1sb_u32(svbool_t pg, const int8_t *base) - /// LDFF1SB Zresult.S, Pg/Z, [Xbase, XZR] + /// svuint32_t svldff1sb_u32(svbool_t pg, const int8_t *base) + /// LDFF1SB Zresult.S, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svldff1sb_u64(svbool_t pg, const int8_t *base) - /// LDFF1SB Zresult.D, Pg/Z, [Xbase, XZR] + /// svuint64_t svldff1sb_u64(svbool_t pg, const int8_t *base) + /// LDFF1SB Zresult.D, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address) { throw new PlatformNotSupportedException(); } @@ -5368,8 +6030,8 @@ internal Arm64() { } // Load 8-bit data and sign-extend /// - /// svint16_t svld1sb_s16(svbool_t pg, const int8_t *base) - /// LD1SB Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svint16_t svld1sb_s16(svbool_t pg, const int8_t *base) + /// LD1SB Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorSByteSignExtendToInt16(Vector mask, sbyte* address) { throw new PlatformNotSupportedException(); } @@ -5377,8 +6039,8 @@ internal Arm64() { } // Load 8-bit data and sign-extend /// - /// svint32_t svld1sb_s32(svbool_t pg, const int8_t *base) - /// LD1SB Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svint32_t svld1sb_s32(svbool_t pg, const int8_t *base) + /// LD1SB Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorSByteSignExtendToInt32(Vector mask, sbyte* address) { throw new PlatformNotSupportedException(); } @@ -5386,8 +6048,8 @@ internal Arm64() { } // Load 8-bit data and sign-extend /// - /// svint64_t svld1sb_s64(svbool_t pg, const int8_t *base) - /// LD1SB Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svld1sb_s64(svbool_t pg, const int8_t *base) + /// LD1SB Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorSByteSignExtendToInt64(Vector mask, sbyte* address) { throw new PlatformNotSupportedException(); } @@ -5395,8 +6057,8 @@ internal Arm64() { } // Load 8-bit data and sign-extend /// - /// svuint16_t svld1sb_u16(svbool_t pg, const int8_t *base) - /// LD1SB Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svuint16_t svld1sb_u16(svbool_t pg, const int8_t *base) + /// LD1SB Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorSByteSignExtendToUInt16(Vector mask, sbyte* address) { throw new PlatformNotSupportedException(); } @@ -5404,8 +6066,8 @@ internal Arm64() { } // Load 8-bit data and sign-extend /// - /// svuint32_t svld1sb_u32(svbool_t pg, const int8_t *base) - /// LD1SB Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32_t svld1sb_u32(svbool_t pg, const int8_t *base) + /// LD1SB Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorSByteSignExtendToUInt32(Vector mask, sbyte* address) { throw new PlatformNotSupportedException(); } @@ -5413,8 +6075,8 @@ internal Arm64() { } // Load 8-bit data and sign-extend /// - /// svuint64_t svld1sb_u64(svbool_t pg, const int8_t *base) - /// LD1SB Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svld1sb_u64(svbool_t pg, const int8_t *base) + /// LD1SB Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorSByteSignExtendToUInt64(Vector mask, sbyte* address) { throw new PlatformNotSupportedException(); } @@ -5422,8 +6084,8 @@ internal Arm64() { } // Load 16-bit data and zero-extend, non-faulting /// - /// svint32_t svldnf1uh_s32(svbool_t pg, const uint16_t *base) - /// LDNF1H Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svint32_t svldnf1uh_s32(svbool_t pg, const uint16_t *base) + /// LDNF1H Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorUInt16NonFaultingZeroExtendToInt32(ushort* address) { throw new PlatformNotSupportedException(); } @@ -5431,8 +6093,8 @@ internal Arm64() { } // Load 16-bit data and zero-extend, non-faulting /// - /// svint64_t svldnf1uh_s64(svbool_t pg, const uint16_t *base) - /// LDNF1H Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svldnf1uh_s64(svbool_t pg, const uint16_t *base) + /// LDNF1H Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorUInt16NonFaultingZeroExtendToInt64(ushort* address) { throw new PlatformNotSupportedException(); } @@ -5440,8 +6102,8 @@ internal Arm64() { } // Load 16-bit data and zero-extend, non-faulting /// - /// svuint32_t svldnf1uh_u32(svbool_t pg, const uint16_t *base) - /// LDNF1H Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32_t svldnf1uh_u32(svbool_t pg, const uint16_t *base) + /// LDNF1H Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorUInt16NonFaultingZeroExtendToUInt32(ushort* address) { throw new PlatformNotSupportedException(); } @@ -5449,35 +6111,35 @@ internal Arm64() { } // Load 16-bit data and zero-extend, non-faulting /// - /// svuint64_t svldnf1uh_u64(svbool_t pg, const uint16_t *base) - /// LDNF1H Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svldnf1uh_u64(svbool_t pg, const uint16_t *base) + /// LDNF1H Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorUInt16NonFaultingZeroExtendToUInt64(ushort* address) { throw new PlatformNotSupportedException(); } - /// Load 16-bit data and zero-extend, first-faulting + // Load 16-bit data and zero-extend, first-faulting /// - /// svint32_t svldff1uh_s32(svbool_t pg, const uint16_t *base) - /// LDFF1H Zresult.S, Pg/Z, [Xbase, XZR, LSL #1] + /// svint32_t svldff1uh_s32(svbool_t pg, const uint16_t *base) + /// LDFF1H Zresult.S, Pg/Z, [Xbase, XZR, LSL #1] /// public static unsafe Vector LoadVectorUInt16ZeroExtendFirstFaulting(Vector mask, ushort* address) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svldff1uh_s64(svbool_t pg, const uint16_t *base) - /// LDFF1H Zresult.D, Pg/Z, [Xbase, XZR, LSL #1] + /// svint64_t svldff1uh_s64(svbool_t pg, const uint16_t *base) + /// LDFF1H Zresult.D, Pg/Z, [Xbase, XZR, LSL #1] /// public static unsafe Vector LoadVectorUInt16ZeroExtendFirstFaulting(Vector mask, ushort* address) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svldff1uh_u32(svbool_t pg, const uint16_t *base) - /// LDFF1H Zresult.S, Pg/Z, [Xbase, XZR, LSL #1] + /// svuint32_t svldff1uh_u32(svbool_t pg, const uint16_t *base) + /// LDFF1H Zresult.S, Pg/Z, [Xbase, XZR, LSL #1] /// public static unsafe Vector LoadVectorUInt16ZeroExtendFirstFaulting(Vector mask, ushort* address) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svldff1uh_u64(svbool_t pg, const uint16_t *base) - /// LDFF1H Zresult.D, Pg/Z, [Xbase, XZR, LSL #1] + /// svuint64_t svldff1uh_u64(svbool_t pg, const uint16_t *base) + /// LDFF1H Zresult.D, Pg/Z, [Xbase, XZR, LSL #1] /// public static unsafe Vector LoadVectorUInt16ZeroExtendFirstFaulting(Vector mask, ushort* address) { throw new PlatformNotSupportedException(); } @@ -5485,8 +6147,8 @@ internal Arm64() { } // Load 16-bit data and zero-extend /// - /// svint32_t svld1uh_s32(svbool_t pg, const uint16_t *base) - /// LD1H Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svint32_t svld1uh_s32(svbool_t pg, const uint16_t *base) + /// LD1H Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorUInt16ZeroExtendToInt32(Vector mask, ushort* address) { throw new PlatformNotSupportedException(); } @@ -5494,8 +6156,8 @@ internal Arm64() { } // Load 16-bit data and zero-extend /// - /// svint64_t svld1uh_s64(svbool_t pg, const uint16_t *base) - /// LD1H Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svld1uh_s64(svbool_t pg, const uint16_t *base) + /// LD1H Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorUInt16ZeroExtendToInt64(Vector mask, ushort* address) { throw new PlatformNotSupportedException(); } @@ -5503,8 +6165,8 @@ internal Arm64() { } // Load 16-bit data and zero-extend /// - /// svuint32_t svld1uh_u32(svbool_t pg, const uint16_t *base) - /// LD1H Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32_t svld1uh_u32(svbool_t pg, const uint16_t *base) + /// LD1H Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorUInt16ZeroExtendToUInt32(Vector mask, ushort* address) { throw new PlatformNotSupportedException(); } @@ -5512,8 +6174,8 @@ internal Arm64() { } // Load 16-bit data and zero-extend /// - /// svuint64_t svld1uh_u64(svbool_t pg, const uint16_t *base) - /// LD1H Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svld1uh_u64(svbool_t pg, const uint16_t *base) + /// LD1H Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorUInt16ZeroExtendToUInt64(Vector mask, ushort* address) { throw new PlatformNotSupportedException(); } @@ -5521,8 +6183,8 @@ internal Arm64() { } // Load 32-bit data and zero-extend, non-faulting /// - /// svint64_t svldnf1uw_s64(svbool_t pg, const uint32_t *base) - /// LDNF1W Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svldnf1uw_s64(svbool_t pg, const uint32_t *base) + /// LDNF1W Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorUInt32NonFaultingZeroExtendToInt64(uint* address) { throw new PlatformNotSupportedException(); } @@ -5530,23 +6192,23 @@ internal Arm64() { } // Load 32-bit data and zero-extend, non-faulting /// - /// svuint64_t svldnf1uw_u64(svbool_t pg, const uint32_t *base) - /// LDNF1W Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svldnf1uw_u64(svbool_t pg, const uint32_t *base) + /// LDNF1W Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorUInt32NonFaultingZeroExtendToUInt64(uint* address) { throw new PlatformNotSupportedException(); } - /// Load 32-bit data and zero-extend, first-faulting + // Load 32-bit data and zero-extend, first-faulting /// - /// svint64_t svldff1uw_s64(svbool_t pg, const uint32_t *base) - /// LDFF1W Zresult.D, Pg/Z, [Xbase, XZR, LSL #2] + /// svint64_t svldff1uw_s64(svbool_t pg, const uint32_t *base) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, XZR, LSL #2] /// public static unsafe Vector LoadVectorUInt32ZeroExtendFirstFaulting(Vector mask, uint* address) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svldff1uw_u64(svbool_t pg, const uint32_t *base) - /// LDFF1W Zresult.D, Pg/Z, [Xbase, XZR, LSL #2] + /// svuint64_t svldff1uw_u64(svbool_t pg, const uint32_t *base) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, XZR, LSL #2] /// public static unsafe Vector LoadVectorUInt32ZeroExtendFirstFaulting(Vector mask, uint* address) { throw new PlatformNotSupportedException(); } @@ -5554,8 +6216,8 @@ internal Arm64() { } // Load 32-bit data and zero-extend /// - /// svint64_t svld1uw_s64(svbool_t pg, const uint32_t *base) - /// LD1W Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svld1uw_s64(svbool_t pg, const uint32_t *base) + /// LD1W Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorUInt32ZeroExtendToInt64(Vector mask, uint* address) { throw new PlatformNotSupportedException(); } @@ -5563,8 +6225,8 @@ internal Arm64() { } // Load 32-bit data and zero-extend /// - /// svuint64_t svld1uw_u64(svbool_t pg, const uint32_t *base) - /// LD1W Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svld1uw_u64(svbool_t pg, const uint32_t *base) + /// LD1W Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorUInt32ZeroExtendToUInt64(Vector mask, uint* address) { throw new PlatformNotSupportedException(); } @@ -5572,62 +6234,62 @@ internal Arm64() { } // Load two-element tuples into two vectors /// - /// svuint8x2_t svld2[_u8](svbool_t pg, const uint8_t *base) - /// LD2B {Zresult0.B, Zresult1.B}, Pg/Z, [Xbase, #0, MUL VL] + /// svuint8x2_t svld2[_u8](svbool_t pg, const uint8_t *base) + /// LD2B {Zresult0.B, Zresult1.B}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector) Load2xVectorAndUnzip(Vector mask, byte* address) { throw new PlatformNotSupportedException(); } /// - /// svfloat64x2_t svld2[_f64](svbool_t pg, const float64_t *base) - /// LD2D {Zresult0.D, Zresult1.D}, Pg/Z, [Xbase, #0, MUL VL] + /// svfloat64x2_t svld2[_f64](svbool_t pg, const float64_t *base) + /// LD2D {Zresult0.D, Zresult1.D}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector) Load2xVectorAndUnzip(Vector mask, double* address) { throw new PlatformNotSupportedException(); } /// - /// svint16x2_t svld2[_s16](svbool_t pg, const int16_t *base) - /// LD2H {Zresult0.H, Zresult1.H}, Pg/Z, [Xbase, #0, MUL VL] + /// svint16x2_t svld2[_s16](svbool_t pg, const int16_t *base) + /// LD2H {Zresult0.H, Zresult1.H}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector) Load2xVectorAndUnzip(Vector mask, short* address) { throw new PlatformNotSupportedException(); } /// - /// svint32x2_t svld2[_s32](svbool_t pg, const int32_t *base) - /// LD2W {Zresult0.S, Zresult1.S}, Pg/Z, [Xbase, #0, MUL VL] + /// svint32x2_t svld2[_s32](svbool_t pg, const int32_t *base) + /// LD2W {Zresult0.S, Zresult1.S}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector) Load2xVectorAndUnzip(Vector mask, int* address) { throw new PlatformNotSupportedException(); } /// - /// svint64x2_t svld2[_s64](svbool_t pg, const int64_t *base) - /// LD2D {Zresult0.D, Zresult1.D}, Pg/Z, [Xbase, #0, MUL VL] + /// svint64x2_t svld2[_s64](svbool_t pg, const int64_t *base) + /// LD2D {Zresult0.D, Zresult1.D}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector) Load2xVectorAndUnzip(Vector mask, long* address) { throw new PlatformNotSupportedException(); } /// - /// svint8x2_t svld2[_s8](svbool_t pg, const int8_t *base) - /// LD2B {Zresult0.B, Zresult1.B}, Pg/Z, [Xbase, #0, MUL VL] + /// svint8x2_t svld2[_s8](svbool_t pg, const int8_t *base) + /// LD2B {Zresult0.B, Zresult1.B}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector) Load2xVectorAndUnzip(Vector mask, sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// svfloat32x2_t svld2[_f32](svbool_t pg, const float32_t *base) - /// LD2W {Zresult0.S, Zresult1.S}, Pg/Z, [Xbase, #0, MUL VL] + /// svfloat32x2_t svld2[_f32](svbool_t pg, const float32_t *base) + /// LD2W {Zresult0.S, Zresult1.S}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector) Load2xVectorAndUnzip(Vector mask, float* address) { throw new PlatformNotSupportedException(); } /// - /// svuint16x2_t svld2[_u16](svbool_t pg, const uint16_t *base) - /// LD2H {Zresult0.H, Zresult1.H}, Pg/Z, [Xbase, #0, MUL VL] + /// svuint16x2_t svld2[_u16](svbool_t pg, const uint16_t *base) + /// LD2H {Zresult0.H, Zresult1.H}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector) Load2xVectorAndUnzip(Vector mask, ushort* address) { throw new PlatformNotSupportedException(); } /// - /// svuint32x2_t svld2[_u32](svbool_t pg, const uint32_t *base) - /// LD2W {Zresult0.S, Zresult1.S}, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32x2_t svld2[_u32](svbool_t pg, const uint32_t *base) + /// LD2W {Zresult0.S, Zresult1.S}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector) Load2xVectorAndUnzip(Vector mask, uint* address) { throw new PlatformNotSupportedException(); } /// - /// svuint64x2_t svld2[_u64](svbool_t pg, const uint64_t *base) - /// LD2D {Zresult0.D, Zresult1.D}, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64x2_t svld2[_u64](svbool_t pg, const uint64_t *base) + /// LD2D {Zresult0.D, Zresult1.D}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector) Load2xVectorAndUnzip(Vector mask, ulong* address) { throw new PlatformNotSupportedException(); } @@ -5635,62 +6297,62 @@ internal Arm64() { } // Load three-element tuples into three vectors /// - /// svuint8x3_t svld3[_u8](svbool_t pg, const uint8_t *base) - /// LD3B {Zresult0.B - Zresult2.B}, Pg/Z, [Xbase, #0, MUL VL] + /// svuint8x3_t svld3[_u8](svbool_t pg, const uint8_t *base) + /// LD3B {Zresult0.B - Zresult2.B}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector) Load3xVectorAndUnzip(Vector mask, byte* address) { throw new PlatformNotSupportedException(); } /// - /// svfloat64x3_t svld3[_f64](svbool_t pg, const float64_t *base) - /// LD3D {Zresult0.D - Zresult2.D}, Pg/Z, [Xbase, #0, MUL VL] + /// svfloat64x3_t svld3[_f64](svbool_t pg, const float64_t *base) + /// LD3D {Zresult0.D - Zresult2.D}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector) Load3xVectorAndUnzip(Vector mask, double* address) { throw new PlatformNotSupportedException(); } /// - /// svint16x3_t svld3[_s16](svbool_t pg, const int16_t *base) - /// LD3H {Zresult0.H - Zresult2.H}, Pg/Z, [Xbase, #0, MUL VL] + /// svint16x3_t svld3[_s16](svbool_t pg, const int16_t *base) + /// LD3H {Zresult0.H - Zresult2.H}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector) Load3xVectorAndUnzip(Vector mask, short* address) { throw new PlatformNotSupportedException(); } /// - /// svint32x3_t svld3[_s32](svbool_t pg, const int32_t *base) - /// LD3W {Zresult0.S - Zresult2.S}, Pg/Z, [Xbase, #0, MUL VL] + /// svint32x3_t svld3[_s32](svbool_t pg, const int32_t *base) + /// LD3W {Zresult0.S - Zresult2.S}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector) Load3xVectorAndUnzip(Vector mask, int* address) { throw new PlatformNotSupportedException(); } /// - /// svint64x3_t svld3[_s64](svbool_t pg, const int64_t *base) - /// LD3D {Zresult0.D - Zresult2.D}, Pg/Z, [Xbase, #0, MUL VL] + /// svint64x3_t svld3[_s64](svbool_t pg, const int64_t *base) + /// LD3D {Zresult0.D - Zresult2.D}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector) Load3xVectorAndUnzip(Vector mask, long* address) { throw new PlatformNotSupportedException(); } /// - /// svint8x3_t svld3[_s8](svbool_t pg, const int8_t *base) - /// LD3B {Zresult0.B - Zresult2.B}, Pg/Z, [Xbase, #0, MUL VL] + /// svint8x3_t svld3[_s8](svbool_t pg, const int8_t *base) + /// LD3B {Zresult0.B - Zresult2.B}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector) Load3xVectorAndUnzip(Vector mask, sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// svfloat32x3_t svld3[_f32](svbool_t pg, const float32_t *base) - /// LD3W {Zresult0.S - Zresult2.S}, Pg/Z, [Xbase, #0, MUL VL] + /// svfloat32x3_t svld3[_f32](svbool_t pg, const float32_t *base) + /// LD3W {Zresult0.S - Zresult2.S}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector) Load3xVectorAndUnzip(Vector mask, float* address) { throw new PlatformNotSupportedException(); } /// - /// svuint16x3_t svld3[_u16](svbool_t pg, const uint16_t *base) - /// LD3H {Zresult0.H - Zresult2.H}, Pg/Z, [Xbase, #0, MUL VL] + /// svuint16x3_t svld3[_u16](svbool_t pg, const uint16_t *base) + /// LD3H {Zresult0.H - Zresult2.H}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector) Load3xVectorAndUnzip(Vector mask, ushort* address) { throw new PlatformNotSupportedException(); } /// - /// svuint32x3_t svld3[_u32](svbool_t pg, const uint32_t *base) - /// LD3W {Zresult0.S - Zresult2.S}, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32x3_t svld3[_u32](svbool_t pg, const uint32_t *base) + /// LD3W {Zresult0.S - Zresult2.S}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector) Load3xVectorAndUnzip(Vector mask, uint* address) { throw new PlatformNotSupportedException(); } /// - /// svuint64x3_t svld3[_u64](svbool_t pg, const uint64_t *base) - /// LD3D {Zresult0.D - Zresult2.D}, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64x3_t svld3[_u64](svbool_t pg, const uint64_t *base) + /// LD3D {Zresult0.D - Zresult2.D}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector) Load3xVectorAndUnzip(Vector mask, ulong* address) { throw new PlatformNotSupportedException(); } @@ -5698,62 +6360,62 @@ internal Arm64() { } // Load four-element tuples into four vectors /// - /// svuint8x4_t svld4[_u8](svbool_t pg, const uint8_t *base) - /// LD4B {Zresult0.B - Zresult3.B}, Pg/Z, [Xbase, #0, MUL VL] + /// svuint8x4_t svld4[_u8](svbool_t pg, const uint8_t *base) + /// LD4B {Zresult0.B - Zresult3.B}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector, Vector) Load4xVectorAndUnzip(Vector mask, byte* address) { throw new PlatformNotSupportedException(); } /// - /// svfloat64x4_t svld4[_f64](svbool_t pg, const float64_t *base) - /// LD4D {Zresult0.D - Zresult3.D}, Pg/Z, [Xbase, #0, MUL VL] + /// svfloat64x4_t svld4[_f64](svbool_t pg, const float64_t *base) + /// LD4D {Zresult0.D - Zresult3.D}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector, Vector) Load4xVectorAndUnzip(Vector mask, double* address) { throw new PlatformNotSupportedException(); } /// - /// svint16x4_t svld4[_s16](svbool_t pg, const int16_t *base) - /// LD4H {Zresult0.H - Zresult3.H}, Pg/Z, [Xbase, #0, MUL VL] + /// svint16x4_t svld4[_s16](svbool_t pg, const int16_t *base) + /// LD4H {Zresult0.H - Zresult3.H}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector, Vector) Load4xVectorAndUnzip(Vector mask, short* address) { throw new PlatformNotSupportedException(); } /// - /// svint32x4_t svld4[_s32](svbool_t pg, const int32_t *base) - /// LD4W {Zresult0.S - Zresult3.S}, Pg/Z, [Xbase, #0, MUL VL] + /// svint32x4_t svld4[_s32](svbool_t pg, const int32_t *base) + /// LD4W {Zresult0.S - Zresult3.S}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector, Vector) Load4xVectorAndUnzip(Vector mask, int* address) { throw new PlatformNotSupportedException(); } /// - /// svint64x4_t svld4[_s64](svbool_t pg, const int64_t *base) - /// LD4D {Zresult0.D - Zresult3.D}, Pg/Z, [Xbase, #0, MUL VL] + /// svint64x4_t svld4[_s64](svbool_t pg, const int64_t *base) + /// LD4D {Zresult0.D - Zresult3.D}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector, Vector) Load4xVectorAndUnzip(Vector mask, long* address) { throw new PlatformNotSupportedException(); } /// - /// svint8x4_t svld4[_s8](svbool_t pg, const int8_t *base) - /// LD4B {Zresult0.B - Zresult3.B}, Pg/Z, [Xbase, #0, MUL VL] + /// svint8x4_t svld4[_s8](svbool_t pg, const int8_t *base) + /// LD4B {Zresult0.B - Zresult3.B}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector, Vector) Load4xVectorAndUnzip(Vector mask, sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// svfloat32x4_t svld4[_f32](svbool_t pg, const float32_t *base) - /// LD4W {Zresult0.S - Zresult3.S}, Pg/Z, [Xbase, #0, MUL VL] + /// svfloat32x4_t svld4[_f32](svbool_t pg, const float32_t *base) + /// LD4W {Zresult0.S - Zresult3.S}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector, Vector) Load4xVectorAndUnzip(Vector mask, float* address) { throw new PlatformNotSupportedException(); } /// - /// svuint16x4_t svld4[_u16](svbool_t pg, const uint16_t *base) - /// LD4H {Zresult0.H - Zresult3.H}, Pg/Z, [Xbase, #0, MUL VL] + /// svuint16x4_t svld4[_u16](svbool_t pg, const uint16_t *base) + /// LD4H {Zresult0.H - Zresult3.H}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector, Vector) Load4xVectorAndUnzip(Vector mask, ushort* address) { throw new PlatformNotSupportedException(); } /// - /// svuint32x4_t svld4[_u32](svbool_t pg, const uint32_t *base) - /// LD4W {Zresult0.S - Zresult3.S}, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32x4_t svld4[_u32](svbool_t pg, const uint32_t *base) + /// LD4W {Zresult0.S - Zresult3.S}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector, Vector) Load4xVectorAndUnzip(Vector mask, uint* address) { throw new PlatformNotSupportedException(); } /// - /// svuint64x4_t svld4[_u64](svbool_t pg, const uint64_t *base) - /// LD4D {Zresult0.D - Zresult3.D}, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64x4_t svld4[_u64](svbool_t pg, const uint64_t *base) + /// LD4D {Zresult0.D - Zresult3.D}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector, Vector) Load4xVectorAndUnzip(Vector mask, ulong* address) { throw new PlatformNotSupportedException(); } @@ -5761,1010 +6423,1010 @@ internal Arm64() { } // Maximum /// - /// svuint8_t svmax[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svmax[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svmax[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// UMAX Ztied1.B, Pg/M, Ztied1.B, Zop2.B - /// UMAX Ztied2.B, Pg/M, Ztied2.B, Zop1.B + /// svuint8_t svmax[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svmax[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svmax[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// UMAX Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// UMAX Ztied2.B, Pg/M, Ztied2.B, Zop1.B /// - public static unsafe Vector Max(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Max(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svmax[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svmax[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svmax[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FMAX Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// FMAX Ztied2.D, Pg/M, Ztied2.D, Zop1.D + /// svfloat64_t svmax[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svmax[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svmax[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FMAX Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// FMAX Ztied2.D, Pg/M, Ztied2.D, Zop1.D /// - public static unsafe Vector Max(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Max(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svmax[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svmax[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svmax[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) - /// SMAX Ztied1.H, Pg/M, Ztied1.H, Zop2.H - /// SMAX Ztied2.H, Pg/M, Ztied2.H, Zop1.H + /// svint16_t svmax[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svmax[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svmax[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) + /// SMAX Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// SMAX Ztied2.H, Pg/M, Ztied2.H, Zop1.H /// - public static unsafe Vector Max(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Max(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svmax[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svmax[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svmax[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) - /// SMAX Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// SMAX Ztied2.S, Pg/M, Ztied2.S, Zop1.S + /// svint32_t svmax[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svmax[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svmax[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) + /// SMAX Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// SMAX Ztied2.S, Pg/M, Ztied2.S, Zop1.S /// - public static unsafe Vector Max(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Max(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svmax[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svmax[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svmax[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) - /// SMAX Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// SMAX Ztied2.D, Pg/M, Ztied2.D, Zop1.D + /// svint64_t svmax[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svmax[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svmax[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) + /// SMAX Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// SMAX Ztied2.D, Pg/M, Ztied2.D, Zop1.D /// - public static unsafe Vector Max(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Max(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svmax[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svmax[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svmax[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) - /// SMAX Ztied1.B, Pg/M, Ztied1.B, Zop2.B - /// SMAX Ztied2.B, Pg/M, Ztied2.B, Zop1.B + /// svint8_t svmax[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svmax[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svmax[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) + /// SMAX Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// SMAX Ztied2.B, Pg/M, Ztied2.B, Zop1.B /// - public static unsafe Vector Max(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Max(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svmax[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svmax[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svmax[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FMAX Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// FMAX Ztied2.S, Pg/M, Ztied2.S, Zop1.S + /// svfloat32_t svmax[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svmax[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svmax[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FMAX Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// FMAX Ztied2.S, Pg/M, Ztied2.S, Zop1.S /// - public static unsafe Vector Max(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Max(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svmax[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svmax[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svmax[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// UMAX Ztied1.H, Pg/M, Ztied1.H, Zop2.H - /// UMAX Ztied2.H, Pg/M, Ztied2.H, Zop1.H + /// svuint16_t svmax[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svmax[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svmax[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// UMAX Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// UMAX Ztied2.H, Pg/M, Ztied2.H, Zop1.H /// - public static unsafe Vector Max(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Max(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svmax[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svmax[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svmax[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// UMAX Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// UMAX Ztied2.S, Pg/M, Ztied2.S, Zop1.S + /// svuint32_t svmax[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svmax[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svmax[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// UMAX Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// UMAX Ztied2.S, Pg/M, Ztied2.S, Zop1.S /// - public static unsafe Vector Max(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Max(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svmax[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svmax[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svmax[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// UMAX Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// UMAX Ztied2.D, Pg/M, Ztied2.D, Zop1.D + /// svuint64_t svmax[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svmax[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svmax[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// UMAX Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// UMAX Ztied2.D, Pg/M, Ztied2.D, Zop1.D /// - public static unsafe Vector Max(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Max(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Maximum reduction to scalar /// - /// uint8_t svmaxv[_u8](svbool_t pg, svuint8_t op) - /// UMAXV Bresult, Pg, Zop.B + /// uint8_t svmaxv[_u8](svbool_t pg, svuint8_t op) + /// UMAXV Bresult, Pg, Zop.B /// - public static unsafe Vector MaxAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector MaxAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// float64_t svmaxv[_f64](svbool_t pg, svfloat64_t op) - /// FMAXV Dresult, Pg, Zop.D + /// float64_t svmaxv[_f64](svbool_t pg, svfloat64_t op) + /// FMAXV Dresult, Pg, Zop.D /// - public static unsafe Vector MaxAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector MaxAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// int16_t svmaxv[_s16](svbool_t pg, svint16_t op) - /// SMAXV Hresult, Pg, Zop.H + /// int16_t svmaxv[_s16](svbool_t pg, svint16_t op) + /// SMAXV Hresult, Pg, Zop.H /// - public static unsafe Vector MaxAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector MaxAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// int32_t svmaxv[_s32](svbool_t pg, svint32_t op) - /// SMAXV Sresult, Pg, Zop.S + /// int32_t svmaxv[_s32](svbool_t pg, svint32_t op) + /// SMAXV Sresult, Pg, Zop.S /// - public static unsafe Vector MaxAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector MaxAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// int64_t svmaxv[_s64](svbool_t pg, svint64_t op) - /// SMAXV Dresult, Pg, Zop.D + /// int64_t svmaxv[_s64](svbool_t pg, svint64_t op) + /// SMAXV Dresult, Pg, Zop.D /// - public static unsafe Vector MaxAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector MaxAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// int8_t svmaxv[_s8](svbool_t pg, svint8_t op) - /// SMAXV Bresult, Pg, Zop.B + /// int8_t svmaxv[_s8](svbool_t pg, svint8_t op) + /// SMAXV Bresult, Pg, Zop.B /// - public static unsafe Vector MaxAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector MaxAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// float32_t svmaxv[_f32](svbool_t pg, svfloat32_t op) - /// FMAXV Sresult, Pg, Zop.S + /// float32_t svmaxv[_f32](svbool_t pg, svfloat32_t op) + /// FMAXV Sresult, Pg, Zop.S /// - public static unsafe Vector MaxAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector MaxAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// uint16_t svmaxv[_u16](svbool_t pg, svuint16_t op) - /// UMAXV Hresult, Pg, Zop.H + /// uint16_t svmaxv[_u16](svbool_t pg, svuint16_t op) + /// UMAXV Hresult, Pg, Zop.H /// - public static unsafe Vector MaxAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector MaxAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// uint32_t svmaxv[_u32](svbool_t pg, svuint32_t op) - /// UMAXV Sresult, Pg, Zop.S + /// uint32_t svmaxv[_u32](svbool_t pg, svuint32_t op) + /// UMAXV Sresult, Pg, Zop.S /// - public static unsafe Vector MaxAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector MaxAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svmaxv[_u64](svbool_t pg, svuint64_t op) - /// UMAXV Dresult, Pg, Zop.D + /// uint64_t svmaxv[_u64](svbool_t pg, svuint64_t op) + /// UMAXV Dresult, Pg, Zop.D /// - public static unsafe Vector MaxAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector MaxAcross(Vector value) { throw new PlatformNotSupportedException(); } // Maximum number /// - /// svfloat64_t svmaxnm[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svmaxnm[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svmaxnm[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FMAXNM Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// FMAXNM Ztied2.D, Pg/M, Ztied2.D, Zop1.D + /// svfloat64_t svmaxnm[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svmaxnm[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svmaxnm[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FMAXNM Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// FMAXNM Ztied2.D, Pg/M, Ztied2.D, Zop1.D /// - public static unsafe Vector MaxNumber(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector MaxNumber(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svmaxnm[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svmaxnm[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svmaxnm[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FMAXNM Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// FMAXNM Ztied2.S, Pg/M, Ztied2.S, Zop1.S + /// svfloat32_t svmaxnm[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svmaxnm[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svmaxnm[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FMAXNM Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// FMAXNM Ztied2.S, Pg/M, Ztied2.S, Zop1.S /// - public static unsafe Vector MaxNumber(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector MaxNumber(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Maximum number reduction to scalar /// - /// float64_t svmaxnmv[_f64](svbool_t pg, svfloat64_t op) - /// FMAXNMV Dresult, Pg, Zop.D + /// float64_t svmaxnmv[_f64](svbool_t pg, svfloat64_t op) + /// FMAXNMV Dresult, Pg, Zop.D /// - public static unsafe Vector MaxNumberAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector MaxNumberAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// float32_t svmaxnmv[_f32](svbool_t pg, svfloat32_t op) - /// FMAXNMV Sresult, Pg, Zop.S + /// float32_t svmaxnmv[_f32](svbool_t pg, svfloat32_t op) + /// FMAXNMV Sresult, Pg, Zop.S /// - public static unsafe Vector MaxNumberAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector MaxNumberAcross(Vector value) { throw new PlatformNotSupportedException(); } // Minimum /// - /// svuint8_t svmin[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svmin[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svmin[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// UMIN Ztied1.B, Pg/M, Ztied1.B, Zop2.B - /// UMIN Ztied2.B, Pg/M, Ztied2.B, Zop1.B + /// svuint8_t svmin[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svmin[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svmin[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// UMIN Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// UMIN Ztied2.B, Pg/M, Ztied2.B, Zop1.B /// - public static unsafe Vector Min(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Min(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svmin[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svmin[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svmin[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FMIN Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// FMIN Ztied2.D, Pg/M, Ztied2.D, Zop1.D + /// svfloat64_t svmin[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svmin[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svmin[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FMIN Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// FMIN Ztied2.D, Pg/M, Ztied2.D, Zop1.D /// - public static unsafe Vector Min(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Min(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svmin[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svmin[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svmin[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) - /// SMIN Ztied1.H, Pg/M, Ztied1.H, Zop2.H - /// SMIN Ztied2.H, Pg/M, Ztied2.H, Zop1.H + /// svint16_t svmin[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svmin[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svmin[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) + /// SMIN Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// SMIN Ztied2.H, Pg/M, Ztied2.H, Zop1.H /// - public static unsafe Vector Min(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Min(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svmin[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svmin[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svmin[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) - /// SMIN Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// SMIN Ztied2.S, Pg/M, Ztied2.S, Zop1.S + /// svint32_t svmin[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svmin[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svmin[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) + /// SMIN Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// SMIN Ztied2.S, Pg/M, Ztied2.S, Zop1.S /// - public static unsafe Vector Min(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Min(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svmin[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svmin[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svmin[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) - /// SMIN Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// SMIN Ztied2.D, Pg/M, Ztied2.D, Zop1.D + /// svint64_t svmin[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svmin[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svmin[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) + /// SMIN Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// SMIN Ztied2.D, Pg/M, Ztied2.D, Zop1.D /// - public static unsafe Vector Min(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Min(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svmin[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svmin[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svmin[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) - /// SMIN Ztied1.B, Pg/M, Ztied1.B, Zop2.B - /// SMIN Ztied2.B, Pg/M, Ztied2.B, Zop1.B + /// svint8_t svmin[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svmin[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svmin[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) + /// SMIN Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// SMIN Ztied2.B, Pg/M, Ztied2.B, Zop1.B /// - public static unsafe Vector Min(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Min(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svmin[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svmin[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svmin[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FMIN Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// FMIN Ztied2.S, Pg/M, Ztied2.S, Zop1.S + /// svfloat32_t svmin[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svmin[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svmin[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FMIN Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// FMIN Ztied2.S, Pg/M, Ztied2.S, Zop1.S /// - public static unsafe Vector Min(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Min(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svmin[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svmin[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svmin[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// UMIN Ztied1.H, Pg/M, Ztied1.H, Zop2.H - /// UMIN Ztied2.H, Pg/M, Ztied2.H, Zop1.H + /// svuint16_t svmin[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svmin[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svmin[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// UMIN Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// UMIN Ztied2.H, Pg/M, Ztied2.H, Zop1.H /// - public static unsafe Vector Min(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Min(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svmin[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svmin[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svmin[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// UMIN Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// UMIN Ztied2.S, Pg/M, Ztied2.S, Zop1.S + /// svuint32_t svmin[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svmin[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svmin[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// UMIN Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// UMIN Ztied2.S, Pg/M, Ztied2.S, Zop1.S /// - public static unsafe Vector Min(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Min(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svmin[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svmin[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svmin[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// UMIN Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// UMIN Ztied2.D, Pg/M, Ztied2.D, Zop1.D + /// svuint64_t svmin[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svmin[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svmin[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// UMIN Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// UMIN Ztied2.D, Pg/M, Ztied2.D, Zop1.D /// - public static unsafe Vector Min(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Min(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Minimum reduction to scalar /// - /// uint8_t svminv[_u8](svbool_t pg, svuint8_t op) - /// UMINV Bresult, Pg, Zop.B + /// uint8_t svminv[_u8](svbool_t pg, svuint8_t op) + /// UMINV Bresult, Pg, Zop.B /// - public static unsafe Vector MinAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector MinAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// float64_t svminv[_f64](svbool_t pg, svfloat64_t op) - /// FMINV Dresult, Pg, Zop.D + /// float64_t svminv[_f64](svbool_t pg, svfloat64_t op) + /// FMINV Dresult, Pg, Zop.D /// - public static unsafe Vector MinAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector MinAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// int16_t svminv[_s16](svbool_t pg, svint16_t op) - /// SMINV Hresult, Pg, Zop.H + /// int16_t svminv[_s16](svbool_t pg, svint16_t op) + /// SMINV Hresult, Pg, Zop.H /// - public static unsafe Vector MinAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector MinAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// int32_t svminv[_s32](svbool_t pg, svint32_t op) - /// SMINV Sresult, Pg, Zop.S + /// int32_t svminv[_s32](svbool_t pg, svint32_t op) + /// SMINV Sresult, Pg, Zop.S /// - public static unsafe Vector MinAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector MinAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// int64_t svminv[_s64](svbool_t pg, svint64_t op) - /// SMINV Dresult, Pg, Zop.D + /// int64_t svminv[_s64](svbool_t pg, svint64_t op) + /// SMINV Dresult, Pg, Zop.D /// - public static unsafe Vector MinAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector MinAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// int8_t svminv[_s8](svbool_t pg, svint8_t op) - /// SMINV Bresult, Pg, Zop.B + /// int8_t svminv[_s8](svbool_t pg, svint8_t op) + /// SMINV Bresult, Pg, Zop.B /// - public static unsafe Vector MinAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector MinAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// float32_t svminv[_f32](svbool_t pg, svfloat32_t op) - /// FMINV Sresult, Pg, Zop.S + /// float32_t svminv[_f32](svbool_t pg, svfloat32_t op) + /// FMINV Sresult, Pg, Zop.S /// - public static unsafe Vector MinAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector MinAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// uint16_t svminv[_u16](svbool_t pg, svuint16_t op) - /// UMINV Hresult, Pg, Zop.H + /// uint16_t svminv[_u16](svbool_t pg, svuint16_t op) + /// UMINV Hresult, Pg, Zop.H /// - public static unsafe Vector MinAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector MinAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// uint32_t svminv[_u32](svbool_t pg, svuint32_t op) - /// UMINV Sresult, Pg, Zop.S + /// uint32_t svminv[_u32](svbool_t pg, svuint32_t op) + /// UMINV Sresult, Pg, Zop.S /// - public static unsafe Vector MinAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector MinAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svminv[_u64](svbool_t pg, svuint64_t op) - /// UMINV Dresult, Pg, Zop.D + /// uint64_t svminv[_u64](svbool_t pg, svuint64_t op) + /// UMINV Dresult, Pg, Zop.D /// - public static unsafe Vector MinAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector MinAcross(Vector value) { throw new PlatformNotSupportedException(); } // Minimum number /// - /// svfloat64_t svminnm[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svminnm[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svminnm[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FMINNM Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// FMINNM Ztied2.D, Pg/M, Ztied2.D, Zop1.D + /// svfloat64_t svminnm[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svminnm[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svminnm[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FMINNM Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// FMINNM Ztied2.D, Pg/M, Ztied2.D, Zop1.D /// - public static unsafe Vector MinNumber(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector MinNumber(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svminnm[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svminnm[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svminnm[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FMINNM Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// FMINNM Ztied2.S, Pg/M, Ztied2.S, Zop1.S + /// svfloat32_t svminnm[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svminnm[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svminnm[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FMINNM Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// FMINNM Ztied2.S, Pg/M, Ztied2.S, Zop1.S /// - public static unsafe Vector MinNumber(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector MinNumber(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Minimum number reduction to scalar /// - /// float64_t svminnmv[_f64](svbool_t pg, svfloat64_t op) - /// FMINNMV Dresult, Pg, Zop.D + /// float64_t svminnmv[_f64](svbool_t pg, svfloat64_t op) + /// FMINNMV Dresult, Pg, Zop.D /// - public static unsafe Vector MinNumberAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector MinNumberAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// float32_t svminnmv[_f32](svbool_t pg, svfloat32_t op) - /// FMINNMV Sresult, Pg, Zop.S + /// float32_t svminnmv[_f32](svbool_t pg, svfloat32_t op) + /// FMINNMV Sresult, Pg, Zop.S /// - public static unsafe Vector MinNumberAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector MinNumberAcross(Vector value) { throw new PlatformNotSupportedException(); } // Multiply /// - /// svuint8_t svmul[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svmul[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svmul[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// MUL Ztied1.B, Pg/M, Ztied1.B, Zop2.B - /// MUL Ztied2.B, Pg/M, Ztied2.B, Zop1.B - /// svuint8_t svmul[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svmul[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svmul[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svmul[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// MUL Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// MUL Ztied2.B, Pg/M, Ztied2.B, Zop1.B + /// svuint8_t svmul[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) /// - public static unsafe Vector Multiply(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Multiply(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svmul[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svmul[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svmul[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FMUL Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// FMUL Ztied2.D, Pg/M, Ztied2.D, Zop1.D - /// svfloat64_t svmul[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svmul[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svmul[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svmul[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FMUL Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// FMUL Ztied2.D, Pg/M, Ztied2.D, Zop1.D + /// svfloat64_t svmul[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) /// - public static unsafe Vector Multiply(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Multiply(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svmul[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svmul[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svmul[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) - /// MUL Ztied1.H, Pg/M, Ztied1.H, Zop2.H - /// MUL Ztied2.H, Pg/M, Ztied2.H, Zop1.H + /// svint16_t svmul[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svmul[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svmul[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) + /// MUL Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// MUL Ztied2.H, Pg/M, Ztied2.H, Zop1.H /// - public static unsafe Vector Multiply(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Multiply(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svmul[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svmul[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svmul[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) - /// MUL Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// MUL Ztied2.S, Pg/M, Ztied2.S, Zop1.S + /// svint32_t svmul[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svmul[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svmul[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) + /// MUL Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// MUL Ztied2.S, Pg/M, Ztied2.S, Zop1.S /// - public static unsafe Vector Multiply(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Multiply(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svmul[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svmul[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svmul[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) - /// MUL Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// MUL Ztied2.D, Pg/M, Ztied2.D, Zop1.D + /// svint64_t svmul[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svmul[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svmul[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) + /// MUL Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// MUL Ztied2.D, Pg/M, Ztied2.D, Zop1.D /// - public static unsafe Vector Multiply(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Multiply(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svmul[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svmul[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svmul[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) - /// MUL Ztied1.B, Pg/M, Ztied1.B, Zop2.B - /// MUL Ztied2.B, Pg/M, Ztied2.B, Zop1.B + /// svint8_t svmul[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svmul[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svmul[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) + /// MUL Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// MUL Ztied2.B, Pg/M, Ztied2.B, Zop1.B /// - public static unsafe Vector Multiply(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Multiply(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svmul[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svmul[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svmul[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FMUL Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// FMUL Ztied2.S, Pg/M, Ztied2.S, Zop1.S + /// svfloat32_t svmul[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svmul[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svmul[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FMUL Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// FMUL Ztied2.S, Pg/M, Ztied2.S, Zop1.S /// - public static unsafe Vector Multiply(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Multiply(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svmul[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svmul[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svmul[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// MUL Ztied1.H, Pg/M, Ztied1.H, Zop2.H - /// MUL Ztied2.H, Pg/M, Ztied2.H, Zop1.H + /// svuint16_t svmul[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svmul[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svmul[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// MUL Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// MUL Ztied2.H, Pg/M, Ztied2.H, Zop1.H /// - public static unsafe Vector Multiply(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Multiply(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svmul[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svmul[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svmul[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// MUL Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// MUL Ztied2.S, Pg/M, Ztied2.S, Zop1.S + /// svuint32_t svmul[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svmul[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svmul[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// MUL Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// MUL Ztied2.S, Pg/M, Ztied2.S, Zop1.S /// - public static unsafe Vector Multiply(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Multiply(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svmul[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svmul[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svmul[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// MUL Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// MUL Ztied2.D, Pg/M, Ztied2.D, Zop1.D + /// svuint64_t svmul[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svmul[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svmul[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// MUL Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// MUL Ztied2.D, Pg/M, Ztied2.D, Zop1.D /// - public static unsafe Vector Multiply(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Multiply(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Multiply-add, addend first /// - /// svuint8_t svmla[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2, svuint8_t op3) - /// svuint8_t svmla[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2, svuint8_t op3) - /// svuint8_t svmla[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2, svuint8_t op3) - /// MLA Ztied1.B, Pg/M, Zop2.B, Zop3.B + /// svuint8_t svmla[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2, svuint8_t op3) + /// svuint8_t svmla[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2, svuint8_t op3) + /// svuint8_t svmla[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2, svuint8_t op3) + /// MLA Ztied1.B, Pg/M, Zop2.B, Zop3.B /// - public static unsafe Vector MultiplyAdd(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector MultiplyAdd(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svmla[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2, svint16_t op3) - /// svint16_t svmla[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2, svint16_t op3) - /// svint16_t svmla[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2, svint16_t op3) - /// MLA Ztied1.H, Pg/M, Zop2.H, Zop3.H + /// svint16_t svmla[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2, svint16_t op3) + /// svint16_t svmla[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2, svint16_t op3) + /// svint16_t svmla[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2, svint16_t op3) + /// MLA Ztied1.H, Pg/M, Zop2.H, Zop3.H /// - public static unsafe Vector MultiplyAdd(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector MultiplyAdd(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svmla[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2, svint32_t op3) - /// svint32_t svmla[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2, svint32_t op3) - /// svint32_t svmla[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2, svint32_t op3) - /// MLA Ztied1.S, Pg/M, Zop2.S, Zop3.S + /// svint32_t svmla[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2, svint32_t op3) + /// svint32_t svmla[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2, svint32_t op3) + /// svint32_t svmla[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2, svint32_t op3) + /// MLA Ztied1.S, Pg/M, Zop2.S, Zop3.S /// - public static unsafe Vector MultiplyAdd(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector MultiplyAdd(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svmla[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2, svint64_t op3) - /// svint64_t svmla[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2, svint64_t op3) - /// svint64_t svmla[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2, svint64_t op3) - /// MLA Ztied1.D, Pg/M, Zop2.D, Zop3.D + /// svint64_t svmla[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2, svint64_t op3) + /// svint64_t svmla[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2, svint64_t op3) + /// svint64_t svmla[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2, svint64_t op3) + /// MLA Ztied1.D, Pg/M, Zop2.D, Zop3.D /// - public static unsafe Vector MultiplyAdd(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector MultiplyAdd(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svmla[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2, svint8_t op3) - /// svint8_t svmla[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2, svint8_t op3) - /// svint8_t svmla[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2, svint8_t op3) - /// MLA Ztied1.B, Pg/M, Zop2.B, Zop3.B + /// svint8_t svmla[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2, svint8_t op3) + /// svint8_t svmla[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2, svint8_t op3) + /// svint8_t svmla[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2, svint8_t op3) + /// MLA Ztied1.B, Pg/M, Zop2.B, Zop3.B /// - public static unsafe Vector MultiplyAdd(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector MultiplyAdd(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svmla[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2, svuint16_t op3) - /// svuint16_t svmla[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2, svuint16_t op3) - /// svuint16_t svmla[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2, svuint16_t op3) - /// MLA Ztied1.H, Pg/M, Zop2.H, Zop3.H + /// svuint16_t svmla[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2, svuint16_t op3) + /// svuint16_t svmla[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2, svuint16_t op3) + /// svuint16_t svmla[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2, svuint16_t op3) + /// MLA Ztied1.H, Pg/M, Zop2.H, Zop3.H /// - public static unsafe Vector MultiplyAdd(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector MultiplyAdd(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svmla[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2, svuint32_t op3) - /// svuint32_t svmla[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2, svuint32_t op3) - /// svuint32_t svmla[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2, svuint32_t op3) - /// MLA Ztied1.S, Pg/M, Zop2.S, Zop3.S + /// svuint32_t svmla[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2, svuint32_t op3) + /// svuint32_t svmla[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2, svuint32_t op3) + /// svuint32_t svmla[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2, svuint32_t op3) + /// MLA Ztied1.S, Pg/M, Zop2.S, Zop3.S /// - public static unsafe Vector MultiplyAdd(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector MultiplyAdd(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svmla[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2, svuint64_t op3) - /// svuint64_t svmla[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2, svuint64_t op3) - /// svuint64_t svmla[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2, svuint64_t op3) - /// MLA Ztied1.D, Pg/M, Zop2.D, Zop3.D + /// svuint64_t svmla[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2, svuint64_t op3) + /// svuint64_t svmla[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2, svuint64_t op3) + /// svuint64_t svmla[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2, svuint64_t op3) + /// MLA Ztied1.D, Pg/M, Zop2.D, Zop3.D /// - public static unsafe Vector MultiplyAdd(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector MultiplyAdd(Vector addend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Complex multiply-add with rotate /// - /// svfloat64_t svcmla[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3, uint64_t imm_rotation) - /// svfloat64_t svcmla[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3, uint64_t imm_rotation) - /// svfloat64_t svcmla[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3, uint64_t imm_rotation) - /// FCMLA Ztied1.D, Pg/M, Zop2.D, Zop3.D, #imm_rotation + /// svfloat64_t svcmla[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3, uint64_t imm_rotation) + /// svfloat64_t svcmla[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3, uint64_t imm_rotation) + /// svfloat64_t svcmla[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3, uint64_t imm_rotation) + /// FCMLA Ztied1.D, Pg/M, Zop2.D, Zop3.D, #imm_rotation /// - public static unsafe Vector MultiplyAddRotateComplex(Vector addend, Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(3))] byte rotation) { throw new PlatformNotSupportedException(); } + public static Vector MultiplyAddRotateComplex(Vector addend, Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(3))] byte rotation) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svcmla[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3, uint64_t imm_rotation) - /// svfloat32_t svcmla[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3, uint64_t imm_rotation) - /// svfloat32_t svcmla[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3, uint64_t imm_rotation) - /// FCMLA Ztied1.S, Pg/M, Zop2.S, Zop3.S, #imm_rotation + /// svfloat32_t svcmla[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3, uint64_t imm_rotation) + /// svfloat32_t svcmla[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3, uint64_t imm_rotation) + /// svfloat32_t svcmla[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3, uint64_t imm_rotation) + /// FCMLA Ztied1.S, Pg/M, Zop2.S, Zop3.S, #imm_rotation /// - public static unsafe Vector MultiplyAddRotateComplex(Vector addend, Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(3))] byte rotation) { throw new PlatformNotSupportedException(); } + public static Vector MultiplyAddRotateComplex(Vector addend, Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(3))] byte rotation) { throw new PlatformNotSupportedException(); } // Complex multiply-add with rotate /// - /// svfloat32_t svcmla_lane[_f32](svfloat32_t op1, svfloat32_t op2, svfloat32_t op3, uint64_t imm_index, uint64_t imm_rotation) - /// FCMLA Ztied1.S, Zop2.S, Zop3.S[imm_index], #imm_rotation + /// svfloat32_t svcmla_lane[_f32](svfloat32_t op1, svfloat32_t op2, svfloat32_t op3, uint64_t imm_index, uint64_t imm_rotation) + /// FCMLA Ztied1.S, Zop2.S, Zop3.S[imm_index], #imm_rotation /// - public static unsafe Vector MultiplyAddRotateComplexBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(1))] byte rightIndex, [ConstantExpected(Min = 0, Max = (byte)(3))] byte rotation) { throw new PlatformNotSupportedException(); } + public static Vector MultiplyAddRotateComplexBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(1))] byte rightIndex, [ConstantExpected(Min = 0, Max = (byte)(3))] byte rotation) { throw new PlatformNotSupportedException(); } // Multiply /// - /// svfloat64_t svmul_lane[_f64](svfloat64_t op1, svfloat64_t op2, uint64_t imm_index) - /// FMUL Zresult.D, Zop1.D, Zop2.D[imm_index] + /// svfloat64_t svmul_lane[_f64](svfloat64_t op1, svfloat64_t op2, uint64_t imm_index) + /// FMUL Zresult.D, Zop1.D, Zop2.D[imm_index] /// - public static unsafe Vector MultiplyBySelectedScalar(Vector left, Vector right, [ConstantExpected] byte rightIndex) { throw new PlatformNotSupportedException(); } + public static Vector MultiplyBySelectedScalar(Vector left, Vector right, [ConstantExpected] byte rightIndex) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svmul_lane[_f32](svfloat32_t op1, svfloat32_t op2, uint64_t imm_index) - /// FMUL Zresult.S, Zop1.S, Zop2.S[imm_index] + /// svfloat32_t svmul_lane[_f32](svfloat32_t op1, svfloat32_t op2, uint64_t imm_index) + /// FMUL Zresult.S, Zop1.S, Zop2.S[imm_index] /// - public static unsafe Vector MultiplyBySelectedScalar(Vector left, Vector right, [ConstantExpected] byte rightIndex) { throw new PlatformNotSupportedException(); } + public static Vector MultiplyBySelectedScalar(Vector left, Vector right, [ConstantExpected] byte rightIndex) { throw new PlatformNotSupportedException(); } // Multiply extended (∞×0=2) /// - /// svfloat64_t svmulx[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svmulx[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svmulx[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FMULX Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svfloat64_t svmulx[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svmulx[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svmulx[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FMULX Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector MultiplyExtended(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector MultiplyExtended(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svmulx[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svmulx[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svmulx[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FMULX Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svfloat32_t svmulx[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svmulx[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svmulx[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FMULX Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector MultiplyExtended(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector MultiplyExtended(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Multiply-subtract, minuend first /// - /// svuint8_t svmls[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2, svuint8_t op3) - /// svuint8_t svmls[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2, svuint8_t op3) - /// svuint8_t svmls[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2, svuint8_t op3) - /// MLS Ztied1.B, Pg/M, Zop2.B, Zop3.B + /// svuint8_t svmls[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2, svuint8_t op3) + /// svuint8_t svmls[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2, svuint8_t op3) + /// svuint8_t svmls[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2, svuint8_t op3) + /// MLS Ztied1.B, Pg/M, Zop2.B, Zop3.B /// - public static unsafe Vector MultiplySubtract(Vector minuend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector MultiplySubtract(Vector minuend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svmls[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2, svint16_t op3) - /// svint16_t svmls[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2, svint16_t op3) - /// svint16_t svmls[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2, svint16_t op3) - /// MLS Ztied1.H, Pg/M, Zop2.H, Zop3.H + /// svint16_t svmls[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2, svint16_t op3) + /// svint16_t svmls[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2, svint16_t op3) + /// svint16_t svmls[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2, svint16_t op3) + /// MLS Ztied1.H, Pg/M, Zop2.H, Zop3.H /// - public static unsafe Vector MultiplySubtract(Vector minuend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector MultiplySubtract(Vector minuend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svmls[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2, svint32_t op3) - /// svint32_t svmls[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2, svint32_t op3) - /// svint32_t svmls[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2, svint32_t op3) - /// MLS Ztied1.S, Pg/M, Zop2.S, Zop3.S + /// svint32_t svmls[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2, svint32_t op3) + /// svint32_t svmls[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2, svint32_t op3) + /// svint32_t svmls[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2, svint32_t op3) + /// MLS Ztied1.S, Pg/M, Zop2.S, Zop3.S /// - public static unsafe Vector MultiplySubtract(Vector minuend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector MultiplySubtract(Vector minuend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svmls[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2, svint64_t op3) - /// svint64_t svmls[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2, svint64_t op3) - /// svint64_t svmls[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2, svint64_t op3) - /// MLS Ztied1.D, Pg/M, Zop2.D, Zop3.D + /// svint64_t svmls[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2, svint64_t op3) + /// svint64_t svmls[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2, svint64_t op3) + /// svint64_t svmls[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2, svint64_t op3) + /// MLS Ztied1.D, Pg/M, Zop2.D, Zop3.D /// - public static unsafe Vector MultiplySubtract(Vector minuend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector MultiplySubtract(Vector minuend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svmls[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2, svint8_t op3) - /// svint8_t svmls[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2, svint8_t op3) - /// svint8_t svmls[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2, svint8_t op3) - /// MLS Ztied1.B, Pg/M, Zop2.B, Zop3.B + /// svint8_t svmls[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2, svint8_t op3) + /// svint8_t svmls[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2, svint8_t op3) + /// svint8_t svmls[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2, svint8_t op3) + /// MLS Ztied1.B, Pg/M, Zop2.B, Zop3.B /// - public static unsafe Vector MultiplySubtract(Vector minuend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector MultiplySubtract(Vector minuend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svmls[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2, svuint16_t op3) - /// svuint16_t svmls[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2, svuint16_t op3) - /// svuint16_t svmls[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2, svuint16_t op3) - /// MLS Ztied1.H, Pg/M, Zop2.H, Zop3.H + /// svuint16_t svmls[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2, svuint16_t op3) + /// svuint16_t svmls[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2, svuint16_t op3) + /// svuint16_t svmls[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2, svuint16_t op3) + /// MLS Ztied1.H, Pg/M, Zop2.H, Zop3.H /// - public static unsafe Vector MultiplySubtract(Vector minuend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector MultiplySubtract(Vector minuend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svmls[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2, svuint32_t op3) - /// svuint32_t svmls[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2, svuint32_t op3) - /// svuint32_t svmls[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2, svuint32_t op3) - /// MLS Ztied1.S, Pg/M, Zop2.S, Zop3.S + /// svuint32_t svmls[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2, svuint32_t op3) + /// svuint32_t svmls[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2, svuint32_t op3) + /// svuint32_t svmls[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2, svuint32_t op3) + /// MLS Ztied1.S, Pg/M, Zop2.S, Zop3.S /// - public static unsafe Vector MultiplySubtract(Vector minuend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector MultiplySubtract(Vector minuend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svmls[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2, svuint64_t op3) - /// svuint64_t svmls[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2, svuint64_t op3) - /// svuint64_t svmls[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2, svuint64_t op3) - /// MLS Ztied1.D, Pg/M, Zop2.D, Zop3.D + /// svuint64_t svmls[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2, svuint64_t op3) + /// svuint64_t svmls[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2, svuint64_t op3) + /// svuint64_t svmls[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2, svuint64_t op3) + /// MLS Ztied1.D, Pg/M, Zop2.D, Zop3.D /// - public static unsafe Vector MultiplySubtract(Vector minuend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector MultiplySubtract(Vector minuend, Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Negate /// - /// svfloat64_t svneg[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) - /// svfloat64_t svneg[_f64]_x(svbool_t pg, svfloat64_t op) - /// svfloat64_t svneg[_f64]_z(svbool_t pg, svfloat64_t op) - /// FNEG Ztied.D, Pg/M, Zop.D + /// svfloat64_t svneg[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) + /// svfloat64_t svneg[_f64]_x(svbool_t pg, svfloat64_t op) + /// svfloat64_t svneg[_f64]_z(svbool_t pg, svfloat64_t op) + /// FNEG Ztied.D, Pg/M, Zop.D /// - public static unsafe Vector Negate(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Negate(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svneg[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) - /// svint16_t svneg[_s16]_x(svbool_t pg, svint16_t op) - /// svint16_t svneg[_s16]_z(svbool_t pg, svint16_t op) - /// NEG Ztied.H, Pg/M, Zop.H + /// svint16_t svneg[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) + /// svint16_t svneg[_s16]_x(svbool_t pg, svint16_t op) + /// svint16_t svneg[_s16]_z(svbool_t pg, svint16_t op) + /// NEG Ztied.H, Pg/M, Zop.H /// - public static unsafe Vector Negate(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Negate(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svneg[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) - /// svint32_t svneg[_s32]_x(svbool_t pg, svint32_t op) - /// svint32_t svneg[_s32]_z(svbool_t pg, svint32_t op) - /// NEG Ztied.S, Pg/M, Zop.S + /// svint32_t svneg[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) + /// svint32_t svneg[_s32]_x(svbool_t pg, svint32_t op) + /// svint32_t svneg[_s32]_z(svbool_t pg, svint32_t op) + /// NEG Ztied.S, Pg/M, Zop.S /// - public static unsafe Vector Negate(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Negate(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svneg[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) - /// svint64_t svneg[_s64]_x(svbool_t pg, svint64_t op) - /// svint64_t svneg[_s64]_z(svbool_t pg, svint64_t op) - /// NEG Ztied.D, Pg/M, Zop.D + /// svint64_t svneg[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) + /// svint64_t svneg[_s64]_x(svbool_t pg, svint64_t op) + /// svint64_t svneg[_s64]_z(svbool_t pg, svint64_t op) + /// NEG Ztied.D, Pg/M, Zop.D /// - public static unsafe Vector Negate(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Negate(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svneg[_s8]_m(svint8_t inactive, svbool_t pg, svint8_t op) - /// svint8_t svneg[_s8]_x(svbool_t pg, svint8_t op) - /// svint8_t svneg[_s8]_z(svbool_t pg, svint8_t op) - /// NEG Ztied.B, Pg/M, Zop.B + /// svint8_t svneg[_s8]_m(svint8_t inactive, svbool_t pg, svint8_t op) + /// svint8_t svneg[_s8]_x(svbool_t pg, svint8_t op) + /// svint8_t svneg[_s8]_z(svbool_t pg, svint8_t op) + /// NEG Ztied.B, Pg/M, Zop.B /// - public static unsafe Vector Negate(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Negate(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svneg[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) - /// svfloat32_t svneg[_f32]_x(svbool_t pg, svfloat32_t op) - /// svfloat32_t svneg[_f32]_z(svbool_t pg, svfloat32_t op) - /// FNEG Ztied.S, Pg/M, Zop.S + /// svfloat32_t svneg[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) + /// svfloat32_t svneg[_f32]_x(svbool_t pg, svfloat32_t op) + /// svfloat32_t svneg[_f32]_z(svbool_t pg, svfloat32_t op) + /// FNEG Ztied.S, Pg/M, Zop.S /// - public static unsafe Vector Negate(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Negate(Vector value) { throw new PlatformNotSupportedException(); } // Bitwise invert /// - /// svuint8_t svnot[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) - /// svuint8_t svnot[_u8]_x(svbool_t pg, svuint8_t op) - /// svuint8_t svnot[_u8]_z(svbool_t pg, svuint8_t op) - /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) - /// NOT Zresult.B, Pg/M, Zop.B + /// svuint8_t svnot[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) + /// svuint8_t svnot[_u8]_x(svbool_t pg, svuint8_t op) + /// svuint8_t svnot[_u8]_z(svbool_t pg, svuint8_t op) + /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) + /// NOT Zresult.B, Pg/M, Zop.B /// - public static unsafe Vector Not(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Not(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svnot[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) - /// svint16_t svnot[_s16]_x(svbool_t pg, svint16_t op) - /// svint16_t svnot[_s16]_z(svbool_t pg, svint16_t op) - /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) - /// NOT Zresult.H, Pg/M, Zop.H + /// svint16_t svnot[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) + /// svint16_t svnot[_s16]_x(svbool_t pg, svint16_t op) + /// svint16_t svnot[_s16]_z(svbool_t pg, svint16_t op) + /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) + /// NOT Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector Not(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Not(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svnot[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) - /// svint32_t svnot[_s32]_x(svbool_t pg, svint32_t op) - /// svint32_t svnot[_s32]_z(svbool_t pg, svint32_t op) - /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) - /// NOT Zresult.S, Pg/M, Zop.S + /// svint32_t svnot[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) + /// svint32_t svnot[_s32]_x(svbool_t pg, svint32_t op) + /// svint32_t svnot[_s32]_z(svbool_t pg, svint32_t op) + /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) + /// NOT Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector Not(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Not(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svnot[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) - /// svint64_t svnot[_s64]_x(svbool_t pg, svint64_t op) - /// svint64_t svnot[_s64]_z(svbool_t pg, svint64_t op) - /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) - /// NOT Zresult.D, Pg/M, Zop.D + /// svint64_t svnot[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) + /// svint64_t svnot[_s64]_x(svbool_t pg, svint64_t op) + /// svint64_t svnot[_s64]_z(svbool_t pg, svint64_t op) + /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) + /// NOT Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector Not(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Not(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svnot[_s8]_m(svint8_t inactive, svbool_t pg, svint8_t op) - /// svint8_t svnot[_s8]_x(svbool_t pg, svint8_t op) - /// svint8_t svnot[_s8]_z(svbool_t pg, svint8_t op) - /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) - /// NOT Zresult.B, Pg/M, Zop.B + /// svint8_t svnot[_s8]_m(svint8_t inactive, svbool_t pg, svint8_t op) + /// svint8_t svnot[_s8]_x(svbool_t pg, svint8_t op) + /// svint8_t svnot[_s8]_z(svbool_t pg, svint8_t op) + /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) + /// NOT Zresult.B, Pg/M, Zop.B /// - public static unsafe Vector Not(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Not(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svnot[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) - /// svuint16_t svnot[_u16]_x(svbool_t pg, svuint16_t op) - /// svuint16_t svnot[_u16]_z(svbool_t pg, svuint16_t op) - /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) - /// NOT Zresult.H, Pg/M, Zop.H + /// svuint16_t svnot[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) + /// svuint16_t svnot[_u16]_x(svbool_t pg, svuint16_t op) + /// svuint16_t svnot[_u16]_z(svbool_t pg, svuint16_t op) + /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) + /// NOT Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector Not(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Not(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svnot[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) - /// svuint32_t svnot[_u32]_x(svbool_t pg, svuint32_t op) - /// svuint32_t svnot[_u32]_z(svbool_t pg, svuint32_t op) - /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) - /// NOT Zresult.S, Pg/M, Zop.S + /// svuint32_t svnot[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) + /// svuint32_t svnot[_u32]_x(svbool_t pg, svuint32_t op) + /// svuint32_t svnot[_u32]_z(svbool_t pg, svuint32_t op) + /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) + /// NOT Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector Not(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Not(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svnot[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) - /// svuint64_t svnot[_u64]_x(svbool_t pg, svuint64_t op) - /// svuint64_t svnot[_u64]_z(svbool_t pg, svuint64_t op) - /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) - /// NOT Zresult.D, Pg/M, Zop.D + /// svuint64_t svnot[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) + /// svuint64_t svnot[_u64]_x(svbool_t pg, svuint64_t op) + /// svuint64_t svnot[_u64]_z(svbool_t pg, svuint64_t op) + /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) + /// NOT Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector Not(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Not(Vector value) { throw new PlatformNotSupportedException(); } // Bitwise inclusive OR /// - /// svuint8_t svorr[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svorr[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svorr[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// ORR Zresult.D, Zop1.D, Zop2.D + /// svuint8_t svorr[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svorr[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svorr[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// ORR Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector Or(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Or(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svorr[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svorr[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svorr[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) - /// ORR Zresult.D, Zop1.D, Zop2.D + /// svint16_t svorr[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svorr[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svorr[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) + /// ORR Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector Or(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Or(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svorr[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svorr[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svorr[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) - /// ORR Zresult.D, Zop1.D, Zop2.D + /// svint32_t svorr[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svorr[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svorr[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) + /// ORR Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector Or(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Or(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svorr[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svorr[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svorr[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) - /// ORR Zresult.D, Zop1.D, Zop2.D + /// svint64_t svorr[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svorr[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svorr[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) + /// ORR Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector Or(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Or(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svorr[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svorr[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svorr[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) - /// ORR Zresult.D, Zop1.D, Zop2.D + /// svint8_t svorr[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svorr[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svorr[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) + /// ORR Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector Or(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Or(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svorr[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svorr[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svorr[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// ORR Zresult.D, Zop1.D, Zop2.D + /// svuint16_t svorr[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svorr[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svorr[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// ORR Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector Or(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Or(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svorr[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svorr[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svorr[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// ORR Zresult.D, Zop1.D, Zop2.D + /// svuint32_t svorr[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svorr[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svorr[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// ORR Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector Or(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Or(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svorr[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svorr[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svorr[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// ORR Zresult.D, Zop1.D, Zop2.D + /// svuint64_t svorr[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svorr[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svorr[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// ORR Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector Or(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Or(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Bitwise inclusive OR reduction to scalar /// - /// uint8_t svorv[_u8](svbool_t pg, svuint8_t op) - /// ORV Bresult, Pg, Zop.B + /// uint8_t svorv[_u8](svbool_t pg, svuint8_t op) + /// ORV Bresult, Pg, Zop.B /// - public static unsafe Vector OrAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector OrAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// int16_t svorv[_s16](svbool_t pg, svint16_t op) - /// ORV Hresult, Pg, Zop.H + /// int16_t svorv[_s16](svbool_t pg, svint16_t op) + /// ORV Hresult, Pg, Zop.H /// - public static unsafe Vector OrAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector OrAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// int32_t svorv[_s32](svbool_t pg, svint32_t op) - /// ORV Sresult, Pg, Zop.S + /// int32_t svorv[_s32](svbool_t pg, svint32_t op) + /// ORV Sresult, Pg, Zop.S /// - public static unsafe Vector OrAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector OrAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// int64_t svorv[_s64](svbool_t pg, svint64_t op) - /// ORV Dresult, Pg, Zop.D + /// int64_t svorv[_s64](svbool_t pg, svint64_t op) + /// ORV Dresult, Pg, Zop.D /// - public static unsafe Vector OrAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector OrAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// int8_t svorv[_s8](svbool_t pg, svint8_t op) - /// ORV Bresult, Pg, Zop.B + /// int8_t svorv[_s8](svbool_t pg, svint8_t op) + /// ORV Bresult, Pg, Zop.B /// - public static unsafe Vector OrAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector OrAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// uint16_t svorv[_u16](svbool_t pg, svuint16_t op) - /// ORV Hresult, Pg, Zop.H + /// uint16_t svorv[_u16](svbool_t pg, svuint16_t op) + /// ORV Hresult, Pg, Zop.H /// - public static unsafe Vector OrAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector OrAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// uint32_t svorv[_u32](svbool_t pg, svuint32_t op) - /// ORV Sresult, Pg, Zop.S + /// uint32_t svorv[_u32](svbool_t pg, svuint32_t op) + /// ORV Sresult, Pg, Zop.S /// - public static unsafe Vector OrAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector OrAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svorv[_u64](svbool_t pg, svuint64_t op) - /// ORV Dresult, Pg, Zop.D + /// uint64_t svorv[_u64](svbool_t pg, svuint64_t op) + /// ORV Dresult, Pg, Zop.D /// - public static unsafe Vector OrAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector OrAcross(Vector value) { throw new PlatformNotSupportedException(); } // Count nonzero bits /// - /// svuint8_t svcnt[_s8]_m(svuint8_t inactive, svbool_t pg, svint8_t op) - /// svuint8_t svcnt[_s8]_x(svbool_t pg, svint8_t op) - /// svuint8_t svcnt[_s8]_z(svbool_t pg, svint8_t op) - /// CNT Zresult.B, Pg/M, Zop.B + /// svuint8_t svcnt[_s8]_m(svuint8_t inactive, svbool_t pg, svint8_t op) + /// svuint8_t svcnt[_s8]_x(svbool_t pg, svint8_t op) + /// svuint8_t svcnt[_s8]_z(svbool_t pg, svint8_t op) + /// CNT Zresult.B, Pg/M, Zop.B /// - public static unsafe Vector PopCount(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector PopCount(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint8_t svcnt[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) - /// svuint8_t svcnt[_u8]_x(svbool_t pg, svuint8_t op) - /// svuint8_t svcnt[_u8]_z(svbool_t pg, svuint8_t op) - /// CNT Zresult.B, Pg/M, Zop.B + /// svuint8_t svcnt[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) + /// svuint8_t svcnt[_u8]_x(svbool_t pg, svuint8_t op) + /// svuint8_t svcnt[_u8]_z(svbool_t pg, svuint8_t op) + /// CNT Zresult.B, Pg/M, Zop.B /// - public static unsafe Vector PopCount(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector PopCount(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svcnt[_s16]_m(svuint16_t inactive, svbool_t pg, svint16_t op) - /// svuint16_t svcnt[_s16]_x(svbool_t pg, svint16_t op) - /// svuint16_t svcnt[_s16]_z(svbool_t pg, svint16_t op) - /// CNT Zresult.H, Pg/M, Zop.H + /// svuint16_t svcnt[_s16]_m(svuint16_t inactive, svbool_t pg, svint16_t op) + /// svuint16_t svcnt[_s16]_x(svbool_t pg, svint16_t op) + /// svuint16_t svcnt[_s16]_z(svbool_t pg, svint16_t op) + /// CNT Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector PopCount(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector PopCount(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svcnt[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) - /// svuint16_t svcnt[_u16]_x(svbool_t pg, svuint16_t op) - /// svuint16_t svcnt[_u16]_z(svbool_t pg, svuint16_t op) - /// CNT Zresult.H, Pg/M, Zop.H + /// svuint16_t svcnt[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) + /// svuint16_t svcnt[_u16]_x(svbool_t pg, svuint16_t op) + /// svuint16_t svcnt[_u16]_z(svbool_t pg, svuint16_t op) + /// CNT Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector PopCount(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector PopCount(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svcnt[_s32]_m(svuint32_t inactive, svbool_t pg, svint32_t op) - /// svuint32_t svcnt[_s32]_x(svbool_t pg, svint32_t op) - /// svuint32_t svcnt[_s32]_z(svbool_t pg, svint32_t op) - /// CNT Zresult.S, Pg/M, Zop.S + /// svuint32_t svcnt[_s32]_m(svuint32_t inactive, svbool_t pg, svint32_t op) + /// svuint32_t svcnt[_s32]_x(svbool_t pg, svint32_t op) + /// svuint32_t svcnt[_s32]_z(svbool_t pg, svint32_t op) + /// CNT Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector PopCount(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector PopCount(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svcnt[_f32]_m(svuint32_t inactive, svbool_t pg, svfloat32_t op) - /// svuint32_t svcnt[_f32]_x(svbool_t pg, svfloat32_t op) - /// svuint32_t svcnt[_f32]_z(svbool_t pg, svfloat32_t op) - /// CNT Zresult.S, Pg/M, Zop.S + /// svuint32_t svcnt[_f32]_m(svuint32_t inactive, svbool_t pg, svfloat32_t op) + /// svuint32_t svcnt[_f32]_x(svbool_t pg, svfloat32_t op) + /// svuint32_t svcnt[_f32]_z(svbool_t pg, svfloat32_t op) + /// CNT Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector PopCount(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector PopCount(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svcnt[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) - /// svuint32_t svcnt[_u32]_x(svbool_t pg, svuint32_t op) - /// svuint32_t svcnt[_u32]_z(svbool_t pg, svuint32_t op) - /// CNT Zresult.S, Pg/M, Zop.S + /// svuint32_t svcnt[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) + /// svuint32_t svcnt[_u32]_x(svbool_t pg, svuint32_t op) + /// svuint32_t svcnt[_u32]_z(svbool_t pg, svuint32_t op) + /// CNT Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector PopCount(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector PopCount(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svcnt[_f64]_m(svuint64_t inactive, svbool_t pg, svfloat64_t op) - /// svuint64_t svcnt[_f64]_x(svbool_t pg, svfloat64_t op) - /// svuint64_t svcnt[_f64]_z(svbool_t pg, svfloat64_t op) - /// CNT Zresult.D, Pg/M, Zop.D + /// svuint64_t svcnt[_f64]_m(svuint64_t inactive, svbool_t pg, svfloat64_t op) + /// svuint64_t svcnt[_f64]_x(svbool_t pg, svfloat64_t op) + /// svuint64_t svcnt[_f64]_z(svbool_t pg, svfloat64_t op) + /// CNT Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector PopCount(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector PopCount(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svcnt[_s64]_m(svuint64_t inactive, svbool_t pg, svint64_t op) - /// svuint64_t svcnt[_s64]_x(svbool_t pg, svint64_t op) - /// svuint64_t svcnt[_s64]_z(svbool_t pg, svint64_t op) - /// CNT Zresult.D, Pg/M, Zop.D + /// svuint64_t svcnt[_s64]_m(svuint64_t inactive, svbool_t pg, svint64_t op) + /// svuint64_t svcnt[_s64]_x(svbool_t pg, svint64_t op) + /// svuint64_t svcnt[_s64]_z(svbool_t pg, svint64_t op) + /// CNT Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector PopCount(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector PopCount(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svcnt[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) - /// svuint64_t svcnt[_u64]_x(svbool_t pg, svuint64_t op) - /// svuint64_t svcnt[_u64]_z(svbool_t pg, svuint64_t op) - /// CNT Zresult.D, Pg/M, Zop.D + /// svuint64_t svcnt[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) + /// svuint64_t svcnt[_u64]_x(svbool_t pg, svuint64_t op) + /// svuint64_t svcnt[_u64]_z(svbool_t pg, svuint64_t op) + /// CNT Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector PopCount(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector PopCount(Vector value) { throw new PlatformNotSupportedException(); } // Prefetch bytes /// - /// void svprfb(svbool_t pg, const void *base, enum svprfop op) - /// PRFB op, Pg, [Xbase, #0, MUL VL] + /// void svprfb(svbool_t pg, const void *base, enum svprfop op) + /// PRFB op, Pg, [Xbase, #0, MUL VL] /// public static unsafe void PrefetchBytes(Vector mask, void* address, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } @@ -6772,8 +7434,8 @@ internal Arm64() { } // Prefetch halfwords /// - /// void svprfh(svbool_t pg, const void *base, enum svprfop op) - /// PRFH op, Pg, [Xbase, #0, MUL VL] + /// void svprfh(svbool_t pg, const void *base, enum svprfop op) + /// PRFH op, Pg, [Xbase, #0, MUL VL] /// public static unsafe void PrefetchInt16(Vector mask, void* address, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } @@ -6781,8 +7443,8 @@ internal Arm64() { } // Prefetch words /// - /// void svprfw(svbool_t pg, const void *base, enum svprfop op) - /// PRFW op, Pg, [Xbase, #0, MUL VL] + /// void svprfw(svbool_t pg, const void *base, enum svprfop op) + /// PRFW op, Pg, [Xbase, #0, MUL VL] /// public static unsafe void PrefetchInt32(Vector mask, void* address, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } @@ -6790,8 +7452,8 @@ internal Arm64() { } // Prefetch doublewords /// - /// void svprfd(svbool_t pg, const void *base, enum svprfop op) - /// PRFD op, Pg, [Xbase, #0, MUL VL] + /// void svprfd(svbool_t pg, const void *base, enum svprfop op) + /// PRFD op, Pg, [Xbase, #0, MUL VL] /// public static unsafe void PrefetchInt64(Vector mask, void* address, [ConstantExpected] SvePrefetchType prefetchType) { throw new PlatformNotSupportedException(); } @@ -6799,1012 +7461,1012 @@ internal Arm64() { } // Reciprocal estimate /// - /// svfloat64_t svrecpe[_f64](svfloat64_t op) - /// FRECPE Zresult.D, Zop.D + /// svfloat64_t svrecpe[_f64](svfloat64_t op) + /// FRECPE Zresult.D, Zop.D /// - public static unsafe Vector ReciprocalEstimate(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReciprocalEstimate(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svrecpe[_f32](svfloat32_t op) - /// FRECPE Zresult.S, Zop.S + /// svfloat32_t svrecpe[_f32](svfloat32_t op) + /// FRECPE Zresult.S, Zop.S /// - public static unsafe Vector ReciprocalEstimate(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReciprocalEstimate(Vector value) { throw new PlatformNotSupportedException(); } // Reciprocal exponent /// - /// svfloat64_t svrecpx[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) - /// svfloat64_t svrecpx[_f64]_x(svbool_t pg, svfloat64_t op) - /// svfloat64_t svrecpx[_f64]_z(svbool_t pg, svfloat64_t op) - /// FRECPX Zresult.D, Pg/M, Zop.D + /// svfloat64_t svrecpx[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) + /// svfloat64_t svrecpx[_f64]_x(svbool_t pg, svfloat64_t op) + /// svfloat64_t svrecpx[_f64]_z(svbool_t pg, svfloat64_t op) + /// FRECPX Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ReciprocalExponent(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReciprocalExponent(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svrecpx[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) - /// svfloat32_t svrecpx[_f32]_x(svbool_t pg, svfloat32_t op) - /// svfloat32_t svrecpx[_f32]_z(svbool_t pg, svfloat32_t op) - /// FRECPX Zresult.S, Pg/M, Zop.S + /// svfloat32_t svrecpx[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) + /// svfloat32_t svrecpx[_f32]_x(svbool_t pg, svfloat32_t op) + /// svfloat32_t svrecpx[_f32]_z(svbool_t pg, svfloat32_t op) + /// FRECPX Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ReciprocalExponent(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReciprocalExponent(Vector value) { throw new PlatformNotSupportedException(); } // Reciprocal square root estimate /// - /// svfloat64_t svrsqrte[_f64](svfloat64_t op) - /// FRSQRTE Zresult.D, Zop.D + /// svfloat64_t svrsqrte[_f64](svfloat64_t op) + /// FRSQRTE Zresult.D, Zop.D /// - public static unsafe Vector ReciprocalSqrtEstimate(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReciprocalSqrtEstimate(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svrsqrte[_f32](svfloat32_t op) - /// FRSQRTE Zresult.S, Zop.S + /// svfloat32_t svrsqrte[_f32](svfloat32_t op) + /// FRSQRTE Zresult.S, Zop.S /// - public static unsafe Vector ReciprocalSqrtEstimate(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReciprocalSqrtEstimate(Vector value) { throw new PlatformNotSupportedException(); } // Reciprocal square root step /// - /// svfloat64_t svrsqrts[_f64](svfloat64_t op1, svfloat64_t op2) - /// FRSQRTS Zresult.D, Zop1.D, Zop2.D + /// svfloat64_t svrsqrts[_f64](svfloat64_t op1, svfloat64_t op2) + /// FRSQRTS Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector ReciprocalSqrtStep(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ReciprocalSqrtStep(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svrsqrts[_f32](svfloat32_t op1, svfloat32_t op2) - /// FRSQRTS Zresult.S, Zop1.S, Zop2.S + /// svfloat32_t svrsqrts[_f32](svfloat32_t op1, svfloat32_t op2) + /// FRSQRTS Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector ReciprocalSqrtStep(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ReciprocalSqrtStep(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Reciprocal step /// - /// svfloat64_t svrecps[_f64](svfloat64_t op1, svfloat64_t op2) - /// FRECPS Zresult.D, Zop1.D, Zop2.D + /// svfloat64_t svrecps[_f64](svfloat64_t op1, svfloat64_t op2) + /// FRECPS Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector ReciprocalStep(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ReciprocalStep(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svrecps[_f32](svfloat32_t op1, svfloat32_t op2) - /// FRECPS Zresult.S, Zop1.S, Zop2.S + /// svfloat32_t svrecps[_f32](svfloat32_t op1, svfloat32_t op2) + /// FRECPS Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector ReciprocalStep(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ReciprocalStep(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Reverse bits /// - /// svuint8_t svrbit[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) - /// svuint8_t svrbit[_u8]_x(svbool_t pg, svuint8_t op) - /// svuint8_t svrbit[_u8]_z(svbool_t pg, svuint8_t op) - /// RBIT Zresult.B, Pg/M, Zop.B + /// svuint8_t svrbit[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) + /// svuint8_t svrbit[_u8]_x(svbool_t pg, svuint8_t op) + /// svuint8_t svrbit[_u8]_z(svbool_t pg, svuint8_t op) + /// RBIT Zresult.B, Pg/M, Zop.B /// - public static unsafe Vector ReverseBits(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseBits(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svrbit[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) - /// svint16_t svrbit[_s16]_x(svbool_t pg, svint16_t op) - /// svint16_t svrbit[_s16]_z(svbool_t pg, svint16_t op) - /// RBIT Zresult.H, Pg/M, Zop.H + /// svint16_t svrbit[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) + /// svint16_t svrbit[_s16]_x(svbool_t pg, svint16_t op) + /// svint16_t svrbit[_s16]_z(svbool_t pg, svint16_t op) + /// RBIT Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector ReverseBits(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseBits(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svrbit[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) - /// svint32_t svrbit[_s32]_x(svbool_t pg, svint32_t op) - /// svint32_t svrbit[_s32]_z(svbool_t pg, svint32_t op) - /// RBIT Zresult.S, Pg/M, Zop.S + /// svint32_t svrbit[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) + /// svint32_t svrbit[_s32]_x(svbool_t pg, svint32_t op) + /// svint32_t svrbit[_s32]_z(svbool_t pg, svint32_t op) + /// RBIT Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ReverseBits(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseBits(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svrbit[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) - /// svint64_t svrbit[_s64]_x(svbool_t pg, svint64_t op) - /// svint64_t svrbit[_s64]_z(svbool_t pg, svint64_t op) - /// RBIT Zresult.D, Pg/M, Zop.D + /// svint64_t svrbit[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) + /// svint64_t svrbit[_s64]_x(svbool_t pg, svint64_t op) + /// svint64_t svrbit[_s64]_z(svbool_t pg, svint64_t op) + /// RBIT Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ReverseBits(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseBits(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svrbit[_s8]_m(svint8_t inactive, svbool_t pg, svint8_t op) - /// svint8_t svrbit[_s8]_x(svbool_t pg, svint8_t op) - /// svint8_t svrbit[_s8]_z(svbool_t pg, svint8_t op) - /// RBIT Zresult.B, Pg/M, Zop.B + /// svint8_t svrbit[_s8]_m(svint8_t inactive, svbool_t pg, svint8_t op) + /// svint8_t svrbit[_s8]_x(svbool_t pg, svint8_t op) + /// svint8_t svrbit[_s8]_z(svbool_t pg, svint8_t op) + /// RBIT Zresult.B, Pg/M, Zop.B /// - public static unsafe Vector ReverseBits(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseBits(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svrbit[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) - /// svuint16_t svrbit[_u16]_x(svbool_t pg, svuint16_t op) - /// svuint16_t svrbit[_u16]_z(svbool_t pg, svuint16_t op) - /// RBIT Zresult.H, Pg/M, Zop.H + /// svuint16_t svrbit[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) + /// svuint16_t svrbit[_u16]_x(svbool_t pg, svuint16_t op) + /// svuint16_t svrbit[_u16]_z(svbool_t pg, svuint16_t op) + /// RBIT Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector ReverseBits(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseBits(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svrbit[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) - /// svuint32_t svrbit[_u32]_x(svbool_t pg, svuint32_t op) - /// svuint32_t svrbit[_u32]_z(svbool_t pg, svuint32_t op) - /// RBIT Zresult.S, Pg/M, Zop.S + /// svuint32_t svrbit[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) + /// svuint32_t svrbit[_u32]_x(svbool_t pg, svuint32_t op) + /// svuint32_t svrbit[_u32]_z(svbool_t pg, svuint32_t op) + /// RBIT Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ReverseBits(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseBits(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svrbit[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) - /// svuint64_t svrbit[_u64]_x(svbool_t pg, svuint64_t op) - /// svuint64_t svrbit[_u64]_z(svbool_t pg, svuint64_t op) - /// RBIT Zresult.D, Pg/M, Zop.D + /// svuint64_t svrbit[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) + /// svuint64_t svrbit[_u64]_x(svbool_t pg, svuint64_t op) + /// svuint64_t svrbit[_u64]_z(svbool_t pg, svuint64_t op) + /// RBIT Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ReverseBits(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseBits(Vector value) { throw new PlatformNotSupportedException(); } // Reverse all elements /// - /// svuint8_t svrev[_u8](svuint8_t op) - /// REV Zresult.B, Zop.B + /// svuint8_t svrev[_u8](svuint8_t op) + /// REV Zresult.B, Zop.B /// - public static unsafe Vector ReverseElement(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseElement(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svrev[_f64](svfloat64_t op) - /// REV Zresult.D, Zop.D + /// svfloat64_t svrev[_f64](svfloat64_t op) + /// REV Zresult.D, Zop.D /// - public static unsafe Vector ReverseElement(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseElement(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svrev[_s16](svint16_t op) - /// REV Zresult.H, Zop.H + /// svint16_t svrev[_s16](svint16_t op) + /// REV Zresult.H, Zop.H /// - public static unsafe Vector ReverseElement(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseElement(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svrev[_s32](svint32_t op) - /// REV Zresult.S, Zop.S + /// svint32_t svrev[_s32](svint32_t op) + /// REV Zresult.S, Zop.S /// - public static unsafe Vector ReverseElement(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseElement(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svrev[_s64](svint64_t op) - /// REV Zresult.D, Zop.D + /// svint64_t svrev[_s64](svint64_t op) + /// REV Zresult.D, Zop.D /// - public static unsafe Vector ReverseElement(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseElement(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svrev[_s8](svint8_t op) - /// REV Zresult.B, Zop.B + /// svint8_t svrev[_s8](svint8_t op) + /// REV Zresult.B, Zop.B /// - public static unsafe Vector ReverseElement(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseElement(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svrev[_f32](svfloat32_t op) - /// REV Zresult.S, Zop.S + /// svfloat32_t svrev[_f32](svfloat32_t op) + /// REV Zresult.S, Zop.S /// - public static unsafe Vector ReverseElement(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseElement(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svrev[_u16](svuint16_t op) - /// REV Zresult.H, Zop.H + /// svuint16_t svrev[_u16](svuint16_t op) + /// REV Zresult.H, Zop.H /// - public static unsafe Vector ReverseElement(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseElement(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svrev[_u32](svuint32_t op) - /// REV Zresult.S, Zop.S + /// svuint32_t svrev[_u32](svuint32_t op) + /// REV Zresult.S, Zop.S /// - public static unsafe Vector ReverseElement(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseElement(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svrev[_u64](svuint64_t op) - /// REV Zresult.D, Zop.D + /// svuint64_t svrev[_u64](svuint64_t op) + /// REV Zresult.D, Zop.D /// - public static unsafe Vector ReverseElement(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseElement(Vector value) { throw new PlatformNotSupportedException(); } // Reverse halfwords within elements /// - /// svint32_t svrevh[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) - /// svint32_t svrevh[_s32]_x(svbool_t pg, svint32_t op) - /// svint32_t svrevh[_s32]_z(svbool_t pg, svint32_t op) - /// REVH Zresult.S, Pg/M, Zop.S + /// svint32_t svrevh[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) + /// svint32_t svrevh[_s32]_x(svbool_t pg, svint32_t op) + /// svint32_t svrevh[_s32]_z(svbool_t pg, svint32_t op) + /// REVH Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ReverseElement16(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseElement16(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svrevh[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) - /// svint64_t svrevh[_s64]_x(svbool_t pg, svint64_t op) - /// svint64_t svrevh[_s64]_z(svbool_t pg, svint64_t op) - /// REVH Zresult.D, Pg/M, Zop.D + /// svint64_t svrevh[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) + /// svint64_t svrevh[_s64]_x(svbool_t pg, svint64_t op) + /// svint64_t svrevh[_s64]_z(svbool_t pg, svint64_t op) + /// REVH Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ReverseElement16(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseElement16(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svrevh[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) - /// svuint32_t svrevh[_u32]_x(svbool_t pg, svuint32_t op) - /// svuint32_t svrevh[_u32]_z(svbool_t pg, svuint32_t op) - /// REVH Zresult.S, Pg/M, Zop.S + /// svuint32_t svrevh[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) + /// svuint32_t svrevh[_u32]_x(svbool_t pg, svuint32_t op) + /// svuint32_t svrevh[_u32]_z(svbool_t pg, svuint32_t op) + /// REVH Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ReverseElement16(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseElement16(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svrevh[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) - /// svuint64_t svrevh[_u64]_x(svbool_t pg, svuint64_t op) - /// svuint64_t svrevh[_u64]_z(svbool_t pg, svuint64_t op) - /// REVH Zresult.D, Pg/M, Zop.D + /// svuint64_t svrevh[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) + /// svuint64_t svrevh[_u64]_x(svbool_t pg, svuint64_t op) + /// svuint64_t svrevh[_u64]_z(svbool_t pg, svuint64_t op) + /// REVH Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ReverseElement16(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseElement16(Vector value) { throw new PlatformNotSupportedException(); } // Reverse words within elements /// - /// svint64_t svrevw[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) - /// svint64_t svrevw[_s64]_x(svbool_t pg, svint64_t op) - /// svint64_t svrevw[_s64]_z(svbool_t pg, svint64_t op) - /// REVW Zresult.D, Pg/M, Zop.D + /// svint64_t svrevw[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) + /// svint64_t svrevw[_s64]_x(svbool_t pg, svint64_t op) + /// svint64_t svrevw[_s64]_z(svbool_t pg, svint64_t op) + /// REVW Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ReverseElement32(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseElement32(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svrevw[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) - /// svuint64_t svrevw[_u64]_x(svbool_t pg, svuint64_t op) - /// svuint64_t svrevw[_u64]_z(svbool_t pg, svuint64_t op) - /// REVW Zresult.D, Pg/M, Zop.D + /// svuint64_t svrevw[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) + /// svuint64_t svrevw[_u64]_x(svbool_t pg, svuint64_t op) + /// svuint64_t svrevw[_u64]_z(svbool_t pg, svuint64_t op) + /// REVW Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ReverseElement32(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseElement32(Vector value) { throw new PlatformNotSupportedException(); } // Reverse bytes within elements /// - /// svint16_t svrevb[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) - /// svint16_t svrevb[_s16]_x(svbool_t pg, svint16_t op) - /// svint16_t svrevb[_s16]_z(svbool_t pg, svint16_t op) - /// REVB Zresult.H, Pg/M, Zop.H + /// svint16_t svrevb[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) + /// svint16_t svrevb[_s16]_x(svbool_t pg, svint16_t op) + /// svint16_t svrevb[_s16]_z(svbool_t pg, svint16_t op) + /// REVB Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector ReverseElement8(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseElement8(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svrevb[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) - /// svint32_t svrevb[_s32]_x(svbool_t pg, svint32_t op) - /// svint32_t svrevb[_s32]_z(svbool_t pg, svint32_t op) - /// REVB Zresult.S, Pg/M, Zop.S + /// svint32_t svrevb[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) + /// svint32_t svrevb[_s32]_x(svbool_t pg, svint32_t op) + /// svint32_t svrevb[_s32]_z(svbool_t pg, svint32_t op) + /// REVB Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ReverseElement8(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseElement8(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svrevb[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) - /// svint64_t svrevb[_s64]_x(svbool_t pg, svint64_t op) - /// svint64_t svrevb[_s64]_z(svbool_t pg, svint64_t op) - /// REVB Zresult.D, Pg/M, Zop.D + /// svint64_t svrevb[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) + /// svint64_t svrevb[_s64]_x(svbool_t pg, svint64_t op) + /// svint64_t svrevb[_s64]_z(svbool_t pg, svint64_t op) + /// REVB Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ReverseElement8(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseElement8(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svrevb[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) - /// svuint16_t svrevb[_u16]_x(svbool_t pg, svuint16_t op) - /// svuint16_t svrevb[_u16]_z(svbool_t pg, svuint16_t op) - /// REVB Zresult.H, Pg/M, Zop.H + /// svuint16_t svrevb[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) + /// svuint16_t svrevb[_u16]_x(svbool_t pg, svuint16_t op) + /// svuint16_t svrevb[_u16]_z(svbool_t pg, svuint16_t op) + /// REVB Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector ReverseElement8(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseElement8(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svrevb[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) - /// svuint32_t svrevb[_u32]_x(svbool_t pg, svuint32_t op) - /// svuint32_t svrevb[_u32]_z(svbool_t pg, svuint32_t op) - /// REVB Zresult.S, Pg/M, Zop.S + /// svuint32_t svrevb[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) + /// svuint32_t svrevb[_u32]_x(svbool_t pg, svuint32_t op) + /// svuint32_t svrevb[_u32]_z(svbool_t pg, svuint32_t op) + /// REVB Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ReverseElement8(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseElement8(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svrevb[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) - /// svuint64_t svrevb[_u64]_x(svbool_t pg, svuint64_t op) - /// svuint64_t svrevb[_u64]_z(svbool_t pg, svuint64_t op) - /// REVB Zresult.D, Pg/M, Zop.D + /// svuint64_t svrevb[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) + /// svuint64_t svrevb[_u64]_x(svbool_t pg, svuint64_t op) + /// svuint64_t svrevb[_u64]_z(svbool_t pg, svuint64_t op) + /// REVB Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ReverseElement8(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ReverseElement8(Vector value) { throw new PlatformNotSupportedException(); } // Round to nearest, ties away from zero /// - /// svfloat64_t svrinta[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) - /// svfloat64_t svrinta[_f64]_x(svbool_t pg, svfloat64_t op) - /// svfloat64_t svrinta[_f64]_z(svbool_t pg, svfloat64_t op) - /// FRINTA Zresult.D, Pg/M, Zop.D + /// svfloat64_t svrinta[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) + /// svfloat64_t svrinta[_f64]_x(svbool_t pg, svfloat64_t op) + /// svfloat64_t svrinta[_f64]_z(svbool_t pg, svfloat64_t op) + /// FRINTA Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector RoundAwayFromZero(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector RoundAwayFromZero(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svrinta[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) - /// svfloat32_t svrinta[_f32]_x(svbool_t pg, svfloat32_t op) - /// svfloat32_t svrinta[_f32]_z(svbool_t pg, svfloat32_t op) - /// FRINTA Zresult.S, Pg/M, Zop.S + /// svfloat32_t svrinta[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) + /// svfloat32_t svrinta[_f32]_x(svbool_t pg, svfloat32_t op) + /// svfloat32_t svrinta[_f32]_z(svbool_t pg, svfloat32_t op) + /// FRINTA Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector RoundAwayFromZero(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector RoundAwayFromZero(Vector value) { throw new PlatformNotSupportedException(); } // Round to nearest, ties to even /// - /// svfloat64_t svrintn[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) - /// svfloat64_t svrintn[_f64]_x(svbool_t pg, svfloat64_t op) - /// svfloat64_t svrintn[_f64]_z(svbool_t pg, svfloat64_t op) - /// FRINTN Zresult.D, Pg/M, Zop.D + /// svfloat64_t svrintn[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) + /// svfloat64_t svrintn[_f64]_x(svbool_t pg, svfloat64_t op) + /// svfloat64_t svrintn[_f64]_z(svbool_t pg, svfloat64_t op) + /// FRINTN Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector RoundToNearest(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector RoundToNearest(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svrintn[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) - /// svfloat32_t svrintn[_f32]_x(svbool_t pg, svfloat32_t op) - /// svfloat32_t svrintn[_f32]_z(svbool_t pg, svfloat32_t op) - /// FRINTN Zresult.S, Pg/M, Zop.S + /// svfloat32_t svrintn[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) + /// svfloat32_t svrintn[_f32]_x(svbool_t pg, svfloat32_t op) + /// svfloat32_t svrintn[_f32]_z(svbool_t pg, svfloat32_t op) + /// FRINTN Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector RoundToNearest(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector RoundToNearest(Vector value) { throw new PlatformNotSupportedException(); } // Round towards -∞ /// - /// svfloat64_t svrintm[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) - /// svfloat64_t svrintm[_f64]_x(svbool_t pg, svfloat64_t op) - /// svfloat64_t svrintm[_f64]_z(svbool_t pg, svfloat64_t op) - /// FRINTM Zresult.D, Pg/M, Zop.D + /// svfloat64_t svrintm[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) + /// svfloat64_t svrintm[_f64]_x(svbool_t pg, svfloat64_t op) + /// svfloat64_t svrintm[_f64]_z(svbool_t pg, svfloat64_t op) + /// FRINTM Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector RoundToNegativeInfinity(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector RoundToNegativeInfinity(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svrintm[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) - /// svfloat32_t svrintm[_f32]_x(svbool_t pg, svfloat32_t op) - /// svfloat32_t svrintm[_f32]_z(svbool_t pg, svfloat32_t op) - /// FRINTM Zresult.S, Pg/M, Zop.S + /// svfloat32_t svrintm[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) + /// svfloat32_t svrintm[_f32]_x(svbool_t pg, svfloat32_t op) + /// svfloat32_t svrintm[_f32]_z(svbool_t pg, svfloat32_t op) + /// FRINTM Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector RoundToNegativeInfinity(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector RoundToNegativeInfinity(Vector value) { throw new PlatformNotSupportedException(); } // Round towards +∞ /// - /// svfloat64_t svrintp[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) - /// svfloat64_t svrintp[_f64]_x(svbool_t pg, svfloat64_t op) - /// svfloat64_t svrintp[_f64]_z(svbool_t pg, svfloat64_t op) - /// FRINTP Zresult.D, Pg/M, Zop.D + /// svfloat64_t svrintp[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) + /// svfloat64_t svrintp[_f64]_x(svbool_t pg, svfloat64_t op) + /// svfloat64_t svrintp[_f64]_z(svbool_t pg, svfloat64_t op) + /// FRINTP Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector RoundToPositiveInfinity(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector RoundToPositiveInfinity(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svrintp[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) - /// svfloat32_t svrintp[_f32]_x(svbool_t pg, svfloat32_t op) - /// svfloat32_t svrintp[_f32]_z(svbool_t pg, svfloat32_t op) - /// FRINTP Zresult.S, Pg/M, Zop.S + /// svfloat32_t svrintp[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) + /// svfloat32_t svrintp[_f32]_x(svbool_t pg, svfloat32_t op) + /// svfloat32_t svrintp[_f32]_z(svbool_t pg, svfloat32_t op) + /// FRINTP Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector RoundToPositiveInfinity(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector RoundToPositiveInfinity(Vector value) { throw new PlatformNotSupportedException(); } // Round towards zero /// - /// svfloat64_t svrintz[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) - /// svfloat64_t svrintz[_f64]_x(svbool_t pg, svfloat64_t op) - /// svfloat64_t svrintz[_f64]_z(svbool_t pg, svfloat64_t op) - /// FRINTZ Zresult.D, Pg/M, Zop.D + /// svfloat64_t svrintz[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) + /// svfloat64_t svrintz[_f64]_x(svbool_t pg, svfloat64_t op) + /// svfloat64_t svrintz[_f64]_z(svbool_t pg, svfloat64_t op) + /// FRINTZ Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector RoundToZero(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector RoundToZero(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svrintz[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) - /// svfloat32_t svrintz[_f32]_x(svbool_t pg, svfloat32_t op) - /// svfloat32_t svrintz[_f32]_z(svbool_t pg, svfloat32_t op) - /// FRINTZ Zresult.S, Pg/M, Zop.S + /// svfloat32_t svrintz[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) + /// svfloat32_t svrintz[_f32]_x(svbool_t pg, svfloat32_t op) + /// svfloat32_t svrintz[_f32]_z(svbool_t pg, svfloat32_t op) + /// FRINTZ Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector RoundToZero(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector RoundToZero(Vector value) { throw new PlatformNotSupportedException(); } // Saturating decrement by number of halfword elements /// - /// int32_t svqdech_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQDECH Xtied, Wtied, pattern, MUL #imm_factor + /// int32_t svqdech_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQDECH Xtied, Wtied, pattern, MUL #imm_factor /// - public static unsafe int SaturatingDecrementBy16BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static int SaturatingDecrementBy16BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// int64_t svqdech_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQDECH Xtied, pattern, MUL #imm_factor + /// int64_t svqdech_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQDECH Xtied, pattern, MUL #imm_factor /// - public static unsafe long SaturatingDecrementBy16BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static long SaturatingDecrementBy16BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// uint32_t svqdech_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQDECH Wtied, pattern, MUL #imm_factor + /// uint32_t svqdech_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQDECH Wtied, pattern, MUL #imm_factor /// - public static unsafe uint SaturatingDecrementBy16BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static uint SaturatingDecrementBy16BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svqdech_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQDECH Xtied, pattern, MUL #imm_factor + /// uint64_t svqdech_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQDECH Xtied, pattern, MUL #imm_factor /// - public static unsafe ulong SaturatingDecrementBy16BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static ulong SaturatingDecrementBy16BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svqdech_pat[_s16](svint16_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQDECH Ztied.H, pattern, MUL #imm_factor + /// svint16_t svqdech_pat[_s16](svint16_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQDECH Ztied.H, pattern, MUL #imm_factor /// - public static unsafe Vector SaturatingDecrementBy16BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static Vector SaturatingDecrementBy16BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svqdech_pat[_u16](svuint16_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQDECH Ztied.H, pattern, MUL #imm_factor + /// svuint16_t svqdech_pat[_u16](svuint16_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQDECH Ztied.H, pattern, MUL #imm_factor /// - public static unsafe Vector SaturatingDecrementBy16BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static Vector SaturatingDecrementBy16BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } // Saturating decrement by number of word elements /// - /// int32_t svqdecw_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQDECW Xtied, Wtied, pattern, MUL #imm_factor + /// int32_t svqdecw_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQDECW Xtied, Wtied, pattern, MUL #imm_factor /// - public static unsafe int SaturatingDecrementBy32BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static int SaturatingDecrementBy32BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// int64_t svqdecw_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQDECW Xtied, pattern, MUL #imm_factor + /// int64_t svqdecw_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQDECW Xtied, pattern, MUL #imm_factor /// - public static unsafe long SaturatingDecrementBy32BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static long SaturatingDecrementBy32BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// uint32_t svqdecw_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQDECW Wtied, pattern, MUL #imm_factor + /// uint32_t svqdecw_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQDECW Wtied, pattern, MUL #imm_factor /// - public static unsafe uint SaturatingDecrementBy32BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static uint SaturatingDecrementBy32BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svqdecw_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQDECW Xtied, pattern, MUL #imm_factor + /// uint64_t svqdecw_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQDECW Xtied, pattern, MUL #imm_factor /// - public static unsafe ulong SaturatingDecrementBy32BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static ulong SaturatingDecrementBy32BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svqdecw_pat[_s32](svint32_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQDECW Ztied.S, pattern, MUL #imm_factor + /// svint32_t svqdecw_pat[_s32](svint32_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQDECW Ztied.S, pattern, MUL #imm_factor /// - public static unsafe Vector SaturatingDecrementBy32BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static Vector SaturatingDecrementBy32BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svqdecw_pat[_u32](svuint32_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQDECW Ztied.S, pattern, MUL #imm_factor + /// svuint32_t svqdecw_pat[_u32](svuint32_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQDECW Ztied.S, pattern, MUL #imm_factor /// - public static unsafe Vector SaturatingDecrementBy32BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static Vector SaturatingDecrementBy32BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } // Saturating decrement by number of doubleword elements /// - /// int32_t svqdecd_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQDECD Xtied, Wtied, pattern, MUL #imm_factor + /// int32_t svqdecd_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQDECD Xtied, Wtied, pattern, MUL #imm_factor /// - public static unsafe int SaturatingDecrementBy64BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static int SaturatingDecrementBy64BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// int64_t svqdecd_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQDECD Xtied, pattern, MUL #imm_factor + /// int64_t svqdecd_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQDECD Xtied, pattern, MUL #imm_factor /// - public static unsafe long SaturatingDecrementBy64BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static long SaturatingDecrementBy64BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// uint32_t svqdecd_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQDECD Wtied, pattern, MUL #imm_factor + /// uint32_t svqdecd_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQDECD Wtied, pattern, MUL #imm_factor /// - public static unsafe uint SaturatingDecrementBy64BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static uint SaturatingDecrementBy64BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svqdecd_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQDECD Xtied, pattern, MUL #imm_factor + /// uint64_t svqdecd_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQDECD Xtied, pattern, MUL #imm_factor /// - public static unsafe ulong SaturatingDecrementBy64BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static ulong SaturatingDecrementBy64BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svqdecd_pat[_s64](svint64_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQDECD Ztied.D, pattern, MUL #imm_factor + /// svint64_t svqdecd_pat[_s64](svint64_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQDECD Ztied.D, pattern, MUL #imm_factor /// - public static unsafe Vector SaturatingDecrementBy64BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static Vector SaturatingDecrementBy64BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svqdecd_pat[_u64](svuint64_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQDECD Ztied.D, pattern, MUL #imm_factor + /// svuint64_t svqdecd_pat[_u64](svuint64_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQDECD Ztied.D, pattern, MUL #imm_factor /// - public static unsafe Vector SaturatingDecrementBy64BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static Vector SaturatingDecrementBy64BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } // Saturating decrement by number of byte elements /// - /// int32_t svqdecb_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQDECB Xtied, Wtied, pattern, MUL #imm_factor + /// int32_t svqdecb_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQDECB Xtied, Wtied, pattern, MUL #imm_factor /// - public static unsafe int SaturatingDecrementBy8BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static int SaturatingDecrementBy8BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// int64_t svqdecb_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQDECB Xtied, pattern, MUL #imm_factor + /// int64_t svqdecb_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQDECB Xtied, pattern, MUL #imm_factor /// - public static unsafe long SaturatingDecrementBy8BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static long SaturatingDecrementBy8BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// uint32_t svqdecb_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQDECB Wtied, pattern, MUL #imm_factor + /// uint32_t svqdecb_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQDECB Wtied, pattern, MUL #imm_factor /// - public static unsafe uint SaturatingDecrementBy8BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static uint SaturatingDecrementBy8BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svqdecb_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQDECB Xtied, pattern, MUL #imm_factor + /// uint64_t svqdecb_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQDECB Xtied, pattern, MUL #imm_factor /// - public static unsafe ulong SaturatingDecrementBy8BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static ulong SaturatingDecrementBy8BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } // Saturating decrement by active element count /// - /// int32_t svqdecp[_n_s32]_b8(int32_t op, svbool_t pg) - /// SQDECP Xtied, Pg.B, Wtied + /// int32_t svqdecp[_n_s32]_b8(int32_t op, svbool_t pg) + /// SQDECP Xtied, Pg.B, Wtied /// - public static unsafe long SaturatingDecrementByActiveElementCount(int value, Vector from) { throw new PlatformNotSupportedException(); } + public static long SaturatingDecrementByActiveElementCount(int value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// int64_t svqdecp[_n_s64]_b8(int64_t op, svbool_t pg) - /// SQDECP Xtied, Pg.B + /// int64_t svqdecp[_n_s64]_b8(int64_t op, svbool_t pg) + /// SQDECP Xtied, Pg.B /// - public static unsafe long SaturatingDecrementByActiveElementCount(long value, Vector from) { throw new PlatformNotSupportedException(); } + public static long SaturatingDecrementByActiveElementCount(long value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint32_t svqdecp[_n_u32]_b8(uint32_t op, svbool_t pg) - /// UQDECP Wtied, Pg.B + /// uint32_t svqdecp[_n_u32]_b8(uint32_t op, svbool_t pg) + /// UQDECP Wtied, Pg.B /// - public static unsafe ulong SaturatingDecrementByActiveElementCount(uint value, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong SaturatingDecrementByActiveElementCount(uint value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svqdecp[_n_u64]_b8(uint64_t op, svbool_t pg) - /// UQDECP Xtied, Pg.B + /// uint64_t svqdecp[_n_u64]_b8(uint64_t op, svbool_t pg) + /// UQDECP Xtied, Pg.B /// - public static unsafe ulong SaturatingDecrementByActiveElementCount(ulong value, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong SaturatingDecrementByActiveElementCount(ulong value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svqdecp[_s16](svint16_t op, svbool_t pg) - /// SQDECP Ztied.H, Pg + /// svint16_t svqdecp[_s16](svint16_t op, svbool_t pg) + /// SQDECP Ztied.H, Pg /// - public static unsafe Vector SaturatingDecrementByActiveElementCount(Vector value, Vector from) { throw new PlatformNotSupportedException(); } + public static Vector SaturatingDecrementByActiveElementCount(Vector value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svqdecp[_s32](svint32_t op, svbool_t pg) - /// SQDECP Ztied.S, Pg + /// svint32_t svqdecp[_s32](svint32_t op, svbool_t pg) + /// SQDECP Ztied.S, Pg /// - public static unsafe Vector SaturatingDecrementByActiveElementCount(Vector value, Vector from) { throw new PlatformNotSupportedException(); } + public static Vector SaturatingDecrementByActiveElementCount(Vector value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svqdecp[_s64](svint64_t op, svbool_t pg) - /// SQDECP Ztied.D, Pg + /// svint64_t svqdecp[_s64](svint64_t op, svbool_t pg) + /// SQDECP Ztied.D, Pg /// - public static unsafe Vector SaturatingDecrementByActiveElementCount(Vector value, Vector from) { throw new PlatformNotSupportedException(); } + public static Vector SaturatingDecrementByActiveElementCount(Vector value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// int32_t svqdecp[_n_s32]_b16(int32_t op, svbool_t pg) - /// SQDECP Xtied, Pg.H, Wtied + /// int32_t svqdecp[_n_s32]_b16(int32_t op, svbool_t pg) + /// SQDECP Xtied, Pg.H, Wtied /// - public static unsafe long SaturatingDecrementByActiveElementCount(int value, Vector from) { throw new PlatformNotSupportedException(); } + public static long SaturatingDecrementByActiveElementCount(int value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// int64_t svqdecp[_n_s64]_b16(int64_t op, svbool_t pg) - /// SQDECP Xtied, Pg.H + /// int64_t svqdecp[_n_s64]_b16(int64_t op, svbool_t pg) + /// SQDECP Xtied, Pg.H /// - public static unsafe long SaturatingDecrementByActiveElementCount(long value, Vector from) { throw new PlatformNotSupportedException(); } + public static long SaturatingDecrementByActiveElementCount(long value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint32_t svqdecp[_n_u32]_b16(uint32_t op, svbool_t pg) - /// UQDECP Wtied, Pg.H + /// uint32_t svqdecp[_n_u32]_b16(uint32_t op, svbool_t pg) + /// UQDECP Wtied, Pg.H /// - public static unsafe ulong SaturatingDecrementByActiveElementCount(uint value, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong SaturatingDecrementByActiveElementCount(uint value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svqdecp[_n_u64]_b16(uint64_t op, svbool_t pg) - /// UQDECP Xtied, Pg.H + /// uint64_t svqdecp[_n_u64]_b16(uint64_t op, svbool_t pg) + /// UQDECP Xtied, Pg.H /// - public static unsafe ulong SaturatingDecrementByActiveElementCount(ulong value, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong SaturatingDecrementByActiveElementCount(ulong value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svqdecp[_u16](svuint16_t op, svbool_t pg) - /// UQDECP Ztied.H, Pg + /// svuint16_t svqdecp[_u16](svuint16_t op, svbool_t pg) + /// UQDECP Ztied.H, Pg /// - public static unsafe Vector SaturatingDecrementByActiveElementCount(Vector value, Vector from) { throw new PlatformNotSupportedException(); } + public static Vector SaturatingDecrementByActiveElementCount(Vector value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// int32_t svqdecp[_n_s32]_b32(int32_t op, svbool_t pg) - /// SQDECP Xtied, Pg.S, Wtied + /// int32_t svqdecp[_n_s32]_b32(int32_t op, svbool_t pg) + /// SQDECP Xtied, Pg.S, Wtied /// - public static unsafe long SaturatingDecrementByActiveElementCount(int value, Vector from) { throw new PlatformNotSupportedException(); } + public static long SaturatingDecrementByActiveElementCount(int value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// int64_t svqdecp[_n_s64]_b32(int64_t op, svbool_t pg) - /// SQDECP Xtied, Pg.S + /// int64_t svqdecp[_n_s64]_b32(int64_t op, svbool_t pg) + /// SQDECP Xtied, Pg.S /// - public static unsafe long SaturatingDecrementByActiveElementCount(long value, Vector from) { throw new PlatformNotSupportedException(); } + public static long SaturatingDecrementByActiveElementCount(long value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint32_t svqdecp[_n_u32]_b32(uint32_t op, svbool_t pg) - /// UQDECP Wtied, Pg.S + /// uint32_t svqdecp[_n_u32]_b32(uint32_t op, svbool_t pg) + /// UQDECP Wtied, Pg.S /// - public static unsafe ulong SaturatingDecrementByActiveElementCount(uint value, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong SaturatingDecrementByActiveElementCount(uint value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svqdecp[_n_u64]_b32(uint64_t op, svbool_t pg) - /// UQDECP Xtied, Pg.S + /// uint64_t svqdecp[_n_u64]_b32(uint64_t op, svbool_t pg) + /// UQDECP Xtied, Pg.S /// - public static unsafe ulong SaturatingDecrementByActiveElementCount(ulong value, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong SaturatingDecrementByActiveElementCount(ulong value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svqdecp[_u32](svuint32_t op, svbool_t pg) - /// UQDECP Ztied.S, Pg + /// svuint32_t svqdecp[_u32](svuint32_t op, svbool_t pg) + /// UQDECP Ztied.S, Pg /// - public static unsafe Vector SaturatingDecrementByActiveElementCount(Vector value, Vector from) { throw new PlatformNotSupportedException(); } + public static Vector SaturatingDecrementByActiveElementCount(Vector value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// int32_t svqdecp[_n_s32]_b64(int32_t op, svbool_t pg) - /// SQDECP Xtied, Pg.D, Wtied + /// int32_t svqdecp[_n_s32]_b64(int32_t op, svbool_t pg) + /// SQDECP Xtied, Pg.D, Wtied /// - public static unsafe long SaturatingDecrementByActiveElementCount(int value, Vector from) { throw new PlatformNotSupportedException(); } + public static long SaturatingDecrementByActiveElementCount(int value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// int64_t svqdecp[_n_s64]_b64(int64_t op, svbool_t pg) - /// SQDECP Xtied, Pg.D + /// int64_t svqdecp[_n_s64]_b64(int64_t op, svbool_t pg) + /// SQDECP Xtied, Pg.D /// - public static unsafe long SaturatingDecrementByActiveElementCount(long value, Vector from) { throw new PlatformNotSupportedException(); } + public static long SaturatingDecrementByActiveElementCount(long value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint32_t svqdecp[_n_u32]_b64(uint32_t op, svbool_t pg) - /// UQDECP Wtied, Pg.D + /// uint32_t svqdecp[_n_u32]_b64(uint32_t op, svbool_t pg) + /// UQDECP Wtied, Pg.D /// - public static unsafe ulong SaturatingDecrementByActiveElementCount(uint value, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong SaturatingDecrementByActiveElementCount(uint value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svqdecp[_n_u64]_b64(uint64_t op, svbool_t pg) - /// UQDECP Xtied, Pg.D + /// uint64_t svqdecp[_n_u64]_b64(uint64_t op, svbool_t pg) + /// UQDECP Xtied, Pg.D /// - public static unsafe ulong SaturatingDecrementByActiveElementCount(ulong value, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong SaturatingDecrementByActiveElementCount(ulong value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svqdecp[_u64](svuint64_t op, svbool_t pg) - /// UQDECP Ztied.D, Pg + /// svuint64_t svqdecp[_u64](svuint64_t op, svbool_t pg) + /// UQDECP Ztied.D, Pg /// - public static unsafe Vector SaturatingDecrementByActiveElementCount(Vector value, Vector from) { throw new PlatformNotSupportedException(); } + public static Vector SaturatingDecrementByActiveElementCount(Vector value, Vector from) { throw new PlatformNotSupportedException(); } // Saturating increment by number of halfword elements /// - /// int32_t svqinch_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQINCH Xtied, Wtied, pattern, MUL #imm_factor + /// int32_t svqinch_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQINCH Xtied, Wtied, pattern, MUL #imm_factor /// - public static unsafe int SaturatingIncrementBy16BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static int SaturatingIncrementBy16BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// int64_t svqinch_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQINCH Xtied, pattern, MUL #imm_factor + /// int64_t svqinch_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQINCH Xtied, pattern, MUL #imm_factor /// - public static unsafe long SaturatingIncrementBy16BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static long SaturatingIncrementBy16BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// uint32_t svqinch_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQINCH Wtied, pattern, MUL #imm_factor + /// uint32_t svqinch_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQINCH Wtied, pattern, MUL #imm_factor /// - public static unsafe uint SaturatingIncrementBy16BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static uint SaturatingIncrementBy16BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svqinch_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQINCH Xtied, pattern, MUL #imm_factor + /// uint64_t svqinch_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQINCH Xtied, pattern, MUL #imm_factor /// - public static unsafe ulong SaturatingIncrementBy16BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static ulong SaturatingIncrementBy16BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svqinch_pat[_s16](svint16_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQINCH Ztied.H, pattern, MUL #imm_factor + /// svint16_t svqinch_pat[_s16](svint16_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQINCH Ztied.H, pattern, MUL #imm_factor /// - public static unsafe Vector SaturatingIncrementBy16BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static Vector SaturatingIncrementBy16BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svqinch_pat[_u16](svuint16_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQINCH Ztied.H, pattern, MUL #imm_factor + /// svuint16_t svqinch_pat[_u16](svuint16_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQINCH Ztied.H, pattern, MUL #imm_factor /// - public static unsafe Vector SaturatingIncrementBy16BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static Vector SaturatingIncrementBy16BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } // Saturating increment by number of word elements /// - /// int32_t svqincw_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQINCW Xtied, Wtied, pattern, MUL #imm_factor + /// int32_t svqincw_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQINCW Xtied, Wtied, pattern, MUL #imm_factor /// - public static unsafe int SaturatingIncrementBy32BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static int SaturatingIncrementBy32BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// int64_t svqincw_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQINCW Xtied, pattern, MUL #imm_factor + /// int64_t svqincw_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQINCW Xtied, pattern, MUL #imm_factor /// - public static unsafe long SaturatingIncrementBy32BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static long SaturatingIncrementBy32BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// uint32_t svqincw_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQINCW Wtied, pattern, MUL #imm_factor + /// uint32_t svqincw_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQINCW Wtied, pattern, MUL #imm_factor /// - public static unsafe uint SaturatingIncrementBy32BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static uint SaturatingIncrementBy32BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svqincw_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQINCW Xtied, pattern, MUL #imm_factor + /// uint64_t svqincw_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQINCW Xtied, pattern, MUL #imm_factor /// - public static unsafe ulong SaturatingIncrementBy32BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static ulong SaturatingIncrementBy32BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svqincw_pat[_s32](svint32_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQINCW Ztied.S, pattern, MUL #imm_factor + /// svint32_t svqincw_pat[_s32](svint32_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQINCW Ztied.S, pattern, MUL #imm_factor /// - public static unsafe Vector SaturatingIncrementBy32BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static Vector SaturatingIncrementBy32BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svqincw_pat[_u32](svuint32_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQINCW Ztied.S, pattern, MUL #imm_factor + /// svuint32_t svqincw_pat[_u32](svuint32_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQINCW Ztied.S, pattern, MUL #imm_factor /// - public static unsafe Vector SaturatingIncrementBy32BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static Vector SaturatingIncrementBy32BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } // Saturating increment by number of doubleword elements /// - /// int32_t svqincd_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQINCD Xtied, Wtied, pattern, MUL #imm_factor + /// int32_t svqincd_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQINCD Xtied, Wtied, pattern, MUL #imm_factor /// - public static unsafe int SaturatingIncrementBy64BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static int SaturatingIncrementBy64BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// int64_t svqincd_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQINCD Xtied, pattern, MUL #imm_factor + /// int64_t svqincd_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQINCD Xtied, pattern, MUL #imm_factor /// - public static unsafe long SaturatingIncrementBy64BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static long SaturatingIncrementBy64BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// uint32_t svqincd_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQINCD Wtied, pattern, MUL #imm_factor + /// uint32_t svqincd_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQINCD Wtied, pattern, MUL #imm_factor /// - public static unsafe uint SaturatingIncrementBy64BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static uint SaturatingIncrementBy64BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svqincd_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQINCD Xtied, pattern, MUL #imm_factor + /// uint64_t svqincd_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQINCD Xtied, pattern, MUL #imm_factor /// - public static unsafe ulong SaturatingIncrementBy64BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static ulong SaturatingIncrementBy64BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svqincd_pat[_s64](svint64_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQINCD Ztied.D, pattern, MUL #imm_factor + /// svint64_t svqincd_pat[_s64](svint64_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQINCD Ztied.D, pattern, MUL #imm_factor /// - public static unsafe Vector SaturatingIncrementBy64BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static Vector SaturatingIncrementBy64BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svqincd_pat[_u64](svuint64_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQINCD Ztied.D, pattern, MUL #imm_factor + /// svuint64_t svqincd_pat[_u64](svuint64_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQINCD Ztied.D, pattern, MUL #imm_factor /// - public static unsafe Vector SaturatingIncrementBy64BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static Vector SaturatingIncrementBy64BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } // Saturating increment by number of byte elements /// - /// int32_t svqincb_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQINCB Xtied, Wtied, pattern, MUL #imm_factor + /// int32_t svqincb_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQINCB Xtied, Wtied, pattern, MUL #imm_factor /// - public static unsafe int SaturatingIncrementBy8BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static int SaturatingIncrementBy8BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// int64_t svqincb_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQINCB Xtied, pattern, MUL #imm_factor + /// int64_t svqincb_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQINCB Xtied, pattern, MUL #imm_factor /// - public static unsafe long SaturatingIncrementBy8BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static long SaturatingIncrementBy8BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// uint32_t svqincb_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQINCB Wtied, pattern, MUL #imm_factor + /// uint32_t svqincb_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQINCB Wtied, pattern, MUL #imm_factor /// - public static unsafe uint SaturatingIncrementBy8BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static uint SaturatingIncrementBy8BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svqincb_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQINCB Xtied, pattern, MUL #imm_factor + /// uint64_t svqincb_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQINCB Xtied, pattern, MUL #imm_factor /// - public static unsafe ulong SaturatingIncrementBy8BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + public static ulong SaturatingIncrementBy8BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } // Saturating increment by active element count /// - /// int32_t svqincp[_n_s32]_b8(int32_t op, svbool_t pg) - /// SQINCP Xtied, Pg.B, Wtied + /// int32_t svqincp[_n_s32]_b8(int32_t op, svbool_t pg) + /// SQINCP Xtied, Pg.B, Wtied /// - public static unsafe long SaturatingIncrementByActiveElementCount(int value, Vector from) { throw new PlatformNotSupportedException(); } + public static long SaturatingIncrementByActiveElementCount(int value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// int64_t svqincp[_n_s64]_b8(int64_t op, svbool_t pg) - /// SQINCP Xtied, Pg.B + /// int64_t svqincp[_n_s64]_b8(int64_t op, svbool_t pg) + /// SQINCP Xtied, Pg.B /// - public static unsafe long SaturatingIncrementByActiveElementCount(long value, Vector from) { throw new PlatformNotSupportedException(); } + public static long SaturatingIncrementByActiveElementCount(long value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint32_t svqincp[_n_u32]_b8(uint32_t op, svbool_t pg) - /// UQINCP Wtied, Pg.B + /// uint32_t svqincp[_n_u32]_b8(uint32_t op, svbool_t pg) + /// UQINCP Wtied, Pg.B /// - public static unsafe ulong SaturatingIncrementByActiveElementCount(uint value, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong SaturatingIncrementByActiveElementCount(uint value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svqincp[_n_u64]_b8(uint64_t op, svbool_t pg) - /// UQINCP Xtied, Pg.B + /// uint64_t svqincp[_n_u64]_b8(uint64_t op, svbool_t pg) + /// UQINCP Xtied, Pg.B /// - public static unsafe ulong SaturatingIncrementByActiveElementCount(ulong value, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong SaturatingIncrementByActiveElementCount(ulong value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svqincp[_s16](svint16_t op, svbool_t pg) - /// SQINCP Ztied.H, Pg + /// svint16_t svqincp[_s16](svint16_t op, svbool_t pg) + /// SQINCP Ztied.H, Pg /// - public static unsafe Vector SaturatingIncrementByActiveElementCount(Vector value, Vector from) { throw new PlatformNotSupportedException(); } + public static Vector SaturatingIncrementByActiveElementCount(Vector value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svqincp[_s32](svint32_t op, svbool_t pg) - /// SQINCP Ztied.S, Pg + /// svint32_t svqincp[_s32](svint32_t op, svbool_t pg) + /// SQINCP Ztied.S, Pg /// - public static unsafe Vector SaturatingIncrementByActiveElementCount(Vector value, Vector from) { throw new PlatformNotSupportedException(); } + public static Vector SaturatingIncrementByActiveElementCount(Vector value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svqincp[_s64](svint64_t op, svbool_t pg) - /// SQINCP Ztied.D, Pg + /// svint64_t svqincp[_s64](svint64_t op, svbool_t pg) + /// SQINCP Ztied.D, Pg /// - public static unsafe Vector SaturatingIncrementByActiveElementCount(Vector value, Vector from) { throw new PlatformNotSupportedException(); } + public static Vector SaturatingIncrementByActiveElementCount(Vector value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// int32_t svqincp[_n_s32]_b16(int32_t op, svbool_t pg) - /// SQINCP Xtied, Pg.H, Wtied + /// int32_t svqincp[_n_s32]_b16(int32_t op, svbool_t pg) + /// SQINCP Xtied, Pg.H, Wtied /// - public static unsafe long SaturatingIncrementByActiveElementCount(int value, Vector from) { throw new PlatformNotSupportedException(); } + public static long SaturatingIncrementByActiveElementCount(int value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// int64_t svqincp[_n_s64]_b16(int64_t op, svbool_t pg) - /// SQINCP Xtied, Pg.H + /// int64_t svqincp[_n_s64]_b16(int64_t op, svbool_t pg) + /// SQINCP Xtied, Pg.H /// - public static unsafe long SaturatingIncrementByActiveElementCount(long value, Vector from) { throw new PlatformNotSupportedException(); } + public static long SaturatingIncrementByActiveElementCount(long value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint32_t svqincp[_n_u32]_b16(uint32_t op, svbool_t pg) - /// UQINCP Wtied, Pg.H + /// uint32_t svqincp[_n_u32]_b16(uint32_t op, svbool_t pg) + /// UQINCP Wtied, Pg.H /// - public static unsafe ulong SaturatingIncrementByActiveElementCount(uint value, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong SaturatingIncrementByActiveElementCount(uint value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svqincp[_n_u64]_b16(uint64_t op, svbool_t pg) - /// UQINCP Xtied, Pg.H + /// uint64_t svqincp[_n_u64]_b16(uint64_t op, svbool_t pg) + /// UQINCP Xtied, Pg.H /// - public static unsafe ulong SaturatingIncrementByActiveElementCount(ulong value, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong SaturatingIncrementByActiveElementCount(ulong value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svqincp[_u16](svuint16_t op, svbool_t pg) - /// UQINCP Ztied.H, Pg + /// svuint16_t svqincp[_u16](svuint16_t op, svbool_t pg) + /// UQINCP Ztied.H, Pg /// - public static unsafe Vector SaturatingIncrementByActiveElementCount(Vector value, Vector from) { throw new PlatformNotSupportedException(); } + public static Vector SaturatingIncrementByActiveElementCount(Vector value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// int32_t svqincp[_n_s32]_b32(int32_t op, svbool_t pg) - /// SQINCP Xtied, Pg.S, Wtied + /// int32_t svqincp[_n_s32]_b32(int32_t op, svbool_t pg) + /// SQINCP Xtied, Pg.S, Wtied /// - public static unsafe long SaturatingIncrementByActiveElementCount(int value, Vector from) { throw new PlatformNotSupportedException(); } + public static long SaturatingIncrementByActiveElementCount(int value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// int64_t svqincp[_n_s64]_b32(int64_t op, svbool_t pg) - /// SQINCP Xtied, Pg.S + /// int64_t svqincp[_n_s64]_b32(int64_t op, svbool_t pg) + /// SQINCP Xtied, Pg.S /// - public static unsafe long SaturatingIncrementByActiveElementCount(long value, Vector from) { throw new PlatformNotSupportedException(); } + public static long SaturatingIncrementByActiveElementCount(long value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint32_t svqincp[_n_u32]_b32(uint32_t op, svbool_t pg) - /// UQINCP Wtied, Pg.S + /// uint32_t svqincp[_n_u32]_b32(uint32_t op, svbool_t pg) + /// UQINCP Wtied, Pg.S /// - public static unsafe ulong SaturatingIncrementByActiveElementCount(uint value, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong SaturatingIncrementByActiveElementCount(uint value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svqincp[_n_u64]_b32(uint64_t op, svbool_t pg) - /// UQINCP Xtied, Pg.S + /// uint64_t svqincp[_n_u64]_b32(uint64_t op, svbool_t pg) + /// UQINCP Xtied, Pg.S /// - public static unsafe ulong SaturatingIncrementByActiveElementCount(ulong value, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong SaturatingIncrementByActiveElementCount(ulong value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svqincp[_u32](svuint32_t op, svbool_t pg) - /// UQINCP Ztied.S, Pg + /// svuint32_t svqincp[_u32](svuint32_t op, svbool_t pg) + /// UQINCP Ztied.S, Pg /// - public static unsafe Vector SaturatingIncrementByActiveElementCount(Vector value, Vector from) { throw new PlatformNotSupportedException(); } + public static Vector SaturatingIncrementByActiveElementCount(Vector value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// int32_t svqincp[_n_s32]_b64(int32_t op, svbool_t pg) - /// SQINCP Xtied, Pg.D, Wtied + /// int32_t svqincp[_n_s32]_b64(int32_t op, svbool_t pg) + /// SQINCP Xtied, Pg.D, Wtied /// - public static unsafe long SaturatingIncrementByActiveElementCount(int value, Vector from) { throw new PlatformNotSupportedException(); } + public static long SaturatingIncrementByActiveElementCount(int value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// int64_t svqincp[_n_s64]_b64(int64_t op, svbool_t pg) - /// SQINCP Xtied, Pg.D + /// int64_t svqincp[_n_s64]_b64(int64_t op, svbool_t pg) + /// SQINCP Xtied, Pg.D /// - public static unsafe long SaturatingIncrementByActiveElementCount(long value, Vector from) { throw new PlatformNotSupportedException(); } + public static long SaturatingIncrementByActiveElementCount(long value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint32_t svqincp[_n_u32]_b64(uint32_t op, svbool_t pg) - /// UQINCP Wtied, Pg.D + /// uint32_t svqincp[_n_u32]_b64(uint32_t op, svbool_t pg) + /// UQINCP Wtied, Pg.D /// - public static unsafe ulong SaturatingIncrementByActiveElementCount(uint value, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong SaturatingIncrementByActiveElementCount(uint value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// uint64_t svqincp[_n_u64]_b64(uint64_t op, svbool_t pg) - /// UQINCP Xtied, Pg.D + /// uint64_t svqincp[_n_u64]_b64(uint64_t op, svbool_t pg) + /// UQINCP Xtied, Pg.D /// - public static unsafe ulong SaturatingIncrementByActiveElementCount(ulong value, Vector from) { throw new PlatformNotSupportedException(); } + public static ulong SaturatingIncrementByActiveElementCount(ulong value, Vector from) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svqincp[_u64](svuint64_t op, svbool_t pg) - /// UQINCP Ztied.D, Pg + /// svuint64_t svqincp[_u64](svuint64_t op, svbool_t pg) + /// UQINCP Ztied.D, Pg /// - public static unsafe Vector SaturatingIncrementByActiveElementCount(Vector value, Vector from) { throw new PlatformNotSupportedException(); } + public static Vector SaturatingIncrementByActiveElementCount(Vector value, Vector from) { throw new PlatformNotSupportedException(); } // Adjust exponent /// - /// svfloat64_t svscale[_f64]_m(svbool_t pg, svfloat64_t op1, svint64_t op2) - /// svfloat64_t svscale[_f64]_x(svbool_t pg, svfloat64_t op1, svint64_t op2) - /// svfloat64_t svscale[_f64]_z(svbool_t pg, svfloat64_t op1, svint64_t op2) - /// FSCALE Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svfloat64_t svscale[_f64]_m(svbool_t pg, svfloat64_t op1, svint64_t op2) + /// svfloat64_t svscale[_f64]_x(svbool_t pg, svfloat64_t op1, svint64_t op2) + /// svfloat64_t svscale[_f64]_z(svbool_t pg, svfloat64_t op1, svint64_t op2) + /// FSCALE Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector Scale(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Scale(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svscale[_f32]_m(svbool_t pg, svfloat32_t op1, svint32_t op2) - /// svfloat32_t svscale[_f32]_x(svbool_t pg, svfloat32_t op1, svint32_t op2) - /// svfloat32_t svscale[_f32]_z(svbool_t pg, svfloat32_t op1, svint32_t op2) - /// FSCALE Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svfloat32_t svscale[_f32]_m(svbool_t pg, svfloat32_t op1, svint32_t op2) + /// svfloat32_t svscale[_f32]_x(svbool_t pg, svfloat32_t op1, svint32_t op2) + /// svfloat32_t svscale[_f32]_z(svbool_t pg, svfloat32_t op1, svint32_t op2) + /// FSCALE Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector Scale(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Scale(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Non-truncating store /// - /// void svst1_scatter_[s64]offset[_f64](svbool_t pg, float64_t *base, svint64_t offsets, svfloat64_t data) - /// ST1D Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1_scatter_[s64]offset[_f64](svbool_t pg, float64_t *base, svint64_t offsets, svfloat64_t data) + /// ST1D Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter(Vector mask, double* address, Vector indicies, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1_scatter[_u64base_f64](svbool_t pg, svuint64_t bases, svfloat64_t data) - /// ST1D Zdata.D, Pg, [Zbases.D, #0] + /// void svst1_scatter[_u64base_f64](svbool_t pg, svuint64_t bases, svfloat64_t data) + /// ST1D Zdata.D, Pg, [Zbases.D, #0] /// - public static unsafe void Scatter(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } + public static void Scatter(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1_scatter_[u64]offset[_f64](svbool_t pg, float64_t *base, svuint64_t offsets, svfloat64_t data) - /// ST1D Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1_scatter_[u64]offset[_f64](svbool_t pg, float64_t *base, svuint64_t offsets, svfloat64_t data) + /// ST1D Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter(Vector mask, double* address, Vector indicies, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1_scatter_[s32]offset[_s32](svbool_t pg, int32_t *base, svint32_t offsets, svint32_t data) - /// ST1W Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] + /// void svst1_scatter_[s32]offset[_s32](svbool_t pg, int32_t *base, svint32_t offsets, svint32_t data) + /// ST1W Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] /// public static unsafe void Scatter(Vector mask, int* address, Vector indicies, Vector data) { throw new PlatformNotSupportedException(); } @@ -7813,35 +8475,35 @@ internal Arm64() { } // ST1W Zdata.S, Pg, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe void Scatter(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } + // public static void Scatter(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1_scatter_[u32]offset[_s32](svbool_t pg, int32_t *base, svuint32_t offsets, svint32_t data) - /// ST1W Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] + /// void svst1_scatter_[u32]offset[_s32](svbool_t pg, int32_t *base, svuint32_t offsets, svint32_t data) + /// ST1W Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] /// public static unsafe void Scatter(Vector mask, int* address, Vector indicies, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1_scatter_[s64]offset[_s64](svbool_t pg, int64_t *base, svint64_t offsets, svint64_t data) - /// ST1D Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1_scatter_[s64]offset[_s64](svbool_t pg, int64_t *base, svint64_t offsets, svint64_t data) + /// ST1D Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter(Vector mask, long* address, Vector indicies, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1_scatter[_u64base_s64](svbool_t pg, svuint64_t bases, svint64_t data) - /// ST1D Zdata.D, Pg, [Zbases.D, #0] + /// void svst1_scatter[_u64base_s64](svbool_t pg, svuint64_t bases, svint64_t data) + /// ST1D Zdata.D, Pg, [Zbases.D, #0] /// - public static unsafe void Scatter(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } + public static void Scatter(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1_scatter_[u64]offset[_s64](svbool_t pg, int64_t *base, svuint64_t offsets, svint64_t data) - /// ST1D Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1_scatter_[u64]offset[_s64](svbool_t pg, int64_t *base, svuint64_t offsets, svint64_t data) + /// ST1D Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter(Vector mask, long* address, Vector indicies, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1_scatter_[s32]offset[_f32](svbool_t pg, float32_t *base, svint32_t offsets, svfloat32_t data) - /// ST1W Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] + /// void svst1_scatter_[s32]offset[_f32](svbool_t pg, float32_t *base, svint32_t offsets, svfloat32_t data) + /// ST1W Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] /// public static unsafe void Scatter(Vector mask, float* address, Vector indicies, Vector data) { throw new PlatformNotSupportedException(); } @@ -7850,17 +8512,17 @@ internal Arm64() { } // ST1W Zdata.S, Pg, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe void Scatter(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } + // public static void Scatter(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1_scatter_[u32]offset[_f32](svbool_t pg, float32_t *base, svuint32_t offsets, svfloat32_t data) - /// ST1W Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] + /// void svst1_scatter_[u32]offset[_f32](svbool_t pg, float32_t *base, svuint32_t offsets, svfloat32_t data) + /// ST1W Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] /// public static unsafe void Scatter(Vector mask, float* address, Vector indicies, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1_scatter_[s32]offset[_u32](svbool_t pg, uint32_t *base, svint32_t offsets, svuint32_t data) - /// ST1W Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] + /// void svst1_scatter_[s32]offset[_u32](svbool_t pg, uint32_t *base, svint32_t offsets, svuint32_t data) + /// ST1W Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] /// public static unsafe void Scatter(Vector mask, uint* address, Vector indicies, Vector data) { throw new PlatformNotSupportedException(); } @@ -7869,29 +8531,29 @@ internal Arm64() { } // ST1W Zdata.S, Pg, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe void Scatter(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } + // public static void Scatter(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1_scatter_[u32]offset[_u32](svbool_t pg, uint32_t *base, svuint32_t offsets, svuint32_t data) - /// ST1W Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] + /// void svst1_scatter_[u32]offset[_u32](svbool_t pg, uint32_t *base, svuint32_t offsets, svuint32_t data) + /// ST1W Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] /// public static unsafe void Scatter(Vector mask, uint* address, Vector indicies, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1_scatter_[s64]offset[_u64](svbool_t pg, uint64_t *base, svint64_t offsets, svuint64_t data) - /// ST1D Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1_scatter_[s64]offset[_u64](svbool_t pg, uint64_t *base, svint64_t offsets, svuint64_t data) + /// ST1D Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter(Vector mask, ulong* address, Vector indicies, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1_scatter[_u64base_u64](svbool_t pg, svuint64_t bases, svuint64_t data) - /// ST1D Zdata.D, Pg, [Zbases.D, #0] + /// void svst1_scatter[_u64base_u64](svbool_t pg, svuint64_t bases, svuint64_t data) + /// ST1D Zdata.D, Pg, [Zbases.D, #0] /// - public static unsafe void Scatter(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } + public static void Scatter(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1_scatter_[u64]offset[_u64](svbool_t pg, uint64_t *base, svuint64_t offsets, svuint64_t data) - /// ST1D Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1_scatter_[u64]offset[_u64](svbool_t pg, uint64_t *base, svuint64_t offsets, svuint64_t data) + /// ST1D Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter(Vector mask, ulong* address, Vector indicies, Vector data) { throw new PlatformNotSupportedException(); } @@ -7903,75 +8565,75 @@ internal Arm64() { } // ST1H Zdata.S, Pg, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe void Scatter16BitNarrowing(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } + // public static void Scatter16BitNarrowing(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1h_scatter[_u64base_s64](svbool_t pg, svuint64_t bases, svint64_t data) - /// ST1H Zdata.D, Pg, [Zbases.D, #0] + /// void svst1h_scatter[_u64base_s64](svbool_t pg, svuint64_t bases, svint64_t data) + /// ST1H Zdata.D, Pg, [Zbases.D, #0] /// - public static unsafe void Scatter16BitNarrowing(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } + public static void Scatter16BitNarrowing(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } // // void svst1h_scatter[_u32base_u32](svbool_t pg, svuint32_t bases, svuint32_t data) // ST1H Zdata.S, Pg, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe void Scatter16BitNarrowing(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } + // public static void Scatter16BitNarrowing(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1h_scatter[_u64base_u64](svbool_t pg, svuint64_t bases, svuint64_t data) - /// ST1H Zdata.D, Pg, [Zbases.D, #0] + /// void svst1h_scatter[_u64base_u64](svbool_t pg, svuint64_t bases, svuint64_t data) + /// ST1H Zdata.D, Pg, [Zbases.D, #0] /// - public static unsafe void Scatter16BitNarrowing(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } + public static void Scatter16BitNarrowing(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } // Truncate to 16 bits and store /// - /// void svst1h_scatter_[s32]offset[_s32](svbool_t pg, int16_t *base, svint32_t offsets, svint32_t data) - /// ST1H Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] + /// void svst1h_scatter_[s32]offset[_s32](svbool_t pg, int16_t *base, svint32_t offsets, svint32_t data) + /// ST1H Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] /// public static unsafe void Scatter16BitWithByteOffsetsNarrowing(Vector mask, short* address, Vector offsets, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1h_scatter_[u32]offset[_s32](svbool_t pg, int16_t *base, svuint32_t offsets, svint32_t data) - /// ST1H Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] + /// void svst1h_scatter_[u32]offset[_s32](svbool_t pg, int16_t *base, svuint32_t offsets, svint32_t data) + /// ST1H Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] /// public static unsafe void Scatter16BitWithByteOffsetsNarrowing(Vector mask, short* address, Vector offsets, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1h_scatter_[s64]offset[_s64](svbool_t pg, int16_t *base, svint64_t offsets, svint64_t data) - /// ST1H Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1h_scatter_[s64]offset[_s64](svbool_t pg, int16_t *base, svint64_t offsets, svint64_t data) + /// ST1H Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter16BitWithByteOffsetsNarrowing(Vector mask, short* address, Vector offsets, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1h_scatter_[u64]offset[_s64](svbool_t pg, int16_t *base, svuint64_t offsets, svint64_t data) - /// ST1H Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1h_scatter_[u64]offset[_s64](svbool_t pg, int16_t *base, svuint64_t offsets, svint64_t data) + /// ST1H Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter16BitWithByteOffsetsNarrowing(Vector mask, short* address, Vector offsets, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1h_scatter_[s32]offset[_u32](svbool_t pg, uint16_t *base, svint32_t offsets, svuint32_t data) - /// ST1H Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] + /// void svst1h_scatter_[s32]offset[_u32](svbool_t pg, uint16_t *base, svint32_t offsets, svuint32_t data) + /// ST1H Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] /// public static unsafe void Scatter16BitWithByteOffsetsNarrowing(Vector mask, ushort* address, Vector offsets, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1h_scatter_[u32]offset[_u32](svbool_t pg, uint16_t *base, svuint32_t offsets, svuint32_t data) - /// ST1H Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] + /// void svst1h_scatter_[u32]offset[_u32](svbool_t pg, uint16_t *base, svuint32_t offsets, svuint32_t data) + /// ST1H Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] /// public static unsafe void Scatter16BitWithByteOffsetsNarrowing(Vector mask, ushort* address, Vector offsets, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1h_scatter_[s64]offset[_u64](svbool_t pg, uint16_t *base, svint64_t offsets, svuint64_t data) - /// ST1H Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1h_scatter_[s64]offset[_u64](svbool_t pg, uint16_t *base, svint64_t offsets, svuint64_t data) + /// ST1H Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter16BitWithByteOffsetsNarrowing(Vector mask, ushort* address, Vector offsets, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1h_scatter_[u64]offset[_u64](svbool_t pg, uint16_t *base, svuint64_t offsets, svuint64_t data) - /// ST1H Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1h_scatter_[u64]offset[_u64](svbool_t pg, uint16_t *base, svuint64_t offsets, svuint64_t data) + /// ST1H Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter16BitWithByteOffsetsNarrowing(Vector mask, ushort* address, Vector offsets, Vector data) { throw new PlatformNotSupportedException(); } @@ -7979,41 +8641,41 @@ internal Arm64() { } // Truncate to 32 bits and store /// - /// void svst1w_scatter[_u64base_s64](svbool_t pg, svuint64_t bases, svint64_t data) - /// ST1W Zdata.D, Pg, [Zbases.D, #0] + /// void svst1w_scatter[_u64base_s64](svbool_t pg, svuint64_t bases, svint64_t data) + /// ST1W Zdata.D, Pg, [Zbases.D, #0] /// - public static unsafe void Scatter32BitNarrowing(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } + public static void Scatter32BitNarrowing(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1w_scatter[_u64base_u64](svbool_t pg, svuint64_t bases, svuint64_t data) - /// ST1W Zdata.D, Pg, [Zbases.D, #0] + /// void svst1w_scatter[_u64base_u64](svbool_t pg, svuint64_t bases, svuint64_t data) + /// ST1W Zdata.D, Pg, [Zbases.D, #0] /// - public static unsafe void Scatter32BitNarrowing(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } + public static void Scatter32BitNarrowing(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } // Truncate to 32 bits and store /// - /// void svst1w_scatter_[s64]offset[_s64](svbool_t pg, int32_t *base, svint64_t offsets, svint64_t data) - /// ST1W Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1w_scatter_[s64]offset[_s64](svbool_t pg, int32_t *base, svint64_t offsets, svint64_t data) + /// ST1W Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter32BitWithByteOffsetsNarrowing(Vector mask, int* address, Vector offsets, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1w_scatter_[u64]offset[_s64](svbool_t pg, int32_t *base, svuint64_t offsets, svint64_t data) - /// ST1W Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1w_scatter_[u64]offset[_s64](svbool_t pg, int32_t *base, svuint64_t offsets, svint64_t data) + /// ST1W Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter32BitWithByteOffsetsNarrowing(Vector mask, int* address, Vector offsets, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1w_scatter_[s64]offset[_u64](svbool_t pg, uint32_t *base, svint64_t offsets, svuint64_t data) - /// ST1W Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1w_scatter_[s64]offset[_u64](svbool_t pg, uint32_t *base, svint64_t offsets, svuint64_t data) + /// ST1W Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter32BitWithByteOffsetsNarrowing(Vector mask, uint* address, Vector offsets, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1w_scatter_[u64]offset[_u64](svbool_t pg, uint32_t *base, svuint64_t offsets, svuint64_t data) - /// ST1W Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1w_scatter_[u64]offset[_u64](svbool_t pg, uint32_t *base, svuint64_t offsets, svuint64_t data) + /// ST1W Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter32BitWithByteOffsetsNarrowing(Vector mask, uint* address, Vector offsets, Vector data) { throw new PlatformNotSupportedException(); } @@ -8025,75 +8687,75 @@ internal Arm64() { } // ST1B Zdata.S, Pg, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe void Scatter8BitNarrowing(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } + // public static void Scatter8BitNarrowing(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1b_scatter[_u64base_s64](svbool_t pg, svuint64_t bases, svint64_t data) - /// ST1B Zdata.D, Pg, [Zbases.D, #0] + /// void svst1b_scatter[_u64base_s64](svbool_t pg, svuint64_t bases, svint64_t data) + /// ST1B Zdata.D, Pg, [Zbases.D, #0] /// - public static unsafe void Scatter8BitNarrowing(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } + public static void Scatter8BitNarrowing(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } // // void svst1b_scatter[_u32base_u32](svbool_t pg, svuint32_t bases, svuint32_t data) // ST1B Zdata.S, Pg, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe void Scatter8BitNarrowing(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } + // public static void Scatter8BitNarrowing(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1b_scatter[_u64base_u64](svbool_t pg, svuint64_t bases, svuint64_t data) - /// ST1B Zdata.D, Pg, [Zbases.D, #0] + /// void svst1b_scatter[_u64base_u64](svbool_t pg, svuint64_t bases, svuint64_t data) + /// ST1B Zdata.D, Pg, [Zbases.D, #0] /// - public static unsafe void Scatter8BitNarrowing(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } + public static void Scatter8BitNarrowing(Vector mask, Vector addresses, Vector data) { throw new PlatformNotSupportedException(); } // Truncate to 8 bits and store /// - /// void svst1b_scatter_[s32]offset[_s32](svbool_t pg, int8_t *base, svint32_t offsets, svint32_t data) - /// ST1B Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] + /// void svst1b_scatter_[s32]offset[_s32](svbool_t pg, int8_t *base, svint32_t offsets, svint32_t data) + /// ST1B Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] /// public static unsafe void Scatter8BitWithByteOffsetsNarrowing(Vector mask, sbyte* address, Vector offsets, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1b_scatter_[u32]offset[_s32](svbool_t pg, int8_t *base, svuint32_t offsets, svint32_t data) - /// ST1B Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] + /// void svst1b_scatter_[u32]offset[_s32](svbool_t pg, int8_t *base, svuint32_t offsets, svint32_t data) + /// ST1B Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] /// public static unsafe void Scatter8BitWithByteOffsetsNarrowing(Vector mask, sbyte* address, Vector offsets, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1b_scatter_[s64]offset[_s64](svbool_t pg, int8_t *base, svint64_t offsets, svint64_t data) - /// ST1B Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1b_scatter_[s64]offset[_s64](svbool_t pg, int8_t *base, svint64_t offsets, svint64_t data) + /// ST1B Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter8BitWithByteOffsetsNarrowing(Vector mask, sbyte* address, Vector offsets, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1b_scatter_[u64]offset[_s64](svbool_t pg, int8_t *base, svuint64_t offsets, svint64_t data) - /// ST1B Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1b_scatter_[u64]offset[_s64](svbool_t pg, int8_t *base, svuint64_t offsets, svint64_t data) + /// ST1B Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter8BitWithByteOffsetsNarrowing(Vector mask, sbyte* address, Vector offsets, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1b_scatter_[s32]offset[_u32](svbool_t pg, uint8_t *base, svint32_t offsets, svuint32_t data) - /// ST1B Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] + /// void svst1b_scatter_[s32]offset[_u32](svbool_t pg, uint8_t *base, svint32_t offsets, svuint32_t data) + /// ST1B Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] /// public static unsafe void Scatter8BitWithByteOffsetsNarrowing(Vector mask, byte* address, Vector offsets, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1b_scatter_[u32]offset[_u32](svbool_t pg, uint8_t *base, svuint32_t offsets, svuint32_t data) - /// ST1B Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] + /// void svst1b_scatter_[u32]offset[_u32](svbool_t pg, uint8_t *base, svuint32_t offsets, svuint32_t data) + /// ST1B Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] /// public static unsafe void Scatter8BitWithByteOffsetsNarrowing(Vector mask, byte* address, Vector offsets, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1b_scatter_[s64]offset[_u64](svbool_t pg, uint8_t *base, svint64_t offsets, svuint64_t data) - /// ST1B Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1b_scatter_[s64]offset[_u64](svbool_t pg, uint8_t *base, svint64_t offsets, svuint64_t data) + /// ST1B Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter8BitWithByteOffsetsNarrowing(Vector mask, byte* address, Vector offsets, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1b_scatter_[u64]offset[_u64](svbool_t pg, uint8_t *base, svuint64_t offsets, svuint64_t data) - /// ST1B Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1b_scatter_[u64]offset[_u64](svbool_t pg, uint8_t *base, svuint64_t offsets, svuint64_t data) + /// ST1B Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter8BitWithByteOffsetsNarrowing(Vector mask, byte* address, Vector offsets, Vector data) { throw new PlatformNotSupportedException(); } @@ -8101,742 +8763,742 @@ internal Arm64() { } // Write to the first-fault register /// - /// void svwrffr(svbool_t op) - /// WRFFR Pop.B + /// void svwrffr(svbool_t op) + /// WRFFR Pop.B /// - public static unsafe void SetFfr(Vector value) { throw new PlatformNotSupportedException(); } + public static void SetFfr(Vector value) { throw new PlatformNotSupportedException(); } /// - /// void svwrffr(svbool_t op) - /// WRFFR Pop.B + /// void svwrffr(svbool_t op) + /// WRFFR Pop.B /// - public static unsafe void SetFfr(Vector value) { throw new PlatformNotSupportedException(); } + public static void SetFfr(Vector value) { throw new PlatformNotSupportedException(); } /// - /// void svwrffr(svbool_t op) - /// WRFFR Pop.B + /// void svwrffr(svbool_t op) + /// WRFFR Pop.B /// - public static unsafe void SetFfr(Vector value) { throw new PlatformNotSupportedException(); } + public static void SetFfr(Vector value) { throw new PlatformNotSupportedException(); } /// - /// void svwrffr(svbool_t op) - /// WRFFR Pop.B + /// void svwrffr(svbool_t op) + /// WRFFR Pop.B /// - public static unsafe void SetFfr(Vector value) { throw new PlatformNotSupportedException(); } + public static void SetFfr(Vector value) { throw new PlatformNotSupportedException(); } /// - /// void svwrffr(svbool_t op) - /// WRFFR Pop.B + /// void svwrffr(svbool_t op) + /// WRFFR Pop.B /// - public static unsafe void SetFfr(Vector value) { throw new PlatformNotSupportedException(); } + public static void SetFfr(Vector value) { throw new PlatformNotSupportedException(); } /// - /// void svwrffr(svbool_t op) - /// WRFFR Pop.B + /// void svwrffr(svbool_t op) + /// WRFFR Pop.B /// - public static unsafe void SetFfr(Vector value) { throw new PlatformNotSupportedException(); } + public static void SetFfr(Vector value) { throw new PlatformNotSupportedException(); } /// - /// void svwrffr(svbool_t op) - /// WRFFR Pop.B + /// void svwrffr(svbool_t op) + /// WRFFR Pop.B /// - public static unsafe void SetFfr(Vector value) { throw new PlatformNotSupportedException(); } + public static void SetFfr(Vector value) { throw new PlatformNotSupportedException(); } /// - /// void svwrffr(svbool_t op) - /// WRFFR Pop.B + /// void svwrffr(svbool_t op) + /// WRFFR Pop.B /// - public static unsafe void SetFfr(Vector value) { throw new PlatformNotSupportedException(); } + public static void SetFfr(Vector value) { throw new PlatformNotSupportedException(); } // Logical shift left /// - /// svuint8_t svlsl[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svlsl[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svlsl[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// LSL Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// svuint8_t svlsl[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svlsl[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svlsl[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// LSL Ztied1.B, Pg/M, Ztied1.B, Zop2.B /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint8_t svlsl_wide[_u8]_m(svbool_t pg, svuint8_t op1, svuint64_t op2) - /// svuint8_t svlsl_wide[_u8]_x(svbool_t pg, svuint8_t op1, svuint64_t op2) - /// LSL Ztied1.B, Pg/M, Ztied1.B, Zop2.D - /// LSL Zresult.B, Zop1.B, Zop2.D + /// svuint8_t svlsl_wide[_u8]_m(svbool_t pg, svuint8_t op1, svuint64_t op2) + /// svuint8_t svlsl_wide[_u8]_x(svbool_t pg, svuint8_t op1, svuint64_t op2) + /// LSL Ztied1.B, Pg/M, Ztied1.B, Zop2.D + /// LSL Zresult.B, Zop1.B, Zop2.D /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svlsl[_s16]_m(svbool_t pg, svint16_t op1, svuint16_t op2) - /// svint16_t svlsl[_s16]_x(svbool_t pg, svint16_t op1, svuint16_t op2) - /// svint16_t svlsl[_s16]_z(svbool_t pg, svint16_t op1, svuint16_t op2) - /// LSL Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// svint16_t svlsl[_s16]_m(svbool_t pg, svint16_t op1, svuint16_t op2) + /// svint16_t svlsl[_s16]_x(svbool_t pg, svint16_t op1, svuint16_t op2) + /// svint16_t svlsl[_s16]_z(svbool_t pg, svint16_t op1, svuint16_t op2) + /// LSL Ztied1.H, Pg/M, Ztied1.H, Zop2.H /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svlsl_wide[_s16]_m(svbool_t pg, svint16_t op1, svuint64_t op2) - /// svint16_t svlsl_wide[_s16]_x(svbool_t pg, svint16_t op1, svuint64_t op2) - /// svint16_t svlsl_wide[_s16]_z(svbool_t pg, svint16_t op1, svuint64_t op2) - /// LSL Ztied1.H, Pg/M, Ztied1.H, Zop2.D + /// svint16_t svlsl_wide[_s16]_m(svbool_t pg, svint16_t op1, svuint64_t op2) + /// svint16_t svlsl_wide[_s16]_x(svbool_t pg, svint16_t op1, svuint64_t op2) + /// svint16_t svlsl_wide[_s16]_z(svbool_t pg, svint16_t op1, svuint64_t op2) + /// LSL Ztied1.H, Pg/M, Ztied1.H, Zop2.D /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svlsl[_s32]_m(svbool_t pg, svint32_t op1, svuint32_t op2) - /// svint32_t svlsl[_s32]_x(svbool_t pg, svint32_t op1, svuint32_t op2) - /// svint32_t svlsl[_s32]_z(svbool_t pg, svint32_t op1, svuint32_t op2) - /// LSL Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svint32_t svlsl[_s32]_m(svbool_t pg, svint32_t op1, svuint32_t op2) + /// svint32_t svlsl[_s32]_x(svbool_t pg, svint32_t op1, svuint32_t op2) + /// svint32_t svlsl[_s32]_z(svbool_t pg, svint32_t op1, svuint32_t op2) + /// LSL Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svlsl_wide[_s32]_m(svbool_t pg, svint32_t op1, svuint64_t op2) - /// svint32_t svlsl_wide[_s32]_x(svbool_t pg, svint32_t op1, svuint64_t op2) - /// svint32_t svlsl_wide[_s32]_z(svbool_t pg, svint32_t op1, svuint64_t op2) - /// LSL Ztied1.S, Pg/M, Ztied1.S, Zop2.D + /// svint32_t svlsl_wide[_s32]_m(svbool_t pg, svint32_t op1, svuint64_t op2) + /// svint32_t svlsl_wide[_s32]_x(svbool_t pg, svint32_t op1, svuint64_t op2) + /// svint32_t svlsl_wide[_s32]_z(svbool_t pg, svint32_t op1, svuint64_t op2) + /// LSL Ztied1.S, Pg/M, Ztied1.S, Zop2.D /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svlsl[_s64]_m(svbool_t pg, svint64_t op1, svuint64_t op2) - /// svint64_t svlsl[_s64]_x(svbool_t pg, svint64_t op1, svuint64_t op2) - /// svint64_t svlsl[_s64]_z(svbool_t pg, svint64_t op1, svuint64_t op2) - /// LSL Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svint64_t svlsl[_s64]_m(svbool_t pg, svint64_t op1, svuint64_t op2) + /// svint64_t svlsl[_s64]_x(svbool_t pg, svint64_t op1, svuint64_t op2) + /// svint64_t svlsl[_s64]_z(svbool_t pg, svint64_t op1, svuint64_t op2) + /// LSL Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svlsl[_s8]_m(svbool_t pg, svint8_t op1, svuint8_t op2) - /// svint8_t svlsl[_s8]_x(svbool_t pg, svint8_t op1, svuint8_t op2) - /// svint8_t svlsl[_s8]_z(svbool_t pg, svint8_t op1, svuint8_t op2) - /// LSL Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// svint8_t svlsl[_s8]_m(svbool_t pg, svint8_t op1, svuint8_t op2) + /// svint8_t svlsl[_s8]_x(svbool_t pg, svint8_t op1, svuint8_t op2) + /// svint8_t svlsl[_s8]_z(svbool_t pg, svint8_t op1, svuint8_t op2) + /// LSL Ztied1.B, Pg/M, Ztied1.B, Zop2.B /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svlsl_wide[_s8]_m(svbool_t pg, svint8_t op1, svuint64_t op2) - /// svint8_t svlsl_wide[_s8]_x(svbool_t pg, svint8_t op1, svuint64_t op2) - /// svint8_t svlsl_wide[_s8]_z(svbool_t pg, svint8_t op1, svuint64_t op2) - /// LSL Ztied1.B, Pg/M, Ztied1.B, Zop2.D + /// svint8_t svlsl_wide[_s8]_m(svbool_t pg, svint8_t op1, svuint64_t op2) + /// svint8_t svlsl_wide[_s8]_x(svbool_t pg, svint8_t op1, svuint64_t op2) + /// svint8_t svlsl_wide[_s8]_z(svbool_t pg, svint8_t op1, svuint64_t op2) + /// LSL Ztied1.B, Pg/M, Ztied1.B, Zop2.D /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svlsl[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svlsl[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svlsl[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// LSL Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// svuint16_t svlsl[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svlsl[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svlsl[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// LSL Ztied1.H, Pg/M, Ztied1.H, Zop2.H /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svlsl_wide[_u16]_m(svbool_t pg, svuint16_t op1, svuint64_t op2) - /// svuint16_t svlsl_wide[_u16]_x(svbool_t pg, svuint16_t op1, svuint64_t op2) - /// svuint16_t svlsl_wide[_u16]_z(svbool_t pg, svuint16_t op1, svuint64_t op2) - /// LSL Ztied1.H, Pg/M, Ztied1.H, Zop2.D + /// svuint16_t svlsl_wide[_u16]_m(svbool_t pg, svuint16_t op1, svuint64_t op2) + /// svuint16_t svlsl_wide[_u16]_x(svbool_t pg, svuint16_t op1, svuint64_t op2) + /// svuint16_t svlsl_wide[_u16]_z(svbool_t pg, svuint16_t op1, svuint64_t op2) + /// LSL Ztied1.H, Pg/M, Ztied1.H, Zop2.D /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svlsl[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svlsl[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svlsl[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// LSL Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svuint32_t svlsl[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svlsl[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svlsl[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// LSL Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svlsl_wide[_u32]_m(svbool_t pg, svuint32_t op1, svuint64_t op2) - /// svuint32_t svlsl_wide[_u32]_x(svbool_t pg, svuint32_t op1, svuint64_t op2) - /// svuint32_t svlsl_wide[_u32]_z(svbool_t pg, svuint32_t op1, svuint64_t op2) - /// LSL Ztied1.S, Pg/M, Ztied1.S, Zop2.D + /// svuint32_t svlsl_wide[_u32]_m(svbool_t pg, svuint32_t op1, svuint64_t op2) + /// svuint32_t svlsl_wide[_u32]_x(svbool_t pg, svuint32_t op1, svuint64_t op2) + /// svuint32_t svlsl_wide[_u32]_z(svbool_t pg, svuint32_t op1, svuint64_t op2) + /// LSL Ztied1.S, Pg/M, Ztied1.S, Zop2.D /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svlsl[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svlsl[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svlsl[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// LSL Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svuint64_t svlsl[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svlsl[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svlsl[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// LSL Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftLeftLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Arithmetic shift right /// - /// svint16_t svasr[_s16]_m(svbool_t pg, svint16_t op1, svuint16_t op2) - /// svint16_t svasr[_s16]_x(svbool_t pg, svint16_t op1, svuint16_t op2) - /// svint16_t svasr[_s16]_z(svbool_t pg, svint16_t op1, svuint16_t op2) - /// ASR Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// svint16_t svasr[_s16]_m(svbool_t pg, svint16_t op1, svuint16_t op2) + /// svint16_t svasr[_s16]_x(svbool_t pg, svint16_t op1, svuint16_t op2) + /// svint16_t svasr[_s16]_z(svbool_t pg, svint16_t op1, svuint16_t op2) + /// ASR Ztied1.H, Pg/M, Ztied1.H, Zop2.H /// - public static unsafe Vector ShiftRightArithmetic(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftRightArithmetic(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svasr_wide[_s16]_m(svbool_t pg, svint16_t op1, svuint64_t op2) - /// svint16_t svasr_wide[_s16]_x(svbool_t pg, svint16_t op1, svuint64_t op2) - /// svint16_t svasr_wide[_s16]_z(svbool_t pg, svint16_t op1, svuint64_t op2) - /// ASR Ztied1.H, Pg/M, Ztied1.H, Zop2.D + /// svint16_t svasr_wide[_s16]_m(svbool_t pg, svint16_t op1, svuint64_t op2) + /// svint16_t svasr_wide[_s16]_x(svbool_t pg, svint16_t op1, svuint64_t op2) + /// svint16_t svasr_wide[_s16]_z(svbool_t pg, svint16_t op1, svuint64_t op2) + /// ASR Ztied1.H, Pg/M, Ztied1.H, Zop2.D /// - public static unsafe Vector ShiftRightArithmetic(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftRightArithmetic(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svasr[_s32]_m(svbool_t pg, svint32_t op1, svuint32_t op2) - /// svint32_t svasr[_s32]_x(svbool_t pg, svint32_t op1, svuint32_t op2) - /// svint32_t svasr[_s32]_z(svbool_t pg, svint32_t op1, svuint32_t op2) - /// ASR Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svint32_t svasr[_s32]_m(svbool_t pg, svint32_t op1, svuint32_t op2) + /// svint32_t svasr[_s32]_x(svbool_t pg, svint32_t op1, svuint32_t op2) + /// svint32_t svasr[_s32]_z(svbool_t pg, svint32_t op1, svuint32_t op2) + /// ASR Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector ShiftRightArithmetic(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftRightArithmetic(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svasr_wide[_s32]_m(svbool_t pg, svint32_t op1, svuint64_t op2) - /// svint32_t svasr_wide[_s32]_x(svbool_t pg, svint32_t op1, svuint64_t op2) - /// svint32_t svasr_wide[_s32]_z(svbool_t pg, svint32_t op1, svuint64_t op2) - /// ASR Ztied1.S, Pg/M, Ztied1.S, Zop2.D + /// svint32_t svasr_wide[_s32]_m(svbool_t pg, svint32_t op1, svuint64_t op2) + /// svint32_t svasr_wide[_s32]_x(svbool_t pg, svint32_t op1, svuint64_t op2) + /// svint32_t svasr_wide[_s32]_z(svbool_t pg, svint32_t op1, svuint64_t op2) + /// ASR Ztied1.S, Pg/M, Ztied1.S, Zop2.D /// - public static unsafe Vector ShiftRightArithmetic(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftRightArithmetic(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svasr[_s64]_m(svbool_t pg, svint64_t op1, svuint64_t op2) - /// svint64_t svasr[_s64]_x(svbool_t pg, svint64_t op1, svuint64_t op2) - /// svint64_t svasr[_s64]_z(svbool_t pg, svint64_t op1, svuint64_t op2) - /// ASR Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svint64_t svasr[_s64]_m(svbool_t pg, svint64_t op1, svuint64_t op2) + /// svint64_t svasr[_s64]_x(svbool_t pg, svint64_t op1, svuint64_t op2) + /// svint64_t svasr[_s64]_z(svbool_t pg, svint64_t op1, svuint64_t op2) + /// ASR Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector ShiftRightArithmetic(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftRightArithmetic(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svasr[_s8]_m(svbool_t pg, svint8_t op1, svuint8_t op2) - /// svint8_t svasr[_s8]_x(svbool_t pg, svint8_t op1, svuint8_t op2) - /// svint8_t svasr[_s8]_z(svbool_t pg, svint8_t op1, svuint8_t op2) - /// ASR Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// svint8_t svasr[_s8]_m(svbool_t pg, svint8_t op1, svuint8_t op2) + /// svint8_t svasr[_s8]_x(svbool_t pg, svint8_t op1, svuint8_t op2) + /// svint8_t svasr[_s8]_z(svbool_t pg, svint8_t op1, svuint8_t op2) + /// ASR Ztied1.B, Pg/M, Ztied1.B, Zop2.B /// - public static unsafe Vector ShiftRightArithmetic(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftRightArithmetic(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svasr_wide[_s8]_m(svbool_t pg, svint8_t op1, svuint64_t op2) - /// svint8_t svasr_wide[_s8]_x(svbool_t pg, svint8_t op1, svuint64_t op2) - /// svint8_t svasr_wide[_s8]_z(svbool_t pg, svint8_t op1, svuint64_t op2) - /// ASR Ztied1.B, Pg/M, Ztied1.B, Zop2.D + /// svint8_t svasr_wide[_s8]_m(svbool_t pg, svint8_t op1, svuint64_t op2) + /// svint8_t svasr_wide[_s8]_x(svbool_t pg, svint8_t op1, svuint64_t op2) + /// svint8_t svasr_wide[_s8]_z(svbool_t pg, svint8_t op1, svuint64_t op2) + /// ASR Ztied1.B, Pg/M, Ztied1.B, Zop2.D /// - public static unsafe Vector ShiftRightArithmetic(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftRightArithmetic(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Arithmetic shift right for divide by immediate /// - /// svint16_t svasrd[_n_s16]_m(svbool_t pg, svint16_t op1, uint64_t imm2) - /// svint16_t svasrd[_n_s16]_x(svbool_t pg, svint16_t op1, uint64_t imm2) - /// svint16_t svasrd[_n_s16]_z(svbool_t pg, svint16_t op1, uint64_t imm2) - /// ASRD Ztied1.H, Pg/M, Ztied1.H, #imm2 + /// svint16_t svasrd[_n_s16]_m(svbool_t pg, svint16_t op1, uint64_t imm2) + /// svint16_t svasrd[_n_s16]_x(svbool_t pg, svint16_t op1, uint64_t imm2) + /// svint16_t svasrd[_n_s16]_z(svbool_t pg, svint16_t op1, uint64_t imm2) + /// ASRD Ztied1.H, Pg/M, Ztied1.H, #imm2 /// - public static unsafe Vector ShiftRightArithmeticForDivide(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte control) { throw new PlatformNotSupportedException(); } + public static Vector ShiftRightArithmeticForDivide(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte control) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svasrd[_n_s32]_m(svbool_t pg, svint32_t op1, uint64_t imm2) - /// svint32_t svasrd[_n_s32]_x(svbool_t pg, svint32_t op1, uint64_t imm2) - /// svint32_t svasrd[_n_s32]_z(svbool_t pg, svint32_t op1, uint64_t imm2) - /// ASRD Ztied1.S, Pg/M, Ztied1.S, #imm2 + /// svint32_t svasrd[_n_s32]_m(svbool_t pg, svint32_t op1, uint64_t imm2) + /// svint32_t svasrd[_n_s32]_x(svbool_t pg, svint32_t op1, uint64_t imm2) + /// svint32_t svasrd[_n_s32]_z(svbool_t pg, svint32_t op1, uint64_t imm2) + /// ASRD Ztied1.S, Pg/M, Ztied1.S, #imm2 /// - public static unsafe Vector ShiftRightArithmeticForDivide(Vector value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte control) { throw new PlatformNotSupportedException(); } + public static Vector ShiftRightArithmeticForDivide(Vector value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte control) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svasrd[_n_s64]_m(svbool_t pg, svint64_t op1, uint64_t imm2) - /// svint64_t svasrd[_n_s64]_x(svbool_t pg, svint64_t op1, uint64_t imm2) - /// svint64_t svasrd[_n_s64]_z(svbool_t pg, svint64_t op1, uint64_t imm2) - /// ASRD Ztied1.D, Pg/M, Ztied1.D, #imm2 + /// svint64_t svasrd[_n_s64]_m(svbool_t pg, svint64_t op1, uint64_t imm2) + /// svint64_t svasrd[_n_s64]_x(svbool_t pg, svint64_t op1, uint64_t imm2) + /// svint64_t svasrd[_n_s64]_z(svbool_t pg, svint64_t op1, uint64_t imm2) + /// ASRD Ztied1.D, Pg/M, Ztied1.D, #imm2 /// - public static unsafe Vector ShiftRightArithmeticForDivide(Vector value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte control) { throw new PlatformNotSupportedException(); } + public static Vector ShiftRightArithmeticForDivide(Vector value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte control) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svasrd[_n_s8]_m(svbool_t pg, svint8_t op1, uint64_t imm2) - /// svint8_t svasrd[_n_s8]_x(svbool_t pg, svint8_t op1, uint64_t imm2) - /// svint8_t svasrd[_n_s8]_z(svbool_t pg, svint8_t op1, uint64_t imm2) - /// ASRD Ztied1.B, Pg/M, Ztied1.B, #imm2 + /// svint8_t svasrd[_n_s8]_m(svbool_t pg, svint8_t op1, uint64_t imm2) + /// svint8_t svasrd[_n_s8]_x(svbool_t pg, svint8_t op1, uint64_t imm2) + /// svint8_t svasrd[_n_s8]_z(svbool_t pg, svint8_t op1, uint64_t imm2) + /// ASRD Ztied1.B, Pg/M, Ztied1.B, #imm2 /// - public static unsafe Vector ShiftRightArithmeticForDivide(Vector value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte control) { throw new PlatformNotSupportedException(); } + public static Vector ShiftRightArithmeticForDivide(Vector value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte control) { throw new PlatformNotSupportedException(); } // Logical shift right /// - /// svuint8_t svlsr[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svlsr[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svlsr[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// LSR Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// svuint8_t svlsr[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svlsr[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svlsr[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// LSR Ztied1.B, Pg/M, Ztied1.B, Zop2.B /// - public static unsafe Vector ShiftRightLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftRightLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint8_t svlsr_wide[_u8]_m(svbool_t pg, svuint8_t op1, svuint64_t op2) - /// svuint8_t svlsr_wide[_u8]_x(svbool_t pg, svuint8_t op1, svuint64_t op2) - /// svuint8_t svlsr_wide[_u8]_z(svbool_t pg, svuint8_t op1, svuint64_t op2) - /// LSR Ztied1.B, Pg/M, Ztied1.B, Zop2.D + /// svuint8_t svlsr_wide[_u8]_m(svbool_t pg, svuint8_t op1, svuint64_t op2) + /// svuint8_t svlsr_wide[_u8]_x(svbool_t pg, svuint8_t op1, svuint64_t op2) + /// svuint8_t svlsr_wide[_u8]_z(svbool_t pg, svuint8_t op1, svuint64_t op2) + /// LSR Ztied1.B, Pg/M, Ztied1.B, Zop2.D /// - public static unsafe Vector ShiftRightLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftRightLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svlsr[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svlsr[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svlsr[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// LSR Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// svuint16_t svlsr[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svlsr[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svlsr[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// LSR Ztied1.H, Pg/M, Ztied1.H, Zop2.H /// - public static unsafe Vector ShiftRightLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftRightLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svlsr_wide[_u16]_m(svbool_t pg, svuint16_t op1, svuint64_t op2) - /// svuint16_t svlsr_wide[_u16]_x(svbool_t pg, svuint16_t op1, svuint64_t op2) - /// svuint16_t svlsr_wide[_u16]_z(svbool_t pg, svuint16_t op1, svuint64_t op2) - /// LSR Ztied1.H, Pg/M, Ztied1.H, Zop2.D + /// svuint16_t svlsr_wide[_u16]_m(svbool_t pg, svuint16_t op1, svuint64_t op2) + /// svuint16_t svlsr_wide[_u16]_x(svbool_t pg, svuint16_t op1, svuint64_t op2) + /// svuint16_t svlsr_wide[_u16]_z(svbool_t pg, svuint16_t op1, svuint64_t op2) + /// LSR Ztied1.H, Pg/M, Ztied1.H, Zop2.D /// - public static unsafe Vector ShiftRightLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftRightLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svlsr[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svlsr[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svlsr[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// LSR Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svuint32_t svlsr[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svlsr[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svlsr[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// LSR Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector ShiftRightLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftRightLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svlsr_wide[_u32]_m(svbool_t pg, svuint32_t op1, svuint64_t op2) - /// svuint32_t svlsr_wide[_u32]_x(svbool_t pg, svuint32_t op1, svuint64_t op2) - /// svuint32_t svlsr_wide[_u32]_z(svbool_t pg, svuint32_t op1, svuint64_t op2) - /// LSR Ztied1.S, Pg/M, Ztied1.S, Zop2.D + /// svuint32_t svlsr_wide[_u32]_m(svbool_t pg, svuint32_t op1, svuint64_t op2) + /// svuint32_t svlsr_wide[_u32]_x(svbool_t pg, svuint32_t op1, svuint64_t op2) + /// svuint32_t svlsr_wide[_u32]_z(svbool_t pg, svuint32_t op1, svuint64_t op2) + /// LSR Ztied1.S, Pg/M, Ztied1.S, Zop2.D /// - public static unsafe Vector ShiftRightLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftRightLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svlsr[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svlsr[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svlsr[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// LSR Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svuint64_t svlsr[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svlsr[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svlsr[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// LSR Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector ShiftRightLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ShiftRightLogical(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Sign-extend the low 16 bits /// - /// svint32_t svexth[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) - /// svint32_t svexth[_s32]_x(svbool_t pg, svint32_t op) - /// svint32_t svexth[_s32]_z(svbool_t pg, svint32_t op) - /// SXTH Zresult.S, Pg/M, Zop.S + /// svint32_t svexth[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) + /// svint32_t svexth[_s32]_x(svbool_t pg, svint32_t op) + /// svint32_t svexth[_s32]_z(svbool_t pg, svint32_t op) + /// SXTH Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector SignExtend16(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector SignExtend16(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svexth[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) - /// svint64_t svexth[_s64]_x(svbool_t pg, svint64_t op) - /// svint64_t svexth[_s64]_z(svbool_t pg, svint64_t op) - /// SXTH Zresult.D, Pg/M, Zop.D + /// svint64_t svexth[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) + /// svint64_t svexth[_s64]_x(svbool_t pg, svint64_t op) + /// svint64_t svexth[_s64]_z(svbool_t pg, svint64_t op) + /// SXTH Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector SignExtend16(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector SignExtend16(Vector value) { throw new PlatformNotSupportedException(); } // Sign-extend the low 32 bits /// - /// svint64_t svextw[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) - /// svint64_t svextw[_s64]_x(svbool_t pg, svint64_t op) - /// svint64_t svextw[_s64]_z(svbool_t pg, svint64_t op) - /// SXTW Zresult.D, Pg/M, Zop.D + /// svint64_t svextw[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) + /// svint64_t svextw[_s64]_x(svbool_t pg, svint64_t op) + /// svint64_t svextw[_s64]_z(svbool_t pg, svint64_t op) + /// SXTW Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector SignExtend32(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector SignExtend32(Vector value) { throw new PlatformNotSupportedException(); } // Sign-extend the low 8 bits /// - /// svint16_t svextb[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) - /// svint16_t svextb[_s16]_x(svbool_t pg, svint16_t op) - /// svint16_t svextb[_s16]_z(svbool_t pg, svint16_t op) - /// SXTB Zresult.H, Pg/M, Zop.H + /// svint16_t svextb[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) + /// svint16_t svextb[_s16]_x(svbool_t pg, svint16_t op) + /// svint16_t svextb[_s16]_z(svbool_t pg, svint16_t op) + /// SXTB Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector SignExtend8(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector SignExtend8(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svextb[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) - /// svint32_t svextb[_s32]_x(svbool_t pg, svint32_t op) - /// svint32_t svextb[_s32]_z(svbool_t pg, svint32_t op) - /// SXTB Zresult.S, Pg/M, Zop.S + /// svint32_t svextb[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) + /// svint32_t svextb[_s32]_x(svbool_t pg, svint32_t op) + /// svint32_t svextb[_s32]_z(svbool_t pg, svint32_t op) + /// SXTB Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector SignExtend8(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector SignExtend8(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svextb[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) - /// svint64_t svextb[_s64]_x(svbool_t pg, svint64_t op) - /// svint64_t svextb[_s64]_z(svbool_t pg, svint64_t op) - /// SXTB Zresult.D, Pg/M, Zop.D + /// svint64_t svextb[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) + /// svint64_t svextb[_s64]_x(svbool_t pg, svint64_t op) + /// svint64_t svextb[_s64]_z(svbool_t pg, svint64_t op) + /// SXTB Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector SignExtend8(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector SignExtend8(Vector value) { throw new PlatformNotSupportedException(); } // Unpack and extend low half /// - /// svint16_t svunpklo[_s16](svint8_t op) - /// SUNPKLO Zresult.H, Zop.B + /// svint16_t svunpklo[_s16](svint8_t op) + /// SUNPKLO Zresult.H, Zop.B /// - public static unsafe Vector SignExtendWideningLower(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector SignExtendWideningLower(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svunpklo[_s32](svint16_t op) - /// SUNPKLO Zresult.S, Zop.H + /// svint32_t svunpklo[_s32](svint16_t op) + /// SUNPKLO Zresult.S, Zop.H /// - public static unsafe Vector SignExtendWideningLower(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector SignExtendWideningLower(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svunpklo[_s64](svint32_t op) - /// SUNPKLO Zresult.D, Zop.S + /// svint64_t svunpklo[_s64](svint32_t op) + /// SUNPKLO Zresult.D, Zop.S /// - public static unsafe Vector SignExtendWideningLower(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector SignExtendWideningLower(Vector value) { throw new PlatformNotSupportedException(); } // Unpack and extend high half /// - /// svint16_t svunpkhi[_s16](svint8_t op) - /// SUNPKHI Zresult.H, Zop.B + /// svint16_t svunpkhi[_s16](svint8_t op) + /// SUNPKHI Zresult.H, Zop.B /// - public static unsafe Vector SignExtendWideningUpper(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector SignExtendWideningUpper(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svunpkhi[_s32](svint16_t op) - /// SUNPKHI Zresult.S, Zop.H + /// svint32_t svunpkhi[_s32](svint16_t op) + /// SUNPKHI Zresult.S, Zop.H /// - public static unsafe Vector SignExtendWideningUpper(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector SignExtendWideningUpper(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svunpkhi[_s64](svint32_t op) - /// SUNPKHI Zresult.D, Zop.S + /// svint64_t svunpkhi[_s64](svint32_t op) + /// SUNPKHI Zresult.D, Zop.S /// - public static unsafe Vector SignExtendWideningUpper(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector SignExtendWideningUpper(Vector value) { throw new PlatformNotSupportedException(); } // Splice two vectors under predicate control /// - /// svuint8_t svsplice[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) - /// SPLICE Ztied1.B, Pg, Ztied1.B, Zop2.B + /// svuint8_t svsplice[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) + /// SPLICE Ztied1.B, Pg, Ztied1.B, Zop2.B /// - public static unsafe Vector Splice(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Splice(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svsplice[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// SPLICE Ztied1.D, Pg, Ztied1.D, Zop2.D + /// svfloat64_t svsplice[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// SPLICE Ztied1.D, Pg, Ztied1.D, Zop2.D /// - public static unsafe Vector Splice(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Splice(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svsplice[_s16](svbool_t pg, svint16_t op1, svint16_t op2) - /// SPLICE Ztied1.H, Pg, Ztied1.H, Zop2.H + /// svint16_t svsplice[_s16](svbool_t pg, svint16_t op1, svint16_t op2) + /// SPLICE Ztied1.H, Pg, Ztied1.H, Zop2.H /// - public static unsafe Vector Splice(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Splice(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svsplice[_s32](svbool_t pg, svint32_t op1, svint32_t op2) - /// SPLICE Ztied1.S, Pg, Ztied1.S, Zop2.S + /// svint32_t svsplice[_s32](svbool_t pg, svint32_t op1, svint32_t op2) + /// SPLICE Ztied1.S, Pg, Ztied1.S, Zop2.S /// - public static unsafe Vector Splice(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Splice(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svsplice[_s64](svbool_t pg, svint64_t op1, svint64_t op2) - /// SPLICE Ztied1.D, Pg, Ztied1.D, Zop2.D + /// svint64_t svsplice[_s64](svbool_t pg, svint64_t op1, svint64_t op2) + /// SPLICE Ztied1.D, Pg, Ztied1.D, Zop2.D /// - public static unsafe Vector Splice(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Splice(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svsplice[_s8](svbool_t pg, svint8_t op1, svint8_t op2) - /// SPLICE Ztied1.B, Pg, Ztied1.B, Zop2.B + /// svint8_t svsplice[_s8](svbool_t pg, svint8_t op1, svint8_t op2) + /// SPLICE Ztied1.B, Pg, Ztied1.B, Zop2.B /// - public static unsafe Vector Splice(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Splice(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svsplice[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// SPLICE Ztied1.S, Pg, Ztied1.S, Zop2.S + /// svfloat32_t svsplice[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// SPLICE Ztied1.S, Pg, Ztied1.S, Zop2.S /// - public static unsafe Vector Splice(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Splice(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svsplice[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) - /// SPLICE Ztied1.H, Pg, Ztied1.H, Zop2.H + /// svuint16_t svsplice[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) + /// SPLICE Ztied1.H, Pg, Ztied1.H, Zop2.H /// - public static unsafe Vector Splice(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Splice(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svsplice[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) - /// SPLICE Ztied1.S, Pg, Ztied1.S, Zop2.S + /// svuint32_t svsplice[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) + /// SPLICE Ztied1.S, Pg, Ztied1.S, Zop2.S /// - public static unsafe Vector Splice(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Splice(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svsplice[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) - /// SPLICE Ztied1.D, Pg, Ztied1.D, Zop2.D + /// svuint64_t svsplice[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) + /// SPLICE Ztied1.D, Pg, Ztied1.D, Zop2.D /// - public static unsafe Vector Splice(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Splice(Vector mask, Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Square root /// - /// svfloat64_t svsqrt[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) - /// svfloat64_t svsqrt[_f64]_x(svbool_t pg, svfloat64_t op) - /// svfloat64_t svsqrt[_f64]_z(svbool_t pg, svfloat64_t op) - /// FSQRT Zresult.D, Pg/M, Zop.D + /// svfloat64_t svsqrt[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) + /// svfloat64_t svsqrt[_f64]_x(svbool_t pg, svfloat64_t op) + /// svfloat64_t svsqrt[_f64]_z(svbool_t pg, svfloat64_t op) + /// FSQRT Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector Sqrt(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Sqrt(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svsqrt[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) - /// svfloat32_t svsqrt[_f32]_x(svbool_t pg, svfloat32_t op) - /// svfloat32_t svsqrt[_f32]_z(svbool_t pg, svfloat32_t op) - /// FSQRT Zresult.S, Pg/M, Zop.S + /// svfloat32_t svsqrt[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) + /// svfloat32_t svsqrt[_f32]_x(svbool_t pg, svfloat32_t op) + /// svfloat32_t svsqrt[_f32]_z(svbool_t pg, svfloat32_t op) + /// FSQRT Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector Sqrt(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector Sqrt(Vector value) { throw new PlatformNotSupportedException(); } // Non-truncating store /// - /// void svst1[_u8](svbool_t pg, uint8_t *base, svuint8_t data) - /// ST1B Zdata.B, Pg, [Xbase, #0, MUL VL] + /// void svst1[_u8](svbool_t pg, uint8_t *base, svuint8_t data) + /// ST1B Zdata.B, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, byte* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst2[_u8](svbool_t pg, uint8_t *base, svuint8x2_t data) - /// ST2B {Zdata0.B, Zdata1.B}, Pg, [Xbase, #0, MUL VL] + /// void svst2[_u8](svbool_t pg, uint8_t *base, svuint8x2_t data) + /// ST2B {Zdata0.B, Zdata1.B}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, byte* address, (Vector Value1, Vector Value2) data) { throw new PlatformNotSupportedException(); } /// - /// void svst3[_u8](svbool_t pg, uint8_t *base, svuint8x3_t data) - /// ST3B {Zdata0.B - Zdata2.B}, Pg, [Xbase, #0, MUL VL] + /// void svst3[_u8](svbool_t pg, uint8_t *base, svuint8x3_t data) + /// ST3B {Zdata0.B - Zdata2.B}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, byte* address, (Vector Value1, Vector Value2, Vector Value3) data) { throw new PlatformNotSupportedException(); } /// - /// void svst4[_u8](svbool_t pg, uint8_t *base, svuint8x4_t data) - /// ST4B {Zdata0.B - Zdata3.B}, Pg, [Xbase, #0, MUL VL] + /// void svst4[_u8](svbool_t pg, uint8_t *base, svuint8x4_t data) + /// ST4B {Zdata0.B - Zdata3.B}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, byte* address, (Vector Value1, Vector Value2, Vector Value3, Vector Value4) data) { throw new PlatformNotSupportedException(); } /// - /// void svst1[_f64](svbool_t pg, float64_t *base, svfloat64_t data) - /// ST1D Zdata.D, Pg, [Xbase, #0, MUL VL] + /// void svst1[_f64](svbool_t pg, float64_t *base, svfloat64_t data) + /// ST1D Zdata.D, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, double* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst2[_f64](svbool_t pg, float64_t *base, svfloat64x2_t data) - /// ST2D {Zdata0.D, Zdata1.D}, Pg, [Xbase, #0, MUL VL] + /// void svst2[_f64](svbool_t pg, float64_t *base, svfloat64x2_t data) + /// ST2D {Zdata0.D, Zdata1.D}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, double* address, (Vector Value1, Vector Value2) data) { throw new PlatformNotSupportedException(); } /// - /// void svst3[_f64](svbool_t pg, float64_t *base, svfloat64x3_t data) - /// ST3D {Zdata0.D - Zdata2.D}, Pg, [Xbase, #0, MUL VL] + /// void svst3[_f64](svbool_t pg, float64_t *base, svfloat64x3_t data) + /// ST3D {Zdata0.D - Zdata2.D}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, double* address, (Vector Value1, Vector Value2, Vector Value3) data) { throw new PlatformNotSupportedException(); } /// - /// void svst4[_f64](svbool_t pg, float64_t *base, svfloat64x4_t data) - /// ST4D {Zdata0.D - Zdata3.D}, Pg, [Xbase, #0, MUL VL] + /// void svst4[_f64](svbool_t pg, float64_t *base, svfloat64x4_t data) + /// ST4D {Zdata0.D - Zdata3.D}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, double* address, (Vector Value1, Vector Value2, Vector Value3, Vector Value4) data) { throw new PlatformNotSupportedException(); } /// - /// void svst1[_s16](svbool_t pg, int16_t *base, svint16_t data) - /// ST1H Zdata.H, Pg, [Xbase, #0, MUL VL] + /// void svst1[_s16](svbool_t pg, int16_t *base, svint16_t data) + /// ST1H Zdata.H, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, short* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst2[_s16](svbool_t pg, int16_t *base, svint16x2_t data) - /// ST2H {Zdata0.H, Zdata1.H}, Pg, [Xbase, #0, MUL VL] + /// void svst2[_s16](svbool_t pg, int16_t *base, svint16x2_t data) + /// ST2H {Zdata0.H, Zdata1.H}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, short* address, (Vector Value1, Vector Value2) data) { throw new PlatformNotSupportedException(); } /// - /// void svst3[_s16](svbool_t pg, int16_t *base, svint16x3_t data) - /// ST3H {Zdata0.H - Zdata2.H}, Pg, [Xbase, #0, MUL VL] + /// void svst3[_s16](svbool_t pg, int16_t *base, svint16x3_t data) + /// ST3H {Zdata0.H - Zdata2.H}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, short* address, (Vector Value1, Vector Value2, Vector Value3) data) { throw new PlatformNotSupportedException(); } /// - /// void svst4[_s16](svbool_t pg, int16_t *base, svint16x4_t data) - /// ST4H {Zdata0.H - Zdata3.H}, Pg, [Xbase, #0, MUL VL] + /// void svst4[_s16](svbool_t pg, int16_t *base, svint16x4_t data) + /// ST4H {Zdata0.H - Zdata3.H}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, short* address, (Vector Value1, Vector Value2, Vector Value3, Vector Value4) data) { throw new PlatformNotSupportedException(); } /// - /// void svst1[_s32](svbool_t pg, int32_t *base, svint32_t data) - /// ST1W Zdata.S, Pg, [Xbase, #0, MUL VL] + /// void svst1[_s32](svbool_t pg, int32_t *base, svint32_t data) + /// ST1W Zdata.S, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, int* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst2[_s32](svbool_t pg, int32_t *base, svint32x2_t data) - /// ST2W {Zdata0.S, Zdata1.S}, Pg, [Xbase, #0, MUL VL] + /// void svst2[_s32](svbool_t pg, int32_t *base, svint32x2_t data) + /// ST2W {Zdata0.S, Zdata1.S}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, int* address, (Vector Value1, Vector Value2) data) { throw new PlatformNotSupportedException(); } /// - /// void svst3[_s32](svbool_t pg, int32_t *base, svint32x3_t data) - /// ST3W {Zdata0.S - Zdata2.S}, Pg, [Xbase, #0, MUL VL] + /// void svst3[_s32](svbool_t pg, int32_t *base, svint32x3_t data) + /// ST3W {Zdata0.S - Zdata2.S}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, int* address, (Vector Value1, Vector Value2, Vector Value3) data) { throw new PlatformNotSupportedException(); } /// - /// void svst4[_s32](svbool_t pg, int32_t *base, svint32x4_t data) - /// ST4W {Zdata0.S - Zdata3.S}, Pg, [Xbase, #0, MUL VL] + /// void svst4[_s32](svbool_t pg, int32_t *base, svint32x4_t data) + /// ST4W {Zdata0.S - Zdata3.S}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, int* address, (Vector Value1, Vector Value2, Vector Value3, Vector Value4) data) { throw new PlatformNotSupportedException(); } /// - /// void svst1[_s64](svbool_t pg, int64_t *base, svint64_t data) - /// ST1D Zdata.D, Pg, [Xbase, #0, MUL VL] + /// void svst1[_s64](svbool_t pg, int64_t *base, svint64_t data) + /// ST1D Zdata.D, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, long* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst2[_s64](svbool_t pg, int64_t *base, svint64x2_t data) - /// ST2D {Zdata0.D, Zdata1.D}, Pg, [Xbase, #0, MUL VL] + /// void svst2[_s64](svbool_t pg, int64_t *base, svint64x2_t data) + /// ST2D {Zdata0.D, Zdata1.D}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, long* address, (Vector Value1, Vector Value2) data) { throw new PlatformNotSupportedException(); } /// - /// void svst3[_s64](svbool_t pg, int64_t *base, svint64x3_t data) - /// ST3D {Zdata0.D - Zdata2.D}, Pg, [Xbase, #0, MUL VL] + /// void svst3[_s64](svbool_t pg, int64_t *base, svint64x3_t data) + /// ST3D {Zdata0.D - Zdata2.D}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, long* address, (Vector Value1, Vector Value2, Vector Value3) data) { throw new PlatformNotSupportedException(); } /// - /// void svst4[_s64](svbool_t pg, int64_t *base, svint64x4_t data) - /// ST4D {Zdata0.D - Zdata3.D}, Pg, [Xbase, #0, MUL VL] + /// void svst4[_s64](svbool_t pg, int64_t *base, svint64x4_t data) + /// ST4D {Zdata0.D - Zdata3.D}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, long* address, (Vector Value1, Vector Value2, Vector Value3, Vector Value4) data) { throw new PlatformNotSupportedException(); } /// - /// void svst1[_s8](svbool_t pg, int8_t *base, svint8_t data) - /// ST1B Zdata.B, Pg, [Xbase, #0, MUL VL] + /// void svst1[_s8](svbool_t pg, int8_t *base, svint8_t data) + /// ST1B Zdata.B, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, sbyte* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst2[_s8](svbool_t pg, int8_t *base, svint8x2_t data) - /// ST2B {Zdata0.B, Zdata1.B}, Pg, [Xbase, #0, MUL VL] + /// void svst2[_s8](svbool_t pg, int8_t *base, svint8x2_t data) + /// ST2B {Zdata0.B, Zdata1.B}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, sbyte* address, (Vector Value1, Vector Value2) data) { throw new PlatformNotSupportedException(); } /// - /// void svst3[_s8](svbool_t pg, int8_t *base, svint8x3_t data) - /// ST3B {Zdata0.B - Zdata2.B}, Pg, [Xbase, #0, MUL VL] + /// void svst3[_s8](svbool_t pg, int8_t *base, svint8x3_t data) + /// ST3B {Zdata0.B - Zdata2.B}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, sbyte* address, (Vector Value1, Vector Value2, Vector Value3) data) { throw new PlatformNotSupportedException(); } /// - /// void svst4[_s8](svbool_t pg, int8_t *base, svint8x4_t data) - /// ST4B {Zdata0.B - Zdata3.B}, Pg, [Xbase, #0, MUL VL] + /// void svst4[_s8](svbool_t pg, int8_t *base, svint8x4_t data) + /// ST4B {Zdata0.B - Zdata3.B}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, sbyte* address, (Vector Value1, Vector Value2, Vector Value3, Vector Value4) data) { throw new PlatformNotSupportedException(); } /// - /// void svst1[_f32](svbool_t pg, float32_t *base, svfloat32_t data) - /// ST1W Zdata.S, Pg, [Xbase, #0, MUL VL] + /// void svst1[_f32](svbool_t pg, float32_t *base, svfloat32_t data) + /// ST1W Zdata.S, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, float* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst2[_f32](svbool_t pg, float32_t *base, svfloat32x2_t data) - /// ST2W {Zdata0.S, Zdata1.S}, Pg, [Xbase, #0, MUL VL] + /// void svst2[_f32](svbool_t pg, float32_t *base, svfloat32x2_t data) + /// ST2W {Zdata0.S, Zdata1.S}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, float* address, (Vector Value1, Vector Value2) data) { throw new PlatformNotSupportedException(); } /// - /// void svst3[_f32](svbool_t pg, float32_t *base, svfloat32x3_t data) - /// ST3W {Zdata0.S - Zdata2.S}, Pg, [Xbase, #0, MUL VL] + /// void svst3[_f32](svbool_t pg, float32_t *base, svfloat32x3_t data) + /// ST3W {Zdata0.S - Zdata2.S}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, float* address, (Vector Value1, Vector Value2, Vector Value3) data) { throw new PlatformNotSupportedException(); } /// - /// void svst4[_f32](svbool_t pg, float32_t *base, svfloat32x4_t data) - /// ST4W {Zdata0.S - Zdata3.S}, Pg, [Xbase, #0, MUL VL] + /// void svst4[_f32](svbool_t pg, float32_t *base, svfloat32x4_t data) + /// ST4W {Zdata0.S - Zdata3.S}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, float* address, (Vector Value1, Vector Value2, Vector Value3, Vector Value4) data) { throw new PlatformNotSupportedException(); } /// - /// void svst1[_u16](svbool_t pg, uint16_t *base, svuint16_t data) - /// ST1H Zdata.H, Pg, [Xbase, #0, MUL VL] + /// void svst1[_u16](svbool_t pg, uint16_t *base, svuint16_t data) + /// ST1H Zdata.H, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, ushort* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst2[_u16](svbool_t pg, uint16_t *base, svuint16x2_t data) - /// ST2H {Zdata0.H, Zdata1.H}, Pg, [Xbase, #0, MUL VL] + /// void svst2[_u16](svbool_t pg, uint16_t *base, svuint16x2_t data) + /// ST2H {Zdata0.H, Zdata1.H}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, ushort* address, (Vector Value1, Vector Value2) data) { throw new PlatformNotSupportedException(); } /// - /// void svst3[_u16](svbool_t pg, uint16_t *base, svuint16x3_t data) - /// ST3H {Zdata0.H - Zdata2.H}, Pg, [Xbase, #0, MUL VL] + /// void svst3[_u16](svbool_t pg, uint16_t *base, svuint16x3_t data) + /// ST3H {Zdata0.H - Zdata2.H}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, ushort* address, (Vector Value1, Vector Value2, Vector Value3) data) { throw new PlatformNotSupportedException(); } /// - /// void svst4[_u16](svbool_t pg, uint16_t *base, svuint16x4_t data) - /// ST4H {Zdata0.H - Zdata3.H}, Pg, [Xbase, #0, MUL VL] + /// void svst4[_u16](svbool_t pg, uint16_t *base, svuint16x4_t data) + /// ST4H {Zdata0.H - Zdata3.H}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, ushort* address, (Vector Value1, Vector Value2, Vector Value3, Vector Value4) data) { throw new PlatformNotSupportedException(); } /// - /// void svst1[_u32](svbool_t pg, uint32_t *base, svuint32_t data) - /// ST1W Zdata.S, Pg, [Xbase, #0, MUL VL] + /// void svst1[_u32](svbool_t pg, uint32_t *base, svuint32_t data) + /// ST1W Zdata.S, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, uint* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst2[_u32](svbool_t pg, uint32_t *base, svuint32x2_t data) - /// ST2W {Zdata0.S, Zdata1.S}, Pg, [Xbase, #0, MUL VL] + /// void svst2[_u32](svbool_t pg, uint32_t *base, svuint32x2_t data) + /// ST2W {Zdata0.S, Zdata1.S}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, uint* address, (Vector Value1, Vector Value2) data) { throw new PlatformNotSupportedException(); } /// - /// void svst3[_u32](svbool_t pg, uint32_t *base, svuint32x3_t data) - /// ST3W {Zdata0.S - Zdata2.S}, Pg, [Xbase, #0, MUL VL] + /// void svst3[_u32](svbool_t pg, uint32_t *base, svuint32x3_t data) + /// ST3W {Zdata0.S - Zdata2.S}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, uint* address, (Vector Value1, Vector Value2, Vector Value3) data) { throw new PlatformNotSupportedException(); } /// - /// void svst4[_u32](svbool_t pg, uint32_t *base, svuint32x4_t data) - /// ST4W {Zdata0.S - Zdata3.S}, Pg, [Xbase, #0, MUL VL] + /// void svst4[_u32](svbool_t pg, uint32_t *base, svuint32x4_t data) + /// ST4W {Zdata0.S - Zdata3.S}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, uint* address, (Vector Value1, Vector Value2, Vector Value3, Vector Value4) data) { throw new PlatformNotSupportedException(); } /// - /// void svst1[_u64](svbool_t pg, uint64_t *base, svuint64_t data) - /// ST1D Zdata.D, Pg, [Xbase, #0, MUL VL] + /// void svst1[_u64](svbool_t pg, uint64_t *base, svuint64_t data) + /// ST1D Zdata.D, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, ulong* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst2[_u64](svbool_t pg, uint64_t *base, svuint64x2_t data) - /// ST2D {Zdata0.D, Zdata1.D}, Pg, [Xbase, #0, MUL VL] + /// void svst2[_u64](svbool_t pg, uint64_t *base, svuint64x2_t data) + /// ST2D {Zdata0.D, Zdata1.D}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, ulong* address, (Vector Value1, Vector Value2) data) { throw new PlatformNotSupportedException(); } /// - /// void svst3[_u64](svbool_t pg, uint64_t *base, svuint64x3_t data) - /// ST3D {Zdata0.D - Zdata2.D}, Pg, [Xbase, #0, MUL VL] + /// void svst3[_u64](svbool_t pg, uint64_t *base, svuint64x3_t data) + /// ST3D {Zdata0.D - Zdata2.D}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, ulong* address, (Vector Value1, Vector Value2, Vector Value3) data) { throw new PlatformNotSupportedException(); } /// - /// void svst4[_u64](svbool_t pg, uint64_t *base, svuint64x4_t data) - /// ST4D {Zdata0.D - Zdata3.D}, Pg, [Xbase, #0, MUL VL] + /// void svst4[_u64](svbool_t pg, uint64_t *base, svuint64x4_t data) + /// ST4D {Zdata0.D - Zdata3.D}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, ulong* address, (Vector Value1, Vector Value2, Vector Value3, Vector Value4) data) { throw new PlatformNotSupportedException(); } @@ -8844,74 +9506,74 @@ internal Arm64() { } // Truncate to 8 bits and store /// - /// void svst1b[_s16](svbool_t pg, int8_t *base, svint16_t data) - /// ST1B Zdata.H, Pg, [Xbase, #0, MUL VL] + /// void svst1b[_s16](svbool_t pg, int8_t *base, svint16_t data) + /// ST1B Zdata.H, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNarrowing(Vector mask, sbyte* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1b[_s32](svbool_t pg, int8_t *base, svint32_t data) - /// ST1B Zdata.S, Pg, [Xbase, #0, MUL VL] + /// void svst1b[_s32](svbool_t pg, int8_t *base, svint32_t data) + /// ST1B Zdata.S, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNarrowing(Vector mask, sbyte* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1h[_s32](svbool_t pg, int16_t *base, svint32_t data) - /// ST1H Zdata.S, Pg, [Xbase, #0, MUL VL] + /// void svst1h[_s32](svbool_t pg, int16_t *base, svint32_t data) + /// ST1H Zdata.S, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNarrowing(Vector mask, short* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1b[_s64](svbool_t pg, int8_t *base, svint64_t data) - /// ST1B Zdata.D, Pg, [Xbase, #0, MUL VL] + /// void svst1b[_s64](svbool_t pg, int8_t *base, svint64_t data) + /// ST1B Zdata.D, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNarrowing(Vector mask, sbyte* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1h[_s64](svbool_t pg, int16_t *base, svint64_t data) - /// ST1H Zdata.D, Pg, [Xbase, #0, MUL VL] + /// void svst1h[_s64](svbool_t pg, int16_t *base, svint64_t data) + /// ST1H Zdata.D, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNarrowing(Vector mask, short* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1w[_s64](svbool_t pg, int32_t *base, svint64_t data) - /// ST1W Zdata.D, Pg, [Xbase, #0, MUL VL] + /// void svst1w[_s64](svbool_t pg, int32_t *base, svint64_t data) + /// ST1W Zdata.D, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNarrowing(Vector mask, int* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1b[_u16](svbool_t pg, uint8_t *base, svuint16_t data) - /// ST1B Zdata.H, Pg, [Xbase, #0, MUL VL] + /// void svst1b[_u16](svbool_t pg, uint8_t *base, svuint16_t data) + /// ST1B Zdata.H, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNarrowing(Vector mask, byte* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1b[_u32](svbool_t pg, uint8_t *base, svuint32_t data) - /// ST1B Zdata.S, Pg, [Xbase, #0, MUL VL] + /// void svst1b[_u32](svbool_t pg, uint8_t *base, svuint32_t data) + /// ST1B Zdata.S, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNarrowing(Vector mask, byte* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1h[_u32](svbool_t pg, uint16_t *base, svuint32_t data) - /// ST1H Zdata.S, Pg, [Xbase, #0, MUL VL] + /// void svst1h[_u32](svbool_t pg, uint16_t *base, svuint32_t data) + /// ST1H Zdata.S, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNarrowing(Vector mask, ushort* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1b[_u64](svbool_t pg, uint8_t *base, svuint64_t data) - /// ST1B Zdata.D, Pg, [Xbase, #0, MUL VL] + /// void svst1b[_u64](svbool_t pg, uint8_t *base, svuint64_t data) + /// ST1B Zdata.D, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNarrowing(Vector mask, byte* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1h[_u64](svbool_t pg, uint16_t *base, svuint64_t data) - /// ST1H Zdata.D, Pg, [Xbase, #0, MUL VL] + /// void svst1h[_u64](svbool_t pg, uint16_t *base, svuint64_t data) + /// ST1H Zdata.D, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNarrowing(Vector mask, ushort* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svst1w[_u64](svbool_t pg, uint32_t *base, svuint64_t data) - /// ST1W Zdata.D, Pg, [Xbase, #0, MUL VL] + /// void svst1w[_u64](svbool_t pg, uint32_t *base, svuint64_t data) + /// ST1W Zdata.D, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNarrowing(Vector mask, uint* address, Vector data) { throw new PlatformNotSupportedException(); } @@ -8919,62 +9581,62 @@ internal Arm64() { } // Non-truncating store, non-temporal /// - /// void svstnt1[_u8](svbool_t pg, uint8_t *base, svuint8_t data) - /// STNT1B Zdata.B, Pg, [Xbase, #0, MUL VL] + /// void svstnt1[_u8](svbool_t pg, uint8_t *base, svuint8_t data) + /// STNT1B Zdata.B, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNonTemporal(Vector mask, byte* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svstnt1[_f64](svbool_t pg, float64_t *base, svfloat64_t data) - /// STNT1D Zdata.D, Pg, [Xbase, #0, MUL VL] + /// void svstnt1[_f64](svbool_t pg, float64_t *base, svfloat64_t data) + /// STNT1D Zdata.D, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNonTemporal(Vector mask, double* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svstnt1[_s16](svbool_t pg, int16_t *base, svint16_t data) - /// STNT1H Zdata.H, Pg, [Xbase, #0, MUL VL] + /// void svstnt1[_s16](svbool_t pg, int16_t *base, svint16_t data) + /// STNT1H Zdata.H, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNonTemporal(Vector mask, short* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svstnt1[_s32](svbool_t pg, int32_t *base, svint32_t data) - /// STNT1W Zdata.S, Pg, [Xbase, #0, MUL VL] + /// void svstnt1[_s32](svbool_t pg, int32_t *base, svint32_t data) + /// STNT1W Zdata.S, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNonTemporal(Vector mask, int* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svstnt1[_s64](svbool_t pg, int64_t *base, svint64_t data) - /// STNT1D Zdata.D, Pg, [Xbase, #0, MUL VL] + /// void svstnt1[_s64](svbool_t pg, int64_t *base, svint64_t data) + /// STNT1D Zdata.D, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNonTemporal(Vector mask, long* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svstnt1[_s8](svbool_t pg, int8_t *base, svint8_t data) - /// STNT1B Zdata.B, Pg, [Xbase, #0, MUL VL] + /// void svstnt1[_s8](svbool_t pg, int8_t *base, svint8_t data) + /// STNT1B Zdata.B, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNonTemporal(Vector mask, sbyte* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svstnt1[_f32](svbool_t pg, float32_t *base, svfloat32_t data) - /// STNT1W Zdata.S, Pg, [Xbase, #0, MUL VL] + /// void svstnt1[_f32](svbool_t pg, float32_t *base, svfloat32_t data) + /// STNT1W Zdata.S, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNonTemporal(Vector mask, float* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svstnt1[_u16](svbool_t pg, uint16_t *base, svuint16_t data) - /// STNT1H Zdata.H, Pg, [Xbase, #0, MUL VL] + /// void svstnt1[_u16](svbool_t pg, uint16_t *base, svuint16_t data) + /// STNT1H Zdata.H, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNonTemporal(Vector mask, ushort* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svstnt1[_u32](svbool_t pg, uint32_t *base, svuint32_t data) - /// STNT1W Zdata.S, Pg, [Xbase, #0, MUL VL] + /// void svstnt1[_u32](svbool_t pg, uint32_t *base, svuint32_t data) + /// STNT1W Zdata.S, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNonTemporal(Vector mask, uint* address, Vector data) { throw new PlatformNotSupportedException(); } /// - /// void svstnt1[_u64](svbool_t pg, uint64_t *base, svuint64_t data) - /// STNT1D Zdata.D, Pg, [Xbase, #0, MUL VL] + /// void svstnt1[_u64](svbool_t pg, uint64_t *base, svuint64_t data) + /// STNT1D Zdata.D, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNonTemporal(Vector mask, ulong* address, Vector data) { throw new PlatformNotSupportedException(); } @@ -8982,1005 +9644,991 @@ internal Arm64() { } // Subtract /// - /// svuint8_t svsub[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svsub[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svsub[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// SUB Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// svuint8_t svsub[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svsub[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svsub[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// SUB Ztied1.B, Pg/M, Ztied1.B, Zop2.B /// - public static unsafe Vector Subtract(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Subtract(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svsub[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svsub[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svsub[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FSUB Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svfloat64_t svsub[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svsub[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svsub[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FSUB Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector Subtract(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Subtract(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svsub[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svsub[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svsub[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) - /// SUB Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// svint16_t svsub[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svsub[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svsub[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) + /// SUB Ztied1.H, Pg/M, Ztied1.H, Zop2.H /// - public static unsafe Vector Subtract(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Subtract(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svsub[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svsub[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svsub[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) - /// SUB Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svint32_t svsub[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svsub[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svsub[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) + /// SUB Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector Subtract(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Subtract(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svsub[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svsub[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svsub[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) - /// SUB Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svint64_t svsub[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svsub[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svsub[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) + /// SUB Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector Subtract(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Subtract(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svsub[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svsub[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svsub[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) - /// SUB Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// svint8_t svsub[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svsub[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svsub[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) + /// SUB Ztied1.B, Pg/M, Ztied1.B, Zop2.B /// - public static unsafe Vector Subtract(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Subtract(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svsub[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svsub[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svsub[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FSUB Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svfloat32_t svsub[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svsub[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svsub[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FSUB Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector Subtract(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Subtract(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svsub[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svsub[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svsub[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// SUB Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// svuint16_t svsub[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svsub[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svsub[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// SUB Ztied1.H, Pg/M, Ztied1.H, Zop2.H /// - public static unsafe Vector Subtract(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Subtract(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svsub[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svsub[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svsub[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// SUB Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svuint32_t svsub[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svsub[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svsub[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// SUB Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector Subtract(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Subtract(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svsub[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svsub[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svsub[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// SUB Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svuint64_t svsub[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svsub[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svsub[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// SUB Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector Subtract(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Subtract(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Saturating subtract /// - /// svuint8_t svqsub[_u8](svuint8_t op1, svuint8_t op2) - /// UQSUB Zresult.B, Zop1.B, Zop2.B + /// svuint8_t svqsub[_u8](svuint8_t op1, svuint8_t op2) + /// UQSUB Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector SubtractSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector SubtractSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svqsub[_s16](svint16_t op1, svint16_t op2) - /// SQSUB Zresult.H, Zop1.H, Zop2.H + /// svint16_t svqsub[_s16](svint16_t op1, svint16_t op2) + /// SQSUB Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector SubtractSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector SubtractSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svqsub[_s32](svint32_t op1, svint32_t op2) - /// SQSUB Zresult.S, Zop1.S, Zop2.S + /// svint32_t svqsub[_s32](svint32_t op1, svint32_t op2) + /// SQSUB Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector SubtractSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector SubtractSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svqsub[_s64](svint64_t op1, svint64_t op2) - /// SQSUB Zresult.D, Zop1.D, Zop2.D + /// svint64_t svqsub[_s64](svint64_t op1, svint64_t op2) + /// SQSUB Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector SubtractSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector SubtractSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svqsub[_s8](svint8_t op1, svint8_t op2) - /// SQSUB Zresult.B, Zop1.B, Zop2.B + /// svint8_t svqsub[_s8](svint8_t op1, svint8_t op2) + /// SQSUB Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector SubtractSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector SubtractSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svqsub[_u16](svuint16_t op1, svuint16_t op2) - /// UQSUB Zresult.H, Zop1.H, Zop2.H + /// svuint16_t svqsub[_u16](svuint16_t op1, svuint16_t op2) + /// UQSUB Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector SubtractSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector SubtractSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svqsub[_u32](svuint32_t op1, svuint32_t op2) - /// UQSUB Zresult.S, Zop1.S, Zop2.S + /// svuint32_t svqsub[_u32](svuint32_t op1, svuint32_t op2) + /// UQSUB Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector SubtractSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector SubtractSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svqsub[_u64](svuint64_t op1, svuint64_t op2) - /// UQSUB Zresult.D, Zop1.D, Zop2.D + /// svuint64_t svqsub[_u64](svuint64_t op1, svuint64_t op2) + /// UQSUB Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector SubtractSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector SubtractSaturate(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Test whether any active element is true /// - /// bool svptest_any(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_any(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestAnyTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static bool TestAnyTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// bool svptest_any(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_any(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestAnyTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static bool TestAnyTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// bool svptest_any(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_any(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestAnyTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static bool TestAnyTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// bool svptest_any(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_any(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestAnyTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static bool TestAnyTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// bool svptest_any(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_any(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestAnyTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static bool TestAnyTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// bool svptest_any(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_any(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestAnyTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static bool TestAnyTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// bool svptest_any(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_any(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestAnyTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static bool TestAnyTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// bool svptest_any(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_any(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestAnyTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static bool TestAnyTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } // Test whether the first active element is true /// - /// bool svptest_first(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_first(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestFirstTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static bool TestFirstTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// bool svptest_first(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_first(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestFirstTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static bool TestFirstTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// bool svptest_first(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_first(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestFirstTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static bool TestFirstTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// bool svptest_first(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_first(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestFirstTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static bool TestFirstTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// bool svptest_first(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_first(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestFirstTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static bool TestFirstTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// bool svptest_first(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_first(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestFirstTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static bool TestFirstTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// bool svptest_first(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_first(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestFirstTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static bool TestFirstTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// bool svptest_first(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_first(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestFirstTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static bool TestFirstTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } // Test whether the last active element is true /// - /// bool svptest_last(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_last(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestLastTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static bool TestLastTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// bool svptest_last(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_last(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestLastTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static bool TestLastTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// bool svptest_last(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_last(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestLastTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static bool TestLastTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// bool svptest_last(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_last(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestLastTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static bool TestLastTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// bool svptest_last(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_last(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestLastTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static bool TestLastTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// bool svptest_last(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_last(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestLastTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static bool TestLastTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// bool svptest_last(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_last(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestLastTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static bool TestLastTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } /// - /// bool svptest_last(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_last(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestLastTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } + public static bool TestLastTrue(Vector mask, Vector srcMask) { throw new PlatformNotSupportedException(); } // Interleave even elements from two inputs /// - /// svuint8_t svtrn1[_u8](svuint8_t op1, svuint8_t op2) - /// TRN1 Zresult.B, Zop1.B, Zop2.B + /// svuint8_t svtrn1[_u8](svuint8_t op1, svuint8_t op2) + /// TRN1 Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector TransposeEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector TransposeEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svtrn1[_f64](svfloat64_t op1, svfloat64_t op2) - /// TRN1 Zresult.D, Zop1.D, Zop2.D + /// svfloat64_t svtrn1[_f64](svfloat64_t op1, svfloat64_t op2) + /// TRN1 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector TransposeEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector TransposeEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svtrn1[_s16](svint16_t op1, svint16_t op2) - /// TRN1 Zresult.H, Zop1.H, Zop2.H + /// svint16_t svtrn1[_s16](svint16_t op1, svint16_t op2) + /// TRN1 Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector TransposeEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector TransposeEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svtrn1[_s32](svint32_t op1, svint32_t op2) - /// TRN1 Zresult.S, Zop1.S, Zop2.S + /// svint32_t svtrn1[_s32](svint32_t op1, svint32_t op2) + /// TRN1 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector TransposeEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector TransposeEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svtrn1[_s64](svint64_t op1, svint64_t op2) - /// TRN1 Zresult.D, Zop1.D, Zop2.D + /// svint64_t svtrn1[_s64](svint64_t op1, svint64_t op2) + /// TRN1 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector TransposeEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector TransposeEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svtrn1[_s8](svint8_t op1, svint8_t op2) - /// TRN1 Zresult.B, Zop1.B, Zop2.B + /// svint8_t svtrn1[_s8](svint8_t op1, svint8_t op2) + /// TRN1 Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector TransposeEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector TransposeEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svtrn1[_f32](svfloat32_t op1, svfloat32_t op2) - /// TRN1 Zresult.S, Zop1.S, Zop2.S + /// svfloat32_t svtrn1[_f32](svfloat32_t op1, svfloat32_t op2) + /// TRN1 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector TransposeEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector TransposeEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svtrn1[_u16](svuint16_t op1, svuint16_t op2) - /// TRN1 Zresult.H, Zop1.H, Zop2.H + /// svuint16_t svtrn1[_u16](svuint16_t op1, svuint16_t op2) + /// TRN1 Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector TransposeEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector TransposeEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svtrn1[_u32](svuint32_t op1, svuint32_t op2) - /// TRN1 Zresult.S, Zop1.S, Zop2.S + /// svuint32_t svtrn1[_u32](svuint32_t op1, svuint32_t op2) + /// TRN1 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector TransposeEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector TransposeEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svtrn1[_u64](svuint64_t op1, svuint64_t op2) - /// TRN1 Zresult.D, Zop1.D, Zop2.D + /// svuint64_t svtrn1[_u64](svuint64_t op1, svuint64_t op2) + /// TRN1 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector TransposeEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector TransposeEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Interleave odd elements from two inputs /// - /// svuint8_t svtrn2[_u8](svuint8_t op1, svuint8_t op2) - /// TRN2 Zresult.B, Zop1.B, Zop2.B + /// svuint8_t svtrn2[_u8](svuint8_t op1, svuint8_t op2) + /// TRN2 Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector TransposeOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector TransposeOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svtrn2[_f64](svfloat64_t op1, svfloat64_t op2) - /// TRN2 Zresult.D, Zop1.D, Zop2.D + /// svfloat64_t svtrn2[_f64](svfloat64_t op1, svfloat64_t op2) + /// TRN2 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector TransposeOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector TransposeOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svtrn2[_s16](svint16_t op1, svint16_t op2) - /// TRN2 Zresult.H, Zop1.H, Zop2.H + /// svint16_t svtrn2[_s16](svint16_t op1, svint16_t op2) + /// TRN2 Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector TransposeOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector TransposeOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svtrn2[_s32](svint32_t op1, svint32_t op2) - /// TRN2 Zresult.S, Zop1.S, Zop2.S + /// svint32_t svtrn2[_s32](svint32_t op1, svint32_t op2) + /// TRN2 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector TransposeOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector TransposeOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svtrn2[_s64](svint64_t op1, svint64_t op2) - /// TRN2 Zresult.D, Zop1.D, Zop2.D + /// svint64_t svtrn2[_s64](svint64_t op1, svint64_t op2) + /// TRN2 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector TransposeOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector TransposeOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svtrn2[_s8](svint8_t op1, svint8_t op2) - /// TRN2 Zresult.B, Zop1.B, Zop2.B + /// svint8_t svtrn2[_s8](svint8_t op1, svint8_t op2) + /// TRN2 Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector TransposeOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector TransposeOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svtrn2[_f32](svfloat32_t op1, svfloat32_t op2) - /// TRN2 Zresult.S, Zop1.S, Zop2.S + /// svfloat32_t svtrn2[_f32](svfloat32_t op1, svfloat32_t op2) + /// TRN2 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector TransposeOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector TransposeOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svtrn2[_u16](svuint16_t op1, svuint16_t op2) - /// TRN2 Zresult.H, Zop1.H, Zop2.H + /// svuint16_t svtrn2[_u16](svuint16_t op1, svuint16_t op2) + /// TRN2 Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector TransposeOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector TransposeOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svtrn2[_u32](svuint32_t op1, svuint32_t op2) - /// TRN2 Zresult.S, Zop1.S, Zop2.S + /// svuint32_t svtrn2[_u32](svuint32_t op1, svuint32_t op2) + /// TRN2 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector TransposeOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector TransposeOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svtrn2[_u64](svuint64_t op1, svuint64_t op2) - /// TRN2 Zresult.D, Zop1.D, Zop2.D + /// svuint64_t svtrn2[_u64](svuint64_t op1, svuint64_t op2) + /// TRN2 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector TransposeOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector TransposeOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Trigonometric multiply-add coefficient /// - /// svfloat64_t svtmad[_f64](svfloat64_t op1, svfloat64_t op2, uint64_t imm3) - /// FTMAD Ztied1.D, Ztied1.D, Zop2.D, #imm3 + /// svfloat64_t svtmad[_f64](svfloat64_t op1, svfloat64_t op2, uint64_t imm3) + /// FTMAD Ztied1.D, Ztied1.D, Zop2.D, #imm3 /// - public static unsafe Vector TrigonometricMultiplyAddCoefficient(Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(7))] byte control) { throw new PlatformNotSupportedException(); } + public static Vector TrigonometricMultiplyAddCoefficient(Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(7))] byte control) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svtmad[_f32](svfloat32_t op1, svfloat32_t op2, uint64_t imm3) - /// FTMAD Ztied1.S, Ztied1.S, Zop2.S, #imm3 + /// svfloat32_t svtmad[_f32](svfloat32_t op1, svfloat32_t op2, uint64_t imm3) + /// FTMAD Ztied1.S, Ztied1.S, Zop2.S, #imm3 /// - public static unsafe Vector TrigonometricMultiplyAddCoefficient(Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(7))] byte control) { throw new PlatformNotSupportedException(); } + public static Vector TrigonometricMultiplyAddCoefficient(Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(7))] byte control) { throw new PlatformNotSupportedException(); } // Trigonometric select coefficient /// - /// svfloat64_t svtssel[_f64](svfloat64_t op1, svuint64_t op2) - /// FTSSEL Zresult.D, Zop1.D, Zop2.D + /// svfloat64_t svtssel[_f64](svfloat64_t op1, svuint64_t op2) + /// FTSSEL Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector TrigonometricSelectCoefficient(Vector value, Vector selector) { throw new PlatformNotSupportedException(); } + public static Vector TrigonometricSelectCoefficient(Vector value, Vector selector) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svtssel[_f32](svfloat32_t op1, svuint32_t op2) - /// FTSSEL Zresult.S, Zop1.S, Zop2.S + /// svfloat32_t svtssel[_f32](svfloat32_t op1, svuint32_t op2) + /// FTSSEL Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector TrigonometricSelectCoefficient(Vector value, Vector selector) { throw new PlatformNotSupportedException(); } + public static Vector TrigonometricSelectCoefficient(Vector value, Vector selector) { throw new PlatformNotSupportedException(); } // Trigonometric starting value /// - /// svfloat64_t svtsmul[_f64](svfloat64_t op1, svuint64_t op2) - /// FTSMUL Zresult.D, Zop1.D, Zop2.D + /// svfloat64_t svtsmul[_f64](svfloat64_t op1, svuint64_t op2) + /// FTSMUL Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector TrigonometricStartingValue(Vector value, Vector sign) { throw new PlatformNotSupportedException(); } + public static Vector TrigonometricStartingValue(Vector value, Vector sign) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svtsmul[_f32](svfloat32_t op1, svuint32_t op2) - /// FTSMUL Zresult.S, Zop1.S, Zop2.S + /// svfloat32_t svtsmul[_f32](svfloat32_t op1, svuint32_t op2) + /// FTSMUL Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector TrigonometricStartingValue(Vector value, Vector sign) { throw new PlatformNotSupportedException(); } + public static Vector TrigonometricStartingValue(Vector value, Vector sign) { throw new PlatformNotSupportedException(); } // Concatenate even elements from two inputs /// - /// svuint8_t svuzp1[_u8](svuint8_t op1, svuint8_t op2) - /// svbool_t svuzp1_b8(svbool_t op1, svbool_t op2) + /// svuint8_t svuzp1[_u8](svuint8_t op1, svuint8_t op2) + /// svbool_t svuzp1_b8(svbool_t op1, svbool_t op2) /// - public static unsafe Vector UnzipEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector UnzipEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svuzp1[_f64](svfloat64_t op1, svfloat64_t op2) - /// UZP1 Zresult.D, Zop1.D, Zop2.D + /// svfloat64_t svuzp1[_f64](svfloat64_t op1, svfloat64_t op2) + /// UZP1 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector UnzipEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector UnzipEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svuzp1[_s16](svint16_t op1, svint16_t op2) - /// UZP1 Zresult.H, Zop1.H, Zop2.H + /// svint16_t svuzp1[_s16](svint16_t op1, svint16_t op2) + /// UZP1 Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector UnzipEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector UnzipEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svuzp1[_s32](svint32_t op1, svint32_t op2) - /// UZP1 Zresult.S, Zop1.S, Zop2.S + /// svint32_t svuzp1[_s32](svint32_t op1, svint32_t op2) + /// UZP1 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector UnzipEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector UnzipEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svuzp1[_s64](svint64_t op1, svint64_t op2) - /// UZP1 Zresult.D, Zop1.D, Zop2.D + /// svint64_t svuzp1[_s64](svint64_t op1, svint64_t op2) + /// UZP1 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector UnzipEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector UnzipEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svuzp1[_s8](svint8_t op1, svint8_t op2) - /// UZP1 Zresult.B, Zop1.B, Zop2.B + /// svint8_t svuzp1[_s8](svint8_t op1, svint8_t op2) + /// UZP1 Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector UnzipEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector UnzipEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svuzp1[_f32](svfloat32_t op1, svfloat32_t op2) - /// UZP1 Zresult.S, Zop1.S, Zop2.S + /// svfloat32_t svuzp1[_f32](svfloat32_t op1, svfloat32_t op2) + /// UZP1 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector UnzipEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector UnzipEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svuzp1[_u16](svuint16_t op1, svuint16_t op2) - /// UZP1 Zresult.H, Zop1.H, Zop2.H + /// svuint16_t svuzp1[_u16](svuint16_t op1, svuint16_t op2) + /// UZP1 Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector UnzipEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector UnzipEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svuzp1[_u32](svuint32_t op1, svuint32_t op2) - /// UZP1 Zresult.S, Zop1.S, Zop2.S + /// svuint32_t svuzp1[_u32](svuint32_t op1, svuint32_t op2) + /// UZP1 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector UnzipEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector UnzipEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svuzp1[_u64](svuint64_t op1, svuint64_t op2) - /// UZP1 Zresult.D, Zop1.D, Zop2.D + /// svuint64_t svuzp1[_u64](svuint64_t op1, svuint64_t op2) + /// UZP1 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector UnzipEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector UnzipEven(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Concatenate odd elements from two inputs /// - /// svuint8_t svuzp2[_u8](svuint8_t op1, svuint8_t op2) - /// UZP2 Zresult.B, Zop1.B, Zop2.B + /// svuint8_t svuzp2[_u8](svuint8_t op1, svuint8_t op2) + /// UZP2 Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector UnzipOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector UnzipOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svuzp2[_f64](svfloat64_t op1, svfloat64_t op2) - /// UZP2 Zresult.D, Zop1.D, Zop2.D + /// svfloat64_t svuzp2[_f64](svfloat64_t op1, svfloat64_t op2) + /// UZP2 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector UnzipOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector UnzipOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svuzp2[_s16](svint16_t op1, svint16_t op2) - /// UZP2 Zresult.H, Zop1.H, Zop2.H + /// svint16_t svuzp2[_s16](svint16_t op1, svint16_t op2) + /// UZP2 Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector UnzipOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector UnzipOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svuzp2[_s32](svint32_t op1, svint32_t op2) - /// UZP2 Zresult.S, Zop1.S, Zop2.S + /// svint32_t svuzp2[_s32](svint32_t op1, svint32_t op2) + /// UZP2 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector UnzipOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector UnzipOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svuzp2[_s64](svint64_t op1, svint64_t op2) - /// UZP2 Zresult.D, Zop1.D, Zop2.D + /// svint64_t svuzp2[_s64](svint64_t op1, svint64_t op2) + /// UZP2 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector UnzipOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector UnzipOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svuzp2[_s8](svint8_t op1, svint8_t op2) - /// UZP2 Zresult.B, Zop1.B, Zop2.B + /// svint8_t svuzp2[_s8](svint8_t op1, svint8_t op2) + /// UZP2 Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector UnzipOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector UnzipOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svuzp2[_f32](svfloat32_t op1, svfloat32_t op2) - /// UZP2 Zresult.S, Zop1.S, Zop2.S + /// svfloat32_t svuzp2[_f32](svfloat32_t op1, svfloat32_t op2) + /// UZP2 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector UnzipOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector UnzipOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svuzp2[_u16](svuint16_t op1, svuint16_t op2) - /// UZP2 Zresult.H, Zop1.H, Zop2.H + /// svuint16_t svuzp2[_u16](svuint16_t op1, svuint16_t op2) + /// UZP2 Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector UnzipOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector UnzipOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svuzp2[_u32](svuint32_t op1, svuint32_t op2) - /// UZP2 Zresult.S, Zop1.S, Zop2.S + /// svuint32_t svuzp2[_u32](svuint32_t op1, svuint32_t op2) + /// UZP2 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector UnzipOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector UnzipOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svuzp2[_u64](svuint64_t op1, svuint64_t op2) - /// UZP2 Zresult.D, Zop1.D, Zop2.D + /// svuint64_t svuzp2[_u64](svuint64_t op1, svuint64_t op2) + /// UZP2 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector UnzipOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector UnzipOdd(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Table lookup in single-vector table /// - /// svuint8_t svtbl[_u8](svuint8_t data, svuint8_t indices) - /// TBL Zresult.B, {Zdata.B}, Zindices.B + /// svuint8_t svtbl[_u8](svuint8_t data, svuint8_t indices) + /// TBL Zresult.B, {Zdata.B}, Zindices.B /// - public static unsafe Vector VectorTableLookup(Vector data, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector VectorTableLookup(Vector data, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svtbl[_f64](svfloat64_t data, svuint64_t indices) - /// TBL Zresult.D, {Zdata.D}, Zindices.D + /// svfloat64_t svtbl[_f64](svfloat64_t data, svuint64_t indices) + /// TBL Zresult.D, {Zdata.D}, Zindices.D /// - public static unsafe Vector VectorTableLookup(Vector data, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector VectorTableLookup(Vector data, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svtbl[_s16](svint16_t data, svuint16_t indices) - /// TBL Zresult.H, {Zdata.H}, Zindices.H + /// svint16_t svtbl[_s16](svint16_t data, svuint16_t indices) + /// TBL Zresult.H, {Zdata.H}, Zindices.H /// - public static unsafe Vector VectorTableLookup(Vector data, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector VectorTableLookup(Vector data, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svtbl[_s32](svint32_t data, svuint32_t indices) - /// TBL Zresult.S, {Zdata.S}, Zindices.S + /// svint32_t svtbl[_s32](svint32_t data, svuint32_t indices) + /// TBL Zresult.S, {Zdata.S}, Zindices.S /// - public static unsafe Vector VectorTableLookup(Vector data, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector VectorTableLookup(Vector data, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svtbl[_s64](svint64_t data, svuint64_t indices) - /// TBL Zresult.D, {Zdata.D}, Zindices.D + /// svint64_t svtbl[_s64](svint64_t data, svuint64_t indices) + /// TBL Zresult.D, {Zdata.D}, Zindices.D /// - public static unsafe Vector VectorTableLookup(Vector data, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector VectorTableLookup(Vector data, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svtbl[_s8](svint8_t data, svuint8_t indices) - /// TBL Zresult.B, {Zdata.B}, Zindices.B + /// svint8_t svtbl[_s8](svint8_t data, svuint8_t indices) + /// TBL Zresult.B, {Zdata.B}, Zindices.B /// - public static unsafe Vector VectorTableLookup(Vector data, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector VectorTableLookup(Vector data, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svtbl[_f32](svfloat32_t data, svuint32_t indices) - /// TBL Zresult.S, {Zdata.S}, Zindices.S + /// svfloat32_t svtbl[_f32](svfloat32_t data, svuint32_t indices) + /// TBL Zresult.S, {Zdata.S}, Zindices.S /// - public static unsafe Vector VectorTableLookup(Vector data, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector VectorTableLookup(Vector data, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svtbl[_u16](svuint16_t data, svuint16_t indices) - /// TBL Zresult.H, {Zdata.H}, Zindices.H + /// svuint16_t svtbl[_u16](svuint16_t data, svuint16_t indices) + /// TBL Zresult.H, {Zdata.H}, Zindices.H /// - public static unsafe Vector VectorTableLookup(Vector data, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector VectorTableLookup(Vector data, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svtbl[_u32](svuint32_t data, svuint32_t indices) - /// TBL Zresult.S, {Zdata.S}, Zindices.S + /// svuint32_t svtbl[_u32](svuint32_t data, svuint32_t indices) + /// TBL Zresult.S, {Zdata.S}, Zindices.S /// - public static unsafe Vector VectorTableLookup(Vector data, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector VectorTableLookup(Vector data, Vector indices) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svtbl[_u64](svuint64_t data, svuint64_t indices) - /// TBL Zresult.D, {Zdata.D}, Zindices.D + /// svuint64_t svtbl[_u64](svuint64_t data, svuint64_t indices) + /// TBL Zresult.D, {Zdata.D}, Zindices.D /// - public static unsafe Vector VectorTableLookup(Vector data, Vector indices) { throw new PlatformNotSupportedException(); } + public static Vector VectorTableLookup(Vector data, Vector indices) { throw new PlatformNotSupportedException(); } // Bitwise exclusive OR /// - /// svuint8_t sveor[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t sveor[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t sveor[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// EOR Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// svuint8_t sveor[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t sveor[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t sveor[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// EOR Ztied1.B, Pg/M, Ztied1.B, Zop2.B /// - public static unsafe Vector Xor(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Xor(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t sveor[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t sveor[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t sveor[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) - /// EOR Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// svint16_t sveor[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t sveor[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t sveor[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) + /// EOR Ztied1.H, Pg/M, Ztied1.H, Zop2.H /// - public static unsafe Vector Xor(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Xor(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t sveor[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t sveor[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t sveor[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) - /// EOR Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svint32_t sveor[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t sveor[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t sveor[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) + /// EOR Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector Xor(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Xor(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t sveor[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t sveor[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t sveor[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) - /// EOR Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svint64_t sveor[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t sveor[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t sveor[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) + /// EOR Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector Xor(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Xor(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t sveor[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t sveor[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t sveor[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) - /// EOR Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// svint8_t sveor[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t sveor[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t sveor[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) + /// EOR Ztied1.B, Pg/M, Ztied1.B, Zop2.B /// - public static unsafe Vector Xor(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Xor(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t sveor[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t sveor[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t sveor[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// EOR Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// svuint16_t sveor[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t sveor[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t sveor[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// EOR Ztied1.H, Pg/M, Ztied1.H, Zop2.H /// - public static unsafe Vector Xor(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Xor(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t sveor[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t sveor[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t sveor[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// EOR Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svuint32_t sveor[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t sveor[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t sveor[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// EOR Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector Xor(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Xor(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t sveor[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t sveor[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t sveor[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// EOR Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svuint64_t sveor[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t sveor[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t sveor[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// EOR Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector Xor(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector Xor(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Bitwise exclusive OR reduction to scalar /// - /// uint8_t sveorv[_u8](svbool_t pg, svuint8_t op) - /// EORV Bresult, Pg, Zop.B + /// uint8_t sveorv[_u8](svbool_t pg, svuint8_t op) + /// EORV Bresult, Pg, Zop.B /// - public static unsafe Vector XorAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector XorAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// int16_t sveorv[_s16](svbool_t pg, svint16_t op) - /// EORV Hresult, Pg, Zop.H + /// int16_t sveorv[_s16](svbool_t pg, svint16_t op) + /// EORV Hresult, Pg, Zop.H /// - public static unsafe Vector XorAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector XorAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// int32_t sveorv[_s32](svbool_t pg, svint32_t op) - /// EORV Sresult, Pg, Zop.S + /// int32_t sveorv[_s32](svbool_t pg, svint32_t op) + /// EORV Sresult, Pg, Zop.S /// - public static unsafe Vector XorAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector XorAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// int64_t sveorv[_s64](svbool_t pg, svint64_t op) - /// EORV Dresult, Pg, Zop.D + /// int64_t sveorv[_s64](svbool_t pg, svint64_t op) + /// EORV Dresult, Pg, Zop.D /// - public static unsafe Vector XorAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector XorAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// int8_t sveorv[_s8](svbool_t pg, svint8_t op) - /// EORV Bresult, Pg, Zop.B + /// int8_t sveorv[_s8](svbool_t pg, svint8_t op) + /// EORV Bresult, Pg, Zop.B /// - public static unsafe Vector XorAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector XorAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// uint16_t sveorv[_u16](svbool_t pg, svuint16_t op) - /// EORV Hresult, Pg, Zop.H + /// uint16_t sveorv[_u16](svbool_t pg, svuint16_t op) + /// EORV Hresult, Pg, Zop.H /// - public static unsafe Vector XorAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector XorAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// uint32_t sveorv[_u32](svbool_t pg, svuint32_t op) - /// EORV Sresult, Pg, Zop.S + /// uint32_t sveorv[_u32](svbool_t pg, svuint32_t op) + /// EORV Sresult, Pg, Zop.S /// - public static unsafe Vector XorAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector XorAcross(Vector value) { throw new PlatformNotSupportedException(); } /// - /// uint64_t sveorv[_u64](svbool_t pg, svuint64_t op) - /// EORV Dresult, Pg, Zop.D + /// uint64_t sveorv[_u64](svbool_t pg, svuint64_t op) + /// EORV Dresult, Pg, Zop.D /// - public static unsafe Vector XorAcross(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector XorAcross(Vector value) { throw new PlatformNotSupportedException(); } // Zero-extend the low 16 bits /// - /// svuint32_t svexth[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) - /// svuint32_t svexth[_u32]_x(svbool_t pg, svuint32_t op) - /// svuint32_t svexth[_u32]_z(svbool_t pg, svuint32_t op) - /// UXTH Zresult.S, Pg/M, Zop.S + /// svuint32_t svexth[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) + /// svuint32_t svexth[_u32]_x(svbool_t pg, svuint32_t op) + /// svuint32_t svexth[_u32]_z(svbool_t pg, svuint32_t op) + /// UXTH Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ZeroExtend16(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ZeroExtend16(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svexth[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) - /// svuint64_t svexth[_u64]_x(svbool_t pg, svuint64_t op) - /// svuint64_t svexth[_u64]_z(svbool_t pg, svuint64_t op) - /// UXTH Zresult.D, Pg/M, Zop.D + /// svuint64_t svexth[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) + /// svuint64_t svexth[_u64]_x(svbool_t pg, svuint64_t op) + /// svuint64_t svexth[_u64]_z(svbool_t pg, svuint64_t op) + /// UXTH Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ZeroExtend16(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ZeroExtend16(Vector value) { throw new PlatformNotSupportedException(); } // Zero-extend the low 32 bits /// - /// svuint64_t svextw[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) - /// svuint64_t svextw[_u64]_x(svbool_t pg, svuint64_t op) - /// svuint64_t svextw[_u64]_z(svbool_t pg, svuint64_t op) - /// UXTW Zresult.D, Pg/M, Zop.D + /// svuint64_t svextw[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) + /// svuint64_t svextw[_u64]_x(svbool_t pg, svuint64_t op) + /// svuint64_t svextw[_u64]_z(svbool_t pg, svuint64_t op) + /// UXTW Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ZeroExtend32(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ZeroExtend32(Vector value) { throw new PlatformNotSupportedException(); } // Zero-extend the low 8 bits /// - /// svuint16_t svextb[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) - /// svuint16_t svextb[_u16]_x(svbool_t pg, svuint16_t op) - /// svuint16_t svextb[_u16]_z(svbool_t pg, svuint16_t op) - /// UXTB Zresult.H, Pg/M, Zop.H + /// svuint16_t svextb[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) + /// svuint16_t svextb[_u16]_x(svbool_t pg, svuint16_t op) + /// svuint16_t svextb[_u16]_z(svbool_t pg, svuint16_t op) + /// UXTB Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector ZeroExtend8(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ZeroExtend8(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svextb[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) - /// svuint32_t svextb[_u32]_x(svbool_t pg, svuint32_t op) - /// svuint32_t svextb[_u32]_z(svbool_t pg, svuint32_t op) - /// UXTB Zresult.S, Pg/M, Zop.S + /// svuint32_t svextb[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) + /// svuint32_t svextb[_u32]_x(svbool_t pg, svuint32_t op) + /// svuint32_t svextb[_u32]_z(svbool_t pg, svuint32_t op) + /// UXTB Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ZeroExtend8(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ZeroExtend8(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svextb[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) - /// svuint64_t svextb[_u64]_x(svbool_t pg, svuint64_t op) - /// svuint64_t svextb[_u64]_z(svbool_t pg, svuint64_t op) - /// UXTB Zresult.D, Pg/M, Zop.D + /// svuint64_t svextb[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) + /// svuint64_t svextb[_u64]_x(svbool_t pg, svuint64_t op) + /// svuint64_t svextb[_u64]_z(svbool_t pg, svuint64_t op) + /// UXTB Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ZeroExtend8(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ZeroExtend8(Vector value) { throw new PlatformNotSupportedException(); } // Unpack and extend low half /// - /// svuint16_t svunpklo[_u16](svuint8_t op) - /// UUNPKLO Zresult.H, Zop.B + /// svuint16_t svunpklo[_u16](svuint8_t op) + /// UUNPKLO Zresult.H, Zop.B /// - public static unsafe Vector ZeroExtendWideningLower(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ZeroExtendWideningLower(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svunpklo[_u32](svuint16_t op) - /// UUNPKLO Zresult.S, Zop.H + /// svuint32_t svunpklo[_u32](svuint16_t op) + /// UUNPKLO Zresult.S, Zop.H /// - public static unsafe Vector ZeroExtendWideningLower(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ZeroExtendWideningLower(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svunpklo[_u64](svuint32_t op) - /// UUNPKLO Zresult.D, Zop.S + /// svuint64_t svunpklo[_u64](svuint32_t op) + /// UUNPKLO Zresult.D, Zop.S /// - public static unsafe Vector ZeroExtendWideningLower(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ZeroExtendWideningLower(Vector value) { throw new PlatformNotSupportedException(); } // Unpack and extend high half /// - /// svuint16_t svunpkhi[_u16](svuint8_t op) - /// UUNPKHI Zresult.H, Zop.B + /// svuint16_t svunpkhi[_u16](svuint8_t op) + /// UUNPKHI Zresult.H, Zop.B /// - public static unsafe Vector ZeroExtendWideningUpper(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ZeroExtendWideningUpper(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svunpkhi[_u32](svuint16_t op) - /// UUNPKHI Zresult.S, Zop.H + /// svuint32_t svunpkhi[_u32](svuint16_t op) + /// UUNPKHI Zresult.S, Zop.H /// - public static unsafe Vector ZeroExtendWideningUpper(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ZeroExtendWideningUpper(Vector value) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svunpkhi[_u64](svuint32_t op) - /// UUNPKHI Zresult.D, Zop.S + /// svuint64_t svunpkhi[_u64](svuint32_t op) + /// UUNPKHI Zresult.D, Zop.S /// - public static unsafe Vector ZeroExtendWideningUpper(Vector value) { throw new PlatformNotSupportedException(); } + public static Vector ZeroExtendWideningUpper(Vector value) { throw new PlatformNotSupportedException(); } // Interleave elements from high halves of two inputs /// - /// svuint8_t svzip2[_u8](svuint8_t op1, svuint8_t op2) - /// ZIP2 Zresult.B, Zop1.B, Zop2.B + /// svuint8_t svzip2[_u8](svuint8_t op1, svuint8_t op2) + /// ZIP2 Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector ZipHigh(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ZipHigh(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svzip2[_f64](svfloat64_t op1, svfloat64_t op2) - /// ZIP2 Zresult.D, Zop1.D, Zop2.D + /// svfloat64_t svzip2[_f64](svfloat64_t op1, svfloat64_t op2) + /// ZIP2 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector ZipHigh(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ZipHigh(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svzip2[_s16](svint16_t op1, svint16_t op2) - /// ZIP2 Zresult.H, Zop1.H, Zop2.H + /// svint16_t svzip2[_s16](svint16_t op1, svint16_t op2) + /// ZIP2 Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector ZipHigh(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ZipHigh(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svzip2[_s32](svint32_t op1, svint32_t op2) - /// ZIP2 Zresult.S, Zop1.S, Zop2.S + /// svint32_t svzip2[_s32](svint32_t op1, svint32_t op2) + /// ZIP2 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector ZipHigh(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ZipHigh(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svzip2[_s64](svint64_t op1, svint64_t op2) - /// ZIP2 Zresult.D, Zop1.D, Zop2.D + /// svint64_t svzip2[_s64](svint64_t op1, svint64_t op2) + /// ZIP2 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector ZipHigh(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ZipHigh(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svzip2[_s8](svint8_t op1, svint8_t op2) - /// ZIP2 Zresult.B, Zop1.B, Zop2.B + /// svint8_t svzip2[_s8](svint8_t op1, svint8_t op2) + /// ZIP2 Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector ZipHigh(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ZipHigh(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svzip2[_f32](svfloat32_t op1, svfloat32_t op2) - /// ZIP2 Zresult.S, Zop1.S, Zop2.S + /// svfloat32_t svzip2[_f32](svfloat32_t op1, svfloat32_t op2) + /// ZIP2 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector ZipHigh(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ZipHigh(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svzip2[_u16](svuint16_t op1, svuint16_t op2) - /// ZIP2 Zresult.H, Zop1.H, Zop2.H - /// svbool_t svzip2_b16(svbool_t op1, svbool_t op2) - /// ZIP2 Presult.H, Pop1.H, Pop2.H + /// svuint16_t svzip2[_u16](svuint16_t op1, svuint16_t op2) + /// ZIP2 Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector ZipHigh(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ZipHigh(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svzip2[_u32](svuint32_t op1, svuint32_t op2) - /// ZIP2 Zresult.S, Zop1.S, Zop2.S - /// svbool_t svzip2_b32(svbool_t op1, svbool_t op2) - /// ZIP2 Presult.S, Pop1.S, Pop2.S + /// svuint32_t svzip2[_u32](svuint32_t op1, svuint32_t op2) + /// ZIP2 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector ZipHigh(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ZipHigh(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svzip2[_u64](svuint64_t op1, svuint64_t op2) - /// ZIP2 Zresult.D, Zop1.D, Zop2.D - /// svbool_t svzip2_b64(svbool_t op1, svbool_t op2) - /// ZIP2 Presult.D, Pop1.D, Pop2.D + /// svuint64_t svzip2[_u64](svuint64_t op1, svuint64_t op2) + /// ZIP2 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector ZipHigh(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ZipHigh(Vector left, Vector right) { throw new PlatformNotSupportedException(); } // Interleave elements from low halves of two inputs /// - /// svuint8_t svzip1[_u8](svuint8_t op1, svuint8_t op2) - /// ZIP1 Zresult.B, Zop1.B, Zop2.B - /// svbool_t svzip1_b8(svbool_t op1, svbool_t op2) - /// ZIP1 Presult.B, Pop1.B, Pop2.B + /// svuint8_t svzip1[_u8](svuint8_t op1, svuint8_t op2) + /// ZIP1 Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector ZipLow(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ZipLow(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat64_t svzip1[_f64](svfloat64_t op1, svfloat64_t op2) - /// ZIP1 Zresult.D, Zop1.D, Zop2.D + /// svfloat64_t svzip1[_f64](svfloat64_t op1, svfloat64_t op2) + /// ZIP1 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector ZipLow(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ZipLow(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint16_t svzip1[_s16](svint16_t op1, svint16_t op2) - /// ZIP1 Zresult.H, Zop1.H, Zop2.H + /// svint16_t svzip1[_s16](svint16_t op1, svint16_t op2) + /// ZIP1 Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector ZipLow(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ZipLow(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint32_t svzip1[_s32](svint32_t op1, svint32_t op2) - /// ZIP1 Zresult.S, Zop1.S, Zop2.S + /// svint32_t svzip1[_s32](svint32_t op1, svint32_t op2) + /// ZIP1 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector ZipLow(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ZipLow(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint64_t svzip1[_s64](svint64_t op1, svint64_t op2) - /// ZIP1 Zresult.D, Zop1.D, Zop2.D + /// svint64_t svzip1[_s64](svint64_t op1, svint64_t op2) + /// ZIP1 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector ZipLow(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ZipLow(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svint8_t svzip1[_s8](svint8_t op1, svint8_t op2) - /// ZIP1 Zresult.B, Zop1.B, Zop2.B + /// svint8_t svzip1[_s8](svint8_t op1, svint8_t op2) + /// ZIP1 Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector ZipLow(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ZipLow(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svfloat32_t svzip1[_f32](svfloat32_t op1, svfloat32_t op2) - /// ZIP1 Zresult.S, Zop1.S, Zop2.S + /// svfloat32_t svzip1[_f32](svfloat32_t op1, svfloat32_t op2) + /// ZIP1 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector ZipLow(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ZipLow(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint16_t svzip1[_u16](svuint16_t op1, svuint16_t op2) - /// ZIP1 Zresult.H, Zop1.H, Zop2.H - /// svbool_t svzip1_b16(svbool_t op1, svbool_t op2) - /// ZIP1 Presult.H, Pop1.H, Pop2.H + /// svuint16_t svzip1[_u16](svuint16_t op1, svuint16_t op2) + /// ZIP1 Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector ZipLow(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ZipLow(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint32_t svzip1[_u32](svuint32_t op1, svuint32_t op2) - /// ZIP1 Zresult.S, Zop1.S, Zop2.S - /// svbool_t svzip1_b32(svbool_t op1, svbool_t op2) - /// ZIP1 Presult.S, Pop1.S, Pop2.S + /// svuint32_t svzip1[_u32](svuint32_t op1, svuint32_t op2) + /// ZIP1 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector ZipLow(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ZipLow(Vector left, Vector right) { throw new PlatformNotSupportedException(); } /// - /// svuint64_t svzip1[_u64](svuint64_t op1, svuint64_t op2) - /// ZIP1 Zresult.D, Zop1.D, Zop2.D - /// svbool_t svzip1_b64(svbool_t op1, svbool_t op2) - /// ZIP1 Presult.D, Pop1.D, Pop2.D + /// svuint64_t svzip1[_u64](svuint64_t op1, svuint64_t op2) + /// ZIP1 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector ZipLow(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + public static Vector ZipLow(Vector left, Vector right) { throw new PlatformNotSupportedException(); } } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.cs index 44777bcb012..4664271d600 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.cs @@ -8,9 +8,7 @@ namespace System.Runtime.Intrinsics.Arm { - /// - /// This class provides access to the ARM SVE hardware instructions via intrinsics - /// + /// Provides access to the ARM SVE hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] [Experimental(Experimentals.ArmSveDiagId, UrlFormat = Experimentals.SharedUrlFormat)] @@ -18,13 +16,20 @@ public abstract class Sve : AdvSimd { internal Sve() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the ARM SVE hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class Arm64 : AdvSimd.Arm64 { internal Arm64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } } @@ -32,3200 +37,3170 @@ internal Arm64() { } // Absolute value /// - /// svfloat64_t svabs[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) - /// svfloat64_t svabs[_f64]_x(svbool_t pg, svfloat64_t op) - /// svfloat64_t svabs[_f64]_z(svbool_t pg, svfloat64_t op) - /// FABS Ztied.D, Pg/M, Zop.D - /// FABS Ztied.D, Pg/M, Ztied.D + /// svfloat64_t svabs[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) + /// svfloat64_t svabs[_f64]_x(svbool_t pg, svfloat64_t op) + /// svfloat64_t svabs[_f64]_z(svbool_t pg, svfloat64_t op) + /// FABS Ztied.D, Pg/M, Zop.D + /// FABS Ztied.D, Pg/M, Ztied.D /// - public static unsafe Vector Abs(Vector value) => Abs(value); + public static Vector Abs(Vector value) => Abs(value); /// - /// svint16_t svabs[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) - /// svint16_t svabs[_s16]_x(svbool_t pg, svint16_t op) - /// svint16_t svabs[_s16]_z(svbool_t pg, svint16_t op) - /// ABS Zresult.H, Pg/M, Zop.H + /// svint16_t svabs[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) + /// svint16_t svabs[_s16]_x(svbool_t pg, svint16_t op) + /// svint16_t svabs[_s16]_z(svbool_t pg, svint16_t op) + /// ABS Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector Abs(Vector value) => Abs(value); + public static Vector Abs(Vector value) => Abs(value); /// - /// svint32_t svabs[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) - /// svint32_t svabs[_s32]_x(svbool_t pg, svint32_t op) - /// svint32_t svabs[_s32]_z(svbool_t pg, svint32_t op) - /// ABS Zresult.S, Pg/M, Zop.S + /// svint32_t svabs[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) + /// svint32_t svabs[_s32]_x(svbool_t pg, svint32_t op) + /// svint32_t svabs[_s32]_z(svbool_t pg, svint32_t op) + /// ABS Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector Abs(Vector value) => Abs(value); + public static Vector Abs(Vector value) => Abs(value); /// - /// svint64_t svabs[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) - /// svint64_t svabs[_s64]_x(svbool_t pg, svint64_t op) - /// svint64_t svabs[_s64]_z(svbool_t pg, svint64_t op) - /// ABS Zresult.D, Pg/M, Zop.D + /// svint64_t svabs[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) + /// svint64_t svabs[_s64]_x(svbool_t pg, svint64_t op) + /// svint64_t svabs[_s64]_z(svbool_t pg, svint64_t op) + /// ABS Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector Abs(Vector value) => Abs(value); + public static Vector Abs(Vector value) => Abs(value); /// - /// svint8_t svabs[_s8]_m(svint8_t inactive, svbool_t pg, svint8_t op) - /// svint8_t svabs[_s8]_x(svbool_t pg, svint8_t op) - /// svint8_t svabs[_s8]_z(svbool_t pg, svint8_t op) - /// ABS Zresult.B, Pg/M, Zop.B + /// svint8_t svabs[_s8]_m(svint8_t inactive, svbool_t pg, svint8_t op) + /// svint8_t svabs[_s8]_x(svbool_t pg, svint8_t op) + /// svint8_t svabs[_s8]_z(svbool_t pg, svint8_t op) + /// ABS Zresult.B, Pg/M, Zop.B /// - public static unsafe Vector Abs(Vector value) => Abs(value); + public static Vector Abs(Vector value) => Abs(value); /// - /// svfloat32_t svabs[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) - /// svfloat32_t svabs[_f32]_x(svbool_t pg, svfloat32_t op) - /// svfloat32_t svabs[_f32]_z(svbool_t pg, svfloat32_t op) - /// FABS Zresult.S, Pg/M, Zop.S + /// svfloat32_t svabs[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) + /// svfloat32_t svabs[_f32]_x(svbool_t pg, svfloat32_t op) + /// svfloat32_t svabs[_f32]_z(svbool_t pg, svfloat32_t op) + /// FABS Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector Abs(Vector value) => Abs(value); + public static Vector Abs(Vector value) => Abs(value); // Absolute compare greater than /// - /// svbool_t svacgt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FACGT Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svacgt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FACGT Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector AbsoluteCompareGreaterThan(Vector left, Vector right) => AbsoluteCompareGreaterThan(left, right); + public static Vector AbsoluteCompareGreaterThan(Vector left, Vector right) => AbsoluteCompareGreaterThan(left, right); /// - /// svbool_t svacgt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FACGT Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svacgt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FACGT Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector AbsoluteCompareGreaterThan(Vector left, Vector right) => AbsoluteCompareGreaterThan(left, right); + public static Vector AbsoluteCompareGreaterThan(Vector left, Vector right) => AbsoluteCompareGreaterThan(left, right); // Absolute compare greater than or equal to /// - /// svbool_t svacge[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FACGE Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svacge[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FACGE Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector AbsoluteCompareGreaterThanOrEqual(Vector left, Vector right) => AbsoluteCompareGreaterThanOrEqual(left, right); + public static Vector AbsoluteCompareGreaterThanOrEqual(Vector left, Vector right) => AbsoluteCompareGreaterThanOrEqual(left, right); /// - /// svbool_t svacge[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FACGE Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svacge[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FACGE Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector AbsoluteCompareGreaterThanOrEqual(Vector left, Vector right) => AbsoluteCompareGreaterThanOrEqual(left, right); + public static Vector AbsoluteCompareGreaterThanOrEqual(Vector left, Vector right) => AbsoluteCompareGreaterThanOrEqual(left, right); // Absolute compare less than /// - /// svbool_t svaclt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FACLT Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svaclt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FACLT Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector AbsoluteCompareLessThan(Vector left, Vector right) => AbsoluteCompareLessThan(left, right); + public static Vector AbsoluteCompareLessThan(Vector left, Vector right) => AbsoluteCompareLessThan(left, right); /// - /// svbool_t svaclt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FACLT Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svaclt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FACLT Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector AbsoluteCompareLessThan(Vector left, Vector right) => AbsoluteCompareLessThan(left, right); + public static Vector AbsoluteCompareLessThan(Vector left, Vector right) => AbsoluteCompareLessThan(left, right); // Absolute compare less than or equal to /// - /// svbool_t svacle[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FACLE Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svacle[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FACLE Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector AbsoluteCompareLessThanOrEqual(Vector left, Vector right) => AbsoluteCompareLessThanOrEqual(left, right); + public static Vector AbsoluteCompareLessThanOrEqual(Vector left, Vector right) => AbsoluteCompareLessThanOrEqual(left, right); /// - /// svbool_t svacle[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FACLE Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svacle[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FACLE Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector AbsoluteCompareLessThanOrEqual(Vector left, Vector right) => AbsoluteCompareLessThanOrEqual(left, right); + public static Vector AbsoluteCompareLessThanOrEqual(Vector left, Vector right) => AbsoluteCompareLessThanOrEqual(left, right); // Absolute difference /// - /// svuint8_t svabd[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svabd[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// UABD Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// svuint8_t svabd[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svabd[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// UABD Ztied1.B, Pg/M, Ztied1.B, Zop2.B /// - public static unsafe Vector AbsoluteDifference(Vector left, Vector right) => AbsoluteDifference(left, right); + public static Vector AbsoluteDifference(Vector left, Vector right) => AbsoluteDifference(left, right); /// - /// svfloat64_t svabd[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svabd[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svabd[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FABD Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svfloat64_t svabd[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svabd[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svabd[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FABD Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector AbsoluteDifference(Vector left, Vector right) => AbsoluteDifference(left, right); + public static Vector AbsoluteDifference(Vector left, Vector right) => AbsoluteDifference(left, right); /// - /// svint16_t svabd[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svabd[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svabd[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) - /// SABD Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// svint16_t svabd[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svabd[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svabd[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) + /// SABD Ztied1.H, Pg/M, Ztied1.H, Zop2.H /// - public static unsafe Vector AbsoluteDifference(Vector left, Vector right) => AbsoluteDifference(left, right); + public static Vector AbsoluteDifference(Vector left, Vector right) => AbsoluteDifference(left, right); /// - /// svint32_t svabd[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svabd[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svabd[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) - /// SABD Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svint32_t svabd[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svabd[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svabd[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) + /// SABD Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector AbsoluteDifference(Vector left, Vector right) => AbsoluteDifference(left, right); + public static Vector AbsoluteDifference(Vector left, Vector right) => AbsoluteDifference(left, right); /// - /// svint64_t svabd[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svabd[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svabd[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) - /// SABD Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svint64_t svabd[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svabd[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svabd[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) + /// SABD Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector AbsoluteDifference(Vector left, Vector right) => AbsoluteDifference(left, right); + public static Vector AbsoluteDifference(Vector left, Vector right) => AbsoluteDifference(left, right); /// - /// svint8_t svabd[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svabd[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svabd[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) - /// SABD Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// svint8_t svabd[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svabd[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svabd[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) + /// SABD Ztied1.B, Pg/M, Ztied1.B, Zop2.B /// - public static unsafe Vector AbsoluteDifference(Vector left, Vector right) => AbsoluteDifference(left, right); + public static Vector AbsoluteDifference(Vector left, Vector right) => AbsoluteDifference(left, right); /// - /// svfloat32_t svabd[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svabd[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svabd[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FABD Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svfloat32_t svabd[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svabd[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svabd[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FABD Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector AbsoluteDifference(Vector left, Vector right) => AbsoluteDifference(left, right); + public static Vector AbsoluteDifference(Vector left, Vector right) => AbsoluteDifference(left, right); /// - /// svuint16_t svabd[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svabd[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svabd[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// UABD Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// svuint16_t svabd[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svabd[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svabd[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// UABD Ztied1.H, Pg/M, Ztied1.H, Zop2.H /// - public static unsafe Vector AbsoluteDifference(Vector left, Vector right) => AbsoluteDifference(left, right); + public static Vector AbsoluteDifference(Vector left, Vector right) => AbsoluteDifference(left, right); /// - /// svuint32_t svabd[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svabd[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svabd[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// UABD Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svuint32_t svabd[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svabd[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svabd[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// UABD Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector AbsoluteDifference(Vector left, Vector right) => AbsoluteDifference(left, right); + public static Vector AbsoluteDifference(Vector left, Vector right) => AbsoluteDifference(left, right); /// - /// svuint64_t svabd[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svabd[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svabd[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// UABD Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svuint64_t svabd[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svabd[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svabd[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// UABD Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector AbsoluteDifference(Vector left, Vector right) => AbsoluteDifference(left, right); + public static Vector AbsoluteDifference(Vector left, Vector right) => AbsoluteDifference(left, right); // Add /// - /// svuint8_t svadd[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svadd[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svadd[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// ADD Zresult.B, Zop1.B, Zop2.B + /// svuint8_t svadd[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svadd[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svadd[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// ADD Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector Add(Vector left, Vector right) => Add(left, right); + public static Vector Add(Vector left, Vector right) => Add(left, right); /// - /// svfloat64_t svadd[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svadd[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svadd[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FADD Zresult.D, Zop1.D, Zop2.D + /// svfloat64_t svadd[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svadd[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svadd[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FADD Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector Add(Vector left, Vector right) => Add(left, right); + public static Vector Add(Vector left, Vector right) => Add(left, right); /// - /// svint16_t svadd[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svadd[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svadd[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) - /// ADD Zresult.H, Zop1.H, Zop2.H + /// svint16_t svadd[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svadd[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svadd[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) + /// ADD Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector Add(Vector left, Vector right) => Add(left, right); + public static Vector Add(Vector left, Vector right) => Add(left, right); /// - /// svint32_t svadd[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svadd[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svadd[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) - /// ADD Zresult.S, Zop1.S, Zop2.S + /// svint32_t svadd[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svadd[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svadd[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) + /// ADD Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector Add(Vector left, Vector right) => Add(left, right); + public static Vector Add(Vector left, Vector right) => Add(left, right); /// - /// svint64_t svadd[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svadd[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svadd[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) - /// ADD Zresult.D, Zop1.D, Zop2.D + /// svint64_t svadd[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svadd[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svadd[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) + /// ADD Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector Add(Vector left, Vector right) => Add(left, right); + public static Vector Add(Vector left, Vector right) => Add(left, right); /// - /// svint8_t svadd[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svadd[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svadd[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) - /// ADD Zresult.B, Zop1.B, Zop2.B + /// svint8_t svadd[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svadd[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svadd[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) + /// ADD Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector Add(Vector left, Vector right) => Add(left, right); + public static Vector Add(Vector left, Vector right) => Add(left, right); /// - /// svfloat32_t svadd[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svadd[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svadd[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FADD Zresult.S, Zop1.S, Zop2.S + /// svfloat32_t svadd[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svadd[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svadd[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FADD Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector Add(Vector left, Vector right) => Add(left, right); + public static Vector Add(Vector left, Vector right) => Add(left, right); /// - /// svuint16_t svadd[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svadd[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svadd[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// ADD Zresult.H, Zop1.H, Zop2.H + /// svuint16_t svadd[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svadd[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svadd[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// ADD Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector Add(Vector left, Vector right) => Add(left, right); + public static Vector Add(Vector left, Vector right) => Add(left, right); /// - /// svuint32_t svadd[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svadd[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svadd[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// ADD Zresult.S, Zop1.S, Zop2.S + /// svuint32_t svadd[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svadd[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svadd[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// ADD Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector Add(Vector left, Vector right) => Add(left, right); + public static Vector Add(Vector left, Vector right) => Add(left, right); /// - /// svuint64_t svadd[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svadd[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svadd[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// ADD Zresult.D, Zop1.D, Zop2.D + /// svuint64_t svadd[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svadd[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svadd[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// ADD Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector Add(Vector left, Vector right) => Add(left, right); + public static Vector Add(Vector left, Vector right) => Add(left, right); // Add reduction /// - /// float64_t svaddv[_f64](svbool_t pg, svfloat64_t op) - /// FADDV Dresult, Pg, Zop.D + /// float64_t svaddv[_f64](svbool_t pg, svfloat64_t op) + /// FADDV Dresult, Pg, Zop.D /// - public static unsafe Vector AddAcross(Vector value) => AddAcross(value); + public static Vector AddAcross(Vector value) => AddAcross(value); /// - /// int64_t svaddv[_s16](svbool_t pg, svint16_t op) - /// SADDV Dresult, Pg, Zop.H + /// int64_t svaddv[_s16](svbool_t pg, svint16_t op) + /// SADDV Dresult, Pg, Zop.H /// - public static unsafe Vector AddAcross(Vector value) => AddAcross(value); + public static Vector AddAcross(Vector value) => AddAcross(value); /// - /// int64_t svaddv[_s32](svbool_t pg, svint32_t op) - /// SADDV Dresult, Pg, Zop.S + /// int64_t svaddv[_s32](svbool_t pg, svint32_t op) + /// SADDV Dresult, Pg, Zop.S /// - public static unsafe Vector AddAcross(Vector value) => AddAcross(value); + public static Vector AddAcross(Vector value) => AddAcross(value); /// - /// int64_t svaddv[_s8](svbool_t pg, svint8_t op) - /// SADDV Dresult, Pg, Zop.B + /// int64_t svaddv[_s8](svbool_t pg, svint8_t op) + /// SADDV Dresult, Pg, Zop.B /// - public static unsafe Vector AddAcross(Vector value) => AddAcross(value); + public static Vector AddAcross(Vector value) => AddAcross(value); /// - /// int64_t svaddv[_s64](svbool_t pg, svint64_t op) - /// UADDV Dresult, Pg, Zop.D + /// int64_t svaddv[_s64](svbool_t pg, svint64_t op) + /// UADDV Dresult, Pg, Zop.D /// - public static unsafe Vector AddAcross(Vector value) => AddAcross(value); + public static Vector AddAcross(Vector value) => AddAcross(value); /// - /// float32_t svaddv[_f32](svbool_t pg, svfloat32_t op) - /// FADDV Sresult, Pg, Zop.S + /// float32_t svaddv[_f32](svbool_t pg, svfloat32_t op) + /// FADDV Sresult, Pg, Zop.S /// - public static unsafe Vector AddAcross(Vector value) => AddAcross(value); + public static Vector AddAcross(Vector value) => AddAcross(value); /// - /// uint64_t svaddv[_u8](svbool_t pg, svuint8_t op) - /// UADDV Dresult, Pg, Zop.B + /// uint64_t svaddv[_u8](svbool_t pg, svuint8_t op) + /// UADDV Dresult, Pg, Zop.B /// - public static unsafe Vector AddAcross(Vector value) => AddAcross(value); + public static Vector AddAcross(Vector value) => AddAcross(value); /// - /// uint64_t svaddv[_u16](svbool_t pg, svuint16_t op) - /// UADDV Dresult, Pg, Zop.H + /// uint64_t svaddv[_u16](svbool_t pg, svuint16_t op) + /// UADDV Dresult, Pg, Zop.H /// - public static unsafe Vector AddAcross(Vector value) => AddAcross(value); + public static Vector AddAcross(Vector value) => AddAcross(value); /// - /// uint64_t svaddv[_u32](svbool_t pg, svuint32_t op) - /// UADDV Dresult, Pg, Zop.S + /// uint64_t svaddv[_u32](svbool_t pg, svuint32_t op) + /// UADDV Dresult, Pg, Zop.S /// - public static unsafe Vector AddAcross(Vector value) => AddAcross(value); + public static Vector AddAcross(Vector value) => AddAcross(value); /// - /// uint64_t svaddv[_u64](svbool_t pg, svuint64_t op) - /// UADDV Dresult, Pg, Zop.D + /// uint64_t svaddv[_u64](svbool_t pg, svuint64_t op) + /// UADDV Dresult, Pg, Zop.D /// - public static unsafe Vector AddAcross(Vector value) => AddAcross(value); + public static Vector AddAcross(Vector value) => AddAcross(value); // Complex add with rotate /// - /// svfloat64_t svcadd[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2, uint64_t imm_rotation) - /// svfloat64_t svcadd[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2, uint64_t imm_rotation) - /// svfloat64_t svcadd[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2, uint64_t imm_rotation) - /// FCADD Ztied1.D, Pg/M, Ztied1.D, Zop2.D, #imm_rotation + /// svfloat64_t svcadd[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2, uint64_t imm_rotation) + /// svfloat64_t svcadd[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2, uint64_t imm_rotation) + /// svfloat64_t svcadd[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2, uint64_t imm_rotation) + /// FCADD Ztied1.D, Pg/M, Ztied1.D, Zop2.D, #imm_rotation /// - public static unsafe Vector AddRotateComplex(Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(1))] byte rotation) => AddRotateComplex(left, right, rotation); + public static Vector AddRotateComplex(Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(1))] byte rotation) => AddRotateComplex(left, right, rotation); /// - /// svfloat32_t svcadd[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2, uint64_t imm_rotation) - /// svfloat32_t svcadd[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2, uint64_t imm_rotation) - /// svfloat32_t svcadd[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2, uint64_t imm_rotation) - /// FCADD Ztied1.S, Pg/M, Ztied1.S, Zop2.S, #imm_rotation - /// FCADD Ztied1.S, Pg/M, Ztied1.S, Zop2.S, #imm_rotation + /// svfloat32_t svcadd[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2, uint64_t imm_rotation) + /// svfloat32_t svcadd[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2, uint64_t imm_rotation) + /// svfloat32_t svcadd[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2, uint64_t imm_rotation) + /// FCADD Ztied1.S, Pg/M, Ztied1.S, Zop2.S, #imm_rotation + /// FCADD Ztied1.S, Pg/M, Ztied1.S, Zop2.S, #imm_rotation /// - public static unsafe Vector AddRotateComplex(Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(1))] byte rotation) => AddRotateComplex(left, right, rotation); + public static Vector AddRotateComplex(Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(1))] byte rotation) => AddRotateComplex(left, right, rotation); // Saturating add /// - /// svuint8_t svqadd[_u8](svuint8_t op1, svuint8_t op2) - /// UQADD Zresult.B, Zop1.B, Zop2.B + /// svuint8_t svqadd[_u8](svuint8_t op1, svuint8_t op2) + /// UQADD Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector AddSaturate(Vector left, Vector right) => AddSaturate(left, right); + public static Vector AddSaturate(Vector left, Vector right) => AddSaturate(left, right); /// - /// svint16_t svqadd[_s16](svint16_t op1, svint16_t op2) - /// SQADD Zresult.H, Zop1.H, Zop2.H + /// svint16_t svqadd[_s16](svint16_t op1, svint16_t op2) + /// SQADD Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector AddSaturate(Vector left, Vector right) => AddSaturate(left, right); + public static Vector AddSaturate(Vector left, Vector right) => AddSaturate(left, right); /// - /// svint32_t svqadd[_s32](svint32_t op1, svint32_t op2) - /// SQADD Zresult.S, Zop1.S, Zop2.S + /// svint32_t svqadd[_s32](svint32_t op1, svint32_t op2) + /// SQADD Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector AddSaturate(Vector left, Vector right) => AddSaturate(left, right); + public static Vector AddSaturate(Vector left, Vector right) => AddSaturate(left, right); /// - /// svint64_t svqadd[_s64](svint64_t op1, svint64_t op2) - /// SQADD Zresult.D, Zop1.D, Zop2.D + /// svint64_t svqadd[_s64](svint64_t op1, svint64_t op2) + /// SQADD Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector AddSaturate(Vector left, Vector right) => AddSaturate(left, right); + public static Vector AddSaturate(Vector left, Vector right) => AddSaturate(left, right); /// - /// svint8_t svqadd[_s8](svint8_t op1, svint8_t op2) - /// SQADD Zresult.B, Zop1.B, Zop2.B + /// svint8_t svqadd[_s8](svint8_t op1, svint8_t op2) + /// SQADD Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector AddSaturate(Vector left, Vector right) => AddSaturate(left, right); + public static Vector AddSaturate(Vector left, Vector right) => AddSaturate(left, right); /// - /// svuint16_t svqadd[_u16](svuint16_t op1, svuint16_t op2) - /// UQADD Zresult.H, Zop1.H, Zop2.H + /// svuint16_t svqadd[_u16](svuint16_t op1, svuint16_t op2) + /// UQADD Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector AddSaturate(Vector left, Vector right) => AddSaturate(left, right); + public static Vector AddSaturate(Vector left, Vector right) => AddSaturate(left, right); /// - /// svuint32_t svqadd[_u32](svuint32_t op1, svuint32_t op2) - /// UQADD Zresult.S, Zop1.S, Zop2.S + /// svuint32_t svqadd[_u32](svuint32_t op1, svuint32_t op2) + /// UQADD Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector AddSaturate(Vector left, Vector right) => AddSaturate(left, right); + public static Vector AddSaturate(Vector left, Vector right) => AddSaturate(left, right); /// - /// svuint64_t svqadd[_u64](svuint64_t op1, svuint64_t op2) - /// UQADD Zresult.D, Zop1.D, Zop2.D + /// svuint64_t svqadd[_u64](svuint64_t op1, svuint64_t op2) + /// UQADD Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector AddSaturate(Vector left, Vector right) => AddSaturate(left, right); + public static Vector AddSaturate(Vector left, Vector right) => AddSaturate(left, right); // Add reduction (strictly-ordered) /// - /// float64_t svadda[_f64](svbool_t pg, float64_t initial, svfloat64_t op) - /// FADDA Dtied, Pg, Dtied, Zop.D + /// float64_t svadda[_f64](svbool_t pg, float64_t initial, svfloat64_t op) + /// FADDA Dtied, Pg, Dtied, Zop.D /// - public static unsafe Vector AddSequentialAcross(Vector initial, Vector value) => AddSequentialAcross(initial, value); + public static Vector AddSequentialAcross(Vector initial, Vector value) => AddSequentialAcross(initial, value); /// - /// float32_t svadda[_f32](svbool_t pg, float32_t initial, svfloat32_t op) - /// FADDA Stied, Pg, Stied, Zop.S + /// float32_t svadda[_f32](svbool_t pg, float32_t initial, svfloat32_t op) + /// FADDA Stied, Pg, Stied, Zop.S /// - public static unsafe Vector AddSequentialAcross(Vector initial, Vector value) => AddSequentialAcross(initial, value); + public static Vector AddSequentialAcross(Vector initial, Vector value) => AddSequentialAcross(initial, value); // Bitwise AND /// - /// svuint8_t svand[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svand[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svand[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// AND Zresult.D, Zop1.D, Zop2.D - /// svbool_t svand[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// AND Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svuint8_t svand[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svand[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svand[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// AND Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector And(Vector left, Vector right) => And(left, right); + public static Vector And(Vector left, Vector right) => And(left, right); /// - /// svint16_t svand[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svand[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svand[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) - /// AND Zresult.D, Zop1.D, Zop2.D - /// svbool_t svand[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// AND Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svint16_t svand[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svand[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svand[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) + /// AND Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector And(Vector left, Vector right) => And(left, right); + public static Vector And(Vector left, Vector right) => And(left, right); /// - /// svint32_t svand[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svand[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svand[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) - /// AND Zresult.D, Zop1.D, Zop2.D - /// svbool_t svand[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// AND Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svint32_t svand[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svand[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svand[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) + /// AND Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector And(Vector left, Vector right) => And(left, right); + public static Vector And(Vector left, Vector right) => And(left, right); /// - /// svint64_t svand[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svand[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svand[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) - /// AND Zresult.D, Zop1.D, Zop2.D - /// svbool_t svand[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// AND Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svint64_t svand[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svand[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svand[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) + /// AND Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector And(Vector left, Vector right) => And(left, right); + public static Vector And(Vector left, Vector right) => And(left, right); /// - /// svint8_t svand[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svand[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svand[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) - /// AND Zresult.D, Zop1.D, Zop2.D - /// svbool_t svand[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// AND Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svint8_t svand[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svand[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svand[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) + /// AND Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector And(Vector left, Vector right) => And(left, right); + public static Vector And(Vector left, Vector right) => And(left, right); /// - /// svuint16_t svand[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svand[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svand[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// AND Zresult.D, Zop1.D, Zop2.D - /// svbool_t svand[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// AND Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svuint16_t svand[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svand[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svand[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// AND Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector And(Vector left, Vector right) => And(left, right); + public static Vector And(Vector left, Vector right) => And(left, right); /// - /// svuint32_t svand[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svand[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svand[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// AND Zresult.D, Zop1.D, Zop2.D - /// svbool_t svand[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// AND Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svuint32_t svand[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svand[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svand[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// AND Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector And(Vector left, Vector right) => And(left, right); + public static Vector And(Vector left, Vector right) => And(left, right); /// - /// svuint64_t svand[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svand[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svand[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// AND Zresult.D, Zop1.D, Zop2.D - /// svbool_t svand[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// AND Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svuint64_t svand[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svand[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svand[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// AND Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector And(Vector left, Vector right) => And(left, right); + public static Vector And(Vector left, Vector right) => And(left, right); // Bitwise AND reduction to scalar /// - /// uint8_t svandv[_u8](svbool_t pg, svuint8_t op) - /// ANDV Bresult, Pg, Zop.B + /// uint8_t svandv[_u8](svbool_t pg, svuint8_t op) + /// ANDV Bresult, Pg, Zop.B /// - public static unsafe Vector AndAcross(Vector value) => AndAcross(value); + public static Vector AndAcross(Vector value) => AndAcross(value); /// - /// int16_t svandv[_s16](svbool_t pg, svint16_t op) - /// ANDV Hresult, Pg, Zop.H + /// int16_t svandv[_s16](svbool_t pg, svint16_t op) + /// ANDV Hresult, Pg, Zop.H /// - public static unsafe Vector AndAcross(Vector value) => AndAcross(value); + public static Vector AndAcross(Vector value) => AndAcross(value); /// - /// int32_t svandv[_s32](svbool_t pg, svint32_t op) - /// ANDV Sresult, Pg, Zop.S + /// int32_t svandv[_s32](svbool_t pg, svint32_t op) + /// ANDV Sresult, Pg, Zop.S /// - public static unsafe Vector AndAcross(Vector value) => AndAcross(value); + public static Vector AndAcross(Vector value) => AndAcross(value); /// - /// int64_t svandv[_s64](svbool_t pg, svint64_t op) - /// ANDV Dresult, Pg, Zop.D + /// int64_t svandv[_s64](svbool_t pg, svint64_t op) + /// ANDV Dresult, Pg, Zop.D /// - public static unsafe Vector AndAcross(Vector value) => AndAcross(value); + public static Vector AndAcross(Vector value) => AndAcross(value); /// - /// int8_t svandv[_s8](svbool_t pg, svint8_t op) - /// ANDV Bresult, Pg, Zop.B + /// int8_t svandv[_s8](svbool_t pg, svint8_t op) + /// ANDV Bresult, Pg, Zop.B /// - public static unsafe Vector AndAcross(Vector value) => AndAcross(value); + public static Vector AndAcross(Vector value) => AndAcross(value); /// - /// uint16_t svandv[_u16](svbool_t pg, svuint16_t op) - /// ANDV Hresult, Pg, Zop.H + /// uint16_t svandv[_u16](svbool_t pg, svuint16_t op) + /// ANDV Hresult, Pg, Zop.H /// - public static unsafe Vector AndAcross(Vector value) => AndAcross(value); + public static Vector AndAcross(Vector value) => AndAcross(value); /// - /// uint32_t svandv[_u32](svbool_t pg, svuint32_t op) - /// ANDV Sresult, Pg, Zop.S + /// uint32_t svandv[_u32](svbool_t pg, svuint32_t op) + /// ANDV Sresult, Pg, Zop.S /// - public static unsafe Vector AndAcross(Vector value) => AndAcross(value); + public static Vector AndAcross(Vector value) => AndAcross(value); /// - /// uint64_t svandv[_u64](svbool_t pg, svuint64_t op) - /// ANDV Dresult, Pg, Zop.D + /// uint64_t svandv[_u64](svbool_t pg, svuint64_t op) + /// ANDV Dresult, Pg, Zop.D /// - public static unsafe Vector AndAcross(Vector value) => AndAcross(value); + public static Vector AndAcross(Vector value) => AndAcross(value); // Bitwise clear /// - /// svuint8_t svbic[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svbic[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svbic[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// BIC Ztied1.B, Pg/M, Ztied1.B, Zop2.B - /// BIC Zresult.D, Zop1.D, Zop2.D - /// svbool_t svbic[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BIC Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svuint8_t svbic[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svbic[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svbic[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// BIC Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// BIC Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector BitwiseClear(Vector left, Vector right) => BitwiseClear(left, right); + public static Vector BitwiseClear(Vector left, Vector right) => BitwiseClear(left, right); /// - /// svint16_t svbic[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svbic[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svbic[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) - /// BIC Ztied1.H, Pg/M, Ztied1.H, Zop2.H - /// BIC Zresult.D, Zop1.D, Zop2.D - /// svbool_t svbic[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BIC Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svint16_t svbic[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svbic[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svbic[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) + /// BIC Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// BIC Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector BitwiseClear(Vector left, Vector right) => BitwiseClear(left, right); + public static Vector BitwiseClear(Vector left, Vector right) => BitwiseClear(left, right); /// - /// svint32_t svbic[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svbic[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svbic[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) - /// BIC Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// BIC Zresult.D, Zop1.D, Zop2.D - /// svbool_t svbic[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BIC Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svint32_t svbic[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svbic[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svbic[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) + /// BIC Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// BIC Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector BitwiseClear(Vector left, Vector right) => BitwiseClear(left, right); + public static Vector BitwiseClear(Vector left, Vector right) => BitwiseClear(left, right); /// - /// svint64_t svbic[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svbic[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svbic[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) - /// BIC Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// BIC Zresult.D, Zop1.D, Zop2.D - /// svbool_t svbic[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BIC Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svint64_t svbic[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svbic[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svbic[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) + /// BIC Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// BIC Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector BitwiseClear(Vector left, Vector right) => BitwiseClear(left, right); + public static Vector BitwiseClear(Vector left, Vector right) => BitwiseClear(left, right); /// - /// svint8_t svbic[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svbic[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svbic[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) - /// BIC Ztied1.B, Pg/M, Ztied1.B, Zop2.B - /// BIC Zresult.D, Zop1.D, Zop2.D - /// svbool_t svbic[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BIC Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svint8_t svbic[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svbic[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svbic[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) + /// BIC Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// BIC Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector BitwiseClear(Vector left, Vector right) => BitwiseClear(left, right); + public static Vector BitwiseClear(Vector left, Vector right) => BitwiseClear(left, right); /// - /// svuint16_t svbic[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svbic[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svbic[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// BIC Ztied1.H, Pg/M, Ztied1.H, Zop2.H - /// BIC Zresult.D, Zop1.D, Zop2.D - /// svbool_t svbic[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BIC Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svuint16_t svbic[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svbic[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svbic[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// BIC Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// BIC Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector BitwiseClear(Vector left, Vector right) => BitwiseClear(left, right); + public static Vector BitwiseClear(Vector left, Vector right) => BitwiseClear(left, right); /// - /// svuint32_t svbic[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svbic[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svbic[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// BIC Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// BIC Zresult.D, Zop1.D, Zop2.D - /// svbool_t svbic[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BIC Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svuint32_t svbic[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svbic[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svbic[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// BIC Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// BIC Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector BitwiseClear(Vector left, Vector right) => BitwiseClear(left, right); + public static Vector BitwiseClear(Vector left, Vector right) => BitwiseClear(left, right); /// - /// svuint64_t svbic[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svbic[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svbic[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// BIC Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// BIC Zresult.D, Zop1.D, Zop2.D - /// svbool_t svbic[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BIC Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svuint64_t svbic[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svbic[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svbic[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// BIC Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// BIC Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector BitwiseClear(Vector left, Vector right) => BitwiseClear(left, right); + public static Vector BitwiseClear(Vector left, Vector right) => BitwiseClear(left, right); // Logically invert boolean condition /// - /// svuint8_t svcnot[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) - /// svuint8_t svcnot[_u8]_x(svbool_t pg, svuint8_t op) - /// svuint8_t svcnot[_u8]_z(svbool_t pg, svuint8_t op) - /// CNOT Zresult.B, Pg/M, Zop.B + /// svuint8_t svcnot[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) + /// svuint8_t svcnot[_u8]_x(svbool_t pg, svuint8_t op) + /// svuint8_t svcnot[_u8]_z(svbool_t pg, svuint8_t op) + /// CNOT Zresult.B, Pg/M, Zop.B /// - public static unsafe Vector BooleanNot(Vector value) => BooleanNot(value); + public static Vector BooleanNot(Vector value) => BooleanNot(value); /// - /// svint16_t svcnot[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) - /// svint16_t svcnot[_s16]_x(svbool_t pg, svint16_t op) - /// svint16_t svcnot[_s16]_z(svbool_t pg, svint16_t op) - /// CNOT Zresult.H, Pg/M, Zop.H + /// svint16_t svcnot[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) + /// svint16_t svcnot[_s16]_x(svbool_t pg, svint16_t op) + /// svint16_t svcnot[_s16]_z(svbool_t pg, svint16_t op) + /// CNOT Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector BooleanNot(Vector value) => BooleanNot(value); + public static Vector BooleanNot(Vector value) => BooleanNot(value); /// - /// svint32_t svcnot[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) - /// svint32_t svcnot[_s32]_x(svbool_t pg, svint32_t op) - /// svint32_t svcnot[_s32]_z(svbool_t pg, svint32_t op) - /// CNOT Zresult.S, Pg/M, Zop.S + /// svint32_t svcnot[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) + /// svint32_t svcnot[_s32]_x(svbool_t pg, svint32_t op) + /// svint32_t svcnot[_s32]_z(svbool_t pg, svint32_t op) + /// CNOT Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector BooleanNot(Vector value) => BooleanNot(value); + public static Vector BooleanNot(Vector value) => BooleanNot(value); /// - /// svint64_t svcnot[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) - /// svint64_t svcnot[_s64]_x(svbool_t pg, svint64_t op) - /// svint64_t svcnot[_s64]_z(svbool_t pg, svint64_t op) - /// CNOT Zresult.D, Pg/M, Zop.D + /// svint64_t svcnot[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) + /// svint64_t svcnot[_s64]_x(svbool_t pg, svint64_t op) + /// svint64_t svcnot[_s64]_z(svbool_t pg, svint64_t op) + /// CNOT Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector BooleanNot(Vector value) => BooleanNot(value); + public static Vector BooleanNot(Vector value) => BooleanNot(value); /// - /// svint8_t svcnot[_s8]_m(svint8_t inactive, svbool_t pg, svint8_t op) - /// svint8_t svcnot[_s8]_x(svbool_t pg, svint8_t op) - /// svint8_t svcnot[_s8]_z(svbool_t pg, svint8_t op) - /// CNOT Zresult.B, Pg/M, Zop.B + /// svint8_t svcnot[_s8]_m(svint8_t inactive, svbool_t pg, svint8_t op) + /// svint8_t svcnot[_s8]_x(svbool_t pg, svint8_t op) + /// svint8_t svcnot[_s8]_z(svbool_t pg, svint8_t op) + /// CNOT Zresult.B, Pg/M, Zop.B /// - public static unsafe Vector BooleanNot(Vector value) => BooleanNot(value); + public static Vector BooleanNot(Vector value) => BooleanNot(value); /// - /// svuint16_t svcnot[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) - /// svuint16_t svcnot[_u16]_x(svbool_t pg, svuint16_t op) - /// svuint16_t svcnot[_u16]_z(svbool_t pg, svuint16_t op) - /// CNOT Zresult.H, Pg/M, Zop.H + /// svuint16_t svcnot[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) + /// svuint16_t svcnot[_u16]_x(svbool_t pg, svuint16_t op) + /// svuint16_t svcnot[_u16]_z(svbool_t pg, svuint16_t op) + /// CNOT Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector BooleanNot(Vector value) => BooleanNot(value); + public static Vector BooleanNot(Vector value) => BooleanNot(value); /// - /// svuint32_t svcnot[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) - /// svuint32_t svcnot[_u32]_x(svbool_t pg, svuint32_t op) - /// svuint32_t svcnot[_u32]_z(svbool_t pg, svuint32_t op) - /// CNOT Zresult.S, Pg/M, Zop.S + /// svuint32_t svcnot[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) + /// svuint32_t svcnot[_u32]_x(svbool_t pg, svuint32_t op) + /// svuint32_t svcnot[_u32]_z(svbool_t pg, svuint32_t op) + /// CNOT Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector BooleanNot(Vector value) => BooleanNot(value); + public static Vector BooleanNot(Vector value) => BooleanNot(value); /// - /// svuint64_t svcnot[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) - /// svuint64_t svcnot[_u64]_x(svbool_t pg, svuint64_t op) - /// svuint64_t svcnot[_u64]_z(svbool_t pg, svuint64_t op) - /// CNOT Zresult.D, Pg/M, Zop.D + /// svuint64_t svcnot[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) + /// svuint64_t svcnot[_u64]_x(svbool_t pg, svuint64_t op) + /// svuint64_t svcnot[_u64]_z(svbool_t pg, svuint64_t op) + /// CNOT Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector BooleanNot(Vector value) => BooleanNot(value); + public static Vector BooleanNot(Vector value) => BooleanNot(value); // Shuffle active elements of vector to the right and fill with zero /// - /// svfloat64_t svcompact[_f64](svbool_t pg, svfloat64_t op) - /// COMPACT Zresult.D, Pg, Zop.D + /// svfloat64_t svcompact[_f64](svbool_t pg, svfloat64_t op) + /// COMPACT Zresult.D, Pg, Zop.D /// - public static unsafe Vector Compact(Vector mask, Vector value) => Compact(mask, value); + public static Vector Compact(Vector mask, Vector value) => Compact(mask, value); /// - /// svint32_t svcompact[_s32](svbool_t pg, svint32_t op) - /// COMPACT Zresult.S, Pg, Zop.S + /// svint32_t svcompact[_s32](svbool_t pg, svint32_t op) + /// COMPACT Zresult.S, Pg, Zop.S /// - public static unsafe Vector Compact(Vector mask, Vector value) => Compact(mask, value); + public static Vector Compact(Vector mask, Vector value) => Compact(mask, value); /// - /// svint64_t svcompact[_s64](svbool_t pg, svint64_t op) - /// COMPACT Zresult.D, Pg, Zop.D + /// svint64_t svcompact[_s64](svbool_t pg, svint64_t op) + /// COMPACT Zresult.D, Pg, Zop.D /// - public static unsafe Vector Compact(Vector mask, Vector value) => Compact(mask, value); + public static Vector Compact(Vector mask, Vector value) => Compact(mask, value); /// - /// svfloat32_t svcompact[_f32](svbool_t pg, svfloat32_t op) - /// COMPACT Zresult.S, Pg, Zop.S + /// svfloat32_t svcompact[_f32](svbool_t pg, svfloat32_t op) + /// COMPACT Zresult.S, Pg, Zop.S /// - public static unsafe Vector Compact(Vector mask, Vector value) => Compact(mask, value); + public static Vector Compact(Vector mask, Vector value) => Compact(mask, value); /// - /// svuint32_t svcompact[_u32](svbool_t pg, svuint32_t op) - /// COMPACT Zresult.S, Pg, Zop.S + /// svuint32_t svcompact[_u32](svbool_t pg, svuint32_t op) + /// COMPACT Zresult.S, Pg, Zop.S /// - public static unsafe Vector Compact(Vector mask, Vector value) => Compact(mask, value); + public static Vector Compact(Vector mask, Vector value) => Compact(mask, value); /// - /// svuint64_t svcompact[_u64](svbool_t pg, svuint64_t op) - /// COMPACT Zresult.D, Pg, Zop.D + /// svuint64_t svcompact[_u64](svbool_t pg, svuint64_t op) + /// COMPACT Zresult.D, Pg, Zop.D /// - public static unsafe Vector Compact(Vector mask, Vector value) => Compact(mask, value); + public static Vector Compact(Vector mask, Vector value) => Compact(mask, value); // Compare equal to /// - /// svbool_t svcmpeq[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) - /// CMPEQ Presult.B, Pg/Z, Zop1.B, Zop2.B + /// svbool_t svcmpeq[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) + /// CMPEQ Presult.B, Pg/Z, Zop1.B, Zop2.B /// - public static unsafe Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); + public static Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); /// - /// svbool_t svcmpeq[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FCMEQ Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpeq[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FCMEQ Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); + public static Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); /// - /// svbool_t svcmpeq[_s16](svbool_t pg, svint16_t op1, svint16_t op2) - /// CMPEQ Presult.H, Pg/Z, Zop1.H, Zop2.H + /// svbool_t svcmpeq[_s16](svbool_t pg, svint16_t op1, svint16_t op2) + /// CMPEQ Presult.H, Pg/Z, Zop1.H, Zop2.H /// - public static unsafe Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); + public static Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); /// - /// svbool_t svcmpeq_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) - /// CMPEQ Presult.H, Pg/Z, Zop1.H, Zop2.D + /// svbool_t svcmpeq_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) + /// CMPEQ Presult.H, Pg/Z, Zop1.H, Zop2.D /// - public static unsafe Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); + public static Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); /// - /// svbool_t svcmpeq[_s32](svbool_t pg, svint32_t op1, svint32_t op2) - /// CMPEQ Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpeq[_s32](svbool_t pg, svint32_t op1, svint32_t op2) + /// CMPEQ Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); + public static Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); /// - /// svbool_t svcmpeq_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) - /// CMPEQ Presult.S, Pg/Z, Zop1.S, Zop2.D + /// svbool_t svcmpeq_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) + /// CMPEQ Presult.S, Pg/Z, Zop1.S, Zop2.D /// - public static unsafe Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); + public static Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); /// - /// svbool_t svcmpeq[_s64](svbool_t pg, svint64_t op1, svint64_t op2) - /// CMPEQ Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpeq[_s64](svbool_t pg, svint64_t op1, svint64_t op2) + /// CMPEQ Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); + public static Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); /// - /// svbool_t svcmpeq[_s8](svbool_t pg, svint8_t op1, svint8_t op2) - /// CMPEQ Presult.B, Pg/Z, Zop1.B, Zop2.B + /// svbool_t svcmpeq[_s8](svbool_t pg, svint8_t op1, svint8_t op2) + /// CMPEQ Presult.B, Pg/Z, Zop1.B, Zop2.B /// - public static unsafe Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); + public static Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); /// - /// svbool_t svcmpeq_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) - /// CMPEQ Presult.B, Pg/Z, Zop1.B, Zop2.D + /// svbool_t svcmpeq_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) + /// CMPEQ Presult.B, Pg/Z, Zop1.B, Zop2.D /// - public static unsafe Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); + public static Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); /// - /// svbool_t svcmpeq[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FCMEQ Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpeq[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FCMEQ Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); + public static Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); /// - /// svbool_t svcmpeq[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) - /// CMPEQ Presult.H, Pg/Z, Zop1.H, Zop2.H + /// svbool_t svcmpeq[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) + /// CMPEQ Presult.H, Pg/Z, Zop1.H, Zop2.H /// - public static unsafe Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); + public static Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); /// - /// svbool_t svcmpeq[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) - /// CMPEQ Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpeq[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) + /// CMPEQ Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); + public static Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); /// - /// svbool_t svcmpeq[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) - /// CMPEQ Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpeq[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) + /// CMPEQ Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); + public static Vector CompareEqual(Vector left, Vector right) => CompareEqual(left, right); // Compare greater than /// - /// svbool_t svcmpgt[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) - /// CMPHI Presult.B, Pg/Z, Zop1.B, Zop2.B + /// svbool_t svcmpgt[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) + /// CMPHI Presult.B, Pg/Z, Zop1.B, Zop2.B /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); + public static Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); /// - /// svbool_t svcmpgt_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) - /// CMPHI Presult.B, Pg/Z, Zop1.B, Zop2.D + /// svbool_t svcmpgt_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) + /// CMPHI Presult.B, Pg/Z, Zop1.B, Zop2.D /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); + public static Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); /// - /// svbool_t svcmpgt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FCMGT Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpgt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FCMGT Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); + public static Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); /// - /// svbool_t svcmpgt[_s16](svbool_t pg, svint16_t op1, svint16_t op2) - /// CMPGT Presult.H, Pg/Z, Zop1.H, Zop2.H + /// svbool_t svcmpgt[_s16](svbool_t pg, svint16_t op1, svint16_t op2) + /// CMPGT Presult.H, Pg/Z, Zop1.H, Zop2.H /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); + public static Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); /// - /// svbool_t svcmpgt_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) - /// CMPGT Presult.H, Pg/Z, Zop1.H, Zop2.D + /// svbool_t svcmpgt_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) + /// CMPGT Presult.H, Pg/Z, Zop1.H, Zop2.D /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); + public static Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); /// - /// svbool_t svcmpgt[_s32](svbool_t pg, svint32_t op1, svint32_t op2) - /// CMPGT Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpgt[_s32](svbool_t pg, svint32_t op1, svint32_t op2) + /// CMPGT Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); + public static Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); /// - /// svbool_t svcmpgt_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) - /// CMPGT Presult.S, Pg/Z, Zop1.S, Zop2.D + /// svbool_t svcmpgt_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) + /// CMPGT Presult.S, Pg/Z, Zop1.S, Zop2.D /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); + public static Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); /// - /// svbool_t svcmpgt[_s64](svbool_t pg, svint64_t op1, svint64_t op2) - /// CMPGT Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpgt[_s64](svbool_t pg, svint64_t op1, svint64_t op2) + /// CMPGT Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); + public static Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); /// - /// svbool_t svcmpgt[_s8](svbool_t pg, svint8_t op1, svint8_t op2) - /// CMPGT Presult.B, Pg/Z, Zop1.B, Zop2.B + /// svbool_t svcmpgt[_s8](svbool_t pg, svint8_t op1, svint8_t op2) + /// CMPGT Presult.B, Pg/Z, Zop1.B, Zop2.B /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); + public static Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); /// - /// svbool_t svcmpgt_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) - /// CMPGT Presult.B, Pg/Z, Zop1.B, Zop2.D + /// svbool_t svcmpgt_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) + /// CMPGT Presult.B, Pg/Z, Zop1.B, Zop2.D /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); + public static Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); /// - /// svbool_t svcmpgt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FCMGT Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpgt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FCMGT Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); + public static Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); /// - /// svbool_t svcmpgt[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) - /// CMPHI Presult.H, Pg/Z, Zop1.H, Zop2.H + /// svbool_t svcmpgt[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) + /// CMPHI Presult.H, Pg/Z, Zop1.H, Zop2.H /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); + public static Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); /// - /// svbool_t svcmpgt_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) - /// CMPHI Presult.H, Pg/Z, Zop1.H, Zop2.D + /// svbool_t svcmpgt_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) + /// CMPHI Presult.H, Pg/Z, Zop1.H, Zop2.D /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); + public static Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); /// - /// svbool_t svcmpgt[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) - /// CMPHI Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpgt[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) + /// CMPHI Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); + public static Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); /// - /// svbool_t svcmpgt_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) - /// CMPHI Presult.S, Pg/Z, Zop1.S, Zop2.D + /// svbool_t svcmpgt_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) + /// CMPHI Presult.S, Pg/Z, Zop1.S, Zop2.D /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); + public static Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); /// - /// svbool_t svcmpgt[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) - /// CMPHI Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpgt[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) + /// CMPHI Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); + public static Vector CompareGreaterThan(Vector left, Vector right) => CompareGreaterThan(left, right); // Compare greater than or equal to /// - /// svbool_t svcmpge[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) - /// CMPHS Presult.B, Pg/Z, Zop1.B, Zop2.B + /// svbool_t svcmpge[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) + /// CMPHS Presult.B, Pg/Z, Zop1.B, Zop2.B /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); /// - /// svbool_t svcmpge_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) - /// CMPHS Presult.B, Pg/Z, Zop1.B, Zop2.D + /// svbool_t svcmpge_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) + /// CMPHS Presult.B, Pg/Z, Zop1.B, Zop2.D /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); /// - /// svbool_t svcmpge[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FCMGE Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpge[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FCMGE Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); /// - /// svbool_t svcmpge[_s16](svbool_t pg, svint16_t op1, svint16_t op2) - /// CMPGE Presult.H, Pg/Z, Zop1.H, Zop2.H + /// svbool_t svcmpge[_s16](svbool_t pg, svint16_t op1, svint16_t op2) + /// CMPGE Presult.H, Pg/Z, Zop1.H, Zop2.H /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); /// - /// svbool_t svcmpge_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) - /// CMPGE Presult.H, Pg/Z, Zop1.H, Zop2.D + /// svbool_t svcmpge_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) + /// CMPGE Presult.H, Pg/Z, Zop1.H, Zop2.D /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); /// - /// svbool_t svcmpge[_s32](svbool_t pg, svint32_t op1, svint32_t op2) - /// CMPGE Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpge[_s32](svbool_t pg, svint32_t op1, svint32_t op2) + /// CMPGE Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); /// - /// svbool_t svcmpge_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) - /// CMPGE Presult.S, Pg/Z, Zop1.S, Zop2.D + /// svbool_t svcmpge_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) + /// CMPGE Presult.S, Pg/Z, Zop1.S, Zop2.D /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); /// - /// svbool_t svcmpge[_s64](svbool_t pg, svint64_t op1, svint64_t op2) - /// CMPGE Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpge[_s64](svbool_t pg, svint64_t op1, svint64_t op2) + /// CMPGE Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); /// - /// svbool_t svcmpge[_s8](svbool_t pg, svint8_t op1, svint8_t op2) - /// CMPGE Presult.B, Pg/Z, Zop1.B, Zop2.B + /// svbool_t svcmpge[_s8](svbool_t pg, svint8_t op1, svint8_t op2) + /// CMPGE Presult.B, Pg/Z, Zop1.B, Zop2.B /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); /// - /// svbool_t svcmpge_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) - /// CMPGE Presult.B, Pg/Z, Zop1.B, Zop2.D + /// svbool_t svcmpge_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) + /// CMPGE Presult.B, Pg/Z, Zop1.B, Zop2.D /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); /// - /// svbool_t svcmpge[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FCMGE Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpge[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FCMGE Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); /// - /// svbool_t svcmpge[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) - /// CMPHS Presult.H, Pg/Z, Zop1.H, Zop2.H + /// svbool_t svcmpge[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) + /// CMPHS Presult.H, Pg/Z, Zop1.H, Zop2.H /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); /// - /// svbool_t svcmpge_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) - /// CMPHS Presult.H, Pg/Z, Zop1.H, Zop2.D + /// svbool_t svcmpge_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) + /// CMPHS Presult.H, Pg/Z, Zop1.H, Zop2.D /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); /// - /// svbool_t svcmpge[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) - /// CMPHS Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpge[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) + /// CMPHS Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); /// - /// svbool_t svcmpge_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) - /// CMPHS Presult.S, Pg/Z, Zop1.S, Zop2.D + /// svbool_t svcmpge_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) + /// CMPHS Presult.S, Pg/Z, Zop1.S, Zop2.D /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); /// - /// svbool_t svcmpge[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) - /// CMPHS Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpge[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) + /// CMPHS Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); + public static Vector CompareGreaterThanOrEqual(Vector left, Vector right) => CompareGreaterThanOrEqual(left, right); // Compare less than /// - /// svbool_t svcmplt[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) - /// CMPHI Presult.B, Pg/Z, Zop2.B, Zop1.B + /// svbool_t svcmplt[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) + /// CMPHI Presult.B, Pg/Z, Zop2.B, Zop1.B /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); + public static Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); /// - /// svbool_t svcmplt_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) - /// CMPLO Presult.B, Pg/Z, Zop1.B, Zop2.D + /// svbool_t svcmplt_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) + /// CMPLO Presult.B, Pg/Z, Zop1.B, Zop2.D /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); + public static Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); /// - /// svbool_t svcmplt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FCMGT Presult.D, Pg/Z, Zop2.D, Zop1.D + /// svbool_t svcmplt[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FCMGT Presult.D, Pg/Z, Zop2.D, Zop1.D /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); + public static Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); /// - /// svbool_t svcmplt[_s16](svbool_t pg, svint16_t op1, svint16_t op2) - /// CMPGT Presult.H, Pg/Z, Zop2.H, Zop1.H + /// svbool_t svcmplt[_s16](svbool_t pg, svint16_t op1, svint16_t op2) + /// CMPGT Presult.H, Pg/Z, Zop2.H, Zop1.H /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); + public static Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); /// - /// svbool_t svcmplt_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) - /// CMPLT Presult.H, Pg/Z, Zop1.H, Zop2.D + /// svbool_t svcmplt_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) + /// CMPLT Presult.H, Pg/Z, Zop1.H, Zop2.D /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); + public static Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); /// - /// svbool_t svcmplt[_s32](svbool_t pg, svint32_t op1, svint32_t op2) - /// CMPGT Presult.S, Pg/Z, Zop2.S, Zop1.S + /// svbool_t svcmplt[_s32](svbool_t pg, svint32_t op1, svint32_t op2) + /// CMPGT Presult.S, Pg/Z, Zop2.S, Zop1.S /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); + public static Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); /// - /// svbool_t svcmplt_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) - /// CMPLT Presult.S, Pg/Z, Zop1.S, Zop2.D + /// svbool_t svcmplt_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) + /// CMPLT Presult.S, Pg/Z, Zop1.S, Zop2.D /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); + public static Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); /// - /// svbool_t svcmplt[_s64](svbool_t pg, svint64_t op1, svint64_t op2) - /// CMPGT Presult.D, Pg/Z, Zop2.D, Zop1.D + /// svbool_t svcmplt[_s64](svbool_t pg, svint64_t op1, svint64_t op2) + /// CMPGT Presult.D, Pg/Z, Zop2.D, Zop1.D /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); + public static Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); /// - /// svbool_t svcmplt[_s8](svbool_t pg, svint8_t op1, svint8_t op2) - /// CMPGT Presult.B, Pg/Z, Zop2.B, Zop1.B + /// svbool_t svcmplt[_s8](svbool_t pg, svint8_t op1, svint8_t op2) + /// CMPGT Presult.B, Pg/Z, Zop2.B, Zop1.B /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); + public static Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); /// - /// svbool_t svcmplt_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) - /// CMPLT Presult.B, Pg/Z, Zop1.B, Zop2.D + /// svbool_t svcmplt_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) + /// CMPLT Presult.B, Pg/Z, Zop1.B, Zop2.D /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); + public static Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); /// - /// svbool_t svcmplt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FCMGT Presult.S, Pg/Z, Zop2.S, Zop1.S + /// svbool_t svcmplt[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FCMGT Presult.S, Pg/Z, Zop2.S, Zop1.S /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); + public static Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); /// - /// svbool_t svcmplt[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) - /// CMPHI Presult.H, Pg/Z, Zop2.H, Zop1.H + /// svbool_t svcmplt[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) + /// CMPHI Presult.H, Pg/Z, Zop2.H, Zop1.H /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); + public static Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); /// - /// svbool_t svcmplt_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) - /// CMPLO Presult.H, Pg/Z, Zop1.H, Zop2.D + /// svbool_t svcmplt_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) + /// CMPLO Presult.H, Pg/Z, Zop1.H, Zop2.D /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); + public static Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); /// - /// svbool_t svcmplt[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) - /// CMPHI Presult.S, Pg/Z, Zop2.S, Zop1.S + /// svbool_t svcmplt[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) + /// CMPHI Presult.S, Pg/Z, Zop2.S, Zop1.S /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); + public static Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); /// - /// svbool_t svcmplt_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) - /// CMPLO Presult.S, Pg/Z, Zop1.S, Zop2.D + /// svbool_t svcmplt_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) + /// CMPLO Presult.S, Pg/Z, Zop1.S, Zop2.D /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); + public static Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); /// - /// svbool_t svcmplt[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) - /// CMPHI Presult.D, Pg/Z, Zop2.D, Zop1.D + /// svbool_t svcmplt[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) + /// CMPHI Presult.D, Pg/Z, Zop2.D, Zop1.D /// - public static unsafe Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); + public static Vector CompareLessThan(Vector left, Vector right) => CompareLessThan(left, right); // Compare less than or equal to /// - /// svbool_t svcmple[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) - /// CMPHS Presult.B, Pg/Z, Zop2.B, Zop1.B + /// svbool_t svcmple[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) + /// CMPHS Presult.B, Pg/Z, Zop2.B, Zop1.B /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); + public static Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); /// - /// svbool_t svcmple_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) - /// CMPLS Presult.B, Pg/Z, Zop1.B, Zop2.D + /// svbool_t svcmple_wide[_u8](svbool_t pg, svuint8_t op1, svuint64_t op2) + /// CMPLS Presult.B, Pg/Z, Zop1.B, Zop2.D /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); + public static Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); /// - /// svbool_t svcmple[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FCMGE Presult.D, Pg/Z, Zop2.D, Zop1.D + /// svbool_t svcmple[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FCMGE Presult.D, Pg/Z, Zop2.D, Zop1.D /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); + public static Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); /// - /// svbool_t svcmple[_s16](svbool_t pg, svint16_t op1, svint16_t op2) - /// CMPGE Presult.H, Pg/Z, Zop2.H, Zop1.H + /// svbool_t svcmple[_s16](svbool_t pg, svint16_t op1, svint16_t op2) + /// CMPGE Presult.H, Pg/Z, Zop2.H, Zop1.H /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); + public static Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); /// - /// svbool_t svcmple_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) - /// CMPLE Presult.H, Pg/Z, Zop1.H, Zop2.D + /// svbool_t svcmple_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) + /// CMPLE Presult.H, Pg/Z, Zop1.H, Zop2.D /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); + public static Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); /// - /// svbool_t svcmple[_s32](svbool_t pg, svint32_t op1, svint32_t op2) - /// CMPGE Presult.S, Pg/Z, Zop2.S, Zop1.S + /// svbool_t svcmple[_s32](svbool_t pg, svint32_t op1, svint32_t op2) + /// CMPGE Presult.S, Pg/Z, Zop2.S, Zop1.S /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); + public static Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); /// - /// svbool_t svcmple_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) - /// CMPLE Presult.S, Pg/Z, Zop1.S, Zop2.D + /// svbool_t svcmple_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) + /// CMPLE Presult.S, Pg/Z, Zop1.S, Zop2.D /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); + public static Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); /// - /// svbool_t svcmple[_s64](svbool_t pg, svint64_t op1, svint64_t op2) - /// CMPGE Presult.D, Pg/Z, Zop2.D, Zop1.D + /// svbool_t svcmple[_s64](svbool_t pg, svint64_t op1, svint64_t op2) + /// CMPGE Presult.D, Pg/Z, Zop2.D, Zop1.D /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); + public static Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); /// - /// svbool_t svcmple[_s8](svbool_t pg, svint8_t op1, svint8_t op2) - /// CMPGE Presult.B, Pg/Z, Zop2.B, Zop1.B + /// svbool_t svcmple[_s8](svbool_t pg, svint8_t op1, svint8_t op2) + /// CMPGE Presult.B, Pg/Z, Zop2.B, Zop1.B /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); + public static Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); /// - /// svbool_t svcmple_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) - /// CMPLE Presult.B, Pg/Z, Zop1.B, Zop2.D + /// svbool_t svcmple_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) + /// CMPLE Presult.B, Pg/Z, Zop1.B, Zop2.D /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); + public static Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); /// - /// svbool_t svcmple[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FCMGE Presult.S, Pg/Z, Zop2.S, Zop1.S + /// svbool_t svcmple[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FCMGE Presult.S, Pg/Z, Zop2.S, Zop1.S /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); + public static Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); /// - /// svbool_t svcmple[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) - /// CMPHS Presult.H, Pg/Z, Zop2.H, Zop1.H + /// svbool_t svcmple[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) + /// CMPHS Presult.H, Pg/Z, Zop2.H, Zop1.H /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); + public static Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); /// - /// svbool_t svcmple_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) - /// CMPLS Presult.H, Pg/Z, Zop1.H, Zop2.D + /// svbool_t svcmple_wide[_u16](svbool_t pg, svuint16_t op1, svuint64_t op2) + /// CMPLS Presult.H, Pg/Z, Zop1.H, Zop2.D /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); + public static Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); /// - /// svbool_t svcmple[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) - /// CMPHS Presult.S, Pg/Z, Zop2.S, Zop1.S + /// svbool_t svcmple[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) + /// CMPHS Presult.S, Pg/Z, Zop2.S, Zop1.S /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); + public static Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); /// - /// svbool_t svcmple_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) - /// CMPLS Presult.S, Pg/Z, Zop1.S, Zop2.D + /// svbool_t svcmple_wide[_u32](svbool_t pg, svuint32_t op1, svuint64_t op2) + /// CMPLS Presult.S, Pg/Z, Zop1.S, Zop2.D /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); + public static Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); /// - /// svbool_t svcmple[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) - /// CMPHS Presult.D, Pg/Z, Zop2.D, Zop1.D + /// svbool_t svcmple[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) + /// CMPHS Presult.D, Pg/Z, Zop2.D, Zop1.D /// - public static unsafe Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); + public static Vector CompareLessThanOrEqual(Vector left, Vector right) => CompareLessThanOrEqual(left, right); // Compare not equal to /// - /// svbool_t svcmpne[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) - /// CMPNE Presult.B, Pg/Z, Zop1.B, Zop2.B + /// svbool_t svcmpne[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) + /// CMPNE Presult.B, Pg/Z, Zop1.B, Zop2.B /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); + public static Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); /// - /// svbool_t svcmpne[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FCMNE Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpne[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FCMNE Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); + public static Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); /// - /// svbool_t svcmpne[_s16](svbool_t pg, svint16_t op1, svint16_t op2) - /// CMPNE Presult.H, Pg/Z, Zop1.H, Zop2.H + /// svbool_t svcmpne[_s16](svbool_t pg, svint16_t op1, svint16_t op2) + /// CMPNE Presult.H, Pg/Z, Zop1.H, Zop2.H /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); + public static Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); /// - /// svbool_t svcmpne_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) - /// CMPNE Presult.H, Pg/Z, Zop1.H, Zop2.D + /// svbool_t svcmpne_wide[_s16](svbool_t pg, svint16_t op1, svint64_t op2) + /// CMPNE Presult.H, Pg/Z, Zop1.H, Zop2.D /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); + public static Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); /// - /// svbool_t svcmpne[_s32](svbool_t pg, svint32_t op1, svint32_t op2) - /// CMPNE Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpne[_s32](svbool_t pg, svint32_t op1, svint32_t op2) + /// CMPNE Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); + public static Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); /// - /// svbool_t svcmpne_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) - /// CMPNE Presult.S, Pg/Z, Zop1.S, Zop2.D + /// svbool_t svcmpne_wide[_s32](svbool_t pg, svint32_t op1, svint64_t op2) + /// CMPNE Presult.S, Pg/Z, Zop1.S, Zop2.D /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); + public static Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); /// - /// svbool_t svcmpne[_s64](svbool_t pg, svint64_t op1, svint64_t op2) - /// CMPNE Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpne[_s64](svbool_t pg, svint64_t op1, svint64_t op2) + /// CMPNE Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); + public static Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); /// - /// svbool_t svcmpne[_s8](svbool_t pg, svint8_t op1, svint8_t op2) - /// CMPNE Presult.B, Pg/Z, Zop1.B, Zop2.B + /// svbool_t svcmpne[_s8](svbool_t pg, svint8_t op1, svint8_t op2) + /// CMPNE Presult.B, Pg/Z, Zop1.B, Zop2.B /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); + public static Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); /// - /// svbool_t svcmpne_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) - /// CMPNE Presult.B, Pg/Z, Zop1.B, Zop2.D + /// svbool_t svcmpne_wide[_s8](svbool_t pg, svint8_t op1, svint64_t op2) + /// CMPNE Presult.B, Pg/Z, Zop1.B, Zop2.D /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); + public static Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); /// - /// svbool_t svcmpne[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FCMNE Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpne[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FCMNE Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); + public static Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); /// - /// svbool_t svcmpne[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) - /// CMPNE Presult.H, Pg/Z, Zop1.H, Zop2.H + /// svbool_t svcmpne[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) + /// CMPNE Presult.H, Pg/Z, Zop1.H, Zop2.H /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); + public static Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); /// - /// svbool_t svcmpne[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) - /// CMPNE Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpne[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) + /// CMPNE Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); + public static Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); /// - /// svbool_t svcmpne[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) - /// CMPNE Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpne[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) + /// CMPNE Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); + public static Vector CompareNotEqualTo(Vector left, Vector right) => CompareNotEqualTo(left, right); // Compare unordered with /// - /// svbool_t svcmpuo[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FCMUO Presult.D, Pg/Z, Zop1.D, Zop2.D + /// svbool_t svcmpuo[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FCMUO Presult.D, Pg/Z, Zop1.D, Zop2.D /// - public static unsafe Vector CompareUnordered(Vector left, Vector right) => CompareUnordered(left, right); + public static Vector CompareUnordered(Vector left, Vector right) => CompareUnordered(left, right); /// - /// svbool_t svcmpuo[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FCMUO Presult.S, Pg/Z, Zop1.S, Zop2.S + /// svbool_t svcmpuo[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FCMUO Presult.S, Pg/Z, Zop1.S, Zop2.S /// - public static unsafe Vector CompareUnordered(Vector left, Vector right) => CompareUnordered(left, right); + public static Vector CompareUnordered(Vector left, Vector right) => CompareUnordered(left, right); // Compute vector addresses for 16-bit data /// - /// svuint32_t svadrh[_u32base]_[s32]index(svuint32_t bases, svint32_t indices) - /// ADR Zresult.S, [Zbases.S, Zindices.S, LSL #1] + /// svuint32_t svadrh[_u32base]_[s32]index(svuint32_t bases, svint32_t indices) + /// ADR Zresult.S, [Zbases.S, Zindices.S, LSL #1] /// - public static unsafe Vector Compute16BitAddresses(Vector bases, Vector indices) => Compute16BitAddresses(bases, indices); + public static Vector Compute16BitAddresses(Vector bases, Vector indices) => Compute16BitAddresses(bases, indices); /// - /// svuint32_t svadrh[_u32base]_[u32]index(svuint32_t bases, svuint32_t indices) - /// ADR Zresult.S, [Zbases.S, Zindices.S, LSL #1] + /// svuint32_t svadrh[_u32base]_[u32]index(svuint32_t bases, svuint32_t indices) + /// ADR Zresult.S, [Zbases.S, Zindices.S, LSL #1] /// - public static unsafe Vector Compute16BitAddresses(Vector bases, Vector indices) => Compute16BitAddresses(bases, indices); + public static Vector Compute16BitAddresses(Vector bases, Vector indices) => Compute16BitAddresses(bases, indices); /// - /// svuint64_t svadrh[_u64base]_[s64]index(svuint64_t bases, svint64_t indices) - /// ADR Zresult.D, [Zbases.D, Zindices.D, LSL #1] + /// svuint64_t svadrh[_u64base]_[s64]index(svuint64_t bases, svint64_t indices) + /// ADR Zresult.D, [Zbases.D, Zindices.D, LSL #1] /// - public static unsafe Vector Compute16BitAddresses(Vector bases, Vector indices) => Compute16BitAddresses(bases, indices); + public static Vector Compute16BitAddresses(Vector bases, Vector indices) => Compute16BitAddresses(bases, indices); /// - /// svuint64_t svadrh[_u64base]_[u64]index(svuint64_t bases, svuint64_t indices) - /// ADR Zresult.D, [Zbases.D, Zindices.D, LSL #1] + /// svuint64_t svadrh[_u64base]_[u64]index(svuint64_t bases, svuint64_t indices) + /// ADR Zresult.D, [Zbases.D, Zindices.D, LSL #1] /// - public static unsafe Vector Compute16BitAddresses(Vector bases, Vector indices) => Compute16BitAddresses(bases, indices); + public static Vector Compute16BitAddresses(Vector bases, Vector indices) => Compute16BitAddresses(bases, indices); // Compute vector addresses for 32-bit data /// - /// svuint32_t svadrw[_u32base]_[s32]index(svuint32_t bases, svint32_t indices) - /// ADR Zresult.S, [Zbases.S, Zindices.S, LSL #2] + /// svuint32_t svadrw[_u32base]_[s32]index(svuint32_t bases, svint32_t indices) + /// ADR Zresult.S, [Zbases.S, Zindices.S, LSL #2] /// - public static unsafe Vector Compute32BitAddresses(Vector bases, Vector indices) => Compute32BitAddresses(bases, indices); + public static Vector Compute32BitAddresses(Vector bases, Vector indices) => Compute32BitAddresses(bases, indices); /// - /// svuint32_t svadrw[_u32base]_[u32]index(svuint32_t bases, svuint32_t indices) - /// ADR Zresult.S, [Zbases.S, Zindices.S, LSL #2] + /// svuint32_t svadrw[_u32base]_[u32]index(svuint32_t bases, svuint32_t indices) + /// ADR Zresult.S, [Zbases.S, Zindices.S, LSL #2] /// - public static unsafe Vector Compute32BitAddresses(Vector bases, Vector indices) => Compute32BitAddresses(bases, indices); + public static Vector Compute32BitAddresses(Vector bases, Vector indices) => Compute32BitAddresses(bases, indices); /// - /// svuint64_t svadrw[_u64base]_[s64]index(svuint64_t bases, svint64_t indices) - /// ADR Zresult.D, [Zbases.D, Zindices.D, LSL #2] + /// svuint64_t svadrw[_u64base]_[s64]index(svuint64_t bases, svint64_t indices) + /// ADR Zresult.D, [Zbases.D, Zindices.D, LSL #2] /// - public static unsafe Vector Compute32BitAddresses(Vector bases, Vector indices) => Compute32BitAddresses(bases, indices); + public static Vector Compute32BitAddresses(Vector bases, Vector indices) => Compute32BitAddresses(bases, indices); /// - /// svuint64_t svadrw[_u64base]_[u64]index(svuint64_t bases, svuint64_t indices) - /// ADR Zresult.D, [Zbases.D, Zindices.D, LSL #2] + /// svuint64_t svadrw[_u64base]_[u64]index(svuint64_t bases, svuint64_t indices) + /// ADR Zresult.D, [Zbases.D, Zindices.D, LSL #2] /// - public static unsafe Vector Compute32BitAddresses(Vector bases, Vector indices) => Compute32BitAddresses(bases, indices); + public static Vector Compute32BitAddresses(Vector bases, Vector indices) => Compute32BitAddresses(bases, indices); // Compute vector addresses for 64-bit data /// - /// svuint32_t svadrd[_u32base]_[s32]index(svuint32_t bases, svint32_t indices) - /// ADR Zresult.S, [Zbases.S, Zindices.S, LSL #3] + /// svuint32_t svadrd[_u32base]_[s32]index(svuint32_t bases, svint32_t indices) + /// ADR Zresult.S, [Zbases.S, Zindices.S, LSL #3] /// - public static unsafe Vector Compute64BitAddresses(Vector bases, Vector indices) => Compute64BitAddresses(bases, indices); + public static Vector Compute64BitAddresses(Vector bases, Vector indices) => Compute64BitAddresses(bases, indices); /// - /// svuint32_t svadrd[_u32base]_[u32]index(svuint32_t bases, svuint32_t indices) - /// ADR Zresult.S, [Zbases.S, Zindices.S, LSL #3] + /// svuint32_t svadrd[_u32base]_[u32]index(svuint32_t bases, svuint32_t indices) + /// ADR Zresult.S, [Zbases.S, Zindices.S, LSL #3] /// - public static unsafe Vector Compute64BitAddresses(Vector bases, Vector indices) => Compute64BitAddresses(bases, indices); + public static Vector Compute64BitAddresses(Vector bases, Vector indices) => Compute64BitAddresses(bases, indices); /// - /// svuint64_t svadrd[_u64base]_[s64]index(svuint64_t bases, svint64_t indices) - /// ADR Zresult.D, [Zbases.D, Zindices.D, LSL #3] + /// svuint64_t svadrd[_u64base]_[s64]index(svuint64_t bases, svint64_t indices) + /// ADR Zresult.D, [Zbases.D, Zindices.D, LSL #3] /// - public static unsafe Vector Compute64BitAddresses(Vector bases, Vector indices) => Compute64BitAddresses(bases, indices); + public static Vector Compute64BitAddresses(Vector bases, Vector indices) => Compute64BitAddresses(bases, indices); /// - /// svuint64_t svadrd[_u64base]_[u64]index(svuint64_t bases, svuint64_t indices) - /// ADR Zresult.D, [Zbases.D, Zindices.D, LSL #3] + /// svuint64_t svadrd[_u64base]_[u64]index(svuint64_t bases, svuint64_t indices) + /// ADR Zresult.D, [Zbases.D, Zindices.D, LSL #3] /// - public static unsafe Vector Compute64BitAddresses(Vector bases, Vector indices) => Compute64BitAddresses(bases, indices); + public static Vector Compute64BitAddresses(Vector bases, Vector indices) => Compute64BitAddresses(bases, indices); // Compute vector addresses for 8-bit data /// - /// svuint32_t svadrb[_u32base]_[s32]offset(svuint32_t bases, svint32_t offsets) - /// ADR Zresult.S, [Zbases.S, Zoffsets.S] + /// svuint32_t svadrb[_u32base]_[s32]offset(svuint32_t bases, svint32_t offsets) + /// ADR Zresult.S, [Zbases.S, Zoffsets.S] /// - public static unsafe Vector Compute8BitAddresses(Vector bases, Vector indices) => Compute8BitAddresses(bases, indices); + public static Vector Compute8BitAddresses(Vector bases, Vector indices) => Compute8BitAddresses(bases, indices); /// - /// svuint32_t svadrb[_u32base]_[u32]offset(svuint32_t bases, svuint32_t offsets) - /// ADR Zresult.S, [Zbases.S, Zoffsets.S] + /// svuint32_t svadrb[_u32base]_[u32]offset(svuint32_t bases, svuint32_t offsets) + /// ADR Zresult.S, [Zbases.S, Zoffsets.S] /// - public static unsafe Vector Compute8BitAddresses(Vector bases, Vector indices) => Compute8BitAddresses(bases, indices); + public static Vector Compute8BitAddresses(Vector bases, Vector indices) => Compute8BitAddresses(bases, indices); /// - /// svuint64_t svadrb[_u64base]_[s64]offset(svuint64_t bases, svint64_t offsets) - /// ADR Zresult.D, [Zbases.D, Zoffsets.D] + /// svuint64_t svadrb[_u64base]_[s64]offset(svuint64_t bases, svint64_t offsets) + /// ADR Zresult.D, [Zbases.D, Zoffsets.D] /// - public static unsafe Vector Compute8BitAddresses(Vector bases, Vector indices) => Compute8BitAddresses(bases, indices); + public static Vector Compute8BitAddresses(Vector bases, Vector indices) => Compute8BitAddresses(bases, indices); /// - /// svuint64_t svadrb[_u64base]_[u64]offset(svuint64_t bases, svuint64_t offsets) - /// ADR Zresult.D, [Zbases.D, Zoffsets.D] + /// svuint64_t svadrb[_u64base]_[u64]offset(svuint64_t bases, svuint64_t offsets) + /// ADR Zresult.D, [Zbases.D, Zoffsets.D] /// - public static unsafe Vector Compute8BitAddresses(Vector bases, Vector indices) => Compute8BitAddresses(bases, indices); + public static Vector Compute8BitAddresses(Vector bases, Vector indices) => Compute8BitAddresses(bases, indices); // Conditionally extract element after last /// - /// svuint8_t svclasta[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) - /// CLASTA Btied, Pg, Btied, Zdata.B + /// svuint8_t svclasta[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) + /// CLASTA Btied, Pg, Btied, Zdata.B /// - public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); + public static Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); /// - /// uint8_t svclasta[_n_u8](svbool_t pg, uint8_t fallback, svuint8_t data) - /// CLASTA Wtied, Pg, Wtied, Zdata.B + /// uint8_t svclasta[_n_u8](svbool_t pg, uint8_t fallback, svuint8_t data) + /// CLASTA Wtied, Pg, Wtied, Zdata.B /// - public static unsafe byte ConditionalExtractAfterLastActiveElement(Vector mask, byte defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); + public static byte ConditionalExtractAfterLastActiveElement(Vector mask, byte defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); /// - /// svfloat64_t svclasta[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) - /// CLASTA Dtied, Pg, Dtied, Zdata.D + /// svfloat64_t svclasta[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) + /// CLASTA Dtied, Pg, Dtied, Zdata.D /// - public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); + public static Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); /// - /// float64_t svclasta[_n_f64](svbool_t pg, float64_t fallback, svfloat64_t data) - /// CLASTA Dtied, Pg, Dtied, Zdata.D + /// float64_t svclasta[_n_f64](svbool_t pg, float64_t fallback, svfloat64_t data) + /// CLASTA Dtied, Pg, Dtied, Zdata.D /// - public static unsafe double ConditionalExtractAfterLastActiveElement(Vector mask, double defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); + public static double ConditionalExtractAfterLastActiveElement(Vector mask, double defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); /// - /// svint16_t svclasta[_s16](svbool_t pg, svint16_t fallback, svint16_t data) - /// CLASTA Htied, Pg, Htied, Zdata.H + /// svint16_t svclasta[_s16](svbool_t pg, svint16_t fallback, svint16_t data) + /// CLASTA Htied, Pg, Htied, Zdata.H /// - public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); + public static Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); /// - /// int16_t svclasta[_n_s16](svbool_t pg, int16_t fallback, svint16_t data) - /// CLASTA Wtied, Pg, Wtied, Zdata.H + /// int16_t svclasta[_n_s16](svbool_t pg, int16_t fallback, svint16_t data) + /// CLASTA Wtied, Pg, Wtied, Zdata.H /// - public static unsafe short ConditionalExtractAfterLastActiveElement(Vector mask, short defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); + public static short ConditionalExtractAfterLastActiveElement(Vector mask, short defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); /// - /// svint32_t svclasta[_s32](svbool_t pg, svint32_t fallback, svint32_t data) - /// CLASTA Stied, Pg, Stied, Zdata.S + /// svint32_t svclasta[_s32](svbool_t pg, svint32_t fallback, svint32_t data) + /// CLASTA Stied, Pg, Stied, Zdata.S /// - public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); + public static Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); /// - /// int32_t svclasta[_n_s32](svbool_t pg, int32_t fallback, svint32_t data) - /// CLASTA Wtied, Pg, Wtied, Zdata.S + /// int32_t svclasta[_n_s32](svbool_t pg, int32_t fallback, svint32_t data) + /// CLASTA Wtied, Pg, Wtied, Zdata.S /// - public static unsafe int ConditionalExtractAfterLastActiveElement(Vector mask, int defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); + public static int ConditionalExtractAfterLastActiveElement(Vector mask, int defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); /// - /// svint64_t svclasta[_s64](svbool_t pg, svint64_t fallback, svint64_t data) - /// CLASTA Dtied, Pg, Dtied, Zdata.D + /// svint64_t svclasta[_s64](svbool_t pg, svint64_t fallback, svint64_t data) + /// CLASTA Dtied, Pg, Dtied, Zdata.D /// - public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); + public static Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); /// - /// int64_t svclasta[_n_s64](svbool_t pg, int64_t fallback, svint64_t data) - /// CLASTA Xtied, Pg, Xtied, Zdata.D + /// int64_t svclasta[_n_s64](svbool_t pg, int64_t fallback, svint64_t data) + /// CLASTA Xtied, Pg, Xtied, Zdata.D /// - public static unsafe long ConditionalExtractAfterLastActiveElement(Vector mask, long defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); + public static long ConditionalExtractAfterLastActiveElement(Vector mask, long defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); /// - /// svint8_t svclasta[_s8](svbool_t pg, svint8_t fallback, svint8_t data) - /// CLASTA Btied, Pg, Btied, Zdata.B + /// svint8_t svclasta[_s8](svbool_t pg, svint8_t fallback, svint8_t data) + /// CLASTA Btied, Pg, Btied, Zdata.B /// - public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); + public static Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); /// - /// int8_t svclasta[_n_s8](svbool_t pg, int8_t fallback, svint8_t data) - /// CLASTA Wtied, Pg, Wtied, Zdata.B + /// int8_t svclasta[_n_s8](svbool_t pg, int8_t fallback, svint8_t data) + /// CLASTA Wtied, Pg, Wtied, Zdata.B /// - public static unsafe sbyte ConditionalExtractAfterLastActiveElement(Vector mask, sbyte defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); + public static sbyte ConditionalExtractAfterLastActiveElement(Vector mask, sbyte defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); /// - /// svfloat32_t svclasta[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) - /// CLASTA Stied, Pg, Stied, Zdata.S + /// svfloat32_t svclasta[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) + /// CLASTA Stied, Pg, Stied, Zdata.S /// - public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); + public static Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); /// - /// float32_t svclasta[_n_f32](svbool_t pg, float32_t fallback, svfloat32_t data) - /// CLASTA Stied, Pg, Stied, Zdata.S + /// float32_t svclasta[_n_f32](svbool_t pg, float32_t fallback, svfloat32_t data) + /// CLASTA Stied, Pg, Stied, Zdata.S /// - public static unsafe float ConditionalExtractAfterLastActiveElement(Vector mask, float defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); + public static float ConditionalExtractAfterLastActiveElement(Vector mask, float defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); /// - /// svuint16_t svclasta[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) - /// CLASTA Htied, Pg, Htied, Zdata.H + /// svuint16_t svclasta[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) + /// CLASTA Htied, Pg, Htied, Zdata.H /// - public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); + public static Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); /// - /// uint16_t svclasta[_n_u16](svbool_t pg, uint16_t fallback, svuint16_t data) - /// CLASTA Wtied, Pg, Wtied, Zdata.H + /// uint16_t svclasta[_n_u16](svbool_t pg, uint16_t fallback, svuint16_t data) + /// CLASTA Wtied, Pg, Wtied, Zdata.H /// - public static unsafe ushort ConditionalExtractAfterLastActiveElement(Vector mask, ushort defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); + public static ushort ConditionalExtractAfterLastActiveElement(Vector mask, ushort defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); /// - /// svuint32_t svclasta[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) - /// CLASTA Stied, Pg, Stied, Zdata.S + /// svuint32_t svclasta[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) + /// CLASTA Stied, Pg, Stied, Zdata.S /// - public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); + public static Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); /// - /// uint32_t svclasta[_n_u32](svbool_t pg, uint32_t fallback, svuint32_t data) - /// CLASTA Wtied, Pg, Wtied, Zdata.S + /// uint32_t svclasta[_n_u32](svbool_t pg, uint32_t fallback, svuint32_t data) + /// CLASTA Wtied, Pg, Wtied, Zdata.S /// - public static unsafe uint ConditionalExtractAfterLastActiveElement(Vector mask, uint defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); + public static uint ConditionalExtractAfterLastActiveElement(Vector mask, uint defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); /// - /// svuint64_t svclasta[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) - /// CLASTA Dtied, Pg, Dtied, Zdata.D + /// svuint64_t svclasta[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) + /// CLASTA Dtied, Pg, Dtied, Zdata.D /// - public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); + public static Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); /// - /// uint64_t svclasta[_n_u64](svbool_t pg, uint64_t fallback, svuint64_t data) - /// CLASTA Xtied, Pg, Xtied, Zdata.D + /// uint64_t svclasta[_n_u64](svbool_t pg, uint64_t fallback, svuint64_t data) + /// CLASTA Xtied, Pg, Xtied, Zdata.D /// - public static unsafe ulong ConditionalExtractAfterLastActiveElement(Vector mask, ulong defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); + public static ulong ConditionalExtractAfterLastActiveElement(Vector mask, ulong defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); // Conditionally extract element after last /// - /// svuint8_t svclasta[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) - /// CLASTA Ztied.B, Pg, Ztied.B, Zdata.B + /// svuint8_t svclasta[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) + /// CLASTA Ztied.B, Pg, Ztied.B, Zdata.B /// - public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); + public static Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); /// - /// svfloat64_t svclasta[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) - /// CLASTA Ztied.D, Pg, Ztied.D, Zdata.D + /// svfloat64_t svclasta[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) + /// CLASTA Ztied.D, Pg, Ztied.D, Zdata.D /// - public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); + public static Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); /// - /// svint16_t svclasta[_s16](svbool_t pg, svint16_t fallback, svint16_t data) - /// CLASTA Ztied.H, Pg, Ztied.H, Zdata.H + /// svint16_t svclasta[_s16](svbool_t pg, svint16_t fallback, svint16_t data) + /// CLASTA Ztied.H, Pg, Ztied.H, Zdata.H /// - public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); + public static Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); /// - /// svint32_t svclasta[_s32](svbool_t pg, svint32_t fallback, svint32_t data) - /// CLASTA Ztied.S, Pg, Ztied.S, Zdata.S + /// svint32_t svclasta[_s32](svbool_t pg, svint32_t fallback, svint32_t data) + /// CLASTA Ztied.S, Pg, Ztied.S, Zdata.S /// - public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); + public static Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); /// - /// svint64_t svclasta[_s64](svbool_t pg, svint64_t fallback, svint64_t data) - /// CLASTA Ztied.D, Pg, Ztied.D, Zdata.D + /// svint64_t svclasta[_s64](svbool_t pg, svint64_t fallback, svint64_t data) + /// CLASTA Ztied.D, Pg, Ztied.D, Zdata.D /// - public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); + public static Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); /// - /// svint8_t svclasta[_s8](svbool_t pg, svint8_t fallback, svint8_t data) - /// CLASTA Ztied.B, Pg, Ztied.B, Zdata.B + /// svint8_t svclasta[_s8](svbool_t pg, svint8_t fallback, svint8_t data) + /// CLASTA Ztied.B, Pg, Ztied.B, Zdata.B /// - public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); + public static Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); /// - /// svfloat32_t svclasta[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) - /// CLASTA Ztied.S, Pg, Ztied.S, Zdata.S + /// svfloat32_t svclasta[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) + /// CLASTA Ztied.S, Pg, Ztied.S, Zdata.S /// - public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); + public static Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); /// - /// svuint16_t svclasta[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) - /// CLASTA Ztied.H, Pg, Ztied.H, Zdata.H + /// svuint16_t svclasta[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) + /// CLASTA Ztied.H, Pg, Ztied.H, Zdata.H /// - public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); + public static Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); /// - /// svuint32_t svclasta[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) - /// CLASTA Ztied.S, Pg, Ztied.S, Zdata.S + /// svuint32_t svclasta[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) + /// CLASTA Ztied.S, Pg, Ztied.S, Zdata.S /// - public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); + public static Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); /// - /// svuint64_t svclasta[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) - /// CLASTA Ztied.D, Pg, Ztied.D, Zdata.D + /// svuint64_t svclasta[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) + /// CLASTA Ztied.D, Pg, Ztied.D, Zdata.D /// - public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); + public static Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); // Conditionally extract last element /// - /// svuint8_t svclastb[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) - /// CLASTB Btied, Pg, Btied, Zdata.B + /// svuint8_t svclastb[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) + /// CLASTB Btied, Pg, Btied, Zdata.B /// - public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); + public static Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); /// - /// uint8_t svclastb[_n_u8](svbool_t pg, uint8_t fallback, svuint8_t data) - /// CLASTB Wtied, Pg, Wtied, Zdata.B + /// uint8_t svclastb[_n_u8](svbool_t pg, uint8_t fallback, svuint8_t data) + /// CLASTB Wtied, Pg, Wtied, Zdata.B /// - public static unsafe byte ConditionalExtractLastActiveElement(Vector mask, byte defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); + public static byte ConditionalExtractLastActiveElement(Vector mask, byte defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); /// - /// svfloat64_t svclastb[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) - /// CLASTB Dtied, Pg, Dtied, Zdata.D + /// svfloat64_t svclastb[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) + /// CLASTB Dtied, Pg, Dtied, Zdata.D /// - public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); + public static Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); /// - /// float64_t svclastb[_n_f64](svbool_t pg, float64_t fallback, svfloat64_t data) - /// CLASTB Dtied, Pg, Dtied, Zdata.D + /// float64_t svclastb[_n_f64](svbool_t pg, float64_t fallback, svfloat64_t data) + /// CLASTB Dtied, Pg, Dtied, Zdata.D /// - public static unsafe double ConditionalExtractLastActiveElement(Vector mask, double defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); + public static double ConditionalExtractLastActiveElement(Vector mask, double defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); /// - /// svint16_t svclastb[_s16](svbool_t pg, svint16_t fallback, svint16_t data) - /// CLASTB Htied, Pg, Htied, Zdata.H + /// svint16_t svclastb[_s16](svbool_t pg, svint16_t fallback, svint16_t data) + /// CLASTB Htied, Pg, Htied, Zdata.H /// - public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); + public static Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); /// - /// int16_t svclastb[_n_s16](svbool_t pg, int16_t fallback, svint16_t data) - /// CLASTB Wtied, Pg, Wtied, Zdata.H + /// int16_t svclastb[_n_s16](svbool_t pg, int16_t fallback, svint16_t data) + /// CLASTB Wtied, Pg, Wtied, Zdata.H /// - public static unsafe short ConditionalExtractLastActiveElement(Vector mask, short defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); + public static short ConditionalExtractLastActiveElement(Vector mask, short defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); /// - /// svint32_t svclastb[_s32](svbool_t pg, svint32_t fallback, svint32_t data) - /// CLASTB Stied, Pg, Stied, Zdata.S + /// svint32_t svclastb[_s32](svbool_t pg, svint32_t fallback, svint32_t data) + /// CLASTB Stied, Pg, Stied, Zdata.S /// - public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); + public static Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); /// - /// int32_t svclastb[_n_s32](svbool_t pg, int32_t fallback, svint32_t data) - /// CLASTB Wtied, Pg, Wtied, Zdata.S + /// int32_t svclastb[_n_s32](svbool_t pg, int32_t fallback, svint32_t data) + /// CLASTB Wtied, Pg, Wtied, Zdata.S /// - public static unsafe int ConditionalExtractLastActiveElement(Vector mask, int defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); + public static int ConditionalExtractLastActiveElement(Vector mask, int defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); /// - /// svint64_t svclastb[_s64](svbool_t pg, svint64_t fallback, svint64_t data) - /// CLASTB Dtied, Pg, Dtied, Zdata.D + /// svint64_t svclastb[_s64](svbool_t pg, svint64_t fallback, svint64_t data) + /// CLASTB Dtied, Pg, Dtied, Zdata.D /// - public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); + public static Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); /// - /// int64_t svclastb[_n_s64](svbool_t pg, int64_t fallback, svint64_t data) - /// CLASTB Xtied, Pg, Xtied, Zdata.D + /// int64_t svclastb[_n_s64](svbool_t pg, int64_t fallback, svint64_t data) + /// CLASTB Xtied, Pg, Xtied, Zdata.D /// - public static unsafe long ConditionalExtractLastActiveElement(Vector mask, long defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); + public static long ConditionalExtractLastActiveElement(Vector mask, long defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); /// - /// svint8_t svclastb[_s8](svbool_t pg, svint8_t fallback, svint8_t data) - /// CLASTB Btied, Pg, Btied, Zdata.B + /// svint8_t svclastb[_s8](svbool_t pg, svint8_t fallback, svint8_t data) + /// CLASTB Btied, Pg, Btied, Zdata.B /// - public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); + public static Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); /// - /// int8_t svclastb[_n_s8](svbool_t pg, int8_t fallback, svint8_t data) - /// CLASTB Wtied, Pg, Wtied, Zdata.B + /// int8_t svclastb[_n_s8](svbool_t pg, int8_t fallback, svint8_t data) + /// CLASTB Wtied, Pg, Wtied, Zdata.B /// - public static unsafe sbyte ConditionalExtractLastActiveElement(Vector mask, sbyte defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); + public static sbyte ConditionalExtractLastActiveElement(Vector mask, sbyte defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); /// - /// svfloat32_t svclastb[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) - /// CLASTB Stied, Pg, Stied, Zdata.S + /// svfloat32_t svclastb[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) + /// CLASTB Stied, Pg, Stied, Zdata.S /// - public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); + public static Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); /// - /// float32_t svclastb[_n_f32](svbool_t pg, float32_t fallback, svfloat32_t data) - /// CLASTB Stied, Pg, Stied, Zdata.S + /// float32_t svclastb[_n_f32](svbool_t pg, float32_t fallback, svfloat32_t data) + /// CLASTB Stied, Pg, Stied, Zdata.S /// - public static unsafe float ConditionalExtractLastActiveElement(Vector mask, float defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); + public static float ConditionalExtractLastActiveElement(Vector mask, float defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); /// - /// svuint16_t svclastb[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) - /// CLASTB Htied, Pg, Htied, Zdata.H + /// svuint16_t svclastb[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) + /// CLASTB Htied, Pg, Htied, Zdata.H /// - public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); + public static Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); /// - /// uint16_t svclastb[_n_u16](svbool_t pg, uint16_t fallback, svuint16_t data) - /// CLASTB Wtied, Pg, Wtied, Zdata.H + /// uint16_t svclastb[_n_u16](svbool_t pg, uint16_t fallback, svuint16_t data) + /// CLASTB Wtied, Pg, Wtied, Zdata.H /// - public static unsafe ushort ConditionalExtractLastActiveElement(Vector mask, ushort defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); + public static ushort ConditionalExtractLastActiveElement(Vector mask, ushort defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); /// - /// svuint32_t svclastb[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) - /// CLASTB Stied, Pg, Stied, Zdata.S + /// svuint32_t svclastb[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) + /// CLASTB Stied, Pg, Stied, Zdata.S /// - public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); + public static Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); /// - /// uint32_t svclastb[_n_u32](svbool_t pg, uint32_t fallback, svuint32_t data) - /// CLASTB Wtied, Pg, Wtied, Zdata.S + /// uint32_t svclastb[_n_u32](svbool_t pg, uint32_t fallback, svuint32_t data) + /// CLASTB Wtied, Pg, Wtied, Zdata.S /// - public static unsafe uint ConditionalExtractLastActiveElement(Vector mask, uint defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); + public static uint ConditionalExtractLastActiveElement(Vector mask, uint defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); /// - /// svuint64_t svclastb[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) - /// CLASTB Dtied, Pg, Dtied, Zdata.D + /// svuint64_t svclastb[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) + /// CLASTB Dtied, Pg, Dtied, Zdata.D /// - public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); + public static Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); /// - /// uint64_t svclastb[_n_u64](svbool_t pg, uint64_t fallback, svuint64_t data) - /// CLASTB Xtied, Pg, Xtied, Zdata.D + /// uint64_t svclastb[_n_u64](svbool_t pg, uint64_t fallback, svuint64_t data) + /// CLASTB Xtied, Pg, Xtied, Zdata.D /// - public static unsafe ulong ConditionalExtractLastActiveElement(Vector mask, ulong defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); + public static ulong ConditionalExtractLastActiveElement(Vector mask, ulong defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); // Conditionally extract last element /// - /// svuint8_t svclastb[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) - /// CLASTB Ztied.B, Pg, Ztied.B, Zdata.B + /// svuint8_t svclastb[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) + /// CLASTB Ztied.B, Pg, Ztied.B, Zdata.B /// - public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); + public static Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); /// - /// svfloat64_t svclastb[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) - /// CLASTB Ztied.D, Pg, Ztied.D, Zdata.D + /// svfloat64_t svclastb[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) + /// CLASTB Ztied.D, Pg, Ztied.D, Zdata.D /// - public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); + public static Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); /// - /// svint16_t svclastb[_s16](svbool_t pg, svint16_t fallback, svint16_t data) - /// CLASTB Ztied.H, Pg, Ztied.H, Zdata.H + /// svint16_t svclastb[_s16](svbool_t pg, svint16_t fallback, svint16_t data) + /// CLASTB Ztied.H, Pg, Ztied.H, Zdata.H /// - public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); + public static Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); /// - /// svint32_t svclastb[_s32](svbool_t pg, svint32_t fallback, svint32_t data) - /// CLASTB Ztied.S, Pg, Ztied.S, Zdata.S + /// svint32_t svclastb[_s32](svbool_t pg, svint32_t fallback, svint32_t data) + /// CLASTB Ztied.S, Pg, Ztied.S, Zdata.S /// - public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); + public static Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); /// - /// svint64_t svclastb[_s64](svbool_t pg, svint64_t fallback, svint64_t data) - /// CLASTB Ztied.D, Pg, Ztied.D, Zdata.D + /// svint64_t svclastb[_s64](svbool_t pg, svint64_t fallback, svint64_t data) + /// CLASTB Ztied.D, Pg, Ztied.D, Zdata.D /// - public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); + public static Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); /// - /// svint8_t svclastb[_s8](svbool_t pg, svint8_t fallback, svint8_t data) - /// CLASTB Ztied.B, Pg, Ztied.B, Zdata.B + /// svint8_t svclastb[_s8](svbool_t pg, svint8_t fallback, svint8_t data) + /// CLASTB Ztied.B, Pg, Ztied.B, Zdata.B /// - public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); + public static Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); /// - /// svfloat32_t svclastb[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) - /// CLASTB Ztied.S, Pg, Ztied.S, Zdata.S + /// svfloat32_t svclastb[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) + /// CLASTB Ztied.S, Pg, Ztied.S, Zdata.S /// - public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); + public static Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); /// - /// svuint16_t svclastb[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) - /// CLASTB Ztied.H, Pg, Ztied.H, Zdata.H + /// svuint16_t svclastb[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) + /// CLASTB Ztied.H, Pg, Ztied.H, Zdata.H /// - public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); + public static Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); /// - /// svuint32_t svclastb[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) - /// CLASTB Ztied.S, Pg, Ztied.S, Zdata.S + /// svuint32_t svclastb[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) + /// CLASTB Ztied.S, Pg, Ztied.S, Zdata.S /// - public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); + public static Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); /// - /// svuint64_t svclastb[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) - /// CLASTB Ztied.D, Pg, Ztied.D, Zdata.D + /// svuint64_t svclastb[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) + /// CLASTB Ztied.D, Pg, Ztied.D, Zdata.D /// - public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); + public static Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); // Conditionally select elements /// - /// svuint8_t svsel[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) - /// SEL Zresult.B, Pg, Zop1.B, Zop2.B + /// svuint8_t svsel[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) + /// SEL Zresult.B, Pg, Zop1.B, Zop2.B /// - public static unsafe Vector ConditionalSelect(Vector mask, Vector left, Vector right) => ConditionalSelect(mask, left, right); + public static Vector ConditionalSelect(Vector mask, Vector left, Vector right) => ConditionalSelect(mask, left, right); /// - /// svfloat64_t svsel[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// SEL Zresult.D, Pg, Zop1.D, Zop2.D + /// svfloat64_t svsel[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// SEL Zresult.D, Pg, Zop1.D, Zop2.D /// - public static unsafe Vector ConditionalSelect(Vector mask, Vector left, Vector right) => ConditionalSelect(mask, left, right); + public static Vector ConditionalSelect(Vector mask, Vector left, Vector right) => ConditionalSelect(mask, left, right); /// - /// svint16_t svsel[_s16](svbool_t pg, svint16_t op1, svint16_t op2) - /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) - /// SEL Zresult.H, Pg, Zop1.H, Zop2.H + /// svint16_t svsel[_s16](svbool_t pg, svint16_t op1, svint16_t op2) + /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) + /// SEL Zresult.H, Pg, Zop1.H, Zop2.H /// - public static unsafe Vector ConditionalSelect(Vector mask, Vector left, Vector right) => ConditionalSelect(mask, left, right); + public static Vector ConditionalSelect(Vector mask, Vector left, Vector right) => ConditionalSelect(mask, left, right); /// - /// svint32_t svsel[_s32](svbool_t pg, svint32_t op1, svint32_t op2) - /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) - /// SEL Zresult.S, Pg, Zop1.S, Zop2.S + /// svint32_t svsel[_s32](svbool_t pg, svint32_t op1, svint32_t op2) + /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) + /// SEL Zresult.S, Pg, Zop1.S, Zop2.S /// - public static unsafe Vector ConditionalSelect(Vector mask, Vector left, Vector right) => ConditionalSelect(mask, left, right); + public static Vector ConditionalSelect(Vector mask, Vector left, Vector right) => ConditionalSelect(mask, left, right); /// - /// svint64_t svsel[_s64](svbool_t pg, svint64_t op1, svint64_t op2) - /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) - /// SEL Zresult.D, Pg, Zop1.D, Zop2.D + /// svint64_t svsel[_s64](svbool_t pg, svint64_t op1, svint64_t op2) + /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) + /// SEL Zresult.D, Pg, Zop1.D, Zop2.D /// - public static unsafe Vector ConditionalSelect(Vector mask, Vector left, Vector right) => ConditionalSelect(mask, left, right); + public static Vector ConditionalSelect(Vector mask, Vector left, Vector right) => ConditionalSelect(mask, left, right); /// - /// svint8_t svsel[_s8](svbool_t pg, svint8_t op1, svint8_t op2) - /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) - /// SEL Zresult.B, Pg, Zop1.B, Zop2.B + /// svint8_t svsel[_s8](svbool_t pg, svint8_t op1, svint8_t op2) + /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) + /// SEL Zresult.B, Pg, Zop1.B, Zop2.B /// - public static unsafe Vector ConditionalSelect(Vector mask, Vector left, Vector right) => ConditionalSelect(mask, left, right); + public static Vector ConditionalSelect(Vector mask, Vector left, Vector right) => ConditionalSelect(mask, left, right); /// - /// svfloat32_t svsel[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// SEL Zresult.S, Pg, Zop1.S, Zop2.S + /// svfloat32_t svsel[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// SEL Zresult.S, Pg, Zop1.S, Zop2.S /// - public static unsafe Vector ConditionalSelect(Vector mask, Vector left, Vector right) => ConditionalSelect(mask, left, right); + public static Vector ConditionalSelect(Vector mask, Vector left, Vector right) => ConditionalSelect(mask, left, right); /// - /// svuint16_t svsel[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) - /// SEL Zresult.H, Pg, Zop1.H, Zop2.H + /// svuint16_t svsel[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) + /// SEL Zresult.H, Pg, Zop1.H, Zop2.H /// - public static unsafe Vector ConditionalSelect(Vector mask, Vector left, Vector right) => ConditionalSelect(mask, left, right); + public static Vector ConditionalSelect(Vector mask, Vector left, Vector right) => ConditionalSelect(mask, left, right); /// - /// svuint32_t svsel[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) - /// SEL Zresult.S, Pg, Zop1.S, Zop2.S + /// svuint32_t svsel[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) + /// SEL Zresult.S, Pg, Zop1.S, Zop2.S /// - public static unsafe Vector ConditionalSelect(Vector mask, Vector left, Vector right) => ConditionalSelect(mask, left, right); + public static Vector ConditionalSelect(Vector mask, Vector left, Vector right) => ConditionalSelect(mask, left, right); /// - /// svuint64_t svsel[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) - /// SEL Zresult.D, Pg, Zop1.D, Zop2.D + /// svuint64_t svsel[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svbool_t svsel[_b](svbool_t pg, svbool_t op1, svbool_t op2) + /// SEL Zresult.D, Pg, Zop1.D, Zop2.D /// - public static unsafe Vector ConditionalSelect(Vector mask, Vector left, Vector right) => ConditionalSelect(mask, left, right); + public static Vector ConditionalSelect(Vector mask, Vector left, Vector right) => ConditionalSelect(mask, left, right); // Floating-point convert /// - /// svfloat64_t svcvt_f64[_s32]_m(svfloat64_t inactive, svbool_t pg, svint32_t op) - /// svfloat64_t svcvt_f64[_s32]_x(svbool_t pg, svint32_t op) - /// svfloat64_t svcvt_f64[_s32]_z(svbool_t pg, svint32_t op) - /// SCVTF Zresult.D, Pg/M, Zop.S + /// svfloat64_t svcvt_f64[_s32]_m(svfloat64_t inactive, svbool_t pg, svint32_t op) + /// svfloat64_t svcvt_f64[_s32]_x(svbool_t pg, svint32_t op) + /// svfloat64_t svcvt_f64[_s32]_z(svbool_t pg, svint32_t op) + /// SCVTF Zresult.D, Pg/M, Zop.S /// - public static unsafe Vector ConvertToDouble(Vector value) => ConvertToDouble(value); + public static Vector ConvertToDouble(Vector value) => ConvertToDouble(value); /// - /// svfloat64_t svcvt_f64[_s64]_m(svfloat64_t inactive, svbool_t pg, svint64_t op) - /// svfloat64_t svcvt_f64[_s64]_x(svbool_t pg, svint64_t op) - /// svfloat64_t svcvt_f64[_s64]_z(svbool_t pg, svint64_t op) - /// SCVTF Zresult.D, Pg/M, Zop.D + /// svfloat64_t svcvt_f64[_s64]_m(svfloat64_t inactive, svbool_t pg, svint64_t op) + /// svfloat64_t svcvt_f64[_s64]_x(svbool_t pg, svint64_t op) + /// svfloat64_t svcvt_f64[_s64]_z(svbool_t pg, svint64_t op) + /// SCVTF Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ConvertToDouble(Vector value) => ConvertToDouble(value); + public static Vector ConvertToDouble(Vector value) => ConvertToDouble(value); /// - /// svfloat64_t svcvt_f64[_f32]_m(svfloat64_t inactive, svbool_t pg, svfloat32_t op) - /// svfloat64_t svcvt_f64[_f32]_x(svbool_t pg, svfloat32_t op) - /// svfloat64_t svcvt_f64[_f32]_z(svbool_t pg, svfloat32_t op) - /// FCVT Zresult.D, Pg/M, Zop.S + /// svfloat64_t svcvt_f64[_f32]_m(svfloat64_t inactive, svbool_t pg, svfloat32_t op) + /// svfloat64_t svcvt_f64[_f32]_x(svbool_t pg, svfloat32_t op) + /// svfloat64_t svcvt_f64[_f32]_z(svbool_t pg, svfloat32_t op) + /// FCVT Zresult.D, Pg/M, Zop.S /// - public static unsafe Vector ConvertToDouble(Vector value) => ConvertToDouble(value); + public static Vector ConvertToDouble(Vector value) => ConvertToDouble(value); /// - /// svfloat64_t svcvt_f64[_u32]_m(svfloat64_t inactive, svbool_t pg, svuint32_t op) - /// svfloat64_t svcvt_f64[_u32]_x(svbool_t pg, svuint32_t op) - /// svfloat64_t svcvt_f64[_u32]_z(svbool_t pg, svuint32_t op) - /// UCVTF Zresult.D, Pg/M, Zop.S + /// svfloat64_t svcvt_f64[_u32]_m(svfloat64_t inactive, svbool_t pg, svuint32_t op) + /// svfloat64_t svcvt_f64[_u32]_x(svbool_t pg, svuint32_t op) + /// svfloat64_t svcvt_f64[_u32]_z(svbool_t pg, svuint32_t op) + /// UCVTF Zresult.D, Pg/M, Zop.S /// - public static unsafe Vector ConvertToDouble(Vector value) => ConvertToDouble(value); + public static Vector ConvertToDouble(Vector value) => ConvertToDouble(value); /// - /// svfloat64_t svcvt_f64[_u64]_m(svfloat64_t inactive, svbool_t pg, svuint64_t op) - /// svfloat64_t svcvt_f64[_u64]_x(svbool_t pg, svuint64_t op) - /// svfloat64_t svcvt_f64[_u64]_z(svbool_t pg, svuint64_t op) - /// UCVTF Zresult.D, Pg/M, Zop.D + /// svfloat64_t svcvt_f64[_u64]_m(svfloat64_t inactive, svbool_t pg, svuint64_t op) + /// svfloat64_t svcvt_f64[_u64]_x(svbool_t pg, svuint64_t op) + /// svfloat64_t svcvt_f64[_u64]_z(svbool_t pg, svuint64_t op) + /// UCVTF Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ConvertToDouble(Vector value) => ConvertToDouble(value); + public static Vector ConvertToDouble(Vector value) => ConvertToDouble(value); // Floating-point convert /// - /// svint32_t svcvt_s32[_f64]_m(svint32_t inactive, svbool_t pg, svfloat64_t op) - /// svint32_t svcvt_s32[_f64]_x(svbool_t pg, svfloat64_t op) - /// svint32_t svcvt_s32[_f64]_z(svbool_t pg, svfloat64_t op) - /// FCVTZS Zresult.S, Pg/M, Zop.D + /// svint32_t svcvt_s32[_f64]_m(svint32_t inactive, svbool_t pg, svfloat64_t op) + /// svint32_t svcvt_s32[_f64]_x(svbool_t pg, svfloat64_t op) + /// svint32_t svcvt_s32[_f64]_z(svbool_t pg, svfloat64_t op) + /// FCVTZS Zresult.S, Pg/M, Zop.D /// - public static unsafe Vector ConvertToInt32(Vector value) => ConvertToInt32(value); + public static Vector ConvertToInt32(Vector value) => ConvertToInt32(value); /// - /// svint32_t svcvt_s32[_f32]_m(svint32_t inactive, svbool_t pg, svfloat32_t op) - /// svint32_t svcvt_s32[_f32]_x(svbool_t pg, svfloat32_t op) - /// svint32_t svcvt_s32[_f32]_z(svbool_t pg, svfloat32_t op) - /// FCVTZS Zresult.S, Pg/M, Zop.S + /// svint32_t svcvt_s32[_f32]_m(svint32_t inactive, svbool_t pg, svfloat32_t op) + /// svint32_t svcvt_s32[_f32]_x(svbool_t pg, svfloat32_t op) + /// svint32_t svcvt_s32[_f32]_z(svbool_t pg, svfloat32_t op) + /// FCVTZS Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ConvertToInt32(Vector value) => ConvertToInt32(value); + public static Vector ConvertToInt32(Vector value) => ConvertToInt32(value); // Floating-point convert /// - /// svint64_t svcvt_s64[_f64]_m(svint64_t inactive, svbool_t pg, svfloat64_t op) - /// svint64_t svcvt_s64[_f64]_x(svbool_t pg, svfloat64_t op) - /// svint64_t svcvt_s64[_f64]_z(svbool_t pg, svfloat64_t op) - /// FCVTZS Zresult.D, Pg/M, Zop.D + /// svint64_t svcvt_s64[_f64]_m(svint64_t inactive, svbool_t pg, svfloat64_t op) + /// svint64_t svcvt_s64[_f64]_x(svbool_t pg, svfloat64_t op) + /// svint64_t svcvt_s64[_f64]_z(svbool_t pg, svfloat64_t op) + /// FCVTZS Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ConvertToInt64(Vector value) => ConvertToInt64(value); + public static Vector ConvertToInt64(Vector value) => ConvertToInt64(value); /// - /// svint64_t svcvt_s64[_f32]_m(svint64_t inactive, svbool_t pg, svfloat32_t op) - /// svint64_t svcvt_s64[_f32]_x(svbool_t pg, svfloat32_t op) - /// svint64_t svcvt_s64[_f32]_z(svbool_t pg, svfloat32_t op) - /// FCVTZS Zresult.D, Pg/M, Zop.S + /// svint64_t svcvt_s64[_f32]_m(svint64_t inactive, svbool_t pg, svfloat32_t op) + /// svint64_t svcvt_s64[_f32]_x(svbool_t pg, svfloat32_t op) + /// svint64_t svcvt_s64[_f32]_z(svbool_t pg, svfloat32_t op) + /// FCVTZS Zresult.D, Pg/M, Zop.S /// - public static unsafe Vector ConvertToInt64(Vector value) => ConvertToInt64(value); + public static Vector ConvertToInt64(Vector value) => ConvertToInt64(value); // Floating-point convert /// - /// svfloat32_t svcvt_f32[_f64]_m(svfloat32_t inactive, svbool_t pg, svfloat64_t op) - /// svfloat32_t svcvt_f32[_f64]_x(svbool_t pg, svfloat64_t op) - /// svfloat32_t svcvt_f32[_f64]_z(svbool_t pg, svfloat64_t op) - /// FCVT Zresult.S, Pg/M, Zop.D + /// svfloat32_t svcvt_f32[_f64]_m(svfloat32_t inactive, svbool_t pg, svfloat64_t op) + /// svfloat32_t svcvt_f32[_f64]_x(svbool_t pg, svfloat64_t op) + /// svfloat32_t svcvt_f32[_f64]_z(svbool_t pg, svfloat64_t op) + /// FCVT Zresult.S, Pg/M, Zop.D /// - public static unsafe Vector ConvertToSingle(Vector value) => ConvertToSingle(value); + public static Vector ConvertToSingle(Vector value) => ConvertToSingle(value); /// - /// svfloat32_t svcvt_f32[_s32]_m(svfloat32_t inactive, svbool_t pg, svint32_t op) - /// svfloat32_t svcvt_f32[_s32]_x(svbool_t pg, svint32_t op) - /// svfloat32_t svcvt_f32[_s32]_z(svbool_t pg, svint32_t op) - /// SCVTF Zresult.S, Pg/M, Zop.S + /// svfloat32_t svcvt_f32[_s32]_m(svfloat32_t inactive, svbool_t pg, svint32_t op) + /// svfloat32_t svcvt_f32[_s32]_x(svbool_t pg, svint32_t op) + /// svfloat32_t svcvt_f32[_s32]_z(svbool_t pg, svint32_t op) + /// SCVTF Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ConvertToSingle(Vector value) => ConvertToSingle(value); + public static Vector ConvertToSingle(Vector value) => ConvertToSingle(value); /// - /// svfloat32_t svcvt_f32[_s64]_m(svfloat32_t inactive, svbool_t pg, svint64_t op) - /// svfloat32_t svcvt_f32[_s64]_x(svbool_t pg, svint64_t op) - /// svfloat32_t svcvt_f32[_s64]_z(svbool_t pg, svint64_t op) - /// SCVTF Zresult.S, Pg/M, Zop.D + /// svfloat32_t svcvt_f32[_s64]_m(svfloat32_t inactive, svbool_t pg, svint64_t op) + /// svfloat32_t svcvt_f32[_s64]_x(svbool_t pg, svint64_t op) + /// svfloat32_t svcvt_f32[_s64]_z(svbool_t pg, svint64_t op) + /// SCVTF Zresult.S, Pg/M, Zop.D /// - public static unsafe Vector ConvertToSingle(Vector value) => ConvertToSingle(value); + public static Vector ConvertToSingle(Vector value) => ConvertToSingle(value); /// - /// svfloat32_t svcvt_f32[_u32]_m(svfloat32_t inactive, svbool_t pg, svuint32_t op) - /// svfloat32_t svcvt_f32[_u32]_x(svbool_t pg, svuint32_t op) - /// svfloat32_t svcvt_f32[_u32]_z(svbool_t pg, svuint32_t op) - /// UCVTF Zresult.S, Pg/M, Zop.S + /// svfloat32_t svcvt_f32[_u32]_m(svfloat32_t inactive, svbool_t pg, svuint32_t op) + /// svfloat32_t svcvt_f32[_u32]_x(svbool_t pg, svuint32_t op) + /// svfloat32_t svcvt_f32[_u32]_z(svbool_t pg, svuint32_t op) + /// UCVTF Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ConvertToSingle(Vector value) => ConvertToSingle(value); + public static Vector ConvertToSingle(Vector value) => ConvertToSingle(value); /// - /// svfloat32_t svcvt_f32[_u64]_m(svfloat32_t inactive, svbool_t pg, svuint64_t op) - /// svfloat32_t svcvt_f32[_u64]_x(svbool_t pg, svuint64_t op) - /// svfloat32_t svcvt_f32[_u64]_z(svbool_t pg, svuint64_t op) - /// UCVTF Zresult.S, Pg/M, Zop.D + /// svfloat32_t svcvt_f32[_u64]_m(svfloat32_t inactive, svbool_t pg, svuint64_t op) + /// svfloat32_t svcvt_f32[_u64]_x(svbool_t pg, svuint64_t op) + /// svfloat32_t svcvt_f32[_u64]_z(svbool_t pg, svuint64_t op) + /// UCVTF Zresult.S, Pg/M, Zop.D /// - public static unsafe Vector ConvertToSingle(Vector value) => ConvertToSingle(value); + public static Vector ConvertToSingle(Vector value) => ConvertToSingle(value); // Floating-point convert /// - /// svuint32_t svcvt_u32[_f64]_m(svuint32_t inactive, svbool_t pg, svfloat64_t op) - /// svuint32_t svcvt_u32[_f64]_x(svbool_t pg, svfloat64_t op) - /// svuint32_t svcvt_u32[_f64]_z(svbool_t pg, svfloat64_t op) - /// FCVTZU Zresult.S, Pg/M, Zop.D + /// svuint32_t svcvt_u32[_f64]_m(svuint32_t inactive, svbool_t pg, svfloat64_t op) + /// svuint32_t svcvt_u32[_f64]_x(svbool_t pg, svfloat64_t op) + /// svuint32_t svcvt_u32[_f64]_z(svbool_t pg, svfloat64_t op) + /// FCVTZU Zresult.S, Pg/M, Zop.D /// - public static unsafe Vector ConvertToUInt32(Vector value) => ConvertToUInt32(value); + public static Vector ConvertToUInt32(Vector value) => ConvertToUInt32(value); /// - /// svuint32_t svcvt_u32[_f32]_m(svuint32_t inactive, svbool_t pg, svfloat32_t op) - /// svuint32_t svcvt_u32[_f32]_x(svbool_t pg, svfloat32_t op) - /// svuint32_t svcvt_u32[_f32]_z(svbool_t pg, svfloat32_t op) - /// FCVTZU Zresult.S, Pg/M, Zop.S + /// svuint32_t svcvt_u32[_f32]_m(svuint32_t inactive, svbool_t pg, svfloat32_t op) + /// svuint32_t svcvt_u32[_f32]_x(svbool_t pg, svfloat32_t op) + /// svuint32_t svcvt_u32[_f32]_z(svbool_t pg, svfloat32_t op) + /// FCVTZU Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ConvertToUInt32(Vector value) => ConvertToUInt32(value); + public static Vector ConvertToUInt32(Vector value) => ConvertToUInt32(value); // Floating-point convert /// - /// svuint64_t svcvt_u64[_f64]_m(svuint64_t inactive, svbool_t pg, svfloat64_t op) - /// svuint64_t svcvt_u64[_f64]_x(svbool_t pg, svfloat64_t op) - /// svuint64_t svcvt_u64[_f64]_z(svbool_t pg, svfloat64_t op) - /// FCVTZU Zresult.D, Pg/M, Zop.D + /// svuint64_t svcvt_u64[_f64]_m(svuint64_t inactive, svbool_t pg, svfloat64_t op) + /// svuint64_t svcvt_u64[_f64]_x(svbool_t pg, svfloat64_t op) + /// svuint64_t svcvt_u64[_f64]_z(svbool_t pg, svfloat64_t op) + /// FCVTZU Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ConvertToUInt64(Vector value) => ConvertToUInt64(value); + public static Vector ConvertToUInt64(Vector value) => ConvertToUInt64(value); /// - /// svuint64_t svcvt_u64[_f32]_m(svuint64_t inactive, svbool_t pg, svfloat32_t op) - /// svuint64_t svcvt_u64[_f32]_x(svbool_t pg, svfloat32_t op) - /// svuint64_t svcvt_u64[_f32]_z(svbool_t pg, svfloat32_t op) - /// FCVTZU Zresult.D, Pg/M, Zop.S + /// svuint64_t svcvt_u64[_f32]_m(svuint64_t inactive, svbool_t pg, svfloat32_t op) + /// svuint64_t svcvt_u64[_f32]_x(svbool_t pg, svfloat32_t op) + /// svuint64_t svcvt_u64[_f32]_z(svbool_t pg, svfloat32_t op) + /// FCVTZU Zresult.D, Pg/M, Zop.S /// - public static unsafe Vector ConvertToUInt64(Vector value) => ConvertToUInt64(value); + public static Vector ConvertToUInt64(Vector value) => ConvertToUInt64(value); // Count the number of 16-bit elements in a vector /// - /// uint64_t svcnth_pat(enum svpattern pattern) - /// CNTH Xresult, pattern + /// uint64_t svcnth_pat(enum svpattern pattern) + /// CNTH Xresult, pattern /// - public static unsafe ulong Count16BitElements([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => Count16BitElements(pattern); + public static ulong Count16BitElements([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => Count16BitElements(pattern); // Count the number of 32-bit elements in a vector /// - /// uint64_t svcntw_pat(enum svpattern pattern) - /// CNTW Xresult, pattern + /// uint64_t svcntw_pat(enum svpattern pattern) + /// CNTW Xresult, pattern /// - public static unsafe ulong Count32BitElements([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => Count32BitElements(pattern); + public static ulong Count32BitElements([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => Count32BitElements(pattern); // Count the number of 64-bit elements in a vector /// - /// uint64_t svcntd_pat(enum svpattern pattern) - /// CNTD Xresult, pattern + /// uint64_t svcntd_pat(enum svpattern pattern) + /// CNTD Xresult, pattern /// - public static unsafe ulong Count64BitElements([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => Count64BitElements(pattern); + public static ulong Count64BitElements([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => Count64BitElements(pattern); // Count the number of 8-bit elements in a vector /// - /// uint64_t svcntb_pat(enum svpattern pattern) - /// CNTB Xresult, pattern + /// uint64_t svcntb_pat(enum svpattern pattern) + /// CNTB Xresult, pattern /// - public static unsafe ulong Count8BitElements([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => Count8BitElements(pattern); + public static ulong Count8BitElements([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => Count8BitElements(pattern); // Break after first true condition /// - /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) - /// BRKA Presult.B, Pg/Z, Pop.B + /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) + /// BRKA Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakAfterMask(Vector mask, Vector srcMask) => CreateBreakAfterMask(mask, srcMask); + public static Vector CreateBreakAfterMask(Vector mask, Vector srcMask) => CreateBreakAfterMask(mask, srcMask); /// - /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) - /// BRKA Presult.B, Pg/Z, Pop.B + /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) + /// BRKA Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakAfterMask(Vector mask, Vector srcMask) => CreateBreakAfterMask(mask, srcMask); + public static Vector CreateBreakAfterMask(Vector mask, Vector srcMask) => CreateBreakAfterMask(mask, srcMask); /// - /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) - /// BRKA Presult.B, Pg/Z, Pop.B + /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) + /// BRKA Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakAfterMask(Vector mask, Vector srcMask) => CreateBreakAfterMask(mask, srcMask); + public static Vector CreateBreakAfterMask(Vector mask, Vector srcMask) => CreateBreakAfterMask(mask, srcMask); /// - /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) - /// BRKA Presult.B, Pg/Z, Pop.B + /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) + /// BRKA Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakAfterMask(Vector mask, Vector srcMask) => CreateBreakAfterMask(mask, srcMask); + public static Vector CreateBreakAfterMask(Vector mask, Vector srcMask) => CreateBreakAfterMask(mask, srcMask); /// - /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) - /// BRKA Presult.B, Pg/Z, Pop.B + /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) + /// BRKA Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakAfterMask(Vector mask, Vector srcMask) => CreateBreakAfterMask(mask, srcMask); + public static Vector CreateBreakAfterMask(Vector mask, Vector srcMask) => CreateBreakAfterMask(mask, srcMask); /// - /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) - /// BRKA Presult.B, Pg/Z, Pop.B + /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) + /// BRKA Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakAfterMask(Vector mask, Vector srcMask) => CreateBreakAfterMask(mask, srcMask); + public static Vector CreateBreakAfterMask(Vector mask, Vector srcMask) => CreateBreakAfterMask(mask, srcMask); /// - /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) - /// BRKA Presult.B, Pg/Z, Pop.B + /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) + /// BRKA Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakAfterMask(Vector mask, Vector srcMask) => CreateBreakAfterMask(mask, srcMask); + public static Vector CreateBreakAfterMask(Vector mask, Vector srcMask) => CreateBreakAfterMask(mask, srcMask); /// - /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) - /// BRKA Presult.B, Pg/Z, Pop.B + /// svbool_t svbrka[_b]_z(svbool_t pg, svbool_t op) + /// BRKA Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakAfterMask(Vector mask, Vector srcMask) => CreateBreakAfterMask(mask, srcMask); + public static Vector CreateBreakAfterMask(Vector mask, Vector srcMask) => CreateBreakAfterMask(mask, srcMask); // Break after first true condition, propagating from previous partition /// - /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) => CreateBreakAfterPropagateMask(mask, left, right); + public static Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) => CreateBreakAfterPropagateMask(mask, left, right); /// - /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) => CreateBreakAfterPropagateMask(mask, left, right); + public static Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) => CreateBreakAfterPropagateMask(mask, left, right); /// - /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) => CreateBreakAfterPropagateMask(mask, left, right); + public static Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) => CreateBreakAfterPropagateMask(mask, left, right); /// - /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) => CreateBreakAfterPropagateMask(mask, left, right); + public static Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) => CreateBreakAfterPropagateMask(mask, left, right); /// - /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) => CreateBreakAfterPropagateMask(mask, left, right); + public static Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) => CreateBreakAfterPropagateMask(mask, left, right); /// - /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) => CreateBreakAfterPropagateMask(mask, left, right); + public static Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) => CreateBreakAfterPropagateMask(mask, left, right); /// - /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) => CreateBreakAfterPropagateMask(mask, left, right); + public static Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) => CreateBreakAfterPropagateMask(mask, left, right); /// - /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpa[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPA Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) => CreateBreakAfterPropagateMask(mask, left, right); + public static Vector CreateBreakAfterPropagateMask(Vector mask, Vector left, Vector right) => CreateBreakAfterPropagateMask(mask, left, right); // Break before first true condition /// - /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) - /// BRKB Presult.B, Pg/Z, Pop.B + /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) + /// BRKB Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) => CreateBreakBeforeMask(mask, srcMask); + public static Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) => CreateBreakBeforeMask(mask, srcMask); /// - /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) - /// BRKB Presult.B, Pg/Z, Pop.B + /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) + /// BRKB Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) => CreateBreakBeforeMask(mask, srcMask); + public static Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) => CreateBreakBeforeMask(mask, srcMask); /// - /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) - /// BRKB Presult.B, Pg/Z, Pop.B + /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) + /// BRKB Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) => CreateBreakBeforeMask(mask, srcMask); + public static Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) => CreateBreakBeforeMask(mask, srcMask); /// - /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) - /// BRKB Presult.B, Pg/Z, Pop.B + /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) + /// BRKB Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) => CreateBreakBeforeMask(mask, srcMask); + public static Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) => CreateBreakBeforeMask(mask, srcMask); /// - /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) - /// BRKB Presult.B, Pg/Z, Pop.B + /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) + /// BRKB Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) => CreateBreakBeforeMask(mask, srcMask); + public static Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) => CreateBreakBeforeMask(mask, srcMask); /// - /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) - /// BRKB Presult.B, Pg/Z, Pop.B + /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) + /// BRKB Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) => CreateBreakBeforeMask(mask, srcMask); + public static Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) => CreateBreakBeforeMask(mask, srcMask); /// - /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) - /// BRKB Presult.B, Pg/Z, Pop.B + /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) + /// BRKB Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) => CreateBreakBeforeMask(mask, srcMask); + public static Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) => CreateBreakBeforeMask(mask, srcMask); /// - /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) - /// BRKB Presult.B, Pg/Z, Pop.B + /// svbool_t svbrkb[_b]_z(svbool_t pg, svbool_t op) + /// BRKB Presult.B, Pg/Z, Pop.B /// - public static unsafe Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) => CreateBreakBeforeMask(mask, srcMask); + public static Vector CreateBreakBeforeMask(Vector mask, Vector srcMask) => CreateBreakBeforeMask(mask, srcMask); // Break before first true condition, propagating from previous partition /// - /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) => CreateBreakBeforePropagateMask(mask, left, right); + public static Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) => CreateBreakBeforePropagateMask(mask, left, right); /// - /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) => CreateBreakBeforePropagateMask(mask, left, right); + public static Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) => CreateBreakBeforePropagateMask(mask, left, right); /// - /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) => CreateBreakBeforePropagateMask(mask, left, right); + public static Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) => CreateBreakBeforePropagateMask(mask, left, right); /// - /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) => CreateBreakBeforePropagateMask(mask, left, right); + public static Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) => CreateBreakBeforePropagateMask(mask, left, right); /// - /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) => CreateBreakBeforePropagateMask(mask, left, right); + public static Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) => CreateBreakBeforePropagateMask(mask, left, right); /// - /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) => CreateBreakBeforePropagateMask(mask, left, right); + public static Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) => CreateBreakBeforePropagateMask(mask, left, right); /// - /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) => CreateBreakBeforePropagateMask(mask, left, right); + public static Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) => CreateBreakBeforePropagateMask(mask, left, right); /// - /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B + /// svbool_t svbrkpb[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKPB Presult.B, Pg/Z, Pop1.B, Pop2.B /// - public static unsafe Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) => CreateBreakBeforePropagateMask(mask, left, right); + public static Vector CreateBreakBeforePropagateMask(Vector mask, Vector left, Vector right) => CreateBreakBeforePropagateMask(mask, left, right); // Propagate break to next partition /// - /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B + /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B /// - public static unsafe Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) => CreateBreakPropagateMask(totalMask, fromMask); + public static Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) => CreateBreakPropagateMask(totalMask, fromMask); /// - /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B + /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B /// - public static unsafe Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) => CreateBreakPropagateMask(totalMask, fromMask); + public static Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) => CreateBreakPropagateMask(totalMask, fromMask); /// - /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B + /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B /// - public static unsafe Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) => CreateBreakPropagateMask(totalMask, fromMask); + public static Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) => CreateBreakPropagateMask(totalMask, fromMask); /// - /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B + /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B /// - public static unsafe Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) => CreateBreakPropagateMask(totalMask, fromMask); + public static Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) => CreateBreakPropagateMask(totalMask, fromMask); /// - /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B + /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B /// - public static unsafe Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) => CreateBreakPropagateMask(totalMask, fromMask); + public static Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) => CreateBreakPropagateMask(totalMask, fromMask); /// - /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B + /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B /// - public static unsafe Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) => CreateBreakPropagateMask(totalMask, fromMask); + public static Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) => CreateBreakPropagateMask(totalMask, fromMask); /// - /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B + /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B /// - public static unsafe Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) => CreateBreakPropagateMask(totalMask, fromMask); + public static Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) => CreateBreakPropagateMask(totalMask, fromMask); /// - /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) - /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B + /// svbool_t svbrkn[_b]_z(svbool_t pg, svbool_t op1, svbool_t op2) + /// BRKN Ptied2.B, Pg/Z, Pop1.B, Ptied2.B /// - public static unsafe Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) => CreateBreakPropagateMask(totalMask, fromMask); + public static Vector CreateBreakPropagateMask(Vector totalMask, Vector fromMask) => CreateBreakPropagateMask(totalMask, fromMask); // Set all predicate elements to false /// - /// svbool_t svpfalse[_b]() - /// PFALSE Presult.B + /// svbool_t svpfalse[_b]() + /// PFALSE Presult.B /// - public static unsafe Vector CreateFalseMaskByte() => CreateFalseMaskByte(); + public static Vector CreateFalseMaskByte() => CreateFalseMaskByte(); // Set all predicate elements to false /// - /// svbool_t svpfalse[_b]() - /// PFALSE Presult.B + /// svbool_t svpfalse[_b]() + /// PFALSE Presult.B /// - public static unsafe Vector CreateFalseMaskDouble() => CreateFalseMaskDouble(); + public static Vector CreateFalseMaskDouble() => CreateFalseMaskDouble(); // Set all predicate elements to false /// - /// svbool_t svpfalse[_b]() - /// PFALSE Presult.B + /// svbool_t svpfalse[_b]() + /// PFALSE Presult.B /// - public static unsafe Vector CreateFalseMaskInt16() => CreateFalseMaskInt16(); + public static Vector CreateFalseMaskInt16() => CreateFalseMaskInt16(); // Set all predicate elements to false /// - /// svbool_t svpfalse[_b]() - /// PFALSE Presult.B + /// svbool_t svpfalse[_b]() + /// PFALSE Presult.B /// - public static unsafe Vector CreateFalseMaskInt32() => CreateFalseMaskInt32(); + public static Vector CreateFalseMaskInt32() => CreateFalseMaskInt32(); // Set all predicate elements to false /// - /// svbool_t svpfalse[_b]() - /// PFALSE Presult.B + /// svbool_t svpfalse[_b]() + /// PFALSE Presult.B /// - public static unsafe Vector CreateFalseMaskInt64() => CreateFalseMaskInt64(); + public static Vector CreateFalseMaskInt64() => CreateFalseMaskInt64(); // Set all predicate elements to false /// - /// svbool_t svpfalse[_b]() - /// PFALSE Presult.B + /// svbool_t svpfalse[_b]() + /// PFALSE Presult.B /// - public static unsafe Vector CreateFalseMaskSByte() => CreateFalseMaskSByte(); + public static Vector CreateFalseMaskSByte() => CreateFalseMaskSByte(); // Set all predicate elements to false /// - /// svbool_t svpfalse[_b]() - /// PFALSE Presult.B + /// svbool_t svpfalse[_b]() + /// PFALSE Presult.B /// - public static unsafe Vector CreateFalseMaskSingle() => CreateFalseMaskSingle(); + public static Vector CreateFalseMaskSingle() => CreateFalseMaskSingle(); // Set all predicate elements to false /// - /// svbool_t svpfalse[_b]() - /// PFALSE Presult.B + /// svbool_t svpfalse[_b]() + /// PFALSE Presult.B /// - public static unsafe Vector CreateFalseMaskUInt16() => CreateFalseMaskUInt16(); + public static Vector CreateFalseMaskUInt16() => CreateFalseMaskUInt16(); // Set all predicate elements to false /// - /// svbool_t svpfalse[_b]() - /// PFALSE Presult.B + /// svbool_t svpfalse[_b]() + /// PFALSE Presult.B /// - public static unsafe Vector CreateFalseMaskUInt32() => CreateFalseMaskUInt32(); + public static Vector CreateFalseMaskUInt32() => CreateFalseMaskUInt32(); // Set all predicate elements to false /// - /// svbool_t svpfalse[_b]() - /// PFALSE Presult.B + /// svbool_t svpfalse[_b]() + /// PFALSE Presult.B /// - public static unsafe Vector CreateFalseMaskUInt64() => CreateFalseMaskUInt64(); + public static Vector CreateFalseMaskUInt64() => CreateFalseMaskUInt64(); // Set the first active predicate element to true /// - /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) - /// PFIRST Ptied.B, Pg, Ptied.B + /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) + /// PFIRST Ptied.B, Pg, Ptied.B /// - public static unsafe Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) => CreateMaskForFirstActiveElement(mask, srcMask); + public static Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) => CreateMaskForFirstActiveElement(mask, srcMask); /// - /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) - /// PFIRST Ptied.B, Pg, Ptied.B + /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) + /// PFIRST Ptied.B, Pg, Ptied.B /// - public static unsafe Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) => CreateMaskForFirstActiveElement(mask, srcMask); + public static Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) => CreateMaskForFirstActiveElement(mask, srcMask); /// - /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) - /// PFIRST Ptied.B, Pg, Ptied.B + /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) + /// PFIRST Ptied.B, Pg, Ptied.B /// - public static unsafe Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) => CreateMaskForFirstActiveElement(mask, srcMask); + public static Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) => CreateMaskForFirstActiveElement(mask, srcMask); /// - /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) - /// PFIRST Ptied.B, Pg, Ptied.B + /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) + /// PFIRST Ptied.B, Pg, Ptied.B /// - public static unsafe Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) => CreateMaskForFirstActiveElement(mask, srcMask); + public static Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) => CreateMaskForFirstActiveElement(mask, srcMask); /// - /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) - /// PFIRST Ptied.B, Pg, Ptied.B + /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) + /// PFIRST Ptied.B, Pg, Ptied.B /// - public static unsafe Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) => CreateMaskForFirstActiveElement(mask, srcMask); + public static Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) => CreateMaskForFirstActiveElement(mask, srcMask); /// - /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) - /// PFIRST Ptied.B, Pg, Ptied.B + /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) + /// PFIRST Ptied.B, Pg, Ptied.B /// - public static unsafe Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) => CreateMaskForFirstActiveElement(mask, srcMask); + public static Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) => CreateMaskForFirstActiveElement(mask, srcMask); /// - /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) - /// PFIRST Ptied.B, Pg, Ptied.B + /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) + /// PFIRST Ptied.B, Pg, Ptied.B /// - public static unsafe Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) => CreateMaskForFirstActiveElement(mask, srcMask); + public static Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) => CreateMaskForFirstActiveElement(mask, srcMask); /// - /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) - /// PFIRST Ptied.B, Pg, Ptied.B + /// svbool_t svpfirst[_b](svbool_t pg, svbool_t op) + /// PFIRST Ptied.B, Pg, Ptied.B /// - public static unsafe Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) => CreateMaskForFirstActiveElement(mask, srcMask); + public static Vector CreateMaskForFirstActiveElement(Vector mask, Vector srcMask) => CreateMaskForFirstActiveElement(mask, srcMask); // Find next active predicate /// - /// svbool_t svpnext_b8(svbool_t pg, svbool_t op) - /// PNEXT Ptied.B, Pg, Ptied.B + /// svbool_t svpnext_b8(svbool_t pg, svbool_t op) + /// PNEXT Ptied.B, Pg, Ptied.B /// - public static unsafe Vector CreateMaskForNextActiveElement(Vector mask, Vector srcMask) => CreateMaskForNextActiveElement(mask, srcMask); + public static Vector CreateMaskForNextActiveElement(Vector mask, Vector srcMask) => CreateMaskForNextActiveElement(mask, srcMask); /// - /// svbool_t svpnext_b16(svbool_t pg, svbool_t op) - /// PNEXT Ptied.H, Pg, Ptied.H + /// svbool_t svpnext_b16(svbool_t pg, svbool_t op) + /// PNEXT Ptied.H, Pg, Ptied.H /// - public static unsafe Vector CreateMaskForNextActiveElement(Vector mask, Vector srcMask) => CreateMaskForNextActiveElement(mask, srcMask); + public static Vector CreateMaskForNextActiveElement(Vector mask, Vector srcMask) => CreateMaskForNextActiveElement(mask, srcMask); /// - /// svbool_t svpnext_b32(svbool_t pg, svbool_t op) - /// PNEXT Ptied.S, Pg, Ptied.S + /// svbool_t svpnext_b32(svbool_t pg, svbool_t op) + /// PNEXT Ptied.S, Pg, Ptied.S /// - public static unsafe Vector CreateMaskForNextActiveElement(Vector mask, Vector srcMask) => CreateMaskForNextActiveElement(mask, srcMask); + public static Vector CreateMaskForNextActiveElement(Vector mask, Vector srcMask) => CreateMaskForNextActiveElement(mask, srcMask); /// - /// svbool_t svpnext_b64(svbool_t pg, svbool_t op) - /// PNEXT Ptied.D, Pg, Ptied.D + /// svbool_t svpnext_b64(svbool_t pg, svbool_t op) + /// PNEXT Ptied.D, Pg, Ptied.D /// - public static unsafe Vector CreateMaskForNextActiveElement(Vector mask, Vector srcMask) => CreateMaskForNextActiveElement(mask, srcMask); + public static Vector CreateMaskForNextActiveElement(Vector mask, Vector srcMask) => CreateMaskForNextActiveElement(mask, srcMask); // Set predicate elements to true /// - /// svbool_t svptrue_pat_b8(enum svpattern pattern) - /// PTRUE Presult.B, pattern + /// svbool_t svptrue_pat_b8(enum svpattern pattern) + /// PTRUE Presult.B, pattern /// - public static unsafe Vector CreateTrueMaskByte([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => CreateTrueMaskByte(pattern); + public static Vector CreateTrueMaskByte([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => CreateTrueMaskByte(pattern); // Set predicate elements to true /// - /// svbool_t svptrue_pat_b8(enum svpattern pattern) - /// PTRUE Presult.B, pattern + /// svbool_t svptrue_pat_b8(enum svpattern pattern) + /// PTRUE Presult.B, pattern /// - public static unsafe Vector CreateTrueMaskDouble([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => CreateTrueMaskDouble(pattern); + public static Vector CreateTrueMaskDouble([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => CreateTrueMaskDouble(pattern); // Set predicate elements to true /// - /// svbool_t svptrue_pat_b8(enum svpattern pattern) - /// PTRUE Presult.B, pattern + /// svbool_t svptrue_pat_b8(enum svpattern pattern) + /// PTRUE Presult.B, pattern /// - public static unsafe Vector CreateTrueMaskInt16([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => CreateTrueMaskInt16(pattern); + public static Vector CreateTrueMaskInt16([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => CreateTrueMaskInt16(pattern); // Set predicate elements to true /// - /// svbool_t svptrue_pat_b8(enum svpattern pattern) - /// PTRUE Presult.B, pattern + /// svbool_t svptrue_pat_b8(enum svpattern pattern) + /// PTRUE Presult.B, pattern /// - public static unsafe Vector CreateTrueMaskInt32([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => CreateTrueMaskInt32(pattern); + public static Vector CreateTrueMaskInt32([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => CreateTrueMaskInt32(pattern); // Set predicate elements to true /// - /// svbool_t svptrue_pat_b8(enum svpattern pattern) - /// PTRUE Presult.B, pattern + /// svbool_t svptrue_pat_b8(enum svpattern pattern) + /// PTRUE Presult.B, pattern /// - public static unsafe Vector CreateTrueMaskInt64([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => CreateTrueMaskInt64(pattern); + public static Vector CreateTrueMaskInt64([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => CreateTrueMaskInt64(pattern); // Set predicate elements to true /// - /// svbool_t svptrue_pat_b8(enum svpattern pattern) - /// PTRUE Presult.B, pattern + /// svbool_t svptrue_pat_b8(enum svpattern pattern) + /// PTRUE Presult.B, pattern /// - public static unsafe Vector CreateTrueMaskSByte([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => CreateTrueMaskSByte(pattern); + public static Vector CreateTrueMaskSByte([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => CreateTrueMaskSByte(pattern); // Set predicate elements to true /// - /// svbool_t svptrue_pat_b8(enum svpattern pattern) - /// PTRUE Presult.B, pattern + /// svbool_t svptrue_pat_b8(enum svpattern pattern) + /// PTRUE Presult.B, pattern /// - public static unsafe Vector CreateTrueMaskSingle([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => CreateTrueMaskSingle(pattern); + public static Vector CreateTrueMaskSingle([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => CreateTrueMaskSingle(pattern); // Set predicate elements to true /// - /// svbool_t svptrue_pat_b16(enum svpattern pattern) - /// PTRUE Presult.H, pattern + /// svbool_t svptrue_pat_b16(enum svpattern pattern) + /// PTRUE Presult.H, pattern /// - public static unsafe Vector CreateTrueMaskUInt16([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => CreateTrueMaskUInt16(pattern); + public static Vector CreateTrueMaskUInt16([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => CreateTrueMaskUInt16(pattern); // Set predicate elements to true /// - /// svbool_t svptrue_pat_b32(enum svpattern pattern) - /// PTRUE Presult.S, pattern + /// svbool_t svptrue_pat_b32(enum svpattern pattern) + /// PTRUE Presult.S, pattern /// - public static unsafe Vector CreateTrueMaskUInt32([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => CreateTrueMaskUInt32(pattern); + public static Vector CreateTrueMaskUInt32([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => CreateTrueMaskUInt32(pattern); // Set predicate elements to true /// - /// svbool_t svptrue_pat_b64(enum svpattern pattern) - /// PTRUE Presult.D, pattern + /// svbool_t svptrue_pat_b64(enum svpattern pattern) + /// PTRUE Presult.D, pattern /// - public static unsafe Vector CreateTrueMaskUInt64([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => CreateTrueMaskUInt64(pattern); + public static Vector CreateTrueMaskUInt64([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => CreateTrueMaskUInt64(pattern); // While incrementing scalar is less than /// - /// svbool_t svwhilelt_b16[_s32](int32_t op1, int32_t op2) - /// WHILELT Presult.H, Wop1, Wop2 + /// svbool_t svwhilelt_b16[_s32](int32_t op1, int32_t op2) + /// WHILELT Presult.H, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanMask16Bit(int left, int right) => CreateWhileLessThanMask16Bit(left, right); + public static Vector CreateWhileLessThanMask16Bit(int left, int right) => CreateWhileLessThanMask16Bit(left, right); /// - /// svbool_t svwhilelt_b16[_s64](int64_t op1, int64_t op2) - /// WHILELT Presult.H, Xop1, Xop2 + /// svbool_t svwhilelt_b16[_s64](int64_t op1, int64_t op2) + /// WHILELT Presult.H, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanMask16Bit(long left, long right) => CreateWhileLessThanMask16Bit(left, right); + public static Vector CreateWhileLessThanMask16Bit(long left, long right) => CreateWhileLessThanMask16Bit(left, right); /// - /// svbool_t svwhilelt_b16[_u32](uint32_t op1, uint32_t op2) - /// WHILELO Presult.H, Wop1, Wop2 + /// svbool_t svwhilelt_b16[_u32](uint32_t op1, uint32_t op2) + /// WHILELO Presult.H, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanMask16Bit(uint left, uint right) => CreateWhileLessThanMask16Bit(left, right); + public static Vector CreateWhileLessThanMask16Bit(uint left, uint right) => CreateWhileLessThanMask16Bit(left, right); /// - /// svbool_t svwhilelt_b16[_u64](uint64_t op1, uint64_t op2) - /// WHILELO Presult.H, Xop1, Xop2 + /// svbool_t svwhilelt_b16[_u64](uint64_t op1, uint64_t op2) + /// WHILELO Presult.H, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanMask16Bit(ulong left, ulong right) => CreateWhileLessThanMask16Bit(left, right); + public static Vector CreateWhileLessThanMask16Bit(ulong left, ulong right) => CreateWhileLessThanMask16Bit(left, right); // While incrementing scalar is less than /// - /// svbool_t svwhilelt_b32[_s32](int32_t op1, int32_t op2) - /// WHILELT Presult.S, Wop1, Wop2 + /// svbool_t svwhilelt_b32[_s32](int32_t op1, int32_t op2) + /// WHILELT Presult.S, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanMask32Bit(int left, int right) => CreateWhileLessThanMask32Bit(left, right); + public static Vector CreateWhileLessThanMask32Bit(int left, int right) => CreateWhileLessThanMask32Bit(left, right); /// - /// svbool_t svwhilelt_b32[_s64](int64_t op1, int64_t op2) - /// WHILELT Presult.S, Xop1, Xop2 + /// svbool_t svwhilelt_b32[_s64](int64_t op1, int64_t op2) + /// WHILELT Presult.S, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanMask32Bit(long left, long right) => CreateWhileLessThanMask32Bit(left, right); + public static Vector CreateWhileLessThanMask32Bit(long left, long right) => CreateWhileLessThanMask32Bit(left, right); /// - /// svbool_t svwhilelt_b32[_u32](uint32_t op1, uint32_t op2) - /// WHILELO Presult.S, Wop1, Wop2 + /// svbool_t svwhilelt_b32[_u32](uint32_t op1, uint32_t op2) + /// WHILELO Presult.S, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanMask32Bit(uint left, uint right) => CreateWhileLessThanMask32Bit(left, right); + public static Vector CreateWhileLessThanMask32Bit(uint left, uint right) => CreateWhileLessThanMask32Bit(left, right); /// - /// svbool_t svwhilelt_b32[_u64](uint64_t op1, uint64_t op2) - /// WHILELO Presult.S, Xop1, Xop2 + /// svbool_t svwhilelt_b32[_u64](uint64_t op1, uint64_t op2) + /// WHILELO Presult.S, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanMask32Bit(ulong left, ulong right) => CreateWhileLessThanMask32Bit(left, right); + public static Vector CreateWhileLessThanMask32Bit(ulong left, ulong right) => CreateWhileLessThanMask32Bit(left, right); // While incrementing scalar is less than /// - /// svbool_t svwhilelt_b64[_s32](int32_t op1, int32_t op2) - /// WHILELT Presult.D, Wop1, Wop2 + /// svbool_t svwhilelt_b64[_s32](int32_t op1, int32_t op2) + /// WHILELT Presult.D, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanMask64Bit(int left, int right) => CreateWhileLessThanMask64Bit(left, right); + public static Vector CreateWhileLessThanMask64Bit(int left, int right) => CreateWhileLessThanMask64Bit(left, right); /// - /// svbool_t svwhilelt_b64[_s64](int64_t op1, int64_t op2) - /// WHILELT Presult.D, Xop1, Xop2 + /// svbool_t svwhilelt_b64[_s64](int64_t op1, int64_t op2) + /// WHILELT Presult.D, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanMask64Bit(long left, long right) => CreateWhileLessThanMask64Bit(left, right); + public static Vector CreateWhileLessThanMask64Bit(long left, long right) => CreateWhileLessThanMask64Bit(left, right); /// - /// svbool_t svwhilelt_b64[_u32](uint32_t op1, uint32_t op2) - /// WHILELO Presult.D, Wop1, Wop2 + /// svbool_t svwhilelt_b64[_u32](uint32_t op1, uint32_t op2) + /// WHILELO Presult.D, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanMask64Bit(uint left, uint right) => CreateWhileLessThanMask64Bit(left, right); + public static Vector CreateWhileLessThanMask64Bit(uint left, uint right) => CreateWhileLessThanMask64Bit(left, right); /// - /// svbool_t svwhilelt_b64[_u64](uint64_t op1, uint64_t op2) - /// WHILELO Presult.D, Xop1, Xop2 + /// svbool_t svwhilelt_b64[_u64](uint64_t op1, uint64_t op2) + /// WHILELO Presult.D, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanMask64Bit(ulong left, ulong right) => CreateWhileLessThanMask64Bit(left, right); + public static Vector CreateWhileLessThanMask64Bit(ulong left, ulong right) => CreateWhileLessThanMask64Bit(left, right); // While incrementing scalar is less than /// - /// svbool_t svwhilelt_b8[_s32](int32_t op1, int32_t op2) - /// WHILELT Presult.B, Wop1, Wop2 + /// svbool_t svwhilelt_b8[_s32](int32_t op1, int32_t op2) + /// WHILELT Presult.B, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanMask8Bit(int left, int right) => CreateWhileLessThanMask8Bit(left, right); + public static Vector CreateWhileLessThanMask8Bit(int left, int right) => CreateWhileLessThanMask8Bit(left, right); /// - /// svbool_t svwhilelt_b8[_s64](int64_t op1, int64_t op2) - /// WHILELT Presult.B, Xop1, Xop2 + /// svbool_t svwhilelt_b8[_s64](int64_t op1, int64_t op2) + /// WHILELT Presult.B, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanMask8Bit(long left, long right) => CreateWhileLessThanMask8Bit(left, right); + public static Vector CreateWhileLessThanMask8Bit(long left, long right) => CreateWhileLessThanMask8Bit(left, right); /// - /// svbool_t svwhilelt_b8[_u32](uint32_t op1, uint32_t op2) - /// WHILELO Presult.B, Wop1, Wop2 + /// svbool_t svwhilelt_b8[_u32](uint32_t op1, uint32_t op2) + /// WHILELO Presult.B, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanMask8Bit(uint left, uint right) => CreateWhileLessThanMask8Bit(left, right); + public static Vector CreateWhileLessThanMask8Bit(uint left, uint right) => CreateWhileLessThanMask8Bit(left, right); /// - /// svbool_t svwhilelt_b8[_u64](uint64_t op1, uint64_t op2) - /// WHILELO Presult.B, Xop1, Xop2 + /// svbool_t svwhilelt_b8[_u64](uint64_t op1, uint64_t op2) + /// WHILELO Presult.B, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanMask8Bit(ulong left, ulong right) => CreateWhileLessThanMask8Bit(left, right); + public static Vector CreateWhileLessThanMask8Bit(ulong left, ulong right) => CreateWhileLessThanMask8Bit(left, right); // While incrementing scalar is less than or equal to /// - /// svbool_t svwhilele_b16[_s32](int32_t op1, int32_t op2) - /// WHILELE Presult.H, Wop1, Wop2 + /// svbool_t svwhilele_b16[_s32](int32_t op1, int32_t op2) + /// WHILELE Presult.H, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask16Bit(int left, int right) => CreateWhileLessThanOrEqualMask16Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMask16Bit(int left, int right) => CreateWhileLessThanOrEqualMask16Bit(left, right); /// - /// svbool_t svwhilele_b16[_s64](int64_t op1, int64_t op2) - /// WHILELE Presult.H, Xop1, Xop2 + /// svbool_t svwhilele_b16[_s64](int64_t op1, int64_t op2) + /// WHILELE Presult.H, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask16Bit(long left, long right) => CreateWhileLessThanOrEqualMask16Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMask16Bit(long left, long right) => CreateWhileLessThanOrEqualMask16Bit(left, right); /// - /// svbool_t svwhilele_b16[_u32](uint32_t op1, uint32_t op2) - /// WHILELS Presult.H, Wop1, Wop2 + /// svbool_t svwhilele_b16[_u32](uint32_t op1, uint32_t op2) + /// WHILELS Presult.H, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask16Bit(uint left, uint right) => CreateWhileLessThanOrEqualMask16Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMask16Bit(uint left, uint right) => CreateWhileLessThanOrEqualMask16Bit(left, right); /// - /// svbool_t svwhilele_b16[_u64](uint64_t op1, uint64_t op2) - /// WHILELS Presult.H, Xop1, Xop2 + /// svbool_t svwhilele_b16[_u64](uint64_t op1, uint64_t op2) + /// WHILELS Presult.H, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask16Bit(ulong left, ulong right) => CreateWhileLessThanOrEqualMask16Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMask16Bit(ulong left, ulong right) => CreateWhileLessThanOrEqualMask16Bit(left, right); // While incrementing scalar is less than or equal to /// - /// svbool_t svwhilele_b32[_s32](int32_t op1, int32_t op2) - /// WHILELE Presult.S, Wop1, Wop2 + /// svbool_t svwhilele_b32[_s32](int32_t op1, int32_t op2) + /// WHILELE Presult.S, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask32Bit(int left, int right) => CreateWhileLessThanOrEqualMask32Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMask32Bit(int left, int right) => CreateWhileLessThanOrEqualMask32Bit(left, right); /// - /// svbool_t svwhilele_b32[_s64](int64_t op1, int64_t op2) - /// WHILELE Presult.S, Xop1, Xop2 + /// svbool_t svwhilele_b32[_s64](int64_t op1, int64_t op2) + /// WHILELE Presult.S, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask32Bit(long left, long right) => CreateWhileLessThanOrEqualMask32Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMask32Bit(long left, long right) => CreateWhileLessThanOrEqualMask32Bit(left, right); /// - /// svbool_t svwhilele_b32[_u32](uint32_t op1, uint32_t op2) - /// WHILELS Presult.S, Wop1, Wop2 + /// svbool_t svwhilele_b32[_u32](uint32_t op1, uint32_t op2) + /// WHILELS Presult.S, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask32Bit(uint left, uint right) => CreateWhileLessThanOrEqualMask32Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMask32Bit(uint left, uint right) => CreateWhileLessThanOrEqualMask32Bit(left, right); /// - /// svbool_t svwhilele_b32[_u64](uint64_t op1, uint64_t op2) - /// WHILELS Presult.S, Xop1, Xop2 + /// svbool_t svwhilele_b32[_u64](uint64_t op1, uint64_t op2) + /// WHILELS Presult.S, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask32Bit(ulong left, ulong right) => CreateWhileLessThanOrEqualMask32Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMask32Bit(ulong left, ulong right) => CreateWhileLessThanOrEqualMask32Bit(left, right); // While incrementing scalar is less than or equal to /// - /// svbool_t svwhilele_b64[_s32](int32_t op1, int32_t op2) - /// WHILELE Presult.D, Wop1, Wop2 + /// svbool_t svwhilele_b64[_s32](int32_t op1, int32_t op2) + /// WHILELE Presult.D, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask64Bit(int left, int right) => CreateWhileLessThanOrEqualMask64Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMask64Bit(int left, int right) => CreateWhileLessThanOrEqualMask64Bit(left, right); /// - /// svbool_t svwhilele_b64[_s64](int64_t op1, int64_t op2) - /// WHILELE Presult.D, Xop1, Xop2 + /// svbool_t svwhilele_b64[_s64](int64_t op1, int64_t op2) + /// WHILELE Presult.D, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask64Bit(long left, long right) => CreateWhileLessThanOrEqualMask64Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMask64Bit(long left, long right) => CreateWhileLessThanOrEqualMask64Bit(left, right); /// - /// svbool_t svwhilele_b64[_u32](uint32_t op1, uint32_t op2) - /// WHILELS Presult.D, Wop1, Wop2 + /// svbool_t svwhilele_b64[_u32](uint32_t op1, uint32_t op2) + /// WHILELS Presult.D, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask64Bit(uint left, uint right) => CreateWhileLessThanOrEqualMask64Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMask64Bit(uint left, uint right) => CreateWhileLessThanOrEqualMask64Bit(left, right); /// - /// svbool_t svwhilele_b64[_u64](uint64_t op1, uint64_t op2) - /// WHILELS Presult.D, Xop1, Xop2 + /// svbool_t svwhilele_b64[_u64](uint64_t op1, uint64_t op2) + /// WHILELS Presult.D, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask64Bit(ulong left, ulong right) => CreateWhileLessThanOrEqualMask64Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMask64Bit(ulong left, ulong right) => CreateWhileLessThanOrEqualMask64Bit(left, right); // While incrementing scalar is less than or equal to /// - /// svbool_t svwhilele_b8[_s32](int32_t op1, int32_t op2) - /// WHILELE Presult.B, Wop1, Wop2 + /// svbool_t svwhilele_b8[_s32](int32_t op1, int32_t op2) + /// WHILELE Presult.B, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask8Bit(int left, int right) => CreateWhileLessThanOrEqualMask8Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMask8Bit(int left, int right) => CreateWhileLessThanOrEqualMask8Bit(left, right); /// - /// svbool_t svwhilele_b8[_s64](int64_t op1, int64_t op2) - /// WHILELE Presult.B, Xop1, Xop2 + /// svbool_t svwhilele_b8[_s64](int64_t op1, int64_t op2) + /// WHILELE Presult.B, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask8Bit(long left, long right) => CreateWhileLessThanOrEqualMask8Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMask8Bit(long left, long right) => CreateWhileLessThanOrEqualMask8Bit(left, right); /// - /// svbool_t svwhilele_b8[_u32](uint32_t op1, uint32_t op2) - /// WHILELS Presult.B, Wop1, Wop2 + /// svbool_t svwhilele_b8[_u32](uint32_t op1, uint32_t op2) + /// WHILELS Presult.B, Wop1, Wop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask8Bit(uint left, uint right) => CreateWhileLessThanOrEqualMask8Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMask8Bit(uint left, uint right) => CreateWhileLessThanOrEqualMask8Bit(left, right); /// - /// svbool_t svwhilele_b8[_u64](uint64_t op1, uint64_t op2) - /// WHILELS Presult.B, Xop1, Xop2 + /// svbool_t svwhilele_b8[_u64](uint64_t op1, uint64_t op2) + /// WHILELS Presult.B, Xop1, Xop2 /// - public static unsafe Vector CreateWhileLessThanOrEqualMask8Bit(ulong left, ulong right) => CreateWhileLessThanOrEqualMask8Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMask8Bit(ulong left, ulong right) => CreateWhileLessThanOrEqualMask8Bit(left, right); // Divide /// - /// svfloat64_t svdiv[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svdiv[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svdiv[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FDIV Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svfloat64_t svdiv[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svdiv[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svdiv[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FDIV Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector Divide(Vector left, Vector right) => Divide(left, right); + public static Vector Divide(Vector left, Vector right) => Divide(left, right); /// - /// svfloat32_t svdiv[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svdiv[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svdiv[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FDIV Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svfloat32_t svdiv[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svdiv[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svdiv[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FDIV Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector Divide(Vector left, Vector right) => Divide(left, right); + public static Vector Divide(Vector left, Vector right) => Divide(left, right); // Dot product /// - /// svint32_t svdot[_s32](svint32_t op1, svint8_t op2, svint8_t op3) - /// SDOT Ztied1.S, Zop2.B, Zop3.B + /// svint32_t svdot[_s32](svint32_t op1, svint8_t op2, svint8_t op3) + /// SDOT Ztied1.S, Zop2.B, Zop3.B /// - public static unsafe Vector DotProduct(Vector addend, Vector left, Vector right) => DotProduct(addend, left, right); + public static Vector DotProduct(Vector addend, Vector left, Vector right) => DotProduct(addend, left, right); /// - /// svint64_t svdot[_s64](svint64_t op1, svint16_t op2, svint16_t op3) - /// SDOT Ztied1.D, Zop2.H, Zop3.H + /// svint64_t svdot[_s64](svint64_t op1, svint16_t op2, svint16_t op3) + /// SDOT Ztied1.D, Zop2.H, Zop3.H /// - public static unsafe Vector DotProduct(Vector addend, Vector left, Vector right) => DotProduct(addend, left, right); + public static Vector DotProduct(Vector addend, Vector left, Vector right) => DotProduct(addend, left, right); /// - /// svuint32_t svdot[_u32](svuint32_t op1, svuint8_t op2, svuint8_t op3) - /// UDOT Ztied1.S, Zop2.B, Zop3.B + /// svuint32_t svdot[_u32](svuint32_t op1, svuint8_t op2, svuint8_t op3) + /// UDOT Ztied1.S, Zop2.B, Zop3.B /// - public static unsafe Vector DotProduct(Vector addend, Vector left, Vector right) => DotProduct(addend, left, right); + public static Vector DotProduct(Vector addend, Vector left, Vector right) => DotProduct(addend, left, right); /// - /// svuint64_t svdot[_u64](svuint64_t op1, svuint16_t op2, svuint16_t op3) - /// UDOT Ztied1.D, Zop2.H, Zop3.H + /// svuint64_t svdot[_u64](svuint64_t op1, svuint16_t op2, svuint16_t op3) + /// UDOT Ztied1.D, Zop2.H, Zop3.H /// - public static unsafe Vector DotProduct(Vector addend, Vector left, Vector right) => DotProduct(addend, left, right); + public static Vector DotProduct(Vector addend, Vector left, Vector right) => DotProduct(addend, left, right); // Dot product /// - /// svint32_t svdot_lane[_s32](svint32_t op1, svint8_t op2, svint8_t op3, uint64_t imm_index) - /// SDOT Ztied1.S, Zop2.B, Zop3.B[imm_index] + /// svint32_t svdot_lane[_s32](svint32_t op1, svint8_t op2, svint8_t op3, uint64_t imm_index) + /// SDOT Ztied1.S, Zop2.B, Zop3.B[imm_index] /// - public static unsafe Vector DotProductBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected] byte rightIndex) => DotProductBySelectedScalar(addend, left, right, rightIndex); + public static Vector DotProductBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected] byte rightIndex) => DotProductBySelectedScalar(addend, left, right, rightIndex); /// - /// svint64_t svdot_lane[_s64](svint64_t op1, svint16_t op2, svint16_t op3, uint64_t imm_index) - /// SDOT Ztied1.D, Zop2.H, Zop3.H[imm_index] + /// svint64_t svdot_lane[_s64](svint64_t op1, svint16_t op2, svint16_t op3, uint64_t imm_index) + /// SDOT Ztied1.D, Zop2.H, Zop3.H[imm_index] /// - public static unsafe Vector DotProductBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected] byte rightIndex) => DotProductBySelectedScalar(addend, left, right, rightIndex); + public static Vector DotProductBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected] byte rightIndex) => DotProductBySelectedScalar(addend, left, right, rightIndex); /// - /// svuint32_t svdot_lane[_u32](svuint32_t op1, svuint8_t op2, svuint8_t op3, uint64_t imm_index) - /// UDOT Ztied1.S, Zop2.B, Zop3.B[imm_index] + /// svuint32_t svdot_lane[_u32](svuint32_t op1, svuint8_t op2, svuint8_t op3, uint64_t imm_index) + /// UDOT Ztied1.S, Zop2.B, Zop3.B[imm_index] /// - public static unsafe Vector DotProductBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected] byte rightIndex) => DotProductBySelectedScalar(addend, left, right, rightIndex); + public static Vector DotProductBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected] byte rightIndex) => DotProductBySelectedScalar(addend, left, right, rightIndex); /// - /// svuint64_t svdot_lane[_u64](svuint64_t op1, svuint16_t op2, svuint16_t op3, uint64_t imm_index) - /// UDOT Ztied1.D, Zop2.H, Zop3.H[imm_index] + /// svuint64_t svdot_lane[_u64](svuint64_t op1, svuint16_t op2, svuint16_t op3, uint64_t imm_index) + /// UDOT Ztied1.D, Zop2.H, Zop3.H[imm_index] /// - public static unsafe Vector DotProductBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected] byte rightIndex) => DotProductBySelectedScalar(addend, left, right, rightIndex); + public static Vector DotProductBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected] byte rightIndex) => DotProductBySelectedScalar(addend, left, right, rightIndex); // Broadcast a scalar value /// - /// svuint8_t svdup_lane[_u8](svuint8_t data, uint8_t index) - /// DUP Zresult.B, Zdata.B[index] + /// svuint8_t svdup_lane[_u8](svuint8_t data, uint8_t index) + /// DUP Zresult.B, Zdata.B[index] /// - public static unsafe Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(63))] byte index) => DuplicateSelectedScalarToVector(data, index); + public static Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(63))] byte index) => DuplicateSelectedScalarToVector(data, index); /// - /// svfloat64_t svdup_lane[_f64](svfloat64_t data, uint64_t index) - /// DUP Zresult.D, Zdata.D[index] + /// svfloat64_t svdup_lane[_f64](svfloat64_t data, uint64_t index) + /// DUP Zresult.D, Zdata.D[index] /// - public static unsafe Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(7))] byte index) => DuplicateSelectedScalarToVector(data, index); + public static Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(7))] byte index) => DuplicateSelectedScalarToVector(data, index); /// - /// svint16_t svdup_lane[_s16](svint16_t data, uint16_t index) - /// DUP Zresult.H, Zdata.H[index] + /// svint16_t svdup_lane[_s16](svint16_t data, uint16_t index) + /// DUP Zresult.H, Zdata.H[index] /// - public static unsafe Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(31))] byte index) => DuplicateSelectedScalarToVector(data, index); + public static Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(31))] byte index) => DuplicateSelectedScalarToVector(data, index); /// - /// svint32_t svdup_lane[_s32](svint32_t data, uint32_t index) - /// DUP Zresult.S, Zdata.S[index] + /// svint32_t svdup_lane[_s32](svint32_t data, uint32_t index) + /// DUP Zresult.S, Zdata.S[index] /// - public static unsafe Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(15))] byte index) => DuplicateSelectedScalarToVector(data, index); + public static Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(15))] byte index) => DuplicateSelectedScalarToVector(data, index); /// - /// svint64_t svdup_lane[_s64](svint64_t data, uint64_t index) - /// DUP Zresult.D, Zdata.D[index] + /// svint64_t svdup_lane[_s64](svint64_t data, uint64_t index) + /// DUP Zresult.D, Zdata.D[index] /// - public static unsafe Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(7))] byte index) => DuplicateSelectedScalarToVector(data, index); + public static Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(7))] byte index) => DuplicateSelectedScalarToVector(data, index); /// - /// svint8_t svdup_lane[_s8](svint8_t data, uint8_t index) - /// DUP Zresult.B, Zdata.B[index] + /// svint8_t svdup_lane[_s8](svint8_t data, uint8_t index) + /// DUP Zresult.B, Zdata.B[index] /// - public static unsafe Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(63))] byte index) => DuplicateSelectedScalarToVector(data, index); + public static Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(63))] byte index) => DuplicateSelectedScalarToVector(data, index); /// - /// svfloat32_t svdup_lane[_f32](svfloat32_t data, uint32_t index) - /// DUP Zresult.S, Zdata.S[index] + /// svfloat32_t svdup_lane[_f32](svfloat32_t data, uint32_t index) + /// DUP Zresult.S, Zdata.S[index] /// - public static unsafe Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(15))] byte index) => DuplicateSelectedScalarToVector(data, index); + public static Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(15))] byte index) => DuplicateSelectedScalarToVector(data, index); /// - /// svuint16_t svdup_lane[_u16](svuint16_t data, uint16_t index) - /// DUP Zresult.H, Zdata.H[index] + /// svuint16_t svdup_lane[_u16](svuint16_t data, uint16_t index) + /// DUP Zresult.H, Zdata.H[index] /// - public static unsafe Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(31))] byte index) => DuplicateSelectedScalarToVector(data, index); + public static Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(31))] byte index) => DuplicateSelectedScalarToVector(data, index); /// - /// svuint32_t svdup_lane[_u32](svuint32_t data, uint32_t index) - /// DUP Zresult.S, Zdata.S[index] + /// svuint32_t svdup_lane[_u32](svuint32_t data, uint32_t index) + /// DUP Zresult.S, Zdata.S[index] /// - public static unsafe Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(15))] byte index) => DuplicateSelectedScalarToVector(data, index); + public static Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(15))] byte index) => DuplicateSelectedScalarToVector(data, index); /// - /// svuint64_t svdup_lane[_u64](svuint64_t data, uint64_t index) - /// DUP Zresult.D, Zdata.D[index] + /// svuint64_t svdup_lane[_u64](svuint64_t data, uint64_t index) + /// DUP Zresult.D, Zdata.D[index] /// - public static unsafe Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(7))] byte index) => DuplicateSelectedScalarToVector(data, index); + public static Vector DuplicateSelectedScalarToVector(Vector data, [ConstantExpected(Min = 0, Max = (byte)(7))] byte index) => DuplicateSelectedScalarToVector(data, index); /// - /// svuint8_t svext[_u8](svuint8_t op1, svuint8_t op2, uint64_t imm3) - /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 + /// svuint8_t svext[_u8](svuint8_t op1, svuint8_t op2, uint64_t imm3) + /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 /// - public static unsafe Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) => ExtractVector(upper, lower, index); + public static Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) => ExtractVector(upper, lower, index); /// - /// svfloat64_t svext[_f64](svfloat64_t op1, svfloat64_t op2, uint64_t imm3) - /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 8 + /// svfloat64_t svext[_f64](svfloat64_t op1, svfloat64_t op2, uint64_t imm3) + /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 8 /// - public static unsafe Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) => ExtractVector(upper, lower, index); + public static Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) => ExtractVector(upper, lower, index); /// - /// svint16_t svext[_s16](svint16_t op1, svint16_t op2, uint64_t imm3) - /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 2 + /// svint16_t svext[_s16](svint16_t op1, svint16_t op2, uint64_t imm3) + /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 2 /// - public static unsafe Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) => ExtractVector(upper, lower, index); + public static Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) => ExtractVector(upper, lower, index); /// - /// svint32_t svext[_s32](svint32_t op1, svint32_t op2, uint64_t imm3) - /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 4 + /// svint32_t svext[_s32](svint32_t op1, svint32_t op2, uint64_t imm3) + /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 4 /// - public static unsafe Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) => ExtractVector(upper, lower, index); + public static Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) => ExtractVector(upper, lower, index); /// - /// svint64_t svext[_s64](svint64_t op1, svint64_t op2, uint64_t imm3) - /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 8 + /// svint64_t svext[_s64](svint64_t op1, svint64_t op2, uint64_t imm3) + /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 8 /// - public static unsafe Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) => ExtractVector(upper, lower, index); + public static Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) => ExtractVector(upper, lower, index); /// - /// svint8_t svext[_s8](svint8_t op1, svint8_t op2, uint64_t imm3) - /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 + /// svint8_t svext[_s8](svint8_t op1, svint8_t op2, uint64_t imm3) + /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 /// - public static unsafe Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) => ExtractVector(upper, lower, index); + public static Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) => ExtractVector(upper, lower, index); /// - /// svfloat32_t svext[_f32](svfloat32_t op1, svfloat32_t op2, uint64_t imm3) - /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 4 + /// svfloat32_t svext[_f32](svfloat32_t op1, svfloat32_t op2, uint64_t imm3) + /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 4 /// - public static unsafe Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) => ExtractVector(upper, lower, index); + public static Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) => ExtractVector(upper, lower, index); /// - /// svuint16_t svext[_u16](svuint16_t op1, svuint16_t op2, uint64_t imm3) - /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 2 + /// svuint16_t svext[_u16](svuint16_t op1, svuint16_t op2, uint64_t imm3) + /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 2 /// - public static unsafe Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) => ExtractVector(upper, lower, index); + public static Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) => ExtractVector(upper, lower, index); /// - /// svuint32_t svext[_u32](svuint32_t op1, svuint32_t op2, uint64_t imm3) - /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 4 + /// svuint32_t svext[_u32](svuint32_t op1, svuint32_t op2, uint64_t imm3) + /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 4 /// - public static unsafe Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) => ExtractVector(upper, lower, index); + public static Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) => ExtractVector(upper, lower, index); /// - /// svuint64_t svext[_u64](svuint64_t op1, svuint64_t op2, uint64_t imm3) - /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 8 + /// svuint64_t svext[_u64](svuint64_t op1, svuint64_t op2, uint64_t imm3) + /// EXT Ztied1.B, Ztied1.B, Zop2.B, #imm3 * 8 /// - public static unsafe Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) => ExtractVector(upper, lower, index); + public static Vector ExtractVector(Vector upper, Vector lower, [ConstantExpected] byte index) => ExtractVector(upper, lower, index); // Floating-point exponential accelerator /// - /// svfloat64_t svexpa[_f64](svuint64_t op) - /// FEXPA Zresult.D, Zop.D + /// svfloat64_t svexpa[_f64](svuint64_t op) + /// FEXPA Zresult.D, Zop.D /// - public static unsafe Vector FloatingPointExponentialAccelerator(Vector value) => FloatingPointExponentialAccelerator(value); + public static Vector FloatingPointExponentialAccelerator(Vector value) => FloatingPointExponentialAccelerator(value); /// - /// svfloat32_t svexpa[_f32](svuint32_t op) - /// FEXPA Zresult.S, Zop.S + /// svfloat32_t svexpa[_f32](svuint32_t op) + /// FEXPA Zresult.S, Zop.S /// - public static unsafe Vector FloatingPointExponentialAccelerator(Vector value) => FloatingPointExponentialAccelerator(value); + public static Vector FloatingPointExponentialAccelerator(Vector value) => FloatingPointExponentialAccelerator(value); // Multiply-add, addend first /// - /// svfloat64_t svmla[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) - /// svfloat64_t svmla[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) - /// svfloat64_t svmla[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) - /// FMLA Ztied1.D, Pg/M, Zop2.D, Zop3.D + /// svfloat64_t svmla[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) + /// svfloat64_t svmla[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) + /// svfloat64_t svmla[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) + /// FMLA Ztied1.D, Pg/M, Zop2.D, Zop3.D /// - public static unsafe Vector FusedMultiplyAdd(Vector addend, Vector left, Vector right) => FusedMultiplyAdd(addend, left, right); + public static Vector FusedMultiplyAdd(Vector addend, Vector left, Vector right) => FusedMultiplyAdd(addend, left, right); /// - /// svfloat32_t svmla[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) - /// svfloat32_t svmla[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) - /// svfloat32_t svmla[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) - /// FMLA Ztied1.S, Pg/M, Zop2.S, Zop3.S + /// svfloat32_t svmla[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) + /// svfloat32_t svmla[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) + /// svfloat32_t svmla[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) + /// FMLA Ztied1.S, Pg/M, Zop2.S, Zop3.S /// - public static unsafe Vector FusedMultiplyAdd(Vector addend, Vector left, Vector right) => FusedMultiplyAdd(addend, left, right); + public static Vector FusedMultiplyAdd(Vector addend, Vector left, Vector right) => FusedMultiplyAdd(addend, left, right); // Multiply-add, addend first /// - /// svfloat64_t svmla_lane[_f64](svfloat64_t op1, svfloat64_t op2, svfloat64_t op3, uint64_t imm_index) - /// FMLA Ztied1.D, Zop2.D, Zop3.D[imm_index] + /// svfloat64_t svmla_lane[_f64](svfloat64_t op1, svfloat64_t op2, svfloat64_t op3, uint64_t imm_index) + /// FMLA Ztied1.D, Zop2.D, Zop3.D[imm_index] /// - public static unsafe Vector FusedMultiplyAddBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected] byte rightIndex) => FusedMultiplyAddBySelectedScalar(addend, left, right, rightIndex); + public static Vector FusedMultiplyAddBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected] byte rightIndex) => FusedMultiplyAddBySelectedScalar(addend, left, right, rightIndex); /// - /// svfloat32_t svmla_lane[_f32](svfloat32_t op1, svfloat32_t op2, svfloat32_t op3, uint64_t imm_index) - /// FMLA Ztied1.S, Zop2.S, Zop3.S[imm_index] + /// svfloat32_t svmla_lane[_f32](svfloat32_t op1, svfloat32_t op2, svfloat32_t op3, uint64_t imm_index) + /// FMLA Ztied1.S, Zop2.S, Zop3.S[imm_index] /// - public static unsafe Vector FusedMultiplyAddBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected] byte rightIndex) => FusedMultiplyAddBySelectedScalar(addend, left, right, rightIndex); + public static Vector FusedMultiplyAddBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected] byte rightIndex) => FusedMultiplyAddBySelectedScalar(addend, left, right, rightIndex); // Negated multiply-add, addend first /// - /// svfloat64_t svnmla[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) - /// svfloat64_t svnmla[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) - /// svfloat64_t svnmla[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) - /// FNMLA Ztied1.D, Pg/M, Zop2.D, Zop3.D + /// svfloat64_t svnmla[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) + /// svfloat64_t svnmla[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) + /// svfloat64_t svnmla[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) + /// FNMLA Ztied1.D, Pg/M, Zop2.D, Zop3.D /// - public static unsafe Vector FusedMultiplyAddNegated(Vector addend, Vector left, Vector right) => FusedMultiplyAddNegated(addend, left, right); + public static Vector FusedMultiplyAddNegated(Vector addend, Vector left, Vector right) => FusedMultiplyAddNegated(addend, left, right); /// - /// svfloat32_t svnmla[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) - /// svfloat32_t svnmla[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) - /// svfloat32_t svnmla[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) - /// FNMLA Ztied1.S, Pg/M, Zop2.S, Zop3.S + /// svfloat32_t svnmla[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) + /// svfloat32_t svnmla[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) + /// svfloat32_t svnmla[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) + /// FNMLA Ztied1.S, Pg/M, Zop2.S, Zop3.S /// - public static unsafe Vector FusedMultiplyAddNegated(Vector addend, Vector left, Vector right) => FusedMultiplyAddNegated(addend, left, right); + public static Vector FusedMultiplyAddNegated(Vector addend, Vector left, Vector right) => FusedMultiplyAddNegated(addend, left, right); // Multiply-subtract, minuend first /// - /// svfloat64_t svmls[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) - /// svfloat64_t svmls[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) - /// svfloat64_t svmls[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) - /// FMLS Ztied1.D, Pg/M, Zop2.D, Zop3.D + /// svfloat64_t svmls[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) + /// svfloat64_t svmls[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) + /// svfloat64_t svmls[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) + /// FMLS Ztied1.D, Pg/M, Zop2.D, Zop3.D /// - public static unsafe Vector FusedMultiplySubtract(Vector minuend, Vector left, Vector right) => FusedMultiplySubtract(minuend, left, right); + public static Vector FusedMultiplySubtract(Vector minuend, Vector left, Vector right) => FusedMultiplySubtract(minuend, left, right); /// - /// svfloat32_t svmls[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) - /// svfloat32_t svmls[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) - /// svfloat32_t svmls[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) - /// FMLS Ztied1.S, Pg/M, Zop2.S, Zop3.S + /// svfloat32_t svmls[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) + /// svfloat32_t svmls[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) + /// svfloat32_t svmls[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) + /// FMLS Ztied1.S, Pg/M, Zop2.S, Zop3.S /// - public static unsafe Vector FusedMultiplySubtract(Vector minuend, Vector left, Vector right) => FusedMultiplySubtract(minuend, left, right); + public static Vector FusedMultiplySubtract(Vector minuend, Vector left, Vector right) => FusedMultiplySubtract(minuend, left, right); // Multiply-subtract, minuend first /// - /// svfloat64_t svmls_lane[_f64](svfloat64_t op1, svfloat64_t op2, svfloat64_t op3, uint64_t imm_index) - /// FMLS Ztied1.D, Zop2.D, Zop3.D[imm_index] + /// svfloat64_t svmls_lane[_f64](svfloat64_t op1, svfloat64_t op2, svfloat64_t op3, uint64_t imm_index) + /// FMLS Ztied1.D, Zop2.D, Zop3.D[imm_index] /// - public static unsafe Vector FusedMultiplySubtractBySelectedScalar(Vector minuend, Vector left, Vector right, [ConstantExpected] byte rightIndex) => FusedMultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); + public static Vector FusedMultiplySubtractBySelectedScalar(Vector minuend, Vector left, Vector right, [ConstantExpected] byte rightIndex) => FusedMultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); /// - /// svfloat32_t svmls_lane[_f32](svfloat32_t op1, svfloat32_t op2, svfloat32_t op3, uint64_t imm_index) - /// FMLS Ztied1.S, Zop2.S, Zop3.S[imm_index] + /// svfloat32_t svmls_lane[_f32](svfloat32_t op1, svfloat32_t op2, svfloat32_t op3, uint64_t imm_index) + /// FMLS Ztied1.S, Zop2.S, Zop3.S[imm_index] /// - public static unsafe Vector FusedMultiplySubtractBySelectedScalar(Vector minuend, Vector left, Vector right, [ConstantExpected] byte rightIndex) => FusedMultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); + public static Vector FusedMultiplySubtractBySelectedScalar(Vector minuend, Vector left, Vector right, [ConstantExpected] byte rightIndex) => FusedMultiplySubtractBySelectedScalar(minuend, left, right, rightIndex); // Negated multiply-subtract, minuend first /// - /// svfloat64_t svnmls[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) - /// svfloat64_t svnmls[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) - /// svfloat64_t svnmls[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) - /// FNMLS Ztied1.D, Pg/M, Zop2.D, Zop3.D + /// svfloat64_t svnmls[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) + /// svfloat64_t svnmls[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) + /// svfloat64_t svnmls[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3) + /// FNMLS Ztied1.D, Pg/M, Zop2.D, Zop3.D /// - public static unsafe Vector FusedMultiplySubtractNegated(Vector minuend, Vector left, Vector right) => FusedMultiplySubtractNegated(minuend, left, right); + public static Vector FusedMultiplySubtractNegated(Vector minuend, Vector left, Vector right) => FusedMultiplySubtractNegated(minuend, left, right); /// - /// svfloat32_t svnmls[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) - /// svfloat32_t svnmls[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) - /// svfloat32_t svnmls[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) - /// FNMLS Ztied1.S, Pg/M, Zop2.S, Zop3.S + /// svfloat32_t svnmls[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) + /// svfloat32_t svnmls[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) + /// svfloat32_t svnmls[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3) + /// FNMLS Ztied1.S, Pg/M, Zop2.S, Zop3.S /// - public static unsafe Vector FusedMultiplySubtractNegated(Vector minuend, Vector left, Vector right) => FusedMultiplySubtractNegated(minuend, left, right); + public static Vector FusedMultiplySubtractNegated(Vector minuend, Vector left, Vector right) => FusedMultiplySubtractNegated(minuend, left, right); // Prefetch halfwords /// - /// void svprfh_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) - /// PRFH op, Pg, [Xbase, Zindices.S, SXTW #1] + /// void svprfh_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) + /// PRFH op, Pg, [Xbase, Zindices.S, SXTW #1] /// public static unsafe void GatherPrefetch16Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch16Bit(mask, address, indices, prefetchType); /// - /// void svprfh_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) - /// PRFH op, Pg, [Xbase, Zindices.D, LSL #1] + /// void svprfh_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) + /// PRFH op, Pg, [Xbase, Zindices.D, LSL #1] /// public static unsafe void GatherPrefetch16Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch16Bit(mask, address, indices, prefetchType); - /// - /// void svprfh_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) - /// PRFH op, Pg, [Zbases.S, #0] - /// - public static unsafe void GatherPrefetch16Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch16Bit(mask, addresses, prefetchType); + // + // void svprfh_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) + // PRFH op, Pg, [Zbases.S, #0] + // + // Removed as per #103297 + // public static void GatherPrefetch16Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch16Bit(mask, addresses, prefetchType); /// - /// void svprfh_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) - /// PRFH op, Pg, [Xbase, Zindices.S, UXTW #1] + /// void svprfh_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) + /// PRFH op, Pg, [Xbase, Zindices.S, UXTW #1] /// public static unsafe void GatherPrefetch16Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch16Bit(mask, address, indices, prefetchType); /// - /// void svprfh_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) - /// PRFH op, Pg, [Zbases.D, #0] + /// void svprfh_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) + /// PRFH op, Pg, [Zbases.D, #0] /// - public static unsafe void GatherPrefetch16Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch16Bit(mask, addresses, prefetchType); + public static void GatherPrefetch16Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch16Bit(mask, addresses, prefetchType); /// - /// void svprfh_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) - /// PRFH op, Pg, [Xbase, Zindices.D, LSL #1] + /// void svprfh_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) + /// PRFH op, Pg, [Xbase, Zindices.D, LSL #1] /// public static unsafe void GatherPrefetch16Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch16Bit(mask, address, indices, prefetchType); /// - /// void svprfh_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) - /// PRFH op, Pg, [Xbase, Zindices.S, SXTW #1] + /// void svprfh_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) + /// PRFH op, Pg, [Xbase, Zindices.S, SXTW #1] /// public static unsafe void GatherPrefetch16Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch16Bit(mask, address, indices, prefetchType); /// - /// void svprfh_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) - /// PRFH op, Pg, [Xbase, Zindices.D, LSL #1] + /// void svprfh_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) + /// PRFH op, Pg, [Xbase, Zindices.D, LSL #1] /// public static unsafe void GatherPrefetch16Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch16Bit(mask, address, indices, prefetchType); - /// - /// void svprfh_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) - /// PRFH op, Pg, [Zbases.S, #0] - /// - public static unsafe void GatherPrefetch16Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch16Bit(mask, addresses, prefetchType); + // + // void svprfh_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) + // PRFH op, Pg, [Zbases.S, #0] + // + // Removed as per #103297 + // public static void GatherPrefetch16Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch16Bit(mask, addresses, prefetchType); /// - /// void svprfh_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) - /// PRFH op, Pg, [Xbase, Zindices.S, UXTW #1] + /// void svprfh_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) + /// PRFH op, Pg, [Xbase, Zindices.S, UXTW #1] /// public static unsafe void GatherPrefetch16Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch16Bit(mask, address, indices, prefetchType); /// - /// void svprfh_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) - /// PRFH op, Pg, [Zbases.D, #0] + /// void svprfh_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) + /// PRFH op, Pg, [Zbases.D, #0] /// - public static unsafe void GatherPrefetch16Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch16Bit(mask, addresses, prefetchType); + public static void GatherPrefetch16Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch16Bit(mask, addresses, prefetchType); /// - /// void svprfh_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) - /// PRFH op, Pg, [Xbase, Zindices.D, LSL #1] + /// void svprfh_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) + /// PRFH op, Pg, [Xbase, Zindices.D, LSL #1] /// public static unsafe void GatherPrefetch16Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch16Bit(mask, address, indices, prefetchType); @@ -3233,74 +3208,76 @@ internal Arm64() { } // Prefetch words /// - /// void svprfw_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) - /// PRFW op, Pg, [Xbase, Zindices.S, SXTW #2] + /// void svprfw_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) + /// PRFW op, Pg, [Xbase, Zindices.S, SXTW #2] /// public static unsafe void GatherPrefetch32Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch32Bit(mask, address, indices, prefetchType); /// - /// void svprfw_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) - /// PRFW op, Pg, [Xbase, Zindices.D, LSL #2] + /// void svprfw_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) + /// PRFW op, Pg, [Xbase, Zindices.D, LSL #2] /// public static unsafe void GatherPrefetch32Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch32Bit(mask, address, indices, prefetchType); - /// - /// void svprfw_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) - /// PRFW op, Pg, [Zbases.S, #0] - /// - public static unsafe void GatherPrefetch32Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch32Bit(mask, addresses, prefetchType); + // + // void svprfw_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) + // PRFW op, Pg, [Zbases.S, #0] + // + // Removed as per #103297 + // public static void GatherPrefetch32Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch32Bit(mask, addresses, prefetchType); /// - /// void svprfw_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) - /// PRFW op, Pg, [Xbase, Zindices.S, UXTW #2] + /// void svprfw_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) + /// PRFW op, Pg, [Xbase, Zindices.S, UXTW #2] /// public static unsafe void GatherPrefetch32Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch32Bit(mask, address, indices, prefetchType); /// - /// void svprfw_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) - /// PRFW op, Pg, [Zbases.D, #0] + /// void svprfw_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) + /// PRFW op, Pg, [Zbases.D, #0] /// - public static unsafe void GatherPrefetch32Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch32Bit(mask, addresses, prefetchType); + public static void GatherPrefetch32Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch32Bit(mask, addresses, prefetchType); /// - /// void svprfw_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) - /// PRFW op, Pg, [Xbase, Zindices.D, LSL #2] + /// void svprfw_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) + /// PRFW op, Pg, [Xbase, Zindices.D, LSL #2] /// public static unsafe void GatherPrefetch32Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch32Bit(mask, address, indices, prefetchType); /// - /// void svprfw_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) - /// PRFW op, Pg, [Xbase, Zindices.S, SXTW #2] + /// void svprfw_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) + /// PRFW op, Pg, [Xbase, Zindices.S, SXTW #2] /// public static unsafe void GatherPrefetch32Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch32Bit(mask, address, indices, prefetchType); /// - /// void svprfw_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) - /// PRFW op, Pg, [Xbase, Zindices.D, LSL #2] + /// void svprfw_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) + /// PRFW op, Pg, [Xbase, Zindices.D, LSL #2] /// public static unsafe void GatherPrefetch32Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch32Bit(mask, address, indices, prefetchType); - /// - /// void svprfw_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) - /// PRFW op, Pg, [Zbases.S, #0] - /// - public static unsafe void GatherPrefetch32Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch32Bit(mask, addresses, prefetchType); + // + // void svprfw_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) + // PRFW op, Pg, [Zbases.S, #0] + // + // Removed as per #103297 + // public static unsafe void GatherPrefetch32Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch32Bit(mask, addresses, prefetchType); /// - /// void svprfw_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) - /// PRFW op, Pg, [Xbase, Zindices.S, UXTW #2] + /// void svprfw_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) + /// PRFW op, Pg, [Xbase, Zindices.S, UXTW #2] /// public static unsafe void GatherPrefetch32Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch32Bit(mask, address, indices, prefetchType); /// - /// void svprfw_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) - /// PRFW op, Pg, [Zbases.D, #0] + /// void svprfw_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) + /// PRFW op, Pg, [Zbases.D, #0] /// - public static unsafe void GatherPrefetch32Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch32Bit(mask, addresses, prefetchType); + public static void GatherPrefetch32Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch32Bit(mask, addresses, prefetchType); /// - /// void svprfw_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) - /// PRFW op, Pg, [Xbase, Zindices.D, LSL #2] + /// void svprfw_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) + /// PRFW op, Pg, [Xbase, Zindices.D, LSL #2] /// public static unsafe void GatherPrefetch32Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch32Bit(mask, address, indices, prefetchType); @@ -3308,74 +3285,76 @@ internal Arm64() { } // Prefetch doublewords /// - /// void svprfd_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) - /// PRFD op, Pg, [Xbase, Zindices.S, SXTW #3] + /// void svprfd_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) + /// PRFD op, Pg, [Xbase, Zindices.S, SXTW #3] /// public static unsafe void GatherPrefetch64Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch64Bit(mask, address, indices, prefetchType); /// - /// void svprfd_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) - /// PRFD op, Pg, [Xbase, Zindices.D, LSL #3] + /// void svprfd_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) + /// PRFD op, Pg, [Xbase, Zindices.D, LSL #3] /// public static unsafe void GatherPrefetch64Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch64Bit(mask, address, indices, prefetchType); - /// - /// void svprfd_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) - /// PRFD op, Pg, [Zbases.S, #0] - /// - public static unsafe void GatherPrefetch64Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch64Bit(mask, addresses, prefetchType); + // + // void svprfd_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) + // PRFD op, Pg, [Zbases.S, #0] + // + // Removed as per #103297 + // public static unsafe void GatherPrefetch64Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch64Bit(mask, addresses, prefetchType); /// - /// void svprfd_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) - /// PRFD op, Pg, [Xbase, Zindices.S, UXTW #3] + /// void svprfd_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) + /// PRFD op, Pg, [Xbase, Zindices.S, UXTW #3] /// public static unsafe void GatherPrefetch64Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch64Bit(mask, address, indices, prefetchType); /// - /// void svprfd_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) - /// PRFD op, Pg, [Zbases.D, #0] + /// void svprfd_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) + /// PRFD op, Pg, [Zbases.D, #0] /// - public static unsafe void GatherPrefetch64Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch64Bit(mask, addresses, prefetchType); + public static void GatherPrefetch64Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch64Bit(mask, addresses, prefetchType); /// - /// void svprfd_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) - /// PRFD op, Pg, [Xbase, Zindices.D, LSL #3] + /// void svprfd_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) + /// PRFD op, Pg, [Xbase, Zindices.D, LSL #3] /// public static unsafe void GatherPrefetch64Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch64Bit(mask, address, indices, prefetchType); /// - /// void svprfd_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) - /// PRFD op, Pg, [Xbase, Zindices.S, SXTW #3] + /// void svprfd_gather_[s32]index(svbool_t pg, const void *base, svint32_t indices, enum svprfop op) + /// PRFD op, Pg, [Xbase, Zindices.S, SXTW #3] /// public static unsafe void GatherPrefetch64Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch64Bit(mask, address, indices, prefetchType); /// - /// void svprfd_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) - /// PRFD op, Pg, [Xbase, Zindices.D, LSL #3] + /// void svprfd_gather_[s64]index(svbool_t pg, const void *base, svint64_t indices, enum svprfop op) + /// PRFD op, Pg, [Xbase, Zindices.D, LSL #3] /// public static unsafe void GatherPrefetch64Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch64Bit(mask, address, indices, prefetchType); - /// - /// void svprfd_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) - /// PRFD op, Pg, [Zbases.S, #0] - /// - public static unsafe void GatherPrefetch64Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch64Bit(mask, addresses, prefetchType); + // + // void svprfd_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) + // PRFD op, Pg, [Zbases.S, #0] + // + // Removed as per #103297 + // public static unsafe void GatherPrefetch64Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch64Bit(mask, addresses, prefetchType); /// - /// void svprfd_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) - /// PRFD op, Pg, [Xbase, Zindices.S, UXTW #3] + /// void svprfd_gather_[u32]index(svbool_t pg, const void *base, svuint32_t indices, enum svprfop op) + /// PRFD op, Pg, [Xbase, Zindices.S, UXTW #3] /// public static unsafe void GatherPrefetch64Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch64Bit(mask, address, indices, prefetchType); /// - /// void svprfd_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) - /// PRFD op, Pg, [Zbases.D, #0] + /// void svprfd_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) + /// PRFD op, Pg, [Zbases.D, #0] /// - public static unsafe void GatherPrefetch64Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch64Bit(mask, addresses, prefetchType); + public static void GatherPrefetch64Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch64Bit(mask, addresses, prefetchType); /// - /// void svprfd_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) - /// PRFD op, Pg, [Xbase, Zindices.D, LSL #3] + /// void svprfd_gather_[u64]index(svbool_t pg, const void *base, svuint64_t indices, enum svprfop op) + /// PRFD op, Pg, [Xbase, Zindices.D, LSL #3] /// public static unsafe void GatherPrefetch64Bit(Vector mask, void* address, Vector indices, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch64Bit(mask, address, indices, prefetchType); @@ -3383,74 +3362,76 @@ internal Arm64() { } // Prefetch bytes /// - /// void svprfb_gather_[s32]offset(svbool_t pg, const void *base, svint32_t offsets, enum svprfop op) - /// PRFB op, Pg, [Xbase, Zoffsets.S, SXTW] + /// void svprfb_gather_[s32]offset(svbool_t pg, const void *base, svint32_t offsets, enum svprfop op) + /// PRFB op, Pg, [Xbase, Zoffsets.S, SXTW] /// public static unsafe void GatherPrefetch8Bit(Vector mask, void* address, Vector offsets, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch8Bit(mask, address, offsets, prefetchType); /// - /// void svprfb_gather_[s64]offset(svbool_t pg, const void *base, svint64_t offsets, enum svprfop op) - /// PRFB op, Pg, [Xbase, Zoffsets.D] + /// void svprfb_gather_[s64]offset(svbool_t pg, const void *base, svint64_t offsets, enum svprfop op) + /// PRFB op, Pg, [Xbase, Zoffsets.D] /// public static unsafe void GatherPrefetch8Bit(Vector mask, void* address, Vector offsets, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch8Bit(mask, address, offsets, prefetchType); - /// - /// void svprfb_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) - /// PRFB op, Pg, [Zbases.S, #0] - /// - public static unsafe void GatherPrefetch8Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch8Bit(mask, addresses, prefetchType); + // + // void svprfb_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) + // PRFB op, Pg, [Zbases.S, #0] + // + // Removed as per #103297 + // public static unsafe void GatherPrefetch8Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch8Bit(mask, addresses, prefetchType); /// - /// void svprfb_gather_[u32]offset(svbool_t pg, const void *base, svuint32_t offsets, enum svprfop op) - /// PRFB op, Pg, [Xbase, Zoffsets.S, UXTW] + /// void svprfb_gather_[u32]offset(svbool_t pg, const void *base, svuint32_t offsets, enum svprfop op) + /// PRFB op, Pg, [Xbase, Zoffsets.S, UXTW] /// public static unsafe void GatherPrefetch8Bit(Vector mask, void* address, Vector offsets, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch8Bit(mask, address, offsets, prefetchType); /// - /// void svprfb_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) - /// PRFB op, Pg, [Zbases.D, #0] + /// void svprfb_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) + /// PRFB op, Pg, [Zbases.D, #0] /// - public static unsafe void GatherPrefetch8Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch8Bit(mask, addresses, prefetchType); + public static void GatherPrefetch8Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch8Bit(mask, addresses, prefetchType); /// - /// void svprfb_gather_[u64]offset(svbool_t pg, const void *base, svuint64_t offsets, enum svprfop op) - /// PRFB op, Pg, [Xbase, Zoffsets.D] + /// void svprfb_gather_[u64]offset(svbool_t pg, const void *base, svuint64_t offsets, enum svprfop op) + /// PRFB op, Pg, [Xbase, Zoffsets.D] /// public static unsafe void GatherPrefetch8Bit(Vector mask, void* address, Vector offsets, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch8Bit(mask, address, offsets, prefetchType); /// - /// void svprfb_gather_[s32]offset(svbool_t pg, const void *base, svint32_t offsets, enum svprfop op) - /// PRFB op, Pg, [Xbase, Zoffsets.S, SXTW] + /// void svprfb_gather_[s32]offset(svbool_t pg, const void *base, svint32_t offsets, enum svprfop op) + /// PRFB op, Pg, [Xbase, Zoffsets.S, SXTW] /// public static unsafe void GatherPrefetch8Bit(Vector mask, void* address, Vector offsets, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch8Bit(mask, address, offsets, prefetchType); /// - /// void svprfb_gather_[s64]offset(svbool_t pg, const void *base, svint64_t offsets, enum svprfop op) - /// PRFB op, Pg, [Xbase, Zoffsets.D] + /// void svprfb_gather_[s64]offset(svbool_t pg, const void *base, svint64_t offsets, enum svprfop op) + /// PRFB op, Pg, [Xbase, Zoffsets.D] /// public static unsafe void GatherPrefetch8Bit(Vector mask, void* address, Vector offsets, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch8Bit(mask, address, offsets, prefetchType); - /// - /// void svprfb_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) - /// PRFB op, Pg, [Zbases.S, #0] - /// - public static unsafe void GatherPrefetch8Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch8Bit(mask, addresses, prefetchType); + // + // void svprfb_gather[_u32base](svbool_t pg, svuint32_t bases, enum svprfop op) + // PRFB op, Pg, [Zbases.S, #0] + // + // Removed as per #103297 + // public static unsafe void GatherPrefetch8Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch8Bit(mask, addresses, prefetchType); /// - /// void svprfb_gather_[u32]offset(svbool_t pg, const void *base, svuint32_t offsets, enum svprfop op) - /// PRFB op, Pg, [Xbase, Zoffsets.S, UXTW] + /// void svprfb_gather_[u32]offset(svbool_t pg, const void *base, svuint32_t offsets, enum svprfop op) + /// PRFB op, Pg, [Xbase, Zoffsets.S, UXTW] /// public static unsafe void GatherPrefetch8Bit(Vector mask, void* address, Vector offsets, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch8Bit(mask, address, offsets, prefetchType); /// - /// void svprfb_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) - /// PRFB op, Pg, [Zbases.D, #0] + /// void svprfb_gather[_u64base](svbool_t pg, svuint64_t bases, enum svprfop op) + /// PRFB op, Pg, [Zbases.D, #0] /// - public static unsafe void GatherPrefetch8Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch8Bit(mask, addresses, prefetchType); + public static void GatherPrefetch8Bit(Vector mask, Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch8Bit(mask, addresses, prefetchType); /// - /// void svprfb_gather_[u64]offset(svbool_t pg, const void *base, svuint64_t offsets, enum svprfop op) - /// PRFB op, Pg, [Xbase, Zoffsets.D] + /// void svprfb_gather_[u64]offset(svbool_t pg, const void *base, svuint64_t offsets, enum svprfop op) + /// PRFB op, Pg, [Xbase, Zoffsets.D] /// public static unsafe void GatherPrefetch8Bit(Vector mask, void* address, Vector offsets, [ConstantExpected] SvePrefetchType prefetchType) => GatherPrefetch8Bit(mask, address, offsets, prefetchType); @@ -3458,26 +3439,26 @@ internal Arm64() { } // Unextended load /// - /// svfloat64_t svld1_gather_[s64]index[_f64](svbool_t pg, const float64_t *base, svint64_t indices) - /// LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] + /// svfloat64_t svld1_gather_[s64]index[_f64](svbool_t pg, const float64_t *base, svint64_t indices) + /// LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] /// public static unsafe Vector GatherVector(Vector mask, double* address, Vector indices) => GatherVector(mask, address, indices); /// - /// svfloat64_t svld1_gather[_u64base]_f64(svbool_t pg, svuint64_t bases) - /// LD1D Zresult.D, Pg/Z, [Zbases.D, #0] + /// svfloat64_t svld1_gather[_u64base]_f64(svbool_t pg, svuint64_t bases) + /// LD1D Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVector(Vector mask, Vector addresses) => GatherVector(mask, addresses); + public static Vector GatherVector(Vector mask, Vector addresses) => GatherVector(mask, addresses); /// - /// svfloat64_t svld1_gather_[u64]index[_f64](svbool_t pg, const float64_t *base, svuint64_t indices) - /// LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] + /// svfloat64_t svld1_gather_[u64]index[_f64](svbool_t pg, const float64_t *base, svuint64_t indices) + /// LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] /// public static unsafe Vector GatherVector(Vector mask, double* address, Vector indices) => GatherVector(mask, address, indices); /// - /// svint32_t svld1_gather_[s32]index[_s32](svbool_t pg, const int32_t *base, svint32_t indices) - /// LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2] + /// svint32_t svld1_gather_[s32]index[_s32](svbool_t pg, const int32_t *base, svint32_t indices) + /// LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2] /// public static unsafe Vector GatherVector(Vector mask, int* address, Vector indices) => GatherVector(mask, address, indices); @@ -3486,35 +3467,35 @@ internal Arm64() { } // LD1W Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVector(Vector mask, Vector addresses) => GatherVector(mask, addresses); + // public static Vector GatherVector(Vector mask, Vector addresses) => GatherVector(mask, addresses); /// - /// svint32_t svld1_gather_[u32]index[_s32](svbool_t pg, const int32_t *base, svuint32_t indices) - /// LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2] + /// svint32_t svld1_gather_[u32]index[_s32](svbool_t pg, const int32_t *base, svuint32_t indices) + /// LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2] /// public static unsafe Vector GatherVector(Vector mask, int* address, Vector indices) => GatherVector(mask, address, indices); /// - /// svint64_t svld1_gather_[s64]index[_s64](svbool_t pg, const int64_t *base, svint64_t indices) - /// LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] + /// svint64_t svld1_gather_[s64]index[_s64](svbool_t pg, const int64_t *base, svint64_t indices) + /// LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] /// public static unsafe Vector GatherVector(Vector mask, long* address, Vector indices) => GatherVector(mask, address, indices); /// - /// svint64_t svld1_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) - /// LD1D Zresult.D, Pg/Z, [Zbases.D, #0] + /// svint64_t svld1_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LD1D Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVector(Vector mask, Vector addresses) => GatherVector(mask, addresses); + public static Vector GatherVector(Vector mask, Vector addresses) => GatherVector(mask, addresses); /// - /// svint64_t svld1_gather_[u64]index[_s64](svbool_t pg, const int64_t *base, svuint64_t indices) - /// LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] + /// svint64_t svld1_gather_[u64]index[_s64](svbool_t pg, const int64_t *base, svuint64_t indices) + /// LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] /// public static unsafe Vector GatherVector(Vector mask, long* address, Vector indices) => GatherVector(mask, address, indices); /// - /// svfloat32_t svld1_gather_[s32]index[_f32](svbool_t pg, const float32_t *base, svint32_t indices) - /// LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2] + /// svfloat32_t svld1_gather_[s32]index[_f32](svbool_t pg, const float32_t *base, svint32_t indices) + /// LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2] /// public static unsafe Vector GatherVector(Vector mask, float* address, Vector indices) => GatherVector(mask, address, indices); @@ -3523,17 +3504,17 @@ internal Arm64() { } // LD1W Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVector(Vector mask, Vector addresses) => GatherVector(mask, addresses); + // public static Vector GatherVector(Vector mask, Vector addresses) => GatherVector(mask, addresses); /// - /// svfloat32_t svld1_gather_[u32]index[_f32](svbool_t pg, const float32_t *base, svuint32_t indices) - /// LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2] + /// svfloat32_t svld1_gather_[u32]index[_f32](svbool_t pg, const float32_t *base, svuint32_t indices) + /// LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2] /// public static unsafe Vector GatherVector(Vector mask, float* address, Vector indices) => GatherVector(mask, address, indices); /// - /// svuint32_t svld1_gather_[s32]index[_u32](svbool_t pg, const uint32_t *base, svint32_t indices) - /// LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2] + /// svuint32_t svld1_gather_[s32]index[_u32](svbool_t pg, const uint32_t *base, svint32_t indices) + /// LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2] /// public static unsafe Vector GatherVector(Vector mask, uint* address, Vector indices) => GatherVector(mask, address, indices); @@ -3542,29 +3523,29 @@ internal Arm64() { } // LD1W Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVector(Vector mask, Vector addresses) => GatherVector(mask, addresses); + // public static Vector GatherVector(Vector mask, Vector addresses) => GatherVector(mask, addresses); /// - /// svuint32_t svld1_gather_[u32]index[_u32](svbool_t pg, const uint32_t *base, svuint32_t indices) - /// LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2] + /// svuint32_t svld1_gather_[u32]index[_u32](svbool_t pg, const uint32_t *base, svuint32_t indices) + /// LD1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2] /// public static unsafe Vector GatherVector(Vector mask, uint* address, Vector indices) => GatherVector(mask, address, indices); /// - /// svuint64_t svld1_gather_[s64]index[_u64](svbool_t pg, const uint64_t *base, svint64_t indices) - /// LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] + /// svuint64_t svld1_gather_[s64]index[_u64](svbool_t pg, const uint64_t *base, svint64_t indices) + /// LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] /// public static unsafe Vector GatherVector(Vector mask, ulong* address, Vector indices) => GatherVector(mask, address, indices); /// - /// svuint64_t svld1_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) - /// LD1D Zresult.D, Pg/Z, [Zbases.D, #0] + /// svuint64_t svld1_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LD1D Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVector(Vector mask, Vector addresses) => GatherVector(mask, addresses); + public static Vector GatherVector(Vector mask, Vector addresses) => GatherVector(mask, addresses); /// - /// svuint64_t svld1_gather_[u64]index[_u64](svbool_t pg, const uint64_t *base, svuint64_t indices) - /// LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] + /// svuint64_t svld1_gather_[u64]index[_u64](svbool_t pg, const uint64_t *base, svuint64_t indices) + /// LD1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] /// public static unsafe Vector GatherVector(Vector mask, ulong* address, Vector indices) => GatherVector(mask, address, indices); @@ -3572,8 +3553,8 @@ internal Arm64() { } // Load 8-bit data and zero-extend /// - /// svint32_t svld1ub_gather_[s32]offset_s32(svbool_t pg, const uint8_t *base, svint32_t offsets) - /// LD1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// svint32_t svld1ub_gather_[s32]offset_s32(svbool_t pg, const uint8_t *base, svint32_t offsets) + /// LD1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] /// public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, byte* address, Vector indices) => GatherVectorByteZeroExtend(mask, address, indices); @@ -3582,35 +3563,35 @@ internal Arm64() { } // LD1B Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, Vector addresses) => GatherVectorByteZeroExtend(mask, addresses); + // public static Vector GatherVectorByteZeroExtend(Vector mask, Vector addresses) => GatherVectorByteZeroExtend(mask, addresses); /// - /// svint32_t svld1ub_gather_[u32]offset_s32(svbool_t pg, const uint8_t *base, svuint32_t offsets) - /// LD1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// svint32_t svld1ub_gather_[u32]offset_s32(svbool_t pg, const uint8_t *base, svuint32_t offsets) + /// LD1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] /// public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, byte* address, Vector indices) => GatherVectorByteZeroExtend(mask, address, indices); /// - /// svint64_t svld1ub_gather_[s64]offset_s64(svbool_t pg, const uint8_t *base, svint64_t offsets) - /// LD1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1ub_gather_[s64]offset_s64(svbool_t pg, const uint8_t *base, svint64_t offsets) + /// LD1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, byte* address, Vector indices) => GatherVectorByteZeroExtend(mask, address, indices); /// - /// svint64_t svld1ub_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) - /// LD1B Zresult.D, Pg/Z, [Zbases.D, #0] + /// svint64_t svld1ub_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LD1B Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, Vector addresses) => GatherVectorByteZeroExtend(mask, addresses); + public static Vector GatherVectorByteZeroExtend(Vector mask, Vector addresses) => GatherVectorByteZeroExtend(mask, addresses); /// - /// svint64_t svld1ub_gather_[u64]offset_s64(svbool_t pg, const uint8_t *base, svuint64_t offsets) - /// LD1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1ub_gather_[u64]offset_s64(svbool_t pg, const uint8_t *base, svuint64_t offsets) + /// LD1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, byte* address, Vector indices) => GatherVectorByteZeroExtend(mask, address, indices); /// - /// svuint32_t svld1ub_gather_[s32]offset_u32(svbool_t pg, const uint8_t *base, svint32_t offsets) - /// LD1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// svuint32_t svld1ub_gather_[s32]offset_u32(svbool_t pg, const uint8_t *base, svint32_t offsets) + /// LD1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] /// public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, byte* address, Vector indices) => GatherVectorByteZeroExtend(mask, address, indices); @@ -3619,50 +3600,127 @@ internal Arm64() { } // LD1B Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, Vector addresses) => GatherVectorByteZeroExtend(mask, addresses); + // public static Vector GatherVectorByteZeroExtend(Vector mask, Vector addresses) => GatherVectorByteZeroExtend(mask, addresses); /// - /// svuint32_t svld1ub_gather_[u32]offset_u32(svbool_t pg, const uint8_t *base, svuint32_t offsets) - /// LD1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// svuint32_t svld1ub_gather_[u32]offset_u32(svbool_t pg, const uint8_t *base, svuint32_t offsets) + /// LD1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] /// public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, byte* address, Vector indices) => GatherVectorByteZeroExtend(mask, address, indices); /// - /// svuint64_t svld1ub_gather_[s64]offset_u64(svbool_t pg, const uint8_t *base, svint64_t offsets) - /// LD1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1ub_gather_[s64]offset_u64(svbool_t pg, const uint8_t *base, svint64_t offsets) + /// LD1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, byte* address, Vector indices) => GatherVectorByteZeroExtend(mask, address, indices); /// - /// svuint64_t svld1ub_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) - /// LD1B Zresult.D, Pg/Z, [Zbases.D, #0] + /// svuint64_t svld1ub_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LD1B Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, Vector addresses) => GatherVectorByteZeroExtend(mask, addresses); + public static Vector GatherVectorByteZeroExtend(Vector mask, Vector addresses) => GatherVectorByteZeroExtend(mask, addresses); /// - /// svuint64_t svld1ub_gather_[u64]offset_u64(svbool_t pg, const uint8_t *base, svuint64_t offsets) - /// LD1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1ub_gather_[u64]offset_u64(svbool_t pg, const uint8_t *base, svuint64_t offsets) + /// LD1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorByteZeroExtend(Vector mask, byte* address, Vector indices) => GatherVectorByteZeroExtend(mask, address, indices); - // Unextended load, first-faulting + // Load 8-bit data and zero-extend, first-faulting + + /// + /// svint32_t svldff1ub_gather_[s32]offset_s32(svbool_t pg, const uint8_t *base, svint32_t offsets) + /// LDFF1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// + public static unsafe Vector GatherVectorByteZeroExtendFirstFaulting(Vector mask, byte* address, Vector offsets) => GatherVectorByteZeroExtendFirstFaulting(mask, address, offsets); + + // + // svint32_t svldff1ub_gather[_u32base]_s32(svbool_t pg, svuint32_t bases) + // LDFF1B Zresult.S, Pg/Z, [Zbases.S, #0] + // + // Removed as per #103297 + // public static Vector GatherVectorByteZeroExtendFirstFaulting(Vector mask, Vector addresses) => GatherVectorByteZeroExtendFirstFaulting(mask, addresses); + + /// + /// svint32_t svldff1ub_gather_[u32]offset_s32(svbool_t pg, const uint8_t *base, svuint32_t offsets) + /// LDFF1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// + public static unsafe Vector GatherVectorByteZeroExtendFirstFaulting(Vector mask, byte* address, Vector offsets) => GatherVectorByteZeroExtendFirstFaulting(mask, address, offsets); /// - /// svfloat64_t svldff1_gather_[s64]index[_f64](svbool_t pg, const float64_t *base, svint64_t indices) - /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] + /// svint64_t svldff1ub_gather_[s64]offset_s64(svbool_t pg, const uint8_t *base, svint64_t offsets) + /// LDFF1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorByteZeroExtendFirstFaulting(Vector mask, byte* address, Vector offsets) => GatherVectorByteZeroExtendFirstFaulting(mask, address, offsets); + + /// + /// svint64_t svldff1ub_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LDFF1B Zresult.D, Pg/Z, [Zbases.D, #0] + /// + public static Vector GatherVectorByteZeroExtendFirstFaulting(Vector mask, Vector addresses) => GatherVectorByteZeroExtendFirstFaulting(mask, addresses); + + /// + /// svint64_t svldff1ub_gather_[u64]offset_s64(svbool_t pg, const uint8_t *base, svuint64_t offsets) + /// LDFF1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorByteZeroExtendFirstFaulting(Vector mask, byte* address, Vector offsets) => GatherVectorByteZeroExtendFirstFaulting(mask, address, offsets); + + /// + /// svuint32_t svldff1ub_gather_[s32]offset_u32(svbool_t pg, const uint8_t *base, svint32_t offsets) + /// LDFF1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// + public static unsafe Vector GatherVectorByteZeroExtendFirstFaulting(Vector mask, byte* address, Vector offsets) => GatherVectorByteZeroExtendFirstFaulting(mask, address, offsets); + + // + // svuint32_t svldff1ub_gather[_u32base]_u32(svbool_t pg, svuint32_t bases) + // LDFF1B Zresult.S, Pg/Z, [Zbases.S, #0] + // + // Removed as per #103297 + // public static Vector GatherVectorByteZeroExtendFirstFaulting(Vector mask, Vector addresses) => GatherVectorByteZeroExtendFirstFaulting(mask, addresses); + + /// + /// svuint32_t svldff1ub_gather_[u32]offset_u32(svbool_t pg, const uint8_t *base, svuint32_t offsets) + /// LDFF1B Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// + public static unsafe Vector GatherVectorByteZeroExtendFirstFaulting(Vector mask, byte* address, Vector offsets) => GatherVectorByteZeroExtendFirstFaulting(mask, address, offsets); + + /// + /// svuint64_t svldff1ub_gather_[s64]offset_u64(svbool_t pg, const uint8_t *base, svint64_t offsets) + /// LDFF1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorByteZeroExtendFirstFaulting(Vector mask, byte* address, Vector offsets) => GatherVectorByteZeroExtendFirstFaulting(mask, address, offsets); + + /// + /// svuint64_t svldff1ub_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LDFF1B Zresult.D, Pg/Z, [Zbases.D, #0] + /// + public static Vector GatherVectorByteZeroExtendFirstFaulting(Vector mask, Vector addresses) => GatherVectorByteZeroExtendFirstFaulting(mask, addresses); + + /// + /// svuint64_t svldff1ub_gather_[u64]offset_u64(svbool_t pg, const uint8_t *base, svuint64_t offsets) + /// LDFF1B Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorByteZeroExtendFirstFaulting(Vector mask, byte* address, Vector offsets) => GatherVectorByteZeroExtendFirstFaulting(mask, address, offsets); + + + // Unextended load, first-faulting + + /// + /// svfloat64_t svldff1_gather_[s64]index[_f64](svbool_t pg, const float64_t *base, svint64_t indices) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] /// public static unsafe Vector GatherVectorFirstFaulting(Vector mask, double* address, Vector indices) => GatherVectorFirstFaulting(mask, address, indices); /// - /// svfloat64_t svldff1_gather[_u64base]_f64(svbool_t pg, svuint64_t bases) - /// LDFF1D Zresult.D, Pg/Z, [Zbases.D, #0] + /// svfloat64_t svldff1_gather[_u64base]_f64(svbool_t pg, svuint64_t bases) + /// LDFF1D Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorFirstFaulting(Vector mask, Vector addresses) => GatherVectorFirstFaulting(mask, addresses); + public static Vector GatherVectorFirstFaulting(Vector mask, Vector addresses) => GatherVectorFirstFaulting(mask, addresses); /// - /// svfloat64_t svldff1_gather_[u64]index[_f64](svbool_t pg, const float64_t *base, svuint64_t indices) - /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] + /// svfloat64_t svldff1_gather_[u64]index[_f64](svbool_t pg, const float64_t *base, svuint64_t indices) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] /// public static unsafe Vector GatherVectorFirstFaulting(Vector mask, double* address, Vector indices) => GatherVectorFirstFaulting(mask, address, indices); @@ -3671,41 +3729,41 @@ internal Arm64() { } // LDFF1W Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorFirstFaulting(Vector mask, Vector addresses) => GatherVectorFirstFaulting(mask, addresses); + // public static Vector GatherVectorFirstFaulting(Vector mask, Vector addresses) => GatherVectorFirstFaulting(mask, addresses); /// - /// svint32_t svldff1_gather_[s32]index[_s32](svbool_t pg, const int32_t *base, svint32_t indices) - /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2] + /// svint32_t svldff1_gather_[s32]index[_s32](svbool_t pg, const int32_t *base, svint32_t indices) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2] /// public static unsafe Vector GatherVectorFirstFaulting(Vector mask, int* address, Vector indices) => GatherVectorFirstFaulting(mask, address, indices); /// - /// svint32_t svldff1_gather_[u32]index[_s32](svbool_t pg, const int32_t *base, svuint32_t indices) - /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2] + /// svint32_t svldff1_gather_[u32]index[_s32](svbool_t pg, const int32_t *base, svuint32_t indices) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2] /// public static unsafe Vector GatherVectorFirstFaulting(Vector mask, int* address, Vector indices) => GatherVectorFirstFaulting(mask, address, indices); /// - /// svint64_t svldff1_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) - /// LDFF1D Zresult.D, Pg/Z, [Zbases.D, #0] + /// svint64_t svldff1_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LDFF1D Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorFirstFaulting(Vector mask, Vector addresses) => GatherVectorFirstFaulting(mask, addresses); + public static Vector GatherVectorFirstFaulting(Vector mask, Vector addresses) => GatherVectorFirstFaulting(mask, addresses); /// - /// svint64_t svldff1_gather_[s64]index[_s64](svbool_t pg, const int64_t *base, svint64_t indices) - /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] + /// svint64_t svldff1_gather_[s64]index[_s64](svbool_t pg, const int64_t *base, svint64_t indices) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] /// public static unsafe Vector GatherVectorFirstFaulting(Vector mask, long* address, Vector indices) => GatherVectorFirstFaulting(mask, address, indices); /// - /// svint64_t svldff1_gather_[u64]index[_s64](svbool_t pg, const int64_t *base, svuint64_t indices) - /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] + /// svint64_t svldff1_gather_[u64]index[_s64](svbool_t pg, const int64_t *base, svuint64_t indices) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] /// public static unsafe Vector GatherVectorFirstFaulting(Vector mask, long* address, Vector indices) => GatherVectorFirstFaulting(mask, address, indices); /// - /// svfloat32_t svldff1_gather_[s32]index[_f32](svbool_t pg, const float32_t *base, svint32_t indices) - /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2] + /// svfloat32_t svldff1_gather_[s32]index[_f32](svbool_t pg, const float32_t *base, svint32_t indices) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2] /// public static unsafe Vector GatherVectorFirstFaulting(Vector mask, float* address, Vector indices) => GatherVectorFirstFaulting(mask, address, indices); @@ -3714,11 +3772,11 @@ internal Arm64() { } // LDFF1W Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorFirstFaulting(Vector mask, Vector addresses) => GatherVectorFirstFaulting(mask, addresses); + // public static Vector GatherVectorFirstFaulting(Vector mask, Vector addresses) => GatherVectorFirstFaulting(mask, addresses); /// - /// svfloat32_t svldff1_gather_[u32]index[_f32](svbool_t pg, const float32_t *base, svuint32_t indices) - /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2] + /// svfloat32_t svldff1_gather_[u32]index[_f32](svbool_t pg, const float32_t *base, svuint32_t indices) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2] /// public static unsafe Vector GatherVectorFirstFaulting(Vector mask, float* address, Vector indices) => GatherVectorFirstFaulting(mask, address, indices); @@ -3727,44 +3785,44 @@ internal Arm64() { } // LDFF1W Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorFirstFaulting(Vector mask, Vector addresses) => GatherVectorFirstFaulting(mask, addresses); + // public static Vector GatherVectorFirstFaulting(Vector mask, Vector addresses) => GatherVectorFirstFaulting(mask, addresses); /// - /// svuint32_t svldff1_gather_[s32]index[_u32](svbool_t pg, const uint32_t *base, svint32_t indices) - /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2] + /// svuint32_t svldff1_gather_[s32]index[_u32](svbool_t pg, const uint32_t *base, svint32_t indices) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #2] /// public static unsafe Vector GatherVectorFirstFaulting(Vector mask, uint* address, Vector indices) => GatherVectorFirstFaulting(mask, address, indices); /// - /// svuint32_t svldff1_gather_[u32]index[_u32](svbool_t pg, const uint32_t *base, svuint32_t indices) - /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2] + /// svuint32_t svldff1_gather_[u32]index[_u32](svbool_t pg, const uint32_t *base, svuint32_t indices) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #2] /// public static unsafe Vector GatherVectorFirstFaulting(Vector mask, uint* address, Vector indices) => GatherVectorFirstFaulting(mask, address, indices); /// - /// svuint64_t svldff1_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) - /// LDFF1D Zresult.D, Pg/Z, [Zbases.D, #0] + /// svuint64_t svldff1_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LDFF1D Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorFirstFaulting(Vector mask, Vector addresses) => GatherVectorFirstFaulting(mask, addresses); + public static Vector GatherVectorFirstFaulting(Vector mask, Vector addresses) => GatherVectorFirstFaulting(mask, addresses); /// - /// svuint64_t svldff1_gather_[s64]index[_u64](svbool_t pg, const uint64_t *base, svint64_t indices) - /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] + /// svuint64_t svldff1_gather_[s64]index[_u64](svbool_t pg, const uint64_t *base, svint64_t indices) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] /// public static unsafe Vector GatherVectorFirstFaulting(Vector mask, ulong* address, Vector indices) => GatherVectorFirstFaulting(mask, address, indices); /// - /// svuint64_t svldff1_gather_[u64]index[_u64](svbool_t pg, const uint64_t *base, svuint64_t indices) - /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] + /// svuint64_t svldff1_gather_[u64]index[_u64](svbool_t pg, const uint64_t *base, svuint64_t indices) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #3] /// public static unsafe Vector GatherVectorFirstFaulting(Vector mask, ulong* address, Vector indices) => GatherVectorFirstFaulting(mask, address, indices); - // Load 16-bit data and sign-extend + // Load 16-bit data and sign-extend /// - /// svint32_t svld1sh_gather_[s32]index_s32(svbool_t pg, const int16_t *base, svint32_t indices) - /// LD1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1] + /// svint32_t svld1sh_gather_[s32]index_s32(svbool_t pg, const int16_t *base, svint32_t indices) + /// LD1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1] /// public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, short* address, Vector indices) => GatherVectorInt16SignExtend(mask, address, indices); @@ -3773,35 +3831,35 @@ internal Arm64() { } // LD1SH Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, Vector addresses) => GatherVectorInt16SignExtend(mask, addresses); + // public static Vector GatherVectorInt16SignExtend(Vector mask, Vector addresses) => GatherVectorInt16SignExtend(mask, addresses); /// - /// svint32_t svld1sh_gather_[u32]index_s32(svbool_t pg, const int16_t *base, svuint32_t indices) - /// LD1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1] + /// svint32_t svld1sh_gather_[u32]index_s32(svbool_t pg, const int16_t *base, svuint32_t indices) + /// LD1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1] /// public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, short* address, Vector indices) => GatherVectorInt16SignExtend(mask, address, indices); /// - /// svint64_t svld1sh_gather_[s64]index_s64(svbool_t pg, const int16_t *base, svint64_t indices) - /// LD1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// svint64_t svld1sh_gather_[s64]index_s64(svbool_t pg, const int16_t *base, svint64_t indices) + /// LD1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] /// public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, short* address, Vector indices) => GatherVectorInt16SignExtend(mask, address, indices); /// - /// svint64_t svld1sh_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) - /// LD1SH Zresult.D, Pg/Z, [Zbases.D, #0] + /// svint64_t svld1sh_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LD1SH Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, Vector addresses) => GatherVectorInt16SignExtend(mask, addresses); + public static Vector GatherVectorInt16SignExtend(Vector mask, Vector addresses) => GatherVectorInt16SignExtend(mask, addresses); /// - /// svint64_t svld1sh_gather_[u64]index_s64(svbool_t pg, const int16_t *base, svuint64_t indices) - /// LD1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// svint64_t svld1sh_gather_[u64]index_s64(svbool_t pg, const int16_t *base, svuint64_t indices) + /// LD1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] /// public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, short* address, Vector indices) => GatherVectorInt16SignExtend(mask, address, indices); /// - /// svuint32_t svld1sh_gather_[s32]index_u32(svbool_t pg, const int16_t *base, svint32_t indices) - /// LD1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1] + /// svuint32_t svld1sh_gather_[s32]index_u32(svbool_t pg, const int16_t *base, svint32_t indices) + /// LD1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1] /// public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, short* address, Vector indices) => GatherVectorInt16SignExtend(mask, address, indices); @@ -3810,155 +3868,349 @@ internal Arm64() { } // LD1SH Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, Vector addresses) => GatherVectorInt16SignExtend(mask, addresses); + // public static Vector GatherVectorInt16SignExtend(Vector mask, Vector addresses) => GatherVectorInt16SignExtend(mask, addresses); /// - /// svuint32_t svld1sh_gather_[u32]index_u32(svbool_t pg, const int16_t *base, svuint32_t indices) - /// LD1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1] + /// svuint32_t svld1sh_gather_[u32]index_u32(svbool_t pg, const int16_t *base, svuint32_t indices) + /// LD1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1] /// public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, short* address, Vector indices) => GatherVectorInt16SignExtend(mask, address, indices); /// - /// svuint64_t svld1sh_gather_[s64]index_u64(svbool_t pg, const int16_t *base, svint64_t indices) - /// LD1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// svuint64_t svld1sh_gather_[s64]index_u64(svbool_t pg, const int16_t *base, svint64_t indices) + /// LD1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] /// public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, short* address, Vector indices) => GatherVectorInt16SignExtend(mask, address, indices); /// - /// svuint64_t svld1sh_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) - /// LD1SH Zresult.D, Pg/Z, [Zbases.D, #0] + /// svuint64_t svld1sh_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LD1SH Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, Vector addresses) => GatherVectorInt16SignExtend(mask, addresses); + public static Vector GatherVectorInt16SignExtend(Vector mask, Vector addresses) => GatherVectorInt16SignExtend(mask, addresses); /// - /// svuint64_t svld1sh_gather_[u64]index_u64(svbool_t pg, const int16_t *base, svuint64_t indices) - /// LD1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// svuint64_t svld1sh_gather_[u64]index_u64(svbool_t pg, const int16_t *base, svuint64_t indices) + /// LD1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] /// public static unsafe Vector GatherVectorInt16SignExtend(Vector mask, short* address, Vector indices) => GatherVectorInt16SignExtend(mask, address, indices); - // Load 16-bit data and sign-extend + // Load 16-bit data and sign-extend, first-faulting /// - /// svint32_t svld1sh_gather_[s32]offset_s32(svbool_t pg, const int16_t *base, svint32_t offsets) - /// LD1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// svint32_t svldff1sh_gather_[s32]index_s32(svbool_t pg, const int16_t *base, svint32_t indices) + /// LDFF1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1] + /// + public static unsafe Vector GatherVectorInt16SignExtendFirstFaulting(Vector mask, short* address, Vector indices) => GatherVectorInt16SignExtendFirstFaulting(mask, address, indices); + + // + // svint32_t svldff1sh_gather[_u32base]_s32(svbool_t pg, svuint32_t bases) + // LDFF1SH Zresult.S, Pg/Z, [Zbases.S, #0] + // + // Removed as per #103297 + // public static Vector GatherVectorInt16SignExtendFirstFaulting(Vector mask, Vector addresses) => GatherVectorInt16SignExtendFirstFaulting(mask, addresses); + + /// + /// svint32_t svldff1sh_gather_[u32]index_s32(svbool_t pg, const int16_t *base, svuint32_t indices) + /// LDFF1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1] + /// + public static unsafe Vector GatherVectorInt16SignExtendFirstFaulting(Vector mask, short* address, Vector indices) => GatherVectorInt16SignExtendFirstFaulting(mask, address, indices); + + /// + /// svint64_t svldff1sh_gather_[s64]index_s64(svbool_t pg, const int16_t *base, svint64_t indices) + /// LDFF1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// + public static unsafe Vector GatherVectorInt16SignExtendFirstFaulting(Vector mask, short* address, Vector indices) => GatherVectorInt16SignExtendFirstFaulting(mask, address, indices); + + /// + /// svint64_t svldff1sh_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LDFF1SH Zresult.D, Pg/Z, [Zbases.D, #0] + /// + public static Vector GatherVectorInt16SignExtendFirstFaulting(Vector mask, Vector addresses) => GatherVectorInt16SignExtendFirstFaulting(mask, addresses); + + /// + /// svint64_t svldff1sh_gather_[u64]index_s64(svbool_t pg, const int16_t *base, svuint64_t indices) + /// LDFF1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// + public static unsafe Vector GatherVectorInt16SignExtendFirstFaulting(Vector mask, short* address, Vector indices) => GatherVectorInt16SignExtendFirstFaulting(mask, address, indices); + + /// + /// svuint32_t svldff1sh_gather_[s32]index_u32(svbool_t pg, const int16_t *base, svint32_t indices) + /// LDFF1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1] + /// + public static unsafe Vector GatherVectorInt16SignExtendFirstFaulting(Vector mask, short* address, Vector indices) => GatherVectorInt16SignExtendFirstFaulting(mask, address, indices); + + // + // svuint32_t svldff1sh_gather[_u32base]_u32(svbool_t pg, svuint32_t bases) + // LDFF1SH Zresult.S, Pg/Z, [Zbases.S, #0] + // + // Removed as per #103297 + // public static Vector GatherVectorInt16SignExtendFirstFaulting(Vector mask, Vector addresses) => GatherVectorInt16SignExtendFirstFaulting(mask, addresses); + + /// + /// svuint32_t svldff1sh_gather_[u32]index_u32(svbool_t pg, const int16_t *base, svuint32_t indices) + /// LDFF1SH Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1] + /// + public static unsafe Vector GatherVectorInt16SignExtendFirstFaulting(Vector mask, short* address, Vector indices) => GatherVectorInt16SignExtendFirstFaulting(mask, address, indices); + + /// + /// svuint64_t svldff1sh_gather_[s64]index_u64(svbool_t pg, const int16_t *base, svint64_t indices) + /// LDFF1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// + public static unsafe Vector GatherVectorInt16SignExtendFirstFaulting(Vector mask, short* address, Vector indices) => GatherVectorInt16SignExtendFirstFaulting(mask, address, indices); + + /// + /// svuint64_t svldff1sh_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LDFF1SH Zresult.D, Pg/Z, [Zbases.D, #0] + /// + public static Vector GatherVectorInt16SignExtendFirstFaulting(Vector mask, Vector addresses) => GatherVectorInt16SignExtendFirstFaulting(mask, addresses); + + /// + /// svuint64_t svldff1sh_gather_[u64]index_u64(svbool_t pg, const int16_t *base, svuint64_t indices) + /// LDFF1SH Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// + public static unsafe Vector GatherVectorInt16SignExtendFirstFaulting(Vector mask, short* address, Vector indices) => GatherVectorInt16SignExtendFirstFaulting(mask, address, indices); + + + // Load 16-bit data and sign-extend + + /// + /// svint32_t svld1sh_gather_[s32]offset_s32(svbool_t pg, const int16_t *base, svint32_t offsets) + /// LD1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] /// public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtend(Vector mask, short* address, Vector offsets) => GatherVectorInt16WithByteOffsetsSignExtend(mask, address, offsets); /// - /// svint32_t svld1sh_gather_[u32]offset_s32(svbool_t pg, const int16_t *base, svuint32_t offsets) - /// LD1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// svint32_t svld1sh_gather_[u32]offset_s32(svbool_t pg, const int16_t *base, svuint32_t offsets) + /// LD1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] /// public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtend(Vector mask, short* address, Vector offsets) => GatherVectorInt16WithByteOffsetsSignExtend(mask, address, offsets); /// - /// svint64_t svld1sh_gather_[s64]offset_s64(svbool_t pg, const int16_t *base, svint64_t offsets) - /// LD1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1sh_gather_[s64]offset_s64(svbool_t pg, const int16_t *base, svint64_t offsets) + /// LD1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtend(Vector mask, short* address, Vector offsets) => GatherVectorInt16WithByteOffsetsSignExtend(mask, address, offsets); /// - /// svint64_t svld1sh_gather_[u64]offset_s64(svbool_t pg, const int16_t *base, svuint64_t offsets) - /// LD1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1sh_gather_[u64]offset_s64(svbool_t pg, const int16_t *base, svuint64_t offsets) + /// LD1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtend(Vector mask, short* address, Vector offsets) => GatherVectorInt16WithByteOffsetsSignExtend(mask, address, offsets); /// - /// svuint32_t svld1sh_gather_[s32]offset_u32(svbool_t pg, const int16_t *base, svint32_t offsets) - /// LD1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// svuint32_t svld1sh_gather_[s32]offset_u32(svbool_t pg, const int16_t *base, svint32_t offsets) + /// LD1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] /// public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtend(Vector mask, short* address, Vector offsets) => GatherVectorInt16WithByteOffsetsSignExtend(mask, address, offsets); /// - /// svuint32_t svld1sh_gather_[u32]offset_u32(svbool_t pg, const int16_t *base, svuint32_t offsets) - /// LD1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// svuint32_t svld1sh_gather_[u32]offset_u32(svbool_t pg, const int16_t *base, svuint32_t offsets) + /// LD1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] /// public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtend(Vector mask, short* address, Vector offsets) => GatherVectorInt16WithByteOffsetsSignExtend(mask, address, offsets); /// - /// svuint64_t svld1sh_gather_[s64]offset_u64(svbool_t pg, const int16_t *base, svint64_t offsets) - /// LD1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1sh_gather_[s64]offset_u64(svbool_t pg, const int16_t *base, svint64_t offsets) + /// LD1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtend(Vector mask, short* address, Vector offsets) => GatherVectorInt16WithByteOffsetsSignExtend(mask, address, offsets); /// - /// svuint64_t svld1sh_gather_[u64]offset_u64(svbool_t pg, const int16_t *base, svuint64_t offsets) - /// LD1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1sh_gather_[u64]offset_u64(svbool_t pg, const int16_t *base, svuint64_t offsets) + /// LD1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtend(Vector mask, short* address, Vector offsets) => GatherVectorInt16WithByteOffsetsSignExtend(mask, address, offsets); - // Load 32-bit data and sign-extend + // Load 16-bit data and sign-extend, first-faulting + + /// + /// svint32_t svldff1sh_gather_[s32]offset_s32(svbool_t pg, const int16_t *base, svint32_t offsets) + /// LDFF1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// + public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(Vector mask, short* address, Vector offsets) => GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(mask, address, offsets); + + /// + /// svint32_t svldff1sh_gather_[u32]offset_s32(svbool_t pg, const int16_t *base, svuint32_t offsets) + /// LDFF1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// + public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(Vector mask, short* address, Vector offsets) => GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(mask, address, offsets); + + /// + /// svint64_t svldff1sh_gather_[s64]offset_s64(svbool_t pg, const int16_t *base, svint64_t offsets) + /// LDFF1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(Vector mask, short* address, Vector offsets) => GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(mask, address, offsets); + + /// + /// svint64_t svldff1sh_gather_[u64]offset_s64(svbool_t pg, const int16_t *base, svuint64_t offsets) + /// LDFF1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(Vector mask, short* address, Vector offsets) => GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(mask, address, offsets); + + /// + /// svuint32_t svldff1sh_gather_[s32]offset_u32(svbool_t pg, const int16_t *base, svint32_t offsets) + /// LDFF1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// + public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(Vector mask, short* address, Vector offsets) => GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(mask, address, offsets); /// - /// svint64_t svld1sw_gather_[s64]index_s64(svbool_t pg, const int32_t *base, svint64_t indices) - /// LD1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// svuint32_t svldff1sh_gather_[u32]offset_u32(svbool_t pg, const int16_t *base, svuint32_t offsets) + /// LDFF1SH Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// + public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(Vector mask, short* address, Vector offsets) => GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(mask, address, offsets); + + /// + /// svuint64_t svldff1sh_gather_[s64]offset_u64(svbool_t pg, const int16_t *base, svint64_t offsets) + /// LDFF1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(Vector mask, short* address, Vector offsets) => GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(mask, address, offsets); + + /// + /// svuint64_t svldff1sh_gather_[u64]offset_u64(svbool_t pg, const int16_t *base, svuint64_t offsets) + /// LDFF1SH Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(Vector mask, short* address, Vector offsets) => GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(mask, address, offsets); + + + // Load 32-bit data and sign-extend + + /// + /// svint64_t svld1sw_gather_[s64]index_s64(svbool_t pg, const int32_t *base, svint64_t indices) + /// LD1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] /// public static unsafe Vector GatherVectorInt32SignExtend(Vector mask, int* address, Vector indices) => GatherVectorInt32SignExtend(mask, address, indices); /// - /// svint64_t svld1sw_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) - /// LD1SW Zresult.D, Pg/Z, [Zbases.D, #0] + /// svint64_t svld1sw_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LD1SW Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorInt32SignExtend(Vector mask, Vector addresses) => GatherVectorInt32SignExtend(mask, addresses); + public static Vector GatherVectorInt32SignExtend(Vector mask, Vector addresses) => GatherVectorInt32SignExtend(mask, addresses); /// - /// svint64_t svld1sw_gather_[u64]index_s64(svbool_t pg, const int32_t *base, svuint64_t indices) - /// LD1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// svint64_t svld1sw_gather_[u64]index_s64(svbool_t pg, const int32_t *base, svuint64_t indices) + /// LD1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] /// public static unsafe Vector GatherVectorInt32SignExtend(Vector mask, int* address, Vector indices) => GatherVectorInt32SignExtend(mask, address, indices); /// - /// svuint64_t svld1sw_gather_[s64]index_u64(svbool_t pg, const int32_t *base, svint64_t indices) - /// LD1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// svuint64_t svld1sw_gather_[s64]index_u64(svbool_t pg, const int32_t *base, svint64_t indices) + /// LD1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] /// public static unsafe Vector GatherVectorInt32SignExtend(Vector mask, int* address, Vector indices) => GatherVectorInt32SignExtend(mask, address, indices); /// - /// svuint64_t svld1sw_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) - /// LD1SW Zresult.D, Pg/Z, [Zbases.D, #0] + /// svuint64_t svld1sw_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LD1SW Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorInt32SignExtend(Vector mask, Vector addresses) => GatherVectorInt32SignExtend(mask, addresses); + public static Vector GatherVectorInt32SignExtend(Vector mask, Vector addresses) => GatherVectorInt32SignExtend(mask, addresses); /// - /// svuint64_t svld1sw_gather_[u64]index_u64(svbool_t pg, const int32_t *base, svuint64_t indices) - /// LD1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// svuint64_t svld1sw_gather_[u64]index_u64(svbool_t pg, const int32_t *base, svuint64_t indices) + /// LD1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] /// public static unsafe Vector GatherVectorInt32SignExtend(Vector mask, int* address, Vector indices) => GatherVectorInt32SignExtend(mask, address, indices); - // Load 32-bit data and sign-extend + // Load 32-bit data and sign-extend, first-faulting /// - /// svint64_t svld1sw_gather_[s64]offset_s64(svbool_t pg, const int32_t *base, svint64_t offsets) - /// LD1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svldff1sw_gather_[s64]index_s64(svbool_t pg, const int32_t *base, svint64_t indices) + /// LDFF1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// + public static unsafe Vector GatherVectorInt32SignExtendFirstFaulting(Vector mask, int* address, Vector indices) => GatherVectorInt32SignExtendFirstFaulting(mask, address, indices); + + /// + /// svint64_t svldff1sw_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LDFF1SW Zresult.D, Pg/Z, [Zbases.D, #0] + /// + public static Vector GatherVectorInt32SignExtendFirstFaulting(Vector mask, Vector addresses) => GatherVectorInt32SignExtendFirstFaulting(mask, addresses); + + /// + /// svint64_t svldff1sw_gather_[u64]index_s64(svbool_t pg, const int32_t *base, svuint64_t indices) + /// LDFF1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// + public static unsafe Vector GatherVectorInt32SignExtendFirstFaulting(Vector mask, int* address, Vector indices) => GatherVectorInt32SignExtendFirstFaulting(mask, address, indices); + + /// + /// svuint64_t svldff1sw_gather_[s64]index_u64(svbool_t pg, const int32_t *base, svint64_t indices) + /// LDFF1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// + public static unsafe Vector GatherVectorInt32SignExtendFirstFaulting(Vector mask, int* address, Vector indices) => GatherVectorInt32SignExtendFirstFaulting(mask, address, indices); + + /// + /// svuint64_t svldff1sw_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LDFF1SW Zresult.D, Pg/Z, [Zbases.D, #0] + /// + public static Vector GatherVectorInt32SignExtendFirstFaulting(Vector mask, Vector addresses) => GatherVectorInt32SignExtendFirstFaulting(mask, addresses); + + /// + /// svuint64_t svldff1sw_gather_[u64]index_u64(svbool_t pg, const int32_t *base, svuint64_t indices) + /// LDFF1SW Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// + public static unsafe Vector GatherVectorInt32SignExtendFirstFaulting(Vector mask, int* address, Vector indices) => GatherVectorInt32SignExtendFirstFaulting(mask, address, indices); + + + // Load 32-bit data and sign-extend + + /// + /// svint64_t svld1sw_gather_[s64]offset_s64(svbool_t pg, const int32_t *base, svint64_t offsets) + /// LD1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorInt32WithByteOffsetsSignExtend(Vector mask, int* address, Vector offsets) => GatherVectorInt32WithByteOffsetsSignExtend(mask, address, offsets); /// - /// svint64_t svld1sw_gather_[u64]offset_s64(svbool_t pg, const int32_t *base, svuint64_t offsets) - /// LD1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1sw_gather_[u64]offset_s64(svbool_t pg, const int32_t *base, svuint64_t offsets) + /// LD1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorInt32WithByteOffsetsSignExtend(Vector mask, int* address, Vector offsets) => GatherVectorInt32WithByteOffsetsSignExtend(mask, address, offsets); /// - /// svuint64_t svld1sw_gather_[s64]offset_u64(svbool_t pg, const int32_t *base, svint64_t offsets) - /// LD1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1sw_gather_[s64]offset_u64(svbool_t pg, const int32_t *base, svint64_t offsets) + /// LD1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorInt32WithByteOffsetsSignExtend(Vector mask, int* address, Vector offsets) => GatherVectorInt32WithByteOffsetsSignExtend(mask, address, offsets); /// - /// svuint64_t svld1sw_gather_[u64]offset_u64(svbool_t pg, const int32_t *base, svuint64_t offsets) - /// LD1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1sw_gather_[u64]offset_u64(svbool_t pg, const int32_t *base, svuint64_t offsets) + /// LD1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorInt32WithByteOffsetsSignExtend(Vector mask, int* address, Vector offsets) => GatherVectorInt32WithByteOffsetsSignExtend(mask, address, offsets); - // Load 8-bit data and sign-extend + // Load 32-bit data and sign-extend, first-faulting + + /// + /// svint64_t svldff1sw_gather_[s64]offset_s64(svbool_t pg, const int32_t *base, svint64_t offsets) + /// LDFF1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorInt32WithByteOffsetsSignExtendFirstFaulting(Vector mask, int* address, Vector offsets) => GatherVectorInt32WithByteOffsetsSignExtendFirstFaulting(mask, address, offsets); + + /// + /// svint64_t svldff1sw_gather_[u64]offset_s64(svbool_t pg, const int32_t *base, svuint64_t offsets) + /// LDFF1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorInt32WithByteOffsetsSignExtendFirstFaulting(Vector mask, int* address, Vector offsets) => GatherVectorInt32WithByteOffsetsSignExtendFirstFaulting(mask, address, offsets); /// - /// svint32_t svld1sb_gather_[s32]offset_s32(svbool_t pg, const int8_t *base, svint32_t offsets) - /// LD1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// svuint64_t svldff1sw_gather_[s64]offset_u64(svbool_t pg, const int32_t *base, svint64_t offsets) + /// LDFF1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorInt32WithByteOffsetsSignExtendFirstFaulting(Vector mask, int* address, Vector offsets) => GatherVectorInt32WithByteOffsetsSignExtendFirstFaulting(mask, address, offsets); + + /// + /// svuint64_t svldff1sw_gather_[u64]offset_u64(svbool_t pg, const int32_t *base, svuint64_t offsets) + /// LDFF1SW Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorInt32WithByteOffsetsSignExtendFirstFaulting(Vector mask, int* address, Vector offsets) => GatherVectorInt32WithByteOffsetsSignExtendFirstFaulting(mask, address, offsets); + + + // Load 8-bit data and sign-extend + + /// + /// svint32_t svld1sb_gather_[s32]offset_s32(svbool_t pg, const int8_t *base, svint32_t offsets) + /// LD1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] /// public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, sbyte* address, Vector indices) => GatherVectorSByteSignExtend(mask, address, indices); @@ -3967,35 +4219,35 @@ internal Arm64() { } // LD1SB Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, Vector addresses) => GatherVectorSByteSignExtend(mask, addresses); + // public static Vector GatherVectorSByteSignExtend(Vector mask, Vector addresses) => GatherVectorSByteSignExtend(mask, addresses); /// - /// svint32_t svld1sb_gather_[u32]offset_s32(svbool_t pg, const int8_t *base, svuint32_t offsets) - /// LD1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// svint32_t svld1sb_gather_[u32]offset_s32(svbool_t pg, const int8_t *base, svuint32_t offsets) + /// LD1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] /// public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, sbyte* address, Vector indices) => GatherVectorSByteSignExtend(mask, address, indices); /// - /// svint64_t svld1sb_gather_[s64]offset_s64(svbool_t pg, const int8_t *base, svint64_t offsets) - /// LD1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1sb_gather_[s64]offset_s64(svbool_t pg, const int8_t *base, svint64_t offsets) + /// LD1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, sbyte* address, Vector indices) => GatherVectorSByteSignExtend(mask, address, indices); /// - /// svint64_t svld1sb_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) - /// LD1SB Zresult.D, Pg/Z, [Zbases.D, #0] + /// svint64_t svld1sb_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LD1SB Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, Vector addresses) => GatherVectorSByteSignExtend(mask, addresses); + public static Vector GatherVectorSByteSignExtend(Vector mask, Vector addresses) => GatherVectorSByteSignExtend(mask, addresses); /// - /// svint64_t svld1sb_gather_[u64]offset_s64(svbool_t pg, const int8_t *base, svuint64_t offsets) - /// LD1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1sb_gather_[u64]offset_s64(svbool_t pg, const int8_t *base, svuint64_t offsets) + /// LD1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, sbyte* address, Vector indices) => GatherVectorSByteSignExtend(mask, address, indices); /// - /// svuint32_t svld1sb_gather_[s32]offset_u32(svbool_t pg, const int8_t *base, svint32_t offsets) - /// LD1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// svuint32_t svld1sb_gather_[s32]offset_u32(svbool_t pg, const int8_t *base, svint32_t offsets) + /// LD1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] /// public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, sbyte* address, Vector indices) => GatherVectorSByteSignExtend(mask, address, indices); @@ -4004,89 +4256,217 @@ internal Arm64() { } // LD1SB Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, Vector addresses) => GatherVectorSByteSignExtend(mask, addresses); + // public static Vector GatherVectorSByteSignExtend(Vector mask, Vector addresses) => GatherVectorSByteSignExtend(mask, addresses); /// - /// svuint32_t svld1sb_gather_[u32]offset_u32(svbool_t pg, const int8_t *base, svuint32_t offsets) - /// LD1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// svuint32_t svld1sb_gather_[u32]offset_u32(svbool_t pg, const int8_t *base, svuint32_t offsets) + /// LD1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] /// public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, sbyte* address, Vector indices) => GatherVectorSByteSignExtend(mask, address, indices); /// - /// svuint64_t svld1sb_gather_[s64]offset_u64(svbool_t pg, const int8_t *base, svint64_t offsets) - /// LD1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1sb_gather_[s64]offset_u64(svbool_t pg, const int8_t *base, svint64_t offsets) + /// LD1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, sbyte* address, Vector indices) => GatherVectorSByteSignExtend(mask, address, indices); /// - /// svuint64_t svld1sb_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) - /// LD1SB Zresult.D, Pg/Z, [Zbases.D, #0] + /// svuint64_t svld1sb_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LD1SB Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, Vector addresses) => GatherVectorSByteSignExtend(mask, addresses); + public static Vector GatherVectorSByteSignExtend(Vector mask, Vector addresses) => GatherVectorSByteSignExtend(mask, addresses); /// - /// svuint64_t svld1sb_gather_[u64]offset_u64(svbool_t pg, const int8_t *base, svuint64_t offsets) - /// LD1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1sb_gather_[u64]offset_u64(svbool_t pg, const int8_t *base, svuint64_t offsets) + /// LD1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorSByteSignExtend(Vector mask, sbyte* address, Vector indices) => GatherVectorSByteSignExtend(mask, address, indices); - // Load 16-bit data and zero-extend + // Load 8-bit data and sign-extend, first-faulting + + /// + /// svint32_t svldff1sb_gather_[s32]offset_s32(svbool_t pg, const int8_t *base, svint32_t offsets) + /// LDFF1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// + public static unsafe Vector GatherVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address, Vector offsets) => GatherVectorSByteSignExtendFirstFaulting(mask, address, offsets); + + // + // svint32_t svldff1sb_gather[_u32base]_s32(svbool_t pg, svuint32_t bases) + // LDFF1SB Zresult.S, Pg/Z, [Zbases.S, #0] + // + // Removed as per #103297 + // public static Vector GatherVectorSByteSignExtendFirstFaulting(Vector mask, Vector addresses) => GatherVectorSByteSignExtendFirstFaulting(mask, addresses); + + /// + /// svint32_t svldff1sb_gather_[u32]offset_s32(svbool_t pg, const int8_t *base, svuint32_t offsets) + /// LDFF1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// + public static unsafe Vector GatherVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address, Vector offsets) => GatherVectorSByteSignExtendFirstFaulting(mask, address, offsets); + + /// + /// svint64_t svldff1sb_gather_[s64]offset_s64(svbool_t pg, const int8_t *base, svint64_t offsets) + /// LDFF1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address, Vector offsets) => GatherVectorSByteSignExtendFirstFaulting(mask, address, offsets); + + /// + /// svint64_t svldff1sb_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LDFF1SB Zresult.D, Pg/Z, [Zbases.D, #0] + /// + public static Vector GatherVectorSByteSignExtendFirstFaulting(Vector mask, Vector addresses) => GatherVectorSByteSignExtendFirstFaulting(mask, addresses); + + /// + /// svint64_t svldff1sb_gather_[u64]offset_s64(svbool_t pg, const int8_t *base, svuint64_t offsets) + /// LDFF1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address, Vector offsets) => GatherVectorSByteSignExtendFirstFaulting(mask, address, offsets); + + /// + /// svuint32_t svldff1sb_gather_[s32]offset_u32(svbool_t pg, const int8_t *base, svint32_t offsets) + /// LDFF1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// + public static unsafe Vector GatherVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address, Vector offsets) => GatherVectorSByteSignExtendFirstFaulting(mask, address, offsets); + + // + // svuint32_t svldff1sb_gather[_u32base]_u32(svbool_t pg, svuint32_t bases) + // LDFF1SB Zresult.S, Pg/Z, [Zbases.S, #0] + // + // Removed as per #103297 + // public static Vector GatherVectorSByteSignExtendFirstFaulting(Vector mask, Vector addresses) => GatherVectorSByteSignExtendFirstFaulting(mask, addresses); + + /// + /// svuint32_t svldff1sb_gather_[u32]offset_u32(svbool_t pg, const int8_t *base, svuint32_t offsets) + /// LDFF1SB Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// + public static unsafe Vector GatherVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address, Vector offsets) => GatherVectorSByteSignExtendFirstFaulting(mask, address, offsets); + + /// + /// svuint64_t svldff1sb_gather_[s64]offset_u64(svbool_t pg, const int8_t *base, svint64_t offsets) + /// LDFF1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address, Vector offsets) => GatherVectorSByteSignExtendFirstFaulting(mask, address, offsets); + + /// + /// svuint64_t svldff1sb_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LDFF1SB Zresult.D, Pg/Z, [Zbases.D, #0] + /// + public static Vector GatherVectorSByteSignExtendFirstFaulting(Vector mask, Vector addresses) => GatherVectorSByteSignExtendFirstFaulting(mask, addresses); + + /// + /// svuint64_t svldff1sb_gather_[u64]offset_u64(svbool_t pg, const int8_t *base, svuint64_t offsets) + /// LDFF1SB Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address, Vector offsets) => GatherVectorSByteSignExtendFirstFaulting(mask, address, offsets); + + + // Load 16-bit data and zero-extend /// - /// svint32_t svld1uh_gather_[s32]offset_s32(svbool_t pg, const uint16_t *base, svint32_t offsets) - /// LD1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// svint32_t svld1uh_gather_[s32]offset_s32(svbool_t pg, const uint16_t *base, svint32_t offsets) + /// LD1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] /// public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtend(Vector mask, ushort* address, Vector offsets) => GatherVectorUInt16WithByteOffsetsZeroExtend(mask, address, offsets); /// - /// svint32_t svld1uh_gather_[u32]offset_s32(svbool_t pg, const uint16_t *base, svuint32_t offsets) - /// LD1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// svint32_t svld1uh_gather_[u32]offset_s32(svbool_t pg, const uint16_t *base, svuint32_t offsets) + /// LD1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] /// public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtend(Vector mask, ushort* address, Vector offsets) => GatherVectorUInt16WithByteOffsetsZeroExtend(mask, address, offsets); /// - /// svint64_t svld1uh_gather_[s64]offset_s64(svbool_t pg, const uint16_t *base, svint64_t offsets) - /// LD1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1uh_gather_[s64]offset_s64(svbool_t pg, const uint16_t *base, svint64_t offsets) + /// LD1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtend(Vector mask, ushort* address, Vector offsets) => GatherVectorUInt16WithByteOffsetsZeroExtend(mask, address, offsets); /// - /// svint64_t svld1uh_gather_[u64]offset_s64(svbool_t pg, const uint16_t *base, svuint64_t offsets) - /// LD1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1uh_gather_[u64]offset_s64(svbool_t pg, const uint16_t *base, svuint64_t offsets) + /// LD1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtend(Vector mask, ushort* address, Vector offsets) => GatherVectorUInt16WithByteOffsetsZeroExtend(mask, address, offsets); /// - /// svuint32_t svld1uh_gather_[s32]offset_u32(svbool_t pg, const uint16_t *base, svint32_t offsets) - /// LD1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// svuint32_t svld1uh_gather_[s32]offset_u32(svbool_t pg, const uint16_t *base, svint32_t offsets) + /// LD1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] /// public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtend(Vector mask, ushort* address, Vector offsets) => GatherVectorUInt16WithByteOffsetsZeroExtend(mask, address, offsets); /// - /// svuint32_t svld1uh_gather_[u32]offset_u32(svbool_t pg, const uint16_t *base, svuint32_t offsets) - /// LD1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// svuint32_t svld1uh_gather_[u32]offset_u32(svbool_t pg, const uint16_t *base, svuint32_t offsets) + /// LD1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] /// public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtend(Vector mask, ushort* address, Vector offsets) => GatherVectorUInt16WithByteOffsetsZeroExtend(mask, address, offsets); /// - /// svuint64_t svld1uh_gather_[s64]offset_u64(svbool_t pg, const uint16_t *base, svint64_t offsets) - /// LD1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1uh_gather_[s64]offset_u64(svbool_t pg, const uint16_t *base, svint64_t offsets) + /// LD1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtend(Vector mask, ushort* address, Vector offsets) => GatherVectorUInt16WithByteOffsetsZeroExtend(mask, address, offsets); /// - /// svuint64_t svld1uh_gather_[u64]offset_u64(svbool_t pg, const uint16_t *base, svuint64_t offsets) - /// LD1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1uh_gather_[u64]offset_u64(svbool_t pg, const uint16_t *base, svuint64_t offsets) + /// LD1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtend(Vector mask, ushort* address, Vector offsets) => GatherVectorUInt16WithByteOffsetsZeroExtend(mask, address, offsets); - // Load 16-bit data and zero-extend + // Load 16-bit data and zero-extend, first-faulting + + /// + /// svint32_t svldff1uh_gather_[s32]offset_s32(svbool_t pg, const uint16_t *base, svint32_t offsets) + /// LDFF1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// + public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(Vector mask, ushort* address, Vector offsets) => GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(mask, address, offsets); + + /// + /// svint32_t svldff1uh_gather_[u32]offset_s32(svbool_t pg, const uint16_t *base, svuint32_t offsets) + /// LDFF1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// + public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(Vector mask, ushort* address, Vector offsets) => GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(mask, address, offsets); + + /// + /// svint64_t svldff1uh_gather_[s64]offset_s64(svbool_t pg, const uint16_t *base, svint64_t offsets) + /// LDFF1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(Vector mask, ushort* address, Vector offsets) => GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(mask, address, offsets); + + /// + /// svint64_t svldff1uh_gather_[u64]offset_s64(svbool_t pg, const uint16_t *base, svuint64_t offsets) + /// LDFF1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(Vector mask, ushort* address, Vector offsets) => GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(mask, address, offsets); /// - /// svint32_t svld1uh_gather_[s32]index_s32(svbool_t pg, const uint16_t *base, svint32_t indices) - /// LD1H Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1] + /// svuint32_t svldff1uh_gather_[s32]offset_u32(svbool_t pg, const uint16_t *base, svint32_t offsets) + /// LDFF1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// + public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(Vector mask, ushort* address, Vector offsets) => GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(mask, address, offsets); + + /// + /// svuint32_t svldff1uh_gather_[u32]offset_u32(svbool_t pg, const uint16_t *base, svuint32_t offsets) + /// LDFF1H Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// + public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(Vector mask, ushort* address, Vector offsets) => GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(mask, address, offsets); + + /// + /// svuint64_t svldff1uh_gather_[s64]offset_u64(svbool_t pg, const uint16_t *base, svint64_t offsets) + /// LDFF1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(Vector mask, ushort* address, Vector offsets) => GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(mask, address, offsets); + + /// + /// svuint64_t svldff1uh_gather_[u64]offset_u64(svbool_t pg, const uint16_t *base, svuint64_t offsets) + /// LDFF1H Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(Vector mask, ushort* address, Vector offsets) => GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(mask, address, offsets); + + + // Load 16-bit data and zero-extend + + /// + /// svint32_t svld1uh_gather_[s32]index_s32(svbool_t pg, const uint16_t *base, svint32_t indices) + /// LD1H Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1] /// public static unsafe Vector GatherVectorUInt16ZeroExtend(Vector mask, ushort* address, Vector indices) => GatherVectorUInt16ZeroExtend(mask, address, indices); @@ -4095,35 +4475,35 @@ internal Arm64() { } // LD1H Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorUInt16ZeroExtend(Vector mask, Vector addresses) => GatherVectorUInt16ZeroExtend(mask, addresses); + // public static Vector GatherVectorUInt16ZeroExtend(Vector mask, Vector addresses) => GatherVectorUInt16ZeroExtend(mask, addresses); /// - /// svint32_t svld1uh_gather_[u32]index_s32(svbool_t pg, const uint16_t *base, svuint32_t indices) - /// LD1H Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1] + /// svint32_t svld1uh_gather_[u32]index_s32(svbool_t pg, const uint16_t *base, svuint32_t indices) + /// LD1H Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1] /// public static unsafe Vector GatherVectorUInt16ZeroExtend(Vector mask, ushort* address, Vector indices) => GatherVectorUInt16ZeroExtend(mask, address, indices); /// - /// svint64_t svld1uh_gather_[s64]index_s64(svbool_t pg, const uint16_t *base, svint64_t indices) - /// LD1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// svint64_t svld1uh_gather_[s64]index_s64(svbool_t pg, const uint16_t *base, svint64_t indices) + /// LD1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] /// public static unsafe Vector GatherVectorUInt16ZeroExtend(Vector mask, ushort* address, Vector indices) => GatherVectorUInt16ZeroExtend(mask, address, indices); /// - /// svint64_t svld1uh_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) - /// LD1H Zresult.D, Pg/Z, [Zbases.D, #0] + /// svint64_t svld1uh_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LD1H Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorUInt16ZeroExtend(Vector mask, Vector addresses) => GatherVectorUInt16ZeroExtend(mask, addresses); + public static Vector GatherVectorUInt16ZeroExtend(Vector mask, Vector addresses) => GatherVectorUInt16ZeroExtend(mask, addresses); /// - /// svint64_t svld1uh_gather_[u64]index_s64(svbool_t pg, const uint16_t *base, svuint64_t indices) - /// LD1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// svint64_t svld1uh_gather_[u64]index_s64(svbool_t pg, const uint16_t *base, svuint64_t indices) + /// LD1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] /// public static unsafe Vector GatherVectorUInt16ZeroExtend(Vector mask, ushort* address, Vector indices) => GatherVectorUInt16ZeroExtend(mask, address, indices); /// - /// svuint32_t svld1uh_gather_[s32]index_u32(svbool_t pg, const uint16_t *base, svint32_t indices) - /// LD1H Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1] + /// svuint32_t svld1uh_gather_[s32]index_u32(svbool_t pg, const uint16_t *base, svint32_t indices) + /// LD1H Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1] /// public static unsafe Vector GatherVectorUInt16ZeroExtend(Vector mask, ushort* address, Vector indices) => GatherVectorUInt16ZeroExtend(mask, address, indices); @@ -4132,89 +4512,217 @@ internal Arm64() { } // LD1H Zresult.S, Pg/Z, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorUInt16ZeroExtend(Vector mask, Vector addresses) => GatherVectorUInt16ZeroExtend(mask, addresses); + // public static Vector GatherVectorUInt16ZeroExtend(Vector mask, Vector addresses) => GatherVectorUInt16ZeroExtend(mask, addresses); /// - /// svuint32_t svld1uh_gather_[u32]index_u32(svbool_t pg, const uint16_t *base, svuint32_t indices) - /// LD1H Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1] + /// svuint32_t svld1uh_gather_[u32]index_u32(svbool_t pg, const uint16_t *base, svuint32_t indices) + /// LD1H Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1] /// public static unsafe Vector GatherVectorUInt16ZeroExtend(Vector mask, ushort* address, Vector indices) => GatherVectorUInt16ZeroExtend(mask, address, indices); /// - /// svuint64_t svld1uh_gather_[s64]index_u64(svbool_t pg, const uint16_t *base, svint64_t indices) - /// LD1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// svuint64_t svld1uh_gather_[s64]index_u64(svbool_t pg, const uint16_t *base, svint64_t indices) + /// LD1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] /// public static unsafe Vector GatherVectorUInt16ZeroExtend(Vector mask, ushort* address, Vector indices) => GatherVectorUInt16ZeroExtend(mask, address, indices); /// - /// svuint64_t svld1uh_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) - /// LD1H Zresult.D, Pg/Z, [Zbases.D, #0] + /// svuint64_t svld1uh_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LD1H Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorUInt16ZeroExtend(Vector mask, Vector addresses) => GatherVectorUInt16ZeroExtend(mask, addresses); + public static Vector GatherVectorUInt16ZeroExtend(Vector mask, Vector addresses) => GatherVectorUInt16ZeroExtend(mask, addresses); /// - /// svuint64_t svld1uh_gather_[u64]index_u64(svbool_t pg, const uint16_t *base, svuint64_t indices) - /// LD1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// svuint64_t svld1uh_gather_[u64]index_u64(svbool_t pg, const uint16_t *base, svuint64_t indices) + /// LD1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] /// public static unsafe Vector GatherVectorUInt16ZeroExtend(Vector mask, ushort* address, Vector indices) => GatherVectorUInt16ZeroExtend(mask, address, indices); - // Load 32-bit data and zero-extend + // Load 16-bit data and zero-extend, first-faulting + + /// + /// svint32_t svldff1uh_gather_[s32]index_s32(svbool_t pg, const uint16_t *base, svint32_t indices) + /// LDFF1H Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1] + /// + public static unsafe Vector GatherVectorUInt16ZeroExtendFirstFaulting(Vector mask, ushort* address, Vector indices) => GatherVectorUInt16ZeroExtendFirstFaulting(mask, address, indices); + + // + // svint32_t svldff1uh_gather[_u32base]_s32(svbool_t pg, svuint32_t bases) + // LDFF1H Zresult.S, Pg/Z, [Zbases.S, #0] + // + // Removed as per #103297 + // public static Vector GatherVectorUInt16ZeroExtendFirstFaulting(Vector mask, Vector addresses) => GatherVectorUInt16ZeroExtendFirstFaulting(mask, addresses); + + /// + /// svint32_t svldff1uh_gather_[u32]index_s32(svbool_t pg, const uint16_t *base, svuint32_t indices) + /// LDFF1H Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1] + /// + public static unsafe Vector GatherVectorUInt16ZeroExtendFirstFaulting(Vector mask, ushort* address, Vector indices) => GatherVectorUInt16ZeroExtendFirstFaulting(mask, address, indices); + + /// + /// svint64_t svldff1uh_gather_[s64]index_s64(svbool_t pg, const uint16_t *base, svint64_t indices) + /// LDFF1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// + public static unsafe Vector GatherVectorUInt16ZeroExtendFirstFaulting(Vector mask, ushort* address, Vector indices) => GatherVectorUInt16ZeroExtendFirstFaulting(mask, address, indices); + + /// + /// svint64_t svldff1uh_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LDFF1H Zresult.D, Pg/Z, [Zbases.D, #0] + /// + public static Vector GatherVectorUInt16ZeroExtendFirstFaulting(Vector mask, Vector addresses) => GatherVectorUInt16ZeroExtendFirstFaulting(mask, addresses); + + /// + /// svint64_t svldff1uh_gather_[u64]index_s64(svbool_t pg, const uint16_t *base, svuint64_t indices) + /// LDFF1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// + public static unsafe Vector GatherVectorUInt16ZeroExtendFirstFaulting(Vector mask, ushort* address, Vector indices) => GatherVectorUInt16ZeroExtendFirstFaulting(mask, address, indices); + + /// + /// svuint32_t svldff1uh_gather_[s32]index_u32(svbool_t pg, const uint16_t *base, svint32_t indices) + /// LDFF1H Zresult.S, Pg/Z, [Xbase, Zindices.S, SXTW #1] + /// + public static unsafe Vector GatherVectorUInt16ZeroExtendFirstFaulting(Vector mask, ushort* address, Vector indices) => GatherVectorUInt16ZeroExtendFirstFaulting(mask, address, indices); + + // + // svuint32_t svldff1uh_gather[_u32base]_u32(svbool_t pg, svuint32_t bases) + // LDFF1H Zresult.S, Pg/Z, [Zbases.S, #0] + // + // Removed as per #103297 + // public static Vector GatherVectorUInt16ZeroExtendFirstFaulting(Vector mask, Vector addresses) => GatherVectorUInt16ZeroExtendFirstFaulting(mask, addresses); + + /// + /// svuint32_t svldff1uh_gather_[u32]index_u32(svbool_t pg, const uint16_t *base, svuint32_t indices) + /// LDFF1H Zresult.S, Pg/Z, [Xbase, Zindices.S, UXTW #1] + /// + public static unsafe Vector GatherVectorUInt16ZeroExtendFirstFaulting(Vector mask, ushort* address, Vector indices) => GatherVectorUInt16ZeroExtendFirstFaulting(mask, address, indices); + + /// + /// svuint64_t svldff1uh_gather_[s64]index_u64(svbool_t pg, const uint16_t *base, svint64_t indices) + /// LDFF1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// + public static unsafe Vector GatherVectorUInt16ZeroExtendFirstFaulting(Vector mask, ushort* address, Vector indices) => GatherVectorUInt16ZeroExtendFirstFaulting(mask, address, indices); + + /// + /// svuint64_t svldff1uh_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LDFF1H Zresult.D, Pg/Z, [Zbases.D, #0] + /// + public static Vector GatherVectorUInt16ZeroExtendFirstFaulting(Vector mask, Vector addresses) => GatherVectorUInt16ZeroExtendFirstFaulting(mask, addresses); /// - /// svint64_t svld1uw_gather_[s64]offset_s64(svbool_t pg, const uint32_t *base, svint64_t offsets) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svldff1uh_gather_[u64]index_u64(svbool_t pg, const uint16_t *base, svuint64_t indices) + /// LDFF1H Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #1] + /// + public static unsafe Vector GatherVectorUInt16ZeroExtendFirstFaulting(Vector mask, ushort* address, Vector indices) => GatherVectorUInt16ZeroExtendFirstFaulting(mask, address, indices); + + + // Load 32-bit data and zero-extend + + /// + /// svint64_t svld1uw_gather_[s64]offset_s64(svbool_t pg, const uint32_t *base, svint64_t offsets) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtend(Vector mask, uint* address, Vector offsets) => GatherVectorUInt32WithByteOffsetsZeroExtend(mask, address, offsets); /// - /// svint64_t svld1uw_gather_[u64]offset_s64(svbool_t pg, const uint32_t *base, svuint64_t offsets) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1uw_gather_[u64]offset_s64(svbool_t pg, const uint32_t *base, svuint64_t offsets) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtend(Vector mask, uint* address, Vector offsets) => GatherVectorUInt32WithByteOffsetsZeroExtend(mask, address, offsets); /// - /// svint64_t svld1uw_gather_[s64]offset_s64(svbool_t pg, const uint32_t *base, svint64_t offsets) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1uw_gather_[s64]offset_s64(svbool_t pg, const uint32_t *base, svint64_t offsets) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtend(Vector mask, uint* address, Vector offsets) => GatherVectorUInt32WithByteOffsetsZeroExtend(mask, address, offsets); /// - /// svint64_t svld1uw_gather_[u64]offset_s64(svbool_t pg, const uint32_t *base, svuint64_t offsets) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1uw_gather_[u64]offset_s64(svbool_t pg, const uint32_t *base, svuint64_t offsets) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtend(Vector mask, uint* address, Vector offsets) => GatherVectorUInt32WithByteOffsetsZeroExtend(mask, address, offsets); /// - /// svuint64_t svld1uw_gather_[s64]offset_u64(svbool_t pg, const uint32_t *base, svint64_t offsets) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1uw_gather_[s64]offset_u64(svbool_t pg, const uint32_t *base, svint64_t offsets) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtend(Vector mask, uint* address, Vector offsets) => GatherVectorUInt32WithByteOffsetsZeroExtend(mask, address, offsets); /// - /// svuint64_t svld1uw_gather_[u64]offset_u64(svbool_t pg, const uint32_t *base, svuint64_t offsets) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1uw_gather_[u64]offset_u64(svbool_t pg, const uint32_t *base, svuint64_t offsets) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtend(Vector mask, uint* address, Vector offsets) => GatherVectorUInt32WithByteOffsetsZeroExtend(mask, address, offsets); /// - /// svuint64_t svld1uw_gather_[s64]offset_u64(svbool_t pg, const uint32_t *base, svint64_t offsets) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1uw_gather_[s64]offset_u64(svbool_t pg, const uint32_t *base, svint64_t offsets) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtend(Vector mask, uint* address, Vector offsets) => GatherVectorUInt32WithByteOffsetsZeroExtend(mask, address, offsets); /// - /// svuint64_t svld1uw_gather_[u64]offset_u64(svbool_t pg, const uint32_t *base, svuint64_t offsets) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1uw_gather_[u64]offset_u64(svbool_t pg, const uint32_t *base, svuint64_t offsets) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtend(Vector mask, uint* address, Vector offsets) => GatherVectorUInt32WithByteOffsetsZeroExtend(mask, address, offsets); - // Load 32-bit data and zero-extend + // Load 32-bit data and zero-extend, first-faulting + + /// + /// svint64_t svldff1uw_gather_[s64]offset_s64(svbool_t pg, const uint32_t *base, svint64_t offsets) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(Vector mask, uint* address, Vector offsets) => GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(mask, address, offsets); + + /// + /// svint64_t svldff1uw_gather_[u64]offset_s64(svbool_t pg, const uint32_t *base, svuint64_t offsets) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(Vector mask, uint* address, Vector offsets) => GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(mask, address, offsets); /// - /// svint64_t svld1uw_gather_[s64]index_s64(svbool_t pg, const uint32_t *base, svint64_t indices) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// svint64_t svldff1uw_gather_[s64]offset_s64(svbool_t pg, const uint32_t *base, svint64_t offsets) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(Vector mask, uint* address, Vector offsets) => GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(mask, address, offsets); + + /// + /// svint64_t svldff1uw_gather_[u64]offset_s64(svbool_t pg, const uint32_t *base, svuint64_t offsets) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(Vector mask, uint* address, Vector offsets) => GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(mask, address, offsets); + + /// + /// svuint64_t svldff1uw_gather_[s64]offset_u64(svbool_t pg, const uint32_t *base, svint64_t offsets) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(Vector mask, uint* address, Vector offsets) => GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(mask, address, offsets); + + /// + /// svuint64_t svldff1uw_gather_[u64]offset_u64(svbool_t pg, const uint32_t *base, svuint64_t offsets) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(Vector mask, uint* address, Vector offsets) => GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(mask, address, offsets); + + /// + /// svuint64_t svldff1uw_gather_[s64]offset_u64(svbool_t pg, const uint32_t *base, svint64_t offsets) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(Vector mask, uint* address, Vector offsets) => GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(mask, address, offsets); + + /// + /// svuint64_t svldff1uw_gather_[u64]offset_u64(svbool_t pg, const uint32_t *base, svuint64_t offsets) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(Vector mask, uint* address, Vector offsets) => GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(mask, address, offsets); + + + // Load 32-bit data and zero-extend + + /// + /// svint64_t svld1uw_gather_[s64]index_s64(svbool_t pg, const uint32_t *base, svint64_t indices) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] /// public static unsafe Vector GatherVectorUInt32ZeroExtend(Vector mask, uint* address, Vector indices) => GatherVectorUInt32ZeroExtend(mask, address, indices); @@ -4223,35 +4731,35 @@ internal Arm64() { } // LD1W Zresult.D, Pg/Z, [Zbases.D, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorUInt32ZeroExtend(Vector mask, Vector addresses) => GatherVectorUInt32ZeroExtend(mask, addresses); + // public static Vector GatherVectorUInt32ZeroExtend(Vector mask, Vector addresses) => GatherVectorUInt32ZeroExtend(mask, addresses); /// - /// svint64_t svld1uw_gather_[u64]index_s64(svbool_t pg, const uint32_t *base, svuint64_t indices) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// svint64_t svld1uw_gather_[u64]index_s64(svbool_t pg, const uint32_t *base, svuint64_t indices) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] /// public static unsafe Vector GatherVectorUInt32ZeroExtend(Vector mask, uint* address, Vector indices) => GatherVectorUInt32ZeroExtend(mask, address, indices); /// - /// svint64_t svld1uw_gather_[s64]index_s64(svbool_t pg, const uint32_t *base, svint64_t indices) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// svint64_t svld1uw_gather_[s64]index_s64(svbool_t pg, const uint32_t *base, svint64_t indices) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] /// public static unsafe Vector GatherVectorUInt32ZeroExtend(Vector mask, uint* address, Vector indices) => GatherVectorUInt32ZeroExtend(mask, address, indices); /// - /// svint64_t svld1uw_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) - /// LD1W Zresult.D, Pg/Z, [Zbases.D, #0] + /// svint64_t svld1uw_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LD1W Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorUInt32ZeroExtend(Vector mask, Vector addresses) => GatherVectorUInt32ZeroExtend(mask, addresses); + public static Vector GatherVectorUInt32ZeroExtend(Vector mask, Vector addresses) => GatherVectorUInt32ZeroExtend(mask, addresses); /// - /// svint64_t svld1uw_gather_[u64]index_s64(svbool_t pg, const uint32_t *base, svuint64_t indices) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// svint64_t svld1uw_gather_[u64]index_s64(svbool_t pg, const uint32_t *base, svuint64_t indices) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] /// public static unsafe Vector GatherVectorUInt32ZeroExtend(Vector mask, uint* address, Vector indices) => GatherVectorUInt32ZeroExtend(mask, address, indices); /// - /// svuint64_t svld1uw_gather_[s64]index_u64(svbool_t pg, const uint32_t *base, svint64_t indices) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// svuint64_t svld1uw_gather_[s64]index_u64(svbool_t pg, const uint32_t *base, svint64_t indices) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] /// public static unsafe Vector GatherVectorUInt32ZeroExtend(Vector mask, uint* address, Vector indices) => GatherVectorUInt32ZeroExtend(mask, address, indices); @@ -4260,104 +4768,256 @@ internal Arm64() { } // LD1W Zresult.D, Pg/Z, [Zbases.D, #0] // // Removed as per #103297 - // public static unsafe Vector GatherVectorUInt32ZeroExtend(Vector mask, Vector addresses) => GatherVectorUInt32ZeroExtend(mask, addresses); + // public static Vector GatherVectorUInt32ZeroExtend(Vector mask, Vector addresses) => GatherVectorUInt32ZeroExtend(mask, addresses); /// - /// svuint64_t svld1uw_gather_[u64]index_u64(svbool_t pg, const uint32_t *base, svuint64_t indices) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// svuint64_t svld1uw_gather_[u64]index_u64(svbool_t pg, const uint32_t *base, svuint64_t indices) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] /// public static unsafe Vector GatherVectorUInt32ZeroExtend(Vector mask, uint* address, Vector indices) => GatherVectorUInt32ZeroExtend(mask, address, indices); /// - /// svuint64_t svld1uw_gather_[s64]index_u64(svbool_t pg, const uint32_t *base, svint64_t indices) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// svuint64_t svld1uw_gather_[s64]index_u64(svbool_t pg, const uint32_t *base, svint64_t indices) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] /// public static unsafe Vector GatherVectorUInt32ZeroExtend(Vector mask, uint* address, Vector indices) => GatherVectorUInt32ZeroExtend(mask, address, indices); /// - /// svuint64_t svld1uw_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) - /// LD1W Zresult.D, Pg/Z, [Zbases.D, #0] + /// svuint64_t svld1uw_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LD1W Zresult.D, Pg/Z, [Zbases.D, #0] /// - public static unsafe Vector GatherVectorUInt32ZeroExtend(Vector mask, Vector addresses) => GatherVectorUInt32ZeroExtend(mask, addresses); + public static Vector GatherVectorUInt32ZeroExtend(Vector mask, Vector addresses) => GatherVectorUInt32ZeroExtend(mask, addresses); /// - /// svuint64_t svld1uw_gather_[u64]index_u64(svbool_t pg, const uint32_t *base, svuint64_t indices) - /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// svuint64_t svld1uw_gather_[u64]index_u64(svbool_t pg, const uint32_t *base, svuint64_t indices) + /// LD1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] /// public static unsafe Vector GatherVectorUInt32ZeroExtend(Vector mask, uint* address, Vector indices) => GatherVectorUInt32ZeroExtend(mask, address, indices); - // Unextended load + // Load 32-bit data and zero-extend, first-faulting + + /// + /// svint64_t svldff1uw_gather_[s64]index_s64(svbool_t pg, const uint32_t *base, svint64_t indices) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// + public static unsafe Vector GatherVectorUInt32ZeroExtendFirstFaulting(Vector mask, uint* address, Vector indices) => GatherVectorUInt32ZeroExtendFirstFaulting(mask, address, indices); + + // + // svint64_t svldff1uw_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + // LDFF1W Zresult.D, Pg/Z, [Zbases.D, #0] + // + // Removed as per #103297 + // public static Vector GatherVectorUInt32ZeroExtendFirstFaulting(Vector mask, Vector addresses) => GatherVectorUInt32ZeroExtendFirstFaulting(mask, addresses); + + /// + /// svint64_t svldff1uw_gather_[u64]index_s64(svbool_t pg, const uint32_t *base, svuint64_t indices) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// + public static unsafe Vector GatherVectorUInt32ZeroExtendFirstFaulting(Vector mask, uint* address, Vector indices) => GatherVectorUInt32ZeroExtendFirstFaulting(mask, address, indices); + + /// + /// svint64_t svldff1uw_gather_[s64]index_s64(svbool_t pg, const uint32_t *base, svint64_t indices) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// + public static unsafe Vector GatherVectorUInt32ZeroExtendFirstFaulting(Vector mask, uint* address, Vector indices) => GatherVectorUInt32ZeroExtendFirstFaulting(mask, address, indices); + + /// + /// svint64_t svldff1uw_gather[_u64base]_s64(svbool_t pg, svuint64_t bases) + /// LDFF1W Zresult.D, Pg/Z, [Zbases.D, #0] + /// + public static Vector GatherVectorUInt32ZeroExtendFirstFaulting(Vector mask, Vector addresses) => GatherVectorUInt32ZeroExtendFirstFaulting(mask, addresses); + + /// + /// svint64_t svldff1uw_gather_[u64]index_s64(svbool_t pg, const uint32_t *base, svuint64_t indices) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// + public static unsafe Vector GatherVectorUInt32ZeroExtendFirstFaulting(Vector mask, uint* address, Vector indices) => GatherVectorUInt32ZeroExtendFirstFaulting(mask, address, indices); + + /// + /// svuint64_t svldff1uw_gather_[s64]index_u64(svbool_t pg, const uint32_t *base, svint64_t indices) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// + public static unsafe Vector GatherVectorUInt32ZeroExtendFirstFaulting(Vector mask, uint* address, Vector indices) => GatherVectorUInt32ZeroExtendFirstFaulting(mask, address, indices); + + // + // svuint64_t svldff1uw_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + // LDFF1W Zresult.D, Pg/Z, [Zbases.D, #0] + // + // Removed as per #103297 + // public static Vector GatherVectorUInt32ZeroExtendFirstFaulting(Vector mask, Vector addresses) => GatherVectorUInt32ZeroExtendFirstFaulting(mask, addresses); + + /// + /// svuint64_t svldff1uw_gather_[u64]index_u64(svbool_t pg, const uint32_t *base, svuint64_t indices) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// + public static unsafe Vector GatherVectorUInt32ZeroExtendFirstFaulting(Vector mask, uint* address, Vector indices) => GatherVectorUInt32ZeroExtendFirstFaulting(mask, address, indices); /// - /// svfloat64_t svld1_gather_[s64]offset[_f64](svbool_t pg, const float64_t *base, svint64_t offsets) - /// LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svldff1uw_gather_[s64]index_u64(svbool_t pg, const uint32_t *base, svint64_t indices) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// + public static unsafe Vector GatherVectorUInt32ZeroExtendFirstFaulting(Vector mask, uint* address, Vector indices) => GatherVectorUInt32ZeroExtendFirstFaulting(mask, address, indices); + + /// + /// svuint64_t svldff1uw_gather[_u64base]_u64(svbool_t pg, svuint64_t bases) + /// LDFF1W Zresult.D, Pg/Z, [Zbases.D, #0] + /// + public static Vector GatherVectorUInt32ZeroExtendFirstFaulting(Vector mask, Vector addresses) => GatherVectorUInt32ZeroExtendFirstFaulting(mask, addresses); + + /// + /// svuint64_t svldff1uw_gather_[u64]index_u64(svbool_t pg, const uint32_t *base, svuint64_t indices) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, Zindices.D, LSL #2] + /// + public static unsafe Vector GatherVectorUInt32ZeroExtendFirstFaulting(Vector mask, uint* address, Vector indices) => GatherVectorUInt32ZeroExtendFirstFaulting(mask, address, indices); + + + /// Unextended load, first-faulting + + /// + /// svfloat64_t svldff1_gather_[s64]offset[_f64](svbool_t pg, const float64_t *base, svint64_t offsets) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorWithByteOffsetFirstFaulting(Vector mask, double* address, Vector offsets) => GatherVectorWithByteOffsetFirstFaulting(mask, address, offsets); + + /// + /// svfloat64_t svldff1_gather_[u64]offset[_f64](svbool_t pg, const float64_t *base, svuint64_t offsets) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorWithByteOffsetFirstFaulting(Vector mask, double* address, Vector offsets) => GatherVectorWithByteOffsetFirstFaulting(mask, address, offsets); + + /// + /// svint32_t svldff1_gather_[s32]offset[_s32](svbool_t pg, const int32_t *base, svint32_t offsets) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// + public static unsafe Vector GatherVectorWithByteOffsetFirstFaulting(Vector mask, int* address, Vector offsets) => GatherVectorWithByteOffsetFirstFaulting(mask, address, offsets); + + /// + /// svint32_t svldff1_gather_[u32]offset[_s32](svbool_t pg, const int32_t *base, svuint32_t offsets) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// + public static unsafe Vector GatherVectorWithByteOffsetFirstFaulting(Vector mask, int* address, Vector offsets) => GatherVectorWithByteOffsetFirstFaulting(mask, address, offsets); + + /// + /// svint64_t svldff1_gather_[s64]offset[_s64](svbool_t pg, const int64_t *base, svint64_t offsets) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorWithByteOffsetFirstFaulting(Vector mask, long* address, Vector offsets) => GatherVectorWithByteOffsetFirstFaulting(mask, address, offsets); + + /// + /// svint64_t svldff1_gather_[u64]offset[_s64](svbool_t pg, const int64_t *base, svuint64_t offsets) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorWithByteOffsetFirstFaulting(Vector mask, long* address, Vector offsets) => GatherVectorWithByteOffsetFirstFaulting(mask, address, offsets); + + /// + /// svfloat32_t svldff1_gather_[s32]offset[_f32](svbool_t pg, const float32_t *base, svint32_t offsets) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// + public static unsafe Vector GatherVectorWithByteOffsetFirstFaulting(Vector mask, float* address, Vector offsets) => GatherVectorWithByteOffsetFirstFaulting(mask, address, offsets); + + /// + /// svfloat32_t svldff1_gather_[u32]offset[_f32](svbool_t pg, const float32_t *base, svuint32_t offsets) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// + public static unsafe Vector GatherVectorWithByteOffsetFirstFaulting(Vector mask, float* address, Vector offsets) => GatherVectorWithByteOffsetFirstFaulting(mask, address, offsets); + + /// + /// svuint32_t svldff1_gather_[s32]offset[_u32](svbool_t pg, const uint32_t *base, svint32_t offsets) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// + public static unsafe Vector GatherVectorWithByteOffsetFirstFaulting(Vector mask, uint* address, Vector offsets) => GatherVectorWithByteOffsetFirstFaulting(mask, address, offsets); + + /// + /// svuint32_t svldff1_gather_[u32]offset[_u32](svbool_t pg, const uint32_t *base, svuint32_t offsets) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// + public static unsafe Vector GatherVectorWithByteOffsetFirstFaulting(Vector mask, uint* address, Vector offsets) => GatherVectorWithByteOffsetFirstFaulting(mask, address, offsets); + + /// + /// svuint64_t svldff1_gather_[s64]offset[_u64](svbool_t pg, const uint64_t *base, svint64_t offsets) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorWithByteOffsetFirstFaulting(Vector mask, ulong* address, Vector offsets) => GatherVectorWithByteOffsetFirstFaulting(mask, address, offsets); + + /// + /// svuint64_t svldff1_gather_[u64]offset[_u64](svbool_t pg, const uint64_t *base, svuint64_t offsets) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// + public static unsafe Vector GatherVectorWithByteOffsetFirstFaulting(Vector mask, ulong* address, Vector offsets) => GatherVectorWithByteOffsetFirstFaulting(mask, address, offsets); + + + /// Unextended load + + /// + /// svfloat64_t svld1_gather_[s64]offset[_f64](svbool_t pg, const float64_t *base, svint64_t offsets) + /// LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorWithByteOffsets(Vector mask, double* address, Vector offsets) => GatherVectorWithByteOffsets(mask, address, offsets); /// - /// svfloat64_t svld1_gather_[u64]offset[_f64](svbool_t pg, const float64_t *base, svuint64_t offsets) - /// LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svfloat64_t svld1_gather_[u64]offset[_f64](svbool_t pg, const float64_t *base, svuint64_t offsets) + /// LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorWithByteOffsets(Vector mask, double* address, Vector offsets) => GatherVectorWithByteOffsets(mask, address, offsets); /// - /// svint32_t svld1_gather_[s32]offset[_s32](svbool_t pg, const int32_t *base, svint32_t offsets) - /// LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// svint32_t svld1_gather_[s32]offset[_s32](svbool_t pg, const int32_t *base, svint32_t offsets) + /// LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] /// public static unsafe Vector GatherVectorWithByteOffsets(Vector mask, int* address, Vector offsets) => GatherVectorWithByteOffsets(mask, address, offsets); /// - /// svint32_t svld1_gather_[u32]offset[_s32](svbool_t pg, const int32_t *base, svuint32_t offsets) - /// LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// svint32_t svld1_gather_[u32]offset[_s32](svbool_t pg, const int32_t *base, svuint32_t offsets) + /// LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] /// public static unsafe Vector GatherVectorWithByteOffsets(Vector mask, int* address, Vector offsets) => GatherVectorWithByteOffsets(mask, address, offsets); /// - /// svint64_t svld1_gather_[s64]offset[_s64](svbool_t pg, const int64_t *base, svint64_t offsets) - /// LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1_gather_[s64]offset[_s64](svbool_t pg, const int64_t *base, svint64_t offsets) + /// LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorWithByteOffsets(Vector mask, long* address, Vector offsets) => GatherVectorWithByteOffsets(mask, address, offsets); /// - /// svint64_t svld1_gather_[u64]offset[_s64](svbool_t pg, const int64_t *base, svuint64_t offsets) - /// LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svint64_t svld1_gather_[u64]offset[_s64](svbool_t pg, const int64_t *base, svuint64_t offsets) + /// LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorWithByteOffsets(Vector mask, long* address, Vector offsets) => GatherVectorWithByteOffsets(mask, address, offsets); /// - /// svfloat32_t svld1_gather_[s32]offset[_f32](svbool_t pg, const float32_t *base, svint32_t offsets) - /// LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// svfloat32_t svld1_gather_[s32]offset[_f32](svbool_t pg, const float32_t *base, svint32_t offsets) + /// LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] /// public static unsafe Vector GatherVectorWithByteOffsets(Vector mask, float* address, Vector offsets) => GatherVectorWithByteOffsets(mask, address, offsets); /// - /// svfloat32_t svld1_gather_[u32]offset[_f32](svbool_t pg, const float32_t *base, svuint32_t offsets) - /// LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// svfloat32_t svld1_gather_[u32]offset[_f32](svbool_t pg, const float32_t *base, svuint32_t offsets) + /// LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] /// public static unsafe Vector GatherVectorWithByteOffsets(Vector mask, float* address, Vector offsets) => GatherVectorWithByteOffsets(mask, address, offsets); /// - /// svuint32_t svld1_gather_[s32]offset[_u32](svbool_t pg, const uint32_t *base, svint32_t offsets) - /// LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] + /// svuint32_t svld1_gather_[s32]offset[_u32](svbool_t pg, const uint32_t *base, svint32_t offsets) + /// LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, SXTW] /// public static unsafe Vector GatherVectorWithByteOffsets(Vector mask, uint* address, Vector offsets) => GatherVectorWithByteOffsets(mask, address, offsets); /// - /// svuint32_t svld1_gather_[u32]offset[_u32](svbool_t pg, const uint32_t *base, svuint32_t offsets) - /// LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] + /// svuint32_t svld1_gather_[u32]offset[_u32](svbool_t pg, const uint32_t *base, svuint32_t offsets) + /// LD1W Zresult.S, Pg/Z, [Xbase, Zoffsets.S, UXTW] /// public static unsafe Vector GatherVectorWithByteOffsets(Vector mask, uint* address, Vector offsets) => GatherVectorWithByteOffsets(mask, address, offsets); /// - /// svuint64_t svld1_gather_[s64]offset[_u64](svbool_t pg, const uint64_t *base, svint64_t offsets) - /// LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1_gather_[s64]offset[_u64](svbool_t pg, const uint64_t *base, svint64_t offsets) + /// LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorWithByteOffsets(Vector mask, ulong* address, Vector offsets) => GatherVectorWithByteOffsets(mask, address, offsets); /// - /// svuint64_t svld1_gather_[u64]offset[_u64](svbool_t pg, const uint64_t *base, svuint64_t offsets) - /// LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] + /// svuint64_t svld1_gather_[u64]offset[_u64](svbool_t pg, const uint64_t *base, svuint64_t offsets) + /// LD1D Zresult.D, Pg/Z, [Xbase, Zoffsets.D] /// public static unsafe Vector GatherVectorWithByteOffsets(Vector mask, ulong* address, Vector offsets) => GatherVectorWithByteOffsets(mask, address, offsets); @@ -4365,113 +5025,113 @@ internal Arm64() { } // Count set predicate bits /// - /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) - /// CNTP Xresult, Pg, Pop.B + /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) + /// CNTP Xresult, Pg, Pop.B /// - public static unsafe ulong GetActiveElementCount(Vector mask, Vector from) => GetActiveElementCount(mask, from); + public static ulong GetActiveElementCount(Vector mask, Vector from) => GetActiveElementCount(mask, from); /// - /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) - /// CNTP Xresult, Pg, Pop.B + /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) + /// CNTP Xresult, Pg, Pop.B /// - public static unsafe ulong GetActiveElementCount(Vector mask, Vector from) => GetActiveElementCount(mask, from); + public static ulong GetActiveElementCount(Vector mask, Vector from) => GetActiveElementCount(mask, from); /// - /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) - /// CNTP Xresult, Pg, Pop.B + /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) + /// CNTP Xresult, Pg, Pop.B /// - public static unsafe ulong GetActiveElementCount(Vector mask, Vector from) => GetActiveElementCount(mask, from); + public static ulong GetActiveElementCount(Vector mask, Vector from) => GetActiveElementCount(mask, from); /// - /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) - /// CNTP Xresult, Pg, Pop.B + /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) + /// CNTP Xresult, Pg, Pop.B /// - public static unsafe ulong GetActiveElementCount(Vector mask, Vector from) => GetActiveElementCount(mask, from); + public static ulong GetActiveElementCount(Vector mask, Vector from) => GetActiveElementCount(mask, from); /// - /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) - /// CNTP Xresult, Pg, Pop.B + /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) + /// CNTP Xresult, Pg, Pop.B /// - public static unsafe ulong GetActiveElementCount(Vector mask, Vector from) => GetActiveElementCount(mask, from); + public static ulong GetActiveElementCount(Vector mask, Vector from) => GetActiveElementCount(mask, from); /// - /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) - /// CNTP Xresult, Pg, Pop.B + /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) + /// CNTP Xresult, Pg, Pop.B /// - public static unsafe ulong GetActiveElementCount(Vector mask, Vector from) => GetActiveElementCount(mask, from); + public static ulong GetActiveElementCount(Vector mask, Vector from) => GetActiveElementCount(mask, from); /// - /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) - /// CNTP Xresult, Pg, Pop.B + /// uint64_t svcntp_b8(svbool_t pg, svbool_t op) + /// CNTP Xresult, Pg, Pop.B /// - public static unsafe ulong GetActiveElementCount(Vector mask, Vector from) => GetActiveElementCount(mask, from); + public static ulong GetActiveElementCount(Vector mask, Vector from) => GetActiveElementCount(mask, from); /// - /// uint64_t svcntp_b16(svbool_t pg, svbool_t op) - /// CNTP Xresult, Pg, Pop.H + /// uint64_t svcntp_b16(svbool_t pg, svbool_t op) + /// CNTP Xresult, Pg, Pop.H /// - public static unsafe ulong GetActiveElementCount(Vector mask, Vector from) => GetActiveElementCount(mask, from); + public static ulong GetActiveElementCount(Vector mask, Vector from) => GetActiveElementCount(mask, from); /// - /// uint64_t svcntp_b32(svbool_t pg, svbool_t op) - /// CNTP Xresult, Pg, Pop.S + /// uint64_t svcntp_b32(svbool_t pg, svbool_t op) + /// CNTP Xresult, Pg, Pop.S /// - public static unsafe ulong GetActiveElementCount(Vector mask, Vector from) => GetActiveElementCount(mask, from); + public static ulong GetActiveElementCount(Vector mask, Vector from) => GetActiveElementCount(mask, from); /// - /// uint64_t svcntp_b64(svbool_t pg, svbool_t op) - /// CNTP Xresult, Pg, Pop.D + /// uint64_t svcntp_b64(svbool_t pg, svbool_t op) + /// CNTP Xresult, Pg, Pop.D /// - public static unsafe ulong GetActiveElementCount(Vector mask, Vector from) => GetActiveElementCount(mask, from); + public static ulong GetActiveElementCount(Vector mask, Vector from) => GetActiveElementCount(mask, from); // Read FFR, returning predicate of successfully loaded elements /// - /// svbool_t svrdffr() - /// RDFFR Presult.B + /// svbool_t svrdffr() + /// RDFFR Presult.B /// public static Vector GetFfrByte() => GetFfrByte(); /// - /// svbool_t svrdffr() - /// RDFFR Presult.B + /// svbool_t svrdffr() + /// RDFFR Presult.B /// public static Vector GetFfrInt16() => GetFfrInt16(); /// - /// svbool_t svrdffr() - /// RDFFR Presult.B + /// svbool_t svrdffr() + /// RDFFR Presult.B /// public static Vector GetFfrInt32() => GetFfrInt32(); /// - /// svbool_t svrdffr() - /// RDFFR Presult.B + /// svbool_t svrdffr() + /// RDFFR Presult.B /// public static Vector GetFfrInt64() => GetFfrInt64(); /// - /// svbool_t svrdffr() - /// RDFFR Presult.B + /// svbool_t svrdffr() + /// RDFFR Presult.B /// public static Vector GetFfrSByte() => GetFfrSByte(); /// - /// svbool_t svrdffr() - /// RDFFR Presult.B + /// svbool_t svrdffr() + /// RDFFR Presult.B /// public static Vector GetFfrUInt16() => GetFfrUInt16(); /// - /// svbool_t svrdffr() - /// RDFFR Presult.B + /// svbool_t svrdffr() + /// RDFFR Presult.B /// public static Vector GetFfrUInt32() => GetFfrUInt32(); /// - /// svbool_t svrdffr() - /// RDFFR Presult.B + /// svbool_t svrdffr() + /// RDFFR Presult.B /// public static Vector GetFfrUInt64() => GetFfrUInt64(); @@ -4479,247 +5139,247 @@ internal Arm64() { } // Insert scalar into shifted vector /// - /// svuint8_t svinsr[_n_u8](svuint8_t op1, uint8_t op2) - /// INSR Ztied1.B, Wop2 - /// INSR Ztied1.B, Bop2 + /// svuint8_t svinsr[_n_u8](svuint8_t op1, uint8_t op2) + /// INSR Ztied1.B, Wop2 + /// INSR Ztied1.B, Bop2 /// - public static unsafe Vector InsertIntoShiftedVector(Vector left, byte right) => InsertIntoShiftedVector(left, right); + public static Vector InsertIntoShiftedVector(Vector left, byte right) => InsertIntoShiftedVector(left, right); /// - /// svfloat64_t svinsr[_n_f64](svfloat64_t op1, float64_t op2) - /// INSR Ztied1.D, Xop2 - /// INSR Ztied1.D, Dop2 + /// svfloat64_t svinsr[_n_f64](svfloat64_t op1, float64_t op2) + /// INSR Ztied1.D, Xop2 + /// INSR Ztied1.D, Dop2 /// - public static unsafe Vector InsertIntoShiftedVector(Vector left, double right) => InsertIntoShiftedVector(left, right); + public static Vector InsertIntoShiftedVector(Vector left, double right) => InsertIntoShiftedVector(left, right); /// - /// svint16_t svinsr[_n_s16](svint16_t op1, int16_t op2) - /// INSR Ztied1.H, Wop2 - /// INSR Ztied1.H, Hop2 + /// svint16_t svinsr[_n_s16](svint16_t op1, int16_t op2) + /// INSR Ztied1.H, Wop2 + /// INSR Ztied1.H, Hop2 /// - public static unsafe Vector InsertIntoShiftedVector(Vector left, short right) => InsertIntoShiftedVector(left, right); + public static Vector InsertIntoShiftedVector(Vector left, short right) => InsertIntoShiftedVector(left, right); /// - /// svint32_t svinsr[_n_s32](svint32_t op1, int32_t op2) - /// INSR Ztied1.S, Wop2 - /// INSR Ztied1.S, Sop2 + /// svint32_t svinsr[_n_s32](svint32_t op1, int32_t op2) + /// INSR Ztied1.S, Wop2 + /// INSR Ztied1.S, Sop2 /// - public static unsafe Vector InsertIntoShiftedVector(Vector left, int right) => InsertIntoShiftedVector(left, right); + public static Vector InsertIntoShiftedVector(Vector left, int right) => InsertIntoShiftedVector(left, right); /// - /// svint64_t svinsr[_n_s64](svint64_t op1, int64_t op2) - /// INSR Ztied1.D, Xop2 - /// INSR Ztied1.D, Dop2 + /// svint64_t svinsr[_n_s64](svint64_t op1, int64_t op2) + /// INSR Ztied1.D, Xop2 + /// INSR Ztied1.D, Dop2 /// - public static unsafe Vector InsertIntoShiftedVector(Vector left, long right) => InsertIntoShiftedVector(left, right); + public static Vector InsertIntoShiftedVector(Vector left, long right) => InsertIntoShiftedVector(left, right); /// - /// svint8_t svinsr[_n_s8](svint8_t op1, int8_t op2) - /// INSR Ztied1.B, Wop2 - /// INSR Ztied1.B, Bop2 + /// svint8_t svinsr[_n_s8](svint8_t op1, int8_t op2) + /// INSR Ztied1.B, Wop2 + /// INSR Ztied1.B, Bop2 /// - public static unsafe Vector InsertIntoShiftedVector(Vector left, sbyte right) => InsertIntoShiftedVector(left, right); + public static Vector InsertIntoShiftedVector(Vector left, sbyte right) => InsertIntoShiftedVector(left, right); /// - /// svfloat32_t svinsr[_n_f32](svfloat32_t op1, float32_t op2) - /// INSR Ztied1.S, Wop2 - /// INSR Ztied1.S, Sop2 + /// svfloat32_t svinsr[_n_f32](svfloat32_t op1, float32_t op2) + /// INSR Ztied1.S, Wop2 + /// INSR Ztied1.S, Sop2 /// - public static unsafe Vector InsertIntoShiftedVector(Vector left, float right) => InsertIntoShiftedVector(left, right); + public static Vector InsertIntoShiftedVector(Vector left, float right) => InsertIntoShiftedVector(left, right); /// - /// svuint16_t svinsr[_n_u16](svuint16_t op1, uint16_t op2) - /// INSR Ztied1.H, Wop2 - /// INSR Ztied1.H, Hop2 + /// svuint16_t svinsr[_n_u16](svuint16_t op1, uint16_t op2) + /// INSR Ztied1.H, Wop2 + /// INSR Ztied1.H, Hop2 /// - public static unsafe Vector InsertIntoShiftedVector(Vector left, ushort right) => InsertIntoShiftedVector(left, right); + public static Vector InsertIntoShiftedVector(Vector left, ushort right) => InsertIntoShiftedVector(left, right); /// - /// svuint32_t svinsr[_n_u32](svuint32_t op1, uint32_t op2) - /// INSR Ztied1.S, Wop2 - /// INSR Ztied1.S, Sop2 + /// svuint32_t svinsr[_n_u32](svuint32_t op1, uint32_t op2) + /// INSR Ztied1.S, Wop2 + /// INSR Ztied1.S, Sop2 /// - public static unsafe Vector InsertIntoShiftedVector(Vector left, uint right) => InsertIntoShiftedVector(left, right); + public static Vector InsertIntoShiftedVector(Vector left, uint right) => InsertIntoShiftedVector(left, right); /// - /// svuint64_t svinsr[_n_u64](svuint64_t op1, uint64_t op2) - /// INSR Ztied1.D, Xop2 - /// INSR Ztied1.D, Dop2 + /// svuint64_t svinsr[_n_u64](svuint64_t op1, uint64_t op2) + /// INSR Ztied1.D, Xop2 + /// INSR Ztied1.D, Dop2 /// - public static unsafe Vector InsertIntoShiftedVector(Vector left, ulong right) => InsertIntoShiftedVector(left, right); + public static Vector InsertIntoShiftedVector(Vector left, ulong right) => InsertIntoShiftedVector(left, right); // Count leading sign bits /// - /// svuint8_t svcls[_s8]_m(svuint8_t inactive, svbool_t pg, svint8_t op) - /// svuint8_t svcls[_s8]_x(svbool_t pg, svint8_t op) - /// svuint8_t svcls[_s8]_z(svbool_t pg, svint8_t op) - /// CLS Zresult.B, Pg/M, Zop.B + /// svuint8_t svcls[_s8]_m(svuint8_t inactive, svbool_t pg, svint8_t op) + /// svuint8_t svcls[_s8]_x(svbool_t pg, svint8_t op) + /// svuint8_t svcls[_s8]_z(svbool_t pg, svint8_t op) + /// CLS Zresult.B, Pg/M, Zop.B /// - public static unsafe Vector LeadingSignCount(Vector value) => LeadingSignCount(value); + public static Vector LeadingSignCount(Vector value) => LeadingSignCount(value); /// - /// svuint16_t svcls[_s16]_m(svuint16_t inactive, svbool_t pg, svint16_t op) - /// svuint16_t svcls[_s16]_x(svbool_t pg, svint16_t op) - /// svuint16_t svcls[_s16]_z(svbool_t pg, svint16_t op) - /// CLS Zresult.H, Pg/M, Zop.H + /// svuint16_t svcls[_s16]_m(svuint16_t inactive, svbool_t pg, svint16_t op) + /// svuint16_t svcls[_s16]_x(svbool_t pg, svint16_t op) + /// svuint16_t svcls[_s16]_z(svbool_t pg, svint16_t op) + /// CLS Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector LeadingSignCount(Vector value) => LeadingSignCount(value); + public static Vector LeadingSignCount(Vector value) => LeadingSignCount(value); /// - /// svuint32_t svcls[_s32]_m(svuint32_t inactive, svbool_t pg, svint32_t op) - /// svuint32_t svcls[_s32]_x(svbool_t pg, svint32_t op) - /// svuint32_t svcls[_s32]_z(svbool_t pg, svint32_t op) - /// CLS Zresult.S, Pg/M, Zop.S + /// svuint32_t svcls[_s32]_m(svuint32_t inactive, svbool_t pg, svint32_t op) + /// svuint32_t svcls[_s32]_x(svbool_t pg, svint32_t op) + /// svuint32_t svcls[_s32]_z(svbool_t pg, svint32_t op) + /// CLS Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector LeadingSignCount(Vector value) => LeadingSignCount(value); + public static Vector LeadingSignCount(Vector value) => LeadingSignCount(value); /// - /// svuint64_t svcls[_s64]_m(svuint64_t inactive, svbool_t pg, svint64_t op) - /// svuint64_t svcls[_s64]_x(svbool_t pg, svint64_t op) - /// svuint64_t svcls[_s64]_z(svbool_t pg, svint64_t op) - /// CLS Zresult.D, Pg/M, Zop.D + /// svuint64_t svcls[_s64]_m(svuint64_t inactive, svbool_t pg, svint64_t op) + /// svuint64_t svcls[_s64]_x(svbool_t pg, svint64_t op) + /// svuint64_t svcls[_s64]_z(svbool_t pg, svint64_t op) + /// CLS Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector LeadingSignCount(Vector value) => LeadingSignCount(value); + public static Vector LeadingSignCount(Vector value) => LeadingSignCount(value); // Count leading zero bits /// - /// svuint8_t svclz[_s8]_m(svuint8_t inactive, svbool_t pg, svint8_t op) - /// svuint8_t svclz[_s8]_x(svbool_t pg, svint8_t op) - /// svuint8_t svclz[_s8]_z(svbool_t pg, svint8_t op) - /// CLZ Zresult.B, Pg/M, Zop.B + /// svuint8_t svclz[_s8]_m(svuint8_t inactive, svbool_t pg, svint8_t op) + /// svuint8_t svclz[_s8]_x(svbool_t pg, svint8_t op) + /// svuint8_t svclz[_s8]_z(svbool_t pg, svint8_t op) + /// CLZ Zresult.B, Pg/M, Zop.B /// - public static unsafe Vector LeadingZeroCount(Vector value) => LeadingZeroCount(value); + public static Vector LeadingZeroCount(Vector value) => LeadingZeroCount(value); /// - /// svuint8_t svclz[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) - /// svuint8_t svclz[_u8]_x(svbool_t pg, svuint8_t op) - /// svuint8_t svclz[_u8]_z(svbool_t pg, svuint8_t op) - /// CLZ Zresult.B, Pg/M, Zop.B + /// svuint8_t svclz[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) + /// svuint8_t svclz[_u8]_x(svbool_t pg, svuint8_t op) + /// svuint8_t svclz[_u8]_z(svbool_t pg, svuint8_t op) + /// CLZ Zresult.B, Pg/M, Zop.B /// - public static unsafe Vector LeadingZeroCount(Vector value) => LeadingZeroCount(value); + public static Vector LeadingZeroCount(Vector value) => LeadingZeroCount(value); /// - /// svuint16_t svclz[_s16]_m(svuint16_t inactive, svbool_t pg, svint16_t op) - /// svuint16_t svclz[_s16]_x(svbool_t pg, svint16_t op) - /// svuint16_t svclz[_s16]_z(svbool_t pg, svint16_t op) - /// CLZ Zresult.H, Pg/M, Zop.H + /// svuint16_t svclz[_s16]_m(svuint16_t inactive, svbool_t pg, svint16_t op) + /// svuint16_t svclz[_s16]_x(svbool_t pg, svint16_t op) + /// svuint16_t svclz[_s16]_z(svbool_t pg, svint16_t op) + /// CLZ Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector LeadingZeroCount(Vector value) => LeadingZeroCount(value); + public static Vector LeadingZeroCount(Vector value) => LeadingZeroCount(value); /// - /// svuint16_t svclz[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) - /// svuint16_t svclz[_u16]_x(svbool_t pg, svuint16_t op) - /// svuint16_t svclz[_u16]_z(svbool_t pg, svuint16_t op) - /// CLZ Zresult.H, Pg/M, Zop.H + /// svuint16_t svclz[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) + /// svuint16_t svclz[_u16]_x(svbool_t pg, svuint16_t op) + /// svuint16_t svclz[_u16]_z(svbool_t pg, svuint16_t op) + /// CLZ Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector LeadingZeroCount(Vector value) => LeadingZeroCount(value); + public static Vector LeadingZeroCount(Vector value) => LeadingZeroCount(value); /// - /// svuint32_t svclz[_s32]_m(svuint32_t inactive, svbool_t pg, svint32_t op) - /// svuint32_t svclz[_s32]_x(svbool_t pg, svint32_t op) - /// svuint32_t svclz[_s32]_z(svbool_t pg, svint32_t op) - /// CLZ Zresult.S, Pg/M, Zop.S + /// svuint32_t svclz[_s32]_m(svuint32_t inactive, svbool_t pg, svint32_t op) + /// svuint32_t svclz[_s32]_x(svbool_t pg, svint32_t op) + /// svuint32_t svclz[_s32]_z(svbool_t pg, svint32_t op) + /// CLZ Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector LeadingZeroCount(Vector value) => LeadingZeroCount(value); + public static Vector LeadingZeroCount(Vector value) => LeadingZeroCount(value); /// - /// svuint32_t svclz[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) - /// svuint32_t svclz[_u32]_x(svbool_t pg, svuint32_t op) - /// svuint32_t svclz[_u32]_z(svbool_t pg, svuint32_t op) - /// CLZ Zresult.S, Pg/M, Zop.S + /// svuint32_t svclz[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) + /// svuint32_t svclz[_u32]_x(svbool_t pg, svuint32_t op) + /// svuint32_t svclz[_u32]_z(svbool_t pg, svuint32_t op) + /// CLZ Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector LeadingZeroCount(Vector value) => LeadingZeroCount(value); + public static Vector LeadingZeroCount(Vector value) => LeadingZeroCount(value); /// - /// svuint64_t svclz[_s64]_m(svuint64_t inactive, svbool_t pg, svint64_t op) - /// svuint64_t svclz[_s64]_x(svbool_t pg, svint64_t op) - /// svuint64_t svclz[_s64]_z(svbool_t pg, svint64_t op) - /// CLZ Zresult.D, Pg/M, Zop.D + /// svuint64_t svclz[_s64]_m(svuint64_t inactive, svbool_t pg, svint64_t op) + /// svuint64_t svclz[_s64]_x(svbool_t pg, svint64_t op) + /// svuint64_t svclz[_s64]_z(svbool_t pg, svint64_t op) + /// CLZ Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector LeadingZeroCount(Vector value) => LeadingZeroCount(value); + public static Vector LeadingZeroCount(Vector value) => LeadingZeroCount(value); /// - /// svuint64_t svclz[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) - /// svuint64_t svclz[_u64]_x(svbool_t pg, svuint64_t op) - /// svuint64_t svclz[_u64]_z(svbool_t pg, svuint64_t op) - /// CLZ Zresult.D, Pg/M, Zop.D + /// svuint64_t svclz[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) + /// svuint64_t svclz[_u64]_x(svbool_t pg, svuint64_t op) + /// svuint64_t svclz[_u64]_z(svbool_t pg, svuint64_t op) + /// CLZ Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector LeadingZeroCount(Vector value) => LeadingZeroCount(value); + public static Vector LeadingZeroCount(Vector value) => LeadingZeroCount(value); // Unextended load /// - /// svuint8_t svld1[_u8](svbool_t pg, const uint8_t *base) - /// LD1B Zresult.B, Pg/Z, [Xarray, Xindex] - /// LD1B Zresult.B, Pg/Z, [Xbase, #0, MUL VL] + /// svuint8_t svld1[_u8](svbool_t pg, const uint8_t *base) + /// LD1B Zresult.B, Pg/Z, [Xarray, Xindex] + /// LD1B Zresult.B, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVector(Vector mask, byte* address) => LoadVector(mask, address); /// - /// svfloat64_t svld1[_f64](svbool_t pg, const float64_t *base) - /// LD1D Zresult.D, Pg/Z, [Xarray, Xindex, LSL #3] - /// LD1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svfloat64_t svld1[_f64](svbool_t pg, const float64_t *base) + /// LD1D Zresult.D, Pg/Z, [Xarray, Xindex, LSL #3] + /// LD1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVector(Vector mask, double* address) => LoadVector(mask, address); /// - /// svint16_t svld1[_s16](svbool_t pg, const int16_t *base) - /// LD1H Zresult.H, Pg/Z, [Xarray, Xindex, LSL #1] - /// LD1H Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svint16_t svld1[_s16](svbool_t pg, const int16_t *base) + /// LD1H Zresult.H, Pg/Z, [Xarray, Xindex, LSL #1] + /// LD1H Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVector(Vector mask, short* address) => LoadVector(mask, address); /// - /// svint32_t svld1[_s32](svbool_t pg, const int32_t *base) - /// LD1W Zresult.S, Pg/Z, [Xarray, Xindex, LSL #2] - /// LD1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svint32_t svld1[_s32](svbool_t pg, const int32_t *base) + /// LD1W Zresult.S, Pg/Z, [Xarray, Xindex, LSL #2] + /// LD1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVector(Vector mask, int* address) => LoadVector(mask, address); /// - /// svint64_t svld1[_s64](svbool_t pg, const int64_t *base) - /// LD1D Zresult.D, Pg/Z, [Xarray, Xindex, LSL #3] - /// LD1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svld1[_s64](svbool_t pg, const int64_t *base) + /// LD1D Zresult.D, Pg/Z, [Xarray, Xindex, LSL #3] + /// LD1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVector(Vector mask, long* address) => LoadVector(mask, address); /// - /// svint8_t svld1[_s8](svbool_t pg, const int8_t *base) - /// LD1B Zresult.B, Pg/Z, [Xarray, Xindex] - /// LD1B Zresult.B, Pg/Z, [Xbase, #0, MUL VL] + /// svint8_t svld1[_s8](svbool_t pg, const int8_t *base) + /// LD1B Zresult.B, Pg/Z, [Xarray, Xindex] + /// LD1B Zresult.B, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVector(Vector mask, sbyte* address) => LoadVector(mask, address); /// - /// svfloat32_t svld1[_f32](svbool_t pg, const float32_t *base) - /// LD1W Zresult.S, Pg/Z, [Xarray, Xindex, LSL #2] - /// LD1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svfloat32_t svld1[_f32](svbool_t pg, const float32_t *base) + /// LD1W Zresult.S, Pg/Z, [Xarray, Xindex, LSL #2] + /// LD1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVector(Vector mask, float* address) => LoadVector(mask, address); /// - /// svuint16_t svld1[_u16](svbool_t pg, const uint16_t *base) - /// LD1H Zresult.H, Pg/Z, [Xarray, Xindex, LSL #1] - /// LD1H Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svuint16_t svld1[_u16](svbool_t pg, const uint16_t *base) + /// LD1H Zresult.H, Pg/Z, [Xarray, Xindex, LSL #1] + /// LD1H Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVector(Vector mask, ushort* address) => LoadVector(mask, address); /// - /// svuint32_t svld1[_u32](svbool_t pg, const uint32_t *base) - /// LD1W Zresult.S, Pg/Z, [Xarray, Xindex, LSL #2] - /// LD1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32_t svld1[_u32](svbool_t pg, const uint32_t *base) + /// LD1W Zresult.S, Pg/Z, [Xarray, Xindex, LSL #2] + /// LD1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVector(Vector mask, uint* address) => LoadVector(mask, address); /// - /// svuint64_t svld1[_u64](svbool_t pg, const uint64_t *base) - /// LD1D Zresult.D, Pg/Z, [Xarray, Xindex, LSL #3] - /// LD1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svld1[_u64](svbool_t pg, const uint64_t *base) + /// LD1D Zresult.D, Pg/Z, [Xarray, Xindex, LSL #3] + /// LD1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVector(Vector mask, ulong* address) => LoadVector(mask, address); @@ -4727,62 +5387,62 @@ internal Arm64() { } // Load and replicate 128 bits of data /// - /// svuint8_t svld1rq[_u8](svbool_t pg, const uint8_t *base) - /// LD1RQB Zresult.B, Pg/Z, [Xbase, #0] + /// svuint8_t svld1rq[_u8](svbool_t pg, const uint8_t *base) + /// LD1RQB Zresult.B, Pg/Z, [Xbase, #0] /// public static unsafe Vector LoadVector128AndReplicateToVector(Vector mask, byte* address) => LoadVector128AndReplicateToVector(mask, address); /// - /// svfloat64_t svld1rq[_f64](svbool_t pg, const float64_t *base) - /// LD1RQD Zresult.D, Pg/Z, [Xbase, #0] + /// svfloat64_t svld1rq[_f64](svbool_t pg, const float64_t *base) + /// LD1RQD Zresult.D, Pg/Z, [Xbase, #0] /// public static unsafe Vector LoadVector128AndReplicateToVector(Vector mask, double* address) => LoadVector128AndReplicateToVector(mask, address); /// - /// svint16_t svld1rq[_s16](svbool_t pg, const int16_t *base) - /// LD1RQH Zresult.H, Pg/Z, [Xbase, #0] + /// svint16_t svld1rq[_s16](svbool_t pg, const int16_t *base) + /// LD1RQH Zresult.H, Pg/Z, [Xbase, #0] /// public static unsafe Vector LoadVector128AndReplicateToVector(Vector mask, short* address) => LoadVector128AndReplicateToVector(mask, address); /// - /// svint32_t svld1rq[_s32](svbool_t pg, const int32_t *base) - /// LD1RQW Zresult.S, Pg/Z, [Xbase, #0] + /// svint32_t svld1rq[_s32](svbool_t pg, const int32_t *base) + /// LD1RQW Zresult.S, Pg/Z, [Xbase, #0] /// public static unsafe Vector LoadVector128AndReplicateToVector(Vector mask, int* address) => LoadVector128AndReplicateToVector(mask, address); /// - /// svint64_t svld1rq[_s64](svbool_t pg, const int64_t *base) - /// LD1RQD Zresult.D, Pg/Z, [Xbase, #0] + /// svint64_t svld1rq[_s64](svbool_t pg, const int64_t *base) + /// LD1RQD Zresult.D, Pg/Z, [Xbase, #0] /// public static unsafe Vector LoadVector128AndReplicateToVector(Vector mask, long* address) => LoadVector128AndReplicateToVector(mask, address); /// - /// svint8_t svld1rq[_s8](svbool_t pg, const int8_t *base) - /// LD1RQB Zresult.B, Pg/Z, [Xbase, #0] + /// svint8_t svld1rq[_s8](svbool_t pg, const int8_t *base) + /// LD1RQB Zresult.B, Pg/Z, [Xbase, #0] /// public static unsafe Vector LoadVector128AndReplicateToVector(Vector mask, sbyte* address) => LoadVector128AndReplicateToVector(mask, address); /// - /// svfloat32_t svld1rq[_f32](svbool_t pg, const float32_t *base) - /// LD1RQW Zresult.S, Pg/Z, [Xbase, #0] + /// svfloat32_t svld1rq[_f32](svbool_t pg, const float32_t *base) + /// LD1RQW Zresult.S, Pg/Z, [Xbase, #0] /// public static unsafe Vector LoadVector128AndReplicateToVector(Vector mask, float* address) => LoadVector128AndReplicateToVector(mask, address); /// - /// svuint16_t svld1rq[_u16](svbool_t pg, const uint16_t *base) - /// LD1RQH Zresult.H, Pg/Z, [Xbase, #0] + /// svuint16_t svld1rq[_u16](svbool_t pg, const uint16_t *base) + /// LD1RQH Zresult.H, Pg/Z, [Xbase, #0] /// public static unsafe Vector LoadVector128AndReplicateToVector(Vector mask, ushort* address) => LoadVector128AndReplicateToVector(mask, address); /// - /// svuint32_t svld1rq[_u32](svbool_t pg, const uint32_t *base) - /// LD1RQW Zresult.S, Pg/Z, [Xbase, #0] + /// svuint32_t svld1rq[_u32](svbool_t pg, const uint32_t *base) + /// LD1RQW Zresult.S, Pg/Z, [Xbase, #0] /// public static unsafe Vector LoadVector128AndReplicateToVector(Vector mask, uint* address) => LoadVector128AndReplicateToVector(mask, address); /// - /// svuint64_t svld1rq[_u64](svbool_t pg, const uint64_t *base) - /// LD1RQD Zresult.D, Pg/Z, [Xbase, #0] + /// svuint64_t svld1rq[_u64](svbool_t pg, const uint64_t *base) + /// LD1RQD Zresult.D, Pg/Z, [Xbase, #0] /// public static unsafe Vector LoadVector128AndReplicateToVector(Vector mask, ulong* address) => LoadVector128AndReplicateToVector(mask, address); @@ -4790,8 +5450,8 @@ internal Arm64() { } // Load 8-bit data and zero-extend, non-faulting /// - /// svint16_t svldnf1ub_s16(svbool_t pg, const uint8_t *base) - /// LDNF1B Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svint16_t svldnf1ub_s16(svbool_t pg, const uint8_t *base) + /// LDNF1B Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorByteNonFaultingZeroExtendToInt16(byte* address) => LoadVectorByteNonFaultingZeroExtendToInt16(address); @@ -4799,8 +5459,8 @@ internal Arm64() { } // Load 8-bit data and zero-extend, non-faulting /// - /// svint32_t svldnf1ub_s32(svbool_t pg, const uint8_t *base) - /// LDNF1B Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svint32_t svldnf1ub_s32(svbool_t pg, const uint8_t *base) + /// LDNF1B Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorByteNonFaultingZeroExtendToInt32(byte* address) => LoadVectorByteNonFaultingZeroExtendToInt32(address); @@ -4808,8 +5468,8 @@ internal Arm64() { } // Load 8-bit data and zero-extend, non-faulting /// - /// svint64_t svldnf1ub_s64(svbool_t pg, const uint8_t *base) - /// LDNF1B Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svldnf1ub_s64(svbool_t pg, const uint8_t *base) + /// LDNF1B Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorByteNonFaultingZeroExtendToInt64(byte* address) => LoadVectorByteNonFaultingZeroExtendToInt64(address); @@ -4817,8 +5477,8 @@ internal Arm64() { } // Load 8-bit data and zero-extend, non-faulting /// - /// svuint16_t svldnf1ub_u16(svbool_t pg, const uint8_t *base) - /// LDNF1B Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svuint16_t svldnf1ub_u16(svbool_t pg, const uint8_t *base) + /// LDNF1B Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorByteNonFaultingZeroExtendToUInt16(byte* address) => LoadVectorByteNonFaultingZeroExtendToUInt16(address); @@ -4826,8 +5486,8 @@ internal Arm64() { } // Load 8-bit data and zero-extend, non-faulting /// - /// svuint32_t svldnf1ub_u32(svbool_t pg, const uint8_t *base) - /// LDNF1B Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32_t svldnf1ub_u32(svbool_t pg, const uint8_t *base) + /// LDNF1B Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorByteNonFaultingZeroExtendToUInt32(byte* address) => LoadVectorByteNonFaultingZeroExtendToUInt32(address); @@ -4835,45 +5495,45 @@ internal Arm64() { } // Load 8-bit data and zero-extend, non-faulting /// - /// svuint64_t svldnf1ub_u64(svbool_t pg, const uint8_t *base) - /// LDNF1B Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svldnf1ub_u64(svbool_t pg, const uint8_t *base) + /// LDNF1B Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorByteNonFaultingZeroExtendToUInt64(byte* address) => LoadVectorByteNonFaultingZeroExtendToUInt64(address); /// - /// svint16_t svldff1ub_s16(svbool_t pg, const uint8_t *base) - /// LDFF1B Zresult.H, Pg/Z, [Xbase, XZR] + /// svint16_t svldff1ub_s16(svbool_t pg, const uint8_t *base) + /// LDFF1B Zresult.H, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorByteZeroExtendFirstFaulting(Vector mask, byte* address) => LoadVectorByteZeroExtendFirstFaulting(mask, address); /// - /// svint32_t svldff1ub_s32(svbool_t pg, const uint8_t *base) - /// LDFF1B Zresult.S, Pg/Z, [Xbase, XZR] + /// svint32_t svldff1ub_s32(svbool_t pg, const uint8_t *base) + /// LDFF1B Zresult.S, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorByteZeroExtendFirstFaulting(Vector mask, byte* address) => LoadVectorByteZeroExtendFirstFaulting(mask, address); /// - /// svint64_t svldff1ub_s64(svbool_t pg, const uint8_t *base) - /// LDFF1B Zresult.D, Pg/Z, [Xbase, XZR] + /// svint64_t svldff1ub_s64(svbool_t pg, const uint8_t *base) + /// LDFF1B Zresult.D, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorByteZeroExtendFirstFaulting(Vector mask, byte* address) => LoadVectorByteZeroExtendFirstFaulting(mask, address); /// - /// svuint16_t svldff1ub_u16(svbool_t pg, const uint8_t *base) - /// LDFF1B Zresult.H, Pg/Z, [Xbase, XZR] + /// svuint16_t svldff1ub_u16(svbool_t pg, const uint8_t *base) + /// LDFF1B Zresult.H, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorByteZeroExtendFirstFaulting(Vector mask, byte* address) => LoadVectorByteZeroExtendFirstFaulting(mask, address); /// - /// svuint32_t svldff1ub_u32(svbool_t pg, const uint8_t *base) - /// LDFF1B Zresult.S, Pg/Z, [Xbase, XZR] + /// svuint32_t svldff1ub_u32(svbool_t pg, const uint8_t *base) + /// LDFF1B Zresult.S, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorByteZeroExtendFirstFaulting(Vector mask, byte* address) => LoadVectorByteZeroExtendFirstFaulting(mask, address); /// - /// svuint64_t svldff1ub_u64(svbool_t pg, const uint8_t *base) - /// LDFF1B Zresult.D, Pg/Z, [Xbase, XZR] + /// svuint64_t svldff1ub_u64(svbool_t pg, const uint8_t *base) + /// LDFF1B Zresult.D, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorByteZeroExtendFirstFaulting(Vector mask, byte* address) => LoadVectorByteZeroExtendFirstFaulting(mask, address); @@ -4881,8 +5541,8 @@ internal Arm64() { } // Load 8-bit data and zero-extend /// - /// svint16_t svld1ub_s16(svbool_t pg, const uint8_t *base) - /// LD1B Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svint16_t svld1ub_s16(svbool_t pg, const uint8_t *base) + /// LD1B Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorByteZeroExtendToInt16(Vector mask, byte* address) => LoadVectorByteZeroExtendToInt16(mask, address); @@ -4890,8 +5550,8 @@ internal Arm64() { } // Load 8-bit data and zero-extend /// - /// svint32_t svld1ub_s32(svbool_t pg, const uint8_t *base) - /// LD1B Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svint32_t svld1ub_s32(svbool_t pg, const uint8_t *base) + /// LD1B Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorByteZeroExtendToInt32(Vector mask, byte* address) => LoadVectorByteZeroExtendToInt32(mask, address); @@ -4899,8 +5559,8 @@ internal Arm64() { } // Load 8-bit data and zero-extend /// - /// svint64_t svld1ub_s64(svbool_t pg, const uint8_t *base) - /// LD1B Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svld1ub_s64(svbool_t pg, const uint8_t *base) + /// LD1B Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorByteZeroExtendToInt64(Vector mask, byte* address) => LoadVectorByteZeroExtendToInt64(mask, address); @@ -4908,8 +5568,8 @@ internal Arm64() { } // Load 8-bit data and zero-extend /// - /// svuint16_t svld1ub_u16(svbool_t pg, const uint8_t *base) - /// LD1B Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svuint16_t svld1ub_u16(svbool_t pg, const uint8_t *base) + /// LD1B Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorByteZeroExtendToUInt16(Vector mask, byte* address) => LoadVectorByteZeroExtendToUInt16(mask, address); @@ -4917,8 +5577,8 @@ internal Arm64() { } // Load 8-bit data and zero-extend /// - /// svuint32_t svld1ub_u32(svbool_t pg, const uint8_t *base) - /// LD1B Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32_t svld1ub_u32(svbool_t pg, const uint8_t *base) + /// LD1B Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorByteZeroExtendToUInt32(Vector mask, byte* address) => LoadVectorByteZeroExtendToUInt32(mask, address); @@ -4926,8 +5586,8 @@ internal Arm64() { } // Load 8-bit data and zero-extend /// - /// svuint64_t svld1ub_u64(svbool_t pg, const uint8_t *base) - /// LD1B Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svld1ub_u64(svbool_t pg, const uint8_t *base) + /// LD1B Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorByteZeroExtendToUInt64(Vector mask, byte* address) => LoadVectorByteZeroExtendToUInt64(mask, address); @@ -4935,69 +5595,69 @@ internal Arm64() { } // Unextended load, first-faulting /// - /// svuint8_t svldff1[_u8](svbool_t pg, const uint8_t *base) - /// LDFF1B Zresult.B, Pg/Z, [Xbase, XZR] + /// svuint8_t svldff1[_u8](svbool_t pg, const uint8_t *base) + /// LDFF1B Zresult.B, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorFirstFaulting(Vector mask, byte* address) => LoadVectorFirstFaulting(mask, address); /// - /// svfloat64_t svldff1[_f64](svbool_t pg, const float64_t *base) - /// LDFF1D Zresult.D, Pg/Z, [Xbase, XZR, LSL #3] + /// svfloat64_t svldff1[_f64](svbool_t pg, const float64_t *base) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, XZR, LSL #3] /// public static unsafe Vector LoadVectorFirstFaulting(Vector mask, double* address) => LoadVectorFirstFaulting(mask, address); /// - /// svint16_t svldff1[_s16](svbool_t pg, const int16_t *base) - /// LDFF1H Zresult.H, Pg/Z, [Xbase, XZR, LSL #1] + /// svint16_t svldff1[_s16](svbool_t pg, const int16_t *base) + /// LDFF1H Zresult.H, Pg/Z, [Xbase, XZR, LSL #1] /// public static unsafe Vector LoadVectorFirstFaulting(Vector mask, short* address) => LoadVectorFirstFaulting(mask, address); /// - /// svint32_t svldff1[_s32](svbool_t pg, const int32_t *base) - /// LDFF1W Zresult.S, Pg/Z, [Xbase, XZR, LSL #2] + /// svint32_t svldff1[_s32](svbool_t pg, const int32_t *base) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, XZR, LSL #2] /// public static unsafe Vector LoadVectorFirstFaulting(Vector mask, int* address) => LoadVectorFirstFaulting(mask, address); /// - /// svint64_t svldff1[_s64](svbool_t pg, const int64_t *base) - /// LDFF1D Zresult.D, Pg/Z, [Xbase, XZR, LSL #3] + /// svint64_t svldff1[_s64](svbool_t pg, const int64_t *base) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, XZR, LSL #3] /// public static unsafe Vector LoadVectorFirstFaulting(Vector mask, long* address) => LoadVectorFirstFaulting(mask, address); /// - /// svint8_t svldff1[_s8](svbool_t pg, const int8_t *base) - /// LDFF1B Zresult.B, Pg/Z, [Xbase, XZR] + /// svint8_t svldff1[_s8](svbool_t pg, const int8_t *base) + /// LDFF1B Zresult.B, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorFirstFaulting(Vector mask, sbyte* address) => LoadVectorFirstFaulting(mask, address); /// - /// svfloat32_t svldff1[_f32](svbool_t pg, const float32_t *base) - /// LDFF1W Zresult.S, Pg/Z, [Xbase, XZR, LSL #2] + /// svfloat32_t svldff1[_f32](svbool_t pg, const float32_t *base) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, XZR, LSL #2] /// public static unsafe Vector LoadVectorFirstFaulting(Vector mask, float* address) => LoadVectorFirstFaulting(mask, address); /// - /// svuint16_t svldff1[_u16](svbool_t pg, const uint16_t *base) - /// LDFF1H Zresult.H, Pg/Z, [Xbase, XZR, LSL #1] + /// svuint16_t svldff1[_u16](svbool_t pg, const uint16_t *base) + /// LDFF1H Zresult.H, Pg/Z, [Xbase, XZR, LSL #1] /// public static unsafe Vector LoadVectorFirstFaulting(Vector mask, ushort* address) => LoadVectorFirstFaulting(mask, address); /// - /// svuint32_t svldff1[_u32](svbool_t pg, const uint32_t *base) - /// LDFF1W Zresult.S, Pg/Z, [Xbase, XZR, LSL #2] + /// svuint32_t svldff1[_u32](svbool_t pg, const uint32_t *base) + /// LDFF1W Zresult.S, Pg/Z, [Xbase, XZR, LSL #2] /// public static unsafe Vector LoadVectorFirstFaulting(Vector mask, uint* address) => LoadVectorFirstFaulting(mask, address); /// - /// svuint64_t svldff1[_u64](svbool_t pg, const uint64_t *base) - /// LDFF1D Zresult.D, Pg/Z, [Xbase, XZR, LSL #3] + /// svuint64_t svldff1[_u64](svbool_t pg, const uint64_t *base) + /// LDFF1D Zresult.D, Pg/Z, [Xbase, XZR, LSL #3] /// public static unsafe Vector LoadVectorFirstFaulting(Vector mask, ulong* address) => LoadVectorFirstFaulting(mask, address); // Load 16-bit data and sign-extend, non-faulting /// - /// svint32_t svldnf1sh_s32(svbool_t pg, const int16_t *base) - /// LDNF1SH Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svint32_t svldnf1sh_s32(svbool_t pg, const int16_t *base) + /// LDNF1SH Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorInt16NonFaultingSignExtendToInt32(short* address) => LoadVectorInt16NonFaultingSignExtendToInt32(address); @@ -5005,8 +5665,8 @@ internal Arm64() { } // Load 16-bit data and sign-extend, non-faulting /// - /// svint64_t svldnf1sh_s64(svbool_t pg, const int16_t *base) - /// LDNF1SH Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svldnf1sh_s64(svbool_t pg, const int16_t *base) + /// LDNF1SH Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorInt16NonFaultingSignExtendToInt64(short* address) => LoadVectorInt16NonFaultingSignExtendToInt64(address); @@ -5014,8 +5674,8 @@ internal Arm64() { } // Load 16-bit data and sign-extend, non-faulting /// - /// svuint32_t svldnf1sh_u32(svbool_t pg, const int16_t *base) - /// LDNF1SH Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32_t svldnf1sh_u32(svbool_t pg, const int16_t *base) + /// LDNF1SH Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorInt16NonFaultingSignExtendToUInt32(short* address) => LoadVectorInt16NonFaultingSignExtendToUInt32(address); @@ -5023,35 +5683,35 @@ internal Arm64() { } // Load 16-bit data and sign-extend, non-faulting /// - /// svuint64_t svldnf1sh_u64(svbool_t pg, const int16_t *base) - /// LDNF1SH Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svldnf1sh_u64(svbool_t pg, const int16_t *base) + /// LDNF1SH Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorInt16NonFaultingSignExtendToUInt64(short* address) => LoadVectorInt16NonFaultingSignExtendToUInt64(address); - /// Load 16-bit data and sign-extend, first-faulting + /// Load 16-bit data and sign-extend, first-faulting /// - /// svint32_t svldff1sh_s32(svbool_t pg, const int16_t *base) - /// LDFF1SH Zresult.S, Pg/Z, [Xbase, XZR, LSL #1] + /// svint32_t svldff1sh_s32(svbool_t pg, const int16_t *base) + /// LDFF1SH Zresult.S, Pg/Z, [Xbase, XZR, LSL #1] /// public static unsafe Vector LoadVectorInt16SignExtendFirstFaulting(Vector mask, short* address) => LoadVectorInt16SignExtendFirstFaulting(mask, address); /// - /// svint64_t svldff1sh_s64(svbool_t pg, const int16_t *base) - /// LDFF1SH Zresult.D, Pg/Z, [Xbase, XZR, LSL #1] + /// svint64_t svldff1sh_s64(svbool_t pg, const int16_t *base) + /// LDFF1SH Zresult.D, Pg/Z, [Xbase, XZR, LSL #1] /// public static unsafe Vector LoadVectorInt16SignExtendFirstFaulting(Vector mask, short* address) => LoadVectorInt16SignExtendFirstFaulting(mask, address); /// - /// svuint32_t svldff1sh_u32(svbool_t pg, const int16_t *base) - /// LDFF1SH Zresult.S, Pg/Z, [Xbase, XZR, LSL #1] + /// svuint32_t svldff1sh_u32(svbool_t pg, const int16_t *base) + /// LDFF1SH Zresult.S, Pg/Z, [Xbase, XZR, LSL #1] /// public static unsafe Vector LoadVectorInt16SignExtendFirstFaulting(Vector mask, short* address) => LoadVectorInt16SignExtendFirstFaulting(mask, address); /// - /// svuint64_t svldff1sh_u64(svbool_t pg, const int16_t *base) - /// LDFF1SH Zresult.D, Pg/Z, [Xbase, XZR, LSL #1] + /// svuint64_t svldff1sh_u64(svbool_t pg, const int16_t *base) + /// LDFF1SH Zresult.D, Pg/Z, [Xbase, XZR, LSL #1] /// public static unsafe Vector LoadVectorInt16SignExtendFirstFaulting(Vector mask, short* address) => LoadVectorInt16SignExtendFirstFaulting(mask, address); @@ -5059,8 +5719,8 @@ internal Arm64() { } // Load 16-bit data and sign-extend /// - /// svint32_t svld1sh_s32(svbool_t pg, const int16_t *base) - /// LD1SH Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svint32_t svld1sh_s32(svbool_t pg, const int16_t *base) + /// LD1SH Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorInt16SignExtendToInt32(Vector mask, short* address) => LoadVectorInt16SignExtendToInt32(mask, address); @@ -5068,8 +5728,8 @@ internal Arm64() { } // Load 16-bit data and sign-extend /// - /// svint64_t svld1sh_s64(svbool_t pg, const int16_t *base) - /// LD1SH Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svld1sh_s64(svbool_t pg, const int16_t *base) + /// LD1SH Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorInt16SignExtendToInt64(Vector mask, short* address) => LoadVectorInt16SignExtendToInt64(mask, address); @@ -5077,8 +5737,8 @@ internal Arm64() { } // Load 16-bit data and sign-extend /// - /// svuint32_t svld1sh_u32(svbool_t pg, const int16_t *base) - /// LD1SH Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32_t svld1sh_u32(svbool_t pg, const int16_t *base) + /// LD1SH Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorInt16SignExtendToUInt32(Vector mask, short* address) => LoadVectorInt16SignExtendToUInt32(mask, address); @@ -5086,8 +5746,8 @@ internal Arm64() { } // Load 16-bit data and sign-extend /// - /// svuint64_t svld1sh_u64(svbool_t pg, const int16_t *base) - /// LD1SH Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svld1sh_u64(svbool_t pg, const int16_t *base) + /// LD1SH Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorInt16SignExtendToUInt64(Vector mask, short* address) => LoadVectorInt16SignExtendToUInt64(mask, address); @@ -5095,8 +5755,8 @@ internal Arm64() { } // Load 32-bit data and sign-extend, non-faulting /// - /// svint64_t svldnf1sw_s64(svbool_t pg, const int32_t *base) - /// LDNF1SW Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svldnf1sw_s64(svbool_t pg, const int32_t *base) + /// LDNF1SW Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorInt32NonFaultingSignExtendToInt64(int* address) => LoadVectorInt32NonFaultingSignExtendToInt64(address); @@ -5104,23 +5764,23 @@ internal Arm64() { } // Load 32-bit data and sign-extend, non-faulting /// - /// svuint64_t svldnf1sw_u64(svbool_t pg, const int32_t *base) - /// LDNF1SW Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svldnf1sw_u64(svbool_t pg, const int32_t *base) + /// LDNF1SW Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorInt32NonFaultingSignExtendToUInt64(int* address) => LoadVectorInt32NonFaultingSignExtendToUInt64(address); - /// Load 32-bit data and sign-extend, first-faulting + /// Load 32-bit data and sign-extend, first-faulting /// - /// svint64_t svldff1sw_s64(svbool_t pg, const int32_t *base) - /// LDFF1SW Zresult.D, Pg/Z, [Xbase, XZR, LSL #2] + /// svint64_t svldff1sw_s64(svbool_t pg, const int32_t *base) + /// LDFF1SW Zresult.D, Pg/Z, [Xbase, XZR, LSL #2] /// public static unsafe Vector LoadVectorInt32SignExtendFirstFaulting(Vector mask, int* address) => LoadVectorInt32SignExtendFirstFaulting(mask, address); /// - /// svuint64_t svldff1sw_u64(svbool_t pg, const int32_t *base) - /// LDFF1SW Zresult.D, Pg/Z, [Xbase, XZR, LSL #2] + /// svuint64_t svldff1sw_u64(svbool_t pg, const int32_t *base) + /// LDFF1SW Zresult.D, Pg/Z, [Xbase, XZR, LSL #2] /// public static unsafe Vector LoadVectorInt32SignExtendFirstFaulting(Vector mask, int* address) => LoadVectorInt32SignExtendFirstFaulting(mask, address); @@ -5128,8 +5788,8 @@ internal Arm64() { } // Load 32-bit data and sign-extend /// - /// svint64_t svld1sw_s64(svbool_t pg, const int32_t *base) - /// LD1SW Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svld1sw_s64(svbool_t pg, const int32_t *base) + /// LD1SW Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorInt32SignExtendToInt64(Vector mask, int* address) => LoadVectorInt32SignExtendToInt64(mask, address); @@ -5137,8 +5797,8 @@ internal Arm64() { } // Load 32-bit data and sign-extend /// - /// svuint64_t svld1sw_u64(svbool_t pg, const int32_t *base) - /// LD1SW Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svld1sw_u64(svbool_t pg, const int32_t *base) + /// LD1SW Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorInt32SignExtendToUInt64(Vector mask, int* address) => LoadVectorInt32SignExtendToUInt64(mask, address); @@ -5146,62 +5806,62 @@ internal Arm64() { } // Unextended load, non-faulting /// - /// svuint8_t svldnf1[_u8](svbool_t pg, const uint8_t *base) - /// LDNF1B Zresult.B, Pg/Z, [Xbase, #0, MUL VL] + /// svuint8_t svldnf1[_u8](svbool_t pg, const uint8_t *base) + /// LDNF1B Zresult.B, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonFaulting(byte* address) => LoadVectorNonFaulting(address); /// - /// svfloat64_t svldnf1[_f64](svbool_t pg, const float64_t *base) - /// LDNF1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svfloat64_t svldnf1[_f64](svbool_t pg, const float64_t *base) + /// LDNF1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonFaulting(double* address) => LoadVectorNonFaulting(address); /// - /// svint16_t svldnf1[_s16](svbool_t pg, const int16_t *base) - /// LDNF1H Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svint16_t svldnf1[_s16](svbool_t pg, const int16_t *base) + /// LDNF1H Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonFaulting(short* address) => LoadVectorNonFaulting(address); /// - /// svint32_t svldnf1[_s32](svbool_t pg, const int32_t *base) - /// LDNF1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svint32_t svldnf1[_s32](svbool_t pg, const int32_t *base) + /// LDNF1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonFaulting(int* address) => LoadVectorNonFaulting(address); /// - /// svint64_t svldnf1[_s64](svbool_t pg, const int64_t *base) - /// LDNF1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svldnf1[_s64](svbool_t pg, const int64_t *base) + /// LDNF1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonFaulting(long* address) => LoadVectorNonFaulting(address); /// - /// svint8_t svldnf1[_s8](svbool_t pg, const int8_t *base) - /// LDNF1B Zresult.B, Pg/Z, [Xbase, #0, MUL VL] + /// svint8_t svldnf1[_s8](svbool_t pg, const int8_t *base) + /// LDNF1B Zresult.B, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonFaulting(sbyte* address) => LoadVectorNonFaulting(address); /// - /// svfloat32_t svldnf1[_f32](svbool_t pg, const float32_t *base) - /// LDNF1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svfloat32_t svldnf1[_f32](svbool_t pg, const float32_t *base) + /// LDNF1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonFaulting(float* address) => LoadVectorNonFaulting(address); /// - /// svuint16_t svldnf1[_u16](svbool_t pg, const uint16_t *base) - /// LDNF1H Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svuint16_t svldnf1[_u16](svbool_t pg, const uint16_t *base) + /// LDNF1H Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonFaulting(ushort* address) => LoadVectorNonFaulting(address); /// - /// svuint32_t svldnf1[_u32](svbool_t pg, const uint32_t *base) - /// LDNF1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32_t svldnf1[_u32](svbool_t pg, const uint32_t *base) + /// LDNF1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonFaulting(uint* address) => LoadVectorNonFaulting(address); /// - /// svuint64_t svldnf1[_u64](svbool_t pg, const uint64_t *base) - /// LDNF1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svldnf1[_u64](svbool_t pg, const uint64_t *base) + /// LDNF1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonFaulting(ulong* address) => LoadVectorNonFaulting(address); @@ -5209,62 +5869,62 @@ internal Arm64() { } // Unextended load, non-temporal /// - /// svuint8_t svldnt1[_u8](svbool_t pg, const uint8_t *base) - /// LDNT1B Zresult.B, Pg/Z, [Xbase, #0, MUL VL] + /// svuint8_t svldnt1[_u8](svbool_t pg, const uint8_t *base) + /// LDNT1B Zresult.B, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonTemporal(Vector mask, byte* address) => LoadVectorNonTemporal(mask, address); /// - /// svfloat64_t svldnt1[_f64](svbool_t pg, const float64_t *base) - /// LDNT1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svfloat64_t svldnt1[_f64](svbool_t pg, const float64_t *base) + /// LDNT1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonTemporal(Vector mask, double* address) => LoadVectorNonTemporal(mask, address); /// - /// svint16_t svldnt1[_s16](svbool_t pg, const int16_t *base) - /// LDNT1H Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svint16_t svldnt1[_s16](svbool_t pg, const int16_t *base) + /// LDNT1H Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonTemporal(Vector mask, short* address) => LoadVectorNonTemporal(mask, address); /// - /// svint32_t svldnt1[_s32](svbool_t pg, const int32_t *base) - /// LDNT1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svint32_t svldnt1[_s32](svbool_t pg, const int32_t *base) + /// LDNT1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonTemporal(Vector mask, int* address) => LoadVectorNonTemporal(mask, address); /// - /// svint64_t svldnt1[_s64](svbool_t pg, const int64_t *base) - /// LDNT1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svldnt1[_s64](svbool_t pg, const int64_t *base) + /// LDNT1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonTemporal(Vector mask, long* address) => LoadVectorNonTemporal(mask, address); /// - /// svint8_t svldnt1[_s8](svbool_t pg, const int8_t *base) - /// LDNT1B Zresult.B, Pg/Z, [Xbase, #0, MUL VL] + /// svint8_t svldnt1[_s8](svbool_t pg, const int8_t *base) + /// LDNT1B Zresult.B, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonTemporal(Vector mask, sbyte* address) => LoadVectorNonTemporal(mask, address); /// - /// svfloat32_t svldnt1[_f32](svbool_t pg, const float32_t *base) - /// LDNT1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svfloat32_t svldnt1[_f32](svbool_t pg, const float32_t *base) + /// LDNT1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonTemporal(Vector mask, float* address) => LoadVectorNonTemporal(mask, address); /// - /// svuint16_t svldnt1[_u16](svbool_t pg, const uint16_t *base) - /// LDNT1H Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svuint16_t svldnt1[_u16](svbool_t pg, const uint16_t *base) + /// LDNT1H Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonTemporal(Vector mask, ushort* address) => LoadVectorNonTemporal(mask, address); /// - /// svuint32_t svldnt1[_u32](svbool_t pg, const uint32_t *base) - /// LDNT1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32_t svldnt1[_u32](svbool_t pg, const uint32_t *base) + /// LDNT1W Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonTemporal(Vector mask, uint* address) => LoadVectorNonTemporal(mask, address); /// - /// svuint64_t svldnt1[_u64](svbool_t pg, const uint64_t *base) - /// LDNT1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svldnt1[_u64](svbool_t pg, const uint64_t *base) + /// LDNT1D Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorNonTemporal(Vector mask, ulong* address) => LoadVectorNonTemporal(mask, address); @@ -5272,8 +5932,8 @@ internal Arm64() { } // Load 8-bit data and sign-extend, non-faulting /// - /// svint16_t svldnf1sb_s16(svbool_t pg, const int8_t *base) - /// LDNF1SB Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svint16_t svldnf1sb_s16(svbool_t pg, const int8_t *base) + /// LDNF1SB Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorSByteNonFaultingSignExtendToInt16(sbyte* address) => LoadVectorSByteNonFaultingSignExtendToInt16(address); @@ -5281,8 +5941,8 @@ internal Arm64() { } // Load 8-bit data and sign-extend, non-faulting /// - /// svint32_t svldnf1sb_s32(svbool_t pg, const int8_t *base) - /// LDNF1SB Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svint32_t svldnf1sb_s32(svbool_t pg, const int8_t *base) + /// LDNF1SB Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorSByteNonFaultingSignExtendToInt32(sbyte* address) => LoadVectorSByteNonFaultingSignExtendToInt32(address); @@ -5290,8 +5950,8 @@ internal Arm64() { } // Load 8-bit data and sign-extend, non-faulting /// - /// svint64_t svldnf1sb_s64(svbool_t pg, const int8_t *base) - /// LDNF1SB Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svldnf1sb_s64(svbool_t pg, const int8_t *base) + /// LDNF1SB Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorSByteNonFaultingSignExtendToInt64(sbyte* address) => LoadVectorSByteNonFaultingSignExtendToInt64(address); @@ -5299,8 +5959,8 @@ internal Arm64() { } // Load 8-bit data and sign-extend, non-faulting /// - /// svuint16_t svldnf1sb_u16(svbool_t pg, const int8_t *base) - /// LDNF1SB Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svuint16_t svldnf1sb_u16(svbool_t pg, const int8_t *base) + /// LDNF1SB Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorSByteNonFaultingSignExtendToUInt16(sbyte* address) => LoadVectorSByteNonFaultingSignExtendToUInt16(address); @@ -5308,8 +5968,8 @@ internal Arm64() { } // Load 8-bit data and sign-extend, non-faulting /// - /// svuint32_t svldnf1sb_u32(svbool_t pg, const int8_t *base) - /// LDNF1SB Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32_t svldnf1sb_u32(svbool_t pg, const int8_t *base) + /// LDNF1SB Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorSByteNonFaultingSignExtendToUInt32(sbyte* address) => LoadVectorSByteNonFaultingSignExtendToUInt32(address); @@ -5317,56 +5977,56 @@ internal Arm64() { } // Load 8-bit data and sign-extend, non-faulting /// - /// svuint64_t svldnf1sb_u64(svbool_t pg, const int8_t *base) - /// LDNF1SB Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svldnf1sb_u64(svbool_t pg, const int8_t *base) + /// LDNF1SB Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorSByteNonFaultingSignExtendToUInt64(sbyte* address) => LoadVectorSByteNonFaultingSignExtendToUInt64(address); - /// Load 8-bit data and sign-extend, first-faulting + /// Load 8-bit data and sign-extend, first-faulting /// - /// svint16_t svldff1sb_s16(svbool_t pg, const int8_t *base) - /// LDFF1SB Zresult.H, Pg/Z, [Xbase, XZR] + /// svint16_t svldff1sb_s16(svbool_t pg, const int8_t *base) + /// LDFF1SB Zresult.H, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address) => LoadVectorSByteSignExtendFirstFaulting(mask, address); /// - /// svint32_t svldff1sb_s32(svbool_t pg, const int8_t *base) - /// LDFF1SB Zresult.S, Pg/Z, [Xbase, XZR] + /// svint32_t svldff1sb_s32(svbool_t pg, const int8_t *base) + /// LDFF1SB Zresult.S, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address) => LoadVectorSByteSignExtendFirstFaulting(mask, address); /// - /// svint64_t svldff1sb_s64(svbool_t pg, const int8_t *base) - /// LDFF1SB Zresult.D, Pg/Z, [Xbase, XZR] + /// svint64_t svldff1sb_s64(svbool_t pg, const int8_t *base) + /// LDFF1SB Zresult.D, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address) => LoadVectorSByteSignExtendFirstFaulting(mask, address); /// - /// svuint16_t svldff1sb_u16(svbool_t pg, const int8_t *base) - /// LDFF1SB Zresult.H, Pg/Z, [Xbase, XZR] + /// svuint16_t svldff1sb_u16(svbool_t pg, const int8_t *base) + /// LDFF1SB Zresult.H, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address) => LoadVectorSByteSignExtendFirstFaulting(mask, address); /// - /// svuint32_t svldff1sb_u32(svbool_t pg, const int8_t *base) - /// LDFF1SB Zresult.S, Pg/Z, [Xbase, XZR] + /// svuint32_t svldff1sb_u32(svbool_t pg, const int8_t *base) + /// LDFF1SB Zresult.S, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address) => LoadVectorSByteSignExtendFirstFaulting(mask, address); /// - /// svuint64_t svldff1sb_u64(svbool_t pg, const int8_t *base) - /// LDFF1SB Zresult.D, Pg/Z, [Xbase, XZR] + /// svuint64_t svldff1sb_u64(svbool_t pg, const int8_t *base) + /// LDFF1SB Zresult.D, Pg/Z, [Xbase, XZR] /// public static unsafe Vector LoadVectorSByteSignExtendFirstFaulting(Vector mask, sbyte* address) => LoadVectorSByteSignExtendFirstFaulting(mask, address); - // Load 8-bit data and sign-extend + // Load 8-bit data and sign-extend /// - /// svint16_t svld1sb_s16(svbool_t pg, const int8_t *base) - /// LD1SB Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svint16_t svld1sb_s16(svbool_t pg, const int8_t *base) + /// LD1SB Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorSByteSignExtendToInt16(Vector mask, sbyte* address) => LoadVectorSByteSignExtendToInt16(mask, address); @@ -5374,8 +6034,8 @@ internal Arm64() { } // Load 8-bit data and sign-extend /// - /// svint32_t svld1sb_s32(svbool_t pg, const int8_t *base) - /// LD1SB Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svint32_t svld1sb_s32(svbool_t pg, const int8_t *base) + /// LD1SB Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorSByteSignExtendToInt32(Vector mask, sbyte* address) => LoadVectorSByteSignExtendToInt32(mask, address); @@ -5383,8 +6043,8 @@ internal Arm64() { } // Load 8-bit data and sign-extend /// - /// svint64_t svld1sb_s64(svbool_t pg, const int8_t *base) - /// LD1SB Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svld1sb_s64(svbool_t pg, const int8_t *base) + /// LD1SB Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorSByteSignExtendToInt64(Vector mask, sbyte* address) => LoadVectorSByteSignExtendToInt64(mask, address); @@ -5392,8 +6052,8 @@ internal Arm64() { } // Load 8-bit data and sign-extend /// - /// svuint16_t svld1sb_u16(svbool_t pg, const int8_t *base) - /// LD1SB Zresult.H, Pg/Z, [Xbase, #0, MUL VL] + /// svuint16_t svld1sb_u16(svbool_t pg, const int8_t *base) + /// LD1SB Zresult.H, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorSByteSignExtendToUInt16(Vector mask, sbyte* address) => LoadVectorSByteSignExtendToUInt16(mask, address); @@ -5401,8 +6061,8 @@ internal Arm64() { } // Load 8-bit data and sign-extend /// - /// svuint32_t svld1sb_u32(svbool_t pg, const int8_t *base) - /// LD1SB Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32_t svld1sb_u32(svbool_t pg, const int8_t *base) + /// LD1SB Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorSByteSignExtendToUInt32(Vector mask, sbyte* address) => LoadVectorSByteSignExtendToUInt32(mask, address); @@ -5410,8 +6070,8 @@ internal Arm64() { } // Load 8-bit data and sign-extend /// - /// svuint64_t svld1sb_u64(svbool_t pg, const int8_t *base) - /// LD1SB Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svld1sb_u64(svbool_t pg, const int8_t *base) + /// LD1SB Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorSByteSignExtendToUInt64(Vector mask, sbyte* address) => LoadVectorSByteSignExtendToUInt64(mask, address); @@ -5419,8 +6079,8 @@ internal Arm64() { } // Load 16-bit data and zero-extend, non-faulting /// - /// svint32_t svldnf1uh_s32(svbool_t pg, const uint16_t *base) - /// LDNF1H Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svint32_t svldnf1uh_s32(svbool_t pg, const uint16_t *base) + /// LDNF1H Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorUInt16NonFaultingZeroExtendToInt32(ushort* address) => LoadVectorUInt16NonFaultingZeroExtendToInt32(address); @@ -5428,8 +6088,8 @@ internal Arm64() { } // Load 16-bit data and zero-extend, non-faulting /// - /// svint64_t svldnf1uh_s64(svbool_t pg, const uint16_t *base) - /// LDNF1H Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svldnf1uh_s64(svbool_t pg, const uint16_t *base) + /// LDNF1H Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorUInt16NonFaultingZeroExtendToInt64(ushort* address) => LoadVectorUInt16NonFaultingZeroExtendToInt64(address); @@ -5437,8 +6097,8 @@ internal Arm64() { } // Load 16-bit data and zero-extend, non-faulting /// - /// svuint32_t svldnf1uh_u32(svbool_t pg, const uint16_t *base) - /// LDNF1H Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32_t svldnf1uh_u32(svbool_t pg, const uint16_t *base) + /// LDNF1H Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorUInt16NonFaultingZeroExtendToUInt32(ushort* address) => LoadVectorUInt16NonFaultingZeroExtendToUInt32(address); @@ -5446,33 +6106,33 @@ internal Arm64() { } // Load 16-bit data and zero-extend, non-faulting /// - /// svuint64_t svldnf1uh_u64(svbool_t pg, const uint16_t *base) - /// LDNF1H Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svldnf1uh_u64(svbool_t pg, const uint16_t *base) + /// LDNF1H Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorUInt16NonFaultingZeroExtendToUInt64(ushort* address) => LoadVectorUInt16NonFaultingZeroExtendToUInt64(address); /// - /// svint32_t svldff1uh_s32(svbool_t pg, const uint16_t *base) - /// LDFF1H Zresult.S, Pg/Z, [Xbase, XZR, LSL #1] + /// svint32_t svldff1uh_s32(svbool_t pg, const uint16_t *base) + /// LDFF1H Zresult.S, Pg/Z, [Xbase, XZR, LSL #1] /// public static unsafe Vector LoadVectorUInt16ZeroExtendFirstFaulting(Vector mask, ushort* address) => LoadVectorUInt16ZeroExtendFirstFaulting(mask, address); /// - /// svint64_t svldff1uh_s64(svbool_t pg, const uint16_t *base) - /// LDFF1H Zresult.D, Pg/Z, [Xbase, XZR, LSL #1] + /// svint64_t svldff1uh_s64(svbool_t pg, const uint16_t *base) + /// LDFF1H Zresult.D, Pg/Z, [Xbase, XZR, LSL #1] /// public static unsafe Vector LoadVectorUInt16ZeroExtendFirstFaulting(Vector mask, ushort* address) => LoadVectorUInt16ZeroExtendFirstFaulting(mask, address); /// - /// svuint32_t svldff1uh_u32(svbool_t pg, const uint16_t *base) - /// LDFF1H Zresult.S, Pg/Z, [Xbase, XZR, LSL #1] + /// svuint32_t svldff1uh_u32(svbool_t pg, const uint16_t *base) + /// LDFF1H Zresult.S, Pg/Z, [Xbase, XZR, LSL #1] /// public static unsafe Vector LoadVectorUInt16ZeroExtendFirstFaulting(Vector mask, ushort* address) => LoadVectorUInt16ZeroExtendFirstFaulting(mask, address); /// - /// svuint64_t svldff1uh_u64(svbool_t pg, const uint16_t *base) - /// LDFF1H Zresult.D, Pg/Z, [Xbase, XZR, LSL #1] + /// svuint64_t svldff1uh_u64(svbool_t pg, const uint16_t *base) + /// LDFF1H Zresult.D, Pg/Z, [Xbase, XZR, LSL #1] /// public static unsafe Vector LoadVectorUInt16ZeroExtendFirstFaulting(Vector mask, ushort* address) => LoadVectorUInt16ZeroExtendFirstFaulting(mask, address); @@ -5480,8 +6140,8 @@ internal Arm64() { } // Load 16-bit data and zero-extend /// - /// svint32_t svld1uh_s32(svbool_t pg, const uint16_t *base) - /// LD1H Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svint32_t svld1uh_s32(svbool_t pg, const uint16_t *base) + /// LD1H Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorUInt16ZeroExtendToInt32(Vector mask, ushort* address) => LoadVectorUInt16ZeroExtendToInt32(mask, address); @@ -5489,8 +6149,8 @@ internal Arm64() { } // Load 16-bit data and zero-extend /// - /// svint64_t svld1uh_s64(svbool_t pg, const uint16_t *base) - /// LD1H Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svld1uh_s64(svbool_t pg, const uint16_t *base) + /// LD1H Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorUInt16ZeroExtendToInt64(Vector mask, ushort* address) => LoadVectorUInt16ZeroExtendToInt64(mask, address); @@ -5498,8 +6158,8 @@ internal Arm64() { } // Load 16-bit data and zero-extend /// - /// svuint32_t svld1uh_u32(svbool_t pg, const uint16_t *base) - /// LD1H Zresult.S, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32_t svld1uh_u32(svbool_t pg, const uint16_t *base) + /// LD1H Zresult.S, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorUInt16ZeroExtendToUInt32(Vector mask, ushort* address) => LoadVectorUInt16ZeroExtendToUInt32(mask, address); @@ -5507,8 +6167,8 @@ internal Arm64() { } // Load 16-bit data and zero-extend /// - /// svuint64_t svld1uh_u64(svbool_t pg, const uint16_t *base) - /// LD1H Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svld1uh_u64(svbool_t pg, const uint16_t *base) + /// LD1H Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorUInt16ZeroExtendToUInt64(Vector mask, ushort* address) => LoadVectorUInt16ZeroExtendToUInt64(mask, address); @@ -5516,8 +6176,8 @@ internal Arm64() { } // Load 32-bit data and zero-extend, non-faulting /// - /// svint64_t svldnf1uw_s64(svbool_t pg, const uint32_t *base) - /// LDNF1W Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svldnf1uw_s64(svbool_t pg, const uint32_t *base) + /// LDNF1W Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorUInt32NonFaultingZeroExtendToInt64(uint* address) => LoadVectorUInt32NonFaultingZeroExtendToInt64(address); @@ -5525,21 +6185,21 @@ internal Arm64() { } // Load 32-bit data and zero-extend, non-faulting /// - /// svuint64_t svldnf1uw_u64(svbool_t pg, const uint32_t *base) - /// LDNF1W Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svldnf1uw_u64(svbool_t pg, const uint32_t *base) + /// LDNF1W Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorUInt32NonFaultingZeroExtendToUInt64(uint* address) => LoadVectorUInt32NonFaultingZeroExtendToUInt64(address); /// - /// svint64_t svldff1uw_s64(svbool_t pg, const uint32_t *base) - /// LDFF1W Zresult.D, Pg/Z, [Xbase, XZR, LSL #2] + /// svint64_t svldff1uw_s64(svbool_t pg, const uint32_t *base) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, XZR, LSL #2] /// public static unsafe Vector LoadVectorUInt32ZeroExtendFirstFaulting(Vector mask, uint* address) => LoadVectorUInt32ZeroExtendFirstFaulting(mask, address); /// - /// svuint64_t svldff1uw_u64(svbool_t pg, const uint32_t *base) - /// LDFF1W Zresult.D, Pg/Z, [Xbase, XZR, LSL #2] + /// svuint64_t svldff1uw_u64(svbool_t pg, const uint32_t *base) + /// LDFF1W Zresult.D, Pg/Z, [Xbase, XZR, LSL #2] /// public static unsafe Vector LoadVectorUInt32ZeroExtendFirstFaulting(Vector mask, uint* address) => LoadVectorUInt32ZeroExtendFirstFaulting(mask, address); @@ -5547,8 +6207,8 @@ internal Arm64() { } // Load 32-bit data and zero-extend /// - /// svint64_t svld1uw_s64(svbool_t pg, const uint32_t *base) - /// LD1W Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svint64_t svld1uw_s64(svbool_t pg, const uint32_t *base) + /// LD1W Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorUInt32ZeroExtendToInt64(Vector mask, uint* address) => LoadVectorUInt32ZeroExtendToInt64(mask, address); @@ -5556,8 +6216,8 @@ internal Arm64() { } // Load 32-bit data and zero-extend /// - /// svuint64_t svld1uw_u64(svbool_t pg, const uint32_t *base) - /// LD1W Zresult.D, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64_t svld1uw_u64(svbool_t pg, const uint32_t *base) + /// LD1W Zresult.D, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe Vector LoadVectorUInt32ZeroExtendToUInt64(Vector mask, uint* address) => LoadVectorUInt32ZeroExtendToUInt64(mask, address); @@ -5565,62 +6225,62 @@ internal Arm64() { } // Load two-element tuples into two vectors /// - /// svuint8x2_t svld2[_u8](svbool_t pg, const uint8_t *base) - /// LD2B {Zresult0.B, Zresult1.B}, Pg/Z, [Xbase, #0, MUL VL] + /// svuint8x2_t svld2[_u8](svbool_t pg, const uint8_t *base) + /// LD2B {Zresult0.B, Zresult1.B}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector) Load2xVectorAndUnzip(Vector mask, byte* address) => Load2xVectorAndUnzip(mask, address); /// - /// svfloat64x2_t svld2[_f64](svbool_t pg, const float64_t *base) - /// LD2D {Zresult0.D, Zresult1.D}, Pg/Z, [Xbase, #0, MUL VL] + /// svfloat64x2_t svld2[_f64](svbool_t pg, const float64_t *base) + /// LD2D {Zresult0.D, Zresult1.D}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector) Load2xVectorAndUnzip(Vector mask, double* address) => Load2xVectorAndUnzip(mask, address); /// - /// svint16x2_t svld2[_s16](svbool_t pg, const int16_t *base) - /// LD2H {Zresult0.H, Zresult1.H}, Pg/Z, [Xbase, #0, MUL VL] + /// svint16x2_t svld2[_s16](svbool_t pg, const int16_t *base) + /// LD2H {Zresult0.H, Zresult1.H}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector) Load2xVectorAndUnzip(Vector mask, short* address) => Load2xVectorAndUnzip(mask, address); /// - /// svint32x2_t svld2[_s32](svbool_t pg, const int32_t *base) - /// LD2W {Zresult0.S, Zresult1.S}, Pg/Z, [Xbase, #0, MUL VL] + /// svint32x2_t svld2[_s32](svbool_t pg, const int32_t *base) + /// LD2W {Zresult0.S, Zresult1.S}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector) Load2xVectorAndUnzip(Vector mask, int* address) => Load2xVectorAndUnzip(mask, address); /// - /// svint64x2_t svld2[_s64](svbool_t pg, const int64_t *base) - /// LD2D {Zresult0.D, Zresult1.D}, Pg/Z, [Xbase, #0, MUL VL] + /// svint64x2_t svld2[_s64](svbool_t pg, const int64_t *base) + /// LD2D {Zresult0.D, Zresult1.D}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector) Load2xVectorAndUnzip(Vector mask, long* address) => Load2xVectorAndUnzip(mask, address); /// - /// svint8x2_t svld2[_s8](svbool_t pg, const int8_t *base) - /// LD2B {Zresult0.B, Zresult1.B}, Pg/Z, [Xbase, #0, MUL VL] + /// svint8x2_t svld2[_s8](svbool_t pg, const int8_t *base) + /// LD2B {Zresult0.B, Zresult1.B}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector) Load2xVectorAndUnzip(Vector mask, sbyte* address) => Load2xVectorAndUnzip(mask, address); /// - /// svfloat32x2_t svld2[_f32](svbool_t pg, const float32_t *base) - /// LD2W {Zresult0.S, Zresult1.S}, Pg/Z, [Xbase, #0, MUL VL] + /// svfloat32x2_t svld2[_f32](svbool_t pg, const float32_t *base) + /// LD2W {Zresult0.S, Zresult1.S}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector) Load2xVectorAndUnzip(Vector mask, float* address) => Load2xVectorAndUnzip(mask, address); /// - /// svuint16x2_t svld2[_u16](svbool_t pg, const uint16_t *base) - /// LD2H {Zresult0.H, Zresult1.H}, Pg/Z, [Xbase, #0, MUL VL] + /// svuint16x2_t svld2[_u16](svbool_t pg, const uint16_t *base) + /// LD2H {Zresult0.H, Zresult1.H}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector) Load2xVectorAndUnzip(Vector mask, ushort* address) => Load2xVectorAndUnzip(mask, address); /// - /// svuint32x2_t svld2[_u32](svbool_t pg, const uint32_t *base) - /// LD2W {Zresult0.S, Zresult1.S}, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32x2_t svld2[_u32](svbool_t pg, const uint32_t *base) + /// LD2W {Zresult0.S, Zresult1.S}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector) Load2xVectorAndUnzip(Vector mask, uint* address) => Load2xVectorAndUnzip(mask, address); /// - /// svuint64x2_t svld2[_u64](svbool_t pg, const uint64_t *base) - /// LD2D {Zresult0.D, Zresult1.D}, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64x2_t svld2[_u64](svbool_t pg, const uint64_t *base) + /// LD2D {Zresult0.D, Zresult1.D}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector) Load2xVectorAndUnzip(Vector mask, ulong* address) => Load2xVectorAndUnzip(mask, address); @@ -5628,62 +6288,62 @@ internal Arm64() { } // Load three-element tuples into three vectors /// - /// svuint8x3_t svld3[_u8](svbool_t pg, const uint8_t *base) - /// LD3B {Zresult0.B - Zresult2.B}, Pg/Z, [Xbase, #0, MUL VL] + /// svuint8x3_t svld3[_u8](svbool_t pg, const uint8_t *base) + /// LD3B {Zresult0.B - Zresult2.B}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector) Load3xVectorAndUnzip(Vector mask, byte* address) => Load3xVectorAndUnzip(mask, address); /// - /// svfloat64x3_t svld3[_f64](svbool_t pg, const float64_t *base) - /// LD3D {Zresult0.D - Zresult2.D}, Pg/Z, [Xbase, #0, MUL VL] + /// svfloat64x3_t svld3[_f64](svbool_t pg, const float64_t *base) + /// LD3D {Zresult0.D - Zresult2.D}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector) Load3xVectorAndUnzip(Vector mask, double* address) => Load3xVectorAndUnzip(mask, address); /// - /// svint16x3_t svld3[_s16](svbool_t pg, const int16_t *base) - /// LD3H {Zresult0.H - Zresult2.H}, Pg/Z, [Xbase, #0, MUL VL] + /// svint16x3_t svld3[_s16](svbool_t pg, const int16_t *base) + /// LD3H {Zresult0.H - Zresult2.H}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector) Load3xVectorAndUnzip(Vector mask, short* address) => Load3xVectorAndUnzip(mask, address); /// - /// svint32x3_t svld3[_s32](svbool_t pg, const int32_t *base) - /// LD3W {Zresult0.S - Zresult2.S}, Pg/Z, [Xbase, #0, MUL VL] + /// svint32x3_t svld3[_s32](svbool_t pg, const int32_t *base) + /// LD3W {Zresult0.S - Zresult2.S}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector) Load3xVectorAndUnzip(Vector mask, int* address) => Load3xVectorAndUnzip(mask, address); /// - /// svint64x3_t svld3[_s64](svbool_t pg, const int64_t *base) - /// LD3D {Zresult0.D - Zresult2.D}, Pg/Z, [Xbase, #0, MUL VL] + /// svint64x3_t svld3[_s64](svbool_t pg, const int64_t *base) + /// LD3D {Zresult0.D - Zresult2.D}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector) Load3xVectorAndUnzip(Vector mask, long* address) => Load3xVectorAndUnzip(mask, address); /// - /// svint8x3_t svld3[_s8](svbool_t pg, const int8_t *base) - /// LD3B {Zresult0.B - Zresult2.B}, Pg/Z, [Xbase, #0, MUL VL] + /// svint8x3_t svld3[_s8](svbool_t pg, const int8_t *base) + /// LD3B {Zresult0.B - Zresult2.B}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector) Load3xVectorAndUnzip(Vector mask, sbyte* address) => Load3xVectorAndUnzip(mask, address); /// - /// svfloat32x3_t svld3[_f32](svbool_t pg, const float32_t *base) - /// LD3W {Zresult0.S - Zresult2.S}, Pg/Z, [Xbase, #0, MUL VL] + /// svfloat32x3_t svld3[_f32](svbool_t pg, const float32_t *base) + /// LD3W {Zresult0.S - Zresult2.S}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector) Load3xVectorAndUnzip(Vector mask, float* address) => Load3xVectorAndUnzip(mask, address); /// - /// svuint16x3_t svld3[_u16](svbool_t pg, const uint16_t *base) - /// LD3H {Zresult0.H - Zresult2.H}, Pg/Z, [Xbase, #0, MUL VL] + /// svuint16x3_t svld3[_u16](svbool_t pg, const uint16_t *base) + /// LD3H {Zresult0.H - Zresult2.H}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector) Load3xVectorAndUnzip(Vector mask, ushort* address) => Load3xVectorAndUnzip(mask, address); /// - /// svuint32x3_t svld3[_u32](svbool_t pg, const uint32_t *base) - /// LD3W {Zresult0.S - Zresult2.S}, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32x3_t svld3[_u32](svbool_t pg, const uint32_t *base) + /// LD3W {Zresult0.S - Zresult2.S}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector) Load3xVectorAndUnzip(Vector mask, uint* address) => Load3xVectorAndUnzip(mask, address); /// - /// svuint64x3_t svld3[_u64](svbool_t pg, const uint64_t *base) - /// LD3D {Zresult0.D - Zresult2.D}, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64x3_t svld3[_u64](svbool_t pg, const uint64_t *base) + /// LD3D {Zresult0.D - Zresult2.D}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector) Load3xVectorAndUnzip(Vector mask, ulong* address) => Load3xVectorAndUnzip(mask, address); @@ -5691,62 +6351,62 @@ internal Arm64() { } // Load four-element tuples into four vectors /// - /// svuint8x4_t svld4[_u8](svbool_t pg, const uint8_t *base) - /// LD4B {Zresult0.B - Zresult3.B}, Pg/Z, [Xbase, #0, MUL VL] + /// svuint8x4_t svld4[_u8](svbool_t pg, const uint8_t *base) + /// LD4B {Zresult0.B - Zresult3.B}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector, Vector) Load4xVectorAndUnzip(Vector mask, byte* address) => Load4xVectorAndUnzip(mask, address); /// - /// svfloat64x4_t svld4[_f64](svbool_t pg, const float64_t *base) - /// LD4D {Zresult0.D - Zresult3.D}, Pg/Z, [Xbase, #0, MUL VL] + /// svfloat64x4_t svld4[_f64](svbool_t pg, const float64_t *base) + /// LD4D {Zresult0.D - Zresult3.D}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector, Vector) Load4xVectorAndUnzip(Vector mask, double* address) => Load4xVectorAndUnzip(mask, address); /// - /// svint16x4_t svld4[_s16](svbool_t pg, const int16_t *base) - /// LD4H {Zresult0.H - Zresult3.H}, Pg/Z, [Xbase, #0, MUL VL] + /// svint16x4_t svld4[_s16](svbool_t pg, const int16_t *base) + /// LD4H {Zresult0.H - Zresult3.H}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector, Vector) Load4xVectorAndUnzip(Vector mask, short* address) => Load4xVectorAndUnzip(mask, address); /// - /// svint32x4_t svld4[_s32](svbool_t pg, const int32_t *base) - /// LD4W {Zresult0.S - Zresult3.S}, Pg/Z, [Xbase, #0, MUL VL] + /// svint32x4_t svld4[_s32](svbool_t pg, const int32_t *base) + /// LD4W {Zresult0.S - Zresult3.S}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector, Vector) Load4xVectorAndUnzip(Vector mask, int* address) => Load4xVectorAndUnzip(mask, address); /// - /// svint64x4_t svld4[_s64](svbool_t pg, const int64_t *base) - /// LD4D {Zresult0.D - Zresult3.D}, Pg/Z, [Xbase, #0, MUL VL] + /// svint64x4_t svld4[_s64](svbool_t pg, const int64_t *base) + /// LD4D {Zresult0.D - Zresult3.D}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector, Vector) Load4xVectorAndUnzip(Vector mask, long* address) => Load4xVectorAndUnzip(mask, address); /// - /// svint8x4_t svld4[_s8](svbool_t pg, const int8_t *base) - /// LD4B {Zresult0.B - Zresult3.B}, Pg/Z, [Xbase, #0, MUL VL] + /// svint8x4_t svld4[_s8](svbool_t pg, const int8_t *base) + /// LD4B {Zresult0.B - Zresult3.B}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector, Vector) Load4xVectorAndUnzip(Vector mask, sbyte* address) => Load4xVectorAndUnzip(mask, address); /// - /// svfloat32x4_t svld4[_f32](svbool_t pg, const float32_t *base) - /// LD4W {Zresult0.S - Zresult3.S}, Pg/Z, [Xbase, #0, MUL VL] + /// svfloat32x4_t svld4[_f32](svbool_t pg, const float32_t *base) + /// LD4W {Zresult0.S - Zresult3.S}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector, Vector) Load4xVectorAndUnzip(Vector mask, float* address) => Load4xVectorAndUnzip(mask, address); /// - /// svuint16x4_t svld4[_u16](svbool_t pg, const uint16_t *base) - /// LD4H {Zresult0.H - Zresult3.H}, Pg/Z, [Xbase, #0, MUL VL] + /// svuint16x4_t svld4[_u16](svbool_t pg, const uint16_t *base) + /// LD4H {Zresult0.H - Zresult3.H}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector, Vector) Load4xVectorAndUnzip(Vector mask, ushort* address) => Load4xVectorAndUnzip(mask, address); /// - /// svuint32x4_t svld4[_u32](svbool_t pg, const uint32_t *base) - /// LD4W {Zresult0.S - Zresult3.S}, Pg/Z, [Xbase, #0, MUL VL] + /// svuint32x4_t svld4[_u32](svbool_t pg, const uint32_t *base) + /// LD4W {Zresult0.S - Zresult3.S}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector, Vector) Load4xVectorAndUnzip(Vector mask, uint* address) => Load4xVectorAndUnzip(mask, address); /// - /// svuint64x4_t svld4[_u64](svbool_t pg, const uint64_t *base) - /// LD4D {Zresult0.D - Zresult3.D}, Pg/Z, [Xbase, #0, MUL VL] + /// svuint64x4_t svld4[_u64](svbool_t pg, const uint64_t *base) + /// LD4D {Zresult0.D - Zresult3.D}, Pg/Z, [Xbase, #0, MUL VL] /// public static unsafe (Vector, Vector, Vector, Vector) Load4xVectorAndUnzip(Vector mask, ulong* address) => Load4xVectorAndUnzip(mask, address); @@ -5754,1010 +6414,1010 @@ internal Arm64() { } // Maximum /// - /// svuint8_t svmax[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svmax[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svmax[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// UMAX Ztied1.B, Pg/M, Ztied1.B, Zop2.B - /// UMAX Ztied2.B, Pg/M, Ztied2.B, Zop1.B + /// svuint8_t svmax[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svmax[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svmax[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// UMAX Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// UMAX Ztied2.B, Pg/M, Ztied2.B, Zop1.B /// - public static unsafe Vector Max(Vector left, Vector right) => Max(left, right); + public static Vector Max(Vector left, Vector right) => Max(left, right); /// - /// svfloat64_t svmax[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svmax[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svmax[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FMAX Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// FMAX Ztied2.D, Pg/M, Ztied2.D, Zop1.D + /// svfloat64_t svmax[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svmax[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svmax[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FMAX Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// FMAX Ztied2.D, Pg/M, Ztied2.D, Zop1.D /// - public static unsafe Vector Max(Vector left, Vector right) => Max(left, right); + public static Vector Max(Vector left, Vector right) => Max(left, right); /// - /// svint16_t svmax[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svmax[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svmax[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) - /// SMAX Ztied1.H, Pg/M, Ztied1.H, Zop2.H - /// SMAX Ztied2.H, Pg/M, Ztied2.H, Zop1.H + /// svint16_t svmax[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svmax[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svmax[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) + /// SMAX Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// SMAX Ztied2.H, Pg/M, Ztied2.H, Zop1.H /// - public static unsafe Vector Max(Vector left, Vector right) => Max(left, right); + public static Vector Max(Vector left, Vector right) => Max(left, right); /// - /// svint32_t svmax[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svmax[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svmax[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) - /// SMAX Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// SMAX Ztied2.S, Pg/M, Ztied2.S, Zop1.S + /// svint32_t svmax[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svmax[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svmax[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) + /// SMAX Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// SMAX Ztied2.S, Pg/M, Ztied2.S, Zop1.S /// - public static unsafe Vector Max(Vector left, Vector right) => Max(left, right); + public static Vector Max(Vector left, Vector right) => Max(left, right); /// - /// svint64_t svmax[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svmax[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svmax[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) - /// SMAX Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// SMAX Ztied2.D, Pg/M, Ztied2.D, Zop1.D + /// svint64_t svmax[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svmax[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svmax[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) + /// SMAX Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// SMAX Ztied2.D, Pg/M, Ztied2.D, Zop1.D /// - public static unsafe Vector Max(Vector left, Vector right) => Max(left, right); + public static Vector Max(Vector left, Vector right) => Max(left, right); /// - /// svint8_t svmax[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svmax[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svmax[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) - /// SMAX Ztied1.B, Pg/M, Ztied1.B, Zop2.B - /// SMAX Ztied2.B, Pg/M, Ztied2.B, Zop1.B + /// svint8_t svmax[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svmax[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svmax[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) + /// SMAX Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// SMAX Ztied2.B, Pg/M, Ztied2.B, Zop1.B /// - public static unsafe Vector Max(Vector left, Vector right) => Max(left, right); + public static Vector Max(Vector left, Vector right) => Max(left, right); /// - /// svfloat32_t svmax[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svmax[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svmax[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FMAX Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// FMAX Ztied2.S, Pg/M, Ztied2.S, Zop1.S + /// svfloat32_t svmax[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svmax[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svmax[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FMAX Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// FMAX Ztied2.S, Pg/M, Ztied2.S, Zop1.S /// - public static unsafe Vector Max(Vector left, Vector right) => Max(left, right); + public static Vector Max(Vector left, Vector right) => Max(left, right); /// - /// svuint16_t svmax[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svmax[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svmax[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// UMAX Ztied1.H, Pg/M, Ztied1.H, Zop2.H - /// UMAX Ztied2.H, Pg/M, Ztied2.H, Zop1.H + /// svuint16_t svmax[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svmax[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svmax[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// UMAX Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// UMAX Ztied2.H, Pg/M, Ztied2.H, Zop1.H /// - public static unsafe Vector Max(Vector left, Vector right) => Max(left, right); + public static Vector Max(Vector left, Vector right) => Max(left, right); /// - /// svuint32_t svmax[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svmax[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svmax[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// UMAX Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// UMAX Ztied2.S, Pg/M, Ztied2.S, Zop1.S + /// svuint32_t svmax[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svmax[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svmax[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// UMAX Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// UMAX Ztied2.S, Pg/M, Ztied2.S, Zop1.S /// - public static unsafe Vector Max(Vector left, Vector right) => Max(left, right); + public static Vector Max(Vector left, Vector right) => Max(left, right); /// - /// svuint64_t svmax[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svmax[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svmax[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// UMAX Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// UMAX Ztied2.D, Pg/M, Ztied2.D, Zop1.D + /// svuint64_t svmax[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svmax[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svmax[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// UMAX Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// UMAX Ztied2.D, Pg/M, Ztied2.D, Zop1.D /// - public static unsafe Vector Max(Vector left, Vector right) => Max(left, right); + public static Vector Max(Vector left, Vector right) => Max(left, right); // Maximum reduction to scalar /// - /// uint8_t svmaxv[_u8](svbool_t pg, svuint8_t op) - /// UMAXV Bresult, Pg, Zop.B + /// uint8_t svmaxv[_u8](svbool_t pg, svuint8_t op) + /// UMAXV Bresult, Pg, Zop.B /// - public static unsafe Vector MaxAcross(Vector value) => MaxAcross(value); + public static Vector MaxAcross(Vector value) => MaxAcross(value); /// - /// float64_t svmaxv[_f64](svbool_t pg, svfloat64_t op) - /// FMAXV Dresult, Pg, Zop.D + /// float64_t svmaxv[_f64](svbool_t pg, svfloat64_t op) + /// FMAXV Dresult, Pg, Zop.D /// - public static unsafe Vector MaxAcross(Vector value) => MaxAcross(value); + public static Vector MaxAcross(Vector value) => MaxAcross(value); /// - /// int16_t svmaxv[_s16](svbool_t pg, svint16_t op) - /// SMAXV Hresult, Pg, Zop.H + /// int16_t svmaxv[_s16](svbool_t pg, svint16_t op) + /// SMAXV Hresult, Pg, Zop.H /// - public static unsafe Vector MaxAcross(Vector value) => MaxAcross(value); + public static Vector MaxAcross(Vector value) => MaxAcross(value); /// - /// int32_t svmaxv[_s32](svbool_t pg, svint32_t op) - /// SMAXV Sresult, Pg, Zop.S + /// int32_t svmaxv[_s32](svbool_t pg, svint32_t op) + /// SMAXV Sresult, Pg, Zop.S /// - public static unsafe Vector MaxAcross(Vector value) => MaxAcross(value); + public static Vector MaxAcross(Vector value) => MaxAcross(value); /// - /// int64_t svmaxv[_s64](svbool_t pg, svint64_t op) - /// SMAXV Dresult, Pg, Zop.D + /// int64_t svmaxv[_s64](svbool_t pg, svint64_t op) + /// SMAXV Dresult, Pg, Zop.D /// - public static unsafe Vector MaxAcross(Vector value) => MaxAcross(value); + public static Vector MaxAcross(Vector value) => MaxAcross(value); /// - /// int8_t svmaxv[_s8](svbool_t pg, svint8_t op) - /// SMAXV Bresult, Pg, Zop.B + /// int8_t svmaxv[_s8](svbool_t pg, svint8_t op) + /// SMAXV Bresult, Pg, Zop.B /// - public static unsafe Vector MaxAcross(Vector value) => MaxAcross(value); + public static Vector MaxAcross(Vector value) => MaxAcross(value); /// - /// float32_t svmaxv[_f32](svbool_t pg, svfloat32_t op) - /// FMAXV Sresult, Pg, Zop.S + /// float32_t svmaxv[_f32](svbool_t pg, svfloat32_t op) + /// FMAXV Sresult, Pg, Zop.S /// - public static unsafe Vector MaxAcross(Vector value) => MaxAcross(value); + public static Vector MaxAcross(Vector value) => MaxAcross(value); /// - /// uint16_t svmaxv[_u16](svbool_t pg, svuint16_t op) - /// UMAXV Hresult, Pg, Zop.H + /// uint16_t svmaxv[_u16](svbool_t pg, svuint16_t op) + /// UMAXV Hresult, Pg, Zop.H /// - public static unsafe Vector MaxAcross(Vector value) => MaxAcross(value); + public static Vector MaxAcross(Vector value) => MaxAcross(value); /// - /// uint32_t svmaxv[_u32](svbool_t pg, svuint32_t op) - /// UMAXV Sresult, Pg, Zop.S + /// uint32_t svmaxv[_u32](svbool_t pg, svuint32_t op) + /// UMAXV Sresult, Pg, Zop.S /// - public static unsafe Vector MaxAcross(Vector value) => MaxAcross(value); + public static Vector MaxAcross(Vector value) => MaxAcross(value); /// - /// uint64_t svmaxv[_u64](svbool_t pg, svuint64_t op) - /// UMAXV Dresult, Pg, Zop.D + /// uint64_t svmaxv[_u64](svbool_t pg, svuint64_t op) + /// UMAXV Dresult, Pg, Zop.D /// - public static unsafe Vector MaxAcross(Vector value) => MaxAcross(value); + public static Vector MaxAcross(Vector value) => MaxAcross(value); // Maximum number /// - /// svfloat64_t svmaxnm[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svmaxnm[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svmaxnm[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FMAXNM Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// FMAXNM Ztied2.D, Pg/M, Ztied2.D, Zop1.D + /// svfloat64_t svmaxnm[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svmaxnm[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svmaxnm[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FMAXNM Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// FMAXNM Ztied2.D, Pg/M, Ztied2.D, Zop1.D /// - public static unsafe Vector MaxNumber(Vector left, Vector right) => MaxNumber(left, right); + public static Vector MaxNumber(Vector left, Vector right) => MaxNumber(left, right); /// - /// svfloat32_t svmaxnm[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svmaxnm[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svmaxnm[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FMAXNM Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// FMAXNM Ztied2.S, Pg/M, Ztied2.S, Zop1.S + /// svfloat32_t svmaxnm[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svmaxnm[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svmaxnm[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FMAXNM Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// FMAXNM Ztied2.S, Pg/M, Ztied2.S, Zop1.S /// - public static unsafe Vector MaxNumber(Vector left, Vector right) => MaxNumber(left, right); + public static Vector MaxNumber(Vector left, Vector right) => MaxNumber(left, right); // Maximum number reduction to scalar /// - /// float64_t svmaxnmv[_f64](svbool_t pg, svfloat64_t op) - /// FMAXNMV Dresult, Pg, Zop.D + /// float64_t svmaxnmv[_f64](svbool_t pg, svfloat64_t op) + /// FMAXNMV Dresult, Pg, Zop.D /// - public static unsafe Vector MaxNumberAcross(Vector value) => MaxNumberAcross(value); + public static Vector MaxNumberAcross(Vector value) => MaxNumberAcross(value); /// - /// float32_t svmaxnmv[_f32](svbool_t pg, svfloat32_t op) - /// FMAXNMV Sresult, Pg, Zop.S + /// float32_t svmaxnmv[_f32](svbool_t pg, svfloat32_t op) + /// FMAXNMV Sresult, Pg, Zop.S /// - public static unsafe Vector MaxNumberAcross(Vector value) => MaxNumberAcross(value); + public static Vector MaxNumberAcross(Vector value) => MaxNumberAcross(value); // Minimum /// - /// svuint8_t svmin[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svmin[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svmin[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// UMIN Ztied1.B, Pg/M, Ztied1.B, Zop2.B - /// UMIN Ztied2.B, Pg/M, Ztied2.B, Zop1.B + /// svuint8_t svmin[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svmin[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svmin[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// UMIN Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// UMIN Ztied2.B, Pg/M, Ztied2.B, Zop1.B /// - public static unsafe Vector Min(Vector left, Vector right) => Min(left, right); + public static Vector Min(Vector left, Vector right) => Min(left, right); /// - /// svfloat64_t svmin[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svmin[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svmin[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FMIN Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// FMIN Ztied2.D, Pg/M, Ztied2.D, Zop1.D + /// svfloat64_t svmin[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svmin[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svmin[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FMIN Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// FMIN Ztied2.D, Pg/M, Ztied2.D, Zop1.D /// - public static unsafe Vector Min(Vector left, Vector right) => Min(left, right); + public static Vector Min(Vector left, Vector right) => Min(left, right); /// - /// svint16_t svmin[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svmin[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svmin[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) - /// SMIN Ztied1.H, Pg/M, Ztied1.H, Zop2.H - /// SMIN Ztied2.H, Pg/M, Ztied2.H, Zop1.H + /// svint16_t svmin[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svmin[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svmin[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) + /// SMIN Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// SMIN Ztied2.H, Pg/M, Ztied2.H, Zop1.H /// - public static unsafe Vector Min(Vector left, Vector right) => Min(left, right); + public static Vector Min(Vector left, Vector right) => Min(left, right); /// - /// svint32_t svmin[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svmin[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svmin[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) - /// SMIN Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// SMIN Ztied2.S, Pg/M, Ztied2.S, Zop1.S + /// svint32_t svmin[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svmin[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svmin[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) + /// SMIN Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// SMIN Ztied2.S, Pg/M, Ztied2.S, Zop1.S /// - public static unsafe Vector Min(Vector left, Vector right) => Min(left, right); + public static Vector Min(Vector left, Vector right) => Min(left, right); /// - /// svint64_t svmin[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svmin[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svmin[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) - /// SMIN Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// SMIN Ztied2.D, Pg/M, Ztied2.D, Zop1.D + /// svint64_t svmin[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svmin[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svmin[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) + /// SMIN Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// SMIN Ztied2.D, Pg/M, Ztied2.D, Zop1.D /// - public static unsafe Vector Min(Vector left, Vector right) => Min(left, right); + public static Vector Min(Vector left, Vector right) => Min(left, right); /// - /// svint8_t svmin[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svmin[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svmin[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) - /// SMIN Ztied1.B, Pg/M, Ztied1.B, Zop2.B - /// SMIN Ztied2.B, Pg/M, Ztied2.B, Zop1.B + /// svint8_t svmin[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svmin[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svmin[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) + /// SMIN Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// SMIN Ztied2.B, Pg/M, Ztied2.B, Zop1.B /// - public static unsafe Vector Min(Vector left, Vector right) => Min(left, right); + public static Vector Min(Vector left, Vector right) => Min(left, right); /// - /// svfloat32_t svmin[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svmin[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svmin[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FMIN Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// FMIN Ztied2.S, Pg/M, Ztied2.S, Zop1.S + /// svfloat32_t svmin[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svmin[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svmin[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FMIN Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// FMIN Ztied2.S, Pg/M, Ztied2.S, Zop1.S /// - public static unsafe Vector Min(Vector left, Vector right) => Min(left, right); + public static Vector Min(Vector left, Vector right) => Min(left, right); /// - /// svuint16_t svmin[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svmin[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svmin[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// UMIN Ztied1.H, Pg/M, Ztied1.H, Zop2.H - /// UMIN Ztied2.H, Pg/M, Ztied2.H, Zop1.H + /// svuint16_t svmin[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svmin[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svmin[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// UMIN Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// UMIN Ztied2.H, Pg/M, Ztied2.H, Zop1.H /// - public static unsafe Vector Min(Vector left, Vector right) => Min(left, right); + public static Vector Min(Vector left, Vector right) => Min(left, right); /// - /// svuint32_t svmin[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svmin[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svmin[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// UMIN Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// UMIN Ztied2.S, Pg/M, Ztied2.S, Zop1.S + /// svuint32_t svmin[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svmin[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svmin[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// UMIN Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// UMIN Ztied2.S, Pg/M, Ztied2.S, Zop1.S /// - public static unsafe Vector Min(Vector left, Vector right) => Min(left, right); + public static Vector Min(Vector left, Vector right) => Min(left, right); /// - /// svuint64_t svmin[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svmin[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svmin[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// UMIN Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// UMIN Ztied2.D, Pg/M, Ztied2.D, Zop1.D + /// svuint64_t svmin[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svmin[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svmin[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// UMIN Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// UMIN Ztied2.D, Pg/M, Ztied2.D, Zop1.D /// - public static unsafe Vector Min(Vector left, Vector right) => Min(left, right); + public static Vector Min(Vector left, Vector right) => Min(left, right); // Minimum reduction to scalar /// - /// uint8_t svminv[_u8](svbool_t pg, svuint8_t op) - /// UMINV Bresult, Pg, Zop.B + /// uint8_t svminv[_u8](svbool_t pg, svuint8_t op) + /// UMINV Bresult, Pg, Zop.B /// - public static unsafe Vector MinAcross(Vector value) => MinAcross(value); + public static Vector MinAcross(Vector value) => MinAcross(value); /// - /// float64_t svminv[_f64](svbool_t pg, svfloat64_t op) - /// FMINV Dresult, Pg, Zop.D + /// float64_t svminv[_f64](svbool_t pg, svfloat64_t op) + /// FMINV Dresult, Pg, Zop.D /// - public static unsafe Vector MinAcross(Vector value) => MinAcross(value); + public static Vector MinAcross(Vector value) => MinAcross(value); /// - /// int16_t svminv[_s16](svbool_t pg, svint16_t op) - /// SMINV Hresult, Pg, Zop.H + /// int16_t svminv[_s16](svbool_t pg, svint16_t op) + /// SMINV Hresult, Pg, Zop.H /// - public static unsafe Vector MinAcross(Vector value) => MinAcross(value); + public static Vector MinAcross(Vector value) => MinAcross(value); /// - /// int32_t svminv[_s32](svbool_t pg, svint32_t op) - /// SMINV Sresult, Pg, Zop.S + /// int32_t svminv[_s32](svbool_t pg, svint32_t op) + /// SMINV Sresult, Pg, Zop.S /// - public static unsafe Vector MinAcross(Vector value) => MinAcross(value); + public static Vector MinAcross(Vector value) => MinAcross(value); /// - /// int64_t svminv[_s64](svbool_t pg, svint64_t op) - /// SMINV Dresult, Pg, Zop.D + /// int64_t svminv[_s64](svbool_t pg, svint64_t op) + /// SMINV Dresult, Pg, Zop.D /// - public static unsafe Vector MinAcross(Vector value) => MinAcross(value); + public static Vector MinAcross(Vector value) => MinAcross(value); /// - /// int8_t svminv[_s8](svbool_t pg, svint8_t op) - /// SMINV Bresult, Pg, Zop.B + /// int8_t svminv[_s8](svbool_t pg, svint8_t op) + /// SMINV Bresult, Pg, Zop.B /// - public static unsafe Vector MinAcross(Vector value) => MinAcross(value); + public static Vector MinAcross(Vector value) => MinAcross(value); /// - /// float32_t svminv[_f32](svbool_t pg, svfloat32_t op) - /// FMINV Sresult, Pg, Zop.S + /// float32_t svminv[_f32](svbool_t pg, svfloat32_t op) + /// FMINV Sresult, Pg, Zop.S /// - public static unsafe Vector MinAcross(Vector value) => MinAcross(value); + public static Vector MinAcross(Vector value) => MinAcross(value); /// - /// uint16_t svminv[_u16](svbool_t pg, svuint16_t op) - /// UMINV Hresult, Pg, Zop.H + /// uint16_t svminv[_u16](svbool_t pg, svuint16_t op) + /// UMINV Hresult, Pg, Zop.H /// - public static unsafe Vector MinAcross(Vector value) => MinAcross(value); + public static Vector MinAcross(Vector value) => MinAcross(value); /// - /// uint32_t svminv[_u32](svbool_t pg, svuint32_t op) - /// UMINV Sresult, Pg, Zop.S + /// uint32_t svminv[_u32](svbool_t pg, svuint32_t op) + /// UMINV Sresult, Pg, Zop.S /// - public static unsafe Vector MinAcross(Vector value) => MinAcross(value); + public static Vector MinAcross(Vector value) => MinAcross(value); /// - /// uint64_t svminv[_u64](svbool_t pg, svuint64_t op) - /// UMINV Dresult, Pg, Zop.D + /// uint64_t svminv[_u64](svbool_t pg, svuint64_t op) + /// UMINV Dresult, Pg, Zop.D /// - public static unsafe Vector MinAcross(Vector value) => MinAcross(value); + public static Vector MinAcross(Vector value) => MinAcross(value); // Minimum number /// - /// svfloat64_t svminnm[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svminnm[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svminnm[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FMINNM Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// FMINNM Ztied2.D, Pg/M, Ztied2.D, Zop1.D + /// svfloat64_t svminnm[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svminnm[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svminnm[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FMINNM Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// FMINNM Ztied2.D, Pg/M, Ztied2.D, Zop1.D /// - public static unsafe Vector MinNumber(Vector left, Vector right) => MinNumber(left, right); + public static Vector MinNumber(Vector left, Vector right) => MinNumber(left, right); /// - /// svfloat32_t svminnm[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svminnm[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svminnm[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FMINNM Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// FMINNM Ztied2.S, Pg/M, Ztied2.S, Zop1.S + /// svfloat32_t svminnm[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svminnm[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svminnm[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FMINNM Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// FMINNM Ztied2.S, Pg/M, Ztied2.S, Zop1.S /// - public static unsafe Vector MinNumber(Vector left, Vector right) => MinNumber(left, right); + public static Vector MinNumber(Vector left, Vector right) => MinNumber(left, right); // Minimum number reduction to scalar /// - /// float64_t svminnmv[_f64](svbool_t pg, svfloat64_t op) - /// FMINNMV Dresult, Pg, Zop.D + /// float64_t svminnmv[_f64](svbool_t pg, svfloat64_t op) + /// FMINNMV Dresult, Pg, Zop.D /// - public static unsafe Vector MinNumberAcross(Vector value) => MinNumberAcross(value); + public static Vector MinNumberAcross(Vector value) => MinNumberAcross(value); /// - /// float32_t svminnmv[_f32](svbool_t pg, svfloat32_t op) - /// FMINNMV Sresult, Pg, Zop.S + /// float32_t svminnmv[_f32](svbool_t pg, svfloat32_t op) + /// FMINNMV Sresult, Pg, Zop.S /// - public static unsafe Vector MinNumberAcross(Vector value) => MinNumberAcross(value); + public static Vector MinNumberAcross(Vector value) => MinNumberAcross(value); // Multiply /// - /// svuint8_t svmul[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svmul[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svmul[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// MUL Ztied1.B, Pg/M, Ztied1.B, Zop2.B - /// MUL Ztied2.B, Pg/M, Ztied2.B, Zop1.B - /// svuint8_t svmul[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svmul[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svmul[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svmul[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// MUL Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// MUL Ztied2.B, Pg/M, Ztied2.B, Zop1.B + /// svuint8_t svmul[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) /// - public static unsafe Vector Multiply(Vector left, Vector right) => Multiply(left, right); + public static Vector Multiply(Vector left, Vector right) => Multiply(left, right); /// - /// svfloat64_t svmul[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svmul[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svmul[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FMUL Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// FMUL Ztied2.D, Pg/M, Ztied2.D, Zop1.D - /// svfloat64_t svmul[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svmul[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svmul[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svmul[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FMUL Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// FMUL Ztied2.D, Pg/M, Ztied2.D, Zop1.D + /// svfloat64_t svmul[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) /// - public static unsafe Vector Multiply(Vector left, Vector right) => Multiply(left, right); + public static Vector Multiply(Vector left, Vector right) => Multiply(left, right); /// - /// svint16_t svmul[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svmul[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svmul[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) - /// MUL Ztied1.H, Pg/M, Ztied1.H, Zop2.H - /// MUL Ztied2.H, Pg/M, Ztied2.H, Zop1.H + /// svint16_t svmul[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svmul[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svmul[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) + /// MUL Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// MUL Ztied2.H, Pg/M, Ztied2.H, Zop1.H /// - public static unsafe Vector Multiply(Vector left, Vector right) => Multiply(left, right); + public static Vector Multiply(Vector left, Vector right) => Multiply(left, right); /// - /// svint32_t svmul[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svmul[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svmul[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) - /// MUL Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// MUL Ztied2.S, Pg/M, Ztied2.S, Zop1.S + /// svint32_t svmul[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svmul[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svmul[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) + /// MUL Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// MUL Ztied2.S, Pg/M, Ztied2.S, Zop1.S /// - public static unsafe Vector Multiply(Vector left, Vector right) => Multiply(left, right); + public static Vector Multiply(Vector left, Vector right) => Multiply(left, right); /// - /// svint64_t svmul[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svmul[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svmul[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) - /// MUL Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// MUL Ztied2.D, Pg/M, Ztied2.D, Zop1.D + /// svint64_t svmul[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svmul[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svmul[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) + /// MUL Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// MUL Ztied2.D, Pg/M, Ztied2.D, Zop1.D /// - public static unsafe Vector Multiply(Vector left, Vector right) => Multiply(left, right); + public static Vector Multiply(Vector left, Vector right) => Multiply(left, right); /// - /// svint8_t svmul[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svmul[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svmul[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) - /// MUL Ztied1.B, Pg/M, Ztied1.B, Zop2.B - /// MUL Ztied2.B, Pg/M, Ztied2.B, Zop1.B + /// svint8_t svmul[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svmul[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svmul[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) + /// MUL Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// MUL Ztied2.B, Pg/M, Ztied2.B, Zop1.B /// - public static unsafe Vector Multiply(Vector left, Vector right) => Multiply(left, right); + public static Vector Multiply(Vector left, Vector right) => Multiply(left, right); /// - /// svfloat32_t svmul[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svmul[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svmul[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FMUL Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// FMUL Ztied2.S, Pg/M, Ztied2.S, Zop1.S + /// svfloat32_t svmul[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svmul[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svmul[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FMUL Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// FMUL Ztied2.S, Pg/M, Ztied2.S, Zop1.S /// - public static unsafe Vector Multiply(Vector left, Vector right) => Multiply(left, right); + public static Vector Multiply(Vector left, Vector right) => Multiply(left, right); /// - /// svuint16_t svmul[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svmul[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svmul[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// MUL Ztied1.H, Pg/M, Ztied1.H, Zop2.H - /// MUL Ztied2.H, Pg/M, Ztied2.H, Zop1.H + /// svuint16_t svmul[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svmul[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svmul[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// MUL Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// MUL Ztied2.H, Pg/M, Ztied2.H, Zop1.H /// - public static unsafe Vector Multiply(Vector left, Vector right) => Multiply(left, right); + public static Vector Multiply(Vector left, Vector right) => Multiply(left, right); /// - /// svuint32_t svmul[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svmul[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svmul[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// MUL Ztied1.S, Pg/M, Ztied1.S, Zop2.S - /// MUL Ztied2.S, Pg/M, Ztied2.S, Zop1.S + /// svuint32_t svmul[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svmul[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svmul[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// MUL Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// MUL Ztied2.S, Pg/M, Ztied2.S, Zop1.S /// - public static unsafe Vector Multiply(Vector left, Vector right) => Multiply(left, right); + public static Vector Multiply(Vector left, Vector right) => Multiply(left, right); /// - /// svuint64_t svmul[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svmul[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svmul[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// MUL Ztied1.D, Pg/M, Ztied1.D, Zop2.D - /// MUL Ztied2.D, Pg/M, Ztied2.D, Zop1.D + /// svuint64_t svmul[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svmul[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svmul[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// MUL Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// MUL Ztied2.D, Pg/M, Ztied2.D, Zop1.D /// - public static unsafe Vector Multiply(Vector left, Vector right) => Multiply(left, right); + public static Vector Multiply(Vector left, Vector right) => Multiply(left, right); // Multiply-add, addend first /// - /// svuint8_t svmla[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2, svuint8_t op3) - /// svuint8_t svmla[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2, svuint8_t op3) - /// svuint8_t svmla[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2, svuint8_t op3) - /// MLA Ztied1.B, Pg/M, Zop2.B, Zop3.B + /// svuint8_t svmla[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2, svuint8_t op3) + /// svuint8_t svmla[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2, svuint8_t op3) + /// svuint8_t svmla[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2, svuint8_t op3) + /// MLA Ztied1.B, Pg/M, Zop2.B, Zop3.B /// - public static unsafe Vector MultiplyAdd(Vector addend, Vector left, Vector right) => MultiplyAdd(addend, left, right); + public static Vector MultiplyAdd(Vector addend, Vector left, Vector right) => MultiplyAdd(addend, left, right); /// - /// svint16_t svmla[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2, svint16_t op3) - /// svint16_t svmla[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2, svint16_t op3) - /// svint16_t svmla[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2, svint16_t op3) - /// MLA Ztied1.H, Pg/M, Zop2.H, Zop3.H + /// svint16_t svmla[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2, svint16_t op3) + /// svint16_t svmla[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2, svint16_t op3) + /// svint16_t svmla[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2, svint16_t op3) + /// MLA Ztied1.H, Pg/M, Zop2.H, Zop3.H /// - public static unsafe Vector MultiplyAdd(Vector addend, Vector left, Vector right) => MultiplyAdd(addend, left, right); + public static Vector MultiplyAdd(Vector addend, Vector left, Vector right) => MultiplyAdd(addend, left, right); /// - /// svint32_t svmla[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2, svint32_t op3) - /// svint32_t svmla[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2, svint32_t op3) - /// svint32_t svmla[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2, svint32_t op3) - /// MLA Ztied1.S, Pg/M, Zop2.S, Zop3.S + /// svint32_t svmla[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2, svint32_t op3) + /// svint32_t svmla[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2, svint32_t op3) + /// svint32_t svmla[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2, svint32_t op3) + /// MLA Ztied1.S, Pg/M, Zop2.S, Zop3.S /// - public static unsafe Vector MultiplyAdd(Vector addend, Vector left, Vector right) => MultiplyAdd(addend, left, right); + public static Vector MultiplyAdd(Vector addend, Vector left, Vector right) => MultiplyAdd(addend, left, right); /// - /// svint64_t svmla[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2, svint64_t op3) - /// svint64_t svmla[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2, svint64_t op3) - /// svint64_t svmla[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2, svint64_t op3) - /// MLA Ztied1.D, Pg/M, Zop2.D, Zop3.D + /// svint64_t svmla[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2, svint64_t op3) + /// svint64_t svmla[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2, svint64_t op3) + /// svint64_t svmla[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2, svint64_t op3) + /// MLA Ztied1.D, Pg/M, Zop2.D, Zop3.D /// - public static unsafe Vector MultiplyAdd(Vector addend, Vector left, Vector right) => MultiplyAdd(addend, left, right); + public static Vector MultiplyAdd(Vector addend, Vector left, Vector right) => MultiplyAdd(addend, left, right); /// - /// svint8_t svmla[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2, svint8_t op3) - /// svint8_t svmla[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2, svint8_t op3) - /// svint8_t svmla[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2, svint8_t op3) - /// MLA Ztied1.B, Pg/M, Zop2.B, Zop3.B + /// svint8_t svmla[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2, svint8_t op3) + /// svint8_t svmla[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2, svint8_t op3) + /// svint8_t svmla[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2, svint8_t op3) + /// MLA Ztied1.B, Pg/M, Zop2.B, Zop3.B /// - public static unsafe Vector MultiplyAdd(Vector addend, Vector left, Vector right) => MultiplyAdd(addend, left, right); + public static Vector MultiplyAdd(Vector addend, Vector left, Vector right) => MultiplyAdd(addend, left, right); /// - /// svuint16_t svmla[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2, svuint16_t op3) - /// svuint16_t svmla[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2, svuint16_t op3) - /// svuint16_t svmla[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2, svuint16_t op3) - /// MLA Ztied1.H, Pg/M, Zop2.H, Zop3.H + /// svuint16_t svmla[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2, svuint16_t op3) + /// svuint16_t svmla[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2, svuint16_t op3) + /// svuint16_t svmla[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2, svuint16_t op3) + /// MLA Ztied1.H, Pg/M, Zop2.H, Zop3.H /// - public static unsafe Vector MultiplyAdd(Vector addend, Vector left, Vector right) => MultiplyAdd(addend, left, right); + public static Vector MultiplyAdd(Vector addend, Vector left, Vector right) => MultiplyAdd(addend, left, right); /// - /// svuint32_t svmla[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2, svuint32_t op3) - /// svuint32_t svmla[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2, svuint32_t op3) - /// svuint32_t svmla[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2, svuint32_t op3) - /// MLA Ztied1.S, Pg/M, Zop2.S, Zop3.S + /// svuint32_t svmla[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2, svuint32_t op3) + /// svuint32_t svmla[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2, svuint32_t op3) + /// svuint32_t svmla[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2, svuint32_t op3) + /// MLA Ztied1.S, Pg/M, Zop2.S, Zop3.S /// - public static unsafe Vector MultiplyAdd(Vector addend, Vector left, Vector right) => MultiplyAdd(addend, left, right); + public static Vector MultiplyAdd(Vector addend, Vector left, Vector right) => MultiplyAdd(addend, left, right); /// - /// svuint64_t svmla[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2, svuint64_t op3) - /// svuint64_t svmla[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2, svuint64_t op3) - /// svuint64_t svmla[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2, svuint64_t op3) - /// MLA Ztied1.D, Pg/M, Zop2.D, Zop3.D + /// svuint64_t svmla[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2, svuint64_t op3) + /// svuint64_t svmla[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2, svuint64_t op3) + /// svuint64_t svmla[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2, svuint64_t op3) + /// MLA Ztied1.D, Pg/M, Zop2.D, Zop3.D /// - public static unsafe Vector MultiplyAdd(Vector addend, Vector left, Vector right) => MultiplyAdd(addend, left, right); + public static Vector MultiplyAdd(Vector addend, Vector left, Vector right) => MultiplyAdd(addend, left, right); // Complex multiply-add with rotate /// - /// svfloat64_t svcmla[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3, uint64_t imm_rotation) - /// svfloat64_t svcmla[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3, uint64_t imm_rotation) - /// svfloat64_t svcmla[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3, uint64_t imm_rotation) - /// FCMLA Ztied1.D, Pg/M, Zop2.D, Zop3.D, #imm_rotation + /// svfloat64_t svcmla[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3, uint64_t imm_rotation) + /// svfloat64_t svcmla[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3, uint64_t imm_rotation) + /// svfloat64_t svcmla[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2, svfloat64_t op3, uint64_t imm_rotation) + /// FCMLA Ztied1.D, Pg/M, Zop2.D, Zop3.D, #imm_rotation /// - public static unsafe Vector MultiplyAddRotateComplex(Vector addend, Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(3))] byte rotation) => MultiplyAddRotateComplex(addend, left, right, rotation); + public static Vector MultiplyAddRotateComplex(Vector addend, Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(3))] byte rotation) => MultiplyAddRotateComplex(addend, left, right, rotation); /// - /// svfloat32_t svcmla[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3, uint64_t imm_rotation) - /// svfloat32_t svcmla[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3, uint64_t imm_rotation) - /// svfloat32_t svcmla[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3, uint64_t imm_rotation) - /// FCMLA Ztied1.S, Pg/M, Zop2.S, Zop3.S, #imm_rotation + /// svfloat32_t svcmla[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3, uint64_t imm_rotation) + /// svfloat32_t svcmla[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3, uint64_t imm_rotation) + /// svfloat32_t svcmla[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2, svfloat32_t op3, uint64_t imm_rotation) + /// FCMLA Ztied1.S, Pg/M, Zop2.S, Zop3.S, #imm_rotation /// - public static unsafe Vector MultiplyAddRotateComplex(Vector addend, Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(3))] byte rotation) => MultiplyAddRotateComplex(addend, left, right, rotation); + public static Vector MultiplyAddRotateComplex(Vector addend, Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(3))] byte rotation) => MultiplyAddRotateComplex(addend, left, right, rotation); // Complex multiply-add with rotate /// - /// svfloat32_t svcmla_lane[_f32](svfloat32_t op1, svfloat32_t op2, svfloat32_t op3, uint64_t imm_index, uint64_t imm_rotation) - /// FCMLA Ztied1.S, Zop2.S, Zop3.S[imm_index], #imm_rotation + /// svfloat32_t svcmla_lane[_f32](svfloat32_t op1, svfloat32_t op2, svfloat32_t op3, uint64_t imm_index, uint64_t imm_rotation) + /// FCMLA Ztied1.S, Zop2.S, Zop3.S[imm_index], #imm_rotation /// - public static unsafe Vector MultiplyAddRotateComplexBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(1))] byte rightIndex, [ConstantExpected(Min = 0, Max = (byte)(3))] byte rotation) => MultiplyAddRotateComplexBySelectedScalar(addend, left, right, rightIndex, rotation); + public static Vector MultiplyAddRotateComplexBySelectedScalar(Vector addend, Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(1))] byte rightIndex, [ConstantExpected(Min = 0, Max = (byte)(3))] byte rotation) => MultiplyAddRotateComplexBySelectedScalar(addend, left, right, rightIndex, rotation); // Multiply /// - /// svfloat64_t svmul_lane[_f64](svfloat64_t op1, svfloat64_t op2, uint64_t imm_index) - /// FMUL Zresult.D, Zop1.D, Zop2.D[imm_index] + /// svfloat64_t svmul_lane[_f64](svfloat64_t op1, svfloat64_t op2, uint64_t imm_index) + /// FMUL Zresult.D, Zop1.D, Zop2.D[imm_index] /// - public static unsafe Vector MultiplyBySelectedScalar(Vector left, Vector right, [ConstantExpected] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); + public static Vector MultiplyBySelectedScalar(Vector left, Vector right, [ConstantExpected] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); /// - /// svfloat32_t svmul_lane[_f32](svfloat32_t op1, svfloat32_t op2, uint64_t imm_index) - /// FMUL Zresult.S, Zop1.S, Zop2.S[imm_index] + /// svfloat32_t svmul_lane[_f32](svfloat32_t op1, svfloat32_t op2, uint64_t imm_index) + /// FMUL Zresult.S, Zop1.S, Zop2.S[imm_index] /// - public static unsafe Vector MultiplyBySelectedScalar(Vector left, Vector right, [ConstantExpected] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); + public static Vector MultiplyBySelectedScalar(Vector left, Vector right, [ConstantExpected] byte rightIndex) => MultiplyBySelectedScalar(left, right, rightIndex); // Multiply extended (∞×0=2) /// - /// svfloat64_t svmulx[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svmulx[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svmulx[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FMULX Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svfloat64_t svmulx[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svmulx[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svmulx[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FMULX Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector MultiplyExtended(Vector left, Vector right) => MultiplyExtended(left, right); + public static Vector MultiplyExtended(Vector left, Vector right) => MultiplyExtended(left, right); /// - /// svfloat32_t svmulx[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svmulx[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svmulx[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FMULX Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svfloat32_t svmulx[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svmulx[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svmulx[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FMULX Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector MultiplyExtended(Vector left, Vector right) => MultiplyExtended(left, right); + public static Vector MultiplyExtended(Vector left, Vector right) => MultiplyExtended(left, right); // Multiply-subtract, minuend first /// - /// svuint8_t svmls[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2, svuint8_t op3) - /// svuint8_t svmls[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2, svuint8_t op3) - /// svuint8_t svmls[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2, svuint8_t op3) - /// MLS Ztied1.B, Pg/M, Zop2.B, Zop3.B + /// svuint8_t svmls[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2, svuint8_t op3) + /// svuint8_t svmls[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2, svuint8_t op3) + /// svuint8_t svmls[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2, svuint8_t op3) + /// MLS Ztied1.B, Pg/M, Zop2.B, Zop3.B /// - public static unsafe Vector MultiplySubtract(Vector minuend, Vector left, Vector right) => MultiplySubtract(minuend, left, right); + public static Vector MultiplySubtract(Vector minuend, Vector left, Vector right) => MultiplySubtract(minuend, left, right); /// - /// svint16_t svmls[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2, svint16_t op3) - /// svint16_t svmls[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2, svint16_t op3) - /// svint16_t svmls[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2, svint16_t op3) - /// MLS Ztied1.H, Pg/M, Zop2.H, Zop3.H + /// svint16_t svmls[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2, svint16_t op3) + /// svint16_t svmls[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2, svint16_t op3) + /// svint16_t svmls[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2, svint16_t op3) + /// MLS Ztied1.H, Pg/M, Zop2.H, Zop3.H /// - public static unsafe Vector MultiplySubtract(Vector minuend, Vector left, Vector right) => MultiplySubtract(minuend, left, right); + public static Vector MultiplySubtract(Vector minuend, Vector left, Vector right) => MultiplySubtract(minuend, left, right); /// - /// svint32_t svmls[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2, svint32_t op3) - /// svint32_t svmls[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2, svint32_t op3) - /// svint32_t svmls[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2, svint32_t op3) - /// MLS Ztied1.S, Pg/M, Zop2.S, Zop3.S + /// svint32_t svmls[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2, svint32_t op3) + /// svint32_t svmls[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2, svint32_t op3) + /// svint32_t svmls[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2, svint32_t op3) + /// MLS Ztied1.S, Pg/M, Zop2.S, Zop3.S /// - public static unsafe Vector MultiplySubtract(Vector minuend, Vector left, Vector right) => MultiplySubtract(minuend, left, right); + public static Vector MultiplySubtract(Vector minuend, Vector left, Vector right) => MultiplySubtract(minuend, left, right); /// - /// svint64_t svmls[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2, svint64_t op3) - /// svint64_t svmls[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2, svint64_t op3) - /// svint64_t svmls[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2, svint64_t op3) - /// MLS Ztied1.D, Pg/M, Zop2.D, Zop3.D + /// svint64_t svmls[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2, svint64_t op3) + /// svint64_t svmls[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2, svint64_t op3) + /// svint64_t svmls[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2, svint64_t op3) + /// MLS Ztied1.D, Pg/M, Zop2.D, Zop3.D /// - public static unsafe Vector MultiplySubtract(Vector minuend, Vector left, Vector right) => MultiplySubtract(minuend, left, right); + public static Vector MultiplySubtract(Vector minuend, Vector left, Vector right) => MultiplySubtract(minuend, left, right); /// - /// svint8_t svmls[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2, svint8_t op3) - /// svint8_t svmls[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2, svint8_t op3) - /// svint8_t svmls[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2, svint8_t op3) - /// MLS Ztied1.B, Pg/M, Zop2.B, Zop3.B + /// svint8_t svmls[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2, svint8_t op3) + /// svint8_t svmls[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2, svint8_t op3) + /// svint8_t svmls[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2, svint8_t op3) + /// MLS Ztied1.B, Pg/M, Zop2.B, Zop3.B /// - public static unsafe Vector MultiplySubtract(Vector minuend, Vector left, Vector right) => MultiplySubtract(minuend, left, right); + public static Vector MultiplySubtract(Vector minuend, Vector left, Vector right) => MultiplySubtract(minuend, left, right); /// - /// svuint16_t svmls[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2, svuint16_t op3) - /// svuint16_t svmls[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2, svuint16_t op3) - /// svuint16_t svmls[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2, svuint16_t op3) - /// MLS Ztied1.H, Pg/M, Zop2.H, Zop3.H + /// svuint16_t svmls[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2, svuint16_t op3) + /// svuint16_t svmls[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2, svuint16_t op3) + /// svuint16_t svmls[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2, svuint16_t op3) + /// MLS Ztied1.H, Pg/M, Zop2.H, Zop3.H /// - public static unsafe Vector MultiplySubtract(Vector minuend, Vector left, Vector right) => MultiplySubtract(minuend, left, right); + public static Vector MultiplySubtract(Vector minuend, Vector left, Vector right) => MultiplySubtract(minuend, left, right); /// - /// svuint32_t svmls[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2, svuint32_t op3) - /// svuint32_t svmls[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2, svuint32_t op3) - /// svuint32_t svmls[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2, svuint32_t op3) - /// MLS Ztied1.S, Pg/M, Zop2.S, Zop3.S + /// svuint32_t svmls[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2, svuint32_t op3) + /// svuint32_t svmls[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2, svuint32_t op3) + /// svuint32_t svmls[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2, svuint32_t op3) + /// MLS Ztied1.S, Pg/M, Zop2.S, Zop3.S /// - public static unsafe Vector MultiplySubtract(Vector minuend, Vector left, Vector right) => MultiplySubtract(minuend, left, right); + public static Vector MultiplySubtract(Vector minuend, Vector left, Vector right) => MultiplySubtract(minuend, left, right); /// - /// svuint64_t svmls[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2, svuint64_t op3) - /// svuint64_t svmls[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2, svuint64_t op3) - /// svuint64_t svmls[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2, svuint64_t op3) - /// MLS Ztied1.D, Pg/M, Zop2.D, Zop3.D + /// svuint64_t svmls[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2, svuint64_t op3) + /// svuint64_t svmls[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2, svuint64_t op3) + /// svuint64_t svmls[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2, svuint64_t op3) + /// MLS Ztied1.D, Pg/M, Zop2.D, Zop3.D /// - public static unsafe Vector MultiplySubtract(Vector minuend, Vector left, Vector right) => MultiplySubtract(minuend, left, right); + public static Vector MultiplySubtract(Vector minuend, Vector left, Vector right) => MultiplySubtract(minuend, left, right); // Negate /// - /// svfloat64_t svneg[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) - /// svfloat64_t svneg[_f64]_x(svbool_t pg, svfloat64_t op) - /// svfloat64_t svneg[_f64]_z(svbool_t pg, svfloat64_t op) - /// FNEG Ztied.D, Pg/M, Zop.D + /// svfloat64_t svneg[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) + /// svfloat64_t svneg[_f64]_x(svbool_t pg, svfloat64_t op) + /// svfloat64_t svneg[_f64]_z(svbool_t pg, svfloat64_t op) + /// FNEG Ztied.D, Pg/M, Zop.D /// - public static unsafe Vector Negate(Vector value) => Negate(value); + public static Vector Negate(Vector value) => Negate(value); /// - /// svint16_t svneg[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) - /// svint16_t svneg[_s16]_x(svbool_t pg, svint16_t op) - /// svint16_t svneg[_s16]_z(svbool_t pg, svint16_t op) - /// NEG Ztied.H, Pg/M, Zop.H + /// svint16_t svneg[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) + /// svint16_t svneg[_s16]_x(svbool_t pg, svint16_t op) + /// svint16_t svneg[_s16]_z(svbool_t pg, svint16_t op) + /// NEG Ztied.H, Pg/M, Zop.H /// - public static unsafe Vector Negate(Vector value) => Negate(value); + public static Vector Negate(Vector value) => Negate(value); /// - /// svint32_t svneg[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) - /// svint32_t svneg[_s32]_x(svbool_t pg, svint32_t op) - /// svint32_t svneg[_s32]_z(svbool_t pg, svint32_t op) - /// NEG Ztied.S, Pg/M, Zop.S + /// svint32_t svneg[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) + /// svint32_t svneg[_s32]_x(svbool_t pg, svint32_t op) + /// svint32_t svneg[_s32]_z(svbool_t pg, svint32_t op) + /// NEG Ztied.S, Pg/M, Zop.S /// - public static unsafe Vector Negate(Vector value) => Negate(value); + public static Vector Negate(Vector value) => Negate(value); /// - /// svint64_t svneg[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) - /// svint64_t svneg[_s64]_x(svbool_t pg, svint64_t op) - /// svint64_t svneg[_s64]_z(svbool_t pg, svint64_t op) - /// NEG Ztied.D, Pg/M, Zop.D + /// svint64_t svneg[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) + /// svint64_t svneg[_s64]_x(svbool_t pg, svint64_t op) + /// svint64_t svneg[_s64]_z(svbool_t pg, svint64_t op) + /// NEG Ztied.D, Pg/M, Zop.D /// - public static unsafe Vector Negate(Vector value) => Negate(value); + public static Vector Negate(Vector value) => Negate(value); /// - /// svint8_t svneg[_s8]_m(svint8_t inactive, svbool_t pg, svint8_t op) - /// svint8_t svneg[_s8]_x(svbool_t pg, svint8_t op) - /// svint8_t svneg[_s8]_z(svbool_t pg, svint8_t op) - /// NEG Ztied.B, Pg/M, Zop.B + /// svint8_t svneg[_s8]_m(svint8_t inactive, svbool_t pg, svint8_t op) + /// svint8_t svneg[_s8]_x(svbool_t pg, svint8_t op) + /// svint8_t svneg[_s8]_z(svbool_t pg, svint8_t op) + /// NEG Ztied.B, Pg/M, Zop.B /// - public static unsafe Vector Negate(Vector value) => Negate(value); + public static Vector Negate(Vector value) => Negate(value); /// - /// svfloat32_t svneg[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) - /// svfloat32_t svneg[_f32]_x(svbool_t pg, svfloat32_t op) - /// svfloat32_t svneg[_f32]_z(svbool_t pg, svfloat32_t op) - /// FNEG Ztied.S, Pg/M, Zop.S + /// svfloat32_t svneg[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) + /// svfloat32_t svneg[_f32]_x(svbool_t pg, svfloat32_t op) + /// svfloat32_t svneg[_f32]_z(svbool_t pg, svfloat32_t op) + /// FNEG Ztied.S, Pg/M, Zop.S /// - public static unsafe Vector Negate(Vector value) => Negate(value); + public static Vector Negate(Vector value) => Negate(value); // Bitwise invert /// - /// svuint8_t svnot[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) - /// svuint8_t svnot[_u8]_x(svbool_t pg, svuint8_t op) - /// svuint8_t svnot[_u8]_z(svbool_t pg, svuint8_t op) - /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) - /// NOT Zresult.B, Pg/M, Zop.B + /// svuint8_t svnot[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) + /// svuint8_t svnot[_u8]_x(svbool_t pg, svuint8_t op) + /// svuint8_t svnot[_u8]_z(svbool_t pg, svuint8_t op) + /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) + /// NOT Zresult.B, Pg/M, Zop.B /// - public static unsafe Vector Not(Vector value) => Not(value); + public static Vector Not(Vector value) => Not(value); /// - /// svint16_t svnot[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) - /// svint16_t svnot[_s16]_x(svbool_t pg, svint16_t op) - /// svint16_t svnot[_s16]_z(svbool_t pg, svint16_t op) - /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) - /// NOT Zresult.H, Pg/M, Zop.H + /// svint16_t svnot[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) + /// svint16_t svnot[_s16]_x(svbool_t pg, svint16_t op) + /// svint16_t svnot[_s16]_z(svbool_t pg, svint16_t op) + /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) + /// NOT Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector Not(Vector value) => Not(value); + public static Vector Not(Vector value) => Not(value); /// - /// svint32_t svnot[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) - /// svint32_t svnot[_s32]_x(svbool_t pg, svint32_t op) - /// svint32_t svnot[_s32]_z(svbool_t pg, svint32_t op) - /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) - /// NOT Zresult.S, Pg/M, Zop.S + /// svint32_t svnot[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) + /// svint32_t svnot[_s32]_x(svbool_t pg, svint32_t op) + /// svint32_t svnot[_s32]_z(svbool_t pg, svint32_t op) + /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) + /// NOT Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector Not(Vector value) => Not(value); + public static Vector Not(Vector value) => Not(value); /// - /// svint64_t svnot[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) - /// svint64_t svnot[_s64]_x(svbool_t pg, svint64_t op) - /// svint64_t svnot[_s64]_z(svbool_t pg, svint64_t op) - /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) - /// NOT Zresult.D, Pg/M, Zop.D + /// svint64_t svnot[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) + /// svint64_t svnot[_s64]_x(svbool_t pg, svint64_t op) + /// svint64_t svnot[_s64]_z(svbool_t pg, svint64_t op) + /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) + /// NOT Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector Not(Vector value) => Not(value); + public static Vector Not(Vector value) => Not(value); /// - /// svint8_t svnot[_s8]_m(svint8_t inactive, svbool_t pg, svint8_t op) - /// svint8_t svnot[_s8]_x(svbool_t pg, svint8_t op) - /// svint8_t svnot[_s8]_z(svbool_t pg, svint8_t op) - /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) - /// NOT Zresult.B, Pg/M, Zop.B + /// svint8_t svnot[_s8]_m(svint8_t inactive, svbool_t pg, svint8_t op) + /// svint8_t svnot[_s8]_x(svbool_t pg, svint8_t op) + /// svint8_t svnot[_s8]_z(svbool_t pg, svint8_t op) + /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) + /// NOT Zresult.B, Pg/M, Zop.B /// - public static unsafe Vector Not(Vector value) => Not(value); + public static Vector Not(Vector value) => Not(value); /// - /// svuint16_t svnot[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) - /// svuint16_t svnot[_u16]_x(svbool_t pg, svuint16_t op) - /// svuint16_t svnot[_u16]_z(svbool_t pg, svuint16_t op) - /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) - /// NOT Zresult.H, Pg/M, Zop.H + /// svuint16_t svnot[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) + /// svuint16_t svnot[_u16]_x(svbool_t pg, svuint16_t op) + /// svuint16_t svnot[_u16]_z(svbool_t pg, svuint16_t op) + /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) + /// NOT Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector Not(Vector value) => Not(value); + public static Vector Not(Vector value) => Not(value); /// - /// svuint32_t svnot[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) - /// svuint32_t svnot[_u32]_x(svbool_t pg, svuint32_t op) - /// svuint32_t svnot[_u32]_z(svbool_t pg, svuint32_t op) - /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) - /// NOT Zresult.S, Pg/M, Zop.S + /// svuint32_t svnot[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) + /// svuint32_t svnot[_u32]_x(svbool_t pg, svuint32_t op) + /// svuint32_t svnot[_u32]_z(svbool_t pg, svuint32_t op) + /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) + /// NOT Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector Not(Vector value) => Not(value); + public static Vector Not(Vector value) => Not(value); /// - /// svuint64_t svnot[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) - /// svuint64_t svnot[_u64]_x(svbool_t pg, svuint64_t op) - /// svuint64_t svnot[_u64]_z(svbool_t pg, svuint64_t op) - /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) - /// NOT Zresult.D, Pg/M, Zop.D + /// svuint64_t svnot[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) + /// svuint64_t svnot[_u64]_x(svbool_t pg, svuint64_t op) + /// svuint64_t svnot[_u64]_z(svbool_t pg, svuint64_t op) + /// svbool_t svnot[_b]_z(svbool_t pg, svbool_t op) + /// NOT Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector Not(Vector value) => Not(value); + public static Vector Not(Vector value) => Not(value); // Bitwise inclusive OR /// - /// svuint8_t svorr[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svorr[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svorr[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// ORR Zresult.D, Zop1.D, Zop2.D + /// svuint8_t svorr[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svorr[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svorr[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// ORR Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector Or(Vector left, Vector right) => Or(left, right); + public static Vector Or(Vector left, Vector right) => Or(left, right); /// - /// svint16_t svorr[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svorr[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svorr[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) - /// ORR Zresult.D, Zop1.D, Zop2.D + /// svint16_t svorr[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svorr[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svorr[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) + /// ORR Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector Or(Vector left, Vector right) => Or(left, right); + public static Vector Or(Vector left, Vector right) => Or(left, right); /// - /// svint32_t svorr[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svorr[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svorr[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) - /// ORR Zresult.D, Zop1.D, Zop2.D + /// svint32_t svorr[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svorr[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svorr[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) + /// ORR Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector Or(Vector left, Vector right) => Or(left, right); + public static Vector Or(Vector left, Vector right) => Or(left, right); /// - /// svint64_t svorr[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svorr[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svorr[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) - /// ORR Zresult.D, Zop1.D, Zop2.D + /// svint64_t svorr[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svorr[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svorr[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) + /// ORR Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector Or(Vector left, Vector right) => Or(left, right); + public static Vector Or(Vector left, Vector right) => Or(left, right); /// - /// svint8_t svorr[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svorr[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svorr[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) - /// ORR Zresult.D, Zop1.D, Zop2.D + /// svint8_t svorr[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svorr[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svorr[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) + /// ORR Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector Or(Vector left, Vector right) => Or(left, right); + public static Vector Or(Vector left, Vector right) => Or(left, right); /// - /// svuint16_t svorr[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svorr[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svorr[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// ORR Zresult.D, Zop1.D, Zop2.D + /// svuint16_t svorr[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svorr[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svorr[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// ORR Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector Or(Vector left, Vector right) => Or(left, right); + public static Vector Or(Vector left, Vector right) => Or(left, right); /// - /// svuint32_t svorr[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svorr[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svorr[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// ORR Zresult.D, Zop1.D, Zop2.D + /// svuint32_t svorr[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svorr[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svorr[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// ORR Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector Or(Vector left, Vector right) => Or(left, right); + public static Vector Or(Vector left, Vector right) => Or(left, right); /// - /// svuint64_t svorr[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svorr[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svorr[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// ORR Zresult.D, Zop1.D, Zop2.D + /// svuint64_t svorr[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svorr[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svorr[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// ORR Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector Or(Vector left, Vector right) => Or(left, right); + public static Vector Or(Vector left, Vector right) => Or(left, right); // Bitwise inclusive OR reduction to scalar /// - /// uint8_t svorv[_u8](svbool_t pg, svuint8_t op) - /// ORV Bresult, Pg, Zop.B + /// uint8_t svorv[_u8](svbool_t pg, svuint8_t op) + /// ORV Bresult, Pg, Zop.B /// - public static unsafe Vector OrAcross(Vector value) => OrAcross(value); + public static Vector OrAcross(Vector value) => OrAcross(value); /// - /// int16_t svorv[_s16](svbool_t pg, svint16_t op) - /// ORV Hresult, Pg, Zop.H + /// int16_t svorv[_s16](svbool_t pg, svint16_t op) + /// ORV Hresult, Pg, Zop.H /// - public static unsafe Vector OrAcross(Vector value) => OrAcross(value); + public static Vector OrAcross(Vector value) => OrAcross(value); /// - /// int32_t svorv[_s32](svbool_t pg, svint32_t op) - /// ORV Sresult, Pg, Zop.S + /// int32_t svorv[_s32](svbool_t pg, svint32_t op) + /// ORV Sresult, Pg, Zop.S /// - public static unsafe Vector OrAcross(Vector value) => OrAcross(value); + public static Vector OrAcross(Vector value) => OrAcross(value); /// - /// int64_t svorv[_s64](svbool_t pg, svint64_t op) - /// ORV Dresult, Pg, Zop.D + /// int64_t svorv[_s64](svbool_t pg, svint64_t op) + /// ORV Dresult, Pg, Zop.D /// - public static unsafe Vector OrAcross(Vector value) => OrAcross(value); + public static Vector OrAcross(Vector value) => OrAcross(value); /// - /// int8_t svorv[_s8](svbool_t pg, svint8_t op) - /// ORV Bresult, Pg, Zop.B + /// int8_t svorv[_s8](svbool_t pg, svint8_t op) + /// ORV Bresult, Pg, Zop.B /// - public static unsafe Vector OrAcross(Vector value) => OrAcross(value); + public static Vector OrAcross(Vector value) => OrAcross(value); /// - /// uint16_t svorv[_u16](svbool_t pg, svuint16_t op) - /// ORV Hresult, Pg, Zop.H + /// uint16_t svorv[_u16](svbool_t pg, svuint16_t op) + /// ORV Hresult, Pg, Zop.H /// - public static unsafe Vector OrAcross(Vector value) => OrAcross(value); + public static Vector OrAcross(Vector value) => OrAcross(value); /// - /// uint32_t svorv[_u32](svbool_t pg, svuint32_t op) - /// ORV Sresult, Pg, Zop.S + /// uint32_t svorv[_u32](svbool_t pg, svuint32_t op) + /// ORV Sresult, Pg, Zop.S /// - public static unsafe Vector OrAcross(Vector value) => OrAcross(value); + public static Vector OrAcross(Vector value) => OrAcross(value); /// - /// uint64_t svorv[_u64](svbool_t pg, svuint64_t op) - /// ORV Dresult, Pg, Zop.D + /// uint64_t svorv[_u64](svbool_t pg, svuint64_t op) + /// ORV Dresult, Pg, Zop.D /// - public static unsafe Vector OrAcross(Vector value) => OrAcross(value); + public static Vector OrAcross(Vector value) => OrAcross(value); // Count nonzero bits /// - /// svuint8_t svcnt[_s8]_m(svuint8_t inactive, svbool_t pg, svint8_t op) - /// svuint8_t svcnt[_s8]_x(svbool_t pg, svint8_t op) - /// svuint8_t svcnt[_s8]_z(svbool_t pg, svint8_t op) - /// CNT Zresult.B, Pg/M, Zop.B + /// svuint8_t svcnt[_s8]_m(svuint8_t inactive, svbool_t pg, svint8_t op) + /// svuint8_t svcnt[_s8]_x(svbool_t pg, svint8_t op) + /// svuint8_t svcnt[_s8]_z(svbool_t pg, svint8_t op) + /// CNT Zresult.B, Pg/M, Zop.B /// - public static unsafe Vector PopCount(Vector value) => PopCount(value); + public static Vector PopCount(Vector value) => PopCount(value); /// - /// svuint8_t svcnt[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) - /// svuint8_t svcnt[_u8]_x(svbool_t pg, svuint8_t op) - /// svuint8_t svcnt[_u8]_z(svbool_t pg, svuint8_t op) - /// CNT Zresult.B, Pg/M, Zop.B + /// svuint8_t svcnt[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) + /// svuint8_t svcnt[_u8]_x(svbool_t pg, svuint8_t op) + /// svuint8_t svcnt[_u8]_z(svbool_t pg, svuint8_t op) + /// CNT Zresult.B, Pg/M, Zop.B /// - public static unsafe Vector PopCount(Vector value) => PopCount(value); + public static Vector PopCount(Vector value) => PopCount(value); /// - /// svuint16_t svcnt[_s16]_m(svuint16_t inactive, svbool_t pg, svint16_t op) - /// svuint16_t svcnt[_s16]_x(svbool_t pg, svint16_t op) - /// svuint16_t svcnt[_s16]_z(svbool_t pg, svint16_t op) - /// CNT Zresult.H, Pg/M, Zop.H + /// svuint16_t svcnt[_s16]_m(svuint16_t inactive, svbool_t pg, svint16_t op) + /// svuint16_t svcnt[_s16]_x(svbool_t pg, svint16_t op) + /// svuint16_t svcnt[_s16]_z(svbool_t pg, svint16_t op) + /// CNT Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector PopCount(Vector value) => PopCount(value); + public static Vector PopCount(Vector value) => PopCount(value); /// - /// svuint16_t svcnt[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) - /// svuint16_t svcnt[_u16]_x(svbool_t pg, svuint16_t op) - /// svuint16_t svcnt[_u16]_z(svbool_t pg, svuint16_t op) - /// CNT Zresult.H, Pg/M, Zop.H + /// svuint16_t svcnt[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) + /// svuint16_t svcnt[_u16]_x(svbool_t pg, svuint16_t op) + /// svuint16_t svcnt[_u16]_z(svbool_t pg, svuint16_t op) + /// CNT Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector PopCount(Vector value) => PopCount(value); + public static Vector PopCount(Vector value) => PopCount(value); /// - /// svuint32_t svcnt[_s32]_m(svuint32_t inactive, svbool_t pg, svint32_t op) - /// svuint32_t svcnt[_s32]_x(svbool_t pg, svint32_t op) - /// svuint32_t svcnt[_s32]_z(svbool_t pg, svint32_t op) - /// CNT Zresult.S, Pg/M, Zop.S + /// svuint32_t svcnt[_s32]_m(svuint32_t inactive, svbool_t pg, svint32_t op) + /// svuint32_t svcnt[_s32]_x(svbool_t pg, svint32_t op) + /// svuint32_t svcnt[_s32]_z(svbool_t pg, svint32_t op) + /// CNT Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector PopCount(Vector value) => PopCount(value); + public static Vector PopCount(Vector value) => PopCount(value); /// - /// svuint32_t svcnt[_f32]_m(svuint32_t inactive, svbool_t pg, svfloat32_t op) - /// svuint32_t svcnt[_f32]_x(svbool_t pg, svfloat32_t op) - /// svuint32_t svcnt[_f32]_z(svbool_t pg, svfloat32_t op) - /// CNT Zresult.S, Pg/M, Zop.S + /// svuint32_t svcnt[_f32]_m(svuint32_t inactive, svbool_t pg, svfloat32_t op) + /// svuint32_t svcnt[_f32]_x(svbool_t pg, svfloat32_t op) + /// svuint32_t svcnt[_f32]_z(svbool_t pg, svfloat32_t op) + /// CNT Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector PopCount(Vector value) => PopCount(value); + public static Vector PopCount(Vector value) => PopCount(value); /// - /// svuint32_t svcnt[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) - /// svuint32_t svcnt[_u32]_x(svbool_t pg, svuint32_t op) - /// svuint32_t svcnt[_u32]_z(svbool_t pg, svuint32_t op) - /// CNT Zresult.S, Pg/M, Zop.S + /// svuint32_t svcnt[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) + /// svuint32_t svcnt[_u32]_x(svbool_t pg, svuint32_t op) + /// svuint32_t svcnt[_u32]_z(svbool_t pg, svuint32_t op) + /// CNT Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector PopCount(Vector value) => PopCount(value); + public static Vector PopCount(Vector value) => PopCount(value); /// - /// svuint64_t svcnt[_f64]_m(svuint64_t inactive, svbool_t pg, svfloat64_t op) - /// svuint64_t svcnt[_f64]_x(svbool_t pg, svfloat64_t op) - /// svuint64_t svcnt[_f64]_z(svbool_t pg, svfloat64_t op) - /// CNT Zresult.D, Pg/M, Zop.D + /// svuint64_t svcnt[_f64]_m(svuint64_t inactive, svbool_t pg, svfloat64_t op) + /// svuint64_t svcnt[_f64]_x(svbool_t pg, svfloat64_t op) + /// svuint64_t svcnt[_f64]_z(svbool_t pg, svfloat64_t op) + /// CNT Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector PopCount(Vector value) => PopCount(value); + public static Vector PopCount(Vector value) => PopCount(value); /// - /// svuint64_t svcnt[_s64]_m(svuint64_t inactive, svbool_t pg, svint64_t op) - /// svuint64_t svcnt[_s64]_x(svbool_t pg, svint64_t op) - /// svuint64_t svcnt[_s64]_z(svbool_t pg, svint64_t op) - /// CNT Zresult.D, Pg/M, Zop.D + /// svuint64_t svcnt[_s64]_m(svuint64_t inactive, svbool_t pg, svint64_t op) + /// svuint64_t svcnt[_s64]_x(svbool_t pg, svint64_t op) + /// svuint64_t svcnt[_s64]_z(svbool_t pg, svint64_t op) + /// CNT Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector PopCount(Vector value) => PopCount(value); + public static Vector PopCount(Vector value) => PopCount(value); /// - /// svuint64_t svcnt[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) - /// svuint64_t svcnt[_u64]_x(svbool_t pg, svuint64_t op) - /// svuint64_t svcnt[_u64]_z(svbool_t pg, svuint64_t op) - /// CNT Zresult.D, Pg/M, Zop.D + /// svuint64_t svcnt[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) + /// svuint64_t svcnt[_u64]_x(svbool_t pg, svuint64_t op) + /// svuint64_t svcnt[_u64]_z(svbool_t pg, svuint64_t op) + /// CNT Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector PopCount(Vector value) => PopCount(value); + public static Vector PopCount(Vector value) => PopCount(value); // Prefetch bytes /// - /// void svprfb(svbool_t pg, const void *base, enum svprfop op) - /// PRFB op, Pg, [Xbase, #0, MUL VL] + /// void svprfb(svbool_t pg, const void *base, enum svprfop op) + /// PRFB op, Pg, [Xbase, #0, MUL VL] /// public static unsafe void PrefetchBytes(Vector mask, void* address, [ConstantExpected] SvePrefetchType prefetchType) => PrefetchBytes(mask, address, prefetchType); @@ -6765,8 +7425,8 @@ internal Arm64() { } // Prefetch halfwords /// - /// void svprfh(svbool_t pg, const void *base, enum svprfop op) - /// PRFH op, Pg, [Xbase, #0, MUL VL] + /// void svprfh(svbool_t pg, const void *base, enum svprfop op) + /// PRFH op, Pg, [Xbase, #0, MUL VL] /// public static unsafe void PrefetchInt16(Vector mask, void* address, [ConstantExpected] SvePrefetchType prefetchType) => PrefetchInt16(mask, address, prefetchType); @@ -6774,8 +7434,8 @@ internal Arm64() { } // Prefetch words /// - /// void svprfw(svbool_t pg, const void *base, enum svprfop op) - /// PRFW op, Pg, [Xbase, #0, MUL VL] + /// void svprfw(svbool_t pg, const void *base, enum svprfop op) + /// PRFW op, Pg, [Xbase, #0, MUL VL] /// public static unsafe void PrefetchInt32(Vector mask, void* address, [ConstantExpected] SvePrefetchType prefetchType) => PrefetchInt32(mask, address, prefetchType); @@ -6783,8 +7443,8 @@ internal Arm64() { } // Prefetch doublewords /// - /// void svprfd(svbool_t pg, const void *base, enum svprfop op) - /// PRFD op, Pg, [Xbase, #0, MUL VL] + /// void svprfd(svbool_t pg, const void *base, enum svprfop op) + /// PRFD op, Pg, [Xbase, #0, MUL VL] /// public static unsafe void PrefetchInt64(Vector mask, void* address, [ConstantExpected] SvePrefetchType prefetchType) => PrefetchInt64(mask, address, prefetchType); @@ -6792,1012 +7452,1012 @@ internal Arm64() { } // Reciprocal estimate /// - /// svfloat64_t svrecpe[_f64](svfloat64_t op) - /// FRECPE Zresult.D, Zop.D + /// svfloat64_t svrecpe[_f64](svfloat64_t op) + /// FRECPE Zresult.D, Zop.D /// - public static unsafe Vector ReciprocalEstimate(Vector value) => ReciprocalEstimate(value); + public static Vector ReciprocalEstimate(Vector value) => ReciprocalEstimate(value); /// - /// svfloat32_t svrecpe[_f32](svfloat32_t op) - /// FRECPE Zresult.S, Zop.S + /// svfloat32_t svrecpe[_f32](svfloat32_t op) + /// FRECPE Zresult.S, Zop.S /// - public static unsafe Vector ReciprocalEstimate(Vector value) => ReciprocalEstimate(value); + public static Vector ReciprocalEstimate(Vector value) => ReciprocalEstimate(value); // Reciprocal exponent /// - /// svfloat64_t svrecpx[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) - /// svfloat64_t svrecpx[_f64]_x(svbool_t pg, svfloat64_t op) - /// svfloat64_t svrecpx[_f64]_z(svbool_t pg, svfloat64_t op) - /// FRECPX Zresult.D, Pg/M, Zop.D + /// svfloat64_t svrecpx[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) + /// svfloat64_t svrecpx[_f64]_x(svbool_t pg, svfloat64_t op) + /// svfloat64_t svrecpx[_f64]_z(svbool_t pg, svfloat64_t op) + /// FRECPX Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ReciprocalExponent(Vector value) => ReciprocalExponent(value); + public static Vector ReciprocalExponent(Vector value) => ReciprocalExponent(value); /// - /// svfloat32_t svrecpx[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) - /// svfloat32_t svrecpx[_f32]_x(svbool_t pg, svfloat32_t op) - /// svfloat32_t svrecpx[_f32]_z(svbool_t pg, svfloat32_t op) - /// FRECPX Zresult.S, Pg/M, Zop.S + /// svfloat32_t svrecpx[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) + /// svfloat32_t svrecpx[_f32]_x(svbool_t pg, svfloat32_t op) + /// svfloat32_t svrecpx[_f32]_z(svbool_t pg, svfloat32_t op) + /// FRECPX Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ReciprocalExponent(Vector value) => ReciprocalExponent(value); + public static Vector ReciprocalExponent(Vector value) => ReciprocalExponent(value); // Reciprocal square root estimate /// - /// svfloat64_t svrsqrte[_f64](svfloat64_t op) - /// FRSQRTE Zresult.D, Zop.D + /// svfloat64_t svrsqrte[_f64](svfloat64_t op) + /// FRSQRTE Zresult.D, Zop.D /// - public static unsafe Vector ReciprocalSqrtEstimate(Vector value) => ReciprocalSqrtEstimate(value); + public static Vector ReciprocalSqrtEstimate(Vector value) => ReciprocalSqrtEstimate(value); /// - /// svfloat32_t svrsqrte[_f32](svfloat32_t op) - /// FRSQRTE Zresult.S, Zop.S + /// svfloat32_t svrsqrte[_f32](svfloat32_t op) + /// FRSQRTE Zresult.S, Zop.S /// - public static unsafe Vector ReciprocalSqrtEstimate(Vector value) => ReciprocalSqrtEstimate(value); + public static Vector ReciprocalSqrtEstimate(Vector value) => ReciprocalSqrtEstimate(value); // Reciprocal square root step /// - /// svfloat64_t svrsqrts[_f64](svfloat64_t op1, svfloat64_t op2) - /// FRSQRTS Zresult.D, Zop1.D, Zop2.D + /// svfloat64_t svrsqrts[_f64](svfloat64_t op1, svfloat64_t op2) + /// FRSQRTS Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector ReciprocalSqrtStep(Vector left, Vector right) => ReciprocalSqrtStep(left, right); + public static Vector ReciprocalSqrtStep(Vector left, Vector right) => ReciprocalSqrtStep(left, right); /// - /// svfloat32_t svrsqrts[_f32](svfloat32_t op1, svfloat32_t op2) - /// FRSQRTS Zresult.S, Zop1.S, Zop2.S + /// svfloat32_t svrsqrts[_f32](svfloat32_t op1, svfloat32_t op2) + /// FRSQRTS Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector ReciprocalSqrtStep(Vector left, Vector right) => ReciprocalSqrtStep(left, right); + public static Vector ReciprocalSqrtStep(Vector left, Vector right) => ReciprocalSqrtStep(left, right); // Reciprocal step /// - /// svfloat64_t svrecps[_f64](svfloat64_t op1, svfloat64_t op2) - /// FRECPS Zresult.D, Zop1.D, Zop2.D + /// svfloat64_t svrecps[_f64](svfloat64_t op1, svfloat64_t op2) + /// FRECPS Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector ReciprocalStep(Vector left, Vector right) => ReciprocalStep(left, right); + public static Vector ReciprocalStep(Vector left, Vector right) => ReciprocalStep(left, right); /// - /// svfloat32_t svrecps[_f32](svfloat32_t op1, svfloat32_t op2) - /// FRECPS Zresult.S, Zop1.S, Zop2.S + /// svfloat32_t svrecps[_f32](svfloat32_t op1, svfloat32_t op2) + /// FRECPS Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector ReciprocalStep(Vector left, Vector right) => ReciprocalStep(left, right); + public static Vector ReciprocalStep(Vector left, Vector right) => ReciprocalStep(left, right); // Reverse bits /// - /// svuint8_t svrbit[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) - /// svuint8_t svrbit[_u8]_x(svbool_t pg, svuint8_t op) - /// svuint8_t svrbit[_u8]_z(svbool_t pg, svuint8_t op) - /// RBIT Zresult.B, Pg/M, Zop.B + /// svuint8_t svrbit[_u8]_m(svuint8_t inactive, svbool_t pg, svuint8_t op) + /// svuint8_t svrbit[_u8]_x(svbool_t pg, svuint8_t op) + /// svuint8_t svrbit[_u8]_z(svbool_t pg, svuint8_t op) + /// RBIT Zresult.B, Pg/M, Zop.B /// - public static unsafe Vector ReverseBits(Vector value) => ReverseBits(value); + public static Vector ReverseBits(Vector value) => ReverseBits(value); /// - /// svint16_t svrbit[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) - /// svint16_t svrbit[_s16]_x(svbool_t pg, svint16_t op) - /// svint16_t svrbit[_s16]_z(svbool_t pg, svint16_t op) - /// RBIT Zresult.H, Pg/M, Zop.H + /// svint16_t svrbit[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) + /// svint16_t svrbit[_s16]_x(svbool_t pg, svint16_t op) + /// svint16_t svrbit[_s16]_z(svbool_t pg, svint16_t op) + /// RBIT Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector ReverseBits(Vector value) => ReverseBits(value); + public static Vector ReverseBits(Vector value) => ReverseBits(value); /// - /// svint32_t svrbit[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) - /// svint32_t svrbit[_s32]_x(svbool_t pg, svint32_t op) - /// svint32_t svrbit[_s32]_z(svbool_t pg, svint32_t op) - /// RBIT Zresult.S, Pg/M, Zop.S + /// svint32_t svrbit[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) + /// svint32_t svrbit[_s32]_x(svbool_t pg, svint32_t op) + /// svint32_t svrbit[_s32]_z(svbool_t pg, svint32_t op) + /// RBIT Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ReverseBits(Vector value) => ReverseBits(value); + public static Vector ReverseBits(Vector value) => ReverseBits(value); /// - /// svint64_t svrbit[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) - /// svint64_t svrbit[_s64]_x(svbool_t pg, svint64_t op) - /// svint64_t svrbit[_s64]_z(svbool_t pg, svint64_t op) - /// RBIT Zresult.D, Pg/M, Zop.D + /// svint64_t svrbit[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) + /// svint64_t svrbit[_s64]_x(svbool_t pg, svint64_t op) + /// svint64_t svrbit[_s64]_z(svbool_t pg, svint64_t op) + /// RBIT Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ReverseBits(Vector value) => ReverseBits(value); + public static Vector ReverseBits(Vector value) => ReverseBits(value); /// - /// svint8_t svrbit[_s8]_m(svint8_t inactive, svbool_t pg, svint8_t op) - /// svint8_t svrbit[_s8]_x(svbool_t pg, svint8_t op) - /// svint8_t svrbit[_s8]_z(svbool_t pg, svint8_t op) - /// RBIT Zresult.B, Pg/M, Zop.B + /// svint8_t svrbit[_s8]_m(svint8_t inactive, svbool_t pg, svint8_t op) + /// svint8_t svrbit[_s8]_x(svbool_t pg, svint8_t op) + /// svint8_t svrbit[_s8]_z(svbool_t pg, svint8_t op) + /// RBIT Zresult.B, Pg/M, Zop.B /// - public static unsafe Vector ReverseBits(Vector value) => ReverseBits(value); + public static Vector ReverseBits(Vector value) => ReverseBits(value); /// - /// svuint16_t svrbit[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) - /// svuint16_t svrbit[_u16]_x(svbool_t pg, svuint16_t op) - /// svuint16_t svrbit[_u16]_z(svbool_t pg, svuint16_t op) - /// RBIT Zresult.H, Pg/M, Zop.H + /// svuint16_t svrbit[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) + /// svuint16_t svrbit[_u16]_x(svbool_t pg, svuint16_t op) + /// svuint16_t svrbit[_u16]_z(svbool_t pg, svuint16_t op) + /// RBIT Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector ReverseBits(Vector value) => ReverseBits(value); + public static Vector ReverseBits(Vector value) => ReverseBits(value); /// - /// svuint32_t svrbit[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) - /// svuint32_t svrbit[_u32]_x(svbool_t pg, svuint32_t op) - /// svuint32_t svrbit[_u32]_z(svbool_t pg, svuint32_t op) - /// RBIT Zresult.S, Pg/M, Zop.S + /// svuint32_t svrbit[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) + /// svuint32_t svrbit[_u32]_x(svbool_t pg, svuint32_t op) + /// svuint32_t svrbit[_u32]_z(svbool_t pg, svuint32_t op) + /// RBIT Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ReverseBits(Vector value) => ReverseBits(value); + public static Vector ReverseBits(Vector value) => ReverseBits(value); /// - /// svuint64_t svrbit[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) - /// svuint64_t svrbit[_u64]_x(svbool_t pg, svuint64_t op) - /// svuint64_t svrbit[_u64]_z(svbool_t pg, svuint64_t op) - /// RBIT Zresult.D, Pg/M, Zop.D + /// svuint64_t svrbit[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) + /// svuint64_t svrbit[_u64]_x(svbool_t pg, svuint64_t op) + /// svuint64_t svrbit[_u64]_z(svbool_t pg, svuint64_t op) + /// RBIT Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ReverseBits(Vector value) => ReverseBits(value); + public static Vector ReverseBits(Vector value) => ReverseBits(value); // Reverse all elements /// - /// svuint8_t svrev[_u8](svuint8_t op) - /// REV Zresult.B, Zop.B + /// svuint8_t svrev[_u8](svuint8_t op) + /// REV Zresult.B, Zop.B /// - public static unsafe Vector ReverseElement(Vector value) => ReverseElement(value); + public static Vector ReverseElement(Vector value) => ReverseElement(value); /// - /// svfloat64_t svrev[_f64](svfloat64_t op) - /// REV Zresult.D, Zop.D + /// svfloat64_t svrev[_f64](svfloat64_t op) + /// REV Zresult.D, Zop.D /// - public static unsafe Vector ReverseElement(Vector value) => ReverseElement(value); + public static Vector ReverseElement(Vector value) => ReverseElement(value); /// - /// svint16_t svrev[_s16](svint16_t op) - /// REV Zresult.H, Zop.H + /// svint16_t svrev[_s16](svint16_t op) + /// REV Zresult.H, Zop.H /// - public static unsafe Vector ReverseElement(Vector value) => ReverseElement(value); + public static Vector ReverseElement(Vector value) => ReverseElement(value); /// - /// svint32_t svrev[_s32](svint32_t op) - /// REV Zresult.S, Zop.S + /// svint32_t svrev[_s32](svint32_t op) + /// REV Zresult.S, Zop.S /// - public static unsafe Vector ReverseElement(Vector value) => ReverseElement(value); + public static Vector ReverseElement(Vector value) => ReverseElement(value); /// - /// svint64_t svrev[_s64](svint64_t op) - /// REV Zresult.D, Zop.D + /// svint64_t svrev[_s64](svint64_t op) + /// REV Zresult.D, Zop.D /// - public static unsafe Vector ReverseElement(Vector value) => ReverseElement(value); + public static Vector ReverseElement(Vector value) => ReverseElement(value); /// - /// svint8_t svrev[_s8](svint8_t op) - /// REV Zresult.B, Zop.B + /// svint8_t svrev[_s8](svint8_t op) + /// REV Zresult.B, Zop.B /// - public static unsafe Vector ReverseElement(Vector value) => ReverseElement(value); + public static Vector ReverseElement(Vector value) => ReverseElement(value); /// - /// svfloat32_t svrev[_f32](svfloat32_t op) - /// REV Zresult.S, Zop.S + /// svfloat32_t svrev[_f32](svfloat32_t op) + /// REV Zresult.S, Zop.S /// - public static unsafe Vector ReverseElement(Vector value) => ReverseElement(value); + public static Vector ReverseElement(Vector value) => ReverseElement(value); /// - /// svuint16_t svrev[_u16](svuint16_t op) - /// REV Zresult.H, Zop.H + /// svuint16_t svrev[_u16](svuint16_t op) + /// REV Zresult.H, Zop.H /// - public static unsafe Vector ReverseElement(Vector value) => ReverseElement(value); + public static Vector ReverseElement(Vector value) => ReverseElement(value); /// - /// svuint32_t svrev[_u32](svuint32_t op) - /// REV Zresult.S, Zop.S + /// svuint32_t svrev[_u32](svuint32_t op) + /// REV Zresult.S, Zop.S /// - public static unsafe Vector ReverseElement(Vector value) => ReverseElement(value); + public static Vector ReverseElement(Vector value) => ReverseElement(value); /// - /// svuint64_t svrev[_u64](svuint64_t op) - /// REV Zresult.D, Zop.D + /// svuint64_t svrev[_u64](svuint64_t op) + /// REV Zresult.D, Zop.D /// - public static unsafe Vector ReverseElement(Vector value) => ReverseElement(value); + public static Vector ReverseElement(Vector value) => ReverseElement(value); // Reverse halfwords within elements /// - /// svint32_t svrevh[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) - /// svint32_t svrevh[_s32]_x(svbool_t pg, svint32_t op) - /// svint32_t svrevh[_s32]_z(svbool_t pg, svint32_t op) - /// REVH Zresult.S, Pg/M, Zop.S + /// svint32_t svrevh[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) + /// svint32_t svrevh[_s32]_x(svbool_t pg, svint32_t op) + /// svint32_t svrevh[_s32]_z(svbool_t pg, svint32_t op) + /// REVH Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ReverseElement16(Vector value) => ReverseElement16(value); + public static Vector ReverseElement16(Vector value) => ReverseElement16(value); /// - /// svint64_t svrevh[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) - /// svint64_t svrevh[_s64]_x(svbool_t pg, svint64_t op) - /// svint64_t svrevh[_s64]_z(svbool_t pg, svint64_t op) - /// REVH Zresult.D, Pg/M, Zop.D + /// svint64_t svrevh[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) + /// svint64_t svrevh[_s64]_x(svbool_t pg, svint64_t op) + /// svint64_t svrevh[_s64]_z(svbool_t pg, svint64_t op) + /// REVH Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ReverseElement16(Vector value) => ReverseElement16(value); + public static Vector ReverseElement16(Vector value) => ReverseElement16(value); /// - /// svuint32_t svrevh[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) - /// svuint32_t svrevh[_u32]_x(svbool_t pg, svuint32_t op) - /// svuint32_t svrevh[_u32]_z(svbool_t pg, svuint32_t op) - /// REVH Zresult.S, Pg/M, Zop.S + /// svuint32_t svrevh[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) + /// svuint32_t svrevh[_u32]_x(svbool_t pg, svuint32_t op) + /// svuint32_t svrevh[_u32]_z(svbool_t pg, svuint32_t op) + /// REVH Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ReverseElement16(Vector value) => ReverseElement16(value); + public static Vector ReverseElement16(Vector value) => ReverseElement16(value); /// - /// svuint64_t svrevh[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) - /// svuint64_t svrevh[_u64]_x(svbool_t pg, svuint64_t op) - /// svuint64_t svrevh[_u64]_z(svbool_t pg, svuint64_t op) - /// REVH Zresult.D, Pg/M, Zop.D + /// svuint64_t svrevh[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) + /// svuint64_t svrevh[_u64]_x(svbool_t pg, svuint64_t op) + /// svuint64_t svrevh[_u64]_z(svbool_t pg, svuint64_t op) + /// REVH Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ReverseElement16(Vector value) => ReverseElement16(value); + public static Vector ReverseElement16(Vector value) => ReverseElement16(value); // Reverse words within elements /// - /// svint64_t svrevw[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) - /// svint64_t svrevw[_s64]_x(svbool_t pg, svint64_t op) - /// svint64_t svrevw[_s64]_z(svbool_t pg, svint64_t op) - /// REVW Zresult.D, Pg/M, Zop.D + /// svint64_t svrevw[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) + /// svint64_t svrevw[_s64]_x(svbool_t pg, svint64_t op) + /// svint64_t svrevw[_s64]_z(svbool_t pg, svint64_t op) + /// REVW Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ReverseElement32(Vector value) => ReverseElement32(value); + public static Vector ReverseElement32(Vector value) => ReverseElement32(value); /// - /// svuint64_t svrevw[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) - /// svuint64_t svrevw[_u64]_x(svbool_t pg, svuint64_t op) - /// svuint64_t svrevw[_u64]_z(svbool_t pg, svuint64_t op) - /// REVW Zresult.D, Pg/M, Zop.D + /// svuint64_t svrevw[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) + /// svuint64_t svrevw[_u64]_x(svbool_t pg, svuint64_t op) + /// svuint64_t svrevw[_u64]_z(svbool_t pg, svuint64_t op) + /// REVW Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ReverseElement32(Vector value) => ReverseElement32(value); + public static Vector ReverseElement32(Vector value) => ReverseElement32(value); // Reverse bytes within elements /// - /// svint16_t svrevb[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) - /// svint16_t svrevb[_s16]_x(svbool_t pg, svint16_t op) - /// svint16_t svrevb[_s16]_z(svbool_t pg, svint16_t op) - /// REVB Zresult.H, Pg/M, Zop.H + /// svint16_t svrevb[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) + /// svint16_t svrevb[_s16]_x(svbool_t pg, svint16_t op) + /// svint16_t svrevb[_s16]_z(svbool_t pg, svint16_t op) + /// REVB Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector ReverseElement8(Vector value) => ReverseElement8(value); + public static Vector ReverseElement8(Vector value) => ReverseElement8(value); /// - /// svint32_t svrevb[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) - /// svint32_t svrevb[_s32]_x(svbool_t pg, svint32_t op) - /// svint32_t svrevb[_s32]_z(svbool_t pg, svint32_t op) - /// REVB Zresult.S, Pg/M, Zop.S + /// svint32_t svrevb[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) + /// svint32_t svrevb[_s32]_x(svbool_t pg, svint32_t op) + /// svint32_t svrevb[_s32]_z(svbool_t pg, svint32_t op) + /// REVB Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ReverseElement8(Vector value) => ReverseElement8(value); + public static Vector ReverseElement8(Vector value) => ReverseElement8(value); /// - /// svint64_t svrevb[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) - /// svint64_t svrevb[_s64]_x(svbool_t pg, svint64_t op) - /// svint64_t svrevb[_s64]_z(svbool_t pg, svint64_t op) - /// REVB Zresult.D, Pg/M, Zop.D + /// svint64_t svrevb[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) + /// svint64_t svrevb[_s64]_x(svbool_t pg, svint64_t op) + /// svint64_t svrevb[_s64]_z(svbool_t pg, svint64_t op) + /// REVB Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ReverseElement8(Vector value) => ReverseElement8(value); + public static Vector ReverseElement8(Vector value) => ReverseElement8(value); /// - /// svuint16_t svrevb[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) - /// svuint16_t svrevb[_u16]_x(svbool_t pg, svuint16_t op) - /// svuint16_t svrevb[_u16]_z(svbool_t pg, svuint16_t op) - /// REVB Zresult.H, Pg/M, Zop.H + /// svuint16_t svrevb[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) + /// svuint16_t svrevb[_u16]_x(svbool_t pg, svuint16_t op) + /// svuint16_t svrevb[_u16]_z(svbool_t pg, svuint16_t op) + /// REVB Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector ReverseElement8(Vector value) => ReverseElement8(value); + public static Vector ReverseElement8(Vector value) => ReverseElement8(value); /// - /// svuint32_t svrevb[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) - /// svuint32_t svrevb[_u32]_x(svbool_t pg, svuint32_t op) - /// svuint32_t svrevb[_u32]_z(svbool_t pg, svuint32_t op) - /// REVB Zresult.S, Pg/M, Zop.S + /// svuint32_t svrevb[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) + /// svuint32_t svrevb[_u32]_x(svbool_t pg, svuint32_t op) + /// svuint32_t svrevb[_u32]_z(svbool_t pg, svuint32_t op) + /// REVB Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ReverseElement8(Vector value) => ReverseElement8(value); + public static Vector ReverseElement8(Vector value) => ReverseElement8(value); /// - /// svuint64_t svrevb[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) - /// svuint64_t svrevb[_u64]_x(svbool_t pg, svuint64_t op) - /// svuint64_t svrevb[_u64]_z(svbool_t pg, svuint64_t op) - /// REVB Zresult.D, Pg/M, Zop.D + /// svuint64_t svrevb[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) + /// svuint64_t svrevb[_u64]_x(svbool_t pg, svuint64_t op) + /// svuint64_t svrevb[_u64]_z(svbool_t pg, svuint64_t op) + /// REVB Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ReverseElement8(Vector value) => ReverseElement8(value); + public static Vector ReverseElement8(Vector value) => ReverseElement8(value); // Round to nearest, ties away from zero /// - /// svfloat64_t svrinta[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) - /// svfloat64_t svrinta[_f64]_x(svbool_t pg, svfloat64_t op) - /// svfloat64_t svrinta[_f64]_z(svbool_t pg, svfloat64_t op) - /// FRINTA Zresult.D, Pg/M, Zop.D + /// svfloat64_t svrinta[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) + /// svfloat64_t svrinta[_f64]_x(svbool_t pg, svfloat64_t op) + /// svfloat64_t svrinta[_f64]_z(svbool_t pg, svfloat64_t op) + /// FRINTA Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector RoundAwayFromZero(Vector value) => RoundAwayFromZero(value); + public static Vector RoundAwayFromZero(Vector value) => RoundAwayFromZero(value); /// - /// svfloat32_t svrinta[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) - /// svfloat32_t svrinta[_f32]_x(svbool_t pg, svfloat32_t op) - /// svfloat32_t svrinta[_f32]_z(svbool_t pg, svfloat32_t op) - /// FRINTA Zresult.S, Pg/M, Zop.S + /// svfloat32_t svrinta[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) + /// svfloat32_t svrinta[_f32]_x(svbool_t pg, svfloat32_t op) + /// svfloat32_t svrinta[_f32]_z(svbool_t pg, svfloat32_t op) + /// FRINTA Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector RoundAwayFromZero(Vector value) => RoundAwayFromZero(value); + public static Vector RoundAwayFromZero(Vector value) => RoundAwayFromZero(value); // Round to nearest, ties to even /// - /// svfloat64_t svrintn[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) - /// svfloat64_t svrintn[_f64]_x(svbool_t pg, svfloat64_t op) - /// svfloat64_t svrintn[_f64]_z(svbool_t pg, svfloat64_t op) - /// FRINTN Zresult.D, Pg/M, Zop.D + /// svfloat64_t svrintn[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) + /// svfloat64_t svrintn[_f64]_x(svbool_t pg, svfloat64_t op) + /// svfloat64_t svrintn[_f64]_z(svbool_t pg, svfloat64_t op) + /// FRINTN Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector RoundToNearest(Vector value) => RoundToNearest(value); + public static Vector RoundToNearest(Vector value) => RoundToNearest(value); /// - /// svfloat32_t svrintn[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) - /// svfloat32_t svrintn[_f32]_x(svbool_t pg, svfloat32_t op) - /// svfloat32_t svrintn[_f32]_z(svbool_t pg, svfloat32_t op) - /// FRINTN Zresult.S, Pg/M, Zop.S + /// svfloat32_t svrintn[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) + /// svfloat32_t svrintn[_f32]_x(svbool_t pg, svfloat32_t op) + /// svfloat32_t svrintn[_f32]_z(svbool_t pg, svfloat32_t op) + /// FRINTN Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector RoundToNearest(Vector value) => RoundToNearest(value); + public static Vector RoundToNearest(Vector value) => RoundToNearest(value); // Round towards -∞ /// - /// svfloat64_t svrintm[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) - /// svfloat64_t svrintm[_f64]_x(svbool_t pg, svfloat64_t op) - /// svfloat64_t svrintm[_f64]_z(svbool_t pg, svfloat64_t op) - /// FRINTM Zresult.D, Pg/M, Zop.D + /// svfloat64_t svrintm[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) + /// svfloat64_t svrintm[_f64]_x(svbool_t pg, svfloat64_t op) + /// svfloat64_t svrintm[_f64]_z(svbool_t pg, svfloat64_t op) + /// FRINTM Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector RoundToNegativeInfinity(Vector value) => RoundToNegativeInfinity(value); + public static Vector RoundToNegativeInfinity(Vector value) => RoundToNegativeInfinity(value); /// - /// svfloat32_t svrintm[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) - /// svfloat32_t svrintm[_f32]_x(svbool_t pg, svfloat32_t op) - /// svfloat32_t svrintm[_f32]_z(svbool_t pg, svfloat32_t op) - /// FRINTM Zresult.S, Pg/M, Zop.S + /// svfloat32_t svrintm[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) + /// svfloat32_t svrintm[_f32]_x(svbool_t pg, svfloat32_t op) + /// svfloat32_t svrintm[_f32]_z(svbool_t pg, svfloat32_t op) + /// FRINTM Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector RoundToNegativeInfinity(Vector value) => RoundToNegativeInfinity(value); + public static Vector RoundToNegativeInfinity(Vector value) => RoundToNegativeInfinity(value); // Round towards +∞ /// - /// svfloat64_t svrintp[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) - /// svfloat64_t svrintp[_f64]_x(svbool_t pg, svfloat64_t op) - /// svfloat64_t svrintp[_f64]_z(svbool_t pg, svfloat64_t op) - /// FRINTP Zresult.D, Pg/M, Zop.D + /// svfloat64_t svrintp[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) + /// svfloat64_t svrintp[_f64]_x(svbool_t pg, svfloat64_t op) + /// svfloat64_t svrintp[_f64]_z(svbool_t pg, svfloat64_t op) + /// FRINTP Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector RoundToPositiveInfinity(Vector value) => RoundToPositiveInfinity(value); + public static Vector RoundToPositiveInfinity(Vector value) => RoundToPositiveInfinity(value); /// - /// svfloat32_t svrintp[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) - /// svfloat32_t svrintp[_f32]_x(svbool_t pg, svfloat32_t op) - /// svfloat32_t svrintp[_f32]_z(svbool_t pg, svfloat32_t op) - /// FRINTP Zresult.S, Pg/M, Zop.S + /// svfloat32_t svrintp[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) + /// svfloat32_t svrintp[_f32]_x(svbool_t pg, svfloat32_t op) + /// svfloat32_t svrintp[_f32]_z(svbool_t pg, svfloat32_t op) + /// FRINTP Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector RoundToPositiveInfinity(Vector value) => RoundToPositiveInfinity(value); + public static Vector RoundToPositiveInfinity(Vector value) => RoundToPositiveInfinity(value); // Round towards zero /// - /// svfloat64_t svrintz[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) - /// svfloat64_t svrintz[_f64]_x(svbool_t pg, svfloat64_t op) - /// svfloat64_t svrintz[_f64]_z(svbool_t pg, svfloat64_t op) - /// FRINTZ Zresult.D, Pg/M, Zop.D + /// svfloat64_t svrintz[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) + /// svfloat64_t svrintz[_f64]_x(svbool_t pg, svfloat64_t op) + /// svfloat64_t svrintz[_f64]_z(svbool_t pg, svfloat64_t op) + /// FRINTZ Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector RoundToZero(Vector value) => RoundToZero(value); + public static Vector RoundToZero(Vector value) => RoundToZero(value); /// - /// svfloat32_t svrintz[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) - /// svfloat32_t svrintz[_f32]_x(svbool_t pg, svfloat32_t op) - /// svfloat32_t svrintz[_f32]_z(svbool_t pg, svfloat32_t op) - /// FRINTZ Zresult.S, Pg/M, Zop.S + /// svfloat32_t svrintz[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) + /// svfloat32_t svrintz[_f32]_x(svbool_t pg, svfloat32_t op) + /// svfloat32_t svrintz[_f32]_z(svbool_t pg, svfloat32_t op) + /// FRINTZ Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector RoundToZero(Vector value) => RoundToZero(value); + public static Vector RoundToZero(Vector value) => RoundToZero(value); // Saturating decrement by number of halfword elements /// - /// int32_t svqdech_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQDECH Xtied, Wtied, pattern, MUL #imm_factor + /// int32_t svqdech_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQDECH Xtied, Wtied, pattern, MUL #imm_factor /// - public static unsafe int SaturatingDecrementBy16BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy16BitElementCount(value, scale, pattern); + public static int SaturatingDecrementBy16BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy16BitElementCount(value, scale, pattern); /// - /// int64_t svqdech_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQDECH Xtied, pattern, MUL #imm_factor + /// int64_t svqdech_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQDECH Xtied, pattern, MUL #imm_factor /// - public static unsafe long SaturatingDecrementBy16BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy16BitElementCount(value, scale, pattern); + public static long SaturatingDecrementBy16BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy16BitElementCount(value, scale, pattern); /// - /// uint32_t svqdech_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQDECH Wtied, pattern, MUL #imm_factor + /// uint32_t svqdech_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQDECH Wtied, pattern, MUL #imm_factor /// - public static unsafe uint SaturatingDecrementBy16BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy16BitElementCount(value, scale, pattern); + public static uint SaturatingDecrementBy16BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy16BitElementCount(value, scale, pattern); /// - /// uint64_t svqdech_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQDECH Xtied, pattern, MUL #imm_factor + /// uint64_t svqdech_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQDECH Xtied, pattern, MUL #imm_factor /// - public static unsafe ulong SaturatingDecrementBy16BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy16BitElementCount(value, scale, pattern); + public static ulong SaturatingDecrementBy16BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy16BitElementCount(value, scale, pattern); /// - /// svint16_t svqdech_pat[_s16](svint16_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQDECH Ztied.H, pattern, MUL #imm_factor + /// svint16_t svqdech_pat[_s16](svint16_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQDECH Ztied.H, pattern, MUL #imm_factor /// - public static unsafe Vector SaturatingDecrementBy16BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy16BitElementCount(value, scale, pattern); + public static Vector SaturatingDecrementBy16BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy16BitElementCount(value, scale, pattern); /// - /// svuint16_t svqdech_pat[_u16](svuint16_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQDECH Ztied.H, pattern, MUL #imm_factor + /// svuint16_t svqdech_pat[_u16](svuint16_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQDECH Ztied.H, pattern, MUL #imm_factor /// - public static unsafe Vector SaturatingDecrementBy16BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy16BitElementCount(value, scale, pattern); + public static Vector SaturatingDecrementBy16BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy16BitElementCount(value, scale, pattern); // Saturating decrement by number of word elements /// - /// int32_t svqdecw_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQDECW Xtied, Wtied, pattern, MUL #imm_factor + /// int32_t svqdecw_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQDECW Xtied, Wtied, pattern, MUL #imm_factor /// - public static unsafe int SaturatingDecrementBy32BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy32BitElementCount(value, scale, pattern); + public static int SaturatingDecrementBy32BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy32BitElementCount(value, scale, pattern); /// - /// int64_t svqdecw_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQDECW Xtied, pattern, MUL #imm_factor + /// int64_t svqdecw_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQDECW Xtied, pattern, MUL #imm_factor /// - public static unsafe long SaturatingDecrementBy32BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy32BitElementCount(value, scale, pattern); + public static long SaturatingDecrementBy32BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy32BitElementCount(value, scale, pattern); /// - /// uint32_t svqdecw_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQDECW Wtied, pattern, MUL #imm_factor + /// uint32_t svqdecw_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQDECW Wtied, pattern, MUL #imm_factor /// - public static unsafe uint SaturatingDecrementBy32BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy32BitElementCount(value, scale, pattern); + public static uint SaturatingDecrementBy32BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy32BitElementCount(value, scale, pattern); /// - /// uint64_t svqdecw_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQDECW Xtied, pattern, MUL #imm_factor + /// uint64_t svqdecw_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQDECW Xtied, pattern, MUL #imm_factor /// - public static unsafe ulong SaturatingDecrementBy32BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy32BitElementCount(value, scale, pattern); + public static ulong SaturatingDecrementBy32BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy32BitElementCount(value, scale, pattern); /// - /// svint32_t svqdecw_pat[_s32](svint32_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQDECW Ztied.S, pattern, MUL #imm_factor + /// svint32_t svqdecw_pat[_s32](svint32_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQDECW Ztied.S, pattern, MUL #imm_factor /// - public static unsafe Vector SaturatingDecrementBy32BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy32BitElementCount(value, scale, pattern); + public static Vector SaturatingDecrementBy32BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy32BitElementCount(value, scale, pattern); /// - /// svuint32_t svqdecw_pat[_u32](svuint32_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQDECW Ztied.S, pattern, MUL #imm_factor + /// svuint32_t svqdecw_pat[_u32](svuint32_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQDECW Ztied.S, pattern, MUL #imm_factor /// - public static unsafe Vector SaturatingDecrementBy32BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy32BitElementCount(value, scale, pattern); + public static Vector SaturatingDecrementBy32BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy32BitElementCount(value, scale, pattern); // Saturating decrement by number of doubleword elements /// - /// int32_t svqdecd_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQDECD Xtied, Wtied, pattern, MUL #imm_factor + /// int32_t svqdecd_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQDECD Xtied, Wtied, pattern, MUL #imm_factor /// - public static unsafe int SaturatingDecrementBy64BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy64BitElementCount(value, scale, pattern); + public static int SaturatingDecrementBy64BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy64BitElementCount(value, scale, pattern); /// - /// int64_t svqdecd_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQDECD Xtied, pattern, MUL #imm_factor + /// int64_t svqdecd_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQDECD Xtied, pattern, MUL #imm_factor /// - public static unsafe long SaturatingDecrementBy64BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy64BitElementCount(value, scale, pattern); + public static long SaturatingDecrementBy64BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy64BitElementCount(value, scale, pattern); /// - /// uint32_t svqdecd_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQDECD Wtied, pattern, MUL #imm_factor + /// uint32_t svqdecd_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQDECD Wtied, pattern, MUL #imm_factor /// - public static unsafe uint SaturatingDecrementBy64BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy64BitElementCount(value, scale, pattern); + public static uint SaturatingDecrementBy64BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy64BitElementCount(value, scale, pattern); /// - /// uint64_t svqdecd_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQDECD Xtied, pattern, MUL #imm_factor + /// uint64_t svqdecd_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQDECD Xtied, pattern, MUL #imm_factor /// - public static unsafe ulong SaturatingDecrementBy64BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy64BitElementCount(value, scale, pattern); + public static ulong SaturatingDecrementBy64BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy64BitElementCount(value, scale, pattern); /// - /// svint64_t svqdecd_pat[_s64](svint64_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQDECD Ztied.D, pattern, MUL #imm_factor + /// svint64_t svqdecd_pat[_s64](svint64_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQDECD Ztied.D, pattern, MUL #imm_factor /// - public static unsafe Vector SaturatingDecrementBy64BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy64BitElementCount(value, scale, pattern); + public static Vector SaturatingDecrementBy64BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy64BitElementCount(value, scale, pattern); /// - /// svuint64_t svqdecd_pat[_u64](svuint64_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQDECD Ztied.D, pattern, MUL #imm_factor + /// svuint64_t svqdecd_pat[_u64](svuint64_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQDECD Ztied.D, pattern, MUL #imm_factor /// - public static unsafe Vector SaturatingDecrementBy64BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy64BitElementCount(value, scale, pattern); + public static Vector SaturatingDecrementBy64BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy64BitElementCount(value, scale, pattern); // Saturating decrement by number of byte elements /// - /// int32_t svqdecb_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQDECB Xtied, Wtied, pattern, MUL #imm_factor + /// int32_t svqdecb_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQDECB Xtied, Wtied, pattern, MUL #imm_factor /// - public static unsafe int SaturatingDecrementBy8BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy8BitElementCount(value, scale, pattern); + public static int SaturatingDecrementBy8BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy8BitElementCount(value, scale, pattern); /// - /// int64_t svqdecb_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQDECB Xtied, pattern, MUL #imm_factor + /// int64_t svqdecb_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQDECB Xtied, pattern, MUL #imm_factor /// - public static unsafe long SaturatingDecrementBy8BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy8BitElementCount(value, scale, pattern); + public static long SaturatingDecrementBy8BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy8BitElementCount(value, scale, pattern); /// - /// uint32_t svqdecb_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQDECB Wtied, pattern, MUL #imm_factor + /// uint32_t svqdecb_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQDECB Wtied, pattern, MUL #imm_factor /// - public static unsafe uint SaturatingDecrementBy8BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy8BitElementCount(value, scale, pattern); + public static uint SaturatingDecrementBy8BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy8BitElementCount(value, scale, pattern); /// - /// uint64_t svqdecb_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQDECB Xtied, pattern, MUL #imm_factor + /// uint64_t svqdecb_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQDECB Xtied, pattern, MUL #imm_factor /// - public static unsafe ulong SaturatingDecrementBy8BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy8BitElementCount(value, scale, pattern); + public static ulong SaturatingDecrementBy8BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingDecrementBy8BitElementCount(value, scale, pattern); // Saturating decrement by active element count /// - /// int32_t svqdecp[_n_s32]_b8(int32_t op, svbool_t pg) - /// SQDECP Xtied, Pg.B, Wtied + /// int32_t svqdecp[_n_s32]_b8(int32_t op, svbool_t pg) + /// SQDECP Xtied, Pg.B, Wtied /// - public static unsafe long SaturatingDecrementByActiveElementCount(int value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); + public static long SaturatingDecrementByActiveElementCount(int value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); /// - /// int64_t svqdecp[_n_s64]_b8(int64_t op, svbool_t pg) - /// SQDECP Xtied, Pg.B + /// int64_t svqdecp[_n_s64]_b8(int64_t op, svbool_t pg) + /// SQDECP Xtied, Pg.B /// - public static unsafe long SaturatingDecrementByActiveElementCount(long value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); + public static long SaturatingDecrementByActiveElementCount(long value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); /// - /// uint32_t svqdecp[_n_u32]_b8(uint32_t op, svbool_t pg) - /// UQDECP Wtied, Pg.B + /// uint32_t svqdecp[_n_u32]_b8(uint32_t op, svbool_t pg) + /// UQDECP Wtied, Pg.B /// - public static unsafe ulong SaturatingDecrementByActiveElementCount(uint value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); + public static ulong SaturatingDecrementByActiveElementCount(uint value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); /// - /// uint64_t svqdecp[_n_u64]_b8(uint64_t op, svbool_t pg) - /// UQDECP Xtied, Pg.B + /// uint64_t svqdecp[_n_u64]_b8(uint64_t op, svbool_t pg) + /// UQDECP Xtied, Pg.B /// - public static unsafe ulong SaturatingDecrementByActiveElementCount(ulong value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); + public static ulong SaturatingDecrementByActiveElementCount(ulong value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); /// - /// svint16_t svqdecp[_s16](svint16_t op, svbool_t pg) - /// SQDECP Ztied.H, Pg + /// svint16_t svqdecp[_s16](svint16_t op, svbool_t pg) + /// SQDECP Ztied.H, Pg /// - public static unsafe Vector SaturatingDecrementByActiveElementCount(Vector value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); + public static Vector SaturatingDecrementByActiveElementCount(Vector value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); /// - /// svint32_t svqdecp[_s32](svint32_t op, svbool_t pg) - /// SQDECP Ztied.S, Pg + /// svint32_t svqdecp[_s32](svint32_t op, svbool_t pg) + /// SQDECP Ztied.S, Pg /// - public static unsafe Vector SaturatingDecrementByActiveElementCount(Vector value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); + public static Vector SaturatingDecrementByActiveElementCount(Vector value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); /// - /// svint64_t svqdecp[_s64](svint64_t op, svbool_t pg) - /// SQDECP Ztied.D, Pg + /// svint64_t svqdecp[_s64](svint64_t op, svbool_t pg) + /// SQDECP Ztied.D, Pg /// - public static unsafe Vector SaturatingDecrementByActiveElementCount(Vector value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); + public static Vector SaturatingDecrementByActiveElementCount(Vector value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); /// - /// int32_t svqdecp[_n_s32]_b16(int32_t op, svbool_t pg) - /// SQDECP Xtied, Pg.H, Wtied + /// int32_t svqdecp[_n_s32]_b16(int32_t op, svbool_t pg) + /// SQDECP Xtied, Pg.H, Wtied /// - public static unsafe long SaturatingDecrementByActiveElementCount(int value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); + public static long SaturatingDecrementByActiveElementCount(int value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); /// - /// int64_t svqdecp[_n_s64]_b16(int64_t op, svbool_t pg) - /// SQDECP Xtied, Pg.H + /// int64_t svqdecp[_n_s64]_b16(int64_t op, svbool_t pg) + /// SQDECP Xtied, Pg.H /// - public static unsafe long SaturatingDecrementByActiveElementCount(long value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); + public static long SaturatingDecrementByActiveElementCount(long value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); /// - /// uint32_t svqdecp[_n_u32]_b16(uint32_t op, svbool_t pg) - /// UQDECP Wtied, Pg.H + /// uint32_t svqdecp[_n_u32]_b16(uint32_t op, svbool_t pg) + /// UQDECP Wtied, Pg.H /// - public static unsafe ulong SaturatingDecrementByActiveElementCount(uint value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); + public static ulong SaturatingDecrementByActiveElementCount(uint value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); /// - /// uint64_t svqdecp[_n_u64]_b16(uint64_t op, svbool_t pg) - /// UQDECP Xtied, Pg.H + /// uint64_t svqdecp[_n_u64]_b16(uint64_t op, svbool_t pg) + /// UQDECP Xtied, Pg.H /// - public static unsafe ulong SaturatingDecrementByActiveElementCount(ulong value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); + public static ulong SaturatingDecrementByActiveElementCount(ulong value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); /// - /// svuint16_t svqdecp[_u16](svuint16_t op, svbool_t pg) - /// UQDECP Ztied.H, Pg + /// svuint16_t svqdecp[_u16](svuint16_t op, svbool_t pg) + /// UQDECP Ztied.H, Pg /// - public static unsafe Vector SaturatingDecrementByActiveElementCount(Vector value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); + public static Vector SaturatingDecrementByActiveElementCount(Vector value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); /// - /// int32_t svqdecp[_n_s32]_b32(int32_t op, svbool_t pg) - /// SQDECP Xtied, Pg.S, Wtied + /// int32_t svqdecp[_n_s32]_b32(int32_t op, svbool_t pg) + /// SQDECP Xtied, Pg.S, Wtied /// - public static unsafe long SaturatingDecrementByActiveElementCount(int value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); + public static long SaturatingDecrementByActiveElementCount(int value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); /// - /// int64_t svqdecp[_n_s64]_b32(int64_t op, svbool_t pg) - /// SQDECP Xtied, Pg.S + /// int64_t svqdecp[_n_s64]_b32(int64_t op, svbool_t pg) + /// SQDECP Xtied, Pg.S /// - public static unsafe long SaturatingDecrementByActiveElementCount(long value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); + public static long SaturatingDecrementByActiveElementCount(long value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); /// - /// uint32_t svqdecp[_n_u32]_b32(uint32_t op, svbool_t pg) - /// UQDECP Wtied, Pg.S + /// uint32_t svqdecp[_n_u32]_b32(uint32_t op, svbool_t pg) + /// UQDECP Wtied, Pg.S /// - public static unsafe ulong SaturatingDecrementByActiveElementCount(uint value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); + public static ulong SaturatingDecrementByActiveElementCount(uint value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); /// - /// uint64_t svqdecp[_n_u64]_b32(uint64_t op, svbool_t pg) - /// UQDECP Xtied, Pg.S + /// uint64_t svqdecp[_n_u64]_b32(uint64_t op, svbool_t pg) + /// UQDECP Xtied, Pg.S /// - public static unsafe ulong SaturatingDecrementByActiveElementCount(ulong value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); + public static ulong SaturatingDecrementByActiveElementCount(ulong value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); /// - /// svuint32_t svqdecp[_u32](svuint32_t op, svbool_t pg) - /// UQDECP Ztied.S, Pg + /// svuint32_t svqdecp[_u32](svuint32_t op, svbool_t pg) + /// UQDECP Ztied.S, Pg /// - public static unsafe Vector SaturatingDecrementByActiveElementCount(Vector value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); + public static Vector SaturatingDecrementByActiveElementCount(Vector value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); /// - /// int32_t svqdecp[_n_s32]_b64(int32_t op, svbool_t pg) - /// SQDECP Xtied, Pg.D, Wtied + /// int32_t svqdecp[_n_s32]_b64(int32_t op, svbool_t pg) + /// SQDECP Xtied, Pg.D, Wtied /// - public static unsafe long SaturatingDecrementByActiveElementCount(int value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); + public static long SaturatingDecrementByActiveElementCount(int value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); /// - /// int64_t svqdecp[_n_s64]_b64(int64_t op, svbool_t pg) - /// SQDECP Xtied, Pg.D + /// int64_t svqdecp[_n_s64]_b64(int64_t op, svbool_t pg) + /// SQDECP Xtied, Pg.D /// - public static unsafe long SaturatingDecrementByActiveElementCount(long value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); + public static long SaturatingDecrementByActiveElementCount(long value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); /// - /// uint32_t svqdecp[_n_u32]_b64(uint32_t op, svbool_t pg) - /// UQDECP Wtied, Pg.D + /// uint32_t svqdecp[_n_u32]_b64(uint32_t op, svbool_t pg) + /// UQDECP Wtied, Pg.D /// - public static unsafe ulong SaturatingDecrementByActiveElementCount(uint value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); + public static ulong SaturatingDecrementByActiveElementCount(uint value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); /// - /// uint64_t svqdecp[_n_u64]_b64(uint64_t op, svbool_t pg) - /// UQDECP Xtied, Pg.D + /// uint64_t svqdecp[_n_u64]_b64(uint64_t op, svbool_t pg) + /// UQDECP Xtied, Pg.D /// - public static unsafe ulong SaturatingDecrementByActiveElementCount(ulong value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); + public static ulong SaturatingDecrementByActiveElementCount(ulong value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); /// - /// svuint64_t svqdecp[_u64](svuint64_t op, svbool_t pg) - /// UQDECP Ztied.D, Pg + /// svuint64_t svqdecp[_u64](svuint64_t op, svbool_t pg) + /// UQDECP Ztied.D, Pg /// - public static unsafe Vector SaturatingDecrementByActiveElementCount(Vector value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); + public static Vector SaturatingDecrementByActiveElementCount(Vector value, Vector from) => SaturatingDecrementByActiveElementCount(value, from); // Saturating increment by number of halfword elements /// - /// int32_t svqinch_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQINCH Xtied, Wtied, pattern, MUL #imm_factor + /// int32_t svqinch_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQINCH Xtied, Wtied, pattern, MUL #imm_factor /// - public static unsafe int SaturatingIncrementBy16BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy16BitElementCount(value, scale, pattern); + public static int SaturatingIncrementBy16BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy16BitElementCount(value, scale, pattern); /// - /// int64_t svqinch_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQINCH Xtied, pattern, MUL #imm_factor + /// int64_t svqinch_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQINCH Xtied, pattern, MUL #imm_factor /// - public static unsafe long SaturatingIncrementBy16BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy16BitElementCount(value, scale, pattern); + public static long SaturatingIncrementBy16BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy16BitElementCount(value, scale, pattern); /// - /// uint32_t svqinch_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQINCH Wtied, pattern, MUL #imm_factor + /// uint32_t svqinch_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQINCH Wtied, pattern, MUL #imm_factor /// - public static unsafe uint SaturatingIncrementBy16BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy16BitElementCount(value, scale, pattern); + public static uint SaturatingIncrementBy16BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy16BitElementCount(value, scale, pattern); /// - /// uint64_t svqinch_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQINCH Xtied, pattern, MUL #imm_factor + /// uint64_t svqinch_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQINCH Xtied, pattern, MUL #imm_factor /// - public static unsafe ulong SaturatingIncrementBy16BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy16BitElementCount(value, scale, pattern); + public static ulong SaturatingIncrementBy16BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy16BitElementCount(value, scale, pattern); /// - /// svint16_t svqinch_pat[_s16](svint16_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQINCH Ztied.H, pattern, MUL #imm_factor + /// svint16_t svqinch_pat[_s16](svint16_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQINCH Ztied.H, pattern, MUL #imm_factor /// - public static unsafe Vector SaturatingIncrementBy16BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy16BitElementCount(value, scale, pattern); + public static Vector SaturatingIncrementBy16BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy16BitElementCount(value, scale, pattern); /// - /// svuint16_t svqinch_pat[_u16](svuint16_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQINCH Ztied.H, pattern, MUL #imm_factor + /// svuint16_t svqinch_pat[_u16](svuint16_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQINCH Ztied.H, pattern, MUL #imm_factor /// - public static unsafe Vector SaturatingIncrementBy16BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy16BitElementCount(value, scale, pattern); + public static Vector SaturatingIncrementBy16BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy16BitElementCount(value, scale, pattern); // Saturating increment by number of word elements /// - /// int32_t svqincw_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQINCW Xtied, Wtied, pattern, MUL #imm_factor + /// int32_t svqincw_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQINCW Xtied, Wtied, pattern, MUL #imm_factor /// - public static unsafe int SaturatingIncrementBy32BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy32BitElementCount(value, scale, pattern); + public static int SaturatingIncrementBy32BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy32BitElementCount(value, scale, pattern); /// - /// int64_t svqincw_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQINCW Xtied, pattern, MUL #imm_factor + /// int64_t svqincw_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQINCW Xtied, pattern, MUL #imm_factor /// - public static unsafe long SaturatingIncrementBy32BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy32BitElementCount(value, scale, pattern); + public static long SaturatingIncrementBy32BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy32BitElementCount(value, scale, pattern); /// - /// uint32_t svqincw_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQINCW Wtied, pattern, MUL #imm_factor + /// uint32_t svqincw_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQINCW Wtied, pattern, MUL #imm_factor /// - public static unsafe uint SaturatingIncrementBy32BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy32BitElementCount(value, scale, pattern); + public static uint SaturatingIncrementBy32BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy32BitElementCount(value, scale, pattern); /// - /// uint64_t svqincw_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQINCW Xtied, pattern, MUL #imm_factor + /// uint64_t svqincw_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQINCW Xtied, pattern, MUL #imm_factor /// - public static unsafe ulong SaturatingIncrementBy32BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy32BitElementCount(value, scale, pattern); + public static ulong SaturatingIncrementBy32BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy32BitElementCount(value, scale, pattern); /// - /// svint32_t svqincw_pat[_s32](svint32_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQINCW Ztied.S, pattern, MUL #imm_factor + /// svint32_t svqincw_pat[_s32](svint32_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQINCW Ztied.S, pattern, MUL #imm_factor /// - public static unsafe Vector SaturatingIncrementBy32BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy32BitElementCount(value, scale, pattern); + public static Vector SaturatingIncrementBy32BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy32BitElementCount(value, scale, pattern); /// - /// svuint32_t svqincw_pat[_u32](svuint32_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQINCW Ztied.S, pattern, MUL #imm_factor + /// svuint32_t svqincw_pat[_u32](svuint32_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQINCW Ztied.S, pattern, MUL #imm_factor /// - public static unsafe Vector SaturatingIncrementBy32BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy32BitElementCount(value, scale, pattern); + public static Vector SaturatingIncrementBy32BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy32BitElementCount(value, scale, pattern); // Saturating increment by number of doubleword elements /// - /// int32_t svqincd_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQINCD Xtied, Wtied, pattern, MUL #imm_factor + /// int32_t svqincd_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQINCD Xtied, Wtied, pattern, MUL #imm_factor /// - public static unsafe int SaturatingIncrementBy64BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy64BitElementCount(value, scale, pattern); + public static int SaturatingIncrementBy64BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy64BitElementCount(value, scale, pattern); /// - /// int64_t svqincd_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQINCD Xtied, pattern, MUL #imm_factor + /// int64_t svqincd_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQINCD Xtied, pattern, MUL #imm_factor /// - public static unsafe long SaturatingIncrementBy64BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy64BitElementCount(value, scale, pattern); + public static long SaturatingIncrementBy64BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy64BitElementCount(value, scale, pattern); /// - /// uint32_t svqincd_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQINCD Wtied, pattern, MUL #imm_factor + /// uint32_t svqincd_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQINCD Wtied, pattern, MUL #imm_factor /// - public static unsafe uint SaturatingIncrementBy64BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy64BitElementCount(value, scale, pattern); + public static uint SaturatingIncrementBy64BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy64BitElementCount(value, scale, pattern); /// - /// uint64_t svqincd_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQINCD Xtied, pattern, MUL #imm_factor + /// uint64_t svqincd_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQINCD Xtied, pattern, MUL #imm_factor /// - public static unsafe ulong SaturatingIncrementBy64BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy64BitElementCount(value, scale, pattern); + public static ulong SaturatingIncrementBy64BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy64BitElementCount(value, scale, pattern); /// - /// svint64_t svqincd_pat[_s64](svint64_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQINCD Ztied.D, pattern, MUL #imm_factor + /// svint64_t svqincd_pat[_s64](svint64_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQINCD Ztied.D, pattern, MUL #imm_factor /// - public static unsafe Vector SaturatingIncrementBy64BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy64BitElementCount(value, scale, pattern); + public static Vector SaturatingIncrementBy64BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy64BitElementCount(value, scale, pattern); /// - /// svuint64_t svqincd_pat[_u64](svuint64_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQINCD Ztied.D, pattern, MUL #imm_factor + /// svuint64_t svqincd_pat[_u64](svuint64_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQINCD Ztied.D, pattern, MUL #imm_factor /// - public static unsafe Vector SaturatingIncrementBy64BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy64BitElementCount(value, scale, pattern); + public static Vector SaturatingIncrementBy64BitElementCount(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy64BitElementCount(value, scale, pattern); // Saturating increment by number of byte elements /// - /// int32_t svqincb_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQINCB Xtied, Wtied, pattern, MUL #imm_factor + /// int32_t svqincb_pat[_n_s32](int32_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQINCB Xtied, Wtied, pattern, MUL #imm_factor /// - public static unsafe int SaturatingIncrementBy8BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy8BitElementCount(value, scale, pattern); + public static int SaturatingIncrementBy8BitElementCount(int value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy8BitElementCount(value, scale, pattern); /// - /// int64_t svqincb_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) - /// SQINCB Xtied, pattern, MUL #imm_factor + /// int64_t svqincb_pat[_n_s64](int64_t op, enum svpattern pattern, uint64_t imm_factor) + /// SQINCB Xtied, pattern, MUL #imm_factor /// - public static unsafe long SaturatingIncrementBy8BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy8BitElementCount(value, scale, pattern); + public static long SaturatingIncrementBy8BitElementCount(long value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy8BitElementCount(value, scale, pattern); /// - /// uint32_t svqincb_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQINCB Wtied, pattern, MUL #imm_factor + /// uint32_t svqincb_pat[_n_u32](uint32_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQINCB Wtied, pattern, MUL #imm_factor /// - public static unsafe uint SaturatingIncrementBy8BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy8BitElementCount(value, scale, pattern); + public static uint SaturatingIncrementBy8BitElementCount(uint value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy8BitElementCount(value, scale, pattern); /// - /// uint64_t svqincb_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) - /// UQINCB Xtied, pattern, MUL #imm_factor + /// uint64_t svqincb_pat[_n_u64](uint64_t op, enum svpattern pattern, uint64_t imm_factor) + /// UQINCB Xtied, pattern, MUL #imm_factor /// - public static unsafe ulong SaturatingIncrementBy8BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy8BitElementCount(value, scale, pattern); + public static ulong SaturatingIncrementBy8BitElementCount(ulong value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte scale, [ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => SaturatingIncrementBy8BitElementCount(value, scale, pattern); // Saturating increment by active element count /// - /// int32_t svqincp[_n_s32]_b8(int32_t op, svbool_t pg) - /// SQINCP Xtied, Pg.B, Wtied + /// int32_t svqincp[_n_s32]_b8(int32_t op, svbool_t pg) + /// SQINCP Xtied, Pg.B, Wtied /// - public static unsafe long SaturatingIncrementByActiveElementCount(int value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); + public static long SaturatingIncrementByActiveElementCount(int value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); /// - /// int64_t svqincp[_n_s64]_b8(int64_t op, svbool_t pg) - /// SQINCP Xtied, Pg.B + /// int64_t svqincp[_n_s64]_b8(int64_t op, svbool_t pg) + /// SQINCP Xtied, Pg.B /// - public static unsafe long SaturatingIncrementByActiveElementCount(long value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); + public static long SaturatingIncrementByActiveElementCount(long value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); /// - /// uint32_t svqincp[_n_u32]_b8(uint32_t op, svbool_t pg) - /// UQINCP Wtied, Pg.B + /// uint32_t svqincp[_n_u32]_b8(uint32_t op, svbool_t pg) + /// UQINCP Wtied, Pg.B /// - public static unsafe ulong SaturatingIncrementByActiveElementCount(uint value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); + public static ulong SaturatingIncrementByActiveElementCount(uint value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); /// - /// uint64_t svqincp[_n_u64]_b8(uint64_t op, svbool_t pg) - /// UQINCP Xtied, Pg.B + /// uint64_t svqincp[_n_u64]_b8(uint64_t op, svbool_t pg) + /// UQINCP Xtied, Pg.B /// - public static unsafe ulong SaturatingIncrementByActiveElementCount(ulong value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); + public static ulong SaturatingIncrementByActiveElementCount(ulong value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); /// - /// svint16_t svqincp[_s16](svint16_t op, svbool_t pg) - /// SQINCP Ztied.H, Pg + /// svint16_t svqincp[_s16](svint16_t op, svbool_t pg) + /// SQINCP Ztied.H, Pg /// - public static unsafe Vector SaturatingIncrementByActiveElementCount(Vector value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); + public static Vector SaturatingIncrementByActiveElementCount(Vector value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); /// - /// svint32_t svqincp[_s32](svint32_t op, svbool_t pg) - /// SQINCP Ztied.S, Pg + /// svint32_t svqincp[_s32](svint32_t op, svbool_t pg) + /// SQINCP Ztied.S, Pg /// - public static unsafe Vector SaturatingIncrementByActiveElementCount(Vector value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); + public static Vector SaturatingIncrementByActiveElementCount(Vector value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); /// - /// svint64_t svqincp[_s64](svint64_t op, svbool_t pg) - /// SQINCP Ztied.D, Pg + /// svint64_t svqincp[_s64](svint64_t op, svbool_t pg) + /// SQINCP Ztied.D, Pg /// - public static unsafe Vector SaturatingIncrementByActiveElementCount(Vector value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); + public static Vector SaturatingIncrementByActiveElementCount(Vector value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); /// - /// int32_t svqincp[_n_s32]_b16(int32_t op, svbool_t pg) - /// SQINCP Xtied, Pg.H, Wtied + /// int32_t svqincp[_n_s32]_b16(int32_t op, svbool_t pg) + /// SQINCP Xtied, Pg.H, Wtied /// - public static unsafe long SaturatingIncrementByActiveElementCount(int value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); + public static long SaturatingIncrementByActiveElementCount(int value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); /// - /// int64_t svqincp[_n_s64]_b16(int64_t op, svbool_t pg) - /// SQINCP Xtied, Pg.H + /// int64_t svqincp[_n_s64]_b16(int64_t op, svbool_t pg) + /// SQINCP Xtied, Pg.H /// - public static unsafe long SaturatingIncrementByActiveElementCount(long value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); + public static long SaturatingIncrementByActiveElementCount(long value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); /// - /// uint32_t svqincp[_n_u32]_b16(uint32_t op, svbool_t pg) - /// UQINCP Wtied, Pg.H + /// uint32_t svqincp[_n_u32]_b16(uint32_t op, svbool_t pg) + /// UQINCP Wtied, Pg.H /// - public static unsafe ulong SaturatingIncrementByActiveElementCount(uint value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); + public static ulong SaturatingIncrementByActiveElementCount(uint value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); /// - /// uint64_t svqincp[_n_u64]_b16(uint64_t op, svbool_t pg) - /// UQINCP Xtied, Pg.H + /// uint64_t svqincp[_n_u64]_b16(uint64_t op, svbool_t pg) + /// UQINCP Xtied, Pg.H /// - public static unsafe ulong SaturatingIncrementByActiveElementCount(ulong value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); + public static ulong SaturatingIncrementByActiveElementCount(ulong value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); /// - /// svuint16_t svqincp[_u16](svuint16_t op, svbool_t pg) - /// UQINCP Ztied.H, Pg + /// svuint16_t svqincp[_u16](svuint16_t op, svbool_t pg) + /// UQINCP Ztied.H, Pg /// - public static unsafe Vector SaturatingIncrementByActiveElementCount(Vector value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); + public static Vector SaturatingIncrementByActiveElementCount(Vector value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); /// - /// int32_t svqincp[_n_s32]_b32(int32_t op, svbool_t pg) - /// SQINCP Xtied, Pg.S, Wtied + /// int32_t svqincp[_n_s32]_b32(int32_t op, svbool_t pg) + /// SQINCP Xtied, Pg.S, Wtied /// - public static unsafe long SaturatingIncrementByActiveElementCount(int value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); + public static long SaturatingIncrementByActiveElementCount(int value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); /// - /// int64_t svqincp[_n_s64]_b32(int64_t op, svbool_t pg) - /// SQINCP Xtied, Pg.S + /// int64_t svqincp[_n_s64]_b32(int64_t op, svbool_t pg) + /// SQINCP Xtied, Pg.S /// - public static unsafe long SaturatingIncrementByActiveElementCount(long value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); + public static long SaturatingIncrementByActiveElementCount(long value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); /// - /// uint32_t svqincp[_n_u32]_b32(uint32_t op, svbool_t pg) - /// UQINCP Wtied, Pg.S + /// uint32_t svqincp[_n_u32]_b32(uint32_t op, svbool_t pg) + /// UQINCP Wtied, Pg.S /// - public static unsafe ulong SaturatingIncrementByActiveElementCount(uint value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); + public static ulong SaturatingIncrementByActiveElementCount(uint value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); /// - /// uint64_t svqincp[_n_u64]_b32(uint64_t op, svbool_t pg) - /// UQINCP Xtied, Pg.S + /// uint64_t svqincp[_n_u64]_b32(uint64_t op, svbool_t pg) + /// UQINCP Xtied, Pg.S /// - public static unsafe ulong SaturatingIncrementByActiveElementCount(ulong value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); + public static ulong SaturatingIncrementByActiveElementCount(ulong value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); /// - /// svuint32_t svqincp[_u32](svuint32_t op, svbool_t pg) - /// UQINCP Ztied.S, Pg + /// svuint32_t svqincp[_u32](svuint32_t op, svbool_t pg) + /// UQINCP Ztied.S, Pg /// - public static unsafe Vector SaturatingIncrementByActiveElementCount(Vector value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); + public static Vector SaturatingIncrementByActiveElementCount(Vector value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); /// - /// int32_t svqincp[_n_s32]_b64(int32_t op, svbool_t pg) - /// SQINCP Xtied, Pg.D, Wtied + /// int32_t svqincp[_n_s32]_b64(int32_t op, svbool_t pg) + /// SQINCP Xtied, Pg.D, Wtied /// - public static unsafe long SaturatingIncrementByActiveElementCount(int value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); + public static long SaturatingIncrementByActiveElementCount(int value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); /// - /// int64_t svqincp[_n_s64]_b64(int64_t op, svbool_t pg) - /// SQINCP Xtied, Pg.D + /// int64_t svqincp[_n_s64]_b64(int64_t op, svbool_t pg) + /// SQINCP Xtied, Pg.D /// - public static unsafe long SaturatingIncrementByActiveElementCount(long value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); + public static long SaturatingIncrementByActiveElementCount(long value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); /// - /// uint32_t svqincp[_n_u32]_b64(uint32_t op, svbool_t pg) - /// UQINCP Wtied, Pg.D + /// uint32_t svqincp[_n_u32]_b64(uint32_t op, svbool_t pg) + /// UQINCP Wtied, Pg.D /// - public static unsafe ulong SaturatingIncrementByActiveElementCount(uint value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); + public static ulong SaturatingIncrementByActiveElementCount(uint value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); /// - /// uint64_t svqincp[_n_u64]_b64(uint64_t op, svbool_t pg) - /// UQINCP Xtied, Pg.D + /// uint64_t svqincp[_n_u64]_b64(uint64_t op, svbool_t pg) + /// UQINCP Xtied, Pg.D /// - public static unsafe ulong SaturatingIncrementByActiveElementCount(ulong value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); + public static ulong SaturatingIncrementByActiveElementCount(ulong value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); /// - /// svuint64_t svqincp[_u64](svuint64_t op, svbool_t pg) - /// UQINCP Ztied.D, Pg + /// svuint64_t svqincp[_u64](svuint64_t op, svbool_t pg) + /// UQINCP Ztied.D, Pg /// - public static unsafe Vector SaturatingIncrementByActiveElementCount(Vector value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); + public static Vector SaturatingIncrementByActiveElementCount(Vector value, Vector from) => SaturatingIncrementByActiveElementCount(value, from); // Adjust exponent /// - /// svfloat64_t svscale[_f64]_m(svbool_t pg, svfloat64_t op1, svint64_t op2) - /// svfloat64_t svscale[_f64]_x(svbool_t pg, svfloat64_t op1, svint64_t op2) - /// svfloat64_t svscale[_f64]_z(svbool_t pg, svfloat64_t op1, svint64_t op2) - /// FSCALE Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svfloat64_t svscale[_f64]_m(svbool_t pg, svfloat64_t op1, svint64_t op2) + /// svfloat64_t svscale[_f64]_x(svbool_t pg, svfloat64_t op1, svint64_t op2) + /// svfloat64_t svscale[_f64]_z(svbool_t pg, svfloat64_t op1, svint64_t op2) + /// FSCALE Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector Scale(Vector left, Vector right) => Scale(left, right); + public static Vector Scale(Vector left, Vector right) => Scale(left, right); /// - /// svfloat32_t svscale[_f32]_m(svbool_t pg, svfloat32_t op1, svint32_t op2) - /// svfloat32_t svscale[_f32]_x(svbool_t pg, svfloat32_t op1, svint32_t op2) - /// svfloat32_t svscale[_f32]_z(svbool_t pg, svfloat32_t op1, svint32_t op2) - /// FSCALE Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svfloat32_t svscale[_f32]_m(svbool_t pg, svfloat32_t op1, svint32_t op2) + /// svfloat32_t svscale[_f32]_x(svbool_t pg, svfloat32_t op1, svint32_t op2) + /// svfloat32_t svscale[_f32]_z(svbool_t pg, svfloat32_t op1, svint32_t op2) + /// FSCALE Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector Scale(Vector left, Vector right) => Scale(left, right); + public static Vector Scale(Vector left, Vector right) => Scale(left, right); // Non-truncating store /// - /// void svst1_scatter_[s64]offset[_f64](svbool_t pg, float64_t *base, svint64_t offsets, svfloat64_t data) - /// ST1D Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1_scatter_[s64]offset[_f64](svbool_t pg, float64_t *base, svint64_t offsets, svfloat64_t data) + /// ST1D Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter(Vector mask, double* address, Vector indicies, Vector data) => Scatter(mask, address, indicies, data); /// - /// void svst1_scatter[_u64base_f64](svbool_t pg, svuint64_t bases, svfloat64_t data) - /// ST1D Zdata.D, Pg, [Zbases.D, #0] + /// void svst1_scatter[_u64base_f64](svbool_t pg, svuint64_t bases, svfloat64_t data) + /// ST1D Zdata.D, Pg, [Zbases.D, #0] /// - public static unsafe void Scatter(Vector mask, Vector addresses, Vector data) => Scatter(mask, addresses, data); + public static void Scatter(Vector mask, Vector addresses, Vector data) => Scatter(mask, addresses, data); /// - /// void svst1_scatter_[u64]offset[_f64](svbool_t pg, float64_t *base, svuint64_t offsets, svfloat64_t data) - /// ST1D Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1_scatter_[u64]offset[_f64](svbool_t pg, float64_t *base, svuint64_t offsets, svfloat64_t data) + /// ST1D Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter(Vector mask, double* address, Vector indicies, Vector data) => Scatter(mask, address, indicies, data); /// - /// void svst1_scatter_[s32]offset[_s32](svbool_t pg, int32_t *base, svint32_t offsets, svint32_t data) - /// ST1W Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] + /// void svst1_scatter_[s32]offset[_s32](svbool_t pg, int32_t *base, svint32_t offsets, svint32_t data) + /// ST1W Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] /// public static unsafe void Scatter(Vector mask, int* address, Vector indicies, Vector data) => Scatter(mask, address, indicies, data); @@ -7806,35 +8466,35 @@ internal Arm64() { } // ST1W Zdata.S, Pg, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe void Scatter(Vector mask, Vector addresses, Vector data) => Scatter(mask, addresses, data); + // public static void Scatter(Vector mask, Vector addresses, Vector data) => Scatter(mask, addresses, data); /// - /// void svst1_scatter_[u32]offset[_s32](svbool_t pg, int32_t *base, svuint32_t offsets, svint32_t data) - /// ST1W Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] + /// void svst1_scatter_[u32]offset[_s32](svbool_t pg, int32_t *base, svuint32_t offsets, svint32_t data) + /// ST1W Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] /// public static unsafe void Scatter(Vector mask, int* address, Vector indicies, Vector data) => Scatter(mask, address, indicies, data); /// - /// void svst1_scatter_[s64]offset[_s64](svbool_t pg, int64_t *base, svint64_t offsets, svint64_t data) - /// ST1D Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1_scatter_[s64]offset[_s64](svbool_t pg, int64_t *base, svint64_t offsets, svint64_t data) + /// ST1D Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter(Vector mask, long* address, Vector indicies, Vector data) => Scatter(mask, address, indicies, data); /// - /// void svst1_scatter[_u64base_s64](svbool_t pg, svuint64_t bases, svint64_t data) - /// ST1D Zdata.D, Pg, [Zbases.D, #0] + /// void svst1_scatter[_u64base_s64](svbool_t pg, svuint64_t bases, svint64_t data) + /// ST1D Zdata.D, Pg, [Zbases.D, #0] /// - public static unsafe void Scatter(Vector mask, Vector addresses, Vector data) => Scatter(mask, addresses, data); + public static void Scatter(Vector mask, Vector addresses, Vector data) => Scatter(mask, addresses, data); /// - /// void svst1_scatter_[u64]offset[_s64](svbool_t pg, int64_t *base, svuint64_t offsets, svint64_t data) - /// ST1D Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1_scatter_[u64]offset[_s64](svbool_t pg, int64_t *base, svuint64_t offsets, svint64_t data) + /// ST1D Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter(Vector mask, long* address, Vector indicies, Vector data) => Scatter(mask, address, indicies, data); /// - /// void svst1_scatter_[s32]offset[_f32](svbool_t pg, float32_t *base, svint32_t offsets, svfloat32_t data) - /// ST1W Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] + /// void svst1_scatter_[s32]offset[_f32](svbool_t pg, float32_t *base, svint32_t offsets, svfloat32_t data) + /// ST1W Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] /// public static unsafe void Scatter(Vector mask, float* address, Vector indicies, Vector data) => Scatter(mask, address, indicies, data); @@ -7843,17 +8503,17 @@ internal Arm64() { } // ST1W Zdata.S, Pg, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe void Scatter(Vector mask, Vector addresses, Vector data) => Scatter(mask, addresses, data); + // public static void Scatter(Vector mask, Vector addresses, Vector data) => Scatter(mask, addresses, data); /// - /// void svst1_scatter_[u32]offset[_f32](svbool_t pg, float32_t *base, svuint32_t offsets, svfloat32_t data) - /// ST1W Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] + /// void svst1_scatter_[u32]offset[_f32](svbool_t pg, float32_t *base, svuint32_t offsets, svfloat32_t data) + /// ST1W Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] /// public static unsafe void Scatter(Vector mask, float* address, Vector indicies, Vector data) => Scatter(mask, address, indicies, data); /// - /// void svst1_scatter_[s32]offset[_u32](svbool_t pg, uint32_t *base, svint32_t offsets, svuint32_t data) - /// ST1W Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] + /// void svst1_scatter_[s32]offset[_u32](svbool_t pg, uint32_t *base, svint32_t offsets, svuint32_t data) + /// ST1W Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] /// public static unsafe void Scatter(Vector mask, uint* address, Vector indicies, Vector data) => Scatter(mask, address, indicies, data); @@ -7862,29 +8522,29 @@ internal Arm64() { } // ST1W Zdata.S, Pg, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe void Scatter(Vector mask, Vector addresses, Vector data) => Scatter(mask, addresses, data); + // public static void Scatter(Vector mask, Vector addresses, Vector data) => Scatter(mask, addresses, data); /// - /// void svst1_scatter_[u32]offset[_u32](svbool_t pg, uint32_t *base, svuint32_t offsets, svuint32_t data) - /// ST1W Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] + /// void svst1_scatter_[u32]offset[_u32](svbool_t pg, uint32_t *base, svuint32_t offsets, svuint32_t data) + /// ST1W Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] /// public static unsafe void Scatter(Vector mask, uint* address, Vector indicies, Vector data) => Scatter(mask, address, indicies, data); /// - /// void svst1_scatter_[s64]offset[_u64](svbool_t pg, uint64_t *base, svint64_t offsets, svuint64_t data) - /// ST1D Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1_scatter_[s64]offset[_u64](svbool_t pg, uint64_t *base, svint64_t offsets, svuint64_t data) + /// ST1D Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter(Vector mask, ulong* address, Vector indicies, Vector data) => Scatter(mask, address, indicies, data); /// - /// void svst1_scatter[_u64base_u64](svbool_t pg, svuint64_t bases, svuint64_t data) - /// ST1D Zdata.D, Pg, [Zbases.D, #0] + /// void svst1_scatter[_u64base_u64](svbool_t pg, svuint64_t bases, svuint64_t data) + /// ST1D Zdata.D, Pg, [Zbases.D, #0] /// - public static unsafe void Scatter(Vector mask, Vector addresses, Vector data) => Scatter(mask, addresses, data); + public static void Scatter(Vector mask, Vector addresses, Vector data) => Scatter(mask, addresses, data); /// - /// void svst1_scatter_[u64]offset[_u64](svbool_t pg, uint64_t *base, svuint64_t offsets, svuint64_t data) - /// ST1D Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1_scatter_[u64]offset[_u64](svbool_t pg, uint64_t *base, svuint64_t offsets, svuint64_t data) + /// ST1D Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter(Vector mask, ulong* address, Vector indicies, Vector data) => Scatter(mask, address, indicies, data); @@ -7896,75 +8556,75 @@ internal Arm64() { } // ST1H Zdata.S, Pg, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe void Scatter16BitNarrowing(Vector mask, Vector addresses, Vector data) => Scatter16BitNarrowing(mask, addresses, data); + // public static void Scatter16BitNarrowing(Vector mask, Vector addresses, Vector data) => Scatter16BitNarrowing(mask, addresses, data); /// - /// void svst1h_scatter[_u64base_s64](svbool_t pg, svuint64_t bases, svint64_t data) - /// ST1H Zdata.D, Pg, [Zbases.D, #0] + /// void svst1h_scatter[_u64base_s64](svbool_t pg, svuint64_t bases, svint64_t data) + /// ST1H Zdata.D, Pg, [Zbases.D, #0] /// - public static unsafe void Scatter16BitNarrowing(Vector mask, Vector addresses, Vector data) => Scatter16BitNarrowing(mask, addresses, data); + public static void Scatter16BitNarrowing(Vector mask, Vector addresses, Vector data) => Scatter16BitNarrowing(mask, addresses, data); // // void svst1h_scatter[_u32base_u32](svbool_t pg, svuint32_t bases, svuint32_t data) // ST1H Zdata.S, Pg, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe void Scatter16BitNarrowing(Vector mask, Vector addresses, Vector data) => Scatter16BitNarrowing(mask, addresses, data); + // public static void Scatter16BitNarrowing(Vector mask, Vector addresses, Vector data) => Scatter16BitNarrowing(mask, addresses, data); /// - /// void svst1h_scatter[_u64base_u64](svbool_t pg, svuint64_t bases, svuint64_t data) - /// ST1H Zdata.D, Pg, [Zbases.D, #0] + /// void svst1h_scatter[_u64base_u64](svbool_t pg, svuint64_t bases, svuint64_t data) + /// ST1H Zdata.D, Pg, [Zbases.D, #0] /// - public static unsafe void Scatter16BitNarrowing(Vector mask, Vector addresses, Vector data) => Scatter16BitNarrowing(mask, addresses, data); + public static void Scatter16BitNarrowing(Vector mask, Vector addresses, Vector data) => Scatter16BitNarrowing(mask, addresses, data); // Truncate to 16 bits and store /// - /// void svst1h_scatter_[s32]offset[_s32](svbool_t pg, int16_t *base, svint32_t offsets, svint32_t data) - /// ST1H Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] + /// void svst1h_scatter_[s32]offset[_s32](svbool_t pg, int16_t *base, svint32_t offsets, svint32_t data) + /// ST1H Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] /// public static unsafe void Scatter16BitWithByteOffsetsNarrowing(Vector mask, short* address, Vector offsets, Vector data) => Scatter16BitWithByteOffsetsNarrowing(mask, address, offsets, data); /// - /// void svst1h_scatter_[u32]offset[_s32](svbool_t pg, int16_t *base, svuint32_t offsets, svint32_t data) - /// ST1H Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] + /// void svst1h_scatter_[u32]offset[_s32](svbool_t pg, int16_t *base, svuint32_t offsets, svint32_t data) + /// ST1H Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] /// public static unsafe void Scatter16BitWithByteOffsetsNarrowing(Vector mask, short* address, Vector offsets, Vector data) => Scatter16BitWithByteOffsetsNarrowing(mask, address, offsets, data); /// - /// void svst1h_scatter_[s64]offset[_s64](svbool_t pg, int16_t *base, svint64_t offsets, svint64_t data) - /// ST1H Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1h_scatter_[s64]offset[_s64](svbool_t pg, int16_t *base, svint64_t offsets, svint64_t data) + /// ST1H Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter16BitWithByteOffsetsNarrowing(Vector mask, short* address, Vector offsets, Vector data) => Scatter16BitWithByteOffsetsNarrowing(mask, address, offsets, data); /// - /// void svst1h_scatter_[u64]offset[_s64](svbool_t pg, int16_t *base, svuint64_t offsets, svint64_t data) - /// ST1H Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1h_scatter_[u64]offset[_s64](svbool_t pg, int16_t *base, svuint64_t offsets, svint64_t data) + /// ST1H Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter16BitWithByteOffsetsNarrowing(Vector mask, short* address, Vector offsets, Vector data) => Scatter16BitWithByteOffsetsNarrowing(mask, address, offsets, data); /// - /// void svst1h_scatter_[s32]offset[_u32](svbool_t pg, uint16_t *base, svint32_t offsets, svuint32_t data) - /// ST1H Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] + /// void svst1h_scatter_[s32]offset[_u32](svbool_t pg, uint16_t *base, svint32_t offsets, svuint32_t data) + /// ST1H Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] /// public static unsafe void Scatter16BitWithByteOffsetsNarrowing(Vector mask, ushort* address, Vector offsets, Vector data) => Scatter16BitWithByteOffsetsNarrowing(mask, address, offsets, data); /// - /// void svst1h_scatter_[u32]offset[_u32](svbool_t pg, uint16_t *base, svuint32_t offsets, svuint32_t data) - /// ST1H Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] + /// void svst1h_scatter_[u32]offset[_u32](svbool_t pg, uint16_t *base, svuint32_t offsets, svuint32_t data) + /// ST1H Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] /// public static unsafe void Scatter16BitWithByteOffsetsNarrowing(Vector mask, ushort* address, Vector offsets, Vector data) => Scatter16BitWithByteOffsetsNarrowing(mask, address, offsets, data); /// - /// void svst1h_scatter_[s64]offset[_u64](svbool_t pg, uint16_t *base, svint64_t offsets, svuint64_t data) - /// ST1H Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1h_scatter_[s64]offset[_u64](svbool_t pg, uint16_t *base, svint64_t offsets, svuint64_t data) + /// ST1H Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter16BitWithByteOffsetsNarrowing(Vector mask, ushort* address, Vector offsets, Vector data) => Scatter16BitWithByteOffsetsNarrowing(mask, address, offsets, data); /// - /// void svst1h_scatter_[u64]offset[_u64](svbool_t pg, uint16_t *base, svuint64_t offsets, svuint64_t data) - /// ST1H Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1h_scatter_[u64]offset[_u64](svbool_t pg, uint16_t *base, svuint64_t offsets, svuint64_t data) + /// ST1H Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter16BitWithByteOffsetsNarrowing(Vector mask, ushort* address, Vector offsets, Vector data) => Scatter16BitWithByteOffsetsNarrowing(mask, address, offsets, data); @@ -7972,41 +8632,41 @@ internal Arm64() { } // Truncate to 32 bits and store /// - /// void svst1w_scatter[_u64base_s64](svbool_t pg, svuint64_t bases, svint64_t data) - /// ST1W Zdata.D, Pg, [Zbases.D, #0] + /// void svst1w_scatter[_u64base_s64](svbool_t pg, svuint64_t bases, svint64_t data) + /// ST1W Zdata.D, Pg, [Zbases.D, #0] /// - public static unsafe void Scatter32BitNarrowing(Vector mask, Vector addresses, Vector data) => Scatter32BitNarrowing(mask, addresses, data); + public static void Scatter32BitNarrowing(Vector mask, Vector addresses, Vector data) => Scatter32BitNarrowing(mask, addresses, data); /// - /// void svst1w_scatter[_u64base_u64](svbool_t pg, svuint64_t bases, svuint64_t data) - /// ST1W Zdata.D, Pg, [Zbases.D, #0] + /// void svst1w_scatter[_u64base_u64](svbool_t pg, svuint64_t bases, svuint64_t data) + /// ST1W Zdata.D, Pg, [Zbases.D, #0] /// - public static unsafe void Scatter32BitNarrowing(Vector mask, Vector addresses, Vector data) => Scatter32BitNarrowing(mask, addresses, data); + public static void Scatter32BitNarrowing(Vector mask, Vector addresses, Vector data) => Scatter32BitNarrowing(mask, addresses, data); // Truncate to 32 bits and store /// - /// void svst1w_scatter_[s64]offset[_s64](svbool_t pg, int32_t *base, svint64_t offsets, svint64_t data) - /// ST1W Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1w_scatter_[s64]offset[_s64](svbool_t pg, int32_t *base, svint64_t offsets, svint64_t data) + /// ST1W Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter32BitWithByteOffsetsNarrowing(Vector mask, int* address, Vector offsets, Vector data) => Scatter32BitWithByteOffsetsNarrowing(mask, address, offsets, data); /// - /// void svst1w_scatter_[u64]offset[_s64](svbool_t pg, int32_t *base, svuint64_t offsets, svint64_t data) - /// ST1W Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1w_scatter_[u64]offset[_s64](svbool_t pg, int32_t *base, svuint64_t offsets, svint64_t data) + /// ST1W Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter32BitWithByteOffsetsNarrowing(Vector mask, int* address, Vector offsets, Vector data) => Scatter32BitWithByteOffsetsNarrowing(mask, address, offsets, data); /// - /// void svst1w_scatter_[s64]offset[_u64](svbool_t pg, uint32_t *base, svint64_t offsets, svuint64_t data) - /// ST1W Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1w_scatter_[s64]offset[_u64](svbool_t pg, uint32_t *base, svint64_t offsets, svuint64_t data) + /// ST1W Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter32BitWithByteOffsetsNarrowing(Vector mask, uint* address, Vector offsets, Vector data) => Scatter32BitWithByteOffsetsNarrowing(mask, address, offsets, data); /// - /// void svst1w_scatter_[u64]offset[_u64](svbool_t pg, uint32_t *base, svuint64_t offsets, svuint64_t data) - /// ST1W Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1w_scatter_[u64]offset[_u64](svbool_t pg, uint32_t *base, svuint64_t offsets, svuint64_t data) + /// ST1W Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter32BitWithByteOffsetsNarrowing(Vector mask, uint* address, Vector offsets, Vector data) => Scatter32BitWithByteOffsetsNarrowing(mask, address, offsets, data); @@ -8018,75 +8678,75 @@ internal Arm64() { } // ST1B Zdata.S, Pg, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe void Scatter8BitNarrowing(Vector mask, Vector addresses, Vector data) => Scatter8BitNarrowing(mask, addresses, data); + // public static void Scatter8BitNarrowing(Vector mask, Vector addresses, Vector data) => Scatter8BitNarrowing(mask, addresses, data); /// - /// void svst1b_scatter[_u64base_s64](svbool_t pg, svuint64_t bases, svint64_t data) - /// ST1B Zdata.D, Pg, [Zbases.D, #0] + /// void svst1b_scatter[_u64base_s64](svbool_t pg, svuint64_t bases, svint64_t data) + /// ST1B Zdata.D, Pg, [Zbases.D, #0] /// - public static unsafe void Scatter8BitNarrowing(Vector mask, Vector addresses, Vector data) => Scatter8BitNarrowing(mask, addresses, data); + public static void Scatter8BitNarrowing(Vector mask, Vector addresses, Vector data) => Scatter8BitNarrowing(mask, addresses, data); // // void svst1b_scatter[_u32base_u32](svbool_t pg, svuint32_t bases, svuint32_t data) // ST1B Zdata.S, Pg, [Zbases.S, #0] // // Removed as per #103297 - // public static unsafe void Scatter8BitNarrowing(Vector mask, Vector addresses, Vector data) => Scatter8BitNarrowing(mask, addresses, data); + // public static void Scatter8BitNarrowing(Vector mask, Vector addresses, Vector data) => Scatter8BitNarrowing(mask, addresses, data); /// - /// void svst1b_scatter[_u64base_u64](svbool_t pg, svuint64_t bases, svuint64_t data) - /// ST1B Zdata.D, Pg, [Zbases.D, #0] + /// void svst1b_scatter[_u64base_u64](svbool_t pg, svuint64_t bases, svuint64_t data) + /// ST1B Zdata.D, Pg, [Zbases.D, #0] /// - public static unsafe void Scatter8BitNarrowing(Vector mask, Vector addresses, Vector data) => Scatter8BitNarrowing(mask, addresses, data); + public static void Scatter8BitNarrowing(Vector mask, Vector addresses, Vector data) => Scatter8BitNarrowing(mask, addresses, data); // Truncate to 8 bits and store /// - /// void svst1b_scatter_[s32]offset[_s32](svbool_t pg, int8_t *base, svint32_t offsets, svint32_t data) - /// ST1B Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] + /// void svst1b_scatter_[s32]offset[_s32](svbool_t pg, int8_t *base, svint32_t offsets, svint32_t data) + /// ST1B Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] /// public static unsafe void Scatter8BitWithByteOffsetsNarrowing(Vector mask, sbyte* address, Vector offsets, Vector data) => Scatter8BitWithByteOffsetsNarrowing(mask, address, offsets, data); /// - /// void svst1b_scatter_[u32]offset[_s32](svbool_t pg, int8_t *base, svuint32_t offsets, svint32_t data) - /// ST1B Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] + /// void svst1b_scatter_[u32]offset[_s32](svbool_t pg, int8_t *base, svuint32_t offsets, svint32_t data) + /// ST1B Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] /// public static unsafe void Scatter8BitWithByteOffsetsNarrowing(Vector mask, sbyte* address, Vector offsets, Vector data) => Scatter8BitWithByteOffsetsNarrowing(mask, address, offsets, data); /// - /// void svst1b_scatter_[s64]offset[_s64](svbool_t pg, int8_t *base, svint64_t offsets, svint64_t data) - /// ST1B Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1b_scatter_[s64]offset[_s64](svbool_t pg, int8_t *base, svint64_t offsets, svint64_t data) + /// ST1B Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter8BitWithByteOffsetsNarrowing(Vector mask, sbyte* address, Vector offsets, Vector data) => Scatter8BitWithByteOffsetsNarrowing(mask, address, offsets, data); /// - /// void svst1b_scatter_[u64]offset[_s64](svbool_t pg, int8_t *base, svuint64_t offsets, svint64_t data) - /// ST1B Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1b_scatter_[u64]offset[_s64](svbool_t pg, int8_t *base, svuint64_t offsets, svint64_t data) + /// ST1B Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter8BitWithByteOffsetsNarrowing(Vector mask, sbyte* address, Vector offsets, Vector data) => Scatter8BitWithByteOffsetsNarrowing(mask, address, offsets, data); /// - /// void svst1b_scatter_[s32]offset[_u32](svbool_t pg, uint8_t *base, svint32_t offsets, svuint32_t data) - /// ST1B Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] + /// void svst1b_scatter_[s32]offset[_u32](svbool_t pg, uint8_t *base, svint32_t offsets, svuint32_t data) + /// ST1B Zdata.S, Pg, [Xbase, Zoffsets.S, SXTW] /// public static unsafe void Scatter8BitWithByteOffsetsNarrowing(Vector mask, byte* address, Vector offsets, Vector data) => Scatter8BitWithByteOffsetsNarrowing(mask, address, offsets, data); /// - /// void svst1b_scatter_[u32]offset[_u32](svbool_t pg, uint8_t *base, svuint32_t offsets, svuint32_t data) - /// ST1B Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] + /// void svst1b_scatter_[u32]offset[_u32](svbool_t pg, uint8_t *base, svuint32_t offsets, svuint32_t data) + /// ST1B Zdata.S, Pg, [Xbase, Zoffsets.S, UXTW] /// public static unsafe void Scatter8BitWithByteOffsetsNarrowing(Vector mask, byte* address, Vector offsets, Vector data) => Scatter8BitWithByteOffsetsNarrowing(mask, address, offsets, data); /// - /// void svst1b_scatter_[s64]offset[_u64](svbool_t pg, uint8_t *base, svint64_t offsets, svuint64_t data) - /// ST1B Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1b_scatter_[s64]offset[_u64](svbool_t pg, uint8_t *base, svint64_t offsets, svuint64_t data) + /// ST1B Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter8BitWithByteOffsetsNarrowing(Vector mask, byte* address, Vector offsets, Vector data) => Scatter8BitWithByteOffsetsNarrowing(mask, address, offsets, data); /// - /// void svst1b_scatter_[u64]offset[_u64](svbool_t pg, uint8_t *base, svuint64_t offsets, svuint64_t data) - /// ST1B Zdata.D, Pg, [Xbase, Zoffsets.D] + /// void svst1b_scatter_[u64]offset[_u64](svbool_t pg, uint8_t *base, svuint64_t offsets, svuint64_t data) + /// ST1B Zdata.D, Pg, [Xbase, Zoffsets.D] /// public static unsafe void Scatter8BitWithByteOffsetsNarrowing(Vector mask, byte* address, Vector offsets, Vector data) => Scatter8BitWithByteOffsetsNarrowing(mask, address, offsets, data); @@ -8094,742 +8754,742 @@ internal Arm64() { } // Write to the first-fault register /// - /// void svwrffr(svbool_t op) - /// WRFFR Pop.B + /// void svwrffr(svbool_t op) + /// WRFFR Pop.B /// - public static unsafe void SetFfr(Vector value) => SetFfr(value); + public static void SetFfr(Vector value) => SetFfr(value); /// - /// void svwrffr(svbool_t op) - /// WRFFR Pop.B + /// void svwrffr(svbool_t op) + /// WRFFR Pop.B /// - public static unsafe void SetFfr(Vector value) => SetFfr(value); + public static void SetFfr(Vector value) => SetFfr(value); /// - /// void svwrffr(svbool_t op) - /// WRFFR Pop.B + /// void svwrffr(svbool_t op) + /// WRFFR Pop.B /// - public static unsafe void SetFfr(Vector value) => SetFfr(value); + public static void SetFfr(Vector value) => SetFfr(value); /// - /// void svwrffr(svbool_t op) - /// WRFFR Pop.B + /// void svwrffr(svbool_t op) + /// WRFFR Pop.B /// - public static unsafe void SetFfr(Vector value) => SetFfr(value); + public static void SetFfr(Vector value) => SetFfr(value); /// - /// void svwrffr(svbool_t op) - /// WRFFR Pop.B + /// void svwrffr(svbool_t op) + /// WRFFR Pop.B /// - public static unsafe void SetFfr(Vector value) => SetFfr(value); + public static void SetFfr(Vector value) => SetFfr(value); /// - /// void svwrffr(svbool_t op) - /// WRFFR Pop.B + /// void svwrffr(svbool_t op) + /// WRFFR Pop.B /// - public static unsafe void SetFfr(Vector value) => SetFfr(value); + public static void SetFfr(Vector value) => SetFfr(value); /// - /// void svwrffr(svbool_t op) - /// WRFFR Pop.B + /// void svwrffr(svbool_t op) + /// WRFFR Pop.B /// - public static unsafe void SetFfr(Vector value) => SetFfr(value); + public static void SetFfr(Vector value) => SetFfr(value); /// - /// void svwrffr(svbool_t op) - /// WRFFR Pop.B + /// void svwrffr(svbool_t op) + /// WRFFR Pop.B /// - public static unsafe void SetFfr(Vector value) => SetFfr(value); + public static void SetFfr(Vector value) => SetFfr(value); // Logical shift left /// - /// svuint8_t svlsl[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svlsl[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svlsl[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// LSL Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// svuint8_t svlsl[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svlsl[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svlsl[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// LSL Ztied1.B, Pg/M, Ztied1.B, Zop2.B /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); + public static Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); /// - /// svuint8_t svlsl_wide[_u8]_m(svbool_t pg, svuint8_t op1, svuint64_t op2) - /// svuint8_t svlsl_wide[_u8]_x(svbool_t pg, svuint8_t op1, svuint64_t op2) - /// LSL Ztied1.B, Pg/M, Ztied1.B, Zop2.D - /// LSL Zresult.B, Zop1.B, Zop2.D + /// svuint8_t svlsl_wide[_u8]_m(svbool_t pg, svuint8_t op1, svuint64_t op2) + /// svuint8_t svlsl_wide[_u8]_x(svbool_t pg, svuint8_t op1, svuint64_t op2) + /// LSL Ztied1.B, Pg/M, Ztied1.B, Zop2.D + /// LSL Zresult.B, Zop1.B, Zop2.D /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); + public static Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); /// - /// svint16_t svlsl[_s16]_m(svbool_t pg, svint16_t op1, svuint16_t op2) - /// svint16_t svlsl[_s16]_x(svbool_t pg, svint16_t op1, svuint16_t op2) - /// svint16_t svlsl[_s16]_z(svbool_t pg, svint16_t op1, svuint16_t op2) - /// LSL Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// svint16_t svlsl[_s16]_m(svbool_t pg, svint16_t op1, svuint16_t op2) + /// svint16_t svlsl[_s16]_x(svbool_t pg, svint16_t op1, svuint16_t op2) + /// svint16_t svlsl[_s16]_z(svbool_t pg, svint16_t op1, svuint16_t op2) + /// LSL Ztied1.H, Pg/M, Ztied1.H, Zop2.H /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); + public static Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); /// - /// svint16_t svlsl_wide[_s16]_m(svbool_t pg, svint16_t op1, svuint64_t op2) - /// svint16_t svlsl_wide[_s16]_x(svbool_t pg, svint16_t op1, svuint64_t op2) - /// svint16_t svlsl_wide[_s16]_z(svbool_t pg, svint16_t op1, svuint64_t op2) - /// LSL Ztied1.H, Pg/M, Ztied1.H, Zop2.D + /// svint16_t svlsl_wide[_s16]_m(svbool_t pg, svint16_t op1, svuint64_t op2) + /// svint16_t svlsl_wide[_s16]_x(svbool_t pg, svint16_t op1, svuint64_t op2) + /// svint16_t svlsl_wide[_s16]_z(svbool_t pg, svint16_t op1, svuint64_t op2) + /// LSL Ztied1.H, Pg/M, Ztied1.H, Zop2.D /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); + public static Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); /// - /// svint32_t svlsl[_s32]_m(svbool_t pg, svint32_t op1, svuint32_t op2) - /// svint32_t svlsl[_s32]_x(svbool_t pg, svint32_t op1, svuint32_t op2) - /// svint32_t svlsl[_s32]_z(svbool_t pg, svint32_t op1, svuint32_t op2) - /// LSL Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svint32_t svlsl[_s32]_m(svbool_t pg, svint32_t op1, svuint32_t op2) + /// svint32_t svlsl[_s32]_x(svbool_t pg, svint32_t op1, svuint32_t op2) + /// svint32_t svlsl[_s32]_z(svbool_t pg, svint32_t op1, svuint32_t op2) + /// LSL Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); + public static Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); /// - /// svint32_t svlsl_wide[_s32]_m(svbool_t pg, svint32_t op1, svuint64_t op2) - /// svint32_t svlsl_wide[_s32]_x(svbool_t pg, svint32_t op1, svuint64_t op2) - /// svint32_t svlsl_wide[_s32]_z(svbool_t pg, svint32_t op1, svuint64_t op2) - /// LSL Ztied1.S, Pg/M, Ztied1.S, Zop2.D + /// svint32_t svlsl_wide[_s32]_m(svbool_t pg, svint32_t op1, svuint64_t op2) + /// svint32_t svlsl_wide[_s32]_x(svbool_t pg, svint32_t op1, svuint64_t op2) + /// svint32_t svlsl_wide[_s32]_z(svbool_t pg, svint32_t op1, svuint64_t op2) + /// LSL Ztied1.S, Pg/M, Ztied1.S, Zop2.D /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); + public static Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); /// - /// svint64_t svlsl[_s64]_m(svbool_t pg, svint64_t op1, svuint64_t op2) - /// svint64_t svlsl[_s64]_x(svbool_t pg, svint64_t op1, svuint64_t op2) - /// svint64_t svlsl[_s64]_z(svbool_t pg, svint64_t op1, svuint64_t op2) - /// LSL Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svint64_t svlsl[_s64]_m(svbool_t pg, svint64_t op1, svuint64_t op2) + /// svint64_t svlsl[_s64]_x(svbool_t pg, svint64_t op1, svuint64_t op2) + /// svint64_t svlsl[_s64]_z(svbool_t pg, svint64_t op1, svuint64_t op2) + /// LSL Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); + public static Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); /// - /// svint8_t svlsl[_s8]_m(svbool_t pg, svint8_t op1, svuint8_t op2) - /// svint8_t svlsl[_s8]_x(svbool_t pg, svint8_t op1, svuint8_t op2) - /// svint8_t svlsl[_s8]_z(svbool_t pg, svint8_t op1, svuint8_t op2) - /// LSL Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// svint8_t svlsl[_s8]_m(svbool_t pg, svint8_t op1, svuint8_t op2) + /// svint8_t svlsl[_s8]_x(svbool_t pg, svint8_t op1, svuint8_t op2) + /// svint8_t svlsl[_s8]_z(svbool_t pg, svint8_t op1, svuint8_t op2) + /// LSL Ztied1.B, Pg/M, Ztied1.B, Zop2.B /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); + public static Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); /// - /// svint8_t svlsl_wide[_s8]_m(svbool_t pg, svint8_t op1, svuint64_t op2) - /// svint8_t svlsl_wide[_s8]_x(svbool_t pg, svint8_t op1, svuint64_t op2) - /// svint8_t svlsl_wide[_s8]_z(svbool_t pg, svint8_t op1, svuint64_t op2) - /// LSL Ztied1.B, Pg/M, Ztied1.B, Zop2.D + /// svint8_t svlsl_wide[_s8]_m(svbool_t pg, svint8_t op1, svuint64_t op2) + /// svint8_t svlsl_wide[_s8]_x(svbool_t pg, svint8_t op1, svuint64_t op2) + /// svint8_t svlsl_wide[_s8]_z(svbool_t pg, svint8_t op1, svuint64_t op2) + /// LSL Ztied1.B, Pg/M, Ztied1.B, Zop2.D /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); + public static Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); /// - /// svuint16_t svlsl[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svlsl[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svlsl[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// LSL Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// svuint16_t svlsl[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svlsl[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svlsl[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// LSL Ztied1.H, Pg/M, Ztied1.H, Zop2.H /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); + public static Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); /// - /// svuint16_t svlsl_wide[_u16]_m(svbool_t pg, svuint16_t op1, svuint64_t op2) - /// svuint16_t svlsl_wide[_u16]_x(svbool_t pg, svuint16_t op1, svuint64_t op2) - /// svuint16_t svlsl_wide[_u16]_z(svbool_t pg, svuint16_t op1, svuint64_t op2) - /// LSL Ztied1.H, Pg/M, Ztied1.H, Zop2.D + /// svuint16_t svlsl_wide[_u16]_m(svbool_t pg, svuint16_t op1, svuint64_t op2) + /// svuint16_t svlsl_wide[_u16]_x(svbool_t pg, svuint16_t op1, svuint64_t op2) + /// svuint16_t svlsl_wide[_u16]_z(svbool_t pg, svuint16_t op1, svuint64_t op2) + /// LSL Ztied1.H, Pg/M, Ztied1.H, Zop2.D /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); + public static Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); /// - /// svuint32_t svlsl[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svlsl[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svlsl[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// LSL Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svuint32_t svlsl[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svlsl[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svlsl[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// LSL Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); + public static Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); /// - /// svuint32_t svlsl_wide[_u32]_m(svbool_t pg, svuint32_t op1, svuint64_t op2) - /// svuint32_t svlsl_wide[_u32]_x(svbool_t pg, svuint32_t op1, svuint64_t op2) - /// svuint32_t svlsl_wide[_u32]_z(svbool_t pg, svuint32_t op1, svuint64_t op2) - /// LSL Ztied1.S, Pg/M, Ztied1.S, Zop2.D + /// svuint32_t svlsl_wide[_u32]_m(svbool_t pg, svuint32_t op1, svuint64_t op2) + /// svuint32_t svlsl_wide[_u32]_x(svbool_t pg, svuint32_t op1, svuint64_t op2) + /// svuint32_t svlsl_wide[_u32]_z(svbool_t pg, svuint32_t op1, svuint64_t op2) + /// LSL Ztied1.S, Pg/M, Ztied1.S, Zop2.D /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); + public static Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); /// - /// svuint64_t svlsl[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svlsl[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svlsl[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// LSL Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svuint64_t svlsl[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svlsl[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svlsl[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// LSL Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); + public static Vector ShiftLeftLogical(Vector left, Vector right) => ShiftLeftLogical(left, right); // Arithmetic shift right /// - /// svint16_t svasr[_s16]_m(svbool_t pg, svint16_t op1, svuint16_t op2) - /// svint16_t svasr[_s16]_x(svbool_t pg, svint16_t op1, svuint16_t op2) - /// svint16_t svasr[_s16]_z(svbool_t pg, svint16_t op1, svuint16_t op2) - /// ASR Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// svint16_t svasr[_s16]_m(svbool_t pg, svint16_t op1, svuint16_t op2) + /// svint16_t svasr[_s16]_x(svbool_t pg, svint16_t op1, svuint16_t op2) + /// svint16_t svasr[_s16]_z(svbool_t pg, svint16_t op1, svuint16_t op2) + /// ASR Ztied1.H, Pg/M, Ztied1.H, Zop2.H /// - public static unsafe Vector ShiftRightArithmetic(Vector left, Vector right) => ShiftRightArithmetic(left, right); + public static Vector ShiftRightArithmetic(Vector left, Vector right) => ShiftRightArithmetic(left, right); /// - /// svint16_t svasr_wide[_s16]_m(svbool_t pg, svint16_t op1, svuint64_t op2) - /// svint16_t svasr_wide[_s16]_x(svbool_t pg, svint16_t op1, svuint64_t op2) - /// svint16_t svasr_wide[_s16]_z(svbool_t pg, svint16_t op1, svuint64_t op2) - /// ASR Ztied1.H, Pg/M, Ztied1.H, Zop2.D + /// svint16_t svasr_wide[_s16]_m(svbool_t pg, svint16_t op1, svuint64_t op2) + /// svint16_t svasr_wide[_s16]_x(svbool_t pg, svint16_t op1, svuint64_t op2) + /// svint16_t svasr_wide[_s16]_z(svbool_t pg, svint16_t op1, svuint64_t op2) + /// ASR Ztied1.H, Pg/M, Ztied1.H, Zop2.D /// - public static unsafe Vector ShiftRightArithmetic(Vector left, Vector right) => ShiftRightArithmetic(left, right); + public static Vector ShiftRightArithmetic(Vector left, Vector right) => ShiftRightArithmetic(left, right); /// - /// svint32_t svasr[_s32]_m(svbool_t pg, svint32_t op1, svuint32_t op2) - /// svint32_t svasr[_s32]_x(svbool_t pg, svint32_t op1, svuint32_t op2) - /// svint32_t svasr[_s32]_z(svbool_t pg, svint32_t op1, svuint32_t op2) - /// ASR Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svint32_t svasr[_s32]_m(svbool_t pg, svint32_t op1, svuint32_t op2) + /// svint32_t svasr[_s32]_x(svbool_t pg, svint32_t op1, svuint32_t op2) + /// svint32_t svasr[_s32]_z(svbool_t pg, svint32_t op1, svuint32_t op2) + /// ASR Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector ShiftRightArithmetic(Vector left, Vector right) => ShiftRightArithmetic(left, right); + public static Vector ShiftRightArithmetic(Vector left, Vector right) => ShiftRightArithmetic(left, right); /// - /// svint32_t svasr_wide[_s32]_m(svbool_t pg, svint32_t op1, svuint64_t op2) - /// svint32_t svasr_wide[_s32]_x(svbool_t pg, svint32_t op1, svuint64_t op2) - /// svint32_t svasr_wide[_s32]_z(svbool_t pg, svint32_t op1, svuint64_t op2) - /// ASR Ztied1.S, Pg/M, Ztied1.S, Zop2.D + /// svint32_t svasr_wide[_s32]_m(svbool_t pg, svint32_t op1, svuint64_t op2) + /// svint32_t svasr_wide[_s32]_x(svbool_t pg, svint32_t op1, svuint64_t op2) + /// svint32_t svasr_wide[_s32]_z(svbool_t pg, svint32_t op1, svuint64_t op2) + /// ASR Ztied1.S, Pg/M, Ztied1.S, Zop2.D /// - public static unsafe Vector ShiftRightArithmetic(Vector left, Vector right) => ShiftRightArithmetic(left, right); + public static Vector ShiftRightArithmetic(Vector left, Vector right) => ShiftRightArithmetic(left, right); /// - /// svint64_t svasr[_s64]_m(svbool_t pg, svint64_t op1, svuint64_t op2) - /// svint64_t svasr[_s64]_x(svbool_t pg, svint64_t op1, svuint64_t op2) - /// svint64_t svasr[_s64]_z(svbool_t pg, svint64_t op1, svuint64_t op2) - /// ASR Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svint64_t svasr[_s64]_m(svbool_t pg, svint64_t op1, svuint64_t op2) + /// svint64_t svasr[_s64]_x(svbool_t pg, svint64_t op1, svuint64_t op2) + /// svint64_t svasr[_s64]_z(svbool_t pg, svint64_t op1, svuint64_t op2) + /// ASR Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector ShiftRightArithmetic(Vector left, Vector right) => ShiftRightArithmetic(left, right); + public static Vector ShiftRightArithmetic(Vector left, Vector right) => ShiftRightArithmetic(left, right); /// - /// svint8_t svasr[_s8]_m(svbool_t pg, svint8_t op1, svuint8_t op2) - /// svint8_t svasr[_s8]_x(svbool_t pg, svint8_t op1, svuint8_t op2) - /// svint8_t svasr[_s8]_z(svbool_t pg, svint8_t op1, svuint8_t op2) - /// ASR Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// svint8_t svasr[_s8]_m(svbool_t pg, svint8_t op1, svuint8_t op2) + /// svint8_t svasr[_s8]_x(svbool_t pg, svint8_t op1, svuint8_t op2) + /// svint8_t svasr[_s8]_z(svbool_t pg, svint8_t op1, svuint8_t op2) + /// ASR Ztied1.B, Pg/M, Ztied1.B, Zop2.B /// - public static unsafe Vector ShiftRightArithmetic(Vector left, Vector right) => ShiftRightArithmetic(left, right); + public static Vector ShiftRightArithmetic(Vector left, Vector right) => ShiftRightArithmetic(left, right); /// - /// svint8_t svasr_wide[_s8]_m(svbool_t pg, svint8_t op1, svuint64_t op2) - /// svint8_t svasr_wide[_s8]_x(svbool_t pg, svint8_t op1, svuint64_t op2) - /// svint8_t svasr_wide[_s8]_z(svbool_t pg, svint8_t op1, svuint64_t op2) - /// ASR Ztied1.B, Pg/M, Ztied1.B, Zop2.D + /// svint8_t svasr_wide[_s8]_m(svbool_t pg, svint8_t op1, svuint64_t op2) + /// svint8_t svasr_wide[_s8]_x(svbool_t pg, svint8_t op1, svuint64_t op2) + /// svint8_t svasr_wide[_s8]_z(svbool_t pg, svint8_t op1, svuint64_t op2) + /// ASR Ztied1.B, Pg/M, Ztied1.B, Zop2.D /// - public static unsafe Vector ShiftRightArithmetic(Vector left, Vector right) => ShiftRightArithmetic(left, right); + public static Vector ShiftRightArithmetic(Vector left, Vector right) => ShiftRightArithmetic(left, right); // Arithmetic shift right for divide by immediate /// - /// svint16_t svasrd[_n_s16]_m(svbool_t pg, svint16_t op1, uint64_t imm2) - /// svint16_t svasrd[_n_s16]_x(svbool_t pg, svint16_t op1, uint64_t imm2) - /// svint16_t svasrd[_n_s16]_z(svbool_t pg, svint16_t op1, uint64_t imm2) - /// ASRD Ztied1.H, Pg/M, Ztied1.H, #imm2 + /// svint16_t svasrd[_n_s16]_m(svbool_t pg, svint16_t op1, uint64_t imm2) + /// svint16_t svasrd[_n_s16]_x(svbool_t pg, svint16_t op1, uint64_t imm2) + /// svint16_t svasrd[_n_s16]_z(svbool_t pg, svint16_t op1, uint64_t imm2) + /// ASRD Ztied1.H, Pg/M, Ztied1.H, #imm2 /// - public static unsafe Vector ShiftRightArithmeticForDivide(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte control) => ShiftRightArithmeticForDivide(value, control); + public static Vector ShiftRightArithmeticForDivide(Vector value, [ConstantExpected(Min = 1, Max = (byte)(16))] byte control) => ShiftRightArithmeticForDivide(value, control); /// - /// svint32_t svasrd[_n_s32]_m(svbool_t pg, svint32_t op1, uint64_t imm2) - /// svint32_t svasrd[_n_s32]_x(svbool_t pg, svint32_t op1, uint64_t imm2) - /// svint32_t svasrd[_n_s32]_z(svbool_t pg, svint32_t op1, uint64_t imm2) - /// ASRD Ztied1.S, Pg/M, Ztied1.S, #imm2 + /// svint32_t svasrd[_n_s32]_m(svbool_t pg, svint32_t op1, uint64_t imm2) + /// svint32_t svasrd[_n_s32]_x(svbool_t pg, svint32_t op1, uint64_t imm2) + /// svint32_t svasrd[_n_s32]_z(svbool_t pg, svint32_t op1, uint64_t imm2) + /// ASRD Ztied1.S, Pg/M, Ztied1.S, #imm2 /// - public static unsafe Vector ShiftRightArithmeticForDivide(Vector value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte control) => ShiftRightArithmeticForDivide(value, control); + public static Vector ShiftRightArithmeticForDivide(Vector value, [ConstantExpected(Min = 1, Max = (byte)(32))] byte control) => ShiftRightArithmeticForDivide(value, control); /// - /// svint64_t svasrd[_n_s64]_m(svbool_t pg, svint64_t op1, uint64_t imm2) - /// svint64_t svasrd[_n_s64]_x(svbool_t pg, svint64_t op1, uint64_t imm2) - /// svint64_t svasrd[_n_s64]_z(svbool_t pg, svint64_t op1, uint64_t imm2) - /// ASRD Ztied1.D, Pg/M, Ztied1.D, #imm2 + /// svint64_t svasrd[_n_s64]_m(svbool_t pg, svint64_t op1, uint64_t imm2) + /// svint64_t svasrd[_n_s64]_x(svbool_t pg, svint64_t op1, uint64_t imm2) + /// svint64_t svasrd[_n_s64]_z(svbool_t pg, svint64_t op1, uint64_t imm2) + /// ASRD Ztied1.D, Pg/M, Ztied1.D, #imm2 /// - public static unsafe Vector ShiftRightArithmeticForDivide(Vector value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte control) => ShiftRightArithmeticForDivide(value, control); + public static Vector ShiftRightArithmeticForDivide(Vector value, [ConstantExpected(Min = 1, Max = (byte)(64))] byte control) => ShiftRightArithmeticForDivide(value, control); /// - /// svint8_t svasrd[_n_s8]_m(svbool_t pg, svint8_t op1, uint64_t imm2) - /// svint8_t svasrd[_n_s8]_x(svbool_t pg, svint8_t op1, uint64_t imm2) - /// svint8_t svasrd[_n_s8]_z(svbool_t pg, svint8_t op1, uint64_t imm2) - /// ASRD Ztied1.B, Pg/M, Ztied1.B, #imm2 + /// svint8_t svasrd[_n_s8]_m(svbool_t pg, svint8_t op1, uint64_t imm2) + /// svint8_t svasrd[_n_s8]_x(svbool_t pg, svint8_t op1, uint64_t imm2) + /// svint8_t svasrd[_n_s8]_z(svbool_t pg, svint8_t op1, uint64_t imm2) + /// ASRD Ztied1.B, Pg/M, Ztied1.B, #imm2 /// - public static unsafe Vector ShiftRightArithmeticForDivide(Vector value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte control) => ShiftRightArithmeticForDivide(value, control); + public static Vector ShiftRightArithmeticForDivide(Vector value, [ConstantExpected(Min = 1, Max = (byte)(8))] byte control) => ShiftRightArithmeticForDivide(value, control); // Logical shift right /// - /// svuint8_t svlsr[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svlsr[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svlsr[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// LSR Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// svuint8_t svlsr[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svlsr[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svlsr[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// LSR Ztied1.B, Pg/M, Ztied1.B, Zop2.B /// - public static unsafe Vector ShiftRightLogical(Vector left, Vector right) => ShiftRightLogical(left, right); + public static Vector ShiftRightLogical(Vector left, Vector right) => ShiftRightLogical(left, right); /// - /// svuint8_t svlsr_wide[_u8]_m(svbool_t pg, svuint8_t op1, svuint64_t op2) - /// svuint8_t svlsr_wide[_u8]_x(svbool_t pg, svuint8_t op1, svuint64_t op2) - /// svuint8_t svlsr_wide[_u8]_z(svbool_t pg, svuint8_t op1, svuint64_t op2) - /// LSR Ztied1.B, Pg/M, Ztied1.B, Zop2.D + /// svuint8_t svlsr_wide[_u8]_m(svbool_t pg, svuint8_t op1, svuint64_t op2) + /// svuint8_t svlsr_wide[_u8]_x(svbool_t pg, svuint8_t op1, svuint64_t op2) + /// svuint8_t svlsr_wide[_u8]_z(svbool_t pg, svuint8_t op1, svuint64_t op2) + /// LSR Ztied1.B, Pg/M, Ztied1.B, Zop2.D /// - public static unsafe Vector ShiftRightLogical(Vector left, Vector right) => ShiftRightLogical(left, right); + public static Vector ShiftRightLogical(Vector left, Vector right) => ShiftRightLogical(left, right); /// - /// svuint16_t svlsr[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svlsr[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svlsr[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// LSR Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// svuint16_t svlsr[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svlsr[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svlsr[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// LSR Ztied1.H, Pg/M, Ztied1.H, Zop2.H /// - public static unsafe Vector ShiftRightLogical(Vector left, Vector right) => ShiftRightLogical(left, right); + public static Vector ShiftRightLogical(Vector left, Vector right) => ShiftRightLogical(left, right); /// - /// svuint16_t svlsr_wide[_u16]_m(svbool_t pg, svuint16_t op1, svuint64_t op2) - /// svuint16_t svlsr_wide[_u16]_x(svbool_t pg, svuint16_t op1, svuint64_t op2) - /// svuint16_t svlsr_wide[_u16]_z(svbool_t pg, svuint16_t op1, svuint64_t op2) - /// LSR Ztied1.H, Pg/M, Ztied1.H, Zop2.D + /// svuint16_t svlsr_wide[_u16]_m(svbool_t pg, svuint16_t op1, svuint64_t op2) + /// svuint16_t svlsr_wide[_u16]_x(svbool_t pg, svuint16_t op1, svuint64_t op2) + /// svuint16_t svlsr_wide[_u16]_z(svbool_t pg, svuint16_t op1, svuint64_t op2) + /// LSR Ztied1.H, Pg/M, Ztied1.H, Zop2.D /// - public static unsafe Vector ShiftRightLogical(Vector left, Vector right) => ShiftRightLogical(left, right); + public static Vector ShiftRightLogical(Vector left, Vector right) => ShiftRightLogical(left, right); /// - /// svuint32_t svlsr[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svlsr[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svlsr[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// LSR Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svuint32_t svlsr[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svlsr[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svlsr[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// LSR Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector ShiftRightLogical(Vector left, Vector right) => ShiftRightLogical(left, right); + public static Vector ShiftRightLogical(Vector left, Vector right) => ShiftRightLogical(left, right); /// - /// svuint32_t svlsr_wide[_u32]_m(svbool_t pg, svuint32_t op1, svuint64_t op2) - /// svuint32_t svlsr_wide[_u32]_x(svbool_t pg, svuint32_t op1, svuint64_t op2) - /// svuint32_t svlsr_wide[_u32]_z(svbool_t pg, svuint32_t op1, svuint64_t op2) - /// LSR Ztied1.S, Pg/M, Ztied1.S, Zop2.D + /// svuint32_t svlsr_wide[_u32]_m(svbool_t pg, svuint32_t op1, svuint64_t op2) + /// svuint32_t svlsr_wide[_u32]_x(svbool_t pg, svuint32_t op1, svuint64_t op2) + /// svuint32_t svlsr_wide[_u32]_z(svbool_t pg, svuint32_t op1, svuint64_t op2) + /// LSR Ztied1.S, Pg/M, Ztied1.S, Zop2.D /// - public static unsafe Vector ShiftRightLogical(Vector left, Vector right) => ShiftRightLogical(left, right); + public static Vector ShiftRightLogical(Vector left, Vector right) => ShiftRightLogical(left, right); /// - /// svuint64_t svlsr[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svlsr[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svlsr[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// LSR Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svuint64_t svlsr[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svlsr[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svlsr[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// LSR Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector ShiftRightLogical(Vector left, Vector right) => ShiftRightLogical(left, right); + public static Vector ShiftRightLogical(Vector left, Vector right) => ShiftRightLogical(left, right); // Sign-extend the low 16 bits /// - /// svint32_t svexth[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) - /// svint32_t svexth[_s32]_x(svbool_t pg, svint32_t op) - /// svint32_t svexth[_s32]_z(svbool_t pg, svint32_t op) - /// SXTH Zresult.S, Pg/M, Zop.S + /// svint32_t svexth[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) + /// svint32_t svexth[_s32]_x(svbool_t pg, svint32_t op) + /// svint32_t svexth[_s32]_z(svbool_t pg, svint32_t op) + /// SXTH Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector SignExtend16(Vector value) => SignExtend16(value); + public static Vector SignExtend16(Vector value) => SignExtend16(value); /// - /// svint64_t svexth[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) - /// svint64_t svexth[_s64]_x(svbool_t pg, svint64_t op) - /// svint64_t svexth[_s64]_z(svbool_t pg, svint64_t op) - /// SXTH Zresult.D, Pg/M, Zop.D + /// svint64_t svexth[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) + /// svint64_t svexth[_s64]_x(svbool_t pg, svint64_t op) + /// svint64_t svexth[_s64]_z(svbool_t pg, svint64_t op) + /// SXTH Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector SignExtend16(Vector value) => SignExtend16(value); + public static Vector SignExtend16(Vector value) => SignExtend16(value); // Sign-extend the low 32 bits /// - /// svint64_t svextw[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) - /// svint64_t svextw[_s64]_x(svbool_t pg, svint64_t op) - /// svint64_t svextw[_s64]_z(svbool_t pg, svint64_t op) - /// SXTW Zresult.D, Pg/M, Zop.D + /// svint64_t svextw[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) + /// svint64_t svextw[_s64]_x(svbool_t pg, svint64_t op) + /// svint64_t svextw[_s64]_z(svbool_t pg, svint64_t op) + /// SXTW Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector SignExtend32(Vector value) => SignExtend32(value); + public static Vector SignExtend32(Vector value) => SignExtend32(value); // Sign-extend the low 8 bits /// - /// svint16_t svextb[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) - /// svint16_t svextb[_s16]_x(svbool_t pg, svint16_t op) - /// svint16_t svextb[_s16]_z(svbool_t pg, svint16_t op) - /// SXTB Zresult.H, Pg/M, Zop.H + /// svint16_t svextb[_s16]_m(svint16_t inactive, svbool_t pg, svint16_t op) + /// svint16_t svextb[_s16]_x(svbool_t pg, svint16_t op) + /// svint16_t svextb[_s16]_z(svbool_t pg, svint16_t op) + /// SXTB Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector SignExtend8(Vector value) => SignExtend8(value); + public static Vector SignExtend8(Vector value) => SignExtend8(value); /// - /// svint32_t svextb[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) - /// svint32_t svextb[_s32]_x(svbool_t pg, svint32_t op) - /// svint32_t svextb[_s32]_z(svbool_t pg, svint32_t op) - /// SXTB Zresult.S, Pg/M, Zop.S + /// svint32_t svextb[_s32]_m(svint32_t inactive, svbool_t pg, svint32_t op) + /// svint32_t svextb[_s32]_x(svbool_t pg, svint32_t op) + /// svint32_t svextb[_s32]_z(svbool_t pg, svint32_t op) + /// SXTB Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector SignExtend8(Vector value) => SignExtend8(value); + public static Vector SignExtend8(Vector value) => SignExtend8(value); /// - /// svint64_t svextb[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) - /// svint64_t svextb[_s64]_x(svbool_t pg, svint64_t op) - /// svint64_t svextb[_s64]_z(svbool_t pg, svint64_t op) - /// SXTB Zresult.D, Pg/M, Zop.D + /// svint64_t svextb[_s64]_m(svint64_t inactive, svbool_t pg, svint64_t op) + /// svint64_t svextb[_s64]_x(svbool_t pg, svint64_t op) + /// svint64_t svextb[_s64]_z(svbool_t pg, svint64_t op) + /// SXTB Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector SignExtend8(Vector value) => SignExtend8(value); + public static Vector SignExtend8(Vector value) => SignExtend8(value); // Unpack and extend low half /// - /// svint16_t svunpklo[_s16](svint8_t op) - /// SUNPKLO Zresult.H, Zop.B + /// svint16_t svunpklo[_s16](svint8_t op) + /// SUNPKLO Zresult.H, Zop.B /// - public static unsafe Vector SignExtendWideningLower(Vector value) => SignExtendWideningLower(value); + public static Vector SignExtendWideningLower(Vector value) => SignExtendWideningLower(value); /// - /// svint32_t svunpklo[_s32](svint16_t op) - /// SUNPKLO Zresult.S, Zop.H + /// svint32_t svunpklo[_s32](svint16_t op) + /// SUNPKLO Zresult.S, Zop.H /// - public static unsafe Vector SignExtendWideningLower(Vector value) => SignExtendWideningLower(value); + public static Vector SignExtendWideningLower(Vector value) => SignExtendWideningLower(value); /// - /// svint64_t svunpklo[_s64](svint32_t op) - /// SUNPKLO Zresult.D, Zop.S + /// svint64_t svunpklo[_s64](svint32_t op) + /// SUNPKLO Zresult.D, Zop.S /// - public static unsafe Vector SignExtendWideningLower(Vector value) => SignExtendWideningLower(value); + public static Vector SignExtendWideningLower(Vector value) => SignExtendWideningLower(value); // Unpack and extend high half /// - /// svint16_t svunpkhi[_s16](svint8_t op) - /// SUNPKHI Zresult.H, Zop.B + /// svint16_t svunpkhi[_s16](svint8_t op) + /// SUNPKHI Zresult.H, Zop.B /// - public static unsafe Vector SignExtendWideningUpper(Vector value) => SignExtendWideningUpper(value); + public static Vector SignExtendWideningUpper(Vector value) => SignExtendWideningUpper(value); /// - /// svint32_t svunpkhi[_s32](svint16_t op) - /// SUNPKHI Zresult.S, Zop.H + /// svint32_t svunpkhi[_s32](svint16_t op) + /// SUNPKHI Zresult.S, Zop.H /// - public static unsafe Vector SignExtendWideningUpper(Vector value) => SignExtendWideningUpper(value); + public static Vector SignExtendWideningUpper(Vector value) => SignExtendWideningUpper(value); /// - /// svint64_t svunpkhi[_s64](svint32_t op) - /// SUNPKHI Zresult.D, Zop.S + /// svint64_t svunpkhi[_s64](svint32_t op) + /// SUNPKHI Zresult.D, Zop.S /// - public static unsafe Vector SignExtendWideningUpper(Vector value) => SignExtendWideningUpper(value); + public static Vector SignExtendWideningUpper(Vector value) => SignExtendWideningUpper(value); // Splice two vectors under predicate control /// - /// svuint8_t svsplice[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) - /// SPLICE Ztied1.B, Pg, Ztied1.B, Zop2.B + /// svuint8_t svsplice[_u8](svbool_t pg, svuint8_t op1, svuint8_t op2) + /// SPLICE Ztied1.B, Pg, Ztied1.B, Zop2.B /// - public static unsafe Vector Splice(Vector mask, Vector left, Vector right) => Splice(mask, left, right); + public static Vector Splice(Vector mask, Vector left, Vector right) => Splice(mask, left, right); /// - /// svfloat64_t svsplice[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// SPLICE Ztied1.D, Pg, Ztied1.D, Zop2.D + /// svfloat64_t svsplice[_f64](svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// SPLICE Ztied1.D, Pg, Ztied1.D, Zop2.D /// - public static unsafe Vector Splice(Vector mask, Vector left, Vector right) => Splice(mask, left, right); + public static Vector Splice(Vector mask, Vector left, Vector right) => Splice(mask, left, right); /// - /// svint16_t svsplice[_s16](svbool_t pg, svint16_t op1, svint16_t op2) - /// SPLICE Ztied1.H, Pg, Ztied1.H, Zop2.H + /// svint16_t svsplice[_s16](svbool_t pg, svint16_t op1, svint16_t op2) + /// SPLICE Ztied1.H, Pg, Ztied1.H, Zop2.H /// - public static unsafe Vector Splice(Vector mask, Vector left, Vector right) => Splice(mask, left, right); + public static Vector Splice(Vector mask, Vector left, Vector right) => Splice(mask, left, right); /// - /// svint32_t svsplice[_s32](svbool_t pg, svint32_t op1, svint32_t op2) - /// SPLICE Ztied1.S, Pg, Ztied1.S, Zop2.S + /// svint32_t svsplice[_s32](svbool_t pg, svint32_t op1, svint32_t op2) + /// SPLICE Ztied1.S, Pg, Ztied1.S, Zop2.S /// - public static unsafe Vector Splice(Vector mask, Vector left, Vector right) => Splice(mask, left, right); + public static Vector Splice(Vector mask, Vector left, Vector right) => Splice(mask, left, right); /// - /// svint64_t svsplice[_s64](svbool_t pg, svint64_t op1, svint64_t op2) - /// SPLICE Ztied1.D, Pg, Ztied1.D, Zop2.D + /// svint64_t svsplice[_s64](svbool_t pg, svint64_t op1, svint64_t op2) + /// SPLICE Ztied1.D, Pg, Ztied1.D, Zop2.D /// - public static unsafe Vector Splice(Vector mask, Vector left, Vector right) => Splice(mask, left, right); + public static Vector Splice(Vector mask, Vector left, Vector right) => Splice(mask, left, right); /// - /// svint8_t svsplice[_s8](svbool_t pg, svint8_t op1, svint8_t op2) - /// SPLICE Ztied1.B, Pg, Ztied1.B, Zop2.B + /// svint8_t svsplice[_s8](svbool_t pg, svint8_t op1, svint8_t op2) + /// SPLICE Ztied1.B, Pg, Ztied1.B, Zop2.B /// - public static unsafe Vector Splice(Vector mask, Vector left, Vector right) => Splice(mask, left, right); + public static Vector Splice(Vector mask, Vector left, Vector right) => Splice(mask, left, right); /// - /// svfloat32_t svsplice[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// SPLICE Ztied1.S, Pg, Ztied1.S, Zop2.S + /// svfloat32_t svsplice[_f32](svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// SPLICE Ztied1.S, Pg, Ztied1.S, Zop2.S /// - public static unsafe Vector Splice(Vector mask, Vector left, Vector right) => Splice(mask, left, right); + public static Vector Splice(Vector mask, Vector left, Vector right) => Splice(mask, left, right); /// - /// svuint16_t svsplice[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) - /// SPLICE Ztied1.H, Pg, Ztied1.H, Zop2.H + /// svuint16_t svsplice[_u16](svbool_t pg, svuint16_t op1, svuint16_t op2) + /// SPLICE Ztied1.H, Pg, Ztied1.H, Zop2.H /// - public static unsafe Vector Splice(Vector mask, Vector left, Vector right) => Splice(mask, left, right); + public static Vector Splice(Vector mask, Vector left, Vector right) => Splice(mask, left, right); /// - /// svuint32_t svsplice[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) - /// SPLICE Ztied1.S, Pg, Ztied1.S, Zop2.S + /// svuint32_t svsplice[_u32](svbool_t pg, svuint32_t op1, svuint32_t op2) + /// SPLICE Ztied1.S, Pg, Ztied1.S, Zop2.S /// - public static unsafe Vector Splice(Vector mask, Vector left, Vector right) => Splice(mask, left, right); + public static Vector Splice(Vector mask, Vector left, Vector right) => Splice(mask, left, right); /// - /// svuint64_t svsplice[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) - /// SPLICE Ztied1.D, Pg, Ztied1.D, Zop2.D + /// svuint64_t svsplice[_u64](svbool_t pg, svuint64_t op1, svuint64_t op2) + /// SPLICE Ztied1.D, Pg, Ztied1.D, Zop2.D /// - public static unsafe Vector Splice(Vector mask, Vector left, Vector right) => Splice(mask, left, right); + public static Vector Splice(Vector mask, Vector left, Vector right) => Splice(mask, left, right); // Square root /// - /// svfloat64_t svsqrt[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) - /// svfloat64_t svsqrt[_f64]_x(svbool_t pg, svfloat64_t op) - /// svfloat64_t svsqrt[_f64]_z(svbool_t pg, svfloat64_t op) - /// FSQRT Zresult.D, Pg/M, Zop.D + /// svfloat64_t svsqrt[_f64]_m(svfloat64_t inactive, svbool_t pg, svfloat64_t op) + /// svfloat64_t svsqrt[_f64]_x(svbool_t pg, svfloat64_t op) + /// svfloat64_t svsqrt[_f64]_z(svbool_t pg, svfloat64_t op) + /// FSQRT Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector Sqrt(Vector value) => Sqrt(value); + public static Vector Sqrt(Vector value) => Sqrt(value); /// - /// svfloat32_t svsqrt[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) - /// svfloat32_t svsqrt[_f32]_x(svbool_t pg, svfloat32_t op) - /// svfloat32_t svsqrt[_f32]_z(svbool_t pg, svfloat32_t op) - /// FSQRT Zresult.S, Pg/M, Zop.S + /// svfloat32_t svsqrt[_f32]_m(svfloat32_t inactive, svbool_t pg, svfloat32_t op) + /// svfloat32_t svsqrt[_f32]_x(svbool_t pg, svfloat32_t op) + /// svfloat32_t svsqrt[_f32]_z(svbool_t pg, svfloat32_t op) + /// FSQRT Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector Sqrt(Vector value) => Sqrt(value); + public static Vector Sqrt(Vector value) => Sqrt(value); // Non-truncating store /// - /// void svst1[_u8](svbool_t pg, uint8_t *base, svuint8_t data) - /// ST1B Zdata.B, Pg, [Xbase, #0, MUL VL] + /// void svst1[_u8](svbool_t pg, uint8_t *base, svuint8_t data) + /// ST1B Zdata.B, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, byte* address, Vector data) => StoreAndZip(mask, address, data); /// - /// void svst2[_u8](svbool_t pg, uint8_t *base, svuint8x2_t data) - /// ST2B {Zdata0.B, Zdata1.B}, Pg, [Xbase, #0, MUL VL] + /// void svst2[_u8](svbool_t pg, uint8_t *base, svuint8x2_t data) + /// ST2B {Zdata0.B, Zdata1.B}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, byte* address, (Vector Value1, Vector Value2) data) => StoreAndZip(mask, address, data); /// - /// void svst3[_u8](svbool_t pg, uint8_t *base, svuint8x3_t data) - /// ST3B {Zdata0.B - Zdata2.B}, Pg, [Xbase, #0, MUL VL] + /// void svst3[_u8](svbool_t pg, uint8_t *base, svuint8x3_t data) + /// ST3B {Zdata0.B - Zdata2.B}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, byte* address, (Vector Value1, Vector Value2, Vector Value3) data) => StoreAndZip(mask, address, data); /// - /// void svst4[_u8](svbool_t pg, uint8_t *base, svuint8x4_t data) - /// ST4B {Zdata0.B - Zdata3.B}, Pg, [Xbase, #0, MUL VL] + /// void svst4[_u8](svbool_t pg, uint8_t *base, svuint8x4_t data) + /// ST4B {Zdata0.B - Zdata3.B}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, byte* address, (Vector Value1, Vector Value2, Vector Value3, Vector Value4) data) => StoreAndZip(mask, address, data); /// - /// void svst1[_f64](svbool_t pg, float64_t *base, svfloat64_t data) - /// ST1D Zdata.D, Pg, [Xbase, #0, MUL VL] + /// void svst1[_f64](svbool_t pg, float64_t *base, svfloat64_t data) + /// ST1D Zdata.D, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, double* address, Vector data) => StoreAndZip(mask, address, data); /// - /// void svst2[_f64](svbool_t pg, float64_t *base, svfloat64x2_t data) - /// ST2D {Zdata0.D, Zdata1.D}, Pg, [Xbase, #0, MUL VL] + /// void svst2[_f64](svbool_t pg, float64_t *base, svfloat64x2_t data) + /// ST2D {Zdata0.D, Zdata1.D}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, double* address, (Vector Value1, Vector Value2) data) => StoreAndZip(mask, address, data); /// - /// void svst3[_f64](svbool_t pg, float64_t *base, svfloat64x3_t data) - /// ST3D {Zdata0.D - Zdata2.D}, Pg, [Xbase, #0, MUL VL] + /// void svst3[_f64](svbool_t pg, float64_t *base, svfloat64x3_t data) + /// ST3D {Zdata0.D - Zdata2.D}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, double* address, (Vector Value1, Vector Value2, Vector Value3) data) => StoreAndZip(mask, address, data); /// - /// void svst4[_f64](svbool_t pg, float64_t *base, svfloat64x4_t data) - /// ST4D {Zdata0.D - Zdata3.D}, Pg, [Xbase, #0, MUL VL] + /// void svst4[_f64](svbool_t pg, float64_t *base, svfloat64x4_t data) + /// ST4D {Zdata0.D - Zdata3.D}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, double* address, (Vector Value1, Vector Value2, Vector Value3, Vector Value4) data) => StoreAndZip(mask, address, data); /// - /// void svst1[_s16](svbool_t pg, int16_t *base, svint16_t data) - /// ST1H Zdata.H, Pg, [Xbase, #0, MUL VL] + /// void svst1[_s16](svbool_t pg, int16_t *base, svint16_t data) + /// ST1H Zdata.H, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, short* address, Vector data) => StoreAndZip(mask, address, data); /// - /// void svst2[_s16](svbool_t pg, int16_t *base, svint16x2_t data) - /// ST2H {Zdata0.H, Zdata1.H}, Pg, [Xbase, #0, MUL VL] + /// void svst2[_s16](svbool_t pg, int16_t *base, svint16x2_t data) + /// ST2H {Zdata0.H, Zdata1.H}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, short* address, (Vector Value1, Vector Value2) data) => StoreAndZip(mask, address, data); /// - /// void svst3[_s16](svbool_t pg, int16_t *base, svint16x3_t data) - /// ST3H {Zdata0.H - Zdata2.H}, Pg, [Xbase, #0, MUL VL] + /// void svst3[_s16](svbool_t pg, int16_t *base, svint16x3_t data) + /// ST3H {Zdata0.H - Zdata2.H}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, short* address, (Vector Value1, Vector Value2, Vector Value3) data) => StoreAndZip(mask, address, data); /// - /// void svst4[_s16](svbool_t pg, int16_t *base, svint16x4_t data) - /// ST4H {Zdata0.H - Zdata3.H}, Pg, [Xbase, #0, MUL VL] + /// void svst4[_s16](svbool_t pg, int16_t *base, svint16x4_t data) + /// ST4H {Zdata0.H - Zdata3.H}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, short* address, (Vector Value1, Vector Value2, Vector Value3, Vector Value4) data) => StoreAndZip(mask, address, data); /// - /// void svst1[_s32](svbool_t pg, int32_t *base, svint32_t data) - /// ST1W Zdata.S, Pg, [Xbase, #0, MUL VL] + /// void svst1[_s32](svbool_t pg, int32_t *base, svint32_t data) + /// ST1W Zdata.S, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, int* address, Vector data) => StoreAndZip(mask, address, data); /// - /// void svst2[_s32](svbool_t pg, int32_t *base, svint32x2_t data) - /// ST2W {Zdata0.S, Zdata1.S}, Pg, [Xbase, #0, MUL VL] + /// void svst2[_s32](svbool_t pg, int32_t *base, svint32x2_t data) + /// ST2W {Zdata0.S, Zdata1.S}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, int* address, (Vector Value1, Vector Value2) data) => StoreAndZip(mask, address, data); /// - /// void svst3[_s32](svbool_t pg, int32_t *base, svint32x3_t data) - /// ST3W {Zdata0.S - Zdata2.S}, Pg, [Xbase, #0, MUL VL] + /// void svst3[_s32](svbool_t pg, int32_t *base, svint32x3_t data) + /// ST3W {Zdata0.S - Zdata2.S}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, int* address, (Vector Value1, Vector Value2, Vector Value3) data) => StoreAndZip(mask, address, data); /// - /// void svst4[_s32](svbool_t pg, int32_t *base, svint32x4_t data) - /// ST4W {Zdata0.S - Zdata3.S}, Pg, [Xbase, #0, MUL VL] + /// void svst4[_s32](svbool_t pg, int32_t *base, svint32x4_t data) + /// ST4W {Zdata0.S - Zdata3.S}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, int* address, (Vector Value1, Vector Value2, Vector Value3, Vector Value4) data) => StoreAndZip(mask, address, data); /// - /// void svst1[_s64](svbool_t pg, int64_t *base, svint64_t data) - /// ST1D Zdata.D, Pg, [Xbase, #0, MUL VL] + /// void svst1[_s64](svbool_t pg, int64_t *base, svint64_t data) + /// ST1D Zdata.D, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, long* address, Vector data) => StoreAndZip(mask, address, data); /// - /// void svst2[_s64](svbool_t pg, int64_t *base, svint64x2_t data) - /// ST2D {Zdata0.D, Zdata1.D}, Pg, [Xbase, #0, MUL VL] + /// void svst2[_s64](svbool_t pg, int64_t *base, svint64x2_t data) + /// ST2D {Zdata0.D, Zdata1.D}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, long* address, (Vector Value1, Vector Value2) data) => StoreAndZip(mask, address, data); /// - /// void svst3[_s64](svbool_t pg, int64_t *base, svint64x3_t data) - /// ST3D {Zdata0.D - Zdata2.D}, Pg, [Xbase, #0, MUL VL] + /// void svst3[_s64](svbool_t pg, int64_t *base, svint64x3_t data) + /// ST3D {Zdata0.D - Zdata2.D}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, long* address, (Vector Value1, Vector Value2, Vector Value3) data) => StoreAndZip(mask, address, data); /// - /// void svst4[_s64](svbool_t pg, int64_t *base, svint64x4_t data) - /// ST4D {Zdata0.D - Zdata3.D}, Pg, [Xbase, #0, MUL VL] + /// void svst4[_s64](svbool_t pg, int64_t *base, svint64x4_t data) + /// ST4D {Zdata0.D - Zdata3.D}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, long* address, (Vector Value1, Vector Value2, Vector Value3, Vector Value4) data) => StoreAndZip(mask, address, data); /// - /// void svst1[_s8](svbool_t pg, int8_t *base, svint8_t data) - /// ST1B Zdata.B, Pg, [Xbase, #0, MUL VL] + /// void svst1[_s8](svbool_t pg, int8_t *base, svint8_t data) + /// ST1B Zdata.B, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, sbyte* address, Vector data) => StoreAndZip(mask, address, data); /// - /// void svst2[_s8](svbool_t pg, int8_t *base, svint8x2_t data) - /// ST2B {Zdata0.B, Zdata1.B}, Pg, [Xbase, #0, MUL VL] + /// void svst2[_s8](svbool_t pg, int8_t *base, svint8x2_t data) + /// ST2B {Zdata0.B, Zdata1.B}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, sbyte* address, (Vector Value1, Vector Value2) data) => StoreAndZip(mask, address, data); /// - /// void svst3[_s8](svbool_t pg, int8_t *base, svint8x3_t data) - /// ST3B {Zdata0.B - Zdata2.B}, Pg, [Xbase, #0, MUL VL] + /// void svst3[_s8](svbool_t pg, int8_t *base, svint8x3_t data) + /// ST3B {Zdata0.B - Zdata2.B}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, sbyte* address, (Vector Value1, Vector Value2, Vector Value3) data) => StoreAndZip(mask, address, data); /// - /// void svst4[_s8](svbool_t pg, int8_t *base, svint8x4_t data) - /// ST4B {Zdata0.B - Zdata3.B}, Pg, [Xbase, #0, MUL VL] + /// void svst4[_s8](svbool_t pg, int8_t *base, svint8x4_t data) + /// ST4B {Zdata0.B - Zdata3.B}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, sbyte* address, (Vector Value1, Vector Value2, Vector Value3, Vector Value4) data) => StoreAndZip(mask, address, data); /// - /// void svst1[_f32](svbool_t pg, float32_t *base, svfloat32_t data) - /// ST1W Zdata.S, Pg, [Xbase, #0, MUL VL] + /// void svst1[_f32](svbool_t pg, float32_t *base, svfloat32_t data) + /// ST1W Zdata.S, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, float* address, Vector data) => StoreAndZip(mask, address, data); /// - /// void svst2[_f32](svbool_t pg, float32_t *base, svfloat32x2_t data) - /// ST2W {Zdata0.S, Zdata1.S}, Pg, [Xbase, #0, MUL VL] + /// void svst2[_f32](svbool_t pg, float32_t *base, svfloat32x2_t data) + /// ST2W {Zdata0.S, Zdata1.S}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, float* address, (Vector Value1, Vector Value2) data) => StoreAndZip(mask, address, data); /// - /// void svst3[_f32](svbool_t pg, float32_t *base, svfloat32x3_t data) - /// ST3W {Zdata0.S - Zdata2.S}, Pg, [Xbase, #0, MUL VL] + /// void svst3[_f32](svbool_t pg, float32_t *base, svfloat32x3_t data) + /// ST3W {Zdata0.S - Zdata2.S}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, float* address, (Vector Value1, Vector Value2, Vector Value3) data) => StoreAndZip(mask, address, data); /// - /// void svst4[_f32](svbool_t pg, float32_t *base, svfloat32x4_t data) - /// ST4W {Zdata0.S - Zdata3.S}, Pg, [Xbase, #0, MUL VL] + /// void svst4[_f32](svbool_t pg, float32_t *base, svfloat32x4_t data) + /// ST4W {Zdata0.S - Zdata3.S}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, float* address, (Vector Value1, Vector Value2, Vector Value3, Vector Value4) data) => StoreAndZip(mask, address, data); /// - /// void svst1[_u16](svbool_t pg, uint16_t *base, svuint16_t data) - /// ST1H Zdata.H, Pg, [Xbase, #0, MUL VL] + /// void svst1[_u16](svbool_t pg, uint16_t *base, svuint16_t data) + /// ST1H Zdata.H, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, ushort* address, Vector data) => StoreAndZip(mask, address, data); /// - /// void svst2[_u16](svbool_t pg, uint16_t *base, svuint16x2_t data) - /// ST2H {Zdata0.H, Zdata1.H}, Pg, [Xbase, #0, MUL VL] + /// void svst2[_u16](svbool_t pg, uint16_t *base, svuint16x2_t data) + /// ST2H {Zdata0.H, Zdata1.H}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, ushort* address, (Vector Value1, Vector Value2) data) => StoreAndZip(mask, address, data); /// - /// void svst3[_u16](svbool_t pg, uint16_t *base, svuint16x3_t data) - /// ST3H {Zdata0.H - Zdata2.H}, Pg, [Xbase, #0, MUL VL] + /// void svst3[_u16](svbool_t pg, uint16_t *base, svuint16x3_t data) + /// ST3H {Zdata0.H - Zdata2.H}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, ushort* address, (Vector Value1, Vector Value2, Vector Value3) data) => StoreAndZip(mask, address, data); /// - /// void svst4[_u16](svbool_t pg, uint16_t *base, svuint16x4_t data) - /// ST4H {Zdata0.H - Zdata3.H}, Pg, [Xbase, #0, MUL VL] + /// void svst4[_u16](svbool_t pg, uint16_t *base, svuint16x4_t data) + /// ST4H {Zdata0.H - Zdata3.H}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, ushort* address, (Vector Value1, Vector Value2, Vector Value3, Vector Value4) data) => StoreAndZip(mask, address, data); /// - /// void svst1[_u32](svbool_t pg, uint32_t *base, svuint32_t data) - /// ST1W Zdata.S, Pg, [Xbase, #0, MUL VL] + /// void svst1[_u32](svbool_t pg, uint32_t *base, svuint32_t data) + /// ST1W Zdata.S, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, uint* address, Vector data) => StoreAndZip(mask, address, data); /// - /// void svst2[_u32](svbool_t pg, uint32_t *base, svuint32x2_t data) - /// ST2W {Zdata0.S, Zdata1.S}, Pg, [Xbase, #0, MUL VL] + /// void svst2[_u32](svbool_t pg, uint32_t *base, svuint32x2_t data) + /// ST2W {Zdata0.S, Zdata1.S}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, uint* address, (Vector Value1, Vector Value2) data) => StoreAndZip(mask, address, data); /// - /// void svst3[_u32](svbool_t pg, uint32_t *base, svuint32x3_t data) - /// ST3W {Zdata0.S - Zdata2.S}, Pg, [Xbase, #0, MUL VL] + /// void svst3[_u32](svbool_t pg, uint32_t *base, svuint32x3_t data) + /// ST3W {Zdata0.S - Zdata2.S}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, uint* address, (Vector Value1, Vector Value2, Vector Value3) data) => StoreAndZip(mask, address, data); /// - /// void svst4[_u32](svbool_t pg, uint32_t *base, svuint32x4_t data) - /// ST4W {Zdata0.S - Zdata3.S}, Pg, [Xbase, #0, MUL VL] + /// void svst4[_u32](svbool_t pg, uint32_t *base, svuint32x4_t data) + /// ST4W {Zdata0.S - Zdata3.S}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, uint* address, (Vector Value1, Vector Value2, Vector Value3, Vector Value4) data) => StoreAndZip(mask, address, data); /// - /// void svst1[_u64](svbool_t pg, uint64_t *base, svuint64_t data) - /// ST1D Zdata.D, Pg, [Xbase, #0, MUL VL] + /// void svst1[_u64](svbool_t pg, uint64_t *base, svuint64_t data) + /// ST1D Zdata.D, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, ulong* address, Vector data) => StoreAndZip(mask, address, data); /// - /// void svst2[_u64](svbool_t pg, uint64_t *base, svuint64x2_t data) - /// ST2D {Zdata0.D, Zdata1.D}, Pg, [Xbase, #0, MUL VL] + /// void svst2[_u64](svbool_t pg, uint64_t *base, svuint64x2_t data) + /// ST2D {Zdata0.D, Zdata1.D}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, ulong* address, (Vector Value1, Vector Value2) data) => StoreAndZip(mask, address, data); /// - /// void svst3[_u64](svbool_t pg, uint64_t *base, svuint64x3_t data) - /// ST3D {Zdata0.D - Zdata2.D}, Pg, [Xbase, #0, MUL VL] + /// void svst3[_u64](svbool_t pg, uint64_t *base, svuint64x3_t data) + /// ST3D {Zdata0.D - Zdata2.D}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, ulong* address, (Vector Value1, Vector Value2, Vector Value3) data) => StoreAndZip(mask, address, data); /// - /// void svst4[_u64](svbool_t pg, uint64_t *base, svuint64x4_t data) - /// ST4D {Zdata0.D - Zdata3.D}, Pg, [Xbase, #0, MUL VL] + /// void svst4[_u64](svbool_t pg, uint64_t *base, svuint64x4_t data) + /// ST4D {Zdata0.D - Zdata3.D}, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreAndZip(Vector mask, ulong* address, (Vector Value1, Vector Value2, Vector Value3, Vector Value4) data) => StoreAndZip(mask, address, data); @@ -8837,74 +9497,74 @@ internal Arm64() { } // Truncate to 8 bits and store /// - /// void svst1b[_s16](svbool_t pg, int8_t *base, svint16_t data) - /// ST1B Zdata.H, Pg, [Xbase, #0, MUL VL] + /// void svst1b[_s16](svbool_t pg, int8_t *base, svint16_t data) + /// ST1B Zdata.H, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNarrowing(Vector mask, sbyte* address, Vector data) => StoreNarrowing(mask, address, data); /// - /// void svst1b[_s32](svbool_t pg, int8_t *base, svint32_t data) - /// ST1B Zdata.S, Pg, [Xbase, #0, MUL VL] + /// void svst1b[_s32](svbool_t pg, int8_t *base, svint32_t data) + /// ST1B Zdata.S, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNarrowing(Vector mask, sbyte* address, Vector data) => StoreNarrowing(mask, address, data); /// - /// void svst1h[_s32](svbool_t pg, int16_t *base, svint32_t data) - /// ST1H Zdata.S, Pg, [Xbase, #0, MUL VL] + /// void svst1h[_s32](svbool_t pg, int16_t *base, svint32_t data) + /// ST1H Zdata.S, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNarrowing(Vector mask, short* address, Vector data) => StoreNarrowing(mask, address, data); /// - /// void svst1b[_s64](svbool_t pg, int8_t *base, svint64_t data) - /// ST1B Zdata.D, Pg, [Xbase, #0, MUL VL] + /// void svst1b[_s64](svbool_t pg, int8_t *base, svint64_t data) + /// ST1B Zdata.D, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNarrowing(Vector mask, sbyte* address, Vector data) => StoreNarrowing(mask, address, data); /// - /// void svst1h[_s64](svbool_t pg, int16_t *base, svint64_t data) - /// ST1H Zdata.D, Pg, [Xbase, #0, MUL VL] + /// void svst1h[_s64](svbool_t pg, int16_t *base, svint64_t data) + /// ST1H Zdata.D, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNarrowing(Vector mask, short* address, Vector data) => StoreNarrowing(mask, address, data); /// - /// void svst1w[_s64](svbool_t pg, int32_t *base, svint64_t data) - /// ST1W Zdata.D, Pg, [Xbase, #0, MUL VL] + /// void svst1w[_s64](svbool_t pg, int32_t *base, svint64_t data) + /// ST1W Zdata.D, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNarrowing(Vector mask, int* address, Vector data) => StoreNarrowing(mask, address, data); /// - /// void svst1b[_u16](svbool_t pg, uint8_t *base, svuint16_t data) - /// ST1B Zdata.H, Pg, [Xbase, #0, MUL VL] + /// void svst1b[_u16](svbool_t pg, uint8_t *base, svuint16_t data) + /// ST1B Zdata.H, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNarrowing(Vector mask, byte* address, Vector data) => StoreNarrowing(mask, address, data); /// - /// void svst1b[_u32](svbool_t pg, uint8_t *base, svuint32_t data) - /// ST1B Zdata.S, Pg, [Xbase, #0, MUL VL] + /// void svst1b[_u32](svbool_t pg, uint8_t *base, svuint32_t data) + /// ST1B Zdata.S, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNarrowing(Vector mask, byte* address, Vector data) => StoreNarrowing(mask, address, data); /// - /// void svst1h[_u32](svbool_t pg, uint16_t *base, svuint32_t data) - /// ST1H Zdata.S, Pg, [Xbase, #0, MUL VL] + /// void svst1h[_u32](svbool_t pg, uint16_t *base, svuint32_t data) + /// ST1H Zdata.S, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNarrowing(Vector mask, ushort* address, Vector data) => StoreNarrowing(mask, address, data); /// - /// void svst1b[_u64](svbool_t pg, uint8_t *base, svuint64_t data) - /// ST1B Zdata.D, Pg, [Xbase, #0, MUL VL] + /// void svst1b[_u64](svbool_t pg, uint8_t *base, svuint64_t data) + /// ST1B Zdata.D, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNarrowing(Vector mask, byte* address, Vector data) => StoreNarrowing(mask, address, data); /// - /// void svst1h[_u64](svbool_t pg, uint16_t *base, svuint64_t data) - /// ST1H Zdata.D, Pg, [Xbase, #0, MUL VL] + /// void svst1h[_u64](svbool_t pg, uint16_t *base, svuint64_t data) + /// ST1H Zdata.D, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNarrowing(Vector mask, ushort* address, Vector data) => StoreNarrowing(mask, address, data); /// - /// void svst1w[_u64](svbool_t pg, uint32_t *base, svuint64_t data) - /// ST1W Zdata.D, Pg, [Xbase, #0, MUL VL] + /// void svst1w[_u64](svbool_t pg, uint32_t *base, svuint64_t data) + /// ST1W Zdata.D, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNarrowing(Vector mask, uint* address, Vector data) => StoreNarrowing(mask, address, data); @@ -8912,62 +9572,62 @@ internal Arm64() { } // Non-truncating store, non-temporal /// - /// void svstnt1[_u8](svbool_t pg, uint8_t *base, svuint8_t data) - /// STNT1B Zdata.B, Pg, [Xbase, #0, MUL VL] + /// void svstnt1[_u8](svbool_t pg, uint8_t *base, svuint8_t data) + /// STNT1B Zdata.B, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNonTemporal(Vector mask, byte* address, Vector data) => StoreNonTemporal(mask, address, data); /// - /// void svstnt1[_f64](svbool_t pg, float64_t *base, svfloat64_t data) - /// STNT1D Zdata.D, Pg, [Xbase, #0, MUL VL] + /// void svstnt1[_f64](svbool_t pg, float64_t *base, svfloat64_t data) + /// STNT1D Zdata.D, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNonTemporal(Vector mask, double* address, Vector data) => StoreNonTemporal(mask, address, data); /// - /// void svstnt1[_s16](svbool_t pg, int16_t *base, svint16_t data) - /// STNT1H Zdata.H, Pg, [Xbase, #0, MUL VL] + /// void svstnt1[_s16](svbool_t pg, int16_t *base, svint16_t data) + /// STNT1H Zdata.H, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNonTemporal(Vector mask, short* address, Vector data) => StoreNonTemporal(mask, address, data); /// - /// void svstnt1[_s32](svbool_t pg, int32_t *base, svint32_t data) - /// STNT1W Zdata.S, Pg, [Xbase, #0, MUL VL] + /// void svstnt1[_s32](svbool_t pg, int32_t *base, svint32_t data) + /// STNT1W Zdata.S, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNonTemporal(Vector mask, int* address, Vector data) => StoreNonTemporal(mask, address, data); /// - /// void svstnt1[_s64](svbool_t pg, int64_t *base, svint64_t data) - /// STNT1D Zdata.D, Pg, [Xbase, #0, MUL VL] + /// void svstnt1[_s64](svbool_t pg, int64_t *base, svint64_t data) + /// STNT1D Zdata.D, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNonTemporal(Vector mask, long* address, Vector data) => StoreNonTemporal(mask, address, data); /// - /// void svstnt1[_s8](svbool_t pg, int8_t *base, svint8_t data) - /// STNT1B Zdata.B, Pg, [Xbase, #0, MUL VL] + /// void svstnt1[_s8](svbool_t pg, int8_t *base, svint8_t data) + /// STNT1B Zdata.B, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNonTemporal(Vector mask, sbyte* address, Vector data) => StoreNonTemporal(mask, address, data); /// - /// void svstnt1[_f32](svbool_t pg, float32_t *base, svfloat32_t data) - /// STNT1W Zdata.S, Pg, [Xbase, #0, MUL VL] + /// void svstnt1[_f32](svbool_t pg, float32_t *base, svfloat32_t data) + /// STNT1W Zdata.S, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNonTemporal(Vector mask, float* address, Vector data) => StoreNonTemporal(mask, address, data); /// - /// void svstnt1[_u16](svbool_t pg, uint16_t *base, svuint16_t data) - /// STNT1H Zdata.H, Pg, [Xbase, #0, MUL VL] + /// void svstnt1[_u16](svbool_t pg, uint16_t *base, svuint16_t data) + /// STNT1H Zdata.H, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNonTemporal(Vector mask, ushort* address, Vector data) => StoreNonTemporal(mask, address, data); /// - /// void svstnt1[_u32](svbool_t pg, uint32_t *base, svuint32_t data) - /// STNT1W Zdata.S, Pg, [Xbase, #0, MUL VL] + /// void svstnt1[_u32](svbool_t pg, uint32_t *base, svuint32_t data) + /// STNT1W Zdata.S, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNonTemporal(Vector mask, uint* address, Vector data) => StoreNonTemporal(mask, address, data); /// - /// void svstnt1[_u64](svbool_t pg, uint64_t *base, svuint64_t data) - /// STNT1D Zdata.D, Pg, [Xbase, #0, MUL VL] + /// void svstnt1[_u64](svbool_t pg, uint64_t *base, svuint64_t data) + /// STNT1D Zdata.D, Pg, [Xbase, #0, MUL VL] /// public static unsafe void StoreNonTemporal(Vector mask, ulong* address, Vector data) => StoreNonTemporal(mask, address, data); @@ -8975,1005 +9635,991 @@ internal Arm64() { } // Subtract /// - /// svuint8_t svsub[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svsub[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t svsub[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// SUB Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// svuint8_t svsub[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svsub[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t svsub[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// SUB Ztied1.B, Pg/M, Ztied1.B, Zop2.B /// - public static unsafe Vector Subtract(Vector left, Vector right) => Subtract(left, right); + public static Vector Subtract(Vector left, Vector right) => Subtract(left, right); /// - /// svfloat64_t svsub[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svsub[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// svfloat64_t svsub[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) - /// FSUB Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svfloat64_t svsub[_f64]_m(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svsub[_f64]_x(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// svfloat64_t svsub[_f64]_z(svbool_t pg, svfloat64_t op1, svfloat64_t op2) + /// FSUB Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector Subtract(Vector left, Vector right) => Subtract(left, right); + public static Vector Subtract(Vector left, Vector right) => Subtract(left, right); /// - /// svint16_t svsub[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svsub[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t svsub[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) - /// SUB Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// svint16_t svsub[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svsub[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t svsub[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) + /// SUB Ztied1.H, Pg/M, Ztied1.H, Zop2.H /// - public static unsafe Vector Subtract(Vector left, Vector right) => Subtract(left, right); + public static Vector Subtract(Vector left, Vector right) => Subtract(left, right); /// - /// svint32_t svsub[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svsub[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t svsub[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) - /// SUB Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svint32_t svsub[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svsub[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t svsub[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) + /// SUB Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector Subtract(Vector left, Vector right) => Subtract(left, right); + public static Vector Subtract(Vector left, Vector right) => Subtract(left, right); /// - /// svint64_t svsub[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svsub[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t svsub[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) - /// SUB Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svint64_t svsub[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svsub[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t svsub[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) + /// SUB Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector Subtract(Vector left, Vector right) => Subtract(left, right); + public static Vector Subtract(Vector left, Vector right) => Subtract(left, right); /// - /// svint8_t svsub[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svsub[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t svsub[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) - /// SUB Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// svint8_t svsub[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svsub[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t svsub[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) + /// SUB Ztied1.B, Pg/M, Ztied1.B, Zop2.B /// - public static unsafe Vector Subtract(Vector left, Vector right) => Subtract(left, right); + public static Vector Subtract(Vector left, Vector right) => Subtract(left, right); /// - /// svfloat32_t svsub[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svsub[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// svfloat32_t svsub[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) - /// FSUB Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svfloat32_t svsub[_f32]_m(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svsub[_f32]_x(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// svfloat32_t svsub[_f32]_z(svbool_t pg, svfloat32_t op1, svfloat32_t op2) + /// FSUB Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector Subtract(Vector left, Vector right) => Subtract(left, right); + public static Vector Subtract(Vector left, Vector right) => Subtract(left, right); /// - /// svuint16_t svsub[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svsub[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t svsub[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// SUB Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// svuint16_t svsub[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svsub[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t svsub[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// SUB Ztied1.H, Pg/M, Ztied1.H, Zop2.H /// - public static unsafe Vector Subtract(Vector left, Vector right) => Subtract(left, right); + public static Vector Subtract(Vector left, Vector right) => Subtract(left, right); /// - /// svuint32_t svsub[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svsub[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t svsub[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// SUB Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svuint32_t svsub[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svsub[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t svsub[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// SUB Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector Subtract(Vector left, Vector right) => Subtract(left, right); + public static Vector Subtract(Vector left, Vector right) => Subtract(left, right); /// - /// svuint64_t svsub[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svsub[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t svsub[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// SUB Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svuint64_t svsub[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svsub[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t svsub[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// SUB Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector Subtract(Vector left, Vector right) => Subtract(left, right); + public static Vector Subtract(Vector left, Vector right) => Subtract(left, right); // Saturating subtract /// - /// svuint8_t svqsub[_u8](svuint8_t op1, svuint8_t op2) - /// UQSUB Zresult.B, Zop1.B, Zop2.B + /// svuint8_t svqsub[_u8](svuint8_t op1, svuint8_t op2) + /// UQSUB Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector SubtractSaturate(Vector left, Vector right) => SubtractSaturate(left, right); + public static Vector SubtractSaturate(Vector left, Vector right) => SubtractSaturate(left, right); /// - /// svint16_t svqsub[_s16](svint16_t op1, svint16_t op2) - /// SQSUB Zresult.H, Zop1.H, Zop2.H + /// svint16_t svqsub[_s16](svint16_t op1, svint16_t op2) + /// SQSUB Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector SubtractSaturate(Vector left, Vector right) => SubtractSaturate(left, right); + public static Vector SubtractSaturate(Vector left, Vector right) => SubtractSaturate(left, right); /// - /// svint32_t svqsub[_s32](svint32_t op1, svint32_t op2) - /// SQSUB Zresult.S, Zop1.S, Zop2.S + /// svint32_t svqsub[_s32](svint32_t op1, svint32_t op2) + /// SQSUB Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector SubtractSaturate(Vector left, Vector right) => SubtractSaturate(left, right); + public static Vector SubtractSaturate(Vector left, Vector right) => SubtractSaturate(left, right); /// - /// svint64_t svqsub[_s64](svint64_t op1, svint64_t op2) - /// SQSUB Zresult.D, Zop1.D, Zop2.D + /// svint64_t svqsub[_s64](svint64_t op1, svint64_t op2) + /// SQSUB Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector SubtractSaturate(Vector left, Vector right) => SubtractSaturate(left, right); + public static Vector SubtractSaturate(Vector left, Vector right) => SubtractSaturate(left, right); /// - /// svint8_t svqsub[_s8](svint8_t op1, svint8_t op2) - /// SQSUB Zresult.B, Zop1.B, Zop2.B + /// svint8_t svqsub[_s8](svint8_t op1, svint8_t op2) + /// SQSUB Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector SubtractSaturate(Vector left, Vector right) => SubtractSaturate(left, right); + public static Vector SubtractSaturate(Vector left, Vector right) => SubtractSaturate(left, right); /// - /// svuint16_t svqsub[_u16](svuint16_t op1, svuint16_t op2) - /// UQSUB Zresult.H, Zop1.H, Zop2.H + /// svuint16_t svqsub[_u16](svuint16_t op1, svuint16_t op2) + /// UQSUB Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector SubtractSaturate(Vector left, Vector right) => SubtractSaturate(left, right); + public static Vector SubtractSaturate(Vector left, Vector right) => SubtractSaturate(left, right); /// - /// svuint32_t svqsub[_u32](svuint32_t op1, svuint32_t op2) - /// UQSUB Zresult.S, Zop1.S, Zop2.S + /// svuint32_t svqsub[_u32](svuint32_t op1, svuint32_t op2) + /// UQSUB Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector SubtractSaturate(Vector left, Vector right) => SubtractSaturate(left, right); + public static Vector SubtractSaturate(Vector left, Vector right) => SubtractSaturate(left, right); /// - /// svuint64_t svqsub[_u64](svuint64_t op1, svuint64_t op2) - /// UQSUB Zresult.D, Zop1.D, Zop2.D + /// svuint64_t svqsub[_u64](svuint64_t op1, svuint64_t op2) + /// UQSUB Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector SubtractSaturate(Vector left, Vector right) => SubtractSaturate(left, right); + public static Vector SubtractSaturate(Vector left, Vector right) => SubtractSaturate(left, right); // Test whether any active element is true /// - /// bool svptest_any(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_any(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestAnyTrue(Vector mask, Vector srcMask) => TestAnyTrue(mask, srcMask); + public static bool TestAnyTrue(Vector mask, Vector srcMask) => TestAnyTrue(mask, srcMask); /// - /// bool svptest_any(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_any(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestAnyTrue(Vector mask, Vector srcMask) => TestAnyTrue(mask, srcMask); + public static bool TestAnyTrue(Vector mask, Vector srcMask) => TestAnyTrue(mask, srcMask); /// - /// bool svptest_any(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_any(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestAnyTrue(Vector mask, Vector srcMask) => TestAnyTrue(mask, srcMask); + public static bool TestAnyTrue(Vector mask, Vector srcMask) => TestAnyTrue(mask, srcMask); /// - /// bool svptest_any(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_any(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestAnyTrue(Vector mask, Vector srcMask) => TestAnyTrue(mask, srcMask); + public static bool TestAnyTrue(Vector mask, Vector srcMask) => TestAnyTrue(mask, srcMask); /// - /// bool svptest_any(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_any(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestAnyTrue(Vector mask, Vector srcMask) => TestAnyTrue(mask, srcMask); + public static bool TestAnyTrue(Vector mask, Vector srcMask) => TestAnyTrue(mask, srcMask); /// - /// bool svptest_any(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_any(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestAnyTrue(Vector mask, Vector srcMask) => TestAnyTrue(mask, srcMask); + public static bool TestAnyTrue(Vector mask, Vector srcMask) => TestAnyTrue(mask, srcMask); /// - /// bool svptest_any(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_any(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestAnyTrue(Vector mask, Vector srcMask) => TestAnyTrue(mask, srcMask); + public static bool TestAnyTrue(Vector mask, Vector srcMask) => TestAnyTrue(mask, srcMask); /// - /// bool svptest_any(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_any(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestAnyTrue(Vector mask, Vector srcMask) => TestAnyTrue(mask, srcMask); + public static bool TestAnyTrue(Vector mask, Vector srcMask) => TestAnyTrue(mask, srcMask); // Test whether the first active element is true /// - /// bool svptest_first(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_first(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestFirstTrue(Vector mask, Vector srcMask) => TestFirstTrue(mask, srcMask); + public static bool TestFirstTrue(Vector mask, Vector srcMask) => TestFirstTrue(mask, srcMask); /// - /// bool svptest_first(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_first(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestFirstTrue(Vector mask, Vector srcMask) => TestFirstTrue(mask, srcMask); + public static bool TestFirstTrue(Vector mask, Vector srcMask) => TestFirstTrue(mask, srcMask); /// - /// bool svptest_first(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_first(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestFirstTrue(Vector mask, Vector srcMask) => TestFirstTrue(mask, srcMask); + public static bool TestFirstTrue(Vector mask, Vector srcMask) => TestFirstTrue(mask, srcMask); /// - /// bool svptest_first(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_first(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestFirstTrue(Vector mask, Vector srcMask) => TestFirstTrue(mask, srcMask); + public static bool TestFirstTrue(Vector mask, Vector srcMask) => TestFirstTrue(mask, srcMask); /// - /// bool svptest_first(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_first(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestFirstTrue(Vector mask, Vector srcMask) => TestFirstTrue(mask, srcMask); + public static bool TestFirstTrue(Vector mask, Vector srcMask) => TestFirstTrue(mask, srcMask); /// - /// bool svptest_first(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_first(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestFirstTrue(Vector mask, Vector srcMask) => TestFirstTrue(mask, srcMask); + public static bool TestFirstTrue(Vector mask, Vector srcMask) => TestFirstTrue(mask, srcMask); /// - /// bool svptest_first(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_first(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestFirstTrue(Vector mask, Vector srcMask) => TestFirstTrue(mask, srcMask); + public static bool TestFirstTrue(Vector mask, Vector srcMask) => TestFirstTrue(mask, srcMask); /// - /// bool svptest_first(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_first(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestFirstTrue(Vector mask, Vector srcMask) => TestFirstTrue(mask, srcMask); + public static bool TestFirstTrue(Vector mask, Vector srcMask) => TestFirstTrue(mask, srcMask); // Test whether the last active element is true /// - /// bool svptest_last(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_last(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestLastTrue(Vector mask, Vector srcMask) => TestLastTrue(mask, srcMask); + public static bool TestLastTrue(Vector mask, Vector srcMask) => TestLastTrue(mask, srcMask); /// - /// bool svptest_last(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_last(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestLastTrue(Vector mask, Vector srcMask) => TestLastTrue(mask, srcMask); + public static bool TestLastTrue(Vector mask, Vector srcMask) => TestLastTrue(mask, srcMask); /// - /// bool svptest_last(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_last(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestLastTrue(Vector mask, Vector srcMask) => TestLastTrue(mask, srcMask); + public static bool TestLastTrue(Vector mask, Vector srcMask) => TestLastTrue(mask, srcMask); /// - /// bool svptest_last(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_last(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestLastTrue(Vector mask, Vector srcMask) => TestLastTrue(mask, srcMask); + public static bool TestLastTrue(Vector mask, Vector srcMask) => TestLastTrue(mask, srcMask); /// - /// bool svptest_last(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_last(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestLastTrue(Vector mask, Vector srcMask) => TestLastTrue(mask, srcMask); + public static bool TestLastTrue(Vector mask, Vector srcMask) => TestLastTrue(mask, srcMask); /// - /// bool svptest_last(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_last(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestLastTrue(Vector mask, Vector srcMask) => TestLastTrue(mask, srcMask); + public static bool TestLastTrue(Vector mask, Vector srcMask) => TestLastTrue(mask, srcMask); /// - /// bool svptest_last(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_last(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestLastTrue(Vector mask, Vector srcMask) => TestLastTrue(mask, srcMask); + public static bool TestLastTrue(Vector mask, Vector srcMask) => TestLastTrue(mask, srcMask); /// - /// bool svptest_last(svbool_t pg, svbool_t op) - /// PTEST + /// bool svptest_last(svbool_t pg, svbool_t op) + /// PTEST /// - public static unsafe bool TestLastTrue(Vector mask, Vector srcMask) => TestLastTrue(mask, srcMask); + public static bool TestLastTrue(Vector mask, Vector srcMask) => TestLastTrue(mask, srcMask); // Interleave even elements from two inputs /// - /// svuint8_t svtrn1[_u8](svuint8_t op1, svuint8_t op2) - /// TRN1 Zresult.B, Zop1.B, Zop2.B + /// svuint8_t svtrn1[_u8](svuint8_t op1, svuint8_t op2) + /// TRN1 Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector TransposeEven(Vector left, Vector right) => TransposeEven(left, right); + public static Vector TransposeEven(Vector left, Vector right) => TransposeEven(left, right); /// - /// svfloat64_t svtrn1[_f64](svfloat64_t op1, svfloat64_t op2) - /// TRN1 Zresult.D, Zop1.D, Zop2.D + /// svfloat64_t svtrn1[_f64](svfloat64_t op1, svfloat64_t op2) + /// TRN1 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector TransposeEven(Vector left, Vector right) => TransposeEven(left, right); + public static Vector TransposeEven(Vector left, Vector right) => TransposeEven(left, right); /// - /// svint16_t svtrn1[_s16](svint16_t op1, svint16_t op2) - /// TRN1 Zresult.H, Zop1.H, Zop2.H + /// svint16_t svtrn1[_s16](svint16_t op1, svint16_t op2) + /// TRN1 Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector TransposeEven(Vector left, Vector right) => TransposeEven(left, right); + public static Vector TransposeEven(Vector left, Vector right) => TransposeEven(left, right); /// - /// svint32_t svtrn1[_s32](svint32_t op1, svint32_t op2) - /// TRN1 Zresult.S, Zop1.S, Zop2.S + /// svint32_t svtrn1[_s32](svint32_t op1, svint32_t op2) + /// TRN1 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector TransposeEven(Vector left, Vector right) => TransposeEven(left, right); + public static Vector TransposeEven(Vector left, Vector right) => TransposeEven(left, right); /// - /// svint64_t svtrn1[_s64](svint64_t op1, svint64_t op2) - /// TRN1 Zresult.D, Zop1.D, Zop2.D + /// svint64_t svtrn1[_s64](svint64_t op1, svint64_t op2) + /// TRN1 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector TransposeEven(Vector left, Vector right) => TransposeEven(left, right); + public static Vector TransposeEven(Vector left, Vector right) => TransposeEven(left, right); /// - /// svint8_t svtrn1[_s8](svint8_t op1, svint8_t op2) - /// TRN1 Zresult.B, Zop1.B, Zop2.B + /// svint8_t svtrn1[_s8](svint8_t op1, svint8_t op2) + /// TRN1 Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector TransposeEven(Vector left, Vector right) => TransposeEven(left, right); + public static Vector TransposeEven(Vector left, Vector right) => TransposeEven(left, right); /// - /// svfloat32_t svtrn1[_f32](svfloat32_t op1, svfloat32_t op2) - /// TRN1 Zresult.S, Zop1.S, Zop2.S + /// svfloat32_t svtrn1[_f32](svfloat32_t op1, svfloat32_t op2) + /// TRN1 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector TransposeEven(Vector left, Vector right) => TransposeEven(left, right); + public static Vector TransposeEven(Vector left, Vector right) => TransposeEven(left, right); /// - /// svuint16_t svtrn1[_u16](svuint16_t op1, svuint16_t op2) - /// TRN1 Zresult.H, Zop1.H, Zop2.H + /// svuint16_t svtrn1[_u16](svuint16_t op1, svuint16_t op2) + /// TRN1 Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector TransposeEven(Vector left, Vector right) => TransposeEven(left, right); + public static Vector TransposeEven(Vector left, Vector right) => TransposeEven(left, right); /// - /// svuint32_t svtrn1[_u32](svuint32_t op1, svuint32_t op2) - /// TRN1 Zresult.S, Zop1.S, Zop2.S + /// svuint32_t svtrn1[_u32](svuint32_t op1, svuint32_t op2) + /// TRN1 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector TransposeEven(Vector left, Vector right) => TransposeEven(left, right); + public static Vector TransposeEven(Vector left, Vector right) => TransposeEven(left, right); /// - /// svuint64_t svtrn1[_u64](svuint64_t op1, svuint64_t op2) - /// TRN1 Zresult.D, Zop1.D, Zop2.D + /// svuint64_t svtrn1[_u64](svuint64_t op1, svuint64_t op2) + /// TRN1 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector TransposeEven(Vector left, Vector right) => TransposeEven(left, right); + public static Vector TransposeEven(Vector left, Vector right) => TransposeEven(left, right); // Interleave odd elements from two inputs /// - /// svuint8_t svtrn2[_u8](svuint8_t op1, svuint8_t op2) - /// TRN2 Zresult.B, Zop1.B, Zop2.B + /// svuint8_t svtrn2[_u8](svuint8_t op1, svuint8_t op2) + /// TRN2 Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector TransposeOdd(Vector left, Vector right) => TransposeOdd(left, right); + public static Vector TransposeOdd(Vector left, Vector right) => TransposeOdd(left, right); /// - /// svfloat64_t svtrn2[_f64](svfloat64_t op1, svfloat64_t op2) - /// TRN2 Zresult.D, Zop1.D, Zop2.D + /// svfloat64_t svtrn2[_f64](svfloat64_t op1, svfloat64_t op2) + /// TRN2 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector TransposeOdd(Vector left, Vector right) => TransposeOdd(left, right); + public static Vector TransposeOdd(Vector left, Vector right) => TransposeOdd(left, right); /// - /// svint16_t svtrn2[_s16](svint16_t op1, svint16_t op2) - /// TRN2 Zresult.H, Zop1.H, Zop2.H + /// svint16_t svtrn2[_s16](svint16_t op1, svint16_t op2) + /// TRN2 Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector TransposeOdd(Vector left, Vector right) => TransposeOdd(left, right); + public static Vector TransposeOdd(Vector left, Vector right) => TransposeOdd(left, right); /// - /// svint32_t svtrn2[_s32](svint32_t op1, svint32_t op2) - /// TRN2 Zresult.S, Zop1.S, Zop2.S + /// svint32_t svtrn2[_s32](svint32_t op1, svint32_t op2) + /// TRN2 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector TransposeOdd(Vector left, Vector right) => TransposeOdd(left, right); + public static Vector TransposeOdd(Vector left, Vector right) => TransposeOdd(left, right); /// - /// svint64_t svtrn2[_s64](svint64_t op1, svint64_t op2) - /// TRN2 Zresult.D, Zop1.D, Zop2.D + /// svint64_t svtrn2[_s64](svint64_t op1, svint64_t op2) + /// TRN2 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector TransposeOdd(Vector left, Vector right) => TransposeOdd(left, right); + public static Vector TransposeOdd(Vector left, Vector right) => TransposeOdd(left, right); /// - /// svint8_t svtrn2[_s8](svint8_t op1, svint8_t op2) - /// TRN2 Zresult.B, Zop1.B, Zop2.B + /// svint8_t svtrn2[_s8](svint8_t op1, svint8_t op2) + /// TRN2 Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector TransposeOdd(Vector left, Vector right) => TransposeOdd(left, right); + public static Vector TransposeOdd(Vector left, Vector right) => TransposeOdd(left, right); /// - /// svfloat32_t svtrn2[_f32](svfloat32_t op1, svfloat32_t op2) - /// TRN2 Zresult.S, Zop1.S, Zop2.S + /// svfloat32_t svtrn2[_f32](svfloat32_t op1, svfloat32_t op2) + /// TRN2 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector TransposeOdd(Vector left, Vector right) => TransposeOdd(left, right); + public static Vector TransposeOdd(Vector left, Vector right) => TransposeOdd(left, right); /// - /// svuint16_t svtrn2[_u16](svuint16_t op1, svuint16_t op2) - /// TRN2 Zresult.H, Zop1.H, Zop2.H + /// svuint16_t svtrn2[_u16](svuint16_t op1, svuint16_t op2) + /// TRN2 Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector TransposeOdd(Vector left, Vector right) => TransposeOdd(left, right); + public static Vector TransposeOdd(Vector left, Vector right) => TransposeOdd(left, right); /// - /// svuint32_t svtrn2[_u32](svuint32_t op1, svuint32_t op2) - /// TRN2 Zresult.S, Zop1.S, Zop2.S + /// svuint32_t svtrn2[_u32](svuint32_t op1, svuint32_t op2) + /// TRN2 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector TransposeOdd(Vector left, Vector right) => TransposeOdd(left, right); + public static Vector TransposeOdd(Vector left, Vector right) => TransposeOdd(left, right); /// - /// svuint64_t svtrn2[_u64](svuint64_t op1, svuint64_t op2) - /// TRN2 Zresult.D, Zop1.D, Zop2.D + /// svuint64_t svtrn2[_u64](svuint64_t op1, svuint64_t op2) + /// TRN2 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector TransposeOdd(Vector left, Vector right) => TransposeOdd(left, right); + public static Vector TransposeOdd(Vector left, Vector right) => TransposeOdd(left, right); // Trigonometric multiply-add coefficient /// - /// svfloat64_t svtmad[_f64](svfloat64_t op1, svfloat64_t op2, uint64_t imm3) - /// FTMAD Ztied1.D, Ztied1.D, Zop2.D, #imm3 + /// svfloat64_t svtmad[_f64](svfloat64_t op1, svfloat64_t op2, uint64_t imm3) + /// FTMAD Ztied1.D, Ztied1.D, Zop2.D, #imm3 /// - public static unsafe Vector TrigonometricMultiplyAddCoefficient(Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(7))] byte control) => TrigonometricMultiplyAddCoefficient(left, right, control); + public static Vector TrigonometricMultiplyAddCoefficient(Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(7))] byte control) => TrigonometricMultiplyAddCoefficient(left, right, control); /// - /// svfloat32_t svtmad[_f32](svfloat32_t op1, svfloat32_t op2, uint64_t imm3) - /// FTMAD Ztied1.S, Ztied1.S, Zop2.S, #imm3 + /// svfloat32_t svtmad[_f32](svfloat32_t op1, svfloat32_t op2, uint64_t imm3) + /// FTMAD Ztied1.S, Ztied1.S, Zop2.S, #imm3 /// - public static unsafe Vector TrigonometricMultiplyAddCoefficient(Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(7))] byte control) => TrigonometricMultiplyAddCoefficient(left, right, control); + public static Vector TrigonometricMultiplyAddCoefficient(Vector left, Vector right, [ConstantExpected(Min = 0, Max = (byte)(7))] byte control) => TrigonometricMultiplyAddCoefficient(left, right, control); // Trigonometric select coefficient /// - /// svfloat64_t svtssel[_f64](svfloat64_t op1, svuint64_t op2) - /// FTSSEL Zresult.D, Zop1.D, Zop2.D + /// svfloat64_t svtssel[_f64](svfloat64_t op1, svuint64_t op2) + /// FTSSEL Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector TrigonometricSelectCoefficient(Vector value, Vector selector) => TrigonometricSelectCoefficient(value, selector); + public static Vector TrigonometricSelectCoefficient(Vector value, Vector selector) => TrigonometricSelectCoefficient(value, selector); /// - /// svfloat32_t svtssel[_f32](svfloat32_t op1, svuint32_t op2) - /// FTSSEL Zresult.S, Zop1.S, Zop2.S + /// svfloat32_t svtssel[_f32](svfloat32_t op1, svuint32_t op2) + /// FTSSEL Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector TrigonometricSelectCoefficient(Vector value, Vector selector) => TrigonometricSelectCoefficient(value, selector); + public static Vector TrigonometricSelectCoefficient(Vector value, Vector selector) => TrigonometricSelectCoefficient(value, selector); // Trigonometric starting value /// - /// svfloat64_t svtsmul[_f64](svfloat64_t op1, svuint64_t op2) - /// FTSMUL Zresult.D, Zop1.D, Zop2.D + /// svfloat64_t svtsmul[_f64](svfloat64_t op1, svuint64_t op2) + /// FTSMUL Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector TrigonometricStartingValue(Vector value, Vector sign) => TrigonometricStartingValue(value, sign); + public static Vector TrigonometricStartingValue(Vector value, Vector sign) => TrigonometricStartingValue(value, sign); /// - /// svfloat32_t svtsmul[_f32](svfloat32_t op1, svuint32_t op2) - /// FTSMUL Zresult.S, Zop1.S, Zop2.S + /// svfloat32_t svtsmul[_f32](svfloat32_t op1, svuint32_t op2) + /// FTSMUL Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector TrigonometricStartingValue(Vector value, Vector sign) => TrigonometricStartingValue(value, sign); + public static Vector TrigonometricStartingValue(Vector value, Vector sign) => TrigonometricStartingValue(value, sign); // Concatenate even elements from two inputs /// - /// svuint8_t svuzp1[_u8](svuint8_t op1, svuint8_t op2) - /// UZP1 Zresult.B, Zop1.B, Zop2.B + /// svuint8_t svuzp1[_u8](svuint8_t op1, svuint8_t op2) + /// UZP1 Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector UnzipEven(Vector left, Vector right) => UnzipEven(left, right); + public static Vector UnzipEven(Vector left, Vector right) => UnzipEven(left, right); /// - /// svfloat64_t svuzp1[_f64](svfloat64_t op1, svfloat64_t op2) - /// UZP1 Zresult.D, Zop1.D, Zop2.D + /// svfloat64_t svuzp1[_f64](svfloat64_t op1, svfloat64_t op2) + /// UZP1 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector UnzipEven(Vector left, Vector right) => UnzipEven(left, right); + public static Vector UnzipEven(Vector left, Vector right) => UnzipEven(left, right); /// - /// svint16_t svuzp1[_s16](svint16_t op1, svint16_t op2) - /// UZP1 Zresult.H, Zop1.H, Zop2.H + /// svint16_t svuzp1[_s16](svint16_t op1, svint16_t op2) + /// UZP1 Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector UnzipEven(Vector left, Vector right) => UnzipEven(left, right); + public static Vector UnzipEven(Vector left, Vector right) => UnzipEven(left, right); /// - /// svint32_t svuzp1[_s32](svint32_t op1, svint32_t op2) - /// UZP1 Zresult.S, Zop1.S, Zop2.S + /// svint32_t svuzp1[_s32](svint32_t op1, svint32_t op2) + /// UZP1 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector UnzipEven(Vector left, Vector right) => UnzipEven(left, right); + public static Vector UnzipEven(Vector left, Vector right) => UnzipEven(left, right); /// - /// svint64_t svuzp1[_s64](svint64_t op1, svint64_t op2) - /// UZP1 Zresult.D, Zop1.D, Zop2.D + /// svint64_t svuzp1[_s64](svint64_t op1, svint64_t op2) + /// UZP1 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector UnzipEven(Vector left, Vector right) => UnzipEven(left, right); + public static Vector UnzipEven(Vector left, Vector right) => UnzipEven(left, right); /// - /// svint8_t svuzp1[_s8](svint8_t op1, svint8_t op2) - /// UZP1 Zresult.B, Zop1.B, Zop2.B + /// svint8_t svuzp1[_s8](svint8_t op1, svint8_t op2) + /// UZP1 Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector UnzipEven(Vector left, Vector right) => UnzipEven(left, right); + public static Vector UnzipEven(Vector left, Vector right) => UnzipEven(left, right); /// - /// svfloat32_t svuzp1[_f32](svfloat32_t op1, svfloat32_t op2) - /// UZP1 Zresult.S, Zop1.S, Zop2.S + /// svfloat32_t svuzp1[_f32](svfloat32_t op1, svfloat32_t op2) + /// UZP1 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector UnzipEven(Vector left, Vector right) => UnzipEven(left, right); + public static Vector UnzipEven(Vector left, Vector right) => UnzipEven(left, right); /// - /// svuint16_t svuzp1[_u16](svuint16_t op1, svuint16_t op2) - /// UZP1 Zresult.H, Zop1.H, Zop2.H + /// svuint16_t svuzp1[_u16](svuint16_t op1, svuint16_t op2) + /// UZP1 Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector UnzipEven(Vector left, Vector right) => UnzipEven(left, right); + public static Vector UnzipEven(Vector left, Vector right) => UnzipEven(left, right); /// - /// svuint32_t svuzp1[_u32](svuint32_t op1, svuint32_t op2) - /// UZP1 Zresult.S, Zop1.S, Zop2.S + /// svuint32_t svuzp1[_u32](svuint32_t op1, svuint32_t op2) + /// UZP1 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector UnzipEven(Vector left, Vector right) => UnzipEven(left, right); + public static Vector UnzipEven(Vector left, Vector right) => UnzipEven(left, right); /// - /// svuint64_t svuzp1[_u64](svuint64_t op1, svuint64_t op2) - /// UZP1 Zresult.D, Zop1.D, Zop2.D + /// svuint64_t svuzp1[_u64](svuint64_t op1, svuint64_t op2) + /// UZP1 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector UnzipEven(Vector left, Vector right) => UnzipEven(left, right); + public static Vector UnzipEven(Vector left, Vector right) => UnzipEven(left, right); // Concatenate odd elements from two inputs /// - /// svuint8_t svuzp2[_u8](svuint8_t op1, svuint8_t op2) - /// UZP2 Zresult.B, Zop1.B, Zop2.B + /// svuint8_t svuzp2[_u8](svuint8_t op1, svuint8_t op2) + /// UZP2 Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector UnzipOdd(Vector left, Vector right) => UnzipOdd(left, right); + public static Vector UnzipOdd(Vector left, Vector right) => UnzipOdd(left, right); /// - /// svfloat64_t svuzp2[_f64](svfloat64_t op1, svfloat64_t op2) - /// UZP2 Zresult.D, Zop1.D, Zop2.D + /// svfloat64_t svuzp2[_f64](svfloat64_t op1, svfloat64_t op2) + /// UZP2 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector UnzipOdd(Vector left, Vector right) => UnzipOdd(left, right); + public static Vector UnzipOdd(Vector left, Vector right) => UnzipOdd(left, right); /// - /// svint16_t svuzp2[_s16](svint16_t op1, svint16_t op2) - /// UZP2 Zresult.H, Zop1.H, Zop2.H + /// svint16_t svuzp2[_s16](svint16_t op1, svint16_t op2) + /// UZP2 Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector UnzipOdd(Vector left, Vector right) => UnzipOdd(left, right); + public static Vector UnzipOdd(Vector left, Vector right) => UnzipOdd(left, right); /// - /// svint32_t svuzp2[_s32](svint32_t op1, svint32_t op2) - /// UZP2 Zresult.S, Zop1.S, Zop2.S + /// svint32_t svuzp2[_s32](svint32_t op1, svint32_t op2) + /// UZP2 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector UnzipOdd(Vector left, Vector right) => UnzipOdd(left, right); + public static Vector UnzipOdd(Vector left, Vector right) => UnzipOdd(left, right); /// - /// svint64_t svuzp2[_s64](svint64_t op1, svint64_t op2) - /// UZP2 Zresult.D, Zop1.D, Zop2.D + /// svint64_t svuzp2[_s64](svint64_t op1, svint64_t op2) + /// UZP2 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector UnzipOdd(Vector left, Vector right) => UnzipOdd(left, right); + public static Vector UnzipOdd(Vector left, Vector right) => UnzipOdd(left, right); /// - /// svint8_t svuzp2[_s8](svint8_t op1, svint8_t op2) - /// UZP2 Zresult.B, Zop1.B, Zop2.B + /// svint8_t svuzp2[_s8](svint8_t op1, svint8_t op2) + /// UZP2 Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector UnzipOdd(Vector left, Vector right) => UnzipOdd(left, right); + public static Vector UnzipOdd(Vector left, Vector right) => UnzipOdd(left, right); /// - /// svfloat32_t svuzp2[_f32](svfloat32_t op1, svfloat32_t op2) - /// UZP2 Zresult.S, Zop1.S, Zop2.S + /// svfloat32_t svuzp2[_f32](svfloat32_t op1, svfloat32_t op2) + /// UZP2 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector UnzipOdd(Vector left, Vector right) => UnzipOdd(left, right); + public static Vector UnzipOdd(Vector left, Vector right) => UnzipOdd(left, right); /// - /// svuint16_t svuzp2[_u16](svuint16_t op1, svuint16_t op2) - /// UZP2 Zresult.H, Zop1.H, Zop2.H + /// svuint16_t svuzp2[_u16](svuint16_t op1, svuint16_t op2) + /// UZP2 Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector UnzipOdd(Vector left, Vector right) => UnzipOdd(left, right); + public static Vector UnzipOdd(Vector left, Vector right) => UnzipOdd(left, right); /// - /// svuint32_t svuzp2[_u32](svuint32_t op1, svuint32_t op2) - /// UZP2 Zresult.S, Zop1.S, Zop2.S + /// svuint32_t svuzp2[_u32](svuint32_t op1, svuint32_t op2) + /// UZP2 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector UnzipOdd(Vector left, Vector right) => UnzipOdd(left, right); + public static Vector UnzipOdd(Vector left, Vector right) => UnzipOdd(left, right); /// - /// svuint64_t svuzp2[_u64](svuint64_t op1, svuint64_t op2) - /// UZP2 Zresult.D, Zop1.D, Zop2.D + /// svuint64_t svuzp2[_u64](svuint64_t op1, svuint64_t op2) + /// UZP2 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector UnzipOdd(Vector left, Vector right) => UnzipOdd(left, right); + public static Vector UnzipOdd(Vector left, Vector right) => UnzipOdd(left, right); // Table lookup in single-vector table /// - /// svuint8_t svtbl[_u8](svuint8_t data, svuint8_t indices) - /// TBL Zresult.B, {Zdata.B}, Zindices.B + /// svuint8_t svtbl[_u8](svuint8_t data, svuint8_t indices) + /// TBL Zresult.B, {Zdata.B}, Zindices.B /// - public static unsafe Vector VectorTableLookup(Vector data, Vector indices) => VectorTableLookup(data, indices); + public static Vector VectorTableLookup(Vector data, Vector indices) => VectorTableLookup(data, indices); /// - /// svfloat64_t svtbl[_f64](svfloat64_t data, svuint64_t indices) - /// TBL Zresult.D, {Zdata.D}, Zindices.D + /// svfloat64_t svtbl[_f64](svfloat64_t data, svuint64_t indices) + /// TBL Zresult.D, {Zdata.D}, Zindices.D /// - public static unsafe Vector VectorTableLookup(Vector data, Vector indices) => VectorTableLookup(data, indices); + public static Vector VectorTableLookup(Vector data, Vector indices) => VectorTableLookup(data, indices); /// - /// svint16_t svtbl[_s16](svint16_t data, svuint16_t indices) - /// TBL Zresult.H, {Zdata.H}, Zindices.H + /// svint16_t svtbl[_s16](svint16_t data, svuint16_t indices) + /// TBL Zresult.H, {Zdata.H}, Zindices.H /// - public static unsafe Vector VectorTableLookup(Vector data, Vector indices) => VectorTableLookup(data, indices); + public static Vector VectorTableLookup(Vector data, Vector indices) => VectorTableLookup(data, indices); /// - /// svint32_t svtbl[_s32](svint32_t data, svuint32_t indices) - /// TBL Zresult.S, {Zdata.S}, Zindices.S + /// svint32_t svtbl[_s32](svint32_t data, svuint32_t indices) + /// TBL Zresult.S, {Zdata.S}, Zindices.S /// - public static unsafe Vector VectorTableLookup(Vector data, Vector indices) => VectorTableLookup(data, indices); + public static Vector VectorTableLookup(Vector data, Vector indices) => VectorTableLookup(data, indices); /// - /// svint64_t svtbl[_s64](svint64_t data, svuint64_t indices) - /// TBL Zresult.D, {Zdata.D}, Zindices.D + /// svint64_t svtbl[_s64](svint64_t data, svuint64_t indices) + /// TBL Zresult.D, {Zdata.D}, Zindices.D /// - public static unsafe Vector VectorTableLookup(Vector data, Vector indices) => VectorTableLookup(data, indices); + public static Vector VectorTableLookup(Vector data, Vector indices) => VectorTableLookup(data, indices); /// - /// svint8_t svtbl[_s8](svint8_t data, svuint8_t indices) - /// TBL Zresult.B, {Zdata.B}, Zindices.B + /// svint8_t svtbl[_s8](svint8_t data, svuint8_t indices) + /// TBL Zresult.B, {Zdata.B}, Zindices.B /// - public static unsafe Vector VectorTableLookup(Vector data, Vector indices) => VectorTableLookup(data, indices); + public static Vector VectorTableLookup(Vector data, Vector indices) => VectorTableLookup(data, indices); /// - /// svfloat32_t svtbl[_f32](svfloat32_t data, svuint32_t indices) - /// TBL Zresult.S, {Zdata.S}, Zindices.S + /// svfloat32_t svtbl[_f32](svfloat32_t data, svuint32_t indices) + /// TBL Zresult.S, {Zdata.S}, Zindices.S /// - public static unsafe Vector VectorTableLookup(Vector data, Vector indices) => VectorTableLookup(data, indices); + public static Vector VectorTableLookup(Vector data, Vector indices) => VectorTableLookup(data, indices); /// - /// svuint16_t svtbl[_u16](svuint16_t data, svuint16_t indices) - /// TBL Zresult.H, {Zdata.H}, Zindices.H + /// svuint16_t svtbl[_u16](svuint16_t data, svuint16_t indices) + /// TBL Zresult.H, {Zdata.H}, Zindices.H /// - public static unsafe Vector VectorTableLookup(Vector data, Vector indices) => VectorTableLookup(data, indices); + public static Vector VectorTableLookup(Vector data, Vector indices) => VectorTableLookup(data, indices); /// - /// svuint32_t svtbl[_u32](svuint32_t data, svuint32_t indices) - /// TBL Zresult.S, {Zdata.S}, Zindices.S + /// svuint32_t svtbl[_u32](svuint32_t data, svuint32_t indices) + /// TBL Zresult.S, {Zdata.S}, Zindices.S /// - public static unsafe Vector VectorTableLookup(Vector data, Vector indices) => VectorTableLookup(data, indices); + public static Vector VectorTableLookup(Vector data, Vector indices) => VectorTableLookup(data, indices); /// - /// svuint64_t svtbl[_u64](svuint64_t data, svuint64_t indices) - /// TBL Zresult.D, {Zdata.D}, Zindices.D + /// svuint64_t svtbl[_u64](svuint64_t data, svuint64_t indices) + /// TBL Zresult.D, {Zdata.D}, Zindices.D /// - public static unsafe Vector VectorTableLookup(Vector data, Vector indices) => VectorTableLookup(data, indices); + public static Vector VectorTableLookup(Vector data, Vector indices) => VectorTableLookup(data, indices); // Bitwise exclusive OR /// - /// svuint8_t sveor[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t sveor[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// svuint8_t sveor[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) - /// EOR Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// svuint8_t sveor[_u8]_m(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t sveor[_u8]_x(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// svuint8_t sveor[_u8]_z(svbool_t pg, svuint8_t op1, svuint8_t op2) + /// EOR Ztied1.B, Pg/M, Ztied1.B, Zop2.B /// - public static unsafe Vector Xor(Vector left, Vector right) => Xor(left, right); + public static Vector Xor(Vector left, Vector right) => Xor(left, right); /// - /// svint16_t sveor[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t sveor[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) - /// svint16_t sveor[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) - /// EOR Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// svint16_t sveor[_s16]_m(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t sveor[_s16]_x(svbool_t pg, svint16_t op1, svint16_t op2) + /// svint16_t sveor[_s16]_z(svbool_t pg, svint16_t op1, svint16_t op2) + /// EOR Ztied1.H, Pg/M, Ztied1.H, Zop2.H /// - public static unsafe Vector Xor(Vector left, Vector right) => Xor(left, right); + public static Vector Xor(Vector left, Vector right) => Xor(left, right); /// - /// svint32_t sveor[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t sveor[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) - /// svint32_t sveor[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) - /// EOR Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svint32_t sveor[_s32]_m(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t sveor[_s32]_x(svbool_t pg, svint32_t op1, svint32_t op2) + /// svint32_t sveor[_s32]_z(svbool_t pg, svint32_t op1, svint32_t op2) + /// EOR Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector Xor(Vector left, Vector right) => Xor(left, right); + public static Vector Xor(Vector left, Vector right) => Xor(left, right); /// - /// svint64_t sveor[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t sveor[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) - /// svint64_t sveor[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) - /// EOR Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svint64_t sveor[_s64]_m(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t sveor[_s64]_x(svbool_t pg, svint64_t op1, svint64_t op2) + /// svint64_t sveor[_s64]_z(svbool_t pg, svint64_t op1, svint64_t op2) + /// EOR Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector Xor(Vector left, Vector right) => Xor(left, right); + public static Vector Xor(Vector left, Vector right) => Xor(left, right); /// - /// svint8_t sveor[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t sveor[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) - /// svint8_t sveor[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) - /// EOR Ztied1.B, Pg/M, Ztied1.B, Zop2.B + /// svint8_t sveor[_s8]_m(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t sveor[_s8]_x(svbool_t pg, svint8_t op1, svint8_t op2) + /// svint8_t sveor[_s8]_z(svbool_t pg, svint8_t op1, svint8_t op2) + /// EOR Ztied1.B, Pg/M, Ztied1.B, Zop2.B /// - public static unsafe Vector Xor(Vector left, Vector right) => Xor(left, right); + public static Vector Xor(Vector left, Vector right) => Xor(left, right); /// - /// svuint16_t sveor[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t sveor[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// svuint16_t sveor[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) - /// EOR Ztied1.H, Pg/M, Ztied1.H, Zop2.H + /// svuint16_t sveor[_u16]_m(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t sveor[_u16]_x(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// svuint16_t sveor[_u16]_z(svbool_t pg, svuint16_t op1, svuint16_t op2) + /// EOR Ztied1.H, Pg/M, Ztied1.H, Zop2.H /// - public static unsafe Vector Xor(Vector left, Vector right) => Xor(left, right); + public static Vector Xor(Vector left, Vector right) => Xor(left, right); /// - /// svuint32_t sveor[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t sveor[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// svuint32_t sveor[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) - /// EOR Ztied1.S, Pg/M, Ztied1.S, Zop2.S + /// svuint32_t sveor[_u32]_m(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t sveor[_u32]_x(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// svuint32_t sveor[_u32]_z(svbool_t pg, svuint32_t op1, svuint32_t op2) + /// EOR Ztied1.S, Pg/M, Ztied1.S, Zop2.S /// - public static unsafe Vector Xor(Vector left, Vector right) => Xor(left, right); + public static Vector Xor(Vector left, Vector right) => Xor(left, right); /// - /// svuint64_t sveor[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t sveor[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// svuint64_t sveor[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) - /// EOR Ztied1.D, Pg/M, Ztied1.D, Zop2.D + /// svuint64_t sveor[_u64]_m(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t sveor[_u64]_x(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// svuint64_t sveor[_u64]_z(svbool_t pg, svuint64_t op1, svuint64_t op2) + /// EOR Ztied1.D, Pg/M, Ztied1.D, Zop2.D /// - public static unsafe Vector Xor(Vector left, Vector right) => Xor(left, right); + public static Vector Xor(Vector left, Vector right) => Xor(left, right); // Bitwise exclusive OR reduction to scalar /// - /// uint8_t sveorv[_u8](svbool_t pg, svuint8_t op) - /// EORV Bresult, Pg, Zop.B + /// uint8_t sveorv[_u8](svbool_t pg, svuint8_t op) + /// EORV Bresult, Pg, Zop.B /// - public static unsafe Vector XorAcross(Vector value) => XorAcross(value); + public static Vector XorAcross(Vector value) => XorAcross(value); /// - /// int16_t sveorv[_s16](svbool_t pg, svint16_t op) - /// EORV Hresult, Pg, Zop.H + /// int16_t sveorv[_s16](svbool_t pg, svint16_t op) + /// EORV Hresult, Pg, Zop.H /// - public static unsafe Vector XorAcross(Vector value) => XorAcross(value); + public static Vector XorAcross(Vector value) => XorAcross(value); /// - /// int32_t sveorv[_s32](svbool_t pg, svint32_t op) - /// EORV Sresult, Pg, Zop.S + /// int32_t sveorv[_s32](svbool_t pg, svint32_t op) + /// EORV Sresult, Pg, Zop.S /// - public static unsafe Vector XorAcross(Vector value) => XorAcross(value); + public static Vector XorAcross(Vector value) => XorAcross(value); /// - /// int64_t sveorv[_s64](svbool_t pg, svint64_t op) - /// EORV Dresult, Pg, Zop.D + /// int64_t sveorv[_s64](svbool_t pg, svint64_t op) + /// EORV Dresult, Pg, Zop.D /// - public static unsafe Vector XorAcross(Vector value) => XorAcross(value); + public static Vector XorAcross(Vector value) => XorAcross(value); /// - /// int8_t sveorv[_s8](svbool_t pg, svint8_t op) - /// EORV Bresult, Pg, Zop.B + /// int8_t sveorv[_s8](svbool_t pg, svint8_t op) + /// EORV Bresult, Pg, Zop.B /// - public static unsafe Vector XorAcross(Vector value) => XorAcross(value); + public static Vector XorAcross(Vector value) => XorAcross(value); /// - /// uint16_t sveorv[_u16](svbool_t pg, svuint16_t op) - /// EORV Hresult, Pg, Zop.H + /// uint16_t sveorv[_u16](svbool_t pg, svuint16_t op) + /// EORV Hresult, Pg, Zop.H /// - public static unsafe Vector XorAcross(Vector value) => XorAcross(value); + public static Vector XorAcross(Vector value) => XorAcross(value); /// - /// uint32_t sveorv[_u32](svbool_t pg, svuint32_t op) - /// EORV Sresult, Pg, Zop.S + /// uint32_t sveorv[_u32](svbool_t pg, svuint32_t op) + /// EORV Sresult, Pg, Zop.S /// - public static unsafe Vector XorAcross(Vector value) => XorAcross(value); + public static Vector XorAcross(Vector value) => XorAcross(value); /// - /// uint64_t sveorv[_u64](svbool_t pg, svuint64_t op) - /// EORV Dresult, Pg, Zop.D + /// uint64_t sveorv[_u64](svbool_t pg, svuint64_t op) + /// EORV Dresult, Pg, Zop.D /// - public static unsafe Vector XorAcross(Vector value) => XorAcross(value); + public static Vector XorAcross(Vector value) => XorAcross(value); // Zero-extend the low 16 bits /// - /// svuint32_t svexth[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) - /// svuint32_t svexth[_u32]_x(svbool_t pg, svuint32_t op) - /// svuint32_t svexth[_u32]_z(svbool_t pg, svuint32_t op) - /// UXTH Zresult.S, Pg/M, Zop.S + /// svuint32_t svexth[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) + /// svuint32_t svexth[_u32]_x(svbool_t pg, svuint32_t op) + /// svuint32_t svexth[_u32]_z(svbool_t pg, svuint32_t op) + /// UXTH Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ZeroExtend16(Vector value) => ZeroExtend16(value); + public static Vector ZeroExtend16(Vector value) => ZeroExtend16(value); /// - /// svuint64_t svexth[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) - /// svuint64_t svexth[_u64]_x(svbool_t pg, svuint64_t op) - /// svuint64_t svexth[_u64]_z(svbool_t pg, svuint64_t op) - /// UXTH Zresult.D, Pg/M, Zop.D + /// svuint64_t svexth[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) + /// svuint64_t svexth[_u64]_x(svbool_t pg, svuint64_t op) + /// svuint64_t svexth[_u64]_z(svbool_t pg, svuint64_t op) + /// UXTH Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ZeroExtend16(Vector value) => ZeroExtend16(value); + public static Vector ZeroExtend16(Vector value) => ZeroExtend16(value); // Zero-extend the low 32 bits /// - /// svuint64_t svextw[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) - /// svuint64_t svextw[_u64]_x(svbool_t pg, svuint64_t op) - /// svuint64_t svextw[_u64]_z(svbool_t pg, svuint64_t op) - /// UXTW Zresult.D, Pg/M, Zop.D + /// svuint64_t svextw[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) + /// svuint64_t svextw[_u64]_x(svbool_t pg, svuint64_t op) + /// svuint64_t svextw[_u64]_z(svbool_t pg, svuint64_t op) + /// UXTW Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ZeroExtend32(Vector value) => ZeroExtend32(value); + public static Vector ZeroExtend32(Vector value) => ZeroExtend32(value); // Zero-extend the low 8 bits /// - /// svuint16_t svextb[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) - /// svuint16_t svextb[_u16]_x(svbool_t pg, svuint16_t op) - /// svuint16_t svextb[_u16]_z(svbool_t pg, svuint16_t op) - /// UXTB Zresult.H, Pg/M, Zop.H + /// svuint16_t svextb[_u16]_m(svuint16_t inactive, svbool_t pg, svuint16_t op) + /// svuint16_t svextb[_u16]_x(svbool_t pg, svuint16_t op) + /// svuint16_t svextb[_u16]_z(svbool_t pg, svuint16_t op) + /// UXTB Zresult.H, Pg/M, Zop.H /// - public static unsafe Vector ZeroExtend8(Vector value) => ZeroExtend8(value); + public static Vector ZeroExtend8(Vector value) => ZeroExtend8(value); /// - /// svuint32_t svextb[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) - /// svuint32_t svextb[_u32]_x(svbool_t pg, svuint32_t op) - /// svuint32_t svextb[_u32]_z(svbool_t pg, svuint32_t op) - /// UXTB Zresult.S, Pg/M, Zop.S + /// svuint32_t svextb[_u32]_m(svuint32_t inactive, svbool_t pg, svuint32_t op) + /// svuint32_t svextb[_u32]_x(svbool_t pg, svuint32_t op) + /// svuint32_t svextb[_u32]_z(svbool_t pg, svuint32_t op) + /// UXTB Zresult.S, Pg/M, Zop.S /// - public static unsafe Vector ZeroExtend8(Vector value) => ZeroExtend8(value); + public static Vector ZeroExtend8(Vector value) => ZeroExtend8(value); /// - /// svuint64_t svextb[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) - /// svuint64_t svextb[_u64]_x(svbool_t pg, svuint64_t op) - /// svuint64_t svextb[_u64]_z(svbool_t pg, svuint64_t op) - /// UXTB Zresult.D, Pg/M, Zop.D + /// svuint64_t svextb[_u64]_m(svuint64_t inactive, svbool_t pg, svuint64_t op) + /// svuint64_t svextb[_u64]_x(svbool_t pg, svuint64_t op) + /// svuint64_t svextb[_u64]_z(svbool_t pg, svuint64_t op) + /// UXTB Zresult.D, Pg/M, Zop.D /// - public static unsafe Vector ZeroExtend8(Vector value) => ZeroExtend8(value); + public static Vector ZeroExtend8(Vector value) => ZeroExtend8(value); // Unpack and extend low half /// - /// svuint16_t svunpklo[_u16](svuint8_t op) - /// UUNPKLO Zresult.H, Zop.B + /// svuint16_t svunpklo[_u16](svuint8_t op) + /// UUNPKLO Zresult.H, Zop.B /// - public static unsafe Vector ZeroExtendWideningLower(Vector value) => ZeroExtendWideningLower(value); + public static Vector ZeroExtendWideningLower(Vector value) => ZeroExtendWideningLower(value); /// - /// svuint32_t svunpklo[_u32](svuint16_t op) - /// UUNPKLO Zresult.S, Zop.H + /// svuint32_t svunpklo[_u32](svuint16_t op) + /// UUNPKLO Zresult.S, Zop.H /// - public static unsafe Vector ZeroExtendWideningLower(Vector value) => ZeroExtendWideningLower(value); + public static Vector ZeroExtendWideningLower(Vector value) => ZeroExtendWideningLower(value); /// - /// svuint64_t svunpklo[_u64](svuint32_t op) - /// UUNPKLO Zresult.D, Zop.S + /// svuint64_t svunpklo[_u64](svuint32_t op) + /// UUNPKLO Zresult.D, Zop.S /// - public static unsafe Vector ZeroExtendWideningLower(Vector value) => ZeroExtendWideningLower(value); + public static Vector ZeroExtendWideningLower(Vector value) => ZeroExtendWideningLower(value); // Unpack and extend high half /// - /// svuint16_t svunpkhi[_u16](svuint8_t op) - /// UUNPKHI Zresult.H, Zop.B + /// svuint16_t svunpkhi[_u16](svuint8_t op) + /// UUNPKHI Zresult.H, Zop.B /// - public static unsafe Vector ZeroExtendWideningUpper(Vector value) => ZeroExtendWideningUpper(value); + public static Vector ZeroExtendWideningUpper(Vector value) => ZeroExtendWideningUpper(value); /// - /// svuint32_t svunpkhi[_u32](svuint16_t op) - /// UUNPKHI Zresult.S, Zop.H + /// svuint32_t svunpkhi[_u32](svuint16_t op) + /// UUNPKHI Zresult.S, Zop.H /// - public static unsafe Vector ZeroExtendWideningUpper(Vector value) => ZeroExtendWideningUpper(value); + public static Vector ZeroExtendWideningUpper(Vector value) => ZeroExtendWideningUpper(value); /// - /// svuint64_t svunpkhi[_u64](svuint32_t op) - /// UUNPKHI Zresult.D, Zop.S + /// svuint64_t svunpkhi[_u64](svuint32_t op) + /// UUNPKHI Zresult.D, Zop.S /// - public static unsafe Vector ZeroExtendWideningUpper(Vector value) => ZeroExtendWideningUpper(value); + public static Vector ZeroExtendWideningUpper(Vector value) => ZeroExtendWideningUpper(value); // Interleave elements from high halves of two inputs /// - /// svuint8_t svzip2[_u8](svuint8_t op1, svuint8_t op2) - /// ZIP2 Zresult.B, Zop1.B, Zop2.B + /// svuint8_t svzip2[_u8](svuint8_t op1, svuint8_t op2) + /// ZIP2 Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector ZipHigh(Vector left, Vector right) => ZipHigh(left, right); + public static Vector ZipHigh(Vector left, Vector right) => ZipHigh(left, right); /// - /// svfloat64_t svzip2[_f64](svfloat64_t op1, svfloat64_t op2) - /// ZIP2 Zresult.D, Zop1.D, Zop2.D + /// svfloat64_t svzip2[_f64](svfloat64_t op1, svfloat64_t op2) + /// ZIP2 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector ZipHigh(Vector left, Vector right) => ZipHigh(left, right); + public static Vector ZipHigh(Vector left, Vector right) => ZipHigh(left, right); /// - /// svint16_t svzip2[_s16](svint16_t op1, svint16_t op2) - /// ZIP2 Zresult.H, Zop1.H, Zop2.H + /// svint16_t svzip2[_s16](svint16_t op1, svint16_t op2) + /// ZIP2 Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector ZipHigh(Vector left, Vector right) => ZipHigh(left, right); + public static Vector ZipHigh(Vector left, Vector right) => ZipHigh(left, right); /// - /// svint32_t svzip2[_s32](svint32_t op1, svint32_t op2) - /// ZIP2 Zresult.S, Zop1.S, Zop2.S + /// svint32_t svzip2[_s32](svint32_t op1, svint32_t op2) + /// ZIP2 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector ZipHigh(Vector left, Vector right) => ZipHigh(left, right); + public static Vector ZipHigh(Vector left, Vector right) => ZipHigh(left, right); /// - /// svint64_t svzip2[_s64](svint64_t op1, svint64_t op2) - /// ZIP2 Zresult.D, Zop1.D, Zop2.D + /// svint64_t svzip2[_s64](svint64_t op1, svint64_t op2) + /// ZIP2 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector ZipHigh(Vector left, Vector right) => ZipHigh(left, right); + public static Vector ZipHigh(Vector left, Vector right) => ZipHigh(left, right); /// - /// svint8_t svzip2[_s8](svint8_t op1, svint8_t op2) - /// ZIP2 Zresult.B, Zop1.B, Zop2.B + /// svint8_t svzip2[_s8](svint8_t op1, svint8_t op2) + /// ZIP2 Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector ZipHigh(Vector left, Vector right) => ZipHigh(left, right); + public static Vector ZipHigh(Vector left, Vector right) => ZipHigh(left, right); /// - /// svfloat32_t svzip2[_f32](svfloat32_t op1, svfloat32_t op2) - /// ZIP2 Zresult.S, Zop1.S, Zop2.S + /// svfloat32_t svzip2[_f32](svfloat32_t op1, svfloat32_t op2) + /// ZIP2 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector ZipHigh(Vector left, Vector right) => ZipHigh(left, right); + public static Vector ZipHigh(Vector left, Vector right) => ZipHigh(left, right); /// - /// svuint16_t svzip2[_u16](svuint16_t op1, svuint16_t op2) - /// ZIP2 Zresult.H, Zop1.H, Zop2.H - /// svbool_t svzip2_b16(svbool_t op1, svbool_t op2) - /// ZIP2 Presult.H, Pop1.H, Pop2.H + /// svuint16_t svzip2[_u16](svuint16_t op1, svuint16_t op2) + /// ZIP2 Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector ZipHigh(Vector left, Vector right) => ZipHigh(left, right); + public static Vector ZipHigh(Vector left, Vector right) => ZipHigh(left, right); /// - /// svuint32_t svzip2[_u32](svuint32_t op1, svuint32_t op2) - /// ZIP2 Zresult.S, Zop1.S, Zop2.S - /// svbool_t svzip2_b32(svbool_t op1, svbool_t op2) - /// ZIP2 Presult.S, Pop1.S, Pop2.S + /// svuint32_t svzip2[_u32](svuint32_t op1, svuint32_t op2) + /// ZIP2 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector ZipHigh(Vector left, Vector right) => ZipHigh(left, right); + public static Vector ZipHigh(Vector left, Vector right) => ZipHigh(left, right); /// - /// svuint64_t svzip2[_u64](svuint64_t op1, svuint64_t op2) - /// ZIP2 Zresult.D, Zop1.D, Zop2.D - /// svbool_t svzip2_b64(svbool_t op1, svbool_t op2) - /// ZIP2 Presult.D, Pop1.D, Pop2.D + /// svuint64_t svzip2[_u64](svuint64_t op1, svuint64_t op2) + /// ZIP2 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector ZipHigh(Vector left, Vector right) => ZipHigh(left, right); + public static Vector ZipHigh(Vector left, Vector right) => ZipHigh(left, right); // Interleave elements from low halves of two inputs /// - /// svuint8_t svzip1[_u8](svuint8_t op1, svuint8_t op2) - /// ZIP1 Zresult.B, Zop1.B, Zop2.B - /// svbool_t svzip1_b8(svbool_t op1, svbool_t op2) - /// ZIP1 Presult.B, Pop1.B, Pop2.B + /// svuint8_t svzip1[_u8](svuint8_t op1, svuint8_t op2) + /// ZIP1 Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector ZipLow(Vector left, Vector right) => ZipLow(left, right); + public static Vector ZipLow(Vector left, Vector right) => ZipLow(left, right); /// - /// svfloat64_t svzip1[_f64](svfloat64_t op1, svfloat64_t op2) - /// ZIP1 Zresult.D, Zop1.D, Zop2.D + /// svfloat64_t svzip1[_f64](svfloat64_t op1, svfloat64_t op2) + /// ZIP1 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector ZipLow(Vector left, Vector right) => ZipLow(left, right); + public static Vector ZipLow(Vector left, Vector right) => ZipLow(left, right); /// - /// svint16_t svzip1[_s16](svint16_t op1, svint16_t op2) - /// ZIP1 Zresult.H, Zop1.H, Zop2.H + /// svint16_t svzip1[_s16](svint16_t op1, svint16_t op2) + /// ZIP1 Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector ZipLow(Vector left, Vector right) => ZipLow(left, right); + public static Vector ZipLow(Vector left, Vector right) => ZipLow(left, right); /// - /// svint32_t svzip1[_s32](svint32_t op1, svint32_t op2) - /// ZIP1 Zresult.S, Zop1.S, Zop2.S + /// svint32_t svzip1[_s32](svint32_t op1, svint32_t op2) + /// ZIP1 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector ZipLow(Vector left, Vector right) => ZipLow(left, right); + public static Vector ZipLow(Vector left, Vector right) => ZipLow(left, right); /// - /// svint64_t svzip1[_s64](svint64_t op1, svint64_t op2) - /// ZIP1 Zresult.D, Zop1.D, Zop2.D + /// svint64_t svzip1[_s64](svint64_t op1, svint64_t op2) + /// ZIP1 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector ZipLow(Vector left, Vector right) => ZipLow(left, right); + public static Vector ZipLow(Vector left, Vector right) => ZipLow(left, right); /// - /// svint8_t svzip1[_s8](svint8_t op1, svint8_t op2) - /// ZIP1 Zresult.B, Zop1.B, Zop2.B + /// svint8_t svzip1[_s8](svint8_t op1, svint8_t op2) + /// ZIP1 Zresult.B, Zop1.B, Zop2.B /// - public static unsafe Vector ZipLow(Vector left, Vector right) => ZipLow(left, right); + public static Vector ZipLow(Vector left, Vector right) => ZipLow(left, right); /// - /// svfloat32_t svzip1[_f32](svfloat32_t op1, svfloat32_t op2) - /// ZIP1 Zresult.S, Zop1.S, Zop2.S + /// svfloat32_t svzip1[_f32](svfloat32_t op1, svfloat32_t op2) + /// ZIP1 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector ZipLow(Vector left, Vector right) => ZipLow(left, right); + public static Vector ZipLow(Vector left, Vector right) => ZipLow(left, right); /// - /// svuint16_t svzip1[_u16](svuint16_t op1, svuint16_t op2) - /// ZIP1 Zresult.H, Zop1.H, Zop2.H - /// svbool_t svzip1_b16(svbool_t op1, svbool_t op2) - /// ZIP1 Presult.H, Pop1.H, Pop2.H + /// svuint16_t svzip1[_u16](svuint16_t op1, svuint16_t op2) + /// ZIP1 Zresult.H, Zop1.H, Zop2.H /// - public static unsafe Vector ZipLow(Vector left, Vector right) => ZipLow(left, right); + public static Vector ZipLow(Vector left, Vector right) => ZipLow(left, right); /// - /// svuint32_t svzip1[_u32](svuint32_t op1, svuint32_t op2) - /// ZIP1 Zresult.S, Zop1.S, Zop2.S - /// svbool_t svzip1_b32(svbool_t op1, svbool_t op2) - /// ZIP1 Presult.S, Pop1.S, Pop2.S + /// svuint32_t svzip1[_u32](svuint32_t op1, svuint32_t op2) + /// ZIP1 Zresult.S, Zop1.S, Zop2.S /// - public static unsafe Vector ZipLow(Vector left, Vector right) => ZipLow(left, right); + public static Vector ZipLow(Vector left, Vector right) => ZipLow(left, right); /// - /// svuint64_t svzip1[_u64](svuint64_t op1, svuint64_t op2) - /// ZIP1 Zresult.D, Zop1.D, Zop2.D - /// svbool_t svzip1_b64(svbool_t op1, svbool_t op2) - /// ZIP1 Presult.D, Pop1.D, Pop2.D + /// svuint64_t svzip1[_u64](svuint64_t op1, svuint64_t op2) + /// ZIP1 Zresult.D, Zop1.D, Zop2.D /// - public static unsafe Vector ZipLow(Vector left, Vector right) => ZipLow(left, right); + public static Vector ZipLow(Vector left, Vector right) => ZipLow(left, right); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/ISimdVector_2.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/ISimdVector_2.cs index 520f854a9c3..b0b28310be1 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/ISimdVector_2.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/ISimdVector_2.cs @@ -102,14 +102,14 @@ internal unsafe interface ISimdVector /// Computes the bitwise-and of two vectors. /// The vector to bitwise-and with . /// The vector to bitwise-and with . - /// The bitwise-and of and . + /// The bitwise-and of and . /// The type of and () is not supported. static virtual TSelf BitwiseAnd(TSelf left, TSelf right) => left & right; /// Computes the bitwise-or of two vectors. /// The vector to bitwise-or with . /// The vector to bitwise-or with . - /// The bitwise-or of and . + /// The bitwise-or of and . /// The type of and () is not supported. static virtual TSelf BitwiseOr(TSelf left, TSelf right) => left | right; @@ -520,24 +520,24 @@ static virtual TSelf LoadAligned(T* source) /// The vector to multiply with . /// The vector to multiply with . /// The element-wise product of and . - /// The type of and () is not supported. + /// The type of and () is not supported. static virtual TSelf Multiply(TSelf left, TSelf right) => left * right; /// Multiplies a vector by a scalar to compute their product. /// The vector to multiply with . /// The scalar to multiply with . /// The product of and . - /// The type of and () is not supported. + /// The type of and () is not supported. static virtual TSelf Multiply(TSelf left, T right) => left * right; - /// Computes an estimate of ( * ) + . + /// Computes an estimate of ( * ) + . /// The vector to be multiplied with . /// The vector to be multiplied with . /// The vector to be added to the result of multiplied by . - /// An estimate of ( * ) + . + /// An estimate of ( * ) + . /// /// On hardware that natively supports FusedMultiplyAdd, this may return a result that was rounded as one ternary operation. - /// On hardware without specialized support, this may just return ( * ) + . + /// On hardware without specialized support, this may just return ( * ) + . /// static abstract TSelf MultiplyAddEstimate(TSelf left, TSelf right, TSelf addend); diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs index 3f022bc4764..8fb3436cf3c 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128.cs @@ -93,11 +93,11 @@ public static Vector128 Abs(Vector128 vector) [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector128 AndNot(Vector128 left, Vector128 right) => left & ~right; - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the input vector. /// The type of the elements in the output vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () or the type of the target () is not supported. [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -113,64 +113,64 @@ public static Vector128 As(this Vector128 vector) #endif } - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector128 AsByte(this Vector128 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector128 AsDouble(this Vector128 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector128 AsInt16(this Vector128 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector128 AsInt32(this Vector128 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector128 AsInt64(this Vector128 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector128 AsNInt(this Vector128 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static Vector128 AsNUInt(this Vector128 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The vector to reinterpret. /// reinterpreted as a new . [Intrinsic] @@ -183,7 +183,7 @@ internal static Plane AsPlane(this Vector128 value) #endif } - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The vector to reinterpret. /// reinterpreted as a new . [Intrinsic] @@ -196,53 +196,53 @@ internal static Quaternion AsQuaternion(this Vector128 value) #endif } - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static Vector128 AsSByte(this Vector128 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector128 AsSingle(this Vector128 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static Vector128 AsUInt16(this Vector128 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static Vector128 AsUInt32(this Vector128 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static Vector128 AsUInt64(this Vector128 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The plane to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . [Intrinsic] internal static Vector128 AsVector128(this Plane value) { @@ -253,9 +253,9 @@ internal static Vector128 AsVector128(this Plane value) #endif } - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The quaternion to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . [Intrinsic] internal static Vector128 AsVector128(this Quaternion value) { @@ -266,21 +266,21 @@ internal static Vector128 AsVector128(this Quaternion value) #endif } - /// Reinterprets a as a new with the new elements zeroed. + /// Reinterprets a as a new with the new elements zeroed. /// The vector to reinterpret. - /// reinterpreted as a new with the new elements zeroed. + /// reinterpreted as a new with the new elements zeroed. [Intrinsic] public static Vector128 AsVector128(this Vector2 value) => Vector4.Create(value, 0, 0).AsVector128(); - /// Reinterprets a as a new with the new elements zeroed. + /// Reinterprets a as a new with the new elements zeroed. /// The vector to reinterpret. - /// reinterpreted as a new with the new elements zeroed. + /// reinterpreted as a new with the new elements zeroed. [Intrinsic] public static Vector128 AsVector128(this Vector3 value) => Vector4.Create(value, 0).AsVector128(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . [Intrinsic] public static Vector128 AsVector128(this Vector4 value) { @@ -307,9 +307,9 @@ public static Vector128 AsVector128(this Vector value) return Unsafe.ReadUnaligned>(ref address); } - /// Reinterprets a as a new , leaving the new elements undefined. + /// Reinterprets a as a new , leaving the new elements undefined. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . [Intrinsic] public static Vector128 AsVector128Unsafe(this Vector2 value) { @@ -321,9 +321,9 @@ public static Vector128 AsVector128Unsafe(this Vector2 value) return result; } - /// Reinterprets a as a new , leaving the new elements undefined. + /// Reinterprets a as a new , leaving the new elements undefined. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . [Intrinsic] public static Vector128 AsVector128Unsafe(this Vector3 value) { @@ -335,7 +335,7 @@ public static Vector128 AsVector128Unsafe(this Vector3 value) return result; } - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The vector to reinterpret. /// reinterpreted as a new . [Intrinsic] @@ -346,7 +346,7 @@ public static Vector2 AsVector2(this Vector128 value) return Unsafe.ReadUnaligned(ref address); } - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The vector to reinterpret. /// reinterpreted as a new . [Intrinsic] @@ -357,7 +357,7 @@ public static Vector3 AsVector3(this Vector128 value) return Unsafe.ReadUnaligned(ref address); } - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The vector to reinterpret. /// reinterpreted as a new . [Intrinsic] @@ -391,7 +391,7 @@ public static Vector AsVector(this Vector128 value) /// The type of the elements in the vector. /// The vector to bitwise-and with . /// The vector to bitwise-and with . - /// The bitwise-and of and . + /// The bitwise-and of and . /// The type of and () is not supported. [Intrinsic] public static Vector128 BitwiseAnd(Vector128 left, Vector128 right) => left & right; @@ -400,7 +400,7 @@ public static Vector AsVector(this Vector128 value) /// The type of the elements in the vector. /// The vector to bitwise-or with . /// The vector to bitwise-or with . - /// The bitwise-or of and . + /// The bitwise-or of and . /// The type of and () is not supported. [Intrinsic] public static Vector128 BitwiseOr(Vector128 left, Vector128 right) => left | right; @@ -475,7 +475,7 @@ public static Vector128 ClampNative(Vector128 value, Vector128 min, [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector128 ConditionalSelect(Vector128 condition, Vector128 left, Vector128 right) => (left & condition) | AndNot(right, condition); - /// Converts a to a . + /// Converts a to a . /// The vector to convert. /// The converted vector. [Intrinsic] @@ -515,7 +515,7 @@ public static unsafe Vector128 ConvertToDouble(Vector128 vector) } } - /// Converts a to a . + /// Converts a to a . /// The vector to convert. /// The converted vector. [Intrinsic] @@ -556,7 +556,7 @@ public static unsafe Vector128 ConvertToDouble(Vector128 vector) } } - /// Converts a to a using saturation on overflow. + /// Converts a to a using saturation on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -569,7 +569,7 @@ public static unsafe Vector128 ConvertToInt32(Vector128 vector) ); } - /// Converts a to a platform specific behavior on overflow. + /// Converts a to a platform specific behavior on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -582,7 +582,7 @@ public static unsafe Vector128 ConvertToInt32Native(Vector128 vector ); } - /// Converts a to a using saturation on overflow. + /// Converts a to a using saturation on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -595,7 +595,7 @@ public static unsafe Vector128 ConvertToInt64(Vector128 vector) ); } - /// Converts a to a using platform specific behavior on overflow. + /// Converts a to a using platform specific behavior on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -608,7 +608,7 @@ public static unsafe Vector128 ConvertToInt64Native(Vector128 vect ); } - /// Converts a to a . + /// Converts a to a . /// The vector to convert. /// The converted vector. [Intrinsic] @@ -621,7 +621,7 @@ public static unsafe Vector128 ConvertToSingle(Vector128 vector) ); } - /// Converts a to a . + /// Converts a to a . /// The vector to convert. /// The converted vector. [Intrinsic] @@ -678,7 +678,7 @@ static Vector128 SoftwareFallback(Vector128 vector) } } - /// Converts a to a using saturation on overflow. + /// Converts a to a using saturation on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -692,7 +692,7 @@ public static unsafe Vector128 ConvertToUInt32(Vector128 vector) ); } - /// Converts a to a using platform specific behavior on overflow. + /// Converts a to a using platform specific behavior on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -706,7 +706,7 @@ public static unsafe Vector128 ConvertToUInt32Native(Vector128 vect ); } - /// Converts a to a using saturation on overflow. + /// Converts a to a using saturation on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -720,7 +720,7 @@ public static unsafe Vector128 ConvertToUInt64(Vector128 vector) ); } - /// Converts a to a using platform specific behavior on overflow. + /// Converts a to a using platform specific behavior on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -877,88 +877,88 @@ public static unsafe Vector128 Create(T value) return Create(vector, vector); } - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m128i _mm_set1_epi8 [Intrinsic] public static unsafe Vector128 Create(byte value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m128d _mm_set1_pd [Intrinsic] public static unsafe Vector128 Create(double value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m128i _mm_set1_epi16 [Intrinsic] public static unsafe Vector128 Create(short value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m128i _mm_set1_epi32 [Intrinsic] public static unsafe Vector128 Create(int value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m128i _mm_set1_epi64x [Intrinsic] public static unsafe Vector128 Create(long value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . [Intrinsic] public static unsafe Vector128 Create(nint value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . [Intrinsic] [CLSCompliant(false)] public static unsafe Vector128 Create(nuint value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m128i _mm_set1_epi8 [Intrinsic] [CLSCompliant(false)] public static unsafe Vector128 Create(sbyte value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m128 _mm_set1_ps [Intrinsic] public static unsafe Vector128 Create(float value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m128i _mm_set1_epi16 [Intrinsic] [CLSCompliant(false)] public static unsafe Vector128 Create(ushort value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m128i _mm_set1_epi32 [Intrinsic] [CLSCompliant(false)] public static unsafe Vector128 Create(uint value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m128i _mm_set1_epi64x [Intrinsic] [CLSCompliant(false)] @@ -1022,7 +1022,7 @@ public static Vector128 Create(ReadOnlySpan values) return Unsafe.ReadUnaligned>(ref Unsafe.As(ref MemoryMarshal.GetReference(values))); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. @@ -1039,7 +1039,7 @@ public static Vector128 Create(ReadOnlySpan values) /// The value that element 13 will be initialized to. /// The value that element 14 will be initialized to. /// The value that element 15 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m128i _mm_setr_epi8 [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -1051,10 +1051,10 @@ public static unsafe Vector128 Create(byte e0, byte e1, byte e2, byte e3, ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m128d _mm_setr_pd [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -1066,7 +1066,7 @@ public static unsafe Vector128 Create(double e0, double e1) ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. @@ -1075,7 +1075,7 @@ public static unsafe Vector128 Create(double e0, double e1) /// The value that element 5 will be initialized to. /// The value that element 6 will be initialized to. /// The value that element 7 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m128i _mm_setr_epi16 [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -1087,12 +1087,12 @@ public static unsafe Vector128 Create(short e0, short e1, short e2, short ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. /// The value that element 3 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m128i _mm_setr_epi32 [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -1104,10 +1104,10 @@ public static unsafe Vector128 Create(int e0, int e1, int e2, int e3) ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m128i _mm_setr_epi64x [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -1119,7 +1119,7 @@ public static unsafe Vector128 Create(long e0, long e1) ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. @@ -1136,7 +1136,7 @@ public static unsafe Vector128 Create(long e0, long e1) /// The value that element 13 will be initialized to. /// The value that element 14 will be initialized to. /// The value that element 15 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m128i _mm_setr_epi8 [Intrinsic] [CLSCompliant(false)] @@ -1149,12 +1149,12 @@ public static unsafe Vector128 Create(sbyte e0, sbyte e1, sbyte e2, sbyte ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. /// The value that element 3 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m128 _mm_setr_ps [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -1166,7 +1166,7 @@ public static unsafe Vector128 Create(float e0, float e1, float e2, float ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. @@ -1175,7 +1175,7 @@ public static unsafe Vector128 Create(float e0, float e1, float e2, float /// The value that element 5 will be initialized to. /// The value that element 6 will be initialized to. /// The value that element 7 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m128i _mm_setr_epi16 [Intrinsic] [CLSCompliant(false)] @@ -1188,12 +1188,12 @@ public static unsafe Vector128 Create(ushort e0, ushort e1, ushort e2, u ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. /// The value that element 3 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m128i _mm_setr_epi32 [Intrinsic] [CLSCompliant(false)] @@ -1206,10 +1206,10 @@ public static unsafe Vector128 Create(uint e0, uint e1, uint e2, uint e3) ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m128i _mm_setr_epi64x [Intrinsic] [CLSCompliant(false)] @@ -1255,82 +1255,82 @@ public static Vector128 Create(Vector64 lower, Vector64 upper) } } - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 64-bits will be initialized to. /// The value that the upper 64-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . public static unsafe Vector128 Create(Vector64 lower, Vector64 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 64-bits will be initialized to. /// The value that the upper 64-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . public static unsafe Vector128 Create(Vector64 lower, Vector64 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 64-bits will be initialized to. /// The value that the upper 64-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . public static unsafe Vector128 Create(Vector64 lower, Vector64 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 64-bits will be initialized to. /// The value that the upper 64-bits will be initialized to. /// On x86, this method corresponds to __m128i _mm_setr_epi64 - /// A new initialized from and . + /// A new initialized from and . public static unsafe Vector128 Create(Vector64 lower, Vector64 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 64-bits will be initialized to. /// The value that the upper 64-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . public static unsafe Vector128 Create(Vector64 lower, Vector64 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 64-bits will be initialized to. /// The value that the upper 64-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . public static unsafe Vector128 Create(Vector64 lower, Vector64 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 64-bits will be initialized to. /// The value that the upper 64-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . [CLSCompliant(false)] public static unsafe Vector128 Create(Vector64 lower, Vector64 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 64-bits will be initialized to. /// The value that the upper 64-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . [CLSCompliant(false)] public static unsafe Vector128 Create(Vector64 lower, Vector64 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 64-bits will be initialized to. /// The value that the upper 64-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . public static unsafe Vector128 Create(Vector64 lower, Vector64 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 64-bits will be initialized to. /// The value that the upper 64-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . [CLSCompliant(false)] public static unsafe Vector128 Create(Vector64 lower, Vector64 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 64-bits will be initialized to. /// The value that the upper 64-bits will be initialized to. /// On x86, this method corresponds to __m128i _mm_setr_epi64 - /// A new initialized from and . + /// A new initialized from and . [CLSCompliant(false)] public static unsafe Vector128 Create(Vector64 lower, Vector64 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 64-bits will be initialized to. /// The value that the upper 64-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . [CLSCompliant(false)] public static unsafe Vector128 Create(Vector64 lower, Vector64 upper) => Create(lower, upper); @@ -1342,79 +1342,79 @@ public static Vector128 Create(Vector64 lower, Vector64 upper) [Intrinsic] public static unsafe Vector128 CreateScalar(T value) => Vector64.CreateScalar(value).ToVector128(); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static unsafe Vector128 CreateScalar(byte value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static unsafe Vector128 CreateScalar(double value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static unsafe Vector128 CreateScalar(short value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static unsafe Vector128 CreateScalar(int value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static unsafe Vector128 CreateScalar(long value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static unsafe Vector128 CreateScalar(nint value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] [CLSCompliant(false)] public static unsafe Vector128 CreateScalar(nuint value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] [CLSCompliant(false)] public static unsafe Vector128 CreateScalar(sbyte value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static unsafe Vector128 CreateScalar(float value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] [CLSCompliant(false)] public static unsafe Vector128 CreateScalar(ushort value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] [CLSCompliant(false)] public static unsafe Vector128 CreateScalar(uint value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] [CLSCompliant(false)] public static unsafe Vector128 CreateScalar(ulong value) => CreateScalar(value); @@ -1438,79 +1438,79 @@ public static Vector128 CreateScalarUnsafe(T value) return result; } - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static unsafe Vector128 CreateScalarUnsafe(byte value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static unsafe Vector128 CreateScalarUnsafe(double value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static unsafe Vector128 CreateScalarUnsafe(short value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static unsafe Vector128 CreateScalarUnsafe(int value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static unsafe Vector128 CreateScalarUnsafe(long value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static unsafe Vector128 CreateScalarUnsafe(nint value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] [CLSCompliant(false)] public static unsafe Vector128 CreateScalarUnsafe(nuint value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] [CLSCompliant(false)] public static unsafe Vector128 CreateScalarUnsafe(sbyte value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static unsafe Vector128 CreateScalarUnsafe(float value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] [CLSCompliant(false)] public static unsafe Vector128 CreateScalarUnsafe(ushort value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] [CLSCompliant(false)] public static unsafe Vector128 CreateScalarUnsafe(uint value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] [CLSCompliant(false)] public static unsafe Vector128 CreateScalarUnsafe(ulong value) => CreateScalarUnsafe(value); @@ -2201,12 +2201,12 @@ public static Vector128 LoadUnsafe(ref readonly T source, nuint elementOff return Unsafe.ReadUnaligned>(in address); } - /// Loads a vector from the given source and reinterprets it as . + /// Loads a vector from the given source and reinterprets it as . /// The source from which the vector will be loaded. /// The vector loaded from . internal static Vector128 LoadUnsafe(ref char source) => LoadUnsafe(ref Unsafe.As(ref source)); - /// Loads a vector from the given source and element offset and reinterprets it as . + /// Loads a vector from the given source and element offset and reinterprets it as . /// The source to which will be added before loading the vector. /// The element offset from from which the vector will be loaded. /// The vector loaded from plus . @@ -2465,7 +2465,7 @@ public static Vector128 MinNumber(Vector128 left, Vector128 right) /// The vector to multiply with . /// The vector to multiply with . /// The element-wise product of and . - /// The type of and () is not supported. + /// The type of and () is not supported. [Intrinsic] public static Vector128 Multiply(Vector128 left, Vector128 right) => left * right; @@ -2474,7 +2474,7 @@ public static Vector128 MinNumber(Vector128 left, Vector128 right) /// The vector to multiply with . /// The scalar to multiply with . /// The product of and . - /// The type of and () is not supported. + /// The type of and () is not supported. [Intrinsic] public static Vector128 Multiply(Vector128 left, T right) => left * right; @@ -2483,7 +2483,7 @@ public static Vector128 MinNumber(Vector128 left, Vector128 right) /// The scalar to multiply with . /// The vector to multiply with . /// The product of and . - /// The type of and () is not supported. + /// The type of and () is not supported. [Intrinsic] public static Vector128 Multiply(T left, Vector128 right) => right * left; @@ -2519,10 +2519,10 @@ public static Vector128 MultiplyAddEstimate(Vector128 left, Vector ); } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe Vector128 Narrow(Vector128 lower, Vector128 upper) @@ -2533,10 +2533,10 @@ public static unsafe Vector128 Narrow(Vector128 lower, Vector128< ); } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -2548,10 +2548,10 @@ public static unsafe Vector128 Narrow(Vector128 lower, Vector128Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe Vector128 Narrow(Vector128 lower, Vector128 upper) @@ -2562,10 +2562,10 @@ public static unsafe Vector128 Narrow(Vector128 lower, Vector128Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe Vector128 Narrow(Vector128 lower, Vector128 upper) @@ -2576,10 +2576,10 @@ public static unsafe Vector128 Narrow(Vector128 lower, Vector128Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -2591,10 +2591,10 @@ public static unsafe Vector128 Narrow(Vector128 lower, Vector128Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -2606,10 +2606,10 @@ public static unsafe Vector128 Narrow(Vector128 lower, Vector128Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -2976,9 +2976,9 @@ public static Vector128 Shuffle(Vector128 vector, Vector128 /// The input vector from which values are selected. /// The per-element indices used to select a value from . /// A new vector containing the values from selected by the given . - /// Unlike Shuffle, this method delegates to the underlying hardware intrinsic without ensuring that are normalized to [0, 15]. - /// On hardware with support, indices are treated as modulo 16, and if the high bit is set, the result will be set to 0 for that element. - /// On hardware with or support, this method behaves the same as Shuffle. + /// Unlike Shuffle, this method delegates to the underlying hardware intrinsic without ensuring that are normalized to [0, 15]. + /// On hardware with support, indices are treated as modulo 16, and if the high bit is set, the result will be set to 0 for that element. + /// On hardware with or support, this method behaves the same as Shuffle. [MethodImpl(MethodImplOptions.AggressiveInlining)] [CompExactlyDependsOn(typeof(Ssse3))] [CompExactlyDependsOn(typeof(AdvSimd))] @@ -3341,7 +3341,7 @@ public static unsafe void StoreAligned(this Vector128 source, T* destinati public static unsafe void StoreAlignedNonTemporal(this Vector128 source, T* destination) => source.StoreAligned(destination); /// - /// Stores to lower 64 bits of to memory destination of [] + /// Stores to lower 64 bits of to memory destination of [] /// /// The type of the elements in the vector. /// The vector that will be stored. @@ -3513,53 +3513,53 @@ public static bool TryCopyTo(this Vector128 vector, Span destination) return true; } - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe (Vector128 Lower, Vector128 Upper) Widen(Vector128 source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe (Vector128 Lower, Vector128 Upper) Widen(Vector128 source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe (Vector128 Lower, Vector128 Upper) Widen(Vector128 source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe (Vector128 Lower, Vector128 Upper) Widen(Vector128 source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe (Vector128 Lower, Vector128 Upper) Widen(Vector128 source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe (Vector128 Lower, Vector128 Upper) Widen(Vector128 source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe (Vector128 Lower, Vector128 Upper) Widen(Vector128 source) => (WidenLower(source), WidenUpper(source)); - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3575,7 +3575,7 @@ public static Vector128 WidenLower(Vector128 source) ); } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3590,7 +3590,7 @@ public static unsafe Vector128 WidenLower(Vector128 source) ); } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3605,7 +3605,7 @@ public static unsafe Vector128 WidenLower(Vector128 source) ); } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3621,7 +3621,7 @@ public static unsafe Vector128 WidenLower(Vector128 source) ); } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3636,7 +3636,7 @@ public static unsafe Vector128 WidenLower(Vector128 source) ); } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3652,7 +3652,7 @@ public static unsafe Vector128 WidenLower(Vector128 source) ); } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3668,7 +3668,7 @@ public static unsafe Vector128 WidenLower(Vector128 source) ); } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3684,7 +3684,7 @@ public static Vector128 WidenUpper(Vector128 source) ); } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3699,7 +3699,7 @@ public static unsafe Vector128 WidenUpper(Vector128 source) ); } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3714,7 +3714,7 @@ public static unsafe Vector128 WidenUpper(Vector128 source) ); } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3730,7 +3730,7 @@ public static unsafe Vector128 WidenUpper(Vector128 source) ); } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3745,7 +3745,7 @@ public static unsafe Vector128 WidenUpper(Vector128 source) ); } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3761,7 +3761,7 @@ public static unsafe Vector128 WidenUpper(Vector128 source) ); } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128_1.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128_1.cs index 9228778af29..46c2ae3cb1c 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128_1.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector128_1.cs @@ -144,7 +144,7 @@ public static Vector128 Zero /// Computes the bitwise-and of two vectors. /// The vector to bitwise-and with . /// The vector to bitwise-and with . - /// The bitwise-and of and . + /// The bitwise-and of and . /// The type of the vector () is not supported. [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -159,7 +159,7 @@ public static Vector128 Zero /// Computes the bitwise-or of two vectors. /// The vector to bitwise-or with . /// The vector to bitwise-or with . - /// The bitwise-or of and . + /// The bitwise-or of and . /// The type of the vector () is not supported. [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs index 2edd04c3fc9..6708b81a203 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256.cs @@ -98,11 +98,11 @@ public static Vector256 Abs(Vector256 vector) [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector256 AndNot(Vector256 left, Vector256 right) => left & ~right; - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the input vector. /// The type of the elements in the output vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () or the type of the target () is not supported. [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -118,102 +118,102 @@ public static Vector256 As(this Vector256 vector) #endif } - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector256 AsByte(this Vector256 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector256 AsDouble(this Vector256 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector256 AsInt16(this Vector256 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector256 AsInt32(this Vector256 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector256 AsInt64(this Vector256 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector256 AsNInt(this Vector256 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static Vector256 AsNUInt(this Vector256 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static Vector256 AsSByte(this Vector256 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector256 AsSingle(this Vector256 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static Vector256 AsUInt16(this Vector256 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static Vector256 AsUInt32(this Vector256 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] @@ -256,7 +256,7 @@ public static Vector AsVector(this Vector256 value) /// The type of the elements in the vector. /// The vector to bitwise-and with . /// The vector to bitwise-and with . - /// The bitwise-and of and . + /// The bitwise-and of and . /// The type of and () is not supported. [Intrinsic] public static Vector256 BitwiseAnd(Vector256 left, Vector256 right) => left & right; @@ -265,7 +265,7 @@ public static Vector AsVector(this Vector256 value) /// The type of the elements in the vector. /// The vector to bitwise-or with . /// The vector to bitwise-or with . - /// The bitwise-or of and . + /// The bitwise-or of and . /// The type of and () is not supported. [Intrinsic] public static Vector256 BitwiseOr(Vector256 left, Vector256 right) => left | right; @@ -340,7 +340,7 @@ public static Vector256 ClampNative(Vector256 value, Vector256 min, [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector256 ConditionalSelect(Vector256 condition, Vector256 left, Vector256 right) => (left & condition) | AndNot(right, condition); - /// Converts a to a . + /// Converts a to a . /// The vector to convert. /// The converted vector. [Intrinsic] @@ -372,7 +372,7 @@ public static Vector256 ConvertToDouble(Vector256 vector) } } - /// Converts a to a . + /// Converts a to a . /// The vector to convert. /// The converted vector. [Intrinsic] @@ -405,7 +405,7 @@ public static Vector256 ConvertToDouble(Vector256 vector) } } - /// Converts a to a using saturation on overflow. + /// Converts a to a using saturation on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -418,7 +418,7 @@ public static Vector256 ConvertToInt32(Vector256 vector) ); } - /// Converts a to a using platform specific behavior on overflow. + /// Converts a to a using platform specific behavior on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -431,7 +431,7 @@ public static Vector256 ConvertToInt32Native(Vector256 vector) ); } - /// Converts a to a using saturation on overflow. + /// Converts a to a using saturation on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -444,7 +444,7 @@ public static Vector256 ConvertToInt64(Vector256 vector) ); } - /// Converts a to a using platform specific behavior on overflow. + /// Converts a to a using platform specific behavior on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -457,7 +457,7 @@ public static Vector256 ConvertToInt64Native(Vector256 vector) ); } - /// Converts a to a . + /// Converts a to a . /// The vector to convert. /// The converted vector. [Intrinsic] @@ -470,7 +470,7 @@ public static Vector256 ConvertToSingle(Vector256 vector) ); } - /// Converts a to a . + /// Converts a to a . /// The vector to convert. /// The converted vector. [Intrinsic] @@ -517,7 +517,7 @@ public static Vector256 ConvertToSingle(Vector256 vector) } } - /// Converts a to a using saturation on overflow. + /// Converts a to a using saturation on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -531,7 +531,7 @@ public static Vector256 ConvertToUInt32(Vector256 vector) ); } - /// Converts a to a using platform specific behavior on overflow. + /// Converts a to a using platform specific behavior on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -545,7 +545,7 @@ public static Vector256 ConvertToUInt32Native(Vector256 vector) ); } - /// Converts a to a using saturation on overflow. + /// Converts a to a using saturation on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -559,7 +559,7 @@ public static Vector256 ConvertToUInt64(Vector256 vector) ); } - /// Converts a to a using platform specific behavior on overflow. + /// Converts a to a using platform specific behavior on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -716,88 +716,88 @@ public static Vector256 Create(T value) return Create(vector, vector); } - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m256i _mm256_set1_epi8 [Intrinsic] public static Vector256 Create(byte value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m256d _mm256_set1_pd [Intrinsic] public static Vector256 Create(double value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m256i _mm256_set1_epi16 [Intrinsic] public static Vector256 Create(short value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m256i _mm256_set1_epi32 [Intrinsic] public static Vector256 Create(int value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m256i _mm256_set1_epi64x [Intrinsic] public static Vector256 Create(long value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . [Intrinsic] public static Vector256 Create(nint value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . [Intrinsic] [CLSCompliant(false)] public static Vector256 Create(nuint value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m256i _mm256_set1_epi8 [Intrinsic] [CLSCompliant(false)] public static Vector256 Create(sbyte value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m256 _mm256_set1_ps [Intrinsic] public static Vector256 Create(float value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m256i _mm256_set1_epi16 [Intrinsic] [CLSCompliant(false)] public static Vector256 Create(ushort value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m256i _mm256_set1_epi32 [Intrinsic] [CLSCompliant(false)] public static Vector256 Create(uint value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m256i _mm256_set1_epi64x [Intrinsic] [CLSCompliant(false)] @@ -861,7 +861,7 @@ public static Vector256 Create(ReadOnlySpan values) return Unsafe.ReadUnaligned>(ref Unsafe.As(ref MemoryMarshal.GetReference(values))); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. @@ -894,7 +894,7 @@ public static Vector256 Create(ReadOnlySpan values) /// The value that element 29 will be initialized to. /// The value that element 30 will be initialized to. /// The value that element 31 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m256i _mm256_setr_epi8 [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -907,12 +907,12 @@ public static Vector256 Create(byte e0, byte e1, byte e2, byte e3, byt ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. /// The value that element 3 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m256d _mm256_setr_pd [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -924,7 +924,7 @@ public static Vector256 Create(double e0, double e1, double e2, double e ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. @@ -941,7 +941,7 @@ public static Vector256 Create(double e0, double e1, double e2, double e /// The value that element 13 will be initialized to. /// The value that element 14 will be initialized to. /// The value that element 15 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m256i _mm256_setr_epi16 [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -953,7 +953,7 @@ public static Vector256 Create(short e0, short e1, short e2, short e3, sh ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. @@ -962,7 +962,7 @@ public static Vector256 Create(short e0, short e1, short e2, short e3, sh /// The value that element 5 will be initialized to. /// The value that element 6 will be initialized to. /// The value that element 7 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m256i _mm256_setr_epi32 [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -974,12 +974,12 @@ public static Vector256 Create(int e0, int e1, int e2, int e3, int e4, int ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. /// The value that element 3 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m256i _mm256_setr_epi64x [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -991,7 +991,7 @@ public static Vector256 Create(long e0, long e1, long e2, long e3) ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. @@ -1024,7 +1024,7 @@ public static Vector256 Create(long e0, long e1, long e2, long e3) /// The value that element 29 will be initialized to. /// The value that element 30 will be initialized to. /// The value that element 31 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m256i _mm256_setr_epi8 [Intrinsic] [CLSCompliant(false)] @@ -1038,7 +1038,7 @@ public static Vector256 Create(sbyte e0, sbyte e1, sbyte e2, sbyte e3, ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. @@ -1047,7 +1047,7 @@ public static Vector256 Create(sbyte e0, sbyte e1, sbyte e2, sbyte e3, /// The value that element 5 will be initialized to. /// The value that element 6 will be initialized to. /// The value that element 7 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m256 _mm256_setr_ps [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -1059,7 +1059,7 @@ public static Vector256 Create(float e0, float e1, float e2, float e3, fl ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. @@ -1076,7 +1076,7 @@ public static Vector256 Create(float e0, float e1, float e2, float e3, fl /// The value that element 13 will be initialized to. /// The value that element 14 will be initialized to. /// The value that element 15 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m256i _mm256_setr_epi16 [Intrinsic] [CLSCompliant(false)] @@ -1089,7 +1089,7 @@ public static Vector256 Create(ushort e0, ushort e1, ushort e2, ushort e ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. @@ -1098,7 +1098,7 @@ public static Vector256 Create(ushort e0, ushort e1, ushort e2, ushort e /// The value that element 5 will be initialized to. /// The value that element 6 will be initialized to. /// The value that element 7 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m256i _mm256_setr_epi32 [Intrinsic] [CLSCompliant(false)] @@ -1111,12 +1111,12 @@ public static Vector256 Create(uint e0, uint e1, uint e2, uint e3, uint e4 ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. /// The value that element 3 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m256i _mm256_setr_epi64x [Intrinsic] [CLSCompliant(false)] @@ -1171,84 +1171,84 @@ public static Vector256 Create(Vector128 lower, Vector128 upper) } } - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 128-bits will be initialized to. /// The value that the upper 128-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . public static Vector256 Create(Vector128 lower, Vector128 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 128-bits will be initialized to. /// The value that the upper 128-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . /// On x86, this method corresponds to __m256d _mm256_setr_m128d (__m128d lo, __m128d hi) public static Vector256 Create(Vector128 lower, Vector128 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 128-bits will be initialized to. /// The value that the upper 128-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . public static Vector256 Create(Vector128 lower, Vector128 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 128-bits will be initialized to. /// The value that the upper 128-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . /// On x86, this method corresponds to __m256i _mm256_setr_m128i (__m128i lo, __m128i hi) public static Vector256 Create(Vector128 lower, Vector128 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 128-bits will be initialized to. /// The value that the upper 128-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . public static Vector256 Create(Vector128 lower, Vector128 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 128-bits will be initialized to. /// The value that the upper 128-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . public static Vector256 Create(Vector128 lower, Vector128 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 128-bits will be initialized to. /// The value that the upper 128-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . [CLSCompliant(false)] public static Vector256 Create(Vector128 lower, Vector128 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 128-bits will be initialized to. /// The value that the upper 128-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . [CLSCompliant(false)] public static Vector256 Create(Vector128 lower, Vector128 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 128-bits will be initialized to. /// The value that the upper 128-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . /// On x86, this method corresponds to __m256 _mm256_setr_m128 (__m128 lo, __m128 hi) public static Vector256 Create(Vector128 lower, Vector128 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 128-bits will be initialized to. /// The value that the upper 128-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . [CLSCompliant(false)] public static Vector256 Create(Vector128 lower, Vector128 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 128-bits will be initialized to. /// The value that the upper 128-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . /// On x86, this method corresponds to __m256i _mm256_setr_m128i (__m128i lo, __m128i hi) [CLSCompliant(false)] public static Vector256 Create(Vector128 lower, Vector128 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 128-bits will be initialized to. /// The value that the upper 128-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . [CLSCompliant(false)] public static Vector256 Create(Vector128 lower, Vector128 upper) => Create(lower, upper); @@ -1260,79 +1260,79 @@ public static Vector256 Create(Vector128 lower, Vector128 upper) [Intrinsic] public static Vector256 CreateScalar(T value) => Vector128.CreateScalar(value).ToVector256(); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static Vector256 CreateScalar(byte value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static Vector256 CreateScalar(double value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static Vector256 CreateScalar(short value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static Vector256 CreateScalar(int value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static Vector256 CreateScalar(long value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static Vector256 CreateScalar(nint value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] [CLSCompliant(false)] public static Vector256 CreateScalar(nuint value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] [CLSCompliant(false)] public static Vector256 CreateScalar(sbyte value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static Vector256 CreateScalar(float value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] [CLSCompliant(false)] public static Vector256 CreateScalar(ushort value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] [CLSCompliant(false)] public static Vector256 CreateScalar(uint value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] [CLSCompliant(false)] public static Vector256 CreateScalar(ulong value) => CreateScalar(value); @@ -1356,79 +1356,79 @@ public static Vector256 CreateScalarUnsafe(T value) return result; } - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static Vector256 CreateScalarUnsafe(byte value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static Vector256 CreateScalarUnsafe(double value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static Vector256 CreateScalarUnsafe(short value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static Vector256 CreateScalarUnsafe(int value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static Vector256 CreateScalarUnsafe(long value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static Vector256 CreateScalarUnsafe(nint value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] [CLSCompliant(false)] public static Vector256 CreateScalarUnsafe(nuint value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] [CLSCompliant(false)] public static Vector256 CreateScalarUnsafe(sbyte value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static Vector256 CreateScalarUnsafe(float value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] [CLSCompliant(false)] public static Vector256 CreateScalarUnsafe(ushort value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] [CLSCompliant(false)] public static Vector256 CreateScalarUnsafe(uint value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] [CLSCompliant(false)] public static Vector256 CreateScalarUnsafe(ulong value) => CreateScalarUnsafe(value); @@ -2117,12 +2117,12 @@ public static Vector256 LoadUnsafe(ref readonly T source, nuint elementOff return Unsafe.ReadUnaligned>(in address); } - /// Loads a vector from the given source and reinterprets it as . + /// Loads a vector from the given source and reinterprets it as . /// The source from which the vector will be loaded. /// The vector loaded from . internal static Vector256 LoadUnsafe(ref char source) => LoadUnsafe(ref Unsafe.As(ref source)); - /// Loads a vector from the given source and element offset and reinterprets it as . + /// Loads a vector from the given source and element offset and reinterprets it as . /// The source to which will be added before loading the vector. /// The element offset from from which the vector will be loaded. /// The vector loaded from plus . @@ -2435,10 +2435,10 @@ public static Vector256 MultiplyAddEstimate(Vector256 left, Vector ); } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector256 Narrow(Vector256 lower, Vector256 upper) @@ -2449,10 +2449,10 @@ public static Vector256 Narrow(Vector256 lower, Vector256 ); } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -2464,10 +2464,10 @@ public static Vector256 Narrow(Vector256 lower, Vector256 u ); } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector256 Narrow(Vector256 lower, Vector256 upper) @@ -2478,10 +2478,10 @@ public static Vector256 Narrow(Vector256 lower, Vector256 upper ); } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector256 Narrow(Vector256 lower, Vector256 upper) @@ -2492,10 +2492,10 @@ public static Vector256 Narrow(Vector256 lower, Vector256 upper ); } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -2507,10 +2507,10 @@ public static Vector256 Narrow(Vector256 lower, Vector256 ); } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -2522,10 +2522,10 @@ public static Vector256 Narrow(Vector256 lower, Vector256 up ); } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -3378,53 +3378,53 @@ public static bool TryCopyTo(this Vector256 vector, Span destination) return true; } - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static (Vector256 Lower, Vector256 Upper) Widen(Vector256 source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [MethodImpl(MethodImplOptions.AggressiveInlining)] public static (Vector256 Lower, Vector256 Upper) Widen(Vector256 source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [MethodImpl(MethodImplOptions.AggressiveInlining)] public static (Vector256 Lower, Vector256 Upper) Widen(Vector256 source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static (Vector256 Lower, Vector256 Upper) Widen(Vector256 source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [MethodImpl(MethodImplOptions.AggressiveInlining)] public static (Vector256 Lower, Vector256 Upper) Widen(Vector256 source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static (Vector256 Lower, Vector256 Upper) Widen(Vector256 source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static (Vector256 Lower, Vector256 Upper) Widen(Vector256 source) => (WidenLower(source), WidenUpper(source)); - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3440,7 +3440,7 @@ public static Vector256 WidenLower(Vector256 source) ); } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3455,7 +3455,7 @@ public static Vector256 WidenLower(Vector256 source) ); } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3470,7 +3470,7 @@ public static Vector256 WidenLower(Vector256 source) ); } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3485,7 +3485,7 @@ public static Vector256 WidenLower(Vector256 source) Vector128.WidenUpper(lower) ); } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3500,7 +3500,7 @@ public static Vector256 WidenLower(Vector256 source) ); } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3516,7 +3516,7 @@ public static Vector256 WidenLower(Vector256 source) ); } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3532,7 +3532,7 @@ public static Vector256 WidenLower(Vector256 source) ); } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3548,7 +3548,7 @@ public static Vector256 WidenUpper(Vector256 source) ); } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3563,7 +3563,7 @@ public static Vector256 WidenUpper(Vector256 source) ); } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3578,7 +3578,7 @@ public static Vector256 WidenUpper(Vector256 source) ); } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3594,7 +3594,7 @@ public static Vector256 WidenUpper(Vector256 source) ); } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3609,7 +3609,7 @@ public static Vector256 WidenUpper(Vector256 source) ); } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3625,7 +3625,7 @@ public static Vector256 WidenUpper(Vector256 source) ); } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256_1.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256_1.cs index 52df8ffcaf4..b4c2996484f 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256_1.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector256_1.cs @@ -143,7 +143,7 @@ public static Vector256 Zero /// Computes the bitwise-and of two vectors. /// The vector to bitwise-and with . /// The vector to bitwise-and with . - /// The bitwise-and of and . + /// The bitwise-and of and . /// The type of the vector () is not supported. [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -158,7 +158,7 @@ public static Vector256 Zero /// Computes the bitwise-or of two vectors. /// The vector to bitwise-or with . /// The vector to bitwise-or with . - /// The bitwise-or of and . + /// The bitwise-or of and . /// The type of the vector () is not supported. [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512.cs index 10e6d278594..2b683f06524 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512.cs @@ -98,11 +98,11 @@ public static Vector512 Abs(Vector512 vector) [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector512 AndNot(Vector512 left, Vector512 right) => left & ~right; - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the input vector. /// The type of the elements in the output vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () or the type of the target () is not supported. [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -118,102 +118,102 @@ public static Vector512 As(this Vector512 vector) #endif } - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector512 AsByte(this Vector512 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector512 AsDouble(this Vector512 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector512 AsInt16(this Vector512 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector512 AsInt32(this Vector512 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector512 AsInt64(this Vector512 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector512 AsNInt(this Vector512 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static Vector512 AsNUInt(this Vector512 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static Vector512 AsSByte(this Vector512 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector512 AsSingle(this Vector512 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static Vector512 AsUInt16(this Vector512 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static Vector512 AsUInt32(this Vector512 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] @@ -256,7 +256,7 @@ public static Vector AsVector(this Vector512 value) /// The type of the elements in the vector. /// The vector to bitwise-and with . /// The vector to bitwise-and with . - /// The bitwise-and of and . + /// The bitwise-and of and . /// The type of and () is not supported. [Intrinsic] public static Vector512 BitwiseAnd(Vector512 left, Vector512 right) => left & right; @@ -265,7 +265,7 @@ public static Vector AsVector(this Vector512 value) /// The type of the elements in the vector. /// The vector to bitwise-or with . /// The vector to bitwise-or with . - /// The bitwise-or of and . + /// The bitwise-or of and . /// The type of and () is not supported. [Intrinsic] public static Vector512 BitwiseOr(Vector512 left, Vector512 right) => left | right; @@ -340,7 +340,7 @@ public static Vector512 ClampNative(Vector512 value, Vector512 min, [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector512 ConditionalSelect(Vector512 condition, Vector512 left, Vector512 right) => (left & condition) | AndNot(right, condition); - /// Converts a to a . + /// Converts a to a . /// The vector to convert. /// The converted vector. [Intrinsic] @@ -353,7 +353,7 @@ public static Vector512 ConvertToDouble(Vector512 vector) ); } - /// Converts a to a . + /// Converts a to a . /// The vector to convert. /// The converted vector. [Intrinsic] @@ -367,7 +367,7 @@ public static Vector512 ConvertToDouble(Vector512 vector) ); } - /// Converts a to a using saturation on overflow. + /// Converts a to a using saturation on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -380,7 +380,7 @@ public static Vector512 ConvertToInt32(Vector512 vector) ); } - /// Converts a to a using platform specific behavior on overflow. + /// Converts a to a using platform specific behavior on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -393,7 +393,7 @@ public static Vector512 ConvertToInt32Native(Vector512 vector) ); } - /// Converts a to a using saturation on overflow. + /// Converts a to a using saturation on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -406,7 +406,7 @@ public static Vector512 ConvertToInt64(Vector512 vector) ); } - /// Converts a to a using platform specific behavior on overflow. + /// Converts a to a using platform specific behavior on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -419,7 +419,7 @@ public static Vector512 ConvertToInt64Native(Vector512 vector) ); } - /// Converts a to a . + /// Converts a to a . /// The vector to convert. /// The converted vector. [Intrinsic] @@ -432,7 +432,7 @@ public static Vector512 ConvertToSingle(Vector512 vector) ); } - /// Converts a to a . + /// Converts a to a . /// The vector to convert. /// The converted vector. [Intrinsic] @@ -446,7 +446,7 @@ public static Vector512 ConvertToSingle(Vector512 vector) ); } - /// Converts a to a using saturation on overflow. + /// Converts a to a using saturation on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -460,7 +460,7 @@ public static Vector512 ConvertToUInt32(Vector512 vector) ); } - /// Converts a to a using platform specific behavior on overflow. + /// Converts a to a using platform specific behavior on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -474,7 +474,7 @@ public static Vector512 ConvertToUInt32Native(Vector512 vector) ); } - /// Converts a to a using saturation on overflow. + /// Converts a to a using saturation on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -488,7 +488,7 @@ public static Vector512 ConvertToUInt64(Vector512 vector) ); } - /// Converts a to a using platform specific behavior on overflow. + /// Converts a to a using platform specific behavior on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -635,88 +635,88 @@ public static Vector512 Create(T value) return Create(vector, vector); } - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m512i _mm512_set1_epi8 [Intrinsic] public static Vector512 Create(byte value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m512d _mm512_set1_pd [Intrinsic] public static Vector512 Create(double value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m512i _mm512_set1_epi16 [Intrinsic] public static Vector512 Create(short value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m512i _mm512_set1_epi32 [Intrinsic] public static Vector512 Create(int value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m512i _mm512_set1_epi64x [Intrinsic] public static Vector512 Create(long value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . [Intrinsic] public static Vector512 Create(nint value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . [Intrinsic] [CLSCompliant(false)] public static Vector512 Create(nuint value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m512i _mm512_set1_epi8 [Intrinsic] [CLSCompliant(false)] public static Vector512 Create(sbyte value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m512 _mm512_set1_ps [Intrinsic] public static Vector512 Create(float value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m512i _mm512_set1_epi16 [Intrinsic] [CLSCompliant(false)] public static Vector512 Create(ushort value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m512i _mm512_set1_epi32 [Intrinsic] [CLSCompliant(false)] public static Vector512 Create(uint value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . /// On x86, this method corresponds to __m512i _mm512_set1_epi64x [Intrinsic] [CLSCompliant(false)] @@ -778,7 +778,7 @@ public static Vector512 Create(ReadOnlySpan values) return Unsafe.ReadUnaligned>(ref Unsafe.As(ref MemoryMarshal.GetReference(values))); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. @@ -843,7 +843,7 @@ public static Vector512 Create(ReadOnlySpan values) /// The value that element 61 will be initialized to. /// The value that element 62 will be initialized to. /// The value that element 63 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m512i _mm512_setr_epi8 [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -858,7 +858,7 @@ public static Vector512 Create(byte e0, byte e1, byte e2, byte e3, byt ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. @@ -867,7 +867,7 @@ public static Vector512 Create(byte e0, byte e1, byte e2, byte e3, byt /// The value that element 5 will be initialized to. /// The value that element 6 will be initialized to. /// The value that element 7 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m512d _mm512_setr_pd [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -879,7 +879,7 @@ public static Vector512 Create(double e0, double e1, double e2, double e ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. @@ -912,7 +912,7 @@ public static Vector512 Create(double e0, double e1, double e2, double e /// The value that element 29 will be initialized to. /// The value that element 30 will be initialized to. /// The value that element 31 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m512i _mm512_setr_epi16 [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -925,7 +925,7 @@ public static Vector512 Create(short e0, short e1, short e2, short e3, ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. @@ -942,7 +942,7 @@ public static Vector512 Create(short e0, short e1, short e2, short e3, /// The value that element 13 will be initialized to. /// The value that element 14 will be initialized to. /// The value that element 15 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m512i _mm512_setr_epi32 [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -954,7 +954,7 @@ public static Vector512 Create(int e0, int e1, int e2, int e3, int e4, int ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. @@ -963,7 +963,7 @@ public static Vector512 Create(int e0, int e1, int e2, int e3, int e4, int /// The value that element 5 will be initialized to. /// The value that element 6 will be initialized to. /// The value that element 7 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m512i _mm512_setr_epi64x [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -975,7 +975,7 @@ public static Vector512 Create(long e0, long e1, long e2, long e3, long e4 ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. @@ -1040,7 +1040,7 @@ public static Vector512 Create(long e0, long e1, long e2, long e3, long e4 /// The value that element 61 will be initialized to. /// The value that element 62 will be initialized to. /// The value that element 63 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m512i _mm512_setr_epi8 [Intrinsic] [CLSCompliant(false)] @@ -1056,7 +1056,7 @@ public static Vector512 Create(sbyte e0, sbyte e1, sbyte e2, sbyte e3, ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. @@ -1073,7 +1073,7 @@ public static Vector512 Create(sbyte e0, sbyte e1, sbyte e2, sbyte e3, /// The value that element 13 will be initialized to. /// The value that element 14 will be initialized to. /// The value that element 15 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m512 _mm512_setr_ps [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -1085,7 +1085,7 @@ public static Vector512 Create(float e0, float e1, float e2, float e3, fl ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. @@ -1118,7 +1118,7 @@ public static Vector512 Create(float e0, float e1, float e2, float e3, fl /// The value that element 29 will be initialized to. /// The value that element 30 will be initialized to. /// The value that element 31 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m512i _mm512_setr_epi16 [Intrinsic] [CLSCompliant(false)] @@ -1132,7 +1132,7 @@ public static Vector512 Create(ushort e0, ushort e1, ushort e2, ushor ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. @@ -1149,7 +1149,7 @@ public static Vector512 Create(ushort e0, ushort e1, ushort e2, ushor /// The value that element 13 will be initialized to. /// The value that element 14 will be initialized to. /// The value that element 15 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m512i _mm512_setr_epi32 [Intrinsic] [CLSCompliant(false)] @@ -1162,7 +1162,7 @@ public static Vector512 Create(uint e0, uint e1, uint e2, uint e3, uint e4 ); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. @@ -1171,7 +1171,7 @@ public static Vector512 Create(uint e0, uint e1, uint e2, uint e3, uint e4 /// The value that element 5 will be initialized to. /// The value that element 6 will be initialized to. /// The value that element 7 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. /// On x86, this method corresponds to __m512i _mm512_setr_epi64x [Intrinsic] [CLSCompliant(false)] @@ -1226,84 +1226,84 @@ public static Vector512 Create(Vector256 lower, Vector256 upper) return result; } - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 256-bits will be initialized to. /// The value that the upper 256-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . public static Vector512 Create(Vector256 lower, Vector256 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 256-bits will be initialized to. /// The value that the upper 256-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . /// On x86, this method corresponds to __m512d _mm512_setr_m256d (__m256d lo, __m256d hi) public static Vector512 Create(Vector256 lower, Vector256 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 256-bits will be initialized to. /// The value that the upper 256-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . public static Vector512 Create(Vector256 lower, Vector256 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 256-bits will be initialized to. /// The value that the upper 256-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . /// On x86, this method corresponds to __m512i _mm512_setr_m256i (__m256i lo, __m256i hi) public static Vector512 Create(Vector256 lower, Vector256 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 256-bits will be initialized to. /// The value that the upper 256-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . public static Vector512 Create(Vector256 lower, Vector256 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 256-bits will be initialized to. /// The value that the upper 256-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . public static Vector512 Create(Vector256 lower, Vector256 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 256-bits will be initialized to. /// The value that the upper 256-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . [CLSCompliant(false)] public static Vector512 Create(Vector256 lower, Vector256 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 256-bits will be initialized to. /// The value that the upper 256-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . [CLSCompliant(false)] public static Vector512 Create(Vector256 lower, Vector256 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 256-bits will be initialized to. /// The value that the upper 256-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . /// On x86, this method corresponds to __m512 _mm512_setr_m256 (__m256 lo, __m256 hi) public static Vector512 Create(Vector256 lower, Vector256 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 256-bits will be initialized to. /// The value that the upper 256-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . [CLSCompliant(false)] public static Vector512 Create(Vector256 lower, Vector256 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 256-bits will be initialized to. /// The value that the upper 256-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . /// On x86, this method corresponds to __m512i _mm512_setr_m256i (__m256i lo, __m256i hi) [CLSCompliant(false)] public static Vector512 Create(Vector256 lower, Vector256 upper) => Create(lower, upper); - /// Creates a new instance from two instances. + /// Creates a new instance from two instances. /// The value that the lower 256-bits will be initialized to. /// The value that the upper 256-bits will be initialized to. - /// A new initialized from and . + /// A new initialized from and . [CLSCompliant(false)] public static Vector512 Create(Vector256 lower, Vector256 upper) => Create(lower, upper); @@ -1315,79 +1315,79 @@ public static Vector512 Create(Vector256 lower, Vector256 upper) [Intrinsic] public static Vector512 CreateScalar(T value) => Vector256.CreateScalar(value).ToVector512(); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static Vector512 CreateScalar(byte value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static Vector512 CreateScalar(double value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static Vector512 CreateScalar(short value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static Vector512 CreateScalar(int value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static Vector512 CreateScalar(long value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static Vector512 CreateScalar(nint value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] [CLSCompliant(false)] public static Vector512 CreateScalar(nuint value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] [CLSCompliant(false)] public static Vector512 CreateScalar(sbyte value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static Vector512 CreateScalar(float value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] [CLSCompliant(false)] public static Vector512 CreateScalar(ushort value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] [CLSCompliant(false)] public static Vector512 CreateScalar(uint value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] [CLSCompliant(false)] public static Vector512 CreateScalar(ulong value) => CreateScalar(value); @@ -1411,79 +1411,79 @@ public static Vector512 CreateScalarUnsafe(T value) return result; } - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static Vector512 CreateScalarUnsafe(byte value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static Vector512 CreateScalarUnsafe(double value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static Vector512 CreateScalarUnsafe(short value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static Vector512 CreateScalarUnsafe(int value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static Vector512 CreateScalarUnsafe(long value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static Vector512 CreateScalarUnsafe(nint value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] [CLSCompliant(false)] public static Vector512 CreateScalarUnsafe(nuint value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] [CLSCompliant(false)] public static Vector512 CreateScalarUnsafe(sbyte value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static Vector512 CreateScalarUnsafe(float value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] [CLSCompliant(false)] public static Vector512 CreateScalarUnsafe(ushort value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] [CLSCompliant(false)] public static Vector512 CreateScalarUnsafe(uint value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] [CLSCompliant(false)] public static Vector512 CreateScalarUnsafe(ulong value) => CreateScalarUnsafe(value); @@ -2159,12 +2159,12 @@ public static Vector512 LoadUnsafe(ref readonly T source, nuint elementOff return Unsafe.ReadUnaligned>(in address); } - /// Loads a vector from the given source and reinterprets it as . + /// Loads a vector from the given source and reinterprets it as . /// The source from which the vector will be loaded. /// The vector loaded from . internal static Vector512 LoadUnsafe(ref char source) => LoadUnsafe(ref Unsafe.As(ref source)); - /// Loads a vector from the given source and element offset and reinterprets it as . + /// Loads a vector from the given source and element offset and reinterprets it as . /// The source to which will be added before loading the vector. /// The element offset from from which the vector will be loaded. /// The vector loaded from plus . @@ -2476,10 +2476,10 @@ public static Vector512 MultiplyAddEstimate(Vector512 left, Vector ); } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector512 Narrow(Vector512 lower, Vector512 upper) @@ -2490,10 +2490,10 @@ public static Vector512 Narrow(Vector512 lower, Vector512 ); } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -2505,10 +2505,10 @@ public static Vector512 Narrow(Vector512 lower, Vector512 u ); } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector512 Narrow(Vector512 lower, Vector512 upper) @@ -2519,10 +2519,10 @@ public static Vector512 Narrow(Vector512 lower, Vector512 upper ); } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector512 Narrow(Vector512 lower, Vector512 upper) @@ -2533,10 +2533,10 @@ public static Vector512 Narrow(Vector512 lower, Vector512 upper ); } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -2548,10 +2548,10 @@ public static Vector512 Narrow(Vector512 lower, Vector512 ); } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -2563,10 +2563,10 @@ public static Vector512 Narrow(Vector512 lower, Vector512 up ); } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -3371,53 +3371,53 @@ public static bool TryCopyTo(this Vector512 vector, Span destination) return true; } - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static (Vector512 Lower, Vector512 Upper) Widen(Vector512 source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [MethodImpl(MethodImplOptions.AggressiveInlining)] public static (Vector512 Lower, Vector512 Upper) Widen(Vector512 source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [MethodImpl(MethodImplOptions.AggressiveInlining)] public static (Vector512 Lower, Vector512 Upper) Widen(Vector512 source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static (Vector512 Lower, Vector512 Upper) Widen(Vector512 source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [MethodImpl(MethodImplOptions.AggressiveInlining)] public static (Vector512 Lower, Vector512 Upper) Widen(Vector512 source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static (Vector512 Lower, Vector512 Upper) Widen(Vector512 source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static (Vector512 Lower, Vector512 Upper) Widen(Vector512 source) => (WidenLower(source), WidenUpper(source)); - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3433,7 +3433,7 @@ public static Vector512 WidenLower(Vector512 source) ); } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3448,7 +3448,7 @@ public static Vector512 WidenLower(Vector512 source) ); } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3463,7 +3463,7 @@ public static Vector512 WidenLower(Vector512 source) ); } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3478,7 +3478,7 @@ public static Vector512 WidenLower(Vector512 source) Vector256.WidenUpper(lower) ); } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3493,7 +3493,7 @@ public static Vector512 WidenLower(Vector512 source) ); } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3509,7 +3509,7 @@ public static Vector512 WidenLower(Vector512 source) ); } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3525,7 +3525,7 @@ public static Vector512 WidenLower(Vector512 source) ); } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3541,7 +3541,7 @@ public static Vector512 WidenUpper(Vector512 source) ); } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3556,7 +3556,7 @@ public static Vector512 WidenUpper(Vector512 source) ); } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3571,7 +3571,7 @@ public static Vector512 WidenUpper(Vector512 source) ); } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3587,7 +3587,7 @@ public static Vector512 WidenUpper(Vector512 source) ); } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3602,7 +3602,7 @@ public static Vector512 WidenUpper(Vector512 source) ); } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3618,7 +3618,7 @@ public static Vector512 WidenUpper(Vector512 source) ); } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512_1.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512_1.cs index e70dca3d3d6..2105c18257a 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512_1.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector512_1.cs @@ -143,7 +143,7 @@ public static Vector512 Zero /// Computes the bitwise-and of two vectors. /// The vector to bitwise-and with . /// The vector to bitwise-and with . - /// The bitwise-and of and . + /// The bitwise-and of and . /// The type of the vector () is not supported. [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -158,7 +158,7 @@ public static Vector512 Zero /// Computes the bitwise-or of two vectors. /// The vector to bitwise-or with . /// The vector to bitwise-or with . - /// The bitwise-or of and . + /// The bitwise-or of and . /// The type of the vector () is not supported. [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64.cs index dfd95f4021d..570933c7abb 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64.cs @@ -76,11 +76,11 @@ public static Vector64 Abs(Vector64 vector) [Intrinsic] public static Vector64 AndNot(Vector64 left, Vector64 right) => left & ~right; - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the input vector. /// The type of the elements in the output vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () or the type of the target () is not supported. [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -96,102 +96,102 @@ public static Vector64 As(this Vector64 vector) #endif } - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector64 AsByte(this Vector64 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector64 AsDouble(this Vector64 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector64 AsInt16(this Vector64 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector64 AsInt32(this Vector64 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector64 AsInt64(this Vector64 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector64 AsNInt(this Vector64 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static Vector64 AsNUInt(this Vector64 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static Vector64 AsSByte(this Vector64 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] public static Vector64 AsSingle(this Vector64 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static Vector64 AsUInt16(this Vector64 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] public static Vector64 AsUInt32(this Vector64 vector) => vector.As(); - /// Reinterprets a as a new . + /// Reinterprets a as a new . /// The type of the elements in the vector. /// The vector to reinterpret. - /// reinterpreted as a new . + /// reinterpreted as a new . /// The type of () is not supported. [Intrinsic] [CLSCompliant(false)] @@ -201,7 +201,7 @@ public static Vector64 As(this Vector64 vector) /// The type of the elements in the vector. /// The vector to bitwise-and with . /// The vector to bitwise-and with . - /// The bitwise-and of and . + /// The bitwise-and of and . /// The type of and () is not supported. [Intrinsic] public static Vector64 BitwiseAnd(Vector64 left, Vector64 right) => left & right; @@ -210,7 +210,7 @@ public static Vector64 As(this Vector64 vector) /// The type of the elements in the vector. /// The vector to bitwise-or with . /// The vector to bitwise-or with . - /// The bitwise-or of and . + /// The bitwise-or of and . /// The type of and () is not supported. [Intrinsic] public static Vector64 BitwiseOr(Vector64 left, Vector64 right) => left | right; @@ -290,7 +290,7 @@ public static Vector64 ClampNative(Vector64 value, Vector64 min, Vec [MethodImpl(MethodImplOptions.AggressiveInlining)] public static Vector64 ConditionalSelect(Vector64 condition, Vector64 left, Vector64 right) => (left & condition) | AndNot(right, condition); - /// Converts a to a . + /// Converts a to a . /// The vector to convert. /// The converted vector. [Intrinsic] @@ -308,7 +308,7 @@ public static unsafe Vector64 ConvertToDouble(Vector64 vector) return result; } - /// Converts a to a . + /// Converts a to a . /// The vector to convert. /// The converted vector. [Intrinsic] @@ -327,7 +327,7 @@ public static unsafe Vector64 ConvertToDouble(Vector64 vector) return result; } - /// Converts a to a using saturation on overflow. + /// Converts a to a using saturation on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -345,7 +345,7 @@ public static unsafe Vector64 ConvertToInt32(Vector64 vector) return result; } - /// Converts a to a using platform specific behavior on overflow. + /// Converts a to a using platform specific behavior on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -363,7 +363,7 @@ public static unsafe Vector64 ConvertToInt32Native(Vector64 vector) return result; } - /// Converts a to a using saturation on overflow. + /// Converts a to a using saturation on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -381,7 +381,7 @@ public static unsafe Vector64 ConvertToInt64(Vector64 vector) return result; } - /// Converts a to a using platform specific behavior on overflow. + /// Converts a to a using platform specific behavior on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -399,7 +399,7 @@ public static unsafe Vector64 ConvertToInt64Native(Vector64 vector return result; } - /// Converts a to a . + /// Converts a to a . /// The vector to convert. /// The converted vector. [Intrinsic] @@ -417,7 +417,7 @@ public static unsafe Vector64 ConvertToSingle(Vector64 vector) return result; } - /// Converts a to a . + /// Converts a to a . /// The vector to convert. /// The converted vector. [Intrinsic] @@ -436,7 +436,7 @@ public static unsafe Vector64 ConvertToSingle(Vector64 vector) return result; } - /// Converts a to a using saturation on overflow. + /// Converts a to a using saturation on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -455,7 +455,7 @@ public static unsafe Vector64 ConvertToUInt32(Vector64 vector) return result; } - /// Converts a to a using platform specific behavior on overflow. + /// Converts a to a using platform specific behavior on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -474,7 +474,7 @@ public static unsafe Vector64 ConvertToUInt32Native(Vector64 vector return result; } - /// Converts a to a using saturation on overflow. + /// Converts a to a using saturation on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -493,7 +493,7 @@ public static unsafe Vector64 ConvertToUInt64(Vector64 vector) return result; } - /// Converts a to a using platform specific behavior on overflow. + /// Converts a to a using platform specific behavior on overflow. /// The vector to convert. /// The converted vector. [Intrinsic] @@ -678,85 +678,85 @@ public static unsafe Vector64 Create(T value) return result; } - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. /// On x86, this method corresponds to __m64 _mm_set1_pi8 - /// A new with all elements initialized to . + /// A new with all elements initialized to . [Intrinsic] public static unsafe Vector64 Create(byte value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . [Intrinsic] public static unsafe Vector64 Create(double value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. /// On x86, this method corresponds to __m64 _mm_set1_pi16 - /// A new with all elements initialized to . + /// A new with all elements initialized to . [Intrinsic] public static unsafe Vector64 Create(short value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. /// On x86, this method corresponds to __m64 _mm_set1_pi32 - /// A new with all elements initialized to . + /// A new with all elements initialized to . [Intrinsic] public static unsafe Vector64 Create(int value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . [Intrinsic] public static unsafe Vector64 Create(long value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . [Intrinsic] public static unsafe Vector64 Create(nint value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . [Intrinsic] [CLSCompliant(false)] public static unsafe Vector64 Create(nuint value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. /// On x86, this method corresponds to __m64 _mm_set1_pi8 - /// A new with all elements initialized to . + /// A new with all elements initialized to . [Intrinsic] [CLSCompliant(false)] public static unsafe Vector64 Create(sbyte value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . [Intrinsic] public static unsafe Vector64 Create(float value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. /// On x86, this method corresponds to __m64 _mm_set1_pi16 - /// A new with all elements initialized to . + /// A new with all elements initialized to . [Intrinsic] [CLSCompliant(false)] public static unsafe Vector64 Create(ushort value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. /// On x86, this method corresponds to __m64 _mm_set1_pi32 - /// A new with all elements initialized to . + /// A new with all elements initialized to . [Intrinsic] [CLSCompliant(false)] public static unsafe Vector64 Create(uint value) => Create(value); - /// Creates a new instance with all elements initialized to the specified value. + /// Creates a new instance with all elements initialized to the specified value. /// The value that all elements will be initialized to. - /// A new with all elements initialized to . + /// A new with all elements initialized to . [Intrinsic] [CLSCompliant(false)] public static unsafe Vector64 Create(ulong value) => Create(value); @@ -819,7 +819,7 @@ public static Vector64 Create(ReadOnlySpan values) return Unsafe.ReadUnaligned>(ref Unsafe.As(ref MemoryMarshal.GetReference(values))); } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. @@ -829,7 +829,7 @@ public static Vector64 Create(ReadOnlySpan values) /// The value that element 6 will be initialized to. /// The value that element 7 will be initialized to. /// On x86, this method corresponds to __m64 _mm_setr_pi8 - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe Vector64 Create(byte e0, byte e1, byte e2, byte e3, byte e4, byte e5, byte e6, byte e7) @@ -846,13 +846,13 @@ public static unsafe Vector64 Create(byte e0, byte e1, byte e2, byte e3, b return result; } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. /// The value that element 3 will be initialized to. /// On x86, this method corresponds to __m64 _mm_setr_pi16 - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe Vector64 Create(short e0, short e1, short e2, short e3) @@ -865,11 +865,11 @@ public static unsafe Vector64 Create(short e0, short e1, short e2, short return result; } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// On x86, this method corresponds to __m64 _mm_setr_pi32 - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe Vector64 Create(int e0, int e1) @@ -880,7 +880,7 @@ public static unsafe Vector64 Create(int e0, int e1) return result; } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. @@ -890,7 +890,7 @@ public static unsafe Vector64 Create(int e0, int e1) /// The value that element 6 will be initialized to. /// The value that element 7 will be initialized to. /// On x86, this method corresponds to __m64 _mm_setr_pi8 - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. [Intrinsic] [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -908,10 +908,10 @@ public static unsafe Vector64 Create(sbyte e0, sbyte e1, sbyte e2, sbyte return result; } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe Vector64 Create(float e0, float e1) @@ -922,13 +922,13 @@ public static unsafe Vector64 Create(float e0, float e1) return result; } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// The value that element 2 will be initialized to. /// The value that element 3 will be initialized to. /// On x86, this method corresponds to __m64 _mm_setr_pi16 - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. [Intrinsic] [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -942,11 +942,11 @@ public static unsafe Vector64 Create(ushort e0, ushort e1, ushort e2, us return result; } - /// Creates a new instance with each element initialized to the corresponding specified value. + /// Creates a new instance with each element initialized to the corresponding specified value. /// The value that element 0 will be initialized to. /// The value that element 1 will be initialized to. /// On x86, this method corresponds to __m64 _mm_setr_pi32 - /// A new with each element initialized to corresponding specified value. + /// A new with each element initialized to corresponding specified value. [Intrinsic] [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -961,7 +961,7 @@ public static unsafe Vector64 Create(uint e0, uint e1) /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The type of the elements in the vector. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. /// The type of () is not supported. [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -972,79 +972,79 @@ public static unsafe Vector64 CreateScalar(T value) return result; } - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static unsafe Vector64 CreateScalar(byte value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static unsafe Vector64 CreateScalar(double value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static unsafe Vector64 CreateScalar(short value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static unsafe Vector64 CreateScalar(int value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static unsafe Vector64 CreateScalar(long value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static unsafe Vector64 CreateScalar(nint value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] [CLSCompliant(false)] public static unsafe Vector64 CreateScalar(nuint value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] [CLSCompliant(false)] public static unsafe Vector64 CreateScalar(sbyte value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] public static unsafe Vector64 CreateScalar(float value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] [CLSCompliant(false)] public static unsafe Vector64 CreateScalar(ushort value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] [CLSCompliant(false)] public static unsafe Vector64 CreateScalar(uint value) => CreateScalar(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements initialized to zero. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements initialized to zero. + /// A new instance with the first element initialized to and the remaining elements initialized to zero. [Intrinsic] [CLSCompliant(false)] public static unsafe Vector64 CreateScalar(ulong value) => CreateScalar(value); @@ -1068,79 +1068,79 @@ public static Vector64 CreateScalarUnsafe(T value) return result; } - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static unsafe Vector64 CreateScalarUnsafe(byte value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static unsafe Vector64 CreateScalarUnsafe(double value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static unsafe Vector64 CreateScalarUnsafe(short value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static unsafe Vector64 CreateScalarUnsafe(int value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static unsafe Vector64 CreateScalarUnsafe(long value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static unsafe Vector64 CreateScalarUnsafe(nint value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] [CLSCompliant(false)] public static unsafe Vector64 CreateScalarUnsafe(nuint value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] [CLSCompliant(false)] public static unsafe Vector64 CreateScalarUnsafe(sbyte value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] public static unsafe Vector64 CreateScalarUnsafe(float value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] [CLSCompliant(false)] public static unsafe Vector64 CreateScalarUnsafe(ushort value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] [CLSCompliant(false)] public static unsafe Vector64 CreateScalarUnsafe(uint value) => CreateScalarUnsafe(value); - /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. + /// Creates a new instance with the first element initialized to the specified value and the remaining elements left uninitialized. /// The value that element 0 will be initialized to. - /// A new instance with the first element initialized to and the remaining elements left uninitialized. + /// A new instance with the first element initialized to and the remaining elements left uninitialized. [Intrinsic] [CLSCompliant(false)] public static unsafe Vector64 CreateScalarUnsafe(ulong value) => CreateScalarUnsafe(value); @@ -1401,14 +1401,14 @@ internal static Vector64 Floor(Vector64 vector) [Intrinsic] public static Vector64 Floor(Vector64 vector) => Floor(vector); - /// Computes ( * ) + , rounded as one ternary operation. + /// Computes ( * ) + , rounded as one ternary operation. /// The vector to be multiplied with . /// The vector to be multiplied with . /// The vector to be added to the result of multiplied by . - /// ( * ) + , rounded as one ternary operation. + /// ( * ) + , rounded as one ternary operation. /// - /// This computes ( * ) as if to infinite precision, adds to that result as if to infinite precision, and finally rounds to the nearest representable value. - /// This differs from the non-fused sequence which would compute ( * ) as if to infinite precision, round the result to the nearest representable value, add to the rounded result as if to infinite precision, and finally round to the nearest representable value. + /// This computes ( * ) as if to infinite precision, adds to that result as if to infinite precision, and finally rounds to the nearest representable value. + /// This differs from the non-fused sequence which would compute ( * ) as if to infinite precision, round the result to the nearest representable value, add to the rounded result as if to infinite precision, and finally round to the nearest representable value. /// [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -1425,14 +1425,14 @@ public static Vector64 FusedMultiplyAdd(Vector64 left, Vector64< return result; } - /// Computes ( * ) + , rounded as one ternary operation. + /// Computes ( * ) + , rounded as one ternary operation. /// The vector to be multiplied with . /// The vector to be multiplied with . /// The vector to be added to the result of multiplied by . - /// ( * ) + , rounded as one ternary operation. + /// ( * ) + , rounded as one ternary operation. /// - /// This computes ( * ) as if to infinite precision, adds to that result as if to infinite precision, and finally rounds to the nearest representable value. - /// This differs from the non-fused sequence which would compute ( * ) as if to infinite precision, round the result to the nearest representable value, add to the rounded result as if to infinite precision, and finally round to the nearest representable value. + /// This computes ( * ) as if to infinite precision, adds to that result as if to infinite precision, and finally rounds to the nearest representable value. + /// This differs from the non-fused sequence which would compute ( * ) as if to infinite precision, round the result to the nearest representable value, add to the rounded result as if to infinite precision, and finally round to the nearest representable value. /// [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -2310,7 +2310,7 @@ public static Vector64 MinNumber(Vector64 left, Vector64 right) /// The vector to multiply with . /// The vector to multiply with . /// The element-wise product of and . - /// The type of and () is not supported. + /// The type of and () is not supported. [Intrinsic] public static Vector64 Multiply(Vector64 left, Vector64 right) => left * right; @@ -2319,7 +2319,7 @@ public static Vector64 MinNumber(Vector64 left, Vector64 right) /// The vector to multiply with . /// The scalar to multiply with . /// The product of and . - /// The type of and () is not supported. + /// The type of and () is not supported. [Intrinsic] public static Vector64 Multiply(Vector64 left, T right) => left * right; @@ -2328,7 +2328,7 @@ public static Vector64 MinNumber(Vector64 left, Vector64 right) /// The scalar to multiply with . /// The vector to multiply with . /// The product of and . - /// The type of and () is not supported. + /// The type of and () is not supported. [Intrinsic] public static Vector64 Multiply(T left, Vector64 right) => right * left; @@ -2347,14 +2347,14 @@ internal static Vector64 MultiplyAddEstimate(Vector64 left, Vector64 return result; } - /// Computes an estimate of ( * ) + . + /// Computes an estimate of ( * ) + . /// The vector to be multiplied with . /// The vector to be multiplied with . /// The vector to be added to the result of multiplied by . - /// An estimate of ( * ) + . + /// An estimate of ( * ) + . /// /// On hardware that natively supports , this may return a result that was rounded as one ternary operation. - /// On hardware without specialized support, this may just return ( * ) + . + /// On hardware without specialized support, this may just return ( * ) + . /// [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -2371,14 +2371,14 @@ public static Vector64 MultiplyAddEstimate(Vector64 left, Vector return result; } - /// Computes an estimate of ( * ) + . + /// Computes an estimate of ( * ) + . /// The vector to be multiplied with . /// The vector to be multiplied with . /// The vector to be added to the result of multiplied by . - /// An estimate of ( * ) + . + /// An estimate of ( * ) + . /// /// On hardware that natively supports , this may return a result that was rounded as one ternary operation. - /// On hardware without specialized support, this may just return ( * ) + . + /// On hardware without specialized support, this may just return ( * ) + . /// [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -2395,10 +2395,10 @@ public static Vector64 MultiplyAddEstimate(Vector64 left, Vector64 return result; } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe Vector64 Narrow(Vector64 lower, Vector64 upper) @@ -2420,10 +2420,10 @@ public static unsafe Vector64 Narrow(Vector64 lower, Vector64Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -2446,10 +2446,10 @@ public static unsafe Vector64 Narrow(Vector64 lower, Vector64Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe Vector64 Narrow(Vector64 lower, Vector64 upper) @@ -2471,10 +2471,10 @@ public static unsafe Vector64 Narrow(Vector64 lower, Vector64 u return result; } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe Vector64 Narrow(Vector64 lower, Vector64 upper) @@ -2496,10 +2496,10 @@ public static unsafe Vector64 Narrow(Vector64 lower, Vector64 u return result; } - /// Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -2522,10 +2522,10 @@ public static unsafe Vector64 Narrow(Vector64 lower, Vector64Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -2548,10 +2548,10 @@ public static unsafe Vector64 Narrow(Vector64 lower, Vector64Narrows two instances into one . + /// Narrows two instances into one . /// The vector that will be narrowed to the lower half of the result vector. /// The vector that will be narrowed to the upper half of the result vector. - /// A containing elements narrowed from and . + /// A containing elements narrowed from and . [Intrinsic] [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -3398,53 +3398,53 @@ public static bool TryCopyTo(this Vector64 vector, Span destination) return true; } - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe (Vector64 Lower, Vector64 Upper) Widen(Vector64 source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe (Vector64 Lower, Vector64 Upper) Widen(Vector64 source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe (Vector64 Lower, Vector64 Upper) Widen(Vector64 source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe (Vector64 Lower, Vector64 Upper) Widen(Vector64 source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe (Vector64 Lower, Vector64 Upper) Widen(Vector64 source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe (Vector64 Lower, Vector64 Upper) Widen(Vector64 source) => (WidenLower(source), WidenUpper(source)); - /// Widens a into two . + /// Widens a into two . /// The vector whose elements are to be widened. /// A pair of vectors that contain the widened lower and upper halves of . [CLSCompliant(false)] [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe (Vector64 Lower, Vector64 Upper) Widen(Vector64 source) => (WidenLower(source), WidenUpper(source)); - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3463,7 +3463,7 @@ public static Vector64 WidenLower(Vector64 source) return lower; } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3481,7 +3481,7 @@ public static unsafe Vector64 WidenLower(Vector64 source) return lower; } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3499,7 +3499,7 @@ public static unsafe Vector64 WidenLower(Vector64 source) return lower; } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3518,7 +3518,7 @@ public static unsafe Vector64 WidenLower(Vector64 source) return lower; } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3536,7 +3536,7 @@ public static unsafe Vector64 WidenLower(Vector64 source) return lower; } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3555,7 +3555,7 @@ public static unsafe Vector64 WidenLower(Vector64 source) return lower; } - /// Widens the lower half of a into a . + /// Widens the lower half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened lower half of . [Intrinsic] @@ -3574,7 +3574,7 @@ public static unsafe Vector64 WidenLower(Vector64 source) return lower; } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3593,7 +3593,7 @@ public static Vector64 WidenUpper(Vector64 source) return upper; } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3611,7 +3611,7 @@ public static unsafe Vector64 WidenUpper(Vector64 source) return upper; } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3629,7 +3629,7 @@ public static unsafe Vector64 WidenUpper(Vector64 source) return upper; } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3648,7 +3648,7 @@ public static unsafe Vector64 WidenUpper(Vector64 source) return upper; } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3666,7 +3666,7 @@ public static unsafe Vector64 WidenUpper(Vector64 source) return upper; } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] @@ -3685,7 +3685,7 @@ public static unsafe Vector64 WidenUpper(Vector64 source) return upper; } - /// Widens the upper half of a into a . + /// Widens the upper half of a into a . /// The vector whose elements are to be widened. /// A vector that contain the widened upper half of . [Intrinsic] diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64_1.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64_1.cs index db281b582aa..f7c447195e0 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64_1.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Vector64_1.cs @@ -148,7 +148,7 @@ public static Vector64 Zero /// Computes the bitwise-and of two vectors. /// The vector to bitwise-and with . /// The vector to bitwise-and with . - /// The bitwise-and of and . + /// The bitwise-and of and . /// The type of the vector () is not supported. [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -165,7 +165,7 @@ public static Vector64 Zero /// Computes the bitwise-or of two vectors. /// The vector to bitwise-or with . /// The vector to bitwise-or with . - /// The bitwise-or of and . + /// The bitwise-or of and . /// The type of the vector () is not supported. [Intrinsic] [MethodImpl(MethodImplOptions.AggressiveInlining)] diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/VectorMath.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/VectorMath.cs index bc0d1b7c82f..fbd5af0fa1b 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/VectorMath.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/VectorMath.cs @@ -391,9 +391,6 @@ public static TVectorDouble ExpDouble(TVectorDoubl const ulong V_ARG_MAX = 0x40862000_00000000; const ulong V_DP64_BIAS = 1023; - const double V_EXPF_MIN = -709.782712893384; - const double V_EXPF_MAX = +709.782712893384; - const double V_EXPF_HUGE = 6755399441055744; const double V_TBL_LN2 = 1.4426950408889634; @@ -411,66 +408,69 @@ public static TVectorDouble ExpDouble(TVectorDoubl const double C11 = 2.7632293298250954E-07; const double C12 = 2.499430431958571E-08; - // x * (64.0 / ln(2)) - TVectorDouble dn = TVectorDouble.MultiplyAddEstimate(x, TVectorDouble.Create(V_TBL_LN2), TVectorDouble.Create(V_EXPF_HUGE)); + // Check if -709 < vx < 709 + if (TVectorUInt64.LessThanOrEqualAll(Unsafe.BitCast(TVectorDouble.Abs(x)), TVectorUInt64.Create(V_ARG_MAX))) + { + // x * (64.0 / ln(2)) + TVectorDouble dn = TVectorDouble.MultiplyAddEstimate(x, TVectorDouble.Create(V_TBL_LN2), TVectorDouble.Create(V_EXPF_HUGE)); - // n = (int)z - TVectorUInt64 n = Unsafe.BitCast(dn); + // n = (int)z + TVectorUInt64 n = Unsafe.BitCast(dn); - // dn = (double)n - dn -= TVectorDouble.Create(V_EXPF_HUGE); + // dn = (double)n + dn -= TVectorDouble.Create(V_EXPF_HUGE); - // r = x - (dn * (ln(2) / 64)) - // where ln(2) / 64 is split into Head and Tail values - TVectorDouble r = TVectorDouble.MultiplyAddEstimate(dn, TVectorDouble.Create(-V_LN2_HEAD), x); - r = TVectorDouble.MultiplyAddEstimate(dn, TVectorDouble.Create(-V_LN2_TAIL), r); + // r = x - (dn * (ln(2) / 64)) + // where ln(2) / 64 is split into Head and Tail values + TVectorDouble r = TVectorDouble.MultiplyAddEstimate(dn, TVectorDouble.Create(-V_LN2_HEAD), x); + r = TVectorDouble.MultiplyAddEstimate(dn, TVectorDouble.Create(-V_LN2_TAIL), r); - TVectorDouble r2 = r * r; - TVectorDouble r4 = r2 * r2; - TVectorDouble r8 = r4 * r4; + TVectorDouble r2 = r * r; + TVectorDouble r4 = r2 * r2; + TVectorDouble r8 = r4 * r4; - // Compute polynomial - TVectorDouble poly = TVectorDouble.MultiplyAddEstimate( - TVectorDouble.MultiplyAddEstimate( - TVectorDouble.MultiplyAddEstimate(TVectorDouble.Create(C12), r, TVectorDouble.Create(C11)), - r2, - TVectorDouble.MultiplyAddEstimate(TVectorDouble.Create(C10), r, TVectorDouble.Create(C09))), - r8, - TVectorDouble.MultiplyAddEstimate( + // Compute polynomial + TVectorDouble poly = TVectorDouble.MultiplyAddEstimate( TVectorDouble.MultiplyAddEstimate( - TVectorDouble.MultiplyAddEstimate(TVectorDouble.Create(C08), r, TVectorDouble.Create(C07)), + TVectorDouble.MultiplyAddEstimate(TVectorDouble.Create(C12), r, TVectorDouble.Create(C11)), r2, - TVectorDouble.MultiplyAddEstimate(TVectorDouble.Create(C06), r, TVectorDouble.Create(C05))), - r4, + TVectorDouble.MultiplyAddEstimate(TVectorDouble.Create(C10), r, TVectorDouble.Create(C09))), + r8, TVectorDouble.MultiplyAddEstimate( - TVectorDouble.MultiplyAddEstimate(TVectorDouble.Create(C04), r, TVectorDouble.Create(C03)), - r2, - r + TVectorDouble.One + TVectorDouble.MultiplyAddEstimate( + TVectorDouble.MultiplyAddEstimate(TVectorDouble.Create(C08), r, TVectorDouble.Create(C07)), + r2, + TVectorDouble.MultiplyAddEstimate(TVectorDouble.Create(C06), r, TVectorDouble.Create(C05))), + r4, + TVectorDouble.MultiplyAddEstimate( + TVectorDouble.MultiplyAddEstimate(TVectorDouble.Create(C04), r, TVectorDouble.Create(C03)), + r2, + r + TVectorDouble.One + ) ) - ) - ); - - // m = (n - j) / 64 - // result = polynomial * 2^m - TVectorDouble result = poly * Unsafe.BitCast((n + TVectorUInt64.Create(V_DP64_BIAS)) << 52); + ); - // Check if -709 < vx < 709 - if (TVectorUInt64.GreaterThanAny(Unsafe.BitCast(TVectorDouble.Abs(x)), TVectorUInt64.Create(V_ARG_MAX))) + // m = (n - j) / 64 + // result = polynomial * 2^m + return poly * Unsafe.BitCast((n + TVectorUInt64.Create(V_DP64_BIAS)) << 52); + } + else { - // (x > V_EXPF_MAX) ? double.PositiveInfinity : x - TVectorDouble infinityMask = TVectorDouble.GreaterThan(x, TVectorDouble.Create(V_EXPF_MAX)); + return ScalarFallback(x); - result = TVectorDouble.ConditionalSelect( - infinityMask, - TVectorDouble.Create(double.PositiveInfinity), - result - ); + static TVectorDouble ScalarFallback(TVectorDouble x) + { + TVectorDouble expResult = TVectorDouble.Zero; - // (x < V_EXPF_MIN) ? 0 : x - result = TVectorDouble.AndNot(result, TVectorDouble.LessThan(x, TVectorDouble.Create(V_EXPF_MIN))); - } + for (int i = 0; i < TVectorDouble.Count; i++) + { + double expScalar = double.Exp(x[i]); + expResult = expResult.WithElement(i, expScalar); + } - return result; + return expResult; + } + } } public static TVectorSingle ExpSingle(TVectorSingle x) diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/PackedSimd.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/PackedSimd.PlatformNotSupported.cs index a78f608ae73..ba0d08193e1 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/PackedSimd.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/PackedSimd.PlatformNotSupported.cs @@ -9,6 +9,9 @@ namespace System.Runtime.Intrinsics.Wasm [CLSCompliant(false)] public abstract class PackedSimd { + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static bool IsSupported { [Intrinsic] get { return false; } } public static Vector128 Splat(sbyte value) { throw new PlatformNotSupportedException(); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/PackedSimd.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/PackedSimd.cs index 3d9fb000131..278d8a94a5f 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/PackedSimd.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/PackedSimd.cs @@ -7,13 +7,14 @@ namespace System.Runtime.Intrinsics.Wasm { - /// - /// This class provides access to the WebAssembly packed SIMD instructions via intrinsics - /// + /// Provides access to the WebAssembly packed SIMD instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class PackedSimd { + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static bool IsSupported { [Intrinsic] get { return IsSupported; } } // Constructing SIMD Values @@ -21,2437 +22,1493 @@ public abstract class PackedSimd // cut (lives somewhere else, use Vector128.Create) // public static Vector128 Constant(ImmByte[16] imm); - /// - /// i8x16.splat or v128.const - /// + /// i8x16.splat or v128.const [Intrinsic] public static Vector128 Splat(sbyte value) => Splat(value); - /// - /// i8x16.splat or v128.const - /// + /// i8x16.splat or v128.const [Intrinsic] public static Vector128 Splat(byte value) => Splat(value); - /// - /// i16x8.splat or v128.const - /// + /// i16x8.splat or v128.const [Intrinsic] public static Vector128 Splat(short value) => Splat(value); - /// - /// i16x8.splat or v128.const - /// + /// i16x8.splat or v128.const [Intrinsic] public static Vector128 Splat(ushort value) => Splat(value); - /// - /// i32x4.splat or v128.const - /// + /// i32x4.splat or v128.const [Intrinsic] public static Vector128 Splat(int value) => Splat(value); - /// - /// i32x4.splat or v128.const - /// + /// i32x4.splat or v128.const [Intrinsic] public static Vector128 Splat(uint value) => Splat(value); - /// - /// i64x2.splat or v128.const - /// + /// i64x2.splat or v128.const [Intrinsic] public static Vector128 Splat(long value) => Splat(value); - /// - /// i64x2.splat or v128.const - /// + /// i64x2.splat or v128.const [Intrinsic] public static Vector128 Splat(ulong value) => Splat(value); - /// - /// f32x4.splat or v128.const - /// + /// f32x4.splat or v128.const [Intrinsic] public static Vector128 Splat(float value) => Splat(value); - /// - /// f64x2.splat or v128.const - /// + /// f64x2.splat or v128.const [Intrinsic] public static Vector128 Splat(double value) => Splat(value); - /// - /// i32x4.splat or v128.const - /// + /// i32x4.splat or v128.const [Intrinsic] public static Vector128 Splat(nint value) => Splat(value); - /// - /// i32x4.splat or v128.const - /// + /// i32x4.splat or v128.const [Intrinsic] public static Vector128 Splat(nuint value) => Splat(value); // Accessing lanes - /// - /// i8x16.extract_lane_s - /// + /// i8x16.extract_lane_s [Intrinsic] public static int ExtractScalar(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte index) => ExtractScalar(value, index); // takes ImmLaneIdx16 - /// - /// i8x16.extract_lane_u - /// + /// i8x16.extract_lane_u [Intrinsic] public static uint ExtractScalar(Vector128 value, [ConstantExpected(Max = (byte)(15))] byte index) => ExtractScalar(value, index); // takes ImmLaneIdx16 - /// - /// i16x8.extract_lane_s - /// + /// i16x8.extract_lane_s [Intrinsic] public static int ExtractScalar(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte index) => ExtractScalar(value, index); // takes ImmLaneIdx8 - /// - /// i16x8.extract_lane_u - /// + /// i16x8.extract_lane_u [Intrinsic] public static uint ExtractScalar(Vector128 value, [ConstantExpected(Max = (byte)(7))] byte index) => ExtractScalar(value, index); // takes ImmLaneIdx8 - /// - /// i32x4.extract_lane - /// + /// i32x4.extract_lane [Intrinsic] public static int ExtractScalar(Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index) => ExtractScalar(value, index); // takes ImmLaneIdx4 - /// - /// i32x4.extract_lane - /// + /// i32x4.extract_lane [Intrinsic] public static uint ExtractScalar(Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index) => ExtractScalar(value, index); // takes ImmLaneIdx4 - /// - /// i64x2.extract_lane - /// + /// i64x2.extract_lane [Intrinsic] public static long ExtractScalar(Vector128 value, [ConstantExpected(Max = (byte)(1))] byte index) => ExtractScalar(value, index); // takes ImmLaneIdx2 - /// - /// i64x2.extract_lane - /// + /// i64x2.extract_lane [Intrinsic] public static ulong ExtractScalar(Vector128 value, [ConstantExpected(Max = (byte)(1))] byte index) => ExtractScalar(value, index); // takes ImmLaneIdx2 - /// - /// f32x4.extract_lane - /// + /// f32x4.extract_lane [Intrinsic] public static float ExtractScalar(Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index) => ExtractScalar(value, index); // takes ImmLaneIdx4 - /// - /// f64x2.extract_lane - /// + /// f64x2.extract_lane [Intrinsic] public static double ExtractScalar(Vector128 value, [ConstantExpected(Max = (byte)(1))] byte index) => ExtractScalar(value, index); // takes ImmLaneIdx2 - /// - /// i32x4.extract_lane - /// + /// i32x4.extract_lane [Intrinsic] public static nint ExtractScalar(Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index) => ExtractScalar(value, index); - /// - /// i32x4.extract_lane - /// + /// i32x4.extract_lane [Intrinsic] public static nuint ExtractScalar(Vector128 value, [ConstantExpected(Max = (byte)(3))] byte index) => ExtractScalar(value, index); - /// - /// i8x16.replace_lane - /// + /// i8x16.replace_lane [Intrinsic] public static Vector128 ReplaceScalar(Vector128 vector, [ConstantExpected(Max = (byte)(15))] byte imm, int value) => ReplaceScalar(vector, imm, value); // takes ImmLaneIdx16 - /// - /// i8x16.replace_lane - /// + /// i8x16.replace_lane [Intrinsic] public static Vector128 ReplaceScalar(Vector128 vector, [ConstantExpected(Max = (byte)(15))] byte imm, uint value) => ReplaceScalar(vector, imm, value); // takes ImmLaneIdx16 - /// - /// i16x8.replace_lane - /// + /// i16x8.replace_lane [Intrinsic] public static Vector128 ReplaceScalar(Vector128 vector, [ConstantExpected(Max = (byte)(7))] byte imm, int value) => ReplaceScalar(vector, imm, value); // takes ImmLaneIdx8 - /// - /// i16x8.replace_lane - /// + /// i16x8.replace_lane [Intrinsic] public static Vector128 ReplaceScalar(Vector128 vector, [ConstantExpected(Max = (byte)(7))] byte imm, uint value) => ReplaceScalar(vector, imm, value); // takes ImmLaneIdx8 - /// - /// i32x4.replace_lane - /// + /// i32x4.replace_lane [Intrinsic] public static Vector128 ReplaceScalar(Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte imm, int value) => ReplaceScalar(vector, imm, value); // takes ImmLaneIdx4 - /// - /// i32x4.replace_lane - /// + /// i32x4.replace_lane [Intrinsic] public static Vector128 ReplaceScalar(Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte imm, uint value) => ReplaceScalar(vector, imm, value); // takes ImmLaneIdx4 - /// - /// i64x2.replace_lane - /// + /// i64x2.replace_lane [Intrinsic] public static Vector128 ReplaceScalar(Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte imm, long value) => ReplaceScalar(vector, imm, value); // takes ImmLaneIdx2 - /// - /// i64x2.replace_lane - /// + /// i64x2.replace_lane [Intrinsic] public static Vector128 ReplaceScalar(Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte imm, ulong value) => ReplaceScalar(vector, imm, value); // takes ImmLaneIdx2 - /// - /// f32x4.replace_lane - /// + /// f32x4.replace_lane [Intrinsic] public static Vector128 ReplaceScalar(Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte imm, float value) => ReplaceScalar(vector, imm, value); // takes ImmLaneIdx4 - /// - /// f64x2.replace_lane - /// + /// f64x2.replace_lane [Intrinsic] public static Vector128 ReplaceScalar(Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte imm, double value) => ReplaceScalar(vector, imm, value); // takes ImmLaneIdx2 - /// - /// i32x4.replace_lane - /// + /// i32x4.replace_lane [Intrinsic] public static Vector128 ReplaceScalar(Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte imm, nint value) => ReplaceScalar(vector, imm, value); - /// - /// i32x4.replace_lane - /// + /// i32x4.replace_lane [Intrinsic] public static Vector128 ReplaceScalar(Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte imm, nuint value) => ReplaceScalar(vector, imm, value); - /// - /// i8x16.shuffle - /// + /// i8x16.shuffle [Intrinsic] internal static Vector128 Shuffle(Vector128 lower, Vector128 upper, Vector128 indices) => Shuffle(lower, upper, indices); - /// - /// i8x16.shuffle - /// + /// i8x16.shuffle [Intrinsic] internal static Vector128 Shuffle(Vector128 lower, Vector128 upper, Vector128 indices) => Shuffle(lower, upper, indices); - /// - /// i8x16.swizzle - /// + /// i8x16.swizzle [Intrinsic] public static Vector128 Swizzle(Vector128 vector, Vector128 indices) => Swizzle(vector, indices); - /// - /// i8x16.swizzle - /// + /// i8x16.swizzle [Intrinsic] public static Vector128 Swizzle(Vector128 vector, Vector128 indices) => Swizzle(vector, indices); // Integer arithmetic - /// - /// i8x16.add - /// + /// i8x16.add [Intrinsic] public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); - /// - /// i8x16.add - /// + /// i8x16.add [Intrinsic] public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); - /// - /// i16x8.add - /// + /// i16x8.add [Intrinsic] public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); - /// - /// i16x8.add - /// + /// i16x8.add [Intrinsic] public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); - /// - /// i32x4.add - /// + /// i32x4.add [Intrinsic] public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); - /// - /// i32x4.add - /// + /// i32x4.add [Intrinsic] public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); - /// - /// i64x2.add - /// + /// i64x2.add [Intrinsic] public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); - /// - /// i64x2.add - /// + /// i64x2.add [Intrinsic] public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); - /// - /// i32x4.add - /// + /// i32x4.add [Intrinsic] public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); - /// - /// i32x4.add - /// + /// i32x4.add [Intrinsic] public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); - /// - /// i8x16.sub - /// + /// i8x16.sub [Intrinsic] public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); - /// - /// i8x16.sub - /// + /// i8x16.sub [Intrinsic] public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); - /// - /// i16x8.sub - /// + /// i16x8.sub [Intrinsic] public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); - /// - /// i16x8.sub - /// + /// i16x8.sub [Intrinsic] public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); - /// - /// i32x4.sub - /// + /// i32x4.sub [Intrinsic] public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); - /// - /// i32x4.sub - /// + /// i32x4.sub [Intrinsic] public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); - /// - /// i64x2.sub - /// + /// i64x2.sub [Intrinsic] public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); - /// - /// i64x2.sub - /// + /// i64x2.sub [Intrinsic] public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); - /// - /// i32x4.sub - /// + /// i32x4.sub [Intrinsic] public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); - /// - /// i32x4.sub - /// + /// i32x4.sub [Intrinsic] public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); - /// - /// i16x8.mul - /// + /// i16x8.mul [Intrinsic] public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); - /// - /// i16x8.mul - /// + /// i16x8.mul [Intrinsic] public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); - /// - /// i32x4.mul - /// + /// i32x4.mul [Intrinsic] public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); - /// - /// i32x4.mul - /// + /// i32x4.mul [Intrinsic] public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); - /// - /// i64x2.mul - /// + /// i64x2.mul [Intrinsic] public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); - /// - /// i64x2.mul - /// + /// i64x2.mul [Intrinsic] public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); - /// - /// i32x4.mul - /// + /// i32x4.mul [Intrinsic] public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); - /// - /// i32x4.mul - /// + /// i32x4.mul [Intrinsic] public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); - /// - /// i32x4.dot_i16x8_s - /// + /// i32x4.dot_i16x8_s [Intrinsic] public static Vector128 Dot(Vector128 left, Vector128 right) => Dot(left, right); - /// - /// i8x16.neg - /// + /// i8x16.neg [Intrinsic] public static Vector128 Negate(Vector128 value) => Negate(value); - /// - /// i8x16.neg - /// + /// i8x16.neg [Intrinsic] public static Vector128 Negate(Vector128 value) => Negate(value); - /// - /// i16x8.neg - /// + /// i16x8.neg [Intrinsic] public static Vector128 Negate(Vector128 value) => Negate(value); - /// - /// i16x8.neg - /// + /// i16x8.neg [Intrinsic] public static Vector128 Negate(Vector128 value) => Negate(value); - /// - /// i32x4.neg - /// + /// i32x4.neg [Intrinsic] public static Vector128 Negate(Vector128 value) => Negate(value); - /// - /// i32x4.neg - /// + /// i32x4.neg [Intrinsic] public static Vector128 Negate(Vector128 value) => Negate(value); - /// - /// i64x2.neg - /// + /// i64x2.neg [Intrinsic] public static Vector128 Negate(Vector128 value) => Negate(value); - /// - /// i64x2.neg - /// + /// i64x2.neg [Intrinsic] public static Vector128 Negate(Vector128 value) => Negate(value); - /// - /// i32x4.neg - /// + /// i32x4.neg [Intrinsic] public static Vector128 Negate(Vector128 value) => Negate(value); - /// - /// i32x4.neg - /// + /// i32x4.neg [Intrinsic] public static Vector128 Negate(Vector128 value) => Negate(value); // Extended integer arithmetic - /// - /// i16x8.extmul_low_i8x16_s - /// + /// i16x8.extmul_low_i8x16_s [Intrinsic] public static Vector128 MultiplyWideningLower(Vector128 left, Vector128 right) => MultiplyWideningLower(left, right); - /// - /// i16x8.extmul_low_i8x16_u - /// + /// i16x8.extmul_low_i8x16_u [Intrinsic] public static Vector128 MultiplyWideningLower(Vector128 left, Vector128 right) => MultiplyWideningLower(left, right); - /// - /// i32x4.extmul_low_i16x8_s - /// + /// i32x4.extmul_low_i16x8_s [Intrinsic] public static Vector128 MultiplyWideningLower(Vector128 left, Vector128 right) => MultiplyWideningLower(left, right); - /// - /// i32x4.extmul_low_i16x8_u - /// + /// i32x4.extmul_low_i16x8_u [Intrinsic] public static Vector128 MultiplyWideningLower(Vector128 left, Vector128 right) => MultiplyWideningLower(left, right); - /// - /// i64x2.extmul_low_i32x4_s - /// + /// i64x2.extmul_low_i32x4_s [Intrinsic] public static Vector128 MultiplyWideningLower(Vector128 left, Vector128 right) => MultiplyWideningLower(left, right); - /// - /// i64x2.extmul_low_i32x4_u - /// + /// i64x2.extmul_low_i32x4_u [Intrinsic] public static Vector128 MultiplyWideningLower(Vector128 left, Vector128 right) => MultiplyWideningLower(left, right); - /// - /// i16x8.extmul_high_i8x16_s - /// + /// i16x8.extmul_high_i8x16_s [Intrinsic] public static Vector128 MultiplyWideningUpper(Vector128 left, Vector128 right) => MultiplyWideningUpper(left, right); - /// - /// i16x8.extmul_high_i8x16_u - /// + /// i16x8.extmul_high_i8x16_u [Intrinsic] public static Vector128 MultiplyWideningUpper(Vector128 left, Vector128 right) => MultiplyWideningUpper(left, right); - /// - /// i32x4.extmul_high_i16x8_s - /// + /// i32x4.extmul_high_i16x8_s [Intrinsic] public static Vector128 MultiplyWideningUpper(Vector128 left, Vector128 right) => MultiplyWideningUpper(left, right); - /// - /// i32x4.extmul_high_i16x8_u - /// + /// i32x4.extmul_high_i16x8_u [Intrinsic] public static Vector128 MultiplyWideningUpper(Vector128 left, Vector128 right) => MultiplyWideningUpper(left, right); - /// - /// i64x2.extmul_high_i32x4_s - /// + /// i64x2.extmul_high_i32x4_s [Intrinsic] public static Vector128 MultiplyWideningUpper(Vector128 left, Vector128 right) => MultiplyWideningUpper(left, right); - /// - /// i64x2.extmul_high_i32x4_u - /// + /// i64x2.extmul_high_i32x4_u [Intrinsic] public static Vector128 MultiplyWideningUpper(Vector128 left, Vector128 right) => MultiplyWideningUpper(left, right); - /// - /// i16x8.extadd_pairwise_i8x16_s - /// + /// i16x8.extadd_pairwise_i8x16_s [Intrinsic] public static Vector128 AddPairwiseWidening(Vector128 value) => AddPairwiseWidening(value); - /// - /// i16x8.extadd_pairwise_i8x16_u - /// + /// i16x8.extadd_pairwise_i8x16_u [Intrinsic] public static Vector128 AddPairwiseWidening(Vector128 value) => AddPairwiseWidening(value); - /// - /// i32x4.extadd_pairwise_i16x8_s - /// + /// i32x4.extadd_pairwise_i16x8_s [Intrinsic] public static Vector128 AddPairwiseWidening(Vector128 value) => AddPairwiseWidening(value); - /// - /// i32x4.extadd_pairwise_i16x8_u - /// + /// i32x4.extadd_pairwise_i16x8_u [Intrinsic] public static Vector128 AddPairwiseWidening(Vector128 value) => AddPairwiseWidening(value); // Saturating integer arithmetic - /// - /// i8x16.add.sat.s - /// + /// i8x16.add.sat.s public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); - /// - /// i8x16.add.sat.u - /// + /// i8x16.add.sat.u public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); - /// - /// i16x8.add.sat.s - /// + /// i16x8.add.sat.s public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); - /// - /// i16x8.add.sat.u - /// + /// i16x8.add.sat.u public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); - /// - /// i8x16.sub.sat.s - /// + /// i8x16.sub.sat.s public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) => SubtractSaturate(left, right); - /// - /// i8x16.sub.sat.u - /// + /// i8x16.sub.sat.u public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) => SubtractSaturate(left, right); - /// - /// i16x8.sub.sat.s - /// + /// i16x8.sub.sat.s public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) => SubtractSaturate(left, right); - /// - /// i16x8.sub.sat.u - /// + /// i16x8.sub.sat.u public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) => SubtractSaturate(left, right); - /// - /// i16x8.q15mulr.sat.s - /// + /// i16x8.q15mulr.sat.s public static Vector128 MultiplyRoundedSaturateQ15(Vector128 left, Vector128 right) => MultiplyRoundedSaturateQ15(left, right); - /// - /// i8x16.min.s - /// + /// i8x16.min.s public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); - /// - /// i8x16.min.u - /// + /// i8x16.min.u public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); - /// - /// i16x8.min.s - /// + /// i16x8.min.s public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); - /// - /// i16x8.min.u - /// + /// i16x8.min.u public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); - /// - /// i32x4.min.s - /// + /// i32x4.min.s public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); - /// - /// i32x4.min.u - /// + /// i32x4.min.u public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); - /// - /// i8x16.max.s - /// + /// i8x16.max.s public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); - /// - /// i8x16.max.u - /// + /// i8x16.max.u public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); - /// - /// i16x8.max.s - /// + /// i16x8.max.s public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); - /// - /// i16x8.max.u - /// + /// i16x8.max.u public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); - /// - /// i32x4.max.s - /// + /// i32x4.max.s public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); - /// - /// i32x4.max.u - /// + /// i32x4.max.u public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); - /// - /// i8x16.avgr.u - /// + /// i8x16.avgr.u public static Vector128 AverageRounded(Vector128 left, Vector128 right) => AverageRounded(left, right); - /// - /// i16x8.avgr.u - /// + /// i16x8.avgr.u public static Vector128 AverageRounded(Vector128 left, Vector128 right) => AverageRounded(left, right); - /// - /// i8x16.abs - /// + /// i8x16.abs public static Vector128 Abs(Vector128 value) => Abs(value); - /// - /// i16x8.abs - /// + /// i16x8.abs public static Vector128 Abs(Vector128 value) => Abs(value); - /// - /// i32x4.abs - /// + /// i32x4.abs public static Vector128 Abs(Vector128 value) => Abs(value); - /// - /// i64x2.abs - /// + /// i64x2.abs public static Vector128 Abs(Vector128 value) => Abs(value); - /// - /// i32x4.abs - /// + /// i32x4.abs public static Vector128 Abs(Vector128 value) => Abs(value); // Bit shifts - /// - /// i8x16.shl - /// + /// i8x16.shl [Intrinsic] public static Vector128 ShiftLeft(Vector128 value, int count) => ShiftLeft(value, count); - /// - /// i8x16.shl - /// + /// i8x16.shl [Intrinsic] public static Vector128 ShiftLeft(Vector128 value, int count) => ShiftLeft(value, count); - /// - /// i16x8.shl - /// + /// i16x8.shl [Intrinsic] public static Vector128 ShiftLeft(Vector128 value, int count) => ShiftLeft(value, count); - /// - /// i16x8.shl - /// + /// i16x8.shl [Intrinsic] public static Vector128 ShiftLeft(Vector128 value, int count) => ShiftLeft(value, count); - /// - /// i32x4.shl - /// + /// i32x4.shl [Intrinsic] public static Vector128 ShiftLeft(Vector128 value, int count) => ShiftLeft(value, count); - /// - /// i32x4.shl - /// + /// i32x4.shl [Intrinsic] public static Vector128 ShiftLeft(Vector128 value, int count) => ShiftLeft(value, count); - /// - /// i64x2.shl - /// + /// i64x2.shl [Intrinsic] public static Vector128 ShiftLeft(Vector128 value, int count) => ShiftLeft(value, count); - /// - /// i64x2.shl - /// + /// i64x2.shl [Intrinsic] public static Vector128 ShiftLeft(Vector128 value, int count) => ShiftLeft(value, count); - /// - /// i32x4.shl - /// + /// i32x4.shl [Intrinsic] public static Vector128 ShiftLeft(Vector128 value, int count) => ShiftLeft(value, count); - /// - /// i32x4.shl - /// + /// i32x4.shl [Intrinsic] public static Vector128 ShiftLeft(Vector128 value, int count) => ShiftLeft(value, count); - /// - /// i8x16.shr_s - /// + /// i8x16.shr_s [Intrinsic] public static Vector128 ShiftRightArithmetic(Vector128 value, int count) => ShiftRightArithmetic(value, count); - /// - /// i8x16.shr_s - /// + /// i8x16.shr_s [Intrinsic] public static Vector128 ShiftRightArithmetic(Vector128 value, int count) => ShiftRightArithmetic(value, count); - /// - /// i16x8.shr_s - /// + /// i16x8.shr_s [Intrinsic] public static Vector128 ShiftRightArithmetic(Vector128 value, int count) => ShiftRightArithmetic(value, count); - /// - /// i16x8.shr_s - /// + /// i16x8.shr_s [Intrinsic] public static Vector128 ShiftRightArithmetic(Vector128 value, int count) => ShiftRightArithmetic(value, count); - /// - /// i32x4.shr_s - /// + /// i32x4.shr_s [Intrinsic] public static Vector128 ShiftRightArithmetic(Vector128 value, int count) => ShiftRightArithmetic(value, count); - /// - /// i32x4.shr_s - /// + /// i32x4.shr_s [Intrinsic] public static Vector128 ShiftRightArithmetic(Vector128 value, int count) => ShiftRightArithmetic(value, count); - /// - /// i64x2.shr_s - /// + /// i64x2.shr_s [Intrinsic] public static Vector128 ShiftRightArithmetic(Vector128 value, int count) => ShiftRightArithmetic(value, count); - /// - /// i64x2.shr_s - /// + /// i64x2.shr_s [Intrinsic] public static Vector128 ShiftRightArithmetic(Vector128 value, int count) => ShiftRightArithmetic(value, count); - /// - /// i32x4.shr_s - /// + /// i32x4.shr_s [Intrinsic] public static Vector128 ShiftRightArithmetic(Vector128 value, int count) => ShiftRightArithmetic(value, count); - /// - /// i32x4.shr_s - /// + /// i32x4.shr_s [Intrinsic] public static Vector128 ShiftRightArithmetic(Vector128 value, int count) => ShiftRightArithmetic(value, count); - /// - /// i8x16.shr_u - /// + /// i8x16.shr_u [Intrinsic] public static Vector128 ShiftRightLogical(Vector128 value, int count) => ShiftRightLogical(value, count); - /// - /// i8x16.shr_u - /// + /// i8x16.shr_u [Intrinsic] public static Vector128 ShiftRightLogical(Vector128 value, int count) => ShiftRightLogical(value, count); - /// - /// i16x8.shr_u - /// + /// i16x8.shr_u [Intrinsic] public static Vector128 ShiftRightLogical(Vector128 value, int count) => ShiftRightLogical(value, count); - /// - /// i16x8.shr_u - /// + /// i16x8.shr_u [Intrinsic] public static Vector128 ShiftRightLogical(Vector128 value, int count) => ShiftRightLogical(value, count); - /// - /// i32x4.shr_u - /// + /// i32x4.shr_u [Intrinsic] public static Vector128 ShiftRightLogical(Vector128 value, int count) => ShiftRightLogical(value, count); - /// - /// i32x4.shr_u - /// + /// i32x4.shr_u [Intrinsic] public static Vector128 ShiftRightLogical(Vector128 value, int count) => ShiftRightLogical(value, count); - /// - /// i64x2.shr_u - /// + /// i64x2.shr_u [Intrinsic] public static Vector128 ShiftRightLogical(Vector128 value, int count) => ShiftRightLogical(value, count); - /// - /// i64x2.shr_u - /// + /// i64x2.shr_u [Intrinsic] public static Vector128 ShiftRightLogical(Vector128 value, int count) => ShiftRightLogical(value, count); - /// - /// i32x4.shr_u - /// + /// i32x4.shr_u [Intrinsic] public static Vector128 ShiftRightLogical(Vector128 value, int count) => ShiftRightLogical(value, count); - /// - /// i32x4.shr_u - /// + /// i32x4.shr_u [Intrinsic] public static Vector128 ShiftRightLogical(Vector128 value, int count) => ShiftRightLogical(value, count); // Bitwise operations - /// - /// v128.and - /// + /// v128.and [Intrinsic] public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); - /// - /// v128.and - /// + /// v128.and [Intrinsic] public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); - /// - /// v128.and - /// + /// v128.and [Intrinsic] public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); - /// - /// v128.and - /// + /// v128.and [Intrinsic] public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); - /// - /// v128.and - /// + /// v128.and [Intrinsic] public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); - /// - /// v128.and - /// + /// v128.and [Intrinsic] public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); - /// - /// v128.and - /// + /// v128.and [Intrinsic] public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); - /// - /// v128.and - /// + /// v128.and [Intrinsic] public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); - /// - /// v128.and - /// + /// v128.and [Intrinsic] public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); - /// - /// v128.and - /// + /// v128.and [Intrinsic] public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); - /// - /// v128.and - /// + /// v128.and [Intrinsic] public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); - /// - /// v128.and - /// + /// v128.and [Intrinsic] public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); - /// - /// v128.or - /// + /// v128.or [Intrinsic] public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); - /// - /// v128.or - /// + /// v128.or [Intrinsic] public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); - /// - /// v128.or - /// + /// v128.or [Intrinsic] public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); - /// - /// v128.or - /// + /// v128.or [Intrinsic] public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); - /// - /// v128.or - /// + /// v128.or [Intrinsic] public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); - /// - /// v128.or - /// + /// v128.or [Intrinsic] public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); - /// - /// v128.or - /// + /// v128.or [Intrinsic] public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); - /// - /// v128.or - /// + /// v128.or [Intrinsic] public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); - /// - /// v128.or - /// + /// v128.or [Intrinsic] public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); - /// - /// v128.or - /// + /// v128.or [Intrinsic] public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); - /// - /// v128.or - /// + /// v128.or [Intrinsic] public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); - /// - /// v128.or - /// + /// v128.or [Intrinsic] public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); - /// - /// v128.xor - /// + /// v128.xor [Intrinsic] public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); - /// - /// v128.xor - /// + /// v128.xor [Intrinsic] public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); - /// - /// v128.xor - /// + /// v128.xor [Intrinsic] public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); - /// - /// v128.xor - /// + /// v128.xor [Intrinsic] public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); - /// - /// v128.xor - /// + /// v128.xor [Intrinsic] public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); - /// - /// v128.xor - /// + /// v128.xor [Intrinsic] public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); - /// - /// v128.xor - /// + /// v128.xor [Intrinsic] public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); - /// - /// v128.xor - /// + /// v128.xor [Intrinsic] public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); - /// - /// v128.xor - /// + /// v128.xor [Intrinsic] public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); - /// - /// v128.xor - /// + /// v128.xor [Intrinsic] public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); - /// - /// v128.xor - /// + /// v128.xor [Intrinsic] public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); - /// - /// v128.xor - /// + /// v128.xor [Intrinsic] public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); - /// - /// v128.not - /// + /// v128.not [Intrinsic] public static Vector128 Not(Vector128 value) => Not(value); - /// - /// v128.not - /// + /// v128.not [Intrinsic] public static Vector128 Not(Vector128 value) => Not(value); - /// - /// v128.not - /// + /// v128.not [Intrinsic] public static Vector128 Not(Vector128 value) => Not(value); - /// - /// v128.not - /// + /// v128.not [Intrinsic] public static Vector128 Not(Vector128 value) => Not(value); - /// - /// v128.not - /// + /// v128.not [Intrinsic] public static Vector128 Not(Vector128 value) => Not(value); - /// - /// v128.not - /// + /// v128.not [Intrinsic] public static Vector128 Not(Vector128 value) => Not(value); - /// - /// v128.not - /// + /// v128.not [Intrinsic] public static Vector128 Not(Vector128 value) => Not(value); - /// - /// v128.not - /// + /// v128.not [Intrinsic] public static Vector128 Not(Vector128 value) => Not(value); - /// - /// v128.not - /// + /// v128.not [Intrinsic] public static Vector128 Not(Vector128 value) => Not(value); - /// - /// v128.not - /// + /// v128.not [Intrinsic] public static Vector128 Not(Vector128 value) => Not(value); - /// - /// v128.not - /// + /// v128.not [Intrinsic] public static Vector128 Not(Vector128 value) => Not(value); - /// - /// v128.not - /// + /// v128.not [Intrinsic] public static Vector128 Not(Vector128 value) => Not(value); - /// - /// v128.andnot - /// + /// v128.andnot [Intrinsic] public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); - /// - /// v128.andnot - /// + /// v128.andnot [Intrinsic] public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); - /// - /// v128.andnot - /// + /// v128.andnot [Intrinsic] public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); - /// - /// v128.andnot - /// + /// v128.andnot [Intrinsic] public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); - /// - /// v128.andnot - /// + /// v128.andnot [Intrinsic] public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); - /// - /// v128.andnot - /// + /// v128.andnot [Intrinsic] public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); - /// - /// v128.andnot - /// + /// v128.andnot [Intrinsic] public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); - /// - /// v128.andnot - /// + /// v128.andnot [Intrinsic] public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); - /// - /// v128.andnot - /// + /// v128.andnot [Intrinsic] public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); - /// - /// v128.andnot - /// + /// v128.andnot [Intrinsic] public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); - /// - /// v128.andnot - /// + /// v128.andnot [Intrinsic] public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); - /// - /// v128.andnot - /// + /// v128.andnot [Intrinsic] public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); - /// - /// v128.bitselect - /// + /// v128.bitselect [Intrinsic] public static Vector128 BitwiseSelect(Vector128 left, Vector128 right, Vector128 select) => BitwiseSelect(left, right, select); - /// - /// v128.bitselect - /// + /// v128.bitselect [Intrinsic] public static Vector128 BitwiseSelect(Vector128 left, Vector128 right, Vector128 select) => BitwiseSelect(left, right, select); - /// - /// v128.bitselect - /// + /// v128.bitselect [Intrinsic] public static Vector128 BitwiseSelect(Vector128 left, Vector128 right, Vector128 select) => BitwiseSelect(left, right, select); - /// - /// v128.bitselect - /// + /// v128.bitselect [Intrinsic] public static Vector128 BitwiseSelect(Vector128 left, Vector128 right, Vector128 select) => BitwiseSelect(left, right, select); - /// - /// v128.bitselect - /// + /// v128.bitselect [Intrinsic] public static Vector128 BitwiseSelect(Vector128 left, Vector128 right, Vector128 select) => BitwiseSelect(left, right, select); - /// - /// v128.bitselect - /// + /// v128.bitselect [Intrinsic] public static Vector128 BitwiseSelect(Vector128 left, Vector128 right, Vector128 select) => BitwiseSelect(left, right, select); - /// - /// v128.bitselect - /// + /// v128.bitselect [Intrinsic] public static Vector128 BitwiseSelect(Vector128 left, Vector128 right, Vector128 select) => BitwiseSelect(left, right, select); - /// - /// v128.bitselect - /// + /// v128.bitselect [Intrinsic] public static Vector128 BitwiseSelect(Vector128 left, Vector128 right, Vector128 select) => BitwiseSelect(left, right, select); - /// - /// v128.bitselect - /// + /// v128.bitselect [Intrinsic] public static Vector128 BitwiseSelect(Vector128 left, Vector128 right, Vector128 select) => BitwiseSelect(left, right, select); - /// - /// v128.bitselect - /// + /// v128.bitselect [Intrinsic] public static Vector128 BitwiseSelect(Vector128 left, Vector128 right, Vector128 select) => BitwiseSelect(left, right, select); - /// - /// v128.bitselect - /// + /// v128.bitselect [Intrinsic] public static Vector128 BitwiseSelect(Vector128 left, Vector128 right, Vector128 select) => BitwiseSelect(left, right, select); - /// - /// v128.bitselect - /// + /// v128.bitselect [Intrinsic] public static Vector128 BitwiseSelect(Vector128 left, Vector128 right, Vector128 select) => BitwiseSelect(left, right, select); - /// - /// i8x16.popcnt - /// + /// i8x16.popcnt [Intrinsic] public static Vector128 PopCount(Vector128 value) => PopCount(value); // Boolean horizontal reductions - /// - /// v128.any_true - /// + /// v128.any_true [Intrinsic] public static bool AnyTrue(Vector128 value) => AnyTrue(value); - /// - /// v128.any_true - /// + /// v128.any_true [Intrinsic] public static bool AnyTrue(Vector128 value) => AnyTrue(value); - /// - /// v128.any_true - /// + /// v128.any_true [Intrinsic] public static bool AnyTrue(Vector128 value) => AnyTrue(value); - /// - /// v128.any_true - /// + /// v128.any_true [Intrinsic] public static bool AnyTrue(Vector128 value) => AnyTrue(value); - /// - /// v128.any_true - /// + /// v128.any_true [Intrinsic] public static bool AnyTrue(Vector128 value) => AnyTrue(value); - /// - /// v128.any_true - /// + /// v128.any_true [Intrinsic] public static bool AnyTrue(Vector128 value) => AnyTrue(value); - /// - /// v128.any_true - /// + /// v128.any_true [Intrinsic] public static bool AnyTrue(Vector128 value) => AnyTrue(value); - /// - /// v128.any_true - /// + /// v128.any_true [Intrinsic] public static bool AnyTrue(Vector128 value) => AnyTrue(value); - /// - /// v128.any_true - /// + /// v128.any_true [Intrinsic] public static bool AnyTrue(Vector128 value) => AnyTrue(value); - /// - /// v128.any_true - /// + /// v128.any_true [Intrinsic] public static bool AnyTrue(Vector128 value) => AnyTrue(value); - /// - /// v128.any_true - /// + /// v128.any_true [Intrinsic] public static bool AnyTrue(Vector128 value) => AnyTrue(value); - /// - /// v128.any_true - /// + /// v128.any_true [Intrinsic] public static bool AnyTrue(Vector128 value) => AnyTrue(value); - /// - /// i8x16.all_true - /// + /// i8x16.all_true [Intrinsic] public static bool AllTrue(Vector128 value) => AllTrue(value); - /// - /// i8x16.all_true - /// + /// i8x16.all_true [Intrinsic] public static bool AllTrue(Vector128 value) => AllTrue(value); - /// - /// i16x8.all_true - /// + /// i16x8.all_true [Intrinsic] public static bool AllTrue(Vector128 value) => AllTrue(value); - /// - /// i16x8.all_true - /// + /// i16x8.all_true [Intrinsic] public static bool AllTrue(Vector128 value) => AllTrue(value); - /// - /// i32x4.all_true - /// + /// i32x4.all_true [Intrinsic] public static bool AllTrue(Vector128 value) => AllTrue(value); - /// - /// i32x4.all_true - /// + /// i32x4.all_true [Intrinsic] public static bool AllTrue(Vector128 value) => AllTrue(value); - /// - /// i64x2.all_true - /// + /// i64x2.all_true [Intrinsic] public static bool AllTrue(Vector128 value) => AllTrue(value); - /// - /// i64x2.all_true - /// + /// i64x2.all_true [Intrinsic] public static bool AllTrue(Vector128 value) => AllTrue(value); - /// - /// i32x4.all_true - /// + /// i32x4.all_true [Intrinsic] public static bool AllTrue(Vector128 value) => AllTrue(value); - /// - /// i32x4.all_true - /// + /// i32x4.all_true [Intrinsic] public static bool AllTrue(Vector128 value) => AllTrue(value); // Bitmask extraction - /// - /// i8x16.bitmask - /// + /// i8x16.bitmask [Intrinsic] public static int Bitmask(Vector128 value) => Bitmask(value); - /// - /// i8x16.bitmask - /// + /// i8x16.bitmask [Intrinsic] public static int Bitmask(Vector128 value) => Bitmask(value); - /// - /// i16x8.bitmask - /// + /// i16x8.bitmask [Intrinsic] public static int Bitmask(Vector128 value) => Bitmask(value); - /// - /// i16x8.bitmask - /// + /// i16x8.bitmask [Intrinsic] public static int Bitmask(Vector128 value) => Bitmask(value); - /// - /// i32x4.bitmask - /// + /// i32x4.bitmask [Intrinsic] public static int Bitmask(Vector128 value) => Bitmask(value); - /// - /// i32x4.bitmask - /// + /// i32x4.bitmask [Intrinsic] public static int Bitmask(Vector128 value) => Bitmask(value); - /// - /// i64x2.bitmask - /// + /// i64x2.bitmask [Intrinsic] public static int Bitmask(Vector128 value) => Bitmask(value); - /// - /// i64x2.bitmask - /// + /// i64x2.bitmask [Intrinsic] public static int Bitmask(Vector128 value) => Bitmask(value); - /// - /// i32x4.bitmask - /// + /// i32x4.bitmask [Intrinsic] public static int Bitmask(Vector128 value) => Bitmask(value); - /// - /// i32x4.bitmask - /// + /// i32x4.bitmask [Intrinsic] public static int Bitmask(Vector128 value) => Bitmask(value); // Comparisons - /// - /// i8x16.eq - /// + /// i8x16.eq [Intrinsic] public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); - /// - /// i8x16.eq - /// + /// i8x16.eq [Intrinsic] public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); - /// - /// i16x8.eq - /// + /// i16x8.eq [Intrinsic] public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); - /// - /// i16x8.eq - /// + /// i16x8.eq [Intrinsic] public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); - /// - /// i32x4.eq - /// + /// i32x4.eq [Intrinsic] public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); - /// - /// i32x4.eq - /// + /// i32x4.eq [Intrinsic] public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); - /// - /// i64x2.eq - /// + /// i64x2.eq [Intrinsic] public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); - /// - /// i64x2.eq - /// + /// i64x2.eq [Intrinsic] public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); - /// - /// f32x4.eq - /// + /// f32x4.eq [Intrinsic] public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); - /// - /// f64x2.eq - /// + /// f64x2.eq [Intrinsic] public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); - /// - /// i32x4.eq - /// + /// i32x4.eq [Intrinsic] public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); - /// - /// i32x4.eq - /// + /// i32x4.eq [Intrinsic] public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); - /// - /// i8x16.ne - /// + /// i8x16.ne [Intrinsic] public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); - /// - /// i8x16.ne - /// + /// i8x16.ne [Intrinsic] public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); - /// - /// i16x8.ne - /// + /// i16x8.ne [Intrinsic] public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); - /// - /// i16x8.ne - /// + /// i16x8.ne [Intrinsic] public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); - /// - /// i32x4.ne - /// + /// i32x4.ne [Intrinsic] public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); - /// - /// i32x4.ne - /// + /// i32x4.ne [Intrinsic] public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); - /// - /// i64x2.ne - /// + /// i64x2.ne [Intrinsic] public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); - /// - /// i64x2.ne - /// + /// i64x2.ne [Intrinsic] public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); - /// - /// f32x4.ne - /// + /// f32x4.ne [Intrinsic] public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); - /// - /// f64x2.ne - /// + /// f64x2.ne [Intrinsic] public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); - /// - /// i32x4.ne - /// + /// i32x4.ne [Intrinsic] public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); - /// - /// i32x4.ne - /// + /// i32x4.ne [Intrinsic] public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); - /// - /// i8x16.lt_s - /// + /// i8x16.lt_s [Intrinsic] public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); - /// - /// i8x16.lt_u - /// + /// i8x16.lt_u [Intrinsic] public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); - /// - /// i16x8.lt_s - /// + /// i16x8.lt_s [Intrinsic] public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); - /// - /// i16x8.lt_u - /// + /// i16x8.lt_u [Intrinsic] public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); - /// - /// i32x4.lt_s - /// + /// i32x4.lt_s [Intrinsic] public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); - /// - /// i32x4.lt_u - /// + /// i32x4.lt_u [Intrinsic] public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); - /// - /// i64x2.lt_s - /// + /// i64x2.lt_s [Intrinsic] public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); - /// - /// i64x2.lt_u - /// + /// i64x2.lt_u [Intrinsic] public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); - /// - /// f32x4.lt - /// + /// f32x4.lt [Intrinsic] public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); - /// - /// f64x2.lt - /// + /// f64x2.lt [Intrinsic] public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); - /// - /// i32x4.lt_s - /// + /// i32x4.lt_s [Intrinsic] public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); - /// - /// i32x4.lt_u - /// + /// i32x4.lt_u [Intrinsic] public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); - /// - /// i8x16.le_s - /// + /// i8x16.le_s [Intrinsic] public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); - /// - /// i8x16.le_u - /// + /// i8x16.le_u [Intrinsic] public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); - /// - /// i16x8.le_s - /// + /// i16x8.le_s [Intrinsic] public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); - /// - /// i16x8.le_u - /// + /// i16x8.le_u [Intrinsic] public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); - /// - /// i32x4.le_s - /// + /// i32x4.le_s [Intrinsic] public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); - /// - /// i32x4.le_u - /// + /// i32x4.le_u [Intrinsic] public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); - /// - /// i64x2.le_s - /// + /// i64x2.le_s [Intrinsic] public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); - /// - /// i64x2.le_u - /// + /// i64x2.le_u [Intrinsic] public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); - /// - /// f32x4.le - /// + /// f32x4.le [Intrinsic] public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); - /// - /// f64x2.le - /// + /// f64x2.le [Intrinsic] public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); - /// - /// i32x4.le_s - /// + /// i32x4.le_s [Intrinsic] public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); - /// - /// i32x4.le_u - /// + /// i32x4.le_u [Intrinsic] public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); - /// - /// i8x16.gt_s - /// + /// i8x16.gt_s [Intrinsic] public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); - /// - /// i8x16.gt_u - /// + /// i8x16.gt_u [Intrinsic] public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); - /// - /// i16x8.gt_s - /// + /// i16x8.gt_s [Intrinsic] public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); - /// - /// i16x8.gt_u - /// + /// i16x8.gt_u [Intrinsic] public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); - /// - /// i32x4.gt_s - /// + /// i32x4.gt_s [Intrinsic] public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); - /// - /// i32x4.gt_u - /// + /// i32x4.gt_u [Intrinsic] public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); - /// - /// i64x2.gt_s - /// + /// i64x2.gt_s [Intrinsic] public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); - /// - /// i64x2.gt_u - /// + /// i64x2.gt_u [Intrinsic] public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); - /// - /// f32x4.gt - /// + /// f32x4.gt [Intrinsic] public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); - /// - /// f64x2.gt - /// + /// f64x2.gt [Intrinsic] public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); - /// - /// i32x4.gt_s - /// + /// i32x4.gt_s [Intrinsic] public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); - /// - /// i32x4.gt_u - /// + /// i32x4.gt_u [Intrinsic] public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); - /// - /// i8x16.ge_s - /// + /// i8x16.ge_s [Intrinsic] public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); - /// - /// i8x16.ge_u - /// + /// i8x16.ge_u [Intrinsic] public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); - /// - /// i16x8.ge_s - /// + /// i16x8.ge_s [Intrinsic] public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); - /// - /// i16x8.ge_u - /// + /// i16x8.ge_u [Intrinsic] public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); - /// - /// i32x4.ge_s - /// + /// i32x4.ge_s [Intrinsic] public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); - /// - /// i32x4.ge_u - /// + /// i32x4.ge_u [Intrinsic] public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); - /// - /// i32x4.ge_s - /// + /// i32x4.ge_s [Intrinsic] public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); - /// - /// i64x2.ge_s - /// + /// i64x2.ge_s [Intrinsic] public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); - /// - /// f32x4.ge - /// + /// f32x4.ge [Intrinsic] public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); - /// - /// f64x2.ge - /// + /// f64x2.ge public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); - /// - /// i32x4.ge_s - /// + /// i32x4.ge_s [Intrinsic] public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); - /// - /// i32x4.ge_u - /// + /// i32x4.ge_u [Intrinsic] public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); // Load - /// - /// v128.load - /// + /// v128.load [Intrinsic] public static unsafe Vector128 LoadVector128(sbyte* address) => LoadVector128(address); - /// - /// v128.load - /// + /// v128.load [Intrinsic] public static unsafe Vector128 LoadVector128(byte* address) => LoadVector128(address); - /// - /// v128.load - /// + /// v128.load [Intrinsic] public static unsafe Vector128 LoadVector128(short* address) => LoadVector128(address); - /// - /// v128.load - /// + /// v128.load [Intrinsic] public static unsafe Vector128 LoadVector128(ushort* address) => LoadVector128(address); - /// - /// v128.load - /// + /// v128.load [Intrinsic] public static unsafe Vector128 LoadVector128(int* address) => LoadVector128(address); - /// - /// v128.load - /// + /// v128.load [Intrinsic] public static unsafe Vector128 LoadVector128(uint* address) => LoadVector128(address); - /// - /// v128.load - /// + /// v128.load [Intrinsic] public static unsafe Vector128 LoadVector128(long* address) => LoadVector128(address); - /// - /// v128.load - /// + /// v128.load [Intrinsic] public static unsafe Vector128 LoadVector128(ulong* address) => LoadVector128(address); - /// - /// v128.load - /// + /// v128.load [Intrinsic] public static unsafe Vector128 LoadVector128(float* address) => LoadVector128(address); - /// - /// v128.load - /// + /// v128.load [Intrinsic] public static unsafe Vector128 LoadVector128(double* address) => LoadVector128(address); - /// - /// v128.load - /// + /// v128.load [Intrinsic] public static unsafe Vector128 LoadVector128(nint* address) => LoadVector128(address); - /// - /// v128.load - /// + /// v128.load [Intrinsic] public static unsafe Vector128 LoadVector128(nuint* address) => LoadVector128(address); - /// - /// v128.load32.zero - /// + /// v128.load32.zero [Intrinsic] public static unsafe Vector128 LoadScalarVector128(int* address) => LoadScalarVector128(address); - /// - /// v128.load32.zero - /// + /// v128.load32.zero [Intrinsic] public static unsafe Vector128 LoadScalarVector128(uint* address) => LoadScalarVector128(address); - /// - /// v128.load64.zero - /// + /// v128.load64.zero [Intrinsic] public static unsafe Vector128 LoadScalarVector128(long* address) => LoadScalarVector128(address); - /// - /// v128.load64.zero - /// + /// v128.load64.zero [Intrinsic] public static unsafe Vector128 LoadScalarVector128(ulong* address) => LoadScalarVector128(address); - /// - /// v128.load32.zero - /// + /// v128.load32.zero [Intrinsic] public static unsafe Vector128 LoadScalarVector128(float* address) => LoadScalarVector128(address); - /// - /// v128.load64.zero - /// + /// v128.load64.zero [Intrinsic] public static unsafe Vector128 LoadScalarVector128(double* address) => LoadScalarVector128(address); - /// - /// v128.load32.zero - /// + /// v128.load32.zero [Intrinsic] public static unsafe Vector128 LoadScalarVector128(nint* address) => LoadScalarVector128(address); - /// - /// v128.load32.zero - /// + /// v128.load32.zero [Intrinsic] public static unsafe Vector128 LoadScalarVector128(nuint* address) => LoadScalarVector128(address); - /// - /// v128.load8_splat - /// + /// v128.load8_splat [Intrinsic] public static unsafe Vector128 LoadScalarAndSplatVector128(sbyte* address) => LoadScalarAndSplatVector128(address); - /// - /// v128.load8_splat - /// + /// v128.load8_splat [Intrinsic] public static unsafe Vector128 LoadScalarAndSplatVector128(byte* address) => LoadScalarAndSplatVector128(address); - /// - /// v128.load16_splat - /// + /// v128.load16_splat [Intrinsic] public static unsafe Vector128 LoadScalarAndSplatVector128(short* address) => LoadScalarAndSplatVector128(address); - /// - /// v128.load16_splat - /// + /// v128.load16_splat [Intrinsic] public static unsafe Vector128 LoadScalarAndSplatVector128(ushort* address) => LoadScalarAndSplatVector128(address); - /// - /// v128.load32_splat - /// + /// v128.load32_splat [Intrinsic] public static unsafe Vector128 LoadScalarAndSplatVector128(int* address) => LoadScalarAndSplatVector128(address); - /// - /// v128.load32_splat - /// + /// v128.load32_splat [Intrinsic] public static unsafe Vector128 LoadScalarAndSplatVector128(uint* address) => LoadScalarAndSplatVector128(address); - /// - /// v128.load64_splat - /// + /// v128.load64_splat [Intrinsic] public static unsafe Vector128 LoadScalarAndSplatVector128(long* address) => LoadScalarAndSplatVector128(address); - /// - /// v128.load64_splat - /// + /// v128.load64_splat [Intrinsic] public static unsafe Vector128 LoadScalarAndSplatVector128(ulong* address) => LoadScalarAndSplatVector128(address); - /// - /// v128.load64_splat - /// + /// v128.load64_splat [Intrinsic] public static unsafe Vector128 LoadScalarAndSplatVector128(float* address) => LoadScalarAndSplatVector128(address); - /// - /// v128.load64_splat - /// + /// v128.load64_splat [Intrinsic] public static unsafe Vector128 LoadScalarAndSplatVector128(double* address) => LoadScalarAndSplatVector128(address); - /// - /// v128.load64_splat - /// + /// v128.load64_splat [Intrinsic] public static unsafe Vector128 LoadScalarAndSplatVector128(nint* address) => LoadScalarAndSplatVector128(address); - /// - /// v128.load64_splat - /// + /// v128.load64_splat [Intrinsic] public static unsafe Vector128 LoadScalarAndSplatVector128(nuint* address) => LoadScalarAndSplatVector128(address); - /// - /// v128.load8_lane - /// + /// v128.load8_lane [Intrinsic] public static unsafe Vector128 LoadScalarAndInsert(sbyte* address, Vector128 vector, [ConstantExpected(Max = (byte)(15))] byte index) => LoadScalarAndInsert(address, vector, index); // takes ImmLaneIdx16 - /// - /// v128.load8_lane - /// + /// v128.load8_lane [Intrinsic] public static unsafe Vector128 LoadScalarAndInsert(byte* address, Vector128 vector, [ConstantExpected(Max = (byte)(15))] byte index) => LoadScalarAndInsert(address, vector, index); // takes ImmLaneIdx16 - /// - /// v128.load16_lane - /// + /// v128.load16_lane [Intrinsic] public static unsafe Vector128 LoadScalarAndInsert(short* address, Vector128 vector, [ConstantExpected(Max = (byte)(7))] byte index) => LoadScalarAndInsert(address, vector, index); // takes ImmLaneIdx8 - /// - /// v128.load16_lane - /// + /// v128.load16_lane [Intrinsic] public static unsafe Vector128 LoadScalarAndInsert(ushort* address, Vector128 vector, [ConstantExpected(Max = (byte)(7))] byte index) => LoadScalarAndInsert(address, vector, index); // takes ImmLaneIdx8 - /// - /// v128.load32_lane - /// + /// v128.load32_lane [Intrinsic] public static unsafe Vector128 LoadScalarAndInsert(int* address, Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) => LoadScalarAndInsert(address, vector, index); // takes ImmLaneIdx4 - /// - /// v128.load32_lane - /// + /// v128.load32_lane [Intrinsic] public static unsafe Vector128 LoadScalarAndInsert(uint* address, Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) => LoadScalarAndInsert(address, vector, index); // takes ImmLaneIdx4 - /// - /// v128.load64_lane - /// + /// v128.load64_lane [Intrinsic] public static unsafe Vector128 LoadScalarAndInsert(long* address, Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte index) => LoadScalarAndInsert(address, vector, index); // takes ImmLaneIdx2 - /// - /// v128.load64_lane - /// + /// v128.load64_lane [Intrinsic] public static unsafe Vector128 LoadScalarAndInsert(ulong* address, Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte index) => LoadScalarAndInsert(address, vector, index); // takes ImmLaneIdx2 - /// - /// v128.load32_lane - /// + /// v128.load32_lane [Intrinsic] public static unsafe Vector128 LoadScalarAndInsert(float* address, Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) => LoadScalarAndInsert(address, vector, index); // takes ImmLaneIdx4 - /// - /// v128.load64_lane - /// + /// v128.load64_lane [Intrinsic] public static unsafe Vector128 LoadScalarAndInsert(double* address, Vector128 vector, [ConstantExpected(Max = (byte)(1))] byte index) => LoadScalarAndInsert(address, vector, index); // takes ImmLaneIdx2 - /// - /// v128.load32_lane - /// + /// v128.load32_lane [Intrinsic] public static unsafe Vector128 LoadScalarAndInsert(nint* address, Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) => LoadScalarAndInsert(address, vector, index); // takes ImmLaneIdx4 - /// - /// v128.load32_lane - /// + /// v128.load32_lane [Intrinsic] public static unsafe Vector128 LoadScalarAndInsert(nuint* address, Vector128 vector, [ConstantExpected(Max = (byte)(3))] byte index) => LoadScalarAndInsert(address, vector, index); // takes ImmLaneIdx4 // Store - /// - /// v128.store - /// + /// v128.store [Intrinsic] public static unsafe void Store(sbyte* address, Vector128 source) => Store(address, source); - /// - /// v128.store - /// + /// v128.store [Intrinsic] public static unsafe void Store(byte* address, Vector128 source) => Store(address, source); - /// - /// v128.store - /// + /// v128.store [Intrinsic] public static unsafe void Store(short* address, Vector128 source) => Store(address, source); - /// - /// v128.store - /// + /// v128.store [Intrinsic] public static unsafe void Store(ushort* address, Vector128 source) => Store(address, source); - /// - /// v128.store - /// + /// v128.store [Intrinsic] public static unsafe void Store(int* address, Vector128 source) => Store(address, source); - /// - /// v128.store - /// + /// v128.store [Intrinsic] public static unsafe void Store(uint* address, Vector128 source) => Store(address, source); - /// - /// v128.store - /// + /// v128.store [Intrinsic] public static unsafe void Store(long* address, Vector128 source) => Store(address, source); - /// - /// v128.store - /// + /// v128.store [Intrinsic] public static unsafe void Store(ulong* address, Vector128 source) => Store(address, source); - /// - /// v128.store - /// + /// v128.store [Intrinsic] public static unsafe void Store(float* address, Vector128 source) => Store(address, source); - /// - /// v128.store - /// + /// v128.store [Intrinsic] public static unsafe void Store(double* address, Vector128 source) => Store(address, source); - /// - /// v128.store - /// + /// v128.store [Intrinsic] public static unsafe void Store(nint* address, Vector128 source) => Store(address, source); - /// - /// v128.store - /// + /// v128.store [Intrinsic] public static unsafe void Store(nuint* address, Vector128 source) => Store(address, source); - /// - /// v128.store8_lane - /// + /// v128.store8_lane [Intrinsic] public static unsafe void StoreSelectedScalar(sbyte* address, Vector128 source, [ConstantExpected(Max = (byte)(15))] byte index) => StoreSelectedScalar(address, source, index); // takes ImmLaneIdx16 - /// - /// v128.store8_lane - /// + /// v128.store8_lane [Intrinsic] public static unsafe void StoreSelectedScalar(byte* address, Vector128 source, [ConstantExpected(Max = (byte)(15))] byte index) => StoreSelectedScalar(address, source, index); // takes ImmLaneIdx16 - /// - /// v128.store16_lane - /// + /// v128.store16_lane [Intrinsic] public static unsafe void StoreSelectedScalar(short* address, Vector128 source, [ConstantExpected(Max = (byte)(7))] byte index) => StoreSelectedScalar(address, source, index); // takes ImmLaneIdx8 - /// - /// v128.store16_lane - /// + /// v128.store16_lane [Intrinsic] public static unsafe void StoreSelectedScalar(ushort* address, Vector128 source, [ConstantExpected(Max = (byte)(7))] byte index) => StoreSelectedScalar(address, source, index); // takes ImmLaneIdx8 - /// - /// v128.store32_lane - /// + /// v128.store32_lane [Intrinsic] public static unsafe void StoreSelectedScalar(int* address, Vector128 source, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, source, index); // takes ImmLaneIdx4 - /// - /// v128.store32_lane - /// + /// v128.store32_lane [Intrinsic] public static unsafe void StoreSelectedScalar(uint* address, Vector128 source, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, source, index); // takes ImmLaneIdx4 - /// - /// v128.store64_lane - /// + /// v128.store64_lane [Intrinsic] public static unsafe void StoreSelectedScalar(long* address, Vector128 source, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, source, index); // takes ImmLaneIdx2 - /// - /// v128.store64_lane - /// + /// v128.store64_lane [Intrinsic] public static unsafe void StoreSelectedScalar(ulong* address, Vector128 source, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, source, index); // takes ImmLaneIdx2 - /// - /// v128.store32_lane - /// + /// v128.store32_lane [Intrinsic] public static unsafe void StoreSelectedScalar(float* address, Vector128 source, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, source, index); // takes ImmLaneIdx4 - /// - /// v128.store64_lane - /// + /// v128.store64_lane [Intrinsic] public static unsafe void StoreSelectedScalar(double* address, Vector128 source, [ConstantExpected(Max = (byte)(1))] byte index) => StoreSelectedScalar(address, source, index); // takes ImmLaneIdx2 - /// - /// v128.store32_lane - /// + /// v128.store32_lane [Intrinsic] public static unsafe void StoreSelectedScalar(nint* address, Vector128 source, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, source, index); - /// - /// v128.store32_lane - /// + /// v128.store32_lane [Intrinsic] public static unsafe void StoreSelectedScalar(nuint* address, Vector128 source, [ConstantExpected(Max = (byte)(3))] byte index) => StoreSelectedScalar(address, source, index); - /// - /// v128.load8x8_s - /// + /// v128.load8x8_s [Intrinsic] public static unsafe Vector128 LoadWideningVector128(sbyte* address) => LoadWideningVector128(address); - /// - /// v128.load8x8_u - /// + /// v128.load8x8_u [Intrinsic] public static unsafe Vector128 LoadWideningVector128(byte* address) => LoadWideningVector128(address); - /// - /// v128.load16x4_s - /// + /// v128.load16x4_s [Intrinsic] public static unsafe Vector128 LoadWideningVector128(short* address) => LoadWideningVector128(address); - /// - /// v128.load16x4_u - /// + /// v128.load16x4_u [Intrinsic] public static unsafe Vector128 LoadWideningVector128(ushort* address) => LoadWideningVector128(address); - /// - /// v128.load32x2_s - /// + /// v128.load32x2_s [Intrinsic] public static unsafe Vector128 LoadWideningVector128(int* address) => LoadWideningVector128(address); - /// - /// v128.load32x2_u - /// + /// v128.load32x2_u [Intrinsic] public static unsafe Vector128 LoadWideningVector128(uint* address) => LoadWideningVector128(address); // Floating-point sign bit operations - /// - /// f32x4.neg - /// + /// f32x4.neg [Intrinsic] public static Vector128 Negate(Vector128 value) => Negate(value); - /// - /// f64x2.neg - /// + /// f64x2.neg [Intrinsic] public static Vector128 Negate(Vector128 value) => Negate(value); - /// - /// f32x4.abs - /// + /// f32x4.abs [Intrinsic] public static Vector128 Abs(Vector128 value) => Abs(value); - /// - /// f64x2.abs - /// + /// f64x2.abs [Intrinsic] public static Vector128 Abs(Vector128 value) => Abs(value); // Floating-point min and max - /// - /// f32x4.min - /// + /// f32x4.min [Intrinsic] public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); - /// - /// f64x2.min - /// + /// f64x2.min [Intrinsic] public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); - /// - /// f32x4.max - /// + /// f32x4.max [Intrinsic] public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); - /// - /// f64x2.max - /// + /// f64x2.max [Intrinsic] public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); - /// - /// f32x4.pmin - /// + /// f32x4.pmin [Intrinsic] public static Vector128 PseudoMin(Vector128 left, Vector128 right) => PseudoMin(left, right); - /// - /// f64x2.pmin - /// + /// f64x2.pmin [Intrinsic] public static Vector128 PseudoMin(Vector128 left, Vector128 right) => PseudoMin(left, right); - /// - /// f32x4.pmax - /// + /// f32x4.pmax [Intrinsic] public static Vector128 PseudoMax(Vector128 left, Vector128 right) => PseudoMax(left, right); - /// - /// f64x2.pmax - /// + /// f64x2.pmax [Intrinsic] public static Vector128 PseudoMax(Vector128 left, Vector128 right) => PseudoMax(left, right); // Floating-point arithmetic - /// - /// f32x4.add - /// + /// f32x4.add [Intrinsic] public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); - /// - /// f64x2.add - /// + /// f64x2.add [Intrinsic] public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); - /// - /// f32x4.sub - /// + /// f32x4.sub [Intrinsic] public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); - /// - /// f64x2.sub - /// + /// f64x2.sub [Intrinsic] public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); - /// - /// f32x4.div - /// + /// f32x4.div [Intrinsic] public static Vector128 Divide(Vector128 left, Vector128 right) => Divide(left, right); - /// - /// f64x2.div - /// + /// f64x2.div [Intrinsic] public static Vector128 Divide(Vector128 left, Vector128 right) => Divide(left, right); - /// - /// f32x4.mul - /// + /// f32x4.mul [Intrinsic] public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); - /// - /// f64x2.mul - /// + /// f64x2.mul [Intrinsic] public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); - /// - /// f32x4.sqrt - /// + /// f32x4.sqrt [Intrinsic] public static Vector128 Sqrt(Vector128 value) => Sqrt(value); - /// - /// f64x2.sqrt - /// + /// f64x2.sqrt [Intrinsic] public static Vector128 Sqrt(Vector128 value) => Sqrt(value); - /// - /// f32x4.ceil - /// + /// f32x4.ceil [Intrinsic] public static Vector128 Ceiling(Vector128 value) => Ceiling(value); - /// - /// f64x2.ceil - /// + /// f64x2.ceil [Intrinsic] public static Vector128 Ceiling(Vector128 value) => Ceiling(value); - /// - /// f32x4.floor - /// + /// f32x4.floor [Intrinsic] public static Vector128 Floor(Vector128 value) => Floor(value); - /// - /// f64x2.floor - /// + /// f64x2.floor [Intrinsic] public static Vector128 Floor(Vector128 value) => Floor(value); - /// - /// f32x4.trunc - /// + /// f32x4.trunc [Intrinsic] public static Vector128 Truncate(Vector128 value) => Truncate(value); - /// - /// f64x2.trunc - /// + /// f64x2.trunc [Intrinsic] public static Vector128 Truncate(Vector128 value) => Truncate(value); - /// - /// f32x4.nearest - /// + /// f32x4.nearest [Intrinsic] public static Vector128 RoundToNearest(Vector128 value) => RoundToNearest(value); - /// - /// f64x2.nearest - /// + /// f64x2.nearest [Intrinsic] public static Vector128 RoundToNearest(Vector128 value) => RoundToNearest(value); // Conversions - /// - /// f32x4.convert_i32x4_s - /// + /// f32x4.convert_i32x4_s [Intrinsic] public static Vector128 ConvertToSingle(Vector128 value) => ConvertToSingle(value); - /// - /// f32x4.convert_i32x4_u - /// + /// f32x4.convert_i32x4_u [Intrinsic] public static Vector128 ConvertToSingle(Vector128 value) => ConvertToSingle(value); - /// - /// f32x4.demote_f64x2_zero - /// + /// f32x4.demote_f64x2_zero [Intrinsic] public static Vector128 ConvertToSingle(Vector128 value) => ConvertToSingle(value); - /// - /// f64x2.convert_low_i32x4_s - /// + /// f64x2.convert_low_i32x4_s [Intrinsic] public static Vector128 ConvertToDoubleLower(Vector128 value) => ConvertToDoubleLower(value); - /// - /// f64x2.convert_low_i32x4_u - /// + /// f64x2.convert_low_i32x4_u [Intrinsic] public static Vector128 ConvertToDoubleLower(Vector128 value) => ConvertToDoubleLower(value); - /// - /// f64x2.promote_low_f32x4 - /// + /// f64x2.promote_low_f32x4 [Intrinsic] public static Vector128 ConvertToDoubleLower(Vector128 value) => ConvertToDoubleLower(value); - /// - /// i32x4.trunc_sat_f32x4_s - /// + /// i32x4.trunc_sat_f32x4_s [Intrinsic] public static Vector128 ConvertToInt32Saturate(Vector128 value) => ConvertToInt32Saturate(value); - /// - /// i32x4.trunc_sat_f32x4_u - /// + /// i32x4.trunc_sat_f32x4_u [Intrinsic] public static Vector128 ConvertToUInt32Saturate(Vector128 value) => ConvertToUInt32Saturate(value); - /// - /// i32x4.trunc_sat_f64x2_s_zero - /// + /// i32x4.trunc_sat_f64x2_s_zero [Intrinsic] public static Vector128 ConvertToInt32Saturate(Vector128 value) => ConvertToInt32Saturate(value); - /// - /// i32x4.trunc_sat_f64x2_u_zero - /// + /// i32x4.trunc_sat_f64x2_u_zero [Intrinsic] public static Vector128 ConvertToUInt32Saturate(Vector128 value) => ConvertToUInt32Saturate(value); - /// - /// i8x16.narrow_i16x8_s - /// + /// i8x16.narrow_i16x8_s [Intrinsic] public static Vector128 ConvertNarrowingSaturateSigned(Vector128 lower, Vector128 upper) => ConvertNarrowingSaturateSigned(lower, upper); - /// - /// i16x8.narrow_i32x4_s - /// + /// i16x8.narrow_i32x4_s [Intrinsic] public static Vector128 ConvertNarrowingSaturateSigned(Vector128 lower, Vector128 upper) => ConvertNarrowingSaturateSigned(lower, upper); - /// - /// i8x16.narrow_i16x8_u - /// + /// i8x16.narrow_i16x8_u [Intrinsic] public static Vector128 ConvertNarrowingSaturateUnsigned(Vector128 lower, Vector128 upper) => ConvertNarrowingSaturateUnsigned(lower, upper); - /// - /// i16x8.narrow_i32x4_u - /// + /// i16x8.narrow_i32x4_u [Intrinsic] public static Vector128 ConvertNarrowingSaturateUnsigned(Vector128 lower, Vector128 upper) => ConvertNarrowingSaturateUnsigned(lower, upper); - /// - /// i16x8.extend_low_i8x16_s - /// + /// i16x8.extend_low_i8x16_s [Intrinsic] public static Vector128 SignExtendWideningLower(Vector128 value) => SignExtendWideningLower(value); - /// - /// i16x8.extend_low_i8x16_s - /// + /// i16x8.extend_low_i8x16_s [Intrinsic] public static Vector128 SignExtendWideningLower(Vector128 value) => SignExtendWideningLower(value); - /// - /// i32x4.extend_low_i16x8_s - /// + /// i32x4.extend_low_i16x8_s [Intrinsic] public static Vector128 SignExtendWideningLower(Vector128 value) => SignExtendWideningLower(value); - /// - /// i32x4.extend_low_i16x8_s - /// + /// i32x4.extend_low_i16x8_s [Intrinsic] public static Vector128 SignExtendWideningLower(Vector128 value) => SignExtendWideningLower(value); - /// - /// i64x2.extend_low_i32x4_s - /// + /// i64x2.extend_low_i32x4_s [Intrinsic] public static Vector128 SignExtendWideningLower(Vector128 value) => SignExtendWideningLower(value); - /// - /// i64x2.extend_low_i32x4_s - /// + /// i64x2.extend_low_i32x4_s [Intrinsic] public static Vector128 SignExtendWideningLower(Vector128 value) => SignExtendWideningLower(value); - /// - /// i16x8.extend_high_i8x16_s - /// + /// i16x8.extend_high_i8x16_s [Intrinsic] public static Vector128 SignExtendWideningUpper(Vector128 value) => SignExtendWideningUpper(value); - /// - /// i16x8.extend_high_i8x16_s - /// + /// i16x8.extend_high_i8x16_s [Intrinsic] public static Vector128 SignExtendWideningUpper(Vector128 value) => SignExtendWideningUpper(value); - /// - /// i32x4.extend_high_i16x8_s - /// + /// i32x4.extend_high_i16x8_s [Intrinsic] public static Vector128 SignExtendWideningUpper(Vector128 value) => SignExtendWideningUpper(value); - /// - /// i32x4.extend_high_i16x8_s - /// + /// i32x4.extend_high_i16x8_s [Intrinsic] public static Vector128 SignExtendWideningUpper(Vector128 value) => SignExtendWideningUpper(value); - /// - /// i64x2.extend_high_i32x4_s - /// + /// i64x2.extend_high_i32x4_s [Intrinsic] public static Vector128 SignExtendWideningUpper(Vector128 value) => SignExtendWideningUpper(value); - /// - /// i64x2.extend_high_i32x4_s - /// + /// i64x2.extend_high_i32x4_s [Intrinsic] public static Vector128 SignExtendWideningUpper(Vector128 value) => SignExtendWideningUpper(value); - /// - /// i16x8.extend_low_i8x16_u - /// + /// i16x8.extend_low_i8x16_u [Intrinsic] public static Vector128 ZeroExtendWideningLower(Vector128 value) => ZeroExtendWideningLower(value); - /// - /// i16x8.extend_low_i8x16_u - /// + /// i16x8.extend_low_i8x16_u [Intrinsic] public static Vector128 ZeroExtendWideningLower(Vector128 value) => ZeroExtendWideningLower(value); - /// - /// i32x4.extend_low_i16x8_u - /// + /// i32x4.extend_low_i16x8_u [Intrinsic] public static Vector128 ZeroExtendWideningLower(Vector128 value) => ZeroExtendWideningLower(value); - /// - /// i32x4.extend_low_i16x8_u - /// + /// i32x4.extend_low_i16x8_u [Intrinsic] public static Vector128 ZeroExtendWideningLower(Vector128 value) => ZeroExtendWideningLower(value); - /// - /// i64x2.extend_low_i32x4_u - /// + /// i64x2.extend_low_i32x4_u [Intrinsic] public static Vector128 ZeroExtendWideningLower(Vector128 value) => ZeroExtendWideningLower(value); - /// - /// i64x2.extend_low_i32x4_u - /// + /// i64x2.extend_low_i32x4_u [Intrinsic] public static Vector128 ZeroExtendWideningLower(Vector128 value) => ZeroExtendWideningLower(value); - /// - /// i16x8.extend_high_i8x16_u - /// + /// i16x8.extend_high_i8x16_u [Intrinsic] public static Vector128 ZeroExtendWideningUpper(Vector128 value) => ZeroExtendWideningUpper(value); - /// - /// i16x8.extend_high_i8x16_u - /// + /// i16x8.extend_high_i8x16_u [Intrinsic] public static Vector128 ZeroExtendWideningUpper(Vector128 value) => ZeroExtendWideningUpper(value); - /// - /// i32x4.extend_high_i16x8_u - /// + /// i32x4.extend_high_i16x8_u [Intrinsic] public static Vector128 ZeroExtendWideningUpper(Vector128 value) => ZeroExtendWideningUpper(value); - /// - /// i32x4.extend_high_i16x8_u - /// + /// i32x4.extend_high_i16x8_u [Intrinsic] public static Vector128 ZeroExtendWideningUpper(Vector128 value) => ZeroExtendWideningUpper(value); - /// - /// i64x2.extend_high_i32x4_u - /// + /// i64x2.extend_high_i32x4_u [Intrinsic] public static Vector128 ZeroExtendWideningUpper(Vector128 value) => ZeroExtendWideningUpper(value); - /// - /// i64x2.extend_high_i32x4_u - /// + /// i64x2.extend_high_i32x4_u [Intrinsic] public static Vector128 ZeroExtendWideningUpper(Vector128 value) => ZeroExtendWideningUpper(value); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/WasmBase.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/WasmBase.PlatformNotSupported.cs index e12c419b638..242c208ee25 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/WasmBase.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/WasmBase.PlatformNotSupported.cs @@ -5,46 +5,33 @@ namespace System.Runtime.Intrinsics.Wasm { internal abstract class WasmBase { + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static bool IsSupported => false; - /// - /// i32.clz - /// + /// i32.clz public static int LeadingZeroCount(int value) { throw new PlatformNotSupportedException(); } - /// - /// i32.clz - /// + /// i32.clz public static int LeadingZeroCount(uint value) { throw new PlatformNotSupportedException(); } - /// - /// i64.clz - /// + /// i64.clz public static int LeadingZeroCount(long value) { throw new PlatformNotSupportedException(); } - /// - /// i64.clz - /// + /// i64.clz public static int LeadingZeroCount(ulong value) { throw new PlatformNotSupportedException(); } - /// - /// i32.ctz - /// + /// i32.ctz public static int TrailingZeroCount(int value) { throw new PlatformNotSupportedException(); } - /// - /// i32.ctz - /// + /// i32.ctz public static int TrailingZeroCount(uint value) { throw new PlatformNotSupportedException(); } - /// - /// i64.ctz - /// + /// i64.ctz public static int TrailingZeroCount(long value) { throw new PlatformNotSupportedException(); } - /// - /// i64.ctz - /// + /// i64.ctz public static int TrailingZeroCount(ulong value) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/WasmBase.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/WasmBase.cs index cbe39940434..e4fe4618bd3 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/WasmBase.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Wasm/WasmBase.cs @@ -9,46 +9,33 @@ namespace System.Runtime.Intrinsics.Wasm [Intrinsic] internal abstract class WasmBase { + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static bool IsSupported { get => IsSupported; } - /// - /// i32.clz - /// + /// i32.clz public static int LeadingZeroCount(int value) => LeadingZeroCount(value); - /// - /// i32.clz - /// + /// i32.clz public static int LeadingZeroCount(uint value) => LeadingZeroCount(value); - /// - /// i64.clz - /// + /// i64.clz public static int LeadingZeroCount(long value) => LeadingZeroCount(value); - /// - /// i64.clz - /// + /// i64.clz public static int LeadingZeroCount(ulong value) => LeadingZeroCount(value); - /// - /// i32.ctz - /// + /// i32.ctz public static int TrailingZeroCount(int value) => TrailingZeroCount(value); - /// - /// i32.ctz - /// + /// i32.ctz public static int TrailingZeroCount(uint value) => TrailingZeroCount(value); - /// - /// i64.ctz - /// + /// i64.ctz public static int TrailingZeroCount(long value) => TrailingZeroCount(value); - /// - /// i64.ctz - /// + /// i64.ctz public static int TrailingZeroCount(ulong value) => TrailingZeroCount(value); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Aes.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Aes.PlatformNotSupported.cs index b4a56e0b9d6..d5c16c9b989 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Aes.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Aes.PlatformNotSupported.cs @@ -8,62 +8,67 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel AES hardware instructions via intrinsics - /// + /// Provides access to X86 AES hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Aes : Sse2 { internal Aes() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } + /// Provides access to the x86 AES hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class X64 : Sse2.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } } /// - /// __m128i _mm_aesdec_si128 (__m128i a, __m128i RoundKey) - /// AESDEC xmm1, xmm2/m128 - /// VAESDEC xmm1, xmm2, xmm3/m128 + /// __m128i _mm_aesdec_si128 (__m128i a, __m128i RoundKey) + /// AESDEC xmm1, xmm2/m128 + /// VAESDEC xmm1, xmm2, xmm3/m128 /// public static Vector128 Decrypt(Vector128 value, Vector128 roundKey) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_aesdeclast_si128 (__m128i a, __m128i RoundKey) - /// AESDECLAST xmm1, xmm2/m128 - /// VAESDECLAST xmm1, xmm2, xmm3/m128 + /// __m128i _mm_aesdeclast_si128 (__m128i a, __m128i RoundKey) + /// AESDECLAST xmm1, xmm2/m128 + /// VAESDECLAST xmm1, xmm2, xmm3/m128 /// public static Vector128 DecryptLast(Vector128 value, Vector128 roundKey) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_aesenc_si128 (__m128i a, __m128i RoundKey) - /// AESENC xmm1, xmm2/m128 - /// VAESENC xmm1, xmm2, xmm3/m128 + /// __m128i _mm_aesenc_si128 (__m128i a, __m128i RoundKey) + /// AESENC xmm1, xmm2/m128 + /// VAESENC xmm1, xmm2, xmm3/m128 /// public static Vector128 Encrypt(Vector128 value, Vector128 roundKey) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_aesenclast_si128 (__m128i a, __m128i RoundKey) - /// AESENCLAST xmm1, xmm2/m128 - /// VAESENCLAST xmm1, xmm2, xmm3/m128 + /// __m128i _mm_aesenclast_si128 (__m128i a, __m128i RoundKey) + /// AESENCLAST xmm1, xmm2/m128 + /// VAESENCLAST xmm1, xmm2, xmm3/m128 /// public static Vector128 EncryptLast(Vector128 value, Vector128 roundKey) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_aesimc_si128 (__m128i a) - /// AESIMC xmm1, xmm2/m128 - /// VAESIMC xmm1, xmm2/m128 + /// __m128i _mm_aesimc_si128 (__m128i a) + /// AESIMC xmm1, xmm2/m128 + /// VAESIMC xmm1, xmm2/m128 /// public static Vector128 InverseMixColumns(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_aeskeygenassist_si128 (__m128i a, const int imm8) - /// AESKEYGENASSIST xmm1, xmm2/m128, imm8 - /// VAESKEYGENASSIST xmm1, xmm2/m128, imm8 + /// __m128i _mm_aeskeygenassist_si128 (__m128i a, const int imm8) + /// AESKEYGENASSIST xmm1, xmm2/m128, imm8 + /// VAESKEYGENASSIST xmm1, xmm2/m128, imm8 /// public static Vector128 KeygenAssist(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Aes.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Aes.cs index 1424a66dc83..b60258d3903 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Aes.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Aes.cs @@ -6,64 +6,69 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel AES hardware instructions via intrinsics - /// + /// Provides access to X86 AES hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Aes : Sse2 { internal Aes() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the x86 AES hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : Sse2.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } } /// - /// __m128i _mm_aesdec_si128 (__m128i a, __m128i RoundKey) - /// AESDEC xmm1, xmm2/m128 - /// VAESDEC xmm1, xmm2, xmm3/m128 + /// __m128i _mm_aesdec_si128 (__m128i a, __m128i RoundKey) + /// AESDEC xmm1, xmm2/m128 + /// VAESDEC xmm1, xmm2, xmm3/m128 /// public static Vector128 Decrypt(Vector128 value, Vector128 roundKey) => Decrypt(value, roundKey); /// - /// __m128i _mm_aesdeclast_si128 (__m128i a, __m128i RoundKey) - /// AESDECLAST xmm1, xmm2/m128 - /// VAESDECLAST xmm1, xmm2, xmm3/m128 + /// __m128i _mm_aesdeclast_si128 (__m128i a, __m128i RoundKey) + /// AESDECLAST xmm1, xmm2/m128 + /// VAESDECLAST xmm1, xmm2, xmm3/m128 /// public static Vector128 DecryptLast(Vector128 value, Vector128 roundKey) => DecryptLast(value, roundKey); /// - /// __m128i _mm_aesenc_si128 (__m128i a, __m128i RoundKey) - /// AESENC xmm1, xmm2/m128 - /// VAESENC xmm1, xmm2, xmm3/m128 + /// __m128i _mm_aesenc_si128 (__m128i a, __m128i RoundKey) + /// AESENC xmm1, xmm2/m128 + /// VAESENC xmm1, xmm2, xmm3/m128 /// public static Vector128 Encrypt(Vector128 value, Vector128 roundKey) => Encrypt(value, roundKey); /// - /// __m128i _mm_aesenclast_si128 (__m128i a, __m128i RoundKey) - /// AESENCLAST xmm1, xmm2/m128 - /// VAESENCLAST xmm1, xmm2, xmm3/m128 + /// __m128i _mm_aesenclast_si128 (__m128i a, __m128i RoundKey) + /// AESENCLAST xmm1, xmm2/m128 + /// VAESENCLAST xmm1, xmm2, xmm3/m128 /// public static Vector128 EncryptLast(Vector128 value, Vector128 roundKey) => EncryptLast(value, roundKey); /// - /// __m128i _mm_aesimc_si128 (__m128i a) - /// AESIMC xmm1, xmm2/m128 - /// VAESIMC xmm1, xmm2/m128 + /// __m128i _mm_aesimc_si128 (__m128i a) + /// AESIMC xmm1, xmm2/m128 + /// VAESIMC xmm1, xmm2/m128 /// public static Vector128 InverseMixColumns(Vector128 value) => InverseMixColumns(value); /// - /// __m128i _mm_aeskeygenassist_si128 (__m128i a, const int imm8) - /// AESKEYGENASSIST xmm1, xmm2/m128, imm8 - /// VAESKEYGENASSIST xmm1, xmm2/m128, imm8 + /// __m128i _mm_aeskeygenassist_si128 (__m128i a, const int imm8) + /// AESKEYGENASSIST xmm1, xmm2/m128, imm8 + /// VAESKEYGENASSIST xmm1, xmm2/m128, imm8 /// public static Vector128 KeygenAssist(Vector128 value, [ConstantExpected] byte control) => KeygenAssist(value, control); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx.PlatformNotSupported.cs index 663071e37e6..e16db173888 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx.PlatformNotSupported.cs @@ -8,1439 +8,1444 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel AVX hardware instructions via intrinsics - /// + /// Provides access to X86 AVX hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Avx : Sse42 { internal Avx() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } + /// Provides access to the x86 AVX hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class X64 : Sse42.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } } /// - /// __m256 _mm256_add_ps (__m256 a, __m256 b) - /// VADDPS ymm1, ymm2, ymm3/m256 - /// VADDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_add_ps (__m256 a, __m256 b) + /// VADDPS ymm1, ymm2, ymm3/m256 + /// VADDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Add(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_add_pd (__m256d a, __m256d b) - /// VADDPD ymm1, ymm2, ymm3/m256 - /// VADDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_add_pd (__m256d a, __m256d b) + /// VADDPD ymm1, ymm2, ymm3/m256 + /// VADDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Add(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_addsub_ps (__m256 a, __m256 b) - /// VADDSUBPS ymm1, ymm2, ymm3/m256 + /// __m256 _mm256_addsub_ps (__m256 a, __m256 b) + /// VADDSUBPS ymm1, ymm2, ymm3/m256 /// public static Vector256 AddSubtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_addsub_pd (__m256d a, __m256d b) - /// VADDSUBPD ymm1, ymm2, ymm3/m256 + /// __m256d _mm256_addsub_pd (__m256d a, __m256d b) + /// VADDSUBPD ymm1, ymm2, ymm3/m256 /// public static Vector256 AddSubtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_and_ps (__m256 a, __m256 b) - /// VANDPS ymm1, ymm2, ymm2/m256 - /// VANDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_and_ps (__m256 a, __m256 b) + /// VANDPS ymm1, ymm2, ymm2/m256 + /// VANDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 And(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_and_pd (__m256d a, __m256d b) - /// VANDPD ymm1, ymm2, ymm2/m256 - /// VANDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_and_pd (__m256d a, __m256d b) + /// VANDPD ymm1, ymm2, ymm2/m256 + /// VANDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 And(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_andnot_ps (__m256 a, __m256 b) - /// VANDNPS ymm1, ymm2, ymm2/m256 - /// VANDNPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_andnot_ps (__m256 a, __m256 b) + /// VANDNPS ymm1, ymm2, ymm2/m256 + /// VANDNPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_andnot_pd (__m256d a, __m256d b) - /// VANDNPD ymm1, ymm2, ymm2/m256 - /// VANDNPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_andnot_pd (__m256d a, __m256d b) + /// VANDNPD ymm1, ymm2, ymm2/m256 + /// VANDNPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_blend_ps (__m256 a, __m256 b, const int imm8) - /// VBLENDPS ymm1, ymm2, ymm3/m256, imm8 + /// __m256 _mm256_blend_ps (__m256 a, __m256 b, const int imm8) + /// VBLENDPS ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Blend(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_blend_pd (__m256d a, __m256d b, const int imm8) - /// VBLENDPD ymm1, ymm2, ymm3/m256, imm8 + /// __m256d _mm256_blend_pd (__m256d a, __m256d b, const int imm8) + /// VBLENDPD ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Blend(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_blendv_ps (__m256 a, __m256 b, __m256 mask) - /// VBLENDVPS ymm1, ymm2, ymm3/m256, ymm4 + /// __m256 _mm256_blendv_ps (__m256 a, __m256 b, __m256 mask) + /// VBLENDVPS ymm1, ymm2, ymm3/m256, ymm4 /// public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_blendv_pd (__m256d a, __m256d b, __m256d mask) - /// VBLENDVPD ymm1, ymm2, ymm3/m256, ymm4 + /// __m256d _mm256_blendv_pd (__m256d a, __m256d b, __m256d mask) + /// VBLENDVPD ymm1, ymm2, ymm3/m256, ymm4 /// public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_broadcast_ss (float const * mem_addr) - /// VBROADCASTSS xmm1, m32 - /// VBROADCASTSS xmm1 {k1}{z}, m32 + /// __m128 _mm_broadcast_ss (float const * mem_addr) + /// VBROADCASTSS xmm1, m32 + /// VBROADCASTSS xmm1 {k1}{z}, m32 /// public static unsafe Vector128 BroadcastScalarToVector128(float* source) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_broadcast_ss (float const * mem_addr) - /// VBROADCASTSS ymm1, m32 - /// VBROADCASTSS ymm1 {k1}{z}, m32 + /// __m256 _mm256_broadcast_ss (float const * mem_addr) + /// VBROADCASTSS ymm1, m32 + /// VBROADCASTSS ymm1 {k1}{z}, m32 /// public static unsafe Vector256 BroadcastScalarToVector256(float* source) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_broadcast_sd (double const * mem_addr) - /// VBROADCASTSD ymm1, m64 - /// VBROADCASTSD ymm1 {k1}{z}, m64 + /// __m256d _mm256_broadcast_sd (double const * mem_addr) + /// VBROADCASTSD ymm1, m64 + /// VBROADCASTSD ymm1 {k1}{z}, m64 /// public static unsafe Vector256 BroadcastScalarToVector256(double* source) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_broadcast_ps (__m128 const * mem_addr) - /// VBROADCASTF128 ymm1, m128 - /// VBROADCASTF32x4 ymm1 {k1}{z}, m128 + /// __m256 _mm256_broadcast_ps (__m128 const * mem_addr) + /// VBROADCASTF128 ymm1, m128 + /// VBROADCASTF32x4 ymm1 {k1}{z}, m128 /// public static unsafe Vector256 BroadcastVector128ToVector256(float* address) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_broadcast_pd (__m128d const * mem_addr) - /// VBROADCASTF128 ymm1, m128 - /// VBROADCASTF64x2 ymm1 {k1}{z}, m128 + /// __m256d _mm256_broadcast_pd (__m128d const * mem_addr) + /// VBROADCASTF128 ymm1, m128 + /// VBROADCASTF64x2 ymm1 {k1}{z}, m128 /// public static unsafe Vector256 BroadcastVector128ToVector256(double* address) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_ceil_ps (__m128 a) - /// VROUNDPS ymm1, ymm2/m256, imm8(10) + /// __m256 _mm256_ceil_ps (__m128 a) + /// VROUNDPS ymm1, ymm2/m256, imm8(10) /// public static Vector256 Ceiling(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_ceil_pd (__m128d a) - /// VROUNDPD ymm1, ymm2/m256, imm8(10) + /// __m256d _mm256_ceil_pd (__m128d a) + /// VROUNDPD ymm1, ymm2/m256, imm8(10) /// public static Vector256 Ceiling(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmp_ps (__m128 a, __m128 b, const int imm8) - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8 + /// __m128 _mm_cmp_ps (__m128 a, __m128 b, const int imm8) + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8 /// public static Vector128 Compare(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_cmp_ps (__m256 a, __m256 b, const int imm8) - /// VCMPPS ymm1, ymm2, ymm3/m256, imm8 + /// __m256 _mm256_cmp_ps (__m256 a, __m256 b, const int imm8) + /// VCMPPS ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Compare(Vector256 left, Vector256 right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_cmpeq_ps (__m256 a, __m256 b) - /// VCMPPS ymm1, ymm2/m256, imm8(0) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256 _mm256_cmpeq_ps (__m256 a, __m256 b) + /// VCMPPS ymm1, ymm2/m256, imm8(0) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_cmpgt_ps (__m256 a, __m256 b) - /// VCMPPS ymm1, ymm2/m256, imm8(14) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256 _mm256_cmpgt_ps (__m256 a, __m256 b) + /// VCMPPS ymm1, ymm2/m256, imm8(14) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_cmpge_ps (__m256 a, __m256 b) - /// VCMPPS ymm1, ymm2/m256, imm8(13) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256 _mm256_cmpge_ps (__m256 a, __m256 b) + /// VCMPPS ymm1, ymm2/m256, imm8(13) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_cmplt_ps (__m256 a, __m256 b) - /// VCMPPS ymm1, ymm2/m256, imm8(1) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256 _mm256_cmplt_ps (__m256 a, __m256 b) + /// VCMPPS ymm1, ymm2/m256, imm8(1) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_cmple_ps (__m256 a, __m256 b) - /// VCMPPS ymm1, ymm2/m256, imm8(2) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256 _mm256_cmple_ps (__m256 a, __m256 b) + /// VCMPPS ymm1, ymm2/m256, imm8(2) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_cmpneq_ps (__m256 a, __m256 b) - /// VCMPPS ymm1, ymm2/m256, imm8(4) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256 _mm256_cmpneq_ps (__m256 a, __m256 b) + /// VCMPPS ymm1, ymm2/m256, imm8(4) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_cmpngt_ps (__m256 a, __m256 b) - /// VCMPPS ymm1, ymm2/m256, imm8(10) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256 _mm256_cmpngt_ps (__m256 a, __m256 b) + /// VCMPPS ymm1, ymm2/m256, imm8(10) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareNotGreaterThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_cmpnge_ps (__m256 a, __m256 b) - /// VCMPPS ymm1, ymm2/m256, imm8(9) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256 _mm256_cmpnge_ps (__m256 a, __m256 b) + /// VCMPPS ymm1, ymm2/m256, imm8(9) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareNotGreaterThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_cmpnlt_ps (__m256 a, __m256 b) - /// VCMPPS ymm1, ymm2/m256, imm8(5) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256 _mm256_cmpnlt_ps (__m256 a, __m256 b) + /// VCMPPS ymm1, ymm2/m256, imm8(5) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareNotLessThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_cmpnle_ps (__m256 a, __m256 b) - /// VCMPPS ymm1, ymm2/m256, imm8(6) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256 _mm256_cmpnle_ps (__m256 a, __m256 b) + /// VCMPPS ymm1, ymm2/m256, imm8(6) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareNotLessThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_cmpord_ps (__m256 a, __m256 b) - /// VCMPPS ymm1, ymm2/m256, imm8(7) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256 _mm256_cmpord_ps (__m256 a, __m256 b) + /// VCMPPS ymm1, ymm2/m256, imm8(7) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareOrdered(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_cmpunord_ps (__m256 a, __m256 b) - /// VCMPPS ymm1, ymm2/m256, imm8(3) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256 _mm256_cmpunord_ps (__m256 a, __m256 b) + /// VCMPPS ymm1, ymm2/m256, imm8(3) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareUnordered(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmp_pd (__m128d a, __m128d b, const int imm8) - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8 + /// __m128d _mm_cmp_pd (__m128d a, __m128d b, const int imm8) + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8 /// public static Vector128 Compare(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_cmp_pd (__m256d a, __m256d b, const int imm8) - /// VCMPPD ymm1, ymm2, ymm3/m256, imm8 + /// __m256d _mm256_cmp_pd (__m256d a, __m256d b, const int imm8) + /// VCMPPD ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Compare(Vector256 left, Vector256 right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_cmpeq_pd (__m256d a, __m256d b) - /// VCMPPD ymm1, ymm2/m256, imm8(0) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256d _mm256_cmpeq_pd (__m256d a, __m256d b) + /// VCMPPD ymm1, ymm2/m256, imm8(0) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_cmpgt_pd (__m256d a, __m256d b) - /// VCMPPD ymm1, ymm2/m256, imm8(14) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256d _mm256_cmpgt_pd (__m256d a, __m256d b) + /// VCMPPD ymm1, ymm2/m256, imm8(14) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_cmpge_pd (__m256d a, __m256d b) - /// VCMPPD ymm1, ymm2/m256, imm8(13) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256d _mm256_cmpge_pd (__m256d a, __m256d b) + /// VCMPPD ymm1, ymm2/m256, imm8(13) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_cmplt_pd (__m256d a, __m256d b) - /// VCMPPD ymm1, ymm2/m256, imm8(1) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256d _mm256_cmplt_pd (__m256d a, __m256d b) + /// VCMPPD ymm1, ymm2/m256, imm8(1) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_cmple_pd (__m256d a, __m256d b) - /// VCMPPD ymm1, ymm2/m256, imm8(2) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256d _mm256_cmple_pd (__m256d a, __m256d b) + /// VCMPPD ymm1, ymm2/m256, imm8(2) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_cmpneq_pd (__m256d a, __m256d b) - /// VCMPPD ymm1, ymm2/m256, imm8(4) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256d _mm256_cmpneq_pd (__m256d a, __m256d b) + /// VCMPPD ymm1, ymm2/m256, imm8(4) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_cmpngt_pd (__m256d a, __m256d b) - /// VCMPPD ymm1, ymm2/m256, imm8(10) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256d _mm256_cmpngt_pd (__m256d a, __m256d b) + /// VCMPPD ymm1, ymm2/m256, imm8(10) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareNotGreaterThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_cmpnge_pd (__m256d a, __m256d b) - /// VCMPPD ymm1, ymm2/m256, imm8(9) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256d _mm256_cmpnge_pd (__m256d a, __m256d b) + /// VCMPPD ymm1, ymm2/m256, imm8(9) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareNotGreaterThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_cmpnlt_pd (__m256d a, __m256d b) - /// VCMPPD ymm1, ymm2/m256, imm8(5) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256d _mm256_cmpnlt_pd (__m256d a, __m256d b) + /// VCMPPD ymm1, ymm2/m256, imm8(5) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareNotLessThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_cmpnle_pd (__m256d a, __m256d b) - /// VCMPPD ymm1, ymm2/m256, imm8(6) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256d _mm256_cmpnle_pd (__m256d a, __m256d b) + /// VCMPPD ymm1, ymm2/m256, imm8(6) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareNotLessThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_cmpord_pd (__m256d a, __m256d b) - /// VCMPPD ymm1, ymm2/m256, imm8(7) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256d _mm256_cmpord_pd (__m256d a, __m256d b) + /// VCMPPD ymm1, ymm2/m256, imm8(7) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareOrdered(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_cmpunord_pd (__m256d a, __m256d b) - /// VCMPPD ymm1, ymm2/m256, imm8(3) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256d _mm256_cmpunord_pd (__m256d a, __m256d b) + /// VCMPPD ymm1, ymm2/m256, imm8(3) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareUnordered(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmp_ss (__m128 a, __m128 b, const int imm8) - /// VCMPSD xmm1, xmm2, xmm3/m64, imm8 + /// __m128 _mm_cmp_ss (__m128 a, __m128 b, const int imm8) + /// VCMPSD xmm1, xmm2, xmm3/m64, imm8 /// public static Vector128 CompareScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmp_sd (__m128d a, __m128d b, const int imm8) - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8 + /// __m128d _mm_cmp_sd (__m128d a, __m128d b, const int imm8) + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8 /// public static Vector128 CompareScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtpd_epi32 (__m256d a) - /// VCVTPD2DQ xmm1, ymm2/m256 - /// VCVTPD2DQ xmm1 {k1}{z}, ymm2/m256/m64bcst + /// __m128i _mm256_cvtpd_epi32 (__m256d a) + /// VCVTPD2DQ xmm1, ymm2/m256 + /// VCVTPD2DQ xmm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector128 ConvertToVector128Int32(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm256_cvtpd_ps (__m256d a) - /// VCVTPD2PS xmm1, ymm2/m256 - /// VCVTPD2PS xmm1 {k1}{z}, ymm2/m256/m64bcst + /// __m128 _mm256_cvtpd_ps (__m256d a) + /// VCVTPD2PS xmm1, ymm2/m256 + /// VCVTPD2PS xmm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector128 ConvertToVector128Single(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_cvtepi32_pd (__m128i a) - /// VCVTDQ2PD ymm1, xmm2/m128 - /// VCVTDQ2PD ymm1 {k1}{z}, xmm2/m128/m32bcst + /// __m256d _mm256_cvtepi32_pd (__m128i a) + /// VCVTDQ2PD ymm1, xmm2/m128 + /// VCVTDQ2PD ymm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector256 ConvertToVector256Double(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_cvtps_pd (__m128 a) - /// VCVTPS2PD ymm1, xmm2/m128 - /// VCVTPS2PD ymm1 {k1}{z}, xmm2/m128/m32bcst + /// __m256d _mm256_cvtps_pd (__m128 a) + /// VCVTPS2PD ymm1, xmm2/m128 + /// VCVTPS2PD ymm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector256 ConvertToVector256Double(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvtps_epi32 (__m256 a) - /// VCVTPS2DQ ymm1, ymm2/m256 - /// VCVTPS2DQ ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_cvtps_epi32 (__m256 a) + /// VCVTPS2DQ ymm1, ymm2/m256 + /// VCVTPS2DQ ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 ConvertToVector256Int32(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_cvtepi32_ps (__m256i a) - /// VCVTDQ2PS ymm1, ymm2/m256 - /// VCVTDQ2PS ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256 _mm256_cvtepi32_ps (__m256i a) + /// VCVTDQ2PS ymm1, ymm2/m256 + /// VCVTDQ2PS ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 ConvertToVector256Single(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvttps_epi32 (__m256 a) - /// VCVTTPS2DQ ymm1, ymm2/m256 - /// VCVTTPS2DQ ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_cvttps_epi32 (__m256 a) + /// VCVTTPS2DQ ymm1, ymm2/m256 + /// VCVTTPS2DQ ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 ConvertToVector256Int32WithTruncation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvttpd_epi32 (__m256d a) - /// VCVTTPD2DQ xmm1, ymm2/m256 - /// VCVTTPD2DQ xmm1 {k1}{z}, ymm2/m256/m64bcst + /// __m128i _mm256_cvttpd_epi32 (__m256d a) + /// VCVTTPD2DQ xmm1, ymm2/m256 + /// VCVTTPD2DQ xmm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector128 ConvertToVector128Int32WithTruncation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_div_ps (__m256 a, __m256 b) - /// VDIVPS ymm1, ymm2, ymm3/m256 - /// VDIVPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_div_ps (__m256 a, __m256 b) + /// VDIVPS ymm1, ymm2, ymm3/m256 + /// VDIVPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Divide(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_div_pd (__m256d a, __m256d b) - /// VDIVPD ymm1, ymm2, ymm3/m256 - /// VDIVPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_div_pd (__m256d a, __m256d b) + /// VDIVPD ymm1, ymm2, ymm3/m256 + /// VDIVPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Divide(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_dp_ps (__m256 a, __m256 b, const int imm8) - /// VDPPS ymm, ymm, ymm/m256, imm8 + /// __m256 _mm256_dp_ps (__m256 a, __m256 b, const int imm8) + /// VDPPS ymm, ymm, ymm/m256, imm8 /// public static Vector256 DotProduct(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_moveldup_ps (__m256 a) - /// VMOVSLDUP ymm1, ymm2/m256 - /// VMOVSLDUP ymm1 {k1}{z}, ymm2/m256 + /// __m256 _mm256_moveldup_ps (__m256 a) + /// VMOVSLDUP ymm1, ymm2/m256 + /// VMOVSLDUP ymm1 {k1}{z}, ymm2/m256 /// public static Vector256 DuplicateEvenIndexed(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_movedup_pd (__m256d a) - /// VMOVDDUP ymm1, ymm2/m256 - /// VMOVDDUP ymm1 {k1}{z}, ymm2/m256 + /// __m256d _mm256_movedup_pd (__m256d a) + /// VMOVDDUP ymm1, ymm2/m256 + /// VMOVDDUP ymm1 {k1}{z}, ymm2/m256 /// public static Vector256 DuplicateEvenIndexed(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_movehdup_ps (__m256 a) - /// VMOVSHDUP ymm1, ymm2/m256 - /// VMOVSHDUP ymm1 {k1}{z}, ymm2/m256 + /// __m256 _mm256_movehdup_ps (__m256 a) + /// VMOVSHDUP ymm1, ymm2/m256 + /// VMOVSHDUP ymm1 {k1}{z}, ymm2/m256 /// public static Vector256 DuplicateOddIndexed(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) - /// VEXTRACTF128 xmm1/m128, ymm2, imm8 - /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// VEXTRACTF128 xmm1/m128, ymm2, imm8 + /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) - /// VEXTRACTF128 xmm1/m128, ymm2, imm8 - /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// VEXTRACTF128 xmm1/m128, ymm2, imm8 + /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) - /// VEXTRACTF128 xmm1/m128, ymm2, imm8 - /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// VEXTRACTF128 xmm1/m128, ymm2, imm8 + /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) - /// VEXTRACTF128 xmm1/m128, ymm2, imm8 - /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// VEXTRACTF128 xmm1/m128, ymm2, imm8 + /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) - /// VEXTRACTF128 xmm1/m128, ymm2, imm8 - /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// VEXTRACTF128 xmm1/m128, ymm2, imm8 + /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) - /// VEXTRACTF128 xmm1/m128, ymm2, imm8 - /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// VEXTRACTF128 xmm1/m128, ymm2, imm8 + /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) - /// VEXTRACTF128 xmm1/m128, ymm2, imm8 - /// VEXTRACTF64x2 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// VEXTRACTF128 xmm1/m128, ymm2, imm8 + /// VEXTRACTF64x2 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) - /// VEXTRACTF128 xmm1/m128, ymm2, imm8 - /// VEXTRACTF64x2 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// VEXTRACTF128 xmm1/m128, ymm2, imm8 + /// VEXTRACTF64x2 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm256_extractf128_ps (__m256 a, const int imm8) - /// VEXTRACTF128 xmm1/m128, ymm2, imm8 - /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128 _mm256_extractf128_ps (__m256 a, const int imm8) + /// VEXTRACTF128 xmm1/m128, ymm2, imm8 + /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm256_extractf128_pd (__m256d a, const int imm8) - /// VEXTRACTF128 xmm1/m128, ymm2, imm8 - /// VEXTRACTF64x2 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128d _mm256_extractf128_pd (__m256d a, const int imm8) + /// VEXTRACTF128 xmm1/m128, ymm2, imm8 + /// VEXTRACTF64x2 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_floor_ps (__m256 a) - /// VROUNDPS ymm1, ymm2/m256, imm8(9) + /// __m256 _mm256_floor_ps (__m256 a) + /// VROUNDPS ymm1, ymm2/m256, imm8(9) /// public static Vector256 Floor(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_floor_pd (__m256d a) - /// VROUNDPD ymm1, ymm2/m256, imm8(9) + /// __m256d _mm256_floor_pd (__m256d a) + /// VROUNDPD ymm1, ymm2/m256, imm8(9) /// public static Vector256 Floor(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_hadd_ps (__m256 a, __m256 b) - /// VHADDPS ymm1, ymm2, ymm3/m256 + /// __m256 _mm256_hadd_ps (__m256 a, __m256 b) + /// VHADDPS ymm1, ymm2, ymm3/m256 /// public static Vector256 HorizontalAdd(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_hadd_pd (__m256d a, __m256d b) - /// VHADDPD ymm1, ymm2, ymm3/m256 + /// __m256d _mm256_hadd_pd (__m256d a, __m256d b) + /// VHADDPD ymm1, ymm2, ymm3/m256 /// public static Vector256 HorizontalAdd(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_hsub_ps (__m256 a, __m256 b) - /// VHSUBPS ymm1, ymm2, ymm3/m256 + /// __m256 _mm256_hsub_ps (__m256 a, __m256 b) + /// VHSUBPS ymm1, ymm2, ymm3/m256 /// public static Vector256 HorizontalSubtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_hsub_pd (__m256d a, __m256d b) - /// VHSUBPD ymm1, ymm2, ymm3/m256 + /// __m256d _mm256_hsub_pd (__m256d a, __m256d b) + /// VHSUBPD ymm1, ymm2, ymm3/m256 /// public static Vector256 HorizontalSubtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) - /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) - /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) - /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) - /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) - /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) - /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) - /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTF64x2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTF64x2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) - /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTF64x2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTF64x2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_insertf128_ps (__m256 a, __m128 b, int imm8) - /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256 _mm256_insertf128_ps (__m256 a, __m128 b, int imm8) + /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_insertf128_pd (__m256d a, __m128d b, int imm8) - /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTF64x2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256d _mm256_insertf128_pd (__m256d a, __m128d b, int imm8) + /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTF64x2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_load_si256 (__m256i const * mem_addr) - /// VMOVDQA ymm1, m256 - /// VMOVDQA32 ymm1 {k1}{z}, m256 + /// __m256i _mm256_load_si256 (__m256i const * mem_addr) + /// VMOVDQA ymm1, m256 + /// VMOVDQA32 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadAlignedVector256(sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_load_si256 (__m256i const * mem_addr) - /// VMOVDQA ymm1, m256 - /// VMOVDQA32 ymm1 {k1}{z}, m256 + /// __m256i _mm256_load_si256 (__m256i const * mem_addr) + /// VMOVDQA ymm1, m256 + /// VMOVDQA32 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadAlignedVector256(byte* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_load_si256 (__m256i const * mem_addr) - /// VMOVDQA ymm1, m256 - /// VMOVDQA32 ymm1 {k1}{z}, m256 + /// __m256i _mm256_load_si256 (__m256i const * mem_addr) + /// VMOVDQA ymm1, m256 + /// VMOVDQA32 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadAlignedVector256(short* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_load_si256 (__m256i const * mem_addr) - /// VMOVDQA ymm1, m256 - /// VMOVDQA32 ymm1 {k1}{z}, m256 + /// __m256i _mm256_load_si256 (__m256i const * mem_addr) + /// VMOVDQA ymm1, m256 + /// VMOVDQA32 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadAlignedVector256(ushort* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_load_si256 (__m256i const * mem_addr) - /// VMOVDQA ymm1, m256 - /// VMOVDQA32 ymm1 {k1}{z}, m256 + /// __m256i _mm256_load_si256 (__m256i const * mem_addr) + /// VMOVDQA ymm1, m256 + /// VMOVDQA32 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadAlignedVector256(int* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_load_si256 (__m256i const * mem_addr) - /// VMOVDQA ymm1, m256 - /// VMOVDQA32 ymm1 {k1}{z}, m256 + /// __m256i _mm256_load_si256 (__m256i const * mem_addr) + /// VMOVDQA ymm1, m256 + /// VMOVDQA32 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadAlignedVector256(uint* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_load_si256 (__m256i const * mem_addr) - /// VMOVDQA ymm1, m256 - /// VMOVDQA64 ymm1 {k1}{z}, m256 + /// __m256i _mm256_load_si256 (__m256i const * mem_addr) + /// VMOVDQA ymm1, m256 + /// VMOVDQA64 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadAlignedVector256(long* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_load_si256 (__m256i const * mem_addr) - /// VMOVDQA ymm1, m256 - /// VMOVDQA64 ymm1 {k1}{z}, m256 + /// __m256i _mm256_load_si256 (__m256i const * mem_addr) + /// VMOVDQA ymm1, m256 + /// VMOVDQA64 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadAlignedVector256(ulong* address) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_load_ps (float const * mem_addr) - /// VMOVAPS ymm1, m256 - /// VMOVAPS ymm1 {k1}{z}, m256 + /// __m256 _mm256_load_ps (float const * mem_addr) + /// VMOVAPS ymm1, m256 + /// VMOVAPS ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadAlignedVector256(float* address) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_load_pd (double const * mem_addr) - /// VMOVAPD ymm1, m256 - /// VMOVAPD ymm1 {k1}{z}, m256 + /// __m256d _mm256_load_pd (double const * mem_addr) + /// VMOVAPD ymm1, m256 + /// VMOVAPD ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadAlignedVector256(double* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) - /// VLDDQU ymm1, m256 + /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) + /// VLDDQU ymm1, m256 /// public static unsafe Vector256 LoadDquVector256(sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) - /// VLDDQU ymm1, m256 + /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) + /// VLDDQU ymm1, m256 /// public static unsafe Vector256 LoadDquVector256(byte* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) - /// VLDDQU ymm1, m256 + /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) + /// VLDDQU ymm1, m256 /// public static unsafe Vector256 LoadDquVector256(short* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) - /// VLDDQU ymm1, m256 + /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) + /// VLDDQU ymm1, m256 /// public static unsafe Vector256 LoadDquVector256(ushort* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) - /// VLDDQU ymm1, m256 + /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) + /// VLDDQU ymm1, m256 /// public static unsafe Vector256 LoadDquVector256(int* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) - /// VLDDQU ymm1, m256 + /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) + /// VLDDQU ymm1, m256 /// public static unsafe Vector256 LoadDquVector256(uint* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) - /// VLDDQU ymm1, m256 + /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) + /// VLDDQU ymm1, m256 /// public static unsafe Vector256 LoadDquVector256(long* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) - /// VLDDQU ymm1, m256 + /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) + /// VLDDQU ymm1, m256 /// public static unsafe Vector256 LoadDquVector256(ulong* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) - /// VMOVDQU ymm1, m256 - /// VMOVDQU8 ymm1 {k1}{z}, m256 + /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) + /// VMOVDQU ymm1, m256 + /// VMOVDQU8 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadVector256(sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) - /// VMOVDQU ymm1, m256 - /// VMOVDQU8 ymm1 {k1}{z}, m256 + /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) + /// VMOVDQU ymm1, m256 + /// VMOVDQU8 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadVector256(byte* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) - /// VMOVDQU ymm1, m256 - /// VMOVDQU16 ymm1 {k1}{z}, m256 + /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) + /// VMOVDQU ymm1, m256 + /// VMOVDQU16 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadVector256(short* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) - /// VMOVDQU ymm1, m256 - /// VMOVDQU16 ymm1 {k1}{z}, m256 + /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) + /// VMOVDQU ymm1, m256 + /// VMOVDQU16 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadVector256(ushort* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) - /// VMOVDQU ymm1, m256 - /// VMOVDQU32 ymm1 {k1}{z}, m256 + /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) + /// VMOVDQU ymm1, m256 + /// VMOVDQU32 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadVector256(int* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) - /// VMOVDQU ymm1, m256 - /// VMOVDQU32 ymm1 {k1}{z}, m256 + /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) + /// VMOVDQU ymm1, m256 + /// VMOVDQU32 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadVector256(uint* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) - /// VMOVDQU ymm1, m256 - /// VMOVDQU64 ymm1 {k1}{z}, m256 + /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) + /// VMOVDQU ymm1, m256 + /// VMOVDQU64 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadVector256(long* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) - /// VMOVDQU ymm1, m256 - /// VMOVDQU64 ymm1 {k1}{z}, m256 + /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) + /// VMOVDQU ymm1, m256 + /// VMOVDQU64 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadVector256(ulong* address) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_loadu_ps (float const * mem_addr) - /// VMOVUPS ymm1, m256 - /// VMOVUPS ymm1 {k1}{z}, m256 + /// __m256 _mm256_loadu_ps (float const * mem_addr) + /// VMOVUPS ymm1, m256 + /// VMOVUPS ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadVector256(float* address) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_loadu_pd (double const * mem_addr) - /// VMOVUPD ymm1, m256 - /// VMOVUPD ymm1 {k1}{z}, m256 + /// __m256d _mm256_loadu_pd (double const * mem_addr) + /// VMOVUPD ymm1, m256 + /// VMOVUPD ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadVector256(double* address) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_maskload_ps (float const * mem_addr, __m128i mask) - /// VMASKMOVPS xmm1, xmm2, m128 + /// __m128 _mm_maskload_ps (float const * mem_addr, __m128i mask) + /// VMASKMOVPS xmm1, xmm2, m128 /// public static unsafe Vector128 MaskLoad(float* address, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_maskload_pd (double const * mem_addr, __m128i mask) - /// VMASKMOVPD xmm1, xmm2, m128 + /// __m128d _mm_maskload_pd (double const * mem_addr, __m128i mask) + /// VMASKMOVPD xmm1, xmm2, m128 /// public static unsafe Vector128 MaskLoad(double* address, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_maskload_ps (float const * mem_addr, __m256i mask) - /// VMASKMOVPS ymm1, ymm2, m256 + /// __m256 _mm256_maskload_ps (float const * mem_addr, __m256i mask) + /// VMASKMOVPS ymm1, ymm2, m256 /// public static unsafe Vector256 MaskLoad(float* address, Vector256 mask) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_maskload_pd (double const * mem_addr, __m256i mask) - /// VMASKMOVPD ymm1, ymm2, m256 + /// __m256d _mm256_maskload_pd (double const * mem_addr, __m256i mask) + /// VMASKMOVPD ymm1, ymm2, m256 /// public static unsafe Vector256 MaskLoad(double* address, Vector256 mask) { throw new PlatformNotSupportedException(); } /// - /// void _mm_maskstore_ps (float * mem_addr, __m128i mask, __m128 a) - /// VMASKMOVPS m128, xmm1, xmm2 + /// void _mm_maskstore_ps (float * mem_addr, __m128i mask, __m128 a) + /// VMASKMOVPS m128, xmm1, xmm2 /// public static unsafe void MaskStore(float* address, Vector128 mask, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_maskstore_pd (double * mem_addr, __m128i mask, __m128d a) - /// VMASKMOVPD m128, xmm1, xmm2 + /// void _mm_maskstore_pd (double * mem_addr, __m128i mask, __m128d a) + /// VMASKMOVPD m128, xmm1, xmm2 /// public static unsafe void MaskStore(double* address, Vector128 mask, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_maskstore_ps (float * mem_addr, __m256i mask, __m256 a) - /// VMASKMOVPS m256, ymm1, ymm2 + /// void _mm256_maskstore_ps (float * mem_addr, __m256i mask, __m256 a) + /// VMASKMOVPS m256, ymm1, ymm2 /// public static unsafe void MaskStore(float* address, Vector256 mask, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_maskstore_pd (double * mem_addr, __m256i mask, __m256d a) - /// VMASKMOVPD m256, ymm1, ymm2 + /// void _mm256_maskstore_pd (double * mem_addr, __m256i mask, __m256d a) + /// VMASKMOVPD m256, ymm1, ymm2 /// public static unsafe void MaskStore(double* address, Vector256 mask, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_max_ps (__m256 a, __m256 b) - /// VMAXPS ymm1, ymm2, ymm3/m256 - /// VMAXPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_max_ps (__m256 a, __m256 b) + /// VMAXPS ymm1, ymm2, ymm3/m256 + /// VMAXPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Max(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_max_pd (__m256d a, __m256d b) - /// VMAXPD ymm1, ymm2, ymm3/m256 - /// VMAXPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_max_pd (__m256d a, __m256d b) + /// VMAXPD ymm1, ymm2, ymm3/m256 + /// VMAXPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Max(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_min_ps (__m256 a, __m256 b) - /// VMINPS ymm1, ymm2, ymm3/m256 - /// VMINPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_min_ps (__m256 a, __m256 b) + /// VMINPS ymm1, ymm2, ymm3/m256 + /// VMINPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Min(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_min_pd (__m256d a, __m256d b) - /// VMINPD ymm1, ymm2, ymm3/m256 - /// VMINPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_min_pd (__m256d a, __m256d b) + /// VMINPD ymm1, ymm2, ymm3/m256 + /// VMINPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Min(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_movemask_ps (__m256 a) - /// VMOVMSKPS r32, ymm1 + /// int _mm256_movemask_ps (__m256 a) + /// VMOVMSKPS r32, ymm1 /// public static int MoveMask(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_movemask_pd (__m256d a) - /// VMOVMSKPD r32, ymm1 + /// int _mm256_movemask_pd (__m256d a) + /// VMOVMSKPD r32, ymm1 /// public static int MoveMask(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_mul_ps (__m256 a, __m256 b) - /// VMULPS ymm1, ymm2, ymm3/m256 - /// VMULPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_mul_ps (__m256 a, __m256 b) + /// VMULPS ymm1, ymm2, ymm3/m256 + /// VMULPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Multiply(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_mul_pd (__m256d a, __m256d b) - /// VMULPD ymm1, ymm2, ymm3/m256 - /// VMULPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_mul_pd (__m256d a, __m256d b) + /// VMULPD ymm1, ymm2, ymm3/m256 + /// VMULPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Multiply(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_or_ps (__m256 a, __m256 b) - /// VORPS ymm1, ymm2, ymm3/m256 - /// VORPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_or_ps (__m256 a, __m256 b) + /// VORPS ymm1, ymm2, ymm3/m256 + /// VORPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Or(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_or_pd (__m256d a, __m256d b) - /// VORPD ymm1, ymm2, ymm3/m256 - /// VORPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_or_pd (__m256d a, __m256d b) + /// VORPD ymm1, ymm2, ymm3/m256 + /// VORPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Or(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_permute_ps (__m128 a, int imm8) - /// VPERMILPS xmm1, xmm2/m128, imm8 - /// VPERMILPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128 _mm_permute_ps (__m128 a, int imm8) + /// VPERMILPS xmm1, xmm2/m128, imm8 + /// VPERMILPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 Permute(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_permute_pd (__m128d a, int imm8) - /// VPERMILPD xmm1, xmm2/m128, imm8 - /// VPERMILPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128d _mm_permute_pd (__m128d a, int imm8) + /// VPERMILPD xmm1, xmm2/m128, imm8 + /// VPERMILPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 Permute(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_permute_ps (__m256 a, int imm8) - /// VPERMILPS ymm1, ymm2/m256, imm8 - /// VPERMILPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256 _mm256_permute_ps (__m256 a, int imm8) + /// VPERMILPS ymm1, ymm2/m256, imm8 + /// VPERMILPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 Permute(Vector256 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_permute_pd (__m256d a, int imm8) - /// VPERMILPD ymm1, ymm2/m256, imm8 - /// VPERMILPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256d _mm256_permute_pd (__m256d a, int imm8) + /// VPERMILPD ymm1, ymm2/m256, imm8 + /// VPERMILPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 Permute(Vector256 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) - /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) + /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) - /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) + /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) - /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) + /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) - /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) + /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) - /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) + /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) - /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) + /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) - /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) + /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) - /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) + /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_permute2f128_ps (__m256 a, __m256 b, int imm8) - /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256 _mm256_permute2f128_ps (__m256 a, __m256 b, int imm8) + /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_permute2f128_pd (__m256d a, __m256d b, int imm8) - /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256d _mm256_permute2f128_pd (__m256d a, __m256d b, int imm8) + /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_permutevar_ps (__m128 a, __m128i b) - /// VPERMILPS xmm1, xmm2, xmm3/m128 - /// VPERMILPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_permutevar_ps (__m128 a, __m128i b) + /// VPERMILPS xmm1, xmm2, xmm3/m128 + /// VPERMILPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 PermuteVar(Vector128 left, Vector128 control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_permutevar_pd (__m128d a, __m128i b) - /// VPERMILPD xmm1, xmm2, xmm3/m128 - /// VPERMILPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_permutevar_pd (__m128d a, __m128i b) + /// VPERMILPD xmm1, xmm2, xmm3/m128 + /// VPERMILPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 PermuteVar(Vector128 left, Vector128 control) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_permutevar_ps (__m256 a, __m256i b) - /// VPERMILPS ymm1, ymm2, ymm3/m256 - /// VPERMILPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_permutevar_ps (__m256 a, __m256i b) + /// VPERMILPS ymm1, ymm2, ymm3/m256 + /// VPERMILPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 PermuteVar(Vector256 left, Vector256 control) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_permutevar_pd (__m256d a, __m256i b) - /// VPERMILPD ymm1, ymm2, ymm3/m256 - /// VPERMILPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_permutevar_pd (__m256d a, __m256i b) + /// VPERMILPD ymm1, ymm2, ymm3/m256 + /// VPERMILPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar(Vector256 left, Vector256 control) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_rcp_ps (__m256 a) - /// VRCPPS ymm1, ymm2/m256 + /// __m256 _mm256_rcp_ps (__m256 a) + /// VRCPPS ymm1, ymm2/m256 /// public static Vector256 Reciprocal(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_rsqrt_ps (__m256 a) - /// VRSQRTPS ymm1, ymm2/m256 + /// __m256 _mm256_rsqrt_ps (__m256 a) + /// VRSQRTPS ymm1, ymm2/m256 /// public static Vector256 ReciprocalSqrt(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_round_ps (__m256 a, _MM_FROUND_CUR_DIRECTION) - /// VROUNDPS ymm1, ymm2/m256, imm8(4) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m256 _mm256_round_ps (__m256 a, _MM_FROUND_CUR_DIRECTION) + /// VROUNDPS ymm1, ymm2/m256, imm8(4) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector256 RoundCurrentDirection(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_round_ps (__m256d a, _MM_FROUND_CUR_DIRECTION) - /// VROUNDPD ymm1, ymm2/m256, imm8(4) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m256d _mm256_round_ps (__m256d a, _MM_FROUND_CUR_DIRECTION) + /// VROUNDPD ymm1, ymm2/m256, imm8(4) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector256 RoundCurrentDirection(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_round_ps (__m256 a, _MM_FROUND_TO_NEAREST_INT) - /// VROUNDPS ymm1, ymm2/m256, imm8(8) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m256 _mm256_round_ps (__m256 a, _MM_FROUND_TO_NEAREST_INT) + /// VROUNDPS ymm1, ymm2/m256, imm8(8) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector256 RoundToNearestInteger(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_round_pd (__m256d a, _MM_FROUND_TO_NEAREST_INT) - /// VROUNDPD ymm1, ymm2/m256, imm8(8) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m256d _mm256_round_pd (__m256d a, _MM_FROUND_TO_NEAREST_INT) + /// VROUNDPD ymm1, ymm2/m256, imm8(8) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector256 RoundToNearestInteger(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_round_ps (__m256 a, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) - /// VROUNDPS ymm1, ymm2/m256, imm8(9) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m256 _mm256_round_ps (__m256 a, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) + /// VROUNDPS ymm1, ymm2/m256, imm8(9) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector256 RoundToNegativeInfinity(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_round_pd (__m256d a, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) - /// VROUNDPD ymm1, ymm2/m256, imm8(9) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m256d _mm256_round_pd (__m256d a, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) + /// VROUNDPD ymm1, ymm2/m256, imm8(9) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector256 RoundToNegativeInfinity(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_round_ps (__m256 a, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) - /// VROUNDPS ymm1, ymm2/m256, imm8(10) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m256 _mm256_round_ps (__m256 a, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) + /// VROUNDPS ymm1, ymm2/m256, imm8(10) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector256 RoundToPositiveInfinity(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_round_pd (__m256d a, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) - /// VROUNDPD ymm1, ymm2/m256, imm8(10) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m256d _mm256_round_pd (__m256d a, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) + /// VROUNDPD ymm1, ymm2/m256, imm8(10) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector256 RoundToPositiveInfinity(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_round_ps (__m256 a, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) - /// VROUNDPS ymm1, ymm2/m256, imm8(11) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m256 _mm256_round_ps (__m256 a, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) + /// VROUNDPS ymm1, ymm2/m256, imm8(11) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector256 RoundToZero(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_round_pd (__m256d a, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) - /// VROUNDPD ymm1, ymm2/m256, imm8(11) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m256d _mm256_round_pd (__m256d a, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) + /// VROUNDPD ymm1, ymm2/m256, imm8(11) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector256 RoundToZero(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_shuffle_ps (__m256 a, __m256 b, const int imm8) - /// VSHUFPS ymm1, ymm2, ymm3/m256, imm8 - /// VSHUFPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256 _mm256_shuffle_ps (__m256 a, __m256 b, const int imm8) + /// VSHUFPS ymm1, ymm2, ymm3/m256, imm8 + /// VSHUFPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 Shuffle(Vector256 value, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_shuffle_pd (__m256d a, __m256d b, const int imm8) - /// VSHUFPD ymm1, ymm2, ymm3/m256, imm8 - /// VSHUFPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256d _mm256_shuffle_pd (__m256d a, __m256d b, const int imm8) + /// VSHUFPD ymm1, ymm2, ymm3/m256, imm8 + /// VSHUFPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 Shuffle(Vector256 value, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_sqrt_ps (__m256 a) - /// VSQRTPS ymm1, ymm2/m256 - /// VSQRTPS ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256 _mm256_sqrt_ps (__m256 a) + /// VSQRTPS ymm1, ymm2/m256 + /// VSQRTPS ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 Sqrt(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_sqrt_pd (__m256d a) - /// VSQRTPD ymm1, ymm2/m256 - /// VSQRTPD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_sqrt_pd (__m256d a) + /// VSQRTPD ymm1, ymm2/m256 + /// VSQRTPD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 Sqrt(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQU m256, ymm1 - /// VMOVDQU8 m256 {k1}{z}, ymm1 + /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQU m256, ymm1 + /// VMOVDQU8 m256 {k1}{z}, ymm1 /// public static unsafe void Store(sbyte* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQU m256, ymm1 - /// VMOVDQU8 m256 {k1}{z}, ymm1 + /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQU m256, ymm1 + /// VMOVDQU8 m256 {k1}{z}, ymm1 /// public static unsafe void Store(byte* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQU m256, ymm1 - /// VMOVDQU16 m256 {k1}{z}, ymm1 + /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQU m256, ymm1 + /// VMOVDQU16 m256 {k1}{z}, ymm1 /// public static unsafe void Store(short* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQU m256, ymm1 - /// VMOVDQU16 m256 {k1}{z}, ymm1 + /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQU m256, ymm1 + /// VMOVDQU16 m256 {k1}{z}, ymm1 /// public static unsafe void Store(ushort* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQU m256, ymm1 - /// VMOVDQU32 m256 {k1}{z}, ymm1 + /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQU m256, ymm1 + /// VMOVDQU32 m256 {k1}{z}, ymm1 /// public static unsafe void Store(int* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQU m256, ymm1 - /// VMOVDQU32 m256 {k1}{z}, ymm1 + /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQU m256, ymm1 + /// VMOVDQU32 m256 {k1}{z}, ymm1 /// public static unsafe void Store(uint* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQU m256, ymm1 - /// VMOVDQU64 m256 {k1}{z}, ymm1 + /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQU m256, ymm1 + /// VMOVDQU64 m256 {k1}{z}, ymm1 /// public static unsafe void Store(long* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQU m256, ymm1 - /// VMOVDQU64 m256 {k1}{z}, ymm1 + /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQU m256, ymm1 + /// VMOVDQU64 m256 {k1}{z}, ymm1 /// public static unsafe void Store(ulong* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_storeu_ps (float * mem_addr, __m256 a) - /// VMOVUPS m256, ymm1 - /// VMOVUPS m256 {k1}{z}, ymm1 + /// void _mm256_storeu_ps (float * mem_addr, __m256 a) + /// VMOVUPS m256, ymm1 + /// VMOVUPS m256 {k1}{z}, ymm1 /// public static unsafe void Store(float* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_storeu_pd (double * mem_addr, __m256d a) - /// VMOVUPD m256, ymm1 - /// VMOVUPD m256 {k1}{z}, ymm1 + /// void _mm256_storeu_pd (double * mem_addr, __m256d a) + /// VMOVUPD m256, ymm1 + /// VMOVUPD m256 {k1}{z}, ymm1 /// public static unsafe void Store(double* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQA m256, ymm1 - /// VMOVDQA32 m256 {k1}{z}, ymm1 + /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQA m256, ymm1 + /// VMOVDQA32 m256 {k1}{z}, ymm1 /// public static unsafe void StoreAligned(sbyte* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQA m256, ymm1 - /// VMOVDQA32 m256 {k1}{z}, ymm1 + /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQA m256, ymm1 + /// VMOVDQA32 m256 {k1}{z}, ymm1 /// public static unsafe void StoreAligned(byte* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQA m256, ymm1 - /// VMOVDQA32 m256 {k1}{z}, ymm1 + /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQA m256, ymm1 + /// VMOVDQA32 m256 {k1}{z}, ymm1 /// public static unsafe void StoreAligned(short* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQA m256, ymm1 - /// VMOVDQA32 m256 {k1}{z}, ymm1 + /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQA m256, ymm1 + /// VMOVDQA32 m256 {k1}{z}, ymm1 /// public static unsafe void StoreAligned(ushort* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQA m256, ymm1 - /// VMOVDQA32 m256 {k1}{z}, ymm1 + /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQA m256, ymm1 + /// VMOVDQA32 m256 {k1}{z}, ymm1 /// public static unsafe void StoreAligned(int* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQA m256, ymm1 - /// VMOVDQA32 m256 {k1}{z}, ymm1 + /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQA m256, ymm1 + /// VMOVDQA32 m256 {k1}{z}, ymm1 /// public static unsafe void StoreAligned(uint* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQA m256, ymm1 - /// VMOVDQA64 m256 {k1}{z}, ymm1 + /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQA m256, ymm1 + /// VMOVDQA64 m256 {k1}{z}, ymm1 /// public static unsafe void StoreAligned(long* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQA m256, ymm1 - /// VMOVDQA64 m256 {k1}{z}, ymm1 + /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQA m256, ymm1 + /// VMOVDQA64 m256 {k1}{z}, ymm1 /// public static unsafe void StoreAligned(ulong* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_store_ps (float * mem_addr, __m256 a) - /// VMOVAPS m256, ymm1 - /// VMOVAPS m256 {k1}{z}, ymm1 + /// void _mm256_store_ps (float * mem_addr, __m256 a) + /// VMOVAPS m256, ymm1 + /// VMOVAPS m256 {k1}{z}, ymm1 /// public static unsafe void StoreAligned(float* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_store_pd (double * mem_addr, __m256d a) - /// VMOVAPD m256, ymm1 - /// VMOVAPD m256 {k1}{z}, ymm1 + /// void _mm256_store_pd (double * mem_addr, __m256d a) + /// VMOVAPD m256, ymm1 + /// VMOVAPD m256 {k1}{z}, ymm1 /// public static unsafe void StoreAligned(double* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) - /// VMOVNTDQ m256, ymm1 + /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) + /// VMOVNTDQ m256, ymm1 /// public static unsafe void StoreAlignedNonTemporal(sbyte* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) - /// VMOVNTDQ m256, ymm1 + /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) + /// VMOVNTDQ m256, ymm1 /// public static unsafe void StoreAlignedNonTemporal(byte* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) - /// VMOVNTDQ m256, ymm1 + /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) + /// VMOVNTDQ m256, ymm1 /// public static unsafe void StoreAlignedNonTemporal(short* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) - /// VMOVNTDQ m256, ymm1 + /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) + /// VMOVNTDQ m256, ymm1 /// public static unsafe void StoreAlignedNonTemporal(ushort* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) - /// VMOVNTDQ m256, ymm1 + /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) + /// VMOVNTDQ m256, ymm1 /// public static unsafe void StoreAlignedNonTemporal(int* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) - /// VMOVNTDQ m256, ymm1 + /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) + /// VMOVNTDQ m256, ymm1 /// public static unsafe void StoreAlignedNonTemporal(uint* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) - /// VMOVNTDQ m256, ymm1 + /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) + /// VMOVNTDQ m256, ymm1 /// public static unsafe void StoreAlignedNonTemporal(long* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) - /// VMOVNTDQ m256, ymm1 + /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) + /// VMOVNTDQ m256, ymm1 /// public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_stream_ps (float * mem_addr, __m256 a) - /// VMOVNTPS m256, ymm1 + /// void _mm256_stream_ps (float * mem_addr, __m256 a) + /// VMOVNTPS m256, ymm1 /// public static unsafe void StoreAlignedNonTemporal(float* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_stream_pd (double * mem_addr, __m256d a) - /// VMOVNTPD m256, ymm1 + /// void _mm256_stream_pd (double * mem_addr, __m256d a) + /// VMOVNTPD m256, ymm1 /// public static unsafe void StoreAlignedNonTemporal(double* address, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_sub_ps (__m256 a, __m256 b) - /// VSUBPS ymm1, ymm2, ymm3/m256 - /// VSUBPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_sub_ps (__m256 a, __m256 b) + /// VSUBPS ymm1, ymm2, ymm3/m256 + /// VSUBPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_sub_pd (__m256d a, __m256d b) - /// VSUBPD ymm1, ymm2, ymm3/m256 - /// VSUBPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_sub_pd (__m256d a, __m256d b) + /// VSUBPD ymm1, ymm2, ymm3/m256 + /// VSUBPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testc_ps (__m128 a, __m128 b) - /// VTESTPS xmm1, xmm2/m128 ; CF=1 + /// int _mm_testc_ps (__m128 a, __m128 b) + /// VTESTPS xmm1, xmm2/m128 ; CF=1 /// public static bool TestC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testc_pd (__m128d a, __m128d b) - /// VTESTPD xmm1, xmm2/m128 ; CF=1 + /// int _mm_testc_pd (__m128d a, __m128d b) + /// VTESTPD xmm1, xmm2/m128 ; CF=1 /// public static bool TestC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; CF=1 + /// int _mm256_testc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; CF=1 /// public static bool TestC(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; CF=1 + /// int _mm256_testc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; CF=1 /// public static bool TestC(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; CF=1 + /// int _mm256_testc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; CF=1 /// public static bool TestC(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; CF=1 + /// int _mm256_testc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; CF=1 /// public static bool TestC(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; CF=1 + /// int _mm256_testc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; CF=1 /// public static bool TestC(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; CF=1 + /// int _mm256_testc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; CF=1 /// public static bool TestC(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; CF=1 + /// int _mm256_testc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; CF=1 /// public static bool TestC(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; CF=1 + /// int _mm256_testc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; CF=1 /// public static bool TestC(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testc_ps (__m256 a, __m256 b) - /// VTESTPS ymm1, ymm2/m256 ; CF=1 + /// int _mm256_testc_ps (__m256 a, __m256 b) + /// VTESTPS ymm1, ymm2/m256 ; CF=1 /// public static bool TestC(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testc_pd (__m256d a, __m256d b) - /// VTESTPD ymm1, ymm2/m256 ; CF=1 + /// int _mm256_testc_pd (__m256d a, __m256d b) + /// VTESTPD ymm1, ymm2/m256 ; CF=1 /// public static bool TestC(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testnzc_ps (__m128 a, __m128 b) - /// VTESTPS xmm1, ymm2/m128 ; ZF=0 && CF=0 + /// int _mm_testnzc_ps (__m128 a, __m128 b) + /// VTESTPS xmm1, ymm2/m128 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testnzc_pd (__m128d a, __m128d b) - /// VTESTPD xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// int _mm_testnzc_pd (__m128d a, __m128d b) + /// VTESTPD xmm1, xmm2/m128 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testnzc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 + /// int _mm256_testnzc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testnzc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 + /// int _mm256_testnzc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testnzc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 + /// int _mm256_testnzc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testnzc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 + /// int _mm256_testnzc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testnzc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 + /// int _mm256_testnzc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testnzc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 + /// int _mm256_testnzc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testnzc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 + /// int _mm256_testnzc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testnzc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 + /// int _mm256_testnzc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testnzc_ps (__m256 a, __m256 b) - /// VTESTPS ymm1, ymm2/m256 ; ZF=0 && CF=0 + /// int _mm256_testnzc_ps (__m256 a, __m256 b) + /// VTESTPS ymm1, ymm2/m256 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testnzc_pd (__m256d a, __m256d b) - /// VTESTPD ymm1, ymm2/m256 ; ZF=0 && CF=0 + /// int _mm256_testnzc_pd (__m256d a, __m256d b) + /// VTESTPD ymm1, ymm2/m256 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testz_ps (__m128 a, __m128 b) - /// VTESTPS xmm1, xmm2/m128 ; ZF=1 + /// int _mm_testz_ps (__m128 a, __m128 b) + /// VTESTPS xmm1, xmm2/m128 ; ZF=1 /// public static bool TestZ(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testz_pd (__m128d a, __m128d b) - /// VTESTPD xmm1, xmm2/m128 ; ZF=1 + /// int _mm_testz_pd (__m128d a, __m128d b) + /// VTESTPD xmm1, xmm2/m128 ; ZF=1 /// public static bool TestZ(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testz_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=1 + /// int _mm256_testz_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=1 /// public static bool TestZ(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testz_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=1 + /// int _mm256_testz_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=1 /// public static bool TestZ(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testz_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=1 + /// int _mm256_testz_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=1 /// public static bool TestZ(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testz_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=1 + /// int _mm256_testz_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=1 /// public static bool TestZ(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testz_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=1 + /// int _mm256_testz_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=1 /// public static bool TestZ(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testz_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=1 + /// int _mm256_testz_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=1 /// public static bool TestZ(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testz_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=1 + /// int _mm256_testz_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=1 /// public static bool TestZ(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testz_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=1 + /// int _mm256_testz_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=1 /// public static bool TestZ(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testz_ps (__m256 a, __m256 b) - /// VTESTPS ymm1, ymm2/m256 ; ZF=1 + /// int _mm256_testz_ps (__m256 a, __m256 b) + /// VTESTPS ymm1, ymm2/m256 ; ZF=1 /// public static bool TestZ(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_testz_pd (__m256d a, __m256d b) - /// VTESTPD ymm1, ymm2/m256 ; ZF=1 + /// int _mm256_testz_pd (__m256d a, __m256d b) + /// VTESTPD ymm1, ymm2/m256 ; ZF=1 /// public static bool TestZ(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_unpackhi_ps (__m256 a, __m256 b) - /// VUNPCKHPS ymm1, ymm2, ymm3/m256 - /// VUNPCKHPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_unpackhi_ps (__m256 a, __m256 b) + /// VUNPCKHPS ymm1, ymm2, ymm3/m256 + /// VUNPCKHPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_unpackhi_pd (__m256d a, __m256d b) - /// VUNPCKHPD ymm1, ymm2, ymm3/m256 - /// VUNPCKHPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_unpackhi_pd (__m256d a, __m256d b) + /// VUNPCKHPD ymm1, ymm2, ymm3/m256 + /// VUNPCKHPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_unpacklo_ps (__m256 a, __m256 b) - /// VUNPCKLPS ymm1, ymm2, ymm3/m256 - /// VUNPCKLPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_unpacklo_ps (__m256 a, __m256 b) + /// VUNPCKLPS ymm1, ymm2, ymm3/m256 + /// VUNPCKLPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_unpacklo_pd (__m256d a, __m256d b) - /// VUNPCKLPD ymm1, ymm2, ymm3/m256 - /// VUNPCKLPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_unpacklo_pd (__m256d a, __m256d b) + /// VUNPCKLPD ymm1, ymm2, ymm3/m256 + /// VUNPCKLPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_xor_ps (__m256 a, __m256 b) - /// VXORPS ymm1, ymm2, ymm3/m256 - /// VXORPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_xor_ps (__m256 a, __m256 b) + /// VXORPS ymm1, ymm2, ymm3/m256 + /// VXORPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Xor(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_xor_pd (__m256d a, __m256d b) - /// VXORPD ymm1, ymm2, ymm3/m256 - /// VXORPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_xor_pd (__m256d a, __m256d b) + /// VXORPD ymm1, ymm2, ymm3/m256 + /// VXORPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Xor(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx.cs index 890a18a12e9..c0212c3f8da 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx.cs @@ -6,1441 +6,1446 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel AVX hardware instructions via intrinsics - /// + /// Provides access to X86 AVX hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Avx : Sse42 { internal Avx() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the x86 AVX hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : Sse42.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } } /// - /// __m256 _mm256_add_ps (__m256 a, __m256 b) - /// VADDPS ymm1, ymm2, ymm3/m256 - /// VADDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_add_ps (__m256 a, __m256 b) + /// VADDPS ymm1, ymm2, ymm3/m256 + /// VADDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Add(Vector256 left, Vector256 right) => Add(left, right); /// - /// __m256d _mm256_add_pd (__m256d a, __m256d b) - /// VADDPD ymm1, ymm2, ymm3/m256 - /// VADDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_add_pd (__m256d a, __m256d b) + /// VADDPD ymm1, ymm2, ymm3/m256 + /// VADDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Add(Vector256 left, Vector256 right) => Add(left, right); /// - /// __m256 _mm256_addsub_ps (__m256 a, __m256 b) - /// VADDSUBPS ymm1, ymm2, ymm3/m256 + /// __m256 _mm256_addsub_ps (__m256 a, __m256 b) + /// VADDSUBPS ymm1, ymm2, ymm3/m256 /// public static Vector256 AddSubtract(Vector256 left, Vector256 right) => AddSubtract(left, right); /// - /// __m256d _mm256_addsub_pd (__m256d a, __m256d b) - /// VADDSUBPD ymm1, ymm2, ymm3/m256 + /// __m256d _mm256_addsub_pd (__m256d a, __m256d b) + /// VADDSUBPD ymm1, ymm2, ymm3/m256 /// public static Vector256 AddSubtract(Vector256 left, Vector256 right) => AddSubtract(left, right); /// - /// __m256 _mm256_and_ps (__m256 a, __m256 b) - /// VANDPS ymm1, ymm2, ymm2/m256 - /// VANDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_and_ps (__m256 a, __m256 b) + /// VANDPS ymm1, ymm2, ymm2/m256 + /// VANDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 And(Vector256 left, Vector256 right) => And(left, right); /// - /// __m256d _mm256_and_pd (__m256d a, __m256d b) - /// VANDPD ymm1, ymm2, ymm2/m256 - /// VANDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_and_pd (__m256d a, __m256d b) + /// VANDPD ymm1, ymm2, ymm2/m256 + /// VANDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 And(Vector256 left, Vector256 right) => And(left, right); /// - /// __m256 _mm256_andnot_ps (__m256 a, __m256 b) - /// VANDNPS ymm1, ymm2, ymm2/m256 - /// VANDNPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_andnot_ps (__m256 a, __m256 b) + /// VANDNPS ymm1, ymm2, ymm2/m256 + /// VANDNPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 AndNot(Vector256 left, Vector256 right) => AndNot(left, right); /// - /// __m256d _mm256_andnot_pd (__m256d a, __m256d b) - /// VANDNPD ymm1, ymm2, ymm2/m256 - /// VANDNPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_andnot_pd (__m256d a, __m256d b) + /// VANDNPD ymm1, ymm2, ymm2/m256 + /// VANDNPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 AndNot(Vector256 left, Vector256 right) => AndNot(left, right); /// - /// __m256 _mm256_blend_ps (__m256 a, __m256 b, const int imm8) - /// VBLENDPS ymm1, ymm2, ymm3/m256, imm8 + /// __m256 _mm256_blend_ps (__m256 a, __m256 b, const int imm8) + /// VBLENDPS ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Blend(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Blend(left, right, control); /// - /// __m256d _mm256_blend_pd (__m256d a, __m256d b, const int imm8) - /// VBLENDPD ymm1, ymm2, ymm3/m256, imm8 + /// __m256d _mm256_blend_pd (__m256d a, __m256d b, const int imm8) + /// VBLENDPD ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Blend(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Blend(left, right, control); /// - /// __m256 _mm256_blendv_ps (__m256 a, __m256 b, __m256 mask) - /// VBLENDVPS ymm1, ymm2, ymm3/m256, ymm4 + /// __m256 _mm256_blendv_ps (__m256 a, __m256 b, __m256 mask) + /// VBLENDVPS ymm1, ymm2, ymm3/m256, ymm4 /// public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) => BlendVariable(left, right, mask); /// - /// __m256d _mm256_blendv_pd (__m256d a, __m256d b, __m256d mask) - /// VBLENDVPD ymm1, ymm2, ymm3/m256, ymm4 + /// __m256d _mm256_blendv_pd (__m256d a, __m256d b, __m256d mask) + /// VBLENDVPD ymm1, ymm2, ymm3/m256, ymm4 /// public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) => BlendVariable(left, right, mask); /// - /// __m128 _mm_broadcast_ss (float const * mem_addr) - /// VBROADCASTSS xmm1, m32 - /// VBROADCASTSS xmm1 {k1}{z}, m32 + /// __m128 _mm_broadcast_ss (float const * mem_addr) + /// VBROADCASTSS xmm1, m32 + /// VBROADCASTSS xmm1 {k1}{z}, m32 /// public static unsafe Vector128 BroadcastScalarToVector128(float* source) => BroadcastScalarToVector128(source); /// - /// __m256 _mm256_broadcast_ss (float const * mem_addr) - /// VBROADCASTSS ymm1, m32 - /// VBROADCASTSS ymm1 {k1}{z}, m32 + /// __m256 _mm256_broadcast_ss (float const * mem_addr) + /// VBROADCASTSS ymm1, m32 + /// VBROADCASTSS ymm1 {k1}{z}, m32 /// public static unsafe Vector256 BroadcastScalarToVector256(float* source) => BroadcastScalarToVector256(source); /// - /// __m256d _mm256_broadcast_sd (double const * mem_addr) - /// VBROADCASTSD ymm1, m64 - /// VBROADCASTSD ymm1 {k1}{z}, m64 + /// __m256d _mm256_broadcast_sd (double const * mem_addr) + /// VBROADCASTSD ymm1, m64 + /// VBROADCASTSD ymm1 {k1}{z}, m64 /// public static unsafe Vector256 BroadcastScalarToVector256(double* source) => BroadcastScalarToVector256(source); /// - /// __m256 _mm256_broadcast_ps (__m128 const * mem_addr) - /// VBROADCASTF128 ymm1, m128 - /// VBROADCASTF32x4 ymm1 {k1}{z}, m128 + /// __m256 _mm256_broadcast_ps (__m128 const * mem_addr) + /// VBROADCASTF128 ymm1, m128 + /// VBROADCASTF32x4 ymm1 {k1}{z}, m128 /// public static unsafe Vector256 BroadcastVector128ToVector256(float* address) => BroadcastVector128ToVector256(address); /// - /// __m256d _mm256_broadcast_pd (__m128d const * mem_addr) - /// VBROADCASTF128 ymm1, m128 - /// VBROADCASTF64x2 ymm1 {k1}{z}, m128 + /// __m256d _mm256_broadcast_pd (__m128d const * mem_addr) + /// VBROADCASTF128 ymm1, m128 + /// VBROADCASTF64x2 ymm1 {k1}{z}, m128 /// public static unsafe Vector256 BroadcastVector128ToVector256(double* address) => BroadcastVector128ToVector256(address); /// - /// __m256 _mm256_ceil_ps (__m128 a) - /// VROUNDPS ymm1, ymm2/m256, imm8(10) + /// __m256 _mm256_ceil_ps (__m128 a) + /// VROUNDPS ymm1, ymm2/m256, imm8(10) /// public static Vector256 Ceiling(Vector256 value) => Ceiling(value); /// - /// __m256d _mm256_ceil_pd (__m128d a) - /// VROUNDPD ymm1, ymm2/m256, imm8(10) + /// __m256d _mm256_ceil_pd (__m128d a) + /// VROUNDPD ymm1, ymm2/m256, imm8(10) /// public static Vector256 Ceiling(Vector256 value) => Ceiling(value); /// - /// __m128 _mm_cmp_ps (__m128 a, __m128 b, const int imm8) - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8 + /// __m128 _mm_cmp_ps (__m128 a, __m128 b, const int imm8) + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8 /// public static Vector128 Compare(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) => Compare(left, right, mode); /// - /// __m256 _mm256_cmp_ps (__m256 a, __m256 b, const int imm8) - /// VCMPPS ymm1, ymm2, ymm3/m256, imm8 + /// __m256 _mm256_cmp_ps (__m256 a, __m256 b, const int imm8) + /// VCMPPS ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Compare(Vector256 left, Vector256 right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) => Compare(left, right, mode); /// - /// __m256 _mm256_cmpeq_ps (__m256 a, __m256 b) - /// VCMPPS ymm1, ymm2/m256, imm8(0) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256 _mm256_cmpeq_ps (__m256 a, __m256 b) + /// VCMPPS ymm1, ymm2/m256, imm8(0) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareEqual(Vector256 left, Vector256 right) => CompareEqual(left, right); /// - /// __m256 _mm256_cmpgt_ps (__m256 a, __m256 b) - /// VCMPPS ymm1, ymm2/m256, imm8(14) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256 _mm256_cmpgt_ps (__m256 a, __m256 b) + /// VCMPPS ymm1, ymm2/m256, imm8(14) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) => CompareGreaterThan(left, right); /// - /// __m256 _mm256_cmpge_ps (__m256 a, __m256 b) - /// VCMPPS ymm1, ymm2/m256, imm8(13) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256 _mm256_cmpge_ps (__m256 a, __m256 b) + /// VCMPPS ymm1, ymm2/m256, imm8(13) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m256 _mm256_cmplt_ps (__m256 a, __m256 b) - /// VCMPPS ymm1, ymm2/m256, imm8(1) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256 _mm256_cmplt_ps (__m256 a, __m256 b) + /// VCMPPS ymm1, ymm2/m256, imm8(1) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) => CompareLessThan(left, right); /// - /// __m256 _mm256_cmple_ps (__m256 a, __m256 b) - /// VCMPPS ymm1, ymm2/m256, imm8(2) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256 _mm256_cmple_ps (__m256 a, __m256 b) + /// VCMPPS ymm1, ymm2/m256, imm8(2) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) => CompareLessThanOrEqual(left, right); /// - /// __m256 _mm256_cmpneq_ps (__m256 a, __m256 b) - /// VCMPPS ymm1, ymm2/m256, imm8(4) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256 _mm256_cmpneq_ps (__m256 a, __m256 b) + /// VCMPPS ymm1, ymm2/m256, imm8(4) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) => CompareNotEqual(left, right); /// - /// __m256 _mm256_cmpngt_ps (__m256 a, __m256 b) - /// VCMPPS ymm1, ymm2/m256, imm8(10) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256 _mm256_cmpngt_ps (__m256 a, __m256 b) + /// VCMPPS ymm1, ymm2/m256, imm8(10) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareNotGreaterThan(Vector256 left, Vector256 right) => CompareNotGreaterThan(left, right); /// - /// __m256 _mm256_cmpnge_ps (__m256 a, __m256 b) - /// VCMPPS ymm1, ymm2/m256, imm8(9) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256 _mm256_cmpnge_ps (__m256 a, __m256 b) + /// VCMPPS ymm1, ymm2/m256, imm8(9) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareNotGreaterThanOrEqual(Vector256 left, Vector256 right) => CompareNotGreaterThanOrEqual(left, right); /// - /// __m256 _mm256_cmpnlt_ps (__m256 a, __m256 b) - /// VCMPPS ymm1, ymm2/m256, imm8(5) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256 _mm256_cmpnlt_ps (__m256 a, __m256 b) + /// VCMPPS ymm1, ymm2/m256, imm8(5) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareNotLessThan(Vector256 left, Vector256 right) => CompareNotLessThan(left, right); /// - /// __m256 _mm256_cmpnle_ps (__m256 a, __m256 b) - /// VCMPPS ymm1, ymm2/m256, imm8(6) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256 _mm256_cmpnle_ps (__m256 a, __m256 b) + /// VCMPPS ymm1, ymm2/m256, imm8(6) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareNotLessThanOrEqual(Vector256 left, Vector256 right) => CompareNotLessThanOrEqual(left, right); /// - /// __m256 _mm256_cmpord_ps (__m256 a, __m256 b) - /// VCMPPS ymm1, ymm2/m256, imm8(7) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256 _mm256_cmpord_ps (__m256 a, __m256 b) + /// VCMPPS ymm1, ymm2/m256, imm8(7) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareOrdered(Vector256 left, Vector256 right) => CompareOrdered(left, right); /// - /// __m256 _mm256_cmpunord_ps (__m256 a, __m256 b) - /// VCMPPS ymm1, ymm2/m256, imm8(3) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256 _mm256_cmpunord_ps (__m256 a, __m256 b) + /// VCMPPS ymm1, ymm2/m256, imm8(3) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareUnordered(Vector256 left, Vector256 right) => CompareUnordered(left, right); /// - /// __m128d _mm_cmp_pd (__m128d a, __m128d b, const int imm8) - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8 + /// __m128d _mm_cmp_pd (__m128d a, __m128d b, const int imm8) + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8 /// public static Vector128 Compare(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) => Compare(left, right, mode); /// - /// __m256d _mm256_cmp_pd (__m256d a, __m256d b, const int imm8) - /// VCMPPD ymm1, ymm2, ymm3/m256, imm8 + /// __m256d _mm256_cmp_pd (__m256d a, __m256d b, const int imm8) + /// VCMPPD ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Compare(Vector256 left, Vector256 right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) => Compare(left, right, mode); /// - /// __m256d _mm256_cmpeq_pd (__m256d a, __m256d b) - /// VCMPPD ymm1, ymm2/m256, imm8(0) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256d _mm256_cmpeq_pd (__m256d a, __m256d b) + /// VCMPPD ymm1, ymm2/m256, imm8(0) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareEqual(Vector256 left, Vector256 right) => CompareEqual(left, right); /// - /// __m256d _mm256_cmpgt_pd (__m256d a, __m256d b) - /// VCMPPD ymm1, ymm2/m256, imm8(14) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256d _mm256_cmpgt_pd (__m256d a, __m256d b) + /// VCMPPD ymm1, ymm2/m256, imm8(14) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) => CompareGreaterThan(left, right); /// - /// __m256d _mm256_cmpge_pd (__m256d a, __m256d b) - /// VCMPPD ymm1, ymm2/m256, imm8(13) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256d _mm256_cmpge_pd (__m256d a, __m256d b) + /// VCMPPD ymm1, ymm2/m256, imm8(13) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m256d _mm256_cmplt_pd (__m256d a, __m256d b) - /// VCMPPD ymm1, ymm2/m256, imm8(1) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256d _mm256_cmplt_pd (__m256d a, __m256d b) + /// VCMPPD ymm1, ymm2/m256, imm8(1) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) => CompareLessThan(left, right); /// - /// __m256d _mm256_cmple_pd (__m256d a, __m256d b) - /// VCMPPD ymm1, ymm2/m256, imm8(2) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256d _mm256_cmple_pd (__m256d a, __m256d b) + /// VCMPPD ymm1, ymm2/m256, imm8(2) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) => CompareLessThanOrEqual(left, right); /// - /// __m256d _mm256_cmpneq_pd (__m256d a, __m256d b) - /// VCMPPD ymm1, ymm2/m256, imm8(4) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256d _mm256_cmpneq_pd (__m256d a, __m256d b) + /// VCMPPD ymm1, ymm2/m256, imm8(4) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) => CompareNotEqual(left, right); /// - /// __m256d _mm256_cmpngt_pd (__m256d a, __m256d b) - /// VCMPPD ymm1, ymm2/m256, imm8(10) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256d _mm256_cmpngt_pd (__m256d a, __m256d b) + /// VCMPPD ymm1, ymm2/m256, imm8(10) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareNotGreaterThan(Vector256 left, Vector256 right) => CompareNotGreaterThan(left, right); /// - /// __m256d _mm256_cmpnge_pd (__m256d a, __m256d b) - /// VCMPPD ymm1, ymm2/m256, imm8(9) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256d _mm256_cmpnge_pd (__m256d a, __m256d b) + /// VCMPPD ymm1, ymm2/m256, imm8(9) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareNotGreaterThanOrEqual(Vector256 left, Vector256 right) => CompareNotGreaterThanOrEqual(left, right); /// - /// __m256d _mm256_cmpnlt_pd (__m256d a, __m256d b) - /// VCMPPD ymm1, ymm2/m256, imm8(5) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256d _mm256_cmpnlt_pd (__m256d a, __m256d b) + /// VCMPPD ymm1, ymm2/m256, imm8(5) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareNotLessThan(Vector256 left, Vector256 right) => CompareNotLessThan(left, right); /// - /// __m256d _mm256_cmpnle_pd (__m256d a, __m256d b) - /// VCMPPD ymm1, ymm2/m256, imm8(6) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256d _mm256_cmpnle_pd (__m256d a, __m256d b) + /// VCMPPD ymm1, ymm2/m256, imm8(6) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareNotLessThanOrEqual(Vector256 left, Vector256 right) => CompareNotLessThanOrEqual(left, right); /// - /// __m256d _mm256_cmpord_pd (__m256d a, __m256d b) - /// VCMPPD ymm1, ymm2/m256, imm8(7) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256d _mm256_cmpord_pd (__m256d a, __m256d b) + /// VCMPPD ymm1, ymm2/m256, imm8(7) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareOrdered(Vector256 left, Vector256 right) => CompareOrdered(left, right); /// - /// __m256d _mm256_cmpunord_pd (__m256d a, __m256d b) - /// VCMPPD ymm1, ymm2/m256, imm8(3) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m256d _mm256_cmpunord_pd (__m256d a, __m256d b) + /// VCMPPD ymm1, ymm2/m256, imm8(3) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector256 CompareUnordered(Vector256 left, Vector256 right) => CompareUnordered(left, right); /// - /// __m128 _mm_cmp_ss (__m128 a, __m128 b, const int imm8) - /// VCMPSD xmm1, xmm2, xmm3/m64, imm8 + /// __m128 _mm_cmp_ss (__m128 a, __m128 b, const int imm8) + /// VCMPSD xmm1, xmm2, xmm3/m64, imm8 /// public static Vector128 CompareScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) => CompareScalar(left, right, mode); /// - /// __m128d _mm_cmp_sd (__m128d a, __m128d b, const int imm8) - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8 + /// __m128d _mm_cmp_sd (__m128d a, __m128d b, const int imm8) + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8 /// public static Vector128 CompareScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) => CompareScalar(left, right, mode); /// - /// __m128i _mm256_cvtpd_epi32 (__m256d a) - /// VCVTPD2DQ xmm1, ymm2/m256 - /// VCVTPD2DQ xmm1 {k1}{z}, ymm2/m256/m64bcst + /// __m128i _mm256_cvtpd_epi32 (__m256d a) + /// VCVTPD2DQ xmm1, ymm2/m256 + /// VCVTPD2DQ xmm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector128 ConvertToVector128Int32(Vector256 value) => ConvertToVector128Int32(value); /// - /// __m128 _mm256_cvtpd_ps (__m256d a) - /// VCVTPD2PS xmm1, ymm2/m256 - /// VCVTPD2PS xmm1 {k1}{z}, ymm2/m256/m64bcst + /// __m128 _mm256_cvtpd_ps (__m256d a) + /// VCVTPD2PS xmm1, ymm2/m256 + /// VCVTPD2PS xmm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector128 ConvertToVector128Single(Vector256 value) => ConvertToVector128Single(value); /// - /// __m256d _mm256_cvtepi32_pd (__m128i a) - /// VCVTDQ2PD ymm1, xmm2/m128 - /// VCVTDQ2PD ymm1 {k1}{z}, xmm2/m128/m32bcst + /// __m256d _mm256_cvtepi32_pd (__m128i a) + /// VCVTDQ2PD ymm1, xmm2/m128 + /// VCVTDQ2PD ymm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector256 ConvertToVector256Double(Vector128 value) => ConvertToVector256Double(value); /// - /// __m256d _mm256_cvtps_pd (__m128 a) - /// VCVTPS2PD ymm1, xmm2/m128 - /// VCVTPS2PD ymm1 {k1}{z}, xmm2/m128/m32bcst + /// __m256d _mm256_cvtps_pd (__m128 a) + /// VCVTPS2PD ymm1, xmm2/m128 + /// VCVTPS2PD ymm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector256 ConvertToVector256Double(Vector128 value) => ConvertToVector256Double(value); /// - /// __m256i _mm256_cvtps_epi32 (__m256 a) - /// VCVTPS2DQ ymm1, ymm2/m256 - /// VCVTPS2DQ ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_cvtps_epi32 (__m256 a) + /// VCVTPS2DQ ymm1, ymm2/m256 + /// VCVTPS2DQ ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 ConvertToVector256Int32(Vector256 value) => ConvertToVector256Int32(value); /// - /// __m256 _mm256_cvtepi32_ps (__m256i a) - /// VCVTDQ2PS ymm1, ymm2/m256 - /// VCVTDQ2PS ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256 _mm256_cvtepi32_ps (__m256i a) + /// VCVTDQ2PS ymm1, ymm2/m256 + /// VCVTDQ2PS ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 ConvertToVector256Single(Vector256 value) => ConvertToVector256Single(value); /// - /// __m256i _mm256_cvttps_epi32 (__m256 a) - /// VCVTTPS2DQ ymm1, ymm2/m256 - /// VCVTTPS2DQ ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_cvttps_epi32 (__m256 a) + /// VCVTTPS2DQ ymm1, ymm2/m256 + /// VCVTTPS2DQ ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 ConvertToVector256Int32WithTruncation(Vector256 value) => ConvertToVector256Int32WithTruncation(value); /// - /// __m128i _mm256_cvttpd_epi32 (__m256d a) - /// VCVTTPD2DQ xmm1, ymm2/m256 - /// VCVTTPD2DQ xmm1 {k1}{z}, ymm2/m256/m64bcst + /// __m128i _mm256_cvttpd_epi32 (__m256d a) + /// VCVTTPD2DQ xmm1, ymm2/m256 + /// VCVTTPD2DQ xmm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector128 ConvertToVector128Int32WithTruncation(Vector256 value) => ConvertToVector128Int32WithTruncation(value); /// - /// __m256 _mm256_div_ps (__m256 a, __m256 b) - /// VDIVPS ymm1, ymm2, ymm3/m256 - /// VDIVPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_div_ps (__m256 a, __m256 b) + /// VDIVPS ymm1, ymm2, ymm3/m256 + /// VDIVPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Divide(Vector256 left, Vector256 right) => Divide(left, right); /// - /// __m256d _mm256_div_pd (__m256d a, __m256d b) - /// VDIVPD ymm1, ymm2, ymm3/m256 - /// VDIVPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_div_pd (__m256d a, __m256d b) + /// VDIVPD ymm1, ymm2, ymm3/m256 + /// VDIVPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Divide(Vector256 left, Vector256 right) => Divide(left, right); /// - /// __m256 _mm256_dp_ps (__m256 a, __m256 b, const int imm8) - /// VDPPS ymm1, ymm2, ymm3/m256, imm8 + /// __m256 _mm256_dp_ps (__m256 a, __m256 b, const int imm8) + /// VDPPS ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 DotProduct(Vector256 left, Vector256 right, [ConstantExpected] byte control) => DotProduct(left, right, control); /// - /// __m256 _mm256_moveldup_ps (__m256 a) - /// VMOVSLDUP ymm1, ymm2/m256 - /// VMOVSLDUP ymm1 {k1}{z}, ymm2/m256 + /// __m256 _mm256_moveldup_ps (__m256 a) + /// VMOVSLDUP ymm1, ymm2/m256 + /// VMOVSLDUP ymm1 {k1}{z}, ymm2/m256 /// public static Vector256 DuplicateEvenIndexed(Vector256 value) => DuplicateEvenIndexed(value); /// - /// __m256d _mm256_movedup_pd (__m256d a) - /// VMOVDDUP ymm1, ymm2/m256 - /// VMOVDDUP ymm1 {k1}{z}, ymm2/m256 + /// __m256d _mm256_movedup_pd (__m256d a) + /// VMOVDDUP ymm1, ymm2/m256 + /// VMOVDDUP ymm1 {k1}{z}, ymm2/m256 /// public static Vector256 DuplicateEvenIndexed(Vector256 value) => DuplicateEvenIndexed(value); /// - /// __m256 _mm256_movehdup_ps (__m256 a) - /// VMOVSHDUP ymm1, ymm2/m256 - /// VMOVSHDUP ymm1 {k1}{z}, ymm2/m256 + /// __m256 _mm256_movehdup_ps (__m256 a) + /// VMOVSHDUP ymm1, ymm2/m256 + /// VMOVSHDUP ymm1 {k1}{z}, ymm2/m256 /// public static Vector256 DuplicateOddIndexed(Vector256 value) => DuplicateOddIndexed(value); /// - /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) - /// VEXTRACTF128 xmm1/m128, ymm2, imm8 - /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// VEXTRACTF128 xmm1/m128, ymm2, imm8 + /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) - /// VEXTRACTF128 xmm1/m128, ymm2, imm8 - /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// VEXTRACTF128 xmm1/m128, ymm2, imm8 + /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) - /// VEXTRACTF128 xmm1/m128, ymm2, imm8 - /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// VEXTRACTF128 xmm1/m128, ymm2, imm8 + /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) - /// VEXTRACTF128 xmm1/m128, ymm2, imm8 - /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// VEXTRACTF128 xmm1/m128, ymm2, imm8 + /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) - /// VEXTRACTF128 xmm1/m128, ymm2, imm8 - /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// VEXTRACTF128 xmm1/m128, ymm2, imm8 + /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) - /// VEXTRACTF128 xmm1/m128, ymm2, imm8 - /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// VEXTRACTF128 xmm1/m128, ymm2, imm8 + /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) - /// VEXTRACTF128 xmm1/m128, ymm2, imm8 - /// VEXTRACTF64x2 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// VEXTRACTF128 xmm1/m128, ymm2, imm8 + /// VEXTRACTF64x2 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) - /// VEXTRACTF128 xmm1/m128, ymm2, imm8 - /// VEXTRACTF64x2 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extractf128_si256 (__m256i a, const int imm8) + /// VEXTRACTF128 xmm1/m128, ymm2, imm8 + /// VEXTRACTF64x2 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128 _mm256_extractf128_ps (__m256 a, const int imm8) - /// VEXTRACTF128 xmm1/m128, ymm2, imm8 - /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128 _mm256_extractf128_ps (__m256 a, const int imm8) + /// VEXTRACTF128 xmm1/m128, ymm2, imm8 + /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128d _mm256_extractf128_pd (__m256d a, const int imm8) - /// VEXTRACTF128 xmm1/m128, ymm2, imm8 - /// VEXTRACTF64x2 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128d _mm256_extractf128_pd (__m256d a, const int imm8) + /// VEXTRACTF128 xmm1/m128, ymm2, imm8 + /// VEXTRACTF64x2 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m256 _mm256_floor_ps (__m256 a) - /// VROUNDPS ymm1, ymm2/m256, imm8(9) + /// __m256 _mm256_floor_ps (__m256 a) + /// VROUNDPS ymm1, ymm2/m256, imm8(9) /// public static Vector256 Floor(Vector256 value) => Floor(value); /// - /// __m256d _mm256_floor_pd (__m256d a) - /// VROUNDPD ymm1, ymm2/m256, imm8(9) + /// __m256d _mm256_floor_pd (__m256d a) + /// VROUNDPD ymm1, ymm2/m256, imm8(9) /// public static Vector256 Floor(Vector256 value) => Floor(value); /// - /// __m256 _mm256_hadd_ps (__m256 a, __m256 b) - /// VHADDPS ymm1, ymm2, ymm3/m256 + /// __m256 _mm256_hadd_ps (__m256 a, __m256 b) + /// VHADDPS ymm1, ymm2, ymm3/m256 /// public static Vector256 HorizontalAdd(Vector256 left, Vector256 right) => HorizontalAdd(left, right); /// - /// __m256d _mm256_hadd_pd (__m256d a, __m256d b) - /// VHADDPD ymm1, ymm2, ymm3/m256 + /// __m256d _mm256_hadd_pd (__m256d a, __m256d b) + /// VHADDPD ymm1, ymm2, ymm3/m256 /// public static Vector256 HorizontalAdd(Vector256 left, Vector256 right) => HorizontalAdd(left, right); /// - /// __m256 _mm256_hsub_ps (__m256 a, __m256 b) - /// VHSUBPS ymm1, ymm2, ymm3/m256 + /// __m256 _mm256_hsub_ps (__m256 a, __m256 b) + /// VHSUBPS ymm1, ymm2, ymm3/m256 /// public static Vector256 HorizontalSubtract(Vector256 left, Vector256 right) => HorizontalSubtract(left, right); /// - /// __m256d _mm256_hsub_pd (__m256d a, __m256d b) - /// VHSUBPD ymm1, ymm2, ymm3/m256 + /// __m256d _mm256_hsub_pd (__m256d a, __m256d b) + /// VHSUBPD ymm1, ymm2, ymm3/m256 /// public static Vector256 HorizontalSubtract(Vector256 left, Vector256 right) => HorizontalSubtract(left, right); /// - /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) - /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) - /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) - /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) - /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) - /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) - /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) - /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTF64x2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTF64x2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) - /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTF64x2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_insertf128_si256 (__m256i a, __m128i b, int imm8) + /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTF64x2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m256 _mm256_insertf128_ps (__m256 a, __m128 b, int imm8) - /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256 _mm256_insertf128_ps (__m256 a, __m128 b, int imm8) + /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTF32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m256d _mm256_insertf128_pd (__m256d a, __m128d b, int imm8) - /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTF64x2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256d _mm256_insertf128_pd (__m256d a, __m128d b, int imm8) + /// VINSERTF128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTF64x2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m256i _mm256_load_si256 (__m256i const * mem_addr) - /// VMOVDQA ymm1, m256 - /// VMOVDQA32 ymm1 {k1}{z}, m256 + /// __m256i _mm256_load_si256 (__m256i const * mem_addr) + /// VMOVDQA ymm1, m256 + /// VMOVDQA32 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadAlignedVector256(sbyte* address) => LoadAlignedVector256(address); /// - /// __m256i _mm256_load_si256 (__m256i const * mem_addr) - /// VMOVDQA ymm1, m256 - /// VMOVDQA32 ymm1 {k1}{z}, m256 + /// __m256i _mm256_load_si256 (__m256i const * mem_addr) + /// VMOVDQA ymm1, m256 + /// VMOVDQA32 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadAlignedVector256(byte* address) => LoadAlignedVector256(address); /// - /// __m256i _mm256_load_si256 (__m256i const * mem_addr) - /// VMOVDQA ymm1, m256 - /// VMOVDQA32 ymm1 {k1}{z}, m256 + /// __m256i _mm256_load_si256 (__m256i const * mem_addr) + /// VMOVDQA ymm1, m256 + /// VMOVDQA32 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadAlignedVector256(short* address) => LoadAlignedVector256(address); /// - /// __m256i _mm256_load_si256 (__m256i const * mem_addr) - /// VMOVDQA ymm1, m256 - /// VMOVDQA32 ymm1 {k1}{z}, m256 + /// __m256i _mm256_load_si256 (__m256i const * mem_addr) + /// VMOVDQA ymm1, m256 + /// VMOVDQA32 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadAlignedVector256(ushort* address) => LoadAlignedVector256(address); /// - /// __m256i _mm256_load_si256 (__m256i const * mem_addr) - /// VMOVDQA ymm1, m256 - /// VMOVDQA32 ymm1 {k1}{z}, m256 + /// __m256i _mm256_load_si256 (__m256i const * mem_addr) + /// VMOVDQA ymm1, m256 + /// VMOVDQA32 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadAlignedVector256(int* address) => LoadAlignedVector256(address); /// - /// __m256i _mm256_load_si256 (__m256i const * mem_addr) - /// VMOVDQA ymm1, m256 - /// VMOVDQA32 ymm1 {k1}{z}, m256 + /// __m256i _mm256_load_si256 (__m256i const * mem_addr) + /// VMOVDQA ymm1, m256 + /// VMOVDQA32 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadAlignedVector256(uint* address) => LoadAlignedVector256(address); /// - /// __m256i _mm256_load_si256 (__m256i const * mem_addr) - /// VMOVDQA ymm1, m256 - /// VMOVDQA64 ymm1 {k1}{z}, m256 + /// __m256i _mm256_load_si256 (__m256i const * mem_addr) + /// VMOVDQA ymm1, m256 + /// VMOVDQA64 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadAlignedVector256(long* address) => LoadAlignedVector256(address); /// - /// __m256i _mm256_load_si256 (__m256i const * mem_addr) - /// VMOVDQA ymm1, m256 - /// VMOVDQA64 ymm1 {k1}{z}, m256 + /// __m256i _mm256_load_si256 (__m256i const * mem_addr) + /// VMOVDQA ymm1, m256 + /// VMOVDQA64 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadAlignedVector256(ulong* address) => LoadAlignedVector256(address); /// - /// __m256 _mm256_load_ps (float const * mem_addr) - /// VMOVAPS ymm1, m256 - /// VMOVAPS ymm1 {k1}{z}, m256 + /// __m256 _mm256_load_ps (float const * mem_addr) + /// VMOVAPS ymm1, m256 + /// VMOVAPS ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadAlignedVector256(float* address) => LoadAlignedVector256(address); /// - /// __m256d _mm256_load_pd (double const * mem_addr) - /// VMOVAPD ymm1, m256 - /// VMOVAPD ymm1 {k1}{z}, m256 + /// __m256d _mm256_load_pd (double const * mem_addr) + /// VMOVAPD ymm1, m256 + /// VMOVAPD ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadAlignedVector256(double* address) => LoadAlignedVector256(address); /// - /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) - /// VLDDQU ymm1, m256 + /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) + /// VLDDQU ymm1, m256 /// public static unsafe Vector256 LoadDquVector256(sbyte* address) => LoadDquVector256(address); /// - /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) - /// VLDDQU ymm1, m256 + /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) + /// VLDDQU ymm1, m256 /// public static unsafe Vector256 LoadDquVector256(byte* address) => LoadDquVector256(address); /// - /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) - /// VLDDQU ymm1, m256 + /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) + /// VLDDQU ymm1, m256 /// public static unsafe Vector256 LoadDquVector256(short* address) => LoadDquVector256(address); /// - /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) - /// VLDDQU ymm1, m256 + /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) + /// VLDDQU ymm1, m256 /// public static unsafe Vector256 LoadDquVector256(ushort* address) => LoadDquVector256(address); /// - /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) - /// VLDDQU ymm1, m256 + /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) + /// VLDDQU ymm1, m256 /// public static unsafe Vector256 LoadDquVector256(int* address) => LoadDquVector256(address); /// - /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) - /// VLDDQU ymm1, m256 + /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) + /// VLDDQU ymm1, m256 /// public static unsafe Vector256 LoadDquVector256(uint* address) => LoadDquVector256(address); /// - /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) - /// VLDDQU ymm1, m256 + /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) + /// VLDDQU ymm1, m256 /// public static unsafe Vector256 LoadDquVector256(long* address) => LoadDquVector256(address); /// - /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) - /// VLDDQU ymm1, m256 + /// __m256i _mm256_lddqu_si256 (__m256i const * mem_addr) + /// VLDDQU ymm1, m256 /// public static unsafe Vector256 LoadDquVector256(ulong* address) => LoadDquVector256(address); /// - /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) - /// VMOVDQU ymm1, m256 - /// VMOVDQU8 ymm1 {k1}{z}, m256 + /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) + /// VMOVDQU ymm1, m256 + /// VMOVDQU8 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadVector256(sbyte* address) => LoadVector256(address); /// - /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) - /// VMOVDQU ymm1, m256 - /// VMOVDQU8 ymm1 {k1}{z}, m256 + /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) + /// VMOVDQU ymm1, m256 + /// VMOVDQU8 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadVector256(byte* address) => LoadVector256(address); /// - /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) - /// VMOVDQU ymm1, m256 - /// VMOVDQU16 ymm1 {k1}{z}, m256 + /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) + /// VMOVDQU ymm1, m256 + /// VMOVDQU16 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadVector256(short* address) => LoadVector256(address); /// - /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) - /// VMOVDQU ymm1, m256 - /// VMOVDQU16 ymm1 {k1}{z}, m256 + /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) + /// VMOVDQU ymm1, m256 + /// VMOVDQU16 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadVector256(ushort* address) => LoadVector256(address); /// - /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) - /// VMOVDQU ymm1, m256 - /// VMOVDQU32 ymm1 {k1}{z}, m256 + /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) + /// VMOVDQU ymm1, m256 + /// VMOVDQU32 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadVector256(int* address) => LoadVector256(address); /// - /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) - /// VMOVDQU ymm1, m256 - /// VMOVDQU32 ymm1 {k1}{z}, m256 + /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) + /// VMOVDQU ymm1, m256 + /// VMOVDQU32 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadVector256(uint* address) => LoadVector256(address); /// - /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) - /// VMOVDQU ymm1, m256 - /// VMOVDQU64 ymm1 {k1}{z}, m256 + /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) + /// VMOVDQU ymm1, m256 + /// VMOVDQU64 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadVector256(long* address) => LoadVector256(address); /// - /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) - /// VMOVDQU ymm1, m256 - /// VMOVDQU64 ymm1 {k1}{z}, m256 + /// __m256i _mm256_loadu_si256 (__m256i const * mem_addr) + /// VMOVDQU ymm1, m256 + /// VMOVDQU64 ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadVector256(ulong* address) => LoadVector256(address); /// - /// __m256 _mm256_loadu_ps (float const * mem_addr) - /// VMOVUPS ymm1, m256 - /// VMOVUPS ymm1 {k1}{z}, m256 + /// __m256 _mm256_loadu_ps (float const * mem_addr) + /// VMOVUPS ymm1, m256 + /// VMOVUPS ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadVector256(float* address) => LoadVector256(address); /// - /// __m256d _mm256_loadu_pd (double const * mem_addr) - /// VMOVUPD ymm1, m256 - /// VMOVUPD ymm1 {k1}{z}, m256 + /// __m256d _mm256_loadu_pd (double const * mem_addr) + /// VMOVUPD ymm1, m256 + /// VMOVUPD ymm1 {k1}{z}, m256 /// public static unsafe Vector256 LoadVector256(double* address) => LoadVector256(address); /// - /// __m128 _mm_maskload_ps (float const * mem_addr, __m128i mask) - /// VMASKMOVPS xmm1, xmm2, m128 + /// __m128 _mm_maskload_ps (float const * mem_addr, __m128i mask) + /// VMASKMOVPS xmm1, xmm2, m128 /// public static unsafe Vector128 MaskLoad(float* address, Vector128 mask) => MaskLoad(address, mask); /// - /// __m128d _mm_maskload_pd (double const * mem_addr, __m128i mask) - /// VMASKMOVPD xmm1, xmm2, m128 + /// __m128d _mm_maskload_pd (double const * mem_addr, __m128i mask) + /// VMASKMOVPD xmm1, xmm2, m128 /// public static unsafe Vector128 MaskLoad(double* address, Vector128 mask) => MaskLoad(address, mask); /// - /// __m256 _mm256_maskload_ps (float const * mem_addr, __m256i mask) - /// VMASKMOVPS ymm1, ymm2, m256 + /// __m256 _mm256_maskload_ps (float const * mem_addr, __m256i mask) + /// VMASKMOVPS ymm1, ymm2, m256 /// public static unsafe Vector256 MaskLoad(float* address, Vector256 mask) => MaskLoad(address, mask); /// - /// __m256d _mm256_maskload_pd (double const * mem_addr, __m256i mask) - /// VMASKMOVPD ymm1, ymm2, m256 + /// __m256d _mm256_maskload_pd (double const * mem_addr, __m256i mask) + /// VMASKMOVPD ymm1, ymm2, m256 /// public static unsafe Vector256 MaskLoad(double* address, Vector256 mask) => MaskLoad(address, mask); /// - /// void _mm_maskstore_ps (float * mem_addr, __m128i mask, __m128 a) - /// VMASKMOVPS m128, xmm1, xmm2 + /// void _mm_maskstore_ps (float * mem_addr, __m128i mask, __m128 a) + /// VMASKMOVPS m128, xmm1, xmm2 /// public static unsafe void MaskStore(float* address, Vector128 mask, Vector128 source) => MaskStore(address, mask, source); /// - /// void _mm_maskstore_pd (double * mem_addr, __m128i mask, __m128d a) - /// VMASKMOVPD m128, xmm1, xmm2 + /// void _mm_maskstore_pd (double * mem_addr, __m128i mask, __m128d a) + /// VMASKMOVPD m128, xmm1, xmm2 /// public static unsafe void MaskStore(double* address, Vector128 mask, Vector128 source) => MaskStore(address, mask, source); /// - /// void _mm256_maskstore_ps (float * mem_addr, __m256i mask, __m256 a) - /// VMASKMOVPS m256, ymm1, ymm2 + /// void _mm256_maskstore_ps (float * mem_addr, __m256i mask, __m256 a) + /// VMASKMOVPS m256, ymm1, ymm2 /// public static unsafe void MaskStore(float* address, Vector256 mask, Vector256 source) => MaskStore(address, mask, source); /// - /// void _mm256_maskstore_pd (double * mem_addr, __m256i mask, __m256d a) - /// VMASKMOVPD m256, ymm1, ymm2 + /// void _mm256_maskstore_pd (double * mem_addr, __m256i mask, __m256d a) + /// VMASKMOVPD m256, ymm1, ymm2 /// public static unsafe void MaskStore(double* address, Vector256 mask, Vector256 source) => MaskStore(address, mask, source); /// - /// __m256 _mm256_max_ps (__m256 a, __m256 b) - /// VMAXPS ymm1, ymm2, ymm3/m256 - /// VMAXPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_max_ps (__m256 a, __m256 b) + /// VMAXPS ymm1, ymm2, ymm3/m256 + /// VMAXPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Max(Vector256 left, Vector256 right) => Max(left, right); /// - /// __m256d _mm256_max_pd (__m256d a, __m256d b) - /// VMAXPD ymm1, ymm2, ymm3/m256 - /// VMAXPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_max_pd (__m256d a, __m256d b) + /// VMAXPD ymm1, ymm2, ymm3/m256 + /// VMAXPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Max(Vector256 left, Vector256 right) => Max(left, right); /// - /// __m256 _mm256_min_ps (__m256 a, __m256 b) - /// VMINPS ymm1, ymm2, ymm3/m256 - /// VMINPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_min_ps (__m256 a, __m256 b) + /// VMINPS ymm1, ymm2, ymm3/m256 + /// VMINPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Min(Vector256 left, Vector256 right) => Min(left, right); /// - /// __m256d _mm256_min_pd (__m256d a, __m256d b) - /// VMINPD ymm1, ymm2, ymm3/m256 - /// VMINPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_min_pd (__m256d a, __m256d b) + /// VMINPD ymm1, ymm2, ymm3/m256 + /// VMINPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Min(Vector256 left, Vector256 right) => Min(left, right); /// - /// int _mm256_movemask_ps (__m256 a) - /// VMOVMSKPS r32, ymm1 + /// int _mm256_movemask_ps (__m256 a) + /// VMOVMSKPS r32, ymm1 /// public static int MoveMask(Vector256 value) => MoveMask(value); /// - /// int _mm256_movemask_pd (__m256d a) - /// VMOVMSKPD r32, ymm1 + /// int _mm256_movemask_pd (__m256d a) + /// VMOVMSKPD r32, ymm1 /// public static int MoveMask(Vector256 value) => MoveMask(value); /// - /// __m256 _mm256_mul_ps (__m256 a, __m256 b) - /// VMULPS ymm1, ymm2, ymm3/m256 - /// VMULPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_mul_ps (__m256 a, __m256 b) + /// VMULPS ymm1, ymm2, ymm3/m256 + /// VMULPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Multiply(Vector256 left, Vector256 right) => Multiply(left, right); /// - /// __m256d _mm256_mul_pd (__m256d a, __m256d b) - /// VMULPD ymm1, ymm2, ymm3/m256 - /// VMULPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_mul_pd (__m256d a, __m256d b) + /// VMULPD ymm1, ymm2, ymm3/m256 + /// VMULPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Multiply(Vector256 left, Vector256 right) => Multiply(left, right); /// - /// __m256 _mm256_or_ps (__m256 a, __m256 b) - /// VORPS ymm1, ymm2, ymm3/m256 - /// VORPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_or_ps (__m256 a, __m256 b) + /// VORPS ymm1, ymm2, ymm3/m256 + /// VORPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Or(Vector256 left, Vector256 right) => Or(left, right); /// - /// __m256d _mm256_or_pd (__m256d a, __m256d b) - /// VORPD ymm1, ymm2, ymm3/m256 - /// VORPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_or_pd (__m256d a, __m256d b) + /// VORPD ymm1, ymm2, ymm3/m256 + /// VORPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Or(Vector256 left, Vector256 right) => Or(left, right); /// - /// __m128 _mm_permute_ps (__m128 a, int imm8) - /// VPERMILPS xmm1, xmm2/m128, imm8 - /// VPERMILPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128 _mm_permute_ps (__m128 a, int imm8) + /// VPERMILPS xmm1, xmm2/m128, imm8 + /// VPERMILPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 Permute(Vector128 value, [ConstantExpected] byte control) => Permute(value, control); /// - /// __m128d _mm_permute_pd (__m128d a, int imm8) - /// VPERMILPD xmm1, xmm2/m128, imm8 - /// VPERMILPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128d _mm_permute_pd (__m128d a, int imm8) + /// VPERMILPD xmm1, xmm2/m128, imm8 + /// VPERMILPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 Permute(Vector128 value, [ConstantExpected] byte control) => Permute(value, control); /// - /// __m256 _mm256_permute_ps (__m256 a, int imm8) - /// VPERMILPS ymm1, ymm2/m256, imm8 - /// VPERMILPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256 _mm256_permute_ps (__m256 a, int imm8) + /// VPERMILPS ymm1, ymm2/m256, imm8 + /// VPERMILPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 Permute(Vector256 value, [ConstantExpected] byte control) => Permute(value, control); /// - /// __m256d _mm256_permute_pd (__m256d a, int imm8) - /// VPERMILPD ymm1, ymm2/m256, imm8 - /// VPERMILPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256d _mm256_permute_pd (__m256d a, int imm8) + /// VPERMILPD ymm1, ymm2/m256, imm8 + /// VPERMILPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 Permute(Vector256 value, [ConstantExpected] byte control) => Permute(value, control); /// - /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) - /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) + /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Permute2x128(left, right, control); /// - /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) - /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) + /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Permute2x128(left, right, control); /// - /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) - /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) + /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Permute2x128(left, right, control); /// - /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) - /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) + /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Permute2x128(left, right, control); /// - /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) - /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) + /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Permute2x128(left, right, control); /// - /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) - /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) + /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Permute2x128(left, right, control); /// - /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) - /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) + /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Permute2x128(left, right, control); /// - /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) - /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2f128_si256 (__m256i a, __m256i b, int imm8) + /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Permute2x128(left, right, control); /// - /// __m256 _mm256_permute2f128_ps (__m256 a, __m256 b, int imm8) - /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256 _mm256_permute2f128_ps (__m256 a, __m256 b, int imm8) + /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Permute2x128(left, right, control); /// - /// __m256d _mm256_permute2f128_pd (__m256d a, __m256d b, int imm8) - /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256d _mm256_permute2f128_pd (__m256d a, __m256d b, int imm8) + /// VPERM2F128 ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Permute2x128(left, right, control); /// - /// __m128 _mm_permutevar_ps (__m128 a, __m128i b) - /// VPERMILPS xmm1, xmm2, xmm3/m128 - /// VPERMILPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_permutevar_ps (__m128 a, __m128i b) + /// VPERMILPS xmm1, xmm2, xmm3/m128 + /// VPERMILPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 PermuteVar(Vector128 left, Vector128 control) => PermuteVar(left, control); /// - /// __m128d _mm_permutevar_pd (__m128d a, __m128i b) - /// VPERMILPD xmm1, xmm2, xmm3/m128 - /// VPERMILPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_permutevar_pd (__m128d a, __m128i b) + /// VPERMILPD xmm1, xmm2, xmm3/m128 + /// VPERMILPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 PermuteVar(Vector128 left, Vector128 control) => PermuteVar(left, control); /// - /// __m256 _mm256_permutevar_ps (__m256 a, __m256i b) - /// VPERMILPS ymm1, ymm2, ymm3/m256 - /// VPERMILPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_permutevar_ps (__m256 a, __m256i b) + /// VPERMILPS ymm1, ymm2, ymm3/m256 + /// VPERMILPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 PermuteVar(Vector256 left, Vector256 control) => PermuteVar(left, control); /// - /// __m256d _mm256_permutevar_pd (__m256d a, __m256i b) - /// VPERMILPD ymm1, ymm2, ymm3/m256 - /// VPERMILPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_permutevar_pd (__m256d a, __m256i b) + /// VPERMILPD ymm1, ymm2, ymm3/m256 + /// VPERMILPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar(Vector256 left, Vector256 control) => PermuteVar(left, control); /// - /// __m256 _mm256_rcp_ps (__m256 a) - /// VRCPPS ymm1, ymm2/m256 + /// __m256 _mm256_rcp_ps (__m256 a) + /// VRCPPS ymm1, ymm2/m256 /// public static Vector256 Reciprocal(Vector256 value) => Reciprocal(value); /// - /// __m256 _mm256_rsqrt_ps (__m256 a) - /// VRSQRTPS ymm1, ymm2/m256 + /// __m256 _mm256_rsqrt_ps (__m256 a) + /// VRSQRTPS ymm1, ymm2/m256 /// public static Vector256 ReciprocalSqrt(Vector256 value) => ReciprocalSqrt(value); /// - /// __m256 _mm256_round_ps (__m256 a, _MM_FROUND_CUR_DIRECTION) - /// VROUNDPS ymm1, ymm2/m256, imm8(4) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m256 _mm256_round_ps (__m256 a, _MM_FROUND_CUR_DIRECTION) + /// VROUNDPS ymm1, ymm2/m256, imm8(4) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector256 RoundCurrentDirection(Vector256 value) => RoundCurrentDirection(value); /// - /// __m256d _mm256_round_ps (__m256d a, _MM_FROUND_CUR_DIRECTION) - /// VROUNDPD ymm1, ymm2/m256, imm8(4) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m256d _mm256_round_ps (__m256d a, _MM_FROUND_CUR_DIRECTION) + /// VROUNDPD ymm1, ymm2/m256, imm8(4) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector256 RoundCurrentDirection(Vector256 value) => RoundCurrentDirection(value); /// - /// __m256 _mm256_round_ps (__m256 a, _MM_FROUND_TO_NEAREST_INT) - /// VROUNDPS ymm1, ymm2/m256, imm8(8) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m256 _mm256_round_ps (__m256 a, _MM_FROUND_TO_NEAREST_INT) + /// VROUNDPS ymm1, ymm2/m256, imm8(8) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector256 RoundToNearestInteger(Vector256 value) => RoundToNearestInteger(value); /// - /// __m256d _mm256_round_pd (__m256d a, _MM_FROUND_TO_NEAREST_INT) - /// VROUNDPD ymm1, ymm2/m256, imm8(8) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m256d _mm256_round_pd (__m256d a, _MM_FROUND_TO_NEAREST_INT) + /// VROUNDPD ymm1, ymm2/m256, imm8(8) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector256 RoundToNearestInteger(Vector256 value) => RoundToNearestInteger(value); /// - /// __m256 _mm256_round_ps (__m256 a, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) - /// VROUNDPS ymm1, ymm2/m256, imm8(9) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m256 _mm256_round_ps (__m256 a, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) + /// VROUNDPS ymm1, ymm2/m256, imm8(9) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector256 RoundToNegativeInfinity(Vector256 value) => RoundToNegativeInfinity(value); /// - /// __m256d _mm256_round_pd (__m256d a, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) - /// VROUNDPD ymm1, ymm2/m256, imm8(9) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m256d _mm256_round_pd (__m256d a, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) + /// VROUNDPD ymm1, ymm2/m256, imm8(9) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector256 RoundToNegativeInfinity(Vector256 value) => RoundToNegativeInfinity(value); /// - /// __m256 _mm256_round_ps (__m256 a, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) - /// VROUNDPS ymm1, ymm2/m256, imm8(10) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m256 _mm256_round_ps (__m256 a, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) + /// VROUNDPS ymm1, ymm2/m256, imm8(10) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector256 RoundToPositiveInfinity(Vector256 value) => RoundToPositiveInfinity(value); /// - /// __m256d _mm256_round_pd (__m256d a, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) - /// VROUNDPD ymm1, ymm2/m256, imm8(10) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m256d _mm256_round_pd (__m256d a, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) + /// VROUNDPD ymm1, ymm2/m256, imm8(10) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector256 RoundToPositiveInfinity(Vector256 value) => RoundToPositiveInfinity(value); /// - /// __m256 _mm256_round_ps (__m256 a, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) - /// VROUNDPS ymm1, ymm2/m256, imm8(11) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m256 _mm256_round_ps (__m256 a, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) + /// VROUNDPS ymm1, ymm2/m256, imm8(11) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector256 RoundToZero(Vector256 value) => RoundToZero(value); /// - /// __m256d _mm256_round_pd (__m256d a, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) - /// VROUNDPD ymm1, ymm2/m256, imm8(11) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m256d _mm256_round_pd (__m256d a, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) + /// VROUNDPD ymm1, ymm2/m256, imm8(11) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector256 RoundToZero(Vector256 value) => RoundToZero(value); /// - /// __m256 _mm256_shuffle_ps (__m256 a, __m256 b, const int imm8) - /// VSHUFPS ymm1, ymm2, ymm3/m256, imm8 - /// VSHUFPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256 _mm256_shuffle_ps (__m256 a, __m256 b, const int imm8) + /// VSHUFPS ymm1, ymm2, ymm3/m256, imm8 + /// VSHUFPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 Shuffle(Vector256 value, Vector256 right, [ConstantExpected] byte control) => Shuffle(value, right, control); /// - /// __m256d _mm256_shuffle_pd (__m256d a, __m256d b, const int imm8) - /// VSHUFPD ymm1, ymm2, ymm3/m256, imm8 - /// VSHUFPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256d _mm256_shuffle_pd (__m256d a, __m256d b, const int imm8) + /// VSHUFPD ymm1, ymm2, ymm3/m256, imm8 + /// VSHUFPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 Shuffle(Vector256 value, Vector256 right, [ConstantExpected] byte control) => Shuffle(value, right, control); /// - /// __m256 _mm256_sqrt_ps (__m256 a) - /// VSQRTPS ymm1, ymm2/m256 - /// VSQRTPS ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256 _mm256_sqrt_ps (__m256 a) + /// VSQRTPS ymm1, ymm2/m256 + /// VSQRTPS ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 Sqrt(Vector256 value) => Sqrt(value); /// - /// __m256d _mm256_sqrt_pd (__m256d a) - /// VSQRTPD ymm1, ymm2/m256 - /// VSQRTPD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_sqrt_pd (__m256d a) + /// VSQRTPD ymm1, ymm2/m256 + /// VSQRTPD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 Sqrt(Vector256 value) => Sqrt(value); /// - /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQU m256, ymm1 - /// VMOVDQU8 m256 {k1}{z}, ymm1 + /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQU m256, ymm1 + /// VMOVDQU8 m256 {k1}{z}, ymm1 /// public static unsafe void Store(sbyte* address, Vector256 source) => Store(address, source); /// - /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQU m256, ymm1 - /// VMOVDQU8 m256 {k1}{z}, ymm1 + /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQU m256, ymm1 + /// VMOVDQU8 m256 {k1}{z}, ymm1 /// public static unsafe void Store(byte* address, Vector256 source) => Store(address, source); /// - /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQU m256, ymm1 - /// VMOVDQU16 m256 {k1}{z}, ymm1 + /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQU m256, ymm1 + /// VMOVDQU16 m256 {k1}{z}, ymm1 /// public static unsafe void Store(short* address, Vector256 source) => Store(address, source); /// - /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQU m256, ymm1 - /// VMOVDQU16 m256 {k1}{z}, ymm1 + /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQU m256, ymm1 + /// VMOVDQU16 m256 {k1}{z}, ymm1 /// public static unsafe void Store(ushort* address, Vector256 source) => Store(address, source); /// - /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQU m256, ymm1 - /// VMOVDQU32 m256 {k1}{z}, ymm1 + /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQU m256, ymm1 + /// VMOVDQU32 m256 {k1}{z}, ymm1 /// public static unsafe void Store(int* address, Vector256 source) => Store(address, source); /// - /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQU m256, ymm1 - /// VMOVDQU32 m256 {k1}{z}, ymm1 + /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQU m256, ymm1 + /// VMOVDQU32 m256 {k1}{z}, ymm1 /// public static unsafe void Store(uint* address, Vector256 source) => Store(address, source); /// - /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQU m256, ymm1 - /// VMOVDQU64 m256 {k1}{z}, ymm1 + /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQU m256, ymm1 + /// VMOVDQU64 m256 {k1}{z}, ymm1 /// public static unsafe void Store(long* address, Vector256 source) => Store(address, source); /// - /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQU m256, ymm1 - /// VMOVDQU64 m256 {k1}{z}, ymm1 + /// void _mm256_storeu_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQU m256, ymm1 + /// VMOVDQU64 m256 {k1}{z}, ymm1 /// public static unsafe void Store(ulong* address, Vector256 source) => Store(address, source); /// - /// void _mm256_storeu_ps (float * mem_addr, __m256 a) - /// VMOVUPS m256, ymm1 - /// VMOVUPS m256 {k1}{z}, ymm1 + /// void _mm256_storeu_ps (float * mem_addr, __m256 a) + /// VMOVUPS m256, ymm1 + /// VMOVUPS m256 {k1}{z}, ymm1 /// public static unsafe void Store(float* address, Vector256 source) => Store(address, source); /// - /// void _mm256_storeu_pd (double * mem_addr, __m256d a) - /// VMOVUPD m256, ymm1 - /// VMOVUPD m256 {k1}{z}, ymm1 + /// void _mm256_storeu_pd (double * mem_addr, __m256d a) + /// VMOVUPD m256, ymm1 + /// VMOVUPD m256 {k1}{z}, ymm1 /// public static unsafe void Store(double* address, Vector256 source) => Store(address, source); /// - /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQA m256, ymm1 - /// VMOVDQA32 m256 {k1}{z}, ymm1 + /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQA m256, ymm1 + /// VMOVDQA32 m256 {k1}{z}, ymm1 /// public static unsafe void StoreAligned(sbyte* address, Vector256 source) => StoreAligned(address, source); /// - /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQA m256, ymm1 - /// VMOVDQA32 m256 {k1}{z}, ymm1 + /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQA m256, ymm1 + /// VMOVDQA32 m256 {k1}{z}, ymm1 /// public static unsafe void StoreAligned(byte* address, Vector256 source) => StoreAligned(address, source); /// - /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQA m256, ymm1 - /// VMOVDQA32 m256 {k1}{z}, ymm1 + /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQA m256, ymm1 + /// VMOVDQA32 m256 {k1}{z}, ymm1 /// public static unsafe void StoreAligned(short* address, Vector256 source) => StoreAligned(address, source); /// - /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQA m256, ymm1 - /// VMOVDQA32 m256 {k1}{z}, ymm1 + /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQA m256, ymm1 + /// VMOVDQA32 m256 {k1}{z}, ymm1 /// public static unsafe void StoreAligned(ushort* address, Vector256 source) => StoreAligned(address, source); /// - /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQA m256, ymm1 - /// VMOVDQA32 m256 {k1}{z}, ymm1 + /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQA m256, ymm1 + /// VMOVDQA32 m256 {k1}{z}, ymm1 /// public static unsafe void StoreAligned(int* address, Vector256 source) => StoreAligned(address, source); /// - /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQA m256, ymm1 - /// VMOVDQA32 m256 {k1}{z}, ymm1 + /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQA m256, ymm1 + /// VMOVDQA32 m256 {k1}{z}, ymm1 /// public static unsafe void StoreAligned(uint* address, Vector256 source) => StoreAligned(address, source); /// - /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQA m256, ymm1 - /// VMOVDQA64 m256 {k1}{z}, ymm1 + /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQA m256, ymm1 + /// VMOVDQA64 m256 {k1}{z}, ymm1 /// public static unsafe void StoreAligned(long* address, Vector256 source) => StoreAligned(address, source); /// - /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) - /// VMOVDQA m256, ymm1 - /// VMOVDQA64 m256 {k1}{z}, ymm1 + /// void _mm256_store_si256 (__m256i * mem_addr, __m256i a) + /// VMOVDQA m256, ymm1 + /// VMOVDQA64 m256 {k1}{z}, ymm1 /// public static unsafe void StoreAligned(ulong* address, Vector256 source) => StoreAligned(address, source); /// - /// void _mm256_store_ps (float * mem_addr, __m256 a) - /// VMOVAPS m256, ymm1 - /// VMOVAPS m256 {k1}{z}, ymm1 + /// void _mm256_store_ps (float * mem_addr, __m256 a) + /// VMOVAPS m256, ymm1 + /// VMOVAPS m256 {k1}{z}, ymm1 /// public static unsafe void StoreAligned(float* address, Vector256 source) => StoreAligned(address, source); /// - /// void _mm256_store_pd (double * mem_addr, __m256d a) - /// VMOVAPD m256, ymm1 - /// VMOVAPD m256 {k1}{z}, ymm1 + /// void _mm256_store_pd (double * mem_addr, __m256d a) + /// VMOVAPD m256, ymm1 + /// VMOVAPD m256 {k1}{z}, ymm1 /// public static unsafe void StoreAligned(double* address, Vector256 source) => StoreAligned(address, source); /// - /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) - /// VMOVNTDQ m256, ymm1 + /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) + /// VMOVNTDQ m256, ymm1 /// public static unsafe void StoreAlignedNonTemporal(sbyte* address, Vector256 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) - /// VMOVNTDQ m256, ymm1 + /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) + /// VMOVNTDQ m256, ymm1 /// public static unsafe void StoreAlignedNonTemporal(byte* address, Vector256 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) - /// VMOVNTDQ m256, ymm1 + /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) + /// VMOVNTDQ m256, ymm1 /// public static unsafe void StoreAlignedNonTemporal(short* address, Vector256 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) - /// VMOVNTDQ m256, ymm1 + /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) + /// VMOVNTDQ m256, ymm1 /// public static unsafe void StoreAlignedNonTemporal(ushort* address, Vector256 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) - /// VMOVNTDQ m256, ymm1 + /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) + /// VMOVNTDQ m256, ymm1 /// public static unsafe void StoreAlignedNonTemporal(int* address, Vector256 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) - /// VMOVNTDQ m256, ymm1 + /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) + /// VMOVNTDQ m256, ymm1 /// public static unsafe void StoreAlignedNonTemporal(uint* address, Vector256 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) - /// VMOVNTDQ m256, ymm1 + /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) + /// VMOVNTDQ m256, ymm1 /// public static unsafe void StoreAlignedNonTemporal(long* address, Vector256 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) - /// VMOVNTDQ m256, ymm1 + /// void _mm256_stream_si256 (__m256i * mem_addr, __m256i a) + /// VMOVNTDQ m256, ymm1 /// public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector256 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm256_stream_ps (float * mem_addr, __m256 a) - /// VMOVNTPS m256, ymm1 + /// void _mm256_stream_ps (float * mem_addr, __m256 a) + /// VMOVNTPS m256, ymm1 /// public static unsafe void StoreAlignedNonTemporal(float* address, Vector256 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm256_stream_pd (double * mem_addr, __m256d a) - /// VMOVNTPD m256, ymm1 + /// void _mm256_stream_pd (double * mem_addr, __m256d a) + /// VMOVNTPD m256, ymm1 /// public static unsafe void StoreAlignedNonTemporal(double* address, Vector256 source) => StoreAlignedNonTemporal(address, source); /// - /// __m256 _mm256_sub_ps (__m256 a, __m256 b) - /// VSUBPS ymm1, ymm2, ymm3/m256 - /// VSUBPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_sub_ps (__m256 a, __m256 b) + /// VSUBPS ymm1, ymm2, ymm3/m256 + /// VSUBPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Subtract(Vector256 left, Vector256 right) => Subtract(left, right); /// - /// __m256d _mm256_sub_pd (__m256d a, __m256d b) - /// VSUBPD ymm1, ymm2, ymm3/m256 - /// VSUBPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_sub_pd (__m256d a, __m256d b) + /// VSUBPD ymm1, ymm2, ymm3/m256 + /// VSUBPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Subtract(Vector256 left, Vector256 right) => Subtract(left, right); /// - /// int _mm_testc_ps (__m128 a, __m128 b) - /// VTESTPS xmm1, xmm2/m128 ; CF=1 + /// int _mm_testc_ps (__m128 a, __m128 b) + /// VTESTPS xmm1, xmm2/m128 ; CF=1 /// public static bool TestC(Vector128 left, Vector128 right) => TestC(left, right); /// - /// int _mm_testc_pd (__m128d a, __m128d b) - /// VTESTPD xmm1, xmm2/m128 ; CF=1 + /// int _mm_testc_pd (__m128d a, __m128d b) + /// VTESTPD xmm1, xmm2/m128 ; CF=1 /// public static bool TestC(Vector128 left, Vector128 right) => TestC(left, right); /// - /// int _mm256_testc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; CF=1 + /// int _mm256_testc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; CF=1 /// public static bool TestC(Vector256 left, Vector256 right) => TestC(left, right); /// - /// int _mm256_testc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; CF=1 + /// int _mm256_testc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; CF=1 /// public static bool TestC(Vector256 left, Vector256 right) => TestC(left, right); /// - /// int _mm256_testc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; CF=1 + /// int _mm256_testc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; CF=1 /// public static bool TestC(Vector256 left, Vector256 right) => TestC(left, right); /// - /// int _mm256_testc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; CF=1 + /// int _mm256_testc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; CF=1 /// public static bool TestC(Vector256 left, Vector256 right) => TestC(left, right); /// - /// int _mm256_testc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; CF=1 + /// int _mm256_testc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; CF=1 /// public static bool TestC(Vector256 left, Vector256 right) => TestC(left, right); /// - /// int _mm256_testc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; CF=1 + /// int _mm256_testc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; CF=1 /// public static bool TestC(Vector256 left, Vector256 right) => TestC(left, right); /// - /// int _mm256_testc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; CF=1 + /// int _mm256_testc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; CF=1 /// public static bool TestC(Vector256 left, Vector256 right) => TestC(left, right); /// - /// int _mm256_testc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; CF=1 + /// int _mm256_testc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; CF=1 /// public static bool TestC(Vector256 left, Vector256 right) => TestC(left, right); /// - /// int _mm256_testc_ps (__m256 a, __m256 b) - /// VTESTPS ymm1, ymm2/m256 ; CF=1 + /// int _mm256_testc_ps (__m256 a, __m256 b) + /// VTESTPS ymm1, ymm2/m256 ; CF=1 /// public static bool TestC(Vector256 left, Vector256 right) => TestC(left, right); /// - /// int _mm256_testc_pd (__m256d a, __m256d b) - /// VTESTPD ymm1, ymm2/m256 ; CF=1 + /// int _mm256_testc_pd (__m256d a, __m256d b) + /// VTESTPD ymm1, ymm2/m256 ; CF=1 /// public static bool TestC(Vector256 left, Vector256 right) => TestC(left, right); /// - /// int _mm_testnzc_ps (__m128 a, __m128 b) - /// VTESTPS xmm1, ymm2/m128 ; ZF=0 && CF=0 + /// int _mm_testnzc_ps (__m128 a, __m128 b) + /// VTESTPS xmm1, ymm2/m128 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector128 left, Vector128 right) => TestNotZAndNotC(left, right); /// - /// int _mm_testnzc_pd (__m128d a, __m128d b) - /// VTESTPD xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// int _mm_testnzc_pd (__m128d a, __m128d b) + /// VTESTPD xmm1, xmm2/m128 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector128 left, Vector128 right) => TestNotZAndNotC(left, right); /// - /// int _mm256_testnzc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 + /// int _mm256_testnzc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector256 left, Vector256 right) => TestNotZAndNotC(left, right); /// - /// int _mm256_testnzc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 + /// int _mm256_testnzc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector256 left, Vector256 right) => TestNotZAndNotC(left, right); /// - /// int _mm256_testnzc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 + /// int _mm256_testnzc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector256 left, Vector256 right) => TestNotZAndNotC(left, right); /// - /// int _mm256_testnzc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 + /// int _mm256_testnzc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector256 left, Vector256 right) => TestNotZAndNotC(left, right); /// - /// int _mm256_testnzc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 + /// int _mm256_testnzc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector256 left, Vector256 right) => TestNotZAndNotC(left, right); /// - /// int _mm256_testnzc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 + /// int _mm256_testnzc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector256 left, Vector256 right) => TestNotZAndNotC(left, right); /// - /// int _mm256_testnzc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 + /// int _mm256_testnzc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector256 left, Vector256 right) => TestNotZAndNotC(left, right); /// - /// int _mm256_testnzc_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 + /// int _mm256_testnzc_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector256 left, Vector256 right) => TestNotZAndNotC(left, right); /// - /// int _mm256_testnzc_ps (__m256 a, __m256 b) - /// VTESTPS ymm1, ymm2/m256 ; ZF=0 && CF=0 + /// int _mm256_testnzc_ps (__m256 a, __m256 b) + /// VTESTPS ymm1, ymm2/m256 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector256 left, Vector256 right) => TestNotZAndNotC(left, right); /// - /// int _mm256_testnzc_pd (__m256d a, __m256d b) - /// VTESTPD ymm1, ymm2/m256 ; ZF=0 && CF=0 + /// int _mm256_testnzc_pd (__m256d a, __m256d b) + /// VTESTPD ymm1, ymm2/m256 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector256 left, Vector256 right) => TestNotZAndNotC(left, right); /// - /// int _mm_testz_ps (__m128 a, __m128 b) - /// VTESTPS xmm1, xmm2/m128 ; ZF=1 + /// int _mm_testz_ps (__m128 a, __m128 b) + /// VTESTPS xmm1, xmm2/m128 ; ZF=1 /// public static bool TestZ(Vector128 left, Vector128 right) => TestZ(left, right); /// - /// int _mm_testz_pd (__m128d a, __m128d b) - /// VTESTPD xmm1, xmm2/m128 ; ZF=1 + /// int _mm_testz_pd (__m128d a, __m128d b) + /// VTESTPD xmm1, xmm2/m128 ; ZF=1 /// public static bool TestZ(Vector128 left, Vector128 right) => TestZ(left, right); /// - /// int _mm256_testz_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=1 + /// int _mm256_testz_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=1 /// public static bool TestZ(Vector256 left, Vector256 right) => TestZ(left, right); /// - /// int _mm256_testz_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=1 + /// int _mm256_testz_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=1 /// public static bool TestZ(Vector256 left, Vector256 right) => TestZ(left, right); /// - /// int _mm256_testz_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=1 + /// int _mm256_testz_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=1 /// public static bool TestZ(Vector256 left, Vector256 right) => TestZ(left, right); /// - /// int _mm256_testz_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=1 + /// int _mm256_testz_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=1 /// public static bool TestZ(Vector256 left, Vector256 right) => TestZ(left, right); /// - /// int _mm256_testz_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=1 + /// int _mm256_testz_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=1 /// public static bool TestZ(Vector256 left, Vector256 right) => TestZ(left, right); /// - /// int _mm256_testz_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=1 + /// int _mm256_testz_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=1 /// public static bool TestZ(Vector256 left, Vector256 right) => TestZ(left, right); /// - /// int _mm256_testz_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=1 + /// int _mm256_testz_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=1 /// public static bool TestZ(Vector256 left, Vector256 right) => TestZ(left, right); /// - /// int _mm256_testz_si256 (__m256i a, __m256i b) - /// VPTEST ymm1, ymm2/m256 ; ZF=1 + /// int _mm256_testz_si256 (__m256i a, __m256i b) + /// VPTEST ymm1, ymm2/m256 ; ZF=1 /// public static bool TestZ(Vector256 left, Vector256 right) => TestZ(left, right); /// - /// int _mm256_testz_ps (__m256 a, __m256 b) - /// VTESTPS ymm1, ymm2/m256 ; ZF=1 + /// int _mm256_testz_ps (__m256 a, __m256 b) + /// VTESTPS ymm1, ymm2/m256 ; ZF=1 /// public static bool TestZ(Vector256 left, Vector256 right) => TestZ(left, right); /// - /// int _mm256_testz_pd (__m256d a, __m256d b) - /// VTESTPD ymm1, ymm2/m256 ; ZF=1 + /// int _mm256_testz_pd (__m256d a, __m256d b) + /// VTESTPD ymm1, ymm2/m256 ; ZF=1 /// public static bool TestZ(Vector256 left, Vector256 right) => TestZ(left, right); /// - /// __m256 _mm256_unpackhi_ps (__m256 a, __m256 b) - /// VUNPCKHPS ymm1, ymm2, ymm3/m256 - /// VUNPCKHPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_unpackhi_ps (__m256 a, __m256 b) + /// VUNPCKHPS ymm1, ymm2, ymm3/m256 + /// VUNPCKHPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 UnpackHigh(Vector256 left, Vector256 right) => UnpackHigh(left, right); /// - /// __m256d _mm256_unpackhi_pd (__m256d a, __m256d b) - /// VUNPCKHPD ymm1, ymm2, ymm3/m256 - /// VUNPCKHPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_unpackhi_pd (__m256d a, __m256d b) + /// VUNPCKHPD ymm1, ymm2, ymm3/m256 + /// VUNPCKHPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 UnpackHigh(Vector256 left, Vector256 right) => UnpackHigh(left, right); /// - /// __m256 _mm256_unpacklo_ps (__m256 a, __m256 b) - /// VUNPCKLPS ymm1, ymm2, ymm3/m256 - /// VUNPCKLPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_unpacklo_ps (__m256 a, __m256 b) + /// VUNPCKLPS ymm1, ymm2, ymm3/m256 + /// VUNPCKLPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 UnpackLow(Vector256 left, Vector256 right) => UnpackLow(left, right); /// - /// __m256d _mm256_unpacklo_pd (__m256d a, __m256d b) - /// VUNPCKLPD ymm1, ymm2, ymm3/m256 - /// VUNPCKLPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_unpacklo_pd (__m256d a, __m256d b) + /// VUNPCKLPD ymm1, ymm2, ymm3/m256 + /// VUNPCKLPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 UnpackLow(Vector256 left, Vector256 right) => UnpackLow(left, right); /// - /// __m256 _mm256_xor_ps (__m256 a, __m256 b) - /// VXORPS ymm1, ymm2, ymm3/m256 - /// VXORPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_xor_ps (__m256 a, __m256 b) + /// VXORPS ymm1, ymm2, ymm3/m256 + /// VXORPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Xor(Vector256 left, Vector256 right) => Xor(left, right); /// - /// __m256d _mm256_xor_pd (__m256d a, __m256d b) - /// VXORPD ymm1, ymm2, ymm3/m256 - /// VXORPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_xor_pd (__m256d a, __m256d b) + /// VXORPD ymm1, ymm2, ymm3/m256 + /// VXORPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Xor(Vector256 left, Vector256 right) => Xor(left, right); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx10v1.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx10v1.PlatformNotSupported.cs index 11ec731a685..33f194424bc 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx10v1.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx10v1.PlatformNotSupported.cs @@ -8,3185 +8,3200 @@ namespace System.Runtime.Intrinsics.X86 { - /// This class provides access to X86 Avx10.1 hardware instructions via intrinsics + /// Provides access to X86 Avx10.1 hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Avx10v1 : Avx2 { internal Avx10v1() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } /// - /// __m128i _mm_abs_epi64 (__m128i a) - /// VPABSQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_abs_epi64 (__m128i a) + /// VPABSQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 Abs(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_abs_epi64 (__m128i a) - /// VPABSQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_abs_epi64 (__m128i a) + /// VPABSQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 Abs(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_add_round_sd (__m128d a, __m128d b, int rounding) - /// VADDSD xmm1, xmm2, xmm3 {er} + /// __m128d _mm_add_round_sd (__m128d a, __m128d b, int rounding) + /// VADDSD xmm1, xmm2, xmm3 {er} /// public static Vector128 AddScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_add_round_ss (__m128 a, __m128 b, int rounding) - /// VADDSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_add_round_ss (__m128 a, __m128 b, int rounding) + /// VADDSS xmm1, xmm2, xmm3 {er} /// public static Vector128 AddScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_alignr_epi32 (__m128i a, __m128i b, const int count) - /// VALIGND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128i _mm_alignr_epi32 (__m128i a, __m128i b, const int count) + /// VALIGND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 AlignRight32(Vector128 left, Vector128 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_alignr_epi32 (__m128i a, __m128i b, const int count) - /// VALIGND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128i _mm_alignr_epi32 (__m128i a, __m128i b, const int count) + /// VALIGND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 AlignRight32(Vector128 left, Vector128 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_alignr_epi32 (__m256i a, __m256i b, const int count) - /// VALIGND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256i _mm256_alignr_epi32 (__m256i a, __m256i b, const int count) + /// VALIGND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 AlignRight32(Vector256 left, Vector256 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_alignr_epi32 (__m256i a, __m256i b, const int count) - /// VALIGND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256i _mm256_alignr_epi32 (__m256i a, __m256i b, const int count) + /// VALIGND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 AlignRight32(Vector256 left, Vector256 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_alignr_epi64 (__m128i a, __m128i b, const int count) - /// VALIGNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128i _mm_alignr_epi64 (__m128i a, __m128i b, const int count) + /// VALIGNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 AlignRight64(Vector128 left, Vector128 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_alignr_epi64 (__m128i a, __m128i b, const int count) - /// VALIGNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128i _mm_alignr_epi64 (__m128i a, __m128i b, const int count) + /// VALIGNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 AlignRight64(Vector128 left, Vector128 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_alignr_epi64 (__m256i a, __m256i b, const int count) - /// VALIGNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256i _mm256_alignr_epi64 (__m256i a, __m256i b, const int count) + /// VALIGNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 AlignRight64(Vector256 left, Vector256 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_alignr_epi64 (__m256i a, __m256i b, const int count) - /// VALIGNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256i _mm256_alignr_epi64 (__m256i a, __m256i b, const int count) + /// VALIGNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 AlignRight64(Vector256 left, Vector256 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_broadcast_i32x2 (__m128i a) - /// VBROADCASTI32x2 xmm1 {k1}{z}, xmm2/m64 + /// __m128i _mm_broadcast_i32x2 (__m128i a) + /// VBROADCASTI32x2 xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 BroadcastPairScalarToVector128(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_broadcast_i32x2 (__m128i a) - /// VBROADCASTI32x2 xmm1 {k1}{z}, xmm2/m64 + /// __m128i _mm_broadcast_i32x2 (__m128i a) + /// VBROADCASTI32x2 xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 BroadcastPairScalarToVector128(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_broadcast_f32x2 (__m128 a) - /// VBROADCASTF32x2 ymm1 {k1}{z}, xmm2/m64 + /// __m256 _mm256_broadcast_f32x2 (__m128 a) + /// VBROADCASTF32x2 ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 BroadcastPairScalarToVector256(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcast_i32x2 (__m128i a) - /// VBROADCASTI32x2 ymm1 {k1}{z}, xmm2/m64 + /// __m256i _mm256_broadcast_i32x2 (__m128i a) + /// VBROADCASTI32x2 ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 BroadcastPairScalarToVector256(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcast_i32x2 (__m128i a) - /// VBROADCASTI32x2 ymm1 {k1}{z}, xmm2/m64 + /// __m256i _mm256_broadcast_i32x2 (__m128i a) + /// VBROADCASTI32x2 ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 BroadcastPairScalarToVector256(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpgt_epu8 (__m128i a, __m128i b) - /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(6) + /// __m128i _mm_cmpgt_epu8 (__m128i a, __m128i b) + /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(6) /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpgt_epu32 (__m128i a, __m128i b) - /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(6) + /// __m128i _mm_cmpgt_epu32 (__m128i a, __m128i b) + /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(6) /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpgt_epu64 (__m128i a, __m128i b) - /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(6) + /// __m128i _mm_cmpgt_epu64 (__m128i a, __m128i b) + /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(6) /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpgt_epu16 (__m128i a, __m128i b) - /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(6) + /// __m128i _mm_cmpgt_epu16 (__m128i a, __m128i b) + /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(6) /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpgt_epu8 (__m256i a, __m256i b) - /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(6) + /// __m256i _mm256_cmpgt_epu8 (__m256i a, __m256i b) + /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(6) /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpgt_epu32 (__m256i a, __m256i b) - /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(6) + /// __m256i _mm256_cmpgt_epu32 (__m256i a, __m256i b) + /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(6) /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpgt_epu64 (__m256i a, __m256i b) - /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(6) + /// __m256i _mm256_cmpgt_epu64 (__m256i a, __m256i b) + /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(6) /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpgt_epu16 (__m256i a, __m256i b) - /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(6) + /// __m256i _mm256_cmpgt_epu16 (__m256i a, __m256i b) + /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(6) /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpge_epu8 (__m128i a, __m128i b) - /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(5) + /// __m128i _mm_cmpge_epu8 (__m128i a, __m128i b) + /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpge_epi32 (__m128i a, __m128i b) - /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(5) + /// __m128i _mm_cmpge_epi32 (__m128i a, __m128i b) + /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpge_epi64 (__m128i a, __m128i b) - /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(5) + /// __m128i _mm_cmpge_epi64 (__m128i a, __m128i b) + /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpge_epi8 (__m128i a, __m128i b) - /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(5) + /// __m128i _mm_cmpge_epi8 (__m128i a, __m128i b) + /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpge_epi16 (__m128i a, __m128i b) - /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(5) + /// __m128i _mm_cmpge_epi16 (__m128i a, __m128i b) + /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpge_epu32 (__m128i a, __m128i b) - /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(5) + /// __m128i _mm_cmpge_epu32 (__m128i a, __m128i b) + /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpge_epu64 (__m128i a, __m128i b) - /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(5) + /// __m128i _mm_cmpge_epu64 (__m128i a, __m128i b) + /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpge_epu16 (__m128i a, __m128i b) - /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(5) + /// __m128i _mm_cmpge_epu16 (__m128i a, __m128i b) + /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpge_epu8 (__m256i a, __m256i b) - /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(5) + /// __m256i _mm256_cmpge_epu8 (__m256i a, __m256i b) + /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpge_epi32 (__m256i a, __m256i b) - /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(5) + /// __m256i _mm256_cmpge_epi32 (__m256i a, __m256i b) + /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpge_epi64 (__m256i a, __m256i b) - /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(5) + /// __m256i _mm256_cmpge_epi64 (__m256i a, __m256i b) + /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpge_epi8 (__m256i a, __m256i b) - /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(5) + /// __m256i _mm256_cmpge_epi8 (__m256i a, __m256i b) + /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpge_epi16 (__m256i a, __m256i b) - /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(5) + /// __m256i _mm256_cmpge_epi16 (__m256i a, __m256i b) + /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpge_epu32 (__m256i a, __m256i b) - /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(5) + /// __m256i _mm256_cmpge_epu32 (__m256i a, __m256i b) + /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpge_epu64 (__m256i a, __m256i b) - /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(5) + /// __m256i _mm256_cmpge_epu64 (__m256i a, __m256i b) + /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpge_epu16 (__m256i a, __m256i b) - /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(5) + /// __m256i _mm256_cmpge_epu16 (__m256i a, __m256i b) + /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmplt_epi32 (__m128i a, __m128i b) - /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(1) + /// __m128i _mm_cmplt_epi32 (__m128i a, __m128i b) + /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(1) /// public static new Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmplt_epi8 (__m128i a, __m128i b) - /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(1) + /// __m128i _mm_cmplt_epi8 (__m128i a, __m128i b) + /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(1) /// public static new Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmplt_epi16 (__m128i a, __m128i b) - /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(1) + /// __m128i _mm_cmplt_epi16 (__m128i a, __m128i b) + /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(1) /// public static new Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmplt_epu8 (__m128i a, __m128i b) - /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(1) + /// __m128i _mm_cmplt_epu8 (__m128i a, __m128i b) + /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmplt_epi64 (__m128i a, __m128i b) - /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(1) + /// __m128i _mm_cmplt_epi64 (__m128i a, __m128i b) + /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmplt_epu32 (__m128i a, __m128i b) - /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(1) + /// __m128i _mm_cmplt_epu32 (__m128i a, __m128i b) + /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmplt_epu64 (__m128i a, __m128i b) - /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(1) + /// __m128i _mm_cmplt_epu64 (__m128i a, __m128i b) + /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmplt_epu16 (__m128i a, __m128i b) - /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(1) + /// __m128i _mm_cmplt_epu16 (__m128i a, __m128i b) + /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmplt_epu8 (__m256i a, __m256i b) - /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(1) + /// __m256i _mm256_cmplt_epu8 (__m256i a, __m256i b) + /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmplt_epi32 (__m256i a, __m256i b) - /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(1) + /// __m256i _mm256_cmplt_epi32 (__m256i a, __m256i b) + /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmplt_epi64 (__m256i a, __m256i b) - /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(1) + /// __m256i _mm256_cmplt_epi64 (__m256i a, __m256i b) + /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmplt_epi8 (__m256i a, __m256i b) - /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(1) + /// __m256i _mm256_cmplt_epi8 (__m256i a, __m256i b) + /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmplt_epi16 (__m256i a, __m256i b) - /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(1) + /// __m256i _mm256_cmplt_epi16 (__m256i a, __m256i b) + /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmplt_epu32 (__m256i a, __m256i b) - /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(1) + /// __m256i _mm256_cmplt_epu32 (__m256i a, __m256i b) + /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmplt_epu64 (__m256i a, __m256i b) - /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(1) + /// __m256i _mm256_cmplt_epu64 (__m256i a, __m256i b) + /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmplt_epu16 (__m256i a, __m256i b) - /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(1) + /// __m256i _mm256_cmplt_epu16 (__m256i a, __m256i b) + /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmple_epu8 (__m128i a, __m128i b) - /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(2) + /// __m128i _mm_cmple_epu8 (__m128i a, __m128i b) + /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmple_epi32 (__m128i a, __m128i b) - /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(2) + /// __m128i _mm_cmple_epi32 (__m128i a, __m128i b) + /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmple_epi64 (__m128i a, __m128i b) - /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(2) + /// __m128i _mm_cmple_epi64 (__m128i a, __m128i b) + /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmple_epi8 (__m128i a, __m128i b) - /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(2) + /// __m128i _mm_cmple_epi8 (__m128i a, __m128i b) + /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmple_epi16 (__m128i a, __m128i b) - /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(2) + /// __m128i _mm_cmple_epi16 (__m128i a, __m128i b) + /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmple_epu32 (__m128i a, __m128i b) - /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(2) + /// __m128i _mm_cmple_epu32 (__m128i a, __m128i b) + /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmple_epu64 (__m128i a, __m128i b) - /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(2) + /// __m128i _mm_cmple_epu64 (__m128i a, __m128i b) + /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmple_epu16 (__m128i a, __m128i b) - /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(2) + /// __m128i _mm_cmple_epu16 (__m128i a, __m128i b) + /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmple_epu8 (__m256i a, __m256i b) - /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(2) + /// __m256i _mm256_cmple_epu8 (__m256i a, __m256i b) + /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmple_epi32 (__m256i a, __m256i b) - /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(2) + /// __m256i _mm256_cmple_epi32 (__m256i a, __m256i b) + /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmple_epi64 (__m256i a, __m256i b) - /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(2) + /// __m256i _mm256_cmple_epi64 (__m256i a, __m256i b) + /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmple_epi8 (__m256i a, __m256i b) - /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(2) + /// __m256i _mm256_cmple_epi8 (__m256i a, __m256i b) + /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmple_epi16 (__m256i a, __m256i b) - /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(2) + /// __m256i _mm256_cmple_epi16 (__m256i a, __m256i b) + /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmple_epu32 (__m256i a, __m256i b) - /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(2) + /// __m256i _mm256_cmple_epu32 (__m256i a, __m256i b) + /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmple_epu64 (__m256i a, __m256i b) - /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(2) + /// __m256i _mm256_cmple_epu64 (__m256i a, __m256i b) + /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmple_epu16 (__m256i a, __m256i b) - /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(2) + /// __m256i _mm256_cmple_epu16 (__m256i a, __m256i b) + /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpne_epu8 (__m128i a, __m128i b) - /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(4) + /// __m128i _mm_cmpne_epu8 (__m128i a, __m128i b) + /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpne_epi32 (__m128i a, __m128i b) - /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(4) + /// __m128i _mm_cmpne_epi32 (__m128i a, __m128i b) + /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpne_epi64 (__m128i a, __m128i b) - /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(4) + /// __m128i _mm_cmpne_epi64 (__m128i a, __m128i b) + /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpne_epi8 (__m128i a, __m128i b) - /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(4) + /// __m128i _mm_cmpne_epi8 (__m128i a, __m128i b) + /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpne_epi16 (__m128i a, __m128i b) - /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(4) + /// __m128i _mm_cmpne_epi16 (__m128i a, __m128i b) + /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpne_epu32 (__m128i a, __m128i b) - /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(4) + /// __m128i _mm_cmpne_epu32 (__m128i a, __m128i b) + /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpne_epu64 (__m128i a, __m128i b) - /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(4) + /// __m128i _mm_cmpne_epu64 (__m128i a, __m128i b) + /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpne_epu16 (__m128i a, __m128i b) - /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(4) + /// __m128i _mm_cmpne_epu16 (__m128i a, __m128i b) + /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpne_epu8 (__m256i a, __m256i b) - /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(4) + /// __m256i _mm256_cmpne_epu8 (__m256i a, __m256i b) + /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpne_epi32 (__m256i a, __m256i b) - /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(4) + /// __m256i _mm256_cmpne_epi32 (__m256i a, __m256i b) + /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpne_epi64 (__m256i a, __m256i b) - /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(4) + /// __m256i _mm256_cmpne_epi64 (__m256i a, __m256i b) + /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpne_epi8 (__m256i a, __m256i b) - /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(4) + /// __m256i _mm256_cmpne_epi8 (__m256i a, __m256i b) + /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpne_epi16 (__m256i a, __m256i b) - /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(4) + /// __m256i _mm256_cmpne_epi16 (__m256i a, __m256i b) + /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpne_epu32 (__m256i a, __m256i b) - /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(4) + /// __m256i _mm256_cmpne_epu32 (__m256i a, __m256i b) + /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpne_epu64 (__m256i a, __m256i b) - /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(4) + /// __m256i _mm256_cmpne_epu64 (__m256i a, __m256i b) + /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpne_epu16 (__m256i a, __m256i b) - /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(4) + /// __m256i _mm256_cmpne_epu16 (__m256i a, __m256i b) + /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cvtsi32_sd (__m128d a, int b) - /// VCVTUSI2SD xmm1, xmm2, r/m32 + /// __m128d _mm_cvtsi32_sd (__m128d a, int b) + /// VCVTUSI2SD xmm1, xmm2, r/m32 /// public static Vector128 ConvertScalarToVector128Double(Vector128 upper, uint value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cvt_roundi32_ss (__m128 a, int b, int rounding) - /// VCVTSI2SS xmm1, xmm2, r32 {er} + /// __m128 _mm_cvt_roundi32_ss (__m128 a, int b, int rounding) + /// VCVTSI2SS xmm1, xmm2, r32 {er} /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, int value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cvt_roundi32_ss (__m128 a, int b, int rounding) - /// VCVTUSI2SS xmm1, xmm2, r32 {er} + /// __m128 _mm_cvt_roundi32_ss (__m128 a, int b, int rounding) + /// VCVTUSI2SS xmm1, xmm2, r32 {er} /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, uint value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cvtsi32_ss (__m128 a, int b) - /// VCVTUSI2SS xmm1, xmm2, r/m32 + /// __m128 _mm_cvtsi32_ss (__m128 a, int b) + /// VCVTUSI2SS xmm1, xmm2, r/m32 /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, uint value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cvt_roundsd_ss (__m128 a, __m128d b, int rounding) - /// VCVTSD2SS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_cvt_roundsd_ss (__m128 a, __m128d b, int rounding) + /// VCVTSD2SS xmm1, xmm2, xmm3 {er} /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// int _mm_cvt_roundsd_i32 (__m128d a, int rounding) - /// VCVTSD2SI r32, xmm1 {er} + /// int _mm_cvt_roundsd_i32 (__m128d a, int rounding) + /// VCVTSD2SI r32, xmm1 {er} /// public static int ConvertToInt32(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// int _mm_cvt_roundss_i32 (__m128 a, int rounding) - /// VCVTSS2SIK r32, xmm1 {er} + /// int _mm_cvt_roundss_i32 (__m128 a, int rounding) + /// VCVTSS2SIK r32, xmm1 {er} /// public static int ConvertToInt32(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// unsigned int _mm_cvt_roundsd_u32 (__m128d a, int rounding) - /// VCVTSD2USI r32, xmm1 {er} + /// unsigned int _mm_cvt_roundsd_u32 (__m128d a, int rounding) + /// VCVTSD2USI r32, xmm1 {er} /// public static uint ConvertToUInt32(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// unsigned int _mm_cvtsd_u32 (__m128d a) - /// VCVTSD2USI r32, xmm1/m64{er} + /// unsigned int _mm_cvtsd_u32 (__m128d a) + /// VCVTSD2USI r32, xmm1/m64{er} /// public static uint ConvertToUInt32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// unsigned int _mm_cvt_roundss_u32 (__m128 a, int rounding) - /// VCVTSS2USI r32, xmm1 {er} + /// unsigned int _mm_cvt_roundss_u32 (__m128 a, int rounding) + /// VCVTSS2USI r32, xmm1 {er} /// public static uint ConvertToUInt32(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// unsigned int _mm_cvtss_u32 (__m128 a) - /// VCVTSS2USI r32, xmm1/m32{er} + /// unsigned int _mm_cvtss_u32 (__m128 a) + /// VCVTSS2USI r32, xmm1/m32{er} /// public static uint ConvertToUInt32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// unsigned int _mm_cvttsd_u32 (__m128d a) - /// VCVTTSD2USI r32, xmm1/m64{er} + /// unsigned int _mm_cvttsd_u32 (__m128d a) + /// VCVTTSD2USI r32, xmm1/m64{er} /// public static uint ConvertToUInt32WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// unsigned int _mm_cvttss_u32 (__m128 a) - /// VCVTTSS2USI r32, xmm1/m32{er} + /// unsigned int _mm_cvttss_u32 (__m128 a) + /// VCVTTSS2USI r32, xmm1/m32{er} /// public static uint ConvertToUInt32WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi32_epi8 (__m128i a) - /// VPMOVDB xmm1/m32 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi32_epi8 (__m128i a) + /// VPMOVDB xmm1/m32 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Byte(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi64_epi8 (__m128i a) - /// VPMOVQB xmm1/m16 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi8 (__m128i a) + /// VPMOVQB xmm1/m16 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Byte(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi16_epi8 (__m128i a) - /// VPMOVWB xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi16_epi8 (__m128i a) + /// VPMOVWB xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Byte(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi32_epi8 (__m128i a) - /// VPMOVDB xmm1/m32 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi32_epi8 (__m128i a) + /// VPMOVDB xmm1/m32 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Byte(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi64_epi8 (__m128i a) - /// VPMOVQB xmm1/m16 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi8 (__m128i a) + /// VPMOVQB xmm1/m16 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Byte(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi16_epi8 (__m128i a) - /// VPMOVWB xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi16_epi8 (__m128i a) + /// VPMOVWB xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Byte(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi32_epi8 (__m256i a) - /// VPMOVDB xmm1/m64 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi32_epi8 (__m256i a) + /// VPMOVDB xmm1/m64 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Byte(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi64_epi8 (__m256i a) - /// VPMOVQB xmm1/m32 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi8 (__m256i a) + /// VPMOVQB xmm1/m32 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Byte(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi16_epi8 (__m256i a) - /// VPMOVWB xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi16_epi8 (__m256i a) + /// VPMOVWB xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Byte(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi32_epi8 (__m256i a) - /// VPMOVDB xmm1/m64 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi32_epi8 (__m256i a) + /// VPMOVDB xmm1/m64 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Byte(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi64_epi8 (__m256i a) - /// VPMOVQB xmm1/m32 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi8 (__m256i a) + /// VPMOVQB xmm1/m32 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Byte(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi16_epi8 (__m256i a) - /// VPMOVWB xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi16_epi8 (__m256i a) + /// VPMOVWB xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Byte(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtusepi32_epi8 (__m128i a) - /// VPMOVUSDB xmm1/m32 {k1}{z}, xmm2 + /// __m128i _mm_cvtusepi32_epi8 (__m128i a) + /// VPMOVUSDB xmm1/m32 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtusepi64_epi8 (__m128i a) - /// VPMOVUSQB xmm1/m16 {k1}{z}, xmm2 + /// __m128i _mm_cvtusepi64_epi8 (__m128i a) + /// VPMOVUSQB xmm1/m16 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtusepi16_epi8 (__m128i a) - /// VPMOVUWB xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtusepi16_epi8 (__m128i a) + /// VPMOVUWB xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtusepi32_epi8 (__m256i a) - /// VPMOVUSDB xmm1/m64 {k1}{z}, ymm2 + /// __m128i _mm256_cvtusepi32_epi8 (__m256i a) + /// VPMOVUSDB xmm1/m64 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtusepi64_epi8 (__m256i a) - /// VPMOVUSQB xmm1/m32 {k1}{z}, ymm2 + /// __m128i _mm256_cvtusepi64_epi8 (__m256i a) + /// VPMOVUSQB xmm1/m32 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtusepi16_epi8 (__m256i a) - /// VPMOVUWB xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtusepi16_epi8 (__m256i a) + /// VPMOVUWB xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cvtepi64_pd (__m128i a) - /// VCVTQQ2PD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_cvtepi64_pd (__m128i a) + /// VCVTQQ2PD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Double(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cvtepu32_pd (__m128i a) - /// VCVTUDQ2PD xmm1 {k1}{z}, xmm2/m64/m32bcst + /// __m128d _mm_cvtepu32_pd (__m128i a) + /// VCVTUDQ2PD xmm1 {k1}{z}, xmm2/m64/m32bcst /// public static Vector128 ConvertToVector128Double(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cvtepu64_pd (__m128i a) - /// VCVTUQQ2PD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_cvtepu64_pd (__m128i a) + /// VCVTUQQ2PD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Double(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi32_epi16 (__m128i a) - /// VPMOVDW xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi32_epi16 (__m128i a) + /// VPMOVDW xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi64_epi16 (__m128i a) - /// VPMOVQW xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi64_epi16 (__m128i a) + /// VPMOVQW xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi32_epi16 (__m128i a) - /// VPMOVDW xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi32_epi16 (__m128i a) + /// VPMOVDW xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi64_epi16 (__m128i a) - /// VPMOVQW xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi64_epi16 (__m128i a) + /// VPMOVQW xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi32_epi16 (__m256i a) - /// VPMOVDW xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi32_epi16 (__m256i a) + /// VPMOVDW xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi64_epi16 (__m256i a) - /// VPMOVQW xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi64_epi16 (__m256i a) + /// VPMOVQW xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi32_epi16 (__m256i a) - /// VPMOVDW xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi32_epi16 (__m256i a) + /// VPMOVDW xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi64_epi16 (__m256i a) - /// VPMOVQW xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi64_epi16 (__m256i a) + /// VPMOVQW xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtsepi32_epi16 (__m128i a) - /// VPMOVSDW xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm_cvtsepi32_epi16 (__m128i a) + /// VPMOVSDW xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16WithSaturation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtsepi64_epi16 (__m128i a) - /// VPMOVSQW xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm_cvtsepi64_epi16 (__m128i a) + /// VPMOVSQW xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16WithSaturation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtsepi32_epi16 (__m256i a) - /// VPMOVSDW xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm256_cvtsepi32_epi16 (__m256i a) + /// VPMOVSDW xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16WithSaturation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtsepi64_epi16 (__m256i a) - /// VPMOVSQW xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm256_cvtsepi64_epi16 (__m256i a) + /// VPMOVSQW xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16WithSaturation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi64_epi32 (__m128i a) - /// VPMOVQD xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi32 (__m128i a) + /// VPMOVQD xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Int32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi64_epi32 (__m128i a) - /// VPMOVQD xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi32 (__m128i a) + /// VPMOVQD xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Int32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi64_epi32 (__m256i a) - /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi32 (__m256i a) + /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Int32(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi64_epi32 (__m256i a) - /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi32 (__m256i a) + /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Int32(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtsepi64_epi32 (__m128i a) - /// VPMOVSQD xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtsepi64_epi32 (__m128i a) + /// VPMOVSQD xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Int32WithSaturation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtsepi64_epi32 (__m256i a) - /// VPMOVSQD xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtsepi64_epi32 (__m256i a) + /// VPMOVSQD xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Int32WithSaturation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtpd_epi64 (__m128d a) - /// VCVTPD2QQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvtpd_epi64 (__m128d a) + /// VCVTPD2QQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Int64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtps_epi64 (__m128 a) - /// VCVTPS2QQ xmm1 {k1}{z}, xmm2/m64/m32bcst + /// __m128i _mm_cvtps_epi64 (__m128 a) + /// VCVTPS2QQ xmm1 {k1}{z}, xmm2/m64/m32bcst /// public static Vector128 ConvertToVector128Int64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvttpd_epi64 (__m128d a) - /// VCVTTPD2QQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvttpd_epi64 (__m128d a) + /// VCVTTPD2QQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Int64WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvttps_epi64 (__m128 a) - /// VCVTTPS2QQ xmm1 {k1}{z}, xmm2/m64/m32bcst + /// __m128i _mm_cvttps_epi64 (__m128 a) + /// VCVTTPS2QQ xmm1 {k1}{z}, xmm2/m64/m32bcst /// public static Vector128 ConvertToVector128Int64WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi32_epi8 (__m128i a) - /// VPMOVDB xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi32_epi8 (__m128i a) + /// VPMOVDB xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi64_epi8 (__m128i a) - /// VPMOVQB xmm1/m16 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi64_epi8 (__m128i a) + /// VPMOVQB xmm1/m16 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi16_epi8 (__m128i a) - /// VPMOVWB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi16_epi8 (__m128i a) + /// VPMOVWB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi32_epi8 (__m128i a) - /// VPMOVDB xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi32_epi8 (__m128i a) + /// VPMOVDB xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi64_epi8 (__m128i a) - /// VPMOVQB xmm1/m16 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi64_epi8 (__m128i a) + /// VPMOVQB xmm1/m16 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi16_epi8 (__m128i a) - /// VPMOVWB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi16_epi8 (__m128i a) + /// VPMOVWB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi32_epi8 (__m256i a) - /// VPMOVDB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi32_epi8 (__m256i a) + /// VPMOVDB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi64_epi8 (__m256i a) - /// VPMOVQB xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi64_epi8 (__m256i a) + /// VPMOVQB xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi16_epi8 (__m256i a) - /// VPMOVWB xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi16_epi8 (__m256i a) + /// VPMOVWB xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi32_epi8 (__m256i a) - /// VPMOVDB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi32_epi8 (__m256i a) + /// VPMOVDB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi64_epi8 (__m256i a) - /// VPMOVQB xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi64_epi8 (__m256i a) + /// VPMOVQB xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi16_epi8 (__m256i a) - /// VPMOVWB xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi16_epi8 (__m256i a) + /// VPMOVWB xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtsepi32_epi8 (__m128i a) - /// VPMOVSDB xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm_cvtsepi32_epi8 (__m128i a) + /// VPMOVSDB xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtsepi64_epi8 (__m128i a) - /// VPMOVSQB xmm1/m16 {k1}{z}, zmm2 + /// __m128i _mm_cvtsepi64_epi8 (__m128i a) + /// VPMOVSQB xmm1/m16 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtsepi16_epi8 (__m128i a) - /// VPMOVSWB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm_cvtsepi16_epi8 (__m128i a) + /// VPMOVSWB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtsepi32_epi8 (__m256i a) - /// VPMOVSDB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm256_cvtsepi32_epi8 (__m256i a) + /// VPMOVSDB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtsepi64_epi8 (__m256i a) - /// VPMOVSQB xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm256_cvtsepi64_epi8 (__m256i a) + /// VPMOVSQB xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtsepi16_epi8 (__m256i a) - /// VPMOVSWB xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm256_cvtsepi16_epi8 (__m256i a) + /// VPMOVSWB xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cvtepi64_ps (__m128i a) - /// VCVTQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128 _mm_cvtepi64_ps (__m128i a) + /// VCVTQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Single(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cvtepu32_ps (__m128i a) - /// VCVTUDQ2PS xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128 _mm_cvtepu32_ps (__m128i a) + /// VCVTUDQ2PS xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 ConvertToVector128Single(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cvtepu64_ps (__m128i a) - /// VCVTUQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128 _mm_cvtepu64_ps (__m128i a) + /// VCVTUQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Single(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm256_cvtepi64_ps (__m256i a) - /// VCVTQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcst + /// __m128 _mm256_cvtepi64_ps (__m256i a) + /// VCVTQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector128 ConvertToVector128Single(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm256_cvtepu64_ps (__m256i a) - /// VCVTUQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcst + /// __m128 _mm256_cvtepu64_ps (__m256i a) + /// VCVTUQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector128 ConvertToVector128Single(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi32_epi16 (__m128i a) - /// VPMOVDW xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi32_epi16 (__m128i a) + /// VPMOVDW xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt16(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi64_epi16 (__m128i a) - /// VPMOVQW xmm1/m32 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi16 (__m128i a) + /// VPMOVQW xmm1/m32 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt16(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi32_epi16 (__m128i a) - /// VPMOVDW xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi32_epi16 (__m128i a) + /// VPMOVDW xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt16(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi64_epi16 (__m128i a) - /// VPMOVQW xmm1/m32 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi16 (__m128i a) + /// VPMOVQW xmm1/m32 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt16(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi32_epi16 (__m256i a) - /// VPMOVDW xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi32_epi16 (__m256i a) + /// VPMOVDW xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt16(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi64_epi16 (__m256i a) - /// VPMOVQW xmm1/m64 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi16 (__m256i a) + /// VPMOVQW xmm1/m64 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt16(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi32_epi16 (__m256i a) - /// VPMOVDW xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi32_epi16 (__m256i a) + /// VPMOVDW xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt16(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi64_epi16 (__m256i a) - /// VPMOVQW xmm1/m64 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi16 (__m256i a) + /// VPMOVQW xmm1/m64 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt16(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtusepi32_epi16 (__m128i a) - /// VPMOVUSDW xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtusepi32_epi16 (__m128i a) + /// VPMOVUSDW xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt16WithSaturation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtusepi64_epi16 (__m128i a) - /// VPMOVUSQW xmm1/m32 {k1}{z}, xmm2 + /// __m128i _mm_cvtusepi64_epi16 (__m128i a) + /// VPMOVUSQW xmm1/m32 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt16WithSaturation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtusepi32_epi16 (__m256i a) - /// VPMOVUSDW xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtusepi32_epi16 (__m256i a) + /// VPMOVUSDW xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt16WithSaturation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtusepi64_epi16 (__m256i a) - /// VPMOVUSQW xmm1/m64 {k1}{z}, ymm2 + /// __m128i _mm256_cvtusepi64_epi16 (__m256i a) + /// VPMOVUSQW xmm1/m64 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt16WithSaturation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtpd_epu32 (__m128d a) - /// VCVTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvtpd_epu32 (__m128d a) + /// VCVTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128UInt32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtps_epu32 (__m128 a) - /// VCVTPS2UDQ xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_cvtps_epu32 (__m128 a) + /// VCVTPS2UDQ xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 ConvertToVector128UInt32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi64_epi32 (__m128i a) - /// VPMOVQD xmm1/m128 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi32 (__m128i a) + /// VPMOVQD xmm1/m128 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi64_epi32 (__m128i a) - /// VPMOVQD xmm1/m128 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi32 (__m128i a) + /// VPMOVQD xmm1/m128 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtpd_epu32 (__m256d a) - /// VCVTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcst + /// __m128i _mm256_cvtpd_epu32 (__m256d a) + /// VCVTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector128 ConvertToVector128UInt32(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi64_epi32 (__m256i a) - /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi32 (__m256i a) + /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt32(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi64_epi32 (__m256i a) - /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi32 (__m256i a) + /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt32(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtusepi64_epi32 (__m128i a) - /// VPMOVUSQD xmm1/m128 {k1}{z}, xmm2 + /// __m128i _mm_cvtusepi64_epi32 (__m128i a) + /// VPMOVUSQD xmm1/m128 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt32WithSaturation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtusepi64_epi32 (__m256i a) - /// VPMOVUSQD xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtusepi64_epi32 (__m256i a) + /// VPMOVUSQD xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt32WithSaturation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvttpd_epu32 (__m128d a) - /// VCVTTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvttpd_epu32 (__m128d a) + /// VCVTTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128UInt32WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvttps_epu32 (__m128 a) - /// VCVTTPS2UDQ xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_cvttps_epu32 (__m128 a) + /// VCVTTPS2UDQ xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 ConvertToVector128UInt32WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvttpd_epu32 (__m256d a) - /// VCVTTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcst + /// __m128i _mm256_cvttpd_epu32 (__m256d a) + /// VCVTTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector128 ConvertToVector128UInt32WithTruncation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtpd_epu64 (__m128d a) - /// VCVTPD2UQQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvtpd_epu64 (__m128d a) + /// VCVTPD2UQQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128UInt64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtps_epu64 (__m128 a) - /// VCVTPS2UQQ xmm1 {k1}{z}, xmm2/m64/m32bcst + /// __m128i _mm_cvtps_epu64 (__m128 a) + /// VCVTPS2UQQ xmm1 {k1}{z}, xmm2/m64/m32bcst /// public static Vector128 ConvertToVector128UInt64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvttpd_epu64 (__m128d a) - /// VCVTTPD2UQQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvttpd_epu64 (__m128d a) + /// VCVTTPD2UQQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128UInt64WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvttps_epu64 (__m128 a) - /// VCVTTPS2UQQ xmm1 {k1}{z}, xmm2/m64/m32bcst + /// __m128i _mm_cvttps_epu64 (__m128 a) + /// VCVTTPS2UQQ xmm1 {k1}{z}, xmm2/m64/m32bcst /// public static Vector128 ConvertToVector128UInt64WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm512_cvtepu32_pd (__m128i a) - /// VCVTUDQ2PD ymm1 {k1}{z}, xmm2/m128/m32bcst + /// __m256d _mm512_cvtepu32_pd (__m128i a) + /// VCVTUDQ2PD ymm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector256 ConvertToVector256Double(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_cvtepi64_pd (__m256i a) - /// VCVTQQ2PD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_cvtepi64_pd (__m256i a) + /// VCVTQQ2PD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ConvertToVector256Double(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_cvtepu64_pd (__m256i a) - /// VCVTUQQ2PD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_cvtepu64_pd (__m256i a) + /// VCVTUQQ2PD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ConvertToVector256Double(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvtps_epi64 (__m128 a) - /// VCVTPS2QQ ymm1 {k1}{z}, xmm2/m128/m32bcst + /// __m256i _mm256_cvtps_epi64 (__m128 a) + /// VCVTPS2QQ ymm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector256 ConvertToVector256Int64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvtpd_epi64 (__m256d a) - /// VCVTPD2QQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_cvtpd_epi64 (__m256d a) + /// VCVTPD2QQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ConvertToVector256Int64(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvttps_epi64 (__m128 a) - /// VCVTTPS2QQ ymm1 {k1}{z}, xmm2/m128/m32bcst + /// __m256i _mm256_cvttps_epi64 (__m128 a) + /// VCVTTPS2QQ ymm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector256 ConvertToVector256Int64WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvttpd_epi64 (__m256d a) - /// VCVTTPD2QQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_cvttpd_epi64 (__m256d a) + /// VCVTTPD2QQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ConvertToVector256Int64WithTruncation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_cvtepu32_ps (__m256i a) - /// VCVTUDQ2PS ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256 _mm256_cvtepu32_ps (__m256i a) + /// VCVTUDQ2PS ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 ConvertToVector256Single(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvtps_epu32 (__m256 a) - /// VCVTPS2UDQ ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_cvtps_epu32 (__m256 a) + /// VCVTPS2UDQ ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 ConvertToVector256UInt32(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvttps_epu32 (__m256 a) - /// VCVTTPS2UDQ ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_cvttps_epu32 (__m256 a) + /// VCVTTPS2UDQ ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 ConvertToVector256UInt32WithTruncation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvtps_epu64 (__m128 a) - /// VCVTPS2UQQ ymm1 {k1}{z}, xmm2/m128/m32bcst + /// __m256i _mm256_cvtps_epu64 (__m128 a) + /// VCVTPS2UQQ ymm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector256 ConvertToVector256UInt64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvtpd_epu64 (__m256d a) - /// VCVTPD2UQQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_cvtpd_epu64 (__m256d a) + /// VCVTPD2UQQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ConvertToVector256UInt64(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvttps_epu64 (__m128 a) - /// VCVTTPS2UQQ ymm1 {k1}{z}, xmm2/m128/m32bcst + /// __m256i _mm256_cvttps_epu64 (__m128 a) + /// VCVTTPS2UQQ ymm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector256 ConvertToVector256UInt64WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvttpd_epu64 (__m256d a) - /// VCVTTPD2UQQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_cvttpd_epu64 (__m256d a) + /// VCVTTPD2UQQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ConvertToVector256UInt64WithTruncation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_conflict_epi32 (__m128i a) - /// VPCONFLICTD xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_conflict_epi32 (__m128i a) + /// VPCONFLICTD xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 DetectConflicts(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_conflict_epi64 (__m128i a) - /// VPCONFLICTQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_conflict_epi64 (__m128i a) + /// VPCONFLICTQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 DetectConflicts(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_conflict_epi32 (__m128i a) - /// VPCONFLICTD xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_conflict_epi32 (__m128i a) + /// VPCONFLICTD xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 DetectConflicts(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_conflict_epi64 (__m128i a) - /// VPCONFLICTQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_conflict_epi64 (__m128i a) + /// VPCONFLICTQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 DetectConflicts(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_conflict_epi32 (__m256i a) - /// VPCONFLICTD ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_conflict_epi32 (__m256i a) + /// VPCONFLICTD ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 DetectConflicts(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_conflict_epi64 (__m256i a) - /// VPCONFLICTQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_conflict_epi64 (__m256i a) + /// VPCONFLICTQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 DetectConflicts(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_conflict_epi32 (__m256i a) - /// VPCONFLICTD ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_conflict_epi32 (__m256i a) + /// VPCONFLICTD ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 DetectConflicts(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_conflict_epi64 (__m256i a) - /// VPCONFLICTQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_conflict_epi64 (__m256i a) + /// VPCONFLICTQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 DetectConflicts(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_div_round_sd (__m128d a, __m128d b, int rounding) - /// VDIVSS xmm1, xmm2, xmm3 {er} + /// __m128d _mm_div_round_sd (__m128d a, __m128d b, int rounding) + /// VDIVSS xmm1, xmm2, xmm3 {er} /// public static Vector128 DivideScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_div_round_ss (__m128 a, __m128 b, int rounding) - /// VDIVSD xmm1, xmm2, xmm3 {er} + /// __m128 _mm_div_round_ss (__m128 a, __m128 b, int rounding) + /// VDIVSD xmm1, xmm2, xmm3 {er} /// public static Vector128 DivideScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_fixupimm_pd(__m128d a, __m128d b, __m128i tbl, int imm); - /// VFIXUPIMMPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128d _mm_fixupimm_pd(__m128d a, __m128d b, __m128i tbl, int imm); + /// VFIXUPIMMPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 Fixup(Vector128 left, Vector128 right, Vector128 table, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_fixupimm_ps(__m128 a, __m128 b, __m128i tbl, int imm); - /// VFIXUPIMMPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128 _mm_fixupimm_ps(__m128 a, __m128 b, __m128i tbl, int imm); + /// VFIXUPIMMPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 Fixup(Vector128 left, Vector128 right, Vector128 table, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_fixupimm_pd(__m256d a, __m256d b, __m256i tbl, int imm); - /// VFIXUPIMMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256d _mm256_fixupimm_pd(__m256d a, __m256d b, __m256i tbl, int imm); + /// VFIXUPIMMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 Fixup(Vector256 left, Vector256 right, Vector256 table, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_fixupimm_ps(__m256 a, __m256 b, __m256i tbl, int imm); - /// VFIXUPIMMPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256 _mm256_fixupimm_ps(__m256 a, __m256 b, __m256i tbl, int imm); + /// VFIXUPIMMPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 Fixup(Vector256 left, Vector256 right, Vector256 table, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_fixupimm_sd(__m128d a, __m128d b, __m128i tbl, int imm); - /// VFIXUPIMMSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 + /// __m128d _mm_fixupimm_sd(__m128d a, __m128d b, __m128i tbl, int imm); + /// VFIXUPIMMSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 /// public static Vector128 FixupScalar(Vector128 left, Vector128 right, Vector128 table, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_fixupimm_ss(__m128 a, __m128 b, __m128i tbl, int imm); - /// VFIXUPIMMSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 + /// __m128 _mm_fixupimm_ss(__m128 a, __m128 b, __m128i tbl, int imm); + /// VFIXUPIMMSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 /// public static Vector128 FixupScalar(Vector128 left, Vector128 right, Vector128 table, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_fnmadd_round_sd (__m128d a, __m128d b, __m128d c, int r) - /// VFNMADDSD xmm1, xmm2, xmm3 {er} + /// __m128d _mm_fnmadd_round_sd (__m128d a, __m128d b, __m128d c, int r) + /// VFNMADDSD xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplyAddNegatedScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_fnmadd_round_ss (__m128 a, __m128 b, __m128 c, int r) - /// VFNMADDSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_fnmadd_round_ss (__m128 a, __m128 b, __m128 c, int r) + /// VFNMADDSS xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplyAddNegatedScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_fmadd_round_sd (__m128d a, __m128d b, __m128d c, int r) - /// VFMADDSD xmm1, xmm2, xmm3 {er} + /// __m128d _mm_fmadd_round_sd (__m128d a, __m128d b, __m128d c, int r) + /// VFMADDSD xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplyAddScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_fmadd_round_ss (__m128 a, __m128 b, __m128 c, int r) - /// VFMADDSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_fmadd_round_ss (__m128 a, __m128 b, __m128 c, int r) + /// VFMADDSS xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplyAddScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_fnmsub_round_sd (__m128d a, __m128d b, __m128d c, int r) - /// VFNMSUBSS xmm1, xmm2, xmm3 {er} + /// __m128d _mm_fnmsub_round_sd (__m128d a, __m128d b, __m128d c, int r) + /// VFNMSUBSS xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplySubtractNegatedScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_fnmsub_round_ss (__m128 a, __m128 b, __m128 c, int r) - /// VFNMSUBSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_fnmsub_round_ss (__m128 a, __m128 b, __m128 c, int r) + /// VFNMSUBSS xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplySubtractNegatedScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_fmsub_round_sd (__m128d a, __m128d b, __m128d c, int r) - /// VFMSUBSS xmm1, xmm2, xmm3 {er} + /// __m128d _mm_fmsub_round_sd (__m128d a, __m128d b, __m128d c, int r) + /// VFMSUBSS xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplySubtractScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_fmsub_round_ss (__m128 a, __m128 b, __m128 c, int r) - /// VFMSUBSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_fmsub_round_ss (__m128 a, __m128 b, __m128 c, int r) + /// VFMSUBSS xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplySubtractScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_getexp_pd (__m128d a) - /// VGETEXPPD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_getexp_pd (__m128d a) + /// VGETEXPPD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 GetExponent(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_getexp_ps (__m128 a) - /// VGETEXPPS xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128 _mm_getexp_ps (__m128 a) + /// VGETEXPPS xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 GetExponent(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_getexp_pd (__m256d a) - /// VGETEXPPD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_getexp_pd (__m256d a) + /// VGETEXPPD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 GetExponent(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_getexp_ps (__m256 a) - /// VGETEXPPS ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256 _mm256_getexp_ps (__m256 a) + /// VGETEXPPS ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 GetExponent(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_getexp_sd (__m128d a, __m128d b) - /// VGETEXPSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128d _mm_getexp_sd (__m128d a, __m128d b) + /// VGETEXPSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 GetExponentScalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_getexp_sd (__m128d a) - /// VGETEXPSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} + /// __m128d _mm_getexp_sd (__m128d a) + /// VGETEXPSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} /// public static Vector128 GetExponentScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_getexp_ss (__m128 a, __m128 b) - /// VGETEXPSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_getexp_ss (__m128 a, __m128 b) + /// VGETEXPSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 GetExponentScalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_getexp_ss (__m128 a) - /// VGETEXPSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} + /// __m128 _mm_getexp_ss (__m128 a) + /// VGETEXPSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} /// public static Vector128 GetExponentScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_getmant_pd (__m128d a) - /// VGETMANTPD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_getmant_pd (__m128d a) + /// VGETMANTPD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 GetMantissa(Vector128 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_getmant_ps (__m128 a) - /// VGETMANTPS xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128 _mm_getmant_ps (__m128 a) + /// VGETMANTPS xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 GetMantissa(Vector128 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_getmant_pd (__m256d a) - /// VGETMANTPD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_getmant_pd (__m256d a) + /// VGETMANTPD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 GetMantissa(Vector256 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_getmant_ps (__m256 a) - /// VGETMANTPS ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256 _mm256_getmant_ps (__m256 a) + /// VGETMANTPS ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 GetMantissa(Vector256 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_getmant_sd (__m128d a, __m128d b) - /// VGETMANTSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128d _mm_getmant_sd (__m128d a, __m128d b) + /// VGETMANTSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 GetMantissaScalar(Vector128 upper, Vector128 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_getmant_sd (__m128d a) - /// VGETMANTSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} + /// __m128d _mm_getmant_sd (__m128d a) + /// VGETMANTSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} /// public static Vector128 GetMantissaScalar(Vector128 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_getmant_ss (__m128 a, __m128 b) - /// VGETMANTSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_getmant_ss (__m128 a, __m128 b) + /// VGETMANTSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 GetMantissaScalar(Vector128 upper, Vector128 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_getmant_ss (__m128 a) - /// VGETMANTSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} + /// __m128 _mm_getmant_ss (__m128 a) + /// VGETMANTSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} /// public static Vector128 GetMantissaScalar(Vector128 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_lzcnt_epi32 (__m128i a) - /// VPLZCNTD xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_lzcnt_epi32 (__m128i a) + /// VPLZCNTD xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 LeadingZeroCount(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_lzcnt_epi64 (__m128i a) - /// VPLZCNTQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_lzcnt_epi64 (__m128i a) + /// VPLZCNTQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 LeadingZeroCount(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_lzcnt_epi32 (__m128i a) - /// VPLZCNTD xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_lzcnt_epi32 (__m128i a) + /// VPLZCNTD xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 LeadingZeroCount(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_lzcnt_epi64 (__m128i a) - /// VPLZCNTQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_lzcnt_epi64 (__m128i a) + /// VPLZCNTQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 LeadingZeroCount(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_lzcnt_epi32 (__m256i a) - /// VPLZCNTD ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_lzcnt_epi32 (__m256i a) + /// VPLZCNTD ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 LeadingZeroCount(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_lzcnt_epi64 (__m256i a) - /// VPLZCNTQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_lzcnt_epi64 (__m256i a) + /// VPLZCNTQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 LeadingZeroCount(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_lzcnt_epi32 (__m256i a) - /// VPLZCNTD ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_lzcnt_epi32 (__m256i a) + /// VPLZCNTD ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 LeadingZeroCount(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_lzcnt_epi64 (__m256i a) - /// VPLZCNTQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_lzcnt_epi64 (__m256i a) + /// VPLZCNTQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 LeadingZeroCount(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_max_epi64 (__m128i a, __m128i b) - /// VPMAXSQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_max_epi64 (__m128i a, __m128i b) + /// VPMAXSQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_max_epu64 (__m128i a, __m128i b) - /// VPMAXUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_max_epu64 (__m128i a, __m128i b) + /// VPMAXUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_max_epi64 (__m256i a, __m256i b) - /// VPMAXSQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_max_epi64 (__m256i a, __m256i b) + /// VPMAXSQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Max(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_max_epu64 (__m256i a, __m256i b) - /// VPMAXUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_max_epu64 (__m256i a, __m256i b) + /// VPMAXUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Max(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_min_epi64 (__m128i a, __m128i b) - /// VPMINSQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_min_epi64 (__m128i a, __m128i b) + /// VPMINSQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_min_epu64 (__m128i a, __m128i b) - /// VPMINUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_min_epu64 (__m128i a, __m128i b) + /// VPMINUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_min_epi64 (__m256i a, __m256i b) - /// VPMINSQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_min_epi64 (__m256i a, __m256i b) + /// VPMINSQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Min(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_min_epu64 (__m256i a, __m256i b) - /// VPMINUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_min_epu64 (__m256i a, __m256i b) + /// VPMINUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Min(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_mullo_epi64 (__m128i a, __m128i b) - /// VPMULLQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_mullo_epi64 (__m128i a, __m128i b) + /// VPMULLQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiplyLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_mullo_epi64 (__m128i a, __m128i b) - /// VPMULLQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_mullo_epi64 (__m128i a, __m128i b) + /// VPMULLQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiplyLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_mullo_epi64 (__m256i a, __m256i b) - /// VPMULLQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_mullo_epi64 (__m256i a, __m256i b) + /// VPMULLQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiplyLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_mullo_epi64 (__m256i a, __m256i b) - /// VPMULLQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_mullo_epi64 (__m256i a, __m256i b) + /// VPMULLQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiplyLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_mul_round_sd (__m128d a, __m128d b, int rounding) - /// VMULSD xmm1, xmm2, xmm3 {er} + /// __m128d _mm_mul_round_sd (__m128d a, __m128d b, int rounding) + /// VMULSD xmm1, xmm2, xmm3 {er} /// public static Vector128 MultiplyScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_mul_round_ss (__m128 a, __m128 b, int rounding) - /// VMULSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_mul_round_ss (__m128 a, __m128 b, int rounding) + /// VMULSS xmm1, xmm2, xmm3 {er} /// public static Vector128 MultiplyScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_multishift_epi64_epi8(__m128i a, __m128i b) - /// VPMULTISHIFTQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_multishift_epi64_epi8(__m128i a, __m128i b) + /// VPMULTISHIFTQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiShift(Vector128 control, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_multishift_epi64_epi8(__m128i a, __m128i b) - /// VPMULTISHIFTQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_multishift_epi64_epi8(__m128i a, __m128i b) + /// VPMULTISHIFTQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiShift(Vector128 control, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_multishift_epi64_epi8(__m256i a, __m256i b) - /// VPMULTISHIFTQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_multishift_epi64_epi8(__m256i a, __m256i b) + /// VPMULTISHIFTQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiShift(Vector256 control, Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_multishift_epi64_epi8(__m256i a, __m256i b) - /// VPMULTISHIFTQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_multishift_epi64_epi8(__m256i a, __m256i b) + /// VPMULTISHIFTQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiShift(Vector256 control, Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutevar16x16_epi16 (__m256i a, __m256i b) - /// VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutevar16x16_epi16 (__m256i a, __m256i b) + /// VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar16x16(Vector256 left, Vector256 control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutevar16x16_epi16 (__m256i a, __m256i b) - /// VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutevar16x16_epi16 (__m256i a, __m256i b) + /// VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar16x16(Vector256 left, Vector256 control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutex2var_epi16 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2W ymm1 {k1}{z}, ymm2, ymm3/m256 - /// VPERMT2W ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutex2var_epi16 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2W ymm1 {k1}{z}, ymm2, ymm3/m256 + /// VPERMT2W ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar16x16x2(Vector256 lower, Vector256 indices, Vector256 upper) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutex2var_epi16 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2W ymm1 {k1}{z}, ymm2, ymm3/m256 - /// VPERMT2W ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutex2var_epi16 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2W ymm1 {k1}{z}, ymm2, ymm3/m256 + /// VPERMT2W ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar16x16x2(Vector256 lower, Vector256 indices, Vector256 upper) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_permutevar64x8_epi8 (__m128i a, __m128i b) - /// VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutevar64x8_epi8 (__m128i a, __m128i b) + /// VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar16x8(Vector128 left, Vector128 control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_permutevar64x8_epi8 (__m128i a, __m128i b) - /// VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutevar64x8_epi8 (__m128i a, __m128i b) + /// VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar16x8(Vector128 left, Vector128 control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_permutex2var_epi8 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2B xmm1 {k1}{z}, xmm2, xmm3/m128 - /// VPERMT2B xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutex2var_epi8 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2B xmm1 {k1}{z}, xmm2, xmm3/m128 + /// VPERMT2B xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar16x8x2(Vector128 lower, Vector128 indices, Vector128 upper) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_permutex2var_epi8 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2B xmm1 {k1}{z}, xmm2, xmm3/m128 - /// VPERMT2B xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutex2var_epi8 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2B xmm1 {k1}{z}, xmm2, xmm3/m128 + /// VPERMT2B xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar16x8x2(Vector128 lower, Vector128 indices, Vector128 upper) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_permutex2var_pd (__m128d a, __m128i idx, __m128i b) - /// VPERMI2PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst - /// VPERMT2PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_permutex2var_pd (__m128d a, __m128i idx, __m128i b) + /// VPERMI2PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// VPERMT2PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 PermuteVar2x64x2(Vector128 lower, Vector128 indices, Vector128 upper) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_permutex2var_epi64 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst - /// VPERMT2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_permutex2var_epi64 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// VPERMT2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 PermuteVar2x64x2(Vector128 lower, Vector128 indices, Vector128 upper) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_permutex2var_epi64 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst - /// VPERMT2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_permutex2var_epi64 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// VPERMT2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 PermuteVar2x64x2(Vector128 lower, Vector128 indices, Vector128 upper) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutevar64x8_epi8 (__m256i a, __m256i b) - /// VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutevar64x8_epi8 (__m256i a, __m256i b) + /// VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar32x8(Vector256 left, Vector256 control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutevar64x8_epi8 (__m256i a, __m256i b) - /// VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutevar64x8_epi8 (__m256i a, __m256i b) + /// VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar32x8(Vector256 left, Vector256 control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutex2var_epi8 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2B ymm1 {k1}{z}, ymm2, ymm3/m256 - /// VPERMT2B ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutex2var_epi8 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2B ymm1 {k1}{z}, ymm2, ymm3/m256 + /// VPERMT2B ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar32x8x2(Vector256 lower, Vector256 indices, Vector256 upper) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutex2var_epi8 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2B ymm1 {k1}{z}, ymm2, ymm3/m256 - /// VPERMT2B ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutex2var_epi8 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2B ymm1 {k1}{z}, ymm2, ymm3/m256 + /// VPERMT2B ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar32x8x2(Vector256 lower, Vector256 indices, Vector256 upper) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_permutex2var_ps (__m128 a, __m128i idx, __m128i b) - /// VPERMI2PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst - /// VPERMT2PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_permutex2var_ps (__m128 a, __m128i idx, __m128i b) + /// VPERMI2PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// VPERMT2PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 PermuteVar4x32x2(Vector128 lower, Vector128 indices, Vector128 upper) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_permutex2var_epi32 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst - /// VPERMT2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_permutex2var_epi32 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// VPERMT2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 PermuteVar4x32x2(Vector128 lower, Vector128 indices, Vector128 upper) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_permutex2var_epi32 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst - /// VPERMT2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_permutex2var_epi32 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// VPERMT2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 PermuteVar4x32x2(Vector128 lower, Vector128 indices, Vector128 upper) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_permute4x64_pd (__m256d a, __m256i b) - /// VPERMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_permute4x64_pd (__m256d a, __m256i b) + /// VPERMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar4x64(Vector256 value, Vector256 control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permute4x64_epi64 (__m256i a, __m256i b) - /// VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_permute4x64_epi64 (__m256i a, __m256i b) + /// VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar4x64(Vector256 value, Vector256 control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permute4x64_pd (__m256d a, __m256i b) - /// VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_permute4x64_pd (__m256d a, __m256i b) + /// VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar4x64(Vector256 value, Vector256 control) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_permutex2var_pd (__m256d a, __m256i idx, __m256i b) - /// VPERMI2PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst - /// VPERMT2PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_permutex2var_pd (__m256d a, __m256i idx, __m256i b) + /// VPERMI2PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// VPERMT2PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar4x64x2(Vector256 lower, Vector256 indices, Vector256 upper) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutex2var_epi64 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst - /// VPERMT2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_permutex2var_epi64 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// VPERMT2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar4x64x2(Vector256 lower, Vector256 indices, Vector256 upper) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutex2var_epi64 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst - /// VPERMT2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_permutex2var_epi64 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// VPERMT2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar4x64x2(Vector256 lower, Vector256 indices, Vector256 upper) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_permutevar8x16_epi16 (__m128i a, __m128i b) - /// VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutevar8x16_epi16 (__m128i a, __m128i b) + /// VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar8x16(Vector128 left, Vector128 control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_permutevar8x16_epi16 (__m128i a, __m128i b) - /// VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutevar8x16_epi16 (__m128i a, __m128i b) + /// VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar8x16(Vector128 left, Vector128 control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_permutex2var_epi16 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2W xmm1 {k1}{z}, xmm2, xmm3/m128 - /// VPERMT2W xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutex2var_epi16 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2W xmm1 {k1}{z}, xmm2, xmm3/m128 + /// VPERMT2W xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar8x16x2(Vector128 lower, Vector128 indices, Vector128 upper) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_permutex2var_epi16 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2W xmm1 {k1}{z}, xmm2, xmm3/m128 - /// VPERMT2W xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutex2var_epi16 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2W xmm1 {k1}{z}, xmm2, xmm3/m128 + /// VPERMT2W xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar8x16x2(Vector128 lower, Vector128 indices, Vector128 upper) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_permutex2var_ps (__m256 a, __m256i idx, __m256i b) - /// VPERMI2PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst - /// VPERMT2PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_permutex2var_ps (__m256 a, __m256i idx, __m256i b) + /// VPERMI2PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// VPERMT2PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 PermuteVar8x32x2(Vector256 lower, Vector256 indices, Vector256 upper) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutex2var_epi32 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst - /// VPERMT2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_permutex2var_epi32 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// VPERMT2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 PermuteVar8x32x2(Vector256 lower, Vector256 indices, Vector256 upper) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutex2var_epi32 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst - /// VPERMT2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_permutex2var_epi32 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// VPERMT2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 PermuteVar8x32x2(Vector256 lower, Vector256 indices, Vector256 upper) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_range_pd(__m128d a, __m128d b, int imm); - /// VRANGEPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128d _mm_range_pd(__m128d a, __m128d b, int imm); + /// VRANGEPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 Range(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_range_ps(__m128 a, __m128 b, int imm); - /// VRANGEPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128 _mm_range_ps(__m128 a, __m128 b, int imm); + /// VRANGEPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 Range(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_range_pd(__m256d a, __m256d b, int imm); - /// VRANGEPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256d _mm256_range_pd(__m256d a, __m256d b, int imm); + /// VRANGEPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 Range(Vector256 left, Vector256 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_range_ps(__m256 a, __m256 b, int imm); - /// VRANGEPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256 _mm256_range_ps(__m256 a, __m256 b, int imm); + /// VRANGEPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 Range(Vector256 left, Vector256 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_range_sd(__m128d a, __m128d b, int imm); - /// VRANGESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 + /// __m128d _mm_range_sd(__m128d a, __m128d b, int imm); + /// VRANGESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 /// public static Vector128 RangeScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_range_ss(__m128 a, __m128 b, int imm); - /// VRANGESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 + /// __m128 _mm_range_ss(__m128 a, __m128 b, int imm); + /// VRANGESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 /// public static Vector128 RangeScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_rcp14_pd (__m128d a, __m128d b) - /// VRCP14PD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_rcp14_pd (__m128d a, __m128d b) + /// VRCP14PD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 Reciprocal14(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_rcp14_ps (__m128 a, __m128 b) - /// VRCP14PS xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128 _mm_rcp14_ps (__m128 a, __m128 b) + /// VRCP14PS xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 Reciprocal14(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_rcp14_pd (__m256d a, __m256d b) - /// VRCP14PD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_rcp14_pd (__m256d a, __m256d b) + /// VRCP14PD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 Reciprocal14(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_rcp14_ps (__m256 a, __m256 b) - /// VRCP14PS ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256 _mm256_rcp14_ps (__m256 a, __m256 b) + /// VRCP14PS ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 Reciprocal14(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_rcp14_sd (__m128d a, __m128d b) - /// VRCP14SD xmm1 {k1}{z}, xmm2, xmm3/m64 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128d _mm_rcp14_sd (__m128d a, __m128d b) + /// VRCP14SD xmm1 {k1}{z}, xmm2, xmm3/m64 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 Reciprocal14Scalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_rcp14_sd (__m128d a) - /// VRCP14SD xmm1 {k1}{z}, xmm2, xmm3/m64 + /// __m128d _mm_rcp14_sd (__m128d a) + /// VRCP14SD xmm1 {k1}{z}, xmm2, xmm3/m64 /// public static Vector128 Reciprocal14Scalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_rcp14_ss (__m128 a, __m128 b) - /// VRCP14SS xmm1 {k1}{z}, xmm2, xmm3/m32 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_rcp14_ss (__m128 a, __m128 b) + /// VRCP14SS xmm1 {k1}{z}, xmm2, xmm3/m32 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 Reciprocal14Scalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_rcp14_ss (__m128 a) - /// VRCP14SS xmm1 {k1}{z}, xmm2, xmm3/m32 + /// __m128 _mm_rcp14_ss (__m128 a) + /// VRCP14SS xmm1 {k1}{z}, xmm2, xmm3/m32 /// public static Vector128 Reciprocal14Scalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_rsqrt14_pd (__m128d a, __m128d b) - /// VRSQRT14PD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_rsqrt14_pd (__m128d a, __m128d b) + /// VRSQRT14PD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ReciprocalSqrt14(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_rsqrt14_ps (__m128 a, __m128 b) - /// VRSQRT14PS xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128 _mm_rsqrt14_ps (__m128 a, __m128 b) + /// VRSQRT14PS xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 ReciprocalSqrt14(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_rsqrt14_pd (__m256d a, __m256d b) - /// VRSQRT14PD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_rsqrt14_pd (__m256d a, __m256d b) + /// VRSQRT14PD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ReciprocalSqrt14(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_rsqrt14_ps (__m256 a, __m256 b) - /// VRSQRT14PS ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256 _mm256_rsqrt14_ps (__m256 a, __m256 b) + /// VRSQRT14PS ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 ReciprocalSqrt14(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_rsqrt14_sd (__m128d a, __m128d b) - /// VRSQRT14SD xmm1 {k1}{z}, xmm2, xmm3/m64 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128d _mm_rsqrt14_sd (__m128d a, __m128d b) + /// VRSQRT14SD xmm1 {k1}{z}, xmm2, xmm3/m64 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 ReciprocalSqrt14Scalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_rsqrt14_sd (__m128d a) - /// VRSQRT14SD xmm1 {k1}{z}, xmm2, xmm3/m64 + /// __m128d _mm_rsqrt14_sd (__m128d a) + /// VRSQRT14SD xmm1 {k1}{z}, xmm2, xmm3/m64 /// public static Vector128 ReciprocalSqrt14Scalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_rsqrt14_ss (__m128 a, __m128 b) - /// VRSQRT14SS xmm1 {k1}{z}, xmm2, xmm3/m32 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_rsqrt14_ss (__m128 a, __m128 b) + /// VRSQRT14SS xmm1 {k1}{z}, xmm2, xmm3/m32 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 ReciprocalSqrt14Scalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_rsqrt14_ss (__m128 a) - /// VRSQRT14SS xmm1 {k1}{z}, xmm2, xmm3/m32 + /// __m128 _mm_rsqrt14_ss (__m128 a) + /// VRSQRT14SS xmm1 {k1}{z}, xmm2, xmm3/m32 /// public static Vector128 ReciprocalSqrt14Scalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_reduce_pd(__m128d a, int imm); - /// VREDUCEPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128d _mm_reduce_pd(__m128d a, int imm); + /// VREDUCEPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 Reduce(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_reduce_ps(__m128 a, int imm); - /// VREDUCEPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128 _mm_reduce_ps(__m128 a, int imm); + /// VREDUCEPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 Reduce(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_reduce_pd(__m256d a, int imm); - /// VREDUCEPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256d _mm256_reduce_pd(__m256d a, int imm); + /// VREDUCEPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 Reduce(Vector256 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_reduce_ps(__m256 a, int imm); - /// VREDUCEPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256 _mm256_reduce_ps(__m256 a, int imm); + /// VREDUCEPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 Reduce(Vector256 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_reduce_sd(__m128d a, __m128d b, int imm); - /// VREDUCESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128d _mm_reduce_sd(__m128d a, __m128d b, int imm); + /// VREDUCESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 ReduceScalar(Vector128 upper, Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_reduce_sd(__m128d a, int imm); - /// VREDUCESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 + /// __m128d _mm_reduce_sd(__m128d a, int imm); + /// VREDUCESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 /// public static Vector128 ReduceScalar(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_reduce_ss(__m128 a, __m128 b, int imm); - /// VREDUCESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_reduce_ss(__m128 a, __m128 b, int imm); + /// VREDUCESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 ReduceScalar(Vector128 upper, Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_reduce_ss(__m128 a, int imm); - /// VREDUCESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 + /// __m128 _mm_reduce_ss(__m128 a, int imm); + /// VREDUCESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 /// public static Vector128 ReduceScalar(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_rol_epi32 (__m128i a, int imm8) - /// VPROLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128i _mm_rol_epi32 (__m128i a, int imm8) + /// VPROLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 RotateLeft(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_rol_epi64 (__m128i a, int imm8) - /// VPROLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128i _mm_rol_epi64 (__m128i a, int imm8) + /// VPROLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 RotateLeft(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_rol_epi32 (__m128i a, int imm8) - /// VPROLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128i _mm_rol_epi32 (__m128i a, int imm8) + /// VPROLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 RotateLeft(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_rol_epi64 (__m128i a, int imm8) - /// VPROLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128i _mm_rol_epi64 (__m128i a, int imm8) + /// VPROLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 RotateLeft(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_rol_epi32 (__m256i a, int imm8) - /// VPROLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256i _mm256_rol_epi32 (__m256i a, int imm8) + /// VPROLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 RotateLeft(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_rol_epi64 (__m256i a, int imm8) - /// VPROLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256i _mm256_rol_epi64 (__m256i a, int imm8) + /// VPROLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 RotateLeft(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_rol_epi32 (__m256i a, int imm8) - /// VPROLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256i _mm256_rol_epi32 (__m256i a, int imm8) + /// VPROLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 RotateLeft(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_rol_epi64 (__m256i a, int imm8) - /// VPROLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256i _mm256_rol_epi64 (__m256i a, int imm8) + /// VPROLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 RotateLeft(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_rolv_epi32 (__m128i a, __m128i b) - /// VPROLDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_rolv_epi32 (__m128i a, __m128i b) + /// VPROLDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 RotateLeftVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_rolv_epi64 (__m128i a, __m128i b) - /// VPROLQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_rolv_epi64 (__m128i a, __m128i b) + /// VPROLQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 RotateLeftVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_rolv_epi32 (__m128i a, __m128i b) - /// VPROLDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_rolv_epi32 (__m128i a, __m128i b) + /// VPROLDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 RotateLeftVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_rolv_epi64 (__m128i a, __m128i b) - /// VPROLQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_rolv_epi64 (__m128i a, __m128i b) + /// VPROLQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 RotateLeftVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_rolv_epi32 (__m256i a, __m256i b) - /// VPROLDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_rolv_epi32 (__m256i a, __m256i b) + /// VPROLDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 RotateLeftVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_rolv_epi64 (__m256i a, __m256i b) - /// VPROLQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_rolv_epi64 (__m256i a, __m256i b) + /// VPROLQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 RotateLeftVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_rolv_epi32 (__m256i a, __m256i b) - /// VPROLDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_rolv_epi32 (__m256i a, __m256i b) + /// VPROLDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 RotateLeftVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_rolv_epi64 (__m256i a, __m256i b) - /// VPROLQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_rolv_epi64 (__m256i a, __m256i b) + /// VPROLQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 RotateLeftVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_ror_epi32 (__m128i a, int imm8) - /// VPRORD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128i _mm_ror_epi32 (__m128i a, int imm8) + /// VPRORD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 RotateRight(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_ror_epi64 (__m128i a, int imm8) - /// VPRORQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128i _mm_ror_epi64 (__m128i a, int imm8) + /// VPRORQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 RotateRight(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_ror_epi32 (__m128i a, int imm8) - /// VPRORD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128i _mm_ror_epi32 (__m128i a, int imm8) + /// VPRORD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 RotateRight(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_ror_epi64 (__m128i a, int imm8) - /// VPRORQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128i _mm_ror_epi64 (__m128i a, int imm8) + /// VPRORQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 RotateRight(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_ror_epi32 (__m256i a, int imm8) - /// VPRORD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256i _mm256_ror_epi32 (__m256i a, int imm8) + /// VPRORD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 RotateRight(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_ror_epi64 (__m256i a, int imm8) - /// VPRORQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256i _mm256_ror_epi64 (__m256i a, int imm8) + /// VPRORQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 RotateRight(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_ror_epi32 (__m256i a, int imm8) - /// VPRORD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256i _mm256_ror_epi32 (__m256i a, int imm8) + /// VPRORD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 RotateRight(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_ror_epi64 (__m256i a, int imm8) - /// VPRORQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256i _mm256_ror_epi64 (__m256i a, int imm8) + /// VPRORQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 RotateRight(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_rorv_epi32 (__m128i a, __m128i b) - /// VPRORDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_rorv_epi32 (__m128i a, __m128i b) + /// VPRORDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 RotateRightVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_rorv_epi64 (__m128i a, __m128i b) - /// VPRORQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_rorv_epi64 (__m128i a, __m128i b) + /// VPRORQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 RotateRightVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_rorv_epi32 (__m128i a, __m128i b) - /// VPRORDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_rorv_epi32 (__m128i a, __m128i b) + /// VPRORDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 RotateRightVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_rorv_epi64 (__m128i a, __m128i b) - /// VPRORQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_rorv_epi64 (__m128i a, __m128i b) + /// VPRORQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 RotateRightVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_rorv_epi32 (__m256i a, __m256i b) - /// VPRORDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_rorv_epi32 (__m256i a, __m256i b) + /// VPRORDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 RotateRightVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_rorv_epi64 (__m256i a, __m256i b) - /// VPRORQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_rorv_epi64 (__m256i a, __m256i b) + /// VPRORQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 RotateRightVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_rorv_epi32 (__m256i a, __m256i b) - /// VPRORDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_rorv_epi32 (__m256i a, __m256i b) + /// VPRORDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 RotateRightVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_rorv_epi64 (__m256i a, __m256i b) - /// VPRORQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_rorv_epi64 (__m256i a, __m256i b) + /// VPRORQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 RotateRightVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_roundscale_pd (__m128d a, int imm) - /// VRNDSCALEPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128d _mm_roundscale_pd (__m128d a, int imm) + /// VRNDSCALEPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 RoundScale(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_roundscale_ps (__m128 a, int imm) - /// VRNDSCALEPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128 _mm_roundscale_ps (__m128 a, int imm) + /// VRNDSCALEPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 RoundScale(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_roundscale_pd (__m256d a, int imm) - /// VRNDSCALEPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256d _mm256_roundscale_pd (__m256d a, int imm) + /// VRNDSCALEPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 RoundScale(Vector256 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_roundscale_ps (__m256 a, int imm) - /// VRNDSCALEPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256 _mm256_roundscale_ps (__m256 a, int imm) + /// VRNDSCALEPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 RoundScale(Vector256 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_roundscale_sd (__m128d a, __m128d b, int imm) - /// VRNDSCALESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128d _mm_roundscale_sd (__m128d a, __m128d b, int imm) + /// VRNDSCALESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 RoundScaleScalar(Vector128 upper, Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_roundscale_sd (__m128d a, int imm) - /// VRNDSCALESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 + /// __m128d _mm_roundscale_sd (__m128d a, int imm) + /// VRNDSCALESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 /// public static Vector128 RoundScaleScalar(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_roundscale_ss (__m128 a, __m128 b, int imm) - /// VRNDSCALESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_roundscale_ss (__m128 a, __m128 b, int imm) + /// VRNDSCALESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 RoundScaleScalar(Vector128 upper, Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_roundscale_ss (__m128 a, int imm) - /// VRNDSCALESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 + /// __m128 _mm_roundscale_ss (__m128 a, int imm) + /// VRNDSCALESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 /// public static Vector128 RoundScaleScalar(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_scalef_pd (__m128d a, int imm) - /// VSCALEFPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_scalef_pd (__m128d a, int imm) + /// VSCALEFPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Scale(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_scalef_ps (__m128 a, int imm) - /// VSCALEFPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_scalef_ps (__m128 a, int imm) + /// VSCALEFPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Scale(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_scalef_pd (__m256d a, int imm) - /// VSCALEFPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_scalef_pd (__m256d a, int imm) + /// VSCALEFPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Scale(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_scalef_ps (__m256 a, int imm) - /// VSCALEFPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_scalef_ps (__m256 a, int imm) + /// VSCALEFPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Scale(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_scalef_round_sd (__m128d a, __m128d b) - /// VSCALEFSD xmm1, xmm2, xmm3 {er} + /// __m128d _mm_scalef_round_sd (__m128d a, __m128d b) + /// VSCALEFSD xmm1, xmm2, xmm3 {er} /// public static Vector128 ScaleScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_scalef_sd (__m128d a, __m128d b) - /// VSCALEFSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} + /// __m128d _mm_scalef_sd (__m128d a, __m128d b) + /// VSCALEFSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} /// public static Vector128 ScaleScalar(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_scalef_round_ss (__m128 a, __m128 b) - /// VSCALEFSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_scalef_round_ss (__m128 a, __m128 b) + /// VSCALEFSS xmm1, xmm2, xmm3 {er} /// public static Vector128 ScaleScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_scalef_ss (__m128 a, __m128 b) - /// VSCALEFSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} + /// __m128 _mm_scalef_ss (__m128 a, __m128 b) + /// VSCALEFSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} /// public static Vector128 ScaleScalar(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sllv_epi16 (__m128i a, __m128i count) - /// VPSLLVW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sllv_epi16 (__m128i a, __m128i count) + /// VPSLLVW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftLeftLogicalVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sllv_epi16 (__m128i a, __m128i count) - /// VPSLLVW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sllv_epi16 (__m128i a, __m128i count) + /// VPSLLVW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftLeftLogicalVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sllv_epi16 (__m256i a, __m256i count) - /// VPSLLVW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sllv_epi16 (__m256i a, __m256i count) + /// VPSLLVW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sllv_epi16 (__m256i a, __m256i count) - /// VPSLLVW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sllv_epi16 (__m256i a, __m256i count) + /// VPSLLVW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __128i _mm_srai_epi64 (__m128i a, int imm8) - /// VPSRAQ xmm1 {k1}{z}, xmm2, imm8 + /// __128i _mm_srai_epi64 (__m128i a, int imm8) + /// VPSRAQ xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftRightArithmetic(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sra_epi64 (__m128i a, __m128i count) - /// VPSRAQ xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sra_epi64 (__m128i a, __m128i count) + /// VPSRAQ xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightArithmetic(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srai_epi64 (__m256i a, int imm8) - /// VPSRAQ ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_srai_epi64 (__m256i a, int imm8) + /// VPSRAQ ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftRightArithmetic(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sra_epi64 (__m256i a, __m128i count) - /// VPSRAQ ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_sra_epi64 (__m256i a, __m128i count) + /// VPSRAQ ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftRightArithmetic(Vector256 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srav_epi64 (__m128i a, __m128i count) - /// VPSRAVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_srav_epi64 (__m128i a, __m128i count) + /// VPSRAVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 ShiftRightArithmeticVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srav_epi16 (__m128i a, __m128i count) - /// VPSRAVW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_srav_epi16 (__m128i a, __m128i count) + /// VPSRAVW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightArithmeticVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srav_epi64 (__m256i a, __m256i count) - /// VPSRAVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_srav_epi64 (__m256i a, __m256i count) + /// VPSRAVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 ShiftRightArithmeticVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srav_epi16 (__m256i a, __m256i count) - /// VPSRAVW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_srav_epi16 (__m256i a, __m256i count) + /// VPSRAVW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 ShiftRightArithmeticVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srlv_epi16 (__m128i a, __m128i count) - /// VPSRLVW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_srlv_epi16 (__m128i a, __m128i count) + /// VPSRLVW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightLogicalVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srlv_epi16 (__m128i a, __m128i count) - /// VPSRLVW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_srlv_epi16 (__m128i a, __m128i count) + /// VPSRLVW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightLogicalVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srlv_epi16 (__m256i a, __m256i count) - /// VPSRLVW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_srlv_epi16 (__m256i a, __m256i count) + /// VPSRLVW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srlv_epi16 (__m256i a, __m256i count) - /// VPSRLVW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_srlv_epi16 (__m256i a, __m256i count) + /// VPSRLVW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_shuffle_f64x2 (__m256d a, __m256d b, const int imm8) - /// VSHUFF64x2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256d _mm256_shuffle_f64x2 (__m256d a, __m256d b, const int imm8) + /// VSHUFF64x2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 Shuffle2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_shuffle_f32x4 (__m256 a, __m256 b, const int imm8) - /// VSHUFF32x4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256 _mm256_shuffle_f32x4 (__m256 a, __m256 b, const int imm8) + /// VSHUFF32x4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 Shuffle2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_shuffle_i32x4 (__m256i a, __m256i b, const int imm8) - /// VSHUFI32x4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256i _mm256_shuffle_i32x4 (__m256i a, __m256i b, const int imm8) + /// VSHUFI32x4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 Shuffle2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_shuffle_i64x2 (__m256i a, __m256i b, const int imm8) - /// VSHUFI64x2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256i _mm256_shuffle_i64x2 (__m256i a, __m256i b, const int imm8) + /// VSHUFI64x2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 Shuffle2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_shuffle_i32x4 (__m256i a, __m256i b, const int imm8) - /// VSHUFI32x4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256i _mm256_shuffle_i32x4 (__m256i a, __m256i b, const int imm8) + /// VSHUFI32x4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 Shuffle2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_shuffle_i64x2 (__m256i a, __m256i b, const int imm8) - /// VSHUFI64x2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256i _mm256_shuffle_i64x2 (__m256i a, __m256i b, const int imm8) + /// VSHUFI64x2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 Shuffle2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_sqrt_round_sd (__m128d a, __m128d b, int rounding) - /// VSQRTSD xmm1, xmm2 xmm3 {er} + /// __m128d _mm_sqrt_round_sd (__m128d a, __m128d b, int rounding) + /// VSQRTSD xmm1, xmm2 xmm3 {er} /// public static Vector128 SqrtScalar(Vector128 upper, Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_sqrt_round_ss (__m128 a, __m128 b, int rounding) - /// VSQRTSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_sqrt_round_ss (__m128 a, __m128 b, int rounding) + /// VSQRTSS xmm1, xmm2, xmm3 {er} /// public static Vector128 SqrtScalar(Vector128 upper, Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_sub_round_sd (__m128d a, __m128d b, int rounding) - /// VSUBSD xmm1, xmm2, xmm3 {er} + /// __m128d _mm_sub_round_sd (__m128d a, __m128d b, int rounding) + /// VSUBSD xmm1, xmm2, xmm3 {er} /// public static Vector128 SubtractScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_sub_round_ss (__m128 a, __m128 b, int rounding) - /// VSUBSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_sub_round_ss (__m128 a, __m128 b, int rounding) + /// VSUBSS xmm1, xmm2, xmm3 {er} /// public static Vector128 SubtractScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_dbsad_epu8 (__m128i a, __m128i b, int imm8) - /// VDBPSADBW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_dbsad_epu8 (__m128i a, __m128i b, int imm8) + /// VDBPSADBW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 SumAbsoluteDifferencesInBlock32(Vector128 left, Vector128 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_dbsad_epu8 (__m256i a, __m256i b, int imm8) - /// VDBPSADBW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_dbsad_epu8 (__m256i a, __m256i b, int imm8) + /// VDBPSADBW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 SumAbsoluteDifferencesInBlock32(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, byte imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, byte imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_ternarylogic_pd (__m128d a, __m128d b, __m128d c, int imm) - /// VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m128d _mm_ternarylogic_pd (__m128d a, __m128d b, __m128d c, int imm) + /// VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_ternarylogic_ps (__m128 a, __m128 b, __m128 c, int imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m128 _mm_ternarylogic_ps (__m128 a, __m128 b, __m128 c, int imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_ternarylogic_epi32 (__m128i a, __m128i b, __m128i c, int imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128i _mm_ternarylogic_epi32 (__m128i a, __m128i b, __m128i c, int imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_ternarylogic_epi64 (__m128i a, __m128i b, __m128i c, int imm) - /// VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128i _mm_ternarylogic_epi64 (__m128i a, __m128i b, __m128i c, int imm) + /// VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, byte imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, byte imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, short imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, short imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_ternarylogic_epi32 (__m128i a, __m128i b, __m128i c, int imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128i _mm_ternarylogic_epi32 (__m128i a, __m128i b, __m128i c, int imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_ternarylogic_epi64 (__m128i a, __m128i b, __m128i c, int imm) - /// VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128i _mm_ternarylogic_epi64 (__m128i a, __m128i b, __m128i c, int imm) + /// VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, short imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, short imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, byte imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, byte imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_ternarylogic_pd (__m256d a, __m256d b, __m256d c, int imm) - /// VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m256d _mm256_ternarylogic_pd (__m256d a, __m256d b, __m256d c, int imm) + /// VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_ternarylogic_ps (__m256 a, __m256 b, __m256 c, int imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m256 _mm256_ternarylogic_ps (__m256 a, __m256 b, __m256 c, int imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_ternarylogic_epi32 (__m256i a, __m256i b, __m256i c, int imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256i _mm256_ternarylogic_epi32 (__m256i a, __m256i b, __m256i c, int imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_ternarylogic_epi64 (__m256i a, __m256i b, __m256i c, int imm) - /// VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256i _mm256_ternarylogic_epi64 (__m256i a, __m256i b, __m256i c, int imm) + /// VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, byte imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, byte imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, short imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, short imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_ternarylogic_epi32 (__m256i a, __m256i b, __m256i c, int imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256i _mm256_ternarylogic_epi32 (__m256i a, __m256i b, __m256i c, int imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_ternarylogic_epi64 (__m256i a, __m256i b, __m256i c, int imm) - /// VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256i _mm256_ternarylogic_epi64 (__m256i a, __m256i b, __m256i c, int imm) + /// VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, short imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, short imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } + /// Provides access to the x86 AVX10.1 hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class X64 : Avx2.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } /// - /// __m128 _mm_cvt_roundi64_ss (__m128 a, __int64 b, int rounding) - /// VCVTSI2SS xmm1, xmm2, r64 {er} - /// This intrinsic is only available on 64-bit processes + /// __m128 _mm_cvt_roundi64_ss (__m128 a, __int64 b, int rounding) + /// VCVTSI2SS xmm1, xmm2, r64 {er} + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, ulong value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cvtsi64_ss (__m128 a, __int64 b) - /// VCVTUSI2SS xmm1, xmm2, r/m64 - /// This intrinsic is only available on 64-bit processes + /// __m128 _mm_cvtsi64_ss (__m128 a, __int64 b) + /// VCVTUSI2SS xmm1, xmm2, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, long value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cvt_roundu64_ss (__m128 a, unsigned __int64 b, int rounding) - /// VCVTUSI2SS xmm1, xmm2, r64 {er} - /// This intrinsic is only available on 64-bit processes + /// __m128 _mm_cvt_roundu64_ss (__m128 a, unsigned __int64 b, int rounding) + /// VCVTUSI2SS xmm1, xmm2, r64 {er} + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, ulong value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cvtsi64_sd (__m128d a, __int64 b) - /// VCVTUSI2SD xmm1, xmm2, r/m64 - /// This intrinsic is only available on 64-bit processes + /// __m128d _mm_cvtsi64_sd (__m128d a, __int64 b) + /// VCVTUSI2SD xmm1, xmm2, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Double(Vector128 upper, ulong value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cvt_roundsi64_sd (__m128d a, __int64 b, int rounding) - /// VCVTSI2SD xmm1, xmm2, r64 {er} - /// This intrinsic is only available on 64-bit processes + /// __m128d _mm_cvt_roundsi64_sd (__m128d a, __int64 b, int rounding) + /// VCVTSI2SD xmm1, xmm2, r64 {er} + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Double(Vector128 upper, long value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cvt_roundu64_sd (__m128d a, unsigned __int64 b, int rounding) - /// VCVTUSI2SD xmm1, xmm2, r64 {er} - /// This intrinsic is only available on 64-bit processes + /// __m128d _mm_cvt_roundu64_sd (__m128d a, unsigned __int64 b, int rounding) + /// VCVTUSI2SD xmm1, xmm2, r64 {er} + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Double(Vector128 upper, ulong value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __int64 _mm_cvt_roundss_i64 (__m128 a, int rounding) - /// VCVTSS2SI r64, xmm1 {er} - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_cvt_roundss_i64 (__m128 a, int rounding) + /// VCVTSS2SI r64, xmm1 {er} + /// This intrinsic is only available on 64-bit processes /// public static long ConvertToInt64(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __int64 _mm_cvt_roundsd_i64 (__m128d a, int rounding) - /// VCVTSD2SI r64, xmm1 {er} - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_cvt_roundsd_i64 (__m128d a, int rounding) + /// VCVTSD2SI r64, xmm1 {er} + /// This intrinsic is only available on 64-bit processes /// public static long ConvertToInt64(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// unsigned __int64 _mm_cvtss_u64 (__m128 a) - /// VCVTSS2USI r64, xmm1/m32{er} - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_cvtss_u64 (__m128 a) + /// VCVTSS2USI r64, xmm1/m32{er} + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// unsigned __int64 _mm_cvt_roundss_u64 (__m128 a, int rounding) - /// VCVTSS2USI r64, xmm1 {er} - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_cvt_roundss_u64 (__m128 a, int rounding) + /// VCVTSS2USI r64, xmm1 {er} + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// unsigned __int64 _mm_cvtsd_u64 (__m128d a) - /// VCVTSD2USI r64, xmm1/m64{er} - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_cvtsd_u64 (__m128d a) + /// VCVTSD2USI r64, xmm1/m64{er} + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// unsigned __int64 _mm_cvt_roundsd_u64 (__m128d a, int rounding) - /// VCVTSD2USI r64, xmm1 {er} - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_cvt_roundsd_u64 (__m128d a, int rounding) + /// VCVTSD2USI r64, xmm1 {er} + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// unsigned __int64 _mm_cvttss_u64 (__m128 a) - /// VCVTTSS2USI r64, xmm1/m32{er} - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_cvttss_u64 (__m128 a) + /// VCVTTSS2USI r64, xmm1/m32{er} + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// unsigned __int64 _mm_cvttsd_u64 (__m128d a) - /// VCVTTSD2USI r64, xmm1/m64{er} - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_cvttsd_u64 (__m128d a) + /// VCVTTSD2USI r64, xmm1/m64{er} + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } } + /// Provides access to the x86 AVX10.1/512 hardware instructions via intrinsics. public abstract class V512 : Avx512BW { internal V512() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } /// - /// __m512i _mm512_conflict_epi32 (__m512i a) - /// VPCONFLICTD zmm1 {k1}{z}, zmm2/m512/m32bcst + /// __m512i _mm512_conflict_epi32 (__m512i a) + /// VPCONFLICTD zmm1 {k1}{z}, zmm2/m512/m32bcst /// public static Vector512 DetectConflicts(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_conflict_epi32 (__m512i a) - /// VPCONFLICTD zmm1 {k1}{z}, zmm2/m512/m32bcst + /// __m512i _mm512_conflict_epi32 (__m512i a) + /// VPCONFLICTD zmm1 {k1}{z}, zmm2/m512/m32bcst /// public static Vector512 DetectConflicts(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_conflict_epi64 (__m512i a) - /// VPCONFLICTQ zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512i _mm512_conflict_epi64 (__m512i a) + /// VPCONFLICTQ zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 DetectConflicts(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_conflict_epi64 (__m512i a) - /// VPCONFLICTQ zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512i _mm512_conflict_epi64 (__m512i a) + /// VPCONFLICTQ zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 DetectConflicts(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_lzcnt_epi32 (__m512i a) - /// VPLZCNTD zmm1 {k1}{z}, zmm2/m512/m32bcst + /// __m512i _mm512_lzcnt_epi32 (__m512i a) + /// VPLZCNTD zmm1 {k1}{z}, zmm2/m512/m32bcst /// public static Vector512 LeadingZeroCount(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_lzcnt_epi32 (__m512i a) - /// VPLZCNTD zmm1 {k1}{z}, zmm2/m512/m32bcst + /// __m512i _mm512_lzcnt_epi32 (__m512i a) + /// VPLZCNTD zmm1 {k1}{z}, zmm2/m512/m32bcst /// public static Vector512 LeadingZeroCount(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_lzcnt_epi64 (__m512i a) - /// VPLZCNTQ zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512i _mm512_lzcnt_epi64 (__m512i a) + /// VPLZCNTQ zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 LeadingZeroCount(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_lzcnt_epi64 (__m512i a) - /// VPLZCNTQ zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512i _mm512_lzcnt_epi64 (__m512i a) + /// VPLZCNTQ zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 LeadingZeroCount(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_and_ps (__m512 a, __m512 b) - /// VANDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_and_ps (__m512 a, __m512 b) + /// VANDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 And(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_and_pd (__m512d a, __m512d b) - /// VANDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_and_pd (__m512d a, __m512d b) + /// VANDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 And(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_andnot_ps (__m512 a, __m512 b) - /// VANDNPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_andnot_ps (__m512 a, __m512 b) + /// VANDNPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 AndNot(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_andnot_pd (__m512d a, __m512d b) - /// VANDNPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_andnot_pd (__m512d a, __m512d b) + /// VANDNPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 AndNot(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_broadcast_i32x2 (__m128i a) - /// VBROADCASTI32x2 zmm1 {k1}{z}, xmm2/m64 + /// __m512i _mm512_broadcast_i32x2 (__m128i a) + /// VBROADCASTI32x2 zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 BroadcastPairScalarToVector512(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_broadcast_i32x2 (__m128i a) - /// VBROADCASTI32x2 zmm1 {k1}{z}, xmm2/m64 + /// __m512i _mm512_broadcast_i32x2 (__m128i a) + /// VBROADCASTI32x2 zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 BroadcastPairScalarToVector512(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_broadcast_f32x2 (__m128 a) - /// VBROADCASTF32x2 zmm1 {k1}{z}, xmm2/m64 + /// __m512 _mm512_broadcast_f32x2 (__m128 a) + /// VBROADCASTF32x2 zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 BroadcastPairScalarToVector512(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_broadcast_i64x2 (__m128i const * mem_addr) - /// VBROADCASTI64x2 zmm1 {k1}{z}, m128 + /// __m512i _mm512_broadcast_i64x2 (__m128i const * mem_addr) + /// VBROADCASTI64x2 zmm1 {k1}{z}, m128 /// public static unsafe Vector512 BroadcastVector128ToVector512(long* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_broadcast_i64x2 (__m128i const * mem_addr) - /// VBROADCASTI64x2 zmm1 {k1}{z}, m128 + /// __m512i _mm512_broadcast_i64x2 (__m128i const * mem_addr) + /// VBROADCASTI64x2 zmm1 {k1}{z}, m128 /// public static unsafe Vector512 BroadcastVector128ToVector512(ulong* address) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_broadcast_f64x2 (__m128d const * mem_addr) - /// VBROADCASTF64x2 zmm1 {k1}{z}, m128 + /// __m512d _mm512_broadcast_f64x2 (__m128d const * mem_addr) + /// VBROADCASTF64x2 zmm1 {k1}{z}, m128 /// public static unsafe Vector512 BroadcastVector128ToVector512(double* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_broadcast_i32x8 (__m256i const * mem_addr) - /// VBROADCASTI32x8 zmm1 {k1}{z}, m256 + /// __m512i _mm512_broadcast_i32x8 (__m256i const * mem_addr) + /// VBROADCASTI32x8 zmm1 {k1}{z}, m256 /// public static unsafe Vector512 BroadcastVector256ToVector512(int* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_broadcast_i32x8 (__m256i const * mem_addr) - /// VBROADCASTI32x8 zmm1 {k1}{z}, m256 + /// __m512i _mm512_broadcast_i32x8 (__m256i const * mem_addr) + /// VBROADCASTI32x8 zmm1 {k1}{z}, m256 /// public static unsafe Vector512 BroadcastVector256ToVector512(uint* address) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_broadcast_f32x8 (__m256 const * mem_addr) - /// VBROADCASTF32x8 zmm1 {k1}{z}, m256 + /// __m512 _mm512_broadcast_f32x8 (__m256 const * mem_addr) + /// VBROADCASTF32x8 zmm1 {k1}{z}, m256 /// public static unsafe Vector512 BroadcastVector256ToVector512(float* address) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_cvtepi64_ps (__m512i a) - /// VCVTQQ2PS ymm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512 _mm512_cvtepi64_ps (__m512i a) + /// VCVTQQ2PS ymm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector256 ConvertToVector256Single(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_cvtepu64_ps (__m512i a) - /// VCVTUQQ2PS ymm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512 _mm512_cvtepu64_ps (__m512i a) + /// VCVTUQQ2PS ymm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector256 ConvertToVector256Single(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm512_cvt_roundepi64_ps (__m512i a, int r) - /// VCVTQQ2PS ymm1, zmm2 {er} + /// __m256 _mm512_cvt_roundepi64_ps (__m512i a, int r) + /// VCVTQQ2PS ymm1, zmm2 {er} /// public static Vector256 ConvertToVector256Single(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm512_cvt_roundepu64_ps (__m512i a, int r) - /// VCVTUQQ2PS ymm1, zmm2 {er} + /// __m256 _mm512_cvt_roundepu64_ps (__m512i a, int r) + /// VCVTUQQ2PS ymm1, zmm2 {er} /// public static Vector256 ConvertToVector256Single(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_cvtepi64_pd (__m512i a) - /// VCVTQQ2PD zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512d _mm512_cvtepi64_pd (__m512i a) + /// VCVTQQ2PD zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 ConvertToVector512Double(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_cvtepu64_pd (__m512i a) - /// VCVTUQQ2PD zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512d _mm512_cvtepu64_pd (__m512i a) + /// VCVTUQQ2PD zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 ConvertToVector512Double(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_cvt_roundepi64_pd (__m512i a, int r) - /// VCVTQQ2PD zmm1, zmm2 {er} + /// __m512d _mm512_cvt_roundepi64_pd (__m512i a, int r) + /// VCVTQQ2PD zmm1, zmm2 {er} /// public static Vector512 ConvertToVector512Double(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_cvt_roundepu64_pd (__m512i a, int r) - /// VCVTUQQ2PD zmm1, zmm2 {er} + /// __m512d _mm512_cvt_roundepu64_pd (__m512i a, int r) + /// VCVTUQQ2PD zmm1, zmm2 {er} /// public static Vector512 ConvertToVector512Double(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtps_epi64 (__m512 a) - /// VCVTPS2QQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} + /// __m512i _mm512_cvtps_epi64 (__m512 a) + /// VCVTPS2QQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} /// public static Vector512 ConvertToVector512Int64(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtpd_epi64 (__m512d a) - /// VCVTPD2QQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m512i _mm512_cvtpd_epi64 (__m512d a) + /// VCVTPD2QQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector512 ConvertToVector512Int64(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvt_roundps_epi64 (__m512 a, int r) - /// VCVTPS2QQ zmm1, ymm2 {er} + /// __m512i _mm512_cvt_roundps_epi64 (__m512 a, int r) + /// VCVTPS2QQ zmm1, ymm2 {er} /// public static Vector512 ConvertToVector512Int64(Vector256 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvt_roundpd_epi64 (__m512d a, int r) - /// VCVTPD2QQ zmm1, zmm2 {er} + /// __m512i _mm512_cvt_roundpd_epi64 (__m512d a, int r) + /// VCVTPD2QQ zmm1, zmm2 {er} /// public static Vector512 ConvertToVector512Int64(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvttps_epi64 (__m512 a) - /// VCVTTPS2QQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} + /// __m512i _mm512_cvttps_epi64 (__m512 a) + /// VCVTTPS2QQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} /// public static Vector512 ConvertToVector512Int64WithTruncation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvttpd_epi64 (__m512 a) - /// VCVTTPD2QQ zmm1 {k1}{z}, zmm2/m512/m64bcst{sae} + /// __m512i _mm512_cvttpd_epi64 (__m512 a) + /// VCVTTPD2QQ zmm1 {k1}{z}, zmm2/m512/m64bcst{sae} /// public static Vector512 ConvertToVector512Int64WithTruncation(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtps_epu64 (__m512 a) - /// VCVTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} + /// __m512i _mm512_cvtps_epu64 (__m512 a) + /// VCVTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} /// public static Vector512 ConvertToVector512UInt64(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtpd_epu64 (__m512d a) - /// VCVTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m512i _mm512_cvtpd_epu64 (__m512d a) + /// VCVTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector512 ConvertToVector512UInt64(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvt_roundps_epu64 (__m512 a, int r) - /// VCVTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} + /// __m512i _mm512_cvt_roundps_epu64 (__m512 a, int r) + /// VCVTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} /// public static Vector512 ConvertToVector512UInt64(Vector256 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvt_roundpd_epu64 (__m512d a, int r) - /// VCVTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m512i _mm512_cvt_roundpd_epu64 (__m512d a, int r) + /// VCVTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector512 ConvertToVector512UInt64(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvttps_epu64 (__m512 a) - /// VCVTTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} + /// __m512i _mm512_cvttps_epu64 (__m512 a) + /// VCVTTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} /// public static Vector512 ConvertToVector512UInt64WithTruncation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvttpd_epu64 (__m512d a) - /// VCVTTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m512i _mm512_cvttpd_epu64 (__m512d a) + /// VCVTTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector512 ConvertToVector512UInt64WithTruncation(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_extracti64x2_epi64 (__m512i a, const int imm8) - /// VEXTRACTI64x2 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128i _mm512_extracti64x2_epi64 (__m512i a, const int imm8) + /// VEXTRACTI64x2 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static new Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_extracti64x2_epi64 (__m512i a, const int imm8) - /// VEXTRACTI64x2 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128i _mm512_extracti64x2_epi64 (__m512i a, const int imm8) + /// VEXTRACTI64x2 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static new Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm512_extractf64x2_pd (__m512d a, const int imm8) - /// VEXTRACTF64x2 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128d _mm512_extractf64x2_pd (__m512d a, const int imm8) + /// VEXTRACTF64x2 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static new Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_extracti32x8_epi32 (__m512i a, const int imm8) - /// VEXTRACTI32x8 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256i _mm512_extracti32x8_epi32 (__m512i a, const int imm8) + /// VEXTRACTI32x8 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static new Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_extracti32x8_epi32 (__m512i a, const int imm8) - /// VEXTRACTI32x8 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256i _mm512_extracti32x8_epi32 (__m512i a, const int imm8) + /// VEXTRACTI32x8 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static new Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm512_extractf32x8_ps (__m512 a, const int imm8) - /// VEXTRACTF32x8 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256 _mm512_extractf32x8_ps (__m512 a, const int imm8) + /// VEXTRACTF32x8 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static new Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_inserti64x2_si512 (__m512i a, __m128i b, const int imm8) - /// VINSERTI64x2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512i _mm512_inserti64x2_si512 (__m512i a, __m128i b, const int imm8) + /// VINSERTI64x2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static new Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_inserti64x2_si512 (__m512i a, __m128i b, const int imm8) - /// VINSERTI64x2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512i _mm512_inserti64x2_si512 (__m512i a, __m128i b, const int imm8) + /// VINSERTI64x2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static new Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_insertf64x2_pd (__m512d a, __m128d b, int imm8) - /// VINSERTF64x2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512d _mm512_insertf64x2_pd (__m512d a, __m128d b, int imm8) + /// VINSERTF64x2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static new Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_inserti32x8_si512 (__m512i a, __m256i b, const int imm8) - /// VINSERTI32x8 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512i _mm512_inserti32x8_si512 (__m512i a, __m256i b, const int imm8) + /// VINSERTI32x8 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static new Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_inserti32x8_si512 (__m512i a, __m256i b, const int imm8) - /// VINSERTI32x8 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512i _mm512_inserti32x8_si512 (__m512i a, __m256i b, const int imm8) + /// VINSERTI32x8 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static new Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_insertf32x8_ps (__m512 a, __m256 b, int imm8) - /// VINSERTF32x8 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512 _mm512_insertf32x8_ps (__m512 a, __m256 b, int imm8) + /// VINSERTF32x8 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static new Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_mullo_epi64 (__m512i a, __m512i b) - /// VPMULLQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_mullo_epi64 (__m512i a, __m512i b) + /// VPMULLQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 MultiplyLow(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_mullo_epi64 (__m512i a, __m512i b) - /// VPMULLQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_mullo_epi64 (__m512i a, __m512i b) + /// VPMULLQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 MultiplyLow(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_multishift_epi64_epi8( __m512i a, __m512i b) - /// VPMULTISHIFTQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_multishift_epi64_epi8( __m512i a, __m512i b) + /// VPMULTISHIFTQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 MultiShift(Vector512 control, Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_multishift_epi64_epi8( __m512i a, __m512i b) - /// VPMULTISHIFTQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_multishift_epi64_epi8( __m512i a, __m512i b) + /// VPMULTISHIFTQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 MultiShift(Vector512 control, Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_or_ps (__m512 a, __m512 b) - /// VORPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_or_ps (__m512 a, __m512 b) + /// VORPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Or(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_or_pd (__m512d a, __m512d b) - /// VORPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_or_pd (__m512d a, __m512d b) + /// VORPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Or(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_range_ps(__m512 a, __m512 b, int imm); - /// VRANGEPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}, imm8 + /// __m512 _mm512_range_ps(__m512 a, __m512 b, int imm); + /// VRANGEPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}, imm8 /// public static Vector512 Range(Vector512 left, Vector512 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_range_pd(__m512d a, __m512d b, int imm); - /// VRANGEPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}, imm8 + /// __m512d _mm512_range_pd(__m512d a, __m512d b, int imm); + /// VRANGEPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}, imm8 /// public static Vector512 Range(Vector512 left, Vector512 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_reduce_ps(__m512 a, int imm); - /// VREDUCEPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}, imm8 + /// __m512 _mm512_reduce_ps(__m512 a, int imm); + /// VREDUCEPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}, imm8 /// public static Vector512 Reduce(Vector512 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_reduce_pd(__m512d a, int imm); - /// VREDUCEPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}, imm8 + /// __m512d _mm512_reduce_pd(__m512d a, int imm); + /// VREDUCEPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}, imm8 /// public static Vector512 Reduce(Vector512 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_xor_ps (__m512 a, __m512 b) - /// VXORPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_xor_ps (__m512 a, __m512 b) + /// VXORPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Xor(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_xor_pd (__m512d a, __m512d b) - /// VXORPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_xor_pd (__m512d a, __m512d b) + /// VXORPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Xor(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_permutevar64x8_epi8 (__m512i a, __m512i b) - /// VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_permutevar64x8_epi8 (__m512i a, __m512i b) + /// VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PermuteVar64x8(Vector512 left, Vector512 control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_permutevar64x8_epi8 (__m512i a, __m512i b) - /// VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_permutevar64x8_epi8 (__m512i a, __m512i b) + /// VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PermuteVar64x8(Vector512 left, Vector512 control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_permutex2var_epi8 (__m512i a, __m512i idx, __m512i b) - /// VPERMI2B zmm1 {k1}{z}, zmm2, zmm3/m512 - /// VPERMT2B zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_permutex2var_epi8 (__m512i a, __m512i idx, __m512i b) + /// VPERMI2B zmm1 {k1}{z}, zmm2, zmm3/m512 + /// VPERMT2B zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PermuteVar64x8x2(Vector512 lower, Vector512 indices, Vector512 upper) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_permutex2var_epi8 (__m512i a, __m512i idx, __m512i b) - /// VPERMI2B zmm1 {k1}{z}, zmm2, zmm3/m512 - /// VPERMT2B zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_permutex2var_epi8 (__m512i a, __m512i idx, __m512i b) + /// VPERMI2B zmm1 {k1}{z}, zmm2, zmm3/m512 + /// VPERMT2B zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PermuteVar64x8x2(Vector512 lower, Vector512 indices, Vector512 upper) { throw new PlatformNotSupportedException(); } + /// Provides access to the x86 AVX10.1/512 hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : Avx512BW.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx10v1.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx10v1.cs index f1dd488826e..7cd16c3ae3f 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx10v1.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx10v1.cs @@ -6,3177 +6,3192 @@ namespace System.Runtime.Intrinsics.X86 { - /// This class provides access to X86 AVX10.1 hardware instructions via intrinsics + /// Provides access to X86 AVX10.1 hardware instructions via intrinsics [Intrinsic] [CLSCompliant(false)] public abstract class Avx10v1 : Avx2 { internal Avx10v1() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } /// - /// __m128i _mm_abs_epi64 (__m128i a) - /// VPABSQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_abs_epi64 (__m128i a) + /// VPABSQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 Abs(Vector128 value) => Abs(value); /// - /// __m256i _mm256_abs_epi64 (__m128i a) - /// VPABSQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_abs_epi64 (__m128i a) + /// VPABSQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 Abs(Vector256 value) => Abs(value); /// - /// __m128d _mm_add_round_sd (__m128d a, __m128d b, int rounding) - /// VADDSD xmm1, xmm2, xmm3 {er} + /// __m128d _mm_add_round_sd (__m128d a, __m128d b, int rounding) + /// VADDSD xmm1, xmm2, xmm3 {er} /// public static Vector128 AddScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => AddScalar(left, right, mode); /// - /// __m128 _mm_add_round_ss (__m128 a, __m128 b, int rounding) - /// VADDSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_add_round_ss (__m128 a, __m128 b, int rounding) + /// VADDSS xmm1, xmm2, xmm3 {er} /// public static Vector128 AddScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => AddScalar(left, right, mode); /// - /// __m128i _mm_alignr_epi32 (__m128i a, __m128i b, const int count) - /// VALIGND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128i _mm_alignr_epi32 (__m128i a, __m128i b, const int count) + /// VALIGND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 AlignRight32(Vector128 left, Vector128 right, [ConstantExpected] byte mask) => AlignRight32(left, right, mask); /// - /// __m128i _mm_alignr_epi32 (__m128i a, __m128i b, const int count) - /// VALIGND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128i _mm_alignr_epi32 (__m128i a, __m128i b, const int count) + /// VALIGND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 AlignRight32(Vector128 left, Vector128 right, [ConstantExpected] byte mask) => AlignRight32(left, right, mask); /// - /// __m256i _mm256_alignr_epi32 (__m256i a, __m256i b, const int count) - /// VALIGND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256i _mm256_alignr_epi32 (__m256i a, __m256i b, const int count) + /// VALIGND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 AlignRight32(Vector256 left, Vector256 right, [ConstantExpected] byte mask) => AlignRight32(left, right, mask); /// - /// __m256i _mm256_alignr_epi32 (__m256i a, __m256i b, const int count) - /// VALIGND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256i _mm256_alignr_epi32 (__m256i a, __m256i b, const int count) + /// VALIGND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 AlignRight32(Vector256 left, Vector256 right, [ConstantExpected] byte mask) => AlignRight32(left, right, mask); /// - /// __m128i _mm_alignr_epi64 (__m128i a, __m128i b, const int count) - /// VALIGNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128i _mm_alignr_epi64 (__m128i a, __m128i b, const int count) + /// VALIGNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 AlignRight64(Vector128 left, Vector128 right, [ConstantExpected] byte mask) => AlignRight64(left, right, mask); /// - /// __m128i _mm_alignr_epi64 (__m128i a, __m128i b, const int count) - /// VALIGNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128i _mm_alignr_epi64 (__m128i a, __m128i b, const int count) + /// VALIGNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 AlignRight64(Vector128 left, Vector128 right, [ConstantExpected] byte mask) => AlignRight64(left, right, mask); /// - /// __m256i _mm256_alignr_epi64 (__m256i a, __m256i b, const int count) - /// VALIGNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256i _mm256_alignr_epi64 (__m256i a, __m256i b, const int count) + /// VALIGNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 AlignRight64(Vector256 left, Vector256 right, [ConstantExpected] byte mask) => AlignRight64(left, right, mask); /// - /// __m256i _mm256_alignr_epi64 (__m256i a, __m256i b, const int count) - /// VALIGNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256i _mm256_alignr_epi64 (__m256i a, __m256i b, const int count) + /// VALIGNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 AlignRight64(Vector256 left, Vector256 right, [ConstantExpected] byte mask) => AlignRight64(left, right, mask); /// - /// __m128i _mm_broadcast_i32x2 (__m128i a) - /// VBROADCASTI32x2 xmm1 {k1}{z}, xmm2/m64 + /// __m128i _mm_broadcast_i32x2 (__m128i a) + /// VBROADCASTI32x2 xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 BroadcastPairScalarToVector128(Vector128 value) => BroadcastPairScalarToVector128(value); /// - /// __m128i _mm_broadcast_i32x2 (__m128i a) - /// VBROADCASTI32x2 xmm1 {k1}{z}, xmm2/m64 + /// __m128i _mm_broadcast_i32x2 (__m128i a) + /// VBROADCASTI32x2 xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 BroadcastPairScalarToVector128(Vector128 value) => BroadcastPairScalarToVector128(value); /// - /// __m256 _mm256_broadcast_f32x2 (__m128 a) - /// VBROADCASTF32x2 ymm1 {k1}{z}, xmm2/m64 + /// __m256 _mm256_broadcast_f32x2 (__m128 a) + /// VBROADCASTF32x2 ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 BroadcastPairScalarToVector256(Vector128 value) => BroadcastPairScalarToVector256(value); /// - /// __m256i _mm256_broadcast_i32x2 (__m128i a) - /// VBROADCASTI32x2 ymm1 {k1}{z}, xmm2/m64 + /// __m256i _mm256_broadcast_i32x2 (__m128i a) + /// VBROADCASTI32x2 ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 BroadcastPairScalarToVector256(Vector128 value) => BroadcastPairScalarToVector256(value); /// - /// __m256i _mm256_broadcast_i32x2 (__m128i a) - /// VBROADCASTI32x2 ymm1 {k1}{z}, xmm2/m64 + /// __m256i _mm256_broadcast_i32x2 (__m128i a) + /// VBROADCASTI32x2 ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 BroadcastPairScalarToVector256(Vector128 value) => BroadcastPairScalarToVector256(value); /// - /// __m128i _mm_cmpgt_epu8 (__m128i a, __m128i b) - /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(6) + /// __m128i _mm_cmpgt_epu8 (__m128i a, __m128i b) + /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(6) /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// - /// __m128i _mm_cmpgt_epu32 (__m128i a, __m128i b) - /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(6) + /// __m128i _mm_cmpgt_epu32 (__m128i a, __m128i b) + /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(6) /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// - /// __m128i _mm_cmpgt_epu64 (__m128i a, __m128i b) - /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(6) + /// __m128i _mm_cmpgt_epu64 (__m128i a, __m128i b) + /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(6) /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// - /// __m128i _mm_cmpgt_epu16 (__m128i a, __m128i b) - /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(6) + /// __m128i _mm_cmpgt_epu16 (__m128i a, __m128i b) + /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(6) /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// - /// __m256i _mm256_cmpgt_epu8 (__m256i a, __m256i b) - /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(6) + /// __m256i _mm256_cmpgt_epu8 (__m256i a, __m256i b) + /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(6) /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) => CompareGreaterThan(left, right); /// - /// __m256i _mm256_cmpgt_epu32 (__m256i a, __m256i b) - /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(6) + /// __m256i _mm256_cmpgt_epu32 (__m256i a, __m256i b) + /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(6) /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) => CompareGreaterThan(left, right); /// - /// __m256i _mm256_cmpgt_epu64 (__m256i a, __m256i b) - /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(6) + /// __m256i _mm256_cmpgt_epu64 (__m256i a, __m256i b) + /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(6) /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) => CompareGreaterThan(left, right); /// - /// __m256i _mm256_cmpgt_epu16 (__m256i a, __m256i b) - /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(6) + /// __m256i _mm256_cmpgt_epu16 (__m256i a, __m256i b) + /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(6) /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) => CompareGreaterThan(left, right); /// - /// __m128i _mm_cmpge_epu8 (__m128i a, __m128i b) - /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(5) + /// __m128i _mm_cmpge_epu8 (__m128i a, __m128i b) + /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m128i _mm_cmpge_epi32 (__m128i a, __m128i b) - /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(5) + /// __m128i _mm_cmpge_epi32 (__m128i a, __m128i b) + /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m128i _mm_cmpge_epi64 (__m128i a, __m128i b) - /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(5) + /// __m128i _mm_cmpge_epi64 (__m128i a, __m128i b) + /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m128i _mm_cmpge_epi8 (__m128i a, __m128i b) - /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(5) + /// __m128i _mm_cmpge_epi8 (__m128i a, __m128i b) + /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m128i _mm_cmpge_epi16 (__m128i a, __m128i b) - /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(5) + /// __m128i _mm_cmpge_epi16 (__m128i a, __m128i b) + /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m128i _mm_cmpge_epu32 (__m128i a, __m128i b) - /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(5) + /// __m128i _mm_cmpge_epu32 (__m128i a, __m128i b) + /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m128i _mm_cmpge_epu64 (__m128i a, __m128i b) - /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(5) + /// __m128i _mm_cmpge_epu64 (__m128i a, __m128i b) + /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m128i _mm_cmpge_epu16 (__m128i a, __m128i b) - /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(5) + /// __m128i _mm_cmpge_epu16 (__m128i a, __m128i b) + /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m256i _mm256_cmpge_epu8 (__m256i a, __m256i b) - /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(5) + /// __m256i _mm256_cmpge_epu8 (__m256i a, __m256i b) + /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m256i _mm256_cmpge_epi32 (__m256i a, __m256i b) - /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(5) + /// __m256i _mm256_cmpge_epi32 (__m256i a, __m256i b) + /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m256i _mm256_cmpge_epi64 (__m256i a, __m256i b) - /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(5) + /// __m256i _mm256_cmpge_epi64 (__m256i a, __m256i b) + /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m256i _mm256_cmpge_epi8 (__m256i a, __m256i b) - /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(5) + /// __m256i _mm256_cmpge_epi8 (__m256i a, __m256i b) + /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m256i _mm256_cmpge_epi16 (__m256i a, __m256i b) - /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(5) + /// __m256i _mm256_cmpge_epi16 (__m256i a, __m256i b) + /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m256i _mm256_cmpge_epu32 (__m256i a, __m256i b) - /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(5) + /// __m256i _mm256_cmpge_epu32 (__m256i a, __m256i b) + /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m256i _mm256_cmpge_epu64 (__m256i a, __m256i b) - /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(5) + /// __m256i _mm256_cmpge_epu64 (__m256i a, __m256i b) + /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m256i _mm256_cmpge_epu16 (__m256i a, __m256i b) - /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(5) + /// __m256i _mm256_cmpge_epu16 (__m256i a, __m256i b) + /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m128i _mm_cmplt_epi32 (__m128i a, __m128i b) - /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(1) + /// __m128i _mm_cmplt_epi32 (__m128i a, __m128i b) + /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(1) /// public static new Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// __m128i _mm_cmplt_epi8 (__m128i a, __m128i b) - /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(1) + /// __m128i _mm_cmplt_epi8 (__m128i a, __m128i b) + /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(1) /// public static new Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// __m128i _mm_cmplt_epi16 (__m128i a, __m128i b) - /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(1) + /// __m128i _mm_cmplt_epi16 (__m128i a, __m128i b) + /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(1) /// public static new Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// __m128i _mm_cmplt_epu8 (__m128i a, __m128i b) - /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(1) + /// __m128i _mm_cmplt_epu8 (__m128i a, __m128i b) + /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// __m128i _mm_cmplt_epi64 (__m128i a, __m128i b) - /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(1) + /// __m128i _mm_cmplt_epi64 (__m128i a, __m128i b) + /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// __m128i _mm_cmplt_epu32 (__m128i a, __m128i b) - /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(1) + /// __m128i _mm_cmplt_epu32 (__m128i a, __m128i b) + /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// __m128i _mm_cmplt_epu64 (__m128i a, __m128i b) - /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(1) + /// __m128i _mm_cmplt_epu64 (__m128i a, __m128i b) + /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// __m128i _mm_cmplt_epu16 (__m128i a, __m128i b) - /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(1) + /// __m128i _mm_cmplt_epu16 (__m128i a, __m128i b) + /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// __m256i _mm256_cmplt_epu8 (__m256i a, __m256i b) - /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(1) + /// __m256i _mm256_cmplt_epu8 (__m256i a, __m256i b) + /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) => CompareLessThan(left, right); /// - /// __m256i _mm256_cmplt_epi32 (__m256i a, __m256i b) - /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(1) + /// __m256i _mm256_cmplt_epi32 (__m256i a, __m256i b) + /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) => CompareLessThan(left, right); /// - /// __m256i _mm256_cmplt_epi64 (__m256i a, __m256i b) - /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(1) + /// __m256i _mm256_cmplt_epi64 (__m256i a, __m256i b) + /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) => CompareLessThan(left, right); /// - /// __m256i _mm256_cmplt_epi8 (__m256i a, __m256i b) - /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(1) + /// __m256i _mm256_cmplt_epi8 (__m256i a, __m256i b) + /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) => CompareLessThan(left, right); /// - /// __m256i _mm256_cmplt_epi16 (__m256i a, __m256i b) - /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(1) + /// __m256i _mm256_cmplt_epi16 (__m256i a, __m256i b) + /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) => CompareLessThan(left, right); /// - /// __m256i _mm256_cmplt_epu32 (__m256i a, __m256i b) - /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(1) + /// __m256i _mm256_cmplt_epu32 (__m256i a, __m256i b) + /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) => CompareLessThan(left, right); /// - /// __m256i _mm256_cmplt_epu64 (__m256i a, __m256i b) - /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(1) + /// __m256i _mm256_cmplt_epu64 (__m256i a, __m256i b) + /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) => CompareLessThan(left, right); /// - /// __m256i _mm256_cmplt_epu16 (__m256i a, __m256i b) - /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(1) + /// __m256i _mm256_cmplt_epu16 (__m256i a, __m256i b) + /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) => CompareLessThan(left, right); /// - /// __m128i _mm_cmple_epu8 (__m128i a, __m128i b) - /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(2) + /// __m128i _mm_cmple_epu8 (__m128i a, __m128i b) + /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// __m128i _mm_cmple_epi32 (__m128i a, __m128i b) - /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(2) + /// __m128i _mm_cmple_epi32 (__m128i a, __m128i b) + /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// __m128i _mm_cmple_epi64 (__m128i a, __m128i b) - /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(2) + /// __m128i _mm_cmple_epi64 (__m128i a, __m128i b) + /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// __m128i _mm_cmple_epi8 (__m128i a, __m128i b) - /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(2) + /// __m128i _mm_cmple_epi8 (__m128i a, __m128i b) + /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// __m128i _mm_cmple_epi16 (__m128i a, __m128i b) - /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(2) + /// __m128i _mm_cmple_epi16 (__m128i a, __m128i b) + /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// __m128i _mm_cmple_epu32 (__m128i a, __m128i b) - /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(2) + /// __m128i _mm_cmple_epu32 (__m128i a, __m128i b) + /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// __m128i _mm_cmple_epu64 (__m128i a, __m128i b) - /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(2) + /// __m128i _mm_cmple_epu64 (__m128i a, __m128i b) + /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// __m128i _mm_cmple_epu16 (__m128i a, __m128i b) - /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(2) + /// __m128i _mm_cmple_epu16 (__m128i a, __m128i b) + /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// __m256i _mm256_cmple_epu8 (__m256i a, __m256i b) - /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(2) + /// __m256i _mm256_cmple_epu8 (__m256i a, __m256i b) + /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) => CompareLessThanOrEqual(left, right); /// - /// __m256i _mm256_cmple_epi32 (__m256i a, __m256i b) - /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(2) + /// __m256i _mm256_cmple_epi32 (__m256i a, __m256i b) + /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) => CompareLessThanOrEqual(left, right); /// - /// __m256i _mm256_cmple_epi64 (__m256i a, __m256i b) - /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(2) + /// __m256i _mm256_cmple_epi64 (__m256i a, __m256i b) + /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) => CompareLessThanOrEqual(left, right); /// - /// __m256i _mm256_cmple_epi8 (__m256i a, __m256i b) - /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(2) + /// __m256i _mm256_cmple_epi8 (__m256i a, __m256i b) + /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) => CompareLessThanOrEqual(left, right); /// - /// __m256i _mm256_cmple_epi16 (__m256i a, __m256i b) - /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(2) + /// __m256i _mm256_cmple_epi16 (__m256i a, __m256i b) + /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) => CompareLessThanOrEqual(left, right); /// - /// __m256i _mm256_cmple_epu32 (__m256i a, __m256i b) - /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(2) + /// __m256i _mm256_cmple_epu32 (__m256i a, __m256i b) + /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) => CompareLessThanOrEqual(left, right); /// - /// __m256i _mm256_cmple_epu64 (__m256i a, __m256i b) - /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(2) + /// __m256i _mm256_cmple_epu64 (__m256i a, __m256i b) + /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) => CompareLessThanOrEqual(left, right); /// - /// __m256i _mm256_cmple_epu16 (__m256i a, __m256i b) - /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(2) + /// __m256i _mm256_cmple_epu16 (__m256i a, __m256i b) + /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) => CompareLessThanOrEqual(left, right); /// - /// __m128i _mm_cmpne_epu8 (__m128i a, __m128i b) - /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(4) + /// __m128i _mm_cmpne_epu8 (__m128i a, __m128i b) + /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); /// - /// __m128i _mm_cmpne_epi32 (__m128i a, __m128i b) - /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(4) + /// __m128i _mm_cmpne_epi32 (__m128i a, __m128i b) + /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); /// - /// __m128i _mm_cmpne_epi64 (__m128i a, __m128i b) - /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(4) + /// __m128i _mm_cmpne_epi64 (__m128i a, __m128i b) + /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); /// - /// __m128i _mm_cmpne_epi8 (__m128i a, __m128i b) - /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(4) + /// __m128i _mm_cmpne_epi8 (__m128i a, __m128i b) + /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); /// - /// __m128i _mm_cmpne_epi16 (__m128i a, __m128i b) - /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(4) + /// __m128i _mm_cmpne_epi16 (__m128i a, __m128i b) + /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); /// - /// __m128i _mm_cmpne_epu32 (__m128i a, __m128i b) - /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(4) + /// __m128i _mm_cmpne_epu32 (__m128i a, __m128i b) + /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); /// - /// __m128i _mm_cmpne_epu64 (__m128i a, __m128i b) - /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(4) + /// __m128i _mm_cmpne_epu64 (__m128i a, __m128i b) + /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); /// - /// __m128i _mm_cmpne_epu16 (__m128i a, __m128i b) - /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(4) + /// __m128i _mm_cmpne_epu16 (__m128i a, __m128i b) + /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); /// - /// __m256i _mm256_cmpne_epu8 (__m256i a, __m256i b) - /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(4) + /// __m256i _mm256_cmpne_epu8 (__m256i a, __m256i b) + /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) => CompareNotEqual(left, right); /// - /// __m256i _mm256_cmpne_epi32 (__m256i a, __m256i b) - /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(4) + /// __m256i _mm256_cmpne_epi32 (__m256i a, __m256i b) + /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) => CompareNotEqual(left, right); /// - /// __m256i _mm256_cmpne_epi64 (__m256i a, __m256i b) - /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(4) + /// __m256i _mm256_cmpne_epi64 (__m256i a, __m256i b) + /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) => CompareNotEqual(left, right); /// - /// __m256i _mm256_cmpne_epi8 (__m256i a, __m256i b) - /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(4) + /// __m256i _mm256_cmpne_epi8 (__m256i a, __m256i b) + /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) => CompareNotEqual(left, right); /// - /// __m256i _mm256_cmpne_epi16 (__m256i a, __m256i b) - /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(4) + /// __m256i _mm256_cmpne_epi16 (__m256i a, __m256i b) + /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) => CompareNotEqual(left, right); /// - /// __m256i _mm256_cmpne_epu32 (__m256i a, __m256i b) - /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(4) + /// __m256i _mm256_cmpne_epu32 (__m256i a, __m256i b) + /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) => CompareNotEqual(left, right); /// - /// __m256i _mm256_cmpne_epu64 (__m256i a, __m256i b) - /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(4) + /// __m256i _mm256_cmpne_epu64 (__m256i a, __m256i b) + /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) => CompareNotEqual(left, right); /// - /// __m256i _mm256_cmpne_epu16 (__m256i a, __m256i b) - /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(4) + /// __m256i _mm256_cmpne_epu16 (__m256i a, __m256i b) + /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) => CompareNotEqual(left, right); /// - /// __m128d _mm_cvtsi32_sd (__m128d a, int b) - /// VCVTUSI2SD xmm1, xmm2, r/m32 + /// __m128d _mm_cvtsi32_sd (__m128d a, int b) + /// VCVTUSI2SD xmm1, xmm2, r/m32 /// public static Vector128 ConvertScalarToVector128Double(Vector128 upper, uint value) => ConvertScalarToVector128Double(upper, value); /// - /// __m128 _mm_cvt_roundi32_ss (__m128 a, int b, int rounding) - /// VCVTSI2SS xmm1, xmm2, r32 {er} + /// __m128 _mm_cvt_roundi32_ss (__m128 a, int b, int rounding) + /// VCVTSI2SS xmm1, xmm2, r32 {er} /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, int value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertScalarToVector128Single(upper, value, mode); /// - /// __m128 _mm_cvt_roundi32_ss (__m128 a, int b, int rounding) - /// VCVTUSI2SS xmm1, xmm2, r32 {er} + /// __m128 _mm_cvt_roundi32_ss (__m128 a, int b, int rounding) + /// VCVTUSI2SS xmm1, xmm2, r32 {er} /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, uint value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertScalarToVector128Single(upper, value, mode); /// - /// __m128 _mm_cvtsi32_ss (__m128 a, int b) - /// VCVTUSI2SS xmm1, xmm2, r/m32 + /// __m128 _mm_cvtsi32_ss (__m128 a, int b) + /// VCVTUSI2SS xmm1, xmm2, r/m32 /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, uint value) => ConvertScalarToVector128Single(upper, value); /// - /// __m128 _mm_cvt_roundsd_ss (__m128 a, __m128d b, int rounding) - /// VCVTSD2SS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_cvt_roundsd_ss (__m128 a, __m128d b, int rounding) + /// VCVTSD2SS xmm1, xmm2, xmm3 {er} /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertScalarToVector128Single(upper, value, mode); /// - /// int _mm_cvt_roundsd_i32 (__m128d a, int rounding) - /// VCVTSD2SI r32, xmm1 {er} + /// int _mm_cvt_roundsd_i32 (__m128d a, int rounding) + /// VCVTSD2SI r32, xmm1 {er} /// public static int ConvertToInt32(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToInt32(value, mode); /// - /// int _mm_cvt_roundss_i32 (__m128 a, int rounding) - /// VCVTSS2SIK r32, xmm1 {er} + /// int _mm_cvt_roundss_i32 (__m128 a, int rounding) + /// VCVTSS2SIK r32, xmm1 {er} /// public static int ConvertToInt32(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToInt32(value, mode); /// - /// unsigned int _mm_cvt_roundsd_u32 (__m128d a, int rounding) - /// VCVTSD2USI r32, xmm1 {er} + /// unsigned int _mm_cvt_roundsd_u32 (__m128d a, int rounding) + /// VCVTSD2USI r32, xmm1 {er} /// public static uint ConvertToUInt32(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToUInt32(value, mode); /// - /// unsigned int _mm_cvtsd_u32 (__m128d a) - /// VCVTSD2USI r32, xmm1/m64{er} + /// unsigned int _mm_cvtsd_u32 (__m128d a) + /// VCVTSD2USI r32, xmm1/m64{er} /// public static uint ConvertToUInt32(Vector128 value) => ConvertToUInt32(value); /// - /// unsigned int _mm_cvt_roundss_u32 (__m128 a, int rounding) - /// VCVTSS2USI r32, xmm1 {er} + /// unsigned int _mm_cvt_roundss_u32 (__m128 a, int rounding) + /// VCVTSS2USI r32, xmm1 {er} /// public static uint ConvertToUInt32(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToUInt32(value, mode); /// - /// unsigned int _mm_cvtss_u32 (__m128 a) - /// VCVTSS2USI r32, xmm1/m32{er} + /// unsigned int _mm_cvtss_u32 (__m128 a) + /// VCVTSS2USI r32, xmm1/m32{er} /// public static uint ConvertToUInt32(Vector128 value) => ConvertToUInt32(value); /// - /// unsigned int _mm_cvttsd_u32 (__m128d a) - /// VCVTTSD2USI r32, xmm1/m64{er} + /// unsigned int _mm_cvttsd_u32 (__m128d a) + /// VCVTTSD2USI r32, xmm1/m64{er} /// public static uint ConvertToUInt32WithTruncation(Vector128 value) => ConvertToUInt32WithTruncation(value); /// - /// unsigned int _mm_cvttss_u32 (__m128 a) - /// VCVTTSS2USI r32, xmm1/m32{er} + /// unsigned int _mm_cvttss_u32 (__m128 a) + /// VCVTTSS2USI r32, xmm1/m32{er} /// public static uint ConvertToUInt32WithTruncation(Vector128 value) => ConvertToUInt32WithTruncation(value); /// - /// __m128i _mm_cvtepi32_epi8 (__m128i a) - /// VPMOVDB xmm1/m32 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi32_epi8 (__m128i a) + /// VPMOVDB xmm1/m32 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Byte(Vector128 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm_cvtepi64_epi8 (__m128i a) - /// VPMOVQB xmm1/m16 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi8 (__m128i a) + /// VPMOVQB xmm1/m16 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Byte(Vector128 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm_cvtepi16_epi8 (__m128i a) - /// VPMOVWB xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi16_epi8 (__m128i a) + /// VPMOVWB xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Byte(Vector128 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm_cvtepi32_epi8 (__m128i a) - /// VPMOVDB xmm1/m32 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi32_epi8 (__m128i a) + /// VPMOVDB xmm1/m32 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Byte(Vector128 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm_cvtepi64_epi8 (__m128i a) - /// VPMOVQB xmm1/m16 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi8 (__m128i a) + /// VPMOVQB xmm1/m16 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Byte(Vector128 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm_cvtepi16_epi8 (__m128i a) - /// VPMOVWB xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi16_epi8 (__m128i a) + /// VPMOVWB xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Byte(Vector128 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm256_cvtepi32_epi8 (__m256i a) - /// VPMOVDB xmm1/m64 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi32_epi8 (__m256i a) + /// VPMOVDB xmm1/m64 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Byte(Vector256 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm256_cvtepi64_epi8 (__m256i a) - /// VPMOVQB xmm1/m32 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi8 (__m256i a) + /// VPMOVQB xmm1/m32 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Byte(Vector256 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm256_cvtepi16_epi8 (__m256i a) - /// VPMOVWB xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi16_epi8 (__m256i a) + /// VPMOVWB xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Byte(Vector256 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm256_cvtepi32_epi8 (__m256i a) - /// VPMOVDB xmm1/m64 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi32_epi8 (__m256i a) + /// VPMOVDB xmm1/m64 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Byte(Vector256 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm256_cvtepi64_epi8 (__m256i a) - /// VPMOVQB xmm1/m32 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi8 (__m256i a) + /// VPMOVQB xmm1/m32 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Byte(Vector256 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm256_cvtepi16_epi8 (__m256i a) - /// VPMOVWB xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi16_epi8 (__m256i a) + /// VPMOVWB xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Byte(Vector256 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm_cvtusepi32_epi8 (__m128i a) - /// VPMOVUSDB xmm1/m32 {k1}{z}, xmm2 + /// __m128i _mm_cvtusepi32_epi8 (__m128i a) + /// VPMOVUSDB xmm1/m32 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector128 value) => ConvertToVector128ByteWithSaturation(value); /// - /// __m128i _mm_cvtusepi64_epi8 (__m128i a) - /// VPMOVUSQB xmm1/m16 {k1}{z}, xmm2 + /// __m128i _mm_cvtusepi64_epi8 (__m128i a) + /// VPMOVUSQB xmm1/m16 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector128 value) => ConvertToVector128ByteWithSaturation(value); /// - /// __m128i _mm_cvtusepi16_epi8 (__m128i a) - /// VPMOVUWB xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtusepi16_epi8 (__m128i a) + /// VPMOVUWB xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector128 value) => ConvertToVector128ByteWithSaturation(value); /// - /// __m128i _mm256_cvtusepi32_epi8 (__m256i a) - /// VPMOVUSDB xmm1/m64 {k1}{z}, ymm2 + /// __m128i _mm256_cvtusepi32_epi8 (__m256i a) + /// VPMOVUSDB xmm1/m64 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector256 value) => ConvertToVector128ByteWithSaturation(value); /// - /// __m128i _mm256_cvtusepi64_epi8 (__m256i a) - /// VPMOVUSQB xmm1/m32 {k1}{z}, ymm2 + /// __m128i _mm256_cvtusepi64_epi8 (__m256i a) + /// VPMOVUSQB xmm1/m32 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector256 value) => ConvertToVector128ByteWithSaturation(value); /// - /// __m128i _mm256_cvtusepi16_epi8 (__m256i a) - /// VPMOVUWB xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtusepi16_epi8 (__m256i a) + /// VPMOVUWB xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector256 value) => ConvertToVector128ByteWithSaturation(value); /// - /// __m128d _mm_cvtepi64_pd (__m128i a) - /// VCVTQQ2PD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_cvtepi64_pd (__m128i a) + /// VCVTQQ2PD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Double(Vector128 value) => ConvertToVector128Double(value); /// - /// __m128d _mm_cvtepu32_pd (__m128i a) - /// VCVTUDQ2PD xmm1 {k1}{z}, xmm2/m64/m32bcst + /// __m128d _mm_cvtepu32_pd (__m128i a) + /// VCVTUDQ2PD xmm1 {k1}{z}, xmm2/m64/m32bcst /// public static Vector128 ConvertToVector128Double(Vector128 value) => ConvertToVector128Double(value); /// - /// __m128d _mm_cvtepu64_pd (__m128i a) - /// VCVTUQQ2PD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_cvtepu64_pd (__m128i a) + /// VCVTUQQ2PD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Double(Vector128 value) => ConvertToVector128Double(value); /// - /// __m128i _mm_cvtepi32_epi16 (__m128i a) - /// VPMOVDW xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi32_epi16 (__m128i a) + /// VPMOVDW xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector128 value) => ConvertToVector128Int16(value); /// - /// __m128i _mm_cvtepi64_epi16 (__m128i a) - /// VPMOVQW xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi64_epi16 (__m128i a) + /// VPMOVQW xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector128 value) => ConvertToVector128Int16(value); /// - /// __m128i _mm_cvtepi32_epi16 (__m128i a) - /// VPMOVDW xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi32_epi16 (__m128i a) + /// VPMOVDW xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector128 value) => ConvertToVector128Int16(value); /// - /// __m128i _mm_cvtepi64_epi16 (__m128i a) - /// VPMOVQW xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi64_epi16 (__m128i a) + /// VPMOVQW xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector128 value) => ConvertToVector128Int16(value); /// - /// __m128i _mm256_cvtepi32_epi16 (__m256i a) - /// VPMOVDW xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi32_epi16 (__m256i a) + /// VPMOVDW xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector256 value) => ConvertToVector128Int16(value); /// - /// __m128i _mm256_cvtepi64_epi16 (__m256i a) - /// VPMOVQW xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi64_epi16 (__m256i a) + /// VPMOVQW xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector256 value) => ConvertToVector128Int16(value); /// - /// __m128i _mm256_cvtepi32_epi16 (__m256i a) - /// VPMOVDW xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi32_epi16 (__m256i a) + /// VPMOVDW xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector256 value) => ConvertToVector128Int16(value); /// - /// __m128i _mm256_cvtepi64_epi16 (__m256i a) - /// VPMOVQW xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi64_epi16 (__m256i a) + /// VPMOVQW xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector256 value) => ConvertToVector128Int16(value); /// - /// __m128i _mm_cvtsepi32_epi16 (__m128i a) - /// VPMOVSDW xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm_cvtsepi32_epi16 (__m128i a) + /// VPMOVSDW xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16WithSaturation(Vector128 value) => ConvertToVector128Int16WithSaturation(value); /// - /// __m128i _mm_cvtsepi64_epi16 (__m128i a) - /// VPMOVSQW xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm_cvtsepi64_epi16 (__m128i a) + /// VPMOVSQW xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16WithSaturation(Vector128 value) => ConvertToVector128Int16WithSaturation(value); /// - /// __m128i _mm256_cvtsepi32_epi16 (__m256i a) - /// VPMOVSDW xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm256_cvtsepi32_epi16 (__m256i a) + /// VPMOVSDW xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16WithSaturation(Vector256 value) => ConvertToVector128Int16WithSaturation(value); /// - /// __m128i _mm256_cvtsepi64_epi16 (__m256i a) - /// VPMOVSQW xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm256_cvtsepi64_epi16 (__m256i a) + /// VPMOVSQW xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16WithSaturation(Vector256 value) => ConvertToVector128Int16WithSaturation(value); /// - /// __m128i _mm_cvtepi64_epi32 (__m128i a) - /// VPMOVQD xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi32 (__m128i a) + /// VPMOVQD xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Int32(Vector128 value) => ConvertToVector128Int32(value); /// - /// __m128i _mm_cvtepi64_epi32 (__m128i a) - /// VPMOVQD xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi32 (__m128i a) + /// VPMOVQD xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Int32(Vector128 value) => ConvertToVector128Int32(value); /// - /// __m128i _mm256_cvtepi64_epi32 (__m256i a) - /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi32 (__m256i a) + /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Int32(Vector256 value) => ConvertToVector128Int32(value); /// - /// __m128i _mm256_cvtepi64_epi32 (__m256i a) - /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi32 (__m256i a) + /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Int32(Vector256 value) => ConvertToVector128Int32(value); /// - /// __m128i _mm_cvtsepi64_epi32 (__m128i a) - /// VPMOVSQD xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtsepi64_epi32 (__m128i a) + /// VPMOVSQD xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Int32WithSaturation(Vector128 value) => ConvertToVector128Int32WithSaturation(value); /// - /// __m128i _mm256_cvtsepi64_epi32 (__m256i a) - /// VPMOVSQD xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtsepi64_epi32 (__m256i a) + /// VPMOVSQD xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Int32WithSaturation(Vector256 value) => ConvertToVector128Int32WithSaturation(value); /// - /// __m128i _mm_cvtpd_epi64 (__m128d a) - /// VCVTPD2QQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvtpd_epi64 (__m128d a) + /// VCVTPD2QQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Int64(Vector128 value) => ConvertToVector128Int64(value); /// - /// __m128i _mm_cvtps_epi64 (__m128 a) - /// VCVTPS2QQ xmm1 {k1}{z}, xmm2/m64/m32bcst + /// __m128i _mm_cvtps_epi64 (__m128 a) + /// VCVTPS2QQ xmm1 {k1}{z}, xmm2/m64/m32bcst /// public static Vector128 ConvertToVector128Int64(Vector128 value) => ConvertToVector128Int64(value); /// - /// __m128i _mm_cvttpd_epi64 (__m128d a) - /// VCVTTPD2QQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvttpd_epi64 (__m128d a) + /// VCVTTPD2QQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Int64WithTruncation(Vector128 value) => ConvertToVector128Int64WithTruncation(value); /// - /// __m128i _mm_cvttps_epi64 (__m128 a) - /// VCVTTPS2QQ xmm1 {k1}{z}, xmm2/m64/m32bcst + /// __m128i _mm_cvttps_epi64 (__m128 a) + /// VCVTTPS2QQ xmm1 {k1}{z}, xmm2/m64/m32bcst /// public static Vector128 ConvertToVector128Int64WithTruncation(Vector128 value) => ConvertToVector128Int64WithTruncation(value); /// - /// __m128i _mm_cvtepi32_epi8 (__m128i a) - /// VPMOVDB xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi32_epi8 (__m128i a) + /// VPMOVDB xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector128 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm_cvtepi64_epi8 (__m128i a) - /// VPMOVQB xmm1/m16 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi64_epi8 (__m128i a) + /// VPMOVQB xmm1/m16 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector128 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm_cvtepi16_epi8 (__m128i a) - /// VPMOVWB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi16_epi8 (__m128i a) + /// VPMOVWB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector128 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm_cvtepi32_epi8 (__m128i a) - /// VPMOVDB xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi32_epi8 (__m128i a) + /// VPMOVDB xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector128 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm_cvtepi64_epi8 (__m128i a) - /// VPMOVQB xmm1/m16 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi64_epi8 (__m128i a) + /// VPMOVQB xmm1/m16 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector128 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm_cvtepi16_epi8 (__m128i a) - /// VPMOVWB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi16_epi8 (__m128i a) + /// VPMOVWB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector128 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm256_cvtepi32_epi8 (__m256i a) - /// VPMOVDB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi32_epi8 (__m256i a) + /// VPMOVDB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector256 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm256_cvtepi64_epi8 (__m256i a) - /// VPMOVQB xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi64_epi8 (__m256i a) + /// VPMOVQB xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector256 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm256_cvtepi16_epi8 (__m256i a) - /// VPMOVWB xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi16_epi8 (__m256i a) + /// VPMOVWB xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector256 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm256_cvtepi32_epi8 (__m256i a) - /// VPMOVDB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi32_epi8 (__m256i a) + /// VPMOVDB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector256 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm256_cvtepi64_epi8 (__m256i a) - /// VPMOVQB xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi64_epi8 (__m256i a) + /// VPMOVQB xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector256 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm256_cvtepi16_epi8 (__m256i a) - /// VPMOVWB xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi16_epi8 (__m256i a) + /// VPMOVWB xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector256 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm_cvtsepi32_epi8 (__m128i a) - /// VPMOVSDB xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm_cvtsepi32_epi8 (__m128i a) + /// VPMOVSDB xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector128 value) => ConvertToVector128SByteWithSaturation(value); /// - /// __m128i _mm_cvtsepi64_epi8 (__m128i a) - /// VPMOVSQB xmm1/m16 {k1}{z}, zmm2 + /// __m128i _mm_cvtsepi64_epi8 (__m128i a) + /// VPMOVSQB xmm1/m16 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector128 value) => ConvertToVector128SByteWithSaturation(value); /// - /// __m128i _mm_cvtsepi16_epi8 (__m128i a) - /// VPMOVSWB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm_cvtsepi16_epi8 (__m128i a) + /// VPMOVSWB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector128 value) => ConvertToVector128SByteWithSaturation(value); /// - /// __m128i _mm256_cvtsepi32_epi8 (__m256i a) - /// VPMOVSDB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm256_cvtsepi32_epi8 (__m256i a) + /// VPMOVSDB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector256 value) => ConvertToVector128SByteWithSaturation(value); /// - /// __m128i _mm256_cvtsepi64_epi8 (__m256i a) - /// VPMOVSQB xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm256_cvtsepi64_epi8 (__m256i a) + /// VPMOVSQB xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector256 value) => ConvertToVector128SByteWithSaturation(value); /// - /// __m128i _mm256_cvtsepi16_epi8 (__m256i a) - /// VPMOVSWB xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm256_cvtsepi16_epi8 (__m256i a) + /// VPMOVSWB xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector256 value) => ConvertToVector128SByteWithSaturation(value); /// - /// __m128 _mm_cvtepi64_ps (__m128i a) - /// VCVTQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128 _mm_cvtepi64_ps (__m128i a) + /// VCVTQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Single(Vector128 value) => ConvertToVector128Single(value); /// - /// __m128 _mm_cvtepu32_ps (__m128i a) - /// VCVTUDQ2PS xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128 _mm_cvtepu32_ps (__m128i a) + /// VCVTUDQ2PS xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 ConvertToVector128Single(Vector128 value) => ConvertToVector128Single(value); /// - /// __m128 _mm_cvtepu64_ps (__m128i a) - /// VCVTUQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128 _mm_cvtepu64_ps (__m128i a) + /// VCVTUQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Single(Vector128 value) => ConvertToVector128Single(value); /// - /// __m128 _mm256_cvtepi64_ps (__m256i a) - /// VCVTQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcst + /// __m128 _mm256_cvtepi64_ps (__m256i a) + /// VCVTQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector128 ConvertToVector128Single(Vector256 value) => ConvertToVector128Single(value); /// - /// __m128 _mm256_cvtepu64_ps (__m256i a) - /// VCVTUQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcst + /// __m128 _mm256_cvtepu64_ps (__m256i a) + /// VCVTUQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector128 ConvertToVector128Single(Vector256 value) => ConvertToVector128Single(value); /// - /// __m128i _mm_cvtepi32_epi16 (__m128i a) - /// VPMOVDW xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi32_epi16 (__m128i a) + /// VPMOVDW xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt16(Vector128 value) => ConvertToVector128UInt16(value); /// - /// __m128i _mm_cvtepi64_epi16 (__m128i a) - /// VPMOVQW xmm1/m32 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi16 (__m128i a) + /// VPMOVQW xmm1/m32 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt16(Vector128 value) => ConvertToVector128UInt16(value); /// - /// __m128i _mm_cvtepi32_epi16 (__m128i a) - /// VPMOVDW xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi32_epi16 (__m128i a) + /// VPMOVDW xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt16(Vector128 value) => ConvertToVector128UInt16(value); /// - /// __m128i _mm_cvtepi64_epi16 (__m128i a) - /// VPMOVQW xmm1/m32 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi16 (__m128i a) + /// VPMOVQW xmm1/m32 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt16(Vector128 value) => ConvertToVector128UInt16(value); /// - /// __m128i _mm256_cvtepi32_epi16 (__m256i a) - /// VPMOVDW xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi32_epi16 (__m256i a) + /// VPMOVDW xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt16(Vector256 value) => ConvertToVector128UInt16(value); /// - /// __m128i _mm256_cvtepi64_epi16 (__m256i a) - /// VPMOVQW xmm1/m64 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi16 (__m256i a) + /// VPMOVQW xmm1/m64 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt16(Vector256 value) => ConvertToVector128UInt16(value); /// - /// __m128i _mm256_cvtepi32_epi16 (__m256i a) - /// VPMOVDW xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi32_epi16 (__m256i a) + /// VPMOVDW xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt16(Vector256 value) => ConvertToVector128UInt16(value); /// - /// __m128i _mm256_cvtepi64_epi16 (__m256i a) - /// VPMOVQW xmm1/m64 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi16 (__m256i a) + /// VPMOVQW xmm1/m64 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt16(Vector256 value) => ConvertToVector128UInt16(value); /// - /// __m128i _mm_cvtusepi32_epi16 (__m128i a) - /// VPMOVUSDW xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtusepi32_epi16 (__m128i a) + /// VPMOVUSDW xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt16WithSaturation(Vector128 value) => ConvertToVector128UInt16WithSaturation(value); /// - /// __m128i _mm_cvtusepi64_epi16 (__m128i a) - /// VPMOVUSQW xmm1/m32 {k1}{z}, xmm2 + /// __m128i _mm_cvtusepi64_epi16 (__m128i a) + /// VPMOVUSQW xmm1/m32 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt16WithSaturation(Vector128 value) => ConvertToVector128UInt16WithSaturation(value); /// - /// __m128i _mm256_cvtusepi32_epi16 (__m256i a) - /// VPMOVUSDW xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtusepi32_epi16 (__m256i a) + /// VPMOVUSDW xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt16WithSaturation(Vector256 value) => ConvertToVector128UInt16WithSaturation(value); /// - /// __m128i _mm256_cvtusepi64_epi16 (__m256i a) - /// VPMOVUSQW xmm1/m64 {k1}{z}, ymm2 + /// __m128i _mm256_cvtusepi64_epi16 (__m256i a) + /// VPMOVUSQW xmm1/m64 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt16WithSaturation(Vector256 value) => ConvertToVector128UInt16WithSaturation(value); /// - /// __m128i _mm_cvtpd_epu32 (__m128d a) - /// VCVTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvtpd_epu32 (__m128d a) + /// VCVTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128UInt32(Vector128 value) => ConvertToVector128UInt32(value); /// - /// __m128i _mm_cvtps_epu32 (__m128 a) - /// VCVTPS2UDQ xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_cvtps_epu32 (__m128 a) + /// VCVTPS2UDQ xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 ConvertToVector128UInt32(Vector128 value) => ConvertToVector128UInt32(value); /// - /// __m128i _mm_cvtepi64_epi32 (__m128i a) - /// VPMOVQD xmm1/m128 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi32 (__m128i a) + /// VPMOVQD xmm1/m128 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt32(Vector128 value) => ConvertToVector128UInt32(value); /// - /// __m128i _mm_cvtepi64_epi32 (__m128i a) - /// VPMOVQD xmm1/m128 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi32 (__m128i a) + /// VPMOVQD xmm1/m128 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt32(Vector128 value) => ConvertToVector128UInt32(value); /// - /// __m128i _mm256_cvtpd_epu32 (__m256d a) - /// VCVTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcst + /// __m128i _mm256_cvtpd_epu32 (__m256d a) + /// VCVTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector128 ConvertToVector128UInt32(Vector256 value) => ConvertToVector128UInt32(value); /// - /// __m128i _mm256_cvtepi64_epi32 (__m256i a) - /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi32 (__m256i a) + /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt32(Vector256 value) => ConvertToVector128UInt32(value); /// - /// __m128i _mm256_cvtepi64_epi32 (__m256i a) - /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi32 (__m256i a) + /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt32(Vector256 value) => ConvertToVector128UInt32(value); /// - /// __m128i _mm_cvtusepi64_epi32 (__m128i a) - /// VPMOVUSQD xmm1/m128 {k1}{z}, xmm2 + /// __m128i _mm_cvtusepi64_epi32 (__m128i a) + /// VPMOVUSQD xmm1/m128 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt32WithSaturation(Vector128 value) => ConvertToVector128UInt32WithSaturation(value); /// - /// __m128i _mm256_cvtusepi64_epi32 (__m256i a) - /// VPMOVUSQD xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtusepi64_epi32 (__m256i a) + /// VPMOVUSQD xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt32WithSaturation(Vector256 value) => ConvertToVector128UInt32WithSaturation(value); /// - /// __m128i _mm_cvttpd_epu32 (__m128d a) - /// VCVTTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvttpd_epu32 (__m128d a) + /// VCVTTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128UInt32WithTruncation(Vector128 value) => ConvertToVector128UInt32WithTruncation(value); /// - /// __m128i _mm_cvttps_epu32 (__m128 a) - /// VCVTTPS2UDQ xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_cvttps_epu32 (__m128 a) + /// VCVTTPS2UDQ xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 ConvertToVector128UInt32WithTruncation(Vector128 value) => ConvertToVector128UInt32WithTruncation(value); /// - /// __m128i _mm256_cvttpd_epu32 (__m256d a) - /// VCVTTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcst + /// __m128i _mm256_cvttpd_epu32 (__m256d a) + /// VCVTTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector128 ConvertToVector128UInt32WithTruncation(Vector256 value) => ConvertToVector128UInt32WithTruncation(value); /// - /// __m128i _mm_cvtpd_epu64 (__m128d a) - /// VCVTPD2UQQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvtpd_epu64 (__m128d a) + /// VCVTPD2UQQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128UInt64(Vector128 value) => ConvertToVector128UInt64(value); /// - /// __m128i _mm_cvtps_epu64 (__m128 a) - /// VCVTPS2UQQ xmm1 {k1}{z}, xmm2/m64/m32bcst + /// __m128i _mm_cvtps_epu64 (__m128 a) + /// VCVTPS2UQQ xmm1 {k1}{z}, xmm2/m64/m32bcst /// public static Vector128 ConvertToVector128UInt64(Vector128 value) => ConvertToVector128UInt64(value); /// - /// __m128i _mm_cvttpd_epu64 (__m128d a) - /// VCVTTPD2UQQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvttpd_epu64 (__m128d a) + /// VCVTTPD2UQQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128UInt64WithTruncation(Vector128 value) => ConvertToVector128UInt64WithTruncation(value); /// - /// __m128i _mm_cvttps_epu64 (__m128 a) - /// VCVTTPS2UQQ xmm1 {k1}{z}, xmm2/m64/m32bcst + /// __m128i _mm_cvttps_epu64 (__m128 a) + /// VCVTTPS2UQQ xmm1 {k1}{z}, xmm2/m64/m32bcst /// public static Vector128 ConvertToVector128UInt64WithTruncation(Vector128 value) => ConvertToVector128UInt64WithTruncation(value); /// - /// __m256d _mm512_cvtepu32_pd (__m128i a) - /// VCVTUDQ2PD ymm1 {k1}{z}, xmm2/m128/m32bcst + /// __m256d _mm512_cvtepu32_pd (__m128i a) + /// VCVTUDQ2PD ymm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector256 ConvertToVector256Double(Vector128 value) => ConvertToVector256Double(value); /// - /// __m256d _mm256_cvtepi64_pd (__m256i a) - /// VCVTQQ2PD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_cvtepi64_pd (__m256i a) + /// VCVTQQ2PD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ConvertToVector256Double(Vector256 value) => ConvertToVector256Double(value); /// - /// __m256d _mm256_cvtepu64_pd (__m256i a) - /// VCVTUQQ2PD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_cvtepu64_pd (__m256i a) + /// VCVTUQQ2PD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ConvertToVector256Double(Vector256 value) => ConvertToVector256Double(value); /// - /// __m256i _mm256_cvtps_epi64 (__m128 a) - /// VCVTPS2QQ ymm1 {k1}{z}, xmm2/m128/m32bcst + /// __m256i _mm256_cvtps_epi64 (__m128 a) + /// VCVTPS2QQ ymm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector256 ConvertToVector256Int64(Vector128 value) => ConvertToVector256Int64(value); /// - /// __m256i _mm256_cvtpd_epi64 (__m256d a) - /// VCVTPD2QQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_cvtpd_epi64 (__m256d a) + /// VCVTPD2QQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ConvertToVector256Int64(Vector256 value) => ConvertToVector256Int64(value); /// - /// __m256i _mm256_cvttps_epi64 (__m128 a) - /// VCVTTPS2QQ ymm1 {k1}{z}, xmm2/m128/m32bcst + /// __m256i _mm256_cvttps_epi64 (__m128 a) + /// VCVTTPS2QQ ymm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector256 ConvertToVector256Int64WithTruncation(Vector128 value) => ConvertToVector256Int64WithTruncation(value); /// - /// __m256i _mm256_cvttpd_epi64 (__m256d a) - /// VCVTTPD2QQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_cvttpd_epi64 (__m256d a) + /// VCVTTPD2QQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ConvertToVector256Int64WithTruncation(Vector256 value) => ConvertToVector256Int64WithTruncation(value); /// - /// __m256 _mm256_cvtepu32_ps (__m256i a) - /// VCVTUDQ2PS ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256 _mm256_cvtepu32_ps (__m256i a) + /// VCVTUDQ2PS ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 ConvertToVector256Single(Vector256 value) => ConvertToVector256Single(value); /// - /// __m256i _mm256_cvtps_epu32 (__m256 a) - /// VCVTPS2UDQ ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_cvtps_epu32 (__m256 a) + /// VCVTPS2UDQ ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 ConvertToVector256UInt32(Vector256 value) => ConvertToVector256UInt32(value); /// - /// __m256i _mm256_cvttps_epu32 (__m256 a) - /// VCVTTPS2UDQ ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_cvttps_epu32 (__m256 a) + /// VCVTTPS2UDQ ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 ConvertToVector256UInt32WithTruncation(Vector256 value) => ConvertToVector256UInt32WithTruncation(value); /// - /// __m256i _mm256_cvtps_epu64 (__m128 a) - /// VCVTPS2UQQ ymm1 {k1}{z}, xmm2/m128/m32bcst + /// __m256i _mm256_cvtps_epu64 (__m128 a) + /// VCVTPS2UQQ ymm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector256 ConvertToVector256UInt64(Vector128 value) => ConvertToVector256UInt64(value); /// - /// __m256i _mm256_cvtpd_epu64 (__m256d a) - /// VCVTPD2UQQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_cvtpd_epu64 (__m256d a) + /// VCVTPD2UQQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ConvertToVector256UInt64(Vector256 value) => ConvertToVector256UInt64(value); /// - /// __m256i _mm256_cvttps_epu64 (__m128 a) - /// VCVTTPS2UQQ ymm1 {k1}{z}, xmm2/m128/m32bcst + /// __m256i _mm256_cvttps_epu64 (__m128 a) + /// VCVTTPS2UQQ ymm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector256 ConvertToVector256UInt64WithTruncation(Vector128 value) => ConvertToVector256UInt64WithTruncation(value); /// - /// __m256i _mm256_cvttpd_epu64 (__m256d a) - /// VCVTTPD2UQQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_cvttpd_epu64 (__m256d a) + /// VCVTTPD2UQQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ConvertToVector256UInt64WithTruncation(Vector256 value) => ConvertToVector256UInt64WithTruncation(value); /// - /// __m128i _mm_conflict_epi32 (__m128i a) - /// VPCONFLICTD xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_conflict_epi32 (__m128i a) + /// VPCONFLICTD xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 DetectConflicts(Vector128 value) => DetectConflicts(value); /// - /// __m128i _mm_conflict_epi64 (__m128i a) - /// VPCONFLICTQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_conflict_epi64 (__m128i a) + /// VPCONFLICTQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 DetectConflicts(Vector128 value) => DetectConflicts(value); /// - /// __m128i _mm_conflict_epi32 (__m128i a) - /// VPCONFLICTD xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_conflict_epi32 (__m128i a) + /// VPCONFLICTD xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 DetectConflicts(Vector128 value) => DetectConflicts(value); /// - /// __m128i _mm_conflict_epi64 (__m128i a) - /// VPCONFLICTQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_conflict_epi64 (__m128i a) + /// VPCONFLICTQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 DetectConflicts(Vector128 value) => DetectConflicts(value); /// - /// __m256i _mm256_conflict_epi32 (__m256i a) - /// VPCONFLICTD ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_conflict_epi32 (__m256i a) + /// VPCONFLICTD ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 DetectConflicts(Vector256 value) => DetectConflicts(value); /// - /// __m256i _mm256_conflict_epi64 (__m256i a) - /// VPCONFLICTQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_conflict_epi64 (__m256i a) + /// VPCONFLICTQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 DetectConflicts(Vector256 value) => DetectConflicts(value); /// - /// __m256i _mm256_conflict_epi32 (__m256i a) - /// VPCONFLICTD ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_conflict_epi32 (__m256i a) + /// VPCONFLICTD ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 DetectConflicts(Vector256 value) => DetectConflicts(value); /// - /// __m256i _mm256_conflict_epi64 (__m256i a) - /// VPCONFLICTQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_conflict_epi64 (__m256i a) + /// VPCONFLICTQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 DetectConflicts(Vector256 value) => DetectConflicts(value); /// - /// __m128d _mm_div_round_sd (__m128d a, __m128d b, int rounding) - /// VDIVSS xmm1, xmm2, xmm3 {er} + /// __m128d _mm_div_round_sd (__m128d a, __m128d b, int rounding) + /// VDIVSS xmm1, xmm2, xmm3 {er} /// public static Vector128 DivideScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => DivideScalar(left, right, mode); /// - /// __m128 _mm_div_round_ss (__m128 a, __m128 b, int rounding) - /// VDIVSD xmm1, xmm2, xmm3 {er} + /// __m128 _mm_div_round_ss (__m128 a, __m128 b, int rounding) + /// VDIVSD xmm1, xmm2, xmm3 {er} /// public static Vector128 DivideScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => DivideScalar(left, right, mode); /// - /// __m128d _mm_fixupimm_pd(__m128d a, __m128d b, __m128i tbl, int imm); - /// VFIXUPIMMPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128d _mm_fixupimm_pd(__m128d a, __m128d b, __m128i tbl, int imm); + /// VFIXUPIMMPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 Fixup(Vector128 left, Vector128 right, Vector128 table, [ConstantExpected] byte control) => Fixup(left, right, table, control); /// - /// __m128 _mm_fixupimm_ps(__m128 a, __m128 b, __m128i tbl, int imm); - /// VFIXUPIMMPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128 _mm_fixupimm_ps(__m128 a, __m128 b, __m128i tbl, int imm); + /// VFIXUPIMMPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 Fixup(Vector128 left, Vector128 right, Vector128 table, [ConstantExpected] byte control) => Fixup(left, right, table, control); /// - /// __m256d _mm256_fixupimm_pd(__m256d a, __m256d b, __m256i tbl, int imm); - /// VFIXUPIMMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256d _mm256_fixupimm_pd(__m256d a, __m256d b, __m256i tbl, int imm); + /// VFIXUPIMMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 Fixup(Vector256 left, Vector256 right, Vector256 table, [ConstantExpected] byte control) => Fixup(left, right, table, control); /// - /// __m256 _mm256_fixupimm_ps(__m256 a, __m256 b, __m256i tbl, int imm); - /// VFIXUPIMMPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256 _mm256_fixupimm_ps(__m256 a, __m256 b, __m256i tbl, int imm); + /// VFIXUPIMMPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 Fixup(Vector256 left, Vector256 right, Vector256 table, [ConstantExpected] byte control) => Fixup(left, right, table, control); /// - /// __m128d _mm_fixupimm_sd(__m128d a, __m128d b, __m128i tbl, int imm); - /// VFIXUPIMMSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 + /// __m128d _mm_fixupimm_sd(__m128d a, __m128d b, __m128i tbl, int imm); + /// VFIXUPIMMSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 /// public static Vector128 FixupScalar(Vector128 left, Vector128 right, Vector128 table, [ConstantExpected] byte control) => FixupScalar(left, right, table, control); /// - /// __m128 _mm_fixupimm_ss(__m128 a, __m128 b, __m128i tbl, int imm); - /// VFIXUPIMMSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 + /// __m128 _mm_fixupimm_ss(__m128 a, __m128 b, __m128i tbl, int imm); + /// VFIXUPIMMSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 /// public static Vector128 FixupScalar(Vector128 left, Vector128 right, Vector128 table, [ConstantExpected] byte control) => FixupScalar(left, right, table, control); /// - /// __m128d _mm_fnmadd_round_sd (__m128d a, __m128d b, __m128d c, int r) - /// VFNMADDSD xmm1, xmm2, xmm3 {er} + /// __m128d _mm_fnmadd_round_sd (__m128d a, __m128d b, __m128d c, int r) + /// VFNMADDSD xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplyAddNegatedScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplyAddNegatedScalar(a, b, c, mode); /// - /// __m128 _mm_fnmadd_round_ss (__m128 a, __m128 b, __m128 c, int r) - /// VFNMADDSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_fnmadd_round_ss (__m128 a, __m128 b, __m128 c, int r) + /// VFNMADDSS xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplyAddNegatedScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplyAddNegatedScalar(a, b, c, mode); /// - /// __m128d _mm_fmadd_round_sd (__m128d a, __m128d b, __m128d c, int r) - /// VFMADDSD xmm1, xmm2, xmm3 {er} + /// __m128d _mm_fmadd_round_sd (__m128d a, __m128d b, __m128d c, int r) + /// VFMADDSD xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplyAddScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplyAddScalar(a, b, c, mode); /// - /// __m128 _mm_fmadd_round_ss (__m128 a, __m128 b, __m128 c, int r) - /// VFMADDSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_fmadd_round_ss (__m128 a, __m128 b, __m128 c, int r) + /// VFMADDSS xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplyAddScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplyAddScalar(a, b, c, mode); /// - /// __m128d _mm_fnmsub_round_sd (__m128d a, __m128d b, __m128d c, int r) - /// VFNMSUBSS xmm1, xmm2, xmm3 {er} + /// __m128d _mm_fnmsub_round_sd (__m128d a, __m128d b, __m128d c, int r) + /// VFNMSUBSS xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplySubtractNegatedScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplySubtractNegatedScalar(a, b, c, mode); /// - /// __m128 _mm_fnmsub_round_ss (__m128 a, __m128 b, __m128 c, int r) - /// VFNMSUBSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_fnmsub_round_ss (__m128 a, __m128 b, __m128 c, int r) + /// VFNMSUBSS xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplySubtractNegatedScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplySubtractNegatedScalar(a, b, c, mode); /// - /// __m128d _mm_fmsub_round_sd (__m128d a, __m128d b, __m128d c, int r) - /// VFMSUBSS xmm1, xmm2, xmm3 {er} + /// __m128d _mm_fmsub_round_sd (__m128d a, __m128d b, __m128d c, int r) + /// VFMSUBSS xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplySubtractScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplySubtractScalar(a, b, c, mode); /// - /// __m128 _mm_fmsub_round_ss (__m128 a, __m128 b, __m128 c, int r) - /// VFMSUBSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_fmsub_round_ss (__m128 a, __m128 b, __m128 c, int r) + /// VFMSUBSS xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplySubtractScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplySubtractScalar(a, b, c, mode); /// - /// __m128d _mm_getexp_pd (__m128d a) - /// VGETEXPPD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_getexp_pd (__m128d a) + /// VGETEXPPD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 GetExponent(Vector128 value) => GetExponent(value); /// - /// __m128 _mm_getexp_ps (__m128 a) - /// VGETEXPPS xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128 _mm_getexp_ps (__m128 a) + /// VGETEXPPS xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 GetExponent(Vector128 value) => GetExponent(value); /// - /// __m256d _mm256_getexp_pd (__m256d a) - /// VGETEXPPD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_getexp_pd (__m256d a) + /// VGETEXPPD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 GetExponent(Vector256 value) => GetExponent(value); /// - /// __m256 _mm256_getexp_ps (__m256 a) - /// VGETEXPPS ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256 _mm256_getexp_ps (__m256 a) + /// VGETEXPPS ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 GetExponent(Vector256 value) => GetExponent(value); /// - /// __m128d _mm_getexp_sd (__m128d a, __m128d b) - /// VGETEXPSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128d _mm_getexp_sd (__m128d a, __m128d b) + /// VGETEXPSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 GetExponentScalar(Vector128 upper, Vector128 value) => GetExponentScalar(upper, value); /// - /// __m128d _mm_getexp_sd (__m128d a) - /// VGETEXPSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} + /// __m128d _mm_getexp_sd (__m128d a) + /// VGETEXPSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} /// public static Vector128 GetExponentScalar(Vector128 value) => GetExponentScalar(value); /// - /// __m128 _mm_getexp_ss (__m128 a, __m128 b) - /// VGETEXPSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_getexp_ss (__m128 a, __m128 b) + /// VGETEXPSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 GetExponentScalar(Vector128 upper, Vector128 value) => GetExponentScalar(upper, value); /// - /// __m128 _mm_getexp_ss (__m128 a) - /// VGETEXPSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} + /// __m128 _mm_getexp_ss (__m128 a) + /// VGETEXPSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} /// public static Vector128 GetExponentScalar(Vector128 value) => GetExponentScalar(value); /// - /// __m128d _mm_getmant_pd (__m128d a) - /// VGETMANTPD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_getmant_pd (__m128d a) + /// VGETMANTPD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 GetMantissa(Vector128 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) => GetMantissa(value, control); /// - /// __m128 _mm_getmant_ps (__m128 a) - /// VGETMANTPS xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128 _mm_getmant_ps (__m128 a) + /// VGETMANTPS xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 GetMantissa(Vector128 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) => GetMantissa(value, control); /// - /// __m256d _mm256_getmant_pd (__m256d a) - /// VGETMANTPD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_getmant_pd (__m256d a) + /// VGETMANTPD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 GetMantissa(Vector256 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) => GetMantissa(value, control); /// - /// __m256 _mm256_getmant_ps (__m256 a) - /// VGETMANTPS ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256 _mm256_getmant_ps (__m256 a) + /// VGETMANTPS ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 GetMantissa(Vector256 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) => GetMantissa(value, control); /// - /// __m128d _mm_getmant_sd (__m128d a, __m128d b) - /// VGETMANTSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128d _mm_getmant_sd (__m128d a, __m128d b) + /// VGETMANTSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 GetMantissaScalar(Vector128 upper, Vector128 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) => GetMantissaScalar(upper, value, control); /// - /// __m128d _mm_getmant_sd (__m128d a) - /// VGETMANTSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} + /// __m128d _mm_getmant_sd (__m128d a) + /// VGETMANTSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} /// public static Vector128 GetMantissaScalar(Vector128 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) => GetMantissaScalar(value, control); /// - /// __m128 _mm_getmant_ss (__m128 a, __m128 b) - /// VGETMANTSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_getmant_ss (__m128 a, __m128 b) + /// VGETMANTSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 GetMantissaScalar(Vector128 upper, Vector128 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) => GetMantissaScalar(upper, value, control); /// - /// __m128 _mm_getmant_ss (__m128 a) - /// VGETMANTSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} + /// __m128 _mm_getmant_ss (__m128 a) + /// VGETMANTSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} /// public static Vector128 GetMantissaScalar(Vector128 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) => GetMantissaScalar(value, control); /// - /// __m128i _mm_lzcnt_epi32 (__m128i a) - /// VPLZCNTD xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_lzcnt_epi32 (__m128i a) + /// VPLZCNTD xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 LeadingZeroCount(Vector128 value) => LeadingZeroCount(value); /// - /// __m128i _mm_lzcnt_epi64 (__m128i a) - /// VPLZCNTQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_lzcnt_epi64 (__m128i a) + /// VPLZCNTQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 LeadingZeroCount(Vector128 value) => LeadingZeroCount(value); /// - /// __m128i _mm_lzcnt_epi32 (__m128i a) - /// VPLZCNTD xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_lzcnt_epi32 (__m128i a) + /// VPLZCNTD xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 LeadingZeroCount(Vector128 value) => LeadingZeroCount(value); /// - /// __m128i _mm_lzcnt_epi64 (__m128i a) - /// VPLZCNTQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_lzcnt_epi64 (__m128i a) + /// VPLZCNTQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 LeadingZeroCount(Vector128 value) => LeadingZeroCount(value); /// - /// __m256i _mm256_lzcnt_epi32 (__m256i a) - /// VPLZCNTD ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_lzcnt_epi32 (__m256i a) + /// VPLZCNTD ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 LeadingZeroCount(Vector256 value) => LeadingZeroCount(value); /// - /// __m256i _mm256_lzcnt_epi64 (__m256i a) - /// VPLZCNTQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_lzcnt_epi64 (__m256i a) + /// VPLZCNTQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 LeadingZeroCount(Vector256 value) => LeadingZeroCount(value); /// - /// __m256i _mm256_lzcnt_epi32 (__m256i a) - /// VPLZCNTD ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_lzcnt_epi32 (__m256i a) + /// VPLZCNTD ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 LeadingZeroCount(Vector256 value) => LeadingZeroCount(value); /// - /// __m256i _mm256_lzcnt_epi64 (__m256i a) - /// VPLZCNTQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_lzcnt_epi64 (__m256i a) + /// VPLZCNTQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 LeadingZeroCount(Vector256 value) => LeadingZeroCount(value); /// - /// __m128i _mm_max_epi64 (__m128i a, __m128i b) - /// VPMAXSQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_max_epi64 (__m128i a, __m128i b) + /// VPMAXSQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// - /// __m128i _mm_max_epu64 (__m128i a, __m128i b) - /// VPMAXUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_max_epu64 (__m128i a, __m128i b) + /// VPMAXUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// - /// __m256i _mm256_max_epi64 (__m256i a, __m256i b) - /// VPMAXSQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_max_epi64 (__m256i a, __m256i b) + /// VPMAXSQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Max(Vector256 left, Vector256 right) => Max(left, right); /// - /// __m256i _mm256_max_epu64 (__m256i a, __m256i b) - /// VPMAXUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_max_epu64 (__m256i a, __m256i b) + /// VPMAXUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Max(Vector256 left, Vector256 right) => Max(left, right); /// - /// __m128i _mm_min_epi64 (__m128i a, __m128i b) - /// VPMINSQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_min_epi64 (__m128i a, __m128i b) + /// VPMINSQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// - /// __m128i _mm_min_epu64 (__m128i a, __m128i b) - /// VPMINUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_min_epu64 (__m128i a, __m128i b) + /// VPMINUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// - /// __m256i _mm256_min_epi64 (__m256i a, __m256i b) - /// VPMINSQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_min_epi64 (__m256i a, __m256i b) + /// VPMINSQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Min(Vector256 left, Vector256 right) => Min(left, right); /// - /// __m256i _mm256_min_epu64 (__m256i a, __m256i b) - /// VPMINUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_min_epu64 (__m256i a, __m256i b) + /// VPMINUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Min(Vector256 left, Vector256 right) => Min(left, right); /// - /// __m128i _mm_mullo_epi64 (__m128i a, __m128i b) - /// VPMULLQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_mullo_epi64 (__m128i a, __m128i b) + /// VPMULLQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiplyLow(Vector128 left, Vector128 right) => MultiplyLow(left, right); /// - /// __m128i _mm_mullo_epi64 (__m128i a, __m128i b) - /// VPMULLQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_mullo_epi64 (__m128i a, __m128i b) + /// VPMULLQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiplyLow(Vector128 left, Vector128 right) => MultiplyLow(left, right); /// - /// __m256i _mm256_mullo_epi64 (__m256i a, __m256i b) - /// VPMULLQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_mullo_epi64 (__m256i a, __m256i b) + /// VPMULLQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiplyLow(Vector256 left, Vector256 right) => MultiplyLow(left, right); /// - /// __m256i _mm256_mullo_epi64 (__m256i a, __m256i b) - /// VPMULLQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_mullo_epi64 (__m256i a, __m256i b) + /// VPMULLQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiplyLow(Vector256 left, Vector256 right) => MultiplyLow(left, right); /// - /// __m128d _mm_mul_round_sd (__m128d a, __m128d b, int rounding) - /// VMULSD xmm1, xmm2, xmm3 {er} + /// __m128d _mm_mul_round_sd (__m128d a, __m128d b, int rounding) + /// VMULSD xmm1, xmm2, xmm3 {er} /// public static Vector128 MultiplyScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => MultiplyScalar(left, right, mode); /// - /// __m128 _mm_mul_round_ss (__m128 a, __m128 b, int rounding) - /// VMULSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_mul_round_ss (__m128 a, __m128 b, int rounding) + /// VMULSS xmm1, xmm2, xmm3 {er} /// public static Vector128 MultiplyScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => MultiplyScalar(left, right, mode); /// - /// __m128i _mm_multishift_epi64_epi8(__m128i a, __m128i b) - /// VPMULTISHIFTQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_multishift_epi64_epi8(__m128i a, __m128i b) + /// VPMULTISHIFTQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiShift(Vector128 control, Vector128 value) => MultiShift(control, value); /// - /// __m128i _mm_multishift_epi64_epi8(__m128i a, __m128i b) - /// VPMULTISHIFTQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_multishift_epi64_epi8(__m128i a, __m128i b) + /// VPMULTISHIFTQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiShift(Vector128 control, Vector128 value) => MultiShift(control, value); /// - /// __m256i _mm256_multishift_epi64_epi8(__m256i a, __m256i b) - /// VPMULTISHIFTQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_multishift_epi64_epi8(__m256i a, __m256i b) + /// VPMULTISHIFTQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiShift(Vector256 control, Vector256 value) => MultiShift(control, value); /// - /// __m256i _mm256_multishift_epi64_epi8(__m256i a, __m256i b) - /// VPMULTISHIFTQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_multishift_epi64_epi8(__m256i a, __m256i b) + /// VPMULTISHIFTQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiShift(Vector256 control, Vector256 value) => MultiShift(control, value); /// - /// __m256i _mm256_permutevar16x16_epi16 (__m256i a, __m256i b) - /// VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutevar16x16_epi16 (__m256i a, __m256i b) + /// VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar16x16(Vector256 left, Vector256 control) => PermuteVar16x16(left, control); /// - /// __m256i _mm256_permutevar16x16_epi16 (__m256i a, __m256i b) - /// VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutevar16x16_epi16 (__m256i a, __m256i b) + /// VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar16x16(Vector256 left, Vector256 control) => PermuteVar16x16(left, control); /// - /// __m256i _mm256_permutex2var_epi16 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2W ymm1 {k1}{z}, ymm2, ymm3/m256 - /// VPERMT2W ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutex2var_epi16 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2W ymm1 {k1}{z}, ymm2, ymm3/m256 + /// VPERMT2W ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar16x16x2(Vector256 lower, Vector256 indices, Vector256 upper) => PermuteVar16x16x2(lower, indices, upper); /// - /// __m256i _mm256_permutex2var_epi16 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2W ymm1 {k1}{z}, ymm2, ymm3/m256 - /// VPERMT2W ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutex2var_epi16 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2W ymm1 {k1}{z}, ymm2, ymm3/m256 + /// VPERMT2W ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar16x16x2(Vector256 lower, Vector256 indices, Vector256 upper) => PermuteVar16x16x2(lower, indices, upper); /// - /// __m128i _mm_permutevar64x8_epi8 (__m128i a, __m128i b) - /// VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutevar64x8_epi8 (__m128i a, __m128i b) + /// VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar16x8(Vector128 left, Vector128 control) => PermuteVar16x8(left, control); /// - /// __m128i _mm_permutevar64x8_epi8 (__m128i a, __m128i b) - /// VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutevar64x8_epi8 (__m128i a, __m128i b) + /// VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar16x8(Vector128 left, Vector128 control) => PermuteVar16x8(left, control); /// - /// __m128i _mm_permutex2var_epi8 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2B xmm1 {k1}{z}, xmm2, xmm3/m128 - /// VPERMT2B xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutex2var_epi8 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2B xmm1 {k1}{z}, xmm2, xmm3/m128 + /// VPERMT2B xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar16x8x2(Vector128 lower, Vector128 indices, Vector128 upper) => PermuteVar16x8x2(lower, indices, upper); /// - /// __m128i _mm_permutex2var_epi8 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2B xmm1 {k1}{z}, xmm2, xmm3/m128 - /// VPERMT2B xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutex2var_epi8 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2B xmm1 {k1}{z}, xmm2, xmm3/m128 + /// VPERMT2B xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar16x8x2(Vector128 lower, Vector128 indices, Vector128 upper) => PermuteVar16x8x2(lower, indices, upper); /// - /// __m128d _mm_permutex2var_pd (__m128d a, __m128i idx, __m128i b) - /// VPERMI2PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst - /// VPERMT2PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_permutex2var_pd (__m128d a, __m128i idx, __m128i b) + /// VPERMI2PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// VPERMT2PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 PermuteVar2x64x2(Vector128 lower, Vector128 indices, Vector128 upper) => PermuteVar2x64x2(lower, indices, upper); /// - /// __m128i _mm_permutex2var_epi64 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst - /// VPERMT2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_permutex2var_epi64 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// VPERMT2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 PermuteVar2x64x2(Vector128 lower, Vector128 indices, Vector128 upper) => PermuteVar2x64x2(lower, indices, upper); /// - /// __m128i _mm_permutex2var_epi64 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst - /// VPERMT2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_permutex2var_epi64 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// VPERMT2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 PermuteVar2x64x2(Vector128 lower, Vector128 indices, Vector128 upper) => PermuteVar2x64x2(lower, indices, upper); /// - /// __m256i _mm256_permutevar64x8_epi8 (__m256i a, __m256i b) - /// VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutevar64x8_epi8 (__m256i a, __m256i b) + /// VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar32x8(Vector256 left, Vector256 control) => PermuteVar32x8(left, control); /// - /// __m256i _mm256_permutevar64x8_epi8 (__m256i a, __m256i b) - /// VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutevar64x8_epi8 (__m256i a, __m256i b) + /// VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar32x8(Vector256 left, Vector256 control) => PermuteVar32x8(left, control); /// - /// __m256i _mm256_permutex2var_epi8 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2B ymm1 {k1}{z}, ymm2, ymm3/m256 - /// VPERMT2B ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutex2var_epi8 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2B ymm1 {k1}{z}, ymm2, ymm3/m256 + /// VPERMT2B ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar32x8x2(Vector256 lower, Vector256 indices, Vector256 upper) => PermuteVar32x8x2(lower, indices, upper); /// - /// __m256i _mm256_permutex2var_epi8 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2B ymm1 {k1}{z}, ymm2, ymm3/m256 - /// VPERMT2B ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutex2var_epi8 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2B ymm1 {k1}{z}, ymm2, ymm3/m256 + /// VPERMT2B ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar32x8x2(Vector256 lower, Vector256 indices, Vector256 upper) => PermuteVar32x8x2(lower, indices, upper); /// - /// __m128 _mm_permutex2var_ps (__m128 a, __m128i idx, __m128i b) - /// VPERMI2PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst - /// VPERMT2PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_permutex2var_ps (__m128 a, __m128i idx, __m128i b) + /// VPERMI2PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// VPERMT2PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 PermuteVar4x32x2(Vector128 lower, Vector128 indices, Vector128 upper) => PermuteVar4x32x2(lower, indices, upper); /// - /// __m128i _mm_permutex2var_epi32 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst - /// VPERMT2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_permutex2var_epi32 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// VPERMT2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 PermuteVar4x32x2(Vector128 lower, Vector128 indices, Vector128 upper) => PermuteVar4x32x2(lower, indices, upper); /// - /// __m128i _mm_permutex2var_epi32 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst - /// VPERMT2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_permutex2var_epi32 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// VPERMT2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 PermuteVar4x32x2(Vector128 lower, Vector128 indices, Vector128 upper) => PermuteVar4x32x2(lower, indices, upper); /// - /// __m256d _mm256_permute4x64_pd (__m256d a, __m256i b) - /// VPERMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_permute4x64_pd (__m256d a, __m256i b) + /// VPERMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar4x64(Vector256 value, Vector256 control) => PermuteVar4x64(value, control); /// - /// __m256i _mm256_permute4x64_epi64 (__m256i a, __m256i b) - /// VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_permute4x64_epi64 (__m256i a, __m256i b) + /// VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar4x64(Vector256 value, Vector256 control) => PermuteVar4x64(value, control); /// - /// __m256i _mm256_permute4x64_pd (__m256d a, __m256i b) - /// VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_permute4x64_pd (__m256d a, __m256i b) + /// VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar4x64(Vector256 value, Vector256 control) => PermuteVar4x64(value, control); /// - /// __m256d _mm256_permutex2var_pd (__m256d a, __m256i idx, __m256i b) - /// VPERMI2PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst - /// VPERMT2PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_permutex2var_pd (__m256d a, __m256i idx, __m256i b) + /// VPERMI2PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// VPERMT2PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar4x64x2(Vector256 lower, Vector256 indices, Vector256 upper) => PermuteVar4x64x2(lower, indices, upper); /// - /// __m256i _mm256_permutex2var_epi64 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst - /// VPERMT2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_permutex2var_epi64 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// VPERMT2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar4x64x2(Vector256 lower, Vector256 indices, Vector256 upper) => PermuteVar4x64x2(lower, indices, upper); /// - /// __m256i _mm256_permutex2var_epi64 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst - /// VPERMT2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_permutex2var_epi64 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// VPERMT2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar4x64x2(Vector256 lower, Vector256 indices, Vector256 upper) => PermuteVar4x64x2(lower, indices, upper); /// - /// __m128i _mm_permutevar8x16_epi16 (__m128i a, __m128i b) - /// VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutevar8x16_epi16 (__m128i a, __m128i b) + /// VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar8x16(Vector128 left, Vector128 control) => PermuteVar8x16(left, control); /// - /// __m128i _mm_permutevar8x16_epi16 (__m128i a, __m128i b) - /// VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutevar8x16_epi16 (__m128i a, __m128i b) + /// VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar8x16(Vector128 left, Vector128 control) => PermuteVar8x16(left, control); /// - /// __m128i _mm_permutex2var_epi16 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2W xmm1 {k1}{z}, xmm2, xmm3/m128 - /// VPERMT2W xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutex2var_epi16 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2W xmm1 {k1}{z}, xmm2, xmm3/m128 + /// VPERMT2W xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar8x16x2(Vector128 lower, Vector128 indices, Vector128 upper) => PermuteVar8x16x2(lower, indices, upper); /// - /// __m128i _mm_permutex2var_epi16 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2W xmm1 {k1}{z}, xmm2, xmm3/m128 - /// VPERMT2W xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutex2var_epi16 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2W xmm1 {k1}{z}, xmm2, xmm3/m128 + /// VPERMT2W xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar8x16x2(Vector128 lower, Vector128 indices, Vector128 upper) => PermuteVar8x16x2(lower, indices, upper); /// - /// __m256 _mm256_permutex2var_ps (__m256 a, __m256i idx, __m256i b) - /// VPERMI2PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst - /// VPERMT2PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_permutex2var_ps (__m256 a, __m256i idx, __m256i b) + /// VPERMI2PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// VPERMT2PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 PermuteVar8x32x2(Vector256 lower, Vector256 indices, Vector256 upper) => PermuteVar8x32x2(lower, indices, upper); /// - /// __m256i _mm256_permutex2var_epi32 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst - /// VPERMT2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_permutex2var_epi32 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// VPERMT2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 PermuteVar8x32x2(Vector256 lower, Vector256 indices, Vector256 upper) => PermuteVar8x32x2(lower, indices, upper); /// - /// __m256i _mm256_permutex2var_epi32 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst - /// VPERMT2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_permutex2var_epi32 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// VPERMT2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 PermuteVar8x32x2(Vector256 lower, Vector256 indices, Vector256 upper) => PermuteVar8x32x2(lower, indices, upper); /// - /// __m128d _mm_range_pd(__m128d a, __m128d b, int imm); - /// VRANGEPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128d _mm_range_pd(__m128d a, __m128d b, int imm); + /// VRANGEPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 Range(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => Range(left, right, control); /// - /// __m128 _mm_range_ps(__m128 a, __m128 b, int imm); - /// VRANGEPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128 _mm_range_ps(__m128 a, __m128 b, int imm); + /// VRANGEPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 Range(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => Range(left, right, control); /// - /// __m256d _mm256_range_pd(__m256d a, __m256d b, int imm); - /// VRANGEPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256d _mm256_range_pd(__m256d a, __m256d b, int imm); + /// VRANGEPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 Range(Vector256 left, Vector256 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => Range(left, right, control); /// - /// __m256 _mm256_range_ps(__m256 a, __m256 b, int imm); - /// VRANGEPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256 _mm256_range_ps(__m256 a, __m256 b, int imm); + /// VRANGEPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 Range(Vector256 left, Vector256 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => Range(left, right, control); /// - /// __m128d _mm_range_sd(__m128d a, __m128d b, int imm); - /// VRANGESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 + /// __m128d _mm_range_sd(__m128d a, __m128d b, int imm); + /// VRANGESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 /// public static Vector128 RangeScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => RangeScalar(left, right, control); /// - /// __m128 _mm_range_ss(__m128 a, __m128 b, int imm); - /// VRANGESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 + /// __m128 _mm_range_ss(__m128 a, __m128 b, int imm); + /// VRANGESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 /// public static Vector128 RangeScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => RangeScalar(left, right, control); /// - /// __m128d _mm_rcp14_pd (__m128d a, __m128d b) - /// VRCP14PD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_rcp14_pd (__m128d a, __m128d b) + /// VRCP14PD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 Reciprocal14(Vector128 value) => Reciprocal14(value); /// - /// __m128 _mm_rcp14_ps (__m128 a, __m128 b) - /// VRCP14PS xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128 _mm_rcp14_ps (__m128 a, __m128 b) + /// VRCP14PS xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 Reciprocal14(Vector128 value) => Reciprocal14(value); /// - /// __m256d _mm256_rcp14_pd (__m256d a, __m256d b) - /// VRCP14PD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_rcp14_pd (__m256d a, __m256d b) + /// VRCP14PD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 Reciprocal14(Vector256 value) => Reciprocal14(value); /// - /// __m256 _mm256_rcp14_ps (__m256 a, __m256 b) - /// VRCP14PS ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256 _mm256_rcp14_ps (__m256 a, __m256 b) + /// VRCP14PS ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 Reciprocal14(Vector256 value) => Reciprocal14(value); /// - /// __m128d _mm_rcp14_sd (__m128d a, __m128d b) - /// VRCP14SD xmm1 {k1}{z}, xmm2, xmm3/m64 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128d _mm_rcp14_sd (__m128d a, __m128d b) + /// VRCP14SD xmm1 {k1}{z}, xmm2, xmm3/m64 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 Reciprocal14Scalar(Vector128 upper, Vector128 value) => Reciprocal14Scalar(upper, value); /// - /// __m128d _mm_rcp14_sd (__m128d a) - /// VRCP14SD xmm1 {k1}{z}, xmm2, xmm3/m64 + /// __m128d _mm_rcp14_sd (__m128d a) + /// VRCP14SD xmm1 {k1}{z}, xmm2, xmm3/m64 /// public static Vector128 Reciprocal14Scalar(Vector128 value) => Reciprocal14Scalar(value); /// - /// __m128 _mm_rcp14_ss (__m128 a, __m128 b) - /// VRCP14SS xmm1 {k1}{z}, xmm2, xmm3/m32 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_rcp14_ss (__m128 a, __m128 b) + /// VRCP14SS xmm1 {k1}{z}, xmm2, xmm3/m32 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 Reciprocal14Scalar(Vector128 upper, Vector128 value) => Reciprocal14Scalar(upper, value); /// - /// __m128 _mm_rcp14_ss (__m128 a) - /// VRCP14SS xmm1 {k1}{z}, xmm2, xmm3/m32 + /// __m128 _mm_rcp14_ss (__m128 a) + /// VRCP14SS xmm1 {k1}{z}, xmm2, xmm3/m32 /// public static Vector128 Reciprocal14Scalar(Vector128 value) => Reciprocal14Scalar(value); /// - /// __m128d _mm_rsqrt14_pd (__m128d a, __m128d b) - /// VRSQRT14PD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_rsqrt14_pd (__m128d a, __m128d b) + /// VRSQRT14PD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ReciprocalSqrt14(Vector128 value) => ReciprocalSqrt14(value); /// - /// __m128 _mm_rsqrt14_ps (__m128 a, __m128 b) - /// VRSQRT14PS xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128 _mm_rsqrt14_ps (__m128 a, __m128 b) + /// VRSQRT14PS xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 ReciprocalSqrt14(Vector128 value) => ReciprocalSqrt14(value); /// - /// __m256d _mm256_rsqrt14_pd (__m256d a, __m256d b) - /// VRSQRT14PD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_rsqrt14_pd (__m256d a, __m256d b) + /// VRSQRT14PD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ReciprocalSqrt14(Vector256 value) => ReciprocalSqrt14(value); /// - /// __m256 _mm256_rsqrt14_ps (__m256 a, __m256 b) - /// VRSQRT14PS ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256 _mm256_rsqrt14_ps (__m256 a, __m256 b) + /// VRSQRT14PS ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 ReciprocalSqrt14(Vector256 value) => ReciprocalSqrt14(value); /// - /// __m128d _mm_rsqrt14_sd (__m128d a, __m128d b) - /// VRSQRT14SD xmm1 {k1}{z}, xmm2, xmm3/m64 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128d _mm_rsqrt14_sd (__m128d a, __m128d b) + /// VRSQRT14SD xmm1 {k1}{z}, xmm2, xmm3/m64 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 ReciprocalSqrt14Scalar(Vector128 upper, Vector128 value) => ReciprocalSqrt14Scalar(upper, value); /// - /// __m128d _mm_rsqrt14_sd (__m128d a) - /// VRSQRT14SD xmm1 {k1}{z}, xmm2, xmm3/m64 + /// __m128d _mm_rsqrt14_sd (__m128d a) + /// VRSQRT14SD xmm1 {k1}{z}, xmm2, xmm3/m64 /// public static Vector128 ReciprocalSqrt14Scalar(Vector128 value) => ReciprocalSqrt14Scalar(value); /// - /// __m128 _mm_rsqrt14_ss (__m128 a, __m128 b) - /// VRSQRT14SS xmm1 {k1}{z}, xmm2, xmm3/m32 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_rsqrt14_ss (__m128 a, __m128 b) + /// VRSQRT14SS xmm1 {k1}{z}, xmm2, xmm3/m32 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 ReciprocalSqrt14Scalar(Vector128 upper, Vector128 value) => ReciprocalSqrt14Scalar(upper, value); /// - /// __m128 _mm_rsqrt14_ss (__m128 a) - /// VRSQRT14SS xmm1 {k1}{z}, xmm2, xmm3/m32 + /// __m128 _mm_rsqrt14_ss (__m128 a) + /// VRSQRT14SS xmm1 {k1}{z}, xmm2, xmm3/m32 /// public static Vector128 ReciprocalSqrt14Scalar(Vector128 value) => ReciprocalSqrt14Scalar(value); /// - /// __m128d _mm_reduce_pd(__m128d a, int imm); - /// VREDUCEPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128d _mm_reduce_pd(__m128d a, int imm); + /// VREDUCEPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 Reduce(Vector128 value, [ConstantExpected] byte control) => Reduce(value, control); /// - /// __m128 _mm_reduce_ps(__m128 a, int imm); - /// VREDUCEPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128 _mm_reduce_ps(__m128 a, int imm); + /// VREDUCEPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 Reduce(Vector128 value, [ConstantExpected] byte control) => Reduce(value, control); /// - /// __m256d _mm256_reduce_pd(__m256d a, int imm); - /// VREDUCEPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256d _mm256_reduce_pd(__m256d a, int imm); + /// VREDUCEPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 Reduce(Vector256 value, [ConstantExpected] byte control) => Reduce(value, control); /// - /// __m256 _mm256_reduce_ps(__m256 a, int imm); - /// VREDUCEPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256 _mm256_reduce_ps(__m256 a, int imm); + /// VREDUCEPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 Reduce(Vector256 value, [ConstantExpected] byte control) => Reduce(value, control); /// - /// __m128d _mm_reduce_sd(__m128d a, __m128d b, int imm); - /// VREDUCESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128d _mm_reduce_sd(__m128d a, __m128d b, int imm); + /// VREDUCESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 ReduceScalar(Vector128 upper, Vector128 value, [ConstantExpected] byte control) => ReduceScalar(upper, value, control); /// - /// __m128d _mm_reduce_sd(__m128d a, int imm); - /// VREDUCESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 + /// __m128d _mm_reduce_sd(__m128d a, int imm); + /// VREDUCESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 /// public static Vector128 ReduceScalar(Vector128 value, [ConstantExpected] byte control) => ReduceScalar(value, control); /// - /// __m128 _mm_reduce_ss(__m128 a, __m128 b, int imm); - /// VREDUCESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_reduce_ss(__m128 a, __m128 b, int imm); + /// VREDUCESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 ReduceScalar(Vector128 upper, Vector128 value, [ConstantExpected] byte control) => ReduceScalar(upper, value, control); /// - /// __m128 _mm_reduce_ss(__m128 a, int imm); - /// VREDUCESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 + /// __m128 _mm_reduce_ss(__m128 a, int imm); + /// VREDUCESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 /// public static Vector128 ReduceScalar(Vector128 value, [ConstantExpected] byte control) => ReduceScalar(value, control); /// - /// __m128i _mm_rol_epi32 (__m128i a, int imm8) - /// VPROLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128i _mm_rol_epi32 (__m128i a, int imm8) + /// VPROLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 RotateLeft(Vector128 value, [ConstantExpected] byte count) => RotateLeft(value, count); /// - /// __m128i _mm_rol_epi64 (__m128i a, int imm8) - /// VPROLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128i _mm_rol_epi64 (__m128i a, int imm8) + /// VPROLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 RotateLeft(Vector128 value, [ConstantExpected] byte count) => RotateLeft(value, count); /// - /// __m128i _mm_rol_epi32 (__m128i a, int imm8) - /// VPROLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128i _mm_rol_epi32 (__m128i a, int imm8) + /// VPROLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 RotateLeft(Vector128 value, [ConstantExpected] byte count) => RotateLeft(value, count); /// - /// __m128i _mm_rol_epi64 (__m128i a, int imm8) - /// VPROLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128i _mm_rol_epi64 (__m128i a, int imm8) + /// VPROLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 RotateLeft(Vector128 value, [ConstantExpected] byte count) => RotateLeft(value, count); /// - /// __m256i _mm256_rol_epi32 (__m256i a, int imm8) - /// VPROLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256i _mm256_rol_epi32 (__m256i a, int imm8) + /// VPROLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 RotateLeft(Vector256 value, [ConstantExpected] byte count) => RotateLeft(value, count); /// - /// __m256i _mm256_rol_epi64 (__m256i a, int imm8) - /// VPROLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256i _mm256_rol_epi64 (__m256i a, int imm8) + /// VPROLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 RotateLeft(Vector256 value, [ConstantExpected] byte count) => RotateLeft(value, count); /// - /// __m256i _mm256_rol_epi32 (__m256i a, int imm8) - /// VPROLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256i _mm256_rol_epi32 (__m256i a, int imm8) + /// VPROLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 RotateLeft(Vector256 value, [ConstantExpected] byte count) => RotateLeft(value, count); /// - /// __m256i _mm256_rol_epi64 (__m256i a, int imm8) - /// VPROLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256i _mm256_rol_epi64 (__m256i a, int imm8) + /// VPROLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 RotateLeft(Vector256 value, [ConstantExpected] byte count) => RotateLeft(value, count); /// - /// __m128i _mm_rolv_epi32 (__m128i a, __m128i b) - /// VPROLDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_rolv_epi32 (__m128i a, __m128i b) + /// VPROLDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 RotateLeftVariable(Vector128 value, Vector128 count) => RotateLeftVariable(value, count); /// - /// __m128i _mm_rolv_epi64 (__m128i a, __m128i b) - /// VPROLQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_rolv_epi64 (__m128i a, __m128i b) + /// VPROLQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 RotateLeftVariable(Vector128 value, Vector128 count) => RotateLeftVariable(value, count); /// - /// __m128i _mm_rolv_epi32 (__m128i a, __m128i b) - /// VPROLDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_rolv_epi32 (__m128i a, __m128i b) + /// VPROLDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 RotateLeftVariable(Vector128 value, Vector128 count) => RotateLeftVariable(value, count); /// - /// __m128i _mm_rolv_epi64 (__m128i a, __m128i b) - /// VPROLQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_rolv_epi64 (__m128i a, __m128i b) + /// VPROLQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 RotateLeftVariable(Vector128 value, Vector128 count) => RotateLeftVariable(value, count); /// - /// __m256i _mm256_rolv_epi32 (__m256i a, __m256i b) - /// VPROLDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_rolv_epi32 (__m256i a, __m256i b) + /// VPROLDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 RotateLeftVariable(Vector256 value, Vector256 count) => RotateLeftVariable(value, count); /// - /// __m256i _mm256_rolv_epi64 (__m256i a, __m256i b) - /// VPROLQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_rolv_epi64 (__m256i a, __m256i b) + /// VPROLQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 RotateLeftVariable(Vector256 value, Vector256 count) => RotateLeftVariable(value, count); /// - /// __m256i _mm256_rolv_epi32 (__m256i a, __m256i b) - /// VPROLDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_rolv_epi32 (__m256i a, __m256i b) + /// VPROLDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 RotateLeftVariable(Vector256 value, Vector256 count) => RotateLeftVariable(value, count); /// - /// __m256i _mm256_rolv_epi64 (__m256i a, __m256i b) - /// VPROLQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_rolv_epi64 (__m256i a, __m256i b) + /// VPROLQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 RotateLeftVariable(Vector256 value, Vector256 count) => RotateLeftVariable(value, count); /// - /// __m128i _mm_ror_epi32 (__m128i a, int imm8) - /// VPRORD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128i _mm_ror_epi32 (__m128i a, int imm8) + /// VPRORD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 RotateRight(Vector128 value, [ConstantExpected] byte count) => RotateRight(value, count); /// - /// __m128i _mm_ror_epi64 (__m128i a, int imm8) - /// VPRORQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128i _mm_ror_epi64 (__m128i a, int imm8) + /// VPRORQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 RotateRight(Vector128 value, [ConstantExpected] byte count) => RotateRight(value, count); /// - /// __m128i _mm_ror_epi32 (__m128i a, int imm8) - /// VPRORD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128i _mm_ror_epi32 (__m128i a, int imm8) + /// VPRORD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 RotateRight(Vector128 value, [ConstantExpected] byte count) => RotateRight(value, count); /// - /// __m128i _mm_ror_epi64 (__m128i a, int imm8) - /// VPRORQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128i _mm_ror_epi64 (__m128i a, int imm8) + /// VPRORQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 RotateRight(Vector128 value, [ConstantExpected] byte count) => RotateRight(value, count); /// - /// __m256i _mm256_ror_epi32 (__m256i a, int imm8) - /// VPRORD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256i _mm256_ror_epi32 (__m256i a, int imm8) + /// VPRORD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 RotateRight(Vector256 value, [ConstantExpected] byte count) => RotateRight(value, count); /// - /// __m256i _mm256_ror_epi64 (__m256i a, int imm8) - /// VPRORQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256i _mm256_ror_epi64 (__m256i a, int imm8) + /// VPRORQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 RotateRight(Vector256 value, [ConstantExpected] byte count) => RotateRight(value, count); /// - /// __m256i _mm256_ror_epi32 (__m256i a, int imm8) - /// VPRORD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256i _mm256_ror_epi32 (__m256i a, int imm8) + /// VPRORD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 RotateRight(Vector256 value, [ConstantExpected] byte count) => RotateRight(value, count); /// - /// __m256i _mm256_ror_epi64 (__m256i a, int imm8) - /// VPRORQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256i _mm256_ror_epi64 (__m256i a, int imm8) + /// VPRORQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 RotateRight(Vector256 value, [ConstantExpected] byte count) => RotateRight(value, count); /// - /// __m128i _mm_rorv_epi32 (__m128i a, __m128i b) - /// VPRORDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_rorv_epi32 (__m128i a, __m128i b) + /// VPRORDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 RotateRightVariable(Vector128 value, Vector128 count) => RotateRightVariable(value, count); /// - /// __m128i _mm_rorv_epi64 (__m128i a, __m128i b) - /// VPRORQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_rorv_epi64 (__m128i a, __m128i b) + /// VPRORQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 RotateRightVariable(Vector128 value, Vector128 count) => RotateRightVariable(value, count); /// - /// __m128i _mm_rorv_epi32 (__m128i a, __m128i b) - /// VPRORDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_rorv_epi32 (__m128i a, __m128i b) + /// VPRORDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 RotateRightVariable(Vector128 value, Vector128 count) => RotateRightVariable(value, count); /// - /// __m128i _mm_rorv_epi64 (__m128i a, __m128i b) - /// VPRORQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_rorv_epi64 (__m128i a, __m128i b) + /// VPRORQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 RotateRightVariable(Vector128 value, Vector128 count) => RotateRightVariable(value, count); /// - /// __m256i _mm256_rorv_epi32 (__m256i a, __m256i b) - /// VPRORDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_rorv_epi32 (__m256i a, __m256i b) + /// VPRORDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 RotateRightVariable(Vector256 value, Vector256 count) => RotateRightVariable(value, count); /// - /// __m256i _mm256_rorv_epi64 (__m256i a, __m256i b) - /// VPRORQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_rorv_epi64 (__m256i a, __m256i b) + /// VPRORQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 RotateRightVariable(Vector256 value, Vector256 count) => RotateRightVariable(value, count); /// - /// __m256i _mm256_rorv_epi32 (__m256i a, __m256i b) - /// VPRORDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_rorv_epi32 (__m256i a, __m256i b) + /// VPRORDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 RotateRightVariable(Vector256 value, Vector256 count) => RotateRightVariable(value, count); /// - /// __m256i _mm256_rorv_epi64 (__m256i a, __m256i b) - /// VPRORQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_rorv_epi64 (__m256i a, __m256i b) + /// VPRORQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 RotateRightVariable(Vector256 value, Vector256 count) => RotateRightVariable(value, count); /// - /// __m128d _mm_roundscale_pd (__m128d a, int imm) - /// VRNDSCALEPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128d _mm_roundscale_pd (__m128d a, int imm) + /// VRNDSCALEPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 RoundScale(Vector128 value, [ConstantExpected] byte control) => RoundScale(value, control); /// - /// __m128 _mm_roundscale_ps (__m128 a, int imm) - /// VRNDSCALEPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128 _mm_roundscale_ps (__m128 a, int imm) + /// VRNDSCALEPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 RoundScale(Vector128 value, [ConstantExpected] byte control) => RoundScale(value, control); /// - /// __m256d _mm256_roundscale_pd (__m256d a, int imm) - /// VRNDSCALEPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256d _mm256_roundscale_pd (__m256d a, int imm) + /// VRNDSCALEPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 RoundScale(Vector256 value, [ConstantExpected] byte control) => RoundScale(value, control); /// - /// __m256 _mm256_roundscale_ps (__m256 a, int imm) - /// VRNDSCALEPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256 _mm256_roundscale_ps (__m256 a, int imm) + /// VRNDSCALEPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 RoundScale(Vector256 value, [ConstantExpected] byte control) => RoundScale(value, control); /// - /// __m128d _mm_roundscale_sd (__m128d a, __m128d b, int imm) - /// VRNDSCALESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128d _mm_roundscale_sd (__m128d a, __m128d b, int imm) + /// VRNDSCALESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 RoundScaleScalar(Vector128 upper, Vector128 value, [ConstantExpected] byte control) => RoundScaleScalar(upper, value, control); /// - /// __m128d _mm_roundscale_sd (__m128d a, int imm) - /// VRNDSCALESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 + /// __m128d _mm_roundscale_sd (__m128d a, int imm) + /// VRNDSCALESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 /// public static Vector128 RoundScaleScalar(Vector128 value, [ConstantExpected] byte control) => RoundScaleScalar(value, control); /// - /// __m128 _mm_roundscale_ss (__m128 a, __m128 b, int imm) - /// VRNDSCALESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_roundscale_ss (__m128 a, __m128 b, int imm) + /// VRNDSCALESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 RoundScaleScalar(Vector128 upper, Vector128 value, [ConstantExpected] byte control) => RoundScaleScalar(upper, value, control); /// - /// __m128 _mm_roundscale_ss (__m128 a, int imm) - /// VRNDSCALESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 + /// __m128 _mm_roundscale_ss (__m128 a, int imm) + /// VRNDSCALESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 /// public static Vector128 RoundScaleScalar(Vector128 value, [ConstantExpected] byte control) => RoundScaleScalar(value, control); /// - /// __m128d _mm_scalef_pd (__m128d a, int imm) - /// VSCALEFPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_scalef_pd (__m128d a, int imm) + /// VSCALEFPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Scale(Vector128 left, Vector128 right) => Scale(left, right); /// - /// __m128 _mm_scalef_ps (__m128 a, int imm) - /// VSCALEFPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_scalef_ps (__m128 a, int imm) + /// VSCALEFPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Scale(Vector128 left, Vector128 right) => Scale(left, right); /// - /// __m256d _mm256_scalef_pd (__m256d a, int imm) - /// VSCALEFPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_scalef_pd (__m256d a, int imm) + /// VSCALEFPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Scale(Vector256 left, Vector256 right) => Scale(left, right); /// - /// __m256 _mm256_scalef_ps (__m256 a, int imm) - /// VSCALEFPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_scalef_ps (__m256 a, int imm) + /// VSCALEFPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Scale(Vector256 left, Vector256 right) => Scale(left, right); /// - /// __m128d _mm_scalef_round_sd (__m128d a, __m128d b) - /// VSCALEFSD xmm1, xmm2, xmm3 {er} + /// __m128d _mm_scalef_round_sd (__m128d a, __m128d b) + /// VSCALEFSD xmm1, xmm2, xmm3 {er} /// public static Vector128 ScaleScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ScaleScalar(left, right, mode); /// - /// __m128d _mm_scalef_sd (__m128d a, __m128d b) - /// VSCALEFSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} + /// __m128d _mm_scalef_sd (__m128d a, __m128d b) + /// VSCALEFSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} /// public static Vector128 ScaleScalar(Vector128 left, Vector128 right) => ScaleScalar(left, right); /// - /// __m128 _mm_scalef_round_ss (__m128 a, __m128 b) - /// VSCALEFSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_scalef_round_ss (__m128 a, __m128 b) + /// VSCALEFSS xmm1, xmm2, xmm3 {er} /// public static Vector128 ScaleScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ScaleScalar(left, right, mode); /// - /// __m128 _mm_scalef_ss (__m128 a, __m128 b) - /// VSCALEFSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} + /// __m128 _mm_scalef_ss (__m128 a, __m128 b) + /// VSCALEFSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} /// public static Vector128 ScaleScalar(Vector128 left, Vector128 right) => ScaleScalar(left, right); /// - /// __m128i _mm_sllv_epi16 (__m128i a, __m128i count) - /// VPSLLVW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sllv_epi16 (__m128i a, __m128i count) + /// VPSLLVW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftLeftLogicalVariable(Vector128 value, Vector128 count) => ShiftLeftLogicalVariable(value, count); /// - /// __m128i _mm_sllv_epi16 (__m128i a, __m128i count) - /// VPSLLVW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sllv_epi16 (__m128i a, __m128i count) + /// VPSLLVW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftLeftLogicalVariable(Vector128 value, Vector128 count) => ShiftLeftLogicalVariable(value, count); /// - /// __m256i _mm256_sllv_epi16 (__m256i a, __m256i count) - /// VPSLLVW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sllv_epi16 (__m256i a, __m256i count) + /// VPSLLVW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) => ShiftLeftLogicalVariable(value, count); /// - /// __m256i _mm256_sllv_epi16 (__m256i a, __m256i count) - /// VPSLLVW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sllv_epi16 (__m256i a, __m256i count) + /// VPSLLVW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) => ShiftLeftLogicalVariable(value, count); /// - /// __128i _mm_srai_epi64 (__m128i a, int imm8) - /// VPSRAQ xmm1 {k1}{z}, xmm2, imm8 + /// __128i _mm_srai_epi64 (__m128i a, int imm8) + /// VPSRAQ xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftRightArithmetic(Vector128 value, [ConstantExpected] byte count) => ShiftRightArithmetic(value, count); /// - /// __m128i _mm_sra_epi64 (__m128i a, __m128i count) - /// VPSRAQ xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sra_epi64 (__m128i a, __m128i count) + /// VPSRAQ xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightArithmetic(Vector128 value, Vector128 count) => ShiftRightArithmetic(value, count); /// - /// __m256i _mm256_srai_epi64 (__m256i a, int imm8) - /// VPSRAQ ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_srai_epi64 (__m256i a, int imm8) + /// VPSRAQ ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftRightArithmetic(Vector256 value, [ConstantExpected] byte count) => ShiftRightArithmetic(value, count); /// - /// __m256i _mm256_sra_epi64 (__m256i a, __m128i count) - /// VPSRAQ ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_sra_epi64 (__m256i a, __m128i count) + /// VPSRAQ ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftRightArithmetic(Vector256 value, Vector128 count) => ShiftRightArithmetic(value, count); /// - /// __m128i _mm_srav_epi64 (__m128i a, __m128i count) - /// VPSRAVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_srav_epi64 (__m128i a, __m128i count) + /// VPSRAVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 ShiftRightArithmeticVariable(Vector128 value, Vector128 count) => ShiftRightArithmeticVariable(value, count); /// - /// __m128i _mm_srav_epi16 (__m128i a, __m128i count) - /// VPSRAVW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_srav_epi16 (__m128i a, __m128i count) + /// VPSRAVW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightArithmeticVariable(Vector128 value, Vector128 count) => ShiftRightArithmeticVariable(value, count); /// - /// __m256i _mm256_srav_epi64 (__m256i a, __m256i count) - /// VPSRAVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_srav_epi64 (__m256i a, __m256i count) + /// VPSRAVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 ShiftRightArithmeticVariable(Vector256 value, Vector256 count) => ShiftRightArithmeticVariable(value, count); /// - /// __m256i _mm256_srav_epi16 (__m256i a, __m256i count) - /// VPSRAVW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_srav_epi16 (__m256i a, __m256i count) + /// VPSRAVW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 ShiftRightArithmeticVariable(Vector256 value, Vector256 count) => ShiftRightArithmeticVariable(value, count); /// - /// __m128i _mm_srlv_epi16 (__m128i a, __m128i count) - /// VPSRLVW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_srlv_epi16 (__m128i a, __m128i count) + /// VPSRLVW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightLogicalVariable(Vector128 value, Vector128 count) => ShiftRightLogicalVariable(value, count); /// - /// __m128i _mm_srlv_epi16 (__m128i a, __m128i count) - /// VPSRLVW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_srlv_epi16 (__m128i a, __m128i count) + /// VPSRLVW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightLogicalVariable(Vector128 value, Vector128 count) => ShiftRightLogicalVariable(value, count); /// - /// __m256i _mm256_srlv_epi16 (__m256i a, __m256i count) - /// VPSRLVW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_srlv_epi16 (__m256i a, __m256i count) + /// VPSRLVW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) => ShiftRightLogicalVariable(value, count); /// - /// __m256i _mm256_srlv_epi16 (__m256i a, __m256i count) - /// VPSRLVW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_srlv_epi16 (__m256i a, __m256i count) + /// VPSRLVW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) => ShiftRightLogicalVariable(value, count); /// - /// __m256d _mm256_shuffle_f64x2 (__m256d a, __m256d b, const int imm8) - /// VSHUFF64x2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256d _mm256_shuffle_f64x2 (__m256d a, __m256d b, const int imm8) + /// VSHUFF64x2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 Shuffle2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Shuffle2x128(left, right, control); /// - /// __m256 _mm256_shuffle_f32x4 (__m256 a, __m256 b, const int imm8) - /// VSHUFF32x4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256 _mm256_shuffle_f32x4 (__m256 a, __m256 b, const int imm8) + /// VSHUFF32x4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 Shuffle2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Shuffle2x128(left, right, control); /// - /// __m256i _mm256_shuffle_i32x4 (__m256i a, __m256i b, const int imm8) - /// VSHUFI32x4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256i _mm256_shuffle_i32x4 (__m256i a, __m256i b, const int imm8) + /// VSHUFI32x4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 Shuffle2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Shuffle2x128(left, right, control); /// - /// __m256i _mm256_shuffle_i64x2 (__m256i a, __m256i b, const int imm8) - /// VSHUFI64x2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256i _mm256_shuffle_i64x2 (__m256i a, __m256i b, const int imm8) + /// VSHUFI64x2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 Shuffle2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Shuffle2x128(left, right, control); /// - /// __m256i _mm256_shuffle_i32x4 (__m256i a, __m256i b, const int imm8) - /// VSHUFI32x4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256i _mm256_shuffle_i32x4 (__m256i a, __m256i b, const int imm8) + /// VSHUFI32x4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 Shuffle2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Shuffle2x128(left, right, control); /// - /// __m256i _mm256_shuffle_i64x2 (__m256i a, __m256i b, const int imm8) - /// VSHUFI64x2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256i _mm256_shuffle_i64x2 (__m256i a, __m256i b, const int imm8) + /// VSHUFI64x2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 Shuffle2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Shuffle2x128(left, right, control); /// - /// __m128d _mm_sqrt_round_sd (__m128d a, __m128d b, int rounding) - /// VSQRTSD xmm1, xmm2 xmm3 {er} + /// __m128d _mm_sqrt_round_sd (__m128d a, __m128d b, int rounding) + /// VSQRTSD xmm1, xmm2 xmm3 {er} /// public static Vector128 SqrtScalar(Vector128 upper, Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => SqrtScalar(upper, value, mode); /// - /// __m128 _mm_sqrt_round_ss (__m128 a, __m128 b, int rounding) - /// VSQRTSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_sqrt_round_ss (__m128 a, __m128 b, int rounding) + /// VSQRTSS xmm1, xmm2, xmm3 {er} /// public static Vector128 SqrtScalar(Vector128 upper, Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => SqrtScalar(upper, value, mode); /// - /// __m128d _mm_sub_round_sd (__m128d a, __m128d b, int rounding) - /// VSUBSD xmm1, xmm2, xmm3 {er} + /// __m128d _mm_sub_round_sd (__m128d a, __m128d b, int rounding) + /// VSUBSD xmm1, xmm2, xmm3 {er} /// public static Vector128 SubtractScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => SubtractScalar(left, right, mode); /// - /// __m128 _mm_sub_round_ss (__m128 a, __m128 b, int rounding) - /// VSUBSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_sub_round_ss (__m128 a, __m128 b, int rounding) + /// VSUBSS xmm1, xmm2, xmm3 {er} /// public static Vector128 SubtractScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => SubtractScalar(left, right, mode); /// - /// __m128i _mm_dbsad_epu8 (__m128i a, __m128i b, int imm8) - /// VDBPSADBW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_dbsad_epu8 (__m128i a, __m128i b, int imm8) + /// VDBPSADBW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 SumAbsoluteDifferencesInBlock32(Vector128 left, Vector128 right, [ConstantExpected] byte control) => SumAbsoluteDifferencesInBlock32(left, right, control); /// - /// __m256i _mm256_dbsad_epu8 (__m256i a, __m256i b, int imm8) - /// VDBPSADBW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_dbsad_epu8 (__m256i a, __m256i b, int imm8) + /// VDBPSADBW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 SumAbsoluteDifferencesInBlock32(Vector256 left, Vector256 right, [ConstantExpected] byte control) => SumAbsoluteDifferencesInBlock32(left, right, control); /// - /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, byte imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, byte imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m128d _mm_ternarylogic_pd (__m128d a, __m128d b, __m128d c, int imm) - /// VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m128d _mm_ternarylogic_pd (__m128d a, __m128d b, __m128d c, int imm) + /// VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m128 _mm_ternarylogic_ps (__m128 a, __m128 b, __m128 c, int imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m128 _mm_ternarylogic_ps (__m128 a, __m128 b, __m128 c, int imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m128i _mm_ternarylogic_epi32 (__m128i a, __m128i b, __m128i c, int imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128i _mm_ternarylogic_epi32 (__m128i a, __m128i b, __m128i c, int imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m128i _mm_ternarylogic_epi64 (__m128i a, __m128i b, __m128i c, int imm) - /// VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128i _mm_ternarylogic_epi64 (__m128i a, __m128i b, __m128i c, int imm) + /// VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, byte imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, byte imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, short imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, short imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m128i _mm_ternarylogic_epi32 (__m128i a, __m128i b, __m128i c, int imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128i _mm_ternarylogic_epi32 (__m128i a, __m128i b, __m128i c, int imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m128i _mm_ternarylogic_epi64 (__m128i a, __m128i b, __m128i c, int imm) - /// VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128i _mm_ternarylogic_epi64 (__m128i a, __m128i b, __m128i c, int imm) + /// VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, short imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, short imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, byte imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, byte imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m256d _mm256_ternarylogic_pd (__m256d a, __m256d b, __m256d c, int imm) - /// VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m256d _mm256_ternarylogic_pd (__m256d a, __m256d b, __m256d c, int imm) + /// VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m256 _mm256_ternarylogic_ps (__m256 a, __m256 b, __m256 c, int imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m256 _mm256_ternarylogic_ps (__m256 a, __m256 b, __m256 c, int imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m256i _mm256_ternarylogic_epi32 (__m256i a, __m256i b, __m256i c, int imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256i _mm256_ternarylogic_epi32 (__m256i a, __m256i b, __m256i c, int imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m256i _mm256_ternarylogic_epi64 (__m256i a, __m256i b, __m256i c, int imm) - /// VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256i _mm256_ternarylogic_epi64 (__m256i a, __m256i b, __m256i c, int imm) + /// VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, byte imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, byte imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, short imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, short imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m256i _mm256_ternarylogic_epi32 (__m256i a, __m256i b, __m256i c, int imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256i _mm256_ternarylogic_epi32 (__m256i a, __m256i b, __m256i c, int imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m256i _mm256_ternarylogic_epi64 (__m256i a, __m256i b, __m256i c, int imm) - /// VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256i _mm256_ternarylogic_epi64 (__m256i a, __m256i b, __m256i c, int imm) + /// VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, short imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, short imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); + /// Provides access to the x86 AVX10.1 hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : Avx2.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } /// - /// __m128 _mm_cvt_roundi64_ss (__m128 a, __int64 b, int rounding) - /// VCVTSI2SS xmm1, xmm2, r64 {er} - /// This intrinsic is only available on 64-bit processes + /// __m128 _mm_cvt_roundi64_ss (__m128 a, __int64 b, int rounding) + /// VCVTSI2SS xmm1, xmm2, r64 {er} + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, long value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertScalarToVector128Single(upper, value, mode); /// - /// __m128 _mm_cvtsi64_ss (__m128 a, __int64 b) - /// VCVTUSI2SS xmm1, xmm2, r/m64 - /// This intrinsic is only available on 64-bit processes + /// __m128 _mm_cvtsi64_ss (__m128 a, __int64 b) + /// VCVTUSI2SS xmm1, xmm2, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, ulong value) => ConvertScalarToVector128Single(upper, value); /// - /// __m128 _mm_cvt_roundu64_ss (__m128 a, unsigned __int64 b, int rounding) - /// VCVTUSI2SS xmm1, xmm2, r64 {er} - /// This intrinsic is only available on 64-bit processes + /// __m128 _mm_cvt_roundu64_ss (__m128 a, unsigned __int64 b, int rounding) + /// VCVTUSI2SS xmm1, xmm2, r64 {er} + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, ulong value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertScalarToVector128Single(upper, value, mode); /// - /// __m128d _mm_cvt_roundsi64_sd (__m128d a, __int64 b, int rounding) - /// VCVTSI2SD xmm1, xmm2, r64 {er} - /// This intrinsic is only available on 64-bit processes + /// __m128d _mm_cvt_roundsi64_sd (__m128d a, __int64 b, int rounding) + /// VCVTSI2SD xmm1, xmm2, r64 {er} + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Double(Vector128 upper, long value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertScalarToVector128Double(upper, value, mode); /// - /// __m128d _mm_cvtsi64_sd (__m128d a, __int64 b) - /// VCVTUSI2SD xmm1, xmm2, r/m64 - /// This intrinsic is only available on 64-bit processes + /// __m128d _mm_cvtsi64_sd (__m128d a, __int64 b) + /// VCVTUSI2SD xmm1, xmm2, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Double(Vector128 upper, ulong value) => ConvertScalarToVector128Double(upper, value); /// - /// __m128d _mm_cvt_roundu64_sd (__m128d a, unsigned __int64 b, int rounding) - /// VCVTUSI2SD xmm1, xmm2, r64 {er} - /// This intrinsic is only available on 64-bit processes + /// __m128d _mm_cvt_roundu64_sd (__m128d a, unsigned __int64 b, int rounding) + /// VCVTUSI2SD xmm1, xmm2, r64 {er} + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Double(Vector128 upper, ulong value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertScalarToVector128Double(upper, value, mode); /// - /// __int64 _mm_cvt_roundss_i64 (__m128 a, int rounding) - /// VCVTSS2SI r64, xmm1 {er} - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_cvt_roundss_i64 (__m128 a, int rounding) + /// VCVTSS2SI r64, xmm1 {er} + /// This intrinsic is only available on 64-bit processes /// public static long ConvertToInt64(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToInt64(value, mode); /// - /// __int64 _mm_cvt_roundsd_i64 (__m128d a, int rounding) - /// VCVTSD2SI r64, xmm1 {er} - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_cvt_roundsd_i64 (__m128d a, int rounding) + /// VCVTSD2SI r64, xmm1 {er} + /// This intrinsic is only available on 64-bit processes /// public static long ConvertToInt64(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToInt64(value, mode); /// - /// unsigned __int64 _mm_cvtss_u64 (__m128 a) - /// VCVTSS2USI r64, xmm1/m32{er} - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_cvtss_u64 (__m128 a) + /// VCVTSS2USI r64, xmm1/m32{er} + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64(Vector128 value) => ConvertToUInt64(value); /// - /// unsigned __int64 _mm_cvt_roundss_u64 (__m128 a, int rounding) - /// VCVTSS2USI r64, xmm1 {er} - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_cvt_roundss_u64 (__m128 a, int rounding) + /// VCVTSS2USI r64, xmm1 {er} + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToUInt64(value, mode); /// - /// unsigned __int64 _mm_cvtsd_u64 (__m128d a) - /// VCVTSD2USI r64, xmm1/m64{er} - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_cvtsd_u64 (__m128d a) + /// VCVTSD2USI r64, xmm1/m64{er} + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64(Vector128 value) => ConvertToUInt64(value); /// - /// unsigned __int64 _mm_cvt_roundsd_u64 (__m128d a, int rounding) - /// VCVTSD2USI r64, xmm1 {er} - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_cvt_roundsd_u64 (__m128d a, int rounding) + /// VCVTSD2USI r64, xmm1 {er} + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToUInt64(value, mode); /// - /// unsigned __int64 _mm_cvttss_u64 (__m128 a) - /// VCVTTSS2USI r64, xmm1/m32{er} - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_cvttss_u64 (__m128 a) + /// VCVTTSS2USI r64, xmm1/m32{er} + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64WithTruncation(Vector128 value) => ConvertToUInt64WithTruncation(value); /// - /// unsigned __int64 _mm_cvttsd_u64 (__m128d a) - /// VCVTTSD2USI r64, xmm1/m64{er} - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_cvttsd_u64 (__m128d a) + /// VCVTTSD2USI r64, xmm1/m64{er} + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64WithTruncation(Vector128 value) => ConvertToUInt64WithTruncation(value); } + /// Provides access to the x86 AVX10.1/512 hardware instructions via intrinsics. [Intrinsic] public abstract class V512 : Avx512BW { internal V512() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } /// - /// __m512i _mm512_conflict_epi32 (__m512i a) - /// VPCONFLICTD zmm1 {k1}{z}, zmm2/m512/m32bcst + /// __m512i _mm512_conflict_epi32 (__m512i a) + /// VPCONFLICTD zmm1 {k1}{z}, zmm2/m512/m32bcst /// public static Vector512 DetectConflicts(Vector512 value) => DetectConflicts(value); /// - /// __m512i _mm512_conflict_epi32 (__m512i a) - /// VPCONFLICTD zmm1 {k1}{z}, zmm2/m512/m32bcst + /// __m512i _mm512_conflict_epi32 (__m512i a) + /// VPCONFLICTD zmm1 {k1}{z}, zmm2/m512/m32bcst /// public static Vector512 DetectConflicts(Vector512 value) => DetectConflicts(value); /// - /// __m512i _mm512_conflict_epi64 (__m512i a) - /// VPCONFLICTQ zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512i _mm512_conflict_epi64 (__m512i a) + /// VPCONFLICTQ zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 DetectConflicts(Vector512 value) => DetectConflicts(value); /// - /// __m512i _mm512_conflict_epi64 (__m512i a) - /// VPCONFLICTQ zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512i _mm512_conflict_epi64 (__m512i a) + /// VPCONFLICTQ zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 DetectConflicts(Vector512 value) => DetectConflicts(value); /// - /// __m512i _mm512_lzcnt_epi32 (__m512i a) - /// VPLZCNTD zmm1 {k1}{z}, zmm2/m512/m32bcst + /// __m512i _mm512_lzcnt_epi32 (__m512i a) + /// VPLZCNTD zmm1 {k1}{z}, zmm2/m512/m32bcst /// public static Vector512 LeadingZeroCount(Vector512 value) => LeadingZeroCount(value); /// - /// __m512i _mm512_lzcnt_epi32 (__m512i a) - /// VPLZCNTD zmm1 {k1}{z}, zmm2/m512/m32bcst + /// __m512i _mm512_lzcnt_epi32 (__m512i a) + /// VPLZCNTD zmm1 {k1}{z}, zmm2/m512/m32bcst /// public static Vector512 LeadingZeroCount(Vector512 value) => LeadingZeroCount(value); /// - /// __m512i _mm512_lzcnt_epi64 (__m512i a) - /// VPLZCNTQ zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512i _mm512_lzcnt_epi64 (__m512i a) + /// VPLZCNTQ zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 LeadingZeroCount(Vector512 value) => LeadingZeroCount(value); /// - /// __m512i _mm512_lzcnt_epi64 (__m512i a) - /// VPLZCNTQ zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512i _mm512_lzcnt_epi64 (__m512i a) + /// VPLZCNTQ zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 LeadingZeroCount(Vector512 value) => LeadingZeroCount(value); /// - /// __m512 _mm512_and_ps (__m512 a, __m512 b) - /// VANDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_and_ps (__m512 a, __m512 b) + /// VANDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 And(Vector512 left, Vector512 right) => And(left, right); /// - /// __m512d _mm512_and_pd (__m512d a, __m512d b) - /// VANDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_and_pd (__m512d a, __m512d b) + /// VANDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 And(Vector512 left, Vector512 right) => And(left, right); /// - /// __m512 _mm512_andnot_ps (__m512 a, __m512 b) - /// VANDNPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_andnot_ps (__m512 a, __m512 b) + /// VANDNPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 AndNot(Vector512 left, Vector512 right) => AndNot(left, right); /// - /// __m512d _mm512_andnot_pd (__m512d a, __m512d b) - /// VANDNPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_andnot_pd (__m512d a, __m512d b) + /// VANDNPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 AndNot(Vector512 left, Vector512 right) => AndNot(left, right); /// - /// __m512i _mm512_broadcast_i32x2 (__m128i a) - /// VBROADCASTI32x2 zmm1 {k1}{z}, xmm2/m64 + /// __m512i _mm512_broadcast_i32x2 (__m128i a) + /// VBROADCASTI32x2 zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 BroadcastPairScalarToVector512(Vector128 value) => BroadcastPairScalarToVector512(value); /// - /// __m512i _mm512_broadcast_i32x2 (__m128i a) - /// VBROADCASTI32x2 zmm1 {k1}{z}, xmm2/m64 + /// __m512i _mm512_broadcast_i32x2 (__m128i a) + /// VBROADCASTI32x2 zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 BroadcastPairScalarToVector512(Vector128 value) => BroadcastPairScalarToVector512(value); /// - /// __m512 _mm512_broadcast_f32x2 (__m128 a) - /// VBROADCASTF32x2 zmm1 {k1}{z}, xmm2/m64 + /// __m512 _mm512_broadcast_f32x2 (__m128 a) + /// VBROADCASTF32x2 zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 BroadcastPairScalarToVector512(Vector128 value) => BroadcastPairScalarToVector512(value); /// - /// __m512i _mm512_broadcast_i64x2 (__m128i const * mem_addr) - /// VBROADCASTI64x2 zmm1 {k1}{z}, m128 + /// __m512i _mm512_broadcast_i64x2 (__m128i const * mem_addr) + /// VBROADCASTI64x2 zmm1 {k1}{z}, m128 /// public static unsafe Vector512 BroadcastVector128ToVector512(long* address) => BroadcastVector128ToVector512(address); /// - /// __m512i _mm512_broadcast_i64x2 (__m128i const * mem_addr) - /// VBROADCASTI64x2 zmm1 {k1}{z}, m128 + /// __m512i _mm512_broadcast_i64x2 (__m128i const * mem_addr) + /// VBROADCASTI64x2 zmm1 {k1}{z}, m128 /// public static unsafe Vector512 BroadcastVector128ToVector512(ulong* address) => BroadcastVector128ToVector512(address); /// - /// __m512d _mm512_broadcast_f64x2 (__m128d const * mem_addr) - /// VBROADCASTF64x2 zmm1 {k1}{z}, m128 + /// __m512d _mm512_broadcast_f64x2 (__m128d const * mem_addr) + /// VBROADCASTF64x2 zmm1 {k1}{z}, m128 /// public static unsafe Vector512 BroadcastVector128ToVector512(double* address) => BroadcastVector128ToVector512(address); /// - /// __m512i _mm512_broadcast_i32x8 (__m256i const * mem_addr) - /// VBROADCASTI32x8 zmm1 {k1}{z}, m256 + /// __m512i _mm512_broadcast_i32x8 (__m256i const * mem_addr) + /// VBROADCASTI32x8 zmm1 {k1}{z}, m256 /// public static unsafe Vector512 BroadcastVector256ToVector512(int* address) => BroadcastVector256ToVector512(address); /// - /// __m512i _mm512_broadcast_i32x8 (__m256i const * mem_addr) - /// VBROADCASTI32x8 zmm1 {k1}{z}, m256 + /// __m512i _mm512_broadcast_i32x8 (__m256i const * mem_addr) + /// VBROADCASTI32x8 zmm1 {k1}{z}, m256 /// public static unsafe Vector512 BroadcastVector256ToVector512(uint* address) => BroadcastVector256ToVector512(address); /// - /// __m512 _mm512_broadcast_f32x8 (__m256 const * mem_addr) - /// VBROADCASTF32x8 zmm1 {k1}{z}, m256 + /// __m512 _mm512_broadcast_f32x8 (__m256 const * mem_addr) + /// VBROADCASTF32x8 zmm1 {k1}{z}, m256 /// public static unsafe Vector512 BroadcastVector256ToVector512(float* address) => BroadcastVector256ToVector512(address); /// - /// __m512 _mm512_cvtepi64_ps (__m512i a) - /// VCVTQQ2PS ymm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512 _mm512_cvtepi64_ps (__m512i a) + /// VCVTQQ2PS ymm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector256 ConvertToVector256Single(Vector512 value) => ConvertToVector256Single(value); /// - /// __m512 _mm512_cvtepu64_ps (__m512i a) - /// VCVTUQQ2PS ymm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512 _mm512_cvtepu64_ps (__m512i a) + /// VCVTUQQ2PS ymm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector256 ConvertToVector256Single(Vector512 value) => ConvertToVector256Single(value); /// - /// __m256 _mm512_cvt_roundepi64_ps (__m512i a, int r) - /// VCVTQQ2PS ymm1, zmm2 {er} + /// __m256 _mm512_cvt_roundepi64_ps (__m512i a, int r) + /// VCVTQQ2PS ymm1, zmm2 {er} /// public static Vector256 ConvertToVector256Single(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector256Single(value, mode); /// - /// __m256 _mm512_cvt_roundepu64_ps (__m512i a, int r) - /// VCVTUQQ2PS ymm1, zmm2 {er} + /// __m256 _mm512_cvt_roundepu64_ps (__m512i a, int r) + /// VCVTUQQ2PS ymm1, zmm2 {er} /// public static Vector256 ConvertToVector256Single(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector256Single(value, mode); /// - /// __m512d _mm512_cvtepi64_pd (__m512i a) - /// VCVTQQ2PD zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512d _mm512_cvtepi64_pd (__m512i a) + /// VCVTQQ2PD zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 ConvertToVector512Double(Vector512 value) => ConvertToVector512Double(value); /// - /// __m512d _mm512_cvtepu64_pd (__m512i a) - /// VCVTUQQ2PD zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512d _mm512_cvtepu64_pd (__m512i a) + /// VCVTUQQ2PD zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 ConvertToVector512Double(Vector512 value) => ConvertToVector512Double(value); /// - /// __m512d _mm512_cvt_roundepi64_pd (__m512i a, int r) - /// VCVTQQ2PD zmm1, zmm2 {er} + /// __m512d _mm512_cvt_roundepi64_pd (__m512i a, int r) + /// VCVTQQ2PD zmm1, zmm2 {er} /// public static Vector512 ConvertToVector512Double(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Double(value, mode); /// - /// __m512d _mm512_cvt_roundepu64_pd (__m512i a, int r) - /// VCVTUQQ2PD zmm1, zmm2 {er} + /// __m512d _mm512_cvt_roundepu64_pd (__m512i a, int r) + /// VCVTUQQ2PD zmm1, zmm2 {er} /// public static Vector512 ConvertToVector512Double(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Double(value, mode); /// - /// __m512i _mm512_cvtps_epi64 (__m512 a) - /// VCVTPS2QQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} + /// __m512i _mm512_cvtps_epi64 (__m512 a) + /// VCVTPS2QQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} /// public static Vector512 ConvertToVector512Int64(Vector256 value) => ConvertToVector512Int64(value); /// - /// __m512i _mm512_cvtpd_epi64 (__m512d a) - /// VCVTPD2QQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m512i _mm512_cvtpd_epi64 (__m512d a) + /// VCVTPD2QQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector512 ConvertToVector512Int64(Vector512 value) => ConvertToVector512Int64(value); /// - /// __m512i _mm512_cvt_roundps_epi64 (__m512 a, int r) - /// VCVTPS2QQ zmm1, ymm2 {er} + /// __m512i _mm512_cvt_roundps_epi64 (__m512 a, int r) + /// VCVTPS2QQ zmm1, ymm2 {er} /// public static Vector512 ConvertToVector512Int64(Vector256 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Int64(value, mode); /// - /// __m512i _mm512_cvt_roundpd_epi64 (__m512d a, int r) - /// VCVTPD2QQ zmm1, zmm2 {er} + /// __m512i _mm512_cvt_roundpd_epi64 (__m512d a, int r) + /// VCVTPD2QQ zmm1, zmm2 {er} /// public static Vector512 ConvertToVector512Int64(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Int64(value, mode); /// - /// __m512i _mm512_cvttps_epi64 (__m512 a) - /// VCVTTPS2QQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} + /// __m512i _mm512_cvttps_epi64 (__m512 a) + /// VCVTTPS2QQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} /// public static Vector512 ConvertToVector512Int64WithTruncation(Vector256 value) => ConvertToVector512Int64WithTruncation(value); /// - /// __m512i _mm512_cvttpd_epi64 (__m512 a) - /// VCVTTPD2QQ zmm1 {k1}{z}, zmm2/m512/m64bcst{sae} + /// __m512i _mm512_cvttpd_epi64 (__m512 a) + /// VCVTTPD2QQ zmm1 {k1}{z}, zmm2/m512/m64bcst{sae} /// public static Vector512 ConvertToVector512Int64WithTruncation(Vector512 value) => ConvertToVector512Int64WithTruncation(value); /// - /// __m512i _mm512_cvtps_epu64 (__m512 a) - /// VCVTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} + /// __m512i _mm512_cvtps_epu64 (__m512 a) + /// VCVTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} /// public static Vector512 ConvertToVector512UInt64(Vector256 value) => ConvertToVector512UInt64(value); /// - /// __m512i _mm512_cvtpd_epu64 (__m512d a) - /// VCVTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m512i _mm512_cvtpd_epu64 (__m512d a) + /// VCVTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector512 ConvertToVector512UInt64(Vector512 value) => ConvertToVector512UInt64(value); /// - /// __m512i _mm512_cvt_roundps_epu64 (__m512 a, int r) - /// VCVTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} + /// __m512i _mm512_cvt_roundps_epu64 (__m512 a, int r) + /// VCVTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} /// public static Vector512 ConvertToVector512UInt64(Vector256 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512UInt64(value, mode); /// - /// __m512i _mm512_cvt_roundpd_epu64 (__m512d a, int r) - /// VCVTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m512i _mm512_cvt_roundpd_epu64 (__m512d a, int r) + /// VCVTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector512 ConvertToVector512UInt64(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512UInt64(value, mode); /// - /// __m512i _mm512_cvttps_epu64 (__m512 a) - /// VCVTTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} + /// __m512i _mm512_cvttps_epu64 (__m512 a) + /// VCVTTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} /// public static Vector512 ConvertToVector512UInt64WithTruncation(Vector256 value) => ConvertToVector512UInt64WithTruncation(value); /// - /// __m512i _mm512_cvttpd_epu64 (__m512d a) - /// VCVTTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m512i _mm512_cvttpd_epu64 (__m512d a) + /// VCVTTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector512 ConvertToVector512UInt64WithTruncation(Vector512 value) => ConvertToVector512UInt64WithTruncation(value); /// - /// __m128i _mm512_extracti64x2_epi64 (__m512i a, const int imm8) - /// VEXTRACTI64x2 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128i _mm512_extracti64x2_epi64 (__m512i a, const int imm8) + /// VEXTRACTI64x2 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static new Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128i _mm512_extracti64x2_epi64 (__m512i a, const int imm8) - /// VEXTRACTI64x2 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128i _mm512_extracti64x2_epi64 (__m512i a, const int imm8) + /// VEXTRACTI64x2 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static new Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128d _mm512_extractf64x2_pd (__m512d a, const int imm8) - /// VEXTRACTF64x2 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128d _mm512_extractf64x2_pd (__m512d a, const int imm8) + /// VEXTRACTF64x2 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static new Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m256i _mm512_extracti32x8_epi32 (__m512i a, const int imm8) - /// VEXTRACTI32x8 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256i _mm512_extracti32x8_epi32 (__m512i a, const int imm8) + /// VEXTRACTI32x8 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static new Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) => ExtractVector256(value, index); /// - /// __m256i _mm512_extracti32x8_epi32 (__m512i a, const int imm8) - /// VEXTRACTI32x8 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256i _mm512_extracti32x8_epi32 (__m512i a, const int imm8) + /// VEXTRACTI32x8 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static new Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) => ExtractVector256(value, index); /// - /// __m256 _mm512_extractf32x8_ps (__m512 a, const int imm8) - /// VEXTRACTF32x8 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256 _mm512_extractf32x8_ps (__m512 a, const int imm8) + /// VEXTRACTF32x8 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static new Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) => ExtractVector256(value, index); /// - /// __m512i _mm512_inserti64x2_si512 (__m512i a, __m128i b, const int imm8) - /// VINSERTI64x2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512i _mm512_inserti64x2_si512 (__m512i a, __m128i b, const int imm8) + /// VINSERTI64x2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static new Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m512i _mm512_inserti64x2_si512 (__m512i a, __m128i b, const int imm8) - /// VINSERTI64x2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512i _mm512_inserti64x2_si512 (__m512i a, __m128i b, const int imm8) + /// VINSERTI64x2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static new Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m512d _mm512_insertf64x2_pd (__m512d a, __m128d b, int imm8) - /// VINSERTF64x2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512d _mm512_insertf64x2_pd (__m512d a, __m128d b, int imm8) + /// VINSERTF64x2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static new Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m512i _mm512_inserti32x8_si512 (__m512i a, __m256i b, const int imm8) - /// VINSERTI32x8 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512i _mm512_inserti32x8_si512 (__m512i a, __m256i b, const int imm8) + /// VINSERTI32x8 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static new Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) => InsertVector256(value, data, index); /// - /// __m512i _mm512_inserti32x8_si512 (__m512i a, __m256i b, const int imm8) - /// VINSERTI32x8 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512i _mm512_inserti32x8_si512 (__m512i a, __m256i b, const int imm8) + /// VINSERTI32x8 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static new Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) => InsertVector256(value, data, index); /// - /// __m512 _mm512_insertf32x8_ps (__m512 a, __m256 b, int imm8) - /// VINSERTF32x8 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512 _mm512_insertf32x8_ps (__m512 a, __m256 b, int imm8) + /// VINSERTF32x8 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static new Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) => InsertVector256(value, data, index); /// - /// __m512i _mm512_mullo_epi64 (__m512i a, __m512i b) - /// VPMULLQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_mullo_epi64 (__m512i a, __m512i b) + /// VPMULLQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 MultiplyLow(Vector512 left, Vector512 right) => MultiplyLow(left, right); /// - /// __m512i _mm512_mullo_epi64 (__m512i a, __m512i b) - /// VPMULLQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_mullo_epi64 (__m512i a, __m512i b) + /// VPMULLQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 MultiplyLow(Vector512 left, Vector512 right) => MultiplyLow(left, right); /// - /// __m512i _mm512_multishift_epi64_epi8( __m512i a, __m512i b) - /// VPMULTISHIFTQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_multishift_epi64_epi8( __m512i a, __m512i b) + /// VPMULTISHIFTQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 MultiShift(Vector512 control, Vector512 value) => MultiShift(control, value); /// - /// __m512i _mm512_multishift_epi64_epi8( __m512i a, __m512i b) - /// VPMULTISHIFTQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_multishift_epi64_epi8( __m512i a, __m512i b) + /// VPMULTISHIFTQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 MultiShift(Vector512 control, Vector512 value) => MultiShift(control, value); /// - /// __m512 _mm512_or_ps (__m512 a, __m512 b) - /// VORPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_or_ps (__m512 a, __m512 b) + /// VORPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Or(Vector512 left, Vector512 right) => Or(left, right); /// - /// __m512d _mm512_or_pd (__m512d a, __m512d b) - /// VORPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_or_pd (__m512d a, __m512d b) + /// VORPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Or(Vector512 left, Vector512 right) => Or(left, right); /// - /// __m512 _mm512_range_ps(__m512 a, __m512 b, int imm); - /// VRANGEPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}, imm8 + /// __m512 _mm512_range_ps(__m512 a, __m512 b, int imm); + /// VRANGEPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}, imm8 /// public static Vector512 Range(Vector512 left, Vector512 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => Range(left, right, control); /// - /// __m512d _mm512_range_pd(__m512d a, __m512d b, int imm); - /// VRANGEPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}, imm8 + /// __m512d _mm512_range_pd(__m512d a, __m512d b, int imm); + /// VRANGEPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}, imm8 /// public static Vector512 Range(Vector512 left, Vector512 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => Range(left, right, control); /// - /// __m512 _mm512_reduce_ps(__m512 a, int imm); - /// VREDUCEPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}, imm8 + /// __m512 _mm512_reduce_ps(__m512 a, int imm); + /// VREDUCEPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}, imm8 /// public static Vector512 Reduce(Vector512 value, [ConstantExpected] byte control) => Reduce(value, control); /// - /// __m512d _mm512_reduce_pd(__m512d a, int imm); - /// VREDUCEPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}, imm8 + /// __m512d _mm512_reduce_pd(__m512d a, int imm); + /// VREDUCEPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}, imm8 /// public static Vector512 Reduce(Vector512 value, [ConstantExpected] byte control) => Reduce(value, control); /// - /// __m512 _mm512_xor_ps (__m512 a, __m512 b) - /// VXORPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_xor_ps (__m512 a, __m512 b) + /// VXORPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Xor(Vector512 left, Vector512 right) => Xor(left, right); /// - /// __m512d _mm512_xor_pd (__m512d a, __m512d b) - /// VXORPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_xor_pd (__m512d a, __m512d b) + /// VXORPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Xor(Vector512 left, Vector512 right) => Xor(left, right); /// - /// __m512i _mm512_permutevar64x8_epi8 (__m512i a, __m512i b) - /// VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_permutevar64x8_epi8 (__m512i a, __m512i b) + /// VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PermuteVar64x8(Vector512 left, Vector512 control) => PermuteVar64x8(left, control); /// - /// __m512i _mm512_permutevar64x8_epi8 (__m512i a, __m512i b) - /// VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_permutevar64x8_epi8 (__m512i a, __m512i b) + /// VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PermuteVar64x8(Vector512 left, Vector512 control) => PermuteVar64x8(left, control); /// - /// __m512i _mm512_permutex2var_epi8 (__m512i a, __m512i idx, __m512i b) - /// VPERMI2B zmm1 {k1}{z}, zmm2, zmm3/m512 - /// VPERMT2B zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_permutex2var_epi8 (__m512i a, __m512i idx, __m512i b) + /// VPERMI2B zmm1 {k1}{z}, zmm2, zmm3/m512 + /// VPERMT2B zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PermuteVar64x8x2(Vector512 lower, Vector512 indices, Vector512 upper) => PermuteVar64x8x2(lower, indices, upper); /// - /// __m512i _mm512_permutex2var_epi8 (__m512i a, __m512i idx, __m512i b) - /// VPERMI2B zmm1 {k1}{z}, zmm2, zmm3/m512 - /// VPERMT2B zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_permutex2var_epi8 (__m512i a, __m512i idx, __m512i b) + /// VPERMI2B zmm1 {k1}{z}, zmm2, zmm3/m512 + /// VPERMT2B zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PermuteVar64x8x2(Vector512 lower, Vector512 indices, Vector512 upper) => PermuteVar64x8x2(lower, indices, upper); + /// Provides access to the x86 AVX10.1/512 hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : Avx512BW.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs index f85e14928be..bacca0da373 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.PlatformNotSupported.cs @@ -8,2387 +8,2392 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel AVX2 hardware instructions via intrinsics - /// + /// Provides access to X86 AVX2 hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Avx2 : Avx { internal Avx2() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } + /// Provides access to the x86 AVX2 hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class X64 : Avx.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } } /// - /// __m256i _mm256_abs_epi8 (__m256i a) - /// VPABSB ymm1, ymm2/m256 - /// VPABSB ymm1 {k1}{z}, ymm2/m256 + /// __m256i _mm256_abs_epi8 (__m256i a) + /// VPABSB ymm1, ymm2/m256 + /// VPABSB ymm1 {k1}{z}, ymm2/m256 /// public static Vector256 Abs(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_abs_epi16 (__m256i a) - /// VPABSW ymm1, ymm2/m256 - /// VPABSW ymm1 {k1}{z}, ymm2/m256 + /// __m256i _mm256_abs_epi16 (__m256i a) + /// VPABSW ymm1, ymm2/m256 + /// VPABSW ymm1 {k1}{z}, ymm2/m256 /// public static Vector256 Abs(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_abs_epi32 (__m256i a) - /// VPABSD ymm1, ymm2/m256 - /// VPABSD ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_abs_epi32 (__m256i a) + /// VPABSD ymm1, ymm2/m256 + /// VPABSD ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 Abs(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_add_epi8 (__m256i a, __m256i b) - /// VPADDB ymm1, ymm2, ymm3/m256 - /// VPADDB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_add_epi8 (__m256i a, __m256i b) + /// VPADDB ymm1, ymm2, ymm3/m256 + /// VPADDB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Add(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_add_epi8 (__m256i a, __m256i b) - /// VPADDB ymm1, ymm2, ymm3/m256 - /// VPADDB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_add_epi8 (__m256i a, __m256i b) + /// VPADDB ymm1, ymm2, ymm3/m256 + /// VPADDB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Add(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_add_epi16 (__m256i a, __m256i b) - /// VPADDW ymm1, ymm2, ymm3/m256 - /// VPADDW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_add_epi16 (__m256i a, __m256i b) + /// VPADDW ymm1, ymm2, ymm3/m256 + /// VPADDW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Add(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_add_epi16 (__m256i a, __m256i b) - /// VPADDW ymm1, ymm2, ymm3/m256 - /// VPADDW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_add_epi16 (__m256i a, __m256i b) + /// VPADDW ymm1, ymm2, ymm3/m256 + /// VPADDW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Add(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_add_epi32 (__m256i a, __m256i b) - /// VPADDD ymm1, ymm2, ymm3/m256 - /// VPADDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_add_epi32 (__m256i a, __m256i b) + /// VPADDD ymm1, ymm2, ymm3/m256 + /// VPADDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Add(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_add_epi32 (__m256i a, __m256i b) - /// VPADDD ymm1, ymm2, ymm3/m256 - /// VPADDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_add_epi32 (__m256i a, __m256i b) + /// VPADDD ymm1, ymm2, ymm3/m256 + /// VPADDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Add(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_add_epi64 (__m256i a, __m256i b) - /// VPADDQ ymm1, ymm2, ymm3/m256 - /// VPADDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_add_epi64 (__m256i a, __m256i b) + /// VPADDQ ymm1, ymm2, ymm3/m256 + /// VPADDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Add(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_add_epi64 (__m256i a, __m256i b) - /// VPADDQ ymm1, ymm2, ymm3/m256 - /// VPADDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_add_epi64 (__m256i a, __m256i b) + /// VPADDQ ymm1, ymm2, ymm3/m256 + /// VPADDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Add(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_adds_epi8 (__m256i a, __m256i b) - /// VPADDSB ymm1, ymm2, ymm3/m256 - /// VPADDSB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_adds_epi8 (__m256i a, __m256i b) + /// VPADDSB ymm1, ymm2, ymm3/m256 + /// VPADDSB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 AddSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_adds_epu8 (__m256i a, __m256i b) - /// VPADDUSB ymm1, ymm2, ymm3/m256 - /// VPADDUSB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_adds_epu8 (__m256i a, __m256i b) + /// VPADDUSB ymm1, ymm2, ymm3/m256 + /// VPADDUSB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 AddSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_adds_epi16 (__m256i a, __m256i b) - /// VPADDSW ymm1, ymm2, ymm3/m256 - /// VPADDSW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_adds_epi16 (__m256i a, __m256i b) + /// VPADDSW ymm1, ymm2, ymm3/m256 + /// VPADDSW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 AddSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_adds_epu16 (__m256i a, __m256i b) - /// VPADDUSW ymm1, ymm2, ymm3/m256 - /// VPADDUSW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_adds_epu16 (__m256i a, __m256i b) + /// VPADDUSW ymm1, ymm2, ymm3/m256 + /// VPADDUSW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 AddSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) - /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 - /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) + /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 + /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 /// public static Vector256 AlignRight(Vector256 left, Vector256 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) - /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 - /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) + /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 + /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 /// public static Vector256 AlignRight(Vector256 left, Vector256 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) - /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 - /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) + /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 + /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors. /// public static Vector256 AlignRight(Vector256 left, Vector256 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) - /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 - /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) + /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 + /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors. /// public static Vector256 AlignRight(Vector256 left, Vector256 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) - /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 - /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) + /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 + /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors. /// public static Vector256 AlignRight(Vector256 left, Vector256 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) - /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 - /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) + /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 + /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors. /// public static Vector256 AlignRight(Vector256 left, Vector256 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) - /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 - /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) + /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 + /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors. /// public static Vector256 AlignRight(Vector256 left, Vector256 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) - /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 - /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) + /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 + /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors. /// public static Vector256 AlignRight(Vector256 left, Vector256 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_and_si256 (__m256i a, __m256i b) - /// VPAND ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_and_si256 (__m256i a, __m256i b) + /// VPAND ymm1, ymm2, ymm3/m256 /// public static Vector256 And(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_and_si256 (__m256i a, __m256i b) - /// VPAND ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_and_si256 (__m256i a, __m256i b) + /// VPAND ymm1, ymm2, ymm3/m256 /// public static Vector256 And(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_and_si256 (__m256i a, __m256i b) - /// VPAND ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_and_si256 (__m256i a, __m256i b) + /// VPAND ymm1, ymm2, ymm3/m256 /// public static Vector256 And(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_and_si256 (__m256i a, __m256i b) - /// VPAND ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_and_si256 (__m256i a, __m256i b) + /// VPAND ymm1, ymm2, ymm3/m256 /// public static Vector256 And(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_and_si256 (__m256i a, __m256i b) - /// VPAND ymm1, ymm2, ymm3/m256 - /// VPANDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_and_si256 (__m256i a, __m256i b) + /// VPAND ymm1, ymm2, ymm3/m256 + /// VPANDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 And(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_and_si256 (__m256i a, __m256i b) - /// VPAND ymm1, ymm2, ymm3/m256 - /// VPANDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_and_si256 (__m256i a, __m256i b) + /// VPAND ymm1, ymm2, ymm3/m256 + /// VPANDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 And(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_and_si256 (__m256i a, __m256i b) - /// VPAND ymm1, ymm2, ymm3/m256 - /// VPANDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_and_si256 (__m256i a, __m256i b) + /// VPAND ymm1, ymm2, ymm3/m256 + /// VPANDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 And(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_and_si256 (__m256i a, __m256i b) - /// VPAND ymm1, ymm2, ymm3/m256 - /// VPANDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_and_si256 (__m256i a, __m256i b) + /// VPAND ymm1, ymm2, ymm3/m256 + /// VPANDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 And(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) - /// VPANDN ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) + /// VPANDN ymm1, ymm2, ymm3/m256 /// public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) - /// VPANDN ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) + /// VPANDN ymm1, ymm2, ymm3/m256 /// public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) - /// VPANDN ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) + /// VPANDN ymm1, ymm2, ymm3/m256 /// public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) - /// VPANDN ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) + /// VPANDN ymm1, ymm2, ymm3/m256 /// public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) - /// VPANDN ymm1, ymm2, ymm3/m256 - /// VPANDND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) + /// VPANDN ymm1, ymm2, ymm3/m256 + /// VPANDND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) - /// VPANDN ymm1, ymm2, ymm3/m256 - /// VPANDND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) + /// VPANDN ymm1, ymm2, ymm3/m256 + /// VPANDND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) - /// VPANDN ymm1, ymm2, ymm3/m256 - /// VPANDNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) + /// VPANDN ymm1, ymm2, ymm3/m256 + /// VPANDNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) - /// VPANDN ymm1, ymm2, ymm3/m256 - /// VPANDNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) + /// VPANDN ymm1, ymm2, ymm3/m256 + /// VPANDNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 AndNot(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_avg_epu8 (__m256i a, __m256i b) - /// VPAVGB ymm1, ymm2, ymm3/m256 - /// VPAVGB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_avg_epu8 (__m256i a, __m256i b) + /// VPAVGB ymm1, ymm2, ymm3/m256 + /// VPAVGB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Average(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_avg_epu16 (__m256i a, __m256i b) - /// VPAVGW ymm1, ymm2, ymm3/m256 - /// VPAVGW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_avg_epu16 (__m256i a, __m256i b) + /// VPAVGW ymm1, ymm2, ymm3/m256 + /// VPAVGW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Average(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_blend_epi32 (__m128i a, __m128i b, const int imm8) - /// VPBLENDD xmm1, xmm2, xmm3/m128, imm8 + /// __m128i _mm_blend_epi32 (__m128i a, __m128i b, const int imm8) + /// VPBLENDD xmm1, xmm2, xmm3/m128, imm8 /// public static Vector128 Blend(Vector128 left, Vector128 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_blend_epi32 (__m128i a, __m128i b, const int imm8) - /// VPBLENDD xmm1, xmm2, xmm3/m128, imm8 + /// __m128i _mm_blend_epi32 (__m128i a, __m128i b, const int imm8) + /// VPBLENDD xmm1, xmm2, xmm3/m128, imm8 /// public static Vector128 Blend(Vector128 left, Vector128 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_blend_epi16 (__m256i a, __m256i b, const int imm8) - /// VPBLENDW ymm1, ymm2, ymm3/m256 imm8 + /// __m256i _mm256_blend_epi16 (__m256i a, __m256i b, const int imm8) + /// VPBLENDW ymm1, ymm2, ymm3/m256 imm8 /// public static Vector256 Blend(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_blend_epi16 (__m256i a, __m256i b, const int imm8) - /// VPBLENDW ymm1, ymm2, ymm3/m256 imm8 + /// __m256i _mm256_blend_epi16 (__m256i a, __m256i b, const int imm8) + /// VPBLENDW ymm1, ymm2, ymm3/m256 imm8 /// public static Vector256 Blend(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_blend_epi32 (__m256i a, __m256i b, const int imm8) - /// VPBLENDD ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_blend_epi32 (__m256i a, __m256i b, const int imm8) + /// VPBLENDD ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Blend(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_blend_epi32 (__m256i a, __m256i b, const int imm8) - /// VPBLENDD ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_blend_epi32 (__m256i a, __m256i b, const int imm8) + /// VPBLENDD ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Blend(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) - /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 + /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) + /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 /// public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) - /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 + /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) + /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 /// public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) - /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 - /// This intrinsic generates VPBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. + /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) + /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 + /// This intrinsic generates VPBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. /// public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) - /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 - /// This intrinsic generates VPBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. + /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) + /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 + /// This intrinsic generates VPBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. /// public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) - /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 - /// This intrinsic generates VPBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. + /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) + /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 + /// This intrinsic generates VPBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. /// public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) - /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 - /// This intrinsic generates VPBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. + /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) + /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 + /// This intrinsic generates VPBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. /// public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) - /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 - /// This intrinsic generates VPBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. + /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) + /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 + /// This intrinsic generates VPBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. /// public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) - /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 - /// This intrinsic generates VPBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. + /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) + /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 + /// This intrinsic generates VPBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. /// public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_broadcastb_epi8 (__m128i a) - /// VPBROADCASTB xmm1, xmm2/m8 - /// VPBROADCASTB xmm1 {k1}{z}, xmm2/m8 + /// __m128i _mm_broadcastb_epi8 (__m128i a) + /// VPBROADCASTB xmm1, xmm2/m8 + /// VPBROADCASTB xmm1 {k1}{z}, xmm2/m8 /// public static Vector128 BroadcastScalarToVector128(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_broadcastb_epi8 (__m128i a) - /// VPBROADCASTB xmm1, xmm2/m8 - /// VPBROADCASTB xmm1 {k1}{z}, xmm2/m8 + /// __m128i _mm_broadcastb_epi8 (__m128i a) + /// VPBROADCASTB xmm1, xmm2/m8 + /// VPBROADCASTB xmm1 {k1}{z}, xmm2/m8 /// public static Vector128 BroadcastScalarToVector128(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_broadcastw_epi16 (__m128i a) - /// VPBROADCASTW xmm1, xmm2/m16 - /// VPBROADCASTW xmm1 {k1}{z}, xmm2/m16 + /// __m128i _mm_broadcastw_epi16 (__m128i a) + /// VPBROADCASTW xmm1, xmm2/m16 + /// VPBROADCASTW xmm1 {k1}{z}, xmm2/m16 /// public static Vector128 BroadcastScalarToVector128(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_broadcastw_epi16 (__m128i a) - /// VPBROADCASTW xmm1, xmm2/m16 - /// VPBROADCASTW xmm1 {k1}{z}, xmm2/m16 + /// __m128i _mm_broadcastw_epi16 (__m128i a) + /// VPBROADCASTW xmm1, xmm2/m16 + /// VPBROADCASTW xmm1 {k1}{z}, xmm2/m16 /// public static Vector128 BroadcastScalarToVector128(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_broadcastd_epi32 (__m128i a) - /// VPBROADCASTD xmm1, xmm2/m32 - /// VPBROADCASTD xmm1 {k1}{z}, xmm2/m32 + /// __m128i _mm_broadcastd_epi32 (__m128i a) + /// VPBROADCASTD xmm1, xmm2/m32 + /// VPBROADCASTD xmm1 {k1}{z}, xmm2/m32 /// public static Vector128 BroadcastScalarToVector128(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_broadcastd_epi32 (__m128i a) - /// VPBROADCASTD xmm1, xmm2/m32 - /// VPBROADCASTD xmm1 {k1}{z}, xmm2/m32 + /// __m128i _mm_broadcastd_epi32 (__m128i a) + /// VPBROADCASTD xmm1, xmm2/m32 + /// VPBROADCASTD xmm1 {k1}{z}, xmm2/m32 /// public static Vector128 BroadcastScalarToVector128(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_broadcastq_epi64 (__m128i a) - /// VPBROADCASTQ xmm1, xmm2/m64 - /// VPBROADCASTQ xmm1 {k1}{z}, xmm2/m64 + /// __m128i _mm_broadcastq_epi64 (__m128i a) + /// VPBROADCASTQ xmm1, xmm2/m64 + /// VPBROADCASTQ xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 BroadcastScalarToVector128(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_broadcastq_epi64 (__m128i a) - /// VPBROADCASTQ xmm1, xmm2/m64 - /// VPBROADCASTQ xmm1 {k1}{z}, xmm2/m64 + /// __m128i _mm_broadcastq_epi64 (__m128i a) + /// VPBROADCASTQ xmm1, xmm2/m64 + /// VPBROADCASTQ xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 BroadcastScalarToVector128(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_broadcastss_ps (__m128 a) - /// VBROADCASTSS xmm1, xmm2/m32 - /// VBROADCASTSS xmm1 {k1}{z}, xmm2/m32 + /// __m128 _mm_broadcastss_ps (__m128 a) + /// VBROADCASTSS xmm1, xmm2/m32 + /// VBROADCASTSS xmm1 {k1}{z}, xmm2/m32 /// public static Vector128 BroadcastScalarToVector128(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_broadcastsd_pd (__m128d a) - /// VMOVDDUP xmm1, xmm/m64 + /// __m128d _mm_broadcastsd_pd (__m128d a) + /// VMOVDDUP xmm1, xmm/m64 /// public static Vector128 BroadcastScalarToVector128(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_broadcastb_epi8 (__m128i a) - /// VPBROADCASTB xmm1, m8 - /// VPBROADCASTB xmm1 {k1}{z}, m8 - /// The above native signature does not directly correspond to the managed signature. + /// __m128i _mm_broadcastb_epi8 (__m128i a) + /// VPBROADCASTB xmm1, m8 + /// VPBROADCASTB xmm1 {k1}{z}, m8 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector128 BroadcastScalarToVector128(byte* source) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_broadcastb_epi8 (__m128i a) - /// VPBROADCASTB xmm1, m8 - /// VPBROADCASTB xmm1 {k1}{z}, m8 - /// The above native signature does not directly correspond to the managed signature. + /// __m128i _mm_broadcastb_epi8 (__m128i a) + /// VPBROADCASTB xmm1, m8 + /// VPBROADCASTB xmm1 {k1}{z}, m8 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector128 BroadcastScalarToVector128(sbyte* source) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_broadcastw_epi16 (__m128i a) - /// VPBROADCASTW xmm1, m16 - /// VPBROADCASTW xmm1 {k1}{z}, m16 - /// The above native signature does not directly correspond to the managed signature. + /// __m128i _mm_broadcastw_epi16 (__m128i a) + /// VPBROADCASTW xmm1, m16 + /// VPBROADCASTW xmm1 {k1}{z}, m16 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector128 BroadcastScalarToVector128(short* source) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_broadcastw_epi16 (__m128i a) - /// VPBROADCASTW xmm1, m16 - /// VPBROADCASTW xmm1 {k1}{z}, m16 - /// The above native signature does not directly correspond to the managed signature. + /// __m128i _mm_broadcastw_epi16 (__m128i a) + /// VPBROADCASTW xmm1, m16 + /// VPBROADCASTW xmm1 {k1}{z}, m16 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector128 BroadcastScalarToVector128(ushort* source) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_broadcastd_epi32 (__m128i a) - /// VPBROADCASTD xmm1, m32 - /// VPBROADCASTD xmm1 {k1}{z}, m32 - /// The above native signature does not directly correspond to the managed signature. + /// __m128i _mm_broadcastd_epi32 (__m128i a) + /// VPBROADCASTD xmm1, m32 + /// VPBROADCASTD xmm1 {k1}{z}, m32 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector128 BroadcastScalarToVector128(int* source) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_broadcastd_epi32 (__m128i a) - /// VPBROADCASTD xmm1, m32 - /// VPBROADCASTD xmm1 {k1}{z}, m32 - /// The above native signature does not directly correspond to the managed signature. + /// __m128i _mm_broadcastd_epi32 (__m128i a) + /// VPBROADCASTD xmm1, m32 + /// VPBROADCASTD xmm1 {k1}{z}, m32 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector128 BroadcastScalarToVector128(uint* source) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_broadcastq_epi64 (__m128i a) - /// VPBROADCASTQ xmm1, m64 - /// VPBROADCASTQ xmm1 {k1}{z}, m64 - /// The above native signature does not directly correspond to the managed signature. + /// __m128i _mm_broadcastq_epi64 (__m128i a) + /// VPBROADCASTQ xmm1, m64 + /// VPBROADCASTQ xmm1 {k1}{z}, m64 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector128 BroadcastScalarToVector128(long* source) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_broadcastq_epi64 (__m128i a) - /// VPBROADCASTQ xmm1, m64 - /// VPBROADCASTQ xmm1 {k1}{z}, m64 - /// The above native signature does not directly correspond to the managed signature. + /// __m128i _mm_broadcastq_epi64 (__m128i a) + /// VPBROADCASTQ xmm1, m64 + /// VPBROADCASTQ xmm1 {k1}{z}, m64 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector128 BroadcastScalarToVector128(ulong* source) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcastb_epi8 (__m128i a) - /// VPBROADCASTB ymm1, xmm2/m8 - /// VPBROADCASTB ymm1 {k1}{z}, xmm2/m8 + /// __m256i _mm256_broadcastb_epi8 (__m128i a) + /// VPBROADCASTB ymm1, xmm2/m8 + /// VPBROADCASTB ymm1 {k1}{z}, xmm2/m8 /// public static Vector256 BroadcastScalarToVector256(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcastb_epi8 (__m128i a) - /// VPBROADCASTB ymm1, xmm2/m8 - /// VPBROADCASTB ymm1 {k1}{z}, xmm2/m8 + /// __m256i _mm256_broadcastb_epi8 (__m128i a) + /// VPBROADCASTB ymm1, xmm2/m8 + /// VPBROADCASTB ymm1 {k1}{z}, xmm2/m8 /// public static Vector256 BroadcastScalarToVector256(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcastw_epi16 (__m128i a) - /// VPBROADCASTW ymm1, xmm2/m16 - /// VPBROADCASTW ymm1 {k1}{z}, xmm2/m16 + /// __m256i _mm256_broadcastw_epi16 (__m128i a) + /// VPBROADCASTW ymm1, xmm2/m16 + /// VPBROADCASTW ymm1 {k1}{z}, xmm2/m16 /// public static Vector256 BroadcastScalarToVector256(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcastw_epi16 (__m128i a) - /// VPBROADCASTW ymm1, xmm2/m16 - /// VPBROADCASTW ymm1 {k1}{z}, xmm2/m16 + /// __m256i _mm256_broadcastw_epi16 (__m128i a) + /// VPBROADCASTW ymm1, xmm2/m16 + /// VPBROADCASTW ymm1 {k1}{z}, xmm2/m16 /// public static Vector256 BroadcastScalarToVector256(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcastd_epi32 (__m128i a) - /// VPBROADCASTD ymm1, xmm2/m32 - /// VPBROADCASTD ymm1 {k1}{z}, xmm2/m32 + /// __m256i _mm256_broadcastd_epi32 (__m128i a) + /// VPBROADCASTD ymm1, xmm2/m32 + /// VPBROADCASTD ymm1 {k1}{z}, xmm2/m32 /// public static Vector256 BroadcastScalarToVector256(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcastd_epi32 (__m128i a) - /// VPBROADCASTD ymm1, xmm2/m32 - /// VPBROADCASTD ymm1 {k1}{z}, xmm2/m32 + /// __m256i _mm256_broadcastd_epi32 (__m128i a) + /// VPBROADCASTD ymm1, xmm2/m32 + /// VPBROADCASTD ymm1 {k1}{z}, xmm2/m32 /// public static Vector256 BroadcastScalarToVector256(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcastq_epi64 (__m128i a) - /// VPBROADCASTQ ymm1, xmm2/m64 - /// VPBROADCASTQ ymm1 {k1}{z}, xmm2/m64 + /// __m256i _mm256_broadcastq_epi64 (__m128i a) + /// VPBROADCASTQ ymm1, xmm2/m64 + /// VPBROADCASTQ ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 BroadcastScalarToVector256(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcastq_epi64 (__m128i a) - /// VPBROADCASTQ ymm1, xmm2/m64 - /// VPBROADCASTQ ymm1 {k1}{z}, xmm2/m64 + /// __m256i _mm256_broadcastq_epi64 (__m128i a) + /// VPBROADCASTQ ymm1, xmm2/m64 + /// VPBROADCASTQ ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 BroadcastScalarToVector256(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_broadcastss_ps (__m128 a) - /// VBROADCASTSS ymm1, xmm2/m32 - /// VBROADCASTSS ymm1 {k1}{z}, xmm2/m32 + /// __m256 _mm256_broadcastss_ps (__m128 a) + /// VBROADCASTSS ymm1, xmm2/m32 + /// VBROADCASTSS ymm1 {k1}{z}, xmm2/m32 /// public static Vector256 BroadcastScalarToVector256(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_broadcastsd_pd (__m128d a) - /// VBROADCASTSD ymm1, xmm2/m64 - /// VBROADCASTSD ymm1 {k1}{z}, xmm2/m64 + /// __m256d _mm256_broadcastsd_pd (__m128d a) + /// VBROADCASTSD ymm1, xmm2/m64 + /// VBROADCASTSD ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 BroadcastScalarToVector256(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcastb_epi8 (__m128i a) - /// VPBROADCASTB ymm1, m8 - /// VPBROADCASTB ymm1 {k1}{z}, m8 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastb_epi8 (__m128i a) + /// VPBROADCASTB ymm1, m8 + /// VPBROADCASTB ymm1 {k1}{z}, m8 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastScalarToVector256(byte* source) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcastb_epi8 (__m128i a) - /// VPBROADCASTB ymm1, m8 - /// VPBROADCASTB ymm1 {k1}{z}, m8 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastb_epi8 (__m128i a) + /// VPBROADCASTB ymm1, m8 + /// VPBROADCASTB ymm1 {k1}{z}, m8 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastScalarToVector256(sbyte* source) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcastw_epi16 (__m128i a) - /// VPBROADCASTW ymm1, m16 - /// VPBROADCASTW ymm1 {k1}{z}, m16 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastw_epi16 (__m128i a) + /// VPBROADCASTW ymm1, m16 + /// VPBROADCASTW ymm1 {k1}{z}, m16 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastScalarToVector256(short* source) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcastw_epi16 (__m128i a) - /// VPBROADCASTW ymm1, m16 - /// VPBROADCASTW ymm1 {k1}{z}, m16 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastw_epi16 (__m128i a) + /// VPBROADCASTW ymm1, m16 + /// VPBROADCASTW ymm1 {k1}{z}, m16 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastScalarToVector256(ushort* source) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcastd_epi32 (__m128i a) - /// VPBROADCASTD ymm1, m32 - /// VPBROADCASTD ymm1 {k1}{z}, m32 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastd_epi32 (__m128i a) + /// VPBROADCASTD ymm1, m32 + /// VPBROADCASTD ymm1 {k1}{z}, m32 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastScalarToVector256(int* source) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcastd_epi32 (__m128i a) - /// VPBROADCASTD ymm1, m32 - /// VPBROADCASTD ymm1 {k1}{z}, m32 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastd_epi32 (__m128i a) + /// VPBROADCASTD ymm1, m32 + /// VPBROADCASTD ymm1 {k1}{z}, m32 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastScalarToVector256(uint* source) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcastq_epi64 (__m128i a) - /// VPBROADCASTQ ymm1, m64 - /// VPBROADCASTQ ymm1 {k1}{z}, m64 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastq_epi64 (__m128i a) + /// VPBROADCASTQ ymm1, m64 + /// VPBROADCASTQ ymm1 {k1}{z}, m64 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastScalarToVector256(long* source) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcastq_epi64 (__m128i a) - /// VPBROADCASTQ ymm1, m64 - /// VPBROADCASTQ ymm1 {k1}{z}, m64 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastq_epi64 (__m128i a) + /// VPBROADCASTQ ymm1, m64 + /// VPBROADCASTQ ymm1 {k1}{z}, m64 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastScalarToVector256(ulong* source) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcastsi128_si256 (__m128i a) - /// VBROADCASTI128 ymm1, m128 - /// VBROADCASTI32x4 ymm1 {k1}{z}, m128 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastsi128_si256 (__m128i a) + /// VBROADCASTI128 ymm1, m128 + /// VBROADCASTI32x4 ymm1 {k1}{z}, m128 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastVector128ToVector256(sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcastsi128_si256 (__m128i a) - /// VBROADCASTI128 ymm1, m128 - /// VBROADCASTI32x4 ymm1 {k1}{z}, m128 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastsi128_si256 (__m128i a) + /// VBROADCASTI128 ymm1, m128 + /// VBROADCASTI32x4 ymm1 {k1}{z}, m128 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastVector128ToVector256(byte* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcastsi128_si256 (__m128i a) - /// VBROADCASTI128 ymm1, m128 - /// VBROADCASTI32x4 ymm1 {k1}{z}, m128 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastsi128_si256 (__m128i a) + /// VBROADCASTI128 ymm1, m128 + /// VBROADCASTI32x4 ymm1 {k1}{z}, m128 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastVector128ToVector256(short* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcastsi128_si256 (__m128i a) - /// VBROADCASTI128 ymm1, m128 - /// VBROADCASTI32x4 ymm1 {k1}{z}, m128 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastsi128_si256 (__m128i a) + /// VBROADCASTI128 ymm1, m128 + /// VBROADCASTI32x4 ymm1 {k1}{z}, m128 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastVector128ToVector256(ushort* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcastsi128_si256 (__m128i a) - /// VBROADCASTI128 ymm1, m128 - /// VBROADCASTI32x4 ymm1 {k1}{z}, m128 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastsi128_si256 (__m128i a) + /// VBROADCASTI128 ymm1, m128 + /// VBROADCASTI32x4 ymm1 {k1}{z}, m128 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastVector128ToVector256(int* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcastsi128_si256 (__m128i a) - /// VBROADCASTI128 ymm1, m128 - /// VBROADCASTI32x4 ymm1 {k1}{z}, m128 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastsi128_si256 (__m128i a) + /// VBROADCASTI128 ymm1, m128 + /// VBROADCASTI32x4 ymm1 {k1}{z}, m128 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastVector128ToVector256(uint* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcastsi128_si256 (__m128i a) - /// VBROADCASTI128 ymm1, m128 - /// VBROADCASTI64x2 ymm1 {k1}{z}, m128 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastsi128_si256 (__m128i a) + /// VBROADCASTI128 ymm1, m128 + /// VBROADCASTI64x2 ymm1 {k1}{z}, m128 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastVector128ToVector256(long* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcastsi128_si256 (__m128i a) - /// VBROADCASTI128 ymm1, m128 - /// VBROADCASTI64x2 ymm1 {k1}{z}, m128 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastsi128_si256 (__m128i a) + /// VBROADCASTI128 ymm1, m128 + /// VBROADCASTI64x2 ymm1 {k1}{z}, m128 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastVector128ToVector256(ulong* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpeq_epi8 (__m256i a, __m256i b) - /// VPCMPEQB ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_cmpeq_epi8 (__m256i a, __m256i b) + /// VPCMPEQB ymm1, ymm2, ymm3/m256 /// public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpeq_epi8 (__m256i a, __m256i b) - /// VPCMPEQB ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_cmpeq_epi8 (__m256i a, __m256i b) + /// VPCMPEQB ymm1, ymm2, ymm3/m256 /// public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpeq_epi16 (__m256i a, __m256i b) - /// VPCMPEQW ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_cmpeq_epi16 (__m256i a, __m256i b) + /// VPCMPEQW ymm1, ymm2, ymm3/m256 /// public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpeq_epi16 (__m256i a, __m256i b) - /// VPCMPEQW ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_cmpeq_epi16 (__m256i a, __m256i b) + /// VPCMPEQW ymm1, ymm2, ymm3/m256 /// public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpeq_epi32 (__m256i a, __m256i b) - /// VPCMPEQD ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_cmpeq_epi32 (__m256i a, __m256i b) + /// VPCMPEQD ymm1, ymm2, ymm3/m256 /// public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpeq_epi32 (__m256i a, __m256i b) - /// VPCMPEQD ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_cmpeq_epi32 (__m256i a, __m256i b) + /// VPCMPEQD ymm1, ymm2, ymm3/m256 /// public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpeq_epi64 (__m256i a, __m256i b) - /// VPCMPEQQ ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_cmpeq_epi64 (__m256i a, __m256i b) + /// VPCMPEQQ ymm1, ymm2, ymm3/m256 /// public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpeq_epi64 (__m256i a, __m256i b) - /// VPCMPEQQ ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_cmpeq_epi64 (__m256i a, __m256i b) + /// VPCMPEQQ ymm1, ymm2, ymm3/m256 /// public static Vector256 CompareEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpgt_epi8 (__m256i a, __m256i b) - /// VPCMPGTB ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_cmpgt_epi8 (__m256i a, __m256i b) + /// VPCMPGTB ymm1, ymm2, ymm3/m256 /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpgt_epi16 (__m256i a, __m256i b) - /// VPCMPGTW ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_cmpgt_epi16 (__m256i a, __m256i b) + /// VPCMPGTW ymm1, ymm2, ymm3/m256 /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpgt_epi32 (__m256i a, __m256i b) - /// VPCMPGTD ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_cmpgt_epi32 (__m256i a, __m256i b) + /// VPCMPGTD ymm1, ymm2, ymm3/m256 /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpgt_epi64 (__m256i a, __m256i b) - /// VPCMPGTQ ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_cmpgt_epi64 (__m256i a, __m256i b) + /// VPCMPGTQ ymm1, ymm2, ymm3/m256 /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_cvtsi256_si32 (__m256i a) - /// VMOVD r/m32, ymm1 + /// int _mm256_cvtsi256_si32 (__m256i a) + /// VMOVD r/m32, ymm1 /// public static int ConvertToInt32(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_cvtsi256_si32 (__m256i a) - /// VMOVD r/m32, ymm1 + /// int _mm256_cvtsi256_si32 (__m256i a) + /// VMOVD r/m32, ymm1 /// public static uint ConvertToUInt32(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvtepi8_epi16 (__m128i a) - /// VPMOVSXBW ymm1, xmm2/m128 - /// VPMOVSXBW ymm1 {k1}{z}, xmm2/m128 + /// __m256i _mm256_cvtepi8_epi16 (__m128i a) + /// VPMOVSXBW ymm1, xmm2/m128 + /// VPMOVSXBW ymm1 {k1}{z}, xmm2/m128 /// public static Vector256 ConvertToVector256Int16(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvtepu8_epi16 (__m128i a) - /// VPMOVZXBW ymm1, xmm2/m128 - /// VPMOVZXBW ymm1 {k1}{z}, xmm2/m128 + /// __m256i _mm256_cvtepu8_epi16 (__m128i a) + /// VPMOVZXBW ymm1, xmm2/m128 + /// VPMOVZXBW ymm1 {k1}{z}, xmm2/m128 /// public static Vector256 ConvertToVector256Int16(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvtepi8_epi32 (__m128i a) - /// VPMOVSXBD ymm1, xmm2/m64 - /// VPMOVSXBD ymm1 {k1}{z}, xmm2/m64 + /// __m256i _mm256_cvtepi8_epi32 (__m128i a) + /// VPMOVSXBD ymm1, xmm2/m64 + /// VPMOVSXBD ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 ConvertToVector256Int32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvtepu8_epi32 (__m128i a) - /// VPMOVZXBD ymm1, xmm2/m64 - /// VPMOVZXBD ymm1 {k1}{z}, xmm2/m64 + /// __m256i _mm256_cvtepu8_epi32 (__m128i a) + /// VPMOVZXBD ymm1, xmm2/m64 + /// VPMOVZXBD ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 ConvertToVector256Int32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvtepi16_epi32 (__m128i a) - /// VPMOVSXWD ymm1, xmm2/m128 - /// VPMOVSXWD ymm1 {k1}{z}, xmm2/m128 + /// __m256i _mm256_cvtepi16_epi32 (__m128i a) + /// VPMOVSXWD ymm1, xmm2/m128 + /// VPMOVSXWD ymm1 {k1}{z}, xmm2/m128 /// public static Vector256 ConvertToVector256Int32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvtepu16_epi32 (__m128i a) - /// VPMOVZXWD ymm1, xmm2/m128 - /// VPMOVZXWD ymm1 {k1}{z}, xmm2/m128 + /// __m256i _mm256_cvtepu16_epi32 (__m128i a) + /// VPMOVZXWD ymm1, xmm2/m128 + /// VPMOVZXWD ymm1 {k1}{z}, xmm2/m128 /// public static Vector256 ConvertToVector256Int32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvtepi8_epi64 (__m128i a) - /// VPMOVSXBQ ymm1, xmm2/m32 - /// VPMOVSXBQ ymm1 {k1}{z}, xmm2/m32 + /// __m256i _mm256_cvtepi8_epi64 (__m128i a) + /// VPMOVSXBQ ymm1, xmm2/m32 + /// VPMOVSXBQ ymm1 {k1}{z}, xmm2/m32 /// public static Vector256 ConvertToVector256Int64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvtepu8_epi64 (__m128i a) - /// VPMOVZXBQ ymm1, xmm2/m32 - /// VPMOVZXBQ ymm1 {k1}{z}, xmm2/m32 + /// __m256i _mm256_cvtepu8_epi64 (__m128i a) + /// VPMOVZXBQ ymm1, xmm2/m32 + /// VPMOVZXBQ ymm1 {k1}{z}, xmm2/m32 /// public static Vector256 ConvertToVector256Int64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvtepi16_epi64 (__m128i a) - /// VPMOVSXWQ ymm1, xmm2/m64 - /// VPMOVSXWQ ymm1 {k1}{z}, xmm2/m64 + /// __m256i _mm256_cvtepi16_epi64 (__m128i a) + /// VPMOVSXWQ ymm1, xmm2/m64 + /// VPMOVSXWQ ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 ConvertToVector256Int64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvtepu16_epi64 (__m128i a) - /// VPMOVZXWQ ymm1, xmm2/m64 - /// VPMOVZXWQ ymm1 {k1}{z}, xmm2/m64 + /// __m256i _mm256_cvtepu16_epi64 (__m128i a) + /// VPMOVZXWQ ymm1, xmm2/m64 + /// VPMOVZXWQ ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 ConvertToVector256Int64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvtepi32_epi64 (__m128i a) - /// VPMOVSXDQ ymm1, xmm2/m128 - /// VPMOVSXDQ ymm1 {k1}{z}, xmm2/m128 + /// __m256i _mm256_cvtepi32_epi64 (__m128i a) + /// VPMOVSXDQ ymm1, xmm2/m128 + /// VPMOVSXDQ ymm1 {k1}{z}, xmm2/m128 /// public static Vector256 ConvertToVector256Int64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvtepu32_epi64 (__m128i a) - /// VPMOVZXDQ ymm1, xmm2/m128 - /// VPMOVZXDQ ymm1 {k1}{z}, xmm2/m128 + /// __m256i _mm256_cvtepu32_epi64 (__m128i a) + /// VPMOVZXDQ ymm1, xmm2/m128 + /// VPMOVZXDQ ymm1 {k1}{z}, xmm2/m128 /// public static Vector256 ConvertToVector256Int64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// VPMOVSXBW ymm1, m128 - /// VPMOVSXBW ymm1 {k1}{z}, m128 - /// The native signature does not exist. We provide this additional overload for completeness. + /// VPMOVSXBW ymm1, m128 + /// VPMOVSXBW ymm1 {k1}{z}, m128 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector256 ConvertToVector256Int16(sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// VPMOVZXBW ymm1, m128 - /// VPMOVZXBW ymm1 {k1}{z}, m128 - /// The native signature does not exist. We provide this additional overload for completeness. + /// VPMOVZXBW ymm1, m128 + /// VPMOVZXBW ymm1 {k1}{z}, m128 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector256 ConvertToVector256Int16(byte* address) { throw new PlatformNotSupportedException(); } /// - /// VPMOVSXBD ymm1, m64 - /// VPMOVSXBD ymm1 {k1}{z}, m64 - /// The native signature does not exist. We provide this additional overload for completeness. + /// VPMOVSXBD ymm1, m64 + /// VPMOVSXBD ymm1 {k1}{z}, m64 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector256 ConvertToVector256Int32(sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// VPMOVZXBD ymm1, m64 - /// VPMOVZXBD ymm1 {k1}{z}, m64 - /// The native signature does not exist. We provide this additional overload for completeness. + /// VPMOVZXBD ymm1, m64 + /// VPMOVZXBD ymm1 {k1}{z}, m64 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector256 ConvertToVector256Int32(byte* address) { throw new PlatformNotSupportedException(); } /// - /// VPMOVSXWD ymm1, m128 - /// VPMOVSXWD ymm1 {k1}{z}, m128 - /// The native signature does not exist. We provide this additional overload for completeness. + /// VPMOVSXWD ymm1, m128 + /// VPMOVSXWD ymm1 {k1}{z}, m128 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector256 ConvertToVector256Int32(short* address) { throw new PlatformNotSupportedException(); } /// - /// VPMOVZXWD ymm1, m128 - /// VPMOVZXWD ymm1 {k1}{z}, m128 - /// The native signature does not exist. We provide this additional overload for completeness. + /// VPMOVZXWD ymm1, m128 + /// VPMOVZXWD ymm1 {k1}{z}, m128 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector256 ConvertToVector256Int32(ushort* address) { throw new PlatformNotSupportedException(); } /// - /// VPMOVSXBQ ymm1, m32 - /// VPMOVSXBQ ymm1 {k1}{z}, m32 - /// The native signature does not exist. We provide this additional overload for completeness. + /// VPMOVSXBQ ymm1, m32 + /// VPMOVSXBQ ymm1 {k1}{z}, m32 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector256 ConvertToVector256Int64(sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// VPMOVZXBQ ymm1, m32 - /// VPMOVZXBQ ymm1 {k1}{z}, m32 - /// The native signature does not exist. We provide this additional overload for completeness. + /// VPMOVZXBQ ymm1, m32 + /// VPMOVZXBQ ymm1 {k1}{z}, m32 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector256 ConvertToVector256Int64(byte* address) { throw new PlatformNotSupportedException(); } /// - /// VPMOVSXWQ ymm1, m64 - /// VPMOVSXWQ ymm1 {k1}{z}, m64 - /// The native signature does not exist. We provide this additional overload for completeness. + /// VPMOVSXWQ ymm1, m64 + /// VPMOVSXWQ ymm1 {k1}{z}, m64 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector256 ConvertToVector256Int64(short* address) { throw new PlatformNotSupportedException(); } /// - /// VPMOVZXWQ ymm1, m64 - /// VPMOVZXWQ ymm1 {k1}{z}, m64 - /// The native signature does not exist. We provide this additional overload for completeness. + /// VPMOVZXWQ ymm1, m64 + /// VPMOVZXWQ ymm1 {k1}{z}, m64 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector256 ConvertToVector256Int64(ushort* address) { throw new PlatformNotSupportedException(); } /// - /// VPMOVSXDQ ymm1, m128 - /// VPMOVSXDQ ymm1 {k1}{z}, m128 - /// The native signature does not exist. We provide this additional overload for completeness. + /// VPMOVSXDQ ymm1, m128 + /// VPMOVSXDQ ymm1 {k1}{z}, m128 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector256 ConvertToVector256Int64(int* address) { throw new PlatformNotSupportedException(); } /// - /// VPMOVZXDQ ymm1, m128 - /// VPMOVZXDQ ymm1 {k1}{z}, m128 - /// The native signature does not exist. We provide this additional overload for completeness. + /// VPMOVZXDQ ymm1, m128 + /// VPMOVZXDQ ymm1 {k1}{z}, m128 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector256 ConvertToVector256Int64(uint* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) - /// VEXTRACTI128 xmm1/m128, ymm2, imm8 - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// VEXTRACTI128 xmm1/m128, ymm2, imm8 + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static new Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) - /// VEXTRACTI128 xmm1/m128, ymm2, imm8 - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// VEXTRACTI128 xmm1/m128, ymm2, imm8 + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static new Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) - /// VEXTRACTI128 xmm1/m128, ymm2, imm8 - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// VEXTRACTI128 xmm1/m128, ymm2, imm8 + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static new Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) - /// VEXTRACTI128 xmm1/m128, ymm2, imm8 - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// VEXTRACTI128 xmm1/m128, ymm2, imm8 + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static new Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) - /// VEXTRACTI128 xmm1/m128, ymm2, imm8 - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// VEXTRACTI128 xmm1/m128, ymm2, imm8 + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static new Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) - /// VEXTRACTI128 xmm1/m128, ymm2, imm8 - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// VEXTRACTI128 xmm1/m128, ymm2, imm8 + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static new Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) - /// VEXTRACTI128 xmm1/m128, ymm2, imm8 - /// VEXTRACTI64x2 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// VEXTRACTI128 xmm1/m128, ymm2, imm8 + /// VEXTRACTI64x2 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static new Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) - /// VEXTRACTI128 xmm1/m128, ymm2, imm8 - /// VEXTRACTI64x2 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// VEXTRACTI128 xmm1/m128, ymm2, imm8 + /// VEXTRACTI64x2 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static new Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_i32gather_epi32 (int const* base_addr, __m128i vindex, const int scale) - /// VPGATHERDD xmm1, vm32x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_i32gather_epi32 (int const* base_addr, __m128i vindex, const int scale) + /// VPGATHERDD xmm1, vm32x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(int* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_i32gather_epi32 (int const* base_addr, __m128i vindex, const int scale) - /// VPGATHERDD xmm1, vm32x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_i32gather_epi32 (int const* base_addr, __m128i vindex, const int scale) + /// VPGATHERDD xmm1, vm32x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(uint* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) - /// VPGATHERDQ xmm1, vm32x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) + /// VPGATHERDQ xmm1, vm32x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(long* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) - /// VPGATHERDQ xmm1, vm32x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) + /// VPGATHERDQ xmm1, vm32x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(ulong* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_i32gather_ps (float const* base_addr, __m128i vindex, const int scale) - /// VGATHERDPS xmm1, vm32x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128 _mm_i32gather_ps (float const* base_addr, __m128i vindex, const int scale) + /// VGATHERDPS xmm1, vm32x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(float* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_i32gather_pd (double const* base_addr, __m128i vindex, const int scale) - /// VGATHERDPD xmm1, vm32x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128d _mm_i32gather_pd (double const* base_addr, __m128i vindex, const int scale) + /// VGATHERDPD xmm1, vm32x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(double* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_i64gather_epi32 (int const* base_addr, __m128i vindex, const int scale) - /// VPGATHERQD xmm1, vm64x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_i64gather_epi32 (int const* base_addr, __m128i vindex, const int scale) + /// VPGATHERQD xmm1, vm64x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(int* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_i64gather_epi32 (int const* base_addr, __m128i vindex, const int scale) - /// VPGATHERQD xmm1, vm64x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_i64gather_epi32 (int const* base_addr, __m128i vindex, const int scale) + /// VPGATHERQD xmm1, vm64x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(uint* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_i64gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) - /// VPGATHERQQ xmm1, vm64x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_i64gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) + /// VPGATHERQQ xmm1, vm64x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(long* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_i64gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) - /// VPGATHERQQ xmm1, vm64x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_i64gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) + /// VPGATHERQQ xmm1, vm64x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(ulong* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_i64gather_ps (float const* base_addr, __m128i vindex, const int scale) - /// VGATHERQPS xmm1, vm64x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128 _mm_i64gather_ps (float const* base_addr, __m128i vindex, const int scale) + /// VGATHERQPS xmm1, vm64x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(float* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_i64gather_pd (double const* base_addr, __m128i vindex, const int scale) - /// VGATHERQPD xmm1, vm64x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128d _mm_i64gather_pd (double const* base_addr, __m128i vindex, const int scale) + /// VGATHERQPD xmm1, vm64x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(double* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_i32gather_epi32 (int const* base_addr, __m256i vindex, const int scale) - /// VPGATHERDD ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256i _mm256_i32gather_epi32 (int const* base_addr, __m256i vindex, const int scale) + /// VPGATHERDD ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherVector256(int* baseAddress, Vector256 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_i32gather_epi32 (int const* base_addr, __m256i vindex, const int scale) - /// VPGATHERDD ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256i _mm256_i32gather_epi32 (int const* base_addr, __m256i vindex, const int scale) + /// VPGATHERDD ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherVector256(uint* baseAddress, Vector256 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) - /// VPGATHERDQ ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256i _mm256_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) + /// VPGATHERDQ ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherVector256(long* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) - /// VPGATHERDQ ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256i _mm256_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) + /// VPGATHERDQ ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherVector256(ulong* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_i32gather_ps (float const* base_addr, __m256i vindex, const int scale) - /// VGATHERDPS ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256 _mm256_i32gather_ps (float const* base_addr, __m256i vindex, const int scale) + /// VGATHERDPS ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherVector256(float* baseAddress, Vector256 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_i32gather_pd (double const* base_addr, __m128i vindex, const int scale) - /// VGATHERDPD ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256d _mm256_i32gather_pd (double const* base_addr, __m128i vindex, const int scale) + /// VGATHERDPD ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherVector256(double* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_i64gather_epi32 (int const* base_addr, __m256i vindex, const int scale) - /// VPGATHERQD xmm1, vm64y, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm256_i64gather_epi32 (int const* base_addr, __m256i vindex, const int scale) + /// VPGATHERQD xmm1, vm64y, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(int* baseAddress, Vector256 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_i64gather_epi32 (int const* base_addr, __m256i vindex, const int scale) - /// VPGATHERQD xmm1, vm64y, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm256_i64gather_epi32 (int const* base_addr, __m256i vindex, const int scale) + /// VPGATHERQD xmm1, vm64y, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(uint* baseAddress, Vector256 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_i64gather_epi64 (__int64 const* base_addr, __m256i vindex, const int scale) - /// VPGATHERQQ ymm1, vm64y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256i _mm256_i64gather_epi64 (__int64 const* base_addr, __m256i vindex, const int scale) + /// VPGATHERQQ ymm1, vm64y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherVector256(long* baseAddress, Vector256 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_i64gather_epi64 (__int64 const* base_addr, __m256i vindex, const int scale) - /// VPGATHERQQ ymm1, vm64y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256i _mm256_i64gather_epi64 (__int64 const* base_addr, __m256i vindex, const int scale) + /// VPGATHERQQ ymm1, vm64y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherVector256(ulong* baseAddress, Vector256 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm256_i64gather_ps (float const* base_addr, __m256i vindex, const int scale) - /// VGATHERQPS xmm1, vm64y, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128 _mm256_i64gather_ps (float const* base_addr, __m256i vindex, const int scale) + /// VGATHERQPS xmm1, vm64y, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(float* baseAddress, Vector256 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_i64gather_pd (double const* base_addr, __m256i vindex, const int scale) - /// VGATHERQPD ymm1, vm64y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256d _mm256_i64gather_pd (double const* base_addr, __m256i vindex, const int scale) + /// VGATHERQPD ymm1, vm64y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherVector256(double* baseAddress, Vector256 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_mask_i32gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale) - /// VPGATHERDD xmm1, vm32x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_mask_i32gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale) + /// VPGATHERDD xmm1, vm32x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, int* baseAddress, Vector128 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_mask_i32gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale) - /// VPGATHERDD xmm1, vm32x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_mask_i32gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale) + /// VPGATHERDD xmm1, vm32x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, uint* baseAddress, Vector128 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_mask_i32gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) - /// VPGATHERDQ xmm1, vm32x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_mask_i32gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) + /// VPGATHERDQ xmm1, vm32x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, long* baseAddress, Vector128 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_mask_i32gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) - /// VPGATHERDQ xmm1, vm32x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_mask_i32gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) + /// VPGATHERDQ xmm1, vm32x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, ulong* baseAddress, Vector128 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_mask_i32gather_ps (__m128 src, float const* base_addr, __m128i vindex, __m128 mask, const int scale) - /// VGATHERDPS xmm1, vm32x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128 _mm_mask_i32gather_ps (__m128 src, float const* base_addr, __m128i vindex, __m128 mask, const int scale) + /// VGATHERDPS xmm1, vm32x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, float* baseAddress, Vector128 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_mask_i32gather_pd (__m128d src, double const* base_addr, __m128i vindex, __m128d mask, const int scale) - /// VGATHERDPD xmm1, vm32x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128d _mm_mask_i32gather_pd (__m128d src, double const* base_addr, __m128i vindex, __m128d mask, const int scale) + /// VGATHERDPD xmm1, vm32x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, double* baseAddress, Vector128 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale) - /// VPGATHERQD xmm1, vm64x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale) + /// VPGATHERQD xmm1, vm64x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, int* baseAddress, Vector128 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale) - /// VPGATHERQD xmm1, vm64x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale) + /// VPGATHERQD xmm1, vm64x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, uint* baseAddress, Vector128 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_mask_i64gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) - /// VPGATHERQQ xmm1, vm64x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_mask_i64gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) + /// VPGATHERQQ xmm1, vm64x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, long* baseAddress, Vector128 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_mask_i64gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) - /// VPGATHERQQ xmm1, vm64x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_mask_i64gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) + /// VPGATHERQQ xmm1, vm64x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, ulong* baseAddress, Vector128 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_mask_i64gather_ps (__m128 src, float const* base_addr, __m128i vindex, __m128 mask, const int scale) - /// VGATHERQPS xmm1, vm64x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128 _mm_mask_i64gather_ps (__m128 src, float const* base_addr, __m128i vindex, __m128 mask, const int scale) + /// VGATHERQPS xmm1, vm64x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, float* baseAddress, Vector128 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_mask_i64gather_pd (__m128d src, double const* base_addr, __m128i vindex, __m128d mask, const int scale) - /// VGATHERQPD xmm1, vm64x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128d _mm_mask_i64gather_pd (__m128d src, double const* base_addr, __m128i vindex, __m128d mask, const int scale) + /// VGATHERQPD xmm1, vm64x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, double* baseAddress, Vector128 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_mask_i32gather_epi32 (__m256i src, int const* base_addr, __m256i vindex, __m256i mask, const int scale) - /// VPGATHERDD ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256i _mm256_mask_i32gather_epi32 (__m256i src, int const* base_addr, __m256i vindex, __m256i mask, const int scale) + /// VPGATHERDD ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherMaskVector256(Vector256 source, int* baseAddress, Vector256 index, Vector256 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_mask_i32gather_epi32 (__m256i src, int const* base_addr, __m256i vindex, __m256i mask, const int scale) - /// VPGATHERDD ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256i _mm256_mask_i32gather_epi32 (__m256i src, int const* base_addr, __m256i vindex, __m256i mask, const int scale) + /// VPGATHERDD ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherMaskVector256(Vector256 source, uint* baseAddress, Vector256 index, Vector256 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_mask_i32gather_epi64 (__m256i src, __int64 const* base_addr, __m128i vindex, __m256i mask, const int scale) - /// VPGATHERDQ ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256i _mm256_mask_i32gather_epi64 (__m256i src, __int64 const* base_addr, __m128i vindex, __m256i mask, const int scale) + /// VPGATHERDQ ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherMaskVector256(Vector256 source, long* baseAddress, Vector128 index, Vector256 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_mask_i32gather_epi64 (__m256i src, __int64 const* base_addr, __m128i vindex, __m256i mask, const int scale) - /// VPGATHERDQ ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256i _mm256_mask_i32gather_epi64 (__m256i src, __int64 const* base_addr, __m128i vindex, __m256i mask, const int scale) + /// VPGATHERDQ ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherMaskVector256(Vector256 source, ulong* baseAddress, Vector128 index, Vector256 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_mask_i32gather_ps (__m256 src, float const* base_addr, __m256i vindex, __m256 mask, const int scale) - /// VPGATHERDPS ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256 _mm256_mask_i32gather_ps (__m256 src, float const* base_addr, __m256i vindex, __m256 mask, const int scale) + /// VPGATHERDPS ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherMaskVector256(Vector256 source, float* baseAddress, Vector256 index, Vector256 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_mask_i32gather_pd (__m256d src, double const* base_addr, __m128i vindex, __m256d mask, const int scale) - /// VPGATHERDPD ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256d _mm256_mask_i32gather_pd (__m256d src, double const* base_addr, __m128i vindex, __m256d mask, const int scale) + /// VPGATHERDPD ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherMaskVector256(Vector256 source, double* baseAddress, Vector128 index, Vector256 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m256i vindex, __m128i mask, const int scale) - /// VPGATHERQD xmm1, vm32y, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm256_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m256i vindex, __m128i mask, const int scale) + /// VPGATHERQD xmm1, vm32y, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, int* baseAddress, Vector256 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m256i vindex, __m128i mask, const int scale) - /// VPGATHERQD xmm1, vm32y, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm256_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m256i vindex, __m128i mask, const int scale) + /// VPGATHERQD xmm1, vm32y, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, uint* baseAddress, Vector256 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_mask_i64gather_epi64 (__m256i src, __int64 const* base_addr, __m256i vindex, __m256i mask, const int scale) - /// VPGATHERQQ ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256i _mm256_mask_i64gather_epi64 (__m256i src, __int64 const* base_addr, __m256i vindex, __m256i mask, const int scale) + /// VPGATHERQQ ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherMaskVector256(Vector256 source, long* baseAddress, Vector256 index, Vector256 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_mask_i64gather_epi64 (__m256i src, __int64 const* base_addr, __m256i vindex, __m256i mask, const int scale) - /// VPGATHERQQ ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256i _mm256_mask_i64gather_epi64 (__m256i src, __int64 const* base_addr, __m256i vindex, __m256i mask, const int scale) + /// VPGATHERQQ ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherMaskVector256(Vector256 source, ulong* baseAddress, Vector256 index, Vector256 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm256_mask_i64gather_ps (__m128 src, float const* base_addr, __m256i vindex, __m128 mask, const int scale) - /// VGATHERQPS xmm1, vm32y, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128 _mm256_mask_i64gather_ps (__m128 src, float const* base_addr, __m256i vindex, __m128 mask, const int scale) + /// VGATHERQPS xmm1, vm32y, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, float* baseAddress, Vector256 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_mask_i64gather_pd (__m256d src, double const* base_addr, __m256i vindex, __m256d mask, const int scale) - /// VGATHERQPD ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256d _mm256_mask_i64gather_pd (__m256d src, double const* base_addr, __m256i vindex, __m256d mask, const int scale) + /// VGATHERQPD ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherMaskVector256(Vector256 source, double* baseAddress, Vector256 index, Vector256 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_hadd_epi16 (__m256i a, __m256i b) - /// VPHADDW ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_hadd_epi16 (__m256i a, __m256i b) + /// VPHADDW ymm1, ymm2, ymm3/m256 /// public static Vector256 HorizontalAdd(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_hadd_epi32 (__m256i a, __m256i b) - /// VPHADDD ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_hadd_epi32 (__m256i a, __m256i b) + /// VPHADDD ymm1, ymm2, ymm3/m256 /// public static Vector256 HorizontalAdd(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_hadds_epi16 (__m256i a, __m256i b) - /// VPHADDSW ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_hadds_epi16 (__m256i a, __m256i b) + /// VPHADDSW ymm1, ymm2, ymm3/m256 /// public static Vector256 HorizontalAddSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_hsub_epi16 (__m256i a, __m256i b) - /// VPHSUBW ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_hsub_epi16 (__m256i a, __m256i b) + /// VPHSUBW ymm1, ymm2, ymm3/m256 /// public static Vector256 HorizontalSubtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_hsub_epi32 (__m256i a, __m256i b) - /// VPHSUBD ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_hsub_epi32 (__m256i a, __m256i b) + /// VPHSUBD ymm1, ymm2, ymm3/m256 /// public static Vector256 HorizontalSubtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_hsubs_epi16 (__m256i a, __m256i b) - /// VPHSUBSW ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_hsubs_epi16 (__m256i a, __m256i b) + /// VPHSUBSW ymm1, ymm2, ymm3/m256 /// public static Vector256 HorizontalSubtractSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) - /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTI32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTI32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static new Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) - /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTI32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTI32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static new Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) - /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTI32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTI32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static new Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) - /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTI32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTI32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static new Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) - /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTI32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTI32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static new Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) - /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTI32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTI32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static new Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) - /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTI64x2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTI64x2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static new Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) - /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTI64x2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTI64x2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static new Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) - /// VMOVNTDQA ymm1, m256 + /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) + /// VMOVNTDQA ymm1, m256 /// public static unsafe Vector256 LoadAlignedVector256NonTemporal(sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) - /// VMOVNTDQA ymm1, m256 + /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) + /// VMOVNTDQA ymm1, m256 /// public static unsafe Vector256 LoadAlignedVector256NonTemporal(byte* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) - /// VMOVNTDQA ymm1, m256 + /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) + /// VMOVNTDQA ymm1, m256 /// public static unsafe Vector256 LoadAlignedVector256NonTemporal(short* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) - /// VMOVNTDQA ymm1, m256 + /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) + /// VMOVNTDQA ymm1, m256 /// public static unsafe Vector256 LoadAlignedVector256NonTemporal(ushort* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) - /// VMOVNTDQA ymm1, m256 + /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) + /// VMOVNTDQA ymm1, m256 /// public static unsafe Vector256 LoadAlignedVector256NonTemporal(int* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) - /// VMOVNTDQA ymm1, m256 + /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) + /// VMOVNTDQA ymm1, m256 /// public static unsafe Vector256 LoadAlignedVector256NonTemporal(uint* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) - /// VMOVNTDQA ymm1, m256 + /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) + /// VMOVNTDQA ymm1, m256 /// public static unsafe Vector256 LoadAlignedVector256NonTemporal(long* address) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) - /// VMOVNTDQA ymm1, m256 + /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) + /// VMOVNTDQA ymm1, m256 /// public static unsafe Vector256 LoadAlignedVector256NonTemporal(ulong* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_maskload_epi32 (int const* mem_addr, __m128i mask) - /// VPMASKMOVD xmm1, xmm2, m128 + /// __m128i _mm_maskload_epi32 (int const* mem_addr, __m128i mask) + /// VPMASKMOVD xmm1, xmm2, m128 /// public static unsafe Vector128 MaskLoad(int* address, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_maskload_epi32 (int const* mem_addr, __m128i mask) - /// VPMASKMOVD xmm1, xmm2, m128 + /// __m128i _mm_maskload_epi32 (int const* mem_addr, __m128i mask) + /// VPMASKMOVD xmm1, xmm2, m128 /// public static unsafe Vector128 MaskLoad(uint* address, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_maskload_epi64 (__int64 const* mem_addr, __m128i mask) - /// VPMASKMOVQ xmm1, xmm2, m128 + /// __m128i _mm_maskload_epi64 (__int64 const* mem_addr, __m128i mask) + /// VPMASKMOVQ xmm1, xmm2, m128 /// public static unsafe Vector128 MaskLoad(long* address, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_maskload_epi64 (__int64 const* mem_addr, __m128i mask) - /// VPMASKMOVQ xmm1, xmm2, m128 + /// __m128i _mm_maskload_epi64 (__int64 const* mem_addr, __m128i mask) + /// VPMASKMOVQ xmm1, xmm2, m128 /// public static unsafe Vector128 MaskLoad(ulong* address, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_maskload_epi32 (int const* mem_addr, __m256i mask) - /// VPMASKMOVD ymm1, ymm2, m256 + /// __m256i _mm256_maskload_epi32 (int const* mem_addr, __m256i mask) + /// VPMASKMOVD ymm1, ymm2, m256 /// public static unsafe Vector256 MaskLoad(int* address, Vector256 mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_maskload_epi32 (int const* mem_addr, __m256i mask) - /// VPMASKMOVD ymm1, ymm2, m256 + /// __m256i _mm256_maskload_epi32 (int const* mem_addr, __m256i mask) + /// VPMASKMOVD ymm1, ymm2, m256 /// public static unsafe Vector256 MaskLoad(uint* address, Vector256 mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_maskload_epi64 (__int64 const* mem_addr, __m256i mask) - /// VPMASKMOVQ ymm1, ymm2, m256 + /// __m256i _mm256_maskload_epi64 (__int64 const* mem_addr, __m256i mask) + /// VPMASKMOVQ ymm1, ymm2, m256 /// public static unsafe Vector256 MaskLoad(long* address, Vector256 mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_maskload_epi64 (__int64 const* mem_addr, __m256i mask) - /// VPMASKMOVQ ymm1, ymm2, m256 + /// __m256i _mm256_maskload_epi64 (__int64 const* mem_addr, __m256i mask) + /// VPMASKMOVQ ymm1, ymm2, m256 /// public static unsafe Vector256 MaskLoad(ulong* address, Vector256 mask) { throw new PlatformNotSupportedException(); } /// - /// void _mm_maskstore_epi32 (int* mem_addr, __m128i mask, __m128i a) - /// VPMASKMOVD m128, xmm1, xmm2 + /// void _mm_maskstore_epi32 (int* mem_addr, __m128i mask, __m128i a) + /// VPMASKMOVD m128, xmm1, xmm2 /// public static unsafe void MaskStore(int* address, Vector128 mask, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_maskstore_epi32 (int* mem_addr, __m128i mask, __m128i a) - /// VPMASKMOVD m128, xmm1, xmm2 + /// void _mm_maskstore_epi32 (int* mem_addr, __m128i mask, __m128i a) + /// VPMASKMOVD m128, xmm1, xmm2 /// public static unsafe void MaskStore(uint* address, Vector128 mask, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_maskstore_epi64 (__int64* mem_addr, __m128i mask, __m128i a) - /// VPMASKMOVQ m128, xmm1, xmm2 + /// void _mm_maskstore_epi64 (__int64* mem_addr, __m128i mask, __m128i a) + /// VPMASKMOVQ m128, xmm1, xmm2 /// public static unsafe void MaskStore(long* address, Vector128 mask, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_maskstore_epi64 (__int64* mem_addr, __m128i mask, __m128i a) - /// VPMASKMOVQ m128, xmm1, xmm2 + /// void _mm_maskstore_epi64 (__int64* mem_addr, __m128i mask, __m128i a) + /// VPMASKMOVQ m128, xmm1, xmm2 /// public static unsafe void MaskStore(ulong* address, Vector128 mask, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_maskstore_epi32 (int* mem_addr, __m256i mask, __m256i a) - /// VPMASKMOVD m256, ymm1, ymm2 + /// void _mm256_maskstore_epi32 (int* mem_addr, __m256i mask, __m256i a) + /// VPMASKMOVD m256, ymm1, ymm2 /// public static unsafe void MaskStore(int* address, Vector256 mask, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_maskstore_epi32 (int* mem_addr, __m256i mask, __m256i a) - /// VPMASKMOVD m256, ymm1, ymm2 + /// void _mm256_maskstore_epi32 (int* mem_addr, __m256i mask, __m256i a) + /// VPMASKMOVD m256, ymm1, ymm2 /// public static unsafe void MaskStore(uint* address, Vector256 mask, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_maskstore_epi64 (__int64* mem_addr, __m256i mask, __m256i a) - /// VPMASKMOVQ m256, ymm1, ymm2 + /// void _mm256_maskstore_epi64 (__int64* mem_addr, __m256i mask, __m256i a) + /// VPMASKMOVQ m256, ymm1, ymm2 /// public static unsafe void MaskStore(long* address, Vector256 mask, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm256_maskstore_epi64 (__int64* mem_addr, __m256i mask, __m256i a) - /// VPMASKMOVQ m256, ymm1, ymm2 + /// void _mm256_maskstore_epi64 (__int64* mem_addr, __m256i mask, __m256i a) + /// VPMASKMOVQ m256, ymm1, ymm2 /// public static unsafe void MaskStore(ulong* address, Vector256 mask, Vector256 source) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_madd_epi16 (__m256i a, __m256i b) - /// VPMADDWD ymm1, ymm2, ymm3/m256 - /// VPMADDWD ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_madd_epi16 (__m256i a, __m256i b) + /// VPMADDWD ymm1, ymm2, ymm3/m256 + /// VPMADDWD ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 MultiplyAddAdjacent(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_maddubs_epi16 (__m256i a, __m256i b) - /// VPMADDUBSW ymm1, ymm2, ymm3/m256 - /// VPMADDUBSW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_maddubs_epi16 (__m256i a, __m256i b) + /// VPMADDUBSW ymm1, ymm2, ymm3/m256 + /// VPMADDUBSW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 MultiplyAddAdjacent(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_max_epi8 (__m256i a, __m256i b) - /// VPMAXSB ymm1, ymm2, ymm3/m256 - /// VPMAXSB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_max_epi8 (__m256i a, __m256i b) + /// VPMAXSB ymm1, ymm2, ymm3/m256 + /// VPMAXSB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Max(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_max_epu8 (__m256i a, __m256i b) - /// VPMAXUB ymm1, ymm2, ymm3/m256 - /// VPMAXUB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_max_epu8 (__m256i a, __m256i b) + /// VPMAXUB ymm1, ymm2, ymm3/m256 + /// VPMAXUB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Max(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_max_epi16 (__m256i a, __m256i b) - /// VPMAXSW ymm1, ymm2, ymm3/m256 - /// VPMAXSW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_max_epi16 (__m256i a, __m256i b) + /// VPMAXSW ymm1, ymm2, ymm3/m256 + /// VPMAXSW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Max(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_max_epu16 (__m256i a, __m256i b) - /// VPMAXUW ymm1, ymm2, ymm3/m256 - /// VPMAXUW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_max_epu16 (__m256i a, __m256i b) + /// VPMAXUW ymm1, ymm2, ymm3/m256 + /// VPMAXUW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Max(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_max_epi32 (__m256i a, __m256i b) - /// VPMAXSD ymm1, ymm2, ymm3/m256 - /// VPMAXSD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_max_epi32 (__m256i a, __m256i b) + /// VPMAXSD ymm1, ymm2, ymm3/m256 + /// VPMAXSD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Max(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_max_epu32 (__m256i a, __m256i b) - /// VPMAXUD ymm1, ymm2, ymm3/m256 - /// VPMAXUD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_max_epu32 (__m256i a, __m256i b) + /// VPMAXUD ymm1, ymm2, ymm3/m256 + /// VPMAXUD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Max(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_min_epi8 (__m256i a, __m256i b) - /// VPMINSB ymm1, ymm2, ymm3/m256 - /// VPMINSB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_min_epi8 (__m256i a, __m256i b) + /// VPMINSB ymm1, ymm2, ymm3/m256 + /// VPMINSB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Min(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_min_epu8 (__m256i a, __m256i b) - /// VPMINUB ymm1, ymm2, ymm3/m256 - /// VPMINUB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_min_epu8 (__m256i a, __m256i b) + /// VPMINUB ymm1, ymm2, ymm3/m256 + /// VPMINUB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Min(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_min_epi16 (__m256i a, __m256i b) - /// VPMINSW ymm1, ymm2, ymm3/m256 - /// VPMINSW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_min_epi16 (__m256i a, __m256i b) + /// VPMINSW ymm1, ymm2, ymm3/m256 + /// VPMINSW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Min(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_min_epu16 (__m256i a, __m256i b) - /// VPMINUW ymm1, ymm2, ymm3/m256 - /// VPMINUW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_min_epu16 (__m256i a, __m256i b) + /// VPMINUW ymm1, ymm2, ymm3/m256 + /// VPMINUW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Min(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_min_epi32 (__m256i a, __m256i b) - /// VPMINSD ymm1, ymm2, ymm3/m256 - /// VPMINSD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_min_epi32 (__m256i a, __m256i b) + /// VPMINSD ymm1, ymm2, ymm3/m256 + /// VPMINSD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Min(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_min_epu32 (__m256i a, __m256i b) - /// VPMINUD ymm1, ymm2, ymm3/m256 - /// VPMINUD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_min_epu32 (__m256i a, __m256i b) + /// VPMINUD ymm1, ymm2, ymm3/m256 + /// VPMINUD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Min(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_movemask_epi8 (__m256i a) - /// VPMOVMSKB r32, ymm1 + /// int _mm256_movemask_epi8 (__m256i a) + /// VPMOVMSKB r32, ymm1 /// public static int MoveMask(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// int _mm256_movemask_epi8 (__m256i a) - /// VPMOVMSKB r32, ymm1 + /// int _mm256_movemask_epi8 (__m256i a) + /// VPMOVMSKB r32, ymm1 /// public static int MoveMask(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_mpsadbw_epu8 (__m256i a, __m256i b, const int imm8) - /// VMPSADBW ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_mpsadbw_epu8 (__m256i a, __m256i b, const int imm8) + /// VMPSADBW ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 MultipleSumAbsoluteDifferences(Vector256 left, Vector256 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_mul_epi32 (__m256i a, __m256i b) - /// VPMULDQ ymm1, ymm2, ymm3/m256 - /// VPMULDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_mul_epi32 (__m256i a, __m256i b) + /// VPMULDQ ymm1, ymm2, ymm3/m256 + /// VPMULDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Multiply(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_mul_epu32 (__m256i a, __m256i b) - /// VPMULUDQ ymm1, ymm2, ymm3/m256 - /// VPMULUDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_mul_epu32 (__m256i a, __m256i b) + /// VPMULUDQ ymm1, ymm2, ymm3/m256 + /// VPMULUDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Multiply(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_mulhi_epi16 (__m256i a, __m256i b) - /// VPMULHW ymm1, ymm2, ymm3/m256 - /// VPMULHW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_mulhi_epi16 (__m256i a, __m256i b) + /// VPMULHW ymm1, ymm2, ymm3/m256 + /// VPMULHW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 MultiplyHigh(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_mulhi_epu16 (__m256i a, __m256i b) - /// VPMULHUW ymm1, ymm2, ymm3/m256 - /// VPMULHUW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_mulhi_epu16 (__m256i a, __m256i b) + /// VPMULHUW ymm1, ymm2, ymm3/m256 + /// VPMULHUW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 MultiplyHigh(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_mulhrs_epi16 (__m256i a, __m256i b) - /// VPMULHRSW ymm1, ymm2, ymm3/m256 - /// VPMULHRSW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_mulhrs_epi16 (__m256i a, __m256i b) + /// VPMULHRSW ymm1, ymm2, ymm3/m256 + /// VPMULHRSW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 MultiplyHighRoundScale(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_mullo_epi16 (__m256i a, __m256i b) - /// VPMULLW ymm1, ymm2, ymm3/m256 - /// VPMULLW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_mullo_epi16 (__m256i a, __m256i b) + /// VPMULLW ymm1, ymm2, ymm3/m256 + /// VPMULLW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 MultiplyLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_mullo_epi16 (__m256i a, __m256i b) - /// VPMULLW ymm1, ymm2, ymm3/m256 - /// VPMULLW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_mullo_epi16 (__m256i a, __m256i b) + /// VPMULLW ymm1, ymm2, ymm3/m256 + /// VPMULLW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 MultiplyLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_mullo_epi32 (__m256i a, __m256i b) - /// VPMULLD ymm1, ymm2, ymm3/m256 - /// VPMULLD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_mullo_epi32 (__m256i a, __m256i b) + /// VPMULLD ymm1, ymm2, ymm3/m256 + /// VPMULLD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 MultiplyLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_mullo_epi32 (__m256i a, __m256i b) - /// VPMULLD ymm1, ymm2, ymm3/m256 - /// VPMULLD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_mullo_epi32 (__m256i a, __m256i b) + /// VPMULLD ymm1, ymm2, ymm3/m256 + /// VPMULLD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 MultiplyLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_or_si256 (__m256i a, __m256i b) - /// VPOR ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_or_si256 (__m256i a, __m256i b) + /// VPOR ymm1, ymm2, ymm3/m256 /// public static Vector256 Or(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_or_si256 (__m256i a, __m256i b) - /// VPOR ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_or_si256 (__m256i a, __m256i b) + /// VPOR ymm1, ymm2, ymm3/m256 /// public static Vector256 Or(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_or_si256 (__m256i a, __m256i b) - /// VPOR ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_or_si256 (__m256i a, __m256i b) + /// VPOR ymm1, ymm2, ymm3/m256 /// public static Vector256 Or(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_or_si256 (__m256i a, __m256i b) - /// VPOR ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_or_si256 (__m256i a, __m256i b) + /// VPOR ymm1, ymm2, ymm3/m256 /// public static Vector256 Or(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_or_si256 (__m256i a, __m256i b) - /// VPOR ymm1, ymm2, ymm3/m256 - /// VPORD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_or_si256 (__m256i a, __m256i b) + /// VPOR ymm1, ymm2, ymm3/m256 + /// VPORD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Or(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_or_si256 (__m256i a, __m256i b) - /// VPOR ymm1, ymm2, ymm3/m256 - /// VPORD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_or_si256 (__m256i a, __m256i b) + /// VPOR ymm1, ymm2, ymm3/m256 + /// VPORD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Or(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_or_si256 (__m256i a, __m256i b) - /// VPOR ymm1, ymm2, ymm3/m256 - /// VPORQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_or_si256 (__m256i a, __m256i b) + /// VPOR ymm1, ymm2, ymm3/m256 + /// VPORQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Or(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_or_si256 (__m256i a, __m256i b) - /// VPOR ymm1, ymm2, ymm3/m256 - /// VPORQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_or_si256 (__m256i a, __m256i b) + /// VPOR ymm1, ymm2, ymm3/m256 + /// VPORQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Or(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_packs_epi16 (__m256i a, __m256i b) - /// VPACKSSWB ymm1, ymm2, ymm3/m256 - /// VPACKSSWB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_packs_epi16 (__m256i a, __m256i b) + /// VPACKSSWB ymm1, ymm2, ymm3/m256 + /// VPACKSSWB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PackSignedSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_packs_epi32 (__m256i a, __m256i b) - /// VPACKSSDW ymm1, ymm2, ymm3/m256 - /// VPACKSSDW ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_packs_epi32 (__m256i a, __m256i b) + /// VPACKSSDW ymm1, ymm2, ymm3/m256 + /// VPACKSSDW ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 PackSignedSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_packus_epi16 (__m256i a, __m256i b) - /// VPACKUSWB ymm1, ymm2, ymm3/m256 - /// VPACKUSWB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_packus_epi16 (__m256i a, __m256i b) + /// VPACKUSWB ymm1, ymm2, ymm3/m256 + /// VPACKUSWB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PackUnsignedSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_packus_epi32 (__m256i a, __m256i b) - /// VPACKUSDW ymm1, ymm2, ymm3/m256 - /// VPACKUSDW ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_packus_epi32 (__m256i a, __m256i b) + /// VPACKUSDW ymm1, ymm2, ymm3/m256 + /// VPACKUSDW ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 PackUnsignedSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) - /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) + /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 /// public static new Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) - /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) + /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 /// public static new Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) - /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) + /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 /// public static new Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) - /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) + /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 /// public static new Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) - /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) + /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 /// public static new Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) - /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) + /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 /// public static new Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) - /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) + /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 /// public static new Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) - /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) + /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 /// public static new Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permute4x64_epi64 (__m256i a, const int imm8) - /// VPERMQ ymm1, ymm2/m256, imm8 - /// VPERMQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256i _mm256_permute4x64_epi64 (__m256i a, const int imm8) + /// VPERMQ ymm1, ymm2/m256, imm8 + /// VPERMQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 Permute4x64(Vector256 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permute4x64_epi64 (__m256i a, const int imm8) - /// VPERMQ ymm1, ymm2/m256, imm8 - /// VPERMQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256i _mm256_permute4x64_epi64 (__m256i a, const int imm8) + /// VPERMQ ymm1, ymm2/m256, imm8 + /// VPERMQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 Permute4x64(Vector256 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_permute4x64_pd (__m256d a, const int imm8) - /// VPERMPD ymm1, ymm2/m256, imm8 - /// VPERMPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256d _mm256_permute4x64_pd (__m256d a, const int imm8) + /// VPERMPD ymm1, ymm2/m256, imm8 + /// VPERMPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 Permute4x64(Vector256 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutevar8x32_epi32 (__m256i a, __m256i idx) - /// VPERMD ymm1, ymm2/m256, imm8 - /// VPERMD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256i _mm256_permutevar8x32_epi32 (__m256i a, __m256i idx) + /// VPERMD ymm1, ymm2/m256, imm8 + /// VPERMD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 PermuteVar8x32(Vector256 left, Vector256 control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutevar8x32_epi32 (__m256i a, __m256i idx) - /// VPERMD ymm1, ymm2/m256, imm8 - /// VPERMD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256i _mm256_permutevar8x32_epi32 (__m256i a, __m256i idx) + /// VPERMD ymm1, ymm2/m256, imm8 + /// VPERMD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 PermuteVar8x32(Vector256 left, Vector256 control) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_permutevar8x32_ps (__m256 a, __m256i idx) - /// VPERMPS ymm1, ymm2/m256, imm8 - /// VPERMPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256 _mm256_permutevar8x32_ps (__m256 a, __m256i idx) + /// VPERMPS ymm1, ymm2/m256, imm8 + /// VPERMPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 PermuteVar8x32(Vector256 left, Vector256 control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sll_epi16 (__m256i a, __m128i count) - /// VPSLLW ymm1, ymm2, xmm3/m128 - /// VPSLLW ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_sll_epi16 (__m256i a, __m128i count) + /// VPSLLW ymm1, ymm2, xmm3/m128 + /// VPSLLW ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftLeftLogical(Vector256 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sll_epi16 (__m256i a, __m128i count) - /// VPSLLW ymm1, ymm2, xmm3/m128 - /// VPSLLW ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_sll_epi16 (__m256i a, __m128i count) + /// VPSLLW ymm1, ymm2, xmm3/m128 + /// VPSLLW ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftLeftLogical(Vector256 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sll_epi32 (__m256i a, __m128i count) - /// VPSLLD ymm1, ymm2, xmm3/m128 - /// VPSLLD ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_sll_epi32 (__m256i a, __m128i count) + /// VPSLLD ymm1, ymm2, xmm3/m128 + /// VPSLLD ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftLeftLogical(Vector256 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sll_epi32 (__m256i a, __m128i count) - /// VPSLLD ymm1, ymm2, xmm3/m128 - /// VPSLLD ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_sll_epi32 (__m256i a, __m128i count) + /// VPSLLD ymm1, ymm2, xmm3/m128 + /// VPSLLD ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftLeftLogical(Vector256 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sll_epi64 (__m256i a, __m128i count) - /// VPSLLQ ymm1, ymm2, xmm3/m128 - /// VPSLLQ ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_sll_epi64 (__m256i a, __m128i count) + /// VPSLLQ ymm1, ymm2, xmm3/m128 + /// VPSLLQ ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftLeftLogical(Vector256 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sll_epi64 (__m256i a, __m128i count) - /// VPSLLQ ymm1, ymm2, xmm3/m128 - /// VPSLLQ ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_sll_epi64 (__m256i a, __m128i count) + /// VPSLLQ ymm1, ymm2, xmm3/m128 + /// VPSLLQ ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftLeftLogical(Vector256 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_slli_epi16 (__m256i a, int imm8) - /// VPSLLW ymm1, ymm2, imm8 - /// VPSLLW ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_slli_epi16 (__m256i a, int imm8) + /// VPSLLW ymm1, ymm2, imm8 + /// VPSLLW ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftLeftLogical(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_slli_epi16 (__m256i a, int imm8) - /// VPSLLW ymm1, ymm2, imm8 - /// VPSLLW ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_slli_epi16 (__m256i a, int imm8) + /// VPSLLW ymm1, ymm2, imm8 + /// VPSLLW ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftLeftLogical(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_slli_epi32 (__m256i a, int imm8) - /// VPSLLD ymm1, ymm2, imm8 - /// VPSLLD ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_slli_epi32 (__m256i a, int imm8) + /// VPSLLD ymm1, ymm2, imm8 + /// VPSLLD ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftLeftLogical(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_slli_epi32 (__m256i a, int imm8) - /// VPSLLD ymm1, ymm2, imm8 - /// VPSLLD ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_slli_epi32 (__m256i a, int imm8) + /// VPSLLD ymm1, ymm2, imm8 + /// VPSLLD ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftLeftLogical(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_slli_epi64 (__m256i a, int imm8) - /// VPSLLQ ymm1, ymm2, imm8 - /// VPSLLQ ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_slli_epi64 (__m256i a, int imm8) + /// VPSLLQ ymm1, ymm2, imm8 + /// VPSLLQ ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftLeftLogical(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_slli_epi64 (__m256i a, int imm8) - /// VPSLLQ ymm1, ymm2, imm8 - /// VPSLLQ ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_slli_epi64 (__m256i a, int imm8) + /// VPSLLQ ymm1, ymm2, imm8 + /// VPSLLQ ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftLeftLogical(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) - /// VPSLLDQ ymm1, ymm2/m256, imm8 + /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) + /// VPSLLDQ ymm1, ymm2/m256, imm8 /// public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) - /// VPSLLDQ ymm1, ymm2/m256, imm8 + /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) + /// VPSLLDQ ymm1, ymm2/m256, imm8 /// public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) - /// VPSLLDQ ymm1, ymm2/m256, imm8 - /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) + /// VPSLLDQ ymm1, ymm2/m256, imm8 + /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. /// public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) - /// VPSLLDQ ymm1, ymm2/m256, imm8 - /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) + /// VPSLLDQ ymm1, ymm2/m256, imm8 + /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. /// public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) - /// VPSLLDQ ymm1, ymm2/m256, imm8 - /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) + /// VPSLLDQ ymm1, ymm2/m256, imm8 + /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. /// public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) - /// VPSLLDQ ymm1, ymm2/m256, imm8 - /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) + /// VPSLLDQ ymm1, ymm2/m256, imm8 + /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. /// public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) - /// VPSLLDQ ymm1, ymm2/m256, imm8 - /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) + /// VPSLLDQ ymm1, ymm2/m256, imm8 + /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. /// public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) - /// VPSLLDQ ymm1, ymm2/m256, imm8 - /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) + /// VPSLLDQ ymm1, ymm2/m256, imm8 + /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. /// public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sllv_epi32 (__m128i a, __m128i count) - /// VPSLLVD xmm1, xmm2, xmm3/m128 - /// VPSLLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_sllv_epi32 (__m128i a, __m128i count) + /// VPSLLVD xmm1, xmm2, xmm3/m128 + /// VPSLLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 ShiftLeftLogicalVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sllv_epi32 (__m128i a, __m128i count) - /// VPSLLVD xmm1, xmm2, xmm3/m128 - /// VPSLLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_sllv_epi32 (__m128i a, __m128i count) + /// VPSLLVD xmm1, xmm2, xmm3/m128 + /// VPSLLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 ShiftLeftLogicalVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sllv_epi64 (__m128i a, __m128i count) - /// VPSLLVQ xmm1, xmm2, xmm3/m128 - /// VPSLLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_sllv_epi64 (__m128i a, __m128i count) + /// VPSLLVQ xmm1, xmm2, xmm3/m128 + /// VPSLLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 ShiftLeftLogicalVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sllv_epi64 (__m128i a, __m128i count) - /// VPSLLVQ xmm1, xmm2, xmm3/m128 - /// VPSLLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_sllv_epi64 (__m128i a, __m128i count) + /// VPSLLVQ xmm1, xmm2, xmm3/m128 + /// VPSLLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 ShiftLeftLogicalVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sllv_epi32 (__m256i a, __m256i count) - /// VPSLLVD ymm1, ymm2, ymm3/m256 - /// VPSLLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_sllv_epi32 (__m256i a, __m256i count) + /// VPSLLVD ymm1, ymm2, ymm3/m256 + /// VPSLLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sllv_epi32 (__m256i a, __m256i count) - /// VPSLLVD ymm1, ymm2, ymm3/m256 - /// VPSLLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_sllv_epi32 (__m256i a, __m256i count) + /// VPSLLVD ymm1, ymm2, ymm3/m256 + /// VPSLLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sllv_epi64 (__m256i a, __m256i count) - /// VPSLLVQ ymm1, ymm2, ymm3/m256 - /// VPSLLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_sllv_epi64 (__m256i a, __m256i count) + /// VPSLLVQ ymm1, ymm2, ymm3/m256 + /// VPSLLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sllv_epi64 (__m256i a, __m256i count) - /// VPSLLVQ ymm1, ymm2, ymm3/m256 - /// VPSLLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_sllv_epi64 (__m256i a, __m256i count) + /// VPSLLVQ ymm1, ymm2, ymm3/m256 + /// VPSLLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// _mm256_sra_epi16 (__m256i a, __m128i count) - /// VPSRAW ymm1, ymm2, xmm3/m128 - /// VPSRAW ymm1 {k1}{z}, ymm2, xmm3/m128 + /// _mm256_sra_epi16 (__m256i a, __m128i count) + /// VPSRAW ymm1, ymm2, xmm3/m128 + /// VPSRAW ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftRightArithmetic(Vector256 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// _mm256_sra_epi32 (__m256i a, __m128i count) - /// VPSRAD ymm1, ymm2, xmm3/m128 - /// VPSRAD ymm1 {k1}{z}, ymm2, xmm3/m128 + /// _mm256_sra_epi32 (__m256i a, __m128i count) + /// VPSRAD ymm1, ymm2, xmm3/m128 + /// VPSRAD ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftRightArithmetic(Vector256 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srai_epi16 (__m256i a, int imm8) - /// VPSRAW ymm1, ymm2, imm8 - /// VPSRAW ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_srai_epi16 (__m256i a, int imm8) + /// VPSRAW ymm1, ymm2, imm8 + /// VPSRAW ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftRightArithmetic(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srai_epi32 (__m256i a, int imm8) - /// VPSRAD ymm1, ymm2, imm8 - /// VPSRAD ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_srai_epi32 (__m256i a, int imm8) + /// VPSRAD ymm1, ymm2, imm8 + /// VPSRAD ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftRightArithmetic(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srav_epi32 (__m128i a, __m128i count) - /// VPSRAVD xmm1, xmm2, xmm3/m128 - /// VPSRAVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_srav_epi32 (__m128i a, __m128i count) + /// VPSRAVD xmm1, xmm2, xmm3/m128 + /// VPSRAVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 ShiftRightArithmeticVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srav_epi32 (__m256i a, __m256i count) - /// VPSRAVD ymm1, ymm2, ymm3/m256 - /// VPSRAVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_srav_epi32 (__m256i a, __m256i count) + /// VPSRAVD ymm1, ymm2, ymm3/m256 + /// VPSRAVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 ShiftRightArithmeticVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srl_epi16 (__m256i a, __m128i count) - /// VPSRLW ymm1, ymm2, xmm3/m128 - /// VPSRLW ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_srl_epi16 (__m256i a, __m128i count) + /// VPSRLW ymm1, ymm2, xmm3/m128 + /// VPSRLW ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftRightLogical(Vector256 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srl_epi16 (__m256i a, __m128i count) - /// VPSRLW ymm1, ymm2, xmm3/m128 - /// VPSRLW ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_srl_epi16 (__m256i a, __m128i count) + /// VPSRLW ymm1, ymm2, xmm3/m128 + /// VPSRLW ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftRightLogical(Vector256 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srl_epi32 (__m256i a, __m128i count) - /// VPSRLD ymm1, ymm2, xmm3/m128 - /// VPSRLD ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_srl_epi32 (__m256i a, __m128i count) + /// VPSRLD ymm1, ymm2, xmm3/m128 + /// VPSRLD ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftRightLogical(Vector256 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srl_epi32 (__m256i a, __m128i count) - /// VPSRLD ymm1, ymm2, xmm3/m128 - /// VPSRLD ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_srl_epi32 (__m256i a, __m128i count) + /// VPSRLD ymm1, ymm2, xmm3/m128 + /// VPSRLD ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftRightLogical(Vector256 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srl_epi64 (__m256i a, __m128i count) - /// VPSRLQ ymm1, ymm2, xmm3/m128 - /// VPSRLQ ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_srl_epi64 (__m256i a, __m128i count) + /// VPSRLQ ymm1, ymm2, xmm3/m128 + /// VPSRLQ ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftRightLogical(Vector256 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srl_epi64 (__m256i a, __m128i count) - /// VPSRLQ ymm1, ymm2, xmm3/m128 - /// VPSRLQ ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_srl_epi64 (__m256i a, __m128i count) + /// VPSRLQ ymm1, ymm2, xmm3/m128 + /// VPSRLQ ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftRightLogical(Vector256 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srli_epi16 (__m256i a, int imm8) - /// VPSRLW ymm1, ymm2, imm8 - /// VPSRLW ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_srli_epi16 (__m256i a, int imm8) + /// VPSRLW ymm1, ymm2, imm8 + /// VPSRLW ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftRightLogical(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srli_epi16 (__m256i a, int imm8) - /// VPSRLW ymm1, ymm2, imm8 - /// VPSRLW ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_srli_epi16 (__m256i a, int imm8) + /// VPSRLW ymm1, ymm2, imm8 + /// VPSRLW ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftRightLogical(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srli_epi32 (__m256i a, int imm8) - /// VPSRLD ymm1, ymm2, imm8 - /// VPSRLD ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_srli_epi32 (__m256i a, int imm8) + /// VPSRLD ymm1, ymm2, imm8 + /// VPSRLD ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftRightLogical(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srli_epi32 (__m256i a, int imm8) - /// VPSRLD ymm1, ymm2, imm8 - /// VPSRLD ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_srli_epi32 (__m256i a, int imm8) + /// VPSRLD ymm1, ymm2, imm8 + /// VPSRLD ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftRightLogical(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srli_epi64 (__m256i a, int imm8) - /// VPSRLQ ymm1, ymm2, imm8 - /// VPSRLQ ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_srli_epi64 (__m256i a, int imm8) + /// VPSRLQ ymm1, ymm2, imm8 + /// VPSRLQ ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftRightLogical(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srli_epi64 (__m256i a, int imm8) - /// VPSRLQ ymm1, ymm2, imm8 - /// VPSRLQ ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_srli_epi64 (__m256i a, int imm8) + /// VPSRLQ ymm1, ymm2, imm8 + /// VPSRLQ ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftRightLogical(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) - /// VPSRLDQ ymm1, ymm2/m128, imm8 + /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) + /// VPSRLDQ ymm1, ymm2/m128, imm8 /// public static Vector256 ShiftRightLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) - /// VPSRLDQ ymm1, ymm2/m128, imm8 + /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) + /// VPSRLDQ ymm1, ymm2/m128, imm8 /// public static Vector256 ShiftRightLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) - /// VPSRLDQ ymm1, ymm2/m128, imm8 - /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) + /// VPSRLDQ ymm1, ymm2/m128, imm8 + /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. /// public static Vector256 ShiftRightLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) - /// VPSRLDQ ymm1, ymm2/m128, imm8 - /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) + /// VPSRLDQ ymm1, ymm2/m128, imm8 + /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. /// public static Vector256 ShiftRightLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) - /// VPSRLDQ ymm1, ymm2/m128, imm8 - /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) + /// VPSRLDQ ymm1, ymm2/m128, imm8 + /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. /// public static Vector256 ShiftRightLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) - /// VPSRLDQ ymm1, ymm2/m128, imm8 - /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) + /// VPSRLDQ ymm1, ymm2/m128, imm8 + /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. /// public static Vector256 ShiftRightLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) - /// VPSRLDQ ymm1, ymm2/m128, imm8 - /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) + /// VPSRLDQ ymm1, ymm2/m128, imm8 + /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. /// public static Vector256 ShiftRightLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) - /// VPSRLDQ ymm1, ymm2/m128, imm8 - /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) + /// VPSRLDQ ymm1, ymm2/m128, imm8 + /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. /// public static Vector256 ShiftRightLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srlv_epi32 (__m128i a, __m128i count) - /// VPSRLVD xmm1, xmm2, xmm3/m128 - /// VPSRLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_srlv_epi32 (__m128i a, __m128i count) + /// VPSRLVD xmm1, xmm2, xmm3/m128 + /// VPSRLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 ShiftRightLogicalVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srlv_epi32 (__m128i a, __m128i count) - /// VPSRLVD xmm1, xmm2, xmm3/m128 - /// VPSRLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_srlv_epi32 (__m128i a, __m128i count) + /// VPSRLVD xmm1, xmm2, xmm3/m128 + /// VPSRLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 ShiftRightLogicalVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srlv_epi64 (__m128i a, __m128i count) - /// VPSRLVQ xmm1, xmm2, xmm3/m128 - /// VPSRLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_srlv_epi64 (__m128i a, __m128i count) + /// VPSRLVQ xmm1, xmm2, xmm3/m128 + /// VPSRLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 ShiftRightLogicalVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srlv_epi64 (__m128i a, __m128i count) - /// VPSRLVQ xmm1, xmm2, xmm3/m128 - /// VPSRLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_srlv_epi64 (__m128i a, __m128i count) + /// VPSRLVQ xmm1, xmm2, xmm3/m128 + /// VPSRLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 ShiftRightLogicalVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srlv_epi32 (__m256i a, __m256i count) - /// VPSRLVD ymm1, ymm2, ymm3/m256 - /// VPSRLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_srlv_epi32 (__m256i a, __m256i count) + /// VPSRLVD ymm1, ymm2, ymm3/m256 + /// VPSRLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srlv_epi32 (__m256i a, __m256i count) - /// VPSRLVD ymm1, ymm2, ymm3/m256 - /// VPSRLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_srlv_epi32 (__m256i a, __m256i count) + /// VPSRLVD ymm1, ymm2, ymm3/m256 + /// VPSRLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srlv_epi64 (__m256i a, __m256i count) - /// VPSRLVQ ymm1, ymm2, ymm3/m256 - /// VPSRLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_srlv_epi64 (__m256i a, __m256i count) + /// VPSRLVQ ymm1, ymm2, ymm3/m256 + /// VPSRLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srlv_epi64 (__m256i a, __m256i count) - /// VPSRLVQ ymm1, ymm2, ymm3/m256 - /// VPSRLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_srlv_epi64 (__m256i a, __m256i count) + /// VPSRLVQ ymm1, ymm2, ymm3/m256 + /// VPSRLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_shuffle_epi8 (__m256i a, __m256i b) - /// VPSHUFB ymm1, ymm2, ymm3/m256 - /// VPSHUFB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_shuffle_epi8 (__m256i a, __m256i b) + /// VPSHUFB ymm1, ymm2, ymm3/m256 + /// VPSHUFB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Shuffle(Vector256 value, Vector256 mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_shuffle_epi8 (__m256i a, __m256i b) - /// VPSHUFB ymm1, ymm2, ymm3/m256 - /// VPSHUFB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_shuffle_epi8 (__m256i a, __m256i b) + /// VPSHUFB ymm1, ymm2, ymm3/m256 + /// VPSHUFB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Shuffle(Vector256 value, Vector256 mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_shuffle_epi32 (__m256i a, const int imm8) - /// VPSHUFD ymm1, ymm2/m256, imm8 - /// VPSHUFD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256i _mm256_shuffle_epi32 (__m256i a, const int imm8) + /// VPSHUFD ymm1, ymm2/m256, imm8 + /// VPSHUFD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 Shuffle(Vector256 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_shuffle_epi32 (__m256i a, const int imm8) - /// VPSHUFD ymm1, ymm2/m256, imm8 - /// VPSHUFD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256i _mm256_shuffle_epi32 (__m256i a, const int imm8) + /// VPSHUFD ymm1, ymm2/m256, imm8 + /// VPSHUFD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 Shuffle(Vector256 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_shufflehi_epi16 (__m256i a, const int imm8) - /// VPSHUFHW ymm1, ymm2/m256, imm8 - /// VPSHUFHW ymm1 {k1}{z}, ymm2/m256, imm8 + /// __m256i _mm256_shufflehi_epi16 (__m256i a, const int imm8) + /// VPSHUFHW ymm1, ymm2/m256, imm8 + /// VPSHUFHW ymm1 {k1}{z}, ymm2/m256, imm8 /// public static Vector256 ShuffleHigh(Vector256 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_shufflehi_epi16 (__m256i a, const int imm8) - /// VPSHUFHW ymm1, ymm2/m256, imm8 - /// VPSHUFHW ymm1 {k1}{z}, ymm2/m256, imm8 + /// __m256i _mm256_shufflehi_epi16 (__m256i a, const int imm8) + /// VPSHUFHW ymm1, ymm2/m256, imm8 + /// VPSHUFHW ymm1 {k1}{z}, ymm2/m256, imm8 /// public static Vector256 ShuffleHigh(Vector256 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_shufflelo_epi16 (__m256i a, const int imm8) - /// VPSHUFLW ymm1, ymm2/m256, imm8 - /// VPSHUFLW ymm1 {k1}{z}, ymm2/m256, imm8 + /// __m256i _mm256_shufflelo_epi16 (__m256i a, const int imm8) + /// VPSHUFLW ymm1, ymm2/m256, imm8 + /// VPSHUFLW ymm1 {k1}{z}, ymm2/m256, imm8 /// public static Vector256 ShuffleLow(Vector256 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_shufflelo_epi16 (__m256i a, const int imm8) - /// VPSHUFLW ymm1, ymm2/m256, imm8 - /// VPSHUFLW ymm1 {k1}{z}, ymm2/m256, imm8 + /// __m256i _mm256_shufflelo_epi16 (__m256i a, const int imm8) + /// VPSHUFLW ymm1, ymm2/m256, imm8 + /// VPSHUFLW ymm1 {k1}{z}, ymm2/m256, imm8 /// public static Vector256 ShuffleLow(Vector256 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sign_epi8 (__m256i a, __m256i b) - /// VPSIGNB ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_sign_epi8 (__m256i a, __m256i b) + /// VPSIGNB ymm1, ymm2, ymm3/m256 /// public static Vector256 Sign(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sign_epi16 (__m256i a, __m256i b) - /// VPSIGNW ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_sign_epi16 (__m256i a, __m256i b) + /// VPSIGNW ymm1, ymm2, ymm3/m256 /// public static Vector256 Sign(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sign_epi32 (__m256i a, __m256i b) - /// VPSIGND ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_sign_epi32 (__m256i a, __m256i b) + /// VPSIGND ymm1, ymm2, ymm3/m256 /// public static Vector256 Sign(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sub_epi8 (__m256i a, __m256i b) - /// VPSUBB ymm1, ymm2, ymm3/m256 - /// VPSUBB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sub_epi8 (__m256i a, __m256i b) + /// VPSUBB ymm1, ymm2, ymm3/m256 + /// VPSUBB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sub_epi8 (__m256i a, __m256i b) - /// VPSUBB ymm1, ymm2, ymm3/m256 - /// VPSUBB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sub_epi8 (__m256i a, __m256i b) + /// VPSUBB ymm1, ymm2, ymm3/m256 + /// VPSUBB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sub_epi16 (__m256i a, __m256i b) - /// VPSUBW ymm1, ymm2, ymm3/m256 - /// VPSUBW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sub_epi16 (__m256i a, __m256i b) + /// VPSUBW ymm1, ymm2, ymm3/m256 + /// VPSUBW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sub_epi16 (__m256i a, __m256i b) - /// VPSUBW ymm1, ymm2, ymm3/m256 - /// VPSUBW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sub_epi16 (__m256i a, __m256i b) + /// VPSUBW ymm1, ymm2, ymm3/m256 + /// VPSUBW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sub_epi32 (__m256i a, __m256i b) - /// VPSUBD ymm1, ymm2, ymm3/m256 - /// VPSUBD ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sub_epi32 (__m256i a, __m256i b) + /// VPSUBD ymm1, ymm2, ymm3/m256 + /// VPSUBD ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sub_epi32 (__m256i a, __m256i b) - /// VPSUBD ymm1, ymm2, ymm3/m256 - /// VPSUBD ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sub_epi32 (__m256i a, __m256i b) + /// VPSUBD ymm1, ymm2, ymm3/m256 + /// VPSUBD ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sub_epi64 (__m256i a, __m256i b) - /// VPSUBQ ymm1, ymm2, ymm3/m256 - /// VPSUBQ ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sub_epi64 (__m256i a, __m256i b) + /// VPSUBQ ymm1, ymm2, ymm3/m256 + /// VPSUBQ ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sub_epi64 (__m256i a, __m256i b) - /// VPSUBQ ymm1, ymm2, ymm3/m256 - /// VPSUBQ ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sub_epi64 (__m256i a, __m256i b) + /// VPSUBQ ymm1, ymm2, ymm3/m256 + /// VPSUBQ ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Subtract(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_subs_epi8 (__m256i a, __m256i b) - /// VPSUBSB ymm1, ymm2, ymm3/m128 - /// VPSUBSB ymm1 {k1}{z}, ymm2, ymm3/m128 + /// __m256i _mm256_subs_epi8 (__m256i a, __m256i b) + /// VPSUBSB ymm1, ymm2, ymm3/m128 + /// VPSUBSB ymm1 {k1}{z}, ymm2, ymm3/m128 /// public static Vector256 SubtractSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_subs_epi16 (__m256i a, __m256i b) - /// VPSUBSW ymm1, ymm2, ymm3/m128 - /// VPSUBSW ymm1 {k1}{z}, ymm2, ymm3/m128 + /// __m256i _mm256_subs_epi16 (__m256i a, __m256i b) + /// VPSUBSW ymm1, ymm2, ymm3/m128 + /// VPSUBSW ymm1 {k1}{z}, ymm2, ymm3/m128 /// public static Vector256 SubtractSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_subs_epu8 (__m256i a, __m256i b) - /// VPSUBUSB ymm1, ymm2, ymm3/m128 - /// VPSUBUSB ymm1 {k1}{z}, ymm2, ymm3/m128 + /// __m256i _mm256_subs_epu8 (__m256i a, __m256i b) + /// VPSUBUSB ymm1, ymm2, ymm3/m128 + /// VPSUBUSB ymm1 {k1}{z}, ymm2, ymm3/m128 /// public static Vector256 SubtractSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_subs_epu16 (__m256i a, __m256i b) - /// VPSUBUSW ymm1, ymm2, ymm3/m128 - /// VPSUBUSW ymm1 {k1}{z}, ymm2, ymm3/m128 + /// __m256i _mm256_subs_epu16 (__m256i a, __m256i b) + /// VPSUBUSW ymm1, ymm2, ymm3/m128 + /// VPSUBUSW ymm1 {k1}{z}, ymm2, ymm3/m128 /// public static Vector256 SubtractSaturate(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sad_epu8 (__m256i a, __m256i b) - /// VPSADBW ymm1, ymm2, ymm3/m256 - /// VPSADBW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sad_epu8 (__m256i a, __m256i b) + /// VPSADBW ymm1, ymm2, ymm3/m256 + /// VPSADBW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 SumAbsoluteDifferences(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_unpackhi_epi8 (__m256i a, __m256i b) - /// VPUNPCKHBW ymm1, ymm2, ymm3/m256 - /// VPUNPCKHBW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_unpackhi_epi8 (__m256i a, __m256i b) + /// VPUNPCKHBW ymm1, ymm2, ymm3/m256 + /// VPUNPCKHBW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_unpackhi_epi8 (__m256i a, __m256i b) - /// VPUNPCKHBW ymm1, ymm2, ymm3/m256 - /// VPUNPCKHBW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_unpackhi_epi8 (__m256i a, __m256i b) + /// VPUNPCKHBW ymm1, ymm2, ymm3/m256 + /// VPUNPCKHBW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_unpackhi_epi16 (__m256i a, __m256i b) - /// VPUNPCKHWD ymm1, ymm2, ymm3/m256 - /// VPUNPCKHWD ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_unpackhi_epi16 (__m256i a, __m256i b) + /// VPUNPCKHWD ymm1, ymm2, ymm3/m256 + /// VPUNPCKHWD ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_unpackhi_epi16 (__m256i a, __m256i b) - /// VPUNPCKHWD ymm1, ymm2, ymm3/m256 - /// VPUNPCKHWD ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_unpackhi_epi16 (__m256i a, __m256i b) + /// VPUNPCKHWD ymm1, ymm2, ymm3/m256 + /// VPUNPCKHWD ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_unpackhi_epi32 (__m256i a, __m256i b) - /// VPUNPCKHDQ ymm1, ymm2, ymm3/m256 - /// VPUNPCKHDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_unpackhi_epi32 (__m256i a, __m256i b) + /// VPUNPCKHDQ ymm1, ymm2, ymm3/m256 + /// VPUNPCKHDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_unpackhi_epi32 (__m256i a, __m256i b) - /// VPUNPCKHDQ ymm1, ymm2, ymm3/m256 - /// VPUNPCKHDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_unpackhi_epi32 (__m256i a, __m256i b) + /// VPUNPCKHDQ ymm1, ymm2, ymm3/m256 + /// VPUNPCKHDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_unpackhi_epi64 (__m256i a, __m256i b) - /// VPUNPCKHQDQ ymm1, ymm2, ymm3/m256 - /// VPUNPCKHQDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_unpackhi_epi64 (__m256i a, __m256i b) + /// VPUNPCKHQDQ ymm1, ymm2, ymm3/m256 + /// VPUNPCKHQDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_unpackhi_epi64 (__m256i a, __m256i b) - /// VPUNPCKHQDQ ymm1, ymm2, ymm3/m256 - /// VPUNPCKHQDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_unpackhi_epi64 (__m256i a, __m256i b) + /// VPUNPCKHQDQ ymm1, ymm2, ymm3/m256 + /// VPUNPCKHQDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 UnpackHigh(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_unpacklo_epi8 (__m256i a, __m256i b) - /// VPUNPCKLBW ymm1, ymm2, ymm3/m256 - /// VPUNPCKLBW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_unpacklo_epi8 (__m256i a, __m256i b) + /// VPUNPCKLBW ymm1, ymm2, ymm3/m256 + /// VPUNPCKLBW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_unpacklo_epi8 (__m256i a, __m256i b) - /// VPUNPCKLBW ymm1, ymm2, ymm3/m256 - /// VPUNPCKLBW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_unpacklo_epi8 (__m256i a, __m256i b) + /// VPUNPCKLBW ymm1, ymm2, ymm3/m256 + /// VPUNPCKLBW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_unpacklo_epi16 (__m256i a, __m256i b) - /// VPUNPCKLWD ymm1, ymm2, ymm3/m256 - /// VPUNPCKLWD ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_unpacklo_epi16 (__m256i a, __m256i b) + /// VPUNPCKLWD ymm1, ymm2, ymm3/m256 + /// VPUNPCKLWD ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_unpacklo_epi16 (__m256i a, __m256i b) - /// VPUNPCKLWD ymm1, ymm2, ymm3/m256 - /// VPUNPCKLWD ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_unpacklo_epi16 (__m256i a, __m256i b) + /// VPUNPCKLWD ymm1, ymm2, ymm3/m256 + /// VPUNPCKLWD ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_unpacklo_epi32 (__m256i a, __m256i b) - /// VPUNPCKLDQ ymm1, ymm2, ymm3/m256 - /// VPUNPCKLDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_unpacklo_epi32 (__m256i a, __m256i b) + /// VPUNPCKLDQ ymm1, ymm2, ymm3/m256 + /// VPUNPCKLDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_unpacklo_epi32 (__m256i a, __m256i b) - /// VPUNPCKLDQ ymm1, ymm2, ymm3/m256 - /// VPUNPCKLDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_unpacklo_epi32 (__m256i a, __m256i b) + /// VPUNPCKLDQ ymm1, ymm2, ymm3/m256 + /// VPUNPCKLDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_unpacklo_epi64 (__m256i a, __m256i b) - /// VPUNPCKLQDQ ymm1, ymm2, ymm3/m256 - /// VPUNPCKLQDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_unpacklo_epi64 (__m256i a, __m256i b) + /// VPUNPCKLQDQ ymm1, ymm2, ymm3/m256 + /// VPUNPCKLQDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_unpacklo_epi64 (__m256i a, __m256i b) - /// VPUNPCKLQDQ ymm1, ymm2, ymm3/m256 - /// VPUNPCKLQDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_unpacklo_epi64 (__m256i a, __m256i b) + /// VPUNPCKLQDQ ymm1, ymm2, ymm3/m256 + /// VPUNPCKLQDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 UnpackLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) - /// VPXOR ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) + /// VPXOR ymm1, ymm2, ymm3/m256 /// public static Vector256 Xor(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) - /// VPXOR ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) + /// VPXOR ymm1, ymm2, ymm3/m256 /// public static Vector256 Xor(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) - /// VPXOR ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) + /// VPXOR ymm1, ymm2, ymm3/m256 /// public static Vector256 Xor(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) - /// VPXOR ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) + /// VPXOR ymm1, ymm2, ymm3/m256 /// public static Vector256 Xor(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) - /// VPXOR ymm1, ymm2, ymm3/m256 - /// VPXORD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) + /// VPXOR ymm1, ymm2, ymm3/m256 + /// VPXORD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Xor(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) - /// VPXOR ymm1, ymm2, ymm3/m256 - /// VPXORD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) + /// VPXOR ymm1, ymm2, ymm3/m256 + /// VPXORD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Xor(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) - /// VPXOR ymm1, ymm2, ymm3/m256 - /// VPXORQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) + /// VPXOR ymm1, ymm2, ymm3/m256 + /// VPXORQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Xor(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) - /// VPXOR ymm1, ymm2, ymm3/m256 - /// VPXORQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) + /// VPXOR ymm1, ymm2, ymm3/m256 + /// VPXORQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Xor(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.cs index 3783778cc85..05ee3126de3 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx2.cs @@ -6,918 +6,923 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel AVX2 hardware instructions via intrinsics - /// + /// Provides access to X86 AVX2 hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Avx2 : Avx { internal Avx2() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the x86 AVX2 hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : Avx.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } } /// - /// __m256i _mm256_abs_epi8 (__m256i a) - /// VPABSB ymm1, ymm2/m256 - /// VPABSB ymm1 {k1}{z}, ymm2/m256 + /// __m256i _mm256_abs_epi8 (__m256i a) + /// VPABSB ymm1, ymm2/m256 + /// VPABSB ymm1 {k1}{z}, ymm2/m256 /// public static Vector256 Abs(Vector256 value) => Abs(value); /// - /// __m256i _mm256_abs_epi16 (__m256i a) - /// VPABSW ymm1, ymm2/m256 - /// VPABSW ymm1 {k1}{z}, ymm2/m256 + /// __m256i _mm256_abs_epi16 (__m256i a) + /// VPABSW ymm1, ymm2/m256 + /// VPABSW ymm1 {k1}{z}, ymm2/m256 /// public static Vector256 Abs(Vector256 value) => Abs(value); /// - /// __m256i _mm256_abs_epi32 (__m256i a) - /// VPABSD ymm1, ymm2/m256 - /// VPABSD ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_abs_epi32 (__m256i a) + /// VPABSD ymm1, ymm2/m256 + /// VPABSD ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 Abs(Vector256 value) => Abs(value); /// - /// __m256i _mm256_add_epi8 (__m256i a, __m256i b) - /// VPADDB ymm1, ymm2, ymm3/m256 - /// VPADDB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_add_epi8 (__m256i a, __m256i b) + /// VPADDB ymm1, ymm2, ymm3/m256 + /// VPADDB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Add(Vector256 left, Vector256 right) => Add(left, right); /// - /// __m256i _mm256_add_epi8 (__m256i a, __m256i b) - /// VPADDB ymm1, ymm2, ymm3/m256 - /// VPADDB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_add_epi8 (__m256i a, __m256i b) + /// VPADDB ymm1, ymm2, ymm3/m256 + /// VPADDB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Add(Vector256 left, Vector256 right) => Add(left, right); /// - /// __m256i _mm256_add_epi16 (__m256i a, __m256i b) - /// VPADDW ymm1, ymm2, ymm3/m256 - /// VPADDW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_add_epi16 (__m256i a, __m256i b) + /// VPADDW ymm1, ymm2, ymm3/m256 + /// VPADDW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Add(Vector256 left, Vector256 right) => Add(left, right); /// - /// __m256i _mm256_add_epi16 (__m256i a, __m256i b) - /// VPADDW ymm1, ymm2, ymm3/m256 - /// VPADDW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_add_epi16 (__m256i a, __m256i b) + /// VPADDW ymm1, ymm2, ymm3/m256 + /// VPADDW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Add(Vector256 left, Vector256 right) => Add(left, right); /// - /// __m256i _mm256_add_epi32 (__m256i a, __m256i b) - /// VPADDD ymm1, ymm2, ymm3/m256 - /// VPADDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_add_epi32 (__m256i a, __m256i b) + /// VPADDD ymm1, ymm2, ymm3/m256 + /// VPADDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Add(Vector256 left, Vector256 right) => Add(left, right); /// - /// __m256i _mm256_add_epi32 (__m256i a, __m256i b) - /// VPADDD ymm1, ymm2, ymm3/m256 - /// VPADDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_add_epi32 (__m256i a, __m256i b) + /// VPADDD ymm1, ymm2, ymm3/m256 + /// VPADDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Add(Vector256 left, Vector256 right) => Add(left, right); /// - /// __m256i _mm256_add_epi64 (__m256i a, __m256i b) - /// VPADDQ ymm1, ymm2, ymm3/m256 - /// VPADDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_add_epi64 (__m256i a, __m256i b) + /// VPADDQ ymm1, ymm2, ymm3/m256 + /// VPADDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Add(Vector256 left, Vector256 right) => Add(left, right); /// - /// __m256i _mm256_add_epi64 (__m256i a, __m256i b) - /// VPADDQ ymm1, ymm2, ymm3/m256 - /// VPADDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_add_epi64 (__m256i a, __m256i b) + /// VPADDQ ymm1, ymm2, ymm3/m256 + /// VPADDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Add(Vector256 left, Vector256 right) => Add(left, right); /// - /// __m256i _mm256_adds_epi8 (__m256i a, __m256i b) - /// VPADDSB ymm1, ymm2, ymm3/m256 - /// VPADDSB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_adds_epi8 (__m256i a, __m256i b) + /// VPADDSB ymm1, ymm2, ymm3/m256 + /// VPADDSB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 AddSaturate(Vector256 left, Vector256 right) => AddSaturate(left, right); /// - /// __m256i _mm256_adds_epu8 (__m256i a, __m256i b) - /// VPADDUSB ymm1, ymm2, ymm3/m256 - /// VPADDUSB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_adds_epu8 (__m256i a, __m256i b) + /// VPADDUSB ymm1, ymm2, ymm3/m256 + /// VPADDUSB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 AddSaturate(Vector256 left, Vector256 right) => AddSaturate(left, right); /// - /// __m256i _mm256_adds_epi16 (__m256i a, __m256i b) - /// VPADDSW ymm1, ymm2, ymm3/m256 - /// VPADDSW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_adds_epi16 (__m256i a, __m256i b) + /// VPADDSW ymm1, ymm2, ymm3/m256 + /// VPADDSW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 AddSaturate(Vector256 left, Vector256 right) => AddSaturate(left, right); /// - /// __m256i _mm256_adds_epu16 (__m256i a, __m256i b) - /// VPADDUSW ymm1, ymm2, ymm3/m256 - /// VPADDUSW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_adds_epu16 (__m256i a, __m256i b) + /// VPADDUSW ymm1, ymm2, ymm3/m256 + /// VPADDUSW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 AddSaturate(Vector256 left, Vector256 right) => AddSaturate(left, right); /// - /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) - /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 - /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) + /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 + /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 /// public static Vector256 AlignRight(Vector256 left, Vector256 right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); /// - /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) - /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 - /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) + /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 + /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 /// public static Vector256 AlignRight(Vector256 left, Vector256 right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); /// - /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) - /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 - /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) + /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 + /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors. /// public static Vector256 AlignRight(Vector256 left, Vector256 right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); /// - /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) - /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 - /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) + /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 + /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors. /// public static Vector256 AlignRight(Vector256 left, Vector256 right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); /// - /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) - /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 - /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) + /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 + /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors. /// public static Vector256 AlignRight(Vector256 left, Vector256 right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); /// - /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) - /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 - /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) + /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 + /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors. /// public static Vector256 AlignRight(Vector256 left, Vector256 right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); /// - /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) - /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 - /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) + /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 + /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors. /// public static Vector256 AlignRight(Vector256 left, Vector256 right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); /// - /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) - /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 - /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_alignr_epi8 (__m256i a, __m256i b, const int count) + /// VPALIGNR ymm1, ymm2, ymm3/m256, imm8 + /// VPALIGNR ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// This intrinsic generates VPALIGNR that operates over bytes rather than elements of the vectors. /// public static Vector256 AlignRight(Vector256 left, Vector256 right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); /// - /// __m256i _mm256_and_si256 (__m256i a, __m256i b) - /// VPAND ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_and_si256 (__m256i a, __m256i b) + /// VPAND ymm1, ymm2, ymm3/m256 /// public static Vector256 And(Vector256 left, Vector256 right) => And(left, right); /// - /// __m256i _mm256_and_si256 (__m256i a, __m256i b) - /// VPAND ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_and_si256 (__m256i a, __m256i b) + /// VPAND ymm1, ymm2, ymm3/m256 /// public static Vector256 And(Vector256 left, Vector256 right) => And(left, right); /// - /// __m256i _mm256_and_si256 (__m256i a, __m256i b) - /// VPAND ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_and_si256 (__m256i a, __m256i b) + /// VPAND ymm1, ymm2, ymm3/m256 /// public static Vector256 And(Vector256 left, Vector256 right) => And(left, right); /// - /// __m256i _mm256_and_si256 (__m256i a, __m256i b) - /// VPAND ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_and_si256 (__m256i a, __m256i b) + /// VPAND ymm1, ymm2, ymm3/m256 /// public static Vector256 And(Vector256 left, Vector256 right) => And(left, right); /// - /// __m256i _mm256_and_si256 (__m256i a, __m256i b) - /// VPAND ymm1, ymm2, ymm3/m256 - /// VPANDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_and_si256 (__m256i a, __m256i b) + /// VPAND ymm1, ymm2, ymm3/m256 + /// VPANDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 And(Vector256 left, Vector256 right) => And(left, right); /// - /// __m256i _mm256_and_si256 (__m256i a, __m256i b) - /// VPAND ymm1, ymm2, ymm3/m256 - /// VPANDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_and_si256 (__m256i a, __m256i b) + /// VPAND ymm1, ymm2, ymm3/m256 + /// VPANDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 And(Vector256 left, Vector256 right) => And(left, right); /// - /// __m256i _mm256_and_si256 (__m256i a, __m256i b) - /// VPAND ymm1, ymm2, ymm3/m256 - /// VPANDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_and_si256 (__m256i a, __m256i b) + /// VPAND ymm1, ymm2, ymm3/m256 + /// VPANDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 And(Vector256 left, Vector256 right) => And(left, right); /// - /// __m256i _mm256_and_si256 (__m256i a, __m256i b) - /// VPAND ymm1, ymm2, ymm3/m256 - /// VPANDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_and_si256 (__m256i a, __m256i b) + /// VPAND ymm1, ymm2, ymm3/m256 + /// VPANDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 And(Vector256 left, Vector256 right) => And(left, right); /// - /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) - /// VPANDN ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) + /// VPANDN ymm1, ymm2, ymm3/m256 /// public static Vector256 AndNot(Vector256 left, Vector256 right) => AndNot(left, right); /// - /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) - /// VPANDN ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) + /// VPANDN ymm1, ymm2, ymm3/m256 /// public static Vector256 AndNot(Vector256 left, Vector256 right) => AndNot(left, right); /// - /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) - /// VPANDN ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) + /// VPANDN ymm1, ymm2, ymm3/m256 /// public static Vector256 AndNot(Vector256 left, Vector256 right) => AndNot(left, right); /// - /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) - /// VPANDN ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) + /// VPANDN ymm1, ymm2, ymm3/m256 /// public static Vector256 AndNot(Vector256 left, Vector256 right) => AndNot(left, right); /// - /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) - /// VPANDN ymm1, ymm2, ymm3/m256 - /// VPANDND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) + /// VPANDN ymm1, ymm2, ymm3/m256 + /// VPANDND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 AndNot(Vector256 left, Vector256 right) => AndNot(left, right); /// - /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) - /// VPANDN ymm1, ymm2, ymm3/m256 - /// VPANDND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) + /// VPANDN ymm1, ymm2, ymm3/m256 + /// VPANDND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 AndNot(Vector256 left, Vector256 right) => AndNot(left, right); /// - /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) - /// VPANDN ymm1, ymm2, ymm3/m256 - /// VPANDNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) + /// VPANDN ymm1, ymm2, ymm3/m256 + /// VPANDNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 AndNot(Vector256 left, Vector256 right) => AndNot(left, right); /// - /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) - /// VPANDN ymm1, ymm2, ymm3/m256 - /// VPANDNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_andnot_si256 (__m256i a, __m256i b) + /// VPANDN ymm1, ymm2, ymm3/m256 + /// VPANDNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 AndNot(Vector256 left, Vector256 right) => AndNot(left, right); /// - /// __m256i _mm256_avg_epu8 (__m256i a, __m256i b) - /// VPAVGB ymm1, ymm2, ymm3/m256 - /// VPAVGB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_avg_epu8 (__m256i a, __m256i b) + /// VPAVGB ymm1, ymm2, ymm3/m256 + /// VPAVGB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Average(Vector256 left, Vector256 right) => Average(left, right); /// - /// __m256i _mm256_avg_epu16 (__m256i a, __m256i b) - /// VPAVGW ymm1, ymm2, ymm3/m256 - /// VPAVGW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_avg_epu16 (__m256i a, __m256i b) + /// VPAVGW ymm1, ymm2, ymm3/m256 + /// VPAVGW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Average(Vector256 left, Vector256 right) => Average(left, right); /// - /// __m128i _mm_blend_epi32 (__m128i a, __m128i b, const int imm8) - /// VPBLENDD xmm1, xmm2, xmm3/m128, imm8 + /// __m128i _mm_blend_epi32 (__m128i a, __m128i b, const int imm8) + /// VPBLENDD xmm1, xmm2, xmm3/m128, imm8 /// public static Vector128 Blend(Vector128 left, Vector128 right, [ConstantExpected] byte control) => Blend(left, right, control); /// - /// __m128i _mm_blend_epi32 (__m128i a, __m128i b, const int imm8) - /// VPBLENDD xmm1, xmm2, xmm3/m128, imm8 + /// __m128i _mm_blend_epi32 (__m128i a, __m128i b, const int imm8) + /// VPBLENDD xmm1, xmm2, xmm3/m128, imm8 /// public static Vector128 Blend(Vector128 left, Vector128 right, [ConstantExpected] byte control) => Blend(left, right, control); /// - /// __m256i _mm256_blend_epi16 (__m256i a, __m256i b, const int imm8) - /// VPBLENDW ymm1, ymm2, ymm3/m256 imm8 + /// __m256i _mm256_blend_epi16 (__m256i a, __m256i b, const int imm8) + /// VPBLENDW ymm1, ymm2, ymm3/m256 imm8 /// public static Vector256 Blend(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Blend(left, right, control); /// - /// __m256i _mm256_blend_epi16 (__m256i a, __m256i b, const int imm8) - /// VPBLENDW ymm1, ymm2, ymm3/m256 imm8 + /// __m256i _mm256_blend_epi16 (__m256i a, __m256i b, const int imm8) + /// VPBLENDW ymm1, ymm2, ymm3/m256 imm8 /// public static Vector256 Blend(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Blend(left, right, control); /// - /// __m256i _mm256_blend_epi32 (__m256i a, __m256i b, const int imm8) - /// VPBLENDD ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_blend_epi32 (__m256i a, __m256i b, const int imm8) + /// VPBLENDD ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Blend(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Blend(left, right, control); /// - /// __m256i _mm256_blend_epi32 (__m256i a, __m256i b, const int imm8) - /// VPBLENDD ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_blend_epi32 (__m256i a, __m256i b, const int imm8) + /// VPBLENDD ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 Blend(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Blend(left, right, control); /// - /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) - /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 + /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) + /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 /// public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) => BlendVariable(left, right, mask); /// - /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) - /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 + /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) + /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 /// public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) => BlendVariable(left, right, mask); /// - /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) - /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 - /// This intrinsic generates VPBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. + /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) + /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 + /// This intrinsic generates VPBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. /// public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) => BlendVariable(left, right, mask); /// - /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) - /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 - /// This intrinsic generates VPBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. + /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) + /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 + /// This intrinsic generates VPBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. /// public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) => BlendVariable(left, right, mask); /// - /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) - /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 - /// This intrinsic generates VPBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. + /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) + /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 + /// This intrinsic generates VPBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. /// public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) => BlendVariable(left, right, mask); /// - /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) - /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 - /// This intrinsic generates VPBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. + /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) + /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 + /// This intrinsic generates VPBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. /// public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) => BlendVariable(left, right, mask); /// - /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) - /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 - /// This intrinsic generates VPBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. + /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) + /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 + /// This intrinsic generates VPBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. /// public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) => BlendVariable(left, right, mask); /// - /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) - /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 - /// This intrinsic generates VPBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. + /// __m256i _mm256_blendv_epi8 (__m256i a, __m256i b, __m256i mask) + /// VPBLENDVB ymm1, ymm2, ymm3/m256, ymm4 + /// This intrinsic generates VPBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. /// public static Vector256 BlendVariable(Vector256 left, Vector256 right, Vector256 mask) => BlendVariable(left, right, mask); /// - /// __m128i _mm_broadcastb_epi8 (__m128i a) - /// VPBROADCASTB xmm1, xmm2/m8 - /// VPBROADCASTB xmm1 {k1}{z}, xmm2/m8 + /// __m128i _mm_broadcastb_epi8 (__m128i a) + /// VPBROADCASTB xmm1, xmm2/m8 + /// VPBROADCASTB xmm1 {k1}{z}, xmm2/m8 /// public static Vector128 BroadcastScalarToVector128(Vector128 value) => BroadcastScalarToVector128(value); /// - /// __m128i _mm_broadcastb_epi8 (__m128i a) - /// VPBROADCASTB xmm1, xmm2/m8 - /// VPBROADCASTB xmm1 {k1}{z}, xmm2/m8 + /// __m128i _mm_broadcastb_epi8 (__m128i a) + /// VPBROADCASTB xmm1, xmm2/m8 + /// VPBROADCASTB xmm1 {k1}{z}, xmm2/m8 /// public static Vector128 BroadcastScalarToVector128(Vector128 value) => BroadcastScalarToVector128(value); /// - /// __m128i _mm_broadcastw_epi16 (__m128i a) - /// VPBROADCASTW xmm1, xmm2/m16 - /// VPBROADCASTW xmm1 {k1}{z}, xmm2/m16 + /// __m128i _mm_broadcastw_epi16 (__m128i a) + /// VPBROADCASTW xmm1, xmm2/m16 + /// VPBROADCASTW xmm1 {k1}{z}, xmm2/m16 /// public static Vector128 BroadcastScalarToVector128(Vector128 value) => BroadcastScalarToVector128(value); /// - /// __m128i _mm_broadcastw_epi16 (__m128i a) - /// VPBROADCASTW xmm1, xmm2/m16 - /// VPBROADCASTW xmm1 {k1}{z}, xmm2/m16 + /// __m128i _mm_broadcastw_epi16 (__m128i a) + /// VPBROADCASTW xmm1, xmm2/m16 + /// VPBROADCASTW xmm1 {k1}{z}, xmm2/m16 /// public static Vector128 BroadcastScalarToVector128(Vector128 value) => BroadcastScalarToVector128(value); /// - /// __m128i _mm_broadcastd_epi32 (__m128i a) - /// VPBROADCASTD xmm1, xmm2/m32 - /// VPBROADCASTD xmm1 {k1}{z}, xmm2/m32 + /// __m128i _mm_broadcastd_epi32 (__m128i a) + /// VPBROADCASTD xmm1, xmm2/m32 + /// VPBROADCASTD xmm1 {k1}{z}, xmm2/m32 /// public static Vector128 BroadcastScalarToVector128(Vector128 value) => BroadcastScalarToVector128(value); /// - /// __m128i _mm_broadcastd_epi32 (__m128i a) - /// VPBROADCASTD xmm1, xmm2/m32 - /// VPBROADCASTD xmm1 {k1}{z}, xmm2/m32 + /// __m128i _mm_broadcastd_epi32 (__m128i a) + /// VPBROADCASTD xmm1, xmm2/m32 + /// VPBROADCASTD xmm1 {k1}{z}, xmm2/m32 /// public static Vector128 BroadcastScalarToVector128(Vector128 value) => BroadcastScalarToVector128(value); /// - /// __m128i _mm_broadcastq_epi64 (__m128i a) - /// VPBROADCASTQ xmm1, xmm2/m64 - /// VPBROADCASTQ xmm1 {k1}{z}, xmm2/m64 + /// __m128i _mm_broadcastq_epi64 (__m128i a) + /// VPBROADCASTQ xmm1, xmm2/m64 + /// VPBROADCASTQ xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 BroadcastScalarToVector128(Vector128 value) => BroadcastScalarToVector128(value); /// - /// __m128i _mm_broadcastq_epi64 (__m128i a) - /// VPBROADCASTQ xmm1, xmm2/m64 - /// VPBROADCASTQ xmm1 {k1}{z}, xmm2/m64 + /// __m128i _mm_broadcastq_epi64 (__m128i a) + /// VPBROADCASTQ xmm1, xmm2/m64 + /// VPBROADCASTQ xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 BroadcastScalarToVector128(Vector128 value) => BroadcastScalarToVector128(value); /// - /// __m128 _mm_broadcastss_ps (__m128 a) - /// VBROADCASTSS xmm1, xmm2/m32 - /// VBROADCASTSS xmm1 {k1}{z}, xmm2/m32 + /// __m128 _mm_broadcastss_ps (__m128 a) + /// VBROADCASTSS xmm1, xmm2/m32 + /// VBROADCASTSS xmm1 {k1}{z}, xmm2/m32 /// public static Vector128 BroadcastScalarToVector128(Vector128 value) => BroadcastScalarToVector128(value); /// - /// __m128d _mm_broadcastsd_pd (__m128d a) - /// VMOVDDUP xmm1, xmm/m64 + /// __m128d _mm_broadcastsd_pd (__m128d a) + /// VMOVDDUP xmm1, xmm/m64 /// public static Vector128 BroadcastScalarToVector128(Vector128 value) => BroadcastScalarToVector128(value); /// - /// __m128i _mm_broadcastb_epi8 (__m128i a) - /// VPBROADCASTB xmm1, m8 - /// VPBROADCASTB xmm1 {k1}{z}, m8 - /// The above native signature does not directly correspond to the managed signature. + /// __m128i _mm_broadcastb_epi8 (__m128i a) + /// VPBROADCASTB xmm1, m8 + /// VPBROADCASTB xmm1 {k1}{z}, m8 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector128 BroadcastScalarToVector128(byte* source) => BroadcastScalarToVector128(source); /// - /// __m128i _mm_broadcastb_epi8 (__m128i a) - /// VPBROADCASTB xmm1, m8 - /// VPBROADCASTB xmm1 {k1}{z}, m8 - /// The above native signature does not directly correspond to the managed signature. + /// __m128i _mm_broadcastb_epi8 (__m128i a) + /// VPBROADCASTB xmm1, m8 + /// VPBROADCASTB xmm1 {k1}{z}, m8 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector128 BroadcastScalarToVector128(sbyte* source) => BroadcastScalarToVector128(source); /// - /// __m128i _mm_broadcastw_epi16 (__m128i a) - /// VPBROADCASTW xmm1, m16 - /// VPBROADCASTW xmm1 {k1}{z}, m16 - /// The above native signature does not directly correspond to the managed signature. + /// __m128i _mm_broadcastw_epi16 (__m128i a) + /// VPBROADCASTW xmm1, m16 + /// VPBROADCASTW xmm1 {k1}{z}, m16 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector128 BroadcastScalarToVector128(short* source) => BroadcastScalarToVector128(source); /// - /// __m128i _mm_broadcastw_epi16 (__m128i a) - /// VPBROADCASTW xmm1, m16 - /// VPBROADCASTW xmm1 {k1}{z}, m16 - /// The above native signature does not directly correspond to the managed signature. + /// __m128i _mm_broadcastw_epi16 (__m128i a) + /// VPBROADCASTW xmm1, m16 + /// VPBROADCASTW xmm1 {k1}{z}, m16 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector128 BroadcastScalarToVector128(ushort* source) => BroadcastScalarToVector128(source); /// - /// __m128i _mm_broadcastd_epi32 (__m128i a) - /// VPBROADCASTD xmm1, m32 - /// VPBROADCASTD xmm1 {k1}{z}, m32 - /// The above native signature does not directly correspond to the managed signature. + /// __m128i _mm_broadcastd_epi32 (__m128i a) + /// VPBROADCASTD xmm1, m32 + /// VPBROADCASTD xmm1 {k1}{z}, m32 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector128 BroadcastScalarToVector128(int* source) => BroadcastScalarToVector128(source); /// - /// __m128i _mm_broadcastd_epi32 (__m128i a) - /// VPBROADCASTD xmm1, m32 - /// VPBROADCASTD xmm1 {k1}{z}, m32 - /// The above native signature does not directly correspond to the managed signature. + /// __m128i _mm_broadcastd_epi32 (__m128i a) + /// VPBROADCASTD xmm1, m32 + /// VPBROADCASTD xmm1 {k1}{z}, m32 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector128 BroadcastScalarToVector128(uint* source) => BroadcastScalarToVector128(source); /// - /// __m128i _mm_broadcastq_epi64 (__m128i a) - /// VPBROADCASTQ xmm1, m64 - /// VPBROADCASTQ xmm1 {k1}{z}, m64 - /// The above native signature does not directly correspond to the managed signature. + /// __m128i _mm_broadcastq_epi64 (__m128i a) + /// VPBROADCASTQ xmm1, m64 + /// VPBROADCASTQ xmm1 {k1}{z}, m64 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector128 BroadcastScalarToVector128(long* source) => BroadcastScalarToVector128(source); /// - /// __m128i _mm_broadcastq_epi64 (__m128i a) - /// VPBROADCASTQ xmm1, m64 - /// VPBROADCASTQ xmm1 {k1}{z}, m64 - /// The above native signature does not directly correspond to the managed signature. + /// __m128i _mm_broadcastq_epi64 (__m128i a) + /// VPBROADCASTQ xmm1, m64 + /// VPBROADCASTQ xmm1 {k1}{z}, m64 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector128 BroadcastScalarToVector128(ulong* source) => BroadcastScalarToVector128(source); /// - /// __m256i _mm256_broadcastb_epi8 (__m128i a) - /// VPBROADCASTB ymm1, xmm2/m8 - /// VPBROADCASTB ymm1 {k1}{z}, xmm2/m8 + /// __m256i _mm256_broadcastb_epi8 (__m128i a) + /// VPBROADCASTB ymm1, xmm2/m8 + /// VPBROADCASTB ymm1 {k1}{z}, xmm2/m8 /// public static Vector256 BroadcastScalarToVector256(Vector128 value) => BroadcastScalarToVector256(value); /// - /// __m256i _mm256_broadcastb_epi8 (__m128i a) - /// VPBROADCASTB ymm1, xmm2/m8 - /// VPBROADCASTB ymm1 {k1}{z}, xmm2/m8 + /// __m256i _mm256_broadcastb_epi8 (__m128i a) + /// VPBROADCASTB ymm1, xmm2/m8 + /// VPBROADCASTB ymm1 {k1}{z}, xmm2/m8 /// public static Vector256 BroadcastScalarToVector256(Vector128 value) => BroadcastScalarToVector256(value); /// - /// __m256i _mm256_broadcastw_epi16 (__m128i a) - /// VPBROADCASTW ymm1, xmm2/m16 - /// VPBROADCASTW ymm1 {k1}{z}, xmm2/m16 + /// __m256i _mm256_broadcastw_epi16 (__m128i a) + /// VPBROADCASTW ymm1, xmm2/m16 + /// VPBROADCASTW ymm1 {k1}{z}, xmm2/m16 /// public static Vector256 BroadcastScalarToVector256(Vector128 value) => BroadcastScalarToVector256(value); /// - /// __m256i _mm256_broadcastw_epi16 (__m128i a) - /// VPBROADCASTW ymm1, xmm2/m16 - /// VPBROADCASTW ymm1 {k1}{z}, xmm2/m16 + /// __m256i _mm256_broadcastw_epi16 (__m128i a) + /// VPBROADCASTW ymm1, xmm2/m16 + /// VPBROADCASTW ymm1 {k1}{z}, xmm2/m16 /// public static Vector256 BroadcastScalarToVector256(Vector128 value) => BroadcastScalarToVector256(value); /// - /// __m256i _mm256_broadcastd_epi32 (__m128i a) - /// VPBROADCASTD ymm1, xmm2/m32 - /// VPBROADCASTD ymm1 {k1}{z}, xmm2/m32 + /// __m256i _mm256_broadcastd_epi32 (__m128i a) + /// VPBROADCASTD ymm1, xmm2/m32 + /// VPBROADCASTD ymm1 {k1}{z}, xmm2/m32 /// public static Vector256 BroadcastScalarToVector256(Vector128 value) => BroadcastScalarToVector256(value); /// - /// __m256i _mm256_broadcastd_epi32 (__m128i a) - /// VPBROADCASTD ymm1, xmm2/m32 - /// VPBROADCASTD ymm1 {k1}{z}, xmm2/m32 + /// __m256i _mm256_broadcastd_epi32 (__m128i a) + /// VPBROADCASTD ymm1, xmm2/m32 + /// VPBROADCASTD ymm1 {k1}{z}, xmm2/m32 /// public static Vector256 BroadcastScalarToVector256(Vector128 value) => BroadcastScalarToVector256(value); /// - /// __m256i _mm256_broadcastq_epi64 (__m128i a) - /// VPBROADCASTQ ymm1, xmm2/m64 - /// VPBROADCASTQ ymm1 {k1}{z}, xmm2/m64 + /// __m256i _mm256_broadcastq_epi64 (__m128i a) + /// VPBROADCASTQ ymm1, xmm2/m64 + /// VPBROADCASTQ ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 BroadcastScalarToVector256(Vector128 value) => BroadcastScalarToVector256(value); /// - /// __m256i _mm256_broadcastq_epi64 (__m128i a) - /// VPBROADCASTQ ymm1, xmm2/m64 - /// VPBROADCASTQ ymm1 {k1}{z}, xmm2/m64 + /// __m256i _mm256_broadcastq_epi64 (__m128i a) + /// VPBROADCASTQ ymm1, xmm2/m64 + /// VPBROADCASTQ ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 BroadcastScalarToVector256(Vector128 value) => BroadcastScalarToVector256(value); /// - /// __m256 _mm256_broadcastss_ps (__m128 a) - /// VBROADCASTSS ymm1, xmm2/m32 - /// VBROADCASTSS ymm1 {k1}{z}, xmm2/m32 + /// __m256 _mm256_broadcastss_ps (__m128 a) + /// VBROADCASTSS ymm1, xmm2/m32 + /// VBROADCASTSS ymm1 {k1}{z}, xmm2/m32 /// public static Vector256 BroadcastScalarToVector256(Vector128 value) => BroadcastScalarToVector256(value); /// - /// __m256d _mm256_broadcastsd_pd (__m128d a) - /// VBROADCASTSD ymm1, xmm2/m64 - /// VBROADCASTSD ymm1 {k1}{z}, xmm2/m64 + /// __m256d _mm256_broadcastsd_pd (__m128d a) + /// VBROADCASTSD ymm1, xmm2/m64 + /// VBROADCASTSD ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 BroadcastScalarToVector256(Vector128 value) => BroadcastScalarToVector256(value); /// - /// __m256i _mm256_broadcastb_epi8 (__m128i a) - /// VPBROADCASTB ymm1, m8 - /// VPBROADCASTB ymm1 {k1}{z}, m8 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastb_epi8 (__m128i a) + /// VPBROADCASTB ymm1, m8 + /// VPBROADCASTB ymm1 {k1}{z}, m8 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastScalarToVector256(byte* source) => BroadcastScalarToVector256(source); /// - /// __m256i _mm256_broadcastb_epi8 (__m128i a) - /// VPBROADCASTB ymm1, m8 - /// VPBROADCASTB ymm1 {k1}{z}, m8 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastb_epi8 (__m128i a) + /// VPBROADCASTB ymm1, m8 + /// VPBROADCASTB ymm1 {k1}{z}, m8 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastScalarToVector256(sbyte* source) => BroadcastScalarToVector256(source); /// - /// __m256i _mm256_broadcastw_epi16 (__m128i a) - /// VPBROADCASTW ymm1, m16 - /// VPBROADCASTW ymm1 {k1}{z}, m16 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastw_epi16 (__m128i a) + /// VPBROADCASTW ymm1, m16 + /// VPBROADCASTW ymm1 {k1}{z}, m16 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastScalarToVector256(short* source) => BroadcastScalarToVector256(source); /// - /// __m256i _mm256_broadcastw_epi16 (__m128i a) - /// VPBROADCASTW ymm1, m16 - /// VPBROADCASTW ymm1 {k1}{z}, m16 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastw_epi16 (__m128i a) + /// VPBROADCASTW ymm1, m16 + /// VPBROADCASTW ymm1 {k1}{z}, m16 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastScalarToVector256(ushort* source) => BroadcastScalarToVector256(source); /// - /// __m256i _mm256_broadcastd_epi32 (__m128i a) - /// VPBROADCASTD ymm1, m32 - /// VPBROADCASTD ymm1 {k1}{z}, m32 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastd_epi32 (__m128i a) + /// VPBROADCASTD ymm1, m32 + /// VPBROADCASTD ymm1 {k1}{z}, m32 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastScalarToVector256(int* source) => BroadcastScalarToVector256(source); /// - /// __m256i _mm256_broadcastd_epi32 (__m128i a) - /// VPBROADCASTD ymm1, m32 - /// VPBROADCASTD ymm1 {k1}{z}, m32 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastd_epi32 (__m128i a) + /// VPBROADCASTD ymm1, m32 + /// VPBROADCASTD ymm1 {k1}{z}, m32 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastScalarToVector256(uint* source) => BroadcastScalarToVector256(source); /// - /// __m256i _mm256_broadcastq_epi64 (__m128i a) - /// VPBROADCASTQ ymm1, m64 - /// VPBROADCASTQ ymm1 {k1}{z}, m64 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastq_epi64 (__m128i a) + /// VPBROADCASTQ ymm1, m64 + /// VPBROADCASTQ ymm1 {k1}{z}, m64 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastScalarToVector256(long* source) => BroadcastScalarToVector256(source); /// - /// __m256i _mm256_broadcastq_epi64 (__m128i a) - /// VPBROADCASTQ ymm1, m64 - /// VPBROADCASTQ ymm1 {k1}{z}, m64 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastq_epi64 (__m128i a) + /// VPBROADCASTQ ymm1, m64 + /// VPBROADCASTQ ymm1 {k1}{z}, m64 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastScalarToVector256(ulong* source) => BroadcastScalarToVector256(source); /// - /// __m256i _mm256_broadcastsi128_si256 (__m128i a) - /// VBROADCASTI128 ymm1, m128 - /// VBROADCASTI32x4 ymm1 {k1}{z}, m128 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastsi128_si256 (__m128i a) + /// VBROADCASTI128 ymm1, m128 + /// VBROADCASTI32x4 ymm1 {k1}{z}, m128 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastVector128ToVector256(sbyte* address) => BroadcastVector128ToVector256(address); /// - /// __m256i _mm256_broadcastsi128_si256 (__m128i a) - /// VBROADCASTI128 ymm1, m128 - /// VBROADCASTI32x4 ymm1 {k1}{z}, m128 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastsi128_si256 (__m128i a) + /// VBROADCASTI128 ymm1, m128 + /// VBROADCASTI32x4 ymm1 {k1}{z}, m128 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastVector128ToVector256(byte* address) => BroadcastVector128ToVector256(address); /// - /// __m256i _mm256_broadcastsi128_si256 (__m128i a) - /// VBROADCASTI128 ymm1, m128 - /// VBROADCASTI32x4 ymm1 {k1}{z}, m128 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastsi128_si256 (__m128i a) + /// VBROADCASTI128 ymm1, m128 + /// VBROADCASTI32x4 ymm1 {k1}{z}, m128 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastVector128ToVector256(short* address) => BroadcastVector128ToVector256(address); /// - /// __m256i _mm256_broadcastsi128_si256 (__m128i a) - /// VBROADCASTI128 ymm1, m128 - /// VBROADCASTI32x4 ymm1 {k1}{z}, m128 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastsi128_si256 (__m128i a) + /// VBROADCASTI128 ymm1, m128 + /// VBROADCASTI32x4 ymm1 {k1}{z}, m128 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastVector128ToVector256(ushort* address) => BroadcastVector128ToVector256(address); /// - /// __m256i _mm256_broadcastsi128_si256 (__m128i a) - /// VBROADCASTI128 ymm1, m128 - /// VBROADCASTI32x4 ymm1 {k1}{z}, m128 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastsi128_si256 (__m128i a) + /// VBROADCASTI128 ymm1, m128 + /// VBROADCASTI32x4 ymm1 {k1}{z}, m128 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastVector128ToVector256(int* address) => BroadcastVector128ToVector256(address); /// - /// __m256i _mm256_broadcastsi128_si256 (__m128i a) - /// VBROADCASTI128 ymm1, m128 - /// VBROADCASTI32x4 ymm1 {k1}{z}, m128 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastsi128_si256 (__m128i a) + /// VBROADCASTI128 ymm1, m128 + /// VBROADCASTI32x4 ymm1 {k1}{z}, m128 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastVector128ToVector256(uint* address) => BroadcastVector128ToVector256(address); /// - /// __m256i _mm256_broadcastsi128_si256 (__m128i a) - /// VBROADCASTI128 ymm1, m128 - /// VBROADCASTI64x2 ymm1 {k1}{z}, m128 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastsi128_si256 (__m128i a) + /// VBROADCASTI128 ymm1, m128 + /// VBROADCASTI64x2 ymm1 {k1}{z}, m128 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastVector128ToVector256(long* address) => BroadcastVector128ToVector256(address); /// - /// __m256i _mm256_broadcastsi128_si256 (__m128i a) - /// VBROADCASTI128 ymm1, m128 - /// VBROADCASTI64x2 ymm1 {k1}{z}, m128 - /// The above native signature does not directly correspond to the managed signature. + /// __m256i _mm256_broadcastsi128_si256 (__m128i a) + /// VBROADCASTI128 ymm1, m128 + /// VBROADCASTI64x2 ymm1 {k1}{z}, m128 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe Vector256 BroadcastVector128ToVector256(ulong* address) => BroadcastVector128ToVector256(address); /// - /// __m256i _mm256_cmpeq_epi8 (__m256i a, __m256i b) - /// VPCMPEQB ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_cmpeq_epi8 (__m256i a, __m256i b) + /// VPCMPEQB ymm1, ymm2, ymm3/m256 /// public static Vector256 CompareEqual(Vector256 left, Vector256 right) => CompareEqual(left, right); /// - /// __m256i _mm256_cmpeq_epi8 (__m256i a, __m256i b) - /// VPCMPEQB ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_cmpeq_epi8 (__m256i a, __m256i b) + /// VPCMPEQB ymm1, ymm2, ymm3/m256 /// public static Vector256 CompareEqual(Vector256 left, Vector256 right) => CompareEqual(left, right); /// - /// __m256i _mm256_cmpeq_epi16 (__m256i a, __m256i b) - /// VPCMPEQW ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_cmpeq_epi16 (__m256i a, __m256i b) + /// VPCMPEQW ymm1, ymm2, ymm3/m256 /// public static Vector256 CompareEqual(Vector256 left, Vector256 right) => CompareEqual(left, right); /// - /// __m256i _mm256_cmpeq_epi16 (__m256i a, __m256i b) - /// VPCMPEQW ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_cmpeq_epi16 (__m256i a, __m256i b) + /// VPCMPEQW ymm1, ymm2, ymm3/m256 /// public static Vector256 CompareEqual(Vector256 left, Vector256 right) => CompareEqual(left, right); /// - /// __m256i _mm256_cmpeq_epi32 (__m256i a, __m256i b) - /// VPCMPEQD ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_cmpeq_epi32 (__m256i a, __m256i b) + /// VPCMPEQD ymm1, ymm2, ymm3/m256 /// public static Vector256 CompareEqual(Vector256 left, Vector256 right) => CompareEqual(left, right); /// - /// __m256i _mm256_cmpeq_epi32 (__m256i a, __m256i b) - /// VPCMPEQD ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_cmpeq_epi32 (__m256i a, __m256i b) + /// VPCMPEQD ymm1, ymm2, ymm3/m256 /// public static Vector256 CompareEqual(Vector256 left, Vector256 right) => CompareEqual(left, right); /// - /// __m256i _mm256_cmpeq_epi64 (__m256i a, __m256i b) - /// VPCMPEQQ ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_cmpeq_epi64 (__m256i a, __m256i b) + /// VPCMPEQQ ymm1, ymm2, ymm3/m256 /// public static Vector256 CompareEqual(Vector256 left, Vector256 right) => CompareEqual(left, right); /// - /// __m256i _mm256_cmpeq_epi64 (__m256i a, __m256i b) - /// VPCMPEQQ ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_cmpeq_epi64 (__m256i a, __m256i b) + /// VPCMPEQQ ymm1, ymm2, ymm3/m256 /// public static Vector256 CompareEqual(Vector256 left, Vector256 right) => CompareEqual(left, right); /// - /// __m256i _mm256_cmpgt_epi8 (__m256i a, __m256i b) - /// VPCMPGTB ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_cmpgt_epi8 (__m256i a, __m256i b) + /// VPCMPGTB ymm1, ymm2, ymm3/m256 /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) => CompareGreaterThan(left, right); /// - /// __m256i _mm256_cmpgt_epi16 (__m256i a, __m256i b) - /// VPCMPGTW ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_cmpgt_epi16 (__m256i a, __m256i b) + /// VPCMPGTW ymm1, ymm2, ymm3/m256 /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) => CompareGreaterThan(left, right); /// - /// __m256i _mm256_cmpgt_epi32 (__m256i a, __m256i b) - /// VPCMPGTD ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_cmpgt_epi32 (__m256i a, __m256i b) + /// VPCMPGTD ymm1, ymm2, ymm3/m256 /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) => CompareGreaterThan(left, right); /// - /// __m256i _mm256_cmpgt_epi64 (__m256i a, __m256i b) - /// VPCMPGTQ ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_cmpgt_epi64 (__m256i a, __m256i b) + /// VPCMPGTQ ymm1, ymm2, ymm3/m256 /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) => CompareGreaterThan(left, right); /// - /// int _mm256_cvtsi256_si32 (__m256i a) - /// VMOVD r/m32, ymm1 + /// int _mm256_cvtsi256_si32 (__m256i a) + /// VMOVD r/m32, ymm1 /// public static int ConvertToInt32(Vector256 value) => ConvertToInt32(value); /// - /// int _mm256_cvtsi256_si32 (__m256i a) - /// VMOVD r/m32, ymm1 + /// int _mm256_cvtsi256_si32 (__m256i a) + /// VMOVD r/m32, ymm1 /// public static uint ConvertToUInt32(Vector256 value) => ConvertToUInt32(value); /// - /// __m256i _mm256_cvtepi8_epi16 (__m128i a) - /// VPMOVSXBW ymm1, xmm2/m128 - /// VPMOVSXBW ymm1 {k1}{z}, xmm2/m128 + /// __m256i _mm256_cvtepi8_epi16 (__m128i a) + /// VPMOVSXBW ymm1, xmm2/m128 + /// VPMOVSXBW ymm1 {k1}{z}, xmm2/m128 /// public static Vector256 ConvertToVector256Int16(Vector128 value) => ConvertToVector256Int16(value); /// - /// __m256i _mm256_cvtepu8_epi16 (__m128i a) - /// VPMOVZXBW ymm1, xmm2/m128 - /// VPMOVZXBW ymm1 {k1}{z}, xmm2/m128 + /// __m256i _mm256_cvtepu8_epi16 (__m128i a) + /// VPMOVZXBW ymm1, xmm2/m128 + /// VPMOVZXBW ymm1 {k1}{z}, xmm2/m128 /// public static Vector256 ConvertToVector256Int16(Vector128 value) => ConvertToVector256Int16(value); /// - /// __m256i _mm256_cvtepi8_epi32 (__m128i a) - /// VPMOVSXBD ymm1, xmm2/m64 - /// VPMOVSXBD ymm1 {k1}{z}, xmm2/m64 + /// __m256i _mm256_cvtepi8_epi32 (__m128i a) + /// VPMOVSXBD ymm1, xmm2/m64 + /// VPMOVSXBD ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 ConvertToVector256Int32(Vector128 value) => ConvertToVector256Int32(value); /// - /// __m256i _mm256_cvtepu8_epi32 (__m128i a) - /// VPMOVZXBD ymm1, xmm2/m64 - /// VPMOVZXBD ymm1 {k1}{z}, xmm2/m64 + /// __m256i _mm256_cvtepu8_epi32 (__m128i a) + /// VPMOVZXBD ymm1, xmm2/m64 + /// VPMOVZXBD ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 ConvertToVector256Int32(Vector128 value) => ConvertToVector256Int32(value); /// - /// __m256i _mm256_cvtepi16_epi32 (__m128i a) - /// VPMOVSXWD ymm1, xmm2/m128 - /// VPMOVSXWD ymm1 {k1}{z}, xmm2/m128 + /// __m256i _mm256_cvtepi16_epi32 (__m128i a) + /// VPMOVSXWD ymm1, xmm2/m128 + /// VPMOVSXWD ymm1 {k1}{z}, xmm2/m128 /// public static Vector256 ConvertToVector256Int32(Vector128 value) => ConvertToVector256Int32(value); /// - /// __m256i _mm256_cvtepu16_epi32 (__m128i a) - /// VPMOVZXWD ymm1, xmm2/m128 - /// VPMOVZXWD ymm1 {k1}{z}, xmm2/m128 + /// __m256i _mm256_cvtepu16_epi32 (__m128i a) + /// VPMOVZXWD ymm1, xmm2/m128 + /// VPMOVZXWD ymm1 {k1}{z}, xmm2/m128 /// public static Vector256 ConvertToVector256Int32(Vector128 value) => ConvertToVector256Int32(value); /// - /// __m256i _mm256_cvtepi8_epi64 (__m128i a) - /// VPMOVSXBQ ymm1, xmm2/m32 - /// VPMOVSXBQ ymm1 {k1}{z}, xmm2/m32 + /// __m256i _mm256_cvtepi8_epi64 (__m128i a) + /// VPMOVSXBQ ymm1, xmm2/m32 + /// VPMOVSXBQ ymm1 {k1}{z}, xmm2/m32 /// public static Vector256 ConvertToVector256Int64(Vector128 value) => ConvertToVector256Int64(value); /// - /// __m256i _mm256_cvtepu8_epi64 (__m128i a) - /// VPMOVZXBQ ymm1, xmm2/m32 - /// VPMOVZXBQ ymm1 {k1}{z}, xmm2/m32 + /// __m256i _mm256_cvtepu8_epi64 (__m128i a) + /// VPMOVZXBQ ymm1, xmm2/m32 + /// VPMOVZXBQ ymm1 {k1}{z}, xmm2/m32 /// public static Vector256 ConvertToVector256Int64(Vector128 value) => ConvertToVector256Int64(value); /// - /// __m256i _mm256_cvtepi16_epi64 (__m128i a) - /// VPMOVSXWQ ymm1, xmm2/m64 - /// VPMOVSXWQ ymm1 {k1}{z}, xmm2/m64 + /// __m256i _mm256_cvtepi16_epi64 (__m128i a) + /// VPMOVSXWQ ymm1, xmm2/m64 + /// VPMOVSXWQ ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 ConvertToVector256Int64(Vector128 value) => ConvertToVector256Int64(value); /// - /// __m256i _mm256_cvtepu16_epi64 (__m128i a) - /// VPMOVZXWQ ymm1, xmm2/m64 - /// VPMOVZXWQ ymm1 {k1}{z}, xmm2/m64 + /// __m256i _mm256_cvtepu16_epi64 (__m128i a) + /// VPMOVZXWQ ymm1, xmm2/m64 + /// VPMOVZXWQ ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 ConvertToVector256Int64(Vector128 value) => ConvertToVector256Int64(value); /// - /// __m256i _mm256_cvtepi32_epi64 (__m128i a) - /// VPMOVSXDQ ymm1, xmm2/m128 - /// VPMOVSXDQ ymm1 {k1}{z}, xmm2/m128 + /// __m256i _mm256_cvtepi32_epi64 (__m128i a) + /// VPMOVSXDQ ymm1, xmm2/m128 + /// VPMOVSXDQ ymm1 {k1}{z}, xmm2/m128 /// public static Vector256 ConvertToVector256Int64(Vector128 value) => ConvertToVector256Int64(value); /// - /// __m256i _mm256_cvtepu32_epi64 (__m128i a) - /// VPMOVZXDQ ymm1, xmm2/m128 - /// VPMOVZXDQ ymm1 {k1}{z}, xmm2/m128 + /// __m256i _mm256_cvtepu32_epi64 (__m128i a) + /// VPMOVZXDQ ymm1, xmm2/m128 + /// VPMOVZXDQ ymm1 {k1}{z}, xmm2/m128 /// public static Vector256 ConvertToVector256Int64(Vector128 value) => ConvertToVector256Int64(value); /// - /// VPMOVSXBW ymm1, m128 - /// VPMOVSXBW ymm1 {k1}{z}, m128 - /// The native signature does not exist. We provide this additional overload for completeness. + /// VPMOVSXBW ymm1, m128 + /// VPMOVSXBW ymm1 {k1}{z}, m128 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector256 ConvertToVector256Int16(sbyte* address) => ConvertToVector256Int16(address); /// - /// VPMOVZXBW ymm1, m128 - /// VPMOVZXBW ymm1 {k1}{z}, m128 - /// The native signature does not exist. We provide this additional overload for completeness. + /// VPMOVZXBW ymm1, m128 + /// VPMOVZXBW ymm1 {k1}{z}, m128 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector256 ConvertToVector256Int16(byte* address) => ConvertToVector256Int16(address); /// - /// VPMOVSXBD ymm1, m64 - /// VPMOVSXBD ymm1 {k1}{z}, m64 - /// The native signature does not exist. We provide this additional overload for completeness. + /// VPMOVSXBD ymm1, m64 + /// VPMOVSXBD ymm1 {k1}{z}, m64 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector256 ConvertToVector256Int32(sbyte* address) => ConvertToVector256Int32(address); /// - /// VPMOVZXBD ymm1, m64 - /// VPMOVZXBD ymm1 {k1}{z}, m64 - /// The native signature does not exist. We provide this additional overload for completeness. + /// VPMOVZXBD ymm1, m64 + /// VPMOVZXBD ymm1 {k1}{z}, m64 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector256 ConvertToVector256Int32(byte* address) => ConvertToVector256Int32(address); /// - /// VPMOVSXWD ymm1, m128 - /// VPMOVSXWD ymm1 {k1}{z}, m128 - /// The native signature does not exist. We provide this additional overload for completeness. + /// VPMOVSXWD ymm1, m128 + /// VPMOVSXWD ymm1 {k1}{z}, m128 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector256 ConvertToVector256Int32(short* address) => ConvertToVector256Int32(address); /// - /// VPMOVZXWD ymm1, m128 - /// VPMOVZXWD ymm1 {k1}{z}, m128 - /// The native signature does not exist. We provide this additional overload for completeness. + /// VPMOVZXWD ymm1, m128 + /// VPMOVZXWD ymm1 {k1}{z}, m128 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector256 ConvertToVector256Int32(ushort* address) => ConvertToVector256Int32(address); /// - /// VPMOVSXBQ ymm1, m32 - /// VPMOVSXBQ ymm1 {k1}{z}, m32 - /// The native signature does not exist. We provide this additional overload for completeness. + /// VPMOVSXBQ ymm1, m32 + /// VPMOVSXBQ ymm1 {k1}{z}, m32 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector256 ConvertToVector256Int64(sbyte* address) => ConvertToVector256Int64(address); /// - /// VPMOVZXBQ ymm1, m32 - /// VPMOVZXBQ ymm1 {k1}{z}, m32 - /// The native signature does not exist. We provide this additional overload for completeness. + /// VPMOVZXBQ ymm1, m32 + /// VPMOVZXBQ ymm1 {k1}{z}, m32 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector256 ConvertToVector256Int64(byte* address) => ConvertToVector256Int64(address); /// - /// VPMOVSXWQ ymm1, m64 - /// VPMOVSXWQ ymm1 {k1}{z}, m64 - /// The native signature does not exist. We provide this additional overload for completeness. + /// VPMOVSXWQ ymm1, m64 + /// VPMOVSXWQ ymm1 {k1}{z}, m64 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector256 ConvertToVector256Int64(short* address) => ConvertToVector256Int64(address); /// - /// VPMOVZXWQ ymm1, m64 - /// VPMOVZXWQ ymm1 {k1}{z}, m64 - /// The native signature does not exist. We provide this additional overload for completeness. + /// VPMOVZXWQ ymm1, m64 + /// VPMOVZXWQ ymm1 {k1}{z}, m64 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector256 ConvertToVector256Int64(ushort* address) => ConvertToVector256Int64(address); /// - /// VPMOVSXDQ ymm1, m128 - /// VPMOVSXDQ ymm1 {k1}{z}, m128 - /// The native signature does not exist. We provide this additional overload for completeness. + /// VPMOVSXDQ ymm1, m128 + /// VPMOVSXDQ ymm1 {k1}{z}, m128 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector256 ConvertToVector256Int64(int* address) => ConvertToVector256Int64(address); /// - /// VPMOVZXDQ ymm1, m128 - /// VPMOVZXDQ ymm1 {k1}{z}, m128 - /// The native signature does not exist. We provide this additional overload for completeness. + /// VPMOVZXDQ ymm1, m128 + /// VPMOVZXDQ ymm1 {k1}{z}, m128 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector256 ConvertToVector256Int64(uint* address) => ConvertToVector256Int64(address); /// - /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) - /// VEXTRACTI128 xmm1/m128, ymm2, imm8 - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// VEXTRACTI128 xmm1/m128, ymm2, imm8 + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static new Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) - /// VEXTRACTI128 xmm1/m128, ymm2, imm8 - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// VEXTRACTI128 xmm1/m128, ymm2, imm8 + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static new Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) - /// VEXTRACTI128 xmm1/m128, ymm2, imm8 - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// VEXTRACTI128 xmm1/m128, ymm2, imm8 + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static new Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) - /// VEXTRACTI128 xmm1/m128, ymm2, imm8 - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// VEXTRACTI128 xmm1/m128, ymm2, imm8 + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static new Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) - /// VEXTRACTI128 xmm1/m128, ymm2, imm8 - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// VEXTRACTI128 xmm1/m128, ymm2, imm8 + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static new Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) - /// VEXTRACTI128 xmm1/m128, ymm2, imm8 - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// VEXTRACTI128 xmm1/m128, ymm2, imm8 + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static new Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) - /// VEXTRACTI128 xmm1/m128, ymm2, imm8 - /// VEXTRACTI64x2 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// VEXTRACTI128 xmm1/m128, ymm2, imm8 + /// VEXTRACTI64x2 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static new Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) - /// VEXTRACTI128 xmm1/m128, ymm2, imm8 - /// VEXTRACTI64x2 xmm1/m128 {k1}{z}, ymm2, imm8 + /// __m128i _mm256_extracti128_si256 (__m256i a, const int imm8) + /// VEXTRACTI128 xmm1/m128, ymm2, imm8 + /// VEXTRACTI64x2 xmm1/m128 {k1}{z}, ymm2, imm8 /// public static new Vector128 ExtractVector128(Vector256 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128i _mm_i32gather_epi32 (int const* base_addr, __m128i vindex, const int scale) - /// VPGATHERDD xmm1, vm32x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_i32gather_epi32 (int const* base_addr, __m128i vindex, const int scale) + /// VPGATHERDD xmm1, vm32x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(int* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -931,9 +936,9 @@ public static unsafe Vector128 GatherVector128(int* baseAddress, Vector128< }; } /// - /// __m128i _mm_i32gather_epi32 (int const* base_addr, __m128i vindex, const int scale) - /// VPGATHERDD xmm1, vm32x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_i32gather_epi32 (int const* base_addr, __m128i vindex, const int scale) + /// VPGATHERDD xmm1, vm32x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(uint* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -947,9 +952,9 @@ public static unsafe Vector128 GatherVector128(uint* baseAddress, Vector12 }; } /// - /// __m128i _mm_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) - /// VPGATHERDQ xmm1, vm32x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) + /// VPGATHERDQ xmm1, vm32x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(long* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -963,9 +968,9 @@ public static unsafe Vector128 GatherVector128(long* baseAddress, Vector12 }; } /// - /// __m128i _mm_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) - /// VPGATHERDQ xmm1, vm32x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) + /// VPGATHERDQ xmm1, vm32x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(ulong* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -979,9 +984,9 @@ public static unsafe Vector128 GatherVector128(ulong* baseAddress, Vector }; } /// - /// __m128 _mm_i32gather_ps (float const* base_addr, __m128i vindex, const int scale) - /// VGATHERDPS xmm1, vm32x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128 _mm_i32gather_ps (float const* base_addr, __m128i vindex, const int scale) + /// VGATHERDPS xmm1, vm32x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(float* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -995,9 +1000,9 @@ public static unsafe Vector128 GatherVector128(float* baseAddress, Vector }; } /// - /// __m128d _mm_i32gather_pd (double const* base_addr, __m128i vindex, const int scale) - /// VGATHERDPD xmm1, vm32x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128d _mm_i32gather_pd (double const* base_addr, __m128i vindex, const int scale) + /// VGATHERDPD xmm1, vm32x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(double* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1011,9 +1016,9 @@ public static unsafe Vector128 GatherVector128(double* baseAddress, Vect }; } /// - /// __m128i _mm_i64gather_epi32 (int const* base_addr, __m128i vindex, const int scale) - /// VPGATHERQD xmm1, vm64x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_i64gather_epi32 (int const* base_addr, __m128i vindex, const int scale) + /// VPGATHERQD xmm1, vm64x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(int* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1027,9 +1032,9 @@ public static unsafe Vector128 GatherVector128(int* baseAddress, Vector128< }; } /// - /// __m128i _mm_i64gather_epi32 (int const* base_addr, __m128i vindex, const int scale) - /// VPGATHERQD xmm1, vm64x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_i64gather_epi32 (int const* base_addr, __m128i vindex, const int scale) + /// VPGATHERQD xmm1, vm64x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(uint* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1043,9 +1048,9 @@ public static unsafe Vector128 GatherVector128(uint* baseAddress, Vector12 }; } /// - /// __m128i _mm_i64gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) - /// VPGATHERQQ xmm1, vm64x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_i64gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) + /// VPGATHERQQ xmm1, vm64x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(long* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1059,9 +1064,9 @@ public static unsafe Vector128 GatherVector128(long* baseAddress, Vector12 }; } /// - /// __m128i _mm_i64gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) - /// VPGATHERQQ xmm1, vm64x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_i64gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) + /// VPGATHERQQ xmm1, vm64x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(ulong* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1075,9 +1080,9 @@ public static unsafe Vector128 GatherVector128(ulong* baseAddress, Vector }; } /// - /// __m128 _mm_i64gather_ps (float const* base_addr, __m128i vindex, const int scale) - /// VGATHERQPS xmm1, vm64x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128 _mm_i64gather_ps (float const* base_addr, __m128i vindex, const int scale) + /// VGATHERQPS xmm1, vm64x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(float* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1091,9 +1096,9 @@ public static unsafe Vector128 GatherVector128(float* baseAddress, Vector }; } /// - /// __m128d _mm_i64gather_pd (double const* base_addr, __m128i vindex, const int scale) - /// VGATHERQPD xmm1, vm64x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128d _mm_i64gather_pd (double const* base_addr, __m128i vindex, const int scale) + /// VGATHERQPD xmm1, vm64x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(double* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1107,9 +1112,9 @@ public static unsafe Vector128 GatherVector128(double* baseAddress, Vect }; } /// - /// __m256i _mm256_i32gather_epi32 (int const* base_addr, __m256i vindex, const int scale) - /// VPGATHERDD ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256i _mm256_i32gather_epi32 (int const* base_addr, __m256i vindex, const int scale) + /// VPGATHERDD ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherVector256(int* baseAddress, Vector256 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1123,9 +1128,9 @@ public static unsafe Vector256 GatherVector256(int* baseAddress, Vector256< }; } /// - /// __m256i _mm256_i32gather_epi32 (int const* base_addr, __m256i vindex, const int scale) - /// VPGATHERDD ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256i _mm256_i32gather_epi32 (int const* base_addr, __m256i vindex, const int scale) + /// VPGATHERDD ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherVector256(uint* baseAddress, Vector256 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1139,9 +1144,9 @@ public static unsafe Vector256 GatherVector256(uint* baseAddress, Vector25 }; } /// - /// __m256i _mm256_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) - /// VPGATHERDQ ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256i _mm256_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) + /// VPGATHERDQ ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherVector256(long* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1155,9 +1160,9 @@ public static unsafe Vector256 GatherVector256(long* baseAddress, Vector12 }; } /// - /// __m256i _mm256_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) - /// VPGATHERDQ ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256i _mm256_i32gather_epi64 (__int64 const* base_addr, __m128i vindex, const int scale) + /// VPGATHERDQ ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherVector256(ulong* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1171,9 +1176,9 @@ public static unsafe Vector256 GatherVector256(ulong* baseAddress, Vector }; } /// - /// __m256 _mm256_i32gather_ps (float const* base_addr, __m256i vindex, const int scale) - /// VGATHERDPS ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256 _mm256_i32gather_ps (float const* base_addr, __m256i vindex, const int scale) + /// VGATHERDPS ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherVector256(float* baseAddress, Vector256 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1187,9 +1192,9 @@ public static unsafe Vector256 GatherVector256(float* baseAddress, Vector }; } /// - /// __m256d _mm256_i32gather_pd (double const* base_addr, __m128i vindex, const int scale) - /// VGATHERDPD ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256d _mm256_i32gather_pd (double const* base_addr, __m128i vindex, const int scale) + /// VGATHERDPD ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherVector256(double* baseAddress, Vector128 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1203,9 +1208,9 @@ public static unsafe Vector256 GatherVector256(double* baseAddress, Vect }; } /// - /// __m128i _mm256_i64gather_epi32 (int const* base_addr, __m256i vindex, const int scale) - /// VPGATHERQD xmm1, vm64y, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm256_i64gather_epi32 (int const* base_addr, __m256i vindex, const int scale) + /// VPGATHERQD xmm1, vm64y, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(int* baseAddress, Vector256 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1219,9 +1224,9 @@ public static unsafe Vector128 GatherVector128(int* baseAddress, Vector256< }; } /// - /// __m128i _mm256_i64gather_epi32 (int const* base_addr, __m256i vindex, const int scale) - /// VPGATHERQD xmm1, vm64y, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm256_i64gather_epi32 (int const* base_addr, __m256i vindex, const int scale) + /// VPGATHERQD xmm1, vm64y, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(uint* baseAddress, Vector256 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1235,9 +1240,9 @@ public static unsafe Vector128 GatherVector128(uint* baseAddress, Vector25 }; } /// - /// __m256i _mm256_i64gather_epi64 (__int64 const* base_addr, __m256i vindex, const int scale) - /// VPGATHERQQ ymm1, vm64y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256i _mm256_i64gather_epi64 (__int64 const* base_addr, __m256i vindex, const int scale) + /// VPGATHERQQ ymm1, vm64y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherVector256(long* baseAddress, Vector256 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1251,9 +1256,9 @@ public static unsafe Vector256 GatherVector256(long* baseAddress, Vector25 }; } /// - /// __m256i _mm256_i64gather_epi64 (__int64 const* base_addr, __m256i vindex, const int scale) - /// VPGATHERQQ ymm1, vm64y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256i _mm256_i64gather_epi64 (__int64 const* base_addr, __m256i vindex, const int scale) + /// VPGATHERQQ ymm1, vm64y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherVector256(ulong* baseAddress, Vector256 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1267,9 +1272,9 @@ public static unsafe Vector256 GatherVector256(ulong* baseAddress, Vector }; } /// - /// __m128 _mm256_i64gather_ps (float const* base_addr, __m256i vindex, const int scale) - /// VGATHERQPS xmm1, vm64y, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128 _mm256_i64gather_ps (float const* base_addr, __m256i vindex, const int scale) + /// VGATHERQPS xmm1, vm64y, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherVector128(float* baseAddress, Vector256 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1283,9 +1288,9 @@ public static unsafe Vector128 GatherVector128(float* baseAddress, Vector }; } /// - /// __m256d _mm256_i64gather_pd (double const* base_addr, __m256i vindex, const int scale) - /// VGATHERQPD ymm1, vm64y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256d _mm256_i64gather_pd (double const* base_addr, __m256i vindex, const int scale) + /// VGATHERQPD ymm1, vm64y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherVector256(double* baseAddress, Vector256 index, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1300,9 +1305,9 @@ public static unsafe Vector256 GatherVector256(double* baseAddress, Vect } /// - /// __m128i _mm_mask_i32gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale) - /// VPGATHERDD xmm1, vm32x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_mask_i32gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale) + /// VPGATHERDD xmm1, vm32x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, int* baseAddress, Vector128 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1316,9 +1321,9 @@ public static unsafe Vector128 GatherMaskVector128(Vector128 source, i }; } /// - /// __m128i _mm_mask_i32gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale) - /// VPGATHERDD xmm1, vm32x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_mask_i32gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale) + /// VPGATHERDD xmm1, vm32x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, uint* baseAddress, Vector128 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1332,9 +1337,9 @@ public static unsafe Vector128 GatherMaskVector128(Vector128 source, }; } /// - /// __m128i _mm_mask_i32gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) - /// VPGATHERDQ xmm1, vm32x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_mask_i32gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) + /// VPGATHERDQ xmm1, vm32x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, long* baseAddress, Vector128 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1348,9 +1353,9 @@ public static unsafe Vector128 GatherMaskVector128(Vector128 source, }; } /// - /// __m128i _mm_mask_i32gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) - /// VPGATHERDQ xmm1, vm32x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_mask_i32gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) + /// VPGATHERDQ xmm1, vm32x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, ulong* baseAddress, Vector128 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1364,9 +1369,9 @@ public static unsafe Vector128 GatherMaskVector128(Vector128 sourc }; } /// - /// __m128 _mm_mask_i32gather_ps (__m128 src, float const* base_addr, __m128i vindex, __m128 mask, const int scale) - /// VGATHERDPS xmm1, vm32x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128 _mm_mask_i32gather_ps (__m128 src, float const* base_addr, __m128i vindex, __m128 mask, const int scale) + /// VGATHERDPS xmm1, vm32x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, float* baseAddress, Vector128 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1380,9 +1385,9 @@ public static unsafe Vector128 GatherMaskVector128(Vector128 sourc }; } /// - /// __m128d _mm_mask_i32gather_pd (__m128d src, double const* base_addr, __m128i vindex, __m128d mask, const int scale) - /// VGATHERDPD xmm1, vm32x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128d _mm_mask_i32gather_pd (__m128d src, double const* base_addr, __m128i vindex, __m128d mask, const int scale) + /// VGATHERDPD xmm1, vm32x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, double* baseAddress, Vector128 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1396,9 +1401,9 @@ public static unsafe Vector128 GatherMaskVector128(Vector128 sou }; } /// - /// __m128i _mm_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale) - /// VPGATHERQD xmm1, vm64x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale) + /// VPGATHERQD xmm1, vm64x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, int* baseAddress, Vector128 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1412,9 +1417,9 @@ public static unsafe Vector128 GatherMaskVector128(Vector128 source, i }; } /// - /// __m128i _mm_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale) - /// VPGATHERQD xmm1, vm64x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m128i vindex, __m128i mask, const int scale) + /// VPGATHERQD xmm1, vm64x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, uint* baseAddress, Vector128 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1428,9 +1433,9 @@ public static unsafe Vector128 GatherMaskVector128(Vector128 source, }; } /// - /// __m128i _mm_mask_i64gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) - /// VPGATHERQQ xmm1, vm64x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_mask_i64gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) + /// VPGATHERQQ xmm1, vm64x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, long* baseAddress, Vector128 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1444,9 +1449,9 @@ public static unsafe Vector128 GatherMaskVector128(Vector128 source, }; } /// - /// __m128i _mm_mask_i64gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) - /// VPGATHERQQ xmm1, vm64x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm_mask_i64gather_epi64 (__m128i src, __int64 const* base_addr, __m128i vindex, __m128i mask, const int scale) + /// VPGATHERQQ xmm1, vm64x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, ulong* baseAddress, Vector128 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1460,9 +1465,9 @@ public static unsafe Vector128 GatherMaskVector128(Vector128 sourc }; } /// - /// __m128 _mm_mask_i64gather_ps (__m128 src, float const* base_addr, __m128i vindex, __m128 mask, const int scale) - /// VGATHERQPS xmm1, vm64x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128 _mm_mask_i64gather_ps (__m128 src, float const* base_addr, __m128i vindex, __m128 mask, const int scale) + /// VGATHERQPS xmm1, vm64x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, float* baseAddress, Vector128 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1476,9 +1481,9 @@ public static unsafe Vector128 GatherMaskVector128(Vector128 sourc }; } /// - /// __m128d _mm_mask_i64gather_pd (__m128d src, double const* base_addr, __m128i vindex, __m128d mask, const int scale) - /// VGATHERQPD xmm1, vm64x, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128d _mm_mask_i64gather_pd (__m128d src, double const* base_addr, __m128i vindex, __m128d mask, const int scale) + /// VGATHERQPD xmm1, vm64x, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, double* baseAddress, Vector128 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1492,9 +1497,9 @@ public static unsafe Vector128 GatherMaskVector128(Vector128 sou }; } /// - /// __m256i _mm256_mask_i32gather_epi32 (__m256i src, int const* base_addr, __m256i vindex, __m256i mask, const int scale) - /// VPGATHERDD ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256i _mm256_mask_i32gather_epi32 (__m256i src, int const* base_addr, __m256i vindex, __m256i mask, const int scale) + /// VPGATHERDD ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherMaskVector256(Vector256 source, int* baseAddress, Vector256 index, Vector256 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1508,9 +1513,9 @@ public static unsafe Vector256 GatherMaskVector256(Vector256 source, i }; } /// - /// __m256i _mm256_mask_i32gather_epi32 (__m256i src, int const* base_addr, __m256i vindex, __m256i mask, const int scale) - /// VPGATHERDD ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256i _mm256_mask_i32gather_epi32 (__m256i src, int const* base_addr, __m256i vindex, __m256i mask, const int scale) + /// VPGATHERDD ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherMaskVector256(Vector256 source, uint* baseAddress, Vector256 index, Vector256 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1524,9 +1529,9 @@ public static unsafe Vector256 GatherMaskVector256(Vector256 source, }; } /// - /// __m256i _mm256_mask_i32gather_epi64 (__m256i src, __int64 const* base_addr, __m128i vindex, __m256i mask, const int scale) - /// VPGATHERDQ ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256i _mm256_mask_i32gather_epi64 (__m256i src, __int64 const* base_addr, __m128i vindex, __m256i mask, const int scale) + /// VPGATHERDQ ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherMaskVector256(Vector256 source, long* baseAddress, Vector128 index, Vector256 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1540,9 +1545,9 @@ public static unsafe Vector256 GatherMaskVector256(Vector256 source, }; } /// - /// __m256i _mm256_mask_i32gather_epi64 (__m256i src, __int64 const* base_addr, __m128i vindex, __m256i mask, const int scale) - /// VPGATHERDQ ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256i _mm256_mask_i32gather_epi64 (__m256i src, __int64 const* base_addr, __m128i vindex, __m256i mask, const int scale) + /// VPGATHERDQ ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherMaskVector256(Vector256 source, ulong* baseAddress, Vector128 index, Vector256 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1556,9 +1561,9 @@ public static unsafe Vector256 GatherMaskVector256(Vector256 sourc }; } /// - /// __m256 _mm256_mask_i32gather_ps (__m256 src, float const* base_addr, __m256i vindex, __m256 mask, const int scale) - /// VPGATHERDPS ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256 _mm256_mask_i32gather_ps (__m256 src, float const* base_addr, __m256i vindex, __m256 mask, const int scale) + /// VPGATHERDPS ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherMaskVector256(Vector256 source, float* baseAddress, Vector256 index, Vector256 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1572,9 +1577,9 @@ public static unsafe Vector256 GatherMaskVector256(Vector256 sourc }; } /// - /// __m256d _mm256_mask_i32gather_pd (__m256d src, double const* base_addr, __m128i vindex, __m256d mask, const int scale) - /// VPGATHERDPD ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256d _mm256_mask_i32gather_pd (__m256d src, double const* base_addr, __m128i vindex, __m256d mask, const int scale) + /// VPGATHERDPD ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherMaskVector256(Vector256 source, double* baseAddress, Vector128 index, Vector256 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1588,9 +1593,9 @@ public static unsafe Vector256 GatherMaskVector256(Vector256 sou }; } /// - /// __m128i _mm256_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m256i vindex, __m128i mask, const int scale) - /// VPGATHERQD xmm1, vm32y, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm256_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m256i vindex, __m128i mask, const int scale) + /// VPGATHERQD xmm1, vm32y, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, int* baseAddress, Vector256 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1604,9 +1609,9 @@ public static unsafe Vector128 GatherMaskVector128(Vector128 source, i }; } /// - /// __m128i _mm256_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m256i vindex, __m128i mask, const int scale) - /// VPGATHERQD xmm1, vm32y, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128i _mm256_mask_i64gather_epi32 (__m128i src, int const* base_addr, __m256i vindex, __m128i mask, const int scale) + /// VPGATHERQD xmm1, vm32y, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, uint* baseAddress, Vector256 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1620,9 +1625,9 @@ public static unsafe Vector128 GatherMaskVector128(Vector128 source, }; } /// - /// __m256i _mm256_mask_i64gather_epi64 (__m256i src, __int64 const* base_addr, __m256i vindex, __m256i mask, const int scale) - /// VPGATHERQQ ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256i _mm256_mask_i64gather_epi64 (__m256i src, __int64 const* base_addr, __m256i vindex, __m256i mask, const int scale) + /// VPGATHERQQ ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherMaskVector256(Vector256 source, long* baseAddress, Vector256 index, Vector256 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1636,9 +1641,9 @@ public static unsafe Vector256 GatherMaskVector256(Vector256 source, }; } /// - /// __m256i _mm256_mask_i64gather_epi64 (__m256i src, __int64 const* base_addr, __m256i vindex, __m256i mask, const int scale) - /// VPGATHERQQ ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256i _mm256_mask_i64gather_epi64 (__m256i src, __int64 const* base_addr, __m256i vindex, __m256i mask, const int scale) + /// VPGATHERQQ ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherMaskVector256(Vector256 source, ulong* baseAddress, Vector256 index, Vector256 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1652,9 +1657,9 @@ public static unsafe Vector256 GatherMaskVector256(Vector256 sourc }; } /// - /// __m128 _mm256_mask_i64gather_ps (__m128 src, float const* base_addr, __m256i vindex, __m128 mask, const int scale) - /// VGATHERQPS xmm1, vm32y, xmm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m128 _mm256_mask_i64gather_ps (__m128 src, float const* base_addr, __m256i vindex, __m128 mask, const int scale) + /// VGATHERQPS xmm1, vm32y, xmm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector128 GatherMaskVector128(Vector128 source, float* baseAddress, Vector256 index, Vector128 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1668,9 +1673,9 @@ public static unsafe Vector128 GatherMaskVector128(Vector128 sourc }; } /// - /// __m256d _mm256_mask_i64gather_pd (__m256d src, double const* base_addr, __m256i vindex, __m256d mask, const int scale) - /// VGATHERQPD ymm1, vm32y, ymm2 - /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. + /// __m256d _mm256_mask_i64gather_pd (__m256d src, double const* base_addr, __m256i vindex, __m256d mask, const int scale) + /// VGATHERQPD ymm1, vm32y, ymm2 + /// The scale parameter should be 1, 2, 4 or 8, otherwise, ArgumentOutOfRangeException will be thrown. /// public static unsafe Vector256 GatherMaskVector256(Vector256 source, double* baseAddress, Vector256 index, Vector256 mask, [ConstantExpected(Min = (byte)(1), Max = (byte)(8))] byte scale) { @@ -1685,1190 +1690,1190 @@ public static unsafe Vector256 GatherMaskVector256(Vector256 sou } /// - /// __m256i _mm256_hadd_epi16 (__m256i a, __m256i b) - /// VPHADDW ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_hadd_epi16 (__m256i a, __m256i b) + /// VPHADDW ymm1, ymm2, ymm3/m256 /// public static Vector256 HorizontalAdd(Vector256 left, Vector256 right) => HorizontalAdd(left, right); /// - /// __m256i _mm256_hadd_epi32 (__m256i a, __m256i b) - /// VPHADDD ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_hadd_epi32 (__m256i a, __m256i b) + /// VPHADDD ymm1, ymm2, ymm3/m256 /// public static Vector256 HorizontalAdd(Vector256 left, Vector256 right) => HorizontalAdd(left, right); /// - /// __m256i _mm256_hadds_epi16 (__m256i a, __m256i b) - /// VPHADDSW ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_hadds_epi16 (__m256i a, __m256i b) + /// VPHADDSW ymm1, ymm2, ymm3/m256 /// public static Vector256 HorizontalAddSaturate(Vector256 left, Vector256 right) => HorizontalAddSaturate(left, right); /// - /// __m256i _mm256_hsub_epi16 (__m256i a, __m256i b) - /// VPHSUBW ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_hsub_epi16 (__m256i a, __m256i b) + /// VPHSUBW ymm1, ymm2, ymm3/m256 /// public static Vector256 HorizontalSubtract(Vector256 left, Vector256 right) => HorizontalSubtract(left, right); /// - /// __m256i _mm256_hsub_epi32 (__m256i a, __m256i b) - /// VPHSUBD ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_hsub_epi32 (__m256i a, __m256i b) + /// VPHSUBD ymm1, ymm2, ymm3/m256 /// public static Vector256 HorizontalSubtract(Vector256 left, Vector256 right) => HorizontalSubtract(left, right); /// - /// __m256i _mm256_hsubs_epi16 (__m256i a, __m256i b) - /// VPHSUBSW ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_hsubs_epi16 (__m256i a, __m256i b) + /// VPHSUBSW ymm1, ymm2, ymm3/m256 /// public static Vector256 HorizontalSubtractSaturate(Vector256 left, Vector256 right) => HorizontalSubtractSaturate(left, right); /// - /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) - /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTI32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTI32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static new Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) - /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTI32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTI32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static new Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) - /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTI32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTI32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static new Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) - /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTI32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTI32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static new Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) - /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTI32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTI32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static new Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) - /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTI32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTI32x4 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static new Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) - /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTI64x2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTI64x2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static new Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) - /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 - /// VINSERTI64x2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 + /// __m256i _mm256_inserti128_si256 (__m256i a, __m128i b, const int imm8) + /// VINSERTI128 ymm1, ymm2, xmm3/m128, imm8 + /// VINSERTI64x2 ymm1 {k1}{z}, ymm2, xmm3/m128, imm8 /// public static new Vector256 InsertVector128(Vector256 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) - /// VMOVNTDQA ymm1, m256 + /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) + /// VMOVNTDQA ymm1, m256 /// public static unsafe Vector256 LoadAlignedVector256NonTemporal(sbyte* address) => LoadAlignedVector256NonTemporal(address); /// - /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) - /// VMOVNTDQA ymm1, m256 + /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) + /// VMOVNTDQA ymm1, m256 /// public static unsafe Vector256 LoadAlignedVector256NonTemporal(byte* address) => LoadAlignedVector256NonTemporal(address); /// - /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) - /// VMOVNTDQA ymm1, m256 + /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) + /// VMOVNTDQA ymm1, m256 /// public static unsafe Vector256 LoadAlignedVector256NonTemporal(short* address) => LoadAlignedVector256NonTemporal(address); /// - /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) - /// VMOVNTDQA ymm1, m256 + /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) + /// VMOVNTDQA ymm1, m256 /// public static unsafe Vector256 LoadAlignedVector256NonTemporal(ushort* address) => LoadAlignedVector256NonTemporal(address); /// - /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) - /// VMOVNTDQA ymm1, m256 + /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) + /// VMOVNTDQA ymm1, m256 /// public static unsafe Vector256 LoadAlignedVector256NonTemporal(int* address) => LoadAlignedVector256NonTemporal(address); /// - /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) - /// VMOVNTDQA ymm1, m256 + /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) + /// VMOVNTDQA ymm1, m256 /// public static unsafe Vector256 LoadAlignedVector256NonTemporal(uint* address) => LoadAlignedVector256NonTemporal(address); /// - /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) - /// VMOVNTDQA ymm1, m256 + /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) + /// VMOVNTDQA ymm1, m256 /// public static unsafe Vector256 LoadAlignedVector256NonTemporal(long* address) => LoadAlignedVector256NonTemporal(address); /// - /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) - /// VMOVNTDQA ymm1, m256 + /// __m256i _mm256_stream_load_si256 (__m256i const* mem_addr) + /// VMOVNTDQA ymm1, m256 /// public static unsafe Vector256 LoadAlignedVector256NonTemporal(ulong* address) => LoadAlignedVector256NonTemporal(address); /// - /// __m128i _mm_maskload_epi32 (int const* mem_addr, __m128i mask) - /// VPMASKMOVD xmm1, xmm2, m128 + /// __m128i _mm_maskload_epi32 (int const* mem_addr, __m128i mask) + /// VPMASKMOVD xmm1, xmm2, m128 /// public static unsafe Vector128 MaskLoad(int* address, Vector128 mask) => MaskLoad(address, mask); /// - /// __m128i _mm_maskload_epi32 (int const* mem_addr, __m128i mask) - /// VPMASKMOVD xmm1, xmm2, m128 + /// __m128i _mm_maskload_epi32 (int const* mem_addr, __m128i mask) + /// VPMASKMOVD xmm1, xmm2, m128 /// public static unsafe Vector128 MaskLoad(uint* address, Vector128 mask) => MaskLoad(address, mask); /// - /// __m128i _mm_maskload_epi64 (__int64 const* mem_addr, __m128i mask) - /// VPMASKMOVQ xmm1, xmm2, m128 + /// __m128i _mm_maskload_epi64 (__int64 const* mem_addr, __m128i mask) + /// VPMASKMOVQ xmm1, xmm2, m128 /// public static unsafe Vector128 MaskLoad(long* address, Vector128 mask) => MaskLoad(address, mask); /// - /// __m128i _mm_maskload_epi64 (__int64 const* mem_addr, __m128i mask) - /// VPMASKMOVQ xmm1, xmm2, m128 + /// __m128i _mm_maskload_epi64 (__int64 const* mem_addr, __m128i mask) + /// VPMASKMOVQ xmm1, xmm2, m128 /// public static unsafe Vector128 MaskLoad(ulong* address, Vector128 mask) => MaskLoad(address, mask); /// - /// __m256i _mm256_maskload_epi32 (int const* mem_addr, __m256i mask) - /// VPMASKMOVD ymm1, ymm2, m256 + /// __m256i _mm256_maskload_epi32 (int const* mem_addr, __m256i mask) + /// VPMASKMOVD ymm1, ymm2, m256 /// public static unsafe Vector256 MaskLoad(int* address, Vector256 mask) => MaskLoad(address, mask); /// - /// __m256i _mm256_maskload_epi32 (int const* mem_addr, __m256i mask) - /// VPMASKMOVD ymm1, ymm2, m256 + /// __m256i _mm256_maskload_epi32 (int const* mem_addr, __m256i mask) + /// VPMASKMOVD ymm1, ymm2, m256 /// public static unsafe Vector256 MaskLoad(uint* address, Vector256 mask) => MaskLoad(address, mask); /// - /// __m256i _mm256_maskload_epi64 (__int64 const* mem_addr, __m256i mask) - /// VPMASKMOVQ ymm1, ymm2, m256 + /// __m256i _mm256_maskload_epi64 (__int64 const* mem_addr, __m256i mask) + /// VPMASKMOVQ ymm1, ymm2, m256 /// public static unsafe Vector256 MaskLoad(long* address, Vector256 mask) => MaskLoad(address, mask); /// - /// __m256i _mm256_maskload_epi64 (__int64 const* mem_addr, __m256i mask) - /// VPMASKMOVQ ymm1, ymm2, m256 + /// __m256i _mm256_maskload_epi64 (__int64 const* mem_addr, __m256i mask) + /// VPMASKMOVQ ymm1, ymm2, m256 /// public static unsafe Vector256 MaskLoad(ulong* address, Vector256 mask) => MaskLoad(address, mask); /// - /// void _mm_maskstore_epi32 (int* mem_addr, __m128i mask, __m128i a) - /// VPMASKMOVD m128, xmm1, xmm2 + /// void _mm_maskstore_epi32 (int* mem_addr, __m128i mask, __m128i a) + /// VPMASKMOVD m128, xmm1, xmm2 /// public static unsafe void MaskStore(int* address, Vector128 mask, Vector128 source) => MaskStore(address, mask, source); /// - /// void _mm_maskstore_epi32 (int* mem_addr, __m128i mask, __m128i a) - /// VPMASKMOVD m128, xmm1, xmm2 + /// void _mm_maskstore_epi32 (int* mem_addr, __m128i mask, __m128i a) + /// VPMASKMOVD m128, xmm1, xmm2 /// public static unsafe void MaskStore(uint* address, Vector128 mask, Vector128 source) => MaskStore(address, mask, source); /// - /// void _mm_maskstore_epi64 (__int64* mem_addr, __m128i mask, __m128i a) - /// VPMASKMOVQ m128, xmm1, xmm2 + /// void _mm_maskstore_epi64 (__int64* mem_addr, __m128i mask, __m128i a) + /// VPMASKMOVQ m128, xmm1, xmm2 /// public static unsafe void MaskStore(long* address, Vector128 mask, Vector128 source) => MaskStore(address, mask, source); /// - /// void _mm_maskstore_epi64 (__int64* mem_addr, __m128i mask, __m128i a) - /// VPMASKMOVQ m128, xmm1, xmm2 + /// void _mm_maskstore_epi64 (__int64* mem_addr, __m128i mask, __m128i a) + /// VPMASKMOVQ m128, xmm1, xmm2 /// public static unsafe void MaskStore(ulong* address, Vector128 mask, Vector128 source) => MaskStore(address, mask, source); /// - /// void _mm256_maskstore_epi32 (int* mem_addr, __m256i mask, __m256i a) - /// VPMASKMOVD m256, ymm1, ymm2 + /// void _mm256_maskstore_epi32 (int* mem_addr, __m256i mask, __m256i a) + /// VPMASKMOVD m256, ymm1, ymm2 /// public static unsafe void MaskStore(int* address, Vector256 mask, Vector256 source) => MaskStore(address, mask, source); /// - /// void _mm256_maskstore_epi32 (int* mem_addr, __m256i mask, __m256i a) - /// VPMASKMOVD m256, ymm1, ymm2 + /// void _mm256_maskstore_epi32 (int* mem_addr, __m256i mask, __m256i a) + /// VPMASKMOVD m256, ymm1, ymm2 /// public static unsafe void MaskStore(uint* address, Vector256 mask, Vector256 source) => MaskStore(address, mask, source); /// - /// void _mm256_maskstore_epi64 (__int64* mem_addr, __m256i mask, __m256i a) - /// VPMASKMOVQ m256, ymm1, ymm2 + /// void _mm256_maskstore_epi64 (__int64* mem_addr, __m256i mask, __m256i a) + /// VPMASKMOVQ m256, ymm1, ymm2 /// public static unsafe void MaskStore(long* address, Vector256 mask, Vector256 source) => MaskStore(address, mask, source); /// - /// void _mm256_maskstore_epi64 (__int64* mem_addr, __m256i mask, __m256i a) - /// VPMASKMOVQ m256, ymm1, ymm2 + /// void _mm256_maskstore_epi64 (__int64* mem_addr, __m256i mask, __m256i a) + /// VPMASKMOVQ m256, ymm1, ymm2 /// public static unsafe void MaskStore(ulong* address, Vector256 mask, Vector256 source) => MaskStore(address, mask, source); /// - /// __m256i _mm256_madd_epi16 (__m256i a, __m256i b) - /// VPMADDWD ymm1, ymm2, ymm3/m256 - /// VPMADDWD ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_madd_epi16 (__m256i a, __m256i b) + /// VPMADDWD ymm1, ymm2, ymm3/m256 + /// VPMADDWD ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 MultiplyAddAdjacent(Vector256 left, Vector256 right) => MultiplyAddAdjacent(left, right); /// - /// __m256i _mm256_maddubs_epi16 (__m256i a, __m256i b) - /// VPMADDUBSW ymm1, ymm2, ymm3/m256 - /// VPMADDUBSW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_maddubs_epi16 (__m256i a, __m256i b) + /// VPMADDUBSW ymm1, ymm2, ymm3/m256 + /// VPMADDUBSW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 MultiplyAddAdjacent(Vector256 left, Vector256 right) => MultiplyAddAdjacent(left, right); /// - /// __m256i _mm256_max_epi8 (__m256i a, __m256i b) - /// VPMAXSB ymm1, ymm2, ymm3/m256 - /// VPMAXSB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_max_epi8 (__m256i a, __m256i b) + /// VPMAXSB ymm1, ymm2, ymm3/m256 + /// VPMAXSB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Max(Vector256 left, Vector256 right) => Max(left, right); /// - /// __m256i _mm256_max_epu8 (__m256i a, __m256i b) - /// VPMAXUB ymm1, ymm2, ymm3/m256 - /// VPMAXUB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_max_epu8 (__m256i a, __m256i b) + /// VPMAXUB ymm1, ymm2, ymm3/m256 + /// VPMAXUB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Max(Vector256 left, Vector256 right) => Max(left, right); /// - /// __m256i _mm256_max_epi16 (__m256i a, __m256i b) - /// VPMAXSW ymm1, ymm2, ymm3/m256 - /// VPMAXSW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_max_epi16 (__m256i a, __m256i b) + /// VPMAXSW ymm1, ymm2, ymm3/m256 + /// VPMAXSW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Max(Vector256 left, Vector256 right) => Max(left, right); /// - /// __m256i _mm256_max_epu16 (__m256i a, __m256i b) - /// VPMAXUW ymm1, ymm2, ymm3/m256 - /// VPMAXUW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_max_epu16 (__m256i a, __m256i b) + /// VPMAXUW ymm1, ymm2, ymm3/m256 + /// VPMAXUW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Max(Vector256 left, Vector256 right) => Max(left, right); /// - /// __m256i _mm256_max_epi32 (__m256i a, __m256i b) - /// VPMAXSD ymm1, ymm2, ymm3/m256 - /// VPMAXSD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_max_epi32 (__m256i a, __m256i b) + /// VPMAXSD ymm1, ymm2, ymm3/m256 + /// VPMAXSD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Max(Vector256 left, Vector256 right) => Max(left, right); /// - /// __m256i _mm256_max_epu32 (__m256i a, __m256i b) - /// VPMAXUD ymm1, ymm2, ymm3/m256 - /// VPMAXUD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_max_epu32 (__m256i a, __m256i b) + /// VPMAXUD ymm1, ymm2, ymm3/m256 + /// VPMAXUD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Max(Vector256 left, Vector256 right) => Max(left, right); /// - /// __m256i _mm256_min_epi8 (__m256i a, __m256i b) - /// VPMINSB ymm1, ymm2, ymm3/m256 - /// VPMINSB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_min_epi8 (__m256i a, __m256i b) + /// VPMINSB ymm1, ymm2, ymm3/m256 + /// VPMINSB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Min(Vector256 left, Vector256 right) => Min(left, right); /// - /// __m256i _mm256_min_epu8 (__m256i a, __m256i b) - /// VPMINUB ymm1, ymm2, ymm3/m256 - /// VPMINUB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_min_epu8 (__m256i a, __m256i b) + /// VPMINUB ymm1, ymm2, ymm3/m256 + /// VPMINUB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Min(Vector256 left, Vector256 right) => Min(left, right); /// - /// __m256i _mm256_min_epi16 (__m256i a, __m256i b) - /// VPMINSW ymm1, ymm2, ymm3/m256 - /// VPMINSW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_min_epi16 (__m256i a, __m256i b) + /// VPMINSW ymm1, ymm2, ymm3/m256 + /// VPMINSW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Min(Vector256 left, Vector256 right) => Min(left, right); /// - /// __m256i _mm256_min_epu16 (__m256i a, __m256i b) - /// VPMINUW ymm1, ymm2, ymm3/m256 - /// VPMINUW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_min_epu16 (__m256i a, __m256i b) + /// VPMINUW ymm1, ymm2, ymm3/m256 + /// VPMINUW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Min(Vector256 left, Vector256 right) => Min(left, right); /// - /// __m256i _mm256_min_epi32 (__m256i a, __m256i b) - /// VPMINSD ymm1, ymm2, ymm3/m256 - /// VPMINSD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_min_epi32 (__m256i a, __m256i b) + /// VPMINSD ymm1, ymm2, ymm3/m256 + /// VPMINSD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Min(Vector256 left, Vector256 right) => Min(left, right); /// - /// __m256i _mm256_min_epu32 (__m256i a, __m256i b) - /// VPMINUD ymm1, ymm2, ymm3/m256 - /// VPMINUD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_min_epu32 (__m256i a, __m256i b) + /// VPMINUD ymm1, ymm2, ymm3/m256 + /// VPMINUD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Min(Vector256 left, Vector256 right) => Min(left, right); /// - /// int _mm256_movemask_epi8 (__m256i a) - /// VPMOVMSKB r32, ymm1 + /// int _mm256_movemask_epi8 (__m256i a) + /// VPMOVMSKB r32, ymm1 /// public static int MoveMask(Vector256 value) => MoveMask(value); /// - /// int _mm256_movemask_epi8 (__m256i a) - /// VPMOVMSKB r32, ymm1 + /// int _mm256_movemask_epi8 (__m256i a) + /// VPMOVMSKB r32, ymm1 /// public static int MoveMask(Vector256 value) => MoveMask(value); /// - /// __m256i _mm256_mpsadbw_epu8 (__m256i a, __m256i b, const int imm8) - /// VMPSADBW ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_mpsadbw_epu8 (__m256i a, __m256i b, const int imm8) + /// VMPSADBW ymm1, ymm2, ymm3/m256, imm8 /// public static Vector256 MultipleSumAbsoluteDifferences(Vector256 left, Vector256 right, [ConstantExpected] byte mask) => MultipleSumAbsoluteDifferences(left, right, mask); /// - /// __m256i _mm256_mul_epi32 (__m256i a, __m256i b) - /// VPMULDQ ymm1, ymm2, ymm3/m256 - /// VPMULDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_mul_epi32 (__m256i a, __m256i b) + /// VPMULDQ ymm1, ymm2, ymm3/m256 + /// VPMULDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Multiply(Vector256 left, Vector256 right) => Multiply(left, right); /// - /// __m256i _mm256_mul_epu32 (__m256i a, __m256i b) - /// VPMULUDQ ymm1, ymm2, ymm3/m256 - /// VPMULUDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_mul_epu32 (__m256i a, __m256i b) + /// VPMULUDQ ymm1, ymm2, ymm3/m256 + /// VPMULUDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Multiply(Vector256 left, Vector256 right) => Multiply(left, right); /// - /// __m256i _mm256_mulhi_epi16 (__m256i a, __m256i b) - /// VPMULHW ymm1, ymm2, ymm3/m256 - /// VPMULHW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_mulhi_epi16 (__m256i a, __m256i b) + /// VPMULHW ymm1, ymm2, ymm3/m256 + /// VPMULHW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 MultiplyHigh(Vector256 left, Vector256 right) => MultiplyHigh(left, right); /// - /// __m256i _mm256_mulhi_epu16 (__m256i a, __m256i b) - /// VPMULHUW ymm1, ymm2, ymm3/m256 - /// VPMULHUW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_mulhi_epu16 (__m256i a, __m256i b) + /// VPMULHUW ymm1, ymm2, ymm3/m256 + /// VPMULHUW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 MultiplyHigh(Vector256 left, Vector256 right) => MultiplyHigh(left, right); /// - /// __m256i _mm256_mulhrs_epi16 (__m256i a, __m256i b) - /// VPMULHRSW ymm1, ymm2, ymm3/m256 - /// VPMULHRSW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_mulhrs_epi16 (__m256i a, __m256i b) + /// VPMULHRSW ymm1, ymm2, ymm3/m256 + /// VPMULHRSW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 MultiplyHighRoundScale(Vector256 left, Vector256 right) => MultiplyHighRoundScale(left, right); /// - /// __m256i _mm256_mullo_epi16 (__m256i a, __m256i b) - /// VPMULLW ymm1, ymm2, ymm3/m256 - /// VPMULLW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_mullo_epi16 (__m256i a, __m256i b) + /// VPMULLW ymm1, ymm2, ymm3/m256 + /// VPMULLW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 MultiplyLow(Vector256 left, Vector256 right) => MultiplyLow(left, right); /// - /// __m256i _mm256_mullo_epi16 (__m256i a, __m256i b) - /// VPMULLW ymm1, ymm2, ymm3/m256 - /// VPMULLW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_mullo_epi16 (__m256i a, __m256i b) + /// VPMULLW ymm1, ymm2, ymm3/m256 + /// VPMULLW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 MultiplyLow(Vector256 left, Vector256 right) => MultiplyLow(left, right); /// - /// __m256i _mm256_mullo_epi32 (__m256i a, __m256i b) - /// VPMULLD ymm1, ymm2, ymm3/m256 - /// VPMULLD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_mullo_epi32 (__m256i a, __m256i b) + /// VPMULLD ymm1, ymm2, ymm3/m256 + /// VPMULLD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 MultiplyLow(Vector256 left, Vector256 right) => MultiplyLow(left, right); /// - /// __m256i _mm256_mullo_epi32 (__m256i a, __m256i b) - /// VPMULLD ymm1, ymm2, ymm3/m256 - /// VPMULLD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_mullo_epi32 (__m256i a, __m256i b) + /// VPMULLD ymm1, ymm2, ymm3/m256 + /// VPMULLD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 MultiplyLow(Vector256 left, Vector256 right) => MultiplyLow(left, right); /// - /// __m256i _mm256_or_si256 (__m256i a, __m256i b) - /// VPOR ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_or_si256 (__m256i a, __m256i b) + /// VPOR ymm1, ymm2, ymm3/m256 /// public static Vector256 Or(Vector256 left, Vector256 right) => Or(left, right); /// - /// __m256i _mm256_or_si256 (__m256i a, __m256i b) - /// VPOR ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_or_si256 (__m256i a, __m256i b) + /// VPOR ymm1, ymm2, ymm3/m256 /// public static Vector256 Or(Vector256 left, Vector256 right) => Or(left, right); /// - /// __m256i _mm256_or_si256 (__m256i a, __m256i b) - /// VPOR ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_or_si256 (__m256i a, __m256i b) + /// VPOR ymm1, ymm2, ymm3/m256 /// public static Vector256 Or(Vector256 left, Vector256 right) => Or(left, right); /// - /// __m256i _mm256_or_si256 (__m256i a, __m256i b) - /// VPOR ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_or_si256 (__m256i a, __m256i b) + /// VPOR ymm1, ymm2, ymm3/m256 /// public static Vector256 Or(Vector256 left, Vector256 right) => Or(left, right); /// - /// __m256i _mm256_or_si256 (__m256i a, __m256i b) - /// VPOR ymm1, ymm2, ymm3/m256 - /// VPORD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_or_si256 (__m256i a, __m256i b) + /// VPOR ymm1, ymm2, ymm3/m256 + /// VPORD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Or(Vector256 left, Vector256 right) => Or(left, right); /// - /// __m256i _mm256_or_si256 (__m256i a, __m256i b) - /// VPOR ymm1, ymm2, ymm3/m256 - /// VPORD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_or_si256 (__m256i a, __m256i b) + /// VPOR ymm1, ymm2, ymm3/m256 + /// VPORD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Or(Vector256 left, Vector256 right) => Or(left, right); /// - /// __m256i _mm256_or_si256 (__m256i a, __m256i b) - /// VPOR ymm1, ymm2, ymm3/m256 - /// VPORQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_or_si256 (__m256i a, __m256i b) + /// VPOR ymm1, ymm2, ymm3/m256 + /// VPORQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Or(Vector256 left, Vector256 right) => Or(left, right); /// - /// __m256i _mm256_or_si256 (__m256i a, __m256i b) - /// VPOR ymm1, ymm2, ymm3/m256 - /// VPORQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_or_si256 (__m256i a, __m256i b) + /// VPOR ymm1, ymm2, ymm3/m256 + /// VPORQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Or(Vector256 left, Vector256 right) => Or(left, right); /// - /// __m256i _mm256_packs_epi16 (__m256i a, __m256i b) - /// VPACKSSWB ymm1, ymm2, ymm3/m256 - /// VPACKSSWB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_packs_epi16 (__m256i a, __m256i b) + /// VPACKSSWB ymm1, ymm2, ymm3/m256 + /// VPACKSSWB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PackSignedSaturate(Vector256 left, Vector256 right) => PackSignedSaturate(left, right); /// - /// __m256i _mm256_packs_epi32 (__m256i a, __m256i b) - /// VPACKSSDW ymm1, ymm2, ymm3/m256 - /// VPACKSSDW ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_packs_epi32 (__m256i a, __m256i b) + /// VPACKSSDW ymm1, ymm2, ymm3/m256 + /// VPACKSSDW ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 PackSignedSaturate(Vector256 left, Vector256 right) => PackSignedSaturate(left, right); /// - /// __m256i _mm256_packus_epi16 (__m256i a, __m256i b) - /// VPACKUSWB ymm1, ymm2, ymm3/m256 - /// VPACKUSWB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_packus_epi16 (__m256i a, __m256i b) + /// VPACKUSWB ymm1, ymm2, ymm3/m256 + /// VPACKUSWB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PackUnsignedSaturate(Vector256 left, Vector256 right) => PackUnsignedSaturate(left, right); /// - /// __m256i _mm256_packus_epi32 (__m256i a, __m256i b) - /// VPACKUSDW ymm1, ymm2, ymm3/m256 - /// VPACKUSDW ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_packus_epi32 (__m256i a, __m256i b) + /// VPACKUSDW ymm1, ymm2, ymm3/m256 + /// VPACKUSDW ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 PackUnsignedSaturate(Vector256 left, Vector256 right) => PackUnsignedSaturate(left, right); /// - /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) - /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) + /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 /// public static new Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Permute2x128(left, right, control); /// - /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) - /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) + /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 /// public static new Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Permute2x128(left, right, control); /// - /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) - /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) + /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 /// public static new Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Permute2x128(left, right, control); /// - /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) - /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) + /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 /// public static new Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Permute2x128(left, right, control); /// - /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) - /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) + /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 /// public static new Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Permute2x128(left, right, control); /// - /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) - /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) + /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 /// public static new Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Permute2x128(left, right, control); /// - /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) - /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) + /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 /// public static new Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Permute2x128(left, right, control); /// - /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) - /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 + /// __m256i _mm256_permute2x128_si256 (__m256i a, __m256i b, const int imm8) + /// VPERM2I128 ymm1, ymm2, ymm3/m256, imm8 /// public static new Vector256 Permute2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Permute2x128(left, right, control); /// - /// __m256i _mm256_permute4x64_epi64 (__m256i a, const int imm8) - /// VPERMQ ymm1, ymm2/m256, imm8 - /// VPERMQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256i _mm256_permute4x64_epi64 (__m256i a, const int imm8) + /// VPERMQ ymm1, ymm2/m256, imm8 + /// VPERMQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 Permute4x64(Vector256 value, [ConstantExpected] byte control) => Permute4x64(value, control); /// - /// __m256i _mm256_permute4x64_epi64 (__m256i a, const int imm8) - /// VPERMQ ymm1, ymm2/m256, imm8 - /// VPERMQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256i _mm256_permute4x64_epi64 (__m256i a, const int imm8) + /// VPERMQ ymm1, ymm2/m256, imm8 + /// VPERMQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 Permute4x64(Vector256 value, [ConstantExpected] byte control) => Permute4x64(value, control); /// - /// __m256d _mm256_permute4x64_pd (__m256d a, const int imm8) - /// VPERMPD ymm1, ymm2/m256, imm8 - /// VPERMPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256d _mm256_permute4x64_pd (__m256d a, const int imm8) + /// VPERMPD ymm1, ymm2/m256, imm8 + /// VPERMPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 Permute4x64(Vector256 value, [ConstantExpected] byte control) => Permute4x64(value, control); /// - /// __m256i _mm256_permutevar8x32_epi32 (__m256i a, __m256i idx) - /// VPERMD ymm1, ymm2/m256, imm8 - /// VPERMD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256i _mm256_permutevar8x32_epi32 (__m256i a, __m256i idx) + /// VPERMD ymm1, ymm2/m256, imm8 + /// VPERMD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 PermuteVar8x32(Vector256 left, Vector256 control) => PermuteVar8x32(left, control); /// - /// __m256i _mm256_permutevar8x32_epi32 (__m256i a, __m256i idx) - /// VPERMD ymm1, ymm2/m256, imm8 - /// VPERMD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256i _mm256_permutevar8x32_epi32 (__m256i a, __m256i idx) + /// VPERMD ymm1, ymm2/m256, imm8 + /// VPERMD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 PermuteVar8x32(Vector256 left, Vector256 control) => PermuteVar8x32(left, control); /// - /// __m256 _mm256_permutevar8x32_ps (__m256 a, __m256i idx) - /// VPERMPS ymm1, ymm2/m256, imm8 - /// VPERMPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256 _mm256_permutevar8x32_ps (__m256 a, __m256i idx) + /// VPERMPS ymm1, ymm2/m256, imm8 + /// VPERMPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 PermuteVar8x32(Vector256 left, Vector256 control) => PermuteVar8x32(left, control); /// - /// __m256i _mm256_sll_epi16 (__m256i a, __m128i count) - /// VPSLLW ymm1, ymm2, xmm3/m128 - /// VPSLLW ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_sll_epi16 (__m256i a, __m128i count) + /// VPSLLW ymm1, ymm2, xmm3/m128 + /// VPSLLW ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftLeftLogical(Vector256 value, Vector128 count) => ShiftLeftLogical(value, count); /// - /// __m256i _mm256_sll_epi16 (__m256i a, __m128i count) - /// VPSLLW ymm1, ymm2, xmm3/m128 - /// VPSLLW ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_sll_epi16 (__m256i a, __m128i count) + /// VPSLLW ymm1, ymm2, xmm3/m128 + /// VPSLLW ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftLeftLogical(Vector256 value, Vector128 count) => ShiftLeftLogical(value, count); /// - /// __m256i _mm256_sll_epi32 (__m256i a, __m128i count) - /// VPSLLD ymm1, ymm2, xmm3/m128 - /// VPSLLD ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_sll_epi32 (__m256i a, __m128i count) + /// VPSLLD ymm1, ymm2, xmm3/m128 + /// VPSLLD ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftLeftLogical(Vector256 value, Vector128 count) => ShiftLeftLogical(value, count); /// - /// __m256i _mm256_sll_epi32 (__m256i a, __m128i count) - /// VPSLLD ymm1, ymm2, xmm3/m128 - /// VPSLLD ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_sll_epi32 (__m256i a, __m128i count) + /// VPSLLD ymm1, ymm2, xmm3/m128 + /// VPSLLD ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftLeftLogical(Vector256 value, Vector128 count) => ShiftLeftLogical(value, count); /// - /// __m256i _mm256_sll_epi64 (__m256i a, __m128i count) - /// VPSLLQ ymm1, ymm2, xmm3/m128 - /// VPSLLQ ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_sll_epi64 (__m256i a, __m128i count) + /// VPSLLQ ymm1, ymm2, xmm3/m128 + /// VPSLLQ ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftLeftLogical(Vector256 value, Vector128 count) => ShiftLeftLogical(value, count); /// - /// __m256i _mm256_sll_epi64 (__m256i a, __m128i count) - /// VPSLLQ ymm1, ymm2, xmm3/m128 - /// VPSLLQ ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_sll_epi64 (__m256i a, __m128i count) + /// VPSLLQ ymm1, ymm2, xmm3/m128 + /// VPSLLQ ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftLeftLogical(Vector256 value, Vector128 count) => ShiftLeftLogical(value, count); /// - /// __m256i _mm256_slli_epi16 (__m256i a, int imm8) - /// VPSLLW ymm1, ymm2, imm8 - /// VPSLLW ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_slli_epi16 (__m256i a, int imm8) + /// VPSLLW ymm1, ymm2, imm8 + /// VPSLLW ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftLeftLogical(Vector256 value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); /// - /// __m256i _mm256_slli_epi16 (__m256i a, int imm8) - /// VPSLLW ymm1, ymm2, imm8 - /// VPSLLW ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_slli_epi16 (__m256i a, int imm8) + /// VPSLLW ymm1, ymm2, imm8 + /// VPSLLW ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftLeftLogical(Vector256 value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); /// - /// __m256i _mm256_slli_epi32 (__m256i a, int imm8) - /// VPSLLD ymm1, ymm2, imm8 - /// VPSLLD ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_slli_epi32 (__m256i a, int imm8) + /// VPSLLD ymm1, ymm2, imm8 + /// VPSLLD ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftLeftLogical(Vector256 value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); /// - /// __m256i _mm256_slli_epi32 (__m256i a, int imm8) - /// VPSLLD ymm1, ymm2, imm8 - /// VPSLLD ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_slli_epi32 (__m256i a, int imm8) + /// VPSLLD ymm1, ymm2, imm8 + /// VPSLLD ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftLeftLogical(Vector256 value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); /// - /// __m256i _mm256_slli_epi64 (__m256i a, int imm8) - /// VPSLLQ ymm1, ymm2, imm8 - /// VPSLLQ ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_slli_epi64 (__m256i a, int imm8) + /// VPSLLQ ymm1, ymm2, imm8 + /// VPSLLQ ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftLeftLogical(Vector256 value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); /// - /// __m256i _mm256_slli_epi64 (__m256i a, int imm8) - /// VPSLLQ ymm1, ymm2, imm8 - /// VPSLLQ ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_slli_epi64 (__m256i a, int imm8) + /// VPSLLQ ymm1, ymm2, imm8 + /// VPSLLQ ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftLeftLogical(Vector256 value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); /// - /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) - /// VPSLLDQ ymm1, ymm2/m256, imm8 + /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) + /// VPSLLDQ ymm1, ymm2/m256, imm8 /// public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// - /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) - /// VPSLLDQ ymm1, ymm2/m256, imm8 + /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) + /// VPSLLDQ ymm1, ymm2/m256, imm8 /// public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// - /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) - /// VPSLLDQ ymm1, ymm2/m256, imm8 - /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) + /// VPSLLDQ ymm1, ymm2/m256, imm8 + /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. /// public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// - /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) - /// VPSLLDQ ymm1, ymm2/m256, imm8 - /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) + /// VPSLLDQ ymm1, ymm2/m256, imm8 + /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. /// public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// - /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) - /// VPSLLDQ ymm1, ymm2/m256, imm8 - /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) + /// VPSLLDQ ymm1, ymm2/m256, imm8 + /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. /// public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// - /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) - /// VPSLLDQ ymm1, ymm2/m256, imm8 - /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) + /// VPSLLDQ ymm1, ymm2/m256, imm8 + /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. /// public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// - /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) - /// VPSLLDQ ymm1, ymm2/m256, imm8 - /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) + /// VPSLLDQ ymm1, ymm2/m256, imm8 + /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. /// public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// - /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) - /// VPSLLDQ ymm1, ymm2/m256, imm8 - /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_bslli_epi128 (__m256i a, const int imm8) + /// VPSLLDQ ymm1, ymm2/m256, imm8 + /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. /// public static Vector256 ShiftLeftLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// - /// __m128i _mm_sllv_epi32 (__m128i a, __m128i count) - /// VPSLLVD xmm1, xmm2, xmm3/m128 - /// VPSLLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_sllv_epi32 (__m128i a, __m128i count) + /// VPSLLVD xmm1, xmm2, xmm3/m128 + /// VPSLLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 ShiftLeftLogicalVariable(Vector128 value, Vector128 count) => ShiftLeftLogicalVariable(value, count); /// - /// __m128i _mm_sllv_epi32 (__m128i a, __m128i count) - /// VPSLLVD xmm1, xmm2, xmm3/m128 - /// VPSLLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_sllv_epi32 (__m128i a, __m128i count) + /// VPSLLVD xmm1, xmm2, xmm3/m128 + /// VPSLLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 ShiftLeftLogicalVariable(Vector128 value, Vector128 count) => ShiftLeftLogicalVariable(value, count); /// - /// __m128i _mm_sllv_epi64 (__m128i a, __m128i count) - /// VPSLLVQ xmm1, xmm2, xmm3/m128 - /// VPSLLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_sllv_epi64 (__m128i a, __m128i count) + /// VPSLLVQ xmm1, xmm2, xmm3/m128 + /// VPSLLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 ShiftLeftLogicalVariable(Vector128 value, Vector128 count) => ShiftLeftLogicalVariable(value, count); /// - /// __m128i _mm_sllv_epi64 (__m128i a, __m128i count) - /// VPSLLVQ xmm1, xmm2, xmm3/m128 - /// VPSLLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_sllv_epi64 (__m128i a, __m128i count) + /// VPSLLVQ xmm1, xmm2, xmm3/m128 + /// VPSLLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 ShiftLeftLogicalVariable(Vector128 value, Vector128 count) => ShiftLeftLogicalVariable(value, count); /// - /// __m256i _mm256_sllv_epi32 (__m256i a, __m256i count) - /// VPSLLVD ymm1, ymm2, ymm3/m256 - /// VPSLLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_sllv_epi32 (__m256i a, __m256i count) + /// VPSLLVD ymm1, ymm2, ymm3/m256 + /// VPSLLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) => ShiftLeftLogicalVariable(value, count); /// - /// __m256i _mm256_sllv_epi32 (__m256i a, __m256i count) - /// VPSLLVD ymm1, ymm2, ymm3/m256 - /// VPSLLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_sllv_epi32 (__m256i a, __m256i count) + /// VPSLLVD ymm1, ymm2, ymm3/m256 + /// VPSLLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) => ShiftLeftLogicalVariable(value, count); /// - /// __m256i _mm256_sllv_epi64 (__m256i a, __m256i count) - /// VPSLLVQ ymm1, ymm2, ymm3/m256 - /// VPSLLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_sllv_epi64 (__m256i a, __m256i count) + /// VPSLLVQ ymm1, ymm2, ymm3/m256 + /// VPSLLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) => ShiftLeftLogicalVariable(value, count); /// - /// __m256i _mm256_sllv_epi64 (__m256i a, __m256i count) - /// VPSLLVQ ymm1, ymm2, ymm3/m256 - /// VPSLLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_sllv_epi64 (__m256i a, __m256i count) + /// VPSLLVQ ymm1, ymm2, ymm3/m256 + /// VPSLLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) => ShiftLeftLogicalVariable(value, count); /// - /// _mm256_sra_epi16 (__m256i a, __m128i count) - /// VPSRAW ymm1, ymm2, xmm3/m128 - /// VPSRAW ymm1 {k1}{z}, ymm2, xmm3/m128 + /// _mm256_sra_epi16 (__m256i a, __m128i count) + /// VPSRAW ymm1, ymm2, xmm3/m128 + /// VPSRAW ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftRightArithmetic(Vector256 value, Vector128 count) => ShiftRightArithmetic(value, count); /// - /// _mm256_sra_epi32 (__m256i a, __m128i count) - /// VPSRAD ymm1, ymm2, xmm3/m128 - /// VPSRAD ymm1 {k1}{z}, ymm2, xmm3/m128 + /// _mm256_sra_epi32 (__m256i a, __m128i count) + /// VPSRAD ymm1, ymm2, xmm3/m128 + /// VPSRAD ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftRightArithmetic(Vector256 value, Vector128 count) => ShiftRightArithmetic(value, count); /// - /// __m256i _mm256_srai_epi16 (__m256i a, int imm8) - /// VPSRAW ymm1, ymm2, imm8 - /// VPSRAW ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_srai_epi16 (__m256i a, int imm8) + /// VPSRAW ymm1, ymm2, imm8 + /// VPSRAW ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftRightArithmetic(Vector256 value, [ConstantExpected] byte count) => ShiftRightArithmetic(value, count); /// - /// __m256i _mm256_srai_epi32 (__m256i a, int imm8) - /// VPSRAD ymm1, ymm2, imm8 - /// VPSRAD ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_srai_epi32 (__m256i a, int imm8) + /// VPSRAD ymm1, ymm2, imm8 + /// VPSRAD ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftRightArithmetic(Vector256 value, [ConstantExpected] byte count) => ShiftRightArithmetic(value, count); /// - /// __m128i _mm_srav_epi32 (__m128i a, __m128i count) - /// VPSRAVD xmm1, xmm2, xmm3/m128 - /// VPSRAVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_srav_epi32 (__m128i a, __m128i count) + /// VPSRAVD xmm1, xmm2, xmm3/m128 + /// VPSRAVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 ShiftRightArithmeticVariable(Vector128 value, Vector128 count) => ShiftRightArithmeticVariable(value, count); /// - /// __m256i _mm256_srav_epi32 (__m256i a, __m256i count) - /// VPSRAVD ymm1, ymm2, ymm3/m256 - /// VPSRAVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_srav_epi32 (__m256i a, __m256i count) + /// VPSRAVD ymm1, ymm2, ymm3/m256 + /// VPSRAVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 ShiftRightArithmeticVariable(Vector256 value, Vector256 count) => ShiftRightArithmeticVariable(value, count); /// - /// __m256i _mm256_srl_epi16 (__m256i a, __m128i count) - /// VPSRLW ymm1, ymm2, xmm3/m128 - /// VPSRLW ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_srl_epi16 (__m256i a, __m128i count) + /// VPSRLW ymm1, ymm2, xmm3/m128 + /// VPSRLW ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftRightLogical(Vector256 value, Vector128 count) => ShiftRightLogical(value, count); /// - /// __m256i _mm256_srl_epi16 (__m256i a, __m128i count) - /// VPSRLW ymm1, ymm2, xmm3/m128 - /// VPSRLW ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_srl_epi16 (__m256i a, __m128i count) + /// VPSRLW ymm1, ymm2, xmm3/m128 + /// VPSRLW ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftRightLogical(Vector256 value, Vector128 count) => ShiftRightLogical(value, count); /// - /// __m256i _mm256_srl_epi32 (__m256i a, __m128i count) - /// VPSRLD ymm1, ymm2, xmm3/m128 - /// VPSRLD ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_srl_epi32 (__m256i a, __m128i count) + /// VPSRLD ymm1, ymm2, xmm3/m128 + /// VPSRLD ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftRightLogical(Vector256 value, Vector128 count) => ShiftRightLogical(value, count); /// - /// __m256i _mm256_srl_epi32 (__m256i a, __m128i count) - /// VPSRLD ymm1, ymm2, xmm3/m128 - /// VPSRLD ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_srl_epi32 (__m256i a, __m128i count) + /// VPSRLD ymm1, ymm2, xmm3/m128 + /// VPSRLD ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftRightLogical(Vector256 value, Vector128 count) => ShiftRightLogical(value, count); /// - /// __m256i _mm256_srl_epi64 (__m256i a, __m128i count) - /// VPSRLQ ymm1, ymm2, xmm3/m128 - /// VPSRLQ ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_srl_epi64 (__m256i a, __m128i count) + /// VPSRLQ ymm1, ymm2, xmm3/m128 + /// VPSRLQ ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftRightLogical(Vector256 value, Vector128 count) => ShiftRightLogical(value, count); /// - /// __m256i _mm256_srl_epi64 (__m256i a, __m128i count) - /// VPSRLQ ymm1, ymm2, xmm3/m128 - /// VPSRLQ ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_srl_epi64 (__m256i a, __m128i count) + /// VPSRLQ ymm1, ymm2, xmm3/m128 + /// VPSRLQ ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftRightLogical(Vector256 value, Vector128 count) => ShiftRightLogical(value, count); /// - /// __m256i _mm256_srli_epi16 (__m256i a, int imm8) - /// VPSRLW ymm1, ymm2, imm8 - /// VPSRLW ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_srli_epi16 (__m256i a, int imm8) + /// VPSRLW ymm1, ymm2, imm8 + /// VPSRLW ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftRightLogical(Vector256 value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); /// - /// __m256i _mm256_srli_epi16 (__m256i a, int imm8) - /// VPSRLW ymm1, ymm2, imm8 - /// VPSRLW ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_srli_epi16 (__m256i a, int imm8) + /// VPSRLW ymm1, ymm2, imm8 + /// VPSRLW ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftRightLogical(Vector256 value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); /// - /// __m256i _mm256_srli_epi32 (__m256i a, int imm8) - /// VPSRLD ymm1, ymm2, imm8 - /// VPSRLD ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_srli_epi32 (__m256i a, int imm8) + /// VPSRLD ymm1, ymm2, imm8 + /// VPSRLD ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftRightLogical(Vector256 value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); /// - /// __m256i _mm256_srli_epi32 (__m256i a, int imm8) - /// VPSRLD ymm1, ymm2, imm8 - /// VPSRLD ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_srli_epi32 (__m256i a, int imm8) + /// VPSRLD ymm1, ymm2, imm8 + /// VPSRLD ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftRightLogical(Vector256 value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); /// - /// __m256i _mm256_srli_epi64 (__m256i a, int imm8) - /// VPSRLQ ymm1, ymm2, imm8 - /// VPSRLQ ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_srli_epi64 (__m256i a, int imm8) + /// VPSRLQ ymm1, ymm2, imm8 + /// VPSRLQ ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftRightLogical(Vector256 value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); /// - /// __m256i _mm256_srli_epi64 (__m256i a, int imm8) - /// VPSRLQ ymm1, ymm2, imm8 - /// VPSRLQ ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_srli_epi64 (__m256i a, int imm8) + /// VPSRLQ ymm1, ymm2, imm8 + /// VPSRLQ ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftRightLogical(Vector256 value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); /// - /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) - /// VPSRLDQ ymm1, ymm2/m128, imm8 + /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) + /// VPSRLDQ ymm1, ymm2/m128, imm8 /// public static Vector256 ShiftRightLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// - /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) - /// VPSRLDQ ymm1, ymm2/m128, imm8 + /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) + /// VPSRLDQ ymm1, ymm2/m128, imm8 /// public static Vector256 ShiftRightLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// - /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) - /// VPSRLDQ ymm1, ymm2/m128, imm8 - /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) + /// VPSRLDQ ymm1, ymm2/m128, imm8 + /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. /// public static Vector256 ShiftRightLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// - /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) - /// VPSRLDQ ymm1, ymm2/m128, imm8 - /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) + /// VPSRLDQ ymm1, ymm2/m128, imm8 + /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. /// public static Vector256 ShiftRightLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// - /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) - /// VPSRLDQ ymm1, ymm2/m128, imm8 - /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) + /// VPSRLDQ ymm1, ymm2/m128, imm8 + /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. /// public static Vector256 ShiftRightLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// - /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) - /// VPSRLDQ ymm1, ymm2/m128, imm8 - /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) + /// VPSRLDQ ymm1, ymm2/m128, imm8 + /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. /// public static Vector256 ShiftRightLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// - /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) - /// VPSRLDQ ymm1, ymm2/m128, imm8 - /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) + /// VPSRLDQ ymm1, ymm2/m128, imm8 + /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. /// public static Vector256 ShiftRightLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// - /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) - /// VPSRLDQ ymm1, ymm2/m128, imm8 - /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. + /// __m256i _mm256_bsrli_epi128 (__m256i a, const int imm8) + /// VPSRLDQ ymm1, ymm2/m128, imm8 + /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. /// public static Vector256 ShiftRightLogical128BitLane(Vector256 value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// - /// __m128i _mm_srlv_epi32 (__m128i a, __m128i count) - /// VPSRLVD xmm1, xmm2, xmm3/m128 - /// VPSRLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_srlv_epi32 (__m128i a, __m128i count) + /// VPSRLVD xmm1, xmm2, xmm3/m128 + /// VPSRLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 ShiftRightLogicalVariable(Vector128 value, Vector128 count) => ShiftRightLogicalVariable(value, count); /// - /// __m128i _mm_srlv_epi32 (__m128i a, __m128i count) - /// VPSRLVD xmm1, xmm2, xmm3/m128 - /// VPSRLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_srlv_epi32 (__m128i a, __m128i count) + /// VPSRLVD xmm1, xmm2, xmm3/m128 + /// VPSRLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 ShiftRightLogicalVariable(Vector128 value, Vector128 count) => ShiftRightLogicalVariable(value, count); /// - /// __m128i _mm_srlv_epi64 (__m128i a, __m128i count) - /// VPSRLVQ xmm1, xmm2, xmm3/m128 - /// VPSRLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_srlv_epi64 (__m128i a, __m128i count) + /// VPSRLVQ xmm1, xmm2, xmm3/m128 + /// VPSRLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 ShiftRightLogicalVariable(Vector128 value, Vector128 count) => ShiftRightLogicalVariable(value, count); /// - /// __m128i _mm_srlv_epi64 (__m128i a, __m128i count) - /// VPSRLVQ xmm1, xmm2, xmm3/m128 - /// VPSRLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_srlv_epi64 (__m128i a, __m128i count) + /// VPSRLVQ xmm1, xmm2, xmm3/m128 + /// VPSRLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 ShiftRightLogicalVariable(Vector128 value, Vector128 count) => ShiftRightLogicalVariable(value, count); /// - /// __m256i _mm256_srlv_epi32 (__m256i a, __m256i count) - /// VPSRLVD ymm1, ymm2, ymm3/m256 - /// VPSRLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_srlv_epi32 (__m256i a, __m256i count) + /// VPSRLVD ymm1, ymm2, ymm3/m256 + /// VPSRLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) => ShiftRightLogicalVariable(value, count); /// - /// __m256i _mm256_srlv_epi32 (__m256i a, __m256i count) - /// VPSRLVD ymm1, ymm2, ymm3/m256 - /// VPSRLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_srlv_epi32 (__m256i a, __m256i count) + /// VPSRLVD ymm1, ymm2, ymm3/m256 + /// VPSRLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) => ShiftRightLogicalVariable(value, count); /// - /// __m256i _mm256_srlv_epi64 (__m256i a, __m256i count) - /// VPSRLVQ ymm1, ymm2, ymm3/m256 - /// VPSRLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_srlv_epi64 (__m256i a, __m256i count) + /// VPSRLVQ ymm1, ymm2, ymm3/m256 + /// VPSRLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) => ShiftRightLogicalVariable(value, count); /// - /// __m256i _mm256_srlv_epi64 (__m256i a, __m256i count) - /// VPSRLVQ ymm1, ymm2, ymm3/m256 - /// VPSRLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_srlv_epi64 (__m256i a, __m256i count) + /// VPSRLVQ ymm1, ymm2, ymm3/m256 + /// VPSRLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) => ShiftRightLogicalVariable(value, count); /// - /// __m256i _mm256_shuffle_epi8 (__m256i a, __m256i b) - /// VPSHUFB ymm1, ymm2, ymm3/m256 - /// VPSHUFB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_shuffle_epi8 (__m256i a, __m256i b) + /// VPSHUFB ymm1, ymm2, ymm3/m256 + /// VPSHUFB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Shuffle(Vector256 value, Vector256 mask) => Shuffle(value, mask); /// - /// __m256i _mm256_shuffle_epi8 (__m256i a, __m256i b) - /// VPSHUFB ymm1, ymm2, ymm3/m256 - /// VPSHUFB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_shuffle_epi8 (__m256i a, __m256i b) + /// VPSHUFB ymm1, ymm2, ymm3/m256 + /// VPSHUFB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Shuffle(Vector256 value, Vector256 mask) => Shuffle(value, mask); /// - /// __m256i _mm256_shuffle_epi32 (__m256i a, const int imm8) - /// VPSHUFD ymm1, ymm2/m256, imm8 - /// VPSHUFD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256i _mm256_shuffle_epi32 (__m256i a, const int imm8) + /// VPSHUFD ymm1, ymm2/m256, imm8 + /// VPSHUFD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 Shuffle(Vector256 value, [ConstantExpected] byte control) => Shuffle(value, control); /// - /// __m256i _mm256_shuffle_epi32 (__m256i a, const int imm8) - /// VPSHUFD ymm1, ymm2/m256, imm8 - /// VPSHUFD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256i _mm256_shuffle_epi32 (__m256i a, const int imm8) + /// VPSHUFD ymm1, ymm2/m256, imm8 + /// VPSHUFD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 Shuffle(Vector256 value, [ConstantExpected] byte control) => Shuffle(value, control); /// - /// __m256i _mm256_shufflehi_epi16 (__m256i a, const int imm8) - /// VPSHUFHW ymm1, ymm2/m256, imm8 - /// VPSHUFHW ymm1 {k1}{z}, ymm2/m256, imm8 + /// __m256i _mm256_shufflehi_epi16 (__m256i a, const int imm8) + /// VPSHUFHW ymm1, ymm2/m256, imm8 + /// VPSHUFHW ymm1 {k1}{z}, ymm2/m256, imm8 /// public static Vector256 ShuffleHigh(Vector256 value, [ConstantExpected] byte control) => ShuffleHigh(value, control); /// - /// __m256i _mm256_shufflehi_epi16 (__m256i a, const int imm8) - /// VPSHUFHW ymm1, ymm2/m256, imm8 - /// VPSHUFHW ymm1 {k1}{z}, ymm2/m256, imm8 + /// __m256i _mm256_shufflehi_epi16 (__m256i a, const int imm8) + /// VPSHUFHW ymm1, ymm2/m256, imm8 + /// VPSHUFHW ymm1 {k1}{z}, ymm2/m256, imm8 /// public static Vector256 ShuffleHigh(Vector256 value, [ConstantExpected] byte control) => ShuffleHigh(value, control); /// - /// __m256i _mm256_shufflelo_epi16 (__m256i a, const int imm8) - /// VPSHUFLW ymm1, ymm2/m256, imm8 - /// VPSHUFLW ymm1 {k1}{z}, ymm2/m256, imm8 + /// __m256i _mm256_shufflelo_epi16 (__m256i a, const int imm8) + /// VPSHUFLW ymm1, ymm2/m256, imm8 + /// VPSHUFLW ymm1 {k1}{z}, ymm2/m256, imm8 /// public static Vector256 ShuffleLow(Vector256 value, [ConstantExpected] byte control) => ShuffleLow(value, control); /// - /// __m256i _mm256_shufflelo_epi16 (__m256i a, const int imm8) - /// VPSHUFLW ymm1, ymm2/m256, imm8 - /// VPSHUFLW ymm1 {k1}{z}, ymm2/m256, imm8 + /// __m256i _mm256_shufflelo_epi16 (__m256i a, const int imm8) + /// VPSHUFLW ymm1, ymm2/m256, imm8 + /// VPSHUFLW ymm1 {k1}{z}, ymm2/m256, imm8 /// public static Vector256 ShuffleLow(Vector256 value, [ConstantExpected] byte control) => ShuffleLow(value, control); /// - /// __m256i _mm256_sign_epi8 (__m256i a, __m256i b) - /// VPSIGNB ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_sign_epi8 (__m256i a, __m256i b) + /// VPSIGNB ymm1, ymm2, ymm3/m256 /// public static Vector256 Sign(Vector256 left, Vector256 right) => Sign(left, right); /// - /// __m256i _mm256_sign_epi16 (__m256i a, __m256i b) - /// VPSIGNW ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_sign_epi16 (__m256i a, __m256i b) + /// VPSIGNW ymm1, ymm2, ymm3/m256 /// public static Vector256 Sign(Vector256 left, Vector256 right) => Sign(left, right); /// - /// __m256i _mm256_sign_epi32 (__m256i a, __m256i b) - /// VPSIGND ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_sign_epi32 (__m256i a, __m256i b) + /// VPSIGND ymm1, ymm2, ymm3/m256 /// public static Vector256 Sign(Vector256 left, Vector256 right) => Sign(left, right); /// - /// __m256i _mm256_sub_epi8 (__m256i a, __m256i b) - /// VPSUBB ymm1, ymm2, ymm3/m256 - /// VPSUBB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sub_epi8 (__m256i a, __m256i b) + /// VPSUBB ymm1, ymm2, ymm3/m256 + /// VPSUBB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Subtract(Vector256 left, Vector256 right) => Subtract(left, right); /// - /// __m256i _mm256_sub_epi8 (__m256i a, __m256i b) - /// VPSUBB ymm1, ymm2, ymm3/m256 - /// VPSUBB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sub_epi8 (__m256i a, __m256i b) + /// VPSUBB ymm1, ymm2, ymm3/m256 + /// VPSUBB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Subtract(Vector256 left, Vector256 right) => Subtract(left, right); /// - /// __m256i _mm256_sub_epi16 (__m256i a, __m256i b) - /// VPSUBW ymm1, ymm2, ymm3/m256 - /// VPSUBW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sub_epi16 (__m256i a, __m256i b) + /// VPSUBW ymm1, ymm2, ymm3/m256 + /// VPSUBW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Subtract(Vector256 left, Vector256 right) => Subtract(left, right); /// - /// __m256i _mm256_sub_epi16 (__m256i a, __m256i b) - /// VPSUBW ymm1, ymm2, ymm3/m256 - /// VPSUBW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sub_epi16 (__m256i a, __m256i b) + /// VPSUBW ymm1, ymm2, ymm3/m256 + /// VPSUBW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Subtract(Vector256 left, Vector256 right) => Subtract(left, right); /// - /// __m256i _mm256_sub_epi32 (__m256i a, __m256i b) - /// VPSUBD ymm1, ymm2, ymm3/m256 - /// VPSUBD ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sub_epi32 (__m256i a, __m256i b) + /// VPSUBD ymm1, ymm2, ymm3/m256 + /// VPSUBD ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Subtract(Vector256 left, Vector256 right) => Subtract(left, right); /// - /// __m256i _mm256_sub_epi32 (__m256i a, __m256i b) - /// VPSUBD ymm1, ymm2, ymm3/m256 - /// VPSUBD ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sub_epi32 (__m256i a, __m256i b) + /// VPSUBD ymm1, ymm2, ymm3/m256 + /// VPSUBD ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Subtract(Vector256 left, Vector256 right) => Subtract(left, right); /// - /// __m256i _mm256_sub_epi64 (__m256i a, __m256i b) - /// VPSUBQ ymm1, ymm2, ymm3/m256 - /// VPSUBQ ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sub_epi64 (__m256i a, __m256i b) + /// VPSUBQ ymm1, ymm2, ymm3/m256 + /// VPSUBQ ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Subtract(Vector256 left, Vector256 right) => Subtract(left, right); /// - /// __m256i _mm256_sub_epi64 (__m256i a, __m256i b) - /// VPSUBQ ymm1, ymm2, ymm3/m256 - /// VPSUBQ ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sub_epi64 (__m256i a, __m256i b) + /// VPSUBQ ymm1, ymm2, ymm3/m256 + /// VPSUBQ ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 Subtract(Vector256 left, Vector256 right) => Subtract(left, right); /// - /// __m256i _mm256_subs_epi8 (__m256i a, __m256i b) - /// VPSUBSB ymm1, ymm2, ymm3/m128 - /// VPSUBSB ymm1 {k1}{z}, ymm2, ymm3/m128 + /// __m256i _mm256_subs_epi8 (__m256i a, __m256i b) + /// VPSUBSB ymm1, ymm2, ymm3/m128 + /// VPSUBSB ymm1 {k1}{z}, ymm2, ymm3/m128 /// public static Vector256 SubtractSaturate(Vector256 left, Vector256 right) => SubtractSaturate(left, right); /// - /// __m256i _mm256_subs_epi16 (__m256i a, __m256i b) - /// VPSUBSW ymm1, ymm2, ymm3/m128 - /// VPSUBSW ymm1 {k1}{z}, ymm2, ymm3/m128 + /// __m256i _mm256_subs_epi16 (__m256i a, __m256i b) + /// VPSUBSW ymm1, ymm2, ymm3/m128 + /// VPSUBSW ymm1 {k1}{z}, ymm2, ymm3/m128 /// public static Vector256 SubtractSaturate(Vector256 left, Vector256 right) => SubtractSaturate(left, right); /// - /// __m256i _mm256_subs_epu8 (__m256i a, __m256i b) - /// VPSUBUSB ymm1, ymm2, ymm3/m128 - /// VPSUBUSB ymm1 {k1}{z}, ymm2, ymm3/m128 + /// __m256i _mm256_subs_epu8 (__m256i a, __m256i b) + /// VPSUBUSB ymm1, ymm2, ymm3/m128 + /// VPSUBUSB ymm1 {k1}{z}, ymm2, ymm3/m128 /// public static Vector256 SubtractSaturate(Vector256 left, Vector256 right) => SubtractSaturate(left, right); /// - /// __m256i _mm256_subs_epu16 (__m256i a, __m256i b) - /// VPSUBUSW ymm1, ymm2, ymm3/m128 - /// VPSUBUSW ymm1 {k1}{z}, ymm2, ymm3/m128 + /// __m256i _mm256_subs_epu16 (__m256i a, __m256i b) + /// VPSUBUSW ymm1, ymm2, ymm3/m128 + /// VPSUBUSW ymm1 {k1}{z}, ymm2, ymm3/m128 /// public static Vector256 SubtractSaturate(Vector256 left, Vector256 right) => SubtractSaturate(left, right); /// - /// __m256i _mm256_sad_epu8 (__m256i a, __m256i b) - /// VPSADBW ymm1, ymm2, ymm3/m256 - /// VPSADBW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sad_epu8 (__m256i a, __m256i b) + /// VPSADBW ymm1, ymm2, ymm3/m256 + /// VPSADBW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 SumAbsoluteDifferences(Vector256 left, Vector256 right) => SumAbsoluteDifferences(left, right); /// - /// __m256i _mm256_unpackhi_epi8 (__m256i a, __m256i b) - /// VPUNPCKHBW ymm1, ymm2, ymm3/m256 - /// VPUNPCKHBW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_unpackhi_epi8 (__m256i a, __m256i b) + /// VPUNPCKHBW ymm1, ymm2, ymm3/m256 + /// VPUNPCKHBW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 UnpackHigh(Vector256 left, Vector256 right) => UnpackHigh(left, right); /// - /// __m256i _mm256_unpackhi_epi8 (__m256i a, __m256i b) - /// VPUNPCKHBW ymm1, ymm2, ymm3/m256 - /// VPUNPCKHBW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_unpackhi_epi8 (__m256i a, __m256i b) + /// VPUNPCKHBW ymm1, ymm2, ymm3/m256 + /// VPUNPCKHBW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 UnpackHigh(Vector256 left, Vector256 right) => UnpackHigh(left, right); /// - /// __m256i _mm256_unpackhi_epi16 (__m256i a, __m256i b) - /// VPUNPCKHWD ymm1, ymm2, ymm3/m256 - /// VPUNPCKHWD ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_unpackhi_epi16 (__m256i a, __m256i b) + /// VPUNPCKHWD ymm1, ymm2, ymm3/m256 + /// VPUNPCKHWD ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 UnpackHigh(Vector256 left, Vector256 right) => UnpackHigh(left, right); /// - /// __m256i _mm256_unpackhi_epi16 (__m256i a, __m256i b) - /// VPUNPCKHWD ymm1, ymm2, ymm3/m256 - /// VPUNPCKHWD ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_unpackhi_epi16 (__m256i a, __m256i b) + /// VPUNPCKHWD ymm1, ymm2, ymm3/m256 + /// VPUNPCKHWD ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 UnpackHigh(Vector256 left, Vector256 right) => UnpackHigh(left, right); /// - /// __m256i _mm256_unpackhi_epi32 (__m256i a, __m256i b) - /// VPUNPCKHDQ ymm1, ymm2, ymm3/m256 - /// VPUNPCKHDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_unpackhi_epi32 (__m256i a, __m256i b) + /// VPUNPCKHDQ ymm1, ymm2, ymm3/m256 + /// VPUNPCKHDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 UnpackHigh(Vector256 left, Vector256 right) => UnpackHigh(left, right); /// - /// __m256i _mm256_unpackhi_epi32 (__m256i a, __m256i b) - /// VPUNPCKHDQ ymm1, ymm2, ymm3/m256 - /// VPUNPCKHDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_unpackhi_epi32 (__m256i a, __m256i b) + /// VPUNPCKHDQ ymm1, ymm2, ymm3/m256 + /// VPUNPCKHDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 UnpackHigh(Vector256 left, Vector256 right) => UnpackHigh(left, right); /// - /// __m256i _mm256_unpackhi_epi64 (__m256i a, __m256i b) - /// VPUNPCKHQDQ ymm1, ymm2, ymm3/m256 - /// VPUNPCKHQDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_unpackhi_epi64 (__m256i a, __m256i b) + /// VPUNPCKHQDQ ymm1, ymm2, ymm3/m256 + /// VPUNPCKHQDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 UnpackHigh(Vector256 left, Vector256 right) => UnpackHigh(left, right); /// - /// __m256i _mm256_unpackhi_epi64 (__m256i a, __m256i b) - /// VPUNPCKHQDQ ymm1, ymm2, ymm3/m256 - /// VPUNPCKHQDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_unpackhi_epi64 (__m256i a, __m256i b) + /// VPUNPCKHQDQ ymm1, ymm2, ymm3/m256 + /// VPUNPCKHQDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 UnpackHigh(Vector256 left, Vector256 right) => UnpackHigh(left, right); /// - /// __m256i _mm256_unpacklo_epi8 (__m256i a, __m256i b) - /// VPUNPCKLBW ymm1, ymm2, ymm3/m256 - /// VPUNPCKLBW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_unpacklo_epi8 (__m256i a, __m256i b) + /// VPUNPCKLBW ymm1, ymm2, ymm3/m256 + /// VPUNPCKLBW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 UnpackLow(Vector256 left, Vector256 right) => UnpackLow(left, right); /// - /// __m256i _mm256_unpacklo_epi8 (__m256i a, __m256i b) - /// VPUNPCKLBW ymm1, ymm2, ymm3/m256 - /// VPUNPCKLBW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_unpacklo_epi8 (__m256i a, __m256i b) + /// VPUNPCKLBW ymm1, ymm2, ymm3/m256 + /// VPUNPCKLBW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 UnpackLow(Vector256 left, Vector256 right) => UnpackLow(left, right); /// - /// __m256i _mm256_unpacklo_epi16 (__m256i a, __m256i b) - /// VPUNPCKLWD ymm1, ymm2, ymm3/m256 - /// VPUNPCKLWD ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_unpacklo_epi16 (__m256i a, __m256i b) + /// VPUNPCKLWD ymm1, ymm2, ymm3/m256 + /// VPUNPCKLWD ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 UnpackLow(Vector256 left, Vector256 right) => UnpackLow(left, right); /// - /// __m256i _mm256_unpacklo_epi16 (__m256i a, __m256i b) - /// VPUNPCKLWD ymm1, ymm2, ymm3/m256 - /// VPUNPCKLWD ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_unpacklo_epi16 (__m256i a, __m256i b) + /// VPUNPCKLWD ymm1, ymm2, ymm3/m256 + /// VPUNPCKLWD ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 UnpackLow(Vector256 left, Vector256 right) => UnpackLow(left, right); /// - /// __m256i _mm256_unpacklo_epi32 (__m256i a, __m256i b) - /// VPUNPCKLDQ ymm1, ymm2, ymm3/m256 - /// VPUNPCKLDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_unpacklo_epi32 (__m256i a, __m256i b) + /// VPUNPCKLDQ ymm1, ymm2, ymm3/m256 + /// VPUNPCKLDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 UnpackLow(Vector256 left, Vector256 right) => UnpackLow(left, right); /// - /// __m256i _mm256_unpacklo_epi32 (__m256i a, __m256i b) - /// VPUNPCKLDQ ymm1, ymm2, ymm3/m256 - /// VPUNPCKLDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_unpacklo_epi32 (__m256i a, __m256i b) + /// VPUNPCKLDQ ymm1, ymm2, ymm3/m256 + /// VPUNPCKLDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 UnpackLow(Vector256 left, Vector256 right) => UnpackLow(left, right); /// - /// __m256i _mm256_unpacklo_epi64 (__m256i a, __m256i b) - /// VPUNPCKLQDQ ymm1, ymm2, ymm3/m256 - /// VPUNPCKLQDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_unpacklo_epi64 (__m256i a, __m256i b) + /// VPUNPCKLQDQ ymm1, ymm2, ymm3/m256 + /// VPUNPCKLQDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 UnpackLow(Vector256 left, Vector256 right) => UnpackLow(left, right); /// - /// __m256i _mm256_unpacklo_epi64 (__m256i a, __m256i b) - /// VPUNPCKLQDQ ymm1, ymm2, ymm3/m256 - /// VPUNPCKLQDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_unpacklo_epi64 (__m256i a, __m256i b) + /// VPUNPCKLQDQ ymm1, ymm2, ymm3/m256 + /// VPUNPCKLQDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 UnpackLow(Vector256 left, Vector256 right) => UnpackLow(left, right); /// - /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) - /// VPXOR ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) + /// VPXOR ymm1, ymm2, ymm3/m256 /// public static Vector256 Xor(Vector256 left, Vector256 right) => Xor(left, right); /// - /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) - /// VPXOR ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) + /// VPXOR ymm1, ymm2, ymm3/m256 /// public static Vector256 Xor(Vector256 left, Vector256 right) => Xor(left, right); /// - /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) - /// VPXOR ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) + /// VPXOR ymm1, ymm2, ymm3/m256 /// public static Vector256 Xor(Vector256 left, Vector256 right) => Xor(left, right); /// - /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) - /// VPXOR ymm1, ymm2, ymm3/m256 + /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) + /// VPXOR ymm1, ymm2, ymm3/m256 /// public static Vector256 Xor(Vector256 left, Vector256 right) => Xor(left, right); /// - /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) - /// VPXOR ymm1, ymm2, ymm3/m256 - /// VPXORD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) + /// VPXOR ymm1, ymm2, ymm3/m256 + /// VPXORD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Xor(Vector256 left, Vector256 right) => Xor(left, right); /// - /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) - /// VPXOR ymm1, ymm2, ymm3/m256 - /// VPXORD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) + /// VPXOR ymm1, ymm2, ymm3/m256 + /// VPXORD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Xor(Vector256 left, Vector256 right) => Xor(left, right); /// - /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) - /// VPXOR ymm1, ymm2, ymm3/m256 - /// VPXORQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) + /// VPXOR ymm1, ymm2, ymm3/m256 + /// VPXORQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Xor(Vector256 left, Vector256 right) => Xor(left, right); /// - /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) - /// VPXOR ymm1, ymm2, ymm3/m256 - /// VPXORQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_xor_si256 (__m256i a, __m256i b) + /// VPXOR ymm1, ymm2, ymm3/m256 + /// VPXORQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Xor(Vector256 left, Vector256 right) => Xor(left, right); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512BW.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512BW.PlatformNotSupported.cs index 74d27c8a526..7cc4d2ef352 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512BW.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512BW.PlatformNotSupported.cs @@ -8,1086 +8,1097 @@ namespace System.Runtime.Intrinsics.X86 { - /// This class provides access to X86 AVX512BW hardware instructions via intrinsics + /// Provides access to X86 AVX512BW hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Avx512BW : Avx512F { internal Avx512BW() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } + /// Provides access to the x86 AVX512BW+VL hardware instructions via intrinsics. public new abstract class VL : Avx512F.VL { internal VL() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } /// - /// __m128i _mm_cmpgt_epu8 (__m128i a, __m128i b) - /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(6) + /// __m128i _mm_cmpgt_epu8 (__m128i a, __m128i b) + /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(6) /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpge_epu8 (__m128i a, __m128i b) - /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(5) + /// __m128i _mm_cmpge_epu8 (__m128i a, __m128i b) + /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmplt_epu8 (__m128i a, __m128i b) - /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(1) + /// __m128i _mm_cmplt_epu8 (__m128i a, __m128i b) + /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmple_epu8 (__m128i a, __m128i b) - /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(2) + /// __m128i _mm_cmple_epu8 (__m128i a, __m128i b) + /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpne_epu8 (__m128i a, __m128i b) - /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(4) + /// __m128i _mm_cmpne_epu8 (__m128i a, __m128i b) + /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpgt_epu8 (__m256i a, __m256i b) - /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(6) + /// __m256i _mm256_cmpgt_epu8 (__m256i a, __m256i b) + /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(6) /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpge_epu8 (__m256i a, __m256i b) - /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(5) + /// __m256i _mm256_cmpge_epu8 (__m256i a, __m256i b) + /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmplt_epu8 (__m256i a, __m256i b) - /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(1) + /// __m256i _mm256_cmplt_epu8 (__m256i a, __m256i b) + /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmple_epu8 (__m256i a, __m256i b) - /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(2) + /// __m256i _mm256_cmple_epu8 (__m256i a, __m256i b) + /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpne_epu8 (__m256i a, __m256i b) - /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(4) + /// __m256i _mm256_cmpne_epu8 (__m256i a, __m256i b) + /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpge_epi16 (__m128i a, __m128i b) - /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(5) + /// __m128i _mm_cmpge_epi16 (__m128i a, __m128i b) + /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmplt_epi16 (__m128i a, __m128i b) - /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(1) + /// __m128i _mm_cmplt_epi16 (__m128i a, __m128i b) + /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmple_epi16 (__m128i a, __m128i b) - /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(2) + /// __m128i _mm_cmple_epi16 (__m128i a, __m128i b) + /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpne_epi16 (__m128i a, __m128i b) - /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(4) + /// __m128i _mm_cmpne_epi16 (__m128i a, __m128i b) + /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpge_epi16 (__m256i a, __m256i b) - /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(5) + /// __m256i _mm256_cmpge_epi16 (__m256i a, __m256i b) + /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmplt_epi16 (__m256i a, __m256i b) - /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(1) + /// __m256i _mm256_cmplt_epi16 (__m256i a, __m256i b) + /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmple_epi16 (__m256i a, __m256i b) - /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(2) + /// __m256i _mm256_cmple_epi16 (__m256i a, __m256i b) + /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpne_epi16 (__m256i a, __m256i b) - /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(4) + /// __m256i _mm256_cmpne_epi16 (__m256i a, __m256i b) + /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpge_epi8 (__m128i a, __m128i b) - /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(5) + /// __m128i _mm_cmpge_epi8 (__m128i a, __m128i b) + /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmplt_epi8 (__m128i a, __m128i b) - /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(1) + /// __m128i _mm_cmplt_epi8 (__m128i a, __m128i b) + /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmple_epi8 (__m128i a, __m128i b) - /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(2) + /// __m128i _mm_cmple_epi8 (__m128i a, __m128i b) + /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpne_epi8 (__m128i a, __m128i b) - /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(4) + /// __m128i _mm_cmpne_epi8 (__m128i a, __m128i b) + /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpge_epi8 (__m256i a, __m256i b) - /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(5) + /// __m256i _mm256_cmpge_epi8 (__m256i a, __m256i b) + /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmplt_epi8 (__m256i a, __m256i b) - /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(1) + /// __m256i _mm256_cmplt_epi8 (__m256i a, __m256i b) + /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmple_epi8 (__m256i a, __m256i b) - /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(2) + /// __m256i _mm256_cmple_epi8 (__m256i a, __m256i b) + /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpne_epi8 (__m256i a, __m256i b) - /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(4) + /// __m256i _mm256_cmpne_epi8 (__m256i a, __m256i b) + /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpgt_epu16 (__m128i a, __m128i b) - /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(6) + /// __m128i _mm_cmpgt_epu16 (__m128i a, __m128i b) + /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(6) /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpge_epu16 (__m128i a, __m128i b) - /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(5) + /// __m128i _mm_cmpge_epu16 (__m128i a, __m128i b) + /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmplt_epu16 (__m128i a, __m128i b) - /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(1) + /// __m128i _mm_cmplt_epu16 (__m128i a, __m128i b) + /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmple_epu16 (__m128i a, __m128i b) - /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(2) + /// __m128i _mm_cmple_epu16 (__m128i a, __m128i b) + /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpne_epu16 (__m128i a, __m128i b) - /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(4) + /// __m128i _mm_cmpne_epu16 (__m128i a, __m128i b) + /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpgt_epu16 (__m256i a, __m256i b) - /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(6) + /// __m256i _mm256_cmpgt_epu16 (__m256i a, __m256i b) + /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(6) /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpge_epu16 (__m256i a, __m256i b) - /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(5) + /// __m256i _mm256_cmpge_epu16 (__m256i a, __m256i b) + /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmplt_epu16 (__m256i a, __m256i b) - /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(1) + /// __m256i _mm256_cmplt_epu16 (__m256i a, __m256i b) + /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmple_epu16 (__m256i a, __m256i b) - /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(2) + /// __m256i _mm256_cmple_epu16 (__m256i a, __m256i b) + /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpne_epu16 (__m256i a, __m256i b) - /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(4) + /// __m256i _mm256_cmpne_epu16 (__m256i a, __m256i b) + /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi16_epi8 (__m128i a) - /// VPMOVWB xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi16_epi8 (__m128i a) + /// VPMOVWB xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Byte(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi16_epi8 (__m128i a) - /// VPMOVWB xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi16_epi8 (__m128i a) + /// VPMOVWB xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Byte(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi16_epi8 (__m256i a) - /// VPMOVWB xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi16_epi8 (__m256i a) + /// VPMOVWB xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Byte(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi16_epi8 (__m256i a) - /// VPMOVWB xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi16_epi8 (__m256i a) + /// VPMOVWB xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Byte(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtusepi16_epi8 (__m128i a) - /// VPMOVUWB xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtusepi16_epi8 (__m128i a) + /// VPMOVUWB xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtusepi16_epi8 (__m256i a) - /// VPMOVUWB xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtusepi16_epi8 (__m256i a) + /// VPMOVUWB xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi16_epi8 (__m128i a) - /// VPMOVWB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi16_epi8 (__m128i a) + /// VPMOVWB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi16_epi8 (__m128i a) - /// VPMOVWB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi16_epi8 (__m128i a) + /// VPMOVWB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi16_epi8 (__m256i a) - /// VPMOVWB xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi16_epi8 (__m256i a) + /// VPMOVWB xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi16_epi8 (__m256i a) - /// VPMOVWB xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi16_epi8 (__m256i a) + /// VPMOVWB xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtsepi16_epi8 (__m128i a) - /// VPMOVSWB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm_cvtsepi16_epi8 (__m128i a) + /// VPMOVSWB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtsepi16_epi8 (__m256i a) - /// VPMOVSWB xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm256_cvtsepi16_epi8 (__m256i a) + /// VPMOVSWB xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_permutevar8x16_epi16 (__m128i a, __m128i b) - /// VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutevar8x16_epi16 (__m128i a, __m128i b) + /// VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar8x16(Vector128 left, Vector128 control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_permutevar8x16_epi16 (__m128i a, __m128i b) - /// VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutevar8x16_epi16 (__m128i a, __m128i b) + /// VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar8x16(Vector128 left, Vector128 control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_permutex2var_epi16 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2W xmm1 {k1}{z}, xmm2, xmm3/m128 - /// VPERMT2W xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutex2var_epi16 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2W xmm1 {k1}{z}, xmm2, xmm3/m128 + /// VPERMT2W xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar8x16x2(Vector128 lower, Vector128 indices, Vector128 upper) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_permutex2var_epi16 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2W xmm1 {k1}{z}, xmm2, xmm3/m128 - /// VPERMT2W xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutex2var_epi16 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2W xmm1 {k1}{z}, xmm2, xmm3/m128 + /// VPERMT2W xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar8x16x2(Vector128 lower, Vector128 indices, Vector128 upper) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutevar16x16_epi16 (__m256i a, __m256i b) - /// VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutevar16x16_epi16 (__m256i a, __m256i b) + /// VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar16x16(Vector256 left, Vector256 control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutevar16x16_epi16 (__m256i a, __m256i b) - /// VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutevar16x16_epi16 (__m256i a, __m256i b) + /// VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar16x16(Vector256 left, Vector256 control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutex2var_epi16 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2W ymm1 {k1}{z}, ymm2, ymm3/m256 - /// VPERMT2W ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutex2var_epi16 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2W ymm1 {k1}{z}, ymm2, ymm3/m256 + /// VPERMT2W ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar16x16x2(Vector256 lower, Vector256 indices, Vector256 upper) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutex2var_epi16 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2W ymm1 {k1}{z}, ymm2, ymm3/m256 - /// VPERMT2W ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutex2var_epi16 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2W ymm1 {k1}{z}, ymm2, ymm3/m256 + /// VPERMT2W ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar16x16x2(Vector256 lower, Vector256 indices, Vector256 upper) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sllv_epi16 (__m128i a, __m128i count) - /// VPSLLVW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sllv_epi16 (__m128i a, __m128i count) + /// VPSLLVW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftLeftLogicalVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sllv_epi16 (__m128i a, __m128i count) - /// VPSLLVW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sllv_epi16 (__m128i a, __m128i count) + /// VPSLLVW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftLeftLogicalVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sllv_epi16 (__m256i a, __m256i count) - /// VPSLLVW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sllv_epi16 (__m256i a, __m256i count) + /// VPSLLVW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sllv_epi16 (__m256i a, __m256i count) - /// VPSLLVW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sllv_epi16 (__m256i a, __m256i count) + /// VPSLLVW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srav_epi16 (__m128i a, __m128i count) - /// VPSRAVW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_srav_epi16 (__m128i a, __m128i count) + /// VPSRAVW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightArithmeticVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srav_epi16 (__m256i a, __m256i count) - /// VPSRAVW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_srav_epi16 (__m256i a, __m256i count) + /// VPSRAVW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 ShiftRightArithmeticVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srlv_epi16 (__m128i a, __m128i count) - /// VPSRLVW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_srlv_epi16 (__m128i a, __m128i count) + /// VPSRLVW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightLogicalVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srlv_epi16 (__m128i a, __m128i count) - /// VPSRLVW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_srlv_epi16 (__m128i a, __m128i count) + /// VPSRLVW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightLogicalVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srlv_epi16 (__m256i a, __m256i count) - /// VPSRLVW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_srlv_epi16 (__m256i a, __m256i count) + /// VPSRLVW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srlv_epi16 (__m256i a, __m256i count) - /// VPSRLVW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_srlv_epi16 (__m256i a, __m256i count) + /// VPSRLVW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_dbsad_epu8 (__m128i a, __m128i b, int imm8) - /// VDBPSADBW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_dbsad_epu8 (__m128i a, __m128i b, int imm8) + /// VDBPSADBW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 SumAbsoluteDifferencesInBlock32(Vector128 left, Vector128 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_dbsad_epu8 (__m256i a, __m256i b, int imm8) - /// VDBPSADBW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_dbsad_epu8 (__m256i a, __m256i b, int imm8) + /// VDBPSADBW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 SumAbsoluteDifferencesInBlock32(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } } + /// Provides access to the x86 AVX512BW hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class X64 : Avx512F.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } } /// - /// __m512i _mm512_abs_epi8 (__m512i a) - /// VPABSB zmm1 {k1}{z}, zmm2/m512 + /// __m512i _mm512_abs_epi8 (__m512i a) + /// VPABSB zmm1 {k1}{z}, zmm2/m512 /// public static Vector512 Abs(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_abs_epi16 (__m512i a) - /// VPABSW zmm1 {k1}{z}, zmm2/m512 + /// __m512i _mm512_abs_epi16 (__m512i a) + /// VPABSW zmm1 {k1}{z}, zmm2/m512 /// public static Vector512 Abs(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_add_epi8 (__m512i a, __m512i b) - /// VPADDB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_add_epi8 (__m512i a, __m512i b) + /// VPADDB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Add(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_add_epi8 (__m512i a, __m512i b) - /// VPADDB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_add_epi8 (__m512i a, __m512i b) + /// VPADDB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Add(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_add_epi16 (__m512i a, __m512i b) - /// VPADDW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_add_epi16 (__m512i a, __m512i b) + /// VPADDW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Add(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_add_epi16 (__m512i a, __m512i b) - /// VPADDW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_add_epi16 (__m512i a, __m512i b) + /// VPADDW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Add(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_adds_epi8 (__m512i a, __m512i b) - /// VPADDSB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_adds_epi8 (__m512i a, __m512i b) + /// VPADDSB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 AddSaturate(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_adds_epu8 (__m512i a, __m512i b) - /// VPADDUSB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_adds_epu8 (__m512i a, __m512i b) + /// VPADDUSB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 AddSaturate(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_adds_epi16 (__m512i a, __m512i b) - /// VPADDSW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_adds_epi16 (__m512i a, __m512i b) + /// VPADDSW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 AddSaturate(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_adds_epu16 (__m512i a, __m512i b) - /// VPADDUSW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_adds_epu16 (__m512i a, __m512i b) + /// VPADDUSW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 AddSaturate(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_alignr_epi8 (__m512i a, __m512i b, const int count) - /// VPALIGNR zmm1 {k1}{z}, zmm2, zmm3/m512, imm8 + /// __m512i _mm512_alignr_epi8 (__m512i a, __m512i b, const int count) + /// VPALIGNR zmm1 {k1}{z}, zmm2, zmm3/m512, imm8 /// public static Vector512 AlignRight(Vector512 left, Vector512 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_alignr_epi8 (__m512i a, __m512i b, const int count) - /// VPALIGNR zmm1 {k1}{z}, zmm2, zmm3/m512, imm8 + /// __m512i _mm512_alignr_epi8 (__m512i a, __m512i b, const int count) + /// VPALIGNR zmm1 {k1}{z}, zmm2, zmm3/m512, imm8 /// public static Vector512 AlignRight(Vector512 left, Vector512 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_avg_epu8 (__m512i a, __m512i b) - /// VPAVGB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_avg_epu8 (__m512i a, __m512i b) + /// VPAVGB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Average(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_avg_epu16 (__m512i a, __m512i b) - /// VPAVGW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_avg_epu16 (__m512i a, __m512i b) + /// VPAVGW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Average(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_blendv_epu8 (__m512i a, __m512i b, __m512i mask) - /// VPBLENDMB zmm1 {k1}, zmm2, zmm3/m512 + /// __m512i _mm512_blendv_epu8 (__m512i a, __m512i b, __m512i mask) + /// VPBLENDMB zmm1 {k1}, zmm2, zmm3/m512 /// public static Vector512 BlendVariable(Vector512 left, Vector512 right, Vector512 mask) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_blendv_epi16 (__m512i a, __m512i b, __m512i mask) - /// VPBLENDMW zmm1 {k1}, zmm2, zmm3/m512 + /// __m512i _mm512_blendv_epi16 (__m512i a, __m512i b, __m512i mask) + /// VPBLENDMW zmm1 {k1}, zmm2, zmm3/m512 /// public static Vector512 BlendVariable(Vector512 left, Vector512 right, Vector512 mask) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_blendv_epi8 (__m512i a, __m512i b, __m512i mask) - /// VPBLENDMB zmm1 {k1}, zmm2, zmm3/m512 + /// __m512i _mm512_blendv_epi8 (__m512i a, __m512i b, __m512i mask) + /// VPBLENDMB zmm1 {k1}, zmm2, zmm3/m512 /// public static Vector512 BlendVariable(Vector512 left, Vector512 right, Vector512 mask) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_blendv_epu16 (__m512i a, __m512i b, __m512i mask) - /// VPBLENDMW zmm1 {k1}, zmm2, zmm3/m512 + /// __m512i _mm512_blendv_epu16 (__m512i a, __m512i b, __m512i mask) + /// VPBLENDMW zmm1 {k1}, zmm2, zmm3/m512 /// public static Vector512 BlendVariable(Vector512 left, Vector512 right, Vector512 mask) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_broadcastb_epi8 (__m128i a) - /// VPBROADCASTB zmm1 {k1}{z}, xmm2/m8 + /// __m512i _mm512_broadcastb_epi8 (__m128i a) + /// VPBROADCASTB zmm1 {k1}{z}, xmm2/m8 /// public static Vector512 BroadcastScalarToVector512(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_broadcastb_epi8 (__m128i a) - /// VPBROADCASTB zmm1 {k1}{z}, xmm2/m8 + /// __m512i _mm512_broadcastb_epi8 (__m128i a) + /// VPBROADCASTB zmm1 {k1}{z}, xmm2/m8 /// public static Vector512 BroadcastScalarToVector512(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_broadcastw_epi16 (__m128i a) - /// VPBROADCASTW zmm1 {k1}{z}, xmm2/m16 + /// __m512i _mm512_broadcastw_epi16 (__m128i a) + /// VPBROADCASTW zmm1 {k1}{z}, xmm2/m16 /// public static Vector512 BroadcastScalarToVector512(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_broadcastw_epi16 (__m128i a) - /// VPBROADCASTW zmm1 {k1}{z}, xmm2/m16 + /// __m512i _mm512_broadcastw_epi16 (__m128i a) + /// VPBROADCASTW zmm1 {k1}{z}, xmm2/m16 /// public static Vector512 BroadcastScalarToVector512(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpeq_epu8 (__m512i a, __m512i b) - /// VPCMPEQB k1 {k2}, zmm2, zmm3/m512 + /// __m512i _mm512_cmpeq_epu8 (__m512i a, __m512i b) + /// VPCMPEQB k1 {k2}, zmm2, zmm3/m512 /// public static Vector512 CompareEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpgt_epu8 (__m512i a, __m512i b) - /// VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(6) + /// __m512i _mm512_cmpgt_epu8 (__m512i a, __m512i b) + /// VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(6) /// public static Vector512 CompareGreaterThan(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpge_epu8 (__m512i a, __m512i b) - /// VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(5) + /// __m512i _mm512_cmpge_epu8 (__m512i a, __m512i b) + /// VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(5) /// public static Vector512 CompareGreaterThanOrEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmplt_epu8 (__m512i a, __m512i b) - /// VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(1) + /// __m512i _mm512_cmplt_epu8 (__m512i a, __m512i b) + /// VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(1) /// public static Vector512 CompareLessThan(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmple_epu8 (__m512i a, __m512i b) - /// VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(2) + /// __m512i _mm512_cmple_epu8 (__m512i a, __m512i b) + /// VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(2) /// public static Vector512 CompareLessThanOrEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpne_epu8 (__m512i a, __m512i b) - /// VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(4) + /// __m512i _mm512_cmpne_epu8 (__m512i a, __m512i b) + /// VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(4) /// public static Vector512 CompareNotEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpeq_epi16 (__m512i a, __m512i b) - /// VPCMPEQW k1 {k2}, zmm2, zmm3/m512 + /// __m512i _mm512_cmpeq_epi16 (__m512i a, __m512i b) + /// VPCMPEQW k1 {k2}, zmm2, zmm3/m512 /// public static Vector512 CompareEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpgt_epi16 (__m512i a, __m512i b) - /// VPCMPGTW k1 {k2}, zmm2, zmm3/m512 + /// __m512i _mm512_cmpgt_epi16 (__m512i a, __m512i b) + /// VPCMPGTW k1 {k2}, zmm2, zmm3/m512 /// public static Vector512 CompareGreaterThan(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpge_epi16 (__m512i a, __m512i b) - /// VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8(5) + /// __m512i _mm512_cmpge_epi16 (__m512i a, __m512i b) + /// VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8(5) /// public static Vector512 CompareGreaterThanOrEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmplt_epi16 (__m512i a, __m512i b) - /// VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8(1) + /// __m512i _mm512_cmplt_epi16 (__m512i a, __m512i b) + /// VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8(1) /// public static Vector512 CompareLessThan(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmple_epi16 (__m512i a, __m512i b) - /// VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8(2) + /// __m512i _mm512_cmple_epi16 (__m512i a, __m512i b) + /// VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8(2) /// public static Vector512 CompareLessThanOrEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpne_epi16 (__m512i a, __m512i b) - /// VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8(4) + /// __m512i _mm512_cmpne_epi16 (__m512i a, __m512i b) + /// VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8(4) /// public static Vector512 CompareNotEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpeq_epi8 (__m512i a, __m512i b) - /// VPCMPEQB k1 {k2}, zmm2, zmm3/m512 + /// __m512i _mm512_cmpeq_epi8 (__m512i a, __m512i b) + /// VPCMPEQB k1 {k2}, zmm2, zmm3/m512 /// public static Vector512 CompareEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpgt_epi8 (__m512i a, __m512i b) - /// VPCMPGTB k1 {k2}, zmm2, zmm3/m512 + /// __m512i _mm512_cmpgt_epi8 (__m512i a, __m512i b) + /// VPCMPGTB k1 {k2}, zmm2, zmm3/m512 /// public static Vector512 CompareGreaterThan(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpge_epi8 (__m512i a, __m512i b) - /// VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8(5) + /// __m512i _mm512_cmpge_epi8 (__m512i a, __m512i b) + /// VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8(5) /// public static Vector512 CompareGreaterThanOrEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmplt_epi8 (__m512i a, __m512i b) - /// VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8(1) + /// __m512i _mm512_cmplt_epi8 (__m512i a, __m512i b) + /// VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8(1) /// public static Vector512 CompareLessThan(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmple_epi8 (__m512i a, __m512i b) - /// VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8(2) + /// __m512i _mm512_cmple_epi8 (__m512i a, __m512i b) + /// VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8(2) /// public static Vector512 CompareLessThanOrEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpne_epi8 (__m512i a, __m512i b) - /// VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8(4) + /// __m512i _mm512_cmpne_epi8 (__m512i a, __m512i b) + /// VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8(4) /// public static Vector512 CompareNotEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpeq_epu16 (__m512i a, __m512i b) - /// VPCMPEQW k1 {k2}, zmm2, zmm3/m512 + /// __m512i _mm512_cmpeq_epu16 (__m512i a, __m512i b) + /// VPCMPEQW k1 {k2}, zmm2, zmm3/m512 /// public static Vector512 CompareEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpgt_epu16 (__m512i a, __m512i b) - /// VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(6) + /// __m512i _mm512_cmpgt_epu16 (__m512i a, __m512i b) + /// VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(6) /// public static Vector512 CompareGreaterThan(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpge_epu16 (__m512i a, __m512i b) - /// VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(5) + /// __m512i _mm512_cmpge_epu16 (__m512i a, __m512i b) + /// VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(5) /// public static Vector512 CompareGreaterThanOrEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmplt_epu16 (__m512i a, __m512i b) - /// VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(1) + /// __m512i _mm512_cmplt_epu16 (__m512i a, __m512i b) + /// VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(1) /// public static Vector512 CompareLessThan(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmple_epu16 (__m512i a, __m512i b) - /// VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(2) + /// __m512i _mm512_cmple_epu16 (__m512i a, __m512i b) + /// VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(2) /// public static Vector512 CompareLessThanOrEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpne_epu16 (__m512i a, __m512i b) - /// VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(4) + /// __m512i _mm512_cmpne_epu16 (__m512i a, __m512i b) + /// VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(4) /// public static Vector512 CompareNotEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_cvtepi16_epi8 (__m512i a) - /// VPMOVWB ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtepi16_epi8 (__m512i a) + /// VPMOVWB ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256Byte(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_cvtepi16_epi8 (__m512i a) - /// VPMOVWB ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtepi16_epi8 (__m512i a) + /// VPMOVWB ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256Byte(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_cvtusepi16_epi8 (__m512i a) - /// VPMOVUWB ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtusepi16_epi8 (__m512i a) + /// VPMOVUWB ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256ByteWithSaturation(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_cvtepi16_epi8 (__m512i a) - /// VPMOVWB ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtepi16_epi8 (__m512i a) + /// VPMOVWB ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256SByte(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_cvtepi16_epi8 (__m512i a) - /// VPMOVWB ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtepi16_epi8 (__m512i a) + /// VPMOVWB ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256SByte(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_cvtsepi16_epi8 (__m512i a) - /// VPMOVSWB ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtsepi16_epi8 (__m512i a) + /// VPMOVSWB ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256SByteWithSaturation(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtepi8_epi16 (__m128i a) - /// VPMOVSXBW zmm1 {k1}{z}, ymm2/m256 + /// __m512i _mm512_cvtepi8_epi16 (__m128i a) + /// VPMOVSXBW zmm1 {k1}{z}, ymm2/m256 /// public static Vector512 ConvertToVector512Int16(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtepu8_epi16 (__m128i a) - /// VPMOVZXBW zmm1 {k1}{z}, ymm2/m256 + /// __m512i _mm512_cvtepu8_epi16 (__m128i a) + /// VPMOVZXBW zmm1 {k1}{z}, ymm2/m256 /// public static Vector512 ConvertToVector512Int16(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtepi8_epi16 (__m128i a) - /// VPMOVSXBW zmm1 {k1}{z}, ymm2/m256 + /// __m512i _mm512_cvtepi8_epi16 (__m128i a) + /// VPMOVSXBW zmm1 {k1}{z}, ymm2/m256 /// public static Vector512 ConvertToVector512UInt16(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtepu8_epi16 (__m128i a) - /// VPMOVZXBW zmm1 {k1}{z}, ymm2/m256 + /// __m512i _mm512_cvtepu8_epi16 (__m128i a) + /// VPMOVZXBW zmm1 {k1}{z}, ymm2/m256 /// public static Vector512 ConvertToVector512UInt16(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_loadu_epi8 (__m512i const * mem_addr) - /// VMOVDQU8 zmm1 {k1}{z}, m512 + /// __m512i _mm512_loadu_epi8 (__m512i const * mem_addr) + /// VMOVDQU8 zmm1 {k1}{z}, m512 /// public static new unsafe Vector512 LoadVector512(sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_loadu_epi8 (__m512i const * mem_addr) - /// VMOVDQU8 zmm1 {k1}{z}, m512 + /// __m512i _mm512_loadu_epi8 (__m512i const * mem_addr) + /// VMOVDQU8 zmm1 {k1}{z}, m512 /// public static new unsafe Vector512 LoadVector512(byte* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_loadu_epi16 (__m512i const * mem_addr) - /// VMOVDQU16 zmm1 {k1}{z}, m512 + /// __m512i _mm512_loadu_epi16 (__m512i const * mem_addr) + /// VMOVDQU16 zmm1 {k1}{z}, m512 /// public static new unsafe Vector512 LoadVector512(short* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_loadu_epi16 (__m512i const * mem_addr) - /// VMOVDQU16 zmm1 {k1}{z}, m512 + /// __m512i _mm512_loadu_epi16 (__m512i const * mem_addr) + /// VMOVDQU16 zmm1 {k1}{z}, m512 /// public static new unsafe Vector512 LoadVector512(ushort* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_max_epi8 (__m512i a, __m512i b) - /// VPMAXSB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_max_epi8 (__m512i a, __m512i b) + /// VPMAXSB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Max(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_max_epu8 (__m512i a, __m512i b) - /// VPMAXUB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_max_epu8 (__m512i a, __m512i b) + /// VPMAXUB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Max(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_max_epi16 (__m512i a, __m512i b) - /// VPMAXSW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_max_epi16 (__m512i a, __m512i b) + /// VPMAXSW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Max(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_max_epu16 (__m512i a, __m512i b) - /// VPMAXUW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_max_epu16 (__m512i a, __m512i b) + /// VPMAXUW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Max(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_min_epi8 (__m512i a, __m512i b) - /// VPMINSB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_min_epi8 (__m512i a, __m512i b) + /// VPMINSB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Min(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_min_epu8 (__m512i a, __m512i b) - /// VPMINUB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_min_epu8 (__m512i a, __m512i b) + /// VPMINUB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Min(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_min_epi16 (__m512i a, __m512i b) - /// VPMINSW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_min_epi16 (__m512i a, __m512i b) + /// VPMINSW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Min(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_min_epu16 (__m512i a, __m512i b) - /// VPMINUW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_min_epu16 (__m512i a, __m512i b) + /// VPMINUW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Min(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_madd_epi16 (__m512i a, __m512i b) - /// VPMADDWD zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_madd_epi16 (__m512i a, __m512i b) + /// VPMADDWD zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 MultiplyAddAdjacent(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_maddubs_epi16 (__m512i a, __m512i b) - /// VPMADDUBSW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_maddubs_epi16 (__m512i a, __m512i b) + /// VPMADDUBSW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 MultiplyAddAdjacent(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_mulhi_epi16 (__m512i a, __m512i b) - /// VPMULHW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_mulhi_epi16 (__m512i a, __m512i b) + /// VPMULHW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 MultiplyHigh(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_mulhi_epu16 (__m512i a, __m512i b) - /// VPMULHUW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_mulhi_epu16 (__m512i a, __m512i b) + /// VPMULHUW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 MultiplyHigh(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_mulhrs_epi16 (__m512i a, __m512i b) - /// VPMULHRSW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_mulhrs_epi16 (__m512i a, __m512i b) + /// VPMULHRSW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 MultiplyHighRoundScale(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_mullo_epi16 (__m512i a, __m512i b) - /// VPMULLW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_mullo_epi16 (__m512i a, __m512i b) + /// VPMULLW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 MultiplyLow(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_mullo_epi16 (__m512i a, __m512i b) - /// VPMULLW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_mullo_epi16 (__m512i a, __m512i b) + /// VPMULLW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 MultiplyLow(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_packs_epi16 (__m512i a, __m512i b) - /// VPACKSSWB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_packs_epi16 (__m512i a, __m512i b) + /// VPACKSSWB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PackSignedSaturate(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_packs_epi32 (__m512i a, __m512i b) - /// VPACKSSDW zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_packs_epi32 (__m512i a, __m512i b) + /// VPACKSSDW zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 PackSignedSaturate(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_packus_epi16 (__m512i a, __m512i b) - /// VPACKUSWB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_packus_epi16 (__m512i a, __m512i b) + /// VPACKUSWB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PackUnsignedSaturate(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_packus_epi32 (__m512i a, __m512i b) - /// VPACKUSDW zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_packus_epi32 (__m512i a, __m512i b) + /// VPACKUSDW zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 PackUnsignedSaturate(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_permutevar32x16_epi16 (__m512i a, __m512i b) - /// VPERMW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_permutevar32x16_epi16 (__m512i a, __m512i b) + /// VPERMW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PermuteVar32x16(Vector512 left, Vector512 control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_permutevar32x16_epi16 (__m512i a, __m512i b) - /// VPERMW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_permutevar32x16_epi16 (__m512i a, __m512i b) + /// VPERMW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PermuteVar32x16(Vector512 left, Vector512 control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_permutex2var_epi16 (__m512i a, __m512i idx, __m512i b) - /// VPERMI2W zmm1 {k1}{z}, zmm2, zmm3/m512 - /// VPERMT2W zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_permutex2var_epi16 (__m512i a, __m512i idx, __m512i b) + /// VPERMI2W zmm1 {k1}{z}, zmm2, zmm3/m512 + /// VPERMT2W zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PermuteVar32x16x2(Vector512 lower, Vector512 indices, Vector512 upper) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_permutex2var_epi16 (__m512i a, __m512i idx, __m512i b) - /// VPERMI2W zmm1 {k1}{z}, zmm2, zmm3/m512 - /// VPERMT2W zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_permutex2var_epi16 (__m512i a, __m512i idx, __m512i b) + /// VPERMI2W zmm1 {k1}{z}, zmm2, zmm3/m512 + /// VPERMT2W zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PermuteVar32x16x2(Vector512 lower, Vector512 indices, Vector512 upper) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_sll_epi16 (__m512i a, __m128i count) - /// VPSLLW zmm1 {k1}{z}, zmm2, xmm3/m128 + /// __m512i _mm512_sll_epi16 (__m512i a, __m128i count) + /// VPSLLW zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftLeftLogical(Vector512 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_sll_epi16 (__m512i a, __m128i count) - /// VPSLLW zmm1 {k1}{z}, zmm2, xmm3/m128 + /// __m512i _mm512_sll_epi16 (__m512i a, __m128i count) + /// VPSLLW zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftLeftLogical(Vector512 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_slli_epi16 (__m512i a, int imm8) - /// VPSLLW zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_slli_epi16 (__m512i a, int imm8) + /// VPSLLW zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftLeftLogical(Vector512 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_slli_epi16 (__m512i a, int imm8) - /// VPSLLW zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_slli_epi16 (__m512i a, int imm8) + /// VPSLLW zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftLeftLogical(Vector512 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_bslli_epi128 (__m512i a, const int imm8) - /// VPSLLDQ zmm1, zmm2/m512, imm8 + /// __m512i _mm512_bslli_epi128 (__m512i a, const int imm8) + /// VPSLLDQ zmm1, zmm2/m512, imm8 /// public static Vector512 ShiftLeftLogical128BitLane(Vector512 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_bslli_epi128 (__m512i a, const int imm8) - /// VPSLLDQ zmm1, zmm2/m512, imm8 + /// __m512i _mm512_bslli_epi128 (__m512i a, const int imm8) + /// VPSLLDQ zmm1, zmm2/m512, imm8 /// public static Vector512 ShiftLeftLogical128BitLane(Vector512 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_sllv_epi16 (__m512i a, __m512i count) - /// VPSLLVW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_sllv_epi16 (__m512i a, __m512i count) + /// VPSLLVW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 ShiftLeftLogicalVariable(Vector512 value, Vector512 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_sllv_epi16 (__m512i a, __m512i count) - /// VPSLLVW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_sllv_epi16 (__m512i a, __m512i count) + /// VPSLLVW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 ShiftLeftLogicalVariable(Vector512 value, Vector512 count) { throw new PlatformNotSupportedException(); } /// - /// _mm512_sra_epi16 (__m512i a, __m128i count) - /// VPSRAW zmm1 {k1}{z}, zmm2, xmm3/m128 + /// _mm512_sra_epi16 (__m512i a, __m128i count) + /// VPSRAW zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftRightArithmetic(Vector512 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_srai_epi16 (__m512i a, int imm8) - /// VPSRAW zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_srai_epi16 (__m512i a, int imm8) + /// VPSRAW zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftRightArithmetic(Vector512 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_srav_epi16 (__m512i a, __m512i count) - /// VPSRAVW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_srav_epi16 (__m512i a, __m512i count) + /// VPSRAVW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 ShiftRightArithmeticVariable(Vector512 value, Vector512 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_srl_epi16 (__m512i a, __m128i count) - /// VPSRLW zmm1 {k1}{z}, zmm2, xmm3/m128 + /// __m512i _mm512_srl_epi16 (__m512i a, __m128i count) + /// VPSRLW zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftRightLogical(Vector512 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_srl_epi16 (__m512i a, __m128i count) - /// VPSRLW zmm1 {k1}{z}, zmm2, xmm3/m128 + /// __m512i _mm512_srl_epi16 (__m512i a, __m128i count) + /// VPSRLW zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftRightLogical(Vector512 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_srli_epi16 (__m512i a, int imm8) - /// VPSRLW zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_srli_epi16 (__m512i a, int imm8) + /// VPSRLW zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftRightLogical(Vector512 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_srli_epi16 (__m512i a, int imm8) - /// VPSRLW zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_srli_epi16 (__m512i a, int imm8) + /// VPSRLW zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftRightLogical(Vector512 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_bsrli_epi128 (__m512i a, const int imm8) - /// VPSRLDQ zmm1, zmm2/m128, imm8 + /// __m512i _mm512_bsrli_epi128 (__m512i a, const int imm8) + /// VPSRLDQ zmm1, zmm2/m128, imm8 /// public static Vector512 ShiftRightLogical128BitLane(Vector512 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_bsrli_epi128 (__m512i a, const int imm8) - /// VPSRLDQ zmm1, zmm2/m128, imm8 + /// __m512i _mm512_bsrli_epi128 (__m512i a, const int imm8) + /// VPSRLDQ zmm1, zmm2/m128, imm8 /// public static Vector512 ShiftRightLogical128BitLane(Vector512 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_srlv_epi16 (__m512i a, __m512i count) - /// VPSRLVW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_srlv_epi16 (__m512i a, __m512i count) + /// VPSRLVW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 ShiftRightLogicalVariable(Vector512 value, Vector512 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_srlv_epi16 (__m512i a, __m512i count) - /// VPSRLVW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_srlv_epi16 (__m512i a, __m512i count) + /// VPSRLVW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 ShiftRightLogicalVariable(Vector512 value, Vector512 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_shuffle_epi8 (__m512i a, __m512i b) - /// VPSHUFB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_shuffle_epi8 (__m512i a, __m512i b) + /// VPSHUFB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Shuffle(Vector512 value, Vector512 mask) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_shuffle_epi8 (__m512i a, __m512i b) - /// VPSHUFB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_shuffle_epi8 (__m512i a, __m512i b) + /// VPSHUFB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Shuffle(Vector512 value, Vector512 mask) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_shufflehi_epi16 (__m512i a, const int imm8) - /// VPSHUFHW zmm1 {k1}{z}, zmm2/m512, imm8 + /// __m512i _mm512_shufflehi_epi16 (__m512i a, const int imm8) + /// VPSHUFHW zmm1 {k1}{z}, zmm2/m512, imm8 /// public static Vector512 ShuffleHigh(Vector512 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_shufflehi_epi16 (__m512i a, const int imm8) - /// VPSHUFHW zmm1 {k1}{z}, zmm2/m512, imm8 + /// __m512i _mm512_shufflehi_epi16 (__m512i a, const int imm8) + /// VPSHUFHW zmm1 {k1}{z}, zmm2/m512, imm8 /// public static Vector512 ShuffleHigh(Vector512 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_shufflelo_epi16 (__m512i a, const int imm8) - /// VPSHUFLW zmm1 {k1}{z}, zmm2/m512, imm8 + /// __m512i _mm512_shufflelo_epi16 (__m512i a, const int imm8) + /// VPSHUFLW zmm1 {k1}{z}, zmm2/m512, imm8 /// public static Vector512 ShuffleLow(Vector512 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_shufflelo_epi16 (__m512i a, const int imm8) - /// VPSHUFLW zmm1 {k1}{z}, zmm2/m512, imm8 + /// __m512i _mm512_shufflelo_epi16 (__m512i a, const int imm8) + /// VPSHUFLW zmm1 {k1}{z}, zmm2/m512, imm8 /// public static Vector512 ShuffleLow(Vector512 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_storeu_epi8 (__m512i * mem_addr, __m512i a) - /// VMOVDQU8 m512 {k1}{z}, zmm1 + /// void _mm512_storeu_epi8 (__m512i * mem_addr, __m512i a) + /// VMOVDQU8 m512 {k1}{z}, zmm1 /// public static new unsafe void Store(sbyte* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_storeu_epi8 (__m512i * mem_addr, __m512i a) - /// VMOVDQU8 m512 {k1}{z}, zmm1 + /// void _mm512_storeu_epi8 (__m512i * mem_addr, __m512i a) + /// VMOVDQU8 m512 {k1}{z}, zmm1 /// public static new unsafe void Store(byte* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_storeu_epi16 (__m512i * mem_addr, __m512i a) - /// VMOVDQU16 m512 {k1}{z}, zmm1 + /// void _mm512_storeu_epi16 (__m512i * mem_addr, __m512i a) + /// VMOVDQU16 m512 {k1}{z}, zmm1 /// public static new unsafe void Store(short* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_storeu_epi16 (__m512i * mem_addr, __m512i a) - /// VMOVDQU16 m512 {k1}{z}, zmm1 + /// void _mm512_storeu_epi16 (__m512i * mem_addr, __m512i a) + /// VMOVDQU16 m512 {k1}{z}, zmm1 /// public static new unsafe void Store(ushort* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_sub_epi8 (__m512i a, __m512i b) - /// VPSUBB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_sub_epi8 (__m512i a, __m512i b) + /// VPSUBB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Subtract(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_sub_epi8 (__m512i a, __m512i b) - /// VPSUBB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_sub_epi8 (__m512i a, __m512i b) + /// VPSUBB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Subtract(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_sub_epi16 (__m512i a, __m512i b) - /// VPSUBW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_sub_epi16 (__m512i a, __m512i b) + /// VPSUBW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Subtract(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_sub_epi16 (__m512i a, __m512i b) - /// VPSUBW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_sub_epi16 (__m512i a, __m512i b) + /// VPSUBW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Subtract(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_subs_epi8 (__m512i a, __m512i b) - /// VPSUBSB zmm1 {k1}{z}, zmm2, zmm3/m128 + /// __m512i _mm512_subs_epi8 (__m512i a, __m512i b) + /// VPSUBSB zmm1 {k1}{z}, zmm2, zmm3/m128 /// public static Vector512 SubtractSaturate(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_subs_epi16 (__m512i a, __m512i b) - /// VPSUBSW zmm1 {k1}{z}, zmm2, zmm3/m128 + /// __m512i _mm512_subs_epi16 (__m512i a, __m512i b) + /// VPSUBSW zmm1 {k1}{z}, zmm2, zmm3/m128 /// public static Vector512 SubtractSaturate(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_subs_epu8 (__m512i a, __m512i b) - /// VPSUBUSB zmm1 {k1}{z}, zmm2, zmm3/m128 + /// __m512i _mm512_subs_epu8 (__m512i a, __m512i b) + /// VPSUBUSB zmm1 {k1}{z}, zmm2, zmm3/m128 /// public static Vector512 SubtractSaturate(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_subs_epu16 (__m512i a, __m512i b) - /// VPSUBUSW zmm1 {k1}{z}, zmm2, zmm3/m128 + /// __m512i _mm512_subs_epu16 (__m512i a, __m512i b) + /// VPSUBUSW zmm1 {k1}{z}, zmm2, zmm3/m128 /// public static Vector512 SubtractSaturate(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_sad_epu8 (__m512i a, __m512i b) - /// VPSADBW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_sad_epu8 (__m512i a, __m512i b) + /// VPSADBW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 SumAbsoluteDifferences(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_dbsad_epu8 (__m512i a, __m512i b) - /// VDBPSADBW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_dbsad_epu8 (__m512i a, __m512i b) + /// VDBPSADBW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 SumAbsoluteDifferencesInBlock32(Vector512 left, Vector512 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_unpackhi_epi8 (__m512i a, __m512i b) - /// VPUNPCKHBW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_unpackhi_epi8 (__m512i a, __m512i b) + /// VPUNPCKHBW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 UnpackHigh(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_unpackhi_epi8 (__m512i a, __m512i b) - /// VPUNPCKHBW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_unpackhi_epi8 (__m512i a, __m512i b) + /// VPUNPCKHBW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 UnpackHigh(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_unpackhi_epi16 (__m512i a, __m512i b) - /// VPUNPCKHWD zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_unpackhi_epi16 (__m512i a, __m512i b) + /// VPUNPCKHWD zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 UnpackHigh(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_unpackhi_epi16 (__m512i a, __m512i b) - /// VPUNPCKHWD zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_unpackhi_epi16 (__m512i a, __m512i b) + /// VPUNPCKHWD zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 UnpackHigh(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_unpacklo_epi8 (__m512i a, __m512i b) - /// VPUNPCKLBW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_unpacklo_epi8 (__m512i a, __m512i b) + /// VPUNPCKLBW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 UnpackLow(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_unpacklo_epi8 (__m512i a, __m512i b) - /// VPUNPCKLBW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_unpacklo_epi8 (__m512i a, __m512i b) + /// VPUNPCKLBW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 UnpackLow(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_unpacklo_epi16 (__m512i a, __m512i b) - /// VPUNPCKLWD zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_unpacklo_epi16 (__m512i a, __m512i b) + /// VPUNPCKLWD zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 UnpackLow(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_unpacklo_epi16 (__m512i a, __m512i b) - /// VPUNPCKLWD zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_unpacklo_epi16 (__m512i a, __m512i b) + /// VPUNPCKLWD zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 UnpackLow(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512BW.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512BW.cs index f2bf3a4c341..64d393d8355 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512BW.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512BW.cs @@ -6,1088 +6,1099 @@ namespace System.Runtime.Intrinsics.X86 { - /// This class provides access to X86 AVX512BW hardware instructions via intrinsics + /// Provides access to X86 AVX512BW hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Avx512BW : Avx512F { internal Avx512BW() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the x86 AVX512BW+VL hardware instructions via intrinsics. [Intrinsic] public new abstract class VL : Avx512F.VL { internal VL() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } /// - /// __m128i _mm_cmpgt_epu8 (__m128i a, __m128i b) - /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(6) + /// __m128i _mm_cmpgt_epu8 (__m128i a, __m128i b) + /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(6) /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// - /// __m128i _mm_cmpge_epu8 (__m128i a, __m128i b) - /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(5) + /// __m128i _mm_cmpge_epu8 (__m128i a, __m128i b) + /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m128i _mm_cmplt_epu8 (__m128i a, __m128i b) - /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(1) + /// __m128i _mm_cmplt_epu8 (__m128i a, __m128i b) + /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// __m128i _mm_cmple_epu8 (__m128i a, __m128i b) - /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(2) + /// __m128i _mm_cmple_epu8 (__m128i a, __m128i b) + /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// __m128i _mm_cmpne_epu8 (__m128i a, __m128i b) - /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(4) + /// __m128i _mm_cmpne_epu8 (__m128i a, __m128i b) + /// VPCMPUB k1 {k2}, xmm2, xmm3/m128, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); /// - /// __m256i _mm256_cmpgt_epu8 (__m256i a, __m256i b) - /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(6) + /// __m256i _mm256_cmpgt_epu8 (__m256i a, __m256i b) + /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(6) /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) => CompareGreaterThan(left, right); /// - /// __m256i _mm256_cmpge_epu8 (__m256i a, __m256i b) - /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(5) + /// __m256i _mm256_cmpge_epu8 (__m256i a, __m256i b) + /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m256i _mm256_cmplt_epu8 (__m256i a, __m256i b) - /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(1) + /// __m256i _mm256_cmplt_epu8 (__m256i a, __m256i b) + /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) => CompareLessThan(left, right); /// - /// __m256i _mm256_cmple_epu8 (__m256i a, __m256i b) - /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(2) + /// __m256i _mm256_cmple_epu8 (__m256i a, __m256i b) + /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) => CompareLessThanOrEqual(left, right); /// - /// __m256i _mm256_cmpne_epu8 (__m256i a, __m256i b) - /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(4) + /// __m256i _mm256_cmpne_epu8 (__m256i a, __m256i b) + /// VPCMPUB k1 {k2}, ymm2, ymm3/m256, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) => CompareNotEqual(left, right); /// - /// __m128i _mm_cmpge_epi16 (__m128i a, __m128i b) - /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(5) + /// __m128i _mm_cmpge_epi16 (__m128i a, __m128i b) + /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m128i _mm_cmplt_epi16 (__m128i a, __m128i b) - /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(1) + /// __m128i _mm_cmplt_epi16 (__m128i a, __m128i b) + /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// __m128i _mm_cmple_epi16 (__m128i a, __m128i b) - /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(2) + /// __m128i _mm_cmple_epi16 (__m128i a, __m128i b) + /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// __m128i _mm_cmpne_epi16 (__m128i a, __m128i b) - /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(4) + /// __m128i _mm_cmpne_epi16 (__m128i a, __m128i b) + /// VPCMPW k1 {k2}, xmm2, xmm3/m128, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); /// - /// __m256i _mm256_cmpge_epi16 (__m256i a, __m256i b) - /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(5) + /// __m256i _mm256_cmpge_epi16 (__m256i a, __m256i b) + /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m256i _mm256_cmplt_epi16 (__m256i a, __m256i b) - /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(1) + /// __m256i _mm256_cmplt_epi16 (__m256i a, __m256i b) + /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) => CompareLessThan(left, right); /// - /// __m256i _mm256_cmple_epi16 (__m256i a, __m256i b) - /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(2) + /// __m256i _mm256_cmple_epi16 (__m256i a, __m256i b) + /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) => CompareLessThanOrEqual(left, right); /// - /// __m256i _mm256_cmpne_epi16 (__m256i a, __m256i b) - /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(4) + /// __m256i _mm256_cmpne_epi16 (__m256i a, __m256i b) + /// VPCMPW k1 {k2}, ymm2, ymm3/m256, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) => CompareNotEqual(left, right); /// - /// __m128i _mm_cmpge_epi8 (__m128i a, __m128i b) - /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(5) + /// __m128i _mm_cmpge_epi8 (__m128i a, __m128i b) + /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m128i _mm_cmplt_epi8 (__m128i a, __m128i b) - /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(1) + /// __m128i _mm_cmplt_epi8 (__m128i a, __m128i b) + /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// __m128i _mm_cmple_epi8 (__m128i a, __m128i b) - /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(2) + /// __m128i _mm_cmple_epi8 (__m128i a, __m128i b) + /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// __m128i _mm_cmpne_epi8 (__m128i a, __m128i b) - /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(4) + /// __m128i _mm_cmpne_epi8 (__m128i a, __m128i b) + /// VPCMPB k1 {k2}, xmm2, xmm3/m128, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); /// - /// __m256i _mm256_cmpge_epi8 (__m256i a, __m256i b) - /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(5) + /// __m256i _mm256_cmpge_epi8 (__m256i a, __m256i b) + /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m256i _mm256_cmplt_epi8 (__m256i a, __m256i b) - /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(1) + /// __m256i _mm256_cmplt_epi8 (__m256i a, __m256i b) + /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) => CompareLessThan(left, right); /// - /// __m256i _mm256_cmple_epi8 (__m256i a, __m256i b) - /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(2) + /// __m256i _mm256_cmple_epi8 (__m256i a, __m256i b) + /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) => CompareLessThanOrEqual(left, right); /// - /// __m256i _mm256_cmpne_epi8 (__m256i a, __m256i b) - /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(4) + /// __m256i _mm256_cmpne_epi8 (__m256i a, __m256i b) + /// VPCMPB k1 {k2}, ymm2, ymm3/m256, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) => CompareNotEqual(left, right); /// - /// __m128i _mm_cmpgt_epu16 (__m128i a, __m128i b) - /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(6) + /// __m128i _mm_cmpgt_epu16 (__m128i a, __m128i b) + /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(6) /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// - /// __m128i _mm_cmpge_epu16 (__m128i a, __m128i b) - /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(5) + /// __m128i _mm_cmpge_epu16 (__m128i a, __m128i b) + /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m128i _mm_cmplt_epu16 (__m128i a, __m128i b) - /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(1) + /// __m128i _mm_cmplt_epu16 (__m128i a, __m128i b) + /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// __m128i _mm_cmple_epu16 (__m128i a, __m128i b) - /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(2) + /// __m128i _mm_cmple_epu16 (__m128i a, __m128i b) + /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// __m128i _mm_cmpne_epu16 (__m128i a, __m128i b) - /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(4) + /// __m128i _mm_cmpne_epu16 (__m128i a, __m128i b) + /// VPCMPUW k1 {k2}, xmm2, xmm3/m128, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); /// - /// __m256i _mm256_cmpgt_epu16 (__m256i a, __m256i b) - /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(6) + /// __m256i _mm256_cmpgt_epu16 (__m256i a, __m256i b) + /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(6) /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) => CompareGreaterThan(left, right); /// - /// __m256i _mm256_cmpge_epu16 (__m256i a, __m256i b) - /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(5) + /// __m256i _mm256_cmpge_epu16 (__m256i a, __m256i b) + /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m256i _mm256_cmplt_epu16 (__m256i a, __m256i b) - /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(1) + /// __m256i _mm256_cmplt_epu16 (__m256i a, __m256i b) + /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) => CompareLessThan(left, right); /// - /// __m256i _mm256_cmple_epu16 (__m256i a, __m256i b) - /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(2) + /// __m256i _mm256_cmple_epu16 (__m256i a, __m256i b) + /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) => CompareLessThanOrEqual(left, right); /// - /// __m256i _mm256_cmpne_epu16 (__m256i a, __m256i b) - /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(4) + /// __m256i _mm256_cmpne_epu16 (__m256i a, __m256i b) + /// VPCMPUW k1 {k2}, ymm2, ymm3/m256, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) => CompareNotEqual(left, right); /// - /// __m128i _mm_cvtepi16_epi8 (__m128i a) - /// VPMOVWB xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi16_epi8 (__m128i a) + /// VPMOVWB xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Byte(Vector128 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm_cvtepi16_epi8 (__m128i a) - /// VPMOVWB xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi16_epi8 (__m128i a) + /// VPMOVWB xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Byte(Vector128 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm256_cvtepi16_epi8 (__m256i a) - /// VPMOVWB xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi16_epi8 (__m256i a) + /// VPMOVWB xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Byte(Vector256 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm256_cvtepi16_epi8 (__m256i a) - /// VPMOVWB xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi16_epi8 (__m256i a) + /// VPMOVWB xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Byte(Vector256 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm_cvtusepi16_epi8 (__m128i a) - /// VPMOVUWB xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtusepi16_epi8 (__m128i a) + /// VPMOVUWB xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector128 value) => ConvertToVector128ByteWithSaturation(value); /// - /// __m128i _mm256_cvtusepi16_epi8 (__m256i a) - /// VPMOVUWB xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtusepi16_epi8 (__m256i a) + /// VPMOVUWB xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector256 value) => ConvertToVector128ByteWithSaturation(value); /// - /// __m128i _mm_cvtepi16_epi8 (__m128i a) - /// VPMOVWB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi16_epi8 (__m128i a) + /// VPMOVWB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector128 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm_cvtepi16_epi8 (__m128i a) - /// VPMOVWB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi16_epi8 (__m128i a) + /// VPMOVWB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector128 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm256_cvtepi16_epi8 (__m256i a) - /// VPMOVWB xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi16_epi8 (__m256i a) + /// VPMOVWB xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector256 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm256_cvtepi16_epi8 (__m256i a) - /// VPMOVWB xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi16_epi8 (__m256i a) + /// VPMOVWB xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector256 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm_cvtsepi16_epi8 (__m128i a) - /// VPMOVSWB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm_cvtsepi16_epi8 (__m128i a) + /// VPMOVSWB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector128 value) => ConvertToVector128SByteWithSaturation(value); /// - /// __m128i _mm256_cvtsepi16_epi8 (__m256i a) - /// VPMOVSWB xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm256_cvtsepi16_epi8 (__m256i a) + /// VPMOVSWB xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector256 value) => ConvertToVector128SByteWithSaturation(value); /// - /// __m128i _mm_permutevar8x16_epi16 (__m128i a, __m128i b) - /// VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutevar8x16_epi16 (__m128i a, __m128i b) + /// VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar8x16(Vector128 left, Vector128 control) => PermuteVar8x16(left, control); /// - /// __m128i _mm_permutevar8x16_epi16 (__m128i a, __m128i b) - /// VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutevar8x16_epi16 (__m128i a, __m128i b) + /// VPERMW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar8x16(Vector128 left, Vector128 control) => PermuteVar8x16(left, control); /// - /// __m128i _mm_permutex2var_epi16 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2W xmm1 {k1}{z}, xmm2, xmm3/m128 - /// VPERMT2W xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutex2var_epi16 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2W xmm1 {k1}{z}, xmm2, xmm3/m128 + /// VPERMT2W xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar8x16x2(Vector128 lower, Vector128 indices, Vector128 upper) => PermuteVar8x16x2(lower, indices, upper); /// - /// __m128i _mm_permutex2var_epi16 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2W xmm1 {k1}{z}, xmm2, xmm3/m128 - /// VPERMT2W xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutex2var_epi16 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2W xmm1 {k1}{z}, xmm2, xmm3/m128 + /// VPERMT2W xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar8x16x2(Vector128 lower, Vector128 indices, Vector128 upper) => PermuteVar8x16x2(lower, indices, upper); /// - /// __m256i _mm256_permutevar16x16_epi16 (__m256i a, __m256i b) - /// VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutevar16x16_epi16 (__m256i a, __m256i b) + /// VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar16x16(Vector256 left, Vector256 control) => PermuteVar16x16(left, control); /// - /// __m256i _mm256_permutevar16x16_epi16 (__m256i a, __m256i b) - /// VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutevar16x16_epi16 (__m256i a, __m256i b) + /// VPERMW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar16x16(Vector256 left, Vector256 control) => PermuteVar16x16(left, control); /// - /// __m256i _mm256_permutex2var_epi16 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2W ymm1 {k1}{z}, ymm2, ymm3/m256 - /// VPERMT2W ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutex2var_epi16 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2W ymm1 {k1}{z}, ymm2, ymm3/m256 + /// VPERMT2W ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar16x16x2(Vector256 lower, Vector256 indices, Vector256 upper) => PermuteVar16x16x2(lower, indices, upper); /// - /// __m256i _mm256_permutex2var_epi16 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2W ymm1 {k1}{z}, ymm2, ymm3/m256 - /// VPERMT2W ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutex2var_epi16 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2W ymm1 {k1}{z}, ymm2, ymm3/m256 + /// VPERMT2W ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar16x16x2(Vector256 lower, Vector256 indices, Vector256 upper) => PermuteVar16x16x2(lower, indices, upper); /// - /// __m128i _mm_sllv_epi16 (__m128i a, __m128i count) - /// VPSLLVW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sllv_epi16 (__m128i a, __m128i count) + /// VPSLLVW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftLeftLogicalVariable(Vector128 value, Vector128 count) => ShiftLeftLogicalVariable(value, count); /// - /// __m128i _mm_sllv_epi16 (__m128i a, __m128i count) - /// VPSLLVW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sllv_epi16 (__m128i a, __m128i count) + /// VPSLLVW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftLeftLogicalVariable(Vector128 value, Vector128 count) => ShiftLeftLogicalVariable(value, count); /// - /// __m256i _mm256_sllv_epi16 (__m256i a, __m256i count) - /// VPSLLVW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sllv_epi16 (__m256i a, __m256i count) + /// VPSLLVW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) => ShiftLeftLogicalVariable(value, count); /// - /// __m256i _mm256_sllv_epi16 (__m256i a, __m256i count) - /// VPSLLVW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_sllv_epi16 (__m256i a, __m256i count) + /// VPSLLVW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 ShiftLeftLogicalVariable(Vector256 value, Vector256 count) => ShiftLeftLogicalVariable(value, count); /// - /// __m128i _mm_srav_epi16 (__m128i a, __m128i count) - /// VPSRAVW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_srav_epi16 (__m128i a, __m128i count) + /// VPSRAVW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightArithmeticVariable(Vector128 value, Vector128 count) => ShiftRightArithmeticVariable(value, count); /// - /// __m256i _mm256_srav_epi16 (__m256i a, __m256i count) - /// VPSRAVW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_srav_epi16 (__m256i a, __m256i count) + /// VPSRAVW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 ShiftRightArithmeticVariable(Vector256 value, Vector256 count) => ShiftRightArithmeticVariable(value, count); /// - /// __m128i _mm_srlv_epi16 (__m128i a, __m128i count) - /// VPSRLVW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_srlv_epi16 (__m128i a, __m128i count) + /// VPSRLVW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightLogicalVariable(Vector128 value, Vector128 count) => ShiftRightLogicalVariable(value, count); /// - /// __m128i _mm_srlv_epi16 (__m128i a, __m128i count) - /// VPSRLVW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_srlv_epi16 (__m128i a, __m128i count) + /// VPSRLVW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightLogicalVariable(Vector128 value, Vector128 count) => ShiftRightLogicalVariable(value, count); /// - /// __m256i _mm256_srlv_epi16 (__m256i a, __m256i count) - /// VPSRLVW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_srlv_epi16 (__m256i a, __m256i count) + /// VPSRLVW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) => ShiftRightLogicalVariable(value, count); /// - /// __m256i _mm256_srlv_epi16 (__m256i a, __m256i count) - /// VPSRLVW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_srlv_epi16 (__m256i a, __m256i count) + /// VPSRLVW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 ShiftRightLogicalVariable(Vector256 value, Vector256 count) => ShiftRightLogicalVariable(value, count); /// - /// __m128i _mm_dbsad_epu8 (__m128i a, __m128i b, int imm8) - /// VDBPSADBW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_dbsad_epu8 (__m128i a, __m128i b, int imm8) + /// VDBPSADBW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 SumAbsoluteDifferencesInBlock32(Vector128 left, Vector128 right, [ConstantExpected] byte control) => SumAbsoluteDifferencesInBlock32(left, right, control); /// - /// __m256i _mm256_dbsad_epu8 (__m256i a, __m256i b, int imm8) - /// VDBPSADBW ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_dbsad_epu8 (__m256i a, __m256i b, int imm8) + /// VDBPSADBW ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 SumAbsoluteDifferencesInBlock32(Vector256 left, Vector256 right, [ConstantExpected] byte control) => SumAbsoluteDifferencesInBlock32(left, right, control); } + /// Provides access to the x86 AVX512BW hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : Avx512F.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } } /// - /// __m512i _mm512_abs_epi8 (__m512i a) - /// VPABSB zmm1 {k1}{z}, zmm2/m512 + /// __m512i _mm512_abs_epi8 (__m512i a) + /// VPABSB zmm1 {k1}{z}, zmm2/m512 /// public static Vector512 Abs(Vector512 value) => Abs(value); /// - /// __m512i _mm512_abs_epi16 (__m512i a) - /// VPABSW zmm1 {k1}{z}, zmm2/m512 + /// __m512i _mm512_abs_epi16 (__m512i a) + /// VPABSW zmm1 {k1}{z}, zmm2/m512 /// public static Vector512 Abs(Vector512 value) => Abs(value); /// - /// __m512i _mm512_add_epi8 (__m512i a, __m512i b) - /// VPADDB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_add_epi8 (__m512i a, __m512i b) + /// VPADDB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Add(Vector512 left, Vector512 right) => Add(left, right); /// - /// __m512i _mm512_add_epi8 (__m512i a, __m512i b) - /// VPADDB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_add_epi8 (__m512i a, __m512i b) + /// VPADDB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Add(Vector512 left, Vector512 right) => Add(left, right); /// - /// __m512i _mm512_add_epi16 (__m512i a, __m512i b) - /// VPADDW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_add_epi16 (__m512i a, __m512i b) + /// VPADDW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Add(Vector512 left, Vector512 right) => Add(left, right); /// - /// __m512i _mm512_add_epi16 (__m512i a, __m512i b) - /// VPADDW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_add_epi16 (__m512i a, __m512i b) + /// VPADDW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Add(Vector512 left, Vector512 right) => Add(left, right); /// - /// __m512i _mm512_adds_epi8 (__m512i a, __m512i b) - /// VPADDSB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_adds_epi8 (__m512i a, __m512i b) + /// VPADDSB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 AddSaturate(Vector512 left, Vector512 right) => AddSaturate(left, right); /// - /// __m512i _mm512_adds_epu8 (__m512i a, __m512i b) - /// VPADDUSB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_adds_epu8 (__m512i a, __m512i b) + /// VPADDUSB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 AddSaturate(Vector512 left, Vector512 right) => AddSaturate(left, right); /// - /// __m512i _mm512_adds_epi16 (__m512i a, __m512i b) - /// VPADDSW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_adds_epi16 (__m512i a, __m512i b) + /// VPADDSW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 AddSaturate(Vector512 left, Vector512 right) => AddSaturate(left, right); /// - /// __m512i _mm512_adds_epu16 (__m512i a, __m512i b) - /// VPADDUSW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_adds_epu16 (__m512i a, __m512i b) + /// VPADDUSW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 AddSaturate(Vector512 left, Vector512 right) => AddSaturate(left, right); /// - /// __m512i _mm512_alignr_epi8 (__m512i a, __m512i b, const int count) - /// VPALIGNR zmm1 {k1}{z}, zmm2, zmm3/m512, imm8 + /// __m512i _mm512_alignr_epi8 (__m512i a, __m512i b, const int count) + /// VPALIGNR zmm1 {k1}{z}, zmm2, zmm3/m512, imm8 /// public static Vector512 AlignRight(Vector512 left, Vector512 right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); /// - /// __m512i _mm512_alignr_epi8 (__m512i a, __m512i b, const int count) - /// VPALIGNR zmm1 {k1}{z}, zmm2, zmm3/m512, imm8 + /// __m512i _mm512_alignr_epi8 (__m512i a, __m512i b, const int count) + /// VPALIGNR zmm1 {k1}{z}, zmm2, zmm3/m512, imm8 /// public static Vector512 AlignRight(Vector512 left, Vector512 right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); /// - /// __m512i _mm512_avg_epu8 (__m512i a, __m512i b) - /// VPAVGB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_avg_epu8 (__m512i a, __m512i b) + /// VPAVGB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Average(Vector512 left, Vector512 right) => Average(left, right); /// - /// __m512i _mm512_avg_epu16 (__m512i a, __m512i b) - /// VPAVGW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_avg_epu16 (__m512i a, __m512i b) + /// VPAVGW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Average(Vector512 left, Vector512 right) => Average(left, right); /// - /// __m512i _mm512_blendv_epu8 (__m512i a, __m512i b, __m512i mask) - /// VPBLENDMB zmm1 {k1}, zmm2, zmm3/m512 + /// __m512i _mm512_blendv_epu8 (__m512i a, __m512i b, __m512i mask) + /// VPBLENDMB zmm1 {k1}, zmm2, zmm3/m512 /// public static Vector512 BlendVariable(Vector512 left, Vector512 right, Vector512 mask) => BlendVariable(left, right, mask); /// - /// __m512i _mm512_blendv_epi16 (__m512i a, __m512i b, __m512i mask) - /// VPBLENDMW zmm1 {k1}, zmm2, zmm3/m512 + /// __m512i _mm512_blendv_epi16 (__m512i a, __m512i b, __m512i mask) + /// VPBLENDMW zmm1 {k1}, zmm2, zmm3/m512 /// public static Vector512 BlendVariable(Vector512 left, Vector512 right, Vector512 mask) => BlendVariable(left, right, mask); /// - /// __m512i _mm512_blendv_epi8 (__m512i a, __m512i b, __m512i mask) - /// VPBLENDMB zmm1 {k1}, zmm2, zmm3/m512 + /// __m512i _mm512_blendv_epi8 (__m512i a, __m512i b, __m512i mask) + /// VPBLENDMB zmm1 {k1}, zmm2, zmm3/m512 /// public static Vector512 BlendVariable(Vector512 left, Vector512 right, Vector512 mask) => BlendVariable(left, right, mask); /// - /// __m512i _mm512_blendv_epu16 (__m512i a, __m512i b, __m512i mask) - /// VPBLENDMW zmm1 {k1}, zmm2, zmm3/m512 + /// __m512i _mm512_blendv_epu16 (__m512i a, __m512i b, __m512i mask) + /// VPBLENDMW zmm1 {k1}, zmm2, zmm3/m512 /// public static Vector512 BlendVariable(Vector512 left, Vector512 right, Vector512 mask) => BlendVariable(left, right, mask); /// - /// __m512i _mm512_broadcastb_epi8 (__m128i a) - /// VPBROADCASTB zmm1 {k1}{z}, xmm2/m8 + /// __m512i _mm512_broadcastb_epi8 (__m128i a) + /// VPBROADCASTB zmm1 {k1}{z}, xmm2/m8 /// public static Vector512 BroadcastScalarToVector512(Vector128 value) => BroadcastScalarToVector512(value); /// - /// __m512i _mm512_broadcastb_epi8 (__m128i a) - /// VPBROADCASTB zmm1 {k1}{z}, xmm2/m8 + /// __m512i _mm512_broadcastb_epi8 (__m128i a) + /// VPBROADCASTB zmm1 {k1}{z}, xmm2/m8 /// public static Vector512 BroadcastScalarToVector512(Vector128 value) => BroadcastScalarToVector512(value); /// - /// __m512i _mm512_broadcastw_epi16 (__m128i a) - /// VPBROADCASTW zmm1 {k1}{z}, xmm2/m16 + /// __m512i _mm512_broadcastw_epi16 (__m128i a) + /// VPBROADCASTW zmm1 {k1}{z}, xmm2/m16 /// public static Vector512 BroadcastScalarToVector512(Vector128 value) => BroadcastScalarToVector512(value); /// - /// __m512i _mm512_broadcastw_epi16 (__m128i a) - /// VPBROADCASTW zmm1 {k1}{z}, xmm2/m16 + /// __m512i _mm512_broadcastw_epi16 (__m128i a) + /// VPBROADCASTW zmm1 {k1}{z}, xmm2/m16 /// public static Vector512 BroadcastScalarToVector512(Vector128 value) => BroadcastScalarToVector512(value); /// - /// __m512i _mm512_cmpeq_epu8 (__m512i a, __m512i b) - /// VPCMPEQB k1 {k2}, zmm2, zmm3/m512 + /// __m512i _mm512_cmpeq_epu8 (__m512i a, __m512i b) + /// VPCMPEQB k1 {k2}, zmm2, zmm3/m512 /// public static Vector512 CompareEqual(Vector512 left, Vector512 right) => CompareEqual(left, right); /// - /// __m512i _mm512_cmpgt_epu8 (__m512i a, __m512i b) - /// VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(6) + /// __m512i _mm512_cmpgt_epu8 (__m512i a, __m512i b) + /// VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(6) /// public static Vector512 CompareGreaterThan(Vector512 left, Vector512 right) => CompareGreaterThan(left, right); /// - /// __m512i _mm512_cmpge_epu8 (__m512i a, __m512i b) - /// VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(5) + /// __m512i _mm512_cmpge_epu8 (__m512i a, __m512i b) + /// VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(5) /// public static Vector512 CompareGreaterThanOrEqual(Vector512 left, Vector512 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m512i _mm512_cmplt_epu8 (__m512i a, __m512i b) - /// VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(1) + /// __m512i _mm512_cmplt_epu8 (__m512i a, __m512i b) + /// VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(1) /// public static Vector512 CompareLessThan(Vector512 left, Vector512 right) => CompareLessThan(left, right); /// - /// __m512i _mm512_cmple_epu8 (__m512i a, __m512i b) - /// VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(2) + /// __m512i _mm512_cmple_epu8 (__m512i a, __m512i b) + /// VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(2) /// public static Vector512 CompareLessThanOrEqual(Vector512 left, Vector512 right) => CompareLessThanOrEqual(left, right); /// - /// __m512i _mm512_cmpne_epu8 (__m512i a, __m512i b) - /// VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(4) + /// __m512i _mm512_cmpne_epu8 (__m512i a, __m512i b) + /// VPCMPUB k1 {k2}, zmm2, zmm3/m512, imm8(4) /// public static Vector512 CompareNotEqual(Vector512 left, Vector512 right) => CompareNotEqual(left, right); /// - /// __m512i _mm512_cmpeq_epi16 (__m512i a, __m512i b) - /// VPCMPEQW k1 {k2}, zmm2, zmm3/m512 + /// __m512i _mm512_cmpeq_epi16 (__m512i a, __m512i b) + /// VPCMPEQW k1 {k2}, zmm2, zmm3/m512 /// public static Vector512 CompareEqual(Vector512 left, Vector512 right) => CompareEqual(left, right); /// - /// __m512i _mm512_cmpgt_epi16 (__m512i a, __m512i b) - /// VPCMPGTW k1 {k2}, zmm2, zmm3/m512 + /// __m512i _mm512_cmpgt_epi16 (__m512i a, __m512i b) + /// VPCMPGTW k1 {k2}, zmm2, zmm3/m512 /// public static Vector512 CompareGreaterThan(Vector512 left, Vector512 right) => CompareGreaterThan(left, right); /// - /// __m512i _mm512_cmpge_epi16 (__m512i a, __m512i b) - /// VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8(5) + /// __m512i _mm512_cmpge_epi16 (__m512i a, __m512i b) + /// VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8(5) /// public static Vector512 CompareGreaterThanOrEqual(Vector512 left, Vector512 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m512i _mm512_cmplt_epi16 (__m512i a, __m512i b) - /// VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8(1) + /// __m512i _mm512_cmplt_epi16 (__m512i a, __m512i b) + /// VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8(1) /// public static Vector512 CompareLessThan(Vector512 left, Vector512 right) => CompareLessThan(left, right); /// - /// __m512i _mm512_cmple_epi16 (__m512i a, __m512i b) - /// VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8(2) + /// __m512i _mm512_cmple_epi16 (__m512i a, __m512i b) + /// VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8(2) /// public static Vector512 CompareLessThanOrEqual(Vector512 left, Vector512 right) => CompareLessThanOrEqual(left, right); /// - /// __m512i _mm512_cmpne_epi16 (__m512i a, __m512i b) - /// VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8(4) + /// __m512i _mm512_cmpne_epi16 (__m512i a, __m512i b) + /// VPCMPW k1 {k2}, zmm2, zmm3/m512, imm8(4) /// public static Vector512 CompareNotEqual(Vector512 left, Vector512 right) => CompareNotEqual(left, right); /// - /// __m512i _mm512_cmpeq_epi8 (__m512i a, __m512i b) - /// VPCMPEQB k1 {k2}, zmm2, zmm3/m512 + /// __m512i _mm512_cmpeq_epi8 (__m512i a, __m512i b) + /// VPCMPEQB k1 {k2}, zmm2, zmm3/m512 /// public static Vector512 CompareEqual(Vector512 left, Vector512 right) => CompareEqual(left, right); /// - /// __m512i _mm512_cmpgt_epi8 (__m512i a, __m512i b) - /// VPCMPGTB k1 {k2}, zmm2, zmm3/m512 + /// __m512i _mm512_cmpgt_epi8 (__m512i a, __m512i b) + /// VPCMPGTB k1 {k2}, zmm2, zmm3/m512 /// public static Vector512 CompareGreaterThan(Vector512 left, Vector512 right) => CompareGreaterThan(left, right); /// - /// __m512i _mm512_cmpge_epi8 (__m512i a, __m512i b) - /// VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8(5) + /// __m512i _mm512_cmpge_epi8 (__m512i a, __m512i b) + /// VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8(5) /// public static Vector512 CompareGreaterThanOrEqual(Vector512 left, Vector512 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m512i _mm512_cmplt_epi8 (__m512i a, __m512i b) - /// VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8(1) + /// __m512i _mm512_cmplt_epi8 (__m512i a, __m512i b) + /// VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8(1) /// public static Vector512 CompareLessThan(Vector512 left, Vector512 right) => CompareLessThan(left, right); /// - /// __m512i _mm512_cmple_epi8 (__m512i a, __m512i b) - /// VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8(2) + /// __m512i _mm512_cmple_epi8 (__m512i a, __m512i b) + /// VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8(2) /// public static Vector512 CompareLessThanOrEqual(Vector512 left, Vector512 right) => CompareLessThanOrEqual(left, right); /// - /// __m512i _mm512_cmpne_epi8 (__m512i a, __m512i b) - /// VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8(4) + /// __m512i _mm512_cmpne_epi8 (__m512i a, __m512i b) + /// VPCMPB k1 {k2}, zmm2, zmm3/m512, imm8(4) /// public static Vector512 CompareNotEqual(Vector512 left, Vector512 right) => CompareNotEqual(left, right); /// - /// __m512i _mm512_cmpeq_epu16 (__m512i a, __m512i b) - /// VPCMPEQW k1 {k2}, zmm2, zmm3/m512 + /// __m512i _mm512_cmpeq_epu16 (__m512i a, __m512i b) + /// VPCMPEQW k1 {k2}, zmm2, zmm3/m512 /// public static Vector512 CompareEqual(Vector512 left, Vector512 right) => CompareEqual(left, right); /// - /// __m512i _mm512_cmpgt_epu16 (__m512i a, __m512i b) - /// VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(6) + /// __m512i _mm512_cmpgt_epu16 (__m512i a, __m512i b) + /// VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(6) /// public static Vector512 CompareGreaterThan(Vector512 left, Vector512 right) => CompareGreaterThan(left, right); /// - /// __m512i _mm512_cmpge_epu16 (__m512i a, __m512i b) - /// VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(5) + /// __m512i _mm512_cmpge_epu16 (__m512i a, __m512i b) + /// VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(5) /// public static Vector512 CompareGreaterThanOrEqual(Vector512 left, Vector512 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m512i _mm512_cmplt_epu16 (__m512i a, __m512i b) - /// VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(1) + /// __m512i _mm512_cmplt_epu16 (__m512i a, __m512i b) + /// VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(1) /// public static Vector512 CompareLessThan(Vector512 left, Vector512 right) => CompareLessThan(left, right); /// - /// __m512i _mm512_cmple_epu16 (__m512i a, __m512i b) - /// VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(2) + /// __m512i _mm512_cmple_epu16 (__m512i a, __m512i b) + /// VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(2) /// public static Vector512 CompareLessThanOrEqual(Vector512 left, Vector512 right) => CompareLessThanOrEqual(left, right); /// - /// __m512i _mm512_cmpne_epu16 (__m512i a, __m512i b) - /// VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(4) + /// __m512i _mm512_cmpne_epu16 (__m512i a, __m512i b) + /// VPCMPUW k1 {k2}, zmm2, zmm3/m512, imm8(4) /// public static Vector512 CompareNotEqual(Vector512 left, Vector512 right) => CompareNotEqual(left, right); /// - /// __m256i _mm512_cvtepi16_epi8 (__m512i a) - /// VPMOVWB ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtepi16_epi8 (__m512i a) + /// VPMOVWB ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256Byte(Vector512 value) => ConvertToVector256Byte(value); /// - /// __m256i _mm512_cvtepi16_epi8 (__m512i a) - /// VPMOVWB ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtepi16_epi8 (__m512i a) + /// VPMOVWB ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256Byte(Vector512 value) => ConvertToVector256Byte(value); /// - /// __m256i _mm512_cvtusepi16_epi8 (__m512i a) - /// VPMOVUWB ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtusepi16_epi8 (__m512i a) + /// VPMOVUWB ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256ByteWithSaturation(Vector512 value) => ConvertToVector256ByteWithSaturation(value); /// - /// __m256i _mm512_cvtepi16_epi8 (__m512i a) - /// VPMOVWB ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtepi16_epi8 (__m512i a) + /// VPMOVWB ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256SByte(Vector512 value) => ConvertToVector256SByte(value); /// - /// __m256i _mm512_cvtepi16_epi8 (__m512i a) - /// VPMOVWB ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtepi16_epi8 (__m512i a) + /// VPMOVWB ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256SByte(Vector512 value) => ConvertToVector256SByte(value); /// - /// __m256i _mm512_cvtsepi16_epi8 (__m512i a) - /// VPMOVSWB ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtsepi16_epi8 (__m512i a) + /// VPMOVSWB ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256SByteWithSaturation(Vector512 value) => ConvertToVector256SByteWithSaturation(value); /// - /// __m512i _mm512_cvtepi8_epi16 (__m128i a) - /// VPMOVSXBW zmm1 {k1}{z}, ymm2/m256 + /// __m512i _mm512_cvtepi8_epi16 (__m128i a) + /// VPMOVSXBW zmm1 {k1}{z}, ymm2/m256 /// public static Vector512 ConvertToVector512Int16(Vector256 value) => ConvertToVector512Int16(value); /// - /// __m512i _mm512_cvtepu8_epi16 (__m128i a) - /// VPMOVZXBW zmm1 {k1}{z}, ymm2/m256 + /// __m512i _mm512_cvtepu8_epi16 (__m128i a) + /// VPMOVZXBW zmm1 {k1}{z}, ymm2/m256 /// public static Vector512 ConvertToVector512Int16(Vector256 value) => ConvertToVector512Int16(value); /// - /// __m512i _mm512_cvtepi8_epi16 (__m128i a) - /// VPMOVSXBW zmm1 {k1}{z}, ymm2/m256 + /// __m512i _mm512_cvtepi8_epi16 (__m128i a) + /// VPMOVSXBW zmm1 {k1}{z}, ymm2/m256 /// public static Vector512 ConvertToVector512UInt16(Vector256 value) => ConvertToVector512UInt16(value); /// - /// __m512i _mm512_cvtepu8_epi16 (__m128i a) - /// VPMOVZXBW zmm1 {k1}{z}, ymm2/m256 + /// __m512i _mm512_cvtepu8_epi16 (__m128i a) + /// VPMOVZXBW zmm1 {k1}{z}, ymm2/m256 /// public static Vector512 ConvertToVector512UInt16(Vector256 value) => ConvertToVector512UInt16(value); /// - /// __m512i _mm512_loadu_epi8 (__m512i const * mem_addr) - /// VMOVDQU8 zmm1 {k1}{z}, m512 + /// __m512i _mm512_loadu_epi8 (__m512i const * mem_addr) + /// VMOVDQU8 zmm1 {k1}{z}, m512 /// public static new unsafe Vector512 LoadVector512(sbyte* address) => LoadVector512(address); /// - /// __m512i _mm512_loadu_epi8 (__m512i const * mem_addr) - /// VMOVDQU8 zmm1 {k1}{z}, m512 + /// __m512i _mm512_loadu_epi8 (__m512i const * mem_addr) + /// VMOVDQU8 zmm1 {k1}{z}, m512 /// public static new unsafe Vector512 LoadVector512(byte* address) => LoadVector512(address); /// - /// __m512i _mm512_loadu_epi16 (__m512i const * mem_addr) - /// VMOVDQU16 zmm1 {k1}{z}, m512 + /// __m512i _mm512_loadu_epi16 (__m512i const * mem_addr) + /// VMOVDQU16 zmm1 {k1}{z}, m512 /// public static new unsafe Vector512 LoadVector512(short* address) => LoadVector512(address); /// - /// __m512i _mm512_loadu_epi16 (__m512i const * mem_addr) - /// VMOVDQU16 zmm1 {k1}{z}, m512 + /// __m512i _mm512_loadu_epi16 (__m512i const * mem_addr) + /// VMOVDQU16 zmm1 {k1}{z}, m512 /// public static new unsafe Vector512 LoadVector512(ushort* address) => LoadVector512(address); /// - /// __m512i _mm512_max_epi8 (__m512i a, __m512i b) - /// VPMAXSB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_max_epi8 (__m512i a, __m512i b) + /// VPMAXSB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Max(Vector512 left, Vector512 right) => Max(left, right); /// - /// __m512i _mm512_max_epu8 (__m512i a, __m512i b) - /// VPMAXUB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_max_epu8 (__m512i a, __m512i b) + /// VPMAXUB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Max(Vector512 left, Vector512 right) => Max(left, right); /// - /// __m512i _mm512_max_epi16 (__m512i a, __m512i b) - /// VPMAXSW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_max_epi16 (__m512i a, __m512i b) + /// VPMAXSW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Max(Vector512 left, Vector512 right) => Max(left, right); /// - /// __m512i _mm512_max_epu16 (__m512i a, __m512i b) - /// VPMAXUW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_max_epu16 (__m512i a, __m512i b) + /// VPMAXUW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Max(Vector512 left, Vector512 right) => Max(left, right); /// - /// __m512i _mm512_min_epi8 (__m512i a, __m512i b) - /// VPMINSB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_min_epi8 (__m512i a, __m512i b) + /// VPMINSB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Min(Vector512 left, Vector512 right) => Min(left, right); /// - /// __m512i _mm512_min_epu8 (__m512i a, __m512i b) - /// VPMINUB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_min_epu8 (__m512i a, __m512i b) + /// VPMINUB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Min(Vector512 left, Vector512 right) => Min(left, right); /// - /// __m512i _mm512_min_epi16 (__m512i a, __m512i b) - /// VPMINSW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_min_epi16 (__m512i a, __m512i b) + /// VPMINSW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Min(Vector512 left, Vector512 right) => Min(left, right); /// - /// __m512i _mm512_min_epu16 (__m512i a, __m512i b) - /// VPMINUW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_min_epu16 (__m512i a, __m512i b) + /// VPMINUW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Min(Vector512 left, Vector512 right) => Min(left, right); /// - /// __m512i _mm512_madd_epi16 (__m512i a, __m512i b) - /// VPMADDWD zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_madd_epi16 (__m512i a, __m512i b) + /// VPMADDWD zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 MultiplyAddAdjacent(Vector512 left, Vector512 right) => MultiplyAddAdjacent(left, right); /// - /// __m512i _mm512_maddubs_epi16 (__m512i a, __m512i b) - /// VPMADDUBSW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_maddubs_epi16 (__m512i a, __m512i b) + /// VPMADDUBSW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 MultiplyAddAdjacent(Vector512 left, Vector512 right) => MultiplyAddAdjacent(left, right); /// - /// __m512i _mm512_mulhi_epi16 (__m512i a, __m512i b) - /// VPMULHW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_mulhi_epi16 (__m512i a, __m512i b) + /// VPMULHW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 MultiplyHigh(Vector512 left, Vector512 right) => MultiplyHigh(left, right); /// - /// __m512i _mm512_mulhi_epu16 (__m512i a, __m512i b) - /// VPMULHUW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_mulhi_epu16 (__m512i a, __m512i b) + /// VPMULHUW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 MultiplyHigh(Vector512 left, Vector512 right) => MultiplyHigh(left, right); /// - /// __m512i _mm512_mulhrs_epi16 (__m512i a, __m512i b) - /// VPMULHRSW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_mulhrs_epi16 (__m512i a, __m512i b) + /// VPMULHRSW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 MultiplyHighRoundScale(Vector512 left, Vector512 right) => MultiplyHighRoundScale(left, right); /// - /// __m512i _mm512_mullo_epi16 (__m512i a, __m512i b) - /// VPMULLW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_mullo_epi16 (__m512i a, __m512i b) + /// VPMULLW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 MultiplyLow(Vector512 left, Vector512 right) => MultiplyLow(left, right); /// - /// __m512i _mm512_mullo_epi16 (__m512i a, __m512i b) - /// VPMULLW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_mullo_epi16 (__m512i a, __m512i b) + /// VPMULLW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 MultiplyLow(Vector512 left, Vector512 right) => MultiplyLow(left, right); /// - /// __m512i _mm512_packs_epi16 (__m512i a, __m512i b) - /// VPACKSSWB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_packs_epi16 (__m512i a, __m512i b) + /// VPACKSSWB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PackSignedSaturate(Vector512 left, Vector512 right) => PackSignedSaturate(left, right); /// - /// __m512i _mm512_packs_epi32 (__m512i a, __m512i b) - /// VPACKSSDW zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_packs_epi32 (__m512i a, __m512i b) + /// VPACKSSDW zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 PackSignedSaturate(Vector512 left, Vector512 right) => PackSignedSaturate(left, right); /// - /// __m512i _mm512_packus_epi16 (__m512i a, __m512i b) - /// VPACKUSWB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_packus_epi16 (__m512i a, __m512i b) + /// VPACKUSWB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PackUnsignedSaturate(Vector512 left, Vector512 right) => PackUnsignedSaturate(left, right); /// - /// __m512i _mm512_packus_epi32 (__m512i a, __m512i b) - /// VPACKUSDW zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_packus_epi32 (__m512i a, __m512i b) + /// VPACKUSDW zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 PackUnsignedSaturate(Vector512 left, Vector512 right) => PackUnsignedSaturate(left, right); /// - /// __m512i _mm512_permutevar32x16_epi16 (__m512i a, __m512i b) - /// VPERMW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_permutevar32x16_epi16 (__m512i a, __m512i b) + /// VPERMW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PermuteVar32x16(Vector512 left, Vector512 control) => PermuteVar32x16(left, control); /// - /// __m512i _mm512_permutevar32x16_epi16 (__m512i a, __m512i b) - /// VPERMW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_permutevar32x16_epi16 (__m512i a, __m512i b) + /// VPERMW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PermuteVar32x16(Vector512 left, Vector512 control) => PermuteVar32x16(left, control); /// - /// __m512i _mm512_permutex2var_epi16 (__m512i a, __m512i idx, __m512i b) - /// VPERMI2W zmm1 {k1}{z}, zmm2, zmm3/m512 - /// VPERMT2W zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_permutex2var_epi16 (__m512i a, __m512i idx, __m512i b) + /// VPERMI2W zmm1 {k1}{z}, zmm2, zmm3/m512 + /// VPERMT2W zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PermuteVar32x16x2(Vector512 lower, Vector512 indices, Vector512 upper) => PermuteVar32x16x2(lower, indices, upper); /// - /// __m512i _mm512_permutex2var_epi16 (__m512i a, __m512i idx, __m512i b) - /// VPERMI2W zmm1 {k1}{z}, zmm2, zmm3/m512 - /// VPERMT2W zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_permutex2var_epi16 (__m512i a, __m512i idx, __m512i b) + /// VPERMI2W zmm1 {k1}{z}, zmm2, zmm3/m512 + /// VPERMT2W zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PermuteVar32x16x2(Vector512 lower, Vector512 indices, Vector512 upper) => PermuteVar32x16x2(lower, indices, upper); /// - /// __m512i _mm512_sll_epi16 (__m512i a, __m128i count) - /// VPSLLW zmm1 {k1}{z}, zmm2, xmm3/m128 + /// __m512i _mm512_sll_epi16 (__m512i a, __m128i count) + /// VPSLLW zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftLeftLogical(Vector512 value, Vector128 count) => ShiftLeftLogical(value, count); /// - /// __m512i _mm512_sll_epi16 (__m512i a, __m128i count) - /// VPSLLW zmm1 {k1}{z}, zmm2, xmm3/m128 + /// __m512i _mm512_sll_epi16 (__m512i a, __m128i count) + /// VPSLLW zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftLeftLogical(Vector512 value, Vector128 count) => ShiftLeftLogical(value, count); /// - /// __m512i _mm512_slli_epi16 (__m512i a, int imm8) - /// VPSLLW zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_slli_epi16 (__m512i a, int imm8) + /// VPSLLW zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftLeftLogical(Vector512 value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); /// - /// __m512i _mm512_slli_epi16 (__m512i a, int imm8) - /// VPSLLW zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_slli_epi16 (__m512i a, int imm8) + /// VPSLLW zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftLeftLogical(Vector512 value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); /// - /// __m512i _mm512_bslli_epi128 (__m512i a, const int imm8) - /// VPSLLDQ zmm1, zmm2/m512, imm8 + /// __m512i _mm512_bslli_epi128 (__m512i a, const int imm8) + /// VPSLLDQ zmm1, zmm2/m512, imm8 /// public static Vector512 ShiftLeftLogical128BitLane(Vector512 value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// - /// __m512i _mm512_bslli_epi128 (__m512i a, const int imm8) - /// VPSLLDQ zmm1, zmm2/m512, imm8 + /// __m512i _mm512_bslli_epi128 (__m512i a, const int imm8) + /// VPSLLDQ zmm1, zmm2/m512, imm8 /// public static Vector512 ShiftLeftLogical128BitLane(Vector512 value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// - /// __m512i _mm512_sllv_epi16 (__m512i a, __m512i count) - /// VPSLLVW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_sllv_epi16 (__m512i a, __m512i count) + /// VPSLLVW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 ShiftLeftLogicalVariable(Vector512 value, Vector512 count) => ShiftLeftLogicalVariable(value, count); /// - /// __m512i _mm512_sllv_epi16 (__m512i a, __m512i count) - /// VPSLLVW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_sllv_epi16 (__m512i a, __m512i count) + /// VPSLLVW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 ShiftLeftLogicalVariable(Vector512 value, Vector512 count) => ShiftLeftLogicalVariable(value, count); /// - /// _mm512_sra_epi16 (__m512i a, __m128i count) - /// VPSRAW zmm1 {k1}{z}, zmm2, xmm3/m128 + /// _mm512_sra_epi16 (__m512i a, __m128i count) + /// VPSRAW zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftRightArithmetic(Vector512 value, Vector128 count) => ShiftRightArithmetic(value, count); /// - /// __m512i _mm512_srai_epi16 (__m512i a, int imm8) - /// VPSRAW zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_srai_epi16 (__m512i a, int imm8) + /// VPSRAW zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftRightArithmetic(Vector512 value, [ConstantExpected] byte count) => ShiftRightArithmetic(value, count); /// - /// __m512i _mm512_srav_epi16 (__m512i a, __m512i count) - /// VPSRAVW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_srav_epi16 (__m512i a, __m512i count) + /// VPSRAVW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 ShiftRightArithmeticVariable(Vector512 value, Vector512 count) => ShiftRightArithmeticVariable(value, count); /// - /// __m512i _mm512_srl_epi16 (__m512i a, __m128i count) - /// VPSRLW zmm1 {k1}{z}, zmm2, xmm3/m128 + /// __m512i _mm512_srl_epi16 (__m512i a, __m128i count) + /// VPSRLW zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftRightLogical(Vector512 value, Vector128 count) => ShiftRightLogical(value, count); /// - /// __m512i _mm512_srl_epi16 (__m512i a, __m128i count) - /// VPSRLW zmm1 {k1}{z}, zmm2, xmm3/m128 + /// __m512i _mm512_srl_epi16 (__m512i a, __m128i count) + /// VPSRLW zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftRightLogical(Vector512 value, Vector128 count) => ShiftRightLogical(value, count); /// - /// __m512i _mm512_srli_epi16 (__m512i a, int imm8) - /// VPSRLW zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_srli_epi16 (__m512i a, int imm8) + /// VPSRLW zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftRightLogical(Vector512 value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); /// - /// __m512i _mm512_srli_epi16 (__m512i a, int imm8) - /// VPSRLW zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_srli_epi16 (__m512i a, int imm8) + /// VPSRLW zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftRightLogical(Vector512 value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); /// - /// __m512i _mm512_bsrli_epi128 (__m512i a, const int imm8) - /// VPSRLDQ zmm1, zmm2/m128, imm8 + /// __m512i _mm512_bsrli_epi128 (__m512i a, const int imm8) + /// VPSRLDQ zmm1, zmm2/m128, imm8 /// public static Vector512 ShiftRightLogical128BitLane(Vector512 value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// - /// __m512i _mm512_bsrli_epi128 (__m512i a, const int imm8) - /// VPSRLDQ zmm1, zmm2/m128, imm8 + /// __m512i _mm512_bsrli_epi128 (__m512i a, const int imm8) + /// VPSRLDQ zmm1, zmm2/m128, imm8 /// public static Vector512 ShiftRightLogical128BitLane(Vector512 value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// - /// __m512i _mm512_srlv_epi16 (__m512i a, __m512i count) - /// VPSRLVW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_srlv_epi16 (__m512i a, __m512i count) + /// VPSRLVW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 ShiftRightLogicalVariable(Vector512 value, Vector512 count) => ShiftRightLogicalVariable(value, count); /// - /// __m512i _mm512_srlv_epi16 (__m512i a, __m512i count) - /// VPSRLVW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_srlv_epi16 (__m512i a, __m512i count) + /// VPSRLVW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 ShiftRightLogicalVariable(Vector512 value, Vector512 count) => ShiftRightLogicalVariable(value, count); /// - /// __m512i _mm512_shuffle_epi8 (__m512i a, __m512i b) - /// VPSHUFB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_shuffle_epi8 (__m512i a, __m512i b) + /// VPSHUFB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Shuffle(Vector512 value, Vector512 mask) => Shuffle(value, mask); /// - /// __m512i _mm512_shuffle_epi8 (__m512i a, __m512i b) - /// VPSHUFB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_shuffle_epi8 (__m512i a, __m512i b) + /// VPSHUFB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Shuffle(Vector512 value, Vector512 mask) => Shuffle(value, mask); /// - /// __m512i _mm512_shufflehi_epi16 (__m512i a, const int imm8) - /// VPSHUFHW zmm1 {k1}{z}, zmm2/m512, imm8 + /// __m512i _mm512_shufflehi_epi16 (__m512i a, const int imm8) + /// VPSHUFHW zmm1 {k1}{z}, zmm2/m512, imm8 /// public static Vector512 ShuffleHigh(Vector512 value, [ConstantExpected] byte control) => ShuffleHigh(value, control); /// - /// __m512i _mm512_shufflehi_epi16 (__m512i a, const int imm8) - /// VPSHUFHW zmm1 {k1}{z}, zmm2/m512, imm8 + /// __m512i _mm512_shufflehi_epi16 (__m512i a, const int imm8) + /// VPSHUFHW zmm1 {k1}{z}, zmm2/m512, imm8 /// public static Vector512 ShuffleHigh(Vector512 value, [ConstantExpected] byte control) => ShuffleHigh(value, control); /// - /// __m512i _mm512_shufflelo_epi16 (__m512i a, const int imm8) - /// VPSHUFLW zmm1 {k1}{z}, zmm2/m512, imm8 + /// __m512i _mm512_shufflelo_epi16 (__m512i a, const int imm8) + /// VPSHUFLW zmm1 {k1}{z}, zmm2/m512, imm8 /// public static Vector512 ShuffleLow(Vector512 value, [ConstantExpected] byte control) => ShuffleLow(value, control); /// - /// __m512i _mm512_shufflelo_epi16 (__m512i a, const int imm8) - /// VPSHUFLW zmm1 {k1}{z}, zmm2/m512, imm8 + /// __m512i _mm512_shufflelo_epi16 (__m512i a, const int imm8) + /// VPSHUFLW zmm1 {k1}{z}, zmm2/m512, imm8 /// public static Vector512 ShuffleLow(Vector512 value, [ConstantExpected] byte control) => ShuffleLow(value, control); /// - /// void _mm512_storeu_epi8 (__m512i * mem_addr, __m512i a) - /// VMOVDQU8 m512 {k1}{z}, zmm1 + /// void _mm512_storeu_epi8 (__m512i * mem_addr, __m512i a) + /// VMOVDQU8 m512 {k1}{z}, zmm1 /// public static new unsafe void Store(sbyte* address, Vector512 source) => Store(address, source); /// - /// void _mm512_storeu_epi8 (__m512i * mem_addr, __m512i a) - /// VMOVDQU8 m512 {k1}{z}, zmm1 + /// void _mm512_storeu_epi8 (__m512i * mem_addr, __m512i a) + /// VMOVDQU8 m512 {k1}{z}, zmm1 /// public static new unsafe void Store(byte* address, Vector512 source) => Store(address, source); /// - /// void _mm512_storeu_epi16 (__m512i * mem_addr, __m512i a) - /// VMOVDQU16 m512 {k1}{z}, zmm1 + /// void _mm512_storeu_epi16 (__m512i * mem_addr, __m512i a) + /// VMOVDQU16 m512 {k1}{z}, zmm1 /// public static new unsafe void Store(short* address, Vector512 source) => Store(address, source); /// - /// void _mm512_storeu_epi16 (__m512i * mem_addr, __m512i a) - /// VMOVDQU16 m512 {k1}{z}, zmm1 + /// void _mm512_storeu_epi16 (__m512i * mem_addr, __m512i a) + /// VMOVDQU16 m512 {k1}{z}, zmm1 /// public static new unsafe void Store(ushort* address, Vector512 source) => Store(address, source); /// - /// __m512i _mm512_sub_epi8 (__m512i a, __m512i b) - /// VPSUBB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_sub_epi8 (__m512i a, __m512i b) + /// VPSUBB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Subtract(Vector512 left, Vector512 right) => Subtract(left, right); /// - /// __m512i _mm512_sub_epi8 (__m512i a, __m512i b) - /// VPSUBB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_sub_epi8 (__m512i a, __m512i b) + /// VPSUBB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Subtract(Vector512 left, Vector512 right) => Subtract(left, right); /// - /// __m512i _mm512_sub_epi16 (__m512i a, __m512i b) - /// VPSUBW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_sub_epi16 (__m512i a, __m512i b) + /// VPSUBW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Subtract(Vector512 left, Vector512 right) => Subtract(left, right); /// - /// __m512i _mm512_sub_epi16 (__m512i a, __m512i b) - /// VPSUBW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_sub_epi16 (__m512i a, __m512i b) + /// VPSUBW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 Subtract(Vector512 left, Vector512 right) => Subtract(left, right); /// - /// __m512i _mm512_subs_epi8 (__m512i a, __m512i b) - /// VPSUBSB zmm1 {k1}{z}, zmm2, zmm3/m128 + /// __m512i _mm512_subs_epi8 (__m512i a, __m512i b) + /// VPSUBSB zmm1 {k1}{z}, zmm2, zmm3/m128 /// public static Vector512 SubtractSaturate(Vector512 left, Vector512 right) => SubtractSaturate(left, right); /// - /// __m512i _mm512_subs_epi16 (__m512i a, __m512i b) - /// VPSUBSW zmm1 {k1}{z}, zmm2, zmm3/m128 + /// __m512i _mm512_subs_epi16 (__m512i a, __m512i b) + /// VPSUBSW zmm1 {k1}{z}, zmm2, zmm3/m128 /// public static Vector512 SubtractSaturate(Vector512 left, Vector512 right) => SubtractSaturate(left, right); /// - /// __m512i _mm512_subs_epu8 (__m512i a, __m512i b) - /// VPSUBUSB zmm1 {k1}{z}, zmm2, zmm3/m128 + /// __m512i _mm512_subs_epu8 (__m512i a, __m512i b) + /// VPSUBUSB zmm1 {k1}{z}, zmm2, zmm3/m128 /// public static Vector512 SubtractSaturate(Vector512 left, Vector512 right) => SubtractSaturate(left, right); /// - /// __m512i _mm512_subs_epu16 (__m512i a, __m512i b) - /// VPSUBUSW zmm1 {k1}{z}, zmm2, zmm3/m128 + /// __m512i _mm512_subs_epu16 (__m512i a, __m512i b) + /// VPSUBUSW zmm1 {k1}{z}, zmm2, zmm3/m128 /// public static Vector512 SubtractSaturate(Vector512 left, Vector512 right) => SubtractSaturate(left, right); /// - /// __m512i _mm512_sad_epu8 (__m512i a, __m512i b) - /// VPSADBW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_sad_epu8 (__m512i a, __m512i b) + /// VPSADBW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 SumAbsoluteDifferences(Vector512 left, Vector512 right) => SumAbsoluteDifferences(left, right); /// - /// __m512i _mm512_dbsad_epu8 (__m512i a, __m512i b, int imm8) - /// VDBPSADBW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_dbsad_epu8 (__m512i a, __m512i b, int imm8) + /// VDBPSADBW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 SumAbsoluteDifferencesInBlock32(Vector512 left, Vector512 right, [ConstantExpected] byte control) => SumAbsoluteDifferencesInBlock32(left, right, control); /// - /// __m512i _mm512_unpackhi_epi8 (__m512i a, __m512i b) - /// VPUNPCKHBW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_unpackhi_epi8 (__m512i a, __m512i b) + /// VPUNPCKHBW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 UnpackHigh(Vector512 left, Vector512 right) => UnpackHigh(left, right); /// - /// __m512i _mm512_unpackhi_epi8 (__m512i a, __m512i b) - /// VPUNPCKHBW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_unpackhi_epi8 (__m512i a, __m512i b) + /// VPUNPCKHBW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 UnpackHigh(Vector512 left, Vector512 right) => UnpackHigh(left, right); /// - /// __m512i _mm512_unpackhi_epi16 (__m512i a, __m512i b) - /// VPUNPCKHWD zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_unpackhi_epi16 (__m512i a, __m512i b) + /// VPUNPCKHWD zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 UnpackHigh(Vector512 left, Vector512 right) => UnpackHigh(left, right); /// - /// __m512i _mm512_unpackhi_epi16 (__m512i a, __m512i b) - /// VPUNPCKHWD zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_unpackhi_epi16 (__m512i a, __m512i b) + /// VPUNPCKHWD zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 UnpackHigh(Vector512 left, Vector512 right) => UnpackHigh(left, right); /// - /// __m512i _mm512_unpacklo_epi8 (__m512i a, __m512i b) - /// VPUNPCKLBW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_unpacklo_epi8 (__m512i a, __m512i b) + /// VPUNPCKLBW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 UnpackLow(Vector512 left, Vector512 right) => UnpackLow(left, right); /// - /// __m512i _mm512_unpacklo_epi8 (__m512i a, __m512i b) - /// VPUNPCKLBW zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_unpacklo_epi8 (__m512i a, __m512i b) + /// VPUNPCKLBW zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 UnpackLow(Vector512 left, Vector512 right) => UnpackLow(left, right); /// - /// __m512i _mm512_unpacklo_epi16 (__m512i a, __m512i b) - /// VPUNPCKLWD zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_unpacklo_epi16 (__m512i a, __m512i b) + /// VPUNPCKLWD zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 UnpackLow(Vector512 left, Vector512 right) => UnpackLow(left, right); /// - /// __m512i _mm512_unpacklo_epi16 (__m512i a, __m512i b) - /// VPUNPCKLWD zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_unpacklo_epi16 (__m512i a, __m512i b) + /// VPUNPCKLWD zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 UnpackLow(Vector512 left, Vector512 right) => UnpackLow(left, right); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512CD.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512CD.PlatformNotSupported.cs index f3b0af381a3..2b9d27a850b 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512CD.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512CD.PlatformNotSupported.cs @@ -8,149 +8,160 @@ namespace System.Runtime.Intrinsics.X86 { - /// This class provides access to X86 AVX512CD hardware instructions via intrinsics + /// Provides access to X86 AVX512CD hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Avx512CD : Avx512F { internal Avx512CD() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } + /// Provides access to the x86 AVX512CD+VL hardware instructions via intrinsics. public new abstract class VL : Avx512F.VL { internal VL() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } /// - /// __m128i _mm_conflict_epi32 (__m128i a) - /// VPCONFLICTD xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_conflict_epi32 (__m128i a) + /// VPCONFLICTD xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 DetectConflicts(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_conflict_epi32 (__m128i a) - /// VPCONFLICTD xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_conflict_epi32 (__m128i a) + /// VPCONFLICTD xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 DetectConflicts(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_conflict_epi64 (__m128i a) - /// VPCONFLICTQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_conflict_epi64 (__m128i a) + /// VPCONFLICTQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 DetectConflicts(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_conflict_epi64 (__m128i a) - /// VPCONFLICTQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_conflict_epi64 (__m128i a) + /// VPCONFLICTQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 DetectConflicts(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_conflict_epi32 (__m256i a) - /// VPCONFLICTD ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_conflict_epi32 (__m256i a) + /// VPCONFLICTD ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 DetectConflicts(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_conflict_epi32 (__m256i a) - /// VPCONFLICTD ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_conflict_epi32 (__m256i a) + /// VPCONFLICTD ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 DetectConflicts(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_conflict_epi64 (__m256i a) - /// VPCONFLICTQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_conflict_epi64 (__m256i a) + /// VPCONFLICTQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 DetectConflicts(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_conflict_epi64 (__m256i a) - /// VPCONFLICTQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_conflict_epi64 (__m256i a) + /// VPCONFLICTQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 DetectConflicts(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_lzcnt_epi32 (__m128i a) - /// VPLZCNTD xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_lzcnt_epi32 (__m128i a) + /// VPLZCNTD xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 LeadingZeroCount(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_lzcnt_epi32 (__m128i a) - /// VPLZCNTD xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_lzcnt_epi32 (__m128i a) + /// VPLZCNTD xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 LeadingZeroCount(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_lzcnt_epi64 (__m128i a) - /// VPLZCNTQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_lzcnt_epi64 (__m128i a) + /// VPLZCNTQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 LeadingZeroCount(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_lzcnt_epi64 (__m128i a) - /// VPLZCNTQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_lzcnt_epi64 (__m128i a) + /// VPLZCNTQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 LeadingZeroCount(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_lzcnt_epi32 (__m256i a) - /// VPLZCNTD ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_lzcnt_epi32 (__m256i a) + /// VPLZCNTD ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 LeadingZeroCount(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_lzcnt_epi32 (__m256i a) - /// VPLZCNTD ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_lzcnt_epi32 (__m256i a) + /// VPLZCNTD ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 LeadingZeroCount(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_lzcnt_epi64 (__m256i a) - /// VPLZCNTQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_lzcnt_epi64 (__m256i a) + /// VPLZCNTQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 LeadingZeroCount(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_lzcnt_epi64 (__m256i a) - /// VPLZCNTQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_lzcnt_epi64 (__m256i a) + /// VPLZCNTQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 LeadingZeroCount(Vector256 value) { throw new PlatformNotSupportedException(); } } + /// Provides access to the x86 AVX512CD hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class X64 : Avx512F.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } } /// - /// __m512i _mm512_conflict_epi32 (__m512i a) - /// VPCONFLICTD zmm1 {k1}{z}, zmm2/m512/m32bcst + /// __m512i _mm512_conflict_epi32 (__m512i a) + /// VPCONFLICTD zmm1 {k1}{z}, zmm2/m512/m32bcst /// public static Vector512 DetectConflicts(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_conflict_epi32 (__m512i a) - /// VPCONFLICTD zmm1 {k1}{z}, zmm2/m512/m32bcst + /// __m512i _mm512_conflict_epi32 (__m512i a) + /// VPCONFLICTD zmm1 {k1}{z}, zmm2/m512/m32bcst /// public static Vector512 DetectConflicts(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_conflict_epi64 (__m512i a) - /// VPCONFLICTQ zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512i _mm512_conflict_epi64 (__m512i a) + /// VPCONFLICTQ zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 DetectConflicts(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_conflict_epi64 (__m512i a) - /// VPCONFLICTQ zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512i _mm512_conflict_epi64 (__m512i a) + /// VPCONFLICTQ zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 DetectConflicts(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_lzcnt_epi32 (__m512i a) - /// VPLZCNTD zmm1 {k1}{z}, zmm2/m512/m32bcst + /// __m512i _mm512_lzcnt_epi32 (__m512i a) + /// VPLZCNTD zmm1 {k1}{z}, zmm2/m512/m32bcst /// public static Vector512 LeadingZeroCount(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_lzcnt_epi32 (__m512i a) - /// VPLZCNTD zmm1 {k1}{z}, zmm2/m512/m32bcst + /// __m512i _mm512_lzcnt_epi32 (__m512i a) + /// VPLZCNTD zmm1 {k1}{z}, zmm2/m512/m32bcst /// public static Vector512 LeadingZeroCount(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_lzcnt_epi64 (__m512i a) - /// VPLZCNTQ zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512i _mm512_lzcnt_epi64 (__m512i a) + /// VPLZCNTQ zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 LeadingZeroCount(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_lzcnt_epi64 (__m512i a) - /// VPLZCNTQ zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512i _mm512_lzcnt_epi64 (__m512i a) + /// VPLZCNTQ zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 LeadingZeroCount(Vector512 value) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512CD.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512CD.cs index aa1429b97ba..f9e25d01340 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512CD.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512CD.cs @@ -6,152 +6,163 @@ namespace System.Runtime.Intrinsics.X86 { - /// This class provides access to X86 AVX512CD hardware instructions via intrinsics + /// Provides access to X86 AVX512CD hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Avx512CD : Avx512F { internal Avx512CD() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the x86 AVX512CD+VL hardware instructions via intrinsics. [Intrinsic] public new abstract class VL : Avx512F.VL { internal VL() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } /// - /// __m128i _mm_conflict_epi32 (__m128i a) - /// VPCONFLICTD xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_conflict_epi32 (__m128i a) + /// VPCONFLICTD xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 DetectConflicts(Vector128 value) => DetectConflicts(value); /// - /// __m128i _mm_conflict_epi32 (__m128i a) - /// VPCONFLICTD xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_conflict_epi32 (__m128i a) + /// VPCONFLICTD xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 DetectConflicts(Vector128 value) => DetectConflicts(value); /// - /// __m128i _mm_conflict_epi64 (__m128i a) - /// VPCONFLICTQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_conflict_epi64 (__m128i a) + /// VPCONFLICTQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 DetectConflicts(Vector128 value) => DetectConflicts(value); /// - /// __m128i _mm_conflict_epi64 (__m128i a) - /// VPCONFLICTQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_conflict_epi64 (__m128i a) + /// VPCONFLICTQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 DetectConflicts(Vector128 value) => DetectConflicts(value); /// - /// __m256i _mm256_conflict_epi32 (__m256i a) - /// VPCONFLICTD ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_conflict_epi32 (__m256i a) + /// VPCONFLICTD ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 DetectConflicts(Vector256 value) => DetectConflicts(value); /// - /// __m256i _mm256_conflict_epi32 (__m256i a) - /// VPCONFLICTD ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_conflict_epi32 (__m256i a) + /// VPCONFLICTD ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 DetectConflicts(Vector256 value) => DetectConflicts(value); /// - /// __m256i _mm256_conflict_epi64 (__m256i a) - /// VPCONFLICTQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_conflict_epi64 (__m256i a) + /// VPCONFLICTQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 DetectConflicts(Vector256 value) => DetectConflicts(value); /// - /// __m256i _mm256_conflict_epi64 (__m256i a) - /// VPCONFLICTQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_conflict_epi64 (__m256i a) + /// VPCONFLICTQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 DetectConflicts(Vector256 value) => DetectConflicts(value); /// - /// __m128i _mm_lzcnt_epi32 (__m128i a) - /// VPLZCNTD xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_lzcnt_epi32 (__m128i a) + /// VPLZCNTD xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 LeadingZeroCount(Vector128 value) => LeadingZeroCount(value); /// - /// __m128i _mm_lzcnt_epi32 (__m128i a) - /// VPLZCNTD xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_lzcnt_epi32 (__m128i a) + /// VPLZCNTD xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 LeadingZeroCount(Vector128 value) => LeadingZeroCount(value); /// - /// __m128i _mm_lzcnt_epi64 (__m128i a) - /// VPLZCNTQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_lzcnt_epi64 (__m128i a) + /// VPLZCNTQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 LeadingZeroCount(Vector128 value) => LeadingZeroCount(value); /// - /// __m128i _mm_lzcnt_epi64 (__m128i a) - /// VPLZCNTQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_lzcnt_epi64 (__m128i a) + /// VPLZCNTQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 LeadingZeroCount(Vector128 value) => LeadingZeroCount(value); /// - /// __m256i _mm256_lzcnt_epi32 (__m256i a) - /// VPLZCNTD ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_lzcnt_epi32 (__m256i a) + /// VPLZCNTD ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 LeadingZeroCount(Vector256 value) => LeadingZeroCount(value); /// - /// __m256i _mm256_lzcnt_epi32 (__m256i a) - /// VPLZCNTD ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_lzcnt_epi32 (__m256i a) + /// VPLZCNTD ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 LeadingZeroCount(Vector256 value) => LeadingZeroCount(value); /// - /// __m256i _mm256_lzcnt_epi64 (__m256i a) - /// VPLZCNTQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_lzcnt_epi64 (__m256i a) + /// VPLZCNTQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 LeadingZeroCount(Vector256 value) => LeadingZeroCount(value); /// - /// __m256i _mm256_lzcnt_epi64 (__m256i a) - /// VPLZCNTQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_lzcnt_epi64 (__m256i a) + /// VPLZCNTQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 LeadingZeroCount(Vector256 value) => LeadingZeroCount(value); } + /// Provides access to the x86 AVX512CD hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : Avx512F.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } } /// - /// __m512i _mm512_conflict_epi32 (__m512i a) - /// VPCONFLICTD zmm1 {k1}{z}, zmm2/m512/m32bcst + /// __m512i _mm512_conflict_epi32 (__m512i a) + /// VPCONFLICTD zmm1 {k1}{z}, zmm2/m512/m32bcst /// public static Vector512 DetectConflicts(Vector512 value) => DetectConflicts(value); /// - /// __m512i _mm512_conflict_epi32 (__m512i a) - /// VPCONFLICTD zmm1 {k1}{z}, zmm2/m512/m32bcst + /// __m512i _mm512_conflict_epi32 (__m512i a) + /// VPCONFLICTD zmm1 {k1}{z}, zmm2/m512/m32bcst /// public static Vector512 DetectConflicts(Vector512 value) => DetectConflicts(value); /// - /// __m512i _mm512_conflict_epi64 (__m512i a) - /// VPCONFLICTQ zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512i _mm512_conflict_epi64 (__m512i a) + /// VPCONFLICTQ zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 DetectConflicts(Vector512 value) => DetectConflicts(value); /// - /// __m512i _mm512_conflict_epi64 (__m512i a) - /// VPCONFLICTQ zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512i _mm512_conflict_epi64 (__m512i a) + /// VPCONFLICTQ zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 DetectConflicts(Vector512 value) => DetectConflicts(value); /// - /// __m512i _mm512_lzcnt_epi32 (__m512i a) - /// VPLZCNTD zmm1 {k1}{z}, zmm2/m512/m32bcst + /// __m512i _mm512_lzcnt_epi32 (__m512i a) + /// VPLZCNTD zmm1 {k1}{z}, zmm2/m512/m32bcst /// public static Vector512 LeadingZeroCount(Vector512 value) => LeadingZeroCount(value); /// - /// __m512i _mm512_lzcnt_epi32 (__m512i a) - /// VPLZCNTD zmm1 {k1}{z}, zmm2/m512/m32bcst + /// __m512i _mm512_lzcnt_epi32 (__m512i a) + /// VPLZCNTD zmm1 {k1}{z}, zmm2/m512/m32bcst /// public static Vector512 LeadingZeroCount(Vector512 value) => LeadingZeroCount(value); /// - /// __m512i _mm512_lzcnt_epi64 (__m512i a) - /// VPLZCNTQ zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512i _mm512_lzcnt_epi64 (__m512i a) + /// VPLZCNTQ zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 LeadingZeroCount(Vector512 value) => LeadingZeroCount(value); /// - /// __m512i _mm512_lzcnt_epi64 (__m512i a) - /// VPLZCNTQ zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512i _mm512_lzcnt_epi64 (__m512i a) + /// VPLZCNTQ zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 LeadingZeroCount(Vector512 value) => LeadingZeroCount(value); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512DQ.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512DQ.PlatformNotSupported.cs index 305e7333dbc..b6a88f3bfe9 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512DQ.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512DQ.PlatformNotSupported.cs @@ -8,561 +8,572 @@ namespace System.Runtime.Intrinsics.X86 { - /// This class provides access to X86 AVX512DQ hardware instructions via intrinsics + /// Provides access to X86 AVX512DQ hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Avx512DQ : Avx512F { internal Avx512DQ() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } + /// Provides access to the x86 AVX512DQ+VL hardware instructions via intrinsics. public new abstract class VL : Avx512F.VL { internal VL() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } /// - /// __m128i _mm_broadcast_i32x2 (__m128i a) - /// VBROADCASTI32x2 xmm1 {k1}{z}, xmm2/m64 + /// __m128i _mm_broadcast_i32x2 (__m128i a) + /// VBROADCASTI32x2 xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 BroadcastPairScalarToVector128(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_broadcast_i32x2 (__m128i a) - /// VBROADCASTI32x2 xmm1 {k1}{z}, xmm2/m64 + /// __m128i _mm_broadcast_i32x2 (__m128i a) + /// VBROADCASTI32x2 xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 BroadcastPairScalarToVector128(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcast_i32x2 (__m128i a) - /// VBROADCASTI32x2 ymm1 {k1}{z}, xmm2/m64 + /// __m256i _mm256_broadcast_i32x2 (__m128i a) + /// VBROADCASTI32x2 ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 BroadcastPairScalarToVector256(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_broadcast_i32x2 (__m128i a) - /// VBROADCASTI32x2 ymm1 {k1}{z}, xmm2/m64 + /// __m256i _mm256_broadcast_i32x2 (__m128i a) + /// VBROADCASTI32x2 ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 BroadcastPairScalarToVector256(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_broadcast_f32x2 (__m128 a) - /// VBROADCASTF32x2 ymm1 {k1}{z}, xmm2/m64 + /// __m256 _mm256_broadcast_f32x2 (__m128 a) + /// VBROADCASTF32x2 ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 BroadcastPairScalarToVector256(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cvtepi64_pd (__m128i a) - /// VCVTQQ2PD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_cvtepi64_pd (__m128i a) + /// VCVTQQ2PD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Double(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cvtepu64_pd (__m128i a) - /// VCVTUQQ2PD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_cvtepu64_pd (__m128i a) + /// VCVTUQQ2PD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Double(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtps_epi64 (__m128 a) - /// VCVTPS2QQ xmm1 {k1}{z}, xmm2/m64/m32bcst + /// __m128i _mm_cvtps_epi64 (__m128 a) + /// VCVTPS2QQ xmm1 {k1}{z}, xmm2/m64/m32bcst /// public static Vector128 ConvertToVector128Int64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtpd_epi64 (__m128d a) - /// VCVTPD2QQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvtpd_epi64 (__m128d a) + /// VCVTPD2QQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Int64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvttps_epi64 (__m128 a) - /// VCVTTPS2QQ xmm1 {k1}{z}, xmm2/m64/m32bcst + /// __m128i _mm_cvttps_epi64 (__m128 a) + /// VCVTTPS2QQ xmm1 {k1}{z}, xmm2/m64/m32bcst /// public static Vector128 ConvertToVector128Int64WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvttpd_epi64 (__m128d a) - /// VCVTTPD2QQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvttpd_epi64 (__m128d a) + /// VCVTTPD2QQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Int64WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cvtepi64_ps (__m128i a) - /// VCVTQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128 _mm_cvtepi64_ps (__m128i a) + /// VCVTQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Single(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm256_cvtepi64_ps (__m256i a) - /// VCVTQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcst + /// __m128 _mm256_cvtepi64_ps (__m256i a) + /// VCVTQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector128 ConvertToVector128Single(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cvtepu64_ps (__m128i a) - /// VCVTUQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128 _mm_cvtepu64_ps (__m128i a) + /// VCVTUQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Single(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm256_cvtepu64_ps (__m256i a) - /// VCVTUQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcst + /// __m128 _mm256_cvtepu64_ps (__m256i a) + /// VCVTUQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector128 ConvertToVector128Single(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtps_epu64 (__m128 a) - /// VCVTPS2UQQ xmm1 {k1}{z}, xmm2/m64/m32bcst + /// __m128i _mm_cvtps_epu64 (__m128 a) + /// VCVTPS2UQQ xmm1 {k1}{z}, xmm2/m64/m32bcst /// public static Vector128 ConvertToVector128UInt64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtpd_epu64 (__m128d a) - /// VCVTPD2UQQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvtpd_epu64 (__m128d a) + /// VCVTPD2UQQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128UInt64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvttps_epu64 (__m128 a) - /// VCVTTPS2UQQ xmm1 {k1}{z}, xmm2/m64/m32bcst + /// __m128i _mm_cvttps_epu64 (__m128 a) + /// VCVTTPS2UQQ xmm1 {k1}{z}, xmm2/m64/m32bcst /// public static Vector128 ConvertToVector128UInt64WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvttpd_epu64 (__m128d a) - /// VCVTTPD2UQQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvttpd_epu64 (__m128d a) + /// VCVTTPD2UQQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128UInt64WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_cvtepi64_pd (__m256i a) - /// VCVTQQ2PD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_cvtepi64_pd (__m256i a) + /// VCVTQQ2PD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ConvertToVector256Double(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_cvtepu64_pd (__m256i a) - /// VCVTUQQ2PD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_cvtepu64_pd (__m256i a) + /// VCVTUQQ2PD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ConvertToVector256Double(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvtps_epi64 (__m128 a) - /// VCVTPS2QQ ymm1 {k1}{z}, xmm2/m128/m32bcst + /// __m256i _mm256_cvtps_epi64 (__m128 a) + /// VCVTPS2QQ ymm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector256 ConvertToVector256Int64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvtpd_epi64 (__m256d a) - /// VCVTPD2QQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_cvtpd_epi64 (__m256d a) + /// VCVTPD2QQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ConvertToVector256Int64(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvttps_epi64 (__m128 a) - /// VCVTTPS2QQ ymm1 {k1}{z}, xmm2/m128/m32bcst + /// __m256i _mm256_cvttps_epi64 (__m128 a) + /// VCVTTPS2QQ ymm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector256 ConvertToVector256Int64WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvttpd_epi64 (__m256d a) - /// VCVTTPD2QQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_cvttpd_epi64 (__m256d a) + /// VCVTTPD2QQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ConvertToVector256Int64WithTruncation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvtps_epu64 (__m128 a) - /// VCVTPS2UQQ ymm1 {k1}{z}, xmm2/m128/m32bcst + /// __m256i _mm256_cvtps_epu64 (__m128 a) + /// VCVTPS2UQQ ymm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector256 ConvertToVector256UInt64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvtpd_epu64 (__m256d a) - /// VCVTPD2UQQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_cvtpd_epu64 (__m256d a) + /// VCVTPD2UQQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ConvertToVector256UInt64(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvttps_epu64 (__m128 a) - /// VCVTTPS2UQQ ymm1 {k1}{z}, xmm2/m128/m32bcst + /// __m256i _mm256_cvttps_epu64 (__m128 a) + /// VCVTTPS2UQQ ymm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector256 ConvertToVector256UInt64WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvttpd_epu64 (__m256d a) - /// VCVTTPD2UQQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_cvttpd_epu64 (__m256d a) + /// VCVTTPD2UQQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ConvertToVector256UInt64WithTruncation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_mullo_epi64 (__m128i a, __m128i b) - /// VPMULLQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_mullo_epi64 (__m128i a, __m128i b) + /// VPMULLQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiplyLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_mullo_epi64 (__m128i a, __m128i b) - /// VPMULLQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_mullo_epi64 (__m128i a, __m128i b) + /// VPMULLQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiplyLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_mullo_epi64 (__m256i a, __m256i b) - /// VPMULLQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_mullo_epi64 (__m256i a, __m256i b) + /// VPMULLQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiplyLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_mullo_epi64 (__m256i a, __m256i b) - /// VPMULLQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_mullo_epi64 (__m256i a, __m256i b) + /// VPMULLQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiplyLow(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_range_ps(__m128 a, __m128 b, int imm); - /// VRANGEPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128 _mm_range_ps(__m128 a, __m128 b, int imm); + /// VRANGEPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 Range(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_range_pd(__m128d a, __m128d b, int imm); - /// VRANGEPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128d _mm_range_pd(__m128d a, __m128d b, int imm); + /// VRANGEPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 Range(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_range_ps(__m256 a, __m256 b, int imm); - /// VRANGEPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256 _mm256_range_ps(__m256 a, __m256 b, int imm); + /// VRANGEPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 Range(Vector256 left, Vector256 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_range_pd(__m256d a, __m256d b, int imm); - /// VRANGEPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256d _mm256_range_pd(__m256d a, __m256d b, int imm); + /// VRANGEPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 Range(Vector256 left, Vector256 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_reduce_ps(__m128 a, int imm); - /// VREDUCEPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128 _mm_reduce_ps(__m128 a, int imm); + /// VREDUCEPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 Reduce(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_reduce_pd(__m128d a, int imm); - /// VREDUCEPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128d _mm_reduce_pd(__m128d a, int imm); + /// VREDUCEPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 Reduce(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_reduce_ps(__m256 a, int imm); - /// VREDUCEPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256 _mm256_reduce_ps(__m256 a, int imm); + /// VREDUCEPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 Reduce(Vector256 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_reduce_pd(__m256d a, int imm); - /// VREDUCEPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256d _mm256_reduce_pd(__m256d a, int imm); + /// VREDUCEPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 Reduce(Vector256 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } } + /// Provides access to the x86 AVX512DQ hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class X64 : Avx512F.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } } /// - /// __m512 _mm512_and_ps (__m512 a, __m512 b) - /// VANDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_and_ps (__m512 a, __m512 b) + /// VANDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 And(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_and_pd (__m512d a, __m512d b) - /// VANDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_and_pd (__m512d a, __m512d b) + /// VANDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 And(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_andnot_ps (__m512 a, __m512 b) - /// VANDNPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_andnot_ps (__m512 a, __m512 b) + /// VANDNPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 AndNot(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_andnot_pd (__m512d a, __m512d b) - /// VANDNPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_andnot_pd (__m512d a, __m512d b) + /// VANDNPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 AndNot(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_broadcast_i32x2 (__m128i a) - /// VBROADCASTI32x2 zmm1 {k1}{z}, xmm2/m64 + /// __m512i _mm512_broadcast_i32x2 (__m128i a) + /// VBROADCASTI32x2 zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 BroadcastPairScalarToVector512(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_broadcast_i32x2 (__m128i a) - /// VBROADCASTI32x2 zmm1 {k1}{z}, xmm2/m64 + /// __m512i _mm512_broadcast_i32x2 (__m128i a) + /// VBROADCASTI32x2 zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 BroadcastPairScalarToVector512(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_broadcast_f32x2 (__m128 a) - /// VBROADCASTF32x2 zmm1 {k1}{z}, xmm2/m64 + /// __m512 _mm512_broadcast_f32x2 (__m128 a) + /// VBROADCASTF32x2 zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 BroadcastPairScalarToVector512(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_broadcast_i64x2 (__m128i const * mem_addr) - /// VBROADCASTI64x2 zmm1 {k1}{z}, m128 + /// __m512i _mm512_broadcast_i64x2 (__m128i const * mem_addr) + /// VBROADCASTI64x2 zmm1 {k1}{z}, m128 /// public static unsafe Vector512 BroadcastVector128ToVector512(long* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_broadcast_i64x2 (__m128i const * mem_addr) - /// VBROADCASTI64x2 zmm1 {k1}{z}, m128 + /// __m512i _mm512_broadcast_i64x2 (__m128i const * mem_addr) + /// VBROADCASTI64x2 zmm1 {k1}{z}, m128 /// public static unsafe Vector512 BroadcastVector128ToVector512(ulong* address) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_broadcast_f64x2 (__m128d const * mem_addr) - /// VBROADCASTF64x2 zmm1 {k1}{z}, m128 + /// __m512d _mm512_broadcast_f64x2 (__m128d const * mem_addr) + /// VBROADCASTF64x2 zmm1 {k1}{z}, m128 /// public static unsafe Vector512 BroadcastVector128ToVector512(double* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_broadcast_i32x8 (__m256i const * mem_addr) - /// VBROADCASTI32x8 zmm1 {k1}{z}, m256 + /// __m512i _mm512_broadcast_i32x8 (__m256i const * mem_addr) + /// VBROADCASTI32x8 zmm1 {k1}{z}, m256 /// public static unsafe Vector512 BroadcastVector256ToVector512(int* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_broadcast_i32x8 (__m256i const * mem_addr) - /// VBROADCASTI32x8 zmm1 {k1}{z}, m256 + /// __m512i _mm512_broadcast_i32x8 (__m256i const * mem_addr) + /// VBROADCASTI32x8 zmm1 {k1}{z}, m256 /// public static unsafe Vector512 BroadcastVector256ToVector512(uint* address) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_broadcast_f32x8 (__m256 const * mem_addr) - /// VBROADCASTF32x8 zmm1 {k1}{z}, m256 + /// __m512 _mm512_broadcast_f32x8 (__m256 const * mem_addr) + /// VBROADCASTF32x8 zmm1 {k1}{z}, m256 /// public static unsafe Vector512 BroadcastVector256ToVector512(float* address) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_cvtepi64_ps (__m512i a) - /// VCVTQQ2PS ymm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512 _mm512_cvtepi64_ps (__m512i a) + /// VCVTQQ2PS ymm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector256 ConvertToVector256Single(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_cvtepu64_ps (__m512i a) - /// VCVTUQQ2PS ymm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512 _mm512_cvtepu64_ps (__m512i a) + /// VCVTUQQ2PS ymm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector256 ConvertToVector256Single(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm512_cvt_roundepi64_ps (__m512i a, int r) - /// VCVTQQ2PS ymm1, zmm2 {er} + /// __m256 _mm512_cvt_roundepi64_ps (__m512i a, int r) + /// VCVTQQ2PS ymm1, zmm2 {er} /// public static Vector256 ConvertToVector256Single(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm512_cvt_roundepu64_ps (__m512i a, int r) - /// VCVTUQQ2PS ymm1, zmm2 {er} + /// __m256 _mm512_cvt_roundepu64_ps (__m512i a, int r) + /// VCVTUQQ2PS ymm1, zmm2 {er} /// public static Vector256 ConvertToVector256Single(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_cvtepi64_pd (__m512i a) - /// VCVTQQ2PD zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512d _mm512_cvtepi64_pd (__m512i a) + /// VCVTQQ2PD zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 ConvertToVector512Double(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_cvtepu64_pd (__m512i a) - /// VCVTUQQ2PD zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512d _mm512_cvtepu64_pd (__m512i a) + /// VCVTUQQ2PD zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 ConvertToVector512Double(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_cvt_roundepi64_pd (__m512i a, int r) - /// VCVTQQ2PD zmm1, zmm2 {er} + /// __m512d _mm512_cvt_roundepi64_pd (__m512i a, int r) + /// VCVTQQ2PD zmm1, zmm2 {er} /// public static Vector512 ConvertToVector512Double(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_cvt_roundepu64_pd (__m512i a, int r) - /// VCVTUQQ2PD zmm1, zmm2 {er} + /// __m512d _mm512_cvt_roundepu64_pd (__m512i a, int r) + /// VCVTUQQ2PD zmm1, zmm2 {er} /// public static Vector512 ConvertToVector512Double(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtps_epi64 (__m512 a) - /// VCVTPS2QQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} + /// __m512i _mm512_cvtps_epi64 (__m512 a) + /// VCVTPS2QQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} /// public static Vector512 ConvertToVector512Int64(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtpd_epi64 (__m512d a) - /// VCVTPD2QQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m512i _mm512_cvtpd_epi64 (__m512d a) + /// VCVTPD2QQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector512 ConvertToVector512Int64(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvt_roundps_epi64 (__m512 a, int r) - /// VCVTPS2QQ zmm1, ymm2 {er} + /// __m512i _mm512_cvt_roundps_epi64 (__m512 a, int r) + /// VCVTPS2QQ zmm1, ymm2 {er} /// public static Vector512 ConvertToVector512Int64(Vector256 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvt_roundpd_epi64 (__m512d a, int r) - /// VCVTPD2QQ zmm1, zmm2 {er} + /// __m512i _mm512_cvt_roundpd_epi64 (__m512d a, int r) + /// VCVTPD2QQ zmm1, zmm2 {er} /// public static Vector512 ConvertToVector512Int64(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvttps_epi64 (__m512 a) - /// VCVTTPS2QQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} + /// __m512i _mm512_cvttps_epi64 (__m512 a) + /// VCVTTPS2QQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} /// public static Vector512 ConvertToVector512Int64WithTruncation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvttpd_epi64 (__m512 a) - /// VCVTTPD2QQ zmm1 {k1}{z}, zmm2/m512/m64bcst{sae} + /// __m512i _mm512_cvttpd_epi64 (__m512 a) + /// VCVTTPD2QQ zmm1 {k1}{z}, zmm2/m512/m64bcst{sae} /// public static Vector512 ConvertToVector512Int64WithTruncation(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtps_epu64 (__m512 a) - /// VCVTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} + /// __m512i _mm512_cvtps_epu64 (__m512 a) + /// VCVTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} /// public static Vector512 ConvertToVector512UInt64(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtpd_epu64 (__m512d a) - /// VCVTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m512i _mm512_cvtpd_epu64 (__m512d a) + /// VCVTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector512 ConvertToVector512UInt64(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvt_roundps_epu64 (__m512 a, int r) - /// VCVTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} + /// __m512i _mm512_cvt_roundps_epu64 (__m512 a, int r) + /// VCVTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} /// public static Vector512 ConvertToVector512UInt64(Vector256 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvt_roundpd_epu64 (__m512d a, int r) - /// VCVTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m512i _mm512_cvt_roundpd_epu64 (__m512d a, int r) + /// VCVTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector512 ConvertToVector512UInt64(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvttps_epu64 (__m512 a) - /// VCVTTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} + /// __m512i _mm512_cvttps_epu64 (__m512 a) + /// VCVTTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} /// public static Vector512 ConvertToVector512UInt64WithTruncation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvttpd_epu64 (__m512d a) - /// VCVTTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m512i _mm512_cvttpd_epu64 (__m512d a) + /// VCVTTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector512 ConvertToVector512UInt64WithTruncation(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_extracti64x2_epi64 (__m512i a, const int imm8) - /// VEXTRACTI64x2 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128i _mm512_extracti64x2_epi64 (__m512i a, const int imm8) + /// VEXTRACTI64x2 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static new Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_extracti64x2_epi64 (__m512i a, const int imm8) - /// VEXTRACTI64x2 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128i _mm512_extracti64x2_epi64 (__m512i a, const int imm8) + /// VEXTRACTI64x2 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static new Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm512_extractf64x2_pd (__m512d a, const int imm8) - /// VEXTRACTF64x2 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128d _mm512_extractf64x2_pd (__m512d a, const int imm8) + /// VEXTRACTF64x2 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static new Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_extracti32x8_epi32 (__m512i a, const int imm8) - /// VEXTRACTI32x8 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256i _mm512_extracti32x8_epi32 (__m512i a, const int imm8) + /// VEXTRACTI32x8 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static new Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_extracti32x8_epi32 (__m512i a, const int imm8) - /// VEXTRACTI32x8 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256i _mm512_extracti32x8_epi32 (__m512i a, const int imm8) + /// VEXTRACTI32x8 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static new Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm512_extractf32x8_ps (__m512 a, const int imm8) - /// VEXTRACTF32x8 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256 _mm512_extractf32x8_ps (__m512 a, const int imm8) + /// VEXTRACTF32x8 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static new Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_inserti64x2_si512 (__m512i a, __m128i b, const int imm8) - /// VINSERTI64x2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512i _mm512_inserti64x2_si512 (__m512i a, __m128i b, const int imm8) + /// VINSERTI64x2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static new Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_inserti64x2_si512 (__m512i a, __m128i b, const int imm8) - /// VINSERTI64x2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512i _mm512_inserti64x2_si512 (__m512i a, __m128i b, const int imm8) + /// VINSERTI64x2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static new Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_insertf64x2_pd (__m512d a, __m128d b, int imm8) - /// VINSERTF64x2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512d _mm512_insertf64x2_pd (__m512d a, __m128d b, int imm8) + /// VINSERTF64x2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static new Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_inserti32x8_si512 (__m512i a, __m256i b, const int imm8) - /// VINSERTI32x8 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512i _mm512_inserti32x8_si512 (__m512i a, __m256i b, const int imm8) + /// VINSERTI32x8 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static new Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_inserti32x8_si512 (__m512i a, __m256i b, const int imm8) - /// VINSERTI32x8 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512i _mm512_inserti32x8_si512 (__m512i a, __m256i b, const int imm8) + /// VINSERTI32x8 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static new Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_insertf32x8_ps (__m512 a, __m256 b, int imm8) - /// VINSERTF32x8 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512 _mm512_insertf32x8_ps (__m512 a, __m256 b, int imm8) + /// VINSERTF32x8 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static new Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_mullo_epi64 (__m512i a, __m512i b) - /// VPMULLQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_mullo_epi64 (__m512i a, __m512i b) + /// VPMULLQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 MultiplyLow(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_mullo_epi64 (__m512i a, __m512i b) - /// VPMULLQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_mullo_epi64 (__m512i a, __m512i b) + /// VPMULLQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 MultiplyLow(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_or_ps (__m512 a, __m512 b) - /// VORPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_or_ps (__m512 a, __m512 b) + /// VORPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Or(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_or_pd (__m512d a, __m512d b) - /// VORPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_or_pd (__m512d a, __m512d b) + /// VORPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Or(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_range_ps(__m512 a, __m512 b, int imm); - /// VRANGEPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}, imm8 + /// __m512 _mm512_range_ps(__m512 a, __m512 b, int imm); + /// VRANGEPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}, imm8 /// public static Vector512 Range(Vector512 left, Vector512 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_range_pd(__m512d a, __m512d b, int imm); - /// VRANGEPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}, imm8 + /// __m512d _mm512_range_pd(__m512d a, __m512d b, int imm); + /// VRANGEPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}, imm8 /// public static Vector512 Range(Vector512 left, Vector512 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_range_ss(__m128 a, __m128 b, int imm); - /// VRANGESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 + /// __m128 _mm_range_ss(__m128 a, __m128 b, int imm); + /// VRANGESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 /// public static Vector128 RangeScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_range_sd(__m128d a, __m128d b, int imm); - /// VRANGESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 + /// __m128d _mm_range_sd(__m128d a, __m128d b, int imm); + /// VRANGESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 /// public static Vector128 RangeScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_reduce_ps(__m512 a, int imm); - /// VREDUCEPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}, imm8 + /// __m512 _mm512_reduce_ps(__m512 a, int imm); + /// VREDUCEPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}, imm8 /// public static Vector512 Reduce(Vector512 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_reduce_pd(__m512d a, int imm); - /// VREDUCEPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}, imm8 + /// __m512d _mm512_reduce_pd(__m512d a, int imm); + /// VREDUCEPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}, imm8 /// public static Vector512 Reduce(Vector512 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_reduce_ss(__m128 a, int imm); - /// VREDUCESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 + /// __m128 _mm_reduce_ss(__m128 a, int imm); + /// VREDUCESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 /// public static Vector128 ReduceScalar(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_reduce_sd(__m128d a, int imm); - /// VREDUCESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 + /// __m128d _mm_reduce_sd(__m128d a, int imm); + /// VREDUCESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 /// public static Vector128 ReduceScalar(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_reduce_ss(__m128 a, __m128 b, int imm); - /// VREDUCESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_reduce_ss(__m128 a, __m128 b, int imm); + /// VREDUCESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 ReduceScalar(Vector128 upper, Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_reduce_sd(__m128d a, __m128d b, int imm); - /// VREDUCESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128d _mm_reduce_sd(__m128d a, __m128d b, int imm); + /// VREDUCESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 ReduceScalar(Vector128 upper, Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_xor_ps (__m512 a, __m512 b) - /// VXORPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_xor_ps (__m512 a, __m512 b) + /// VXORPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Xor(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_xor_pd (__m512d a, __m512d b) - /// VXORPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_xor_pd (__m512d a, __m512d b) + /// VXORPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Xor(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512DQ.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512DQ.cs index 403a851dbd1..abcd3a38f3f 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512DQ.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512DQ.cs @@ -6,567 +6,578 @@ namespace System.Runtime.Intrinsics.X86 { - /// This class provides access to X86 AVX512DQ hardware instructions via intrinsics + /// Provides access to X86 AVX512DQ hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Avx512DQ : Avx512F { internal Avx512DQ() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the x86 AVX512DQ+VL hardware instructions via intrinsics. [Intrinsic] public new abstract class VL : Avx512F.VL { internal VL() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } /// - /// __m128i _mm_broadcast_i32x2 (__m128i a) - /// VBROADCASTI32x2 xmm1 {k1}{z}, xmm2/m64 + /// __m128i _mm_broadcast_i32x2 (__m128i a) + /// VBROADCASTI32x2 xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 BroadcastPairScalarToVector128(Vector128 value) => BroadcastPairScalarToVector128(value); /// - /// __m128i _mm_broadcast_i32x2 (__m128i a) - /// VBROADCASTI32x2 xmm1 {k1}{z}, xmm2/m64 + /// __m128i _mm_broadcast_i32x2 (__m128i a) + /// VBROADCASTI32x2 xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 BroadcastPairScalarToVector128(Vector128 value) => BroadcastPairScalarToVector128(value); /// - /// __m256i _mm256_broadcast_i32x2 (__m128i a) - /// VBROADCASTI32x2 ymm1 {k1}{z}, xmm2/m64 + /// __m256i _mm256_broadcast_i32x2 (__m128i a) + /// VBROADCASTI32x2 ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 BroadcastPairScalarToVector256(Vector128 value) => BroadcastPairScalarToVector256(value); /// - /// __m256i _mm256_broadcast_i32x2 (__m128i a) - /// VBROADCASTI32x2 ymm1 {k1}{z}, xmm2/m64 + /// __m256i _mm256_broadcast_i32x2 (__m128i a) + /// VBROADCASTI32x2 ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 BroadcastPairScalarToVector256(Vector128 value) => BroadcastPairScalarToVector256(value); /// - /// __m256 _mm256_broadcast_f32x2 (__m128 a) - /// VBROADCASTF32x2 ymm1 {k1}{z}, xmm2/m64 + /// __m256 _mm256_broadcast_f32x2 (__m128 a) + /// VBROADCASTF32x2 ymm1 {k1}{z}, xmm2/m64 /// public static Vector256 BroadcastPairScalarToVector256(Vector128 value) => BroadcastPairScalarToVector256(value); /// - /// __m128d _mm_cvtepi64_pd (__m128i a) - /// VCVTQQ2PD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_cvtepi64_pd (__m128i a) + /// VCVTQQ2PD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Double(Vector128 value) => ConvertToVector128Double(value); /// - /// __m128d _mm_cvtepu64_pd (__m128i a) - /// VCVTUQQ2PD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_cvtepu64_pd (__m128i a) + /// VCVTUQQ2PD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Double(Vector128 value) => ConvertToVector128Double(value); /// - /// __m128i _mm_cvtps_epi64 (__m128 a) - /// VCVTPS2QQ xmm1 {k1}{z}, xmm2/m64/m32bcst + /// __m128i _mm_cvtps_epi64 (__m128 a) + /// VCVTPS2QQ xmm1 {k1}{z}, xmm2/m64/m32bcst /// public static Vector128 ConvertToVector128Int64(Vector128 value) => ConvertToVector128Int64(value); /// - /// __m128i _mm_cvtpd_epi64 (__m128d a) - /// VCVTPD2QQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvtpd_epi64 (__m128d a) + /// VCVTPD2QQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Int64(Vector128 value) => ConvertToVector128Int64(value); /// - /// __m128i _mm_cvttps_epi64 (__m128 a) - /// VCVTTPS2QQ xmm1 {k1}{z}, xmm2/m64/m32bcst + /// __m128i _mm_cvttps_epi64 (__m128 a) + /// VCVTTPS2QQ xmm1 {k1}{z}, xmm2/m64/m32bcst /// public static Vector128 ConvertToVector128Int64WithTruncation(Vector128 value) => ConvertToVector128Int64WithTruncation(value); /// - /// __m128i _mm_cvttpd_epi64 (__m128d a) - /// VCVTTPD2QQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvttpd_epi64 (__m128d a) + /// VCVTTPD2QQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Int64WithTruncation(Vector128 value) => ConvertToVector128Int64WithTruncation(value); /// - /// __m128 _mm_cvtepi64_ps (__m128i a) - /// VCVTQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128 _mm_cvtepi64_ps (__m128i a) + /// VCVTQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Single(Vector128 value) => ConvertToVector128Single(value); /// - /// __m128 _mm256_cvtepi64_ps (__m256i a) - /// VCVTQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcst + /// __m128 _mm256_cvtepi64_ps (__m256i a) + /// VCVTQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector128 ConvertToVector128Single(Vector256 value) => ConvertToVector128Single(value); /// - /// __m128 _mm_cvtepu64_ps (__m128i a) - /// VCVTUQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128 _mm_cvtepu64_ps (__m128i a) + /// VCVTUQQ2PS xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Single(Vector128 value) => ConvertToVector128Single(value); /// - /// __m128 _mm256_cvtepu64_ps (__m256i a) - /// VCVTUQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcst + /// __m128 _mm256_cvtepu64_ps (__m256i a) + /// VCVTUQQ2PS xmm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector128 ConvertToVector128Single(Vector256 value) => ConvertToVector128Single(value); /// - /// __m128i _mm_cvtps_epu64 (__m128 a) - /// VCVTPS2UQQ xmm1 {k1}{z}, xmm2/m64/m32bcst + /// __m128i _mm_cvtps_epu64 (__m128 a) + /// VCVTPS2UQQ xmm1 {k1}{z}, xmm2/m64/m32bcst /// public static Vector128 ConvertToVector128UInt64(Vector128 value) => ConvertToVector128UInt64(value); /// - /// __m128i _mm_cvtpd_epu64 (__m128d a) - /// VCVTPD2UQQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvtpd_epu64 (__m128d a) + /// VCVTPD2UQQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128UInt64(Vector128 value) => ConvertToVector128UInt64(value); /// - /// __m128i _mm_cvttps_epu64 (__m128 a) - /// VCVTTPS2UQQ xmm1 {k1}{z}, xmm2/m64/m32bcst + /// __m128i _mm_cvttps_epu64 (__m128 a) + /// VCVTTPS2UQQ xmm1 {k1}{z}, xmm2/m64/m32bcst /// public static Vector128 ConvertToVector128UInt64WithTruncation(Vector128 value) => ConvertToVector128UInt64WithTruncation(value); /// - /// __m128i _mm_cvttpd_epu64 (__m128d a) - /// VCVTTPD2UQQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvttpd_epu64 (__m128d a) + /// VCVTTPD2UQQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128UInt64WithTruncation(Vector128 value) => ConvertToVector128UInt64WithTruncation(value); /// - /// __m256d _mm256_cvtepi64_pd (__m256i a) - /// VCVTQQ2PD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_cvtepi64_pd (__m256i a) + /// VCVTQQ2PD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ConvertToVector256Double(Vector256 value) => ConvertToVector256Double(value); /// - /// __m256d _mm256_cvtepu64_pd (__m256i a) - /// VCVTUQQ2PD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_cvtepu64_pd (__m256i a) + /// VCVTUQQ2PD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ConvertToVector256Double(Vector256 value) => ConvertToVector256Double(value); /// - /// __m256i _mm256_cvtps_epi64 (__m128 a) - /// VCVTPS2QQ ymm1 {k1}{z}, xmm2/m128/m32bcst + /// __m256i _mm256_cvtps_epi64 (__m128 a) + /// VCVTPS2QQ ymm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector256 ConvertToVector256Int64(Vector128 value) => ConvertToVector256Int64(value); /// - /// __m256i _mm256_cvtpd_epi64 (__m256d a) - /// VCVTPD2QQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_cvtpd_epi64 (__m256d a) + /// VCVTPD2QQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ConvertToVector256Int64(Vector256 value) => ConvertToVector256Int64(value); /// - /// __m256i _mm256_cvttps_epi64 (__m128 a) - /// VCVTTPS2QQ ymm1 {k1}{z}, xmm2/m128/m32bcst + /// __m256i _mm256_cvttps_epi64 (__m128 a) + /// VCVTTPS2QQ ymm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector256 ConvertToVector256Int64WithTruncation(Vector128 value) => ConvertToVector256Int64WithTruncation(value); /// - /// __m256i _mm256_cvttpd_epi64 (__m256d a) - /// VCVTTPD2QQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_cvttpd_epi64 (__m256d a) + /// VCVTTPD2QQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ConvertToVector256Int64WithTruncation(Vector256 value) => ConvertToVector256Int64WithTruncation(value); /// - /// __m256i _mm256_cvtps_epu64 (__m128 a) - /// VCVTPS2UQQ ymm1 {k1}{z}, xmm2/m128/m32bcst + /// __m256i _mm256_cvtps_epu64 (__m128 a) + /// VCVTPS2UQQ ymm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector256 ConvertToVector256UInt64(Vector128 value) => ConvertToVector256UInt64(value); /// - /// __m256i _mm256_cvtpd_epu64 (__m256d a) - /// VCVTPD2UQQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_cvtpd_epu64 (__m256d a) + /// VCVTPD2UQQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ConvertToVector256UInt64(Vector256 value) => ConvertToVector256UInt64(value); /// - /// __m256i _mm256_cvttps_epu64 (__m128 a) - /// VCVTTPS2UQQ ymm1 {k1}{z}, xmm2/m128/m32bcst + /// __m256i _mm256_cvttps_epu64 (__m128 a) + /// VCVTTPS2UQQ ymm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector256 ConvertToVector256UInt64WithTruncation(Vector128 value) => ConvertToVector256UInt64WithTruncation(value); /// - /// __m256i _mm256_cvttpd_epu64 (__m256d a) - /// VCVTTPD2UQQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_cvttpd_epu64 (__m256d a) + /// VCVTTPD2UQQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ConvertToVector256UInt64WithTruncation(Vector256 value) => ConvertToVector256UInt64WithTruncation(value); /// - /// __m128i _mm_mullo_epi64 (__m128i a, __m128i b) - /// VPMULLQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_mullo_epi64 (__m128i a, __m128i b) + /// VPMULLQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiplyLow(Vector128 left, Vector128 right) => MultiplyLow(left, right); /// - /// __m128i _mm_mullo_epi64 (__m128i a, __m128i b) - /// VPMULLQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_mullo_epi64 (__m128i a, __m128i b) + /// VPMULLQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiplyLow(Vector128 left, Vector128 right) => MultiplyLow(left, right); /// - /// __m256i _mm256_mullo_epi64 (__m256i a, __m256i b) - /// VPMULLQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_mullo_epi64 (__m256i a, __m256i b) + /// VPMULLQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiplyLow(Vector256 left, Vector256 right) => MultiplyLow(left, right); /// - /// __m256i _mm256_mullo_epi64 (__m256i a, __m256i b) - /// VPMULLQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_mullo_epi64 (__m256i a, __m256i b) + /// VPMULLQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiplyLow(Vector256 left, Vector256 right) => MultiplyLow(left, right); /// - /// __m128 _mm_range_ps(__m128 a, __m128 b, int imm); - /// VRANGEPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128 _mm_range_ps(__m128 a, __m128 b, int imm); + /// VRANGEPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 Range(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => Range(left, right, control); /// - /// __m128d _mm_range_pd(__m128d a, __m128d b, int imm); - /// VRANGEPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128d _mm_range_pd(__m128d a, __m128d b, int imm); + /// VRANGEPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 Range(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => Range(left, right, control); /// - /// __m256 _mm256_range_ps(__m256 a, __m256 b, int imm); - /// VRANGEPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256 _mm256_range_ps(__m256 a, __m256 b, int imm); + /// VRANGEPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 Range(Vector256 left, Vector256 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => Range(left, right, control); /// - /// __m256d _mm256_range_pd(__m256d a, __m256d b, int imm); - /// VRANGEPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256d _mm256_range_pd(__m256d a, __m256d b, int imm); + /// VRANGEPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 Range(Vector256 left, Vector256 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => Range(left, right, control); /// - /// __m128 _mm_reduce_ps(__m128 a, int imm); - /// VREDUCEPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128 _mm_reduce_ps(__m128 a, int imm); + /// VREDUCEPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 Reduce(Vector128 value, [ConstantExpected] byte control) => Reduce(value, control); /// - /// __m128d _mm_reduce_pd(__m128d a, int imm); - /// VREDUCEPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128d _mm_reduce_pd(__m128d a, int imm); + /// VREDUCEPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 Reduce(Vector128 value, [ConstantExpected] byte control) => Reduce(value, control); /// - /// __m256 _mm256_reduce_ps(__m256 a, int imm); - /// VREDUCEPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256 _mm256_reduce_ps(__m256 a, int imm); + /// VREDUCEPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 Reduce(Vector256 value, [ConstantExpected] byte control) => Reduce(value, control); /// - /// __m256d _mm256_reduce_pd(__m256d a, int imm); - /// VREDUCEPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256d _mm256_reduce_pd(__m256d a, int imm); + /// VREDUCEPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 Reduce(Vector256 value, [ConstantExpected] byte control) => Reduce(value, control); } + /// Provides access to the x86 AVX512DQ hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : Avx512F.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } } /// - /// __m512 _mm512_and_ps (__m512 a, __m512 b) - /// VANDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_and_ps (__m512 a, __m512 b) + /// VANDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 And(Vector512 left, Vector512 right) => And(left, right); /// - /// __m512d _mm512_and_pd (__m512d a, __m512d b) - /// VANDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_and_pd (__m512d a, __m512d b) + /// VANDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 And(Vector512 left, Vector512 right) => And(left, right); /// - /// __m512 _mm512_andnot_ps (__m512 a, __m512 b) - /// VANDNPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_andnot_ps (__m512 a, __m512 b) + /// VANDNPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 AndNot(Vector512 left, Vector512 right) => AndNot(left, right); /// - /// __m512d _mm512_andnot_pd (__m512d a, __m512d b) - /// VANDNPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_andnot_pd (__m512d a, __m512d b) + /// VANDNPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 AndNot(Vector512 left, Vector512 right) => AndNot(left, right); /// - /// __m512i _mm512_broadcast_i32x2 (__m128i a) - /// VBROADCASTI32x2 zmm1 {k1}{z}, xmm2/m64 + /// __m512i _mm512_broadcast_i32x2 (__m128i a) + /// VBROADCASTI32x2 zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 BroadcastPairScalarToVector512(Vector128 value) => BroadcastPairScalarToVector512(value); /// - /// __m512i _mm512_broadcast_i32x2 (__m128i a) - /// VBROADCASTI32x2 zmm1 {k1}{z}, xmm2/m64 + /// __m512i _mm512_broadcast_i32x2 (__m128i a) + /// VBROADCASTI32x2 zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 BroadcastPairScalarToVector512(Vector128 value) => BroadcastPairScalarToVector512(value); /// - /// __m512 _mm512_broadcast_f32x2 (__m128 a) - /// VBROADCASTF32x2 zmm1 {k1}{z}, xmm2/m64 + /// __m512 _mm512_broadcast_f32x2 (__m128 a) + /// VBROADCASTF32x2 zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 BroadcastPairScalarToVector512(Vector128 value) => BroadcastPairScalarToVector512(value); /// - /// __m512i _mm512_broadcast_i64x2 (__m128i const * mem_addr) - /// VBROADCASTI64x2 zmm1 {k1}{z}, m128 + /// __m512i _mm512_broadcast_i64x2 (__m128i const * mem_addr) + /// VBROADCASTI64x2 zmm1 {k1}{z}, m128 /// public static unsafe Vector512 BroadcastVector128ToVector512(long* address) => BroadcastVector128ToVector512(address); /// - /// __m512i _mm512_broadcast_i64x2 (__m128i const * mem_addr) - /// VBROADCASTI64x2 zmm1 {k1}{z}, m128 + /// __m512i _mm512_broadcast_i64x2 (__m128i const * mem_addr) + /// VBROADCASTI64x2 zmm1 {k1}{z}, m128 /// public static unsafe Vector512 BroadcastVector128ToVector512(ulong* address) => BroadcastVector128ToVector512(address); /// - /// __m512d _mm512_broadcast_f64x2 (__m128d const * mem_addr) - /// VBROADCASTF64x2 zmm1 {k1}{z}, m128 + /// __m512d _mm512_broadcast_f64x2 (__m128d const * mem_addr) + /// VBROADCASTF64x2 zmm1 {k1}{z}, m128 /// public static unsafe Vector512 BroadcastVector128ToVector512(double* address) => BroadcastVector128ToVector512(address); /// - /// __m512i _mm512_broadcast_i32x8 (__m256i const * mem_addr) - /// VBROADCASTI32x8 zmm1 {k1}{z}, m256 + /// __m512i _mm512_broadcast_i32x8 (__m256i const * mem_addr) + /// VBROADCASTI32x8 zmm1 {k1}{z}, m256 /// public static unsafe Vector512 BroadcastVector256ToVector512(int* address) => BroadcastVector256ToVector512(address); /// - /// __m512i _mm512_broadcast_i32x8 (__m256i const * mem_addr) - /// VBROADCASTI32x8 zmm1 {k1}{z}, m256 + /// __m512i _mm512_broadcast_i32x8 (__m256i const * mem_addr) + /// VBROADCASTI32x8 zmm1 {k1}{z}, m256 /// public static unsafe Vector512 BroadcastVector256ToVector512(uint* address) => BroadcastVector256ToVector512(address); /// - /// __m512 _mm512_broadcast_f32x8 (__m256 const * mem_addr) - /// VBROADCASTF32x8 zmm1 {k1}{z}, m256 + /// __m512 _mm512_broadcast_f32x8 (__m256 const * mem_addr) + /// VBROADCASTF32x8 zmm1 {k1}{z}, m256 /// public static unsafe Vector512 BroadcastVector256ToVector512(float* address) => BroadcastVector256ToVector512(address); /// - /// __m512 _mm512_cvtepi64_ps (__m512i a) - /// VCVTQQ2PS ymm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512 _mm512_cvtepi64_ps (__m512i a) + /// VCVTQQ2PS ymm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector256 ConvertToVector256Single(Vector512 value) => ConvertToVector256Single(value); /// - /// __m512 _mm512_cvtepu64_ps (__m512i a) - /// VCVTUQQ2PS ymm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512 _mm512_cvtepu64_ps (__m512i a) + /// VCVTUQQ2PS ymm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector256 ConvertToVector256Single(Vector512 value) => ConvertToVector256Single(value); /// - /// __m256 _mm512_cvt_roundepi64_ps (__m512i a, int r) - /// VCVTQQ2PS ymm1, zmm2 {er} + /// __m256 _mm512_cvt_roundepi64_ps (__m512i a, int r) + /// VCVTQQ2PS ymm1, zmm2 {er} /// public static Vector256 ConvertToVector256Single(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector256Single(value, mode); /// - /// __m256 _mm512_cvt_roundepu64_ps (__m512i a, int r) - /// VCVTUQQ2PS ymm1, zmm2 {er} + /// __m256 _mm512_cvt_roundepu64_ps (__m512i a, int r) + /// VCVTUQQ2PS ymm1, zmm2 {er} /// public static Vector256 ConvertToVector256Single(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector256Single(value, mode); /// - /// __m512d _mm512_cvtepi64_pd (__m512i a) - /// VCVTQQ2PD zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512d _mm512_cvtepi64_pd (__m512i a) + /// VCVTQQ2PD zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 ConvertToVector512Double(Vector512 value) => ConvertToVector512Double(value); /// - /// __m512d _mm512_cvtepu64_pd (__m512i a) - /// VCVTUQQ2PD zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512d _mm512_cvtepu64_pd (__m512i a) + /// VCVTUQQ2PD zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 ConvertToVector512Double(Vector512 value) => ConvertToVector512Double(value); /// - /// __m512d _mm512_cvt_roundepi64_pd (__m512i a, int r) - /// VCVTQQ2PD zmm1, zmm2 {er} + /// __m512d _mm512_cvt_roundepi64_pd (__m512i a, int r) + /// VCVTQQ2PD zmm1, zmm2 {er} /// public static Vector512 ConvertToVector512Double(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Double(value, mode); /// - /// __m512d _mm512_cvt_roundepu64_pd (__m512i a, int r) - /// VCVTUQQ2PD zmm1, zmm2 {er} + /// __m512d _mm512_cvt_roundepu64_pd (__m512i a, int r) + /// VCVTUQQ2PD zmm1, zmm2 {er} /// public static Vector512 ConvertToVector512Double(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Double(value, mode); /// - /// __m512i _mm512_cvtps_epi64 (__m512 a) - /// VCVTPS2QQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} + /// __m512i _mm512_cvtps_epi64 (__m512 a) + /// VCVTPS2QQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} /// public static Vector512 ConvertToVector512Int64(Vector256 value) => ConvertToVector512Int64(value); /// - /// __m512i _mm512_cvtpd_epi64 (__m512d a) - /// VCVTPD2QQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m512i _mm512_cvtpd_epi64 (__m512d a) + /// VCVTPD2QQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector512 ConvertToVector512Int64(Vector512 value) => ConvertToVector512Int64(value); /// - /// __m512i _mm512_cvt_roundps_epi64 (__m512 a, int r) - /// VCVTPS2QQ zmm1, ymm2 {er} + /// __m512i _mm512_cvt_roundps_epi64 (__m512 a, int r) + /// VCVTPS2QQ zmm1, ymm2 {er} /// public static Vector512 ConvertToVector512Int64(Vector256 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Int64(value, mode); /// - /// __m512i _mm512_cvt_roundpd_epi64 (__m512d a, int r) - /// VCVTPD2QQ zmm1, zmm2 {er} + /// __m512i _mm512_cvt_roundpd_epi64 (__m512d a, int r) + /// VCVTPD2QQ zmm1, zmm2 {er} /// public static Vector512 ConvertToVector512Int64(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Int64(value, mode); /// - /// __m512i _mm512_cvttps_epi64 (__m512 a) - /// VCVTTPS2QQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} + /// __m512i _mm512_cvttps_epi64 (__m512 a) + /// VCVTTPS2QQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} /// public static Vector512 ConvertToVector512Int64WithTruncation(Vector256 value) => ConvertToVector512Int64WithTruncation(value); /// - /// __m512i _mm512_cvttpd_epi64 (__m512 a) - /// VCVTTPD2QQ zmm1 {k1}{z}, zmm2/m512/m64bcst{sae} + /// __m512i _mm512_cvttpd_epi64 (__m512 a) + /// VCVTTPD2QQ zmm1 {k1}{z}, zmm2/m512/m64bcst{sae} /// public static Vector512 ConvertToVector512Int64WithTruncation(Vector512 value) => ConvertToVector512Int64WithTruncation(value); /// - /// __m512i _mm512_cvtps_epu64 (__m512 a) - /// VCVTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} + /// __m512i _mm512_cvtps_epu64 (__m512 a) + /// VCVTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} /// public static Vector512 ConvertToVector512UInt64(Vector256 value) => ConvertToVector512UInt64(value); /// - /// __m512i _mm512_cvtpd_epu64 (__m512d a) - /// VCVTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m512i _mm512_cvtpd_epu64 (__m512d a) + /// VCVTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector512 ConvertToVector512UInt64(Vector512 value) => ConvertToVector512UInt64(value); /// - /// __m512i _mm512_cvt_roundps_epu64 (__m512 a, int r) - /// VCVTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} + /// __m512i _mm512_cvt_roundps_epu64 (__m512 a, int r) + /// VCVTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} /// public static Vector512 ConvertToVector512UInt64(Vector256 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512UInt64(value, mode); /// - /// __m512i _mm512_cvt_roundpd_epu64 (__m512d a, int r) - /// VCVTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m512i _mm512_cvt_roundpd_epu64 (__m512d a, int r) + /// VCVTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector512 ConvertToVector512UInt64(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512UInt64(value, mode); /// - /// __m512i _mm512_cvttps_epu64 (__m512 a) - /// VCVTTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} + /// __m512i _mm512_cvttps_epu64 (__m512 a) + /// VCVTTPS2UQQ zmm1 {k1}{z}, ymm2/m256/m32bcst{er} /// public static Vector512 ConvertToVector512UInt64WithTruncation(Vector256 value) => ConvertToVector512UInt64WithTruncation(value); /// - /// __m512i _mm512_cvttpd_epu64 (__m512d a) - /// VCVTTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m512i _mm512_cvttpd_epu64 (__m512d a) + /// VCVTTPD2UQQ zmm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector512 ConvertToVector512UInt64WithTruncation(Vector512 value) => ConvertToVector512UInt64WithTruncation(value); /// - /// __m128i _mm512_extracti64x2_epi64 (__m512i a, const int imm8) - /// VEXTRACTI64x2 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128i _mm512_extracti64x2_epi64 (__m512i a, const int imm8) + /// VEXTRACTI64x2 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static new Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128i _mm512_extracti64x2_epi64 (__m512i a, const int imm8) - /// VEXTRACTI64x2 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128i _mm512_extracti64x2_epi64 (__m512i a, const int imm8) + /// VEXTRACTI64x2 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static new Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128d _mm512_extractf64x2_pd (__m512d a, const int imm8) - /// VEXTRACTF64x2 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128d _mm512_extractf64x2_pd (__m512d a, const int imm8) + /// VEXTRACTF64x2 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static new Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m256i _mm512_extracti32x8_epi32 (__m512i a, const int imm8) - /// VEXTRACTI32x8 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256i _mm512_extracti32x8_epi32 (__m512i a, const int imm8) + /// VEXTRACTI32x8 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static new Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) => ExtractVector256(value, index); /// - /// __m256i _mm512_extracti32x8_epi32 (__m512i a, const int imm8) - /// VEXTRACTI32x8 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256i _mm512_extracti32x8_epi32 (__m512i a, const int imm8) + /// VEXTRACTI32x8 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static new Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) => ExtractVector256(value, index); /// - /// __m256 _mm512_extractf32x8_ps (__m512 a, const int imm8) - /// VEXTRACTF32x8 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256 _mm512_extractf32x8_ps (__m512 a, const int imm8) + /// VEXTRACTF32x8 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static new Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) => ExtractVector256(value, index); /// - /// __m512i _mm512_inserti64x2_si512 (__m512i a, __m128i b, const int imm8) - /// VINSERTI64x2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512i _mm512_inserti64x2_si512 (__m512i a, __m128i b, const int imm8) + /// VINSERTI64x2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static new Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m512i _mm512_inserti64x2_si512 (__m512i a, __m128i b, const int imm8) - /// VINSERTI64x2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512i _mm512_inserti64x2_si512 (__m512i a, __m128i b, const int imm8) + /// VINSERTI64x2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static new Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m512d _mm512_insertf64x2_pd (__m512d a, __m128d b, int imm8) - /// VINSERTF64x2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512d _mm512_insertf64x2_pd (__m512d a, __m128d b, int imm8) + /// VINSERTF64x2 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static new Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m512i _mm512_inserti32x8_si512 (__m512i a, __m256i b, const int imm8) - /// VINSERTI32x8 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512i _mm512_inserti32x8_si512 (__m512i a, __m256i b, const int imm8) + /// VINSERTI32x8 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static new Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) => InsertVector256(value, data, index); /// - /// __m512i _mm512_inserti32x8_si512 (__m512i a, __m256i b, const int imm8) - /// VINSERTI32x8 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512i _mm512_inserti32x8_si512 (__m512i a, __m256i b, const int imm8) + /// VINSERTI32x8 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static new Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) => InsertVector256(value, data, index); /// - /// __m512 _mm512_insertf32x8_ps (__m512 a, __m256 b, int imm8) - /// VINSERTF32x8 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512 _mm512_insertf32x8_ps (__m512 a, __m256 b, int imm8) + /// VINSERTF32x8 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static new Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) => InsertVector256(value, data, index); /// - /// __m512i _mm512_mullo_epi64 (__m512i a, __m512i b) - /// VPMULLQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_mullo_epi64 (__m512i a, __m512i b) + /// VPMULLQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 MultiplyLow(Vector512 left, Vector512 right) => MultiplyLow(left, right); /// - /// __m512i _mm512_mullo_epi64 (__m512i a, __m512i b) - /// VPMULLQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_mullo_epi64 (__m512i a, __m512i b) + /// VPMULLQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 MultiplyLow(Vector512 left, Vector512 right) => MultiplyLow(left, right); /// - /// __m512 _mm512_or_ps (__m512 a, __m512 b) - /// VORPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_or_ps (__m512 a, __m512 b) + /// VORPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Or(Vector512 left, Vector512 right) => Or(left, right); /// - /// __m512d _mm512_or_pd (__m512d a, __m512d b) - /// VORPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_or_pd (__m512d a, __m512d b) + /// VORPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Or(Vector512 left, Vector512 right) => Or(left, right); /// - /// __m512 _mm512_range_ps(__m512 a, __m512 b, int imm); - /// VRANGEPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}, imm8 + /// __m512 _mm512_range_ps(__m512 a, __m512 b, int imm); + /// VRANGEPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}, imm8 /// public static Vector512 Range(Vector512 left, Vector512 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => Range(left, right, control); /// - /// __m512d _mm512_range_pd(__m512d a, __m512d b, int imm); - /// VRANGEPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}, imm8 + /// __m512d _mm512_range_pd(__m512d a, __m512d b, int imm); + /// VRANGEPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}, imm8 /// public static Vector512 Range(Vector512 left, Vector512 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => Range(left, right, control); /// - /// __m128 _mm_range_ss(__m128 a, __m128 b, int imm); - /// VRANGESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 + /// __m128 _mm_range_ss(__m128 a, __m128 b, int imm); + /// VRANGESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 /// public static Vector128 RangeScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => RangeScalar(left, right, control); /// - /// __m128d _mm_range_sd(__m128d a, __m128d b, int imm); - /// VRANGESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 + /// __m128d _mm_range_sd(__m128d a, __m128d b, int imm); + /// VRANGESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 /// public static Vector128 RangeScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = (byte)(0x0F))] byte control) => RangeScalar(left, right, control); /// - /// __m512 _mm512_reduce_ps(__m512 a, int imm); - /// VREDUCEPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}, imm8 + /// __m512 _mm512_reduce_ps(__m512 a, int imm); + /// VREDUCEPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}, imm8 /// public static Vector512 Reduce(Vector512 value, [ConstantExpected] byte control) => Reduce(value, control); /// - /// __m512d _mm512_reduce_pd(__m512d a, int imm); - /// VREDUCEPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}, imm8 + /// __m512d _mm512_reduce_pd(__m512d a, int imm); + /// VREDUCEPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}, imm8 /// public static Vector512 Reduce(Vector512 value, [ConstantExpected] byte control) => Reduce(value, control); /// - /// __m128 _mm_reduce_ss(__m128 a, int imm); - /// VREDUCESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 + /// __m128 _mm_reduce_ss(__m128 a, int imm); + /// VREDUCESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 /// public static Vector128 ReduceScalar(Vector128 value, [ConstantExpected] byte control) => ReduceScalar(value, control); /// - /// __m128d _mm_reduce_sd(__m128d a, int imm); - /// VREDUCESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 + /// __m128d _mm_reduce_sd(__m128d a, int imm); + /// VREDUCESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 /// public static Vector128 ReduceScalar(Vector128 value, [ConstantExpected] byte control) => ReduceScalar(value, control); /// - /// __m128 _mm_reduce_ss(__m128 a, __m128 b, int imm); - /// VREDUCESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_reduce_ss(__m128 a, __m128 b, int imm); + /// VREDUCESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 ReduceScalar(Vector128 upper, Vector128 value, [ConstantExpected] byte control) => ReduceScalar(upper, value, control); /// - /// __m128d _mm_reduce_sd(__m128d a, __m128d b, int imm); - /// VREDUCESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128d _mm_reduce_sd(__m128d a, __m128d b, int imm); + /// VREDUCESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 ReduceScalar(Vector128 upper, Vector128 value, [ConstantExpected] byte control) => ReduceScalar(upper, value, control); /// - /// __m512 _mm512_xor_ps (__m512 a, __m512 b) - /// VXORPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_xor_ps (__m512 a, __m512 b) + /// VXORPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Xor(Vector512 left, Vector512 right) => Xor(left, right); /// - /// __m512d _mm512_xor_pd (__m512d a, __m512d b) - /// VXORPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_xor_pd (__m512d a, __m512d b) + /// VXORPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Xor(Vector512 left, Vector512 right) => Xor(left, right); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512F.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512F.PlatformNotSupported.cs index 249d3af06fb..44d43475b5d 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512F.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512F.PlatformNotSupported.cs @@ -8,4056 +8,4067 @@ namespace System.Runtime.Intrinsics.X86 { - /// This class provides access to X86 AVX512F hardware instructions via intrinsics + /// Provides access to X86 AVX512F hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Avx512F : Avx2 { internal Avx512F() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } + /// Provides access to the x86 AVX512F+VL hardware instructions via intrinsics. public abstract class VL { internal VL() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static bool IsSupported { [Intrinsic] get { return false; } } /// - /// __m128i _mm_abs_epi64 (__m128i a) - /// VPABSQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_abs_epi64 (__m128i a) + /// VPABSQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 Abs(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_abs_epi64 (__m128i a) - /// VPABSQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_abs_epi64 (__m128i a) + /// VPABSQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 Abs(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_alignr_epi32 (__m128i a, __m128i b, const int count) - /// VALIGND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128i _mm_alignr_epi32 (__m128i a, __m128i b, const int count) + /// VALIGND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 AlignRight32(Vector128 left, Vector128 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_alignr_epi32 (__m128i a, __m128i b, const int count) - /// VALIGND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128i _mm_alignr_epi32 (__m128i a, __m128i b, const int count) + /// VALIGND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 AlignRight32(Vector128 left, Vector128 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_alignr_epi32 (__m256i a, __m256i b, const int count) - /// VALIGND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256i _mm256_alignr_epi32 (__m256i a, __m256i b, const int count) + /// VALIGND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 AlignRight32(Vector256 left, Vector256 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_alignr_epi32 (__m256i a, __m256i b, const int count) - /// VALIGND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256i _mm256_alignr_epi32 (__m256i a, __m256i b, const int count) + /// VALIGND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 AlignRight32(Vector256 left, Vector256 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_alignr_epi64 (__m128i a, __m128i b, const int count) - /// VALIGNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128i _mm_alignr_epi64 (__m128i a, __m128i b, const int count) + /// VALIGNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 AlignRight64(Vector128 left, Vector128 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_alignr_epi64 (__m128i a, __m128i b, const int count) - /// VALIGNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128i _mm_alignr_epi64 (__m128i a, __m128i b, const int count) + /// VALIGNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 AlignRight64(Vector128 left, Vector128 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_alignr_epi64 (__m256i a, __m256i b, const int count) - /// VALIGNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256i _mm256_alignr_epi64 (__m256i a, __m256i b, const int count) + /// VALIGNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 AlignRight64(Vector256 left, Vector256 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_alignr_epi64 (__m256i a, __m256i b, const int count) - /// VALIGNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256i _mm256_alignr_epi64 (__m256i a, __m256i b, const int count) + /// VALIGNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 AlignRight64(Vector256 left, Vector256 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpge_epi32 (__m128i a, __m128i b) - /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(5) + /// __m128i _mm_cmpge_epi32 (__m128i a, __m128i b) + /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmplt_epi32 (__m128i a, __m128i b) - /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(1) + /// __m128i _mm_cmplt_epi32 (__m128i a, __m128i b) + /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmple_epi32 (__m128i a, __m128i b) - /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(2) + /// __m128i _mm_cmple_epi32 (__m128i a, __m128i b) + /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpne_epi32 (__m128i a, __m128i b) - /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(4) + /// __m128i _mm_cmpne_epi32 (__m128i a, __m128i b) + /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpge_epi32 (__m256i a, __m256i b) - /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(5) + /// __m256i _mm256_cmpge_epi32 (__m256i a, __m256i b) + /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmplt_epi32 (__m256i a, __m256i b) - /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(1) + /// __m256i _mm256_cmplt_epi32 (__m256i a, __m256i b) + /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmple_epi32 (__m256i a, __m256i b) - /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(2) + /// __m256i _mm256_cmple_epi32 (__m256i a, __m256i b) + /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpne_epi32 (__m256i a, __m256i b) - /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(4) + /// __m256i _mm256_cmpne_epi32 (__m256i a, __m256i b) + /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpge_epi64 (__m128i a, __m128i b) - /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(5) + /// __m128i _mm_cmpge_epi64 (__m128i a, __m128i b) + /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmplt_epi64 (__m128i a, __m128i b) - /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(1) + /// __m128i _mm_cmplt_epi64 (__m128i a, __m128i b) + /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmple_epi64 (__m128i a, __m128i b) - /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(2) + /// __m128i _mm_cmple_epi64 (__m128i a, __m128i b) + /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpne_epi64 (__m128i a, __m128i b) - /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(4) + /// __m128i _mm_cmpne_epi64 (__m128i a, __m128i b) + /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpge_epi64 (__m256i a, __m256i b) - /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(5) + /// __m256i _mm256_cmpge_epi64 (__m256i a, __m256i b) + /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmplt_epi64 (__m256i a, __m256i b) - /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(1) + /// __m256i _mm256_cmplt_epi64 (__m256i a, __m256i b) + /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmple_epi64 (__m256i a, __m256i b) - /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(2) + /// __m256i _mm256_cmple_epi64 (__m256i a, __m256i b) + /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpne_epi64 (__m256i a, __m256i b) - /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(4) + /// __m256i _mm256_cmpne_epi64 (__m256i a, __m256i b) + /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpgt_epu32 (__m128i a, __m128i b) - /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(6) + /// __m128i _mm_cmpgt_epu32 (__m128i a, __m128i b) + /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(6) /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpge_epu32 (__m128i a, __m128i b) - /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(5) + /// __m128i _mm_cmpge_epu32 (__m128i a, __m128i b) + /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmplt_epu32 (__m128i a, __m128i b) - /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(1) + /// __m128i _mm_cmplt_epu32 (__m128i a, __m128i b) + /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmple_epu32 (__m128i a, __m128i b) - /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(2) + /// __m128i _mm_cmple_epu32 (__m128i a, __m128i b) + /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpne_epu32 (__m128i a, __m128i b) - /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(4) + /// __m128i _mm_cmpne_epu32 (__m128i a, __m128i b) + /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpgt_epu32 (__m256i a, __m256i b) - /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(6) + /// __m256i _mm256_cmpgt_epu32 (__m256i a, __m256i b) + /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(6) /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpge_epu32 (__m256i a, __m256i b) - /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(5) + /// __m256i _mm256_cmpge_epu32 (__m256i a, __m256i b) + /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmplt_epu32 (__m256i a, __m256i b) - /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(1) + /// __m256i _mm256_cmplt_epu32 (__m256i a, __m256i b) + /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmple_epu32 (__m256i a, __m256i b) - /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(2) + /// __m256i _mm256_cmple_epu32 (__m256i a, __m256i b) + /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpne_epu32 (__m256i a, __m256i b) - /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(4) + /// __m256i _mm256_cmpne_epu32 (__m256i a, __m256i b) + /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpgt_epu64 (__m128i a, __m128i b) - /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(6) + /// __m128i _mm_cmpgt_epu64 (__m128i a, __m128i b) + /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(6) /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpge_epu64 (__m128i a, __m128i b) - /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(5) + /// __m128i _mm_cmpge_epu64 (__m128i a, __m128i b) + /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmplt_epu64 (__m128i a, __m128i b) - /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(1) + /// __m128i _mm_cmplt_epu64 (__m128i a, __m128i b) + /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmple_epu64 (__m128i a, __m128i b) - /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(2) + /// __m128i _mm_cmple_epu64 (__m128i a, __m128i b) + /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpne_epu64 (__m128i a, __m128i b) - /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(4) + /// __m128i _mm_cmpne_epu64 (__m128i a, __m128i b) + /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpgt_epu64 (__m256i a, __m256i b) - /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(6) + /// __m256i _mm256_cmpgt_epu64 (__m256i a, __m256i b) + /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(6) /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpge_epu64 (__m256i a, __m256i b) - /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(5) + /// __m256i _mm256_cmpge_epu64 (__m256i a, __m256i b) + /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmplt_epu64 (__m256i a, __m256i b) - /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(1) + /// __m256i _mm256_cmplt_epu64 (__m256i a, __m256i b) + /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmple_epu64 (__m256i a, __m256i b) - /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(2) + /// __m256i _mm256_cmple_epu64 (__m256i a, __m256i b) + /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cmpne_epu64 (__m256i a, __m256i b) - /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(4) + /// __m256i _mm256_cmpne_epu64 (__m256i a, __m256i b) + /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi32_epi8 (__m128i a) - /// VPMOVDB xmm1/m32 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi32_epi8 (__m128i a) + /// VPMOVDB xmm1/m32 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Byte(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi64_epi8 (__m128i a) - /// VPMOVQB xmm1/m16 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi8 (__m128i a) + /// VPMOVQB xmm1/m16 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Byte(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi32_epi8 (__m128i a) - /// VPMOVDB xmm1/m32 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi32_epi8 (__m128i a) + /// VPMOVDB xmm1/m32 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Byte(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi64_epi8 (__m128i a) - /// VPMOVQB xmm1/m16 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi8 (__m128i a) + /// VPMOVQB xmm1/m16 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Byte(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi32_epi8 (__m256i a) - /// VPMOVDB xmm1/m64 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi32_epi8 (__m256i a) + /// VPMOVDB xmm1/m64 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Byte(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi64_epi8 (__m256i a) - /// VPMOVQB xmm1/m32 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi8 (__m256i a) + /// VPMOVQB xmm1/m32 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Byte(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi32_epi8 (__m256i a) - /// VPMOVDB xmm1/m64 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi32_epi8 (__m256i a) + /// VPMOVDB xmm1/m64 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Byte(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi64_epi8 (__m256i a) - /// VPMOVQB xmm1/m32 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi8 (__m256i a) + /// VPMOVQB xmm1/m32 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Byte(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtusepi32_epi8 (__m128i a) - /// VPMOVUSDB xmm1/m32 {k1}{z}, xmm2 + /// __m128i _mm_cvtusepi32_epi8 (__m128i a) + /// VPMOVUSDB xmm1/m32 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtusepi64_epi8 (__m128i a) - /// VPMOVUSQB xmm1/m16 {k1}{z}, xmm2 + /// __m128i _mm_cvtusepi64_epi8 (__m128i a) + /// VPMOVUSQB xmm1/m16 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtusepi32_epi8 (__m256i a) - /// VPMOVUSDB xmm1/m64 {k1}{z}, ymm2 + /// __m128i _mm256_cvtusepi32_epi8 (__m256i a) + /// VPMOVUSDB xmm1/m64 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtusepi64_epi8 (__m256i a) - /// VPMOVUSQB xmm1/m32 {k1}{z}, ymm2 + /// __m128i _mm256_cvtusepi64_epi8 (__m256i a) + /// VPMOVUSQB xmm1/m32 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cvtepu32_pd (__m128i a) - /// VCVTUDQ2PD xmm1 {k1}{z}, xmm2/m64/m32bcst + /// __m128d _mm_cvtepu32_pd (__m128i a) + /// VCVTUDQ2PD xmm1 {k1}{z}, xmm2/m64/m32bcst /// public static Vector128 ConvertToVector128Double(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi32_epi16 (__m128i a) - /// VPMOVDW xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi32_epi16 (__m128i a) + /// VPMOVDW xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi64_epi16 (__m128i a) - /// VPMOVQW xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi64_epi16 (__m128i a) + /// VPMOVQW xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi32_epi16 (__m128i a) - /// VPMOVDW xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi32_epi16 (__m128i a) + /// VPMOVDW xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi64_epi16 (__m128i a) - /// VPMOVQW xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi64_epi16 (__m128i a) + /// VPMOVQW xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi32_epi16 (__m256i a) - /// VPMOVDW xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi32_epi16 (__m256i a) + /// VPMOVDW xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi64_epi16 (__m256i a) - /// VPMOVQW xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi64_epi16 (__m256i a) + /// VPMOVQW xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi32_epi16 (__m256i a) - /// VPMOVDW xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi32_epi16 (__m256i a) + /// VPMOVDW xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi64_epi16 (__m256i a) - /// VPMOVQW xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi64_epi16 (__m256i a) + /// VPMOVQW xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtsepi32_epi16 (__m128i a) - /// VPMOVSDW xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm_cvtsepi32_epi16 (__m128i a) + /// VPMOVSDW xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16WithSaturation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtsepi64_epi16 (__m128i a) - /// VPMOVSQW xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm_cvtsepi64_epi16 (__m128i a) + /// VPMOVSQW xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16WithSaturation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtsepi32_epi16 (__m256i a) - /// VPMOVSDW xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm256_cvtsepi32_epi16 (__m256i a) + /// VPMOVSDW xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16WithSaturation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtsepi64_epi16 (__m256i a) - /// VPMOVSQW xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm256_cvtsepi64_epi16 (__m256i a) + /// VPMOVSQW xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16WithSaturation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi64_epi32 (__m128i a) - /// VPMOVQD xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi32 (__m128i a) + /// VPMOVQD xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Int32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi64_epi32 (__m128i a) - /// VPMOVQD xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi32 (__m128i a) + /// VPMOVQD xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Int32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi64_epi32 (__m256i a) - /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi32 (__m256i a) + /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Int32(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi64_epi32 (__m256i a) - /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi32 (__m256i a) + /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Int32(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm128_cvtsepi64_epi32 (__m128i a) - /// VPMOVSQD xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm128_cvtsepi64_epi32 (__m128i a) + /// VPMOVSQD xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Int32WithSaturation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtsepi64_epi32 (__m256i a) - /// VPMOVSQD xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtsepi64_epi32 (__m256i a) + /// VPMOVSQD xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Int32WithSaturation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi32_epi8 (__m128i a) - /// VPMOVDB xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi32_epi8 (__m128i a) + /// VPMOVDB xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi64_epi8 (__m128i a) - /// VPMOVQB xmm1/m16 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi64_epi8 (__m128i a) + /// VPMOVQB xmm1/m16 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi32_epi8 (__m128i a) - /// VPMOVDB xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi32_epi8 (__m128i a) + /// VPMOVDB xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi64_epi8 (__m128i a) - /// VPMOVQB xmm1/m16 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi64_epi8 (__m128i a) + /// VPMOVQB xmm1/m16 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi32_epi8 (__m256i a) - /// VPMOVDB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi32_epi8 (__m256i a) + /// VPMOVDB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi64_epi8 (__m256i a) - /// VPMOVQB xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi64_epi8 (__m256i a) + /// VPMOVQB xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi32_epi8 (__m256i a) - /// VPMOVDB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi32_epi8 (__m256i a) + /// VPMOVDB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi64_epi8 (__m256i a) - /// VPMOVQB xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi64_epi8 (__m256i a) + /// VPMOVQB xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtsepi32_epi8 (__m128i a) - /// VPMOVSDB xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm_cvtsepi32_epi8 (__m128i a) + /// VPMOVSDB xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtsepi64_epi8 (__m128i a) - /// VPMOVSQB xmm1/m16 {k1}{z}, zmm2 + /// __m128i _mm_cvtsepi64_epi8 (__m128i a) + /// VPMOVSQB xmm1/m16 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtsepi32_epi8 (__m256i a) - /// VPMOVSDB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm256_cvtsepi32_epi8 (__m256i a) + /// VPMOVSDB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtsepi64_epi8 (__m256i a) - /// VPMOVSQB xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm256_cvtsepi64_epi8 (__m256i a) + /// VPMOVSQB xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cvtepu32_ps (__m128i a) - /// VCVTUDQ2PS xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128 _mm_cvtepu32_ps (__m128i a) + /// VCVTUDQ2PS xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 ConvertToVector128Single(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi32_epi16 (__m128i a) - /// VPMOVDW xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi32_epi16 (__m128i a) + /// VPMOVDW xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt16(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi64_epi16 (__m128i a) - /// VPMOVQW xmm1/m32 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi16 (__m128i a) + /// VPMOVQW xmm1/m32 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt16(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi32_epi16 (__m128i a) - /// VPMOVDW xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi32_epi16 (__m128i a) + /// VPMOVDW xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt16(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi64_epi16 (__m128i a) - /// VPMOVQW xmm1/m32 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi16 (__m128i a) + /// VPMOVQW xmm1/m32 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt16(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi32_epi16 (__m256i a) - /// VPMOVDW xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi32_epi16 (__m256i a) + /// VPMOVDW xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt16(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi64_epi16 (__m256i a) - /// VPMOVQW xmm1/m64 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi16 (__m256i a) + /// VPMOVQW xmm1/m64 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt16(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi32_epi16 (__m256i a) - /// VPMOVDW xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi32_epi16 (__m256i a) + /// VPMOVDW xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt16(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi64_epi16 (__m256i a) - /// VPMOVQW xmm1/m64 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi16 (__m256i a) + /// VPMOVQW xmm1/m64 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt16(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtusepi32_epi16 (__m128i a) - /// VPMOVUSDW xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtusepi32_epi16 (__m128i a) + /// VPMOVUSDW xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt16WithSaturation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtusepi64_epi16 (__m128i a) - /// VPMOVUSQW xmm1/m32 {k1}{z}, xmm2 + /// __m128i _mm_cvtusepi64_epi16 (__m128i a) + /// VPMOVUSQW xmm1/m32 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt16WithSaturation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtusepi32_epi16 (__m256i a) - /// VPMOVUSDW xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtusepi32_epi16 (__m256i a) + /// VPMOVUSDW xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt16WithSaturation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtusepi64_epi16 (__m256i a) - /// VPMOVUSQW xmm1/m64 {k1}{z}, ymm2 + /// __m128i _mm256_cvtusepi64_epi16 (__m256i a) + /// VPMOVUSQW xmm1/m64 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt16WithSaturation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm128_cvtepi64_epi32 (__m128i a) - /// VPMOVQD xmm1/m128 {k1}{z}, xmm2 + /// __m128i _mm128_cvtepi64_epi32 (__m128i a) + /// VPMOVQD xmm1/m128 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm128_cvtepi64_epi32 (__m128i a) - /// VPMOVQD xmm1/m128 {k1}{z}, xmm2 + /// __m128i _mm128_cvtepi64_epi32 (__m128i a) + /// VPMOVQD xmm1/m128 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtps_epu32 (__m128 a) - /// VCVTPS2UDQ xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_cvtps_epu32 (__m128 a) + /// VCVTPS2UDQ xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 ConvertToVector128UInt32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtpd_epu32 (__m128d a) - /// VCVTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvtpd_epu32 (__m128d a) + /// VCVTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128UInt32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi64_epi32 (__m256i a) - /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi32 (__m256i a) + /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt32(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtepi64_epi32 (__m256i a) - /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi32 (__m256i a) + /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt32(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtpd_epu32 (__m256d a) - /// VCVTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcst + /// __m128i _mm256_cvtpd_epu32 (__m256d a) + /// VCVTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector128 ConvertToVector128UInt32(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm128_cvtusepi64_epi32 (__m128i a) - /// VPMOVUSQD xmm1/m128 {k1}{z}, xmm2 + /// __m128i _mm128_cvtusepi64_epi32 (__m128i a) + /// VPMOVUSQD xmm1/m128 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt32WithSaturation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvtusepi64_epi32 (__m256i a) - /// VPMOVUSQD xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtusepi64_epi32 (__m256i a) + /// VPMOVUSQD xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt32WithSaturation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvttps_epu32 (__m128 a) - /// VCVTTPS2UDQ xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_cvttps_epu32 (__m128 a) + /// VCVTTPS2UDQ xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 ConvertToVector128UInt32WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvttpd_epu32 (__m128d a) - /// VCVTTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvttpd_epu32 (__m128d a) + /// VCVTTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128UInt32WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm256_cvttpd_epu32 (__m256d a) - /// VCVTTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcst + /// __m128i _mm256_cvttpd_epu32 (__m256d a) + /// VCVTTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector128 ConvertToVector128UInt32WithTruncation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm512_cvtepu32_pd (__m128i a) - /// VCVTUDQ2PD ymm1 {k1}{z}, xmm2/m128/m32bcst + /// __m256d _mm512_cvtepu32_pd (__m128i a) + /// VCVTUDQ2PD ymm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector256 ConvertToVector256Double(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_cvtepu32_ps (__m256i a) - /// VCVTUDQ2PS ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256 _mm256_cvtepu32_ps (__m256i a) + /// VCVTUDQ2PS ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 ConvertToVector256Single(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvtps_epu32 (__m256 a) - /// VCVTPS2UDQ ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_cvtps_epu32 (__m256 a) + /// VCVTPS2UDQ ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 ConvertToVector256UInt32(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_cvttps_epu32 (__m256 a) - /// VCVTTPS2UDQ ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_cvttps_epu32 (__m256 a) + /// VCVTTPS2UDQ ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 ConvertToVector256UInt32WithTruncation(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_fixupimm_ps(__m128 a, __m128 b, __m128i tbl, int imm); - /// VFIXUPIMMPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128 _mm_fixupimm_ps(__m128 a, __m128 b, __m128i tbl, int imm); + /// VFIXUPIMMPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 Fixup(Vector128 left, Vector128 right, Vector128 table, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_fixupimm_pd(__m128d a, __m128d b, __m128i tbl, int imm); - /// VFIXUPIMMPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128d _mm_fixupimm_pd(__m128d a, __m128d b, __m128i tbl, int imm); + /// VFIXUPIMMPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 Fixup(Vector128 left, Vector128 right, Vector128 table, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_fixupimm_ps(__m256 a, __m256 b, __m256i tbl, int imm); - /// VFIXUPIMMPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256 _mm256_fixupimm_ps(__m256 a, __m256 b, __m256i tbl, int imm); + /// VFIXUPIMMPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 Fixup(Vector256 left, Vector256 right, Vector256 table, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_fixupimm_pd(__m256d a, __m256d b, __m256i tbl, int imm); - /// VFIXUPIMMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256d _mm256_fixupimm_pd(__m256d a, __m256d b, __m256i tbl, int imm); + /// VFIXUPIMMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 Fixup(Vector256 left, Vector256 right, Vector256 table, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_getexp_ps (__m128 a) - /// VGETEXPPS xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128 _mm_getexp_ps (__m128 a) + /// VGETEXPPS xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 GetExponent(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_getexp_pd (__m128d a) - /// VGETEXPPD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_getexp_pd (__m128d a) + /// VGETEXPPD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 GetExponent(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_getexp_ps (__m256 a) - /// VGETEXPPS ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256 _mm256_getexp_ps (__m256 a) + /// VGETEXPPS ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 GetExponent(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_getexp_pd (__m256d a) - /// VGETEXPPD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_getexp_pd (__m256d a) + /// VGETEXPPD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 GetExponent(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_getmant_ps (__m128 a) - /// VGETMANTPS xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128 _mm_getmant_ps (__m128 a) + /// VGETMANTPS xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 GetMantissa(Vector128 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_getmant_pd (__m128d a) - /// VGETMANTPD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_getmant_pd (__m128d a) + /// VGETMANTPD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 GetMantissa(Vector128 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_getmant_ps (__m256 a) - /// VGETMANTPS ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256 _mm256_getmant_ps (__m256 a) + /// VGETMANTPS ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 GetMantissa(Vector256 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_getmant_pd (__m256d a) - /// VGETMANTPD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_getmant_pd (__m256d a) + /// VGETMANTPD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 GetMantissa(Vector256 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_max_epi64 (__m128i a, __m128i b) - /// VPMAXSQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_max_epi64 (__m128i a, __m128i b) + /// VPMAXSQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_max_epu64 (__m128i a, __m128i b) - /// VPMAXUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_max_epu64 (__m128i a, __m128i b) + /// VPMAXUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_max_epi64 (__m256i a, __m256i b) - /// VPMAXSQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_max_epi64 (__m256i a, __m256i b) + /// VPMAXSQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Max(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_max_epu64 (__m256i a, __m256i b) - /// VPMAXUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_max_epu64 (__m256i a, __m256i b) + /// VPMAXUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Max(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_min_epi64 (__m128i a, __m128i b) - /// VPMINSQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_min_epi64 (__m128i a, __m128i b) + /// VPMINSQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_min_epu64 (__m128i a, __m128i b) - /// VPMINUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_min_epu64 (__m128i a, __m128i b) + /// VPMINUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_min_epi64 (__m256i a, __m256i b) - /// VPMINSQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_min_epi64 (__m256i a, __m256i b) + /// VPMINSQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Min(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_min_epu64 (__m256i a, __m256i b) - /// VPMINUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_min_epu64 (__m256i a, __m256i b) + /// VPMINUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Min(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_permutex2var_epi64 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst - /// VPERMT2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_permutex2var_epi64 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// VPERMT2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 PermuteVar2x64x2(Vector128 lower, Vector128 indices, Vector128 upper) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_permutex2var_epi64 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst - /// VPERMT2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_permutex2var_epi64 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// VPERMT2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 PermuteVar2x64x2(Vector128 lower, Vector128 indices, Vector128 upper) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_permutex2var_pd (__m128d a, __m128i idx, __m128i b) - /// VPERMI2PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst - /// VPERMT2PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_permutex2var_pd (__m128d a, __m128i idx, __m128i b) + /// VPERMI2PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// VPERMT2PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 PermuteVar2x64x2(Vector128 lower, Vector128 indices, Vector128 upper) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_permutex2var_epi32 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst - /// VPERMT2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_permutex2var_epi32 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// VPERMT2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 PermuteVar4x32x2(Vector128 lower, Vector128 indices, Vector128 upper) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_permutex2var_epi32 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst - /// VPERMT2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_permutex2var_epi32 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// VPERMT2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 PermuteVar4x32x2(Vector128 lower, Vector128 indices, Vector128 upper) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_permutex2var_ps (__m128 a, __m128i idx, __m128i b) - /// VPERMI2PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst - /// VPERMT2PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_permutex2var_ps (__m128 a, __m128i idx, __m128i b) + /// VPERMI2PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// VPERMT2PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 PermuteVar4x32x2(Vector128 lower, Vector128 indices, Vector128 upper) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permute4x64_epi64 (__m256i a, __m256i b) - /// VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_permute4x64_epi64 (__m256i a, __m256i b) + /// VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar4x64(Vector256 value, Vector256 control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permute4x64_pd (__m256d a, __m256i b) - /// VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_permute4x64_pd (__m256d a, __m256i b) + /// VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar4x64(Vector256 value, Vector256 control) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_permute4x64_pd (__m256d a, __m256i b) - /// VPERMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_permute4x64_pd (__m256d a, __m256i b) + /// VPERMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar4x64(Vector256 value, Vector256 control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutex2var_epi64 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst - /// VPERMT2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_permutex2var_epi64 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// VPERMT2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar4x64x2(Vector256 lower, Vector256 indices, Vector256 upper) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutex2var_epi64 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst - /// VPERMT2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_permutex2var_epi64 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// VPERMT2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar4x64x2(Vector256 lower, Vector256 indices, Vector256 upper) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_permutex2var_pd (__m256d a, __m256i idx, __m256i b) - /// VPERMI2PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst - /// VPERMT2PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_permutex2var_pd (__m256d a, __m256i idx, __m256i b) + /// VPERMI2PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// VPERMT2PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar4x64x2(Vector256 lower, Vector256 indices, Vector256 upper) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutex2var_epi32 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst - /// VPERMT2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_permutex2var_epi32 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// VPERMT2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 PermuteVar8x32x2(Vector256 lower, Vector256 indices, Vector256 upper) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutex2var_epi32 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst - /// VPERMT2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_permutex2var_epi32 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// VPERMT2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 PermuteVar8x32x2(Vector256 lower, Vector256 indices, Vector256 upper) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_permutex2var_ps (__m256 a, __m256i idx, __m256i b) - /// VPERMI2PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst - /// VPERMT2PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_permutex2var_ps (__m256 a, __m256i idx, __m256i b) + /// VPERMI2PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// VPERMT2PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 PermuteVar8x32x2(Vector256 lower, Vector256 indices, Vector256 upper) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_rcp14_ps (__m128 a, __m128 b) - /// VRCP14PS xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128 _mm_rcp14_ps (__m128 a, __m128 b) + /// VRCP14PS xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 Reciprocal14(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_rcp14_pd (__m128d a, __m128d b) - /// VRCP14PD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_rcp14_pd (__m128d a, __m128d b) + /// VRCP14PD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 Reciprocal14(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_rcp14_ps (__m256 a, __m256 b) - /// VRCP14PS ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256 _mm256_rcp14_ps (__m256 a, __m256 b) + /// VRCP14PS ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 Reciprocal14(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_rcp14_pd (__m256d a, __m256d b) - /// VRCP14PD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_rcp14_pd (__m256d a, __m256d b) + /// VRCP14PD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 Reciprocal14(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_rsqrt14_ps (__m128 a, __m128 b) - /// VRSQRT14PS xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128 _mm_rsqrt14_ps (__m128 a, __m128 b) + /// VRSQRT14PS xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 ReciprocalSqrt14(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_rsqrt14_pd (__m128d a, __m128d b) - /// VRSQRT14PD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_rsqrt14_pd (__m128d a, __m128d b) + /// VRSQRT14PD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ReciprocalSqrt14(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_rsqrt14_ps (__m256 a, __m256 b) - /// VRSQRT14PS ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256 _mm256_rsqrt14_ps (__m256 a, __m256 b) + /// VRSQRT14PS ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 ReciprocalSqrt14(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_rsqrt14_pd (__m256d a, __m256d b) - /// VRSQRT14PD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_rsqrt14_pd (__m256d a, __m256d b) + /// VRSQRT14PD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ReciprocalSqrt14(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_rol_epi32 (__m128i a, int imm8) - /// VPROLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128i _mm_rol_epi32 (__m128i a, int imm8) + /// VPROLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 RotateLeft(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_rol_epi32 (__m128i a, int imm8) - /// VPROLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128i _mm_rol_epi32 (__m128i a, int imm8) + /// VPROLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 RotateLeft(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_rol_epi64 (__m128i a, int imm8) - /// VPROLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128i _mm_rol_epi64 (__m128i a, int imm8) + /// VPROLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 RotateLeft(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_rol_epi64 (__m128i a, int imm8) - /// VPROLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128i _mm_rol_epi64 (__m128i a, int imm8) + /// VPROLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 RotateLeft(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_rol_epi32 (__m256i a, int imm8) - /// VPROLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256i _mm256_rol_epi32 (__m256i a, int imm8) + /// VPROLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 RotateLeft(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_rol_epi32 (__m256i a, int imm8) - /// VPROLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256i _mm256_rol_epi32 (__m256i a, int imm8) + /// VPROLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 RotateLeft(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_rol_epi64 (__m256i a, int imm8) - /// VPROLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256i _mm256_rol_epi64 (__m256i a, int imm8) + /// VPROLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 RotateLeft(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_rol_epi64 (__m256i a, int imm8) - /// VPROLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256i _mm256_rol_epi64 (__m256i a, int imm8) + /// VPROLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 RotateLeft(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_rolv_epi32 (__m128i a, __m128i b) - /// VPROLDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_rolv_epi32 (__m128i a, __m128i b) + /// VPROLDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 RotateLeftVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_rolv_epi32 (__m128i a, __m128i b) - /// VPROLDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_rolv_epi32 (__m128i a, __m128i b) + /// VPROLDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 RotateLeftVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_rolv_epi64 (__m128i a, __m128i b) - /// VPROLQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_rolv_epi64 (__m128i a, __m128i b) + /// VPROLQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 RotateLeftVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_rolv_epi64 (__m128i a, __m128i b) - /// VPROLQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_rolv_epi64 (__m128i a, __m128i b) + /// VPROLQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 RotateLeftVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_rolv_epi32 (__m256i a, __m256i b) - /// VPROLDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_rolv_epi32 (__m256i a, __m256i b) + /// VPROLDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 RotateLeftVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_rolv_epi32 (__m256i a, __m256i b) - /// VPROLDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_rolv_epi32 (__m256i a, __m256i b) + /// VPROLDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 RotateLeftVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_rolv_epi64 (__m256i a, __m256i b) - /// VPROLQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_rolv_epi64 (__m256i a, __m256i b) + /// VPROLQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 RotateLeftVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_rolv_epi64 (__m256i a, __m256i b) - /// VPROLQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_rolv_epi64 (__m256i a, __m256i b) + /// VPROLQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 RotateLeftVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_ror_epi32 (__m128i a, int imm8) - /// VPRORD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128i _mm_ror_epi32 (__m128i a, int imm8) + /// VPRORD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 RotateRight(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_ror_epi32 (__m128i a, int imm8) - /// VPRORD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128i _mm_ror_epi32 (__m128i a, int imm8) + /// VPRORD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 RotateRight(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_ror_epi64 (__m128i a, int imm8) - /// VPRORQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128i _mm_ror_epi64 (__m128i a, int imm8) + /// VPRORQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 RotateRight(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_ror_epi64 (__m128i a, int imm8) - /// VPRORQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128i _mm_ror_epi64 (__m128i a, int imm8) + /// VPRORQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 RotateRight(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_ror_epi32 (__m256i a, int imm8) - /// VPRORD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256i _mm256_ror_epi32 (__m256i a, int imm8) + /// VPRORD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 RotateRight(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_ror_epi32 (__m256i a, int imm8) - /// VPRORD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256i _mm256_ror_epi32 (__m256i a, int imm8) + /// VPRORD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 RotateRight(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_ror_epi64 (__m256i a, int imm8) - /// VPRORQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256i _mm256_ror_epi64 (__m256i a, int imm8) + /// VPRORQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 RotateRight(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_ror_epi64 (__m256i a, int imm8) - /// VPRORQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256i _mm256_ror_epi64 (__m256i a, int imm8) + /// VPRORQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 RotateRight(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_rorv_epi32 (__m128i a, __m128i b) - /// VPRORDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_rorv_epi32 (__m128i a, __m128i b) + /// VPRORDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 RotateRightVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_rorv_epi32 (__m128i a, __m128i b) - /// VPRORDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_rorv_epi32 (__m128i a, __m128i b) + /// VPRORDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 RotateRightVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_rorv_epi64 (__m128i a, __m128i b) - /// VPRORQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_rorv_epi64 (__m128i a, __m128i b) + /// VPRORQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 RotateRightVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_rorv_epi64 (__m128i a, __m128i b) - /// VPRORQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_rorv_epi64 (__m128i a, __m128i b) + /// VPRORQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 RotateRightVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_rorv_epi32 (__m256i a, __m256i b) - /// VPRORDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_rorv_epi32 (__m256i a, __m256i b) + /// VPRORDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 RotateRightVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_rorv_epi32 (__m256i a, __m256i b) - /// VPRORDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_rorv_epi32 (__m256i a, __m256i b) + /// VPRORDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 RotateRightVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_rorv_epi64 (__m256i a, __m256i b) - /// VPRORQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_rorv_epi64 (__m256i a, __m256i b) + /// VPRORQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 RotateRightVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_rorv_epi64 (__m256i a, __m256i b) - /// VPRORQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_rorv_epi64 (__m256i a, __m256i b) + /// VPRORQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 RotateRightVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_roundscale_ps (__m128 a, int imm) - /// VRNDSCALEPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128 _mm_roundscale_ps (__m128 a, int imm) + /// VRNDSCALEPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 RoundScale(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_roundscale_pd (__m128d a, int imm) - /// VRNDSCALEPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128d _mm_roundscale_pd (__m128d a, int imm) + /// VRNDSCALEPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 RoundScale(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_roundscale_ps (__m256 a, int imm) - /// VRNDSCALEPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256 _mm256_roundscale_ps (__m256 a, int imm) + /// VRNDSCALEPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 RoundScale(Vector256 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_roundscale_pd (__m256d a, int imm) - /// VRNDSCALEPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256d _mm256_roundscale_pd (__m256d a, int imm) + /// VRNDSCALEPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 RoundScale(Vector256 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_scalef_ps (__m128 a, int imm) - /// VSCALEFPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_scalef_ps (__m128 a, int imm) + /// VSCALEFPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Scale(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_scalef_pd (__m128d a, int imm) - /// VSCALEFPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_scalef_pd (__m128d a, int imm) + /// VSCALEFPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Scale(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_scalef_ps (__m256 a, int imm) - /// VSCALEFPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_scalef_ps (__m256 a, int imm) + /// VSCALEFPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Scale(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_scalef_pd (__m256d a, int imm) - /// VSCALEFPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_scalef_pd (__m256d a, int imm) + /// VSCALEFPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Scale(Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sra_epi64 (__m128i a, __m128i count) - /// VPSRAQ xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sra_epi64 (__m128i a, __m128i count) + /// VPSRAQ xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightArithmetic(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_sra_epi64 (__m256i a, __m128i count) - /// VPSRAQ ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_sra_epi64 (__m256i a, __m128i count) + /// VPSRAQ ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftRightArithmetic(Vector256 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __128i _mm_srai_epi64 (__m128i a, int imm8) - /// VPSRAQ xmm1 {k1}{z}, xmm2, imm8 + /// __128i _mm_srai_epi64 (__m128i a, int imm8) + /// VPSRAQ xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftRightArithmetic(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srai_epi64 (__m256i a, int imm8) - /// VPSRAQ ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_srai_epi64 (__m256i a, int imm8) + /// VPSRAQ ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftRightArithmetic(Vector256 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srav_epi64 (__m128i a, __m128i count) - /// VPSRAVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_srav_epi64 (__m128i a, __m128i count) + /// VPSRAVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 ShiftRightArithmeticVariable(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_srav_epi64 (__m256i a, __m256i count) - /// VPSRAVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_srav_epi64 (__m256i a, __m256i count) + /// VPSRAVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 ShiftRightArithmeticVariable(Vector256 value, Vector256 count) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_shuffle_f64x2 (__m256d a, __m256d b, const int imm8) - /// VSHUFF64x2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256d _mm256_shuffle_f64x2 (__m256d a, __m256d b, const int imm8) + /// VSHUFF64x2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 Shuffle2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_shuffle_i32x4 (__m256i a, __m256i b, const int imm8) - /// VSHUFI32x4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256i _mm256_shuffle_i32x4 (__m256i a, __m256i b, const int imm8) + /// VSHUFI32x4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 Shuffle2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_shuffle_i64x2 (__m256i a, __m256i b, const int imm8) - /// VSHUFI64x2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256i _mm256_shuffle_i64x2 (__m256i a, __m256i b, const int imm8) + /// VSHUFI64x2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 Shuffle2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_shuffle_f32x4 (__m256 a, __m256 b, const int imm8) - /// VSHUFF32x4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256 _mm256_shuffle_f32x4 (__m256 a, __m256 b, const int imm8) + /// VSHUFF32x4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 Shuffle2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_shuffle_i32x4 (__m256i a, __m256i b, const int imm8) - /// VSHUFI32x4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256i _mm256_shuffle_i32x4 (__m256i a, __m256i b, const int imm8) + /// VSHUFI32x4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 Shuffle2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_shuffle_i64x2 (__m256i a, __m256i b, const int imm8) - /// VSHUFI64x2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256i _mm256_shuffle_i64x2 (__m256i a, __m256i b, const int imm8) + /// VSHUFI64x2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 Shuffle2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, byte imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, byte imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, byte imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, byte imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, short imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, short imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, short imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, short imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_ternarylogic_epi32 (__m128i a, __m128i b, __m128i c, int imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128i _mm_ternarylogic_epi32 (__m128i a, __m128i b, __m128i c, int imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_ternarylogic_epi32 (__m128i a, __m128i b, __m128i c, int imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128i _mm_ternarylogic_epi32 (__m128i a, __m128i b, __m128i c, int imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_ternarylogic_epi64 (__m128i a, __m128i b, __m128i c, int imm) - /// VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128i _mm_ternarylogic_epi64 (__m128i a, __m128i b, __m128i c, int imm) + /// VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_ternarylogic_epi64 (__m128i a, __m128i b, __m128i c, int imm) - /// VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128i _mm_ternarylogic_epi64 (__m128i a, __m128i b, __m128i c, int imm) + /// VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_ternarylogic_ps (__m128 a, __m128 b, __m128 c, int imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m128 _mm_ternarylogic_ps (__m128 a, __m128 b, __m128 c, int imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_ternarylogic_pd (__m128d a, __m128d b, __m128d c, int imm) - /// VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m128d _mm_ternarylogic_pd (__m128d a, __m128d b, __m128d c, int imm) + /// VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, byte imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, byte imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, byte imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, byte imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, short imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, short imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, short imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, short imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_ternarylogic_epi32 (__m256i a, __m256i b, __m256i c, int imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256i _mm256_ternarylogic_epi32 (__m256i a, __m256i b, __m256i c, int imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_ternarylogic_epi32 (__m256i a, __m256i b, __m256i c, int imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256i _mm256_ternarylogic_epi32 (__m256i a, __m256i b, __m256i c, int imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_ternarylogic_epi64 (__m256i a, __m256i b, __m256i c, int imm) - /// VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256i _mm256_ternarylogic_epi64 (__m256i a, __m256i b, __m256i c, int imm) + /// VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_ternarylogic_epi64 (__m256i a, __m256i b, __m256i c, int imm) - /// VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256i _mm256_ternarylogic_epi64 (__m256i a, __m256i b, __m256i c, int imm) + /// VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_ternarylogic_ps (__m256 a, __m256 b, __m256 c, int imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m256 _mm256_ternarylogic_ps (__m256 a, __m256 b, __m256 c, int imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_ternarylogic_pd (__m256d a, __m256d b, __m256d c, int imm) - /// VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m256d _mm256_ternarylogic_pd (__m256d a, __m256d b, __m256d c, int imm) + /// VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } } + /// Provides access to the x86 AVX512F hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class X64 : Avx2.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } /// - /// __m128 _mm_cvt_roundi64_ss (__m128 a, __int64 b, int rounding) - /// VCVTSI2SS xmm1, xmm2, r64 {er} - /// This intrinsic is only available on 64-bit processes + /// __m128 _mm_cvt_roundi64_ss (__m128 a, __int64 b, int rounding) + /// VCVTSI2SS xmm1, xmm2, r64 {er} + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, ulong value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cvtsi64_ss (__m128 a, __int64 b) - /// VCVTUSI2SS xmm1, xmm2, r/m64 - /// This intrinsic is only available on 64-bit processes + /// __m128 _mm_cvtsi64_ss (__m128 a, __int64 b) + /// VCVTUSI2SS xmm1, xmm2, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, long value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cvt_roundu64_ss (__m128 a, unsigned __int64 b, int rounding) - /// VCVTUSI2SS xmm1, xmm2, r64 {er} - /// This intrinsic is only available on 64-bit processes + /// __m128 _mm_cvt_roundu64_ss (__m128 a, unsigned __int64 b, int rounding) + /// VCVTUSI2SS xmm1, xmm2, r64 {er} + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, ulong value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cvtsi64_sd (__m128d a, __int64 b) - /// VCVTUSI2SD xmm1, xmm2, r/m64 - /// This intrinsic is only available on 64-bit processes + /// __m128d _mm_cvtsi64_sd (__m128d a, __int64 b) + /// VCVTUSI2SD xmm1, xmm2, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Double(Vector128 upper, ulong value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cvt_roundsi64_sd (__m128d a, __int64 b, int rounding) - /// VCVTSI2SD xmm1, xmm2, r64 {er} - /// This intrinsic is only available on 64-bit processes + /// __m128d _mm_cvt_roundsi64_sd (__m128d a, __int64 b, int rounding) + /// VCVTSI2SD xmm1, xmm2, r64 {er} + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Double(Vector128 upper, long value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cvt_roundu64_sd (__m128d a, unsigned __int64 b, int rounding) - /// VCVTUSI2SD xmm1, xmm2, r64 {er} - /// This intrinsic is only available on 64-bit processes + /// __m128d _mm_cvt_roundu64_sd (__m128d a, unsigned __int64 b, int rounding) + /// VCVTUSI2SD xmm1, xmm2, r64 {er} + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Double(Vector128 upper, ulong value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __int64 _mm_cvt_roundss_i64 (__m128 a, int rounding) - /// VCVTSS2SI r64, xmm1 {er} - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_cvt_roundss_i64 (__m128 a, int rounding) + /// VCVTSS2SI r64, xmm1 {er} + /// This intrinsic is only available on 64-bit processes /// public static long ConvertToInt64(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __int64 _mm_cvt_roundsd_i64 (__m128d a, int rounding) - /// VCVTSD2SI r64, xmm1 {er} - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_cvt_roundsd_i64 (__m128d a, int rounding) + /// VCVTSD2SI r64, xmm1 {er} + /// This intrinsic is only available on 64-bit processes /// public static long ConvertToInt64(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// unsigned __int64 _mm_cvtss_u64 (__m128 a) - /// VCVTSS2USI r64, xmm1/m32{er} - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_cvtss_u64 (__m128 a) + /// VCVTSS2USI r64, xmm1/m32{er} + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// unsigned __int64 _mm_cvt_roundss_u64 (__m128 a, int rounding) - /// VCVTSS2USI r64, xmm1 {er} - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_cvt_roundss_u64 (__m128 a, int rounding) + /// VCVTSS2USI r64, xmm1 {er} + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// unsigned __int64 _mm_cvtsd_u64 (__m128d a) - /// VCVTSD2USI r64, xmm1/m64{er} - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_cvtsd_u64 (__m128d a) + /// VCVTSD2USI r64, xmm1/m64{er} + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// unsigned __int64 _mm_cvt_roundsd_u64 (__m128d a, int rounding) - /// VCVTSD2USI r64, xmm1 {er} - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_cvt_roundsd_u64 (__m128d a, int rounding) + /// VCVTSD2USI r64, xmm1 {er} + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// unsigned __int64 _mm_cvttss_u64 (__m128 a) - /// VCVTTSS2USI r64, xmm1/m32{er} - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_cvttss_u64 (__m128 a) + /// VCVTTSS2USI r64, xmm1/m32{er} + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// unsigned __int64 _mm_cvttsd_u64 (__m128d a) - /// VCVTTSD2USI r64, xmm1/m64{er} - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_cvttsd_u64 (__m128d a) + /// VCVTTSD2USI r64, xmm1/m64{er} + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } } /// - /// __m512i _mm512_abs_epi32 (__m512i a) - /// VPABSD zmm1 {k1}{z}, zmm2/m512/m32bcst + /// __m512i _mm512_abs_epi32 (__m512i a) + /// VPABSD zmm1 {k1}{z}, zmm2/m512/m32bcst /// public static Vector512 Abs(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_abs_epi64 (__m512i a) - /// VPABSQ zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512i _mm512_abs_epi64 (__m512i a) + /// VPABSQ zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 Abs(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_add_epi32 (__m512i a, __m512i b) - /// VPADDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_add_epi32 (__m512i a, __m512i b) + /// VPADDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Add(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_add_epi32 (__m512i a, __m512i b) - /// VPADDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_add_epi32 (__m512i a, __m512i b) + /// VPADDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Add(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_add_epi64 (__m512i a, __m512i b) - /// VPADDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_add_epi64 (__m512i a, __m512i b) + /// VPADDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Add(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_add_epi64 (__m512i a, __m512i b) - /// VPADDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_add_epi64 (__m512i a, __m512i b) + /// VPADDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Add(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_add_pd (__m512d a, __m512d b) - /// VADDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er} + /// __m512d _mm512_add_pd (__m512d a, __m512d b) + /// VADDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er} /// public static Vector512 Add(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_add_round_pd (__m512d a, __m512d b, int rounding) - /// VADDPD zmm1, zmm2, zmm3 {er} + /// __m512d _mm512_add_round_pd (__m512d a, __m512d b, int rounding) + /// VADDPD zmm1, zmm2, zmm3 {er} /// public static Vector512 Add(Vector512 left, Vector512 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_add_ps (__m512 a, __m512 b) - /// VADDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er} + /// __m512 _mm512_add_ps (__m512 a, __m512 b) + /// VADDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er} /// public static Vector512 Add(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_add_round_ps (__m512 a, __m512 b, int rounding) - /// VADDPS zmm1, zmm2, zmm3 {er} + /// __m512 _mm512_add_round_ps (__m512 a, __m512 b, int rounding) + /// VADDPS zmm1, zmm2, zmm3 {er} /// public static Vector512 Add(Vector512 left, Vector512 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_add_round_sd (__m128d a, __m128d b, int rounding) - /// VADDSD xmm1, xmm2, xmm3 {er} + /// __m128d _mm_add_round_sd (__m128d a, __m128d b, int rounding) + /// VADDSD xmm1, xmm2, xmm3 {er} /// public static Vector128 AddScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_add_round_ss (__m128 a, __m128 b, int rounding) - /// VADDSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_add_round_ss (__m128 a, __m128 b, int rounding) + /// VADDSS xmm1, xmm2, xmm3 {er} /// public static Vector128 AddScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_alignr_epi32 (__m512i a, __m512i b, const int count) - /// VALIGND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 + /// __m512i _mm512_alignr_epi32 (__m512i a, __m512i b, const int count) + /// VALIGND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 /// public static Vector512 AlignRight32(Vector512 left, Vector512 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_alignr_epi32 (__m512i a, __m512i b, const int count) - /// VALIGND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 + /// __m512i _mm512_alignr_epi32 (__m512i a, __m512i b, const int count) + /// VALIGND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 /// public static Vector512 AlignRight32(Vector512 left, Vector512 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_alignr_epi64 (__m512i a, __m512i b, const int count) - /// VALIGNQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 + /// __m512i _mm512_alignr_epi64 (__m512i a, __m512i b, const int count) + /// VALIGNQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 /// public static Vector512 AlignRight64(Vector512 left, Vector512 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_alignr_epi64 (__m512i a, __m512i b, const int count) - /// VALIGNQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 + /// __m512i _mm512_alignr_epi64 (__m512i a, __m512i b, const int count) + /// VALIGNQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 /// public static Vector512 AlignRight64(Vector512 left, Vector512 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_and_si512 (__m512i a, __m512i b) - /// VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_and_si512 (__m512i a, __m512i b) + /// VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 And(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_and_si512 (__m512i a, __m512i b) - /// VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_and_si512 (__m512i a, __m512i b) + /// VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 And(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_and_si512 (__m512i a, __m512i b) - /// VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_and_si512 (__m512i a, __m512i b) + /// VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 And(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_and_si512 (__m512i a, __m512i b) - /// VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_and_si512 (__m512i a, __m512i b) + /// VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 And(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_and_epi32 (__m512i a, __m512i b) - /// VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_and_epi32 (__m512i a, __m512i b) + /// VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 And(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_and_epi32 (__m512i a, __m512i b) - /// VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_and_epi32 (__m512i a, __m512i b) + /// VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 And(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_and_epi64 (__m512i a, __m512i b) - /// VPANDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_and_epi64 (__m512i a, __m512i b) + /// VPANDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 And(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_and_epi64 (__m512i a, __m512i b) - /// VPANDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_and_epi64 (__m512i a, __m512i b) + /// VPANDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 And(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b) - /// VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b) + /// VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 AndNot(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b) - /// VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b) + /// VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 AndNot(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b) - /// VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b) + /// VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 AndNot(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b) - /// VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b) + /// VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 AndNot(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_andnot_epi32 (__m512i a, __m512i b) - /// VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_andnot_epi32 (__m512i a, __m512i b) + /// VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 AndNot(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_andnot_epi32 (__m512i a, __m512i b) - /// VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_andnot_epi32 (__m512i a, __m512i b) + /// VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 AndNot(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_andnot_epi64 (__m512i a, __m512i b) - /// VPANDNQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_andnot_epi64 (__m512i a, __m512i b) + /// VPANDNQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 AndNot(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_andnot_epi64 (__m512i a, __m512i b) - /// VPANDNQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_andnot_epi64 (__m512i a, __m512i b) + /// VPANDNQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 AndNot(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_blendv_pd (__m512d a, __m512d b, __m512d mask) - /// VBLENDMPD zmm1 {k1}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_blendv_pd (__m512d a, __m512d b, __m512d mask) + /// VBLENDMPD zmm1 {k1}, zmm2, zmm3/m512/m64bcst /// public static Vector512 BlendVariable(Vector512 left, Vector512 right, Vector512 mask) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_blendv_epi32 (__m512i a, __m512i b, __m512i mask) - /// VPBLENDMD zmm1 {k1}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_blendv_epi32 (__m512i a, __m512i b, __m512i mask) + /// VPBLENDMD zmm1 {k1}, zmm2, zmm3/m512/m32bcst /// public static Vector512 BlendVariable(Vector512 left, Vector512 right, Vector512 mask) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_blendv_epi64 (__m512i a, __m512i b, __m512i mask) - /// VPBLENDMQ zmm1 {k1}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_blendv_epi64 (__m512i a, __m512i b, __m512i mask) + /// VPBLENDMQ zmm1 {k1}, zmm2, zmm3/m512/m64bcst /// public static Vector512 BlendVariable(Vector512 left, Vector512 right, Vector512 mask) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_blendv_ps (__m512 a, __m512 b, __m512 mask) - /// VBLENDMPS zmm1 {k1}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_blendv_ps (__m512 a, __m512 b, __m512 mask) + /// VBLENDMPS zmm1 {k1}, zmm2, zmm3/m512/m32bcst /// public static Vector512 BlendVariable(Vector512 left, Vector512 right, Vector512 mask) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_blendv_epu32 (__m512i a, __m512i b, __m512i mask) - /// VPBLENDMD zmm1 {k1}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_blendv_epu32 (__m512i a, __m512i b, __m512i mask) + /// VPBLENDMD zmm1 {k1}, zmm2, zmm3/m512/m32bcst /// public static Vector512 BlendVariable(Vector512 left, Vector512 right, Vector512 mask) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_blendv_epu64 (__m512i a, __m512i b, __m512i mask) - /// VPBLENDMQ zmm1 {k1}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_blendv_epu64 (__m512i a, __m512i b, __m512i mask) + /// VPBLENDMQ zmm1 {k1}, zmm2, zmm3/m512/m64bcst /// public static Vector512 BlendVariable(Vector512 left, Vector512 right, Vector512 mask) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_broadcastd_epi32 (__m128i a) - /// VPBROADCASTD zmm1 {k1}{z}, xmm2/m32 + /// __m512i _mm512_broadcastd_epi32 (__m128i a) + /// VPBROADCASTD zmm1 {k1}{z}, xmm2/m32 /// public static Vector512 BroadcastScalarToVector512(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_broadcastd_epi32 (__m128i a) - /// VPBROADCASTD zmm1 {k1}{z}, xmm2/m32 + /// __m512i _mm512_broadcastd_epi32 (__m128i a) + /// VPBROADCASTD zmm1 {k1}{z}, xmm2/m32 /// public static Vector512 BroadcastScalarToVector512(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_broadcastq_epi64 (__m128i a) - /// VPBROADCASTQ zmm1 {k1}{z}, xmm2/m64 + /// __m512i _mm512_broadcastq_epi64 (__m128i a) + /// VPBROADCASTQ zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 BroadcastScalarToVector512(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_broadcastq_epi64 (__m128i a) - /// VPBROADCASTQ zmm1 {k1}{z}, xmm2/m64 + /// __m512i _mm512_broadcastq_epi64 (__m128i a) + /// VPBROADCASTQ zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 BroadcastScalarToVector512(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_broadcastss_ps (__m128 a) - /// VBROADCASTSS zmm1 {k1}{z}, xmm2/m32 + /// __m512 _mm512_broadcastss_ps (__m128 a) + /// VBROADCASTSS zmm1 {k1}{z}, xmm2/m32 /// public static Vector512 BroadcastScalarToVector512(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_broadcastsd_pd (__m128d a) - /// VBROADCASTSD zmm1 {k1}{z}, xmm2/m64 + /// __m512d _mm512_broadcastsd_pd (__m128d a) + /// VBROADCASTSD zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 BroadcastScalarToVector512(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_broadcast_i32x4 (__m128i const * mem_addr) - /// VBROADCASTI32x4 zmm1 {k1}{z}, m128 + /// __m512i _mm512_broadcast_i32x4 (__m128i const * mem_addr) + /// VBROADCASTI32x4 zmm1 {k1}{z}, m128 /// public static unsafe Vector512 BroadcastVector128ToVector512(int* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_broadcast_i32x4 (__m128i const * mem_addr) - /// VBROADCASTI32x4 zmm1 {k1}{z}, m128 + /// __m512i _mm512_broadcast_i32x4 (__m128i const * mem_addr) + /// VBROADCASTI32x4 zmm1 {k1}{z}, m128 /// public static unsafe Vector512 BroadcastVector128ToVector512(uint* address) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_broadcast_f32x4 (__m128 const * mem_addr) - /// VBROADCASTF32x4 zmm1 {k1}{z}, m128 + /// __m512 _mm512_broadcast_f32x4 (__m128 const * mem_addr) + /// VBROADCASTF32x4 zmm1 {k1}{z}, m128 /// public static unsafe Vector512 BroadcastVector128ToVector512(float* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_broadcast_i64x4 (__m256i const * mem_addr) - /// VBROADCASTI64x4 zmm1 {k1}{z}, m256 + /// __m512i _mm512_broadcast_i64x4 (__m256i const * mem_addr) + /// VBROADCASTI64x4 zmm1 {k1}{z}, m256 /// public static unsafe Vector512 BroadcastVector256ToVector512(long* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_broadcast_i64x4 (__m256i const * mem_addr) - /// VBROADCASTI64x4 zmm1 {k1}{z}, m256 + /// __m512i _mm512_broadcast_i64x4 (__m256i const * mem_addr) + /// VBROADCASTI64x4 zmm1 {k1}{z}, m256 /// public static unsafe Vector512 BroadcastVector256ToVector512(ulong* address) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_broadcast_f64x4 (__m256d const * mem_addr) - /// VBROADCASTF64x4 zmm1 {k1}{z}, m256 + /// __m512d _mm512_broadcast_f64x4 (__m256d const * mem_addr) + /// VBROADCASTF64x4 zmm1 {k1}{z}, m256 /// public static unsafe Vector512 BroadcastVector256ToVector512(double* address) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_cmp_pd (__m512d a, __m512d b, const int imm8) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8 + /// __m512d _mm512_cmp_pd (__m512d a, __m512d b, const int imm8) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8 /// public static Vector512 Compare(Vector512 left, Vector512 right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_cmpeq_pd (__m512d a, __m512d b) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(0) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512d _mm512_cmpeq_pd (__m512d a, __m512d b) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(0) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_cmpgt_pd (__m512d a, __m512d b) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(14) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512d _mm512_cmpgt_pd (__m512d a, __m512d b) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(14) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareGreaterThan(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_cmpge_pd (__m512d a, __m512d b) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(13) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512d _mm512_cmpge_pd (__m512d a, __m512d b) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(13) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareGreaterThanOrEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_cmplt_pd (__m512d a, __m512d b) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(1) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512d _mm512_cmplt_pd (__m512d a, __m512d b) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(1) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareLessThan(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_cmple_pd (__m512d a, __m512d b) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(2) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512d _mm512_cmple_pd (__m512d a, __m512d b) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(2) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareLessThanOrEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_cmpneq_pd (__m512d a, __m512d b) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(4) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512d _mm512_cmpneq_pd (__m512d a, __m512d b) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(4) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareNotEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_cmpngt_pd (__m512d a, __m512d b) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(10) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512d _mm512_cmpngt_pd (__m512d a, __m512d b) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(10) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareNotGreaterThan(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_cmpnge_pd (__m512d a, __m512d b) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(9) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512d _mm512_cmpnge_pd (__m512d a, __m512d b) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(9) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareNotGreaterThanOrEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_cmpnlt_pd (__m512d a, __m512d b) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(5) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512d _mm512_cmpnlt_pd (__m512d a, __m512d b) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(5) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareNotLessThan(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_cmpnle_pd (__m512d a, __m512d b) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(6) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512d _mm512_cmpnle_pd (__m512d a, __m512d b) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(6) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareNotLessThanOrEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_cmpord_pd (__m512d a, __m512d b) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(7) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512d _mm512_cmpord_pd (__m512d a, __m512d b) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(7) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareOrdered(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_cmpunord_pd (__m512d a, __m512d b) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(3) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512d _mm512_cmpunord_pd (__m512d a, __m512d b) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(3) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareUnordered(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_cmp_ps (__m512 a, __m512 b, const int imm8) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8 + /// __m512 _mm512_cmp_ps (__m512 a, __m512 b, const int imm8) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8 /// public static Vector512 Compare(Vector512 left, Vector512 right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_cmpeq_ps (__m512 a, __m512 b) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(0) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512 _mm512_cmpeq_ps (__m512 a, __m512 b) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(0) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_cmpgt_ps (__m512 a, __m512 b) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(14) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512 _mm512_cmpgt_ps (__m512 a, __m512 b) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(14) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareGreaterThan(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_cmpge_ps (__m512 a, __m512 b) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(13) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512 _mm512_cmpge_ps (__m512 a, __m512 b) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(13) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareGreaterThanOrEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_cmplt_ps (__m512 a, __m512 b) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(1) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512 _mm512_cmplt_ps (__m512 a, __m512 b) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(1) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareLessThan(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_cmple_ps (__m512 a, __m512 b) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(2) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512 _mm512_cmple_ps (__m512 a, __m512 b) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(2) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareLessThanOrEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_cmpneq_ps (__m512 a, __m512 b) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(4) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512 _mm512_cmpneq_ps (__m512 a, __m512 b) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(4) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareNotEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_cmpngt_ps (__m512 a, __m512 b) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(10) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512 _mm512_cmpngt_ps (__m512 a, __m512 b) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(10) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareNotGreaterThan(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_cmpnge_ps (__m512 a, __m512 b) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(9) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512 _mm512_cmpnge_ps (__m512 a, __m512 b) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(9) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareNotGreaterThanOrEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_cmpnlt_ps (__m512 a, __m512 b) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(5) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512 _mm512_cmpnlt_ps (__m512 a, __m512 b) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(5) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareNotLessThan(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_cmpnle_ps (__m512 a, __m512 b) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(6) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512 _mm512_cmpnle_ps (__m512 a, __m512 b) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(6) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareNotLessThanOrEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_cmpord_ps (__m512 a, __m512 b) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(7) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512 _mm512_cmpord_ps (__m512 a, __m512 b) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(7) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareOrdered(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_cmpunord_ps (__m512 a, __m512 b) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(3) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512 _mm512_cmpunord_ps (__m512 a, __m512 b) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(3) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareUnordered(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpeq_epi32 (__m512i a, __m512i b) - /// VPCMPEQD k1 {k2}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_cmpeq_epi32 (__m512i a, __m512i b) + /// VPCMPEQD k1 {k2}, zmm2, zmm3/m512/m32bcst /// public static Vector512 CompareEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpgt_epi32 (__m512i a, __m512i b) - /// VPCMPGTD k1 {k2}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_cmpgt_epi32 (__m512i a, __m512i b) + /// VPCMPGTD k1 {k2}, zmm2, zmm3/m512/m32bcst /// public static Vector512 CompareGreaterThan(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpge_epi32 (__m512i a, __m512i b) - /// VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(5) + /// __m512i _mm512_cmpge_epi32 (__m512i a, __m512i b) + /// VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(5) /// public static Vector512 CompareGreaterThanOrEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmplt_epi32 (__m512i a, __m512i b) - /// VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(1) + /// __m512i _mm512_cmplt_epi32 (__m512i a, __m512i b) + /// VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(1) /// public static Vector512 CompareLessThan(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmple_epi32 (__m512i a, __m512i b) - /// VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(2) + /// __m512i _mm512_cmple_epi32 (__m512i a, __m512i b) + /// VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(2) /// public static Vector512 CompareLessThanOrEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpne_epi32 (__m512i a, __m512i b) - /// VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(4) + /// __m512i _mm512_cmpne_epi32 (__m512i a, __m512i b) + /// VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(4) /// public static Vector512 CompareNotEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpeq_epi64 (__m512i a, __m512i b) - /// VPCMPEQQ k1 {k2}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_cmpeq_epi64 (__m512i a, __m512i b) + /// VPCMPEQQ k1 {k2}, zmm2, zmm3/m512/m64bcst /// public static Vector512 CompareEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpgt_epi64 (__m512i a, __m512i b) - /// VPCMPGTQ k1 {k2}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_cmpgt_epi64 (__m512i a, __m512i b) + /// VPCMPGTQ k1 {k2}, zmm2, zmm3/m512/m64bcst /// public static Vector512 CompareGreaterThan(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpge_epi64 (__m512i a, __m512i b) - /// VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(5) + /// __m512i _mm512_cmpge_epi64 (__m512i a, __m512i b) + /// VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(5) /// public static Vector512 CompareGreaterThanOrEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmplt_epi64 (__m512i a, __m512i b) - /// VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(1) + /// __m512i _mm512_cmplt_epi64 (__m512i a, __m512i b) + /// VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(1) /// public static Vector512 CompareLessThan(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmple_epi64 (__m512i a, __m512i b) - /// VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(2) + /// __m512i _mm512_cmple_epi64 (__m512i a, __m512i b) + /// VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(2) /// public static Vector512 CompareLessThanOrEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpne_epi64 (__m512i a, __m512i b) - /// VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(4) + /// __m512i _mm512_cmpne_epi64 (__m512i a, __m512i b) + /// VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(4) /// public static Vector512 CompareNotEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpeq_epu32 (__m512i a, __m512i b) - /// VPCMPEQD k1 {k2}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_cmpeq_epu32 (__m512i a, __m512i b) + /// VPCMPEQD k1 {k2}, zmm2, zmm3/m512/m32bcst /// public static Vector512 CompareEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpgt_epu32 (__m512i a, __m512i b) - /// VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(6) + /// __m512i _mm512_cmpgt_epu32 (__m512i a, __m512i b) + /// VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(6) /// public static Vector512 CompareGreaterThan(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpge_epu32 (__m512i a, __m512i b) - /// VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(5) + /// __m512i _mm512_cmpge_epu32 (__m512i a, __m512i b) + /// VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(5) /// public static Vector512 CompareGreaterThanOrEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmplt_epu32 (__m512i a, __m512i b) - /// VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(1) + /// __m512i _mm512_cmplt_epu32 (__m512i a, __m512i b) + /// VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(1) /// public static Vector512 CompareLessThan(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmple_epu32 (__m512i a, __m512i b) - /// VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(2) + /// __m512i _mm512_cmple_epu32 (__m512i a, __m512i b) + /// VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(2) /// public static Vector512 CompareLessThanOrEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpne_epu32 (__m512i a, __m512i b) - /// VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(4) + /// __m512i _mm512_cmpne_epu32 (__m512i a, __m512i b) + /// VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(4) /// public static Vector512 CompareNotEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpeq_epu64 (__m512i a, __m512i b) - /// VPCMPEQQ k1 {k2}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_cmpeq_epu64 (__m512i a, __m512i b) + /// VPCMPEQQ k1 {k2}, zmm2, zmm3/m512/m64bcst /// public static Vector512 CompareEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpgt_epu64 (__m512i a, __m512i b) - /// VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(6) + /// __m512i _mm512_cmpgt_epu64 (__m512i a, __m512i b) + /// VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(6) /// public static Vector512 CompareGreaterThan(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpge_epu64 (__m512i a, __m512i b) - /// VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(5) + /// __m512i _mm512_cmpge_epu64 (__m512i a, __m512i b) + /// VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(5) /// public static Vector512 CompareGreaterThanOrEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmplt_epu64 (__m512i a, __m512i b) - /// VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(1) + /// __m512i _mm512_cmplt_epu64 (__m512i a, __m512i b) + /// VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(1) /// public static Vector512 CompareLessThan(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmple_epu64 (__m512i a, __m512i b) - /// VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(2) + /// __m512i _mm512_cmple_epu64 (__m512i a, __m512i b) + /// VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(2) /// public static Vector512 CompareLessThanOrEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cmpne_epu64 (__m512i a, __m512i b) - /// VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(4) + /// __m512i _mm512_cmpne_epu64 (__m512i a, __m512i b) + /// VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(4) /// public static Vector512 CompareNotEqual(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cvtsi32_ss (__m128 a, int b) - /// VCVTUSI2SS xmm1, xmm2, r/m32 + /// __m128 _mm_cvtsi32_ss (__m128 a, int b) + /// VCVTUSI2SS xmm1, xmm2, r/m32 /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, uint value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cvt_roundi32_ss (__m128 a, int b, int rounding) - /// VCVTUSI2SS xmm1, xmm2, r32 {er} + /// __m128 _mm_cvt_roundi32_ss (__m128 a, int b, int rounding) + /// VCVTUSI2SS xmm1, xmm2, r32 {er} /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, uint value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertScalarToVector128Single(upper, value, mode); /// - /// __m128 _mm_cvt_roundi32_ss (__m128 a, int b, int rounding) - /// VCVTSI2SS xmm1, xmm2, r32 {er} + /// __m128 _mm_cvt_roundi32_ss (__m128 a, int b, int rounding) + /// VCVTSI2SS xmm1, xmm2, r32 {er} /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, int value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cvt_roundsd_ss (__m128 a, __m128d b, int rounding) - /// VCVTSD2SS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_cvt_roundsd_ss (__m128 a, __m128d b, int rounding) + /// VCVTSD2SS xmm1, xmm2, xmm3 {er} /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode){ throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cvtsi32_sd (__m128d a, int b) - /// VCVTUSI2SD xmm1, xmm2, r/m32 + /// __m128d _mm_cvtsi32_sd (__m128d a, int b) + /// VCVTUSI2SD xmm1, xmm2, r/m32 /// public static Vector128 ConvertScalarToVector128Double(Vector128 upper, uint value) { throw new PlatformNotSupportedException(); } /// - /// int _mm_cvt_roundss_i32 (__m128 a, int rounding) - /// VCVTSS2SIK r32, xmm1 {er} + /// int _mm_cvt_roundss_i32 (__m128 a, int rounding) + /// VCVTSS2SIK r32, xmm1 {er} /// public static int ConvertToInt32(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// int _mm_cvt_roundsd_i32 (__m128d a, int rounding) - /// VCVTSD2SI r32, xmm1 {er} + /// int _mm_cvt_roundsd_i32 (__m128d a, int rounding) + /// VCVTSD2SI r32, xmm1 {er} /// public static int ConvertToInt32(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// unsigned int _mm_cvtss_u32 (__m128 a) - /// VCVTSS2USI r32, xmm1/m32{er} + /// unsigned int _mm_cvtss_u32 (__m128 a) + /// VCVTSS2USI r32, xmm1/m32{er} /// public static uint ConvertToUInt32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// unsigned int _mm_cvt_roundss_u32 (__m128 a, int rounding) - /// VCVTSS2USI r32, xmm1 {er} + /// unsigned int _mm_cvt_roundss_u32 (__m128 a, int rounding) + /// VCVTSS2USI r32, xmm1 {er} /// public static uint ConvertToUInt32(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// unsigned int _mm_cvtsd_u32 (__m128d a) - /// VCVTSD2USI r32, xmm1/m64{er} + /// unsigned int _mm_cvtsd_u32 (__m128d a) + /// VCVTSD2USI r32, xmm1/m64{er} /// public static uint ConvertToUInt32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// unsigned int _mm_cvt_roundsd_u32 (__m128d a, int rounding) - /// VCVTSD2USI r32, xmm1 {er} + /// unsigned int _mm_cvt_roundsd_u32 (__m128d a, int rounding) + /// VCVTSD2USI r32, xmm1 {er} /// public static uint ConvertToUInt32(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// unsigned int _mm_cvttss_u32 (__m128 a) - /// VCVTTSS2USI r32, xmm1/m32{er} + /// unsigned int _mm_cvttss_u32 (__m128 a) + /// VCVTTSS2USI r32, xmm1/m32{er} /// public static uint ConvertToUInt32WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// unsigned int _mm_cvttsd_u32 (__m128d a) - /// VCVTTSD2USI r32, xmm1/m64{er} + /// unsigned int _mm_cvttsd_u32 (__m128d a) + /// VCVTTSD2USI r32, xmm1/m64{er} /// public static uint ConvertToUInt32WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_cvtepi32_epi8 (__m512i a) - /// VPMOVDB xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm512_cvtepi32_epi8 (__m512i a) + /// VPMOVDB xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Byte(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_cvtepi64_epi8 (__m512i a) - /// VPMOVQB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm512_cvtepi64_epi8 (__m512i a) + /// VPMOVQB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Byte(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_cvtepi32_epi8 (__m512i a) - /// VPMOVDB xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm512_cvtepi32_epi8 (__m512i a) + /// VPMOVDB xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Byte(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_cvtepi64_epi8 (__m512i a) - /// VPMOVQB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm512_cvtepi64_epi8 (__m512i a) + /// VPMOVQB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Byte(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_cvtusepi32_epi8 (__m512i a) - /// VPMOVUSDB xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm512_cvtusepi32_epi8 (__m512i a) + /// VPMOVUSDB xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_cvtusepi64_epi8 (__m512i a) - /// VPMOVUSQB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm512_cvtusepi64_epi8 (__m512i a) + /// VPMOVUSQB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_cvtepi64_epi16 (__m512i a) - /// VPMOVQW xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm512_cvtepi64_epi16 (__m512i a) + /// VPMOVQW xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_cvtepi64_epi16 (__m512i a) - /// VPMOVQW xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm512_cvtepi64_epi16 (__m512i a) + /// VPMOVQW xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_cvtsepi64_epi16 (__m512i a) - /// VPMOVSQW xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm512_cvtsepi64_epi16 (__m512i a) + /// VPMOVSQW xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16WithSaturation(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_cvtepi32_epi8 (__m512i a) - /// VPMOVDB xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm512_cvtepi32_epi8 (__m512i a) + /// VPMOVDB xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_cvtepi64_epi8 (__m512i a) - /// VPMOVQB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm512_cvtepi64_epi8 (__m512i a) + /// VPMOVQB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_cvtepi32_epi8 (__m512i a) - /// VPMOVDB xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm512_cvtepi32_epi8 (__m512i a) + /// VPMOVDB xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_cvtepi64_epi8 (__m512i a) - /// VPMOVQB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm512_cvtepi64_epi8 (__m512i a) + /// VPMOVQB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_cvtsepi32_epi8 (__m512i a) - /// VPMOVSDB xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm512_cvtsepi32_epi8 (__m512i a) + /// VPMOVSDB xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_cvtsepi64_epi8 (__m512i a) - /// VPMOVSQB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm512_cvtsepi64_epi8 (__m512i a) + /// VPMOVSQB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_cvtepi64_epi16 (__m512i a) - /// VPMOVQW xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm512_cvtepi64_epi16 (__m512i a) + /// VPMOVQW xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128UInt16(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_cvtepi64_epi16 (__m512i a) - /// VPMOVQW xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm512_cvtepi64_epi16 (__m512i a) + /// VPMOVQW xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128UInt16(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_cvtusepi64_epi16 (__m512i a) - /// VPMOVUSQW xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm512_cvtusepi64_epi16 (__m512i a) + /// VPMOVUSQW xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128UInt16WithSaturation(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_cvtepi32_epi16 (__m512i a) - /// VPMOVDW ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtepi32_epi16 (__m512i a) + /// VPMOVDW ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256Int16(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_cvtepi32_epi16 (__m512i a) - /// VPMOVDW ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtepi32_epi16 (__m512i a) + /// VPMOVDW ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256Int16(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_cvtsepi32_epi16 (__m512i a) - /// VPMOVSDW ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtsepi32_epi16 (__m512i a) + /// VPMOVSDW ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256Int16WithSaturation(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_cvtpd_epi32 (__m512d a) - /// VCVTPD2DQ ymm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m256i _mm512_cvtpd_epi32 (__m512d a) + /// VCVTPD2DQ ymm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector256 ConvertToVector256Int32(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_cvt_roundpd_epi32 (__m512d a, int rounding) - /// VCVTPD2DQ ymm1, zmm2 {er} + /// __m256i _mm512_cvt_roundpd_epi32 (__m512d a, int rounding) + /// VCVTPD2DQ ymm1, zmm2 {er} /// public static Vector256 ConvertToVector256Int32(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_cvtepi64_epi32 (__m512i a) - /// VPMOVQD ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtepi64_epi32 (__m512i a) + /// VPMOVQD ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256Int32(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_cvtepi64_epi32 (__m512i a) - /// VPMOVQD ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtepi64_epi32 (__m512i a) + /// VPMOVQD ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256Int32(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_cvtsepi64_epi32 (__m512i a) - /// VPMOVSQD ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtsepi64_epi32 (__m512i a) + /// VPMOVSQD ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256Int32WithSaturation(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_cvttpd_epi32 (__m512d a) - /// VCVTTPD2DQ ymm1 {k1}{z}, zmm2/m512/m64bcst{sae} + /// __m256i _mm512_cvttpd_epi32 (__m512d a) + /// VCVTTPD2DQ ymm1 {k1}{z}, zmm2/m512/m64bcst{sae} /// public static Vector256 ConvertToVector256Int32WithTruncation(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm512_cvtpd_ps (__m512d a) - /// VCVTPD2PS ymm1, zmm2/m512 - /// VCVTPD2PS ymm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m256 _mm512_cvtpd_ps (__m512d a) + /// VCVTPD2PS ymm1, zmm2/m512 + /// VCVTPD2PS ymm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector256 ConvertToVector256Single(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm512_cvt_roundpd_ps (__m512d a, int rounding) - /// VCVTPD2PS ymm1, zmm2 {er} + /// __m256 _mm512_cvt_roundpd_ps (__m512d a, int rounding) + /// VCVTPD2PS ymm1, zmm2 {er} /// public static Vector256 ConvertToVector256Single(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_cvtepi32_epi16 (__m512i a) - /// VPMOVDW ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtepi32_epi16 (__m512i a) + /// VPMOVDW ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256UInt16(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_cvtepi32_epi16 (__m512i a) - /// VPMOVDW ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtepi32_epi16 (__m512i a) + /// VPMOVDW ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256UInt16(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_cvtusepi32_epi16 (__m512i a) - /// VPMOVUSDW ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtusepi32_epi16 (__m512i a) + /// VPMOVUSDW ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256UInt16WithSaturation(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_cvtpd_epu32 (__m512d a) - /// VCVTPD2UDQ ymm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m256i _mm512_cvtpd_epu32 (__m512d a) + /// VCVTPD2UDQ ymm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector256 ConvertToVector256UInt32(Vector512 value) { throw new PlatformNotSupportedException(); } /// ///__m256i _mm512_cvt_roundpd_epu32 (__m512d a, int rounding) - /// VCVTPD2UDQ ymm1, zmm2 {er} + /// VCVTPD2UDQ ymm1, zmm2 {er} /// public static Vector256 ConvertToVector256UInt32(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_cvtepi64_epi32 (__m512i a) - /// VPMOVQD ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtepi64_epi32 (__m512i a) + /// VPMOVQD ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256UInt32(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_cvtepi64_epi32 (__m512i a) - /// VPMOVQD ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtepi64_epi32 (__m512i a) + /// VPMOVQD ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256UInt32(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_cvtusepi64_epi32 (__m512i a) - /// VPMOVUSQD ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtusepi64_epi32 (__m512i a) + /// VPMOVUSQD ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256UInt32WithSaturation(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_cvttpd_epu32 (__m512d a) - /// VCVTTPD2UDQ ymm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m256i _mm512_cvttpd_epu32 (__m512d a) + /// VCVTTPD2UDQ ymm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector256 ConvertToVector256UInt32WithTruncation(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_cvtepi32_pd (__m256i a) - /// VCVTDQ2PD zmm1 {k1}{z}, ymm2/m256/m32bcst + /// __m512d _mm512_cvtepi32_pd (__m256i a) + /// VCVTDQ2PD zmm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector512 ConvertToVector512Double(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_cvtps_pd (__m256 a) - /// VCVTPS2PD zmm1 {k1}{z}, ymm2/m256/m32bcst{sae} + /// __m512d _mm512_cvtps_pd (__m256 a) + /// VCVTPS2PD zmm1 {k1}{z}, ymm2/m256/m32bcst{sae} /// public static Vector512 ConvertToVector512Double(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_cvtepu32_pd (__m256i a) - /// VCVTUDQ2PD zmm1 {k1}{z}, ymm2/m256/m32bcst + /// __m512d _mm512_cvtepu32_pd (__m256i a) + /// VCVTUDQ2PD zmm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector512 ConvertToVector512Double(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtepi8_epi32 (__m128i a) - /// VPMOVSXBD zmm1 {k1}{z}, xmm2/m128 + /// __m512i _mm512_cvtepi8_epi32 (__m128i a) + /// VPMOVSXBD zmm1 {k1}{z}, xmm2/m128 /// public static Vector512 ConvertToVector512Int32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_cvt_roundepi32_ps (__m512i a, int rounding) - /// VCVTDQ2PS zmm1, zmm2 {er} + /// __m512 _mm512_cvt_roundepi32_ps (__m512i a, int rounding) + /// VCVTDQ2PS zmm1, zmm2 {er} /// public static Vector512 ConvertToVector512Single(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_cvt_roundepi32_ps (__m512i a, int rounding) - /// VCVTUDQ2PS zmm1, zmm2 {er} + /// __m512 _mm512_cvt_roundepi32_ps (__m512i a, int rounding) + /// VCVTUDQ2PS zmm1, zmm2 {er} /// public static Vector512 ConvertToVector512Single(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtepu8_epi32 (__m128i a) - /// VPMOVZXBD zmm1 {k1}{z}, xmm2/m128 + /// __m512i _mm512_cvtepu8_epi32 (__m128i a) + /// VPMOVZXBD zmm1 {k1}{z}, xmm2/m128 /// public static Vector512 ConvertToVector512Int32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtepi16_epi32 (__m128i a) - /// VPMOVSXWD zmm1 {k1}{z}, ymm2/m256 + /// __m512i _mm512_cvtepi16_epi32 (__m128i a) + /// VPMOVSXWD zmm1 {k1}{z}, ymm2/m256 /// public static Vector512 ConvertToVector512Int32(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtepu16_epi32 (__m128i a) - /// VPMOVZXWD zmm1 {k1}{z}, ymm2/m256 + /// __m512i _mm512_cvtepu16_epi32 (__m128i a) + /// VPMOVZXWD zmm1 {k1}{z}, ymm2/m256 /// public static Vector512 ConvertToVector512Int32(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtps_epi32 (__m512 a) - /// VCVTPS2DQ zmm1 {k1}{z}, zmm2/m512/m32bcst{er} + /// __m512i _mm512_cvtps_epi32 (__m512 a) + /// VCVTPS2DQ zmm1 {k1}{z}, zmm2/m512/m32bcst{er} /// public static Vector512 ConvertToVector512Int32(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvt_roundps_epi32 (__m512 a, int rounding) - /// VCVTPS2DQ zmm1, zmm2 {er} + /// __m512i _mm512_cvt_roundps_epi32 (__m512 a, int rounding) + /// VCVTPS2DQ zmm1, zmm2 {er} /// public static Vector512 ConvertToVector512Int32(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvttps_epi32 (__m512 a) - /// VCVTTPS2DQ zmm1 {k1}{z}, zmm2/m512/m32bcst{sae} + /// __m512i _mm512_cvttps_epi32 (__m512 a) + /// VCVTTPS2DQ zmm1 {k1}{z}, zmm2/m512/m32bcst{sae} /// public static Vector512 ConvertToVector512Int32WithTruncation(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtepi8_epi64 (__m128i a) - /// VPMOVSXBQ zmm1 {k1}{z}, xmm2/m64 + /// __m512i _mm512_cvtepi8_epi64 (__m128i a) + /// VPMOVSXBQ zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 ConvertToVector512Int64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtepu8_epi64 (__m128i a) - /// VPMOVZXBQ zmm1 {k1}{z}, xmm2/m64 + /// __m512i _mm512_cvtepu8_epi64 (__m128i a) + /// VPMOVZXBQ zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 ConvertToVector512Int64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtepi16_epi64 (__m128i a) - /// VPMOVSXWQ zmm1 {k1}{z}, xmm2/m128 + /// __m512i _mm512_cvtepi16_epi64 (__m128i a) + /// VPMOVSXWQ zmm1 {k1}{z}, xmm2/m128 /// public static Vector512 ConvertToVector512Int64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtepu16_epi64 (__m128i a) - /// VPMOVZXWQ zmm1 {k1}{z}, xmm2/m128 + /// __m512i _mm512_cvtepu16_epi64 (__m128i a) + /// VPMOVZXWQ zmm1 {k1}{z}, xmm2/m128 /// public static Vector512 ConvertToVector512Int64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtepi32_epi64 (__m128i a) - /// VPMOVSXDQ zmm1 {k1}{z}, ymm2/m256 + /// __m512i _mm512_cvtepi32_epi64 (__m128i a) + /// VPMOVSXDQ zmm1 {k1}{z}, ymm2/m256 /// public static Vector512 ConvertToVector512Int64(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtepu32_epi64 (__m128i a) - /// VPMOVZXDQ zmm1 {k1}{z}, ymm2/m256 + /// __m512i _mm512_cvtepu32_epi64 (__m128i a) + /// VPMOVZXDQ zmm1 {k1}{z}, ymm2/m256 /// public static Vector512 ConvertToVector512Int64(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_cvtepi32_ps (__m512i a) - /// VCVTDQ2PS zmm1 {k1}{z}, zmm2/m512/m32bcst{er} + /// __m512 _mm512_cvtepi32_ps (__m512i a) + /// VCVTDQ2PS zmm1 {k1}{z}, zmm2/m512/m32bcst{er} /// public static Vector512 ConvertToVector512Single(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_cvtepu32_ps (__m512i a) - /// VCVTUDQ2PS zmm1 {k1}{z}, zmm2/m512/m32bcst{er} + /// __m512 _mm512_cvtepu32_ps (__m512i a) + /// VCVTUDQ2PS zmm1 {k1}{z}, zmm2/m512/m32bcst{er} /// public static Vector512 ConvertToVector512Single(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtepi8_epi32 (__m128i a) - /// VPMOVSXBD zmm1 {k1}{z}, xmm2/m128 + /// __m512i _mm512_cvtepi8_epi32 (__m128i a) + /// VPMOVSXBD zmm1 {k1}{z}, xmm2/m128 /// public static Vector512 ConvertToVector512UInt32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtepu8_epi32 (__m128i a) - /// VPMOVZXBD zmm1 {k1}{z}, xmm2/m128 + /// __m512i _mm512_cvtepu8_epi32 (__m128i a) + /// VPMOVZXBD zmm1 {k1}{z}, xmm2/m128 /// public static Vector512 ConvertToVector512UInt32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtepi16_epi32 (__m128i a) - /// VPMOVSXWD zmm1 {k1}{z}, ymm2/m256 + /// __m512i _mm512_cvtepi16_epi32 (__m128i a) + /// VPMOVSXWD zmm1 {k1}{z}, ymm2/m256 /// public static Vector512 ConvertToVector512UInt32(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtepu16_epi32 (__m128i a) - /// VPMOVZXWD zmm1 {k1}{z}, ymm2/m256 + /// __m512i _mm512_cvtepu16_epi32 (__m128i a) + /// VPMOVZXWD zmm1 {k1}{z}, ymm2/m256 /// public static Vector512 ConvertToVector512UInt32(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtps_epu32 (__m512 a) - /// VCVTPS2UDQ zmm1 {k1}{z}, zmm2/m512/m32bcst{er} + /// __m512i _mm512_cvtps_epu32 (__m512 a) + /// VCVTPS2UDQ zmm1 {k1}{z}, zmm2/m512/m32bcst{er} /// public static Vector512 ConvertToVector512UInt32(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvt_roundps_epu32 (__m512 a, int rounding) - /// VCVTPS2UDQ zmm1, zmm2 {er} + /// __m512i _mm512_cvt_roundps_epu32 (__m512 a, int rounding) + /// VCVTPS2UDQ zmm1, zmm2 {er} /// public static Vector512 ConvertToVector512UInt32(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvttps_epu32 (__m512 a) - /// VCVTTPS2UDQ zmm1 {k1}{z}, zmm2/m512/m32bcst{er} + /// __m512i _mm512_cvttps_epu32 (__m512 a) + /// VCVTTPS2UDQ zmm1 {k1}{z}, zmm2/m512/m32bcst{er} /// public static Vector512 ConvertToVector512UInt32WithTruncation(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtepi8_epi64 (__m128i a) - /// VPMOVSXBQ zmm1 {k1}{z}, xmm2/m64 + /// __m512i _mm512_cvtepi8_epi64 (__m128i a) + /// VPMOVSXBQ zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 ConvertToVector512UInt64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtepu8_epi64 (__m128i a) - /// VPMOVZXBQ zmm1 {k1}{z}, xmm2/m64 + /// __m512i _mm512_cvtepu8_epi64 (__m128i a) + /// VPMOVZXBQ zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 ConvertToVector512UInt64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtepi16_epi64 (__m128i a) - /// VPMOVSXWQ zmm1 {k1}{z}, xmm2/m128 + /// __m512i _mm512_cvtepi16_epi64 (__m128i a) + /// VPMOVSXWQ zmm1 {k1}{z}, xmm2/m128 /// public static Vector512 ConvertToVector512UInt64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtepu16_epi64 (__m128i a) - /// VPMOVZXWQ zmm1 {k1}{z}, xmm2/m128 + /// __m512i _mm512_cvtepu16_epi64 (__m128i a) + /// VPMOVZXWQ zmm1 {k1}{z}, xmm2/m128 /// public static Vector512 ConvertToVector512UInt64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtepi32_epi64 (__m128i a) - /// VPMOVSXDQ zmm1 {k1}{z}, ymm2/m256 + /// __m512i _mm512_cvtepi32_epi64 (__m128i a) + /// VPMOVSXDQ zmm1 {k1}{z}, ymm2/m256 /// public static Vector512 ConvertToVector512UInt64(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_cvtepu32_epi64 (__m128i a) - /// VPMOVZXDQ zmm1 {k1}{z}, ymm2/m256 + /// __m512i _mm512_cvtepu32_epi64 (__m128i a) + /// VPMOVZXDQ zmm1 {k1}{z}, ymm2/m256 /// public static Vector512 ConvertToVector512UInt64(Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_div_ps (__m512 a, __m512 b) - /// VDIVPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er} + /// __m512 _mm512_div_ps (__m512 a, __m512 b) + /// VDIVPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er} /// public static Vector512 Divide(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_div_pd (__m512d a, __m512d b) - /// VDIVPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er} + /// __m512d _mm512_div_pd (__m512d a, __m512d b) + /// VDIVPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er} /// public static Vector512 Divide(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_div_round_ps (__m512 a, __m512 b, int rounding) - /// VDIVPS zmm1, zmm2, zmm3 {er} + /// __m512 _mm512_div_round_ps (__m512 a, __m512 b, int rounding) + /// VDIVPS zmm1, zmm2, zmm3 {er} /// public static Vector512 Divide(Vector512 left, Vector512 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_div_round_pd (__m512d a, __m512d b, int rounding) - /// VDIVPD zmm1, zmm2, zmm3 {er} + /// __m512d _mm512_div_round_pd (__m512d a, __m512d b, int rounding) + /// VDIVPD zmm1, zmm2, zmm3 {er} /// public static Vector512 Divide(Vector512 left, Vector512 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_div_round_sd (__m128d a, __m128d b, int rounding) - /// VDIVSS xmm1, xmm2, xmm3 {er} + /// __m128d _mm_div_round_sd (__m128d a, __m128d b, int rounding) + /// VDIVSS xmm1, xmm2, xmm3 {er} /// public static Vector128 DivideScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_div_round_ss (__m128 a, __m128 b, int rounding) - /// VDIVSD xmm1, xmm2, xmm3 {er} + /// __m128 _mm_div_round_ss (__m128 a, __m128 b, int rounding) + /// VDIVSD xmm1, xmm2, xmm3 {er} /// public static Vector128 DivideScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_moveldup_ps (__m512 a) - /// VMOVSLDUP zmm1 {k1}{z}, zmm2/m512 + /// __m512 _mm512_moveldup_ps (__m512 a) + /// VMOVSLDUP zmm1 {k1}{z}, zmm2/m512 /// public static Vector512 DuplicateEvenIndexed(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_movedup_pd (__m512d a) - /// VMOVDDUP zmm1 {k1}{z}, zmm2/m512 + /// __m512d _mm512_movedup_pd (__m512d a) + /// VMOVDDUP zmm1 {k1}{z}, zmm2/m512 /// public static Vector512 DuplicateEvenIndexed(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_movehdup_ps (__m512 a) - /// VMOVSHDUP zmm1 {k1}{z}, zmm2/m512 + /// __m512 _mm512_movehdup_ps (__m512 a) + /// VMOVSHDUP zmm1 {k1}{z}, zmm2/m512 /// public static Vector512 DuplicateOddIndexed(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_extracti128_si512 (__m512i a, const int imm8) - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128i _mm512_extracti128_si512 (__m512i a, const int imm8) + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_extracti128_si512 (__m512i a, const int imm8) - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128i _mm512_extracti128_si512 (__m512i a, const int imm8) + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_extracti128_si512 (__m512i a, const int imm8) - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128i _mm512_extracti128_si512 (__m512i a, const int imm8) + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_extracti128_si512 (__m512i a, const int imm8) - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128i _mm512_extracti128_si512 (__m512i a, const int imm8) + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_extracti32x4_epi32 (__m512i a, const int imm8) - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128i _mm512_extracti32x4_epi32 (__m512i a, const int imm8) + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_extracti32x4_epi32 (__m512i a, const int imm8) - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128i _mm512_extracti32x4_epi32 (__m512i a, const int imm8) + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_extracti128_si512 (__m512i a, const int imm8) - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128i _mm512_extracti128_si512 (__m512i a, const int imm8) + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm512_extracti128_si512 (__m512i a, const int imm8) - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128i _mm512_extracti128_si512 (__m512i a, const int imm8) + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm512_extractf32x4_ps (__m512 a, const int imm8) - /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128 _mm512_extractf32x4_ps (__m512 a, const int imm8) + /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm512_extractf128_pd (__m512d a, const int imm8) - /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128d _mm512_extractf128_pd (__m512d a, const int imm8) + /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_extracti256_si512 (__m512i a, const int imm8) - /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256i _mm512_extracti256_si512 (__m512i a, const int imm8) + /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_extracti256_si512 (__m512i a, const int imm8) - /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256i _mm512_extracti256_si512 (__m512i a, const int imm8) + /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_extracti256_si512 (__m512i a, const int imm8) - /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256i _mm512_extracti256_si512 (__m512i a, const int imm8) + /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_extracti256_si512 (__m512i a, const int imm8) - /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256i _mm512_extracti256_si512 (__m512i a, const int imm8) + /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_extracti256_si512 (__m512i a, const int imm8) - /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256i _mm512_extracti256_si512 (__m512i a, const int imm8) + /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_extracti256_si512 (__m512i a, const int imm8) - /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256i _mm512_extracti256_si512 (__m512i a, const int imm8) + /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_extracti64x4_epi64 (__m512i a, const int imm8) - /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256i _mm512_extracti64x4_epi64 (__m512i a, const int imm8) + /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm512_extracti64x4_epi64 (__m512i a, const int imm8) - /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256i _mm512_extracti64x4_epi64 (__m512i a, const int imm8) + /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm512_extractf256_ps (__m512 a, const int imm8) - /// VEXTRACTF64x4 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256 _mm512_extractf256_ps (__m512 a, const int imm8) + /// VEXTRACTF64x4 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm512_extractf64x4_pd (__m512d a, const int imm8) - /// VEXTRACTF64x4 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256d _mm512_extractf64x4_pd (__m512d a, const int imm8) + /// VEXTRACTF64x4 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_fixupimm_ps(__m512 a, __m512 b, __m512i tbl, int imm); - /// VFIXUPIMMPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}, imm8 + /// __m512 _mm512_fixupimm_ps(__m512 a, __m512 b, __m512i tbl, int imm); + /// VFIXUPIMMPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}, imm8 /// public static Vector512 Fixup(Vector512 left, Vector512 right, Vector512 table, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_fixupimm_pd(__m512d a, __m512d b, __m512i tbl, int imm); - /// VFIXUPIMMPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}, imm8 + /// __m512d _mm512_fixupimm_pd(__m512d a, __m512d b, __m512i tbl, int imm); + /// VFIXUPIMMPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}, imm8 /// public static Vector512 Fixup(Vector512 left, Vector512 right, Vector512 table, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_fixupimm_ss(__m128 a, __m128 b, __m128i tbl, int imm); - /// VFIXUPIMMSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 + /// __m128 _mm_fixupimm_ss(__m128 a, __m128 b, __m128i tbl, int imm); + /// VFIXUPIMMSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 /// public static Vector128 FixupScalar(Vector128 left, Vector128 right, Vector128 table, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_fixupimm_sd(__m128d a, __m128d b, __m128i tbl, int imm); - /// VFIXUPIMMSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 + /// __m128d _mm_fixupimm_sd(__m128d a, __m128d b, __m128i tbl, int imm); + /// VFIXUPIMMSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 /// public static Vector128 FixupScalar(Vector128 left, Vector128 right, Vector128 table, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_fmadd_ps (__m512 a, __m512 b, __m512 c) - /// VFMADDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_fmadd_ps (__m512 a, __m512 b, __m512 c) + /// VFMADDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 FusedMultiplyAdd(Vector512 a, Vector512 b, Vector512 c) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_fmadd_round_ps (__m512 a, __m512 b, __m512 c, int r) - /// VFMADDPS zmm1, zmm2, zmm3 {er} + /// __m512 _mm512_fmadd_round_ps (__m512 a, __m512 b, __m512 c, int r) + /// VFMADDPS zmm1, zmm2, zmm3 {er} /// public static Vector512 FusedMultiplyAdd(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_fmadd_pd (__m512d a, __m512d b, __m512d c) - /// VFMADDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_fmadd_pd (__m512d a, __m512d b, __m512d c) + /// VFMADDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 FusedMultiplyAdd(Vector512 a, Vector512 b, Vector512 c) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_fmadd_round_pd (__m512d a, __m512d b, __m512d c, int r) - /// VFMADDPS zmm1, zmm2, zmm3 {er} + /// __m512d _mm512_fmadd_round_pd (__m512d a, __m512d b, __m512d c, int r) + /// VFMADDPS zmm1, zmm2, zmm3 {er} /// public static Vector512 FusedMultiplyAdd(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_fmadd_round_ss (__m128 a, __m128 b, __m128 c, int r) - /// VFMADDSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_fmadd_round_ss (__m128 a, __m128 b, __m128 c, int r) + /// VFMADDSS xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplyAddScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_fmadd_round_sd (__m128d a, __m128d b, __m128d c, int r) - /// VFMADDSD xmm1, xmm2, xmm3 {er} + /// __m128d _mm_fmadd_round_sd (__m128d a, __m128d b, __m128d c, int r) + /// VFMADDSD xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplyAddScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_fmaddsub_ps (__m512 a, __m512 b, __m512 c) - /// VFMADDSUBPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_fmaddsub_ps (__m512 a, __m512 b, __m512 c) + /// VFMADDSUBPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 FusedMultiplyAddSubtract(Vector512 a, Vector512 b, Vector512 c) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_fmaddsub_ps (__m512 a, __m512 b, __m512 c, int c) - /// VFMADDSUBPS zmm1, zmm2, zmm3 {er} + /// __m512 _mm512_fmaddsub_ps (__m512 a, __m512 b, __m512 c, int c) + /// VFMADDSUBPS zmm1, zmm2, zmm3 {er} /// public static Vector512 FusedMultiplyAddSubtract(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_fmaddsub_pd (__m512d a, __m512d b, __m512d c) - /// VFMADDSUBPD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512d _mm512_fmaddsub_pd (__m512d a, __m512d b, __m512d c) + /// VFMADDSUBPD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 FusedMultiplyAddSubtract(Vector512 a, Vector512 b, Vector512 c) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_fmaddsub_pd (__m512d a, __m512d b, __m512d c, int c) - /// VFMADDSUBPS zmm1, zmm2, zmm3 {er} + /// __m512d _mm512_fmaddsub_pd (__m512d a, __m512d b, __m512d c, int c) + /// VFMADDSUBPS zmm1, zmm2, zmm3 {er} /// public static Vector512 FusedMultiplyAddSubtract(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_fmsub_ps (__m512 a, __m512 b, __m512 c) - /// VFMSUBPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_fmsub_ps (__m512 a, __m512 b, __m512 c) + /// VFMSUBPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 FusedMultiplySubtract(Vector512 a, Vector512 b, Vector512 c) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_fmsub_round_ps (__m512 a, __m512 b, __m512 c, int r) - /// VFMSUBPS zmm1, zmm2, zmm3 {er} + /// __m512 _mm512_fmsub_round_ps (__m512 a, __m512 b, __m512 c, int r) + /// VFMSUBPS zmm1, zmm2, zmm3 {er} /// public static Vector512 FusedMultiplySubtract(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_fmsub_pd (__m512d a, __m512d b, __m512d c) - /// VFMSUBPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_fmsub_pd (__m512d a, __m512d b, __m512d c) + /// VFMSUBPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 FusedMultiplySubtract(Vector512 a, Vector512 b, Vector512 c) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_fmsub_round_pd (__m512d a, __m512d b, __m512d c, int r) - /// VFMSUBPD zmm1, zmm2, zmm3 {er} + /// __m512d _mm512_fmsub_round_pd (__m512d a, __m512d b, __m512d c, int r) + /// VFMSUBPD zmm1, zmm2, zmm3 {er} /// public static Vector512 FusedMultiplySubtract(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_fmsub_round_ss (__m128 a, __m128 b, __m128 c, int r) - /// VFMSUBSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_fmsub_round_ss (__m128 a, __m128 b, __m128 c, int r) + /// VFMSUBSS xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplySubtractScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_fmsub_round_sd (__m128d a, __m128d b, __m128d c, int r) - /// VFMSUBSS xmm1, xmm2, xmm3 {er} + /// __m128d _mm_fmsub_round_sd (__m128d a, __m128d b, __m128d c, int r) + /// VFMSUBSS xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplySubtractScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_fmsubadd_ps (__m512 a, __m512 b, __m512 c) - /// VFMSUBADDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_fmsubadd_ps (__m512 a, __m512 b, __m512 c) + /// VFMSUBADDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 FusedMultiplySubtractAdd(Vector512 a, Vector512 b, Vector512 c) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_fmsubadd_round_ps (__m512 a, __m512 b, __m512 c) - /// VFMSUBADDPS zmm1, zmm2, zmm3 {er} + /// __m512 _mm512_fmsubadd_round_ps (__m512 a, __m512 b, __m512 c) + /// VFMSUBADDPS zmm1, zmm2, zmm3 {er} /// public static Vector512 FusedMultiplySubtractAdd(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_fmsubadd_pd (__m512d a, __m512d b, __m512d c) - /// VFMSUBADDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_fmsubadd_pd (__m512d a, __m512d b, __m512d c) + /// VFMSUBADDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 FusedMultiplySubtractAdd(Vector512 a, Vector512 b, Vector512 c) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_fmsubadd_round_ps (__m512d a, __m512d b, __m512d c) - /// VFMSUBADDPD zmm1, zmm2, zmm3 {er} + /// __m512d _mm512_fmsubadd_round_ps (__m512d a, __m512d b, __m512d c) + /// VFMSUBADDPD zmm1, zmm2, zmm3 {er} /// public static Vector512 FusedMultiplySubtractAdd(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_fnmadd_ps (__m512 a, __m512 b, __m512 c) - /// VFNMADDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_fnmadd_ps (__m512 a, __m512 b, __m512 c) + /// VFNMADDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 FusedMultiplyAddNegated(Vector512 a, Vector512 b, Vector512 c) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_fnmadd_round_ps (__m512 a, __m512 b, __m512 c, int r) - /// VFNMADDPS zmm1, zmm2, zmm3 {er} + /// __m512 _mm512_fnmadd_round_ps (__m512 a, __m512 b, __m512 c, int r) + /// VFNMADDPS zmm1, zmm2, zmm3 {er} /// public static Vector512 FusedMultiplyAddNegated(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_fnmadd_pd (__m512d a, __m512d b, __m512d c) - /// VFNMADDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_fnmadd_pd (__m512d a, __m512d b, __m512d c) + /// VFNMADDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 FusedMultiplyAddNegated(Vector512 a, Vector512 b, Vector512 c) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_fnmadd_round_pdd (__m512d a, __m512d b, __m512d c, int r) - /// VFNMADDPS zmm1, zmm2, zmm3 {er} + /// __m512d _mm512_fnmadd_round_pdd (__m512d a, __m512d b, __m512d c, int r) + /// VFNMADDPS zmm1, zmm2, zmm3 {er} /// public static Vector512 FusedMultiplyAddNegated(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_fnmadd_round_ss (__m128 a, __m128 b, __m128 c, int r) - /// VFNMADDSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_fnmadd_round_ss (__m128 a, __m128 b, __m128 c, int r) + /// VFNMADDSS xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplyAddNegatedScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_fnmadd_round_sd (__m128d a, __m128d b, __m128d c, int r) - /// VFNMADDSD xmm1, xmm2, xmm3 {er} + /// __m128d _mm_fnmadd_round_sd (__m128d a, __m128d b, __m128d c, int r) + /// VFNMADDSD xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplyAddNegatedScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_fnmsub_ps (__m512 a, __m512 b, __m512 c) - /// VFNMSUBPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_fnmsub_ps (__m512 a, __m512 b, __m512 c) + /// VFNMSUBPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 FusedMultiplySubtractNegated(Vector512 a, Vector512 b, Vector512 c) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_fnmsub_round_ps (__m512 a, __m512 b, __m512 c, int r) - /// VFNMSUBPS zmm1, zmm2, zmm3 {er} + /// __m512 _mm512_fnmsub_round_ps (__m512 a, __m512 b, __m512 c, int r) + /// VFNMSUBPS zmm1, zmm2, zmm3 {er} /// public static Vector512 FusedMultiplySubtractNegated(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_fnmsub_pd (__m512d a, __m512d b, __m512d c) - /// VFNMSUBPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_fnmsub_pd (__m512d a, __m512d b, __m512d c) + /// VFNMSUBPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 FusedMultiplySubtractNegated(Vector512 a, Vector512 b, Vector512 c) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_fnmsub_round_pd (__m512d a, __m512d b, __m512d c, int r) - /// VFNMSUBPS zmm1, zmm2, zmm3 {er} + /// __m512d _mm512_fnmsub_round_pd (__m512d a, __m512d b, __m512d c, int r) + /// VFNMSUBPS zmm1, zmm2, zmm3 {er} /// public static Vector512 FusedMultiplySubtractNegated(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_fnmsub_round_ss (__m128 a, __m128 b, __m128 c, int r) - /// VFNMSUBSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_fnmsub_round_ss (__m128 a, __m128 b, __m128 c, int r) + /// VFNMSUBSS xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplySubtractNegatedScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_fnmsub_round_sd (__m128d a, __m128d b, __m128d c, int r) - /// VFNMSUBSS xmm1, xmm2, xmm3 {er} + /// __m128d _mm_fnmsub_round_sd (__m128d a, __m128d b, __m128d c, int r) + /// VFNMSUBSS xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplySubtractNegatedScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_getexp_ps (__m512 a) - /// VGETEXPPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae} + /// __m512 _mm512_getexp_ps (__m512 a) + /// VGETEXPPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae} /// public static Vector512 GetExponent(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_getexp_pd (__m512d a) - /// VGETEXPPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae} + /// __m512d _mm512_getexp_pd (__m512d a) + /// VGETEXPPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae} /// public static Vector512 GetExponent(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_getexp_ss (__m128 a) - /// VGETEXPSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} + /// __m128 _mm_getexp_ss (__m128 a) + /// VGETEXPSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} /// public static Vector128 GetExponentScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_getexp_sd (__m128d a) - /// VGETEXPSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} + /// __m128d _mm_getexp_sd (__m128d a) + /// VGETEXPSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} /// public static Vector128 GetExponentScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_getexp_ss (__m128 a, __m128 b) - /// VGETEXPSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_getexp_ss (__m128 a, __m128 b) + /// VGETEXPSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 GetExponentScalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_getexp_sd (__m128d a, __m128d b) - /// VGETEXPSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128d _mm_getexp_sd (__m128d a, __m128d b) + /// VGETEXPSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 GetExponentScalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_getmant_ps (__m512 a) - /// VGETMANTPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae} + /// __m512 _mm512_getmant_ps (__m512 a) + /// VGETMANTPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae} /// public static Vector512 GetMantissa(Vector512 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_getmant_pd (__m512d a) - /// VGETMANTPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae} + /// __m512d _mm512_getmant_pd (__m512d a) + /// VGETMANTPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae} /// public static Vector512 GetMantissa(Vector512 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_getmant_ss (__m128 a) - /// VGETMANTSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} + /// __m128 _mm_getmant_ss (__m128 a) + /// VGETMANTSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} /// public static Vector128 GetMantissaScalar(Vector128 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_getmant_sd (__m128d a) - /// VGETMANTSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} + /// __m128d _mm_getmant_sd (__m128d a) + /// VGETMANTSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} /// public static Vector128 GetMantissaScalar(Vector128 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_getmant_ss (__m128 a, __m128 b) - /// VGETMANTSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_getmant_ss (__m128 a, __m128 b) + /// VGETMANTSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 GetMantissaScalar(Vector128 upper, Vector128 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_getmant_sd (__m128d a, __m128d b) - /// VGETMANTSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128d _mm_getmant_sd (__m128d a, __m128d b) + /// VGETMANTSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 GetMantissaScalar(Vector128 upper, Vector128 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_inserti128_si512 (__m512i a, __m128i b, const int imm8) - /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512i _mm512_inserti128_si512 (__m512i a, __m128i b, const int imm8) + /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_inserti128_si512 (__m512i a, __m128i b, const int imm8) - /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512i _mm512_inserti128_si512 (__m512i a, __m128i b, const int imm8) + /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_inserti128_si512 (__m512i a, __m128i b, const int imm8) - /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512i _mm512_inserti128_si512 (__m512i a, __m128i b, const int imm8) + /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_inserti128_si512 (__m512i a, __m128i b, const int imm8) - /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512i _mm512_inserti128_si512 (__m512i a, __m128i b, const int imm8) + /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_inserti32x4_epi32 (__m512i a, __m128i b, const int imm8) - /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512i _mm512_inserti32x4_epi32 (__m512i a, __m128i b, const int imm8) + /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_inserti32x4_epi32 (__m512i a, __m128i b, const int imm8) - /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512i _mm512_inserti32x4_epi32 (__m512i a, __m128i b, const int imm8) + /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_inserti128_si512 (__m512i a, __m128i b, const int imm8) - /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512i _mm512_inserti128_si512 (__m512i a, __m128i b, const int imm8) + /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_inserti128_si512 (__m512i a, __m128i b, const int imm8) - /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512i _mm512_inserti128_si512 (__m512i a, __m128i b, const int imm8) + /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_insertf32x4_ps (__m512 a, __m128 b, int imm8) - /// VINSERTF32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512 _mm512_insertf32x4_ps (__m512 a, __m128 b, int imm8) + /// VINSERTF32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_insertf128_pd (__m512d a, __m128d b, int imm8) - /// VINSERTF32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512d _mm512_insertf128_pd (__m512d a, __m128d b, int imm8) + /// VINSERTF32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_inserti256_si512 (__m512i a, __m256i b, const int imm8) - /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512i _mm512_inserti256_si512 (__m512i a, __m256i b, const int imm8) + /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_inserti256_si512 (__m512i a, __m256i b, const int imm8) - /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512i _mm512_inserti256_si512 (__m512i a, __m256i b, const int imm8) + /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_inserti256_si512 (__m512i a, __m256i b, const int imm8) - /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512i _mm512_inserti256_si512 (__m512i a, __m256i b, const int imm8) + /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_inserti256_si512 (__m512i a, __m256i b, const int imm8) - /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512i _mm512_inserti256_si512 (__m512i a, __m256i b, const int imm8) + /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_inserti256_si512 (__m512i a, __m256i b, const int imm8) - /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512i _mm512_inserti256_si512 (__m512i a, __m256i b, const int imm8) + /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_inserti256_si512 (__m512i a, __m256i b, const int imm8) - /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512i _mm512_inserti256_si512 (__m512i a, __m256i b, const int imm8) + /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_inserti64x4_epi64 (__m512i a, __m256i b, const int imm8) - /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512i _mm512_inserti64x4_epi64 (__m512i a, __m256i b, const int imm8) + /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_inserti64x4_epi64 (__m512i a, __m256i b, const int imm8) - /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512i _mm512_inserti64x4_epi64 (__m512i a, __m256i b, const int imm8) + /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_insertf256_ps (__m512 a, __m256 b, int imm8) - /// VINSERTF64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512 _mm512_insertf256_ps (__m512 a, __m256 b, int imm8) + /// VINSERTF64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_insertf64x4_pd (__m512d a, __m256d b, int imm8) - /// VINSERTF64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512d _mm512_insertf64x4_pd (__m512d a, __m256d b, int imm8) + /// VINSERTF64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_load_si512 (__m512i const * mem_addr) - /// VMOVDQA32 zmm1 {k1}{z}, m512 + /// __m512i _mm512_load_si512 (__m512i const * mem_addr) + /// VMOVDQA32 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadAlignedVector512(byte* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_load_si512 (__m512i const * mem_addr) - /// VMOVDQA32 zmm1 {k1}{z}, m512 + /// __m512i _mm512_load_si512 (__m512i const * mem_addr) + /// VMOVDQA32 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadAlignedVector512(sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_load_si512 (__m512i const * mem_addr) - /// VMOVDQA32 zmm1 {k1}{z}, m512 + /// __m512i _mm512_load_si512 (__m512i const * mem_addr) + /// VMOVDQA32 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadAlignedVector512(short* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_load_si512 (__m512i const * mem_addr) - /// VMOVDQA32 zmm1 {k1}{z}, m512 + /// __m512i _mm512_load_si512 (__m512i const * mem_addr) + /// VMOVDQA32 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadAlignedVector512(ushort* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_load_epi32 (__m512i const * mem_addr) - /// VMOVDQA32 zmm1 {k1}{z}, m512 + /// __m512i _mm512_load_epi32 (__m512i const * mem_addr) + /// VMOVDQA32 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadAlignedVector512(int* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_load_epi32 (__m512i const * mem_addr) - /// VMOVDQA32 zmm1 {k1}{z}, m512 + /// __m512i _mm512_load_epi32 (__m512i const * mem_addr) + /// VMOVDQA32 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadAlignedVector512(uint* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_load_epi64 (__m512i const * mem_addr) - /// VMOVDQA64 zmm1 {k1}{z}, m512 + /// __m512i _mm512_load_epi64 (__m512i const * mem_addr) + /// VMOVDQA64 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadAlignedVector512(long* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_load_epi64 (__m512i const * mem_addr) - /// VMOVDQA64 zmm1 {k1}{z}, m512 + /// __m512i _mm512_load_epi64 (__m512i const * mem_addr) + /// VMOVDQA64 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadAlignedVector512(ulong* address) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_load_ps (float const * mem_addr) - /// VMOVAPS zmm1 {k1}{z}, m512 + /// __m512 _mm512_load_ps (float const * mem_addr) + /// VMOVAPS zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadAlignedVector512(float* address) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_load_pd (double const * mem_addr) - /// VMOVAPD zmm1 {k1}{z}, m512 + /// __m512d _mm512_load_pd (double const * mem_addr) + /// VMOVAPD zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadAlignedVector512(double* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) - /// VMOVNTDQA zmm1, m512 + /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) + /// VMOVNTDQA zmm1, m512 /// public static unsafe Vector512 LoadAlignedVector512NonTemporal(sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) - /// VMOVNTDQA zmm1, m512 + /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) + /// VMOVNTDQA zmm1, m512 /// public static unsafe Vector512 LoadAlignedVector512NonTemporal(byte* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) - /// VMOVNTDQA zmm1, m512 + /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) + /// VMOVNTDQA zmm1, m512 /// public static unsafe Vector512 LoadAlignedVector512NonTemporal(short* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) - /// VMOVNTDQA zmm1, m512 + /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) + /// VMOVNTDQA zmm1, m512 /// public static unsafe Vector512 LoadAlignedVector512NonTemporal(ushort* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) - /// VMOVNTDQA zmm1, m512 + /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) + /// VMOVNTDQA zmm1, m512 /// public static unsafe Vector512 LoadAlignedVector512NonTemporal(int* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) - /// VMOVNTDQA zmm1, m512 + /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) + /// VMOVNTDQA zmm1, m512 /// public static unsafe Vector512 LoadAlignedVector512NonTemporal(uint* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) - /// VMOVNTDQA zmm1, m512 + /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) + /// VMOVNTDQA zmm1, m512 /// public static unsafe Vector512 LoadAlignedVector512NonTemporal(long* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) - /// VMOVNTDQA zmm1, m512 + /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) + /// VMOVNTDQA zmm1, m512 /// public static unsafe Vector512 LoadAlignedVector512NonTemporal(ulong* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr) - /// VMOVDQU32 zmm1 {k1}{z}, m512 + /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr) + /// VMOVDQU32 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadVector512(sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr) - /// VMOVDQU32 zmm1 {k1}{z}, m512 + /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr) + /// VMOVDQU32 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadVector512(byte* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr) - /// VMOVDQU32 zmm1 {k1}{z}, m512 + /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr) + /// VMOVDQU32 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadVector512(short* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr) - /// VMOVDQU32 zmm1 {k1}{z}, m512 + /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr) + /// VMOVDQU32 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadVector512(ushort* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_loadu_epi32 (__m512i const * mem_addr) - /// VMOVDQU32 zmm1 {k1}{z}, m512 + /// __m512i _mm512_loadu_epi32 (__m512i const * mem_addr) + /// VMOVDQU32 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadVector512(int* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_loadu_epi32 (__m512i const * mem_addr) - /// VMOVDQU32 zmm1 {k1}{z}, m512 + /// __m512i _mm512_loadu_epi32 (__m512i const * mem_addr) + /// VMOVDQU32 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadVector512(uint* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_loadu_epi64 (__m512i const * mem_addr) - /// VMOVDQU64 zmm1 {k1}{z}, m512 + /// __m512i _mm512_loadu_epi64 (__m512i const * mem_addr) + /// VMOVDQU64 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadVector512(long* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_loadu_epi64 (__m512i const * mem_addr) - /// VMOVDQU64 zmm1 {k1}{z}, m512 + /// __m512i _mm512_loadu_epi64 (__m512i const * mem_addr) + /// VMOVDQU64 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadVector512(ulong* address) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_loadu_ps (float const * mem_addr) - /// VMOVUPS zmm1 {k1}{z}, m512 + /// __m512 _mm512_loadu_ps (float const * mem_addr) + /// VMOVUPS zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadVector512(float* address) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_loadu_pd (double const * mem_addr) - /// VMOVUPD zmm1 {k1}{z}, m512 + /// __m512d _mm512_loadu_pd (double const * mem_addr) + /// VMOVUPD zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadVector512(double* address) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_max_epi32 (__m512i a, __m512i b) - /// VPMAXSD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_max_epi32 (__m512i a, __m512i b) + /// VPMAXSD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Max(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_max_epu32 (__m512i a, __m512i b) - /// VPMAXUD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_max_epu32 (__m512i a, __m512i b) + /// VPMAXUD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Max(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_max_epi64 (__m512i a, __m512i b) - /// VPMAXSQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_max_epi64 (__m512i a, __m512i b) + /// VPMAXSQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Max(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_max_epu64 (__m512i a, __m512i b) - /// VPMAXUQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_max_epu64 (__m512i a, __m512i b) + /// VPMAXUQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Max(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_max_ps (__m512 a, __m512 b) - /// VMAXPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae} + /// __m512 _mm512_max_ps (__m512 a, __m512 b) + /// VMAXPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae} /// public static Vector512 Max(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_max_pd (__m512d a, __m512d b) - /// VMAXPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae} + /// __m512d _mm512_max_pd (__m512d a, __m512d b) + /// VMAXPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae} /// public static Vector512 Max(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_min_epi32 (__m512i a, __m512i b) - /// VPMINSD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_min_epi32 (__m512i a, __m512i b) + /// VPMINSD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Min(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_min_epu32 (__m512i a, __m512i b) - /// VPMINUD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_min_epu32 (__m512i a, __m512i b) + /// VPMINUD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Min(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_min_epi64 (__m512i a, __m512i b) - /// VPMINSQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_min_epi64 (__m512i a, __m512i b) + /// VPMINSQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Min(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_min_epu64 (__m512i a, __m512i b) - /// VPMINUQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_min_epu64 (__m512i a, __m512i b) + /// VPMINUQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Min(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_min_ps (__m512 a, __m512 b) - /// VMINPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae} + /// __m512 _mm512_min_ps (__m512 a, __m512 b) + /// VMINPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae} /// public static Vector512 Min(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_min_pd (__m512d a, __m512d b) - /// VMINPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae} + /// __m512d _mm512_min_pd (__m512d a, __m512d b) + /// VMINPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae} /// public static Vector512 Min(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_mul_epi32 (__m512i a, __m512i b) - /// VPMULDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_mul_epi32 (__m512i a, __m512i b) + /// VPMULDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Multiply(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_mul_epu32 (__m512i a, __m512i b) - /// VPMULUDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_mul_epu32 (__m512i a, __m512i b) + /// VPMULUDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Multiply(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_mul_ps (__m512 a, __m512 b) - /// VMULPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er} + /// __m512 _mm512_mul_ps (__m512 a, __m512 b) + /// VMULPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er} /// public static Vector512 Multiply(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_mul_pd (__m512d a, __m512d b) - /// VMULPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er} + /// __m512d _mm512_mul_pd (__m512d a, __m512d b) + /// VMULPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er} /// public static Vector512 Multiply(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_mul_round_ps (__m512 a, __m512 b, int rounding) - /// VMULPS zmm1, zmm2, zmm3 {er} + /// __m512 _mm512_mul_round_ps (__m512 a, __m512 b, int rounding) + /// VMULPS zmm1, zmm2, zmm3 {er} /// public static Vector512 Multiply(Vector512 left, Vector512 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_mul_round_pd (__m512d a, __m512d b, int rounding) - /// VMULPD zmm1, zmm2, zmm3 {er} + /// __m512d _mm512_mul_round_pd (__m512d a, __m512d b, int rounding) + /// VMULPD zmm1, zmm2, zmm3 {er} /// public static Vector512 Multiply(Vector512 left, Vector512 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_mul_round_ss (__m128 a, __m128 b, int rounding) - /// VMULSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_mul_round_ss (__m128 a, __m128 b, int rounding) + /// VMULSS xmm1, xmm2, xmm3 {er} /// public static Vector128 MultiplyScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_mul_round_sd (__m128d a, __m128d b, int rounding) - /// VMULSD xmm1, xmm2, xmm3 {er} + /// __m128d _mm_mul_round_sd (__m128d a, __m128d b, int rounding) + /// VMULSD xmm1, xmm2, xmm3 {er} /// public static Vector128 MultiplyScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_mullo_epi32 (__m512i a, __m512i b) - /// VPMULLD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_mullo_epi32 (__m512i a, __m512i b) + /// VPMULLD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 MultiplyLow(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_mullo_epi32 (__m512i a, __m512i b) - /// VPMULLD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_mullo_epi32 (__m512i a, __m512i b) + /// VPMULLD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 MultiplyLow(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_or_si512 (__m512i a, __m512i b) - /// VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_or_si512 (__m512i a, __m512i b) + /// VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Or(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_or_si512 (__m512i a, __m512i b) - /// VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_or_si512 (__m512i a, __m512i b) + /// VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Or(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_or_si512 (__m512i a, __m512i b) - /// VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_or_si512 (__m512i a, __m512i b) + /// VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Or(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_or_si512 (__m512i a, __m512i b) - /// VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_or_si512 (__m512i a, __m512i b) + /// VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Or(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_or_epi32 (__m512i a, __m512i b) - /// VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_or_epi32 (__m512i a, __m512i b) + /// VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Or(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_or_epi32 (__m512i a, __m512i b) - /// VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_or_epi32 (__m512i a, __m512i b) + /// VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Or(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_or_epi64 (__m512i a, __m512i b) - /// VPORQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_or_epi64 (__m512i a, __m512i b) + /// VPORQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Or(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_or_epi64 (__m512i a, __m512i b) - /// VPORQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_or_epi64 (__m512i a, __m512i b) + /// VPORQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Or(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_permute_pd (__m512d a, int imm8) - /// VPERMILPD zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 + /// __m512d _mm512_permute_pd (__m512d a, int imm8) + /// VPERMILPD zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 /// public static Vector512 Permute2x64(Vector512 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_permute_ps (__m512 a, int imm8) - /// VPERMILPS zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 + /// __m512 _mm512_permute_ps (__m512 a, int imm8) + /// VPERMILPS zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 /// public static Vector512 Permute4x32(Vector512 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_permute4x64_epi64 (__m512i a, const int imm8) - /// VPERMQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 + /// __m512i _mm512_permute4x64_epi64 (__m512i a, const int imm8) + /// VPERMQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 /// public static Vector512 Permute4x64(Vector512 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_permute4x64_epi64 (__m512i a, const int imm8) - /// VPERMQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 + /// __m512i _mm512_permute4x64_epi64 (__m512i a, const int imm8) + /// VPERMQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 /// public static Vector512 Permute4x64(Vector512 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_permute4x64_pd (__m512d a, const int imm8) - /// VPERMPD zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 + /// __m512d _mm512_permute4x64_pd (__m512d a, const int imm8) + /// VPERMPD zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 /// public static Vector512 Permute4x64(Vector512 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_permutevar_pd (__m512d a, __m512i b) - /// VPERMILPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_permutevar_pd (__m512d a, __m512i b) + /// VPERMILPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 PermuteVar2x64(Vector512 left, Vector512 control) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_permutevar_ps (__m512 a, __m512i b) - /// VPERMILPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_permutevar_ps (__m512 a, __m512i b) + /// VPERMILPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 PermuteVar4x32(Vector512 left, Vector512 control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_permutevar8x64_epi64 (__m512i a, __m512i b) - /// VPERMQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_permutevar8x64_epi64 (__m512i a, __m512i b) + /// VPERMQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 PermuteVar8x64(Vector512 value, Vector512 control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_permutevar8x64_epi64 (__m512i a, __m512i b) - /// VPERMQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_permutevar8x64_epi64 (__m512i a, __m512i b) + /// VPERMQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 PermuteVar8x64(Vector512 value, Vector512 control) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_permutevar8x64_pd (__m512d a, __m512i b) - /// VPERMPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_permutevar8x64_pd (__m512d a, __m512i b) + /// VPERMPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 PermuteVar8x64(Vector512 value, Vector512 control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_permutex2var_epi64 (__m512i a, __m512i idx, __m512i b) - /// VPERMI2Q zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst - /// VPERMT2Q zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_permutex2var_epi64 (__m512i a, __m512i idx, __m512i b) + /// VPERMI2Q zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// VPERMT2Q zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 PermuteVar8x64x2(Vector512 lower, Vector512 indices, Vector512 upper) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_permutex2var_epi64 (__m512i a, __m512i idx, __m512i b) - /// VPERMI2Q zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst - /// VPERMT2Q zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_permutex2var_epi64 (__m512i a, __m512i idx, __m512i b) + /// VPERMI2Q zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// VPERMT2Q zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 PermuteVar8x64x2(Vector512 lower, Vector512 indices, Vector512 upper) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_permutex2var_pd (__m512d a, __m512i idx, __m512i b) - /// VPERMI2PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst - /// VPERMT2PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_permutex2var_pd (__m512d a, __m512i idx, __m512i b) + /// VPERMI2PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// VPERMT2PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 PermuteVar8x64x2(Vector512 lower, Vector512 indices, Vector512 upper) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_permutevar16x32_epi32 (__m512i a, __m512i b) - /// VPERMD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_permutevar16x32_epi32 (__m512i a, __m512i b) + /// VPERMD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 PermuteVar16x32(Vector512 left, Vector512 control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_permutevar16x32_epi32 (__m512i a, __m512i b) - /// VPERMD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_permutevar16x32_epi32 (__m512i a, __m512i b) + /// VPERMD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 PermuteVar16x32(Vector512 left, Vector512 control) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_permutevar16x32_ps (__m512 a, __m512i b) - /// VPERMPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_permutevar16x32_ps (__m512 a, __m512i b) + /// VPERMPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 PermuteVar16x32(Vector512 left, Vector512 control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_permutex2var_epi32 (__m512i a, __m512i idx, __m512i b) - /// VPERMI2D zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst - /// VPERMT2D zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_permutex2var_epi32 (__m512i a, __m512i idx, __m512i b) + /// VPERMI2D zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// VPERMT2D zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 PermuteVar16x32x2(Vector512 lower, Vector512 indices, Vector512 upper) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_permutex2var_epi32 (__m512i a, __m512i idx, __m512i b) - /// VPERMI2D zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst - /// VPERMT2D zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_permutex2var_epi32 (__m512i a, __m512i idx, __m512i b) + /// VPERMI2D zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// VPERMT2D zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 PermuteVar16x32x2(Vector512 lower, Vector512 indices, Vector512 upper) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_permutex2var_ps (__m512 a, __m512i idx, __m512i b) - /// VPERMI2PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst - /// VPERMT2PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_permutex2var_ps (__m512 a, __m512i idx, __m512i b) + /// VPERMI2PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// VPERMT2PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 PermuteVar16x32x2(Vector512 lower, Vector512 indices, Vector512 upper) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_rcp14_ps (__m512 a, __m512 b) - /// VRCP14PS zmm1 {k1}{z}, zmm2/m512/m32bcst + /// __m512 _mm512_rcp14_ps (__m512 a, __m512 b) + /// VRCP14PS zmm1 {k1}{z}, zmm2/m512/m32bcst /// public static Vector512 Reciprocal14(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_rcp14_pd (__m512d a, __m512d b) - /// VRCP14PD zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512d _mm512_rcp14_pd (__m512d a, __m512d b) + /// VRCP14PD zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 Reciprocal14(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_rcp14_ss (__m128 a) - /// VRCP14SS xmm1 {k1}{z}, xmm2, xmm3/m32 + /// __m128 _mm_rcp14_ss (__m128 a) + /// VRCP14SS xmm1 {k1}{z}, xmm2, xmm3/m32 /// public static Vector128 Reciprocal14Scalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_rcp14_sd (__m128d a) - /// VRCP14SD xmm1 {k1}{z}, xmm2, xmm3/m64 + /// __m128d _mm_rcp14_sd (__m128d a) + /// VRCP14SD xmm1 {k1}{z}, xmm2, xmm3/m64 /// public static Vector128 Reciprocal14Scalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_rcp14_ss (__m128 a, __m128 b) - /// VRCP14SS xmm1 {k1}{z}, xmm2, xmm3/m32 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_rcp14_ss (__m128 a, __m128 b) + /// VRCP14SS xmm1 {k1}{z}, xmm2, xmm3/m32 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 Reciprocal14Scalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_rcp14_sd (__m128d a, __m128d b) - /// VRCP14SD xmm1 {k1}{z}, xmm2, xmm3/m64 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128d _mm_rcp14_sd (__m128d a, __m128d b) + /// VRCP14SD xmm1 {k1}{z}, xmm2, xmm3/m64 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 Reciprocal14Scalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_rsqrt14_ps (__m512 a, __m512 b) - /// VRSQRT14PS zmm1 {k1}{z}, zmm2/m512/m32bcst + /// __m512 _mm512_rsqrt14_ps (__m512 a, __m512 b) + /// VRSQRT14PS zmm1 {k1}{z}, zmm2/m512/m32bcst /// public static Vector512 ReciprocalSqrt14(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_rsqrt14_pd (__m512d a, __m512d b) - /// VRSQRT14PD zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512d _mm512_rsqrt14_pd (__m512d a, __m512d b) + /// VRSQRT14PD zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 ReciprocalSqrt14(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_rsqrt14_ss (__m128 a) - /// VRSQRT14SS xmm1 {k1}{z}, xmm2, xmm3/m32 + /// __m128 _mm_rsqrt14_ss (__m128 a) + /// VRSQRT14SS xmm1 {k1}{z}, xmm2, xmm3/m32 /// public static Vector128 ReciprocalSqrt14Scalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_rsqrt14_sd (__m128d a) - /// VRSQRT14SD xmm1 {k1}{z}, xmm2, xmm3/m64 + /// __m128d _mm_rsqrt14_sd (__m128d a) + /// VRSQRT14SD xmm1 {k1}{z}, xmm2, xmm3/m64 /// public static Vector128 ReciprocalSqrt14Scalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_rsqrt14_ss (__m128 a, __m128 b) - /// VRSQRT14SS xmm1 {k1}{z}, xmm2, xmm3/m32 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_rsqrt14_ss (__m128 a, __m128 b) + /// VRSQRT14SS xmm1 {k1}{z}, xmm2, xmm3/m32 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 ReciprocalSqrt14Scalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_rsqrt14_sd (__m128d a, __m128d b) - /// VRSQRT14SD xmm1 {k1}{z}, xmm2, xmm3/m64 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128d _mm_rsqrt14_sd (__m128d a, __m128d b) + /// VRSQRT14SD xmm1 {k1}{z}, xmm2, xmm3/m64 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 ReciprocalSqrt14Scalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_rol_epi32 (__m512i a, int imm8) - /// VPROLD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 + /// __m512i _mm512_rol_epi32 (__m512i a, int imm8) + /// VPROLD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 /// public static Vector512 RotateLeft(Vector512 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_rol_epi32 (__m512i a, int imm8) - /// VPROLD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 + /// __m512i _mm512_rol_epi32 (__m512i a, int imm8) + /// VPROLD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 /// public static Vector512 RotateLeft(Vector512 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_rol_epi64 (__m512i a, int imm8) - /// VPROLQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 + /// __m512i _mm512_rol_epi64 (__m512i a, int imm8) + /// VPROLQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 /// public static Vector512 RotateLeft(Vector512 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_rol_epi64 (__m512i a, int imm8) - /// VPROLQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 + /// __m512i _mm512_rol_epi64 (__m512i a, int imm8) + /// VPROLQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 /// public static Vector512 RotateLeft(Vector512 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_rolv_epi32 (__m512i a, __m512i b) - /// VPROLDV zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_rolv_epi32 (__m512i a, __m512i b) + /// VPROLDV zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 RotateLeftVariable(Vector512 value, Vector512 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_rolv_epi32 (__m512i a, __m512i b) - /// VPROLDV zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_rolv_epi32 (__m512i a, __m512i b) + /// VPROLDV zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 RotateLeftVariable(Vector512 value, Vector512 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_rolv_epi64 (__m512i a, __m512i b) - /// VPROLQV zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_rolv_epi64 (__m512i a, __m512i b) + /// VPROLQV zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 RotateLeftVariable(Vector512 value, Vector512 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_rolv_epi64 (__m512i a, __m512i b) - /// VPROLQV zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_rolv_epi64 (__m512i a, __m512i b) + /// VPROLQV zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 RotateLeftVariable(Vector512 value, Vector512 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_ror_epi32 (__m512i a, int imm8) - /// VPRORD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 + /// __m512i _mm512_ror_epi32 (__m512i a, int imm8) + /// VPRORD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 /// public static Vector512 RotateRight(Vector512 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_ror_epi32 (__m512i a, int imm8) - /// VPRORD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 + /// __m512i _mm512_ror_epi32 (__m512i a, int imm8) + /// VPRORD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 /// public static Vector512 RotateRight(Vector512 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_ror_epi64 (__m512i a, int imm8) - /// VPRORQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 + /// __m512i _mm512_ror_epi64 (__m512i a, int imm8) + /// VPRORQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 /// public static Vector512 RotateRight(Vector512 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_ror_epi64 (__m512i a, int imm8) - /// VPRORQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 + /// __m512i _mm512_ror_epi64 (__m512i a, int imm8) + /// VPRORQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 /// public static Vector512 RotateRight(Vector512 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_rorv_epi32 (__m512i a, __m512i b) - /// VPRORDV zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_rorv_epi32 (__m512i a, __m512i b) + /// VPRORDV zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 RotateRightVariable(Vector512 value, Vector512 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_rorv_epi32 (__m512i a, __m512i b) - /// VPRORDV zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_rorv_epi32 (__m512i a, __m512i b) + /// VPRORDV zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 RotateRightVariable(Vector512 value, Vector512 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_rorv_epi64 (__m512i a, __m512i b) - /// VPRORQV zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_rorv_epi64 (__m512i a, __m512i b) + /// VPRORQV zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 RotateRightVariable(Vector512 value, Vector512 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_rorv_epi64 (__m512i a, __m512i b) - /// VPRORQV zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_rorv_epi64 (__m512i a, __m512i b) + /// VPRORQV zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 RotateRightVariable(Vector512 value, Vector512 count) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_roundscale_ps (__m512 a, int imm) - /// VRNDSCALEPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}, imm8 + /// __m512 _mm512_roundscale_ps (__m512 a, int imm) + /// VRNDSCALEPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}, imm8 /// public static Vector512 RoundScale(Vector512 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_roundscale_pd (__m512d a, int imm) - /// VRNDSCALEPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}, imm8 + /// __m512d _mm512_roundscale_pd (__m512d a, int imm) + /// VRNDSCALEPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}, imm8 /// public static Vector512 RoundScale(Vector512 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_roundscale_ss (__m128 a, int imm) - /// VRNDSCALESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 + /// __m128 _mm_roundscale_ss (__m128 a, int imm) + /// VRNDSCALESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 /// public static Vector128 RoundScaleScalar(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_roundscale_sd (__m128d a, int imm) - /// VRNDSCALESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 + /// __m128d _mm_roundscale_sd (__m128d a, int imm) + /// VRNDSCALESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 /// public static Vector128 RoundScaleScalar(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_roundscale_ss (__m128 a, __m128 b, int imm) - /// VRNDSCALESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_roundscale_ss (__m128 a, __m128 b, int imm) + /// VRNDSCALESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 RoundScaleScalar(Vector128 upper, Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_roundscale_sd (__m128d a, __m128d b, int imm) - /// VRNDSCALESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128d _mm_roundscale_sd (__m128d a, __m128d b, int imm) + /// VRNDSCALESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 RoundScaleScalar(Vector128 upper, Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_scalef_ps (__m512 a, __m512 b) - /// VSCALEFPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er} + /// __m512 _mm512_scalef_ps (__m512 a, __m512 b) + /// VSCALEFPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er} /// public static Vector512 Scale(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_scalef_pd (__m512d a, __m512d b) - /// VSCALEFPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er} + /// __m512d _mm512_scalef_pd (__m512d a, __m512d b) + /// VSCALEFPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er} /// public static Vector512 Scale(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_scalef_round_ps (__m512 a, __m512 b, int rounding) - /// VSCALEFPS zmm1, zmm2, zmm3 {er} + /// __m512 _mm512_scalef_round_ps (__m512 a, __m512 b, int rounding) + /// VSCALEFPS zmm1, zmm2, zmm3 {er} /// public static Vector512 Scale(Vector512 left, Vector512 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_scalef_round_pd (__m512d a, __m512d b, int rounding) - /// VSCALEFPD zmm1, zmm2, zmm3 {er} + /// __m512d _mm512_scalef_round_pd (__m512d a, __m512d b, int rounding) + /// VSCALEFPD zmm1, zmm2, zmm3 {er} /// public static Vector512 Scale(Vector512 left, Vector512 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_scalef_ss (__m128 a, __m128 b) - /// VSCALEFSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} + /// __m128 _mm_scalef_ss (__m128 a, __m128 b) + /// VSCALEFSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} /// public static Vector128 ScaleScalar(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_scalef_sd (__m128d a, __m128d b) - /// VSCALEFSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} + /// __m128d _mm_scalef_sd (__m128d a, __m128d b) + /// VSCALEFSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} /// public static Vector128 ScaleScalar(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_scalef_round_ss (__m128 a, __m128 b) - /// VSCALEFSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_scalef_round_ss (__m128 a, __m128 b) + /// VSCALEFSS xmm1, xmm2, xmm3 {er} /// public static Vector128 ScaleScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_scalef_round_sd (__m128d a, __m128d b) - /// VSCALEFSD xmm1, xmm2, xmm3 {er} + /// __m128d _mm_scalef_round_sd (__m128d a, __m128d b) + /// VSCALEFSD xmm1, xmm2, xmm3 {er} /// public static Vector128 ScaleScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_sll_epi32 (__m512i a, __m128i count) - /// VPSLLD zmm1 {k1}{z}, zmm2, xmm3/m128 + /// __m512i _mm512_sll_epi32 (__m512i a, __m128i count) + /// VPSLLD zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftLeftLogical(Vector512 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_sll_epi32 (__m512i a, __m128i count) - /// VPSLLD zmm1 {k1}{z}, zmm2, xmm3/m128 + /// __m512i _mm512_sll_epi32 (__m512i a, __m128i count) + /// VPSLLD zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftLeftLogical(Vector512 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_sll_epi64 (__m512i a, __m128i count) - /// VPSLLQ zmm1 {k1}{z}, zmm2, xmm3/m128 + /// __m512i _mm512_sll_epi64 (__m512i a, __m128i count) + /// VPSLLQ zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftLeftLogical(Vector512 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_sll_epi64 (__m512i a, __m128i count) - /// VPSLLQ zmm1 {k1}{z}, zmm2, xmm3/m128 + /// __m512i _mm512_sll_epi64 (__m512i a, __m128i count) + /// VPSLLQ zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftLeftLogical(Vector512 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_slli_epi32 (__m512i a, int imm8) - /// VPSLLD zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_slli_epi32 (__m512i a, int imm8) + /// VPSLLD zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftLeftLogical(Vector512 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_slli_epi32 (__m512i a, int imm8) - /// VPSLLD zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_slli_epi32 (__m512i a, int imm8) + /// VPSLLD zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftLeftLogical(Vector512 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_slli_epi64 (__m512i a, int imm8) - /// VPSLLQ zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_slli_epi64 (__m512i a, int imm8) + /// VPSLLQ zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftLeftLogical(Vector512 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_slli_epi64 (__m512i a, int imm8) - /// VPSLLQ zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_slli_epi64 (__m512i a, int imm8) + /// VPSLLQ zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftLeftLogical(Vector512 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_sllv_epi32 (__m512i a, __m512i count) - /// VPSLLVD ymm1 {k1}{z}, ymm2, ymm3/m512/m32bcst + /// __m512i _mm512_sllv_epi32 (__m512i a, __m512i count) + /// VPSLLVD ymm1 {k1}{z}, ymm2, ymm3/m512/m32bcst /// public static Vector512 ShiftLeftLogicalVariable(Vector512 value, Vector512 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_sllv_epi32 (__m512i a, __m512i count) - /// VPSLLVD ymm1 {k1}{z}, ymm2, ymm3/m512/m32bcst + /// __m512i _mm512_sllv_epi32 (__m512i a, __m512i count) + /// VPSLLVD ymm1 {k1}{z}, ymm2, ymm3/m512/m32bcst /// public static Vector512 ShiftLeftLogicalVariable(Vector512 value, Vector512 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_sllv_epi64 (__m512i a, __m512i count) - /// VPSLLVQ ymm1 {k1}{z}, ymm2, ymm3/m512/m64bcst + /// __m512i _mm512_sllv_epi64 (__m512i a, __m512i count) + /// VPSLLVQ ymm1 {k1}{z}, ymm2, ymm3/m512/m64bcst /// public static Vector512 ShiftLeftLogicalVariable(Vector512 value, Vector512 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_sllv_epi64 (__m512i a, __m512i count) - /// VPSLLVQ ymm1 {k1}{z}, ymm2, ymm3/m512/m64bcst + /// __m512i _mm512_sllv_epi64 (__m512i a, __m512i count) + /// VPSLLVQ ymm1 {k1}{z}, ymm2, ymm3/m512/m64bcst /// public static Vector512 ShiftLeftLogicalVariable(Vector512 value, Vector512 count) { throw new PlatformNotSupportedException(); } /// - /// _mm512_sra_epi32 (__m512i a, __m128i count) - /// VPSRAD zmm1 {k1}{z}, zmm2, xmm3/m128 + /// _mm512_sra_epi32 (__m512i a, __m128i count) + /// VPSRAD zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftRightArithmetic(Vector512 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// _mm512_sra_epi64 (__m512i a, __m128i count) - /// VPSRAQ zmm1 {k1}{z}, zmm2, xmm3/m128 + /// _mm512_sra_epi64 (__m512i a, __m128i count) + /// VPSRAQ zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftRightArithmetic(Vector512 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_srai_epi32 (__m512i a, int imm8) - /// VPSRAD zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_srai_epi32 (__m512i a, int imm8) + /// VPSRAD zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftRightArithmetic(Vector512 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_srai_epi64 (__m512i a, int imm8) - /// VPSRAQ zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_srai_epi64 (__m512i a, int imm8) + /// VPSRAQ zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftRightArithmetic(Vector512 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_srav_epi32 (__m512i a, __m512i count) - /// VPSRAVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_srav_epi32 (__m512i a, __m512i count) + /// VPSRAVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 ShiftRightArithmeticVariable(Vector512 value, Vector512 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_srav_epi64 (__m512i a, __m512i count) - /// VPSRAVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_srav_epi64 (__m512i a, __m512i count) + /// VPSRAVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 ShiftRightArithmeticVariable(Vector512 value, Vector512 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_srl_epi32 (__m512i a, __m128i count) - /// VPSRLD zmm1 {k1}{z}, zmm2, xmm3/m128 + /// __m512i _mm512_srl_epi32 (__m512i a, __m128i count) + /// VPSRLD zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftRightLogical(Vector512 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_srl_epi32 (__m512i a, __m128i count) - /// VPSRLD zmm1 {k1}{z}, zmm2, xmm3/m128 + /// __m512i _mm512_srl_epi32 (__m512i a, __m128i count) + /// VPSRLD zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftRightLogical(Vector512 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_srl_epi64 (__m512i a, __m128i count) - /// VPSRLQ zmm1 {k1}{z}, zmm2, xmm3/m128 + /// __m512i _mm512_srl_epi64 (__m512i a, __m128i count) + /// VPSRLQ zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftRightLogical(Vector512 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_srl_epi64 (__m512i a, __m128i count) - /// VPSRLQ zmm1 {k1}{z}, zmm2, xmm3/m128 + /// __m512i _mm512_srl_epi64 (__m512i a, __m128i count) + /// VPSRLQ zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftRightLogical(Vector512 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_srli_epi32 (__m512i a, int imm8) - /// VPSRLD zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_srli_epi32 (__m512i a, int imm8) + /// VPSRLD zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftRightLogical(Vector512 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_srli_epi32 (__m512i a, int imm8) - /// VPSRLD zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_srli_epi32 (__m512i a, int imm8) + /// VPSRLD zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftRightLogical(Vector512 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_srli_epi64 (__m512i a, int imm8) - /// VPSRLQ zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_srli_epi64 (__m512i a, int imm8) + /// VPSRLQ zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftRightLogical(Vector512 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_srli_epi64 (__m512i a, int imm8) - /// VPSRLQ zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_srli_epi64 (__m512i a, int imm8) + /// VPSRLQ zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftRightLogical(Vector512 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_srlv_epi32 (__m512i a, __m512i count) - /// VPSRLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_srlv_epi32 (__m512i a, __m512i count) + /// VPSRLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 ShiftRightLogicalVariable(Vector512 value, Vector512 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_srlv_epi32 (__m512i a, __m512i count) - /// VPSRLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_srlv_epi32 (__m512i a, __m512i count) + /// VPSRLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 ShiftRightLogicalVariable(Vector512 value, Vector512 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_srlv_epi64 (__m512i a, __m512i count) - /// VPSRLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_srlv_epi64 (__m512i a, __m512i count) + /// VPSRLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 ShiftRightLogicalVariable(Vector512 value, Vector512 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_srlv_epi64 (__m512i a, __m512i count) - /// VPSRLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_srlv_epi64 (__m512i a, __m512i count) + /// VPSRLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 ShiftRightLogicalVariable(Vector512 value, Vector512 count) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_shuffle_epi32 (__m512i a, const int imm8) - /// VPSHUFD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 + /// __m512i _mm512_shuffle_epi32 (__m512i a, const int imm8) + /// VPSHUFD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 /// public static Vector512 Shuffle(Vector512 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_shuffle_epi32 (__m512i a, const int imm8) - /// VPSHUFD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 + /// __m512i _mm512_shuffle_epi32 (__m512i a, const int imm8) + /// VPSHUFD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 /// public static Vector512 Shuffle(Vector512 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_shuffle_ps (__m512 a, __m512 b, const int imm8) - /// VSHUFPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 + /// __m512 _mm512_shuffle_ps (__m512 a, __m512 b, const int imm8) + /// VSHUFPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 /// public static Vector512 Shuffle(Vector512 value, Vector512 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_shuffle_pd (__m512d a, __m512d b, const int imm8) - /// VSHUFPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 + /// __m512d _mm512_shuffle_pd (__m512d a, __m512d b, const int imm8) + /// VSHUFPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 /// public static Vector512 Shuffle(Vector512 value, Vector512 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_shuffle_f64x2 (__m512d a, __m512d b, const int imm8) - /// VSHUFF64x2 zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 + /// __m512d _mm512_shuffle_f64x2 (__m512d a, __m512d b, const int imm8) + /// VSHUFF64x2 zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 /// public static Vector512 Shuffle4x128(Vector512 left, Vector512 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_shuffle_i32x4 (__m512i a, __m512i b, const int imm8) - /// VSHUFI32x4 zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 + /// __m512i _mm512_shuffle_i32x4 (__m512i a, __m512i b, const int imm8) + /// VSHUFI32x4 zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 /// public static Vector512 Shuffle4x128(Vector512 left, Vector512 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_shuffle_i64x2 (__m512i a, __m512i b, const int imm8) - /// VSHUFI64x2 zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 + /// __m512i _mm512_shuffle_i64x2 (__m512i a, __m512i b, const int imm8) + /// VSHUFI64x2 zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 /// public static Vector512 Shuffle4x128(Vector512 left, Vector512 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_shuffle_f32x4 (__m512 a, __m512 b, const int imm8) - /// VSHUFF32x4 zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 + /// __m512 _mm512_shuffle_f32x4 (__m512 a, __m512 b, const int imm8) + /// VSHUFF32x4 zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 /// public static Vector512 Shuffle4x128(Vector512 left, Vector512 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_shuffle_i32x4 (__m512i a, __m512i b, const int imm8) - /// VSHUFI32x4 zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 + /// __m512i _mm512_shuffle_i32x4 (__m512i a, __m512i b, const int imm8) + /// VSHUFI32x4 zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 /// public static Vector512 Shuffle4x128(Vector512 left, Vector512 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_shuffle_i64x2 (__m512i a, __m512i b, const int imm8) - /// VSHUFI64x2 zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 + /// __m512i _mm512_shuffle_i64x2 (__m512i a, __m512i b, const int imm8) + /// VSHUFI64x2 zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 /// public static Vector512 Shuffle4x128(Vector512 left, Vector512 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_sqrt_ps (__m512 a) - /// VSQRTPS zmm1 {k1}{z}, zmm2/m512/m32bcst{er} + /// __m512 _mm512_sqrt_ps (__m512 a) + /// VSQRTPS zmm1 {k1}{z}, zmm2/m512/m32bcst{er} /// public static Vector512 Sqrt(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_sqrt_pd (__m512d a) - /// VSQRTPD zmm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m512d _mm512_sqrt_pd (__m512d a) + /// VSQRTPD zmm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector512 Sqrt(Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_sqrt_round_ps (__m512 a, int rounding) - /// VSQRTPS zmm1, zmm2 {er} + /// __m512 _mm512_sqrt_round_ps (__m512 a, int rounding) + /// VSQRTPS zmm1, zmm2 {er} /// public static Vector512 Sqrt(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_sqrt_round_pd (__m512d a, int rounding) - /// VSQRTPD zmm1, zmm2 {er} + /// __m512d _mm512_sqrt_round_pd (__m512d a, int rounding) + /// VSQRTPD zmm1, zmm2 {er} /// public static Vector512 Sqrt(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_sqrt_round_ss (__m128 a, __m128 b, int rounding) - /// VSQRTSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_sqrt_round_ss (__m128 a, __m128 b, int rounding) + /// VSQRTSS xmm1, xmm2, xmm3 {er} /// public static Vector128 SqrtScalar(Vector128 upper, Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_sqrt_round_sd (__m128d a, __m128d b, int rounding) - /// VSQRTSD xmm1, xmm2 xmm3 {er} + /// __m128d _mm_sqrt_round_sd (__m128d a, __m128d b, int rounding) + /// VSQRTSD xmm1, xmm2 xmm3 {er} /// public static Vector128 SqrtScalar(Vector128 upper, Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a) - /// VMOVDQU32 m512 {k1}{z}, zmm1 + /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a) + /// VMOVDQU32 m512 {k1}{z}, zmm1 /// public static unsafe void Store(sbyte* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a) - /// VMOVDQU32 m512 {k1}{z}, zmm1 + /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a) + /// VMOVDQU32 m512 {k1}{z}, zmm1 /// public static unsafe void Store(byte* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a) - /// VMOVDQU32 m512 {k1}{z}, zmm1 + /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a) + /// VMOVDQU32 m512 {k1}{z}, zmm1 /// public static unsafe void Store(short* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a) - /// VMOVDQU32 m512 {k1}{z}, zmm1 + /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a) + /// VMOVDQU32 m512 {k1}{z}, zmm1 /// public static unsafe void Store(ushort* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_storeu_epi32 (__m512i * mem_addr, __m512i a) - /// VMOVDQU32 m512 {k1}{z}, zmm1 + /// void _mm512_storeu_epi32 (__m512i * mem_addr, __m512i a) + /// VMOVDQU32 m512 {k1}{z}, zmm1 /// public static unsafe void Store(int* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_storeu_epi32 (__m512i * mem_addr, __m512i a) - /// VMOVDQU32 m512 {k1}{z}, zmm1 + /// void _mm512_storeu_epi32 (__m512i * mem_addr, __m512i a) + /// VMOVDQU32 m512 {k1}{z}, zmm1 /// public static unsafe void Store(uint* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_storeu_epi64 (__m512i * mem_addr, __m512i a) - /// VMOVDQU64 m512 {k1}{z}, zmm1 + /// void _mm512_storeu_epi64 (__m512i * mem_addr, __m512i a) + /// VMOVDQU64 m512 {k1}{z}, zmm1 /// public static unsafe void Store(long* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_storeu_epi64 (__m512i * mem_addr, __m512i a) - /// VMOVDQU64 m512 {k1}{z}, zmm1 + /// void _mm512_storeu_epi64 (__m512i * mem_addr, __m512i a) + /// VMOVDQU64 m512 {k1}{z}, zmm1 /// public static unsafe void Store(ulong* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_storeu_ps (float * mem_addr, __m512 a) - /// VMOVUPS m512 {k1}{z}, zmm1 + /// void _mm512_storeu_ps (float * mem_addr, __m512 a) + /// VMOVUPS m512 {k1}{z}, zmm1 /// public static unsafe void Store(float* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_storeu_pd (double * mem_addr, __m512d a) - /// VMOVUPD m512 {k1}{z}, zmm1 + /// void _mm512_storeu_pd (double * mem_addr, __m512d a) + /// VMOVUPD m512 {k1}{z}, zmm1 /// public static unsafe void Store(double* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a) - /// VMOVDQA32 m512 {k1}{z}, zmm1 + /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a) + /// VMOVDQA32 m512 {k1}{z}, zmm1 /// public static unsafe void StoreAligned(byte* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a) - /// VMOVDQA32 m512 {k1}{z}, zmm1 + /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a) + /// VMOVDQA32 m512 {k1}{z}, zmm1 /// public static unsafe void StoreAligned(sbyte* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a) - /// VMOVDQA32 m512 {k1}{z}, zmm1 + /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a) + /// VMOVDQA32 m512 {k1}{z}, zmm1 /// public static unsafe void StoreAligned(short* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a) - /// VMOVDQA32 m512 {k1}{z}, zmm1 + /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a) + /// VMOVDQA32 m512 {k1}{z}, zmm1 /// public static unsafe void StoreAligned(ushort* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_store_epi32 (__m512i * mem_addr, __m512i a) - /// VMOVDQA32 m512 {k1}{z}, zmm1 + /// void _mm512_store_epi32 (__m512i * mem_addr, __m512i a) + /// VMOVDQA32 m512 {k1}{z}, zmm1 /// public static unsafe void StoreAligned(int* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_store_epi32 (__m512i * mem_addr, __m512i a) - /// VMOVDQA32 m512 {k1}{z}, zmm1 + /// void _mm512_store_epi32 (__m512i * mem_addr, __m512i a) + /// VMOVDQA32 m512 {k1}{z}, zmm1 /// public static unsafe void StoreAligned(uint* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_store_epi64 (__m512i * mem_addr, __m512i a) - /// VMOVDQA32 m512 {k1}{z}, zmm1 + /// void _mm512_store_epi64 (__m512i * mem_addr, __m512i a) + /// VMOVDQA32 m512 {k1}{z}, zmm1 /// public static unsafe void StoreAligned(long* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_store_epi64 (__m512i * mem_addr, __m512i a) - /// VMOVDQA32 m512 {k1}{z}, zmm1 + /// void _mm512_store_epi64 (__m512i * mem_addr, __m512i a) + /// VMOVDQA32 m512 {k1}{z}, zmm1 /// public static unsafe void StoreAligned(ulong* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_store_ps (float * mem_addr, __m512 a) - /// VMOVAPS m512 {k1}{z}, zmm1 + /// void _mm512_store_ps (float * mem_addr, __m512 a) + /// VMOVAPS m512 {k1}{z}, zmm1 /// public static unsafe void StoreAligned(float* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_store_pd (double * mem_addr, __m512d a) - /// VMOVAPD m512 {k1}{z}, zmm1 + /// void _mm512_store_pd (double * mem_addr, __m512d a) + /// VMOVAPD m512 {k1}{z}, zmm1 /// public static unsafe void StoreAligned(double* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) - /// VMOVNTDQ m512, zmm1 + /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) + /// VMOVNTDQ m512, zmm1 /// public static unsafe void StoreAlignedNonTemporal(sbyte* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) - /// VMOVNTDQ m512, zmm1 + /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) + /// VMOVNTDQ m512, zmm1 /// public static unsafe void StoreAlignedNonTemporal(byte* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) - /// VMOVNTDQ m512, zmm1 + /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) + /// VMOVNTDQ m512, zmm1 /// public static unsafe void StoreAlignedNonTemporal(short* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) - /// VMOVNTDQ m512, zmm1 + /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) + /// VMOVNTDQ m512, zmm1 /// public static unsafe void StoreAlignedNonTemporal(ushort* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) - /// VMOVNTDQ m512, zmm1 + /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) + /// VMOVNTDQ m512, zmm1 /// public static unsafe void StoreAlignedNonTemporal(int* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) - /// VMOVNTDQ m512, zmm1 + /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) + /// VMOVNTDQ m512, zmm1 /// public static unsafe void StoreAlignedNonTemporal(uint* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) - /// VMOVNTDQ m512, zmm1 + /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) + /// VMOVNTDQ m512, zmm1 /// public static unsafe void StoreAlignedNonTemporal(long* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) - /// VMOVNTDQ m512, zmm1 + /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) + /// VMOVNTDQ m512, zmm1 /// public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_stream_ps (float * mem_addr, __m512 a) - /// VMOVNTPS m512, zmm1 + /// void _mm512_stream_ps (float * mem_addr, __m512 a) + /// VMOVNTPS m512, zmm1 /// public static unsafe void StoreAlignedNonTemporal(float* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm512_stream_pd (double * mem_addr, __m512d a) - /// VMOVNTPD m512, zmm1 + /// void _mm512_stream_pd (double * mem_addr, __m512d a) + /// VMOVNTPD m512, zmm1 /// public static unsafe void StoreAlignedNonTemporal(double* address, Vector512 source) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_sub_epi32 (__m512i a, __m512i b) - /// VPSUBD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_sub_epi32 (__m512i a, __m512i b) + /// VPSUBD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Subtract(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_sub_epi32 (__m512i a, __m512i b) - /// VPSUBD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_sub_epi32 (__m512i a, __m512i b) + /// VPSUBD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Subtract(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_sub_epi64 (__m512i a, __m512i b) - /// VPSUBQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_sub_epi64 (__m512i a, __m512i b) + /// VPSUBQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Subtract(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_sub_epi64 (__m512i a, __m512i b) - /// VPSUBQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_sub_epi64 (__m512i a, __m512i b) + /// VPSUBQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Subtract(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_sub_ps (__m512 a, __m512 b) - /// VSUBPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er} + /// __m512 _mm512_sub_ps (__m512 a, __m512 b) + /// VSUBPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er} /// public static Vector512 Subtract(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_sub_pd (__m512d a, __m512d b) - /// VSUBPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er} + /// __m512d _mm512_sub_pd (__m512d a, __m512d b) + /// VSUBPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er} /// public static Vector512 Subtract(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_sub_round_ps (__m512 a, __m512 b, int rounding) - /// VSUBPS zmm1, zmm2, zmm3 {er} + /// __m512 _mm512_sub_round_ps (__m512 a, __m512 b, int rounding) + /// VSUBPS zmm1, zmm2, zmm3 {er} /// public static Vector512 Subtract(Vector512 left, Vector512 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_sub_round_pd (__m512d a, __m512d b, int rounding) - /// VSUBPD zmm1, zmm2, zmm3 {er} + /// __m512d _mm512_sub_round_pd (__m512d a, __m512d b, int rounding) + /// VSUBPD zmm1, zmm2, zmm3 {er} /// public static Vector512 Subtract(Vector512 left, Vector512 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_sub_round_ss (__m128 a, __m128 b, int rounding) - /// VSUBSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_sub_round_ss (__m128 a, __m128 b, int rounding) + /// VSUBSS xmm1, xmm2, xmm3 {er} /// public static Vector128 SubtractScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_sub_round_sd (__m128d a, __m128d b, int rounding) - /// VSUBSD xmm1, xmm2, xmm3 {er} + /// __m128d _mm_sub_round_sd (__m128d a, __m128d b, int rounding) + /// VSUBSD xmm1, xmm2, xmm3 {er} /// public static Vector128 SubtractScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_ternarylogic_si512 (__m512i a, __m512i b, __m512i c, int imm) - /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m512i _mm512_ternarylogic_si512 (__m512i a, __m512i b, __m512i c, int imm) + /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector512 TernaryLogic(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_ternarylogic_si512 (__m512i a, __m512i b, __m512i c, byte imm) - /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m512i _mm512_ternarylogic_si512 (__m512i a, __m512i b, __m512i c, byte imm) + /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector512 TernaryLogic(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_ternarylogic_si512 (__m512i a, __m512i b, __m512i c, short imm) - /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m512i _mm512_ternarylogic_si512 (__m512i a, __m512i b, __m512i c, short imm) + /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector512 TernaryLogic(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_ternarylogic_si512 (__m512i a, __m512i b, __m512i c, short imm) - /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m512i _mm512_ternarylogic_si512 (__m512i a, __m512i b, __m512i c, short imm) + /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector512 TernaryLogic(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_ternarylogic_epi32 (__m512i a, __m512i b, __m512i c, int imm) - /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 + /// __m512i _mm512_ternarylogic_epi32 (__m512i a, __m512i b, __m512i c, int imm) + /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 /// public static Vector512 TernaryLogic(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_ternarylogic_epi32 (__m512i a, __m512i b, __m512i c, int imm) - /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 + /// __m512i _mm512_ternarylogic_epi32 (__m512i a, __m512i b, __m512i c, int imm) + /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 /// public static Vector512 TernaryLogic(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_ternarylogic_epi64 (__m512i a, __m512i b, __m512i c, int imm) - /// VPTERNLOGQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 + /// __m512i _mm512_ternarylogic_epi64 (__m512i a, __m512i b, __m512i c, int imm) + /// VPTERNLOGQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 /// public static Vector512 TernaryLogic(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_ternarylogic_epi64 (__m512i a, __m512i b, __m512i c, int imm) - /// VPTERNLOGQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 + /// __m512i _mm512_ternarylogic_epi64 (__m512i a, __m512i b, __m512i c, int imm) + /// VPTERNLOGQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 /// public static Vector512 TernaryLogic(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_ternarylogic_ps (__m512 a, __m512 b, __m512 c, int imm) - /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m512 _mm512_ternarylogic_ps (__m512 a, __m512 b, __m512 c, int imm) + /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector512 TernaryLogic(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_ternarylogic_pd (__m512d a, __m512d b, __m512d c, int imm) - /// VPTERNLOGQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m512d _mm512_ternarylogic_pd (__m512d a, __m512d b, __m512d c, int imm) + /// VPTERNLOGQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector512 TernaryLogic(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_unpackhi_epi32 (__m512i a, __m512i b) - /// VPUNPCKHDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_unpackhi_epi32 (__m512i a, __m512i b) + /// VPUNPCKHDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 UnpackHigh(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_unpackhi_epi32 (__m512i a, __m512i b) - /// VPUNPCKHDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_unpackhi_epi32 (__m512i a, __m512i b) + /// VPUNPCKHDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 UnpackHigh(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_unpackhi_epi64 (__m512i a, __m512i b) - /// VPUNPCKHQDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_unpackhi_epi64 (__m512i a, __m512i b) + /// VPUNPCKHQDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 UnpackHigh(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_unpackhi_epi64 (__m512i a, __m512i b) - /// VPUNPCKHQDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_unpackhi_epi64 (__m512i a, __m512i b) + /// VPUNPCKHQDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 UnpackHigh(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_unpackhi_ps (__m512 a, __m512 b) - /// VUNPCKHPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_unpackhi_ps (__m512 a, __m512 b) + /// VUNPCKHPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 UnpackHigh(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_unpackhi_pd (__m512d a, __m512d b) - /// VUNPCKHPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_unpackhi_pd (__m512d a, __m512d b) + /// VUNPCKHPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 UnpackHigh(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_unpacklo_epi32 (__m512i a, __m512i b) - /// VPUNPCKLDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_unpacklo_epi32 (__m512i a, __m512i b) + /// VPUNPCKLDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 UnpackLow(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_unpacklo_epi32 (__m512i a, __m512i b) - /// VPUNPCKLDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_unpacklo_epi32 (__m512i a, __m512i b) + /// VPUNPCKLDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 UnpackLow(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_unpacklo_epi64 (__m512i a, __m512i b) - /// VPUNPCKLQDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_unpacklo_epi64 (__m512i a, __m512i b) + /// VPUNPCKLQDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 UnpackLow(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_unpacklo_epi64 (__m512i a, __m512i b) - /// VPUNPCKLQDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_unpacklo_epi64 (__m512i a, __m512i b) + /// VPUNPCKLQDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 UnpackLow(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512 _mm512_unpacklo_ps (__m512 a, __m512 b) - /// VUNPCKLPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_unpacklo_ps (__m512 a, __m512 b) + /// VUNPCKLPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 UnpackLow(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512d _mm512_unpacklo_pd (__m512d a, __m512d b) - /// VUNPCKLPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_unpacklo_pd (__m512d a, __m512d b) + /// VUNPCKLPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 UnpackLow(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_xor_si512 (__m512i a, __m512i b) - /// VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_xor_si512 (__m512i a, __m512i b) + /// VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Xor(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_xor_si512 (__m512i a, __m512i b) - /// VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_xor_si512 (__m512i a, __m512i b) + /// VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Xor(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_xor_si512 (__m512i a, __m512i b) - /// VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_xor_si512 (__m512i a, __m512i b) + /// VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Xor(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_xor_si512 (__m512i a, __m512i b) - /// VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_xor_si512 (__m512i a, __m512i b) + /// VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Xor(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_xor_epi32 (__m512i a, __m512i b) - /// VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_xor_epi32 (__m512i a, __m512i b) + /// VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Xor(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_xor_epi32 (__m512i a, __m512i b) - /// VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_xor_epi32 (__m512i a, __m512i b) + /// VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Xor(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_xor_epi64 (__m512i a, __m512i b) - /// VPXORQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_xor_epi64 (__m512i a, __m512i b) + /// VPXORQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Xor(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_xor_epi64 (__m512i a, __m512i b) - /// VPXORQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_xor_epi64 (__m512i a, __m512i b) + /// VPXORQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Xor(Vector512 left, Vector512 right) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512F.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512F.cs index 3227da13b99..17074e9f7aa 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512F.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512F.cs @@ -6,4066 +6,4077 @@ namespace System.Runtime.Intrinsics.X86 { - /// This class provides access to X86 AVX512F hardware instructions via intrinsics + /// Provides access to X86 AVX512F hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Avx512F : Avx2 { internal Avx512F() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the x86 AVX512F+VL hardware instructions via intrinsics. [Intrinsic] public abstract class VL { internal VL() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static bool IsSupported { get => IsSupported; } /// - /// __m128i _mm_abs_epi64 (__m128i a) - /// VPABSQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_abs_epi64 (__m128i a) + /// VPABSQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 Abs(Vector128 value) => Abs(value); /// - /// __m256i _mm256_abs_epi64 (__m128i a) - /// VPABSQ ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256i _mm256_abs_epi64 (__m128i a) + /// VPABSQ ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 Abs(Vector256 value) => Abs(value); /// - /// __m128i _mm_alignr_epi32 (__m128i a, __m128i b, const int count) - /// VALIGND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128i _mm_alignr_epi32 (__m128i a, __m128i b, const int count) + /// VALIGND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 AlignRight32(Vector128 left, Vector128 right, [ConstantExpected] byte mask) => AlignRight32(left, right, mask); /// - /// __m128i _mm_alignr_epi32 (__m128i a, __m128i b, const int count) - /// VALIGND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128i _mm_alignr_epi32 (__m128i a, __m128i b, const int count) + /// VALIGND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 AlignRight32(Vector128 left, Vector128 right, [ConstantExpected] byte mask) => AlignRight32(left, right, mask); /// - /// __m256i _mm256_alignr_epi32 (__m256i a, __m256i b, const int count) - /// VALIGND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256i _mm256_alignr_epi32 (__m256i a, __m256i b, const int count) + /// VALIGND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 AlignRight32(Vector256 left, Vector256 right, [ConstantExpected] byte mask) => AlignRight32(left, right, mask); /// - /// __m256i _mm256_alignr_epi32 (__m256i a, __m256i b, const int count) - /// VALIGND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256i _mm256_alignr_epi32 (__m256i a, __m256i b, const int count) + /// VALIGND ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 AlignRight32(Vector256 left, Vector256 right, [ConstantExpected] byte mask) => AlignRight32(left, right, mask); /// - /// __m128i _mm_alignr_epi64 (__m128i a, __m128i b, const int count) - /// VALIGNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128i _mm_alignr_epi64 (__m128i a, __m128i b, const int count) + /// VALIGNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 AlignRight64(Vector128 left, Vector128 right, [ConstantExpected] byte mask) => AlignRight64(left, right, mask); /// - /// __m128i _mm_alignr_epi64 (__m128i a, __m128i b, const int count) - /// VALIGNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128i _mm_alignr_epi64 (__m128i a, __m128i b, const int count) + /// VALIGNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 AlignRight64(Vector128 left, Vector128 right, [ConstantExpected] byte mask) => AlignRight64(left, right, mask); /// - /// __m256i _mm256_alignr_epi64 (__m256i a, __m256i b, const int count) - /// VALIGNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256i _mm256_alignr_epi64 (__m256i a, __m256i b, const int count) + /// VALIGNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 AlignRight64(Vector256 left, Vector256 right, [ConstantExpected] byte mask) => AlignRight64(left, right, mask); /// - /// __m256i _mm256_alignr_epi64 (__m256i a, __m256i b, const int count) - /// VALIGNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256i _mm256_alignr_epi64 (__m256i a, __m256i b, const int count) + /// VALIGNQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 AlignRight64(Vector256 left, Vector256 right, [ConstantExpected] byte mask) => AlignRight64(left, right, mask); /// - /// __m128i _mm_cmpge_epi32 (__m128i a, __m128i b) - /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(5) + /// __m128i _mm_cmpge_epi32 (__m128i a, __m128i b) + /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m128i _mm_cmplt_epi32 (__m128i a, __m128i b) - /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(1) + /// __m128i _mm_cmplt_epi32 (__m128i a, __m128i b) + /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// __m128i _mm_cmple_epi32 (__m128i a, __m128i b) - /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(2) + /// __m128i _mm_cmple_epi32 (__m128i a, __m128i b) + /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// __m128i _mm_cmpne_epi32 (__m128i a, __m128i b) - /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(4) + /// __m128i _mm_cmpne_epi32 (__m128i a, __m128i b) + /// VPCMPD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); /// - /// __m256i _mm256_cmpge_epi32 (__m256i a, __m256i b) - /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(5) + /// __m256i _mm256_cmpge_epi32 (__m256i a, __m256i b) + /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m256i _mm256_cmplt_epi32 (__m256i a, __m256i b) - /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(1) + /// __m256i _mm256_cmplt_epi32 (__m256i a, __m256i b) + /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) => CompareLessThan(left, right); /// - /// __m256i _mm256_cmple_epi32 (__m256i a, __m256i b) - /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(2) + /// __m256i _mm256_cmple_epi32 (__m256i a, __m256i b) + /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) => CompareLessThanOrEqual(left, right); /// - /// __m256i _mm256_cmpne_epi32 (__m256i a, __m256i b) - /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(4) + /// __m256i _mm256_cmpne_epi32 (__m256i a, __m256i b) + /// VPCMPD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) => CompareNotEqual(left, right); /// - /// __m128i _mm_cmpge_epi64 (__m128i a, __m128i b) - /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(5) + /// __m128i _mm_cmpge_epi64 (__m128i a, __m128i b) + /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m128i _mm_cmplt_epi64 (__m128i a, __m128i b) - /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(1) + /// __m128i _mm_cmplt_epi64 (__m128i a, __m128i b) + /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// __m128i _mm_cmple_epi64 (__m128i a, __m128i b) - /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(2) + /// __m128i _mm_cmple_epi64 (__m128i a, __m128i b) + /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// __m128i _mm_cmpne_epi64 (__m128i a, __m128i b) - /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(4) + /// __m128i _mm_cmpne_epi64 (__m128i a, __m128i b) + /// VPCMPQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); /// - /// __m256i _mm256_cmpge_epi64 (__m256i a, __m256i b) - /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(5) + /// __m256i _mm256_cmpge_epi64 (__m256i a, __m256i b) + /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m256i _mm256_cmplt_epi64 (__m256i a, __m256i b) - /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(1) + /// __m256i _mm256_cmplt_epi64 (__m256i a, __m256i b) + /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) => CompareLessThan(left, right); /// - /// __m256i _mm256_cmple_epi64 (__m256i a, __m256i b) - /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(2) + /// __m256i _mm256_cmple_epi64 (__m256i a, __m256i b) + /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) => CompareLessThanOrEqual(left, right); /// - /// __m256i _mm256_cmpne_epi64 (__m256i a, __m256i b) - /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(4) + /// __m256i _mm256_cmpne_epi64 (__m256i a, __m256i b) + /// VPCMPQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) => CompareNotEqual(left, right); /// - /// __m128i _mm_cmpgt_epu32 (__m128i a, __m128i b) - /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(6) + /// __m128i _mm_cmpgt_epu32 (__m128i a, __m128i b) + /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(6) /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// - /// __m128i _mm_cmpge_epu32 (__m128i a, __m128i b) - /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(5) + /// __m128i _mm_cmpge_epu32 (__m128i a, __m128i b) + /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m128i _mm_cmplt_epu32 (__m128i a, __m128i b) - /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(1) + /// __m128i _mm_cmplt_epu32 (__m128i a, __m128i b) + /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// __m128i _mm_cmple_epu32 (__m128i a, __m128i b) - /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(2) + /// __m128i _mm_cmple_epu32 (__m128i a, __m128i b) + /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// __m128i _mm_cmpne_epu32 (__m128i a, __m128i b) - /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(4) + /// __m128i _mm_cmpne_epu32 (__m128i a, __m128i b) + /// VPCMPUD k1 {k2}, xmm2, xmm3/m128/m32bcst, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); /// - /// __m256i _mm256_cmpgt_epu32 (__m256i a, __m256i b) - /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(6) + /// __m256i _mm256_cmpgt_epu32 (__m256i a, __m256i b) + /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(6) /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) => CompareGreaterThan(left, right); /// - /// __m256i _mm256_cmpge_epu32 (__m256i a, __m256i b) - /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(5) + /// __m256i _mm256_cmpge_epu32 (__m256i a, __m256i b) + /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m256i _mm256_cmplt_epu32 (__m256i a, __m256i b) - /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(1) + /// __m256i _mm256_cmplt_epu32 (__m256i a, __m256i b) + /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) => CompareLessThan(left, right); /// - /// __m256i _mm256_cmple_epu32 (__m256i a, __m256i b) - /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(2) + /// __m256i _mm256_cmple_epu32 (__m256i a, __m256i b) + /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) => CompareLessThanOrEqual(left, right); /// - /// __m256i _mm256_cmpne_epu32 (__m256i a, __m256i b) - /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(4) + /// __m256i _mm256_cmpne_epu32 (__m256i a, __m256i b) + /// VPCMPUD k1 {k2}, ymm2, ymm3/m256/m32bcst, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) => CompareNotEqual(left, right); /// - /// __m128i _mm_cmpgt_epu64 (__m128i a, __m128i b) - /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(6) + /// __m128i _mm_cmpgt_epu64 (__m128i a, __m128i b) + /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(6) /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// - /// __m128i _mm_cmpge_epu64 (__m128i a, __m128i b) - /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(5) + /// __m128i _mm_cmpge_epu64 (__m128i a, __m128i b) + /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(5) /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m128i _mm_cmplt_epu64 (__m128i a, __m128i b) - /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(1) + /// __m128i _mm_cmplt_epu64 (__m128i a, __m128i b) + /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// __m128i _mm_cmple_epu64 (__m128i a, __m128i b) - /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(2) + /// __m128i _mm_cmple_epu64 (__m128i a, __m128i b) + /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// __m128i _mm_cmpne_epu64 (__m128i a, __m128i b) - /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(4) + /// __m128i _mm_cmpne_epu64 (__m128i a, __m128i b) + /// VPCMPUQ k1 {k2}, xmm2, xmm3/m128/m64bcst, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); /// - /// __m256i _mm256_cmpgt_epu64 (__m256i a, __m256i b) - /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(6) + /// __m256i _mm256_cmpgt_epu64 (__m256i a, __m256i b) + /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(6) /// public static Vector256 CompareGreaterThan(Vector256 left, Vector256 right) => CompareGreaterThan(left, right); /// - /// __m256i _mm256_cmpge_epu64 (__m256i a, __m256i b) - /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(5) + /// __m256i _mm256_cmpge_epu64 (__m256i a, __m256i b) + /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(5) /// public static Vector256 CompareGreaterThanOrEqual(Vector256 left, Vector256 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m256i _mm256_cmplt_epu64 (__m256i a, __m256i b) - /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(1) + /// __m256i _mm256_cmplt_epu64 (__m256i a, __m256i b) + /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(1) /// public static Vector256 CompareLessThan(Vector256 left, Vector256 right) => CompareLessThan(left, right); /// - /// __m256i _mm256_cmple_epu64 (__m256i a, __m256i b) - /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(2) + /// __m256i _mm256_cmple_epu64 (__m256i a, __m256i b) + /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(2) /// public static Vector256 CompareLessThanOrEqual(Vector256 left, Vector256 right) => CompareLessThanOrEqual(left, right); /// - /// __m256i _mm256_cmpne_epu64 (__m256i a, __m256i b) - /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(4) + /// __m256i _mm256_cmpne_epu64 (__m256i a, __m256i b) + /// VPCMPUQ k1 {k2}, ymm2, ymm3/m256/m64bcst, imm8(4) /// public static Vector256 CompareNotEqual(Vector256 left, Vector256 right) => CompareNotEqual(left, right); /// - /// __m128i _mm_cvtepi32_epi8 (__m128i a) - /// VPMOVDB xmm1/m32 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi32_epi8 (__m128i a) + /// VPMOVDB xmm1/m32 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Byte(Vector128 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm_cvtepi64_epi8 (__m128i a) - /// VPMOVQB xmm1/m16 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi8 (__m128i a) + /// VPMOVQB xmm1/m16 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Byte(Vector128 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm_cvtepi32_epi8 (__m128i a) - /// VPMOVDB xmm1/m32 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi32_epi8 (__m128i a) + /// VPMOVDB xmm1/m32 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Byte(Vector128 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm_cvtepi64_epi8 (__m128i a) - /// VPMOVQB xmm1/m16 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi8 (__m128i a) + /// VPMOVQB xmm1/m16 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Byte(Vector128 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm256_cvtepi32_epi8 (__m256i a) - /// VPMOVDB xmm1/m64 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi32_epi8 (__m256i a) + /// VPMOVDB xmm1/m64 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Byte(Vector256 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm256_cvtepi64_epi8 (__m256i a) - /// VPMOVQB xmm1/m32 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi8 (__m256i a) + /// VPMOVQB xmm1/m32 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Byte(Vector256 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm256_cvtepi32_epi8 (__m256i a) - /// VPMOVDB xmm1/m64 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi32_epi8 (__m256i a) + /// VPMOVDB xmm1/m64 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Byte(Vector256 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm256_cvtepi64_epi8 (__m256i a) - /// VPMOVQB xmm1/m32 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi8 (__m256i a) + /// VPMOVQB xmm1/m32 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Byte(Vector256 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm_cvtusepi32_epi8 (__m128i a) - /// VPMOVUSDB xmm1/m32 {k1}{z}, xmm2 + /// __m128i _mm_cvtusepi32_epi8 (__m128i a) + /// VPMOVUSDB xmm1/m32 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector128 value) => ConvertToVector128ByteWithSaturation(value); /// - /// __m128i _mm_cvtusepi64_epi8 (__m128i a) - /// VPMOVUSQB xmm1/m16 {k1}{z}, xmm2 + /// __m128i _mm_cvtusepi64_epi8 (__m128i a) + /// VPMOVUSQB xmm1/m16 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector128 value) => ConvertToVector128ByteWithSaturation(value); /// - /// __m128i _mm256_cvtusepi32_epi8 (__m256i a) - /// VPMOVUSDB xmm1/m64 {k1}{z}, ymm2 + /// __m128i _mm256_cvtusepi32_epi8 (__m256i a) + /// VPMOVUSDB xmm1/m64 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector256 value) => ConvertToVector128ByteWithSaturation(value); /// - /// __m128i _mm256_cvtusepi64_epi8 (__m256i a) - /// VPMOVUSQB xmm1/m32 {k1}{z}, ymm2 + /// __m128i _mm256_cvtusepi64_epi8 (__m256i a) + /// VPMOVUSQB xmm1/m32 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector256 value) => ConvertToVector128ByteWithSaturation(value); /// - /// __m128d _mm_cvtepu32_pd (__m128i a) - /// VCVTUDQ2PD xmm1 {k1}{z}, xmm2/m64/m32bcst + /// __m128d _mm_cvtepu32_pd (__m128i a) + /// VCVTUDQ2PD xmm1 {k1}{z}, xmm2/m64/m32bcst /// public static Vector128 ConvertToVector128Double(Vector128 value) => ConvertToVector128Double(value); /// - /// __m128i _mm_cvtepi32_epi16 (__m128i a) - /// VPMOVDW xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi32_epi16 (__m128i a) + /// VPMOVDW xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector128 value) => ConvertToVector128Int16(value); /// - /// __m128i _mm_cvtepi64_epi16 (__m128i a) - /// VPMOVQW xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi64_epi16 (__m128i a) + /// VPMOVQW xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector128 value) => ConvertToVector128Int16(value); /// - /// __m128i _mm_cvtepi32_epi16 (__m128i a) - /// VPMOVDW xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi32_epi16 (__m128i a) + /// VPMOVDW xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector128 value) => ConvertToVector128Int16(value); /// - /// __m128i _mm_cvtepi64_epi16 (__m128i a) - /// VPMOVQW xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi64_epi16 (__m128i a) + /// VPMOVQW xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector128 value) => ConvertToVector128Int16(value); /// - /// __m128i _mm256_cvtepi32_epi16 (__m256i a) - /// VPMOVDW xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi32_epi16 (__m256i a) + /// VPMOVDW xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector256 value) => ConvertToVector128Int16(value); /// - /// __m128i _mm256_cvtepi64_epi16 (__m256i a) - /// VPMOVQW xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi64_epi16 (__m256i a) + /// VPMOVQW xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector256 value) => ConvertToVector128Int16(value); /// - /// __m128i _mm256_cvtepi32_epi16 (__m256i a) - /// VPMOVDW xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi32_epi16 (__m256i a) + /// VPMOVDW xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector256 value) => ConvertToVector128Int16(value); /// - /// __m128i _mm256_cvtepi64_epi16 (__m256i a) - /// VPMOVQW xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi64_epi16 (__m256i a) + /// VPMOVQW xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector256 value) => ConvertToVector128Int16(value); /// - /// __m128i _mm_cvtsepi32_epi16 (__m128i a) - /// VPMOVSDW xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm_cvtsepi32_epi16 (__m128i a) + /// VPMOVSDW xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16WithSaturation(Vector128 value) => ConvertToVector128Int16WithSaturation(value); /// - /// __m128i _mm_cvtsepi64_epi16 (__m128i a) - /// VPMOVSQW xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm_cvtsepi64_epi16 (__m128i a) + /// VPMOVSQW xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16WithSaturation(Vector128 value) => ConvertToVector128Int16WithSaturation(value); /// - /// __m128i _mm256_cvtsepi32_epi16 (__m256i a) - /// VPMOVSDW xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm256_cvtsepi32_epi16 (__m256i a) + /// VPMOVSDW xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16WithSaturation(Vector256 value) => ConvertToVector128Int16WithSaturation(value); /// - /// __m128i _mm256_cvtsepi64_epi16 (__m256i a) - /// VPMOVSQW xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm256_cvtsepi64_epi16 (__m256i a) + /// VPMOVSQW xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16WithSaturation(Vector256 value) => ConvertToVector128Int16WithSaturation(value); /// - /// __m128i _mm_cvtepi64_epi32 (__m128i a) - /// VPMOVQD xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi32 (__m128i a) + /// VPMOVQD xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Int32(Vector128 value) => ConvertToVector128Int32(value); /// - /// __m128i _mm_cvtepi64_epi32 (__m128i a) - /// VPMOVQD xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi32 (__m128i a) + /// VPMOVQD xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Int32(Vector128 value) => ConvertToVector128Int32(value); /// - /// __m128i _mm256_cvtepi64_epi32 (__m256i a) - /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi32 (__m256i a) + /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Int32(Vector256 value) => ConvertToVector128Int32(value); /// - /// __m128i _mm256_cvtepi64_epi32 (__m256i a) - /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi32 (__m256i a) + /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Int32(Vector256 value) => ConvertToVector128Int32(value); /// - /// __m128i _mm_cvtsepi64_epi32 (__m128i a) - /// VPMOVSQD xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtsepi64_epi32 (__m128i a) + /// VPMOVSQD xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128Int32WithSaturation(Vector128 value) => ConvertToVector128Int32WithSaturation(value); /// - /// __m128i _mm256_cvtsepi64_epi32 (__m256i a) - /// VPMOVSQD xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtsepi64_epi32 (__m256i a) + /// VPMOVSQD xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128Int32WithSaturation(Vector256 value) => ConvertToVector128Int32WithSaturation(value); /// - /// __m128i _mm_cvtepi32_epi8 (__m128i a) - /// VPMOVDB xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi32_epi8 (__m128i a) + /// VPMOVDB xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector128 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm_cvtepi64_epi8 (__m128i a) - /// VPMOVQB xmm1/m16 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi64_epi8 (__m128i a) + /// VPMOVQB xmm1/m16 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector128 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm_cvtepi32_epi8 (__m128i a) - /// VPMOVDB xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi32_epi8 (__m128i a) + /// VPMOVDB xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector128 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm_cvtepi64_epi8 (__m128i a) - /// VPMOVQB xmm1/m16 {k1}{z}, zmm2 + /// __m128i _mm_cvtepi64_epi8 (__m128i a) + /// VPMOVQB xmm1/m16 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector128 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm256_cvtepi32_epi8 (__m256i a) - /// VPMOVDB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi32_epi8 (__m256i a) + /// VPMOVDB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector256 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm256_cvtepi64_epi8 (__m256i a) - /// VPMOVQB xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi64_epi8 (__m256i a) + /// VPMOVQB xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector256 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm256_cvtepi32_epi8 (__m256i a) - /// VPMOVDB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi32_epi8 (__m256i a) + /// VPMOVDB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector256 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm256_cvtepi64_epi8 (__m256i a) - /// VPMOVQB xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm256_cvtepi64_epi8 (__m256i a) + /// VPMOVQB xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector256 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm_cvtsepi32_epi8 (__m128i a) - /// VPMOVSDB xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm_cvtsepi32_epi8 (__m128i a) + /// VPMOVSDB xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector128 value) => ConvertToVector128SByteWithSaturation(value); /// - /// __m128i _mm_cvtsepi64_epi8 (__m128i a) - /// VPMOVSQB xmm1/m16 {k1}{z}, zmm2 + /// __m128i _mm_cvtsepi64_epi8 (__m128i a) + /// VPMOVSQB xmm1/m16 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector128 value) => ConvertToVector128SByteWithSaturation(value); /// - /// __m128i _mm256_cvtsepi32_epi8 (__m256i a) - /// VPMOVSDB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm256_cvtsepi32_epi8 (__m256i a) + /// VPMOVSDB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector256 value) => ConvertToVector128SByteWithSaturation(value); /// - /// __m128i _mm256_cvtsepi64_epi8 (__m256i a) - /// VPMOVSQB xmm1/m32 {k1}{z}, zmm2 + /// __m128i _mm256_cvtsepi64_epi8 (__m256i a) + /// VPMOVSQB xmm1/m32 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector256 value) => ConvertToVector128SByteWithSaturation(value); /// - /// __m128 _mm_cvtepu32_ps (__m128i a) - /// VCVTUDQ2PS xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128 _mm_cvtepu32_ps (__m128i a) + /// VCVTUDQ2PS xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 ConvertToVector128Single(Vector128 value) => ConvertToVector128Single(value); /// - /// __m128i _mm_cvtepi32_epi16 (__m128i a) - /// VPMOVDW xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi32_epi16 (__m128i a) + /// VPMOVDW xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt16(Vector128 value) => ConvertToVector128UInt16(value); /// - /// __m128i _mm_cvtepi64_epi16 (__m128i a) - /// VPMOVQW xmm1/m32 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi16 (__m128i a) + /// VPMOVQW xmm1/m32 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt16(Vector128 value) => ConvertToVector128UInt16(value); /// - /// __m128i _mm_cvtepi32_epi16 (__m128i a) - /// VPMOVDW xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi32_epi16 (__m128i a) + /// VPMOVDW xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt16(Vector128 value) => ConvertToVector128UInt16(value); /// - /// __m128i _mm_cvtepi64_epi16 (__m128i a) - /// VPMOVQW xmm1/m32 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi16 (__m128i a) + /// VPMOVQW xmm1/m32 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt16(Vector128 value) => ConvertToVector128UInt16(value); /// - /// __m128i _mm256_cvtepi32_epi16 (__m256i a) - /// VPMOVDW xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi32_epi16 (__m256i a) + /// VPMOVDW xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt16(Vector256 value) => ConvertToVector128UInt16(value); /// - /// __m128i _mm256_cvtepi64_epi16 (__m256i a) - /// VPMOVQW xmm1/m64 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi16 (__m256i a) + /// VPMOVQW xmm1/m64 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt16(Vector256 value) => ConvertToVector128UInt16(value); /// - /// __m128i _mm256_cvtepi32_epi16 (__m256i a) - /// VPMOVDW xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi32_epi16 (__m256i a) + /// VPMOVDW xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt16(Vector256 value) => ConvertToVector128UInt16(value); /// - /// __m128i _mm256_cvtepi64_epi16 (__m256i a) - /// VPMOVQW xmm1/m64 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi16 (__m256i a) + /// VPMOVQW xmm1/m64 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt16(Vector256 value) => ConvertToVector128UInt16(value); /// - /// __m128i _mm_cvtusepi32_epi16 (__m128i a) - /// VPMOVUSDW xmm1/m64 {k1}{z}, xmm2 + /// __m128i _mm_cvtusepi32_epi16 (__m128i a) + /// VPMOVUSDW xmm1/m64 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt16WithSaturation(Vector128 value) => ConvertToVector128UInt16WithSaturation(value); /// - /// __m128i _mm_cvtusepi64_epi16 (__m128i a) - /// VPMOVUSQW xmm1/m32 {k1}{z}, xmm2 + /// __m128i _mm_cvtusepi64_epi16 (__m128i a) + /// VPMOVUSQW xmm1/m32 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt16WithSaturation(Vector128 value) => ConvertToVector128UInt16WithSaturation(value); /// - /// __m128i _mm256_cvtusepi32_epi16 (__m256i a) - /// VPMOVUSDW xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtusepi32_epi16 (__m256i a) + /// VPMOVUSDW xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt16WithSaturation(Vector256 value) => ConvertToVector128UInt16WithSaturation(value); /// - /// __m128i _mm256_cvtusepi64_epi16 (__m256i a) - /// VPMOVUSQW xmm1/m64 {k1}{z}, ymm2 + /// __m128i _mm256_cvtusepi64_epi16 (__m256i a) + /// VPMOVUSQW xmm1/m64 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt16WithSaturation(Vector256 value) => ConvertToVector128UInt16WithSaturation(value); /// - /// __m128i _mm_cvtepi64_epi32 (__m128i a) - /// VPMOVQD xmm1/m128 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi32 (__m128i a) + /// VPMOVQD xmm1/m128 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt32(Vector128 value) => ConvertToVector128UInt32(value); /// - /// __m128i _mm_cvtepi64_epi32 (__m128i a) - /// VPMOVQD xmm1/m128 {k1}{z}, xmm2 + /// __m128i _mm_cvtepi64_epi32 (__m128i a) + /// VPMOVQD xmm1/m128 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt32(Vector128 value) => ConvertToVector128UInt32(value); /// - /// __m128i _mm_cvtps_epu32 (__m128 a) - /// VCVTPS2UDQ xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_cvtps_epu32 (__m128 a) + /// VCVTPS2UDQ xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 ConvertToVector128UInt32(Vector128 value) => ConvertToVector128UInt32(value); /// - /// __m128i _mm_cvtpd_epu32 (__m128d a) - /// VCVTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvtpd_epu32 (__m128d a) + /// VCVTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128UInt32(Vector128 value) => ConvertToVector128UInt32(value); /// - /// __m128i _mm256_cvtepi64_epi32 (__m256i a) - /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi32 (__m256i a) + /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt32(Vector256 value) => ConvertToVector128UInt32(value); /// - /// __m128i _mm256_cvtepi64_epi32 (__m256i a) - /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtepi64_epi32 (__m256i a) + /// VPMOVQD xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt32(Vector256 value) => ConvertToVector128UInt32(value); /// - /// __m128i _mm256_cvtpd_epu32 (__m256d a) - /// VCVTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcst + /// __m128i _mm256_cvtpd_epu32 (__m256d a) + /// VCVTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector128 ConvertToVector128UInt32(Vector256 value) => ConvertToVector128UInt32(value); /// - /// __m128i _mm_cvtusepi64_epi32 (__m128i a) - /// VPMOVUSQD xmm1/m128 {k1}{z}, xmm2 + /// __m128i _mm_cvtusepi64_epi32 (__m128i a) + /// VPMOVUSQD xmm1/m128 {k1}{z}, xmm2 /// public static Vector128 ConvertToVector128UInt32WithSaturation(Vector128 value) => ConvertToVector128UInt32WithSaturation(value); /// - /// __m128i _mm256_cvtusepi64_epi32 (__m256i a) - /// VPMOVUSQD xmm1/m128 {k1}{z}, ymm2 + /// __m128i _mm256_cvtusepi64_epi32 (__m256i a) + /// VPMOVUSQD xmm1/m128 {k1}{z}, ymm2 /// public static Vector128 ConvertToVector128UInt32WithSaturation(Vector256 value) => ConvertToVector128UInt32WithSaturation(value); /// - /// __m128i _mm_cvttps_epu32 (__m128 a) - /// VCVTTPS2UDQ xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_cvttps_epu32 (__m128 a) + /// VCVTTPS2UDQ xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 ConvertToVector128UInt32WithTruncation(Vector128 value) => ConvertToVector128UInt32WithTruncation(value); /// - /// __m128i _mm_cvttpd_epu32 (__m128d a) - /// VCVTTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvttpd_epu32 (__m128d a) + /// VCVTTPD2UDQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128UInt32WithTruncation(Vector128 value) => ConvertToVector128UInt32WithTruncation(value); /// - /// __m128i _mm256_cvttpd_epu32 (__m256d a) - /// VCVTTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcst + /// __m128i _mm256_cvttpd_epu32 (__m256d a) + /// VCVTTPD2UDQ xmm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector128 ConvertToVector128UInt32WithTruncation(Vector256 value) => ConvertToVector128UInt32WithTruncation(value); /// - /// __m256d _mm512_cvtepu32_pd (__m128i a) - /// VCVTUDQ2PD ymm1 {k1}{z}, xmm2/m128/m32bcst + /// __m256d _mm512_cvtepu32_pd (__m128i a) + /// VCVTUDQ2PD ymm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector256 ConvertToVector256Double(Vector128 value) => ConvertToVector256Double(value); /// - /// __m256 _mm256_cvtepu32_ps (__m256i a) - /// VCVTUDQ2PS ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256 _mm256_cvtepu32_ps (__m256i a) + /// VCVTUDQ2PS ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 ConvertToVector256Single(Vector256 value) => ConvertToVector256Single(value); /// - /// __m256i _mm256_cvtps_epu32 (__m256 a) - /// VCVTPS2UDQ ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_cvtps_epu32 (__m256 a) + /// VCVTPS2UDQ ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 ConvertToVector256UInt32(Vector256 value) => ConvertToVector256UInt32(value); /// - /// __m256i _mm256_cvttps_epu32 (__m256 a) - /// VCVTTPS2UDQ ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256i _mm256_cvttps_epu32 (__m256 a) + /// VCVTTPS2UDQ ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 ConvertToVector256UInt32WithTruncation(Vector256 value) => ConvertToVector256UInt32WithTruncation(value); /// - /// __m128 _mm_fixupimm_ps(__m128 a, __m128 b, __m128i tbl, int imm); - /// VFIXUPIMMPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128 _mm_fixupimm_ps(__m128 a, __m128 b, __m128i tbl, int imm); + /// VFIXUPIMMPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 Fixup(Vector128 left, Vector128 right, Vector128 table, [ConstantExpected] byte control) => Fixup(left, right, table, control); /// - /// __m128d _mm_fixupimm_pd(__m128d a, __m128d b, __m128i tbl, int imm); - /// VFIXUPIMMPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128d _mm_fixupimm_pd(__m128d a, __m128d b, __m128i tbl, int imm); + /// VFIXUPIMMPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 Fixup(Vector128 left, Vector128 right, Vector128 table, [ConstantExpected] byte control) => Fixup(left, right, table, control); /// - /// __m256 _mm256_fixupimm_ps(__m256 a, __m256 b, __m256i tbl, int imm); - /// VFIXUPIMMPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256 _mm256_fixupimm_ps(__m256 a, __m256 b, __m256i tbl, int imm); + /// VFIXUPIMMPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 Fixup(Vector256 left, Vector256 right, Vector256 table, [ConstantExpected] byte control) => Fixup(left, right, table, control); /// - /// __m256d _mm256_fixupimm_pd(__m256d a, __m256d b, __m256i tbl, int imm); - /// VFIXUPIMMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256d _mm256_fixupimm_pd(__m256d a, __m256d b, __m256i tbl, int imm); + /// VFIXUPIMMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 Fixup(Vector256 left, Vector256 right, Vector256 table, [ConstantExpected] byte control) => Fixup(left, right, table, control); /// - /// __m128 _mm_getexp_ps (__m128 a) - /// VGETEXPPS xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128 _mm_getexp_ps (__m128 a) + /// VGETEXPPS xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 GetExponent(Vector128 value) => GetExponent(value); /// - /// __m128d _mm_getexp_pd (__m128d a) - /// VGETEXPPD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_getexp_pd (__m128d a) + /// VGETEXPPD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 GetExponent(Vector128 value) => GetExponent(value); /// - /// __m256 _mm256_getexp_ps (__m256 a) - /// VGETEXPPS ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256 _mm256_getexp_ps (__m256 a) + /// VGETEXPPS ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 GetExponent(Vector256 value) => GetExponent(value); /// - /// __m256d _mm256_getexp_pd (__m256d a) - /// VGETEXPPD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_getexp_pd (__m256d a) + /// VGETEXPPD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 GetExponent(Vector256 value) => GetExponent(value); /// - /// __m128 _mm_getmant_ps (__m128 a) - /// VGETMANTPS xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128 _mm_getmant_ps (__m128 a) + /// VGETMANTPS xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 GetMantissa(Vector128 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) => GetMantissa(value, control); /// - /// __m128d _mm_getmant_pd (__m128d a) - /// VGETMANTPD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_getmant_pd (__m128d a) + /// VGETMANTPD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 GetMantissa(Vector128 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) => GetMantissa(value, control); /// - /// __m256 _mm256_getmant_ps (__m256 a) - /// VGETMANTPS ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256 _mm256_getmant_ps (__m256 a) + /// VGETMANTPS ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 GetMantissa(Vector256 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) => GetMantissa(value, control); /// - /// __m256d _mm256_getmant_pd (__m256d a) - /// VGETMANTPD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_getmant_pd (__m256d a) + /// VGETMANTPD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 GetMantissa(Vector256 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) => GetMantissa(value, control); /// - /// __m128i _mm_max_epi64 (__m128i a, __m128i b) - /// VPMAXSQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_max_epi64 (__m128i a, __m128i b) + /// VPMAXSQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// - /// __m128i _mm_max_epu64 (__m128i a, __m128i b) - /// VPMAXUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_max_epu64 (__m128i a, __m128i b) + /// VPMAXUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// - /// __m256i _mm256_max_epi64 (__m256i a, __m256i b) - /// VPMAXSQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_max_epi64 (__m256i a, __m256i b) + /// VPMAXSQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Max(Vector256 left, Vector256 right) => Max(left, right); /// - /// __m256i _mm256_max_epu64 (__m256i a, __m256i b) - /// VPMAXUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_max_epu64 (__m256i a, __m256i b) + /// VPMAXUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Max(Vector256 left, Vector256 right) => Max(left, right); /// - /// __m128i _mm_min_epi64 (__m128i a, __m128i b) - /// VPMINSQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_min_epi64 (__m128i a, __m128i b) + /// VPMINSQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// - /// __m128i _mm_min_epu64 (__m128i a, __m128i b) - /// VPMINUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_min_epu64 (__m128i a, __m128i b) + /// VPMINUQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// - /// __m256i _mm256_min_epi64 (__m256i a, __m256i b) - /// VPMINSQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_min_epi64 (__m256i a, __m256i b) + /// VPMINSQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Min(Vector256 left, Vector256 right) => Min(left, right); /// - /// __m256i _mm256_min_epu64 (__m256i a, __m256i b) - /// VPMINUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_min_epu64 (__m256i a, __m256i b) + /// VPMINUQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Min(Vector256 left, Vector256 right) => Min(left, right); /// - /// __m128i _mm_permutex2var_epi64 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst - /// VPERMT2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_permutex2var_epi64 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// VPERMT2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 PermuteVar2x64x2(Vector128 lower, Vector128 indices, Vector128 upper) => PermuteVar2x64x2(lower, indices, upper); /// - /// __m128i _mm_permutex2var_epi64 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst - /// VPERMT2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_permutex2var_epi64 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// VPERMT2Q xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 PermuteVar2x64x2(Vector128 lower, Vector128 indices, Vector128 upper) => PermuteVar2x64x2(lower, indices, upper); /// - /// __m128d _mm_permutex2var_pd (__m128d a, __m128i idx, __m128i b) - /// VPERMI2PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst - /// VPERMT2PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_permutex2var_pd (__m128d a, __m128i idx, __m128i b) + /// VPERMI2PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// VPERMT2PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 PermuteVar2x64x2(Vector128 lower, Vector128 indices, Vector128 upper) => PermuteVar2x64x2(lower, indices, upper); /// - /// __m128i _mm_permutex2var_epi32 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst - /// VPERMT2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_permutex2var_epi32 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// VPERMT2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 PermuteVar4x32x2(Vector128 lower, Vector128 indices, Vector128 upper) => PermuteVar4x32x2(lower, indices, upper); /// - /// __m128i _mm_permutex2var_epi32 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst - /// VPERMT2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_permutex2var_epi32 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// VPERMT2D xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 PermuteVar4x32x2(Vector128 lower, Vector128 indices, Vector128 upper) => PermuteVar4x32x2(lower, indices, upper); /// - /// __m128 _mm_permutex2var_ps (__m128 a, __m128i idx, __m128i b) - /// VPERMI2PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst - /// VPERMT2PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_permutex2var_ps (__m128 a, __m128i idx, __m128i b) + /// VPERMI2PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// VPERMT2PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 PermuteVar4x32x2(Vector128 lower, Vector128 indices, Vector128 upper) => PermuteVar4x32x2(lower, indices, upper); /// - /// __m256i _mm256_permute4x64_epi64 (__m256i a, __m256i b) - /// VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_permute4x64_epi64 (__m256i a, __m256i b) + /// VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar4x64(Vector256 value, Vector256 control) => PermuteVar4x64(value, control); /// - /// __m256i _mm256_permute4x64_pd (__m256d a, __m256i b) - /// VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_permute4x64_pd (__m256d a, __m256i b) + /// VPERMQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar4x64(Vector256 value, Vector256 control) => PermuteVar4x64(value, control); /// - /// __m256d _mm256_permute4x64_pd (__m256d a, __m256i b) - /// VPERMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_permute4x64_pd (__m256d a, __m256i b) + /// VPERMPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar4x64(Vector256 value, Vector256 control) => PermuteVar4x64(value, control); /// - /// __m256i _mm256_permutex2var_epi64 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst - /// VPERMT2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_permutex2var_epi64 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// VPERMT2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar4x64x2(Vector256 lower, Vector256 indices, Vector256 upper) => PermuteVar4x64x2(lower, indices, upper); /// - /// __m256i _mm256_permutex2var_epi64 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst - /// VPERMT2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_permutex2var_epi64 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// VPERMT2Q ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar4x64x2(Vector256 lower, Vector256 indices, Vector256 upper) => PermuteVar4x64x2(lower, indices, upper); /// - /// __m256d _mm256_permutex2var_pd (__m256d a, __m256i idx, __m256i b) - /// VPERMI2PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst - /// VPERMT2PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_permutex2var_pd (__m256d a, __m256i idx, __m256i b) + /// VPERMI2PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// VPERMT2PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 PermuteVar4x64x2(Vector256 lower, Vector256 indices, Vector256 upper) => PermuteVar4x64x2(lower, indices, upper); /// - /// __m256i _mm256_permutex2var_epi32 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst - /// VPERMT2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_permutex2var_epi32 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// VPERMT2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 PermuteVar8x32x2(Vector256 lower, Vector256 indices, Vector256 upper) => PermuteVar8x32x2(lower, indices, upper); /// - /// __m256i _mm256_permutex2var_epi32 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst - /// VPERMT2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_permutex2var_epi32 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// VPERMT2D ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 PermuteVar8x32x2(Vector256 lower, Vector256 indices, Vector256 upper) => PermuteVar8x32x2(lower, indices, upper); /// - /// __m256 _mm256_permutex2var_ps (__m256 a, __m256i idx, __m256i b) - /// VPERMI2PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst - /// VPERMT2PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_permutex2var_ps (__m256 a, __m256i idx, __m256i b) + /// VPERMI2PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// VPERMT2PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 PermuteVar8x32x2(Vector256 lower, Vector256 indices, Vector256 upper) => PermuteVar8x32x2(lower, indices, upper); /// - /// __m128 _mm_rcp14_ps (__m128 a, __m128 b) - /// VRCP14PS xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128 _mm_rcp14_ps (__m128 a, __m128 b) + /// VRCP14PS xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 Reciprocal14(Vector128 value) => Reciprocal14(value); /// - /// __m128d _mm_rcp14_pd (__m128d a, __m128d b) - /// VRCP14PD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_rcp14_pd (__m128d a, __m128d b) + /// VRCP14PD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 Reciprocal14(Vector128 value) => Reciprocal14(value); /// - /// __m256 _mm256_rcp14_ps (__m256 a, __m256 b) - /// VRCP14PS ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256 _mm256_rcp14_ps (__m256 a, __m256 b) + /// VRCP14PS ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 Reciprocal14(Vector256 value) => Reciprocal14(value); /// - /// __m256d _mm256_rcp14_pd (__m256d a, __m256d b) - /// VRCP14PD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_rcp14_pd (__m256d a, __m256d b) + /// VRCP14PD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 Reciprocal14(Vector256 value) => Reciprocal14(value); /// - /// __m128 _mm_rsqrt14_ps (__m128 a, __m128 b) - /// VRSQRT14PS xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128 _mm_rsqrt14_ps (__m128 a, __m128 b) + /// VRSQRT14PS xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 ReciprocalSqrt14(Vector128 value) => ReciprocalSqrt14(value); /// - /// __m128d _mm_rsqrt14_pd (__m128d a, __m128d b) - /// VRSQRT14PD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_rsqrt14_pd (__m128d a, __m128d b) + /// VRSQRT14PD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ReciprocalSqrt14(Vector128 value) => ReciprocalSqrt14(value); /// - /// __m256 _mm256_rsqrt14_ps (__m256 a, __m256 b) - /// VRSQRT14PS ymm1 {k1}{z}, ymm2/m256/m32bcst + /// __m256 _mm256_rsqrt14_ps (__m256 a, __m256 b) + /// VRSQRT14PS ymm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector256 ReciprocalSqrt14(Vector256 value) => ReciprocalSqrt14(value); /// - /// __m256d _mm256_rsqrt14_pd (__m256d a, __m256d b) - /// VRSQRT14PD ymm1 {k1}{z}, ymm2/m256/m64bcst + /// __m256d _mm256_rsqrt14_pd (__m256d a, __m256d b) + /// VRSQRT14PD ymm1 {k1}{z}, ymm2/m256/m64bcst /// public static Vector256 ReciprocalSqrt14(Vector256 value) => ReciprocalSqrt14(value); /// - /// __m128i _mm_rol_epi32 (__m128i a, int imm8) - /// VPROLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128i _mm_rol_epi32 (__m128i a, int imm8) + /// VPROLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 RotateLeft(Vector128 value, [ConstantExpected] byte count) => RotateLeft(value, count); /// - /// __m128i _mm_rol_epi32 (__m128i a, int imm8) - /// VPROLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128i _mm_rol_epi32 (__m128i a, int imm8) + /// VPROLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 RotateLeft(Vector128 value, [ConstantExpected] byte count) => RotateLeft(value, count); /// - /// __m128i _mm_rol_epi64 (__m128i a, int imm8) - /// VPROLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128i _mm_rol_epi64 (__m128i a, int imm8) + /// VPROLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 RotateLeft(Vector128 value, [ConstantExpected] byte count) => RotateLeft(value, count); /// - /// __m128i _mm_rol_epi64 (__m128i a, int imm8) - /// VPROLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128i _mm_rol_epi64 (__m128i a, int imm8) + /// VPROLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 RotateLeft(Vector128 value, [ConstantExpected] byte count) => RotateLeft(value, count); /// - /// __m256i _mm256_rol_epi32 (__m256i a, int imm8) - /// VPROLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256i _mm256_rol_epi32 (__m256i a, int imm8) + /// VPROLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 RotateLeft(Vector256 value, [ConstantExpected] byte count) => RotateLeft(value, count); /// - /// __m256i _mm256_rol_epi32 (__m256i a, int imm8) - /// VPROLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256i _mm256_rol_epi32 (__m256i a, int imm8) + /// VPROLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 RotateLeft(Vector256 value, [ConstantExpected] byte count) => RotateLeft(value, count); /// - /// __m256i _mm256_rol_epi64 (__m256i a, int imm8) - /// VPROLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256i _mm256_rol_epi64 (__m256i a, int imm8) + /// VPROLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 RotateLeft(Vector256 value, [ConstantExpected] byte count) => RotateLeft(value, count); /// - /// __m256i _mm256_rol_epi64 (__m256i a, int imm8) - /// VPROLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256i _mm256_rol_epi64 (__m256i a, int imm8) + /// VPROLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 RotateLeft(Vector256 value, [ConstantExpected] byte count) => RotateLeft(value, count); /// - /// __m128i _mm_rolv_epi32 (__m128i a, __m128i b) - /// VPROLDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_rolv_epi32 (__m128i a, __m128i b) + /// VPROLDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 RotateLeftVariable(Vector128 value, Vector128 count) => RotateLeftVariable(value, count); /// - /// __m128i _mm_rolv_epi32 (__m128i a, __m128i b) - /// VPROLDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_rolv_epi32 (__m128i a, __m128i b) + /// VPROLDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 RotateLeftVariable(Vector128 value, Vector128 count) => RotateLeftVariable(value, count); /// - /// __m128i _mm_rolv_epi64 (__m128i a, __m128i b) - /// VPROLQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_rolv_epi64 (__m128i a, __m128i b) + /// VPROLQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 RotateLeftVariable(Vector128 value, Vector128 count) => RotateLeftVariable(value, count); /// - /// __m128i _mm_rolv_epi64 (__m128i a, __m128i b) - /// VPROLQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_rolv_epi64 (__m128i a, __m128i b) + /// VPROLQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 RotateLeftVariable(Vector128 value, Vector128 count) => RotateLeftVariable(value, count); /// - /// __m256i _mm256_rolv_epi32 (__m256i a, __m256i b) - /// VPROLDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_rolv_epi32 (__m256i a, __m256i b) + /// VPROLDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 RotateLeftVariable(Vector256 value, Vector256 count) => RotateLeftVariable(value, count); /// - /// __m256i _mm256_rolv_epi32 (__m256i a, __m256i b) - /// VPROLDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_rolv_epi32 (__m256i a, __m256i b) + /// VPROLDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 RotateLeftVariable(Vector256 value, Vector256 count) => RotateLeftVariable(value, count); /// - /// __m256i _mm256_rolv_epi64 (__m256i a, __m256i b) - /// VPROLQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_rolv_epi64 (__m256i a, __m256i b) + /// VPROLQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 RotateLeftVariable(Vector256 value, Vector256 count) => RotateLeftVariable(value, count); /// - /// __m256i _mm256_rolv_epi64 (__m256i a, __m256i b) - /// VPROLQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_rolv_epi64 (__m256i a, __m256i b) + /// VPROLQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 RotateLeftVariable(Vector256 value, Vector256 count) => RotateLeftVariable(value, count); /// - /// __m128i _mm_ror_epi32 (__m128i a, int imm8) - /// VPRORD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128i _mm_ror_epi32 (__m128i a, int imm8) + /// VPRORD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 RotateRight(Vector128 value, [ConstantExpected] byte count) => RotateRight(value, count); /// - /// __m128i _mm_ror_epi32 (__m128i a, int imm8) - /// VPRORD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128i _mm_ror_epi32 (__m128i a, int imm8) + /// VPRORD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 RotateRight(Vector128 value, [ConstantExpected] byte count) => RotateRight(value, count); /// - /// __m128i _mm_ror_epi64 (__m128i a, int imm8) - /// VPRORQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128i _mm_ror_epi64 (__m128i a, int imm8) + /// VPRORQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 RotateRight(Vector128 value, [ConstantExpected] byte count) => RotateRight(value, count); /// - /// __m128i _mm_ror_epi64 (__m128i a, int imm8) - /// VPRORQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128i _mm_ror_epi64 (__m128i a, int imm8) + /// VPRORQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 RotateRight(Vector128 value, [ConstantExpected] byte count) => RotateRight(value, count); /// - /// __m256i _mm256_ror_epi32 (__m256i a, int imm8) - /// VPRORD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256i _mm256_ror_epi32 (__m256i a, int imm8) + /// VPRORD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 RotateRight(Vector256 value, [ConstantExpected] byte count) => RotateRight(value, count); /// - /// __m256i _mm256_ror_epi32 (__m256i a, int imm8) - /// VPRORD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256i _mm256_ror_epi32 (__m256i a, int imm8) + /// VPRORD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 RotateRight(Vector256 value, [ConstantExpected] byte count) => RotateRight(value, count); /// - /// __m256i _mm256_ror_epi64 (__m256i a, int imm8) - /// VPRORQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256i _mm256_ror_epi64 (__m256i a, int imm8) + /// VPRORQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 RotateRight(Vector256 value, [ConstantExpected] byte count) => RotateRight(value, count); /// - /// __m256i _mm256_ror_epi64 (__m256i a, int imm8) - /// VPRORQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256i _mm256_ror_epi64 (__m256i a, int imm8) + /// VPRORQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 RotateRight(Vector256 value, [ConstantExpected] byte count) => RotateRight(value, count); /// - /// __m128i _mm_rorv_epi32 (__m128i a, __m128i b) - /// VPRORDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_rorv_epi32 (__m128i a, __m128i b) + /// VPRORDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 RotateRightVariable(Vector128 value, Vector128 count) => RotateRightVariable(value, count); /// - /// __m128i _mm_rorv_epi32 (__m128i a, __m128i b) - /// VPRORDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_rorv_epi32 (__m128i a, __m128i b) + /// VPRORDV xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 RotateRightVariable(Vector128 value, Vector128 count) => RotateRightVariable(value, count); /// - /// __m128i _mm_rorv_epi64 (__m128i a, __m128i b) - /// VPRORQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_rorv_epi64 (__m128i a, __m128i b) + /// VPRORQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 RotateRightVariable(Vector128 value, Vector128 count) => RotateRightVariable(value, count); /// - /// __m128i _mm_rorv_epi64 (__m128i a, __m128i b) - /// VPRORQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_rorv_epi64 (__m128i a, __m128i b) + /// VPRORQV xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 RotateRightVariable(Vector128 value, Vector128 count) => RotateRightVariable(value, count); /// - /// __m256i _mm256_rorv_epi32 (__m256i a, __m256i b) - /// VPRORDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_rorv_epi32 (__m256i a, __m256i b) + /// VPRORDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 RotateRightVariable(Vector256 value, Vector256 count) => RotateRightVariable(value, count); /// - /// __m256i _mm256_rorv_epi32 (__m256i a, __m256i b) - /// VPRORDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256i _mm256_rorv_epi32 (__m256i a, __m256i b) + /// VPRORDV ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 RotateRightVariable(Vector256 value, Vector256 count) => RotateRightVariable(value, count); /// - /// __m256i _mm256_rorv_epi64 (__m256i a, __m256i b) - /// VPRORQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_rorv_epi64 (__m256i a, __m256i b) + /// VPRORQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 RotateRightVariable(Vector256 value, Vector256 count) => RotateRightVariable(value, count); /// - /// __m256i _mm256_rorv_epi64 (__m256i a, __m256i b) - /// VPRORQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_rorv_epi64 (__m256i a, __m256i b) + /// VPRORQV ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 RotateRightVariable(Vector256 value, Vector256 count) => RotateRightVariable(value, count); /// - /// __m128 _mm_roundscale_ps (__m128 a, int imm) - /// VRNDSCALEPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128 _mm_roundscale_ps (__m128 a, int imm) + /// VRNDSCALEPS xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 RoundScale(Vector128 value, [ConstantExpected] byte control) => RoundScale(value, control); /// - /// __m128d _mm_roundscale_pd (__m128d a, int imm) - /// VRNDSCALEPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 + /// __m128d _mm_roundscale_pd (__m128d a, int imm) + /// VRNDSCALEPD xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8 /// public static Vector128 RoundScale(Vector128 value, [ConstantExpected] byte control) => RoundScale(value, control); /// - /// __m256 _mm256_roundscale_ps (__m256 a, int imm) - /// VRNDSCALEPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 + /// __m256 _mm256_roundscale_ps (__m256 a, int imm) + /// VRNDSCALEPS ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8 /// public static Vector256 RoundScale(Vector256 value, [ConstantExpected] byte control) => RoundScale(value, control); /// - /// __m256d _mm256_roundscale_pd (__m256d a, int imm) - /// VRNDSCALEPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 + /// __m256d _mm256_roundscale_pd (__m256d a, int imm) + /// VRNDSCALEPD ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8 /// public static Vector256 RoundScale(Vector256 value, [ConstantExpected] byte control) => RoundScale(value, control); /// - /// __m128 _mm_scalef_ps (__m128 a, int imm) - /// VSCALEFPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_scalef_ps (__m128 a, int imm) + /// VSCALEFPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Scale(Vector128 left, Vector128 right) => Scale(left, right); /// - /// __m128d _mm_scalef_pd (__m128d a, int imm) - /// VSCALEFPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_scalef_pd (__m128d a, int imm) + /// VSCALEFPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Scale(Vector128 left, Vector128 right) => Scale(left, right); /// - /// __m256 _mm256_scalef_ps (__m256 a, int imm) - /// VSCALEFPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_scalef_ps (__m256 a, int imm) + /// VSCALEFPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 Scale(Vector256 left, Vector256 right) => Scale(left, right); /// - /// __m256d _mm256_scalef_pd (__m256d a, int imm) - /// VSCALEFPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_scalef_pd (__m256d a, int imm) + /// VSCALEFPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 Scale(Vector256 left, Vector256 right) => Scale(left, right); /// - /// __m128i _mm_sra_epi64 (__m128i a, __m128i count) - /// VPSRAQ xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sra_epi64 (__m128i a, __m128i count) + /// VPSRAQ xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightArithmetic(Vector128 value, Vector128 count) => ShiftRightArithmetic(value, count); /// - /// __m256i _mm256_sra_epi64 (__m256i a, __m128i count) - /// VPSRAQ ymm1 {k1}{z}, ymm2, xmm3/m128 + /// __m256i _mm256_sra_epi64 (__m256i a, __m128i count) + /// VPSRAQ ymm1 {k1}{z}, ymm2, xmm3/m128 /// public static Vector256 ShiftRightArithmetic(Vector256 value, Vector128 count) => ShiftRightArithmetic(value, count); /// - /// __128i _mm_srai_epi64 (__m128i a, int imm8) - /// VPSRAQ xmm1 {k1}{z}, xmm2, imm8 + /// __128i _mm_srai_epi64 (__m128i a, int imm8) + /// VPSRAQ xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftRightArithmetic(Vector128 value, [ConstantExpected] byte count) => ShiftRightArithmetic(value, count); /// - /// __m256i _mm256_srai_epi64 (__m256i a, int imm8) - /// VPSRAQ ymm1 {k1}{z}, ymm2, imm8 + /// __m256i _mm256_srai_epi64 (__m256i a, int imm8) + /// VPSRAQ ymm1 {k1}{z}, ymm2, imm8 /// public static Vector256 ShiftRightArithmetic(Vector256 value, [ConstantExpected] byte count) => ShiftRightArithmetic(value, count); /// - /// __m128i _mm_srav_epi64 (__m128i a, __m128i count) - /// VPSRAVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_srav_epi64 (__m128i a, __m128i count) + /// VPSRAVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 ShiftRightArithmeticVariable(Vector128 value, Vector128 count) => ShiftRightArithmeticVariable(value, count); /// - /// __m256i _mm256_srav_epi64 (__m256i a, __m256i count) - /// VPSRAVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_srav_epi64 (__m256i a, __m256i count) + /// VPSRAVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 ShiftRightArithmeticVariable(Vector256 value, Vector256 count) => ShiftRightArithmeticVariable(value, count); /// - /// __m256d _mm256_shuffle_f64x2 (__m256d a, __m256d b, const int imm8) - /// VSHUFF64x2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256d _mm256_shuffle_f64x2 (__m256d a, __m256d b, const int imm8) + /// VSHUFF64x2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 Shuffle2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Shuffle2x128(left, right, control); /// - /// __m256i _mm256_shuffle_i32x4 (__m256i a, __m256i b, const int imm8) - /// VSHUFI32x4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256i _mm256_shuffle_i32x4 (__m256i a, __m256i b, const int imm8) + /// VSHUFI32x4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 Shuffle2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Shuffle2x128(left, right, control); /// - /// __m256i _mm256_shuffle_i64x2 (__m256i a, __m256i b, const int imm8) - /// VSHUFI64x2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256i _mm256_shuffle_i64x2 (__m256i a, __m256i b, const int imm8) + /// VSHUFI64x2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 Shuffle2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Shuffle2x128(left, right, control); /// - /// __m256 _mm256_shuffle_f32x4 (__m256 a, __m256 b, const int imm8) - /// VSHUFF32x4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256 _mm256_shuffle_f32x4 (__m256 a, __m256 b, const int imm8) + /// VSHUFF32x4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 Shuffle2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Shuffle2x128(left, right, control); /// - /// __m256i _mm256_shuffle_i32x4 (__m256i a, __m256i b, const int imm8) - /// VSHUFI32x4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256i _mm256_shuffle_i32x4 (__m256i a, __m256i b, const int imm8) + /// VSHUFI32x4 ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 Shuffle2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Shuffle2x128(left, right, control); /// - /// __m256i _mm256_shuffle_i64x2 (__m256i a, __m256i b, const int imm8) - /// VSHUFI64x2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256i _mm256_shuffle_i64x2 (__m256i a, __m256i b, const int imm8) + /// VSHUFI64x2 ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 Shuffle2x128(Vector256 left, Vector256 right, [ConstantExpected] byte control) => Shuffle2x128(left, right, control); /// - /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, byte imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, byte imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, byte imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, byte imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, short imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, short imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, short imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m128i _mm_ternarylogic_si128 (__m128i a, __m128i b, __m128i c, short imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m128i _mm_ternarylogic_epi32 (__m128i a, __m128i b, __m128i c, int imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128i _mm_ternarylogic_epi32 (__m128i a, __m128i b, __m128i c, int imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m128i _mm_ternarylogic_epi32 (__m128i a, __m128i b, __m128i c, int imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128i _mm_ternarylogic_epi32 (__m128i a, __m128i b, __m128i c, int imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m128i _mm_ternarylogic_epi64 (__m128i a, __m128i b, __m128i c, int imm) - /// VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128i _mm_ternarylogic_epi64 (__m128i a, __m128i b, __m128i c, int imm) + /// VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m128i _mm_ternarylogic_epi64 (__m128i a, __m128i b, __m128i c, int imm) - /// VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128i _mm_ternarylogic_epi64 (__m128i a, __m128i b, __m128i c, int imm) + /// VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m128 _mm_ternarylogic_ps (__m128 a, __m128 b, __m128 c, int imm) - /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m128 _mm_ternarylogic_ps (__m128 a, __m128 b, __m128 c, int imm) + /// VPTERNLOGD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m128d _mm_ternarylogic_pd (__m128d a, __m128d b, __m128d c, int imm) - /// VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m128d _mm_ternarylogic_pd (__m128d a, __m128d b, __m128d c, int imm) + /// VPTERNLOGQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector128 TernaryLogic(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, byte imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, byte imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, byte imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, byte imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, short imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, short imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, short imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m256i _mm256_ternarylogic_si256 (__m256i a, __m256i b, __m256i c, short imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m256i _mm256_ternarylogic_epi32 (__m256i a, __m256i b, __m256i c, int imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256i _mm256_ternarylogic_epi32 (__m256i a, __m256i b, __m256i c, int imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m256i _mm256_ternarylogic_epi32 (__m256i a, __m256i b, __m256i c, int imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// __m256i _mm256_ternarylogic_epi32 (__m256i a, __m256i b, __m256i c, int imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m256i _mm256_ternarylogic_epi64 (__m256i a, __m256i b, __m256i c, int imm) - /// VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256i _mm256_ternarylogic_epi64 (__m256i a, __m256i b, __m256i c, int imm) + /// VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m256i _mm256_ternarylogic_epi64 (__m256i a, __m256i b, __m256i c, int imm) - /// VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// __m256i _mm256_ternarylogic_epi64 (__m256i a, __m256i b, __m256i c, int imm) + /// VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m256 _mm256_ternarylogic_ps (__m256 a, __m256 b, __m256 c, int imm) - /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m256 _mm256_ternarylogic_ps (__m256 a, __m256 b, __m256 c, int imm) + /// VPTERNLOGD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m256d _mm256_ternarylogic_pd (__m256d a, __m256d b, __m256d c, int imm) - /// VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m256d _mm256_ternarylogic_pd (__m256d a, __m256d b, __m256d c, int imm) + /// VPTERNLOGQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector256 TernaryLogic(Vector256 a, Vector256 b, Vector256 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); } + /// Provides access to the x86 AVX512F hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : Avx2.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } /// - /// __m128 _mm_cvt_roundi64_ss (__m128 a, __int64 b, int rounding) - /// VCVTSI2SS xmm1, xmm2, r64 {er} - /// This intrinsic is only available on 64-bit processes + /// __m128 _mm_cvt_roundi64_ss (__m128 a, __int64 b, int rounding) + /// VCVTSI2SS xmm1, xmm2, r64 {er} + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, long value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertScalarToVector128Single(upper, value, mode); /// - /// __m128 _mm_cvtsi64_ss (__m128 a, __int64 b) - /// VCVTUSI2SS xmm1, xmm2, r/m64 - /// This intrinsic is only available on 64-bit processes + /// __m128 _mm_cvtsi64_ss (__m128 a, __int64 b) + /// VCVTUSI2SS xmm1, xmm2, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, ulong value) => ConvertScalarToVector128Single(upper, value); /// - /// __m128 _mm_cvt_roundu64_ss (__m128 a, unsigned __int64 b, int rounding) - /// VCVTUSI2SS xmm1, xmm2, r64 {er} - /// This intrinsic is only available on 64-bit processes + /// __m128 _mm_cvt_roundu64_ss (__m128 a, unsigned __int64 b, int rounding) + /// VCVTUSI2SS xmm1, xmm2, r64 {er} + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, ulong value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertScalarToVector128Single(upper, value, mode); /// - /// __m128d _mm_cvt_roundsi64_sd (__m128d a, __int64 b, int rounding) - /// VCVTSI2SD xmm1, xmm2, r64 {er} - /// This intrinsic is only available on 64-bit processes + /// __m128d _mm_cvt_roundsi64_sd (__m128d a, __int64 b, int rounding) + /// VCVTSI2SD xmm1, xmm2, r64 {er} + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Double(Vector128 upper, long value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertScalarToVector128Double(upper, value, mode); /// - /// __m128d _mm_cvtsi64_sd (__m128d a, __int64 b) - /// VCVTUSI2SD xmm1, xmm2, r/m64 - /// This intrinsic is only available on 64-bit processes + /// __m128d _mm_cvtsi64_sd (__m128d a, __int64 b) + /// VCVTUSI2SD xmm1, xmm2, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Double(Vector128 upper, ulong value) => ConvertScalarToVector128Double(upper, value); /// - /// __m128d _mm_cvt_roundu64_sd (__m128d a, unsigned __int64 b, int rounding) - /// VCVTUSI2SD xmm1, xmm2, r64 {er} - /// This intrinsic is only available on 64-bit processes + /// __m128d _mm_cvt_roundu64_sd (__m128d a, unsigned __int64 b, int rounding) + /// VCVTUSI2SD xmm1, xmm2, r64 {er} + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Double(Vector128 upper, ulong value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertScalarToVector128Double(upper, value, mode); /// - /// __int64 _mm_cvt_roundss_i64 (__m128 a, int rounding) - /// VCVTSS2SI r64, xmm1 {er} - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_cvt_roundss_i64 (__m128 a, int rounding) + /// VCVTSS2SI r64, xmm1 {er} + /// This intrinsic is only available on 64-bit processes /// public static long ConvertToInt64(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToInt64(value, mode); /// - /// __int64 _mm_cvt_roundsd_i64 (__m128d a, int rounding) - /// VCVTSD2SI r64, xmm1 {er} - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_cvt_roundsd_i64 (__m128d a, int rounding) + /// VCVTSD2SI r64, xmm1 {er} + /// This intrinsic is only available on 64-bit processes /// public static long ConvertToInt64(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToInt64(value, mode); /// - /// unsigned __int64 _mm_cvtss_u64 (__m128 a) - /// VCVTSS2USI r64, xmm1/m32{er} - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_cvtss_u64 (__m128 a) + /// VCVTSS2USI r64, xmm1/m32{er} + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64(Vector128 value) => ConvertToUInt64(value); /// - /// unsigned __int64 _mm_cvt_roundss_u64 (__m128 a, int rounding) - /// VCVTSS2USI r64, xmm1 {er} - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_cvt_roundss_u64 (__m128 a, int rounding) + /// VCVTSS2USI r64, xmm1 {er} + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToUInt64(value, mode); /// - /// unsigned __int64 _mm_cvtsd_u64 (__m128d a) - /// VCVTSD2USI r64, xmm1/m64{er} - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_cvtsd_u64 (__m128d a) + /// VCVTSD2USI r64, xmm1/m64{er} + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64(Vector128 value) => ConvertToUInt64(value); /// - /// unsigned __int64 _mm_cvt_roundsd_u64 (__m128d a, int rounding) - /// VCVTSD2USI r64, xmm1 {er} - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_cvt_roundsd_u64 (__m128d a, int rounding) + /// VCVTSD2USI r64, xmm1 {er} + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToUInt64(value, mode); /// - /// unsigned __int64 _mm_cvttss_u64 (__m128 a) - /// VCVTTSS2USI r64, xmm1/m32{er} - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_cvttss_u64 (__m128 a) + /// VCVTTSS2USI r64, xmm1/m32{er} + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64WithTruncation(Vector128 value) => ConvertToUInt64WithTruncation(value); /// - /// unsigned __int64 _mm_cvttsd_u64 (__m128d a) - /// VCVTTSD2USI r64, xmm1/m64{er} - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_cvttsd_u64 (__m128d a) + /// VCVTTSD2USI r64, xmm1/m64{er} + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64WithTruncation(Vector128 value) => ConvertToUInt64WithTruncation(value); } /// - /// __m512i _mm512_abs_epi32 (__m512i a) - /// VPABSD zmm1 {k1}{z}, zmm2/m512/m32bcst + /// __m512i _mm512_abs_epi32 (__m512i a) + /// VPABSD zmm1 {k1}{z}, zmm2/m512/m32bcst /// public static Vector512 Abs(Vector512 value) => Abs(value); /// - /// __m512i _mm512_abs_epi64 (__m512i a) - /// VPABSQ zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512i _mm512_abs_epi64 (__m512i a) + /// VPABSQ zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 Abs(Vector512 value) => Abs(value); /// - /// __m512i _mm512_add_epi32 (__m512i a, __m512i b) - /// VPADDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_add_epi32 (__m512i a, __m512i b) + /// VPADDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Add(Vector512 left, Vector512 right) => Add(left, right); /// - /// __m512i _mm512_add_epi32 (__m512i a, __m512i b) - /// VPADDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_add_epi32 (__m512i a, __m512i b) + /// VPADDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Add(Vector512 left, Vector512 right) => Add(left, right); /// - /// __m512i _mm512_add_epi64 (__m512i a, __m512i b) - /// VPADDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_add_epi64 (__m512i a, __m512i b) + /// VPADDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Add(Vector512 left, Vector512 right) => Add(left, right); /// - /// __m512i _mm512_add_epi64 (__m512i a, __m512i b) - /// VPADDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_add_epi64 (__m512i a, __m512i b) + /// VPADDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Add(Vector512 left, Vector512 right) => Add(left, right); /// - /// __m512d _mm512_add_pd (__m512d a, __m512d b) - /// VADDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er} + /// __m512d _mm512_add_pd (__m512d a, __m512d b) + /// VADDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er} /// public static Vector512 Add(Vector512 left, Vector512 right) => Add(left, right); /// - /// __m512d _mm512_add_round_pd (__m512d a, __m512d b, int rounding) - /// VADDPD zmm1, zmm2, zmm3 {er} + /// __m512d _mm512_add_round_pd (__m512d a, __m512d b, int rounding) + /// VADDPD zmm1, zmm2, zmm3 {er} /// public static Vector512 Add(Vector512 left, Vector512 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => Add(left, right, mode); /// - /// __m512 _mm512_add_ps (__m512 a, __m512 b) - /// VADDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er} + /// __m512 _mm512_add_ps (__m512 a, __m512 b) + /// VADDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er} /// public static Vector512 Add(Vector512 left, Vector512 right) => Add(left, right); /// - /// __m512 _mm512_add_round_ps (__m512 a, __m512 b, int rounding) - /// VADDPS zmm1, zmm2, zmm3 {er} + /// __m512 _mm512_add_round_ps (__m512 a, __m512 b, int rounding) + /// VADDPS zmm1, zmm2, zmm3 {er} /// public static Vector512 Add(Vector512 left, Vector512 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => Add(left, right, mode); /// - /// __m128 _mm_add_round_ss (__m128 a, __m128 b, int rounding) - /// VADDSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_add_round_ss (__m128 a, __m128 b, int rounding) + /// VADDSS xmm1, xmm2, xmm3 {er} /// public static Vector128 AddScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => AddScalar(left, right, mode); /// - /// __m128d _mm_add_round_sd (__m128d a, __m128d b, int rounding) - /// VADDSD xmm1, xmm2, xmm3 {er} + /// __m128d _mm_add_round_sd (__m128d a, __m128d b, int rounding) + /// VADDSD xmm1, xmm2, xmm3 {er} /// public static Vector128 AddScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => AddScalar(left, right, mode); /// - /// __m512i _mm512_alignr_epi32 (__m512i a, __m512i b, const int count) - /// VALIGND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 + /// __m512i _mm512_alignr_epi32 (__m512i a, __m512i b, const int count) + /// VALIGND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 /// public static Vector512 AlignRight32(Vector512 left, Vector512 right, [ConstantExpected] byte mask) => AlignRight32(left, right, mask); /// - /// __m512i _mm512_alignr_epi32 (__m512i a, __m512i b, const int count) - /// VALIGND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 + /// __m512i _mm512_alignr_epi32 (__m512i a, __m512i b, const int count) + /// VALIGND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 /// public static Vector512 AlignRight32(Vector512 left, Vector512 right, [ConstantExpected] byte mask) => AlignRight32(left, right, mask); /// - /// __m512i _mm512_alignr_epi64 (__m512i a, __m512i b, const int count) - /// VALIGNQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 + /// __m512i _mm512_alignr_epi64 (__m512i a, __m512i b, const int count) + /// VALIGNQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 /// public static Vector512 AlignRight64(Vector512 left, Vector512 right, [ConstantExpected] byte mask) => AlignRight64(left, right, mask); /// - /// __m512i _mm512_alignr_epi64 (__m512i a, __m512i b, const int count) - /// VALIGNQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 + /// __m512i _mm512_alignr_epi64 (__m512i a, __m512i b, const int count) + /// VALIGNQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 /// public static Vector512 AlignRight64(Vector512 left, Vector512 right, [ConstantExpected] byte mask) => AlignRight64(left, right, mask); /// - /// __m512i _mm512_and_si512 (__m512i a, __m512i b) - /// VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_and_si512 (__m512i a, __m512i b) + /// VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 And(Vector512 left, Vector512 right) => And(left, right); /// - /// __m512i _mm512_and_si512 (__m512i a, __m512i b) - /// VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_and_si512 (__m512i a, __m512i b) + /// VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 And(Vector512 left, Vector512 right) => And(left, right); /// - /// __m512i _mm512_and_si512 (__m512i a, __m512i b) - /// VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_and_si512 (__m512i a, __m512i b) + /// VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 And(Vector512 left, Vector512 right) => And(left, right); /// - /// __m512i _mm512_and_si512 (__m512i a, __m512i b) - /// VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_and_si512 (__m512i a, __m512i b) + /// VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 And(Vector512 left, Vector512 right) => And(left, right); /// - /// __m512i _mm512_and_epi32 (__m512i a, __m512i b) - /// VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_and_epi32 (__m512i a, __m512i b) + /// VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 And(Vector512 left, Vector512 right) => And(left, right); /// - /// __m512i _mm512_and_epi32 (__m512i a, __m512i b) - /// VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_and_epi32 (__m512i a, __m512i b) + /// VPANDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 And(Vector512 left, Vector512 right) => And(left, right); /// - /// __m512i _mm512_and_epi64 (__m512i a, __m512i b) - /// VPANDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_and_epi64 (__m512i a, __m512i b) + /// VPANDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 And(Vector512 left, Vector512 right) => And(left, right); /// - /// __m512i _mm512_and_epi64 (__m512i a, __m512i b) - /// VPANDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_and_epi64 (__m512i a, __m512i b) + /// VPANDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 And(Vector512 left, Vector512 right) => And(left, right); /// - /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b) - /// VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b) + /// VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 AndNot(Vector512 left, Vector512 right) => AndNot(left, right); /// - /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b) - /// VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b) + /// VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 AndNot(Vector512 left, Vector512 right) => AndNot(left, right); /// - /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b) - /// VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b) + /// VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 AndNot(Vector512 left, Vector512 right) => AndNot(left, right); /// - /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b) - /// VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_andnot_si512 (__m512i a, __m512i b) + /// VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 AndNot(Vector512 left, Vector512 right) => AndNot(left, right); /// - /// __m512i _mm512_andnot_epi32 (__m512i a, __m512i b) - /// VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_andnot_epi32 (__m512i a, __m512i b) + /// VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 AndNot(Vector512 left, Vector512 right) => AndNot(left, right); /// - /// __m512i _mm512_andnot_epi32 (__m512i a, __m512i b) - /// VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_andnot_epi32 (__m512i a, __m512i b) + /// VPANDND zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 AndNot(Vector512 left, Vector512 right) => AndNot(left, right); /// - /// __m512i _mm512_andnot_epi64 (__m512i a, __m512i b) - /// VPANDNQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_andnot_epi64 (__m512i a, __m512i b) + /// VPANDNQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 AndNot(Vector512 left, Vector512 right) => AndNot(left, right); /// - /// __m512i _mm512_andnot_epi64 (__m512i a, __m512i b) - /// VPANDNQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_andnot_epi64 (__m512i a, __m512i b) + /// VPANDNQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 AndNot(Vector512 left, Vector512 right) => AndNot(left, right); /// - /// __m512d _mm512_blendv_pd (__m512d a, __m512d b, __m512d mask) - /// VBLENDMPD zmm1 {k1}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_blendv_pd (__m512d a, __m512d b, __m512d mask) + /// VBLENDMPD zmm1 {k1}, zmm2, zmm3/m512/m64bcst /// public static Vector512 BlendVariable(Vector512 left, Vector512 right, Vector512 mask) => BlendVariable(left, right, mask); /// - /// __m512i _mm512_blendv_epi32 (__m512i a, __m512i b, __m512i mask) - /// VPBLENDMD zmm1 {k1}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_blendv_epi32 (__m512i a, __m512i b, __m512i mask) + /// VPBLENDMD zmm1 {k1}, zmm2, zmm3/m512/m32bcst /// public static Vector512 BlendVariable(Vector512 left, Vector512 right, Vector512 mask) => BlendVariable(left, right, mask); /// - /// __m512i _mm512_blendv_epi64 (__m512i a, __m512i b, __m512i mask) - /// VPBLENDMQ zmm1 {k1}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_blendv_epi64 (__m512i a, __m512i b, __m512i mask) + /// VPBLENDMQ zmm1 {k1}, zmm2, zmm3/m512/m64bcst /// public static Vector512 BlendVariable(Vector512 left, Vector512 right, Vector512 mask) => BlendVariable(left, right, mask); /// - /// __m512 _mm512_blendv_ps (__m512 a, __m512 b, __m512 mask) - /// VBLENDMPS zmm1 {k1}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_blendv_ps (__m512 a, __m512 b, __m512 mask) + /// VBLENDMPS zmm1 {k1}, zmm2, zmm3/m512/m32bcst /// public static Vector512 BlendVariable(Vector512 left, Vector512 right, Vector512 mask) => BlendVariable(left, right, mask); /// - /// __m512i _mm512_blendv_epu32 (__m512i a, __m512i b, __m512i mask) - /// VPBLENDMD zmm1 {k1}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_blendv_epu32 (__m512i a, __m512i b, __m512i mask) + /// VPBLENDMD zmm1 {k1}, zmm2, zmm3/m512/m32bcst /// public static Vector512 BlendVariable(Vector512 left, Vector512 right, Vector512 mask) => BlendVariable(left, right, mask); /// - /// __m512i _mm512_blendv_epu64 (__m512i a, __m512i b, __m512i mask) - /// VPBLENDMQ zmm1 {k1}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_blendv_epu64 (__m512i a, __m512i b, __m512i mask) + /// VPBLENDMQ zmm1 {k1}, zmm2, zmm3/m512/m64bcst /// public static Vector512 BlendVariable(Vector512 left, Vector512 right, Vector512 mask) => BlendVariable(left, right, mask); /// - /// __m512i _mm512_broadcastd_epi32 (__m128i a) - /// VPBROADCASTD zmm1 {k1}{z}, xmm2/m32 + /// __m512i _mm512_broadcastd_epi32 (__m128i a) + /// VPBROADCASTD zmm1 {k1}{z}, xmm2/m32 /// public static Vector512 BroadcastScalarToVector512(Vector128 value) => BroadcastScalarToVector512(value); /// - /// __m512i _mm512_broadcastd_epi32 (__m128i a) - /// VPBROADCASTD zmm1 {k1}{z}, xmm2/m32 + /// __m512i _mm512_broadcastd_epi32 (__m128i a) + /// VPBROADCASTD zmm1 {k1}{z}, xmm2/m32 /// public static Vector512 BroadcastScalarToVector512(Vector128 value) => BroadcastScalarToVector512(value); /// - /// __m512i _mm512_broadcastq_epi64 (__m128i a) - /// VPBROADCASTQ zmm1 {k1}{z}, xmm2/m64 + /// __m512i _mm512_broadcastq_epi64 (__m128i a) + /// VPBROADCASTQ zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 BroadcastScalarToVector512(Vector128 value) => BroadcastScalarToVector512(value); /// - /// __m512i _mm512_broadcastq_epi64 (__m128i a) - /// VPBROADCASTQ zmm1 {k1}{z}, xmm2/m64 + /// __m512i _mm512_broadcastq_epi64 (__m128i a) + /// VPBROADCASTQ zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 BroadcastScalarToVector512(Vector128 value) => BroadcastScalarToVector512(value); /// - /// __m512 _mm512_broadcastss_ps (__m128 a) - /// VBROADCASTSS zmm1 {k1}{z}, xmm2/m32 + /// __m512 _mm512_broadcastss_ps (__m128 a) + /// VBROADCASTSS zmm1 {k1}{z}, xmm2/m32 /// public static Vector512 BroadcastScalarToVector512(Vector128 value) => BroadcastScalarToVector512(value); /// - /// __m512d _mm512_broadcastsd_pd (__m128d a) - /// VBROADCASTSD zmm1 {k1}{z}, xmm2/m64 + /// __m512d _mm512_broadcastsd_pd (__m128d a) + /// VBROADCASTSD zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 BroadcastScalarToVector512(Vector128 value) => BroadcastScalarToVector512(value); /// - /// __m512i _mm512_broadcast_i32x4 (__m128i const * mem_addr) - /// VBROADCASTI32x4 zmm1 {k1}{z}, m128 + /// __m512i _mm512_broadcast_i32x4 (__m128i const * mem_addr) + /// VBROADCASTI32x4 zmm1 {k1}{z}, m128 /// public static unsafe Vector512 BroadcastVector128ToVector512(int* address) => BroadcastVector128ToVector512(address); /// - /// __m512i _mm512_broadcast_i32x4 (__m128i const * mem_addr) - /// VBROADCASTI32x4 zmm1 {k1}{z}, m128 + /// __m512i _mm512_broadcast_i32x4 (__m128i const * mem_addr) + /// VBROADCASTI32x4 zmm1 {k1}{z}, m128 /// public static unsafe Vector512 BroadcastVector128ToVector512(uint* address) => BroadcastVector128ToVector512(address); /// - /// __m512 _mm512_broadcast_f32x4 (__m128 const * mem_addr) - /// VBROADCASTF32x4 zmm1 {k1}{z}, m128 + /// __m512 _mm512_broadcast_f32x4 (__m128 const * mem_addr) + /// VBROADCASTF32x4 zmm1 {k1}{z}, m128 /// public static unsafe Vector512 BroadcastVector128ToVector512(float* address) => BroadcastVector128ToVector512(address); /// - /// __m512i _mm512_broadcast_i64x4 (__m256i const * mem_addr) - /// VBROADCASTI64x4 zmm1 {k1}{z}, m256 + /// __m512i _mm512_broadcast_i64x4 (__m256i const * mem_addr) + /// VBROADCASTI64x4 zmm1 {k1}{z}, m256 /// public static unsafe Vector512 BroadcastVector256ToVector512(long* address) => BroadcastVector256ToVector512(address); /// - /// __m512i _mm512_broadcast_i64x4 (__m256i const * mem_addr) - /// VBROADCASTI64x4 zmm1 {k1}{z}, m256 + /// __m512i _mm512_broadcast_i64x4 (__m256i const * mem_addr) + /// VBROADCASTI64x4 zmm1 {k1}{z}, m256 /// public static unsafe Vector512 BroadcastVector256ToVector512(ulong* address) => BroadcastVector256ToVector512(address); /// - /// __m512d _mm512_broadcast_f64x4 (__m256d const * mem_addr) - /// VBROADCASTF64x4 zmm1 {k1}{z}, m256 + /// __m512d _mm512_broadcast_f64x4 (__m256d const * mem_addr) + /// VBROADCASTF64x4 zmm1 {k1}{z}, m256 /// public static unsafe Vector512 BroadcastVector256ToVector512(double* address) => BroadcastVector256ToVector512(address); /// - /// __m512d _mm512_cmp_pd (__m512d a, __m512d b, const int imm8) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8 + /// __m512d _mm512_cmp_pd (__m512d a, __m512d b, const int imm8) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8 /// public static Vector512 Compare(Vector512 left, Vector512 right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) => Compare(left, right, mode); /// - /// __m512d _mm512_cmpeq_pd (__m512d a, __m512d b) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(0) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512d _mm512_cmpeq_pd (__m512d a, __m512d b) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(0) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareEqual(Vector512 left, Vector512 right) => CompareEqual(left, right); /// - /// __m512d _mm512_cmpgt_pd (__m512d a, __m512d b) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(14) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512d _mm512_cmpgt_pd (__m512d a, __m512d b) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(14) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareGreaterThan(Vector512 left, Vector512 right) => CompareGreaterThan(left, right); /// - /// __m512d _mm512_cmpge_pd (__m512d a, __m512d b) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(13) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512d _mm512_cmpge_pd (__m512d a, __m512d b) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(13) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareGreaterThanOrEqual(Vector512 left, Vector512 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m512d _mm512_cmplt_pd (__m512d a, __m512d b) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(1) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512d _mm512_cmplt_pd (__m512d a, __m512d b) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(1) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareLessThan(Vector512 left, Vector512 right) => CompareLessThan(left, right); /// - /// __m512d _mm512_cmple_pd (__m512d a, __m512d b) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(2) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512d _mm512_cmple_pd (__m512d a, __m512d b) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(2) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareLessThanOrEqual(Vector512 left, Vector512 right) => CompareLessThanOrEqual(left, right); /// - /// __m512d _mm512_cmpneq_pd (__m512d a, __m512d b) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(4) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512d _mm512_cmpneq_pd (__m512d a, __m512d b) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(4) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareNotEqual(Vector512 left, Vector512 right) => CompareNotEqual(left, right); /// - /// __m512d _mm512_cmpngt_pd (__m512d a, __m512d b) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(10) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512d _mm512_cmpngt_pd (__m512d a, __m512d b) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(10) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareNotGreaterThan(Vector512 left, Vector512 right) => CompareNotGreaterThan(left, right); /// - /// __m512d _mm512_cmpnge_pd (__m512d a, __m512d b) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(9) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512d _mm512_cmpnge_pd (__m512d a, __m512d b) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(9) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareNotGreaterThanOrEqual(Vector512 left, Vector512 right) => CompareNotGreaterThanOrEqual(left, right); /// - /// __m512d _mm512_cmpnlt_pd (__m512d a, __m512d b) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(5) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512d _mm512_cmpnlt_pd (__m512d a, __m512d b) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(5) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareNotLessThan(Vector512 left, Vector512 right) => CompareNotLessThan(left, right); /// - /// __m512d _mm512_cmpnle_pd (__m512d a, __m512d b) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(6) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512d _mm512_cmpnle_pd (__m512d a, __m512d b) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(6) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareNotLessThanOrEqual(Vector512 left, Vector512 right) => CompareNotLessThanOrEqual(left, right); /// - /// __m512d _mm512_cmpord_pd (__m512d a, __m512d b) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(7) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512d _mm512_cmpord_pd (__m512d a, __m512d b) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(7) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareOrdered(Vector512 left, Vector512 right) => CompareOrdered(left, right); /// - /// __m512d _mm512_cmpunord_pd (__m512d a, __m512d b) - /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(3) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512d _mm512_cmpunord_pd (__m512d a, __m512d b) + /// VCMPPD k1 {k2}, zmm2, zmm3/m512/m64bcst{sae}, imm8(3) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareUnordered(Vector512 left, Vector512 right) => CompareUnordered(left, right); /// - /// __m512 _mm512_cmp_ps (__m512 a, __m512 b, const int imm8) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8 + /// __m512 _mm512_cmp_ps (__m512 a, __m512 b, const int imm8) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8 /// public static Vector512 Compare(Vector512 left, Vector512 right, [ConstantExpected(Max = FloatComparisonMode.UnorderedTrueSignaling)] FloatComparisonMode mode) => Compare(left, right, mode); /// - /// __m512 _mm512_cmpeq_ps (__m512 a, __m512 b) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(0) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512 _mm512_cmpeq_ps (__m512 a, __m512 b) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(0) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareEqual(Vector512 left, Vector512 right) => CompareEqual(left, right); /// - /// __m512 _mm512_cmpgt_ps (__m512 a, __m512 b) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(14) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512 _mm512_cmpgt_ps (__m512 a, __m512 b) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(14) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareGreaterThan(Vector512 left, Vector512 right) => CompareGreaterThan(left, right); /// - /// __m512 _mm512_cmpge_ps (__m512 a, __m512 b) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(13) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512 _mm512_cmpge_ps (__m512 a, __m512 b) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(13) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareGreaterThanOrEqual(Vector512 left, Vector512 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m512 _mm512_cmplt_ps (__m512 a, __m512 b) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(1) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512 _mm512_cmplt_ps (__m512 a, __m512 b) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(1) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareLessThan(Vector512 left, Vector512 right) => CompareLessThan(left, right); /// - /// __m512 _mm512_cmple_ps (__m512 a, __m512 b) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(2) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512 _mm512_cmple_ps (__m512 a, __m512 b) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(2) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareLessThanOrEqual(Vector512 left, Vector512 right) => CompareLessThanOrEqual(left, right); /// - /// __m512 _mm512_cmpneq_ps (__m512 a, __m512 b) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(4) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512 _mm512_cmpneq_ps (__m512 a, __m512 b) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(4) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareNotEqual(Vector512 left, Vector512 right) => CompareNotEqual(left, right); /// - /// __m512 _mm512_cmpngt_ps (__m512 a, __m512 b) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(10) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512 _mm512_cmpngt_ps (__m512 a, __m512 b) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(10) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareNotGreaterThan(Vector512 left, Vector512 right) => CompareNotGreaterThan(left, right); /// - /// __m512 _mm512_cmpnge_ps (__m512 a, __m512 b) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(9) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512 _mm512_cmpnge_ps (__m512 a, __m512 b) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(9) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareNotGreaterThanOrEqual(Vector512 left, Vector512 right) => CompareNotGreaterThanOrEqual(left, right); /// - /// __m512 _mm512_cmpnlt_ps (__m512 a, __m512 b) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(5) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512 _mm512_cmpnlt_ps (__m512 a, __m512 b) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(5) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareNotLessThan(Vector512 left, Vector512 right) => CompareNotLessThan(left, right); /// - /// __m512 _mm512_cmpnle_ps (__m512 a, __m512 b) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(6) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512 _mm512_cmpnle_ps (__m512 a, __m512 b) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(6) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareNotLessThanOrEqual(Vector512 left, Vector512 right) => CompareNotLessThanOrEqual(left, right); /// - /// __m512 _mm512_cmpord_ps (__m512 a, __m512 b) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(7) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512 _mm512_cmpord_ps (__m512 a, __m512 b) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(7) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareOrdered(Vector512 left, Vector512 right) => CompareOrdered(left, right); /// - /// __m512 _mm512_cmpunord_ps (__m512 a, __m512 b) - /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(3) - /// The above native signature does not exist. We provide this additional overload for completeness. + /// __m512 _mm512_cmpunord_ps (__m512 a, __m512 b) + /// VCMPPS k1 {k2}, zmm2, zmm3/m512/m32bcst{sae}, imm8(3) + /// The above native signature does not exist. We provide this additional overload for completeness. /// public static Vector512 CompareUnordered(Vector512 left, Vector512 right) => CompareUnordered(left, right); /// - /// __m512i _mm512_cmpeq_epi32 (__m512i a, __m512i b) - /// VPCMPEQD k1 {k2}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_cmpeq_epi32 (__m512i a, __m512i b) + /// VPCMPEQD k1 {k2}, zmm2, zmm3/m512/m32bcst /// public static Vector512 CompareEqual(Vector512 left, Vector512 right) => CompareEqual(left, right); /// - /// __m512i _mm512_cmpgt_epi32 (__m512i a, __m512i b) - /// VPCMPGTD k1 {k2}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_cmpgt_epi32 (__m512i a, __m512i b) + /// VPCMPGTD k1 {k2}, zmm2, zmm3/m512/m32bcst /// public static Vector512 CompareGreaterThan(Vector512 left, Vector512 right) => CompareGreaterThan(left, right); /// - /// __m512i _mm512_cmpge_epi32 (__m512i a, __m512i b) - /// VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(5) + /// __m512i _mm512_cmpge_epi32 (__m512i a, __m512i b) + /// VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(5) /// public static Vector512 CompareGreaterThanOrEqual(Vector512 left, Vector512 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m512i _mm512_cmplt_epi32 (__m512i a, __m512i b) - /// VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(1) + /// __m512i _mm512_cmplt_epi32 (__m512i a, __m512i b) + /// VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(1) /// public static Vector512 CompareLessThan(Vector512 left, Vector512 right) => CompareLessThan(left, right); /// - /// __m512i _mm512_cmple_epi32 (__m512i a, __m512i b) - /// VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(2) + /// __m512i _mm512_cmple_epi32 (__m512i a, __m512i b) + /// VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(2) /// public static Vector512 CompareLessThanOrEqual(Vector512 left, Vector512 right) => CompareLessThanOrEqual(left, right); /// - /// __m512i _mm512_cmpne_epi32 (__m512i a, __m512i b) - /// VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(4) + /// __m512i _mm512_cmpne_epi32 (__m512i a, __m512i b) + /// VPCMPD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(4) /// public static Vector512 CompareNotEqual(Vector512 left, Vector512 right) => CompareNotEqual(left, right); /// - /// __m512i _mm512_cmpeq_epi64 (__m512i a, __m512i b) - /// VPCMPEQQ k1 {k2}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_cmpeq_epi64 (__m512i a, __m512i b) + /// VPCMPEQQ k1 {k2}, zmm2, zmm3/m512/m64bcst /// public static Vector512 CompareEqual(Vector512 left, Vector512 right) => CompareEqual(left, right); /// - /// __m512i _mm512_cmpgt_epi64 (__m512i a, __m512i b) - /// VPCMPGTQ k1 {k2}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_cmpgt_epi64 (__m512i a, __m512i b) + /// VPCMPGTQ k1 {k2}, zmm2, zmm3/m512/m64bcst /// public static Vector512 CompareGreaterThan(Vector512 left, Vector512 right) => CompareGreaterThan(left, right); /// - /// __m512i _mm512_cmpge_epi64 (__m512i a, __m512i b) - /// VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(5) + /// __m512i _mm512_cmpge_epi64 (__m512i a, __m512i b) + /// VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(5) /// public static Vector512 CompareGreaterThanOrEqual(Vector512 left, Vector512 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m512i _mm512_cmplt_epi64 (__m512i a, __m512i b) - /// VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(1) + /// __m512i _mm512_cmplt_epi64 (__m512i a, __m512i b) + /// VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(1) /// public static Vector512 CompareLessThan(Vector512 left, Vector512 right) => CompareLessThan(left, right); /// - /// __m512i _mm512_cmple_epi64 (__m512i a, __m512i b) - /// VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(2) + /// __m512i _mm512_cmple_epi64 (__m512i a, __m512i b) + /// VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(2) /// public static Vector512 CompareLessThanOrEqual(Vector512 left, Vector512 right) => CompareLessThanOrEqual(left, right); /// - /// __m512i _mm512_cmpne_epi64 (__m512i a, __m512i b) - /// VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(4) + /// __m512i _mm512_cmpne_epi64 (__m512i a, __m512i b) + /// VPCMPQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(4) /// public static Vector512 CompareNotEqual(Vector512 left, Vector512 right) => CompareNotEqual(left, right); /// - /// __m512i _mm512_cmpeq_epu32 (__m512i a, __m512i b) - /// VPCMPEQD k1 {k2}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_cmpeq_epu32 (__m512i a, __m512i b) + /// VPCMPEQD k1 {k2}, zmm2, zmm3/m512/m32bcst /// public static Vector512 CompareEqual(Vector512 left, Vector512 right) => CompareEqual(left, right); /// - /// __m512i _mm512_cmpgt_epu32 (__m512i a, __m512i b) - /// VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(6) + /// __m512i _mm512_cmpgt_epu32 (__m512i a, __m512i b) + /// VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(6) /// public static Vector512 CompareGreaterThan(Vector512 left, Vector512 right) => CompareGreaterThan(left, right); /// - /// __m512i _mm512_cmpge_epu32 (__m512i a, __m512i b) - /// VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(5) + /// __m512i _mm512_cmpge_epu32 (__m512i a, __m512i b) + /// VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(5) /// public static Vector512 CompareGreaterThanOrEqual(Vector512 left, Vector512 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m512i _mm512_cmplt_epu32 (__m512i a, __m512i b) - /// VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(1) + /// __m512i _mm512_cmplt_epu32 (__m512i a, __m512i b) + /// VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(1) /// public static Vector512 CompareLessThan(Vector512 left, Vector512 right) => CompareLessThan(left, right); /// - /// __m512i _mm512_cmple_epu32 (__m512i a, __m512i b) - /// VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(2) + /// __m512i _mm512_cmple_epu32 (__m512i a, __m512i b) + /// VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(2) /// public static Vector512 CompareLessThanOrEqual(Vector512 left, Vector512 right) => CompareLessThanOrEqual(left, right); /// - /// __m512i _mm512_cmpne_epu32 (__m512i a, __m512i b) - /// VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(4) + /// __m512i _mm512_cmpne_epu32 (__m512i a, __m512i b) + /// VPCMPUD k1 {k2}, zmm2, zmm3/m512/m32bcst, imm8(4) /// public static Vector512 CompareNotEqual(Vector512 left, Vector512 right) => CompareNotEqual(left, right); /// - /// __m512i _mm512_cmpeq_epu64 (__m512i a, __m512i b) - /// VPCMPEQQ k1 {k2}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_cmpeq_epu64 (__m512i a, __m512i b) + /// VPCMPEQQ k1 {k2}, zmm2, zmm3/m512/m64bcst /// public static Vector512 CompareEqual(Vector512 left, Vector512 right) => CompareEqual(left, right); /// - /// __m512i _mm512_cmpgt_epu64 (__m512i a, __m512i b) - /// VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(6) + /// __m512i _mm512_cmpgt_epu64 (__m512i a, __m512i b) + /// VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(6) /// public static Vector512 CompareGreaterThan(Vector512 left, Vector512 right) => CompareGreaterThan(left, right); /// - /// __m512i _mm512_cmpge_epu64 (__m512i a, __m512i b) - /// VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(5) + /// __m512i _mm512_cmpge_epu64 (__m512i a, __m512i b) + /// VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(5) /// public static Vector512 CompareGreaterThanOrEqual(Vector512 left, Vector512 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m512i _mm512_cmplt_epu64 (__m512i a, __m512i b) - /// VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(1) + /// __m512i _mm512_cmplt_epu64 (__m512i a, __m512i b) + /// VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(1) /// public static Vector512 CompareLessThan(Vector512 left, Vector512 right) => CompareLessThan(left, right); /// - /// __m512i _mm512_cmple_epu64 (__m512i a, __m512i b) - /// VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(2) + /// __m512i _mm512_cmple_epu64 (__m512i a, __m512i b) + /// VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(2) /// public static Vector512 CompareLessThanOrEqual(Vector512 left, Vector512 right) => CompareLessThanOrEqual(left, right); /// - /// __m512i _mm512_cmpne_epu64 (__m512i a, __m512i b) - /// VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(4) + /// __m512i _mm512_cmpne_epu64 (__m512i a, __m512i b) + /// VPCMPUQ k1 {k2}, zmm2, zmm3/m512/m64bcst, imm8(4) /// public static Vector512 CompareNotEqual(Vector512 left, Vector512 right) => CompareNotEqual(left, right); /// - /// __m128 _mm_cvtsi32_ss (__m128 a, int b) - /// VCVTUSI2SS xmm1, xmm2, r/m32 + /// __m128 _mm_cvtsi32_ss (__m128 a, int b) + /// VCVTUSI2SS xmm1, xmm2, r/m32 /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, uint value) => ConvertScalarToVector128Single(upper, value); /// - /// __m128 _mm_cvt_roundi32_ss (__m128 a, int b, int rounding) - /// VCVTUSI2SS xmm1, xmm2, r32 {er} + /// __m128 _mm_cvt_roundi32_ss (__m128 a, int b, int rounding) + /// VCVTUSI2SS xmm1, xmm2, r32 {er} /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, uint value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertScalarToVector128Single(upper, value, mode); /// - /// __m128 _mm_cvt_roundi32_ss (__m128 a, int b, int rounding) - /// VCVTSI2SS xmm1, xmm2, r32 {er} + /// __m128 _mm_cvt_roundi32_ss (__m128 a, int b, int rounding) + /// VCVTSI2SS xmm1, xmm2, r32 {er} /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, int value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertScalarToVector128Single(upper, value, mode); /// - /// __m128 _mm_cvt_roundsd_ss (__m128 a, __m128d b, int rounding) - /// VCVTSD2SS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_cvt_roundsd_ss (__m128 a, __m128d b, int rounding) + /// VCVTSD2SS xmm1, xmm2, xmm3 {er} /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertScalarToVector128Single(upper, value, mode); /// - /// __m128d _mm_cvtsi32_sd (__m128d a, int b) - /// VCVTUSI2SD xmm1, xmm2, r/m32 + /// __m128d _mm_cvtsi32_sd (__m128d a, int b) + /// VCVTUSI2SD xmm1, xmm2, r/m32 /// public static Vector128 ConvertScalarToVector128Double(Vector128 upper, uint value) => ConvertScalarToVector128Double(upper, value); /// - /// int _mm_cvt_roundss_i32 (__m128 a, int rounding) - /// VCVTSS2SIK r32, xmm1 {er} + /// int _mm_cvt_roundss_i32 (__m128 a, int rounding) + /// VCVTSS2SIK r32, xmm1 {er} /// public static int ConvertToInt32(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToInt32(value, mode); /// - /// int _mm_cvt_roundsd_i32 (__m128d a, int rounding) - /// VCVTSD2SI r32, xmm1 {er} + /// int _mm_cvt_roundsd_i32 (__m128d a, int rounding) + /// VCVTSD2SI r32, xmm1 {er} /// public static int ConvertToInt32(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToInt32(value, mode); /// - /// unsigned int _mm_cvtss_u32 (__m128 a) - /// VCVTSS2USI r32, xmm1/m32{er} + /// unsigned int _mm_cvtss_u32 (__m128 a) + /// VCVTSS2USI r32, xmm1/m32{er} /// public static uint ConvertToUInt32(Vector128 value) => ConvertToUInt32(value); /// - /// unsigned int _mm_cvt_roundss_u32 (__m128 a, int rounding) - /// VCVTSS2USI r32, xmm1 {er} + /// unsigned int _mm_cvt_roundss_u32 (__m128 a, int rounding) + /// VCVTSS2USI r32, xmm1 {er} /// public static uint ConvertToUInt32(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToUInt32(value, mode); /// - /// unsigned int _mm_cvtsd_u32 (__m128d a) - /// VCVTSD2USI r32, xmm1/m64{er} + /// unsigned int _mm_cvtsd_u32 (__m128d a) + /// VCVTSD2USI r32, xmm1/m64{er} /// public static uint ConvertToUInt32(Vector128 value) => ConvertToUInt32(value); /// - /// unsigned int _mm_cvt_roundsd_u32 (__m128d a, int rounding) - /// VCVTSD2USI r32, xmm1 {er} + /// unsigned int _mm_cvt_roundsd_u32 (__m128d a, int rounding) + /// VCVTSD2USI r32, xmm1 {er} /// public static uint ConvertToUInt32(Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToUInt32(value, mode); /// - /// unsigned int _mm_cvttss_u32 (__m128 a) - /// VCVTTSS2USI r32, xmm1/m32{er} + /// unsigned int _mm_cvttss_u32 (__m128 a) + /// VCVTTSS2USI r32, xmm1/m32{er} /// public static uint ConvertToUInt32WithTruncation(Vector128 value) => ConvertToUInt32WithTruncation(value); /// - /// unsigned int _mm_cvttsd_u32 (__m128d a) - /// VCVTTSD2USI r32, xmm1/m64{er} + /// unsigned int _mm_cvttsd_u32 (__m128d a) + /// VCVTTSD2USI r32, xmm1/m64{er} /// public static uint ConvertToUInt32WithTruncation(Vector128 value) => ConvertToUInt32WithTruncation(value); /// - /// __m128i _mm512_cvtepi32_epi8 (__m512i a) - /// VPMOVDB xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm512_cvtepi32_epi8 (__m512i a) + /// VPMOVDB xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Byte(Vector512 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm512_cvtepi64_epi8 (__m512i a) - /// VPMOVQB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm512_cvtepi64_epi8 (__m512i a) + /// VPMOVQB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Byte(Vector512 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm512_cvtepi32_epi8 (__m512i a) - /// VPMOVDB xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm512_cvtepi32_epi8 (__m512i a) + /// VPMOVDB xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Byte(Vector512 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm512_cvtepi64_epi8 (__m512i a) - /// VPMOVQB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm512_cvtepi64_epi8 (__m512i a) + /// VPMOVQB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Byte(Vector512 value) => ConvertToVector128Byte(value); /// - /// __m128i _mm512_cvtusepi32_epi8 (__m512i a) - /// VPMOVUSDB xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm512_cvtusepi32_epi8 (__m512i a) + /// VPMOVUSDB xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector512 value) => ConvertToVector128ByteWithSaturation(value); /// - /// __m128i _mm512_cvtusepi64_epi8 (__m512i a) - /// VPMOVUSQB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm512_cvtusepi64_epi8 (__m512i a) + /// VPMOVUSQB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128ByteWithSaturation(Vector512 value) => ConvertToVector128ByteWithSaturation(value); /// - /// __m128i _mm512_cvtepi64_epi16 (__m512i a) - /// VPMOVQW xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm512_cvtepi64_epi16 (__m512i a) + /// VPMOVQW xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector512 value) => ConvertToVector128Int16(value); /// - /// __m128i _mm512_cvtepi64_epi16 (__m512i a) - /// VPMOVQW xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm512_cvtepi64_epi16 (__m512i a) + /// VPMOVQW xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16(Vector512 value) => ConvertToVector128Int16(value); /// - /// __m128i _mm512_cvtsepi64_epi16 (__m512i a) - /// VPMOVSQW xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm512_cvtsepi64_epi16 (__m512i a) + /// VPMOVSQW xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128Int16WithSaturation(Vector512 value) => ConvertToVector128Int16WithSaturation(value); /// - /// __m128i _mm512_cvtepi32_epi8 (__m512i a) - /// VPMOVDB xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm512_cvtepi32_epi8 (__m512i a) + /// VPMOVDB xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector512 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm512_cvtepi64_epi8 (__m512i a) - /// VPMOVQB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm512_cvtepi64_epi8 (__m512i a) + /// VPMOVQB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector512 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm512_cvtepi32_epi8 (__m512i a) - /// VPMOVDB xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm512_cvtepi32_epi8 (__m512i a) + /// VPMOVDB xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector512 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm512_cvtepi64_epi8 (__m512i a) - /// VPMOVQB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm512_cvtepi64_epi8 (__m512i a) + /// VPMOVQB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByte(Vector512 value) => ConvertToVector128SByte(value); /// - /// __m128i _mm512_cvtsepi32_epi8 (__m512i a) - /// VPMOVSDB xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm512_cvtsepi32_epi8 (__m512i a) + /// VPMOVSDB xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector512 value) => ConvertToVector128SByteWithSaturation(value); /// - /// __m128i _mm512_cvtsepi64_epi8 (__m512i a) - /// VPMOVSQB xmm1/m64 {k1}{z}, zmm2 + /// __m128i _mm512_cvtsepi64_epi8 (__m512i a) + /// VPMOVSQB xmm1/m64 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128SByteWithSaturation(Vector512 value) => ConvertToVector128SByteWithSaturation(value); /// - /// __m128i _mm512_cvtepi64_epi16 (__m512i a) - /// VPMOVQW xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm512_cvtepi64_epi16 (__m512i a) + /// VPMOVQW xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128UInt16(Vector512 value) => ConvertToVector128UInt16(value); /// - /// __m128i _mm512_cvtepi64_epi16 (__m512i a) - /// VPMOVQW xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm512_cvtepi64_epi16 (__m512i a) + /// VPMOVQW xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128UInt16(Vector512 value) => ConvertToVector128UInt16(value); /// - /// __m128i _mm512_cvtusepi64_epi16 (__m512i a) - /// VPMOVUSQW xmm1/m128 {k1}{z}, zmm2 + /// __m128i _mm512_cvtusepi64_epi16 (__m512i a) + /// VPMOVUSQW xmm1/m128 {k1}{z}, zmm2 /// public static Vector128 ConvertToVector128UInt16WithSaturation(Vector512 value) => ConvertToVector128UInt16WithSaturation(value); /// - /// __m256i _mm512_cvtepi32_epi16 (__m512i a) - /// VPMOVDW ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtepi32_epi16 (__m512i a) + /// VPMOVDW ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256Int16(Vector512 value) => ConvertToVector256Int16(value); /// - /// __m256i _mm512_cvtepi32_epi16 (__m512i a) - /// VPMOVDW ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtepi32_epi16 (__m512i a) + /// VPMOVDW ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256Int16(Vector512 value) => ConvertToVector256Int16(value); /// - /// __m256i _mm512_cvtsepi32_epi16 (__m512i a) - /// VPMOVSDW ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtsepi32_epi16 (__m512i a) + /// VPMOVSDW ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256Int16WithSaturation(Vector512 value) => ConvertToVector256Int16WithSaturation(value); /// - /// __m256i _mm512_cvtpd_epi32 (__m512d a) - /// VCVTPD2DQ ymm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m256i _mm512_cvtpd_epi32 (__m512d a) + /// VCVTPD2DQ ymm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector256 ConvertToVector256Int32(Vector512 value) => ConvertToVector256Int32(value); /// - /// __m256i _mm512_cvt_roundpd_epi32 (__m512d a, int rounding) - /// VCVTPD2DQ ymm1, zmm2 {er} + /// __m256i _mm512_cvt_roundpd_epi32 (__m512d a, int rounding) + /// VCVTPD2DQ ymm1, zmm2 {er} /// public static Vector256 ConvertToVector256Int32(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector256Int32(value, mode); /// - /// __m256i _mm512_cvtepi64_epi32 (__m512i a) - /// VPMOVQD ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtepi64_epi32 (__m512i a) + /// VPMOVQD ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256Int32(Vector512 value) => ConvertToVector256Int32(value); /// - /// __m256i _mm512_cvtepi64_epi32 (__m512i a) - /// VPMOVQD ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtepi64_epi32 (__m512i a) + /// VPMOVQD ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256Int32(Vector512 value) => ConvertToVector256Int32(value); /// - /// __m256i _mm512_cvtsepi64_epi32 (__m512i a) - /// VPMOVSQD ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtsepi64_epi32 (__m512i a) + /// VPMOVSQD ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256Int32WithSaturation(Vector512 value) => ConvertToVector256Int32WithSaturation(value); /// - /// __m256i _mm512_cvttpd_epi32 (__m512d a) - /// VCVTTPD2DQ ymm1 {k1}{z}, zmm2/m512/m64bcst{sae} + /// __m256i _mm512_cvttpd_epi32 (__m512d a) + /// VCVTTPD2DQ ymm1 {k1}{z}, zmm2/m512/m64bcst{sae} /// public static Vector256 ConvertToVector256Int32WithTruncation(Vector512 value) => ConvertToVector256Int32WithTruncation(value); /// - /// __m256 _mm512_cvtpd_ps (__m512d a) - /// VCVTPD2PS ymm1, zmm2/m512 - /// VCVTPD2PS ymm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m256 _mm512_cvtpd_ps (__m512d a) + /// VCVTPD2PS ymm1, zmm2/m512 + /// VCVTPD2PS ymm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector256 ConvertToVector256Single(Vector512 value) => ConvertToVector256Single(value); /// - /// __m256 _mm512_cvt_roundpd_ps (__m512d a, int rounding) - /// VCVTPD2PS ymm1, zmm2 {er} + /// __m256 _mm512_cvt_roundpd_ps (__m512d a, int rounding) + /// VCVTPD2PS ymm1, zmm2 {er} /// public static Vector256 ConvertToVector256Single(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector256Single(value, mode); /// - /// __m256i _mm512_cvtepi32_epi16 (__m512i a) - /// VPMOVDW ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtepi32_epi16 (__m512i a) + /// VPMOVDW ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256UInt16(Vector512 value) => ConvertToVector256UInt16(value); /// - /// __m256i _mm512_cvtepi32_epi16 (__m512i a) - /// VPMOVDW ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtepi32_epi16 (__m512i a) + /// VPMOVDW ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256UInt16(Vector512 value) => ConvertToVector256UInt16(value); /// - /// __m256i _mm512_cvtusepi32_epi16 (__m512i a) - /// VPMOVUSDW ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtusepi32_epi16 (__m512i a) + /// VPMOVUSDW ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256UInt16WithSaturation(Vector512 value) => ConvertToVector256UInt16WithSaturation(value); /// - /// __m256i _mm512_cvtpd_epu32 (__m512d a) - /// VCVTPD2UDQ ymm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m256i _mm512_cvtpd_epu32 (__m512d a) + /// VCVTPD2UDQ ymm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector256 ConvertToVector256UInt32(Vector512 value) => ConvertToVector256UInt32(value); /// ///__m256i _mm512_cvt_roundpd_epu32 (__m512d a, int rounding) - /// VCVTPD2UDQ ymm1, zmm2 {er} + /// VCVTPD2UDQ ymm1, zmm2 {er} /// public static Vector256 ConvertToVector256UInt32(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector256UInt32(value, mode); /// - /// __m256i _mm512_cvtepi64_epi32 (__m512i a) - /// VPMOVQD ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtepi64_epi32 (__m512i a) + /// VPMOVQD ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256UInt32(Vector512 value) => ConvertToVector256UInt32(value); /// - /// __m256i _mm512_cvtepi64_epi32 (__m512i a) - /// VPMOVQD ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtepi64_epi32 (__m512i a) + /// VPMOVQD ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256UInt32(Vector512 value) => ConvertToVector256UInt32(value); /// - /// __m256i _mm512_cvtusepi64_epi32 (__m512i a) - /// VPMOVUSQD ymm1/m256 {k1}{z}, zmm2 + /// __m256i _mm512_cvtusepi64_epi32 (__m512i a) + /// VPMOVUSQD ymm1/m256 {k1}{z}, zmm2 /// public static Vector256 ConvertToVector256UInt32WithSaturation(Vector512 value) => ConvertToVector256UInt32WithSaturation(value); /// - /// __m256i _mm512_cvttpd_epu32 (__m512d a) - /// VCVTTPD2UDQ ymm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m256i _mm512_cvttpd_epu32 (__m512d a) + /// VCVTTPD2UDQ ymm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector256 ConvertToVector256UInt32WithTruncation(Vector512 value) => ConvertToVector256UInt32WithTruncation(value); /// - /// __m512d _mm512_cvtepi32_pd (__m256i a) - /// VCVTDQ2PD zmm1 {k1}{z}, ymm2/m256/m32bcst + /// __m512d _mm512_cvtepi32_pd (__m256i a) + /// VCVTDQ2PD zmm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector512 ConvertToVector512Double(Vector256 value) => ConvertToVector512Double(value); /// - /// __m512d _mm512_cvtps_pd (__m256 a) - /// VCVTPS2PD zmm1 {k1}{z}, ymm2/m256/m32bcst{sae} + /// __m512d _mm512_cvtps_pd (__m256 a) + /// VCVTPS2PD zmm1 {k1}{z}, ymm2/m256/m32bcst{sae} /// public static Vector512 ConvertToVector512Double(Vector256 value) => ConvertToVector512Double(value); /// - /// __m512d _mm512_cvtepu32_pd (__m256i a) - /// VCVTUDQ2PD zmm1 {k1}{z}, ymm2/m256/m32bcst + /// __m512d _mm512_cvtepu32_pd (__m256i a) + /// VCVTUDQ2PD zmm1 {k1}{z}, ymm2/m256/m32bcst /// public static Vector512 ConvertToVector512Double(Vector256 value) => ConvertToVector512Double(value); /// - /// __m512i _mm512_cvtepi8_epi32 (__m128i a) - /// VPMOVSXBD zmm1 {k1}{z}, xmm2/m128 + /// __m512i _mm512_cvtepi8_epi32 (__m128i a) + /// VPMOVSXBD zmm1 {k1}{z}, xmm2/m128 /// public static Vector512 ConvertToVector512Int32(Vector128 value) => ConvertToVector512Int32(value); /// - /// __m512i _mm512_cvtepu8_epi32 (__m128i a) - /// VPMOVZXBD zmm1 {k1}{z}, xmm2/m128 + /// __m512i _mm512_cvtepu8_epi32 (__m128i a) + /// VPMOVZXBD zmm1 {k1}{z}, xmm2/m128 /// public static Vector512 ConvertToVector512Int32(Vector128 value) => ConvertToVector512Int32(value); /// - /// __m512i _mm512_cvtepi16_epi32 (__m128i a) - /// VPMOVSXWD zmm1 {k1}{z}, ymm2/m256 + /// __m512i _mm512_cvtepi16_epi32 (__m128i a) + /// VPMOVSXWD zmm1 {k1}{z}, ymm2/m256 /// public static Vector512 ConvertToVector512Int32(Vector256 value) => ConvertToVector512Int32(value); /// - /// __m512i _mm512_cvtepu16_epi32 (__m128i a) - /// VPMOVZXWD zmm1 {k1}{z}, ymm2/m256 + /// __m512i _mm512_cvtepu16_epi32 (__m128i a) + /// VPMOVZXWD zmm1 {k1}{z}, ymm2/m256 /// public static Vector512 ConvertToVector512Int32(Vector256 value) => ConvertToVector512Int32(value); /// - /// __m512i _mm512_cvtps_epi32 (__m512 a) - /// VCVTPS2DQ zmm1 {k1}{z}, zmm2/m512/m32bcst{er} + /// __m512i _mm512_cvtps_epi32 (__m512 a) + /// VCVTPS2DQ zmm1 {k1}{z}, zmm2/m512/m32bcst{er} /// public static Vector512 ConvertToVector512Int32(Vector512 value) => ConvertToVector512Int32(value); /// - /// __m512i _mm512_cvt_roundps_epi32 (__m512 a, int rounding) - /// VCVTPS2DQ zmm1, zmm2 {er} + /// __m512i _mm512_cvt_roundps_epi32 (__m512 a, int rounding) + /// VCVTPS2DQ zmm1, zmm2 {er} /// public static Vector512 ConvertToVector512Int32(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Int32(value, mode); /// - /// __m512i _mm512_cvttps_epi32 (__m512 a) - /// VCVTTPS2DQ zmm1 {k1}{z}, zmm2/m512/m32bcst{sae} + /// __m512i _mm512_cvttps_epi32 (__m512 a) + /// VCVTTPS2DQ zmm1 {k1}{z}, zmm2/m512/m32bcst{sae} /// public static Vector512 ConvertToVector512Int32WithTruncation(Vector512 value) => ConvertToVector512Int32WithTruncation(value); /// - /// __m512i _mm512_cvtepi8_epi64 (__m128i a) - /// VPMOVSXBQ zmm1 {k1}{z}, xmm2/m64 + /// __m512i _mm512_cvtepi8_epi64 (__m128i a) + /// VPMOVSXBQ zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 ConvertToVector512Int64(Vector128 value) => ConvertToVector512Int64(value); /// - /// __m512i _mm512_cvtepu8_epi64 (__m128i a) - /// VPMOVZXBQ zmm1 {k1}{z}, xmm2/m64 + /// __m512i _mm512_cvtepu8_epi64 (__m128i a) + /// VPMOVZXBQ zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 ConvertToVector512Int64(Vector128 value) => ConvertToVector512Int64(value); /// - /// __m512i _mm512_cvtepi16_epi64 (__m128i a) - /// VPMOVSXWQ zmm1 {k1}{z}, xmm2/m128 + /// __m512i _mm512_cvtepi16_epi64 (__m128i a) + /// VPMOVSXWQ zmm1 {k1}{z}, xmm2/m128 /// public static Vector512 ConvertToVector512Int64(Vector128 value) => ConvertToVector512Int64(value); /// - /// __m512i _mm512_cvtepu16_epi64 (__m128i a) - /// VPMOVZXWQ zmm1 {k1}{z}, xmm2/m128 + /// __m512i _mm512_cvtepu16_epi64 (__m128i a) + /// VPMOVZXWQ zmm1 {k1}{z}, xmm2/m128 /// public static Vector512 ConvertToVector512Int64(Vector128 value) => ConvertToVector512Int64(value); /// - /// __m512i _mm512_cvtepi32_epi64 (__m128i a) - /// VPMOVSXDQ zmm1 {k1}{z}, ymm2/m256 + /// __m512i _mm512_cvtepi32_epi64 (__m128i a) + /// VPMOVSXDQ zmm1 {k1}{z}, ymm2/m256 /// public static Vector512 ConvertToVector512Int64(Vector256 value) => ConvertToVector512Int64(value); /// - /// __m512i _mm512_cvtepu32_epi64 (__m128i a) - /// VPMOVZXDQ zmm1 {k1}{z}, ymm2/m256 + /// __m512i _mm512_cvtepu32_epi64 (__m128i a) + /// VPMOVZXDQ zmm1 {k1}{z}, ymm2/m256 /// public static Vector512 ConvertToVector512Int64(Vector256 value) => ConvertToVector512Int64(value); /// - /// __m512 _mm512_cvtepi32_ps (__m512i a) - /// VCVTDQ2PS zmm1 {k1}{z}, zmm2/m512/m32bcst{er} + /// __m512 _mm512_cvtepi32_ps (__m512i a) + /// VCVTDQ2PS zmm1 {k1}{z}, zmm2/m512/m32bcst{er} /// public static Vector512 ConvertToVector512Single(Vector512 value) => ConvertToVector512Single(value); /// - /// __m512 _mm512_cvt_roundepi32_ps (__m512i a, int rounding) - /// VCVTDQ2PS zmm1, zmm2 {er} + /// __m512 _mm512_cvt_roundepi32_ps (__m512i a, int rounding) + /// VCVTDQ2PS zmm1, zmm2 {er} /// public static Vector512 ConvertToVector512Single(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Single(value, mode); /// - /// __m512 _mm512_cvtepu32_ps (__m512i a) - /// VCVTUDQ2PS zmm1 {k1}{z}, zmm2/m512/m32bcst{er} + /// __m512 _mm512_cvtepu32_ps (__m512i a) + /// VCVTUDQ2PS zmm1 {k1}{z}, zmm2/m512/m32bcst{er} /// public static Vector512 ConvertToVector512Single(Vector512 value) => ConvertToVector512Single(value); /// - /// __m512 _mm512_cvt_roundepi32_ps (__m512i a, int rounding) - /// VCVTUDQ2PS zmm1, zmm2 {er} + /// __m512 _mm512_cvt_roundepi32_ps (__m512i a, int rounding) + /// VCVTUDQ2PS zmm1, zmm2 {er} /// public static Vector512 ConvertToVector512Single(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512Single(value, mode); /// - /// __m512i _mm512_cvtepi8_epi32 (__m128i a) - /// VPMOVSXBD zmm1 {k1}{z}, xmm2/m128 + /// __m512i _mm512_cvtepi8_epi32 (__m128i a) + /// VPMOVSXBD zmm1 {k1}{z}, xmm2/m128 /// public static Vector512 ConvertToVector512UInt32(Vector128 value) => ConvertToVector512UInt32(value); /// - /// __m512i _mm512_cvtepu8_epi32 (__m128i a) - /// VPMOVZXBD zmm1 {k1}{z}, xmm2/m128 + /// __m512i _mm512_cvtepu8_epi32 (__m128i a) + /// VPMOVZXBD zmm1 {k1}{z}, xmm2/m128 /// public static Vector512 ConvertToVector512UInt32(Vector128 value) => ConvertToVector512UInt32(value); /// - /// __m512i _mm512_cvtepi16_epi32 (__m128i a) - /// VPMOVSXWD zmm1 {k1}{z}, ymm2/m256 + /// __m512i _mm512_cvtepi16_epi32 (__m128i a) + /// VPMOVSXWD zmm1 {k1}{z}, ymm2/m256 /// public static Vector512 ConvertToVector512UInt32(Vector256 value) => ConvertToVector512UInt32(value); /// - /// __m512i _mm512_cvtepu16_epi32 (__m128i a) - /// VPMOVZXWD zmm1 {k1}{z}, ymm2/m256 + /// __m512i _mm512_cvtepu16_epi32 (__m128i a) + /// VPMOVZXWD zmm1 {k1}{z}, ymm2/m256 /// public static Vector512 ConvertToVector512UInt32(Vector256 value) => ConvertToVector512UInt32(value); /// - /// __m512i _mm512_cvtps_epu32 (__m512 a) - /// VCVTPS2UDQ zmm1 {k1}{z}, zmm2/m512/m32bcst{er} + /// __m512i _mm512_cvtps_epu32 (__m512 a) + /// VCVTPS2UDQ zmm1 {k1}{z}, zmm2/m512/m32bcst{er} /// public static Vector512 ConvertToVector512UInt32(Vector512 value) => ConvertToVector512UInt32(value); /// - /// __m512i _mm512_cvt_roundps_epu32 (__m512 a, int rounding) - /// VCVTPS2UDQ zmm1, zmm2 {er} + /// __m512i _mm512_cvt_roundps_epu32 (__m512 a, int rounding) + /// VCVTPS2UDQ zmm1, zmm2 {er} /// public static Vector512 ConvertToVector512UInt32(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ConvertToVector512UInt32(value, mode); /// - /// __m512i _mm512_cvttps_epu32 (__m512 a) - /// VCVTTPS2UDQ zmm1 {k1}{z}, zmm2/m512/m32bcst{er} + /// __m512i _mm512_cvttps_epu32 (__m512 a) + /// VCVTTPS2UDQ zmm1 {k1}{z}, zmm2/m512/m32bcst{er} /// public static Vector512 ConvertToVector512UInt32WithTruncation(Vector512 value) => ConvertToVector512UInt32WithTruncation(value); /// - /// __m512i _mm512_cvtepi8_epi64 (__m128i a) - /// VPMOVSXBQ zmm1 {k1}{z}, xmm2/m64 + /// __m512i _mm512_cvtepi8_epi64 (__m128i a) + /// VPMOVSXBQ zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 ConvertToVector512UInt64(Vector128 value) => ConvertToVector512UInt64(value); /// - /// __m512i _mm512_cvtepu8_epi64 (__m128i a) - /// VPMOVZXBQ zmm1 {k1}{z}, xmm2/m64 + /// __m512i _mm512_cvtepu8_epi64 (__m128i a) + /// VPMOVZXBQ zmm1 {k1}{z}, xmm2/m64 /// public static Vector512 ConvertToVector512UInt64(Vector128 value) => ConvertToVector512UInt64(value); /// - /// __m512i _mm512_cvtepi16_epi64 (__m128i a) - /// VPMOVSXWQ zmm1 {k1}{z}, xmm2/m128 + /// __m512i _mm512_cvtepi16_epi64 (__m128i a) + /// VPMOVSXWQ zmm1 {k1}{z}, xmm2/m128 /// public static Vector512 ConvertToVector512UInt64(Vector128 value) => ConvertToVector512UInt64(value); /// - /// __m512i _mm512_cvtepu16_epi64 (__m128i a) - /// VPMOVZXWQ zmm1 {k1}{z}, xmm2/m128 + /// __m512i _mm512_cvtepu16_epi64 (__m128i a) + /// VPMOVZXWQ zmm1 {k1}{z}, xmm2/m128 /// public static Vector512 ConvertToVector512UInt64(Vector128 value) => ConvertToVector512UInt64(value); /// - /// __m512i _mm512_cvtepi32_epi64 (__m128i a) - /// VPMOVSXDQ zmm1 {k1}{z}, ymm2/m256 + /// __m512i _mm512_cvtepi32_epi64 (__m128i a) + /// VPMOVSXDQ zmm1 {k1}{z}, ymm2/m256 /// public static Vector512 ConvertToVector512UInt64(Vector256 value) => ConvertToVector512UInt64(value); /// - /// __m512i _mm512_cvtepu32_epi64 (__m128i a) - /// VPMOVZXDQ zmm1 {k1}{z}, ymm2/m256 + /// __m512i _mm512_cvtepu32_epi64 (__m128i a) + /// VPMOVZXDQ zmm1 {k1}{z}, ymm2/m256 /// public static Vector512 ConvertToVector512UInt64(Vector256 value) => ConvertToVector512UInt64(value); /// - /// __m512 _mm512_div_ps (__m512 a, __m512 b) - /// VDIVPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er} + /// __m512 _mm512_div_ps (__m512 a, __m512 b) + /// VDIVPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er} /// public static Vector512 Divide(Vector512 left, Vector512 right) => Divide(left, right); /// - /// __m512d _mm512_div_pd (__m512d a, __m512d b) - /// VDIVPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er} + /// __m512d _mm512_div_pd (__m512d a, __m512d b) + /// VDIVPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er} /// public static Vector512 Divide(Vector512 left, Vector512 right) => Divide(left, right); /// - /// __m512 _mm512_div_round_ps (__m512 a, __m512 b, int rounding) - /// VDIVPS zmm1, zmm2, zmm3 {er} + /// __m512 _mm512_div_round_ps (__m512 a, __m512 b, int rounding) + /// VDIVPS zmm1, zmm2, zmm3 {er} /// public static Vector512 Divide(Vector512 left, Vector512 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => Divide(left, right, mode); /// - /// __m512d _mm512_div_round_pd (__m512d a, __m512d b, int rounding) - /// VDIVPD zmm1, zmm2, zmm3 {er} + /// __m512d _mm512_div_round_pd (__m512d a, __m512d b, int rounding) + /// VDIVPD zmm1, zmm2, zmm3 {er} /// public static Vector512 Divide(Vector512 left, Vector512 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => Divide(left, right, mode); /// - /// __m128 _mm_div_round_ss (__m128 a, __m128 b, int rounding) - /// VDIVSD xmm1, xmm2, xmm3 {er} + /// __m128 _mm_div_round_ss (__m128 a, __m128 b, int rounding) + /// VDIVSD xmm1, xmm2, xmm3 {er} /// public static Vector128 DivideScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => DivideScalar(left, right, mode); /// - /// __m128d _mm_div_round_sd (__m128d a, __m128d b, int rounding) - /// VDIVSS xmm1, xmm2, xmm3 {er} + /// __m128d _mm_div_round_sd (__m128d a, __m128d b, int rounding) + /// VDIVSS xmm1, xmm2, xmm3 {er} /// public static Vector128 DivideScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => DivideScalar(left, right, mode); /// - /// __m512 _mm512_moveldup_ps (__m512 a) - /// VMOVSLDUP zmm1 {k1}{z}, zmm2/m512 + /// __m512 _mm512_moveldup_ps (__m512 a) + /// VMOVSLDUP zmm1 {k1}{z}, zmm2/m512 /// public static Vector512 DuplicateEvenIndexed(Vector512 value) => DuplicateEvenIndexed(value); /// - /// __m512d _mm512_movedup_pd (__m512d a) - /// VMOVDDUP zmm1 {k1}{z}, zmm2/m512 + /// __m512d _mm512_movedup_pd (__m512d a) + /// VMOVDDUP zmm1 {k1}{z}, zmm2/m512 /// public static Vector512 DuplicateEvenIndexed(Vector512 value) => DuplicateEvenIndexed(value); /// - /// __m512 _mm512_movehdup_ps (__m512 a) - /// VMOVSHDUP zmm1 {k1}{z}, zmm2/m512 + /// __m512 _mm512_movehdup_ps (__m512 a) + /// VMOVSHDUP zmm1 {k1}{z}, zmm2/m512 /// public static Vector512 DuplicateOddIndexed(Vector512 value) => DuplicateOddIndexed(value); /// - /// __m128i _mm512_extracti128_si512 (__m512i a, const int imm8) - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128i _mm512_extracti128_si512 (__m512i a, const int imm8) + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128i _mm512_extracti128_si512 (__m512i a, const int imm8) - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128i _mm512_extracti128_si512 (__m512i a, const int imm8) + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128i _mm512_extracti128_si512 (__m512i a, const int imm8) - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128i _mm512_extracti128_si512 (__m512i a, const int imm8) + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128i _mm512_extracti128_si512 (__m512i a, const int imm8) - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128i _mm512_extracti128_si512 (__m512i a, const int imm8) + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128i _mm512_extracti32x4_epi32 (__m512i a, const int imm8) - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128i _mm512_extracti32x4_epi32 (__m512i a, const int imm8) + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128i _mm512_extracti32x4_epi32 (__m512i a, const int imm8) - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128i _mm512_extracti32x4_epi32 (__m512i a, const int imm8) + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128i _mm512_extracti128_si512 (__m512i a, const int imm8) - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128i _mm512_extracti128_si512 (__m512i a, const int imm8) + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128i _mm512_extracti128_si512 (__m512i a, const int imm8) - /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128i _mm512_extracti128_si512 (__m512i a, const int imm8) + /// VEXTRACTI32x4 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128 _mm512_extractf32x4_ps (__m512 a, const int imm8) - /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128 _mm512_extractf32x4_ps (__m512 a, const int imm8) + /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m128d _mm512_extractf128_pd (__m512d a, const int imm8) - /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, zmm2, imm8 + /// __m128d _mm512_extractf128_pd (__m512d a, const int imm8) + /// VEXTRACTF32x4 xmm1/m128 {k1}{z}, zmm2, imm8 /// public static Vector128 ExtractVector128(Vector512 value, [ConstantExpected] byte index) => ExtractVector128(value, index); /// - /// __m256i _mm512_extracti256_si512 (__m512i a, const int imm8) - /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256i _mm512_extracti256_si512 (__m512i a, const int imm8) + /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) => ExtractVector256(value, index); /// - /// __m256i _mm512_extracti256_si512 (__m512i a, const int imm8) - /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256i _mm512_extracti256_si512 (__m512i a, const int imm8) + /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) => ExtractVector256(value, index); /// - /// __m256i _mm512_extracti256_si512 (__m512i a, const int imm8) - /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256i _mm512_extracti256_si512 (__m512i a, const int imm8) + /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) => ExtractVector256(value, index); /// - /// __m256i _mm512_extracti256_si512 (__m512i a, const int imm8) - /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256i _mm512_extracti256_si512 (__m512i a, const int imm8) + /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) => ExtractVector256(value, index); /// - /// __m256i _mm512_extracti256_si512 (__m512i a, const int imm8) - /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256i _mm512_extracti256_si512 (__m512i a, const int imm8) + /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) => ExtractVector256(value, index); /// - /// __m256i _mm512_extracti256_si512 (__m512i a, const int imm8) - /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256i _mm512_extracti256_si512 (__m512i a, const int imm8) + /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) => ExtractVector256(value, index); /// - /// __m256i _mm512_extracti64x4_epi64 (__m512i a, const int imm8) - /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256i _mm512_extracti64x4_epi64 (__m512i a, const int imm8) + /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) => ExtractVector256(value, index); /// - /// __m256i _mm512_extracti64x4_epi64 (__m512i a, const int imm8) - /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256i _mm512_extracti64x4_epi64 (__m512i a, const int imm8) + /// VEXTRACTI64x4 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) => ExtractVector256(value, index); /// - /// __m256 _mm512_extractf256_ps (__m512 a, const int imm8) - /// VEXTRACTF64x4 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256 _mm512_extractf256_ps (__m512 a, const int imm8) + /// VEXTRACTF64x4 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) => ExtractVector256(value, index); /// - /// __m256d _mm512_extractf64x4_pd (__m512d a, const int imm8) - /// VEXTRACTF64x4 ymm1/m256 {k1}{z}, zmm2, imm8 + /// __m256d _mm512_extractf64x4_pd (__m512d a, const int imm8) + /// VEXTRACTF64x4 ymm1/m256 {k1}{z}, zmm2, imm8 /// public static Vector256 ExtractVector256(Vector512 value, [ConstantExpected] byte index) => ExtractVector256(value, index); /// - /// __m512 _mm512_fixupimm_ps(__m512 a, __m512 b, __m512i tbl, int imm); - /// VFIXUPIMMPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}, imm8 + /// __m512 _mm512_fixupimm_ps(__m512 a, __m512 b, __m512i tbl, int imm); + /// VFIXUPIMMPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae}, imm8 /// public static Vector512 Fixup(Vector512 left, Vector512 right, Vector512 table, [ConstantExpected] byte control) => Fixup(left, right, table, control); /// - /// __m512d _mm512_fixupimm_pd(__m512d a, __m512d b, __m512i tbl, int imm); - /// VFIXUPIMMPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}, imm8 + /// __m512d _mm512_fixupimm_pd(__m512d a, __m512d b, __m512i tbl, int imm); + /// VFIXUPIMMPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae}, imm8 /// public static Vector512 Fixup(Vector512 left, Vector512 right, Vector512 table, [ConstantExpected] byte control) => Fixup(left, right, table, control); /// - /// __m128 _mm_fixupimm_ss(__m128 a, __m128 b, __m128i tbl, int imm); - /// VFIXUPIMMSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 + /// __m128 _mm_fixupimm_ss(__m128 a, __m128 b, __m128i tbl, int imm); + /// VFIXUPIMMSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 /// public static Vector128 FixupScalar(Vector128 left, Vector128 right, Vector128 table, [ConstantExpected] byte control) => FixupScalar(left, right, table, control); /// - /// __m128d _mm_fixupimm_sd(__m128d a, __m128d b, __m128i tbl, int imm); - /// VFIXUPIMMSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 + /// __m128d _mm_fixupimm_sd(__m128d a, __m128d b, __m128i tbl, int imm); + /// VFIXUPIMMSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 /// public static Vector128 FixupScalar(Vector128 left, Vector128 right, Vector128 table, [ConstantExpected] byte control) => FixupScalar(left, right, table, control); /// - /// __m512 _mm512_fmadd_ps (__m512 a, __m512 b, __m512 c) - /// VFMADDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_fmadd_ps (__m512 a, __m512 b, __m512 c) + /// VFMADDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 FusedMultiplyAdd(Vector512 a, Vector512 b, Vector512 c) => FusedMultiplyAdd(a, b, c); /// - /// __m512 _mm512_fmadd_round_ps (__m512 a, __m512 b, __m512 c, int r) - /// VFMADDPS zmm1, zmm2, zmm3 {er} + /// __m512 _mm512_fmadd_round_ps (__m512 a, __m512 b, __m512 c, int r) + /// VFMADDPS zmm1, zmm2, zmm3 {er} /// public static Vector512 FusedMultiplyAdd(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplyAdd(a, b, c, mode); /// - /// __m512d _mm512_fmadd_pd (__m512d a, __m512d b, __m512d c) - /// VFMADDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_fmadd_pd (__m512d a, __m512d b, __m512d c) + /// VFMADDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 FusedMultiplyAdd(Vector512 a, Vector512 b, Vector512 c) => FusedMultiplyAdd(a, b, c); /// - /// __m512d _mm512_fmadd_round_pd (__m512d a, __m512d b, __m512d c, int r) - /// VFMADDPS zmm1, zmm2, zmm3 {er} + /// __m512d _mm512_fmadd_round_pd (__m512d a, __m512d b, __m512d c, int r) + /// VFMADDPS zmm1, zmm2, zmm3 {er} /// public static Vector512 FusedMultiplyAdd(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplyAdd(a, b, c, mode); /// - /// __m128 _mm_fmadd_round_ss (__m128 a, __m128 b, __m128 c, int r) - /// VFMADDSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_fmadd_round_ss (__m128 a, __m128 b, __m128 c, int r) + /// VFMADDSS xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplyAddScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplyAddScalar(a, b, c, mode); /// - /// __m128d _mm_fmadd_round_sd (__m128d a, __m128d b, __m128d c, int r) - /// VFMADDSD xmm1, xmm2, xmm3 {er} + /// __m128d _mm_fmadd_round_sd (__m128d a, __m128d b, __m128d c, int r) + /// VFMADDSD xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplyAddScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplyAddScalar(a, b, c, mode); /// - /// __m512 _mm512_fmaddsub_ps (__m512 a, __m512 b, __m512 c) - /// VFMADDSUBPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_fmaddsub_ps (__m512 a, __m512 b, __m512 c) + /// VFMADDSUBPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 FusedMultiplyAddSubtract(Vector512 a, Vector512 b, Vector512 c) => FusedMultiplyAddSubtract(a, b, c); /// - /// __m512 _mm512_fmaddsub_ps (__m512 a, __m512 b, __m512 c, int c) - /// VFMADDSUBPS zmm1, zmm2, zmm3 {er} + /// __m512 _mm512_fmaddsub_ps (__m512 a, __m512 b, __m512 c, int c) + /// VFMADDSUBPS zmm1, zmm2, zmm3 {er} /// public static Vector512 FusedMultiplyAddSubtract(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplyAddSubtract(a, b, c, mode); /// - /// __m512d _mm512_fmaddsub_pd (__m512d a, __m512d b, __m512d c) - /// VFMADDSUBPD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512d _mm512_fmaddsub_pd (__m512d a, __m512d b, __m512d c) + /// VFMADDSUBPD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 FusedMultiplyAddSubtract(Vector512 a, Vector512 b, Vector512 c) => FusedMultiplyAddSubtract(a, b, c); /// - /// __m512d _mm512_fmaddsub_pd (__m512d a, __m512d b, __m512d c, int c) - /// VFMADDSUBPS zmm1, zmm2, zmm3 {er} + /// __m512d _mm512_fmaddsub_pd (__m512d a, __m512d b, __m512d c, int c) + /// VFMADDSUBPS zmm1, zmm2, zmm3 {er} /// public static Vector512 FusedMultiplyAddSubtract(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplyAddSubtract(a, b, c, mode); /// - /// __m512 _mm512_fmsub_ps (__m512 a, __m512 b, __m512 c) - /// VFMSUBPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_fmsub_ps (__m512 a, __m512 b, __m512 c) + /// VFMSUBPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 FusedMultiplySubtract(Vector512 a, Vector512 b, Vector512 c) => FusedMultiplySubtract(a, b, c); /// - /// __m512 _mm512_fmsub_round_ps (__m512 a, __m512 b, __m512 c, int r) - /// VFMSUBPS zmm1, zmm2, zmm3 {er} + /// __m512 _mm512_fmsub_round_ps (__m512 a, __m512 b, __m512 c, int r) + /// VFMSUBPS zmm1, zmm2, zmm3 {er} /// public static Vector512 FusedMultiplySubtract(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplySubtract(a, b, c, mode); /// - /// __m512d _mm512_fmsub_pd (__m512d a, __m512d b, __m512d c) - /// VFMSUBPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_fmsub_pd (__m512d a, __m512d b, __m512d c) + /// VFMSUBPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 FusedMultiplySubtract(Vector512 a, Vector512 b, Vector512 c) => FusedMultiplySubtract(a, b, c); /// - /// __m512d _mm512_fmsub_round_pd (__m512d a, __m512d b, __m512d c, int r) - /// VFMSUBPD zmm1, zmm2, zmm3 {er} + /// __m512d _mm512_fmsub_round_pd (__m512d a, __m512d b, __m512d c, int r) + /// VFMSUBPD zmm1, zmm2, zmm3 {er} /// public static Vector512 FusedMultiplySubtract(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplySubtract(a, b, c, mode); /// - /// __m128 _mm_fmsub_round_ss (__m128 a, __m128 b, __m128 c, int r) - /// VFMSUBSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_fmsub_round_ss (__m128 a, __m128 b, __m128 c, int r) + /// VFMSUBSS xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplySubtractScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplySubtractScalar(a, b, c, mode); /// - /// __m128d _mm_fmsub_round_sd (__m128d a, __m128d b, __m128d c, int r) - /// VFMSUBSS xmm1, xmm2, xmm3 {er} + /// __m128d _mm_fmsub_round_sd (__m128d a, __m128d b, __m128d c, int r) + /// VFMSUBSS xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplySubtractScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplySubtractScalar(a, b, c, mode); /// - /// __m512 _mm512_fmsubadd_ps (__m512 a, __m512 b, __m512 c) - /// VFMSUBADDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_fmsubadd_ps (__m512 a, __m512 b, __m512 c) + /// VFMSUBADDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 FusedMultiplySubtractAdd(Vector512 a, Vector512 b, Vector512 c) => FusedMultiplySubtractAdd(a, b, c); /// - /// __m512 _mm512_fmsubadd_round_ps (__m512 a, __m512 b, __m512 c) - /// VFMSUBADDPS zmm1, zmm2, zmm3 {er} + /// __m512 _mm512_fmsubadd_round_ps (__m512 a, __m512 b, __m512 c) + /// VFMSUBADDPS zmm1, zmm2, zmm3 {er} /// public static Vector512 FusedMultiplySubtractAdd(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplySubtractAdd(a, b, c, mode); /// - /// __m512d _mm512_fmsubadd_pd (__m512d a, __m512d b, __m512d c) - /// VFMSUBADDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_fmsubadd_pd (__m512d a, __m512d b, __m512d c) + /// VFMSUBADDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 FusedMultiplySubtractAdd(Vector512 a, Vector512 b, Vector512 c) => FusedMultiplySubtractAdd(a, b, c); /// - /// __m512d _mm512_fmsubadd_round_ps (__m512d a, __m512d b, __m512d c) - /// VFMSUBADDPD zmm1, zmm2, zmm3 {er} + /// __m512d _mm512_fmsubadd_round_ps (__m512d a, __m512d b, __m512d c) + /// VFMSUBADDPD zmm1, zmm2, zmm3 {er} /// public static Vector512 FusedMultiplySubtractAdd(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplySubtractAdd(a, b, c, mode); /// - /// __m512 _mm512_fnmadd_ps (__m512 a, __m512 b, __m512 c) - /// VFNMADDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_fnmadd_ps (__m512 a, __m512 b, __m512 c) + /// VFNMADDPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 FusedMultiplyAddNegated(Vector512 a, Vector512 b, Vector512 c) => FusedMultiplyAddNegated(a, b, c); /// - /// __m512 _mm512_fnmadd_round_ps (__m512 a, __m512 b, __m512 c, int r) - /// VFNMADDPS zmm1, zmm2, zmm3 {er} + /// __m512 _mm512_fnmadd_round_ps (__m512 a, __m512 b, __m512 c, int r) + /// VFNMADDPS zmm1, zmm2, zmm3 {er} /// public static Vector512 FusedMultiplyAddNegated(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplyAddNegated(a, b, c, mode); /// - /// __m512d _mm512_fnmadd_pd (__m512d a, __m512d b, __m512d c) - /// VFNMADDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_fnmadd_pd (__m512d a, __m512d b, __m512d c) + /// VFNMADDPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 FusedMultiplyAddNegated(Vector512 a, Vector512 b, Vector512 c) => FusedMultiplyAddNegated(a, b, c); /// - /// __m512d _mm512_fnmadd_round_pdd (__m512d a, __m512d b, __m512d c, int r) - /// VFNMADDPS zmm1, zmm2, zmm3 {er} + /// __m512d _mm512_fnmadd_round_pdd (__m512d a, __m512d b, __m512d c, int r) + /// VFNMADDPS zmm1, zmm2, zmm3 {er} /// public static Vector512 FusedMultiplyAddNegated(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplyAddNegated(a, b, c, mode); /// - /// __m128 _mm_fnmadd_round_ss (__m128 a, __m128 b, __m128 c, int r) - /// VFNMADDSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_fnmadd_round_ss (__m128 a, __m128 b, __m128 c, int r) + /// VFNMADDSS xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplyAddNegatedScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplyAddNegatedScalar(a, b, c, mode); /// - /// __m128d _mm_fnmadd_round_sd (__m128d a, __m128d b, __m128d c, int r) - /// VFNMADDSD xmm1, xmm2, xmm3 {er} + /// __m128d _mm_fnmadd_round_sd (__m128d a, __m128d b, __m128d c, int r) + /// VFNMADDSD xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplyAddNegatedScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplyAddNegatedScalar(a, b, c, mode); /// - /// __m512 _mm512_fnmsub_ps (__m512 a, __m512 b, __m512 c) - /// VFNMSUBPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_fnmsub_ps (__m512 a, __m512 b, __m512 c) + /// VFNMSUBPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 FusedMultiplySubtractNegated(Vector512 a, Vector512 b, Vector512 c) => FusedMultiplySubtractNegated(a, b, c); /// - /// __m512 _mm512_fnmsub_round_ps (__m512 a, __m512 b, __m512 c, int r) - /// VFNMSUBPS zmm1, zmm2, zmm3 {er} + /// __m512 _mm512_fnmsub_round_ps (__m512 a, __m512 b, __m512 c, int r) + /// VFNMSUBPS zmm1, zmm2, zmm3 {er} /// public static Vector512 FusedMultiplySubtractNegated(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplySubtractNegated(a, b, c, mode); /// - /// __m512d _mm512_fnmsub_pd (__m512d a, __m512d b, __m512d c) - /// VFNMSUBPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_fnmsub_pd (__m512d a, __m512d b, __m512d c) + /// VFNMSUBPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 FusedMultiplySubtractNegated(Vector512 a, Vector512 b, Vector512 c) => FusedMultiplySubtractNegated(a, b, c); /// - /// __m512d _mm512_fnmsub_round_pd (__m512d a, __m512d b, __m512d c, int r) - /// VFNMSUBPS zmm1, zmm2, zmm3 {er} + /// __m512d _mm512_fnmsub_round_pd (__m512d a, __m512d b, __m512d c, int r) + /// VFNMSUBPS zmm1, zmm2, zmm3 {er} /// public static Vector512 FusedMultiplySubtractNegated(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplySubtractNegated(a, b, c, mode); /// - /// __m128 _mm_fnmsub_round_ss (__m128 a, __m128 b, __m128 c, int r) - /// VFNMSUBSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_fnmsub_round_ss (__m128 a, __m128 b, __m128 c, int r) + /// VFNMSUBSS xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplySubtractNegatedScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplySubtractNegatedScalar(a, b, c, mode); /// - /// __m128d _mm_fnmsub_round_sd (__m128d a, __m128d b, __m128d c, int r) - /// VFNMSUBSS xmm1, xmm2, xmm3 {er} + /// __m128d _mm_fnmsub_round_sd (__m128d a, __m128d b, __m128d c, int r) + /// VFNMSUBSS xmm1, xmm2, xmm3 {er} /// public static Vector128 FusedMultiplySubtractNegatedScalar(Vector128 a, Vector128 b, Vector128 c, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => FusedMultiplySubtractNegatedScalar(a, b, c, mode); /// - /// __m512 _mm512_getexp_ps (__m512 a) - /// VGETEXPPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae} + /// __m512 _mm512_getexp_ps (__m512 a) + /// VGETEXPPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae} /// public static Vector512 GetExponent(Vector512 value) => GetExponent(value); /// - /// __m512d _mm512_getexp_pd (__m512d a) - /// VGETEXPPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae} + /// __m512d _mm512_getexp_pd (__m512d a) + /// VGETEXPPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae} /// public static Vector512 GetExponent(Vector512 value) => GetExponent(value); /// - /// __m128 _mm_getexp_ss (__m128 a) - /// VGETEXPSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} + /// __m128 _mm_getexp_ss (__m128 a) + /// VGETEXPSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} /// public static Vector128 GetExponentScalar(Vector128 value) => GetExponentScalar(value); /// - /// __m128d _mm_getexp_sd (__m128d a) - /// VGETEXPSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} + /// __m128d _mm_getexp_sd (__m128d a) + /// VGETEXPSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} /// public static Vector128 GetExponentScalar(Vector128 value) => GetExponentScalar(value); /// - /// __m128 _mm_getexp_ss (__m128 a, __m128 b) - /// VGETEXPSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_getexp_ss (__m128 a, __m128 b) + /// VGETEXPSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 GetExponentScalar(Vector128 upper, Vector128 value) => GetExponentScalar(upper, value); /// - /// __m128d _mm_getexp_sd (__m128d a, __m128d b) - /// VGETEXPSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128d _mm_getexp_sd (__m128d a, __m128d b) + /// VGETEXPSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 GetExponentScalar(Vector128 upper, Vector128 value) => GetExponentScalar(upper, value); /// - /// __m512 _mm512_getmant_ps (__m512 a) - /// VGETMANTPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae} + /// __m512 _mm512_getmant_ps (__m512 a) + /// VGETMANTPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae} /// public static Vector512 GetMantissa(Vector512 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) => GetMantissa(value, control); /// - /// __m512d _mm512_getmant_pd (__m512d a) - /// VGETMANTPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae} + /// __m512d _mm512_getmant_pd (__m512d a) + /// VGETMANTPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae} /// public static Vector512 GetMantissa(Vector512 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) => GetMantissa(value, control); /// - /// __m128 _mm_getmant_ss (__m128 a) - /// VGETMANTSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} + /// __m128 _mm_getmant_ss (__m128 a) + /// VGETMANTSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} /// public static Vector128 GetMantissaScalar(Vector128 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) => GetMantissaScalar(value, control); /// - /// __m128d _mm_getmant_sd (__m128d a) - /// VGETMANTSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} + /// __m128d _mm_getmant_sd (__m128d a) + /// VGETMANTSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} /// public static Vector128 GetMantissaScalar(Vector128 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) => GetMantissaScalar(value, control); /// - /// __m128 _mm_getmant_ss (__m128 a, __m128 b) - /// VGETMANTSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_getmant_ss (__m128 a, __m128 b) + /// VGETMANTSS xmm1 {k1}{z}, xmm2, xmm3/m32{sae} + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 GetMantissaScalar(Vector128 upper, Vector128 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) => GetMantissaScalar(upper, value, control); /// - /// __m128d _mm_getmant_sd (__m128d a, __m128d b) - /// VGETMANTSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128d _mm_getmant_sd (__m128d a, __m128d b) + /// VGETMANTSD xmm1 {k1}{z}, xmm2, xmm3/m64{sae} + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 GetMantissaScalar(Vector128 upper, Vector128 value, [ConstantExpected(Max = (byte)(0x0F))] byte control) => GetMantissaScalar(upper, value, control); /// - /// __m512i _mm512_inserti128_si512 (__m512i a, __m128i b, const int imm8) - /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512i _mm512_inserti128_si512 (__m512i a, __m128i b, const int imm8) + /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m512i _mm512_inserti128_si512 (__m512i a, __m128i b, const int imm8) - /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512i _mm512_inserti128_si512 (__m512i a, __m128i b, const int imm8) + /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m512i _mm512_inserti128_si512 (__m512i a, __m128i b, const int imm8) - /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512i _mm512_inserti128_si512 (__m512i a, __m128i b, const int imm8) + /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m512i _mm512_inserti128_si512 (__m512i a, __m128i b, const int imm8) - /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512i _mm512_inserti128_si512 (__m512i a, __m128i b, const int imm8) + /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m512i _mm512_inserti32x4_epi32 (__m512i a, __m128i b, const int imm8) - /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512i _mm512_inserti32x4_epi32 (__m512i a, __m128i b, const int imm8) + /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m512i _mm512_inserti32x4_epi32 (__m512i a, __m128i b, const int imm8) - /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512i _mm512_inserti32x4_epi32 (__m512i a, __m128i b, const int imm8) + /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m512i _mm512_inserti128_si512 (__m512i a, __m128i b, const int imm8) - /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512i _mm512_inserti128_si512 (__m512i a, __m128i b, const int imm8) + /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m512i _mm512_inserti128_si512 (__m512i a, __m128i b, const int imm8) - /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512i _mm512_inserti128_si512 (__m512i a, __m128i b, const int imm8) + /// VINSERTI32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m512 _mm512_insertf32x4_ps (__m512 a, __m128 b, int imm8) - /// VINSERTF32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512 _mm512_insertf32x4_ps (__m512 a, __m128 b, int imm8) + /// VINSERTF32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m512d _mm512_insertf128_pd (__m512d a, __m128d b, int imm8) - /// VINSERTF32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 + /// __m512d _mm512_insertf128_pd (__m512d a, __m128d b, int imm8) + /// VINSERTF32x4 zmm1 {k1}{z}, zmm2, xmm3/m128, imm8 /// public static Vector512 InsertVector128(Vector512 value, Vector128 data, [ConstantExpected] byte index) => InsertVector128(value, data, index); /// - /// __m512i _mm512_inserti256_si512 (__m512i a, __m256i b, const int imm8) - /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512i _mm512_inserti256_si512 (__m512i a, __m256i b, const int imm8) + /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) => InsertVector256(value, data, index); /// - /// __m512i _mm512_inserti256_si512 (__m512i a, __m256i b, const int imm8) - /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512i _mm512_inserti256_si512 (__m512i a, __m256i b, const int imm8) + /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) => InsertVector256(value, data, index); /// - /// __m512i _mm512_inserti256_si512 (__m512i a, __m256i b, const int imm8) - /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512i _mm512_inserti256_si512 (__m512i a, __m256i b, const int imm8) + /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) => InsertVector256(value, data, index); /// - /// __m512i _mm512_inserti256_si512 (__m512i a, __m256i b, const int imm8) - /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512i _mm512_inserti256_si512 (__m512i a, __m256i b, const int imm8) + /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) => InsertVector256(value, data, index); /// - /// __m512i _mm512_inserti256_si512 (__m512i a, __m256i b, const int imm8) - /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512i _mm512_inserti256_si512 (__m512i a, __m256i b, const int imm8) + /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) => InsertVector256(value, data, index); /// - /// __m512i _mm512_inserti256_si512 (__m512i a, __m256i b, const int imm8) - /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512i _mm512_inserti256_si512 (__m512i a, __m256i b, const int imm8) + /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) => InsertVector256(value, data, index); /// - /// __m512i _mm512_inserti64x4_epi64 (__m512i a, __m256i b, const int imm8) - /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512i _mm512_inserti64x4_epi64 (__m512i a, __m256i b, const int imm8) + /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) => InsertVector256(value, data, index); /// - /// __m512i _mm512_inserti64x4_epi64 (__m512i a, __m256i b, const int imm8) - /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512i _mm512_inserti64x4_epi64 (__m512i a, __m256i b, const int imm8) + /// VINSERTI64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) => InsertVector256(value, data, index); /// - /// __m512 _mm512_insertf256_ps (__m512 a, __m256 b, int imm8) - /// VINSERTF64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512 _mm512_insertf256_ps (__m512 a, __m256 b, int imm8) + /// VINSERTF64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) => InsertVector256(value, data, index); /// - /// __m512d _mm512_insertf64x4_pd (__m512d a, __m256d b, int imm8) - /// VINSERTF64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 + /// __m512d _mm512_insertf64x4_pd (__m512d a, __m256d b, int imm8) + /// VINSERTF64x4 zmm1 {k1}{z}, zmm2, xmm3/m256, imm8 /// public static Vector512 InsertVector256(Vector512 value, Vector256 data, [ConstantExpected] byte index) => InsertVector256(value, data, index); /// - /// __m512i _mm512_load_si512 (__m512i const * mem_addr) - /// VMOVDQA32 zmm1 {k1}{z}, m512 + /// __m512i _mm512_load_si512 (__m512i const * mem_addr) + /// VMOVDQA32 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadAlignedVector512(byte* address) => LoadAlignedVector512(address); /// - /// __m512i _mm512_load_si512 (__m512i const * mem_addr) - /// VMOVDQA32 zmm1 {k1}{z}, m512 + /// __m512i _mm512_load_si512 (__m512i const * mem_addr) + /// VMOVDQA32 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadAlignedVector512(sbyte* address) => LoadAlignedVector512(address); /// - /// __m512i _mm512_load_si512 (__m512i const * mem_addr) - /// VMOVDQA32 zmm1 {k1}{z}, m512 + /// __m512i _mm512_load_si512 (__m512i const * mem_addr) + /// VMOVDQA32 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadAlignedVector512(short* address) => LoadAlignedVector512(address); /// - /// __m512i _mm512_load_si512 (__m512i const * mem_addr) - /// VMOVDQA32 zmm1 {k1}{z}, m512 + /// __m512i _mm512_load_si512 (__m512i const * mem_addr) + /// VMOVDQA32 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadAlignedVector512(ushort* address) => LoadAlignedVector512(address); /// - /// __m512i _mm512_load_epi32 (__m512i const * mem_addr) - /// VMOVDQA32 zmm1 {k1}{z}, m512 + /// __m512i _mm512_load_epi32 (__m512i const * mem_addr) + /// VMOVDQA32 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadAlignedVector512(int* address) => LoadAlignedVector512(address); /// - /// __m512i _mm512_load_epi32 (__m512i const * mem_addr) - /// VMOVDQA32 zmm1 {k1}{z}, m512 + /// __m512i _mm512_load_epi32 (__m512i const * mem_addr) + /// VMOVDQA32 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadAlignedVector512(uint* address) => LoadAlignedVector512(address); /// - /// __m512i _mm512_load_epi64 (__m512i const * mem_addr) - /// VMOVDQA64 zmm1 {k1}{z}, m512 + /// __m512i _mm512_load_epi64 (__m512i const * mem_addr) + /// VMOVDQA64 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadAlignedVector512(long* address) => LoadAlignedVector512(address); /// - /// __m512i _mm512_load_epi64 (__m512i const * mem_addr) - /// VMOVDQA64 zmm1 {k1}{z}, m512 + /// __m512i _mm512_load_epi64 (__m512i const * mem_addr) + /// VMOVDQA64 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadAlignedVector512(ulong* address) => LoadAlignedVector512(address); /// - /// __m512 _mm512_load_ps (float const * mem_addr) - /// VMOVAPS zmm1 {k1}{z}, m512 + /// __m512 _mm512_load_ps (float const * mem_addr) + /// VMOVAPS zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadAlignedVector512(float* address) => LoadAlignedVector512(address); /// - /// __m512d _mm512_load_pd (double const * mem_addr) - /// VMOVAPD zmm1 {k1}{z}, m512 + /// __m512d _mm512_load_pd (double const * mem_addr) + /// VMOVAPD zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadAlignedVector512(double* address) => LoadAlignedVector512(address); /// - /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) - /// VMOVNTDQA zmm1, m512 + /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) + /// VMOVNTDQA zmm1, m512 /// public static unsafe Vector512 LoadAlignedVector512NonTemporal(sbyte* address) => LoadAlignedVector512NonTemporal(address); /// - /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) - /// VMOVNTDQA zmm1, m512 + /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) + /// VMOVNTDQA zmm1, m512 /// public static unsafe Vector512 LoadAlignedVector512NonTemporal(byte* address) => LoadAlignedVector512NonTemporal(address); /// - /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) - /// VMOVNTDQA zmm1, m512 + /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) + /// VMOVNTDQA zmm1, m512 /// public static unsafe Vector512 LoadAlignedVector512NonTemporal(short* address) => LoadAlignedVector512NonTemporal(address); /// - /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) - /// VMOVNTDQA zmm1, m512 + /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) + /// VMOVNTDQA zmm1, m512 /// public static unsafe Vector512 LoadAlignedVector512NonTemporal(ushort* address) => LoadAlignedVector512NonTemporal(address); /// - /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) - /// VMOVNTDQA zmm1, m512 + /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) + /// VMOVNTDQA zmm1, m512 /// public static unsafe Vector512 LoadAlignedVector512NonTemporal(int* address) => LoadAlignedVector512NonTemporal(address); /// - /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) - /// VMOVNTDQA zmm1, m512 + /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) + /// VMOVNTDQA zmm1, m512 /// public static unsafe Vector512 LoadAlignedVector512NonTemporal(uint* address) => LoadAlignedVector512NonTemporal(address); /// - /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) - /// VMOVNTDQA zmm1, m512 + /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) + /// VMOVNTDQA zmm1, m512 /// public static unsafe Vector512 LoadAlignedVector512NonTemporal(long* address) => LoadAlignedVector512NonTemporal(address); /// - /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) - /// VMOVNTDQA zmm1, m512 + /// __m512i _mm512_stream_load_si512 (__m512i const* mem_addr) + /// VMOVNTDQA zmm1, m512 /// public static unsafe Vector512 LoadAlignedVector512NonTemporal(ulong* address) => LoadAlignedVector512NonTemporal(address); /// - /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr) - /// VMOVDQU32 zmm1 {k1}{z}, m512 + /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr) + /// VMOVDQU32 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadVector512(sbyte* address) => LoadVector512(address); /// - /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr) - /// VMOVDQU32 zmm1 {k1}{z}, m512 + /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr) + /// VMOVDQU32 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadVector512(byte* address) => LoadVector512(address); /// - /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr) - /// VMOVDQU32 zmm1 {k1}{z}, m512 + /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr) + /// VMOVDQU32 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadVector512(short* address) => LoadVector512(address); /// - /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr) - /// VMOVDQU32 zmm1 {k1}{z}, m512 + /// __m512i _mm512_loadu_si512 (__m512i const * mem_addr) + /// VMOVDQU32 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadVector512(ushort* address) => LoadVector512(address); /// - /// __m512i _mm512_loadu_epi32 (__m512i const * mem_addr) - /// VMOVDQU32 zmm1 {k1}{z}, m512 + /// __m512i _mm512_loadu_epi32 (__m512i const * mem_addr) + /// VMOVDQU32 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadVector512(int* address) => LoadVector512(address); /// - /// __m512i _mm512_loadu_epi32 (__m512i const * mem_addr) - /// VMOVDQU32 zmm1 {k1}{z}, m512 + /// __m512i _mm512_loadu_epi32 (__m512i const * mem_addr) + /// VMOVDQU32 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadVector512(uint* address) => LoadVector512(address); /// - /// __m512i _mm512_loadu_epi64 (__m512i const * mem_addr) - /// VMOVDQU64 zmm1 {k1}{z}, m512 + /// __m512i _mm512_loadu_epi64 (__m512i const * mem_addr) + /// VMOVDQU64 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadVector512(long* address) => LoadVector512(address); /// - /// __m512i _mm512_loadu_epi64 (__m512i const * mem_addr) - /// VMOVDQU64 zmm1 {k1}{z}, m512 + /// __m512i _mm512_loadu_epi64 (__m512i const * mem_addr) + /// VMOVDQU64 zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadVector512(ulong* address) => LoadVector512(address); /// - /// __m512 _mm512_loadu_ps (float const * mem_addr) - /// VMOVUPS zmm1 {k1}{z}, m512 + /// __m512 _mm512_loadu_ps (float const * mem_addr) + /// VMOVUPS zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadVector512(float* address) => LoadVector512(address); /// - /// __m512d _mm512_loadu_pd (double const * mem_addr) - /// VMOVUPD zmm1 {k1}{z}, m512 + /// __m512d _mm512_loadu_pd (double const * mem_addr) + /// VMOVUPD zmm1 {k1}{z}, m512 /// public static unsafe Vector512 LoadVector512(double* address) => LoadVector512(address); /// - /// __m512i _mm512_max_epi32 (__m512i a, __m512i b) - /// VPMAXSD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_max_epi32 (__m512i a, __m512i b) + /// VPMAXSD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Max(Vector512 left, Vector512 right) => Max(left, right); /// - /// __m512i _mm512_max_epu32 (__m512i a, __m512i b) - /// VPMAXUD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_max_epu32 (__m512i a, __m512i b) + /// VPMAXUD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Max(Vector512 left, Vector512 right) => Max(left, right); /// - /// __m512i _mm512_max_epi64 (__m512i a, __m512i b) - /// VPMAXSQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_max_epi64 (__m512i a, __m512i b) + /// VPMAXSQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Max(Vector512 left, Vector512 right) => Max(left, right); /// - /// __m512i _mm512_max_epu64 (__m512i a, __m512i b) - /// VPMAXUQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_max_epu64 (__m512i a, __m512i b) + /// VPMAXUQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Max(Vector512 left, Vector512 right) => Max(left, right); /// - /// __m512 _mm512_max_ps (__m512 a, __m512 b) - /// VMAXPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae} + /// __m512 _mm512_max_ps (__m512 a, __m512 b) + /// VMAXPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae} /// public static Vector512 Max(Vector512 left, Vector512 right) => Max(left, right); /// - /// __m512d _mm512_max_pd (__m512d a, __m512d b) - /// VMAXPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae} + /// __m512d _mm512_max_pd (__m512d a, __m512d b) + /// VMAXPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae} /// public static Vector512 Max(Vector512 left, Vector512 right) => Max(left, right); /// - /// __m512i _mm512_min_epi32 (__m512i a, __m512i b) - /// VPMINSD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_min_epi32 (__m512i a, __m512i b) + /// VPMINSD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Min(Vector512 left, Vector512 right) => Min(left, right); /// - /// __m512i _mm512_min_epu32 (__m512i a, __m512i b) - /// VPMINUD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_min_epu32 (__m512i a, __m512i b) + /// VPMINUD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Min(Vector512 left, Vector512 right) => Min(left, right); /// - /// __m512i _mm512_min_epi64 (__m512i a, __m512i b) - /// VPMINSQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_min_epi64 (__m512i a, __m512i b) + /// VPMINSQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Min(Vector512 left, Vector512 right) => Min(left, right); /// - /// __m512i _mm512_min_epu64 (__m512i a, __m512i b) - /// VPMINUQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_min_epu64 (__m512i a, __m512i b) + /// VPMINUQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Min(Vector512 left, Vector512 right) => Min(left, right); /// - /// __m512 _mm512_min_ps (__m512 a, __m512 b) - /// VMINPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae} + /// __m512 _mm512_min_ps (__m512 a, __m512 b) + /// VMINPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{sae} /// public static Vector512 Min(Vector512 left, Vector512 right) => Min(left, right); /// - /// __m512d _mm512_min_pd (__m512d a, __m512d b) - /// VMINPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae} + /// __m512d _mm512_min_pd (__m512d a, __m512d b) + /// VMINPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{sae} /// public static Vector512 Min(Vector512 left, Vector512 right) => Min(left, right); /// - /// __m512i _mm512_mul_epi32 (__m512i a, __m512i b) - /// VPMULDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_mul_epi32 (__m512i a, __m512i b) + /// VPMULDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Multiply(Vector512 left, Vector512 right) => Multiply(left, right); /// - /// __m512i _mm512_mul_epu32 (__m512i a, __m512i b) - /// VPMULUDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_mul_epu32 (__m512i a, __m512i b) + /// VPMULUDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Multiply(Vector512 left, Vector512 right) => Multiply(left, right); /// - /// __m512 _mm512_mul_ps (__m512 a, __m512 b) - /// VMULPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er} + /// __m512 _mm512_mul_ps (__m512 a, __m512 b) + /// VMULPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er} /// public static Vector512 Multiply(Vector512 left, Vector512 right) => Multiply(left, right); /// - /// __m512d _mm512_mul_pd (__m512d a, __m512d b) - /// VMULPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er} + /// __m512d _mm512_mul_pd (__m512d a, __m512d b) + /// VMULPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er} /// public static Vector512 Multiply(Vector512 left, Vector512 right) => Multiply(left, right); /// - /// __m512 _mm512_mul_round_ps (__m512 a, __m512 b, int rounding) - /// VMULPS zmm1, zmm2, zmm3 {er} + /// __m512 _mm512_mul_round_ps (__m512 a, __m512 b, int rounding) + /// VMULPS zmm1, zmm2, zmm3 {er} /// public static Vector512 Multiply(Vector512 left, Vector512 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => Multiply(left, right, mode); /// - /// __m512d _mm512_mul_round_pd (__m512d a, __m512d b, int rounding) - /// VMULPD zmm1, zmm2, zmm3 {er} + /// __m512d _mm512_mul_round_pd (__m512d a, __m512d b, int rounding) + /// VMULPD zmm1, zmm2, zmm3 {er} /// public static Vector512 Multiply(Vector512 left, Vector512 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => Multiply(left, right, mode); /// - /// __m128 _mm_mul_round_ss (__m128 a, __m128 b, int rounding) - /// VMULSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_mul_round_ss (__m128 a, __m128 b, int rounding) + /// VMULSS xmm1, xmm2, xmm3 {er} /// public static Vector128 MultiplyScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => MultiplyScalar(left, right, mode); /// - /// __m128d _mm_mul_round_sd (__m128d a, __m128d b, int rounding) - /// VMULSD xmm1, xmm2, xmm3 {er} + /// __m128d _mm_mul_round_sd (__m128d a, __m128d b, int rounding) + /// VMULSD xmm1, xmm2, xmm3 {er} /// public static Vector128 MultiplyScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => MultiplyScalar(left, right, mode); /// - /// __m512i _mm512_mullo_epi32 (__m512i a, __m512i b) - /// VPMULLD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_mullo_epi32 (__m512i a, __m512i b) + /// VPMULLD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 MultiplyLow(Vector512 left, Vector512 right) => MultiplyLow(left, right); /// - /// __m512i _mm512_mullo_epi32 (__m512i a, __m512i b) - /// VPMULLD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_mullo_epi32 (__m512i a, __m512i b) + /// VPMULLD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 MultiplyLow(Vector512 left, Vector512 right) => MultiplyLow(left, right); /// - /// __m512i _mm512_or_si512 (__m512i a, __m512i b) - /// VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_or_si512 (__m512i a, __m512i b) + /// VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Or(Vector512 left, Vector512 right) => Or(left, right); /// - /// __m512i _mm512_or_si512 (__m512i a, __m512i b) - /// VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_or_si512 (__m512i a, __m512i b) + /// VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Or(Vector512 left, Vector512 right) => Or(left, right); /// - /// __m512i _mm512_or_si512 (__m512i a, __m512i b) - /// VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_or_si512 (__m512i a, __m512i b) + /// VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Or(Vector512 left, Vector512 right) => Or(left, right); /// - /// __m512i _mm512_or_si512 (__m512i a, __m512i b) - /// VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_or_si512 (__m512i a, __m512i b) + /// VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Or(Vector512 left, Vector512 right) => Or(left, right); /// - /// __m512i _mm512_or_epi32 (__m512i a, __m512i b) - /// VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_or_epi32 (__m512i a, __m512i b) + /// VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Or(Vector512 left, Vector512 right) => Or(left, right); /// - /// __m512i _mm512_or_epi32 (__m512i a, __m512i b) - /// VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_or_epi32 (__m512i a, __m512i b) + /// VPORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Or(Vector512 left, Vector512 right) => Or(left, right); /// - /// __m512i _mm512_or_epi64 (__m512i a, __m512i b) - /// VPORQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_or_epi64 (__m512i a, __m512i b) + /// VPORQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Or(Vector512 left, Vector512 right) => Or(left, right); /// - /// __m512i _mm512_or_epi64 (__m512i a, __m512i b) - /// VPORQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_or_epi64 (__m512i a, __m512i b) + /// VPORQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Or(Vector512 left, Vector512 right) => Or(left, right); /// - /// __m512d _mm512_permute_pd (__m512d a, int imm8) - /// VPERMILPD zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 + /// __m512d _mm512_permute_pd (__m512d a, int imm8) + /// VPERMILPD zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 /// public static Vector512 Permute2x64(Vector512 value, [ConstantExpected] byte control) => Permute2x64(value, control); /// - /// __m512 _mm512_permute_ps (__m512 a, int imm8) - /// VPERMILPS zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 + /// __m512 _mm512_permute_ps (__m512 a, int imm8) + /// VPERMILPS zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 /// public static Vector512 Permute4x32(Vector512 value, [ConstantExpected] byte control) => Permute4x32(value, control); /// - /// __m512i _mm512_permute4x64_epi64 (__m512i a, const int imm8) - /// VPERMQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 + /// __m512i _mm512_permute4x64_epi64 (__m512i a, const int imm8) + /// VPERMQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 /// public static Vector512 Permute4x64(Vector512 value, [ConstantExpected] byte control) => Permute4x64(value, control); /// - /// __m512i _mm512_permute4x64_epi64 (__m512i a, const int imm8) - /// VPERMQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 + /// __m512i _mm512_permute4x64_epi64 (__m512i a, const int imm8) + /// VPERMQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 /// public static Vector512 Permute4x64(Vector512 value, [ConstantExpected] byte control) => Permute4x64(value, control); /// - /// __m512d _mm512_permute4x64_pd (__m512d a, const int imm8) - /// VPERMPD zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 + /// __m512d _mm512_permute4x64_pd (__m512d a, const int imm8) + /// VPERMPD zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 /// public static Vector512 Permute4x64(Vector512 value, [ConstantExpected] byte control) => Permute4x64(value, control); /// - /// __m512d _mm512_permutevar_pd (__m512d a, __m512i b) - /// VPERMILPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_permutevar_pd (__m512d a, __m512i b) + /// VPERMILPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 PermuteVar2x64(Vector512 left, Vector512 control) => PermuteVar2x64(left, control); /// - /// __m512 _mm512_permutevar_ps (__m512 a, __m512i b) - /// VPERMILPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_permutevar_ps (__m512 a, __m512i b) + /// VPERMILPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 PermuteVar4x32(Vector512 left, Vector512 control) => PermuteVar4x32(left, control); /// - /// __m512i _mm512_permutevar8x64_epi64 (__m512i a, __m512i b) - /// VPERMQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_permutevar8x64_epi64 (__m512i a, __m512i b) + /// VPERMQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 PermuteVar8x64(Vector512 value, Vector512 control) => PermuteVar8x64(value, control); /// - /// __m512i _mm512_permutevar8x64_epi64 (__m512i a, __m512i b) - /// VPERMQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_permutevar8x64_epi64 (__m512i a, __m512i b) + /// VPERMQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 PermuteVar8x64(Vector512 value, Vector512 control) => PermuteVar8x64(value, control); /// - /// __m512d _mm512_permutevar8x64_pd (__m512d a, __m512i b) - /// VPERMPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_permutevar8x64_pd (__m512d a, __m512i b) + /// VPERMPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 PermuteVar8x64(Vector512 value, Vector512 control) => PermuteVar8x64(value, control); /// - /// __m512i _mm512_permutex2var_epi64 (__m512i a, __m512i idx, __m512i b) - /// VPERMI2Q zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst - /// VPERMT2Q zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_permutex2var_epi64 (__m512i a, __m512i idx, __m512i b) + /// VPERMI2Q zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// VPERMT2Q zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 PermuteVar8x64x2(Vector512 lower, Vector512 indices, Vector512 upper) => PermuteVar8x64x2(lower, indices, upper); /// - /// __m512i _mm512_permutex2var_epi64 (__m512i a, __m512i idx, __m512i b) - /// VPERMI2Q zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst - /// VPERMT2Q zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_permutex2var_epi64 (__m512i a, __m512i idx, __m512i b) + /// VPERMI2Q zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// VPERMT2Q zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 PermuteVar8x64x2(Vector512 lower, Vector512 indices, Vector512 upper) => PermuteVar8x64x2(lower, indices, upper); /// - /// __m512d _mm512_permutex2var_pd (__m512d a, __m512i idx, __m512i b) - /// VPERMI2PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst - /// VPERMT2PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_permutex2var_pd (__m512d a, __m512i idx, __m512i b) + /// VPERMI2PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// VPERMT2PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 PermuteVar8x64x2(Vector512 lower, Vector512 indices, Vector512 upper) => PermuteVar8x64x2(lower, indices, upper); /// - /// __m512i _mm512_permutevar16x32_epi32 (__m512i a, __m512i b) - /// VPERMD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_permutevar16x32_epi32 (__m512i a, __m512i b) + /// VPERMD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 PermuteVar16x32(Vector512 left, Vector512 control) => PermuteVar16x32(left, control); /// - /// __m512i _mm512_permutevar16x32_epi32 (__m512i a, __m512i b) - /// VPERMD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_permutevar16x32_epi32 (__m512i a, __m512i b) + /// VPERMD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 PermuteVar16x32(Vector512 left, Vector512 control) => PermuteVar16x32(left, control); /// - /// __m512 _mm512_permutevar16x32_ps (__m512 a, __m512i b) - /// VPERMPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_permutevar16x32_ps (__m512 a, __m512i b) + /// VPERMPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 PermuteVar16x32(Vector512 left, Vector512 control) => PermuteVar16x32(left, control); /// - /// __m512i _mm512_permutex2var_epi32 (__m512i a, __m512i idx, __m512i b) - /// VPERMI2D zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst - /// VPERMT2D zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_permutex2var_epi32 (__m512i a, __m512i idx, __m512i b) + /// VPERMI2D zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// VPERMT2D zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 PermuteVar16x32x2(Vector512 lower, Vector512 indices, Vector512 upper) => PermuteVar16x32x2(lower, indices, upper); /// - /// __m512i _mm512_permutex2var_epi32 (__m512i a, __m512i idx, __m512i b) - /// VPERMI2D zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst - /// VPERMT2D zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_permutex2var_epi32 (__m512i a, __m512i idx, __m512i b) + /// VPERMI2D zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// VPERMT2D zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 PermuteVar16x32x2(Vector512 lower, Vector512 indices, Vector512 upper) => PermuteVar16x32x2(lower, indices, upper); /// - /// __m512 _mm512_permutex2var_ps (__m512 a, __m512i idx, __m512i b) - /// VPERMI2PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst - /// VPERMT2PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_permutex2var_ps (__m512 a, __m512i idx, __m512i b) + /// VPERMI2PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// VPERMT2PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 PermuteVar16x32x2(Vector512 lower, Vector512 indices, Vector512 upper) => PermuteVar16x32x2(lower, indices, upper); /// - /// __m512 _mm512_rcp14_ps (__m512 a, __m512 b) - /// VRCP14PS zmm1 {k1}{z}, zmm2/m512/m32bcst + /// __m512 _mm512_rcp14_ps (__m512 a, __m512 b) + /// VRCP14PS zmm1 {k1}{z}, zmm2/m512/m32bcst /// public static Vector512 Reciprocal14(Vector512 value) => Reciprocal14(value); /// - /// __m512d _mm512_rcp14_pd (__m512d a, __m512d b) - /// VRCP14PD zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512d _mm512_rcp14_pd (__m512d a, __m512d b) + /// VRCP14PD zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 Reciprocal14(Vector512 value) => Reciprocal14(value); /// - /// __m128 _mm_rcp14_ss (__m128 a) - /// VRCP14SS xmm1 {k1}{z}, xmm2, xmm3/m32 + /// __m128 _mm_rcp14_ss (__m128 a) + /// VRCP14SS xmm1 {k1}{z}, xmm2, xmm3/m32 /// public static Vector128 Reciprocal14Scalar(Vector128 value) => Reciprocal14Scalar(value); /// - /// __m128d _mm_rcp14_sd (__m128d a) - /// VRCP14SD xmm1 {k1}{z}, xmm2, xmm3/m64 + /// __m128d _mm_rcp14_sd (__m128d a) + /// VRCP14SD xmm1 {k1}{z}, xmm2, xmm3/m64 /// public static Vector128 Reciprocal14Scalar(Vector128 value) => Reciprocal14Scalar(value); /// - /// __m128 _mm_rcp14_ss (__m128 a, __m128 b) - /// VRCP14SS xmm1 {k1}{z}, xmm2, xmm3/m32 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_rcp14_ss (__m128 a, __m128 b) + /// VRCP14SS xmm1 {k1}{z}, xmm2, xmm3/m32 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 Reciprocal14Scalar(Vector128 upper, Vector128 value) => Reciprocal14Scalar(upper, value); /// - /// __m128d _mm_rcp14_sd (__m128d a, __m128d b) - /// VRCP14SD xmm1 {k1}{z}, xmm2, xmm3/m64 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128d _mm_rcp14_sd (__m128d a, __m128d b) + /// VRCP14SD xmm1 {k1}{z}, xmm2, xmm3/m64 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 Reciprocal14Scalar(Vector128 upper, Vector128 value) => Reciprocal14Scalar(upper, value); /// - /// __m512 _mm512_rsqrt14_ps (__m512 a, __m512 b) - /// VRSQRT14PS zmm1 {k1}{z}, zmm2/m512/m32bcst + /// __m512 _mm512_rsqrt14_ps (__m512 a, __m512 b) + /// VRSQRT14PS zmm1 {k1}{z}, zmm2/m512/m32bcst /// public static Vector512 ReciprocalSqrt14(Vector512 value) => ReciprocalSqrt14(value); /// - /// __m512d _mm512_rsqrt14_pd (__m512d a, __m512d b) - /// VRSQRT14PD zmm1 {k1}{z}, zmm2/m512/m64bcst + /// __m512d _mm512_rsqrt14_pd (__m512d a, __m512d b) + /// VRSQRT14PD zmm1 {k1}{z}, zmm2/m512/m64bcst /// public static Vector512 ReciprocalSqrt14(Vector512 value) => ReciprocalSqrt14(value); /// - /// __m128 _mm_rsqrt14_ss (__m128 a) - /// VRSQRT14SS xmm1 {k1}{z}, xmm2, xmm3/m32 + /// __m128 _mm_rsqrt14_ss (__m128 a) + /// VRSQRT14SS xmm1 {k1}{z}, xmm2, xmm3/m32 /// public static Vector128 ReciprocalSqrt14Scalar(Vector128 value) => ReciprocalSqrt14Scalar(value); /// - /// __m128d _mm_rsqrt14_sd (__m128d a) - /// VRSQRT14SD xmm1 {k1}{z}, xmm2, xmm3/m64 + /// __m128d _mm_rsqrt14_sd (__m128d a) + /// VRSQRT14SD xmm1 {k1}{z}, xmm2, xmm3/m64 /// public static Vector128 ReciprocalSqrt14Scalar(Vector128 value) => ReciprocalSqrt14Scalar(value); /// - /// __m128 _mm_rsqrt14_ss (__m128 a, __m128 b) - /// VRSQRT14SS xmm1 {k1}{z}, xmm2, xmm3/m32 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_rsqrt14_ss (__m128 a, __m128 b) + /// VRSQRT14SS xmm1 {k1}{z}, xmm2, xmm3/m32 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 ReciprocalSqrt14Scalar(Vector128 upper, Vector128 value) => ReciprocalSqrt14Scalar(upper, value); /// - /// __m128d _mm_rsqrt14_sd (__m128d a, __m128d b) - /// VRSQRT14SD xmm1 {k1}{z}, xmm2, xmm3/m64 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128d _mm_rsqrt14_sd (__m128d a, __m128d b) + /// VRSQRT14SD xmm1 {k1}{z}, xmm2, xmm3/m64 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 ReciprocalSqrt14Scalar(Vector128 upper, Vector128 value) => ReciprocalSqrt14Scalar(upper, value); /// - /// __m512i _mm512_rol_epi32 (__m512i a, int imm8) - /// VPROLD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 + /// __m512i _mm512_rol_epi32 (__m512i a, int imm8) + /// VPROLD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 /// public static Vector512 RotateLeft(Vector512 value, [ConstantExpected] byte count) => RotateLeft(value, count); /// - /// __m512i _mm512_rol_epi32 (__m512i a, int imm8) - /// VPROLD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 + /// __m512i _mm512_rol_epi32 (__m512i a, int imm8) + /// VPROLD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 /// public static Vector512 RotateLeft(Vector512 value, [ConstantExpected] byte count) => RotateLeft(value, count); /// - /// __m512i _mm512_rol_epi64 (__m512i a, int imm8) - /// VPROLQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 + /// __m512i _mm512_rol_epi64 (__m512i a, int imm8) + /// VPROLQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 /// public static Vector512 RotateLeft(Vector512 value, [ConstantExpected] byte count) => RotateLeft(value, count); /// - /// __m512i _mm512_rol_epi64 (__m512i a, int imm8) - /// VPROLQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 + /// __m512i _mm512_rol_epi64 (__m512i a, int imm8) + /// VPROLQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 /// public static Vector512 RotateLeft(Vector512 value, [ConstantExpected] byte count) => RotateLeft(value, count); /// - /// __m512i _mm512_rolv_epi32 (__m512i a, __m512i b) - /// VPROLDV zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_rolv_epi32 (__m512i a, __m512i b) + /// VPROLDV zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 RotateLeftVariable(Vector512 value, Vector512 count) => RotateLeftVariable(value, count); /// - /// __m512i _mm512_rolv_epi32 (__m512i a, __m512i b) - /// VPROLDV zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_rolv_epi32 (__m512i a, __m512i b) + /// VPROLDV zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 RotateLeftVariable(Vector512 value, Vector512 count) => RotateLeftVariable(value, count); /// - /// __m512i _mm512_rolv_epi64 (__m512i a, __m512i b) - /// VPROLQV zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_rolv_epi64 (__m512i a, __m512i b) + /// VPROLQV zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 RotateLeftVariable(Vector512 value, Vector512 count) => RotateLeftVariable(value, count); /// - /// __m512i _mm512_rolv_epi64 (__m512i a, __m512i b) - /// VPROLQV zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_rolv_epi64 (__m512i a, __m512i b) + /// VPROLQV zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 RotateLeftVariable(Vector512 value, Vector512 count) => RotateLeftVariable(value, count); /// - /// __m512i _mm512_ror_epi32 (__m512i a, int imm8) - /// VPRORD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 + /// __m512i _mm512_ror_epi32 (__m512i a, int imm8) + /// VPRORD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 /// public static Vector512 RotateRight(Vector512 value, [ConstantExpected] byte count) => RotateRight(value, count); /// - /// __m512i _mm512_ror_epi32 (__m512i a, int imm8) - /// VPRORD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 + /// __m512i _mm512_ror_epi32 (__m512i a, int imm8) + /// VPRORD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 /// public static Vector512 RotateRight(Vector512 value, [ConstantExpected] byte count) => RotateRight(value, count); /// - /// __m512i _mm512_ror_epi64 (__m512i a, int imm8) - /// VPRORQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 + /// __m512i _mm512_ror_epi64 (__m512i a, int imm8) + /// VPRORQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 /// public static Vector512 RotateRight(Vector512 value, [ConstantExpected] byte count) => RotateRight(value, count); /// - /// __m512i _mm512_ror_epi64 (__m512i a, int imm8) - /// VPRORQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 + /// __m512i _mm512_ror_epi64 (__m512i a, int imm8) + /// VPRORQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8 /// public static Vector512 RotateRight(Vector512 value, [ConstantExpected] byte count) => RotateRight(value, count); /// - /// __m512i _mm512_rorv_epi32 (__m512i a, __m512i b) - /// VPRORDV zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_rorv_epi32 (__m512i a, __m512i b) + /// VPRORDV zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 RotateRightVariable(Vector512 value, Vector512 count) => RotateRightVariable(value, count); /// - /// __m512i _mm512_rorv_epi32 (__m512i a, __m512i b) - /// VPRORDV zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_rorv_epi32 (__m512i a, __m512i b) + /// VPRORDV zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 RotateRightVariable(Vector512 value, Vector512 count) => RotateRightVariable(value, count); /// - /// __m512i _mm512_rorv_epi64 (__m512i a, __m512i b) - /// VPRORQV zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_rorv_epi64 (__m512i a, __m512i b) + /// VPRORQV zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 RotateRightVariable(Vector512 value, Vector512 count) => RotateRightVariable(value, count); /// - /// __m512i _mm512_rorv_epi64 (__m512i a, __m512i b) - /// VPRORQV zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_rorv_epi64 (__m512i a, __m512i b) + /// VPRORQV zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 RotateRightVariable(Vector512 value, Vector512 count) => RotateRightVariable(value, count); /// - /// __m512 _mm512_roundscale_ps (__m512 a, int imm) - /// VRNDSCALEPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}, imm8 + /// __m512 _mm512_roundscale_ps (__m512 a, int imm) + /// VRNDSCALEPS zmm1 {k1}{z}, zmm2/m512/m32bcst{sae}, imm8 /// public static Vector512 RoundScale(Vector512 value, [ConstantExpected] byte control) => RoundScale(value, control); /// - /// __m512d _mm512_roundscale_pd (__m512d a, int imm) - /// VRNDSCALEPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}, imm8 + /// __m512d _mm512_roundscale_pd (__m512d a, int imm) + /// VRNDSCALEPD zmm1 {k1}{z}, zmm2/m512/m64bcst{sae}, imm8 /// public static Vector512 RoundScale(Vector512 value, [ConstantExpected] byte control) => RoundScale(value, control); /// - /// __m128 _mm_roundscale_ss (__m128 a, int imm) - /// VRNDSCALESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 + /// __m128 _mm_roundscale_ss (__m128 a, int imm) + /// VRNDSCALESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 /// public static Vector128 RoundScaleScalar(Vector128 value, [ConstantExpected] byte control) => RoundScaleScalar(value, control); /// - /// __m128d _mm_roundscale_sd (__m128d a, int imm) - /// VRNDSCALESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 + /// __m128d _mm_roundscale_sd (__m128d a, int imm) + /// VRNDSCALESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 /// public static Vector128 RoundScaleScalar(Vector128 value, [ConstantExpected] byte control) => RoundScaleScalar(value, control); /// - /// __m128 _mm_roundscale_ss (__m128 a, __m128 b, int imm) - /// VRNDSCALESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_roundscale_ss (__m128 a, __m128 b, int imm) + /// VRNDSCALESS xmm1 {k1}{z}, xmm2, xmm3/m32{sae}, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 RoundScaleScalar(Vector128 upper, Vector128 value, [ConstantExpected] byte control) => RoundScaleScalar(upper, value, control); /// - /// __m128d _mm_roundscale_sd (__m128d a, __m128d b, int imm) - /// VRNDSCALESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128d _mm_roundscale_sd (__m128d a, __m128d b, int imm) + /// VRNDSCALESD xmm1 {k1}{z}, xmm2, xmm3/m64{sae}, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 RoundScaleScalar(Vector128 upper, Vector128 value, [ConstantExpected] byte control) => RoundScaleScalar(upper, value, control); /// - /// __m512 _mm512_scalef_ps (__m512 a, __m512 b) - /// VSCALEFPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er} + /// __m512 _mm512_scalef_ps (__m512 a, __m512 b) + /// VSCALEFPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er} /// public static Vector512 Scale(Vector512 left, Vector512 right) => Scale(left, right); /// - /// __m512d _mm512_scalef_pd (__m512d a, __m512d b) - /// VSCALEFPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er} + /// __m512d _mm512_scalef_pd (__m512d a, __m512d b) + /// VSCALEFPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er} /// public static Vector512 Scale(Vector512 left, Vector512 right) => Scale(left, right); /// - /// __m512 _mm512_scalef_round_ps (__m512 a, __m512 b, int rounding) - /// VSCALEFPS zmm1, zmm2, zmm3 {er} + /// __m512 _mm512_scalef_round_ps (__m512 a, __m512 b, int rounding) + /// VSCALEFPS zmm1, zmm2, zmm3 {er} /// public static Vector512 Scale(Vector512 left, Vector512 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => Scale(left, right, mode); /// - /// __m512d _mm512_scalef_round_pd (__m512d a, __m512d b, int rounding) - /// VSCALEFPD zmm1, zmm2, zmm3 {er} + /// __m512d _mm512_scalef_round_pd (__m512d a, __m512d b, int rounding) + /// VSCALEFPD zmm1, zmm2, zmm3 {er} /// public static Vector512 Scale(Vector512 left, Vector512 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => Scale(left, right, mode); /// - /// __m128 _mm_scalef_ss (__m128 a, __m128 b) - /// VSCALEFSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} + /// __m128 _mm_scalef_ss (__m128 a, __m128 b) + /// VSCALEFSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} /// public static Vector128 ScaleScalar(Vector128 left, Vector128 right) => ScaleScalar(left, right); /// - /// __m128d _mm_scalef_sd (__m128d a, __m128d b) - /// VSCALEFSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} + /// __m128d _mm_scalef_sd (__m128d a, __m128d b) + /// VSCALEFSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} /// public static Vector128 ScaleScalar(Vector128 left, Vector128 right) => ScaleScalar(left, right); /// - /// __m128 _mm_scalef_round_ss (__m128 a, __m128 b) - /// VSCALEFSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_scalef_round_ss (__m128 a, __m128 b) + /// VSCALEFSS xmm1, xmm2, xmm3 {er} /// public static Vector128 ScaleScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ScaleScalar(left, right, mode); /// - /// __m128d _mm_scalef_round_sd (__m128d a, __m128d b) - /// VSCALEFSD xmm1, xmm2, xmm3 {er} + /// __m128d _mm_scalef_round_sd (__m128d a, __m128d b) + /// VSCALEFSD xmm1, xmm2, xmm3 {er} /// public static Vector128 ScaleScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => ScaleScalar(left, right, mode); /// - /// __m512i _mm512_sll_epi32 (__m512i a, __m128i count) - /// VPSLLD zmm1 {k1}{z}, zmm2, xmm3/m128 + /// __m512i _mm512_sll_epi32 (__m512i a, __m128i count) + /// VPSLLD zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftLeftLogical(Vector512 value, Vector128 count) => ShiftLeftLogical(value, count); /// - /// __m512i _mm512_sll_epi32 (__m512i a, __m128i count) - /// VPSLLD zmm1 {k1}{z}, zmm2, xmm3/m128 + /// __m512i _mm512_sll_epi32 (__m512i a, __m128i count) + /// VPSLLD zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftLeftLogical(Vector512 value, Vector128 count) => ShiftLeftLogical(value, count); /// - /// __m512i _mm512_sll_epi64 (__m512i a, __m128i count) - /// VPSLLQ zmm1 {k1}{z}, zmm2, xmm3/m128 + /// __m512i _mm512_sll_epi64 (__m512i a, __m128i count) + /// VPSLLQ zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftLeftLogical(Vector512 value, Vector128 count) => ShiftLeftLogical(value, count); /// - /// __m512i _mm512_sll_epi64 (__m512i a, __m128i count) - /// VPSLLQ zmm1 {k1}{z}, zmm2, xmm3/m128 + /// __m512i _mm512_sll_epi64 (__m512i a, __m128i count) + /// VPSLLQ zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftLeftLogical(Vector512 value, Vector128 count) => ShiftLeftLogical(value, count); /// - /// __m512i _mm512_slli_epi32 (__m512i a, int imm8) - /// VPSLLD zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_slli_epi32 (__m512i a, int imm8) + /// VPSLLD zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftLeftLogical(Vector512 value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); /// - /// __m512i _mm512_slli_epi32 (__m512i a, int imm8) - /// VPSLLD zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_slli_epi32 (__m512i a, int imm8) + /// VPSLLD zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftLeftLogical(Vector512 value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); /// - /// __m512i _mm512_slli_epi64 (__m512i a, int imm8) - /// VPSLLQ zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_slli_epi64 (__m512i a, int imm8) + /// VPSLLQ zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftLeftLogical(Vector512 value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); /// - /// __m512i _mm512_slli_epi64 (__m512i a, int imm8) - /// VPSLLQ zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_slli_epi64 (__m512i a, int imm8) + /// VPSLLQ zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftLeftLogical(Vector512 value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); /// - /// __m512i _mm512_sllv_epi32 (__m512i a, __m512i count) - /// VPSLLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_sllv_epi32 (__m512i a, __m512i count) + /// VPSLLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 ShiftLeftLogicalVariable(Vector512 value, Vector512 count) => ShiftLeftLogicalVariable(value, count); /// - /// __m512i _mm512_sllv_epi32 (__m512i a, __m512i count) - /// VPSLLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_sllv_epi32 (__m512i a, __m512i count) + /// VPSLLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 ShiftLeftLogicalVariable(Vector512 value, Vector512 count) => ShiftLeftLogicalVariable(value, count); /// - /// __m512i _mm512_sllv_epi64 (__m512i a, __m512i count) - /// VPSLLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_sllv_epi64 (__m512i a, __m512i count) + /// VPSLLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 ShiftLeftLogicalVariable(Vector512 value, Vector512 count) => ShiftLeftLogicalVariable(value, count); /// - /// __m512i _mm512_sllv_epi64 (__m512i a, __m512i count) - /// VPSLLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_sllv_epi64 (__m512i a, __m512i count) + /// VPSLLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 ShiftLeftLogicalVariable(Vector512 value, Vector512 count) => ShiftLeftLogicalVariable(value, count); /// - /// _mm512_sra_epi32 (__m512i a, __m128i count) - /// VPSRAD zmm1 {k1}{z}, zmm2, xmm3/m128 + /// _mm512_sra_epi32 (__m512i a, __m128i count) + /// VPSRAD zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftRightArithmetic(Vector512 value, Vector128 count) => ShiftRightArithmetic(value, count); /// - /// _mm512_sra_epi64 (__m512i a, __m128i count) - /// VPSRAQ zmm1 {k1}{z}, zmm2, xmm3/m128 + /// _mm512_sra_epi64 (__m512i a, __m128i count) + /// VPSRAQ zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftRightArithmetic(Vector512 value, Vector128 count) => ShiftRightArithmetic(value, count); /// - /// __m512i _mm512_srai_epi32 (__m512i a, int imm8) - /// VPSRAD zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_srai_epi32 (__m512i a, int imm8) + /// VPSRAD zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftRightArithmetic(Vector512 value, [ConstantExpected] byte count) => ShiftRightArithmetic(value, count); /// - /// __m512i _mm512_srai_epi64 (__m512i a, int imm8) - /// VPSRAQ zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_srai_epi64 (__m512i a, int imm8) + /// VPSRAQ zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftRightArithmetic(Vector512 value, [ConstantExpected] byte count) => ShiftRightArithmetic(value, count); /// - /// __m512i _mm512_srav_epi32 (__m512i a, __m512i count) - /// VPSRAVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_srav_epi32 (__m512i a, __m512i count) + /// VPSRAVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 ShiftRightArithmeticVariable(Vector512 value, Vector512 count) => ShiftRightArithmeticVariable(value, count); /// - /// __m512i _mm512_srav_epi64 (__m512i a, __m512i count) - /// VPSRAVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_srav_epi64 (__m512i a, __m512i count) + /// VPSRAVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 ShiftRightArithmeticVariable(Vector512 value, Vector512 count) => ShiftRightArithmeticVariable(value, count); /// - /// __m512i _mm512_srl_epi32 (__m512i a, __m128i count) - /// VPSRLD zmm1 {k1}{z}, zmm2, xmm3/m128 + /// __m512i _mm512_srl_epi32 (__m512i a, __m128i count) + /// VPSRLD zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftRightLogical(Vector512 value, Vector128 count) => ShiftRightLogical(value, count); /// - /// __m512i _mm512_srl_epi32 (__m512i a, __m128i count) - /// VPSRLD zmm1 {k1}{z}, zmm2, xmm3/m128 + /// __m512i _mm512_srl_epi32 (__m512i a, __m128i count) + /// VPSRLD zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftRightLogical(Vector512 value, Vector128 count) => ShiftRightLogical(value, count); /// - /// __m512i _mm512_srl_epi64 (__m512i a, __m128i count) - /// VPSRLQ zmm1 {k1}{z}, zmm2, xmm3/m128 + /// __m512i _mm512_srl_epi64 (__m512i a, __m128i count) + /// VPSRLQ zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftRightLogical(Vector512 value, Vector128 count) => ShiftRightLogical(value, count); /// - /// __m512i _mm512_srl_epi64 (__m512i a, __m128i count) - /// VPSRLQ zmm1 {k1}{z}, zmm2, xmm3/m128 + /// __m512i _mm512_srl_epi64 (__m512i a, __m128i count) + /// VPSRLQ zmm1 {k1}{z}, zmm2, xmm3/m128 /// public static Vector512 ShiftRightLogical(Vector512 value, Vector128 count) => ShiftRightLogical(value, count); /// - /// __m512i _mm512_srli_epi32 (__m512i a, int imm8) - /// VPSRLD zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_srli_epi32 (__m512i a, int imm8) + /// VPSRLD zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftRightLogical(Vector512 value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); /// - /// __m512i _mm512_srli_epi32 (__m512i a, int imm8) - /// VPSRLD zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_srli_epi32 (__m512i a, int imm8) + /// VPSRLD zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftRightLogical(Vector512 value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); /// - /// __m512i _mm512_srli_epi64 (__m512i a, int imm8) - /// VPSRLQ zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_srli_epi64 (__m512i a, int imm8) + /// VPSRLQ zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftRightLogical(Vector512 value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); /// - /// __m512i _mm512_srli_epi64 (__m512i a, int imm8) - /// VPSRLQ zmm1 {k1}{z}, zmm2, imm8 + /// __m512i _mm512_srli_epi64 (__m512i a, int imm8) + /// VPSRLQ zmm1 {k1}{z}, zmm2, imm8 /// public static Vector512 ShiftRightLogical(Vector512 value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); /// - /// __m512i _mm512_srlv_epi32 (__m512i a, __m512i count) - /// VPSRLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_srlv_epi32 (__m512i a, __m512i count) + /// VPSRLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 ShiftRightLogicalVariable(Vector512 value, Vector512 count) => ShiftRightLogicalVariable(value, count); /// - /// __m512i _mm512_srlv_epi32 (__m512i a, __m512i count) - /// VPSRLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_srlv_epi32 (__m512i a, __m512i count) + /// VPSRLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 ShiftRightLogicalVariable(Vector512 value, Vector512 count) => ShiftRightLogicalVariable(value, count); /// - /// __m512i _mm512_srlv_epi64 (__m512i a, __m512i count) - /// VPSRLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_srlv_epi64 (__m512i a, __m512i count) + /// VPSRLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 ShiftRightLogicalVariable(Vector512 value, Vector512 count) => ShiftRightLogicalVariable(value, count); /// - /// __m512i _mm512_srlv_epi64 (__m512i a, __m512i count) - /// VPSRLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_srlv_epi64 (__m512i a, __m512i count) + /// VPSRLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 ShiftRightLogicalVariable(Vector512 value, Vector512 count) => ShiftRightLogicalVariable(value, count); /// - /// __m512i _mm512_shuffle_epi32 (__m512i a, const int imm8) - /// VPSHUFD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 + /// __m512i _mm512_shuffle_epi32 (__m512i a, const int imm8) + /// VPSHUFD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 /// public static Vector512 Shuffle(Vector512 value, [ConstantExpected] byte control) => Shuffle(value, control); /// - /// __m512i _mm512_shuffle_epi32 (__m512i a, const int imm8) - /// VPSHUFD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 + /// __m512i _mm512_shuffle_epi32 (__m512i a, const int imm8) + /// VPSHUFD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8 /// public static Vector512 Shuffle(Vector512 value, [ConstantExpected] byte control) => Shuffle(value, control); /// - /// __m512 _mm512_shuffle_ps (__m512 a, __m512 b, const int imm8) - /// VSHUFPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 + /// __m512 _mm512_shuffle_ps (__m512 a, __m512 b, const int imm8) + /// VSHUFPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 /// public static Vector512 Shuffle(Vector512 value, Vector512 right, [ConstantExpected] byte control) => Shuffle(value, right, control); /// - /// __m512d _mm512_shuffle_pd (__m512d a, __m512d b, const int imm8) - /// VSHUFPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 + /// __m512d _mm512_shuffle_pd (__m512d a, __m512d b, const int imm8) + /// VSHUFPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 /// public static Vector512 Shuffle(Vector512 value, Vector512 right, [ConstantExpected] byte control) => Shuffle(value, right, control); /// - /// __m512d _mm512_shuffle_f64x2 (__m512d a, __m512d b, const int imm8) - /// VSHUFF64x2 zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 + /// __m512d _mm512_shuffle_f64x2 (__m512d a, __m512d b, const int imm8) + /// VSHUFF64x2 zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 /// public static Vector512 Shuffle4x128(Vector512 left, Vector512 right, [ConstantExpected] byte control) => Shuffle4x128(left, right, control); /// - /// __m512i _mm512_shuffle_i32x4 (__m512i a, __m512i b, const int imm8) - /// VSHUFI32x4 zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 + /// __m512i _mm512_shuffle_i32x4 (__m512i a, __m512i b, const int imm8) + /// VSHUFI32x4 zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 /// public static Vector512 Shuffle4x128(Vector512 left, Vector512 right, [ConstantExpected] byte control) => Shuffle4x128(left, right, control); /// - /// __m512i _mm512_shuffle_i64x2 (__m512i a, __m512i b, const int imm8) - /// VSHUFI64x2 zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 + /// __m512i _mm512_shuffle_i64x2 (__m512i a, __m512i b, const int imm8) + /// VSHUFI64x2 zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 /// public static Vector512 Shuffle4x128(Vector512 left, Vector512 right, [ConstantExpected] byte control) => Shuffle4x128(left, right, control); /// - /// __m512 _mm512_shuffle_f32x4 (__m512 a, __m512 b, const int imm8) - /// VSHUFF32x4 zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 + /// __m512 _mm512_shuffle_f32x4 (__m512 a, __m512 b, const int imm8) + /// VSHUFF32x4 zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 /// public static Vector512 Shuffle4x128(Vector512 left, Vector512 right, [ConstantExpected] byte control) => Shuffle4x128(left, right, control); /// - /// __m512i _mm512_shuffle_i32x4 (__m512i a, __m512i b, const int imm8) - /// VSHUFI32x4 zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 + /// __m512i _mm512_shuffle_i32x4 (__m512i a, __m512i b, const int imm8) + /// VSHUFI32x4 zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 /// public static Vector512 Shuffle4x128(Vector512 left, Vector512 right, [ConstantExpected] byte control) => Shuffle4x128(left, right, control); /// - /// __m512i _mm512_shuffle_i64x2 (__m512i a, __m512i b, const int imm8) - /// VSHUFI64x2 zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 + /// __m512i _mm512_shuffle_i64x2 (__m512i a, __m512i b, const int imm8) + /// VSHUFI64x2 zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 /// public static Vector512 Shuffle4x128(Vector512 left, Vector512 right, [ConstantExpected] byte control) => Shuffle4x128(left, right, control); /// - /// __m512 _mm512_sqrt_ps (__m512 a) - /// VSQRTPS zmm1 {k1}{z}, zmm2/m512/m32bcst{er} + /// __m512 _mm512_sqrt_ps (__m512 a) + /// VSQRTPS zmm1 {k1}{z}, zmm2/m512/m32bcst{er} /// public static Vector512 Sqrt(Vector512 value) => Sqrt(value); /// - /// __m512d _mm512_sqrt_pd (__m512d a) - /// VSQRTPD zmm1 {k1}{z}, zmm2/m512/m64bcst{er} + /// __m512d _mm512_sqrt_pd (__m512d a) + /// VSQRTPD zmm1 {k1}{z}, zmm2/m512/m64bcst{er} /// public static Vector512 Sqrt(Vector512 value) => Sqrt(value); /// - /// __m512 _mm512_sqrt_round_ps (__m512 a, int rounding) - /// VSQRTPS zmm1, zmm2 {er} + /// __m512 _mm512_sqrt_round_ps (__m512 a, int rounding) + /// VSQRTPS zmm1, zmm2 {er} /// public static Vector512 Sqrt(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => Sqrt(value, mode); /// - /// __m512d _mm512_sqrt_round_pd (__m512d a, int rounding) - /// VSQRTPD zmm1, zmm2 {er} + /// __m512d _mm512_sqrt_round_pd (__m512d a, int rounding) + /// VSQRTPD zmm1, zmm2 {er} /// public static Vector512 Sqrt(Vector512 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => Sqrt(value, mode); /// - /// __m128 _mm_sqrt_round_ss (__m128 a, __m128 b, int rounding) - /// VSQRTSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_sqrt_round_ss (__m128 a, __m128 b, int rounding) + /// VSQRTSS xmm1, xmm2, xmm3 {er} /// public static Vector128 SqrtScalar(Vector128 upper, Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => SqrtScalar(upper, value, mode); /// - /// __m128d _mm_sqrt_round_sd (__m128d a, __m128d b, int rounding) - /// VSQRTSD xmm1, xmm2 xmm3 {er} + /// __m128d _mm_sqrt_round_sd (__m128d a, __m128d b, int rounding) + /// VSQRTSD xmm1, xmm2 xmm3 {er} /// public static Vector128 SqrtScalar(Vector128 upper, Vector128 value, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => SqrtScalar(upper, value, mode); /// - /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a) - /// VMOVDQU32 m512 {k1}{z}, zmm1 + /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a) + /// VMOVDQU32 m512 {k1}{z}, zmm1 /// public static unsafe void Store(sbyte* address, Vector512 source) => Store(address, source); /// - /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a) - /// VMOVDQU32 m512 {k1}{z}, zmm1 + /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a) + /// VMOVDQU32 m512 {k1}{z}, zmm1 /// public static unsafe void Store(byte* address, Vector512 source) => Store(address, source); /// - /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a) - /// VMOVDQU32 m512 {k1}{z}, zmm1 + /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a) + /// VMOVDQU32 m512 {k1}{z}, zmm1 /// public static unsafe void Store(short* address, Vector512 source) => Store(address, source); /// - /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a) - /// VMOVDQU32 m512 {k1}{z}, zmm1 + /// void _mm512_storeu_si512 (__m512i * mem_addr, __m512i a) + /// VMOVDQU32 m512 {k1}{z}, zmm1 /// public static unsafe void Store(ushort* address, Vector512 source) => Store(address, source); /// - /// void _mm512_storeu_epi32 (__m512i * mem_addr, __m512i a) - /// VMOVDQU32 m512 {k1}{z}, zmm1 + /// void _mm512_storeu_epi32 (__m512i * mem_addr, __m512i a) + /// VMOVDQU32 m512 {k1}{z}, zmm1 /// public static unsafe void Store(int* address, Vector512 source) => Store(address, source); /// - /// void _mm512_storeu_epi32 (__m512i * mem_addr, __m512i a) - /// VMOVDQU32 m512 {k1}{z}, zmm1 + /// void _mm512_storeu_epi32 (__m512i * mem_addr, __m512i a) + /// VMOVDQU32 m512 {k1}{z}, zmm1 /// public static unsafe void Store(uint* address, Vector512 source) => Store(address, source); /// - /// void _mm512_storeu_epi64 (__m512i * mem_addr, __m512i a) - /// VMOVDQU64 m512 {k1}{z}, zmm1 + /// void _mm512_storeu_epi64 (__m512i * mem_addr, __m512i a) + /// VMOVDQU64 m512 {k1}{z}, zmm1 /// public static unsafe void Store(long* address, Vector512 source) => Store(address, source); /// - /// void _mm512_storeu_epi64 (__m512i * mem_addr, __m512i a) - /// VMOVDQU64 m512 {k1}{z}, zmm1 + /// void _mm512_storeu_epi64 (__m512i * mem_addr, __m512i a) + /// VMOVDQU64 m512 {k1}{z}, zmm1 /// public static unsafe void Store(ulong* address, Vector512 source) => Store(address, source); /// - /// void _mm512_storeu_ps (float * mem_addr, __m512 a) - /// VMOVUPS m512 {k1}{z}, zmm1 + /// void _mm512_storeu_ps (float * mem_addr, __m512 a) + /// VMOVUPS m512 {k1}{z}, zmm1 /// public static unsafe void Store(float* address, Vector512 source) => Store(address, source); /// - /// void _mm512_storeu_pd (double * mem_addr, __m512d a) - /// VMOVUPD m512 {k1}{z}, zmm1 + /// void _mm512_storeu_pd (double * mem_addr, __m512d a) + /// VMOVUPD m512 {k1}{z}, zmm1 /// public static unsafe void Store(double* address, Vector512 source) => Store(address, source); /// - /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a) - /// VMOVDQA32 m512 {k1}{z}, zmm1 + /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a) + /// VMOVDQA32 m512 {k1}{z}, zmm1 /// public static unsafe void StoreAligned(byte* address, Vector512 source) => StoreAligned(address, source); /// - /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a) - /// VMOVDQA32 m512 {k1}{z}, zmm1 + /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a) + /// VMOVDQA32 m512 {k1}{z}, zmm1 /// public static unsafe void StoreAligned(sbyte* address, Vector512 source) => StoreAligned(address, source); /// - /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a) - /// VMOVDQA32 m512 {k1}{z}, zmm1 + /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a) + /// VMOVDQA32 m512 {k1}{z}, zmm1 /// public static unsafe void StoreAligned(short* address, Vector512 source) => StoreAligned(address, source); /// - /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a) - /// VMOVDQA32 m512 {k1}{z}, zmm1 + /// void _mm512_store_si512 (__m512i * mem_addr, __m512i a) + /// VMOVDQA32 m512 {k1}{z}, zmm1 /// public static unsafe void StoreAligned(ushort* address, Vector512 source) => StoreAligned(address, source); /// - /// void _mm512_store_epi32 (__m512i * mem_addr, __m512i a) - /// VMOVDQA32 m512 {k1}{z}, zmm1 + /// void _mm512_store_epi32 (__m512i * mem_addr, __m512i a) + /// VMOVDQA32 m512 {k1}{z}, zmm1 /// public static unsafe void StoreAligned(int* address, Vector512 source) => StoreAligned(address, source); /// - /// void _mm512_store_epi32 (__m512i * mem_addr, __m512i a) - /// VMOVDQA32 m512 {k1}{z}, zmm1 + /// void _mm512_store_epi32 (__m512i * mem_addr, __m512i a) + /// VMOVDQA32 m512 {k1}{z}, zmm1 /// public static unsafe void StoreAligned(uint* address, Vector512 source) => StoreAligned(address, source); /// - /// void _mm512_store_epi64 (__m512i * mem_addr, __m512i a) - /// VMOVDQA32 m512 {k1}{z}, zmm1 + /// void _mm512_store_epi64 (__m512i * mem_addr, __m512i a) + /// VMOVDQA32 m512 {k1}{z}, zmm1 /// public static unsafe void StoreAligned(long* address, Vector512 source) => StoreAligned(address, source); /// - /// void _mm512_store_epi64 (__m512i * mem_addr, __m512i a) - /// VMOVDQA32 m512 {k1}{z}, zmm1 + /// void _mm512_store_epi64 (__m512i * mem_addr, __m512i a) + /// VMOVDQA32 m512 {k1}{z}, zmm1 /// public static unsafe void StoreAligned(ulong* address, Vector512 source) => StoreAligned(address, source); /// - /// void _mm512_store_ps (float * mem_addr, __m512 a) - /// VMOVAPS m512 {k1}{z}, zmm1 + /// void _mm512_store_ps (float * mem_addr, __m512 a) + /// VMOVAPS m512 {k1}{z}, zmm1 /// public static unsafe void StoreAligned(float* address, Vector512 source) => StoreAligned(address, source); /// - /// void _mm512_store_pd (double * mem_addr, __m512d a) - /// VMOVAPD m512 {k1}{z}, zmm1 + /// void _mm512_store_pd (double * mem_addr, __m512d a) + /// VMOVAPD m512 {k1}{z}, zmm1 /// public static unsafe void StoreAligned(double* address, Vector512 source) => StoreAligned(address, source); /// - /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) - /// VMOVNTDQ m512, zmm1 + /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) + /// VMOVNTDQ m512, zmm1 /// public static unsafe void StoreAlignedNonTemporal(sbyte* address, Vector512 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) - /// VMOVNTDQ m512, zmm1 + /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) + /// VMOVNTDQ m512, zmm1 /// public static unsafe void StoreAlignedNonTemporal(byte* address, Vector512 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) - /// VMOVNTDQ m512, zmm1 + /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) + /// VMOVNTDQ m512, zmm1 /// public static unsafe void StoreAlignedNonTemporal(short* address, Vector512 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) - /// VMOVNTDQ m512, zmm1 + /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) + /// VMOVNTDQ m512, zmm1 /// public static unsafe void StoreAlignedNonTemporal(ushort* address, Vector512 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) - /// VMOVNTDQ m512, zmm1 + /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) + /// VMOVNTDQ m512, zmm1 /// public static unsafe void StoreAlignedNonTemporal(int* address, Vector512 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) - /// VMOVNTDQ m512, zmm1 + /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) + /// VMOVNTDQ m512, zmm1 /// public static unsafe void StoreAlignedNonTemporal(uint* address, Vector512 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) - /// VMOVNTDQ m512, zmm1 + /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) + /// VMOVNTDQ m512, zmm1 /// public static unsafe void StoreAlignedNonTemporal(long* address, Vector512 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) - /// VMOVNTDQ m512, zmm1 + /// void _mm512_stream_si512 (__m512i * mem_addr, __m512i a) + /// VMOVNTDQ m512, zmm1 /// public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector512 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm512_stream_ps (float * mem_addr, __m512 a) - /// VMOVNTPS m512, zmm1 + /// void _mm512_stream_ps (float * mem_addr, __m512 a) + /// VMOVNTPS m512, zmm1 /// public static unsafe void StoreAlignedNonTemporal(float* address, Vector512 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm512_stream_pd (double * mem_addr, __m512d a) - /// VMOVNTPD m512, zmm1 + /// void _mm512_stream_pd (double * mem_addr, __m512d a) + /// VMOVNTPD m512, zmm1 /// public static unsafe void StoreAlignedNonTemporal(double* address, Vector512 source) => StoreAlignedNonTemporal(address, source); /// - /// __m512i _mm512_sub_epi32 (__m512i a, __m512i b) - /// VPSUBD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_sub_epi32 (__m512i a, __m512i b) + /// VPSUBD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Subtract(Vector512 left, Vector512 right) => Subtract(left, right); /// - /// __m512i _mm512_sub_epi32 (__m512i a, __m512i b) - /// VPSUBD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_sub_epi32 (__m512i a, __m512i b) + /// VPSUBD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Subtract(Vector512 left, Vector512 right) => Subtract(left, right); /// - /// __m512i _mm512_sub_epi64 (__m512i a, __m512i b) - /// VPSUBQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_sub_epi64 (__m512i a, __m512i b) + /// VPSUBQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Subtract(Vector512 left, Vector512 right) => Subtract(left, right); /// - /// __m512i _mm512_sub_epi64 (__m512i a, __m512i b) - /// VPSUBQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_sub_epi64 (__m512i a, __m512i b) + /// VPSUBQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Subtract(Vector512 left, Vector512 right) => Subtract(left, right); /// - /// __m512 _mm512_sub_ps (__m512 a, __m512 b) - /// VSUBPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er} + /// __m512 _mm512_sub_ps (__m512 a, __m512 b) + /// VSUBPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er} /// public static Vector512 Subtract(Vector512 left, Vector512 right) => Subtract(left, right); /// - /// __m512d _mm512_sub_pd (__m512d a, __m512d b) - /// VSUBPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er} + /// __m512d _mm512_sub_pd (__m512d a, __m512d b) + /// VSUBPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er} /// public static Vector512 Subtract(Vector512 left, Vector512 right) => Subtract(left, right); /// - /// __m512 _mm512_sub_round_ps (__m512 a, __m512 b, int rounding) - /// VSUBPS zmm1, zmm2, zmm3 {er} + /// __m512 _mm512_sub_round_ps (__m512 a, __m512 b, int rounding) + /// VSUBPS zmm1, zmm2, zmm3 {er} /// public static Vector512 Subtract(Vector512 left, Vector512 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => Subtract(left, right, mode); /// - /// __m512d _mm512_sub_round_pd (__m512d a, __m512d b, int rounding) - /// VSUBPD zmm1, zmm2, zmm3 {er} + /// __m512d _mm512_sub_round_pd (__m512d a, __m512d b, int rounding) + /// VSUBPD zmm1, zmm2, zmm3 {er} /// public static Vector512 Subtract(Vector512 left, Vector512 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => Subtract(left, right, mode); /// - /// __m128 _mm_sub_round_ss (__m128 a, __m128 b, int rounding) - /// VSUBSS xmm1, xmm2, xmm3 {er} + /// __m128 _mm_sub_round_ss (__m128 a, __m128 b, int rounding) + /// VSUBSS xmm1, xmm2, xmm3 {er} /// public static Vector128 SubtractScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => SubtractScalar(left, right, mode); /// - /// __m128d _mm_sub_round_sd (__m128d a, __m128d b, int rounding) - /// VSUBSD xmm1, xmm2, xmm3 {er} + /// __m128d _mm_sub_round_sd (__m128d a, __m128d b, int rounding) + /// VSUBSD xmm1, xmm2, xmm3 {er} /// public static Vector128 SubtractScalar(Vector128 left, Vector128 right, [ConstantExpected(Max = FloatRoundingMode.ToZero)] FloatRoundingMode mode) => SubtractScalar(left, right, mode); /// - /// __m512i _mm512_ternarylogic_si512 (__m512i a, __m512i b, __m512i c, int imm) - /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m512i _mm512_ternarylogic_si512 (__m512i a, __m512i b, __m512i c, int imm) + /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector512 TernaryLogic(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m512i _mm512_ternarylogic_si512 (__m512i a, __m512i b, __m512i c, byte imm) - /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m512i _mm512_ternarylogic_si512 (__m512i a, __m512i b, __m512i c, byte imm) + /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector512 TernaryLogic(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m512i _mm512_ternarylogic_si512 (__m512i a, __m512i b, __m512i c, short imm) - /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m512i _mm512_ternarylogic_si512 (__m512i a, __m512i b, __m512i c, short imm) + /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector512 TernaryLogic(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m512i _mm512_ternarylogic_si512 (__m512i a, __m512i b, __m512i c, short imm) - /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m512i _mm512_ternarylogic_si512 (__m512i a, __m512i b, __m512i c, short imm) + /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector512 TernaryLogic(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m512i _mm512_ternarylogic_epi32 (__m512i a, __m512i b, __m512i c, int imm) - /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 + /// __m512i _mm512_ternarylogic_epi32 (__m512i a, __m512i b, __m512i c, int imm) + /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 /// public static Vector512 TernaryLogic(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m512i _mm512_ternarylogic_epi32 (__m512i a, __m512i b, __m512i c, int imm) - /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 + /// __m512i _mm512_ternarylogic_epi32 (__m512i a, __m512i b, __m512i c, int imm) + /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 /// public static Vector512 TernaryLogic(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m512i _mm512_ternarylogic_epi64 (__m512i a, __m512i b, __m512i c, int imm) - /// VPTERNLOGQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 + /// __m512i _mm512_ternarylogic_epi64 (__m512i a, __m512i b, __m512i c, int imm) + /// VPTERNLOGQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 /// public static Vector512 TernaryLogic(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m512i _mm512_ternarylogic_epi64 (__m512i a, __m512i b, __m512i c, int imm) - /// VPTERNLOGQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 + /// __m512i _mm512_ternarylogic_epi64 (__m512i a, __m512i b, __m512i c, int imm) + /// VPTERNLOGQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 /// public static Vector512 TernaryLogic(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m512 _mm512_ternarylogic_ps (__m512 a, __m512 b, __m512 c, int imm) - /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m512 _mm512_ternarylogic_ps (__m512 a, __m512 b, __m512 c, int imm) + /// VPTERNLOGD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector512 TernaryLogic(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m512d _mm512_ternarylogic_pd (__m512d a, __m512d b, __m512d c, int imm) - /// VPTERNLOGQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 - /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. + /// __m512d _mm512_ternarylogic_pd (__m512d a, __m512d b, __m512d c, int imm) + /// VPTERNLOGQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst, imm8 + /// The above native signature does not exist. We provide this additional overload for consistency with the other bitwise APIs. /// public static Vector512 TernaryLogic(Vector512 a, Vector512 b, Vector512 c, [ConstantExpected] byte control) => TernaryLogic(a, b, c, control); /// - /// __m512i _mm512_unpackhi_epi32 (__m512i a, __m512i b) - /// VPUNPCKHDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_unpackhi_epi32 (__m512i a, __m512i b) + /// VPUNPCKHDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 UnpackHigh(Vector512 left, Vector512 right) => UnpackHigh(left, right); /// - /// __m512i _mm512_unpackhi_epi32 (__m512i a, __m512i b) - /// VPUNPCKHDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_unpackhi_epi32 (__m512i a, __m512i b) + /// VPUNPCKHDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 UnpackHigh(Vector512 left, Vector512 right) => UnpackHigh(left, right); /// - /// __m512i _mm512_unpackhi_epi64 (__m512i a, __m512i b) - /// VPUNPCKHQDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_unpackhi_epi64 (__m512i a, __m512i b) + /// VPUNPCKHQDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 UnpackHigh(Vector512 left, Vector512 right) => UnpackHigh(left, right); /// - /// __m512i _mm512_unpackhi_epi64 (__m512i a, __m512i b) - /// VPUNPCKHQDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_unpackhi_epi64 (__m512i a, __m512i b) + /// VPUNPCKHQDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 UnpackHigh(Vector512 left, Vector512 right) => UnpackHigh(left, right); /// - /// __m512 _mm512_unpackhi_ps (__m512 a, __m512 b) - /// VUNPCKHPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_unpackhi_ps (__m512 a, __m512 b) + /// VUNPCKHPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 UnpackHigh(Vector512 left, Vector512 right) => UnpackHigh(left, right); /// - /// __m512d _mm512_unpackhi_pd (__m512d a, __m512d b) - /// VUNPCKHPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_unpackhi_pd (__m512d a, __m512d b) + /// VUNPCKHPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 UnpackHigh(Vector512 left, Vector512 right) => UnpackHigh(left, right); /// - /// __m512i _mm512_unpacklo_epi32 (__m512i a, __m512i b) - /// VPUNPCKLDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_unpacklo_epi32 (__m512i a, __m512i b) + /// VPUNPCKLDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 UnpackLow(Vector512 left, Vector512 right) => UnpackLow(left, right); /// - /// __m512i _mm512_unpacklo_epi32 (__m512i a, __m512i b) - /// VPUNPCKLDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_unpacklo_epi32 (__m512i a, __m512i b) + /// VPUNPCKLDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 UnpackLow(Vector512 left, Vector512 right) => UnpackLow(left, right); /// - /// __m512i _mm512_unpacklo_epi64 (__m512i a, __m512i b) - /// VPUNPCKLQDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_unpacklo_epi64 (__m512i a, __m512i b) + /// VPUNPCKLQDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 UnpackLow(Vector512 left, Vector512 right) => UnpackLow(left, right); /// - /// __m512i _mm512_unpacklo_epi64 (__m512i a, __m512i b) - /// VPUNPCKLQDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_unpacklo_epi64 (__m512i a, __m512i b) + /// VPUNPCKLQDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 UnpackLow(Vector512 left, Vector512 right) => UnpackLow(left, right); /// - /// __m512 _mm512_unpacklo_ps (__m512 a, __m512 b) - /// VUNPCKLPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512 _mm512_unpacklo_ps (__m512 a, __m512 b) + /// VUNPCKLPS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 UnpackLow(Vector512 left, Vector512 right) => UnpackLow(left, right); /// - /// __m512d _mm512_unpacklo_pd (__m512d a, __m512d b) - /// VUNPCKLPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512d _mm512_unpacklo_pd (__m512d a, __m512d b) + /// VUNPCKLPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 UnpackLow(Vector512 left, Vector512 right) => UnpackLow(left, right); /// - /// __m512i _mm512_xor_si512 (__m512i a, __m512i b) - /// VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_xor_si512 (__m512i a, __m512i b) + /// VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Xor(Vector512 left, Vector512 right) => Xor(left, right); /// - /// __m512i _mm512_xor_si512 (__m512i a, __m512i b) - /// VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_xor_si512 (__m512i a, __m512i b) + /// VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Xor(Vector512 left, Vector512 right) => Xor(left, right); /// - /// __m512i _mm512_xor_si512 (__m512i a, __m512i b) - /// VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_xor_si512 (__m512i a, __m512i b) + /// VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Xor(Vector512 left, Vector512 right) => Xor(left, right); /// - /// __m512i _mm512_xor_si512 (__m512i a, __m512i b) - /// VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_xor_si512 (__m512i a, __m512i b) + /// VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Xor(Vector512 left, Vector512 right) => Xor(left, right); /// - /// __m512i _mm512_xor_epi32 (__m512i a, __m512i b) - /// VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_xor_epi32 (__m512i a, __m512i b) + /// VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Xor(Vector512 left, Vector512 right) => Xor(left, right); /// - /// __m512i _mm512_xor_epi32 (__m512i a, __m512i b) - /// VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst + /// __m512i _mm512_xor_epi32 (__m512i a, __m512i b) + /// VPXORD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst /// public static Vector512 Xor(Vector512 left, Vector512 right) => Xor(left, right); /// - /// __m512i _mm512_xor_epi64 (__m512i a, __m512i b) - /// VPXORQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_xor_epi64 (__m512i a, __m512i b) + /// VPXORQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Xor(Vector512 left, Vector512 right) => Xor(left, right); /// - /// __m512i _mm512_xor_epi64 (__m512i a, __m512i b) - /// VPXORQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_xor_epi64 (__m512i a, __m512i b) + /// VPXORQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 Xor(Vector512 left, Vector512 right) => Xor(left, right); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512Vbmi.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512Vbmi.PlatformNotSupported.cs index 0f3b0c762f7..7262ada388b 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512Vbmi.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512Vbmi.PlatformNotSupported.cs @@ -6,130 +6,141 @@ namespace System.Runtime.Intrinsics.X86 { - /// This class provides access to X86 AVX512VBMI hardware instructions via intrinsics + /// Provides access to X86 AVX512VBMI hardware instructions via intrinsics [CLSCompliant(false)] public abstract class Avx512Vbmi : Avx512BW { internal Avx512Vbmi() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } + /// Provides access to the x86 AVX512VBMI+VL hardware instructions via intrinsics. public new abstract class VL : Avx512BW.VL { internal VL() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } /// - /// __m128i _mm_multishift_epi64_epi8(__m128i a, __m128i b) - /// VPMULTISHIFTQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_multishift_epi64_epi8(__m128i a, __m128i b) + /// VPMULTISHIFTQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiShift(Vector128 control, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_multishift_epi64_epi8(__m128i a, __m128i b) - /// VPMULTISHIFTQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_multishift_epi64_epi8(__m128i a, __m128i b) + /// VPMULTISHIFTQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiShift(Vector128 control, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_multishift_epi64_epi8(__m256i a, __m256i b) - /// VPMULTISHIFTQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_multishift_epi64_epi8(__m256i a, __m256i b) + /// VPMULTISHIFTQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiShift(Vector256 control, Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_multishift_epi64_epi8(__m256i a, __m256i b) - /// VPMULTISHIFTQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_multishift_epi64_epi8(__m256i a, __m256i b) + /// VPMULTISHIFTQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiShift(Vector256 control, Vector256 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_permutevar64x8_epi8 (__m128i a, __m128i b) - /// VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutevar64x8_epi8 (__m128i a, __m128i b) + /// VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar16x8(Vector128 left, Vector128 control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_permutevar64x8_epi8 (__m128i a, __m128i b) - /// VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutevar64x8_epi8 (__m128i a, __m128i b) + /// VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar16x8(Vector128 left, Vector128 control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_permutex2var_epi8 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2B xmm1 {k1}{z}, xmm2, xmm3/m128 - /// VPERMT2B xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutex2var_epi8 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2B xmm1 {k1}{z}, xmm2, xmm3/m128 + /// VPERMT2B xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar16x8x2(Vector128 lower, Vector128 indices, Vector128 upper) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_permutex2var_epi8 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2B xmm1 {k1}{z}, xmm2, xmm3/m128 - /// VPERMT2B xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutex2var_epi8 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2B xmm1 {k1}{z}, xmm2, xmm3/m128 + /// VPERMT2B xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar16x8x2(Vector128 lower, Vector128 indices, Vector128 upper) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutevar64x8_epi8 (__m256i a, __m256i b) - /// VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutevar64x8_epi8 (__m256i a, __m256i b) + /// VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar32x8(Vector256 left, Vector256 control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutevar64x8_epi8 (__m256i a, __m256i b) - /// VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutevar64x8_epi8 (__m256i a, __m256i b) + /// VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar32x8(Vector256 left, Vector256 control) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutex2var_epi8 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2B ymm1 {k1}{z}, ymm2, ymm3/m256 - /// VPERMT2B ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutex2var_epi8 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2B ymm1 {k1}{z}, ymm2, ymm3/m256 + /// VPERMT2B ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar32x8x2(Vector256 lower, Vector256 indices, Vector256 upper) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_permutex2var_epi8 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2B ymm1 {k1}{z}, ymm2, ymm3/m256 - /// VPERMT2B ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutex2var_epi8 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2B ymm1 {k1}{z}, ymm2, ymm3/m256 + /// VPERMT2B ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar32x8x2(Vector256 lower, Vector256 indices, Vector256 upper) { throw new PlatformNotSupportedException(); } } + /// Provides access to the x86 AVX512VBMI hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class X64 : Avx512BW.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } } /// - /// __m512i _mm512_multishift_epi64_epi8(__m512i a, __m512i b) - /// VPMULTISHIFTQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_multishift_epi64_epi8(__m512i a, __m512i b) + /// VPMULTISHIFTQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 MultiShift(Vector512 control, Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_multishift_epi64_epi8(__m512i a, __m512i b) - /// VPMULTISHIFTQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_multishift_epi64_epi8(__m512i a, __m512i b) + /// VPMULTISHIFTQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 MultiShift(Vector512 control, Vector512 value) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_permutevar64x8_epi8 (__m512i a, __m512i b) - /// VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_permutevar64x8_epi8 (__m512i a, __m512i b) + /// VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PermuteVar64x8(Vector512 left, Vector512 control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_permutevar64x8_epi8 (__m512i a, __m512i b) - /// VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_permutevar64x8_epi8 (__m512i a, __m512i b) + /// VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PermuteVar64x8(Vector512 left, Vector512 control) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_permutex2var_epi8 (__m512i a, __m512i idx, __m512i b) - /// VPERMI2B zmm1 {k1}{z}, zmm2, zmm3/m512 - /// VPERMT2B zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_permutex2var_epi8 (__m512i a, __m512i idx, __m512i b) + /// VPERMI2B zmm1 {k1}{z}, zmm2, zmm3/m512 + /// VPERMT2B zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PermuteVar64x8x2(Vector512 lower, Vector512 indices, Vector512 upper) { throw new PlatformNotSupportedException(); } /// - /// __m512i _mm512_permutex2var_epi8 (__m512i a, __m512i idx, __m512i b) - /// VPERMI2B zmm1 {k1}{z}, zmm2, zmm3/m512 - /// VPERMT2B zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_permutex2var_epi8 (__m512i a, __m512i idx, __m512i b) + /// VPERMI2B zmm1 {k1}{z}, zmm2, zmm3/m512 + /// VPERMT2B zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PermuteVar64x8x2(Vector512 lower, Vector512 indices, Vector512 upper) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512Vbmi.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512Vbmi.cs index 7b5641782a7..6d4c48db251 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512Vbmi.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Avx512Vbmi.cs @@ -8,133 +8,144 @@ namespace System.Runtime.Intrinsics.X86 { - /// This class provides access to X86 AVX512VBMI hardware instructions via intrinsics + /// Provides access to X86 AVX512VBMI hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Avx512Vbmi : Avx512BW { internal Avx512Vbmi() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the x86 AVX512VBMI+VL hardware instructions via intrinsics. [Intrinsic] public new abstract class VL : Avx512BW.VL { internal VL() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } /// - /// __m128i _mm_multishift_epi64_epi8(__m128i a, __m128i b) - /// VPMULTISHIFTQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_multishift_epi64_epi8(__m128i a, __m128i b) + /// VPMULTISHIFTQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiShift(Vector128 control, Vector128 value) => MultiShift(control, value); /// - /// __m128i _mm_multishift_epi64_epi8(__m128i a, __m128i b) - /// VPMULTISHIFTQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_multishift_epi64_epi8(__m128i a, __m128i b) + /// VPMULTISHIFTQB xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiShift(Vector128 control, Vector128 value) => MultiShift(control, value); /// - /// __m256i _mm256_multishift_epi64_epi8(__m256i a, __m256i b) - /// VPMULTISHIFTQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_multishift_epi64_epi8(__m256i a, __m256i b) + /// VPMULTISHIFTQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiShift(Vector256 control, Vector256 value) => MultiShift(control, value); /// - /// __m256i _mm256_multishift_epi64_epi8(__m256i a, __m256i b) - /// VPMULTISHIFTQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256i _mm256_multishift_epi64_epi8(__m256i a, __m256i b) + /// VPMULTISHIFTQB ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiShift(Vector256 control, Vector256 value) => MultiShift(control, value); /// - /// __m128i _mm_permutevar64x8_epi8 (__m128i a, __m128i b) - /// VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutevar64x8_epi8 (__m128i a, __m128i b) + /// VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar16x8(Vector128 left, Vector128 control) => PermuteVar16x8(left, control); /// - /// __m128i _mm_permutevar64x8_epi8 (__m128i a, __m128i b) - /// VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutevar64x8_epi8 (__m128i a, __m128i b) + /// VPERMB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar16x8(Vector128 left, Vector128 control) => PermuteVar16x8(left, control); /// - /// __m128i _mm_permutex2var_epi8 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2B xmm1 {k1}{z}, xmm2, xmm3/m128 - /// VPERMT2B xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutex2var_epi8 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2B xmm1 {k1}{z}, xmm2, xmm3/m128 + /// VPERMT2B xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar16x8x2(Vector128 lower, Vector128 indices, Vector128 upper) => PermuteVar16x8x2(lower, indices, upper); /// - /// __m128i _mm_permutex2var_epi8 (__m128i a, __m128i idx, __m128i b) - /// VPERMI2B xmm1 {k1}{z}, xmm2, xmm3/m128 - /// VPERMT2B xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_permutex2var_epi8 (__m128i a, __m128i idx, __m128i b) + /// VPERMI2B xmm1 {k1}{z}, xmm2, xmm3/m128 + /// VPERMT2B xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PermuteVar16x8x2(Vector128 lower, Vector128 indices, Vector128 upper) => PermuteVar16x8x2(lower, indices, upper); /// - /// __m256i _mm256_permutevar64x8_epi8 (__m256i a, __m256i b) - /// VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutevar64x8_epi8 (__m256i a, __m256i b) + /// VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar32x8(Vector256 left, Vector256 control) => PermuteVar32x8(left, control); /// - /// __m256i _mm256_permutevar64x8_epi8 (__m256i a, __m256i b) - /// VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutevar64x8_epi8 (__m256i a, __m256i b) + /// VPERMB ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar32x8(Vector256 left, Vector256 control) => PermuteVar32x8(left, control); /// - /// __m256i _mm256_permutex2var_epi8 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2B ymm1 {k1}{z}, ymm2, ymm3/m256 - /// VPERMT2B ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutex2var_epi8 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2B ymm1 {k1}{z}, ymm2, ymm3/m256 + /// VPERMT2B ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar32x8x2(Vector256 lower, Vector256 indices, Vector256 upper) => PermuteVar32x8x2(lower, indices, upper); /// - /// __m256i _mm256_permutex2var_epi8 (__m256i a, __m256i idx, __m256i b) - /// VPERMI2B ymm1 {k1}{z}, ymm2, ymm3/m256 - /// VPERMT2B ymm1 {k1}{z}, ymm2, ymm3/m256 + /// __m256i _mm256_permutex2var_epi8 (__m256i a, __m256i idx, __m256i b) + /// VPERMI2B ymm1 {k1}{z}, ymm2, ymm3/m256 + /// VPERMT2B ymm1 {k1}{z}, ymm2, ymm3/m256 /// public static Vector256 PermuteVar32x8x2(Vector256 lower, Vector256 indices, Vector256 upper) => PermuteVar32x8x2(lower, indices, upper); } + /// Provides access to the x86 AVX512VBMI hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : Avx512BW.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } } /// - /// __m512i _mm512_multishift_epi64_epi8(__m512i a, __m512i b) - /// VPMULTISHIFTQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_multishift_epi64_epi8(__m512i a, __m512i b) + /// VPMULTISHIFTQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 MultiShift(Vector512 control, Vector512 value) => MultiShift(control, value); /// - /// __m512i _mm512_multishift_epi64_epi8(__m512i a, __m512i b) - /// VPMULTISHIFTQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst + /// __m512i _mm512_multishift_epi64_epi8(__m512i a, __m512i b) + /// VPMULTISHIFTQB zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst /// public static Vector512 MultiShift(Vector512 control, Vector512 value) => MultiShift(control, value); /// - /// __m512i _mm512_permutevar64x8_epi8 (__m512i a, __m512i b) - /// VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_permutevar64x8_epi8 (__m512i a, __m512i b) + /// VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PermuteVar64x8(Vector512 left, Vector512 control) => PermuteVar64x8(left, control); /// - /// __m512i _mm512_permutevar64x8_epi8 (__m512i a, __m512i b) - /// VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_permutevar64x8_epi8 (__m512i a, __m512i b) + /// VPERMB zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PermuteVar64x8(Vector512 left, Vector512 control) => PermuteVar64x8(left, control); /// - /// __m512i _mm512_permutex2var_epi8 (__m512i a, __m512i idx, __m512i b) - /// VPERMI2B zmm1 {k1}{z}, zmm2, zmm3/m512 - /// VPERMT2B zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_permutex2var_epi8 (__m512i a, __m512i idx, __m512i b) + /// VPERMI2B zmm1 {k1}{z}, zmm2, zmm3/m512 + /// VPERMT2B zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PermuteVar64x8x2(Vector512 lower, Vector512 indices, Vector512 upper) => PermuteVar64x8x2(lower, indices, upper); /// - /// __m512i _mm512_permutex2var_epi8 (__m512i a, __m512i idx, __m512i b) - /// VPERMI2B zmm1 {k1}{z}, zmm2, zmm3/m512 - /// VPERMT2B zmm1 {k1}{z}, zmm2, zmm3/m512 + /// __m512i _mm512_permutex2var_epi8 (__m512i a, __m512i idx, __m512i b) + /// VPERMI2B zmm1 {k1}{z}, zmm2, zmm3/m512 + /// VPERMT2B zmm1 {k1}{z}, zmm2, zmm3/m512 /// public static Vector512 PermuteVar64x8x2(Vector512 lower, Vector512 indices, Vector512 upper) => PermuteVar64x8x2(lower, indices, upper); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/AvxVnni.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/AvxVnni.PlatformNotSupported.cs index 039e35e80e3..751c25f1765 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/AvxVnni.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/AvxVnni.PlatformNotSupported.cs @@ -5,65 +5,73 @@ namespace System.Runtime.Intrinsics.X86 { + /// Provides access to the x86 AVXVNNI hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class AvxVnni : Avx2 { internal AvxVnni() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } + /// Provides access to the x86 AVXVNNI hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class X64 : Avx2.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } } /// - /// __m128i _mm_dpbusd_epi32 (__m128i src, __m128i a, __m128i b) - /// VPDPBUSD xmm, xmm, xmm/m128 + /// __m128i _mm_dpbusd_epi32 (__m128i src, __m128i a, __m128i b) + /// VPDPBUSD xmm, xmm, xmm/m128 /// public static Vector128 MultiplyWideningAndAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_dpwssd_epi32 (__m128i src, __m128i a, __m128i b) - /// VPDPWSSD xmm, xmm, xmm/m128 + /// __m128i _mm_dpwssd_epi32 (__m128i src, __m128i a, __m128i b) + /// VPDPWSSD xmm, xmm, xmm/m128 /// public static Vector128 MultiplyWideningAndAdd(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_dpbusd_epi32 (__m256i src, __m256i a, __m256i b) - /// VPDPBUSD ymm, ymm, ymm/m256 + /// __m256i _mm256_dpbusd_epi32 (__m256i src, __m256i a, __m256i b) + /// VPDPBUSD ymm, ymm, ymm/m256 /// public static Vector256 MultiplyWideningAndAdd(Vector256 addend, Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_dpwssd_epi32 (__m256i src, __m256i a, __m256i b) - /// VPDPWSSD ymm, ymm, ymm/m256 + /// __m256i _mm256_dpwssd_epi32 (__m256i src, __m256i a, __m256i b) + /// VPDPWSSD ymm, ymm, ymm/m256 /// public static Vector256 MultiplyWideningAndAdd(Vector256 addend, Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_dpbusds_epi32 (__m128i src, __m128i a, __m128i b) - /// VPDPBUSDS xmm, xmm, xmm/m128 + /// __m128i _mm_dpbusds_epi32 (__m128i src, __m128i a, __m128i b) + /// VPDPBUSDS xmm, xmm, xmm/m128 /// public static Vector128 MultiplyWideningAndAddSaturate(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_dpwssds_epi32 (__m128i src, __m128i a, __m128i b) - /// VPDPWSSDS xmm, xmm, xmm/m128 + /// __m128i _mm_dpwssds_epi32 (__m128i src, __m128i a, __m128i b) + /// VPDPWSSDS xmm, xmm, xmm/m128 /// public static Vector128 MultiplyWideningAndAddSaturate(Vector128 addend, Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_dpbusds_epi32 (__m256i src, __m256i a, __m256i b) - /// VPDPBUSDS ymm, ymm, ymm/m256 + /// __m256i _mm256_dpbusds_epi32 (__m256i src, __m256i a, __m256i b) + /// VPDPBUSDS ymm, ymm, ymm/m256 /// public static Vector256 MultiplyWideningAndAddSaturate(Vector256 addend, Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } /// - /// __m256i _mm256_dpwssds_epi32 (__m256i src, __m256i a, __m256i b) - /// VPDPWSSDS ymm, ymm, ymm/m256 + /// __m256i _mm256_dpwssds_epi32 (__m256i src, __m256i a, __m256i b) + /// VPDPWSSDS ymm, ymm, ymm/m256 /// public static Vector256 MultiplyWideningAndAddSaturate(Vector256 addend, Vector256 left, Vector256 right) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/AvxVnni.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/AvxVnni.cs index 044d87e92c9..902b70b3eb2 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/AvxVnni.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/AvxVnni.cs @@ -5,67 +5,75 @@ namespace System.Runtime.Intrinsics.X86 { + /// Provides access to the x86 AVXVNNI hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class AvxVnni : Avx2 { internal AvxVnni() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the x86 AVXVNNI hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : Avx2.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } } /// - /// __m128i _mm_dpbusd_epi32 (__m128i src, __m128i a, __m128i b) - /// VPDPBUSD xmm, xmm, xmm/m128 + /// __m128i _mm_dpbusd_epi32 (__m128i src, __m128i a, __m128i b) + /// VPDPBUSD xmm, xmm, xmm/m128 /// public static Vector128 MultiplyWideningAndAdd(Vector128 addend, Vector128 left, Vector128 right) => MultiplyWideningAndAdd(addend, left, right); /// - /// __m128i _mm_dpwssd_epi32 (__m128i src, __m128i a, __m128i b) - /// VPDPWSSD xmm, xmm, xmm/m128 + /// __m128i _mm_dpwssd_epi32 (__m128i src, __m128i a, __m128i b) + /// VPDPWSSD xmm, xmm, xmm/m128 /// public static Vector128 MultiplyWideningAndAdd(Vector128 addend, Vector128 left, Vector128 right) => MultiplyWideningAndAdd(addend, left, right); /// - /// __m256i _mm256_dpbusd_epi32 (__m256i src, __m256i a, __m256i b) - /// VPDPBUSD ymm, ymm, ymm/m256 + /// __m256i _mm256_dpbusd_epi32 (__m256i src, __m256i a, __m256i b) + /// VPDPBUSD ymm, ymm, ymm/m256 /// public static Vector256 MultiplyWideningAndAdd(Vector256 addend, Vector256 left, Vector256 right) => MultiplyWideningAndAdd(addend, left, right); /// - /// __m256i _mm256_dpwssd_epi32 (__m256i src, __m256i a, __m256i b) - /// VPDPWSSD ymm, ymm, ymm/m256 + /// __m256i _mm256_dpwssd_epi32 (__m256i src, __m256i a, __m256i b) + /// VPDPWSSD ymm, ymm, ymm/m256 /// public static Vector256 MultiplyWideningAndAdd(Vector256 addend, Vector256 left, Vector256 right) => MultiplyWideningAndAdd(addend, left, right); /// - /// __m128i _mm_dpbusds_epi32 (__m128i src, __m128i a, __m128i b) - /// VPDPBUSDS xmm, xmm, xmm/m128 + /// __m128i _mm_dpbusds_epi32 (__m128i src, __m128i a, __m128i b) + /// VPDPBUSDS xmm, xmm, xmm/m128 /// public static Vector128 MultiplyWideningAndAddSaturate(Vector128 addend, Vector128 left, Vector128 right) => MultiplyWideningAndAddSaturate(addend, left, right); /// - /// __m128i _mm_dpwssds_epi32 (__m128i src, __m128i a, __m128i b) - /// VPDPWSSDS xmm, xmm, xmm/m128 + /// __m128i _mm_dpwssds_epi32 (__m128i src, __m128i a, __m128i b) + /// VPDPWSSDS xmm, xmm, xmm/m128 /// public static Vector128 MultiplyWideningAndAddSaturate(Vector128 addend, Vector128 left, Vector128 right) => MultiplyWideningAndAddSaturate(addend, left, right); /// - /// __m256i _mm256_dpbusds_epi32 (__m256i src, __m256i a, __m256i b) - /// VPDPBUSDS ymm, ymm, ymm/m256 + /// __m256i _mm256_dpbusds_epi32 (__m256i src, __m256i a, __m256i b) + /// VPDPBUSDS ymm, ymm, ymm/m256 /// public static Vector256 MultiplyWideningAndAddSaturate(Vector256 addend, Vector256 left, Vector256 right) => MultiplyWideningAndAddSaturate(addend, left, right); /// - /// __m256i _mm256_dpwssds_epi32 (__m256i src, __m256i a, __m256i b) - /// VPDPWSSDS ymm, ymm, ymm/m256 + /// __m256i _mm256_dpwssds_epi32 (__m256i src, __m256i a, __m256i b) + /// VPDPWSSDS ymm, ymm, ymm/m256 /// public static Vector256 MultiplyWideningAndAddSaturate(Vector256 addend, Vector256 left, Vector256 right) => MultiplyWideningAndAddSaturate(addend, left, right); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi1.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi1.PlatformNotSupported.cs index 46fb386a395..60095cc3d26 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi1.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi1.PlatformNotSupported.cs @@ -7,111 +7,116 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel BMI1 hardware instructions via intrinsics - /// + /// Provides access to X86 BMI1 hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Bmi1 : X86Base { internal Bmi1() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } + /// Provides access to the x86 BMI1 hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class X64 : X86Base.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } /// - /// unsigned __int64 _andn_u64 (unsigned __int64 a, unsigned __int64 b) - /// ANDN r64a, r64b, r/m64 - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _andn_u64 (unsigned __int64 a, unsigned __int64 b) + /// ANDN r64a, r64b, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static ulong AndNot(ulong left, ulong right) { throw new PlatformNotSupportedException(); } /// - /// unsigned __int64 _bextr_u64 (unsigned __int64 a, unsigned int start, unsigned int len) - /// BEXTR r64a, r/m64, r64b - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _bextr_u64 (unsigned __int64 a, unsigned int start, unsigned int len) + /// BEXTR r64a, r/m64, r64b + /// This intrinsic is only available on 64-bit processes /// public static ulong BitFieldExtract(ulong value, byte start, byte length) { throw new PlatformNotSupportedException(); } /// - /// unsigned __int64 _bextr2_u64 (unsigned __int64 a, unsigned __int64 control) - /// BEXTR r64a, r/m64, r64b - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _bextr2_u64 (unsigned __int64 a, unsigned __int64 control) + /// BEXTR r64a, r/m64, r64b + /// This intrinsic is only available on 64-bit processes /// public static ulong BitFieldExtract(ulong value, ushort control) { throw new PlatformNotSupportedException(); } /// - /// unsigned __int64 _blsi_u64 (unsigned __int64 a) - /// BLSI r64, r/m64 - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _blsi_u64 (unsigned __int64 a) + /// BLSI r64, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static ulong ExtractLowestSetBit(ulong value) { throw new PlatformNotSupportedException(); } /// - /// unsigned __int64 _blsmsk_u64 (unsigned __int64 a) - /// BLSMSK r64, r/m64 - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _blsmsk_u64 (unsigned __int64 a) + /// BLSMSK r64, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static ulong GetMaskUpToLowestSetBit(ulong value) { throw new PlatformNotSupportedException(); } /// - /// unsigned __int64 _blsr_u64 (unsigned __int64 a) - /// BLSR r64, r/m64 - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _blsr_u64 (unsigned __int64 a) + /// BLSR r64, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static ulong ResetLowestSetBit(ulong value) { throw new PlatformNotSupportedException(); } /// - /// __int64 _mm_tzcnt_64 (unsigned __int64 a) - /// TZCNT r64, r/m64 - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_tzcnt_64 (unsigned __int64 a) + /// TZCNT r64, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static ulong TrailingZeroCount(ulong value) { throw new PlatformNotSupportedException(); } } /// - /// unsigned int _andn_u32 (unsigned int a, unsigned int b) - /// ANDN r32a, r32b, r/m32 + /// unsigned int _andn_u32 (unsigned int a, unsigned int b) + /// ANDN r32a, r32b, r/m32 /// public static uint AndNot(uint left, uint right) { throw new PlatformNotSupportedException(); } /// - /// unsigned int _bextr_u32 (unsigned int a, unsigned int start, unsigned int len) - /// BEXTR r32a, r/m32, r32b + /// unsigned int _bextr_u32 (unsigned int a, unsigned int start, unsigned int len) + /// BEXTR r32a, r/m32, r32b /// public static uint BitFieldExtract(uint value, byte start, byte length) { throw new PlatformNotSupportedException(); } /// - /// unsigned int _bextr2_u32 (unsigned int a, unsigned int control) - /// BEXTR r32a, r/m32, r32b + /// unsigned int _bextr2_u32 (unsigned int a, unsigned int control) + /// BEXTR r32a, r/m32, r32b /// public static uint BitFieldExtract(uint value, ushort control) { throw new PlatformNotSupportedException(); } /// - /// unsigned int _blsi_u32 (unsigned int a) - /// BLSI r32, r/m32 + /// unsigned int _blsi_u32 (unsigned int a) + /// BLSI r32, r/m32 /// public static uint ExtractLowestSetBit(uint value) { throw new PlatformNotSupportedException(); } /// - /// unsigned int _blsmsk_u32 (unsigned int a) - /// BLSMSK r32, r/m32 + /// unsigned int _blsmsk_u32 (unsigned int a) + /// BLSMSK r32, r/m32 /// public static uint GetMaskUpToLowestSetBit(uint value) { throw new PlatformNotSupportedException(); } /// - /// unsigned int _blsr_u32 (unsigned int a) - /// BLSR r32, r/m32 + /// unsigned int _blsr_u32 (unsigned int a) + /// BLSR r32, r/m32 /// public static uint ResetLowestSetBit(uint value) { throw new PlatformNotSupportedException(); } /// - /// int _mm_tzcnt_32 (unsigned int a) - /// TZCNT r32, r/m32 + /// int _mm_tzcnt_32 (unsigned int a) + /// TZCNT r32, r/m32 /// public static uint TrailingZeroCount(uint value) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi1.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi1.cs index eec6534a142..f60df41b69b 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi1.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi1.cs @@ -5,113 +5,118 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel BMI1 hardware instructions via intrinsics - /// + /// Provides access to X86 BMI1 hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Bmi1 : X86Base { internal Bmi1() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the x86 BMI1 hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : X86Base.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } /// - /// unsigned __int64 _andn_u64 (unsigned __int64 a, unsigned __int64 b) - /// ANDN r64a, r64b, r/m64 - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _andn_u64 (unsigned __int64 a, unsigned __int64 b) + /// ANDN r64a, r64b, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static ulong AndNot(ulong left, ulong right) => AndNot(left, right); /// - /// unsigned __int64 _bextr_u64 (unsigned __int64 a, unsigned int start, unsigned int len) - /// BEXTR r64a, r/m64, r64b - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _bextr_u64 (unsigned __int64 a, unsigned int start, unsigned int len) + /// BEXTR r64a, r/m64, r64b + /// This intrinsic is only available on 64-bit processes /// public static ulong BitFieldExtract(ulong value, byte start, byte length) => BitFieldExtract(value, (ushort)(start | (length << 8))); /// - /// unsigned __int64 _bextr2_u64 (unsigned __int64 a, unsigned __int64 control) - /// BEXTR r64a, r/m64, r64b - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _bextr2_u64 (unsigned __int64 a, unsigned __int64 control) + /// BEXTR r64a, r/m64, r64b + /// This intrinsic is only available on 64-bit processes /// public static ulong BitFieldExtract(ulong value, ushort control) => BitFieldExtract(value, control); /// - /// unsigned __int64 _blsi_u64 (unsigned __int64 a) - /// BLSI r64, r/m64 - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _blsi_u64 (unsigned __int64 a) + /// BLSI r64, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static ulong ExtractLowestSetBit(ulong value) => ExtractLowestSetBit(value); /// - /// unsigned __int64 _blsmsk_u64 (unsigned __int64 a) - /// BLSMSK r64, r/m64 - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _blsmsk_u64 (unsigned __int64 a) + /// BLSMSK r64, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static ulong GetMaskUpToLowestSetBit(ulong value) => GetMaskUpToLowestSetBit(value); /// - /// unsigned __int64 _blsr_u64 (unsigned __int64 a) - /// BLSR r64, r/m64 - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _blsr_u64 (unsigned __int64 a) + /// BLSR r64, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static ulong ResetLowestSetBit(ulong value) => ResetLowestSetBit(value); /// - /// __int64 _mm_tzcnt_64 (unsigned __int64 a) - /// TZCNT r64, r/m64 - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_tzcnt_64 (unsigned __int64 a) + /// TZCNT r64, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static ulong TrailingZeroCount(ulong value) => TrailingZeroCount(value); } /// - /// unsigned int _andn_u32 (unsigned int a, unsigned int b) - /// ANDN r32a, r32b, r/m32 + /// unsigned int _andn_u32 (unsigned int a, unsigned int b) + /// ANDN r32a, r32b, r/m32 /// public static uint AndNot(uint left, uint right) => AndNot(left, right); /// - /// unsigned int _bextr_u32 (unsigned int a, unsigned int start, unsigned int len) - /// BEXTR r32a, r/m32, r32b + /// unsigned int _bextr_u32 (unsigned int a, unsigned int start, unsigned int len) + /// BEXTR r32a, r/m32, r32b /// public static uint BitFieldExtract(uint value, byte start, byte length) => BitFieldExtract(value, (ushort)(start | (length << 8))); /// - /// unsigned int _bextr2_u32 (unsigned int a, unsigned int control) - /// BEXTR r32a, r/m32, r32b + /// unsigned int _bextr2_u32 (unsigned int a, unsigned int control) + /// BEXTR r32a, r/m32, r32b /// public static uint BitFieldExtract(uint value, ushort control) => BitFieldExtract(value, control); /// - /// unsigned int _blsi_u32 (unsigned int a) - /// BLSI r32, r/m32 + /// unsigned int _blsi_u32 (unsigned int a) + /// BLSI r32, r/m32 /// public static uint ExtractLowestSetBit(uint value) => ExtractLowestSetBit(value); /// - /// unsigned int _blsmsk_u32 (unsigned int a) - /// BLSMSK r32, r/m32 + /// unsigned int _blsmsk_u32 (unsigned int a) + /// BLSMSK r32, r/m32 /// public static uint GetMaskUpToLowestSetBit(uint value) => GetMaskUpToLowestSetBit(value); /// - /// unsigned int _blsr_u32 (unsigned int a) - /// BLSR r32, r/m32 + /// unsigned int _blsr_u32 (unsigned int a) + /// BLSR r32, r/m32 /// public static uint ResetLowestSetBit(uint value) => ResetLowestSetBit(value); /// - /// int _mm_tzcnt_32 (unsigned int a) - /// TZCNT r32, r/m32 + /// int _mm_tzcnt_32 (unsigned int a) + /// TZCNT r32, r/m32 /// public static uint TrailingZeroCount(uint value) => TrailingZeroCount(value); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi2.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi2.PlatformNotSupported.cs index a412768afe7..ddeb6a8ac9e 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi2.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi2.PlatformNotSupported.cs @@ -7,89 +7,94 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel BMI2 hardware instructions via intrinsics - /// + /// Provides access to X86 BMI2 hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Bmi2 : X86Base { internal Bmi2() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } + /// Provides access to the x86 BMI2 hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class X64 : X86Base.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } /// - /// unsigned __int64 _bzhi_u64 (unsigned __int64 a, unsigned int index) - /// BZHI r64a, r/m64, r64b - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _bzhi_u64 (unsigned __int64 a, unsigned int index) + /// BZHI r64a, r/m64, r64b + /// This intrinsic is only available on 64-bit processes /// public static ulong ZeroHighBits(ulong value, ulong index) { throw new PlatformNotSupportedException(); } /// - /// unsigned __int64 _mulx_u64 (unsigned __int64 a, unsigned __int64 b, unsigned __int64* hi) - /// MULX r64a, r64b, r/m64 - /// The above native signature does not directly correspond to the managed signature. - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mulx_u64 (unsigned __int64 a, unsigned __int64 b, unsigned __int64* hi) + /// MULX r64a, r64b, r/m64 + /// The above native signature does not directly correspond to the managed signature. + /// This intrinsic is only available on 64-bit processes /// public static ulong MultiplyNoFlags(ulong left, ulong right) { throw new PlatformNotSupportedException(); } /// - /// unsigned __int64 _mulx_u64 (unsigned __int64 a, unsigned __int64 b, unsigned __int64* hi) - /// MULX r64a, r64b, r/m64 - /// The above native signature does not directly correspond to the managed signature. - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mulx_u64 (unsigned __int64 a, unsigned __int64 b, unsigned __int64* hi) + /// MULX r64a, r64b, r/m64 + /// The above native signature does not directly correspond to the managed signature. + /// This intrinsic is only available on 64-bit processes /// public static unsafe ulong MultiplyNoFlags(ulong left, ulong right, ulong* low) { throw new PlatformNotSupportedException(); } /// - /// unsigned __int64 _pdep_u64 (unsigned __int64 a, unsigned __int64 mask) - /// PDEP r64a, r64b, r/m64 - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _pdep_u64 (unsigned __int64 a, unsigned __int64 mask) + /// PDEP r64a, r64b, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static ulong ParallelBitDeposit(ulong value, ulong mask) { throw new PlatformNotSupportedException(); } /// - /// unsigned __int64 _pext_u64 (unsigned __int64 a, unsigned __int64 mask) - /// PEXT r64a, r64b, r/m64 - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _pext_u64 (unsigned __int64 a, unsigned __int64 mask) + /// PEXT r64a, r64b, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static ulong ParallelBitExtract(ulong value, ulong mask) { throw new PlatformNotSupportedException(); } } /// - /// unsigned int _bzhi_u32 (unsigned int a, unsigned int index) - /// BZHI r32a, r/m32, r32b + /// unsigned int _bzhi_u32 (unsigned int a, unsigned int index) + /// BZHI r32a, r/m32, r32b /// public static uint ZeroHighBits(uint value, uint index) { throw new PlatformNotSupportedException(); } /// - /// unsigned int _mulx_u32 (unsigned int a, unsigned int b, unsigned int* hi) - /// MULX r32a, r32b, r/m32 - /// The above native signature does not directly correspond to the managed signature. + /// unsigned int _mulx_u32 (unsigned int a, unsigned int b, unsigned int* hi) + /// MULX r32a, r32b, r/m32 + /// The above native signature does not directly correspond to the managed signature. /// public static uint MultiplyNoFlags(uint left, uint right) { throw new PlatformNotSupportedException(); } /// - /// unsigned int _mulx_u32 (unsigned int a, unsigned int b, unsigned int* hi) - /// MULX r32a, r32b, r/m32 - /// The above native signature does not directly correspond to the managed signature. + /// unsigned int _mulx_u32 (unsigned int a, unsigned int b, unsigned int* hi) + /// MULX r32a, r32b, r/m32 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe uint MultiplyNoFlags(uint left, uint right, uint* low) { throw new PlatformNotSupportedException(); } /// - /// unsigned int _pdep_u32 (unsigned int a, unsigned int mask) - /// PDEP r32a, r32b, r/m32 + /// unsigned int _pdep_u32 (unsigned int a, unsigned int mask) + /// PDEP r32a, r32b, r/m32 /// public static uint ParallelBitDeposit(uint value, uint mask) { throw new PlatformNotSupportedException(); } /// - /// unsigned int _pext_u32 (unsigned int a, unsigned int mask) - /// PEXT r32a, r32b, r/m32 + /// unsigned int _pext_u32 (unsigned int a, unsigned int mask) + /// PEXT r32a, r32b, r/m32 /// public static uint ParallelBitExtract(uint value, uint mask) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi2.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi2.cs index 31ac3531e3b..9178a6e0a8f 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi2.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Bmi2.cs @@ -5,91 +5,96 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel BMI2 hardware instructions via intrinsics - /// + /// Provides access to X86 BMI2 hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Bmi2 : X86Base { internal Bmi2() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the x86 BMI2 hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : X86Base.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } /// - /// unsigned __int64 _bzhi_u64 (unsigned __int64 a, unsigned int index) - /// BZHI r64a, r/m64, r64b - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _bzhi_u64 (unsigned __int64 a, unsigned int index) + /// BZHI r64a, r/m64, r64b + /// This intrinsic is only available on 64-bit processes /// public static ulong ZeroHighBits(ulong value, ulong index) => ZeroHighBits(value, index); /// - /// unsigned __int64 _mulx_u64 (unsigned __int64 a, unsigned __int64 b, unsigned __int64* hi) - /// MULX r64a, r64b, r/m64 - /// The above native signature does not directly correspond to the managed signature. - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mulx_u64 (unsigned __int64 a, unsigned __int64 b, unsigned __int64* hi) + /// MULX r64a, r64b, r/m64 + /// The above native signature does not directly correspond to the managed signature. + /// This intrinsic is only available on 64-bit processes /// public static ulong MultiplyNoFlags(ulong left, ulong right) => MultiplyNoFlags(left, right); /// - /// unsigned __int64 _mulx_u64 (unsigned __int64 a, unsigned __int64 b, unsigned __int64* hi) - /// MULX r64a, r64b, r/m64 - /// The above native signature does not directly correspond to the managed signature. - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mulx_u64 (unsigned __int64 a, unsigned __int64 b, unsigned __int64* hi) + /// MULX r64a, r64b, r/m64 + /// The above native signature does not directly correspond to the managed signature. + /// This intrinsic is only available on 64-bit processes /// public static unsafe ulong MultiplyNoFlags(ulong left, ulong right, ulong* low) => MultiplyNoFlags(left, right, low); /// - /// unsigned __int64 _pdep_u64 (unsigned __int64 a, unsigned __int64 mask) - /// PDEP r64a, r64b, r/m64 - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _pdep_u64 (unsigned __int64 a, unsigned __int64 mask) + /// PDEP r64a, r64b, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static ulong ParallelBitDeposit(ulong value, ulong mask) => ParallelBitDeposit(value, mask); /// - /// unsigned __int64 _pext_u64 (unsigned __int64 a, unsigned __int64 mask) - /// PEXT r64a, r64b, r/m64 - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _pext_u64 (unsigned __int64 a, unsigned __int64 mask) + /// PEXT r64a, r64b, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static ulong ParallelBitExtract(ulong value, ulong mask) => ParallelBitExtract(value, mask); } /// - /// unsigned int _bzhi_u32 (unsigned int a, unsigned int index) - /// BZHI r32a, r/m32, r32b + /// unsigned int _bzhi_u32 (unsigned int a, unsigned int index) + /// BZHI r32a, r/m32, r32b /// public static uint ZeroHighBits(uint value, uint index) => ZeroHighBits(value, index); /// - /// unsigned int _mulx_u32 (unsigned int a, unsigned int b, unsigned int* hi) - /// MULX r32a, r32b, r/m32 - /// The above native signature does not directly correspond to the managed signature. + /// unsigned int _mulx_u32 (unsigned int a, unsigned int b, unsigned int* hi) + /// MULX r32a, r32b, r/m32 + /// The above native signature does not directly correspond to the managed signature. /// public static uint MultiplyNoFlags(uint left, uint right) => MultiplyNoFlags(left, right); /// - /// unsigned int _mulx_u32 (unsigned int a, unsigned int b, unsigned int* hi) - /// MULX r32a, r32b, r/m32 - /// The above native signature does not directly correspond to the managed signature. + /// unsigned int _mulx_u32 (unsigned int a, unsigned int b, unsigned int* hi) + /// MULX r32a, r32b, r/m32 + /// The above native signature does not directly correspond to the managed signature. /// public static unsafe uint MultiplyNoFlags(uint left, uint right, uint* low) => MultiplyNoFlags(left, right, low); /// - /// unsigned int _pdep_u32 (unsigned int a, unsigned int mask) - /// PDEP r32a, r32b, r/m32 + /// unsigned int _pdep_u32 (unsigned int a, unsigned int mask) + /// PDEP r32a, r32b, r/m32 /// public static uint ParallelBitDeposit(uint value, uint mask) => ParallelBitDeposit(value, mask); /// - /// unsigned int _pext_u32 (unsigned int a, unsigned int mask) - /// PEXT r32a, r32b, r/m32 + /// unsigned int _pext_u32 (unsigned int a, unsigned int mask) + /// PEXT r32a, r32b, r/m32 /// public static uint ParallelBitExtract(uint value, uint mask) => ParallelBitExtract(value, mask); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Enums.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Enums.cs index ef5471d6ba4..ef39afd6cfb 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Enums.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Enums.cs @@ -5,184 +5,112 @@ namespace System.Runtime.Intrinsics.X86 { public enum FloatComparisonMode : byte { - /// - /// _CMP_EQ_OQ - /// + /// _CMP_EQ_OQ OrderedEqualNonSignaling = 0, - /// - /// _CMP_LT_OS - /// + /// _CMP_LT_OS OrderedLessThanSignaling = 1, - /// - /// _CMP_LE_OS - /// + /// _CMP_LE_OS OrderedLessThanOrEqualSignaling = 2, - /// - /// _CMP_UNORD_Q - /// + /// _CMP_UNORD_Q UnorderedNonSignaling = 3, - /// - /// _CMP_NEQ_UQ - /// + /// _CMP_NEQ_UQ UnorderedNotEqualNonSignaling = 4, - /// - /// _CMP_NLT_US - /// + /// _CMP_NLT_US UnorderedNotLessThanSignaling = 5, - /// - /// _CMP_NLE_US - /// + /// _CMP_NLE_US UnorderedNotLessThanOrEqualSignaling = 6, - /// - /// _CMP_ORD_Q - /// + /// _CMP_ORD_Q OrderedNonSignaling = 7, - /// - /// _CMP_EQ_UQ - /// + /// _CMP_EQ_UQ UnorderedEqualNonSignaling = 8, - /// - /// _CMP_NGE_US - /// + /// _CMP_NGE_US UnorderedNotGreaterThanOrEqualSignaling = 9, - /// - /// _CMP_NGT_US - /// + /// _CMP_NGT_US UnorderedNotGreaterThanSignaling = 10, - /// - /// _CMP_FALSE_OQ - /// + /// _CMP_FALSE_OQ OrderedFalseNonSignaling = 11, - /// - /// _CMP_NEQ_OQ - /// + /// _CMP_NEQ_OQ OrderedNotEqualNonSignaling = 12, - /// - /// _CMP_GE_OS - /// + /// _CMP_GE_OS OrderedGreaterThanOrEqualSignaling = 13, - /// - /// _CMP_GT_OS - /// + /// _CMP_GT_OS OrderedGreaterThanSignaling = 14, - /// - /// _CMP_TRUE_UQ - /// + /// _CMP_TRUE_UQ UnorderedTrueNonSignaling = 15, - /// - /// _CMP_EQ_OS - /// + /// _CMP_EQ_OS OrderedEqualSignaling = 16, - /// - /// _CMP_LT_OQ - /// + /// _CMP_LT_OQ OrderedLessThanNonSignaling = 17, - /// - /// _CMP_LE_OQ - /// + /// _CMP_LE_OQ OrderedLessThanOrEqualNonSignaling = 18, - /// - /// _CMP_UNORD_S - /// + /// _CMP_UNORD_S UnorderedSignaling = 19, - /// - /// _CMP_NEQ_US - /// + /// _CMP_NEQ_US UnorderedNotEqualSignaling = 20, - /// - /// _CMP_NLT_UQ - /// + /// _CMP_NLT_UQ UnorderedNotLessThanNonSignaling = 21, - /// - /// _CMP_NLE_UQ - /// + /// _CMP_NLE_UQ UnorderedNotLessThanOrEqualNonSignaling = 22, - /// - /// _CMP_ORD_S - /// + /// _CMP_ORD_S OrderedSignaling = 23, - /// - /// _CMP_EQ_US - /// + /// _CMP_EQ_US UnorderedEqualSignaling = 24, - /// - /// _CMP_NGE_UQ - /// + /// _CMP_NGE_UQ UnorderedNotGreaterThanOrEqualNonSignaling = 25, - /// - /// _CMP_NGT_UQ - /// + /// _CMP_NGT_UQ UnorderedNotGreaterThanNonSignaling = 26, - /// - /// _CMP_FALSE_OS - /// + /// _CMP_FALSE_OS OrderedFalseSignaling = 27, - /// - /// _CMP_NEQ_OS - /// + /// _CMP_NEQ_OS OrderedNotEqualSignaling = 28, - /// - /// _CMP_GE_OQ - /// + /// _CMP_GE_OQ OrderedGreaterThanOrEqualNonSignaling = 29, - /// - /// _CMP_GT_OQ - /// + /// _CMP_GT_OQ OrderedGreaterThanNonSignaling = 30, - /// - /// _CMP_TRUE_US - /// + /// _CMP_TRUE_US UnorderedTrueSignaling = 31, } public enum FloatRoundingMode : byte { - /// - /// _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC - /// + /// _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC ToEven = 0x08, - /// - /// _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC - /// + /// _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC ToNegativeInfinity = 0x09, - /// - /// _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC - /// + /// _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC ToPositiveInfinity = 0x0A, - /// - /// _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC - /// + /// _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC ToZero = 0x0B, } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Fma.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Fma.PlatformNotSupported.cs index 398f55f3c6b..eb7de91ad10 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Fma.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Fma.PlatformNotSupported.cs @@ -7,9 +7,7 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel FMA hardware instructions via intrinsics - /// + /// Provides access to X86 FMA hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Fma : Avx { @@ -17,6 +15,7 @@ internal Fma() { } public static new bool IsSupported { [Intrinsic] get { return false; } } + /// Provides access to the x86 FMA hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class X64 : Avx.X64 { internal X64() { } @@ -25,204 +24,204 @@ internal X64() { } } /// - /// __m128 _mm_fmadd_ps (__m128 a, __m128 b, __m128 c) - /// VFMADDPS xmm1, xmm2, xmm3/m128 - /// VFMADDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_fmadd_ps (__m128 a, __m128 b, __m128 c) + /// VFMADDPS xmm1, xmm2, xmm3/m128 + /// VFMADDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 MultiplyAdd(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_fmadd_pd (__m128d a, __m128d b, __m128d c) - /// VFMADDPD xmm1, xmm2, xmm3/m128 - /// VFMADDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_fmadd_pd (__m128d a, __m128d b, __m128d c) + /// VFMADDPD xmm1, xmm2, xmm3/m128 + /// VFMADDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiplyAdd(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_fmadd_ps (__m256 a, __m256 b, __m256 c) - /// VFMADDPS ymm1, ymm2, ymm3/m256 - /// VFMADDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_fmadd_ps (__m256 a, __m256 b, __m256 c) + /// VFMADDPS ymm1, ymm2, ymm3/m256 + /// VFMADDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 MultiplyAdd(Vector256 a, Vector256 b, Vector256 c) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_fmadd_pd (__m256d a, __m256d b, __m256d c) - /// VFMADDPD ymm1, ymm2, ymm3/m256 - /// VFMADDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_fmadd_pd (__m256d a, __m256d b, __m256d c) + /// VFMADDPD ymm1, ymm2, ymm3/m256 + /// VFMADDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiplyAdd(Vector256 a, Vector256 b, Vector256 c) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_fmadd_ss (__m128 a, __m128 b, __m128 c) - /// VFMADDSS xmm1, xmm2, xmm3/m32 - /// VFMADDSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} + /// __m128 _mm_fmadd_ss (__m128 a, __m128 b, __m128 c) + /// VFMADDSS xmm1, xmm2, xmm3/m32 + /// VFMADDSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} /// public static Vector128 MultiplyAddScalar(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_fmadd_sd (__m128d a, __m128d b, __m128d c) - /// VFMADDSD xmm1, xmm2, xmm3/m64 - /// VFMADDSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} + /// __m128d _mm_fmadd_sd (__m128d a, __m128d b, __m128d c) + /// VFMADDSD xmm1, xmm2, xmm3/m64 + /// VFMADDSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} /// public static Vector128 MultiplyAddScalar(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_fmaddsub_ps (__m128 a, __m128 b, __m128 c) - /// VFMADDSUBPS xmm1, xmm2, xmm3/m128 - /// VFMADDSUBPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_fmaddsub_ps (__m128 a, __m128 b, __m128 c) + /// VFMADDSUBPS xmm1, xmm2, xmm3/m128 + /// VFMADDSUBPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 MultiplyAddSubtract(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_fmaddsub_pd (__m128d a, __m128d b, __m128d c) - /// VFMADDSUBPD xmm1, xmm2, xmm3/m128 - /// VFMADDSUBPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_fmaddsub_pd (__m128d a, __m128d b, __m128d c) + /// VFMADDSUBPD xmm1, xmm2, xmm3/m128 + /// VFMADDSUBPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiplyAddSubtract(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_fmaddsub_ps (__m256 a, __m256 b, __m256 c) - /// VFMADDSUBPS ymm1, ymm2, ymm3/m256 - /// VFMADDSUBPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_fmaddsub_ps (__m256 a, __m256 b, __m256 c) + /// VFMADDSUBPS ymm1, ymm2, ymm3/m256 + /// VFMADDSUBPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 MultiplyAddSubtract(Vector256 a, Vector256 b, Vector256 c) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_fmaddsub_pd (__m256d a, __m256d b, __m256d c) - /// VFMADDSUBPD ymm1, ymm2, ymm3/m256 - /// VFMADDSUBPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_fmaddsub_pd (__m256d a, __m256d b, __m256d c) + /// VFMADDSUBPD ymm1, ymm2, ymm3/m256 + /// VFMADDSUBPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiplyAddSubtract(Vector256 a, Vector256 b, Vector256 c) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_fmsub_ps (__m128 a, __m128 b, __m128 c) - /// VFMSUBPS xmm1, xmm2, xmm3/m128 - /// VFMSUBPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_fmsub_ps (__m128 a, __m128 b, __m128 c) + /// VFMSUBPS xmm1, xmm2, xmm3/m128 + /// VFMSUBPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 MultiplySubtract(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_fmsub_pd (__m128d a, __m128d b, __m128d c) - /// VFMSUBPD xmm1, xmm2, xmm3/m128 - /// VFMSUBPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_fmsub_pd (__m128d a, __m128d b, __m128d c) + /// VFMSUBPD xmm1, xmm2, xmm3/m128 + /// VFMSUBPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiplySubtract(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_fmsub_ps (__m256 a, __m256 b, __m256 c) - /// VFMSUBPS ymm1, ymm2, ymm3/m256 - /// VFMSUBPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_fmsub_ps (__m256 a, __m256 b, __m256 c) + /// VFMSUBPS ymm1, ymm2, ymm3/m256 + /// VFMSUBPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 MultiplySubtract(Vector256 a, Vector256 b, Vector256 c) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_fmsub_pd (__m256d a, __m256d b, __m256d c) - /// VFMSUBPD ymm1, ymm2, ymm3/m256 - /// VFMSUBPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_fmsub_pd (__m256d a, __m256d b, __m256d c) + /// VFMSUBPD ymm1, ymm2, ymm3/m256 + /// VFMSUBPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiplySubtract(Vector256 a, Vector256 b, Vector256 c) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_fmsub_ss (__m128 a, __m128 b, __m128 c) - /// VFMSUBSS xmm1, xmm2, xmm3/m32 - /// VFMSUBSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} + /// __m128 _mm_fmsub_ss (__m128 a, __m128 b, __m128 c) + /// VFMSUBSS xmm1, xmm2, xmm3/m32 + /// VFMSUBSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} /// public static Vector128 MultiplySubtractScalar(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_fmsub_sd (__m128d a, __m128d b, __m128d c) - /// VFMSUBSD xmm1, xmm2, xmm3/m64 - /// VFMSUBSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} + /// __m128d _mm_fmsub_sd (__m128d a, __m128d b, __m128d c) + /// VFMSUBSD xmm1, xmm2, xmm3/m64 + /// VFMSUBSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} /// public static Vector128 MultiplySubtractScalar(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_fmsubadd_ps (__m128 a, __m128 b, __m128 c) - /// VFMSUBADDPS xmm1, xmm2, xmm3/m128 - /// VFMSUBADDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_fmsubadd_ps (__m128 a, __m128 b, __m128 c) + /// VFMSUBADDPS xmm1, xmm2, xmm3/m128 + /// VFMSUBADDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 MultiplySubtractAdd(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_fmsubadd_pd (__m128d a, __m128d b, __m128d c) - /// VFMSUBADDPD xmm1, xmm2, xmm3/m128 - /// VFMSUBADDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_fmsubadd_pd (__m128d a, __m128d b, __m128d c) + /// VFMSUBADDPD xmm1, xmm2, xmm3/m128 + /// VFMSUBADDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiplySubtractAdd(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_fmsubadd_ps (__m256 a, __m256 b, __m256 c) - /// VFMSUBADDPS ymm1, ymm2, ymm3/m256 - /// VFMSUBADDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_fmsubadd_ps (__m256 a, __m256 b, __m256 c) + /// VFMSUBADDPS ymm1, ymm2, ymm3/m256 + /// VFMSUBADDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 MultiplySubtractAdd(Vector256 a, Vector256 b, Vector256 c) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_fmsubadd_pd (__m256d a, __m256d b, __m256d c) - /// VFMSUBADDPD ymm1, ymm2, ymm3/m256 - /// VFMSUBADDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_fmsubadd_pd (__m256d a, __m256d b, __m256d c) + /// VFMSUBADDPD ymm1, ymm2, ymm3/m256 + /// VFMSUBADDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiplySubtractAdd(Vector256 a, Vector256 b, Vector256 c) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_fnmadd_ps (__m128 a, __m128 b, __m128 c) - /// VFNMADDPS xmm1, xmm2, xmm3/m128 - /// VFNMADDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_fnmadd_ps (__m128 a, __m128 b, __m128 c) + /// VFNMADDPS xmm1, xmm2, xmm3/m128 + /// VFNMADDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 MultiplyAddNegated(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_fnmadd_pd (__m128d a, __m128d b, __m128d c) - /// VFNMADDPD xmm1, xmm2, xmm3/m128 - /// VFNMADDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_fnmadd_pd (__m128d a, __m128d b, __m128d c) + /// VFNMADDPD xmm1, xmm2, xmm3/m128 + /// VFNMADDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiplyAddNegated(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_fnmadd_ps (__m256 a, __m256 b, __m256 c) - /// VFNMADDPS ymm1, ymm2, ymm3/m256 - /// VFNMADDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_fnmadd_ps (__m256 a, __m256 b, __m256 c) + /// VFNMADDPS ymm1, ymm2, ymm3/m256 + /// VFNMADDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 MultiplyAddNegated(Vector256 a, Vector256 b, Vector256 c) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_fnmadd_pd (__m256d a, __m256d b, __m256d c) - /// VFNMADDPD ymm1, ymm2, ymm3/m256 - /// VFNMADDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_fnmadd_pd (__m256d a, __m256d b, __m256d c) + /// VFNMADDPD ymm1, ymm2, ymm3/m256 + /// VFNMADDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiplyAddNegated(Vector256 a, Vector256 b, Vector256 c) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_fnmadd_ss (__m128 a, __m128 b, __m128 c) - /// VFNMADDSS xmm1, xmm2, xmm3/m32 - /// VFNMADDSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} + /// __m128 _mm_fnmadd_ss (__m128 a, __m128 b, __m128 c) + /// VFNMADDSS xmm1, xmm2, xmm3/m32 + /// VFNMADDSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} /// public static Vector128 MultiplyAddNegatedScalar(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_fnmadd_sd (__m128d a, __m128d b, __m128d c) - /// VFNMADDSD xmm1, xmm2, xmm3/m64 - /// VFNMADDSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} + /// __m128d _mm_fnmadd_sd (__m128d a, __m128d b, __m128d c) + /// VFNMADDSD xmm1, xmm2, xmm3/m64 + /// VFNMADDSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} /// public static Vector128 MultiplyAddNegatedScalar(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_fnmsub_ps (__m128 a, __m128 b, __m128 c) - /// VFNMSUBPS xmm1, xmm2, xmm3/m128 - /// VFNMSUBPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_fnmsub_ps (__m128 a, __m128 b, __m128 c) + /// VFNMSUBPS xmm1, xmm2, xmm3/m128 + /// VFNMSUBPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 MultiplySubtractNegated(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_fnmsub_pd (__m128d a, __m128d b, __m128d c) - /// VFNMSUBPD xmm1, xmm2, xmm3/m128 - /// VFNMSUBPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_fnmsub_pd (__m128d a, __m128d b, __m128d c) + /// VFNMSUBPD xmm1, xmm2, xmm3/m128 + /// VFNMSUBPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiplySubtractNegated(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } /// - /// __m256 _mm256_fnmsub_ps (__m256 a, __m256 b, __m256 c) - /// VFNMSUBPS ymm1, ymm2, ymm3/m256 - /// VFNMSUBPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_fnmsub_ps (__m256 a, __m256 b, __m256 c) + /// VFNMSUBPS ymm1, ymm2, ymm3/m256 + /// VFNMSUBPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 MultiplySubtractNegated(Vector256 a, Vector256 b, Vector256 c) { throw new PlatformNotSupportedException(); } /// - /// __m256d _mm256_fnmsub_pd (__m256d a, __m256d b, __m256d c) - /// VFNMSUBPD ymm1, ymm2, ymm3/m256 - /// VFNMSUBPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_fnmsub_pd (__m256d a, __m256d b, __m256d c) + /// VFNMSUBPD ymm1, ymm2, ymm3/m256 + /// VFNMSUBPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiplySubtractNegated(Vector256 a, Vector256 b, Vector256 c) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_fnmsub_ss (__m128 a, __m128 b, __m128 c) - /// VFNMSUBSS xmm1, xmm2, xmm3/m32 - /// VFNMSUBSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} + /// __m128 _mm_fnmsub_ss (__m128 a, __m128 b, __m128 c) + /// VFNMSUBSS xmm1, xmm2, xmm3/m32 + /// VFNMSUBSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} /// public static Vector128 MultiplySubtractNegatedScalar(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_fnmsub_sd (__m128d a, __m128d b, __m128d c) - /// VFNMSUBSD xmm1, xmm2, xmm3/m64 - /// VFNMSUBSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} + /// __m128d _mm_fnmsub_sd (__m128d a, __m128d b, __m128d c) + /// VFNMSUBSD xmm1, xmm2, xmm3/m64 + /// VFNMSUBSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} /// public static Vector128 MultiplySubtractNegatedScalar(Vector128 a, Vector128 b, Vector128 c) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Fma.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Fma.cs index f1549932e8a..71eeca4bb05 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Fma.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Fma.cs @@ -5,224 +5,229 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel FMA hardware instructions via intrinsics - /// + /// Provides access to X86 FMA hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Fma : Avx { internal Fma() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the x86 FMA hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : Avx.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } } /// - /// __m128 _mm_fmadd_ps (__m128 a, __m128 b, __m128 c) - /// VFMADDPS xmm1, xmm2, xmm3/m128 - /// VFMADDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_fmadd_ps (__m128 a, __m128 b, __m128 c) + /// VFMADDPS xmm1, xmm2, xmm3/m128 + /// VFMADDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 MultiplyAdd(Vector128 a, Vector128 b, Vector128 c) => MultiplyAdd(a, b, c); /// - /// __m128d _mm_fmadd_pd (__m128d a, __m128d b, __m128d c) - /// VFMADDPD xmm1, xmm2, xmm3/m128 - /// VFMADDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_fmadd_pd (__m128d a, __m128d b, __m128d c) + /// VFMADDPD xmm1, xmm2, xmm3/m128 + /// VFMADDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiplyAdd(Vector128 a, Vector128 b, Vector128 c) => MultiplyAdd(a, b, c); /// - /// __m256 _mm256_fmadd_ps (__m256 a, __m256 b, __m256 c) - /// VFMADDPS ymm1, ymm2, ymm3/m256 - /// VFMADDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_fmadd_ps (__m256 a, __m256 b, __m256 c) + /// VFMADDPS ymm1, ymm2, ymm3/m256 + /// VFMADDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 MultiplyAdd(Vector256 a, Vector256 b, Vector256 c) => MultiplyAdd(a, b, c); /// - /// __m256d _mm256_fmadd_pd (__m256d a, __m256d b, __m256d c) - /// VFMADDPD ymm1, ymm2, ymm3/m256 - /// VFMADDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_fmadd_pd (__m256d a, __m256d b, __m256d c) + /// VFMADDPD ymm1, ymm2, ymm3/m256 + /// VFMADDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiplyAdd(Vector256 a, Vector256 b, Vector256 c) => MultiplyAdd(a, b, c); /// - /// __m128 _mm_fmadd_ss (__m128 a, __m128 b, __m128 c) - /// VFMADDSS xmm1, xmm2, xmm3/m32 - /// VFMADDSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} + /// __m128 _mm_fmadd_ss (__m128 a, __m128 b, __m128 c) + /// VFMADDSS xmm1, xmm2, xmm3/m32 + /// VFMADDSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} /// public static Vector128 MultiplyAddScalar(Vector128 a, Vector128 b, Vector128 c) => MultiplyAddScalar(a, b, c); /// - /// __m128d _mm_fmadd_sd (__m128d a, __m128d b, __m128d c) - /// VFMADDSD xmm1, xmm2, xmm3/m64 - /// VFMADDSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} + /// __m128d _mm_fmadd_sd (__m128d a, __m128d b, __m128d c) + /// VFMADDSD xmm1, xmm2, xmm3/m64 + /// VFMADDSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} /// public static Vector128 MultiplyAddScalar(Vector128 a, Vector128 b, Vector128 c) => MultiplyAddScalar(a, b, c); /// - /// __m128 _mm_fmaddsub_ps (__m128 a, __m128 b, __m128 c) - /// VFMADDSUBPS xmm1, xmm2, xmm3/m128 - /// VFMADDSUBPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_fmaddsub_ps (__m128 a, __m128 b, __m128 c) + /// VFMADDSUBPS xmm1, xmm2, xmm3/m128 + /// VFMADDSUBPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 MultiplyAddSubtract(Vector128 a, Vector128 b, Vector128 c) => MultiplyAddSubtract(a, b, c); /// - /// __m128d _mm_fmaddsub_pd (__m128d a, __m128d b, __m128d c) - /// VFMADDSUBPD xmm1, xmm2, xmm3/m128 - /// VFMADDSUBPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_fmaddsub_pd (__m128d a, __m128d b, __m128d c) + /// VFMADDSUBPD xmm1, xmm2, xmm3/m128 + /// VFMADDSUBPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiplyAddSubtract(Vector128 a, Vector128 b, Vector128 c) => MultiplyAddSubtract(a, b, c); /// - /// __m256 _mm256_fmaddsub_ps (__m256 a, __m256 b, __m256 c) - /// VFMADDSUBPS ymm1, ymm2, ymm3/m256 - /// VFMADDSUBPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_fmaddsub_ps (__m256 a, __m256 b, __m256 c) + /// VFMADDSUBPS ymm1, ymm2, ymm3/m256 + /// VFMADDSUBPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 MultiplyAddSubtract(Vector256 a, Vector256 b, Vector256 c) => MultiplyAddSubtract(a, b, c); /// - /// __m256d _mm256_fmaddsub_pd (__m256d a, __m256d b, __m256d c) - /// VFMADDSUBPD ymm1, ymm2, ymm3/m256 - /// VFMADDSUBPD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256d _mm256_fmaddsub_pd (__m256d a, __m256d b, __m256d c) + /// VFMADDSUBPD ymm1, ymm2, ymm3/m256 + /// VFMADDSUBPD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 MultiplyAddSubtract(Vector256 a, Vector256 b, Vector256 c) => MultiplyAddSubtract(a, b, c); /// - /// __m128 _mm_fmsub_ps (__m128 a, __m128 b, __m128 c) - /// VFMSUBPS xmm1, xmm2, xmm3/m128 - /// VFMSUBPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_fmsub_ps (__m128 a, __m128 b, __m128 c) + /// VFMSUBPS xmm1, xmm2, xmm3/m128 + /// VFMSUBPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 MultiplySubtract(Vector128 a, Vector128 b, Vector128 c) => MultiplySubtract(a, b, c); /// - /// __m128d _mm_fmsub_pd (__m128d a, __m128d b, __m128d c) - /// VFMSUBPD xmm1, xmm2, xmm3/m128 - /// VFMSUBPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_fmsub_pd (__m128d a, __m128d b, __m128d c) + /// VFMSUBPD xmm1, xmm2, xmm3/m128 + /// VFMSUBPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiplySubtract(Vector128 a, Vector128 b, Vector128 c) => MultiplySubtract(a, b, c); /// - /// __m256 _mm256_fmsub_ps (__m256 a, __m256 b, __m256 c) - /// VFMSUBPS ymm1, ymm2, ymm3/m256 - /// VFMSUBPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_fmsub_ps (__m256 a, __m256 b, __m256 c) + /// VFMSUBPS ymm1, ymm2, ymm3/m256 + /// VFMSUBPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 MultiplySubtract(Vector256 a, Vector256 b, Vector256 c) => MultiplySubtract(a, b, c); /// - /// __m256d _mm256_fmsub_pd (__m256d a, __m256d b, __m256d c) - /// VFMSUBPD ymm1, ymm2, ymm3/m256 - /// VFMSUBPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_fmsub_pd (__m256d a, __m256d b, __m256d c) + /// VFMSUBPD ymm1, ymm2, ymm3/m256 + /// VFMSUBPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiplySubtract(Vector256 a, Vector256 b, Vector256 c) => MultiplySubtract(a, b, c); /// - /// __m128 _mm_fmsub_ss (__m128 a, __m128 b, __m128 c) - /// VFMSUBSS xmm1, xmm2, xmm3/m32 - /// VFMSUBSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} + /// __m128 _mm_fmsub_ss (__m128 a, __m128 b, __m128 c) + /// VFMSUBSS xmm1, xmm2, xmm3/m32 + /// VFMSUBSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} /// public static Vector128 MultiplySubtractScalar(Vector128 a, Vector128 b, Vector128 c) => MultiplySubtractScalar(a, b, c); /// - /// __m128d _mm_fmsub_sd (__m128d a, __m128d b, __m128d c) - /// VFMSUBSD xmm1, xmm2, xmm3/m64 - /// VFMSUBSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} + /// __m128d _mm_fmsub_sd (__m128d a, __m128d b, __m128d c) + /// VFMSUBSD xmm1, xmm2, xmm3/m64 + /// VFMSUBSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} /// public static Vector128 MultiplySubtractScalar(Vector128 a, Vector128 b, Vector128 c) => MultiplySubtractScalar(a, b, c); /// - /// __m128 _mm_fmsubadd_ps (__m128 a, __m128 b, __m128 c) - /// VFMSUBADDPS xmm1, xmm2, xmm3/m128 - /// VFMSUBADDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_fmsubadd_ps (__m128 a, __m128 b, __m128 c) + /// VFMSUBADDPS xmm1, xmm2, xmm3/m128 + /// VFMSUBADDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 MultiplySubtractAdd(Vector128 a, Vector128 b, Vector128 c) => MultiplySubtractAdd(a, b, c); /// - /// __m128d _mm_fmsubadd_pd (__m128d a, __m128d b, __m128d c) - /// VFMSUBADDPD xmm1, xmm2, xmm3/m128 - /// VFMSUBADDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_fmsubadd_pd (__m128d a, __m128d b, __m128d c) + /// VFMSUBADDPD xmm1, xmm2, xmm3/m128 + /// VFMSUBADDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiplySubtractAdd(Vector128 a, Vector128 b, Vector128 c) => MultiplySubtractAdd(a, b, c); /// - /// __m256 _mm256_fmsubadd_ps (__m256 a, __m256 b, __m256 c) - /// VFMSUBADDPS ymm1, ymm2, ymm3/m256 - /// VFMSUBADDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_fmsubadd_ps (__m256 a, __m256 b, __m256 c) + /// VFMSUBADDPS ymm1, ymm2, ymm3/m256 + /// VFMSUBADDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 MultiplySubtractAdd(Vector256 a, Vector256 b, Vector256 c) => MultiplySubtractAdd(a, b, c); /// - /// __m256d _mm256_fmsubadd_pd (__m256d a, __m256d b, __m256d c) - /// VFMSUBADDPD ymm1, ymm2, ymm3/m256 - /// VFMSUBADDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_fmsubadd_pd (__m256d a, __m256d b, __m256d c) + /// VFMSUBADDPD ymm1, ymm2, ymm3/m256 + /// VFMSUBADDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiplySubtractAdd(Vector256 a, Vector256 b, Vector256 c) => MultiplySubtractAdd(a, b, c); /// - /// __m128 _mm_fnmadd_ps (__m128 a, __m128 b, __m128 c) - /// VFNMADDPS xmm1, xmm2, xmm3/m128 - /// VFNMADDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_fnmadd_ps (__m128 a, __m128 b, __m128 c) + /// VFNMADDPS xmm1, xmm2, xmm3/m128 + /// VFNMADDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 MultiplyAddNegated(Vector128 a, Vector128 b, Vector128 c) => MultiplyAddNegated(a, b, c); /// - /// __m128d _mm_fnmadd_pd (__m128d a, __m128d b, __m128d c) - /// VFNMADDPD xmm1, xmm2, xmm3/m128 - /// VFNMADDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_fnmadd_pd (__m128d a, __m128d b, __m128d c) + /// VFNMADDPD xmm1, xmm2, xmm3/m128 + /// VFNMADDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiplyAddNegated(Vector128 a, Vector128 b, Vector128 c) => MultiplyAddNegated(a, b, c); /// - /// __m256 _mm256_fnmadd_ps (__m256 a, __m256 b, __m256 c) - /// VFNMADDPS ymm1, ymm2, ymm3/m256 - /// VFNMADDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_fnmadd_ps (__m256 a, __m256 b, __m256 c) + /// VFNMADDPS ymm1, ymm2, ymm3/m256 + /// VFNMADDPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 MultiplyAddNegated(Vector256 a, Vector256 b, Vector256 c) => MultiplyAddNegated(a, b, c); /// - /// __m256d _mm256_fnmadd_pd (__m256d a, __m256d b, __m256d c) - /// VFNMADDPD ymm1, ymm2, ymm3/m256 - /// VFNMADDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_fnmadd_pd (__m256d a, __m256d b, __m256d c) + /// VFNMADDPD ymm1, ymm2, ymm3/m256 + /// VFNMADDPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiplyAddNegated(Vector256 a, Vector256 b, Vector256 c) => MultiplyAddNegated(a, b, c); /// - /// __m128 _mm_fnmadd_ss (__m128 a, __m128 b, __m128 c) - /// VFNMADDSS xmm1, xmm2, xmm3/m32 - /// VFNMADDSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} + /// __m128 _mm_fnmadd_ss (__m128 a, __m128 b, __m128 c) + /// VFNMADDSS xmm1, xmm2, xmm3/m32 + /// VFNMADDSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} /// public static Vector128 MultiplyAddNegatedScalar(Vector128 a, Vector128 b, Vector128 c) => MultiplyAddNegatedScalar(a, b, c); /// - /// __m128d _mm_fnmadd_sd (__m128d a, __m128d b, __m128d c) - /// VFNMADDSD xmm1, xmm2, xmm3/m64 - /// VFNMADDSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} + /// __m128d _mm_fnmadd_sd (__m128d a, __m128d b, __m128d c) + /// VFNMADDSD xmm1, xmm2, xmm3/m64 + /// VFNMADDSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} /// public static Vector128 MultiplyAddNegatedScalar(Vector128 a, Vector128 b, Vector128 c) => MultiplyAddNegatedScalar(a, b, c); /// - /// __m128 _mm_fnmsub_ps (__m128 a, __m128 b, __m128 c) - /// VFNMSUBPS xmm1, xmm2, xmm3/m128 - /// VFNMSUBPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_fnmsub_ps (__m128 a, __m128 b, __m128 c) + /// VFNMSUBPS xmm1, xmm2, xmm3/m128 + /// VFNMSUBPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 MultiplySubtractNegated(Vector128 a, Vector128 b, Vector128 c) => MultiplySubtractNegated(a, b, c); /// - /// __m128d _mm_fnmsub_pd (__m128d a, __m128d b, __m128d c) - /// VFNMSUBPD xmm1, xmm2, xmm3/m128 - /// VFNMSUBPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_fnmsub_pd (__m128d a, __m128d b, __m128d c) + /// VFNMSUBPD xmm1, xmm2, xmm3/m128 + /// VFNMSUBPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 MultiplySubtractNegated(Vector128 a, Vector128 b, Vector128 c) => MultiplySubtractNegated(a, b, c); /// - /// __m256 _mm256_fnmsub_ps (__m256 a, __m256 b, __m256 c) - /// VFNMSUBPS ymm1, ymm2, ymm3/m256 - /// VFNMSUBPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst + /// __m256 _mm256_fnmsub_ps (__m256 a, __m256 b, __m256 c) + /// VFNMSUBPS ymm1, ymm2, ymm3/m256 + /// VFNMSUBPS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst /// public static Vector256 MultiplySubtractNegated(Vector256 a, Vector256 b, Vector256 c) => MultiplySubtractNegated(a, b, c); /// - /// __m256d _mm256_fnmsub_pd (__m256d a, __m256d b, __m256d c) - /// VFNMSUBPD ymm1, ymm2, ymm3/m256 - /// VFNMSUBPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst + /// __m256d _mm256_fnmsub_pd (__m256d a, __m256d b, __m256d c) + /// VFNMSUBPD ymm1, ymm2, ymm3/m256 + /// VFNMSUBPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst /// public static Vector256 MultiplySubtractNegated(Vector256 a, Vector256 b, Vector256 c) => MultiplySubtractNegated(a, b, c); /// - /// __m128 _mm_fnmsub_ss (__m128 a, __m128 b, __m128 c) - /// VFNMSUBSS xmm1, xmm2, xmm3/m32 - /// VFNMSUBSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} + /// __m128 _mm_fnmsub_ss (__m128 a, __m128 b, __m128 c) + /// VFNMSUBSS xmm1, xmm2, xmm3/m32 + /// VFNMSUBSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} /// public static Vector128 MultiplySubtractNegatedScalar(Vector128 a, Vector128 b, Vector128 c) => MultiplySubtractNegatedScalar(a, b, c); /// - /// __m128d _mm_fnmsub_sd (__m128d a, __m128d b, __m128d c) - /// VFNMSUBSD xmm1, xmm2, xmm3/m64 - /// VFNMSUBSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} + /// __m128d _mm_fnmsub_sd (__m128d a, __m128d b, __m128d c) + /// VFNMSUBSD xmm1, xmm2, xmm3/m64 + /// VFNMSUBSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} /// public static Vector128 MultiplySubtractNegatedScalar(Vector128 a, Vector128 b, Vector128 c) => MultiplySubtractNegatedScalar(a, b, c); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Lzcnt.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Lzcnt.PlatformNotSupported.cs index f15deb98b68..053844bca42 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Lzcnt.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Lzcnt.PlatformNotSupported.cs @@ -6,33 +6,38 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel LZCNT hardware instructions via intrinsics - /// + /// Provides access to X86 LZCNT hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Lzcnt : X86Base { internal Lzcnt() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } + /// Provides access to the x86 LZCNT hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class X64 : X86Base.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } /// - /// unsigned __int64 _lzcnt_u64 (unsigned __int64 a) - /// LZCNT r64, r/m64 - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _lzcnt_u64 (unsigned __int64 a) + /// LZCNT r64, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static ulong LeadingZeroCount(ulong value) { throw new PlatformNotSupportedException(); } } /// - /// unsigned int _lzcnt_u32 (unsigned int a) - /// LZCNT r32, r/m32 + /// unsigned int _lzcnt_u32 (unsigned int a) + /// LZCNT r32, r/m32 /// public static uint LeadingZeroCount(uint value) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Lzcnt.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Lzcnt.cs index 4fdfabd8189..67405a60bf6 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Lzcnt.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Lzcnt.cs @@ -5,35 +5,40 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel LZCNT hardware instructions via intrinsics - /// + /// Provides access to X86 LZCNT hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Lzcnt : X86Base { internal Lzcnt() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the x86 LZCNT hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : X86Base.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } /// - /// unsigned __int64 _lzcnt_u64 (unsigned __int64 a) - /// LZCNT r64, r/m64 - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _lzcnt_u64 (unsigned __int64 a) + /// LZCNT r64, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static ulong LeadingZeroCount(ulong value) => LeadingZeroCount(value); } /// - /// unsigned int _lzcnt_u32 (unsigned int a) - /// LZCNT r32, r/m32 + /// unsigned int _lzcnt_u32 (unsigned int a) + /// LZCNT r32, r/m32 /// public static uint LeadingZeroCount(uint value) => LeadingZeroCount(value); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.PlatformNotSupported.cs index a815701bc83..c9111f801ec 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.PlatformNotSupported.cs @@ -8,33 +8,38 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel PCLMULQDQ hardware instructions via intrinsics - /// + /// Provides access to X86 CLMUL hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Pclmulqdq : Sse2 { internal Pclmulqdq() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } + /// Provides access to the x86 CLMUL hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class X64 : Sse2.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } } /// - /// __m128i _mm_clmulepi64_si128 (__m128i a, __m128i b, const int imm8) - /// PCLMULQDQ xmm1, xmm2/m128, imm8 - /// VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8 + /// __m128i _mm_clmulepi64_si128 (__m128i a, __m128i b, const int imm8) + /// PCLMULQDQ xmm1, xmm2/m128, imm8 + /// VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8 /// public static Vector128 CarrylessMultiply(Vector128 left, Vector128 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_clmulepi64_si128 (__m128i a, __m128i b, const int imm8) - /// PCLMULQDQ xmm1, xmm2/m128, imm8 - /// VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8 + /// __m128i _mm_clmulepi64_si128 (__m128i a, __m128i b, const int imm8) + /// PCLMULQDQ xmm1, xmm2/m128, imm8 + /// VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8 /// public static Vector128 CarrylessMultiply(Vector128 left, Vector128 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.cs index aa1c3d21b8c..9cc213f0f98 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Pclmulqdq.cs @@ -6,35 +6,40 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel PCLMULQDQ hardware instructions via intrinsics - /// + /// Provides access to X86 CLMUL hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Pclmulqdq : Sse2 { internal Pclmulqdq() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the x86 CLMUL hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : Sse2.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } } /// - /// __m128i _mm_clmulepi64_si128 (__m128i a, __m128i b, const int imm8) - /// PCLMULQDQ xmm1, xmm2/m128, imm8 - /// VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8 + /// __m128i _mm_clmulepi64_si128 (__m128i a, __m128i b, const int imm8) + /// PCLMULQDQ xmm1, xmm2/m128, imm8 + /// VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8 /// public static Vector128 CarrylessMultiply(Vector128 left, Vector128 right, [ConstantExpected] byte control) => CarrylessMultiply(left, right, control); /// - /// __m128i _mm_clmulepi64_si128 (__m128i a, __m128i b, const int imm8) - /// PCLMULQDQ xmm1, xmm2/m128, imm8 - /// VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8 + /// __m128i _mm_clmulepi64_si128 (__m128i a, __m128i b, const int imm8) + /// PCLMULQDQ xmm1, xmm2/m128, imm8 + /// VPCLMULQDQ xmm1, xmm2, xmm3/m128, imm8 /// public static Vector128 CarrylessMultiply(Vector128 left, Vector128 right, [ConstantExpected] byte control) => CarrylessMultiply(left, right, control); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Popcnt.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Popcnt.PlatformNotSupported.cs index bd979943225..8d0550073b3 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Popcnt.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Popcnt.PlatformNotSupported.cs @@ -6,33 +6,38 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel POPCNT hardware instructions via intrinsics - /// + /// Provides access to X86 POPCNT hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Popcnt : Sse42 { internal Popcnt() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } + /// Provides access to the x86 POPCNT hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class X64 : Sse42.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } /// - /// __int64 _mm_popcnt_u64 (unsigned __int64 a) - /// POPCNT r64, r/m64 - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_popcnt_u64 (unsigned __int64 a) + /// POPCNT r64, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static ulong PopCount(ulong value) { throw new PlatformNotSupportedException(); } } /// - /// int _mm_popcnt_u32 (unsigned int a) - /// POPCNT r32, r/m32 + /// int _mm_popcnt_u32 (unsigned int a) + /// POPCNT r32, r/m32 /// public static uint PopCount(uint value) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Popcnt.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Popcnt.cs index c04de74cefc..4345b938d6c 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Popcnt.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Popcnt.cs @@ -5,35 +5,40 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel POPCNT hardware instructions via intrinsics - /// + /// Provides access to X86 POPCNT hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Popcnt : Sse42 { internal Popcnt() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the x86 POPCNT hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : Sse42.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } /// - /// __int64 _mm_popcnt_u64 (unsigned __int64 a) - /// POPCNT r64, r/m64 - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_popcnt_u64 (unsigned __int64 a) + /// POPCNT r64, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static ulong PopCount(ulong value) => PopCount(value); } /// - /// int _mm_popcnt_u32 (unsigned int a) - /// POPCNT r32, r/m32 + /// int _mm_popcnt_u32 (unsigned int a) + /// POPCNT r32, r/m32 /// public static uint PopCount(uint value) => PopCount(value); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse.PlatformNotSupported.cs index c512bc4246f..f732f500d45 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse.PlatformNotSupported.cs @@ -8,636 +8,641 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel SSE hardware instructions via intrinsics - /// + /// Provides access to X86 SSE hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Sse : X86Base { internal Sse() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } + /// Provides access to the x86 SSE hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class X64 : X86Base.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } /// - /// __m128 _mm_cvtsi64_ss (__m128 a, __int64 b) - /// CVTSI2SS xmm1, r/m64 - /// VCVTSI2SS xmm1, xmm2, r/m64 - /// This intrinsic is only available on 64-bit processes + /// __m128 _mm_cvtsi64_ss (__m128 a, __int64 b) + /// CVTSI2SS xmm1, r/m64 + /// VCVTSI2SS xmm1, xmm2, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, long value) { throw new PlatformNotSupportedException(); } /// - /// __int64 _mm_cvtss_si64 (__m128 a) - /// CVTSS2SI r64, xmm1/m32 - /// VCVTSS2SI r64, xmm1/m32 - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_cvtss_si64 (__m128 a) + /// CVTSS2SI r64, xmm1/m32 + /// VCVTSS2SI r64, xmm1/m32 + /// This intrinsic is only available on 64-bit processes /// public static long ConvertToInt64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __int64 _mm_cvttss_si64 (__m128 a) - /// CVTTSS2SI r64, xmm1/m32 - /// VCVTTSS2SI r64, xmm1/m32 - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_cvttss_si64 (__m128 a) + /// CVTTSS2SI r64, xmm1/m32 + /// VCVTTSS2SI r64, xmm1/m32 + /// This intrinsic is only available on 64-bit processes /// public static long ConvertToInt64WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } } /// - /// __m128 _mm_add_ps (__m128 a, __m128 b) - /// ADDPS xmm1, xmm2/m128 - /// VADDPS xmm1, xmm2, xmm3/m128 - /// VADDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_add_ps (__m128 a, __m128 b) + /// ADDPS xmm1, xmm2/m128 + /// VADDPS xmm1, xmm2, xmm3/m128 + /// VADDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_add_ss (__m128 a, __m128 b) - /// ADDSS xmm1, xmm2/m32 - /// VADDSS xmm1, xmm2, xmm3/m32 - /// VADDSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} + /// __m128 _mm_add_ss (__m128 a, __m128 b) + /// ADDSS xmm1, xmm2/m32 + /// VADDSS xmm1, xmm2, xmm3/m32 + /// VADDSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} /// public static Vector128 AddScalar(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_and_ps (__m128 a, __m128 b) - /// ANDPS xmm1, xmm2/m128 - /// VANDPS xmm1, xmm2, xmm3/m128 - /// VANDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_and_ps (__m128 a, __m128 b) + /// ANDPS xmm1, xmm2/m128 + /// VANDPS xmm1, xmm2, xmm3/m128 + /// VANDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_andnot_ps (__m128 a, __m128 b) - /// ANDNPS xmm1, xmm2/m128 - /// VANDNPS xmm1, xmm2, xmm3/m128 - /// VANDNPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_andnot_ps (__m128 a, __m128 b) + /// ANDNPS xmm1, xmm2/m128 + /// VANDNPS xmm1, xmm2, xmm3/m128 + /// VANDNPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmpeq_ps (__m128 a, __m128 b) - /// CMPPS xmm1, xmm2/m128, imm8(0) - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(0) + /// __m128 _mm_cmpeq_ps (__m128 a, __m128 b) + /// CMPPS xmm1, xmm2/m128, imm8(0) + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(0) /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmpgt_ps (__m128 a, __m128 b) - /// CMPPS xmm1, xmm2/m128, imm8(1) ; with swapped operands - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(1) ; with swapped operands + /// __m128 _mm_cmpgt_ps (__m128 a, __m128 b) + /// CMPPS xmm1, xmm2/m128, imm8(1) ; with swapped operands + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(1) ; with swapped operands /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmpge_ps (__m128 a, __m128 b) - /// CMPPS xmm1, xmm2/m128, imm8(2) ; with swapped operands - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(2) ; with swapped operands + /// __m128 _mm_cmpge_ps (__m128 a, __m128 b) + /// CMPPS xmm1, xmm2/m128, imm8(2) ; with swapped operands + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(2) ; with swapped operands /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmplt_ps (__m128 a, __m128 b) - /// CMPPS xmm1, xmm2/m128, imm8(1) - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(1) + /// __m128 _mm_cmplt_ps (__m128 a, __m128 b) + /// CMPPS xmm1, xmm2/m128, imm8(1) + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmple_ps (__m128 a, __m128 b) - /// CMPPS xmm1, xmm2/m128, imm8(2) - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(2) + /// __m128 _mm_cmple_ps (__m128 a, __m128 b) + /// CMPPS xmm1, xmm2/m128, imm8(2) + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmpneq_ps (__m128 a, __m128 b) - /// CMPPS xmm1, xmm2/m128, imm8(4) - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(4) + /// __m128 _mm_cmpneq_ps (__m128 a, __m128 b) + /// CMPPS xmm1, xmm2/m128, imm8(4) + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmpngt_ps (__m128 a, __m128 b) - /// CMPPS xmm1, xmm2/m128, imm8(5) ; with swapped operands - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(5) ; with swapped operands + /// __m128 _mm_cmpngt_ps (__m128 a, __m128 b) + /// CMPPS xmm1, xmm2/m128, imm8(5) ; with swapped operands + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(5) ; with swapped operands /// public static Vector128 CompareNotGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmpnge_ps (__m128 a, __m128 b) - /// CMPPS xmm1, xmm2/m128, imm8(6) ; with swapped operands - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(6) ; with swapped operands + /// __m128 _mm_cmpnge_ps (__m128 a, __m128 b) + /// CMPPS xmm1, xmm2/m128, imm8(6) ; with swapped operands + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(6) ; with swapped operands /// public static Vector128 CompareNotGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmpnlt_ps (__m128 a, __m128 b) - /// CMPPS xmm1, xmm2/m128, imm8(5) - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(5) + /// __m128 _mm_cmpnlt_ps (__m128 a, __m128 b) + /// CMPPS xmm1, xmm2/m128, imm8(5) + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(5) /// public static Vector128 CompareNotLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmpnle_ps (__m128 a, __m128 b) - /// CMPPS xmm1, xmm2/m128, imm8(6) - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(6) + /// __m128 _mm_cmpnle_ps (__m128 a, __m128 b) + /// CMPPS xmm1, xmm2/m128, imm8(6) + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(6) /// public static Vector128 CompareNotLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmpord_ps (__m128 a, __m128 b) - /// CMPPS xmm1, xmm2/m128, imm8(7) - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(7) + /// __m128 _mm_cmpord_ps (__m128 a, __m128 b) + /// CMPPS xmm1, xmm2/m128, imm8(7) + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(7) /// public static Vector128 CompareOrdered(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmpeq_ss (__m128 a, __m128 b) - /// CMPSS xmm1, xmm2/m32, imm8(0) - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(0) + /// __m128 _mm_cmpeq_ss (__m128 a, __m128 b) + /// CMPSS xmm1, xmm2/m32, imm8(0) + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(0) /// public static Vector128 CompareScalarEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmpgt_ss (__m128 a, __m128 b) - /// CMPSS xmm1, xmm2/m32, imm8(1) ; with swapped operands - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(1) ; with swapped operands + /// __m128 _mm_cmpgt_ss (__m128 a, __m128 b) + /// CMPSS xmm1, xmm2/m32, imm8(1) ; with swapped operands + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(1) ; with swapped operands /// public static Vector128 CompareScalarGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmpge_ss (__m128 a, __m128 b) - /// CMPSS xmm1, xmm2/m32, imm8(2) ; with swapped operands - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(2) ; with swapped operands + /// __m128 _mm_cmpge_ss (__m128 a, __m128 b) + /// CMPSS xmm1, xmm2/m32, imm8(2) ; with swapped operands + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(2) ; with swapped operands /// public static Vector128 CompareScalarGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmplt_ss (__m128 a, __m128 b) - /// CMPSS xmm1, xmm2/m32, imm8(1) - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(1) + /// __m128 _mm_cmplt_ss (__m128 a, __m128 b) + /// CMPSS xmm1, xmm2/m32, imm8(1) + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(1) /// public static Vector128 CompareScalarLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmple_ss (__m128 a, __m128 b) - /// CMPSS xmm1, xmm2/m32, imm8(2) - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(2) + /// __m128 _mm_cmple_ss (__m128 a, __m128 b) + /// CMPSS xmm1, xmm2/m32, imm8(2) + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(2) /// public static Vector128 CompareScalarLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmpneq_ss (__m128 a, __m128 b) - /// CMPSS xmm1, xmm2/m32, imm8(4) - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(4) + /// __m128 _mm_cmpneq_ss (__m128 a, __m128 b) + /// CMPSS xmm1, xmm2/m32, imm8(4) + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(4) /// public static Vector128 CompareScalarNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmpngt_ss (__m128 a, __m128 b) - /// CMPSS xmm1, xmm2/m32, imm8(5) ; with swapped operands - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(5) ; with swapped operands + /// __m128 _mm_cmpngt_ss (__m128 a, __m128 b) + /// CMPSS xmm1, xmm2/m32, imm8(5) ; with swapped operands + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(5) ; with swapped operands /// public static Vector128 CompareScalarNotGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmpnge_ss (__m128 a, __m128 b) - /// CMPSS xmm1, xmm2/m32, imm8(6) ; with swapped operands - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(6) ; with swapped operands + /// __m128 _mm_cmpnge_ss (__m128 a, __m128 b) + /// CMPSS xmm1, xmm2/m32, imm8(6) ; with swapped operands + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(6) ; with swapped operands /// public static Vector128 CompareScalarNotGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmpnlt_ss (__m128 a, __m128 b) - /// CMPSS xmm1, xmm2/m32, imm8(5) - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(5) + /// __m128 _mm_cmpnlt_ss (__m128 a, __m128 b) + /// CMPSS xmm1, xmm2/m32, imm8(5) + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(5) /// public static Vector128 CompareScalarNotLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmpnle_ss (__m128 a, __m128 b) - /// CMPSS xmm1, xmm2/m32, imm8(6) - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(6) + /// __m128 _mm_cmpnle_ss (__m128 a, __m128 b) + /// CMPSS xmm1, xmm2/m32, imm8(6) + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(6) /// public static Vector128 CompareScalarNotLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmpord_ss (__m128 a, __m128 b) - /// CMPSS xmm1, xmm2/m32, imm8(7) - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(7) + /// __m128 _mm_cmpord_ss (__m128 a, __m128 b) + /// CMPSS xmm1, xmm2/m32, imm8(7) + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(7) /// public static Vector128 CompareScalarOrdered(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_comieq_ss (__m128 a, __m128 b) - /// COMISS xmm1, xmm2/m32 ; ZF=1 && PF=0 - /// VCOMISS xmm1, xmm2/m32 ; ZF=1 && PF=0 - /// VCOMISS xmm1, xmm2/m32{sae} ; ZF=1 && PF=0 + /// int _mm_comieq_ss (__m128 a, __m128 b) + /// COMISS xmm1, xmm2/m32 ; ZF=1 && PF=0 + /// VCOMISS xmm1, xmm2/m32 ; ZF=1 && PF=0 + /// VCOMISS xmm1, xmm2/m32{sae} ; ZF=1 && PF=0 /// public static bool CompareScalarOrderedEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_comigt_ss (__m128 a, __m128 b) - /// COMISS xmm1, xmm2/m32 ; ZF=0 && CF=0 - /// VCOMISS xmm1, xmm2/m32 ; ZF=0 && CF=0 - /// VCOMISS xmm1, xmm2/m32{sae} ; ZF=0 && CF=0 + /// int _mm_comigt_ss (__m128 a, __m128 b) + /// COMISS xmm1, xmm2/m32 ; ZF=0 && CF=0 + /// VCOMISS xmm1, xmm2/m32 ; ZF=0 && CF=0 + /// VCOMISS xmm1, xmm2/m32{sae} ; ZF=0 && CF=0 /// public static bool CompareScalarOrderedGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_comige_ss (__m128 a, __m128 b) - /// COMISS xmm1, xmm2/m32 ; CF=0 - /// VCOMISS xmm1, xmm2/m32 ; CF=0 - /// VCOMISS xmm1, xmm2/m32{sae} ; CF=0 + /// int _mm_comige_ss (__m128 a, __m128 b) + /// COMISS xmm1, xmm2/m32 ; CF=0 + /// VCOMISS xmm1, xmm2/m32 ; CF=0 + /// VCOMISS xmm1, xmm2/m32{sae} ; CF=0 /// public static bool CompareScalarOrderedGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_comilt_ss (__m128 a, __m128 b) - /// COMISS xmm1, xmm2/m32 ; PF=0 && CF=1 - /// VCOMISS xmm1, xmm2/m32 ; PF=0 && CF=1 - /// VCOMISS xmm1, xmm2/m32{sae} ; PF=0 && CF=1 + /// int _mm_comilt_ss (__m128 a, __m128 b) + /// COMISS xmm1, xmm2/m32 ; PF=0 && CF=1 + /// VCOMISS xmm1, xmm2/m32 ; PF=0 && CF=1 + /// VCOMISS xmm1, xmm2/m32{sae} ; PF=0 && CF=1 /// public static bool CompareScalarOrderedLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_comile_ss (__m128 a, __m128 b) - /// COMISS xmm1, xmm2/m32 ; PF=0 && (ZF=1 || CF=1) - /// VCOMISS xmm1, xmm2/m32 ; PF=0 && (ZF=1 || CF=1) - /// VCOMISS xmm1, xmm2/m32{sae} ; PF=0 && (ZF=1 || CF=1) + /// int _mm_comile_ss (__m128 a, __m128 b) + /// COMISS xmm1, xmm2/m32 ; PF=0 && (ZF=1 || CF=1) + /// VCOMISS xmm1, xmm2/m32 ; PF=0 && (ZF=1 || CF=1) + /// VCOMISS xmm1, xmm2/m32{sae} ; PF=0 && (ZF=1 || CF=1) /// public static bool CompareScalarOrderedLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_comineq_ss (__m128 a, __m128 b) - /// COMISS xmm1, xmm2/m32 ; ZF=0 || PF=1 - /// VCOMISS xmm1, xmm2/m32 ; ZF=0 || PF=1 - /// VCOMISS xmm1, xmm2/m32{sae} ; ZF=0 || PF=1 + /// int _mm_comineq_ss (__m128 a, __m128 b) + /// COMISS xmm1, xmm2/m32 ; ZF=0 || PF=1 + /// VCOMISS xmm1, xmm2/m32 ; ZF=0 || PF=1 + /// VCOMISS xmm1, xmm2/m32{sae} ; ZF=0 || PF=1 /// public static bool CompareScalarOrderedNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmpunord_ss (__m128 a, __m128 b) - /// CMPSS xmm1, xmm2/m32, imm8(3) - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(3) + /// __m128 _mm_cmpunord_ss (__m128 a, __m128 b) + /// CMPSS xmm1, xmm2/m32, imm8(3) + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(3) /// public static Vector128 CompareScalarUnordered(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_ucomieq_ss (__m128 a, __m128 b) - /// UCOMISS xmm1, xmm2/m32 ; ZF=1 && PF=0 - /// VUCOMISS xmm1, xmm2/m32 ; ZF=1 && PF=0 - /// VUCOMISS xmm1, xmm2/m32{sae} ; ZF=1 && PF=0 + /// int _mm_ucomieq_ss (__m128 a, __m128 b) + /// UCOMISS xmm1, xmm2/m32 ; ZF=1 && PF=0 + /// VUCOMISS xmm1, xmm2/m32 ; ZF=1 && PF=0 + /// VUCOMISS xmm1, xmm2/m32{sae} ; ZF=1 && PF=0 /// public static bool CompareScalarUnorderedEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_ucomigt_ss (__m128 a, __m128 b) - /// UCOMISS xmm1, xmm2/m32 ; ZF=0 && CF=0 - /// VUCOMISS xmm1, xmm2/m32 ; ZF=0 && CF=0 - /// VUCOMISS xmm1, xmm2/m32{sae} ; ZF=0 && CF=0 + /// int _mm_ucomigt_ss (__m128 a, __m128 b) + /// UCOMISS xmm1, xmm2/m32 ; ZF=0 && CF=0 + /// VUCOMISS xmm1, xmm2/m32 ; ZF=0 && CF=0 + /// VUCOMISS xmm1, xmm2/m32{sae} ; ZF=0 && CF=0 /// public static bool CompareScalarUnorderedGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_ucomige_ss (__m128 a, __m128 b) - /// UCOMISS xmm1, xmm2/m32 ; CF=0 - /// VUCOMISS xmm1, xmm2/m32 ; CF=0 - /// VUCOMISS xmm1, xmm2/m32{sae} ; CF=0 + /// int _mm_ucomige_ss (__m128 a, __m128 b) + /// UCOMISS xmm1, xmm2/m32 ; CF=0 + /// VUCOMISS xmm1, xmm2/m32 ; CF=0 + /// VUCOMISS xmm1, xmm2/m32{sae} ; CF=0 /// public static bool CompareScalarUnorderedGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_ucomilt_ss (__m128 a, __m128 b) - /// UCOMISS xmm1, xmm2/m32 ; PF=0 && CF=1 - /// VUCOMISS xmm1, xmm2/m32 ; PF=0 && CF=1 - /// VUCOMISS xmm1, xmm2/m32{sae} ; PF=0 && CF=1 + /// int _mm_ucomilt_ss (__m128 a, __m128 b) + /// UCOMISS xmm1, xmm2/m32 ; PF=0 && CF=1 + /// VUCOMISS xmm1, xmm2/m32 ; PF=0 && CF=1 + /// VUCOMISS xmm1, xmm2/m32{sae} ; PF=0 && CF=1 /// public static bool CompareScalarUnorderedLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_ucomile_ss (__m128 a, __m128 b) - /// UCOMISS xmm1, xmm2/m32 ; PF=0 && (ZF=1 || CF=1) - /// VUCOMISS xmm1, xmm2/m32 ; PF=0 && (ZF=1 || CF=1) - /// VUCOMISS xmm1, xmm2/m32{sae} ; PF=0 && (ZF=1 || CF=1) + /// int _mm_ucomile_ss (__m128 a, __m128 b) + /// UCOMISS xmm1, xmm2/m32 ; PF=0 && (ZF=1 || CF=1) + /// VUCOMISS xmm1, xmm2/m32 ; PF=0 && (ZF=1 || CF=1) + /// VUCOMISS xmm1, xmm2/m32{sae} ; PF=0 && (ZF=1 || CF=1) /// public static bool CompareScalarUnorderedLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_ucomineq_ss (__m128 a, __m128 b) - /// UCOMISS xmm1, xmm2/m32 ; ZF=0 || PF=1 - /// VUCOMISS xmm1, xmm2/m32 ; ZF=0 || PF=1 - /// VUCOMISS xmm1, xmm2/m32{sae} ; ZF=0 || PF=1 + /// int _mm_ucomineq_ss (__m128 a, __m128 b) + /// UCOMISS xmm1, xmm2/m32 ; ZF=0 || PF=1 + /// VUCOMISS xmm1, xmm2/m32 ; ZF=0 || PF=1 + /// VUCOMISS xmm1, xmm2/m32{sae} ; ZF=0 || PF=1 /// public static bool CompareScalarUnorderedNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cmpunord_ps (__m128 a, __m128 b) - /// CMPPS xmm1, xmm2/m128, imm8(3) - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(3) + /// __m128 _mm_cmpunord_ps (__m128 a, __m128 b) + /// CMPPS xmm1, xmm2/m128, imm8(3) + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(3) /// public static Vector128 CompareUnordered(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cvtsi32_ss (__m128 a, int b) - /// CVTSI2SS xmm1, r/m32 - /// VCVTSI2SS xmm1, xmm2, r/m32 + /// __m128 _mm_cvtsi32_ss (__m128 a, int b) + /// CVTSI2SS xmm1, r/m32 + /// VCVTSI2SS xmm1, xmm2, r/m32 /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, int value) { throw new PlatformNotSupportedException(); } /// - /// int _mm_cvtss_si32 (__m128 a) - /// CVTSS2SI r32, xmm1/m32 - /// VCVTSS2SI r32, xmm1/m32 + /// int _mm_cvtss_si32 (__m128 a) + /// CVTSS2SI r32, xmm1/m32 + /// VCVTSS2SI r32, xmm1/m32 /// public static int ConvertToInt32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int _mm_cvttss_si32 (__m128 a) - /// CVTTSS2SI r32, xmm1/m32 - /// VCVTTSS2SI r32, xmm1/m32 + /// int _mm_cvttss_si32 (__m128 a) + /// CVTTSS2SI r32, xmm1/m32 + /// VCVTTSS2SI r32, xmm1/m32 /// public static int ConvertToInt32WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_div_ps (__m128 a, __m128 b) - /// DIVPS xmm, xmm2/m128 - /// VDIVPS xmm1, xmm2, xmm3/m128 - /// VDIVPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_div_ps (__m128 a, __m128 b) + /// DIVPS xmm, xmm2/m128 + /// VDIVPS xmm1, xmm2, xmm3/m128 + /// VDIVPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Divide(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_div_ss (__m128 a, __m128 b) - /// DIVSS xmm1, xmm2/m32 - /// VDIVSS xmm1, xmm2, xmm3/m32 + /// __m128 _mm_div_ss (__m128 a, __m128 b) + /// DIVSS xmm1, xmm2/m32 + /// VDIVSS xmm1, xmm2, xmm3/m32 /// public static Vector128 DivideScalar(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_load_ps (float const* mem_address) - /// MOVAPS xmm1, m128 - /// VMOVAPS xmm1, m128 - /// VMOVAPS xmm1 {k1}{z}, m128 + /// __m128 _mm_load_ps (float const* mem_address) + /// MOVAPS xmm1, m128 + /// VMOVAPS xmm1, m128 + /// VMOVAPS xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadAlignedVector128(float* address) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_loadh_pi (__m128 a, __m64 const* mem_addr) - /// MOVHPS xmm1, m64 - /// VMOVHPS xmm1, xmm2, m64 + /// __m128 _mm_loadh_pi (__m128 a, __m64 const* mem_addr) + /// MOVHPS xmm1, m64 + /// VMOVHPS xmm1, xmm2, m64 /// public static unsafe Vector128 LoadHigh(Vector128 lower, float* address) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_loadl_pi (__m128 a, __m64 const* mem_addr) - /// MOVLPS xmm1, m64 - /// VMOVLPS xmm1, xmm2, m64 + /// __m128 _mm_loadl_pi (__m128 a, __m64 const* mem_addr) + /// MOVLPS xmm1, m64 + /// VMOVLPS xmm1, xmm2, m64 /// public static unsafe Vector128 LoadLow(Vector128 upper, float* address) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_load_ss (float const* mem_address) - /// MOVSS xmm1, m32 - /// VMOVSS xmm1, m32 - /// VMOVSS xmm1 {k1}, m32 + /// __m128 _mm_load_ss (float const* mem_address) + /// MOVSS xmm1, m32 + /// VMOVSS xmm1, m32 + /// VMOVSS xmm1 {k1}, m32 /// public static unsafe Vector128 LoadScalarVector128(float* address) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_loadu_ps (float const* mem_address) - /// MOVUPS xmm1, m128 - /// VMOVUPS xmm1, m128 - /// VMOVUPS xmm1 {k1}{z}, m128 + /// __m128 _mm_loadu_ps (float const* mem_address) + /// MOVUPS xmm1, m128 + /// VMOVUPS xmm1, m128 + /// VMOVUPS xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadVector128(float* address) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_max_ps (__m128 a, __m128 b) - /// MAXPS xmm1, xmm2/m128 - /// VMAXPS xmm1, xmm2, xmm3/m128 - /// VMAXPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_max_ps (__m128 a, __m128 b) + /// MAXPS xmm1, xmm2/m128 + /// VMAXPS xmm1, xmm2, xmm3/m128 + /// VMAXPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_max_ss (__m128 a, __m128 b) - /// MAXSS xmm1, xmm2/m32 - /// VMAXSS xmm1, xmm2, xmm3/m32 + /// __m128 _mm_max_ss (__m128 a, __m128 b) + /// MAXSS xmm1, xmm2/m32 + /// VMAXSS xmm1, xmm2, xmm3/m32 /// public static Vector128 MaxScalar(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_min_ps (__m128 a, __m128 b) - /// MINPS xmm1, xmm2/m128 - /// VMINPS xmm1, xmm2, xmm3/m128 - /// VMINPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_min_ps (__m128 a, __m128 b) + /// MINPS xmm1, xmm2/m128 + /// VMINPS xmm1, xmm2, xmm3/m128 + /// VMINPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_min_ss (__m128 a, __m128 b) - /// MINSS xmm1, xmm2/m32 - /// VMINSS xmm1, xmm2, xmm3/m32 + /// __m128 _mm_min_ss (__m128 a, __m128 b) + /// MINSS xmm1, xmm2/m32 + /// VMINSS xmm1, xmm2, xmm3/m32 /// public static Vector128 MinScalar(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_movehl_ps (__m128 a, __m128 b) - /// MOVHLPS xmm1, xmm2 - /// VMOVHLPS xmm1, xmm2, xmm3 + /// __m128 _mm_movehl_ps (__m128 a, __m128 b) + /// MOVHLPS xmm1, xmm2 + /// VMOVHLPS xmm1, xmm2, xmm3 /// public static Vector128 MoveHighToLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_movelh_ps (__m128 a, __m128 b) - /// MOVLHPS xmm1, xmm2 - /// VMOVLHPS xmm1, xmm2, xmm3 + /// __m128 _mm_movelh_ps (__m128 a, __m128 b) + /// MOVLHPS xmm1, xmm2 + /// VMOVLHPS xmm1, xmm2, xmm3 /// public static Vector128 MoveLowToHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_movemask_ps (__m128 a) - /// MOVMSKPS r32, xmm1 - /// VMOVMSKPS r32, xmm1 + /// int _mm_movemask_ps (__m128 a) + /// MOVMSKPS r32, xmm1 + /// VMOVMSKPS r32, xmm1 /// public static int MoveMask(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_move_ss (__m128 a, __m128 b) - /// MOVSS xmm1, xmm2 - /// VMOVSS xmm1, xmm2, xmm3 - /// VMOVSS xmm1 {k1}{z}, xmm2, xmm3 + /// __m128 _mm_move_ss (__m128 a, __m128 b) + /// MOVSS xmm1, xmm2 + /// VMOVSS xmm1, xmm2, xmm3 + /// VMOVSS xmm1 {k1}{z}, xmm2, xmm3 /// public static Vector128 MoveScalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_mul_ps (__m128 a, __m128 b) - /// MULPS xmm1, xmm2/m128 - /// VMULPS xmm1, xmm2, xmm3/m128 - /// VMULPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_mul_ps (__m128 a, __m128 b) + /// MULPS xmm1, xmm2/m128 + /// VMULPS xmm1, xmm2, xmm3/m128 + /// VMULPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Multiply(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_mul_ss (__m128 a, __m128 b) - /// MULSS xmm1, xmm2/m32 - /// VMULSS xmm1, xmm2, xmm3/m32 + /// __m128 _mm_mul_ss (__m128 a, __m128 b) + /// MULSS xmm1, xmm2/m32 + /// VMULSS xmm1, xmm2, xmm3/m32 /// public static Vector128 MultiplyScalar(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_or_ps (__m128 a, __m128 b) - /// ORPS xmm1, xmm2/m128 - /// VORPS xmm1, xmm2, xmm3/m128 - /// VORPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_or_ps (__m128 a, __m128 b) + /// ORPS xmm1, xmm2/m128 + /// VORPS xmm1, xmm2, xmm3/m128 + /// VORPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// void _mm_prefetch(char* p, int i) - /// PREFETCHT0 m8 + /// void _mm_prefetch(char* p, int i) + /// PREFETCHT0 m8 /// public static unsafe void Prefetch0(void* address) { throw new PlatformNotSupportedException(); } /// - /// void _mm_prefetch(char* p, int i) - /// PREFETCHT1 m8 + /// void _mm_prefetch(char* p, int i) + /// PREFETCHT1 m8 /// public static unsafe void Prefetch1(void* address) { throw new PlatformNotSupportedException(); } /// - /// void _mm_prefetch(char* p, int i) - /// PREFETCHT2 m8 + /// void _mm_prefetch(char* p, int i) + /// PREFETCHT2 m8 /// public static unsafe void Prefetch2(void* address) { throw new PlatformNotSupportedException(); } /// - /// void _mm_prefetch(char* p, int i) - /// PREFETCHNTA m8 + /// void _mm_prefetch(char* p, int i) + /// PREFETCHNTA m8 /// public static unsafe void PrefetchNonTemporal(void* address) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_rcp_ps (__m128 a) - /// RCPPS xmm1, xmm2/m128 - /// VRCPPS xmm1, xmm2/m128 + /// __m128 _mm_rcp_ps (__m128 a) + /// RCPPS xmm1, xmm2/m128 + /// VRCPPS xmm1, xmm2/m128 /// public static Vector128 Reciprocal(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_rcp_ss (__m128 a) - /// RCPSS xmm1, xmm2/m32 - /// VRCPSS xmm1, xmm2, xmm3/m32 + /// __m128 _mm_rcp_ss (__m128 a) + /// RCPSS xmm1, xmm2/m32 + /// VRCPSS xmm1, xmm2, xmm3/m32 /// public static Vector128 ReciprocalScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_rcp_ss (__m128 a, __m128 b) - /// RCPSS xmm1, xmm2/m32 - /// VRCPSS xmm1, xmm2, xmm3/m32 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_rcp_ss (__m128 a, __m128 b) + /// RCPSS xmm1, xmm2/m32 + /// VRCPSS xmm1, xmm2, xmm3/m32 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 ReciprocalScalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_rsqrt_ps (__m128 a) - /// RSQRTPS xmm1, xmm2/m128 - /// VRSQRTPS xmm1, xmm2/m128 + /// __m128 _mm_rsqrt_ps (__m128 a) + /// RSQRTPS xmm1, xmm2/m128 + /// VRSQRTPS xmm1, xmm2/m128 /// public static Vector128 ReciprocalSqrt(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_rsqrt_ss (__m128 a) - /// RSQRTSS xmm1, xmm2/m32 - /// VRSQRTSS xmm1, xmm2, xmm3/m32 + /// __m128 _mm_rsqrt_ss (__m128 a) + /// RSQRTSS xmm1, xmm2/m32 + /// VRSQRTSS xmm1, xmm2, xmm3/m32 /// public static Vector128 ReciprocalSqrtScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_rsqrt_ss (__m128 a, __m128 b) - /// RSQRTSS xmm1, xmm2/m32 - /// VRSQRTSS xmm1, xmm2, xmm3/m32 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_rsqrt_ss (__m128 a, __m128 b) + /// RSQRTSS xmm1, xmm2/m32 + /// VRSQRTSS xmm1, xmm2, xmm3/m32 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 ReciprocalSqrtScalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_shuffle_ps (__m128 a, __m128 b, unsigned int control) - /// SHUFPS xmm1, xmm2/m128, imm8 - /// VSHUFPS xmm1, xmm2, xmm3/m128, imm8 - /// VSHUFPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128 _mm_shuffle_ps (__m128 a, __m128 b, unsigned int control) + /// SHUFPS xmm1, xmm2/m128, imm8 + /// VSHUFPS xmm1, xmm2, xmm3/m128, imm8 + /// VSHUFPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 Shuffle(Vector128 left, Vector128 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_sqrt_ps (__m128 a) - /// SQRTPS xmm1, xmm2/m128 - /// VSQRTPS xmm1, xmm2/m128 - /// VSQRTPS xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128 _mm_sqrt_ps (__m128 a) + /// SQRTPS xmm1, xmm2/m128 + /// VSQRTPS xmm1, xmm2/m128 + /// VSQRTPS xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 Sqrt(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_sqrt_ss (__m128 a) - /// SQRTSS xmm1, xmm2/m32 - /// VSQRTSS xmm1, xmm2, xmm3/m32 - /// VSQRTSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} + /// __m128 _mm_sqrt_ss (__m128 a) + /// SQRTSS xmm1, xmm2/m32 + /// VSQRTSS xmm1, xmm2, xmm3/m32 + /// VSQRTSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} /// public static Vector128 SqrtScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_sqrt_ss (__m128 a, __m128 b) - /// SQRTSS xmm1, xmm2/m32 - /// VSQRTSS xmm1, xmm2, xmm3/m32 - /// VSQRTSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_sqrt_ss (__m128 a, __m128 b) + /// SQRTSS xmm1, xmm2/m32 + /// VSQRTSS xmm1, xmm2, xmm3/m32 + /// VSQRTSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 SqrtScalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// void _mm_storeu_ps (float* mem_addr, __m128 a) - /// MOVUPS m128, xmm1 - /// VMOVUPS m128, xmm1 - /// VMOVUPS m128 {k1}{z}, xmm1 + /// void _mm_storeu_ps (float* mem_addr, __m128 a) + /// MOVUPS m128, xmm1 + /// VMOVUPS m128, xmm1 + /// VMOVUPS m128 {k1}{z}, xmm1 /// public static unsafe void Store(float* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_store_ps (float* mem_addr, __m128 a) - /// MOVAPS m128, xmm1 - /// VMOVAPS m128, xmm1 - /// VMOVAPS m128 {k1}{z}, xmm1 + /// void _mm_store_ps (float* mem_addr, __m128 a) + /// MOVAPS m128, xmm1 + /// VMOVAPS m128, xmm1 + /// VMOVAPS m128 {k1}{z}, xmm1 /// public static unsafe void StoreAligned(float* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_stream_ps (float* mem_addr, __m128 a) - /// MOVNTPS m128, xmm1 - /// VMOVNTPS m128, xmm1 + /// void _mm_stream_ps (float* mem_addr, __m128 a) + /// MOVNTPS m128, xmm1 + /// VMOVNTPS m128, xmm1 /// public static unsafe void StoreAlignedNonTemporal(float* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_sfence(void) - /// SFENCE + /// void _mm_sfence(void) + /// SFENCE /// public static void StoreFence() { throw new PlatformNotSupportedException(); } /// - /// void _mm_storeh_pi (__m64* mem_addr, __m128 a) - /// MOVHPS m64, xmm1 - /// VMOVHPS m64, xmm1 + /// void _mm_storeh_pi (__m64* mem_addr, __m128 a) + /// MOVHPS m64, xmm1 + /// VMOVHPS m64, xmm1 /// public static unsafe void StoreHigh(float* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_storel_pi (__m64* mem_addr, __m128 a) - /// MOVLPS m64, xmm1 - /// VMOVLPS m64, xmm1 + /// void _mm_storel_pi (__m64* mem_addr, __m128 a) + /// MOVLPS m64, xmm1 + /// VMOVLPS m64, xmm1 /// public static unsafe void StoreLow(float* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_store_ss (float* mem_addr, __m128 a) - /// MOVSS m32, xmm1 - /// VMOVSS m32, xmm1 - /// VMOVSS m32 {k1}, xmm1 + /// void _mm_store_ss (float* mem_addr, __m128 a) + /// MOVSS m32, xmm1 + /// VMOVSS m32, xmm1 + /// VMOVSS m32 {k1}, xmm1 /// public static unsafe void StoreScalar(float* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_sub_ps (__m128d a, __m128d b) - /// SUBPS xmm1, xmm2/m128 - /// VSUBPS xmm1, xmm2, xmm3/m128 - /// VSUBPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128d _mm_sub_ps (__m128d a, __m128d b) + /// SUBPS xmm1, xmm2/m128 + /// VSUBPS xmm1, xmm2, xmm3/m128 + /// VSUBPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_sub_ss (__m128 a, __m128 b) - /// SUBSS xmm1, xmm2/m32 - /// VSUBSS xmm1, xmm2, xmm3/m32 - /// VSUBSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} + /// __m128 _mm_sub_ss (__m128 a, __m128 b) + /// SUBSS xmm1, xmm2/m32 + /// VSUBSS xmm1, xmm2, xmm3/m32 + /// VSUBSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} /// public static Vector128 SubtractScalar(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_unpackhi_ps (__m128 a, __m128 b) - /// UNPCKHPS xmm1, xmm2/m128 - /// VUNPCKHPS xmm1, xmm2, xmm3/m128 - /// VUNPCKHPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_unpackhi_ps (__m128 a, __m128 b) + /// UNPCKHPS xmm1, xmm2/m128 + /// VUNPCKHPS xmm1, xmm2, xmm3/m128 + /// VUNPCKHPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_unpacklo_ps (__m128 a, __m128 b) - /// UNPCKLPS xmm1, xmm2/m128 - /// VUNPCKLPS xmm1, xmm2, xmm3/m128 - /// VUNPCKLPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_unpacklo_ps (__m128 a, __m128 b) + /// UNPCKLPS xmm1, xmm2/m128 + /// VUNPCKLPS xmm1, xmm2, xmm3/m128 + /// VUNPCKLPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_xor_ps (__m128 a, __m128 b) - /// XORPS xmm1, xmm2/m128 - /// VXORPS xmm1, xmm2, xmm3/m128 - /// VXORPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_xor_ps (__m128 a, __m128 b) + /// XORPS xmm1, xmm2/m128 + /// VXORPS xmm1, xmm2, xmm3/m128 + /// VXORPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse.cs index 67bd57161ab..e6f349afd20 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse.cs @@ -6,638 +6,643 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel SSE hardware instructions via intrinsics - /// + /// Provides access to X86 SSE hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Sse : X86Base { internal Sse() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the x86 SSE hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : X86Base.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } /// - /// __m128 _mm_cvtsi64_ss (__m128 a, __int64 b) - /// CVTSI2SS xmm1, r/m64 - /// VCVTSI2SS xmm1, xmm2, r/m64 - /// This intrinsic is only available on 64-bit processes + /// __m128 _mm_cvtsi64_ss (__m128 a, __int64 b) + /// CVTSI2SS xmm1, r/m64 + /// VCVTSI2SS xmm1, xmm2, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, long value) => ConvertScalarToVector128Single(upper, value); /// - /// __int64 _mm_cvtss_si64 (__m128 a) - /// CVTSS2SI r64, xmm1/m32 - /// VCVTSS2SI r64, xmm1/m32 - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_cvtss_si64 (__m128 a) + /// CVTSS2SI r64, xmm1/m32 + /// VCVTSS2SI r64, xmm1/m32 + /// This intrinsic is only available on 64-bit processes /// public static long ConvertToInt64(Vector128 value) => ConvertToInt64(value); /// - /// __int64 _mm_cvttss_si64 (__m128 a) - /// CVTTSS2SI r64, xmm1/m32 - /// VCVTTSS2SI r64, xmm1/m32 - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_cvttss_si64 (__m128 a) + /// CVTTSS2SI r64, xmm1/m32 + /// VCVTTSS2SI r64, xmm1/m32 + /// This intrinsic is only available on 64-bit processes /// public static long ConvertToInt64WithTruncation(Vector128 value) => ConvertToInt64WithTruncation(value); } /// - /// __m128 _mm_add_ps (__m128 a, __m128 b) - /// ADDPS xmm1, xmm2/m128 - /// VADDPS xmm1, xmm2, xmm3/m128 - /// VADDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_add_ps (__m128 a, __m128 b) + /// ADDPS xmm1, xmm2/m128 + /// VADDPS xmm1, xmm2, xmm3/m128 + /// VADDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// - /// __m128 _mm_add_ss (__m128 a, __m128 b) - /// ADDSS xmm1, xmm2/m32 - /// VADDSS xmm1, xmm2, xmm3/m32 - /// VADDSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} + /// __m128 _mm_add_ss (__m128 a, __m128 b) + /// ADDSS xmm1, xmm2/m32 + /// VADDSS xmm1, xmm2, xmm3/m32 + /// VADDSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} /// public static Vector128 AddScalar(Vector128 left, Vector128 right) => AddScalar(left, right); /// - /// __m128 _mm_and_ps (__m128 a, __m128 b) - /// ANDPS xmm1, xmm2/m128 - /// VANDPS xmm1, xmm2, xmm3/m128 - /// VANDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_and_ps (__m128 a, __m128 b) + /// ANDPS xmm1, xmm2/m128 + /// VANDPS xmm1, xmm2, xmm3/m128 + /// VANDPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// - /// __m128 _mm_andnot_ps (__m128 a, __m128 b) - /// ANDNPS xmm1, xmm2/m128 - /// VANDNPS xmm1, xmm2, xmm3/m128 - /// VANDNPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_andnot_ps (__m128 a, __m128 b) + /// ANDNPS xmm1, xmm2/m128 + /// VANDNPS xmm1, xmm2, xmm3/m128 + /// VANDNPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); /// - /// __m128 _mm_cmpeq_ps (__m128 a, __m128 b) - /// CMPPS xmm1, xmm2/m128, imm8(0) - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(0) + /// __m128 _mm_cmpeq_ps (__m128 a, __m128 b) + /// CMPPS xmm1, xmm2/m128, imm8(0) + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(0) /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// - /// __m128 _mm_cmpgt_ps (__m128 a, __m128 b) - /// CMPPS xmm1, xmm2/m128, imm8(1) ; with swapped operands - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(1) ; with swapped operands + /// __m128 _mm_cmpgt_ps (__m128 a, __m128 b) + /// CMPPS xmm1, xmm2/m128, imm8(1) ; with swapped operands + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(1) ; with swapped operands /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// - /// __m128 _mm_cmpge_ps (__m128 a, __m128 b) - /// CMPPS xmm1, xmm2/m128, imm8(2) ; with swapped operands - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(2) ; with swapped operands + /// __m128 _mm_cmpge_ps (__m128 a, __m128 b) + /// CMPPS xmm1, xmm2/m128, imm8(2) ; with swapped operands + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(2) ; with swapped operands /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m128 _mm_cmplt_ps (__m128 a, __m128 b) - /// CMPPS xmm1, xmm2/m128, imm8(1) - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(1) + /// __m128 _mm_cmplt_ps (__m128 a, __m128 b) + /// CMPPS xmm1, xmm2/m128, imm8(1) + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// __m128 _mm_cmple_ps (__m128 a, __m128 b) - /// CMPPS xmm1, xmm2/m128, imm8(2) - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(2) + /// __m128 _mm_cmple_ps (__m128 a, __m128 b) + /// CMPPS xmm1, xmm2/m128, imm8(2) + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// __m128 _mm_cmpneq_ps (__m128 a, __m128 b) - /// CMPPS xmm1, xmm2/m128, imm8(4) - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(4) + /// __m128 _mm_cmpneq_ps (__m128 a, __m128 b) + /// CMPPS xmm1, xmm2/m128, imm8(4) + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); /// - /// __m128 _mm_cmpngt_ps (__m128 a, __m128 b) - /// CMPPS xmm1, xmm2/m128, imm8(5) ; with swapped operands - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(5) ; with swapped operands + /// __m128 _mm_cmpngt_ps (__m128 a, __m128 b) + /// CMPPS xmm1, xmm2/m128, imm8(5) ; with swapped operands + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(5) ; with swapped operands /// public static Vector128 CompareNotGreaterThan(Vector128 left, Vector128 right) => CompareNotGreaterThan(left, right); /// - /// __m128 _mm_cmpnge_ps (__m128 a, __m128 b) - /// CMPPS xmm1, xmm2/m128, imm8(6) ; with swapped operands - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(6) ; with swapped operands + /// __m128 _mm_cmpnge_ps (__m128 a, __m128 b) + /// CMPPS xmm1, xmm2/m128, imm8(6) ; with swapped operands + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(6) ; with swapped operands /// public static Vector128 CompareNotGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareNotGreaterThanOrEqual(left, right); /// - /// __m128 _mm_cmpnlt_ps (__m128 a, __m128 b) - /// CMPPS xmm1, xmm2/m128, imm8(5) - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(5) + /// __m128 _mm_cmpnlt_ps (__m128 a, __m128 b) + /// CMPPS xmm1, xmm2/m128, imm8(5) + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(5) /// public static Vector128 CompareNotLessThan(Vector128 left, Vector128 right) => CompareNotLessThan(left, right); /// - /// __m128 _mm_cmpnle_ps (__m128 a, __m128 b) - /// CMPPS xmm1, xmm2/m128, imm8(6) - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(6) + /// __m128 _mm_cmpnle_ps (__m128 a, __m128 b) + /// CMPPS xmm1, xmm2/m128, imm8(6) + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(6) /// public static Vector128 CompareNotLessThanOrEqual(Vector128 left, Vector128 right) => CompareNotLessThanOrEqual(left, right); /// - /// __m128 _mm_cmpord_ps (__m128 a, __m128 b) - /// CMPPS xmm1, xmm2/m128, imm8(7) - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(7) + /// __m128 _mm_cmpord_ps (__m128 a, __m128 b) + /// CMPPS xmm1, xmm2/m128, imm8(7) + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(7) /// public static Vector128 CompareOrdered(Vector128 left, Vector128 right) => CompareOrdered(left, right); /// - /// __m128 _mm_cmpeq_ss (__m128 a, __m128 b) - /// CMPSS xmm1, xmm2/m32, imm8(0) - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(0) + /// __m128 _mm_cmpeq_ss (__m128 a, __m128 b) + /// CMPSS xmm1, xmm2/m32, imm8(0) + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(0) /// public static Vector128 CompareScalarEqual(Vector128 left, Vector128 right) => CompareScalarEqual(left, right); /// - /// __m128 _mm_cmpgt_ss (__m128 a, __m128 b) - /// CMPSS xmm1, xmm2/m32, imm8(1) ; with swapped operands - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(1) ; with swapped operands + /// __m128 _mm_cmpgt_ss (__m128 a, __m128 b) + /// CMPSS xmm1, xmm2/m32, imm8(1) ; with swapped operands + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(1) ; with swapped operands /// public static Vector128 CompareScalarGreaterThan(Vector128 left, Vector128 right) => CompareScalarGreaterThan(left, right); /// - /// __m128 _mm_cmpge_ss (__m128 a, __m128 b) - /// CMPSS xmm1, xmm2/m32, imm8(2) ; with swapped operands - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(2) ; with swapped operands + /// __m128 _mm_cmpge_ss (__m128 a, __m128 b) + /// CMPSS xmm1, xmm2/m32, imm8(2) ; with swapped operands + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(2) ; with swapped operands /// public static Vector128 CompareScalarGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareScalarGreaterThanOrEqual(left, right); /// - /// __m128 _mm_cmplt_ss (__m128 a, __m128 b) - /// CMPSS xmm1, xmm2/m32, imm8(1) - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(1) + /// __m128 _mm_cmplt_ss (__m128 a, __m128 b) + /// CMPSS xmm1, xmm2/m32, imm8(1) + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(1) /// public static Vector128 CompareScalarLessThan(Vector128 left, Vector128 right) => CompareScalarLessThan(left, right); /// - /// __m128 _mm_cmple_ss (__m128 a, __m128 b) - /// CMPSS xmm1, xmm2/m32, imm8(2) - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(2) + /// __m128 _mm_cmple_ss (__m128 a, __m128 b) + /// CMPSS xmm1, xmm2/m32, imm8(2) + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(2) /// public static Vector128 CompareScalarLessThanOrEqual(Vector128 left, Vector128 right) => CompareScalarLessThanOrEqual(left, right); /// - /// __m128 _mm_cmpneq_ss (__m128 a, __m128 b) - /// CMPSS xmm1, xmm2/m32, imm8(4) - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(4) + /// __m128 _mm_cmpneq_ss (__m128 a, __m128 b) + /// CMPSS xmm1, xmm2/m32, imm8(4) + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(4) /// public static Vector128 CompareScalarNotEqual(Vector128 left, Vector128 right) => CompareScalarNotEqual(left, right); /// - /// __m128 _mm_cmpngt_ss (__m128 a, __m128 b) - /// CMPSS xmm1, xmm2/m32, imm8(5) ; with swapped operands - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(5) ; with swapped operands + /// __m128 _mm_cmpngt_ss (__m128 a, __m128 b) + /// CMPSS xmm1, xmm2/m32, imm8(5) ; with swapped operands + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(5) ; with swapped operands /// public static Vector128 CompareScalarNotGreaterThan(Vector128 left, Vector128 right) => CompareScalarNotGreaterThan(left, right); /// - /// __m128 _mm_cmpnge_ss (__m128 a, __m128 b) - /// CMPSS xmm1, xmm2/m32, imm8(6) ; with swapped operands - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(6) ; with swapped operands + /// __m128 _mm_cmpnge_ss (__m128 a, __m128 b) + /// CMPSS xmm1, xmm2/m32, imm8(6) ; with swapped operands + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(6) ; with swapped operands /// public static Vector128 CompareScalarNotGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareScalarNotGreaterThanOrEqual(left, right); /// - /// __m128 _mm_cmpnlt_ss (__m128 a, __m128 b) - /// CMPSS xmm1, xmm2/m32, imm8(5) - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(5) + /// __m128 _mm_cmpnlt_ss (__m128 a, __m128 b) + /// CMPSS xmm1, xmm2/m32, imm8(5) + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(5) /// public static Vector128 CompareScalarNotLessThan(Vector128 left, Vector128 right) => CompareScalarNotLessThan(left, right); /// - /// __m128 _mm_cmpnle_ss (__m128 a, __m128 b) - /// CMPSS xmm1, xmm2/m32, imm8(6) - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(6) + /// __m128 _mm_cmpnle_ss (__m128 a, __m128 b) + /// CMPSS xmm1, xmm2/m32, imm8(6) + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(6) /// public static Vector128 CompareScalarNotLessThanOrEqual(Vector128 left, Vector128 right) => CompareScalarNotLessThanOrEqual(left, right); /// - /// __m128 _mm_cmpord_ss (__m128 a, __m128 b) - /// CMPSS xmm1, xmm2/m32, imm8(7) - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(7) + /// __m128 _mm_cmpord_ss (__m128 a, __m128 b) + /// CMPSS xmm1, xmm2/m32, imm8(7) + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(7) /// public static Vector128 CompareScalarOrdered(Vector128 left, Vector128 right) => CompareScalarOrdered(left, right); /// - /// int _mm_comieq_ss (__m128 a, __m128 b) - /// COMISS xmm1, xmm2/m32 ; ZF=1 && PF=0 - /// VCOMISS xmm1, xmm2/m32 ; ZF=1 && PF=0 - /// VCOMISS xmm1, xmm2/m32{sae} ; ZF=1 && PF=0 + /// int _mm_comieq_ss (__m128 a, __m128 b) + /// COMISS xmm1, xmm2/m32 ; ZF=1 && PF=0 + /// VCOMISS xmm1, xmm2/m32 ; ZF=1 && PF=0 + /// VCOMISS xmm1, xmm2/m32{sae} ; ZF=1 && PF=0 /// public static bool CompareScalarOrderedEqual(Vector128 left, Vector128 right) => CompareScalarOrderedEqual(left, right); /// - /// int _mm_comigt_ss (__m128 a, __m128 b) - /// COMISS xmm1, xmm2/m32 ; ZF=0 && CF=0 - /// VCOMISS xmm1, xmm2/m32 ; ZF=0 && CF=0 - /// VCOMISS xmm1, xmm2/m32{sae} ; ZF=0 && CF=0 + /// int _mm_comigt_ss (__m128 a, __m128 b) + /// COMISS xmm1, xmm2/m32 ; ZF=0 && CF=0 + /// VCOMISS xmm1, xmm2/m32 ; ZF=0 && CF=0 + /// VCOMISS xmm1, xmm2/m32{sae} ; ZF=0 && CF=0 /// public static bool CompareScalarOrderedGreaterThan(Vector128 left, Vector128 right) => CompareScalarOrderedGreaterThan(left, right); /// - /// int _mm_comige_ss (__m128 a, __m128 b) - /// COMISS xmm1, xmm2/m32 ; CF=0 - /// VCOMISS xmm1, xmm2/m32 ; CF=0 - /// VCOMISS xmm1, xmm2/m32{sae} ; CF=0 + /// int _mm_comige_ss (__m128 a, __m128 b) + /// COMISS xmm1, xmm2/m32 ; CF=0 + /// VCOMISS xmm1, xmm2/m32 ; CF=0 + /// VCOMISS xmm1, xmm2/m32{sae} ; CF=0 /// public static bool CompareScalarOrderedGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareScalarOrderedGreaterThanOrEqual(left, right); /// - /// int _mm_comilt_ss (__m128 a, __m128 b) - /// COMISS xmm1, xmm2/m32 ; PF=0 && CF=1 - /// VCOMISS xmm1, xmm2/m32 ; PF=0 && CF=1 - /// VCOMISS xmm1, xmm2/m32{sae} ; PF=0 && CF=1 + /// int _mm_comilt_ss (__m128 a, __m128 b) + /// COMISS xmm1, xmm2/m32 ; PF=0 && CF=1 + /// VCOMISS xmm1, xmm2/m32 ; PF=0 && CF=1 + /// VCOMISS xmm1, xmm2/m32{sae} ; PF=0 && CF=1 /// public static bool CompareScalarOrderedLessThan(Vector128 left, Vector128 right) => CompareScalarOrderedLessThan(left, right); /// - /// int _mm_comile_ss (__m128 a, __m128 b) - /// COMISS xmm1, xmm2/m32 ; PF=0 && (ZF=1 || CF=1) - /// VCOMISS xmm1, xmm2/m32 ; PF=0 && (ZF=1 || CF=1) - /// VCOMISS xmm1, xmm2/m32{sae} ; PF=0 && (ZF=1 || CF=1) + /// int _mm_comile_ss (__m128 a, __m128 b) + /// COMISS xmm1, xmm2/m32 ; PF=0 && (ZF=1 || CF=1) + /// VCOMISS xmm1, xmm2/m32 ; PF=0 && (ZF=1 || CF=1) + /// VCOMISS xmm1, xmm2/m32{sae} ; PF=0 && (ZF=1 || CF=1) /// public static bool CompareScalarOrderedLessThanOrEqual(Vector128 left, Vector128 right) => CompareScalarOrderedLessThanOrEqual(left, right); /// - /// int _mm_comineq_ss (__m128 a, __m128 b) - /// COMISS xmm1, xmm2/m32 ; ZF=0 || PF=1 - /// VCOMISS xmm1, xmm2/m32 ; ZF=0 || PF=1 - /// VCOMISS xmm1, xmm2/m32{sae} ; ZF=0 || PF=1 + /// int _mm_comineq_ss (__m128 a, __m128 b) + /// COMISS xmm1, xmm2/m32 ; ZF=0 || PF=1 + /// VCOMISS xmm1, xmm2/m32 ; ZF=0 || PF=1 + /// VCOMISS xmm1, xmm2/m32{sae} ; ZF=0 || PF=1 /// public static bool CompareScalarOrderedNotEqual(Vector128 left, Vector128 right) => CompareScalarOrderedNotEqual(left, right); /// - /// __m128 _mm_cmpunord_ss (__m128 a, __m128 b) - /// CMPSS xmm1, xmm2/m32, imm8(3) - /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(3) + /// __m128 _mm_cmpunord_ss (__m128 a, __m128 b) + /// CMPSS xmm1, xmm2/m32, imm8(3) + /// VCMPSS xmm1, xmm2, xmm3/m32, imm8(3) /// public static Vector128 CompareScalarUnordered(Vector128 left, Vector128 right) => CompareScalarUnordered(left, right); /// - /// int _mm_ucomieq_ss (__m128 a, __m128 b) - /// UCOMISS xmm1, xmm2/m32 ; ZF=1 && PF=0 - /// VUCOMISS xmm1, xmm2/m32 ; ZF=1 && PF=0 - /// VUCOMISS xmm1, xmm2/m32{sae} ; ZF=1 && PF=0 + /// int _mm_ucomieq_ss (__m128 a, __m128 b) + /// UCOMISS xmm1, xmm2/m32 ; ZF=1 && PF=0 + /// VUCOMISS xmm1, xmm2/m32 ; ZF=1 && PF=0 + /// VUCOMISS xmm1, xmm2/m32{sae} ; ZF=1 && PF=0 /// public static bool CompareScalarUnorderedEqual(Vector128 left, Vector128 right) => CompareScalarUnorderedEqual(left, right); /// - /// int _mm_ucomigt_ss (__m128 a, __m128 b) - /// UCOMISS xmm1, xmm2/m32 ; ZF=0 && CF=0 - /// VUCOMISS xmm1, xmm2/m32 ; ZF=0 && CF=0 - /// VUCOMISS xmm1, xmm2/m32{sae} ; ZF=0 && CF=0 + /// int _mm_ucomigt_ss (__m128 a, __m128 b) + /// UCOMISS xmm1, xmm2/m32 ; ZF=0 && CF=0 + /// VUCOMISS xmm1, xmm2/m32 ; ZF=0 && CF=0 + /// VUCOMISS xmm1, xmm2/m32{sae} ; ZF=0 && CF=0 /// public static bool CompareScalarUnorderedGreaterThan(Vector128 left, Vector128 right) => CompareScalarUnorderedGreaterThan(left, right); /// - /// int _mm_ucomige_ss (__m128 a, __m128 b) - /// UCOMISS xmm1, xmm2/m32 ; CF=0 - /// VUCOMISS xmm1, xmm2/m32 ; CF=0 - /// VUCOMISS xmm1, xmm2/m32{sae} ; CF=0 + /// int _mm_ucomige_ss (__m128 a, __m128 b) + /// UCOMISS xmm1, xmm2/m32 ; CF=0 + /// VUCOMISS xmm1, xmm2/m32 ; CF=0 + /// VUCOMISS xmm1, xmm2/m32{sae} ; CF=0 /// public static bool CompareScalarUnorderedGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareScalarUnorderedGreaterThanOrEqual(left, right); /// - /// int _mm_ucomilt_ss (__m128 a, __m128 b) - /// UCOMISS xmm1, xmm2/m32 ; PF=0 && CF=1 - /// VUCOMISS xmm1, xmm2/m32 ; PF=0 && CF=1 - /// VUCOMISS xmm1, xmm2/m32{sae} ; PF=0 && CF=1 + /// int _mm_ucomilt_ss (__m128 a, __m128 b) + /// UCOMISS xmm1, xmm2/m32 ; PF=0 && CF=1 + /// VUCOMISS xmm1, xmm2/m32 ; PF=0 && CF=1 + /// VUCOMISS xmm1, xmm2/m32{sae} ; PF=0 && CF=1 /// public static bool CompareScalarUnorderedLessThan(Vector128 left, Vector128 right) => CompareScalarUnorderedLessThan(left, right); /// - /// int _mm_ucomile_ss (__m128 a, __m128 b) - /// UCOMISS xmm1, xmm2/m32 ; PF=0 && (ZF=1 || CF=1) - /// VUCOMISS xmm1, xmm2/m32 ; PF=0 && (ZF=1 || CF=1) - /// VUCOMISS xmm1, xmm2/m32{sae} ; PF=0 && (ZF=1 || CF=1) + /// int _mm_ucomile_ss (__m128 a, __m128 b) + /// UCOMISS xmm1, xmm2/m32 ; PF=0 && (ZF=1 || CF=1) + /// VUCOMISS xmm1, xmm2/m32 ; PF=0 && (ZF=1 || CF=1) + /// VUCOMISS xmm1, xmm2/m32{sae} ; PF=0 && (ZF=1 || CF=1) /// public static bool CompareScalarUnorderedLessThanOrEqual(Vector128 left, Vector128 right) => CompareScalarUnorderedLessThanOrEqual(left, right); /// - /// int _mm_ucomineq_ss (__m128 a, __m128 b) - /// UCOMISS xmm1, xmm2/m32 ; ZF=0 || PF=1 - /// VUCOMISS xmm1, xmm2/m32 ; ZF=0 || PF=1 - /// VUCOMISS xmm1, xmm2/m32{sae} ; ZF=0 || PF=1 + /// int _mm_ucomineq_ss (__m128 a, __m128 b) + /// UCOMISS xmm1, xmm2/m32 ; ZF=0 || PF=1 + /// VUCOMISS xmm1, xmm2/m32 ; ZF=0 || PF=1 + /// VUCOMISS xmm1, xmm2/m32{sae} ; ZF=0 || PF=1 /// public static bool CompareScalarUnorderedNotEqual(Vector128 left, Vector128 right) => CompareScalarUnorderedNotEqual(left, right); /// - /// __m128 _mm_cmpunord_ps (__m128 a, __m128 b) - /// CMPPS xmm1, xmm2/m128, imm8(3) - /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(3) + /// __m128 _mm_cmpunord_ps (__m128 a, __m128 b) + /// CMPPS xmm1, xmm2/m128, imm8(3) + /// VCMPPS xmm1, xmm2, xmm3/m128, imm8(3) /// public static Vector128 CompareUnordered(Vector128 left, Vector128 right) => CompareUnordered(left, right); /// - /// __m128 _mm_cvtsi32_ss (__m128 a, int b) - /// CVTSI2SS xmm1, r/m32 - /// VCVTSI2SS xmm1, xmm2, r/m32 + /// __m128 _mm_cvtsi32_ss (__m128 a, int b) + /// CVTSI2SS xmm1, r/m32 + /// VCVTSI2SS xmm1, xmm2, r/m32 /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, int value) => ConvertScalarToVector128Single(upper, value); /// - /// int _mm_cvtss_si32 (__m128 a) - /// CVTSS2SI r32, xmm1/m32 - /// VCVTSS2SI r32, xmm1/m32 + /// int _mm_cvtss_si32 (__m128 a) + /// CVTSS2SI r32, xmm1/m32 + /// VCVTSS2SI r32, xmm1/m32 /// public static int ConvertToInt32(Vector128 value) => ConvertToInt32(value); /// - /// int _mm_cvttss_si32 (__m128 a) - /// CVTTSS2SI r32, xmm1/m32 - /// VCVTTSS2SI r32, xmm1/m32 + /// int _mm_cvttss_si32 (__m128 a) + /// CVTTSS2SI r32, xmm1/m32 + /// VCVTTSS2SI r32, xmm1/m32 /// public static int ConvertToInt32WithTruncation(Vector128 value) => ConvertToInt32WithTruncation(value); /// - /// __m128 _mm_div_ps (__m128 a, __m128 b) - /// DIVPS xmm, xmm2/m128 - /// VDIVPS xmm1, xmm2, xmm3/m128 - /// VDIVPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_div_ps (__m128 a, __m128 b) + /// DIVPS xmm, xmm2/m128 + /// VDIVPS xmm1, xmm2, xmm3/m128 + /// VDIVPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Divide(Vector128 left, Vector128 right) => Divide(left, right); /// - /// __m128 _mm_div_ss (__m128 a, __m128 b) - /// DIVSs xmm1, xmm2/m32 - /// VDIVSs xmm1, xmm2, xmm3/m32 + /// __m128 _mm_div_ss (__m128 a, __m128 b) + /// DIVSs xmm1, xmm2/m32 + /// VDIVSs xmm1, xmm2, xmm3/m32 /// public static Vector128 DivideScalar(Vector128 left, Vector128 right) => DivideScalar(left, right); /// - /// __m128 _mm_load_ps (float const* mem_address) - /// MOVAPS xmm1, m128 - /// VMOVAPS xmm1, m128 - /// VMOVAPS xmm1 {k1}{z}, m128 + /// __m128 _mm_load_ps (float const* mem_address) + /// MOVAPS xmm1, m128 + /// VMOVAPS xmm1, m128 + /// VMOVAPS xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadAlignedVector128(float* address) => LoadAlignedVector128(address); /// - /// __m128 _mm_loadh_pi (__m128 a, __m64 const* mem_addr) - /// MOVHPS xmm1, m64 - /// VMOVHPS xmm1, xmm2, m64 + /// __m128 _mm_loadh_pi (__m128 a, __m64 const* mem_addr) + /// MOVHPS xmm1, m64 + /// VMOVHPS xmm1, xmm2, m64 /// public static unsafe Vector128 LoadHigh(Vector128 lower, float* address) => LoadHigh(lower, address); /// - /// __m128 _mm_loadl_pi (__m128 a, __m64 const* mem_addr) - /// MOVLPS xmm1, m64 - /// VMOVLPS xmm1, xmm2, m64 + /// __m128 _mm_loadl_pi (__m128 a, __m64 const* mem_addr) + /// MOVLPS xmm1, m64 + /// VMOVLPS xmm1, xmm2, m64 /// public static unsafe Vector128 LoadLow(Vector128 upper, float* address) => LoadLow(upper, address); /// - /// __m128 _mm_load_ss (float const* mem_address) - /// MOVSS xmm1, m32 - /// VMOVSS xmm1, m32 - /// VMOVSS xmm1 {k1}, m32 + /// __m128 _mm_load_ss (float const* mem_address) + /// MOVSS xmm1, m32 + /// VMOVSS xmm1, m32 + /// VMOVSS xmm1 {k1}, m32 /// public static unsafe Vector128 LoadScalarVector128(float* address) => LoadScalarVector128(address); /// - /// __m128 _mm_loadu_ps (float const* mem_address) - /// MOVUPS xmm1, m128 - /// VMOVUPS xmm1, m128 - /// VMOVUPS xmm1 {k1}{z}, m128 + /// __m128 _mm_loadu_ps (float const* mem_address) + /// MOVUPS xmm1, m128 + /// VMOVUPS xmm1, m128 + /// VMOVUPS xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadVector128(float* address) => LoadVector128(address); /// - /// __m128 _mm_max_ps (__m128 a, __m128 b) - /// MAXPS xmm1, xmm2/m128 - /// VMAXPS xmm1, xmm2, xmm3/m128 - /// VMAXPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_max_ps (__m128 a, __m128 b) + /// MAXPS xmm1, xmm2/m128 + /// VMAXPS xmm1, xmm2, xmm3/m128 + /// VMAXPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// - /// __m128 _mm_max_ss (__m128 a, __m128 b) - /// MAXSS xmm1, xmm2/m32 - /// VMAXSS xmm1, xmm2, xmm3/m32 + /// __m128 _mm_max_ss (__m128 a, __m128 b) + /// MAXSS xmm1, xmm2/m32 + /// VMAXSS xmm1, xmm2, xmm3/m32 /// public static Vector128 MaxScalar(Vector128 left, Vector128 right) => MaxScalar(left, right); /// - /// __m128 _mm_min_ps (__m128 a, __m128 b) - /// MINPS xmm1, xmm2/m128 - /// VMINPS xmm1, xmm2, xmm3/m128 - /// VMINPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_min_ps (__m128 a, __m128 b) + /// MINPS xmm1, xmm2/m128 + /// VMINPS xmm1, xmm2, xmm3/m128 + /// VMINPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// - /// __m128 _mm_min_ss (__m128 a, __m128 b) - /// MINSS xmm1, xmm2/m32 - /// VMINSS xmm1, xmm2, xmm3/m32 + /// __m128 _mm_min_ss (__m128 a, __m128 b) + /// MINSS xmm1, xmm2/m32 + /// VMINSS xmm1, xmm2, xmm3/m32 /// public static Vector128 MinScalar(Vector128 left, Vector128 right) => MinScalar(left, right); /// - /// __m128 _mm_movehl_ps (__m128 a, __m128 b) - /// MOVHLPS xmm1, xmm2 - /// VMOVHLPS xmm1, xmm2, xmm3 + /// __m128 _mm_movehl_ps (__m128 a, __m128 b) + /// MOVHLPS xmm1, xmm2 + /// VMOVHLPS xmm1, xmm2, xmm3 /// public static Vector128 MoveHighToLow(Vector128 left, Vector128 right) => MoveHighToLow(left, right); /// - /// __m128 _mm_movelh_ps (__m128 a, __m128 b) - /// MOVLHPS xmm1, xmm2 - /// VMOVLHPS xmm1, xmm2, xmm3 + /// __m128 _mm_movelh_ps (__m128 a, __m128 b) + /// MOVLHPS xmm1, xmm2 + /// VMOVLHPS xmm1, xmm2, xmm3 /// public static Vector128 MoveLowToHigh(Vector128 left, Vector128 right) => MoveLowToHigh(left, right); /// - /// int _mm_movemask_ps (__m128 a) - /// MOVMSKPS r32, xmm1 - /// VMOVMSKPS r32, xmm1 + /// int _mm_movemask_ps (__m128 a) + /// MOVMSKPS r32, xmm1 + /// VMOVMSKPS r32, xmm1 /// public static int MoveMask(Vector128 value) => MoveMask(value); /// - /// __m128 _mm_move_ss (__m128 a, __m128 b) - /// MOVSS xmm1, xmm2 - /// VMOVSS xmm1, xmm2, xmm3 - /// VMOVSS xmm1 {k1}{z}, xmm2, xmm3 + /// __m128 _mm_move_ss (__m128 a, __m128 b) + /// MOVSS xmm1, xmm2 + /// VMOVSS xmm1, xmm2, xmm3 + /// VMOVSS xmm1 {k1}{z}, xmm2, xmm3 /// public static Vector128 MoveScalar(Vector128 upper, Vector128 value) => MoveScalar(upper, value); /// - /// __m128 _mm_mul_ps (__m128 a, __m128 b) - /// MULPS xmm1, xmm2/m128 - /// VMULPS xmm1, xmm2, xmm3/m128 - /// VMULPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_mul_ps (__m128 a, __m128 b) + /// MULPS xmm1, xmm2/m128 + /// VMULPS xmm1, xmm2, xmm3/m128 + /// VMULPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); /// - /// __m128 _mm_mul_ss (__m128 a, __m128 b) - /// MULSS xmm1, xmm2/m32 - /// VMULSS xmm1, xmm2, xmm3/m32 + /// __m128 _mm_mul_ss (__m128 a, __m128 b) + /// MULSS xmm1, xmm2/m32 + /// VMULSS xmm1, xmm2, xmm3/m32 /// public static Vector128 MultiplyScalar(Vector128 left, Vector128 right) => MultiplyScalar(left, right); /// - /// __m128 _mm_or_ps (__m128 a, __m128 b) - /// ORPS xmm1, xmm2/m128 - /// VORPS xmm1, xmm2, xmm3/m128 - /// VORPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_or_ps (__m128 a, __m128 b) + /// ORPS xmm1, xmm2/m128 + /// VORPS xmm1, xmm2, xmm3/m128 + /// VORPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// - /// void _mm_prefetch(char* p, int i) - /// PREFETCHT0 m8 + /// void _mm_prefetch(char* p, int i) + /// PREFETCHT0 m8 /// public static unsafe void Prefetch0(void* address) => Prefetch0(address); /// - /// void _mm_prefetch(char* p, int i) - /// PREFETCHT1 m8 + /// void _mm_prefetch(char* p, int i) + /// PREFETCHT1 m8 /// public static unsafe void Prefetch1(void* address) => Prefetch1(address); /// - /// void _mm_prefetch(char* p, int i) - /// PREFETCHT2 m8 + /// void _mm_prefetch(char* p, int i) + /// PREFETCHT2 m8 /// public static unsafe void Prefetch2(void* address) => Prefetch2(address); /// - /// void _mm_prefetch(char* p, int i) - /// PREFETCHNTA m8 + /// void _mm_prefetch(char* p, int i) + /// PREFETCHNTA m8 /// public static unsafe void PrefetchNonTemporal(void* address) => PrefetchNonTemporal(address); /// - /// __m128 _mm_rcp_ps (__m128 a) - /// RCPPS xmm1, xmm2/m128 - /// VRCPPS xmm1, xmm2/m128 + /// __m128 _mm_rcp_ps (__m128 a) + /// RCPPS xmm1, xmm2/m128 + /// VRCPPS xmm1, xmm2/m128 /// public static Vector128 Reciprocal(Vector128 value) => Reciprocal(value); /// - /// __m128 _mm_rcp_ss (__m128 a) - /// RCPSS xmm1, xmm2/m32 - /// VRCPSS xmm1, xmm2, xmm3/m32 + /// __m128 _mm_rcp_ss (__m128 a) + /// RCPSS xmm1, xmm2/m32 + /// VRCPSS xmm1, xmm2, xmm3/m32 /// public static Vector128 ReciprocalScalar(Vector128 value) => ReciprocalScalar(value); /// - /// __m128 _mm_rcp_ss (__m128 a, __m128 b) - /// RCPSS xmm1, xmm2/m32 - /// VRCPSS xmm1, xmm2, xmm3/m32 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_rcp_ss (__m128 a, __m128 b) + /// RCPSS xmm1, xmm2/m32 + /// VRCPSS xmm1, xmm2, xmm3/m32 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 ReciprocalScalar(Vector128 upper, Vector128 value) => ReciprocalScalar(upper, value); /// - /// __m128 _mm_rsqrt_ps (__m128 a) - /// RSQRTPS xmm1, xmm2/m128 - /// VRSQRTPS xmm1, xmm2/m128 + /// __m128 _mm_rsqrt_ps (__m128 a) + /// RSQRTPS xmm1, xmm2/m128 + /// VRSQRTPS xmm1, xmm2/m128 /// public static Vector128 ReciprocalSqrt(Vector128 value) => ReciprocalSqrt(value); /// - /// __m128 _mm_rsqrt_ss (__m128 a) - /// RSQRTSS xmm1, xmm2/m32 - /// VRSQRTSS xmm1, xmm2, xmm3/m32 + /// __m128 _mm_rsqrt_ss (__m128 a) + /// RSQRTSS xmm1, xmm2/m32 + /// VRSQRTSS xmm1, xmm2, xmm3/m32 /// public static Vector128 ReciprocalSqrtScalar(Vector128 value) => ReciprocalSqrtScalar(value); /// - /// __m128 _mm_rsqrt_ss (__m128 a, __m128 b) - /// RSQRTSS xmm1, xmm2/m32 - /// VRSQRTSS xmm1, xmm2, xmm3/m32 - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_rsqrt_ss (__m128 a, __m128 b) + /// RSQRTSS xmm1, xmm2/m32 + /// VRSQRTSS xmm1, xmm2, xmm3/m32 + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 ReciprocalSqrtScalar(Vector128 upper, Vector128 value) => ReciprocalSqrtScalar(upper, value); /// - /// __m128 _mm_shuffle_ps (__m128 a, __m128 b, unsigned int control) - /// SHUFPS xmm1, xmm2/m128, imm8 - /// VSHUFPS xmm1, xmm2, xmm3/m128, imm8 - /// VSHUFPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 + /// __m128 _mm_shuffle_ps (__m128 a, __m128 b, unsigned int control) + /// SHUFPS xmm1, xmm2/m128, imm8 + /// VSHUFPS xmm1, xmm2, xmm3/m128, imm8 + /// VSHUFPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst, imm8 /// public static Vector128 Shuffle(Vector128 left, Vector128 right, [ConstantExpected] byte control) => Shuffle(left, right, control); /// - /// __m128 _mm_sqrt_ps (__m128 a) - /// SQRTPS xmm1, xmm2/m128 - /// VSQRTPS xmm1, xmm2/m128 - /// VSQRTPS xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128 _mm_sqrt_ps (__m128 a) + /// SQRTPS xmm1, xmm2/m128 + /// VSQRTPS xmm1, xmm2/m128 + /// VSQRTPS xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 Sqrt(Vector128 value) => Sqrt(value); /// - /// __m128 _mm_sqrt_ss (__m128 a) - /// SQRTSS xmm1, xmm2/m32 - /// VSQRTSS xmm1, xmm2, xmm3/m32 - /// VSQRTSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} + /// __m128 _mm_sqrt_ss (__m128 a) + /// SQRTSS xmm1, xmm2/m32 + /// VSQRTSS xmm1, xmm2, xmm3/m32 + /// VSQRTSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} /// public static Vector128 SqrtScalar(Vector128 value) => SqrtScalar(value); /// - /// __m128 _mm_sqrt_ss (__m128 a, __m128 b) - /// SQRTSS xmm1, xmm2/m32 - /// VSQRTSS xmm1, xmm2, xmm3/m32 - /// VSQRTSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} - /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. + /// __m128 _mm_sqrt_ss (__m128 a, __m128 b) + /// SQRTSS xmm1, xmm2/m32 + /// VSQRTSS xmm1, xmm2, xmm3/m32 + /// VSQRTSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} + /// The above native signature does not exist. We provide this additional overload for consistency with the other scalar APIs. /// public static Vector128 SqrtScalar(Vector128 upper, Vector128 value) => SqrtScalar(upper, value); /// - /// void _mm_storeu_ps (float* mem_addr, __m128 a) - /// MOVAPS m128, xmm1 - /// VMOVAPS m128, xmm1 - /// VMOVAPS m128 {k1}{z}, xmm1 + /// void _mm_storeu_ps (float* mem_addr, __m128 a) + /// MOVAPS m128, xmm1 + /// VMOVAPS m128, xmm1 + /// VMOVAPS m128 {k1}{z}, xmm1 /// public static unsafe void Store(float* address, Vector128 source) => Store(address, source); /// - /// void _mm_store_ps (float* mem_addr, __m128 a) - /// MOVAPS m128, xmm1 - /// VMOVAPS m128, xmm1 - /// VMOVAPS m128 {k1}{z}, xmm1 + /// void _mm_store_ps (float* mem_addr, __m128 a) + /// MOVAPS m128, xmm1 + /// VMOVAPS m128, xmm1 + /// VMOVAPS m128 {k1}{z}, xmm1 /// public static unsafe void StoreAligned(float* address, Vector128 source) => StoreAligned(address, source); /// - /// void _mm_stream_ps (float* mem_addr, __m128 a) - /// MOVNTPS m128, xmm1 - /// VMOVNTPS m128, xmm1 + /// void _mm_stream_ps (float* mem_addr, __m128 a) + /// MOVNTPS m128, xmm1 + /// VMOVNTPS m128, xmm1 /// public static unsafe void StoreAlignedNonTemporal(float* address, Vector128 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm_sfence(void) - /// SFENCE + /// void _mm_sfence(void) + /// SFENCE /// public static void StoreFence() => StoreFence(); /// - /// void _mm_storeh_pi (__m64* mem_addr, __m128 a) - /// MOVHPS m64, xmm1 - /// VMOVHPS m64, xmm1 + /// void _mm_storeh_pi (__m64* mem_addr, __m128 a) + /// MOVHPS m64, xmm1 + /// VMOVHPS m64, xmm1 /// public static unsafe void StoreHigh(float* address, Vector128 source) => StoreHigh(address, source); /// - /// void _mm_storel_pi (__m64* mem_addr, __m128 a) - /// MOVLPS m64, xmm1 - /// VMOVLPS m64, xmm1 + /// void _mm_storel_pi (__m64* mem_addr, __m128 a) + /// MOVLPS m64, xmm1 + /// VMOVLPS m64, xmm1 /// public static unsafe void StoreLow(float* address, Vector128 source) => StoreLow(address, source); /// - /// void _mm_store_ss (float* mem_addr, __m128 a) - /// MOVSS m32, xmm1 - /// VMOVSS m32, xmm1 - /// VMOVSS m32 {k1}, xmm1 + /// void _mm_store_ss (float* mem_addr, __m128 a) + /// MOVSS m32, xmm1 + /// VMOVSS m32, xmm1 + /// VMOVSS m32 {k1}, xmm1 /// public static unsafe void StoreScalar(float* address, Vector128 source) => StoreScalar(address, source); /// - /// __m128d _mm_sub_ps (__m128d a, __m128d b) - /// SUBPS xmm1, xmm2/m128 - /// VSUBPS xmm1, xmm2, xmm3/m128 - /// VSUBPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128d _mm_sub_ps (__m128d a, __m128d b) + /// SUBPS xmm1, xmm2/m128 + /// VSUBPS xmm1, xmm2, xmm3/m128 + /// VSUBPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// - /// __m128 _mm_sub_ss (__m128 a, __m128 b) - /// SUBSS xmm1, xmm2/m32 - /// VSUBSS xmm1, xmm2, xmm3/m32 - /// VSUBSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} + /// __m128 _mm_sub_ss (__m128 a, __m128 b) + /// SUBSS xmm1, xmm2/m32 + /// VSUBSS xmm1, xmm2, xmm3/m32 + /// VSUBSS xmm1 {k1}{z}, xmm2, xmm3/m32{er} /// public static Vector128 SubtractScalar(Vector128 left, Vector128 right) => SubtractScalar(left, right); /// - /// __m128 _mm_unpackhi_ps (__m128 a, __m128 b) - /// UNPCKHPS xmm1, xmm2/m128 - /// VUNPCKHPS xmm1, xmm2, xmm3/m128 - /// VUNPCKHPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_unpackhi_ps (__m128 a, __m128 b) + /// UNPCKHPS xmm1, xmm2/m128 + /// VUNPCKHPS xmm1, xmm2, xmm3/m128 + /// VUNPCKHPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 UnpackHigh(Vector128 left, Vector128 right) => UnpackHigh(left, right); /// - /// __m128 _mm_unpacklo_ps (__m128 a, __m128 b) - /// UNPCKLPS xmm1, xmm2/m128 - /// VUNPCKLPS xmm1, xmm2, xmm3/m128 - /// VUNPCKLPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_unpacklo_ps (__m128 a, __m128 b) + /// UNPCKLPS xmm1, xmm2/m128 + /// VUNPCKLPS xmm1, xmm2, xmm3/m128 + /// VUNPCKLPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 UnpackLow(Vector128 left, Vector128 right) => UnpackLow(left, right); /// - /// __m128 _mm_xor_ps (__m128 a, __m128 b) - /// XORPS xmm1, xmm2/m128 - /// VXORPS xmm1, xmm2, xmm3/m128 - /// VXORPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128 _mm_xor_ps (__m128 a, __m128 b) + /// XORPS xmm1, xmm2/m128 + /// VXORPS xmm1, xmm2, xmm3/m128 + /// VXORPS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse2.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse2.PlatformNotSupported.cs index a52b19af01d..4fae2c1bf12 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse2.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse2.PlatformNotSupported.cs @@ -8,2136 +8,2141 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel SSE2 hardware instructions via intrinsics - /// + /// Provides access to X86 SSE2 hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Sse2 : Sse { internal Sse2() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } + /// Provides access to the x86 SSE2 hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class X64 : Sse.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } /// - /// __m128d _mm_cvtsi64_sd (__m128d a, __int64 b) - /// CVTSI2SD xmm1, r/m64 - /// VCVTSI2SD xmm1, xmm2, r/m64 - /// This intrinsic is only available on 64-bit processes + /// __m128d _mm_cvtsi64_sd (__m128d a, __int64 b) + /// CVTSI2SD xmm1, r/m64 + /// VCVTSI2SD xmm1, xmm2, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Double(Vector128 upper, long value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtsi64_si128 (__int64 a) - /// MOVQ xmm1, r/m64 - /// VMOVQ xmm1, r/m64 - /// This intrinsic is only available on 64-bit processes + /// __m128i _mm_cvtsi64_si128 (__int64 a) + /// MOVQ xmm1, r/m64 + /// VMOVQ xmm1, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Int64(long value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtsi64_si128 (__int64 a) - /// MOVQ xmm1, r/m64 - /// VMOVQ xmm1, r/m64 - /// This intrinsic is only available on 64-bit processes + /// __m128i _mm_cvtsi64_si128 (__int64 a) + /// MOVQ xmm1, r/m64 + /// VMOVQ xmm1, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128UInt64(ulong value) { throw new PlatformNotSupportedException(); } /// - /// __int64 _mm_cvtsi128_si64 (__m128i a) - /// MOVQ r/m64, xmm1 - /// VMOVQ r/m64, xmm1 - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_cvtsi128_si64 (__m128i a) + /// MOVQ r/m64, xmm1 + /// VMOVQ r/m64, xmm1 + /// This intrinsic is only available on 64-bit processes /// public static long ConvertToInt64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __int64 _mm_cvtsd_si64 (__m128d a) - /// CVTSD2SI r64, xmm1/m64 - /// VCVTSD2SI r64, xmm1/m64 - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_cvtsd_si64 (__m128d a) + /// CVTSD2SI r64, xmm1/m64 + /// VCVTSD2SI r64, xmm1/m64 + /// This intrinsic is only available on 64-bit processes /// public static long ConvertToInt64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __int64 _mm_cvttsd_si64 (__m128d a) - /// CVTTSD2SI r64, xmm1/m64 - /// VCVTTSD2SI r64, xmm1/m64 - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_cvttsd_si64 (__m128d a) + /// CVTTSD2SI r64, xmm1/m64 + /// VCVTTSD2SI r64, xmm1/m64 + /// This intrinsic is only available on 64-bit processes /// public static long ConvertToInt64WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __int64 _mm_cvtsi128_si64 (__m128i a) - /// MOVQ r/m64, xmm1 - /// VMOVQ r/m64, xmm1 - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_cvtsi128_si64 (__m128i a) + /// MOVQ r/m64, xmm1 + /// VMOVQ r/m64, xmm1 + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// void _mm_stream_si64(__int64 *p, __int64 a) - /// MOVNTI m64, r64 - /// This intrinsic is only available on 64-bit processes + /// void _mm_stream_si64(__int64 *p, __int64 a) + /// MOVNTI m64, r64 + /// This intrinsic is only available on 64-bit processes /// public static unsafe void StoreNonTemporal(long* address, long value) { throw new PlatformNotSupportedException(); } /// - /// void _mm_stream_si64(__int64 *p, __int64 a) - /// MOVNTI m64, r64 - /// This intrinsic is only available on 64-bit processes + /// void _mm_stream_si64(__int64 *p, __int64 a) + /// MOVNTI m64, r64 + /// This intrinsic is only available on 64-bit processes /// public static unsafe void StoreNonTemporal(ulong* address, ulong value) { throw new PlatformNotSupportedException(); } } /// - /// __m128i _mm_add_epi8 (__m128i a, __m128i b) - /// PADDB xmm1, xmm2/m128 - /// VPADDB xmm1, xmm2, xmm3/m128 - /// VPADDB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_add_epi8 (__m128i a, __m128i b) + /// PADDB xmm1, xmm2/m128 + /// VPADDB xmm1, xmm2, xmm3/m128 + /// VPADDB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_add_epi8 (__m128i a, __m128i b) - /// PADDB xmm1, xmm2/m128 - /// VPADDB xmm1, xmm2, xmm3/m128 - /// VPADDB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_add_epi8 (__m128i a, __m128i b) + /// PADDB xmm1, xmm2/m128 + /// VPADDB xmm1, xmm2, xmm3/m128 + /// VPADDB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_add_epi16 (__m128i a, __m128i b) - /// PADDW xmm1, xmm2/m128 - /// VPADDW xmm1, xmm2, xmm3/m128 - /// VPADDW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_add_epi16 (__m128i a, __m128i b) + /// PADDW xmm1, xmm2/m128 + /// VPADDW xmm1, xmm2, xmm3/m128 + /// VPADDW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_add_epi16 (__m128i a, __m128i b) - /// PADDW xmm1, xmm2/m128 - /// VPADDW xmm1, xmm2, xmm3/m128 - /// VPADDW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_add_epi16 (__m128i a, __m128i b) + /// PADDW xmm1, xmm2/m128 + /// VPADDW xmm1, xmm2, xmm3/m128 + /// VPADDW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_add_epi32 (__m128i a, __m128i b) - /// PADDD xmm1, xmm2/m128 - /// VPADDD xmm1, xmm2, xmm3/m128 - /// VPADDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_add_epi32 (__m128i a, __m128i b) + /// PADDD xmm1, xmm2/m128 + /// VPADDD xmm1, xmm2, xmm3/m128 + /// VPADDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_add_epi32 (__m128i a, __m128i b) - /// PADDD xmm1, xmm2/m128 - /// VPADDD xmm1, xmm2, xmm3/m128 - /// VPADDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_add_epi32 (__m128i a, __m128i b) + /// PADDD xmm1, xmm2/m128 + /// VPADDD xmm1, xmm2, xmm3/m128 + /// VPADDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_add_epi64 (__m128i a, __m128i b) - /// PADDQ xmm1, xmm2/m128 - /// VPADDQ xmm1, xmm2, xmm3/m128 - /// VPADDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_add_epi64 (__m128i a, __m128i b) + /// PADDQ xmm1, xmm2/m128 + /// VPADDQ xmm1, xmm2, xmm3/m128 + /// VPADDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_add_epi64 (__m128i a, __m128i b) - /// PADDQ xmm1, xmm2/m128 - /// VPADDQ xmm1, xmm2, xmm3/m128 - /// VPADDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_add_epi64 (__m128i a, __m128i b) + /// PADDQ xmm1, xmm2/m128 + /// VPADDQ xmm1, xmm2, xmm3/m128 + /// VPADDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_add_pd (__m128d a, __m128d b) - /// ADDPD xmm1, xmm2/m128 - /// VADDPD xmm1, xmm2, xmm3/m128 - /// VADDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_add_pd (__m128d a, __m128d b) + /// ADDPD xmm1, xmm2/m128 + /// VADDPD xmm1, xmm2, xmm3/m128 + /// VADDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Add(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_add_sd (__m128d a, __m128d b) - /// ADDSD xmm1, xmm2/m64 - /// VADDSD xmm1, xmm2, xmm3/m64 - /// VADDSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} + /// __m128d _mm_add_sd (__m128d a, __m128d b) + /// ADDSD xmm1, xmm2/m64 + /// VADDSD xmm1, xmm2, xmm3/m64 + /// VADDSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} /// public static Vector128 AddScalar(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_adds_epi8 (__m128i a, __m128i b) - /// PADDSB xmm1, xmm2/m128 - /// VPADDSB xmm1, xmm2, xmm3/m128 - /// VPADDSB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_adds_epi8 (__m128i a, __m128i b) + /// PADDSB xmm1, xmm2/m128 + /// VPADDSB xmm1, xmm2, xmm3/m128 + /// VPADDSB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_adds_epu8 (__m128i a, __m128i b) - /// PADDUSB xmm1, xmm2/m128 - /// VPADDUSB xmm1, xmm2, xmm3/m128 - /// VPADDUSB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_adds_epu8 (__m128i a, __m128i b) + /// PADDUSB xmm1, xmm2/m128 + /// VPADDUSB xmm1, xmm2, xmm3/m128 + /// VPADDUSB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_adds_epi16 (__m128i a, __m128i b) - /// PADDSW xmm1, xmm2/m128 - /// VPADDSW xmm1, xmm2, xmm3/m128 - /// VPADDSW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_adds_epi16 (__m128i a, __m128i b) + /// PADDSW xmm1, xmm2/m128 + /// VPADDSW xmm1, xmm2, xmm3/m128 + /// VPADDSW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_adds_epu16 (__m128i a, __m128i b) - /// PADDUSW xmm1, xmm2/m128 - /// VPADDUSW xmm1, xmm2, xmm3/m128 - /// VPADDUSW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_adds_epu16 (__m128i a, __m128i b) + /// PADDUSW xmm1, xmm2/m128 + /// VPADDUSW xmm1, xmm2, xmm3/m128 + /// VPADDUSW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_and_si128 (__m128i a, __m128i b) - /// PAND xmm1, xmm2/m128 - /// VPAND xmm1, xmm2, xmm3/m128 + /// __m128i _mm_and_si128 (__m128i a, __m128i b) + /// PAND xmm1, xmm2/m128 + /// VPAND xmm1, xmm2, xmm3/m128 /// public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_and_si128 (__m128i a, __m128i b) - /// PAND xmm1, xmm2/m128 - /// VPAND xmm1, xmm2, xmm3/m128 + /// __m128i _mm_and_si128 (__m128i a, __m128i b) + /// PAND xmm1, xmm2/m128 + /// VPAND xmm1, xmm2, xmm3/m128 /// public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_and_si128 (__m128i a, __m128i b) - /// PAND xmm1, xmm2/m128 - /// VPAND xmm1, xmm2, xmm3/m128 + /// __m128i _mm_and_si128 (__m128i a, __m128i b) + /// PAND xmm1, xmm2/m128 + /// VPAND xmm1, xmm2, xmm3/m128 /// public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_and_si128 (__m128i a, __m128i b) - /// PAND xmm1, xmm2/m128 - /// VPAND xmm1, xmm2, xmm3/m128 + /// __m128i _mm_and_si128 (__m128i a, __m128i b) + /// PAND xmm1, xmm2/m128 + /// VPAND xmm1, xmm2, xmm3/m128 /// public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_and_si128 (__m128i a, __m128i b) - /// PAND xmm1, xmm2/m128 - /// VPAND xmm1, xmm2, xmm3/m128 - /// VPANDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_and_si128 (__m128i a, __m128i b) + /// PAND xmm1, xmm2/m128 + /// VPAND xmm1, xmm2, xmm3/m128 + /// VPANDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_and_si128 (__m128i a, __m128i b) - /// PAND xmm1, xmm2/m128 - /// VPAND xmm1, xmm2, xmm3/m128 - /// VPANDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_and_si128 (__m128i a, __m128i b) + /// PAND xmm1, xmm2/m128 + /// VPAND xmm1, xmm2, xmm3/m128 + /// VPANDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_and_si128 (__m128i a, __m128i b) - /// PAND xmm1, xmm2/m128 - /// VPAND xmm1, xmm2, xmm3/m128 - /// VPANDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_and_si128 (__m128i a, __m128i b) + /// PAND xmm1, xmm2/m128 + /// VPAND xmm1, xmm2, xmm3/m128 + /// VPANDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_and_si128 (__m128i a, __m128i b) - /// PAND xmm1, xmm2/m128 - /// VPAND xmm1, xmm2, xmm3/m128 - /// VPANDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_and_si128 (__m128i a, __m128i b) + /// PAND xmm1, xmm2/m128 + /// VPAND xmm1, xmm2, xmm3/m128 + /// VPANDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_and_pd (__m128d a, __m128d b) - /// ANDPD xmm1, xmm2/m128 - /// VANDPD xmm1, xmm2, xmm3/m128 - /// VANDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_and_pd (__m128d a, __m128d b) + /// ANDPD xmm1, xmm2/m128 + /// VANDPD xmm1, xmm2, xmm3/m128 + /// VANDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 And(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) - /// PANDN xmm1, xmm2/m128 - /// VPANDN xmm1, xmm2, xmm3/m128 + /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) + /// PANDN xmm1, xmm2/m128 + /// VPANDN xmm1, xmm2, xmm3/m128 /// public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) - /// PANDN xmm1, xmm2/m128 - /// VPANDN xmm1, xmm2, xmm3/m128 + /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) + /// PANDN xmm1, xmm2/m128 + /// VPANDN xmm1, xmm2, xmm3/m128 /// public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) - /// PANDN xmm1, xmm2/m128 - /// VPANDN xmm1, xmm2, xmm3/m128 + /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) + /// PANDN xmm1, xmm2/m128 + /// VPANDN xmm1, xmm2, xmm3/m128 /// public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) - /// PANDN xmm1, xmm2/m128 - /// VPANDN xmm1, xmm2, xmm3/m128 + /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) + /// PANDN xmm1, xmm2/m128 + /// VPANDN xmm1, xmm2, xmm3/m128 /// public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) - /// PANDN xmm1, xmm2/m128 - /// VPANDN xmm1, xmm2, xmm3/m128 - /// VPANDND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) + /// PANDN xmm1, xmm2/m128 + /// VPANDN xmm1, xmm2, xmm3/m128 + /// VPANDND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) - /// PANDN xmm1, xmm2/m128 - /// VPANDN xmm1, xmm2, xmm3/m128 - /// VPANDND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) + /// PANDN xmm1, xmm2/m128 + /// VPANDN xmm1, xmm2, xmm3/m128 + /// VPANDND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) - /// PANDN xmm1, xmm2/m128 - /// VPANDN xmm1, xmm2, xmm3/m128 - /// VPANDNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) + /// PANDN xmm1, xmm2/m128 + /// VPANDN xmm1, xmm2, xmm3/m128 + /// VPANDNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) - /// PANDN xmm1, xmm2/m128 - /// VPANDN xmm1, xmm2, xmm3/m128 - /// VPANDNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) + /// PANDN xmm1, xmm2/m128 + /// VPANDN xmm1, xmm2, xmm3/m128 + /// VPANDNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_andnot_pd (__m128d a, __m128d b) - /// ANDNPD xmm1, xmm2/m128 - /// VANDNPD xmm1, xmm2, xmm3/m128 - /// VANDNPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_andnot_pd (__m128d a, __m128d b) + /// ANDNPD xmm1, xmm2/m128 + /// VANDNPD xmm1, xmm2, xmm3/m128 + /// VANDNPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 AndNot(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_avg_epu8 (__m128i a, __m128i b) - /// PAVGB xmm1, xmm2/m128 - /// VPAVGB xmm1, xmm2, xmm3/m128 - /// VPAVGB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_avg_epu8 (__m128i a, __m128i b) + /// PAVGB xmm1, xmm2/m128 + /// VPAVGB xmm1, xmm2, xmm3/m128 + /// VPAVGB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Average(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_avg_epu16 (__m128i a, __m128i b) - /// PAVGW xmm1, xmm2/m128 - /// VPAVGW xmm1, xmm2, xmm3/m128 - /// VPAVGW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_avg_epu16 (__m128i a, __m128i b) + /// PAVGW xmm1, xmm2/m128 + /// VPAVGW xmm1, xmm2, xmm3/m128 + /// VPAVGW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Average(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpeq_epi8 (__m128i a, __m128i b) - /// PCMPEQB xmm1, xmm2/m128 - /// VPCMPEQB xmm1, xmm2, xmm3/m128 + /// __m128i _mm_cmpeq_epi8 (__m128i a, __m128i b) + /// PCMPEQB xmm1, xmm2/m128 + /// VPCMPEQB xmm1, xmm2, xmm3/m128 /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpeq_epi8 (__m128i a, __m128i b) - /// PCMPEQB xmm1, xmm2/m128 - /// VPCMPEQB xmm1, xmm2, xmm3/m128 + /// __m128i _mm_cmpeq_epi8 (__m128i a, __m128i b) + /// PCMPEQB xmm1, xmm2/m128 + /// VPCMPEQB xmm1, xmm2, xmm3/m128 /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpeq_epi16 (__m128i a, __m128i b) - /// PCMPEQW xmm1, xmm2/m128 - /// VPCMPEQW xmm1, xmm2, xmm3/m128 + /// __m128i _mm_cmpeq_epi16 (__m128i a, __m128i b) + /// PCMPEQW xmm1, xmm2/m128 + /// VPCMPEQW xmm1, xmm2, xmm3/m128 /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpeq_epi16 (__m128i a, __m128i b) - /// PCMPEQW xmm1, xmm2/m128 - /// VPCMPEQW xmm1, xmm2, xmm3/m128 + /// __m128i _mm_cmpeq_epi16 (__m128i a, __m128i b) + /// PCMPEQW xmm1, xmm2/m128 + /// VPCMPEQW xmm1, xmm2, xmm3/m128 /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpeq_epi32 (__m128i a, __m128i b) - /// PCMPEQD xmm1, xmm2/m128 - /// VPCMPEQD xmm1, xmm2, xmm3/m128 + /// __m128i _mm_cmpeq_epi32 (__m128i a, __m128i b) + /// PCMPEQD xmm1, xmm2/m128 + /// VPCMPEQD xmm1, xmm2, xmm3/m128 /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpeq_epi32 (__m128i a, __m128i b) - /// PCMPEQD xmm1, xmm2/m128 - /// VPCMPEQD xmm1, xmm2, xmm3/m128 + /// __m128i _mm_cmpeq_epi32 (__m128i a, __m128i b) + /// PCMPEQD xmm1, xmm2/m128 + /// VPCMPEQD xmm1, xmm2, xmm3/m128 /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmpeq_pd (__m128d a, __m128d b) - /// CMPPD xmm1, xmm2/m128, imm8(0) - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(0) + /// __m128d _mm_cmpeq_pd (__m128d a, __m128d b) + /// CMPPD xmm1, xmm2/m128, imm8(0) + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(0) /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpgt_epi8 (__m128i a, __m128i b) - /// PCMPGTB xmm1, xmm2/m128 - /// VPCMPGTB xmm1, xmm2, xmm3/m128 + /// __m128i _mm_cmpgt_epi8 (__m128i a, __m128i b) + /// PCMPGTB xmm1, xmm2/m128 + /// VPCMPGTB xmm1, xmm2, xmm3/m128 /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpgt_epi16 (__m128i a, __m128i b) - /// PCMPGTW xmm1, xmm2/m128 - /// VPCMPGTW xmm1, xmm2, xmm3/m128 + /// __m128i _mm_cmpgt_epi16 (__m128i a, __m128i b) + /// PCMPGTW xmm1, xmm2/m128 + /// VPCMPGTW xmm1, xmm2, xmm3/m128 /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpgt_epi32 (__m128i a, __m128i b) - /// PCMPGTD xmm1, xmm2/m128 - /// VPCMPGTD xmm1, xmm2, xmm3/m128 + /// __m128i _mm_cmpgt_epi32 (__m128i a, __m128i b) + /// PCMPGTD xmm1, xmm2/m128 + /// VPCMPGTD xmm1, xmm2, xmm3/m128 /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmpgt_pd (__m128d a, __m128d b) - /// CMPPD xmm1, xmm2/m128, imm8(1) ; with swapped operands - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(1) ; with swapped operands + /// __m128d _mm_cmpgt_pd (__m128d a, __m128d b) + /// CMPPD xmm1, xmm2/m128, imm8(1) ; with swapped operands + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(1) ; with swapped operands /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmpge_pd (__m128d a, __m128d b) - /// CMPPD xmm1, xmm2/m128, imm8(2) ; with swapped operands - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(2) ; with swapped operands + /// __m128d _mm_cmpge_pd (__m128d a, __m128d b) + /// CMPPD xmm1, xmm2/m128, imm8(2) ; with swapped operands + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(2) ; with swapped operands /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmplt_epi8 (__m128i a, __m128i b) - /// PCMPGTB xmm1, xmm2/m128 ; with swapped operands - /// VPCMPGTB xmm1, xmm2, xmm3/m128 ; with swapped operands + /// __m128i _mm_cmplt_epi8 (__m128i a, __m128i b) + /// PCMPGTB xmm1, xmm2/m128 ; with swapped operands + /// VPCMPGTB xmm1, xmm2, xmm3/m128 ; with swapped operands /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmplt_epi16 (__m128i a, __m128i b) - /// PCMPGTW xmm1, xmm2/m128 ; with swapped operands - /// VPCMPGTW xmm1, xmm2, xmm3/m128 ; with swapped operands + /// __m128i _mm_cmplt_epi16 (__m128i a, __m128i b) + /// PCMPGTW xmm1, xmm2/m128 ; with swapped operands + /// VPCMPGTW xmm1, xmm2, xmm3/m128 ; with swapped operands /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmplt_epi32 (__m128i a, __m128i b) - /// PCMPGTD xmm1, xmm2/m128 ; with swapped operands - /// VPCMPGTD xmm1, xmm2, xmm3/m128 ; with swapped operands + /// __m128i _mm_cmplt_epi32 (__m128i a, __m128i b) + /// PCMPGTD xmm1, xmm2/m128 ; with swapped operands + /// VPCMPGTD xmm1, xmm2, xmm3/m128 ; with swapped operands /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmplt_pd (__m128d a, __m128d b) - /// CMPPD xmm1, xmm2/m128, imm8(1) - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(1) + /// __m128d _mm_cmplt_pd (__m128d a, __m128d b) + /// CMPPD xmm1, xmm2/m128, imm8(1) + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmple_pd (__m128d a, __m128d b) - /// CMPPD xmm1, xmm2/m128, imm8(2) - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(2) + /// __m128d _mm_cmple_pd (__m128d a, __m128d b) + /// CMPPD xmm1, xmm2/m128, imm8(2) + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmpneq_pd (__m128d a, __m128d b) - /// CMPPD xmm1, xmm2/m128, imm8(4) - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(4) + /// __m128d _mm_cmpneq_pd (__m128d a, __m128d b) + /// CMPPD xmm1, xmm2/m128, imm8(4) + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmpngt_pd (__m128d a, __m128d b) - /// CMPPD xmm1, xmm2/m128, imm8(5) ; with swapped operands - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(5) ; with swapped operands + /// __m128d _mm_cmpngt_pd (__m128d a, __m128d b) + /// CMPPD xmm1, xmm2/m128, imm8(5) ; with swapped operands + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(5) ; with swapped operands /// public static Vector128 CompareNotGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmpnge_pd (__m128d a, __m128d b) - /// CMPPD xmm1, xmm2/m128, imm8(6) ; with swapped operands - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(6) ; with swapped operands + /// __m128d _mm_cmpnge_pd (__m128d a, __m128d b) + /// CMPPD xmm1, xmm2/m128, imm8(6) ; with swapped operands + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(6) ; with swapped operands /// public static Vector128 CompareNotGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmpnlt_pd (__m128d a, __m128d b) - /// CMPPD xmm1, xmm2/m128, imm8(5) - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(5) + /// __m128d _mm_cmpnlt_pd (__m128d a, __m128d b) + /// CMPPD xmm1, xmm2/m128, imm8(5) + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(5) /// public static Vector128 CompareNotLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmpnle_pd (__m128d a, __m128d b) - /// CMPPD xmm1, xmm2/m128, imm8(6) - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(6) + /// __m128d _mm_cmpnle_pd (__m128d a, __m128d b) + /// CMPPD xmm1, xmm2/m128, imm8(6) + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(6) /// public static Vector128 CompareNotLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmpord_pd (__m128d a, __m128d b) - /// CMPPD xmm1, xmm2/m128, imm8(7) - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(7) + /// __m128d _mm_cmpord_pd (__m128d a, __m128d b) + /// CMPPD xmm1, xmm2/m128, imm8(7) + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(7) /// public static Vector128 CompareOrdered(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmpeq_sd (__m128d a, __m128d b) - /// CMPDS xmm1, xmm2/m64, imm8(0) - /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(0) + /// __m128d _mm_cmpeq_sd (__m128d a, __m128d b) + /// CMPDS xmm1, xmm2/m64, imm8(0) + /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(0) /// public static Vector128 CompareScalarEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmpgt_sd (__m128d a, __m128d b) - /// CMPDS xmm1, xmm2/m64, imm8(1) ; with swapped operands - /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(1) ; with swapped operands + /// __m128d _mm_cmpgt_sd (__m128d a, __m128d b) + /// CMPDS xmm1, xmm2/m64, imm8(1) ; with swapped operands + /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(1) ; with swapped operands /// public static Vector128 CompareScalarGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmpge_sd (__m128d a, __m128d b) - /// CMPDS xmm1, xmm2/m64, imm8(2) ; with swapped operands - /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(2) ; with swapped operands + /// __m128d _mm_cmpge_sd (__m128d a, __m128d b) + /// CMPDS xmm1, xmm2/m64, imm8(2) ; with swapped operands + /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(2) ; with swapped operands /// public static Vector128 CompareScalarGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmplt_sd (__m128d a, __m128d b) - /// CMPDS xmm1, xmm2/m64, imm8(1) - /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(1) + /// __m128d _mm_cmplt_sd (__m128d a, __m128d b) + /// CMPDS xmm1, xmm2/m64, imm8(1) + /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(1) /// public static Vector128 CompareScalarLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmple_sd (__m128d a, __m128d b) - /// CMPDS xmm1, xmm2/m64, imm8(2) - /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(2) + /// __m128d _mm_cmple_sd (__m128d a, __m128d b) + /// CMPDS xmm1, xmm2/m64, imm8(2) + /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(2) /// public static Vector128 CompareScalarLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmpneq_sd (__m128d a, __m128d b) - /// CMPDS xmm1, xmm2/m64, imm8(4) - /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(4) + /// __m128d _mm_cmpneq_sd (__m128d a, __m128d b) + /// CMPDS xmm1, xmm2/m64, imm8(4) + /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(4) /// public static Vector128 CompareScalarNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmpngt_sd (__m128d a, __m128d b) - /// CMPDS xmm1, xmm2/m64, imm8(5) ; with swapped operands - /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(5) ; with swapped operands + /// __m128d _mm_cmpngt_sd (__m128d a, __m128d b) + /// CMPDS xmm1, xmm2/m64, imm8(5) ; with swapped operands + /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(5) ; with swapped operands /// public static Vector128 CompareScalarNotGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmpnge_sd (__m128d a, __m128d b) - /// CMPDS xmm1, xmm2/m64, imm8(6) ; with swapped operands - /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(6) ; with swapped operands + /// __m128d _mm_cmpnge_sd (__m128d a, __m128d b) + /// CMPDS xmm1, xmm2/m64, imm8(6) ; with swapped operands + /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(6) ; with swapped operands /// public static Vector128 CompareScalarNotGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmpnlt_sd (__m128d a, __m128d b) - /// CMPDS xmm1, xmm2/m64, imm8(5) - /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(5) + /// __m128d _mm_cmpnlt_sd (__m128d a, __m128d b) + /// CMPDS xmm1, xmm2/m64, imm8(5) + /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(5) /// public static Vector128 CompareScalarNotLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmpnle_sd (__m128d a, __m128d b) - /// CMPDS xmm1, xmm2/m64, imm8(6) - /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(6) + /// __m128d _mm_cmpnle_sd (__m128d a, __m128d b) + /// CMPDS xmm1, xmm2/m64, imm8(6) + /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(6) /// public static Vector128 CompareScalarNotLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmpord_sd (__m128d a, __m128d b) - /// CMPDS xmm1, xmm2/m64, imm8(7) - /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(7) + /// __m128d _mm_cmpord_sd (__m128d a, __m128d b) + /// CMPDS xmm1, xmm2/m64, imm8(7) + /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(7) /// public static Vector128 CompareScalarOrdered(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_comieq_sd (__m128d a, __m128d b) - /// COMISD xmm1, xmm2/m64 ; ZF=1 && PF=0 - /// VCOMISD xmm1, xmm2/m64 ; ZF=1 && PF=0 - /// VCOMISD xmm1, xmm2/m64{sae} ; ZF=1 && PF=0 + /// int _mm_comieq_sd (__m128d a, __m128d b) + /// COMISD xmm1, xmm2/m64 ; ZF=1 && PF=0 + /// VCOMISD xmm1, xmm2/m64 ; ZF=1 && PF=0 + /// VCOMISD xmm1, xmm2/m64{sae} ; ZF=1 && PF=0 /// public static bool CompareScalarOrderedEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_comigt_sd (__m128d a, __m128d b) - /// COMISD xmm1, xmm2/m64 ; ZF=0 && CF=0 - /// VCOMISD xmm1, xmm2/m64 ; ZF=0 && CF=0 - /// VCOMISD xmm1, xmm2/m64{sae} ; ZF=0 && CF=0 + /// int _mm_comigt_sd (__m128d a, __m128d b) + /// COMISD xmm1, xmm2/m64 ; ZF=0 && CF=0 + /// VCOMISD xmm1, xmm2/m64 ; ZF=0 && CF=0 + /// VCOMISD xmm1, xmm2/m64{sae} ; ZF=0 && CF=0 /// public static bool CompareScalarOrderedGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_comige_sd (__m128d a, __m128d b) - /// COMISD xmm1, xmm2/m64 ; CF=0 - /// VCOMISD xmm1, xmm2/m64 ; CF=0 - /// VCOMISD xmm1, xmm2/m64{sae} ; CF=0 + /// int _mm_comige_sd (__m128d a, __m128d b) + /// COMISD xmm1, xmm2/m64 ; CF=0 + /// VCOMISD xmm1, xmm2/m64 ; CF=0 + /// VCOMISD xmm1, xmm2/m64{sae} ; CF=0 /// public static bool CompareScalarOrderedGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_comilt_sd (__m128d a, __m128d b) - /// COMISD xmm1, xmm2/m64 ; PF=0 && CF=1 - /// VCOMISD xmm1, xmm2/m64 ; PF=0 && CF=1 - /// VCOMISD xmm1, xmm2/m64{sae} ; PF=0 && CF=1 + /// int _mm_comilt_sd (__m128d a, __m128d b) + /// COMISD xmm1, xmm2/m64 ; PF=0 && CF=1 + /// VCOMISD xmm1, xmm2/m64 ; PF=0 && CF=1 + /// VCOMISD xmm1, xmm2/m64{sae} ; PF=0 && CF=1 /// public static bool CompareScalarOrderedLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_comile_sd (__m128d a, __m128d b) - /// COMISD xmm1, xmm2/m64 ; PF=0 && (ZF=1 || CF=1) - /// VCOMISD xmm1, xmm2/m64 ; PF=0 && (ZF=1 || CF=1) - /// VCOMISD xmm1, xmm2/m64{sae} ; PF=0 && (ZF=1 || CF=1) + /// int _mm_comile_sd (__m128d a, __m128d b) + /// COMISD xmm1, xmm2/m64 ; PF=0 && (ZF=1 || CF=1) + /// VCOMISD xmm1, xmm2/m64 ; PF=0 && (ZF=1 || CF=1) + /// VCOMISD xmm1, xmm2/m64{sae} ; PF=0 && (ZF=1 || CF=1) /// public static bool CompareScalarOrderedLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_comineq_sd (__m128d a, __m128d b) - /// COMISD xmm1, xmm2/m64 ; ZF=0 || PF=1 - /// VCOMISD xmm1, xmm2/m64 ; ZF=0 || PF=1 - /// VCOMISD xmm1, xmm2/m64{sae} ; ZF=0 || PF=1 + /// int _mm_comineq_sd (__m128d a, __m128d b) + /// COMISD xmm1, xmm2/m64 ; ZF=0 || PF=1 + /// VCOMISD xmm1, xmm2/m64 ; ZF=0 || PF=1 + /// VCOMISD xmm1, xmm2/m64{sae} ; ZF=0 || PF=1 /// public static bool CompareScalarOrderedNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmpunord_sd (__m128d a, __m128d b) - /// CMPDS xmm1, xmm2/m64, imm8(3) - /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(3) + /// __m128d _mm_cmpunord_sd (__m128d a, __m128d b) + /// CMPDS xmm1, xmm2/m64, imm8(3) + /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(3) /// public static Vector128 CompareScalarUnordered(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_ucomieq_sd (__m128d a, __m128d b) - /// UCOMISD xmm1, xmm2/m64 ; ZF=1 && PF=0 - /// VUCOMISD xmm1, xmm2/m64 ; ZF=1 && PF=0 - /// VUCOMISD xmm1, xmm2/m64{sae} ; ZF=1 && PF=0 + /// int _mm_ucomieq_sd (__m128d a, __m128d b) + /// UCOMISD xmm1, xmm2/m64 ; ZF=1 && PF=0 + /// VUCOMISD xmm1, xmm2/m64 ; ZF=1 && PF=0 + /// VUCOMISD xmm1, xmm2/m64{sae} ; ZF=1 && PF=0 /// public static bool CompareScalarUnorderedEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_ucomigt_sd (__m128d a, __m128d b) - /// UCOMISD xmm1, xmm2/m64 ; ZF=0 && CF=0 - /// VUCOMISD xmm1, xmm2/m64 ; ZF=0 && CF=0 - /// VUCOMISD xmm1, xmm2/m64{sae} ; ZF=0 && CF=0 + /// int _mm_ucomigt_sd (__m128d a, __m128d b) + /// UCOMISD xmm1, xmm2/m64 ; ZF=0 && CF=0 + /// VUCOMISD xmm1, xmm2/m64 ; ZF=0 && CF=0 + /// VUCOMISD xmm1, xmm2/m64{sae} ; ZF=0 && CF=0 /// public static bool CompareScalarUnorderedGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_ucomige_sd (__m128d a, __m128d b) - /// UCOMISD xmm1, xmm2/m64 ; CF=0 - /// VUCOMISD xmm1, xmm2/m64 ; CF=0 - /// VUCOMISD xmm1, xmm2/m64{sae} ; CF=0 + /// int _mm_ucomige_sd (__m128d a, __m128d b) + /// UCOMISD xmm1, xmm2/m64 ; CF=0 + /// VUCOMISD xmm1, xmm2/m64 ; CF=0 + /// VUCOMISD xmm1, xmm2/m64{sae} ; CF=0 /// public static bool CompareScalarUnorderedGreaterThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_ucomilt_sd (__m128d a, __m128d b) - /// UCOMISD xmm1, xmm2/m64 ; PF=0 && CF=1 - /// VUCOMISD xmm1, xmm2/m64 ; PF=0 && CF=1 - /// VUCOMISD xmm1, xmm2/m64{sae} ; PF=0 && CF=1 + /// int _mm_ucomilt_sd (__m128d a, __m128d b) + /// UCOMISD xmm1, xmm2/m64 ; PF=0 && CF=1 + /// VUCOMISD xmm1, xmm2/m64 ; PF=0 && CF=1 + /// VUCOMISD xmm1, xmm2/m64{sae} ; PF=0 && CF=1 /// public static bool CompareScalarUnorderedLessThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_ucomile_sd (__m128d a, __m128d b) - /// UCOMISD xmm1, xmm2/m64 ; PF=0 && (ZF=1 || CF=1) - /// VUCOMISD xmm1, xmm2/m64 ; PF=0 && (ZF=1 || CF=1) - /// VUCOMISD xmm1, xmm2/m64{sae} ; PF=0 && (ZF=1 || CF=1) + /// int _mm_ucomile_sd (__m128d a, __m128d b) + /// UCOMISD xmm1, xmm2/m64 ; PF=0 && (ZF=1 || CF=1) + /// VUCOMISD xmm1, xmm2/m64 ; PF=0 && (ZF=1 || CF=1) + /// VUCOMISD xmm1, xmm2/m64{sae} ; PF=0 && (ZF=1 || CF=1) /// public static bool CompareScalarUnorderedLessThanOrEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_ucomineq_sd (__m128d a, __m128d b) - /// UCOMISD xmm1, xmm2/m64 ; ZF=0 || PF=1 - /// VUCOMISD xmm1, xmm2/m64 ; ZF=0 || PF=1 - /// VUCOMISD xmm1, xmm2/m64{sae} ; ZF=0 || PF=1 + /// int _mm_ucomineq_sd (__m128d a, __m128d b) + /// UCOMISD xmm1, xmm2/m64 ; ZF=0 || PF=1 + /// VUCOMISD xmm1, xmm2/m64 ; ZF=0 || PF=1 + /// VUCOMISD xmm1, xmm2/m64{sae} ; ZF=0 || PF=1 /// public static bool CompareScalarUnorderedNotEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cmpunord_pd (__m128d a, __m128d b) - /// CMPPD xmm1, xmm2/m128, imm8(3) - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(3) + /// __m128d _mm_cmpunord_pd (__m128d a, __m128d b) + /// CMPPD xmm1, xmm2/m128, imm8(3) + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(3) /// public static Vector128 CompareUnordered(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cvtsi32_sd (__m128d a, int b) - /// CVTSI2SD xmm1, r/m32 - /// VCVTSI2SD xmm1, xmm2, r/m32 + /// __m128d _mm_cvtsi32_sd (__m128d a, int b) + /// CVTSI2SD xmm1, r/m32 + /// VCVTSI2SD xmm1, xmm2, r/m32 /// public static Vector128 ConvertScalarToVector128Double(Vector128 upper, int value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cvtss_sd (__m128d a, __m128 b) - /// CVTSS2SD xmm1, xmm2/m32 - /// VCVTSS2SD xmm1, xmm2, xmm3/m32 + /// __m128d _mm_cvtss_sd (__m128d a, __m128 b) + /// CVTSS2SD xmm1, xmm2/m32 + /// VCVTSS2SD xmm1, xmm2, xmm3/m32 /// public static Vector128 ConvertScalarToVector128Double(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtsi32_si128 (int a) - /// MOVD xmm1, r/m32 - /// VMOVD xmm1, r/m32 + /// __m128i _mm_cvtsi32_si128 (int a) + /// MOVD xmm1, r/m32 + /// VMOVD xmm1, r/m32 /// public static Vector128 ConvertScalarToVector128Int32(int value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cvtsd_ss (__m128 a, __m128d b) - /// CVTSD2SS xmm1, xmm2/m64 - /// VCVTSD2SS xmm1, xmm2, xmm3/m64 + /// __m128 _mm_cvtsd_ss (__m128 a, __m128d b) + /// CVTSD2SS xmm1, xmm2/m64 + /// VCVTSD2SS xmm1, xmm2, xmm3/m64 /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtsi32_si128 (int a) - /// MOVD xmm1, r/m32 - /// VMOVD xmm1, r/m32 + /// __m128i _mm_cvtsi32_si128 (int a) + /// MOVD xmm1, r/m32 + /// VMOVD xmm1, r/m32 /// public static Vector128 ConvertScalarToVector128UInt32(uint value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cvtepi32_pd (__m128i a) - /// CVTDQ2PD xmm1, xmm2/m64 - /// VCVTDQ2PD xmm1, xmm2/m64 - /// VCVTDQ2PD xmm1 {k1}{z}, xmm2/m64/m32bcst + /// __m128d _mm_cvtepi32_pd (__m128i a) + /// CVTDQ2PD xmm1, xmm2/m64 + /// VCVTDQ2PD xmm1, xmm2/m64 + /// VCVTDQ2PD xmm1 {k1}{z}, xmm2/m64/m32bcst /// public static Vector128 ConvertToVector128Double(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_cvtps_pd (__m128 a) - /// CVTPS2PD xmm1, xmm2/m64 - /// VCVTPS2PD xmm1, xmm2/m64 - /// VCVTPS2PD xmm1 {k1}{z}, xmm2/m64/m32bcst + /// __m128d _mm_cvtps_pd (__m128 a) + /// CVTPS2PD xmm1, xmm2/m64 + /// VCVTPS2PD xmm1, xmm2/m64 + /// VCVTPS2PD xmm1 {k1}{z}, xmm2/m64/m32bcst /// public static Vector128 ConvertToVector128Double(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtps_epi32 (__m128 a) - /// CVTPS2DQ xmm1, xmm2/m128 - /// VCVTPS2DQ xmm1, xmm2/m128 - /// VCVTPS2DQ xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_cvtps_epi32 (__m128 a) + /// CVTPS2DQ xmm1, xmm2/m128 + /// VCVTPS2DQ xmm1, xmm2/m128 + /// VCVTPS2DQ xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 ConvertToVector128Int32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtpd_epi32 (__m128d a) - /// CVTPD2DQ xmm1, xmm2/m128 - /// VCVTPD2DQ xmm1, xmm2/m128 - /// VCVTPD2DQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvtpd_epi32 (__m128d a) + /// CVTPD2DQ xmm1, xmm2/m128 + /// VCVTPD2DQ xmm1, xmm2/m128 + /// VCVTPD2DQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Int32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvttps_epi32 (__m128 a) - /// CVTTPS2DQ xmm1, xmm2/m128 - /// VCVTTPS2DQ xmm1, xmm2/m128 - /// VCVTTPS2DQ xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_cvttps_epi32 (__m128 a) + /// CVTTPS2DQ xmm1, xmm2/m128 + /// VCVTTPS2DQ xmm1, xmm2/m128 + /// VCVTTPS2DQ xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 ConvertToVector128Int32WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvttpd_epi32 (__m128d a) - /// CVTTPD2DQ xmm1, xmm2/m128 - /// VCVTTPD2DQ xmm1, xmm2/m128 - /// VCVTTPD2DQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvttpd_epi32 (__m128d a) + /// CVTTPD2DQ xmm1, xmm2/m128 + /// VCVTTPD2DQ xmm1, xmm2/m128 + /// VCVTTPD2DQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Int32WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cvtepi32_ps (__m128i a) - /// CVTDQ2PS xmm1, xmm2/m128 - /// VCVTDQ2PS xmm1, xmm2/m128 - /// VCVTDQ2PS xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128 _mm_cvtepi32_ps (__m128i a) + /// CVTDQ2PS xmm1, xmm2/m128 + /// VCVTDQ2PS xmm1, xmm2/m128 + /// VCVTDQ2PS xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 ConvertToVector128Single(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_cvtpd_ps (__m128d a) - /// CVTPD2PS xmm1, xmm2/m128 - /// VCVTPD2PS xmm1, xmm2/m128 - /// VCVTPD2PS xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128 _mm_cvtpd_ps (__m128d a) + /// CVTPD2PS xmm1, xmm2/m128 + /// VCVTPD2PS xmm1, xmm2/m128 + /// VCVTPD2PS xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Single(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int _mm_cvtsi128_si32 (__m128i a) - /// MOVD r/m32, xmm1 - /// VMOVD r/m32, xmm1 + /// int _mm_cvtsi128_si32 (__m128i a) + /// MOVD r/m32, xmm1 + /// VMOVD r/m32, xmm1 /// public static int ConvertToInt32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int _mm_cvtsd_si32 (__m128d a) - /// CVTSD2SI r32, xmm1/m64 - /// VCVTSD2SI r32, xmm1/m64 + /// int _mm_cvtsd_si32 (__m128d a) + /// CVTSD2SI r32, xmm1/m64 + /// VCVTSD2SI r32, xmm1/m64 /// public static int ConvertToInt32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int _mm_cvttsd_si32 (__m128d a) - /// CVTTSD2SI r32, xmm1/m64 - /// VCVTTSD2SI r32, xmm1/m64 + /// int _mm_cvttsd_si32 (__m128d a) + /// CVTTSD2SI r32, xmm1/m64 + /// VCVTTSD2SI r32, xmm1/m64 /// public static int ConvertToInt32WithTruncation(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int _mm_cvtsi128_si32 (__m128i a) - /// MOVD r/m32, xmm1 - /// VMOVD r/m32, xmm1 + /// int _mm_cvtsi128_si32 (__m128i a) + /// MOVD r/m32, xmm1 + /// VMOVD r/m32, xmm1 /// public static uint ConvertToUInt32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_div_pd (__m128d a, __m128d b) - /// DIVPD xmm1, xmm2/m128 - /// VDIVPD xmm1, xmm2, xmm3/m128 - /// VDIVPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_div_pd (__m128d a, __m128d b) + /// DIVPD xmm1, xmm2/m128 + /// VDIVPD xmm1, xmm2, xmm3/m128 + /// VDIVPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Divide(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_div_sd (__m128d a, __m128d b) - /// DIVSD xmm1, xmm2/m64 - /// VDIVSD xmm1, xmm2, xmm3/m64 + /// __m128d _mm_div_sd (__m128d a, __m128d b) + /// DIVSD xmm1, xmm2/m64 + /// VDIVSD xmm1, xmm2, xmm3/m64 /// public static Vector128 DivideScalar(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_extract_epi16 (__m128i a, int immediate) - /// PEXTRW r/m16, xmm1, imm8 - /// VPEXTRW r/m16, xmm1, imm8 + /// int _mm_extract_epi16 (__m128i a, int immediate) + /// PEXTRW r/m16, xmm1, imm8 + /// VPEXTRW r/m16, xmm1, imm8 /// public static ushort Extract(Vector128 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_insert_epi16 (__m128i a, int i, int immediate) - /// PINSRW xmm1, r/m16, imm8 - /// VPINSRW xmm1, xmm2, r/m16, imm8 + /// __m128i _mm_insert_epi16 (__m128i a, int i, int immediate) + /// PINSRW xmm1, r/m16, imm8 + /// VPINSRW xmm1, xmm2, r/m16, imm8 /// public static Vector128 Insert(Vector128 value, short data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_insert_epi16 (__m128i a, int i, int immediate) - /// PINSRW xmm1, r/m16, imm8 - /// VPINSRW xmm1, xmm2, r/m16, imm8 + /// __m128i _mm_insert_epi16 (__m128i a, int i, int immediate) + /// PINSRW xmm1, r/m16, imm8 + /// VPINSRW xmm1, xmm2, r/m16, imm8 /// public static Vector128 Insert(Vector128 value, ushort data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_load_si128 (__m128i const* mem_address) - /// MOVDQA xmm1, m128 - /// VMOVDQA xmm1, m128 - /// VMOVDQA32 xmm1 {k1}{z}, m128 + /// __m128i _mm_load_si128 (__m128i const* mem_address) + /// MOVDQA xmm1, m128 + /// VMOVDQA xmm1, m128 + /// VMOVDQA32 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadAlignedVector128(sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_load_si128 (__m128i const* mem_address) - /// MOVDQA xmm1, m128 - /// VMOVDQA xmm1, m128 - /// VMOVDQA32 xmm1 {k1}{z}, m128 + /// __m128i _mm_load_si128 (__m128i const* mem_address) + /// MOVDQA xmm1, m128 + /// VMOVDQA xmm1, m128 + /// VMOVDQA32 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadAlignedVector128(byte* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_load_si128 (__m128i const* mem_address) - /// MOVDQA xmm, m128 + /// __m128i _mm_load_si128 (__m128i const* mem_address) + /// MOVDQA xmm, m128 /// public static unsafe Vector128 LoadAlignedVector128(short* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_load_si128 (__m128i const* mem_address) - /// MOVDQA xmm1, m128 - /// VMOVDQA xmm1, m128 - /// VMOVDQA32 xmm1 {k1}{z}, m128 + /// __m128i _mm_load_si128 (__m128i const* mem_address) + /// MOVDQA xmm1, m128 + /// VMOVDQA xmm1, m128 + /// VMOVDQA32 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadAlignedVector128(ushort* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_load_si128 (__m128i const* mem_address) - /// MOVDQA xmm1, m128 - /// VMOVDQA xmm1, m128 - /// VMOVDQA32 xmm1 {k1}{z}, m128 + /// __m128i _mm_load_si128 (__m128i const* mem_address) + /// MOVDQA xmm1, m128 + /// VMOVDQA xmm1, m128 + /// VMOVDQA32 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadAlignedVector128(int* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_load_si128 (__m128i const* mem_address) - /// MOVDQA xmm1, m128 - /// VMOVDQA xmm1, m128 - /// VMOVDQA32 xmm1 {k1}{z}, m128 + /// __m128i _mm_load_si128 (__m128i const* mem_address) + /// MOVDQA xmm1, m128 + /// VMOVDQA xmm1, m128 + /// VMOVDQA32 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadAlignedVector128(uint* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_load_si128 (__m128i const* mem_address) - /// MOVDQA xmm1, m128 - /// VMOVDQA xmm1, m128 - /// VMOVDQA64 xmm1 {k1}{z}, m128 + /// __m128i _mm_load_si128 (__m128i const* mem_address) + /// MOVDQA xmm1, m128 + /// VMOVDQA xmm1, m128 + /// VMOVDQA64 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadAlignedVector128(long* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_load_si128 (__m128i const* mem_address) - /// MOVDQA xmm1, m128 - /// VMOVDQA xmm1, m128 - /// VMOVDQA64 xmm1 {k1}{z}, m128 + /// __m128i _mm_load_si128 (__m128i const* mem_address) + /// MOVDQA xmm1, m128 + /// VMOVDQA xmm1, m128 + /// VMOVDQA64 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadAlignedVector128(ulong* address) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_load_pd (double const* mem_address) - /// MOVAPD xmm1, m128 - /// VMOVAPD xmm1, m128 - /// VMOVAPD xmm1 {k1}{z}, m128 + /// __m128d _mm_load_pd (double const* mem_address) + /// MOVAPD xmm1, m128 + /// VMOVAPD xmm1, m128 + /// VMOVAPD xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadAlignedVector128(double* address) { throw new PlatformNotSupportedException(); } /// - /// void _mm_lfence(void) - /// LFENCE + /// void _mm_lfence(void) + /// LFENCE /// public static void LoadFence() { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_loadh_pd (__m128d a, double const* mem_addr) - /// MOVHPD xmm1, m64 - /// VMOVHPD xmm1, xmm2, m64 + /// __m128d _mm_loadh_pd (__m128d a, double const* mem_addr) + /// MOVHPD xmm1, m64 + /// VMOVHPD xmm1, xmm2, m64 /// public static unsafe Vector128 LoadHigh(Vector128 lower, double* address) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_loadl_pd (__m128d a, double const* mem_addr) - /// MOVLPD xmm1, m64 - /// VMOVLPD xmm1, xmm2, m64 + /// __m128d _mm_loadl_pd (__m128d a, double const* mem_addr) + /// MOVLPD xmm1, m64 + /// VMOVLPD xmm1, xmm2, m64 /// public static unsafe Vector128 LoadLow(Vector128 upper, double* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_loadu_si32 (void const* mem_addr) - /// MOVD xmm1, m32 - /// VMOVD xmm1, m32 + /// __m128i _mm_loadu_si32 (void const* mem_addr) + /// MOVD xmm1, m32 + /// VMOVD xmm1, m32 /// public static unsafe Vector128 LoadScalarVector128(int* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_loadu_si32 (void const* mem_addr) - /// MOVD xmm1, m32 - /// VMOVD xmm1, m32 + /// __m128i _mm_loadu_si32 (void const* mem_addr) + /// MOVD xmm1, m32 + /// VMOVD xmm1, m32 /// public static unsafe Vector128 LoadScalarVector128(uint* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_loadl_epi64 (__m128i const* mem_addr) - /// MOVQ xmm1, m64 - /// VMOVQ xmm1, m64 + /// __m128i _mm_loadl_epi64 (__m128i const* mem_addr) + /// MOVQ xmm1, m64 + /// VMOVQ xmm1, m64 /// public static unsafe Vector128 LoadScalarVector128(long* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_loadl_epi64 (__m128i const* mem_addr) - /// MOVQ xmm1, m64 - /// VMOVQ xmm1, m64 + /// __m128i _mm_loadl_epi64 (__m128i const* mem_addr) + /// MOVQ xmm1, m64 + /// VMOVQ xmm1, m64 /// public static unsafe Vector128 LoadScalarVector128(ulong* address) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_load_sd (double const* mem_address) - /// MOVSD xmm1, m64 - /// VMOVSD xmm1, m64 - /// VMOVSD xmm1 {k1}, m64 + /// __m128d _mm_load_sd (double const* mem_address) + /// MOVSD xmm1, m64 + /// VMOVSD xmm1, m64 + /// VMOVSD xmm1 {k1}, m64 /// public static unsafe Vector128 LoadScalarVector128(double* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_loadu_si128 (__m128i const* mem_address) - /// MOVDQU xmm1, m128 - /// VMOVDQU xmm1, m128 - /// VMOVDQU8 xmm1 {k1}{z}, m128 + /// __m128i _mm_loadu_si128 (__m128i const* mem_address) + /// MOVDQU xmm1, m128 + /// VMOVDQU xmm1, m128 + /// VMOVDQU8 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadVector128(sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_loadu_si128 (__m128i const* mem_address) - /// MOVDQU xmm1, m128 - /// VMOVDQU xmm1, m128 - /// VMOVDQU8 xmm1 {k1}{z}, m128 + /// __m128i _mm_loadu_si128 (__m128i const* mem_address) + /// MOVDQU xmm1, m128 + /// VMOVDQU xmm1, m128 + /// VMOVDQU8 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadVector128(byte* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_loadu_si128 (__m128i const* mem_address) - /// MOVDQU xmm1, m128 - /// VMOVDQU xmm1, m128 - /// VMOVDQU16 xmm1 {k1}{z}, m128 + /// __m128i _mm_loadu_si128 (__m128i const* mem_address) + /// MOVDQU xmm1, m128 + /// VMOVDQU xmm1, m128 + /// VMOVDQU16 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadVector128(short* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_loadu_si128 (__m128i const* mem_address) - /// MOVDQU xmm1, m128 - /// VMOVDQU xmm1, m128 - /// VMOVDQU16 xmm1 {k1}{z}, m128 + /// __m128i _mm_loadu_si128 (__m128i const* mem_address) + /// MOVDQU xmm1, m128 + /// VMOVDQU xmm1, m128 + /// VMOVDQU16 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadVector128(ushort* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_loadu_si128 (__m128i const* mem_address) - /// MOVDQU xmm1, m128 - /// VMOVDQU xmm1, m128 - /// VMOVDQU32 xmm1 {k1}{z}, m128 + /// __m128i _mm_loadu_si128 (__m128i const* mem_address) + /// MOVDQU xmm1, m128 + /// VMOVDQU xmm1, m128 + /// VMOVDQU32 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadVector128(int* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_loadu_si128 (__m128i const* mem_address) - /// MOVDQU xmm1, m128 - /// VMOVDQU xmm1, m128 - /// VMOVDQU32 xmm1 {k1}{z}, m128 + /// __m128i _mm_loadu_si128 (__m128i const* mem_address) + /// MOVDQU xmm1, m128 + /// VMOVDQU xmm1, m128 + /// VMOVDQU32 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadVector128(uint* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_loadu_si128 (__m128i const* mem_address) - /// MOVDQU xmm1, m128 - /// VMOVDQU xmm1, m128 - /// VMOVDQU64 xmm1 {k1}{z}, m128 + /// __m128i _mm_loadu_si128 (__m128i const* mem_address) + /// MOVDQU xmm1, m128 + /// VMOVDQU xmm1, m128 + /// VMOVDQU64 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadVector128(long* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_loadu_si128 (__m128i const* mem_address) - /// MOVDQU xmm1, m128 - /// VMOVDQU xmm1, m128 - /// VMOVDQU64 xmm1 {k1}{z}, m128 + /// __m128i _mm_loadu_si128 (__m128i const* mem_address) + /// MOVDQU xmm1, m128 + /// VMOVDQU xmm1, m128 + /// VMOVDQU64 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadVector128(ulong* address) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_loadu_pd (double const* mem_address) - /// MOVUPD xmm1, m128 - /// VMOVUPD xmm1, m128 - /// VMOVUPD xmm1 {k1}{z}, m128 + /// __m128d _mm_loadu_pd (double const* mem_address) + /// MOVUPD xmm1, m128 + /// VMOVUPD xmm1, m128 + /// VMOVUPD xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadVector128(double* address) { throw new PlatformNotSupportedException(); } /// - /// void _mm_maskmoveu_si128 (__m128i a, __m128i mask, char* mem_address) - /// MASKMOVDQU xmm1, xmm2 ; Address: EDI/RDI - /// VMASKMOVDQU xmm1, xmm2 ; Address: EDI/RDI + /// void _mm_maskmoveu_si128 (__m128i a, __m128i mask, char* mem_address) + /// MASKMOVDQU xmm1, xmm2 ; Address: EDI/RDI + /// VMASKMOVDQU xmm1, xmm2 ; Address: EDI/RDI /// public static unsafe void MaskMove(Vector128 source, Vector128 mask, sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// void _mm_maskmoveu_si128 (__m128i a, __m128i mask, char* mem_address) - /// MASKMOVDQU xmm1, xmm2 ; Address: EDI/RDI - /// VMASKMOVDQU xmm1, xmm2 ; Address: EDI/RDI + /// void _mm_maskmoveu_si128 (__m128i a, __m128i mask, char* mem_address) + /// MASKMOVDQU xmm1, xmm2 ; Address: EDI/RDI + /// VMASKMOVDQU xmm1, xmm2 ; Address: EDI/RDI /// public static unsafe void MaskMove(Vector128 source, Vector128 mask, byte* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_max_epu8 (__m128i a, __m128i b) - /// PMAXUB xmm1, xmm2/m128 - /// VPMAXUB xmm1, xmm2, xmm3/m128 - /// VPMAXUB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_max_epu8 (__m128i a, __m128i b) + /// PMAXUB xmm1, xmm2/m128 + /// VPMAXUB xmm1, xmm2, xmm3/m128 + /// VPMAXUB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_max_epi16 (__m128i a, __m128i b) - /// PMAXSW xmm1, xmm2/m128 - /// VPMAXSW xmm1, xmm2, xmm3/m128 - /// VPMAXSW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_max_epi16 (__m128i a, __m128i b) + /// PMAXSW xmm1, xmm2/m128 + /// VPMAXSW xmm1, xmm2, xmm3/m128 + /// VPMAXSW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_max_pd (__m128d a, __m128d b) - /// MAXPD xmm1, xmm2/m128 - /// VMAXPD xmm1, xmm2, xmm3/m128 - /// VMAXPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_max_pd (__m128d a, __m128d b) + /// MAXPD xmm1, xmm2/m128 + /// VMAXPD xmm1, xmm2, xmm3/m128 + /// VMAXPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_max_sd (__m128d a, __m128d b) - /// MAXSD xmm1, xmm2/m64 - /// VMAXSD xmm1, xmm2, xmm3/m64 + /// __m128d _mm_max_sd (__m128d a, __m128d b) + /// MAXSD xmm1, xmm2/m64 + /// VMAXSD xmm1, xmm2, xmm3/m64 /// public static Vector128 MaxScalar(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// void _mm_mfence(void) - /// MFENCE + /// void _mm_mfence(void) + /// MFENCE /// public static void MemoryFence() { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_min_epu8 (__m128i a, __m128i b) - /// PMINUB xmm1, xmm2/m128 - /// VPMINUB xmm1, xmm2, xmm3/m128 - /// VPMINUB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_min_epu8 (__m128i a, __m128i b) + /// PMINUB xmm1, xmm2/m128 + /// VPMINUB xmm1, xmm2, xmm3/m128 + /// VPMINUB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_min_epi16 (__m128i a, __m128i b) - /// PMINSW xmm1, xmm2/m128 - /// VPMINSW xmm1, xmm2, xmm3/m128 - /// VPMINSW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_min_epi16 (__m128i a, __m128i b) + /// PMINSW xmm1, xmm2/m128 + /// VPMINSW xmm1, xmm2, xmm3/m128 + /// VPMINSW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_min_pd (__m128d a, __m128d b) - /// MINPD xmm1, xmm2/m128 - /// VMINPD xmm1, xmm2, xmm3/m128 - /// VMINPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_min_pd (__m128d a, __m128d b) + /// MINPD xmm1, xmm2/m128 + /// VMINPD xmm1, xmm2, xmm3/m128 + /// VMINPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_min_sd (__m128d a, __m128d b) - /// MINSD xmm1, xmm2/m64 - /// VMINSD xmm1, xmm2, xmm3/m64 + /// __m128d _mm_min_sd (__m128d a, __m128d b) + /// MINSD xmm1, xmm2/m64 + /// VMINSD xmm1, xmm2, xmm3/m64 /// public static Vector128 MinScalar(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_movemask_epi8 (__m128i a) - /// PMOVMSKB r32, xmm1 - /// VPMOVMSKB r32, xmm1 + /// int _mm_movemask_epi8 (__m128i a) + /// PMOVMSKB r32, xmm1 + /// VPMOVMSKB r32, xmm1 /// public static int MoveMask(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int _mm_movemask_epi8 (__m128i a) - /// PMOVMSKB r32, xmm1 - /// VPMOVMSKB r32, xmm1 + /// int _mm_movemask_epi8 (__m128i a) + /// PMOVMSKB r32, xmm1 + /// VPMOVMSKB r32, xmm1 /// public static int MoveMask(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int _mm_movemask_pd (__m128d a) - /// MOVMSKPD r32, xmm1 - /// VMOVMSKPD r32, xmm1 + /// int _mm_movemask_pd (__m128d a) + /// MOVMSKPD r32, xmm1 + /// VMOVMSKPD r32, xmm1 /// public static int MoveMask(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_move_epi64 (__m128i a) - /// MOVQ xmm1, xmm2 - /// VMOVQ xmm1, xmm2 + /// __m128i _mm_move_epi64 (__m128i a) + /// MOVQ xmm1, xmm2 + /// VMOVQ xmm1, xmm2 /// public static Vector128 MoveScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_move_epi64 (__m128i a) - /// MOVQ xmm1, xmm2 - /// VMOVQ xmm1, xmm2 + /// __m128i _mm_move_epi64 (__m128i a) + /// MOVQ xmm1, xmm2 + /// VMOVQ xmm1, xmm2 /// public static Vector128 MoveScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_move_sd (__m128d a, __m128d b) - /// MOVSD xmm1, xmm2 - /// VMOVSD xmm1, xmm2, xmm3 - /// VMOVSD xmm1 {k1}{z}, xmm2, xmm3 + /// __m128d _mm_move_sd (__m128d a, __m128d b) + /// MOVSD xmm1, xmm2 + /// VMOVSD xmm1, xmm2, xmm3 + /// VMOVSD xmm1 {k1}{z}, xmm2, xmm3 /// public static Vector128 MoveScalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_mul_epu32 (__m128i a, __m128i b) - /// PMULUDQ xmm1, xmm2/m128 - /// VPMULUDQ xmm1, xmm2, xmm3/m128 - /// VPMULUDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_mul_epu32 (__m128i a, __m128i b) + /// PMULUDQ xmm1, xmm2/m128 + /// VPMULUDQ xmm1, xmm2, xmm3/m128 + /// VPMULUDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Multiply(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_mul_pd (__m128d a, __m128d b) - /// MULPD xmm1, xmm2/m128 - /// VMULPD xmm1, xmm2, xmm3/m128 - /// VMULPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_mul_pd (__m128d a, __m128d b) + /// MULPD xmm1, xmm2/m128 + /// VMULPD xmm1, xmm2, xmm3/m128 + /// VMULPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Multiply(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_madd_epi16 (__m128i a, __m128i b) - /// PMADDWD xmm1, xmm2/m128 - /// VPMADDWD xmm1, xmm2, xmm3/m128 - /// VPMADDWD xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_madd_epi16 (__m128i a, __m128i b) + /// PMADDWD xmm1, xmm2/m128 + /// VPMADDWD xmm1, xmm2, xmm3/m128 + /// VPMADDWD xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 MultiplyAddAdjacent(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_mulhi_epi16 (__m128i a, __m128i b) - /// PMULHW xmm1, xmm2/m128 - /// VPMULHW xmm1, xmm2, xmm3/m128 - /// VPMULHW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_mulhi_epi16 (__m128i a, __m128i b) + /// PMULHW xmm1, xmm2/m128 + /// VPMULHW xmm1, xmm2, xmm3/m128 + /// VPMULHW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 MultiplyHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_mulhi_epu16 (__m128i a, __m128i b) - /// PMULHUW xmm1, xmm2/m128 - /// VPMULHUW xmm1, xmm2, xmm3/m128 - /// VPMULHUW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_mulhi_epu16 (__m128i a, __m128i b) + /// PMULHUW xmm1, xmm2/m128 + /// VPMULHUW xmm1, xmm2, xmm3/m128 + /// VPMULHUW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 MultiplyHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_mullo_epi16 (__m128i a, __m128i b) - /// PMULLW xmm1, xmm2/m128 - /// VPMULLW xmm1, xmm2, xmm3/m128 - /// VPMULLW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_mullo_epi16 (__m128i a, __m128i b) + /// PMULLW xmm1, xmm2/m128 + /// VPMULLW xmm1, xmm2, xmm3/m128 + /// VPMULLW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 MultiplyLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_mullo_epi16 (__m128i a, __m128i b) - /// PMULLW xmm1, xmm2/m128 - /// VPMULLW xmm1, xmm2, xmm3/m128 - /// VPMULLW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_mullo_epi16 (__m128i a, __m128i b) + /// PMULLW xmm1, xmm2/m128 + /// VPMULLW xmm1, xmm2, xmm3/m128 + /// VPMULLW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 MultiplyLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_mul_sd (__m128d a, __m128d b) - /// MULSD xmm1, xmm2/m64 - /// VMULSD xmm1, xmm2, xmm3/m64 + /// __m128d _mm_mul_sd (__m128d a, __m128d b) + /// MULSD xmm1, xmm2/m64 + /// VMULSD xmm1, xmm2, xmm3/m64 /// public static Vector128 MultiplyScalar(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_or_si128 (__m128i a, __m128i b) - /// POR xmm1, xmm2/m128 - /// VPOR xmm1, xmm2, xmm3/m128 + /// __m128i _mm_or_si128 (__m128i a, __m128i b) + /// POR xmm1, xmm2/m128 + /// VPOR xmm1, xmm2, xmm3/m128 /// public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_or_si128 (__m128i a, __m128i b) - /// POR xmm1, xmm2/m128 - /// VPOR xmm1, xmm2, xmm3/m128 + /// __m128i _mm_or_si128 (__m128i a, __m128i b) + /// POR xmm1, xmm2/m128 + /// VPOR xmm1, xmm2, xmm3/m128 /// public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_or_si128 (__m128i a, __m128i b) - /// POR xmm1, xmm2/m128 - /// VPOR xmm1, xmm2, xmm3/m128 + /// __m128i _mm_or_si128 (__m128i a, __m128i b) + /// POR xmm1, xmm2/m128 + /// VPOR xmm1, xmm2, xmm3/m128 /// public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_or_si128 (__m128i a, __m128i b) - /// POR xmm1, xmm2/m128 - /// VPOR xmm1, xmm2, xmm3/m128 + /// __m128i _mm_or_si128 (__m128i a, __m128i b) + /// POR xmm1, xmm2/m128 + /// VPOR xmm1, xmm2, xmm3/m128 /// public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_or_si128 (__m128i a, __m128i b) - /// POR xmm1, xmm2/m128 - /// VPOR xmm1, xmm2, xmm3/m128 - /// VPORD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_or_si128 (__m128i a, __m128i b) + /// POR xmm1, xmm2/m128 + /// VPOR xmm1, xmm2, xmm3/m128 + /// VPORD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_or_si128 (__m128i a, __m128i b) - /// POR xmm1, xmm2/m128 - /// VPOR xmm1, xmm2, xmm3/m128 - /// VPORD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_or_si128 (__m128i a, __m128i b) + /// POR xmm1, xmm2/m128 + /// VPOR xmm1, xmm2, xmm3/m128 + /// VPORD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_or_si128 (__m128i a, __m128i b) - /// POR xmm1, xmm2/m128 - /// VPOR xmm1, xmm2, xmm3/m128 - /// VPORQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_or_si128 (__m128i a, __m128i b) + /// POR xmm1, xmm2/m128 + /// VPOR xmm1, xmm2, xmm3/m128 + /// VPORQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_or_si128 (__m128i a, __m128i b) - /// POR xmm1, xmm2/m128 - /// VPOR xmm1, xmm2, xmm3/m128 - /// VPORQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_or_si128 (__m128i a, __m128i b) + /// POR xmm1, xmm2/m128 + /// VPOR xmm1, xmm2, xmm3/m128 + /// VPORQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_or_pd (__m128d a, __m128d b) - /// ORPD xmm1, xmm2/m128 - /// VORPD xmm1, xmm2, xmm3/m128 - /// VORPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_or_pd (__m128d a, __m128d b) + /// ORPD xmm1, xmm2/m128 + /// VORPD xmm1, xmm2, xmm3/m128 + /// VORPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Or(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_packs_epi16 (__m128i a, __m128i b) - /// PACKSSWB xmm1, xmm2/m128 - /// VPACKSSWB xmm1, xmm2, xmm3/m128 - /// VPACKSSWB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_packs_epi16 (__m128i a, __m128i b) + /// PACKSSWB xmm1, xmm2/m128 + /// VPACKSSWB xmm1, xmm2, xmm3/m128 + /// VPACKSSWB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PackSignedSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_packs_epi32 (__m128i a, __m128i b) - /// PACKSSDW xmm1, xmm2/m128 - /// VPACKSSDW xmm1, xmm2, xmm3/m128 - /// VPACKSSDW xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_packs_epi32 (__m128i a, __m128i b) + /// PACKSSDW xmm1, xmm2/m128 + /// VPACKSSDW xmm1, xmm2, xmm3/m128 + /// VPACKSSDW xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 PackSignedSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_packus_epi16 (__m128i a, __m128i b) - /// PACKUSWB xmm1, xmm2/m128 - /// VPACKUSWB xmm1, xmm2, xmm3/m128 - /// VPACKUSWB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_packus_epi16 (__m128i a, __m128i b) + /// PACKUSWB xmm1, xmm2/m128 + /// VPACKUSWB xmm1, xmm2, xmm3/m128 + /// VPACKUSWB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PackUnsignedSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sll_epi16 (__m128i a, __m128i count) - /// PSLLW xmm1, xmm2/m128 - /// VPSLLW xmm1, xmm2, xmm3/m128 - /// VPSLLW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sll_epi16 (__m128i a, __m128i count) + /// PSLLW xmm1, xmm2/m128 + /// VPSLLW xmm1, xmm2, xmm3/m128 + /// VPSLLW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftLeftLogical(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sll_epi16 (__m128i a, __m128i count) - /// PSLLW xmm1, xmm2/m128 - /// VPSLLW xmm1, xmm2, xmm3/m128 - /// VPSLLW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sll_epi16 (__m128i a, __m128i count) + /// PSLLW xmm1, xmm2/m128 + /// VPSLLW xmm1, xmm2, xmm3/m128 + /// VPSLLW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftLeftLogical(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sll_epi32 (__m128i a, __m128i count) - /// PSLLD xmm1, xmm2/m128 - /// VPSLLD xmm1, xmm2, xmm3/m128 - /// VPSLLD xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sll_epi32 (__m128i a, __m128i count) + /// PSLLD xmm1, xmm2/m128 + /// VPSLLD xmm1, xmm2, xmm3/m128 + /// VPSLLD xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftLeftLogical(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sll_epi32 (__m128i a, __m128i count) - /// PSLLD xmm1, xmm2/m128 - /// VPSLLD xmm1, xmm2, xmm3/m128 - /// VPSLLD xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sll_epi32 (__m128i a, __m128i count) + /// PSLLD xmm1, xmm2/m128 + /// VPSLLD xmm1, xmm2, xmm3/m128 + /// VPSLLD xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftLeftLogical(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sll_epi64 (__m128i a, __m128i count) - /// PSLLQ xmm1, xmm2/m128 - /// VPSLLQ xmm1, xmm2, xmm3/m128 - /// VPSLLQ xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sll_epi64 (__m128i a, __m128i count) + /// PSLLQ xmm1, xmm2/m128 + /// VPSLLQ xmm1, xmm2, xmm3/m128 + /// VPSLLQ xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftLeftLogical(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sll_epi64 (__m128i a, __m128i count) - /// PSLLQ xmm1, xmm2/m128 - /// VPSLLQ xmm1, xmm2, xmm3/m128 - /// VPSLLQ xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sll_epi64 (__m128i a, __m128i count) + /// PSLLQ xmm1, xmm2/m128 + /// VPSLLQ xmm1, xmm2, xmm3/m128 + /// VPSLLQ xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftLeftLogical(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_slli_epi16 (__m128i a, int immediate) - /// PSLLW xmm1, imm8 - /// VPSLLW xmm1, xmm2, imm8 - /// VPSLLW xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_slli_epi16 (__m128i a, int immediate) + /// PSLLW xmm1, imm8 + /// VPSLLW xmm1, xmm2, imm8 + /// VPSLLW xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_slli_epi16 (__m128i a, int immediate) - /// PSLLW xmm1, imm8 - /// VPSLLW xmm1, xmm2, imm8 - /// VPSLLW xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_slli_epi16 (__m128i a, int immediate) + /// PSLLW xmm1, imm8 + /// VPSLLW xmm1, xmm2, imm8 + /// VPSLLW xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_slli_epi32 (__m128i a, int immediate) - /// PSLLD xmm1, imm8 - /// VPSLLD xmm1, xmm2, imm8 - /// VPSLLD xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_slli_epi32 (__m128i a, int immediate) + /// PSLLD xmm1, imm8 + /// VPSLLD xmm1, xmm2, imm8 + /// VPSLLD xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_slli_epi32 (__m128i a, int immediate) - /// PSLLD xmm1, imm8 - /// VPSLLD xmm1, xmm2, imm8 - /// VPSLLD xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_slli_epi32 (__m128i a, int immediate) + /// PSLLD xmm1, imm8 + /// VPSLLD xmm1, xmm2, imm8 + /// VPSLLD xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_slli_epi64 (__m128i a, int immediate) - /// PSLLQ xmm1, imm8 - /// VPSLLQ xmm1, xmm2, imm8 - /// VPSLLQ xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_slli_epi64 (__m128i a, int immediate) + /// PSLLQ xmm1, imm8 + /// VPSLLQ xmm1, xmm2, imm8 + /// VPSLLQ xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_slli_epi64 (__m128i a, int immediate) - /// PSLLQ xmm1, imm8 - /// VPSLLQ xmm1, xmm2, imm8 - /// VPSLLQ xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_slli_epi64 (__m128i a, int immediate) + /// PSLLQ xmm1, imm8 + /// VPSLLQ xmm1, xmm2, imm8 + /// VPSLLQ xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_bslli_si128 (__m128i a, int imm8) - /// PSLLDQ xmm1, imm8 - /// VPSLLDQ xmm1, xmm2/m128, imm8 + /// __m128i _mm_bslli_si128 (__m128i a, int imm8) + /// PSLLDQ xmm1, imm8 + /// VPSLLDQ xmm1, xmm2/m128, imm8 /// public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_bslli_si128 (__m128i a, int imm8) - /// PSLLDQ xmm1, imm8 - /// VPSLLDQ xmm1, xmm2/m128, imm8 + /// __m128i _mm_bslli_si128 (__m128i a, int imm8) + /// PSLLDQ xmm1, imm8 + /// VPSLLDQ xmm1, xmm2/m128, imm8 /// public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_bslli_si128 (__m128i a, int imm8) - /// PSLLDQ xmm1, imm8 - /// VPSLLDQ xmm1, xmm2/m128, imm8 - /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. + /// __m128i _mm_bslli_si128 (__m128i a, int imm8) + /// PSLLDQ xmm1, imm8 + /// VPSLLDQ xmm1, xmm2/m128, imm8 + /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. /// public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_bslli_si128 (__m128i a, int imm8) - /// PSLLDQ xmm1, imm8 - /// VPSLLDQ xmm1, xmm2/m128, imm8 - /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. + /// __m128i _mm_bslli_si128 (__m128i a, int imm8) + /// PSLLDQ xmm1, imm8 + /// VPSLLDQ xmm1, xmm2/m128, imm8 + /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. /// public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_bslli_si128 (__m128i a, int imm8) - /// PSLLDQ xmm1, imm8 - /// VPSLLDQ xmm1, xmm2/m128, imm8 - /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. + /// __m128i _mm_bslli_si128 (__m128i a, int imm8) + /// PSLLDQ xmm1, imm8 + /// VPSLLDQ xmm1, xmm2/m128, imm8 + /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. /// public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_bslli_si128 (__m128i a, int imm8) - /// PSLLDQ xmm1, imm8 - /// VPSLLDQ xmm1, xmm2/m128, imm8 - /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. + /// __m128i _mm_bslli_si128 (__m128i a, int imm8) + /// PSLLDQ xmm1, imm8 + /// VPSLLDQ xmm1, xmm2/m128, imm8 + /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. /// public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_bslli_si128 (__m128i a, int imm8) - /// PSLLDQ xmm1, imm8 - /// VPSLLDQ xmm1, xmm2/m128, imm8 - /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. + /// __m128i _mm_bslli_si128 (__m128i a, int imm8) + /// PSLLDQ xmm1, imm8 + /// VPSLLDQ xmm1, xmm2/m128, imm8 + /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. /// public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_bslli_si128 (__m128i a, int imm8) - /// PSLLDQ xmm1, imm8 - /// VPSLLDQ xmm1, xmm2/m128, imm8 - /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. + /// __m128i _mm_bslli_si128 (__m128i a, int imm8) + /// PSLLDQ xmm1, imm8 + /// VPSLLDQ xmm1, xmm2/m128, imm8 + /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. /// public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sra_epi16 (__m128i a, __m128i count) - /// PSRAW xmm1, xmm2/m128 - /// VPSRAW xmm1, xmm2, xmm3/m128 - /// VPSRAW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sra_epi16 (__m128i a, __m128i count) + /// PSRAW xmm1, xmm2/m128 + /// VPSRAW xmm1, xmm2, xmm3/m128 + /// VPSRAW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightArithmetic(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sra_epi32 (__m128i a, __m128i count) - /// PSRAD xmm1, xmm2/m128 - /// VPSRAD xmm1, xmm2, xmm3/m128 - /// VPSRAD xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sra_epi32 (__m128i a, __m128i count) + /// PSRAD xmm1, xmm2/m128 + /// VPSRAD xmm1, xmm2, xmm3/m128 + /// VPSRAD xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightArithmetic(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srai_epi16 (__m128i a, int immediate) - /// PSRAW xmm1, imm8 - /// VPSRAW xmm1, xmm2, imm8 - /// VPSRAW xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_srai_epi16 (__m128i a, int immediate) + /// PSRAW xmm1, imm8 + /// VPSRAW xmm1, xmm2, imm8 + /// VPSRAW xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftRightArithmetic(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srai_epi32 (__m128i a, int immediate) - /// PSRAD xmm1, imm8 - /// VPSRAD xmm1, xmm2, imm8 - /// VPSRAD xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_srai_epi32 (__m128i a, int immediate) + /// PSRAD xmm1, imm8 + /// VPSRAD xmm1, xmm2, imm8 + /// VPSRAD xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftRightArithmetic(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srl_epi16 (__m128i a, __m128i count) - /// PSRLW xmm1, xmm2/m128 - /// VPSRLW xmm1, xmm2, xmm3/m128 - /// VPSRLW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_srl_epi16 (__m128i a, __m128i count) + /// PSRLW xmm1, xmm2/m128 + /// VPSRLW xmm1, xmm2, xmm3/m128 + /// VPSRLW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightLogical(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srl_epi16 (__m128i a, __m128i count) - /// PSRLW xmm1, xmm2/m128 - /// VPSRLW xmm1, xmm2, xmm3/m128 - /// VPSRLW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_srl_epi16 (__m128i a, __m128i count) + /// PSRLW xmm1, xmm2/m128 + /// VPSRLW xmm1, xmm2, xmm3/m128 + /// VPSRLW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightLogical(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srl_epi32 (__m128i a, __m128i count) - /// PSRLD xmm1, xmm2/m128 - /// VPSRLD xmm1, xmm2, xmm3/m128 - /// VPSRLD xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_srl_epi32 (__m128i a, __m128i count) + /// PSRLD xmm1, xmm2/m128 + /// VPSRLD xmm1, xmm2, xmm3/m128 + /// VPSRLD xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightLogical(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srl_epi32 (__m128i a, __m128i count) - /// PSRLD xmm1, xmm2/m128 - /// VPSRLD xmm1, xmm2, xmm3/m128 - /// VPSRLD xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_srl_epi32 (__m128i a, __m128i count) + /// PSRLD xmm1, xmm2/m128 + /// VPSRLD xmm1, xmm2, xmm3/m128 + /// VPSRLD xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightLogical(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srl_epi64 (__m128i a, __m128i count) - /// PSRLQ xmm1, xmm2/m128 - /// VPSRLQ xmm1, xmm2, xmm3/m128 - /// VPSRLQ xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_srl_epi64 (__m128i a, __m128i count) + /// PSRLQ xmm1, xmm2/m128 + /// VPSRLQ xmm1, xmm2, xmm3/m128 + /// VPSRLQ xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightLogical(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srl_epi64 (__m128i a, __m128i count) - /// PSRLQ xmm1, xmm2/m128 - /// VPSRLQ xmm1, xmm2, xmm3/m128 - /// VPSRLQ xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_srl_epi64 (__m128i a, __m128i count) + /// PSRLQ xmm1, xmm2/m128 + /// VPSRLQ xmm1, xmm2, xmm3/m128 + /// VPSRLQ xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightLogical(Vector128 value, Vector128 count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srli_epi16 (__m128i a, int immediate) - /// PSRLW xmm1, imm8 - /// VPSRLW xmm1, xmm2, imm8 - /// VPSRLW xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_srli_epi16 (__m128i a, int immediate) + /// PSRLW xmm1, imm8 + /// VPSRLW xmm1, xmm2, imm8 + /// VPSRLW xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srli_epi16 (__m128i a, int immediate) - /// PSRLW xmm1, imm8 - /// VPSRLW xmm1, xmm2, imm8 - /// VPSRLW xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_srli_epi16 (__m128i a, int immediate) + /// PSRLW xmm1, imm8 + /// VPSRLW xmm1, xmm2, imm8 + /// VPSRLW xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srli_epi32 (__m128i a, int immediate) - /// PSRLD xmm1, imm8 - /// VPSRLD xmm1, xmm2, imm8 - /// VPSRLD xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_srli_epi32 (__m128i a, int immediate) + /// PSRLD xmm1, imm8 + /// VPSRLD xmm1, xmm2, imm8 + /// VPSRLD xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srli_epi32 (__m128i a, int immediate) - /// PSRLD xmm1, imm8 - /// VPSRLD xmm1, xmm2, imm8 - /// VPSRLD xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_srli_epi32 (__m128i a, int immediate) + /// PSRLD xmm1, imm8 + /// VPSRLD xmm1, xmm2, imm8 + /// VPSRLD xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srli_epi64 (__m128i a, int immediate) - /// PSRLQ xmm1, imm8 - /// VPSRLQ xmm1, xmm2, imm8 - /// VPSRLQ xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_srli_epi64 (__m128i a, int immediate) + /// PSRLQ xmm1, imm8 + /// VPSRLQ xmm1, xmm2, imm8 + /// VPSRLQ xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_srli_epi64 (__m128i a, int immediate) - /// PSRLQ xmm1, imm8 - /// VPSRLQ xmm1, xmm2, imm8 - /// VPSRLQ xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_srli_epi64 (__m128i a, int immediate) + /// PSRLQ xmm1, imm8 + /// VPSRLQ xmm1, xmm2, imm8 + /// VPSRLQ xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected] byte count) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) - /// PSRLDQ xmm1, imm8 - /// VPSRLDQ xmm1, xmm2/m128, imm8 + /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) + /// PSRLDQ xmm1, imm8 + /// VPSRLDQ xmm1, xmm2/m128, imm8 /// public static Vector128 ShiftRightLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) - /// PSRLDQ xmm1, imm8 - /// VPSRLDQ xmm1, xmm2/m128, imm8 + /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) + /// PSRLDQ xmm1, imm8 + /// VPSRLDQ xmm1, xmm2/m128, imm8 /// public static Vector128 ShiftRightLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) - /// PSRLDQ xmm1, imm8 - /// VPSRLDQ xmm1, xmm2/m128, imm8 - /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. + /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) + /// PSRLDQ xmm1, imm8 + /// VPSRLDQ xmm1, xmm2/m128, imm8 + /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. /// public static Vector128 ShiftRightLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) - /// PSRLDQ xmm1, imm8 - /// VPSRLDQ xmm1, xmm2/m128, imm8 - /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. + /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) + /// PSRLDQ xmm1, imm8 + /// VPSRLDQ xmm1, xmm2/m128, imm8 + /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. /// public static Vector128 ShiftRightLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) - /// PSRLDQ xmm1, imm8 - /// VPSRLDQ xmm1, xmm2/m128, imm8 - /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. + /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) + /// PSRLDQ xmm1, imm8 + /// VPSRLDQ xmm1, xmm2/m128, imm8 + /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. /// public static Vector128 ShiftRightLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) - /// PSRLDQ xmm1, imm8 - /// VPSRLDQ xmm1, xmm2/m128, imm8 - /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. + /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) + /// PSRLDQ xmm1, imm8 + /// VPSRLDQ xmm1, xmm2/m128, imm8 + /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. /// public static Vector128 ShiftRightLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) - /// PSRLDQ xmm1, imm8 - /// VPSRLDQ xmm1, xmm2/m128, imm8 - /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. + /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) + /// PSRLDQ xmm1, imm8 + /// VPSRLDQ xmm1, xmm2/m128, imm8 + /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. /// public static Vector128 ShiftRightLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) - /// PSRLDQ xmm1, imm8 - /// VPSRLDQ xmm1, xmm2/m128, imm8 - /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. + /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) + /// PSRLDQ xmm1, imm8 + /// VPSRLDQ xmm1, xmm2/m128, imm8 + /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. /// public static Vector128 ShiftRightLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_shuffle_epi32 (__m128i a, int immediate) - /// PSHUFD xmm1, xmm2/m128, imm8 - /// VPSHUFD xmm1, xmm2/m128, imm8 - /// VPSHUFD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128i _mm_shuffle_epi32 (__m128i a, int immediate) + /// PSHUFD xmm1, xmm2/m128, imm8 + /// VPSHUFD xmm1, xmm2/m128, imm8 + /// VPSHUFD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 Shuffle(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_shuffle_epi32 (__m128i a, int immediate) - /// PSHUFD xmm1, xmm2/m128, imm8 - /// VPSHUFD xmm1, xmm2/m128, imm8 - /// VPSHUFD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128i _mm_shuffle_epi32 (__m128i a, int immediate) + /// PSHUFD xmm1, xmm2/m128, imm8 + /// VPSHUFD xmm1, xmm2/m128, imm8 + /// VPSHUFD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 Shuffle(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_shuffle_pd (__m128d a, __m128d b, int immediate) - /// SHUFPD xmm1, xmm2/m128, imm8 - /// VSHUFPD xmm1, xmm2, xmm3/m128, imm8 - /// VSHUFPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128d _mm_shuffle_pd (__m128d a, __m128d b, int immediate) + /// SHUFPD xmm1, xmm2/m128, imm8 + /// VSHUFPD xmm1, xmm2, xmm3/m128, imm8 + /// VSHUFPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 Shuffle(Vector128 left, Vector128 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_shufflehi_epi16 (__m128i a, int immediate) - /// PSHUFHW xmm1, xmm2/m128, imm8 - /// VPSHUFHW xmm1, xmm2/m128, imm8 - /// VPSHUFHW xmm1 {k1}{z}, xmm2/m128, imm8 + /// __m128i _mm_shufflehi_epi16 (__m128i a, int immediate) + /// PSHUFHW xmm1, xmm2/m128, imm8 + /// VPSHUFHW xmm1, xmm2/m128, imm8 + /// VPSHUFHW xmm1 {k1}{z}, xmm2/m128, imm8 /// public static Vector128 ShuffleHigh(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_shufflehi_epi16 (__m128i a, int control) - /// PSHUFHW xmm1, xmm2/m128, imm8 - /// VPSHUFHW xmm1, xmm2/m128, imm8 - /// VPSHUFHW xmm1 {k1}{z}, xmm2/m128, imm8 + /// __m128i _mm_shufflehi_epi16 (__m128i a, int control) + /// PSHUFHW xmm1, xmm2/m128, imm8 + /// VPSHUFHW xmm1, xmm2/m128, imm8 + /// VPSHUFHW xmm1 {k1}{z}, xmm2/m128, imm8 /// public static Vector128 ShuffleHigh(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_shufflelo_epi16 (__m128i a, int control) - /// PSHUFLW xmm1, xmm2/m128, imm8 - /// VPSHUFLW xmm1, xmm2/m128, imm8 - /// VPSHUFLW xmm1 {k1}{z}, xmm2/m128, imm8 + /// __m128i _mm_shufflelo_epi16 (__m128i a, int control) + /// PSHUFLW xmm1, xmm2/m128, imm8 + /// VPSHUFLW xmm1, xmm2/m128, imm8 + /// VPSHUFLW xmm1 {k1}{z}, xmm2/m128, imm8 /// public static Vector128 ShuffleLow(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_shufflelo_epi16 (__m128i a, int control) - /// PSHUFLW xmm1, xmm2/m128, imm8 - /// VPSHUFLW xmm1, xmm2/m128, imm8 - /// VPSHUFLW xmm1 {k1}{z}, xmm2/m128, imm8 + /// __m128i _mm_shufflelo_epi16 (__m128i a, int control) + /// PSHUFLW xmm1, xmm2/m128, imm8 + /// VPSHUFLW xmm1, xmm2/m128, imm8 + /// VPSHUFLW xmm1 {k1}{z}, xmm2/m128, imm8 /// public static Vector128 ShuffleLow(Vector128 value, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_sqrt_pd (__m128d a) - /// SQRTPD xmm1, xmm2/m128 - /// VSQRTPD xmm1, xmm2/m128 - /// VSQRTPD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_sqrt_pd (__m128d a) + /// SQRTPD xmm1, xmm2/m128 + /// VSQRTPD xmm1, xmm2/m128 + /// VSQRTPD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 Sqrt(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_sqrt_sd (__m128d a) - /// SQRTSD xmm1, xmm2/m64 - /// VSQRTSD xmm1, xmm2, xmm3/m64 - /// VSQRTSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_sqrt_sd (__m128d a) + /// SQRTSD xmm1, xmm2/m64 + /// VSQRTSD xmm1, xmm2, xmm3/m64 + /// VSQRTSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 SqrtScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_sqrt_sd (__m128d a, __m128d b) - /// SQRTSD xmm1, xmm2/m64 - /// VSQRTSD xmm1, xmm2, xmm3/m64 - /// VSQRTSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} + /// __m128d _mm_sqrt_sd (__m128d a, __m128d b) + /// SQRTSD xmm1, xmm2/m64 + /// VSQRTSD xmm1, xmm2, xmm3/m64 + /// VSQRTSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} /// public static Vector128 SqrtScalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQU m128, xmm1 - /// VMOVDQU m128, xmm1 - /// VMOVDQU8 m128 {k1}{z}, xmm1 + /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQU m128, xmm1 + /// VMOVDQU m128, xmm1 + /// VMOVDQU8 m128 {k1}{z}, xmm1 /// public static unsafe void Store(sbyte* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQU m128, xmm1 - /// VMOVDQU m128, xmm1 - /// VMOVDQU8 m128 {k1}{z}, xmm1 + /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQU m128, xmm1 + /// VMOVDQU m128, xmm1 + /// VMOVDQU8 m128 {k1}{z}, xmm1 /// public static unsafe void Store(byte* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQU m128, xmm1 - /// VMOVDQU m128, xmm1 - /// VMOVDQU16 m128 {k1}{z}, xmm1 + /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQU m128, xmm1 + /// VMOVDQU m128, xmm1 + /// VMOVDQU16 m128 {k1}{z}, xmm1 /// public static unsafe void Store(short* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQU m128, xmm1 - /// VMOVDQU m128, xmm1 - /// VMOVDQU16 m128 {k1}{z}, xmm1 + /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQU m128, xmm1 + /// VMOVDQU m128, xmm1 + /// VMOVDQU16 m128 {k1}{z}, xmm1 /// public static unsafe void Store(ushort* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQU m128, xmm1 - /// VMOVDQU m128, xmm1 - /// VMOVDQU32 m128 {k1}{z}, xmm1 + /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQU m128, xmm1 + /// VMOVDQU m128, xmm1 + /// VMOVDQU32 m128 {k1}{z}, xmm1 /// public static unsafe void Store(int* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQU m128, xmm1 - /// VMOVDQU m128, xmm1 - /// VMOVDQU32 m128 {k1}{z}, xmm1 + /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQU m128, xmm1 + /// VMOVDQU m128, xmm1 + /// VMOVDQU32 m128 {k1}{z}, xmm1 /// public static unsafe void Store(uint* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQU m128, xmm1 - /// VMOVDQU m128, xmm1 - /// VMOVDQU64 m128 {k1}{z}, xmm1 + /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQU m128, xmm1 + /// VMOVDQU m128, xmm1 + /// VMOVDQU64 m128 {k1}{z}, xmm1 /// public static unsafe void Store(long* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQU m128, xmm1 - /// VMOVDQU m128, xmm1 - /// VMOVDQU64 m128 {k1}{z}, xmm1 + /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQU m128, xmm1 + /// VMOVDQU m128, xmm1 + /// VMOVDQU64 m128 {k1}{z}, xmm1 /// public static unsafe void Store(ulong* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_storeu_pd (double* mem_addr, __m128d a) - /// MOVAPD m128, xmm1 - /// VMOVAPD m128, xmm1 - /// VMOVAPD m128 {k1}{z}, xmm1 + /// void _mm_storeu_pd (double* mem_addr, __m128d a) + /// MOVAPD m128, xmm1 + /// VMOVAPD m128, xmm1 + /// VMOVAPD m128 {k1}{z}, xmm1 /// public static unsafe void Store(double* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQA m128, xmm1 - /// VMOVDQA m128, xmm1 - /// VMOVDQA32 m128 {k1}{z}, xmm1 + /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQA m128, xmm1 + /// VMOVDQA m128, xmm1 + /// VMOVDQA32 m128 {k1}{z}, xmm1 /// public static unsafe void StoreAligned(sbyte* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQA m128, xmm1 - /// VMOVDQA m128, xmm1 - /// VMOVDQA32 m128 {k1}{z}, xmm1 + /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQA m128, xmm1 + /// VMOVDQA m128, xmm1 + /// VMOVDQA32 m128 {k1}{z}, xmm1 /// public static unsafe void StoreAligned(byte* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQA m128, xmm1 - /// VMOVDQA m128, xmm1 - /// VMOVDQA32 m128 {k1}{z}, xmm1 + /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQA m128, xmm1 + /// VMOVDQA m128, xmm1 + /// VMOVDQA32 m128 {k1}{z}, xmm1 /// public static unsafe void StoreAligned(short* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQA m128, xmm1 - /// VMOVDQA m128, xmm1 - /// VMOVDQA32 m128 {k1}{z}, xmm1 + /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQA m128, xmm1 + /// VMOVDQA m128, xmm1 + /// VMOVDQA32 m128 {k1}{z}, xmm1 /// public static unsafe void StoreAligned(ushort* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQA m128, xmm1 - /// VMOVDQA m128, xmm1 - /// VMOVDQA32 m128 {k1}{z}, xmm1 + /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQA m128, xmm1 + /// VMOVDQA m128, xmm1 + /// VMOVDQA32 m128 {k1}{z}, xmm1 /// public static unsafe void StoreAligned(int* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQA m128, xmm1 - /// VMOVDQA m128, xmm1 - /// VMOVDQA32 m128 {k1}{z}, xmm1 + /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQA m128, xmm1 + /// VMOVDQA m128, xmm1 + /// VMOVDQA32 m128 {k1}{z}, xmm1 /// public static unsafe void StoreAligned(uint* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQA m128, xmm1 - /// VMOVDQA m128, xmm1 - /// VMOVDQA64 m128 {k1}{z}, xmm1 + /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQA m128, xmm1 + /// VMOVDQA m128, xmm1 + /// VMOVDQA64 m128 {k1}{z}, xmm1 /// public static unsafe void StoreAligned(long* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQA m128, xmm1 - /// VMOVDQA m128, xmm1 - /// VMOVDQA64 m128 {k1}{z}, xmm1 + /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQA m128, xmm1 + /// VMOVDQA m128, xmm1 + /// VMOVDQA64 m128 {k1}{z}, xmm1 /// public static unsafe void StoreAligned(ulong* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_store_pd (double* mem_addr, __m128d a) - /// MOVAPD m128, xmm1 - /// VMOVAPD m128, xmm1 - /// VMOVAPD m128 {k1}{z}, xmm1 + /// void _mm_store_pd (double* mem_addr, __m128d a) + /// MOVAPD m128, xmm1 + /// VMOVAPD m128, xmm1 + /// VMOVAPD m128 {k1}{z}, xmm1 /// public static unsafe void StoreAligned(double* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) - /// MOVNTDQ m128, xmm1 - /// VMOVNTDQ m128, xmm1 + /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) + /// MOVNTDQ m128, xmm1 + /// VMOVNTDQ m128, xmm1 /// public static unsafe void StoreAlignedNonTemporal(sbyte* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) - /// MOVNTDQ m128, xmm1 - /// VMOVNTDQ m128, xmm1 + /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) + /// MOVNTDQ m128, xmm1 + /// VMOVNTDQ m128, xmm1 /// public static unsafe void StoreAlignedNonTemporal(byte* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) - /// MOVNTDQ m128, xmm1 - /// VMOVNTDQ m128, xmm1 + /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) + /// MOVNTDQ m128, xmm1 + /// VMOVNTDQ m128, xmm1 /// public static unsafe void StoreAlignedNonTemporal(short* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) - /// MOVNTDQ m128, xmm1 - /// VMOVNTDQ m128, xmm1 + /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) + /// MOVNTDQ m128, xmm1 + /// VMOVNTDQ m128, xmm1 /// public static unsafe void StoreAlignedNonTemporal(ushort* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) - /// MOVNTDQ m128, xmm1 - /// VMOVNTDQ m128, xmm1 + /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) + /// MOVNTDQ m128, xmm1 + /// VMOVNTDQ m128, xmm1 /// public static unsafe void StoreAlignedNonTemporal(int* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) - /// MOVNTDQ m128, xmm1 - /// VMOVNTDQ m128, xmm1 + /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) + /// MOVNTDQ m128, xmm1 + /// VMOVNTDQ m128, xmm1 /// public static unsafe void StoreAlignedNonTemporal(uint* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) - /// MOVNTDQ m128, xmm1 - /// VMOVNTDQ m128, xmm1 + /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) + /// MOVNTDQ m128, xmm1 + /// VMOVNTDQ m128, xmm1 /// public static unsafe void StoreAlignedNonTemporal(long* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) - /// MOVNTDQ m128, xmm1 - /// VMOVNTDQ m128, xmm1 + /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) + /// MOVNTDQ m128, xmm1 + /// VMOVNTDQ m128, xmm1 /// public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_stream_pd (double* mem_addr, __m128d a) - /// MOVNTPD m128, xmm1 - /// VMOVNTPD m128, xmm1 + /// void _mm_stream_pd (double* mem_addr, __m128d a) + /// MOVNTPD m128, xmm1 + /// VMOVNTPD m128, xmm1 /// public static unsafe void StoreAlignedNonTemporal(double* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_storeh_pd (double* mem_addr, __m128d a) - /// MOVHPD m64, xmm1 - /// VMOVHPD m64, xmm1 + /// void _mm_storeh_pd (double* mem_addr, __m128d a) + /// MOVHPD m64, xmm1 + /// VMOVHPD m64, xmm1 /// public static unsafe void StoreHigh(double* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_storel_pd (double* mem_addr, __m128d a) - /// MOVLPD m64, xmm1 - /// VMOVLPD m64, xmm1 + /// void _mm_storel_pd (double* mem_addr, __m128d a) + /// MOVLPD m64, xmm1 + /// VMOVLPD m64, xmm1 /// public static unsafe void StoreLow(double* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_stream_si32(int *p, int a) - /// MOVNTI m32, r32 + /// void _mm_stream_si32(int *p, int a) + /// MOVNTI m32, r32 /// public static unsafe void StoreNonTemporal(int* address, int value) { throw new PlatformNotSupportedException(); } /// - /// void _mm_stream_si32(int *p, int a) - /// MOVNTI m32, r32 + /// void _mm_stream_si32(int *p, int a) + /// MOVNTI m32, r32 /// public static unsafe void StoreNonTemporal(uint* address, uint value) { throw new PlatformNotSupportedException(); } /// - /// void _mm_storeu_si32 (void* mem_addr, __m128i a) - /// MOVD m32, xmm1 - /// VMOVD m32, xmm1 + /// void _mm_storeu_si32 (void* mem_addr, __m128i a) + /// MOVD m32, xmm1 + /// VMOVD m32, xmm1 /// public static unsafe void StoreScalar(int* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_storeu_si32 (void* mem_addr, __m128i a) - /// MOVD m32, xmm1 - /// VMOVD m32, xmm1 + /// void _mm_storeu_si32 (void* mem_addr, __m128i a) + /// MOVD m32, xmm1 + /// VMOVD m32, xmm1 /// public static unsafe void StoreScalar(uint* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_storel_epi64 (__m128i* mem_addr, __m128i a) - /// MOVQ m64, xmm1 - /// VMOVQ m64, xmm1 + /// void _mm_storel_epi64 (__m128i* mem_addr, __m128i a) + /// MOVQ m64, xmm1 + /// VMOVQ m64, xmm1 /// public static unsafe void StoreScalar(long* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_storel_epi64 (__m128i* mem_addr, __m128i a) - /// MOVQ m64, xmm1 - /// VMOVQ m64, xmm1 + /// void _mm_storel_epi64 (__m128i* mem_addr, __m128i a) + /// MOVQ m64, xmm1 + /// VMOVQ m64, xmm1 /// public static unsafe void StoreScalar(ulong* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// void _mm_store_sd (double* mem_addr, __m128d a) - /// MOVSD m64, xmm1 - /// VMOVSD m64, xmm1 - /// VMOVSD m64 {k1}, xmm1 + /// void _mm_store_sd (double* mem_addr, __m128d a) + /// MOVSD m64, xmm1 + /// VMOVSD m64, xmm1 + /// VMOVSD m64 {k1}, xmm1 /// public static unsafe void StoreScalar(double* address, Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sub_epi8 (__m128i a, __m128i b) - /// PSUBB xmm1, xmm2/m128 - /// VPSUBB xmm1, xmm2, xmm3/m128 - /// VPSUBB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sub_epi8 (__m128i a, __m128i b) + /// PSUBB xmm1, xmm2/m128 + /// VPSUBB xmm1, xmm2, xmm3/m128 + /// VPSUBB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sub_epi8 (__m128i a, __m128i b) - /// PSUBB xmm1, xmm2/m128 - /// VPSUBB xmm1, xmm2, xmm3/m128 - /// VPSUBB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sub_epi8 (__m128i a, __m128i b) + /// PSUBB xmm1, xmm2/m128 + /// VPSUBB xmm1, xmm2, xmm3/m128 + /// VPSUBB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sub_epi16 (__m128i a, __m128i b) - /// PSUBW xmm1, xmm2/m128 - /// VPSUBW xmm1, xmm2, xmm3/m128 - /// VPSUBW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sub_epi16 (__m128i a, __m128i b) + /// PSUBW xmm1, xmm2/m128 + /// VPSUBW xmm1, xmm2, xmm3/m128 + /// VPSUBW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sub_epi16 (__m128i a, __m128i b) - /// PSUBW xmm1, xmm2/m128 - /// VPSUBW xmm1, xmm2, xmm3/m128 - /// VPSUBW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sub_epi16 (__m128i a, __m128i b) + /// PSUBW xmm1, xmm2/m128 + /// VPSUBW xmm1, xmm2, xmm3/m128 + /// VPSUBW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sub_epi32 (__m128i a, __m128i b) - /// PSUBD xmm1, xmm2/m128 - /// VPSUBD xmm1, xmm2, xmm3/m128 - /// VPSUBD xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sub_epi32 (__m128i a, __m128i b) + /// PSUBD xmm1, xmm2/m128 + /// VPSUBD xmm1, xmm2, xmm3/m128 + /// VPSUBD xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sub_epi32 (__m128i a, __m128i b) - /// PSUBD xmm1, xmm2/m128 - /// VPSUBD xmm1, xmm2, xmm3/m128 - /// VPSUBD xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sub_epi32 (__m128i a, __m128i b) + /// PSUBD xmm1, xmm2/m128 + /// VPSUBD xmm1, xmm2, xmm3/m128 + /// VPSUBD xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sub_epi64 (__m128i a, __m128i b) - /// PSUBQ xmm1, xmm2/m128 - /// VPSUBQ xmm1, xmm2, xmm3/m128 - /// VPSUBQ xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sub_epi64 (__m128i a, __m128i b) + /// PSUBQ xmm1, xmm2/m128 + /// VPSUBQ xmm1, xmm2, xmm3/m128 + /// VPSUBQ xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sub_epi64 (__m128i a, __m128i b) - /// PSUBQ xmm1, xmm2/m128 - /// VPSUBQ xmm1, xmm2, xmm3/m128 - /// VPSUBQ xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sub_epi64 (__m128i a, __m128i b) + /// PSUBQ xmm1, xmm2/m128 + /// VPSUBQ xmm1, xmm2, xmm3/m128 + /// VPSUBQ xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_sub_pd (__m128d a, __m128d b) - /// SUBPD xmm1, xmm2/m128 - /// VSUBPD xmm1, xmm2, xmm3/m128 - /// VSUBPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_sub_pd (__m128d a, __m128d b) + /// SUBPD xmm1, xmm2/m128 + /// VSUBPD xmm1, xmm2, xmm3/m128 + /// VSUBPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Subtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_sub_sd (__m128d a, __m128d b) - /// SUBSD xmm1, xmm2/m64 - /// VSUBSD xmm1, xmm2, xmm3/m64 - /// VSUBSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} + /// __m128d _mm_sub_sd (__m128d a, __m128d b) + /// SUBSD xmm1, xmm2/m64 + /// VSUBSD xmm1, xmm2, xmm3/m64 + /// VSUBSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} /// public static Vector128 SubtractScalar(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_subs_epi8 (__m128i a, __m128i b) - /// PSUBSB xmm1, xmm2/m128 - /// VPSUBSB xmm1, xmm2, xmm3/m128 - /// VPSUBSB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_subs_epi8 (__m128i a, __m128i b) + /// PSUBSB xmm1, xmm2/m128 + /// VPSUBSB xmm1, xmm2, xmm3/m128 + /// VPSUBSB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_subs_epi16 (__m128i a, __m128i b) - /// PSUBSW xmm1, xmm2/m128 - /// VPSUBSW xmm1, xmm2, xmm3/m128 - /// VPSUBSW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_subs_epi16 (__m128i a, __m128i b) + /// PSUBSW xmm1, xmm2/m128 + /// VPSUBSW xmm1, xmm2, xmm3/m128 + /// VPSUBSW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_subs_epu8 (__m128i a, __m128i b) - /// PSUBUSB xmm1, xmm2/m128 - /// VPSUBUSB xmm1, xmm2, xmm3/m128 - /// VPSUBUSB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_subs_epu8 (__m128i a, __m128i b) + /// PSUBUSB xmm1, xmm2/m128 + /// VPSUBUSB xmm1, xmm2, xmm3/m128 + /// VPSUBUSB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_subs_epu16 (__m128i a, __m128i b) - /// PSUBUSW xmm1, xmm2/m128 - /// VPSUBUSW xmm1, xmm2, xmm3/m128 - /// VPSUBUSW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_subs_epu16 (__m128i a, __m128i b) + /// PSUBUSW xmm1, xmm2/m128 + /// VPSUBUSW xmm1, xmm2, xmm3/m128 + /// VPSUBUSW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sad_epu8 (__m128i a, __m128i b) - /// PSADBW xmm1, xmm2/m128 - /// VPSADBW xmm1, xmm2, xmm3/m128 - /// VPSADBW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sad_epu8 (__m128i a, __m128i b) + /// PSADBW xmm1, xmm2/m128 + /// VPSADBW xmm1, xmm2, xmm3/m128 + /// VPSADBW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 SumAbsoluteDifferences(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_unpackhi_epi8 (__m128i a, __m128i b) - /// PUNPCKHBW xmm1, xmm2/m128 - /// VPUNPCKHBW xmm1, xmm2, xmm3/m128 - /// VPUNPCKHBW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_unpackhi_epi8 (__m128i a, __m128i b) + /// PUNPCKHBW xmm1, xmm2/m128 + /// VPUNPCKHBW xmm1, xmm2, xmm3/m128 + /// VPUNPCKHBW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_unpackhi_epi8 (__m128i a, __m128i b) - /// PUNPCKHBW xmm1, xmm2/m128 - /// VPUNPCKHBW xmm1, xmm2, xmm3/m128 - /// VPUNPCKHBW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_unpackhi_epi8 (__m128i a, __m128i b) + /// PUNPCKHBW xmm1, xmm2/m128 + /// VPUNPCKHBW xmm1, xmm2, xmm3/m128 + /// VPUNPCKHBW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_unpackhi_epi16 (__m128i a, __m128i b) - /// PUNPCKHWD xmm1, xmm2/m128 - /// VPUNPCKHWD xmm1, xmm2, xmm3/m128 - /// VPUNPCKHWD xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_unpackhi_epi16 (__m128i a, __m128i b) + /// PUNPCKHWD xmm1, xmm2/m128 + /// VPUNPCKHWD xmm1, xmm2, xmm3/m128 + /// VPUNPCKHWD xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_unpackhi_epi16 (__m128i a, __m128i b) - /// PUNPCKHWD xmm1, xmm2/m128 - /// VPUNPCKHWD xmm1, xmm2, xmm3/m128 - /// VPUNPCKHWD xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_unpackhi_epi16 (__m128i a, __m128i b) + /// PUNPCKHWD xmm1, xmm2/m128 + /// VPUNPCKHWD xmm1, xmm2, xmm3/m128 + /// VPUNPCKHWD xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_unpackhi_epi32 (__m128i a, __m128i b) - /// PUNPCKHDQ xmm1, xmm2/m128 - /// VPUNPCKHDQ xmm1, xmm2, xmm3/m128 - /// VPUNPCKHDQ xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_unpackhi_epi32 (__m128i a, __m128i b) + /// PUNPCKHDQ xmm1, xmm2/m128 + /// VPUNPCKHDQ xmm1, xmm2, xmm3/m128 + /// VPUNPCKHDQ xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_unpackhi_epi32 (__m128i a, __m128i b) - /// PUNPCKHDQ xmm1, xmm2/m128 - /// VPUNPCKHDQ xmm1, xmm2, xmm3/m128 - /// VPUNPCKHDQ xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_unpackhi_epi32 (__m128i a, __m128i b) + /// PUNPCKHDQ xmm1, xmm2/m128 + /// VPUNPCKHDQ xmm1, xmm2, xmm3/m128 + /// VPUNPCKHDQ xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_unpackhi_epi64 (__m128i a, __m128i b) - /// PUNPCKHQDQ xmm1, xmm2/m128 - /// VPUNPCKHQDQ xmm1, xmm2, xmm3/m128 - /// VPUNPCKHQDQ xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_unpackhi_epi64 (__m128i a, __m128i b) + /// PUNPCKHQDQ xmm1, xmm2/m128 + /// VPUNPCKHQDQ xmm1, xmm2, xmm3/m128 + /// VPUNPCKHQDQ xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_unpackhi_epi64 (__m128i a, __m128i b) - /// PUNPCKHQDQ xmm1, xmm2/m128 - /// VPUNPCKHQDQ xmm1, xmm2, xmm3/m128 - /// VPUNPCKHQDQ xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_unpackhi_epi64 (__m128i a, __m128i b) + /// PUNPCKHQDQ xmm1, xmm2/m128 + /// VPUNPCKHQDQ xmm1, xmm2, xmm3/m128 + /// VPUNPCKHQDQ xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_unpackhi_pd (__m128d a, __m128d b) - /// UNPCKHPD xmm1, xmm2/m128 - /// VUNPCKHPD xmm1, xmm2, xmm3/m128 - /// VUNPCKHPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_unpackhi_pd (__m128d a, __m128d b) + /// UNPCKHPD xmm1, xmm2/m128 + /// VUNPCKHPD xmm1, xmm2, xmm3/m128 + /// VUNPCKHPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 UnpackHigh(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_unpacklo_epi8 (__m128i a, __m128i b) - /// PUNPCKLBW xmm1, xmm2/m128 - /// VPUNPCKLBW xmm1, xmm2, xmm3/m128 - /// VPUNPCKLBW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_unpacklo_epi8 (__m128i a, __m128i b) + /// PUNPCKLBW xmm1, xmm2/m128 + /// VPUNPCKLBW xmm1, xmm2, xmm3/m128 + /// VPUNPCKLBW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_unpacklo_epi8 (__m128i a, __m128i b) - /// PUNPCKLBW xmm1, xmm2/m128 - /// VPUNPCKLBW xmm1, xmm2, xmm3/m128 - /// VPUNPCKLBW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_unpacklo_epi8 (__m128i a, __m128i b) + /// PUNPCKLBW xmm1, xmm2/m128 + /// VPUNPCKLBW xmm1, xmm2, xmm3/m128 + /// VPUNPCKLBW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_unpacklo_epi16 (__m128i a, __m128i b) - /// PUNPCKLWD xmm1, xmm2/m128 - /// VPUNPCKLWD xmm1, xmm2, xmm3/m128 - /// VPUNPCKLWD xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_unpacklo_epi16 (__m128i a, __m128i b) + /// PUNPCKLWD xmm1, xmm2/m128 + /// VPUNPCKLWD xmm1, xmm2, xmm3/m128 + /// VPUNPCKLWD xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_unpacklo_epi16 (__m128i a, __m128i b) - /// PUNPCKLWD xmm1, xmm2/m128 - /// VPUNPCKLWD xmm1, xmm2, xmm3/m128 - /// VPUNPCKLWD xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_unpacklo_epi16 (__m128i a, __m128i b) + /// PUNPCKLWD xmm1, xmm2/m128 + /// VPUNPCKLWD xmm1, xmm2, xmm3/m128 + /// VPUNPCKLWD xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_unpacklo_epi32 (__m128i a, __m128i b) - /// PUNPCKLDQ xmm1, xmm2/m128 - /// VPUNPCKLDQ xmm1, xmm2, xmm3/m128 - /// VPUNPCKLDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_unpacklo_epi32 (__m128i a, __m128i b) + /// PUNPCKLDQ xmm1, xmm2/m128 + /// VPUNPCKLDQ xmm1, xmm2, xmm3/m128 + /// VPUNPCKLDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_unpacklo_epi32 (__m128i a, __m128i b) - /// PUNPCKLDQ xmm1, xmm2/m128 - /// VPUNPCKLDQ xmm1, xmm2, xmm3/m128 - /// VPUNPCKLDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_unpacklo_epi32 (__m128i a, __m128i b) + /// PUNPCKLDQ xmm1, xmm2/m128 + /// VPUNPCKLDQ xmm1, xmm2, xmm3/m128 + /// VPUNPCKLDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_unpacklo_epi64 (__m128i a, __m128i b) - /// PUNPCKLQDQ xmm1, xmm2/m128 - /// VPUNPCKLQDQ xmm1, xmm2, xmm3/m128 - /// VPUNPCKLQDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_unpacklo_epi64 (__m128i a, __m128i b) + /// PUNPCKLQDQ xmm1, xmm2/m128 + /// VPUNPCKLQDQ xmm1, xmm2, xmm3/m128 + /// VPUNPCKLQDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_unpacklo_epi64 (__m128i a, __m128i b) - /// PUNPCKLQDQ xmm1, xmm2/m128 - /// VPUNPCKLQDQ xmm1, xmm2, xmm3/m128 - /// VPUNPCKLQDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_unpacklo_epi64 (__m128i a, __m128i b) + /// PUNPCKLQDQ xmm1, xmm2/m128 + /// VPUNPCKLQDQ xmm1, xmm2, xmm3/m128 + /// VPUNPCKLQDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_unpacklo_pd (__m128d a, __m128d b) - /// UNPCKLPD xmm1, xmm2/m128 - /// VUNPCKLPD xmm1, xmm2, xmm3/m128 - /// VUNPCKLPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_unpacklo_pd (__m128d a, __m128d b) + /// UNPCKLPD xmm1, xmm2/m128 + /// VUNPCKLPD xmm1, xmm2, xmm3/m128 + /// VUNPCKLPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 UnpackLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_xor_si128 (__m128i a, __m128i b) - /// PXOR xmm1, xmm2/m128 - /// VPXOR xmm1, xmm2, xmm3/m128 + /// __m128i _mm_xor_si128 (__m128i a, __m128i b) + /// PXOR xmm1, xmm2/m128 + /// VPXOR xmm1, xmm2, xmm3/m128 /// public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_xor_si128 (__m128i a, __m128i b) - /// PXOR xmm1, xmm2/m128 - /// VPXOR xmm1, xmm2, xmm3/m128 + /// __m128i _mm_xor_si128 (__m128i a, __m128i b) + /// PXOR xmm1, xmm2/m128 + /// VPXOR xmm1, xmm2, xmm3/m128 /// public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_xor_si128 (__m128i a, __m128i b) - /// PXOR xmm1, xmm2/m128 - /// VPXOR xmm1, xmm2, xmm3/m128 + /// __m128i _mm_xor_si128 (__m128i a, __m128i b) + /// PXOR xmm1, xmm2/m128 + /// VPXOR xmm1, xmm2, xmm3/m128 /// public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_xor_si128 (__m128i a, __m128i b) - /// PXOR xmm1, xmm2/m128 - /// VPXOR xmm1, xmm2, xmm3/m128 + /// __m128i _mm_xor_si128 (__m128i a, __m128i b) + /// PXOR xmm1, xmm2/m128 + /// VPXOR xmm1, xmm2, xmm3/m128 /// public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_xor_si128 (__m128i a, __m128i b) - /// PXOR xmm1, xmm2/m128 - /// VPXOR xmm1, xmm2, xmm3/m128 - /// VPXORD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_xor_si128 (__m128i a, __m128i b) + /// PXOR xmm1, xmm2/m128 + /// VPXOR xmm1, xmm2, xmm3/m128 + /// VPXORD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_xor_si128 (__m128i a, __m128i b) - /// PXOR xmm1, xmm2/m128 - /// VPXOR xmm1, xmm2, xmm3/m128 - /// VPXORD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_xor_si128 (__m128i a, __m128i b) + /// PXOR xmm1, xmm2/m128 + /// VPXOR xmm1, xmm2, xmm3/m128 + /// VPXORD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_xor_si128 (__m128i a, __m128i b) - /// PXOR xmm1, xmm2/m128 - /// VPXOR xmm1, xmm2, xmm3/m128 - /// VPXORQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_xor_si128 (__m128i a, __m128i b) + /// PXOR xmm1, xmm2/m128 + /// VPXOR xmm1, xmm2, xmm3/m128 + /// VPXORQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_xor_si128 (__m128i a, __m128i b) - /// PXOR xmm1, xmm2/m128 - /// VPXOR xmm1, xmm2, xmm3/m128 - /// VPXORQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_xor_si128 (__m128i a, __m128i b) + /// PXOR xmm1, xmm2/m128 + /// VPXOR xmm1, xmm2, xmm3/m128 + /// VPXORQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_xor_pd (__m128d a, __m128d b) - /// XORPD xmm1, xmm2/m128 - /// VXORPD xmm1, xmm2, xmm3/m128 - /// VXORPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_xor_pd (__m128d a, __m128d b) + /// XORPD xmm1, xmm2/m128 + /// VXORPD xmm1, xmm2, xmm3/m128 + /// VXORPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Xor(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse2.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse2.cs index 072c7f9b64b..5fba62f5f16 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse2.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse2.cs @@ -6,2140 +6,2145 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel SSE2 hardware instructions via intrinsics - /// + /// Provides access to X86 SSE2 hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Sse2 : Sse { internal Sse2() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the x86 SSE2 hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : Sse.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } /// - /// __m128d _mm_cvtsi64_sd (__m128d a, __int64 b) - /// CVTSI2SD xmm1, r/m64 - /// VCVTSI2SD xmm1, xmm2, r/m64 - /// This intrinsic is only available on 64-bit processes + /// __m128d _mm_cvtsi64_sd (__m128d a, __int64 b) + /// CVTSI2SD xmm1, r/m64 + /// VCVTSI2SD xmm1, xmm2, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Double(Vector128 upper, long value) => ConvertScalarToVector128Double(upper, value); /// - /// __m128i _mm_cvtsi64_si128 (__int64 a) - /// MOVQ xmm1, r/m64 - /// VMOVQ xmm1, r/m64 - /// This intrinsic is only available on 64-bit processes + /// __m128i _mm_cvtsi64_si128 (__int64 a) + /// MOVQ xmm1, r/m64 + /// VMOVQ xmm1, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128Int64(long value) => ConvertScalarToVector128Int64(value); /// - /// __m128i _mm_cvtsi64_si128 (__int64 a) - /// MOVQ xmm1, r/m64 - /// VMOVQ xmm1, r/m64 - /// This intrinsic is only available on 64-bit processes + /// __m128i _mm_cvtsi64_si128 (__int64 a) + /// MOVQ xmm1, r/m64 + /// VMOVQ xmm1, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static Vector128 ConvertScalarToVector128UInt64(ulong value) => ConvertScalarToVector128UInt64(value); /// - /// __int64 _mm_cvtsi128_si64 (__m128i a) - /// MOVQ r/m64, xmm1 - /// VMOVQ r/m64, xmm1 - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_cvtsi128_si64 (__m128i a) + /// MOVQ r/m64, xmm1 + /// VMOVQ r/m64, xmm1 + /// This intrinsic is only available on 64-bit processes /// public static long ConvertToInt64(Vector128 value) => ConvertToInt64(value); /// - /// __int64 _mm_cvtsd_si64 (__m128d a) - /// CVTSD2SI r64, xmm1/m64 - /// VCVTSD2SI r64, xmm1/m64 - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_cvtsd_si64 (__m128d a) + /// CVTSD2SI r64, xmm1/m64 + /// VCVTSD2SI r64, xmm1/m64 + /// This intrinsic is only available on 64-bit processes /// public static long ConvertToInt64(Vector128 value) => ConvertToInt64(value); /// - /// __int64 _mm_cvttsd_si64 (__m128d a) - /// CVTTSD2SI r64, xmm1/m64 - /// VCVTTSD2SI r64, xmm1/m64 - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_cvttsd_si64 (__m128d a) + /// CVTTSD2SI r64, xmm1/m64 + /// VCVTTSD2SI r64, xmm1/m64 + /// This intrinsic is only available on 64-bit processes /// public static long ConvertToInt64WithTruncation(Vector128 value) => ConvertToInt64WithTruncation(value); /// - /// __int64 _mm_cvtsi128_si64 (__m128i a) - /// MOVQ r/m64, xmm1 - /// VMOVQ r/m64, xmm1 - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_cvtsi128_si64 (__m128i a) + /// MOVQ r/m64, xmm1 + /// VMOVQ r/m64, xmm1 + /// This intrinsic is only available on 64-bit processes /// public static ulong ConvertToUInt64(Vector128 value) => ConvertToUInt64(value); /// - /// void _mm_stream_si64(__int64 *p, __int64 a) - /// MOVNTI m64, r64 - /// This intrinsic is only available on 64-bit processes + /// void _mm_stream_si64(__int64 *p, __int64 a) + /// MOVNTI m64, r64 + /// This intrinsic is only available on 64-bit processes /// public static unsafe void StoreNonTemporal(long* address, long value) => StoreNonTemporal(address, value); /// - /// void _mm_stream_si64(__int64 *p, __int64 a) - /// MOVNTI m64, r64 - /// This intrinsic is only available on 64-bit processes + /// void _mm_stream_si64(__int64 *p, __int64 a) + /// MOVNTI m64, r64 + /// This intrinsic is only available on 64-bit processes /// public static unsafe void StoreNonTemporal(ulong* address, ulong value) => StoreNonTemporal(address, value); } /// - /// __m128i _mm_add_epi8 (__m128i a, __m128i b) - /// PADDB xmm1, xmm2/m128 - /// VPADDB xmm1, xmm2, xmm3/m128 - /// VPADDB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_add_epi8 (__m128i a, __m128i b) + /// PADDB xmm1, xmm2/m128 + /// VPADDB xmm1, xmm2, xmm3/m128 + /// VPADDB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// - /// __m128i _mm_add_epi8 (__m128i a, __m128i b) - /// PADDB xmm1, xmm2/m128 - /// VPADDB xmm1, xmm2, xmm3/m128 - /// VPADDB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_add_epi8 (__m128i a, __m128i b) + /// PADDB xmm1, xmm2/m128 + /// VPADDB xmm1, xmm2, xmm3/m128 + /// VPADDB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// - /// __m128i _mm_add_epi16 (__m128i a, __m128i b) - /// PADDW xmm1, xmm2/m128 - /// VPADDW xmm1, xmm2, xmm3/m128 - /// VPADDW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_add_epi16 (__m128i a, __m128i b) + /// PADDW xmm1, xmm2/m128 + /// VPADDW xmm1, xmm2, xmm3/m128 + /// VPADDW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// - /// __m128i _mm_add_epi16 (__m128i a, __m128i b) - /// PADDW xmm1, xmm2/m128 - /// VPADDW xmm1, xmm2, xmm3/m128 - /// VPADDW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_add_epi16 (__m128i a, __m128i b) + /// PADDW xmm1, xmm2/m128 + /// VPADDW xmm1, xmm2, xmm3/m128 + /// VPADDW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// - /// __m128i _mm_add_epi32 (__m128i a, __m128i b) - /// PADDD xmm1, xmm2/m128 - /// VPADDD xmm1, xmm2, xmm3/m128 - /// VPADDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_add_epi32 (__m128i a, __m128i b) + /// PADDD xmm1, xmm2/m128 + /// VPADDD xmm1, xmm2, xmm3/m128 + /// VPADDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// - /// __m128i _mm_add_epi32 (__m128i a, __m128i b) - /// PADDD xmm1, xmm2/m128 - /// VPADDD xmm1, xmm2, xmm3/m128 - /// VPADDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_add_epi32 (__m128i a, __m128i b) + /// PADDD xmm1, xmm2/m128 + /// VPADDD xmm1, xmm2, xmm3/m128 + /// VPADDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// - /// __m128i _mm_add_epi64 (__m128i a, __m128i b) - /// PADDQ xmm1, xmm2/m128 - /// VPADDQ xmm1, xmm2, xmm3/m128 - /// VPADDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_add_epi64 (__m128i a, __m128i b) + /// PADDQ xmm1, xmm2/m128 + /// VPADDQ xmm1, xmm2, xmm3/m128 + /// VPADDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// - /// __m128i _mm_add_epi64 (__m128i a, __m128i b) - /// PADDQ xmm1, xmm2/m128 - /// VPADDQ xmm1, xmm2, xmm3/m128 - /// VPADDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_add_epi64 (__m128i a, __m128i b) + /// PADDQ xmm1, xmm2/m128 + /// VPADDQ xmm1, xmm2, xmm3/m128 + /// VPADDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// - /// __m128d _mm_add_pd (__m128d a, __m128d b) - /// ADDPD xmm1, xmm2/m128 - /// VADDPD xmm1, xmm2, xmm3/m128 - /// VADDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_add_pd (__m128d a, __m128d b) + /// ADDPD xmm1, xmm2/m128 + /// VADDPD xmm1, xmm2, xmm3/m128 + /// VADDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Add(Vector128 left, Vector128 right) => Add(left, right); /// - /// __m128d _mm_add_sd (__m128d a, __m128d b) - /// ADDSD xmm1, xmm2/m64 - /// VADDSD xmm1, xmm2, xmm3/m64 - /// VADDSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} + /// __m128d _mm_add_sd (__m128d a, __m128d b) + /// ADDSD xmm1, xmm2/m64 + /// VADDSD xmm1, xmm2, xmm3/m64 + /// VADDSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} /// public static Vector128 AddScalar(Vector128 left, Vector128 right) => AddScalar(left, right); /// - /// __m128i _mm_adds_epi8 (__m128i a, __m128i b) - /// PADDSB xmm1, xmm2/m128 - /// VPADDSB xmm1, xmm2, xmm3/m128 - /// VPADDSB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_adds_epi8 (__m128i a, __m128i b) + /// PADDSB xmm1, xmm2/m128 + /// VPADDSB xmm1, xmm2, xmm3/m128 + /// VPADDSB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); /// - /// __m128i _mm_adds_epu8 (__m128i a, __m128i b) - /// PADDUSB xmm1, xmm2/m128 - /// VPADDUSB xmm1, xmm2, xmm3/m128 - /// VPADDUSB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_adds_epu8 (__m128i a, __m128i b) + /// PADDUSB xmm1, xmm2/m128 + /// VPADDUSB xmm1, xmm2, xmm3/m128 + /// VPADDUSB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); /// - /// __m128i _mm_adds_epi16 (__m128i a, __m128i b) - /// PADDSW xmm1, xmm2/m128 - /// VPADDSW xmm1, xmm2, xmm3/m128 - /// VPADDSW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_adds_epi16 (__m128i a, __m128i b) + /// PADDSW xmm1, xmm2/m128 + /// VPADDSW xmm1, xmm2, xmm3/m128 + /// VPADDSW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); /// - /// __m128i _mm_adds_epu16 (__m128i a, __m128i b) - /// PADDUSW xmm1, xmm2/m128 - /// VPADDUSW xmm1, xmm2, xmm3/m128 - /// VPADDUSW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_adds_epu16 (__m128i a, __m128i b) + /// PADDUSW xmm1, xmm2/m128 + /// VPADDUSW xmm1, xmm2, xmm3/m128 + /// VPADDUSW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 AddSaturate(Vector128 left, Vector128 right) => AddSaturate(left, right); /// - /// __m128i _mm_and_si128 (__m128i a, __m128i b) - /// PAND xmm1, xmm2/m128 - /// VPAND xmm1, xmm2, xmm3/m128 + /// __m128i _mm_and_si128 (__m128i a, __m128i b) + /// PAND xmm1, xmm2/m128 + /// VPAND xmm1, xmm2, xmm3/m128 /// public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// - /// __m128i _mm_and_si128 (__m128i a, __m128i b) - /// PAND xmm1, xmm2/m128 - /// VPAND xmm1, xmm2, xmm3/m128 + /// __m128i _mm_and_si128 (__m128i a, __m128i b) + /// PAND xmm1, xmm2/m128 + /// VPAND xmm1, xmm2, xmm3/m128 /// public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// - /// __m128i _mm_and_si128 (__m128i a, __m128i b) - /// PAND xmm1, xmm2/m128 - /// VPAND xmm1, xmm2, xmm3/m128 + /// __m128i _mm_and_si128 (__m128i a, __m128i b) + /// PAND xmm1, xmm2/m128 + /// VPAND xmm1, xmm2, xmm3/m128 /// public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// - /// __m128i _mm_and_si128 (__m128i a, __m128i b) - /// PAND xmm1, xmm2/m128 - /// VPAND xmm1, xmm2, xmm3/m128 + /// __m128i _mm_and_si128 (__m128i a, __m128i b) + /// PAND xmm1, xmm2/m128 + /// VPAND xmm1, xmm2, xmm3/m128 /// public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// - /// __m128i _mm_and_si128 (__m128i a, __m128i b) - /// PAND xmm1, xmm2/m128 - /// VPAND xmm1, xmm2, xmm3/m128 - /// VPANDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_and_si128 (__m128i a, __m128i b) + /// PAND xmm1, xmm2/m128 + /// VPAND xmm1, xmm2, xmm3/m128 + /// VPANDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// - /// __m128i _mm_and_si128 (__m128i a, __m128i b) - /// PAND xmm1, xmm2/m128 - /// VPAND xmm1, xmm2, xmm3/m128 - /// VPANDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_and_si128 (__m128i a, __m128i b) + /// PAND xmm1, xmm2/m128 + /// VPAND xmm1, xmm2, xmm3/m128 + /// VPANDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// - /// __m128i _mm_and_si128 (__m128i a, __m128i b) - /// PAND xmm1, xmm2/m128 - /// VPAND xmm1, xmm2, xmm3/m128 - /// VPANDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_and_si128 (__m128i a, __m128i b) + /// PAND xmm1, xmm2/m128 + /// VPAND xmm1, xmm2, xmm3/m128 + /// VPANDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// - /// __m128i _mm_and_si128 (__m128i a, __m128i b) - /// PAND xmm1, xmm2/m128 - /// VPAND xmm1, xmm2, xmm3/m128 - /// VPANDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_and_si128 (__m128i a, __m128i b) + /// PAND xmm1, xmm2/m128 + /// VPAND xmm1, xmm2, xmm3/m128 + /// VPANDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// - /// __m128d _mm_and_pd (__m128d a, __m128d b) - /// ANDPD xmm1, xmm2/m128 - /// VANDPD xmm1, xmm2, xmm3/m128 - /// VANDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_and_pd (__m128d a, __m128d b) + /// ANDPD xmm1, xmm2/m128 + /// VANDPD xmm1, xmm2, xmm3/m128 + /// VANDPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 And(Vector128 left, Vector128 right) => And(left, right); /// - /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) - /// PANDN xmm1, xmm2/m128 - /// VPANDN xmm1, xmm2, xmm3/m128 + /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) + /// PANDN xmm1, xmm2/m128 + /// VPANDN xmm1, xmm2, xmm3/m128 /// public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); /// - /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) - /// PANDN xmm1, xmm2/m128 - /// VPANDN xmm1, xmm2, xmm3/m128 + /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) + /// PANDN xmm1, xmm2/m128 + /// VPANDN xmm1, xmm2, xmm3/m128 /// public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); /// - /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) - /// PANDN xmm1, xmm2/m128 - /// VPANDN xmm1, xmm2, xmm3/m128 + /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) + /// PANDN xmm1, xmm2/m128 + /// VPANDN xmm1, xmm2, xmm3/m128 /// public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); /// - /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) - /// PANDN xmm1, xmm2/m128 - /// VPANDN xmm1, xmm2, xmm3/m128 + /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) + /// PANDN xmm1, xmm2/m128 + /// VPANDN xmm1, xmm2, xmm3/m128 /// public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); /// - /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) - /// PANDN xmm1, xmm2/m128 - /// VPANDN xmm1, xmm2, xmm3/m128 - /// VPANDND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) + /// PANDN xmm1, xmm2/m128 + /// VPANDN xmm1, xmm2, xmm3/m128 + /// VPANDND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); /// - /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) - /// PANDN xmm1, xmm2/m128 - /// VPANDN xmm1, xmm2, xmm3/m128 - /// VPANDND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) + /// PANDN xmm1, xmm2/m128 + /// VPANDN xmm1, xmm2, xmm3/m128 + /// VPANDND xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); /// - /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) - /// PANDN xmm1, xmm2/m128 - /// VPANDN xmm1, xmm2, xmm3/m128 - /// VPANDNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) + /// PANDN xmm1, xmm2/m128 + /// VPANDN xmm1, xmm2, xmm3/m128 + /// VPANDNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); /// - /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) - /// PANDN xmm1, xmm2/m128 - /// VPANDN xmm1, xmm2, xmm3/m128 - /// VPANDNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_andnot_si128 (__m128i a, __m128i b) + /// PANDN xmm1, xmm2/m128 + /// VPANDN xmm1, xmm2, xmm3/m128 + /// VPANDNQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); /// - /// __m128d _mm_andnot_pd (__m128d a, __m128d b) - /// ANDNPD xmm1, xmm2/m128 - /// VANDNPD xmm1, xmm2, xmm3/m128 - /// VANDNPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_andnot_pd (__m128d a, __m128d b) + /// ANDNPD xmm1, xmm2/m128 + /// VANDNPD xmm1, xmm2, xmm3/m128 + /// VANDNPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 AndNot(Vector128 left, Vector128 right) => AndNot(left, right); /// - /// __m128i _mm_avg_epu8 (__m128i a, __m128i b) - /// PAVGB xmm1, xmm2/m128 - /// VPAVGB xmm1, xmm2, xmm3/m128 - /// VPAVGB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_avg_epu8 (__m128i a, __m128i b) + /// PAVGB xmm1, xmm2/m128 + /// VPAVGB xmm1, xmm2, xmm3/m128 + /// VPAVGB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Average(Vector128 left, Vector128 right) => Average(left, right); /// - /// __m128i _mm_avg_epu16 (__m128i a, __m128i b) - /// PAVGW xmm1, xmm2/m128 - /// VPAVGW xmm1, xmm2, xmm3/m128 - /// VPAVGW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_avg_epu16 (__m128i a, __m128i b) + /// PAVGW xmm1, xmm2/m128 + /// VPAVGW xmm1, xmm2, xmm3/m128 + /// VPAVGW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Average(Vector128 left, Vector128 right) => Average(left, right); /// - /// __m128i _mm_cmpeq_epi8 (__m128i a, __m128i b) - /// PCMPEQB xmm1, xmm2/m128 - /// VPCMPEQB xmm1, xmm2, xmm3/m128 + /// __m128i _mm_cmpeq_epi8 (__m128i a, __m128i b) + /// PCMPEQB xmm1, xmm2/m128 + /// VPCMPEQB xmm1, xmm2, xmm3/m128 /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// - /// __m128i _mm_cmpeq_epi8 (__m128i a, __m128i b) - /// PCMPEQB xmm1, xmm2/m128 - /// VPCMPEQB xmm1, xmm2, xmm3/m128 + /// __m128i _mm_cmpeq_epi8 (__m128i a, __m128i b) + /// PCMPEQB xmm1, xmm2/m128 + /// VPCMPEQB xmm1, xmm2, xmm3/m128 /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// - /// __m128i _mm_cmpeq_epi16 (__m128i a, __m128i b) - /// PCMPEQW xmm1, xmm2/m128 - /// VPCMPEQW xmm1, xmm2, xmm3/m128 + /// __m128i _mm_cmpeq_epi16 (__m128i a, __m128i b) + /// PCMPEQW xmm1, xmm2/m128 + /// VPCMPEQW xmm1, xmm2, xmm3/m128 /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// - /// __m128i _mm_cmpeq_epi16 (__m128i a, __m128i b) - /// PCMPEQW xmm1, xmm2/m128 - /// VPCMPEQW xmm1, xmm2, xmm3/m128 + /// __m128i _mm_cmpeq_epi16 (__m128i a, __m128i b) + /// PCMPEQW xmm1, xmm2/m128 + /// VPCMPEQW xmm1, xmm2, xmm3/m128 /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// - /// __m128i _mm_cmpeq_epi32 (__m128i a, __m128i b) - /// PCMPEQD xmm1, xmm2/m128 - /// VPCMPEQD xmm1, xmm2, xmm3/m128 + /// __m128i _mm_cmpeq_epi32 (__m128i a, __m128i b) + /// PCMPEQD xmm1, xmm2/m128 + /// VPCMPEQD xmm1, xmm2, xmm3/m128 /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// - /// __m128i _mm_cmpeq_epi32 (__m128i a, __m128i b) - /// PCMPEQD xmm1, xmm2/m128 - /// VPCMPEQD xmm1, xmm2, xmm3/m128 + /// __m128i _mm_cmpeq_epi32 (__m128i a, __m128i b) + /// PCMPEQD xmm1, xmm2/m128 + /// VPCMPEQD xmm1, xmm2, xmm3/m128 /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// - /// __m128d _mm_cmpeq_pd (__m128d a, __m128d b) - /// CMPPD xmm1, xmm2/m128, imm8(0) - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(0) + /// __m128d _mm_cmpeq_pd (__m128d a, __m128d b) + /// CMPPD xmm1, xmm2/m128, imm8(0) + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(0) /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// - /// __m128i _mm_cmpgt_epi8 (__m128i a, __m128i b) - /// PCMPGTB xmm1, xmm2/m128 - /// VPCMPGTB xmm1, xmm2, xmm3/m128 + /// __m128i _mm_cmpgt_epi8 (__m128i a, __m128i b) + /// PCMPGTB xmm1, xmm2/m128 + /// VPCMPGTB xmm1, xmm2, xmm3/m128 /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// - /// __m128i _mm_cmpgt_epi16 (__m128i a, __m128i b) - /// PCMPGTW xmm1, xmm2/m128 - /// VPCMPGTW xmm1, xmm2, xmm3/m128 + /// __m128i _mm_cmpgt_epi16 (__m128i a, __m128i b) + /// PCMPGTW xmm1, xmm2/m128 + /// VPCMPGTW xmm1, xmm2, xmm3/m128 /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// - /// __m128i _mm_cmpgt_epi32 (__m128i a, __m128i b) - /// PCMPGTD xmm1, xmm2/m128 - /// VPCMPGTD xmm1, xmm2, xmm3/m128 + /// __m128i _mm_cmpgt_epi32 (__m128i a, __m128i b) + /// PCMPGTD xmm1, xmm2/m128 + /// VPCMPGTD xmm1, xmm2, xmm3/m128 /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// - /// __m128d _mm_cmpgt_pd (__m128d a, __m128d b) - /// CMPPD xmm1, xmm2/m128, imm8(1) ; with swapped operands - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(1) ; with swapped operands + /// __m128d _mm_cmpgt_pd (__m128d a, __m128d b) + /// CMPPD xmm1, xmm2/m128, imm8(1) ; with swapped operands + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(1) ; with swapped operands /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// - /// __m128d _mm_cmpge_pd (__m128d a, __m128d b) - /// CMPPD xmm1, xmm2/m128, imm8(2) ; with swapped operands - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(2) ; with swapped operands + /// __m128d _mm_cmpge_pd (__m128d a, __m128d b) + /// CMPPD xmm1, xmm2/m128, imm8(2) ; with swapped operands + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(2) ; with swapped operands /// public static Vector128 CompareGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareGreaterThanOrEqual(left, right); /// - /// __m128i _mm_cmplt_epi8 (__m128i a, __m128i b) - /// PCMPGTB xmm1, xmm2/m128 ; with swapped operands - /// VPCMPGTB xmm1, xmm2, xmm3/m128 ; with swapped operands + /// __m128i _mm_cmplt_epi8 (__m128i a, __m128i b) + /// PCMPGTB xmm1, xmm2/m128 ; with swapped operands + /// VPCMPGTB xmm1, xmm2, xmm3/m128 ; with swapped operands /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// __m128i _mm_cmplt_epi16 (__m128i a, __m128i b) - /// PCMPGTW xmm1, xmm2/m128 ; with swapped operands - /// VPCMPGTW xmm1, xmm2, xmm3/m128 ; with swapped operands + /// __m128i _mm_cmplt_epi16 (__m128i a, __m128i b) + /// PCMPGTW xmm1, xmm2/m128 ; with swapped operands + /// VPCMPGTW xmm1, xmm2, xmm3/m128 ; with swapped operands /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// __m128i _mm_cmplt_epi32 (__m128i a, __m128i b) - /// PCMPGTD xmm1, xmm2/m128 ; with swapped operands - /// VPCMPGTD xmm1, xmm2, xmm3/m128 ; with swapped operands + /// __m128i _mm_cmplt_epi32 (__m128i a, __m128i b) + /// PCMPGTD xmm1, xmm2/m128 ; with swapped operands + /// VPCMPGTD xmm1, xmm2, xmm3/m128 ; with swapped operands /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// __m128d _mm_cmplt_pd (__m128d a, __m128d b) - /// CMPPD xmm1, xmm2/m128, imm8(1) - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(1) + /// __m128d _mm_cmplt_pd (__m128d a, __m128d b) + /// CMPPD xmm1, xmm2/m128, imm8(1) + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(1) /// public static Vector128 CompareLessThan(Vector128 left, Vector128 right) => CompareLessThan(left, right); /// - /// __m128d _mm_cmple_pd (__m128d a, __m128d b) - /// CMPPD xmm1, xmm2/m128, imm8(2) - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(2) + /// __m128d _mm_cmple_pd (__m128d a, __m128d b) + /// CMPPD xmm1, xmm2/m128, imm8(2) + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(2) /// public static Vector128 CompareLessThanOrEqual(Vector128 left, Vector128 right) => CompareLessThanOrEqual(left, right); /// - /// __m128d _mm_cmpneq_pd (__m128d a, __m128d b) - /// CMPPD xmm1, xmm2/m128, imm8(4) - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(4) + /// __m128d _mm_cmpneq_pd (__m128d a, __m128d b) + /// CMPPD xmm1, xmm2/m128, imm8(4) + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(4) /// public static Vector128 CompareNotEqual(Vector128 left, Vector128 right) => CompareNotEqual(left, right); /// - /// __m128d _mm_cmpngt_pd (__m128d a, __m128d b) - /// CMPPD xmm1, xmm2/m128, imm8(5) ; with swapped operands - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(5) ; with swapped operands + /// __m128d _mm_cmpngt_pd (__m128d a, __m128d b) + /// CMPPD xmm1, xmm2/m128, imm8(5) ; with swapped operands + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(5) ; with swapped operands /// public static Vector128 CompareNotGreaterThan(Vector128 left, Vector128 right) => CompareNotGreaterThan(left, right); /// - /// __m128d _mm_cmpnge_pd (__m128d a, __m128d b) - /// CMPPD xmm1, xmm2/m128, imm8(6) ; with swapped operands - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(6) ; with swapped operands + /// __m128d _mm_cmpnge_pd (__m128d a, __m128d b) + /// CMPPD xmm1, xmm2/m128, imm8(6) ; with swapped operands + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(6) ; with swapped operands /// public static Vector128 CompareNotGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareNotGreaterThanOrEqual(left, right); /// - /// __m128d _mm_cmpnlt_pd (__m128d a, __m128d b) - /// CMPPD xmm1, xmm2/m128, imm8(5) - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(5) + /// __m128d _mm_cmpnlt_pd (__m128d a, __m128d b) + /// CMPPD xmm1, xmm2/m128, imm8(5) + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(5) /// public static Vector128 CompareNotLessThan(Vector128 left, Vector128 right) => CompareNotLessThan(left, right); /// - /// __m128d _mm_cmpnle_pd (__m128d a, __m128d b) - /// CMPPD xmm1, xmm2/m128, imm8(6) - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(6) + /// __m128d _mm_cmpnle_pd (__m128d a, __m128d b) + /// CMPPD xmm1, xmm2/m128, imm8(6) + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(6) /// public static Vector128 CompareNotLessThanOrEqual(Vector128 left, Vector128 right) => CompareNotLessThanOrEqual(left, right); /// - /// __m128d _mm_cmpord_pd (__m128d a, __m128d b) - /// CMPPD xmm1, xmm2/m128, imm8(7) - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(7) + /// __m128d _mm_cmpord_pd (__m128d a, __m128d b) + /// CMPPD xmm1, xmm2/m128, imm8(7) + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(7) /// public static Vector128 CompareOrdered(Vector128 left, Vector128 right) => CompareOrdered(left, right); /// - /// __m128d _mm_cmpeq_sd (__m128d a, __m128d b) - /// CMPDS xmm1, xmm2/m64, imm8(0) - /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(0) + /// __m128d _mm_cmpeq_sd (__m128d a, __m128d b) + /// CMPDS xmm1, xmm2/m64, imm8(0) + /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(0) /// public static Vector128 CompareScalarEqual(Vector128 left, Vector128 right) => CompareScalarEqual(left, right); /// - /// __m128d _mm_cmpgt_sd (__m128d a, __m128d b) - /// CMPDS xmm1, xmm2/m64, imm8(1) ; with swapped operands - /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(1) ; with swapped operands + /// __m128d _mm_cmpgt_sd (__m128d a, __m128d b) + /// CMPDS xmm1, xmm2/m64, imm8(1) ; with swapped operands + /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(1) ; with swapped operands /// public static Vector128 CompareScalarGreaterThan(Vector128 left, Vector128 right) => CompareScalarGreaterThan(left, right); /// - /// __m128d _mm_cmpge_sd (__m128d a, __m128d b) - /// CMPDS xmm1, xmm2/m64, imm8(2) ; with swapped operands - /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(2) ; with swapped operands + /// __m128d _mm_cmpge_sd (__m128d a, __m128d b) + /// CMPDS xmm1, xmm2/m64, imm8(2) ; with swapped operands + /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(2) ; with swapped operands /// public static Vector128 CompareScalarGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareScalarGreaterThanOrEqual(left, right); /// - /// __m128d _mm_cmplt_sd (__m128d a, __m128d b) - /// CMPDS xmm1, xmm2/m64, imm8(1) - /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(1) + /// __m128d _mm_cmplt_sd (__m128d a, __m128d b) + /// CMPDS xmm1, xmm2/m64, imm8(1) + /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(1) /// public static Vector128 CompareScalarLessThan(Vector128 left, Vector128 right) => CompareScalarLessThan(left, right); /// - /// __m128d _mm_cmple_sd (__m128d a, __m128d b) - /// CMPDS xmm1, xmm2/m64, imm8(2) - /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(2) + /// __m128d _mm_cmple_sd (__m128d a, __m128d b) + /// CMPDS xmm1, xmm2/m64, imm8(2) + /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(2) /// public static Vector128 CompareScalarLessThanOrEqual(Vector128 left, Vector128 right) => CompareScalarLessThanOrEqual(left, right); /// - /// __m128d _mm_cmpneq_sd (__m128d a, __m128d b) - /// CMPDS xmm1, xmm2/m64, imm8(4) - /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(4) + /// __m128d _mm_cmpneq_sd (__m128d a, __m128d b) + /// CMPDS xmm1, xmm2/m64, imm8(4) + /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(4) /// public static Vector128 CompareScalarNotEqual(Vector128 left, Vector128 right) => CompareScalarNotEqual(left, right); /// - /// __m128d _mm_cmpngt_sd (__m128d a, __m128d b) - /// CMPDS xmm1, xmm2/m64, imm8(5) ; with swapped operands - /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(5) ; with swapped operands + /// __m128d _mm_cmpngt_sd (__m128d a, __m128d b) + /// CMPDS xmm1, xmm2/m64, imm8(5) ; with swapped operands + /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(5) ; with swapped operands /// public static Vector128 CompareScalarNotGreaterThan(Vector128 left, Vector128 right) => CompareScalarNotGreaterThan(left, right); /// - /// __m128d _mm_cmpnge_sd (__m128d a, __m128d b) - /// CMPDS xmm1, xmm2/m64, imm8(6) ; with swapped operands - /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(6) ; with swapped operands + /// __m128d _mm_cmpnge_sd (__m128d a, __m128d b) + /// CMPDS xmm1, xmm2/m64, imm8(6) ; with swapped operands + /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(6) ; with swapped operands /// public static Vector128 CompareScalarNotGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareScalarNotGreaterThanOrEqual(left, right); /// - /// __m128d _mm_cmpnlt_sd (__m128d a, __m128d b) - /// CMPDS xmm1, xmm2/m64, imm8(5) - /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(5) + /// __m128d _mm_cmpnlt_sd (__m128d a, __m128d b) + /// CMPDS xmm1, xmm2/m64, imm8(5) + /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(5) /// public static Vector128 CompareScalarNotLessThan(Vector128 left, Vector128 right) => CompareScalarNotLessThan(left, right); /// - /// __m128d _mm_cmpnle_sd (__m128d a, __m128d b) - /// CMPDS xmm1, xmm2/m64, imm8(6) - /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(6) + /// __m128d _mm_cmpnle_sd (__m128d a, __m128d b) + /// CMPDS xmm1, xmm2/m64, imm8(6) + /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(6) /// public static Vector128 CompareScalarNotLessThanOrEqual(Vector128 left, Vector128 right) => CompareScalarNotLessThanOrEqual(left, right); /// - /// __m128d _mm_cmpord_sd (__m128d a, __m128d b) - /// CMPDS xmm1, xmm2/m64, imm8(7) - /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(7) + /// __m128d _mm_cmpord_sd (__m128d a, __m128d b) + /// CMPDS xmm1, xmm2/m64, imm8(7) + /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(7) /// public static Vector128 CompareScalarOrdered(Vector128 left, Vector128 right) => CompareScalarOrdered(left, right); /// - /// int _mm_comieq_sd (__m128d a, __m128d b) - /// COMISD xmm1, xmm2/m64 ; ZF=1 && PF=0 - /// VCOMISD xmm1, xmm2/m64 ; ZF=1 && PF=0 - /// VCOMISD xmm1, xmm2/m64{sae} ; ZF=1 && PF=0 + /// int _mm_comieq_sd (__m128d a, __m128d b) + /// COMISD xmm1, xmm2/m64 ; ZF=1 && PF=0 + /// VCOMISD xmm1, xmm2/m64 ; ZF=1 && PF=0 + /// VCOMISD xmm1, xmm2/m64{sae} ; ZF=1 && PF=0 /// public static bool CompareScalarOrderedEqual(Vector128 left, Vector128 right) => CompareScalarOrderedEqual(left, right); /// - /// int _mm_comigt_sd (__m128d a, __m128d b) - /// COMISD xmm1, xmm2/m64 ; ZF=0 && CF=0 - /// VCOMISD xmm1, xmm2/m64 ; ZF=0 && CF=0 - /// VCOMISD xmm1, xmm2/m64{sae} ; ZF=0 && CF=0 + /// int _mm_comigt_sd (__m128d a, __m128d b) + /// COMISD xmm1, xmm2/m64 ; ZF=0 && CF=0 + /// VCOMISD xmm1, xmm2/m64 ; ZF=0 && CF=0 + /// VCOMISD xmm1, xmm2/m64{sae} ; ZF=0 && CF=0 /// public static bool CompareScalarOrderedGreaterThan(Vector128 left, Vector128 right) => CompareScalarOrderedGreaterThan(left, right); /// - /// int _mm_comige_sd (__m128d a, __m128d b) - /// COMISD xmm1, xmm2/m64 ; CF=0 - /// VCOMISD xmm1, xmm2/m64 ; CF=0 - /// VCOMISD xmm1, xmm2/m64{sae} ; CF=0 + /// int _mm_comige_sd (__m128d a, __m128d b) + /// COMISD xmm1, xmm2/m64 ; CF=0 + /// VCOMISD xmm1, xmm2/m64 ; CF=0 + /// VCOMISD xmm1, xmm2/m64{sae} ; CF=0 /// public static bool CompareScalarOrderedGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareScalarOrderedGreaterThanOrEqual(left, right); /// - /// int _mm_comilt_sd (__m128d a, __m128d b) - /// COMISD xmm1, xmm2/m64 ; PF=0 && CF=1 - /// VCOMISD xmm1, xmm2/m64 ; PF=0 && CF=1 - /// VCOMISD xmm1, xmm2/m64{sae} ; PF=0 && CF=1 + /// int _mm_comilt_sd (__m128d a, __m128d b) + /// COMISD xmm1, xmm2/m64 ; PF=0 && CF=1 + /// VCOMISD xmm1, xmm2/m64 ; PF=0 && CF=1 + /// VCOMISD xmm1, xmm2/m64{sae} ; PF=0 && CF=1 /// public static bool CompareScalarOrderedLessThan(Vector128 left, Vector128 right) => CompareScalarOrderedLessThan(left, right); /// - /// int _mm_comile_sd (__m128d a, __m128d b) - /// COMISD xmm1, xmm2/m64 ; PF=0 && (ZF=1 || CF=1) - /// VCOMISD xmm1, xmm2/m64 ; PF=0 && (ZF=1 || CF=1) - /// VCOMISD xmm1, xmm2/m64{sae} ; PF=0 && (ZF=1 || CF=1) + /// int _mm_comile_sd (__m128d a, __m128d b) + /// COMISD xmm1, xmm2/m64 ; PF=0 && (ZF=1 || CF=1) + /// VCOMISD xmm1, xmm2/m64 ; PF=0 && (ZF=1 || CF=1) + /// VCOMISD xmm1, xmm2/m64{sae} ; PF=0 && (ZF=1 || CF=1) /// public static bool CompareScalarOrderedLessThanOrEqual(Vector128 left, Vector128 right) => CompareScalarOrderedLessThanOrEqual(left, right); /// - /// int _mm_comineq_sd (__m128d a, __m128d b) - /// COMISD xmm1, xmm2/m64 ; ZF=0 || PF=1 - /// VCOMISD xmm1, xmm2/m64 ; ZF=0 || PF=1 - /// VCOMISD xmm1, xmm2/m64{sae} ; ZF=0 || PF=1 + /// int _mm_comineq_sd (__m128d a, __m128d b) + /// COMISD xmm1, xmm2/m64 ; ZF=0 || PF=1 + /// VCOMISD xmm1, xmm2/m64 ; ZF=0 || PF=1 + /// VCOMISD xmm1, xmm2/m64{sae} ; ZF=0 || PF=1 /// public static bool CompareScalarOrderedNotEqual(Vector128 left, Vector128 right) => CompareScalarOrderedNotEqual(left, right); /// - /// __m128d _mm_cmpunord_sd (__m128d a, __m128d b) - /// CMPDS xmm1, xmm2/m64, imm8(3) - /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(3) + /// __m128d _mm_cmpunord_sd (__m128d a, __m128d b) + /// CMPDS xmm1, xmm2/m64, imm8(3) + /// VCMPDS xmm1, xmm2, xmm3/m64, imm8(3) /// public static Vector128 CompareScalarUnordered(Vector128 left, Vector128 right) => CompareScalarUnordered(left, right); /// - /// int _mm_ucomieq_sd (__m128d a, __m128d b) - /// UCOMISD xmm1, xmm2/m64 ; ZF=1 && PF=0 - /// VUCOMISD xmm1, xmm2/m64 ; ZF=1 && PF=0 - /// VUCOMISD xmm1, xmm2/m64{sae} ; ZF=1 && PF=0 + /// int _mm_ucomieq_sd (__m128d a, __m128d b) + /// UCOMISD xmm1, xmm2/m64 ; ZF=1 && PF=0 + /// VUCOMISD xmm1, xmm2/m64 ; ZF=1 && PF=0 + /// VUCOMISD xmm1, xmm2/m64{sae} ; ZF=1 && PF=0 /// public static bool CompareScalarUnorderedEqual(Vector128 left, Vector128 right) => CompareScalarUnorderedEqual(left, right); /// - /// int _mm_ucomigt_sd (__m128d a, __m128d b) - /// UCOMISD xmm1, xmm2/m64 ; ZF=0 && CF=0 - /// VUCOMISD xmm1, xmm2/m64 ; ZF=0 && CF=0 - /// VUCOMISD xmm1, xmm2/m64{sae} ; ZF=0 && CF=0 + /// int _mm_ucomigt_sd (__m128d a, __m128d b) + /// UCOMISD xmm1, xmm2/m64 ; ZF=0 && CF=0 + /// VUCOMISD xmm1, xmm2/m64 ; ZF=0 && CF=0 + /// VUCOMISD xmm1, xmm2/m64{sae} ; ZF=0 && CF=0 /// public static bool CompareScalarUnorderedGreaterThan(Vector128 left, Vector128 right) => CompareScalarUnorderedGreaterThan(left, right); /// - /// int _mm_ucomige_sd (__m128d a, __m128d b) - /// UCOMISD xmm1, xmm2/m64 ; CF=0 - /// VUCOMISD xmm1, xmm2/m64 ; CF=0 - /// VUCOMISD xmm1, xmm2/m64{sae} ; CF=0 + /// int _mm_ucomige_sd (__m128d a, __m128d b) + /// UCOMISD xmm1, xmm2/m64 ; CF=0 + /// VUCOMISD xmm1, xmm2/m64 ; CF=0 + /// VUCOMISD xmm1, xmm2/m64{sae} ; CF=0 /// public static bool CompareScalarUnorderedGreaterThanOrEqual(Vector128 left, Vector128 right) => CompareScalarUnorderedGreaterThanOrEqual(left, right); /// - /// int _mm_ucomilt_sd (__m128d a, __m128d b) - /// UCOMISD xmm1, xmm2/m64 ; PF=0 && CF=1 - /// VUCOMISD xmm1, xmm2/m64 ; PF=0 && CF=1 - /// VUCOMISD xmm1, xmm2/m64{sae} ; PF=0 && CF=1 + /// int _mm_ucomilt_sd (__m128d a, __m128d b) + /// UCOMISD xmm1, xmm2/m64 ; PF=0 && CF=1 + /// VUCOMISD xmm1, xmm2/m64 ; PF=0 && CF=1 + /// VUCOMISD xmm1, xmm2/m64{sae} ; PF=0 && CF=1 /// public static bool CompareScalarUnorderedLessThan(Vector128 left, Vector128 right) => CompareScalarUnorderedLessThan(left, right); /// - /// int _mm_ucomile_sd (__m128d a, __m128d b) - /// UCOMISD xmm1, xmm2/m64 ; PF=0 && (ZF=1 || CF=1) - /// VUCOMISD xmm1, xmm2/m64 ; PF=0 && (ZF=1 || CF=1) - /// VUCOMISD xmm1, xmm2/m64{sae} ; PF=0 && (ZF=1 || CF=1) + /// int _mm_ucomile_sd (__m128d a, __m128d b) + /// UCOMISD xmm1, xmm2/m64 ; PF=0 && (ZF=1 || CF=1) + /// VUCOMISD xmm1, xmm2/m64 ; PF=0 && (ZF=1 || CF=1) + /// VUCOMISD xmm1, xmm2/m64{sae} ; PF=0 && (ZF=1 || CF=1) /// public static bool CompareScalarUnorderedLessThanOrEqual(Vector128 left, Vector128 right) => CompareScalarUnorderedLessThanOrEqual(left, right); /// - /// int _mm_ucomineq_sd (__m128d a, __m128d b) - /// UCOMISD xmm1, xmm2/m64 ; ZF=0 || PF=1 - /// VUCOMISD xmm1, xmm2/m64 ; ZF=0 || PF=1 - /// VUCOMISD xmm1, xmm2/m64{sae} ; ZF=0 || PF=1 + /// int _mm_ucomineq_sd (__m128d a, __m128d b) + /// UCOMISD xmm1, xmm2/m64 ; ZF=0 || PF=1 + /// VUCOMISD xmm1, xmm2/m64 ; ZF=0 || PF=1 + /// VUCOMISD xmm1, xmm2/m64{sae} ; ZF=0 || PF=1 /// public static bool CompareScalarUnorderedNotEqual(Vector128 left, Vector128 right) => CompareScalarUnorderedNotEqual(left, right); /// - /// __m128d _mm_cmpunord_pd (__m128d a, __m128d b) - /// CMPPD xmm1, xmm2/m128, imm8(3) - /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(3) + /// __m128d _mm_cmpunord_pd (__m128d a, __m128d b) + /// CMPPD xmm1, xmm2/m128, imm8(3) + /// VCMPPD xmm1, xmm2, xmm3/m128, imm8(3) /// public static Vector128 CompareUnordered(Vector128 left, Vector128 right) => CompareUnordered(left, right); /// - /// __m128d _mm_cvtsi32_sd (__m128d a, int b) - /// CVTSI2SD xmm1, r/m32 - /// VCVTSI2SD xmm1, xmm2, r/m32 + /// __m128d _mm_cvtsi32_sd (__m128d a, int b) + /// CVTSI2SD xmm1, r/m32 + /// VCVTSI2SD xmm1, xmm2, r/m32 /// public static Vector128 ConvertScalarToVector128Double(Vector128 upper, int value) => ConvertScalarToVector128Double(upper, value); /// - /// __m128d _mm_cvtss_sd (__m128d a, __m128 b) - /// CVTSS2SD xmm1, xmm2/m32 - /// VCVTSS2SD xmm1, xmm2, xmm3/m32 + /// __m128d _mm_cvtss_sd (__m128d a, __m128 b) + /// CVTSS2SD xmm1, xmm2/m32 + /// VCVTSS2SD xmm1, xmm2, xmm3/m32 /// public static Vector128 ConvertScalarToVector128Double(Vector128 upper, Vector128 value) => ConvertScalarToVector128Double(upper, value); /// - /// __m128i _mm_cvtsi32_si128 (int a) - /// MOVD xmm1, r/m32 - /// VMOVD xmm1, r/m32 + /// __m128i _mm_cvtsi32_si128 (int a) + /// MOVD xmm1, r/m32 + /// VMOVD xmm1, r/m32 /// public static Vector128 ConvertScalarToVector128Int32(int value) => ConvertScalarToVector128Int32(value); /// - /// __m128 _mm_cvtsd_ss (__m128 a, __m128d b) - /// CVTSD2SS xmm1, xmm2/m64 - /// VCVTSD2SS xmm1, xmm2, xmm3/m64 + /// __m128 _mm_cvtsd_ss (__m128 a, __m128d b) + /// CVTSD2SS xmm1, xmm2/m64 + /// VCVTSD2SS xmm1, xmm2, xmm3/m64 /// public static Vector128 ConvertScalarToVector128Single(Vector128 upper, Vector128 value) => ConvertScalarToVector128Single(upper, value); /// - /// __m128i _mm_cvtsi32_si128 (int a) - /// MOVD xmm1, r/m32 - /// VMOVD xmm1, r/m32 + /// __m128i _mm_cvtsi32_si128 (int a) + /// MOVD xmm1, r/m32 + /// VMOVD xmm1, r/m32 /// public static Vector128 ConvertScalarToVector128UInt32(uint value) => ConvertScalarToVector128UInt32(value); /// - /// int _mm_cvtsi128_si32 (__m128i a) - /// MOVD r/m32, xmm1 - /// VMOVD r/m32, xmm1 + /// int _mm_cvtsi128_si32 (__m128i a) + /// MOVD r/m32, xmm1 + /// VMOVD r/m32, xmm1 /// public static int ConvertToInt32(Vector128 value) => ConvertToInt32(value); /// - /// int _mm_cvtsd_si32 (__m128d a) - /// CVTSD2SI r32, xmm1/m64 - /// VCVTSD2SI r32, xmm1/m64 + /// int _mm_cvtsd_si32 (__m128d a) + /// CVTSD2SI r32, xmm1/m64 + /// VCVTSD2SI r32, xmm1/m64 /// public static int ConvertToInt32(Vector128 value) => ConvertToInt32(value); /// - /// int _mm_cvttsd_si32 (__m128d a) - /// CVTTSD2SI r32, xmm1/m64 - /// VCVTTSD2SI r32, xmm1/m64 + /// int _mm_cvttsd_si32 (__m128d a) + /// CVTTSD2SI r32, xmm1/m64 + /// VCVTTSD2SI r32, xmm1/m64 /// public static int ConvertToInt32WithTruncation(Vector128 value) => ConvertToInt32WithTruncation(value); /// - /// int _mm_cvtsi128_si32 (__m128i a) - /// MOVD r/m32, xmm1 - /// VMOVD r/m32, xmm1 + /// int _mm_cvtsi128_si32 (__m128i a) + /// MOVD r/m32, xmm1 + /// VMOVD r/m32, xmm1 /// public static uint ConvertToUInt32(Vector128 value) => ConvertToUInt32(value); /// - /// __m128d _mm_cvtepi32_pd (__m128i a) - /// CVTDQ2PD xmm1, xmm2/m64 - /// VCVTDQ2PD xmm1, xmm2/m64 - /// VCVTDQ2PD xmm1 {k1}{z}, xmm2/m64/m32bcst + /// __m128d _mm_cvtepi32_pd (__m128i a) + /// CVTDQ2PD xmm1, xmm2/m64 + /// VCVTDQ2PD xmm1, xmm2/m64 + /// VCVTDQ2PD xmm1 {k1}{z}, xmm2/m64/m32bcst /// public static Vector128 ConvertToVector128Double(Vector128 value) => ConvertToVector128Double(value); /// - /// __m128d _mm_cvtps_pd (__m128 a) - /// CVTPS2PD xmm1, xmm2/m64 - /// VCVTPS2PD xmm1, xmm2/m64 - /// VCVTPS2PD xmm1 {k1}{z}, xmm2/m64/m32bcst + /// __m128d _mm_cvtps_pd (__m128 a) + /// CVTPS2PD xmm1, xmm2/m64 + /// VCVTPS2PD xmm1, xmm2/m64 + /// VCVTPS2PD xmm1 {k1}{z}, xmm2/m64/m32bcst /// public static Vector128 ConvertToVector128Double(Vector128 value) => ConvertToVector128Double(value); /// - /// __m128i _mm_cvtps_epi32 (__m128 a) - /// CVTPS2DQ xmm1, xmm2/m128 - /// VCVTPS2DQ xmm1, xmm2/m128 - /// VCVTPS2DQ xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_cvtps_epi32 (__m128 a) + /// CVTPS2DQ xmm1, xmm2/m128 + /// VCVTPS2DQ xmm1, xmm2/m128 + /// VCVTPS2DQ xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 ConvertToVector128Int32(Vector128 value) => ConvertToVector128Int32(value); /// - /// __m128i _mm_cvtpd_epi32 (__m128d a) - /// CVTPD2DQ xmm1, xmm2/m128 - /// VCVTPD2DQ xmm1, xmm2/m128 - /// VCVTPD2DQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvtpd_epi32 (__m128d a) + /// CVTPD2DQ xmm1, xmm2/m128 + /// VCVTPD2DQ xmm1, xmm2/m128 + /// VCVTPD2DQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Int32(Vector128 value) => ConvertToVector128Int32(value); /// - /// __m128i _mm_cvttps_epi32 (__m128 a) - /// CVTTPS2DQ xmm1, xmm2/m128 - /// VCVTTPS2DQ xmm1, xmm2/m128 - /// VCVTTPS2DQ xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_cvttps_epi32 (__m128 a) + /// CVTTPS2DQ xmm1, xmm2/m128 + /// VCVTTPS2DQ xmm1, xmm2/m128 + /// VCVTTPS2DQ xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 ConvertToVector128Int32WithTruncation(Vector128 value) => ConvertToVector128Int32WithTruncation(value); /// - /// __m128i _mm_cvttpd_epi32 (__m128d a) - /// CVTTPD2DQ xmm1, xmm2/m128 - /// VCVTTPD2DQ xmm1, xmm2/m128 - /// VCVTTPD2DQ xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128i _mm_cvttpd_epi32 (__m128d a) + /// CVTTPD2DQ xmm1, xmm2/m128 + /// VCVTTPD2DQ xmm1, xmm2/m128 + /// VCVTTPD2DQ xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Int32WithTruncation(Vector128 value) => ConvertToVector128Int32WithTruncation(value); /// - /// __m128 _mm_cvtepi32_ps (__m128i a) - /// CVTDQ2PS xmm1, xmm2/m128 - /// VCVTDQ2PS xmm1, xmm2/m128 - /// VCVTDQ2PS xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128 _mm_cvtepi32_ps (__m128i a) + /// CVTDQ2PS xmm1, xmm2/m128 + /// VCVTDQ2PS xmm1, xmm2/m128 + /// VCVTDQ2PS xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 ConvertToVector128Single(Vector128 value) => ConvertToVector128Single(value); /// - /// __m128 _mm_cvtpd_ps (__m128d a) - /// CVTPD2PS xmm1, xmm2/m128 - /// VCVTPD2PS xmm1, xmm2/m128 - /// VCVTPD2PS xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128 _mm_cvtpd_ps (__m128d a) + /// CVTPD2PS xmm1, xmm2/m128 + /// VCVTPD2PS xmm1, xmm2/m128 + /// VCVTPD2PS xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 ConvertToVector128Single(Vector128 value) => ConvertToVector128Single(value); /// - /// __m128d _mm_div_pd (__m128d a, __m128d b) - /// DIVPD xmm1, xmm2/m128 - /// VDIVPD xmm1, xmm2, xmm3/m128 - /// VDIVPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_div_pd (__m128d a, __m128d b) + /// DIVPD xmm1, xmm2/m128 + /// VDIVPD xmm1, xmm2, xmm3/m128 + /// VDIVPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Divide(Vector128 left, Vector128 right) => Divide(left, right); /// - /// __m128d _mm_div_sd (__m128d a, __m128d b) - /// DIVSD xmm1, xmm2/m64 - /// VDIVSD xmm1, xmm2, xmm3/m64 + /// __m128d _mm_div_sd (__m128d a, __m128d b) + /// DIVSD xmm1, xmm2/m64 + /// VDIVSD xmm1, xmm2, xmm3/m64 /// public static Vector128 DivideScalar(Vector128 left, Vector128 right) => DivideScalar(left, right); /// - /// int _mm_extract_epi16 (__m128i a, int immediate) - /// PEXTRW r/m16, xmm1, imm8 - /// VPEXTRW r/m16, xmm1, imm8 + /// int _mm_extract_epi16 (__m128i a, int immediate) + /// PEXTRW r/m16, xmm1, imm8 + /// VPEXTRW r/m16, xmm1, imm8 /// public static ushort Extract(Vector128 value, [ConstantExpected] byte index) => Extract(value, index); /// - /// __m128i _mm_insert_epi16 (__m128i a, int i, int immediate) - /// PINSRW xmm1, r/m16, imm8 - /// VPINSRW xmm1, xmm2, r/m16, imm8 + /// __m128i _mm_insert_epi16 (__m128i a, int i, int immediate) + /// PINSRW xmm1, r/m16, imm8 + /// VPINSRW xmm1, xmm2, r/m16, imm8 /// public static Vector128 Insert(Vector128 value, short data, [ConstantExpected] byte index) => Insert(value, data, index); /// - /// __m128i _mm_insert_epi16 (__m128i a, int i, int immediate) - /// PINSRW xmm1, r/m16, imm8 - /// VPINSRW xmm1, xmm2, r/m16, imm8 + /// __m128i _mm_insert_epi16 (__m128i a, int i, int immediate) + /// PINSRW xmm1, r/m16, imm8 + /// VPINSRW xmm1, xmm2, r/m16, imm8 /// public static Vector128 Insert(Vector128 value, ushort data, [ConstantExpected] byte index) => Insert(value, data, index); /// - /// __m128i _mm_load_si128 (__m128i const* mem_address) - /// MOVDQA xmm1, m128 - /// VMOVDQA xmm1, m128 - /// VMOVDQA32 xmm1 {k1}{z}, m128 + /// __m128i _mm_load_si128 (__m128i const* mem_address) + /// MOVDQA xmm1, m128 + /// VMOVDQA xmm1, m128 + /// VMOVDQA32 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadAlignedVector128(sbyte* address) => LoadAlignedVector128(address); /// - /// __m128i _mm_load_si128 (__m128i const* mem_address) - /// MOVDQA xmm1, m128 - /// VMOVDQA xmm1, m128 - /// VMOVDQA32 xmm1 {k1}{z}, m128 + /// __m128i _mm_load_si128 (__m128i const* mem_address) + /// MOVDQA xmm1, m128 + /// VMOVDQA xmm1, m128 + /// VMOVDQA32 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadAlignedVector128(byte* address) => LoadAlignedVector128(address); /// - /// __m128i _mm_load_si128 (__m128i const* mem_address) - /// MOVDQA xmm1, m128 - /// VMOVDQA xmm1, m128 - /// VMOVDQA32 xmm1 {k1}{z}, m128 + /// __m128i _mm_load_si128 (__m128i const* mem_address) + /// MOVDQA xmm1, m128 + /// VMOVDQA xmm1, m128 + /// VMOVDQA32 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadAlignedVector128(short* address) => LoadAlignedVector128(address); /// - /// __m128i _mm_load_si128 (__m128i const* mem_address) - /// MOVDQA xmm1, m128 - /// VMOVDQA xmm1, m128 - /// VMOVDQA32 xmm1 {k1}{z}, m128 + /// __m128i _mm_load_si128 (__m128i const* mem_address) + /// MOVDQA xmm1, m128 + /// VMOVDQA xmm1, m128 + /// VMOVDQA32 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadAlignedVector128(ushort* address) => LoadAlignedVector128(address); /// - /// __m128i _mm_load_si128 (__m128i const* mem_address) - /// MOVDQA xmm1, m128 - /// VMOVDQA xmm1, m128 - /// VMOVDQA32 xmm1 {k1}{z}, m128 + /// __m128i _mm_load_si128 (__m128i const* mem_address) + /// MOVDQA xmm1, m128 + /// VMOVDQA xmm1, m128 + /// VMOVDQA32 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadAlignedVector128(int* address) => LoadAlignedVector128(address); /// - /// __m128i _mm_load_si128 (__m128i const* mem_address) - /// MOVDQA xmm1, m128 - /// VMOVDQA xmm1, m128 - /// VMOVDQA32 xmm1 {k1}{z}, m128 + /// __m128i _mm_load_si128 (__m128i const* mem_address) + /// MOVDQA xmm1, m128 + /// VMOVDQA xmm1, m128 + /// VMOVDQA32 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadAlignedVector128(uint* address) => LoadAlignedVector128(address); /// - /// __m128i _mm_load_si128 (__m128i const* mem_address) - /// MOVDQA xmm1, m128 - /// VMOVDQA xmm1, m128 - /// VMOVDQA64 xmm1 {k1}{z}, m128 + /// __m128i _mm_load_si128 (__m128i const* mem_address) + /// MOVDQA xmm1, m128 + /// VMOVDQA xmm1, m128 + /// VMOVDQA64 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadAlignedVector128(long* address) => LoadAlignedVector128(address); /// - /// __m128i _mm_load_si128 (__m128i const* mem_address) - /// MOVDQA xmm1, m128 - /// VMOVDQA xmm1, m128 - /// VMOVDQA64 xmm1 {k1}{z}, m128 + /// __m128i _mm_load_si128 (__m128i const* mem_address) + /// MOVDQA xmm1, m128 + /// VMOVDQA xmm1, m128 + /// VMOVDQA64 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadAlignedVector128(ulong* address) => LoadAlignedVector128(address); /// - /// __m128d _mm_load_pd (double const* mem_address) - /// MOVAPD xmm1, m128 - /// VMOVAPD xmm1, m128 - /// VMOVAPD xmm1 {k1}{z}, m128 + /// __m128d _mm_load_pd (double const* mem_address) + /// MOVAPD xmm1, m128 + /// VMOVAPD xmm1, m128 + /// VMOVAPD xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadAlignedVector128(double* address) => LoadAlignedVector128(address); /// - /// void _mm_lfence(void) - /// LFENCE + /// void _mm_lfence(void) + /// LFENCE /// public static void LoadFence() => LoadFence(); /// - /// __m128d _mm_loadh_pd (__m128d a, double const* mem_addr) - /// MOVHPD xmm1, m64 - /// VMOVHPD xmm1, xmm2, m64 + /// __m128d _mm_loadh_pd (__m128d a, double const* mem_addr) + /// MOVHPD xmm1, m64 + /// VMOVHPD xmm1, xmm2, m64 /// public static unsafe Vector128 LoadHigh(Vector128 lower, double* address) => LoadHigh(lower, address); /// - /// __m128d _mm_loadl_pd (__m128d a, double const* mem_addr) - /// MOVLPD xmm1, m64 - /// VMOVLPD xmm1, xmm2, m64 + /// __m128d _mm_loadl_pd (__m128d a, double const* mem_addr) + /// MOVLPD xmm1, m64 + /// VMOVLPD xmm1, xmm2, m64 /// public static unsafe Vector128 LoadLow(Vector128 upper, double* address) => LoadLow(upper, address); /// - /// __m128i _mm_loadu_si32 (void const* mem_addr) - /// MOVD xmm1, m32 - /// VMOVD xmm1, m32 + /// __m128i _mm_loadu_si32 (void const* mem_addr) + /// MOVD xmm1, m32 + /// VMOVD xmm1, m32 /// public static unsafe Vector128 LoadScalarVector128(int* address) => LoadScalarVector128(address); /// - /// __m128i _mm_loadu_si32 (void const* mem_addr) - /// MOVD xmm1, m32 - /// VMOVD xmm1, m32 + /// __m128i _mm_loadu_si32 (void const* mem_addr) + /// MOVD xmm1, m32 + /// VMOVD xmm1, m32 /// public static unsafe Vector128 LoadScalarVector128(uint* address) => LoadScalarVector128(address); /// - /// __m128i _mm_loadl_epi64 (__m128i const* mem_addr) - /// MOVQ xmm1, m64 - /// VMOVQ xmm1, m64 + /// __m128i _mm_loadl_epi64 (__m128i const* mem_addr) + /// MOVQ xmm1, m64 + /// VMOVQ xmm1, m64 /// public static unsafe Vector128 LoadScalarVector128(long* address) => LoadScalarVector128(address); /// - /// __m128i _mm_loadl_epi64 (__m128i const* mem_addr) - /// MOVQ xmm1, m64 - /// VMOVQ xmm1, m64 + /// __m128i _mm_loadl_epi64 (__m128i const* mem_addr) + /// MOVQ xmm1, m64 + /// VMOVQ xmm1, m64 /// public static unsafe Vector128 LoadScalarVector128(ulong* address) => LoadScalarVector128(address); /// - /// __m128d _mm_load_sd (double const* mem_address) - /// MOVSD xmm1, m64 - /// VMOVSD xmm1, m64 - /// VMOVSD xmm1 {k1}, m64 + /// __m128d _mm_load_sd (double const* mem_address) + /// MOVSD xmm1, m64 + /// VMOVSD xmm1, m64 + /// VMOVSD xmm1 {k1}, m64 /// public static unsafe Vector128 LoadScalarVector128(double* address) => LoadScalarVector128(address); /// - /// __m128i _mm_loadu_si128 (__m128i const* mem_address) - /// MOVDQU xmm1, m128 - /// VMOVDQU xmm1, m128 - /// VMOVDQU8 xmm1 {k1}{z}, m128 + /// __m128i _mm_loadu_si128 (__m128i const* mem_address) + /// MOVDQU xmm1, m128 + /// VMOVDQU xmm1, m128 + /// VMOVDQU8 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadVector128(sbyte* address) => LoadVector128(address); /// - /// __m128i _mm_loadu_si128 (__m128i const* mem_address) - /// MOVDQU xmm1, m128 - /// VMOVDQU xmm1, m128 - /// VMOVDQU8 xmm1 {k1}{z}, m128 + /// __m128i _mm_loadu_si128 (__m128i const* mem_address) + /// MOVDQU xmm1, m128 + /// VMOVDQU xmm1, m128 + /// VMOVDQU8 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadVector128(byte* address) => LoadVector128(address); /// - /// __m128i _mm_loadu_si128 (__m128i const* mem_address) - /// MOVDQU xmm1, m128 - /// VMOVDQU xmm1, m128 - /// VMOVDQU16 xmm1 {k1}{z}, m128 + /// __m128i _mm_loadu_si128 (__m128i const* mem_address) + /// MOVDQU xmm1, m128 + /// VMOVDQU xmm1, m128 + /// VMOVDQU16 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadVector128(short* address) => LoadVector128(address); /// - /// __m128i _mm_loadu_si128 (__m128i const* mem_address) - /// MOVDQU xmm1, m128 - /// VMOVDQU xmm1, m128 - /// VMOVDQU16 xmm1 {k1}{z}, m128 + /// __m128i _mm_loadu_si128 (__m128i const* mem_address) + /// MOVDQU xmm1, m128 + /// VMOVDQU xmm1, m128 + /// VMOVDQU16 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadVector128(ushort* address) => LoadVector128(address); /// - /// __m128i _mm_loadu_si128 (__m128i const* mem_address) - /// MOVDQU xmm1, m128 - /// VMOVDQU xmm1, m128 - /// VMOVDQU32 xmm1 {k1}{z}, m128 + /// __m128i _mm_loadu_si128 (__m128i const* mem_address) + /// MOVDQU xmm1, m128 + /// VMOVDQU xmm1, m128 + /// VMOVDQU32 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadVector128(int* address) => LoadVector128(address); /// - /// __m128i _mm_loadu_si128 (__m128i const* mem_address) - /// MOVDQU xmm1, m128 - /// VMOVDQU xmm1, m128 - /// VMOVDQU32 xmm1 {k1}{z}, m128 + /// __m128i _mm_loadu_si128 (__m128i const* mem_address) + /// MOVDQU xmm1, m128 + /// VMOVDQU xmm1, m128 + /// VMOVDQU32 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadVector128(uint* address) => LoadVector128(address); /// - /// __m128i _mm_loadu_si128 (__m128i const* mem_address) - /// MOVDQU xmm1, m128 - /// VMOVDQU xmm1, m128 - /// VMOVDQU64 xmm1 {k1}{z}, m128 + /// __m128i _mm_loadu_si128 (__m128i const* mem_address) + /// MOVDQU xmm1, m128 + /// VMOVDQU xmm1, m128 + /// VMOVDQU64 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadVector128(long* address) => LoadVector128(address); /// - /// __m128i _mm_loadu_si128 (__m128i const* mem_address) - /// MOVDQU xmm1, m128 - /// VMOVDQU xmm1, m128 - /// VMOVDQU64 xmm1 {k1}{z}, m128 + /// __m128i _mm_loadu_si128 (__m128i const* mem_address) + /// MOVDQU xmm1, m128 + /// VMOVDQU xmm1, m128 + /// VMOVDQU64 xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadVector128(ulong* address) => LoadVector128(address); /// - /// __m128d _mm_loadu_pd (double const* mem_address) - /// MOVUPD xmm1, m128 - /// VMOVUPD xmm1, m128 - /// VMOVUPD xmm1 {k1}{z}, m128 + /// __m128d _mm_loadu_pd (double const* mem_address) + /// MOVUPD xmm1, m128 + /// VMOVUPD xmm1, m128 + /// VMOVUPD xmm1 {k1}{z}, m128 /// public static unsafe Vector128 LoadVector128(double* address) => LoadVector128(address); /// - /// void _mm_maskmoveu_si128 (__m128i a, __m128i mask, char* mem_address) - /// MASKMOVDQU xmm1, xmm2 ; Address: EDI/RDI - /// VMASKMOVDQU xmm1, xmm2 ; Address: EDI/RDI + /// void _mm_maskmoveu_si128 (__m128i a, __m128i mask, char* mem_address) + /// MASKMOVDQU xmm1, xmm2 ; Address: EDI/RDI + /// VMASKMOVDQU xmm1, xmm2 ; Address: EDI/RDI /// public static unsafe void MaskMove(Vector128 source, Vector128 mask, sbyte* address) => MaskMove(source, mask, address); /// - /// void _mm_maskmoveu_si128 (__m128i a, __m128i mask, char* mem_address) - /// MASKMOVDQU xmm1, xmm2 ; Address: EDI/RDI - /// VMASKMOVDQU xmm1, xmm2 ; Address: EDI/RDI + /// void _mm_maskmoveu_si128 (__m128i a, __m128i mask, char* mem_address) + /// MASKMOVDQU xmm1, xmm2 ; Address: EDI/RDI + /// VMASKMOVDQU xmm1, xmm2 ; Address: EDI/RDI /// public static unsafe void MaskMove(Vector128 source, Vector128 mask, byte* address) => MaskMove(source, mask, address); /// - /// __m128i _mm_max_epu8 (__m128i a, __m128i b) - /// PMAXUB xmm1, xmm2/m128 - /// VPMAXUB xmm1, xmm2, xmm3/m128 - /// VPMAXUB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_max_epu8 (__m128i a, __m128i b) + /// PMAXUB xmm1, xmm2/m128 + /// VPMAXUB xmm1, xmm2, xmm3/m128 + /// VPMAXUB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// - /// __m128i _mm_max_epi16 (__m128i a, __m128i b) - /// PMAXSW xmm1, xmm2/m128 - /// VPMAXSW xmm1, xmm2, xmm3/m128 - /// VPMAXSW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_max_epi16 (__m128i a, __m128i b) + /// PMAXSW xmm1, xmm2/m128 + /// VPMAXSW xmm1, xmm2, xmm3/m128 + /// VPMAXSW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// - /// __m128d _mm_max_pd (__m128d a, __m128d b) - /// MAXPD xmm1, xmm2/m128 - /// VMAXPD xmm1, xmm2, xmm3/m128 - /// VMAXPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_max_pd (__m128d a, __m128d b) + /// MAXPD xmm1, xmm2/m128 + /// VMAXPD xmm1, xmm2, xmm3/m128 + /// VMAXPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// - /// __m128d _mm_max_sd (__m128d a, __m128d b) - /// MAXSD xmm1, xmm2/m64 - /// VMAXSD xmm1, xmm2, xmm3/m64 + /// __m128d _mm_max_sd (__m128d a, __m128d b) + /// MAXSD xmm1, xmm2/m64 + /// VMAXSD xmm1, xmm2, xmm3/m64 /// public static Vector128 MaxScalar(Vector128 left, Vector128 right) => MaxScalar(left, right); /// - /// void _mm_mfence(void) - /// MFENCE + /// void _mm_mfence(void) + /// MFENCE /// public static void MemoryFence() => MemoryFence(); /// - /// __m128i _mm_min_epu8 (__m128i a, __m128i b) - /// PMINUB xmm1, xmm2/m128 - /// VPMINUB xmm1, xmm2, xmm3/m128 - /// VPMINUB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_min_epu8 (__m128i a, __m128i b) + /// PMINUB xmm1, xmm2/m128 + /// VPMINUB xmm1, xmm2, xmm3/m128 + /// VPMINUB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// - /// __m128i _mm_min_epi16 (__m128i a, __m128i b) - /// PMINSW xmm1, xmm2/m128 - /// VPMINSW xmm1, xmm2, xmm3/m128 - /// VPMINSW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_min_epi16 (__m128i a, __m128i b) + /// PMINSW xmm1, xmm2/m128 + /// VPMINSW xmm1, xmm2, xmm3/m128 + /// VPMINSW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// - /// __m128d _mm_min_pd (__m128d a, __m128d b) - /// MINPD xmm1, xmm2/m128 - /// VMINPD xmm1, xmm2, xmm3/m128 - /// VMINPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_min_pd (__m128d a, __m128d b) + /// MINPD xmm1, xmm2/m128 + /// VMINPD xmm1, xmm2, xmm3/m128 + /// VMINPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// - /// __m128d _mm_min_sd (__m128d a, __m128d b) - /// MINSD xmm1, xmm2/m64 - /// VMINSD xmm1, xmm2, xmm3/m64 + /// __m128d _mm_min_sd (__m128d a, __m128d b) + /// MINSD xmm1, xmm2/m64 + /// VMINSD xmm1, xmm2, xmm3/m64 /// public static Vector128 MinScalar(Vector128 left, Vector128 right) => MinScalar(left, right); /// - /// int _mm_movemask_epi8 (__m128i a) - /// PMOVMSKB r32, xmm1 - /// VPMOVMSKB r32, xmm1 + /// int _mm_movemask_epi8 (__m128i a) + /// PMOVMSKB r32, xmm1 + /// VPMOVMSKB r32, xmm1 /// public static int MoveMask(Vector128 value) => MoveMask(value); /// - /// int _mm_movemask_epi8 (__m128i a) - /// PMOVMSKB r32, xmm1 - /// VPMOVMSKB r32, xmm1 + /// int _mm_movemask_epi8 (__m128i a) + /// PMOVMSKB r32, xmm1 + /// VPMOVMSKB r32, xmm1 /// public static int MoveMask(Vector128 value) => MoveMask(value); /// - /// int _mm_movemask_pd (__m128d a) - /// MOVMSKPD r32, xmm1 - /// VMOVMSKPD r32, xmm1 + /// int _mm_movemask_pd (__m128d a) + /// MOVMSKPD r32, xmm1 + /// VMOVMSKPD r32, xmm1 /// public static int MoveMask(Vector128 value) => MoveMask(value); /// - /// __m128i _mm_move_epi64 (__m128i a) - /// MOVQ xmm1, xmm2 - /// VMOVQ xmm1, xmm2 + /// __m128i _mm_move_epi64 (__m128i a) + /// MOVQ xmm1, xmm2 + /// VMOVQ xmm1, xmm2 /// public static Vector128 MoveScalar(Vector128 value) => MoveScalar(value); /// - /// __m128i _mm_move_epi64 (__m128i a) - /// MOVQ xmm1, xmm2 - /// VMOVQ xmm1, xmm2 + /// __m128i _mm_move_epi64 (__m128i a) + /// MOVQ xmm1, xmm2 + /// VMOVQ xmm1, xmm2 /// public static Vector128 MoveScalar(Vector128 value) => MoveScalar(value); /// - /// __m128d _mm_move_sd (__m128d a, __m128d b) - /// MOVSD xmm1, xmm2 - /// VMOVSD xmm1, xmm2, xmm3 - /// VMOVSD xmm1 {k1}{z}, xmm2, xmm3 + /// __m128d _mm_move_sd (__m128d a, __m128d b) + /// MOVSD xmm1, xmm2 + /// VMOVSD xmm1, xmm2, xmm3 + /// VMOVSD xmm1 {k1}{z}, xmm2, xmm3 /// public static Vector128 MoveScalar(Vector128 upper, Vector128 value) => MoveScalar(upper, value); /// - /// __m128i _mm_mul_epu32 (__m128i a, __m128i b) - /// PMULUDQ xmm1, xmm2/m128 - /// VPMULUDQ xmm1, xmm2, xmm3/m128 - /// VPMULUDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_mul_epu32 (__m128i a, __m128i b) + /// PMULUDQ xmm1, xmm2/m128 + /// VPMULUDQ xmm1, xmm2, xmm3/m128 + /// VPMULUDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); /// - /// __m128d _mm_mul_pd (__m128d a, __m128d b) - /// MULPD xmm1, xmm2/m128 - /// VMULPD xmm1, xmm2, xmm3/m128 - /// VMULPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_mul_pd (__m128d a, __m128d b) + /// MULPD xmm1, xmm2/m128 + /// VMULPD xmm1, xmm2, xmm3/m128 + /// VMULPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); /// - /// __m128i _mm_madd_epi16 (__m128i a, __m128i b) - /// PMADDWD xmm1, xmm2/m128 - /// VPMADDWD xmm1, xmm2, xmm3/m128 - /// VPMADDWD xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_madd_epi16 (__m128i a, __m128i b) + /// PMADDWD xmm1, xmm2/m128 + /// VPMADDWD xmm1, xmm2, xmm3/m128 + /// VPMADDWD xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 MultiplyAddAdjacent(Vector128 left, Vector128 right) => MultiplyAddAdjacent(left, right); /// - /// __m128i _mm_mulhi_epi16 (__m128i a, __m128i b) - /// PMULHW xmm1, xmm2/m128 - /// VPMULHW xmm1, xmm2, xmm3/m128 - /// VPMULHW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_mulhi_epi16 (__m128i a, __m128i b) + /// PMULHW xmm1, xmm2/m128 + /// VPMULHW xmm1, xmm2, xmm3/m128 + /// VPMULHW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 MultiplyHigh(Vector128 left, Vector128 right) => MultiplyHigh(left, right); /// - /// __m128i _mm_mulhi_epu16 (__m128i a, __m128i b) - /// PMULHUW xmm1, xmm2/m128 - /// VPMULHUW xmm1, xmm2, xmm3/m128 - /// VPMULHUW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_mulhi_epu16 (__m128i a, __m128i b) + /// PMULHUW xmm1, xmm2/m128 + /// VPMULHUW xmm1, xmm2, xmm3/m128 + /// VPMULHUW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 MultiplyHigh(Vector128 left, Vector128 right) => MultiplyHigh(left, right); /// - /// __m128i _mm_mullo_epi16 (__m128i a, __m128i b) - /// PMULLW xmm1, xmm2/m128 - /// VPMULLW xmm1, xmm2, xmm3/m128 - /// VPMULLW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_mullo_epi16 (__m128i a, __m128i b) + /// PMULLW xmm1, xmm2/m128 + /// VPMULLW xmm1, xmm2, xmm3/m128 + /// VPMULLW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 MultiplyLow(Vector128 left, Vector128 right) => MultiplyLow(left, right); /// - /// __m128i _mm_mullo_epi16 (__m128i a, __m128i b) - /// PMULLW xmm1, xmm2/m128 - /// VPMULLW xmm1, xmm2, xmm3/m128 - /// VPMULLW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_mullo_epi16 (__m128i a, __m128i b) + /// PMULLW xmm1, xmm2/m128 + /// VPMULLW xmm1, xmm2, xmm3/m128 + /// VPMULLW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 MultiplyLow(Vector128 left, Vector128 right) => MultiplyLow(left, right); /// - /// __m128d _mm_mul_sd (__m128d a, __m128d b) - /// MULSD xmm1, xmm2/m64 - /// VMULSD xmm1, xmm2, xmm3/m64 + /// __m128d _mm_mul_sd (__m128d a, __m128d b) + /// MULSD xmm1, xmm2/m64 + /// VMULSD xmm1, xmm2, xmm3/m64 /// public static Vector128 MultiplyScalar(Vector128 left, Vector128 right) => MultiplyScalar(left, right); /// - /// __m128i _mm_or_si128 (__m128i a, __m128i b) - /// POR xmm1, xmm2/m128 - /// VPOR xmm1, xmm2, xmm3/m128 + /// __m128i _mm_or_si128 (__m128i a, __m128i b) + /// POR xmm1, xmm2/m128 + /// VPOR xmm1, xmm2, xmm3/m128 /// public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// - /// __m128i _mm_or_si128 (__m128i a, __m128i b) - /// POR xmm1, xmm2/m128 - /// VPOR xmm1, xmm2, xmm3/m128 + /// __m128i _mm_or_si128 (__m128i a, __m128i b) + /// POR xmm1, xmm2/m128 + /// VPOR xmm1, xmm2, xmm3/m128 /// public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// - /// __m128i _mm_or_si128 (__m128i a, __m128i b) - /// POR xmm1, xmm2/m128 - /// VPOR xmm1, xmm2, xmm3/m128 + /// __m128i _mm_or_si128 (__m128i a, __m128i b) + /// POR xmm1, xmm2/m128 + /// VPOR xmm1, xmm2, xmm3/m128 /// public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// - /// __m128i _mm_or_si128 (__m128i a, __m128i b) - /// POR xmm1, xmm2/m128 - /// VPOR xmm1, xmm2, xmm3/m128 + /// __m128i _mm_or_si128 (__m128i a, __m128i b) + /// POR xmm1, xmm2/m128 + /// VPOR xmm1, xmm2, xmm3/m128 /// public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// - /// __m128i _mm_or_si128 (__m128i a, __m128i b) - /// POR xmm1, xmm2/m128 - /// VPOR xmm1, xmm2, xmm3/m128 - /// VPORD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_or_si128 (__m128i a, __m128i b) + /// POR xmm1, xmm2/m128 + /// VPOR xmm1, xmm2, xmm3/m128 + /// VPORD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// - /// __m128i _mm_or_si128 (__m128i a, __m128i b) - /// POR xmm1, xmm2/m128 - /// VPOR xmm1, xmm2, xmm3/m128 - /// VPORD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_or_si128 (__m128i a, __m128i b) + /// POR xmm1, xmm2/m128 + /// VPOR xmm1, xmm2, xmm3/m128 + /// VPORD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// - /// __m128i _mm_or_si128 (__m128i a, __m128i b) - /// POR xmm1, xmm2/m128 - /// VPOR xmm1, xmm2, xmm3/m128 - /// VPORQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_or_si128 (__m128i a, __m128i b) + /// POR xmm1, xmm2/m128 + /// VPOR xmm1, xmm2, xmm3/m128 + /// VPORQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// - /// __m128i _mm_or_si128 (__m128i a, __m128i b) - /// POR xmm1, xmm2/m128 - /// VPOR xmm1, xmm2, xmm3/m128 - /// VPORQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_or_si128 (__m128i a, __m128i b) + /// POR xmm1, xmm2/m128 + /// VPOR xmm1, xmm2, xmm3/m128 + /// VPORQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// - /// __m128d _mm_or_pd (__m128d a, __m128d b) - /// ORPD xmm1, xmm2/m128 - /// VORPD xmm1, xmm2, xmm3/m128 - /// VORPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_or_pd (__m128d a, __m128d b) + /// ORPD xmm1, xmm2/m128 + /// VORPD xmm1, xmm2, xmm3/m128 + /// VORPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Or(Vector128 left, Vector128 right) => Or(left, right); /// - /// __m128i _mm_packs_epi16 (__m128i a, __m128i b) - /// PACKSSWB xmm1, xmm2/m128 - /// VPACKSSWB xmm1, xmm2, xmm3/m128 - /// VPACKSSWB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_packs_epi16 (__m128i a, __m128i b) + /// PACKSSWB xmm1, xmm2/m128 + /// VPACKSSWB xmm1, xmm2, xmm3/m128 + /// VPACKSSWB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PackSignedSaturate(Vector128 left, Vector128 right) => PackSignedSaturate(left, right); /// - /// __m128i _mm_packs_epi32 (__m128i a, __m128i b) - /// PACKSSDW xmm1, xmm2/m128 - /// VPACKSSDW xmm1, xmm2, xmm3/m128 - /// VPACKSSDW xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_packs_epi32 (__m128i a, __m128i b) + /// PACKSSDW xmm1, xmm2/m128 + /// VPACKSSDW xmm1, xmm2, xmm3/m128 + /// VPACKSSDW xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 PackSignedSaturate(Vector128 left, Vector128 right) => PackSignedSaturate(left, right); /// - /// __m128i _mm_packus_epi16 (__m128i a, __m128i b) - /// PACKUSWB xmm1, xmm2/m128 - /// VPACKUSWB xmm1, xmm2, xmm3/m128 - /// VPACKUSWB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_packus_epi16 (__m128i a, __m128i b) + /// PACKUSWB xmm1, xmm2/m128 + /// VPACKUSWB xmm1, xmm2, xmm3/m128 + /// VPACKUSWB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 PackUnsignedSaturate(Vector128 left, Vector128 right) => PackUnsignedSaturate(left, right); /// - /// __m128i _mm_sll_epi16 (__m128i a, __m128i count) - /// PSLLW xmm1, xmm2/m128 - /// VPSLLW xmm1, xmm2, xmm3/m128 - /// VPSLLW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sll_epi16 (__m128i a, __m128i count) + /// PSLLW xmm1, xmm2/m128 + /// VPSLLW xmm1, xmm2, xmm3/m128 + /// VPSLLW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftLeftLogical(Vector128 value, Vector128 count) => ShiftLeftLogical(value, count); /// - /// __m128i _mm_sll_epi16 (__m128i a, __m128i count) - /// PSLLW xmm1, xmm2/m128 - /// VPSLLW xmm1, xmm2, xmm3/m128 - /// VPSLLW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sll_epi16 (__m128i a, __m128i count) + /// PSLLW xmm1, xmm2/m128 + /// VPSLLW xmm1, xmm2, xmm3/m128 + /// VPSLLW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftLeftLogical(Vector128 value, Vector128 count) => ShiftLeftLogical(value, count); /// - /// __m128i _mm_sll_epi32 (__m128i a, __m128i count) - /// PSLLD xmm1, xmm2/m128 - /// VPSLLD xmm1, xmm2, xmm3/m128 - /// VPSLLD xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sll_epi32 (__m128i a, __m128i count) + /// PSLLD xmm1, xmm2/m128 + /// VPSLLD xmm1, xmm2, xmm3/m128 + /// VPSLLD xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftLeftLogical(Vector128 value, Vector128 count) => ShiftLeftLogical(value, count); /// - /// __m128i _mm_sll_epi32 (__m128i a, __m128i count) - /// PSLLD xmm1, xmm2/m128 - /// VPSLLD xmm1, xmm2, xmm3/m128 - /// VPSLLD xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sll_epi32 (__m128i a, __m128i count) + /// PSLLD xmm1, xmm2/m128 + /// VPSLLD xmm1, xmm2, xmm3/m128 + /// VPSLLD xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftLeftLogical(Vector128 value, Vector128 count) => ShiftLeftLogical(value, count); /// - /// __m128i _mm_sll_epi64 (__m128i a, __m128i count) - /// PSLLQ xmm1, xmm2/m128 - /// VPSLLQ xmm1, xmm2, xmm3/m128 - /// VPSLLQ xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sll_epi64 (__m128i a, __m128i count) + /// PSLLQ xmm1, xmm2/m128 + /// VPSLLQ xmm1, xmm2, xmm3/m128 + /// VPSLLQ xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftLeftLogical(Vector128 value, Vector128 count) => ShiftLeftLogical(value, count); /// - /// __m128i _mm_sll_epi64 (__m128i a, __m128i count) - /// PSLLQ xmm1, xmm2/m128 - /// VPSLLQ xmm1, xmm2, xmm3/m128 - /// VPSLLQ xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sll_epi64 (__m128i a, __m128i count) + /// PSLLQ xmm1, xmm2/m128 + /// VPSLLQ xmm1, xmm2, xmm3/m128 + /// VPSLLQ xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftLeftLogical(Vector128 value, Vector128 count) => ShiftLeftLogical(value, count); /// - /// __m128i _mm_slli_epi16 (__m128i a, int immediate) - /// PSLLW xmm1, imm8 - /// VPSLLW xmm1, xmm2, imm8 - /// VPSLLW xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_slli_epi16 (__m128i a, int immediate) + /// PSLLW xmm1, imm8 + /// VPSLLW xmm1, xmm2, imm8 + /// VPSLLW xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); /// - /// __m128i _mm_slli_epi16 (__m128i a, int immediate) - /// PSLLW xmm1, imm8 - /// VPSLLW xmm1, xmm2, imm8 - /// VPSLLW xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_slli_epi16 (__m128i a, int immediate) + /// PSLLW xmm1, imm8 + /// VPSLLW xmm1, xmm2, imm8 + /// VPSLLW xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); /// - /// __m128i _mm_slli_epi32 (__m128i a, int immediate) - /// PSLLD xmm1, imm8 - /// VPSLLD xmm1, xmm2, imm8 - /// VPSLLD xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_slli_epi32 (__m128i a, int immediate) + /// PSLLD xmm1, imm8 + /// VPSLLD xmm1, xmm2, imm8 + /// VPSLLD xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); /// - /// __m128i _mm_slli_epi32 (__m128i a, int immediate) - /// PSLLD xmm1, imm8 - /// VPSLLD xmm1, xmm2, imm8 - /// VPSLLD xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_slli_epi32 (__m128i a, int immediate) + /// PSLLD xmm1, imm8 + /// VPSLLD xmm1, xmm2, imm8 + /// VPSLLD xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); /// - /// __m128i _mm_slli_epi64 (__m128i a, int immediate) - /// PSLLQ xmm1, imm8 - /// VPSLLQ xmm1, xmm2, imm8 - /// VPSLLQ xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_slli_epi64 (__m128i a, int immediate) + /// PSLLQ xmm1, imm8 + /// VPSLLQ xmm1, xmm2, imm8 + /// VPSLLQ xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); /// - /// __m128i _mm_slli_epi64 (__m128i a, int immediate) - /// PSLLQ xmm1, imm8 - /// VPSLLQ xmm1, xmm2, imm8 - /// VPSLLQ xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_slli_epi64 (__m128i a, int immediate) + /// PSLLQ xmm1, imm8 + /// VPSLLQ xmm1, xmm2, imm8 + /// VPSLLQ xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftLeftLogical(Vector128 value, [ConstantExpected] byte count) => ShiftLeftLogical(value, count); /// - /// __m128i _mm_bslli_si128 (__m128i a, int imm8) - /// PSLLDQ xmm1, imm8 - /// VPSLLDQ xmm1, xmm2/m128, imm8 + /// __m128i _mm_bslli_si128 (__m128i a, int imm8) + /// PSLLDQ xmm1, imm8 + /// VPSLLDQ xmm1, xmm2/m128, imm8 /// public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// - /// __m128i _mm_bslli_si128 (__m128i a, int imm8) - /// PSLLDQ xmm1, imm8 - /// VPSLLDQ xmm1, xmm2/m128, imm8 + /// __m128i _mm_bslli_si128 (__m128i a, int imm8) + /// PSLLDQ xmm1, imm8 + /// VPSLLDQ xmm1, xmm2/m128, imm8 /// public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// - /// __m128i _mm_bslli_si128 (__m128i a, int imm8) - /// PSLLDQ xmm1, imm8 - /// VPSLLDQ xmm1, xmm2/m128, imm8 - /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. + /// __m128i _mm_bslli_si128 (__m128i a, int imm8) + /// PSLLDQ xmm1, imm8 + /// VPSLLDQ xmm1, xmm2/m128, imm8 + /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. /// public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// - /// __m128i _mm_bslli_si128 (__m128i a, int imm8) - /// PSLLDQ xmm1, imm8 - /// VPSLLDQ xmm1, xmm2/m128, imm8 - /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. + /// __m128i _mm_bslli_si128 (__m128i a, int imm8) + /// PSLLDQ xmm1, imm8 + /// VPSLLDQ xmm1, xmm2/m128, imm8 + /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. /// public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// - /// __m128i _mm_bslli_si128 (__m128i a, int imm8) - /// PSLLDQ xmm1, imm8 - /// VPSLLDQ xmm1, xmm2/m128, imm8 - /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. + /// __m128i _mm_bslli_si128 (__m128i a, int imm8) + /// PSLLDQ xmm1, imm8 + /// VPSLLDQ xmm1, xmm2/m128, imm8 + /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. /// public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// - /// __m128i _mm_bslli_si128 (__m128i a, int imm8) - /// PSLLDQ xmm1, imm8 - /// VPSLLDQ xmm1, xmm2/m128, imm8 - /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. + /// __m128i _mm_bslli_si128 (__m128i a, int imm8) + /// PSLLDQ xmm1, imm8 + /// VPSLLDQ xmm1, xmm2/m128, imm8 + /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. /// public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// - /// __m128i _mm_bslli_si128 (__m128i a, int imm8) - /// PSLLDQ xmm1, imm8 - /// VPSLLDQ xmm1, xmm2/m128, imm8 - /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. + /// __m128i _mm_bslli_si128 (__m128i a, int imm8) + /// PSLLDQ xmm1, imm8 + /// VPSLLDQ xmm1, xmm2/m128, imm8 + /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. /// public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// - /// __m128i _mm_bslli_si128 (__m128i a, int imm8) - /// PSLLDQ xmm1, imm8 - /// VPSLLDQ xmm1, xmm2/m128, imm8 - /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. + /// __m128i _mm_bslli_si128 (__m128i a, int imm8) + /// PSLLDQ xmm1, imm8 + /// VPSLLDQ xmm1, xmm2/m128, imm8 + /// This intrinsic generates PSLLDQ that operates over bytes rather than elements of the vectors. /// public static Vector128 ShiftLeftLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) => ShiftLeftLogical128BitLane(value, numBytes); /// - /// __m128i _mm_sra_epi16 (__m128i a, __m128i count) - /// PSRAW xmm1, xmm2/m128 - /// VPSRAW xmm1, xmm2, xmm3/m128 - /// VPSRAW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sra_epi16 (__m128i a, __m128i count) + /// PSRAW xmm1, xmm2/m128 + /// VPSRAW xmm1, xmm2, xmm3/m128 + /// VPSRAW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightArithmetic(Vector128 value, Vector128 count) => ShiftRightArithmetic(value, count); /// - /// __m128i _mm_sra_epi32 (__m128i a, __m128i count) - /// PSRAD xmm1, xmm2/m128 - /// VPSRAD xmm1, xmm2, xmm3/m128 - /// VPSRAD xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sra_epi32 (__m128i a, __m128i count) + /// PSRAD xmm1, xmm2/m128 + /// VPSRAD xmm1, xmm2, xmm3/m128 + /// VPSRAD xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightArithmetic(Vector128 value, Vector128 count) => ShiftRightArithmetic(value, count); /// - /// __m128i _mm_srai_epi16 (__m128i a, int immediate) - /// PSRAW xmm1, imm8 - /// VPSRAW xmm1, xmm2, imm8 - /// VPSRAW xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_srai_epi16 (__m128i a, int immediate) + /// PSRAW xmm1, imm8 + /// VPSRAW xmm1, xmm2, imm8 + /// VPSRAW xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftRightArithmetic(Vector128 value, [ConstantExpected] byte count) => ShiftRightArithmetic(value, count); /// - /// __m128i _mm_srai_epi32 (__m128i a, int immediate) - /// PSRAD xmm1, imm8 - /// VPSRAD xmm1, xmm2, imm8 - /// VPSRAD xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_srai_epi32 (__m128i a, int immediate) + /// PSRAD xmm1, imm8 + /// VPSRAD xmm1, xmm2, imm8 + /// VPSRAD xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftRightArithmetic(Vector128 value, [ConstantExpected] byte count) => ShiftRightArithmetic(value, count); /// - /// __m128i _mm_srl_epi16 (__m128i a, __m128i count) - /// PSRLW xmm1, xmm2/m128 - /// VPSRLW xmm1, xmm2, xmm3/m128 - /// VPSRLW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_srl_epi16 (__m128i a, __m128i count) + /// PSRLW xmm1, xmm2/m128 + /// VPSRLW xmm1, xmm2, xmm3/m128 + /// VPSRLW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightLogical(Vector128 value, Vector128 count) => ShiftRightLogical(value, count); /// - /// __m128i _mm_srl_epi16 (__m128i a, __m128i count) - /// PSRLW xmm1, xmm2/m128 - /// VPSRLW xmm1, xmm2, xmm3/m128 - /// VPSRLW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_srl_epi16 (__m128i a, __m128i count) + /// PSRLW xmm1, xmm2/m128 + /// VPSRLW xmm1, xmm2, xmm3/m128 + /// VPSRLW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightLogical(Vector128 value, Vector128 count) => ShiftRightLogical(value, count); /// - /// __m128i _mm_srl_epi32 (__m128i a, __m128i count) - /// PSRLD xmm1, xmm2/m128 - /// VPSRLD xmm1, xmm2, xmm3/m128 - /// VPSRLD xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_srl_epi32 (__m128i a, __m128i count) + /// PSRLD xmm1, xmm2/m128 + /// VPSRLD xmm1, xmm2, xmm3/m128 + /// VPSRLD xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightLogical(Vector128 value, Vector128 count) => ShiftRightLogical(value, count); /// - /// __m128i _mm_srl_epi32 (__m128i a, __m128i count) - /// PSRLD xmm1, xmm2/m128 - /// VPSRLD xmm1, xmm2, xmm3/m128 - /// VPSRLD xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_srl_epi32 (__m128i a, __m128i count) + /// PSRLD xmm1, xmm2/m128 + /// VPSRLD xmm1, xmm2, xmm3/m128 + /// VPSRLD xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightLogical(Vector128 value, Vector128 count) => ShiftRightLogical(value, count); /// - /// __m128i _mm_srl_epi64 (__m128i a, __m128i count) - /// PSRLQ xmm1, xmm2/m128 - /// VPSRLQ xmm1, xmm2, xmm3/m128 - /// VPSRLQ xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_srl_epi64 (__m128i a, __m128i count) + /// PSRLQ xmm1, xmm2/m128 + /// VPSRLQ xmm1, xmm2, xmm3/m128 + /// VPSRLQ xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightLogical(Vector128 value, Vector128 count) => ShiftRightLogical(value, count); /// - /// __m128i _mm_srl_epi64 (__m128i a, __m128i count) - /// PSRLQ xmm1, xmm2/m128 - /// VPSRLQ xmm1, xmm2, xmm3/m128 - /// VPSRLQ xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_srl_epi64 (__m128i a, __m128i count) + /// PSRLQ xmm1, xmm2/m128 + /// VPSRLQ xmm1, xmm2, xmm3/m128 + /// VPSRLQ xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 ShiftRightLogical(Vector128 value, Vector128 count) => ShiftRightLogical(value, count); /// - /// __m128i _mm_srli_epi16 (__m128i a, int immediate) - /// PSRLW xmm1, imm8 - /// VPSRLW xmm1, xmm2, imm8 - /// VPSRLW xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_srli_epi16 (__m128i a, int immediate) + /// PSRLW xmm1, imm8 + /// VPSRLW xmm1, xmm2, imm8 + /// VPSRLW xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); /// - /// __m128i _mm_srli_epi16 (__m128i a, int immediate) - /// PSRLW xmm1, imm8 - /// VPSRLW xmm1, xmm2, imm8 - /// VPSRLW xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_srli_epi16 (__m128i a, int immediate) + /// PSRLW xmm1, imm8 + /// VPSRLW xmm1, xmm2, imm8 + /// VPSRLW xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); /// - /// __m128i _mm_srli_epi32 (__m128i a, int immediate) - /// PSRLD xmm1, imm8 - /// VPSRLD xmm1, xmm2, imm8 - /// VPSRLD xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_srli_epi32 (__m128i a, int immediate) + /// PSRLD xmm1, imm8 + /// VPSRLD xmm1, xmm2, imm8 + /// VPSRLD xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); /// - /// __m128i _mm_srli_epi32 (__m128i a, int immediate) - /// PSRLD xmm1, imm8 - /// VPSRLD xmm1, xmm2, imm8 - /// VPSRLD xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_srli_epi32 (__m128i a, int immediate) + /// PSRLD xmm1, imm8 + /// VPSRLD xmm1, xmm2, imm8 + /// VPSRLD xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); /// - /// __m128i _mm_srli_epi64 (__m128i a, int immediate) - /// PSRLQ xmm1, imm8 - /// VPSRLQ xmm1, xmm2, imm8 - /// VPSRLQ xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_srli_epi64 (__m128i a, int immediate) + /// PSRLQ xmm1, imm8 + /// VPSRLQ xmm1, xmm2, imm8 + /// VPSRLQ xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); /// - /// __m128i _mm_srli_epi64 (__m128i a, int immediate) - /// PSRLQ xmm1, imm8 - /// VPSRLQ xmm1, xmm2, imm8 - /// VPSRLQ xmm1 {k1}{z}, xmm2, imm8 + /// __m128i _mm_srli_epi64 (__m128i a, int immediate) + /// PSRLQ xmm1, imm8 + /// VPSRLQ xmm1, xmm2, imm8 + /// VPSRLQ xmm1 {k1}{z}, xmm2, imm8 /// public static Vector128 ShiftRightLogical(Vector128 value, [ConstantExpected] byte count) => ShiftRightLogical(value, count); /// - /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) - /// PSRLDQ xmm1, imm8 - /// VPSRLDQ xmm1, xmm2/m128, imm8 + /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) + /// PSRLDQ xmm1, imm8 + /// VPSRLDQ xmm1, xmm2/m128, imm8 /// public static Vector128 ShiftRightLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// - /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) - /// PSRLDQ xmm1, imm8 - /// VPSRLDQ xmm1, xmm2/m128, imm8 + /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) + /// PSRLDQ xmm1, imm8 + /// VPSRLDQ xmm1, xmm2/m128, imm8 /// public static Vector128 ShiftRightLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// - /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) - /// PSRLDQ xmm1, imm8 - /// VPSRLDQ xmm1, xmm2/m128, imm8 - /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. + /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) + /// PSRLDQ xmm1, imm8 + /// VPSRLDQ xmm1, xmm2/m128, imm8 + /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. /// public static Vector128 ShiftRightLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// - /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) - /// PSRLDQ xmm1, imm8 - /// VPSRLDQ xmm1, xmm2/m128, imm8 - /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. + /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) + /// PSRLDQ xmm1, imm8 + /// VPSRLDQ xmm1, xmm2/m128, imm8 + /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. /// public static Vector128 ShiftRightLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// - /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) - /// PSRLDQ xmm1, imm8 - /// VPSRLDQ xmm1, xmm2/m128, imm8 - /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. + /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) + /// PSRLDQ xmm1, imm8 + /// VPSRLDQ xmm1, xmm2/m128, imm8 + /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. /// public static Vector128 ShiftRightLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// - /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) - /// PSRLDQ xmm1, imm8 - /// VPSRLDQ xmm1, xmm2/m128, imm8 - /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. + /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) + /// PSRLDQ xmm1, imm8 + /// VPSRLDQ xmm1, xmm2/m128, imm8 + /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. /// public static Vector128 ShiftRightLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// - /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) - /// PSRLDQ xmm1, imm8 - /// VPSRLDQ xmm1, xmm2/m128, imm8 - /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. + /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) + /// PSRLDQ xmm1, imm8 + /// VPSRLDQ xmm1, xmm2/m128, imm8 + /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. /// public static Vector128 ShiftRightLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// - /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) - /// PSRLDQ xmm1, imm8 - /// VPSRLDQ xmm1, xmm2/m128, imm8 - /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. + /// __m128i _mm_bsrli_si128 (__m128i a, int imm8) + /// PSRLDQ xmm1, imm8 + /// VPSRLDQ xmm1, xmm2/m128, imm8 + /// This intrinsic generates PSRLDQ that operates over bytes rather than elements of the vectors. /// public static Vector128 ShiftRightLogical128BitLane(Vector128 value, [ConstantExpected] byte numBytes) => ShiftRightLogical128BitLane(value, numBytes); /// - /// __m128i _mm_shuffle_epi32 (__m128i a, int immediate) - /// PSHUFD xmm1, xmm2/m128, imm8 - /// VPSHUFD xmm1, xmm2/m128, imm8 - /// VPSHUFD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128i _mm_shuffle_epi32 (__m128i a, int immediate) + /// PSHUFD xmm1, xmm2/m128, imm8 + /// VPSHUFD xmm1, xmm2/m128, imm8 + /// VPSHUFD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 Shuffle(Vector128 value, [ConstantExpected] byte control) => Shuffle(value, control); /// - /// __m128i _mm_shuffle_epi32 (__m128i a, int immediate) - /// PSHUFD xmm1, xmm2/m128, imm8 - /// VPSHUFD xmm1, xmm2/m128, imm8 - /// VPSHUFD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 + /// __m128i _mm_shuffle_epi32 (__m128i a, int immediate) + /// PSHUFD xmm1, xmm2/m128, imm8 + /// VPSHUFD xmm1, xmm2/m128, imm8 + /// VPSHUFD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8 /// public static Vector128 Shuffle(Vector128 value, [ConstantExpected] byte control) => Shuffle(value, control); /// - /// __m128d _mm_shuffle_pd (__m128d a, __m128d b, int immediate) - /// SHUFPD xmm1, xmm2/m128, imm8 - /// VSHUFPD xmm1, xmm2, xmm3/m128, imm8 - /// VSHUFPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 + /// __m128d _mm_shuffle_pd (__m128d a, __m128d b, int immediate) + /// SHUFPD xmm1, xmm2/m128, imm8 + /// VSHUFPD xmm1, xmm2, xmm3/m128, imm8 + /// VSHUFPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst, imm8 /// public static Vector128 Shuffle(Vector128 left, Vector128 right, [ConstantExpected] byte control) => Shuffle(left, right, control); /// - /// __m128i _mm_shufflehi_epi16 (__m128i a, int immediate) - /// PSHUFHW xmm1, xmm2/m128, imm8 - /// VPSHUFHW xmm1, xmm2/m128, imm8 - /// VPSHUFHW xmm1 {k1}{z}, xmm2/m128, imm8 + /// __m128i _mm_shufflehi_epi16 (__m128i a, int immediate) + /// PSHUFHW xmm1, xmm2/m128, imm8 + /// VPSHUFHW xmm1, xmm2/m128, imm8 + /// VPSHUFHW xmm1 {k1}{z}, xmm2/m128, imm8 /// public static Vector128 ShuffleHigh(Vector128 value, [ConstantExpected] byte control) => ShuffleHigh(value, control); /// - /// __m128i _mm_shufflehi_epi16 (__m128i a, int control) - /// PSHUFHW xmm1, xmm2/m128, imm8 - /// VPSHUFHW xmm1, xmm2/m128, imm8 - /// VPSHUFHW xmm1 {k1}{z}, xmm2/m128, imm8 + /// __m128i _mm_shufflehi_epi16 (__m128i a, int control) + /// PSHUFHW xmm1, xmm2/m128, imm8 + /// VPSHUFHW xmm1, xmm2/m128, imm8 + /// VPSHUFHW xmm1 {k1}{z}, xmm2/m128, imm8 /// public static Vector128 ShuffleHigh(Vector128 value, [ConstantExpected] byte control) => ShuffleHigh(value, control); /// - /// __m128i _mm_shufflelo_epi16 (__m128i a, int control) - /// PSHUFLW xmm1, xmm2/m128, imm8 - /// VPSHUFLW xmm1, xmm2/m128, imm8 - /// VPSHUFLW xmm1 {k1}{z}, xmm2/m128, imm8 + /// __m128i _mm_shufflelo_epi16 (__m128i a, int control) + /// PSHUFLW xmm1, xmm2/m128, imm8 + /// VPSHUFLW xmm1, xmm2/m128, imm8 + /// VPSHUFLW xmm1 {k1}{z}, xmm2/m128, imm8 /// public static Vector128 ShuffleLow(Vector128 value, [ConstantExpected] byte control) => ShuffleLow(value, control); /// - /// __m128i _mm_shufflelo_epi16 (__m128i a, int control) - /// PSHUFLW xmm1, xmm2/m128, imm8 - /// VPSHUFLW xmm1, xmm2/m128, imm8 - /// VPSHUFLW xmm1 {k1}{z}, xmm2/m128, imm8 + /// __m128i _mm_shufflelo_epi16 (__m128i a, int control) + /// PSHUFLW xmm1, xmm2/m128, imm8 + /// VPSHUFLW xmm1, xmm2/m128, imm8 + /// VPSHUFLW xmm1 {k1}{z}, xmm2/m128, imm8 /// public static Vector128 ShuffleLow(Vector128 value, [ConstantExpected] byte control) => ShuffleLow(value, control); /// - /// __m128d _mm_sqrt_pd (__m128d a) - /// SQRTPD xmm1, xmm2/m128 - /// VSQRTPD xmm1, xmm2/m128 - /// VSQRTPD xmm1 {k1}{z}, xmm2/m128/m64bcst + /// __m128d _mm_sqrt_pd (__m128d a) + /// SQRTPD xmm1, xmm2/m128 + /// VSQRTPD xmm1, xmm2/m128 + /// VSQRTPD xmm1 {k1}{z}, xmm2/m128/m64bcst /// public static Vector128 Sqrt(Vector128 value) => Sqrt(value); /// - /// __m128d _mm_sqrt_sd (__m128d a) - /// SQRTSD xmm1, xmm2/m64 - /// VSQRTSD xmm1, xmm2, xmm3/m64 - /// VSQRTSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_sqrt_sd (__m128d a) + /// SQRTSD xmm1, xmm2/m64 + /// VSQRTSD xmm1, xmm2, xmm3/m64 + /// VSQRTSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 SqrtScalar(Vector128 value) => SqrtScalar(value); /// - /// __m128d _mm_sqrt_sd (__m128d a, __m128d b) - /// SQRTSD xmm1, xmm2/m64 - /// VSQRTSD xmm1, xmm2, xmm3/m64 - /// VSQRTSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} + /// __m128d _mm_sqrt_sd (__m128d a, __m128d b) + /// SQRTSD xmm1, xmm2/m64 + /// VSQRTSD xmm1, xmm2, xmm3/m64 + /// VSQRTSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} /// public static Vector128 SqrtScalar(Vector128 upper, Vector128 value) => SqrtScalar(upper, value); /// - /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQU m128, xmm1 - /// VMOVDQU m128, xmm1 - /// VMOVDQU8 m128 {k1}{z}, xmm1 + /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQU m128, xmm1 + /// VMOVDQU m128, xmm1 + /// VMOVDQU8 m128 {k1}{z}, xmm1 /// public static unsafe void Store(sbyte* address, Vector128 source) => Store(address, source); /// - /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQU m128, xmm1 - /// VMOVDQU m128, xmm1 - /// VMOVDQU8 m128 {k1}{z}, xmm1 + /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQU m128, xmm1 + /// VMOVDQU m128, xmm1 + /// VMOVDQU8 m128 {k1}{z}, xmm1 /// public static unsafe void Store(byte* address, Vector128 source) => Store(address, source); /// - /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQU m128, xmm1 - /// VMOVDQU m128, xmm1 - /// VMOVDQU16 m128 {k1}{z}, xmm1 + /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQU m128, xmm1 + /// VMOVDQU m128, xmm1 + /// VMOVDQU16 m128 {k1}{z}, xmm1 /// public static unsafe void Store(short* address, Vector128 source) => Store(address, source); /// - /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQU m128, xmm1 - /// VMOVDQU m128, xmm1 - /// VMOVDQU16 m128 {k1}{z}, xmm1 + /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQU m128, xmm1 + /// VMOVDQU m128, xmm1 + /// VMOVDQU16 m128 {k1}{z}, xmm1 /// public static unsafe void Store(ushort* address, Vector128 source) => Store(address, source); /// - /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQU m128, xmm1 - /// VMOVDQU m128, xmm1 - /// VMOVDQU32 m128 {k1}{z}, xmm1 + /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQU m128, xmm1 + /// VMOVDQU m128, xmm1 + /// VMOVDQU32 m128 {k1}{z}, xmm1 /// public static unsafe void Store(int* address, Vector128 source) => Store(address, source); /// - /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQU m128, xmm1 - /// VMOVDQU m128, xmm1 - /// VMOVDQU32 m128 {k1}{z}, xmm1 + /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQU m128, xmm1 + /// VMOVDQU m128, xmm1 + /// VMOVDQU32 m128 {k1}{z}, xmm1 /// public static unsafe void Store(uint* address, Vector128 source) => Store(address, source); /// - /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQU m128, xmm1 - /// VMOVDQU m128, xmm1 - /// VMOVDQU64 m128 {k1}{z}, xmm1 + /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQU m128, xmm1 + /// VMOVDQU m128, xmm1 + /// VMOVDQU64 m128 {k1}{z}, xmm1 /// public static unsafe void Store(long* address, Vector128 source) => Store(address, source); /// - /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQU m128, xmm1 - /// VMOVDQU m128, xmm1 - /// VMOVDQU64 m128 {k1}{z}, xmm1 + /// void _mm_storeu_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQU m128, xmm1 + /// VMOVDQU m128, xmm1 + /// VMOVDQU64 m128 {k1}{z}, xmm1 /// public static unsafe void Store(ulong* address, Vector128 source) => Store(address, source); /// - /// void _mm_storeu_pd (double* mem_addr, __m128d a) - /// MOVUPD m128, xmm1 - /// VMOVUPD m128, xmm1 - /// VMOVUPD m128 {k1}{z}, xmm1 + /// void _mm_storeu_pd (double* mem_addr, __m128d a) + /// MOVUPD m128, xmm1 + /// VMOVUPD m128, xmm1 + /// VMOVUPD m128 {k1}{z}, xmm1 /// public static unsafe void Store(double* address, Vector128 source) => Store(address, source); /// - /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQA m128, xmm1 - /// VMOVDQA m128, xmm1 - /// VMOVDQA32 m128 {k1}{z}, xmm1 + /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQA m128, xmm1 + /// VMOVDQA m128, xmm1 + /// VMOVDQA32 m128 {k1}{z}, xmm1 /// public static unsafe void StoreAligned(sbyte* address, Vector128 source) => StoreAligned(address, source); /// - /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQA m128, xmm1 - /// VMOVDQA m128, xmm1 - /// VMOVDQA32 m128 {k1}{z}, xmm1 + /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQA m128, xmm1 + /// VMOVDQA m128, xmm1 + /// VMOVDQA32 m128 {k1}{z}, xmm1 /// public static unsafe void StoreAligned(byte* address, Vector128 source) => StoreAligned(address, source); /// - /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQA m128, xmm1 - /// VMOVDQA m128, xmm1 - /// VMOVDQA32 m128 {k1}{z}, xmm1 + /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQA m128, xmm1 + /// VMOVDQA m128, xmm1 + /// VMOVDQA32 m128 {k1}{z}, xmm1 /// public static unsafe void StoreAligned(short* address, Vector128 source) => StoreAligned(address, source); /// - /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQA m128, xmm1 - /// VMOVDQA m128, xmm1 - /// VMOVDQA32 m128 {k1}{z}, xmm1 + /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQA m128, xmm1 + /// VMOVDQA m128, xmm1 + /// VMOVDQA32 m128 {k1}{z}, xmm1 /// public static unsafe void StoreAligned(ushort* address, Vector128 source) => StoreAligned(address, source); /// - /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQA m128, xmm1 - /// VMOVDQA m128, xmm1 - /// VMOVDQA32 m128 {k1}{z}, xmm1 + /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQA m128, xmm1 + /// VMOVDQA m128, xmm1 + /// VMOVDQA32 m128 {k1}{z}, xmm1 /// public static unsafe void StoreAligned(int* address, Vector128 source) => StoreAligned(address, source); /// - /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQA m128, xmm1 - /// VMOVDQA m128, xmm1 - /// VMOVDQA32 m128 {k1}{z}, xmm1 + /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQA m128, xmm1 + /// VMOVDQA m128, xmm1 + /// VMOVDQA32 m128 {k1}{z}, xmm1 /// public static unsafe void StoreAligned(uint* address, Vector128 source) => StoreAligned(address, source); /// - /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQA m128, xmm1 - /// VMOVDQA m128, xmm1 - /// VMOVDQA64 m128 {k1}{z}, xmm1 + /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQA m128, xmm1 + /// VMOVDQA m128, xmm1 + /// VMOVDQA64 m128 {k1}{z}, xmm1 /// public static unsafe void StoreAligned(long* address, Vector128 source) => StoreAligned(address, source); /// - /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) - /// MOVDQA m128, xmm1 - /// VMOVDQA m128, xmm1 - /// VMOVDQA64 m128 {k1}{z}, xmm1 + /// void _mm_store_si128 (__m128i* mem_addr, __m128i a) + /// MOVDQA m128, xmm1 + /// VMOVDQA m128, xmm1 + /// VMOVDQA64 m128 {k1}{z}, xmm1 /// public static unsafe void StoreAligned(ulong* address, Vector128 source) => StoreAligned(address, source); /// - /// void _mm_store_pd (double* mem_addr, __m128d a) - /// MOVAPD m128, xmm1 - /// VMOVAPD m128, xmm1 - /// VMOVAPD m128 {k1}{z}, xmm1 + /// void _mm_store_pd (double* mem_addr, __m128d a) + /// MOVAPD m128, xmm1 + /// VMOVAPD m128, xmm1 + /// VMOVAPD m128 {k1}{z}, xmm1 /// public static unsafe void StoreAligned(double* address, Vector128 source) => StoreAligned(address, source); /// - /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) - /// MOVNTDQ m128, xmm1 - /// VMOVNTDQ m128, xmm1 + /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) + /// MOVNTDQ m128, xmm1 + /// VMOVNTDQ m128, xmm1 /// public static unsafe void StoreAlignedNonTemporal(sbyte* address, Vector128 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) - /// MOVNTDQ m128, xmm1 - /// VMOVNTDQ m128, xmm1 + /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) + /// MOVNTDQ m128, xmm1 + /// VMOVNTDQ m128, xmm1 /// public static unsafe void StoreAlignedNonTemporal(byte* address, Vector128 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) - /// MOVNTDQ m128, xmm1 - /// VMOVNTDQ m128, xmm1 + /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) + /// MOVNTDQ m128, xmm1 + /// VMOVNTDQ m128, xmm1 /// public static unsafe void StoreAlignedNonTemporal(short* address, Vector128 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) - /// MOVNTDQ m128, xmm1 - /// VMOVNTDQ m128, xmm1 + /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) + /// MOVNTDQ m128, xmm1 + /// VMOVNTDQ m128, xmm1 /// public static unsafe void StoreAlignedNonTemporal(ushort* address, Vector128 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) - /// MOVNTDQ m128, xmm1 - /// VMOVNTDQ m128, xmm1 + /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) + /// MOVNTDQ m128, xmm1 + /// VMOVNTDQ m128, xmm1 /// public static unsafe void StoreAlignedNonTemporal(int* address, Vector128 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) - /// MOVNTDQ m128, xmm1 - /// VMOVNTDQ m128, xmm1 + /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) + /// MOVNTDQ m128, xmm1 + /// VMOVNTDQ m128, xmm1 /// public static unsafe void StoreAlignedNonTemporal(uint* address, Vector128 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) - /// MOVNTDQ m128, xmm1 - /// VMOVNTDQ m128, xmm1 + /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) + /// MOVNTDQ m128, xmm1 + /// VMOVNTDQ m128, xmm1 /// public static unsafe void StoreAlignedNonTemporal(long* address, Vector128 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) - /// MOVNTDQ m128, xmm1 - /// VMOVNTDQ m128, xmm1 + /// void _mm_stream_si128 (__m128i* mem_addr, __m128i a) + /// MOVNTDQ m128, xmm1 + /// VMOVNTDQ m128, xmm1 /// public static unsafe void StoreAlignedNonTemporal(ulong* address, Vector128 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm_stream_pd (double* mem_addr, __m128d a) - /// MOVNTPD m128, xmm1 - /// VMOVNTPD m128, xmm1 + /// void _mm_stream_pd (double* mem_addr, __m128d a) + /// MOVNTPD m128, xmm1 + /// VMOVNTPD m128, xmm1 /// public static unsafe void StoreAlignedNonTemporal(double* address, Vector128 source) => StoreAlignedNonTemporal(address, source); /// - /// void _mm_storeh_pd (double* mem_addr, __m128d a) - /// MOVHPD m64, xmm1 - /// VMOVHPD m64, xmm1 + /// void _mm_storeh_pd (double* mem_addr, __m128d a) + /// MOVHPD m64, xmm1 + /// VMOVHPD m64, xmm1 /// public static unsafe void StoreHigh(double* address, Vector128 source) => StoreHigh(address, source); /// - /// void _mm_storel_pd (double* mem_addr, __m128d a) - /// MOVLPD m64, xmm1 - /// VMOVLPD m64, xmm1 + /// void _mm_storel_pd (double* mem_addr, __m128d a) + /// MOVLPD m64, xmm1 + /// VMOVLPD m64, xmm1 /// public static unsafe void StoreLow(double* address, Vector128 source) => StoreLow(address, source); /// - /// void _mm_stream_si32(int *p, int a) - /// MOVNTI m32, r32 + /// void _mm_stream_si32(int *p, int a) + /// MOVNTI m32, r32 /// public static unsafe void StoreNonTemporal(int* address, int value) => StoreNonTemporal(address, value); /// - /// void _mm_stream_si32(int *p, int a) - /// MOVNTI m32, r32 + /// void _mm_stream_si32(int *p, int a) + /// MOVNTI m32, r32 /// public static unsafe void StoreNonTemporal(uint* address, uint value) => StoreNonTemporal(address, value); /// - /// void _mm_storeu_si32 (void* mem_addr, __m128i a) - /// MOVD m32, xmm1 - /// VMOVD m32, xmm1 + /// void _mm_storeu_si32 (void* mem_addr, __m128i a) + /// MOVD m32, xmm1 + /// VMOVD m32, xmm1 /// public static unsafe void StoreScalar(int* address, Vector128 source) => StoreScalar(address, source); /// - /// void _mm_storeu_si32 (void* mem_addr, __m128i a) - /// MOVD m32, xmm1 - /// VMOVD m32, xmm1 + /// void _mm_storeu_si32 (void* mem_addr, __m128i a) + /// MOVD m32, xmm1 + /// VMOVD m32, xmm1 /// public static unsafe void StoreScalar(uint* address, Vector128 source) => StoreScalar(address, source); /// - /// void _mm_storel_epi64 (__m128i* mem_addr, __m128i a) - /// MOVQ m64, xmm1 - /// VMOVQ m64, xmm1 + /// void _mm_storel_epi64 (__m128i* mem_addr, __m128i a) + /// MOVQ m64, xmm1 + /// VMOVQ m64, xmm1 /// public static unsafe void StoreScalar(long* address, Vector128 source) => StoreScalar(address, source); /// - /// void _mm_storel_epi64 (__m128i* mem_addr, __m128i a) - /// MOVQ m64, xmm1 - /// VMOVQ m64, xmm1 + /// void _mm_storel_epi64 (__m128i* mem_addr, __m128i a) + /// MOVQ m64, xmm1 + /// VMOVQ m64, xmm1 /// public static unsafe void StoreScalar(ulong* address, Vector128 source) => StoreScalar(address, source); /// - /// void _mm_store_sd (double* mem_addr, __m128d a) - /// MOVSD m64, xmm1 - /// VMOVSD m64, xmm1 - /// VMOVSD m64 {k1}, xmm1 + /// void _mm_store_sd (double* mem_addr, __m128d a) + /// MOVSD m64, xmm1 + /// VMOVSD m64, xmm1 + /// VMOVSD m64 {k1}, xmm1 /// public static unsafe void StoreScalar(double* address, Vector128 source) => StoreScalar(address, source); /// - /// __m128i _mm_sub_epi8 (__m128i a, __m128i b) - /// PSUBB xmm1, xmm2/m128 - /// VPSUBB xmm1, xmm2, xmm3/m128 - /// VPSUBB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sub_epi8 (__m128i a, __m128i b) + /// PSUBB xmm1, xmm2/m128 + /// VPSUBB xmm1, xmm2, xmm3/m128 + /// VPSUBB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// - /// __m128i _mm_sub_epi8 (__m128i a, __m128i b) - /// PSUBB xmm1, xmm2/m128 - /// VPSUBB xmm1, xmm2, xmm3/m128 - /// VPSUBB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sub_epi8 (__m128i a, __m128i b) + /// PSUBB xmm1, xmm2/m128 + /// VPSUBB xmm1, xmm2, xmm3/m128 + /// VPSUBB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// - /// __m128i _mm_sub_epi16 (__m128i a, __m128i b) - /// PSUBW xmm1, xmm2/m128 - /// VPSUBW xmm1, xmm2, xmm3/m128 - /// VPSUBW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sub_epi16 (__m128i a, __m128i b) + /// PSUBW xmm1, xmm2/m128 + /// VPSUBW xmm1, xmm2, xmm3/m128 + /// VPSUBW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// - /// __m128i _mm_sub_epi16 (__m128i a, __m128i b) - /// PSUBW xmm1, xmm2/m128 - /// VPSUBW xmm1, xmm2, xmm3/m128 - /// VPSUBW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sub_epi16 (__m128i a, __m128i b) + /// PSUBW xmm1, xmm2/m128 + /// VPSUBW xmm1, xmm2, xmm3/m128 + /// VPSUBW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// - /// __m128i _mm_sub_epi32 (__m128i a, __m128i b) - /// PSUBD xmm1, xmm2/m128 - /// VPSUBD xmm1, xmm2, xmm3/m128 - /// VPSUBD xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sub_epi32 (__m128i a, __m128i b) + /// PSUBD xmm1, xmm2/m128 + /// VPSUBD xmm1, xmm2, xmm3/m128 + /// VPSUBD xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// - /// __m128i _mm_sub_epi32 (__m128i a, __m128i b) - /// PSUBD xmm1, xmm2/m128 - /// VPSUBD xmm1, xmm2, xmm3/m128 - /// VPSUBD xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sub_epi32 (__m128i a, __m128i b) + /// PSUBD xmm1, xmm2/m128 + /// VPSUBD xmm1, xmm2, xmm3/m128 + /// VPSUBD xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// - /// __m128i _mm_sub_epi64 (__m128i a, __m128i b) - /// PSUBQ xmm1, xmm2/m128 - /// VPSUBQ xmm1, xmm2, xmm3/m128 - /// VPSUBQ xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sub_epi64 (__m128i a, __m128i b) + /// PSUBQ xmm1, xmm2/m128 + /// VPSUBQ xmm1, xmm2, xmm3/m128 + /// VPSUBQ xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// - /// __m128i _mm_sub_epi64 (__m128i a, __m128i b) - /// PSUBQ xmm1, xmm2/m128 - /// VPSUBQ xmm1, xmm2, xmm3/m128 - /// VPSUBQ xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sub_epi64 (__m128i a, __m128i b) + /// PSUBQ xmm1, xmm2/m128 + /// VPSUBQ xmm1, xmm2, xmm3/m128 + /// VPSUBQ xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// - /// __m128d _mm_sub_pd (__m128d a, __m128d b) - /// SUBPD xmm1, xmm2/m128 - /// VSUBPD xmm1, xmm2, xmm3/m128 - /// VSUBPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_sub_pd (__m128d a, __m128d b) + /// SUBPD xmm1, xmm2/m128 + /// VSUBPD xmm1, xmm2, xmm3/m128 + /// VSUBPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Subtract(Vector128 left, Vector128 right) => Subtract(left, right); /// - /// __m128d _mm_sub_sd (__m128d a, __m128d b) - /// SUBSD xmm1, xmm2/m64 - /// VSUBSD xmm1, xmm2, xmm3/m64 - /// VSUBSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} + /// __m128d _mm_sub_sd (__m128d a, __m128d b) + /// SUBSD xmm1, xmm2/m64 + /// VSUBSD xmm1, xmm2, xmm3/m64 + /// VSUBSD xmm1 {k1}{z}, xmm2, xmm3/m64{er} /// public static Vector128 SubtractScalar(Vector128 left, Vector128 right) => SubtractScalar(left, right); /// - /// __m128i _mm_subs_epi8 (__m128i a, __m128i b) - /// PSUBSB xmm1, xmm2/m128 - /// VPSUBSB xmm1, xmm2, xmm3/m128 - /// VPSUBSB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_subs_epi8 (__m128i a, __m128i b) + /// PSUBSB xmm1, xmm2/m128 + /// VPSUBSB xmm1, xmm2, xmm3/m128 + /// VPSUBSB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) => SubtractSaturate(left, right); /// - /// __m128i _mm_subs_epi16 (__m128i a, __m128i b) - /// PSUBSW xmm1, xmm2/m128 - /// VPSUBSW xmm1, xmm2, xmm3/m128 - /// VPSUBSW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_subs_epi16 (__m128i a, __m128i b) + /// PSUBSW xmm1, xmm2/m128 + /// VPSUBSW xmm1, xmm2, xmm3/m128 + /// VPSUBSW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) => SubtractSaturate(left, right); /// - /// __m128i _mm_subs_epu8 (__m128i a, __m128i b) - /// PSUBUSB xmm1, xmm2/m128 - /// VPSUBUSB xmm1, xmm2, xmm3/m128 - /// VPSUBUSB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_subs_epu8 (__m128i a, __m128i b) + /// PSUBUSB xmm1, xmm2/m128 + /// VPSUBUSB xmm1, xmm2, xmm3/m128 + /// VPSUBUSB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) => SubtractSaturate(left, right); /// - /// __m128i _mm_subs_epu16 (__m128i a, __m128i b) - /// PSUBUSW xmm1, xmm2/m128 - /// VPSUBUSW xmm1, xmm2, xmm3/m128 - /// VPSUBUSW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_subs_epu16 (__m128i a, __m128i b) + /// PSUBUSW xmm1, xmm2/m128 + /// VPSUBUSW xmm1, xmm2, xmm3/m128 + /// VPSUBUSW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 SubtractSaturate(Vector128 left, Vector128 right) => SubtractSaturate(left, right); /// - /// __m128i _mm_sad_epu8 (__m128i a, __m128i b) - /// PSADBW xmm1, xmm2/m128 - /// VPSADBW xmm1, xmm2, xmm3/m128 - /// VPSADBW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_sad_epu8 (__m128i a, __m128i b) + /// PSADBW xmm1, xmm2/m128 + /// VPSADBW xmm1, xmm2, xmm3/m128 + /// VPSADBW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 SumAbsoluteDifferences(Vector128 left, Vector128 right) => SumAbsoluteDifferences(left, right); /// - /// __m128i _mm_unpackhi_epi8 (__m128i a, __m128i b) - /// PUNPCKHBW xmm1, xmm2/m128 - /// VPUNPCKHBW xmm1, xmm2, xmm3/m128 - /// VPUNPCKHBW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_unpackhi_epi8 (__m128i a, __m128i b) + /// PUNPCKHBW xmm1, xmm2/m128 + /// VPUNPCKHBW xmm1, xmm2, xmm3/m128 + /// VPUNPCKHBW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 UnpackHigh(Vector128 left, Vector128 right) => UnpackHigh(left, right); /// - /// __m128i _mm_unpackhi_epi8 (__m128i a, __m128i b) - /// PUNPCKHBW xmm1, xmm2/m128 - /// VPUNPCKHBW xmm1, xmm2, xmm3/m128 - /// VPUNPCKHBW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_unpackhi_epi8 (__m128i a, __m128i b) + /// PUNPCKHBW xmm1, xmm2/m128 + /// VPUNPCKHBW xmm1, xmm2, xmm3/m128 + /// VPUNPCKHBW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 UnpackHigh(Vector128 left, Vector128 right) => UnpackHigh(left, right); /// - /// __m128i _mm_unpackhi_epi16 (__m128i a, __m128i b) - /// PUNPCKHWD xmm1, xmm2/m128 - /// VPUNPCKHWD xmm1, xmm2, xmm3/m128 - /// VPUNPCKHWD xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_unpackhi_epi16 (__m128i a, __m128i b) + /// PUNPCKHWD xmm1, xmm2/m128 + /// VPUNPCKHWD xmm1, xmm2, xmm3/m128 + /// VPUNPCKHWD xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 UnpackHigh(Vector128 left, Vector128 right) => UnpackHigh(left, right); /// - /// __m128i _mm_unpackhi_epi16 (__m128i a, __m128i b) - /// PUNPCKHWD xmm1, xmm2/m128 - /// VPUNPCKHWD xmm1, xmm2, xmm3/m128 - /// VPUNPCKHWD xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_unpackhi_epi16 (__m128i a, __m128i b) + /// PUNPCKHWD xmm1, xmm2/m128 + /// VPUNPCKHWD xmm1, xmm2, xmm3/m128 + /// VPUNPCKHWD xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 UnpackHigh(Vector128 left, Vector128 right) => UnpackHigh(left, right); /// - /// __m128i _mm_unpackhi_epi32 (__m128i a, __m128i b) - /// PUNPCKHDQ xmm1, xmm2/m128 - /// VPUNPCKHDQ xmm1, xmm2, xmm3/m128 - /// VPUNPCKHDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_unpackhi_epi32 (__m128i a, __m128i b) + /// PUNPCKHDQ xmm1, xmm2/m128 + /// VPUNPCKHDQ xmm1, xmm2, xmm3/m128 + /// VPUNPCKHDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 UnpackHigh(Vector128 left, Vector128 right) => UnpackHigh(left, right); /// - /// __m128i _mm_unpackhi_epi32 (__m128i a, __m128i b) - /// PUNPCKHDQ xmm1, xmm2/m128 - /// VPUNPCKHDQ xmm1, xmm2, xmm3/m128 - /// VPUNPCKHDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_unpackhi_epi32 (__m128i a, __m128i b) + /// PUNPCKHDQ xmm1, xmm2/m128 + /// VPUNPCKHDQ xmm1, xmm2, xmm3/m128 + /// VPUNPCKHDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 UnpackHigh(Vector128 left, Vector128 right) => UnpackHigh(left, right); /// - /// __m128i _mm_unpackhi_epi64 (__m128i a, __m128i b) - /// PUNPCKHQDQ xmm1, xmm2/m128 - /// VPUNPCKHQDQ xmm1, xmm2, xmm3/m128 - /// VPUNPCKHQDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_unpackhi_epi64 (__m128i a, __m128i b) + /// PUNPCKHQDQ xmm1, xmm2/m128 + /// VPUNPCKHQDQ xmm1, xmm2, xmm3/m128 + /// VPUNPCKHQDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 UnpackHigh(Vector128 left, Vector128 right) => UnpackHigh(left, right); /// - /// __m128i _mm_unpackhi_epi64 (__m128i a, __m128i b) - /// PUNPCKHQDQ xmm1, xmm2/m128 - /// VPUNPCKHQDQ xmm1, xmm2, xmm3/m128 - /// VPUNPCKHQDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_unpackhi_epi64 (__m128i a, __m128i b) + /// PUNPCKHQDQ xmm1, xmm2/m128 + /// VPUNPCKHQDQ xmm1, xmm2, xmm3/m128 + /// VPUNPCKHQDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 UnpackHigh(Vector128 left, Vector128 right) => UnpackHigh(left, right); /// - /// __m128d _mm_unpackhi_pd (__m128d a, __m128d b) - /// UNPCKHPD xmm1, xmm2/m128 - /// VUNPCKHPD xmm1, xmm2, xmm3/m128 - /// VUNPCKHPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_unpackhi_pd (__m128d a, __m128d b) + /// UNPCKHPD xmm1, xmm2/m128 + /// VUNPCKHPD xmm1, xmm2, xmm3/m128 + /// VUNPCKHPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 UnpackHigh(Vector128 left, Vector128 right) => UnpackHigh(left, right); /// - /// __m128i _mm_unpacklo_epi8 (__m128i a, __m128i b) - /// PUNPCKLBW xmm1, xmm2/m128 - /// VPUNPCKLBW xmm1, xmm2, xmm3/m128 - /// VPUNPCKLBW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_unpacklo_epi8 (__m128i a, __m128i b) + /// PUNPCKLBW xmm1, xmm2/m128 + /// VPUNPCKLBW xmm1, xmm2, xmm3/m128 + /// VPUNPCKLBW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 UnpackLow(Vector128 left, Vector128 right) => UnpackLow(left, right); /// - /// __m128i _mm_unpacklo_epi8 (__m128i a, __m128i b) - /// PUNPCKLBW xmm1, xmm2/m128 - /// VPUNPCKLBW xmm1, xmm2, xmm3/m128 - /// VPUNPCKLBW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_unpacklo_epi8 (__m128i a, __m128i b) + /// PUNPCKLBW xmm1, xmm2/m128 + /// VPUNPCKLBW xmm1, xmm2, xmm3/m128 + /// VPUNPCKLBW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 UnpackLow(Vector128 left, Vector128 right) => UnpackLow(left, right); /// - /// __m128i _mm_unpacklo_epi16 (__m128i a, __m128i b) - /// PUNPCKLWD xmm1, xmm2/m128 - /// VPUNPCKLWD xmm1, xmm2, xmm3/m128 - /// VPUNPCKLWD xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_unpacklo_epi16 (__m128i a, __m128i b) + /// PUNPCKLWD xmm1, xmm2/m128 + /// VPUNPCKLWD xmm1, xmm2, xmm3/m128 + /// VPUNPCKLWD xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 UnpackLow(Vector128 left, Vector128 right) => UnpackLow(left, right); /// - /// __m128i _mm_unpacklo_epi16 (__m128i a, __m128i b) - /// PUNPCKLWD xmm1, xmm2/m128 - /// VPUNPCKLWD xmm1, xmm2, xmm3/m128 - /// VPUNPCKLWD xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_unpacklo_epi16 (__m128i a, __m128i b) + /// PUNPCKLWD xmm1, xmm2/m128 + /// VPUNPCKLWD xmm1, xmm2, xmm3/m128 + /// VPUNPCKLWD xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 UnpackLow(Vector128 left, Vector128 right) => UnpackLow(left, right); /// - /// __m128i _mm_unpacklo_epi32 (__m128i a, __m128i b) - /// PUNPCKLDQ xmm1, xmm2/m128 - /// VPUNPCKLDQ xmm1, xmm2, xmm3/m128 - /// VPUNPCKLDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_unpacklo_epi32 (__m128i a, __m128i b) + /// PUNPCKLDQ xmm1, xmm2/m128 + /// VPUNPCKLDQ xmm1, xmm2, xmm3/m128 + /// VPUNPCKLDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 UnpackLow(Vector128 left, Vector128 right) => UnpackLow(left, right); /// - /// __m128i _mm_unpacklo_epi32 (__m128i a, __m128i b) - /// PUNPCKLDQ xmm1, xmm2/m128 - /// VPUNPCKLDQ xmm1, xmm2, xmm3/m128 - /// VPUNPCKLDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_unpacklo_epi32 (__m128i a, __m128i b) + /// PUNPCKLDQ xmm1, xmm2/m128 + /// VPUNPCKLDQ xmm1, xmm2, xmm3/m128 + /// VPUNPCKLDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 UnpackLow(Vector128 left, Vector128 right) => UnpackLow(left, right); /// - /// __m128i _mm_unpacklo_epi64 (__m128i a, __m128i b) - /// PUNPCKLQDQ xmm1, xmm2/m128 - /// VPUNPCKLQDQ xmm1, xmm2, xmm3/m128 - /// VPUNPCKLQDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_unpacklo_epi64 (__m128i a, __m128i b) + /// PUNPCKLQDQ xmm1, xmm2/m128 + /// VPUNPCKLQDQ xmm1, xmm2, xmm3/m128 + /// VPUNPCKLQDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 UnpackLow(Vector128 left, Vector128 right) => UnpackLow(left, right); /// - /// __m128i _mm_unpacklo_epi64 (__m128i a, __m128i b) - /// PUNPCKLQDQ xmm1, xmm2/m128 - /// VPUNPCKLQDQ xmm1, xmm2, xmm3/m128 - /// VPUNPCKLQDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_unpacklo_epi64 (__m128i a, __m128i b) + /// PUNPCKLQDQ xmm1, xmm2/m128 + /// VPUNPCKLQDQ xmm1, xmm2, xmm3/m128 + /// VPUNPCKLQDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 UnpackLow(Vector128 left, Vector128 right) => UnpackLow(left, right); /// - /// __m128d _mm_unpacklo_pd (__m128d a, __m128d b) - /// UNPCKLPD xmm1, xmm2/m128 - /// VUNPCKLPD xmm1, xmm2, xmm3/m128 - /// VUNPCKLPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_unpacklo_pd (__m128d a, __m128d b) + /// UNPCKLPD xmm1, xmm2/m128 + /// VUNPCKLPD xmm1, xmm2, xmm3/m128 + /// VUNPCKLPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 UnpackLow(Vector128 left, Vector128 right) => UnpackLow(left, right); /// - /// __m128i _mm_xor_si128 (__m128i a, __m128i b) - /// PXOR xmm1, xmm2/m128 - /// VPXOR xmm1, xmm2, xmm3/m128 + /// __m128i _mm_xor_si128 (__m128i a, __m128i b) + /// PXOR xmm1, xmm2/m128 + /// VPXOR xmm1, xmm2, xmm3/m128 /// public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// - /// __m128i _mm_xor_si128 (__m128i a, __m128i b) - /// PXOR xmm1, xmm2/m128 - /// VPXOR xmm1, xmm2, xmm3/m128 + /// __m128i _mm_xor_si128 (__m128i a, __m128i b) + /// PXOR xmm1, xmm2/m128 + /// VPXOR xmm1, xmm2, xmm3/m128 /// public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// - /// __m128i _mm_xor_si128 (__m128i a, __m128i b) - /// PXOR xmm1, xmm2/m128 - /// VPXOR xmm1, xmm2, xmm3/m128 + /// __m128i _mm_xor_si128 (__m128i a, __m128i b) + /// PXOR xmm1, xmm2/m128 + /// VPXOR xmm1, xmm2, xmm3/m128 /// public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// - /// __m128i _mm_xor_si128 (__m128i a, __m128i b) - /// PXOR xmm1, xmm2/m128 - /// VPXOR xmm1, xmm2, xmm3/m128 + /// __m128i _mm_xor_si128 (__m128i a, __m128i b) + /// PXOR xmm1, xmm2/m128 + /// VPXOR xmm1, xmm2, xmm3/m128 /// public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// - /// __m128i _mm_xor_si128 (__m128i a, __m128i b) - /// PXOR xmm1, xmm2/m128 - /// VPXOR xmm1, xmm2, xmm3/m128 - /// VPXORD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_xor_si128 (__m128i a, __m128i b) + /// PXOR xmm1, xmm2/m128 + /// VPXOR xmm1, xmm2, xmm3/m128 + /// VPXORD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// - /// __m128i _mm_xor_si128 (__m128i a, __m128i b) - /// PXOR xmm1, xmm2/m128 - /// VPXOR xmm1, xmm2, xmm3/m128 - /// VPXORD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_xor_si128 (__m128i a, __m128i b) + /// PXOR xmm1, xmm2/m128 + /// VPXOR xmm1, xmm2, xmm3/m128 + /// VPXORD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// - /// __m128i _mm_xor_si128 (__m128i a, __m128i b) - /// PXOR xmm1, xmm2/m128 - /// VPXOR xmm1, xmm2, xmm3/m128 - /// VPXORQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_xor_si128 (__m128i a, __m128i b) + /// PXOR xmm1, xmm2/m128 + /// VPXOR xmm1, xmm2, xmm3/m128 + /// VPXORQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// - /// __m128i _mm_xor_si128 (__m128i a, __m128i b) - /// PXOR xmm1, xmm2/m128 - /// VPXOR xmm1, xmm2, xmm3/m128 - /// VPXORQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_xor_si128 (__m128i a, __m128i b) + /// PXOR xmm1, xmm2/m128 + /// VPXOR xmm1, xmm2, xmm3/m128 + /// VPXORQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); /// - /// __m128d _mm_xor_pd (__m128d a, __m128d b) - /// XORPD xmm1, xmm2/m128 - /// VXORPD xmm1, xmm2, xmm3/m128 - /// VXORPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128d _mm_xor_pd (__m128d a, __m128d b) + /// XORPD xmm1, xmm2/m128 + /// VXORPD xmm1, xmm2, xmm3/m128 + /// VXORPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Xor(Vector128 left, Vector128 right) => Xor(left, right); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse3.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse3.PlatformNotSupported.cs index ffc067b654b..6cedd6311c9 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse3.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse3.PlatformNotSupported.cs @@ -7,138 +7,143 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel SSE3 hardware instructions via intrinsics - /// + /// Provides access to X86 SSE3 hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Sse3 : Sse2 { internal Sse3() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } + /// Provides access to the x86 SSE3 hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class X64 : Sse2.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } } /// - /// __m128 _mm_addsub_ps (__m128 a, __m128 b) - /// ADDSUBPS xmm1, xmm2/m128 - /// VADDSUBPS xmm1, xmm2, xmm3/m128 + /// __m128 _mm_addsub_ps (__m128 a, __m128 b) + /// ADDSUBPS xmm1, xmm2/m128 + /// VADDSUBPS xmm1, xmm2, xmm3/m128 /// public static Vector128 AddSubtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_addsub_pd (__m128d a, __m128d b) - /// ADDSUBPD xmm1, xmm2/m128 - /// VADDSUBPD xmm1, xmm2, xmm3/m128 + /// __m128d _mm_addsub_pd (__m128d a, __m128d b) + /// ADDSUBPD xmm1, xmm2/m128 + /// VADDSUBPD xmm1, xmm2, xmm3/m128 /// public static Vector128 AddSubtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_hadd_ps (__m128 a, __m128 b) - /// HADDPS xmm1, xmm2/m128 - /// VHADDPS xmm1, xmm2, xmm3/m128 + /// __m128 _mm_hadd_ps (__m128 a, __m128 b) + /// HADDPS xmm1, xmm2/m128 + /// VHADDPS xmm1, xmm2, xmm3/m128 /// public static Vector128 HorizontalAdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_hadd_pd (__m128d a, __m128d b) - /// HADDPD xmm1, xmm2/m128 - /// VHADDPD xmm1, xmm2, xmm3/m128 + /// __m128d _mm_hadd_pd (__m128d a, __m128d b) + /// HADDPD xmm1, xmm2/m128 + /// VHADDPD xmm1, xmm2, xmm3/m128 /// public static Vector128 HorizontalAdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_hsub_ps (__m128 a, __m128 b) - /// HSUBPS xmm1, xmm2/m128 - /// VHSUBPS xmm1, xmm2, xmm3/m128 + /// __m128 _mm_hsub_ps (__m128 a, __m128 b) + /// HSUBPS xmm1, xmm2/m128 + /// VHSUBPS xmm1, xmm2, xmm3/m128 /// public static Vector128 HorizontalSubtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_hsub_pd (__m128d a, __m128d b) - /// HSUBPD xmm1, xmm2/m128 - /// VHSUBPD xmm1, xmm2, xmm3/m128 + /// __m128d _mm_hsub_pd (__m128d a, __m128d b) + /// HSUBPD xmm1, xmm2/m128 + /// VHSUBPD xmm1, xmm2, xmm3/m128 /// public static Vector128 HorizontalSubtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_loaddup_pd (double const* mem_addr) - /// MOVDDUP xmm1, m64 - /// VMOVDDUP xmm1, m64 - /// VMOVDDUP xmm1 {k1}{z}, m64 + /// __m128d _mm_loaddup_pd (double const* mem_addr) + /// MOVDDUP xmm1, m64 + /// VMOVDDUP xmm1, m64 + /// VMOVDDUP xmm1 {k1}{z}, m64 /// public static unsafe Vector128 LoadAndDuplicateToVector128(double* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) - /// LDDQU xmm1, m128 - /// VLDDQU xmm1, m128 + /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) + /// LDDQU xmm1, m128 + /// VLDDQU xmm1, m128 /// public static unsafe Vector128 LoadDquVector128(sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) - /// LDDQU xmm1, m128 - /// VLDDQU xmm1, m128 + /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) + /// LDDQU xmm1, m128 + /// VLDDQU xmm1, m128 /// public static unsafe Vector128 LoadDquVector128(byte* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) - /// LDDQU xmm1, m128 - /// VLDDQU xmm1, m128 + /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) + /// LDDQU xmm1, m128 + /// VLDDQU xmm1, m128 /// public static unsafe Vector128 LoadDquVector128(short* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) - /// LDDQU xmm1, m128 - /// VLDDQU xmm1, m128 + /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) + /// LDDQU xmm1, m128 + /// VLDDQU xmm1, m128 /// public static unsafe Vector128 LoadDquVector128(ushort* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) - /// LDDQU xmm1, m128 - /// VLDDQU xmm1, m128 + /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) + /// LDDQU xmm1, m128 + /// VLDDQU xmm1, m128 /// public static unsafe Vector128 LoadDquVector128(int* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) - /// LDDQU xmm1, m128 - /// VLDDQU xmm1, m128 + /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) + /// LDDQU xmm1, m128 + /// VLDDQU xmm1, m128 /// public static unsafe Vector128 LoadDquVector128(uint* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) - /// LDDQU xmm1, m128 - /// VLDDQU xmm1, m128 + /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) + /// LDDQU xmm1, m128 + /// VLDDQU xmm1, m128 /// public static unsafe Vector128 LoadDquVector128(long* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) - /// LDDQU xmm1, m128 - /// VLDDQU xmm1, m128 + /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) + /// LDDQU xmm1, m128 + /// VLDDQU xmm1, m128 /// public static unsafe Vector128 LoadDquVector128(ulong* address) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_movedup_pd (__m128d a) - /// MOVDDUP xmm1, xmm2/m64 - /// VMOVDDUP xmm1, xmm2/m64 - /// VMOVDDUP xmm1 {k1}{z}, xmm2/m64 + /// __m128d _mm_movedup_pd (__m128d a) + /// MOVDDUP xmm1, xmm2/m64 + /// VMOVDDUP xmm1, xmm2/m64 + /// VMOVDDUP xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 MoveAndDuplicate(Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_movehdup_ps (__m128 a) - /// MOVSHDUP xmm1, xmm2/m128 - /// VMOVSHDUP xmm1, xmm2/m128 - /// VMOVSHDUP xmm1 {k1}{z}, xmm2/m128 + /// __m128 _mm_movehdup_ps (__m128 a) + /// MOVSHDUP xmm1, xmm2/m128 + /// VMOVSHDUP xmm1, xmm2/m128 + /// VMOVSHDUP xmm1 {k1}{z}, xmm2/m128 /// public static Vector128 MoveHighAndDuplicate(Vector128 source) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_moveldup_ps (__m128 a) - /// MOVSLDUP xmm1, xmm2/m128 - /// VMOVSLDUP xmm1, xmm2/m128 - /// VMOVSLDUP xmm1 {k1}{z}, xmm2/m128 + /// __m128 _mm_moveldup_ps (__m128 a) + /// MOVSLDUP xmm1, xmm2/m128 + /// VMOVSLDUP xmm1, xmm2/m128 + /// VMOVSLDUP xmm1 {k1}{z}, xmm2/m128 /// public static Vector128 MoveLowAndDuplicate(Vector128 source) { throw new PlatformNotSupportedException(); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse3.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse3.cs index 85fff23f4cd..bf14096e90b 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse3.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse3.cs @@ -5,140 +5,145 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel SSE3 hardware instructions via intrinsics - /// + /// Provides access to X86 SSE3 hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Sse3 : Sse2 { internal Sse3() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the x86 SSE3 hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : Sse2.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } } /// - /// __m128 _mm_addsub_ps (__m128 a, __m128 b) - /// ADDSUBPS xmm1, xmm2/m128 - /// VADDSUBPS xmm1, xmm2, xmm3/m128 + /// __m128 _mm_addsub_ps (__m128 a, __m128 b) + /// ADDSUBPS xmm1, xmm2/m128 + /// VADDSUBPS xmm1, xmm2, xmm3/m128 /// public static Vector128 AddSubtract(Vector128 left, Vector128 right) => AddSubtract(left, right); /// - /// __m128d _mm_addsub_pd (__m128d a, __m128d b) - /// ADDSUBPD xmm1, xmm2/m128 - /// VADDSUBPD xmm1, xmm2, xmm3/m128 + /// __m128d _mm_addsub_pd (__m128d a, __m128d b) + /// ADDSUBPD xmm1, xmm2/m128 + /// VADDSUBPD xmm1, xmm2, xmm3/m128 /// public static Vector128 AddSubtract(Vector128 left, Vector128 right) => AddSubtract(left, right); /// - /// __m128 _mm_hadd_ps (__m128 a, __m128 b) - /// HADDPS xmm1, xmm2/m128 - /// VHADDPS xmm1, xmm2, xmm3/m128 + /// __m128 _mm_hadd_ps (__m128 a, __m128 b) + /// HADDPS xmm1, xmm2/m128 + /// VHADDPS xmm1, xmm2, xmm3/m128 /// public static Vector128 HorizontalAdd(Vector128 left, Vector128 right) => HorizontalAdd(left, right); /// - /// __m128d _mm_hadd_pd (__m128d a, __m128d b) - /// HADDPD xmm1, xmm2/m128 - /// VHADDPD xmm1, xmm2, xmm3/m128 + /// __m128d _mm_hadd_pd (__m128d a, __m128d b) + /// HADDPD xmm1, xmm2/m128 + /// VHADDPD xmm1, xmm2, xmm3/m128 /// public static Vector128 HorizontalAdd(Vector128 left, Vector128 right) => HorizontalAdd(left, right); /// - /// __m128 _mm_hsub_ps (__m128 a, __m128 b) - /// HSUBPS xmm1, xmm2/m128 - /// VHSUBPS xmm1, xmm2, xmm3/m128 + /// __m128 _mm_hsub_ps (__m128 a, __m128 b) + /// HSUBPS xmm1, xmm2/m128 + /// VHSUBPS xmm1, xmm2, xmm3/m128 /// public static Vector128 HorizontalSubtract(Vector128 left, Vector128 right) => HorizontalSubtract(left, right); /// - /// __m128d _mm_hsub_pd (__m128d a, __m128d b) - /// HSUBPD xmm1, xmm2/m128 - /// VHSUBPD xmm1, xmm2, xmm3/m128 + /// __m128d _mm_hsub_pd (__m128d a, __m128d b) + /// HSUBPD xmm1, xmm2/m128 + /// VHSUBPD xmm1, xmm2, xmm3/m128 /// public static Vector128 HorizontalSubtract(Vector128 left, Vector128 right) => HorizontalSubtract(left, right); /// - /// __m128d _mm_loaddup_pd (double const* mem_addr) - /// MOVDDUP xmm1, m64 - /// VMOVDDUP xmm1, m64 - /// VMOVDDUP xmm1 {k1}{z}, m64 + /// __m128d _mm_loaddup_pd (double const* mem_addr) + /// MOVDDUP xmm1, m64 + /// VMOVDDUP xmm1, m64 + /// VMOVDDUP xmm1 {k1}{z}, m64 /// public static unsafe Vector128 LoadAndDuplicateToVector128(double* address) => LoadAndDuplicateToVector128(address); /// - /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) - /// LDDQU xmm1, m128 - /// VLDDQU xmm1, m128 + /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) + /// LDDQU xmm1, m128 + /// VLDDQU xmm1, m128 /// public static unsafe Vector128 LoadDquVector128(sbyte* address) => LoadDquVector128(address); /// - /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) - /// LDDQU xmm1, m128 - /// VLDDQU xmm1, m128 + /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) + /// LDDQU xmm1, m128 + /// VLDDQU xmm1, m128 /// public static unsafe Vector128 LoadDquVector128(byte* address) => LoadDquVector128(address); /// - /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) - /// LDDQU xmm1, m128 - /// VLDDQU xmm1, m128 + /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) + /// LDDQU xmm1, m128 + /// VLDDQU xmm1, m128 /// public static unsafe Vector128 LoadDquVector128(short* address) => LoadDquVector128(address); /// - /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) - /// LDDQU xmm1, m128 - /// VLDDQU xmm1, m128 + /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) + /// LDDQU xmm1, m128 + /// VLDDQU xmm1, m128 /// public static unsafe Vector128 LoadDquVector128(ushort* address) => LoadDquVector128(address); /// - /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) - /// LDDQU xmm1, m128 - /// VLDDQU xmm1, m128 + /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) + /// LDDQU xmm1, m128 + /// VLDDQU xmm1, m128 /// public static unsafe Vector128 LoadDquVector128(int* address) => LoadDquVector128(address); /// - /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) - /// LDDQU xmm1, m128 - /// VLDDQU xmm1, m128 + /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) + /// LDDQU xmm1, m128 + /// VLDDQU xmm1, m128 /// public static unsafe Vector128 LoadDquVector128(uint* address) => LoadDquVector128(address); /// - /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) - /// LDDQU xmm1, m128 - /// VLDDQU xmm1, m128 + /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) + /// LDDQU xmm1, m128 + /// VLDDQU xmm1, m128 /// public static unsafe Vector128 LoadDquVector128(long* address) => LoadDquVector128(address); /// - /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) - /// LDDQU xmm1, m128 - /// VLDDQU xmm1, m128 + /// __m128i _mm_lddqu_si128 (__m128i const* mem_addr) + /// LDDQU xmm1, m128 + /// VLDDQU xmm1, m128 /// public static unsafe Vector128 LoadDquVector128(ulong* address) => LoadDquVector128(address); /// - /// __m128d _mm_movedup_pd (__m128d a) - /// MOVDDUP xmm1, xmm2/m64 - /// VMOVDDUP xmm1, xmm2/m64 - /// VMOVDDUP xmm1 {k1}{z}, xmm2/m64 + /// __m128d _mm_movedup_pd (__m128d a) + /// MOVDDUP xmm1, xmm2/m64 + /// VMOVDDUP xmm1, xmm2/m64 + /// VMOVDDUP xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 MoveAndDuplicate(Vector128 source) => MoveAndDuplicate(source); /// - /// __m128 _mm_movehdup_ps (__m128 a) - /// MOVSHDUP xmm1, xmm2/m128 - /// VMOVSHDUP xmm1, xmm2/m128 - /// VMOVSHDUP xmm1 {k1}{z}, xmm2/m128 + /// __m128 _mm_movehdup_ps (__m128 a) + /// MOVSHDUP xmm1, xmm2/m128 + /// VMOVSHDUP xmm1, xmm2/m128 + /// VMOVSHDUP xmm1 {k1}{z}, xmm2/m128 /// public static Vector128 MoveHighAndDuplicate(Vector128 source) => MoveHighAndDuplicate(source); /// - /// __m128 _mm_moveldup_ps (__m128 a) - /// MOVSLDUP xmm1, xmm2/m128 - /// VMOVSLDUP xmm1, xmm2/m128 - /// VMOVSLDUP xmm1 {k1}{z}, xmm2/m128 + /// __m128 _mm_moveldup_ps (__m128 a) + /// MOVSLDUP xmm1, xmm2/m128 + /// VMOVSLDUP xmm1, xmm2/m128 + /// VMOVSLDUP xmm1 {k1}{z}, xmm2/m128 /// public static Vector128 MoveLowAndDuplicate(Vector128 source) => MoveLowAndDuplicate(source); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse41.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse41.PlatformNotSupported.cs index 2f5dd6a2eda..a9f765ea1ca 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse41.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse41.PlatformNotSupported.cs @@ -8,993 +8,998 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel SSE4.1 hardware instructions via intrinsics - /// + /// Provides access to X86 SSE4.1 hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Sse41 : Ssse3 { internal Sse41() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } + /// Provides access to the x86 SSE4.1 hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class X64 : Ssse3.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } /// - /// __int64 _mm_extract_epi64 (__m128i a, const int imm8) - /// PEXTRQ r/m64, xmm1, imm8 - /// VPEXTRQ r/m64, xmm1, imm8 - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_extract_epi64 (__m128i a, const int imm8) + /// PEXTRQ r/m64, xmm1, imm8 + /// VPEXTRQ r/m64, xmm1, imm8 + /// This intrinsic is only available on 64-bit processes /// public static long Extract(Vector128 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __int64 _mm_extract_epi64 (__m128i a, const int imm8) - /// PEXTRQ r/m64, xmm1, imm8 - /// VPEXTRQ r/m64, xmm1, imm8 - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_extract_epi64 (__m128i a, const int imm8) + /// PEXTRQ r/m64, xmm1, imm8 + /// VPEXTRQ r/m64, xmm1, imm8 + /// This intrinsic is only available on 64-bit processes /// public static ulong Extract(Vector128 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_insert_epi64 (__m128i a, __int64 i, const int imm8) - /// PINSRQ xmm1, r/m64, imm8 - /// VPINSRQ xmm1, xmm2, r/m64, imm8 - /// This intrinsic is only available on 64-bit processes + /// __m128i _mm_insert_epi64 (__m128i a, __int64 i, const int imm8) + /// PINSRQ xmm1, r/m64, imm8 + /// VPINSRQ xmm1, xmm2, r/m64, imm8 + /// This intrinsic is only available on 64-bit processes /// public static Vector128 Insert(Vector128 value, long data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_insert_epi64 (__m128i a, __int64 i, const int imm8) - /// PINSRQ xmm1, r/m64, imm8 - /// VPINSRQ xmm1, xmm2, r/m64, imm8 - /// This intrinsic is only available on 64-bit processes + /// __m128i _mm_insert_epi64 (__m128i a, __int64 i, const int imm8) + /// PINSRQ xmm1, r/m64, imm8 + /// VPINSRQ xmm1, xmm2, r/m64, imm8 + /// This intrinsic is only available on 64-bit processes /// public static Vector128 Insert(Vector128 value, ulong data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } } /// - /// __m128i _mm_blend_epi16 (__m128i a, __m128i b, const int imm8) - /// PBLENDW xmm1, xmm2/m128 imm8 - /// VPBLENDW xmm1, xmm2, xmm3/m128 imm8 + /// __m128i _mm_blend_epi16 (__m128i a, __m128i b, const int imm8) + /// PBLENDW xmm1, xmm2/m128 imm8 + /// VPBLENDW xmm1, xmm2, xmm3/m128 imm8 /// public static Vector128 Blend(Vector128 left, Vector128 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_blend_epi16 (__m128i a, __m128i b, const int imm8) - /// PBLENDW xmm1, xmm2/m128 imm8 - /// VPBLENDW xmm1, xmm2, xmm3/m128 imm8 + /// __m128i _mm_blend_epi16 (__m128i a, __m128i b, const int imm8) + /// PBLENDW xmm1, xmm2/m128 imm8 + /// VPBLENDW xmm1, xmm2, xmm3/m128 imm8 /// public static Vector128 Blend(Vector128 left, Vector128 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_blend_ps (__m128 a, __m128 b, const int imm8) - /// BLENDPS xmm1, xmm2/m128, imm8 - /// VBLENDPS xmm1, xmm2, xmm3/m128, imm8 + /// __m128 _mm_blend_ps (__m128 a, __m128 b, const int imm8) + /// BLENDPS xmm1, xmm2/m128, imm8 + /// VBLENDPS xmm1, xmm2, xmm3/m128, imm8 /// public static Vector128 Blend(Vector128 left, Vector128 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_blend_pd (__m128d a, __m128d b, const int imm8) - /// BLENDPD xmm1, xmm2/m128, imm8 - /// VBLENDPD xmm1, xmm2, xmm3/m128, imm8 + /// __m128d _mm_blend_pd (__m128d a, __m128d b, const int imm8) + /// BLENDPD xmm1, xmm2/m128, imm8 + /// VBLENDPD xmm1, xmm2, xmm3/m128, imm8 /// public static Vector128 Blend(Vector128 left, Vector128 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) - /// PBLENDVB xmm1, xmm2/m128, <XMM0> - /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 + /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) + /// PBLENDVB xmm1, xmm2/m128, <XMM0> + /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 /// public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) - /// PBLENDVB xmm1, xmm2/m128, <XMM0> - /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 + /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) + /// PBLENDVB xmm1, xmm2/m128, <XMM0> + /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 /// public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) - /// PBLENDVB xmm1, xmm2/m128, <XMM0> - /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 - /// This intrinsic generates PBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. + /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) + /// PBLENDVB xmm1, xmm2/m128, <XMM0> + /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 + /// This intrinsic generates PBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. /// public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) - /// PBLENDVB xmm1, xmm2/m128, <XMM0> - /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 - /// This intrinsic generates PBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. + /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) + /// PBLENDVB xmm1, xmm2/m128, <XMM0> + /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 + /// This intrinsic generates PBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. /// public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) - /// PBLENDVB xmm1, xmm2/m128, <XMM0> - /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 - /// This intrinsic generates PBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. + /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) + /// PBLENDVB xmm1, xmm2/m128, <XMM0> + /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 + /// This intrinsic generates PBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. /// public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) - /// PBLENDVB xmm1, xmm2/m128, <XMM0> - /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 - /// This intrinsic generates PBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. + /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) + /// PBLENDVB xmm1, xmm2/m128, <XMM0> + /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 + /// This intrinsic generates PBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. /// public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) - /// PBLENDVB xmm1, xmm2/m128, <XMM0> - /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 - /// This intrinsic generates PBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. + /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) + /// PBLENDVB xmm1, xmm2/m128, <XMM0> + /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 + /// This intrinsic generates PBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. /// public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) - /// PBLENDVB xmm1, xmm2/m128, <XMM0> - /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 - /// This intrinsic generates PBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. + /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) + /// PBLENDVB xmm1, xmm2/m128, <XMM0> + /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 + /// This intrinsic generates PBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. /// public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_blendv_ps (__m128 a, __m128 b, __m128 mask) - /// BLENDVPS xmm1, xmm2/m128, <XMM0> - /// VBLENDVPS xmm1, xmm2, xmm3/m128, xmm4 + /// __m128 _mm_blendv_ps (__m128 a, __m128 b, __m128 mask) + /// BLENDVPS xmm1, xmm2/m128, <XMM0> + /// VBLENDVPS xmm1, xmm2, xmm3/m128, xmm4 /// public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_blendv_pd (__m128d a, __m128d b, __m128d mask) - /// BLENDVPD xmm1, xmm2/m128, <XMM0> - /// VBLENDVPD xmm1, xmm2, xmm3/m128, xmm4 + /// __m128d _mm_blendv_pd (__m128d a, __m128d b, __m128d mask) + /// BLENDVPD xmm1, xmm2/m128, <XMM0> + /// VBLENDVPD xmm1, xmm2, xmm3/m128, xmm4 /// public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_ceil_ps (__m128 a) - /// ROUNDPS xmm1, xmm2/m128, imm8(10) - /// VROUNDPS xmm1, xmm2/m128, imm8(10) + /// __m128 _mm_ceil_ps (__m128 a) + /// ROUNDPS xmm1, xmm2/m128, imm8(10) + /// VROUNDPS xmm1, xmm2/m128, imm8(10) /// public static Vector128 Ceiling(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_ceil_pd (__m128d a) - /// ROUNDPD xmm1, xmm2/m128, imm8(10) - /// VROUNDPD xmm1, xmm2/m128, imm8(10) + /// __m128d _mm_ceil_pd (__m128d a) + /// ROUNDPD xmm1, xmm2/m128, imm8(10) + /// VROUNDPD xmm1, xmm2/m128, imm8(10) /// public static Vector128 Ceiling(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_ceil_ss (__m128 a) - /// ROUNDSS xmm1, xmm2/m128, imm8(10) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(10) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_ceil_ss (__m128 a) + /// ROUNDSS xmm1, xmm2/m128, imm8(10) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(10) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 CeilingScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_ceil_ss (__m128 a, __m128 b) - /// ROUNDSS xmm1, xmm2/m128, imm8(10) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(10) + /// __m128 _mm_ceil_ss (__m128 a, __m128 b) + /// ROUNDSS xmm1, xmm2/m128, imm8(10) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(10) /// public static Vector128 CeilingScalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_ceil_sd (__m128d a) - /// ROUNDSD xmm1, xmm2/m128, imm8(10) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(10) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_ceil_sd (__m128d a) + /// ROUNDSD xmm1, xmm2/m128, imm8(10) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(10) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 CeilingScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_ceil_sd (__m128d a, __m128d b) - /// ROUNDSD xmm1, xmm2/m128, imm8(10) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(10) + /// __m128d _mm_ceil_sd (__m128d a, __m128d b) + /// ROUNDSD xmm1, xmm2/m128, imm8(10) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(10) /// public static Vector128 CeilingScalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpeq_epi64 (__m128i a, __m128i b) - /// PCMPEQQ xmm1, xmm2/m128 - /// VPCMPEQQ xmm1, xmm2, xmm3/m128 + /// __m128i _mm_cmpeq_epi64 (__m128i a, __m128i b) + /// PCMPEQQ xmm1, xmm2/m128 + /// VPCMPEQQ xmm1, xmm2, xmm3/m128 /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cmpeq_epi64 (__m128i a, __m128i b) - /// PCMPEQQ xmm1, xmm2/m128 - /// VPCMPEQQ xmm1, xmm2, xmm3/m128 + /// __m128i _mm_cmpeq_epi64 (__m128i a, __m128i b) + /// PCMPEQQ xmm1, xmm2/m128 + /// VPCMPEQQ xmm1, xmm2, xmm3/m128 /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi8_epi16 (__m128i a) - /// PMOVSXBW xmm1, xmm2/m64 - /// VPMOVSXBW xmm1, xmm2/m64 - /// VPMOVSXBW xmm1 {k1}{z}, xmm2/m64 + /// __m128i _mm_cvtepi8_epi16 (__m128i a) + /// PMOVSXBW xmm1, xmm2/m64 + /// VPMOVSXBW xmm1, xmm2/m64 + /// VPMOVSXBW xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 ConvertToVector128Int16(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepu8_epi16 (__m128i a) - /// PMOVZXBW xmm1, xmm2/m64 - /// VPMOVZXBW xmm1, xmm2/m64 - /// VPMOVZXBW xmm1 {k1}{z}, xmm2/m64 + /// __m128i _mm_cvtepu8_epi16 (__m128i a) + /// PMOVZXBW xmm1, xmm2/m64 + /// VPMOVZXBW xmm1, xmm2/m64 + /// VPMOVZXBW xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 ConvertToVector128Int16(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi8_epi32 (__m128i a) - /// PMOVSXBD xmm1, xmm2/m32 - /// VPMOVSXBD xmm1, xmm2/m32 - /// VPMOVSXBD xmm1 {k1}{z}, xmm2/m32 + /// __m128i _mm_cvtepi8_epi32 (__m128i a) + /// PMOVSXBD xmm1, xmm2/m32 + /// VPMOVSXBD xmm1, xmm2/m32 + /// VPMOVSXBD xmm1 {k1}{z}, xmm2/m32 /// public static Vector128 ConvertToVector128Int32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepu8_epi32 (__m128i a) - /// PMOVZXBD xmm1, xmm2/m32 - /// VPMOVZXBD xmm1, xmm2/m32 - /// VPMOVZXBD xmm1 {k1}{z}, xmm2/m32 + /// __m128i _mm_cvtepu8_epi32 (__m128i a) + /// PMOVZXBD xmm1, xmm2/m32 + /// VPMOVZXBD xmm1, xmm2/m32 + /// VPMOVZXBD xmm1 {k1}{z}, xmm2/m32 /// public static Vector128 ConvertToVector128Int32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi16_epi32 (__m128i a) - /// PMOVSXWD xmm1, xmm2/m64 - /// VPMOVSXWD xmm1, xmm2/m64 - /// VPMOVSXWD xmm1 {k1}{z}, xmm2/m64 + /// __m128i _mm_cvtepi16_epi32 (__m128i a) + /// PMOVSXWD xmm1, xmm2/m64 + /// VPMOVSXWD xmm1, xmm2/m64 + /// VPMOVSXWD xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 ConvertToVector128Int32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepu16_epi32 (__m128i a) - /// PMOVZXWD xmm1, xmm2/m64 - /// VPMOVZXWD xmm1, xmm2/m64 - /// VPMOVZXWD xmm1 {k1}{z}, xmm2/m64 + /// __m128i _mm_cvtepu16_epi32 (__m128i a) + /// PMOVZXWD xmm1, xmm2/m64 + /// VPMOVZXWD xmm1, xmm2/m64 + /// VPMOVZXWD xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 ConvertToVector128Int32(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi8_epi64 (__m128i a) - /// PMOVSXBQ xmm1, xmm2/m16 - /// VPMOVSXBQ xmm1, xmm2/m16 - /// VPMOVSXBQ xmm1 {k1}{z}, xmm2/m16 + /// __m128i _mm_cvtepi8_epi64 (__m128i a) + /// PMOVSXBQ xmm1, xmm2/m16 + /// VPMOVSXBQ xmm1, xmm2/m16 + /// VPMOVSXBQ xmm1 {k1}{z}, xmm2/m16 /// public static Vector128 ConvertToVector128Int64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepu8_epi64 (__m128i a) - /// PMOVZXBQ xmm1, xmm2/m16 - /// VPMOVZXBQ xmm1, xmm2/m16 - /// VPMOVZXBQ xmm1 {k1}{z}, xmm2/m16 + /// __m128i _mm_cvtepu8_epi64 (__m128i a) + /// PMOVZXBQ xmm1, xmm2/m16 + /// VPMOVZXBQ xmm1, xmm2/m16 + /// VPMOVZXBQ xmm1 {k1}{z}, xmm2/m16 /// public static Vector128 ConvertToVector128Int64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi16_epi64 (__m128i a) - /// PMOVSXWQ xmm1, xmm2/m32 - /// VPMOVSXWQ xmm1, xmm2/m32 - /// VPMOVSXWQ xmm1 {k1}{z}, xmm2/m32 + /// __m128i _mm_cvtepi16_epi64 (__m128i a) + /// PMOVSXWQ xmm1, xmm2/m32 + /// VPMOVSXWQ xmm1, xmm2/m32 + /// VPMOVSXWQ xmm1 {k1}{z}, xmm2/m32 /// public static Vector128 ConvertToVector128Int64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepu16_epi64 (__m128i a) - /// PMOVZXWQ xmm1, xmm2/m32 - /// VPMOVZXWQ xmm1, xmm2/m32 - /// VPMOVZXWQ xmm1 {k1}{z}, xmm2/m32 + /// __m128i _mm_cvtepu16_epi64 (__m128i a) + /// PMOVZXWQ xmm1, xmm2/m32 + /// VPMOVZXWQ xmm1, xmm2/m32 + /// VPMOVZXWQ xmm1 {k1}{z}, xmm2/m32 /// public static Vector128 ConvertToVector128Int64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepi32_epi64 (__m128i a) - /// PMOVSXDQ xmm1, xmm2/m64 - /// VPMOVSXDQ xmm1, xmm2/m64 - /// VPMOVSXDQ xmm1 {k1}{z}, xmm2/m64 + /// __m128i _mm_cvtepi32_epi64 (__m128i a) + /// PMOVSXDQ xmm1, xmm2/m64 + /// VPMOVSXDQ xmm1, xmm2/m64 + /// VPMOVSXDQ xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 ConvertToVector128Int64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_cvtepu32_epi64 (__m128i a) - /// PMOVZXDQ xmm1, xmm2/m64 - /// VPMOVZXDQ xmm1, xmm2/m64 - /// VPMOVZXDQ xmm1 {k1}{z}, xmm2/m64 + /// __m128i _mm_cvtepu32_epi64 (__m128i a) + /// PMOVZXDQ xmm1, xmm2/m64 + /// VPMOVZXDQ xmm1, xmm2/m64 + /// VPMOVZXDQ xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 ConvertToVector128Int64(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// PMOVSXBW xmm1, m64 - /// VPMOVSXBW xmm1, m64 - /// VPMOVSXBW xmm1 {k1}{z}, m64 - /// The native signature does not exist. We provide this additional overload for completeness. + /// PMOVSXBW xmm1, m64 + /// VPMOVSXBW xmm1, m64 + /// VPMOVSXBW xmm1 {k1}{z}, m64 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector128 ConvertToVector128Int16(sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// PMOVZXBW xmm1, m64 - /// VPMOVZXBW xmm1, m64 - /// VPMOVZXBW xmm1 {k1}{z}, m64 - /// The native signature does not exist. We provide this additional overload for completeness. + /// PMOVZXBW xmm1, m64 + /// VPMOVZXBW xmm1, m64 + /// VPMOVZXBW xmm1 {k1}{z}, m64 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector128 ConvertToVector128Int16(byte* address) { throw new PlatformNotSupportedException(); } /// - /// PMOVSXBD xmm1, m32 - /// VPMOVSXBD xmm1, m32 - /// VPMOVSXBD xmm1 {k1}{z}, m32 - /// The native signature does not exist. We provide this additional overload for completeness. + /// PMOVSXBD xmm1, m32 + /// VPMOVSXBD xmm1, m32 + /// VPMOVSXBD xmm1 {k1}{z}, m32 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector128 ConvertToVector128Int32(sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// PMOVZXBD xmm1, m32 - /// VPMOVZXBD xmm1, m32 - /// VPMOVZXBD xmm1 {k1}{z}, m32 - /// The native signature does not exist. We provide this additional overload for completeness. + /// PMOVZXBD xmm1, m32 + /// VPMOVZXBD xmm1, m32 + /// VPMOVZXBD xmm1 {k1}{z}, m32 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector128 ConvertToVector128Int32(byte* address) { throw new PlatformNotSupportedException(); } /// - /// PMOVSXWD xmm1, m64 - /// VPMOVSXWD xmm1, m64 - /// VPMOVSXWD xmm1 {k1}{z}, m64 - /// The native signature does not exist. We provide this additional overload for completeness. + /// PMOVSXWD xmm1, m64 + /// VPMOVSXWD xmm1, m64 + /// VPMOVSXWD xmm1 {k1}{z}, m64 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector128 ConvertToVector128Int32(short* address) { throw new PlatformNotSupportedException(); } /// - /// PMOVZXWD xmm1, m64 - /// VPMOVZXWD xmm1, m64 - /// VPMOVZXWD xmm1 {k1}{z}, m64 - /// The native signature does not exist. We provide this additional overload for completeness. + /// PMOVZXWD xmm1, m64 + /// VPMOVZXWD xmm1, m64 + /// VPMOVZXWD xmm1 {k1}{z}, m64 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector128 ConvertToVector128Int32(ushort* address) { throw new PlatformNotSupportedException(); } /// - /// PMOVSXBQ xmm1, m16 - /// VPMOVSXBQ xmm1, m16 - /// VPMOVSXBQ xmm1 {k1}{z}, m16 - /// The native signature does not exist. We provide this additional overload for completeness. + /// PMOVSXBQ xmm1, m16 + /// VPMOVSXBQ xmm1, m16 + /// VPMOVSXBQ xmm1 {k1}{z}, m16 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector128 ConvertToVector128Int64(sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// PMOVZXBQ xmm1, m16 - /// VPMOVZXBQ xmm1, m16 - /// VPMOVZXBQ xmm1 {k1}{z}, m16 - /// The native signature does not exist. We provide this additional overload for completeness. + /// PMOVZXBQ xmm1, m16 + /// VPMOVZXBQ xmm1, m16 + /// VPMOVZXBQ xmm1 {k1}{z}, m16 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector128 ConvertToVector128Int64(byte* address) { throw new PlatformNotSupportedException(); } /// - /// PMOVSXWQ xmm1, m32 - /// VPMOVSXWQ xmm1, m32 - /// VPMOVSXWQ xmm1 {k1}{z}, m32 - /// The native signature does not exist. We provide this additional overload for completeness. + /// PMOVSXWQ xmm1, m32 + /// VPMOVSXWQ xmm1, m32 + /// VPMOVSXWQ xmm1 {k1}{z}, m32 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector128 ConvertToVector128Int64(short* address) { throw new PlatformNotSupportedException(); } /// - /// PMOVZXWQ xmm1, m32 - /// VPMOVZXWQ xmm1, m32 - /// VPMOVZXWQ xmm1 {k1}{z}, m32 - /// The native signature does not exist. We provide this additional overload for completeness. + /// PMOVZXWQ xmm1, m32 + /// VPMOVZXWQ xmm1, m32 + /// VPMOVZXWQ xmm1 {k1}{z}, m32 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector128 ConvertToVector128Int64(ushort* address) { throw new PlatformNotSupportedException(); } /// - /// PMOVSXDQ xmm1, m64 - /// VPMOVSXDQ xmm1, m64 - /// VPMOVSXDQ xmm1 {k1}{z}, m64 - /// The native signature does not exist. We provide this additional overload for completeness. + /// PMOVSXDQ xmm1, m64 + /// VPMOVSXDQ xmm1, m64 + /// VPMOVSXDQ xmm1 {k1}{z}, m64 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector128 ConvertToVector128Int64(int* address) { throw new PlatformNotSupportedException(); } /// - /// PMOVZXDQ xmm1, m64 - /// VPMOVZXDQ xmm1, m64 - /// VPMOVZXDQ xmm1 {k1}{z}, m64 - /// The native signature does not exist. We provide this additional overload for completeness. + /// PMOVZXDQ xmm1, m64 + /// VPMOVZXDQ xmm1, m64 + /// VPMOVZXDQ xmm1 {k1}{z}, m64 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector128 ConvertToVector128Int64(uint* address) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_dp_ps (__m128 a, __m128 b, const int imm8) - /// DPPS xmm1, xmm2/m128, imm8 - /// VDPPS xmm1, xmm2, xmm3/m128, imm8 + /// __m128 _mm_dp_ps (__m128 a, __m128 b, const int imm8) + /// DPPS xmm1, xmm2/m128, imm8 + /// VDPPS xmm1, xmm2, xmm3/m128, imm8 /// public static Vector128 DotProduct(Vector128 left, Vector128 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_dp_pd (__m128d a, __m128d b, const int imm8) - /// DPPD xmm1, xmm2/m128, imm8 - /// VDPPD xmm1, xmm2, xmm3/m128, imm8 + /// __m128d _mm_dp_pd (__m128d a, __m128d b, const int imm8) + /// DPPD xmm1, xmm2/m128, imm8 + /// VDPPD xmm1, xmm2, xmm3/m128, imm8 /// public static Vector128 DotProduct(Vector128 left, Vector128 right, [ConstantExpected] byte control) { throw new PlatformNotSupportedException(); } /// - /// int _mm_extract_epi8 (__m128i a, const int imm8) - /// PEXTRB r/m8, xmm1, imm8 - /// VPEXTRB r/m8, xmm1, imm8 + /// int _mm_extract_epi8 (__m128i a, const int imm8) + /// PEXTRB r/m8, xmm1, imm8 + /// VPEXTRB r/m8, xmm1, imm8 /// public static byte Extract(Vector128 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// int _mm_extract_epi32 (__m128i a, const int imm8) - /// PEXTRD r/m32, xmm1, imm8 - /// VPEXTRD r/m32, xmm1, imm8 + /// int _mm_extract_epi32 (__m128i a, const int imm8) + /// PEXTRD r/m32, xmm1, imm8 + /// VPEXTRD r/m32, xmm1, imm8 /// public static int Extract(Vector128 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// int _mm_extract_epi32 (__m128i a, const int imm8) - /// PEXTRD r/m32, xmm1, imm8 - /// VPEXTRD r/m32, xmm1, imm8 + /// int _mm_extract_epi32 (__m128i a, const int imm8) + /// PEXTRD r/m32, xmm1, imm8 + /// VPEXTRD r/m32, xmm1, imm8 /// public static uint Extract(Vector128 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// int _mm_extract_ps (__m128 a, const int imm8) - /// EXTRACTPS r/m32, xmm1, imm8 - /// VEXTRACTPS r/m32, xmm1, imm8 + /// int _mm_extract_ps (__m128 a, const int imm8) + /// EXTRACTPS r/m32, xmm1, imm8 + /// VEXTRACTPS r/m32, xmm1, imm8 /// public static float Extract(Vector128 value, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_floor_ps (__m128 a) - /// ROUNDPS xmm1, xmm2/m128, imm8(9) - /// VROUNDPS xmm1, xmm2/m128, imm8(9) + /// __m128 _mm_floor_ps (__m128 a) + /// ROUNDPS xmm1, xmm2/m128, imm8(9) + /// VROUNDPS xmm1, xmm2/m128, imm8(9) /// public static Vector128 Floor(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_floor_pd (__m128d a) - /// ROUNDPD xmm1, xmm2/m128, imm8(9) - /// VROUNDPD xmm1, xmm2/m128, imm8(9) + /// __m128d _mm_floor_pd (__m128d a) + /// ROUNDPD xmm1, xmm2/m128, imm8(9) + /// VROUNDPD xmm1, xmm2/m128, imm8(9) /// public static Vector128 Floor(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_floor_ss (__m128 a) - /// ROUNDSS xmm1, xmm2/m128, imm8(9) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(9) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_floor_ss (__m128 a) + /// ROUNDSS xmm1, xmm2/m128, imm8(9) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(9) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 FloorScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_floor_ss (__m128 a, __m128 b) - /// ROUNDSS xmm1, xmm2/m128, imm8(9) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(9) + /// __m128 _mm_floor_ss (__m128 a, __m128 b) + /// ROUNDSS xmm1, xmm2/m128, imm8(9) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(9) /// public static Vector128 FloorScalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_floor_sd (__m128d a) - /// ROUNDSD xmm1, xmm2/m128, imm8(9) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(9) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_floor_sd (__m128d a) + /// ROUNDSD xmm1, xmm2/m128, imm8(9) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(9) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 FloorScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_floor_sd (__m128d a, __m128d b) - /// ROUNDSD xmm1, xmm2/m128, imm8(9) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(9) + /// __m128d _mm_floor_sd (__m128d a, __m128d b) + /// ROUNDSD xmm1, xmm2/m128, imm8(9) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(9) /// public static Vector128 FloorScalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_insert_epi8 (__m128i a, int i, const int imm8) - /// PINSRB xmm1, r/m8, imm8 - /// VPINSRB xmm1, xmm2, r/m8, imm8 + /// __m128i _mm_insert_epi8 (__m128i a, int i, const int imm8) + /// PINSRB xmm1, r/m8, imm8 + /// VPINSRB xmm1, xmm2, r/m8, imm8 /// public static Vector128 Insert(Vector128 value, sbyte data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_insert_epi8 (__m128i a, int i, const int imm8) - /// PINSRB xmm1, r/m8, imm8 - /// VPINSRB xmm1, xmm2, r/m8, imm8 + /// __m128i _mm_insert_epi8 (__m128i a, int i, const int imm8) + /// PINSRB xmm1, r/m8, imm8 + /// VPINSRB xmm1, xmm2, r/m8, imm8 /// public static Vector128 Insert(Vector128 value, byte data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_insert_epi32 (__m128i a, int i, const int imm8) - /// PINSRD xmm1, r/m32, imm8 - /// VPINSRD xmm1, xmm2, r/m32, imm8 + /// __m128i _mm_insert_epi32 (__m128i a, int i, const int imm8) + /// PINSRD xmm1, r/m32, imm8 + /// VPINSRD xmm1, xmm2, r/m32, imm8 /// public static Vector128 Insert(Vector128 value, int data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_insert_epi32 (__m128i a, int i, const int imm8) - /// PINSRD xmm1, r/m32, imm8 - /// VPINSRD xmm1, xmm2, r/m32, imm8 + /// __m128i _mm_insert_epi32 (__m128i a, int i, const int imm8) + /// PINSRD xmm1, r/m32, imm8 + /// VPINSRD xmm1, xmm2, r/m32, imm8 /// public static Vector128 Insert(Vector128 value, uint data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_insert_ps (__m128 a, __m128 b, const int imm8) - /// INSERTPS xmm1, xmm2/m32, imm8 - /// VINSERTPS xmm1, xmm2, xmm3/m32, imm8 + /// __m128 _mm_insert_ps (__m128 a, __m128 b, const int imm8) + /// INSERTPS xmm1, xmm2/m32, imm8 + /// VINSERTPS xmm1, xmm2, xmm3/m32, imm8 /// public static Vector128 Insert(Vector128 value, Vector128 data, [ConstantExpected] byte index) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) - /// MOVNTDQA xmm1, m128 - /// VMOVNTDQA xmm1, m128 + /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) + /// MOVNTDQA xmm1, m128 + /// VMOVNTDQA xmm1, m128 /// public static unsafe Vector128 LoadAlignedVector128NonTemporal(sbyte* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) - /// MOVNTDQA xmm1, m128 - /// VMOVNTDQA xmm1, m128 + /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) + /// MOVNTDQA xmm1, m128 + /// VMOVNTDQA xmm1, m128 /// public static unsafe Vector128 LoadAlignedVector128NonTemporal(byte* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) - /// MOVNTDQA xmm1, m128 - /// VMOVNTDQA xmm1, m128 + /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) + /// MOVNTDQA xmm1, m128 + /// VMOVNTDQA xmm1, m128 /// public static unsafe Vector128 LoadAlignedVector128NonTemporal(short* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) - /// MOVNTDQA xmm1, m128 - /// VMOVNTDQA xmm1, m128 + /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) + /// MOVNTDQA xmm1, m128 + /// VMOVNTDQA xmm1, m128 /// public static unsafe Vector128 LoadAlignedVector128NonTemporal(ushort* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) - /// MOVNTDQA xmm1, m128 - /// VMOVNTDQA xmm1, m128 + /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) + /// MOVNTDQA xmm1, m128 + /// VMOVNTDQA xmm1, m128 /// public static unsafe Vector128 LoadAlignedVector128NonTemporal(int* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) - /// MOVNTDQA xmm1, m128 - /// VMOVNTDQA xmm1, m128 + /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) + /// MOVNTDQA xmm1, m128 + /// VMOVNTDQA xmm1, m128 /// public static unsafe Vector128 LoadAlignedVector128NonTemporal(uint* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) - /// MOVNTDQA xmm1, m128 - /// VMOVNTDQA xmm1, m128 + /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) + /// MOVNTDQA xmm1, m128 + /// VMOVNTDQA xmm1, m128 /// public static unsafe Vector128 LoadAlignedVector128NonTemporal(long* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) - /// MOVNTDQA xmm1, m128 - /// VMOVNTDQA xmm1, m128 + /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) + /// MOVNTDQA xmm1, m128 + /// VMOVNTDQA xmm1, m128 /// public static unsafe Vector128 LoadAlignedVector128NonTemporal(ulong* address) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_max_epi8 (__m128i a, __m128i b) - /// PMAXSB xmm1, xmm2/m128 - /// VPMAXSB xmm1, xmm2, xmm3/m128 - /// VPMAXSB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_max_epi8 (__m128i a, __m128i b) + /// PMAXSB xmm1, xmm2/m128 + /// VPMAXSB xmm1, xmm2, xmm3/m128 + /// VPMAXSB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_max_epu16 (__m128i a, __m128i b) - /// PMAXUW xmm1, xmm2/m128 - /// VPMAXUW xmm1, xmm2, xmm3/m128 - /// VPMAXUW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_max_epu16 (__m128i a, __m128i b) + /// PMAXUW xmm1, xmm2/m128 + /// VPMAXUW xmm1, xmm2, xmm3/m128 + /// VPMAXUW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_max_epi32 (__m128i a, __m128i b) - /// PMAXSD xmm1, xmm2/m128 - /// VPMAXSD xmm1, xmm2, xmm3/m128 - /// VPMAXSD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_max_epi32 (__m128i a, __m128i b) + /// PMAXSD xmm1, xmm2/m128 + /// VPMAXSD xmm1, xmm2, xmm3/m128 + /// VPMAXSD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_max_epu32 (__m128i a, __m128i b) - /// PMAXUD xmm1, xmm2/m128 - /// VPMAXUD xmm1, xmm2, xmm3/m128 - /// VPMAXUD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_max_epu32 (__m128i a, __m128i b) + /// PMAXUD xmm1, xmm2/m128 + /// VPMAXUD xmm1, xmm2, xmm3/m128 + /// VPMAXUD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Max(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_min_epi8 (__m128i a, __m128i b) - /// PMINSB xmm1, xmm2/m128 - /// VPMINSB xmm1, xmm2, xmm3/m128 - /// VPMINSB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_min_epi8 (__m128i a, __m128i b) + /// PMINSB xmm1, xmm2/m128 + /// VPMINSB xmm1, xmm2, xmm3/m128 + /// VPMINSB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_min_epu16 (__m128i a, __m128i b) - /// PMINUW xmm1, xmm2/m128 - /// VPMINUW xmm1, xmm2, xmm3/m128 - /// VPMINUW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_min_epu16 (__m128i a, __m128i b) + /// PMINUW xmm1, xmm2/m128 + /// VPMINUW xmm1, xmm2, xmm3/m128 + /// VPMINUW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_min_epi32 (__m128i a, __m128i b) - /// PMINSD xmm1, xmm2/m128 - /// VPMINSD xmm1, xmm2, xmm3/m128 - /// VPMINSD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_min_epi32 (__m128i a, __m128i b) + /// PMINSD xmm1, xmm2/m128 + /// VPMINSD xmm1, xmm2, xmm3/m128 + /// VPMINSD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_min_epu32 (__m128i a, __m128i b) - /// PMINUD xmm1, xmm2/m128 - /// VPMINUD xmm1, xmm2, xmm3/m128 - /// VPMINUD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_min_epu32 (__m128i a, __m128i b) + /// PMINUD xmm1, xmm2/m128 + /// VPMINUD xmm1, xmm2, xmm3/m128 + /// VPMINUD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Min(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_minpos_epu16 (__m128i a) - /// PHMINPOSUW xmm1, xmm2/m128 - /// VPHMINPOSUW xmm1, xmm2/m128 + /// __m128i _mm_minpos_epu16 (__m128i a) + /// PHMINPOSUW xmm1, xmm2/m128 + /// VPHMINPOSUW xmm1, xmm2/m128 /// public static Vector128 MinHorizontal(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_mpsadbw_epu8 (__m128i a, __m128i b, const int imm8) - /// MPSADBW xmm1, xmm2/m128, imm8 - /// VMPSADBW xmm1, xmm2, xmm3/m128, imm8 + /// __m128i _mm_mpsadbw_epu8 (__m128i a, __m128i b, const int imm8) + /// MPSADBW xmm1, xmm2/m128, imm8 + /// VMPSADBW xmm1, xmm2, xmm3/m128, imm8 /// public static Vector128 MultipleSumAbsoluteDifferences(Vector128 left, Vector128 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_mul_epi32 (__m128i a, __m128i b) - /// PMULDQ xmm1, xmm2/m128 - /// VPMULDQ xmm1, xmm2, xmm3/m128 - /// VPMULDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_mul_epi32 (__m128i a, __m128i b) + /// PMULDQ xmm1, xmm2/m128 + /// VPMULDQ xmm1, xmm2, xmm3/m128 + /// VPMULDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Multiply(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_mullo_epi32 (__m128i a, __m128i b) - /// PMULLD xmm1, xmm2/m128 - /// VPMULLD xmm1, xmm2, xmm3/m128 - /// VPMULLD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_mullo_epi32 (__m128i a, __m128i b) + /// PMULLD xmm1, xmm2/m128 + /// VPMULLD xmm1, xmm2, xmm3/m128 + /// VPMULLD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 MultiplyLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_mullo_epi32 (__m128i a, __m128i b) - /// PMULLD xmm1, xmm2/m128 - /// VPMULLD xmm1, xmm2, xmm3/m128 - /// VPMULLD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_mullo_epi32 (__m128i a, __m128i b) + /// PMULLD xmm1, xmm2/m128 + /// VPMULLD xmm1, xmm2, xmm3/m128 + /// VPMULLD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 MultiplyLow(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_packus_epi32 (__m128i a, __m128i b) - /// PACKUSDW xmm1, xmm2/m128 - /// VPACKUSDW xmm1, xmm2, xmm3/m128 - /// VPACKUSDW xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_packus_epi32 (__m128i a, __m128i b) + /// PACKUSDW xmm1, xmm2/m128 + /// VPACKUSDW xmm1, xmm2, xmm3/m128 + /// VPACKUSDW xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 PackUnsignedSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_round_ps (__m128 a, _MM_FROUND_CUR_DIRECTION) - /// ROUNDPS xmm1, xmm2/m128, imm8(4) - /// VROUNDPS xmm1, xmm2/m128, imm8(4) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ps (__m128 a, _MM_FROUND_CUR_DIRECTION) + /// ROUNDPS xmm1, xmm2/m128, imm8(4) + /// VROUNDPS xmm1, xmm2/m128, imm8(4) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundCurrentDirection(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_round_pd (__m128d a, _MM_FROUND_CUR_DIRECTION) - /// ROUNDPD xmm1, xmm2/m128, imm8(4) - /// VROUNDPD xmm1, xmm2/m128, imm8(4) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_round_pd (__m128d a, _MM_FROUND_CUR_DIRECTION) + /// ROUNDPD xmm1, xmm2/m128, imm8(4) + /// VROUNDPD xmm1, xmm2/m128, imm8(4) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundCurrentDirection(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_round_ss (__m128 a, _MM_FROUND_CUR_DIRECTION) - /// ROUNDSS xmm1, xmm2/m128, imm8(4) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(4) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ss (__m128 a, _MM_FROUND_CUR_DIRECTION) + /// ROUNDSS xmm1, xmm2/m128, imm8(4) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(4) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundCurrentDirectionScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_CUR_DIRECTION) - /// ROUNDSS xmm1, xmm2/m128, imm8(4) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(4) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_CUR_DIRECTION) + /// ROUNDSS xmm1, xmm2/m128, imm8(4) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(4) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundCurrentDirectionScalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_round_sd (__m128d a, _MM_FROUND_CUR_DIRECTION) - /// ROUNDSD xmm1, xmm2/m128, imm8(4) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(4) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_round_sd (__m128d a, _MM_FROUND_CUR_DIRECTION) + /// ROUNDSD xmm1, xmm2/m128, imm8(4) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(4) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundCurrentDirectionScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_CUR_DIRECTION) - /// ROUNDSD xmm1, xmm2/m128, imm8(4) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(4) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_CUR_DIRECTION) + /// ROUNDSD xmm1, xmm2/m128, imm8(4) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(4) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundCurrentDirectionScalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_round_ps (__m128 a, _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC) - /// ROUNDPS xmm1, xmm2/m128, imm8(8) - /// VROUNDPS xmm1, xmm2/m128, imm8(8) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ps (__m128 a, _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC) + /// ROUNDPS xmm1, xmm2/m128, imm8(8) + /// VROUNDPS xmm1, xmm2/m128, imm8(8) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToNearestInteger(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_round_pd (__m128 a, _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC) - /// ROUNDPD xmm1, xmm2/m128, imm8(8) - /// VROUNDPD xmm1, xmm2/m128, imm8(8) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_pd (__m128 a, _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC) + /// ROUNDPD xmm1, xmm2/m128, imm8(8) + /// VROUNDPD xmm1, xmm2/m128, imm8(8) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToNearestInteger(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_round_ss (__m128 a, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) - /// ROUNDSS xmm1, xmm2/m128, imm8(8) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(8) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ss (__m128 a, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) + /// ROUNDSS xmm1, xmm2/m128, imm8(8) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(8) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToNearestIntegerScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) - /// ROUNDSS xmm1, xmm2/m128, imm8(8) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(8) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) + /// ROUNDSS xmm1, xmm2/m128, imm8(8) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(8) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToNearestIntegerScalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_round_sd (__m128d a, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) - /// ROUNDSD xmm1, xmm2/m128, imm8(8) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(8) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_round_sd (__m128d a, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) + /// ROUNDSD xmm1, xmm2/m128, imm8(8) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(8) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToNearestIntegerScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) - /// ROUNDSD xmm1, xmm2/m128, imm8(8) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(8) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) + /// ROUNDSD xmm1, xmm2/m128, imm8(8) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(8) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToNearestIntegerScalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_round_ps (__m128 a, _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC) - /// ROUNDPS xmm1, xmm2/m128, imm8(9) - /// VROUNDPS xmm1, xmm2/m128, imm8(9) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ps (__m128 a, _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC) + /// ROUNDPS xmm1, xmm2/m128, imm8(9) + /// VROUNDPS xmm1, xmm2/m128, imm8(9) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToNegativeInfinity(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_round_pd (__m128 a, _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC) - /// ROUNDPD xmm1, xmm2/m128, imm8(9) - /// VROUNDPD xmm1, xmm2/m128, imm8(9) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_pd (__m128 a, _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC) + /// ROUNDPD xmm1, xmm2/m128, imm8(9) + /// VROUNDPD xmm1, xmm2/m128, imm8(9) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToNegativeInfinity(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_round_ss (__m128 a, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) - /// ROUNDSS xmm1, xmm2/m128, imm8(9) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(9) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ss (__m128 a, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) + /// ROUNDSS xmm1, xmm2/m128, imm8(9) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(9) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToNegativeInfinityScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) - /// ROUNDSS xmm1, xmm2/m128, imm8(9) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(9) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) + /// ROUNDSS xmm1, xmm2/m128, imm8(9) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(9) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToNegativeInfinityScalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_round_sd (__m128d a, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) - /// ROUNDSD xmm1, xmm2/m128, imm8(9) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(9) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_round_sd (__m128d a, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) + /// ROUNDSD xmm1, xmm2/m128, imm8(9) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(9) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToNegativeInfinityScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) - /// ROUNDSD xmm1, xmm2/m128, imm8(9) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(9) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) + /// ROUNDSD xmm1, xmm2/m128, imm8(9) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(9) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToNegativeInfinityScalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_round_ps (__m128 a, _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC) - /// ROUNDPS xmm1, xmm2/m128, imm8(10) - /// VROUNDPS xmm1, xmm2/m128, imm8(10) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ps (__m128 a, _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC) + /// ROUNDPS xmm1, xmm2/m128, imm8(10) + /// VROUNDPS xmm1, xmm2/m128, imm8(10) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToPositiveInfinity(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_round_pd (__m128 a, _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC) - /// ROUNDPD xmm1, xmm2/m128, imm8(10) - /// VROUNDPD xmm1, xmm2/m128, imm8(10) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_pd (__m128 a, _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC) + /// ROUNDPD xmm1, xmm2/m128, imm8(10) + /// VROUNDPD xmm1, xmm2/m128, imm8(10) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToPositiveInfinity(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_round_ss (__m128 a, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) - /// ROUNDSS xmm1, xmm2/m128, imm8(10) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(10) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ss (__m128 a, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) + /// ROUNDSS xmm1, xmm2/m128, imm8(10) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(10) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToPositiveInfinityScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) - /// ROUNDSS xmm1, xmm2/m128, imm8(10) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(10) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) + /// ROUNDSS xmm1, xmm2/m128, imm8(10) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(10) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToPositiveInfinityScalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_round_sd (__m128d a, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) - /// ROUNDSD xmm1, xmm2/m128, imm8(10) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(10) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_round_sd (__m128d a, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) + /// ROUNDSD xmm1, xmm2/m128, imm8(10) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(10) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToPositiveInfinityScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) - /// ROUNDSD xmm1, xmm2/m128, imm8(10) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(10) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) + /// ROUNDSD xmm1, xmm2/m128, imm8(10) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(10) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToPositiveInfinityScalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_round_ps (__m128 a, _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC) - /// ROUNDPS xmm1, xmm2/m128, imm8(11) - /// VROUNDPS xmm1, xmm2/m128, imm8(11) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ps (__m128 a, _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC) + /// ROUNDPS xmm1, xmm2/m128, imm8(11) + /// VROUNDPS xmm1, xmm2/m128, imm8(11) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToZero(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_round_pd (__m128 a, _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC) - /// ROUNDPD xmm1, xmm2/m128, imm8(11) - /// VROUNDPD xmm1, xmm2/m128, imm8(11) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_pd (__m128 a, _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC) + /// ROUNDPD xmm1, xmm2/m128, imm8(11) + /// VROUNDPD xmm1, xmm2/m128, imm8(11) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToZero(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_round_ss (__m128 a, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) - /// ROUNDSS xmm1, xmm2/m128, imm8(11) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(11) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ss (__m128 a, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) + /// ROUNDSS xmm1, xmm2/m128, imm8(11) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(11) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToZeroScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) - /// ROUNDSS xmm1, xmm2/m128, imm8(11) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(11) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) + /// ROUNDSS xmm1, xmm2/m128, imm8(11) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(11) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToZeroScalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_round_sd (__m128d a, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) - /// ROUNDSD xmm1, xmm2/m128, imm8(11) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(11) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_round_sd (__m128d a, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) + /// ROUNDSD xmm1, xmm2/m128, imm8(11) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(11) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToZeroScalar(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128d _mm_round_sd (__m128d a, __m128 b, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) - /// ROUNDSD xmm1, xmm2/m128, imm8(11) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(11) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_round_sd (__m128d a, __m128 b, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) + /// ROUNDSD xmm1, xmm2/m128, imm8(11) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(11) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToZeroScalar(Vector128 upper, Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; CF=1 - /// VPTEST xmm1, xmm2/m128 ; CF=1 + /// int _mm_testc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; CF=1 + /// VPTEST xmm1, xmm2/m128 ; CF=1 /// public static bool TestC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; CF=1 - /// VPTEST xmm1, xmm2/m128 ; CF=1 + /// int _mm_testc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; CF=1 + /// VPTEST xmm1, xmm2/m128 ; CF=1 /// public static bool TestC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; CF=1 - /// VPTEST xmm1, xmm2/m128 ; CF=1 + /// int _mm_testc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; CF=1 + /// VPTEST xmm1, xmm2/m128 ; CF=1 /// public static bool TestC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; CF=1 - /// VPTEST xmm1, xmm2/m128 ; CF=1 + /// int _mm_testc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; CF=1 + /// VPTEST xmm1, xmm2/m128 ; CF=1 /// public static bool TestC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; CF=1 - /// VPTEST xmm1, xmm2/m128 ; CF=1 + /// int _mm_testc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; CF=1 + /// VPTEST xmm1, xmm2/m128 ; CF=1 /// public static bool TestC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; CF=1 - /// VPTEST xmm1, xmm2/m128 ; CF=1 + /// int _mm_testc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; CF=1 + /// VPTEST xmm1, xmm2/m128 ; CF=1 /// public static bool TestC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; CF=1 - /// VPTEST xmm1, xmm2/m128 ; CF=1 + /// int _mm_testc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; CF=1 + /// VPTEST xmm1, xmm2/m128 ; CF=1 /// public static bool TestC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; CF=1 - /// VPTEST xmm1, xmm2/m128 ; CF=1 + /// int _mm_testc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; CF=1 + /// VPTEST xmm1, xmm2/m128 ; CF=1 /// public static bool TestC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testnzc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 - /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// int _mm_testnzc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testnzc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 - /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// int _mm_testnzc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testnzc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 - /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// int _mm_testnzc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testnzc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 - /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// int _mm_testnzc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testnzc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 - /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// int _mm_testnzc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testnzc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 - /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// int _mm_testnzc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testnzc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 - /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// int _mm_testnzc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testnzc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 - /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// int _mm_testnzc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testz_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=1 - /// VPTEST xmm1, xmm2/m128 ; ZF=1 + /// int _mm_testz_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=1 + /// VPTEST xmm1, xmm2/m128 ; ZF=1 /// public static bool TestZ(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testz_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=1 - /// VPTEST xmm1, xmm2/m128 ; ZF=1 + /// int _mm_testz_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=1 + /// VPTEST xmm1, xmm2/m128 ; ZF=1 /// public static bool TestZ(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testz_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=1 - /// VPTEST xmm1, xmm2/m128 ; ZF=1 + /// int _mm_testz_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=1 + /// VPTEST xmm1, xmm2/m128 ; ZF=1 /// public static bool TestZ(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testz_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=1 - /// VPTEST xmm1, xmm2/m128 ; ZF=1 + /// int _mm_testz_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=1 + /// VPTEST xmm1, xmm2/m128 ; ZF=1 /// public static bool TestZ(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testz_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=1 - /// VPTEST xmm1, xmm2/m128 ; ZF=1 + /// int _mm_testz_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=1 + /// VPTEST xmm1, xmm2/m128 ; ZF=1 /// public static bool TestZ(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testz_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=1 - /// VPTEST xmm1, xmm2/m128 ; ZF=1 + /// int _mm_testz_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=1 + /// VPTEST xmm1, xmm2/m128 ; ZF=1 /// public static bool TestZ(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testz_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=1 - /// VPTEST xmm1, xmm2/m128 ; ZF=1 + /// int _mm_testz_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=1 + /// VPTEST xmm1, xmm2/m128 ; ZF=1 /// public static bool TestZ(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// int _mm_testz_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=1 - /// VPTEST xmm1, xmm2/m128 ; ZF=1 + /// int _mm_testz_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=1 + /// VPTEST xmm1, xmm2/m128 ; ZF=1 /// public static bool TestZ(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse41.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse41.cs index b69727e61c7..fa05c404fa6 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse41.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse41.cs @@ -6,995 +6,1000 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel SSE4.1 hardware instructions via intrinsics - /// + /// Provides access to X86 SSE4.1 hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Sse41 : Ssse3 { internal Sse41() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the x86 SSE4.1 hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : Ssse3.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } /// - /// __int64 _mm_extract_epi64 (__m128i a, const int imm8) - /// PEXTRQ r/m64, xmm1, imm8 - /// VPEXTRQ r/m64, xmm1, imm8 - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_extract_epi64 (__m128i a, const int imm8) + /// PEXTRQ r/m64, xmm1, imm8 + /// VPEXTRQ r/m64, xmm1, imm8 + /// This intrinsic is only available on 64-bit processes /// public static long Extract(Vector128 value, [ConstantExpected] byte index) => Extract(value, index); /// - /// __int64 _mm_extract_epi64 (__m128i a, const int imm8) - /// PEXTRQ r/m64, xmm1, imm8 - /// VPEXTRQ r/m64, xmm1, imm8 - /// This intrinsic is only available on 64-bit processes + /// __int64 _mm_extract_epi64 (__m128i a, const int imm8) + /// PEXTRQ r/m64, xmm1, imm8 + /// VPEXTRQ r/m64, xmm1, imm8 + /// This intrinsic is only available on 64-bit processes /// public static ulong Extract(Vector128 value, [ConstantExpected] byte index) => Extract(value, index); /// - /// __m128i _mm_insert_epi64 (__m128i a, __int64 i, const int imm8) - /// PINSRQ xmm1, r/m64, imm8 - /// VPINSRQ xmm1, xmm2, r/m64, imm8 - /// This intrinsic is only available on 64-bit processes + /// __m128i _mm_insert_epi64 (__m128i a, __int64 i, const int imm8) + /// PINSRQ xmm1, r/m64, imm8 + /// VPINSRQ xmm1, xmm2, r/m64, imm8 + /// This intrinsic is only available on 64-bit processes /// public static Vector128 Insert(Vector128 value, long data, [ConstantExpected] byte index) => Insert(value, data, index); /// - /// __m128i _mm_insert_epi64 (__m128i a, __int64 i, const int imm8) - /// PINSRQ xmm1, r/m64, imm8 - /// VPINSRQ xmm1, xmm2, r/m64, imm8 - /// This intrinsic is only available on 64-bit processes + /// __m128i _mm_insert_epi64 (__m128i a, __int64 i, const int imm8) + /// PINSRQ xmm1, r/m64, imm8 + /// VPINSRQ xmm1, xmm2, r/m64, imm8 + /// This intrinsic is only available on 64-bit processes /// public static Vector128 Insert(Vector128 value, ulong data, [ConstantExpected] byte index) => Insert(value, data, index); } /// - /// __m128i _mm_blend_epi16 (__m128i a, __m128i b, const int imm8) - /// PBLENDW xmm1, xmm2/m128 imm8 - /// VPBLENDW xmm1, xmm2, xmm3/m128 imm8 + /// __m128i _mm_blend_epi16 (__m128i a, __m128i b, const int imm8) + /// PBLENDW xmm1, xmm2/m128 imm8 + /// VPBLENDW xmm1, xmm2, xmm3/m128 imm8 /// public static Vector128 Blend(Vector128 left, Vector128 right, [ConstantExpected] byte control) => Blend(left, right, control); /// - /// __m128i _mm_blend_epi16 (__m128i a, __m128i b, const int imm8) - /// PBLENDW xmm1, xmm2/m128 imm8 - /// VPBLENDW xmm1, xmm2, xmm3/m128 imm8 + /// __m128i _mm_blend_epi16 (__m128i a, __m128i b, const int imm8) + /// PBLENDW xmm1, xmm2/m128 imm8 + /// VPBLENDW xmm1, xmm2, xmm3/m128 imm8 /// public static Vector128 Blend(Vector128 left, Vector128 right, [ConstantExpected] byte control) => Blend(left, right, control); /// - /// __m128 _mm_blend_ps (__m128 a, __m128 b, const int imm8) - /// BLENDPS xmm1, xmm2/m128, imm8 - /// VBLENDPS xmm1, xmm2, xmm3/m128, imm8 + /// __m128 _mm_blend_ps (__m128 a, __m128 b, const int imm8) + /// BLENDPS xmm1, xmm2/m128, imm8 + /// VBLENDPS xmm1, xmm2, xmm3/m128, imm8 /// public static Vector128 Blend(Vector128 left, Vector128 right, [ConstantExpected] byte control) => Blend(left, right, control); /// - /// __m128d _mm_blend_pd (__m128d a, __m128d b, const int imm8) - /// BLENDPD xmm1, xmm2/m128, imm8 - /// VBLENDPD xmm1, xmm2, xmm3/m128, imm8 + /// __m128d _mm_blend_pd (__m128d a, __m128d b, const int imm8) + /// BLENDPD xmm1, xmm2/m128, imm8 + /// VBLENDPD xmm1, xmm2, xmm3/m128, imm8 /// public static Vector128 Blend(Vector128 left, Vector128 right, [ConstantExpected] byte control) => Blend(left, right, control); /// - /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) - /// PBLENDVB xmm1, xmm2/m128, <XMM0> - /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 + /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) + /// PBLENDVB xmm1, xmm2/m128, <XMM0> + /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 /// public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) => BlendVariable(left, right, mask); /// - /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) - /// PBLENDVB xmm1, xmm2/m128, <XMM0> - /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 + /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) + /// PBLENDVB xmm1, xmm2/m128, <XMM0> + /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 /// public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) => BlendVariable(left, right, mask); /// - /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) - /// PBLENDVB xmm1, xmm2/m128, <XMM0> - /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 - /// This intrinsic generates PBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. + /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) + /// PBLENDVB xmm1, xmm2/m128, <XMM0> + /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 + /// This intrinsic generates PBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. /// public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) => BlendVariable(left, right, mask); /// - /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) - /// PBLENDVB xmm1, xmm2/m128, <XMM0> - /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 - /// This intrinsic generates PBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. + /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) + /// PBLENDVB xmm1, xmm2/m128, <XMM0> + /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 + /// This intrinsic generates PBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. /// public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) => BlendVariable(left, right, mask); /// - /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) - /// PBLENDVB xmm1, xmm2/m128, <XMM0> - /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 - /// This intrinsic generates PBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. + /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) + /// PBLENDVB xmm1, xmm2/m128, <XMM0> + /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 + /// This intrinsic generates PBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. /// public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) => BlendVariable(left, right, mask); /// - /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) - /// PBLENDVB xmm1, xmm2/m128, <XMM0> - /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 - /// This intrinsic generates PBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. + /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) + /// PBLENDVB xmm1, xmm2/m128, <XMM0> + /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 + /// This intrinsic generates PBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. /// public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) => BlendVariable(left, right, mask); /// - /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) - /// PBLENDVB xmm1, xmm2/m128, <XMM0> - /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 - /// This intrinsic generates PBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. + /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) + /// PBLENDVB xmm1, xmm2/m128, <XMM0> + /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 + /// This intrinsic generates PBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. /// public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) => BlendVariable(left, right, mask); /// - /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) - /// PBLENDVB xmm1, xmm2/m128, <XMM0> - /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 - /// This intrinsic generates PBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. + /// __m128i _mm_blendv_epi8 (__m128i a, __m128i b, __m128i mask) + /// PBLENDVB xmm1, xmm2/m128, <XMM0> + /// VPBLENDVB xmm1, xmm2, xmm3/m128, xmm4 + /// This intrinsic generates PBLENDVB that needs a BYTE mask-vector, so users should correctly set each mask byte for the selected elements. /// public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) => BlendVariable(left, right, mask); /// - /// __m128 _mm_blendv_ps (__m128 a, __m128 b, __m128 mask) - /// BLENDVPS xmm1, xmm2/m128, <XMM0> - /// VBLENDVPS xmm1, xmm2, xmm3/m128, xmm4 + /// __m128 _mm_blendv_ps (__m128 a, __m128 b, __m128 mask) + /// BLENDVPS xmm1, xmm2/m128, <XMM0> + /// VBLENDVPS xmm1, xmm2, xmm3/m128, xmm4 /// public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) => BlendVariable(left, right, mask); /// - /// __m128d _mm_blendv_pd (__m128d a, __m128d b, __m128d mask) - /// BLENDVPD xmm1, xmm2/m128, <XMM0> - /// VBLENDVPD xmm1, xmm2, xmm3/m128, xmm4 + /// __m128d _mm_blendv_pd (__m128d a, __m128d b, __m128d mask) + /// BLENDVPD xmm1, xmm2/m128, <XMM0> + /// VBLENDVPD xmm1, xmm2, xmm3/m128, xmm4 /// public static Vector128 BlendVariable(Vector128 left, Vector128 right, Vector128 mask) => BlendVariable(left, right, mask); /// - /// __m128 _mm_ceil_ps (__m128 a) - /// ROUNDPS xmm1, xmm2/m128, imm8(10) - /// VROUNDPS xmm1, xmm2/m128, imm8(10) + /// __m128 _mm_ceil_ps (__m128 a) + /// ROUNDPS xmm1, xmm2/m128, imm8(10) + /// VROUNDPS xmm1, xmm2/m128, imm8(10) /// public static Vector128 Ceiling(Vector128 value) => Ceiling(value); /// - /// __m128d _mm_ceil_pd (__m128d a) - /// ROUNDPD xmm1, xmm2/m128, imm8(10) - /// VROUNDPD xmm1, xmm2/m128, imm8(10) + /// __m128d _mm_ceil_pd (__m128d a) + /// ROUNDPD xmm1, xmm2/m128, imm8(10) + /// VROUNDPD xmm1, xmm2/m128, imm8(10) /// public static Vector128 Ceiling(Vector128 value) => Ceiling(value); /// - /// __m128 _mm_ceil_ss (__m128 a) - /// ROUNDSS xmm1, xmm2/m128, imm8(10) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(10) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_ceil_ss (__m128 a) + /// ROUNDSS xmm1, xmm2/m128, imm8(10) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(10) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 CeilingScalar(Vector128 value) => CeilingScalar(value); /// - /// __m128 _mm_ceil_ss (__m128 a, __m128 b) - /// ROUNDSS xmm1, xmm2/m128, imm8(10) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(10) + /// __m128 _mm_ceil_ss (__m128 a, __m128 b) + /// ROUNDSS xmm1, xmm2/m128, imm8(10) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(10) /// public static Vector128 CeilingScalar(Vector128 upper, Vector128 value) => CeilingScalar(upper, value); /// - /// __m128d _mm_ceil_sd (__m128d a) - /// ROUNDSD xmm1, xmm2/m128, imm8(10) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(10) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_ceil_sd (__m128d a) + /// ROUNDSD xmm1, xmm2/m128, imm8(10) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(10) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 CeilingScalar(Vector128 value) => CeilingScalar(value); /// - /// __m128d _mm_ceil_sd (__m128d a, __m128d b) - /// ROUNDSD xmm1, xmm2/m128, imm8(10) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(10) + /// __m128d _mm_ceil_sd (__m128d a, __m128d b) + /// ROUNDSD xmm1, xmm2/m128, imm8(10) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(10) /// public static Vector128 CeilingScalar(Vector128 upper, Vector128 value) => CeilingScalar(upper, value); /// - /// __m128i _mm_cmpeq_epi64 (__m128i a, __m128i b) - /// PCMPEQQ xmm1, xmm2/m128 - /// VPCMPEQQ xmm1, xmm2, xmm3/m128 + /// __m128i _mm_cmpeq_epi64 (__m128i a, __m128i b) + /// PCMPEQQ xmm1, xmm2/m128 + /// VPCMPEQQ xmm1, xmm2, xmm3/m128 /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// - /// __m128i _mm_cmpeq_epi64 (__m128i a, __m128i b) - /// PCMPEQQ xmm1, xmm2/m128 - /// VPCMPEQQ xmm1, xmm2, xmm3/m128 + /// __m128i _mm_cmpeq_epi64 (__m128i a, __m128i b) + /// PCMPEQQ xmm1, xmm2/m128 + /// VPCMPEQQ xmm1, xmm2, xmm3/m128 /// public static Vector128 CompareEqual(Vector128 left, Vector128 right) => CompareEqual(left, right); /// - /// __m128i _mm_cvtepi8_epi16 (__m128i a) - /// PMOVSXBW xmm1, xmm2/m64 - /// VPMOVSXBW xmm1, xmm2/m64 - /// VPMOVSXBW xmm1 {k1}{z}, xmm2/m64 + /// __m128i _mm_cvtepi8_epi16 (__m128i a) + /// PMOVSXBW xmm1, xmm2/m64 + /// VPMOVSXBW xmm1, xmm2/m64 + /// VPMOVSXBW xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 ConvertToVector128Int16(Vector128 value) => ConvertToVector128Int16(value); /// - /// __m128i _mm_cvtepu8_epi16 (__m128i a) - /// PMOVZXBW xmm1, xmm2/m64 - /// VPMOVZXBW xmm1, xmm2/m64 - /// VPMOVZXBW xmm1 {k1}{z}, xmm2/m64 + /// __m128i _mm_cvtepu8_epi16 (__m128i a) + /// PMOVZXBW xmm1, xmm2/m64 + /// VPMOVZXBW xmm1, xmm2/m64 + /// VPMOVZXBW xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 ConvertToVector128Int16(Vector128 value) => ConvertToVector128Int16(value); /// - /// __m128i _mm_cvtepi8_epi32 (__m128i a) - /// PMOVSXBD xmm1, xmm2/m32 - /// VPMOVSXBD xmm1, xmm2/m32 - /// VPMOVSXBD xmm1 {k1}{z}, xmm2/m32 + /// __m128i _mm_cvtepi8_epi32 (__m128i a) + /// PMOVSXBD xmm1, xmm2/m32 + /// VPMOVSXBD xmm1, xmm2/m32 + /// VPMOVSXBD xmm1 {k1}{z}, xmm2/m32 /// public static Vector128 ConvertToVector128Int32(Vector128 value) => ConvertToVector128Int32(value); /// - /// __m128i _mm_cvtepu8_epi32 (__m128i a) - /// PMOVZXBD xmm1, xmm2/m32 - /// VPMOVZXBD xmm1, xmm2/m32 - /// VPMOVZXBD xmm1 {k1}{z}, xmm2/m32 + /// __m128i _mm_cvtepu8_epi32 (__m128i a) + /// PMOVZXBD xmm1, xmm2/m32 + /// VPMOVZXBD xmm1, xmm2/m32 + /// VPMOVZXBD xmm1 {k1}{z}, xmm2/m32 /// public static Vector128 ConvertToVector128Int32(Vector128 value) => ConvertToVector128Int32(value); /// - /// __m128i _mm_cvtepi16_epi32 (__m128i a) - /// PMOVSXWD xmm1, xmm2/m64 - /// VPMOVSXWD xmm1, xmm2/m64 - /// VPMOVSXWD xmm1 {k1}{z}, xmm2/m64 + /// __m128i _mm_cvtepi16_epi32 (__m128i a) + /// PMOVSXWD xmm1, xmm2/m64 + /// VPMOVSXWD xmm1, xmm2/m64 + /// VPMOVSXWD xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 ConvertToVector128Int32(Vector128 value) => ConvertToVector128Int32(value); /// - /// __m128i _mm_cvtepu16_epi32 (__m128i a) - /// PMOVZXWD xmm1, xmm2/m64 - /// VPMOVZXWD xmm1, xmm2/m64 - /// VPMOVZXWD xmm1 {k1}{z}, xmm2/m64 + /// __m128i _mm_cvtepu16_epi32 (__m128i a) + /// PMOVZXWD xmm1, xmm2/m64 + /// VPMOVZXWD xmm1, xmm2/m64 + /// VPMOVZXWD xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 ConvertToVector128Int32(Vector128 value) => ConvertToVector128Int32(value); /// - /// __m128i _mm_cvtepi8_epi64 (__m128i a) - /// PMOVSXBQ xmm1, xmm2/m16 - /// VPMOVSXBQ xmm1, xmm2/m16 - /// VPMOVSXBQ xmm1 {k1}{z}, xmm2/m16 + /// __m128i _mm_cvtepi8_epi64 (__m128i a) + /// PMOVSXBQ xmm1, xmm2/m16 + /// VPMOVSXBQ xmm1, xmm2/m16 + /// VPMOVSXBQ xmm1 {k1}{z}, xmm2/m16 /// public static Vector128 ConvertToVector128Int64(Vector128 value) => ConvertToVector128Int64(value); /// - /// __m128i _mm_cvtepu8_epi64 (__m128i a) - /// PMOVZXBQ xmm1, xmm2/m16 - /// VPMOVZXBQ xmm1, xmm2/m16 - /// VPMOVZXBQ xmm1 {k1}{z}, xmm2/m16 + /// __m128i _mm_cvtepu8_epi64 (__m128i a) + /// PMOVZXBQ xmm1, xmm2/m16 + /// VPMOVZXBQ xmm1, xmm2/m16 + /// VPMOVZXBQ xmm1 {k1}{z}, xmm2/m16 /// public static Vector128 ConvertToVector128Int64(Vector128 value) => ConvertToVector128Int64(value); /// - /// __m128i _mm_cvtepi16_epi64 (__m128i a) - /// PMOVSXWQ xmm1, xmm2/m32 - /// VPMOVSXWQ xmm1, xmm2/m32 - /// VPMOVSXWQ xmm1 {k1}{z}, xmm2/m32 + /// __m128i _mm_cvtepi16_epi64 (__m128i a) + /// PMOVSXWQ xmm1, xmm2/m32 + /// VPMOVSXWQ xmm1, xmm2/m32 + /// VPMOVSXWQ xmm1 {k1}{z}, xmm2/m32 /// public static Vector128 ConvertToVector128Int64(Vector128 value) => ConvertToVector128Int64(value); /// - /// __m128i _mm_cvtepu16_epi64 (__m128i a) - /// PMOVZXWQ xmm1, xmm2/m32 - /// VPMOVZXWQ xmm1, xmm2/m32 - /// VPMOVZXWQ xmm1 {k1}{z}, xmm2/m32 + /// __m128i _mm_cvtepu16_epi64 (__m128i a) + /// PMOVZXWQ xmm1, xmm2/m32 + /// VPMOVZXWQ xmm1, xmm2/m32 + /// VPMOVZXWQ xmm1 {k1}{z}, xmm2/m32 /// public static Vector128 ConvertToVector128Int64(Vector128 value) => ConvertToVector128Int64(value); /// - /// __m128i _mm_cvtepi32_epi64 (__m128i a) - /// PMOVSXDQ xmm1, xmm2/m64 - /// VPMOVSXDQ xmm1, xmm2/m64 - /// VPMOVSXDQ xmm1 {k1}{z}, xmm2/m64 + /// __m128i _mm_cvtepi32_epi64 (__m128i a) + /// PMOVSXDQ xmm1, xmm2/m64 + /// VPMOVSXDQ xmm1, xmm2/m64 + /// VPMOVSXDQ xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 ConvertToVector128Int64(Vector128 value) => ConvertToVector128Int64(value); /// - /// __m128i _mm_cvtepu32_epi64 (__m128i a) - /// PMOVZXDQ xmm1, xmm2/m64 - /// VPMOVZXDQ xmm1, xmm2/m64 - /// VPMOVZXDQ xmm1 {k1}{z}, xmm2/m64 + /// __m128i _mm_cvtepu32_epi64 (__m128i a) + /// PMOVZXDQ xmm1, xmm2/m64 + /// VPMOVZXDQ xmm1, xmm2/m64 + /// VPMOVZXDQ xmm1 {k1}{z}, xmm2/m64 /// public static Vector128 ConvertToVector128Int64(Vector128 value) => ConvertToVector128Int64(value); /// - /// PMOVSXBW xmm1, m64 - /// VPMOVSXBW xmm1, m64 - /// VPMOVSXBW xmm1 {k1}{z}, m64 - /// The native signature does not exist. We provide this additional overload for completeness. + /// PMOVSXBW xmm1, m64 + /// VPMOVSXBW xmm1, m64 + /// VPMOVSXBW xmm1 {k1}{z}, m64 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector128 ConvertToVector128Int16(sbyte* address) => ConvertToVector128Int16(address); /// - /// PMOVZXBW xmm1, m64 - /// VPMOVZXBW xmm1, m64 - /// VPMOVZXBW xmm1 {k1}{z}, m64 - /// The native signature does not exist. We provide this additional overload for completeness. + /// PMOVZXBW xmm1, m64 + /// VPMOVZXBW xmm1, m64 + /// VPMOVZXBW xmm1 {k1}{z}, m64 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector128 ConvertToVector128Int16(byte* address) => ConvertToVector128Int16(address); /// - /// PMOVSXBD xmm1, m32 - /// VPMOVSXBD xmm1, m32 - /// VPMOVSXBD xmm1 {k1}{z}, m32 - /// The native signature does not exist. We provide this additional overload for completeness. + /// PMOVSXBD xmm1, m32 + /// VPMOVSXBD xmm1, m32 + /// VPMOVSXBD xmm1 {k1}{z}, m32 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector128 ConvertToVector128Int32(sbyte* address) => ConvertToVector128Int32(address); /// - /// PMOVZXBD xmm1, m32 - /// VPMOVZXBD xmm1, m32 - /// VPMOVZXBD xmm1 {k1}{z}, m32 - /// The native signature does not exist. We provide this additional overload for completeness. + /// PMOVZXBD xmm1, m32 + /// VPMOVZXBD xmm1, m32 + /// VPMOVZXBD xmm1 {k1}{z}, m32 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector128 ConvertToVector128Int32(byte* address) => ConvertToVector128Int32(address); /// - /// PMOVSXWD xmm1, m64 - /// VPMOVSXWD xmm1, m64 - /// VPMOVSXWD xmm1 {k1}{z}, m64 - /// The native signature does not exist. We provide this additional overload for completeness. + /// PMOVSXWD xmm1, m64 + /// VPMOVSXWD xmm1, m64 + /// VPMOVSXWD xmm1 {k1}{z}, m64 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector128 ConvertToVector128Int32(short* address) => ConvertToVector128Int32(address); /// - /// PMOVZXWD xmm1, m64 - /// VPMOVZXWD xmm1, m64 - /// VPMOVZXWD xmm1 {k1}{z}, m64 - /// The native signature does not exist. We provide this additional overload for completeness. + /// PMOVZXWD xmm1, m64 + /// VPMOVZXWD xmm1, m64 + /// VPMOVZXWD xmm1 {k1}{z}, m64 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector128 ConvertToVector128Int32(ushort* address) => ConvertToVector128Int32(address); /// - /// PMOVSXBQ xmm1, m16 - /// VPMOVSXBQ xmm1, m16 - /// VPMOVSXBQ xmm1 {k1}{z}, m16 - /// The native signature does not exist. We provide this additional overload for completeness. + /// PMOVSXBQ xmm1, m16 + /// VPMOVSXBQ xmm1, m16 + /// VPMOVSXBQ xmm1 {k1}{z}, m16 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector128 ConvertToVector128Int64(sbyte* address) => ConvertToVector128Int64(address); /// - /// PMOVZXBQ xmm1, m16 - /// VPMOVZXBQ xmm1, m16 - /// VPMOVZXBQ xmm1 {k1}{z}, m16 - /// The native signature does not exist. We provide this additional overload for completeness. + /// PMOVZXBQ xmm1, m16 + /// VPMOVZXBQ xmm1, m16 + /// VPMOVZXBQ xmm1 {k1}{z}, m16 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector128 ConvertToVector128Int64(byte* address) => ConvertToVector128Int64(address); /// - /// PMOVSXWQ xmm1, m32 - /// VPMOVSXWQ xmm1, m32 - /// VPMOVSXWQ xmm1 {k1}{z}, m32 - /// The native signature does not exist. We provide this additional overload for completeness. + /// PMOVSXWQ xmm1, m32 + /// VPMOVSXWQ xmm1, m32 + /// VPMOVSXWQ xmm1 {k1}{z}, m32 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector128 ConvertToVector128Int64(short* address) => ConvertToVector128Int64(address); /// - /// PMOVZXWQ xmm1, m32 - /// VPMOVZXWQ xmm1, m32 - /// VPMOVZXWQ xmm1 {k1}{z}, m32 - /// The native signature does not exist. We provide this additional overload for completeness. + /// PMOVZXWQ xmm1, m32 + /// VPMOVZXWQ xmm1, m32 + /// VPMOVZXWQ xmm1 {k1}{z}, m32 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector128 ConvertToVector128Int64(ushort* address) => ConvertToVector128Int64(address); /// - /// PMOVSXDQ xmm1, m64 - /// VPMOVSXDQ xmm1, m64 - /// VPMOVSXDQ xmm1 {k1}{z}, m64 - /// The native signature does not exist. We provide this additional overload for completeness. + /// PMOVSXDQ xmm1, m64 + /// VPMOVSXDQ xmm1, m64 + /// VPMOVSXDQ xmm1 {k1}{z}, m64 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector128 ConvertToVector128Int64(int* address) => ConvertToVector128Int64(address); /// - /// PMOVZXDQ xmm1, m64 - /// VPMOVZXDQ xmm1, m64 - /// VPMOVZXDQ xmm1 {k1}{z}, m64 - /// The native signature does not exist. We provide this additional overload for completeness. + /// PMOVZXDQ xmm1, m64 + /// VPMOVZXDQ xmm1, m64 + /// VPMOVZXDQ xmm1 {k1}{z}, m64 + /// The native signature does not exist. We provide this additional overload for completeness. /// public static unsafe Vector128 ConvertToVector128Int64(uint* address) => ConvertToVector128Int64(address); /// - /// __m128 _mm_dp_ps (__m128 a, __m128 b, const int imm8) - /// DPPS xmm1, xmm2/m128, imm8 - /// VDPPS xmm1, xmm2, xmm3/m128, imm8 + /// __m128 _mm_dp_ps (__m128 a, __m128 b, const int imm8) + /// DPPS xmm1, xmm2/m128, imm8 + /// VDPPS xmm1, xmm2, xmm3/m128, imm8 /// public static Vector128 DotProduct(Vector128 left, Vector128 right, [ConstantExpected] byte control) => DotProduct(left, right, control); /// - /// __m128d _mm_dp_pd (__m128d a, __m128d b, const int imm8) - /// DPPD xmm1, xmm2/m128, imm8 - /// VDPPD xmm1, xmm2, xmm3/m128, imm8 + /// __m128d _mm_dp_pd (__m128d a, __m128d b, const int imm8) + /// DPPD xmm1, xmm2/m128, imm8 + /// VDPPD xmm1, xmm2, xmm3/m128, imm8 /// public static Vector128 DotProduct(Vector128 left, Vector128 right, [ConstantExpected] byte control) => DotProduct(left, right, control); /// - /// int _mm_extract_epi8 (__m128i a, const int imm8) - /// PEXTRB r/m8, xmm1, imm8 - /// VPEXTRB r/m8, xmm1, imm8 + /// int _mm_extract_epi8 (__m128i a, const int imm8) + /// PEXTRB r/m8, xmm1, imm8 + /// VPEXTRB r/m8, xmm1, imm8 /// public static byte Extract(Vector128 value, [ConstantExpected] byte index) => Extract(value, index); /// - /// int _mm_extract_epi32 (__m128i a, const int imm8) - /// PEXTRD r/m32, xmm1, imm8 - /// VPEXTRD r/m32, xmm1, imm8 + /// int _mm_extract_epi32 (__m128i a, const int imm8) + /// PEXTRD r/m32, xmm1, imm8 + /// VPEXTRD r/m32, xmm1, imm8 /// public static int Extract(Vector128 value, [ConstantExpected] byte index) => Extract(value, index); /// - /// int _mm_extract_epi32 (__m128i a, const int imm8) - /// PEXTRD r/m32, xmm1, imm8 - /// VPEXTRD r/m32, xmm1, imm8 + /// int _mm_extract_epi32 (__m128i a, const int imm8) + /// PEXTRD r/m32, xmm1, imm8 + /// VPEXTRD r/m32, xmm1, imm8 /// public static uint Extract(Vector128 value, [ConstantExpected] byte index) => Extract(value, index); /// - /// int _mm_extract_ps (__m128 a, const int imm8) - /// EXTRACTPS r/m32, xmm1, imm8 - /// VEXTRACTPS r/m32, xmm1, imm8 + /// int _mm_extract_ps (__m128 a, const int imm8) + /// EXTRACTPS r/m32, xmm1, imm8 + /// VEXTRACTPS r/m32, xmm1, imm8 /// public static float Extract(Vector128 value, [ConstantExpected] byte index) => Extract(value, index); /// - /// __m128 _mm_floor_ps (__m128 a) - /// ROUNDPS xmm1, xmm2/m128, imm8(9) - /// VROUNDPS xmm1, xmm2/m128, imm8(9) + /// __m128 _mm_floor_ps (__m128 a) + /// ROUNDPS xmm1, xmm2/m128, imm8(9) + /// VROUNDPS xmm1, xmm2/m128, imm8(9) /// public static Vector128 Floor(Vector128 value) => Floor(value); /// - /// __m128d _mm_floor_pd (__m128d a) - /// ROUNDPD xmm1, xmm2/m128, imm8(9) - /// VROUNDPD xmm1, xmm2/m128, imm8(9) + /// __m128d _mm_floor_pd (__m128d a) + /// ROUNDPD xmm1, xmm2/m128, imm8(9) + /// VROUNDPD xmm1, xmm2/m128, imm8(9) /// public static Vector128 Floor(Vector128 value) => Floor(value); /// - /// __m128 _mm_floor_ss (__m128 a) - /// ROUNDSS xmm1, xmm2/m128, imm8(9) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(9) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_floor_ss (__m128 a) + /// ROUNDSS xmm1, xmm2/m128, imm8(9) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(9) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 FloorScalar(Vector128 value) => FloorScalar(value); /// - /// __m128 _mm_floor_ss (__m128 a, __m128 b) - /// ROUNDSS xmm1, xmm2/m128, imm8(9) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(9) + /// __m128 _mm_floor_ss (__m128 a, __m128 b) + /// ROUNDSS xmm1, xmm2/m128, imm8(9) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(9) /// public static Vector128 FloorScalar(Vector128 upper, Vector128 value) => FloorScalar(upper, value); /// - /// __m128d _mm_floor_sd (__m128d a) - /// ROUNDSD xmm1, xmm2/m128, imm8(9) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(9) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_floor_sd (__m128d a) + /// ROUNDSD xmm1, xmm2/m128, imm8(9) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(9) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 FloorScalar(Vector128 value) => FloorScalar(value); /// - /// __m128d _mm_floor_sd (__m128d a, __m128d b) - /// ROUNDSD xmm1, xmm2/m128, imm8(9) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(9) + /// __m128d _mm_floor_sd (__m128d a, __m128d b) + /// ROUNDSD xmm1, xmm2/m128, imm8(9) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(9) /// public static Vector128 FloorScalar(Vector128 upper, Vector128 value) => FloorScalar(upper, value); /// - /// __m128i _mm_insert_epi8 (__m128i a, int i, const int imm8) - /// PINSRB xmm1, r/m8, imm8 - /// VPINSRB xmm1, xmm2, r/m8, imm8 + /// __m128i _mm_insert_epi8 (__m128i a, int i, const int imm8) + /// PINSRB xmm1, r/m8, imm8 + /// VPINSRB xmm1, xmm2, r/m8, imm8 /// public static Vector128 Insert(Vector128 value, sbyte data, [ConstantExpected] byte index) => Insert(value, data, index); /// - /// __m128i _mm_insert_epi8 (__m128i a, int i, const int imm8) - /// PINSRB xmm1, r/m8, imm8 - /// VPINSRB xmm1, xmm2, r/m8, imm8 + /// __m128i _mm_insert_epi8 (__m128i a, int i, const int imm8) + /// PINSRB xmm1, r/m8, imm8 + /// VPINSRB xmm1, xmm2, r/m8, imm8 /// public static Vector128 Insert(Vector128 value, byte data, [ConstantExpected] byte index) => Insert(value, data, index); /// - /// __m128i _mm_insert_epi32 (__m128i a, int i, const int imm8) - /// PINSRD xmm1, r/m32, imm8 - /// VPINSRD xmm1, xmm2, r/m32, imm8 + /// __m128i _mm_insert_epi32 (__m128i a, int i, const int imm8) + /// PINSRD xmm1, r/m32, imm8 + /// VPINSRD xmm1, xmm2, r/m32, imm8 /// public static Vector128 Insert(Vector128 value, int data, [ConstantExpected] byte index) => Insert(value, data, index); /// - /// __m128i _mm_insert_epi32 (__m128i a, int i, const int imm8) - /// PINSRD xmm1, r/m32, imm8 - /// VPINSRD xmm1, xmm2, r/m32, imm8 + /// __m128i _mm_insert_epi32 (__m128i a, int i, const int imm8) + /// PINSRD xmm1, r/m32, imm8 + /// VPINSRD xmm1, xmm2, r/m32, imm8 /// public static Vector128 Insert(Vector128 value, uint data, [ConstantExpected] byte index) => Insert(value, data, index); /// - /// __m128 _mm_insert_ps (__m128 a, __m128 b, const int imm8) - /// INSERTPS xmm1, xmm2/m32, imm8 - /// VINSERTPS xmm1, xmm2, xmm3/m32, imm8 + /// __m128 _mm_insert_ps (__m128 a, __m128 b, const int imm8) + /// INSERTPS xmm1, xmm2/m32, imm8 + /// VINSERTPS xmm1, xmm2, xmm3/m32, imm8 /// public static Vector128 Insert(Vector128 value, Vector128 data, [ConstantExpected] byte index) => Insert(value, data, index); /// - /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) - /// MOVNTDQA xmm1, m128 - /// VMOVNTDQA xmm1, m128 + /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) + /// MOVNTDQA xmm1, m128 + /// VMOVNTDQA xmm1, m128 /// public static unsafe Vector128 LoadAlignedVector128NonTemporal(sbyte* address) => LoadAlignedVector128NonTemporal(address); /// - /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) - /// MOVNTDQA xmm1, m128 - /// VMOVNTDQA xmm1, m128 + /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) + /// MOVNTDQA xmm1, m128 + /// VMOVNTDQA xmm1, m128 /// public static unsafe Vector128 LoadAlignedVector128NonTemporal(byte* address) => LoadAlignedVector128NonTemporal(address); /// - /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) - /// MOVNTDQA xmm1, m128 - /// VMOVNTDQA xmm1, m128 + /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) + /// MOVNTDQA xmm1, m128 + /// VMOVNTDQA xmm1, m128 /// public static unsafe Vector128 LoadAlignedVector128NonTemporal(short* address) => LoadAlignedVector128NonTemporal(address); /// - /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) - /// MOVNTDQA xmm1, m128 - /// VMOVNTDQA xmm1, m128 + /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) + /// MOVNTDQA xmm1, m128 + /// VMOVNTDQA xmm1, m128 /// public static unsafe Vector128 LoadAlignedVector128NonTemporal(ushort* address) => LoadAlignedVector128NonTemporal(address); /// - /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) - /// MOVNTDQA xmm1, m128 - /// VMOVNTDQA xmm1, m128 + /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) + /// MOVNTDQA xmm1, m128 + /// VMOVNTDQA xmm1, m128 /// public static unsafe Vector128 LoadAlignedVector128NonTemporal(int* address) => LoadAlignedVector128NonTemporal(address); /// - /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) - /// MOVNTDQA xmm1, m128 - /// VMOVNTDQA xmm1, m128 + /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) + /// MOVNTDQA xmm1, m128 + /// VMOVNTDQA xmm1, m128 /// public static unsafe Vector128 LoadAlignedVector128NonTemporal(uint* address) => LoadAlignedVector128NonTemporal(address); /// - /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) - /// MOVNTDQA xmm1, m128 - /// VMOVNTDQA xmm1, m128 + /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) + /// MOVNTDQA xmm1, m128 + /// VMOVNTDQA xmm1, m128 /// public static unsafe Vector128 LoadAlignedVector128NonTemporal(long* address) => LoadAlignedVector128NonTemporal(address); /// - /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) - /// MOVNTDQA xmm1, m128 - /// VMOVNTDQA xmm1, m128 + /// __m128i _mm_stream_load_si128 (const __m128i* mem_addr) + /// MOVNTDQA xmm1, m128 + /// VMOVNTDQA xmm1, m128 /// public static unsafe Vector128 LoadAlignedVector128NonTemporal(ulong* address) => LoadAlignedVector128NonTemporal(address); /// - /// __m128i _mm_max_epi8 (__m128i a, __m128i b) - /// PMAXSB xmm1, xmm2/m128 - /// VPMAXSB xmm1, xmm2, xmm3/m128 - /// VPMAXSB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_max_epi8 (__m128i a, __m128i b) + /// PMAXSB xmm1, xmm2/m128 + /// VPMAXSB xmm1, xmm2, xmm3/m128 + /// VPMAXSB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// - /// __m128i _mm_max_epu16 (__m128i a, __m128i b) - /// PMAXUW xmm1, xmm2/m128 - /// VPMAXUW xmm1, xmm2, xmm3/m128 - /// VPMAXUW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_max_epu16 (__m128i a, __m128i b) + /// PMAXUW xmm1, xmm2/m128 + /// VPMAXUW xmm1, xmm2, xmm3/m128 + /// VPMAXUW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// - /// __m128i _mm_max_epi32 (__m128i a, __m128i b) - /// PMAXSD xmm1, xmm2/m128 - /// VPMAXSD xmm1, xmm2, xmm3/m128 - /// VPMAXSD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_max_epi32 (__m128i a, __m128i b) + /// PMAXSD xmm1, xmm2/m128 + /// VPMAXSD xmm1, xmm2, xmm3/m128 + /// VPMAXSD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// - /// __m128i _mm_max_epu32 (__m128i a, __m128i b) - /// PMAXUD xmm1, xmm2/m128 - /// VPMAXUD xmm1, xmm2, xmm3/m128 - /// VPMAXUD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_max_epu32 (__m128i a, __m128i b) + /// PMAXUD xmm1, xmm2/m128 + /// VPMAXUD xmm1, xmm2, xmm3/m128 + /// VPMAXUD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Max(Vector128 left, Vector128 right) => Max(left, right); /// - /// __m128i _mm_min_epi8 (__m128i a, __m128i b) - /// PMINSB xmm1, xmm2/m128 - /// VPMINSB xmm1, xmm2, xmm3/m128 - /// VPMINSB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_min_epi8 (__m128i a, __m128i b) + /// PMINSB xmm1, xmm2/m128 + /// VPMINSB xmm1, xmm2, xmm3/m128 + /// VPMINSB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// - /// __m128i _mm_min_epu16 (__m128i a, __m128i b) - /// PMINUW xmm1, xmm2/m128 - /// VPMINUW xmm1, xmm2, xmm3/m128 - /// VPMINUW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_min_epu16 (__m128i a, __m128i b) + /// PMINUW xmm1, xmm2/m128 + /// VPMINUW xmm1, xmm2, xmm3/m128 + /// VPMINUW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// - /// __m128i _mm_min_epi32 (__m128i a, __m128i b) - /// PMINSD xmm1, xmm2/m128 - /// VPMINSD xmm1, xmm2, xmm3/m128 - /// VPMINSD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_min_epi32 (__m128i a, __m128i b) + /// PMINSD xmm1, xmm2/m128 + /// VPMINSD xmm1, xmm2, xmm3/m128 + /// VPMINSD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// - /// __m128i _mm_min_epu32 (__m128i a, __m128i b) - /// PMINUD xmm1, xmm2/m128 - /// VPMINUD xmm1, xmm2, xmm3/m128 - /// VPMINUD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_min_epu32 (__m128i a, __m128i b) + /// PMINUD xmm1, xmm2/m128 + /// VPMINUD xmm1, xmm2, xmm3/m128 + /// VPMINUD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 Min(Vector128 left, Vector128 right) => Min(left, right); /// - /// __m128i _mm_minpos_epu16 (__m128i a) - /// PHMINPOSUW xmm1, xmm2/m128 - /// VPHMINPOSUW xmm1, xmm2/m128 + /// __m128i _mm_minpos_epu16 (__m128i a) + /// PHMINPOSUW xmm1, xmm2/m128 + /// VPHMINPOSUW xmm1, xmm2/m128 /// public static Vector128 MinHorizontal(Vector128 value) => MinHorizontal(value); /// - /// __m128i _mm_mpsadbw_epu8 (__m128i a, __m128i b, const int imm8) - /// MPSADBW xmm1, xmm2/m128, imm8 - /// VMPSADBW xmm1, xmm2, xmm3/m128, imm8 + /// __m128i _mm_mpsadbw_epu8 (__m128i a, __m128i b, const int imm8) + /// MPSADBW xmm1, xmm2/m128, imm8 + /// VMPSADBW xmm1, xmm2, xmm3/m128, imm8 /// public static Vector128 MultipleSumAbsoluteDifferences(Vector128 left, Vector128 right, [ConstantExpected] byte mask) => MultipleSumAbsoluteDifferences(left, right, mask); /// - /// __m128i _mm_mul_epi32 (__m128i a, __m128i b) - /// PMULDQ xmm1, xmm2/m128 - /// VPMULDQ xmm1, xmm2, xmm3/m128 - /// VPMULDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst + /// __m128i _mm_mul_epi32 (__m128i a, __m128i b) + /// PMULDQ xmm1, xmm2/m128 + /// VPMULDQ xmm1, xmm2, xmm3/m128 + /// VPMULDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst /// public static Vector128 Multiply(Vector128 left, Vector128 right) => Multiply(left, right); /// - /// __m128i _mm_mullo_epi32 (__m128i a, __m128i b) - /// PMULLD xmm1, xmm2/m128 - /// VPMULLD xmm1, xmm2, xmm3/m128 - /// VPMULLD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_mullo_epi32 (__m128i a, __m128i b) + /// PMULLD xmm1, xmm2/m128 + /// VPMULLD xmm1, xmm2, xmm3/m128 + /// VPMULLD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 MultiplyLow(Vector128 left, Vector128 right) => MultiplyLow(left, right); /// - /// __m128i _mm_mullo_epi32 (__m128i a, __m128i b) - /// PMULLD xmm1, xmm2/m128 - /// VPMULLD xmm1, xmm2, xmm3/m128 - /// VPMULLD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_mullo_epi32 (__m128i a, __m128i b) + /// PMULLD xmm1, xmm2/m128 + /// VPMULLD xmm1, xmm2, xmm3/m128 + /// VPMULLD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 MultiplyLow(Vector128 left, Vector128 right) => MultiplyLow(left, right); /// - /// __m128i _mm_packus_epi32 (__m128i a, __m128i b) - /// PACKUSDW xmm1, xmm2/m128 - /// VPACKUSDW xmm1, xmm2, xmm3/m128 - /// VPACKUSDW xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst + /// __m128i _mm_packus_epi32 (__m128i a, __m128i b) + /// PACKUSDW xmm1, xmm2/m128 + /// VPACKUSDW xmm1, xmm2, xmm3/m128 + /// VPACKUSDW xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst /// public static Vector128 PackUnsignedSaturate(Vector128 left, Vector128 right) => PackUnsignedSaturate(left, right); /// - /// __m128 _mm_round_ps (__m128 a, _MM_FROUND_CUR_DIRECTION) - /// ROUNDPS xmm1, xmm2/m128, imm8(4) - /// VROUNDPS xmm1, xmm2/m128, imm8(4) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ps (__m128 a, _MM_FROUND_CUR_DIRECTION) + /// ROUNDPS xmm1, xmm2/m128, imm8(4) + /// VROUNDPS xmm1, xmm2/m128, imm8(4) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundCurrentDirection(Vector128 value) => RoundCurrentDirection(value); /// - /// __m128d _mm_round_pd (__m128d a, _MM_FROUND_CUR_DIRECTION) - /// ROUNDPD xmm1, xmm2/m128, imm8(4) - /// VROUNDPD xmm1, xmm2/m128, imm8(4) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_round_pd (__m128d a, _MM_FROUND_CUR_DIRECTION) + /// ROUNDPD xmm1, xmm2/m128, imm8(4) + /// VROUNDPD xmm1, xmm2/m128, imm8(4) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundCurrentDirection(Vector128 value) => RoundCurrentDirection(value); /// - /// __m128 _mm_round_ss (__m128 a, _MM_FROUND_CUR_DIRECTION) - /// ROUNDSS xmm1, xmm2/m128, imm8(4) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(4) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ss (__m128 a, _MM_FROUND_CUR_DIRECTION) + /// ROUNDSS xmm1, xmm2/m128, imm8(4) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(4) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundCurrentDirectionScalar(Vector128 value) => RoundCurrentDirectionScalar(value); /// - /// __m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_CUR_DIRECTION) - /// ROUNDSS xmm1, xmm2/m128, imm8(4) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(4) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_CUR_DIRECTION) + /// ROUNDSS xmm1, xmm2/m128, imm8(4) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(4) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundCurrentDirectionScalar(Vector128 upper, Vector128 value) => RoundCurrentDirectionScalar(upper, value); /// - /// __m128d _mm_round_sd (__m128d a, _MM_FROUND_CUR_DIRECTION) - /// ROUNDSD xmm1, xmm2/m128, imm8(4) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(4) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_round_sd (__m128d a, _MM_FROUND_CUR_DIRECTION) + /// ROUNDSD xmm1, xmm2/m128, imm8(4) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(4) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundCurrentDirectionScalar(Vector128 value) => RoundCurrentDirectionScalar(value); /// - /// __m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_CUR_DIRECTION) - /// ROUNDSD xmm1, xmm2/m128, imm8(4) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(4) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_CUR_DIRECTION) + /// ROUNDSD xmm1, xmm2/m128, imm8(4) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(4) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundCurrentDirectionScalar(Vector128 upper, Vector128 value) => RoundCurrentDirectionScalar(upper, value); /// - /// __m128 _mm_round_ps (__m128 a, _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC) - /// ROUNDPS xmm1, xmm2/m128, imm8(8) - /// VROUNDPS xmm1, xmm2/m128, imm8(8) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ps (__m128 a, _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC) + /// ROUNDPS xmm1, xmm2/m128, imm8(8) + /// VROUNDPS xmm1, xmm2/m128, imm8(8) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToNearestInteger(Vector128 value) => RoundToNearestInteger(value); /// - /// __m128 _mm_round_pd (__m128 a, _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC) - /// ROUNDPD xmm1, xmm2/m128, imm8(8) - /// VROUNDPD xmm1, xmm2/m128, imm8(8) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_pd (__m128 a, _MM_FROUND_TO_NEAREST_INT |_MM_FROUND_NO_EXC) + /// ROUNDPD xmm1, xmm2/m128, imm8(8) + /// VROUNDPD xmm1, xmm2/m128, imm8(8) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToNearestInteger(Vector128 value) => RoundToNearestInteger(value); /// - /// __m128 _mm_round_ss (__m128 a, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) - /// ROUNDSS xmm1, xmm2/m128, imm8(8) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(8) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ss (__m128 a, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) + /// ROUNDSS xmm1, xmm2/m128, imm8(8) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(8) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToNearestIntegerScalar(Vector128 value) => RoundToNearestIntegerScalar(value); /// - /// __m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) - /// ROUNDSS xmm1, xmm2/m128, imm8(8) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(8) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) + /// ROUNDSS xmm1, xmm2/m128, imm8(8) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(8) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToNearestIntegerScalar(Vector128 upper, Vector128 value) => RoundToNearestIntegerScalar(upper, value); /// - /// __m128d _mm_round_sd (__m128d a, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) - /// ROUNDSD xmm1, xmm2/m128, imm8(8) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(8) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_round_sd (__m128d a, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) + /// ROUNDSD xmm1, xmm2/m128, imm8(8) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(8) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToNearestIntegerScalar(Vector128 value) => RoundToNearestIntegerScalar(value); /// - /// __m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) - /// ROUNDSD xmm1, xmm2/m128, imm8(8) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(8) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC) + /// ROUNDSD xmm1, xmm2/m128, imm8(8) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(8) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToNearestIntegerScalar(Vector128 upper, Vector128 value) => RoundToNearestIntegerScalar(upper, value); /// - /// __m128 _mm_round_ps (__m128 a, _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC) - /// ROUNDPS xmm1, xmm2/m128, imm8(9) - /// VROUNDPS xmm1, xmm2/m128, imm8(9) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ps (__m128 a, _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC) + /// ROUNDPS xmm1, xmm2/m128, imm8(9) + /// VROUNDPS xmm1, xmm2/m128, imm8(9) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToNegativeInfinity(Vector128 value) => RoundToNegativeInfinity(value); /// - /// __m128 _mm_round_pd (__m128 a, _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC) - /// ROUNDPD xmm1, xmm2/m128, imm8(9) - /// VROUNDPD xmm1, xmm2/m128, imm8(9) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_pd (__m128 a, _MM_FROUND_TO_NEG_INF |_MM_FROUND_NO_EXC) + /// ROUNDPD xmm1, xmm2/m128, imm8(9) + /// VROUNDPD xmm1, xmm2/m128, imm8(9) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToNegativeInfinity(Vector128 value) => RoundToNegativeInfinity(value); /// - /// __m128 _mm_round_ss (__m128 a, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) - /// ROUNDSS xmm1, xmm2/m128, imm8(9) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(9) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ss (__m128 a, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) + /// ROUNDSS xmm1, xmm2/m128, imm8(9) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(9) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToNegativeInfinityScalar(Vector128 value) => RoundToNegativeInfinityScalar(value); /// - /// __m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) - /// ROUNDSS xmm1, xmm2/m128, imm8(9) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(9) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) + /// ROUNDSS xmm1, xmm2/m128, imm8(9) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(9) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToNegativeInfinityScalar(Vector128 upper, Vector128 value) => RoundToNegativeInfinityScalar(upper, value); /// - /// __m128d _mm_round_sd (__m128d a, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) - /// ROUNDSD xmm1, xmm2/m128, imm8(9) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(9) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_round_sd (__m128d a, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) + /// ROUNDSD xmm1, xmm2/m128, imm8(9) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(9) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToNegativeInfinityScalar(Vector128 value) => RoundToNegativeInfinityScalar(value); /// - /// __m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) - /// ROUNDSD xmm1, xmm2/m128, imm8(9) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(9) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC) + /// ROUNDSD xmm1, xmm2/m128, imm8(9) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(9) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToNegativeInfinityScalar(Vector128 upper, Vector128 value) => RoundToNegativeInfinityScalar(upper, value); /// - /// __m128 _mm_round_ps (__m128 a, _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC) - /// ROUNDPS xmm1, xmm2/m128, imm8(10) - /// VROUNDPS xmm1, xmm2/m128, imm8(10) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ps (__m128 a, _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC) + /// ROUNDPS xmm1, xmm2/m128, imm8(10) + /// VROUNDPS xmm1, xmm2/m128, imm8(10) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToPositiveInfinity(Vector128 value) => RoundToPositiveInfinity(value); /// - /// __m128 _mm_round_pd (__m128 a, _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC) - /// ROUNDPD xmm1, xmm2/m128, imm8(10) - /// VROUNDPD xmm1, xmm2/m128, imm8(10) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_pd (__m128 a, _MM_FROUND_TO_POS_INF |_MM_FROUND_NO_EXC) + /// ROUNDPD xmm1, xmm2/m128, imm8(10) + /// VROUNDPD xmm1, xmm2/m128, imm8(10) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToPositiveInfinity(Vector128 value) => RoundToPositiveInfinity(value); /// - /// __m128 _mm_round_ss (__m128 a, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) - /// ROUNDSS xmm1, xmm2/m128, imm8(10) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(10) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ss (__m128 a, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) + /// ROUNDSS xmm1, xmm2/m128, imm8(10) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(10) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToPositiveInfinityScalar(Vector128 value) => RoundToPositiveInfinityScalar(value); /// - /// __m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) - /// ROUNDSS xmm1, xmm2/m128, imm8(10) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(10) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) + /// ROUNDSS xmm1, xmm2/m128, imm8(10) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(10) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToPositiveInfinityScalar(Vector128 upper, Vector128 value) => RoundToPositiveInfinityScalar(upper, value); /// - /// __m128d _mm_round_sd (__m128d a, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) - /// ROUNDSD xmm1, xmm2/m128, imm8(10) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(10) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_round_sd (__m128d a, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) + /// ROUNDSD xmm1, xmm2/m128, imm8(10) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(10) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToPositiveInfinityScalar(Vector128 value) => RoundToPositiveInfinityScalar(value); /// - /// __m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) - /// ROUNDSD xmm1, xmm2/m128, imm8(10) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(10) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_round_sd (__m128d a, __m128d b, _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC) + /// ROUNDSD xmm1, xmm2/m128, imm8(10) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(10) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToPositiveInfinityScalar(Vector128 upper, Vector128 value) => RoundToPositiveInfinityScalar(upper, value); /// - /// __m128 _mm_round_ps (__m128 a, _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC) - /// ROUNDPS xmm1, xmm2/m128, imm8(11) - /// VROUNDPS xmm1, xmm2/m128, imm8(11) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ps (__m128 a, _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC) + /// ROUNDPS xmm1, xmm2/m128, imm8(11) + /// VROUNDPS xmm1, xmm2/m128, imm8(11) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToZero(Vector128 value) => RoundToZero(value); /// - /// __m128 _mm_round_pd (__m128 a, _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC) - /// ROUNDPD xmm1, xmm2/m128, imm8(11) - /// VROUNDPD xmm1, xmm2/m128, imm8(11) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_pd (__m128 a, _MM_FROUND_TO_ZERO |_MM_FROUND_NO_EXC) + /// ROUNDPD xmm1, xmm2/m128, imm8(11) + /// VROUNDPD xmm1, xmm2/m128, imm8(11) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToZero(Vector128 value) => RoundToZero(value); /// - /// __m128 _mm_round_ss (__m128 a, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) - /// ROUNDSS xmm1, xmm2/m128, imm8(11) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(11) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ss (__m128 a, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) + /// ROUNDSS xmm1, xmm2/m128, imm8(11) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(11) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToZeroScalar(Vector128 value) => RoundToZeroScalar(value); /// - /// __m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) - /// ROUNDSS xmm1, xmm2/m128, imm8(11) - /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(11) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128 _mm_round_ss (__m128 a, __m128 b, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) + /// ROUNDSS xmm1, xmm2/m128, imm8(11) + /// VROUNDSS xmm1, xmm2, xmm3/m128, imm8(11) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToZeroScalar(Vector128 upper, Vector128 value) => RoundToZeroScalar(upper, value); /// - /// __m128d _mm_round_sd (__m128d a, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) - /// ROUNDSD xmm1, xmm2/m128, imm8(11) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(11) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_round_sd (__m128d a, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) + /// ROUNDSD xmm1, xmm2/m128, imm8(11) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(11) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToZeroScalar(Vector128 value) => RoundToZeroScalar(value); /// - /// __m128d _mm_round_sd (__m128d a, __m128 b, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) - /// ROUNDSD xmm1, xmm2/m128, imm8(11) - /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(11) - /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. + /// __m128d _mm_round_sd (__m128d a, __m128 b, _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC) + /// ROUNDSD xmm1, xmm2/m128, imm8(11) + /// VROUNDSD xmm1, xmm2, xmm3/m128, imm8(11) + /// The above native signature does not exist. We provide this additional overload for the recommended use case of this intrinsic. /// public static Vector128 RoundToZeroScalar(Vector128 upper, Vector128 value) => RoundToZeroScalar(upper, value); /// - /// int _mm_testc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; CF=1 - /// VPTEST xmm1, xmm2/m128 ; CF=1 + /// int _mm_testc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; CF=1 + /// VPTEST xmm1, xmm2/m128 ; CF=1 /// public static bool TestC(Vector128 left, Vector128 right) => TestC(left, right); /// - /// int _mm_testc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; CF=1 - /// VPTEST xmm1, xmm2/m128 ; CF=1 + /// int _mm_testc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; CF=1 + /// VPTEST xmm1, xmm2/m128 ; CF=1 /// public static bool TestC(Vector128 left, Vector128 right) => TestC(left, right); /// - /// int _mm_testc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; CF=1 - /// VPTEST xmm1, xmm2/m128 ; CF=1 + /// int _mm_testc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; CF=1 + /// VPTEST xmm1, xmm2/m128 ; CF=1 /// public static bool TestC(Vector128 left, Vector128 right) => TestC(left, right); /// - /// int _mm_testc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; CF=1 - /// VPTEST xmm1, xmm2/m128 ; CF=1 + /// int _mm_testc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; CF=1 + /// VPTEST xmm1, xmm2/m128 ; CF=1 /// public static bool TestC(Vector128 left, Vector128 right) => TestC(left, right); /// - /// int _mm_testc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; CF=1 - /// VPTEST xmm1, xmm2/m128 ; CF=1 + /// int _mm_testc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; CF=1 + /// VPTEST xmm1, xmm2/m128 ; CF=1 /// public static bool TestC(Vector128 left, Vector128 right) => TestC(left, right); /// - /// int _mm_testc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; CF=1 - /// VPTEST xmm1, xmm2/m128 ; CF=1 + /// int _mm_testc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; CF=1 + /// VPTEST xmm1, xmm2/m128 ; CF=1 /// public static bool TestC(Vector128 left, Vector128 right) => TestC(left, right); /// - /// int _mm_testc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; CF=1 - /// VPTEST xmm1, xmm2/m128 ; CF=1 + /// int _mm_testc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; CF=1 + /// VPTEST xmm1, xmm2/m128 ; CF=1 /// public static bool TestC(Vector128 left, Vector128 right) => TestC(left, right); /// - /// int _mm_testc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; CF=1 - /// VPTEST xmm1, xmm2/m128 ; CF=1 + /// int _mm_testc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; CF=1 + /// VPTEST xmm1, xmm2/m128 ; CF=1 /// public static bool TestC(Vector128 left, Vector128 right) => TestC(left, right); /// - /// int _mm_testnzc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 - /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// int _mm_testnzc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector128 left, Vector128 right) => TestNotZAndNotC(left, right); /// - /// int _mm_testnzc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 - /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// int _mm_testnzc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector128 left, Vector128 right) => TestNotZAndNotC(left, right); /// - /// int _mm_testnzc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 - /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// int _mm_testnzc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector128 left, Vector128 right) => TestNotZAndNotC(left, right); /// - /// int _mm_testnzc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 - /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// int _mm_testnzc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector128 left, Vector128 right) => TestNotZAndNotC(left, right); /// - /// int _mm_testnzc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 - /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// int _mm_testnzc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector128 left, Vector128 right) => TestNotZAndNotC(left, right); /// - /// int _mm_testnzc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 - /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// int _mm_testnzc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector128 left, Vector128 right) => TestNotZAndNotC(left, right); /// - /// int _mm_testnzc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 - /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// int _mm_testnzc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector128 left, Vector128 right) => TestNotZAndNotC(left, right); /// - /// int _mm_testnzc_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 - /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// int _mm_testnzc_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 + /// VPTEST xmm1, xmm2/m128 ; ZF=0 && CF=0 /// public static bool TestNotZAndNotC(Vector128 left, Vector128 right) => TestNotZAndNotC(left, right); /// - /// int _mm_testz_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=1 - /// VPTEST xmm1, xmm2/m128 ; ZF=1 + /// int _mm_testz_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=1 + /// VPTEST xmm1, xmm2/m128 ; ZF=1 /// public static bool TestZ(Vector128 left, Vector128 right) => TestZ(left, right); /// - /// int _mm_testz_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=1 - /// VPTEST xmm1, xmm2/m128 ; ZF=1 + /// int _mm_testz_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=1 + /// VPTEST xmm1, xmm2/m128 ; ZF=1 /// public static bool TestZ(Vector128 left, Vector128 right) => TestZ(left, right); /// - /// int _mm_testz_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=1 - /// VPTEST xmm1, xmm2/m128 ; ZF=1 + /// int _mm_testz_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=1 + /// VPTEST xmm1, xmm2/m128 ; ZF=1 /// public static bool TestZ(Vector128 left, Vector128 right) => TestZ(left, right); /// - /// int _mm_testz_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=1 - /// VPTEST xmm1, xmm2/m128 ; ZF=1 + /// int _mm_testz_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=1 + /// VPTEST xmm1, xmm2/m128 ; ZF=1 /// public static bool TestZ(Vector128 left, Vector128 right) => TestZ(left, right); /// - /// int _mm_testz_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=1 - /// VPTEST xmm1, xmm2/m128 ; ZF=1 + /// int _mm_testz_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=1 + /// VPTEST xmm1, xmm2/m128 ; ZF=1 /// public static bool TestZ(Vector128 left, Vector128 right) => TestZ(left, right); /// - /// int _mm_testz_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=1 - /// VPTEST xmm1, xmm2/m128 ; ZF=1 + /// int _mm_testz_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=1 + /// VPTEST xmm1, xmm2/m128 ; ZF=1 /// public static bool TestZ(Vector128 left, Vector128 right) => TestZ(left, right); /// - /// int _mm_testz_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=1 - /// VPTEST xmm1, xmm2/m128 ; ZF=1 + /// int _mm_testz_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=1 + /// VPTEST xmm1, xmm2/m128 ; ZF=1 /// public static bool TestZ(Vector128 left, Vector128 right) => TestZ(left, right); /// - /// int _mm_testz_si128 (__m128i a, __m128i b) - /// PTEST xmm1, xmm2/m128 ; ZF=1 - /// VPTEST xmm1, xmm2/m128 ; ZF=1 + /// int _mm_testz_si128 (__m128i a, __m128i b) + /// PTEST xmm1, xmm2/m128 ; ZF=1 + /// VPTEST xmm1, xmm2/m128 ; ZF=1 /// public static bool TestZ(Vector128 left, Vector128 right) => TestZ(left, right); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse42.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse42.PlatformNotSupported.cs index a92a80e1ae1..3786c3bcf3f 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse42.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse42.PlatformNotSupported.cs @@ -7,50 +7,55 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel SSE4.2 hardware instructions via intrinsics - /// + /// This class provides access to X86 SSE4.2 hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Sse42 : Sse41 { internal Sse42() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } + /// This class provides access to the x86 SSE4.2 hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class X64 : Sse41.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } /// - /// unsigned __int64 _mm_crc32_u64 (unsigned __int64 crc, unsigned __int64 v) - /// CRC32 r64, r/m64 - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_crc32_u64 (unsigned __int64 crc, unsigned __int64 v) + /// CRC32 r64, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static ulong Crc32(ulong crc, ulong data) { throw new PlatformNotSupportedException(); } } /// - /// __m128i _mm_cmpgt_epi64 (__m128i a, __m128i b) - /// PCMPGTQ xmm1, xmm2/m128 - /// VPCMPGTQ xmm1, xmm2, xmm3/m128 + /// __m128i _mm_cmpgt_epi64 (__m128i a, __m128i b) + /// PCMPGTQ xmm1, xmm2/m128 + /// VPCMPGTQ xmm1, xmm2, xmm3/m128 /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// unsigned int _mm_crc32_u8 (unsigned int crc, unsigned char v) - /// CRC32 r32, r/m8 + /// unsigned int _mm_crc32_u8 (unsigned int crc, unsigned char v) + /// CRC32 r32, r/m8 /// public static uint Crc32(uint crc, byte data) { throw new PlatformNotSupportedException(); } /// - /// unsigned int _mm_crc32_u16 (unsigned int crc, unsigned short v) - /// CRC32 r32, r/m16 + /// unsigned int _mm_crc32_u16 (unsigned int crc, unsigned short v) + /// CRC32 r32, r/m16 /// public static uint Crc32(uint crc, ushort data) { throw new PlatformNotSupportedException(); } /// - /// unsigned int _mm_crc32_u32 (unsigned int crc, unsigned int v) - /// CRC32 r32, r/m32 + /// unsigned int _mm_crc32_u32 (unsigned int crc, unsigned int v) + /// CRC32 r32, r/m32 /// public static uint Crc32(uint crc, uint data) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse42.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse42.cs index 7eb1c84f591..bfadc313223 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse42.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Sse42.cs @@ -5,52 +5,57 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel SSE4.2 hardware instructions via intrinsics - /// + /// Provides access to X86 SSE4.2 hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Sse42 : Sse41 { internal Sse42() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the x86 SSE4.2 hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : Sse41.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } /// - /// unsigned __int64 _mm_crc32_u64 (unsigned __int64 crc, unsigned __int64 v) - /// CRC32 r64, r/m64 - /// This intrinsic is only available on 64-bit processes + /// unsigned __int64 _mm_crc32_u64 (unsigned __int64 crc, unsigned __int64 v) + /// CRC32 r64, r/m64 + /// This intrinsic is only available on 64-bit processes /// public static ulong Crc32(ulong crc, ulong data) => Crc32(crc, data); } /// - /// __m128i _mm_cmpgt_epi64 (__m128i a, __m128i b) - /// PCMPGTQ xmm1, xmm2/m128 - /// VPCMPGTQ xmm1, xmm2, xmm3/m128 + /// __m128i _mm_cmpgt_epi64 (__m128i a, __m128i b) + /// PCMPGTQ xmm1, xmm2/m128 + /// VPCMPGTQ xmm1, xmm2, xmm3/m128 /// public static Vector128 CompareGreaterThan(Vector128 left, Vector128 right) => CompareGreaterThan(left, right); /// - /// unsigned int _mm_crc32_u8 (unsigned int crc, unsigned char v) - /// CRC32 r32, r/m8 + /// unsigned int _mm_crc32_u8 (unsigned int crc, unsigned char v) + /// CRC32 r32, r/m8 /// public static uint Crc32(uint crc, byte data) => Crc32(crc, data); /// - /// unsigned int _mm_crc32_u16 (unsigned int crc, unsigned short v) - /// CRC32 r32, r/m16 + /// unsigned int _mm_crc32_u16 (unsigned int crc, unsigned short v) + /// CRC32 r32, r/m16 /// public static uint Crc32(uint crc, ushort data) => Crc32(crc, data); /// - /// unsigned int _mm_crc32_u32 (unsigned int crc, unsigned int v) - /// CRC32 r32, r/m32 + /// unsigned int _mm_crc32_u32 (unsigned int crc, unsigned int v) + /// CRC32 r32, r/m32 /// public static uint Crc32(uint crc, uint data) => Crc32(crc, data); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Ssse3.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Ssse3.PlatformNotSupported.cs index d5a1abc545a..bbcefe47c4f 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Ssse3.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Ssse3.PlatformNotSupported.cs @@ -8,194 +8,199 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel SSSE3 hardware instructions via intrinsics - /// + /// Provides access to X86 SSSE3 hardware instructions via intrinsics. [CLSCompliant(false)] public abstract class Ssse3 : Sse3 { internal Ssse3() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } + /// Provides access to the x86 SSSE3 hardware instructions, that are only available to 64-bit processes, via intrinsics. public new abstract class X64 : Sse3.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get { return false; } } } /// - /// __m128i _mm_abs_epi8 (__m128i a) - /// PABSB xmm1, xmm2/m128 - /// VPABSB xmm1, xmm2/m128 - /// VPABSB xmm1 {k1}{z}, xmm2/m128 + /// __m128i _mm_abs_epi8 (__m128i a) + /// PABSB xmm1, xmm2/m128 + /// VPABSB xmm1, xmm2/m128 + /// VPABSB xmm1 {k1}{z}, xmm2/m128 /// public static Vector128 Abs(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_abs_epi16 (__m128i a) - /// PABSW xmm1, xmm2/m128 - /// VPABSW xmm1, xmm2/m128 - /// VPABSW xmm1 {k1}{z}, xmm2/m128 + /// __m128i _mm_abs_epi16 (__m128i a) + /// PABSW xmm1, xmm2/m128 + /// VPABSW xmm1, xmm2/m128 + /// VPABSW xmm1 {k1}{z}, xmm2/m128 /// public static Vector128 Abs(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_abs_epi32 (__m128i a) - /// PABSD xmm1, xmm2/m128 - /// VPABSD xmm1, xmm2/m128 - /// VPABSD xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_abs_epi32 (__m128i a) + /// PABSD xmm1, xmm2/m128 + /// VPABSD xmm1, xmm2/m128 + /// VPABSD xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 Abs(Vector128 value) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) - /// PALIGNR xmm1, xmm2/m128, imm8 - /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 - /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) + /// PALIGNR xmm1, xmm2/m128, imm8 + /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 + /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 /// public static Vector128 AlignRight(Vector128 left, Vector128 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) - /// PALIGNR xmm1, xmm2/m128, imm8 - /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 - /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) + /// PALIGNR xmm1, xmm2/m128, imm8 + /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 + /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 /// public static Vector128 AlignRight(Vector128 left, Vector128 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) - /// PALIGNR xmm1, xmm2/m128, imm8 - /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 - /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors. + /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) + /// PALIGNR xmm1, xmm2/m128, imm8 + /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 + /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors. /// public static Vector128 AlignRight(Vector128 left, Vector128 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) - /// PALIGNR xmm1, xmm2/m128, imm8 - /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 - /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors. + /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) + /// PALIGNR xmm1, xmm2/m128, imm8 + /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 + /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors. /// public static Vector128 AlignRight(Vector128 left, Vector128 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) - /// PALIGNR xmm1, xmm2/m128, imm8 - /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 - /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors. + /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) + /// PALIGNR xmm1, xmm2/m128, imm8 + /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 + /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors. /// public static Vector128 AlignRight(Vector128 left, Vector128 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) - /// PALIGNR xmm1, xmm2/m128, imm8 - /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 - /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors. + /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) + /// PALIGNR xmm1, xmm2/m128, imm8 + /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 + /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors. /// public static Vector128 AlignRight(Vector128 left, Vector128 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) - /// PALIGNR xmm1, xmm2/m128, imm8 - /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 - /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors. + /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) + /// PALIGNR xmm1, xmm2/m128, imm8 + /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 + /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors. /// public static Vector128 AlignRight(Vector128 left, Vector128 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) - /// PALIGNR xmm1, xmm2/m128, imm8 - /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 - /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) + /// PALIGNR xmm1, xmm2/m128, imm8 + /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 + /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 /// public static Vector128 AlignRight(Vector128 left, Vector128 right, [ConstantExpected] byte mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_hadd_epi16 (__m128i a, __m128i b) - /// PHADDW xmm1, xmm2/m128 - /// VPHADDW xmm1, xmm2, xmm3/m128 + /// __m128i _mm_hadd_epi16 (__m128i a, __m128i b) + /// PHADDW xmm1, xmm2/m128 + /// VPHADDW xmm1, xmm2, xmm3/m128 /// public static Vector128 HorizontalAdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_hadd_epi32 (__m128i a, __m128i b) - /// PHADDD xmm1, xmm2/m128 - /// VPHADDD xmm1, xmm2, xmm3/m128 + /// __m128i _mm_hadd_epi32 (__m128i a, __m128i b) + /// PHADDD xmm1, xmm2/m128 + /// VPHADDD xmm1, xmm2, xmm3/m128 /// public static Vector128 HorizontalAdd(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_hadds_epi16 (__m128i a, __m128i b) - /// PHADDSW xmm1, xmm2/m128 - /// VPHADDSW xmm1, xmm2, xmm3/m128 + /// __m128i _mm_hadds_epi16 (__m128i a, __m128i b) + /// PHADDSW xmm1, xmm2/m128 + /// VPHADDSW xmm1, xmm2, xmm3/m128 /// public static Vector128 HorizontalAddSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_hsub_epi16 (__m128i a, __m128i b) - /// PHSUBW xmm1, xmm2/m128 - /// VPHSUBW xmm1, xmm2, xmm3/m128 + /// __m128i _mm_hsub_epi16 (__m128i a, __m128i b) + /// PHSUBW xmm1, xmm2/m128 + /// VPHSUBW xmm1, xmm2, xmm3/m128 /// public static Vector128 HorizontalSubtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_hsub_epi32 (__m128i a, __m128i b) - /// PHSUBD xmm1, xmm2/m128 - /// VPHSUBD xmm1, xmm2, xmm3/m128 + /// __m128i _mm_hsub_epi32 (__m128i a, __m128i b) + /// PHSUBD xmm1, xmm2/m128 + /// VPHSUBD xmm1, xmm2, xmm3/m128 /// public static Vector128 HorizontalSubtract(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_hsubs_epi16 (__m128i a, __m128i b) - /// PHSUBSW xmm1, xmm2/m128 - /// VPHSUBSW xmm1, xmm2, xmm3/m128 + /// __m128i _mm_hsubs_epi16 (__m128i a, __m128i b) + /// PHSUBSW xmm1, xmm2/m128 + /// VPHSUBSW xmm1, xmm2, xmm3/m128 /// public static Vector128 HorizontalSubtractSaturate(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_maddubs_epi16 (__m128i a, __m128i b) - /// PMADDUBSW xmm1, xmm2/m128 - /// VPMADDUBSW xmm1, xmm2, xmm3/m128 - /// VPMADDUBSW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_maddubs_epi16 (__m128i a, __m128i b) + /// PMADDUBSW xmm1, xmm2/m128 + /// VPMADDUBSW xmm1, xmm2, xmm3/m128 + /// VPMADDUBSW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 MultiplyAddAdjacent(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_mulhrs_epi16 (__m128i a, __m128i b) - /// PMULHRSW xmm1, xmm2/m128 - /// VPMULHRSW xmm1, xmm2, xmm3/m128 - /// VPMULHRSW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_mulhrs_epi16 (__m128i a, __m128i b) + /// PMULHRSW xmm1, xmm2/m128 + /// VPMULHRSW xmm1, xmm2, xmm3/m128 + /// VPMULHRSW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 MultiplyHighRoundScale(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_shuffle_epi8 (__m128i a, __m128i b) - /// PSHUFB xmm1, xmm2/m128 - /// VPSHUFB xmm1, xmm2, xmm3/m128 - /// VPSHUFB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_shuffle_epi8 (__m128i a, __m128i b) + /// PSHUFB xmm1, xmm2/m128 + /// VPSHUFB xmm1, xmm2, xmm3/m128 + /// VPSHUFB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Shuffle(Vector128 value, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_shuffle_epi8 (__m128i a, __m128i b) - /// PSHUFB xmm1, xmm2/m128 - /// VPSHUFB xmm1, xmm2, xmm3/m128 - /// VPSHUFB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_shuffle_epi8 (__m128i a, __m128i b) + /// PSHUFB xmm1, xmm2/m128 + /// VPSHUFB xmm1, xmm2, xmm3/m128 + /// VPSHUFB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Shuffle(Vector128 value, Vector128 mask) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sign_epi8 (__m128i a, __m128i b) - /// PSIGNB xmm1, xmm2/m128 - /// VPSIGNB xmm1, xmm2, xmm3/m128 + /// __m128i _mm_sign_epi8 (__m128i a, __m128i b) + /// PSIGNB xmm1, xmm2/m128 + /// VPSIGNB xmm1, xmm2, xmm3/m128 /// public static Vector128 Sign(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sign_epi16 (__m128i a, __m128i b) - /// PSIGNW xmm1, xmm2/m128 - /// VPSIGNW xmm1, xmm2, xmm3/m128 + /// __m128i _mm_sign_epi16 (__m128i a, __m128i b) + /// PSIGNW xmm1, xmm2/m128 + /// VPSIGNW xmm1, xmm2, xmm3/m128 /// public static Vector128 Sign(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } /// - /// __m128i _mm_sign_epi32 (__m128i a, __m128i b) - /// PSIGND xmm1, xmm2/m128 - /// VPSIGND xmm1, xmm2, xmm3/m128 + /// __m128i _mm_sign_epi32 (__m128i a, __m128i b) + /// PSIGND xmm1, xmm2/m128 + /// VPSIGND xmm1, xmm2, xmm3/m128 /// public static Vector128 Sign(Vector128 left, Vector128 right) { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Ssse3.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Ssse3.cs index 30acb5e3233..bf1cead8bd3 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Ssse3.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/Ssse3.cs @@ -6,197 +6,202 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel SSSE3 hardware instructions via intrinsics - /// + /// Provides access to X86 SSSE3 hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class Ssse3 : Sse3 { internal Ssse3() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the x86 SSSE3 hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : Sse3.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } } /// - /// __m128i _mm_abs_epi8 (__m128i a) - /// PABSB xmm1, xmm2/m128 - /// VPABSB xmm1, xmm2/m128 - /// VPABSB xmm1 {k1}{z}, xmm2/m128 + /// __m128i _mm_abs_epi8 (__m128i a) + /// PABSB xmm1, xmm2/m128 + /// VPABSB xmm1, xmm2/m128 + /// VPABSB xmm1 {k1}{z}, xmm2/m128 /// public static Vector128 Abs(Vector128 value) => Abs(value); /// - /// __m128i _mm_abs_epi16 (__m128i a) - /// PABSW xmm1, xmm2/m128 - /// VPABSW xmm1, xmm2/m128 - /// VPABSW xmm1 {k1}{z}, xmm2/m128 + /// __m128i _mm_abs_epi16 (__m128i a) + /// PABSW xmm1, xmm2/m128 + /// VPABSW xmm1, xmm2/m128 + /// VPABSW xmm1 {k1}{z}, xmm2/m128 /// public static Vector128 Abs(Vector128 value) => Abs(value); /// - /// __m128i _mm_abs_epi32 (__m128i a) - /// PABSD xmm1, xmm2/m128 - /// VPABSD xmm1, xmm2/m128 - /// VPABSD xmm1 {k1}{z}, xmm2/m128/m32bcst + /// __m128i _mm_abs_epi32 (__m128i a) + /// PABSD xmm1, xmm2/m128 + /// VPABSD xmm1, xmm2/m128 + /// VPABSD xmm1 {k1}{z}, xmm2/m128/m32bcst /// public static Vector128 Abs(Vector128 value) => Abs(value); /// - /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) - /// PALIGNR xmm1, xmm2/m128, imm8 - /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 - /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) + /// PALIGNR xmm1, xmm2/m128, imm8 + /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 + /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 /// public static Vector128 AlignRight(Vector128 left, Vector128 right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); /// - /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) - /// PALIGNR xmm1, xmm2/m128, imm8 - /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 - /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) + /// PALIGNR xmm1, xmm2/m128, imm8 + /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 + /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 /// public static Vector128 AlignRight(Vector128 left, Vector128 right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); /// - /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) - /// PALIGNR xmm1, xmm2/m128, imm8 - /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 - /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors. + /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) + /// PALIGNR xmm1, xmm2/m128, imm8 + /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 + /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors. /// public static Vector128 AlignRight(Vector128 left, Vector128 right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); /// - /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) - /// PALIGNR xmm1, xmm2/m128, imm8 - /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 - /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors. + /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) + /// PALIGNR xmm1, xmm2/m128, imm8 + /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 + /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors. /// public static Vector128 AlignRight(Vector128 left, Vector128 right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); /// - /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) - /// PALIGNR xmm1, xmm2/m128, imm8 - /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 - /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors. + /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) + /// PALIGNR xmm1, xmm2/m128, imm8 + /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 + /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors. /// public static Vector128 AlignRight(Vector128 left, Vector128 right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); /// - /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) - /// PALIGNR xmm1, xmm2/m128, imm8 - /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 - /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors. + /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) + /// PALIGNR xmm1, xmm2/m128, imm8 + /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 + /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors. /// public static Vector128 AlignRight(Vector128 left, Vector128 right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); /// - /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) - /// PALIGNR xmm1, xmm2/m128, imm8 - /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 - /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors. + /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) + /// PALIGNR xmm1, xmm2/m128, imm8 + /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 + /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors. /// public static Vector128 AlignRight(Vector128 left, Vector128 right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); /// - /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) - /// PALIGNR xmm1, xmm2/m128, imm8 - /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 - /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 - /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors. + /// __m128i _mm_alignr_epi8 (__m128i a, __m128i b, int count) + /// PALIGNR xmm1, xmm2/m128, imm8 + /// VPALIGNR xmm1, xmm2, xmm3/m128, imm8 + /// VPALIGNR xmm1 {k1}{z}, xmm2, xmm3/m128, imm8 + /// This intrinsic generates PALIGNR that operates over bytes rather than elements of the vectors. /// public static Vector128 AlignRight(Vector128 left, Vector128 right, [ConstantExpected] byte mask) => AlignRight(left, right, mask); /// - /// __m128i _mm_hadd_epi16 (__m128i a, __m128i b) - /// PHADDW xmm1, xmm2/m128 - /// VPHADDW xmm1, xmm2, xmm3/m128 + /// __m128i _mm_hadd_epi16 (__m128i a, __m128i b) + /// PHADDW xmm1, xmm2/m128 + /// VPHADDW xmm1, xmm2, xmm3/m128 /// public static Vector128 HorizontalAdd(Vector128 left, Vector128 right) => HorizontalAdd(left, right); /// - /// __m128i _mm_hadd_epi32 (__m128i a, __m128i b) - /// PHADDD xmm1, xmm2/m128 - /// VPHADDD xmm1, xmm2, xmm3/m128 + /// __m128i _mm_hadd_epi32 (__m128i a, __m128i b) + /// PHADDD xmm1, xmm2/m128 + /// VPHADDD xmm1, xmm2, xmm3/m128 /// public static Vector128 HorizontalAdd(Vector128 left, Vector128 right) => HorizontalAdd(left, right); /// - /// __m128i _mm_hadds_epi16 (__m128i a, __m128i b) - /// PHADDSW xmm1, xmm2/m128 - /// VPHADDSW xmm1, xmm2, xmm3/m128 + /// __m128i _mm_hadds_epi16 (__m128i a, __m128i b) + /// PHADDSW xmm1, xmm2/m128 + /// VPHADDSW xmm1, xmm2, xmm3/m128 /// public static Vector128 HorizontalAddSaturate(Vector128 left, Vector128 right) => HorizontalAddSaturate(left, right); /// - /// __m128i _mm_hsub_epi16 (__m128i a, __m128i b) - /// PHSUBW xmm1, xmm2/m128 - /// VPHSUBW xmm1, xmm2, xmm3/m128 + /// __m128i _mm_hsub_epi16 (__m128i a, __m128i b) + /// PHSUBW xmm1, xmm2/m128 + /// VPHSUBW xmm1, xmm2, xmm3/m128 /// public static Vector128 HorizontalSubtract(Vector128 left, Vector128 right) => HorizontalSubtract(left, right); /// - /// __m128i _mm_hsub_epi32 (__m128i a, __m128i b) - /// PHSUBD xmm1, xmm2/m128 - /// VPHSUBD xmm1, xmm2, xmm3/m128 + /// __m128i _mm_hsub_epi32 (__m128i a, __m128i b) + /// PHSUBD xmm1, xmm2/m128 + /// VPHSUBD xmm1, xmm2, xmm3/m128 /// public static Vector128 HorizontalSubtract(Vector128 left, Vector128 right) => HorizontalSubtract(left, right); /// - /// __m128i _mm_hsubs_epi16 (__m128i a, __m128i b) - /// PHSUBSW xmm1, xmm2/m128 - /// VPHSUBSW xmm1, xmm2, xmm3/m128 + /// __m128i _mm_hsubs_epi16 (__m128i a, __m128i b) + /// PHSUBSW xmm1, xmm2/m128 + /// VPHSUBSW xmm1, xmm2, xmm3/m128 /// public static Vector128 HorizontalSubtractSaturate(Vector128 left, Vector128 right) => HorizontalSubtractSaturate(left, right); /// - /// __m128i _mm_maddubs_epi16 (__m128i a, __m128i b) - /// PMADDUBSW xmm1, xmm2/m128 - /// VPMADDUBSW xmm1, xmm2, xmm3/m128 - /// VPMADDUBSW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_maddubs_epi16 (__m128i a, __m128i b) + /// PMADDUBSW xmm1, xmm2/m128 + /// VPMADDUBSW xmm1, xmm2, xmm3/m128 + /// VPMADDUBSW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 MultiplyAddAdjacent(Vector128 left, Vector128 right) => MultiplyAddAdjacent(left, right); /// - /// __m128i _mm_mulhrs_epi16 (__m128i a, __m128i b) - /// PMULHRSW xmm1, xmm2/m128 - /// VPMULHRSW xmm1, xmm2, xmm3/m128 - /// VPMULHRSW xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_mulhrs_epi16 (__m128i a, __m128i b) + /// PMULHRSW xmm1, xmm2/m128 + /// VPMULHRSW xmm1, xmm2, xmm3/m128 + /// VPMULHRSW xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 MultiplyHighRoundScale(Vector128 left, Vector128 right) => MultiplyHighRoundScale(left, right); /// - /// __m128i _mm_shuffle_epi8 (__m128i a, __m128i b) - /// PSHUFB xmm1, xmm2/m128 - /// VPSHUFB xmm1, xmm2, xmm3/m128 - /// VPSHUFB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_shuffle_epi8 (__m128i a, __m128i b) + /// PSHUFB xmm1, xmm2/m128 + /// VPSHUFB xmm1, xmm2, xmm3/m128 + /// VPSHUFB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Shuffle(Vector128 value, Vector128 mask) => Shuffle(value, mask); /// - /// __m128i _mm_shuffle_epi8 (__m128i a, __m128i b) - /// PSHUFB xmm1, xmm2/m128 - /// VPSHUFB xmm1, xmm2, xmm3/m128 - /// VPSHUFB xmm1 {k1}{z}, xmm2, xmm3/m128 + /// __m128i _mm_shuffle_epi8 (__m128i a, __m128i b) + /// PSHUFB xmm1, xmm2/m128 + /// VPSHUFB xmm1, xmm2, xmm3/m128 + /// VPSHUFB xmm1 {k1}{z}, xmm2, xmm3/m128 /// public static Vector128 Shuffle(Vector128 value, Vector128 mask) => Shuffle(value, mask); /// - /// __m128i _mm_sign_epi8 (__m128i a, __m128i b) - /// PSIGNB xmm1, xmm2/m128 - /// VPSIGNB xmm1, xmm2, xmm3/m128 + /// __m128i _mm_sign_epi8 (__m128i a, __m128i b) + /// PSIGNB xmm1, xmm2/m128 + /// VPSIGNB xmm1, xmm2, xmm3/m128 /// public static Vector128 Sign(Vector128 left, Vector128 right) => Sign(left, right); /// - /// __m128i _mm_sign_epi16 (__m128i a, __m128i b) - /// PSIGNW xmm1, xmm2/m128 - /// VPSIGNW xmm1, xmm2, xmm3/m128 + /// __m128i _mm_sign_epi16 (__m128i a, __m128i b) + /// PSIGNW xmm1, xmm2/m128 + /// VPSIGNW xmm1, xmm2, xmm3/m128 /// public static Vector128 Sign(Vector128 left, Vector128 right) => Sign(left, right); /// - /// __m128i _mm_sign_epi32 (__m128i a, __m128i b) - /// PSIGND xmm1, xmm2/m128 - /// VPSIGND xmm1, xmm2, xmm3/m128 + /// __m128i _mm_sign_epi32 (__m128i a, __m128i b) + /// PSIGND xmm1, xmm2/m128 + /// VPSIGND xmm1, xmm2, xmm3/m128 /// public static Vector128 Sign(Vector128 left, Vector128 right) => Sign(left, right); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Base.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Base.PlatformNotSupported.cs index b76934cd77f..97cee9edd60 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Base.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Base.PlatformNotSupported.cs @@ -7,114 +7,111 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to the x86 base hardware instructions via intrinsics - /// + /// Provides access to the x86 base hardware instructions via intrinsics. [CLSCompliant(false)] public abstract partial class X86Base { internal X86Base() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static bool IsSupported { [Intrinsic] get => false; } + /// Provides access to the x86 base hardware instructions, that are only available to 64-bit processes, via intrinsics. public abstract class X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static bool IsSupported { [Intrinsic] get => false; } /// - /// unsigned char _BitScanForward64 (unsigned __int32* index, unsigned __int64 a) - /// BSF reg reg/m64 - /// The above native signature does not directly correspond to the managed signature. + /// unsigned char _BitScanForward64 (unsigned __int32* index, unsigned __int64 a) + /// BSF reg reg/m64 + /// The above native signature does not directly correspond to the managed signature. /// /// - /// This method is to remain internal. - /// Its functionality is exposed in the public class. + /// This method is to remain internal. + /// Its functionality is exposed in the public class. /// internal static ulong BitScanForward(ulong value) { throw new PlatformNotSupportedException(); } /// - /// unsigned char _BitScanReverse64 (unsigned __int32* index, unsigned __int64 a) - /// BSR reg reg/m64 - /// The above native signature does not directly correspond to the managed signature. + /// unsigned char _BitScanReverse64 (unsigned __int32* index, unsigned __int64 a) + /// BSR reg reg/m64 + /// The above native signature does not directly correspond to the managed signature. /// /// - /// This method is to remain internal. - /// Its functionality is exposed in the public class. + /// This method is to remain internal. + /// Its functionality is exposed in the public class. /// internal static ulong BitScanReverse(ulong value) { throw new PlatformNotSupportedException(); } /// - /// unsigned __int64 _udiv128(unsigned __int64 highdividend, unsigned __int64 lowdividend, unsigned __int64 divisor, unsigned __int64* remainder) - /// DIV reg/m64 + /// unsigned __int64 _udiv128(unsigned __int64 highdividend, unsigned __int64 lowdividend, unsigned __int64 divisor, unsigned __int64* remainder) + /// DIV reg/m64 /// [Experimental(Experimentals.X86BaseDivRemDiagId, UrlFormat = Experimentals.SharedUrlFormat)] public static (ulong Quotient, ulong Remainder) DivRem(ulong lower, ulong upper, ulong divisor) { throw new PlatformNotSupportedException(); } /// - /// __int64 _div128(__int64 highdividend, __int64 lowdividend, __int64 divisor, __int64* remainder) - /// DIV reg/m64 + /// __int64 _div128(__int64 highdividend, __int64 lowdividend, __int64 divisor, __int64* remainder) + /// DIV reg/m64 /// [Experimental(Experimentals.X86BaseDivRemDiagId, UrlFormat = Experimentals.SharedUrlFormat)] public static (long Quotient, long Remainder) DivRem(ulong lower, long upper, long divisor) { throw new PlatformNotSupportedException(); } } /// - /// unsigned char _BitScanForward (unsigned __int32* index, unsigned __int32 a) - /// BSF reg reg/m32 - /// The above native signature does not directly correspond to the managed signature. + /// unsigned char _BitScanForward (unsigned __int32* index, unsigned __int32 a) + /// BSF reg reg/m32 + /// The above native signature does not directly correspond to the managed signature. /// /// - /// This method is to remain internal. - /// Its functionality is exposed in the public class. + /// This method is to remain internal. + /// Its functionality is exposed in the public class. /// internal static uint BitScanForward(uint value) { throw new PlatformNotSupportedException(); } /// - /// unsigned char _BitScanReverse (unsigned __int32* index, unsigned __int32 a) - /// BSR reg reg/m32 - /// The above native signature does not directly correspond to the managed signature. + /// unsigned char _BitScanReverse (unsigned __int32* index, unsigned __int32 a) + /// BSR reg reg/m32 + /// The above native signature does not directly correspond to the managed signature. /// /// - /// This method is to remain internal. - /// Its functionality is exposed in the public class. + /// This method is to remain internal. + /// Its functionality is exposed in the public class. /// internal static uint BitScanReverse(uint value) { throw new PlatformNotSupportedException(); } /// - /// void __cpuidex (int cpuInfo[4], int function_id, int subfunction_id); - /// CPUID + /// void __cpuidex (int cpuInfo[4], int function_id, int subfunction_id); + /// CPUID /// public static (int Eax, int Ebx, int Ecx, int Edx) CpuId(int functionId, int subFunctionId) { throw new PlatformNotSupportedException(); } - /// - /// DIV reg/m32 - /// + /// DIV reg/m32 [Experimental(Experimentals.X86BaseDivRemDiagId, UrlFormat = Experimentals.SharedUrlFormat)] public static (uint Quotient, uint Remainder) DivRem(uint lower, uint upper, uint divisor) { throw new PlatformNotSupportedException(); } - /// - /// IDIV reg/m32 - /// + /// IDIV reg/m32 [Experimental(Experimentals.X86BaseDivRemDiagId, UrlFormat = Experimentals.SharedUrlFormat)] public static (int Quotient, int Remainder) DivRem(uint lower, int upper, int divisor) { throw new PlatformNotSupportedException(); } - /// - /// IDIV reg/m - /// + /// IDIV reg/m [Experimental(Experimentals.X86BaseDivRemDiagId, UrlFormat = Experimentals.SharedUrlFormat)] public static (nuint Quotient, nuint Remainder) DivRem(nuint lower, nuint upper, nuint divisor) { throw new PlatformNotSupportedException(); } - /// - /// IDIV reg/m - /// + /// IDIV reg/m [Experimental(Experimentals.X86BaseDivRemDiagId, UrlFormat = Experimentals.SharedUrlFormat)] public static (nint Quotient, nint Remainder) DivRem(nuint lower, nint upper, nint divisor) { throw new PlatformNotSupportedException(); } /// - /// void _mm_pause (void); - /// PAUSE + /// void _mm_pause (void); + /// PAUSE /// public static void Pause() { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Base.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Base.cs index 10c34af0604..721bef9928e 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Base.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Base.cs @@ -8,86 +8,91 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to the x86 base hardware instructions via intrinsics - /// + /// Provides access to the x86 base hardware instructions via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract partial class X86Base { internal X86Base() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static bool IsSupported { get => IsSupported; } + /// Provides access to the x86 base hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public abstract class X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static bool IsSupported { get => IsSupported; } /// - /// unsigned char _BitScanForward64 (unsigned __int32* index, unsigned __int64 a) - /// BSF reg reg/m64 - /// The above native signature does not directly correspond to the managed signature. + /// unsigned char _BitScanForward64 (unsigned __int32* index, unsigned __int64 a) + /// BSF reg reg/m64 + /// The above native signature does not directly correspond to the managed signature. /// /// - /// This method is to remain internal. - /// Its functionality is exposed in the public class. + /// This method is to remain internal. + /// Its functionality is exposed in the public class. /// internal static ulong BitScanForward(ulong value) => BitScanForward(value); /// - /// unsigned char _BitScanReverse64 (unsigned __int32* index, unsigned __int64 a) - /// BSR reg reg/m64 - /// The above native signature does not directly correspond to the managed signature. + /// unsigned char _BitScanReverse64 (unsigned __int32* index, unsigned __int64 a) + /// BSR reg reg/m64 + /// The above native signature does not directly correspond to the managed signature. /// /// - /// This method is to remain internal. - /// Its functionality is exposed in the public class. + /// This method is to remain internal. + /// Its functionality is exposed in the public class. /// internal static ulong BitScanReverse(ulong value) => BitScanReverse(value); /// - /// unsigned __int64 _udiv128(unsigned __int64 highdividend, unsigned __int64 lowdividend, unsigned __int64 divisor, unsigned __int64* remainder) - /// DIV reg/m64 + /// unsigned __int64 _udiv128(unsigned __int64 highdividend, unsigned __int64 lowdividend, unsigned __int64 divisor, unsigned __int64* remainder) + /// DIV reg/m64 /// [Experimental(Experimentals.X86BaseDivRemDiagId, UrlFormat = Experimentals.SharedUrlFormat)] public static (ulong Quotient, ulong Remainder) DivRem(ulong lower, ulong upper, ulong divisor) => DivRem(lower, upper, divisor); /// - /// __int64 _div128(__int64 highdividend, __int64 lowdividend, __int64 divisor, __int64* remainder) - /// DIV reg/m64 + /// __int64 _div128(__int64 highdividend, __int64 lowdividend, __int64 divisor, __int64* remainder) + /// DIV reg/m64 /// [Experimental(Experimentals.X86BaseDivRemDiagId, UrlFormat = Experimentals.SharedUrlFormat)] public static (long Quotient, long Remainder) DivRem(ulong lower, long upper, long divisor) => DivRem(lower, upper, divisor); } /// - /// unsigned char _BitScanForward (unsigned __int32* index, unsigned __int32 a) - /// BSF reg reg/m32 - /// The above native signature does not directly correspond to the managed signature. + /// unsigned char _BitScanForward (unsigned __int32* index, unsigned __int32 a) + /// BSF reg reg/m32 + /// The above native signature does not directly correspond to the managed signature. /// /// - /// This method is to remain internal. - /// Its functionality is exposed in the public class. + /// This method is to remain internal. + /// Its functionality is exposed in the public class. /// internal static uint BitScanForward(uint value) => BitScanForward(value); /// - /// unsigned char _BitScanReverse (unsigned __int32* index, unsigned __int32 a) - /// BSR reg reg/m32 - /// The above native signature does not directly correspond to the managed signature. + /// unsigned char _BitScanReverse (unsigned __int32* index, unsigned __int32 a) + /// BSR reg reg/m32 + /// The above native signature does not directly correspond to the managed signature. /// /// - /// This method is to remain internal. - /// Its functionality is exposed in the public class. + /// This method is to remain internal. + /// Its functionality is exposed in the public class. /// internal static uint BitScanReverse(uint value) => BitScanReverse(value); /// - /// void __cpuidex (int cpuInfo[4], int function_id, int subfunction_id); - /// CPUID + /// void __cpuidex (int cpuInfo[4], int function_id, int subfunction_id); + /// CPUID /// public static unsafe (int Eax, int Ebx, int Ecx, int Edx) CpuId(int functionId, int subFunctionId) { @@ -97,34 +102,30 @@ public static unsafe (int Eax, int Ebx, int Ecx, int Edx) CpuId(int functionId, } /// - /// unsigned _udiv64(unsigned __int64 dividend, unsigned divisor, unsigned* remainder) - /// DIV reg/m32 + /// unsigned _udiv64(unsigned __int64 dividend, unsigned divisor, unsigned* remainder) + /// DIV reg/m32 /// [Experimental(Experimentals.X86BaseDivRemDiagId, UrlFormat = Experimentals.SharedUrlFormat)] public static (uint Quotient, uint Remainder) DivRem(uint lower, uint upper, uint divisor) => DivRem(lower, upper, divisor); /// - /// int _div64(__int64 dividend, int divisor, int* remainder) - /// IDIV reg/m32 + /// int _div64(__int64 dividend, int divisor, int* remainder) + /// IDIV reg/m32 /// [Experimental(Experimentals.X86BaseDivRemDiagId, UrlFormat = Experimentals.SharedUrlFormat)] public static (int Quotient, int Remainder) DivRem(uint lower, int upper, int divisor) => DivRem(lower, upper, divisor); - /// - /// IDIV reg/m - /// + /// IDIV reg/m [Experimental(Experimentals.X86BaseDivRemDiagId, UrlFormat = Experimentals.SharedUrlFormat)] public static (nuint Quotient, nuint Remainder) DivRem(nuint lower, nuint upper, nuint divisor) => DivRem(lower, upper, divisor); - /// - /// IDIV reg/m - /// + /// IDIV reg/m [Experimental(Experimentals.X86BaseDivRemDiagId, UrlFormat = Experimentals.SharedUrlFormat)] public static (nint Quotient, nint Remainder) DivRem(nuint lower, nint upper, nint divisor) => DivRem(lower, upper, divisor); /// - /// void _mm_pause (void); - /// PAUSE + /// void _mm_pause (void); + /// PAUSE /// public static void Pause() => Pause(); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Serialize.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Serialize.PlatformNotSupported.cs index 426f30107e0..2e2b7a91289 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Serialize.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Serialize.PlatformNotSupported.cs @@ -6,27 +6,30 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel SERIALIZE hardware instruction via intrinsics - /// + /// Provides access to the x86 SERIALIZE hardware instruction via intrinsics. [CLSCompliant(false)] public abstract class X86Serialize : X86Base { internal X86Serialize() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get => false; } + /// Provides access to the x86 SERIALIZE hardware instructions, which are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : X86Base.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { [Intrinsic] get => false; } } - /// - /// void _serialize (void); - /// + /// void _serialize (void); public static void Serialize() { throw new PlatformNotSupportedException(); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Serialize.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Serialize.cs index dd8a8daac5d..f186ae05ef6 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Serialize.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/X86/X86Serialize.cs @@ -6,28 +6,31 @@ namespace System.Runtime.Intrinsics.X86 { - /// - /// This class provides access to Intel SERIALIZE hardware instruction via intrinsics - /// + /// Provides access to the x86 SERIALIZE hardware instruction via intrinsics. [Intrinsic] [CLSCompliant(false)] public abstract class X86Serialize : X86Base { internal X86Serialize() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } + /// Provides access to the x86 SERIALIZE hardware instructions, that are only available to 64-bit processes, via intrinsics. [Intrinsic] public new abstract class X64 : X86Base.X64 { internal X64() { } + /// Gets a value that indicates whether the APIs in this class are supported. + /// if the APIs are supported; otherwise, . + /// A value of indicates that the APIs will throw . public static new bool IsSupported { get => IsSupported; } } - /// - /// void _serialize (void); - /// + /// void _serialize (void); public static void Serialize() => Serialize(); } diff --git a/src/libraries/System.Private.CoreLib/src/System/SearchValues/Any2CharPackedIgnoreCaseSearchValues.cs b/src/libraries/System.Private.CoreLib/src/System/SearchValues/Any2CharPackedIgnoreCaseSearchValues.cs index 1073fcf3c81..7b789febead 100644 --- a/src/libraries/System.Private.CoreLib/src/System/SearchValues/Any2CharPackedIgnoreCaseSearchValues.cs +++ b/src/libraries/System.Private.CoreLib/src/System/SearchValues/Any2CharPackedIgnoreCaseSearchValues.cs @@ -53,7 +53,7 @@ internal override int IndexOfAnyExcept(ReadOnlySpan span) => [CompExactlyDependsOn(typeof(AdvSimd))] [CompExactlyDependsOn(typeof(PackedSimd))] internal override int LastIndexOfAny(ReadOnlySpan span) => - IndexOfAnyAsciiSearcher.LastIndexOfAny( + IndexOfAnyAsciiSearcher.LastIndexOfAny( ref Unsafe.As(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -61,7 +61,7 @@ internal override int LastIndexOfAny(ReadOnlySpan span) => [CompExactlyDependsOn(typeof(AdvSimd))] [CompExactlyDependsOn(typeof(PackedSimd))] internal override int LastIndexOfAnyExcept(ReadOnlySpan span) => - IndexOfAnyAsciiSearcher.LastIndexOfAny( + IndexOfAnyAsciiSearcher.LastIndexOfAny( ref Unsafe.As(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/SearchValues/AsciiByteSearchValues.cs b/src/libraries/System.Private.CoreLib/src/System/SearchValues/AsciiByteSearchValues.cs index 57b755b2ce8..a3562f8c98a 100644 --- a/src/libraries/System.Private.CoreLib/src/System/SearchValues/AsciiByteSearchValues.cs +++ b/src/libraries/System.Private.CoreLib/src/System/SearchValues/AsciiByteSearchValues.cs @@ -1,20 +1,36 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System.Diagnostics; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics.Arm; using System.Runtime.Intrinsics.Wasm; using System.Runtime.Intrinsics.X86; +using System.Text; namespace System.Buffers { - internal sealed class AsciiByteSearchValues : SearchValues + internal sealed class AsciiByteSearchValues : SearchValues + where TUniqueLowNibble : struct, SearchValues.IRuntimeConst { private IndexOfAnyAsciiSearcher.AsciiState _state; - public AsciiByteSearchValues(ReadOnlySpan values) => - IndexOfAnyAsciiSearcher.ComputeAsciiState(values, out _state); + public AsciiByteSearchValues(ReadOnlySpan values) + { + // Despite the name being Ascii, this type may be used with non-ASCII values on ARM. + // See IndexOfAnyAsciiSearcher.CanUseUniqueLowNibbleSearch. + Debug.Assert(Ascii.IsValid(values) || (AdvSimd.IsSupported && TUniqueLowNibble.Value)); + + if (TUniqueLowNibble.Value) + { + IndexOfAnyAsciiSearcher.ComputeUniqueLowNibbleState(values, out _state); + } + else + { + IndexOfAnyAsciiSearcher.ComputeAsciiState(values, out _state); + } + } internal override byte[] GetValues() => _state.Lookup.GetByteValues(); @@ -28,7 +44,7 @@ internal override bool ContainsCore(byte value) => [CompExactlyDependsOn(typeof(PackedSimd))] [MethodImpl(MethodImplOptions.AggressiveInlining)] internal override int IndexOfAny(ReadOnlySpan span) => - IndexOfAnyAsciiSearcher.IndexOfAny( + IndexOfAnyAsciiSearcher.IndexOfAny( ref MemoryMarshal.GetReference(span), span.Length, ref _state); [CompExactlyDependsOn(typeof(Ssse3))] @@ -36,7 +52,7 @@ internal override int IndexOfAny(ReadOnlySpan span) => [CompExactlyDependsOn(typeof(PackedSimd))] [MethodImpl(MethodImplOptions.AggressiveInlining)] internal override int IndexOfAnyExcept(ReadOnlySpan span) => - IndexOfAnyAsciiSearcher.IndexOfAny( + IndexOfAnyAsciiSearcher.IndexOfAny( ref MemoryMarshal.GetReference(span), span.Length, ref _state); [CompExactlyDependsOn(typeof(Ssse3))] @@ -44,7 +60,7 @@ internal override int IndexOfAnyExcept(ReadOnlySpan span) => [CompExactlyDependsOn(typeof(PackedSimd))] [MethodImpl(MethodImplOptions.AggressiveInlining)] internal override int LastIndexOfAny(ReadOnlySpan span) => - IndexOfAnyAsciiSearcher.LastIndexOfAny( + IndexOfAnyAsciiSearcher.LastIndexOfAny( ref MemoryMarshal.GetReference(span), span.Length, ref _state); [CompExactlyDependsOn(typeof(Ssse3))] @@ -52,7 +68,7 @@ internal override int LastIndexOfAny(ReadOnlySpan span) => [CompExactlyDependsOn(typeof(PackedSimd))] [MethodImpl(MethodImplOptions.AggressiveInlining)] internal override int LastIndexOfAnyExcept(ReadOnlySpan span) => - IndexOfAnyAsciiSearcher.LastIndexOfAny( + IndexOfAnyAsciiSearcher.LastIndexOfAny( ref MemoryMarshal.GetReference(span), span.Length, ref _state); [CompExactlyDependsOn(typeof(Ssse3))] @@ -60,7 +76,7 @@ internal override int LastIndexOfAnyExcept(ReadOnlySpan span) => [CompExactlyDependsOn(typeof(PackedSimd))] [MethodImpl(MethodImplOptions.AggressiveInlining)] internal override bool ContainsAny(ReadOnlySpan span) => - IndexOfAnyAsciiSearcher.ContainsAny( + IndexOfAnyAsciiSearcher.ContainsAny( ref MemoryMarshal.GetReference(span), span.Length, ref _state); [CompExactlyDependsOn(typeof(Ssse3))] @@ -68,7 +84,7 @@ internal override bool ContainsAny(ReadOnlySpan span) => [CompExactlyDependsOn(typeof(PackedSimd))] [MethodImpl(MethodImplOptions.AggressiveInlining)] internal override bool ContainsAnyExcept(ReadOnlySpan span) => - IndexOfAnyAsciiSearcher.ContainsAny( + IndexOfAnyAsciiSearcher.ContainsAny( ref MemoryMarshal.GetReference(span), span.Length, ref _state); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/SearchValues/AsciiCharSearchValues.cs b/src/libraries/System.Private.CoreLib/src/System/SearchValues/AsciiCharSearchValues.cs index 111a3ad313b..175c2737b9a 100644 --- a/src/libraries/System.Private.CoreLib/src/System/SearchValues/AsciiCharSearchValues.cs +++ b/src/libraries/System.Private.CoreLib/src/System/SearchValues/AsciiCharSearchValues.cs @@ -1,35 +1,51 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System.Diagnostics; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Intrinsics.Arm; using System.Runtime.Intrinsics.Wasm; using System.Runtime.Intrinsics.X86; +using System.Text; namespace System.Buffers { - internal sealed class AsciiCharSearchValues : SearchValues + internal sealed class AsciiCharSearchValues : SearchValues where TOptimizations : struct, IndexOfAnyAsciiSearcher.IOptimizations + where TUniqueLowNibble : struct, SearchValues.IRuntimeConst { private IndexOfAnyAsciiSearcher.AsciiState _state; - public AsciiCharSearchValues(ReadOnlySpan values) => - IndexOfAnyAsciiSearcher.ComputeAsciiState(values, out _state); + public AsciiCharSearchValues(ReadOnlySpan values) + { + // Despite the name being Ascii, this type may be used with non-ASCII values on ARM. + // See IndexOfAnyAsciiSearcher.CanUseUniqueLowNibbleSearch. + Debug.Assert(Ascii.IsValid(values) || (AdvSimd.IsSupported && TUniqueLowNibble.Value)); + + if (TUniqueLowNibble.Value) + { + IndexOfAnyAsciiSearcher.ComputeUniqueLowNibbleState(values, out _state); + } + else + { + IndexOfAnyAsciiSearcher.ComputeAsciiState(values, out _state); + } + } internal override char[] GetValues() => _state.Lookup.GetCharValues(); [MethodImpl(MethodImplOptions.AggressiveInlining)] internal override bool ContainsCore(char value) => - _state.Lookup.Contains128(value); + _state.Lookup.Contains256(value); [CompExactlyDependsOn(typeof(Ssse3))] [CompExactlyDependsOn(typeof(AdvSimd))] [CompExactlyDependsOn(typeof(PackedSimd))] [MethodImpl(MethodImplOptions.AggressiveInlining)] internal override int IndexOfAny(ReadOnlySpan span) => - IndexOfAnyAsciiSearcher.IndexOfAny( + IndexOfAnyAsciiSearcher.IndexOfAny( ref Unsafe.As(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); [CompExactlyDependsOn(typeof(Ssse3))] @@ -37,7 +53,7 @@ internal override int IndexOfAny(ReadOnlySpan span) => [CompExactlyDependsOn(typeof(PackedSimd))] [MethodImpl(MethodImplOptions.AggressiveInlining)] internal override int IndexOfAnyExcept(ReadOnlySpan span) => - IndexOfAnyAsciiSearcher.IndexOfAny( + IndexOfAnyAsciiSearcher.IndexOfAny( ref Unsafe.As(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); [CompExactlyDependsOn(typeof(Ssse3))] @@ -45,7 +61,7 @@ internal override int IndexOfAnyExcept(ReadOnlySpan span) => [CompExactlyDependsOn(typeof(PackedSimd))] [MethodImpl(MethodImplOptions.AggressiveInlining)] internal override int LastIndexOfAny(ReadOnlySpan span) => - IndexOfAnyAsciiSearcher.LastIndexOfAny( + IndexOfAnyAsciiSearcher.LastIndexOfAny( ref Unsafe.As(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); [CompExactlyDependsOn(typeof(Ssse3))] @@ -53,7 +69,7 @@ internal override int LastIndexOfAny(ReadOnlySpan span) => [CompExactlyDependsOn(typeof(PackedSimd))] [MethodImpl(MethodImplOptions.AggressiveInlining)] internal override int LastIndexOfAnyExcept(ReadOnlySpan span) => - IndexOfAnyAsciiSearcher.LastIndexOfAny( + IndexOfAnyAsciiSearcher.LastIndexOfAny( ref Unsafe.As(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); [CompExactlyDependsOn(typeof(Ssse3))] @@ -61,7 +77,7 @@ internal override int LastIndexOfAnyExcept(ReadOnlySpan span) => [CompExactlyDependsOn(typeof(PackedSimd))] [MethodImpl(MethodImplOptions.AggressiveInlining)] internal override bool ContainsAny(ReadOnlySpan span) => - IndexOfAnyAsciiSearcher.ContainsAny( + IndexOfAnyAsciiSearcher.ContainsAny( ref Unsafe.As(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); [CompExactlyDependsOn(typeof(Ssse3))] @@ -69,7 +85,7 @@ internal override bool ContainsAny(ReadOnlySpan span) => [CompExactlyDependsOn(typeof(PackedSimd))] [MethodImpl(MethodImplOptions.AggressiveInlining)] internal override bool ContainsAnyExcept(ReadOnlySpan span) => - IndexOfAnyAsciiSearcher.ContainsAny( + IndexOfAnyAsciiSearcher.ContainsAny( ref Unsafe.As(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); } } diff --git a/src/libraries/System.Private.CoreLib/src/System/SearchValues/BitVector256.cs b/src/libraries/System.Private.CoreLib/src/System/SearchValues/BitVector256.cs index 56e68907c86..74d0836960b 100644 --- a/src/libraries/System.Private.CoreLib/src/System/SearchValues/BitVector256.cs +++ b/src/libraries/System.Private.CoreLib/src/System/SearchValues/BitVector256.cs @@ -31,10 +31,6 @@ public void Set(int c) _values[offset] |= significantBit; } - [MethodImpl(MethodImplOptions.AggressiveInlining)] - public readonly bool Contains128(char c) => - c < 128 && ContainsUnchecked(c); - [MethodImpl(MethodImplOptions.AggressiveInlining)] public readonly bool Contains256(char c) => c < 256 && ContainsUnchecked(c); diff --git a/src/libraries/System.Private.CoreLib/src/System/SearchValues/IndexOfAnyAsciiSearcher.cs b/src/libraries/System.Private.CoreLib/src/System/SearchValues/IndexOfAnyAsciiSearcher.cs index 36965c24da7..c722387c4f4 100644 --- a/src/libraries/System.Private.CoreLib/src/System/SearchValues/IndexOfAnyAsciiSearcher.cs +++ b/src/libraries/System.Private.CoreLib/src/System/SearchValues/IndexOfAnyAsciiSearcher.cs @@ -13,24 +13,35 @@ namespace System.Buffers { internal static class IndexOfAnyAsciiSearcher { + // Reused for both ASCII and UniqueLowNibble searches since the state looks the same (a Vector128). public struct AsciiState(Vector128 bitmap, BitVector256 lookup) { public Vector256 Bitmap = Vector256.Create(bitmap); - public BitVector256 Lookup = lookup; + public readonly BitVector256 Lookup = lookup; public readonly AsciiState CreateInverse() => new AsciiState(~Bitmap._lower, Lookup.CreateInverse()); } - public struct AnyByteState(Vector128 bitmap0, Vector128 bitmap1, BitVector256 lookup) + public readonly struct AnyByteState(Vector128 bitmap0, Vector128 bitmap1, BitVector256 lookup) { - public Vector256 Bitmap0 = Vector256.Create(bitmap0); - public Vector256 Bitmap1 = Vector256.Create(bitmap1); - public BitVector256 Lookup = lookup; + public readonly Vector256 Bitmap0 = Vector256.Create(bitmap0); + public readonly Vector256 Bitmap1 = Vector256.Create(bitmap1); + public readonly BitVector256 Lookup = lookup; } internal static bool IsVectorizationSupported => Ssse3.IsSupported || AdvSimd.Arm64.IsSupported || PackedSimd.IsSupported; + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static unsafe void SetBitmapBit(byte* bitmap, int value) + { + Debug.Assert((uint)value <= 127); + + int highNibble = value >> 4; + int lowNibble = value & 0xF; + bitmap[(uint)lowNibble] |= (byte)(1 << highNibble); + } + internal static unsafe void ComputeAnyByteState(ReadOnlySpan values, out AnyByteState state) { // The exact format of these bitmaps differs from the other ComputeBitmap overloads as it's meant for the full [0, 255] range algorithm. @@ -46,16 +57,13 @@ internal static unsafe void ComputeAnyByteState(ReadOnlySpan values, out A { lookupLocal.Set(b); - int highNibble = b >> 4; - int lowNibble = b & 0xF; - - if (highNibble < 8) + if (b < 128) { - bitmapLocal0[(uint)lowNibble] |= (byte)(1 << highNibble); + SetBitmapBit(bitmapLocal0, b); } else { - bitmapLocal1[(uint)lowNibble] |= (byte)(1 << (highNibble - 8)); + SetBitmapBit(bitmapLocal1, b - 128); } } @@ -81,14 +89,83 @@ internal static unsafe void ComputeAsciiState(ReadOnlySpan values, out Asc } lookupLocal.Set(value); + SetBitmapBit(bitmapLocal, value); + } + + state = new AsciiState(bitmapSpace, lookupLocal); + } - int highNibble = value >> 4; - int lowNibble = value & 0xF; + public static bool CanUseUniqueLowNibbleSearch(ReadOnlySpan values, int maxInclusive) + where T : struct, IUnsignedNumber + { + Debug.Assert(typeof(T) == typeof(byte) || typeof(T) == typeof(char)); - bitmapLocal[(uint)lowNibble] |= (byte)(1 << highNibble); + if (!IsVectorizationSupported || values.Length > 16) + { + return false; } - state = new AsciiState(bitmapSpace, lookupLocal); + if (Ssse3.IsSupported && maxInclusive > 127) + { + // We could support values higher than 127 if we did the "& 0xF" before calling into Shuffle in IndexOfAnyLookupCore. + // We currently optimize for the common case of ASCII characters instead, saving an instruction there. + return false; + } + + if (typeof(T) == typeof(char) && maxInclusive >= byte.MaxValue) + { + // When packing UTF-16 characters into bytes, values may saturate to 255 (false positives), hence ">=" instead of ">". + return false; + } + + // We assume there are no duplicates to simplify the logic (if there are any, they just won't use this searching approach). + int seenNibbles = 0; + + foreach (T tValue in values) + { + int bit = 1 << (int.CreateChecked(tValue) & 0xF); + + if ((seenNibbles & bit) != 0) + { + // We already saw a value with the same low nibble. + return false; + } + + seenNibbles |= bit; + } + + return true; + } + + public static void ComputeUniqueLowNibbleState(ReadOnlySpan values, out AsciiState state) + where T : struct, IUnsignedNumber + { + Debug.Assert(typeof(T) == typeof(byte) || typeof(T) == typeof(char)); + + Vector128 valuesByLowNibble = default; + BitVector256 lookup = default; + + foreach (T tValue in values) + { + byte value = byte.CreateTruncating(tValue); + lookup.Set(value); + valuesByLowNibble.SetElementUnsafe(value & 0xF, value); + } + + // Elements of 'valuesByLowNibble' where no value had that low nibble will be left uninitialized at 0. + // For most, that is okay, as only the zero character in the input could ever match against them, + // but where such input characters will always be mapped to the 0th element of 'valuesByLowNibble'. + // + // That does mean we could still see false positivies if none of the values had a low nibble of zero. + // To avoid that, we can replace the 0th element with any other byte that has a non-zero low nibble. + // The zero character will no longer match, and the new value we pick won't match either as + // it will be mapped to a different element in 'valuesByLowNibble' given its non-zero low nibble. + if (valuesByLowNibble.GetElement(0) == 0 && !lookup.Contains(0)) + { + valuesByLowNibble.SetElementUnsafe(0, (byte)1); + } + + state = new AsciiState(valuesByLowNibble, lookup); } [MethodImpl(MethodImplOptions.AggressiveInlining)] @@ -104,10 +181,7 @@ private static unsafe bool TryComputeBitmap(ReadOnlySpan values, byte* bit return false; } - int highNibble = c >> 4; - int lowNibble = c & 0xF; - - bitmapLocal[(uint)lowNibble] |= (byte)(1 << highNibble); + SetBitmapBit(bitmapLocal, c); } needleContainsZero = (bitmap[0] & 1) != 0; @@ -147,8 +221,8 @@ private static unsafe bool TryIndexOfAny(ref short searchSpace, int se state.Bitmap = Vector256.Create(state.Bitmap.GetLower()); index = (Ssse3.IsSupported || PackedSimd.IsSupported) && needleContainsZero - ? IndexOfAny(ref searchSpace, searchSpaceLength, ref state) - : IndexOfAny(ref searchSpace, searchSpaceLength, ref state); + ? IndexOfAny(ref searchSpace, searchSpaceLength, ref state) + : IndexOfAny(ref searchSpace, searchSpaceLength, ref state); return true; } } @@ -174,8 +248,8 @@ private static unsafe bool TryLastIndexOfAny(ref short searchSpace, in state.Bitmap = Vector256.Create(state.Bitmap.GetLower()); index = (Ssse3.IsSupported || PackedSimd.IsSupported) && needleContainsZero - ? LastIndexOfAny(ref searchSpace, searchSpaceLength, ref state) - : LastIndexOfAny(ref searchSpace, searchSpaceLength, ref state); + ? LastIndexOfAny(ref searchSpace, searchSpaceLength, ref state) + : LastIndexOfAny(ref searchSpace, searchSpaceLength, ref state); return true; } } @@ -188,27 +262,30 @@ private static unsafe bool TryLastIndexOfAny(ref short searchSpace, in [CompExactlyDependsOn(typeof(Ssse3))] [CompExactlyDependsOn(typeof(AdvSimd))] [CompExactlyDependsOn(typeof(PackedSimd))] - public static bool ContainsAny(ref short searchSpace, int searchSpaceLength, ref AsciiState state) + public static bool ContainsAny(ref short searchSpace, int searchSpaceLength, ref AsciiState state) where TNegator : struct, INegator - where TOptimizations : struct, IOptimizations => - IndexOfAnyCore>(ref searchSpace, searchSpaceLength, ref state); + where TOptimizations : struct, IOptimizations + where TUniqueLowNibble : struct, SearchValues.IRuntimeConst => + IndexOfAnyCore>(ref searchSpace, searchSpaceLength, ref state); [MethodImpl(MethodImplOptions.AggressiveInlining)] [CompExactlyDependsOn(typeof(Ssse3))] [CompExactlyDependsOn(typeof(AdvSimd))] [CompExactlyDependsOn(typeof(PackedSimd))] - public static int IndexOfAny(ref short searchSpace, int searchSpaceLength, ref AsciiState state) + public static int IndexOfAny(ref short searchSpace, int searchSpaceLength, ref AsciiState state) where TNegator : struct, INegator - where TOptimizations : struct, IOptimizations => - IndexOfAnyCore>(ref searchSpace, searchSpaceLength, ref state); + where TOptimizations : struct, IOptimizations + where TUniqueLowNibble : struct, SearchValues.IRuntimeConst => + IndexOfAnyCore>(ref searchSpace, searchSpaceLength, ref state); [CompExactlyDependsOn(typeof(Ssse3))] [CompExactlyDependsOn(typeof(AdvSimd))] [CompExactlyDependsOn(typeof(PackedSimd))] - private static TResult IndexOfAnyCore(ref short searchSpace, int searchSpaceLength, ref AsciiState state) + private static TResult IndexOfAnyCore(ref short searchSpace, int searchSpaceLength, ref AsciiState state) where TResult : struct where TNegator : struct, INegator where TOptimizations : struct, IOptimizations + where TUniqueLowNibble : struct, SearchValues.IRuntimeConst where TResultMapper : struct, IResultMapper { ref short currentSearchSpace = ref searchSpace; @@ -220,7 +297,7 @@ private static TResult IndexOfAnyCore source0 = Vector256.LoadUnsafe(ref currentSearchSpace); Vector256 source1 = Vector256.LoadUnsafe(ref currentSearchSpace, (nuint)Vector256.Count); - Vector256 result = IndexOfAnyLookup(source0, source1, bitmap256); + Vector256 result = IndexOfAnyLookup(source0, source1, bitmap256); if (result != Vector256.Zero) { return TResultMapper.FirstIndex(ref searchSpace, ref currentSearchSpace, result); @@ -276,7 +353,7 @@ private static TResult IndexOfAnyCore source0 = Vector256.LoadUnsafe(ref firstVector); Vector256 source1 = Vector256.LoadUnsafe(ref oneVectorAwayFromEnd); - Vector256 result = IndexOfAnyLookup(source0, source1, bitmap256); + Vector256 result = IndexOfAnyLookup(source0, source1, bitmap256); if (result != Vector256.Zero) { return TResultMapper.FirstIndexOverlapped(ref searchSpace, ref firstVector, ref oneVectorAwayFromEnd, result); @@ -305,7 +382,7 @@ private static TResult IndexOfAnyCore source0 = Vector128.LoadUnsafe(ref currentSearchSpace); Vector128 source1 = Vector128.LoadUnsafe(ref currentSearchSpace, (nuint)Vector128.Count); - Vector128 result = IndexOfAnyLookup(source0, source1, bitmap); + Vector128 result = IndexOfAnyLookup(source0, source1, bitmap); if (result != Vector128.Zero) { return TResultMapper.FirstIndex(ref searchSpace, ref currentSearchSpace, result); @@ -329,7 +406,7 @@ private static TResult IndexOfAnyCore source0 = Vector128.LoadUnsafe(ref firstVector); Vector128 source1 = Vector128.LoadUnsafe(ref oneVectorAwayFromEnd); - Vector128 result = IndexOfAnyLookup(source0, source1, bitmap); + Vector128 result = IndexOfAnyLookup(source0, source1, bitmap); if (result != Vector128.Zero) { return TResultMapper.FirstIndexOverlapped(ref searchSpace, ref firstVector, ref oneVectorAwayFromEnd, result); @@ -342,16 +419,17 @@ private static TResult IndexOfAnyCore(ref short searchSpace, int searchSpaceLength, ref AsciiState state) + public static int LastIndexOfAny(ref short searchSpace, int searchSpaceLength, ref AsciiState state) where TNegator : struct, INegator where TOptimizations : struct, IOptimizations + where TUniqueLowNibble : struct, SearchValues.IRuntimeConst { if (searchSpaceLength < Vector128.Count) { for (int i = searchSpaceLength - 1; i >= 0; i--) { char c = (char)Unsafe.Add(ref searchSpace, i); - if (TNegator.NegateIfNeeded(state.Lookup.Contains128(c))) + if (TNegator.NegateIfNeeded(state.Lookup.Contains256(c))) { return i; } @@ -385,7 +463,7 @@ public static int LastIndexOfAny(ref short searchSpace Vector256 source0 = Vector256.LoadUnsafe(ref currentSearchSpace); Vector256 source1 = Vector256.LoadUnsafe(ref currentSearchSpace, (nuint)Vector256.Count); - Vector256 result = IndexOfAnyLookup(source0, source1, bitmap256); + Vector256 result = IndexOfAnyLookup(source0, source1, bitmap256); if (result != Vector256.Zero) { return ComputeLastIndex(ref searchSpace, ref currentSearchSpace, result); @@ -407,7 +485,7 @@ public static int LastIndexOfAny(ref short searchSpace Vector256 source0 = Vector256.LoadUnsafe(ref searchSpace); Vector256 source1 = Vector256.LoadUnsafe(ref secondVector); - Vector256 result = IndexOfAnyLookup(source0, source1, bitmap256); + Vector256 result = IndexOfAnyLookup(source0, source1, bitmap256); if (result != Vector256.Zero) { return ComputeLastIndexOverlapped(ref searchSpace, ref secondVector, result); @@ -436,7 +514,7 @@ public static int LastIndexOfAny(ref short searchSpace Vector128 source0 = Vector128.LoadUnsafe(ref currentSearchSpace); Vector128 source1 = Vector128.LoadUnsafe(ref currentSearchSpace, (nuint)Vector128.Count); - Vector128 result = IndexOfAnyLookup(source0, source1, bitmap); + Vector128 result = IndexOfAnyLookup(source0, source1, bitmap); if (result != Vector128.Zero) { return ComputeLastIndex(ref searchSpace, ref currentSearchSpace, result); @@ -458,7 +536,7 @@ public static int LastIndexOfAny(ref short searchSpace Vector128 source0 = Vector128.LoadUnsafe(ref searchSpace); Vector128 source1 = Vector128.LoadUnsafe(ref secondVector); - Vector128 result = IndexOfAnyLookup(source0, source1, bitmap); + Vector128 result = IndexOfAnyLookup(source0, source1, bitmap); if (result != Vector128.Zero) { return ComputeLastIndexOverlapped(ref searchSpace, ref secondVector, result); @@ -472,24 +550,27 @@ public static int LastIndexOfAny(ref short searchSpace [CompExactlyDependsOn(typeof(Ssse3))] [CompExactlyDependsOn(typeof(AdvSimd))] [CompExactlyDependsOn(typeof(PackedSimd))] - public static bool ContainsAny(ref byte searchSpace, int searchSpaceLength, ref AsciiState state) - where TNegator : struct, INegator => - IndexOfAnyCore>(ref searchSpace, searchSpaceLength, ref state); + public static bool ContainsAny(ref byte searchSpace, int searchSpaceLength, ref AsciiState state) + where TNegator : struct, INegator + where TUniqueLowNibble : struct, SearchValues.IRuntimeConst => + IndexOfAnyCore>(ref searchSpace, searchSpaceLength, ref state); [MethodImpl(MethodImplOptions.AggressiveInlining)] [CompExactlyDependsOn(typeof(Ssse3))] [CompExactlyDependsOn(typeof(AdvSimd))] [CompExactlyDependsOn(typeof(PackedSimd))] - public static int IndexOfAny(ref byte searchSpace, int searchSpaceLength, ref AsciiState state) - where TNegator : struct, INegator => - IndexOfAnyCore>(ref searchSpace, searchSpaceLength, ref state); + public static int IndexOfAny(ref byte searchSpace, int searchSpaceLength, ref AsciiState state) + where TNegator : struct, INegator + where TUniqueLowNibble : struct, SearchValues.IRuntimeConst => + IndexOfAnyCore>(ref searchSpace, searchSpaceLength, ref state); [CompExactlyDependsOn(typeof(Ssse3))] [CompExactlyDependsOn(typeof(AdvSimd))] [CompExactlyDependsOn(typeof(PackedSimd))] - private static TResult IndexOfAnyCore(ref byte searchSpace, int searchSpaceLength, ref AsciiState state) + private static TResult IndexOfAnyCore(ref byte searchSpace, int searchSpaceLength, ref AsciiState state) where TResult : struct where TNegator : struct, INegator + where TUniqueLowNibble : struct, SearchValues.IRuntimeConst where TResultMapper : struct, IResultMapper { ref byte currentSearchSpace = ref searchSpace; @@ -530,7 +611,7 @@ private static TResult IndexOfAnyCore(ref byte { Vector256 source = Vector256.LoadUnsafe(ref currentSearchSpace); - Vector256 result = TNegator.NegateIfNeeded(IndexOfAnyLookupCore(source, bitmap256)); + Vector256 result = TNegator.NegateIfNeeded(IndexOfAnyLookupCore(source, bitmap256)); if (result != Vector256.Zero) { return TResultMapper.FirstIndex(ref searchSpace, ref currentSearchSpace, result); @@ -555,7 +636,7 @@ private static TResult IndexOfAnyCore(ref byte Vector128 source1 = Vector128.LoadUnsafe(ref halfVectorAwayFromEnd); Vector256 source = Vector256.Create(source0, source1); - Vector256 result = TNegator.NegateIfNeeded(IndexOfAnyLookupCore(source, bitmap256)); + Vector256 result = TNegator.NegateIfNeeded(IndexOfAnyLookupCore(source, bitmap256)); if (result != Vector256.Zero) { return TResultMapper.FirstIndexOverlapped(ref searchSpace, ref firstVector, ref halfVectorAwayFromEnd, result); @@ -579,7 +660,7 @@ private static TResult IndexOfAnyCore(ref byte { Vector128 source = Vector128.LoadUnsafe(ref currentSearchSpace); - Vector128 result = TNegator.NegateIfNeeded(IndexOfAnyLookupCore(source, bitmap)); + Vector128 result = TNegator.NegateIfNeeded(IndexOfAnyLookupCore(source, bitmap)); if (result != Vector128.Zero) { return TResultMapper.FirstIndex(ref searchSpace, ref currentSearchSpace, result); @@ -604,7 +685,7 @@ private static TResult IndexOfAnyCore(ref byte ulong source1 = Unsafe.ReadUnaligned(ref halfVectorAwayFromEnd); Vector128 source = Vector128.Create(source0, source1).AsByte(); - Vector128 result = TNegator.NegateIfNeeded(IndexOfAnyLookupCore(source, bitmap)); + Vector128 result = TNegator.NegateIfNeeded(IndexOfAnyLookupCore(source, bitmap)); if (result != Vector128.Zero) { return TResultMapper.FirstIndexOverlapped(ref searchSpace, ref firstVector, ref halfVectorAwayFromEnd, result); @@ -617,8 +698,9 @@ private static TResult IndexOfAnyCore(ref byte [CompExactlyDependsOn(typeof(Ssse3))] [CompExactlyDependsOn(typeof(AdvSimd))] [CompExactlyDependsOn(typeof(PackedSimd))] - public static int LastIndexOfAny(ref byte searchSpace, int searchSpaceLength, ref AsciiState state) + public static int LastIndexOfAny(ref byte searchSpace, int searchSpaceLength, ref AsciiState state) where TNegator : struct, INegator + where TUniqueLowNibble : struct, SearchValues.IRuntimeConst { if (searchSpaceLength < sizeof(ulong)) { @@ -656,7 +738,7 @@ public static int LastIndexOfAny(ref byte searchSpace, int searchSpace Vector256 source = Vector256.LoadUnsafe(ref currentSearchSpace); - Vector256 result = TNegator.NegateIfNeeded(IndexOfAnyLookupCore(source, bitmap256)); + Vector256 result = TNegator.NegateIfNeeded(IndexOfAnyLookupCore(source, bitmap256)); if (result != Vector256.Zero) { return ComputeLastIndex(ref searchSpace, ref currentSearchSpace, result); @@ -679,7 +761,7 @@ public static int LastIndexOfAny(ref byte searchSpace, int searchSpace Vector128 source1 = Vector128.LoadUnsafe(ref secondVector); Vector256 source = Vector256.Create(source0, source1); - Vector256 result = TNegator.NegateIfNeeded(IndexOfAnyLookupCore(source, bitmap256)); + Vector256 result = TNegator.NegateIfNeeded(IndexOfAnyLookupCore(source, bitmap256)); if (result != Vector256.Zero) { return ComputeLastIndexOverlapped(ref searchSpace, ref secondVector, result); @@ -705,7 +787,7 @@ public static int LastIndexOfAny(ref byte searchSpace, int searchSpace Vector128 source = Vector128.LoadUnsafe(ref currentSearchSpace); - Vector128 result = TNegator.NegateIfNeeded(IndexOfAnyLookupCore(source, bitmap)); + Vector128 result = TNegator.NegateIfNeeded(IndexOfAnyLookupCore(source, bitmap)); if (result != Vector128.Zero) { return ComputeLastIndex(ref searchSpace, ref currentSearchSpace, result); @@ -728,7 +810,7 @@ public static int LastIndexOfAny(ref byte searchSpace, int searchSpace ulong source1 = Unsafe.ReadUnaligned(ref secondVector); Vector128 source = Vector128.Create(source0, source1).AsByte(); - Vector128 result = TNegator.NegateIfNeeded(IndexOfAnyLookupCore(source, bitmap)); + Vector128 result = TNegator.NegateIfNeeded(IndexOfAnyLookupCore(source, bitmap)); if (result != Vector128.Zero) { return ComputeLastIndexOverlapped(ref searchSpace, ref secondVector, result); @@ -1020,13 +1102,14 @@ public static int LastIndexOfAny(ref byte searchSpace, int searchSpace [CompExactlyDependsOn(typeof(Sse2))] [CompExactlyDependsOn(typeof(AdvSimd))] [CompExactlyDependsOn(typeof(PackedSimd))] - private static Vector128 IndexOfAnyLookup(Vector128 source0, Vector128 source1, Vector128 bitmapLookup) + private static Vector128 IndexOfAnyLookup(Vector128 source0, Vector128 source1, Vector128 bitmapLookup) where TNegator : struct, INegator where TOptimizations : struct, IOptimizations + where TUniqueLowNibble : struct, SearchValues.IRuntimeConst { Vector128 source = TOptimizations.PackSources(source0.AsUInt16(), source1.AsUInt16()); - Vector128 result = IndexOfAnyLookupCore(source, bitmapLookup); + Vector128 result = IndexOfAnyLookupCore(source, bitmapLookup); return TNegator.NegateIfNeeded(result); } @@ -1035,55 +1118,86 @@ private static Vector128 IndexOfAnyLookup(Vector [CompExactlyDependsOn(typeof(Ssse3))] [CompExactlyDependsOn(typeof(AdvSimd))] [CompExactlyDependsOn(typeof(PackedSimd))] - private static Vector128 IndexOfAnyLookupCore(Vector128 source, Vector128 bitmapLookup) + private static Vector128 IndexOfAnyLookupCore(Vector128 source, Vector128 bitmapLookup) + where TUniqueLowNibble : struct, SearchValues.IRuntimeConst { - // On X86, the Ssse3.Shuffle instruction will already perform an implicit 'AND 0xF' on the indices, so we can skip it. - // For values above 127, Ssse3.Shuffle will also set the result to 0. This is fine as we don't want non-ASCII values to match anyway. - Vector128 lowNibbles = Ssse3.IsSupported - ? source - : source & Vector128.Create((byte)0xF); - - // On ARM, we have an instruction for an arithmetic right shift of 1-byte signed values. - // The shift will map values above 127 to values above 16, which the shuffle will then map to 0. - // On X86 and WASM, use a logical right shift instead. - Vector128 highNibbles = AdvSimd.IsSupported - ? AdvSimd.ShiftRightArithmetic(source.AsSByte(), 4).AsByte() - : source >>> 4; - - // The bitmapLookup represents a 8x16 table of bits, indicating whether a character is present in the needle. - // Lookup the rows via the lower nibble and the column via the higher nibble. - Vector128 bitMask = Vector128.ShuffleUnsafe(bitmapLookup, lowNibbles); - - // For values above 127, the high nibble will be above 7. We construct the positions vector for the shuffle such that those values map to 0. - Vector128 bitPositions = Vector128.ShuffleUnsafe(Vector128.Create(0x8040201008040201, 0).AsByte(), highNibbles); - - Vector128 result = bitMask & bitPositions; - return result; + if (TUniqueLowNibble.Value) + { + // Based on http://0x80.pl/articles/simd-byte-lookup.html#special-case-3-unique-lower-and-higher-nibbles + + // On X86, the Ssse3.Shuffle instruction will already perform an implicit 'AND 0xF' on the indices, so we can skip it. + // For values above 127, Ssse3.Shuffle will also set the result to 0. This is fine as we only use this approach if + // all values are <= 127 when Ssse3 is supported (see CanUseUniqueLowNibbleSearch). + // False positives from values mapped to 0 will be ruled out by the Vector128.Equals comparison below. + Vector128 lowNibbles = Ssse3.IsSupported + ? source + : source & Vector128.Create((byte)0xF); + + // We use a shuffle to look up potential matches for each byte based on its low nibble. + // Since all values have a unique low nibble, there's at most one potential match per nibble. + Vector128 values = Vector128.ShuffleUnsafe(bitmapLookup, lowNibbles); + + // Compare potential matches with the source to rule out false positives that have a different high nibble. + return Vector128.Equals(source, values); + } + else + { + // On X86, the Ssse3.Shuffle instruction will already perform an implicit 'AND 0xF' on the indices, so we can skip it. + // For values above 127, Ssse3.Shuffle will also set the result to 0. This is fine as we don't want non-ASCII values to match anyway. + Vector128 lowNibbles = Ssse3.IsSupported + ? source + : source & Vector128.Create((byte)0xF); + + // On ARM, we have an instruction for an arithmetic right shift of 1-byte signed values. + // The shift will map values above 127 to values above 16, which the shuffle will then map to 0. + // On X86 and WASM, use a logical right shift instead. + Vector128 highNibbles = AdvSimd.IsSupported + ? AdvSimd.ShiftRightArithmetic(source.AsSByte(), 4).AsByte() + : source >>> 4; + + // The bitmapLookup represents a 8x16 table of bits, indicating whether a character is present in the needle. + // Lookup the rows via the lower nibble and the column via the higher nibble. + Vector128 bitMask = Vector128.ShuffleUnsafe(bitmapLookup, lowNibbles); + + // For values above 127, the high nibble will be above 7. We construct the positions vector for the shuffle such that those values map to 0. + Vector128 bitPositions = Vector128.ShuffleUnsafe(Vector128.Create(0x8040201008040201, 0).AsByte(), highNibbles); + + return bitMask & bitPositions; + } } [MethodImpl(MethodImplOptions.AggressiveInlining)] [CompExactlyDependsOn(typeof(Avx2))] - private static Vector256 IndexOfAnyLookup(Vector256 source0, Vector256 source1, Vector256 bitmapLookup) + private static Vector256 IndexOfAnyLookup(Vector256 source0, Vector256 source1, Vector256 bitmapLookup) where TNegator : struct, INegator where TOptimizations : struct, IOptimizations + where TUniqueLowNibble : struct, SearchValues.IRuntimeConst { Vector256 source = TOptimizations.PackSources(source0.AsUInt16(), source1.AsUInt16()); - Vector256 result = IndexOfAnyLookupCore(source, bitmapLookup); + Vector256 result = IndexOfAnyLookupCore(source, bitmapLookup); return TNegator.NegateIfNeeded(result); } [MethodImpl(MethodImplOptions.AggressiveInlining)] [CompExactlyDependsOn(typeof(Avx2))] - private static Vector256 IndexOfAnyLookupCore(Vector256 source, Vector256 bitmapLookup) + private static Vector256 IndexOfAnyLookupCore(Vector256 source, Vector256 bitmapLookup) + where TUniqueLowNibble : struct, SearchValues.IRuntimeConst { // See comments in IndexOfAnyLookupCore(Vector128) above for more details. - Vector256 highNibbles = source >>> 4; - Vector256 bitMask = Avx2.Shuffle(bitmapLookup, source); - Vector256 bitPositions = Avx2.Shuffle(Vector256.Create(0x8040201008040201).AsByte(), highNibbles); - Vector256 result = bitMask & bitPositions; - return result; + if (TUniqueLowNibble.Value) + { + Vector256 values = Avx2.Shuffle(bitmapLookup, source); + return Vector256.Equals(source, values); + } + else + { + Vector256 highNibbles = source >>> 4; + Vector256 bitMask = Avx2.Shuffle(bitmapLookup, source); + Vector256 bitPositions = Avx2.Shuffle(Vector256.Create(0x8040201008040201).AsByte(), highNibbles); + return bitMask & bitPositions; + } } [MethodImpl(MethodImplOptions.AggressiveInlining)] diff --git a/src/libraries/System.Private.CoreLib/src/System/SearchValues/ProbabilisticWithAsciiCharSearchValues.cs b/src/libraries/System.Private.CoreLib/src/System/SearchValues/ProbabilisticWithAsciiCharSearchValues.cs index 7b05c3f8a3b..eb07969130a 100644 --- a/src/libraries/System.Private.CoreLib/src/System/SearchValues/ProbabilisticWithAsciiCharSearchValues.cs +++ b/src/libraries/System.Private.CoreLib/src/System/SearchValues/ProbabilisticWithAsciiCharSearchValues.cs @@ -56,7 +56,7 @@ internal override int IndexOfAny(ReadOnlySpan span) { Debug.Assert(_inverseAsciiState.Lookup.Contains(0), "The inverse bitmap did not contain a 0."); - offset = IndexOfAnyAsciiSearcher.IndexOfAny( + offset = IndexOfAnyAsciiSearcher.IndexOfAny( ref Unsafe.As(ref MemoryMarshal.GetReference(span)), span.Length, ref _inverseAsciiState); @@ -66,7 +66,7 @@ ref Unsafe.As(ref MemoryMarshal.GetReference(span)), Debug.Assert(!(Ssse3.IsSupported || PackedSimd.IsSupported) || !_inverseAsciiState.Lookup.Contains(0), "The inverse bitmap contained a 0, but we're not using Ssse3AndWasmHandleZeroInNeedle."); - offset = IndexOfAnyAsciiSearcher.IndexOfAny( + offset = IndexOfAnyAsciiSearcher.IndexOfAny( ref Unsafe.As(ref MemoryMarshal.GetReference(span)), span.Length, ref _inverseAsciiState); @@ -105,7 +105,7 @@ internal override int IndexOfAnyExcept(ReadOnlySpan span) if (IndexOfAnyAsciiSearcher.IsVectorizationSupported && span.Length >= Vector128.Count && char.IsAscii(span[0])) { // Do a regular IndexOfAnyExcept for the ASCII characters. The search will stop if we encounter a non-ASCII char. - offset = IndexOfAnyAsciiSearcher.IndexOfAny( + offset = IndexOfAnyAsciiSearcher.IndexOfAny( ref Unsafe.As(ref MemoryMarshal.GetReference(span)), span.Length, ref _asciiState); @@ -155,7 +155,7 @@ internal override int LastIndexOfAny(ReadOnlySpan span) { Debug.Assert(_inverseAsciiState.Lookup.Contains(0), "The inverse bitmap did not contain a 0."); - offset = IndexOfAnyAsciiSearcher.LastIndexOfAny( + offset = IndexOfAnyAsciiSearcher.LastIndexOfAny( ref Unsafe.As(ref MemoryMarshal.GetReference(span)), span.Length, ref _inverseAsciiState); @@ -165,7 +165,7 @@ ref Unsafe.As(ref MemoryMarshal.GetReference(span)), Debug.Assert(!(Ssse3.IsSupported || PackedSimd.IsSupported) || !_inverseAsciiState.Lookup.Contains(0), "The inverse bitmap contained a 0, but we're not using Ssse3AndWasmHandleZeroInNeedle."); - offset = IndexOfAnyAsciiSearcher.LastIndexOfAny( + offset = IndexOfAnyAsciiSearcher.LastIndexOfAny( ref Unsafe.As(ref MemoryMarshal.GetReference(span)), span.Length, ref _inverseAsciiState); @@ -194,7 +194,7 @@ internal override int LastIndexOfAnyExcept(ReadOnlySpan span) if (IndexOfAnyAsciiSearcher.IsVectorizationSupported && span.Length >= Vector128.Count && char.IsAscii(span[^1])) { // Do a regular LastIndexOfAnyExcept for the ASCII characters. The search will stop if we encounter a non-ASCII char. - int offset = IndexOfAnyAsciiSearcher.LastIndexOfAny( + int offset = IndexOfAnyAsciiSearcher.LastIndexOfAny( ref Unsafe.As(ref MemoryMarshal.GetReference(span)), span.Length, ref _asciiState); diff --git a/src/libraries/System.Private.CoreLib/src/System/SearchValues/SearchValues.cs b/src/libraries/System.Private.CoreLib/src/System/SearchValues/SearchValues.cs index e02192a70eb..1bd81b6b4ff 100644 --- a/src/libraries/System.Private.CoreLib/src/System/SearchValues/SearchValues.cs +++ b/src/libraries/System.Private.CoreLib/src/System/SearchValues/SearchValues.cs @@ -41,6 +41,13 @@ public static SearchValues Create(params ReadOnlySpan values) return new RangeByteSearchValues(minInclusive, maxInclusive); } + // Depending on the hardware, UniqueLowNibble can be faster than even range or 2 values. + // It's currently consistently faster than 4/5 values on all tested platforms (Arm, Avx2, Avx512). + if (values.Length >= 4 && IndexOfAnyAsciiSearcher.CanUseUniqueLowNibbleSearch(values, maxInclusive)) + { + return new AsciiByteSearchValues(values); + } + if (values.Length <= 5) { Debug.Assert(values.Length is 2 or 3 or 4 or 5); @@ -55,7 +62,7 @@ public static SearchValues Create(params ReadOnlySpan values) if (IndexOfAnyAsciiSearcher.IsVectorizationSupported && maxInclusive < 128) { - return new AsciiByteSearchValues(values); + return new AsciiByteSearchValues(values); } return new AnyByteSearchValues(values); @@ -122,29 +129,39 @@ public static SearchValues Create(params ReadOnlySpan values) : new Any3SearchValues(shortValues); } - // IndexOfAnyAsciiSearcher for chars is slower than Any3CharSearchValues, but faster than Any4SearchValues - if (IndexOfAnyAsciiSearcher.IsVectorizationSupported && maxInclusive < 128) + // If the values are sets of 2 ASCII letters with both cases, we can use an approach that + // reduces the number of comparisons by masking off the bit that differs between lower and upper case (0x20). + // While this most commonly applies to ASCII letters, it also works for other values that differ by 0x20 (e.g. "[]{}" => "{}"). + if (IndexOfAnyAsciiSearcher.IsVectorizationSupported && PackedSpanHelpers.PackedIndexOfIsSupported && + maxInclusive < 128 && values.Length == 4 && minInclusive > 0) { - // If the values are sets of 2 ASCII letters with both cases, we can use an approach that - // reduces the number of comparisons by masking off the bit that differs between lower and upper case (0x20). - // While this most commonly applies to ASCII letters, it also works for other values that differ by 0x20 (e.g. "[]{}" => "{}"). - if (PackedSpanHelpers.PackedIndexOfIsSupported && values.Length == 4 && minInclusive > 0) + Span copy = stackalloc char[4]; + values.CopyTo(copy); + copy.Sort(); + + if ((copy[0] ^ copy[2]) == 0x20 && + (copy[1] ^ copy[3]) == 0x20) { - Span copy = stackalloc char[4]; - values.CopyTo(copy); - copy.Sort(); - - if ((copy[0] ^ copy[2]) == 0x20 && - (copy[1] ^ copy[3]) == 0x20) - { - // We pick the higher two values (with the 0x20 bit set). "AaBb" => 'a', 'b' - return new Any2CharPackedIgnoreCaseSearchValues(copy[2], copy[3]); - } + // We pick the higher two values (with the 0x20 bit set). "AaBb" => 'a', 'b' + return new Any2CharPackedIgnoreCaseSearchValues(copy[2], copy[3]); } + } + // Depending on the hardware, UniqueLowNibble can be faster than most implementations we currently prefer above. + // It's currently consistently faster than 4/5 values or Ascii on all tested platforms (Arm, Avx2, Avx512). + if (IndexOfAnyAsciiSearcher.CanUseUniqueLowNibbleSearch(values, maxInclusive)) + { return (Ssse3.IsSupported || PackedSimd.IsSupported) && minInclusive == 0 - ? new AsciiCharSearchValues(values) - : new AsciiCharSearchValues(values); + ? new AsciiCharSearchValues(values) + : new AsciiCharSearchValues(values); + } + + // IndexOfAnyAsciiSearcher for chars is slower than Any3CharSearchValues, but faster than Any4SearchValues + if (IndexOfAnyAsciiSearcher.IsVectorizationSupported && maxInclusive < 128) + { + return (Ssse3.IsSupported || PackedSimd.IsSupported) && minInclusive == 0 + ? new AsciiCharSearchValues(values) + : new AsciiCharSearchValues(values); } if (values.Length == 4) @@ -162,7 +179,7 @@ public static SearchValues Create(params ReadOnlySpan values) // If we have both ASCII and non-ASCII characters, use an implementation that // does an optimistic ASCII fast-path and then falls back to the ProbabilisticMap. - return (Ssse3.IsSupported || PackedSimd.IsSupported) && values.Contains('\0') + return (Ssse3.IsSupported || PackedSimd.IsSupported) && minInclusive == 0 ? new ProbabilisticWithAsciiCharSearchValues(values, maxInclusive) : new ProbabilisticWithAsciiCharSearchValues(values, maxInclusive); } diff --git a/src/libraries/System.Private.CoreLib/src/System/SearchValues/Strings/Helpers/AhoCorasick.cs b/src/libraries/System.Private.CoreLib/src/System/SearchValues/Strings/Helpers/AhoCorasick.cs index ebc94616ae6..ad3cdfe2e28 100644 --- a/src/libraries/System.Private.CoreLib/src/System/SearchValues/Strings/Helpers/AhoCorasick.cs +++ b/src/libraries/System.Private.CoreLib/src/System/SearchValues/Strings/Helpers/AhoCorasick.cs @@ -49,7 +49,7 @@ public readonly bool ShouldUseAsciiFastScan for (int i = 0; i < 128; i++) { - if (_startingAsciiChars.Lookup.Contains128((char)i)) + if (_startingAsciiChars.Lookup.Contains256((char)i)) { frequency += CharacterFrequencyHelper.AsciiFrequency[i]; } @@ -96,7 +96,7 @@ private readonly int IndexOfAnyCore(ReadOnly // If '\0' is one of the starting chars and we're running on Ssse3 hardware, this may return false-positives. // False-positives here are okay, we'll just rule them out below. While we could flow the Ssse3AndWasmHandleZeroInNeedle // generic through, we expect such values to be rare enough that introducing more code is not worth it. - int offset = IndexOfAnyAsciiSearcher.IndexOfAny( + int offset = IndexOfAnyAsciiSearcher.IndexOfAny( ref Unsafe.As(ref Unsafe.Add(ref MemoryMarshal.GetReference(span), i)), remainingLength, ref Unsafe.AsRef(in _startingAsciiChars)); @@ -205,7 +205,7 @@ private readonly int IndexOfAnyCaseInsensitiveUnicode(ReadOnly if (remainingLength >= Vector128.Count) { - int offset = IndexOfAnyAsciiSearcher.IndexOfAny( + int offset = IndexOfAnyAsciiSearcher.IndexOfAny( ref Unsafe.As(ref Unsafe.Add(ref MemoryMarshal.GetReference(span), i)), remainingLength, ref Unsafe.AsRef(in _startingAsciiChars)); diff --git a/src/libraries/System.Private.CoreLib/src/System/StartupHookProvider.cs b/src/libraries/System.Private.CoreLib/src/System/StartupHookProvider.cs index 4683f6b19ca..5a5a6db49d8 100644 --- a/src/libraries/System.Private.CoreLib/src/System/StartupHookProvider.cs +++ b/src/libraries/System.Private.CoreLib/src/System/StartupHookProvider.cs @@ -18,6 +18,7 @@ internal static partial class StartupHookProvider private const string InitializeMethodName = "Initialize"; private const string DisallowedSimpleAssemblyNameSuffix = ".dll"; + [FeatureSwitchDefinition("System.StartupHookProvider.IsSupported")] private static bool IsSupported => AppContext.TryGetSwitch("System.StartupHookProvider.IsSupported", out bool isSupported) ? isSupported : true; private struct StartupHookNameOrPath diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/AutoreleasePool.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/AutoreleasePool.cs index dc1e266ca30..59cabf53397 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/AutoreleasePool.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/AutoreleasePool.cs @@ -2,6 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; namespace System.Threading { @@ -26,6 +27,7 @@ private static bool CheckEnableAutoreleasePool() #endif } + [FeatureSwitchDefinition("System.Threading.Thread.EnableAutoreleasePool")] public static bool EnableAutoreleasePool { get; } = CheckEnableAutoreleasePool(); [ThreadStatic] diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/CancellationTokenSource.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/CancellationTokenSource.cs index 26c2eb70785..7ea36b67c97 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/CancellationTokenSource.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/CancellationTokenSource.cs @@ -22,6 +22,7 @@ namespace System.Threading /// concurrently from multiple threads. /// /// + [DebuggerDisplay("IsCancellationRequested = {IsCancellationRequested}")] public class CancellationTokenSource : IDisposable { /// A that's already canceled. diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Interlocked.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Interlocked.cs index 625be12066c..e7514a8034d 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Interlocked.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Interlocked.cs @@ -84,7 +84,7 @@ public static short Exchange(ref short location1, short value) => [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe byte Exchange(ref byte location1, byte value) { -#if !MONO && (TARGET_X86 || TARGET_AMD64 || TARGET_ARM64 || TARGET_WASM) +#if (MONO && (TARGET_AMD64 || TARGET_ARM64 || TARGET_WASM)) || (!MONO && (TARGET_X86 || TARGET_AMD64 || TARGET_ARM64 || TARGET_WASM)) return Exchange(ref location1, value); // Must expand intrinsic #else // this relies on GC keeping 4B alignment for refs and on subtracting to such alignment being in the same object @@ -123,7 +123,7 @@ public static unsafe byte Exchange(ref byte location1, byte value) [CLSCompliant(false)] public static unsafe ushort Exchange(ref ushort location1, ushort value) { -#if !MONO && (TARGET_X86 || TARGET_AMD64 || TARGET_ARM64 || TARGET_WASM) +#if ((MONO && (TARGET_AMD64 || TARGET_ARM64 || TARGET_WASM)) || !MONO && (TARGET_X86 || TARGET_AMD64 || TARGET_ARM64 || TARGET_WASM)) return Exchange(ref location1, value); // Must expand intrinsic #else // this relies on GC keeping 4B alignment for refs and on subtracting to such alignment being in the same object @@ -322,7 +322,7 @@ public static short CompareExchange(ref short location1, short value, short comp [MethodImpl(MethodImplOptions.AggressiveInlining)] public static unsafe byte CompareExchange(ref byte location1, byte value, byte comparand) { -#if !MONO && (TARGET_X86 || TARGET_AMD64 || TARGET_ARM64 || TARGET_WASM) +#if (MONO && (TARGET_ARM64 || TARGET_AMD64 || TARGET_WASM)) || (!MONO && (TARGET_X86 || TARGET_AMD64 || TARGET_ARM64 || TARGET_WASM)) return CompareExchange(ref location1, value, comparand); // Must expand intrinsic #else // this relies on GC keeping 4B alignment for refs and on subtracting to such alignment being in the same object @@ -365,7 +365,7 @@ public static unsafe byte CompareExchange(ref byte location1, byte value, byte c [CLSCompliant(false)] public static unsafe ushort CompareExchange(ref ushort location1, ushort value, ushort comparand) { -#if !MONO && (TARGET_X86 || TARGET_AMD64 || TARGET_ARM64 || TARGET_WASM) +#if (MONO && (TARGET_ARM64 || TARGET_AMD64 || TARGET_WASM)) || (!MONO && (TARGET_X86 || TARGET_AMD64 || TARGET_ARM64 || TARGET_WASM)) return CompareExchange(ref location1, value, comparand); // Must expand intrinsic #else // this relies on GC keeping 4B alignment for refs and on subtracting to such alignment being in the same object diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/ManualResetEventSlim.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/ManualResetEventSlim.cs index 37f8c06af04..a9b8c10c033 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/ManualResetEventSlim.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/ManualResetEventSlim.cs @@ -350,6 +350,9 @@ public void Reset() #endif public void Wait() { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif Wait(Timeout.Infinite, CancellationToken.None); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/RegisteredWaitHandle.Portable.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/RegisteredWaitHandle.Portable.cs index 2fb8d1fb3f6..74dbefe5869 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/RegisteredWaitHandle.Portable.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/RegisteredWaitHandle.Portable.cs @@ -55,6 +55,9 @@ public sealed partial class RegisteredWaitHandle : MarshalByRefObject internal RegisteredWaitHandle(WaitHandle waitHandle, _ThreadPoolWaitOrTimerCallback callbackHelper, int millisecondsTimeout, bool repeating) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif #if WINDOWS Debug.Assert(!ThreadPool.UseWindowsThreadPool); #endif diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/SemaphoreSlim.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/SemaphoreSlim.cs index 5340ecaeccc..bab6bbd332b 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/SemaphoreSlim.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/SemaphoreSlim.cs @@ -174,6 +174,9 @@ public SemaphoreSlim(int initialCount, int maxCount) [UnsupportedOSPlatform("browser")] public void Wait() { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif // Call wait with infinite timeout Wait(Timeout.Infinite, CancellationToken.None); } @@ -191,6 +194,9 @@ public void Wait() [UnsupportedOSPlatform("browser")] public void Wait(CancellationToken cancellationToken) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif // Call wait with infinite timeout Wait(Timeout.Infinite, cancellationToken); } @@ -210,6 +216,9 @@ public void Wait(CancellationToken cancellationToken) [UnsupportedOSPlatform("browser")] public bool Wait(TimeSpan timeout) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif // Validate the timeout long totalMilliseconds = (long)timeout.TotalMilliseconds; if (totalMilliseconds < -1 || totalMilliseconds > int.MaxValue) @@ -241,6 +250,9 @@ public bool Wait(TimeSpan timeout) [UnsupportedOSPlatform("browser")] public bool Wait(TimeSpan timeout, CancellationToken cancellationToken) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif // Validate the timeout long totalMilliseconds = (long)timeout.TotalMilliseconds; if (totalMilliseconds < -1 || totalMilliseconds > int.MaxValue) @@ -266,6 +278,9 @@ public bool Wait(TimeSpan timeout, CancellationToken cancellationToken) [UnsupportedOSPlatform("browser")] public bool Wait(int millisecondsTimeout) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif return Wait(millisecondsTimeout, CancellationToken.None); } @@ -284,6 +299,9 @@ public bool Wait(int millisecondsTimeout) [UnsupportedOSPlatform("browser")] public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif CheckDispose(); #if FEATURE_WASM_MANAGED_THREADS Thread.AssureBlockingPossible(); @@ -433,6 +451,9 @@ public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken) [UnsupportedOSPlatform("browser")] private bool WaitUntilCountOrTimeout(int millisecondsTimeout, uint startTime, CancellationToken cancellationToken) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif int remainingWaitMilliseconds = Timeout.Infinite; // Wait on the monitor as long as the count is zero diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/Task.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/Task.cs index 56d8acf0cd8..ab5c875d091 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/Task.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/Task.cs @@ -819,6 +819,7 @@ private protected virtual bool ShouldNotifyDebuggerOfWaitCompletion /// Gets whether the task's debugger notification for wait completion bit is set. /// true if the bit is set; false if it's not set. + [FeatureSwitchDefinition("System.Diagnostics.Debugger.IsSupported")] internal bool IsWaitNotificationEnabled => // internal only to enable unit tests; would otherwise be private (m_stateFlags & (int)TaskStateFlags.WaitCompletionNotification) != 0; @@ -2966,6 +2967,9 @@ internal bool InternalWait(int millisecondsTimeout, CancellationToken cancellati // to be able to see the method on the stack and inspect arguments). private bool InternalWaitCore(int millisecondsTimeout, CancellationToken cancellationToken) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif // If the task has already completed, there's nothing to wait for. bool returnValue = IsCompleted; if (returnValue) @@ -4681,6 +4685,9 @@ internal void RemoveContinuation(object continuationObject) // could be TaskCont [MethodImpl(MethodImplOptions.NoOptimization)] // this is needed for the parallel debugger public static void WaitAll(params Task[] tasks) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif if (tasks is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.tasks); @@ -4706,6 +4713,9 @@ public static void WaitAll(params Task[] tasks) [UnsupportedOSPlatform("browser")] public static void WaitAll(params ReadOnlySpan tasks) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif bool waitResult = WaitAllCore(tasks, Timeout.Infinite, default); Debug.Assert(waitResult, "expected wait to succeed"); } @@ -4743,6 +4753,9 @@ public static void WaitAll(params ReadOnlySpan tasks) [MethodImpl(MethodImplOptions.NoOptimization)] // this is needed for the parallel debugger public static bool WaitAll(Task[] tasks, TimeSpan timeout) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif long totalMilliseconds = (long)timeout.TotalMilliseconds; if (totalMilliseconds is < -1 or > int.MaxValue) { @@ -4787,6 +4800,9 @@ public static bool WaitAll(Task[] tasks, TimeSpan timeout) [MethodImpl(MethodImplOptions.NoOptimization)] // this is needed for the parallel debugger public static bool WaitAll(Task[] tasks, int millisecondsTimeout) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif if (tasks is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.tasks); @@ -4821,6 +4837,9 @@ public static bool WaitAll(Task[] tasks, int millisecondsTimeout) [MethodImpl(MethodImplOptions.NoOptimization)] // this is needed for the parallel debugger public static void WaitAll(Task[] tasks, CancellationToken cancellationToken) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif if (tasks is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.tasks); @@ -4867,6 +4886,9 @@ public static void WaitAll(Task[] tasks, CancellationToken cancellationToken) [MethodImpl(MethodImplOptions.NoOptimization)] // this is needed for the parallel debugger public static bool WaitAll(Task[] tasks, int millisecondsTimeout, CancellationToken cancellationToken) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif if (tasks is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.tasks); @@ -4889,6 +4911,9 @@ public static bool WaitAll(Task[] tasks, int millisecondsTimeout, CancellationTo [UnsupportedOSPlatform("browser")] public static void WaitAll(IEnumerable tasks, CancellationToken cancellationToken = default) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif if (tasks is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.tasks); @@ -4907,6 +4932,9 @@ public static void WaitAll(IEnumerable tasks, CancellationToken cancellati [UnsupportedOSPlatform("browser")] private static bool WaitAllCore(ReadOnlySpan tasks, int millisecondsTimeout, CancellationToken cancellationToken) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif if (millisecondsTimeout < -1) { ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.millisecondsTimeout); @@ -5037,6 +5065,9 @@ private static void AddToList(T item, ref List? list, int initSize) [UnsupportedOSPlatform("browser")] private static bool WaitAllBlockingCore(List tasks, int millisecondsTimeout, CancellationToken cancellationToken) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif Debug.Assert(tasks != null, "Expected a non-null list of tasks"); Debug.Assert(tasks.Count > 0, "Expected at least one task"); @@ -6234,6 +6265,7 @@ public static Task WhenAll(IEnumerable> tasks) /// /// Creates a task that will complete when all of the supplied tasks have completed. /// + /// The type of the result returned by the tasks. /// The tasks to wait on for completion. /// A task that represents the completion of all of the supplied tasks. /// @@ -6274,6 +6306,7 @@ public static Task WhenAll(params Task[] tasks) /// /// Creates a task that will complete when all of the supplied tasks have completed. /// + /// The type of the result returned by the tasks. /// The tasks to wait on for completion. /// A task that represents the completion of all of the supplied tasks. /// @@ -6648,6 +6681,7 @@ public static Task WhenAny(IEnumerable tasks) => /// /// Creates a task that will complete when any of the supplied tasks have completed. /// + /// The type of the result returned by the tasks. /// The tasks to wait on for completion. /// A task that represents the completion of one of the supplied tasks. The return Task's Result is the task that completed. /// @@ -6722,6 +6756,7 @@ private static Task WhenAny(IEnumerable tasks) where TTask /// /// Creates a task that will complete when any of the supplied tasks have completed. /// + /// The type of the result returned by the tasks. /// The tasks to wait on for completion. /// A task that represents the completion of one of the supplied tasks. The return Task's Result is the task that completed. /// @@ -6744,6 +6779,7 @@ public static Task> WhenAny(params Task[] tasks) /// /// Creates a task that will complete when any of the supplied tasks have completed. /// + /// The type of the result returned by the tasks. /// The tasks to wait on for completion. /// A task that represents the completion of one of the supplied tasks. The return Task's Result is the task that completed. /// @@ -6757,6 +6793,7 @@ public static Task> WhenAny(params ReadOnlySpanCreates a task that will complete when either of the supplied tasks have completed. + /// The type of the result returned by the tasks. /// The first task to wait on for completion. /// The second task to wait on for completion. /// A task that represents the completion of one of the supplied tasks. The return Task's Result is the task that completed. @@ -6773,6 +6810,7 @@ public static Task> WhenAny(Task task1, Task /// Creates a task that will complete when any of the supplied tasks have completed. /// + /// The type of the result returned by the tasks. /// The tasks to wait on for completion. /// A task that represents the completion of one of the supplied tasks. The return Task's Result is the task that completed. /// @@ -6806,14 +6844,18 @@ public static IAsyncEnumerable WhenEach(params Task[] tasks) } /// + /// The tasks to iterate through as they complete. public static IAsyncEnumerable WhenEach(ReadOnlySpan tasks) => // TODO https://github.com/dotnet/runtime/issues/77873: Add params WhenEachState.Iterate(WhenEachState.Create(tasks)); /// + /// The tasks to iterate through as they complete. public static IAsyncEnumerable WhenEach(IEnumerable tasks) => WhenEachState.Iterate(WhenEachState.Create(tasks)); /// + /// The type of the result returned by the tasks. + /// The tasks to iterate through as they complete. public static IAsyncEnumerable> WhenEach(params Task[] tasks) { ArgumentNullException.ThrowIfNull(tasks); @@ -6821,10 +6863,14 @@ public static IAsyncEnumerable> WhenEach(params Task + /// The type of the result returned by the tasks. + /// The tasks to iterate through as they complete. public static IAsyncEnumerable> WhenEach(ReadOnlySpan> tasks) => // TODO https://github.com/dotnet/runtime/issues/77873: Add params WhenEachState.Iterate>(WhenEachState.Create(ReadOnlySpan.CastUp(tasks))); /// + /// The type of the result returned by the tasks. + /// The tasks to iterate through as they complete. public static IAsyncEnumerable> WhenEach(IEnumerable> tasks) => WhenEachState.Iterate>(WhenEachState.Create(tasks)); diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/TaskAsyncEnumerableExtensions.ToBlockingEnumerable.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/TaskAsyncEnumerableExtensions.ToBlockingEnumerable.cs index 4c165a91392..2b66d88540b 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/TaskAsyncEnumerableExtensions.ToBlockingEnumerable.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/TaskAsyncEnumerableExtensions.ToBlockingEnumerable.cs @@ -26,6 +26,9 @@ public static partial class TaskAsyncEnumerableExtensions [UnsupportedOSPlatform("browser")] public static IEnumerable ToBlockingEnumerable(this IAsyncEnumerable source, CancellationToken cancellationToken = default) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif IAsyncEnumerator enumerator = source.GetAsyncEnumerator(cancellationToken); // A ManualResetEventSlim variant that lets us reuse the same // awaiter callback allocation across the entire enumeration. @@ -79,6 +82,9 @@ public ManualResetEventWithAwaiterSupport() [UnsupportedOSPlatform("browser")] public void Wait(TAwaiter awaiter) where TAwaiter : ICriticalNotifyCompletion { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif awaiter.UnsafeOnCompleted(_onCompleted); Wait(); Reset(); diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/TaskAsyncEnumerableExtensions.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/TaskAsyncEnumerableExtensions.cs index 15560f3d1e8..796080a24e7 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/TaskAsyncEnumerableExtensions.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Tasks/TaskAsyncEnumerableExtensions.cs @@ -11,7 +11,7 @@ public static partial class TaskAsyncEnumerableExtensions { /// Configures how awaits on the tasks returned from an async disposable will be performed. /// The source async disposable. - /// Whether to capture and marshal back to the current context. + /// to capture and marshal back to the current context; otherwise, . /// The configured async disposable. public static ConfiguredAsyncDisposable ConfigureAwait(this IAsyncDisposable source, bool continueOnCapturedContext) => new ConfiguredAsyncDisposable(source, continueOnCapturedContext); @@ -19,7 +19,7 @@ public static ConfiguredAsyncDisposable ConfigureAwait(this IAsyncDisposable sou /// Configures how awaits on the tasks returned from an async iteration will be performed. /// The type of the objects being iterated. /// The source enumerable being iterated. - /// Whether to capture and marshal back to the current context. + /// to capture and marshal back to the current context; otherwise, . /// The configured enumerable. public static ConfiguredCancelableAsyncEnumerable ConfigureAwait( this IAsyncEnumerable source, bool continueOnCapturedContext) => diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.Unix.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.Unix.cs index 359c889c975..ef2038c86aa 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.Unix.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.Unix.cs @@ -13,27 +13,21 @@ public sealed partial class Thread { // these methods are temporarily accessed via UnsafeAccessor from generated code until we have it in public API, probably in WASI preview3 and promises #if TARGET_WASI - internal static System.Threading.Tasks.Task RegisterWasiPollableHandle(int handle) + internal static System.Threading.Tasks.Task RegisterWasiPollableHandle(int handle, bool ownsPollable, CancellationToken cancellationToken) { - return WasiEventLoop.RegisterWasiPollableHandle(handle); + return WasiEventLoop.RegisterWasiPollableHandle(handle, ownsPollable, cancellationToken); } - internal static int PollWasiEventLoopUntilResolved(Task mainTask) + internal static T PollWasiEventLoopUntilResolved(Task mainTask) { - while (!mainTask.IsCompleted) - { - WasiEventLoop.DispatchWasiEventLoop(); - } - var exception = mainTask.Exception; - if (exception is not null) - { - throw exception; - } - - return mainTask.Result; + return WasiEventLoop.PollWasiEventLoopUntilResolved(mainTask); } -#endif + internal static void PollWasiEventLoopUntilResolvedVoid(Task mainTask) + { + WasiEventLoop.PollWasiEventLoopUntilResolvedVoid(mainTask); + } +#endif // TARGET_WASI // the closest analog to Sleep(0) on Unix is sched_yield internal static void UninterruptibleSleep0() => Thread.Yield(); diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.cs index 7af434b641a..ed4aaf75758 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Thread.cs @@ -149,15 +149,21 @@ public Thread(ParameterizedThreadStart start, int maxStackSize) } #if (!TARGET_BROWSER && !TARGET_WASI) || FEATURE_WASM_MANAGED_THREADS + [UnsupportedOSPlatformGuard("wasi")] [UnsupportedOSPlatformGuard("browser")] + [UnsupportedOSPlatformGuard("wasi")] internal static bool IsThreadStartSupported => true; internal static bool IsInternalThreadStartSupported => true; #elif FEATURE_WASM_PERFTRACING + [UnsupportedOSPlatformGuard("wasi")] [UnsupportedOSPlatformGuard("browser")] + [UnsupportedOSPlatformGuard("wasi")] internal static bool IsThreadStartSupported => false; internal static bool IsInternalThreadStartSupported => true; #else + [UnsupportedOSPlatformGuard("wasi")] [UnsupportedOSPlatformGuard("browser")] + [UnsupportedOSPlatformGuard("wasi")] internal static bool IsThreadStartSupported => false; internal static bool IsInternalThreadStartSupported => false; #endif @@ -197,6 +203,9 @@ internal static void ThrowIfNoThreadStart(bool internalThread = false) private void Start(object? parameter, bool captureContext, bool internalThread = false) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif ThrowIfNoThreadStart(internalThread); StartHelper? startHelper = _startHelper; diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPool.Windows.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPool.Windows.cs index 0da875498af..9006732641d 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPool.Windows.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPool.Windows.cs @@ -2,6 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Versioning; @@ -10,6 +11,7 @@ namespace System.Threading { public static partial class ThreadPool { + [FeatureSwitchDefinition("System.Threading.ThreadPool.UseWindowsThreadPool")] internal static bool UseWindowsThreadPool { get; } = AppContextConfigHelper.GetBooleanConfig("System.Threading.ThreadPool.UseWindowsThreadPool", "DOTNET_ThreadPool_UseWindowsThreadPool"); diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPoolWorkQueue.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPoolWorkQueue.cs index bc0fe4556bb..69a59198a40 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPoolWorkQueue.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPoolWorkQueue.cs @@ -906,10 +906,7 @@ internal static bool Dispatch() // thread because it sees a Determining or Scheduled stage, and the current thread is the last thread processing // work items, the current thread must either see the work item queued by the enqueuer, or it must see a stage of // Scheduled, and try to dequeue again or request another thread. -#if !TARGET_WASI - // TODO https://github.com/dotnet/runtime/issues/104803 Debug.Assert(workQueue._separated.queueProcessingStage == QueueProcessingStage.Scheduled); -#endif workQueue._separated.queueProcessingStage = QueueProcessingStage.Determining; Interlocked.MemoryBarrier(); @@ -1393,7 +1390,11 @@ void IThreadPoolWorkItem.Execute() currentThread.ResetThreadPoolThread(); } - ThreadInt64PersistentCounter.Add(tl.threadLocalCompletionCountObject!, completedCount); + // Discount a work item here to avoid counting most of the queue processing work items + if (completedCount > 1) + { + ThreadInt64PersistentCounter.Add(tl.threadLocalCompletionCountObject!, completedCount - 1); + } } } @@ -1620,6 +1621,9 @@ public static RegisteredWaitHandle RegisterWaitForSingleObject( bool executeOnlyOnce // NOTE: we do not allow other options that allow the callback to be queued as an APC ) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif if (millisecondsTimeOutInterval > (uint)int.MaxValue && millisecondsTimeOutInterval != uint.MaxValue) throw new ArgumentOutOfRangeException(nameof(millisecondsTimeOutInterval), SR.ArgumentOutOfRange_LessEqualToIntegerMaxVal); return RegisterWaitForSingleObject(waitObject, callBack, state, millisecondsTimeOutInterval, executeOnlyOnce, true); @@ -1637,6 +1641,9 @@ public static RegisteredWaitHandle UnsafeRegisterWaitForSingleObject( bool executeOnlyOnce // NOTE: we do not allow other options that allow the callback to be queued as an APC ) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif if (millisecondsTimeOutInterval > (uint)int.MaxValue && millisecondsTimeOutInterval != uint.MaxValue) throw new ArgumentOutOfRangeException(nameof(millisecondsTimeOutInterval), SR.ArgumentOutOfRange_NeedNonNegOrNegative1); return RegisterWaitForSingleObject(waitObject, callBack, state, millisecondsTimeOutInterval, executeOnlyOnce, false); @@ -1668,6 +1675,9 @@ public static RegisteredWaitHandle UnsafeRegisterWaitForSingleObject( bool executeOnlyOnce // NOTE: we do not allow other options that allow the callback to be queued as an APC ) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif ArgumentOutOfRangeException.ThrowIfLessThan(millisecondsTimeOutInterval, -1); return RegisterWaitForSingleObject(waitObject, callBack, state, (uint)millisecondsTimeOutInterval, executeOnlyOnce, false); } @@ -1683,6 +1693,9 @@ public static RegisteredWaitHandle RegisterWaitForSingleObject( bool executeOnlyOnce // NOTE: we do not allow other options that allow the callback to be queued as an APC ) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif ArgumentOutOfRangeException.ThrowIfLessThan(millisecondsTimeOutInterval, -1); ArgumentOutOfRangeException.ThrowIfGreaterThan(millisecondsTimeOutInterval, int.MaxValue); return RegisterWaitForSingleObject(waitObject, callBack, state, (uint)millisecondsTimeOutInterval, executeOnlyOnce, true); @@ -1699,6 +1712,9 @@ public static RegisteredWaitHandle UnsafeRegisterWaitForSingleObject( bool executeOnlyOnce // NOTE: we do not allow other options that allow the callback to be queued as an APC ) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif ArgumentOutOfRangeException.ThrowIfLessThan(millisecondsTimeOutInterval, -1); ArgumentOutOfRangeException.ThrowIfGreaterThan(millisecondsTimeOutInterval, int.MaxValue); return RegisterWaitForSingleObject(waitObject, callBack, state, (uint)millisecondsTimeOutInterval, executeOnlyOnce, false); @@ -1715,6 +1731,9 @@ public static RegisteredWaitHandle RegisterWaitForSingleObject( bool executeOnlyOnce ) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif long tm = (long)timeout.TotalMilliseconds; ArgumentOutOfRangeException.ThrowIfLessThan(tm, -1, nameof(timeout)); @@ -1734,6 +1753,9 @@ public static RegisteredWaitHandle UnsafeRegisterWaitForSingleObject( bool executeOnlyOnce ) { +#if TARGET_WASI + if (OperatingSystem.IsWasi()) throw new PlatformNotSupportedException(); // TODO remove with https://github.com/dotnet/runtime/pull/107185 +#endif long tm = (long)timeout.TotalMilliseconds; ArgumentOutOfRangeException.ThrowIfLessThan(tm, -1, nameof(timeout)); diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiEventLoop.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiEventLoop.cs index 379c5c001c0..5034e23dd01 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiEventLoop.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiEventLoop.cs @@ -3,72 +3,206 @@ using System.Collections.Generic; using System.Threading.Tasks; -using WasiPollWorld.wit.imports.wasi.io.v0_2_1; +using WasiPollWorld.wit.imports.wasi.io.v0_2_0; +using Pollable = WasiPollWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable; +using MonotonicClockInterop = WasiPollWorld.wit.imports.wasi.clocks.v0_2_0.MonotonicClockInterop; namespace System.Threading { internal static class WasiEventLoop { - private static List> s_pollables = new(); + // TODO: if the Pollable never resolves and and the Task is abandoned + // it will be leaked and stay in this list forever. + // it will also keep the Pollable handle alive and prevent it from being disposed + private static readonly List s_pollables = new(); + private static bool s_checkScheduled; + private static Pollable? s_resolvedPollable; + private static Task? s_mainTask; - internal static Task RegisterWasiPollableHandle(int handle) + internal static Task RegisterWasiPollableHandle(int handle, bool ownsPollable, CancellationToken cancellationToken) { // note that this is duplicate of the original Pollable - // the original should be neutralized without disposing the handle - var pollableCpy = new IPoll.Pollable(new IPoll.Pollable.THandle(handle)); - return RegisterWasiPollable(pollableCpy); + // the original should have been neutralized without disposing the handle + var pollableCpy = new Pollable(new Pollable.THandle(handle)); + return RegisterWasiPollable(pollableCpy, ownsPollable, cancellationToken); } - internal static Task RegisterWasiPollable(IPoll.Pollable pollable) + internal static Task RegisterWasiPollable(Pollable pollable, bool ownsPollable, CancellationToken cancellationToken) { - var tcs = new TaskCompletionSource(pollable); - var weakRef = new WeakReference(tcs); - s_pollables.Add(weakRef); - return tcs.Task; + // this will register the pollable holder into s_pollables + var holder = new PollableHolder(pollable, ownsPollable, cancellationToken); + s_pollables.Add(holder); + + ScheduleCheck(); + + return holder.taskCompletionSource.Task; } - internal static void DispatchWasiEventLoop() + + internal static T PollWasiEventLoopUntilResolved(Task mainTask) { - ThreadPoolWorkQueue.Dispatch(); + try + { + s_mainTask = mainTask; + while (!mainTask.IsCompleted) + { + ThreadPoolWorkQueue.Dispatch(); + } + } + finally + { + s_mainTask = null; + } + var exception = mainTask.Exception; + if (exception is not null) + { + throw exception; + } + + return mainTask.Result; + } - if (s_pollables.Count > 0) + internal static void PollWasiEventLoopUntilResolvedVoid(Task mainTask) + { + try { - var pollables = s_pollables; - s_pollables = new List>(pollables.Count); - var arguments = new List(pollables.Count); - var indexes = new List(pollables.Count); - for (var i = 0; i < pollables.Count; i++) + s_mainTask = mainTask; + while (!mainTask.IsCompleted) { - var weakRef = pollables[i]; - if (weakRef.TryGetTarget(out TaskCompletionSource? tcs)) - { - var pollable = (IPoll.Pollable)tcs!.Task.AsyncState!; - arguments.Add(pollable); - indexes.Add(i); - } + ThreadPoolWorkQueue.Dispatch(); } + } + finally + { + s_mainTask = null; + } + + var exception = mainTask.Exception; + if (exception is not null) + { + throw exception; + } + } + + internal static void ScheduleCheck() + { + if (!s_checkScheduled && s_pollables.Count > 0) + { + s_checkScheduled = true; + ThreadPool.UnsafeQueueUserWorkItem(CheckPollables, null); + } + } - // this is blocking until at least one pollable resolves - var readyIndexes = PollInterop.Poll(arguments); + internal static void CheckPollables(object? _) + { + s_checkScheduled = false; - var ready = new bool[arguments.Count]; - foreach (int readyIndex in readyIndexes) + var holders = new List(s_pollables.Count); + var pending = new List(s_pollables.Count); + for (int i = 0; i < s_pollables.Count; i++) + { + var holder = s_pollables[i]; + if (!holder.isDisposed) { - ready[readyIndex] = true; - arguments[readyIndex].Dispose(); - var weakRef = pollables[indexes[readyIndex]]; - if (weakRef.TryGetTarget(out TaskCompletionSource? tcs)) + holders.Add(holder); + pending.Add(holder.pollable); + } + } + + s_pollables.Clear(); + + if (pending.Count > 0) + { + var resolvedPollableIndex = -1; + // if there is CPU-bound work to do, we should not block on PollInterop.Poll below + // so we will append pollable resolved in 0ms + // in effect, the PollInterop.Poll would not block us + if (ThreadPool.PendingWorkItemCount > 0 || (s_mainTask != null && s_mainTask.IsCompleted)) + { + s_resolvedPollable ??= MonotonicClockInterop.SubscribeDuration(0); + resolvedPollableIndex = pending.Count; + pending.Add(s_resolvedPollable); + } + + var readyIndexes = PollInterop.Poll(pending); + for (int i = 0; i < readyIndexes.Length; i++) + { + uint readyIndex = readyIndexes[i]; + if (resolvedPollableIndex != readyIndex) { - tcs!.SetResult(); + var holder = holders[(int)readyIndex]; + holder.ResolveAndDispose(); } } - for (var i = 0; i < arguments.Count; ++i) + + for (int i = 0; i < holders.Count; i++) { - if (!ready[i]) + PollableHolder holder = holders[i]; + if (!holder.isDisposed) { - s_pollables.Add(pollables[indexes[i]]); + s_pollables.Add(holder); } } + + ScheduleCheck(); + } + } + + private sealed class PollableHolder + { + public bool isDisposed; + public bool ownsPollable; + public readonly Pollable pollable; + public readonly TaskCompletionSource taskCompletionSource; + public readonly CancellationTokenRegistration cancellationTokenRegistration; + public readonly CancellationToken cancellationToken; + + public PollableHolder(Pollable pollable, bool ownsPollable, CancellationToken cancellationToken) + { + this.pollable = pollable; + this.ownsPollable = ownsPollable; + this.cancellationToken = cancellationToken; + + // this means that taskCompletionSource.Task.AsyncState -> this; + // which means PollableHolder will be alive until the Task alive + taskCompletionSource = new TaskCompletionSource(this); + + // static method is used to avoid allocating a delegate + cancellationTokenRegistration = cancellationToken.Register(CancelAndDispose, this); + } + + public void ResolveAndDispose() + { + if (isDisposed) + { + return; + } + + // no need to unregister the holder from s_pollables, when this is called + isDisposed = true; + if (ownsPollable){ + pollable.Dispose(); + } + cancellationTokenRegistration.Dispose(); + taskCompletionSource.TrySetResult(); + } + + // for GC of abandoned Tasks or for cancellation + public static void CancelAndDispose(object? s) + { + PollableHolder self = (PollableHolder)s!; + if (self.isDisposed) + { + return; + } + + // it will be removed from s_pollables on the next run + self.isDisposed = true; + if (self.ownsPollable){ + self.pollable.Dispose(); + } + self.cancellationTokenRegistration.Dispose(); + self.taskCompletionSource.TrySetCanceled(self.cancellationToken); } } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiPoll.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiPoll.cs index 754d062c3b1..888adcfe3a3 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiPoll.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiPoll.cs @@ -1,4 +1,4 @@ -// Generated by `wit-bindgen` 0.29.0. DO NOT EDIT! +// Generated by `wit-bindgen` 0.32.0. DO NOT EDIT! // #nullable enable using System; diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiPollWorld.wit.imports.wasi.clocks.v0_2_1.MonotonicClockInterop.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiPollWorld.wit.imports.wasi.clocks.v0_2_0.MonotonicClockInterop.cs similarity index 76% rename from src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiPollWorld.wit.imports.wasi.clocks.v0_2_1.MonotonicClockInterop.cs rename to src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiPollWorld.wit.imports.wasi.clocks.v0_2_0.MonotonicClockInterop.cs index 1a0ef026540..e08ae5bc6d6 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiPollWorld.wit.imports.wasi.clocks.v0_2_1.MonotonicClockInterop.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiPollWorld.wit.imports.wasi.clocks.v0_2_0.MonotonicClockInterop.cs @@ -1,4 +1,4 @@ -// Generated by `wit-bindgen` 0.29.0. DO NOT EDIT! +// Generated by `wit-bindgen` 0.32.0. DO NOT EDIT! // #nullable enable @@ -11,13 +11,13 @@ using System.Diagnostics; using System.Diagnostics.CodeAnalysis; -namespace WasiPollWorld.wit.imports.wasi.clocks.v0_2_1 +namespace WasiPollWorld.wit.imports.wasi.clocks.v0_2_0 { internal static class MonotonicClockInterop { internal static class NowWasmInterop { - [DllImport("wasi:clocks/monotonic-clock@0.2.1", EntryPoint = "now"), WasmImportLinkage] + [DllImport("wasi:clocks/monotonic-clock@0.2.0", EntryPoint = "now"), WasmImportLinkage] internal static extern long wasmImportNow(); } @@ -32,7 +32,7 @@ internal static unsafe ulong Now() internal static class ResolutionWasmInterop { - [DllImport("wasi:clocks/monotonic-clock@0.2.1", EntryPoint = "resolution"), WasmImportLinkage] + [DllImport("wasi:clocks/monotonic-clock@0.2.0", EntryPoint = "resolution"), WasmImportLinkage] internal static extern long wasmImportResolution(); } @@ -47,15 +47,15 @@ internal static unsafe ulong Resolution() internal static class SubscribeInstantWasmInterop { - [DllImport("wasi:clocks/monotonic-clock@0.2.1", EntryPoint = "subscribe-instant"), WasmImportLinkage] + [DllImport("wasi:clocks/monotonic-clock@0.2.0", EntryPoint = "subscribe-instant"), WasmImportLinkage] internal static extern int wasmImportSubscribeInstant(long p0); } - internal static unsafe global::WasiPollWorld.wit.imports.wasi.io.v0_2_1.IPoll.Pollable SubscribeInstant(ulong when) + internal static unsafe global::WasiPollWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable SubscribeInstant(ulong when) { var result = SubscribeInstantWasmInterop.wasmImportSubscribeInstant(unchecked((long)(when))); - var resource = new global::WasiPollWorld.wit.imports.wasi.io.v0_2_1.IPoll.Pollable(new global::WasiPollWorld.wit.imports.wasi.io.v0_2_1.IPoll.Pollable.THandle(result)); + var resource = new global::WasiPollWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable(new global::WasiPollWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable.THandle(result)); return resource; //TODO: free alloc handle (interopString) if exists @@ -63,15 +63,15 @@ internal static class SubscribeInstantWasmInterop internal static class SubscribeDurationWasmInterop { - [DllImport("wasi:clocks/monotonic-clock@0.2.1", EntryPoint = "subscribe-duration"), WasmImportLinkage] + [DllImport("wasi:clocks/monotonic-clock@0.2.0", EntryPoint = "subscribe-duration"), WasmImportLinkage] internal static extern int wasmImportSubscribeDuration(long p0); } - internal static unsafe global::WasiPollWorld.wit.imports.wasi.io.v0_2_1.IPoll.Pollable SubscribeDuration(ulong when) + internal static unsafe global::WasiPollWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable SubscribeDuration(ulong when) { var result = SubscribeDurationWasmInterop.wasmImportSubscribeDuration(unchecked((long)(when))); - var resource = new global::WasiPollWorld.wit.imports.wasi.io.v0_2_1.IPoll.Pollable(new global::WasiPollWorld.wit.imports.wasi.io.v0_2_1.IPoll.Pollable.THandle(result)); + var resource = new global::WasiPollWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable(new global::WasiPollWorld.wit.imports.wasi.io.v0_2_0.IPoll.Pollable.THandle(result)); return resource; //TODO: free alloc handle (interopString) if exists diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiPollWorld.wit.imports.wasi.io.v0_2_1.IPoll.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiPollWorld.wit.imports.wasi.io.v0_2_0.IPoll.cs similarity index 80% rename from src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiPollWorld.wit.imports.wasi.io.v0_2_1.IPoll.cs rename to src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiPollWorld.wit.imports.wasi.io.v0_2_0.IPoll.cs index 8ad5cabf64b..689c515e0b5 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiPollWorld.wit.imports.wasi.io.v0_2_1.IPoll.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiPollWorld.wit.imports.wasi.io.v0_2_0.IPoll.cs @@ -1,4 +1,4 @@ -// Generated by `wit-bindgen` 0.29.0. DO NOT EDIT! +// Generated by `wit-bindgen` 0.32.0. DO NOT EDIT! // #nullable enable @@ -11,7 +11,7 @@ using System.Diagnostics; using System.Diagnostics.CodeAnalysis; -namespace WasiPollWorld.wit.imports.wasi.io.v0_2_1; +namespace WasiPollWorld.wit.imports.wasi.io.v0_2_0; internal interface IPoll { @@ -30,26 +30,21 @@ internal Pollable(THandle handle) { public void Dispose() { Dispose(true); - GC.SuppressFinalize(this); } - [DllImport("wasi:io/poll@0.2.1", EntryPoint = "[resource-drop]pollable"), WasmImportLinkage] + [DllImport("wasi:io/poll@0.2.0", EntryPoint = "[resource-drop]pollable"), WasmImportLinkage] private static extern void wasmImportResourceDrop(int p0); protected virtual void Dispose(bool disposing) { - if (Handle != 0) { + if (disposing && Handle != 0) { wasmImportResourceDrop(Handle); Handle = 0; } } - ~Pollable() { - Dispose(false); - } - internal static class ReadyWasmInterop { - [DllImport("wasi:io/poll@0.2.1", EntryPoint = "[method]pollable.ready"), WasmImportLinkage] + [DllImport("wasi:io/poll@0.2.0", EntryPoint = "[method]pollable.ready"), WasmImportLinkage] internal static extern int wasmImportReady(int p0); } @@ -65,7 +60,7 @@ internal unsafe bool Ready() internal static class BlockWasmInterop { - [DllImport("wasi:io/poll@0.2.1", EntryPoint = "[method]pollable.block"), WasmImportLinkage] + [DllImport("wasi:io/poll@0.2.0", EntryPoint = "[method]pollable.block"), WasmImportLinkage] internal static extern void wasmImportBlock(int p0); } diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiPollWorld.wit.imports.wasi.io.v0_2_1.PollInterop.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiPollWorld.wit.imports.wasi.io.v0_2_0.PollInterop.cs similarity index 86% rename from src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiPollWorld.wit.imports.wasi.io.v0_2_1.PollInterop.cs rename to src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiPollWorld.wit.imports.wasi.io.v0_2_0.PollInterop.cs index dc01e875749..796018f6fbc 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiPollWorld.wit.imports.wasi.io.v0_2_1.PollInterop.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/WasiPollWorld.wit.imports.wasi.io.v0_2_0.PollInterop.cs @@ -1,4 +1,4 @@ -// Generated by `wit-bindgen` 0.29.0. DO NOT EDIT! +// Generated by `wit-bindgen` 0.32.0. DO NOT EDIT! // #nullable enable @@ -11,18 +11,18 @@ using System.Diagnostics; using System.Diagnostics.CodeAnalysis; -namespace WasiPollWorld.wit.imports.wasi.io.v0_2_1 +namespace WasiPollWorld.wit.imports.wasi.io.v0_2_0 { internal static class PollInterop { internal static class PollWasmInterop { - [DllImport("wasi:io/poll@0.2.1", EntryPoint = "poll"), WasmImportLinkage] + [DllImport("wasi:io/poll@0.2.0", EntryPoint = "poll"), WasmImportLinkage] internal static extern void wasmImportPoll(nint p0, int p1, nint p2); } - internal static unsafe uint[] Poll(List @in) + internal static unsafe uint[] Poll(List @in) { byte[] buffer = new byte[4 * @in.Count]; @@ -30,7 +30,7 @@ internal static unsafe uint[] Poll(List((void*)(basePtr + 0), 4), unchecked((int)handle)); diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/generate-wasi-poll-bindings.ps1 b/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/generate-wasi-poll-bindings.ps1 new file mode 100644 index 00000000000..0ae1b0edb04 --- /dev/null +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/generate-wasi-poll-bindings.ps1 @@ -0,0 +1,21 @@ +# Prerequisites: +# powershell +# tar +# [cargo](https://rustup.rs/) +$ProgressPreference = 'SilentlyContinue' +$ErrorActionPreference='Stop' +$scriptpath = $MyInvocation.MyCommand.Path +$dir = Split-Path $scriptpath + +Push-Location $dir + + +cargo install --locked --no-default-features --features csharp --version 0.32.0 wit-bindgen-cli +Invoke-WebRequest -Uri https://github.com/WebAssembly/wasi-http/archive/refs/tags/v0.2.0.tar.gz -OutFile v0.2.0.tar.gz +tar xzf v0.2.0.tar.gz +cp world.wit wasi-http-0.2.0/wit/world.wit +wit-bindgen c-sharp -w wasi-poll -r native-aot --internal --skip-support-files wasi-http-0.2.0/wit +rm -r wasi-http-0.2.0 +rm v0.2.0.tar.gz + +Pop-Location diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/generate-wasi-poll-bindings.sh b/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/generate-wasi-poll-bindings.sh index fd20df8e9df..70da6f36911 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/generate-wasi-poll-bindings.sh +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Wasi/generate-wasi-poll-bindings.sh @@ -11,14 +11,9 @@ set -ex # [cargo](https://rustup.rs/) # [curl](https://curl.se/download.html) -cargo install --locked --no-default-features --features csharp --version 0.29.0 wit-bindgen-cli -curl -OL https://github.com/WebAssembly/wasi-http/archive/refs/tags/v0.2.1.tar.gz -tar xzf v0.2.1.tar.gz -cat >wasi-http-0.2.1/wit/world.wit <The value to convert. /// converted to a . [CLSCompliant(false)] - public static explicit operator Int128(UInt128 value) => Unsafe.BitCast(value); + public static explicit operator Int128(UInt128 value) => new Int128(value._upper, value._lower); /// Explicitly converts a 128-bit unsigned integer to a value, throwing an overflow exception for any values that fall outside the representable range. /// The value to convert. @@ -357,7 +357,7 @@ public static explicit operator checked Int128(UInt128 value) { ThrowHelper.ThrowOverflowException(); } - return Unsafe.BitCast(value); + return new Int128(value._upper, value._lower); } /// Explicitly converts a 128-bit unsigned integer to a value. diff --git a/src/libraries/System.Private.DataContractSerialization/System.Private.DataContractSerialization.sln b/src/libraries/System.Private.DataContractSerialization/System.Private.DataContractSerialization.sln index 939a32fa5b6..2979e84755d 100644 --- a/src/libraries/System.Private.DataContractSerialization/System.Private.DataContractSerialization.sln +++ b/src/libraries/System.Private.DataContractSerialization/System.Private.DataContractSerialization.sln @@ -1,7 +1,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.DataContractSerialization", "src\System.Private.DataContractSerialization.csproj", "{493BBB98-5E20-46BE-A7DC-1584F39DE27D}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{54116CEF-C987-4CE5-940B-613A016AD6CA}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{6141204E-E468-47C3-9581-5263DFB9D4CF}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{801938D9-5DB8-4F15-B1C1-FB67723C75F9}" EndProject @@ -39,10 +39,10 @@ Global {493BBB98-5E20-46BE-A7DC-1584F39DE27D}.Debug|Any CPU.Build.0 = Debug|Any CPU {493BBB98-5E20-46BE-A7DC-1584F39DE27D}.Release|Any CPU.ActiveCfg = Release|Any CPU {493BBB98-5E20-46BE-A7DC-1584F39DE27D}.Release|Any CPU.Build.0 = Release|Any CPU - {54116CEF-C987-4CE5-940B-613A016AD6CA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {54116CEF-C987-4CE5-940B-613A016AD6CA}.Debug|Any CPU.Build.0 = Debug|Any CPU - {54116CEF-C987-4CE5-940B-613A016AD6CA}.Release|Any CPU.ActiveCfg = Release|Any CPU - {54116CEF-C987-4CE5-940B-613A016AD6CA}.Release|Any CPU.Build.0 = Release|Any CPU + {6141204E-E468-47C3-9581-5263DFB9D4CF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {6141204E-E468-47C3-9581-5263DFB9D4CF}.Debug|Any CPU.Build.0 = Debug|Any CPU + {6141204E-E468-47C3-9581-5263DFB9D4CF}.Release|Any CPU.ActiveCfg = Release|Any CPU + {6141204E-E468-47C3-9581-5263DFB9D4CF}.Release|Any CPU.Build.0 = Release|Any CPU {801938D9-5DB8-4F15-B1C1-FB67723C75F9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {801938D9-5DB8-4F15-B1C1-FB67723C75F9}.Debug|Any CPU.Build.0 = Debug|Any CPU {801938D9-5DB8-4F15-B1C1-FB67723C75F9}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -77,7 +77,7 @@ Global EndGlobalSection GlobalSection(NestedProjects) = preSolution {493BBB98-5E20-46BE-A7DC-1584F39DE27D} = {14B38A7F-3A3B-4C41-AE5C-D8AA236626DD} - {54116CEF-C987-4CE5-940B-613A016AD6CA} = {6EF339F7-5861-440F-88F7-333F04F0ABD7} + {6141204E-E468-47C3-9581-5263DFB9D4CF} = {6EF339F7-5861-440F-88F7-333F04F0ABD7} {801938D9-5DB8-4F15-B1C1-FB67723C75F9} = {6EF339F7-5861-440F-88F7-333F04F0ABD7} {FB5A7543-CB37-40A0-807F-76879E1000F5} = {6EF339F7-5861-440F-88F7-333F04F0ABD7} {0F50BEBA-FC93-455A-9234-3E23503154BA} = {C7637E36-CE91-4215-A0F4-78FD03DB7500} diff --git a/src/libraries/System.Private.Uri/System.Private.Uri.sln b/src/libraries/System.Private.Uri/System.Private.Uri.sln index 57f3c06adfe..6adac8c51fb 100644 --- a/src/libraries/System.Private.Uri/System.Private.Uri.sln +++ b/src/libraries/System.Private.Uri/System.Private.Uri.sln @@ -15,6 +15,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.Uri.Function EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.Uri.Unit.Tests", "tests\UnitTests\System.Private.Uri.Unit.Tests.csproj", "{650441DF-021A-45C3-9560-F9FDB3037A64}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{8E277569-BFCB-4679-B4A5-93DE0C1A39D6}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{DC61379F-5CAE-4744-A71C-3E7AAF921877}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{B532288A-97AF-473C-B334-E5F6F572907C}" @@ -241,6 +243,27 @@ Global {650441DF-021A-45C3-9560-F9FDB3037A64}.Checked|arm64.ActiveCfg = Debug|Any CPU {650441DF-021A-45C3-9560-F9FDB3037A64}.Checked|x64.ActiveCfg = Debug|Any CPU {650441DF-021A-45C3-9560-F9FDB3037A64}.Checked|x86.ActiveCfg = Debug|Any CPU + {8E277569-BFCB-4679-B4A5-93DE0C1A39D6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {8E277569-BFCB-4679-B4A5-93DE0C1A39D6}.Debug|Any CPU.Build.0 = Debug|Any CPU + {8E277569-BFCB-4679-B4A5-93DE0C1A39D6}.Debug|arm.ActiveCfg = Debug|Any CPU + {8E277569-BFCB-4679-B4A5-93DE0C1A39D6}.Debug|arm64.ActiveCfg = Debug|Any CPU + {8E277569-BFCB-4679-B4A5-93DE0C1A39D6}.Debug|x64.ActiveCfg = Debug|Any CPU + {8E277569-BFCB-4679-B4A5-93DE0C1A39D6}.Debug|x64.Build.0 = Debug|Any CPU + {8E277569-BFCB-4679-B4A5-93DE0C1A39D6}.Debug|x86.ActiveCfg = Debug|Any CPU + {8E277569-BFCB-4679-B4A5-93DE0C1A39D6}.Debug|x86.Build.0 = Debug|Any CPU + {8E277569-BFCB-4679-B4A5-93DE0C1A39D6}.Release|Any CPU.ActiveCfg = Release|Any CPU + {8E277569-BFCB-4679-B4A5-93DE0C1A39D6}.Release|Any CPU.Build.0 = Release|Any CPU + {8E277569-BFCB-4679-B4A5-93DE0C1A39D6}.Release|arm.ActiveCfg = Release|Any CPU + {8E277569-BFCB-4679-B4A5-93DE0C1A39D6}.Release|arm64.ActiveCfg = Release|Any CPU + {8E277569-BFCB-4679-B4A5-93DE0C1A39D6}.Release|x64.ActiveCfg = Release|Any CPU + {8E277569-BFCB-4679-B4A5-93DE0C1A39D6}.Release|x64.Build.0 = Release|Any CPU + {8E277569-BFCB-4679-B4A5-93DE0C1A39D6}.Release|x86.ActiveCfg = Release|Any CPU + {8E277569-BFCB-4679-B4A5-93DE0C1A39D6}.Release|x86.Build.0 = Release|Any CPU + {8E277569-BFCB-4679-B4A5-93DE0C1A39D6}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {8E277569-BFCB-4679-B4A5-93DE0C1A39D6}.Checked|arm.ActiveCfg = Debug|Any CPU + {8E277569-BFCB-4679-B4A5-93DE0C1A39D6}.Checked|arm64.ActiveCfg = Debug|Any CPU + {8E277569-BFCB-4679-B4A5-93DE0C1A39D6}.Checked|x64.ActiveCfg = Debug|Any CPU + {8E277569-BFCB-4679-B4A5-93DE0C1A39D6}.Checked|x86.ActiveCfg = Debug|Any CPU {DC61379F-5CAE-4744-A71C-3E7AAF921877}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {DC61379F-5CAE-4744-A71C-3E7AAF921877}.Debug|Any CPU.Build.0 = Debug|Any CPU {DC61379F-5CAE-4744-A71C-3E7AAF921877}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -400,6 +423,7 @@ Global {BDD0866A-D856-40EE-A9D5-1DAC11095E42} = {DBF81CE3-B7A6-4A62-9C66-DDB2D87CBB05} {650441DF-021A-45C3-9560-F9FDB3037A64} = {DBF81CE3-B7A6-4A62-9C66-DDB2D87CBB05} {D9F21DA7-0FE6-419E-9CE3-DFFBC3F0067F} = {E3179181-D7ED-459C-B0ED-40DF10FC1959} + {8E277569-BFCB-4679-B4A5-93DE0C1A39D6} = {E3179181-D7ED-459C-B0ED-40DF10FC1959} {DC61379F-5CAE-4744-A71C-3E7AAF921877} = {E3179181-D7ED-459C-B0ED-40DF10FC1959} {B532288A-97AF-473C-B334-E5F6F572907C} = {E3179181-D7ED-459C-B0ED-40DF10FC1959} {8153A96E-335B-4872-9EC0-39178850617B} = {89A8524B-6E70-43E0-AD13-E53D499BB0A1} diff --git a/src/libraries/System.Private.Uri/src/System/UriExt.cs b/src/libraries/System.Private.Uri/src/System/UriExt.cs index 6f2f61c7672..ee35d01e962 100644 --- a/src/libraries/System.Private.Uri/src/System/UriExt.cs +++ b/src/libraries/System.Private.Uri/src/System/UriExt.cs @@ -1,6 +1,7 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System.Buffers; using System.Diagnostics; using System.Diagnostics.CodeAnalysis; using System.Globalization; @@ -216,32 +217,49 @@ private void InitializeUri(ParsingError err, UriKind uriKind, out UriFormatExcep } } - // Unescapes entire string and checks if it has unicode chars - // Also checks for sequences that are 3986 Unreserved characters as these should be un-escaped + /// SearchValues for all ASCII characters other than % + private static readonly SearchValues s_asciiOtherThanPercent = SearchValues.Create( + "\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\u0008\u0009\u000A\u000B\u000C\u000D\u000E\u000F" + + "\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001A\u001B\u001C\u001D\u001E\u001F" + + "\u0020\u0021\u0022\u0023\u0024" + "\u0026\u0027\u0028\u0029\u002A\u002B\u002C\u002D\u002E\u002F" + + "\u0030\u0031\u0032\u0033\u0034\u0035\u0036\u0037\u0038\u0039\u003A\u003B\u003C\u003D\u003E\u003F" + + "\u0040\u0041\u0042\u0043\u0044\u0045\u0046\u0047\u0048\u0049\u004A\u004B\u004C\u004D\u004E\u004F" + + "\u0050\u0051\u0052\u0053\u0054\u0055\u0056\u0057\u0058\u0059\u005A\u005B\u005C\u005D\u005E\u005F" + + "\u0060\u0061\u0062\u0063\u0064\u0065\u0066\u0067\u0068\u0069\u006A\u006B\u006C\u006D\u006E\u006F" + + "\u0070\u0071\u0072\u0073\u0074\u0075\u0076\u0077\u0078\u0079\u007A\u007B\u007C\u007D\u007E\u007F"); + + /// + /// Unescapes entire string and checks if it has unicode chars.Also checks for sequences that are 3986 Unreserved characters as these should be un-escaped + /// private static bool CheckForUnicodeOrEscapedUnreserved(string data) { - for (int i = 0; i < data.Length; i++) + int i = data.AsSpan().IndexOfAnyExcept(s_asciiOtherThanPercent); + if (i >= 0) { - char c = data[i]; - if (c == '%') + for ( ; i < data.Length; i++) { - if ((uint)(i + 2) < (uint)data.Length) + char c = data[i]; + if (c == '%') { - char value = UriHelper.DecodeHexChars(data[i + 1], data[i + 2]); - - if (!char.IsAscii(value) || UriHelper.Unreserved.Contains(value)) + if ((uint)(i + 2) < (uint)data.Length) { - return true; - } + char value = UriHelper.DecodeHexChars(data[i + 1], data[i + 2]); + + if (!char.IsAscii(value) || UriHelper.Unreserved.Contains(value)) + { + return true; + } - i += 2; + i += 2; + } + } + else if (c > 0x7F) + { + return true; } - } - else if (c > 0x7F) - { - return true; } } + return false; } diff --git a/src/libraries/System.Private.Xml.Linq/System.Private.Xml.Linq.sln b/src/libraries/System.Private.Xml.Linq/System.Private.Xml.Linq.sln index 882a30b7c49..f2155549a4a 100644 --- a/src/libraries/System.Private.Xml.Linq/System.Private.Xml.Linq.sln +++ b/src/libraries/System.Private.Xml.Linq/System.Private.Xml.Linq.sln @@ -37,6 +37,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.Xml", "..\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{C87694DB-E6BE-4CE0-B2AA-D3ADB848D5A9}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{72626977-3BF7-4027-9FA4-702BB5C418C1}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{7F136EB7-C602-403B-84CD-753B32D699A8}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{D85F6247-9473-4AA3-80C8-06D65B035C98}" @@ -149,6 +151,10 @@ Global {C87694DB-E6BE-4CE0-B2AA-D3ADB848D5A9}.Debug|Any CPU.Build.0 = Debug|Any CPU {C87694DB-E6BE-4CE0-B2AA-D3ADB848D5A9}.Release|Any CPU.ActiveCfg = Release|Any CPU {C87694DB-E6BE-4CE0-B2AA-D3ADB848D5A9}.Release|Any CPU.Build.0 = Release|Any CPU + {72626977-3BF7-4027-9FA4-702BB5C418C1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {72626977-3BF7-4027-9FA4-702BB5C418C1}.Debug|Any CPU.Build.0 = Debug|Any CPU + {72626977-3BF7-4027-9FA4-702BB5C418C1}.Release|Any CPU.ActiveCfg = Release|Any CPU + {72626977-3BF7-4027-9FA4-702BB5C418C1}.Release|Any CPU.Build.0 = Release|Any CPU {7F136EB7-C602-403B-84CD-753B32D699A8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {7F136EB7-C602-403B-84CD-753B32D699A8}.Debug|Any CPU.Build.0 = Debug|Any CPU {7F136EB7-C602-403B-84CD-753B32D699A8}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -205,6 +211,7 @@ Global {61FD926A-2ED8-4CA5-8D75-854C8C9D9CCD} = {1C4146F1-CF77-449B-865C-5E67ECF0362B} {A4F479E3-A0AD-4646-BD4B-F3CD2C29046B} = {1C4146F1-CF77-449B-865C-5E67ECF0362B} {C87694DB-E6BE-4CE0-B2AA-D3ADB848D5A9} = {E9DEC5AA-D875-466B-9E3C-26CFD3C806D3} + {72626977-3BF7-4027-9FA4-702BB5C418C1} = {E9DEC5AA-D875-466B-9E3C-26CFD3C806D3} {7F136EB7-C602-403B-84CD-753B32D699A8} = {E9DEC5AA-D875-466B-9E3C-26CFD3C806D3} {D85F6247-9473-4AA3-80C8-06D65B035C98} = {E9DEC5AA-D875-466B-9E3C-26CFD3C806D3} {DB61E495-5D63-401A-88C6-6A1BB6A737ED} = {E9DEC5AA-D875-466B-9E3C-26CFD3C806D3} diff --git a/src/libraries/System.Private.Xml/System.Private.Xml.sln b/src/libraries/System.Private.Xml/System.Private.Xml.sln index d18f2ebac94..3306a9269f8 100644 --- a/src/libraries/System.Private.Xml/System.Private.Xml.sln +++ b/src/libraries/System.Private.Xml/System.Private.Xml.sln @@ -21,6 +21,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Xml.XmlSerializer.Re EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{B758029E-F74C-42DC-A500-41B8E9416427}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{A21A9FFB-2901-4343-9DDE-93352D9576D7}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{6BC66CAC-5D61-48C2-8343-FF32DC7BC626}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{9CDA14FB-7312-45E7-BF4C-1E446C2242BC}" @@ -101,6 +103,10 @@ Global {B758029E-F74C-42DC-A500-41B8E9416427}.Debug|Any CPU.Build.0 = Debug|Any CPU {B758029E-F74C-42DC-A500-41B8E9416427}.Release|Any CPU.ActiveCfg = Release|Any CPU {B758029E-F74C-42DC-A500-41B8E9416427}.Release|Any CPU.Build.0 = Release|Any CPU + {A21A9FFB-2901-4343-9DDE-93352D9576D7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A21A9FFB-2901-4343-9DDE-93352D9576D7}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A21A9FFB-2901-4343-9DDE-93352D9576D7}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A21A9FFB-2901-4343-9DDE-93352D9576D7}.Release|Any CPU.Build.0 = Release|Any CPU {6BC66CAC-5D61-48C2-8343-FF32DC7BC626}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {6BC66CAC-5D61-48C2-8343-FF32DC7BC626}.Debug|Any CPU.Build.0 = Debug|Any CPU {6BC66CAC-5D61-48C2-8343-FF32DC7BC626}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -149,6 +155,7 @@ Global {AD461557-2DDB-4A3C-8433-FFB5E31A5E6F} = {E96EBB95-6AC7-4ECD-AD77-30F089F2C1F9} {B49AD269-3938-4F33-AEF8-029D3A94138F} = {41E18B29-2DB1-495A-8460-E7A257F8EA07} {B758029E-F74C-42DC-A500-41B8E9416427} = {75FE1E48-B986-46E6-874F-336D74FF6C94} + {A21A9FFB-2901-4343-9DDE-93352D9576D7} = {75FE1E48-B986-46E6-874F-336D74FF6C94} {6BC66CAC-5D61-48C2-8343-FF32DC7BC626} = {75FE1E48-B986-46E6-874F-336D74FF6C94} {9CDA14FB-7312-45E7-BF4C-1E446C2242BC} = {75FE1E48-B986-46E6-874F-336D74FF6C94} {19C87966-6C1B-4CFA-9798-E989270CAB2B} = {75FE1E48-B986-46E6-874F-336D74FF6C94} diff --git a/src/libraries/System.Private.Xml/src/ILLink/ILLink.Substitutions.xml b/src/libraries/System.Private.Xml/src/ILLink/ILLink.Substitutions.xml deleted file mode 100644 index 52cf62fc636..00000000000 --- a/src/libraries/System.Private.Xml/src/ILLink/ILLink.Substitutions.xml +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - - diff --git a/src/libraries/System.Private.Xml/src/System.Private.Xml.csproj b/src/libraries/System.Private.Xml/src/System.Private.Xml.csproj index a78f7c666e0..67233800dde 100644 --- a/src/libraries/System.Private.Xml/src/System.Private.Xml.csproj +++ b/src/libraries/System.Private.Xml/src/System.Private.Xml.csproj @@ -7,10 +7,6 @@ false - - - - diff --git a/src/libraries/System.Private.Xml/src/System/Xml/Core/LocalAppContextSwitches.cs b/src/libraries/System.Private.Xml/src/System/Xml/Core/LocalAppContextSwitches.cs index a95f9105051..88d9fbd3419 100644 --- a/src/libraries/System.Private.Xml/src/System/Xml/Core/LocalAppContextSwitches.cs +++ b/src/libraries/System.Private.Xml/src/System/Xml/Core/LocalAppContextSwitches.cs @@ -1,6 +1,7 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System.Diagnostics.CodeAnalysis; using System.Runtime.CompilerServices; using SwitchesHelpers = System.LocalAppContextSwitches; @@ -59,6 +60,7 @@ public static bool AllowDefaultResolver } private static int s_isNetworkingEnabledByDefault; + [FeatureSwitchDefinition("System.Xml.XmlResolver.IsNetworkingEnabledByDefault")] public static bool IsNetworkingEnabledByDefault { [MethodImpl(MethodImplOptions.AggressiveInlining)] diff --git a/src/libraries/System.Private.Xml/tests/XmlSerializer/XmlSerializerTests.Internal.cs b/src/libraries/System.Private.Xml/tests/XmlSerializer/XmlSerializerTests.Internal.cs index 1b8ca00625b..9ff61f7fdf5 100644 --- a/src/libraries/System.Private.Xml/tests/XmlSerializer/XmlSerializerTests.Internal.cs +++ b/src/libraries/System.Private.Xml/tests/XmlSerializer/XmlSerializerTests.Internal.cs @@ -3,38 +3,110 @@ using System; using System.Collections.Generic; +using System.Xml; +using System.Xml.Schema; using System.Xml.Serialization; +using SerializationTypes; using Xunit; public static partial class XmlSerializerTests { + // Move this test to XmlSerializerTests.cs once #1398 is fixed for the ReflectionOnly serializer. [Fact] - // XmlTypeMapping is not included in System.Xml.XmlSerializer 4.0.0.0 facade in GAC - public static void Xml_FromMappings() + public static void Xml_CustomDocumentWithXmlAttributesAsNodes() { - var types = new[] { typeof(Guid), typeof(List) }; - XmlReflectionImporter importer = new XmlReflectionImporter(); - XmlTypeMapping[] mappings = new XmlTypeMapping[types.Length]; - for (int i = 0; i < types.Length; i++) + var customDoc = new CustomDocument(); + var customElement = new CustomElement() { Name = "testElement" }; + customElement.AddAttribute(customDoc.CreateAttribute("regularAttribute", "regularValue")); + customElement.AddAttribute(customDoc.CreateCustomAttribute("customAttribute", "customValue")); + customDoc.CustomItems.Add(customElement); + var element = customDoc.Document.CreateElement("regularElement"); + var innerElement = customDoc.Document.CreateElement("innerElement"); + innerElement.InnerXml = "innerText"; + element.InnerText = "regularText"; + element.AppendChild(innerElement); + element.Attributes.Append(customDoc.CreateAttribute("regularElementAttribute", "regularElementAttributeValue")); + customDoc.AddItem(element); + var actual = SerializeAndDeserialize(customDoc, + WithXmlHeader(@""), skipStringCompare: true); + Assert.NotNull(actual); + } + + // Move this test to XmlSerializerTests.cs once #1401 is fixed for the ReflectionOnly serializer. + [Fact] + public static void Xml_DerivedIXmlSerializable() + { + var dClass = new XmlSerializableDerivedClass() { AttributeString = "derivedIXmlSerTest", DateTimeValue = DateTime.Parse("Dec 31, 1999"), BoolValue = true }; + + var expectedXml = WithXmlHeader(@$""); + var fromBase = SerializeAndDeserialize(dClass, expectedXml, () => new XmlSerializer(typeof(XmlSerializableBaseClass), new Type[] { typeof(XmlSerializableDerivedClass) })); + Assert.Equal(dClass.AttributeString, fromBase.AttributeString); + Assert.StrictEqual(dClass.DateTimeValue, fromBase.DateTimeValue); + Assert.Equal(dClass.BoolValue, fromBase.BoolValue); + + // Derived class does not apply XmlRoot attribute to force itself to be emitted with the base class element name, so update expected xml accordingly. + // Since we can't smartly emit xsi:type during serialization though, it is still there even though it isn't needed. + expectedXml = WithXmlHeader(@""); + var fromDerived = SerializeAndDeserialize(dClass, expectedXml, () => new XmlSerializer(typeof(XmlSerializableDerivedClass))); + Assert.Equal(dClass.AttributeString, fromDerived.AttributeString); + Assert.StrictEqual(dClass.DateTimeValue, fromDerived.DateTimeValue); + Assert.Equal(dClass.BoolValue, fromDerived.BoolValue); + } + + // Move this test to XmlSerializerTests.cs once #1402 is fixed for the ReflectionOnly serializer. + // Actually, this test is already there, but it's commented out. Uncomment it once #1402 is fixed. + // BTW, there are multiple (4?) places in the refelction reader where this issue is referenced, although + // one of those places is a potential optimization that is not required to get on par with ILGen afaik. + [Fact] + public static void XML_TypeWithFieldsOrdered() + { + var value = new TypeWithFieldsOrdered() { - mappings[i] = importer.ImportTypeMapping(types[i]); - } - var serializers = XmlSerializer.FromMappings(mappings, typeof(object)); - Xml_GuidAsRoot_Helper(serializers[0]); - Xml_ListGenericRoot_Helper(serializers[1]); + IntField1 = 1, + IntField2 = 2, + StringField1 = "foo1", + StringField2 = "foo2" + }; + + var actual = SerializeAndDeserialize(value, WithXmlHeader("\r\n 2\r\n 1\r\n foo2\r\n foo1\r\n")); + + Assert.NotNull(actual); + Assert.Equal(value.IntField1, actual.IntField1); + Assert.Equal(value.IntField2, actual.IntField2); + Assert.Equal(value.StringField1, actual.StringField1); + Assert.Equal(value.StringField2, actual.StringField2); } + // TODO - Move this test to XmlSerializerTests.RuntimeOnly.cs once #1399 is fixed for the ReflectionOnly serializer. [Fact] - // XmlTypeMapping is not included in System.Xml.XmlSerializer 4.0.0.0 facade in GAC - public static void Xml_ConstructorWithTypeMapping() + public static void Xml_XmlSchema() { - XmlTypeMapping mapping = null; - XmlSerializer serializer = null; - Assert.Throws(() => { new XmlSerializer(mapping); }); + var expectedXml = WithXmlHeader("\r\n \r\n \r\n \r\n \r\n \r\n \r\n \r\n"); + + XmlSchema schema = new XmlSchema + { + TargetNamespace = "http://example.com/my-schema", + ElementFormDefault = XmlSchemaForm.Qualified + }; + schema.Items.Add(new XmlSchemaElement + { + Name = "MyElement", + SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema") + }); + schema.Items.Add(new XmlSchemaGroup + { + Name = "MyGroup", + Particle = new XmlSchemaSequence + { + Items = { new XmlSchemaElement { Name = "Item1" }, new XmlSchemaElement { Name = "Item2" } } + } + }); + schema.Namespaces.Add("xsd", "http://www.w3.org/2001/XMLSchema"); + schema.Namespaces.Add("xsi", "http://www.w3.org/2001/XMLSchema-instance"); + + var actual = SerializeAndDeserialize(schema, expectedXml, () => new XmlSerializer(typeof(XmlSchema))); - mapping = new XmlReflectionImporter(null, null).ImportTypeMapping(typeof(List)); - serializer = new XmlSerializer(mapping); - Xml_ListGenericRoot_Helper(serializer); + Assert.Equivalent(schema, actual); } } diff --git a/src/libraries/System.Private.Xml/tests/XmlSerializer/XmlSerializerTests.RuntimeOnly.cs b/src/libraries/System.Private.Xml/tests/XmlSerializer/XmlSerializerTests.RuntimeOnly.cs index 9fa615c142d..aab8848cd63 100644 --- a/src/libraries/System.Private.Xml/tests/XmlSerializer/XmlSerializerTests.RuntimeOnly.cs +++ b/src/libraries/System.Private.Xml/tests/XmlSerializer/XmlSerializerTests.RuntimeOnly.cs @@ -2143,6 +2143,35 @@ public static void XmlSerializationGeneratedCodeTest() Assert.NotNull(cg); } + [Fact] + // XmlTypeMapping is not included in System.Xml.XmlSerializer 4.0.0.0 facade in GAC + public static void Xml_FromMappings() + { + var types = new[] { typeof(Guid), typeof(List) }; + XmlReflectionImporter importer = new XmlReflectionImporter(); + XmlTypeMapping[] mappings = new XmlTypeMapping[types.Length]; + for (int i = 0; i < types.Length; i++) + { + mappings[i] = importer.ImportTypeMapping(types[i]); + } + var serializers = XmlSerializer.FromMappings(mappings, typeof(object)); + Xml_GuidAsRoot_Helper(serializers[0]); + Xml_ListGenericRoot_Helper(serializers[1]); + } + + [Fact] + // XmlTypeMapping is not included in System.Xml.XmlSerializer 4.0.0.0 facade in GAC + public static void Xml_ConstructorWithTypeMapping() + { + XmlTypeMapping mapping = null; + XmlSerializer serializer = null; + Assert.Throws(() => { new XmlSerializer(mapping); }); + + mapping = new XmlReflectionImporter(null, null).ImportTypeMapping(typeof(List)); + serializer = new XmlSerializer(mapping); + Xml_ListGenericRoot_Helper(serializer); + } + [Fact] public static void XmlMembersMapping_PrimitiveValue() { diff --git a/src/libraries/System.Private.Xml/tests/XmlSerializer/XmlSerializerTests.cs b/src/libraries/System.Private.Xml/tests/XmlSerializer/XmlSerializerTests.cs index 649f5310838..875ebcc1939 100644 --- a/src/libraries/System.Private.Xml/tests/XmlSerializer/XmlSerializerTests.cs +++ b/src/libraries/System.Private.Xml/tests/XmlSerializer/XmlSerializerTests.cs @@ -43,6 +43,8 @@ static XmlSerializerTests() } #endif + public static bool DefaultValueAttributeIsSupported => AppContext.TryGetSwitch("System.ComponentModel.DefaultValueAttribute.IsSupported", out bool isEnabled) ? isEnabled : true; + [Fact] public static void Xml_TypeWithDateTimePropertyAsXmlTime() { @@ -56,8 +58,7 @@ public static void Xml_TypeWithDateTimePropertyAsXmlTime() var localTimeDateTime = DateTime.MinValue + localTime.TimeOfDay; string localTimeString = localTimeDateTime.ToString("HH:mm:ss.fffffffzzzzzz", DateTimeFormatInfo.InvariantInfo); TypeWithDateTimePropertyAsXmlTime localTimeObjectRoundTrip = SerializeAndDeserialize(localTimeObject, -string.Format(@" -{0}", localTimeString)); + string.Format(WithXmlHeader(@"{0}"), localTimeString)); Assert.StrictEqual(localTimeObject.Value, localTimeObjectRoundTrip.Value); @@ -67,8 +68,7 @@ public static void Xml_TypeWithDateTimePropertyAsXmlTime() }; TypeWithDateTimePropertyAsXmlTime utcTimeRoundTrip = SerializeAndDeserialize(utcTimeObject, -@" -15:15:26.9870000Z"); + WithXmlHeader(@"15:15:26.9870000Z")); Assert.StrictEqual(utcTimeObject.Value, utcTimeRoundTrip.Value); } @@ -273,8 +273,8 @@ public static void Xml_ImmutableCollections(Type type, object collection, Type c } public static IEnumerable Xml_ImmutableCollections_MemberData() { - string arrayOfInt = "42"; - string arrayOfAny = ""; + string arrayOfInt = WithXmlHeader("42"); + string arrayOfAny = WithXmlHeader(""); #if ReflectionOnly yield return new object[] { typeof(ImmutableArray), ImmutableArray.Create(42), null, typeof(InvalidOperationException), arrayOfInt, "Specified method is not supported." }; @@ -346,8 +346,7 @@ public static void Xml_EnumAsObject() { object o = MyEnum.Three; object o2 = SerializeAndDeserialize(o, -@" -2"); + WithXmlHeader(@"2")); Assert.NotNull(o2); Assert.StrictEqual((int)o, o2); Assert.Equal(MyEnum.Three, (MyEnum)o2); @@ -485,7 +484,6 @@ public static void Xml_SerializeClassThatImplementsInterface() Assert.StrictEqual(value.IsLoaded, actual.IsLoaded); } - [Fact] public static void Xml_XmlAttributesTest() { @@ -520,7 +518,7 @@ public static void Xml_XmlAttributesTest() public static void Xml_XmlAnyAttributeTest() { var serializer = new XmlSerializer(typeof(TypeWithAnyAttribute)); - const string format = @"{3}"; + string format = WithXmlHeader(@"{3}"); const int intProperty = 42; const string attribute1 = "Technical"; const string attribute2 = "Red"; @@ -600,16 +598,35 @@ public static void Xml_Nullables() } [Fact] - public static void Xml_ClassImplementingIXmlSerialiable() + public static void Xml_DerivedClasses() + { + var dClass = new SimpleDerivedClass() { AttributeString = "derivedClassTest", DateTimeValue = DateTime.Parse("Dec 31, 1999"), BoolValue = true }; + + var expectedXml = WithXmlHeader(@""); + var fromBase = SerializeAndDeserialize(dClass, expectedXml, () => new XmlSerializer(typeof(SimpleBaseClass))); + Assert.Equal(dClass.AttributeString, fromBase.AttributeString); + Assert.StrictEqual(dClass.DateTimeValue, fromBase.DateTimeValue); + Assert.Equal(dClass.BoolValue, fromBase.BoolValue); + + // Derived class does not apply XmlRoot attribute to force itself to be emitted with the base class element name, so update expected xml accordingly. + expectedXml = WithXmlHeader(@""); + var fromDerived = SerializeAndDeserialize(dClass, expectedXml, () => new XmlSerializer(typeof(SimpleDerivedClass))); + Assert.Equal(dClass.AttributeString, fromDerived.AttributeString); + Assert.StrictEqual(dClass.DateTimeValue, fromDerived.DateTimeValue); + Assert.Equal(dClass.BoolValue, fromDerived.BoolValue); + } + + [Fact] + public static void Xml_ClassImplementingIXmlSerializable() { - var value = new ClassImplementingIXmlSerialiable() { StringValue = "Hello world" }; - var actual = SerializeAndDeserialize(value, + var value = new ClassImplementingIXmlSerializable() { StringValue = "Hello world" }; + var actual = SerializeAndDeserialize(value, @" -"); +"); Assert.Equal(value.StringValue, actual.StringValue); Assert.StrictEqual(value.GetPrivateMember(), actual.GetPrivateMember()); - Assert.True(ClassImplementingIXmlSerialiable.ReadXmlInvoked); - Assert.True(ClassImplementingIXmlSerialiable.WriteXmlInvoked); + Assert.True(ClassImplementingIXmlSerializable.ReadXmlInvoked); + Assert.True(ClassImplementingIXmlSerializable.WriteXmlInvoked); } [Fact] @@ -680,7 +697,7 @@ public static void Xml_TypeWithXmlElementProperty() categoryElement.InnerText = "Category innertext"; var expected = new TypeWithXmlElementProperty() { Elements = new[] { productElement, categoryElement } }; var actual = SerializeAndDeserialize(expected, -@"Product innertextCategory innertext"); + WithXmlHeader(@"Product innertextCategory innertext")); Assert.StrictEqual(expected.Elements.Length, actual.Elements.Length); for (int i = 0; i < expected.Elements.Length; ++i) { @@ -731,13 +748,12 @@ private static System.Reflection.ConstructorInfo FindDefaultConstructor(System.R [Fact] public static void Xml_TestIgnoreWhitespaceForDeserialization() { - string xml = @" - + string xml = WithXmlHeader(@" -"; +"); XmlSerializer serializer = new XmlSerializer(typeof(ServerSettings)); StringReader reader = new StringReader(xml); @@ -755,7 +771,7 @@ public static void Xml_TypeWithBinaryProperty() obj.Base64Content = Encoding.Unicode.GetBytes(str); obj.BinaryHexContent = Encoding.Unicode.GetBytes(str); var actual = SerializeAndDeserialize(obj, -@"540068006500200071007500690063006B002000620072006F0077006E00200066006F00780020006A0075006D007000730020006F00760065007200200074006800650020006C0061007A007900200064006F0067002E00VABoAGUAIABxAHUAaQBjAGsAIABiAHIAbwB3AG4AIABmAG8AeAAgAGoAdQBtAHAAcwAgAG8AdgBlAHIAIAB0AGgAZQAgAGwAYQB6AHkAIABkAG8AZwAuAA=="); + WithXmlHeader(@"540068006500200071007500690063006B002000620072006F0077006E00200066006F00780020006A0075006D007000730020006F00760065007200200074006800650020006C0061007A007900200064006F0067002E00VABoAGUAIABxAHUAaQBjAGsAIABiAHIAbwB3AG4AIABmAG8AeAAgAGoAdQBtAHAAcwAgAG8AdgBlAHIAIAB0AGgAZQAgAGwAYQB6AHkAIABkAG8AZwAuAA==")); Assert.True(Enumerable.SequenceEqual(obj.Base64Content, actual.Base64Content)); Assert.True(Enumerable.SequenceEqual(obj.BinaryHexContent, actual.BinaryHexContent)); } @@ -792,8 +808,7 @@ public static void Xml_DifferentSerializeDeserializeOverloads() } stream.Position = 0; var actualOutput = new StreamReader(stream).ReadToEnd(); - const string baseline = - @"p1 value123"; + string baseline = WithXmlHeader(@"p1 value123"); var result = Utils.Compare(baseline, actualOutput); Assert.True(result.Equal, string.Format("{1}{0}Test failed for input: {2}{0}Expected: {3}{0}Actual: {4}", Environment.NewLine, result.ErrorMessage, expected, baseline, actualOutput)); stream.Position = 0; @@ -815,21 +830,17 @@ public static void Xml_DifferentSerializeDeserializeOverloads() public static void Xml_TypeWithTimeSpanProperty() { var obj = new TypeWithTimeSpanProperty { TimeSpanProperty = TimeSpan.FromMilliseconds(1) }; - var deserializedObj = SerializeAndDeserialize(obj, -@" - + var deserializedObj = SerializeAndDeserialize(obj, WithXmlHeader(@" PT0.001S -"); +")); Assert.StrictEqual(obj.TimeSpanProperty, deserializedObj.TimeSpanProperty); } - [Fact] + [ConditionalFact(nameof(DefaultValueAttributeIsSupported))] public static void Xml_TypeWithDefaultTimeSpanProperty() { var obj = new TypeWithDefaultTimeSpanProperty { TimeSpanProperty2 = new TimeSpan(0, 1, 0) }; - var deserializedObj = SerializeAndDeserialize(obj, -@" -PT1M"); + var deserializedObj = SerializeAndDeserialize(obj, WithXmlHeader(@"PT1M")); Assert.NotNull(deserializedObj); Assert.Equal(obj.TimeSpanProperty, deserializedObj.TimeSpanProperty); Assert.Equal(obj.TimeSpanProperty2, deserializedObj.TimeSpanProperty2); @@ -868,7 +879,7 @@ public static void Xml_DeserializeEmptyTimeSpanType() } } - [Fact] + [ConditionalFact(nameof(DefaultValueAttributeIsSupported))] public static void Xml_TypeWithDateTimeOffsetProperty() { var now = new DateTimeOffset(DateTime.Now); @@ -893,7 +904,7 @@ public static void Xml_TypeWithDateTimeOffsetProperty() Assert.True(deserializedObj.NullableDTOWithDefault == null); } - [Fact] + [ConditionalFact(nameof(DefaultValueAttributeIsSupported))] public static void Xml_DeserializeTypeWithEmptyDateTimeOffsetProperties() { //var def = DateTimeOffset.Parse("3/17/1977 5:00:01 PM -05:00"); // "1977-03-17T17:00:01-05:00" @@ -951,10 +962,9 @@ public static void Xml_TypeWithByteProperty() { var obj = new TypeWithByteProperty() { ByteProperty = 123 }; var deserializedObj = SerializeAndDeserialize(obj, -@" - +WithXmlHeader(@" 123 -"); +")); Assert.StrictEqual(obj.ByteProperty, deserializedObj.ByteProperty); } @@ -967,10 +977,9 @@ public static void Xml_DeserializeOutOfRangeByteProperty() { var writer = new StreamWriter(stream); writer.Write( -@" - +WithXmlHeader(@" -1 -"); +")); writer.Flush(); stream.Position = 0; Assert.Throws(() => (TypeWithByteProperty)serializer.Deserialize(stream)); @@ -1043,7 +1052,7 @@ private static SimpleType[][] GetObjectwith2DArrayOfSimpleType() public static void Xml_TypeWithByteArrayAsXmlText() { var value = new TypeWithByteArrayAsXmlText() { Value = new byte[] { 1, 2, 3 } }; - var actual = SerializeAndDeserialize(value, "\r\nAQID"); + var actual = SerializeAndDeserialize(value, WithXmlHeader("AQID")); Assert.NotNull(actual); Assert.NotNull(actual.Value); @@ -1056,11 +1065,10 @@ public static void Xml_SimpleType() { var obj = new SimpleType { P1 = "foo", P2 = 1 }; var deserializedObj = SerializeAndDeserialize(obj, -@" - +WithXmlHeader(@" foo 1 -"); +")); Assert.NotNull(deserializedObj); Assert.Equal(obj.P1, deserializedObj.P1); Assert.StrictEqual(obj.P2, deserializedObj.P2); @@ -1086,7 +1094,7 @@ public static void Xml_SerializedFormat() ms.Position = 0; string nl = Environment.NewLine; string actualFormatting = new StreamReader(ms).ReadToEnd(); - string expectedFormatting = $"{nl}{nl} foo{nl} 1{ nl}"; + string expectedFormatting = WithXmlHeader($"{nl} foo{nl} 1{ nl}"); Assert.Equal(expectedFormatting, actualFormatting); } } @@ -1127,7 +1135,7 @@ public static void Xml_TypeWithPropertiesHavingDefaultValue_DefaultValue() CharProperty = 'm' }; - var actual = SerializeAndDeserialize(value, "\r\n\r\n 109\r\n"); + var actual = SerializeAndDeserialize(value, WithXmlHeader("\r\n 109\r\n")); Assert.NotNull(actual); Assert.Equal(value.StringProperty, actual.StringProperty); @@ -1147,7 +1155,7 @@ public static void Xml_TypeWithStringPropertyWithDefaultValue_NonDefaultValue() CharProperty = 'n' }; - var actual = SerializeAndDeserialize(value, "\r\n\r\n NonEmpty\r\n NonDefaultValue\r\n 12\r\n 110\r\n"); + var actual = SerializeAndDeserialize(value, WithXmlHeader("\r\n NonEmpty\r\n NonDefaultValue\r\n 12\r\n 110\r\n")); Assert.NotNull(actual); Assert.Equal(value.StringProperty, actual.StringProperty); @@ -1158,7 +1166,7 @@ public static void Xml_TypeWithEnumPropertyHavingDefaultValue() { var value = new TypeWithEnumPropertyHavingDefaultValue() { EnumProperty = IntEnum.Option0 }; var actual = SerializeAndDeserialize(value, - "\r\n\r\n Option0\r\n", + WithXmlHeader("\r\n Option0\r\n"), skipStringCompare: false); Assert.NotNull(actual); @@ -1167,7 +1175,7 @@ public static void Xml_TypeWithEnumPropertyHavingDefaultValue() value = new TypeWithEnumPropertyHavingDefaultValue() { EnumProperty = IntEnum.Option1 }; actual = SerializeAndDeserialize(value, - "\r\n", + WithXmlHeader(""), skipStringCompare: false); Assert.NotNull(actual); @@ -1179,7 +1187,7 @@ public static void Xml_TypeWithEnumFlagPropertyHavingDefaultValue() { var value = new TypeWithEnumFlagPropertyHavingDefaultValue() { EnumProperty = EnumFlags.Two | EnumFlags.Three }; var actual = SerializeAndDeserialize(value, - "\r\n\r\n Two Three\r\n"); + WithXmlHeader("\r\n Two Three\r\n")); Assert.NotNull(actual); Assert.StrictEqual(value.EnumProperty, actual.EnumProperty); @@ -1187,7 +1195,7 @@ public static void Xml_TypeWithEnumFlagPropertyHavingDefaultValue() value = new TypeWithEnumFlagPropertyHavingDefaultValue(); actual = SerializeAndDeserialize(value, - "\r\n"); + WithXmlHeader("")); Assert.NotNull(actual); Assert.StrictEqual(value.EnumProperty, actual.EnumProperty); @@ -1227,7 +1235,7 @@ public static void Xml_TypeWithXmlQualifiedName() Value = new XmlQualifiedName("FooName") }; - var actual = SerializeAndDeserialize(value, "\r\n\r\n FooName\r\n", skipStringCompare: false); + var actual = SerializeAndDeserialize(value, WithXmlHeader("\r\n FooName\r\n"), skipStringCompare: false); Assert.NotNull(actual); Assert.StrictEqual(value.Value, actual.Value); @@ -1258,7 +1266,7 @@ public static void Xml_TypeWithShouldSerializeMethod_WithDefaultValue() { var value = new TypeWithShouldSerializeMethod(); - var actual = SerializeAndDeserialize(value, "\r\n"); + var actual = SerializeAndDeserialize(value, WithXmlHeader("")); Assert.NotNull(actual); Assert.Equal(value.Foo, actual.Foo); @@ -1269,7 +1277,7 @@ public static void Xml_TypeWithShouldSerializeMethod_WithNonDefaultValue() { var value = new TypeWithShouldSerializeMethod() { Foo = "SomeValue" }; - var actual = SerializeAndDeserialize(value, "\r\nSomeValue"); + var actual = SerializeAndDeserialize(value, WithXmlHeader("SomeValue")); Assert.NotNull(actual); Assert.Equal(value.Foo, actual.Foo); @@ -1283,7 +1291,7 @@ public static void Xml_KnownTypesThroughConstructorWithArrayProperties() var value = new KnownTypesThroughConstructorWithArrayProperties() { IntArrayValue = intArray, StringArrayValue = stringArray }; var actual = SerializeAndDeserialize(value, - "\r\n\r\n \r\n a\r\n b\r\n \r\n \r\n 1\r\n 2\r\n 3\r\n \r\n", + WithXmlHeader("\r\n \r\n a\r\n b\r\n \r\n \r\n 1\r\n 2\r\n 3\r\n \r\n"), () => { return new XmlSerializer(typeof(KnownTypesThroughConstructorWithArrayProperties), new Type[] { typeof(int[]), typeof(string[]) }); }, skipStringCompare: false); @@ -1306,7 +1314,7 @@ public static void Xml_KnownTypesThroughConstructorWithEnumFlags() var enumFlags = EnumFlags.One | EnumFlags.Four; var value = new KnownTypesThroughConstructorWithValue() { Value = enumFlags }; var actual = SerializeAndDeserialize(value, - "\r\n\r\n One Four\r\n", + WithXmlHeader("\r\n One Four\r\n"), () => { return new XmlSerializer(typeof(KnownTypesThroughConstructorWithValue), new Type[] { typeof(EnumFlags) }); }, skipStringCompare: false); @@ -1319,7 +1327,7 @@ public static void Xml_KnownTypesThroughConstructorWithEnumFlagsXmlQualifiedName { var value = new KnownTypesThroughConstructorWithValue() { Value = new XmlQualifiedName("foo") }; var actual = SerializeAndDeserialize(value, - "\r\n\r\n foo\r\n", + WithXmlHeader("\r\n foo\r\n"), () => { return new XmlSerializer(typeof(KnownTypesThroughConstructorWithValue), new Type[] { typeof(XmlQualifiedName) }); }, skipStringCompare: false); @@ -1345,7 +1353,7 @@ public static void Xml_TypeWithTypesHavingCustomFormatter() }; var actual = SerializeAndDeserialize(value, - "\r\n\r\n 2016-07-18T00:00:00Z\r\n QNameContent\r\n 2016-07-18\r\n NameContent\r\n NCNameContent\r\n NMTOKENContent\r\n NMTOKENSContent\r\n VABoAGUAIABxAHUAaQBjAGsAIABiAHIAbwB3AG4AIABmAG8AeAAgAGoAdQBtAHAAcwAgAG8AdgBlAHIAIAB0AGgAZQAgAGwAYQB6AHkAIABkAG8AZwAuAA==\r\n 540068006500200071007500690063006B002000620072006F0077006E00200066006F00780020006A0075006D007000730020006F00760065007200200074006800650020006C0061007A007900200064006F0067002E00\r\n"); + WithXmlHeader("\r\n 2016-07-18T00:00:00Z\r\n QNameContent\r\n 2016-07-18\r\n NameContent\r\n NCNameContent\r\n NMTOKENContent\r\n NMTOKENSContent\r\n VABoAGUAIABxAHUAaQBjAGsAIABiAHIAbwB3AG4AIABmAG8AeAAgAGoAdQBtAHAAcwAgAG8AdgBlAHIAIAB0AGgAZQAgAGwAYQB6AHkAIABkAG8AZwAuAA==\r\n 540068006500200071007500690063006B002000620072006F0077006E00200066006F00780020006A0075006D007000730020006F00760065007200200074006800650020006C0061007A007900200064006F0067002E00\r\n")); Assert.NotNull(actual); Assert.True(value.DateTimeContent == actual.DateTimeContent, $"Actual DateTimeContent was not as expected. \r\n Expected: {value.DateTimeContent} \r\n Actual: {actual.DateTimeContent}"); @@ -1374,7 +1382,7 @@ public static void Xml_TypeWithArrayPropertyHavingChoice() var value = new TypeWithArrayPropertyHavingChoice() { ManyChoices = choices, ChoiceArray = itemChoices }; - var actual = SerializeAndDeserialize(value, "\r\n\r\n Food\r\n 5\r\n"); + var actual = SerializeAndDeserialize(value, WithXmlHeader("\r\n Food\r\n 5\r\n")); Assert.NotNull(actual); Assert.NotNull(actual.ManyChoices); @@ -1388,32 +1396,32 @@ public static void XML_TypeWithTypeNameInXmlTypeAttribute_WithValue() var value = new TypeWithTypeNameInXmlTypeAttribute() { XmlAttributeForm = "SomeValue" }; var actual = SerializeAndDeserialize(value, - "\r\n", + WithXmlHeader(""), skipStringCompare: false); Assert.NotNull(actual); Assert.Equal(value.XmlAttributeForm, actual.XmlAttributeForm); } - [Fact] - public static void XML_TypeWithFieldsOrdered() - { - var value = new TypeWithFieldsOrdered() - { - IntField1 = 1, - IntField2 = 2, - StringField1 = "foo1", - StringField2 = "foo2" - }; + //[Fact] + //public static void XML_TypeWithFieldsOrdered() + //{ + // var value = new TypeWithFieldsOrdered() + // { + // IntField1 = 1, + // IntField2 = 2, + // StringField1 = "foo1", + // StringField2 = "foo2" + // }; - var actual = SerializeAndDeserialize(value, "\r\n\r\n 1\r\n 2\r\n foo2\r\n foo1\r\n"); + // var actual = SerializeAndDeserialize(value, WithXmlHeader("\r\n 2\r\n 1\r\n foo2\r\n foo1\r\n")); - Assert.NotNull(actual); - Assert.Equal(value.IntField1, actual.IntField1); - Assert.Equal(value.IntField2, actual.IntField2); - Assert.Equal(value.StringField1, actual.StringField1); - Assert.Equal(value.StringField2, actual.StringField2); - } + // Assert.NotNull(actual); + // Assert.Equal(value.IntField1, actual.IntField1); + // Assert.Equal(value.IntField2, actual.IntField2); + // Assert.Equal(value.StringField1, actual.StringField1); + // Assert.Equal(value.StringField2, actual.StringField2); + //} [Fact] public static void XmlSerializerFactoryTest() @@ -1441,13 +1449,12 @@ public static void XmlUnknownElementAndEventHandlerTest() grouplists.Add(args.Element.Name); ++count; }); - string xmlFileContent = @" - + string xmlFileContent = WithXmlHeader(@" MyGroup Large 444 West - "; + "); Group group = (Group)serializer.Deserialize(GetStreamFromString(xmlFileContent)); Assert.NotNull(group); Assert.NotNull(group.GroupName); @@ -1471,8 +1478,7 @@ public static void XmlUnknownNodeAndEventHandlerTest() grouplists.Add(args.LocalName); ++count; }); - string xmlFileContent = @" - + string xmlFileContent = WithXmlHeader(@" MyGroup Large 444 @@ -1484,7 +1490,7 @@ public static void XmlUnknownNodeAndEventHandlerTest() element - "; + "); Group group = (Group)serializer.Deserialize(GetStreamFromString(xmlFileContent)); Assert.NotNull(group); Assert.Null(group.GroupName); @@ -1507,10 +1513,9 @@ public static void XmlUnknownAttributeAndEventHandlerTest() grouplists.Add(args.Attr.LocalName); ++count; }); - string xmlFileContent = @" - + string xmlFileContent = WithXmlHeader(@" MyGroup - "; + "); Group group = (Group)serializer.Deserialize(GetStreamFromString(xmlFileContent)); Assert.NotNull(group); Assert.NotNull(group.GroupName); @@ -1536,10 +1541,9 @@ public static void XmlDeserializationEventsTest() grouplists.Add(args.Attr.LocalName); ++count; }); - string xmlFileContent = @" - + string xmlFileContent = WithXmlHeader(@" MyGroup - "; + "); Group group = (Group)serializer.Deserialize(XmlReader.Create(GetStreamFromString(xmlFileContent)), events); Assert.NotNull(group); Assert.NotNull(group.GroupName); @@ -1964,7 +1968,7 @@ public static void SerializeWithDefaultValueSetToNegativeInfinityTest() [Fact] public static void DeserializeIDREFSIntoStringTest() { - string xmlstring = @""; + string xmlstring = WithXmlHeader(@""); Stream ms = GenerateStreamFromString(xmlstring); XmlSerializer ser = new XmlSerializer(typeof(MsgDocumentType)); var value = (MsgDocumentType)ser.Deserialize(ms); @@ -2013,8 +2017,7 @@ public static void Xml_TypeWithMismatchBetweenAttributeAndPropertyType() [Fact] public static void Xml_XsdValidationAndDeserialization() { - var xsdstring = @" - + var xsdstring = WithXmlHeader(@" @@ -2040,15 +2043,14 @@ public static void Xml_XsdValidationAndDeserialization() -"; - var param = "" + - "" + +"); + var param = WithXmlHeader("" + "" + "" + "" + "" + "" + - ""; + ""); using (var stream = new MemoryStream()) { @@ -2302,6 +2304,12 @@ private static Stream GenerateStreamFromString(string s) return stream; } + private static string WithXmlHeader(string xml, bool normalizeLineEndings = true) + { + xml = (normalizeLineEndings) ? xml.Replace("\r\n", "\n").Replace("\n", Environment.NewLine) : xml; + return "" + Environment.NewLine + xml; + } + private static T SerializeAndDeserialize(T value, string baseline, Func serializerFactory = null, bool skipStringCompare = false, XmlSerializerNamespaces xns = null) { diff --git a/src/libraries/System.Reflection.Context/System.Reflection.Context.sln b/src/libraries/System.Reflection.Context/System.Reflection.Context.sln index 6e26ae1db7a..ac15bf6b162 100644 --- a/src/libraries/System.Reflection.Context/System.Reflection.Context.sln +++ b/src/libraries/System.Reflection.Context/System.Reflection.Context.sln @@ -7,7 +7,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.Context", EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.Context.Tests", "tests\System.Reflection.Context.Tests.csproj", "{34EA59F6-6177-4957-9894-563A73B02D63}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{CDC2FCCA-3BDD-44D6-94E2-864684AFA61D}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{034AC4D1-8E12-42ED-B554-8C1FECF85C73}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{7EEF6CAC-49D4-4D06-9414-2C9175898D13}" EndProject @@ -59,10 +59,10 @@ Global {34EA59F6-6177-4957-9894-563A73B02D63}.Debug|Any CPU.Build.0 = Debug|Any CPU {34EA59F6-6177-4957-9894-563A73B02D63}.Release|Any CPU.ActiveCfg = Release|Any CPU {34EA59F6-6177-4957-9894-563A73B02D63}.Release|Any CPU.Build.0 = Release|Any CPU - {CDC2FCCA-3BDD-44D6-94E2-864684AFA61D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {CDC2FCCA-3BDD-44D6-94E2-864684AFA61D}.Debug|Any CPU.Build.0 = Debug|Any CPU - {CDC2FCCA-3BDD-44D6-94E2-864684AFA61D}.Release|Any CPU.ActiveCfg = Release|Any CPU - {CDC2FCCA-3BDD-44D6-94E2-864684AFA61D}.Release|Any CPU.Build.0 = Release|Any CPU + {034AC4D1-8E12-42ED-B554-8C1FECF85C73}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {034AC4D1-8E12-42ED-B554-8C1FECF85C73}.Debug|Any CPU.Build.0 = Debug|Any CPU + {034AC4D1-8E12-42ED-B554-8C1FECF85C73}.Release|Any CPU.ActiveCfg = Release|Any CPU + {034AC4D1-8E12-42ED-B554-8C1FECF85C73}.Release|Any CPU.Build.0 = Release|Any CPU {7EEF6CAC-49D4-4D06-9414-2C9175898D13}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {7EEF6CAC-49D4-4D06-9414-2C9175898D13}.Debug|Any CPU.Build.0 = Debug|Any CPU {7EEF6CAC-49D4-4D06-9414-2C9175898D13}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -96,7 +96,7 @@ Global {34EA59F6-6177-4957-9894-563A73B02D63} = {C676A2DE-6F6F-44AF-B869-53C834A272AF} {B2EBCE83-FA49-4ECD-9E8E-AF231AADFF67} = {31D51BA2-EB4E-4EC1-908D-EC23CB91C89D} {794EAE71-36BA-436D-841A-A8C72AADF485} = {E460C3AC-CC68-44E7-9256-75062C1CF587} - {CDC2FCCA-3BDD-44D6-94E2-864684AFA61D} = {AC2F6758-1191-4142-B369-6C2E27A4BEBC} + {034AC4D1-8E12-42ED-B554-8C1FECF85C73} = {AC2F6758-1191-4142-B369-6C2E27A4BEBC} {7EEF6CAC-49D4-4D06-9414-2C9175898D13} = {AC2F6758-1191-4142-B369-6C2E27A4BEBC} {164DAD51-B6B7-42FF-9728-1A341B4B4954} = {76FC7429-44DE-4EA2-A86B-0ADA71EF8EB3} {05C4A684-0C5B-4B7D-980B-044AB39C5F27} = {76FC7429-44DE-4EA2-A86B-0ADA71EF8EB3} diff --git a/src/libraries/System.Reflection.Context/src/PACKAGE.md b/src/libraries/System.Reflection.Context/src/PACKAGE.md new file mode 100644 index 00000000000..c7c6dba47e2 --- /dev/null +++ b/src/libraries/System.Reflection.Context/src/PACKAGE.md @@ -0,0 +1,133 @@ +## About + +Provides the `CustomReflectionContext` class to enable adding or removing custom attributes from reflection objects, or adding dummy properties to those objects, without re-implementing the complete reflection model. + +## Key Features + + + +* Create a custom reflection context to control how types and members are presented during reflection. +* Easily extend or customize the reflection model to fit specialized application needs. + +## How to Use + + + +Defining a custom `Attribute` and implement a `CustomReflectionContext` to add the attribute to specic methods. + +```csharp +using System.Reflection; +using System.Reflection.Context; + +[AttributeUsage(AttributeTargets.Method)] +class CustomAttribute : Attribute +{ +} + +class CustomContext : CustomReflectionContext +{ + // Called whenever the reflection context checks for custom attributes. + protected override IEnumerable GetCustomAttributes(MemberInfo member, IEnumerable declaredAttributes) + { + // Add custom attribute to "ToString" members + if (member.Name == "ToString") + { + yield return new CustomAttribute(); + } + + // Keep existing attributes as well + foreach (var attr in declaredAttributes) + { + yield return attr; + } + } +} +``` + +Inspecting the `string` type with both the default and custom reflection context. + +```csharp +Type type = typeof(string); + +// Representation of the type in the default reflection context +TypeInfo typeInfo = type.GetTypeInfo(); + +Console.WriteLine("\"To*\" members and their attributes in the default reflection context"); +foreach (MemberInfo memberInfo in typeInfo.DeclaredMembers) +{ + if (memberInfo.Name.StartsWith("To")) + { + Console.WriteLine(memberInfo.Name); + foreach (Attribute attribute in memberInfo.GetCustomAttributes()) + { + Console.WriteLine($" - {attribute.GetType()}"); + } + } +} +Console.WriteLine(); + +// Output: +// "To*" members and their attributes in the default reflection context +// ToCharArray +// ToCharArray +// ToString +// ToString +// ToLower +// ToLower +// ToLowerInvariant +// ToUpper +// ToUpper +// ToUpperInvariant + +// Representation of the type in the customized reflection context +CustomContext customContext = new(); +TypeInfo customTypeInfo = customContext.MapType(typeInfo); + +Console.WriteLine("\"To*\" members and their attributes in the customized reflection context"); +foreach (MemberInfo memberInfo in customTypeInfo.DeclaredMembers) +{ + if (memberInfo.Name.StartsWith("To")) + { + Console.WriteLine(memberInfo.Name); + foreach (Attribute attribute in memberInfo.GetCustomAttributes()) + { + Console.WriteLine($" - {attribute.GetType()}"); + } + } +} + +// Output: +// "To*" members and their attributes in the customized reflection context +// ToCharArray +// ToCharArray +// ToString +// - CustomAttribute +// ToString +// - CustomAttribute +// ToLower +// ToLower +// ToLowerInvariant +// ToUpper +// ToUpper +// ToUpperInvariant +``` +## Main Types + + + +The main type provided by this library is: + +* `System.Reflection.Context.CustomReflectionContext` + +## Additional Documentation + + + +* [API documentation](https://learn.microsoft.com/dotnet/api/system.reflection.context) + +## Feedback & Contributing + + + +System.Reflection.Context is released as open source under the [MIT license](https://licenses.nuget.org/MIT). +Bug reports and contributions are welcome at [the GitHub repository](https://github.com/dotnet/runtime). diff --git a/src/libraries/System.Reflection.Context/src/System.Reflection.Context.csproj b/src/libraries/System.Reflection.Context/src/System.Reflection.Context.csproj index 59b7bb58d1e..bceb051a5fe 100644 --- a/src/libraries/System.Reflection.Context/src/System.Reflection.Context.csproj +++ b/src/libraries/System.Reflection.Context/src/System.Reflection.Context.csproj @@ -7,12 +7,7 @@ true true true - Provides classes that enable customized reflection contexts. - -Commonly Used Types: -System.Reflection.Context.CustomReflectionContext - - false + Provides CustomReflectionContext to enable customized reflection contexts. diff --git a/src/libraries/System.Reflection.DispatchProxy/System.Reflection.DispatchProxy.sln b/src/libraries/System.Reflection.DispatchProxy/System.Reflection.DispatchProxy.sln index 63e606f05d4..f9e48542223 100644 --- a/src/libraries/System.Reflection.DispatchProxy/System.Reflection.DispatchProxy.sln +++ b/src/libraries/System.Reflection.DispatchProxy/System.Reflection.DispatchProxy.sln @@ -9,7 +9,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.DispatchP EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.DispatchProxy.TestDependency", "tests\TestDependency\System.Reflection.DispatchProxy.TestDependency.csproj", "{86C30AC7-2B89-4757-A580-0FB318D9E784}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{8FC6C206-76D5-4FE2-A7A4-C0B6597709AF}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{D35513A3-7545-4F4B-AA1B-0456BF14D051}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{318BE680-88DD-478B-ABA8-B19C1BBB93E9}" EndProject @@ -67,10 +67,10 @@ Global {86C30AC7-2B89-4757-A580-0FB318D9E784}.Debug|Any CPU.Build.0 = Debug|Any CPU {86C30AC7-2B89-4757-A580-0FB318D9E784}.Release|Any CPU.ActiveCfg = Release|Any CPU {86C30AC7-2B89-4757-A580-0FB318D9E784}.Release|Any CPU.Build.0 = Release|Any CPU - {8FC6C206-76D5-4FE2-A7A4-C0B6597709AF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {8FC6C206-76D5-4FE2-A7A4-C0B6597709AF}.Debug|Any CPU.Build.0 = Debug|Any CPU - {8FC6C206-76D5-4FE2-A7A4-C0B6597709AF}.Release|Any CPU.ActiveCfg = Release|Any CPU - {8FC6C206-76D5-4FE2-A7A4-C0B6597709AF}.Release|Any CPU.Build.0 = Release|Any CPU + {D35513A3-7545-4F4B-AA1B-0456BF14D051}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D35513A3-7545-4F4B-AA1B-0456BF14D051}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D35513A3-7545-4F4B-AA1B-0456BF14D051}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D35513A3-7545-4F4B-AA1B-0456BF14D051}.Release|Any CPU.Build.0 = Release|Any CPU {318BE680-88DD-478B-ABA8-B19C1BBB93E9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {318BE680-88DD-478B-ABA8-B19C1BBB93E9}.Debug|Any CPU.Build.0 = Debug|Any CPU {318BE680-88DD-478B-ABA8-B19C1BBB93E9}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -110,7 +110,7 @@ Global {DE8CF6FB-C4B6-42B4-ADEE-9CE6066DB6D8} = {F1A0875B-0263-4071-8847-F0A2C479F6F9} {A7AB7982-726A-47D1-AD9E-4306FECE5F4B} = {F1A0875B-0263-4071-8847-F0A2C479F6F9} {F5A284B5-10D3-43D4-BB3F-F0FB55033504} = {95661E1D-F86D-4EDC-AF44-E0F782BB7E4B} - {8FC6C206-76D5-4FE2-A7A4-C0B6597709AF} = {03BEF49E-85A2-49A8-9A48-EF93FA21B743} + {D35513A3-7545-4F4B-AA1B-0456BF14D051} = {03BEF49E-85A2-49A8-9A48-EF93FA21B743} {318BE680-88DD-478B-ABA8-B19C1BBB93E9} = {03BEF49E-85A2-49A8-9A48-EF93FA21B743} {49563DBE-6B20-4BED-ADF7-0FD7724299D8} = {B5966BF5-E3ED-494C-9CE1-04A172C511B5} {77BBC09A-4D62-438E-BEFC-4F5EFB2061CB} = {B5966BF5-E3ED-494C-9CE1-04A172C511B5} diff --git a/src/libraries/System.Reflection.Emit.ILGeneration/System.Reflection.Emit.ILGeneration.sln b/src/libraries/System.Reflection.Emit.ILGeneration/System.Reflection.Emit.ILGeneration.sln index bcfde5d3d3a..079df82749e 100644 --- a/src/libraries/System.Reflection.Emit.ILGeneration/System.Reflection.Emit.ILGeneration.sln +++ b/src/libraries/System.Reflection.Emit.ILGeneration/System.Reflection.Emit.ILGeneration.sln @@ -19,6 +19,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.Emit.ILGe EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.Primitives", "..\System.Reflection.Primitives\ref\System.Reflection.Primitives.csproj", "{1F1F9925-48BB-4384-9C46-ADBDCC7E72D1}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{B8EA88A9-C7B3-4DE1-88F3-26BFA15191FC}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{FFA71ACB-EAD8-4242-A5D6-FBB3F704949D}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{3461E542-7F19-4B98-B206-BDF932529A5B}" @@ -291,6 +293,27 @@ Global {1F1F9925-48BB-4384-9C46-ADBDCC7E72D1}.Checked|arm64.ActiveCfg = Debug|Any CPU {1F1F9925-48BB-4384-9C46-ADBDCC7E72D1}.Checked|x64.ActiveCfg = Debug|Any CPU {1F1F9925-48BB-4384-9C46-ADBDCC7E72D1}.Checked|x86.ActiveCfg = Debug|Any CPU + {B8EA88A9-C7B3-4DE1-88F3-26BFA15191FC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {B8EA88A9-C7B3-4DE1-88F3-26BFA15191FC}.Debug|Any CPU.Build.0 = Debug|Any CPU + {B8EA88A9-C7B3-4DE1-88F3-26BFA15191FC}.Debug|arm.ActiveCfg = Debug|Any CPU + {B8EA88A9-C7B3-4DE1-88F3-26BFA15191FC}.Debug|arm64.ActiveCfg = Debug|Any CPU + {B8EA88A9-C7B3-4DE1-88F3-26BFA15191FC}.Debug|x64.ActiveCfg = Debug|Any CPU + {B8EA88A9-C7B3-4DE1-88F3-26BFA15191FC}.Debug|x64.Build.0 = Debug|Any CPU + {B8EA88A9-C7B3-4DE1-88F3-26BFA15191FC}.Debug|x86.ActiveCfg = Debug|Any CPU + {B8EA88A9-C7B3-4DE1-88F3-26BFA15191FC}.Debug|x86.Build.0 = Debug|Any CPU + {B8EA88A9-C7B3-4DE1-88F3-26BFA15191FC}.Release|Any CPU.ActiveCfg = Release|Any CPU + {B8EA88A9-C7B3-4DE1-88F3-26BFA15191FC}.Release|Any CPU.Build.0 = Release|Any CPU + {B8EA88A9-C7B3-4DE1-88F3-26BFA15191FC}.Release|arm.ActiveCfg = Release|Any CPU + {B8EA88A9-C7B3-4DE1-88F3-26BFA15191FC}.Release|arm64.ActiveCfg = Release|Any CPU + {B8EA88A9-C7B3-4DE1-88F3-26BFA15191FC}.Release|x64.ActiveCfg = Release|Any CPU + {B8EA88A9-C7B3-4DE1-88F3-26BFA15191FC}.Release|x64.Build.0 = Release|Any CPU + {B8EA88A9-C7B3-4DE1-88F3-26BFA15191FC}.Release|x86.ActiveCfg = Release|Any CPU + {B8EA88A9-C7B3-4DE1-88F3-26BFA15191FC}.Release|x86.Build.0 = Release|Any CPU + {B8EA88A9-C7B3-4DE1-88F3-26BFA15191FC}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {B8EA88A9-C7B3-4DE1-88F3-26BFA15191FC}.Checked|arm.ActiveCfg = Debug|Any CPU + {B8EA88A9-C7B3-4DE1-88F3-26BFA15191FC}.Checked|arm64.ActiveCfg = Debug|Any CPU + {B8EA88A9-C7B3-4DE1-88F3-26BFA15191FC}.Checked|x64.ActiveCfg = Debug|Any CPU + {B8EA88A9-C7B3-4DE1-88F3-26BFA15191FC}.Checked|x86.ActiveCfg = Debug|Any CPU {FFA71ACB-EAD8-4242-A5D6-FBB3F704949D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {FFA71ACB-EAD8-4242-A5D6-FBB3F704949D}.Debug|Any CPU.Build.0 = Debug|Any CPU {FFA71ACB-EAD8-4242-A5D6-FBB3F704949D}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -497,6 +520,7 @@ Global {D2A00A5C-148B-43D2-BD72-4B70D8E990EB} = {A20A0878-5647-4145-B224-C390446B7676} {81204A19-8DF3-461B-A5FE-7B85149F5CCD} = {A20A0878-5647-4145-B224-C390446B7676} {8843EA69-AD8F-4C73-8436-1641470199DC} = {155A2103-05C1-4020-8922-4F6275F6AE7E} + {B8EA88A9-C7B3-4DE1-88F3-26BFA15191FC} = {155A2103-05C1-4020-8922-4F6275F6AE7E} {FFA71ACB-EAD8-4242-A5D6-FBB3F704949D} = {155A2103-05C1-4020-8922-4F6275F6AE7E} {3461E542-7F19-4B98-B206-BDF932529A5B} = {155A2103-05C1-4020-8922-4F6275F6AE7E} {6B47F791-1C84-4B75-B04B-076E9ACBF954} = {CA60D894-129C-47A8-BDC7-C11E8D67913A} diff --git a/src/libraries/System.Reflection.Emit.Lightweight/System.Reflection.Emit.Lightweight.sln b/src/libraries/System.Reflection.Emit.Lightweight/System.Reflection.Emit.Lightweight.sln index 3713bdbaca8..d125d0ef59a 100644 --- a/src/libraries/System.Reflection.Emit.Lightweight/System.Reflection.Emit.Lightweight.sln +++ b/src/libraries/System.Reflection.Emit.Lightweight/System.Reflection.Emit.Lightweight.sln @@ -21,6 +21,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.Emit.Ligh EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.Primitives", "..\System.Reflection.Primitives\ref\System.Reflection.Primitives.csproj", "{048A4B69-9E22-4B0B-9F05-BBA8E0A47910}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{3FFE14B9-8BFD-43C4-9E9C-F2980A539739}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{40E15C1B-0AB8-4FC5-9CE2-062B736F9021}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{913E983B-B16C-4B1E-BD37-906CFF93CAB4}" @@ -314,6 +316,27 @@ Global {048A4B69-9E22-4B0B-9F05-BBA8E0A47910}.Checked|arm64.ActiveCfg = Debug|Any CPU {048A4B69-9E22-4B0B-9F05-BBA8E0A47910}.Checked|x64.ActiveCfg = Debug|Any CPU {048A4B69-9E22-4B0B-9F05-BBA8E0A47910}.Checked|x86.ActiveCfg = Debug|Any CPU + {3FFE14B9-8BFD-43C4-9E9C-F2980A539739}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {3FFE14B9-8BFD-43C4-9E9C-F2980A539739}.Debug|Any CPU.Build.0 = Debug|Any CPU + {3FFE14B9-8BFD-43C4-9E9C-F2980A539739}.Debug|arm.ActiveCfg = Debug|Any CPU + {3FFE14B9-8BFD-43C4-9E9C-F2980A539739}.Debug|arm64.ActiveCfg = Debug|Any CPU + {3FFE14B9-8BFD-43C4-9E9C-F2980A539739}.Debug|x64.ActiveCfg = Debug|Any CPU + {3FFE14B9-8BFD-43C4-9E9C-F2980A539739}.Debug|x64.Build.0 = Debug|Any CPU + {3FFE14B9-8BFD-43C4-9E9C-F2980A539739}.Debug|x86.ActiveCfg = Debug|Any CPU + {3FFE14B9-8BFD-43C4-9E9C-F2980A539739}.Debug|x86.Build.0 = Debug|Any CPU + {3FFE14B9-8BFD-43C4-9E9C-F2980A539739}.Release|Any CPU.ActiveCfg = Release|Any CPU + {3FFE14B9-8BFD-43C4-9E9C-F2980A539739}.Release|Any CPU.Build.0 = Release|Any CPU + {3FFE14B9-8BFD-43C4-9E9C-F2980A539739}.Release|arm.ActiveCfg = Release|Any CPU + {3FFE14B9-8BFD-43C4-9E9C-F2980A539739}.Release|arm64.ActiveCfg = Release|Any CPU + {3FFE14B9-8BFD-43C4-9E9C-F2980A539739}.Release|x64.ActiveCfg = Release|Any CPU + {3FFE14B9-8BFD-43C4-9E9C-F2980A539739}.Release|x64.Build.0 = Release|Any CPU + {3FFE14B9-8BFD-43C4-9E9C-F2980A539739}.Release|x86.ActiveCfg = Release|Any CPU + {3FFE14B9-8BFD-43C4-9E9C-F2980A539739}.Release|x86.Build.0 = Release|Any CPU + {3FFE14B9-8BFD-43C4-9E9C-F2980A539739}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {3FFE14B9-8BFD-43C4-9E9C-F2980A539739}.Checked|arm.ActiveCfg = Debug|Any CPU + {3FFE14B9-8BFD-43C4-9E9C-F2980A539739}.Checked|arm64.ActiveCfg = Debug|Any CPU + {3FFE14B9-8BFD-43C4-9E9C-F2980A539739}.Checked|x64.ActiveCfg = Debug|Any CPU + {3FFE14B9-8BFD-43C4-9E9C-F2980A539739}.Checked|x86.ActiveCfg = Debug|Any CPU {40E15C1B-0AB8-4FC5-9CE2-062B736F9021}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {40E15C1B-0AB8-4FC5-9CE2-062B736F9021}.Debug|Any CPU.Build.0 = Debug|Any CPU {40E15C1B-0AB8-4FC5-9CE2-062B736F9021}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -521,6 +544,7 @@ Global {E6ECE0CE-B568-4BAE-A3E4-5C795B869832} = {2AB40A0A-24D5-40B9-AA94-5BF17878879A} {86ED21D3-93FC-4FFE-927F-CDB404D71434} = {2AB40A0A-24D5-40B9-AA94-5BF17878879A} {165A3077-1F79-46E7-8BFA-88AACEB6D026} = {09AE6FA7-7363-4994-BC62-3685AE151227} + {3FFE14B9-8BFD-43C4-9E9C-F2980A539739} = {09AE6FA7-7363-4994-BC62-3685AE151227} {40E15C1B-0AB8-4FC5-9CE2-062B736F9021} = {09AE6FA7-7363-4994-BC62-3685AE151227} {913E983B-B16C-4B1E-BD37-906CFF93CAB4} = {09AE6FA7-7363-4994-BC62-3685AE151227} {5EA13609-79BF-4B45-A288-ED20A54E4263} = {81C68A3F-A099-40EE-9F8C-FDA2EEFF1B7B} diff --git a/src/libraries/System.Reflection.Emit/System.Reflection.Emit.sln b/src/libraries/System.Reflection.Emit/System.Reflection.Emit.sln index 9527fb6ae6c..793b25bee5c 100644 --- a/src/libraries/System.Reflection.Emit/System.Reflection.Emit.sln +++ b/src/libraries/System.Reflection.Emit/System.Reflection.Emit.sln @@ -37,6 +37,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.Primitive EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{A2A7CB52-1BC2-40EA-885F-DD5DE607AC96}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{1B329538-0FC3-476A-A986-3EFB0B66CDD0}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{73EA94AD-0C65-47C8-851C-12D136A0DCC1}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{506EBBFA-FF57-4141-A725-882110C17598}" @@ -500,6 +502,27 @@ Global {A2A7CB52-1BC2-40EA-885F-DD5DE607AC96}.Checked|arm64.ActiveCfg = Debug|Any CPU {A2A7CB52-1BC2-40EA-885F-DD5DE607AC96}.Checked|x64.ActiveCfg = Debug|Any CPU {A2A7CB52-1BC2-40EA-885F-DD5DE607AC96}.Checked|x86.ActiveCfg = Debug|Any CPU + {1B329538-0FC3-476A-A986-3EFB0B66CDD0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {1B329538-0FC3-476A-A986-3EFB0B66CDD0}.Debug|Any CPU.Build.0 = Debug|Any CPU + {1B329538-0FC3-476A-A986-3EFB0B66CDD0}.Debug|arm.ActiveCfg = Debug|Any CPU + {1B329538-0FC3-476A-A986-3EFB0B66CDD0}.Debug|arm64.ActiveCfg = Debug|Any CPU + {1B329538-0FC3-476A-A986-3EFB0B66CDD0}.Debug|x64.ActiveCfg = Debug|Any CPU + {1B329538-0FC3-476A-A986-3EFB0B66CDD0}.Debug|x64.Build.0 = Debug|Any CPU + {1B329538-0FC3-476A-A986-3EFB0B66CDD0}.Debug|x86.ActiveCfg = Debug|Any CPU + {1B329538-0FC3-476A-A986-3EFB0B66CDD0}.Debug|x86.Build.0 = Debug|Any CPU + {1B329538-0FC3-476A-A986-3EFB0B66CDD0}.Release|Any CPU.ActiveCfg = Release|Any CPU + {1B329538-0FC3-476A-A986-3EFB0B66CDD0}.Release|Any CPU.Build.0 = Release|Any CPU + {1B329538-0FC3-476A-A986-3EFB0B66CDD0}.Release|arm.ActiveCfg = Release|Any CPU + {1B329538-0FC3-476A-A986-3EFB0B66CDD0}.Release|arm64.ActiveCfg = Release|Any CPU + {1B329538-0FC3-476A-A986-3EFB0B66CDD0}.Release|x64.ActiveCfg = Release|Any CPU + {1B329538-0FC3-476A-A986-3EFB0B66CDD0}.Release|x64.Build.0 = Release|Any CPU + {1B329538-0FC3-476A-A986-3EFB0B66CDD0}.Release|x86.ActiveCfg = Release|Any CPU + {1B329538-0FC3-476A-A986-3EFB0B66CDD0}.Release|x86.Build.0 = Release|Any CPU + {1B329538-0FC3-476A-A986-3EFB0B66CDD0}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {1B329538-0FC3-476A-A986-3EFB0B66CDD0}.Checked|arm.ActiveCfg = Debug|Any CPU + {1B329538-0FC3-476A-A986-3EFB0B66CDD0}.Checked|arm64.ActiveCfg = Debug|Any CPU + {1B329538-0FC3-476A-A986-3EFB0B66CDD0}.Checked|x64.ActiveCfg = Debug|Any CPU + {1B329538-0FC3-476A-A986-3EFB0B66CDD0}.Checked|x86.ActiveCfg = Debug|Any CPU {73EA94AD-0C65-47C8-851C-12D136A0DCC1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {73EA94AD-0C65-47C8-851C-12D136A0DCC1}.Debug|Any CPU.Build.0 = Debug|Any CPU {73EA94AD-0C65-47C8-851C-12D136A0DCC1}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -737,6 +760,7 @@ Global {613C42F2-847A-42B3-9F5E-F5A670356BF7} = {C36D185D-9B3D-42E5-985F-E21B3BAF3B6D} {848EFB55-86B5-4259-BAA2-A49C6E3421A9} = {EB17DB9D-7058-48E8-98C3-A3B3C3BCE99B} {A2A7CB52-1BC2-40EA-885F-DD5DE607AC96} = {EB17DB9D-7058-48E8-98C3-A3B3C3BCE99B} + {1B329538-0FC3-476A-A986-3EFB0B66CDD0} = {EB17DB9D-7058-48E8-98C3-A3B3C3BCE99B} {73EA94AD-0C65-47C8-851C-12D136A0DCC1} = {EB17DB9D-7058-48E8-98C3-A3B3C3BCE99B} {506EBBFA-FF57-4141-A725-882110C17598} = {EB17DB9D-7058-48E8-98C3-A3B3C3BCE99B} {AD7C04D0-8F8C-4114-975F-804C5E30C5D6} = {611CB559-49A7-4046-9425-50E25205E891} diff --git a/src/libraries/System.Reflection.Emit/ref/System.Reflection.Emit.cs b/src/libraries/System.Reflection.Emit/ref/System.Reflection.Emit.cs index 71a79c36dc9..2847b868711 100644 --- a/src/libraries/System.Reflection.Emit/ref/System.Reflection.Emit.cs +++ b/src/libraries/System.Reflection.Emit/ref/System.Reflection.Emit.cs @@ -479,7 +479,6 @@ public sealed class PersistedAssemblyBuilder : System.Reflection.Emit.AssemblyBu { public PersistedAssemblyBuilder(System.Reflection.AssemblyName name, System.Reflection.Assembly coreAssembly, System.Collections.Generic.IEnumerable? assemblyAttributes = null) { } public override string? FullName { get { throw null; } } - public override bool IsDynamic { get { throw null; } } public override System.Reflection.Module ManifestModule { get { throw null; } } [System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Defining a dynamic assembly requires dynamic code.")] protected override System.Reflection.Emit.ModuleBuilder DefineDynamicModuleCore(string name) { throw null; } diff --git a/src/libraries/System.Reflection.Emit/src/Resources/Strings.resx b/src/libraries/System.Reflection.Emit/src/Resources/Strings.resx index 6103dbef1f1..8ec0577d1f8 100644 --- a/src/libraries/System.Reflection.Emit/src/Resources/Strings.resx +++ b/src/libraries/System.Reflection.Emit/src/Resources/Strings.resx @@ -303,4 +303,7 @@ Unmatching symbol scope. + + Type provided must be an Enum. + \ No newline at end of file diff --git a/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/EnumBuilderImpl.cs b/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/EnumBuilderImpl.cs index 1d8854bb43d..5ca6e6c9577 100644 --- a/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/EnumBuilderImpl.cs +++ b/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/EnumBuilderImpl.cs @@ -71,7 +71,7 @@ protected override void SetCustomAttributeCore(ConstructorInfo con, ReadOnlySpan public override Type? ReflectedType => _typeBuilder.ReflectedType; - public override Type UnderlyingSystemType => GetEnumUnderlyingType(); + public override Type UnderlyingSystemType => this; public override Type GetEnumUnderlyingType() => _underlyingField.FieldType; diff --git a/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/FieldBuilderImpl.cs b/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/FieldBuilderImpl.cs index f9f85f90b2a..8d0561d15be 100644 --- a/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/FieldBuilderImpl.cs +++ b/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/FieldBuilderImpl.cs @@ -40,78 +40,10 @@ internal FieldBuilderImpl(TypeBuilderImpl typeBuilder, string fieldName, Type ty protected override void SetConstantCore(object? defaultValue) { _typeBuilder.ThrowIfCreated(); - ValidateDefaultValueType(defaultValue, _fieldType); _defaultValue = defaultValue; _attributes |= FieldAttributes.HasDefault; } - internal static void ValidateDefaultValueType(object? defaultValue, Type destinationType) - { - if (defaultValue == null) - { - // nullable value types can hold null value. - if (destinationType.IsValueType && !(destinationType.IsGenericType && destinationType.GetGenericTypeDefinition() == typeof(Nullable<>))) - { - throw new ArgumentException(SR.Argument_ConstantNull); - } - } - else - { - Type sourceType = defaultValue.GetType(); - // We should allow setting a constant value on a ByRef parameter - if (destinationType.IsByRef) - { - destinationType = destinationType.GetElementType()!; - } - - // Convert nullable types to their underlying type. - destinationType = Nullable.GetUnderlyingType(destinationType) ?? destinationType; - - if (destinationType.IsEnum) - { - Type underlyingType; - if (destinationType is EnumBuilderImpl enumBldr) - { - underlyingType = enumBldr.GetEnumUnderlyingType(); - - if (sourceType != enumBldr._typeBuilder.UnderlyingSystemType && - sourceType != underlyingType && - // If the source type is an enum, should not throw when the underlying types match - sourceType.IsEnum && - sourceType.GetEnumUnderlyingType() != underlyingType) - { - throw new ArgumentException(SR.Argument_ConstantDoesntMatch); - } - } - else if (destinationType is TypeBuilderImpl typeBldr) - { - underlyingType = typeBldr.UnderlyingSystemType; - - if (underlyingType == null || (sourceType != typeBldr.UnderlyingSystemType && sourceType != underlyingType)) - { - throw new ArgumentException(SR.Argument_ConstantDoesntMatch); - } - } - else - { - underlyingType = Enum.GetUnderlyingType(destinationType); - - if (sourceType != destinationType && sourceType != underlyingType) - { - throw new ArgumentException(SR.Argument_ConstantDoesntMatch); - } - } - } - else - { - if (!destinationType.IsAssignableFrom(sourceType)) - { - throw new ArgumentException(SR.Argument_ConstantDoesntMatch); - } - } - } - } - internal void SetData(byte[] data) { _rvaData = data; diff --git a/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/ILGeneratorImpl.cs b/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/ILGeneratorImpl.cs index d4b40387e30..1ac507c16ee 100644 --- a/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/ILGeneratorImpl.cs +++ b/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/ILGeneratorImpl.cs @@ -30,7 +30,8 @@ internal sealed class ILGeneratorImpl : ILGenerator private int _localCount; private Dictionary _labelTable = new(2); private List> _memberReferences = new(); - private List _exceptionStack = new(); + private List _exceptionStack = new(); // tracks the exception nesting + private List _exceptionBlocks = new(); // keeps all ExceptionHandler blocks private Dictionary> _documentToSequencePoints = new(); internal ILGeneratorImpl(MethodBuilderImpl methodBuilder, int size) @@ -54,6 +55,32 @@ internal ILGeneratorImpl(MethodBuilderImpl methodBuilder, int size) internal Scope Scope => _scope; internal Dictionary> DocumentToSequencePoints => _documentToSequencePoints; + internal void AddExceptionBlocks() + { + foreach(ExceptionHandlerInfo eb in _exceptionBlocks) + { + switch (eb.Kind) + { + case ExceptionRegionKind.Catch: + _cfBuilder.AddCatchRegion(GetMetaLabel(eb.TryStart), GetMetaLabel(eb.TryEnd), + GetMetaLabel(eb.HandlerStart), GetMetaLabel(eb.HandlerEnd), _moduleBuilder.GetTypeHandle(eb.ExceptionType!)); + break; + case ExceptionRegionKind.Filter: + _cfBuilder.AddFilterRegion(GetMetaLabel(eb.TryStart), GetMetaLabel(eb.TryEnd), + GetMetaLabel(eb.HandlerStart), GetMetaLabel(eb.HandlerEnd), GetMetaLabel(eb.FilterStart)); + break; + case ExceptionRegionKind.Fault: + _cfBuilder.AddFaultRegion(GetMetaLabel(eb.TryStart), GetMetaLabel(eb.TryEnd), + GetMetaLabel(eb.HandlerStart), GetMetaLabel(eb.HandlerEnd)); + break; + case ExceptionRegionKind.Finally: + _cfBuilder.AddFinallyRegion(GetMetaLabel(eb.TryStart), GetMetaLabel(eb.TryEnd), + GetMetaLabel(eb.HandlerStart), GetMetaLabel(eb.HandlerEnd)); + break; + } + } + } + public override int ILOffset => _il.Offset; public override void BeginCatchBlock(Type? exceptionType) @@ -91,8 +118,8 @@ public override void BeginCatchBlock(Type? exceptionType) currentExBlock.HandleStart = DefineLabel(); currentExBlock.HandleEnd = DefineLabel(); - _cfBuilder.AddCatchRegion(GetMetaLabel(currentExBlock.TryStart), GetMetaLabel(currentExBlock.TryEnd), - GetMetaLabel(currentExBlock.HandleStart), GetMetaLabel(currentExBlock.HandleEnd), _moduleBuilder.GetTypeHandle(exceptionType)); + _exceptionBlocks.Add(new ExceptionHandlerInfo(ExceptionRegionKind.Catch, currentExBlock.TryStart, + currentExBlock.TryEnd, currentExBlock.HandleStart, currentExBlock.HandleEnd, default, exceptionType)); MarkLabel(currentExBlock.HandleStart); } @@ -124,9 +151,9 @@ public override void BeginExceptFilterBlock() currentExBlock.FilterStart = DefineLabel(); currentExBlock.HandleStart = DefineLabel(); currentExBlock.HandleEnd = DefineLabel(); - _cfBuilder.AddFilterRegion(GetMetaLabel(currentExBlock.TryStart), GetMetaLabel(currentExBlock.TryEnd), - GetMetaLabel(currentExBlock.HandleStart), GetMetaLabel(currentExBlock.HandleEnd), GetMetaLabel(currentExBlock.FilterStart)); currentExBlock.State = ExceptionState.Filter; + _exceptionBlocks.Add(new ExceptionHandlerInfo(ExceptionRegionKind.Filter, currentExBlock.TryStart, + currentExBlock.TryEnd, currentExBlock.HandleStart, currentExBlock.HandleEnd, currentExBlock.FilterStart)); MarkLabel(currentExBlock.FilterStart); // Stack depth for "filter" starts at one. _currentStackDepth = 1; @@ -166,8 +193,8 @@ public override void BeginFaultBlock() currentExBlock.HandleStart = DefineLabel(); currentExBlock.HandleEnd = DefineLabel(); - _cfBuilder.AddFaultRegion(GetMetaLabel(currentExBlock.TryStart), GetMetaLabel(currentExBlock.TryEnd), - GetMetaLabel(currentExBlock.HandleStart), GetMetaLabel(currentExBlock.HandleEnd)); + _exceptionBlocks.Add(new ExceptionHandlerInfo(ExceptionRegionKind.Fault, currentExBlock.TryStart, + currentExBlock.TryEnd, currentExBlock.HandleStart, currentExBlock.HandleEnd)); currentExBlock.State = ExceptionState.Fault; MarkLabel(currentExBlock.HandleStart); // Stack depth for "fault" starts at zero. @@ -197,8 +224,8 @@ public override void BeginFinallyBlock() MarkLabel(currentExBlock.TryEnd); currentExBlock.HandleStart = DefineLabel(); currentExBlock.HandleEnd = finallyEndLabel; - _cfBuilder.AddFinallyRegion(GetMetaLabel(currentExBlock.TryStart), GetMetaLabel(currentExBlock.TryEnd), - GetMetaLabel(currentExBlock.HandleStart), GetMetaLabel(currentExBlock.HandleEnd)); + _exceptionBlocks.Add(new ExceptionHandlerInfo(ExceptionRegionKind.Finally, currentExBlock.TryStart, + currentExBlock.TryEnd, currentExBlock.HandleStart, currentExBlock.HandleEnd)); currentExBlock.State = ExceptionState.Finally; MarkLabel(currentExBlock.HandleStart); // Stack depth for "finally" starts at zero. @@ -601,7 +628,7 @@ public override void EmitCall(OpCode opcode, MethodInfo methodInfo, Type[]? opti } EmitOpcode(opcode); - UpdateStackSize(GetStackChange(opcode, methodInfo, optionalParameterTypes)); + UpdateStackSize(GetStackChange(opcode, methodInfo, _moduleBuilder.GetTypeFromCoreAssembly(CoreTypeId.Void), optionalParameterTypes)); if (optionalParameterTypes == null || optionalParameterTypes.Length == 0) { WriteOrReserveToken(_moduleBuilder.TryGetMethodHandle(methodInfo), methodInfo); @@ -613,12 +640,12 @@ public override void EmitCall(OpCode opcode, MethodInfo methodInfo, Type[]? opti } } - private static int GetStackChange(OpCode opcode, MethodInfo methodInfo, Type[]? optionalParameterTypes) + private static int GetStackChange(OpCode opcode, MethodInfo methodInfo, Type voidType, Type[]? optionalParameterTypes) { int stackChange = 0; // Push the return value if there is one. - if (methodInfo.ReturnType != typeof(void)) + if (methodInfo.ReturnType != voidType) { stackChange++; } @@ -665,7 +692,7 @@ public override void EmitCalli(OpCode opcode, CallingConventions callingConventi } } - int stackChange = GetStackChange(returnType, parameterTypes); + int stackChange = GetStackChange(returnType, _moduleBuilder.GetTypeFromCoreAssembly(CoreTypeId.Void), parameterTypes); // Pop off VarArg arguments. if (optionalParameterTypes != null) @@ -685,17 +712,17 @@ public override void EmitCalli(OpCode opcode, CallingConventions callingConventi public override void EmitCalli(OpCode opcode, CallingConvention unmanagedCallConv, Type? returnType, Type[]? parameterTypes) { - int stackChange = GetStackChange(returnType, parameterTypes); + int stackChange = GetStackChange(returnType, _moduleBuilder.GetTypeFromCoreAssembly(CoreTypeId.Void), parameterTypes); UpdateStackSize(stackChange); Emit(OpCodes.Calli); _il.Token(_moduleBuilder.GetSignatureToken(unmanagedCallConv, returnType, parameterTypes)); } - private static int GetStackChange(Type? returnType, Type[]? parameterTypes) + private static int GetStackChange(Type? returnType, Type voidType, Type[]? parameterTypes) { int stackChange = 0; // If there is a non-void return type, push one. - if (returnType != typeof(void)) + if (returnType != voidType) { stackChange++; } @@ -835,6 +862,31 @@ internal sealed class ExceptionBlock public ExceptionState State; } + internal struct ExceptionHandlerInfo + { + public readonly ExceptionRegionKind Kind; + public readonly Label TryStart, TryEnd, HandlerStart, HandlerEnd, FilterStart; + public Type? ExceptionType; + + public ExceptionHandlerInfo( + ExceptionRegionKind kind, + Label tryStart, + Label tryEnd, + Label handlerStart, + Label handlerEnd, + Label filterStart = default, + Type? catchType = null) + { + Kind = kind; + TryStart = tryStart; + TryEnd = tryEnd; + HandlerStart = handlerStart; + HandlerEnd = handlerEnd; + FilterStart = filterStart; + ExceptionType = catchType; + } + } + internal enum ExceptionState { Undefined, diff --git a/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/ModuleBuilderImpl.cs b/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/ModuleBuilderImpl.cs index a8685230ad4..5d242a710ae 100644 --- a/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/ModuleBuilderImpl.cs +++ b/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/ModuleBuilderImpl.cs @@ -357,6 +357,7 @@ private void WriteMethods(List methods, List method is ArrayMethod arrayMethod && - arrayMethod.DeclaringType!.GetElementType() is TypeBuilderImpl; + private bool IsArrayMethodTypeIsTypeBuilder(MethodInfo method) => method is ArrayMethod arrayMethod && + arrayMethod.DeclaringType!.GetElementType() is TypeBuilderImpl tb && Equals(tb.Module); - private static bool IsConstructedFromMethodBuilderOrTypeBuilder(MethodInfo method) => method.IsConstructedGenericMethod && - (method.GetGenericMethodDefinition() is MethodBuilderImpl || ContainsTypeBuilder(method.GetGenericArguments())); + private bool IsConstructedFromMethodBuilderOrTypeBuilder(MethodInfo method) => method.IsConstructedGenericMethod && + ((method.GetGenericMethodDefinition() is MethodBuilderImpl mb && Equals(mb.Module)) || ContainsTypeBuilder(method.GetGenericArguments())); internal EntityHandle TryGetMethodHandle(MethodInfo method, Type[] optionalParameterTypes) { @@ -1193,7 +1195,7 @@ internal EntityHandle TryGetMethodHandle(MethodInfo method, Type[] optionalParam throw new InvalidOperationException(SR.InvalidOperation_NotAVarArgCallingConvention); } - if (method is MethodBuilderImpl mb) + if (method is MethodBuilderImpl mb && Equals(mb.Module)) { return mb._handle; } diff --git a/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/ParameterBuilderImpl.cs b/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/ParameterBuilderImpl.cs index 93040c155f2..f1b6446be8e 100644 --- a/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/ParameterBuilderImpl.cs +++ b/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/ParameterBuilderImpl.cs @@ -32,8 +32,6 @@ public ParameterBuilderImpl(MethodBuilderImpl methodBuilder, int sequence, Param public override void SetConstant(object? defaultValue) { - Type parameterType = _position == 0 ? _methodBuilder.ReturnType : _methodBuilder.ParameterTypes![_position - 1]; - FieldBuilderImpl.ValidateDefaultValueType(defaultValue, parameterType); _defaultValue = defaultValue; _attributes |= ParameterAttributes.HasDefault; } diff --git a/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/PropertyBuilderImpl.cs b/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/PropertyBuilderImpl.cs index 68cc5a81345..faf1538a1a8 100644 --- a/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/PropertyBuilderImpl.cs +++ b/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/PropertyBuilderImpl.cs @@ -57,7 +57,6 @@ protected override void AddOtherMethodCore(MethodBuilder mdBuilder) protected override void SetConstantCore(object? defaultValue) { _containingType.ThrowIfCreated(); - FieldBuilderImpl.ValidateDefaultValueType(defaultValue, _propertyType); _defaultValue = defaultValue; } diff --git a/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/TypeBuilderImpl.cs b/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/TypeBuilderImpl.cs index c4480d7cee5..469b229b20d 100644 --- a/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/TypeBuilderImpl.cs +++ b/src/libraries/System.Reflection.Emit/src/System/Reflection/Emit/TypeBuilderImpl.cs @@ -212,7 +212,7 @@ private ConstructorBuilderImpl DefineDefaultConstructorInternal(MethodAttributes // Get the parent class's default constructor and add it to the IL ConstructorInfo? con; if (_typeParent!.IsConstructedGenericType && - (_typeParent.GetGenericTypeDefinition() is TypeBuilderImpl || ModuleBuilderImpl.ContainsTypeBuilder(_typeParent.GetGenericArguments()))) + (_typeParent.GetGenericTypeDefinition() is TypeBuilderImpl || _module.ContainsTypeBuilder(_typeParent.GetGenericArguments()))) { // When TypeBuilder involved need to construct the parent constructor using TypeBuilder.GetConstructor() static method con = GetConstructor(_typeParent, _typeParent.GetGenericTypeDefinition().GetConstructor( @@ -305,7 +305,6 @@ protected override MethodBuilder DefineMethodCore(string name, MethodAttributes { ThrowIfCreated(); - MethodBuilderImpl methodBuilder = new(name, attributes, callingConvention, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers, _module, this); _methodDefinitions.Add(methodBuilder); @@ -616,23 +615,22 @@ public override Type GetGenericTypeDefinition() public override string? Namespace => _namespace; public override Assembly Assembly => _module.Assembly; public override Module Module => _module; - public override Type UnderlyingSystemType + public override Type UnderlyingSystemType => this; + + public override Type GetEnumUnderlyingType() { - get + if (IsEnum) { - if (IsEnum) - { - if (_enumUnderlyingType == null) - { - throw new InvalidOperationException(SR.InvalidOperation_NoUnderlyingTypeOnEnum); - } - - return _enumUnderlyingType; - } - else + if (_enumUnderlyingType == null) { - return this; + throw new InvalidOperationException(SR.InvalidOperation_NoUnderlyingTypeOnEnum); } + + return _enumUnderlyingType; + } + else + { + throw new ArgumentException(SR.Argument_MustBeEnum); } } public override bool IsSZArray => false; diff --git a/src/libraries/System.Reflection.Emit/tests/PersistedAssemblyBuilder/AssemblySaveEnumBuilderTests.cs b/src/libraries/System.Reflection.Emit/tests/PersistedAssemblyBuilder/AssemblySaveEnumBuilderTests.cs index 3c569b815da..b1012667556 100644 --- a/src/libraries/System.Reflection.Emit/tests/PersistedAssemblyBuilder/AssemblySaveEnumBuilderTests.cs +++ b/src/libraries/System.Reflection.Emit/tests/PersistedAssemblyBuilder/AssemblySaveEnumBuilderTests.cs @@ -37,7 +37,7 @@ public static IEnumerable DefineLiteral_TestData() yield return new object[] { typeof(uint), (uint)1 }; yield return new object[] { typeof(int), 0 }; - yield return new object[] { typeof(int), 1 }; + yield return new object[] { typeof(int), Test.Second }; yield return new object[] { typeof(ulong), (ulong)0 }; yield return new object[] { typeof(ulong), (ulong)1 }; @@ -100,7 +100,7 @@ public void CreateEnumWithMlc() PersistedAssemblyBuilder ab = new PersistedAssemblyBuilder(PopulateAssemblyName(), mlc.CoreAssembly); ModuleBuilder mb = ab.DefineDynamicModule("My Module"); Type intType = mlc.CoreAssembly.GetType("System.Int32"); - EnumBuilder enumBuilder = mb.DefineEnum("TestEnum", TypeAttributes.Public, typeof(int)); + EnumBuilder enumBuilder = mb.DefineEnum("TestEnum", TypeAttributes.Public, intType); FieldBuilder field = enumBuilder.DefineLiteral("Default", 0); enumBuilder.CreateTypeInfo(); @@ -118,7 +118,7 @@ public void CreateEnumWithMlc() FieldInfo testField = createdEnum.GetField("Default"); Assert.Equal(createdEnum, testField.FieldType); - Assert.Equal(typeof(int), enumBuilder.GetEnumUnderlyingType()); + Assert.Equal(intType, enumBuilder.GetEnumUnderlyingType()); Assert.Equal(FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.Literal | FieldAttributes.HasDefault, testField.Attributes); } } diff --git a/src/libraries/System.Reflection.Emit/tests/PersistedAssemblyBuilder/AssemblySaveILGeneratorTests.cs b/src/libraries/System.Reflection.Emit/tests/PersistedAssemblyBuilder/AssemblySaveILGeneratorTests.cs index f912fee6082..2b155556c5f 100644 --- a/src/libraries/System.Reflection.Emit/tests/PersistedAssemblyBuilder/AssemblySaveILGeneratorTests.cs +++ b/src/libraries/System.Reflection.Emit/tests/PersistedAssemblyBuilder/AssemblySaveILGeneratorTests.cs @@ -643,7 +643,7 @@ void Main(int a) ILGenerator il = methodMultiply.GetILGenerator(); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldfld, field); - il.Emit(OpCodes.Ldarg_1); + il.Emit(OpCodes.Ldarg_1); il.Emit(OpCodes.Mul); il.Emit(OpCodes.Ret); @@ -1076,6 +1076,157 @@ public void SimpleTryCatchBlock() } } + [Fact] + public void TryCatchWithTypeBuilderException() + { + using (TempFile file = TempFile.Create()) + { + PersistedAssemblyBuilder ab = new PersistedAssemblyBuilder(new AssemblyName("MyAssembly"), typeof(object).Assembly); + ModuleBuilder mb = ab.DefineDynamicModule("MyModule"); + TypeBuilder tb = mb.DefineType("MyType", TypeAttributes.Public); + TypeBuilder exceptionType = mb.DefineType("MyException", TypeAttributes.Public, typeof(Exception)); + MethodBuilder method = tb.DefineMethod("Method", MethodAttributes.Public | MethodAttributes.Static, typeof(int), [typeof(int), typeof(int)]); + ILGenerator ilGenerator = method.GetILGenerator(); + ilGenerator.BeginExceptionBlock(); + ilGenerator.Emit(OpCodes.Ldarg_0); + ilGenerator.Emit(OpCodes.Ldarg_1); + ilGenerator.Emit(OpCodes.Add); + ilGenerator.BeginCatchBlock(exceptionType); + ilGenerator.Emit(OpCodes.Ldc_I4_0); + ilGenerator.EndExceptionBlock(); + ilGenerator.Emit(OpCodes.Ret); + tb.CreateType(); + exceptionType.CreateType(); + ab.Save(file.Path); + + using (MetadataLoadContext mlc = new MetadataLoadContext(new CoreMetadataAssemblyResolver())) + { + Assembly assemblyFromDisk = mlc.LoadFromAssemblyPath(file.Path); + Type typeFromDisk = assemblyFromDisk.Modules.First().GetType("MyType"); + MethodBody body = typeFromDisk.GetMethod("Method").GetMethodBody(); + Assert.Equal(1, body.ExceptionHandlingClauses.Count); + Assert.Equal("MyException", body.ExceptionHandlingClauses[0].CatchType.FullName); + Assert.Equal(ExceptionHandlingClauseOptions.Clause, body.ExceptionHandlingClauses[0].Flags); + } + } + } + + [Fact] + public void TryMultipleCatchFinallyBlocks() + { + using (TempFile file = TempFile.Create()) + { + PersistedAssemblyBuilder ab = AssemblySaveTools.PopulateAssemblyBuilderAndTypeBuilder(out TypeBuilder tb); + MethodBuilder method = tb.DefineMethod("Method", MethodAttributes.Public | MethodAttributes.Static, typeof(int), [typeof(int), typeof(int)]); + FieldBuilder fb = tb.DefineField("Field", typeof(int), FieldAttributes.Public | FieldAttributes.Static); + Type dBZException = typeof(DivideByZeroException); + TypeBuilder myExceptionType = ab.GetDynamicModule("MyModule").DefineType("MyException", TypeAttributes.Public, typeof(Exception)); + myExceptionType.CreateType(); + Type exception = typeof(Exception); + Type overflowException = typeof(OverflowException); + ILGenerator ilGenerator = method.GetILGenerator(); + LocalBuilder local = ilGenerator.DeclareLocal(typeof(int)); + Label exBlock = ilGenerator.BeginExceptionBlock(); + Label check100 = ilGenerator.DefineLabel(); + Label leave = ilGenerator.DefineLabel(); + ilGenerator.Emit(OpCodes.Ldarg_0); + ilGenerator.Emit(OpCodes.Ldarg_1); + ilGenerator.Emit(OpCodes.Div); + ilGenerator.Emit(OpCodes.Stloc_0); + ilGenerator.Emit(OpCodes.Ldloc_0); + ilGenerator.Emit(OpCodes.Brtrue, check100); + ilGenerator.ThrowException(myExceptionType); + ilGenerator.MarkLabel(check100); + ilGenerator.Emit(OpCodes.Ldarg_1); + ilGenerator.Emit(OpCodes.Ldc_I4, 100); + ilGenerator.Emit(OpCodes.Bne_Un, leave); + ilGenerator.ThrowException(overflowException); + ilGenerator.MarkLabel(leave); + ilGenerator.BeginCatchBlock(dBZException); + ilGenerator.EmitWriteLine("Error: division by zero"); + ilGenerator.Emit(OpCodes.Ldc_I4_M1); + ilGenerator.Emit(OpCodes.Stloc_0); + ilGenerator.BeginCatchBlock(myExceptionType); + ilGenerator.EmitWriteLine("Error: MyException"); + ilGenerator.Emit(OpCodes.Ldc_I4_S, 2); + ilGenerator.Emit(OpCodes.Stloc_0); + ilGenerator.BeginCatchBlock(exception); + ilGenerator.EmitWriteLine("Error: generic Exception"); + ilGenerator.Emit(OpCodes.Ldc_I4_S, 3); + ilGenerator.Emit(OpCodes.Stloc_0); + ilGenerator.BeginFinallyBlock(); + ilGenerator.EmitWriteLine("Finally block"); + ilGenerator.Emit(OpCodes.Ldc_I4_S, 30); + ilGenerator.Emit(OpCodes.Stsfld, fb); + ilGenerator.EndExceptionBlock(); + ilGenerator.Emit(OpCodes.Ldloc_0); + ilGenerator.Emit(OpCodes.Ret); + tb.CreateType(); + ab.Save(file.Path); + + TestAssemblyLoadContext tlc = new TestAssemblyLoadContext(); + Assembly assemblyFromDisk = tlc.LoadFromAssemblyPath(file.Path); + Type typeFromDisk = assemblyFromDisk.GetType("MyType"); + MethodInfo methodFromDisk = typeFromDisk.GetMethod("Method"); + MethodBody body = methodFromDisk.GetMethodBody(); + Assert.Equal(4, body.ExceptionHandlingClauses.Count); + Assert.Equal(ExceptionHandlingClauseOptions.Clause, body.ExceptionHandlingClauses[0].Flags); + Assert.Equal(ExceptionHandlingClauseOptions.Clause, body.ExceptionHandlingClauses[1].Flags); + Assert.Equal(ExceptionHandlingClauseOptions.Clause, body.ExceptionHandlingClauses[2].Flags); + Assert.Equal(ExceptionHandlingClauseOptions.Finally, body.ExceptionHandlingClauses[3].Flags); + Assert.Equal(dBZException.FullName, body.ExceptionHandlingClauses[0].CatchType.FullName); + Assert.Equal("MyException", body.ExceptionHandlingClauses[1].CatchType.FullName); + Assert.Equal(exception.FullName, body.ExceptionHandlingClauses[2].CatchType.FullName); +/* +public class MyException : Exception { } + +public class MyType +{ + public static int Field; + public static int Method(int a, int b) + { + int res; + try{ + res = a/b; + if (res == 0) + throw new MyException(); + if (b == 100) + throw new OverflowException(); + } + catch(DivideByZeroException) + { + Console.WriteLine("Divide by zero caught"); + res = -1; + } + catch(MyException) + { + Console.WriteLine("MyException caught"); + res = 2; + } + catch(Exception) + { + Console.WriteLine("Divide by zero!"); + res = 3; + } + finally + { + Console.WriteLine("Finally block"); + Field = 30; + } + return res; + } +}*/ + FieldInfo field = typeFromDisk.GetField("Field"); + Assert.Equal(0, field.GetValue(null)); + Assert.Equal(5, methodFromDisk.Invoke(null, new object[] { 50, 10 })); + Assert.Equal(30, field.GetValue(null)); + Assert.Equal(-1, methodFromDisk.Invoke(null, new object[] { 1, 0 })); + Assert.Equal(2, methodFromDisk.Invoke(null, new object[] { 0, 1 })); + Assert.Equal(3, methodFromDisk.Invoke(null, new object[] { 1000, 100 })); + tlc.Unload(); + } + } + [Fact] public void TryMultipleCatchBlocks() { @@ -2757,5 +2908,141 @@ public void ExplicitFieldOffsetSavesAndLoads() var assembly = AssemblyLoadContext.Default.LoadFromStream(stream); var method = assembly.GetType("ExplicitLayoutType")!; } + + [Fact] + public void ReferenceMemberInOtherGeneratedAssembly() + { + using (TempFile file = TempFile.Create()) + using (TempFile file2 = TempFile.Create()) + { + PersistedAssemblyBuilder ab1 = new PersistedAssemblyBuilder(new AssemblyName("MyAssembly1"), typeof(object).Assembly); + ModuleBuilder mb1 = ab1.DefineDynamicModule("Module1"); + TypeBuilder type1 = mb1.DefineType("Type1", TypeAttributes.Public); + MethodBuilder method = type1.DefineMethod("TestMethod", MethodAttributes.Public | MethodAttributes.Static, typeof(int), Type.EmptyTypes); + + ILGenerator ilGenerator = method.GetILGenerator(); + int expectedReturn = 5; + ilGenerator.Emit(OpCodes.Ldc_I4, expectedReturn); + ilGenerator.Emit(OpCodes.Ret); + type1.CreateType(); + ab1.Save(file.Path); + + PersistedAssemblyBuilder ab2 = new PersistedAssemblyBuilder(new AssemblyName("MyAssembly2"), typeof(object).Assembly); + ModuleBuilder mb2 = ab2.DefineDynamicModule("Module2"); + TypeBuilder type2 = mb2.DefineType("Type2", TypeAttributes.Public); + MethodBuilder method2 = type2.DefineMethod("TestMethod2", MethodAttributes.Public | MethodAttributes.Static, typeof(int), Type.EmptyTypes); + + ILGenerator ilGenerator2 = method2.GetILGenerator(); + ilGenerator2.Emit(OpCodes.Call, method); + ilGenerator2.Emit(OpCodes.Ret); + type2.CreateType(); + ab2.Save(file2.Path); + + TestAssemblyLoadContext tlc = new TestAssemblyLoadContext(); + tlc.LoadFromAssemblyPath(file.Path); + Type typeFromDisk = tlc.LoadFromAssemblyPath(file2.Path).GetType("Type2"); + MethodInfo methodFromDisk = typeFromDisk.GetMethod("TestMethod2")!; + Assert.Equal(expectedReturn, methodFromDisk.Invoke(null, null)); + tlc.Unload(); + } + } + + [Fact] + public void CrossReferenceGeneratedAssemblyMembers() + { + using (TempFile file = TempFile.Create()) + using (TempFile file2 = TempFile.Create()) + { + PersistedAssemblyBuilder ab1 = new PersistedAssemblyBuilder(new AssemblyName("MyAssembly1"), typeof(object).Assembly); + ModuleBuilder mb1 = ab1.DefineDynamicModule("Module1"); + TypeBuilder type1 = mb1.DefineType("Type1", TypeAttributes.Public); + MethodBuilder method = type1.DefineMethod("TestMethod", MethodAttributes.Public | MethodAttributes.Static, typeof(int), Type.EmptyTypes); + int expectedReturn = 5; + + PersistedAssemblyBuilder ab2 = new PersistedAssemblyBuilder(new AssemblyName("MyAssembly2"), typeof(object).Assembly); + ModuleBuilder mb2 = ab2.DefineDynamicModule("Module2"); + TypeBuilder type2 = mb2.DefineType("Type2", TypeAttributes.Public); + MethodBuilder method2 = type2.DefineMethod("TestMethod2", MethodAttributes.Public | MethodAttributes.Static, typeof(int), Type.EmptyTypes); + FieldBuilder field = type2.DefineField("Field2", typeof(int), FieldAttributes.Public | FieldAttributes.Static); + ILGenerator staticCtorIL = type2.DefineTypeInitializer().GetILGenerator(); + staticCtorIL.Emit(OpCodes.Ldc_I4, expectedReturn); + staticCtorIL.Emit(OpCodes.Stsfld, field); + staticCtorIL.Emit(OpCodes.Ret); + ILGenerator ilGenerator2 = method2.GetILGenerator(); + ilGenerator2.Emit(OpCodes.Call, method); + ilGenerator2.Emit(OpCodes.Ret); + type2.CreateType(); + + ILGenerator ilGenerator = method.GetILGenerator(); + ilGenerator.Emit(OpCodes.Ldsfld, field); + ilGenerator.Emit(OpCodes.Ret); + type1.CreateType(); + + ab1.Save(file.Path); + ab2.Save(file2.Path); + + TestAssemblyLoadContext tlc = new TestAssemblyLoadContext(); + tlc.LoadFromAssemblyPath(file.Path); + Type typeFromDisk = tlc.LoadFromAssemblyPath(file2.Path).GetType("Type2"); + MethodInfo methodFromDisk = typeFromDisk.GetMethod("TestMethod2")!; + Assert.Equal(expectedReturn, methodFromDisk.Invoke(null, null)); + tlc.Unload(); + } + } + + [Fact] + public void ReferenceGenericMembersInOtherGeneratedAssembly() + { + using (TempFile file = TempFile.Create()) + using (TempFile file2 = TempFile.Create()) + { + PersistedAssemblyBuilder ab = AssemblySaveTools.PopulateAssemblyBuilderAndTypeBuilder(out TypeBuilder type); + GenericTypeParameterBuilder[] typeParams = type.DefineGenericParameters(["T"]); + ConstructorBuilder ctor = type.DefineDefaultConstructor(MethodAttributes.PrivateScope | MethodAttributes.Public | + MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName); + FieldBuilder myField = type.DefineField("Field", typeParams[0], FieldAttributes.Public); + MethodBuilder genericMethod = type.DefineMethod("GM", MethodAttributes.Public | MethodAttributes.Static); + GenericTypeParameterBuilder[] methodParams = genericMethod.DefineGenericParameters("U"); + genericMethod.SetSignature(methodParams[0], null, null, new[] { methodParams[0] }, null, null); + + ILGenerator ilg = genericMethod.GetILGenerator(); + Type SampleOfU = type.MakeGenericType(methodParams[0]); + ConstructorInfo ctorOfU = TypeBuilder.GetConstructor(SampleOfU, ctor); + ilg.Emit(OpCodes.Newobj, ctorOfU); + ilg.Emit(OpCodes.Dup); + ilg.Emit(OpCodes.Ldarg_0); + FieldInfo FieldOfU = TypeBuilder.GetField(SampleOfU, myField); + ilg.Emit(OpCodes.Stfld, FieldOfU); + ilg.Emit(OpCodes.Dup); + ilg.Emit(OpCodes.Ldfld, FieldOfU); + ilg.Emit(OpCodes.Box, methodParams[0]); + MethodInfo writeLineObj = typeof(Console).GetMethod("WriteLine", [typeof(object)]); + ilg.EmitCall(OpCodes.Call, writeLineObj, null); + ilg.Emit(OpCodes.Ldfld, FieldOfU); + ilg.Emit(OpCodes.Ret); + type.CreateType(); + ab.Save(file.Path); + + PersistedAssemblyBuilder ab2 = new PersistedAssemblyBuilder(new AssemblyName("MyAssembly2"), typeof(object).Assembly); + TypeBuilder type2 = ab2.DefineDynamicModule("MyModule2").DefineType("Type2", TypeAttributes.Class | TypeAttributes.Public); + MethodBuilder method2 = type2.DefineMethod("Method2", MethodAttributes.Public | MethodAttributes.Static, typeof(string), Type.EmptyTypes); + ilg = method2.GetILGenerator(); + Type SampleOfInt = type.MakeGenericType(typeof(string)); + MethodInfo SampleOfIntGM = TypeBuilder.GetMethod(SampleOfInt, genericMethod); + MethodInfo GMOfString = SampleOfIntGM.MakeGenericMethod(typeof(string)); + ilg.Emit(OpCodes.Ldstr, "Hello, world!"); + ilg.EmitCall(OpCodes.Call, GMOfString, null); + ilg.Emit(OpCodes.Ret); + type2.CreateType(); + ab2.Save(file2.Path); + + TestAssemblyLoadContext tlc = new TestAssemblyLoadContext(); + tlc.LoadFromAssemblyPath(file.Path); + Type typeFromDisk = tlc.LoadFromAssemblyPath(file2.Path).GetType("Type2"); + MethodInfo methodFromDisk = typeFromDisk.GetMethod("Method2")!; + Assert.Equal("Hello, world!", methodFromDisk.Invoke(null, null)); + tlc.Unload(); + } + } } } diff --git a/src/libraries/System.Reflection.Emit/tests/PersistedAssemblyBuilder/AssemblySavePropertyBuilderTests.cs b/src/libraries/System.Reflection.Emit/tests/PersistedAssemblyBuilder/AssemblySavePropertyBuilderTests.cs index 06caf8dbb6a..a8cd0754c85 100644 --- a/src/libraries/System.Reflection.Emit/tests/PersistedAssemblyBuilder/AssemblySavePropertyBuilderTests.cs +++ b/src/libraries/System.Reflection.Emit/tests/PersistedAssemblyBuilder/AssemblySavePropertyBuilderTests.cs @@ -163,6 +163,24 @@ public void SetConstantVariousValues(Type returnType, object defaultValue) Assert.Equal(defaultValue, property.GetConstantValue()); } + [Theory] + [MemberData(nameof(SetConstant_TestData))] + public void SetConstantVariousValuesMlcCoreAssembly(Type returnType, object defaultValue) + { + using (MetadataLoadContext mlc = new MetadataLoadContext(new CoreMetadataAssemblyResolver())) + { + PersistedAssemblyBuilder ab = new PersistedAssemblyBuilder(new AssemblyName("MyDynamicAssembly"), mlc.CoreAssembly); + ModuleBuilder mb = ab.DefineDynamicModule("My Module"); + Type returnTypeFromCore = returnType != typeof(PropertyBuilderTest11.Colors) ? mlc.CoreAssembly.GetType(returnType.FullName, true) : returnType; + TypeBuilder type = mb.DefineType("MyType", TypeAttributes.Public); + + PropertyBuilder property = type.DefineProperty("TestProperty", PropertyAttributes.HasDefault, returnTypeFromCore, null); + property.SetConstant(defaultValue); + + Assert.Equal(defaultValue, property.GetConstantValue()); + } + } + [Fact] public void SetCustomAttribute_ConstructorInfo_ByteArray_NullConstructorInfo_ThrowsArgumentNullException() { @@ -194,7 +212,6 @@ public void Set_WhenTypeAlreadyCreated_ThrowsInvalidOperationException() MethodAttributes getMethodAttributes = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig; MethodBuilder method = type.DefineMethod("TestMethod", getMethodAttributes, typeof(int), null); method.GetILGenerator().Emit(OpCodes.Ret); - AssertExtensions.Throws(() => property.SetConstant((decimal)10)); CustomAttributeBuilder customAttrBuilder = new CustomAttributeBuilder(typeof(IntPropertyAttribute).GetConstructor([typeof(int)]), [10]); type.CreateType(); @@ -204,18 +221,5 @@ public void Set_WhenTypeAlreadyCreated_ThrowsInvalidOperationException() Assert.Throws(() => property.SetConstant(1)); Assert.Throws(() => property.SetCustomAttribute(customAttrBuilder)); } - - [Fact] - public void SetConstant_ValidationThrows() - { - AssemblySaveTools.PopulateAssemblyBuilderAndTypeBuilder(out TypeBuilder type); - FieldBuilder field = type.DefineField("TestField", typeof(int), FieldAttributes.Private); - PropertyBuilder property = type.DefineProperty("TestProperty", PropertyAttributes.HasDefault, typeof(int), null); - - AssertExtensions.Throws(() => property.SetConstant((decimal)10)); - AssertExtensions.Throws(() => property.SetConstant(null)); - type.CreateType(); - Assert.Throws(() => property.SetConstant(1)); - } } } diff --git a/src/libraries/System.Reflection.Metadata/System.Reflection.Metadata.sln b/src/libraries/System.Reflection.Metadata/System.Reflection.Metadata.sln index 9a365da411e..f05ab50d157 100644 --- a/src/libraries/System.Reflection.Metadata/System.Reflection.Metadata.sln +++ b/src/libraries/System.Reflection.Metadata/System.Reflection.Metadata.sln @@ -15,6 +15,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.Metadata. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{D4293B41-CA47-46DB-8E11-C532E8E8DAF1}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{9EE464AC-5B4A-470B-845F-FD9FA44269D8}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{1092AC3C-B01C-4AC4-9F05-6FDB23C699B3}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{930B1167-83BE-42CC-BFED-096CB2BA19F1}" @@ -85,6 +87,10 @@ Global {D4293B41-CA47-46DB-8E11-C532E8E8DAF1}.Debug|Any CPU.Build.0 = Debug|Any CPU {D4293B41-CA47-46DB-8E11-C532E8E8DAF1}.Release|Any CPU.ActiveCfg = Release|Any CPU {D4293B41-CA47-46DB-8E11-C532E8E8DAF1}.Release|Any CPU.Build.0 = Release|Any CPU + {9EE464AC-5B4A-470B-845F-FD9FA44269D8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {9EE464AC-5B4A-470B-845F-FD9FA44269D8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {9EE464AC-5B4A-470B-845F-FD9FA44269D8}.Release|Any CPU.ActiveCfg = Release|Any CPU + {9EE464AC-5B4A-470B-845F-FD9FA44269D8}.Release|Any CPU.Build.0 = Release|Any CPU {1092AC3C-B01C-4AC4-9F05-6FDB23C699B3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {1092AC3C-B01C-4AC4-9F05-6FDB23C699B3}.Debug|Any CPU.Build.0 = Debug|Any CPU {1092AC3C-B01C-4AC4-9F05-6FDB23C699B3}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -131,6 +137,7 @@ Global {A69B0EE0-BE0C-4D53-A16F-5465028D975D} = {19CD37AB-E6A2-431C-8893-5ED903B847BA} {B905521A-FE25-4D35-9929-B2622F590263} = {19CD37AB-E6A2-431C-8893-5ED903B847BA} {D4293B41-CA47-46DB-8E11-C532E8E8DAF1} = {FA7C2C03-A446-4807-A092-9A3ABD5E5FD7} + {9EE464AC-5B4A-470B-845F-FD9FA44269D8} = {FA7C2C03-A446-4807-A092-9A3ABD5E5FD7} {1092AC3C-B01C-4AC4-9F05-6FDB23C699B3} = {FA7C2C03-A446-4807-A092-9A3ABD5E5FD7} {930B1167-83BE-42CC-BFED-096CB2BA19F1} = {FA7C2C03-A446-4807-A092-9A3ABD5E5FD7} {8E173D5F-6011-4471-8514-FF9C7D4417B5} = {F42F22BE-FD44-4242-9E0F-A243EB763BF4} diff --git a/src/libraries/System.Reflection.Metadata/ref/System.Reflection.Metadata.cs b/src/libraries/System.Reflection.Metadata/ref/System.Reflection.Metadata.cs index 367636078e2..5a36e098782 100644 --- a/src/libraries/System.Reflection.Metadata/ref/System.Reflection.Metadata.cs +++ b/src/libraries/System.Reflection.Metadata/ref/System.Reflection.Metadata.cs @@ -2445,6 +2445,12 @@ internal TypeName() { } public System.Reflection.Metadata.TypeName GetGenericTypeDefinition() { throw null; } public System.Reflection.Metadata.TypeName GetElementType() { throw null; } public int GetNodeCount() { throw null; } + public System.Reflection.Metadata.TypeName MakeSZArrayTypeName() { throw null; } + public System.Reflection.Metadata.TypeName MakeArrayTypeName(int rank) { throw null; } + public System.Reflection.Metadata.TypeName MakeByRefTypeName() { throw null; } + public System.Reflection.Metadata.TypeName MakeGenericTypeName(System.Collections.Immutable.ImmutableArray typeArguments) { throw null; } + public System.Reflection.Metadata.TypeName MakePointerTypeName() { throw null; } + public System.Reflection.Metadata.TypeName WithAssemblyName(AssemblyNameInfo? assemblyName) { throw null; } } public sealed partial class TypeNameParseOptions { diff --git a/src/libraries/System.Reflection.Metadata/src/Resources/Strings.resx b/src/libraries/System.Reflection.Metadata/src/Resources/Strings.resx index 963e4d0af9f..21bab756dd6 100644 --- a/src/libraries/System.Reflection.Metadata/src/Resources/Strings.resx +++ b/src/libraries/System.Reflection.Metadata/src/Resources/Strings.resx @@ -432,4 +432,7 @@ The given assembly name was invalid. + + '{0}' is not a simple TypeName. + \ No newline at end of file diff --git a/src/libraries/System.Reflection.Metadata/src/System.Reflection.Metadata.csproj b/src/libraries/System.Reflection.Metadata/src/System.Reflection.Metadata.csproj index 6c74a322902..caa954d459a 100644 --- a/src/libraries/System.Reflection.Metadata/src/System.Reflection.Metadata.csproj +++ b/src/libraries/System.Reflection.Metadata/src/System.Reflection.Metadata.csproj @@ -264,7 +264,7 @@ The System.Reflection.Metadata library is built-in as part of the shared framewo - + @@ -274,6 +274,7 @@ The System.Reflection.Metadata library is built-in as part of the shared framewo + diff --git a/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/AssemblyNameInfo.cs b/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/AssemblyNameInfo.cs index ddc61cd3644..3ac30c92db5 100644 --- a/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/AssemblyNameInfo.cs +++ b/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/AssemblyNameInfo.cs @@ -81,6 +81,10 @@ internal AssemblyNameInfo(AssemblyNameParser.AssemblyNameParts parts) /// /// Gets the name of the culture associated with the assembly. /// + /// + /// Do not create a instance from this string unless + /// you know the string has originated from a trustworthy source. + /// public string? CultureName { get; } /// @@ -131,6 +135,10 @@ public string FullName /// /// Initializes a new instance of the class based on the stored information. /// + /// + /// Do not create an instance with string unless + /// you know the string has originated from a trustworthy source. + /// public AssemblyName ToAssemblyName() { AssemblyName assemblyName = new(); @@ -193,7 +201,7 @@ public static AssemblyNameInfo Parse(ReadOnlySpan assemblyName) public static bool TryParse(ReadOnlySpan assemblyName, [NotNullWhen(true)] out AssemblyNameInfo? result) { AssemblyNameParser.AssemblyNameParts parts = default; - if (AssemblyNameParser.TryParse(assemblyName, ref parts)) + if (!assemblyName.IsEmpty && AssemblyNameParser.TryParse(assemblyName, ref parts)) { result = new(parts); return true; diff --git a/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/TypeName.cs b/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/TypeName.cs index 3f1ea839439..2b620761bb7 100644 --- a/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/TypeName.cs +++ b/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/TypeName.cs @@ -25,7 +25,7 @@ sealed class TypeName /// Positive value is array rank. /// Negative value is modifier encoded using constants defined in . /// - private readonly sbyte _rankOrModifier; + private readonly int _rankOrModifier; /// /// To avoid the need of allocating a string for all declaring types (example: A+B+C+D+E+F+G), /// length of the name is stored and the fullName passed in ctor represents the full name of the nested type. @@ -50,7 +50,7 @@ internal TypeName(string? fullName, #else ImmutableArray.Builder? genericTypeArguments = default, #endif - sbyte rankOrModifier = default, + int rankOrModifier = default, int nestedNameLength = -1) { _fullName = fullName; @@ -69,6 +69,25 @@ internal TypeName(string? fullName, #endif } +#if SYSTEM_REFLECTION_METADATA + private TypeName(string? fullName, + AssemblyNameInfo? assemblyName, + TypeName? elementOrGenericType, + TypeName? declaringType, + ImmutableArray genericTypeArguments, + int rankOrModifier = default, + int nestedNameLength = -1) + { + _fullName = fullName; + AssemblyName = assemblyName; + _elementOrGenericType = elementOrGenericType; + _declaringType = declaringType; + _genericArguments = genericTypeArguments; + _rankOrModifier = rankOrModifier; + _nestedNameLength = nestedNameLength; + } +#endif + /// /// The assembly-qualified name of the type; e.g., "System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089". /// @@ -76,7 +95,7 @@ internal TypeName(string? fullName, /// If returns null, simply returns . /// public string AssemblyQualifiedName - => _assemblyQualifiedName ??= AssemblyName is null ? FullName : $"{FullName}, {AssemblyName.FullName}"; + => _assemblyQualifiedName ??= AssemblyName is null ? FullName : $"{FullName}, {AssemblyName.FullName}"; // see recursion comments in FullName /// /// Returns assembly name which contains this type, or null if this was not @@ -123,6 +142,17 @@ public string FullName { get { + // This is a recursive method over potentially hostile input. Protection against DoS is offered + // via the [Try]Parse method and TypeNameParserOptions.MaxNodes property at construction time. + // This FullName property getter and related methods assume that this TypeName instance has an + // acceptable node count. + // + // The node count controls the total amount of work performed by this method, including: + // - The max possible stack depth due to the recursive methods calls; and + // - The total number of bytes allocated by this function. For a deeply-nested TypeName + // object, the total allocation across the full object graph will be + // O(FullName.Length * GetNodeCount()). + if (_fullName is null) { if (IsConstructedGenericType) @@ -226,6 +256,8 @@ public string Name { get { + // Lookups to Name and FullName might be recursive. See comments in FullName property getter. + if (_name is null) { if (IsConstructedGenericType) @@ -282,24 +314,28 @@ public string Name /// public int GetNodeCount() { + // This method uses checked arithmetic to avoid silent overflows. + // It's impossible to parse a TypeName with NodeCount > int.MaxValue + // (TypeNameParseOptions.MaxNodes is an int), but it's possible + // to create such names with the Make* APIs. int result = 1; - if (IsNested) + if (IsArray || IsPointer || IsByRef) { - result += DeclaringType.GetNodeCount(); + result = checked(result + GetElementType().GetNodeCount()); } else if (IsConstructedGenericType) { - result++; - } - else if (IsArray || IsPointer || IsByRef) - { - result += GetElementType().GetNodeCount(); - } + result = checked(result + GetGenericTypeDefinition().GetNodeCount()); - foreach (TypeName genericArgument in GetGenericArguments()) + foreach (TypeName genericArgument in GetGenericArguments()) + { + result = checked(result + genericArgument.GetNodeCount()); + } + } + else if (IsNested) { - result += genericArgument.GetNodeCount(); + result = checked(result + DeclaringType.GetNodeCount()); } return result; @@ -392,5 +428,112 @@ public int GetArrayRank() #else ImmutableArray GetGenericArguments() => _genericArguments; #endif + +#if SYSTEM_REFLECTION_METADATA + /// + /// Creates a new object that represents current simple name with provided assembly name. + /// + /// Assembly name. + /// Created simple name. + /// The current type name is not simple. + public TypeName WithAssemblyName(AssemblyNameInfo? assemblyName) + { + // Recursive method. See comments in FullName property getter for more information + // on how this is protected against attack. + // + // n.b. AssemblyNameInfo could also be hostile. The typical exploit is that a single + // long AssemblyNameInfo is associated with one or more simple TypeName objects, + // leading to an alg. complexity attack (DoS). It's important that TypeName doesn't + // actually *do* anything with the provided AssemblyNameInfo rather than store it. + // For example, don't use it inside a string concat operation unless the caller + // explicitly requested that to happen. If the input is hostile, the caller should + // never perform such concats in a loop. + + if (!IsSimple) + { + TypeNameParserHelpers.ThrowInvalidOperation_NotSimpleName(FullName); + } + + TypeName? declaringType = IsNested + ? DeclaringType.WithAssemblyName(assemblyName) + : null; + + return new TypeName(fullName: _fullName, + assemblyName: assemblyName, + elementOrGenericType: null, + declaringType: declaringType, + genericTypeArguments: ImmutableArray.Empty, + nestedNameLength: _nestedNameLength); + } + + /// + /// Creates a object representing a one-dimensional array + /// of the current type, with a lower bound of zero. + /// + /// + /// A object representing a one-dimensional array + /// of the current type, with a lower bound of zero. + /// + public TypeName MakeSZArrayTypeName() => MakeElementTypeName(TypeNameParserHelpers.SZArray); + + /// + /// Creates a object representing an array of the current type, + /// with the specified number of dimensions. + /// + /// The number of dimensions for the array. This number must be more than zero and less than or equal to 32. + /// + /// A object representing an array of the current type, + /// with the specified number of dimensions. + /// + /// rank is invalid. For example, 0 or negative. + public TypeName MakeArrayTypeName(int rank) + => rank <= 0 + ? throw new ArgumentOutOfRangeException(nameof(rank)) + : MakeElementTypeName(rank); + + /// + /// Creates a object that represents a pointer to the current type. + /// + /// + /// A object that represents a pointer to the current type. + /// + public TypeName MakePointerTypeName() => MakeElementTypeName(TypeNameParserHelpers.Pointer); + + /// + /// Creates a object that represents a managed reference to the current type. + /// + /// + /// A object that represents a managed reference to the current type. + /// + public TypeName MakeByRefTypeName() => MakeElementTypeName(TypeNameParserHelpers.ByRef); + + /// + /// Creates a new constructed generic type name. + /// + /// An array of type names to be used as generic arguments of the current simple type name. + /// + /// A representing the constructed type name formed by using the elements + /// of for the generic arguments of the current simple type name. + /// + /// The current type name is not simple. + public TypeName MakeGenericTypeName(ImmutableArray typeArguments) + { + if (!IsSimple) + { + TypeNameParserHelpers.ThrowInvalidOperation_NotSimpleName(FullName); + } + + return new TypeName(fullName: null, AssemblyName, elementOrGenericType: this, declaringType: _declaringType, genericTypeArguments: typeArguments); + } + + private TypeName MakeElementTypeName(int rankOrModifier) + => new TypeName( + fullName: null, + assemblyName: AssemblyName, + elementOrGenericType: this, + declaringType: null, + genericTypeArguments: ImmutableArray.Empty, + rankOrModifier: rankOrModifier); +#endif } } diff --git a/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/TypeNameParser.cs b/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/TypeNameParser.cs index 5a5bbe04a0c..08ed944d031 100644 --- a/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/TypeNameParser.cs +++ b/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/TypeNameParser.cs @@ -49,7 +49,7 @@ private TypeNameParser(ReadOnlySpan name, bool throwOnError, TypeNameParse { if (throwOnError) { - if (parser._parseOptions.IsMaxDepthExceeded(recursiveDepth)) + if (IsMaxDepthExceeded(parser._parseOptions, recursiveDepth)) { ThrowInvalidOperation_MaxNodesExceeded(parser._parseOptions.MaxNodes); } @@ -61,23 +61,27 @@ private TypeNameParser(ReadOnlySpan name, bool throwOnError, TypeNameParse return null; } + Debug.Assert(parsedName.GetNodeCount() == recursiveDepth, $"Node count mismatch for '{typeName.ToString()}'"); + return parsedName; } // this method should return null instead of throwing, so the caller can get errorIndex and include it in error msg private TypeName? ParseNextTypeName(bool allowFullyQualifiedName, ref int recursiveDepth) { - if (!TryDive(ref recursiveDepth)) + if (!TryDive(_parseOptions, ref recursiveDepth)) { return null; } List? nestedNameLengths = null; - if (!TryGetTypeNameInfo(ref _inputString, ref nestedNameLengths, out int fullTypeNameLength)) + if (!TryGetTypeNameInfo(_parseOptions, ref _inputString, ref nestedNameLengths, ref recursiveDepth, out int fullTypeNameLength)) { return null; } + // At this point, we have performed O(fullTypeNameLength) total work. + ReadOnlySpan fullTypeName = _inputString.Slice(0, fullTypeNameLength); _inputString = _inputString.Slice(fullTypeNameLength); @@ -140,6 +144,12 @@ private TypeNameParser(ReadOnlySpan name, bool throwOnError, TypeNameParse } } + // At this point, we may have performed O(fullTypeNameLength + _inputString.Length) total work. + // This will be the case if there was whitespace after the full type name in the original input + // string. We could end up looking at these same whitespace chars again later in this method, + // such as when parsing decorators. We rely on the TryDive routine to limit the total number + // of times we might inspect the same character. + // If there was an error stripping the generic args, back up to // before we started processing them, and let the decorator // parser try handling it. @@ -147,6 +157,16 @@ private TypeNameParser(ReadOnlySpan name, bool throwOnError, TypeNameParse { _inputString = capturedBeforeProcessing; } + else + { + // Every constructed generic type needs the generic type definition. + if (!TryDive(_parseOptions, ref recursiveDepth)) + { + return null; + } + // If that generic type is a nested type, we don't increase the recursiveDepth any further, + // as generic type definition uses exactly the same declaring type as the constructed generic type. + } int previousDecorator = default; // capture the current state so we can reprocess it again once we know the AssemblyName @@ -154,7 +174,7 @@ private TypeNameParser(ReadOnlySpan name, bool throwOnError, TypeNameParse // iterate over the decorators to ensure there are no illegal combinations while (TryParseNextDecorator(ref _inputString, out int parsedDecorator)) { - if (!TryDive(ref recursiveDepth)) + if (!TryDive(_parseOptions, ref recursiveDepth)) { return null; } @@ -190,11 +210,14 @@ private TypeNameParser(ReadOnlySpan name, bool throwOnError, TypeNameParse result = new(fullName: null, assemblyName, elementOrGenericType: result, declaringType, genericArgs); } + // The loop below is protected by the dive check during the first decorator pass prior + // to assembly name parsing above. + if (previousDecorator != default) // some decorators were recognized { while (TryParseNextDecorator(ref capturedBeforeProcessing, out int parsedModifier)) { - result = new(fullName: null, assemblyName, elementOrGenericType: result, rankOrModifier: (sbyte)parsedModifier); + result = new(fullName: null, assemblyName, elementOrGenericType: result, rankOrModifier: parsedModifier); } } @@ -233,6 +256,8 @@ private bool TryParseAssemblyName(ref AssemblyNameInfo? assemblyName) return null; } + // The loop below is protected by the dive check in GetFullTypeNameLength. + TypeName? declaringType = null; int nameOffset = 0; foreach (int nestedNameLength in nestedNameLengths) @@ -245,15 +270,5 @@ private bool TryParseAssemblyName(ref AssemblyNameInfo? assemblyName) return declaringType; } - - private bool TryDive(ref int depth) - { - if (_parseOptions.IsMaxDepthExceeded(depth)) - { - return false; - } - depth++; - return true; - } } } diff --git a/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/TypeNameParserHelpers.cs b/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/TypeNameParserHelpers.cs index 2fa33ea1dfe..7cafd746b7d 100644 --- a/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/TypeNameParserHelpers.cs +++ b/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/TypeNameParserHelpers.cs @@ -11,11 +11,12 @@ namespace System.Reflection.Metadata { internal static class TypeNameParserHelpers { - internal const sbyte SZArray = -1; - internal const sbyte Pointer = -2; - internal const sbyte ByRef = -3; + internal const int SZArray = -1; + internal const int Pointer = -2; + internal const int ByRef = -3; private const char EscapeCharacter = '\\'; #if NET8_0_OR_GREATER + // Keep this in sync with GetFullTypeNameLength/NeedsEscaping private static readonly SearchValues s_endOfFullTypeNameDelimitersSearchValues = SearchValues.Create("[]&*,+\\"); #endif @@ -30,7 +31,7 @@ internal static string GetGenericTypeFullName(ReadOnlySpan fullTypeName, R foreach (TypeName genericArg in genericArgs) { result.Append('['); - result.Append(genericArg.AssemblyQualifiedName); + result.Append(genericArg.AssemblyQualifiedName); // see recursion comments in TypeName.FullName result.Append(']'); result.Append(','); } @@ -97,11 +98,16 @@ static int GetUnescapedOffset(ReadOnlySpan input, int startOffset) return offset; } + // Keep this in sync with s_endOfFullTypeNameDelimitersSearchValues static bool NeedsEscaping(char c) => c is '[' or ']' or '&' or '*' or ',' or '+' or EscapeCharacter; } internal static ReadOnlySpan GetName(ReadOnlySpan fullName) { + // The two-value form of MemoryExtensions.LastIndexOfAny does not suffer + // from the behavior mentioned in the comment at the top of GetFullTypeNameLength. + // It always takes O(m * i) worst-case time and is safe to use here. + int offset = fullName.LastIndexOfAny('.', '+'); if (offset > 0 && fullName[offset - 1] == EscapeCharacter) // this should be very rare (IL Emit & pure IL) @@ -182,6 +188,13 @@ internal static string GetRankOrModifierStringRepresentation(int rankOrModifier, { Debug.Assert(rankOrModifier >= 2); + // O(rank) work, so we have to assume the rank is trusted. We don't put a hard cap on this, + // but within the TypeName parser, we do require the input string to contain the correct number + // of commas. This forces the input string to have at least O(rank) length, so there's no + // alg. complexity attack possible here. Callers can of course pass any arbitrary value to + // TypeName.MakeArrayTypeName, but per first sentence in this comment, we have to assume any + // such arbitrary value which is programmatically fed in originates from a trustworthy source. + builder.Append('['); builder.Append(',', rankOrModifier - 1); builder.Append(']'); @@ -220,7 +233,8 @@ internal static bool IsBeginningOfGenericArgs(ref ReadOnlySpan span, out b return false; } - internal static bool TryGetTypeNameInfo(ref ReadOnlySpan input, ref List? nestedNameLengths, out int totalLength) + internal static bool TryGetTypeNameInfo(TypeNameParseOptions options, ref ReadOnlySpan input, + ref List? nestedNameLengths, ref int recursiveDepth, out int totalLength) { bool isNestedType; totalLength = 0; @@ -248,6 +262,11 @@ internal static bool TryGetTypeNameInfo(ref ReadOnlySpan input, ref List input, out int else if (TryStripFirstCharAndTrailingSpaces(ref input, ',')) { // [,,, ...] + // The runtime restricts arrays to rank 32, but we don't enforce that here. + // Instead, the max rank is controlled by the total number of commas present + // in the array decorator. checked { rank++; } goto ReadNextArrayToken; } @@ -388,5 +410,26 @@ internal static void ThrowInvalidOperation_HasToBeArrayClass() throw new InvalidOperationException(); #endif } + + internal static bool IsMaxDepthExceeded(TypeNameParseOptions options, int depth) +#if SYSTEM_PRIVATE_CORELIB + => false; // CoreLib does not enforce any limits +#else + => depth > options.MaxNodes; +#endif + + internal static bool TryDive(TypeNameParseOptions options, ref int depth) + { + depth++; + return !IsMaxDepthExceeded(options, depth); + } + +#if SYSTEM_REFLECTION_METADATA + [DoesNotReturn] + internal static void ThrowInvalidOperation_NotSimpleName(string fullName) + { + throw new InvalidOperationException(SR.Format(SR.Arg_NotSimpleTypeName, fullName)); + } +#endif } } diff --git a/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/TypeNameParserOptions.cs b/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/TypeNameParserOptions.cs index 551876e7314..53d6f7f1642 100644 --- a/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/TypeNameParserOptions.cs +++ b/src/libraries/System.Reflection.Metadata/src/System/Reflection/Metadata/TypeNameParserOptions.cs @@ -10,6 +10,13 @@ public sealed class TypeNameParseOptions /// /// Limits the maximum value of node count that parser can handle. /// + /// + /// + /// Setting this to a large value can render susceptible to Denial of Service + /// attacks when parsing or handling malicious input. + /// + /// The default value is 20. + /// public int MaxNodes { get => _maxNodes; @@ -27,7 +34,5 @@ public int MaxNodes _maxNodes = value; } } - - internal bool IsMaxDepthExceeded(int depth) => depth >= _maxNodes; } } diff --git a/src/libraries/System.Reflection.Metadata/tests/Metadata/AssemblyNameInfoTests.cs b/src/libraries/System.Reflection.Metadata/tests/Metadata/AssemblyNameInfoTests.cs index 89127889c40..c766e6bd4d5 100644 --- a/src/libraries/System.Reflection.Metadata/tests/Metadata/AssemblyNameInfoTests.cs +++ b/src/libraries/System.Reflection.Metadata/tests/Metadata/AssemblyNameInfoTests.cs @@ -98,6 +98,13 @@ public void RetargetableIsPropagated() public void EscapedSquareBracketIsNotAllowedInTheName() => Assert.False(AssemblyNameInfo.TryParse("Esc\\[aped".AsSpan(), out _)); + [Fact] + public void EmptyInputIsInvalid() + { + Assert.False(AssemblyNameInfo.TryParse("".AsSpan(), out _)); + Assert.Throws(() => AssemblyNameInfo.Parse("".AsSpan())); + } + static void Roundtrip(AssemblyName source) { AssemblyNameInfo parsed = AssemblyNameInfo.Parse(source.FullName.AsSpan()); diff --git a/src/libraries/System.Reflection.Metadata/tests/Metadata/TypeNameParserHelpersTests.cs b/src/libraries/System.Reflection.Metadata/tests/Metadata/TypeNameParserHelpersTests.cs index b9d23a2be15..01ec45b50cc 100644 --- a/src/libraries/System.Reflection.Metadata/tests/Metadata/TypeNameParserHelpersTests.cs +++ b/src/libraries/System.Reflection.Metadata/tests/Metadata/TypeNameParserHelpersTests.cs @@ -122,7 +122,9 @@ public void TryGetTypeNameInfoGetsAllTheInfo(string input, bool expectedResult, { List? nestedNameLengths = null; ReadOnlySpan span = input.AsSpan(); - bool result = TypeNameParserHelpers.TryGetTypeNameInfo(ref span, ref nestedNameLengths, out int totalLength); + TypeNameParseOptions options = new(); + int recursiveDepth = 0; + bool result = TypeNameParserHelpers.TryGetTypeNameInfo(options, ref span, ref nestedNameLengths, ref recursiveDepth, out int totalLength); Assert.Equal(expectedResult, result); @@ -130,6 +132,7 @@ public void TryGetTypeNameInfoGetsAllTheInfo(string input, bool expectedResult, { Assert.Equal(expectedNestedNameLengths, nestedNameLengths?.ToArray()); Assert.Equal(expectedTotalLength, totalLength); + Assert.Equal(expectedNestedNameLengths?.Length ?? 0, recursiveDepth); } } diff --git a/src/libraries/System.Reflection.Metadata/tests/Metadata/TypeNameTests.cs b/src/libraries/System.Reflection.Metadata/tests/Metadata/TypeNameTests.cs index a5e22b5d6c5..dcf46d54d2d 100644 --- a/src/libraries/System.Reflection.Metadata/tests/Metadata/TypeNameTests.cs +++ b/src/libraries/System.Reflection.Metadata/tests/Metadata/TypeNameTests.cs @@ -107,9 +107,7 @@ public void TypeNameCanContainAssemblyName(Type type) static void Verify(Type type, AssemblyName expectedAssemblyName, TypeName parsed) { - Assert.Equal(type.AssemblyQualifiedName, parsed.AssemblyQualifiedName); - Assert.Equal(type.FullName, parsed.FullName); - Assert.Equal(type.Name, parsed.Name); + EnsureBasicMatch(parsed, type); AssemblyNameInfo parsedAssemblyName = parsed.AssemblyName; Assert.NotNull(parsedAssemblyName); @@ -123,119 +121,207 @@ static void Verify(Type type, AssemblyName expectedAssemblyName, TypeName parsed } } - [Theory] - [InlineData(10, "*")] // pointer to pointer - [InlineData(10, "[]")] // array of arrays - [InlineData(100, "*")] - [InlineData(100, "[]")] - public void MaxNodesIsRespected_TooManyDecorators(int maxDepth, string decorator) + private static void EnsureMaxNodesIsRespected(string typeName, int expectedNodeCount, Action validate) { - TypeNameParseOptions options = new() + // Specified MaxNodes is equal the actual node count + TypeNameParseOptions equal = new() { - MaxNodes = maxDepth + MaxNodes = expectedNodeCount }; - string notTooMany = $"System.Int32{string.Join("", Enumerable.Repeat(decorator, maxDepth - 1))}"; - string tooMany = $"System.Int32{string.Join("", Enumerable.Repeat(decorator, maxDepth))}"; + TypeName parsed = TypeName.Parse(typeName.AsSpan(), equal); + Assert.Equal(expectedNodeCount, parsed.GetNodeCount()); + validate(parsed); + Assert.True(TypeName.TryParse(typeName.AsSpan(), out parsed, equal)); + Assert.Equal(expectedNodeCount, parsed.GetNodeCount()); + validate(parsed); + + // Specified MaxNodes is less than the actual node count + TypeNameParseOptions less = new() + { + MaxNodes = expectedNodeCount - 1 + }; - Assert.Throws(() => TypeName.Parse(tooMany.AsSpan(), options)); - Assert.False(TypeName.TryParse(tooMany.AsSpan(), out _, options)); + Assert.Throws(() => TypeName.Parse(typeName.AsSpan(), less)); + Assert.False(TypeName.TryParse(typeName.AsSpan(), out _, less)); - TypeName parsed = TypeName.Parse(notTooMany.AsSpan(), options); - ValidateElementType(maxDepth, parsed, decorator); + // Specified MaxNodes is more than the actual node count + TypeNameParseOptions more = new() + { + MaxNodes = expectedNodeCount + 1 + }; - Assert.True(TypeName.TryParse(notTooMany.AsSpan(), out parsed, options)); - ValidateElementType(maxDepth, parsed, decorator); + parsed = TypeName.Parse(typeName.AsSpan(), more); + Assert.Equal(expectedNodeCount, parsed.GetNodeCount()); + validate(parsed); + Assert.True(TypeName.TryParse(typeName.AsSpan(), out parsed, more)); + Assert.Equal(expectedNodeCount, parsed.GetNodeCount()); + validate(parsed); + } - static void ValidateElementType(int maxDepth, TypeName parsed, string decorator) + [Theory] + [InlineData("*", 10)] // pointer to pointer + [InlineData("[]", 10)] // array of arrays + [InlineData("*", 100)] + [InlineData("[]", 100)] + public void MaxNodesIsRespected_Decorators(string decorator, int decoratorsCount) + { + string name = $"System.Int32{string.Join("", Enumerable.Repeat(decorator, decoratorsCount))}"; + + // Expected node count: + // - +1 for the simple type name (System.Int32) + // - +1 for every decorator + int expectedNodeCount = 1 + decoratorsCount; + + EnsureMaxNodesIsRespected(name, expectedNodeCount, parsed => { - for (int i = 0; i < maxDepth - 1; i++) + for (int i = 0; i < decoratorsCount; i++) { + Assert.Equal(expectedNodeCount - i, parsed.GetNodeCount()); + Assert.Equal(decorator == "*", parsed.IsPointer); Assert.Equal(decorator == "[]", parsed.IsSZArray); Assert.False(parsed.IsConstructedGenericType); + Assert.False(parsed.IsSimple); parsed = parsed.GetElementType(); } - } + }); } [Theory] [InlineData(10)] [InlineData(100)] - public void MaxNodesIsRespected_TooDeepGenerics(int maxDepth) + public void MaxNodesIsRespected_GenericsOfGenerics(int depth) { - TypeNameParseOptions options = new() - { - MaxNodes = maxDepth - }; - - string tooDeep = GetName(maxDepth); - string notTooDeep = GetName(maxDepth - 1); - - Assert.Throws(() => TypeName.Parse(tooDeep.AsSpan(), options)); - Assert.False(TypeName.TryParse(tooDeep.AsSpan(), out _, options)); - - TypeName parsed = TypeName.Parse(notTooDeep.AsSpan(), options); - Validate(maxDepth, parsed); - - Assert.True(TypeName.TryParse(notTooDeep.AsSpan(), out parsed, options)); - Validate(maxDepth, parsed); - - static string GetName(int depth) + // MakeGenericType is not used here, as it crashes for larger depths + string coreLibName = typeof(object).Assembly.FullName; + string name = typeof(int).AssemblyQualifiedName!; + for (int i = 0; i < depth; i++) { - // MakeGenericType is not used here, as it crashes for larger depths - string coreLibName = typeof(object).Assembly.FullName; - string fullName = typeof(int).AssemblyQualifiedName!; - for (int i = 0; i < depth; i++) - { - fullName = $"System.Collections.Generic.List`1[[{fullName}]], {coreLibName}"; - } - return fullName; + name = $"System.Collections.Generic.List`1[[{name}]], {coreLibName}"; } - static void Validate(int maxDepth, TypeName parsed) + // Expected node count: + // - +1 for the simple type name (System.Int32) + // - +2 * depth (+1 for the generic type definition and +1 for the constructed generic type) + int expectedNodeCount = 1 + 2 * depth; + + EnsureMaxNodesIsRespected(name, expectedNodeCount, parsed => { - for (int i = 0; i < maxDepth - 1; i++) + for (int i = 0; i < depth - 1; i++) { Assert.True(parsed.IsConstructedGenericType); parsed = parsed.GetGenericArguments()[0]; } - } + }); } [Theory] [InlineData(10)] [InlineData(100)] - public void MaxNodesIsRespected_TooManyGenericArguments(int maxDepth) + public void MaxNodesIsRespected_FlatGenericArguments(int genericArgsCount) { - TypeNameParseOptions options = new() + string name = $"Some.GenericType`{genericArgsCount}[{string.Join(",", Enumerable.Repeat("System.Int32", genericArgsCount))}]"; + + // Expected node count: + // - +1 for the constructed generic type itself + // - +1 * genericArgsCount (all arguments are simple) + // - +1 for generic type definition + int expectedNodeCount = 1 + genericArgsCount + 1; + + EnsureMaxNodesIsRespected(name, expectedNodeCount, parsed => { - MaxNodes = maxDepth - }; + Assert.True(parsed.IsConstructedGenericType); + ImmutableArray genericArgs = parsed.GetGenericArguments(); + Assert.Equal(genericArgsCount, genericArgs.Length); + Assert.All(genericArgs, arg => Assert.False(arg.IsConstructedGenericType)); + Assert.All(genericArgs, arg => Assert.Equal(1, arg.GetNodeCount())); + Assert.Equal(1, parsed.GetGenericTypeDefinition().GetNodeCount()); + Assert.Equal(expectedNodeCount, parsed.GetNodeCount()); + }); + } - string tooMany = GetName(maxDepth); - string notTooMany = GetName(maxDepth - 1); + [Theory] + [InlineData(10)] + [InlineData(100)] + public void MaxNodesIsRespected_NestedNames(int nestingDepth) + { + string name = $"Namespace.NotNestedType+{string.Join("+", Enumerable.Repeat("NestedType", nestingDepth))}"; - Assert.Throws(() => TypeName.Parse(tooMany.AsSpan(), options)); - Assert.False(TypeName.TryParse(tooMany.AsSpan(), out _, options)); + // Expected node count: + // - +1 for the nested type name itself + // - +1 * nestingDepth + int expectedNodeCount = 1 + nestingDepth; - TypeName parsed = TypeName.Parse(notTooMany.AsSpan(), options); - Validate(parsed, maxDepth); + EnsureMaxNodesIsRespected(name, expectedNodeCount, parsed => + { + Assert.True(parsed.IsNested); + Assert.Equal(expectedNodeCount, parsed.GetNodeCount()); - Assert.True(TypeName.TryParse(notTooMany.AsSpan(), out parsed, options)); - Validate(parsed, maxDepth); + int depth = nestingDepth; + while (parsed.IsNested) + { + parsed = parsed.DeclaringType; + Assert.Equal(depth, parsed.GetNodeCount()); + depth--; + } - static string GetName(int depth) - => $"Some.GenericType`{depth}[{string.Join(",", Enumerable.Repeat("System.Int32", depth))}]"; + Assert.False(parsed.IsNested); + Assert.Equal(1, parsed.GetNodeCount()); + Assert.Equal(0, depth); + }); + } - static void Validate(TypeName parsed, int maxDepth) + [Theory] + [InlineData("System.Int32*", 2)] // a pointer to a simple type + [InlineData("System.Int32[]*", 3)] // a pointer to an array of a simple type + [InlineData("System.Declaring+Nested", 2)] // a nested and declaring types + [InlineData("System.Declaring+Nested*", 3)] // a pointer to a nested type, which has the declaring type + // "Namespace.Declaring+NestedGeneric`2[A, B]" requires 5 TypeName instances: + // - constructed generic type: Namespace.Declaring+NestedGeneric`2[A, B] (+1) + // - declaring type: Namespace.Declaring (+1) + // - generic type definition: Namespace.Declaring+NestedGeneric`2 (+1) + // - declaring type is the same as of the constructed generic type (+0) + // - generic arguments: + // - generic arguments: + // - simple: A (+1) + // - simple: B (+1) + [InlineData("Namespace.Declaring+NestedGeneric`2[A, B]", 5)] + // A pointer to the above + [InlineData("Namespace.Declaring+NestedGeneric`2[A, B]*", 6)] + // A pointer to the array of the above + [InlineData("Namespace.Declaring+NestedGeneric`2[A, B][,]*", 7)] + // "Namespace.Declaring+NestedGeneric`1[AnotherGeneric`1[A]]" requires 6 TypeName instances: + // - constructed generic type: Namespace.Declaring+NestedGeneric`1[AnotherGeneric`1[A]] (+1) + // - declaring type: Namespace.Declaring (+1) + // - generic type definition: Namespace.Declaring+NestedGeneric`1 (+1) + // - declaring type is the same as of the constructed generic type (+0) + // - generic arguments: + // - constructed generic type: AnotherGeneric`1[A] (+1) + // - generic type definition: AnotherGeneric`1 (+1) + // - generic arguments: + // - simple: A (+1) + [InlineData("Namespace.Declaring+NestedGeneric`1[AnotherGeneric`1[A]]", 6)] + public void MaxNodesIsRespected(string typeName, int expectedNodeCount) + { + TypeNameParseOptions tooMany = new() { - Assert.True(parsed.IsConstructedGenericType); - ImmutableArray genericArgs = parsed.GetGenericArguments(); - Assert.Equal(maxDepth - 1, genericArgs.Length); - Assert.All(genericArgs, arg => Assert.False(arg.IsConstructedGenericType)); - } + MaxNodes = expectedNodeCount - 1 + }; + TypeNameParseOptions notTooMany = new() + { + MaxNodes = expectedNodeCount + }; + + Assert.Throws(() => TypeName.Parse(typeName.AsSpan(), tooMany)); + Assert.False(TypeName.TryParse(typeName.AsSpan(), out _, tooMany)); + + TypeName parsed = TypeName.Parse(typeName.AsSpan(), notTooMany); + Assert.Equal(expectedNodeCount, parsed.GetNodeCount()); + + Assert.True(TypeName.TryParse(typeName.AsSpan(), out parsed, notTooMany)); + Assert.Equal(expectedNodeCount, parsed.GetNodeCount()); } public static IEnumerable GenericArgumentsAreSupported_Arguments() @@ -473,10 +559,10 @@ public static IEnumerable GetAdditionalConstructedTypeData() [InlineData(typeof(int[,][]), 3)] [InlineData(typeof(Nullable<>), 1)] // open generic type treated as elemental [InlineData(typeof(NestedNonGeneric_0), 2)] // declaring and nested - [InlineData(typeof(NestedGeneric_0), 3)] // declaring, nested and generic arg + [InlineData(typeof(NestedGeneric_0), 4)] // declaring, nested, generic arg and generic type definition [InlineData(typeof(NestedNonGeneric_0.NestedNonGeneric_1), 3)] // declaring, nested 0 and nested 1 // TypeNameTests+NestedGeneric_0`1+NestedGeneric_1`2[[Int32],[String],[Boolean]] (simplified for brevity) - [InlineData(typeof(NestedGeneric_0.NestedGeneric_1), 6)] // declaring, nested 0 and nested 1 and 3 generic args + [InlineData(typeof(NestedGeneric_0.NestedGeneric_1), 7)] // declaring, nested 0 and nested 1 and 3 generic args and generic type definition [MemberData(nameof(GetAdditionalConstructedTypeData))] public void GetNodeCountReturnsExpectedValue(Type type, int expected) { @@ -484,9 +570,147 @@ public void GetNodeCountReturnsExpectedValue(Type type, int expected) Assert.Equal(expected, parsed.GetNodeCount()); - Assert.Equal(type.Name, parsed.Name); - Assert.Equal(type.FullName, parsed.FullName); - Assert.Equal(type.AssemblyQualifiedName, parsed.AssemblyQualifiedName); + EnsureBasicMatch(parsed, type); + + if (!type.IsByRef) + { + EnsureBasicMatch(parsed.MakeSZArrayTypeName(), type.MakeArrayType()); + EnsureBasicMatch(parsed.MakeArrayTypeName(3), type.MakeArrayType(3)); + EnsureBasicMatch(parsed.MakeByRefTypeName(), type.MakeByRefType()); + EnsureBasicMatch(parsed.MakePointerTypeName(), type.MakePointerType()); + } + } + + [OuterLoop("It takes a lot of time")] + [Fact] + public void GetNodeCountThrowsForInt32Overflow() + { + TypeName genericType = TypeName.Parse("Generic".AsSpan()); + TypeName genericArg = TypeName.Parse("Arg".AsSpan()); + // Don't allocate Array.MaxLength array as it may make this test flaky (frequent OOMs). + ImmutableArray.Builder genericArgs = ImmutableArray.CreateBuilder(initialCapacity: (int)Math.Sqrt(int.MaxValue)); + for (int i = 0; i < genericArgs.Capacity; ++i) + { + genericArgs.Add(genericArg); + } + TypeName constructedGenericType = genericType.MakeGenericTypeName(genericArgs.MoveToImmutable()); + // Just repeat the same reference to a large closed generic type multiple times. + // It's going to give us large node count without allocating too much. + TypeName largeNodeCount = genericType.MakeGenericTypeName(Enumerable.Repeat(constructedGenericType, (int)Math.Sqrt(int.MaxValue)).ToImmutableArray()); + + Assert.Throws(() => largeNodeCount.GetNodeCount()); + } + + [Fact] + public void MakeGenericTypeName() + { + Type genericTypeDefinition = typeof(Dictionary<,>); + TypeName genericTypeNameDefinition = TypeName.Parse(genericTypeDefinition.AssemblyQualifiedName.AsSpan()); + + Type[] genericArgs = new Type[] { typeof(int), typeof(bool) }; + ImmutableArray genericTypeNames = genericArgs.Select(type => TypeName.Parse(type.AssemblyQualifiedName.AsSpan())).ToImmutableArray(); + + TypeName genericTypeName = genericTypeNameDefinition.MakeGenericTypeName(genericTypeNames); + Type genericType = genericTypeDefinition.MakeGenericType(genericArgs); + + EnsureBasicMatch(genericTypeName, genericType); + + TypeName szArrayTypeName = genericTypeNameDefinition.MakeSZArrayTypeName(); + Assert.Throws(() => szArrayTypeName.MakeGenericTypeName(genericTypeNames)); + TypeName mdArrayTypeName = genericTypeNameDefinition.MakeArrayTypeName(3); + Assert.Throws(() => mdArrayTypeName.MakeGenericTypeName(genericTypeNames)); + TypeName pointerTypeName = genericTypeNameDefinition.MakePointerTypeName(); + Assert.Throws(() => pointerTypeName.MakeGenericTypeName(genericTypeNames)); + TypeName byRefTypeName = genericTypeNameDefinition.MakeByRefTypeName(); + Assert.Throws(() => byRefTypeName.MakeGenericTypeName(genericTypeNames)); + } + + [Theory] + [InlineData("Simple")] + [InlineData("Pointer*")] + [InlineData("Pointer*******")] + [InlineData("ByRef&")] + [InlineData("SZArray[]")] + [InlineData("CustomOffsetArray[*]")] + [InlineData("MDArray[,]")] + [InlineData("Declaring+Nested")] + [InlineData("Declaring+Deep+Deeper+Nested")] + [InlineData("Generic[[GenericArg]]")] + public void WithAssemblyNameThrowsForNonSimpleNames(string input) + { + TypeName typeName = TypeName.Parse(input.AsSpan()); + + if (typeName.IsSimple) + { + AssemblyNameInfo assemblyName = new("MyName"); + TypeName simple = typeName.WithAssemblyName(assemblyName: assemblyName); + + Assert.Equal(typeName.FullName, simple.FullName); // full name has not changed + Assert.NotEqual(typeName.AssemblyQualifiedName, simple.AssemblyQualifiedName); + Assert.Equal($"{typeName.FullName}, {assemblyName.FullName}", simple.AssemblyQualifiedName); + + Assert.True(simple.IsSimple); + Assert.False(simple.IsArray); + Assert.False(simple.IsConstructedGenericType); + Assert.False(simple.IsPointer); + Assert.False(simple.IsByRef); + Assert.Equal(typeName.IsNested, simple.IsNested); + } + else + { + Assert.Throws(() => typeName.WithAssemblyName(assemblyName: null)); + } + } + + [Theory] + [InlineData("Declaring+Nested")] + [InlineData("Declaring+Nested, Lib")] + [InlineData("Declaring+Deep+Deeper+Nested")] + [InlineData("Declaring+Deep+Deeper+Nested, Lib")] + public void WithAssemblyName_NestedNames(string name) + { + AssemblyNameInfo assemblyName = new("New"); + TypeName parsed = TypeName.Parse(name.AsSpan()); + TypeName made = parsed.WithAssemblyName(assemblyName); + + VerifyNestedNames(parsed, made, assemblyName); + } + + [Theory] + [InlineData(typeof(NestedNonGeneric_0.NestedGeneric_1))] + [InlineData(typeof(NestedGeneric_0))] + [InlineData(typeof(NestedGeneric_0.NestedNonGeneric_1))] + [InlineData(typeof(NestedGeneric_0.NestedGeneric_1))] + [InlineData(typeof(NestedGeneric_0.NestedGeneric_1.NestedNonGeneric_2))] + [InlineData(typeof(NestedGeneric_0.NestedGeneric_1.NestedGeneric_2))] + [InlineData(typeof(NestedGeneric_0.NestedGeneric_1.NestedGeneric_2.NestedNonGeneric_3))] + public void MakeGenericTypeName_NestedNames(Type type) + { + AssemblyNameInfo assemblyName = new("New"); + TypeName parsed = TypeName.Parse(type.AssemblyQualifiedName.AsSpan()); + TypeName made = parsed.GetGenericTypeDefinition().WithAssemblyName(assemblyName).MakeGenericTypeName(parsed.GetGenericArguments()); + + VerifyNestedNames(parsed, made, assemblyName); + } + + private static void VerifyNestedNames(TypeName parsed, TypeName made, AssemblyNameInfo assemblyName) + { + while (true) + { + Assert.Equal(parsed.Name, made.Name); + Assert.Equal(parsed.FullName, made.FullName); + Assert.Equal(assemblyName, made.AssemblyName); + Assert.NotEqual(parsed.AssemblyQualifiedName, made.AssemblyQualifiedName); + Assert.EndsWith(assemblyName.FullName, made.AssemblyQualifiedName); + + if (!parsed.IsNested) + { + break; + } + + parsed = parsed.DeclaringType; + made = made.DeclaringType; + } } [Fact] @@ -561,9 +785,7 @@ public void ParsedNamesMatchSystemTypeNames(Type type) { TypeName parsed = TypeName.Parse(type.AssemblyQualifiedName.AsSpan()); - Assert.Equal(type.Name, parsed.Name); - Assert.Equal(type.FullName, parsed.FullName); - Assert.Equal(type.AssemblyQualifiedName, parsed.AssemblyQualifiedName); + EnsureBasicMatch(parsed, type); if (type.IsGenericType) { @@ -591,6 +813,18 @@ public void TheNumberAfterBacktickDoesNotEnforceGenericArgCount(string input, st Assert.Equal("bool", parsed.GetGenericArguments()[1].Name); } + [Fact] + public void ArrayRank_SByteOverflow() + { + const string Input = "WeDontEnforceAnyMaxArrayRank[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,]"; + + TypeName typeName = TypeName.Parse(Input.AsSpan()); + + Assert.Equal(Input, typeName.FullName); + Assert.True(typeName.IsArray); + Assert.Equal(128, typeName.GetArrayRank()); + } + [Theory] [InlineData(typeof(int))] [InlineData(typeof(int?))] @@ -626,9 +860,7 @@ static void Test(Type type) TypeName parsed = TypeName.Parse(type.AssemblyQualifiedName.AsSpan()); // ensure that Name, FullName and AssemblyQualifiedName match reflection APIs!! - Assert.Equal(type.Name, parsed.Name); - Assert.Equal(type.FullName, parsed.FullName); - Assert.Equal(type.AssemblyQualifiedName, parsed.AssemblyQualifiedName); + EnsureBasicMatch(parsed, type); // now load load the type from name Verify(type, parsed, ignoreCase: false); #if NET // something weird is going on here @@ -729,9 +961,27 @@ static void Verify(Type type, TypeName typeName, bool ignoreCase) #pragma warning restore IL2055, IL2057, IL2075, IL2096 } + private static void EnsureBasicMatch(TypeName typeName, Type type) + { + Assert.Equal(type.AssemblyQualifiedName, typeName.AssemblyQualifiedName); + Assert.Equal(type.FullName, typeName.FullName); + Assert.Equal(type.Name, typeName.Name); + +#if NET + Assert.Equal(type.IsSZArray, typeName.IsSZArray); +#endif + Assert.Equal(type.IsArray, typeName.IsArray); + Assert.Equal(type.IsPointer, typeName.IsPointer); + Assert.Equal(type.IsByRef, typeName.IsByRef); + Assert.Equal(type.IsConstructedGenericType, typeName.IsConstructedGenericType); + Assert.Equal(type.IsNested, typeName.IsNested); + } + public class NestedNonGeneric_0 { public class NestedNonGeneric_1 { } + + public class NestedGeneric_1 { } } public class NestedGeneric_0 @@ -742,7 +992,10 @@ public class NestedGeneric_2 { public class NestedNonGeneric_3 { } } + + public class NestedNonGeneric_2 { } } + public class NestedNonGeneric_1 { } } } } diff --git a/src/libraries/System.Reflection.Metadata/tests/System.Reflection.Metadata.Tests.csproj b/src/libraries/System.Reflection.Metadata/tests/System.Reflection.Metadata.Tests.csproj index a985caddfff..5eb2bf7446e 100644 --- a/src/libraries/System.Reflection.Metadata/tests/System.Reflection.Metadata.Tests.csproj +++ b/src/libraries/System.Reflection.Metadata/tests/System.Reflection.Metadata.Tests.csproj @@ -152,6 +152,12 @@ + + + + diff --git a/src/libraries/System.Reflection.MetadataLoadContext/System.Reflection.MetadataLoadContext.sln b/src/libraries/System.Reflection.MetadataLoadContext/System.Reflection.MetadataLoadContext.sln index 41c9548eefd..6f869f1824b 100644 --- a/src/libraries/System.Reflection.MetadataLoadContext/System.Reflection.MetadataLoadContext.sln +++ b/src/libraries/System.Reflection.MetadataLoadContext/System.Reflection.MetadataLoadContext.sln @@ -21,6 +21,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.MetadataL EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{97806F4F-CCA5-4B86-9B71-B3B35DC990E1}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{F2BBF8AD-F8FC-46D6-845E-698FDA0A852D}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{4361CEFA-8238-4247-9CC5-D99DF794843C}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{7393C7CD-4C31-4B1C-96DC-1D46D240538A}" @@ -103,6 +105,10 @@ Global {97806F4F-CCA5-4B86-9B71-B3B35DC990E1}.Debug|Any CPU.Build.0 = Debug|Any CPU {97806F4F-CCA5-4B86-9B71-B3B35DC990E1}.Release|Any CPU.ActiveCfg = Release|Any CPU {97806F4F-CCA5-4B86-9B71-B3B35DC990E1}.Release|Any CPU.Build.0 = Release|Any CPU + {F2BBF8AD-F8FC-46D6-845E-698FDA0A852D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F2BBF8AD-F8FC-46D6-845E-698FDA0A852D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F2BBF8AD-F8FC-46D6-845E-698FDA0A852D}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F2BBF8AD-F8FC-46D6-845E-698FDA0A852D}.Release|Any CPU.Build.0 = Release|Any CPU {4361CEFA-8238-4247-9CC5-D99DF794843C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {4361CEFA-8238-4247-9CC5-D99DF794843C}.Debug|Any CPU.Build.0 = Debug|Any CPU {4361CEFA-8238-4247-9CC5-D99DF794843C}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -152,6 +158,7 @@ Global {499E5241-B46A-4161-A27C-C6D599070148} = {C9409DA5-0A3B-4194-AEB8-3CA7A6D5387E} {DD06D785-53D2-4C11-895C-E9A24E23E276} = {C9409DA5-0A3B-4194-AEB8-3CA7A6D5387E} {97806F4F-CCA5-4B86-9B71-B3B35DC990E1} = {E86A915C-E800-4558-AFDC-F41C4095B2DF} + {F2BBF8AD-F8FC-46D6-845E-698FDA0A852D} = {E86A915C-E800-4558-AFDC-F41C4095B2DF} {4361CEFA-8238-4247-9CC5-D99DF794843C} = {E86A915C-E800-4558-AFDC-F41C4095B2DF} {7393C7CD-4C31-4B1C-96DC-1D46D240538A} = {E86A915C-E800-4558-AFDC-F41C4095B2DF} {97EB26A9-6F04-4C1B-9977-AA9BFF7F5802} = {0A7CB728-67D0-4F8C-8102-4F433790B9EA} diff --git a/src/libraries/System.Reflection.MetadataLoadContext/src/System.Reflection.MetadataLoadContext.csproj b/src/libraries/System.Reflection.MetadataLoadContext/src/System.Reflection.MetadataLoadContext.csproj index 26bfe897c08..96856f89263 100644 --- a/src/libraries/System.Reflection.MetadataLoadContext/src/System.Reflection.MetadataLoadContext.csproj +++ b/src/libraries/System.Reflection.MetadataLoadContext/src/System.Reflection.MetadataLoadContext.csproj @@ -158,8 +158,8 @@ - - + + diff --git a/src/libraries/System.Reflection.Primitives/System.Reflection.Primitives.sln b/src/libraries/System.Reflection.Primitives/System.Reflection.Primitives.sln index 54b6617bac0..4789c7e19e7 100644 --- a/src/libraries/System.Reflection.Primitives/System.Reflection.Primitives.sln +++ b/src/libraries/System.Reflection.Primitives/System.Reflection.Primitives.sln @@ -9,6 +9,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.Primitive EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.Primitives", "src\System.Reflection.Primitives.csproj", "{5D40069E-7CC2-4B40-A41D-6B003CCB4075}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{F13A875E-C2C8-44E3-931D-A680E472DCFF}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{E8860A76-C8CE-4965-8B6D-C64F1BCAB9F2}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{6DF455E8-D2C8-40EC-AEF2-AE05A66405F7}" @@ -172,6 +174,27 @@ Global {5D40069E-7CC2-4B40-A41D-6B003CCB4075}.Checked|arm64.ActiveCfg = Debug|Any CPU {5D40069E-7CC2-4B40-A41D-6B003CCB4075}.Checked|x64.ActiveCfg = Debug|Any CPU {5D40069E-7CC2-4B40-A41D-6B003CCB4075}.Checked|x86.ActiveCfg = Debug|Any CPU + {F13A875E-C2C8-44E3-931D-A680E472DCFF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F13A875E-C2C8-44E3-931D-A680E472DCFF}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F13A875E-C2C8-44E3-931D-A680E472DCFF}.Debug|arm.ActiveCfg = Debug|Any CPU + {F13A875E-C2C8-44E3-931D-A680E472DCFF}.Debug|arm64.ActiveCfg = Debug|Any CPU + {F13A875E-C2C8-44E3-931D-A680E472DCFF}.Debug|x64.ActiveCfg = Debug|Any CPU + {F13A875E-C2C8-44E3-931D-A680E472DCFF}.Debug|x64.Build.0 = Debug|Any CPU + {F13A875E-C2C8-44E3-931D-A680E472DCFF}.Debug|x86.ActiveCfg = Debug|Any CPU + {F13A875E-C2C8-44E3-931D-A680E472DCFF}.Debug|x86.Build.0 = Debug|Any CPU + {F13A875E-C2C8-44E3-931D-A680E472DCFF}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F13A875E-C2C8-44E3-931D-A680E472DCFF}.Release|Any CPU.Build.0 = Release|Any CPU + {F13A875E-C2C8-44E3-931D-A680E472DCFF}.Release|arm.ActiveCfg = Release|Any CPU + {F13A875E-C2C8-44E3-931D-A680E472DCFF}.Release|arm64.ActiveCfg = Release|Any CPU + {F13A875E-C2C8-44E3-931D-A680E472DCFF}.Release|x64.ActiveCfg = Release|Any CPU + {F13A875E-C2C8-44E3-931D-A680E472DCFF}.Release|x64.Build.0 = Release|Any CPU + {F13A875E-C2C8-44E3-931D-A680E472DCFF}.Release|x86.ActiveCfg = Release|Any CPU + {F13A875E-C2C8-44E3-931D-A680E472DCFF}.Release|x86.Build.0 = Release|Any CPU + {F13A875E-C2C8-44E3-931D-A680E472DCFF}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {F13A875E-C2C8-44E3-931D-A680E472DCFF}.Checked|arm.ActiveCfg = Debug|Any CPU + {F13A875E-C2C8-44E3-931D-A680E472DCFF}.Checked|arm64.ActiveCfg = Debug|Any CPU + {F13A875E-C2C8-44E3-931D-A680E472DCFF}.Checked|x64.ActiveCfg = Debug|Any CPU + {F13A875E-C2C8-44E3-931D-A680E472DCFF}.Checked|x86.ActiveCfg = Debug|Any CPU {E8860A76-C8CE-4965-8B6D-C64F1BCAB9F2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {E8860A76-C8CE-4965-8B6D-C64F1BCAB9F2}.Debug|Any CPU.Build.0 = Debug|Any CPU {E8860A76-C8CE-4965-8B6D-C64F1BCAB9F2}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -348,6 +371,7 @@ Global {661E0A3D-E151-45B2-AA38-B30F8227A741} = {8B893AF4-4C52-4EA7-B4DF-A5ED0E6BEA50} {5D40069E-7CC2-4B40-A41D-6B003CCB4075} = {8B893AF4-4C52-4EA7-B4DF-A5ED0E6BEA50} {869B6F76-2329-474A-854E-5AD5541A1CA0} = {654344FB-C5C8-4364-B43B-C2C9530B96F8} + {F13A875E-C2C8-44E3-931D-A680E472DCFF} = {654344FB-C5C8-4364-B43B-C2C9530B96F8} {E8860A76-C8CE-4965-8B6D-C64F1BCAB9F2} = {654344FB-C5C8-4364-B43B-C2C9530B96F8} {6DF455E8-D2C8-40EC-AEF2-AE05A66405F7} = {654344FB-C5C8-4364-B43B-C2C9530B96F8} {B6734AD0-410E-4B0F-B767-D586E92D4D56} = {4599348B-0480-47D4-9763-F3C6716D3CCC} diff --git a/src/libraries/System.Reflection.TypeExtensions/System.Reflection.TypeExtensions.sln b/src/libraries/System.Reflection.TypeExtensions/System.Reflection.TypeExtensions.sln index 8fe653fd60f..02e9968f05e 100644 --- a/src/libraries/System.Reflection.TypeExtensions/System.Reflection.TypeExtensions.sln +++ b/src/libraries/System.Reflection.TypeExtensions/System.Reflection.TypeExtensions.sln @@ -13,6 +13,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.TypeExten EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.TypeExtensions.Tests", "tests\System.Reflection.TypeExtensions.Tests.csproj", "{FEFD49C5-E2A2-411E-ABF4-DE7B58861750}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{E9D5F96C-8BEE-4A60-9BA3-E330FBC19D33}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{58441636-1844-462C-A3DF-C63CE8442E8F}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{8A6C5539-2206-4A07-8EBE-1C7260B29F31}" @@ -220,6 +222,27 @@ Global {FEFD49C5-E2A2-411E-ABF4-DE7B58861750}.Checked|arm64.ActiveCfg = Debug|Any CPU {FEFD49C5-E2A2-411E-ABF4-DE7B58861750}.Checked|x64.ActiveCfg = Debug|Any CPU {FEFD49C5-E2A2-411E-ABF4-DE7B58861750}.Checked|x86.ActiveCfg = Debug|Any CPU + {E9D5F96C-8BEE-4A60-9BA3-E330FBC19D33}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E9D5F96C-8BEE-4A60-9BA3-E330FBC19D33}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E9D5F96C-8BEE-4A60-9BA3-E330FBC19D33}.Debug|arm.ActiveCfg = Debug|Any CPU + {E9D5F96C-8BEE-4A60-9BA3-E330FBC19D33}.Debug|arm64.ActiveCfg = Debug|Any CPU + {E9D5F96C-8BEE-4A60-9BA3-E330FBC19D33}.Debug|x64.ActiveCfg = Debug|Any CPU + {E9D5F96C-8BEE-4A60-9BA3-E330FBC19D33}.Debug|x64.Build.0 = Debug|Any CPU + {E9D5F96C-8BEE-4A60-9BA3-E330FBC19D33}.Debug|x86.ActiveCfg = Debug|Any CPU + {E9D5F96C-8BEE-4A60-9BA3-E330FBC19D33}.Debug|x86.Build.0 = Debug|Any CPU + {E9D5F96C-8BEE-4A60-9BA3-E330FBC19D33}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E9D5F96C-8BEE-4A60-9BA3-E330FBC19D33}.Release|Any CPU.Build.0 = Release|Any CPU + {E9D5F96C-8BEE-4A60-9BA3-E330FBC19D33}.Release|arm.ActiveCfg = Release|Any CPU + {E9D5F96C-8BEE-4A60-9BA3-E330FBC19D33}.Release|arm64.ActiveCfg = Release|Any CPU + {E9D5F96C-8BEE-4A60-9BA3-E330FBC19D33}.Release|x64.ActiveCfg = Release|Any CPU + {E9D5F96C-8BEE-4A60-9BA3-E330FBC19D33}.Release|x64.Build.0 = Release|Any CPU + {E9D5F96C-8BEE-4A60-9BA3-E330FBC19D33}.Release|x86.ActiveCfg = Release|Any CPU + {E9D5F96C-8BEE-4A60-9BA3-E330FBC19D33}.Release|x86.Build.0 = Release|Any CPU + {E9D5F96C-8BEE-4A60-9BA3-E330FBC19D33}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {E9D5F96C-8BEE-4A60-9BA3-E330FBC19D33}.Checked|arm.ActiveCfg = Debug|Any CPU + {E9D5F96C-8BEE-4A60-9BA3-E330FBC19D33}.Checked|arm64.ActiveCfg = Debug|Any CPU + {E9D5F96C-8BEE-4A60-9BA3-E330FBC19D33}.Checked|x64.ActiveCfg = Debug|Any CPU + {E9D5F96C-8BEE-4A60-9BA3-E330FBC19D33}.Checked|x86.ActiveCfg = Debug|Any CPU {58441636-1844-462C-A3DF-C63CE8442E8F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {58441636-1844-462C-A3DF-C63CE8442E8F}.Debug|Any CPU.Build.0 = Debug|Any CPU {58441636-1844-462C-A3DF-C63CE8442E8F}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -398,6 +421,7 @@ Global {41438432-4DC0-4724-8C8F-0D100083490F} = {9BB99B5C-97D7-4247-B682-27CBBFCF1BB4} {FEFD49C5-E2A2-411E-ABF4-DE7B58861750} = {9BB99B5C-97D7-4247-B682-27CBBFCF1BB4} {EAE41D82-CFFA-4934-89B2-399D12530E84} = {89B14D9D-2BBE-446A-8ED8-020F7BBA6CFC} + {E9D5F96C-8BEE-4A60-9BA3-E330FBC19D33} = {89B14D9D-2BBE-446A-8ED8-020F7BBA6CFC} {58441636-1844-462C-A3DF-C63CE8442E8F} = {89B14D9D-2BBE-446A-8ED8-020F7BBA6CFC} {8A6C5539-2206-4A07-8EBE-1C7260B29F31} = {89B14D9D-2BBE-446A-8ED8-020F7BBA6CFC} {919F14ED-E86A-4757-BFEB-8AEEDBCB09E4} = {B05E90C8-0282-4D7D-955E-3BE8A400D3A6} diff --git a/src/libraries/System.Resources.Extensions/System.Resources.Extensions.sln b/src/libraries/System.Resources.Extensions/System.Resources.Extensions.sln index 79483c6b72d..11652d37434 100644 --- a/src/libraries/System.Resources.Extensions/System.Resources.Extensions.sln +++ b/src/libraries/System.Resources.Extensions/System.Resources.Extensions.sln @@ -37,6 +37,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Resources.Extensions EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{CFC1F91D-D493-4457-B189-E298BCC3F114}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{65E07631-ACAD-4BBD-A9B3-186A7B31B680}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{1C4E0357-1AA5-4DD4-B38F-2A2D10DE7872}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{E6F1606F-5731-44BA-B9F9-8FE32E2A4D84}" @@ -502,6 +504,27 @@ Global {CFC1F91D-D493-4457-B189-E298BCC3F114}.Checked|arm64.ActiveCfg = Debug|Any CPU {CFC1F91D-D493-4457-B189-E298BCC3F114}.Checked|x64.ActiveCfg = Debug|Any CPU {CFC1F91D-D493-4457-B189-E298BCC3F114}.Checked|x86.ActiveCfg = Debug|Any CPU + {65E07631-ACAD-4BBD-A9B3-186A7B31B680}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {65E07631-ACAD-4BBD-A9B3-186A7B31B680}.Debug|Any CPU.Build.0 = Debug|Any CPU + {65E07631-ACAD-4BBD-A9B3-186A7B31B680}.Debug|arm.ActiveCfg = Debug|Any CPU + {65E07631-ACAD-4BBD-A9B3-186A7B31B680}.Debug|arm64.ActiveCfg = Debug|Any CPU + {65E07631-ACAD-4BBD-A9B3-186A7B31B680}.Debug|x64.ActiveCfg = Debug|Any CPU + {65E07631-ACAD-4BBD-A9B3-186A7B31B680}.Debug|x64.Build.0 = Debug|Any CPU + {65E07631-ACAD-4BBD-A9B3-186A7B31B680}.Debug|x86.ActiveCfg = Debug|Any CPU + {65E07631-ACAD-4BBD-A9B3-186A7B31B680}.Debug|x86.Build.0 = Debug|Any CPU + {65E07631-ACAD-4BBD-A9B3-186A7B31B680}.Release|Any CPU.ActiveCfg = Release|Any CPU + {65E07631-ACAD-4BBD-A9B3-186A7B31B680}.Release|Any CPU.Build.0 = Release|Any CPU + {65E07631-ACAD-4BBD-A9B3-186A7B31B680}.Release|arm.ActiveCfg = Release|Any CPU + {65E07631-ACAD-4BBD-A9B3-186A7B31B680}.Release|arm64.ActiveCfg = Release|Any CPU + {65E07631-ACAD-4BBD-A9B3-186A7B31B680}.Release|x64.ActiveCfg = Release|Any CPU + {65E07631-ACAD-4BBD-A9B3-186A7B31B680}.Release|x64.Build.0 = Release|Any CPU + {65E07631-ACAD-4BBD-A9B3-186A7B31B680}.Release|x86.ActiveCfg = Release|Any CPU + {65E07631-ACAD-4BBD-A9B3-186A7B31B680}.Release|x86.Build.0 = Release|Any CPU + {65E07631-ACAD-4BBD-A9B3-186A7B31B680}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {65E07631-ACAD-4BBD-A9B3-186A7B31B680}.Checked|arm.ActiveCfg = Debug|Any CPU + {65E07631-ACAD-4BBD-A9B3-186A7B31B680}.Checked|arm64.ActiveCfg = Debug|Any CPU + {65E07631-ACAD-4BBD-A9B3-186A7B31B680}.Checked|x64.ActiveCfg = Debug|Any CPU + {65E07631-ACAD-4BBD-A9B3-186A7B31B680}.Checked|x86.ActiveCfg = Debug|Any CPU {1C4E0357-1AA5-4DD4-B38F-2A2D10DE7872}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {1C4E0357-1AA5-4DD4-B38F-2A2D10DE7872}.Debug|Any CPU.Build.0 = Debug|Any CPU {1C4E0357-1AA5-4DD4-B38F-2A2D10DE7872}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -761,6 +784,7 @@ Global {51182FA9-71D8-48D4-8461-63A04EDFDF77} = {F5B0A1AE-8B97-4B49-B5C8-8E63C6FAAED3} {C5F4AA26-CCDF-474B-911F-8204E69FC622} = {6DCAB55C-A3EE-46AB-94C0-57DBE27E2A22} {CFC1F91D-D493-4457-B189-E298BCC3F114} = {6DCAB55C-A3EE-46AB-94C0-57DBE27E2A22} + {65E07631-ACAD-4BBD-A9B3-186A7B31B680} = {6DCAB55C-A3EE-46AB-94C0-57DBE27E2A22} {1C4E0357-1AA5-4DD4-B38F-2A2D10DE7872} = {6DCAB55C-A3EE-46AB-94C0-57DBE27E2A22} {E6F1606F-5731-44BA-B9F9-8FE32E2A4D84} = {6DCAB55C-A3EE-46AB-94C0-57DBE27E2A22} {9CA5EAB9-D6EA-428D-A7C9-9E5901293123} = {CB23059A-3642-4B70-84F3-5D5BD57E0561} diff --git a/src/libraries/System.Resources.Extensions/src/System.Resources.Extensions.csproj b/src/libraries/System.Resources.Extensions/src/System.Resources.Extensions.csproj index 03f9bc0c11d..2bb3dab6a1b 100644 --- a/src/libraries/System.Resources.Extensions/src/System.Resources.Extensions.csproj +++ b/src/libraries/System.Resources.Extensions/src/System.Resources.Extensions.csproj @@ -17,6 +17,8 @@ System.Resources.Extensions.DeserializingResourceReader System.Resources.Extensions.PreserializedResourceWriter false + + $(NoWarn);SYSLIB5005 @@ -88,6 +90,10 @@ System.Resources.Extensions.PreserializedResourceWriter + + + + : SerializationTest where T : ISeri [Theory] [MemberData(nameof(SerializableObjects))] - [ActiveIssue("https://github.com/dotnet/runtime/issues/105020", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsPpc64leProcess))] public void DeserializeStoredObjects(object value, TypeSerializableValue[] serializedData) { // Following call may change the contents of the fields by invoking lazy-evaluated properties. diff --git a/src/libraries/System.Resources.Extensions/tests/BinaryFormatTests/FormattedObject/BasicObjectTests.cs b/src/libraries/System.Resources.Extensions/tests/BinaryFormatTests/FormattedObject/BasicObjectTests.cs index b316a3e32b5..fd5fdc9b8c0 100644 --- a/src/libraries/System.Resources.Extensions/tests/BinaryFormatTests/FormattedObject/BasicObjectTests.cs +++ b/src/libraries/System.Resources.Extensions/tests/BinaryFormatTests/FormattedObject/BasicObjectTests.cs @@ -14,6 +14,14 @@ public class BasicObjectTests : Common.BasicObjectTests))) + { + // We can root the provided value, but we can't root the deserialized value: + // GC can free the target of WeakReference after it gets deserialized, + // but before it gets returned from BinaryFormatter.Deserialize. + return; + } + // We need to round trip through the BinaryFormatter as a few objects in tests remove // serialized data on deserialization. BinaryFormatter formatter = new(); diff --git a/src/libraries/System.Resources.Extensions/tests/BinaryFormatTests/Legacy/BinaryFormatterTests.cs b/src/libraries/System.Resources.Extensions/tests/BinaryFormatTests/Legacy/BinaryFormatterTests.cs index 59cd5a2a0c7..fbd0544153a 100644 --- a/src/libraries/System.Resources.Extensions/tests/BinaryFormatTests/Legacy/BinaryFormatterTests.cs +++ b/src/libraries/System.Resources.Extensions/tests/BinaryFormatTests/Legacy/BinaryFormatterTests.cs @@ -20,7 +20,6 @@ public partial class BinaryFormatterTests { [Theory] [MemberData(nameof(SerializableObjects_MemberData))] - [ActiveIssue("https://github.com/dotnet/runtime/issues/105020", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsPpc64leProcess))] public void ValidateAgainstBlobs(object obj, TypeSerializableValue[] blobs) => ValidateAndRoundtrip(obj, blobs, isEqualityComparer: false); diff --git a/src/libraries/System.Resources.Extensions/tests/BinaryFormatTests/System.Resources.Extensions.BinaryFormat.Tests.csproj b/src/libraries/System.Resources.Extensions/tests/BinaryFormatTests/System.Resources.Extensions.BinaryFormat.Tests.csproj index 668bb0c91ee..3e4dc3aae71 100644 --- a/src/libraries/System.Resources.Extensions/tests/BinaryFormatTests/System.Resources.Extensions.BinaryFormat.Tests.csproj +++ b/src/libraries/System.Resources.Extensions/tests/BinaryFormatTests/System.Resources.Extensions.BinaryFormat.Tests.csproj @@ -8,8 +8,9 @@ SYSLIB0011: BinaryFormatter obsolete SYSLIB0050: Obsolete attribute SYSLIB0051: Formatters obsolete + SYSLIB5005: System.Formats.Nrbf experimental --> - $(NoWarn);CS1574;CS1580;CA1036;CA1051;CA1066;SYSLIB0011;SYSLIB0050;SYSLIB0051;xUnit1013;CS0649 + $(NoWarn);CS1574;CS1580;CA1036;CA1051;CA1066;SYSLIB0011;SYSLIB0050;SYSLIB0051;SYSLIB5005;xUnit1013;CS0649 $(LibrariesProjectRoot)\System.Resources.Extensions\src\Resources\Strings.resx @@ -32,12 +33,15 @@ - + - + + diff --git a/src/libraries/System.Resources.Extensions/tests/CompatTests/System.Resources.Extensions.Compat.Tests.csproj b/src/libraries/System.Resources.Extensions/tests/CompatTests/System.Resources.Extensions.Compat.Tests.csproj index e56833eb8b2..6f7bc5fd567 100644 --- a/src/libraries/System.Resources.Extensions/tests/CompatTests/System.Resources.Extensions.Compat.Tests.csproj +++ b/src/libraries/System.Resources.Extensions/tests/CompatTests/System.Resources.Extensions.Compat.Tests.csproj @@ -18,16 +18,16 @@ - - + + + - - - diff --git a/src/libraries/System.Resources.Extensions/tests/System.Resources.Extensions.Tests.csproj b/src/libraries/System.Resources.Extensions/tests/System.Resources.Extensions.Tests.csproj index d9fb191bb69..4ef8e28d3d6 100644 --- a/src/libraries/System.Resources.Extensions/tests/System.Resources.Extensions.Tests.csproj +++ b/src/libraries/System.Resources.Extensions/tests/System.Resources.Extensions.Tests.csproj @@ -21,7 +21,10 @@ - + + diff --git a/src/libraries/System.Resources.Writer/System.Resources.Writer.sln b/src/libraries/System.Resources.Writer/System.Resources.Writer.sln index 696d00e0d58..5ec2f26b542 100644 --- a/src/libraries/System.Resources.Writer/System.Resources.Writer.sln +++ b/src/libraries/System.Resources.Writer/System.Resources.Writer.sln @@ -7,7 +7,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Resources.Writer", " EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Resources.Writer.Tests", "tests\System.Resources.Writer.Tests.csproj", "{2E27487F-36D6-42E9-BA91-F511686122E7}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{5596D7DF-5577-4349-A688-0B014626A7E4}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{6233525C-09FB-419C-A9FE-7CA3EDAAE7E2}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{4EA24626-EACB-49F0-92EC-89502E566053}" EndProject @@ -61,10 +61,10 @@ Global {2E27487F-36D6-42E9-BA91-F511686122E7}.Debug|Any CPU.Build.0 = Debug|Any CPU {2E27487F-36D6-42E9-BA91-F511686122E7}.Release|Any CPU.ActiveCfg = Release|Any CPU {2E27487F-36D6-42E9-BA91-F511686122E7}.Release|Any CPU.Build.0 = Release|Any CPU - {5596D7DF-5577-4349-A688-0B014626A7E4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {5596D7DF-5577-4349-A688-0B014626A7E4}.Debug|Any CPU.Build.0 = Debug|Any CPU - {5596D7DF-5577-4349-A688-0B014626A7E4}.Release|Any CPU.ActiveCfg = Release|Any CPU - {5596D7DF-5577-4349-A688-0B014626A7E4}.Release|Any CPU.Build.0 = Release|Any CPU + {6233525C-09FB-419C-A9FE-7CA3EDAAE7E2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {6233525C-09FB-419C-A9FE-7CA3EDAAE7E2}.Debug|Any CPU.Build.0 = Debug|Any CPU + {6233525C-09FB-419C-A9FE-7CA3EDAAE7E2}.Release|Any CPU.ActiveCfg = Release|Any CPU + {6233525C-09FB-419C-A9FE-7CA3EDAAE7E2}.Release|Any CPU.Build.0 = Release|Any CPU {4EA24626-EACB-49F0-92EC-89502E566053}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {4EA24626-EACB-49F0-92EC-89502E566053}.Debug|Any CPU.Build.0 = Debug|Any CPU {4EA24626-EACB-49F0-92EC-89502E566053}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -103,7 +103,7 @@ Global {DF70E82A-3986-4E74-BF85-7CB4B0A6DED9} = {36F1D0ED-0960-4B7E-832F-F2A304803FC3} {45BE69F2-B543-4056-AF6C-6A711949A7FA} = {36F1D0ED-0960-4B7E-832F-F2A304803FC3} {1C001837-6F9D-4C5A-94B4-4388225C34B5} = {E6EE9961-9C9A-4935-8AE2-18316677F47F} - {5596D7DF-5577-4349-A688-0B014626A7E4} = {AB6CB51B-36BD-4444-BB33-86DADD78045C} + {6233525C-09FB-419C-A9FE-7CA3EDAAE7E2} = {AB6CB51B-36BD-4444-BB33-86DADD78045C} {4EA24626-EACB-49F0-92EC-89502E566053} = {AB6CB51B-36BD-4444-BB33-86DADD78045C} {F3E0DF20-021F-420C-BB37-D0DDC5BBC58A} = {5A32D0DE-B833-4139-86DD-EA6B71B3AEED} {B2EE67CB-0282-4C1D-8EFE-F09897906C83} = {5A32D0DE-B833-4139-86DD-EA6B71B3AEED} diff --git a/src/libraries/System.Runtime.Caching/Directory.Build.props b/src/libraries/System.Runtime.Caching/Directory.Build.props index d68d22c1b91..0232329ad31 100644 --- a/src/libraries/System.Runtime.Caching/Directory.Build.props +++ b/src/libraries/System.Runtime.Caching/Directory.Build.props @@ -3,5 +3,7 @@ Microsoft true + + wasi \ No newline at end of file diff --git a/src/libraries/System.Runtime.Caching/System.Runtime.Caching.sln b/src/libraries/System.Runtime.Caching/System.Runtime.Caching.sln index 16f1476545b..42ea250cc62 100644 --- a/src/libraries/System.Runtime.Caching/System.Runtime.Caching.sln +++ b/src/libraries/System.Runtime.Caching/System.Runtime.Caching.sln @@ -27,6 +27,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Runtime.Caching", "s EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Runtime.Caching.Tests", "tests\System.Runtime.Caching.Tests.csproj", "{AA05074D-88AF-482E-A44A-F1AC13494E9F}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{929AC946-C450-4886-9383-AA95155BCE75}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{B76EE305-CA7C-494C-8374-ABD93081F6AE}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{447797DB-DF70-4568-A323-F88A45A91026}" @@ -395,6 +397,27 @@ Global {AA05074D-88AF-482E-A44A-F1AC13494E9F}.Checked|arm64.ActiveCfg = Debug|Any CPU {AA05074D-88AF-482E-A44A-F1AC13494E9F}.Checked|x64.ActiveCfg = Debug|Any CPU {AA05074D-88AF-482E-A44A-F1AC13494E9F}.Checked|x86.ActiveCfg = Debug|Any CPU + {929AC946-C450-4886-9383-AA95155BCE75}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {929AC946-C450-4886-9383-AA95155BCE75}.Debug|Any CPU.Build.0 = Debug|Any CPU + {929AC946-C450-4886-9383-AA95155BCE75}.Debug|arm.ActiveCfg = Debug|Any CPU + {929AC946-C450-4886-9383-AA95155BCE75}.Debug|arm64.ActiveCfg = Debug|Any CPU + {929AC946-C450-4886-9383-AA95155BCE75}.Debug|x64.ActiveCfg = Debug|Any CPU + {929AC946-C450-4886-9383-AA95155BCE75}.Debug|x64.Build.0 = Debug|Any CPU + {929AC946-C450-4886-9383-AA95155BCE75}.Debug|x86.ActiveCfg = Debug|Any CPU + {929AC946-C450-4886-9383-AA95155BCE75}.Debug|x86.Build.0 = Debug|Any CPU + {929AC946-C450-4886-9383-AA95155BCE75}.Release|Any CPU.ActiveCfg = Release|Any CPU + {929AC946-C450-4886-9383-AA95155BCE75}.Release|Any CPU.Build.0 = Release|Any CPU + {929AC946-C450-4886-9383-AA95155BCE75}.Release|arm.ActiveCfg = Release|Any CPU + {929AC946-C450-4886-9383-AA95155BCE75}.Release|arm64.ActiveCfg = Release|Any CPU + {929AC946-C450-4886-9383-AA95155BCE75}.Release|x64.ActiveCfg = Release|Any CPU + {929AC946-C450-4886-9383-AA95155BCE75}.Release|x64.Build.0 = Release|Any CPU + {929AC946-C450-4886-9383-AA95155BCE75}.Release|x86.ActiveCfg = Release|Any CPU + {929AC946-C450-4886-9383-AA95155BCE75}.Release|x86.Build.0 = Release|Any CPU + {929AC946-C450-4886-9383-AA95155BCE75}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {929AC946-C450-4886-9383-AA95155BCE75}.Checked|arm.ActiveCfg = Debug|Any CPU + {929AC946-C450-4886-9383-AA95155BCE75}.Checked|arm64.ActiveCfg = Debug|Any CPU + {929AC946-C450-4886-9383-AA95155BCE75}.Checked|x64.ActiveCfg = Debug|Any CPU + {929AC946-C450-4886-9383-AA95155BCE75}.Checked|x86.ActiveCfg = Debug|Any CPU {B76EE305-CA7C-494C-8374-ABD93081F6AE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {B76EE305-CA7C-494C-8374-ABD93081F6AE}.Debug|Any CPU.Build.0 = Debug|Any CPU {B76EE305-CA7C-494C-8374-ABD93081F6AE}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -737,6 +760,7 @@ Global {45E0A981-A131-4147-94E7-49AAC45F5D14} = {C315269F-EEA6-4F74-BA10-65ECAA6351C8} {A154C9F1-845A-4596-9061-92C462E971A6} = {C315269F-EEA6-4F74-BA10-65ECAA6351C8} {7D95B81C-25A6-4E6A-88E9-A8BBE59538BE} = {5E28270B-1EEB-4D0E-9A3C-6959BEA9647E} + {929AC946-C450-4886-9383-AA95155BCE75} = {5E28270B-1EEB-4D0E-9A3C-6959BEA9647E} {B76EE305-CA7C-494C-8374-ABD93081F6AE} = {5E28270B-1EEB-4D0E-9A3C-6959BEA9647E} {447797DB-DF70-4568-A323-F88A45A91026} = {5E28270B-1EEB-4D0E-9A3C-6959BEA9647E} {EA4D9319-C5FB-4829-BB2F-E0FAA1DE79E3} = {191AA172-B1CF-40FE-8B10-707FF5A6684F} diff --git a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/HostFileChangeMonitor.cs b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/HostFileChangeMonitor.cs index 374ff288ea0..c14de7b5d2c 100644 --- a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/HostFileChangeMonitor.cs +++ b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/HostFileChangeMonitor.cs @@ -99,7 +99,7 @@ private static void InitFCN() if (fcn == null) { #if NET - if (OperatingSystem.IsBrowser() || (OperatingSystem.IsIOS() && !OperatingSystem.IsMacCatalyst()) || OperatingSystem.IsTvOS()) + if (OperatingSystem.IsBrowser() || OperatingSystem.IsWasi() || (OperatingSystem.IsIOS() && !OperatingSystem.IsMacCatalyst()) || OperatingSystem.IsTvOS()) { throw new PlatformNotSupportedException(); } diff --git a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCache.cs b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCache.cs index aed16512d0d..5ec63c2f65e 100644 --- a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCache.cs +++ b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCache.cs @@ -39,8 +39,9 @@ public class MemoryCache : ObjectCache, IEnumerable, IDisposable private bool _useMemoryCacheManager = true; private bool _throwOnDisposed; #if NET + [UnsupportedOSPlatformGuard("wasi")] [UnsupportedOSPlatformGuard("browser")] - private static bool _countersSupported => !OperatingSystem.IsBrowser(); + private static bool _countersSupported => !OperatingSystem.IsBrowser() && !OperatingSystem.IsWasi(); #else private static bool _countersSupported => true; #endif diff --git a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCacheStatistics.cs b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCacheStatistics.cs index dba747c4acd..634270e09a9 100644 --- a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCacheStatistics.cs +++ b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCacheStatistics.cs @@ -38,8 +38,9 @@ internal sealed class MemoryCacheStatistics : IDisposable private readonly MemoryCache _memoryCache; private readonly PhysicalMemoryMonitor _physicalMemoryMonitor; #if NET + [UnsupportedOSPlatformGuard("wasi")] [UnsupportedOSPlatformGuard("browser")] - private static bool _configSupported => !OperatingSystem.IsBrowser(); + private static bool _configSupported => !OperatingSystem.IsBrowser() && !OperatingSystem.IsWasi(); #else private static bool _configSupported => true; #endif diff --git a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCacheStore.cs b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCacheStore.cs index 146935b54ba..24a9821a75c 100644 --- a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCacheStore.cs +++ b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/MemoryCacheStore.cs @@ -27,8 +27,9 @@ internal sealed class MemoryCacheStore : IDisposable private readonly MemoryCache _cache; private readonly Counters _perfCounters; #if NET + [UnsupportedOSPlatformGuard("wasi")] [UnsupportedOSPlatformGuard("browser")] - private static bool _countersSupported => !OperatingSystem.IsBrowser(); + private static bool _countersSupported => !OperatingSystem.IsBrowser() && !OperatingSystem.IsWasi(); #else private static bool _countersSupported => true; #endif diff --git a/src/libraries/System.Runtime.CompilerServices.VisualC/System.Runtime.CompilerServices.VisualC.sln b/src/libraries/System.Runtime.CompilerServices.VisualC/System.Runtime.CompilerServices.VisualC.sln index 988d2c5b7dc..cf7b25f353b 100644 --- a/src/libraries/System.Runtime.CompilerServices.VisualC/System.Runtime.CompilerServices.VisualC.sln +++ b/src/libraries/System.Runtime.CompilerServices.VisualC/System.Runtime.CompilerServices.VisualC.sln @@ -7,7 +7,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Runtime.CompilerServ EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Runtime.CompilerServices.VisualC.Tests", "tests\System.Runtime.CompilerServices.VisualC.Tests.csproj", "{11D31B6C-3ECF-472B-8AD5-3D799BA3F052}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{8DBC1B4C-6689-429E-9315-1D935BC8A26E}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{B8044FDE-5B2A-47C6-98D3-886F4085DDEF}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{61212F97-E2E3-4602-BDBC-B0BB4C3C7AFD}" EndProject @@ -61,10 +61,10 @@ Global {11D31B6C-3ECF-472B-8AD5-3D799BA3F052}.Debug|Any CPU.Build.0 = Debug|Any CPU {11D31B6C-3ECF-472B-8AD5-3D799BA3F052}.Release|Any CPU.ActiveCfg = Release|Any CPU {11D31B6C-3ECF-472B-8AD5-3D799BA3F052}.Release|Any CPU.Build.0 = Release|Any CPU - {8DBC1B4C-6689-429E-9315-1D935BC8A26E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {8DBC1B4C-6689-429E-9315-1D935BC8A26E}.Debug|Any CPU.Build.0 = Debug|Any CPU - {8DBC1B4C-6689-429E-9315-1D935BC8A26E}.Release|Any CPU.ActiveCfg = Release|Any CPU - {8DBC1B4C-6689-429E-9315-1D935BC8A26E}.Release|Any CPU.Build.0 = Release|Any CPU + {B8044FDE-5B2A-47C6-98D3-886F4085DDEF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {B8044FDE-5B2A-47C6-98D3-886F4085DDEF}.Debug|Any CPU.Build.0 = Debug|Any CPU + {B8044FDE-5B2A-47C6-98D3-886F4085DDEF}.Release|Any CPU.ActiveCfg = Release|Any CPU + {B8044FDE-5B2A-47C6-98D3-886F4085DDEF}.Release|Any CPU.Build.0 = Release|Any CPU {61212F97-E2E3-4602-BDBC-B0BB4C3C7AFD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {61212F97-E2E3-4602-BDBC-B0BB4C3C7AFD}.Debug|Any CPU.Build.0 = Debug|Any CPU {61212F97-E2E3-4602-BDBC-B0BB4C3C7AFD}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -103,7 +103,7 @@ Global {6157FC12-0BEC-4A23-80F0-FBC8A8C71E22} = {65453C51-F488-4026-9596-05F765899247} {A60F4450-369D-4DF2-8FC0-462518A81DB9} = {65453C51-F488-4026-9596-05F765899247} {941D72C5-CA37-4745-B89D-2257517C5761} = {27ADCE48-E139-48C1-A838-A0B8FBDECF95} - {8DBC1B4C-6689-429E-9315-1D935BC8A26E} = {07A6E36B-25A7-47FD-A399-7A722EABF7DF} + {B8044FDE-5B2A-47C6-98D3-886F4085DDEF} = {07A6E36B-25A7-47FD-A399-7A722EABF7DF} {61212F97-E2E3-4602-BDBC-B0BB4C3C7AFD} = {07A6E36B-25A7-47FD-A399-7A722EABF7DF} {A30BAAF3-634E-4E4F-B313-8C3FC945D577} = {E9DFE769-521F-426B-907D-F861F607401E} {8AB4F59A-F763-4673-8B43-C2745E0A8135} = {E9DFE769-521F-426B-907D-F861F607401E} diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/System.Runtime.InteropServices.JavaScript.sln b/src/libraries/System.Runtime.InteropServices.JavaScript/System.Runtime.InteropServices.JavaScript.sln index 4c19df1d78c..9be1cf583e2 100644 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/System.Runtime.InteropServices.JavaScript.sln +++ b/src/libraries/System.Runtime.InteropServices.JavaScript/System.Runtime.InteropServices.JavaScript.sln @@ -31,6 +31,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "JSImportGenerator.Unit.Test EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Runtime.InteropServices.JavaScript.Tests", "tests\System.Runtime.InteropServices.JavaScript.UnitTests\System.Runtime.InteropServices.JavaScript.Tests.csproj", "{765B4AA5-723A-44FF-BC4E-EB0F03103F6D}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{DE207B2C-A0CC-47C8-AC20-46A8C0970287}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{09AA6758-0BD3-4312-9C07-AE9F1D50A3AD}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{B4E3E774-2C16-4CBF-87EF-88C547529B94}" @@ -63,19 +65,19 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Mono.Linker", "..\..\tools\ EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Mono.Linker", "..\..\tools\illink\src\linker\ref\Mono.Linker.csproj", "{008873D5-9028-4FF3-8354-71F713748625}" EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{D819DEB6-6F6B-484B-9F0F-BDBCEDC83A1A}" +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{32733782-56D6-4EAF-B94E-5D10C759DD57}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{26A72FFB-871A-4F2F-A513-B2F6E09F358C}" EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ref", "ref", "{32CDDDCD-5319-494C-AB41-42B87C467F04}" +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ref", "ref", "{19EA33B4-0E87-451F-95E3-8F3959117654}" EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "gen", "gen", "{39B30F44-B141-44E9-B7A7-B1A9EDB1A61C}" +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "gen", "gen", "{1A04C5D7-1DE9-47C3-BCC1-147678B9085F}" EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "gen", "tools\gen", "{1A04C5D7-1DE9-47C3-BCC1-147678B9085F}" +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "gen", "tools\gen", "{F81BA54D-38C5-4493-BB5C-344825706D3A}" EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "tools\src", "{32733782-56D6-4EAF-B94E-5D10C759DD57}" +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "tools\src", "{F0448246-E8A1-49FD-878C-7A6B8486A66B}" EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ref", "tools\ref", "{19EA33B4-0E87-451F-95E3-8F3959117654}" +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ref", "tools\ref", "{9BB52E31-4890-4F4B-8B2B-6282EF13B8D2}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tools", "tools", "{7392B838-42AF-4F54-AD02-366397DAF640}" EndProject @@ -443,6 +445,27 @@ Global {765B4AA5-723A-44FF-BC4E-EB0F03103F6D}.Checked|arm64.ActiveCfg = Debug|Any CPU {765B4AA5-723A-44FF-BC4E-EB0F03103F6D}.Checked|x64.ActiveCfg = Debug|Any CPU {765B4AA5-723A-44FF-BC4E-EB0F03103F6D}.Checked|x86.ActiveCfg = Debug|Any CPU + {DE207B2C-A0CC-47C8-AC20-46A8C0970287}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {DE207B2C-A0CC-47C8-AC20-46A8C0970287}.Debug|Any CPU.Build.0 = Debug|Any CPU + {DE207B2C-A0CC-47C8-AC20-46A8C0970287}.Debug|arm.ActiveCfg = Debug|Any CPU + {DE207B2C-A0CC-47C8-AC20-46A8C0970287}.Debug|arm64.ActiveCfg = Debug|Any CPU + {DE207B2C-A0CC-47C8-AC20-46A8C0970287}.Debug|x64.ActiveCfg = Debug|Any CPU + {DE207B2C-A0CC-47C8-AC20-46A8C0970287}.Debug|x64.Build.0 = Debug|Any CPU + {DE207B2C-A0CC-47C8-AC20-46A8C0970287}.Debug|x86.ActiveCfg = Debug|Any CPU + {DE207B2C-A0CC-47C8-AC20-46A8C0970287}.Debug|x86.Build.0 = Debug|Any CPU + {DE207B2C-A0CC-47C8-AC20-46A8C0970287}.Release|Any CPU.ActiveCfg = Release|Any CPU + {DE207B2C-A0CC-47C8-AC20-46A8C0970287}.Release|Any CPU.Build.0 = Release|Any CPU + {DE207B2C-A0CC-47C8-AC20-46A8C0970287}.Release|arm.ActiveCfg = Release|Any CPU + {DE207B2C-A0CC-47C8-AC20-46A8C0970287}.Release|arm64.ActiveCfg = Release|Any CPU + {DE207B2C-A0CC-47C8-AC20-46A8C0970287}.Release|x64.ActiveCfg = Release|Any CPU + {DE207B2C-A0CC-47C8-AC20-46A8C0970287}.Release|x64.Build.0 = Release|Any CPU + {DE207B2C-A0CC-47C8-AC20-46A8C0970287}.Release|x86.ActiveCfg = Release|Any CPU + {DE207B2C-A0CC-47C8-AC20-46A8C0970287}.Release|x86.Build.0 = Release|Any CPU + {DE207B2C-A0CC-47C8-AC20-46A8C0970287}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {DE207B2C-A0CC-47C8-AC20-46A8C0970287}.Checked|arm.ActiveCfg = Debug|Any CPU + {DE207B2C-A0CC-47C8-AC20-46A8C0970287}.Checked|arm64.ActiveCfg = Debug|Any CPU + {DE207B2C-A0CC-47C8-AC20-46A8C0970287}.Checked|x64.ActiveCfg = Debug|Any CPU + {DE207B2C-A0CC-47C8-AC20-46A8C0970287}.Checked|x86.ActiveCfg = Debug|Any CPU {09AA6758-0BD3-4312-9C07-AE9F1D50A3AD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {09AA6758-0BD3-4312-9C07-AE9F1D50A3AD}.Debug|Any CPU.Build.0 = Debug|Any CPU {09AA6758-0BD3-4312-9C07-AE9F1D50A3AD}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -784,41 +807,42 @@ Global HideSolutionNode = FALSE EndGlobalSection GlobalSection(NestedProjects) = preSolution - {0F7BA062-C34C-41A8-840F-F0B074B18686} = {D819DEB6-6F6B-484B-9F0F-BDBCEDC83A1A} - {FC1007CC-9E52-49B7-A47B-A8AE76E75986} = {D819DEB6-6F6B-484B-9F0F-BDBCEDC83A1A} - {B79E5BB4-2595-48BC-A44C-0A7949AFBDEB} = {D819DEB6-6F6B-484B-9F0F-BDBCEDC83A1A} - {C1C606F3-A246-4EA0-A467-3AC4F31C2AFE} = {D819DEB6-6F6B-484B-9F0F-BDBCEDC83A1A} - {74143A5F-6987-4AB5-B786-DE358F01241B} = {D819DEB6-6F6B-484B-9F0F-BDBCEDC83A1A} - {71A845ED-4344-41FC-8FCA-3AC9B6BA6C45} = {D819DEB6-6F6B-484B-9F0F-BDBCEDC83A1A} - {1EB2EBE2-12EA-4545-B390-098F083329A1} = {D819DEB6-6F6B-484B-9F0F-BDBCEDC83A1A} - {04A40E6C-DD10-473D-AFF8-9033E936DC46} = {D819DEB6-6F6B-484B-9F0F-BDBCEDC83A1A} - {424A7718-F5B7-41FB-A74B-1E23A9BF13EA} = {D819DEB6-6F6B-484B-9F0F-BDBCEDC83A1A} - {8683B814-5459-4412-A881-ECAFF9ED1781} = {D819DEB6-6F6B-484B-9F0F-BDBCEDC83A1A} + {0F7BA062-C34C-41A8-840F-F0B074B18686} = {32733782-56D6-4EAF-B94E-5D10C759DD57} + {FC1007CC-9E52-49B7-A47B-A8AE76E75986} = {32733782-56D6-4EAF-B94E-5D10C759DD57} + {B79E5BB4-2595-48BC-A44C-0A7949AFBDEB} = {32733782-56D6-4EAF-B94E-5D10C759DD57} + {C1C606F3-A246-4EA0-A467-3AC4F31C2AFE} = {32733782-56D6-4EAF-B94E-5D10C759DD57} + {74143A5F-6987-4AB5-B786-DE358F01241B} = {32733782-56D6-4EAF-B94E-5D10C759DD57} + {71A845ED-4344-41FC-8FCA-3AC9B6BA6C45} = {32733782-56D6-4EAF-B94E-5D10C759DD57} + {1EB2EBE2-12EA-4545-B390-098F083329A1} = {32733782-56D6-4EAF-B94E-5D10C759DD57} + {04A40E6C-DD10-473D-AFF8-9033E936DC46} = {32733782-56D6-4EAF-B94E-5D10C759DD57} + {424A7718-F5B7-41FB-A74B-1E23A9BF13EA} = {32733782-56D6-4EAF-B94E-5D10C759DD57} + {8683B814-5459-4412-A881-ECAFF9ED1781} = {32733782-56D6-4EAF-B94E-5D10C759DD57} {ED86AB26-1CFB-457D-BF87-B7A0D8FAF272} = {26A72FFB-871A-4F2F-A513-B2F6E09F358C} {E6A30001-84E3-4C7A-9B56-B9DEA71B3CF9} = {26A72FFB-871A-4F2F-A513-B2F6E09F358C} {BFED925C-18F2-4C98-833E-66F205234598} = {26A72FFB-871A-4F2F-A513-B2F6E09F358C} {765B4AA5-723A-44FF-BC4E-EB0F03103F6D} = {26A72FFB-871A-4F2F-A513-B2F6E09F358C} {EC3ADEFA-1FF3-482C-8CCB-FE4C77292532} = {26A72FFB-871A-4F2F-A513-B2F6E09F358C} - {8B1D80E9-AE0D-4E3C-9F91-E6862B49AEF3} = {32CDDDCD-5319-494C-AB41-42B87C467F04} - {E00AE8BB-7C7F-4D07-949D-EDCC815AC8C8} = {32CDDDCD-5319-494C-AB41-42B87C467F04} - {D549C13B-FC0D-4B5A-B50D-8F74CB5A3D08} = {32CDDDCD-5319-494C-AB41-42B87C467F04} - {28278E01-BF5C-4AB6-AA7A-8DD4E6C04DB1} = {32CDDDCD-5319-494C-AB41-42B87C467F04} - {44BAE6F1-94C2-415B-9A16-3B8EC429B09B} = {32CDDDCD-5319-494C-AB41-42B87C467F04} - {B18C5A3A-CAB0-4B62-9C01-7A046E05089F} = {32CDDDCD-5319-494C-AB41-42B87C467F04} - {B86E4599-88CF-4662-96BA-3FCB926D0BA1} = {32CDDDCD-5319-494C-AB41-42B87C467F04} - {D620CBA3-326B-4E4A-81C2-3D9E9258E45C} = {32CDDDCD-5319-494C-AB41-42B87C467F04} - {8CFB1155-26A2-43E3-B192-1F87D9E543AC} = {39B30F44-B141-44E9-B7A7-B1A9EDB1A61C} - {CE5E53C1-F9B5-41EE-8D00-837913EC57D1} = {39B30F44-B141-44E9-B7A7-B1A9EDB1A61C} - {09AA6758-0BD3-4312-9C07-AE9F1D50A3AD} = {39B30F44-B141-44E9-B7A7-B1A9EDB1A61C} - {B4E3E774-2C16-4CBF-87EF-88C547529B94} = {39B30F44-B141-44E9-B7A7-B1A9EDB1A61C} - {4D8B7538-D933-4F3A-818D-4E19ABA7E182} = {1A04C5D7-1DE9-47C3-BCC1-147678B9085F} - {6C60944F-4FE1-450F-884B-D523EDFCFAB3} = {1A04C5D7-1DE9-47C3-BCC1-147678B9085F} - {1A04C5D7-1DE9-47C3-BCC1-147678B9085F} = {7392B838-42AF-4F54-AD02-366397DAF640} - {B8F2E56D-6571-466D-9EF2-9FCAD3FC6E5B} = {32733782-56D6-4EAF-B94E-5D10C759DD57} - {42F9A600-BEC3-4F87-97EE-38E0DCAABC5A} = {32733782-56D6-4EAF-B94E-5D10C759DD57} - {32733782-56D6-4EAF-B94E-5D10C759DD57} = {7392B838-42AF-4F54-AD02-366397DAF640} - {008873D5-9028-4FF3-8354-71F713748625} = {19EA33B4-0E87-451F-95E3-8F3959117654} - {19EA33B4-0E87-451F-95E3-8F3959117654} = {7392B838-42AF-4F54-AD02-366397DAF640} + {8B1D80E9-AE0D-4E3C-9F91-E6862B49AEF3} = {19EA33B4-0E87-451F-95E3-8F3959117654} + {E00AE8BB-7C7F-4D07-949D-EDCC815AC8C8} = {19EA33B4-0E87-451F-95E3-8F3959117654} + {D549C13B-FC0D-4B5A-B50D-8F74CB5A3D08} = {19EA33B4-0E87-451F-95E3-8F3959117654} + {28278E01-BF5C-4AB6-AA7A-8DD4E6C04DB1} = {19EA33B4-0E87-451F-95E3-8F3959117654} + {44BAE6F1-94C2-415B-9A16-3B8EC429B09B} = {19EA33B4-0E87-451F-95E3-8F3959117654} + {B18C5A3A-CAB0-4B62-9C01-7A046E05089F} = {19EA33B4-0E87-451F-95E3-8F3959117654} + {B86E4599-88CF-4662-96BA-3FCB926D0BA1} = {19EA33B4-0E87-451F-95E3-8F3959117654} + {D620CBA3-326B-4E4A-81C2-3D9E9258E45C} = {19EA33B4-0E87-451F-95E3-8F3959117654} + {8CFB1155-26A2-43E3-B192-1F87D9E543AC} = {1A04C5D7-1DE9-47C3-BCC1-147678B9085F} + {CE5E53C1-F9B5-41EE-8D00-837913EC57D1} = {1A04C5D7-1DE9-47C3-BCC1-147678B9085F} + {DE207B2C-A0CC-47C8-AC20-46A8C0970287} = {1A04C5D7-1DE9-47C3-BCC1-147678B9085F} + {09AA6758-0BD3-4312-9C07-AE9F1D50A3AD} = {1A04C5D7-1DE9-47C3-BCC1-147678B9085F} + {B4E3E774-2C16-4CBF-87EF-88C547529B94} = {1A04C5D7-1DE9-47C3-BCC1-147678B9085F} + {4D8B7538-D933-4F3A-818D-4E19ABA7E182} = {F81BA54D-38C5-4493-BB5C-344825706D3A} + {6C60944F-4FE1-450F-884B-D523EDFCFAB3} = {F81BA54D-38C5-4493-BB5C-344825706D3A} + {F81BA54D-38C5-4493-BB5C-344825706D3A} = {7392B838-42AF-4F54-AD02-366397DAF640} + {B8F2E56D-6571-466D-9EF2-9FCAD3FC6E5B} = {F0448246-E8A1-49FD-878C-7A6B8486A66B} + {42F9A600-BEC3-4F87-97EE-38E0DCAABC5A} = {F0448246-E8A1-49FD-878C-7A6B8486A66B} + {F0448246-E8A1-49FD-878C-7A6B8486A66B} = {7392B838-42AF-4F54-AD02-366397DAF640} + {008873D5-9028-4FF3-8354-71F713748625} = {9BB52E31-4890-4F4B-8B2B-6282EF13B8D2} + {9BB52E31-4890-4F4B-8B2B-6282EF13B8D2} = {7392B838-42AF-4F54-AD02-366397DAF640} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {3FE64246-4AFA-424A-AE5D-7007E20451B5} diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSExportCodeGenerator.cs b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSExportCodeGenerator.cs index c3708497005..33b08510d4f 100644 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSExportCodeGenerator.cs +++ b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSExportCodeGenerator.cs @@ -16,7 +16,8 @@ internal sealed class JSExportCodeGenerator : JSCodeGenerator { private readonly BoundGenerators _marshallers; - private readonly JSExportCodeContext _context; + private readonly StubIdentifierContext _context; + private readonly JSExportData _jsExportData; private readonly JSSignatureContext _signatureContext; public JSExportCodeGenerator( @@ -27,33 +28,35 @@ public JSExportCodeGenerator( IMarshallingGeneratorResolver generatorResolver) { _signatureContext = signatureContext; - NativeToManagedStubCodeContext innerContext = new NativeToManagedStubCodeContext(ReturnIdentifier, ReturnIdentifier) - { - CodeEmitOptions = new(SkipInit: true) - }; - _context = new JSExportCodeContext(attributeData, innerContext); + _jsExportData = attributeData; - _marshallers = BoundGenerators.Create(argTypes, generatorResolver, _context, new EmptyJSGenerator(), out var bindingFailures); + _marshallers = BoundGenerators.Create(argTypes, generatorResolver, StubCodeContext.DefaultNativeToManagedStub, new EmptyJSGenerator(), out var bindingFailures); diagnosticsBag.ReportGeneratorDiagnostics(bindingFailures); - if (_marshallers.ManagedReturnMarshaller.Generator.UsesNativeIdentifier(_marshallers.ManagedReturnMarshaller.TypeInfo, null)) + if (_marshallers.ManagedReturnMarshaller.UsesNativeIdentifier) { // If we need a different native return identifier, then recreate the context with the correct identifier before we generate any code. - innerContext = new NativeToManagedStubCodeContext(ReturnIdentifier, ReturnNativeIdentifier) + _context = new DefaultIdentifierContext(ReturnIdentifier, ReturnNativeIdentifier, MarshalDirection.UnmanagedToManaged) + { + CodeEmitOptions = new(SkipInit: true), + }; + } + else + { + _context = new DefaultIdentifierContext(ReturnIdentifier, ReturnIdentifier, MarshalDirection.UnmanagedToManaged) { - CodeEmitOptions = new(SkipInit: true) + CodeEmitOptions = new(SkipInit: true), }; - _context = new JSExportCodeContext(attributeData, innerContext); } // validate task + span mix if (_marshallers.ManagedReturnMarshaller.TypeInfo.MarshallingAttributeInfo is JSMarshallingInfo(_, JSTaskTypeInfo)) { - BoundGenerator spanArg = _marshallers.SignatureMarshallers.FirstOrDefault(m => m.TypeInfo.MarshallingAttributeInfo is JSMarshallingInfo(_, JSSpanTypeInfo)); + IBoundMarshallingGenerator spanArg = _marshallers.SignatureMarshallers.FirstOrDefault(m => m.TypeInfo.MarshallingAttributeInfo is JSMarshallingInfo(_, JSSpanTypeInfo)); if (spanArg != default) { - diagnosticsBag.ReportGeneratorDiagnostic(new GeneratorDiagnostic.NotSupported(spanArg.TypeInfo, _context) + diagnosticsBag.ReportGeneratorDiagnostic(new GeneratorDiagnostic.NotSupported(spanArg.TypeInfo) { NotSupportedDetails = SR.SpanAndTaskNotSupported }); @@ -160,8 +163,9 @@ public StatementSyntax GenerateJSExportRegistration() private ArgumentSyntax CreateSignaturesSyntax() { - var types = ((IJSMarshallingGenerator)_marshallers.ManagedReturnMarshaller.Generator).GenerateBind(_marshallers.ManagedReturnMarshaller.TypeInfo, _context) - .Concat(_marshallers.NativeParameterMarshallers.SelectMany(p => ((IJSMarshallingGenerator)p.Generator).GenerateBind(p.TypeInfo, _context))); + IEnumerable types = _marshallers.ManagedReturnMarshaller is IJSMarshallingGenerator jsGen ? jsGen.GenerateBind() : []; + types = types + .Concat(_marshallers.NativeParameterMarshallers.OfType().SelectMany(p => p.GenerateBind())); return Argument(ArrayCreationExpression(ArrayType(IdentifierName(Constants.JSMarshalerTypeGlobal)) .WithRankSpecifiers(SingletonList(ArrayRankSpecifier(SingletonSeparatedList(OmittedArraySizeExpression()))))) @@ -170,7 +174,7 @@ private ArgumentSyntax CreateSignaturesSyntax() private void SetupSyntax(List statementsToUpdate) { - foreach (BoundGenerator marshaller in _marshallers.NativeParameterMarshallers) + foreach (IBoundMarshallingGenerator marshaller in _marshallers.NativeParameterMarshallers) { statementsToUpdate.Add(LocalDeclarationStatement(VariableDeclaration(marshaller.TypeInfo.ManagedType.Syntax) .WithVariables(SingletonSeparatedList(VariableDeclarator(marshaller.TypeInfo.InstanceIdentifier))))); @@ -195,10 +199,10 @@ private List InvokeSyntax() var arguments = new List(); // Generate code for each parameter for the current stage - foreach (BoundGenerator marshaller in _marshallers.NativeParameterMarshallers) + foreach (IBoundMarshallingGenerator marshaller in _marshallers.NativeParameterMarshallers) { // convert arguments for invocation - statements.AddRange(marshaller.Generator.Generate(marshaller.TypeInfo, _context)); + statements.AddRange(marshaller.Generate(_context)); arguments.Add(Argument(IdentifierName(marshaller.TypeInfo.InstanceIdentifier))); } diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSExportGenerator.cs b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSExportGenerator.cs index 85bd2550a03..ff7d4a40441 100644 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSExportGenerator.cs +++ b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSExportGenerator.cs @@ -120,13 +120,15 @@ public void Initialize(IncrementalGeneratorInitializationContext context) StringBuilder source = new(); // Mark in source that the file is auto-generated. - source.AppendLine("// "); + source.Append("// \r\n"); // this is the assembly level registration - source.AppendLine(generatedSources[0].Item2); + source.Append(generatedSources[0].Item2); + source.Append("\r\n"); // this is the method wrappers to be called from JS foreach (var generated in generatedSources) { - source.AppendLine(generated.Item1); + source.Append(generated.Item1); + source.Append("\r\n"); } // Once https://github.com/dotnet/roslyn/issues/61326 is resolved, we can avoid the ToString() here. diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSGeneratorFactory.cs b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSGeneratorFactory.cs index 16f2dda426a..f5f61c413bc 100644 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSGeneratorFactory.cs +++ b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSGeneratorFactory.cs @@ -19,7 +19,7 @@ public ResolvedGenerator Create(TypePositionInfo info, StubCodeContext context) if (info.IsByRef || info.ByValueContentsMarshalKind != ByValueContentsMarshalKind.Default) { // out of scope for Net7.0 - return ResolvedGenerator.NotSupported(new(info, context) + return ResolvedGenerator.NotSupported(info, context, new(info) { NotSupportedDetails = SR.InOutRefNotSupported }); @@ -28,27 +28,27 @@ public ResolvedGenerator Create(TypePositionInfo info, StubCodeContext context) ResolvedGenerator fail(string failReason) { - return ResolvedGenerator.NotSupported(new(info, context) + return ResolvedGenerator.NotSupported(info, context, new(info) { NotSupportedDetails = failReason }); } - bool isToJs = info.ManagedIndex != TypePositionInfo.ReturnIndex ^ context is JSExportCodeContext; + bool isToJs = info.ManagedIndex != TypePositionInfo.ReturnIndex ^ context.Direction == MarshalDirection.UnmanagedToManaged; switch (jsMarshalingInfo) { // invalid case { TypeInfo: JSInvalidTypeInfo }: - return ResolvedGenerator.NotSupported(new(info, context)); + return ResolvedGenerator.NotSupported(info, context, new(info)); // void case { TypeInfo: JSSimpleTypeInfo(KnownManagedType.Void), JSType: JSTypeFlags.DiscardNoWait }: - return ResolvedGenerator.Resolved(new VoidGenerator(MarshalerType.DiscardNoWait)); + return ResolvedGenerator.Resolved(new VoidGenerator(info, context, MarshalerType.DiscardNoWait)); case { TypeInfo: JSSimpleTypeInfo(KnownManagedType.Void), JSType: JSTypeFlags.Discard }: case { TypeInfo: JSSimpleTypeInfo(KnownManagedType.Void), JSType: JSTypeFlags.Void }: case { TypeInfo: JSSimpleTypeInfo(KnownManagedType.Void), JSType: JSTypeFlags.None }: case { TypeInfo: JSSimpleTypeInfo(KnownManagedType.Void), JSType: JSTypeFlags.Missing }: - return ResolvedGenerator.Resolved(new VoidGenerator(jsMarshalingInfo.JSType == JSTypeFlags.Void ? MarshalerType.Void : MarshalerType.Discard)); + return ResolvedGenerator.Resolved(new VoidGenerator(info, context, jsMarshalingInfo.JSType == JSTypeFlags.Void ? MarshalerType.Void : MarshalerType.Discard)); // discard no void case { JSType: JSTypeFlags.Discard }: @@ -60,73 +60,73 @@ ResolvedGenerator fail(string failReason) // primitive case { TypeInfo: JSSimpleTypeInfo simple }: - return Create(info, isToJs, simple.KnownType, Array.Empty(), jsMarshalingInfo.JSType, Array.Empty(), fail); + return Create(info, context, isToJs, simple.KnownType, [], jsMarshalingInfo.JSType, Array.Empty(), fail); // nullable case { TypeInfo: JSNullableTypeInfo nullable }: - return Create(info, isToJs, nullable.KnownType, new[] { nullable.ResultTypeInfo.KnownType }, jsMarshalingInfo.JSType, null, fail); + return Create(info, context, isToJs, nullable.KnownType, [nullable.ResultTypeInfo.KnownType], jsMarshalingInfo.JSType, null, fail); // array case { TypeInfo: JSArrayTypeInfo array }: - return Create(info, isToJs, array.KnownType, new[] { array.ElementTypeInfo.KnownType }, jsMarshalingInfo.JSType, jsMarshalingInfo.JSTypeArguments, fail); + return Create(info, context, isToJs, array.KnownType, [array.ElementTypeInfo.KnownType], jsMarshalingInfo.JSType, jsMarshalingInfo.JSTypeArguments, fail); // array segment case { TypeInfo: JSArraySegmentTypeInfo segment }: - return Create(info, isToJs, segment.KnownType, new[] { segment.ElementTypeInfo.KnownType }, jsMarshalingInfo.JSType, jsMarshalingInfo.JSTypeArguments, fail); + return Create(info, context, isToJs, segment.KnownType, [segment.ElementTypeInfo.KnownType], jsMarshalingInfo.JSType, jsMarshalingInfo.JSTypeArguments, fail); // span case { TypeInfo: JSSpanTypeInfo span }: - return Create(info, isToJs, span.KnownType, new[] { span.ElementTypeInfo.KnownType }, jsMarshalingInfo.JSType, jsMarshalingInfo.JSTypeArguments, fail); + return Create(info, context, isToJs, span.KnownType, [span.ElementTypeInfo.KnownType], jsMarshalingInfo.JSType, jsMarshalingInfo.JSTypeArguments, fail); // task case { TypeInfo: JSTaskTypeInfo(JSSimpleTypeInfo(KnownManagedType.Void)) task }: - return Create(info, isToJs, task.KnownType, Array.Empty(), jsMarshalingInfo.JSType, jsMarshalingInfo.JSTypeArguments, fail); + return Create(info, context, isToJs, task.KnownType, [], jsMarshalingInfo.JSType, jsMarshalingInfo.JSTypeArguments, fail); case { TypeInfo: JSTaskTypeInfo task }: - return Create(info, isToJs, task.KnownType, new[] { task.ResultTypeInfo.KnownType }, jsMarshalingInfo.JSType, jsMarshalingInfo.JSTypeArguments, fail); + return Create(info, context, isToJs, task.KnownType, [task.ResultTypeInfo.KnownType], jsMarshalingInfo.JSType, jsMarshalingInfo.JSTypeArguments, fail); // action + function case { TypeInfo: JSFunctionTypeInfo function }: - return Create(info, isToJs, function.KnownType, function.ArgsTypeInfo.Select(a => a.KnownType).ToArray(), jsMarshalingInfo.JSType, jsMarshalingInfo.JSTypeArguments, fail); + return Create(info, context, isToJs, function.KnownType, function.ArgsTypeInfo.Select(a => a.KnownType).ToArray(), jsMarshalingInfo.JSType, jsMarshalingInfo.JSTypeArguments, fail); default: - return ResolvedGenerator.NotSupported(new(info, context)); + return ResolvedGenerator.NotSupported(info, context, new(info)); } } - internal static ResolvedGenerator Create(TypePositionInfo info, bool isToJs, KnownManagedType marshaledType, KnownManagedType[] argumentTypes, JSTypeFlags jsType, JSTypeFlags[] jsTypeArguments, Func failWithReason) + internal static ResolvedGenerator Create(TypePositionInfo info, StubCodeContext context, bool isToJs, KnownManagedType marshaledType, KnownManagedType[] argumentTypes, JSTypeFlags jsType, JSTypeFlags[] jsTypeArguments, Func failWithReason) { switch (marshaledType) { // primitive - case KnownManagedType.Boolean when jsType == JSTypeFlags.Boolean: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.Boolean)); - case KnownManagedType.Byte when jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.Byte)); - case KnownManagedType.Char when jsType == JSTypeFlags.String: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.Char)); - case KnownManagedType.Int16 when jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.Int16)); - case KnownManagedType.Int32 when jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.Int32)); - case KnownManagedType.Int64 when jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.Int52)); - case KnownManagedType.Int64 when jsType == JSTypeFlags.BigInt: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.BigInt64)); - case KnownManagedType.Single when jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.Single)); - case KnownManagedType.Double when jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.Double)); - case KnownManagedType.IntPtr when jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.IntPtr)); - case KnownManagedType.DateTime when jsType == JSTypeFlags.Date: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.DateTime)); - case KnownManagedType.DateTimeOffset when jsType == JSTypeFlags.Date: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.DateTimeOffset)); - case KnownManagedType.Exception when jsType == JSTypeFlags.Error: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.Exception)); - case KnownManagedType.JSObject when jsType == JSTypeFlags.Object: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.JSObject)); - case KnownManagedType.String when jsType == JSTypeFlags.String: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.String)); - case KnownManagedType.Object when jsType == JSTypeFlags.Any: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.Object)); + case KnownManagedType.Boolean when jsType == JSTypeFlags.Boolean: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.Boolean)); + case KnownManagedType.Byte when jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.Byte)); + case KnownManagedType.Char when jsType == JSTypeFlags.String: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.Char)); + case KnownManagedType.Int16 when jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.Int16)); + case KnownManagedType.Int32 when jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.Int32)); + case KnownManagedType.Int64 when jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.Int52)); + case KnownManagedType.Int64 when jsType == JSTypeFlags.BigInt: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.BigInt64)); + case KnownManagedType.Single when jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.Single)); + case KnownManagedType.Double when jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.Double)); + case KnownManagedType.IntPtr when jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.IntPtr)); + case KnownManagedType.DateTime when jsType == JSTypeFlags.Date: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.DateTime)); + case KnownManagedType.DateTimeOffset when jsType == JSTypeFlags.Date: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.DateTimeOffset)); + case KnownManagedType.Exception when jsType == JSTypeFlags.Error: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.Exception)); + case KnownManagedType.JSObject when jsType == JSTypeFlags.Object: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.JSObject)); + case KnownManagedType.String when jsType == JSTypeFlags.String: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.String)); + case KnownManagedType.Object when jsType == JSTypeFlags.Any: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.Object)); // primitive missing - case KnownManagedType.Boolean when jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.Boolean)); - case KnownManagedType.Byte when jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.Byte)); - case KnownManagedType.Char when jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.Char)); - case KnownManagedType.Int16 when jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.Int16)); - case KnownManagedType.Int32 when jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.Int32)); - case KnownManagedType.Single when jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.Single)); - case KnownManagedType.Double when jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.Double)); - case KnownManagedType.IntPtr when jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.IntPtr)); - case KnownManagedType.Exception when jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.Exception)); - case KnownManagedType.JSObject when jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.JSObject)); - case KnownManagedType.String when jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(MarshalerType.String)); + case KnownManagedType.Boolean when jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.Boolean)); + case KnownManagedType.Byte when jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.Byte)); + case KnownManagedType.Char when jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.Char)); + case KnownManagedType.Int16 when jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.Int16)); + case KnownManagedType.Int32 when jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.Int32)); + case KnownManagedType.Single when jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.Single)); + case KnownManagedType.Double when jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.Double)); + case KnownManagedType.IntPtr when jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.IntPtr)); + case KnownManagedType.Exception when jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.Exception)); + case KnownManagedType.JSObject when jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.JSObject)); + case KnownManagedType.String when jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new PrimitiveJSGenerator(info, context, MarshalerType.String)); // primitive forced case KnownManagedType.Int64 when jsType == JSTypeFlags.Missing: @@ -136,28 +136,28 @@ internal static ResolvedGenerator Create(TypePositionInfo info, bool isToJs, Kno return failWithReason(SR.Format(SR.UseJSMarshalAsAttribute, info.ManagedType.FullTypeName)); // nullable - case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Boolean && jsType == JSTypeFlags.Boolean: return ResolvedGenerator.Resolved(new NullableJSGenerator(MarshalerType.Boolean)); - case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Byte && jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new NullableJSGenerator(MarshalerType.Byte)); - case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Char && jsType == JSTypeFlags.String: return ResolvedGenerator.Resolved(new NullableJSGenerator(MarshalerType.Byte)); - case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Int16 && jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new NullableJSGenerator(MarshalerType.Int16)); - case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Int32 && jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new NullableJSGenerator(MarshalerType.Int32)); - case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Int64 && jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new NullableJSGenerator(MarshalerType.Int52)); - case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Int64 && jsType == JSTypeFlags.BigInt: return ResolvedGenerator.Resolved(new NullableJSGenerator(MarshalerType.BigInt64)); - case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Double && jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new NullableJSGenerator(MarshalerType.Double)); - case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Single && jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new NullableJSGenerator(MarshalerType.Single)); - case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.IntPtr && jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new NullableJSGenerator(MarshalerType.IntPtr)); - case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.DateTime && jsType == JSTypeFlags.Date: return ResolvedGenerator.Resolved(new NullableJSGenerator(MarshalerType.DateTime)); - case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.DateTimeOffset && jsType == JSTypeFlags.Date: return ResolvedGenerator.Resolved(new NullableJSGenerator(MarshalerType.DateTimeOffset)); + case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Boolean && jsType == JSTypeFlags.Boolean: return ResolvedGenerator.Resolved(new NullableJSGenerator(info, context, MarshalerType.Boolean)); + case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Byte && jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new NullableJSGenerator(info, context, MarshalerType.Byte)); + case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Char && jsType == JSTypeFlags.String: return ResolvedGenerator.Resolved(new NullableJSGenerator(info, context, MarshalerType.Byte)); + case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Int16 && jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new NullableJSGenerator(info, context, MarshalerType.Int16)); + case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Int32 && jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new NullableJSGenerator(info, context, MarshalerType.Int32)); + case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Int64 && jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new NullableJSGenerator(info, context, MarshalerType.Int52)); + case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Int64 && jsType == JSTypeFlags.BigInt: return ResolvedGenerator.Resolved(new NullableJSGenerator(info, context, MarshalerType.BigInt64)); + case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Double && jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new NullableJSGenerator(info, context, MarshalerType.Double)); + case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Single && jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new NullableJSGenerator(info, context, MarshalerType.Single)); + case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.IntPtr && jsType == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new NullableJSGenerator(info, context, MarshalerType.IntPtr)); + case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.DateTime && jsType == JSTypeFlags.Date: return ResolvedGenerator.Resolved(new NullableJSGenerator(info, context, MarshalerType.DateTime)); + case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.DateTimeOffset && jsType == JSTypeFlags.Date: return ResolvedGenerator.Resolved(new NullableJSGenerator(info, context, MarshalerType.DateTimeOffset)); // nullable missing - case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Boolean && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new NullableJSGenerator(MarshalerType.Boolean)); - case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Byte && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new NullableJSGenerator(MarshalerType.Byte)); - case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Char && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new NullableJSGenerator(MarshalerType.Byte)); - case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Int16 && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new NullableJSGenerator(MarshalerType.Int16)); - case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Int32 && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new NullableJSGenerator(MarshalerType.Int32)); - case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Single && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new NullableJSGenerator(MarshalerType.Single)); - case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Double && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new NullableJSGenerator(MarshalerType.Double)); - case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.IntPtr && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new NullableJSGenerator(MarshalerType.IntPtr)); + case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Boolean && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new NullableJSGenerator(info, context, MarshalerType.Boolean)); + case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Byte && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new NullableJSGenerator(info, context, MarshalerType.Byte)); + case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Char && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new NullableJSGenerator(info, context, MarshalerType.Byte)); + case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Int16 && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new NullableJSGenerator(info, context, MarshalerType.Int16)); + case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Int32 && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new NullableJSGenerator(info, context, MarshalerType.Int32)); + case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Single && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new NullableJSGenerator(info, context, MarshalerType.Single)); + case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Double && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new NullableJSGenerator(info, context, MarshalerType.Double)); + case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.IntPtr && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new NullableJSGenerator(info, context, MarshalerType.IntPtr)); // nullable forced case KnownManagedType.Nullable when argumentTypes[0] == KnownManagedType.Int64 && jsType == JSTypeFlags.Missing: @@ -169,37 +169,37 @@ internal static ResolvedGenerator Create(TypePositionInfo info, bool isToJs, Kno return failWithReason(SR.Format(SR.TypeNotSupportedName, info.ManagedType.FullTypeName)); // task - case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes.Length == 0 && jsTypeArguments[0] == JSTypeFlags.Void: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.Void)); - case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Byte && jsTypeArguments[0] == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.Byte)); - case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Boolean && jsTypeArguments[0] == JSTypeFlags.Boolean: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.Boolean)); - case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Char && jsTypeArguments[0] == JSTypeFlags.String: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.Char)); - case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Int16 && jsTypeArguments[0] == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.Int16)); - case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Int32 && jsTypeArguments[0] == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.Int32)); - case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Int64 && jsTypeArguments[0] == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.Int52)); - case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Int64 && jsTypeArguments[0] == JSTypeFlags.BigInt: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.BigInt64)); - case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.IntPtr && jsTypeArguments[0] == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.IntPtr)); - case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Double && jsTypeArguments[0] == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.Double)); - case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Single && jsTypeArguments[0] == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.Single)); - case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.JSObject && jsTypeArguments[0] == JSTypeFlags.Object: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.JSObject)); - case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.String && jsTypeArguments[0] == JSTypeFlags.String: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.String)); - case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Exception && jsTypeArguments[0] == JSTypeFlags.Error: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.Exception)); - case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.DateTime && jsTypeArguments[0] == JSTypeFlags.Date: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.DateTime)); - case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.DateTimeOffset && jsTypeArguments[0] == JSTypeFlags.Date: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.DateTimeOffset)); - case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Object && jsTypeArguments[0] == JSTypeFlags.Any: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.Object)); + case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes.Length == 0 && jsTypeArguments[0] == JSTypeFlags.Void: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.Void)); + case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Byte && jsTypeArguments[0] == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.Byte)); + case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Boolean && jsTypeArguments[0] == JSTypeFlags.Boolean: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.Boolean)); + case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Char && jsTypeArguments[0] == JSTypeFlags.String: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.Char)); + case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Int16 && jsTypeArguments[0] == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.Int16)); + case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Int32 && jsTypeArguments[0] == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.Int32)); + case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Int64 && jsTypeArguments[0] == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.Int52)); + case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Int64 && jsTypeArguments[0] == JSTypeFlags.BigInt: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.BigInt64)); + case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.IntPtr && jsTypeArguments[0] == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.IntPtr)); + case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Double && jsTypeArguments[0] == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.Double)); + case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Single && jsTypeArguments[0] == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.Single)); + case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.JSObject && jsTypeArguments[0] == JSTypeFlags.Object: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.JSObject)); + case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.String && jsTypeArguments[0] == JSTypeFlags.String: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.String)); + case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Exception && jsTypeArguments[0] == JSTypeFlags.Error: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.Exception)); + case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.DateTime && jsTypeArguments[0] == JSTypeFlags.Date: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.DateTime)); + case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.DateTimeOffset && jsTypeArguments[0] == JSTypeFlags.Date: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.DateTimeOffset)); + case KnownManagedType.Task when jsType == JSTypeFlags.Promise && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Object && jsTypeArguments[0] == JSTypeFlags.Any: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.Object)); // task missing - case KnownManagedType.Task when jsType == JSTypeFlags.Missing && argumentTypes.Length == 0: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.Void)); - case KnownManagedType.Task when argumentTypes[0] == KnownManagedType.Boolean && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.Boolean)); - case KnownManagedType.Task when argumentTypes[0] == KnownManagedType.Byte && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.Byte)); - case KnownManagedType.Task when argumentTypes[0] == KnownManagedType.Char && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.Char)); - case KnownManagedType.Task when argumentTypes[0] == KnownManagedType.Int16 && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.Int16)); - case KnownManagedType.Task when argumentTypes[0] == KnownManagedType.Int32 && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.Int32)); - case KnownManagedType.Task when argumentTypes[0] == KnownManagedType.Single && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.Single)); - case KnownManagedType.Task when argumentTypes[0] == KnownManagedType.Double && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.Double)); - case KnownManagedType.Task when argumentTypes[0] == KnownManagedType.IntPtr && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.IntPtr)); - case KnownManagedType.Task when argumentTypes[0] == KnownManagedType.JSObject && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.JSObject)); - case KnownManagedType.Task when argumentTypes[0] == KnownManagedType.String && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.String)); - case KnownManagedType.Task when argumentTypes[0] == KnownManagedType.Exception && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new TaskJSGenerator(MarshalerType.Exception)); + case KnownManagedType.Task when jsType == JSTypeFlags.Missing && argumentTypes.Length == 0: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.Void)); + case KnownManagedType.Task when argumentTypes[0] == KnownManagedType.Boolean && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.Boolean)); + case KnownManagedType.Task when argumentTypes[0] == KnownManagedType.Byte && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.Byte)); + case KnownManagedType.Task when argumentTypes[0] == KnownManagedType.Char && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.Char)); + case KnownManagedType.Task when argumentTypes[0] == KnownManagedType.Int16 && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.Int16)); + case KnownManagedType.Task when argumentTypes[0] == KnownManagedType.Int32 && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.Int32)); + case KnownManagedType.Task when argumentTypes[0] == KnownManagedType.Single && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.Single)); + case KnownManagedType.Task when argumentTypes[0] == KnownManagedType.Double && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.Double)); + case KnownManagedType.Task when argumentTypes[0] == KnownManagedType.IntPtr && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.IntPtr)); + case KnownManagedType.Task when argumentTypes[0] == KnownManagedType.JSObject && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.JSObject)); + case KnownManagedType.Task when argumentTypes[0] == KnownManagedType.String && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.String)); + case KnownManagedType.Task when argumentTypes[0] == KnownManagedType.Exception && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new TaskJSGenerator(info, context, MarshalerType.Exception)); // task forced case KnownManagedType.Task when argumentTypes[0] == KnownManagedType.Int64 && jsType == JSTypeFlags.Missing: @@ -212,19 +212,19 @@ internal static ResolvedGenerator Create(TypePositionInfo info, bool isToJs, Kno return failWithReason(SR.Format(SR.TypeNotSupportedName, info.ManagedType.FullTypeName)); // array - case KnownManagedType.Array when jsType == JSTypeFlags.Array && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Byte && jsTypeArguments[0] == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new ArrayJSGenerator(MarshalerType.Byte)); - case KnownManagedType.Array when jsType == JSTypeFlags.Array && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.String && jsTypeArguments[0] == JSTypeFlags.String: return ResolvedGenerator.Resolved(new ArrayJSGenerator(MarshalerType.String)); - case KnownManagedType.Array when jsType == JSTypeFlags.Array && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Double && jsTypeArguments[0] == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new ArrayJSGenerator(MarshalerType.Double)); - case KnownManagedType.Array when jsType == JSTypeFlags.Array && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Int32 && jsTypeArguments[0] == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new ArrayJSGenerator(MarshalerType.Int32)); - case KnownManagedType.Array when jsType == JSTypeFlags.Array && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.JSObject && jsTypeArguments[0] == JSTypeFlags.Object: return ResolvedGenerator.Resolved(new ArrayJSGenerator(MarshalerType.JSObject)); - case KnownManagedType.Array when jsType == JSTypeFlags.Array && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Object && jsTypeArguments[0] == JSTypeFlags.Any: return ResolvedGenerator.Resolved(new ArrayJSGenerator(MarshalerType.Object)); + case KnownManagedType.Array when jsType == JSTypeFlags.Array && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Byte && jsTypeArguments[0] == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new ArrayJSGenerator(info, context, MarshalerType.Byte)); + case KnownManagedType.Array when jsType == JSTypeFlags.Array && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.String && jsTypeArguments[0] == JSTypeFlags.String: return ResolvedGenerator.Resolved(new ArrayJSGenerator(info, context, MarshalerType.String)); + case KnownManagedType.Array when jsType == JSTypeFlags.Array && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Double && jsTypeArguments[0] == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new ArrayJSGenerator(info, context, MarshalerType.Double)); + case KnownManagedType.Array when jsType == JSTypeFlags.Array && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Int32 && jsTypeArguments[0] == JSTypeFlags.Number: return ResolvedGenerator.Resolved(new ArrayJSGenerator(info, context, MarshalerType.Int32)); + case KnownManagedType.Array when jsType == JSTypeFlags.Array && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.JSObject && jsTypeArguments[0] == JSTypeFlags.Object: return ResolvedGenerator.Resolved(new ArrayJSGenerator(info, context, MarshalerType.JSObject)); + case KnownManagedType.Array when jsType == JSTypeFlags.Array && jsTypeArguments.Length == 1 && argumentTypes[0] == KnownManagedType.Object && jsTypeArguments[0] == JSTypeFlags.Any: return ResolvedGenerator.Resolved(new ArrayJSGenerator(info, context, MarshalerType.Object)); // array missing - case KnownManagedType.Array when argumentTypes[0] == KnownManagedType.Byte && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new ArrayJSGenerator(MarshalerType.Byte)); - case KnownManagedType.Array when argumentTypes[0] == KnownManagedType.String && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new ArrayJSGenerator(MarshalerType.String)); - case KnownManagedType.Array when argumentTypes[0] == KnownManagedType.Double && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new ArrayJSGenerator(MarshalerType.Double)); - case KnownManagedType.Array when argumentTypes[0] == KnownManagedType.Int32 && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new ArrayJSGenerator(MarshalerType.Int32)); - case KnownManagedType.Array when argumentTypes[0] == KnownManagedType.JSObject && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new ArrayJSGenerator(MarshalerType.JSObject)); + case KnownManagedType.Array when argumentTypes[0] == KnownManagedType.Byte && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new ArrayJSGenerator(info, context, MarshalerType.Byte)); + case KnownManagedType.Array when argumentTypes[0] == KnownManagedType.String && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new ArrayJSGenerator(info, context, MarshalerType.String)); + case KnownManagedType.Array when argumentTypes[0] == KnownManagedType.Double && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new ArrayJSGenerator(info, context, MarshalerType.Double)); + case KnownManagedType.Array when argumentTypes[0] == KnownManagedType.Int32 && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new ArrayJSGenerator(info, context, MarshalerType.Int32)); + case KnownManagedType.Array when argumentTypes[0] == KnownManagedType.JSObject && jsType == JSTypeFlags.Missing: return ResolvedGenerator.Resolved(new ArrayJSGenerator(info, context, MarshalerType.JSObject)); case KnownManagedType.Array when jsType == JSTypeFlags.Array && jsTypeArguments.Length == 1: return failWithReason(SR.Format(SR.TypeNotSupportedName, info.ManagedType.FullTypeName)); @@ -235,9 +235,9 @@ internal static ResolvedGenerator Create(TypePositionInfo info, bool isToJs, Kno // span view case KnownManagedType.Span when jsType == JSTypeFlags.MemoryView && jsTypeArguments.Length != 0: return failWithReason(null); - case KnownManagedType.Span when jsType == JSTypeFlags.MemoryView && argumentTypes[0] == KnownManagedType.Byte: return ResolvedGenerator.Resolved(new SpanJSGenerator(MarshalerType.Byte)); - case KnownManagedType.Span when jsType == JSTypeFlags.MemoryView && argumentTypes[0] == KnownManagedType.Int32: return ResolvedGenerator.Resolved(new SpanJSGenerator(MarshalerType.Int32)); - case KnownManagedType.Span when jsType == JSTypeFlags.MemoryView && argumentTypes[0] == KnownManagedType.Double: return ResolvedGenerator.Resolved(new SpanJSGenerator(MarshalerType.Double)); + case KnownManagedType.Span when jsType == JSTypeFlags.MemoryView && argumentTypes[0] == KnownManagedType.Byte: return ResolvedGenerator.Resolved(new SpanJSGenerator(info, context, MarshalerType.Byte)); + case KnownManagedType.Span when jsType == JSTypeFlags.MemoryView && argumentTypes[0] == KnownManagedType.Int32: return ResolvedGenerator.Resolved(new SpanJSGenerator(info, context, MarshalerType.Int32)); + case KnownManagedType.Span when jsType == JSTypeFlags.MemoryView && argumentTypes[0] == KnownManagedType.Double: return ResolvedGenerator.Resolved(new SpanJSGenerator(info, context, MarshalerType.Double)); case KnownManagedType.Span when jsType == JSTypeFlags.MemoryView: return failWithReason(SR.Format(SR.TypeNotSupportedName, info.ManagedType.FullTypeName)); @@ -251,9 +251,9 @@ internal static ResolvedGenerator Create(TypePositionInfo info, bool isToJs, Kno // segment view case KnownManagedType.ArraySegment when jsType == JSTypeFlags.MemoryView && jsTypeArguments.Length != 0: return failWithReason(null); - case KnownManagedType.ArraySegment when jsType == JSTypeFlags.MemoryView && argumentTypes[0] == KnownManagedType.Byte: return ResolvedGenerator.Resolved(new ArraySegmentJSGenerator(MarshalerType.Byte)); - case KnownManagedType.ArraySegment when jsType == JSTypeFlags.MemoryView && argumentTypes[0] == KnownManagedType.Int32: return ResolvedGenerator.Resolved(new ArraySegmentJSGenerator(MarshalerType.Int32)); - case KnownManagedType.ArraySegment when jsType == JSTypeFlags.MemoryView && argumentTypes[0] == KnownManagedType.Double: return ResolvedGenerator.Resolved(new ArraySegmentJSGenerator(MarshalerType.Double)); + case KnownManagedType.ArraySegment when jsType == JSTypeFlags.MemoryView && argumentTypes[0] == KnownManagedType.Byte: return ResolvedGenerator.Resolved(new ArraySegmentJSGenerator(info, context, MarshalerType.Byte)); + case KnownManagedType.ArraySegment when jsType == JSTypeFlags.MemoryView && argumentTypes[0] == KnownManagedType.Int32: return ResolvedGenerator.Resolved(new ArraySegmentJSGenerator(info, context, MarshalerType.Int32)); + case KnownManagedType.ArraySegment when jsType == JSTypeFlags.MemoryView && argumentTypes[0] == KnownManagedType.Double: return ResolvedGenerator.Resolved(new ArraySegmentJSGenerator(info, context, MarshalerType.Double)); case KnownManagedType.ArraySegment when jsType == JSTypeFlags.MemoryView: return failWithReason(SR.Format(SR.TypeNotSupportedName, info.ManagedType.FullTypeName)); @@ -281,7 +281,7 @@ internal static ResolvedGenerator Create(TypePositionInfo info, bool isToJs, Kno { return failWithReason(SR.Format(SR.FuncArgumentNotSupported, argumentTypes[i])); } - var gen = Create(info, isToJs ^ (!isReturn), argumentTypes[i], Array.Empty(), jsTypeArguments[i], Array.Empty(), failWithReason); + var gen = Create(info, context, isToJs ^ (!isReturn), argumentTypes[i], Array.Empty(), jsTypeArguments[i], Array.Empty(), failWithReason); argsMarshalers.Add(((BaseJSGenerator)gen.Generator).Type); } var maxArgs = marshaledType == KnownManagedType.Action ? 3 : 4; @@ -290,7 +290,7 @@ internal static ResolvedGenerator Create(TypePositionInfo info, bool isToJs, Kno { return failWithReason(SR.FuncTooManyArgs); } - return ResolvedGenerator.Resolved(new FuncJSGenerator(marshaledType == KnownManagedType.Action, argsMarshallerTypes)); + return ResolvedGenerator.Resolved(new FuncJSGenerator(info, context, marshaledType == KnownManagedType.Action, argsMarshallerTypes)); case KnownManagedType.Action when jsType == JSTypeFlags.Function: case KnownManagedType.Function when jsType == JSTypeFlags.Function: return failWithReason(SR.FuncWrongArgumentCount); diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSImportCodeGenerator.cs b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSImportCodeGenerator.cs index 80a9a2338b9..7891bec53f2 100644 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSImportCodeGenerator.cs +++ b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSImportCodeGenerator.cs @@ -15,7 +15,7 @@ namespace Microsoft.Interop.JavaScript internal abstract class JSCodeGenerator { public const string ReturnIdentifier = "__retVal"; - public const string ReturnNativeIdentifier = $"{ReturnIdentifier}{StubCodeContext.GeneratedNativeIdentifierSuffix}"; + public const string ReturnNativeIdentifier = $"{ReturnIdentifier}{StubIdentifierContext.GeneratedNativeIdentifierSuffix}"; public const string InvokeSucceededIdentifier = "__invokeSucceeded"; } @@ -23,7 +23,8 @@ internal sealed class JSImportCodeGenerator : JSCodeGenerator { private readonly BoundGenerators _marshallers; - private readonly JSImportCodeContext _context; + private readonly StubIdentifierContext _context; + private readonly JSImportData _jsImportData; private readonly JSSignatureContext _signatureContext; public JSImportCodeGenerator( @@ -33,33 +34,36 @@ public JSImportCodeGenerator( GeneratorDiagnosticsBag diagnosticsBag, IMarshallingGeneratorResolver generatorResolver) { + _jsImportData = attributeData; _signatureContext = signatureContext; - ManagedToNativeStubCodeContext innerContext = new ManagedToNativeStubCodeContext(ReturnIdentifier, ReturnIdentifier) - { - CodeEmitOptions = new(SkipInit: true) - }; - _context = new JSImportCodeContext(attributeData, innerContext); - _marshallers = BoundGenerators.Create(argTypes, generatorResolver, _context, new EmptyJSGenerator(), out var bindingFailures); + + _marshallers = BoundGenerators.Create(argTypes, generatorResolver, StubCodeContext.DefaultManagedToNativeStub, new EmptyJSGenerator(), out var bindingFailures); diagnosticsBag.ReportGeneratorDiagnostics(bindingFailures); - if (_marshallers.ManagedReturnMarshaller.Generator.UsesNativeIdentifier(_marshallers.ManagedReturnMarshaller.TypeInfo, null)) + if (_marshallers.ManagedReturnMarshaller.UsesNativeIdentifier) { // If we need a different native return identifier, then recreate the context with the correct identifier before we generate any code. - innerContext = new ManagedToNativeStubCodeContext(ReturnIdentifier, ReturnNativeIdentifier) + _context = new DefaultIdentifierContext(ReturnIdentifier, ReturnNativeIdentifier, MarshalDirection.ManagedToUnmanaged) + { + CodeEmitOptions = new(SkipInit: true) + }; + } + else + { + _context = new DefaultIdentifierContext(ReturnIdentifier, ReturnIdentifier, MarshalDirection.ManagedToUnmanaged) { CodeEmitOptions = new(SkipInit: true) }; - _context = new JSImportCodeContext(attributeData, innerContext); } // validate task + span mix if (_marshallers.ManagedReturnMarshaller.TypeInfo.MarshallingAttributeInfo is JSMarshallingInfo(_, JSTaskTypeInfo)) { - BoundGenerator spanArg = _marshallers.SignatureMarshallers.FirstOrDefault(m => m.TypeInfo.MarshallingAttributeInfo is JSMarshallingInfo(_, JSSpanTypeInfo)); + IBoundMarshallingGenerator spanArg = _marshallers.SignatureMarshallers.FirstOrDefault(m => m.TypeInfo.MarshallingAttributeInfo is JSMarshallingInfo(_, JSSpanTypeInfo)); if (spanArg != default) { - diagnosticsBag.ReportGeneratorDiagnostic(new GeneratorDiagnostic.NotSupported(spanArg.TypeInfo, _context) + diagnosticsBag.ReportGeneratorDiagnostic(new GeneratorDiagnostic.NotSupported(spanArg.TypeInfo) { NotSupportedDetails = SR.SpanAndTaskNotSupported }); @@ -132,11 +136,11 @@ private void BindSyntax(List statementsToUpdate) { var bindingParameters = (new ArgumentSyntax[] { - Argument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(_context.AttributeData.FunctionName))), + Argument(LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(_jsImportData.FunctionName))), Argument( - _context.AttributeData.ModuleName == null + _jsImportData.ModuleName == null ? LiteralExpression(SyntaxKind.NullLiteralExpression) - : LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(_context.AttributeData.ModuleName))), + : LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(_jsImportData.ModuleName))), CreateSignaturesSyntax(), }); @@ -151,8 +155,9 @@ private void BindSyntax(List statementsToUpdate) private ArgumentSyntax CreateSignaturesSyntax() { - var types = ((IJSMarshallingGenerator)_marshallers.ManagedReturnMarshaller.Generator).GenerateBind(_marshallers.ManagedReturnMarshaller.TypeInfo, _context) - .Concat(_marshallers.NativeParameterMarshallers.SelectMany(p => ((IJSMarshallingGenerator)p.Generator).GenerateBind(p.TypeInfo, _context))); + IEnumerable types = _marshallers.ManagedReturnMarshaller is IJSMarshallingGenerator jsGen ? jsGen.GenerateBind() : []; + types = types + .Concat(_marshallers.NativeParameterMarshallers.OfType().SelectMany(p => p.GenerateBind())); return Argument(ArrayCreationExpression(ArrayType(IdentifierName(Constants.JSMarshalerTypeGlobal)) .WithRankSpecifiers(SingletonList(ArrayRankSpecifier(SingletonSeparatedList(OmittedArraySizeExpression()))))) diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSImportGenerator.csproj b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSImportGenerator.csproj index d8b8fdfcfe0..d973b24132c 100644 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSImportGenerator.csproj +++ b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSImportGenerator.csproj @@ -25,6 +25,8 @@ + + diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSSignatureContext.cs b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSSignatureContext.cs index 6d0fd6a7c9b..3f058a5c7ee 100644 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSSignatureContext.cs +++ b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSSignatureContext.cs @@ -52,7 +52,10 @@ public static JSSignatureContext Create( { foreach (var param in sigContext.ElementTypeInformation) { - hash = hash * 31 + (uint)param.ManagedType.FullTypeName.GetHashCode(); + // Manually hash the managed type names character by character as + // string hashes are not stable across runs. + foreach (char c in param.ManagedType.FullTypeName) + hash = hash * 31 + c; } }; int typesHash = Math.Abs((int)hash); diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSStubCodeContext.cs b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSStubCodeContext.cs deleted file mode 100644 index 7a696dbb2c4..00000000000 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/JSStubCodeContext.cs +++ /dev/null @@ -1,46 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System; - -namespace Microsoft.Interop.JavaScript -{ - internal abstract record JSStubCodeContext : StubCodeContext - { - public StubCodeContext _inner; - public override bool SingleFrameSpansNativeContext => _inner.SingleFrameSpansNativeContext; - - public override bool AdditionalTemporaryStateLivesAcrossStages => _inner.AdditionalTemporaryStateLivesAcrossStages; - - public override (string managed, string native) GetIdentifiers(TypePositionInfo info) - { - return _inner.GetIdentifiers(info); - } - } - - internal sealed record JSImportCodeContext : JSStubCodeContext - { - public JSImportCodeContext(JSImportData attributeData, StubCodeContext inner) - { - _inner = inner; - Direction = MarshalDirection.ManagedToUnmanaged; - AttributeData = attributeData; - CodeEmitOptions = inner.CodeEmitOptions; - } - - public JSImportData AttributeData { get; set; } - } - - internal sealed record JSExportCodeContext : JSStubCodeContext - { - public JSExportCodeContext(JSExportData attributeData, StubCodeContext inner) - { - _inner = inner; - Direction = MarshalDirection.UnmanagedToManaged; - AttributeData = attributeData; - CodeEmitOptions = inner.CodeEmitOptions; - } - - public JSExportData AttributeData { get; set; } - } -} diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/LanguageSupport.cs b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/LanguageSupport.cs deleted file mode 100644 index 42c8acfd4ab..00000000000 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/LanguageSupport.cs +++ /dev/null @@ -1,12 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -// Types defined to enable language support of various features -// in the source generator. -namespace System.Runtime.CompilerServices -{ - // Define IsExternalInit type to support records. - internal sealed class IsExternalInit - { - } -} diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/ArrayJSGenerator.cs b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/ArrayJSGenerator.cs index 816c9d7b555..5d7d55c644b 100644 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/ArrayJSGenerator.cs +++ b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/ArrayJSGenerator.cs @@ -13,13 +13,13 @@ internal sealed class ArrayJSGenerator : PrimitiveJSGenerator { private readonly MarshalerType _elementMarshalerType; - public ArrayJSGenerator(MarshalerType elementMarshalerType) - : base(MarshalerType.Array) + public ArrayJSGenerator(TypePositionInfo info, StubCodeContext context, MarshalerType elementMarshalerType) + : base(info, context, MarshalerType.Array) { _elementMarshalerType = elementMarshalerType; } - public override IEnumerable GenerateBind(TypePositionInfo info, StubCodeContext context) + public override IEnumerable GenerateBind() { yield return InvocationExpression(MarshalerTypeName(Type), ArgumentList(SingletonSeparatedList(Argument(MarshalerTypeName(_elementMarshalerType))))); diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/ArraySegmentJSGenerator.cs b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/ArraySegmentJSGenerator.cs index ef6ef06107b..f3785d8bf7e 100644 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/ArraySegmentJSGenerator.cs +++ b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/ArraySegmentJSGenerator.cs @@ -12,13 +12,13 @@ internal sealed class ArraySegmentJSGenerator : PrimitiveJSGenerator { private readonly MarshalerType _elementMarshalerType; - public ArraySegmentJSGenerator(MarshalerType elementMarshalerType) - : base(MarshalerType.ArraySegment) + public ArraySegmentJSGenerator(TypePositionInfo info, StubCodeContext context, MarshalerType elementMarshalerType) + : base(info, context, MarshalerType.ArraySegment) { _elementMarshalerType = elementMarshalerType; } - public override IEnumerable GenerateBind(TypePositionInfo info, StubCodeContext context) + public override IEnumerable GenerateBind() { yield return InvocationExpression(MarshalerTypeName(Type), ArgumentList(SingletonSeparatedList(Argument(MarshalerTypeName(_elementMarshalerType))))); diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/BaseJSGenerator.cs b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/BaseJSGenerator.cs index 798be15bc45..1f6eef23465 100644 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/BaseJSGenerator.cs +++ b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/BaseJSGenerator.cs @@ -12,44 +12,52 @@ namespace Microsoft.Interop.JavaScript { internal abstract class BaseJSGenerator : IJSMarshallingGenerator { - protected IMarshallingGenerator _inner; + protected IBoundMarshallingGenerator _inner; public MarshalerType Type; - protected BaseJSGenerator(MarshalerType marshalerType, IMarshallingGenerator inner) + protected BaseJSGenerator(MarshalerType marshalerType, IBoundMarshallingGenerator inner) { _inner = inner; Type = marshalerType; } - public ManagedTypeInfo AsNativeType(TypePositionInfo info) => _inner.AsNativeType(info); - public virtual bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) => _inner.UsesNativeIdentifier(info, context); - public SignatureBehavior GetNativeSignatureBehavior(TypePositionInfo info) => _inner.GetNativeSignatureBehavior(info); - public ValueBoundaryBehavior GetValueBoundaryBehavior(TypePositionInfo info, StubCodeContext context) => _inner.GetValueBoundaryBehavior(info, context); - public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, StubCodeContext context, out GeneratorDiagnostic? diagnostic) - => _inner.SupportsByValueMarshalKind(marshalKind, info, context, out diagnostic); + public TypePositionInfo TypeInfo => _inner.TypeInfo; - public virtual IEnumerable GenerateBind(TypePositionInfo info, StubCodeContext context) + public StubCodeContext CodeContext => _inner.CodeContext; + + public ManagedTypeInfo NativeType => _inner.NativeType; + + public SignatureBehavior NativeSignatureBehavior => _inner.NativeSignatureBehavior; + + public ValueBoundaryBehavior ValueBoundaryBehavior => _inner.ValueBoundaryBehavior; + + public virtual bool UsesNativeIdentifier => _inner.UsesNativeIdentifier; + + public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, out GeneratorDiagnostic? diagnostic) + => _inner.SupportsByValueMarshalKind(marshalKind, out diagnostic); + + public virtual IEnumerable GenerateBind() { yield return MarshalerTypeName(Type); } - public virtual IEnumerable Generate(TypePositionInfo info, StubCodeContext context) + public virtual IEnumerable Generate(StubIdentifierContext context) { - string argName = context.GetAdditionalIdentifier(info, "js_arg"); + string argName = context.GetAdditionalIdentifier(TypeInfo, "js_arg"); - if (context.CurrentStage == StubCodeContext.Stage.Setup) + if (context.CurrentStage == StubIdentifierContext.Stage.Setup) { - if (!info.IsManagedReturnPosition) + if (!TypeInfo.IsManagedReturnPosition) { yield return LocalDeclarationStatement(VariableDeclaration(RefType(IdentifierName(Constants.JSMarshalerArgumentGlobal))) .WithVariables(SingletonSeparatedList(VariableDeclarator(Identifier(argName)) .WithInitializer(EqualsValueClause(RefExpression(ElementAccessExpression(IdentifierName(Constants.ArgumentsBuffer)) .WithArgumentList(BracketedArgumentList(SingletonSeparatedList( - Argument(LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(info.ManagedIndex + 2)))))))))))); + Argument(LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(TypeInfo.ManagedIndex + 2)))))))))))); } } - foreach (var x in _inner.Generate(info, context)) + foreach (var x in _inner.Generate(context)) { yield return x; } diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/EmptyJSGenerator.cs b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/EmptyJSGenerator.cs index 060902fc109..e9704fbdc04 100644 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/EmptyJSGenerator.cs +++ b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/EmptyJSGenerator.cs @@ -7,15 +7,14 @@ namespace Microsoft.Interop.JavaScript { - internal sealed class EmptyJSGenerator : IJSMarshallingGenerator + internal sealed class EmptyJSGenerator : IUnboundMarshallingGenerator { public ManagedTypeInfo AsNativeType(TypePositionInfo info) => info.ManagedType; - public IEnumerable Generate(TypePositionInfo info, StubCodeContext context) => Array.Empty(); - public IEnumerable GenerateBind(TypePositionInfo info, StubCodeContext context) => Array.Empty(); + public IEnumerable Generate(TypePositionInfo info, StubCodeContext codeContext, StubIdentifierContext identifierContext) => Array.Empty(); public SignatureBehavior GetNativeSignatureBehavior(TypePositionInfo info) => SignatureBehavior.ManagedTypeAndAttributes; public ValueBoundaryBehavior GetValueBoundaryBehavior(TypePositionInfo info, StubCodeContext context) => ValueBoundaryBehavior.ManagedIdentifier; - public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, StubCodeContext context, out GeneratorDiagnostic? diagnostic) - => ByValueMarshalKindSupportDescriptor.Default.GetSupport(marshalKind, info, context, out diagnostic); + public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, out GeneratorDiagnostic? diagnostic) + => ByValueMarshalKindSupportDescriptor.Default.GetSupport(marshalKind, info, out diagnostic); public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) => false; } } diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/FuncJSGenerator.cs b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/FuncJSGenerator.cs index b70986a9b3a..d4d7f785c55 100644 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/FuncJSGenerator.cs +++ b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/FuncJSGenerator.cs @@ -16,56 +16,56 @@ internal sealed class FuncJSGenerator : BaseJSGenerator private readonly bool _isAction; private readonly MarshalerType[] _argumentMarshalerTypes; - public FuncJSGenerator(bool isAction, MarshalerType[] argumentMarshalerTypes) - : base(isAction ? MarshalerType.Action : MarshalerType.Function, new Forwarder()) + public FuncJSGenerator(TypePositionInfo info, StubCodeContext context, bool isAction, MarshalerType[] argumentMarshalerTypes) + : base(isAction ? MarshalerType.Action : MarshalerType.Function, new Forwarder().Bind(info, context)) { _isAction = isAction; _argumentMarshalerTypes = argumentMarshalerTypes; } - public override IEnumerable GenerateBind(TypePositionInfo info, StubCodeContext context) + public override IEnumerable GenerateBind() { var args = _argumentMarshalerTypes.Select(x => Argument(MarshalerTypeName(x))).ToList(); yield return InvocationExpression(MarshalerTypeName(Type), ArgumentList(SeparatedList(args))); } - public override IEnumerable Generate(TypePositionInfo info, StubCodeContext context) + public override IEnumerable Generate(StubIdentifierContext context) { - string argName = context.GetAdditionalIdentifier(info, "js_arg"); - var target = info.IsManagedReturnPosition + string argName = context.GetAdditionalIdentifier(TypeInfo, "js_arg"); + var target = TypeInfo.IsManagedReturnPosition ? Constants.ArgumentReturn : argName; - var source = info.IsManagedReturnPosition - ? Argument(IdentifierName(context.GetIdentifiers(info).native)) - : _inner.AsArgument(info, context); + var source = TypeInfo.IsManagedReturnPosition + ? Argument(IdentifierName(context.GetIdentifiers(TypeInfo).native)) + : _inner.AsArgument(context); - var jsty = (JSFunctionTypeInfo)((JSMarshallingInfo)info.MarshallingAttributeInfo).TypeInfo; + var jsty = (JSFunctionTypeInfo)((JSMarshallingInfo)TypeInfo.MarshallingAttributeInfo).TypeInfo; var sourceTypes = jsty.ArgsTypeInfo .Select(a => a.Syntax) .ToArray(); - if (context.CurrentStage == StubCodeContext.Stage.UnmarshalCapture && context.Direction == MarshalDirection.ManagedToUnmanaged && info.IsManagedReturnPosition) + if (context.CurrentStage == StubIdentifierContext.Stage.UnmarshalCapture && CodeContext.Direction == MarshalDirection.ManagedToUnmanaged && TypeInfo.IsManagedReturnPosition) { yield return ToManagedMethod(target, source, jsty); } - if (context.CurrentStage == StubCodeContext.Stage.Marshal && context.Direction == MarshalDirection.UnmanagedToManaged && info.IsManagedReturnPosition) + if (context.CurrentStage == StubIdentifierContext.Stage.Marshal && CodeContext.Direction == MarshalDirection.UnmanagedToManaged && TypeInfo.IsManagedReturnPosition) { yield return ToJSMethod(target, source, jsty); } - foreach (var x in base.Generate(info, context)) + foreach (var x in base.Generate(context)) { yield return x; } - if (context.CurrentStage == StubCodeContext.Stage.PinnedMarshal && context.Direction == MarshalDirection.ManagedToUnmanaged && !info.IsManagedReturnPosition) + if (context.CurrentStage == StubIdentifierContext.Stage.PinnedMarshal && CodeContext.Direction == MarshalDirection.ManagedToUnmanaged && !TypeInfo.IsManagedReturnPosition) { yield return ToJSMethod(target, source, jsty); } - if (context.CurrentStage == StubCodeContext.Stage.Unmarshal && context.Direction == MarshalDirection.UnmanagedToManaged && !info.IsManagedReturnPosition) + if (context.CurrentStage == StubIdentifierContext.Stage.Unmarshal && CodeContext.Direction == MarshalDirection.UnmanagedToManaged && !TypeInfo.IsManagedReturnPosition) { yield return ToManagedMethod(target, source, jsty); } @@ -73,8 +73,7 @@ public override IEnumerable Generate(TypePositionInfo info, Stu private ExpressionStatementSyntax ToManagedMethod(string target, ArgumentSyntax source, JSFunctionTypeInfo info) { - List arguments = new List(); - arguments.Add(source.WithRefOrOutKeyword(Token(SyntaxKind.OutKeyword))); + List arguments = [source.WithRefOrOutKeyword(Token(SyntaxKind.OutKeyword))]; for (int i = 0; i < info.ArgsTypeInfo.Length; i++) { var sourceType = info.ArgsTypeInfo[i]; @@ -95,8 +94,7 @@ private ExpressionStatementSyntax ToManagedMethod(string target, ArgumentSyntax private ExpressionStatementSyntax ToJSMethod(string target, ArgumentSyntax source, JSFunctionTypeInfo info) { - List arguments = new List(); - arguments.Add(source); + List arguments = [source]; for (int i = 0; i < info.ArgsTypeInfo.Length; i++) { var sourceType = info.ArgsTypeInfo[i]; @@ -115,7 +113,6 @@ private ExpressionStatementSyntax ToJSMethod(string target, ArgumentSyntax sourc .WithArgumentList(ArgumentList(SeparatedList(arguments)))); } - private static ArgumentSyntax ArgToJS(int i, TypeSyntax sourceType, MarshalerType marshalerType) => Argument(ParenthesizedLambdaExpression() .WithModifiers(TokenList(Token(SyntaxKind.StaticKeyword))) .WithParameterList(ParameterList(SeparatedList(new[]{ diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/IJSMarshallingGenerator.cs b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/IJSMarshallingGenerator.cs index ec665b5d904..f60406b21e8 100644 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/IJSMarshallingGenerator.cs +++ b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/IJSMarshallingGenerator.cs @@ -6,8 +6,8 @@ namespace Microsoft.Interop.JavaScript { - internal interface IJSMarshallingGenerator : IMarshallingGenerator + internal interface IJSMarshallingGenerator : IBoundMarshallingGenerator { - IEnumerable GenerateBind(TypePositionInfo info, StubCodeContext context); + IEnumerable GenerateBind(); } } diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/NullableJSGenerator.cs b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/NullableJSGenerator.cs index a943e6cf06c..191c475f133 100644 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/NullableJSGenerator.cs +++ b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/NullableJSGenerator.cs @@ -10,12 +10,12 @@ namespace Microsoft.Interop.JavaScript { internal sealed class NullableJSGenerator : PrimitiveJSGenerator { - public NullableJSGenerator(MarshalerType resultMarshalerType) - : base(resultMarshalerType) + public NullableJSGenerator(TypePositionInfo info, StubCodeContext context, MarshalerType resultMarshalerType) + : base(info, context, resultMarshalerType) { } - public override IEnumerable GenerateBind(TypePositionInfo info, StubCodeContext context) + public override IEnumerable GenerateBind() { yield return InvocationExpression(MarshalerTypeName(MarshalerType.Nullable), ArgumentList(SingletonSeparatedList(Argument(MarshalerTypeName(Type))))); diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/PrimitiveJSGenerator.cs b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/PrimitiveJSGenerator.cs index 7690aa4fe43..5da5c9db179 100644 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/PrimitiveJSGenerator.cs +++ b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/PrimitiveJSGenerator.cs @@ -11,49 +11,49 @@ namespace Microsoft.Interop.JavaScript { internal class PrimitiveJSGenerator : BaseJSGenerator { - public PrimitiveJSGenerator(MarshalerType marshalerType, IMarshallingGenerator inner) + public PrimitiveJSGenerator(MarshalerType marshalerType, IBoundMarshallingGenerator inner) : base(marshalerType, inner) { } - public PrimitiveJSGenerator(MarshalerType marshalerType) - : base(marshalerType, new Forwarder()) + public PrimitiveJSGenerator(TypePositionInfo info, StubCodeContext context, MarshalerType marshalerType) + : base(marshalerType, new Forwarder().Bind(info, context)) { } // TODO order parameters in such way that affinity capturing parameters are emitted first - public override IEnumerable Generate(TypePositionInfo info, StubCodeContext context) + public override IEnumerable Generate(StubIdentifierContext context) { - string argName = context.GetAdditionalIdentifier(info, "js_arg"); - var target = info.IsManagedReturnPosition + string argName = context.GetAdditionalIdentifier(TypeInfo, "js_arg"); + var target = TypeInfo.IsManagedReturnPosition ? Constants.ArgumentReturn : argName; - var source = info.IsManagedReturnPosition - ? Argument(IdentifierName(context.GetIdentifiers(info).native)) - : _inner.AsArgument(info, context); + var source = TypeInfo.IsManagedReturnPosition + ? Argument(IdentifierName(context.GetIdentifiers(TypeInfo).native)) + : _inner.AsArgument(context); - if (context.CurrentStage == StubCodeContext.Stage.UnmarshalCapture && context.Direction == MarshalDirection.ManagedToUnmanaged && info.IsManagedReturnPosition) + if (context.CurrentStage == StubIdentifierContext.Stage.UnmarshalCapture && CodeContext.Direction == MarshalDirection.ManagedToUnmanaged && TypeInfo.IsManagedReturnPosition) { yield return ToManagedMethod(target, source); } - if (context.CurrentStage == StubCodeContext.Stage.Marshal && context.Direction == MarshalDirection.UnmanagedToManaged && info.IsManagedReturnPosition) + if (context.CurrentStage == StubIdentifierContext.Stage.Marshal && CodeContext.Direction == MarshalDirection.UnmanagedToManaged && TypeInfo.IsManagedReturnPosition) { yield return ToJSMethod(target, source); } - foreach (var x in base.Generate(info, context)) + foreach (var x in base.Generate(context)) { yield return x; } - if (context.CurrentStage == StubCodeContext.Stage.PinnedMarshal && context.Direction == MarshalDirection.ManagedToUnmanaged && !info.IsManagedReturnPosition) + if (context.CurrentStage == StubIdentifierContext.Stage.PinnedMarshal && CodeContext.Direction == MarshalDirection.ManagedToUnmanaged && !TypeInfo.IsManagedReturnPosition) { yield return ToJSMethod(target, source); } - if (context.CurrentStage == StubCodeContext.Stage.Unmarshal && context.Direction == MarshalDirection.UnmanagedToManaged && !info.IsManagedReturnPosition) + if (context.CurrentStage == StubIdentifierContext.Stage.Unmarshal && CodeContext.Direction == MarshalDirection.UnmanagedToManaged && !TypeInfo.IsManagedReturnPosition) { yield return ToManagedMethod(target, source); } diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/SpanJSGenerator.cs b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/SpanJSGenerator.cs index 6d53af9ba8d..afaedf597b6 100644 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/SpanJSGenerator.cs +++ b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/SpanJSGenerator.cs @@ -12,13 +12,13 @@ internal sealed class SpanJSGenerator : PrimitiveJSGenerator { private readonly MarshalerType _elementMarshalerType; - public SpanJSGenerator(MarshalerType elementMarshalerType) - : base(MarshalerType.Span) + public SpanJSGenerator(TypePositionInfo info, StubCodeContext context, MarshalerType elementMarshalerType) + : base(info, context, MarshalerType.Span) { _elementMarshalerType = elementMarshalerType; } - public override IEnumerable GenerateBind(TypePositionInfo info, StubCodeContext context) + public override IEnumerable GenerateBind() { yield return InvocationExpression(MarshalerTypeName(Type), ArgumentList(SingletonSeparatedList(Argument(MarshalerTypeName(_elementMarshalerType))))); diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/TaskJSGenerator.cs b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/TaskJSGenerator.cs index f4a42613b9d..381f4dac813 100644 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/TaskJSGenerator.cs +++ b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/TaskJSGenerator.cs @@ -13,15 +13,15 @@ internal sealed class TaskJSGenerator : BaseJSGenerator { private readonly MarshalerType _resultMarshalerType; - public TaskJSGenerator(MarshalerType resultMarshalerType) - : base(MarshalerType.Task, new Forwarder()) + public TaskJSGenerator(TypePositionInfo info, StubCodeContext context, MarshalerType resultMarshalerType) + : base(MarshalerType.Task, new Forwarder().Bind(info, context)) { _resultMarshalerType = resultMarshalerType; } - public override IEnumerable GenerateBind(TypePositionInfo info, StubCodeContext context) + public override IEnumerable GenerateBind() { - var jsty = (JSTaskTypeInfo)((JSMarshallingInfo)info.MarshallingAttributeInfo).TypeInfo; + var jsty = (JSTaskTypeInfo)((JSMarshallingInfo)TypeInfo.MarshallingAttributeInfo).TypeInfo; if (jsty.ResultTypeInfo is JSSimpleTypeInfo(KnownManagedType.Void)) { yield return InvocationExpression(MarshalerTypeName(MarshalerType.Task), ArgumentList()); @@ -33,46 +33,46 @@ public override IEnumerable GenerateBind(TypePositionInfo info } } - public override IEnumerable Generate(TypePositionInfo info, StubCodeContext context) + public override IEnumerable Generate(StubIdentifierContext context) { - var jsty = (JSTaskTypeInfo)((JSMarshallingInfo)info.MarshallingAttributeInfo).TypeInfo; + var jsty = (JSTaskTypeInfo)((JSMarshallingInfo)TypeInfo.MarshallingAttributeInfo).TypeInfo; - string argName = context.GetAdditionalIdentifier(info, "js_arg"); - var target = info.IsManagedReturnPosition + string argName = context.GetAdditionalIdentifier(TypeInfo, "js_arg"); + var target = TypeInfo.IsManagedReturnPosition ? Constants.ArgumentReturn : argName; - var source = info.IsManagedReturnPosition - ? Argument(IdentifierName(context.GetIdentifiers(info).native)) - : _inner.AsArgument(info, context); + var source = TypeInfo.IsManagedReturnPosition + ? Argument(IdentifierName(context.GetIdentifiers(TypeInfo).native)) + : _inner.AsArgument(context); - if (context.CurrentStage == StubCodeContext.Stage.UnmarshalCapture && context.Direction == MarshalDirection.ManagedToUnmanaged && info.IsManagedReturnPosition) + if (context.CurrentStage == StubIdentifierContext.Stage.UnmarshalCapture && CodeContext.Direction == MarshalDirection.ManagedToUnmanaged && TypeInfo.IsManagedReturnPosition) { yield return jsty.ResultTypeInfo is JSSimpleTypeInfo(KnownManagedType.Void) ? ToManagedMethodVoid(target, source) : ToManagedMethod(target, source, jsty.ResultTypeInfo.Syntax); } - if (context.CurrentStage == StubCodeContext.Stage.Marshal && context.Direction == MarshalDirection.UnmanagedToManaged && info.IsManagedReturnPosition) + if (context.CurrentStage == StubIdentifierContext.Stage.Marshal && CodeContext.Direction == MarshalDirection.UnmanagedToManaged && TypeInfo.IsManagedReturnPosition) { yield return jsty.ResultTypeInfo is JSSimpleTypeInfo(KnownManagedType.Void) ? ToJSMethodVoid(target, source) : ToJSMethod(target, source, jsty.ResultTypeInfo.Syntax); } - foreach (var x in base.Generate(info, context)) + foreach (var x in base.Generate(context)) { yield return x; } - if (context.CurrentStage == StubCodeContext.Stage.PinnedMarshal && context.Direction == MarshalDirection.ManagedToUnmanaged && !info.IsManagedReturnPosition) + if (context.CurrentStage == StubIdentifierContext.Stage.PinnedMarshal && CodeContext.Direction == MarshalDirection.ManagedToUnmanaged && !TypeInfo.IsManagedReturnPosition) { yield return jsty.ResultTypeInfo is JSSimpleTypeInfo(KnownManagedType.Void) ? ToJSMethodVoid(target, source) : ToJSMethod(target, source, jsty.ResultTypeInfo.Syntax); } - if (context.CurrentStage == StubCodeContext.Stage.Unmarshal && context.Direction == MarshalDirection.UnmanagedToManaged && !info.IsManagedReturnPosition) + if (context.CurrentStage == StubIdentifierContext.Stage.Unmarshal && CodeContext.Direction == MarshalDirection.UnmanagedToManaged && !TypeInfo.IsManagedReturnPosition) { yield return jsty.ResultTypeInfo is JSSimpleTypeInfo(KnownManagedType.Void) ? ToManagedMethodVoid(target, source) diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/VoidGenerator.cs b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/VoidGenerator.cs index 2205323cb7c..2177f5436e4 100644 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/VoidGenerator.cs +++ b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/Marshaling/VoidGenerator.cs @@ -5,11 +5,5 @@ namespace Microsoft.Interop.JavaScript { - internal sealed class VoidGenerator : BaseJSGenerator - { - public VoidGenerator(MarshalerType marshalerType) - : base(marshalerType, new Forwarder()) - { - } - } + internal sealed class VoidGenerator(TypePositionInfo info, StubCodeContext context, MarshalerType marshalerType) : BaseJSGenerator(marshalerType, new Forwarder().Bind(info, context)); } diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/UnreachableException.cs b/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/UnreachableException.cs deleted file mode 100644 index 203657801cc..00000000000 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/gen/JSImportGenerator/UnreachableException.cs +++ /dev/null @@ -1,16 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System; -using System.Collections.Generic; -using System.Text; - -namespace Microsoft.Interop -{ - /// - /// An exception that should be thrown on code-paths that are unreachable. - /// - internal sealed class UnreachableException : Exception - { - } -} diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/tests/JSImportGenerator.UnitTest/CodeSnippets.cs b/src/libraries/System.Runtime.InteropServices.JavaScript/tests/JSImportGenerator.UnitTest/CodeSnippets.cs index 1375df0f7cf..7ef98ebbc63 100644 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/tests/JSImportGenerator.UnitTest/CodeSnippets.cs +++ b/src/libraries/System.Runtime.InteropServices.JavaScript/tests/JSImportGenerator.UnitTest/CodeSnippets.cs @@ -232,6 +232,35 @@ internal static partial void Annotated( } """; + public static readonly string AllAnnotatedExport = """ + //AllAnnotated + using System; + using System.Runtime.InteropServices.JavaScript; + using System.Threading.Tasks; + partial class Basic + { + [JSExport] + internal static void AnnotatedExport( + [JSMarshalAs] object a1, + [JSMarshalAs] long a2, + [JSMarshalAs] long a3, + [JSMarshalAs] Action a4, + [JSMarshalAs>] Func a5, + [JSMarshalAs] Span a6, + [JSMarshalAs] ArraySegment a7, + [JSMarshalAs>] Task a8, + [JSMarshalAs>] object[] a9, + [JSMarshalAs] DateTime a10, + [JSMarshalAs] DateTimeOffset a11, + [JSMarshalAs>] Task a12, + [JSMarshalAs>] Task a13, + [JSMarshalAs>] Task a14, + [JSMarshalAs>] Task a15 + ) + {} + } + """; + public static readonly string AllMissing = """ //AllMissing using System; diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/tests/JSImportGenerator.UnitTest/Compiles.cs b/src/libraries/System.Runtime.InteropServices.JavaScript/tests/JSImportGenerator.UnitTest/Compiles.cs index 22ef1d955ee..7502342d4dd 100644 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/tests/JSImportGenerator.UnitTest/Compiles.cs +++ b/src/libraries/System.Runtime.InteropServices.JavaScript/tests/JSImportGenerator.UnitTest/Compiles.cs @@ -8,6 +8,10 @@ using System; using Xunit; using Microsoft.Interop.UnitTests; +using Microsoft.CodeAnalysis.CSharp.Testing; +using Microsoft.CodeAnalysis.Testing; +using Microsoft.CodeAnalysis.Text; +using System.Text; namespace JSImportGenerator.Unit.Tests { @@ -67,9 +71,9 @@ public static IEnumerable CodeSnippetsToCompile() [Theory] [MemberData(nameof(CodeSnippetsToCompile))] - public async Task ValidateSnippets(string source) + public void ValidateSnippets(string source) { - Compilation comp = await TestUtils.CreateCompilation(source, allowUnsafe: true); + Compilation comp = TestUtils.CreateCompilation(source, allowUnsafe: true); TestUtils.AssertPreSourceGeneratorCompilation(comp); var newComp = TestUtils.RunGenerators(comp, out var generatorDiags, @@ -82,5 +86,220 @@ public async Task ValidateSnippets(string source) TestUtils.AssertPostSourceGeneratorCompilation(newComp); } + + [Fact] + public async Task ValidateGeneratedSourceOutput() + { + var test = new Test() + { + TestState = + { + Sources = { CodeSnippets.AllAnnotated, CodeSnippets.AllAnnotatedExport }, + GeneratedSources = + { + (typeof(Microsoft.Interop.JavaScript.JSImportGenerator), + "JSImports.g.cs", + SourceText.From(""" + // + unsafe partial class Basic + { + [global::System.Diagnostics.DebuggerNonUserCode] + internal static partial void Annotated(object a1, long a2, long a3, global::System.Action a4, global::System.Func a5, global::System.Span a6, global::System.ArraySegment a7, global::System.Threading.Tasks.Task a8, object[] a9, global::System.DateTime a10, global::System.DateTimeOffset a11, global::System.Threading.Tasks.Task a12, global::System.Threading.Tasks.Task a13, global::System.Threading.Tasks.Task a14, global::System.Threading.Tasks.Task a15) + { + if (__signature_Annotated_564258462 == null) + { + __signature_Annotated_564258462 = global::System.Runtime.InteropServices.JavaScript.JSFunctionBinding.BindJSFunction("DoesNotExist", null, new global::System.Runtime.InteropServices.JavaScript.JSMarshalerType[] { global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Discard, global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Object, global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Int52, global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.BigInt64, global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Action(), global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Function(global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Int32), global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Span(global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Byte), global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.ArraySegment(global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Byte), global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Task(global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Object), global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Array(global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Object), global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.DateTime, global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.DateTimeOffset, global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Task(global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.DateTime), global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Task(global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.DateTimeOffset), global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Task(global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Int52), global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Task(global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.BigInt64) }); + } + + global::System.Span __arguments_buffer = stackalloc global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument[17]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __arg_exception = ref __arguments_buffer[0]; + __arg_exception.Initialize(); + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __arg_return = ref __arguments_buffer[1]; + __arg_return.Initialize(); + // Setup - Perform required setup. + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a15_native__js_arg = ref __arguments_buffer[16]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a14_native__js_arg = ref __arguments_buffer[15]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a13_native__js_arg = ref __arguments_buffer[14]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a12_native__js_arg = ref __arguments_buffer[13]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a11_native__js_arg = ref __arguments_buffer[12]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a10_native__js_arg = ref __arguments_buffer[11]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a9_native__js_arg = ref __arguments_buffer[10]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a8_native__js_arg = ref __arguments_buffer[9]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a7_native__js_arg = ref __arguments_buffer[8]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a6_native__js_arg = ref __arguments_buffer[7]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a5_native__js_arg = ref __arguments_buffer[6]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a4_native__js_arg = ref __arguments_buffer[5]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a3_native__js_arg = ref __arguments_buffer[4]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a2_native__js_arg = ref __arguments_buffer[3]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a1_native__js_arg = ref __arguments_buffer[2]; + // PinnedMarshal - Convert managed data to native data that requires the managed data to be pinned. + __a15_native__js_arg.ToJS(a15, static (ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __task_result_arg, long __task_result) => + { + __task_result_arg.ToJSBig(__task_result); + }); + __a14_native__js_arg.ToJS(a14, static (ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __task_result_arg, long __task_result) => + { + __task_result_arg.ToJS(__task_result); + }); + __a13_native__js_arg.ToJS(a13, static (ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __task_result_arg, global::System.DateTimeOffset __task_result) => + { + __task_result_arg.ToJS(__task_result); + }); + __a12_native__js_arg.ToJS(a12, static (ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __task_result_arg, global::System.DateTime __task_result) => + { + __task_result_arg.ToJS(__task_result); + }); + __a11_native__js_arg.ToJS(a11); + __a10_native__js_arg.ToJS(a10); + __a9_native__js_arg.ToJS(a9); + __a8_native__js_arg.ToJS(a8, static (ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __task_result_arg, object __task_result) => + { + __task_result_arg.ToJS(__task_result); + }); + __a7_native__js_arg.ToJS(a7); + __a6_native__js_arg.ToJS(a6); + __a5_native__js_arg.ToJS(a5, static (ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __delegate_arg_arg1, int __delegate_arg1) => + { + __delegate_arg_arg1.ToJS(__delegate_arg1); + }); + __a4_native__js_arg.ToJS(a4); + __a3_native__js_arg.ToJSBig(a3); + __a2_native__js_arg.ToJS(a2); + __a1_native__js_arg.ToJS(a1); + global::System.Runtime.InteropServices.JavaScript.JSFunctionBinding.InvokeJS(__signature_Annotated_564258462, __arguments_buffer); + } + + static global::System.Runtime.InteropServices.JavaScript.JSFunctionBinding __signature_Annotated_564258462; + } + + """.ReplaceLineEndings("\r\n"), Encoding.UTF8)), + (typeof(Microsoft.Interop.JavaScript.JSExportGenerator), + "JSExports.g.cs", + SourceText.From(""" + // + namespace System.Runtime.InteropServices.JavaScript + { + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute] + unsafe class __GeneratedInitializer + { + [global::System.ThreadStaticAttribute] + static bool initialized; + [global::System.Runtime.CompilerServices.ModuleInitializerAttribute, global::System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute(global::System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods | global::System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicMethods, "System.Runtime.InteropServices.JavaScript.__GeneratedInitializer", "TestProject")] + static internal void __TrimmingPreserve_() + { + } + + [global::System.Diagnostics.CodeAnalysis.DynamicDependencyAttribute("__Wrapper_AnnotatedExport_564258462", "Basic", "TestProject")] + static void __Register_() + { + if (initialized || global::System.Runtime.InteropServices.RuntimeInformation.OSArchitecture != global::System.Runtime.InteropServices.Architecture.Wasm) + return; + initialized = true; + global::System.Runtime.InteropServices.JavaScript.JSFunctionBinding.BindManagedFunction("[TestProject]Basic:AnnotatedExport", 564258462, new global::System.Runtime.InteropServices.JavaScript.JSMarshalerType[] { global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Discard, global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Object, global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Int52, global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.BigInt64, global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Action(), global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Function(global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Int32), global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Span(global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Byte), global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.ArraySegment(global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Byte), global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Task(global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Object), global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Array(global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Object), global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.DateTime, global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.DateTimeOffset, global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Task(global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.DateTime), global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Task(global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.DateTimeOffset), global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Task(global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Int52), global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.Task(global::System.Runtime.InteropServices.JavaScript.JSMarshalerType.BigInt64) }); + } + } + } + unsafe partial class Basic + { + [global::System.Diagnostics.DebuggerNonUserCode] + internal static unsafe void __Wrapper_AnnotatedExport_564258462(global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument* __arguments_buffer) + { + object a1; + long a2; + long a3; + global::System.Action a4; + global::System.Func a5; + global::System.Span a6; + global::System.ArraySegment a7; + global::System.Threading.Tasks.Task a8; + object[] a9; + global::System.DateTime a10; + global::System.DateTimeOffset a11; + global::System.Threading.Tasks.Task a12; + global::System.Threading.Tasks.Task a13; + global::System.Threading.Tasks.Task a14; + global::System.Threading.Tasks.Task a15; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __arg_exception = ref __arguments_buffer[0]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __arg_return = ref __arguments_buffer[1]; + // Setup - Perform required setup. + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a15_native__js_arg = ref __arguments_buffer[16]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a14_native__js_arg = ref __arguments_buffer[15]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a13_native__js_arg = ref __arguments_buffer[14]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a12_native__js_arg = ref __arguments_buffer[13]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a11_native__js_arg = ref __arguments_buffer[12]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a10_native__js_arg = ref __arguments_buffer[11]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a9_native__js_arg = ref __arguments_buffer[10]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a8_native__js_arg = ref __arguments_buffer[9]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a7_native__js_arg = ref __arguments_buffer[8]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a6_native__js_arg = ref __arguments_buffer[7]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a5_native__js_arg = ref __arguments_buffer[6]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a4_native__js_arg = ref __arguments_buffer[5]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a3_native__js_arg = ref __arguments_buffer[4]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a2_native__js_arg = ref __arguments_buffer[3]; + ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __a1_native__js_arg = ref __arguments_buffer[2]; + try + { + // Unmarshal - Convert native data to managed data. + __a15_native__js_arg.ToManaged(out a15, static (ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __task_result_arg, out long __task_result) => + { + __task_result_arg.ToManagedBig(out __task_result); + }); + __a14_native__js_arg.ToManaged(out a14, static (ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __task_result_arg, out long __task_result) => + { + __task_result_arg.ToManaged(out __task_result); + }); + __a13_native__js_arg.ToManaged(out a13, static (ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __task_result_arg, out global::System.DateTimeOffset __task_result) => + { + __task_result_arg.ToManaged(out __task_result); + }); + __a12_native__js_arg.ToManaged(out a12, static (ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __task_result_arg, out global::System.DateTime __task_result) => + { + __task_result_arg.ToManaged(out __task_result); + }); + __a11_native__js_arg.ToManaged(out a11); + __a10_native__js_arg.ToManaged(out a10); + __a9_native__js_arg.ToManaged(out a9); + __a8_native__js_arg.ToManaged(out a8, static (ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __task_result_arg, out object __task_result) => + { + __task_result_arg.ToManaged(out __task_result); + }); + __a7_native__js_arg.ToManaged(out a7); + __a6_native__js_arg.ToManaged(out a6); + __a5_native__js_arg.ToManaged(out a5, static (ref global::System.Runtime.InteropServices.JavaScript.JSMarshalerArgument __delegate_arg_arg1, out int __delegate_arg1) => + { + __delegate_arg_arg1.ToManaged(out __delegate_arg1); + }); + __a4_native__js_arg.ToManaged(out a4); + __a3_native__js_arg.ToManagedBig(out a3); + __a2_native__js_arg.ToManaged(out a2); + __a1_native__js_arg.ToManaged(out a1); + Basic.AnnotatedExport(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15); + } + catch (global::System.Exception ex) + { + __arg_exception.ToJS(ex); + } + } + } + + """.ReplaceLineEndings("\r\n"), Encoding.UTF8)), + } + }, + }; + + await test.RunAsync(); + } + + private sealed class Test : CSharpAnalyzerTest + { + public Test() + { + ReferenceAssemblies = new ReferenceAssemblies(string.Empty); + TestState.AdditionalReferences.AddRange(SourceGenerators.Tests.LiveReferencePack.GetMetadataReferences()); + } + + protected override IEnumerable GetSourceGenerators() + => [typeof(Microsoft.Interop.JavaScript.JSImportGenerator), typeof(Microsoft.Interop.JavaScript.JSExportGenerator)]; + } } } diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/tests/JSImportGenerator.UnitTest/Fails.cs b/src/libraries/System.Runtime.InteropServices.JavaScript/tests/JSImportGenerator.UnitTest/Fails.cs index 271ce65e633..197c4282b93 100644 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/tests/JSImportGenerator.UnitTest/Fails.cs +++ b/src/libraries/System.Runtime.InteropServices.JavaScript/tests/JSImportGenerator.UnitTest/Fails.cs @@ -76,9 +76,9 @@ public async Task ValidateAsyncEntryPointFailSnippets(string source, string gene [Theory] [MemberData(nameof(CodeSnippetsToFail))] - public async Task ValidateFailSnippets(string source, string[]? generatorMessages, string[]? compilerMessages) + public void ValidateFailSnippets(string source, string[]? generatorMessages, string[]? compilerMessages) { - Compilation comp = await TestUtils.CreateCompilation(source, allowUnsafe: true); + Compilation comp = TestUtils.CreateCompilation(source, allowUnsafe: true); TestUtils.AssertPreSourceGeneratorCompilation(comp); var newComp = TestUtils.RunGenerators(comp, out var generatorDiags, @@ -98,10 +98,10 @@ public async Task ValidateFailSnippets(string source, string[]? generatorMessage } [Fact] - public async Task ValidateRequireAllowUnsafeBlocksDiagnostic() + public void ValidateRequireAllowUnsafeBlocksDiagnostic() { string source = CodeSnippets.TrivialClassDeclarations; - Compilation comp = await TestUtils.CreateCompilation(new[] { source }, allowUnsafe: false); + Compilation comp = TestUtils.CreateCompilation(new[] { source }, allowUnsafe: false); TestUtils.AssertPreSourceGeneratorCompilation(comp); var newComp = TestUtils.RunGenerators(comp, out var generatorDiags, diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/tests/System.Runtime.InteropServices.JavaScript.UnitTests/System.Runtime.InteropServices.JavaScript.Tests.csproj b/src/libraries/System.Runtime.InteropServices.JavaScript/tests/System.Runtime.InteropServices.JavaScript.UnitTests/System.Runtime.InteropServices.JavaScript.Tests.csproj index db65ab6f9c5..70b12693650 100644 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/tests/System.Runtime.InteropServices.JavaScript.UnitTests/System.Runtime.InteropServices.JavaScript.Tests.csproj +++ b/src/libraries/System.Runtime.InteropServices.JavaScript/tests/System.Runtime.InteropServices.JavaScript.UnitTests/System.Runtime.InteropServices.JavaScript.Tests.csproj @@ -1,39 +1,45 @@ + + - $([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) + $(NetCoreAppCurrent)-browser true - $(NetCoreAppCurrent)-browser true $(WasmXHarnessArgs) --engine-arg=--expose-gc --web-server-use-cop true true - true + true $(DefineConstants);FEATURE_WASM_MANAGED_THREADS true 1 + true + $(NoWarn);IL2103;IL2025;IL2111;IL2122 + true + true false - - true - + + + + @@ -44,20 +50,25 @@ + + + + + diff --git a/src/libraries/System.Runtime.InteropServices.JavaScript/tests/System.Runtime.InteropServices.JavaScript.UnitTests/System/Runtime/InteropServices/JavaScript/JSImportTest.cs b/src/libraries/System.Runtime.InteropServices.JavaScript/tests/System.Runtime.InteropServices.JavaScript.UnitTests/System/Runtime/InteropServices/JavaScript/JSImportTest.cs index 987bc6a2e7a..f2d45a51123 100644 --- a/src/libraries/System.Runtime.InteropServices.JavaScript/tests/System.Runtime.InteropServices.JavaScript.UnitTests/System/Runtime/InteropServices/JavaScript/JSImportTest.cs +++ b/src/libraries/System.Runtime.InteropServices.JavaScript/tests/System.Runtime.InteropServices.JavaScript.UnitTests/System/Runtime/InteropServices/JavaScript/JSImportTest.cs @@ -238,7 +238,7 @@ public unsafe void CreateFunctionString() [Fact] public unsafe void CreateFunctionInternal() { - Func internals = Utils.CreateFunctionBool("return true"); + Func internals = Utils.CreateFunctionBool("return INTERNAL.mono_wasm_runtime_is_ready"); Assert.True(internals()); } diff --git a/src/libraries/System.Runtime.InteropServices/System.Runtime.InteropServices.sln b/src/libraries/System.Runtime.InteropServices/System.Runtime.InteropServices.sln index f2cd248fa7b..831c8b8039b 100644 --- a/src/libraries/System.Runtime.InteropServices/System.Runtime.InteropServices.sln +++ b/src/libraries/System.Runtime.InteropServices/System.Runtime.InteropServices.sln @@ -1,8 +1,4 @@ - -Microsoft Visual Studio Solution File, Format Version 12.00 -# Visual Studio Version 17 -VisualStudioVersion = 17.9.34226.241 -MinimumVisualStudioVersion = 10.0.40219.1 +Microsoft Visual Studio Solution File, Format Version 12.00 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\..\coreclr\System.Private.CoreLib\System.Private.CoreLib.csproj", "{94B59BA0-491F-4B59-ADFF-A057EC3EC835}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{1FF4CC8E-49C3-42A0-A6E0-2E5908455FBA}" @@ -25,6 +21,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", ". EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{C3EA0A28-A597-4946-9E08-EBBBFA94BFA5}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{DD1873BA-2928-464A-B368-7AEFB1E49FD8}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{90CDAD9F-3ACC-43B0-9696-0C849FCD8C40}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{768B77B0-EA45-469D-B39E-545EB72F5A43}" @@ -67,29 +65,24 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Mono.Linker", "..\..\tools\ EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Mono.Linker", "..\..\tools\illink\src\linker\ref\Mono.Linker.csproj", "{B36C9254-0C55-414E-8403-03B4F18D5F35}" EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{9DA56ADF-7AA4-4752-BD91-330F674AAF18}" +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{D5382D82-CC63-4781-A57B-4398A9757BDF}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{FB99AC59-1744-4F12-A4B0-0D54FCA048BF}" EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ref", "ref", "{97B027E5-35BC-4B07-A030-F5C5085C281C}" -EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "gen", "gen", "{0522E1B2-BF32-4B3A-A74C-1CBF642E85E4}" +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ref", "ref", "{1FBC0A06-EE6A-4B51-BFA8-8EF93B6EE574}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "gen", "gen", "{A043B2C0-71A2-4933-900B-E5DFDCB2B508}" EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{D5382D82-CC63-4781-A57B-4398A9757BDF}" +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "gen", "tools\gen", "{962D3C8C-5E06-4E45-BCEC-A7BE2D1BCBDC}" EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ref", "ref", "{1FBC0A06-EE6A-4B51-BFA8-8EF93B6EE574}" +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "tools\src", "{8800B107-6C99-4025-AD74-E6A25D2457B8}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ref", "tools\ref", "{4EFB09EB-10DB-4C5C-B823-E0673D656073}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tools", "tools", "{8FA3249B-3567-4C76-BA32-9488FC92994D}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution - Checked|Any CPU = Checked|Any CPU - Checked|arm = Checked|arm - Checked|arm64 = Checked|arm64 - Checked|x64 = Checked|x64 - Checked|x86 = Checked|x86 Debug|Any CPU = Debug|Any CPU Debug|arm = Debug|arm Debug|arm64 = Debug|arm64 @@ -100,18 +93,13 @@ Global Release|arm64 = Release|arm64 Release|x64 = Release|x64 Release|x86 = Release|x86 + Checked|Any CPU = Checked|Any CPU + Checked|arm = Checked|arm + Checked|arm64 = Checked|arm64 + Checked|x64 = Checked|x64 + Checked|x86 = Checked|x86 EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution - {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Checked|Any CPU.ActiveCfg = Checked|x64 - {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Checked|Any CPU.Build.0 = Checked|x64 - {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Checked|arm.ActiveCfg = Checked|arm - {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Checked|arm.Build.0 = Checked|arm - {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Checked|arm64.ActiveCfg = Checked|arm64 - {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Checked|arm64.Build.0 = Checked|arm64 - {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Checked|x64.ActiveCfg = Checked|x64 - {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Checked|x64.Build.0 = Checked|x64 - {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Checked|x86.ActiveCfg = Checked|x86 - {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Checked|x86.Build.0 = Checked|x86 {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Debug|Any CPU.ActiveCfg = Debug|x64 {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Debug|Any CPU.Build.0 = Debug|x64 {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Debug|arm.ActiveCfg = Debug|arm @@ -132,11 +120,16 @@ Global {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Release|x64.Build.0 = Release|x64 {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Release|x86.ActiveCfg = Release|x86 {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Release|x86.Build.0 = Release|x86 - {1FF4CC8E-49C3-42A0-A6E0-2E5908455FBA}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {1FF4CC8E-49C3-42A0-A6E0-2E5908455FBA}.Checked|arm.ActiveCfg = Debug|Any CPU - {1FF4CC8E-49C3-42A0-A6E0-2E5908455FBA}.Checked|arm64.ActiveCfg = Debug|Any CPU - {1FF4CC8E-49C3-42A0-A6E0-2E5908455FBA}.Checked|x64.ActiveCfg = Debug|Any CPU - {1FF4CC8E-49C3-42A0-A6E0-2E5908455FBA}.Checked|x86.ActiveCfg = Debug|Any CPU + {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Checked|Any CPU.ActiveCfg = Checked|x64 + {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Checked|Any CPU.Build.0 = Checked|x64 + {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Checked|arm.ActiveCfg = Checked|arm + {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Checked|arm.Build.0 = Checked|arm + {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Checked|arm64.ActiveCfg = Checked|arm64 + {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Checked|arm64.Build.0 = Checked|arm64 + {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Checked|x64.ActiveCfg = Checked|x64 + {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Checked|x64.Build.0 = Checked|x64 + {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Checked|x86.ActiveCfg = Checked|x86 + {94B59BA0-491F-4B59-ADFF-A057EC3EC835}.Checked|x86.Build.0 = Checked|x86 {1FF4CC8E-49C3-42A0-A6E0-2E5908455FBA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {1FF4CC8E-49C3-42A0-A6E0-2E5908455FBA}.Debug|Any CPU.Build.0 = Debug|Any CPU {1FF4CC8E-49C3-42A0-A6E0-2E5908455FBA}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -153,11 +146,11 @@ Global {1FF4CC8E-49C3-42A0-A6E0-2E5908455FBA}.Release|x64.Build.0 = Release|Any CPU {1FF4CC8E-49C3-42A0-A6E0-2E5908455FBA}.Release|x86.ActiveCfg = Release|Any CPU {1FF4CC8E-49C3-42A0-A6E0-2E5908455FBA}.Release|x86.Build.0 = Release|Any CPU - {0E0D5A1F-0212-4CEB-BADA-E1E3ABD395A0}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {0E0D5A1F-0212-4CEB-BADA-E1E3ABD395A0}.Checked|arm.ActiveCfg = Debug|Any CPU - {0E0D5A1F-0212-4CEB-BADA-E1E3ABD395A0}.Checked|arm64.ActiveCfg = Debug|Any CPU - {0E0D5A1F-0212-4CEB-BADA-E1E3ABD395A0}.Checked|x64.ActiveCfg = Debug|Any CPU - {0E0D5A1F-0212-4CEB-BADA-E1E3ABD395A0}.Checked|x86.ActiveCfg = Debug|Any CPU + {1FF4CC8E-49C3-42A0-A6E0-2E5908455FBA}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {1FF4CC8E-49C3-42A0-A6E0-2E5908455FBA}.Checked|arm.ActiveCfg = Debug|Any CPU + {1FF4CC8E-49C3-42A0-A6E0-2E5908455FBA}.Checked|arm64.ActiveCfg = Debug|Any CPU + {1FF4CC8E-49C3-42A0-A6E0-2E5908455FBA}.Checked|x64.ActiveCfg = Debug|Any CPU + {1FF4CC8E-49C3-42A0-A6E0-2E5908455FBA}.Checked|x86.ActiveCfg = Debug|Any CPU {0E0D5A1F-0212-4CEB-BADA-E1E3ABD395A0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {0E0D5A1F-0212-4CEB-BADA-E1E3ABD395A0}.Debug|Any CPU.Build.0 = Debug|Any CPU {0E0D5A1F-0212-4CEB-BADA-E1E3ABD395A0}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -174,11 +167,11 @@ Global {0E0D5A1F-0212-4CEB-BADA-E1E3ABD395A0}.Release|x64.Build.0 = Release|Any CPU {0E0D5A1F-0212-4CEB-BADA-E1E3ABD395A0}.Release|x86.ActiveCfg = Release|Any CPU {0E0D5A1F-0212-4CEB-BADA-E1E3ABD395A0}.Release|x86.Build.0 = Release|Any CPU - {F552E4E4-20EE-484C-84F8-4FB3A3BD2E69}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {F552E4E4-20EE-484C-84F8-4FB3A3BD2E69}.Checked|arm.ActiveCfg = Debug|Any CPU - {F552E4E4-20EE-484C-84F8-4FB3A3BD2E69}.Checked|arm64.ActiveCfg = Debug|Any CPU - {F552E4E4-20EE-484C-84F8-4FB3A3BD2E69}.Checked|x64.ActiveCfg = Debug|Any CPU - {F552E4E4-20EE-484C-84F8-4FB3A3BD2E69}.Checked|x86.ActiveCfg = Debug|Any CPU + {0E0D5A1F-0212-4CEB-BADA-E1E3ABD395A0}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {0E0D5A1F-0212-4CEB-BADA-E1E3ABD395A0}.Checked|arm.ActiveCfg = Debug|Any CPU + {0E0D5A1F-0212-4CEB-BADA-E1E3ABD395A0}.Checked|arm64.ActiveCfg = Debug|Any CPU + {0E0D5A1F-0212-4CEB-BADA-E1E3ABD395A0}.Checked|x64.ActiveCfg = Debug|Any CPU + {0E0D5A1F-0212-4CEB-BADA-E1E3ABD395A0}.Checked|x86.ActiveCfg = Debug|Any CPU {F552E4E4-20EE-484C-84F8-4FB3A3BD2E69}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {F552E4E4-20EE-484C-84F8-4FB3A3BD2E69}.Debug|Any CPU.Build.0 = Debug|Any CPU {F552E4E4-20EE-484C-84F8-4FB3A3BD2E69}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -195,11 +188,11 @@ Global {F552E4E4-20EE-484C-84F8-4FB3A3BD2E69}.Release|x64.Build.0 = Release|Any CPU {F552E4E4-20EE-484C-84F8-4FB3A3BD2E69}.Release|x86.ActiveCfg = Release|Any CPU {F552E4E4-20EE-484C-84F8-4FB3A3BD2E69}.Release|x86.Build.0 = Release|Any CPU - {4859BEE3-34B7-48E7-83D4-1ADD8B8F3B3A}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {4859BEE3-34B7-48E7-83D4-1ADD8B8F3B3A}.Checked|arm.ActiveCfg = Debug|Any CPU - {4859BEE3-34B7-48E7-83D4-1ADD8B8F3B3A}.Checked|arm64.ActiveCfg = Debug|Any CPU - {4859BEE3-34B7-48E7-83D4-1ADD8B8F3B3A}.Checked|x64.ActiveCfg = Debug|Any CPU - {4859BEE3-34B7-48E7-83D4-1ADD8B8F3B3A}.Checked|x86.ActiveCfg = Debug|Any CPU + {F552E4E4-20EE-484C-84F8-4FB3A3BD2E69}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {F552E4E4-20EE-484C-84F8-4FB3A3BD2E69}.Checked|arm.ActiveCfg = Debug|Any CPU + {F552E4E4-20EE-484C-84F8-4FB3A3BD2E69}.Checked|arm64.ActiveCfg = Debug|Any CPU + {F552E4E4-20EE-484C-84F8-4FB3A3BD2E69}.Checked|x64.ActiveCfg = Debug|Any CPU + {F552E4E4-20EE-484C-84F8-4FB3A3BD2E69}.Checked|x86.ActiveCfg = Debug|Any CPU {4859BEE3-34B7-48E7-83D4-1ADD8B8F3B3A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {4859BEE3-34B7-48E7-83D4-1ADD8B8F3B3A}.Debug|Any CPU.Build.0 = Debug|Any CPU {4859BEE3-34B7-48E7-83D4-1ADD8B8F3B3A}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -216,11 +209,11 @@ Global {4859BEE3-34B7-48E7-83D4-1ADD8B8F3B3A}.Release|x64.Build.0 = Release|Any CPU {4859BEE3-34B7-48E7-83D4-1ADD8B8F3B3A}.Release|x86.ActiveCfg = Release|Any CPU {4859BEE3-34B7-48E7-83D4-1ADD8B8F3B3A}.Release|x86.Build.0 = Release|Any CPU - {C4B641C3-3317-4913-91DA-0DA3B64BABED}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {C4B641C3-3317-4913-91DA-0DA3B64BABED}.Checked|arm.ActiveCfg = Debug|Any CPU - {C4B641C3-3317-4913-91DA-0DA3B64BABED}.Checked|arm64.ActiveCfg = Debug|Any CPU - {C4B641C3-3317-4913-91DA-0DA3B64BABED}.Checked|x64.ActiveCfg = Debug|Any CPU - {C4B641C3-3317-4913-91DA-0DA3B64BABED}.Checked|x86.ActiveCfg = Debug|Any CPU + {4859BEE3-34B7-48E7-83D4-1ADD8B8F3B3A}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {4859BEE3-34B7-48E7-83D4-1ADD8B8F3B3A}.Checked|arm.ActiveCfg = Debug|Any CPU + {4859BEE3-34B7-48E7-83D4-1ADD8B8F3B3A}.Checked|arm64.ActiveCfg = Debug|Any CPU + {4859BEE3-34B7-48E7-83D4-1ADD8B8F3B3A}.Checked|x64.ActiveCfg = Debug|Any CPU + {4859BEE3-34B7-48E7-83D4-1ADD8B8F3B3A}.Checked|x86.ActiveCfg = Debug|Any CPU {C4B641C3-3317-4913-91DA-0DA3B64BABED}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {C4B641C3-3317-4913-91DA-0DA3B64BABED}.Debug|Any CPU.Build.0 = Debug|Any CPU {C4B641C3-3317-4913-91DA-0DA3B64BABED}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -237,11 +230,11 @@ Global {C4B641C3-3317-4913-91DA-0DA3B64BABED}.Release|x64.Build.0 = Release|Any CPU {C4B641C3-3317-4913-91DA-0DA3B64BABED}.Release|x86.ActiveCfg = Release|Any CPU {C4B641C3-3317-4913-91DA-0DA3B64BABED}.Release|x86.Build.0 = Release|Any CPU - {3FB6F2AA-E763-4336-B927-18AB7AAF6C20}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {3FB6F2AA-E763-4336-B927-18AB7AAF6C20}.Checked|arm.ActiveCfg = Debug|Any CPU - {3FB6F2AA-E763-4336-B927-18AB7AAF6C20}.Checked|arm64.ActiveCfg = Debug|Any CPU - {3FB6F2AA-E763-4336-B927-18AB7AAF6C20}.Checked|x64.ActiveCfg = Debug|Any CPU - {3FB6F2AA-E763-4336-B927-18AB7AAF6C20}.Checked|x86.ActiveCfg = Debug|Any CPU + {C4B641C3-3317-4913-91DA-0DA3B64BABED}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {C4B641C3-3317-4913-91DA-0DA3B64BABED}.Checked|arm.ActiveCfg = Debug|Any CPU + {C4B641C3-3317-4913-91DA-0DA3B64BABED}.Checked|arm64.ActiveCfg = Debug|Any CPU + {C4B641C3-3317-4913-91DA-0DA3B64BABED}.Checked|x64.ActiveCfg = Debug|Any CPU + {C4B641C3-3317-4913-91DA-0DA3B64BABED}.Checked|x86.ActiveCfg = Debug|Any CPU {3FB6F2AA-E763-4336-B927-18AB7AAF6C20}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {3FB6F2AA-E763-4336-B927-18AB7AAF6C20}.Debug|Any CPU.Build.0 = Debug|Any CPU {3FB6F2AA-E763-4336-B927-18AB7AAF6C20}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -258,11 +251,11 @@ Global {3FB6F2AA-E763-4336-B927-18AB7AAF6C20}.Release|x64.Build.0 = Release|Any CPU {3FB6F2AA-E763-4336-B927-18AB7AAF6C20}.Release|x86.ActiveCfg = Release|Any CPU {3FB6F2AA-E763-4336-B927-18AB7AAF6C20}.Release|x86.Build.0 = Release|Any CPU - {716ED44B-37C8-4776-BE70-285952D2B30D}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {716ED44B-37C8-4776-BE70-285952D2B30D}.Checked|arm.ActiveCfg = Debug|Any CPU - {716ED44B-37C8-4776-BE70-285952D2B30D}.Checked|arm64.ActiveCfg = Debug|Any CPU - {716ED44B-37C8-4776-BE70-285952D2B30D}.Checked|x64.ActiveCfg = Debug|Any CPU - {716ED44B-37C8-4776-BE70-285952D2B30D}.Checked|x86.ActiveCfg = Debug|Any CPU + {3FB6F2AA-E763-4336-B927-18AB7AAF6C20}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {3FB6F2AA-E763-4336-B927-18AB7AAF6C20}.Checked|arm.ActiveCfg = Debug|Any CPU + {3FB6F2AA-E763-4336-B927-18AB7AAF6C20}.Checked|arm64.ActiveCfg = Debug|Any CPU + {3FB6F2AA-E763-4336-B927-18AB7AAF6C20}.Checked|x64.ActiveCfg = Debug|Any CPU + {3FB6F2AA-E763-4336-B927-18AB7AAF6C20}.Checked|x86.ActiveCfg = Debug|Any CPU {716ED44B-37C8-4776-BE70-285952D2B30D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {716ED44B-37C8-4776-BE70-285952D2B30D}.Debug|Any CPU.Build.0 = Debug|Any CPU {716ED44B-37C8-4776-BE70-285952D2B30D}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -279,11 +272,11 @@ Global {716ED44B-37C8-4776-BE70-285952D2B30D}.Release|x64.Build.0 = Release|Any CPU {716ED44B-37C8-4776-BE70-285952D2B30D}.Release|x86.ActiveCfg = Release|Any CPU {716ED44B-37C8-4776-BE70-285952D2B30D}.Release|x86.Build.0 = Release|Any CPU - {1B248B4C-7584-4C04-850A-A50EB592052C}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {1B248B4C-7584-4C04-850A-A50EB592052C}.Checked|arm.ActiveCfg = Debug|Any CPU - {1B248B4C-7584-4C04-850A-A50EB592052C}.Checked|arm64.ActiveCfg = Debug|Any CPU - {1B248B4C-7584-4C04-850A-A50EB592052C}.Checked|x64.ActiveCfg = Debug|Any CPU - {1B248B4C-7584-4C04-850A-A50EB592052C}.Checked|x86.ActiveCfg = Debug|Any CPU + {716ED44B-37C8-4776-BE70-285952D2B30D}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {716ED44B-37C8-4776-BE70-285952D2B30D}.Checked|arm.ActiveCfg = Debug|Any CPU + {716ED44B-37C8-4776-BE70-285952D2B30D}.Checked|arm64.ActiveCfg = Debug|Any CPU + {716ED44B-37C8-4776-BE70-285952D2B30D}.Checked|x64.ActiveCfg = Debug|Any CPU + {716ED44B-37C8-4776-BE70-285952D2B30D}.Checked|x86.ActiveCfg = Debug|Any CPU {1B248B4C-7584-4C04-850A-A50EB592052C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {1B248B4C-7584-4C04-850A-A50EB592052C}.Debug|Any CPU.Build.0 = Debug|Any CPU {1B248B4C-7584-4C04-850A-A50EB592052C}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -300,11 +293,11 @@ Global {1B248B4C-7584-4C04-850A-A50EB592052C}.Release|x64.Build.0 = Release|Any CPU {1B248B4C-7584-4C04-850A-A50EB592052C}.Release|x86.ActiveCfg = Release|Any CPU {1B248B4C-7584-4C04-850A-A50EB592052C}.Release|x86.Build.0 = Release|Any CPU - {EF39CC5C-7A3B-40F2-82B6-C1C8BBC3F886}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {EF39CC5C-7A3B-40F2-82B6-C1C8BBC3F886}.Checked|arm.ActiveCfg = Debug|Any CPU - {EF39CC5C-7A3B-40F2-82B6-C1C8BBC3F886}.Checked|arm64.ActiveCfg = Debug|Any CPU - {EF39CC5C-7A3B-40F2-82B6-C1C8BBC3F886}.Checked|x64.ActiveCfg = Debug|Any CPU - {EF39CC5C-7A3B-40F2-82B6-C1C8BBC3F886}.Checked|x86.ActiveCfg = Debug|Any CPU + {1B248B4C-7584-4C04-850A-A50EB592052C}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {1B248B4C-7584-4C04-850A-A50EB592052C}.Checked|arm.ActiveCfg = Debug|Any CPU + {1B248B4C-7584-4C04-850A-A50EB592052C}.Checked|arm64.ActiveCfg = Debug|Any CPU + {1B248B4C-7584-4C04-850A-A50EB592052C}.Checked|x64.ActiveCfg = Debug|Any CPU + {1B248B4C-7584-4C04-850A-A50EB592052C}.Checked|x86.ActiveCfg = Debug|Any CPU {EF39CC5C-7A3B-40F2-82B6-C1C8BBC3F886}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {EF39CC5C-7A3B-40F2-82B6-C1C8BBC3F886}.Debug|Any CPU.Build.0 = Debug|Any CPU {EF39CC5C-7A3B-40F2-82B6-C1C8BBC3F886}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -321,11 +314,11 @@ Global {EF39CC5C-7A3B-40F2-82B6-C1C8BBC3F886}.Release|x64.Build.0 = Release|Any CPU {EF39CC5C-7A3B-40F2-82B6-C1C8BBC3F886}.Release|x86.ActiveCfg = Release|Any CPU {EF39CC5C-7A3B-40F2-82B6-C1C8BBC3F886}.Release|x86.Build.0 = Release|Any CPU - {C3EA0A28-A597-4946-9E08-EBBBFA94BFA5}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {C3EA0A28-A597-4946-9E08-EBBBFA94BFA5}.Checked|arm.ActiveCfg = Debug|Any CPU - {C3EA0A28-A597-4946-9E08-EBBBFA94BFA5}.Checked|arm64.ActiveCfg = Debug|Any CPU - {C3EA0A28-A597-4946-9E08-EBBBFA94BFA5}.Checked|x64.ActiveCfg = Debug|Any CPU - {C3EA0A28-A597-4946-9E08-EBBBFA94BFA5}.Checked|x86.ActiveCfg = Debug|Any CPU + {EF39CC5C-7A3B-40F2-82B6-C1C8BBC3F886}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {EF39CC5C-7A3B-40F2-82B6-C1C8BBC3F886}.Checked|arm.ActiveCfg = Debug|Any CPU + {EF39CC5C-7A3B-40F2-82B6-C1C8BBC3F886}.Checked|arm64.ActiveCfg = Debug|Any CPU + {EF39CC5C-7A3B-40F2-82B6-C1C8BBC3F886}.Checked|x64.ActiveCfg = Debug|Any CPU + {EF39CC5C-7A3B-40F2-82B6-C1C8BBC3F886}.Checked|x86.ActiveCfg = Debug|Any CPU {C3EA0A28-A597-4946-9E08-EBBBFA94BFA5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {C3EA0A28-A597-4946-9E08-EBBBFA94BFA5}.Debug|Any CPU.Build.0 = Debug|Any CPU {C3EA0A28-A597-4946-9E08-EBBBFA94BFA5}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -342,11 +335,32 @@ Global {C3EA0A28-A597-4946-9E08-EBBBFA94BFA5}.Release|x64.Build.0 = Release|Any CPU {C3EA0A28-A597-4946-9E08-EBBBFA94BFA5}.Release|x86.ActiveCfg = Release|Any CPU {C3EA0A28-A597-4946-9E08-EBBBFA94BFA5}.Release|x86.Build.0 = Release|Any CPU - {90CDAD9F-3ACC-43B0-9696-0C849FCD8C40}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {90CDAD9F-3ACC-43B0-9696-0C849FCD8C40}.Checked|arm.ActiveCfg = Debug|Any CPU - {90CDAD9F-3ACC-43B0-9696-0C849FCD8C40}.Checked|arm64.ActiveCfg = Debug|Any CPU - {90CDAD9F-3ACC-43B0-9696-0C849FCD8C40}.Checked|x64.ActiveCfg = Debug|Any CPU - {90CDAD9F-3ACC-43B0-9696-0C849FCD8C40}.Checked|x86.ActiveCfg = Debug|Any CPU + {C3EA0A28-A597-4946-9E08-EBBBFA94BFA5}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {C3EA0A28-A597-4946-9E08-EBBBFA94BFA5}.Checked|arm.ActiveCfg = Debug|Any CPU + {C3EA0A28-A597-4946-9E08-EBBBFA94BFA5}.Checked|arm64.ActiveCfg = Debug|Any CPU + {C3EA0A28-A597-4946-9E08-EBBBFA94BFA5}.Checked|x64.ActiveCfg = Debug|Any CPU + {C3EA0A28-A597-4946-9E08-EBBBFA94BFA5}.Checked|x86.ActiveCfg = Debug|Any CPU + {DD1873BA-2928-464A-B368-7AEFB1E49FD8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {DD1873BA-2928-464A-B368-7AEFB1E49FD8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {DD1873BA-2928-464A-B368-7AEFB1E49FD8}.Debug|arm.ActiveCfg = Debug|Any CPU + {DD1873BA-2928-464A-B368-7AEFB1E49FD8}.Debug|arm64.ActiveCfg = Debug|Any CPU + {DD1873BA-2928-464A-B368-7AEFB1E49FD8}.Debug|x64.ActiveCfg = Debug|Any CPU + {DD1873BA-2928-464A-B368-7AEFB1E49FD8}.Debug|x64.Build.0 = Debug|Any CPU + {DD1873BA-2928-464A-B368-7AEFB1E49FD8}.Debug|x86.ActiveCfg = Debug|Any CPU + {DD1873BA-2928-464A-B368-7AEFB1E49FD8}.Debug|x86.Build.0 = Debug|Any CPU + {DD1873BA-2928-464A-B368-7AEFB1E49FD8}.Release|Any CPU.ActiveCfg = Release|Any CPU + {DD1873BA-2928-464A-B368-7AEFB1E49FD8}.Release|Any CPU.Build.0 = Release|Any CPU + {DD1873BA-2928-464A-B368-7AEFB1E49FD8}.Release|arm.ActiveCfg = Release|Any CPU + {DD1873BA-2928-464A-B368-7AEFB1E49FD8}.Release|arm64.ActiveCfg = Release|Any CPU + {DD1873BA-2928-464A-B368-7AEFB1E49FD8}.Release|x64.ActiveCfg = Release|Any CPU + {DD1873BA-2928-464A-B368-7AEFB1E49FD8}.Release|x64.Build.0 = Release|Any CPU + {DD1873BA-2928-464A-B368-7AEFB1E49FD8}.Release|x86.ActiveCfg = Release|Any CPU + {DD1873BA-2928-464A-B368-7AEFB1E49FD8}.Release|x86.Build.0 = Release|Any CPU + {DD1873BA-2928-464A-B368-7AEFB1E49FD8}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {DD1873BA-2928-464A-B368-7AEFB1E49FD8}.Checked|arm.ActiveCfg = Debug|Any CPU + {DD1873BA-2928-464A-B368-7AEFB1E49FD8}.Checked|arm64.ActiveCfg = Debug|Any CPU + {DD1873BA-2928-464A-B368-7AEFB1E49FD8}.Checked|x64.ActiveCfg = Debug|Any CPU + {DD1873BA-2928-464A-B368-7AEFB1E49FD8}.Checked|x86.ActiveCfg = Debug|Any CPU {90CDAD9F-3ACC-43B0-9696-0C849FCD8C40}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {90CDAD9F-3ACC-43B0-9696-0C849FCD8C40}.Debug|Any CPU.Build.0 = Debug|Any CPU {90CDAD9F-3ACC-43B0-9696-0C849FCD8C40}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -363,11 +377,11 @@ Global {90CDAD9F-3ACC-43B0-9696-0C849FCD8C40}.Release|x64.Build.0 = Release|Any CPU {90CDAD9F-3ACC-43B0-9696-0C849FCD8C40}.Release|x86.ActiveCfg = Release|Any CPU {90CDAD9F-3ACC-43B0-9696-0C849FCD8C40}.Release|x86.Build.0 = Release|Any CPU - {768B77B0-EA45-469D-B39E-545EB72F5A43}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {768B77B0-EA45-469D-B39E-545EB72F5A43}.Checked|arm.ActiveCfg = Debug|Any CPU - {768B77B0-EA45-469D-B39E-545EB72F5A43}.Checked|arm64.ActiveCfg = Debug|Any CPU - {768B77B0-EA45-469D-B39E-545EB72F5A43}.Checked|x64.ActiveCfg = Debug|Any CPU - {768B77B0-EA45-469D-B39E-545EB72F5A43}.Checked|x86.ActiveCfg = Debug|Any CPU + {90CDAD9F-3ACC-43B0-9696-0C849FCD8C40}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {90CDAD9F-3ACC-43B0-9696-0C849FCD8C40}.Checked|arm.ActiveCfg = Debug|Any CPU + {90CDAD9F-3ACC-43B0-9696-0C849FCD8C40}.Checked|arm64.ActiveCfg = Debug|Any CPU + {90CDAD9F-3ACC-43B0-9696-0C849FCD8C40}.Checked|x64.ActiveCfg = Debug|Any CPU + {90CDAD9F-3ACC-43B0-9696-0C849FCD8C40}.Checked|x86.ActiveCfg = Debug|Any CPU {768B77B0-EA45-469D-B39E-545EB72F5A43}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {768B77B0-EA45-469D-B39E-545EB72F5A43}.Debug|Any CPU.Build.0 = Debug|Any CPU {768B77B0-EA45-469D-B39E-545EB72F5A43}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -384,11 +398,11 @@ Global {768B77B0-EA45-469D-B39E-545EB72F5A43}.Release|x64.Build.0 = Release|Any CPU {768B77B0-EA45-469D-B39E-545EB72F5A43}.Release|x86.ActiveCfg = Release|Any CPU {768B77B0-EA45-469D-B39E-545EB72F5A43}.Release|x86.Build.0 = Release|Any CPU - {8671F164-F78C-44FA-93B7-A310F67890FE}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {8671F164-F78C-44FA-93B7-A310F67890FE}.Checked|arm.ActiveCfg = Debug|Any CPU - {8671F164-F78C-44FA-93B7-A310F67890FE}.Checked|arm64.ActiveCfg = Debug|Any CPU - {8671F164-F78C-44FA-93B7-A310F67890FE}.Checked|x64.ActiveCfg = Debug|Any CPU - {8671F164-F78C-44FA-93B7-A310F67890FE}.Checked|x86.ActiveCfg = Debug|Any CPU + {768B77B0-EA45-469D-B39E-545EB72F5A43}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {768B77B0-EA45-469D-B39E-545EB72F5A43}.Checked|arm.ActiveCfg = Debug|Any CPU + {768B77B0-EA45-469D-B39E-545EB72F5A43}.Checked|arm64.ActiveCfg = Debug|Any CPU + {768B77B0-EA45-469D-B39E-545EB72F5A43}.Checked|x64.ActiveCfg = Debug|Any CPU + {768B77B0-EA45-469D-B39E-545EB72F5A43}.Checked|x86.ActiveCfg = Debug|Any CPU {8671F164-F78C-44FA-93B7-A310F67890FE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {8671F164-F78C-44FA-93B7-A310F67890FE}.Debug|Any CPU.Build.0 = Debug|Any CPU {8671F164-F78C-44FA-93B7-A310F67890FE}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -405,11 +419,11 @@ Global {8671F164-F78C-44FA-93B7-A310F67890FE}.Release|x64.Build.0 = Release|Any CPU {8671F164-F78C-44FA-93B7-A310F67890FE}.Release|x86.ActiveCfg = Release|Any CPU {8671F164-F78C-44FA-93B7-A310F67890FE}.Release|x86.Build.0 = Release|Any CPU - {4FC33B9B-1BCF-4D16-B886-DCA8F2B823C1}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {4FC33B9B-1BCF-4D16-B886-DCA8F2B823C1}.Checked|arm.ActiveCfg = Debug|Any CPU - {4FC33B9B-1BCF-4D16-B886-DCA8F2B823C1}.Checked|arm64.ActiveCfg = Debug|Any CPU - {4FC33B9B-1BCF-4D16-B886-DCA8F2B823C1}.Checked|x64.ActiveCfg = Debug|Any CPU - {4FC33B9B-1BCF-4D16-B886-DCA8F2B823C1}.Checked|x86.ActiveCfg = Debug|Any CPU + {8671F164-F78C-44FA-93B7-A310F67890FE}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {8671F164-F78C-44FA-93B7-A310F67890FE}.Checked|arm.ActiveCfg = Debug|Any CPU + {8671F164-F78C-44FA-93B7-A310F67890FE}.Checked|arm64.ActiveCfg = Debug|Any CPU + {8671F164-F78C-44FA-93B7-A310F67890FE}.Checked|x64.ActiveCfg = Debug|Any CPU + {8671F164-F78C-44FA-93B7-A310F67890FE}.Checked|x86.ActiveCfg = Debug|Any CPU {4FC33B9B-1BCF-4D16-B886-DCA8F2B823C1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {4FC33B9B-1BCF-4D16-B886-DCA8F2B823C1}.Debug|Any CPU.Build.0 = Debug|Any CPU {4FC33B9B-1BCF-4D16-B886-DCA8F2B823C1}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -426,11 +440,11 @@ Global {4FC33B9B-1BCF-4D16-B886-DCA8F2B823C1}.Release|x64.Build.0 = Release|Any CPU {4FC33B9B-1BCF-4D16-B886-DCA8F2B823C1}.Release|x86.ActiveCfg = Release|Any CPU {4FC33B9B-1BCF-4D16-B886-DCA8F2B823C1}.Release|x86.Build.0 = Release|Any CPU - {79F7BE0E-01AA-4AFB-B047-CF7C0B38F81E}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {79F7BE0E-01AA-4AFB-B047-CF7C0B38F81E}.Checked|arm.ActiveCfg = Debug|Any CPU - {79F7BE0E-01AA-4AFB-B047-CF7C0B38F81E}.Checked|arm64.ActiveCfg = Debug|Any CPU - {79F7BE0E-01AA-4AFB-B047-CF7C0B38F81E}.Checked|x64.ActiveCfg = Debug|Any CPU - {79F7BE0E-01AA-4AFB-B047-CF7C0B38F81E}.Checked|x86.ActiveCfg = Debug|Any CPU + {4FC33B9B-1BCF-4D16-B886-DCA8F2B823C1}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {4FC33B9B-1BCF-4D16-B886-DCA8F2B823C1}.Checked|arm.ActiveCfg = Debug|Any CPU + {4FC33B9B-1BCF-4D16-B886-DCA8F2B823C1}.Checked|arm64.ActiveCfg = Debug|Any CPU + {4FC33B9B-1BCF-4D16-B886-DCA8F2B823C1}.Checked|x64.ActiveCfg = Debug|Any CPU + {4FC33B9B-1BCF-4D16-B886-DCA8F2B823C1}.Checked|x86.ActiveCfg = Debug|Any CPU {79F7BE0E-01AA-4AFB-B047-CF7C0B38F81E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {79F7BE0E-01AA-4AFB-B047-CF7C0B38F81E}.Debug|Any CPU.Build.0 = Debug|Any CPU {79F7BE0E-01AA-4AFB-B047-CF7C0B38F81E}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -447,11 +461,11 @@ Global {79F7BE0E-01AA-4AFB-B047-CF7C0B38F81E}.Release|x64.Build.0 = Release|Any CPU {79F7BE0E-01AA-4AFB-B047-CF7C0B38F81E}.Release|x86.ActiveCfg = Release|Any CPU {79F7BE0E-01AA-4AFB-B047-CF7C0B38F81E}.Release|x86.Build.0 = Release|Any CPU - {3741C833-C364-4269-9B1D-D442055DA7CE}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {3741C833-C364-4269-9B1D-D442055DA7CE}.Checked|arm.ActiveCfg = Debug|Any CPU - {3741C833-C364-4269-9B1D-D442055DA7CE}.Checked|arm64.ActiveCfg = Debug|Any CPU - {3741C833-C364-4269-9B1D-D442055DA7CE}.Checked|x64.ActiveCfg = Debug|Any CPU - {3741C833-C364-4269-9B1D-D442055DA7CE}.Checked|x86.ActiveCfg = Debug|Any CPU + {79F7BE0E-01AA-4AFB-B047-CF7C0B38F81E}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {79F7BE0E-01AA-4AFB-B047-CF7C0B38F81E}.Checked|arm.ActiveCfg = Debug|Any CPU + {79F7BE0E-01AA-4AFB-B047-CF7C0B38F81E}.Checked|arm64.ActiveCfg = Debug|Any CPU + {79F7BE0E-01AA-4AFB-B047-CF7C0B38F81E}.Checked|x64.ActiveCfg = Debug|Any CPU + {79F7BE0E-01AA-4AFB-B047-CF7C0B38F81E}.Checked|x86.ActiveCfg = Debug|Any CPU {3741C833-C364-4269-9B1D-D442055DA7CE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {3741C833-C364-4269-9B1D-D442055DA7CE}.Debug|Any CPU.Build.0 = Debug|Any CPU {3741C833-C364-4269-9B1D-D442055DA7CE}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -468,11 +482,11 @@ Global {3741C833-C364-4269-9B1D-D442055DA7CE}.Release|x64.Build.0 = Release|Any CPU {3741C833-C364-4269-9B1D-D442055DA7CE}.Release|x86.ActiveCfg = Release|Any CPU {3741C833-C364-4269-9B1D-D442055DA7CE}.Release|x86.Build.0 = Release|Any CPU - {1D771995-D475-429B-AC31-2B1F618AA45F}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {1D771995-D475-429B-AC31-2B1F618AA45F}.Checked|arm.ActiveCfg = Debug|Any CPU - {1D771995-D475-429B-AC31-2B1F618AA45F}.Checked|arm64.ActiveCfg = Debug|Any CPU - {1D771995-D475-429B-AC31-2B1F618AA45F}.Checked|x64.ActiveCfg = Debug|Any CPU - {1D771995-D475-429B-AC31-2B1F618AA45F}.Checked|x86.ActiveCfg = Debug|Any CPU + {3741C833-C364-4269-9B1D-D442055DA7CE}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {3741C833-C364-4269-9B1D-D442055DA7CE}.Checked|arm.ActiveCfg = Debug|Any CPU + {3741C833-C364-4269-9B1D-D442055DA7CE}.Checked|arm64.ActiveCfg = Debug|Any CPU + {3741C833-C364-4269-9B1D-D442055DA7CE}.Checked|x64.ActiveCfg = Debug|Any CPU + {3741C833-C364-4269-9B1D-D442055DA7CE}.Checked|x86.ActiveCfg = Debug|Any CPU {1D771995-D475-429B-AC31-2B1F618AA45F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {1D771995-D475-429B-AC31-2B1F618AA45F}.Debug|Any CPU.Build.0 = Debug|Any CPU {1D771995-D475-429B-AC31-2B1F618AA45F}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -489,11 +503,11 @@ Global {1D771995-D475-429B-AC31-2B1F618AA45F}.Release|x64.Build.0 = Release|Any CPU {1D771995-D475-429B-AC31-2B1F618AA45F}.Release|x86.ActiveCfg = Release|Any CPU {1D771995-D475-429B-AC31-2B1F618AA45F}.Release|x86.Build.0 = Release|Any CPU - {9C2C2B5C-5E75-4935-8A4A-DE3D3A5DBBC1}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {9C2C2B5C-5E75-4935-8A4A-DE3D3A5DBBC1}.Checked|arm.ActiveCfg = Debug|Any CPU - {9C2C2B5C-5E75-4935-8A4A-DE3D3A5DBBC1}.Checked|arm64.ActiveCfg = Debug|Any CPU - {9C2C2B5C-5E75-4935-8A4A-DE3D3A5DBBC1}.Checked|x64.ActiveCfg = Debug|Any CPU - {9C2C2B5C-5E75-4935-8A4A-DE3D3A5DBBC1}.Checked|x86.ActiveCfg = Debug|Any CPU + {1D771995-D475-429B-AC31-2B1F618AA45F}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {1D771995-D475-429B-AC31-2B1F618AA45F}.Checked|arm.ActiveCfg = Debug|Any CPU + {1D771995-D475-429B-AC31-2B1F618AA45F}.Checked|arm64.ActiveCfg = Debug|Any CPU + {1D771995-D475-429B-AC31-2B1F618AA45F}.Checked|x64.ActiveCfg = Debug|Any CPU + {1D771995-D475-429B-AC31-2B1F618AA45F}.Checked|x86.ActiveCfg = Debug|Any CPU {9C2C2B5C-5E75-4935-8A4A-DE3D3A5DBBC1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {9C2C2B5C-5E75-4935-8A4A-DE3D3A5DBBC1}.Debug|Any CPU.Build.0 = Debug|Any CPU {9C2C2B5C-5E75-4935-8A4A-DE3D3A5DBBC1}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -510,11 +524,11 @@ Global {9C2C2B5C-5E75-4935-8A4A-DE3D3A5DBBC1}.Release|x64.Build.0 = Release|Any CPU {9C2C2B5C-5E75-4935-8A4A-DE3D3A5DBBC1}.Release|x86.ActiveCfg = Release|Any CPU {9C2C2B5C-5E75-4935-8A4A-DE3D3A5DBBC1}.Release|x86.Build.0 = Release|Any CPU - {EA8DBC12-60BC-433E-ABFF-A89DFA795283}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {EA8DBC12-60BC-433E-ABFF-A89DFA795283}.Checked|arm.ActiveCfg = Debug|Any CPU - {EA8DBC12-60BC-433E-ABFF-A89DFA795283}.Checked|arm64.ActiveCfg = Debug|Any CPU - {EA8DBC12-60BC-433E-ABFF-A89DFA795283}.Checked|x64.ActiveCfg = Debug|Any CPU - {EA8DBC12-60BC-433E-ABFF-A89DFA795283}.Checked|x86.ActiveCfg = Debug|Any CPU + {9C2C2B5C-5E75-4935-8A4A-DE3D3A5DBBC1}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {9C2C2B5C-5E75-4935-8A4A-DE3D3A5DBBC1}.Checked|arm.ActiveCfg = Debug|Any CPU + {9C2C2B5C-5E75-4935-8A4A-DE3D3A5DBBC1}.Checked|arm64.ActiveCfg = Debug|Any CPU + {9C2C2B5C-5E75-4935-8A4A-DE3D3A5DBBC1}.Checked|x64.ActiveCfg = Debug|Any CPU + {9C2C2B5C-5E75-4935-8A4A-DE3D3A5DBBC1}.Checked|x86.ActiveCfg = Debug|Any CPU {EA8DBC12-60BC-433E-ABFF-A89DFA795283}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {EA8DBC12-60BC-433E-ABFF-A89DFA795283}.Debug|Any CPU.Build.0 = Debug|Any CPU {EA8DBC12-60BC-433E-ABFF-A89DFA795283}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -531,11 +545,11 @@ Global {EA8DBC12-60BC-433E-ABFF-A89DFA795283}.Release|x64.Build.0 = Release|Any CPU {EA8DBC12-60BC-433E-ABFF-A89DFA795283}.Release|x86.ActiveCfg = Release|Any CPU {EA8DBC12-60BC-433E-ABFF-A89DFA795283}.Release|x86.Build.0 = Release|Any CPU - {25D66424-2EAF-464D-8460-10C04EDEF3C3}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {25D66424-2EAF-464D-8460-10C04EDEF3C3}.Checked|arm.ActiveCfg = Debug|Any CPU - {25D66424-2EAF-464D-8460-10C04EDEF3C3}.Checked|arm64.ActiveCfg = Debug|Any CPU - {25D66424-2EAF-464D-8460-10C04EDEF3C3}.Checked|x64.ActiveCfg = Debug|Any CPU - {25D66424-2EAF-464D-8460-10C04EDEF3C3}.Checked|x86.ActiveCfg = Debug|Any CPU + {EA8DBC12-60BC-433E-ABFF-A89DFA795283}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {EA8DBC12-60BC-433E-ABFF-A89DFA795283}.Checked|arm.ActiveCfg = Debug|Any CPU + {EA8DBC12-60BC-433E-ABFF-A89DFA795283}.Checked|arm64.ActiveCfg = Debug|Any CPU + {EA8DBC12-60BC-433E-ABFF-A89DFA795283}.Checked|x64.ActiveCfg = Debug|Any CPU + {EA8DBC12-60BC-433E-ABFF-A89DFA795283}.Checked|x86.ActiveCfg = Debug|Any CPU {25D66424-2EAF-464D-8460-10C04EDEF3C3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {25D66424-2EAF-464D-8460-10C04EDEF3C3}.Debug|Any CPU.Build.0 = Debug|Any CPU {25D66424-2EAF-464D-8460-10C04EDEF3C3}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -552,11 +566,11 @@ Global {25D66424-2EAF-464D-8460-10C04EDEF3C3}.Release|x64.Build.0 = Release|Any CPU {25D66424-2EAF-464D-8460-10C04EDEF3C3}.Release|x86.ActiveCfg = Release|Any CPU {25D66424-2EAF-464D-8460-10C04EDEF3C3}.Release|x86.Build.0 = Release|Any CPU - {049B7FD4-ACEF-4BCD-A7A7-75C9BBEC4EBF}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {049B7FD4-ACEF-4BCD-A7A7-75C9BBEC4EBF}.Checked|arm.ActiveCfg = Debug|Any CPU - {049B7FD4-ACEF-4BCD-A7A7-75C9BBEC4EBF}.Checked|arm64.ActiveCfg = Debug|Any CPU - {049B7FD4-ACEF-4BCD-A7A7-75C9BBEC4EBF}.Checked|x64.ActiveCfg = Debug|Any CPU - {049B7FD4-ACEF-4BCD-A7A7-75C9BBEC4EBF}.Checked|x86.ActiveCfg = Debug|Any CPU + {25D66424-2EAF-464D-8460-10C04EDEF3C3}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {25D66424-2EAF-464D-8460-10C04EDEF3C3}.Checked|arm.ActiveCfg = Debug|Any CPU + {25D66424-2EAF-464D-8460-10C04EDEF3C3}.Checked|arm64.ActiveCfg = Debug|Any CPU + {25D66424-2EAF-464D-8460-10C04EDEF3C3}.Checked|x64.ActiveCfg = Debug|Any CPU + {25D66424-2EAF-464D-8460-10C04EDEF3C3}.Checked|x86.ActiveCfg = Debug|Any CPU {049B7FD4-ACEF-4BCD-A7A7-75C9BBEC4EBF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {049B7FD4-ACEF-4BCD-A7A7-75C9BBEC4EBF}.Debug|Any CPU.Build.0 = Debug|Any CPU {049B7FD4-ACEF-4BCD-A7A7-75C9BBEC4EBF}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -573,11 +587,11 @@ Global {049B7FD4-ACEF-4BCD-A7A7-75C9BBEC4EBF}.Release|x64.Build.0 = Release|Any CPU {049B7FD4-ACEF-4BCD-A7A7-75C9BBEC4EBF}.Release|x86.ActiveCfg = Release|Any CPU {049B7FD4-ACEF-4BCD-A7A7-75C9BBEC4EBF}.Release|x86.Build.0 = Release|Any CPU - {866D295E-424A-4747-9417-CD7746936138}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {866D295E-424A-4747-9417-CD7746936138}.Checked|arm.ActiveCfg = Debug|Any CPU - {866D295E-424A-4747-9417-CD7746936138}.Checked|arm64.ActiveCfg = Debug|Any CPU - {866D295E-424A-4747-9417-CD7746936138}.Checked|x64.ActiveCfg = Debug|Any CPU - {866D295E-424A-4747-9417-CD7746936138}.Checked|x86.ActiveCfg = Debug|Any CPU + {049B7FD4-ACEF-4BCD-A7A7-75C9BBEC4EBF}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {049B7FD4-ACEF-4BCD-A7A7-75C9BBEC4EBF}.Checked|arm.ActiveCfg = Debug|Any CPU + {049B7FD4-ACEF-4BCD-A7A7-75C9BBEC4EBF}.Checked|arm64.ActiveCfg = Debug|Any CPU + {049B7FD4-ACEF-4BCD-A7A7-75C9BBEC4EBF}.Checked|x64.ActiveCfg = Debug|Any CPU + {049B7FD4-ACEF-4BCD-A7A7-75C9BBEC4EBF}.Checked|x86.ActiveCfg = Debug|Any CPU {866D295E-424A-4747-9417-CD7746936138}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {866D295E-424A-4747-9417-CD7746936138}.Debug|Any CPU.Build.0 = Debug|Any CPU {866D295E-424A-4747-9417-CD7746936138}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -594,11 +608,11 @@ Global {866D295E-424A-4747-9417-CD7746936138}.Release|x64.Build.0 = Release|Any CPU {866D295E-424A-4747-9417-CD7746936138}.Release|x86.ActiveCfg = Release|Any CPU {866D295E-424A-4747-9417-CD7746936138}.Release|x86.Build.0 = Release|Any CPU - {D3A329E3-0FEB-4136-9CB6-B38319B0FFA5}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {D3A329E3-0FEB-4136-9CB6-B38319B0FFA5}.Checked|arm.ActiveCfg = Debug|Any CPU - {D3A329E3-0FEB-4136-9CB6-B38319B0FFA5}.Checked|arm64.ActiveCfg = Debug|Any CPU - {D3A329E3-0FEB-4136-9CB6-B38319B0FFA5}.Checked|x64.ActiveCfg = Debug|Any CPU - {D3A329E3-0FEB-4136-9CB6-B38319B0FFA5}.Checked|x86.ActiveCfg = Debug|Any CPU + {866D295E-424A-4747-9417-CD7746936138}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {866D295E-424A-4747-9417-CD7746936138}.Checked|arm.ActiveCfg = Debug|Any CPU + {866D295E-424A-4747-9417-CD7746936138}.Checked|arm64.ActiveCfg = Debug|Any CPU + {866D295E-424A-4747-9417-CD7746936138}.Checked|x64.ActiveCfg = Debug|Any CPU + {866D295E-424A-4747-9417-CD7746936138}.Checked|x86.ActiveCfg = Debug|Any CPU {D3A329E3-0FEB-4136-9CB6-B38319B0FFA5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {D3A329E3-0FEB-4136-9CB6-B38319B0FFA5}.Debug|Any CPU.Build.0 = Debug|Any CPU {D3A329E3-0FEB-4136-9CB6-B38319B0FFA5}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -615,11 +629,11 @@ Global {D3A329E3-0FEB-4136-9CB6-B38319B0FFA5}.Release|x64.Build.0 = Release|Any CPU {D3A329E3-0FEB-4136-9CB6-B38319B0FFA5}.Release|x86.ActiveCfg = Release|Any CPU {D3A329E3-0FEB-4136-9CB6-B38319B0FFA5}.Release|x86.Build.0 = Release|Any CPU - {0B5FD0C2-367D-4AD6-8001-80AD79B2441C}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {0B5FD0C2-367D-4AD6-8001-80AD79B2441C}.Checked|arm.ActiveCfg = Debug|Any CPU - {0B5FD0C2-367D-4AD6-8001-80AD79B2441C}.Checked|arm64.ActiveCfg = Debug|Any CPU - {0B5FD0C2-367D-4AD6-8001-80AD79B2441C}.Checked|x64.ActiveCfg = Debug|Any CPU - {0B5FD0C2-367D-4AD6-8001-80AD79B2441C}.Checked|x86.ActiveCfg = Debug|Any CPU + {D3A329E3-0FEB-4136-9CB6-B38319B0FFA5}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {D3A329E3-0FEB-4136-9CB6-B38319B0FFA5}.Checked|arm.ActiveCfg = Debug|Any CPU + {D3A329E3-0FEB-4136-9CB6-B38319B0FFA5}.Checked|arm64.ActiveCfg = Debug|Any CPU + {D3A329E3-0FEB-4136-9CB6-B38319B0FFA5}.Checked|x64.ActiveCfg = Debug|Any CPU + {D3A329E3-0FEB-4136-9CB6-B38319B0FFA5}.Checked|x86.ActiveCfg = Debug|Any CPU {0B5FD0C2-367D-4AD6-8001-80AD79B2441C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {0B5FD0C2-367D-4AD6-8001-80AD79B2441C}.Debug|Any CPU.Build.0 = Debug|Any CPU {0B5FD0C2-367D-4AD6-8001-80AD79B2441C}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -636,11 +650,11 @@ Global {0B5FD0C2-367D-4AD6-8001-80AD79B2441C}.Release|x64.Build.0 = Release|Any CPU {0B5FD0C2-367D-4AD6-8001-80AD79B2441C}.Release|x86.ActiveCfg = Release|Any CPU {0B5FD0C2-367D-4AD6-8001-80AD79B2441C}.Release|x86.Build.0 = Release|Any CPU - {C7DAC270-CC93-4C97-9A8D-6E724A10727D}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {C7DAC270-CC93-4C97-9A8D-6E724A10727D}.Checked|arm.ActiveCfg = Debug|Any CPU - {C7DAC270-CC93-4C97-9A8D-6E724A10727D}.Checked|arm64.ActiveCfg = Debug|Any CPU - {C7DAC270-CC93-4C97-9A8D-6E724A10727D}.Checked|x64.ActiveCfg = Debug|Any CPU - {C7DAC270-CC93-4C97-9A8D-6E724A10727D}.Checked|x86.ActiveCfg = Debug|Any CPU + {0B5FD0C2-367D-4AD6-8001-80AD79B2441C}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {0B5FD0C2-367D-4AD6-8001-80AD79B2441C}.Checked|arm.ActiveCfg = Debug|Any CPU + {0B5FD0C2-367D-4AD6-8001-80AD79B2441C}.Checked|arm64.ActiveCfg = Debug|Any CPU + {0B5FD0C2-367D-4AD6-8001-80AD79B2441C}.Checked|x64.ActiveCfg = Debug|Any CPU + {0B5FD0C2-367D-4AD6-8001-80AD79B2441C}.Checked|x86.ActiveCfg = Debug|Any CPU {C7DAC270-CC93-4C97-9A8D-6E724A10727D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {C7DAC270-CC93-4C97-9A8D-6E724A10727D}.Debug|Any CPU.Build.0 = Debug|Any CPU {C7DAC270-CC93-4C97-9A8D-6E724A10727D}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -657,11 +671,11 @@ Global {C7DAC270-CC93-4C97-9A8D-6E724A10727D}.Release|x64.Build.0 = Release|Any CPU {C7DAC270-CC93-4C97-9A8D-6E724A10727D}.Release|x86.ActiveCfg = Release|Any CPU {C7DAC270-CC93-4C97-9A8D-6E724A10727D}.Release|x86.Build.0 = Release|Any CPU - {C9B349C8-7B11-4DE4-A4BB-8D957A1D2A82}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {C9B349C8-7B11-4DE4-A4BB-8D957A1D2A82}.Checked|arm.ActiveCfg = Debug|Any CPU - {C9B349C8-7B11-4DE4-A4BB-8D957A1D2A82}.Checked|arm64.ActiveCfg = Debug|Any CPU - {C9B349C8-7B11-4DE4-A4BB-8D957A1D2A82}.Checked|x64.ActiveCfg = Debug|Any CPU - {C9B349C8-7B11-4DE4-A4BB-8D957A1D2A82}.Checked|x86.ActiveCfg = Debug|Any CPU + {C7DAC270-CC93-4C97-9A8D-6E724A10727D}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {C7DAC270-CC93-4C97-9A8D-6E724A10727D}.Checked|arm.ActiveCfg = Debug|Any CPU + {C7DAC270-CC93-4C97-9A8D-6E724A10727D}.Checked|arm64.ActiveCfg = Debug|Any CPU + {C7DAC270-CC93-4C97-9A8D-6E724A10727D}.Checked|x64.ActiveCfg = Debug|Any CPU + {C7DAC270-CC93-4C97-9A8D-6E724A10727D}.Checked|x86.ActiveCfg = Debug|Any CPU {C9B349C8-7B11-4DE4-A4BB-8D957A1D2A82}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {C9B349C8-7B11-4DE4-A4BB-8D957A1D2A82}.Debug|Any CPU.Build.0 = Debug|Any CPU {C9B349C8-7B11-4DE4-A4BB-8D957A1D2A82}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -678,11 +692,11 @@ Global {C9B349C8-7B11-4DE4-A4BB-8D957A1D2A82}.Release|x64.Build.0 = Release|Any CPU {C9B349C8-7B11-4DE4-A4BB-8D957A1D2A82}.Release|x86.ActiveCfg = Release|Any CPU {C9B349C8-7B11-4DE4-A4BB-8D957A1D2A82}.Release|x86.Build.0 = Release|Any CPU - {5600CDE1-139F-461B-8DD9-86FCC499DCC2}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {5600CDE1-139F-461B-8DD9-86FCC499DCC2}.Checked|arm.ActiveCfg = Debug|Any CPU - {5600CDE1-139F-461B-8DD9-86FCC499DCC2}.Checked|arm64.ActiveCfg = Debug|Any CPU - {5600CDE1-139F-461B-8DD9-86FCC499DCC2}.Checked|x64.ActiveCfg = Debug|Any CPU - {5600CDE1-139F-461B-8DD9-86FCC499DCC2}.Checked|x86.ActiveCfg = Debug|Any CPU + {C9B349C8-7B11-4DE4-A4BB-8D957A1D2A82}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {C9B349C8-7B11-4DE4-A4BB-8D957A1D2A82}.Checked|arm.ActiveCfg = Debug|Any CPU + {C9B349C8-7B11-4DE4-A4BB-8D957A1D2A82}.Checked|arm64.ActiveCfg = Debug|Any CPU + {C9B349C8-7B11-4DE4-A4BB-8D957A1D2A82}.Checked|x64.ActiveCfg = Debug|Any CPU + {C9B349C8-7B11-4DE4-A4BB-8D957A1D2A82}.Checked|x86.ActiveCfg = Debug|Any CPU {5600CDE1-139F-461B-8DD9-86FCC499DCC2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {5600CDE1-139F-461B-8DD9-86FCC499DCC2}.Debug|Any CPU.Build.0 = Debug|Any CPU {5600CDE1-139F-461B-8DD9-86FCC499DCC2}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -699,11 +713,11 @@ Global {5600CDE1-139F-461B-8DD9-86FCC499DCC2}.Release|x64.Build.0 = Release|Any CPU {5600CDE1-139F-461B-8DD9-86FCC499DCC2}.Release|x86.ActiveCfg = Release|Any CPU {5600CDE1-139F-461B-8DD9-86FCC499DCC2}.Release|x86.Build.0 = Release|Any CPU - {169B126B-48DF-425C-B902-D376A689D9FB}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {169B126B-48DF-425C-B902-D376A689D9FB}.Checked|arm.ActiveCfg = Debug|Any CPU - {169B126B-48DF-425C-B902-D376A689D9FB}.Checked|arm64.ActiveCfg = Debug|Any CPU - {169B126B-48DF-425C-B902-D376A689D9FB}.Checked|x64.ActiveCfg = Debug|Any CPU - {169B126B-48DF-425C-B902-D376A689D9FB}.Checked|x86.ActiveCfg = Debug|Any CPU + {5600CDE1-139F-461B-8DD9-86FCC499DCC2}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {5600CDE1-139F-461B-8DD9-86FCC499DCC2}.Checked|arm.ActiveCfg = Debug|Any CPU + {5600CDE1-139F-461B-8DD9-86FCC499DCC2}.Checked|arm64.ActiveCfg = Debug|Any CPU + {5600CDE1-139F-461B-8DD9-86FCC499DCC2}.Checked|x64.ActiveCfg = Debug|Any CPU + {5600CDE1-139F-461B-8DD9-86FCC499DCC2}.Checked|x86.ActiveCfg = Debug|Any CPU {169B126B-48DF-425C-B902-D376A689D9FB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {169B126B-48DF-425C-B902-D376A689D9FB}.Debug|Any CPU.Build.0 = Debug|Any CPU {169B126B-48DF-425C-B902-D376A689D9FB}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -720,11 +734,11 @@ Global {169B126B-48DF-425C-B902-D376A689D9FB}.Release|x64.Build.0 = Release|Any CPU {169B126B-48DF-425C-B902-D376A689D9FB}.Release|x86.ActiveCfg = Release|Any CPU {169B126B-48DF-425C-B902-D376A689D9FB}.Release|x86.Build.0 = Release|Any CPU - {8EA17297-41EE-4CEE-AF61-F047D6F7A1AB}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {8EA17297-41EE-4CEE-AF61-F047D6F7A1AB}.Checked|arm.ActiveCfg = Debug|Any CPU - {8EA17297-41EE-4CEE-AF61-F047D6F7A1AB}.Checked|arm64.ActiveCfg = Debug|Any CPU - {8EA17297-41EE-4CEE-AF61-F047D6F7A1AB}.Checked|x64.ActiveCfg = Debug|Any CPU - {8EA17297-41EE-4CEE-AF61-F047D6F7A1AB}.Checked|x86.ActiveCfg = Debug|Any CPU + {169B126B-48DF-425C-B902-D376A689D9FB}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {169B126B-48DF-425C-B902-D376A689D9FB}.Checked|arm.ActiveCfg = Debug|Any CPU + {169B126B-48DF-425C-B902-D376A689D9FB}.Checked|arm64.ActiveCfg = Debug|Any CPU + {169B126B-48DF-425C-B902-D376A689D9FB}.Checked|x64.ActiveCfg = Debug|Any CPU + {169B126B-48DF-425C-B902-D376A689D9FB}.Checked|x86.ActiveCfg = Debug|Any CPU {8EA17297-41EE-4CEE-AF61-F047D6F7A1AB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {8EA17297-41EE-4CEE-AF61-F047D6F7A1AB}.Debug|Any CPU.Build.0 = Debug|Any CPU {8EA17297-41EE-4CEE-AF61-F047D6F7A1AB}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -741,11 +755,11 @@ Global {8EA17297-41EE-4CEE-AF61-F047D6F7A1AB}.Release|x64.Build.0 = Release|Any CPU {8EA17297-41EE-4CEE-AF61-F047D6F7A1AB}.Release|x86.ActiveCfg = Release|Any CPU {8EA17297-41EE-4CEE-AF61-F047D6F7A1AB}.Release|x86.Build.0 = Release|Any CPU - {1347FE73-506C-4C44-A469-979F6ADB78BE}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {1347FE73-506C-4C44-A469-979F6ADB78BE}.Checked|arm.ActiveCfg = Debug|Any CPU - {1347FE73-506C-4C44-A469-979F6ADB78BE}.Checked|arm64.ActiveCfg = Debug|Any CPU - {1347FE73-506C-4C44-A469-979F6ADB78BE}.Checked|x64.ActiveCfg = Debug|Any CPU - {1347FE73-506C-4C44-A469-979F6ADB78BE}.Checked|x86.ActiveCfg = Debug|Any CPU + {8EA17297-41EE-4CEE-AF61-F047D6F7A1AB}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {8EA17297-41EE-4CEE-AF61-F047D6F7A1AB}.Checked|arm.ActiveCfg = Debug|Any CPU + {8EA17297-41EE-4CEE-AF61-F047D6F7A1AB}.Checked|arm64.ActiveCfg = Debug|Any CPU + {8EA17297-41EE-4CEE-AF61-F047D6F7A1AB}.Checked|x64.ActiveCfg = Debug|Any CPU + {8EA17297-41EE-4CEE-AF61-F047D6F7A1AB}.Checked|x86.ActiveCfg = Debug|Any CPU {1347FE73-506C-4C44-A469-979F6ADB78BE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {1347FE73-506C-4C44-A469-979F6ADB78BE}.Debug|Any CPU.Build.0 = Debug|Any CPU {1347FE73-506C-4C44-A469-979F6ADB78BE}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -762,11 +776,11 @@ Global {1347FE73-506C-4C44-A469-979F6ADB78BE}.Release|x64.Build.0 = Release|Any CPU {1347FE73-506C-4C44-A469-979F6ADB78BE}.Release|x86.ActiveCfg = Release|Any CPU {1347FE73-506C-4C44-A469-979F6ADB78BE}.Release|x86.Build.0 = Release|Any CPU - {B36C9254-0C55-414E-8403-03B4F18D5F35}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {B36C9254-0C55-414E-8403-03B4F18D5F35}.Checked|arm.ActiveCfg = Debug|Any CPU - {B36C9254-0C55-414E-8403-03B4F18D5F35}.Checked|arm64.ActiveCfg = Debug|Any CPU - {B36C9254-0C55-414E-8403-03B4F18D5F35}.Checked|x64.ActiveCfg = Debug|Any CPU - {B36C9254-0C55-414E-8403-03B4F18D5F35}.Checked|x86.ActiveCfg = Debug|Any CPU + {1347FE73-506C-4C44-A469-979F6ADB78BE}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {1347FE73-506C-4C44-A469-979F6ADB78BE}.Checked|arm.ActiveCfg = Debug|Any CPU + {1347FE73-506C-4C44-A469-979F6ADB78BE}.Checked|arm64.ActiveCfg = Debug|Any CPU + {1347FE73-506C-4C44-A469-979F6ADB78BE}.Checked|x64.ActiveCfg = Debug|Any CPU + {1347FE73-506C-4C44-A469-979F6ADB78BE}.Checked|x86.ActiveCfg = Debug|Any CPU {B36C9254-0C55-414E-8403-03B4F18D5F35}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {B36C9254-0C55-414E-8403-03B4F18D5F35}.Debug|Any CPU.Build.0 = Debug|Any CPU {B36C9254-0C55-414E-8403-03B4F18D5F35}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -783,26 +797,23 @@ Global {B36C9254-0C55-414E-8403-03B4F18D5F35}.Release|x64.Build.0 = Release|Any CPU {B36C9254-0C55-414E-8403-03B4F18D5F35}.Release|x86.ActiveCfg = Release|Any CPU {B36C9254-0C55-414E-8403-03B4F18D5F35}.Release|x86.Build.0 = Release|Any CPU + {B36C9254-0C55-414E-8403-03B4F18D5F35}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {B36C9254-0C55-414E-8403-03B4F18D5F35}.Checked|arm.ActiveCfg = Debug|Any CPU + {B36C9254-0C55-414E-8403-03B4F18D5F35}.Checked|arm64.ActiveCfg = Debug|Any CPU + {B36C9254-0C55-414E-8403-03B4F18D5F35}.Checked|x64.ActiveCfg = Debug|Any CPU + {B36C9254-0C55-414E-8403-03B4F18D5F35}.Checked|x86.ActiveCfg = Debug|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection GlobalSection(NestedProjects) = preSolution - {94B59BA0-491F-4B59-ADFF-A057EC3EC835} = {9DA56ADF-7AA4-4752-BD91-330F674AAF18} + {94B59BA0-491F-4B59-ADFF-A057EC3EC835} = {D5382D82-CC63-4781-A57B-4398A9757BDF} + {F552E4E4-20EE-484C-84F8-4FB3A3BD2E69} = {D5382D82-CC63-4781-A57B-4398A9757BDF} + {C4B641C3-3317-4913-91DA-0DA3B64BABED} = {D5382D82-CC63-4781-A57B-4398A9757BDF} + {716ED44B-37C8-4776-BE70-285952D2B30D} = {D5382D82-CC63-4781-A57B-4398A9757BDF} + {4FC33B9B-1BCF-4D16-B886-DCA8F2B823C1} = {D5382D82-CC63-4781-A57B-4398A9757BDF} + {C9B349C8-7B11-4DE4-A4BB-8D957A1D2A82} = {D5382D82-CC63-4781-A57B-4398A9757BDF} {1FF4CC8E-49C3-42A0-A6E0-2E5908455FBA} = {FB99AC59-1744-4F12-A4B0-0D54FCA048BF} - {0E0D5A1F-0212-4CEB-BADA-E1E3ABD395A0} = {97B027E5-35BC-4B07-A030-F5C5085C281C} - {F552E4E4-20EE-484C-84F8-4FB3A3BD2E69} = {9DA56ADF-7AA4-4752-BD91-330F674AAF18} - {4859BEE3-34B7-48E7-83D4-1ADD8B8F3B3A} = {97B027E5-35BC-4B07-A030-F5C5085C281C} - {C4B641C3-3317-4913-91DA-0DA3B64BABED} = {9DA56ADF-7AA4-4752-BD91-330F674AAF18} - {3FB6F2AA-E763-4336-B927-18AB7AAF6C20} = {97B027E5-35BC-4B07-A030-F5C5085C281C} - {716ED44B-37C8-4776-BE70-285952D2B30D} = {9DA56ADF-7AA4-4752-BD91-330F674AAF18} - {1B248B4C-7584-4C04-850A-A50EB592052C} = {0522E1B2-BF32-4B3A-A74C-1CBF642E85E4} - {EF39CC5C-7A3B-40F2-82B6-C1C8BBC3F886} = {97B027E5-35BC-4B07-A030-F5C5085C281C} - {C3EA0A28-A597-4946-9E08-EBBBFA94BFA5} = {0522E1B2-BF32-4B3A-A74C-1CBF642E85E4} - {90CDAD9F-3ACC-43B0-9696-0C849FCD8C40} = {0522E1B2-BF32-4B3A-A74C-1CBF642E85E4} - {768B77B0-EA45-469D-B39E-545EB72F5A43} = {0522E1B2-BF32-4B3A-A74C-1CBF642E85E4} - {8671F164-F78C-44FA-93B7-A310F67890FE} = {97B027E5-35BC-4B07-A030-F5C5085C281C} - {4FC33B9B-1BCF-4D16-B886-DCA8F2B823C1} = {9DA56ADF-7AA4-4752-BD91-330F674AAF18} {79F7BE0E-01AA-4AFB-B047-CF7C0B38F81E} = {FB99AC59-1744-4F12-A4B0-0D54FCA048BF} {3741C833-C364-4269-9B1D-D442055DA7CE} = {FB99AC59-1744-4F12-A4B0-0D54FCA048BF} {1D771995-D475-429B-AC31-2B1F618AA45F} = {FB99AC59-1744-4F12-A4B0-0D54FCA048BF} @@ -812,24 +823,28 @@ Global {049B7FD4-ACEF-4BCD-A7A7-75C9BBEC4EBF} = {FB99AC59-1744-4F12-A4B0-0D54FCA048BF} {866D295E-424A-4747-9417-CD7746936138} = {FB99AC59-1744-4F12-A4B0-0D54FCA048BF} {D3A329E3-0FEB-4136-9CB6-B38319B0FFA5} = {FB99AC59-1744-4F12-A4B0-0D54FCA048BF} - {0B5FD0C2-367D-4AD6-8001-80AD79B2441C} = {97B027E5-35BC-4B07-A030-F5C5085C281C} - {C7DAC270-CC93-4C97-9A8D-6E724A10727D} = {97B027E5-35BC-4B07-A030-F5C5085C281C} - {C9B349C8-7B11-4DE4-A4BB-8D957A1D2A82} = {9DA56ADF-7AA4-4752-BD91-330F674AAF18} - {5600CDE1-139F-461B-8DD9-86FCC499DCC2} = {A043B2C0-71A2-4933-900B-E5DFDCB2B508} - {169B126B-48DF-425C-B902-D376A689D9FB} = {A043B2C0-71A2-4933-900B-E5DFDCB2B508} - {8EA17297-41EE-4CEE-AF61-F047D6F7A1AB} = {D5382D82-CC63-4781-A57B-4398A9757BDF} - {1347FE73-506C-4C44-A469-979F6ADB78BE} = {D5382D82-CC63-4781-A57B-4398A9757BDF} - {B36C9254-0C55-414E-8403-03B4F18D5F35} = {1FBC0A06-EE6A-4B51-BFA8-8EF93B6EE574} - {A043B2C0-71A2-4933-900B-E5DFDCB2B508} = {8FA3249B-3567-4C76-BA32-9488FC92994D} - {D5382D82-CC63-4781-A57B-4398A9757BDF} = {8FA3249B-3567-4C76-BA32-9488FC92994D} - {1FBC0A06-EE6A-4B51-BFA8-8EF93B6EE574} = {8FA3249B-3567-4C76-BA32-9488FC92994D} + {0E0D5A1F-0212-4CEB-BADA-E1E3ABD395A0} = {1FBC0A06-EE6A-4B51-BFA8-8EF93B6EE574} + {4859BEE3-34B7-48E7-83D4-1ADD8B8F3B3A} = {1FBC0A06-EE6A-4B51-BFA8-8EF93B6EE574} + {3FB6F2AA-E763-4336-B927-18AB7AAF6C20} = {1FBC0A06-EE6A-4B51-BFA8-8EF93B6EE574} + {EF39CC5C-7A3B-40F2-82B6-C1C8BBC3F886} = {1FBC0A06-EE6A-4B51-BFA8-8EF93B6EE574} + {8671F164-F78C-44FA-93B7-A310F67890FE} = {1FBC0A06-EE6A-4B51-BFA8-8EF93B6EE574} + {0B5FD0C2-367D-4AD6-8001-80AD79B2441C} = {1FBC0A06-EE6A-4B51-BFA8-8EF93B6EE574} + {C7DAC270-CC93-4C97-9A8D-6E724A10727D} = {1FBC0A06-EE6A-4B51-BFA8-8EF93B6EE574} + {1B248B4C-7584-4C04-850A-A50EB592052C} = {A043B2C0-71A2-4933-900B-E5DFDCB2B508} + {C3EA0A28-A597-4946-9E08-EBBBFA94BFA5} = {A043B2C0-71A2-4933-900B-E5DFDCB2B508} + {DD1873BA-2928-464A-B368-7AEFB1E49FD8} = {A043B2C0-71A2-4933-900B-E5DFDCB2B508} + {90CDAD9F-3ACC-43B0-9696-0C849FCD8C40} = {A043B2C0-71A2-4933-900B-E5DFDCB2B508} + {768B77B0-EA45-469D-B39E-545EB72F5A43} = {A043B2C0-71A2-4933-900B-E5DFDCB2B508} + {5600CDE1-139F-461B-8DD9-86FCC499DCC2} = {962D3C8C-5E06-4E45-BCEC-A7BE2D1BCBDC} + {169B126B-48DF-425C-B902-D376A689D9FB} = {962D3C8C-5E06-4E45-BCEC-A7BE2D1BCBDC} + {962D3C8C-5E06-4E45-BCEC-A7BE2D1BCBDC} = {8FA3249B-3567-4C76-BA32-9488FC92994D} + {8EA17297-41EE-4CEE-AF61-F047D6F7A1AB} = {8800B107-6C99-4025-AD74-E6A25D2457B8} + {1347FE73-506C-4C44-A469-979F6ADB78BE} = {8800B107-6C99-4025-AD74-E6A25D2457B8} + {8800B107-6C99-4025-AD74-E6A25D2457B8} = {8FA3249B-3567-4C76-BA32-9488FC92994D} + {B36C9254-0C55-414E-8403-03B4F18D5F35} = {4EFB09EB-10DB-4C5C-B823-E0673D656073} + {4EFB09EB-10DB-4C5C-B823-E0673D656073} = {8FA3249B-3567-4C76-BA32-9488FC92994D} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {D4031401-FEB5-4CCF-91C1-38F5646B2BFD} EndGlobalSection - GlobalSection(SharedMSBuildProjectFiles) = preSolution - ..\..\tools\illink\src\ILLink.Shared\ILLink.Shared.projitems*{1347fe73-506c-4c44-a469-979f6adb78be}*SharedItemsImports = 5 - ..\..\tools\illink\src\ILLink.Shared\ILLink.Shared.projitems*{169b126b-48df-425c-b902-d376a689d9fb}*SharedItemsImports = 5 - ..\System.Private.CoreLib\src\System.Private.CoreLib.Shared.projitems*{94b59ba0-491f-4b59-adff-a057ec3ec835}*SharedItemsImports = 5 - EndGlobalSection EndGlobal diff --git a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Analyzers/ConvertComImportToGeneratedComInterfaceAnalyzer.cs b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Analyzers/ConvertComImportToGeneratedComInterfaceAnalyzer.cs index f9b96eb7e30..edb396095fb 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Analyzers/ConvertComImportToGeneratedComInterfaceAnalyzer.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Analyzers/ConvertComImportToGeneratedComInterfaceAnalyzer.cs @@ -87,9 +87,6 @@ public override void Initialize(AnalysisContext context) mayRequireAdditionalWork = diagnostics.Diagnostics.Any(); bool anyExplicitlyUnsupportedInfo = false; - var managedToNativeStubCodeContext = new ManagedToNativeStubCodeContext("return", "nativeReturn"); - var nativeToManagedStubCodeContext = new NativeToManagedStubCodeContext("return", "nativeReturn"); - var forwarder = new Forwarder(); // We don't actually need the bound generators. We just need them to be attempted to be bound to determine if the generator will be able to bind them. BoundGenerators generators = BoundGenerators.Create(targetSignatureContext.ElementTypeInformation, new CallbackGeneratorResolver((info, context) => @@ -97,17 +94,17 @@ public override void Initialize(AnalysisContext context) if (s_unsupportedTypeNames.Contains(info.ManagedType.FullTypeName)) { anyExplicitlyUnsupportedInfo = true; - return ResolvedGenerator.Resolved(forwarder); + return ResolvedGenerator.Resolved(forwarder.Bind(info, context)); } if (HasUnsupportedMarshalAsInfo(info)) { anyExplicitlyUnsupportedInfo = true; - return ResolvedGenerator.Resolved(forwarder); + return ResolvedGenerator.Resolved(forwarder.Bind(info, context)); } if (info.MarshallingAttributeInfo is TrackedMarshallingInfo(TrackedMarshallingInfoAnnotation.ExplicitlyUnsupported, _)) { anyExplicitlyUnsupportedInfo = true; - return ResolvedGenerator.Resolved(forwarder); + return ResolvedGenerator.Resolved(forwarder.Bind(info, context)); } if (info.MarshallingAttributeInfo is TrackedMarshallingInfo(TrackedMarshallingInfoAnnotation annotation, var inner)) { @@ -118,13 +115,13 @@ public override void Initialize(AnalysisContext context) info = info with { MarshallingAttributeInfo = inner }; } // Run both factories and collect any binding failures. - ResolvedGenerator unmanagedToManagedGenerator = unmanagedToManagedFactory.Create(info, nativeToManagedStubCodeContext); - ResolvedGenerator managedToUnmanagedGenerator = managedToUnmanagedFactory.Create(info, managedToNativeStubCodeContext); + ResolvedGenerator unmanagedToManagedGenerator = unmanagedToManagedFactory.Create(info, StubCodeContext.DefaultNativeToManagedStub); + ResolvedGenerator managedToUnmanagedGenerator = managedToUnmanagedFactory.Create(info, StubCodeContext.DefaultManagedToNativeStub); return managedToUnmanagedGenerator with { Diagnostics = managedToUnmanagedGenerator.Diagnostics.AddRange(unmanagedToManagedGenerator.Diagnostics) }; - }), managedToNativeStubCodeContext, forwarder, out var generatorDiagnostics); + }), StubCodeContext.DefaultManagedToNativeStub, forwarder, out var generatorDiagnostics); mayRequireAdditionalWork |= generatorDiagnostics.Any(diag => diag.IsFatal); @@ -164,7 +161,7 @@ private static MarshallingInfoParser CreateComImportMarshallingInfoParser(StubEn new NativeMarshallingAttributeParser(env.Compilation, diagnostics), new ComInterfaceMarshallingInfoProvider(env.Compilation)), ImmutableArray.Create( - new SafeHandleMarshallingInfoProvider(env.Compilation, method.ContainingType), + new SafeHandleMarshallingInfoProvider(env.Compilation), new ExplicitlyUnsupportedMarshallingInfoProvider(), // We don't support arrays, so we don't include the array marshalling info provider. Instead, we include our "explicitly unsupported" provider. new CharMarshallingInfoProvider(defaultInfo), new TrackingStringMarshallingInfoProvider(new StringMarshallingInfoProvider(env.Compilation, diagnostics, unparsedAttributeData, defaultInfo)), // We need to mark when we see string types to ensure we offer a code-fix that adds the string marshalling info. diff --git a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/ComInterfaceGenerator.csproj b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/ComInterfaceGenerator.csproj index 1ef090dee7a..f100dbb7ad4 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/ComInterfaceGenerator.csproj +++ b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/ComInterfaceGenerator.csproj @@ -27,6 +27,8 @@ + + diff --git a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/ComInterfaceGeneratorHelpers.cs b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/ComInterfaceGeneratorHelpers.cs index 2527ffb9e28..91a3a956a02 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/ComInterfaceGeneratorHelpers.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/ComInterfaceGeneratorHelpers.cs @@ -19,7 +19,7 @@ private static IMarshallingGeneratorResolver CreateGeneratorResolver(Environment => DefaultMarshallingGeneratorResolver.Create(env, direction, TypeNames.GeneratedComInterfaceAttribute_ShortName, [ new StructAsHResultMarshallerFactory(), - new ManagedHResultExceptionGeneratorResolver(direction), + new ManagedHResultExceptionGeneratorResolver(), new ComInterfaceDispatchMarshallingResolver(), ]); diff --git a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/ComMethodContext.cs b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/ComMethodContext.cs index f0cb535607b..e85905a0ee7 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/ComMethodContext.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/ComMethodContext.cs @@ -128,7 +128,6 @@ private MethodDeclarationSyntax GenerateShadow() { // DeclarationCopiedFromBaseDeclaration() // => (()this).(); - var forwarder = new Forwarder(); return MethodDeclaration(GenerationContext.SignatureContext.StubReturnType, MethodInfo.MethodName) .WithModifiers(TokenList(Token(SyntaxKind.NewKeyword))) .WithAttributeLists(List(GenerationContext.SignatureContext.AdditionalAttributes.Concat(MethodInfo.Attributes.Select(a => a.GenerateAttributeList())))) @@ -142,7 +141,7 @@ private MethodDeclarationSyntax GenerateShadow() CastExpression(OriginalDeclaringInterface.Info.Type.Syntax, IdentifierName("this"))), IdentifierName(MethodInfo.MethodName)), ArgumentList( - SeparatedList(GenerationContext.SignatureContext.ManagedParameters.Select(p => forwarder.AsArgument(p, new ManagedStubCodeContext()))))))) + SeparatedList(GenerationContext.SignatureContext.ManagedParameters.Select(p => Argument(IdentifierName(p.InstanceIdentifier)))))))) .WithSemicolonToken(Token(SyntaxKind.SemicolonToken)); } diff --git a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/LanguageSupport.cs b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/LanguageSupport.cs deleted file mode 100644 index 2cf6b881206..00000000000 --- a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/LanguageSupport.cs +++ /dev/null @@ -1,11 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -// Types defined to enable language support of various features -// in the source generator. -namespace System.Runtime.CompilerServices -{ - // Define IsExternalInit type to support records. - internal sealed class IsExternalInit - { } -} diff --git a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/ManagedStubCodeContext.cs b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/ManagedStubCodeContext.cs deleted file mode 100644 index 207ae29537f..00000000000 --- a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/ManagedStubCodeContext.cs +++ /dev/null @@ -1,17 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System; - -namespace Microsoft.Interop -{ - /// - /// Stub code context for generating code that does not cross a native/managed boundary - /// - internal sealed record ManagedStubCodeContext : StubCodeContext - { - public override bool SingleFrameSpansNativeContext => throw new NotImplementedException(); - - public override bool AdditionalTemporaryStateLivesAcrossStages => throw new NotImplementedException(); - } -} diff --git a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/ManagedToNativeVTableMethodGenerator.cs b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/ManagedToNativeVTableMethodGenerator.cs deleted file mode 100644 index 81183b32b9e..00000000000 --- a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/ManagedToNativeVTableMethodGenerator.cs +++ /dev/null @@ -1,237 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System; -using System.Collections.Generic; -using System.Collections.Immutable; -using System.Linq; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; -using Microsoft.CodeAnalysis.CSharp.Syntax; -using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; -using static Microsoft.Interop.SyntaxFactoryExtensions; - -namespace Microsoft.Interop -{ - /// - /// Base code generator for generating the body of a source-generated P/Invoke and providing customization for how to invoke/define the native method. - /// - /// - /// This type enables multiple code generators for P/Invoke-style marshalling - /// to reuse the same basic method body, but with different designs of how to emit the target native method. - /// This enables users to write code generators that work with slightly different semantics. - /// For example, the source generator for [LibraryImport] emits the target P/Invoke as - /// a local function inside the generated stub body. - /// However, other managed-to-native code generators using a P/Invoke style might want to define - /// the target DllImport outside of the stub as a static non-local function or as a function pointer field. - /// This refactoring allows the code generator to have control over where the target method is declared - /// and how it is declared. - /// - internal sealed class ManagedToNativeVTableMethodGenerator - { - private const string ReturnIdentifier = "__retVal"; - private const string LastErrorIdentifier = "__lastError"; - private const string InvokeSucceededIdentifier = "__invokeSucceeded"; - private const string NativeThisParameterIdentifier = "__this"; - private const string VirtualMethodTableIdentifier = $"__vtable{StubCodeContext.GeneratedNativeIdentifierSuffix}"; - - // Error code representing success. This maps to S_OK for Windows HRESULT semantics and 0 for POSIX errno semantics. - private const int SuccessErrorCode = 0; - private readonly bool _setLastError; - private readonly BoundGenerators _marshallers; - - private readonly ManagedToNativeStubCodeContext _context; - - public ManagedToNativeVTableMethodGenerator( - ImmutableArray argTypes, - bool setLastError, - bool implicitThis, - GeneratorDiagnosticsBag diagnosticsBag, - IMarshallingGeneratorResolver generatorResolver) - { - _setLastError = setLastError; - if (implicitThis) - { - ImmutableArray.Builder newArgTypes = ImmutableArray.CreateBuilder(argTypes.Length + 1); - newArgTypes.Add(new TypePositionInfo(new PointerTypeInfo("void*", "void*", false), NoMarshallingInfo.Instance) - { - InstanceIdentifier = NativeThisParameterIdentifier, - NativeIndex = 0 - }); - foreach (var arg in argTypes) - { - newArgTypes.Add(arg with - { - NativeIndex = arg.NativeIndex switch - { - TypePositionInfo.UnsetIndex or TypePositionInfo.ReturnIndex => arg.NativeIndex, - int index => index + 1 - } - }); - } - argTypes = newArgTypes.ToImmutableArray(); - } - - _context = new ManagedToNativeStubCodeContext(ReturnIdentifier, ReturnIdentifier); - _marshallers = BoundGenerators.Create(argTypes, generatorResolver, _context, new Forwarder(), out var bindingFailures); - - diagnosticsBag.ReportGeneratorDiagnostics(bindingFailures); - - if (_marshallers.ManagedReturnMarshaller.Generator.UsesNativeIdentifier(_marshallers.ManagedReturnMarshaller.TypeInfo, _context)) - { - // If we need a different native return identifier, then recreate the context with the correct identifier before we generate any code. - _context = new ManagedToNativeStubCodeContext(ReturnIdentifier, $"{ReturnIdentifier}{StubCodeContext.GeneratedNativeIdentifierSuffix}"); - } - } - - /// - /// Generate the method body of the p/invoke stub. - /// - /// Name of the target DllImport function to invoke - /// Method body of the p/invoke stub - /// - /// The generated code assumes it will be in an unsafe context. - /// - public BlockSyntax GenerateStubBody(int index, ImmutableArray callConv, TypeSyntax containingTypeName) - { - var setupStatements = new List - { - // var (, ) = ((IUnmanagedVirtualMethodTableProvider)this).GetVirtualMethodTableInfoForKey(typeof()); - AssignmentStatement( - DeclarationExpression( - IdentifierName("var"), - ParenthesizedVariableDesignation( - SeparatedList( - new[]{ - SingleVariableDesignation( - Identifier(NativeThisParameterIdentifier)), - SingleVariableDesignation( - Identifier(VirtualMethodTableIdentifier))}))), - MethodInvocation( - ParenthesizedExpression( - CastExpression( - TypeSyntaxes.IUnmanagedVirtualMethodTableProvider, - ThisExpression())), - IdentifierName("GetVirtualMethodTableInfoForKey"), - Argument(TypeOfExpression(containingTypeName)))) - }; - - GeneratedStatements statements = GeneratedStatements.Create( - _marshallers, - _context, - CreateFunctionPointerExpression( - // [] - IndexExpression(IdentifierName(VirtualMethodTableIdentifier), Argument(IntLiteral(index))), - callConv)); - bool shouldInitializeVariables = !statements.GuaranteedUnmarshal.IsEmpty || !statements.CleanupCallerAllocated.IsEmpty || !statements.CleanupCalleeAllocated.IsEmpty; - VariableDeclarations declarations = VariableDeclarations.GenerateDeclarationsForManagedToUnmanaged(_marshallers, _context, shouldInitializeVariables); - - if (_setLastError) - { - // Declare variable for last error - setupStatements.Add(Declare( - PredefinedType(Token(SyntaxKind.IntKeyword)), - LastErrorIdentifier, - initializeToDefault: false)); - } - - if (!(statements.GuaranteedUnmarshal.IsEmpty && statements.CleanupCalleeAllocated.IsEmpty)) - { - setupStatements.Add(Declare(PredefinedType(Token(SyntaxKind.BoolKeyword)), InvokeSucceededIdentifier, initializeToDefault: true)); - } - - setupStatements.AddRange(declarations.Initializations); - setupStatements.AddRange(declarations.Variables); - setupStatements.AddRange(statements.Setup); - - var tryStatements = new List(); - tryStatements.AddRange(statements.Marshal); - - - BlockSyntax fixedBlock = Block(statements.PinnedMarshal); - if (_setLastError) - { - StatementSyntax clearLastError = MarshallerHelpers.CreateClearLastSystemErrorStatement(SuccessErrorCode); - - StatementSyntax getLastError = MarshallerHelpers.CreateGetLastSystemErrorStatement(LastErrorIdentifier); - - fixedBlock = fixedBlock.AddStatements(clearLastError, statements.InvokeStatement, getLastError); - } - else - { - fixedBlock = fixedBlock.AddStatements(statements.InvokeStatement); - } - tryStatements.Add(statements.Pin.CastArray().NestFixedStatements(fixedBlock)); - - tryStatements.AddRange(statements.NotifyForSuccessfulInvoke); - - // = true; - if (!(statements.GuaranteedUnmarshal.IsEmpty && statements.CleanupCalleeAllocated.IsEmpty)) - { - tryStatements.Add(ExpressionStatement(AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, - IdentifierName(InvokeSucceededIdentifier), - LiteralExpression(SyntaxKind.TrueLiteralExpression)))); - } - - // Keep the this object alive across the native call, similar to how we handle marshalling managed delegates. - // We do this right after the NotifyForSuccessfulInvoke phase as that phase is where the delegate objects are kept alive. - // If we ever move the "this" object handling out of this type, we'll move the handling to be emitted in that phase. - // GC.KeepAlive(this); - tryStatements.Add( - MethodInvocationStatement( - TypeSyntaxes.System_GC, - IdentifierName("KeepAlive"), - Argument(ThisExpression()))); - - tryStatements.AddRange(statements.Unmarshal); - - List allStatements = setupStatements; - List finallyStatements = new List(); - if (!(statements.GuaranteedUnmarshal.IsEmpty && statements.CleanupCalleeAllocated.IsEmpty)) - { - finallyStatements.Add(IfStatement(IdentifierName(InvokeSucceededIdentifier), Block(statements.GuaranteedUnmarshal.Concat(statements.CleanupCalleeAllocated)))); - } - - finallyStatements.AddRange(statements.CleanupCallerAllocated); - if (finallyStatements.Count > 0) - { - // Add try-finally block if there are any statements in the finally block - allStatements.Add( - TryStatement(Block(tryStatements), default, FinallyClause(Block(finallyStatements)))); - } - else - { - allStatements.AddRange(tryStatements); - } - - if (_setLastError) - { - // Marshal.SetLastPInvokeError(); - allStatements.Add(MarshallerHelpers.CreateSetLastPInvokeErrorStatement(LastErrorIdentifier)); - } - - // Return - if (!_marshallers.IsManagedVoidReturn) - allStatements.Add(ReturnStatement(IdentifierName(_context.GetIdentifiers(_marshallers.ManagedReturnMarshaller.TypeInfo).managed))); - - return Block(allStatements.Where(s => s is not EmptyStatementSyntax)); - } - - private ParenthesizedExpressionSyntax CreateFunctionPointerExpression( - ExpressionSyntax untypedFunctionPointerExpression, - ImmutableArray callConv) - { - List functionPointerParameters = new(); - var (paramList, retType, _) = _marshallers.GenerateTargetMethodSignatureData(_context); - functionPointerParameters.AddRange(paramList.Parameters.Select(p => FunctionPointerParameter(attributeLists: default, p.Modifiers, p.Type))); - functionPointerParameters.Add(FunctionPointerParameter(retType)); - - // ((delegate* unmanaged<...>)) - return ParenthesizedExpression(CastExpression( - FunctionPointerType( - FunctionPointerCallingConvention(Token(SyntaxKind.UnmanagedKeyword), callConv.IsEmpty ? null : FunctionPointerUnmanagedCallingConventionList(SeparatedList(callConv))), - FunctionPointerParameterList(SeparatedList(functionPointerParameters))), - untypedFunctionPointerExpression)); - } - } -} diff --git a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Marshallers/ComInterfaceDispatchMarshallingResolver.cs b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Marshallers/ComInterfaceDispatchMarshallingResolver.cs index f93be2ed993..145ed0b5830 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Marshallers/ComInterfaceDispatchMarshallingResolver.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Marshallers/ComInterfaceDispatchMarshallingResolver.cs @@ -17,18 +17,29 @@ internal sealed record ComInterfaceDispatchMarshallingInfo : MarshallingInfo internal sealed class ComInterfaceDispatchMarshallingResolver : IMarshallingGeneratorResolver { public ResolvedGenerator Create(TypePositionInfo info, StubCodeContext context) - => info.MarshallingAttributeInfo is ComInterfaceDispatchMarshallingInfo ? ResolvedGenerator.Resolved(new Marshaller()) : ResolvedGenerator.UnresolvedGenerator; + { + if (info.MarshallingAttributeInfo is ComInterfaceDispatchMarshallingInfo) + { + return context.Direction == MarshalDirection.UnmanagedToManaged + ? ResolvedGenerator.Resolved(new Marshaller().Bind(info, context)) + : ResolvedGenerator.Resolved(KeepAliveThisMarshaller.Instance.Bind(info, context)); + } + else + { + return ResolvedGenerator.UnresolvedGenerator; + } + } - private sealed class Marshaller : IMarshallingGenerator + private sealed class Marshaller : IUnboundMarshallingGenerator { public ManagedTypeInfo AsNativeType(TypePositionInfo info) => new PointerTypeInfo( $"{TypeNames.GlobalAlias + TypeNames.System_Runtime_InteropServices_ComWrappers_ComInterfaceDispatch}*", $"{TypeNames.System_Runtime_InteropServices_ComWrappers_ComInterfaceDispatch}*", IsFunctionPointer: false); - public IEnumerable Generate(TypePositionInfo info, StubCodeContext context) + public IEnumerable Generate(TypePositionInfo info, StubCodeContext codeContext, StubIdentifierContext context) { - if (context.CurrentStage != StubCodeContext.Stage.Unmarshal) + if (context.CurrentStage != StubIdentifierContext.Stage.Unmarshal) { yield break; } @@ -53,8 +64,8 @@ public IEnumerable Generate(TypePositionInfo info, StubCodeCont public SignatureBehavior GetNativeSignatureBehavior(TypePositionInfo info) => SignatureBehavior.NativeType; public ValueBoundaryBehavior GetValueBoundaryBehavior(TypePositionInfo info, StubCodeContext context) => ValueBoundaryBehavior.NativeIdentifier; - public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, StubCodeContext context, out GeneratorDiagnostic? diagnostic) - => ByValueMarshalKindSupportDescriptor.Default.GetSupport(marshalKind, info, context, out diagnostic); + public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, out GeneratorDiagnostic? diagnostic) + => ByValueMarshalKindSupportDescriptor.Default.GetSupport(marshalKind, info, out diagnostic); public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) => true; } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Marshallers/KeepAliveThisMarshaller.cs b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Marshallers/KeepAliveThisMarshaller.cs new file mode 100644 index 00000000000..0d1cc0a7c96 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Marshallers/KeepAliveThisMarshaller.cs @@ -0,0 +1,40 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Generic; +using System.Text; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; +using static Microsoft.Interop.SyntaxFactoryExtensions; + +namespace Microsoft.Interop +{ + internal sealed class KeepAliveThisMarshaller : IUnboundMarshallingGenerator + { + public static readonly KeepAliveThisMarshaller Instance = new(); + + public ManagedTypeInfo AsNativeType(TypePositionInfo info) => info.ManagedType; + public IEnumerable Generate(TypePositionInfo info, StubCodeContext codeContext, StubIdentifierContext context) + { + if (context.CurrentStage != StubIdentifierContext.Stage.NotifyForSuccessfulInvoke) + { + return []; + } + + return [ + MethodInvocationStatement( + TypeSyntaxes.System_GC, + IdentifierName("KeepAlive"), + Argument(ThisExpression())) + ]; + } + + public SignatureBehavior GetNativeSignatureBehavior(TypePositionInfo info) => SignatureBehavior.NativeType; + public ValueBoundaryBehavior GetValueBoundaryBehavior(TypePositionInfo info, StubCodeContext context) => ValueBoundaryBehavior.ManagedIdentifier; + public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, out GeneratorDiagnostic? diagnostic) + => ByValueMarshalKindSupportDescriptor.Default.GetSupport(marshalKind, info, out diagnostic); + + public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) => false; + } +} diff --git a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Marshallers/ManagedHResultExceptionGeneratorResolver.cs b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Marshallers/ManagedHResultExceptionGeneratorResolver.cs index 58123926316..8f8254fa6f6 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Marshallers/ManagedHResultExceptionGeneratorResolver.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Marshallers/ManagedHResultExceptionGeneratorResolver.cs @@ -15,25 +15,14 @@ internal sealed record ManagedHResultExceptionMarshallingInfo : MarshallingInfo; internal sealed class ManagedHResultExceptionGeneratorResolver : IMarshallingGeneratorResolver { - private readonly MarshalDirection _direction; - - public ManagedHResultExceptionGeneratorResolver(MarshalDirection direction) - { - if (direction is not (MarshalDirection.ManagedToUnmanaged or MarshalDirection.UnmanagedToManaged)) - { - throw new ArgumentOutOfRangeException(nameof(direction)); - } - _direction = direction; - } - public ResolvedGenerator Create(TypePositionInfo info, StubCodeContext context) { if (info.MarshallingAttributeInfo is ManagedHResultExceptionMarshallingInfo) { - return ResolvedGenerator.Resolved(_direction switch + return ResolvedGenerator.Resolved(context.Direction switch { - MarshalDirection.UnmanagedToManaged => new UnmanagedToManagedMarshaller(), - MarshalDirection.ManagedToUnmanaged => new ManagedToUnmanagedMarshaller(), + MarshalDirection.UnmanagedToManaged => new UnmanagedToManagedMarshaller().Bind(info, context), + MarshalDirection.ManagedToUnmanaged => new ManagedToUnmanagedMarshaller().Bind(info, context), _ => throw new UnreachableException() }); } @@ -43,14 +32,14 @@ public ResolvedGenerator Create(TypePositionInfo info, StubCodeContext context) } } - private sealed class ManagedToUnmanagedMarshaller : IMarshallingGenerator + private sealed class ManagedToUnmanagedMarshaller : IUnboundMarshallingGenerator { public ManagedTypeInfo AsNativeType(TypePositionInfo info) => info.ManagedType; - public IEnumerable Generate(TypePositionInfo info, StubCodeContext context) + public IEnumerable Generate(TypePositionInfo info, StubCodeContext codeContext, StubIdentifierContext context) { Debug.Assert(info.MarshallingAttributeInfo is ManagedHResultExceptionMarshallingInfo); - if (context.CurrentStage != StubCodeContext.Stage.NotifyForSuccessfulInvoke) + if (context.CurrentStage != StubIdentifierContext.Stage.NotifyForSuccessfulInvoke) { yield break; } @@ -66,19 +55,19 @@ public IEnumerable Generate(TypePositionInfo info, StubCodeCont public SignatureBehavior GetNativeSignatureBehavior(TypePositionInfo info) => SignatureBehavior.NativeType; public ValueBoundaryBehavior GetValueBoundaryBehavior(TypePositionInfo info, StubCodeContext context) => ValueBoundaryBehavior.ManagedIdentifier; - public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, StubCodeContext context, out GeneratorDiagnostic? diagnostic) - => ByValueMarshalKindSupportDescriptor.Default.GetSupport(marshalKind, info, context, out diagnostic); + public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, out GeneratorDiagnostic? diagnostic) + => ByValueMarshalKindSupportDescriptor.Default.GetSupport(marshalKind, info, out diagnostic); public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) => false; } - private sealed class UnmanagedToManagedMarshaller : IMarshallingGenerator + private sealed class UnmanagedToManagedMarshaller : IUnboundMarshallingGenerator { public ManagedTypeInfo AsNativeType(TypePositionInfo info) => info.ManagedType; - public IEnumerable Generate(TypePositionInfo info, StubCodeContext context) + public IEnumerable Generate(TypePositionInfo info, StubCodeContext codeContext, StubIdentifierContext context) { Debug.Assert(info.MarshallingAttributeInfo is ManagedHResultExceptionMarshallingInfo); - if (context.CurrentStage != StubCodeContext.Stage.NotifyForSuccessfulInvoke) + if (context.CurrentStage != StubIdentifierContext.Stage.NotifyForSuccessfulInvoke) { yield break; } @@ -103,8 +92,8 @@ public IEnumerable Generate(TypePositionInfo info, StubCodeCont public SignatureBehavior GetNativeSignatureBehavior(TypePositionInfo info) => SignatureBehavior.NativeType; public ValueBoundaryBehavior GetValueBoundaryBehavior(TypePositionInfo info, StubCodeContext context) => ValueBoundaryBehavior.ManagedIdentifier; - public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, StubCodeContext context, out GeneratorDiagnostic? diagnostic) - => ByValueMarshalKindSupportDescriptor.Default.GetSupport(marshalKind, info, context, out diagnostic); + public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, out GeneratorDiagnostic? diagnostic) + => ByValueMarshalKindSupportDescriptor.Default.GetSupport(marshalKind, info, out diagnostic); public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) => false; } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Marshallers/ObjectUnwrapperResolver.cs b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Marshallers/ObjectUnwrapperResolver.cs index 9f76b8bf19d..29b758c6ce5 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Marshallers/ObjectUnwrapperResolver.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Marshallers/ObjectUnwrapperResolver.cs @@ -15,16 +15,27 @@ internal sealed record ObjectUnwrapperInfo(TypeSyntax UnwrapperType) : Marshalli internal sealed class ObjectUnwrapperResolver : IMarshallingGeneratorResolver { public ResolvedGenerator Create(TypePositionInfo info, StubCodeContext context) - => info.MarshallingAttributeInfo is ObjectUnwrapperInfo ? ResolvedGenerator.Resolved(new Marshaller()) : ResolvedGenerator.UnresolvedGenerator; + { + if (info.MarshallingAttributeInfo is ObjectUnwrapperInfo) + { + return context.Direction == MarshalDirection.UnmanagedToManaged + ? ResolvedGenerator.Resolved(new Marshaller().Bind(info, context)) + : ResolvedGenerator.Resolved(KeepAliveThisMarshaller.Instance.Bind(info, context)); + } + else + { + return ResolvedGenerator.UnresolvedGenerator; + } + } - private sealed class Marshaller : IMarshallingGenerator + private sealed class Marshaller : IUnboundMarshallingGenerator { public ManagedTypeInfo AsNativeType(TypePositionInfo info) => new PointerTypeInfo("void*", "void*", false); - public IEnumerable Generate(TypePositionInfo info, StubCodeContext context) + public IEnumerable Generate(TypePositionInfo info, StubCodeContext codeContext, StubIdentifierContext context) { Debug.Assert(info.MarshallingAttributeInfo is ObjectUnwrapperInfo); TypeSyntax unwrapperType = ((ObjectUnwrapperInfo)info.MarshallingAttributeInfo).UnwrapperType; - if (context.CurrentStage != StubCodeContext.Stage.Unmarshal) + if (context.CurrentStage != StubIdentifierContext.Stage.Unmarshal) { yield break; } @@ -48,8 +59,8 @@ public IEnumerable Generate(TypePositionInfo info, StubCodeCont public SignatureBehavior GetNativeSignatureBehavior(TypePositionInfo info) => SignatureBehavior.NativeType; public ValueBoundaryBehavior GetValueBoundaryBehavior(TypePositionInfo info, StubCodeContext context) => ValueBoundaryBehavior.NativeIdentifier; - public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, StubCodeContext context, out GeneratorDiagnostic? diagnostic) - => ByValueMarshalKindSupportDescriptor.Default.GetSupport(marshalKind, info, context, out diagnostic); + public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, out GeneratorDiagnostic? diagnostic) + => ByValueMarshalKindSupportDescriptor.Default.GetSupport(marshalKind, info, out diagnostic); public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) => true; } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Marshallers/StructAsHResultMarshallerFactory.cs b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Marshallers/StructAsHResultMarshallerFactory.cs index 89b297b4e35..af66c1c2d70 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Marshallers/StructAsHResultMarshallerFactory.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/Marshallers/StructAsHResultMarshallerFactory.cs @@ -19,24 +19,24 @@ public ResolvedGenerator Create(TypePositionInfo info, StubCodeContext context) // Value type with MarshalAs(UnmanagedType.Error), to be marshalled as an unmanaged HRESULT. if (info is { ManagedType: ValueTypeInfo, MarshallingAttributeInfo: MarshalAsInfo(UnmanagedType.Error, _) }) { - return ResolvedGenerator.Resolved(s_marshaller); + return ResolvedGenerator.Resolved(s_marshaller.Bind(info, context)); } return ResolvedGenerator.UnresolvedGenerator; } - private sealed class Marshaller : IMarshallingGenerator + private sealed class Marshaller : IUnboundMarshallingGenerator { public ManagedTypeInfo AsNativeType(TypePositionInfo info) => SpecialTypeInfo.Int32; - public IEnumerable Generate(TypePositionInfo info, StubCodeContext context) + public IEnumerable Generate(TypePositionInfo info, StubCodeContext codeContext, StubIdentifierContext context) { var (managed, unmanaged) = context.GetIdentifiers(info); switch (context.CurrentStage) { - case StubCodeContext.Stage.Marshal: - if (MarshallerHelpers.GetMarshalDirection(info, context) is MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional) + case StubIdentifierContext.Stage.Marshal: + if (MarshallerHelpers.GetMarshalDirection(info, codeContext) is MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional) { // unmanaged = Unsafe.BitCast(managed); yield return AssignmentStatement( @@ -53,8 +53,8 @@ public IEnumerable Generate(TypePositionInfo info, StubCodeCont Argument(IdentifierName(managed)))); } break; - case StubCodeContext.Stage.Unmarshal: - if (MarshallerHelpers.GetMarshalDirection(info, context) is MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional) + case StubIdentifierContext.Stage.Unmarshal: + if (MarshallerHelpers.GetMarshalDirection(info, codeContext) is MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional) { // managed = Unsafe.BitCast(unmanaged); yield return AssignmentStatement( @@ -91,8 +91,8 @@ public ValueBoundaryBehavior GetValueBoundaryBehavior(TypePositionInfo info, Stu return ValueBoundaryBehavior.NativeIdentifier; } - public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, StubCodeContext context, out GeneratorDiagnostic? diagnostic) - => ByValueMarshalKindSupportDescriptor.Default.GetSupport(marshalKind, info, context, out diagnostic); + public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, out GeneratorDiagnostic? diagnostic) + => ByValueMarshalKindSupportDescriptor.Default.GetSupport(marshalKind, info, out diagnostic); public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) => true; } diff --git a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/UnmanagedToManagedStubGenerator.cs b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/UnmanagedToManagedStubGenerator.cs index ed94e5d127a..04897fb03d7 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/UnmanagedToManagedStubGenerator.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/UnmanagedToManagedStubGenerator.cs @@ -17,22 +17,25 @@ internal sealed class UnmanagedToManagedStubGenerator private readonly BoundGenerators _marshallers; - private readonly NativeToManagedStubCodeContext _context; + private readonly StubIdentifierContext _context; public UnmanagedToManagedStubGenerator( ImmutableArray argTypes, GeneratorDiagnosticsBag diagnosticsBag, IMarshallingGeneratorResolver generatorResolver) { - _context = new NativeToManagedStubCodeContext(ReturnIdentifier, ReturnIdentifier); - _marshallers = BoundGenerators.Create(argTypes, generatorResolver, _context, new Forwarder(), out var bindingDiagnostics); + _marshallers = BoundGenerators.Create(argTypes, generatorResolver, StubCodeContext.DefaultNativeToManagedStub, new Forwarder(), out var bindingDiagnostics); diagnosticsBag.ReportGeneratorDiagnostics(bindingDiagnostics); - if (_marshallers.NativeReturnMarshaller.Generator.UsesNativeIdentifier(_marshallers.NativeReturnMarshaller.TypeInfo, _context)) + if (_marshallers.NativeReturnMarshaller.UsesNativeIdentifier) { // If we need a different native return identifier, then recreate the context with the correct identifier before we generate any code. - _context = new NativeToManagedStubCodeContext(ReturnIdentifier, $"{ReturnIdentifier}{StubCodeContext.GeneratedNativeIdentifierSuffix}"); + _context = new DefaultIdentifierContext(ReturnIdentifier, $"{ReturnIdentifier}{StubIdentifierContext.GeneratedNativeIdentifierSuffix}", MarshalDirection.UnmanagedToManaged); + } + else + { + _context = new DefaultIdentifierContext(ReturnIdentifier, ReturnIdentifier, MarshalDirection.UnmanagedToManaged); } } @@ -46,11 +49,10 @@ public UnmanagedToManagedStubGenerator( /// public BlockSyntax GenerateStubBody(ExpressionSyntax methodToInvoke) { - List setupStatements = new(); GeneratedStatements statements = GeneratedStatements.Create( _marshallers, - _context, - methodToInvoke); + StubCodeContext.DefaultNativeToManagedStub, + _context, methodToInvoke); Debug.Assert(statements.CleanupCalleeAllocated.IsEmpty); bool shouldInitializeVariables = @@ -59,27 +61,29 @@ public BlockSyntax GenerateStubBody(ExpressionSyntax methodToInvoke) || !statements.ManagedExceptionCatchClauses.IsEmpty; VariableDeclarations declarations = VariableDeclarations.GenerateDeclarationsForUnmanagedToManaged(_marshallers, _context, shouldInitializeVariables); - setupStatements.AddRange(declarations.Initializations); - setupStatements.AddRange(declarations.Variables); - setupStatements.AddRange(statements.Setup); - - List tryStatements = new(); - tryStatements.AddRange(statements.GuaranteedUnmarshal); - tryStatements.AddRange(statements.Unmarshal); - - tryStatements.Add(statements.InvokeStatement); - - tryStatements.AddRange(statements.NotifyForSuccessfulInvoke); - tryStatements.AddRange(statements.Marshal); - tryStatements.AddRange(statements.PinnedMarshal); + List setupStatements = + [ + .. declarations.Initializations, + .. declarations.Variables, + .. statements.Setup, + ]; + + List tryStatements = + [ + .. statements.GuaranteedUnmarshal, + .. statements.Unmarshal, + statements.InvokeStatement, + .. statements.NotifyForSuccessfulInvoke, + .. statements.Marshal, + .. statements.PinnedMarshal, + ]; List allStatements = setupStatements; - List finallyStatements = new(); SyntaxList catchClauses = List(statements.ManagedExceptionCatchClauses); - finallyStatements.AddRange(statements.CleanupCallerAllocated); - if (finallyStatements.Count > 0) + ImmutableArray finallyStatements = statements.CleanupCallerAllocated; + if (finallyStatements.Length > 0) { allStatements.Add( TryStatement(Block(tryStatements), catchClauses, FinallyClause(Block(finallyStatements)))); diff --git a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/UnreachableException.cs b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/UnreachableException.cs deleted file mode 100644 index 9a3052235ca..00000000000 --- a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/UnreachableException.cs +++ /dev/null @@ -1,14 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System; - -namespace Microsoft.Interop -{ - /// - /// An exception that should be thrown on code-paths that are unreachable. - /// - internal sealed class UnreachableException : Exception - { - } -} diff --git a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/VirtualMethodPointerStubGenerator.cs b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/VirtualMethodPointerStubGenerator.cs index 84a838ac148..880022431c0 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/VirtualMethodPointerStubGenerator.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/ComInterfaceGenerator/VirtualMethodPointerStubGenerator.cs @@ -8,6 +8,7 @@ using Microsoft.CodeAnalysis.CSharp.Syntax; using Microsoft.CodeAnalysis.CSharp; using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; +using static Microsoft.Interop.SyntaxFactoryExtensions; using Microsoft.CodeAnalysis; using System.Diagnostics; @@ -15,24 +16,70 @@ namespace Microsoft.Interop { internal static class VirtualMethodPointerStubGenerator { + private const string NativeThisParameterIdentifier = "__this"; + private const string VirtualMethodTableIdentifier = "__vtable"; + private const string VirtualMethodTarget = "__target"; + public static (MethodDeclarationSyntax, ImmutableArray) GenerateManagedToNativeStub( IncrementalMethodStubGenerationContext methodStub, Func generatorResolverCreator) { var diagnostics = new GeneratorDiagnosticsBag(new DiagnosticDescriptorProvider(), methodStub.DiagnosticLocation, SR.ResourceManager, typeof(FxResources.Microsoft.Interop.ComInterfaceGenerator.SR)); + ImmutableArray elements = methodStub.SignatureContext.ElementTypeInformation; + + if (methodStub.VtableIndexData.ImplicitThisParameter) + { + elements = AddManagedToUnmanagedImplicitThis(methodStub); + } + // Generate stub code - var stubGenerator = new ManagedToNativeVTableMethodGenerator( - methodStub.SignatureContext.ElementTypeInformation, + var stubGenerator = new ManagedToNativeStubGenerator( + elements, methodStub.VtableIndexData.SetLastError, - methodStub.VtableIndexData.ImplicitThisParameter, diagnostics, - generatorResolverCreator(methodStub.EnvironmentFlags, MarshalDirection.ManagedToUnmanaged)); + generatorResolverCreator(methodStub.EnvironmentFlags, MarshalDirection.ManagedToUnmanaged), + new CodeEmitOptions(SkipInit: true)); - BlockSyntax code = stubGenerator.GenerateStubBody( - methodStub.VtableIndexData.Index, - methodStub.CallingConvention.Array, - methodStub.TypeKeyOwner.Syntax); + BlockSyntax code = stubGenerator.GenerateStubBody(VirtualMethodTarget); + + var setupStatements = new List + { + // var (, ) = ((IUnmanagedVirtualMethodTableProvider)this).GetVirtualMethodTableInfoForKey(typeof()); + AssignmentStatement( + DeclarationExpression( + IdentifierName("var"), + ParenthesizedVariableDesignation( + SeparatedList( + new[]{ + SingleVariableDesignation( + Identifier(NativeThisParameterIdentifier)), + SingleVariableDesignation( + Identifier(VirtualMethodTableIdentifier))}))), + MethodInvocation( + ParenthesizedExpression( + CastExpression( + TypeSyntaxes.IUnmanagedVirtualMethodTableProvider, + ThisExpression())), + IdentifierName("GetVirtualMethodTableInfoForKey"), + Argument(TypeOfExpression(methodStub.TypeKeyOwner.Syntax)))), + // var = (()[]); + AssignmentStatement( + DeclarationExpression( + IdentifierName("var"), + SingleVariableDesignation(Identifier(VirtualMethodTarget))), + CreateFunctionPointerExpression( + stubGenerator, + IndexExpression( + IdentifierName(VirtualMethodTableIdentifier), + Argument(LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(methodStub.VtableIndexData.Index)))), + methodStub.CallingConvention.Array)), + }; + + code = Block(List([ + .. setupStatements, + code, + ])); // The owner type will always be an interface type, so the syntax will always be a NameSyntax as it's the name of a named type // with no additional decorators. @@ -46,6 +93,25 @@ public static (MethodDeclarationSyntax, ImmutableArray) Generate .WithExplicitInterfaceSpecifier(ExplicitInterfaceSpecifier((NameSyntax)methodStub.TypeKeyOwner.Syntax)), methodStub.Diagnostics.Array.AddRange(diagnostics.Diagnostics)); } + + private static ParenthesizedExpressionSyntax CreateFunctionPointerExpression( + ManagedToNativeStubGenerator stubGenerator, + ExpressionSyntax untypedFunctionPointerExpression, + ImmutableArray callConv) + { + List functionPointerParameters = []; + var (paramList, retType, _) = stubGenerator.GenerateTargetMethodSignatureData(); + functionPointerParameters.AddRange(paramList.Parameters.Select(p => FunctionPointerParameter(attributeLists: default, p.Modifiers, p.Type))); + functionPointerParameters.Add(FunctionPointerParameter(retType)); + + // ((delegate* unmanaged<...>)) + return ParenthesizedExpression(CastExpression( + FunctionPointerType( + FunctionPointerCallingConvention(Token(SyntaxKind.UnmanagedKeyword), callConv.IsEmpty ? null : FunctionPointerUnmanagedCallingConventionList(SeparatedList(callConv))), + FunctionPointerParameterList(SeparatedList(functionPointerParameters))), + untypedFunctionPointerExpression)); + } + private static MethodDeclarationSyntax PrintGeneratedSource( ContainingSyntax stubMethodSyntax, SignatureContext stub, @@ -59,7 +125,7 @@ private static MethodDeclarationSyntax PrintGeneratedSource( .WithBody(stubCode); } - private const string ThisParameterIdentifier = "@this"; + private const string ManagedThisParameterIdentifier = "@this"; public static (MethodDeclarationSyntax, ImmutableArray) GenerateNativeToManagedStub( IncrementalMethodStubGenerationContext methodStub, @@ -67,7 +133,7 @@ public static (MethodDeclarationSyntax, ImmutableArray) Generate { var diagnostics = new GeneratorDiagnosticsBag(new DiagnosticDescriptorProvider(), methodStub.DiagnosticLocation, SR.ResourceManager, typeof(FxResources.Microsoft.Interop.ComInterfaceGenerator.SR)); - ImmutableArray elements = AddImplicitElementInfos(methodStub); + ImmutableArray elements = AddUnmanagedToManagedImplicitElementInfos(methodStub); // Generate stub code var stubGenerator = new UnmanagedToManagedStubGenerator( @@ -77,7 +143,7 @@ public static (MethodDeclarationSyntax, ImmutableArray) Generate BlockSyntax code = stubGenerator.GenerateStubBody( MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, - IdentifierName(ThisParameterIdentifier), + IdentifierName(ManagedThisParameterIdentifier), IdentifierName(methodStub.StubMethodSyntaxTemplate.Identifier))); (ParameterListSyntax unmanagedParameterList, TypeSyntax returnType, _) = stubGenerator.GenerateAbiMethodSignatureData(); @@ -107,7 +173,30 @@ public static (MethodDeclarationSyntax, ImmutableArray) Generate unmanagedToManagedStub, methodStub.Diagnostics.Array.AddRange(diagnostics.Diagnostics)); } - private static ImmutableArray AddImplicitElementInfos(IncrementalMethodStubGenerationContext methodStub) + + private static ImmutableArray AddManagedToUnmanagedImplicitThis(IncrementalMethodStubGenerationContext methodStub) + { + ImmutableArray originalElements = methodStub.SignatureContext.ElementTypeInformation; + + var elements = ImmutableArray.CreateBuilder(originalElements.Length + 2); + + elements.Add(new TypePositionInfo(new PointerTypeInfo("void*", "void*", false), methodStub.ManagedThisMarshallingInfo) + { + InstanceIdentifier = NativeThisParameterIdentifier, + NativeIndex = 0, + }); + foreach (TypePositionInfo element in originalElements) + { + elements.Add(element with + { + NativeIndex = TypePositionInfo.IncrementIndex(element.NativeIndex) + }); + } + + return elements.ToImmutable(); + } + + private static ImmutableArray AddUnmanagedToManagedImplicitElementInfos(IncrementalMethodStubGenerationContext methodStub) { ImmutableArray originalElements = methodStub.SignatureContext.ElementTypeInformation; @@ -115,7 +204,7 @@ private static ImmutableArray AddImplicitElementInfos(Incremen elements.Add(new TypePositionInfo(methodStub.TypeKeyOwner, methodStub.ManagedThisMarshallingInfo) { - InstanceIdentifier = ThisParameterIdentifier, + InstanceIdentifier = ManagedThisParameterIdentifier, NativeIndex = 0, }); foreach (TypePositionInfo element in originalElements) @@ -175,7 +264,7 @@ private static FunctionPointerTypeSyntax GenerateUnmanagedFunctionPointerTypeFor var diagnostics = new GeneratorDiagnosticsBag(new DiagnosticDescriptorProvider(), method.DiagnosticLocation, SR.ResourceManager, typeof(FxResources.Microsoft.Interop.ComInterfaceGenerator.SR)); var stubGenerator = new UnmanagedToManagedStubGenerator( - AddImplicitElementInfos(method), + AddUnmanagedToManagedImplicitElementInfos(method), diagnostics, generatorResolverCreator(method.EnvironmentFlags, MarshalDirection.UnmanagedToManaged)); diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportData.cs b/src/libraries/System.Runtime.InteropServices/gen/Common/LibraryImportData.cs similarity index 100% rename from src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportData.cs rename to src/libraries/System.Runtime.InteropServices/gen/Common/LibraryImportData.cs diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/UnreachableException.cs b/src/libraries/System.Runtime.InteropServices/gen/Common/UnreachableException.cs similarity index 87% rename from src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/UnreachableException.cs rename to src/libraries/System.Runtime.InteropServices/gen/Common/UnreachableException.cs index 48f0d77b1b4..3934612222b 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/UnreachableException.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Common/UnreachableException.cs @@ -1,4 +1,4 @@ -// Licensed to the .NET Foundation under one or more agreements. +// Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. using System; diff --git a/src/libraries/System.Runtime.InteropServices/gen/DownlevelLibraryImportGenerator/Comparers.cs b/src/libraries/System.Runtime.InteropServices/gen/DownlevelLibraryImportGenerator/Comparers.cs new file mode 100644 index 00000000000..87a565111f6 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/DownlevelLibraryImportGenerator/Comparers.cs @@ -0,0 +1,70 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Linq; + +namespace Microsoft.Interop +{ + internal static class Comparers + { + /// + /// Comparer for an individual generated stub source as a syntax tree and the generated diagnostics for the stub. + /// + public static readonly IEqualityComparer<(MemberDeclarationSyntax Syntax, ImmutableArray Diagnostics)> GeneratedSyntax = new CustomValueTupleElementComparer>(SyntaxEquivalentComparer.Instance, new ImmutableArraySequenceEqualComparer(EqualityComparer.Default)); + } + + /// + /// Generic comparer to compare two instances element by element. + /// + /// The type of immutable array element. + internal sealed class ImmutableArraySequenceEqualComparer : IEqualityComparer> + { + private readonly IEqualityComparer _elementComparer; + + /// + /// Creates an with a custom comparer for the elements of the collection. + /// + /// The comparer instance for the collection elements. + public ImmutableArraySequenceEqualComparer(IEqualityComparer elementComparer) + { + _elementComparer = elementComparer; + } + + public bool Equals(ImmutableArray x, ImmutableArray y) + { + return x.SequenceEqual(y, _elementComparer); + } + + public int GetHashCode(ImmutableArray obj) + { + throw new UnreachableException(); + } + } + + internal sealed class CustomValueTupleElementComparer : IEqualityComparer<(T, U)> + { + private readonly IEqualityComparer _item1Comparer; + private readonly IEqualityComparer _item2Comparer; + + public CustomValueTupleElementComparer(IEqualityComparer item1Comparer, IEqualityComparer item2Comparer) + { + _item1Comparer = item1Comparer; + _item2Comparer = item2Comparer; + } + + public bool Equals((T, U) x, (T, U) y) + { + return _item1Comparer.Equals(x.Item1, y.Item1) && _item2Comparer.Equals(x.Item2, y.Item2); + } + + public int GetHashCode((T, U) obj) + { + throw new UnreachableException(); + } + } +} diff --git a/src/libraries/System.Runtime.InteropServices/gen/DownlevelLibraryImportGenerator/DiagnosticDescriptorProvider.cs b/src/libraries/System.Runtime.InteropServices/gen/DownlevelLibraryImportGenerator/DiagnosticDescriptorProvider.cs new file mode 100644 index 00000000000..eb9a0237307 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/DownlevelLibraryImportGenerator/DiagnosticDescriptorProvider.cs @@ -0,0 +1,34 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using Microsoft.CodeAnalysis; + +namespace Microsoft.Interop +{ + internal sealed class DiagnosticDescriptorProvider : IDiagnosticDescriptorProvider + { + public DiagnosticDescriptor InvalidMarshallingAttributeInfo => GeneratorDiagnostics.MarshallingAttributeConfigurationNotSupported; + + public DiagnosticDescriptor ConfigurationNotSupported => GeneratorDiagnostics.ConfigurationNotSupported; + + public DiagnosticDescriptor ConfigurationValueNotSupported => GeneratorDiagnostics.ConfigurationValueNotSupported; + + public DiagnosticDescriptor? GetDescriptor(GeneratorDiagnostic diagnostic) + { + return diagnostic switch + { + GeneratorDiagnostic.NotSupported { NotSupportedDetails: null, TypePositionInfo: { IsManagedReturnPosition: true, MarshallingAttributeInfo: MarshalAsInfo } } => GeneratorDiagnostics.MarshalAsReturnConfigurationNotSupported, + GeneratorDiagnostic.NotSupported { NotSupportedDetails: null, TypePositionInfo: { IsManagedReturnPosition: false, MarshallingAttributeInfo: MarshalAsInfo } } => GeneratorDiagnostics.MarshalAsParameterConfigurationNotSupported, + GeneratorDiagnostic.NotSupported { NotSupportedDetails: not null, TypePositionInfo.IsManagedReturnPosition: true } => GeneratorDiagnostics.ReturnTypeNotSupportedWithDetails, + GeneratorDiagnostic.NotSupported { NotSupportedDetails: not null, TypePositionInfo.IsManagedReturnPosition: false } => GeneratorDiagnostics.ParameterTypeNotSupportedWithDetails, + GeneratorDiagnostic.UnnecessaryData { TypePositionInfo.IsManagedReturnPosition: false } => GeneratorDiagnostics.UnnecessaryParameterMarshallingInfo, + GeneratorDiagnostic.UnnecessaryData { TypePositionInfo.IsManagedReturnPosition: true } => GeneratorDiagnostics.UnnecessaryReturnMarshallingInfo, + GeneratorDiagnostic.NotRecommended => GeneratorDiagnostics.LibraryImportUsageDoesNotFollowBestPractices, + { IsFatal: false } => null, + { TypePositionInfo.IsManagedReturnPosition: true } => GeneratorDiagnostics.ReturnTypeNotSupported, + { TypePositionInfo.IsManagedReturnPosition: false } => GeneratorDiagnostics.ParameterTypeNotSupported, + }; + } + } +} diff --git a/src/libraries/System.Runtime.InteropServices/gen/DownlevelLibraryImportGenerator/DownlevelLibraryImportGenerator.cs b/src/libraries/System.Runtime.InteropServices/gen/DownlevelLibraryImportGenerator/DownlevelLibraryImportGenerator.cs new file mode 100644 index 00000000000..b734647bf69 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/DownlevelLibraryImportGenerator/DownlevelLibraryImportGenerator.cs @@ -0,0 +1,438 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Diagnostics; +using System.Linq; +using System.Runtime.InteropServices; +using System.Threading; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Syntax; +using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; + +[assembly: System.Resources.NeutralResourcesLanguage("en-US")] + +namespace Microsoft.Interop +{ + [Generator] + public sealed class DownlevelLibraryImportGenerator : IIncrementalGenerator + { + internal sealed record IncrementalStubGenerationContext( + SignatureContext SignatureContext, + ContainingSyntaxContext ContainingSyntaxContext, + ContainingSyntax StubMethodSyntaxTemplate, + MethodSignatureDiagnosticLocations DiagnosticLocation, + SequenceEqualImmutableArray ForwardedAttributes, + LibraryImportData LibraryImportData, + EnvironmentFlags EnvironmentFlags, + SequenceEqualImmutableArray Diagnostics); + + public static class StepNames + { + public const string CalculateStubInformation = nameof(CalculateStubInformation); + public const string GenerateSingleStub = nameof(GenerateSingleStub); + } + + public void Initialize(IncrementalGeneratorInitializationContext context) + { + // Collect all methods adorned with LibraryImportAttribute + var attributedMethods = context.SyntaxProvider + .ForAttributeWithMetadataName( + TypeNames.LibraryImportAttribute, + static (node, ct) => node is MethodDeclarationSyntax, + static (context, ct) => context.TargetSymbol is IMethodSymbol methodSymbol + ? new { Syntax = (MethodDeclarationSyntax)context.TargetNode, Symbol = methodSymbol } + : null) + .Where( + static modelData => modelData is not null); + + // Validate if attributed methods can have source generated + var methodsWithDiagnostics = attributedMethods.Select(static (data, ct) => + { + DiagnosticInfo? diagnostic = GetDiagnosticIfInvalidMethodForGeneration(data.Syntax, data.Symbol); + return diagnostic is not null + ? DiagnosticOr<(MethodDeclarationSyntax Syntax, IMethodSymbol Symbol)>.From(diagnostic) + : DiagnosticOr<(MethodDeclarationSyntax Syntax, IMethodSymbol Symbol)>.From((data.Syntax, data.Symbol)); + }); + + var methodsToGenerate = context.FilterAndReportDiagnostics(methodsWithDiagnostics); + + IncrementalValueProvider stubEnvironment = context.CreateStubEnvironmentProvider(); + + IncrementalValuesProvider<(MemberDeclarationSyntax, ImmutableArray)> generateSingleStub = methodsToGenerate + .Combine(stubEnvironment) + .Select(static (data, ct) => new + { + data.Left.Syntax, + data.Left.Symbol, + Environment = data.Right, + }) + .Select( + static (data, ct) => CalculateStubInformation(data.Syntax, data.Symbol, data.Environment, ct) + ) + .WithTrackingName(StepNames.CalculateStubInformation) + .Select( + static (data, ct) => GenerateSource(data) + ) + .WithComparer(Comparers.GeneratedSyntax) + .WithTrackingName(StepNames.GenerateSingleStub); + + context.RegisterDiagnostics(generateSingleStub.SelectMany((stubInfo, ct) => stubInfo.Item2)); + + context.RegisterConcatenatedSyntaxOutputs(generateSingleStub.Select((data, ct) => data.Item1), "LibraryImports.g.cs"); + } + + private static List GenerateSyntaxForForwardedAttributes(AttributeData? defaultDllImportSearchPathsAttribute) + { + // Manually rehydrate the forwarded attributes with fully qualified types so we don't have to worry about any using directives. + List attributes = []; + + if (defaultDllImportSearchPathsAttribute is not null) + { + attributes.Add( + Attribute(NameSyntaxes.DefaultDllImportSearchPathsAttribute).AddArgumentListArguments( + AttributeArgument( + CastExpression(TypeSyntaxes.DllImportSearchPath, + LiteralExpression(SyntaxKind.NumericLiteralExpression, + Literal((int)defaultDllImportSearchPathsAttribute.ConstructorArguments[0].Value!)))))); + } + return attributes; + } + + private static SyntaxTokenList StripTriviaFromModifiers(SyntaxTokenList tokenList) + { + SyntaxToken[] strippedTokens = new SyntaxToken[tokenList.Count]; + for (int i = 0; i < tokenList.Count; i++) + { + strippedTokens[i] = tokenList[i].WithoutTrivia(); + } + return new SyntaxTokenList(strippedTokens); + } + + private static MethodDeclarationSyntax PrintGeneratedSource( + ContainingSyntax userDeclaredMethod, + SignatureContext stub, + BlockSyntax stubCode) + { + // Create stub function + return MethodDeclaration(stub.StubReturnType, userDeclaredMethod.Identifier) + .AddAttributeLists(stub.AdditionalAttributes.ToArray()) + .WithModifiers(StripTriviaFromModifiers(userDeclaredMethod.Modifiers)) + .WithParameterList(ParameterList(SeparatedList(stub.StubParameters))) + .WithBody(stubCode); + } + + private static LibraryImportCompilationData? ProcessLibraryImportAttribute(AttributeData attrData) + { + // Found the LibraryImport, but it has an error so report the error. + // This is most likely an issue with targeting an incorrect TFM. + if (attrData.AttributeClass?.TypeKind is null or TypeKind.Error) + { + return null; + } + + if (attrData.ConstructorArguments.Length == 0) + { + return null; + } + + ImmutableDictionary namedArguments = ImmutableDictionary.CreateRange(attrData.NamedArguments); + + string? entryPoint = null; + if (namedArguments.TryGetValue(nameof(LibraryImportCompilationData.EntryPoint), out TypedConstant entryPointValue)) + { + if (entryPointValue.Value is not string) + { + return null; + } + entryPoint = (string)entryPointValue.Value!; + } + + return new LibraryImportCompilationData(attrData.ConstructorArguments[0].Value!.ToString()) + { + EntryPoint = entryPoint, + }.WithValuesFromNamedArguments(namedArguments); + } + + private static IncrementalStubGenerationContext CalculateStubInformation( + MethodDeclarationSyntax originalSyntax, + IMethodSymbol symbol, + StubEnvironment environment, + CancellationToken ct) + { + ct.ThrowIfCancellationRequested(); + INamedTypeSymbol? lcidConversionAttrType = environment.LcidConversionAttrType; + INamedTypeSymbol? defaultDllImportSearchPathsAttrType = environment.DefaultDllImportSearchPathsAttrType; + // Get any attributes of interest on the method + AttributeData? generatedDllImportAttr = null; + AttributeData? lcidConversionAttr = null; + AttributeData? defaultDllImportSearchPathsAttribute = null; + foreach (AttributeData attr in symbol.GetAttributes()) + { + if (attr.AttributeClass is not null + && attr.AttributeClass.ToDisplayString() == TypeNames.LibraryImportAttribute) + { + generatedDllImportAttr = attr; + } + else if (lcidConversionAttrType is not null && SymbolEqualityComparer.Default.Equals(attr.AttributeClass, lcidConversionAttrType)) + { + lcidConversionAttr = attr; + } + else if (defaultDllImportSearchPathsAttrType is not null && SymbolEqualityComparer.Default.Equals(attr.AttributeClass, defaultDllImportSearchPathsAttrType)) + { + defaultDllImportSearchPathsAttribute = attr; + } + } + + Debug.Assert(generatedDllImportAttr is not null); + + var locations = new MethodSignatureDiagnosticLocations(originalSyntax); + var generatorDiagnostics = new GeneratorDiagnosticsBag(new DiagnosticDescriptorProvider(), locations, SR.ResourceManager, typeof(FxResources.Microsoft.Interop.LibraryImportGenerator.Downlevel.SR)); + + // Process the LibraryImport attribute + LibraryImportCompilationData libraryImportData = + ProcessLibraryImportAttribute(generatedDllImportAttr!) ?? + new LibraryImportCompilationData("INVALID_CSHARP_SYNTAX"); + + if (lcidConversionAttr is not null) + { + // Using LCIDConversion with LibraryImport is not supported + generatorDiagnostics.ReportConfigurationNotSupported(lcidConversionAttr, nameof(TypeNames.LCIDConversionAttribute)); + } + + // Create the stub. + var signatureContext = SignatureContext.Create( + symbol, + DownlevelLibraryImportGeneratorHelpers.CreateMarshallingInfoParser(environment, generatorDiagnostics, symbol, libraryImportData), + environment, + new CodeEmitOptions(SkipInit: false), + typeof(DownlevelLibraryImportGenerator).Assembly); + + var containingTypeContext = new ContainingSyntaxContext(originalSyntax); + + var methodSyntaxTemplate = new ContainingSyntax(originalSyntax.Modifiers, SyntaxKind.MethodDeclaration, originalSyntax.Identifier, originalSyntax.TypeParameterList); + + List additionalAttributes = GenerateSyntaxForForwardedAttributes(defaultDllImportSearchPathsAttribute); + return new IncrementalStubGenerationContext( + signatureContext, + containingTypeContext, + methodSyntaxTemplate, + locations, + new SequenceEqualImmutableArray(additionalAttributes.ToImmutableArray(), SyntaxEquivalentComparer.Instance), + LibraryImportData.From(libraryImportData), + environment.EnvironmentFlags, + new SequenceEqualImmutableArray(generatorDiagnostics.Diagnostics.ToImmutableArray()) + ); + } + + private static (MemberDeclarationSyntax, ImmutableArray) GenerateSource( + IncrementalStubGenerationContext pinvokeStub) + { + var diagnostics = new GeneratorDiagnosticsBag(new DiagnosticDescriptorProvider(), pinvokeStub.DiagnosticLocation, SR.ResourceManager, typeof(FxResources.Microsoft.Interop.LibraryImportGenerator.Downlevel.SR)); + + // Generate stub code + var stubGenerator = new ManagedToNativeStubGenerator( + pinvokeStub.SignatureContext.ElementTypeInformation, + pinvokeStub.LibraryImportData.SetLastError, + diagnostics, + DownlevelLibraryImportGeneratorHelpers.GeneratorResolver, + new CodeEmitOptions(SkipInit: false)); + + // Check if the generator should produce a forwarder stub - regular DllImport. + // This is done if the signature is blittable or if some parameters cannot be marshalled. + if (stubGenerator.NoMarshallingRequired + || stubGenerator.HasForwardedTypes + || pinvokeStub.LibraryImportData.SetLastError) + { + return (PrintForwarderStub(pinvokeStub.StubMethodSyntaxTemplate, pinvokeStub, diagnostics), pinvokeStub.Diagnostics.Array.AddRange(diagnostics.Diagnostics)); + } + + ImmutableArray forwardedAttributes = pinvokeStub.ForwardedAttributes.Array; + + const string innerPInvokeName = "__PInvoke"; + + BlockSyntax code = stubGenerator.GenerateStubBody(innerPInvokeName); + + LocalFunctionStatementSyntax dllImport = CreateTargetDllImportAsLocalStatement( + stubGenerator, + pinvokeStub.LibraryImportData, + innerPInvokeName, + pinvokeStub.StubMethodSyntaxTemplate.Identifier.Text); + + if (!forwardedAttributes.IsEmpty) + { + dllImport = dllImport.AddAttributeLists(AttributeList(SeparatedList(forwardedAttributes))); + } + + dllImport = dllImport.WithLeadingTrivia(Comment("// Local P/Invoke")); + code = code.AddStatements(dllImport); + + return (pinvokeStub.ContainingSyntaxContext.WrapMemberInContainingSyntaxWithUnsafeModifier(PrintGeneratedSource(pinvokeStub.StubMethodSyntaxTemplate, pinvokeStub.SignatureContext, code)), pinvokeStub.Diagnostics.Array.AddRange(diagnostics.Diagnostics)); + } + + private static MemberDeclarationSyntax PrintForwarderStub(ContainingSyntax userDeclaredMethod, IncrementalStubGenerationContext stub, GeneratorDiagnosticsBag diagnostics) + { + LibraryImportData pinvokeData = stub.LibraryImportData with { EntryPoint = stub.LibraryImportData.EntryPoint ?? userDeclaredMethod.Identifier.ValueText }; + + if (pinvokeData.IsUserDefined.HasFlag(InteropAttributeMember.StringMarshalling) + && pinvokeData.StringMarshalling != StringMarshalling.Utf16) + { + // Report a diagnostic when a StringMarshalling other than Utf16 is used. + // The other options can't be forwarded for downlevel scenarios. + diagnostics.ReportCannotForwardToDllImport( + stub.DiagnosticLocation, + $"{nameof(TypeNames.LibraryImportAttribute)}{Type.Delimiter}{nameof(StringMarshalling)}", + $"{nameof(StringMarshalling)}{Type.Delimiter}{pinvokeData.StringMarshalling}"); + + pinvokeData = pinvokeData with { IsUserDefined = pinvokeData.IsUserDefined & ~InteropAttributeMember.StringMarshalling }; + } + + SyntaxTokenList modifiers = StripTriviaFromModifiers(userDeclaredMethod.Modifiers); + modifiers = modifiers.AddToModifiers(SyntaxKind.ExternKeyword); + // Create stub function + MethodDeclarationSyntax stubMethod = MethodDeclaration(stub.SignatureContext.StubReturnType, userDeclaredMethod.Identifier) + .WithModifiers(modifiers) + .WithParameterList(ParameterList(SeparatedList(stub.SignatureContext.StubParameters))) + .WithSemicolonToken(Token(SyntaxKind.SemicolonToken)) + .AddModifiers() + .AddAttributeLists( + AttributeList( + SingletonSeparatedList( + CreateForwarderDllImport(pinvokeData)))); + + MemberDeclarationSyntax toPrint = stub.ContainingSyntaxContext.WrapMemberInContainingSyntaxWithUnsafeModifier(stubMethod); + + return toPrint; + } + + private static LocalFunctionStatementSyntax CreateTargetDllImportAsLocalStatement( + ManagedToNativeStubGenerator stubGenerator, + LibraryImportData libraryImportData, + string stubTargetName, + string stubMethodName) + { + (ParameterListSyntax parameterList, TypeSyntax returnType, AttributeListSyntax returnTypeAttributes) = stubGenerator.GenerateTargetMethodSignatureData(); + LocalFunctionStatementSyntax localDllImport = LocalFunctionStatement(returnType, stubTargetName) + .AddModifiers( + Token(SyntaxKind.StaticKeyword), + Token(SyntaxKind.ExternKeyword), + Token(SyntaxKind.UnsafeKeyword)) + .WithSemicolonToken(Token(SyntaxKind.SemicolonToken)) + .WithAttributeLists( + SingletonList(AttributeList( + SingletonSeparatedList( + Attribute( + NameSyntaxes.DllImportAttribute, + AttributeArgumentList( + SeparatedList( + [ + AttributeArgument(LiteralExpression( + SyntaxKind.StringLiteralExpression, + Literal(libraryImportData.ModuleName))), + AttributeArgument( + NameEquals(nameof(DllImportAttribute.EntryPoint)), + null, + LiteralExpression( + SyntaxKind.StringLiteralExpression, + Literal(libraryImportData.EntryPoint ?? stubMethodName))), + AttributeArgument( + NameEquals(nameof(DllImportAttribute.ExactSpelling)), + null, + LiteralExpression(SyntaxKind.TrueLiteralExpression)) + ] + ))))))) + .WithParameterList(parameterList); + if (returnTypeAttributes is not null) + { + localDllImport = localDllImport.AddAttributeLists(returnTypeAttributes.WithTarget(AttributeTargetSpecifier(Token(SyntaxKind.ReturnKeyword)))); + } + return localDllImport; + } + + private static AttributeSyntax CreateForwarderDllImport(LibraryImportData target) + { + var newAttributeArgs = new List + { + AttributeArgument(LiteralExpression( + SyntaxKind.StringLiteralExpression, + Literal(target.ModuleName))), + AttributeArgument( + NameEquals(nameof(DllImportAttribute.EntryPoint)), + null, + CreateStringExpressionSyntax(target.EntryPoint)), + AttributeArgument( + NameEquals(nameof(DllImportAttribute.ExactSpelling)), + null, + LiteralExpression(SyntaxKind.TrueLiteralExpression)) + }; + + if (target.IsUserDefined.HasFlag(InteropAttributeMember.StringMarshalling)) + { + Debug.Assert(target.StringMarshalling == StringMarshalling.Utf16); + NameEqualsSyntax name = NameEquals(nameof(DllImportAttribute.CharSet)); + ExpressionSyntax value = MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + ParseTypeName(typeof(CharSet).FullName), + IdentifierName(nameof(CharSet.Unicode))); + newAttributeArgs.Add(AttributeArgument(name, null, value)); + } + + if (target.IsUserDefined.HasFlag(InteropAttributeMember.SetLastError)) + { + NameEqualsSyntax name = NameEquals(nameof(DllImportAttribute.SetLastError)); + ExpressionSyntax value = CreateBoolExpressionSyntax(target.SetLastError); + newAttributeArgs.Add(AttributeArgument(name, null, value)); + } + + // Create new attribute + return Attribute( + NameSyntaxes.DllImportAttribute, + AttributeArgumentList(SeparatedList(newAttributeArgs))); + + static ExpressionSyntax CreateBoolExpressionSyntax(bool trueOrFalse) + { + return LiteralExpression( + trueOrFalse + ? SyntaxKind.TrueLiteralExpression + : SyntaxKind.FalseLiteralExpression); + } + + static ExpressionSyntax CreateStringExpressionSyntax(string str) + { + return LiteralExpression( + SyntaxKind.StringLiteralExpression, + Literal(str)); + } + } + + private static DiagnosticInfo? GetDiagnosticIfInvalidMethodForGeneration(MethodDeclarationSyntax methodSyntax, IMethodSymbol method) + { + // Verify the method has no generic types or defined implementation + // and is marked static and partial. + if (methodSyntax.TypeParameterList is not null + || methodSyntax.Body is not null + || !methodSyntax.Modifiers.Any(SyntaxKind.StaticKeyword) + || !methodSyntax.Modifiers.Any(SyntaxKind.PartialKeyword)) + { + return DiagnosticInfo.Create(GeneratorDiagnostics.InvalidAttributedMethodSignature, methodSyntax.Identifier.GetLocation(), method.Name); + } + + // Verify that the types the method is declared in are marked partial. + if (methodSyntax.Parent is TypeDeclarationSyntax typeDecl && !typeDecl.IsInPartialContext(out var nonPartialIdentifier)) + { + return DiagnosticInfo.Create(GeneratorDiagnostics.InvalidAttributedMethodContainingTypeMissingModifiers, methodSyntax.Identifier.GetLocation(), method.Name, nonPartialIdentifier); + } + + // Verify the method does not have a ref return + if (method.ReturnsByRef || method.ReturnsByRefReadonly) + { + return DiagnosticInfo.Create(GeneratorDiagnostics.ReturnConfigurationNotSupported, methodSyntax.Identifier.GetLocation(), "ref return", method.ToDisplayString()); + } + + return null; + } + } +} diff --git a/src/libraries/System.Runtime.InteropServices/gen/DownlevelLibraryImportGenerator/DownlevelLibraryImportGenerator.csproj b/src/libraries/System.Runtime.InteropServices/gen/DownlevelLibraryImportGenerator/DownlevelLibraryImportGenerator.csproj new file mode 100644 index 00000000000..892d285d0e3 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/DownlevelLibraryImportGenerator/DownlevelLibraryImportGenerator.csproj @@ -0,0 +1,33 @@ + + + + Microsoft.Interop.LibraryImportGenerator.Downlevel + netstandard2.0 + true + Microsoft.Interop + true + + $(NoWarn);RS2008;RS1038 + cs + ../Common/Resources/Strings.resx + + + + + + + + + + + + + + + + + + + + diff --git a/src/libraries/System.Runtime.InteropServices/gen/DownlevelLibraryImportGenerator/DownlevelLibraryImportGeneratorHelpers.cs b/src/libraries/System.Runtime.InteropServices/gen/DownlevelLibraryImportGenerator/DownlevelLibraryImportGeneratorHelpers.cs new file mode 100644 index 00000000000..3ae03a53e6c --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/DownlevelLibraryImportGenerator/DownlevelLibraryImportGeneratorHelpers.cs @@ -0,0 +1,57 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Collections.Generic; +using System.Collections.Immutable; +using Microsoft.CodeAnalysis; + +namespace Microsoft.Interop +{ + internal static class DownlevelLibraryImportGeneratorHelpers + { + public static MarshallingInfoParser CreateMarshallingInfoParser(StubEnvironment env, GeneratorDiagnosticsBag diagnostics, IMethodSymbol method, InteropAttributeCompilationData interopAttributeData) + { + // Compute the current default string encoding value. + CharEncoding defaultEncoding = CharEncoding.Undefined; + if (interopAttributeData.IsUserDefined.HasFlag(InteropAttributeMember.StringMarshalling)) + { + defaultEncoding = interopAttributeData.StringMarshalling switch + { + StringMarshalling.Utf16 => CharEncoding.Utf16, + StringMarshalling.Utf8 => CharEncoding.Utf8, + StringMarshalling.Custom => CharEncoding.Custom, + _ => CharEncoding.Undefined, // [Compat] Do not assume a specific value + }; + } + else if (interopAttributeData.IsUserDefined.HasFlag(InteropAttributeMember.StringMarshallingCustomType)) + { + defaultEncoding = CharEncoding.Custom; + } + + var defaultInfo = new DefaultMarshallingInfo(defaultEncoding, interopAttributeData.StringMarshallingCustomType); + + var useSiteAttributeParsers = ImmutableArray.Create( + new MarshalAsAttributeParser(diagnostics, defaultInfo)); + + return new MarshallingInfoParser( + diagnostics, + new MethodSignatureElementInfoProvider(env.Compilation, diagnostics, method, useSiteAttributeParsers), + useSiteAttributeParsers, + ImmutableArray.Create(new MarshalAsAttributeParser(diagnostics, defaultInfo)), + ImmutableArray.Create( + new DownlevelStringMarshallingInfoProvider(defaultInfo), + new CharMarshallingInfoProvider(defaultInfo), + new BooleanMarshallingInfoProvider(), + new BlittableTypeMarshallingInfoProvider(env.Compilation))); + } + + public static IMarshallingGeneratorResolver GeneratorResolver { get; } = new ByValueContentsMarshalKindValidator(new CompositeMarshallingGeneratorResolver( + [ + new BlittableMarshallerResolver(runtimeMarshallingDisabled: false), + new MarshalAsMarshallingGeneratorResolver(new InteropGenerationOptions(UseMarshalType: true)), + new NoMarshallingInfoErrorResolver(TypeNames.LibraryImportAttribute_ShortName), + new CharMarshallingGeneratorResolver(useBlittableMarshallerForUtf16: false, TypeNames.LibraryImportAttribute_ShortName), + new ForwarderResolver() + ])); + } +} diff --git a/src/libraries/System.Runtime.InteropServices/gen/DownlevelLibraryImportGenerator/DownlevelStringMarshallingInfoProvider.cs b/src/libraries/System.Runtime.InteropServices/gen/DownlevelLibraryImportGenerator/DownlevelStringMarshallingInfoProvider.cs new file mode 100644 index 00000000000..23df949b804 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/DownlevelLibraryImportGenerator/DownlevelStringMarshallingInfoProvider.cs @@ -0,0 +1,35 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Generic; +using System.Text; +using Microsoft.CodeAnalysis; + +namespace Microsoft.Interop +{ + /// + /// Marshalling information provider for string elements without any marshalling information on the element itself. + /// + /// + /// Provides only enough marshalling information to specify the encoding that the user requested. + /// + internal sealed class DownlevelStringMarshallingInfoProvider : ITypeBasedMarshallingInfoProvider + { + private readonly DefaultMarshallingInfo _defaultMarshallingInfo; + + public DownlevelStringMarshallingInfoProvider(DefaultMarshallingInfo defaultMarshallingInfo) + { + _defaultMarshallingInfo = defaultMarshallingInfo; + } + + public bool CanProvideMarshallingInfoForType(ITypeSymbol type) => type.SpecialType == SpecialType.System_String; + + public MarshallingInfo GetMarshallingInfo(ITypeSymbol type, int indirectionDepth, UseSiteAttributeProvider useSiteAttributes, GetMarshallingInfoCallback marshallingInfoCallback) + { + // No marshalling info was computed, but a character encoding was provided. + // If the type is a character then pass on these details. + return _defaultMarshallingInfo.CharEncoding == CharEncoding.Undefined ? NoMarshallingInfo.Instance : new MarshallingInfoStringSupport(_defaultMarshallingInfo.CharEncoding); + } + } +} diff --git a/src/libraries/System.Runtime.InteropServices/gen/DownlevelLibraryImportGenerator/ForwarderResolver.cs b/src/libraries/System.Runtime.InteropServices/gen/DownlevelLibraryImportGenerator/ForwarderResolver.cs new file mode 100644 index 00000000000..6b7a68fc19e --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/DownlevelLibraryImportGenerator/ForwarderResolver.cs @@ -0,0 +1,16 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Generic; +using System.Text; + +namespace Microsoft.Interop +{ + internal sealed class ForwarderResolver : IMarshallingGeneratorResolver + { + private static readonly Forwarder s_forwarder = new Forwarder(); + + public ResolvedGenerator Create(TypePositionInfo info, StubCodeContext context) => ResolvedGenerator.Resolved(s_forwarder.Bind(info, context)); + } +} diff --git a/src/libraries/System.Runtime.InteropServices/gen/DownlevelLibraryImportGenerator/GeneratorDiagnostics.cs b/src/libraries/System.Runtime.InteropServices/gen/DownlevelLibraryImportGenerator/GeneratorDiagnostics.cs new file mode 100644 index 00000000000..2e8223fa86b --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/DownlevelLibraryImportGenerator/GeneratorDiagnostics.cs @@ -0,0 +1,306 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.DotnetRuntime.Extensions; + +namespace Microsoft.Interop +{ + /// + /// Class for reporting diagnostics in the library import generator + /// + internal static class GeneratorDiagnostics + { + public static class Ids + { + // SYSLIB1050-SYSLIB1069 are reserved for LibraryImportGenerator + public const string Prefix = "SYSLIB"; + public const string InvalidLibraryImportAttributeUsage = Prefix + "1050"; + public const string TypeNotSupported = Prefix + "1051"; + public const string ConfigurationNotSupported = Prefix + "1052"; + public const string CannotForwardToDllImport = Prefix + "1053"; + + public const string RequiresAllowUnsafeBlocks = Prefix + "1062"; + public const string UnnecessaryMarshallingInfo = Prefix + "1063"; + public const string NotRecommendedGeneratedComInterfaceUsage = Prefix + "1092"; + } + + private const string Category = "LibraryImportGenerator"; + + /// + public static readonly DiagnosticDescriptor InvalidAttributedMethodSignature = + DiagnosticDescriptorHelper.Create( + Ids.InvalidLibraryImportAttributeUsage, + GetResourceString(nameof(SR.InvalidLibraryImportAttributeUsageTitle)), + GetResourceString(nameof(SR.InvalidAttributedMethodSignatureMessageLibraryImport)), + Category, + DiagnosticSeverity.Error, + isEnabledByDefault: true, + description: GetResourceString(nameof(SR.InvalidAttributedMethodDescriptionLibraryImport))); + + /// + public static readonly DiagnosticDescriptor InvalidAttributedMethodContainingTypeMissingModifiers = + DiagnosticDescriptorHelper.Create( + Ids.InvalidLibraryImportAttributeUsage, + GetResourceString(nameof(SR.InvalidLibraryImportAttributeUsageTitle)), + GetResourceString(nameof(SR.InvalidAttributedMethodContainingTypeMissingModifiersMessageLibraryImport)), + Category, + DiagnosticSeverity.Error, + isEnabledByDefault: true, + description: GetResourceString(nameof(SR.InvalidAttributedMethodDescriptionLibraryImport))); + + /// + public static readonly DiagnosticDescriptor InvalidStringMarshallingConfiguration = + DiagnosticDescriptorHelper.Create( + Ids.InvalidLibraryImportAttributeUsage, + GetResourceString(nameof(SR.InvalidLibraryImportAttributeUsageTitle)), + GetResourceString(nameof(SR.InvalidStringMarshallingConfigurationMessageLibraryImport)), + Category, + DiagnosticSeverity.Error, + isEnabledByDefault: true, + description: GetResourceString(nameof(SR.InvalidStringMarshallingConfigurationDescription))); + + /// + public static readonly DiagnosticDescriptor ParameterTypeNotSupported = + DiagnosticDescriptorHelper.Create( + Ids.TypeNotSupported, + GetResourceString(nameof(SR.TypeNotSupportedTitle)), + GetResourceString(nameof(SR.TypeNotSupportedMessageParameterLibraryImport)), + Category, + DiagnosticSeverity.Error, + isEnabledByDefault: true, + description: GetResourceString(nameof(SR.TypeNotSupportedDescriptionLibraryImport))); + + /// + public static readonly DiagnosticDescriptor ReturnTypeNotSupported = + DiagnosticDescriptorHelper.Create( + Ids.TypeNotSupported, + GetResourceString(nameof(SR.TypeNotSupportedTitle)), + GetResourceString(nameof(SR.TypeNotSupportedMessageReturnLibraryImport)), + Category, + DiagnosticSeverity.Error, + isEnabledByDefault: true, + description: GetResourceString(nameof(SR.TypeNotSupportedDescriptionLibraryImport))); + + /// + public static readonly DiagnosticDescriptor ParameterTypeNotSupportedWithDetails = + DiagnosticDescriptorHelper.Create( + Ids.TypeNotSupported, + GetResourceString(nameof(SR.TypeNotSupportedTitle)), + GetResourceString(nameof(SR.TypeNotSupportedMessageParameterWithDetails)), + Category, + DiagnosticSeverity.Error, + isEnabledByDefault: true, + description: GetResourceString(nameof(SR.TypeNotSupportedDescriptionLibraryImport))); + + /// + public static readonly DiagnosticDescriptor ReturnTypeNotSupportedWithDetails = + DiagnosticDescriptorHelper.Create( + Ids.TypeNotSupported, + GetResourceString(nameof(SR.TypeNotSupportedTitle)), + GetResourceString(nameof(SR.TypeNotSupportedMessageReturnWithDetails)), + Category, + DiagnosticSeverity.Error, + isEnabledByDefault: true, + description: GetResourceString(nameof(SR.TypeNotSupportedDescriptionLibraryImport))); + + /// + public static readonly DiagnosticDescriptor ParameterConfigurationNotSupported = + DiagnosticDescriptorHelper.Create( + Ids.ConfigurationNotSupported, + GetResourceString(nameof(SR.ConfigurationNotSupportedTitleLibraryImport)), + GetResourceString(nameof(SR.ConfigurationNotSupportedMessageParameterLibraryImport)), + Category, + DiagnosticSeverity.Error, + isEnabledByDefault: true, + description: GetResourceString(nameof(SR.ConfigurationNotSupportedDescriptionLibraryImport))); + + /// + public static readonly DiagnosticDescriptor ReturnConfigurationNotSupported = + DiagnosticDescriptorHelper.Create( + Ids.ConfigurationNotSupported, + GetResourceString(nameof(SR.ConfigurationNotSupportedTitleLibraryImport)), + GetResourceString(nameof(SR.ConfigurationNotSupportedMessageReturnLibraryImport)), + Category, + DiagnosticSeverity.Error, + isEnabledByDefault: true, + description: GetResourceString(nameof(SR.ConfigurationNotSupportedDescriptionLibraryImport))); + + /// + public static readonly DiagnosticDescriptor MarshalAsParameterConfigurationNotSupported = + DiagnosticDescriptorHelper.Create( + GeneratorDiagnostics.Ids.ConfigurationNotSupported, + GetResourceString(nameof(SR.ConfigurationNotSupportedTitleLibraryImport)), + GetResourceString(nameof(SR.MarshalAsConfigurationNotSupportedMessageParameterLibraryImport)), + Category, + DiagnosticSeverity.Error, + isEnabledByDefault: true, + description: GetResourceString(nameof(SR.ConfigurationNotSupportedDescriptionLibraryImport))); + + /// + public static readonly DiagnosticDescriptor MarshalAsReturnConfigurationNotSupported = + DiagnosticDescriptorHelper.Create( + GeneratorDiagnostics.Ids.ConfigurationNotSupported, + GetResourceString(nameof(SR.ConfigurationNotSupportedTitleLibraryImport)), + GetResourceString(nameof(SR.MarshalAsConfigurationNotSupportedMessageReturnLibraryImport)), + Category, + DiagnosticSeverity.Error, + isEnabledByDefault: true, + description: GetResourceString(nameof(SR.ConfigurationNotSupportedDescriptionLibraryImport))); + + /// + public static readonly DiagnosticDescriptor ConfigurationNotSupported = + DiagnosticDescriptorHelper.Create( + Ids.ConfigurationNotSupported, + GetResourceString(nameof(SR.ConfigurationNotSupportedTitleLibraryImport)), + GetResourceString(nameof(SR.ConfigurationNotSupportedMessageLibraryImport)), + Category, + DiagnosticSeverity.Error, + isEnabledByDefault: true, + description: GetResourceString(nameof(SR.ConfigurationNotSupportedDescriptionLibraryImport))); + + /// + public static readonly DiagnosticDescriptor ConfigurationValueNotSupported = + DiagnosticDescriptorHelper.Create( + Ids.ConfigurationNotSupported, + GetResourceString(nameof(SR.ConfigurationNotSupportedTitleLibraryImport)), + GetResourceString(nameof(SR.ConfigurationNotSupportedMessageValueLibraryImport)), + Category, + DiagnosticSeverity.Error, + isEnabledByDefault: true, + description: GetResourceString(nameof(SR.ConfigurationNotSupportedDescriptionLibraryImport))); + + /// + public static readonly DiagnosticDescriptor MarshallingAttributeConfigurationNotSupported = + DiagnosticDescriptorHelper.Create( + Ids.ConfigurationNotSupported, + GetResourceString(nameof(SR.ConfigurationNotSupportedTitleLibraryImport)), + GetResourceString(nameof(SR.ConfigurationNotSupportedMessageMarshallingInfoLibraryImport)), + Category, + DiagnosticSeverity.Error, + isEnabledByDefault: true, + description: GetResourceString(nameof(SR.ConfigurationNotSupportedDescriptionLibraryImport))); + + /// + public static readonly DiagnosticDescriptor CannotForwardToDllImport = + DiagnosticDescriptorHelper.Create( + Ids.CannotForwardToDllImport, + GetResourceString(nameof(SR.CannotForwardToDllImportTitle)), + GetResourceString(nameof(SR.CannotForwardToDllImportMessage)), + Category, + DiagnosticSeverity.Error, + isEnabledByDefault: true, + description: GetResourceString(nameof(SR.CannotForwardToDllImportDescription))); + + /// + public static readonly DiagnosticDescriptor RequiresAllowUnsafeBlocks = + DiagnosticDescriptorHelper.Create( + Ids.RequiresAllowUnsafeBlocks, + GetResourceString(nameof(SR.RequiresAllowUnsafeBlocksTitleLibraryImport)), + GetResourceString(nameof(SR.RequiresAllowUnsafeBlocksMessageLibraryImport)), + Category, + DiagnosticSeverity.Error, + isEnabledByDefault: true, + description: GetResourceString(nameof(SR.RequiresAllowUnsafeBlocksDescriptionLibraryImport))); + + /// + public static readonly DiagnosticDescriptor UnnecessaryParameterMarshallingInfo = + DiagnosticDescriptorHelper.Create( + Ids.UnnecessaryMarshallingInfo, + GetResourceString(nameof(SR.UnnecessaryMarshallingInfoTitle)), + GetResourceString(nameof(SR.UnnecessaryParameterMarshallingInfoMessage)), + Category, + DiagnosticSeverity.Info, + isEnabledByDefault: true, + description: GetResourceString(nameof(SR.UnnecessaryMarshallingInfoDescription)), + customTags: new[] + { + WellKnownDiagnosticTags.Unnecessary + }); + + /// + public static readonly DiagnosticDescriptor UnnecessaryReturnMarshallingInfo = + DiagnosticDescriptorHelper.Create( + Ids.UnnecessaryMarshallingInfo, + GetResourceString(nameof(SR.UnnecessaryMarshallingInfoTitle)), + GetResourceString(nameof(SR.UnnecessaryReturnMarshallingInfoMessage)), + Category, + DiagnosticSeverity.Info, + isEnabledByDefault: true, + description: GetResourceString(nameof(SR.UnnecessaryMarshallingInfoDescription)), + customTags: new[] + { + WellKnownDiagnosticTags.Unnecessary + }); + + /// + public static readonly DiagnosticDescriptor SizeOfInCollectionMustBeDefinedAtCallOutParam = + DiagnosticDescriptorHelper.Create( + Ids.InvalidLibraryImportAttributeUsage, + GetResourceString(nameof(SR.SizeOfCollectionMustBeKnownAtMarshalTimeTitle)), + GetResourceString(nameof(SR.SizeOfCollectionMustBeKnownAtMarshalTimeMessageOutParam)), + Category, + DiagnosticSeverity.Warning, + isEnabledByDefault: true); + + /// + public static readonly DiagnosticDescriptor SizeOfInCollectionMustBeDefinedAtCallReturnValue = + DiagnosticDescriptorHelper.Create( + Ids.InvalidLibraryImportAttributeUsage, + GetResourceString(nameof(SR.SizeOfCollectionMustBeKnownAtMarshalTimeTitle)), + GetResourceString(nameof(SR.SizeOfCollectionMustBeKnownAtMarshalTimeMessageReturnValue)), + Category, + DiagnosticSeverity.Warning, + isEnabledByDefault: true); + + /// + public static readonly DiagnosticDescriptor LibraryImportUsageDoesNotFollowBestPractices = + new DiagnosticDescriptor( + Ids.NotRecommendedGeneratedComInterfaceUsage, + GetResourceString(nameof(SR.LibraryImportUsageDoesNotFollowBestPracticesTitle)), + GetResourceString(nameof(SR.LibraryImportUsageDoesNotFollowBestPracticesMessageWithDetails)), + Category, + DiagnosticSeverity.Info, + isEnabledByDefault: true); + + /// + /// Report diagnostic for invalid configuration for string marshalling. + /// + /// Attribute specifying the invalid configuration + /// Name of the method + /// Specific reason the configuration is invalid + public static void ReportInvalidStringMarshallingConfiguration( + this GeneratorDiagnosticsBag diagnostics, + AttributeData attributeData, + string methodName, + string detailsMessage) + { + diagnostics.ReportDiagnostic( + attributeData.CreateDiagnosticInfo( + GeneratorDiagnostics.InvalidStringMarshallingConfiguration, + methodName, + detailsMessage)); + } + + /// + /// Report diagnostic for configuration that cannot be forwarded to + /// + /// Method with the configuration that cannot be forwarded + /// Configuration name + /// Configuration value + public static void ReportCannotForwardToDllImport(this GeneratorDiagnosticsBag diagnostics, MethodSignatureDiagnosticLocations method, string name, string? value = null) + { + diagnostics.ReportDiagnostic( + DiagnosticInfo.Create( + CannotForwardToDllImport, + method.FallbackLocation, + value is null ? name : $"{name}={value}")); + } + + private static LocalizableResourceString GetResourceString(string resourceName) + { + return new LocalizableResourceString(resourceName, SR.ResourceManager, typeof(FxResources.Microsoft.Interop.LibraryImportGenerator.Downlevel.SR)); + } + } +} diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/ConvertToLibraryImportAnalyzer.cs b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/ConvertToLibraryImportAnalyzer.cs index 609cdf26746..9d0d19bab2b 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/ConvertToLibraryImportAnalyzer.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Analyzers/ConvertToLibraryImportAnalyzer.cs @@ -36,12 +36,12 @@ public class ConvertToLibraryImportAnalyzer : DiagnosticAnalyzer public const string ExactSpelling = nameof(ExactSpelling); public const string MayRequireAdditionalWork = nameof(MayRequireAdditionalWork); - private static readonly HashSet s_unsupportedTypeNames = new() - { + private static readonly HashSet s_unsupportedTypeNames = + [ "global::System.Runtime.InteropServices.CriticalHandle", "global::System.Runtime.InteropServices.HandleRef", "global::System.Text.StringBuilder" - }; + ]; public override void Initialize(AnalysisContext context) { @@ -56,17 +56,15 @@ public override void Initialize(AnalysisContext context) if (libraryImportAttrType == null) return; - TargetFrameworkSettings targetFramework = context.Options.AnalyzerConfigOptionsProvider.GlobalOptions.GetTargetFrameworkSettings(); - StubEnvironment env = new StubEnvironment( context.Compilation, context.Compilation.GetEnvironmentFlags()); - context.RegisterSymbolAction(symbolContext => AnalyzeSymbol(symbolContext, libraryImportAttrType, env, targetFramework), SymbolKind.Method); + context.RegisterSymbolAction(symbolContext => AnalyzeSymbol(symbolContext, libraryImportAttrType, env), SymbolKind.Method); }); } - private static void AnalyzeSymbol(SymbolAnalysisContext context, INamedTypeSymbol libraryImportAttrType, StubEnvironment env, TargetFrameworkSettings tf) + private static void AnalyzeSymbol(SymbolAnalysisContext context, INamedTypeSymbol libraryImportAttrType, StubEnvironment env) { var method = (IMethodSymbol)context.Symbol; @@ -75,22 +73,47 @@ private static void AnalyzeSymbol(SymbolAnalysisContext context, INamedTypeSymbo if (dllImportData == null) return; + var options = new LibraryImportGeneratorOptions(context.Options.AnalyzerConfigOptionsProvider.GlobalOptions); + + if (!IsEligibleDllImport(method, dllImportData, libraryImportAttrType, env, options, out bool mayRequireAdditionalWork)) + { + return; + } + + ImmutableDictionary.Builder properties = ImmutableDictionary.CreateBuilder(); + + properties.Add(CharSet, dllImportData.CharacterSet.ToString()); + properties.Add(ExactSpelling, dllImportData.ExactSpelling.ToString()); + properties.Add(MayRequireAdditionalWork, mayRequireAdditionalWork.ToString()); + + context.ReportDiagnostic(method.CreateDiagnosticInfo(ConvertToLibraryImport, properties.ToImmutable(), method.Name).ToDiagnostic()); + } + + private static bool IsEligibleDllImport( + IMethodSymbol method, + DllImportData dllImportData, + INamedTypeSymbol libraryImportAttrType, + StubEnvironment env, + LibraryImportGeneratorOptions options, + out bool mayRequireAdditionalWork) + { + mayRequireAdditionalWork = false; if (dllImportData.ThrowOnUnmappableCharacter == true) { // LibraryImportGenerator doesn't support ThrowOnUnmappableCharacter = true - return; + return false; } // LibraryImportGenerator doesn't support BestFitMapping = true if (IsBestFitMapping(method, dllImportData)) { - return; + return false; } if (method.IsVararg) { // LibraryImportGenerator doesn't support varargs - return; + return false; } // Ignore methods already marked LibraryImport @@ -99,13 +122,18 @@ private static void AnalyzeSymbol(SymbolAnalysisContext context, INamedTypeSymbo { if (SymbolEqualityComparer.Default.Equals(attr.AttributeClass, libraryImportAttrType)) { - return; + return false; } } // Ignore methods with unsupported returns if (method.ReturnsByRef || method.ReturnsByRefReadonly) - return; + return false; + + if (options.GenerateForwarders) + { + return true; + } // Use the DllImport attribute data and the method signature to do some of the work the generator will do after conversion. // If any diagnostics or failures to marshal are reported, then mark this diagnostic with a property signifying that it may require @@ -114,51 +142,38 @@ private static void AnalyzeSymbol(SymbolAnalysisContext context, INamedTypeSymbo AttributeData dllImportAttribute = method.GetAttributes().First(attr => attr.AttributeClass.ToDisplayString() == TypeNames.DllImportAttribute); SignatureContext targetSignatureContext = SignatureContext.Create( method, - LibraryImportGeneratorHelpers.CreateMarshallingInfoParser(env, tf, diagnostics, method, CreateInteropAttributeDataFromDllImport(dllImportData), dllImportAttribute), + DefaultMarshallingInfoParser.Create(env, diagnostics, method, CreateInteropAttributeDataFromDllImport(dllImportData), dllImportAttribute), env, - new CodeEmitOptions(SkipInit: tf.TargetFramework == TargetFramework.Net), + new CodeEmitOptions(SkipInit: true), typeof(ConvertToLibraryImportAnalyzer).Assembly); - var factory = LibraryImportGeneratorHelpers.CreateGeneratorResolver(tf, new LibraryImportGeneratorOptions(context.Options.AnalyzerConfigOptionsProvider.GlobalOptions), env.EnvironmentFlags); + var factory = DefaultMarshallingGeneratorResolver.Create(env.EnvironmentFlags, MarshalDirection.ManagedToUnmanaged, TypeNames.LibraryImportAttribute_ShortName, []); - bool mayRequireAdditionalWork = diagnostics.Diagnostics.Any(); + mayRequireAdditionalWork = diagnostics.Diagnostics.Any(); bool anyExplicitlyUnsupportedInfo = false; - var stubCodeContext = new ManagedToNativeStubCodeContext("return", "nativeReturn"); - var forwarder = new Forwarder(); // We don't actually need the bound generators. We just need them to be attempted to be bound to determine if the generator will be able to bind them. - BoundGenerators generators = BoundGenerators.Create(targetSignatureContext.ElementTypeInformation, new CallbackGeneratorResolver((info, context) => + _ = BoundGenerators.Create(targetSignatureContext.ElementTypeInformation, new CallbackGeneratorResolver((info, context) => { if (s_unsupportedTypeNames.Contains(info.ManagedType.FullTypeName)) { anyExplicitlyUnsupportedInfo = true; - return ResolvedGenerator.Resolved(forwarder); + return ResolvedGenerator.Resolved(forwarder.Bind(info, context)); } if (HasUnsupportedMarshalAsInfo(info)) { anyExplicitlyUnsupportedInfo = true; - return ResolvedGenerator.Resolved(forwarder); + return ResolvedGenerator.Resolved(forwarder.Bind(info, context)); } - return factory.Create(info, stubCodeContext); - }), stubCodeContext, forwarder, out var bindingFailures); + return factory.Create(info, context); + }), StubCodeContext.DefaultManagedToNativeStub, forwarder, out var bindingFailures); mayRequireAdditionalWork |= bindingFailures.Any(d => d.IsFatal); - if (anyExplicitlyUnsupportedInfo) - { - // If we have any parameters/return value with an explicitly unsupported marshal type or marshalling info, - // don't offer the fix. The amount of work for the user to get to pairity would be too expensive. - return; - } - - ImmutableDictionary.Builder properties = ImmutableDictionary.CreateBuilder(); - - properties.Add(CharSet, dllImportData.CharacterSet.ToString()); - properties.Add(ExactSpelling, dllImportData.ExactSpelling.ToString()); - properties.Add(MayRequireAdditionalWork, mayRequireAdditionalWork.ToString()); - - context.ReportDiagnostic(method.CreateDiagnosticInfo(ConvertToLibraryImport, properties.ToImmutable(), method.Name).ToDiagnostic()); + // If we have any parameters/return value with an explicitly unsupported marshal type or marshalling info, + // don't offer the fix. The amount of work for the user to get to parity would be too expensive. + return !anyExplicitlyUnsupportedInfo; } private static bool IsBestFitMapping(IMethodSymbol method, DllImportData? dllImportData) @@ -212,16 +227,9 @@ private static InteropAttributeCompilationData CreateInteropAttributeDataFromDll return interopData; } - private sealed class CallbackGeneratorResolver : IMarshallingGeneratorResolver + private sealed class CallbackGeneratorResolver(Func func) : IMarshallingGeneratorResolver { - private readonly Func _func; - - public CallbackGeneratorResolver(Func func) - { - _func = func; - } - - public ResolvedGenerator Create(TypePositionInfo info, StubCodeContext context) => _func(info, context); + public ResolvedGenerator Create(TypePositionInfo info, StubCodeContext context) => func(info, context); } } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Diagnostics/Events.cs b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Diagnostics/Events.cs deleted file mode 100644 index ccb049b1b57..00000000000 --- a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Diagnostics/Events.cs +++ /dev/null @@ -1,66 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System; -using System.Diagnostics.Tracing; - -namespace Microsoft.Interop.Diagnostics -{ - [EventSource(Name = "Microsoft-Interop-SourceGeneration-Events")] - internal sealed class Events : EventSource - { - public static class Keywords - { - public const EventKeywords SourceGeneration = (EventKeywords)1; - } - - public static readonly Events Logger = new Events(); - - private const int StartSourceGenerationEventId = 1; - private const int StopSourceGenerationEventId = StartSourceGenerationEventId + 1; - - private Events() - { } - - /// - /// Utility function that wraps emitting start/stop events for the source generation event. - /// - /// The number of methods being generated - /// An instance that will fire the "stop" event when Disposed. - [NonEvent] - public static IDisposable SourceGenerationStartStop(int methodCount) - { - return new StartStopEvent(methodCount); - } - - // N.B. The 'Start' and 'Stop' suffixes for event names (i.e. "xxxStart" and "xxxStop") - // have special meaning in EventSource. They enable creating 'activities' if they are - // paired and the Stop event's ID is +1 the Start event's ID. - // See https://blogs.msdn.microsoft.com/vancem/2015/09/14/exploring-eventsource-activity-correlation-and-causation-features/ - - /// - /// Indicates the interop's DllImport Roslyn Source Generator has started source generation. - /// - /// The number of methods being generated - [Event(StartSourceGenerationEventId, Level = EventLevel.Informational, Keywords = Keywords.SourceGeneration)] - public void SourceGenerationStart(int methodCount) - { - WriteEvent(StartSourceGenerationEventId, methodCount); - } - - /// - /// Indicates the interop's DllImport Roslyn Source Generator has stopped source generation. - /// - [Event(StopSourceGenerationEventId, Level = EventLevel.Informational, Keywords = Keywords.SourceGeneration)] - public void SourceGenerationStop() - { - WriteEvent(StopSourceGenerationEventId); - } - - private sealed class StartStopEvent : IDisposable - { - public StartStopEvent(int methodCount) => Logger.SourceGenerationStart(methodCount); - public void Dispose() => Logger.SourceGenerationStop(); - } - } -} diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/ForwarderResolver.cs b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/ForwarderResolver.cs index 5570372bd31..6b7a68fc19e 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/ForwarderResolver.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/ForwarderResolver.cs @@ -11,6 +11,6 @@ internal sealed class ForwarderResolver : IMarshallingGeneratorResolver { private static readonly Forwarder s_forwarder = new Forwarder(); - public ResolvedGenerator Create(TypePositionInfo info, StubCodeContext context) => ResolvedGenerator.Resolved(s_forwarder); + public ResolvedGenerator Create(TypePositionInfo info, StubCodeContext context) => ResolvedGenerator.Resolved(s_forwarder.Bind(info, context)); } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LanguageSupport.cs b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LanguageSupport.cs deleted file mode 100644 index 42c8acfd4ab..00000000000 --- a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LanguageSupport.cs +++ /dev/null @@ -1,12 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -// Types defined to enable language support of various features -// in the source generator. -namespace System.Runtime.CompilerServices -{ - // Define IsExternalInit type to support records. - internal sealed class IsExternalInit - { - } -} diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.cs b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.cs index 0c85cda3cba..b4bf0941bdc 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.cs @@ -27,7 +27,6 @@ internal sealed record IncrementalStubGenerationContext( MethodSignatureDiagnosticLocations DiagnosticLocation, SequenceEqualImmutableArray ForwardedAttributes, LibraryImportData LibraryImportData, - TargetFrameworkSettings TargetFramework, LibraryImportGeneratorOptions Options, EnvironmentFlags EnvironmentFlags, SequenceEqualImmutableArray Diagnostics); @@ -66,15 +65,17 @@ public void Initialize(IncrementalGeneratorInitializationContext context) IncrementalValueProvider stubOptions = context.AnalyzerConfigOptionsProvider .Select(static (options, ct) => new LibraryImportGeneratorOptions(options.GlobalOptions)); - IncrementalValueProvider targetFramework = context.AnalyzerConfigOptionsProvider.Select((options, ct) => options.GlobalOptions.GetTargetFrameworkSettings()); IncrementalValueProvider stubEnvironment = context.CreateStubEnvironmentProvider(); // Validate environment that is being used to generate stubs. - context.RegisterDiagnostics(context.CompilationProvider.Combine(attributedMethods.Collect()).Combine(targetFramework).SelectMany((data, ct) => + context.RegisterDiagnostics( + context.CompilationProvider + .Select((comp, ct) => comp.Options is CSharpCompilationOptions { AllowUnsafe: true }) + .Combine(attributedMethods.Collect()) + .SelectMany((data, ct) => { - if (data.Left.Right.IsEmpty // no attributed methods - || data.Left.Left.Options is CSharpCompilationOptions { AllowUnsafe: true } // Unsafe code enabled - || data.Right.TargetFramework != TargetFramework.Net) // Downlevel scenarios use forwarders and don't need unsafe code + if (data.Right.IsEmpty // no attributed methods + || data.Left) // Unsafe code enabled { return ImmutableArray.Empty; } @@ -85,17 +86,15 @@ public void Initialize(IncrementalGeneratorInitializationContext context) IncrementalValuesProvider<(MemberDeclarationSyntax, ImmutableArray)> generateSingleStub = methodsToGenerate .Combine(stubEnvironment) .Combine(stubOptions) - .Combine(targetFramework) .Select(static (data, ct) => new { - data.Left.Left.Left.Syntax, - data.Left.Left.Left.Symbol, - Environment = data.Left.Left.Right, - Options = data.Left.Right, - TargetFramework = data.Right + data.Left.Left.Syntax, + data.Left.Left.Symbol, + Environment = data.Left.Right, + Options = data.Right, }) .Select( - static (data, ct) => CalculateStubInformation(data.Syntax, data.Symbol, data.Environment, data.TargetFramework, data.Options, ct) + static (data, ct) => CalculateStubInformation(data.Syntax, data.Symbol, data.Environment, data.Options, ct) ) .WithTrackingName(StepNames.CalculateStubInformation) .Combine(stubOptions) @@ -216,7 +215,6 @@ private static IncrementalStubGenerationContext CalculateStubInformation( MethodDeclarationSyntax originalSyntax, IMethodSymbol symbol, StubEnvironment environment, - TargetFrameworkSettings targetFramework, LibraryImportGeneratorOptions options, CancellationToken ct) { @@ -292,9 +290,9 @@ private static IncrementalStubGenerationContext CalculateStubInformation( // Create the stub. var signatureContext = SignatureContext.Create( symbol, - LibraryImportGeneratorHelpers.CreateMarshallingInfoParser(environment, targetFramework, generatorDiagnostics, symbol, libraryImportData, generatedDllImportAttr), + DefaultMarshallingInfoParser.Create(environment, generatorDiagnostics, symbol, libraryImportData, generatedDllImportAttr), environment, - new CodeEmitOptions(SkipInit: targetFramework.TargetFramework == TargetFramework.Net), + new CodeEmitOptions(SkipInit: true), typeof(LibraryImportGenerator).Assembly); var containingTypeContext = new ContainingSyntaxContext(originalSyntax); @@ -309,7 +307,6 @@ private static IncrementalStubGenerationContext CalculateStubInformation( locations, new SequenceEqualImmutableArray(additionalAttributes.ToImmutableArray(), SyntaxEquivalentComparer.Instance), LibraryImportData.From(libraryImportData), - targetFramework, options, environment.EnvironmentFlags, new SequenceEqualImmutableArray(generatorDiagnostics.Diagnostics.ToImmutableArray()) @@ -326,47 +323,33 @@ private static (MemberDeclarationSyntax, ImmutableArray) Generat return (PrintForwarderStub(pinvokeStub.StubMethodSyntaxTemplate, explicitForwarding: true, pinvokeStub, diagnostics), pinvokeStub.Diagnostics.Array.AddRange(diagnostics.Diagnostics)); } - bool supportsTargetFramework = !pinvokeStub.LibraryImportData.SetLastError - || options.GenerateForwarders - || (pinvokeStub.TargetFramework is (TargetFramework.Net, { Major: >= 6 })); - - foreach (TypePositionInfo typeInfo in pinvokeStub.SignatureContext.ElementTypeInformation) - { - if (typeInfo.MarshallingAttributeInfo is MissingSupportMarshallingInfo) - { - supportsTargetFramework = false; - break; - } - } + IMarshallingGeneratorResolver resolver = options.GenerateForwarders + ? new ForwarderResolver() + : DefaultMarshallingGeneratorResolver.Create(pinvokeStub.EnvironmentFlags, MarshalDirection.ManagedToUnmanaged, TypeNames.LibraryImportAttribute_ShortName, []); // Generate stub code - var stubGenerator = new PInvokeStubCodeGenerator( + var stubGenerator = new ManagedToNativeStubGenerator( pinvokeStub.SignatureContext.ElementTypeInformation, pinvokeStub.LibraryImportData.SetLastError && !options.GenerateForwarders, diagnostics, - LibraryImportGeneratorHelpers.CreateGeneratorResolver(pinvokeStub.TargetFramework, pinvokeStub.Options, pinvokeStub.EnvironmentFlags), - new CodeEmitOptions(SkipInit: pinvokeStub.TargetFramework is (TargetFramework.Net, _))); - - // For down-level support, if some parameters cannot be marshalled, consider the target framework as not supported - if (stubGenerator.HasForwardedTypes - && (pinvokeStub.TargetFramework.TargetFramework != TargetFramework.Net || pinvokeStub.TargetFramework.Version.Major < 7)) - { - supportsTargetFramework = false; - } + resolver, + new CodeEmitOptions(SkipInit: true)); // Check if the generator should produce a forwarder stub - regular DllImport. - // This is done if the signature is blittable or the target framework is not supported. - if (stubGenerator.StubIsBasicForwarder - || !supportsTargetFramework) + // This is done if the stub doesn't contain any marshalling logic. + if (stubGenerator.NoMarshallingRequired) { - return (PrintForwarderStub(pinvokeStub.StubMethodSyntaxTemplate, !supportsTargetFramework, pinvokeStub, diagnostics), pinvokeStub.Diagnostics.Array.AddRange(diagnostics.Diagnostics)); + // If we have any forwarded types, we're generating a "partial" stub. + // In this case, we'll already emit errors for whatever type we failed to marshal. + // So, don't emit additional errors for the stub itself. + return (PrintForwarderStub(pinvokeStub.StubMethodSyntaxTemplate, explicitForwarding: false, pinvokeStub, diagnostics), pinvokeStub.Diagnostics.Array.AddRange(diagnostics.Diagnostics)); } ImmutableArray forwardedAttributes = pinvokeStub.ForwardedAttributes.Array; const string innerPInvokeName = "__PInvoke"; - BlockSyntax code = stubGenerator.GeneratePInvokeBody(innerPInvokeName); + BlockSyntax code = stubGenerator.GenerateStubBody(innerPInvokeName); LocalFunctionStatementSyntax dllImport = CreateTargetDllImportAsLocalStatement( stubGenerator, @@ -393,7 +376,7 @@ private static MemberDeclarationSyntax PrintForwarderStub(ContainingSyntax userD if (pinvokeData.IsUserDefined.HasFlag(InteropAttributeMember.StringMarshalling) && pinvokeData.StringMarshalling != StringMarshalling.Utf16) { - // Report a diagnostic when forwarding explicitly due to generator options or down-level support. Otherwise, StringMarshalling can just be omitted + // Report a diagnostic when forwarding explicitly. Otherwise, StringMarshalling can just be omitted if (explicitForwarding) { diagnostics.ReportCannotForwardToDllImport( @@ -407,7 +390,7 @@ private static MemberDeclarationSyntax PrintForwarderStub(ContainingSyntax userD if (pinvokeData.IsUserDefined.HasFlag(InteropAttributeMember.StringMarshallingCustomType)) { - // Report a diagnostic when forwarding explicitly due to generator options or down-level support. Otherwise, StringMarshallingCustomType can just be omitted + // Report a diagnostic when forwarding explicitly. Otherwise, StringMarshalling can just be omitted if (explicitForwarding) { diagnostics.ReportCannotForwardToDllImport( @@ -437,7 +420,7 @@ private static MemberDeclarationSyntax PrintForwarderStub(ContainingSyntax userD } private static LocalFunctionStatementSyntax CreateTargetDllImportAsLocalStatement( - PInvokeStubCodeGenerator stubGenerator, + ManagedToNativeStubGenerator stubGenerator, LibraryImportGeneratorOptions options, LibraryImportData libraryImportData, string stubTargetName, diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.csproj b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.csproj index 17727680fae..40dd9ab310c 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.csproj +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGenerator.csproj @@ -22,11 +22,14 @@ + + + diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGeneratorHelpers.cs b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGeneratorHelpers.cs deleted file mode 100644 index bacaa8c74b7..00000000000 --- a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/LibraryImportGeneratorHelpers.cs +++ /dev/null @@ -1,129 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Collections.Generic; -using System.Collections.Immutable; -using Microsoft.CodeAnalysis; - -namespace Microsoft.Interop -{ - internal static class LibraryImportGeneratorHelpers - { - public static MarshallingInfoParser CreateMarshallingInfoParser(StubEnvironment env, TargetFrameworkSettings tf, GeneratorDiagnosticsBag diagnostics, IMethodSymbol method, InteropAttributeCompilationData interopAttributeData, AttributeData unparsedAttributeData) - { - // Compute the current default string encoding value. - CharEncoding defaultEncoding = CharEncoding.Undefined; - if (interopAttributeData.IsUserDefined.HasFlag(InteropAttributeMember.StringMarshalling)) - { - defaultEncoding = interopAttributeData.StringMarshalling switch - { - StringMarshalling.Utf16 => CharEncoding.Utf16, - StringMarshalling.Utf8 => CharEncoding.Utf8, - StringMarshalling.Custom => CharEncoding.Custom, - _ => CharEncoding.Undefined, // [Compat] Do not assume a specific value - }; - } - else if (interopAttributeData.IsUserDefined.HasFlag(InteropAttributeMember.StringMarshallingCustomType)) - { - defaultEncoding = CharEncoding.Custom; - } - - var defaultInfo = new DefaultMarshallingInfo(defaultEncoding, interopAttributeData.StringMarshallingCustomType); - - var useSiteAttributeParsers = ImmutableArray.Create( - new MarshalAsAttributeParser(diagnostics, defaultInfo), - new MarshalUsingAttributeParser(env.Compilation, diagnostics)); - - IMarshallingInfoAttributeParser marshalAsAttributeParser = new MarshalAsAttributeParser(diagnostics, defaultInfo); - - if (tf.TargetFramework == TargetFramework.Net && tf.Version.Major >= 7) - { - // If we have support for the attributed marshalling model, then we want to use that to provide the marshalling logic - // when possible. On other target frameworks, we'll fall back to using the Forwarder logic and re-emitting the MarshalAs attribute. - marshalAsAttributeParser = new MarshalAsWithCustomMarshallersParser(env.Compilation, diagnostics, marshalAsAttributeParser); - } - - return new MarshallingInfoParser( - diagnostics, - new MethodSignatureElementInfoProvider(env.Compilation, diagnostics, method, useSiteAttributeParsers), - useSiteAttributeParsers, - ImmutableArray.Create( - marshalAsAttributeParser, - new MarshalUsingAttributeParser(env.Compilation, diagnostics), - new NativeMarshallingAttributeParser(env.Compilation, diagnostics), - new ComInterfaceMarshallingInfoProvider(env.Compilation)), - ImmutableArray.Create( - new SafeHandleMarshallingInfoProvider(env.Compilation, method.ContainingType), - new ArrayMarshallingInfoProvider(env.Compilation), - new CharMarshallingInfoProvider(defaultInfo), - new StringMarshallingInfoProvider(env.Compilation, diagnostics, unparsedAttributeData, defaultInfo), - new BooleanMarshallingInfoProvider(), - new BlittableTypeMarshallingInfoProvider(env.Compilation))); - } - - public static IMarshallingGeneratorResolver CreateGeneratorResolver(TargetFrameworkSettings tf, LibraryImportGeneratorOptions options, EnvironmentFlags env) - { - IMarshallingGeneratorResolver generatorResolver; - - if (options.GenerateForwarders) - { - generatorResolver = new ForwarderResolver(); - } - else - { - bool isDownstreamScenario = tf.TargetFramework != TargetFramework.Net || tf.Version.Major < 7; - // If we're using our downstream support, fall back to the Forwarder marshaller when the TypePositionInfo is unhandled. - // If we're in a "supported" scenario, then emit a diagnostic as our final fallback. - IMarshallingGeneratorResolver fallbackResolver = isDownstreamScenario ? new ForwarderResolver() : new NotSupportedResolver(); - List coreResolvers = - [ - new MarshalAsMarshallingGeneratorResolver(new InteropGenerationOptions(options.UseMarshalType)), - new NoMarshallingInfoErrorResolver(TypeNames.LibraryImportAttribute_ShortName), - ]; - - if (tf.TargetFramework == TargetFramework.Net || tf.Version.Major >= 7) - { - // Since the char type in an array will not be part of the P/Invoke signature, we can - // use the regular blittable marshaller in all cases. - var charElementMarshaller = new CharMarshallingGeneratorResolver(useBlittableMarshallerForUtf16: true, TypeNames.LibraryImportAttribute_ShortName); - IMarshallingGeneratorResolver elementFactory = new AttributedMarshallingModelGeneratorResolver( - new CompositeMarshallingGeneratorResolver([ - charElementMarshaller, - .. coreResolvers, - fallbackResolver - ]), - new AttributedMarshallingModelOptions( - env.HasFlag(EnvironmentFlags.DisableRuntimeMarshalling), - MarshalMode.ElementIn, - MarshalMode.ElementRef, - MarshalMode.ElementOut, - ResolveElementsFromSelf: true)); - coreResolvers.Add( - new AttributedMarshallingModelGeneratorResolver( - new CompositeMarshallingGeneratorResolver([ - elementFactory, - charElementMarshaller, - .. coreResolvers, - fallbackResolver]), - new AttributedMarshallingModelOptions( - env.HasFlag(EnvironmentFlags.DisableRuntimeMarshalling), - MarshalMode.ManagedToUnmanagedIn, - MarshalMode.ManagedToUnmanagedRef, - MarshalMode.ManagedToUnmanagedOut, - ResolveElementsFromSelf: false))); - } - - generatorResolver = new ByValueContentsMarshalKindValidator(new CompositeMarshallingGeneratorResolver([ - .. coreResolvers, - // Since the char type can go into the P/Invoke signature here, we can only use it when - // runtime marshalling is disabled. - new CharMarshallingGeneratorResolver(useBlittableMarshallerForUtf16: env.HasFlag(EnvironmentFlags.DisableRuntimeMarshalling), TypeNames.LibraryImportAttribute_ShortName), - fallbackResolver - ])); - generatorResolver = new BreakingChangeDetector(generatorResolver); - } - - return generatorResolver; - } - } -} diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Microsoft.Interop.LibraryImportGenerator.props b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Microsoft.Interop.LibraryImportGenerator.props index f4f1372459d..14caceaf8e4 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Microsoft.Interop.LibraryImportGenerator.props +++ b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/Microsoft.Interop.LibraryImportGenerator.props @@ -15,9 +15,5 @@ of generating a stub that handles all of the marshalling. --> - - - - diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/TargetFrameworkSettings.cs b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/TargetFrameworkSettings.cs deleted file mode 100644 index f40e5581f19..00000000000 --- a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/TargetFrameworkSettings.cs +++ /dev/null @@ -1,69 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System; -using System.Collections.Generic; -using System.Reflection; -using System.Text; -using Microsoft.CodeAnalysis.Diagnostics; - -namespace Microsoft.Interop -{ - // This type is a record to get the generated equality and hashing operators - // which will be faster than the reflection-based ones. - public readonly record struct TargetFrameworkSettings(TargetFramework TargetFramework, Version Version); - - /// - /// Target framework identifier - /// - public enum TargetFramework - { - Unknown, - Framework, - Core, - Standard, - Net - } - - public static class TargetFrameworkSettingsExtensions - { - private static readonly Version FirstNonCoreVersion = new(5, 0); - - // Parse from the informational version as that is the only version that always matches the TFM version - // even in debug builds. - private static readonly Version ThisAssemblyVersion = Version.Parse( - typeof(TargetFrameworkSettingsExtensions).Assembly - .GetCustomAttribute().InformationalVersion.Split('-', '+')[0]); - - public static TargetFrameworkSettings GetTargetFrameworkSettings(this AnalyzerConfigOptions options) - { - // Our generator only runs in the following scenarios: - // - In the dotnet/runtime repository. - // - In a .NET SDK for the same TFM that matches the version of this assembly. - // We'll try to pull the TFM information from the build, but if it is not present, - // then we'll assume we're in the ref pack as the TFM information will always be present in the dotnet/runtime build. - options.TryGetValue("build_property.TargetFrameworkIdentifier", out string? frameworkIdentifier); - options.TryGetValue("build_property.TargetFrameworkVersion", out string? versionString); - // TargetFrameworkVersion starts with a 'v'. - Version? version = versionString is not null ? Version.Parse(versionString.Substring(1)) : null; - return new TargetFrameworkSettings( - frameworkIdentifier switch - { - ".NETStandard" => TargetFramework.Standard, - ".NETCoreApp" when version is not null && version < FirstNonCoreVersion => TargetFramework.Core, - ".NETCoreApp" => TargetFramework.Net, - // If the TFM is not specified, we'll infer it from this assembly. - // Since we only ship this assembly as part of the Microsoft.NETCore.App TFM, - // the down-level support only matters for the repo where this project is built. - // In all other cases, we will only be used from the TFM with the matching version as our assembly. - null => TargetFramework.Net, - // Assume that all unknown target framework identifiers are .NET Framework. - // All legacy target frameworks will have effectively the same feature set as we provide for .NET Framework - // for our purposes. - _ => TargetFramework.Framework - }, - // If the version is not specified, we'll infer it from this assembly. - version ?? ThisAssemblyVersion); - } - } -} diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/UnreachableException.cs b/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/UnreachableException.cs deleted file mode 100644 index 203657801cc..00000000000 --- a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/UnreachableException.cs +++ /dev/null @@ -1,16 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System; -using System.Collections.Generic; -using System.Text; - -namespace Microsoft.Interop -{ - /// - /// An exception that should be thrown on code-paths that are unreachable. - /// - internal sealed class UnreachableException : Exception - { - } -} diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/ArrayMarshallingInfoProvider.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/ArrayMarshallingInfoProvider.cs index 2c58acff79b..711886c2797 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/ArrayMarshallingInfoProvider.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/ArrayMarshallingInfoProvider.cs @@ -58,8 +58,8 @@ public static MarshallingInfo CreateArrayMarshallingInfo( if (arrayMarshaller is null) { - // If the array marshaler type is not available, then we cannot marshal arrays but indicate it is missing. - return new MissingSupportCollectionMarshallingInfo(countInfo, elementMarshallingInfo); + // If the array marshaller type is not available, then we cannot marshal arrays + return NoMarshallingInfo.Instance; } if (ManualTypeMarshallingHelper.HasEntryPointMarshallerAttribute(arrayMarshaller) diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/BlittableTypeMarshallingInfoProvider.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/BlittableTypeMarshallingInfoProvider.cs index 04b2da38da3..936cb883473 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/BlittableTypeMarshallingInfoProvider.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/BlittableTypeMarshallingInfoProvider.cs @@ -31,11 +31,6 @@ public MarshallingInfo GetMarshallingInfo(ITypeSymbol type, int indirectionDepth // They are supported in configurations where runtime marshalling is enabled. return NoMarshallingInfo.Instance; } - else if (_compilation.GetTypeByMetadataName(TypeNames.System_Runtime_CompilerServices_DisableRuntimeMarshallingAttribute) is null) - { - // If runtime marshalling cannot be disabled, then treat this as a "missing support" scenario so we can gracefully fall back to using the forwarder downlevel. - return new MissingSupportMarshallingInfo(); - } else { return new UnmanagedBlittableMarshallingInfo(type.IsStrictlyBlittableInContext(_compilation)); diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/BoundGenerators.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/BoundGenerators.cs index 99e15793754..335aca92cab 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/BoundGenerators.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/BoundGenerators.cs @@ -14,24 +14,22 @@ namespace Microsoft.Interop { - public readonly record struct BoundGenerator(TypePositionInfo TypeInfo, IMarshallingGenerator Generator); - public sealed class BoundGenerators { private BoundGenerators() { } - public static BoundGenerators Create(ImmutableArray elementTypeInfo, IMarshallingGeneratorResolver generatorResolver, StubCodeContext context, IMarshallingGenerator fallbackGenerator, out ImmutableArray generatorBindingDiagnostics) + public static BoundGenerators Create(ImmutableArray elementTypeInfo, IMarshallingGeneratorResolver generatorResolver, StubCodeContext context, IUnboundMarshallingGenerator fallbackGenerator, out ImmutableArray generatorBindingDiagnostics) { - BoundGenerator defaultBoundGenerator = new BoundGenerator(new TypePositionInfo(SpecialTypeInfo.Void, NoMarshallingInfo.Instance), fallbackGenerator); + IBoundMarshallingGenerator defaultBoundGenerator = fallbackGenerator.Bind(new TypePositionInfo(SpecialTypeInfo.Void, NoMarshallingInfo.Instance), context); BoundGenerators result = new(); - ImmutableArray.Builder signatureMarshallers = ImmutableArray.CreateBuilder(); - ImmutableArray.Builder nativeParamMarshallers = ImmutableArray.CreateBuilder(); - ImmutableArray.Builder managedParamMarshallers = ImmutableArray.CreateBuilder(); + ImmutableArray.Builder signatureMarshallers = ImmutableArray.CreateBuilder(); + ImmutableArray.Builder nativeParamMarshallers = ImmutableArray.CreateBuilder(); + ImmutableArray.Builder managedParamMarshallers = ImmutableArray.CreateBuilder(); ImmutableArray.Builder generatorDiagnostics = ImmutableArray.CreateBuilder(); - BoundGenerator managedReturnMarshaller = defaultBoundGenerator; - BoundGenerator nativeReturnMarshaller = defaultBoundGenerator; - BoundGenerator managedExceptionMarshaller = defaultBoundGenerator; + IBoundMarshallingGenerator managedReturnMarshaller = defaultBoundGenerator; + IBoundMarshallingGenerator nativeReturnMarshaller = defaultBoundGenerator; + IBoundMarshallingGenerator managedExceptionMarshaller = defaultBoundGenerator; TypePositionInfo? managedExceptionInfo = null; foreach (TypePositionInfo argType in elementTypeInfo) @@ -45,7 +43,7 @@ public static BoundGenerators Create(ImmutableArray elementTyp continue; } - BoundGenerator generator = new BoundGenerator(argType, CreateGenerator(argType, generatorResolver)); + IBoundMarshallingGenerator generator = CreateGenerator(argType, generatorResolver); signatureMarshallers.Add(generator); if (argType.IsManagedReturnPosition) @@ -80,15 +78,15 @@ public static BoundGenerators Create(ImmutableArray elementTyp { managedExceptionInfo = managedExceptionInfo with { - MarshallingAttributeInfo = ComExceptionMarshalling.CreateSpecificMarshallingInfo(nativeReturnMarshaller.Generator.AsNativeType(nativeReturnMarshaller.TypeInfo)) + MarshallingAttributeInfo = ComExceptionMarshalling.CreateSpecificMarshallingInfo(nativeReturnMarshaller.NativeType) }; } - IMarshallingGeneratorResolver exceptionHandlerFactory = new ExtendedInvariantsValidator(nativeReturnMarshaller.Generator.AsNativeType(nativeReturnMarshaller.TypeInfo), generatorResolver); + IMarshallingGeneratorResolver exceptionHandlerFactory = new ExtendedInvariantsValidator(nativeReturnMarshaller.NativeType, generatorResolver); // We explicitly don't include exceptionMarshaller in the signatureMarshallers collection // as it needs to be specially emitted. - managedExceptionMarshaller = new(managedExceptionInfo, CreateGenerator(managedExceptionInfo, generatorResolver)); + managedExceptionMarshaller = CreateGenerator(managedExceptionInfo, generatorResolver); } generatorBindingDiagnostics = generatorDiagnostics.ToImmutable(); @@ -153,34 +151,34 @@ public static BoundGenerators Create(ImmutableArray elementTyp return (false, info.NativeIndex); } - IMarshallingGenerator CreateGenerator(TypePositionInfo p, IMarshallingGeneratorResolver factory) + IBoundMarshallingGenerator CreateGenerator(TypePositionInfo p, IMarshallingGeneratorResolver factory) { ResolvedGenerator generator = factory.Create(p, context); generatorDiagnostics.AddRange(generator.Diagnostics); - return generator.IsResolvedWithoutErrors ? generator.Generator : fallbackGenerator; + return generator.IsResolvedWithoutErrors ? generator.Generator : fallbackGenerator.Bind(p, context); } } - public BoundGenerator ManagedReturnMarshaller { get; private init; } + public IBoundMarshallingGenerator ManagedReturnMarshaller { get; private init; } - public BoundGenerator NativeReturnMarshaller { get; private init; } + public IBoundMarshallingGenerator NativeReturnMarshaller { get; private init; } - public BoundGenerator ManagedExceptionMarshaller { get; private init; } + public IBoundMarshallingGenerator ManagedExceptionMarshaller { get; private init; } - public ImmutableArray SignatureMarshallers { get; private init; } + public ImmutableArray SignatureMarshallers { get; private init; } - public ImmutableArray ManagedParameterMarshallers { get; private init; } + public ImmutableArray ManagedParameterMarshallers { get; private init; } - public ImmutableArray NativeParameterMarshallers { get; private init; } + public ImmutableArray NativeParameterMarshallers { get; private init; } - public (ParameterListSyntax ParameterList, TypeSyntax ReturnType, AttributeListSyntax? ReturnTypeAttributes) GenerateTargetMethodSignatureData(StubCodeContext context) + public (ParameterListSyntax ParameterList, TypeSyntax ReturnType, AttributeListSyntax? ReturnTypeAttributes) GenerateTargetMethodSignatureData(StubIdentifierContext context) { return ( ParameterList( SeparatedList( - NativeParameterMarshallers.Select(marshaler => marshaler.Generator.AsParameter(marshaler.TypeInfo, context)))), - NativeReturnMarshaller.Generator.AsReturnType(NativeReturnMarshaller.TypeInfo), - NativeReturnMarshaller.Generator.GenerateAttributesForReturnType(NativeReturnMarshaller.TypeInfo) + NativeParameterMarshallers.Select(marshaler => marshaler.AsParameter(context)))), + NativeReturnMarshaller.AsReturnType(), + NativeReturnMarshaller.GenerateAttributesForReturnType() ); } @@ -190,7 +188,7 @@ IMarshallingGenerator CreateGenerator(TypePositionInfo p, IMarshallingGeneratorR public bool IsUnmanagedVoidReturn => NativeReturnMarshaller.TypeInfo.ManagedType == SpecialTypeInfo.Void; - public bool HasManagedExceptionMarshaller => ManagedExceptionMarshaller.Generator is not Forwarder; + public bool HasManagedExceptionMarshaller => !ManagedExceptionMarshaller.IsForwarder(); private sealed class ExtendedInvariantsValidator : IMarshallingGeneratorResolver { @@ -212,9 +210,9 @@ public ResolvedGenerator Create(TypePositionInfo info, StubCodeContext context) } // Marshallers that share the native return position must have the same native return type. if (info.IsNativeReturnPosition - && generator.Generator.AsNativeType(info) != _nativeReturnType) + && generator.Generator.NativeType != _nativeReturnType) { - return ResolvedGenerator.NotSupported(new(info, context) + return ResolvedGenerator.NotSupported(info, context, new(info) { NotSupportedDetails = SR.MarshallerInNativeReturnPositionMustMatchNativeReturnType }); diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/ComInterfaceMarshallingInfoProvider.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/ComInterfaceMarshallingInfoProvider.cs index 2386acc0ef5..ac92cc79aad 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/ComInterfaceMarshallingInfoProvider.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/ComInterfaceMarshallingInfoProvider.cs @@ -34,7 +34,7 @@ public static MarshallingInfo CreateComInterfaceMarshallingInfo( { INamedTypeSymbol? comInterfaceMarshaller = compilation.GetTypeByMetadataName(TypeNames.System_Runtime_InteropServices_Marshalling_ComInterfaceMarshaller_Metadata); if (comInterfaceMarshaller is null) - return new MissingSupportMarshallingInfo(); + return NoMarshallingInfo.Instance; comInterfaceMarshaller = comInterfaceMarshaller.Construct(interfaceType); @@ -48,7 +48,7 @@ public static MarshallingInfo CreateComInterfaceMarshallingInfo( } } - return new MissingSupportMarshallingInfo(); + return NoMarshallingInfo.Instance; } } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/CustomMarshallingInfoHelper.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/CustomMarshallingInfoHelper.cs index e98bc9ec3dd..3be46ee6c1c 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/CustomMarshallingInfoHelper.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/CustomMarshallingInfoHelper.cs @@ -174,7 +174,7 @@ public static MarshallingInfo CreateMarshallingInfoByMarshallerTypeName( { INamedTypeSymbol? marshallerType = compilation.GetBestTypeByMetadataName(marshallerName); if (marshallerType is null) - return new MissingSupportMarshallingInfo(); + return NoMarshallingInfo.Instance; if (ManualTypeMarshallingHelper.HasEntryPointMarshallerAttribute(marshallerType)) { @@ -186,7 +186,7 @@ public static MarshallingInfo CreateMarshallingInfoByMarshallerTypeName( } } - return new MissingSupportMarshallingInfo(); + return NoMarshallingInfo.Instance; } } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/ManagedToNativeStubCodeContext.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/DefaultIdentifierContext.cs similarity index 54% rename from src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/ManagedToNativeStubCodeContext.cs rename to src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/DefaultIdentifierContext.cs index bb92b557c81..9785b52b4cc 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/ManagedToNativeStubCodeContext.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/DefaultIdentifierContext.cs @@ -5,46 +5,45 @@ using System.Diagnostics; namespace Microsoft.Interop { - public sealed record ManagedToNativeStubCodeContext : StubCodeContext + public sealed record DefaultIdentifierContext : StubIdentifierContext { - public override bool SingleFrameSpansNativeContext => true; - - public override bool AdditionalTemporaryStateLivesAcrossStages => true; - private const string InvokeReturnIdentifier = "__invokeRetVal"; private const string InvokeReturnIdentifierNative = "__invokeRetValUnmanaged"; private readonly string _returnIdentifier; private readonly string _nativeReturnIdentifier; + private readonly MarshalDirection _direction; - public ManagedToNativeStubCodeContext( + public DefaultIdentifierContext( string returnIdentifier, - string nativeReturnIdentifier) + string nativeReturnIdentifier, + MarshalDirection direction) { _returnIdentifier = returnIdentifier; _nativeReturnIdentifier = nativeReturnIdentifier; + _direction = direction; } public override (string managed, string native) GetIdentifiers(TypePositionInfo info) { - // If the info is in the managed return position, then we need to generate a name to use + // If the info is in the stub return position, then we need to generate a name to use // for both the managed and native values since there is no name in the signature for the return value. - if (info.IsManagedReturnPosition) + if (MarshallerHelpers.IsInStubReturnPosition(info, _direction)) { + // If the info is in the native exception position, + // then we're going to return using name of the native return identifier. + // We use the provided instance identifier as that represents + // the name of the exception variable specified in the catch clause. + if (info.IsManagedExceptionPosition) + { + return (info.InstanceIdentifier, _nativeReturnIdentifier); + } return (_returnIdentifier, _nativeReturnIdentifier); } - // If the info is in the native return position but is not in the managed return position, + // If the info is in the invocation return position but is not in the stub return position, // then that means that the stub is introducing an additional info for the return position. // This means that there is no name in source for this info, so we must provide one here. - // We can't use ReturnIdentifier or ReturnNativeIdentifier since that will be used by the managed return value. - // Additionally, since all use cases today of a TypePositionInfo in the native position but not the managed - // are for infos that aren't in the managed signature at all (PreserveSig scenario), we don't have a name - // that we can use from source. - // If this changes, the assert below will trigger and we will need to decide what to do. - // As a result, we generate another name for the native return value - // and use the same name for native and managed. - else if (info.IsNativeReturnPosition) + else if (MarshallerHelpers.IsInInvocationReturnPosition(info, _direction)) { - Debug.Assert(info.ManagedIndex == TypePositionInfo.UnsetIndex); return (InvokeReturnIdentifier, InvokeReturnIdentifierNative); } else diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/DefaultMarshallingInfoParser.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/DefaultMarshallingInfoParser.cs index 7a587c58d80..a0a51229597 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/DefaultMarshallingInfoParser.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/DefaultMarshallingInfoParser.cs @@ -64,7 +64,7 @@ public static MarshallingInfoParser Create(StubEnvironment env, GeneratorDiagnos new NativeMarshallingAttributeParser(env.Compilation, diagnostics), new ComInterfaceMarshallingInfoProvider(env.Compilation)), ImmutableArray.Create( - new SafeHandleMarshallingInfoProvider(env.Compilation, method.ContainingType), + new SafeHandleMarshallingInfoProvider(env.Compilation), new ArrayMarshallingInfoProvider(env.Compilation), new CharMarshallingInfoProvider(defaultInfo), new StringMarshallingInfoProvider(env.Compilation, diagnostics, unparsedAttributeData, defaultInfo), diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/GeneratedStatements.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/GeneratedStatements.cs index 896487328de..3beed9f31c2 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/GeneratedStatements.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/GeneratedStatements.cs @@ -26,40 +26,41 @@ public struct GeneratedStatements public ImmutableArray ManagedExceptionCatchClauses { get; init; } - public static GeneratedStatements Create(BoundGenerators marshallers, StubCodeContext context) + public static GeneratedStatements Create(BoundGenerators marshallers, StubIdentifierContext context) { return new GeneratedStatements { - Setup = GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubCodeContext.Stage.Setup }), - Marshal = GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubCodeContext.Stage.Marshal }), - Pin = GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubCodeContext.Stage.Pin }).Cast().ToImmutableArray(), - PinnedMarshal = GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubCodeContext.Stage.PinnedMarshal }), + Setup = GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubIdentifierContext.Stage.Setup }), + Marshal = GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubIdentifierContext.Stage.Marshal }), + Pin = GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubIdentifierContext.Stage.Pin }).Cast().ToImmutableArray(), + PinnedMarshal = GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubIdentifierContext.Stage.PinnedMarshal }), InvokeStatement = EmptyStatement(), - Unmarshal = GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubCodeContext.Stage.UnmarshalCapture }) - .AddRange(GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubCodeContext.Stage.Unmarshal })), - NotifyForSuccessfulInvoke = GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubCodeContext.Stage.NotifyForSuccessfulInvoke }), - GuaranteedUnmarshal = GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubCodeContext.Stage.GuaranteedUnmarshal }), - CleanupCallerAllocated = GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubCodeContext.Stage.CleanupCallerAllocated }), - CleanupCalleeAllocated = GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubCodeContext.Stage.CleanupCalleeAllocated }), + Unmarshal = GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubIdentifierContext.Stage.UnmarshalCapture }) + .AddRange(GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubIdentifierContext.Stage.Unmarshal })), + NotifyForSuccessfulInvoke = GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubIdentifierContext.Stage.NotifyForSuccessfulInvoke }), + GuaranteedUnmarshal = GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubIdentifierContext.Stage.GuaranteedUnmarshal }), + CleanupCallerAllocated = GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubIdentifierContext.Stage.CleanupCallerAllocated }), + CleanupCalleeAllocated = GenerateStatementsForStubContext(marshallers, context with { CurrentStage = StubIdentifierContext.Stage.CleanupCalleeAllocated }), ManagedExceptionCatchClauses = GenerateCatchClauseForManagedException(marshallers, context) }; } - public static GeneratedStatements Create(BoundGenerators marshallers, StubCodeContext context, ExpressionSyntax expressionToInvoke) + + public static GeneratedStatements Create(BoundGenerators marshallers, StubCodeContext codeContext, StubIdentifierContext context, ExpressionSyntax expressionToInvoke) { GeneratedStatements statements = Create(marshallers, context); - if (context.Direction == MarshalDirection.ManagedToUnmanaged) + if (codeContext.Direction == MarshalDirection.ManagedToUnmanaged) { return statements with { - InvokeStatement = GenerateStatementForNativeInvoke(marshallers, context with { CurrentStage = StubCodeContext.Stage.Invoke }, expressionToInvoke) + InvokeStatement = GenerateStatementForNativeInvoke(marshallers, context with { CurrentStage = StubIdentifierContext.Stage.Invoke }, expressionToInvoke) }; } - else if (context.Direction == MarshalDirection.UnmanagedToManaged) + else if (codeContext.Direction == MarshalDirection.UnmanagedToManaged) { return statements with { - InvokeStatement = GenerateStatementForManagedInvoke(marshallers, context with { CurrentStage = StubCodeContext.Stage.Invoke }, expressionToInvoke) + InvokeStatement = GenerateStatementForManagedInvoke(marshallers, context with { CurrentStage = StubIdentifierContext.Stage.Invoke }, expressionToInvoke) }; } else @@ -68,12 +69,12 @@ public static GeneratedStatements Create(BoundGenerators marshallers, StubCodeCo } } - private static ImmutableArray GenerateStatementsForStubContext(BoundGenerators marshallers, StubCodeContext context) + private static ImmutableArray GenerateStatementsForStubContext(BoundGenerators marshallers, StubIdentifierContext context) { ImmutableArray.Builder statementsToUpdate = ImmutableArray.CreateBuilder(); - foreach (BoundGenerator marshaller in marshallers.SignatureMarshallers) + foreach (IBoundMarshallingGenerator marshaller in marshallers.SignatureMarshallers) { - statementsToUpdate.AddRange(marshaller.Generator.Generate(marshaller.TypeInfo, context)); + statementsToUpdate.AddRange(marshaller.Generate(context)); } if (statementsToUpdate.Count > 0) @@ -87,18 +88,18 @@ private static ImmutableArray GenerateStatementsForStubContext( return statementsToUpdate.ToImmutable(); } - private static ExpressionStatementSyntax GenerateStatementForNativeInvoke(BoundGenerators marshallers, StubCodeContext context, ExpressionSyntax expressionToInvoke) + private static ExpressionStatementSyntax GenerateStatementForNativeInvoke(BoundGenerators marshallers, StubIdentifierContext context, ExpressionSyntax expressionToInvoke) { - if (context.CurrentStage != StubCodeContext.Stage.Invoke) + if (context.CurrentStage != StubIdentifierContext.Stage.Invoke) { throw new ArgumentException("CurrentStage must be Invoke"); } InvocationExpressionSyntax invoke = InvocationExpression(expressionToInvoke); // Generate code for each parameter for the current stage - foreach (BoundGenerator marshaller in marshallers.NativeParameterMarshallers) + foreach (IBoundMarshallingGenerator marshaller in marshallers.NativeParameterMarshallers) { // Get arguments for invocation - ArgumentSyntax argSyntax = marshaller.Generator.AsArgument(marshaller.TypeInfo, context); + ArgumentSyntax argSyntax = marshaller.AsArgument(context); invoke = invoke.AddArgumentListArguments(argSyntax); } // Assign to return value if necessary @@ -109,7 +110,7 @@ private static ExpressionStatementSyntax GenerateStatementForNativeInvoke(BoundG var (managed, native) = context.GetIdentifiers(marshallers.NativeReturnMarshaller.TypeInfo); - string targetIdentifier = marshallers.NativeReturnMarshaller.Generator.UsesNativeIdentifier(marshallers.NativeReturnMarshaller.TypeInfo, context) + string targetIdentifier = marshallers.NativeReturnMarshaller.UsesNativeIdentifier ? native : managed; @@ -121,18 +122,18 @@ private static ExpressionStatementSyntax GenerateStatementForNativeInvoke(BoundG } - private static ExpressionStatementSyntax GenerateStatementForManagedInvoke(BoundGenerators marshallers, StubCodeContext context, ExpressionSyntax expressionToInvoke) + private static ExpressionStatementSyntax GenerateStatementForManagedInvoke(BoundGenerators marshallers, StubIdentifierContext context, ExpressionSyntax expressionToInvoke) { - if (context.CurrentStage != StubCodeContext.Stage.Invoke) + if (context.CurrentStage != StubIdentifierContext.Stage.Invoke) { throw new ArgumentException("CurrentStage must be Invoke"); } InvocationExpressionSyntax invoke = InvocationExpression(expressionToInvoke); // Generate code for each parameter for the current stage - foreach (BoundGenerator marshaller in marshallers.ManagedParameterMarshallers) + foreach (IBoundMarshallingGenerator marshaller in marshallers.ManagedParameterMarshallers) { // Get arguments for invocation - ArgumentSyntax argSyntax = marshaller.Generator.AsManagedArgument(marshaller.TypeInfo, context); + ArgumentSyntax argSyntax = marshaller.AsManagedArgument(context); invoke = invoke.AddArgumentListArguments(argSyntax); } // Assign to return value if necessary @@ -148,7 +149,7 @@ private static ExpressionStatementSyntax GenerateStatementForManagedInvoke(Bound invoke)); } - private static ImmutableArray GenerateCatchClauseForManagedException(BoundGenerators marshallers, StubCodeContext context) + private static ImmutableArray GenerateCatchClauseForManagedException(BoundGenerators marshallers, StubIdentifierContext context) { if (!marshallers.HasManagedExceptionMarshaller) { @@ -156,16 +157,14 @@ private static ImmutableArray GenerateCatchClauseForManagedEx } ImmutableArray.Builder catchClauseBuilder = ImmutableArray.CreateBuilder(); - BoundGenerator managedExceptionMarshaller = marshallers.ManagedExceptionMarshaller; + IBoundMarshallingGenerator managedExceptionMarshaller = marshallers.ManagedExceptionMarshaller; var (managed, _) = context.GetIdentifiers(managedExceptionMarshaller.TypeInfo); catchClauseBuilder.AddRange( - managedExceptionMarshaller.Generator.Generate( - managedExceptionMarshaller.TypeInfo, context with { CurrentStage = StubCodeContext.Stage.Marshal })); + managedExceptionMarshaller.Generate(context with { CurrentStage = StubIdentifierContext.Stage.Marshal })); catchClauseBuilder.AddRange( - managedExceptionMarshaller.Generator.Generate( - managedExceptionMarshaller.TypeInfo, context with { CurrentStage = StubCodeContext.Stage.PinnedMarshal })); + managedExceptionMarshaller.Generate(context with { CurrentStage = StubIdentifierContext.Stage.PinnedMarshal })); return ImmutableArray.Create( CatchClause( CatchDeclaration(TypeSyntaxes.System_Exception, Identifier(managed)), @@ -173,21 +172,21 @@ private static ImmutableArray GenerateCatchClauseForManagedEx Block(List(catchClauseBuilder)))); } - private static SyntaxTriviaList GenerateStageTrivia(StubCodeContext.Stage stage) + private static SyntaxTriviaList GenerateStageTrivia(StubIdentifierContext.Stage stage) { string comment = stage switch { - StubCodeContext.Stage.Setup => "Perform required setup.", - StubCodeContext.Stage.Marshal => "Convert managed data to native data.", - StubCodeContext.Stage.Pin => "Pin data in preparation for calling the P/Invoke.", - StubCodeContext.Stage.PinnedMarshal => "Convert managed data to native data that requires the managed data to be pinned.", - StubCodeContext.Stage.Invoke => "Call the P/Invoke.", - StubCodeContext.Stage.UnmarshalCapture => "Capture the native data into marshaller instances in case conversion to managed data throws an exception.", - StubCodeContext.Stage.Unmarshal => "Convert native data to managed data.", - StubCodeContext.Stage.CleanupCallerAllocated => "Perform cleanup of caller allocated resources.", - StubCodeContext.Stage.CleanupCalleeAllocated => "Perform cleanup of callee allocated resources.", - StubCodeContext.Stage.NotifyForSuccessfulInvoke => "Keep alive any managed objects that need to stay alive across the call.", - StubCodeContext.Stage.GuaranteedUnmarshal => "Convert native data to managed data even in the case of an exception during the non-cleanup phases.", + StubIdentifierContext.Stage.Setup => "Perform required setup.", + StubIdentifierContext.Stage.Marshal => "Convert managed data to native data.", + StubIdentifierContext.Stage.Pin => "Pin data in preparation for calling the P/Invoke.", + StubIdentifierContext.Stage.PinnedMarshal => "Convert managed data to native data that requires the managed data to be pinned.", + StubIdentifierContext.Stage.Invoke => "Call the P/Invoke.", + StubIdentifierContext.Stage.UnmarshalCapture => "Capture the native data into marshaller instances in case conversion to managed data throws an exception.", + StubIdentifierContext.Stage.Unmarshal => "Convert native data to managed data.", + StubIdentifierContext.Stage.CleanupCallerAllocated => "Perform cleanup of caller allocated resources.", + StubIdentifierContext.Stage.CleanupCalleeAllocated => "Perform cleanup of callee allocated resources.", + StubIdentifierContext.Stage.NotifyForSuccessfulInvoke => "Keep alive any managed objects that need to stay alive across the call.", + StubIdentifierContext.Stage.GuaranteedUnmarshal => "Convert native data to managed data even in the case of an exception during the non-cleanup phases.", _ => throw new ArgumentOutOfRangeException(nameof(stage)) }; diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/IncrementalGeneratorInitializationContextExtensions.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/IncrementalGeneratorInitializationContextExtensions.cs index 48bfaf47297..88094b0cff8 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/IncrementalGeneratorInitializationContextExtensions.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/IncrementalGeneratorInitializationContextExtensions.cs @@ -84,10 +84,12 @@ public static void RegisterConcatenatedSyntaxOutputs(this IncrementalGene StringBuilder source = new(); // Mark in source that the file is auto-generated. - source.AppendLine("// "); + // Explicitly unify on "\r\n" line endings to avoid issues with different line endings in the generated sources. + source.Append("// \r\n"); foreach (string generated in generatedSources) { - source.AppendLine(generated); + source.Append(generated); + source.Append("\r\n"); } // Once https://github.com/dotnet/roslyn/issues/61326 is resolved, we can avoid the ToString() here. diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/LanguageSupport.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/LanguageSupport.cs deleted file mode 100644 index 42c8acfd4ab..00000000000 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/LanguageSupport.cs +++ /dev/null @@ -1,12 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -// Types defined to enable language support of various features -// in the source generator. -namespace System.Runtime.CompilerServices -{ - // Define IsExternalInit type to support records. - internal sealed class IsExternalInit - { - } -} diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/LinearCollectionElementIdentifierContext.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/LinearCollectionElementIdentifierContext.cs new file mode 100644 index 00000000000..22e3008cf65 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/LinearCollectionElementIdentifierContext.cs @@ -0,0 +1,68 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Text; + +namespace Microsoft.Interop +{ + internal sealed record LinearCollectionElementIdentifierContext : StubIdentifierContext + { + private readonly StubIdentifierContext _globalContext; + private readonly TypePositionInfo _elementInfo; + private readonly string _managedSpanIdentifier; + private readonly string _nativeSpanIdentifier; + private readonly int _elementIndirectionLevel; + + public string IndexerIdentifier => MarshallerHelpers.GetIndexerIdentifier(_elementIndirectionLevel - 1); + + /// + /// Create a for marshalling elements of an collection. + /// + /// The type information for elements in the collection. Used to determine which identifiers to provide. + /// The indirection level of the elements in the collection. + /// The identifier of the managed value storage cast to the target element type. + /// The identifier of the native value storage cast to the target element type. + /// The context in which we are marshalling the collection that owns these elements. + public LinearCollectionElementIdentifierContext( + StubIdentifierContext globalContext, + TypePositionInfo elementInfo, + string managedSpanIdentifier, + string nativeSpanIdentifier, + int elementIndirectionLevel) + { + _globalContext = globalContext; + _elementInfo = elementInfo; + _managedSpanIdentifier = managedSpanIdentifier; + _nativeSpanIdentifier = nativeSpanIdentifier; + _elementIndirectionLevel = elementIndirectionLevel; + } + + /// + /// Get managed and native instance identifiers for the + /// + /// Object for which to get identifiers + /// Managed and native identifiers + public override (string managed, string native) GetIdentifiers(TypePositionInfo info) + { + // For this element info, index into the marshaller spans. + if (_elementInfo.PositionsEqual(info)) + { + return ( + $"{_managedSpanIdentifier}[{IndexerIdentifier}]", + $"{_nativeSpanIdentifier}[{IndexerIdentifier}]" + ); + } + // For other element infos, return the names from the global context. + else + { + return _globalContext.GetIdentifiers(info); + } + } + + public override string GetAdditionalIdentifier(TypePositionInfo info, string name) + { + return $"{_nativeSpanIdentifier}__{IndexerIdentifier}__{name}"; + } + } +} diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/LinearCollectionElementMarshallingCodeContext.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/LinearCollectionElementMarshallingCodeContext.cs deleted file mode 100644 index 26990febc94..00000000000 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/LinearCollectionElementMarshallingCodeContext.cs +++ /dev/null @@ -1,76 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System; - -namespace Microsoft.Interop -{ - internal sealed record LinearCollectionElementMarshallingCodeContext : StubCodeContext - { - private readonly string _managedSpanIdentifier; - private readonly string _nativeSpanIdentifier; - - public override bool SingleFrameSpansNativeContext => false; - - public override bool AdditionalTemporaryStateLivesAcrossStages => false; - - public string IndexerIdentifier { get; } - - /// - /// Create a for marshalling elements of an collection. - /// - /// The current marshalling stage. - /// The indexer in the loop to get the element to marshal from the collection. - /// The identifier of the native value storage cast to the target element type. - /// The parent context. - public LinearCollectionElementMarshallingCodeContext( - Stage currentStage, - string managedSpanIdentifier, - string nativeSpanIdentifier, - StubCodeContext parentContext) - { - CurrentStage = currentStage; - IndexerIdentifier = CalculateIndexerIdentifierBasedOnParentContext(parentContext); - _managedSpanIdentifier = managedSpanIdentifier; - _nativeSpanIdentifier = nativeSpanIdentifier; - ParentContext = parentContext; - Direction = ParentContext.Direction; - CodeEmitOptions = ParentContext.CodeEmitOptions; - } - - /// - /// Get managed and native instance identifiers for the - /// - /// Object for which to get identifiers - /// Managed and native identifiers - public override (string managed, string native) GetIdentifiers(TypePositionInfo info) - { - return ( - $"{_managedSpanIdentifier}[{IndexerIdentifier}]", - $"{_nativeSpanIdentifier}[{IndexerIdentifier}]" - ); - } - - public override string GetAdditionalIdentifier(TypePositionInfo info, string name) - { - return $"{_nativeSpanIdentifier}__{IndexerIdentifier}__{name}"; - } - - private static string CalculateIndexerIdentifierBasedOnParentContext(StubCodeContext? parentContext) - { - int i = 0; - while (parentContext is StubCodeContext context) - { - if (context is LinearCollectionElementMarshallingCodeContext) - { - i++; - } - parentContext = context.ParentContext; - } - - // Follow a progression of indexers of the following form: - // __i0, __i1, __i2, __i3, etc/ - return $"__i{i}"; - } - } -} diff --git a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/PInvokeStubCodeGenerator.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/ManagedToNativeStubGenerator.cs similarity index 75% rename from src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/PInvokeStubCodeGenerator.cs rename to src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/ManagedToNativeStubGenerator.cs index 0d5c8a06d14..392b83946a5 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/LibraryImportGenerator/PInvokeStubCodeGenerator.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/ManagedToNativeStubGenerator.cs @@ -13,7 +13,7 @@ namespace Microsoft.Interop { /// - /// Base code generator for generating the body of a source-generated P/Invoke and providing customization for how to invoke/define the native method. + /// Base code generator for generating the body of a source-generated managed-to-unmanaged stub and providing customization for how to invoke/define the native method. /// /// /// This type enables multiple code generators for P/Invoke-style marshalling @@ -26,9 +26,9 @@ namespace Microsoft.Interop /// This refactoring allows the code generator to have control over where the target method is declared /// and how it is declared. /// - internal sealed class PInvokeStubCodeGenerator + public sealed class ManagedToNativeStubGenerator { - public bool StubIsBasicForwarder { get; } + public bool NoMarshallingRequired { get; } public bool HasForwardedTypes { get; } @@ -45,9 +45,9 @@ internal sealed class PInvokeStubCodeGenerator private readonly bool _setLastError; private readonly BoundGenerators _marshallers; - private readonly ManagedToNativeStubCodeContext _context; + private readonly DefaultIdentifierContext _context; - public PInvokeStubCodeGenerator( + public ManagedToNativeStubGenerator( ImmutableArray argTypes, bool setLastError, GeneratorDiagnosticsBag diagnosticsBag, @@ -56,54 +56,63 @@ public PInvokeStubCodeGenerator( { _setLastError = setLastError; - _context = new ManagedToNativeStubCodeContext(ReturnIdentifier, ReturnIdentifier); - _marshallers = BoundGenerators.Create(argTypes, generatorResolver, _context, new Forwarder(), out var bindingDiagnostics); + _marshallers = BoundGenerators.Create(argTypes, generatorResolver, StubCodeContext.DefaultManagedToNativeStub, new Forwarder(), out var bindingDiagnostics); diagnosticsBag.ReportGeneratorDiagnostics(bindingDiagnostics); - if (_marshallers.ManagedReturnMarshaller.Generator.UsesNativeIdentifier(_marshallers.ManagedReturnMarshaller.TypeInfo, _context)) + if (_marshallers.ManagedReturnMarshaller.UsesNativeIdentifier) { // If we need a different native return identifier, then recreate the context with the correct identifier before we generate any code. - _context = new ManagedToNativeStubCodeContext(ReturnIdentifier, $"{ReturnIdentifier}{StubCodeContext.GeneratedNativeIdentifierSuffix}"); + _context = new DefaultIdentifierContext(ReturnIdentifier, $"{ReturnIdentifier}{StubIdentifierContext.GeneratedNativeIdentifierSuffix}", MarshalDirection.ManagedToUnmanaged) + { + CodeEmitOptions = codeEmitOptions + }; + } + else + { + _context = new DefaultIdentifierContext(ReturnIdentifier, ReturnIdentifier, MarshalDirection.ManagedToUnmanaged) + { + CodeEmitOptions = codeEmitOptions + }; } - - _context = _context with { CodeEmitOptions = codeEmitOptions }; bool noMarshallingNeeded = true; - foreach (BoundGenerator generator in _marshallers.SignatureMarshallers) + foreach (IBoundMarshallingGenerator generator in _marshallers.SignatureMarshallers) { // Check if generator is either blittable or just a forwarder. - noMarshallingNeeded &= generator is { Generator: BlittableMarshaller, TypeInfo.IsByRef: false } - or { Generator: Forwarder }; + noMarshallingNeeded &= (generator.IsBlittable() && !generator.TypeInfo.IsByRef) || generator.IsForwarder(); // Track if any generators are just forwarders - for types other than void, this indicates - // types that can't be marshalled by the source generated. - // In .NET 7+ support, we would have emitted a diagnostic error about lack of support - // In down-level support, we do not error - tracking this allows us to switch to generating a basic forwarder (DllImport declaration) - HasForwardedTypes |= generator is { Generator: Forwarder, TypeInfo.ManagedType: not SpecialTypeInfo { SpecialType: Microsoft.CodeAnalysis.SpecialType.System_Void } }; + // types that can't be marshalled by source-generated code. + HasForwardedTypes |= generator.IsForwarder() && generator is { TypeInfo.ManagedType: not SpecialTypeInfo { SpecialType: Microsoft.CodeAnalysis.SpecialType.System_Void } }; } - StubIsBasicForwarder = !setLastError + NoMarshallingRequired = !setLastError && _marshallers.ManagedNativeSameReturn && noMarshallingNeeded; } + public string GetNativeIdentifier(TypePositionInfo info) + { + return _context.GetIdentifiers(info).native; + } + /// - /// Generate the method body of the p/invoke stub. + /// Generate the method body of the managed-to-unmanaged stub. /// - /// Name of the target DllImport function to invoke - /// Method body of the p/invoke stub + /// Name of the target function, function pointer, or delegate to invoke + /// Method body of the managed-to-unmanaged stub /// /// The generated code assumes it will be in an unsafe context. /// - public BlockSyntax GeneratePInvokeBody(string dllImportName) + public BlockSyntax GenerateStubBody(string targetIdentifier) { - GeneratedStatements statements = GeneratedStatements.Create(_marshallers, _context, IdentifierName(dllImportName)); + GeneratedStatements statements = GeneratedStatements.Create(_marshallers, StubCodeContext.DefaultManagedToNativeStub, _context, IdentifierName(targetIdentifier)); bool shouldInitializeVariables = !statements.GuaranteedUnmarshal.IsEmpty || !statements.CleanupCallerAllocated.IsEmpty || !statements.CleanupCalleeAllocated.IsEmpty; VariableDeclarations declarations = VariableDeclarations.GenerateDeclarationsForManagedToUnmanaged(_marshallers, _context, shouldInitializeVariables); - var setupStatements = new List(); + List setupStatements = []; if (_setLastError) { @@ -123,8 +132,7 @@ public BlockSyntax GeneratePInvokeBody(string dllImportName) setupStatements.AddRange(declarations.Variables); setupStatements.AddRange(statements.Setup); - var tryStatements = new List(); - tryStatements.AddRange(statements.Marshal); + List tryStatements = [.. statements.Marshal]; BlockSyntax fixedBlock = Block(statements.PinnedMarshal); if (_setLastError) @@ -140,6 +148,9 @@ public BlockSyntax GeneratePInvokeBody(string dllImportName) fixedBlock = fixedBlock.AddStatements(statements.InvokeStatement); } tryStatements.Add(statements.Pin.NestFixedStatements(fixedBlock)); + + tryStatements.AddRange(statements.NotifyForSuccessfulInvoke); + // = true; if (!(statements.GuaranteedUnmarshal.IsEmpty && statements.CleanupCalleeAllocated.IsEmpty)) { @@ -148,11 +159,10 @@ public BlockSyntax GeneratePInvokeBody(string dllImportName) LiteralExpression(SyntaxKind.TrueLiteralExpression)))); } - tryStatements.AddRange(statements.NotifyForSuccessfulInvoke); tryStatements.AddRange(statements.Unmarshal); List allStatements = setupStatements; - List finallyStatements = new List(); + List finallyStatements = []; if (!(statements.GuaranteedUnmarshal.IsEmpty && statements.CleanupCalleeAllocated.IsEmpty)) { finallyStatements.Add(IfStatement(IdentifierName(InvokeSucceededIdentifier), Block(statements.GuaranteedUnmarshal.Concat(statements.CleanupCalleeAllocated)))); diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/AttributedMarshallingModelGeneratorResolver.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/AttributedMarshallingModelGeneratorResolver.cs index 9a6c6c82d34..771043dcb1a 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/AttributedMarshallingModelGeneratorResolver.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/AttributedMarshallingModelGeneratorResolver.cs @@ -24,9 +24,6 @@ public class AttributedMarshallingModelGeneratorResolver : IMarshallingGenerator private static readonly ImmutableDictionary AddDisableRuntimeMarshallingAttributeProperties = ImmutableDictionary.Empty.Add(GeneratorDiagnosticProperties.AddDisableRuntimeMarshallingAttribute, GeneratorDiagnosticProperties.AddDisableRuntimeMarshallingAttribute); - private static readonly BlittableMarshaller s_blittable = new BlittableMarshaller(); - private static readonly Forwarder s_forwarder = new Forwarder(); - private readonly IMarshallingGeneratorResolver _elementGeneratorResolver; public AttributedMarshallingModelGeneratorResolver( @@ -50,26 +47,6 @@ public ResolvedGenerator Create(TypePositionInfo info, StubCodeContext context) return CreateCustomNativeTypeMarshaller(info, context, marshalInfo); } - if (info.MarshallingAttributeInfo is UnmanagedBlittableMarshallingInfo blittableInfo) - { - if (Options.RuntimeMarshallingDisabled || blittableInfo.IsStrictlyBlittable) - { - return ResolvedGenerator.Resolved(s_blittable); - } - - return ResolvedGenerator.NotSupported( - new GeneratorDiagnostic.NotSupported(info, context) - { - NotSupportedDetails = SR.RuntimeMarshallingMustBeDisabled, - DiagnosticProperties = AddDisableRuntimeMarshallingAttributeProperties - }); - } - - if (info.MarshallingAttributeInfo is MissingSupportMarshallingInfo) - { - return ResolvedGenerator.Resolved(s_forwarder); - } - return ResolvedGenerator.UnresolvedGenerator; } @@ -85,66 +62,28 @@ public ExpressionOrNotSupported(GeneratorDiagnostic.NotSupported notSupportedDia } } - private ExpressionOrNotSupported GetNumElementsExpressionFromMarshallingInfo(TypePositionInfo info, CountInfo count, StubCodeContext context) + private GeneratorDiagnostic.NotSupported? ValidateCountInfo(TypePositionInfo info, CountInfo count, StubCodeContext context, out bool countInfoRequiresCast) { - switch (count) - { - case SizeAndParamIndexInfo(int size, SizeAndParamIndexInfo.UnspecifiedParam): - return new(GetConstSizeExpression(size)); - case ConstSizeCountInfo(int size): - return new(GetConstSizeExpression(size)); - case SizeAndParamIndexInfo(SizeAndParamIndexInfo.UnspecifiedConstSize, TypePositionInfo param): - { - return GetExpressionForParam(param, out bool isIntType) switch - { - (ExpressionSyntax expr, null) => new(isIntType ? expr : CheckedExpression(SyntaxKind.CheckedExpression, expr)), - (null, GeneratorDiagnostic.NotSupported notSupported) => new(notSupported), - (not null, not null) => throw new UnreachableException() - }; - } - case SizeAndParamIndexInfo(int size, TypePositionInfo param): - return GetExpressionForParam(param, out bool _) switch - { - (ExpressionSyntax expr, null) => new( - CheckedExpression(SyntaxKind.CheckedExpression, - BinaryExpression(SyntaxKind.AddExpression, - GetConstSizeExpression(size), - expr))), - (null, GeneratorDiagnostic.NotSupported notSupported) => new(notSupported), - (not null, not null) => throw new UnreachableException() - }; - case CountElementCountInfo(TypePositionInfo elementInfo): - { - return GetExpressionForParam(elementInfo, out bool isIntType) switch - { - (ExpressionSyntax expr, null) => new(isIntType ? expr : CheckedExpression(SyntaxKind.CheckedExpression, expr)), - (null, GeneratorDiagnostic.NotSupported notSupported) => new(notSupported), - (not null, not null) => throw new UnreachableException() - }; - } - default: - return new(new GeneratorDiagnostic.NotSupported(info, context) - { - NotSupportedDetails = SR.ArraySizeMustBeSpecified - }); - } - - static LiteralExpressionSyntax GetConstSizeExpression(int size) - { - return LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(size)); - } + countInfoRequiresCast = false; + return count switch + { + SizeAndParamIndexInfo(_, SizeAndParamIndexInfo.UnspecifiedParam) => null, + ConstSizeCountInfo => null, + SizeAndParamIndexInfo(_, TypePositionInfo param) => ValidateNumElementsExpression(param, out countInfoRequiresCast), + CountElementCountInfo(TypePositionInfo elementInfo) => ValidateNumElementsExpression(elementInfo, out countInfoRequiresCast), + _ => new GeneratorDiagnostic.NotSupported(info) + { + NotSupportedDetails = SR.ArraySizeMustBeSpecified + }, + }; - ExpressionOrNotSupported GetExpressionForParam(TypePositionInfo paramInfo, out bool isIntType) + GeneratorDiagnostic.NotSupported? ValidateNumElementsExpression(TypePositionInfo paramInfo, out bool requiresCast) { - ExpressionSyntax numElementsExpression = GetIndexedNumElementsExpression( - context, - paramInfo, - out int numIndirectionLevels); - + requiresCast = false; ManagedTypeInfo type = paramInfo.ManagedType; MarshallingInfo marshallingInfo = paramInfo.MarshallingAttributeInfo; - for (int i = 0; i < numIndirectionLevels; i++) + for (int i = 0; i < context.ElementIndirectionLevel; i++) { if (marshallingInfo is NativeLinearCollectionMarshallingInfo collectionInfo) { @@ -154,59 +93,24 @@ ExpressionOrNotSupported GetExpressionForParam(TypePositionInfo paramInfo, out b } else { - isIntType = false; - return new(new GeneratorDiagnostic.NotSupported(info, context) + return new GeneratorDiagnostic.NotSupported(info) { NotSupportedDetails = SR.CollectionSizeParamTypeMustBeIntegral - }); + }; } } if (type is not SpecialTypeInfo specialType || !specialType.SpecialType.IsIntegralType()) { - isIntType = false; - return new(new GeneratorDiagnostic.NotSupported(info, context) + return new GeneratorDiagnostic.NotSupported(info) { NotSupportedDetails = SR.CollectionSizeParamTypeMustBeIntegral - }); - } - - isIntType = specialType.SpecialType == SpecialType.System_Int32; - return new(isIntType - ? numElementsExpression - : CastExpression( - PredefinedType(Token(SyntaxKind.IntKeyword)), - ParenthesizedExpression(numElementsExpression))); - } - - static ExpressionSyntax GetIndexedNumElementsExpression(StubCodeContext context, TypePositionInfo numElementsInfo, out int numIndirectionLevels) - { - Stack indexerStack = new(); - - StubCodeContext? currentContext = context; - StubCodeContext lastContext = null!; - - while (currentContext is not null) - { - if (currentContext is LinearCollectionElementMarshallingCodeContext collectionContext) - { - indexerStack.Push(collectionContext.IndexerIdentifier); - } - lastContext = currentContext; - currentContext = currentContext.ParentContext; + }; } - numIndirectionLevels = indexerStack.Count; - - ExpressionSyntax indexedNumElements = IdentifierName(lastContext.GetIdentifiers(numElementsInfo).managed); - while (indexerStack.Count > 0) - { - NameSyntax indexer = IdentifierName(indexerStack.Pop()); - indexedNumElements = ElementAccessExpression(indexedNumElements) - .AddArgumentListArguments(Argument(indexer)); - } + requiresCast = specialType.SpecialType != SpecialType.System_Int32; - return indexedNumElements; + return null; } } @@ -241,13 +145,13 @@ private ResolvedGenerator CreateCustomNativeTypeMarshaller(TypePositionInfo info { if (ValidateCustomNativeTypeMarshallingSupported(info, context, marshalInfo) is GeneratorDiagnostic.NotSupported diagnostic) { - return ResolvedGenerator.NotSupported(diagnostic); + return ResolvedGenerator.NotSupported(info, context, diagnostic); } CustomTypeMarshallerData marshallerData = GetMarshallerDataForTypePositionInfo(marshalInfo.Marshallers, info, context); if (!ValidateRuntimeMarshallingOptions(marshallerData)) { - return ResolvedGenerator.NotSupported(new(info, context) + return ResolvedGenerator.NotSupported(info, context, new(info) { NotSupportedDetails = SR.RuntimeMarshallingMustBeDisabled, DiagnosticProperties = AddDisableRuntimeMarshallingAttributeProperties @@ -261,13 +165,13 @@ private ResolvedGenerator CreateCustomNativeTypeMarshaller(TypePositionInfo info ICustomTypeMarshallingStrategy marshallingStrategy; if (marshallerData.HasState) { - marshallingStrategy = new StatefulValueMarshalling(marshallerData.MarshallerType, marshallerData.NativeType, marshallerData.Shape); + marshallingStrategy = new StatefulValueMarshalling(info, context, marshallerData.MarshallerType, marshallerData.NativeType, marshallerData.Shape); if (marshallerData.Shape.HasFlag(MarshallerShape.CallerAllocatedBuffer)) marshallingStrategy = new StatefulCallerAllocatedBufferMarshalling(marshallingStrategy, marshallerData.MarshallerType.Syntax, marshallerData.BufferElementType.Syntax); } else { - marshallingStrategy = new StatelessValueMarshalling(marshallerData.MarshallerType.Syntax, marshallerData.NativeType, marshallerData.Shape); + marshallingStrategy = new StatelessValueMarshalling(info, context, marshallerData.MarshallerType.Syntax, marshallerData.NativeType, marshallerData.Shape); if (marshallerData.Shape.HasFlag(MarshallerShape.CallerAllocatedBuffer)) marshallingStrategy = new StatelessCallerAllocatedBufferMarshalling(marshallingStrategy, marshallerData.MarshallerType.Syntax, marshallerData.BufferElementType.Syntax, isLinearCollectionMarshalling: false); @@ -289,7 +193,7 @@ private ResolvedGenerator CreateCustomNativeTypeMarshaller(TypePositionInfo info } } - IMarshallingGenerator marshallingGenerator = new CustomTypeMarshallingGenerator(marshallingStrategy, ByValueMarshalKindSupportDescriptor.Default, marshallerData.Shape.HasFlag(MarshallerShape.StatelessPinnableReference)); + IBoundMarshallingGenerator marshallingGenerator = new CustomTypeMarshallingGenerator(marshallingStrategy, ByValueMarshalKindSupportDescriptor.Default, marshallerData.Shape.HasFlag(MarshallerShape.StatelessPinnableReference)); if (marshallerData.Shape.HasFlag(MarshallerShape.StatelessPinnableReference)) { @@ -309,32 +213,33 @@ private ResolvedGenerator CreateNativeCollectionMarshaller( { InstanceIdentifier = info.InstanceIdentifier, ManagedIndex = info.ManagedIndex, + NativeIndex = info.NativeIndex, RefKind = CreateElementRefKind(info.RefKind, info.ByValueContentsMarshalKind) }; ResolvedGenerator resolvedElementMarshaller = _elementGeneratorResolver.Create( elementInfo, - new LinearCollectionElementMarshallingCodeContext(StubCodeContext.Stage.Setup, string.Empty, string.Empty, context)); + StubCodeContext.CreateElementMarshallingContext(context)); if (!resolvedElementMarshaller.IsResolvedWithoutErrors) { return resolvedElementMarshaller; } - IMarshallingGenerator elementMarshaller = resolvedElementMarshaller.Generator; + IBoundMarshallingGenerator elementMarshaller = resolvedElementMarshaller.Generator; - ExpressionSyntax numElementsExpression = LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(0)); + CountInfo countInfo = marshalInfo.ElementCountInfo; + bool countInfoRequiresCast = false; if (MarshallerHelpers.GetMarshalDirection(info, context) != MarshalDirection.ManagedToUnmanaged) { // In this case, we need a numElementsExpression supplied from metadata, so we'll calculate it here. - ExpressionOrNotSupported numElementsExpressionResult = GetNumElementsExpressionFromMarshallingInfo(info, marshalInfo.ElementCountInfo, context); - if (numElementsExpressionResult is (_, GeneratorDiagnostic.NotSupported notSupportedDiagnostic)) + GeneratorDiagnostic.NotSupported? countInfoDiagnostic = ValidateCountInfo(info, countInfo, context, out countInfoRequiresCast); + if (countInfoDiagnostic is not null) { - return ResolvedGenerator.NotSupported(notSupportedDiagnostic); + return ResolvedGenerator.NotSupported(info, context, countInfoDiagnostic); } - numElementsExpression = numElementsExpressionResult.Expression; } // Insert the unmanaged element type into the marshaller type - TypeSyntax unmanagedElementType = elementMarshaller.AsNativeType(elementInfo).Syntax.GetCompatibleGenericTypeParameterSyntax(); + TypeSyntax unmanagedElementType = elementMarshaller.NativeType.Syntax.GetCompatibleGenericTypeParameterSyntax(); ManagedTypeInfo marshallerType = marshallerData.MarshallerType; TypeSyntax marshallerTypeSyntax = ReplacePlaceholderSyntaxWithUnmanagedTypeSyntax(marshallerType.Syntax, marshalInfo, unmanagedElementType); marshallerType = marshallerType with @@ -350,11 +255,11 @@ private ResolvedGenerator CreateNativeCollectionMarshaller( }; ICustomTypeMarshallingStrategy marshallingStrategy; - bool elementIsBlittable = elementMarshaller is BlittableMarshaller; + bool elementIsBlittable = elementMarshaller.IsBlittable(); if (marshallerData.HasState) { - marshallingStrategy = new StatefulValueMarshalling(marshallerType, nativeType, marshallerData.Shape); + marshallingStrategy = new StatefulValueMarshalling(info, context, marshallerType, nativeType, marshallerData.Shape); if (marshallerData.Shape.HasFlag(MarshallerShape.CallerAllocatedBuffer)) { // Check if the buffer element type is actually the unmanaged element type @@ -365,15 +270,15 @@ private ResolvedGenerator CreateNativeCollectionMarshaller( } var freeStrategy = GetFreeStrategy(info, context); - IElementsMarshallingCollectionSource collectionSource = new StatefulLinearCollectionSource(); - ElementsMarshalling elementsMarshalling = CreateElementsMarshalling(marshallerData, elementInfo, elementMarshaller, unmanagedElementType, collectionSource); + IElementsMarshallingCollectionSource collectionSource = new StatefulLinearCollectionSource(info, context); + ElementsMarshalling elementsMarshalling = CreateElementsMarshalling(marshallerData, elementMarshaller, unmanagedElementType, collectionSource); if (freeStrategy == FreeStrategy.FreeOriginal) { marshallingStrategy = new UnmanagedToManagedOwnershipTrackingStrategy(marshallingStrategy); } - marshallingStrategy = new StatefulLinearCollectionMarshalling(marshallingStrategy, marshallerData.Shape, numElementsExpression, elementsMarshalling, freeStrategy != FreeStrategy.NoFree); + marshallingStrategy = new StatefulLinearCollectionMarshalling(marshallingStrategy, marshallerData.Shape, countInfo, countInfoRequiresCast, elementsMarshalling, freeStrategy != FreeStrategy.NoFree); if (freeStrategy == FreeStrategy.FreeOriginal) { @@ -387,19 +292,19 @@ private ResolvedGenerator CreateNativeCollectionMarshaller( } else { - marshallingStrategy = new StatelessLinearCollectionSpaceAllocator(marshallerTypeSyntax, nativeType, marshallerData.Shape, numElementsExpression); + marshallingStrategy = new StatelessLinearCollectionSpaceAllocator(info, context, marshallerTypeSyntax, nativeType, marshallerData.Shape, countInfo, countInfoRequiresCast); var freeStrategy = GetFreeStrategy(info, context); - IElementsMarshallingCollectionSource collectionSource = new StatelessLinearCollectionSource(marshallerTypeSyntax); + IElementsMarshallingCollectionSource collectionSource = new StatelessLinearCollectionSource(info, context, marshallerTypeSyntax); if (freeStrategy == FreeStrategy.FreeOriginal) { marshallingStrategy = new UnmanagedToManagedOwnershipTrackingStrategy(marshallingStrategy); } - ElementsMarshalling elementsMarshalling = CreateElementsMarshalling(marshallerData, elementInfo, elementMarshaller, unmanagedElementType, collectionSource); + ElementsMarshalling elementsMarshalling = CreateElementsMarshalling(marshallerData, elementMarshaller, unmanagedElementType, collectionSource); - marshallingStrategy = new StatelessLinearCollectionMarshalling(marshallingStrategy, elementsMarshalling, nativeType, marshallerData.Shape, numElementsExpression, freeStrategy != FreeStrategy.NoFree); + marshallingStrategy = new StatelessLinearCollectionMarshalling(marshallingStrategy, elementsMarshalling, nativeType, marshallerData.Shape, countInfo, countInfoRequiresCast, freeStrategy != FreeStrategy.NoFree); if (marshallerData.Shape.HasFlag(MarshallerShape.CallerAllocatedBuffer)) { @@ -434,7 +339,7 @@ private ResolvedGenerator CreateNativeCollectionMarshaller( // Elements in the collection must be blittable to use the pinnable marshaller. bool isPinned = marshallerData.Shape.HasFlag(MarshallerShape.StatelessPinnableReference) && elementIsBlittable; - IMarshallingGenerator marshallingGenerator = new CustomTypeMarshallingGenerator(marshallingStrategy, byValueMarshalKindSupport, isPinned); + IBoundMarshallingGenerator marshallingGenerator = new CustomTypeMarshallingGenerator(marshallingStrategy, byValueMarshalKindSupport, isPinned); if (isPinned) { marshallingGenerator = new StaticPinnableManagedValueMarshaller(marshallingGenerator, marshallerTypeSyntax); @@ -484,33 +389,23 @@ private static FreeStrategy GetFreeStrategy(TypePositionInfo info, StubCodeConte return FreeStrategy.NoFree; } - private static ElementsMarshalling CreateElementsMarshalling(CustomTypeMarshallerData marshallerData, TypePositionInfo elementInfo, IMarshallingGenerator elementMarshaller, TypeSyntax unmanagedElementType, IElementsMarshallingCollectionSource collectionSource) + private static ElementsMarshalling CreateElementsMarshalling(CustomTypeMarshallerData marshallerData, IBoundMarshallingGenerator elementMarshaller, TypeSyntax unmanagedElementType, IElementsMarshallingCollectionSource collectionSource) { ElementsMarshalling elementsMarshalling; - bool elementIsBlittable = elementMarshaller is BlittableMarshaller; + bool elementIsBlittable = elementMarshaller.IsBlittable(); if (elementIsBlittable) { elementsMarshalling = new BlittableElementsMarshalling(marshallerData.CollectionElementType.Syntax, unmanagedElementType, collectionSource); } else { - elementsMarshalling = new NonBlittableElementsMarshalling(unmanagedElementType, elementMarshaller, elementInfo, collectionSource); + elementsMarshalling = new NonBlittableElementsMarshalling(unmanagedElementType, elementMarshaller, collectionSource); } return elementsMarshalling; } - private static bool ElementTypeIsSometimesNonBlittable(TypePositionInfo elementInfo) - { - if (elementInfo.MarshallingAttributeInfo is NoMarshallingInfo - || elementInfo.MarshallingAttributeInfo is UnmanagedBlittableMarshallingInfo { IsStrictlyBlittable: true }) - { - return false; - } - return true; - } - private static TypeSyntax ReplacePlaceholderSyntaxWithUnmanagedTypeSyntax( TypeSyntax originalTypeSyntax, NativeLinearCollectionMarshallingInfo marshalInfo, @@ -526,7 +421,7 @@ private static TypeSyntax ReplacePlaceholderSyntaxWithUnmanagedTypeSyntax( if (elementDirection == MarshalDirection.UnmanagedToManaged && !marshalInfo.Marshallers.IsDefinedOrDefault(Options.UnmanagedToManagedMode)) { - return new(info, context) + return new(info) { NotSupportedDetails = SR.Format(SR.UnmanagedToManagedMissingRequiredMarshaller, marshalInfo.EntryPointType.FullTypeName) }; @@ -536,7 +431,7 @@ private static TypeSyntax ReplacePlaceholderSyntaxWithUnmanagedTypeSyntax( if (elementDirection == MarshalDirection.Bidirectional && !marshalInfo.Marshallers.IsDefinedOrDefault(Options.BidirectionalMode)) { - return new(info, context) + return new(info) { NotSupportedDetails = SR.Format(SR.BidirectionalMissingRequiredMarshaller, marshalInfo.EntryPointType.FullTypeName) }; @@ -546,7 +441,7 @@ private static TypeSyntax ReplacePlaceholderSyntaxWithUnmanagedTypeSyntax( if (elementDirection == MarshalDirection.ManagedToUnmanaged && !marshalInfo.Marshallers.IsDefinedOrDefault(Options.ManagedToUnmanagedMode)) { - return new(info, context) + return new(info) { NotSupportedDetails = SR.Format(SR.ManagedToUnmanagedMissingRequiredMarshaller, marshalInfo.EntryPointType.FullTypeName) }; diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/BlittableMarshaller.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/BlittableMarshaller.cs index 76577d497cb..99fc1329955 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/BlittableMarshaller.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/BlittableMarshaller.cs @@ -9,7 +9,7 @@ namespace Microsoft.Interop { - public sealed class BlittableMarshaller : IMarshallingGenerator + public sealed class BlittableMarshaller : IUnboundMarshallingGenerator { public ManagedTypeInfo AsNativeType(TypePositionInfo info) { @@ -34,16 +34,16 @@ public ValueBoundaryBehavior GetValueBoundaryBehavior(TypePositionInfo info, Stu return ValueBoundaryBehavior.AddressOfNativeIdentifier; } - public IEnumerable Generate(TypePositionInfo info, StubCodeContext context) + public IEnumerable Generate(TypePositionInfo info, StubCodeContext codeContext, StubIdentifierContext context) { - if (!info.IsByRef || context.IsInStubReturnPosition(info)) + if (!info.IsByRef || codeContext.IsInStubReturnPosition(info)) yield break; (string managedIdentifier, string nativeIdentifier) = context.GetIdentifiers(info); - if (context.SingleFrameSpansNativeContext) + if (codeContext.SingleFrameSpansNativeContext) { - if (context.CurrentStage == StubCodeContext.Stage.Pin) + if (context.CurrentStage == StubIdentifierContext.Stage.Pin) { yield return FixedStatement( VariableDeclaration( @@ -62,14 +62,14 @@ public IEnumerable Generate(TypePositionInfo info, StubCodeCont yield break; } - MarshalDirection elementMarshalling = MarshallerHelpers.GetMarshalDirection(info, context); + MarshalDirection direction = MarshallerHelpers.GetMarshalDirection(info, codeContext); switch (context.CurrentStage) { - case StubCodeContext.Stage.Setup: + case StubIdentifierContext.Stage.Setup: break; - case StubCodeContext.Stage.Marshal: - if (elementMarshalling is MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional && info.IsByRef) + case StubIdentifierContext.Stage.Marshal: + if (direction is MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional && info.IsByRef) { yield return ExpressionStatement( AssignmentExpression( @@ -79,8 +79,8 @@ public IEnumerable Generate(TypePositionInfo info, StubCodeCont } break; - case StubCodeContext.Stage.Unmarshal: - if (elementMarshalling is MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional && info.IsByRef) + case StubIdentifierContext.Stage.Unmarshal: + if (direction is MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional && info.IsByRef) { yield return ExpressionStatement( AssignmentExpression( @@ -99,7 +99,7 @@ public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) return info.IsByRef && !context.IsInStubReturnPosition(info) && !context.SingleFrameSpansNativeContext; } - public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, StubCodeContext context, out GeneratorDiagnostic? diagnostic) - => ByValueMarshalKindSupportDescriptor.Default.GetSupport(marshalKind, info, context, out diagnostic); + public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, out GeneratorDiagnostic? diagnostic) + => ByValueMarshalKindSupportDescriptor.Default.GetSupport(marshalKind, info, out diagnostic); } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/BlittableMarshallerResolver.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/BlittableMarshallerResolver.cs new file mode 100644 index 00000000000..602753d4e50 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/BlittableMarshallerResolver.cs @@ -0,0 +1,44 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Text; + +namespace Microsoft.Interop +{ + /// + /// Resolves a with based on the target compilation's + /// runtime marshalling support and the type's blittability. + /// + /// Whether or not the target compilation has the 'DisableRuntimeMarshallingAttribute' applied. + public sealed class BlittableMarshallerResolver(bool runtimeMarshallingDisabled) : IMarshallingGeneratorResolver + { + private static readonly ImmutableDictionary AddDisableRuntimeMarshallingAttributeProperties = + ImmutableDictionary.Empty.Add(GeneratorDiagnosticProperties.AddDisableRuntimeMarshallingAttribute, GeneratorDiagnosticProperties.AddDisableRuntimeMarshallingAttribute); + + private static readonly BlittableMarshaller s_blittable = new BlittableMarshaller(); + + public ResolvedGenerator Create(TypePositionInfo info, StubCodeContext context) + { + if (info.MarshallingAttributeInfo is UnmanagedBlittableMarshallingInfo blittableInfo) + { + if (runtimeMarshallingDisabled || blittableInfo.IsStrictlyBlittable) + { + return ResolvedGenerator.Resolved(s_blittable.Bind(info, context)); + } + + return ResolvedGenerator.NotSupported( + info, + context, new GeneratorDiagnostic.NotSupported(info) + { + NotSupportedDetails = SR.RuntimeMarshallingMustBeDisabled, + DiagnosticProperties = AddDisableRuntimeMarshallingAttributeProperties + }); + } + + return ResolvedGenerator.UnresolvedGenerator; + } + } +} diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/BoolMarshaller.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/BoolMarshaller.cs index 24e2102eb73..5b272699863 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/BoolMarshaller.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/BoolMarshaller.cs @@ -11,7 +11,7 @@ namespace Microsoft.Interop { - public abstract class BoolMarshallerBase : IMarshallingGenerator + public abstract class BoolMarshallerBase : IUnboundMarshallingGenerator { private readonly ManagedTypeInfo _nativeType; private readonly int _trueValue; @@ -47,15 +47,15 @@ public ValueBoundaryBehavior GetValueBoundaryBehavior(TypePositionInfo info, Stu return ValueBoundaryBehavior.NativeIdentifier; } - public IEnumerable Generate(TypePositionInfo info, StubCodeContext context) + public IEnumerable Generate(TypePositionInfo info, StubCodeContext codeContext, StubIdentifierContext context) { - MarshalDirection elementMarshalDirection = MarshallerHelpers.GetMarshalDirection(info, context); + MarshalDirection elementMarshalDirection = MarshallerHelpers.GetMarshalDirection(info, codeContext); (string managedIdentifier, string nativeIdentifier) = context.GetIdentifiers(info); switch (context.CurrentStage) { - case StubCodeContext.Stage.Setup: + case StubIdentifierContext.Stage.Setup: break; - case StubCodeContext.Stage.Marshal: + case StubIdentifierContext.Stage.Marshal: // = ()( ? _trueValue : _falseValue); if (elementMarshalDirection is MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional) { @@ -72,7 +72,7 @@ public IEnumerable Generate(TypePositionInfo info, StubCodeCont } break; - case StubCodeContext.Stage.Unmarshal: + case StubIdentifierContext.Stage.Unmarshal: if (elementMarshalDirection is MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional) { // = == _trueValue; @@ -97,8 +97,8 @@ public IEnumerable Generate(TypePositionInfo info, StubCodeCont public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) => true; - public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, StubCodeContext context, out GeneratorDiagnostic? diagnostic) - => ByValueMarshalKindSupportDescriptor.Default.GetSupport(marshalKind, info, context, out diagnostic); + public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, out GeneratorDiagnostic? diagnostic) + => ByValueMarshalKindSupportDescriptor.Default.GetSupport(marshalKind, info, out diagnostic); } /// diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/BreakingChangeDetector.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/BreakingChangeDetector.cs index 02e73d70b01..6906b9b2bcc 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/BreakingChangeDetector.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/BreakingChangeDetector.cs @@ -29,7 +29,7 @@ public ResolvedGenerator Create(TypePositionInfo info, StubCodeContext context) gen = ResolvedGenerator.ResolvedWithDiagnostics( gen.Generator, gen.Diagnostics.Add( - new GeneratorDiagnostic.NotRecommended(info, context) + new GeneratorDiagnostic.NotRecommended(info) { Details = SR.InVariantShouldBeRef })); diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ByValueContentsMarshalKindValidator.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ByValueContentsMarshalKindValidator.cs index 9878cbdbc58..0f3b07fadf7 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ByValueContentsMarshalKindValidator.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ByValueContentsMarshalKindValidator.cs @@ -22,24 +22,24 @@ public ByValueContentsMarshalKindValidator(IMarshallingGeneratorResolver inner) public ResolvedGenerator Create(TypePositionInfo info, StubCodeContext context) { ResolvedGenerator generator = _inner.Create(info, context); - return generator.IsResolvedWithoutErrors ? ValidateByValueMarshalKind(info, context, generator) : generator; + return generator.IsResolvedWithoutErrors ? ValidateByValueMarshalKind(generator, context) : generator; } - private static ResolvedGenerator ValidateByValueMarshalKind(TypePositionInfo info, StubCodeContext context, ResolvedGenerator generator) + private static ResolvedGenerator ValidateByValueMarshalKind(ResolvedGenerator generator, StubCodeContext context) { - if (generator.Generator is Forwarder) + if (generator.Generator.IsForwarder()) { // Forwarder allows everything since it just forwards to a P/Invoke. // The Default marshal kind is always valid. return generator; } - var support = generator.Generator.SupportsByValueMarshalKind(info.ByValueContentsMarshalKind, info, context, out GeneratorDiagnostic? diagnostic); + var support = generator.Generator.SupportsByValueMarshalKind(generator.Generator.TypeInfo.ByValueContentsMarshalKind, out GeneratorDiagnostic? diagnostic); Debug.Assert(support == ByValueMarshalKindSupport.Supported || diagnostic is not null); return support switch { ByValueMarshalKindSupport.Supported => generator, - ByValueMarshalKindSupport.NotSupported => ResolvedGenerator.ResolvedWithDiagnostics(s_forwarder, generator.Diagnostics.Add(diagnostic!)), + ByValueMarshalKindSupport.NotSupported => ResolvedGenerator.ResolvedWithDiagnostics(s_forwarder.Bind(generator.Generator.TypeInfo, context), generator.Diagnostics.Add(diagnostic!)), ByValueMarshalKindSupport.Unnecessary => generator with { Diagnostics = generator.Diagnostics.Add(diagnostic!) }, ByValueMarshalKindSupport.NotRecommended => generator with { Diagnostics = generator.Diagnostics.Add(diagnostic!) }, _ => throw new UnreachableException() diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ByValueMarshalKindSupportDescriptor.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ByValueMarshalKindSupportDescriptor.cs index 7754e177d66..d8aab60196a 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ByValueMarshalKindSupportDescriptor.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ByValueMarshalKindSupportDescriptor.cs @@ -9,27 +9,26 @@ namespace Microsoft.Interop { public record struct ByValueMarshalKindSupportInfo(ByValueMarshalKindSupport Support, string? details) { - public ByValueMarshalKindSupport GetSupport(TypePositionInfo info, StubCodeContext context, out GeneratorDiagnostic? diagnostic) + public ByValueMarshalKindSupport GetSupport(TypePositionInfo info, out GeneratorDiagnostic? diagnostic) { diagnostic = Support switch { ByValueMarshalKindSupport.Supported => null, ByValueMarshalKindSupport.NotRecommended => - new GeneratorDiagnostic.NotRecommended(info, context) + new GeneratorDiagnostic.NotRecommended(info) { Details = details }, ByValueMarshalKindSupport.Unnecessary => new GeneratorDiagnostic.UnnecessaryData( info, - context, ImmutableArray.Create(info.ByValueMarshalAttributeLocations.OutLocation)) { UnnecessaryDataName = SR.InOutAttributes, UnnecessaryDataDetails = details }, ByValueMarshalKindSupport.NotSupported => - new GeneratorDiagnostic.NotSupported(info, context) + new GeneratorDiagnostic.NotSupported(info) { NotSupportedDetails = details }, @@ -40,7 +39,7 @@ public ByValueMarshalKindSupport GetSupport(TypePositionInfo info, StubCodeConte } /// - /// Provides an implementation of through + /// Provides an implementation of through /// public record ByValueMarshalKindSupportDescriptor( ByValueMarshalKindSupportInfo DefaultSupport, @@ -69,14 +68,14 @@ public record ByValueMarshalKindSupportDescriptor( /// /// Returns the support for the ByValueContentsMarshalKind, and if it is not , diagnostic is not null /// - public ByValueMarshalKindSupport GetSupport(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, StubCodeContext context, out GeneratorDiagnostic? diagnostic) + public ByValueMarshalKindSupport GetSupport(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, out GeneratorDiagnostic? diagnostic) { if (info.IsByRef) { // ByRef with ByValue attributes is not allowed if (marshalKind != ByValueContentsMarshalKind.Default) { - diagnostic = new GeneratorDiagnostic.NotSupported(info, context) + diagnostic = new GeneratorDiagnostic.NotSupported(info) { NotSupportedDetails = SR.InOutAttributeByRefNotSupported }; @@ -96,10 +95,10 @@ public ByValueMarshalKindSupport GetSupport(ByValueContentsMarshalKind marshalKi return marshalKind switch { - ByValueContentsMarshalKind.Default => DefaultSupport.GetSupport(info, context, out diagnostic), - ByValueContentsMarshalKind.In => InSupport.GetSupport(info, context, out diagnostic), - ByValueContentsMarshalKind.Out => OutSupport.GetSupport(info, context, out diagnostic), - ByValueContentsMarshalKind.InOut => InOutSupport.GetSupport(info, context, out diagnostic), + ByValueContentsMarshalKind.Default => DefaultSupport.GetSupport(info, out diagnostic), + ByValueContentsMarshalKind.In => InSupport.GetSupport(info, out diagnostic), + ByValueContentsMarshalKind.Out => OutSupport.GetSupport(info, out diagnostic), + ByValueContentsMarshalKind.InOut => InOutSupport.GetSupport(info, out diagnostic), _ => throw new UnreachableException() }; } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/CharMarshaller.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/CharMarshaller.cs index dc70548ff4f..829ccb98510 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/CharMarshaller.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/CharMarshaller.cs @@ -11,7 +11,7 @@ namespace Microsoft.Interop { - public sealed class Utf16CharMarshaller : IMarshallingGenerator + public sealed class Utf16CharMarshaller : IUnboundMarshallingGenerator { private static readonly ManagedTypeInfo s_nativeType = SpecialTypeInfo.UInt16; @@ -44,13 +44,13 @@ public SignatureBehavior GetNativeSignatureBehavior(TypePositionInfo info) return info.IsByRef ? SignatureBehavior.PointerToNativeType : SignatureBehavior.NativeType; } - public IEnumerable Generate(TypePositionInfo info, StubCodeContext context) + public IEnumerable Generate(TypePositionInfo info, StubCodeContext codeContext, StubIdentifierContext context) { (string managedIdentifier, string nativeIdentifier) = context.GetIdentifiers(info); - if (IsPinningPathSupported(info, context)) + if (IsPinningPathSupported(info, codeContext)) { - if (context.CurrentStage == StubCodeContext.Stage.Pin) + if (context.CurrentStage == StubIdentifierContext.Stage.Pin) { // fixed (char* = &) yield return FixedStatement( @@ -79,13 +79,13 @@ public IEnumerable Generate(TypePositionInfo info, StubCodeCont yield break; } - MarshalDirection elementMarshalDirection = MarshallerHelpers.GetMarshalDirection(info, context); + MarshalDirection elementMarshalDirection = MarshallerHelpers.GetMarshalDirection(info, codeContext); switch (context.CurrentStage) { - case StubCodeContext.Stage.Setup: + case StubIdentifierContext.Stage.Setup: break; - case StubCodeContext.Stage.Marshal: + case StubIdentifierContext.Stage.Marshal: if (elementMarshalDirection is MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional) { // There's an implicit conversion from char to ushort, @@ -101,7 +101,7 @@ public IEnumerable Generate(TypePositionInfo info, StubCodeCont } break; - case StubCodeContext.Stage.Unmarshal: + case StubIdentifierContext.Stage.Unmarshal: if (elementMarshalDirection is MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional) { yield return ExpressionStatement( @@ -134,9 +134,9 @@ private static bool IsPinningPathSupported(TypePositionInfo info, StubCodeContex } private static string PinnedIdentifier(string identifier) => $"{identifier}__pinned"; - public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, StubCodeContext context, out GeneratorDiagnostic? diagnostic) + public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, out GeneratorDiagnostic? diagnostic) { - return ByValueMarshalKindSupportDescriptor.Default.GetSupport(marshalKind, info, context, out diagnostic); + return ByValueMarshalKindSupportDescriptor.Default.GetSupport(marshalKind, info, out diagnostic); } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/CharMarshallingGeneratorResolver.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/CharMarshallingGeneratorResolver.cs index 303f4a40a4c..9a223191257 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/CharMarshallingGeneratorResolver.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/CharMarshallingGeneratorResolver.cs @@ -9,8 +9,8 @@ namespace Microsoft.Interop { public sealed class CharMarshallingGeneratorResolver : IMarshallingGeneratorResolver { - private static readonly IMarshallingGenerator s_blittable = new BlittableMarshaller(); - private static readonly IMarshallingGenerator s_utf16Char = new Utf16CharMarshaller(); + private static readonly IUnboundMarshallingGenerator s_blittable = new BlittableMarshaller(); + private static readonly IUnboundMarshallingGenerator s_utf16Char = new Utf16CharMarshaller(); private readonly bool _useBlittableMarshallerForUtf16; private readonly string _stringMarshallingAttribute; @@ -37,7 +37,7 @@ private ResolvedGenerator CreateCharMarshaller(TypePositionInfo info, StubCodeCo if (marshalInfo is NoMarshallingInfo) { // [Compat] Require explicit marshalling information. - return ResolvedGenerator.NotSupported(new(info, context) + return ResolvedGenerator.NotSupported(info, context, new(info) { NotSupportedDetails = string.Format(SR.MarshallingStringOrCharAsUndefinedNotSupported, _stringMarshallingAttribute) }); @@ -50,7 +50,7 @@ private ResolvedGenerator CreateCharMarshaller(TypePositionInfo info, StubCodeCo { case UnmanagedType.I2: case UnmanagedType.U2: - return ResolvedGenerator.Resolved(_useBlittableMarshallerForUtf16 ? s_blittable : s_utf16Char); + return ResolvedGenerator.Resolved(_useBlittableMarshallerForUtf16 ? s_blittable.Bind(info, context) : s_utf16Char.Bind(info, context)); } } else if (marshalInfo is MarshallingInfoStringSupport marshalStringInfo) @@ -58,21 +58,21 @@ private ResolvedGenerator CreateCharMarshaller(TypePositionInfo info, StubCodeCo switch (marshalStringInfo.CharEncoding) { case CharEncoding.Utf16: - return ResolvedGenerator.Resolved(_useBlittableMarshallerForUtf16 ? s_blittable : s_utf16Char); + return ResolvedGenerator.Resolved(_useBlittableMarshallerForUtf16 ? s_blittable.Bind(info, context) : s_utf16Char.Bind(info, context)); case CharEncoding.Utf8: - return ResolvedGenerator.NotSupported(new(info, context) // [Compat] UTF-8 is not supported for char + return ResolvedGenerator.NotSupported(info, context, new(info) // [Compat] UTF-8 is not supported for char { NotSupportedDetails = SR.Format(SR.MarshallingCharAsSpecifiedStringMarshallingNotSupported, nameof(CharEncoding.Utf8)) }); case CharEncoding.Custom: - return ResolvedGenerator.NotSupported(new(info, context) + return ResolvedGenerator.NotSupported(info, context, new(info) { NotSupportedDetails = SR.MarshallingCharAsStringMarshallingCustomNotSupported }); } } - return ResolvedGenerator.NotSupported(new(info, context)); + return ResolvedGenerator.NotSupported(info, context, new(info)); } } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/CustomTypeMarshallingGenerator.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/CustomTypeMarshallingGenerator.cs index 9c65fdc5e7c..259f1e3bd97 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/CustomTypeMarshallingGenerator.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/CustomTypeMarshallingGenerator.cs @@ -10,92 +10,77 @@ namespace Microsoft.Interop /// /// Implements generating code for an instance. /// - internal sealed class CustomTypeMarshallingGenerator : IMarshallingGenerator + internal sealed class CustomTypeMarshallingGenerator(ICustomTypeMarshallingStrategy nativeTypeMarshaller, ByValueMarshalKindSupportDescriptor byValueContentsMarshallingSupport, bool isPinned) + : IBoundMarshallingGenerator { - private readonly ICustomTypeMarshallingStrategy _nativeTypeMarshaller; - private readonly ByValueMarshalKindSupportDescriptor _byValueContentsMarshallingSupport; - private readonly bool _isPinned; + public ValueBoundaryBehavior ValueBoundaryBehavior => TypeInfo.IsByRef ? ValueBoundaryBehavior.AddressOfNativeIdentifier : ValueBoundaryBehavior.NativeIdentifier; - public CustomTypeMarshallingGenerator(ICustomTypeMarshallingStrategy nativeTypeMarshaller, ByValueMarshalKindSupportDescriptor byValueContentsMarshallingSupport, bool isPinned) - { - _nativeTypeMarshaller = nativeTypeMarshaller; - _byValueContentsMarshallingSupport = byValueContentsMarshallingSupport; - _isPinned = isPinned; - } + public ManagedTypeInfo NativeType => nativeTypeMarshaller.NativeType; - public ValueBoundaryBehavior GetValueBoundaryBehavior(TypePositionInfo info, StubCodeContext context) - { - return info.IsByRef ? ValueBoundaryBehavior.AddressOfNativeIdentifier : ValueBoundaryBehavior.NativeIdentifier; - } + public SignatureBehavior NativeSignatureBehavior => TypeInfo.IsByRef ? SignatureBehavior.PointerToNativeType : SignatureBehavior.NativeType; - public ManagedTypeInfo AsNativeType(TypePositionInfo info) - { - return _nativeTypeMarshaller.AsNativeType(info); - } + public TypePositionInfo TypeInfo => nativeTypeMarshaller.TypeInfo; - public SignatureBehavior GetNativeSignatureBehavior(TypePositionInfo info) - { - return info.IsByRef ? SignatureBehavior.PointerToNativeType : SignatureBehavior.NativeType; - } + public StubCodeContext CodeContext => nativeTypeMarshaller.CodeContext; - public IEnumerable Generate(TypePositionInfo info, StubCodeContext context) + public IEnumerable Generate(StubIdentifierContext context) { - MarshalDirection elementMarshalDirection = MarshallerHelpers.GetMarshalDirection(info, context); + MarshalDirection elementMarshalDirection = MarshallerHelpers.GetMarshalDirection(TypeInfo, CodeContext); // Although custom native type marshalling doesn't support [In] or [Out] by value marshalling, // other marshallers that wrap this one might, so we handle the correct cases here. switch (context.CurrentStage) { - case StubCodeContext.Stage.Setup: - return _nativeTypeMarshaller.GenerateSetupStatements(info, context); - case StubCodeContext.Stage.Marshal: + case StubIdentifierContext.Stage.Setup: + return nativeTypeMarshaller.GenerateSetupStatements(context); + case StubIdentifierContext.Stage.Marshal: if (elementMarshalDirection is MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional - || (context.Direction == MarshalDirection.UnmanagedToManaged && ShouldGenerateByValueOutMarshalling(info, context))) + || (CodeContext.Direction == MarshalDirection.UnmanagedToManaged && ShouldGenerateByValueOutMarshalling)) { - return _nativeTypeMarshaller.GenerateMarshalStatements(info, context); + return nativeTypeMarshaller.GenerateMarshalStatements(context); } break; - case StubCodeContext.Stage.Pin: - if (context.SingleFrameSpansNativeContext && elementMarshalDirection is MarshalDirection.ManagedToUnmanaged) + case StubIdentifierContext.Stage.Pin: + if (CodeContext.SingleFrameSpansNativeContext && elementMarshalDirection is MarshalDirection.ManagedToUnmanaged) { - return _nativeTypeMarshaller.GeneratePinStatements(info, context); + return nativeTypeMarshaller.GeneratePinStatements(context); } break; - case StubCodeContext.Stage.PinnedMarshal: + case StubIdentifierContext.Stage.PinnedMarshal: if (elementMarshalDirection is MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional) { - return _nativeTypeMarshaller.GeneratePinnedMarshalStatements(info, context); + return nativeTypeMarshaller.GeneratePinnedMarshalStatements(context); } break; - case StubCodeContext.Stage.NotifyForSuccessfulInvoke: + case StubIdentifierContext.Stage.NotifyForSuccessfulInvoke: if (elementMarshalDirection is MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional) { - return _nativeTypeMarshaller.GenerateNotifyForSuccessfulInvokeStatements(info, context); + return nativeTypeMarshaller.GenerateNotifyForSuccessfulInvokeStatements(context); } break; - case StubCodeContext.Stage.UnmarshalCapture: + case StubIdentifierContext.Stage.UnmarshalCapture: if (elementMarshalDirection is MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional) { - return _nativeTypeMarshaller.GenerateUnmarshalCaptureStatements(info, context); + return nativeTypeMarshaller.GenerateUnmarshalCaptureStatements(context); } break; - case StubCodeContext.Stage.Unmarshal: + case StubIdentifierContext.Stage.Unmarshal: if (elementMarshalDirection is MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional - || (context.Direction == MarshalDirection.ManagedToUnmanaged && ShouldGenerateByValueOutMarshalling(info, context))) + || (CodeContext.Direction == MarshalDirection.ManagedToUnmanaged && ShouldGenerateByValueOutMarshalling)) { - return _nativeTypeMarshaller.GenerateUnmarshalStatements(info, context); + return nativeTypeMarshaller.GenerateUnmarshalStatements(context); } break; - case StubCodeContext.Stage.GuaranteedUnmarshal: + case StubIdentifierContext.Stage.GuaranteedUnmarshal: if (elementMarshalDirection is MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional - || (context.Direction == MarshalDirection.ManagedToUnmanaged && ShouldGenerateByValueOutMarshalling(info, context))) + || (CodeContext.Direction == MarshalDirection.ManagedToUnmanaged && ShouldGenerateByValueOutMarshalling)) { - return _nativeTypeMarshaller.GenerateGuaranteedUnmarshalStatements(info, context); + return nativeTypeMarshaller.GenerateGuaranteedUnmarshalStatements(context); } break; - case StubCodeContext.Stage.CleanupCallerAllocated: - return _nativeTypeMarshaller.GenerateCleanupCallerAllocatedResourcesStatements(info, context); - case StubCodeContext.Stage.CleanupCalleeAllocated: - return _nativeTypeMarshaller.GenerateCleanupCalleeAllocatedResourcesStatements(info, context); + case StubIdentifierContext.Stage.CleanupCallerAllocated: + return nativeTypeMarshaller.GenerateCleanupCallerAllocatedResourcesStatements(context); + case StubIdentifierContext.Stage.CleanupCalleeAllocated: + return nativeTypeMarshaller.GenerateCleanupCalleeAllocatedResourcesStatements(context); default: break; } @@ -103,23 +88,17 @@ public IEnumerable Generate(TypePositionInfo info, StubCodeCont return Array.Empty(); } - private bool ShouldGenerateByValueOutMarshalling(TypePositionInfo info, StubCodeContext context) - { - return - info.ByValueContentsMarshalKind.HasFlag(ByValueContentsMarshalKind.Out) - && _byValueContentsMarshallingSupport.GetSupport(info.ByValueContentsMarshalKind, info, context, out _) != ByValueMarshalKindSupport.NotSupported - && !info.IsByRef - && !_isPinned; - } + private bool ShouldGenerateByValueOutMarshalling + => TypeInfo.ByValueContentsMarshalKind.HasFlag(ByValueContentsMarshalKind.Out) + && byValueContentsMarshallingSupport.GetSupport(TypeInfo.ByValueContentsMarshalKind, TypeInfo, out _) != ByValueMarshalKindSupport.NotSupported + && !TypeInfo.IsByRef + && !isPinned; - public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) - { - return _nativeTypeMarshaller.UsesNativeIdentifier(info, context); - } + public bool UsesNativeIdentifier => nativeTypeMarshaller.UsesNativeIdentifier; - public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, StubCodeContext context, out GeneratorDiagnostic? diagnostic) + public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, out GeneratorDiagnostic? diagnostic) { - return _byValueContentsMarshallingSupport.GetSupport(marshalKind, info, context, out diagnostic); + return byValueContentsMarshallingSupport.GetSupport(marshalKind, TypeInfo, out diagnostic); } } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/DefaultMarshallingGeneratorResolver.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/DefaultMarshallingGeneratorResolver.cs index 005e9b79ed2..68efe7aaae7 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/DefaultMarshallingGeneratorResolver.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/DefaultMarshallingGeneratorResolver.cs @@ -27,8 +27,9 @@ public static IMarshallingGeneratorResolver Create( IMarshallingGeneratorResolver fallbackResolver = new NotSupportedResolver(); List coreResolvers = [ .. additionalResolvers, + new BlittableMarshallerResolver(env.HasFlag(EnvironmentFlags.DisableRuntimeMarshalling)), new MarshalAsMarshallingGeneratorResolver(new InteropGenerationOptions(UseMarshalType: true)), - new NoMarshallingInfoErrorResolver(TypeNames.GeneratedComInterfaceAttribute_ShortName), + new NoMarshallingInfoErrorResolver(stringMarshallingAttribute), ]; // Since the char type in an array will not be part of the P/Invoke signature, we can diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/DelegateMarshaller.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/DelegateMarshaller.cs index 5f52ad6e4e7..180442555d0 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/DelegateMarshaller.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/DelegateMarshaller.cs @@ -10,7 +10,7 @@ namespace Microsoft.Interop { - public sealed class DelegateMarshaller : IMarshallingGenerator + public sealed class DelegateMarshaller : IUnboundMarshallingGenerator { public ManagedTypeInfo AsNativeType(TypePositionInfo info) { @@ -27,15 +27,15 @@ public ValueBoundaryBehavior GetValueBoundaryBehavior(TypePositionInfo info, Stu return info.IsByRef ? ValueBoundaryBehavior.AddressOfNativeIdentifier : ValueBoundaryBehavior.NativeIdentifier; } - public IEnumerable Generate(TypePositionInfo info, StubCodeContext context) + public IEnumerable Generate(TypePositionInfo info, StubCodeContext codeContext, StubIdentifierContext context) { - MarshalDirection elementMarshalDirection = MarshallerHelpers.GetMarshalDirection(info, context); + MarshalDirection elementMarshalDirection = MarshallerHelpers.GetMarshalDirection(info, codeContext); (string managedIdentifier, string nativeIdentifier) = context.GetIdentifiers(info); switch (context.CurrentStage) { - case StubCodeContext.Stage.Setup: + case StubIdentifierContext.Stage.Setup: break; - case StubCodeContext.Stage.Marshal: + case StubIdentifierContext.Stage.Marshal: if (elementMarshalDirection is MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional) { // = != null ? Marshal.GetFunctionPointerForDelegate() : default; @@ -54,7 +54,7 @@ public IEnumerable Generate(TypePositionInfo info, StubCodeCont LiteralExpression(SyntaxKind.DefaultLiteralExpression))); } break; - case StubCodeContext.Stage.Unmarshal: + case StubIdentifierContext.Stage.Unmarshal: if (elementMarshalDirection is MarshalDirection.UnmanagedToManaged or MarshalDirection.Bidirectional) { // = != default : Marshal.GetDelegateForFunctionPointer<>() : null; @@ -76,7 +76,7 @@ public IEnumerable Generate(TypePositionInfo info, StubCodeCont LiteralExpression(SyntaxKind.NullLiteralExpression))); } break; - case StubCodeContext.Stage.NotifyForSuccessfulInvoke: + case StubIdentifierContext.Stage.NotifyForSuccessfulInvoke: if (elementMarshalDirection is MarshalDirection.ManagedToUnmanaged or MarshalDirection.Bidirectional) { yield return ExpressionStatement( @@ -92,7 +92,7 @@ public IEnumerable Generate(TypePositionInfo info, StubCodeCont public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) => true; - public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, StubCodeContext context, out GeneratorDiagnostic? diagnostic) - => ByValueMarshalKindSupportDescriptor.Default.GetSupport(marshalKind, info, context, out diagnostic); + public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, out GeneratorDiagnostic? diagnostic) + => ByValueMarshalKindSupportDescriptor.Default.GetSupport(marshalKind, info, out diagnostic); } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ElementsMarshalling.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ElementsMarshalling.cs index 633b1249f99..6e1b1d44ba6 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ElementsMarshalling.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ElementsMarshalling.cs @@ -3,6 +3,7 @@ using System; using System.Collections.Generic; +using System.Diagnostics; using System.Linq; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; @@ -14,10 +15,13 @@ namespace Microsoft.Interop { internal interface IElementsMarshallingCollectionSource { - InvocationExpressionSyntax GetUnmanagedValuesDestination(TypePositionInfo info, StubCodeContext context); - InvocationExpressionSyntax GetManagedValuesSource(TypePositionInfo info, StubCodeContext context); - InvocationExpressionSyntax GetUnmanagedValuesSource(TypePositionInfo info, StubCodeContext context); - InvocationExpressionSyntax GetManagedValuesDestination(TypePositionInfo info, StubCodeContext context); + TypePositionInfo TypeInfo { get; } + StubCodeContext CodeContext { get; } + + InvocationExpressionSyntax GetUnmanagedValuesDestination(StubIdentifierContext context); + InvocationExpressionSyntax GetManagedValuesSource(StubIdentifierContext context); + InvocationExpressionSyntax GetUnmanagedValuesSource(StubIdentifierContext context); + InvocationExpressionSyntax GetManagedValuesDestination(StubIdentifierContext context); } internal abstract class ElementsMarshalling @@ -34,12 +38,12 @@ protected ElementsMarshalling(IElementsMarshallingCollectionSource collectionSou /// < GetUnmanagedValuesDestination >.Clear(); /// /// - public StatementSyntax GenerateClearUnmanagedDestination(TypePositionInfo info, StubCodeContext context) + public StatementSyntax GenerateClearUnmanagedDestination(StubIdentifierContext context) { // .Clear(); return MethodInvocationStatement( - CollectionSource.GetUnmanagedValuesDestination(info, context), + CollectionSource.GetUnmanagedValuesDestination(context), IdentifierName("Clear")); } /// @@ -47,28 +51,66 @@ public StatementSyntax GenerateClearUnmanagedDestination(TypePositionInfo info, /// < GetManagedValuesDestination >.Clear(); /// /// - public StatementSyntax GenerateClearManagedValuesDestination(TypePositionInfo info, StubCodeContext context) + public StatementSyntax GenerateClearManagedValuesDestination(StubIdentifierContext context) { // .Clear(); return MethodInvocationStatement( - CollectionSource.GetManagedValuesDestination(info, context), + CollectionSource.GetManagedValuesDestination(context), IdentifierName("Clear")); } - public abstract StatementSyntax GenerateSetupStatement(TypePositionInfo info, StubCodeContext context); - public abstract StatementSyntax GenerateUnmanagedToManagedByValueOutMarshalStatement(TypePositionInfo info, StubCodeContext context); - public abstract StatementSyntax GenerateMarshalStatement(TypePositionInfo info, StubCodeContext context); - public abstract StatementSyntax GenerateManagedToUnmanagedByValueOutUnmarshalStatement(TypePositionInfo info, StubCodeContext context); + public static ExpressionSyntax GenerateNumElementsExpression(CountInfo count, bool countInfoRequiresCast, StubCodeContext codeContext, StubIdentifierContext context) + { + ExpressionSyntax numElementsExpression = count switch + { + SizeAndParamIndexInfo(int size, SizeAndParamIndexInfo.UnspecifiedParam) => GetConstSizeExpression(size), + ConstSizeCountInfo(int size) => GetConstSizeExpression(size), + SizeAndParamIndexInfo(SizeAndParamIndexInfo.UnspecifiedConstSize, TypePositionInfo param) => GetExpressionForParam(param), + SizeAndParamIndexInfo(int size, TypePositionInfo param) => CheckedExpression(SyntaxKind.CheckedExpression, + BinaryExpression(SyntaxKind.AddExpression, + GetConstSizeExpression(size), + GetExpressionForParam(param))), + CountElementCountInfo(TypePositionInfo elementInfo) => GetExpressionForParam(elementInfo), + _ => throw new UnreachableException("Count info should have been verified in generator resolution") + }; - public abstract StatementSyntax GenerateUnmarshalStatement(TypePositionInfo info, StubCodeContext context); - public abstract StatementSyntax GenerateElementCleanupStatement(TypePositionInfo info, StubCodeContext context); + if (countInfoRequiresCast) + { + if (numElementsExpression.IsKind(SyntaxKind.CheckedExpression)) + { + numElementsExpression = ((CheckedExpressionSyntax)numElementsExpression).Expression; + } + numElementsExpression = CheckedExpression(SyntaxKind.CheckedExpression, + CastExpression( + PredefinedType(Token(SyntaxKind.IntKeyword)), + ParenthesizedExpression(numElementsExpression))); + } + + return numElementsExpression; + + static LiteralExpressionSyntax GetConstSizeExpression(int size) + { + return LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(size)); + } + + ExpressionSyntax GetExpressionForParam(TypePositionInfo paramInfo) + { + return MarshallerHelpers.GetIndexedManagedElementExpression(paramInfo, codeContext, context); + } + } + + public abstract StatementSyntax GenerateSetupStatement(StubIdentifierContext context); + public abstract StatementSyntax GenerateUnmanagedToManagedByValueOutMarshalStatement(StubIdentifierContext context); + public abstract StatementSyntax GenerateMarshalStatement(StubIdentifierContext context); + public abstract StatementSyntax GenerateManagedToUnmanagedByValueOutUnmarshalStatement(StubIdentifierContext context); + + public abstract StatementSyntax GenerateUnmarshalStatement(StubIdentifierContext context); + public abstract StatementSyntax GenerateElementCleanupStatement(StubIdentifierContext context); } -#pragma warning disable SA1400 // Access modifier should be declared https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3659 file static class ElementsMarshallingCollectionSourceExtensions -#pragma warning restore SA1400 // Access modifier should be declared { - public static StatementSyntax GetNumElementsAssignmentFromManagedValuesSource(this IElementsMarshallingCollectionSource source, TypePositionInfo info, StubCodeContext context) + public static StatementSyntax GetNumElementsAssignmentFromManagedValuesSource(this IElementsMarshallingCollectionSource source, TypePositionInfo info, StubIdentifierContext context) { var numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(info, context); // = .Length; @@ -78,11 +120,11 @@ public static StatementSyntax GetNumElementsAssignmentFromManagedValuesSource(th IdentifierName(numElementsIdentifier), MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, - source.GetManagedValuesSource(info, context), + source.GetManagedValuesSource(context), IdentifierName("Length")))); } - public static StatementSyntax GetNumElementsAssignmentFromManagedValuesDestination(this IElementsMarshallingCollectionSource source, TypePositionInfo info, StubCodeContext context) + public static StatementSyntax GetNumElementsAssignmentFromManagedValuesDestination(this IElementsMarshallingCollectionSource source, TypePositionInfo info, StubIdentifierContext context) { var numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(info, context); // = .Length; @@ -92,7 +134,7 @@ public static StatementSyntax GetNumElementsAssignmentFromManagedValuesDestinati IdentifierName(numElementsIdentifier), MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, - source.GetManagedValuesDestination(info, context), + source.GetManagedValuesDestination(context), IdentifierName("Length")))); } } @@ -100,19 +142,12 @@ public static StatementSyntax GetNumElementsAssignmentFromManagedValuesDestinati /// /// Support for marshalling blittable elements /// - internal sealed class BlittableElementsMarshalling : ElementsMarshalling + internal sealed class BlittableElementsMarshalling( + TypeSyntax managedElementType, + TypeSyntax unmanagedElementType, + IElementsMarshallingCollectionSource collectionSource) : ElementsMarshalling(collectionSource) { - private readonly TypeSyntax _managedElementType; - private readonly TypeSyntax _unmanagedElementType; - - public BlittableElementsMarshalling(TypeSyntax managedElementType, TypeSyntax unmanagedElementType, IElementsMarshallingCollectionSource collectionSource) - : base(collectionSource) - { - _managedElementType = managedElementType; - _unmanagedElementType = unmanagedElementType; - } - - public override StatementSyntax GenerateUnmanagedToManagedByValueOutMarshalStatement(TypePositionInfo info, StubCodeContext context) + public override StatementSyntax GenerateUnmanagedToManagedByValueOutMarshalStatement(StubIdentifierContext context) { // MemoryMarshal.CreateSpan(ref MemoryMarshal.GetReference(), .Length) ExpressionSyntax destination = CastToManagedIfNecessary( @@ -123,33 +158,33 @@ public override StatementSyntax GenerateUnmanagedToManagedByValueOutMarshalState MethodInvocation( TypeSyntaxes.System_Runtime_InteropServices_MemoryMarshal, IdentifierName("GetReference"), - Argument(CollectionSource.GetUnmanagedValuesSource(info, context)))), + Argument(CollectionSource.GetUnmanagedValuesSource(context)))), Argument( MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, - CollectionSource.GetUnmanagedValuesSource(info, context), + CollectionSource.GetUnmanagedValuesSource(context), IdentifierName("Length"))))); // .CopyTo(); return MethodInvocationStatement( - CollectionSource.GetManagedValuesDestination(info, context), + CollectionSource.GetManagedValuesDestination(context), IdentifierName("CopyTo"), Argument(destination)); } - public override StatementSyntax GenerateMarshalStatement(TypePositionInfo info, StubCodeContext context) + public override StatementSyntax GenerateMarshalStatement(StubIdentifierContext context) { - ExpressionSyntax destination = CastToManagedIfNecessary(CollectionSource.GetUnmanagedValuesDestination(info, context)); + ExpressionSyntax destination = CastToManagedIfNecessary(CollectionSource.GetUnmanagedValuesDestination(context)); // .CopyTo(); return MethodInvocationStatement( - CollectionSource.GetManagedValuesSource(info, context), + CollectionSource.GetManagedValuesSource(context), IdentifierName("CopyTo"), Argument(destination)); } - public override StatementSyntax GenerateManagedToUnmanagedByValueOutUnmarshalStatement(TypePositionInfo info, StubCodeContext context) + public override StatementSyntax GenerateManagedToUnmanagedByValueOutUnmarshalStatement(StubIdentifierContext context) { - ExpressionSyntax source = CastToManagedIfNecessary(CollectionSource.GetUnmanagedValuesDestination(info, context)); + ExpressionSyntax source = CastToManagedIfNecessary(CollectionSource.GetUnmanagedValuesDestination(context)); // MemoryMarshal.CreateSpan(ref MemoryMarshal.GetReference(), .Length) ExpressionSyntax destination = MethodInvocation( @@ -159,10 +194,10 @@ public override StatementSyntax GenerateManagedToUnmanagedByValueOutUnmarshalSta MethodInvocation( TypeSyntaxes.System_Runtime_InteropServices_MemoryMarshal, IdentifierName("GetReference"), - Argument(CollectionSource.GetManagedValuesSource(info, context)))), + Argument(CollectionSource.GetManagedValuesSource(context)))), Argument( MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, - CollectionSource.GetManagedValuesSource(info, context), + CollectionSource.GetManagedValuesSource(context), IdentifierName("Length")))); // .CopyTo(); @@ -176,21 +211,21 @@ public override StatementSyntax GenerateManagedToUnmanagedByValueOutUnmarshalSta Argument(destination))); } - public override StatementSyntax GenerateUnmarshalStatement(TypePositionInfo info, StubCodeContext context) + public override StatementSyntax GenerateUnmarshalStatement(StubIdentifierContext context) { - ExpressionSyntax source = CastToManagedIfNecessary(CollectionSource.GetUnmanagedValuesSource(info, context)); + ExpressionSyntax source = CastToManagedIfNecessary(CollectionSource.GetUnmanagedValuesSource(context)); // .CopyTo(); return MethodInvocationStatement( source, IdentifierName("CopyTo"), - Argument(CollectionSource.GetManagedValuesDestination(info, context))); + Argument(CollectionSource.GetManagedValuesDestination(context))); } private ExpressionSyntax CastToManagedIfNecessary(ExpressionSyntax expression) { // Skip the cast if the managed and unmanaged element types are the same - if (_unmanagedElementType.IsEquivalentTo(_managedElementType)) + if (unmanagedElementType.IsEquivalentTo(managedElementType)) return expression; // MemoryMarshal.Cast<, >() @@ -200,41 +235,28 @@ private ExpressionSyntax CastToManagedIfNecessary(ExpressionSyntax expression) Identifier("Cast"), TypeArgumentList(SeparatedList(new[] { - _unmanagedElementType, - _managedElementType + unmanagedElementType, + managedElementType }))), Argument(expression)); } - public override StatementSyntax GenerateElementCleanupStatement(TypePositionInfo info, StubCodeContext context) => EmptyStatement(); - public override StatementSyntax GenerateSetupStatement(TypePositionInfo info, StubCodeContext context) => EmptyStatement(); + public override StatementSyntax GenerateElementCleanupStatement(StubIdentifierContext context) => EmptyStatement(); + public override StatementSyntax GenerateSetupStatement(StubIdentifierContext context) => EmptyStatement(); } /// /// Support for marshalling non-blittable elements /// - internal sealed class NonBlittableElementsMarshalling : ElementsMarshalling + internal sealed class NonBlittableElementsMarshalling( + TypeSyntax unmanagedElementType, + IBoundMarshallingGenerator elementMarshaller, + IElementsMarshallingCollectionSource collectionSource) : ElementsMarshalling(collectionSource) { - private readonly TypeSyntax _unmanagedElementType; - private readonly IMarshallingGenerator _elementMarshaller; - private readonly TypePositionInfo _elementInfo; - - public NonBlittableElementsMarshalling( - TypeSyntax unmanagedElementType, - IMarshallingGenerator elementMarshaller, - TypePositionInfo elementInfo, - IElementsMarshallingCollectionSource collectionSource) - : base(collectionSource) - { - _unmanagedElementType = unmanagedElementType; - _elementMarshaller = elementMarshaller; - _elementInfo = elementInfo; - } - - public override StatementSyntax GenerateMarshalStatement(TypePositionInfo info, StubCodeContext context) + public override StatementSyntax GenerateMarshalStatement(StubIdentifierContext context) { - string managedSpanIdentifier = MarshallerHelpers.GetManagedSpanIdentifier(info, context); - string nativeSpanIdentifier = MarshallerHelpers.GetNativeSpanIdentifier(info, context); + string managedSpanIdentifier = MarshallerHelpers.GetManagedSpanIdentifier(CollectionSource.TypeInfo, context); + string nativeSpanIdentifier = MarshallerHelpers.GetNativeSpanIdentifier(CollectionSource.TypeInfo, context); // ReadOnlySpan = // Span = @@ -243,16 +265,16 @@ public override StatementSyntax GenerateMarshalStatement(TypePositionInfo info, var statements = new List() { Declare( - ReadOnlySpanOf(_elementInfo.ManagedType.Syntax), + ReadOnlySpanOf(elementMarshaller.TypeInfo.ManagedType.Syntax), managedSpanIdentifier, - CollectionSource.GetManagedValuesSource(info, context)), + CollectionSource.GetManagedValuesSource(context)), Declare( - SpanOf(_unmanagedElementType), + SpanOf(unmanagedElementType), nativeSpanIdentifier, - CollectionSource.GetUnmanagedValuesDestination(info, context)) + CollectionSource.GetUnmanagedValuesDestination(context)) }; // If it is a multidimensional array, we will just clear each allocated span. - if (ShouldCleanUpAllElements(info, context)) + if (ShouldCleanUpAllElements(CollectionSource.TypeInfo, CollectionSource.CodeContext)) { // .Clear() statements.Add(MethodInvocationStatement( @@ -260,54 +282,53 @@ public override StatementSyntax GenerateMarshalStatement(TypePositionInfo info, IdentifierName("Clear"))); } statements.Add(GenerateContentsMarshallingStatement( - info, context, MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, - IdentifierName(MarshallerHelpers.GetManagedSpanIdentifier(info, context)), + IdentifierName(MarshallerHelpers.GetManagedSpanIdentifier(CollectionSource.TypeInfo, context)), IdentifierName("Length")), - _elementInfo, _elementMarshaller, StubCodeContext.Stage.Marshal)); + elementMarshaller, + StubIdentifierContext.Stage.Marshal)); return Block(statements); } - public override StatementSyntax GenerateUnmarshalStatement(TypePositionInfo info, StubCodeContext context) + public override StatementSyntax GenerateUnmarshalStatement(StubIdentifierContext context) { - string managedSpanIdentifier = MarshallerHelpers.GetManagedSpanIdentifier(info, context); - string nativeSpanIdentifier = MarshallerHelpers.GetNativeSpanIdentifier(info, context); - string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(info, context); + string managedSpanIdentifier = MarshallerHelpers.GetManagedSpanIdentifier(CollectionSource.TypeInfo, context); + string nativeSpanIdentifier = MarshallerHelpers.GetNativeSpanIdentifier(CollectionSource.TypeInfo, context); + string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(CollectionSource.TypeInfo, context); // ReadOnlySpan = // Span = // << unmarshal contents >> return Block( Declare( - ReadOnlySpanOf(_unmanagedElementType), + ReadOnlySpanOf(unmanagedElementType), nativeSpanIdentifier, - CollectionSource.GetUnmanagedValuesSource(info, context)), + CollectionSource.GetUnmanagedValuesSource(context)), Declare( - SpanOf(_elementInfo.ManagedType.Syntax), + SpanOf(elementMarshaller.TypeInfo.ManagedType.Syntax), managedSpanIdentifier, - CollectionSource.GetManagedValuesDestination(info, context)), + CollectionSource.GetManagedValuesDestination(context)), GenerateContentsMarshallingStatement( - info, context, IdentifierName(numElementsIdentifier), - _elementInfo, _elementMarshaller, StubCodeContext.Stage.UnmarshalCapture, - StubCodeContext.Stage.Unmarshal)); + elementMarshaller, + StubIdentifierContext.Stage.UnmarshalCapture, StubIdentifierContext.Stage.Unmarshal)); } - public override StatementSyntax GenerateManagedToUnmanagedByValueOutUnmarshalStatement(TypePositionInfo info, StubCodeContext context) + public override StatementSyntax GenerateManagedToUnmanagedByValueOutUnmarshalStatement(StubIdentifierContext context) { // Use ManagedSource and NativeDestination spans for by-value marshalling since we're just marshalling back the contents, // not the array itself. // This code is ugly since we're now enforcing readonly safety with ReadOnlySpan for all other scenarios, // but this is an uncommon case so we don't want to design the API around enabling just it. - string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(info, context); - string managedSpanIdentifier = MarshallerHelpers.GetManagedSpanIdentifier(info, context); + string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(CollectionSource.TypeInfo, context); + string managedSpanIdentifier = MarshallerHelpers.GetManagedSpanIdentifier(CollectionSource.TypeInfo, context); - var setNumElements = CollectionSource.GetNumElementsAssignmentFromManagedValuesSource(info, context); + var setNumElements = CollectionSource.GetNumElementsAssignmentFromManagedValuesSource(CollectionSource.TypeInfo, context); // Span = MemoryMarshal.CreateSpan(ref Unsafe.AsRef(in .GetPinnableReference(), )); - LocalDeclarationStatementSyntax managedValuesDeclaration = Declare(SpanOf(_elementInfo.ManagedType.Syntax), + LocalDeclarationStatementSyntax managedValuesDeclaration = Declare(SpanOf(elementMarshaller.TypeInfo.ManagedType.Syntax), managedSpanIdentifier, MethodInvocation( TypeSyntaxes.System_Runtime_InteropServices_MemoryMarshal, @@ -318,34 +339,33 @@ public override StatementSyntax GenerateManagedToUnmanagedByValueOutUnmarshalSta IdentifierName("AsRef"), InArgument( MethodInvocation( - CollectionSource.GetManagedValuesSource(info, context), + CollectionSource.GetManagedValuesSource(context), IdentifierName("GetPinnableReference"))))), Argument(IdentifierName(numElementsIdentifier)))); // Span = - string nativeSpanIdentifier = MarshallerHelpers.GetNativeSpanIdentifier(info, context); + string nativeSpanIdentifier = MarshallerHelpers.GetNativeSpanIdentifier(CollectionSource.TypeInfo, context); LocalDeclarationStatementSyntax unmanagedValuesDeclaration = Declare( - SpanOf(_unmanagedElementType), + SpanOf(unmanagedElementType), nativeSpanIdentifier, - CollectionSource.GetUnmanagedValuesDestination(info, context)); + CollectionSource.GetUnmanagedValuesDestination(context)); return Block( setNumElements, managedValuesDeclaration, unmanagedValuesDeclaration, GenerateContentsMarshallingStatement( - info, context, IdentifierName(numElementsIdentifier), - _elementInfo, _elementMarshaller, StubCodeContext.Stage.UnmarshalCapture, - StubCodeContext.Stage.Unmarshal)); + elementMarshaller, + StubIdentifierContext.Stage.UnmarshalCapture, StubIdentifierContext.Stage.Unmarshal)); } - public override StatementSyntax GenerateElementCleanupStatement(TypePositionInfo info, StubCodeContext context) + public override StatementSyntax GenerateElementCleanupStatement(StubIdentifierContext context) { - string nativeSpanIdentifier = MarshallerHelpers.GetNativeSpanIdentifier(info, context); + string nativeSpanIdentifier = MarshallerHelpers.GetNativeSpanIdentifier(CollectionSource.TypeInfo, context); ExpressionSyntax indexConstraintName; - if (!UsesLastIndexMarshalled(info, context)) + if (!UsesLastIndexMarshalled(CollectionSource.TypeInfo, CollectionSource.CodeContext)) { indexConstraintName = MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, IdentifierName(nativeSpanIdentifier), @@ -353,52 +373,50 @@ public override StatementSyntax GenerateElementCleanupStatement(TypePositionInfo } else { - indexConstraintName = IdentifierName(MarshallerHelpers.GetLastIndexMarshalledIdentifier(info, context)); + indexConstraintName = IdentifierName(MarshallerHelpers.GetLastIndexMarshalledIdentifier(CollectionSource.TypeInfo, context)); } StatementSyntax contentsCleanupStatements = GenerateContentsMarshallingStatement( - info, context, indexConstraintName, - _elementInfo, - _elementMarshaller, + elementMarshaller, context.CurrentStage); if (contentsCleanupStatements.IsKind(SyntaxKind.EmptyStatement)) { - if (UsesLastIndexMarshalled(info, context)) + if (UsesLastIndexMarshalled(CollectionSource.TypeInfo, CollectionSource.CodeContext)) { return AssignmentStatement( IdentifierName("_"), - IdentifierName(MarshallerHelpers.GetLastIndexMarshalledIdentifier(info, context))); + IdentifierName(MarshallerHelpers.GetLastIndexMarshalledIdentifier(CollectionSource.TypeInfo, context))); } return EmptyStatement(); } return Block( Declare( - ReadOnlySpanOf(_unmanagedElementType), + ReadOnlySpanOf(unmanagedElementType), nativeSpanIdentifier, - MarshallerHelpers.GetMarshalDirection(info, context) == MarshalDirection.ManagedToUnmanaged - ? CollectionSource.GetUnmanagedValuesDestination(info, context) - : CollectionSource.GetUnmanagedValuesSource(info, context)), + MarshallerHelpers.GetMarshalDirection(CollectionSource.TypeInfo, CollectionSource.CodeContext) == MarshalDirection.ManagedToUnmanaged + ? CollectionSource.GetUnmanagedValuesDestination(context) + : CollectionSource.GetUnmanagedValuesSource(context)), contentsCleanupStatements); } - public override StatementSyntax GenerateUnmanagedToManagedByValueOutMarshalStatement(TypePositionInfo info, StubCodeContext context) + public override StatementSyntax GenerateUnmanagedToManagedByValueOutMarshalStatement(StubIdentifierContext context) { // Use ManagedSource and NativeDestination spans for by-value marshalling since we're just marshalling back the contents, // not the array itself. // This code is ugly since we're now enforcing readonly safety with ReadOnlySpan for all other scenarios, // but this is an uncommon case so we don't want to design the API around enabling just it. - string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(info, context); - string managedSpanIdentifier = MarshallerHelpers.GetManagedSpanIdentifier(info, context); - string nativeSpanIdentifier = MarshallerHelpers.GetNativeSpanIdentifier(info, context); + string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(CollectionSource.TypeInfo, context); + string managedSpanIdentifier = MarshallerHelpers.GetManagedSpanIdentifier(CollectionSource.TypeInfo, context); + string nativeSpanIdentifier = MarshallerHelpers.GetNativeSpanIdentifier(CollectionSource.TypeInfo, context); - var setNumElements = CollectionSource.GetNumElementsAssignmentFromManagedValuesDestination(info, context); + var setNumElements = CollectionSource.GetNumElementsAssignmentFromManagedValuesDestination(CollectionSource.TypeInfo, context); // Span = MemoryMarshal.CreateSpan(ref Unsafe.AsRef(in .GetPinnableReference()), ); LocalDeclarationStatementSyntax unmanagedValuesSource = Declare( - SpanOf(_unmanagedElementType), + SpanOf(unmanagedElementType), nativeSpanIdentifier, MethodInvocation( TypeSyntaxes.System_Runtime_InteropServices_MemoryMarshal, @@ -409,7 +427,7 @@ public override StatementSyntax GenerateUnmanagedToManagedByValueOutMarshalState IdentifierName("AsRef"), InArgument( MethodInvocation( - CollectionSource.GetUnmanagedValuesSource(info, context), + CollectionSource.GetUnmanagedValuesSource(context), IdentifierName("GetPinnableReference"))))), Argument(IdentifierName(numElementsIdentifier)))); @@ -417,23 +435,23 @@ public override StatementSyntax GenerateUnmanagedToManagedByValueOutMarshalState LocalDeclarationStatementSyntax managedValuesDestination = LocalDeclarationStatement(VariableDeclaration( GenericName( Identifier(TypeNames.System_Span), - TypeArgumentList(SingletonSeparatedList(_elementInfo.ManagedType.Syntax))), + TypeArgumentList(SingletonSeparatedList(elementMarshaller.TypeInfo.ManagedType.Syntax))), SingletonSeparatedList( VariableDeclarator( Identifier(managedSpanIdentifier)) .WithInitializer(EqualsValueClause( - CollectionSource.GetManagedValuesDestination(info, context)))))); + CollectionSource.GetManagedValuesDestination(context)))))); - StubCodeContext.Stage[] stagesToGenerate; + StubIdentifierContext.Stage[] stagesToGenerate; // Until we separate CalleeAllocated cleanup and CallerAllocated cleanup in unmanaged to managed, we'll need this hack - if (context.Direction is MarshalDirection.UnmanagedToManaged && info.ByValueContentsMarshalKind is ByValueContentsMarshalKind.Out) + if (CollectionSource.CodeContext.Direction is MarshalDirection.UnmanagedToManaged && CollectionSource.TypeInfo.ByValueContentsMarshalKind is ByValueContentsMarshalKind.Out) { - stagesToGenerate = new[] { StubCodeContext.Stage.Marshal, StubCodeContext.Stage.PinnedMarshal }; + stagesToGenerate = [StubIdentifierContext.Stage.Marshal, StubIdentifierContext.Stage.PinnedMarshal]; } else { - stagesToGenerate = new[] { StubCodeContext.Stage.Marshal, StubCodeContext.Stage.PinnedMarshal, StubCodeContext.Stage.CleanupCallerAllocated, StubCodeContext.Stage.CleanupCalleeAllocated }; + stagesToGenerate = [StubIdentifierContext.Stage.Marshal, StubIdentifierContext.Stage.PinnedMarshal, StubIdentifierContext.Stage.CleanupCallerAllocated, StubIdentifierContext.Stage.CleanupCalleeAllocated]; } return Block( @@ -441,79 +459,123 @@ public override StatementSyntax GenerateUnmanagedToManagedByValueOutMarshalState unmanagedValuesSource, managedValuesDestination, GenerateContentsMarshallingStatement( - info, context, IdentifierName(numElementsIdentifier), - _elementInfo, - new FreeAlwaysOwnedOriginalValueGenerator(_elementMarshaller), + new FreeAlwaysOwnedOriginalValueGenerator(elementMarshaller), stagesToGenerate)); } - private static List GenerateElementStages( - TypePositionInfo info, - StubCodeContext context, - IMarshallingGenerator elementMarshaller, - TypePositionInfo elementInfo, - out LinearCollectionElementMarshallingCodeContext elementSetupSubContext, - out TypePositionInfo localElementInfo, - params StubCodeContext.Stage[] stagesToGeneratePerElement) + private List GenerateElementStages( + StubIdentifierContext context, + IBoundMarshallingGenerator elementMarshaller, + out string indexer, + params StubIdentifierContext.Stage[] stagesToGeneratePerElement) { - string managedSpanIdentifier = MarshallerHelpers.GetManagedSpanIdentifier(info, context); - string nativeSpanIdentifier = MarshallerHelpers.GetNativeSpanIdentifier(info, context); - elementSetupSubContext = new LinearCollectionElementMarshallingCodeContext( - StubCodeContext.Stage.Setup, + string managedSpanIdentifier = MarshallerHelpers.GetManagedSpanIdentifier(CollectionSource.TypeInfo, context); + string nativeSpanIdentifier = MarshallerHelpers.GetNativeSpanIdentifier(CollectionSource.TypeInfo, context); + StubCodeContext elementCodeContext = StubCodeContext.CreateElementMarshallingContext(CollectionSource.CodeContext); + LinearCollectionElementIdentifierContext elementSetupSubContext = new( + context, + elementMarshaller.TypeInfo, managedSpanIdentifier, nativeSpanIdentifier, - context); - - localElementInfo = elementInfo with + elementCodeContext.ElementIndirectionLevel) { - InstanceIdentifier = info.InstanceIdentifier, - RefKind = info.IsByRef ? info.RefKind : info.ByValueContentsMarshalKind.GetRefKindForByValueContentsKind(), - ManagedIndex = info.ManagedIndex, - NativeIndex = info.NativeIndex + CurrentStage = StubIdentifierContext.Stage.Setup, + CodeEmitOptions = context.CodeEmitOptions }; - List elementStatements = new(); - foreach (StubCodeContext.Stage stage in stagesToGeneratePerElement) + indexer = elementSetupSubContext.IndexerIdentifier; + + StubIdentifierContext identifierContext = elementSetupSubContext; + + if (elementMarshaller.NativeType is PointerTypeInfo) { - var elementSubContext = elementSetupSubContext with { CurrentStage = stage }; - elementStatements.AddRange(elementMarshaller.Generate(localElementInfo, elementSubContext)); + identifierContext = new GenericFriendlyPointerIdentifierContext(elementSetupSubContext, elementMarshaller.TypeInfo, $"{nativeSpanIdentifier}__{indexer}") + { + CodeEmitOptions = elementSetupSubContext.CodeEmitOptions, + }; } - return elementStatements; + + List elementStatements = []; + foreach (StubIdentifierContext.Stage stage in stagesToGeneratePerElement) + { + var elementIdentifierContext = identifierContext with { CurrentStage = stage }; + elementStatements.AddRange(elementMarshaller.Generate(elementIdentifierContext)); + } + + if (elementStatements.Count == 0) + { + return []; + } + + // Only add the setup stage if we generated code for other stages. + elementStatements.InsertRange(0, elementMarshaller.Generate(identifierContext with { CurrentStage = StubIdentifierContext.Stage.Setup })); + + if (identifierContext is not GenericFriendlyPointerIdentifierContext) + { + // If we didn't need to account for pointer types, we have the statements we need. + return elementStatements; + } + + // If we have the generic friendly pointer context, we need to declare the special identifier and assign to/from it. + + // = ()[i]; + StatementSyntax exactTypeDeclaration = + LocalDeclarationStatement( + VariableDeclaration( + elementMarshaller.NativeType.Syntax, + SingletonSeparatedList( + VariableDeclarator( + Identifier(identifierContext.GetIdentifiers(elementMarshaller.TypeInfo).native)) + .WithInitializer( + EqualsValueClause( + CastExpression(elementMarshaller.NativeType.Syntax, + ParseExpression(elementSetupSubContext.GetIdentifiers(elementMarshaller.TypeInfo).native))))))); + + if (stagesToGeneratePerElement.Any(stage => stage is StubIdentifierContext.Stage.Marshal or StubIdentifierContext.Stage.PinnedMarshal)) + { + // [i] = (); + StatementSyntax propagateResult = AssignmentStatement( + ParseExpression(elementSetupSubContext.GetIdentifiers(elementMarshaller.TypeInfo).native), + CastExpression(TypeSyntaxes.System_IntPtr, + IdentifierName(identifierContext.GetIdentifiers(elementMarshaller.TypeInfo).native))); + + return + [ + exactTypeDeclaration, + ..elementStatements, + propagateResult + ]; + } + + return [ + exactTypeDeclaration, + ..elementStatements + ]; } - private static StatementSyntax GenerateContentsMarshallingStatement( - TypePositionInfo info, - StubCodeContext context, + private StatementSyntax GenerateContentsMarshallingStatement( + StubIdentifierContext context, ExpressionSyntax lengthExpression, - TypePositionInfo elementInfo, - IMarshallingGenerator elementMarshaller, - params StubCodeContext.Stage[] stagesToGeneratePerElement) + IBoundMarshallingGenerator elementMarshaller, + params StubIdentifierContext.Stage[] stagesToGeneratePerElement) { - var elementStatements = GenerateElementStages(info, context, elementMarshaller, elementInfo, out var elementSetupSubContext, out var localElementInfo, stagesToGeneratePerElement); + var elementStatements = GenerateElementStages(context, elementMarshaller, out string indexer, stagesToGeneratePerElement); if (elementStatements.Count != 0) { - StatementSyntax marshallingStatement = Block( - List(elementMarshaller.Generate(localElementInfo, elementSetupSubContext) - .Concat(elementStatements))); - - if (elementMarshaller.AsNativeType(elementInfo).Syntax is PointerTypeSyntax elementNativeType) - { - PointerNativeTypeAssignmentRewriter rewriter = new(elementSetupSubContext.GetIdentifiers(localElementInfo).native, elementNativeType); - marshallingStatement = (StatementSyntax)rewriter.Visit(marshallingStatement); - } + StatementSyntax marshallingStatement = Block(elementStatements); // Iterate through the elements of the native collection to marshal them - var forLoop = ForLoop(elementSetupSubContext.IndexerIdentifier, lengthExpression) + var forLoop = ForLoop(indexer, lengthExpression) .WithStatement(marshallingStatement); // If we're tracking LastIndexMarshalled, increment that each iteration as well. - if (UsesLastIndexMarshalled(info, context) && stagesToGeneratePerElement.Contains(StubCodeContext.Stage.Marshal)) + if (UsesLastIndexMarshalled(CollectionSource.TypeInfo, CollectionSource.CodeContext) && stagesToGeneratePerElement.Contains(StubIdentifierContext.Stage.Marshal)) { forLoop = forLoop.AddIncrementors( PrefixUnaryExpression(SyntaxKind.PreIncrementExpression, - IdentifierName(MarshallerHelpers.GetLastIndexMarshalledIdentifier(info, context)))); + IdentifierName(MarshallerHelpers.GetLastIndexMarshalledIdentifier(CollectionSource.TypeInfo, context)))); } return forLoop; } @@ -538,21 +600,19 @@ private static bool UsesLastIndexMarshalled(TypePositionInfo info, StubCodeConte private static bool ShouldCleanUpAllElements(TypePositionInfo info, StubCodeContext context) { - _ = info; - _ = context; - // AdditionalTemporaryStateLivesAcrossStages implies that it is an outer collection + // ElementIndirectionLevel != 0 means that we are in a collection // Out parameters means that the contents are created by the P/Invoke and assumed to have successfully created all elements - return !context.AdditionalTemporaryStateLivesAcrossStages || info.ByValueContentsMarshalKind == ByValueContentsMarshalKind.Out || info.RefKind == RefKind.Out || info.IsNativeReturnPosition; + return context.ElementIndirectionLevel != 0 || info.ByValueContentsMarshalKind == ByValueContentsMarshalKind.Out || info.RefKind == RefKind.Out || info.IsNativeReturnPosition; } - public override StatementSyntax GenerateSetupStatement(TypePositionInfo info, StubCodeContext context) - => UsesLastIndexMarshalled(info, context) + public override StatementSyntax GenerateSetupStatement(StubIdentifierContext context) + => UsesLastIndexMarshalled(CollectionSource.TypeInfo, CollectionSource.CodeContext) ? LocalDeclarationStatement( VariableDeclaration( PredefinedType(Token(SyntaxKind.IntKeyword)), SingletonSeparatedList( VariableDeclarator( - Identifier(MarshallerHelpers.GetLastIndexMarshalledIdentifier(info, context)), + Identifier(MarshallerHelpers.GetLastIndexMarshalledIdentifier(CollectionSource.TypeInfo, context)), null, EqualsValueClause(LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(0))))))) : EmptyStatement(); diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/Forwarder.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/Forwarder.cs index 9679a2e7449..f0b804d9f9d 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/Forwarder.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/Forwarder.cs @@ -7,7 +7,7 @@ namespace Microsoft.Interop { - public sealed class Forwarder : IMarshallingGenerator + public sealed class Forwarder : IUnboundMarshallingGenerator { public ManagedTypeInfo AsNativeType(TypePositionInfo info) { @@ -24,14 +24,14 @@ public ValueBoundaryBehavior GetValueBoundaryBehavior(TypePositionInfo info, Stu return ValueBoundaryBehavior.ManagedIdentifier; } - public IEnumerable Generate(TypePositionInfo info, StubCodeContext context) + public IEnumerable Generate(TypePositionInfo info, StubCodeContext codeContext, StubIdentifierContext context) { return Array.Empty(); } public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) => false; - public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, StubCodeContext context, out GeneratorDiagnostic? diagnostic) - => ByValueMarshalKindSupportDescriptor.Default.GetSupport(marshalKind, info, context, out diagnostic); + public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, out GeneratorDiagnostic? diagnostic) + => ByValueMarshalKindSupportDescriptor.Default.GetSupport(marshalKind, info, out diagnostic); } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/GeneratorDiagnostic.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/GeneratorDiagnostic.cs index 02820335ec1..00a13f71cc2 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/GeneratorDiagnostic.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/GeneratorDiagnostic.cs @@ -10,10 +10,9 @@ namespace Microsoft.Interop { public abstract record GeneratorDiagnostic { - private GeneratorDiagnostic(TypePositionInfo typePositionInfo, StubCodeContext stubCodeContext, bool isFatal) + private GeneratorDiagnostic(TypePositionInfo typePositionInfo, bool isFatal) { TypePositionInfo = typePositionInfo; - StubCodeContext = stubCodeContext; IsFatal = isFatal; } @@ -22,12 +21,11 @@ private GeneratorDiagnostic(TypePositionInfo typePositionInfo, StubCodeContext s /// public ImmutableDictionary DiagnosticProperties { get; init; } = ImmutableDictionary.Empty; public TypePositionInfo TypePositionInfo { get; } - public StubCodeContext StubCodeContext { get; } public bool IsFatal { get; } public abstract DiagnosticInfo ToDiagnosticInfo(DiagnosticDescriptor descriptor, Location location, string elementName); - public sealed record NotSupported(TypePositionInfo TypePositionInfo, StubCodeContext Context) : GeneratorDiagnostic(TypePositionInfo, Context, isFatal: true) + public sealed record NotSupported(TypePositionInfo TypePositionInfo) : GeneratorDiagnostic(TypePositionInfo, isFatal: true) { /// /// [Optional] Specific reason marshalling of the supplied type isn't supported. @@ -44,7 +42,7 @@ public override DiagnosticInfo ToDiagnosticInfo(DiagnosticDescriptor descriptor, } } - public sealed record UnnecessaryData(TypePositionInfo TypePositionInfo, StubCodeContext StubCodeContext, ImmutableArray UnnecessaryDataLocations) : GeneratorDiagnostic(TypePositionInfo, StubCodeContext, isFatal: false) + public sealed record UnnecessaryData(TypePositionInfo TypePositionInfo, ImmutableArray UnnecessaryDataLocations) : GeneratorDiagnostic(TypePositionInfo, isFatal: false) { public required string UnnecessaryDataName { get; init; } public string? UnnecessaryDataDetails { get; init; } @@ -63,7 +61,7 @@ public override DiagnosticInfo ToDiagnosticInfo(DiagnosticDescriptor descriptor, } } - public sealed record NotRecommended(TypePositionInfo TypePositionInfo, StubCodeContext StubCodeContext) : GeneratorDiagnostic(TypePositionInfo, StubCodeContext, isFatal: false) + public sealed record NotRecommended(TypePositionInfo TypePositionInfo) : GeneratorDiagnostic(TypePositionInfo, isFatal: false) { public string? Details { get; init; } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/GenericFriendlyPointerIdentifierContext.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/GenericFriendlyPointerIdentifierContext.cs new file mode 100644 index 00000000000..8400b767e57 --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/GenericFriendlyPointerIdentifierContext.cs @@ -0,0 +1,38 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Text; + +namespace Microsoft.Interop +{ + internal sealed record GenericFriendlyPointerIdentifierContext : StubIdentifierContext + { + private readonly StubIdentifierContext _innerContext; + private readonly TypePositionInfo _adaptedInfo; + private readonly string _nativeIdentifier; + + public GenericFriendlyPointerIdentifierContext(StubIdentifierContext inner, TypePositionInfo adaptedInfo, string baseIdentifier) + { + _innerContext = inner; + _adaptedInfo = adaptedInfo; + _nativeIdentifier = baseIdentifier + "_exactType"; + CurrentStage = inner.CurrentStage; + } + + public override (string managed, string native) GetIdentifiers(TypePositionInfo info) + { + if (info.PositionsEqual(_adaptedInfo)) + { + (string managed, _) = _innerContext.GetIdentifiers(info); + return (managed, _nativeIdentifier); + } + + return _innerContext.GetIdentifiers(info); + } + + public override string GetAdditionalIdentifier(TypePositionInfo info, string name) => _innerContext.GetAdditionalIdentifier(info, name); + } +} diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ICustomTypeMarshallingStrategy.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ICustomTypeMarshallingStrategy.cs index 53223656b7d..649d3e97fac 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ICustomTypeMarshallingStrategy.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ICustomTypeMarshallingStrategy.cs @@ -11,28 +11,32 @@ namespace Microsoft.Interop /// internal interface ICustomTypeMarshallingStrategy { - ManagedTypeInfo AsNativeType(TypePositionInfo info); + TypePositionInfo TypeInfo { get; } - IEnumerable GenerateCleanupCallerAllocatedResourcesStatements(TypePositionInfo info, StubCodeContext context); + StubCodeContext CodeContext { get; } - IEnumerable GenerateCleanupCalleeAllocatedResourcesStatements(TypePositionInfo info, StubCodeContext context); + ManagedTypeInfo NativeType { get; } - IEnumerable GenerateGuaranteedUnmarshalStatements(TypePositionInfo info, StubCodeContext context); + IEnumerable GenerateCleanupCallerAllocatedResourcesStatements(StubIdentifierContext context); - IEnumerable GenerateMarshalStatements(TypePositionInfo info, StubCodeContext context); + IEnumerable GenerateCleanupCalleeAllocatedResourcesStatements(StubIdentifierContext context); - IEnumerable GenerateNotifyForSuccessfulInvokeStatements(TypePositionInfo info, StubCodeContext context); + IEnumerable GenerateGuaranteedUnmarshalStatements(StubIdentifierContext context); - IEnumerable GeneratePinnedMarshalStatements(TypePositionInfo info, StubCodeContext context); + IEnumerable GenerateMarshalStatements(StubIdentifierContext context); - IEnumerable GeneratePinStatements(TypePositionInfo info, StubCodeContext context); + IEnumerable GenerateNotifyForSuccessfulInvokeStatements(StubIdentifierContext context); - IEnumerable GenerateSetupStatements(TypePositionInfo info, StubCodeContext context); + IEnumerable GeneratePinnedMarshalStatements(StubIdentifierContext context); - IEnumerable GenerateUnmarshalCaptureStatements(TypePositionInfo info, StubCodeContext context); + IEnumerable GeneratePinStatements(StubIdentifierContext context); - IEnumerable GenerateUnmarshalStatements(TypePositionInfo info, StubCodeContext context); + IEnumerable GenerateSetupStatements(StubIdentifierContext context); - bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context); + IEnumerable GenerateUnmarshalCaptureStatements(StubIdentifierContext context); + + IEnumerable GenerateUnmarshalStatements(StubIdentifierContext context); + + bool UsesNativeIdentifier { get; } } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/IMarshallingGeneratorResolver.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/IMarshallingGeneratorResolver.cs index 1a66935fda9..272d0a58701 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/IMarshallingGeneratorResolver.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/IMarshallingGeneratorResolver.cs @@ -8,7 +8,7 @@ namespace Microsoft.Interop public interface IMarshallingGeneratorResolver { /// - /// Create an instance for marshalling the supplied type in the given position and collect any diagnostics from generator resolution. + /// Create an instance for marshalling the supplied type in the given position and collect any diagnostics from generator resolution. /// /// Type details /// Metadata about the stub the type is associated with diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshalAsMarshallingGeneratorResolver.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshalAsMarshallingGeneratorResolver.cs index 05d9b5ab31c..6f4721b71fd 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshalAsMarshallingGeneratorResolver.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshalAsMarshallingGeneratorResolver.cs @@ -26,11 +26,11 @@ public MarshalAsMarshallingGeneratorResolver(InteropGenerationOptions options) } /// - /// Create an instance for marshalling the supplied type in the given position. + /// Create an instance for marshalling the supplied type in the given position. /// /// Type details /// Metadata about the stub the type is associated with - /// A instance. + /// A instance. public ResolvedGenerator Create( TypePositionInfo info, StubCodeContext context) @@ -51,7 +51,7 @@ public ResolvedGenerator Create( or { ManagedType: SpecialTypeInfo { SpecialType: SpecialType.System_Single }, MarshallingAttributeInfo: NoMarshallingInfo or MarshalAsInfo(UnmanagedType.R4, _) } or { ManagedType: SpecialTypeInfo { SpecialType: SpecialType.System_Double }, MarshallingAttributeInfo: NoMarshallingInfo or MarshalAsInfo(UnmanagedType.R8, _) }: // TODO: Report the MarshalAs attribute as unnecessary - return ResolvedGenerator.Resolved(s_blittable); + return ResolvedGenerator.Resolved(s_blittable.Bind(info, context)); // Enum with no marshalling info case { ManagedType: EnumTypeInfo enumType, MarshallingAttributeInfo: NoMarshallingInfo }: @@ -59,37 +59,37 @@ public ResolvedGenerator Create( SpecialType underlyingSpecialType = enumType.UnderlyingType; if (underlyingSpecialType == SpecialType.System_Boolean || underlyingSpecialType == SpecialType.System_Char) { - return ResolvedGenerator.NotSupported(new(info, context)); + return ResolvedGenerator.NotSupported(info, context, new(info)); } - return ResolvedGenerator.Resolved(s_blittable); + return ResolvedGenerator.Resolved(s_blittable.Bind(info, context)); // Pointer with no marshalling info case { ManagedType: PointerTypeInfo{ IsFunctionPointer: false }, MarshallingAttributeInfo: NoMarshallingInfo }: - return ResolvedGenerator.Resolved(s_blittable); + return ResolvedGenerator.Resolved(s_blittable.Bind(info, context)); // Function pointer with no marshalling info case { ManagedType: PointerTypeInfo { IsFunctionPointer: true }, MarshallingAttributeInfo: NoMarshallingInfo or MarshalAsInfo(UnmanagedType.FunctionPtr, _) }: - return ResolvedGenerator.Resolved(s_blittable); + return ResolvedGenerator.Resolved(s_blittable.Bind(info, context)); // Bool with marshalling info case { ManagedType: SpecialTypeInfo { SpecialType: SpecialType.System_Boolean }, MarshallingAttributeInfo: MarshalAsInfo(UnmanagedType.U1, _) }: - return ResolvedGenerator.Resolved(s_byteBool); + return ResolvedGenerator.Resolved(s_byteBool.Bind(info, context)); case { ManagedType: SpecialTypeInfo { SpecialType: SpecialType.System_Boolean }, MarshallingAttributeInfo: MarshalAsInfo(UnmanagedType.I1, _) }: - return ResolvedGenerator.Resolved(s_signed_byteBool); + return ResolvedGenerator.Resolved(s_signed_byteBool.Bind(info, context)); case { ManagedType: SpecialTypeInfo { SpecialType: SpecialType.System_Boolean }, MarshallingAttributeInfo: MarshalAsInfo(UnmanagedType.U4, _) }: - return ResolvedGenerator.Resolved(s_winBool); + return ResolvedGenerator.Resolved(s_winBool.Bind(info, context)); case { ManagedType: SpecialTypeInfo { SpecialType: SpecialType.System_Boolean }, MarshallingAttributeInfo: MarshalAsInfo(UnmanagedType.I4 or UnmanagedType.Bool, _) }: - return ResolvedGenerator.Resolved(s_signed_winBool); + return ResolvedGenerator.Resolved(s_signed_winBool.Bind(info, context)); case { ManagedType: SpecialTypeInfo { SpecialType: SpecialType.System_Boolean }, MarshallingAttributeInfo: MarshalAsInfo(UnmanagedType.VariantBool, _) }: - return ResolvedGenerator.Resolved(s_variantBool); + return ResolvedGenerator.Resolved(s_variantBool.Bind(info, context)); // Delegate types case { ManagedType: DelegateTypeInfo, MarshallingAttributeInfo: NoMarshallingInfo or MarshalAsInfo(UnmanagedType.FunctionPtr, _) }: - return ResolvedGenerator.Resolved(s_delegate); + return ResolvedGenerator.Resolved(s_delegate.Bind(info, context)); // void case { ManagedType: SpecialTypeInfo { SpecialType: SpecialType.System_Void } }: - return ResolvedGenerator.Resolved(s_forwarder); + return ResolvedGenerator.Resolved(s_forwarder.Bind(info, context)); default: return ResolvedGenerator.UnresolvedGenerator; diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshallerHelpers.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshallerHelpers.cs index 25e09c52a60..7c7e4b5c609 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshallerHelpers.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshallerHelpers.cs @@ -61,31 +61,47 @@ public static StatementSyntax CreateGetLastSystemErrorStatement(string lastError public static StatementSyntax CreateSetLastPInvokeErrorStatement(string lastErrorIdentifier) => MethodInvocationStatement(TypeSyntaxes.System_Runtime_InteropServices_Marshal, IdentifierName("SetLastPInvokeError"), Argument(IdentifierName(lastErrorIdentifier))); - public static string GetMarshallerIdentifier(TypePositionInfo info, StubCodeContext context) + public static string GetMarshallerIdentifier(TypePositionInfo info, StubIdentifierContext context) { return context.GetAdditionalIdentifier(info, "marshaller"); } - public static string GetManagedSpanIdentifier(TypePositionInfo info, StubCodeContext context) + public static string GetManagedSpanIdentifier(TypePositionInfo info, StubIdentifierContext context) { return context.GetAdditionalIdentifier(info, "managedSpan"); } - public static string GetNativeSpanIdentifier(TypePositionInfo info, StubCodeContext context) + public static string GetNativeSpanIdentifier(TypePositionInfo info, StubIdentifierContext context) { return context.GetAdditionalIdentifier(info, "nativeSpan"); } - public static string GetNumElementsIdentifier(TypePositionInfo info, StubCodeContext context) + public static string GetNumElementsIdentifier(TypePositionInfo info, StubIdentifierContext context) { return context.GetAdditionalIdentifier(info, "numElements"); } - public static string GetLastIndexMarshalledIdentifier(TypePositionInfo info, StubCodeContext context) + public static string GetLastIndexMarshalledIdentifier(TypePositionInfo info, StubIdentifierContext context) { return context.GetAdditionalIdentifier(info, "lastIndexMarshalled"); } + public static string GetIndexerIdentifier(int i) + { + return $"__i{i}"; + } + + public static ExpressionSyntax GetIndexedManagedElementExpression(TypePositionInfo info, StubCodeContext codeContext, StubIdentifierContext context) + { + ExpressionSyntax indexedManagedElement = IdentifierName(context.GetIdentifiers(info).managed); + for (int i = 0; i < codeContext.ElementIndirectionLevel; i++) + { + indexedManagedElement = ElementAccessExpression(indexedManagedElement) + .AddArgumentListArguments(Argument(IdentifierName(GetIndexerIdentifier(i)))); + } + return indexedManagedElement; + } + internal static bool CanUseCallerAllocatedBuffer(TypePositionInfo info, StubCodeContext context) { return context.SingleFrameSpansNativeContext && (!info.IsByRef || info.RefKind == RefKind.In || info.RefKind == RefKind.RefReadOnlyParameter); @@ -241,7 +257,7 @@ public static IEnumerable GetDependentElementsOfMarshallingInf } // private static readonly InvocationExpressionSyntax SkipInitInvocation = - public static StatementSyntax SkipInitOrDefaultInit(TypePositionInfo info, StubCodeContext context) + public static StatementSyntax SkipInitOrDefaultInit(TypePositionInfo info, StubIdentifierContext context) { if (info.ManagedType is not PointerTypeInfo && info.ManagedType is not ValueTypeInfo { IsByRefLike: true } @@ -263,7 +279,7 @@ public static StatementSyntax SkipInitOrDefaultInit(TypePositionInfo info, StubC } } - public static StatementSyntax DefaultInit(TypePositionInfo info, StubCodeContext context) + public static StatementSyntax DefaultInit(TypePositionInfo info, StubIdentifierContext context) { // Assign out params to default return AssignmentStatement( @@ -334,19 +350,19 @@ public static MarshalDirection GetMarshalDirection(TypePositionInfo info, StubCo /// /// Returns which stage cleanup should be performed for the parameter. /// - public static StubCodeContext.Stage GetCleanupStage(TypePositionInfo info, StubCodeContext context) + public static StubIdentifierContext.Stage GetCleanupStage(TypePositionInfo info, StubCodeContext context) { // Unmanaged to managed doesn't properly handle lifetimes right now and will default to the original behavior. // Failures will only occur when marshalling fails, and would only cause leaks, not double frees. // See https://github.com/dotnet/runtime/issues/89483 for more details if (context.Direction is MarshalDirection.UnmanagedToManaged) - return StubCodeContext.Stage.CleanupCallerAllocated; + return StubIdentifierContext.Stage.CleanupCallerAllocated; return GetMarshalDirection(info, context) switch { - MarshalDirection.UnmanagedToManaged => StubCodeContext.Stage.CleanupCalleeAllocated, - MarshalDirection.ManagedToUnmanaged => StubCodeContext.Stage.CleanupCallerAllocated, - MarshalDirection.Bidirectional => StubCodeContext.Stage.CleanupCallerAllocated, + MarshalDirection.UnmanagedToManaged => StubIdentifierContext.Stage.CleanupCalleeAllocated, + MarshalDirection.ManagedToUnmanaged => StubIdentifierContext.Stage.CleanupCallerAllocated, + MarshalDirection.Bidirectional => StubIdentifierContext.Stage.CleanupCallerAllocated, _ => throw new UnreachableException() }; } @@ -446,5 +462,35 @@ public static SyntaxToken GetManagedArgumentRefKindKeyword(TypePositionInfo type _ => throw new NotImplementedException($"Support for some RefKind: {typeInfo.RefKind}") }; } + + /// + /// Compute if the provided element is the return element for the stub that is being generated (not any inner call). + /// + /// The element information + /// true if the element is in the return position for this stub; otherwise, false. + public static bool IsInStubReturnPosition(TypePositionInfo info, MarshalDirection direction) + { + return direction switch + { + MarshalDirection.ManagedToUnmanaged => info.IsManagedReturnPosition, + MarshalDirection.UnmanagedToManaged => info.IsNativeReturnPosition, + _ => throw new ArgumentException("Cannot determine the return position of a bidirectional stub", nameof(direction)), + }; + } + + /// + /// Compute if the provided element is the return element for the invocation in the stub. + /// + /// The element information + /// true if the element is in the return position for the invocation; otherwise, false. + public static bool IsInInvocationReturnPosition(TypePositionInfo info, MarshalDirection direction) + { + return direction switch + { + MarshalDirection.ManagedToUnmanaged => info.IsNativeReturnPosition, + MarshalDirection.UnmanagedToManaged => info.IsManagedReturnPosition, + _ => throw new ArgumentException("Cannot determine the return position of a bidirectional stub", nameof(direction)), + }; + } } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshallingGenerator.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshallingGenerator.cs index a657c5c3865..fad741c769c 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshallingGenerator.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshallingGenerator.cs @@ -18,12 +18,12 @@ public enum SignatureBehavior ManagedTypeAndAttributes, /// - /// The native signature should be the type returned by passed by value. + /// The native signature should be the type returned by passed by value. /// NativeType, /// - /// The native signature should be a pointer to the type returned by passed by value. + /// The native signature should be a pointer to the type returned by passed by value. /// PointerToNativeType } @@ -39,17 +39,17 @@ public enum ValueBoundaryBehavior ManagedIdentifier, /// - /// The native identifier provided by should be passed by value. + /// The native identifier provided by should be passed by value. /// NativeIdentifier, /// - /// The address of the native identifier provided by should be passed by value. + /// The address of the native identifier provided by should be passed by value. /// AddressOfNativeIdentifier, /// - /// The native identifier provided by should be cast to the native type. + /// The native identifier provided by should be cast to the native type. /// CastNativeIdentifier } @@ -80,7 +80,119 @@ public enum ByValueMarshalKindSupport /// /// Interface for generation of marshalling code for P/Invoke stubs /// - public interface IMarshallingGenerator + public interface IBoundMarshallingGenerator + { + /// + /// The managed type and position information this generator is bound to. + /// + TypePositionInfo TypeInfo { get; } + + /// + /// The context into which this generator is bound and will generate code. + /// + StubCodeContext CodeContext { get; } + + /// + /// Get the native type for the bound element of the generator. + /// + ManagedTypeInfo NativeType { get; } + + /// + /// Get the shape that represents the bound element in the native signature + /// + SignatureBehavior NativeSignatureBehavior { get; } + + /// + /// Get the shape of how the value represented by this generator should be passed at the managed/native boundary in the provided + /// + /// Code generation context + /// How to represent the unmanaged value at the managed/unmanaged boundary + ValueBoundaryBehavior ValueBoundaryBehavior { get; } + + /// + /// Generate code for marshalling + /// + /// Code generation context + /// List of statements to be added to the P/Invoke stub + /// + /// The generator should return the appropriate statements based on the + /// of . + /// For , any statements not of type + /// will be ignored. + /// + IEnumerable Generate(StubIdentifierContext context); + + /// + /// Returns whether or not this marshaller uses an identifier for the native value in addition + /// to an identifier for the managed value. + /// + /// Code generation context + /// If the marshaller uses an identifier for the native value, true; otherwise, false. + /// + /// of may not be valid. + /// + bool UsesNativeIdentifier { get; } + + /// + /// Returns if the given ByValueContentsMarshalKind is supported in the current marshalling context. + /// A supported marshal kind has a different behavior than the default behavior. + /// + /// The marshal kind. + /// The TypePositionInfo of the parameter. + /// The marshalling context. + /// + /// The diagnostic to report if the return value is not . + /// It should be non-null if the value is not + /// + /// If the provided is supported and if it is required to specify the requested behavior. + ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, out GeneratorDiagnostic? diagnostic); + } + + /// + /// A bound generator that binds an to a specific . + /// + /// The element info. + /// The unbound generator + internal sealed class BoundMarshallingGenerator(TypePositionInfo info, StubCodeContext context, IUnboundMarshallingGenerator unbound) : IBoundMarshallingGenerator + { + internal bool IsForwarder => unbound is Forwarder; + + internal bool IsBlittable => unbound is BlittableMarshaller; + + public TypePositionInfo TypeInfo => info; + + public StubCodeContext CodeContext => context; + + public ManagedTypeInfo NativeType => unbound.AsNativeType(TypeInfo); + + public SignatureBehavior NativeSignatureBehavior => unbound.GetNativeSignatureBehavior(TypeInfo); + + public IEnumerable Generate(StubIdentifierContext context) => unbound.Generate(TypeInfo, CodeContext, context); + + public ValueBoundaryBehavior ValueBoundaryBehavior => unbound.GetValueBoundaryBehavior(TypeInfo, context); + + public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, out GeneratorDiagnostic? diagnostic) + => unbound.SupportsByValueMarshalKind(marshalKind, TypeInfo, out diagnostic); + + public bool UsesNativeIdentifier => unbound.UsesNativeIdentifier(TypeInfo, context); + } + + public static class UnboundMarshallingGeneratorExtensions + { + /// + /// Bind this marshalling generator to a specific element info. + /// + /// The unbound generator + /// The element info + /// A generator wrapper that is bound to this info. + /// + public static IBoundMarshallingGenerator Bind(this IUnboundMarshallingGenerator unbound, TypePositionInfo info, StubCodeContext context) => new BoundMarshallingGenerator(info, context, unbound); + } + + /// + /// Interface for generation of marshalling code for P/Invoke stubs + /// + public interface IUnboundMarshallingGenerator { /// /// Get the native type syntax for @@ -108,15 +220,16 @@ public interface IMarshallingGenerator /// Generate code for marshalling /// /// Object to marshal - /// Code generation context + /// Code generation context + /// Context to get identifiers /// List of statements to be added to the P/Invoke stub /// /// The generator should return the appropriate statements based on the - /// of . - /// For , any statements not of type + /// of . + /// For , any statements not of type /// will be ignored. /// - IEnumerable Generate(TypePositionInfo info, StubCodeContext context); + IEnumerable Generate(TypePositionInfo info, StubCodeContext codeContext, StubIdentifierContext context); /// /// Returns whether or not this marshaller uses an identifier for the native value in addition @@ -125,9 +238,6 @@ public interface IMarshallingGenerator /// Object to marshal /// Code generation context /// If the marshaller uses an identifier for the native value, true; otherwise, false. - /// - /// of may not be valid. - /// bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context); /// @@ -136,12 +246,11 @@ public interface IMarshallingGenerator /// /// The marshal kind. /// The TypePositionInfo of the parameter. - /// The marshalling context. /// /// The diagnostic to report if the return value is not . /// It should be non-null if the value is not /// /// If the provided is supported and if it is required to specify the requested behavior. - ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, StubCodeContext context, out GeneratorDiagnostic? diagnostic); + ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, out GeneratorDiagnostic? diagnostic); } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshallingGeneratorExtensions.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshallingGeneratorExtensions.cs index 9b9ad2589b1..c54b58cb0e0 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshallingGeneratorExtensions.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/MarshallingGeneratorExtensions.cs @@ -17,13 +17,13 @@ public static class MarshallingGeneratorExtensions /// /// The marshalling generator for this /// Object to marshal - public static TypeSyntax AsReturnType(this IMarshallingGenerator generator, TypePositionInfo info) + public static TypeSyntax AsReturnType(this IBoundMarshallingGenerator generator) { - return generator.GetNativeSignatureBehavior(info) switch + return generator.NativeSignatureBehavior switch { - SignatureBehavior.ManagedTypeAndAttributes => info.ManagedType.Syntax, - SignatureBehavior.NativeType => generator.AsNativeType(info).Syntax, - SignatureBehavior.PointerToNativeType => PointerType(generator.AsNativeType(info).Syntax), + SignatureBehavior.ManagedTypeAndAttributes => generator.TypeInfo.ManagedType.Syntax, + SignatureBehavior.NativeType => generator.NativeType.Syntax, + SignatureBehavior.PointerToNativeType => PointerType(generator.NativeType.Syntax), _ => throw new InvalidOperationException() }; } @@ -33,14 +33,14 @@ public static TypeSyntax AsReturnType(this IMarshallingGenerator generator, Type /// The marshalling generator for this /// Object to marshal /// Attributes for the return type for this , or null if no attributes should be added. - public static AttributeListSyntax? GenerateAttributesForReturnType(this IMarshallingGenerator generator, TypePositionInfo info) + public static AttributeListSyntax? GenerateAttributesForReturnType(this IBoundMarshallingGenerator generator) { - if (generator.GetNativeSignatureBehavior(info) != SignatureBehavior.ManagedTypeAndAttributes) + if (generator.NativeSignatureBehavior != SignatureBehavior.ManagedTypeAndAttributes) { return null; } - if (info.MarshallingAttributeInfo is IForwardedMarshallingInfo forwarded + if (generator.TypeInfo.MarshallingAttributeInfo is IForwardedMarshallingInfo forwarded && forwarded.TryCreateAttributeSyntax(out AttributeSyntax forwardedAttribute)) { return AttributeList(SingletonSeparatedList(forwardedAttribute)); @@ -55,23 +55,22 @@ public static TypeSyntax AsReturnType(this IMarshallingGenerator generator, Type /// Gets a parameter for the unmanaged signature that represents the provided in the given . /// /// The marshalling generator for this - /// Object to marshal /// The stub marshalling context - public static ParameterSyntax AsParameter(this IMarshallingGenerator generator, TypePositionInfo info, StubCodeContext context) + public static ParameterSyntax AsParameter(this IBoundMarshallingGenerator generator, StubIdentifierContext context) { - SignatureBehavior behavior = generator.GetNativeSignatureBehavior(info); + SignatureBehavior behavior = generator.NativeSignatureBehavior; if (behavior == SignatureBehavior.ManagedTypeAndAttributes) { - return GenerateForwardingParameter(info, context.GetIdentifiers(info).managed); + return GenerateForwardingParameter(generator.TypeInfo, context.GetIdentifiers(generator.TypeInfo).managed); } string identifierName; - if (context.Direction == MarshalDirection.ManagedToUnmanaged) + if (generator.CodeContext.Direction == MarshalDirection.ManagedToUnmanaged) { // This name doesn't get introduced into the stub's scope, so we can make it pretty // and reuse the native identifier - identifierName = context.GetIdentifiers(info).native; + identifierName = context.GetIdentifiers(generator.TypeInfo).native; } - else if (context.Direction == MarshalDirection.UnmanagedToManaged) + else if (generator.CodeContext.Direction == MarshalDirection.UnmanagedToManaged) { // This name is introduced into the stub's scope. // When we are passing the managed identifier as-is, we can just use that name everywhere. @@ -79,11 +78,11 @@ public static ParameterSyntax AsParameter(this IMarshallingGenerator generator, // we can use the native identifier. // When we're passing the address of the native identifier, we need to introduce a new name to hold this value // before we assign it to the managed value. - (string managed, string native) = context.GetIdentifiers(info); - string param = context.GetAdditionalIdentifier(info, ParameterIdentifierSuffix); - identifierName = generator.GetValueBoundaryBehavior(info, context) switch + (string managed, string native) = context.GetIdentifiers(generator.TypeInfo); + string param = context.GetAdditionalIdentifier(generator.TypeInfo, ParameterIdentifierSuffix); + identifierName = generator.ValueBoundaryBehavior switch { - ValueBoundaryBehavior.ManagedIdentifier => info.IsByRef ? param : managed, + ValueBoundaryBehavior.ManagedIdentifier => generator.TypeInfo.IsByRef ? param : managed, ValueBoundaryBehavior.NativeIdentifier or ValueBoundaryBehavior.CastNativeIdentifier => native, ValueBoundaryBehavior.AddressOfNativeIdentifier => param, _ => throw new UnreachableException() @@ -96,8 +95,8 @@ public static ParameterSyntax AsParameter(this IMarshallingGenerator generator, return Parameter(Identifier(identifierName)) .WithType(behavior switch { - SignatureBehavior.NativeType => generator.AsNativeType(info).Syntax, - SignatureBehavior.PointerToNativeType => PointerType(generator.AsNativeType(info).Syntax), + SignatureBehavior.NativeType => generator.NativeType.Syntax, + SignatureBehavior.PointerToNativeType => PointerType(generator.NativeType.Syntax), _ => throw new InvalidOperationException() }); } @@ -137,22 +136,24 @@ private static ParameterSyntax GenerateForwardingParameter(TypePositionInfo info /// The marshalling generator for this /// Object to marshal /// Marshalling context - public static ArgumentSyntax AsArgument(this IMarshallingGenerator generator, TypePositionInfo info, StubCodeContext context) + public static ArgumentSyntax AsArgument(this IBoundMarshallingGenerator generator, StubIdentifierContext context) { + TypePositionInfo info = generator.TypeInfo; (string managedIdentifier, string nativeIdentifier) = context.GetIdentifiers(info); - return generator.GetValueBoundaryBehavior(info, context) switch + return generator.ValueBoundaryBehavior switch { ValueBoundaryBehavior.ManagedIdentifier when !info.IsByRef => Argument(IdentifierName(managedIdentifier)), ValueBoundaryBehavior.ManagedIdentifier when info.IsByRef => Argument(IdentifierName(managedIdentifier)).WithRefKindKeyword(MarshallerHelpers.GetManagedArgumentRefKindKeyword(info)), ValueBoundaryBehavior.NativeIdentifier => Argument(IdentifierName(nativeIdentifier)), ValueBoundaryBehavior.AddressOfNativeIdentifier => Argument(PrefixUnaryExpression(SyntaxKind.AddressOfExpression, IdentifierName(nativeIdentifier))), - ValueBoundaryBehavior.CastNativeIdentifier => Argument(CastExpression(generator.AsParameter(info, context).Type, IdentifierName(nativeIdentifier))), + ValueBoundaryBehavior.CastNativeIdentifier => Argument(CastExpression(generator.AsParameter(context).Type, IdentifierName(nativeIdentifier))), _ => throw new InvalidOperationException() }; } - public static ArgumentSyntax AsManagedArgument(this IMarshallingGenerator generator, TypePositionInfo info, StubCodeContext context) + public static ArgumentSyntax AsManagedArgument(this IBoundMarshallingGenerator generator, StubIdentifierContext context) { + TypePositionInfo info = generator.TypeInfo; var (managedIdentifier, _) = context.GetIdentifiers(info); if (info.IsByRef) { @@ -161,10 +162,15 @@ public static ArgumentSyntax AsManagedArgument(this IMarshallingGenerator genera return Argument(IdentifierName(managedIdentifier)); } - public static ExpressionSyntax GenerateNativeByRefInitialization(this IMarshallingGenerator generator, TypePositionInfo info, StubCodeContext context) + public static ExpressionSyntax GenerateNativeByRefInitialization(this IBoundMarshallingGenerator generator, StubIdentifierContext context) { + TypePositionInfo info = generator.TypeInfo; string paramIdentifier = context.GetAdditionalIdentifier(info, ParameterIdentifierSuffix); return RefExpression(PrefixUnaryExpression(SyntaxKind.PointerIndirectionExpression, IdentifierName(paramIdentifier))); } + + public static bool IsForwarder(this IBoundMarshallingGenerator generator) => generator is BoundMarshallingGenerator { IsForwarder: true }; + + public static bool IsBlittable(this IBoundMarshallingGenerator generator) => generator is BoundMarshallingGenerator { IsBlittable: true }; } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/NoMarshallingInfoErrorResolver.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/NoMarshallingInfoErrorResolver.cs index 4b57fb6c9ce..be147193594 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/NoMarshallingInfoErrorResolver.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/NoMarshallingInfoErrorResolver.cs @@ -17,7 +17,7 @@ public ResolvedGenerator Create( { if (info.MarshallingAttributeInfo is NoMarshallingInfo && CustomTypeToErrorMessageMap.TryGetValue(info.ManagedType, out string errorMessage)) { - return ResolvedGenerator.NotSupported(new(info, context) + return ResolvedGenerator.NotSupported(info, context, new(info) { NotSupportedDetails = errorMessage }); diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/NotSupportedResolver.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/NotSupportedResolver.cs index 9b3d5e30885..212e194e1ee 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/NotSupportedResolver.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/NotSupportedResolver.cs @@ -6,6 +6,6 @@ namespace Microsoft.Interop public sealed class NotSupportedResolver : IMarshallingGeneratorResolver { public ResolvedGenerator Create(TypePositionInfo info, StubCodeContext context) => - ResolvedGenerator.NotSupported(new(info, context)); + ResolvedGenerator.NotSupported(info, context, new(info)); } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/PointerNativeTypeAssignmentRewriter.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/PointerNativeTypeAssignmentRewriter.cs deleted file mode 100644 index 5f4f5d43a4a..00000000000 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/PointerNativeTypeAssignmentRewriter.cs +++ /dev/null @@ -1,75 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.CSharp; -using Microsoft.CodeAnalysis.CSharp.Syntax; -using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; - -namespace Microsoft.Interop -{ - /// - /// Rewrite assignment expressions to the native identifier to cast to IntPtr. - /// This handles the case where the native type of a non-blittable managed type is a pointer, - /// which are unsupported in generic type parameters. - /// - internal sealed class PointerNativeTypeAssignmentRewriter : CSharpSyntaxRewriter - { - private readonly string _nativeIdentifier; - private readonly PointerTypeSyntax _nativeType; - - public PointerNativeTypeAssignmentRewriter(string nativeIdentifier, PointerTypeSyntax nativeType) - { - _nativeIdentifier = nativeIdentifier; - _nativeType = nativeType; - } - - public override SyntaxNode? VisitVariableDeclarator(VariableDeclaratorSyntax node) - { - if (node.Initializer is null) - { - return base.VisitVariableDeclarator(node); - } - - if (node.Identifier.ToString() == _nativeIdentifier) - { - return node.WithInitializer( - EqualsValueClause( - CastExpression(TypeSyntaxes.System_IntPtr, node.Initializer.Value))); - } - if (node.Initializer.Value.ToString() == _nativeIdentifier) - { - return node.WithInitializer( - EqualsValueClause( - CastExpression(_nativeType, node.Initializer.Value))); - } - - return base.VisitVariableDeclarator(node); - } - - public override SyntaxNode VisitAssignmentExpression(AssignmentExpressionSyntax node) - { - if (node.Left.ToString() == _nativeIdentifier) - { - return node.WithRight( - CastExpression(TypeSyntaxes.System_IntPtr, node.Right)); - } - if (node.Right.ToString() == _nativeIdentifier) - { - return node.WithRight(CastExpression(_nativeType, node.Right)); - } - - return base.VisitAssignmentExpression(node); - } - - public override SyntaxNode? VisitArgument(ArgumentSyntax node) - { - if (node.Expression.ToString() == _nativeIdentifier) - { - return node.WithExpression( - CastExpression(_nativeType, node.Expression)); - } - return base.VisitArgument(node); - } - } -} diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ResolvedGenerator.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ResolvedGenerator.cs index 496a89e4285..b9723cbac35 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ResolvedGenerator.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/ResolvedGenerator.cs @@ -7,7 +7,7 @@ namespace Microsoft.Interop { - public record struct ResolvedGenerator([property: MemberNotNullWhen(true, nameof(ResolvedGenerator.IsResolved), nameof(ResolvedGenerator.IsResolvedWithoutErrors))] IMarshallingGenerator? Generator, ImmutableArray Diagnostics) + public record struct ResolvedGenerator([property: MemberNotNullWhen(true, nameof(ResolvedGenerator.IsResolved), nameof(ResolvedGenerator.IsResolvedWithoutErrors))] IBoundMarshallingGenerator? Generator, ImmutableArray Diagnostics) { private static readonly Forwarder s_forwarder = new(); @@ -17,17 +17,17 @@ public record struct ResolvedGenerator([property: MemberNotNullWhen(true, nameof public readonly bool IsResolved => Generator is not null; - public static ResolvedGenerator Resolved(IMarshallingGenerator generator) + public static ResolvedGenerator Resolved(IBoundMarshallingGenerator generator) { return new(generator, ImmutableArray.Empty); } - public static ResolvedGenerator NotSupported(GeneratorDiagnostic.NotSupported notSupportedDiagnostic) + public static ResolvedGenerator NotSupported(TypePositionInfo info, StubCodeContext context, GeneratorDiagnostic.NotSupported notSupportedDiagnostic) { - return new(s_forwarder, ImmutableArray.Create(notSupportedDiagnostic)); + return new(s_forwarder.Bind(info, context), ImmutableArray.Create(notSupportedDiagnostic)); } - public static ResolvedGenerator ResolvedWithDiagnostics(IMarshallingGenerator generator, ImmutableArray diagnostics) + public static ResolvedGenerator ResolvedWithDiagnostics(IBoundMarshallingGenerator generator, ImmutableArray diagnostics) { return new(generator, diagnostics); } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/StatefulMarshallingStrategy.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/StatefulMarshallingStrategy.cs index 1137f6ceeca..6cc20f83a48 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/StatefulMarshallingStrategy.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/StatefulMarshallingStrategy.cs @@ -10,33 +10,24 @@ namespace Microsoft.Interop { - internal sealed class StatefulValueMarshalling : ICustomTypeMarshallingStrategy + internal sealed class StatefulValueMarshalling(TypePositionInfo info, StubCodeContext stubContext, ManagedTypeInfo marshallerType, ManagedTypeInfo unmanagedType, MarshallerShape shape) : ICustomTypeMarshallingStrategy { internal const string MarshallerIdentifier = "marshaller"; - private readonly ManagedTypeInfo _marshallerType; - private readonly ManagedTypeInfo _unmanagedType; - private readonly MarshallerShape _shape; - public StatefulValueMarshalling(ManagedTypeInfo marshallerType, ManagedTypeInfo unmanagedType, MarshallerShape shape) - { - _marshallerType = marshallerType; - _unmanagedType = unmanagedType; - _shape = shape; - } + public ManagedTypeInfo NativeType => unmanagedType; - public ManagedTypeInfo AsNativeType(TypePositionInfo info) - { - return _unmanagedType; - } + public bool UsesNativeIdentifier => true; + + public TypePositionInfo TypeInfo => info; - public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) => true; + public StubCodeContext CodeContext => stubContext; - public IEnumerable GenerateCleanupCallerAllocatedResourcesStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateCleanupCallerAllocatedResourcesStatements(StubIdentifierContext context) { - if (MarshallerHelpers.GetCleanupStage(info, context) is not StubCodeContext.Stage.CleanupCallerAllocated) + if (MarshallerHelpers.GetCleanupStage(info, stubContext) is not StubIdentifierContext.Stage.CleanupCallerAllocated) yield break; - if (!_shape.HasFlag(MarshallerShape.Free)) + if (!shape.HasFlag(MarshallerShape.Free)) yield break; // .Free(); @@ -45,12 +36,12 @@ public IEnumerable GenerateCleanupCallerAllocatedResourcesState IdentifierName(ShapeMemberNames.Free)); } - public IEnumerable GenerateCleanupCalleeAllocatedResourcesStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateCleanupCalleeAllocatedResourcesStatements(StubIdentifierContext context) { - if (MarshallerHelpers.GetCleanupStage(info, context) is not StubCodeContext.Stage.CleanupCalleeAllocated) + if (MarshallerHelpers.GetCleanupStage(info, stubContext) is not StubIdentifierContext.Stage.CleanupCalleeAllocated) yield break; - if (!_shape.HasFlag(MarshallerShape.Free)) + if (!shape.HasFlag(MarshallerShape.Free)) yield break; // .Free(); @@ -59,9 +50,9 @@ public IEnumerable GenerateCleanupCalleeAllocatedResourcesState IdentifierName(ShapeMemberNames.Free)); } - public IEnumerable GenerateGuaranteedUnmarshalStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateGuaranteedUnmarshalStatements(StubIdentifierContext context) { - if (!_shape.HasFlag(MarshallerShape.GuaranteedUnmarshal)) + if (!shape.HasFlag(MarshallerShape.GuaranteedUnmarshal)) yield break; (string managedIdentifier, _) = context.GetIdentifiers(info); @@ -74,9 +65,9 @@ public IEnumerable GenerateGuaranteedUnmarshalStatements(TypePo IdentifierName(ShapeMemberNames.Value.Stateful.ToManagedFinally))); } - public IEnumerable GenerateMarshalStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateMarshalStatements(StubIdentifierContext context) { - if (!_shape.HasFlag(MarshallerShape.ToUnmanaged)) + if (!shape.HasFlag(MarshallerShape.ToUnmanaged)) yield break; (string managedIdentifier, _) = context.GetIdentifiers(info); @@ -88,9 +79,9 @@ public IEnumerable GenerateMarshalStatements(TypePositionInfo i Argument(IdentifierName(managedIdentifier))); } - public IEnumerable GeneratePinnedMarshalStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GeneratePinnedMarshalStatements(StubIdentifierContext context) { - if (!_shape.HasFlag(MarshallerShape.ToUnmanaged) && !_shape.HasFlag(MarshallerShape.CallerAllocatedBuffer)) + if (!shape.HasFlag(MarshallerShape.ToUnmanaged) && !shape.HasFlag(MarshallerShape.CallerAllocatedBuffer)) yield break; (_, string nativeIdentifier) = context.GetIdentifiers(info); @@ -103,9 +94,9 @@ public IEnumerable GeneratePinnedMarshalStatements(TypePosition IdentifierName(ShapeMemberNames.Value.Stateful.ToUnmanaged))); } - public IEnumerable GenerateUnmarshalStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateUnmarshalStatements(StubIdentifierContext context) { - if (!_shape.HasFlag(MarshallerShape.ToManaged)) + if (!shape.HasFlag(MarshallerShape.ToManaged)) yield break; (string managedIdentifier, _) = context.GetIdentifiers(info); @@ -118,9 +109,9 @@ public IEnumerable GenerateUnmarshalStatements(TypePositionInfo IdentifierName(ShapeMemberNames.Value.Stateful.ToManaged))); } - public IEnumerable GenerateUnmarshalCaptureStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateUnmarshalCaptureStatements(StubIdentifierContext context) { - if (!_shape.HasFlag(MarshallerShape.ToManaged) && !_shape.HasFlag(MarshallerShape.GuaranteedUnmarshal)) + if (!shape.HasFlag(MarshallerShape.ToManaged) && !shape.HasFlag(MarshallerShape.GuaranteedUnmarshal)) yield break; (_, string nativeIdentifier) = context.GetIdentifiers(info); @@ -132,11 +123,11 @@ public IEnumerable GenerateUnmarshalCaptureStatements(TypePosit Argument(IdentifierName(nativeIdentifier))); } - public IEnumerable GenerateSetupStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateSetupStatements(StubIdentifierContext context) { // = new(); LocalDeclarationStatementSyntax declaration = Declare( - _marshallerType.Syntax, + marshallerType.Syntax, context.GetAdditionalIdentifier(info, MarshallerIdentifier), ImplicitObjectCreationExpression(ArgumentList(), initializer: null)); @@ -146,7 +137,7 @@ public IEnumerable GenerateSetupStatements(TypePositionInfo inf // In particular, this can interact poorly with the caller-allocated-buffer marshalling // support and make the simple `marshaller.FromManaged(managed, stackalloc X[i])` expression // illegal. Mark the marshaller type as scoped so the compiler knows that it won't escape. - if (_marshallerType is ValueTypeInfo { IsByRefLike: true }) + if (marshallerType is ValueTypeInfo { IsByRefLike: true }) { declaration = declaration.AddModifiers(Token(SyntaxKind.ScopedKeyword)); } @@ -154,9 +145,9 @@ public IEnumerable GenerateSetupStatements(TypePositionInfo inf yield return declaration; } - public IEnumerable GeneratePinStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GeneratePinStatements(StubIdentifierContext context) { - if (!_shape.HasFlag(MarshallerShape.StatefulPinnableReference)) + if (!shape.HasFlag(MarshallerShape.StatefulPinnableReference)) yield break; string unusedIdentifier = context.GetAdditionalIdentifier(info, "unused"); @@ -170,9 +161,9 @@ public IEnumerable GeneratePinStatements(TypePositionInfo info, EmptyStatement()); } - public IEnumerable GenerateNotifyForSuccessfulInvokeStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateNotifyForSuccessfulInvokeStatements(StubIdentifierContext context) { - if (!_shape.HasFlag(MarshallerShape.OnInvoked)) + if (!shape.HasFlag(MarshallerShape.OnInvoked)) yield break; // .OnInvoked(); @@ -181,7 +172,7 @@ public IEnumerable GenerateNotifyForSuccessfulInvokeStatements( IdentifierName(ShapeMemberNames.Value.Stateful.OnInvoked)); } - public static string GetMarshallerIdentifier(TypePositionInfo info, StubCodeContext context) + public static string GetMarshallerIdentifier(TypePositionInfo info, StubIdentifierContext context) { return context.GetAdditionalIdentifier(info, MarshallerIdentifier); } @@ -190,99 +181,90 @@ public static string GetMarshallerIdentifier(TypePositionInfo info, StubCodeCont /// /// Marshaller that enables support for a stackalloc constructor variant on a native type. /// - internal sealed class StatefulCallerAllocatedBufferMarshalling : ICustomTypeMarshallingStrategy + internal sealed class StatefulCallerAllocatedBufferMarshalling(ICustomTypeMarshallingStrategy innerMarshaller, TypeSyntax marshallerType, TypeSyntax bufferElementType) : ICustomTypeMarshallingStrategy { - private readonly ICustomTypeMarshallingStrategy _innerMarshaller; - private readonly TypeSyntax _marshallerType; - private readonly TypeSyntax _bufferElementType; - - public StatefulCallerAllocatedBufferMarshalling(ICustomTypeMarshallingStrategy innerMarshaller, TypeSyntax marshallerType, TypeSyntax bufferElementType) - { - _innerMarshaller = innerMarshaller; - _marshallerType = marshallerType; - _bufferElementType = bufferElementType; - } - - public ManagedTypeInfo AsNativeType(TypePositionInfo info) - { - return _innerMarshaller.AsNativeType(info); - } + public ManagedTypeInfo NativeType => innerMarshaller.NativeType; - public IEnumerable GenerateCleanupCallerAllocatedResourcesStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateCleanupCallerAllocatedResourcesStatements(StubIdentifierContext context) { - return _innerMarshaller.GenerateCleanupCallerAllocatedResourcesStatements(info, context); + return innerMarshaller.GenerateCleanupCallerAllocatedResourcesStatements(context); } - public IEnumerable GenerateCleanupCalleeAllocatedResourcesStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateCleanupCalleeAllocatedResourcesStatements(StubIdentifierContext context) { - return _innerMarshaller.GenerateCleanupCalleeAllocatedResourcesStatements(info, context); + return innerMarshaller.GenerateCleanupCalleeAllocatedResourcesStatements(context); } - public IEnumerable GenerateMarshalStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateMarshalStatements(StubIdentifierContext context) { - if (MarshallerHelpers.CanUseCallerAllocatedBuffer(info, context)) + if (MarshallerHelpers.CanUseCallerAllocatedBuffer(TypeInfo, CodeContext)) { return GenerateCallerAllocatedBufferMarshalStatements(); } - return _innerMarshaller.GenerateMarshalStatements(info, context); + return innerMarshaller.GenerateMarshalStatements(context); IEnumerable GenerateCallerAllocatedBufferMarshalStatements() { - (string managedIdentifier, _) = context.GetIdentifiers(info); + (string managedIdentifier, _) = context.GetIdentifiers(TypeInfo); // .FromManaged(, stackalloc [.BufferSize]); yield return MethodInvocationStatement( - IdentifierName(context.GetAdditionalIdentifier(info, StatefulValueMarshalling.MarshallerIdentifier)), + IdentifierName(context.GetAdditionalIdentifier(TypeInfo, StatefulValueMarshalling.MarshallerIdentifier)), IdentifierName(ShapeMemberNames.Value.Stateful.FromManaged), Argument(IdentifierName(managedIdentifier)), Argument(StackAllocArrayCreationExpression( ArrayType( - _bufferElementType, + bufferElementType, SingletonList(ArrayRankSpecifier(SingletonSeparatedList( MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, - _marshallerType, + marshallerType, IdentifierName(ShapeMemberNames.BufferSize))))))))); } } - public IEnumerable GeneratePinnedMarshalStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GeneratePinnedMarshalStatements(StubIdentifierContext context) { - return _innerMarshaller.GeneratePinnedMarshalStatements(info, context); + return innerMarshaller.GeneratePinnedMarshalStatements(context); } - public IEnumerable GeneratePinStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GeneratePinStatements(StubIdentifierContext context) { - return _innerMarshaller.GeneratePinStatements(info, context); + return innerMarshaller.GeneratePinStatements(context); } - public IEnumerable GenerateSetupStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateSetupStatements(StubIdentifierContext context) { - return _innerMarshaller.GenerateSetupStatements(info, context); + return innerMarshaller.GenerateSetupStatements(context); } - public IEnumerable GenerateUnmarshalCaptureStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateUnmarshalCaptureStatements(StubIdentifierContext context) { - return _innerMarshaller.GenerateUnmarshalCaptureStatements(info, context); + return innerMarshaller.GenerateUnmarshalCaptureStatements(context); } - public IEnumerable GenerateUnmarshalStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateUnmarshalStatements(StubIdentifierContext context) { - return _innerMarshaller.GenerateUnmarshalStatements(info, context); + return innerMarshaller.GenerateUnmarshalStatements(context); } - public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) - { - return _innerMarshaller.UsesNativeIdentifier(info, context); - } + public bool UsesNativeIdentifier => innerMarshaller.UsesNativeIdentifier; + + public TypePositionInfo TypeInfo => innerMarshaller.TypeInfo; - public IEnumerable GenerateGuaranteedUnmarshalStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateGuaranteedUnmarshalStatements(info, context); - public IEnumerable GenerateNotifyForSuccessfulInvokeStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateNotifyForSuccessfulInvokeStatements(info, context); + public StubCodeContext CodeContext => innerMarshaller.CodeContext; + + public IEnumerable GenerateGuaranteedUnmarshalStatements(StubIdentifierContext context) => innerMarshaller.GenerateGuaranteedUnmarshalStatements(context); + public IEnumerable GenerateNotifyForSuccessfulInvokeStatements(StubIdentifierContext context) => innerMarshaller.GenerateNotifyForSuccessfulInvokeStatements(context); } - internal sealed class StatefulLinearCollectionSource : IElementsMarshallingCollectionSource + internal sealed class StatefulLinearCollectionSource(TypePositionInfo info, StubCodeContext codeContext) : IElementsMarshallingCollectionSource { - public InvocationExpressionSyntax GetUnmanagedValuesDestination(TypePositionInfo info, StubCodeContext context) + public TypePositionInfo TypeInfo => info; + + public StubCodeContext CodeContext => codeContext; + + public InvocationExpressionSyntax GetUnmanagedValuesDestination(StubIdentifierContext context) { string marshaller = StatefulValueMarshalling.GetMarshallerIdentifier(info, context); @@ -292,7 +274,7 @@ public InvocationExpressionSyntax GetUnmanagedValuesDestination(TypePositionInfo IdentifierName(ShapeMemberNames.LinearCollection.Stateful.GetUnmanagedValuesDestination)); } - public InvocationExpressionSyntax GetManagedValuesSource(TypePositionInfo info, StubCodeContext context) + public InvocationExpressionSyntax GetManagedValuesSource(StubIdentifierContext context) { string marshaller = StatefulValueMarshalling.GetMarshallerIdentifier(info, context); @@ -302,7 +284,7 @@ public InvocationExpressionSyntax GetManagedValuesSource(TypePositionInfo info, IdentifierName(ShapeMemberNames.LinearCollection.Stateful.GetManagedValuesSource)); } - public InvocationExpressionSyntax GetUnmanagedValuesSource(TypePositionInfo info, StubCodeContext context) + public InvocationExpressionSyntax GetUnmanagedValuesSource(StubIdentifierContext context) { string marshaller = StatefulValueMarshalling.GetMarshallerIdentifier(info, context); string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(info, context); @@ -314,7 +296,7 @@ public InvocationExpressionSyntax GetUnmanagedValuesSource(TypePositionInfo info Argument(IdentifierName(numElementsIdentifier))); } - public InvocationExpressionSyntax GetManagedValuesDestination(TypePositionInfo info, StubCodeContext context) + public InvocationExpressionSyntax GetManagedValuesDestination(StubIdentifierContext context) { string marshaller = StatefulValueMarshalling.GetMarshallerIdentifier(info, context); string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(info, context); @@ -330,37 +312,23 @@ public InvocationExpressionSyntax GetManagedValuesDestination(TypePositionInfo i /// /// Marshaller that enables support for marshalling elements of a collection via a native type that implements the LinearCollection marshalling spec. /// - internal sealed class StatefulLinearCollectionMarshalling : ICustomTypeMarshallingStrategy + internal sealed class StatefulLinearCollectionMarshalling( + ICustomTypeMarshallingStrategy innerMarshaller, + MarshallerShape shape, + CountInfo countInfo, + bool castCountInfo, + ElementsMarshalling elementsMarshalling, + bool cleanupElements) : ICustomTypeMarshallingStrategy { - private readonly ICustomTypeMarshallingStrategy _innerMarshaller; - private readonly MarshallerShape _shape; - private readonly ExpressionSyntax _numElementsExpression; - private readonly ElementsMarshalling _elementsMarshalling; - private readonly bool _cleanupElements; - - public StatefulLinearCollectionMarshalling( - ICustomTypeMarshallingStrategy innerMarshaller, - MarshallerShape shape, - ExpressionSyntax numElementsExpression, - ElementsMarshalling elementsMarshalling, - bool cleanupElements) - { - _innerMarshaller = innerMarshaller; - _shape = shape; - _numElementsExpression = numElementsExpression; - _elementsMarshalling = elementsMarshalling; - _cleanupElements = cleanupElements; - } - - public ManagedTypeInfo AsNativeType(TypePositionInfo info) => _innerMarshaller.AsNativeType(info); + public ManagedTypeInfo NativeType => innerMarshaller.NativeType; - public IEnumerable GenerateCleanupCallerAllocatedResourcesStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateCleanupCallerAllocatedResourcesStatements(StubIdentifierContext context) { // We don't have anything to cleanup specifically related to this value, just the elements. We let the element marshaller decide whether to cleanup in callee or caller cleanup stage - if (!_cleanupElements) + if (!cleanupElements) yield break; - StatementSyntax elementCleanup = _elementsMarshalling.GenerateElementCleanupStatement(info, context); + StatementSyntax elementCleanup = elementsMarshalling.GenerateElementCleanupStatement(context); if (!elementCleanup.IsKind(SyntaxKind.EmptyStatement)) { @@ -368,13 +336,13 @@ public IEnumerable GenerateCleanupCallerAllocatedResourcesState } } - public IEnumerable GenerateCleanupCalleeAllocatedResourcesStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateCleanupCalleeAllocatedResourcesStatements(StubIdentifierContext context) { // We don't have anything to cleanup specifically related to this value, just the elements. We let the element marshaller decide whether to cleanup in callee or caller cleanup stage - if (!_cleanupElements) + if (!cleanupElements) yield break; - StatementSyntax elementCleanup = _elementsMarshalling.GenerateElementCleanupStatement(info, context); + StatementSyntax elementCleanup = elementsMarshalling.GenerateElementCleanupStatement(context); if (!elementCleanup.IsKind(SyntaxKind.EmptyStatement)) { @@ -382,169 +350,178 @@ public IEnumerable GenerateCleanupCalleeAllocatedResourcesState } } - public IEnumerable GenerateGuaranteedUnmarshalStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateGuaranteedUnmarshalStatements(info, context); + public IEnumerable GenerateGuaranteedUnmarshalStatements(StubIdentifierContext context) => innerMarshaller.GenerateGuaranteedUnmarshalStatements(context); - public IEnumerable GenerateMarshalStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateMarshalStatements(StubIdentifierContext context) { - foreach (StatementSyntax statement in _innerMarshaller.GenerateMarshalStatements(info, context)) + foreach (StatementSyntax statement in innerMarshaller.GenerateMarshalStatements(context)) { yield return statement; } - if (context.Direction == MarshalDirection.ManagedToUnmanaged && !info.IsByRef && info.ByValueContentsMarshalKind == ByValueContentsMarshalKind.Out) + if (CodeContext.Direction == MarshalDirection.ManagedToUnmanaged && !TypeInfo.IsByRef && TypeInfo.ByValueContentsMarshalKind == ByValueContentsMarshalKind.Out) { // If the parameter is marshalled by-value [Out], then we don't marshal the contents of the collection. // We do clear the span, so that if the invoke target doesn't fill it, we aren't left with undefined content. - yield return _elementsMarshalling.GenerateClearUnmanagedDestination(info, context); + yield return elementsMarshalling.GenerateClearUnmanagedDestination(context); yield break; } - if (context.Direction == MarshalDirection.UnmanagedToManaged && !info.IsByRef && info.ByValueContentsMarshalKind.HasFlag(ByValueContentsMarshalKind.Out)) + if (CodeContext.Direction == MarshalDirection.UnmanagedToManaged && !TypeInfo.IsByRef && TypeInfo.ByValueContentsMarshalKind.HasFlag(ByValueContentsMarshalKind.Out)) { // If the parameter is marshalled by-value [Out] or [In, Out], then we need to unmarshal the contents of the collection // into the passed-in collection value. - yield return _elementsMarshalling.GenerateUnmanagedToManagedByValueOutMarshalStatement(info, context); + yield return elementsMarshalling.GenerateUnmanagedToManagedByValueOutMarshalStatement(context); yield break; } - if (!_shape.HasFlag(MarshallerShape.ToUnmanaged) && !_shape.HasFlag(MarshallerShape.CallerAllocatedBuffer)) + if (!shape.HasFlag(MarshallerShape.ToUnmanaged) && !shape.HasFlag(MarshallerShape.CallerAllocatedBuffer)) yield break; - yield return _elementsMarshalling.GenerateMarshalStatement(info, context); + yield return elementsMarshalling.GenerateMarshalStatement(context); } - public IEnumerable GenerateNotifyForSuccessfulInvokeStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateNotifyForSuccessfulInvokeStatements(info, context); - public IEnumerable GeneratePinnedMarshalStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GeneratePinnedMarshalStatements(info, context); - public IEnumerable GeneratePinStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GeneratePinStatements(info, context); - public IEnumerable GenerateSetupStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateNotifyForSuccessfulInvokeStatements(StubIdentifierContext context) => innerMarshaller.GenerateNotifyForSuccessfulInvokeStatements(context); + public IEnumerable GeneratePinnedMarshalStatements(StubIdentifierContext context) => innerMarshaller.GeneratePinnedMarshalStatements(context); + public IEnumerable GeneratePinStatements(StubIdentifierContext context) => innerMarshaller.GeneratePinStatements(context); + public IEnumerable GenerateSetupStatements(StubIdentifierContext context) { - foreach (StatementSyntax statement in _innerMarshaller.GenerateSetupStatements(info, context)) + foreach (StatementSyntax statement in innerMarshaller.GenerateSetupStatements(context)) { yield return statement; } - string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(info, context); - // int ; - yield return Declare( - PredefinedType(Token(SyntaxKind.IntKeyword)), - numElementsIdentifier, - initializeToDefault: false); + // When we're marshalling a collection and its elements only from managed to unmanaged, + // we don't need to declare the numElements local, as it's not used. + if (MarshallerHelpers.GetMarshalDirection(TypeInfo, CodeContext) is not MarshalDirection.ManagedToUnmanaged + || TypeInfo.ByValueContentsMarshalKind != ByValueContentsMarshalKind.Default) + { + string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(TypeInfo, context); + // int ; + yield return Declare( + PredefinedType(Token(SyntaxKind.IntKeyword)), + numElementsIdentifier, + initializeToDefault: false); + + // Use the numElements local to ensure the compiler doesn't give errors for using an uninitialized variable. + // The value may be used in cleanup before it has been initialized, so this is not safe. + yield return MarshallerHelpers.SkipInitOrDefaultInit( + new TypePositionInfo(SpecialTypeInfo.Int32, NoMarshallingInfo.Instance) + { + InstanceIdentifier = numElementsIdentifier + }, context); + } - var elementsSetup = _elementsMarshalling.GenerateSetupStatement(info, context); + var elementsSetup = elementsMarshalling.GenerateSetupStatement(context); if (elementsSetup is not EmptyStatementSyntax) { yield return elementsSetup; } - // Use the numElements local to ensure the compiler doesn't give errors for using an uninitialized variable. - // The value may be used in cleanup before it has been initialized, so this is not safe. - yield return MarshallerHelpers.SkipInitOrDefaultInit( - new TypePositionInfo(SpecialTypeInfo.Int32, NoMarshallingInfo.Instance) - { - InstanceIdentifier = numElementsIdentifier - }, context); } - public IEnumerable GenerateUnmarshalStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateUnmarshalStatements(StubIdentifierContext context) { - if (context.Direction == MarshalDirection.ManagedToUnmanaged && !info.IsByRef && info.ByValueContentsMarshalKind.HasFlag(ByValueContentsMarshalKind.Out)) + if (CodeContext.Direction == MarshalDirection.ManagedToUnmanaged && !TypeInfo.IsByRef && TypeInfo.ByValueContentsMarshalKind.HasFlag(ByValueContentsMarshalKind.Out)) { // If the parameter is marshalled by-value [Out] or [In, Out], then we need to unmarshal the contents of the collection // into the passed-in collection value. - yield return _elementsMarshalling.GenerateManagedToUnmanagedByValueOutUnmarshalStatement(info, context); + yield return elementsMarshalling.GenerateManagedToUnmanagedByValueOutUnmarshalStatement(context); yield break; } - if (context.Direction == MarshalDirection.UnmanagedToManaged && !info.IsByRef && info.ByValueContentsMarshalKind == ByValueContentsMarshalKind.Out) + if (CodeContext.Direction == MarshalDirection.UnmanagedToManaged && !TypeInfo.IsByRef && TypeInfo.ByValueContentsMarshalKind == ByValueContentsMarshalKind.Out) { // If the parameter is marshalled by-value [Out], then we don't marshal the contents of the collection. // We do clear the span, so that if the invoke target doesn't fill it, we aren't left with undefined content. - yield return _elementsMarshalling.GenerateClearManagedValuesDestination(info, context); + yield return elementsMarshalling.GenerateClearManagedValuesDestination(context); yield break; } - if (!_shape.HasFlag(MarshallerShape.ToManaged)) + if (!shape.HasFlag(MarshallerShape.ToManaged)) { yield break; } - string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(info, context); + string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(TypeInfo, context); // = ; - yield return AssignmentStatement(IdentifierName(numElementsIdentifier), _numElementsExpression); + yield return AssignmentStatement(IdentifierName(numElementsIdentifier), ElementsMarshalling.GenerateNumElementsExpression(countInfo, castCountInfo, CodeContext, context)); - yield return _elementsMarshalling.GenerateUnmarshalStatement(info, context); + yield return elementsMarshalling.GenerateUnmarshalStatement(context); - foreach (StatementSyntax statement in _innerMarshaller.GenerateUnmarshalStatements(info, context)) + foreach (StatementSyntax statement in innerMarshaller.GenerateUnmarshalStatements(context)) { yield return statement; } } - public IEnumerable GenerateUnmarshalCaptureStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateUnmarshalCaptureStatements(info, context); + public IEnumerable GenerateUnmarshalCaptureStatements(StubIdentifierContext context) => innerMarshaller.GenerateUnmarshalCaptureStatements(context); + + public bool UsesNativeIdentifier => true; - public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) => true; + public TypePositionInfo TypeInfo => innerMarshaller.TypeInfo; + + public StubCodeContext CodeContext => innerMarshaller.CodeContext; } /// /// Marshaller that enables calling the Free method on a stateful marshaller. /// - internal sealed class StatefulFreeMarshalling : ICustomTypeMarshallingStrategy + internal sealed class StatefulFreeMarshalling(ICustomTypeMarshallingStrategy innerMarshaller) : ICustomTypeMarshallingStrategy { - private readonly ICustomTypeMarshallingStrategy _innerMarshaller; + public ManagedTypeInfo NativeType => innerMarshaller.NativeType; - public StatefulFreeMarshalling(ICustomTypeMarshallingStrategy innerMarshaller) + public IEnumerable GenerateCleanupCallerAllocatedResourcesStatements(StubIdentifierContext context) { - _innerMarshaller = innerMarshaller; - } - - public ManagedTypeInfo AsNativeType(TypePositionInfo info) => _innerMarshaller.AsNativeType(info); - - public IEnumerable GenerateCleanupCallerAllocatedResourcesStatements(TypePositionInfo info, StubCodeContext context) - { - foreach (var statement in _innerMarshaller.GenerateCleanupCallerAllocatedResourcesStatements(info, context)) + foreach (var statement in innerMarshaller.GenerateCleanupCallerAllocatedResourcesStatements(context)) { yield return statement; } - if (MarshallerHelpers.GetCleanupStage(info, context) is not StubCodeContext.Stage.CleanupCallerAllocated) + if (MarshallerHelpers.GetCleanupStage(TypeInfo, CodeContext) is not StubIdentifierContext.Stage.CleanupCallerAllocated) yield break; - string marshaller = StatefulValueMarshalling.GetMarshallerIdentifier(info, context); + string marshaller = StatefulValueMarshalling.GetMarshallerIdentifier(TypeInfo, context); // .Free(); yield return MethodInvocationStatement( IdentifierName(marshaller), IdentifierName(ShapeMemberNames.Free)); } - public IEnumerable GenerateCleanupCalleeAllocatedResourcesStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateCleanupCalleeAllocatedResourcesStatements(StubIdentifierContext context) { - foreach (var statement in _innerMarshaller.GenerateCleanupCalleeAllocatedResourcesStatements(info, context)) + foreach (var statement in innerMarshaller.GenerateCleanupCalleeAllocatedResourcesStatements(context)) { yield return statement; } - if (MarshallerHelpers.GetCleanupStage(info, context) is not StubCodeContext.Stage.CleanupCalleeAllocated) + if (MarshallerHelpers.GetCleanupStage(TypeInfo, CodeContext) is not StubIdentifierContext.Stage.CleanupCalleeAllocated) yield break; - string marshaller = StatefulValueMarshalling.GetMarshallerIdentifier(info, context); + string marshaller = StatefulValueMarshalling.GetMarshallerIdentifier(TypeInfo, context); // .Free(); yield return MethodInvocationStatement( IdentifierName(marshaller), IdentifierName(ShapeMemberNames.Free)); } - public IEnumerable GenerateGuaranteedUnmarshalStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateGuaranteedUnmarshalStatements(info, context); - public IEnumerable GenerateMarshalStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateMarshalStatements(info, context); + public IEnumerable GenerateGuaranteedUnmarshalStatements(StubIdentifierContext context) => innerMarshaller.GenerateGuaranteedUnmarshalStatements(context); + + public IEnumerable GenerateMarshalStatements(StubIdentifierContext context) => innerMarshaller.GenerateMarshalStatements(context); + + public IEnumerable GenerateNotifyForSuccessfulInvokeStatements(StubIdentifierContext context) => innerMarshaller.GenerateNotifyForSuccessfulInvokeStatements(context); + public IEnumerable GeneratePinnedMarshalStatements(StubIdentifierContext context) => innerMarshaller.GeneratePinnedMarshalStatements(context); + public IEnumerable GeneratePinStatements(StubIdentifierContext context) => innerMarshaller.GeneratePinStatements(context); + public IEnumerable GenerateSetupStatements(StubIdentifierContext context) => innerMarshaller.GenerateSetupStatements(context); + + public IEnumerable GenerateUnmarshalStatements(StubIdentifierContext context) => innerMarshaller.GenerateUnmarshalStatements(context); - public IEnumerable GenerateNotifyForSuccessfulInvokeStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateNotifyForSuccessfulInvokeStatements(info, context); - public IEnumerable GeneratePinnedMarshalStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GeneratePinnedMarshalStatements(info, context); - public IEnumerable GeneratePinStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GeneratePinStatements(info, context); - public IEnumerable GenerateSetupStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateSetupStatements(info, context); + public IEnumerable GenerateUnmarshalCaptureStatements(StubIdentifierContext context) => innerMarshaller.GenerateUnmarshalCaptureStatements(context); - public IEnumerable GenerateUnmarshalStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateUnmarshalStatements(info, context); + public bool UsesNativeIdentifier => innerMarshaller.UsesNativeIdentifier; - public IEnumerable GenerateUnmarshalCaptureStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateUnmarshalCaptureStatements(info, context); + public TypePositionInfo TypeInfo => innerMarshaller.TypeInfo; - public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.UsesNativeIdentifier(info, context); + public StubCodeContext CodeContext => innerMarshaller.CodeContext; } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/StatelessMarshallingStrategy.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/StatelessMarshallingStrategy.cs index b15cf616a4d..da13f490614 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/StatelessMarshallingStrategy.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/StatelessMarshallingStrategy.cs @@ -7,39 +7,30 @@ using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; +using static Microsoft.Interop.SyntaxFactoryExtensions; namespace Microsoft.Interop { /// /// Stateless marshalling support for a type that has a custom unmanaged type. /// - internal sealed class StatelessValueMarshalling : ICustomTypeMarshallingStrategy + internal sealed class StatelessValueMarshalling(TypePositionInfo info, StubCodeContext codeContext, TypeSyntax marshallerTypeSyntax, ManagedTypeInfo unmanagedType, MarshallerShape shape) : ICustomTypeMarshallingStrategy { - private readonly TypeSyntax _marshallerTypeSyntax; - private readonly ManagedTypeInfo _unmanagedType; - private readonly MarshallerShape _shape; + public ManagedTypeInfo NativeType => unmanagedType; - public StatelessValueMarshalling(TypeSyntax marshallerTypeSyntax, ManagedTypeInfo unmanagedType, MarshallerShape shape) - { - _marshallerTypeSyntax = marshallerTypeSyntax; - _unmanagedType = unmanagedType; - _shape = shape; - } + public bool UsesNativeIdentifier => true; - public ManagedTypeInfo AsNativeType(TypePositionInfo info) - { - return _unmanagedType; - } + public TypePositionInfo TypeInfo => info; - public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) => true; + public StubCodeContext CodeContext => codeContext; - public IEnumerable GenerateCleanupCallerAllocatedResourcesStatements(TypePositionInfo info, StubCodeContext context) => Array.Empty(); + public IEnumerable GenerateCleanupCallerAllocatedResourcesStatements(StubIdentifierContext context) => Array.Empty(); - public IEnumerable GenerateCleanupCalleeAllocatedResourcesStatements(TypePositionInfo info, StubCodeContext context) => Array.Empty(); + public IEnumerable GenerateCleanupCalleeAllocatedResourcesStatements(StubIdentifierContext context) => Array.Empty(); - public IEnumerable GenerateGuaranteedUnmarshalStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateGuaranteedUnmarshalStatements(StubIdentifierContext context) { - if (!_shape.HasFlag(MarshallerShape.GuaranteedUnmarshal)) + if (!shape.HasFlag(MarshallerShape.GuaranteedUnmarshal)) yield break; (string managedIdentifier, string nativeIdentifier) = context.GetIdentifiers(info); @@ -51,15 +42,15 @@ public IEnumerable GenerateGuaranteedUnmarshalStatements(TypePo IdentifierName(managedIdentifier), InvocationExpression( MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, - _marshallerTypeSyntax, + marshallerTypeSyntax, IdentifierName(ShapeMemberNames.Value.Stateless.ConvertToManagedFinally)), ArgumentList(SingletonSeparatedList( Argument(IdentifierName(nativeIdentifier))))))); } - public IEnumerable GenerateMarshalStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateMarshalStatements(StubIdentifierContext context) { - if (!_shape.HasFlag(MarshallerShape.ToUnmanaged) && !_shape.HasFlag(MarshallerShape.CallerAllocatedBuffer)) + if (!shape.HasFlag(MarshallerShape.ToUnmanaged) && !shape.HasFlag(MarshallerShape.CallerAllocatedBuffer)) yield break; (string managedIdentifier, string nativeIdentifier) = context.GetIdentifiers(info); @@ -67,12 +58,12 @@ public IEnumerable GenerateMarshalStatements(TypePositionInfo i // .ConvertToUnmanaged() ExpressionSyntax convertToUnmanaged = InvocationExpression( MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, - _marshallerTypeSyntax, + marshallerTypeSyntax, IdentifierName(ShapeMemberNames.Value.Stateless.ConvertToUnmanaged)), ArgumentList(SingletonSeparatedList( Argument(IdentifierName(managedIdentifier))))); - if (_unmanagedType == SpecialTypeInfo.Void) + if (unmanagedType == SpecialTypeInfo.Void) { // To support our exception marshalling scenarios, we allow a "marshal to void" marshaller. // In this case, we don't assign the result to the native identifier because there is no native identifier. @@ -81,29 +72,37 @@ public IEnumerable GenerateMarshalStatements(TypePositionInfo i yield break; } - // = ; - var assignment = AssignmentExpression( - SyntaxKind.SimpleAssignmentExpression, - IdentifierName(nativeIdentifier), - convertToUnmanaged); + ExpressionSyntax assignment; - - if (_unmanagedType is PointerTypeInfo pointer) + // For some of our exception marshallers, our marshaller returns nint for pointer types. + // As a result, we need to insert a cast here in case we're in that scenario (which we can't detect specifically). + if (unmanagedType is PointerTypeInfo ptrType) { - var rewriter = new PointerNativeTypeAssignmentRewriter(assignment.Right.ToString(), (PointerTypeSyntax)pointer.Syntax); - assignment = (AssignmentExpressionSyntax)rewriter.Visit(assignment); + // = (); + assignment = AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, + IdentifierName(nativeIdentifier), + CastExpression(ptrType.Syntax, convertToUnmanaged)); } + else + { + // = ; + assignment = AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + IdentifierName(nativeIdentifier), + convertToUnmanaged); + } + yield return ExpressionStatement(assignment); } - public IEnumerable GeneratePinnedMarshalStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GeneratePinnedMarshalStatements(StubIdentifierContext context) { return Array.Empty(); } - public IEnumerable GenerateUnmarshalStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateUnmarshalStatements(StubIdentifierContext context) { - if (!_shape.HasFlag(MarshallerShape.ToManaged)) + if (!shape.HasFlag(MarshallerShape.ToManaged)) yield break; (string managedIdentifier, string nativeIdentifier) = context.GetIdentifiers(info); @@ -115,28 +114,28 @@ public IEnumerable GenerateUnmarshalStatements(TypePositionInfo IdentifierName(managedIdentifier), InvocationExpression( MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, - _marshallerTypeSyntax, + marshallerTypeSyntax, IdentifierName(ShapeMemberNames.Value.Stateless.ConvertToManaged)), ArgumentList(SingletonSeparatedList( Argument(IdentifierName(nativeIdentifier))))))); } - public IEnumerable GenerateUnmarshalCaptureStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateUnmarshalCaptureStatements(StubIdentifierContext context) { return Array.Empty(); } - public IEnumerable GenerateSetupStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateSetupStatements(StubIdentifierContext context) { return Array.Empty(); } - public IEnumerable GeneratePinStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GeneratePinStatements(StubIdentifierContext context) { return Array.Empty(); } - public IEnumerable GenerateNotifyForSuccessfulInvokeStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateNotifyForSuccessfulInvokeStatements(StubIdentifierContext context) { return Array.Empty(); } @@ -145,38 +144,27 @@ public IEnumerable GenerateNotifyForSuccessfulInvokeStatements( /// /// Marshaller that enables support for a stackalloc constructor variant on a native type. /// - internal sealed class StatelessCallerAllocatedBufferMarshalling : ICustomTypeMarshallingStrategy + internal sealed class StatelessCallerAllocatedBufferMarshalling(ICustomTypeMarshallingStrategy innerMarshaller, TypeSyntax marshallerType, TypeSyntax bufferElementType, bool isLinearCollectionMarshalling) : ICustomTypeMarshallingStrategy { - private readonly ICustomTypeMarshallingStrategy _innerMarshaller; - private readonly TypeSyntax _marshallerType; - private readonly TypeSyntax _bufferElementType; - private readonly bool _isLinearCollectionMarshalling; - - public StatelessCallerAllocatedBufferMarshalling(ICustomTypeMarshallingStrategy innerMarshaller, TypeSyntax marshallerType, TypeSyntax bufferElementType, bool isLinearCollectionMarshalling) - { - _innerMarshaller = innerMarshaller; - _marshallerType = marshallerType; - _bufferElementType = bufferElementType; - _isLinearCollectionMarshalling = isLinearCollectionMarshalling; - } + public ManagedTypeInfo NativeType => innerMarshaller.NativeType; + public TypePositionInfo TypeInfo => innerMarshaller.TypeInfo; + public StubCodeContext CodeContext => innerMarshaller.CodeContext; + public IEnumerable GenerateCleanupCallerAllocatedResourcesStatements(StubIdentifierContext context) => innerMarshaller.GenerateCleanupCallerAllocatedResourcesStatements(context); + public IEnumerable GenerateCleanupCalleeAllocatedResourcesStatements(StubIdentifierContext context) => innerMarshaller.GenerateCleanupCalleeAllocatedResourcesStatements(context); + public IEnumerable GenerateGuaranteedUnmarshalStatements(StubIdentifierContext context) => innerMarshaller.GenerateGuaranteedUnmarshalStatements(context); - public ManagedTypeInfo AsNativeType(TypePositionInfo info) => _innerMarshaller.AsNativeType(info); - public IEnumerable GenerateCleanupCallerAllocatedResourcesStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateCleanupCallerAllocatedResourcesStatements(info, context); - public IEnumerable GenerateCleanupCalleeAllocatedResourcesStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateCleanupCalleeAllocatedResourcesStatements(info, context); - public IEnumerable GenerateGuaranteedUnmarshalStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateGuaranteedUnmarshalStatements(info, context); - - public IEnumerable GenerateMarshalStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateMarshalStatements(StubIdentifierContext context) { - if (MarshallerHelpers.CanUseCallerAllocatedBuffer(info, context)) + if (MarshallerHelpers.CanUseCallerAllocatedBuffer(TypeInfo, CodeContext)) { return GenerateCallerAllocatedBufferMarshalStatements(); } - return _innerMarshaller.GenerateMarshalStatements(info, context); + return innerMarshaller.GenerateMarshalStatements(context); IEnumerable GenerateCallerAllocatedBufferMarshalStatements() { - string bufferIdentifier = context.GetAdditionalIdentifier(info, "buffer"); + string bufferIdentifier = context.GetAdditionalIdentifier(TypeInfo, "buffer"); // Span = stackalloc [.BufferSize]; yield return LocalDeclarationStatement( @@ -184,24 +172,24 @@ IEnumerable GenerateCallerAllocatedBufferMarshalStatements() GenericName( Identifier(TypeNames.System_Span), TypeArgumentList( - SingletonSeparatedList(_bufferElementType))), + SingletonSeparatedList(bufferElementType))), SingletonSeparatedList( VariableDeclarator(bufferIdentifier) .WithInitializer(EqualsValueClause( StackAllocArrayCreationExpression( ArrayType( - _bufferElementType, + bufferElementType, SingletonList(ArrayRankSpecifier(SingletonSeparatedList( MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, - _marshallerType, + marshallerType, IdentifierName(ShapeMemberNames.BufferSize)) )))))))))); - (string managedIdentifier, string nativeIdentifier) = context.GetIdentifiers(info); + (string managedIdentifier, string nativeIdentifier) = context.GetIdentifiers(TypeInfo); - if (_isLinearCollectionMarshalling) + if (isLinearCollectionMarshalling) { - string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(info, context); + string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(TypeInfo, context); // = .AllocateContainerForUnmanagedElements(, , out ); yield return ExpressionStatement( @@ -210,7 +198,7 @@ IEnumerable GenerateCallerAllocatedBufferMarshalStatements() IdentifierName(nativeIdentifier), InvocationExpression( MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, - _marshallerType, + marshallerType, IdentifierName(ShapeMemberNames.LinearCollection.Stateless.AllocateContainerForUnmanagedElements)), ArgumentList(SeparatedList(new ArgumentSyntax[] { @@ -221,7 +209,7 @@ IEnumerable GenerateCallerAllocatedBufferMarshalStatements() }))))); // Linear collections have additional marshalling required using the inner marshaller - foreach (StatementSyntax statement in _innerMarshaller.GenerateMarshalStatements(info, context)) + foreach (StatementSyntax statement in innerMarshaller.GenerateMarshalStatements(context)) { yield return statement; } @@ -235,7 +223,7 @@ IEnumerable GenerateCallerAllocatedBufferMarshalStatements() IdentifierName(nativeIdentifier), InvocationExpression( MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, - _marshallerType, + marshallerType, IdentifierName(ShapeMemberNames.Value.Stateless.ConvertToUnmanaged)), ArgumentList(SeparatedList(new ArgumentSyntax[] { @@ -246,35 +234,32 @@ IEnumerable GenerateCallerAllocatedBufferMarshalStatements() } } - public IEnumerable GeneratePinnedMarshalStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GeneratePinnedMarshalStatements(info, context); - public IEnumerable GeneratePinStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GeneratePinStatements(info, context); - public IEnumerable GenerateSetupStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateSetupStatements(info, context); - public IEnumerable GenerateUnmarshalCaptureStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateUnmarshalCaptureStatements(info, context); - public IEnumerable GenerateUnmarshalStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateUnmarshalStatements(info, context); - public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.UsesNativeIdentifier(info, context); + public IEnumerable GeneratePinnedMarshalStatements(StubIdentifierContext context) => innerMarshaller.GeneratePinnedMarshalStatements(context); + public IEnumerable GeneratePinStatements(StubIdentifierContext context) => innerMarshaller.GeneratePinStatements(context); + public IEnumerable GenerateSetupStatements(StubIdentifierContext context) => innerMarshaller.GenerateSetupStatements(context); + public IEnumerable GenerateUnmarshalCaptureStatements(StubIdentifierContext context) => innerMarshaller.GenerateUnmarshalCaptureStatements(context); + public IEnumerable GenerateUnmarshalStatements(StubIdentifierContext context) => innerMarshaller.GenerateUnmarshalStatements(context); + public bool UsesNativeIdentifier => innerMarshaller.UsesNativeIdentifier; - public IEnumerable GenerateNotifyForSuccessfulInvokeStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateNotifyForSuccessfulInvokeStatements(info, context); + public IEnumerable GenerateNotifyForSuccessfulInvokeStatements(StubIdentifierContext context) => innerMarshaller.GenerateNotifyForSuccessfulInvokeStatements(context); } - internal sealed class StatelessFreeMarshalling : ICustomTypeMarshallingStrategy + internal sealed class StatelessFreeMarshalling(ICustomTypeMarshallingStrategy innerMarshaller, TypeSyntax marshallerType) : ICustomTypeMarshallingStrategy { - private readonly ICustomTypeMarshallingStrategy _innerMarshaller; - private readonly TypeSyntax _marshallerType; + public bool UsesNativeIdentifier => innerMarshaller.UsesNativeIdentifier; - public StatelessFreeMarshalling(ICustomTypeMarshallingStrategy innerMarshaller, TypeSyntax marshallerType) - { - _innerMarshaller = innerMarshaller; - _marshallerType = marshallerType; - } + public TypePositionInfo TypeInfo => innerMarshaller.TypeInfo; + + public StubCodeContext CodeContext => innerMarshaller.CodeContext; - public ManagedTypeInfo AsNativeType(TypePositionInfo info) => _innerMarshaller.AsNativeType(info); + public ManagedTypeInfo NativeType => innerMarshaller.NativeType; - public IEnumerable GenerateCleanupCallerAllocatedResourcesStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateCleanupCallerAllocatedResourcesStatements(StubIdentifierContext context) { - if (MarshallerHelpers.GetCleanupStage(info, context) is not StubCodeContext.Stage.CleanupCallerAllocated) + if (MarshallerHelpers.GetCleanupStage(TypeInfo, CodeContext) is not StubIdentifierContext.Stage.CleanupCallerAllocated) yield break; - foreach (StatementSyntax statement in _innerMarshaller.GenerateCleanupCallerAllocatedResourcesStatements(info, context)) + foreach (StatementSyntax statement in innerMarshaller.GenerateCleanupCallerAllocatedResourcesStatements(context)) { yield return statement; } @@ -282,18 +267,18 @@ public IEnumerable GenerateCleanupCallerAllocatedResourcesState yield return ExpressionStatement( InvocationExpression( MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, - _marshallerType, + marshallerType, IdentifierName(ShapeMemberNames.Free)), ArgumentList(SingletonSeparatedList( - Argument(IdentifierName(context.GetIdentifiers(info).native)))))); + Argument(IdentifierName(context.GetIdentifiers(TypeInfo).native)))))); } - public IEnumerable GenerateCleanupCalleeAllocatedResourcesStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateCleanupCalleeAllocatedResourcesStatements(StubIdentifierContext context) { - if (MarshallerHelpers.GetCleanupStage(info, context) is not StubCodeContext.Stage.CleanupCalleeAllocated) + if (MarshallerHelpers.GetCleanupStage(TypeInfo, CodeContext) is not StubIdentifierContext.Stage.CleanupCalleeAllocated) yield break; - foreach (StatementSyntax statement in _innerMarshaller.GenerateCleanupCalleeAllocatedResourcesStatements(info, context)) + foreach (StatementSyntax statement in innerMarshaller.GenerateCleanupCalleeAllocatedResourcesStatements(context)) { yield return statement; } @@ -301,93 +286,85 @@ public IEnumerable GenerateCleanupCalleeAllocatedResourcesState yield return ExpressionStatement( InvocationExpression( MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, - _marshallerType, + marshallerType, IdentifierName(ShapeMemberNames.Free)), ArgumentList(SingletonSeparatedList( - Argument(IdentifierName(context.GetIdentifiers(info).native)))))); + Argument(IdentifierName(context.GetIdentifiers(TypeInfo).native)))))); } - public IEnumerable GenerateGuaranteedUnmarshalStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateGuaranteedUnmarshalStatements(info, context); - public IEnumerable GenerateMarshalStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateMarshalStatements(info, context); - public IEnumerable GenerateNotifyForSuccessfulInvokeStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateNotifyForSuccessfulInvokeStatements(info, context); - public IEnumerable GeneratePinnedMarshalStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GeneratePinnedMarshalStatements(info, context); - public IEnumerable GeneratePinStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GeneratePinStatements(info, context); - public IEnumerable GenerateSetupStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateSetupStatements(info, context); - public IEnumerable GenerateUnmarshalCaptureStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateUnmarshalCaptureStatements(info, context); - public IEnumerable GenerateUnmarshalStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateUnmarshalStatements(info, context); - public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.UsesNativeIdentifier(info, context); + public IEnumerable GenerateGuaranteedUnmarshalStatements(StubIdentifierContext context) => innerMarshaller.GenerateGuaranteedUnmarshalStatements(context); + public IEnumerable GenerateMarshalStatements(StubIdentifierContext context) => innerMarshaller.GenerateMarshalStatements(context); + public IEnumerable GenerateNotifyForSuccessfulInvokeStatements(StubIdentifierContext context) => innerMarshaller.GenerateNotifyForSuccessfulInvokeStatements(context); + public IEnumerable GeneratePinnedMarshalStatements(StubIdentifierContext context) => innerMarshaller.GeneratePinnedMarshalStatements(context); + public IEnumerable GeneratePinStatements(StubIdentifierContext context) => innerMarshaller.GeneratePinStatements(context); + public IEnumerable GenerateSetupStatements(StubIdentifierContext context) => innerMarshaller.GenerateSetupStatements(context); + public IEnumerable GenerateUnmarshalCaptureStatements(StubIdentifierContext context) => innerMarshaller.GenerateUnmarshalCaptureStatements(context); + public IEnumerable GenerateUnmarshalStatements(StubIdentifierContext context) => innerMarshaller.GenerateUnmarshalStatements(context); } /// /// Marshaller type that enables allocating space for marshalling a linear collection using a marshaller that implements the LinearCollection marshalling spec. /// - internal sealed class StatelessLinearCollectionSpaceAllocator : ICustomTypeMarshallingStrategy + internal sealed class StatelessLinearCollectionSpaceAllocator(TypePositionInfo info, StubCodeContext codeContext, TypeSyntax marshallerTypeSyntax, ManagedTypeInfo unmanagedType, MarshallerShape shape, CountInfo countInfo, bool countInfoRequiresCast) : ICustomTypeMarshallingStrategy { - private readonly TypeSyntax _marshallerTypeSyntax; - private readonly ManagedTypeInfo _unmanagedType; - private readonly MarshallerShape _shape; - private readonly ExpressionSyntax _numElementsExpression; + public ManagedTypeInfo NativeType => unmanagedType; - public StatelessLinearCollectionSpaceAllocator(TypeSyntax marshallerTypeSyntax, ManagedTypeInfo unmanagedType, MarshallerShape shape, ExpressionSyntax numElementsExpression) - { - _marshallerTypeSyntax = marshallerTypeSyntax; - _unmanagedType = unmanagedType; - _shape = shape; - _numElementsExpression = numElementsExpression; - } + public TypePositionInfo TypeInfo => info; - public ManagedTypeInfo AsNativeType(TypePositionInfo info) - { - return _unmanagedType; - } + public StubCodeContext CodeContext => codeContext; - public IEnumerable GenerateCleanupCallerAllocatedResourcesStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateCleanupCallerAllocatedResourcesStatements(StubIdentifierContext context) { - if (MarshallerHelpers.GetCleanupStage(info, context) is not StubCodeContext.Stage.CleanupCallerAllocated) + // If we clean up in a different stage, we don't need to do anything here + if (MarshallerHelpers.GetCleanupStage(TypeInfo, CodeContext) is not StubIdentifierContext.Stage.CleanupCallerAllocated) yield break; - string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(info, context); - // = ; - yield return ExpressionStatement( - AssignmentExpression( - SyntaxKind.SimpleAssignmentExpression, - IdentifierName(numElementsIdentifier), - _numElementsExpression)); + if (MarshallerHelpers.GetMarshalDirection(TypeInfo, CodeContext) != MarshalDirection.ManagedToUnmanaged) + { + // If we are marshalling from unmanaged to managed, we need to get the number of elements again. + string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(TypeInfo, context); + // = ; + yield return ExpressionStatement( + AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + IdentifierName(numElementsIdentifier), + ElementsMarshalling.GenerateNumElementsExpression(countInfo, countInfoRequiresCast, CodeContext, context))); + } } - public IEnumerable GenerateCleanupCalleeAllocatedResourcesStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateCleanupCalleeAllocatedResourcesStatements(StubIdentifierContext context) { - if (MarshallerHelpers.GetCleanupStage(info, context) is not StubCodeContext.Stage.CleanupCalleeAllocated) + if (MarshallerHelpers.GetCleanupStage(TypeInfo, CodeContext) is not StubIdentifierContext.Stage.CleanupCalleeAllocated) yield break; - if (MarshallerHelpers.GetMarshalDirection(info, context) == MarshalDirection.ManagedToUnmanaged) + if (MarshallerHelpers.GetMarshalDirection(TypeInfo, CodeContext) == MarshalDirection.ManagedToUnmanaged) { yield return EmptyStatement(); yield break; } - string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(info, context); + string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(TypeInfo, context); // = ; yield return ExpressionStatement( AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, IdentifierName(numElementsIdentifier), - _numElementsExpression)); + ElementsMarshalling.GenerateNumElementsExpression(countInfo, countInfoRequiresCast, CodeContext, context))); } - public IEnumerable GenerateGuaranteedUnmarshalStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateGuaranteedUnmarshalStatements(StubIdentifierContext context) { - if (!_shape.HasFlag(MarshallerShape.GuaranteedUnmarshal)) + if (!shape.HasFlag(MarshallerShape.GuaranteedUnmarshal)) yield break; - (string managedIdentifier, string nativeIdentifier) = context.GetIdentifiers(info); - string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(info, context); + (string managedIdentifier, string nativeIdentifier) = context.GetIdentifiers(TypeInfo); + string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(TypeInfo, context); yield return ExpressionStatement( AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, IdentifierName(numElementsIdentifier), - _numElementsExpression)); + ElementsMarshalling.GenerateNumElementsExpression(countInfo, countInfoRequiresCast, CodeContext, context))); // = .AllocateContainerForManagedElementsFinally(, ); yield return ExpressionStatement( @@ -396,7 +373,7 @@ public IEnumerable GenerateGuaranteedUnmarshalStatements(TypePo IdentifierName(managedIdentifier), InvocationExpression( MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, - _marshallerTypeSyntax, + marshallerTypeSyntax, IdentifierName(ShapeMemberNames.LinearCollection.Stateless.AllocateContainerForManagedElementsFinally)), ArgumentList(SeparatedList(new ArgumentSyntax[] { @@ -405,17 +382,17 @@ public IEnumerable GenerateGuaranteedUnmarshalStatements(TypePo }))))); } - public IEnumerable GenerateMarshalStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateMarshalStatements(StubIdentifierContext context) { - if (!_shape.HasFlag(MarshallerShape.ToUnmanaged) && !_shape.HasFlag(MarshallerShape.CallerAllocatedBuffer)) + if (!shape.HasFlag(MarshallerShape.ToUnmanaged) && !shape.HasFlag(MarshallerShape.CallerAllocatedBuffer)) yield break; - if (_shape.HasFlag(MarshallerShape.ToUnmanaged) - && !(_shape.HasFlag(MarshallerShape.CallerAllocatedBuffer) - && MarshallerHelpers.CanUseCallerAllocatedBuffer(info, context))) + if (shape.HasFlag(MarshallerShape.ToUnmanaged) + && !(shape.HasFlag(MarshallerShape.CallerAllocatedBuffer) + && MarshallerHelpers.CanUseCallerAllocatedBuffer(TypeInfo, CodeContext))) { - (string managedIdentifier, string nativeIdentifier) = context.GetIdentifiers(info); - string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(info, context); + (string managedIdentifier, string nativeIdentifier) = context.GetIdentifiers(TypeInfo); + string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(TypeInfo, context); // = .AllocateContainerForUnmanagedElements(, out ); yield return ExpressionStatement( @@ -424,7 +401,7 @@ public IEnumerable GenerateMarshalStatements(TypePositionInfo i IdentifierName(nativeIdentifier), InvocationExpression( MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, - _marshallerTypeSyntax, + marshallerTypeSyntax, IdentifierName(ShapeMemberNames.LinearCollection.Stateless.AllocateContainerForUnmanagedElements)), ArgumentList(SeparatedList(new ArgumentSyntax[] { @@ -435,13 +412,13 @@ public IEnumerable GenerateMarshalStatements(TypePositionInfo i } } - public IEnumerable GenerateNotifyForSuccessfulInvokeStatements(TypePositionInfo info, StubCodeContext context) => Array.Empty(); - public IEnumerable GeneratePinnedMarshalStatements(TypePositionInfo info, StubCodeContext context) => Array.Empty(); - public IEnumerable GeneratePinStatements(TypePositionInfo info, StubCodeContext context) => Array.Empty(); - public IEnumerable GenerateSetupStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateNotifyForSuccessfulInvokeStatements(StubIdentifierContext context) => Array.Empty(); + public IEnumerable GeneratePinnedMarshalStatements(StubIdentifierContext context) => Array.Empty(); + public IEnumerable GeneratePinStatements(StubIdentifierContext context) => Array.Empty(); + public IEnumerable GenerateSetupStatements(StubIdentifierContext context) { // int ; - string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(info, context); + string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(TypeInfo, context); yield return LocalDeclarationStatement( VariableDeclaration( PredefinedType(Token(SyntaxKind.IntKeyword)), @@ -456,26 +433,26 @@ public IEnumerable GenerateSetupStatements(TypePositionInfo inf }, context); } - public IEnumerable GenerateUnmarshalCaptureStatements(TypePositionInfo info, StubCodeContext context) => Array.Empty(); + public IEnumerable GenerateUnmarshalCaptureStatements(StubIdentifierContext context) => Array.Empty(); - public IEnumerable GenerateUnmarshalStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateUnmarshalStatements(StubIdentifierContext context) { - if (context.Direction == MarshalDirection.ManagedToUnmanaged && !info.IsByRef && info.ByValueContentsMarshalKind.HasFlag(ByValueContentsMarshalKind.Out)) + if (CodeContext.Direction == MarshalDirection.ManagedToUnmanaged && !TypeInfo.IsByRef && TypeInfo.ByValueContentsMarshalKind.HasFlag(ByValueContentsMarshalKind.Out)) { yield break; } - if (!_shape.HasFlag(MarshallerShape.ToManaged)) + if (!shape.HasFlag(MarshallerShape.ToManaged)) yield break; - (string managedIdentifier, string nativeIdentifier) = context.GetIdentifiers(info); - string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(info, context); + (string managedIdentifier, string nativeIdentifier) = context.GetIdentifiers(TypeInfo); + string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(TypeInfo, context); yield return ExpressionStatement( AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, IdentifierName(numElementsIdentifier), - _numElementsExpression)); + ElementsMarshalling.GenerateNumElementsExpression(countInfo, countInfoRequiresCast, CodeContext, context))); // = .AllocateContainerForManagedElements(, ); yield return ExpressionStatement( @@ -484,7 +461,7 @@ public IEnumerable GenerateUnmarshalStatements(TypePositionInfo IdentifierName(managedIdentifier), InvocationExpression( MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, - _marshallerTypeSyntax, + marshallerTypeSyntax, IdentifierName(ShapeMemberNames.LinearCollection.Stateless.AllocateContainerForManagedElements)), ArgumentList(SeparatedList(new ArgumentSyntax[] { @@ -493,19 +470,16 @@ public IEnumerable GenerateUnmarshalStatements(TypePositionInfo }))))); } - public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) => true; + public bool UsesNativeIdentifier => true; } - internal sealed class StatelessLinearCollectionSource : IElementsMarshallingCollectionSource + internal sealed class StatelessLinearCollectionSource(TypePositionInfo info, StubCodeContext codeContext, TypeSyntax marshallerTypeSyntax) : IElementsMarshallingCollectionSource { - private readonly TypeSyntax _marshallerTypeSyntax; + public TypePositionInfo TypeInfo => info; - public StatelessLinearCollectionSource(TypeSyntax marshallerTypeSyntax) - { - _marshallerTypeSyntax = marshallerTypeSyntax; - } + public StubCodeContext CodeContext => codeContext; - public InvocationExpressionSyntax GetUnmanagedValuesDestination(TypePositionInfo info, StubCodeContext context) + public InvocationExpressionSyntax GetUnmanagedValuesDestination(StubIdentifierContext context) { string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(info, context); string nativeIdentifier = context.GetIdentifiers(info).native; @@ -514,7 +488,7 @@ public InvocationExpressionSyntax GetUnmanagedValuesDestination(TypePositionInfo return InvocationExpression( MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, - _marshallerTypeSyntax, + marshallerTypeSyntax, IdentifierName(ShapeMemberNames.LinearCollection.Stateless.GetUnmanagedValuesDestination)), ArgumentList(SeparatedList(new ArgumentSyntax[] { @@ -523,20 +497,20 @@ public InvocationExpressionSyntax GetUnmanagedValuesDestination(TypePositionInfo }))); } - public InvocationExpressionSyntax GetManagedValuesSource(TypePositionInfo info, StubCodeContext context) + public InvocationExpressionSyntax GetManagedValuesSource(StubIdentifierContext context) { // .GetManagedValuesSource() string managedIdentifier = context.GetIdentifiers(info).managed; return InvocationExpression( MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, - _marshallerTypeSyntax, + marshallerTypeSyntax, IdentifierName(ShapeMemberNames.LinearCollection.Stateless.GetManagedValuesSource)), ArgumentList(SingletonSeparatedList( Argument(IdentifierName(managedIdentifier))))); } - public InvocationExpressionSyntax GetUnmanagedValuesSource(TypePositionInfo info, StubCodeContext context) + public InvocationExpressionSyntax GetUnmanagedValuesSource(StubIdentifierContext context) { string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(info, context); string nativeIdentifier = context.GetIdentifiers(info).native; @@ -545,7 +519,7 @@ public InvocationExpressionSyntax GetUnmanagedValuesSource(TypePositionInfo info return InvocationExpression( MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, - _marshallerTypeSyntax, + marshallerTypeSyntax, IdentifierName(ShapeMemberNames.LinearCollection.Stateless.GetUnmanagedValuesSource)), ArgumentList(SeparatedList(new ArgumentSyntax[] { @@ -554,7 +528,7 @@ public InvocationExpressionSyntax GetUnmanagedValuesSource(TypePositionInfo info }))); } - public InvocationExpressionSyntax GetManagedValuesDestination(TypePositionInfo info, StubCodeContext context) + public InvocationExpressionSyntax GetManagedValuesDestination(StubIdentifierContext context) { string managedIdentifier = context.GetIdentifiers(info).managed; @@ -562,7 +536,7 @@ public InvocationExpressionSyntax GetManagedValuesDestination(TypePositionInfo i return InvocationExpression( MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, - _marshallerTypeSyntax, + marshallerTypeSyntax, IdentifierName(ShapeMemberNames.LinearCollection.Stateless.GetManagedValuesDestination)), ArgumentList(SingletonSeparatedList(Argument(IdentifierName(managedIdentifier))))); } @@ -571,186 +545,191 @@ public InvocationExpressionSyntax GetManagedValuesDestination(TypePositionInfo i /// /// Marshaller that enables support for marshalling elements of a collection via a marshaller type that implements the contiguous collection marshalling shape. /// - internal sealed class StatelessLinearCollectionMarshalling : ICustomTypeMarshallingStrategy + internal sealed class StatelessLinearCollectionMarshalling( + ICustomTypeMarshallingStrategy spaceMarshallingStrategy, + ElementsMarshalling elementsMarshalling, + ManagedTypeInfo unmanagedType, + MarshallerShape shape, + CountInfo countInfo, + bool castCountInfo, + bool cleanupElementsAndSpace) : ICustomTypeMarshallingStrategy { - private readonly ICustomTypeMarshallingStrategy _spaceMarshallingStrategy; - private readonly ElementsMarshalling _elementsMarshalling; - private readonly ManagedTypeInfo _unmanagedType; - private readonly MarshallerShape _shape; - private readonly ExpressionSyntax _numElementsExpression; - private readonly bool _cleanupElementsAndSpace; - - public StatelessLinearCollectionMarshalling( - ICustomTypeMarshallingStrategy spaceMarshallingStrategy, - ElementsMarshalling elementsMarshalling, - ManagedTypeInfo unmanagedType, - MarshallerShape shape, - ExpressionSyntax numElementsExpression, - bool cleanupElementsAndSpace) - { - _spaceMarshallingStrategy = spaceMarshallingStrategy; - _elementsMarshalling = elementsMarshalling; - _unmanagedType = unmanagedType; - _shape = shape; - _numElementsExpression = numElementsExpression; - _cleanupElementsAndSpace = cleanupElementsAndSpace; - } + public bool UsesNativeIdentifier => true; + + public TypePositionInfo TypeInfo => spaceMarshallingStrategy.TypeInfo; - public ManagedTypeInfo AsNativeType(TypePositionInfo info) => _unmanagedType; + public StubCodeContext CodeContext => spaceMarshallingStrategy.CodeContext; - public IEnumerable GenerateCleanupCallerAllocatedResourcesStatements(TypePositionInfo info, StubCodeContext context) + public ManagedTypeInfo NativeType => unmanagedType; + + public IEnumerable GenerateCleanupCallerAllocatedResourcesStatements(StubIdentifierContext context) { - if (!_cleanupElementsAndSpace) + if (!cleanupElementsAndSpace) { yield break; } - StatementSyntax elementCleanup = _elementsMarshalling.GenerateElementCleanupStatement(info, context); + StatementSyntax elementCleanup = elementsMarshalling.GenerateElementCleanupStatement(context); if (!elementCleanup.IsKind(SyntaxKind.EmptyStatement)) { - // If we don't have the numElements variable still available from unmarshal or marshal stage, we need to reassign that again - if (!context.AdditionalTemporaryStateLivesAcrossStages) + // If we don't have the numElements variable still available from unmarshal or marshal stage, we need to reassign that again. + + if (!CodeContext.AdditionalTemporaryStateLivesAcrossStages) { - // = ; - string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(info, context); - yield return ExpressionStatement( - AssignmentExpression( - SyntaxKind.SimpleAssignmentExpression, - IdentifierName(numElementsIdentifier), - _numElementsExpression)); + string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(TypeInfo, context); + if (countInfo is NoCountInfo && MarshallerHelpers.GetMarshalDirection(TypeInfo, CodeContext) == MarshalDirection.ManagedToUnmanaged) + { + // When marshalling from managed to unmanaged, we may not have count info. + // For now, just set to 0. + // See https://github.com/dotnet/runtime/issues/93423 for a tracking issue. + + // = 0; + yield return ExpressionStatement( + AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + IdentifierName(numElementsIdentifier), + LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(0)))); + } + else + { + // = ; + yield return ExpressionStatement( + AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + IdentifierName(numElementsIdentifier), + ElementsMarshalling.GenerateNumElementsExpression(countInfo, castCountInfo, CodeContext, context))); + } } yield return elementCleanup; } - if (MarshallerHelpers.GetCleanupStage(info, context) is StubCodeContext.Stage.CleanupCallerAllocated) + if (MarshallerHelpers.GetCleanupStage(TypeInfo, CodeContext) is StubIdentifierContext.Stage.CleanupCallerAllocated) { - foreach (var statement in _spaceMarshallingStrategy.GenerateCleanupCallerAllocatedResourcesStatements(info, context)) + foreach (var statement in spaceMarshallingStrategy.GenerateCleanupCallerAllocatedResourcesStatements(context)) { yield return statement; } } } - public IEnumerable GenerateCleanupCalleeAllocatedResourcesStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateCleanupCalleeAllocatedResourcesStatements(StubIdentifierContext context) { - if (!_cleanupElementsAndSpace) + if (!cleanupElementsAndSpace) { yield break; } - StatementSyntax elementCleanup = _elementsMarshalling.GenerateElementCleanupStatement(info, context); + StatementSyntax elementCleanup = elementsMarshalling.GenerateElementCleanupStatement(context); if (!elementCleanup.IsKind(SyntaxKind.EmptyStatement)) { // If we don't have the numElements variable still available from unmarshal or marshal stage, we need to reassign that again - if (!context.AdditionalTemporaryStateLivesAcrossStages) + if (!CodeContext.AdditionalTemporaryStateLivesAcrossStages) { // = ; - string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(info, context); + string numElementsIdentifier = MarshallerHelpers.GetNumElementsIdentifier(TypeInfo, context); yield return ExpressionStatement( AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, IdentifierName(numElementsIdentifier), - _numElementsExpression)); + ElementsMarshalling.GenerateNumElementsExpression(countInfo, castCountInfo, CodeContext, context))); } yield return elementCleanup; } - if (MarshallerHelpers.GetCleanupStage(info, context) is StubCodeContext.Stage.CleanupCallerAllocated) + if (MarshallerHelpers.GetCleanupStage(TypeInfo, CodeContext) is StubIdentifierContext.Stage.CleanupCallerAllocated) { - foreach (var statement in _spaceMarshallingStrategy.GenerateCleanupCalleeAllocatedResourcesStatements(info, context)) + foreach (var statement in spaceMarshallingStrategy.GenerateCleanupCalleeAllocatedResourcesStatements(context)) { yield return statement; } } } - public IEnumerable GenerateGuaranteedUnmarshalStatements(TypePositionInfo info, StubCodeContext context) => _spaceMarshallingStrategy.GenerateGuaranteedUnmarshalStatements(info, context); + public IEnumerable GenerateGuaranteedUnmarshalStatements(StubIdentifierContext context) => spaceMarshallingStrategy.GenerateGuaranteedUnmarshalStatements(context); - public IEnumerable GenerateMarshalStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateMarshalStatements(StubIdentifierContext context) { - if (context.Direction == MarshalDirection.ManagedToUnmanaged && !info.IsByRef && info.ByValueContentsMarshalKind == ByValueContentsMarshalKind.Out) + if (CodeContext.Direction == MarshalDirection.ManagedToUnmanaged && !TypeInfo.IsByRef && TypeInfo.ByValueContentsMarshalKind == ByValueContentsMarshalKind.Out) { // If the parameter is marshalled by-value [Out], then we don't marshal the contents of the collection. // We do clear the span, so that if the invoke target doesn't fill it, we aren't left with undefined content. - yield return _elementsMarshalling.GenerateClearUnmanagedDestination(info, context); + yield return elementsMarshalling.GenerateClearUnmanagedDestination(context); yield break; } - if (context.Direction == MarshalDirection.UnmanagedToManaged && !info.IsByRef && info.ByValueContentsMarshalKind.HasFlag(ByValueContentsMarshalKind.Out)) + if (CodeContext.Direction == MarshalDirection.UnmanagedToManaged && !TypeInfo.IsByRef && TypeInfo.ByValueContentsMarshalKind.HasFlag(ByValueContentsMarshalKind.Out)) { // If the parameter is marshalled by-value [Out] or [In, Out], then we need to unmarshal the contents of the collection // into the passed-in collection value. - yield return _elementsMarshalling.GenerateUnmanagedToManagedByValueOutMarshalStatement(info, context); + yield return elementsMarshalling.GenerateUnmanagedToManagedByValueOutMarshalStatement(context); yield break; } - foreach (var statement in _spaceMarshallingStrategy.GenerateMarshalStatements(info, context)) + foreach (var statement in spaceMarshallingStrategy.GenerateMarshalStatements(context)) { yield return statement; } - if (!_shape.HasFlag(MarshallerShape.ToUnmanaged) && !_shape.HasFlag(MarshallerShape.CallerAllocatedBuffer)) + if (!shape.HasFlag(MarshallerShape.ToUnmanaged) && !shape.HasFlag(MarshallerShape.CallerAllocatedBuffer)) yield break; - yield return _elementsMarshalling.GenerateMarshalStatement(info, context); + yield return elementsMarshalling.GenerateMarshalStatement(context); } - public IEnumerable GenerateNotifyForSuccessfulInvokeStatements(TypePositionInfo info, StubCodeContext context) => _spaceMarshallingStrategy.GenerateNotifyForSuccessfulInvokeStatements(info, context); - public IEnumerable GeneratePinnedMarshalStatements(TypePositionInfo info, StubCodeContext context) => _spaceMarshallingStrategy.GeneratePinnedMarshalStatements(info, context); - public IEnumerable GeneratePinStatements(TypePositionInfo info, StubCodeContext context) => _spaceMarshallingStrategy.GeneratePinStatements(info, context); + public IEnumerable GenerateNotifyForSuccessfulInvokeStatements(StubIdentifierContext context) => spaceMarshallingStrategy.GenerateNotifyForSuccessfulInvokeStatements(context); + public IEnumerable GeneratePinnedMarshalStatements(StubIdentifierContext context) => spaceMarshallingStrategy.GeneratePinnedMarshalStatements(context); + public IEnumerable GeneratePinStatements(StubIdentifierContext context) => spaceMarshallingStrategy.GeneratePinStatements(context); - public IEnumerable GenerateSetupStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateSetupStatements(StubIdentifierContext context) { - foreach (var s in _spaceMarshallingStrategy.GenerateSetupStatements(info, context)) + foreach (var s in spaceMarshallingStrategy.GenerateSetupStatements(context)) yield return s; - var elementsSetup = _elementsMarshalling.GenerateSetupStatement(info, context); + var elementsSetup = elementsMarshalling.GenerateSetupStatement(context); if (elementsSetup is not EmptyStatementSyntax) { yield return elementsSetup; } } - public IEnumerable GenerateUnmarshalCaptureStatements(TypePositionInfo info, StubCodeContext context) => Array.Empty(); + public IEnumerable GenerateUnmarshalCaptureStatements(StubIdentifierContext context) => Array.Empty(); - public IEnumerable GenerateUnmarshalStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateUnmarshalStatements(StubIdentifierContext context) { - if (context.Direction == MarshalDirection.ManagedToUnmanaged && !info.IsByRef && info.ByValueContentsMarshalKind.HasFlag(ByValueContentsMarshalKind.Out)) + if (CodeContext.Direction == MarshalDirection.ManagedToUnmanaged && !TypeInfo.IsByRef && TypeInfo.ByValueContentsMarshalKind.HasFlag(ByValueContentsMarshalKind.Out)) { // If the parameter is marshalled by-value [Out] or [In, Out], then we need to unmarshal the contents of the collection // into the passed-in collection value. - yield return _elementsMarshalling.GenerateManagedToUnmanagedByValueOutUnmarshalStatement(info, context); + yield return elementsMarshalling.GenerateManagedToUnmanagedByValueOutUnmarshalStatement(context); yield break; } - if (context.Direction == MarshalDirection.UnmanagedToManaged && !info.IsByRef && info.ByValueContentsMarshalKind == ByValueContentsMarshalKind.Out) + if (CodeContext.Direction == MarshalDirection.UnmanagedToManaged && !TypeInfo.IsByRef && TypeInfo.ByValueContentsMarshalKind == ByValueContentsMarshalKind.Out) { // If the parameter is marshalled by-value [Out], then we don't marshal the contents of the collection. // We do clear the span, so that if the invoke target doesn't fill it, we aren't left with undefined content. - yield return _elementsMarshalling.GenerateClearManagedValuesDestination(info, context); - foreach (var statement in _spaceMarshallingStrategy.GenerateUnmarshalStatements(info, context)) + yield return elementsMarshalling.GenerateClearManagedValuesDestination(context); + foreach (var statement in spaceMarshallingStrategy.GenerateUnmarshalStatements(context)) { yield return statement; } yield break; } - if (!_shape.HasFlag(MarshallerShape.ToManaged)) + if (!shape.HasFlag(MarshallerShape.ToManaged)) { yield break; } else { - foreach (var statement in _spaceMarshallingStrategy.GenerateUnmarshalStatements(info, context)) + foreach (var statement in spaceMarshallingStrategy.GenerateUnmarshalStatements(context)) { yield return statement; } - yield return _elementsMarshalling.GenerateUnmarshalStatement(info, context); + yield return elementsMarshalling.GenerateUnmarshalStatement(context); } } - - public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) => true; } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/StaticPinnableManagedValueMarshaller.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/StaticPinnableManagedValueMarshaller.cs index 07bb36a2eda..dbb7fcabb22 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/StaticPinnableManagedValueMarshaller.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/StaticPinnableManagedValueMarshaller.cs @@ -10,74 +10,70 @@ namespace Microsoft.Interop { - public sealed class StaticPinnableManagedValueMarshaller : IMarshallingGenerator + public sealed class StaticPinnableManagedValueMarshaller(IBoundMarshallingGenerator innerMarshallingGenerator, TypeSyntax getPinnableReferenceType) : IBoundMarshallingGenerator { - private readonly IMarshallingGenerator _innerMarshallingGenerator; - private readonly TypeSyntax _getPinnableReferenceType; + public TypePositionInfo TypeInfo => innerMarshallingGenerator.TypeInfo; - public StaticPinnableManagedValueMarshaller(IMarshallingGenerator innerMarshallingGenerator, TypeSyntax getPinnableReferenceType) - { - _innerMarshallingGenerator = innerMarshallingGenerator; - _getPinnableReferenceType = getPinnableReferenceType; - } + public StubCodeContext CodeContext => innerMarshallingGenerator.CodeContext; + + public ManagedTypeInfo NativeType => innerMarshallingGenerator.NativeType; - public ValueBoundaryBehavior GetValueBoundaryBehavior(TypePositionInfo info, StubCodeContext context) + public SignatureBehavior NativeSignatureBehavior => innerMarshallingGenerator.NativeSignatureBehavior; + + public ValueBoundaryBehavior ValueBoundaryBehavior { - if (IsPinningPathSupported(info, context)) + get { - if (AsNativeType(info).Syntax is PointerTypeSyntax pointerType - && pointerType.ElementType is PredefinedTypeSyntax predefinedType - && predefinedType.Keyword.IsKind(SyntaxKind.VoidKeyword)) + if (IsPinningPathSupported(CodeContext)) { - return ValueBoundaryBehavior.NativeIdentifier; + if (NativeType.Syntax is PointerTypeSyntax pointerType + && pointerType.ElementType is PredefinedTypeSyntax predefinedType + && predefinedType.Keyword.IsKind(SyntaxKind.VoidKeyword)) + { + return Interop.ValueBoundaryBehavior.NativeIdentifier; + } + + // Cast to native type if it is not void* + return Interop.ValueBoundaryBehavior.CastNativeIdentifier; } - // Cast to native type if it is not void* - return ValueBoundaryBehavior.CastNativeIdentifier; + return innerMarshallingGenerator.ValueBoundaryBehavior; } - - return _innerMarshallingGenerator.GetValueBoundaryBehavior(info, context); - } - - public ManagedTypeInfo AsNativeType(TypePositionInfo info) - { - return _innerMarshallingGenerator.AsNativeType(info); } - public SignatureBehavior GetNativeSignatureBehavior(TypePositionInfo info) + public IEnumerable Generate(StubIdentifierContext context) { - return _innerMarshallingGenerator.GetNativeSignatureBehavior(info); - } - - public IEnumerable Generate(TypePositionInfo info, StubCodeContext context) - { - if (IsPinningPathSupported(info, context)) + if (IsPinningPathSupported(CodeContext)) { - return GeneratePinningPath(info, context); + return GeneratePinningPath(context); } - return _innerMarshallingGenerator.Generate(info, context); + return innerMarshallingGenerator.Generate(context); } - public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) + public bool UsesNativeIdentifier { - if (IsPinningPathSupported(info, context)) + get { - return false; - } + if (IsPinningPathSupported(CodeContext)) + { + return false; + } - return _innerMarshallingGenerator.UsesNativeIdentifier(info, context); + return innerMarshallingGenerator.UsesNativeIdentifier; + } } - private static bool IsPinningPathSupported(TypePositionInfo info, StubCodeContext context) + + private bool IsPinningPathSupported(StubCodeContext context) { - return context.SingleFrameSpansNativeContext && !info.IsByRef && !context.IsInStubReturnPosition(info); + return context.SingleFrameSpansNativeContext && !TypeInfo.IsByRef && !context.IsInStubReturnPosition(TypeInfo); } - private IEnumerable GeneratePinningPath(TypePositionInfo info, StubCodeContext context) + private IEnumerable GeneratePinningPath(StubIdentifierContext context) { - if (context.CurrentStage == StubCodeContext.Stage.Pin) + if (context.CurrentStage == StubIdentifierContext.Stage.Pin) { - (string managedIdentifier, string nativeIdentifier) = context.GetIdentifiers(info); + (string managedIdentifier, string nativeIdentifier) = context.GetIdentifiers(innerMarshallingGenerator.TypeInfo); // fixed (void* = &.GetPinnableReference()) yield return FixedStatement( @@ -89,7 +85,7 @@ private IEnumerable GeneratePinningPath(TypePositionInfo info, PrefixUnaryExpression(SyntaxKind.AddressOfExpression, InvocationExpression( MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, - _getPinnableReferenceType, + getPinnableReferenceType, IdentifierName(ShapeMemberNames.GetPinnableReference)), ArgumentList(SingletonSeparatedList( Argument(IdentifierName(managedIdentifier)))))) @@ -100,9 +96,9 @@ private IEnumerable GeneratePinningPath(TypePositionInfo info, } } - public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, StubCodeContext context, out GeneratorDiagnostic? diagnostic) + public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, out GeneratorDiagnostic? diagnostic) { - return _innerMarshallingGenerator.SupportsByValueMarshalKind(marshalKind, info, context, out diagnostic); + return innerMarshallingGenerator.SupportsByValueMarshalKind(marshalKind, out diagnostic); } } } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/UnmanagedToManagedOwnershipTrackingStrategy.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/UnmanagedToManagedOwnershipTrackingStrategy.cs index d20e5c556df..03e384ca60e 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/UnmanagedToManagedOwnershipTrackingStrategy.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Marshalling/UnmanagedToManagedOwnershipTrackingStrategy.cs @@ -3,6 +3,7 @@ using System; using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory; @@ -13,24 +14,23 @@ namespace Microsoft.Interop /// Marshalling strategy that introduces a variable to hold the initial value of the provided and a variable to track if the original value has been replaced. /// /// - internal sealed class UnmanagedToManagedOwnershipTrackingStrategy : ICustomTypeMarshallingStrategy + internal sealed class UnmanagedToManagedOwnershipTrackingStrategy(ICustomTypeMarshallingStrategy innerMarshaller) : ICustomTypeMarshallingStrategy { - private readonly ICustomTypeMarshallingStrategy _innerMarshaller; + public ManagedTypeInfo NativeType => innerMarshaller.NativeType; - public UnmanagedToManagedOwnershipTrackingStrategy(ICustomTypeMarshallingStrategy innerMarshaller) - { - _innerMarshaller = innerMarshaller; - } + public bool UsesNativeIdentifier => innerMarshaller.UsesNativeIdentifier; - public ManagedTypeInfo AsNativeType(TypePositionInfo info) => _innerMarshaller.AsNativeType(info); + public TypePositionInfo TypeInfo => innerMarshaller.TypeInfo; - public IEnumerable GenerateCleanupCallerAllocatedResourcesStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateCleanupCallerAllocatedResourcesStatements(info, context); - public IEnumerable GenerateCleanupCalleeAllocatedResourcesStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateCleanupCalleeAllocatedResourcesStatements(info, context); + public StubCodeContext CodeContext => innerMarshaller.CodeContext; - public IEnumerable GenerateGuaranteedUnmarshalStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateGuaranteedUnmarshalStatements(info, context); - public IEnumerable GenerateMarshalStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateCleanupCallerAllocatedResourcesStatements(StubIdentifierContext context) => innerMarshaller.GenerateCleanupCallerAllocatedResourcesStatements(context); + public IEnumerable GenerateCleanupCalleeAllocatedResourcesStatements(StubIdentifierContext context) => innerMarshaller.GenerateCleanupCalleeAllocatedResourcesStatements(context); + + public IEnumerable GenerateGuaranteedUnmarshalStatements(StubIdentifierContext context) => innerMarshaller.GenerateGuaranteedUnmarshalStatements(context); + public IEnumerable GenerateMarshalStatements(StubIdentifierContext context) { - foreach (StatementSyntax statement in _innerMarshaller.GenerateMarshalStatements(info, context)) + foreach (StatementSyntax statement in innerMarshaller.GenerateMarshalStatements(context)) { yield return statement; } @@ -41,17 +41,17 @@ public IEnumerable GenerateMarshalStatements(TypePositionInfo i // = true; yield return ExpressionStatement( AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, - IdentifierName(context.GetAdditionalIdentifier(info, OwnershipTrackingHelpers.OwnOriginalValueIdentifier)), + IdentifierName(context.GetAdditionalIdentifier(TypeInfo, OwnershipTrackingHelpers.OwnOriginalValueIdentifier)), LiteralExpression(SyntaxKind.TrueLiteralExpression))); } - public IEnumerable GenerateNotifyForSuccessfulInvokeStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateNotifyForSuccessfulInvokeStatements(info, context); - public IEnumerable GeneratePinnedMarshalStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GeneratePinnedMarshalStatements(info, context); + public IEnumerable GenerateNotifyForSuccessfulInvokeStatements(StubIdentifierContext context) => innerMarshaller.GenerateNotifyForSuccessfulInvokeStatements(context); + public IEnumerable GeneratePinnedMarshalStatements(StubIdentifierContext context) => innerMarshaller.GeneratePinnedMarshalStatements(context); - public IEnumerable GeneratePinStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GeneratePinStatements(info, context); - public IEnumerable GenerateSetupStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GeneratePinStatements(StubIdentifierContext context) => innerMarshaller.GeneratePinStatements(context); + public IEnumerable GenerateSetupStatements(StubIdentifierContext context) { - foreach (StatementSyntax statement in _innerMarshaller.GenerateSetupStatements(info, context)) + foreach (StatementSyntax statement in innerMarshaller.GenerateSetupStatements(context)) { yield return statement; } @@ -62,98 +62,98 @@ public IEnumerable GenerateSetupStatements(TypePositionInfo inf PredefinedType(Token(SyntaxKind.BoolKeyword)), SingletonSeparatedList( VariableDeclarator( - Identifier(context.GetAdditionalIdentifier(info, OwnershipTrackingHelpers.OwnOriginalValueIdentifier)), + Identifier(context.GetAdditionalIdentifier(TypeInfo, OwnershipTrackingHelpers.OwnOriginalValueIdentifier)), null, EqualsValueClause( LiteralExpression(SyntaxKind.FalseLiteralExpression)))))); - yield return OwnershipTrackingHelpers.DeclareOriginalValueIdentifier(info, context, AsNativeType(info)); + yield return OwnershipTrackingHelpers.DeclareOriginalValueIdentifier(TypeInfo, context, NativeType); } - public IEnumerable GenerateUnmarshalCaptureStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateUnmarshalCaptureStatements(info, context); + public IEnumerable GenerateUnmarshalCaptureStatements(StubIdentifierContext context) => innerMarshaller.GenerateUnmarshalCaptureStatements(context); - public IEnumerable GenerateUnmarshalStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateUnmarshalStatements(info, context); - public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.UsesNativeIdentifier(info, context); + public IEnumerable GenerateUnmarshalStatements(StubIdentifierContext context) => innerMarshaller.GenerateUnmarshalStatements(context); } /// /// Marshalling strategy that uses the tracking variables introduced by to cleanup the original value if the original value is owned - /// in the stage. + /// in the stage. /// - internal sealed class CleanupOwnedOriginalValueMarshalling : ICustomTypeMarshallingStrategy + internal sealed class CleanupOwnedOriginalValueMarshalling(ICustomTypeMarshallingStrategy innerMarshaller) : ICustomTypeMarshallingStrategy { - private readonly ICustomTypeMarshallingStrategy _innerMarshaller; + public ManagedTypeInfo NativeType => innerMarshaller.NativeType; - public CleanupOwnedOriginalValueMarshalling(ICustomTypeMarshallingStrategy innerMarshaller) - { - _innerMarshaller = innerMarshaller; - } + public bool UsesNativeIdentifier => innerMarshaller.UsesNativeIdentifier; + + public TypePositionInfo TypeInfo => innerMarshaller.TypeInfo; - public ManagedTypeInfo AsNativeType(TypePositionInfo info) => _innerMarshaller.AsNativeType(info); + public StubCodeContext CodeContext => innerMarshaller.CodeContext; - public IEnumerable GenerateCleanupCallerAllocatedResourcesStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateCleanupCallerAllocatedResourcesStatements(StubIdentifierContext context) { - if (MarshallerHelpers.GetCleanupStage(info, context) is not StubCodeContext.Stage.CleanupCallerAllocated) + if (MarshallerHelpers.GetCleanupStage(TypeInfo, CodeContext) is not StubIdentifierContext.Stage.CleanupCallerAllocated) yield break; // if () // { // // } yield return IfStatement( - IdentifierName(context.GetAdditionalIdentifier(info, OwnershipTrackingHelpers.OwnOriginalValueIdentifier)), - Block(_innerMarshaller.GenerateCleanupCallerAllocatedResourcesStatements(info, new OwnedValueCodeContext(context)))); + IdentifierName(context.GetAdditionalIdentifier(TypeInfo, OwnershipTrackingHelpers.OwnOriginalValueIdentifier)), + Block(innerMarshaller.GenerateCleanupCallerAllocatedResourcesStatements(new OwnedValueCodeContext(context)))); } - public IEnumerable GenerateCleanupCalleeAllocatedResourcesStatements(TypePositionInfo info, StubCodeContext context) + public IEnumerable GenerateCleanupCalleeAllocatedResourcesStatements(StubIdentifierContext context) { - if (MarshallerHelpers.GetCleanupStage(info, context) is not StubCodeContext.Stage.CleanupCalleeAllocated) + if (MarshallerHelpers.GetCleanupStage(TypeInfo, CodeContext) is not StubIdentifierContext.Stage.CleanupCalleeAllocated) yield break; // if () // { // // } yield return IfStatement( - IdentifierName(context.GetAdditionalIdentifier(info, OwnershipTrackingHelpers.OwnOriginalValueIdentifier)), - Block(_innerMarshaller.GenerateCleanupCalleeAllocatedResourcesStatements(info, new OwnedValueCodeContext(context)))); + IdentifierName(context.GetAdditionalIdentifier(TypeInfo, OwnershipTrackingHelpers.OwnOriginalValueIdentifier)), + Block(innerMarshaller.GenerateCleanupCalleeAllocatedResourcesStatements(new OwnedValueCodeContext(context)))); } - public IEnumerable GenerateGuaranteedUnmarshalStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateGuaranteedUnmarshalStatements(info, context); - public IEnumerable GenerateMarshalStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateMarshalStatements(info, context); + public IEnumerable GenerateGuaranteedUnmarshalStatements(StubIdentifierContext context) => innerMarshaller.GenerateGuaranteedUnmarshalStatements(context); + public IEnumerable GenerateMarshalStatements(StubIdentifierContext context) => innerMarshaller.GenerateMarshalStatements(context); - public IEnumerable GenerateNotifyForSuccessfulInvokeStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateNotifyForSuccessfulInvokeStatements(info, context); - public IEnumerable GeneratePinnedMarshalStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GeneratePinnedMarshalStatements(info, context); + public IEnumerable GenerateNotifyForSuccessfulInvokeStatements(StubIdentifierContext context) => innerMarshaller.GenerateNotifyForSuccessfulInvokeStatements(context); + public IEnumerable GeneratePinnedMarshalStatements(StubIdentifierContext context) => innerMarshaller.GeneratePinnedMarshalStatements(context); - public IEnumerable GeneratePinStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GeneratePinStatements(info, context); - public IEnumerable GenerateSetupStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateSetupStatements(info, context); + public IEnumerable GeneratePinStatements(StubIdentifierContext context) => innerMarshaller.GeneratePinStatements(context); + public IEnumerable GenerateSetupStatements(StubIdentifierContext context) => innerMarshaller.GenerateSetupStatements(context); - public IEnumerable GenerateUnmarshalCaptureStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateUnmarshalCaptureStatements(info, context); + public IEnumerable GenerateUnmarshalCaptureStatements(StubIdentifierContext context) => innerMarshaller.GenerateUnmarshalCaptureStatements(context); - public IEnumerable GenerateUnmarshalStatements(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.GenerateUnmarshalStatements(info, context); - public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) => _innerMarshaller.UsesNativeIdentifier(info, context); + public IEnumerable GenerateUnmarshalStatements(StubIdentifierContext context) => innerMarshaller.GenerateUnmarshalStatements(context); } /// /// Marshalling strategy to cache the initial value of a given in a local variable and cleanup that value in the cleanup stage. - /// Useful in scenarios where the value is always owned in all code-paths that reach the stage, so additional ownership tracking is extraneous. + /// Useful in scenarios where the value is always owned in all code-paths that reach the stage, so additional ownership tracking is extraneous. /// - internal sealed class FreeAlwaysOwnedOriginalValueGenerator : IMarshallingGenerator + internal sealed class FreeAlwaysOwnedOriginalValueGenerator(IBoundMarshallingGenerator inner) : IBoundMarshallingGenerator { - private readonly IMarshallingGenerator _inner; + public ManagedTypeInfo NativeType => inner.NativeType; - public FreeAlwaysOwnedOriginalValueGenerator(IMarshallingGenerator inner) - { - _inner = inner; - } + public TypePositionInfo TypeInfo => inner.TypeInfo; + + public StubCodeContext CodeContext => inner.CodeContext; + + public SignatureBehavior NativeSignatureBehavior => inner.NativeSignatureBehavior; + + public bool UsesNativeIdentifier => inner.UsesNativeIdentifier; + public ValueBoundaryBehavior ValueBoundaryBehavior => inner.ValueBoundaryBehavior; - public ManagedTypeInfo AsNativeType(TypePositionInfo info) => _inner.AsNativeType(info); - public IEnumerable Generate(TypePositionInfo info, StubCodeContext context) + public IEnumerable Generate(StubIdentifierContext context) { - if (context.CurrentStage == StubCodeContext.Stage.Setup) + if (context.CurrentStage == StubIdentifierContext.Stage.Setup) { return GenerateSetupStatements(); } - if (context.CurrentStage == StubCodeContext.Stage.CleanupCallerAllocated) + if (context.CurrentStage == StubIdentifierContext.Stage.CleanupCallerAllocated) { return GenerateStatementsFromInner(new OwnedValueCodeContext(context)); } @@ -162,44 +162,32 @@ public IEnumerable Generate(TypePositionInfo info, StubCodeCont IEnumerable GenerateSetupStatements() { - foreach (var statement in GenerateStatementsFromInner(context)) - { - yield return statement; - } - - yield return OwnershipTrackingHelpers.DeclareOriginalValueIdentifier(info, context, AsNativeType(info)); + return [ + ..GenerateStatementsFromInner(new OwnedValueCodeContext(context)), + OwnershipTrackingHelpers.DeclareOriginalValueIdentifier(inner.TypeInfo, context, NativeType) + ]; } - IEnumerable GenerateStatementsFromInner(StubCodeContext contextForStage) + IEnumerable GenerateStatementsFromInner(StubIdentifierContext contextForStage) { - return _inner.Generate(info, contextForStage); + return inner.Generate(contextForStage); } } - public SignatureBehavior GetNativeSignatureBehavior(TypePositionInfo info) => _inner.GetNativeSignatureBehavior(info); - public ValueBoundaryBehavior GetValueBoundaryBehavior(TypePositionInfo info, StubCodeContext context) => _inner.GetValueBoundaryBehavior(info, context); - public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, TypePositionInfo info, StubCodeContext context, out GeneratorDiagnostic? diagnostic) - => _inner.SupportsByValueMarshalKind(marshalKind, info, context, out diagnostic); - public bool UsesNativeIdentifier(TypePositionInfo info, StubCodeContext context) => _inner.UsesNativeIdentifier(info, context); + public ByValueMarshalKindSupport SupportsByValueMarshalKind(ByValueContentsMarshalKind marshalKind, out GeneratorDiagnostic? diagnostic) + => inner.SupportsByValueMarshalKind(marshalKind, out diagnostic); } -#pragma warning disable SA1400 // Access modifier should be declared https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3659 - file sealed record OwnedValueCodeContext : StubCodeContext -#pragma warning restore SA1400 // Access modifier should be declared + file sealed record OwnedValueCodeContext : StubIdentifierContext { - private readonly StubCodeContext _innerContext; + private readonly StubIdentifierContext _innerContext; - public OwnedValueCodeContext(StubCodeContext innerContext) + public OwnedValueCodeContext(StubIdentifierContext innerContext) { _innerContext = innerContext; CurrentStage = innerContext.CurrentStage; - Direction = innerContext.Direction; } - public override bool SingleFrameSpansNativeContext => _innerContext.SingleFrameSpansNativeContext; - - public override bool AdditionalTemporaryStateLivesAcrossStages => _innerContext.AdditionalTemporaryStateLivesAcrossStages; - public override (string managed, string native) GetIdentifiers(TypePositionInfo info) { var (managed, _) = _innerContext.GetIdentifiers(info); @@ -209,14 +197,12 @@ public override (string managed, string native) GetIdentifiers(TypePositionInfo public override string GetAdditionalIdentifier(TypePositionInfo info, string name) => _innerContext.GetAdditionalIdentifier(info, name); } -#pragma warning disable SA1400 // Access modifier should be declared https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3659 file static class OwnershipTrackingHelpers -#pragma warning restore SA1400 // Access modifier should be declared { public const string OwnOriginalValueIdentifier = "ownOriginal"; public const string OriginalValueIdentifier = "original"; - public static StatementSyntax DeclareOriginalValueIdentifier(TypePositionInfo info, StubCodeContext context, ManagedTypeInfo nativeType) + public static StatementSyntax DeclareOriginalValueIdentifier(TypePositionInfo info, StubIdentifierContext context, ManagedTypeInfo nativeType) { // = ; return LocalDeclarationStatement( diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/MarshallingAttributeInfo.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/MarshallingAttributeInfo.cs index 8177de0b1fd..36f56c08bc7 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/MarshallingAttributeInfo.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/MarshallingAttributeInfo.cs @@ -47,16 +47,6 @@ public sealed record NoMarshallingInfo : MarshallingInfo private NoMarshallingInfo() { } } - /// - /// Marshalling information is lacking because of support not because it is - /// unknown or non-existent. - /// - /// - /// An indication of "missing support" will trigger the fallback logic, which is - /// the forwarder marshaller. - /// - public record MissingSupportMarshallingInfo : MarshallingInfo; - /// /// Character encoding enumeration. /// @@ -129,18 +119,6 @@ public sealed record NativeLinearCollectionMarshallingInfo( EntryPointType, Marshallers); - /// - /// Marshalling information is lacking because of support not because it is - /// unknown or non-existent. Includes information about element types in case - /// we need to rehydrate the marshalling info into an attribute for the fallback marshaller. - /// - /// - /// An indication of "missing support" will trigger the fallback logic, which is - /// the forwarder marshaller. - /// - public sealed record MissingSupportCollectionMarshallingInfo(CountInfo CountInfo, MarshallingInfo ElementMarshallingInfo) : MissingSupportMarshallingInfo; - - /// /// Marshal an exception based on the same rules as the built-in COM system based on the unmanaged type of the native return marshaller. /// diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Microsoft.Interop.SourceGeneration.csproj b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Microsoft.Interop.SourceGeneration.csproj index 05f7e553e41..ecbd98eb2b9 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Microsoft.Interop.SourceGeneration.csproj +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/Microsoft.Interop.SourceGeneration.csproj @@ -18,10 +18,12 @@ + + diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/NativeToManagedStubCodeContext.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/NativeToManagedStubCodeContext.cs deleted file mode 100644 index 51c71838b76..00000000000 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/NativeToManagedStubCodeContext.cs +++ /dev/null @@ -1,63 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System; -using System.Diagnostics; -using Microsoft.CodeAnalysis.CSharp.Syntax; - -namespace Microsoft.Interop -{ - public sealed record NativeToManagedStubCodeContext : StubCodeContext - { - public override bool SingleFrameSpansNativeContext => false; - - public override bool AdditionalTemporaryStateLivesAcrossStages => true; - - private const string InvokeReturnIdentifier = "__invokeRetVal"; - private const string InvokeReturnIdentifierNative = "__invokeRetValUnmanaged"; - private readonly string _returnIdentifier; - private readonly string _nativeReturnIdentifier; - - public NativeToManagedStubCodeContext( - string returnIdentifier, - string nativeReturnIdentifier) - { - _returnIdentifier = returnIdentifier; - _nativeReturnIdentifier = nativeReturnIdentifier; - Direction = MarshalDirection.UnmanagedToManaged; - } - - public override (string managed, string native) GetIdentifiers(TypePositionInfo info) - { - // If the info is in the native return position, then we need to generate a name to use - // for both the managed and native values since there is no name in the signature for the return value. - if (info.IsNativeReturnPosition) - { - // If the info is in the native exception position, - // then we're going to return using name of the native return identifier. - // We use the provided instance identifier as that represents - // the name of the exception variable specified in the catch clause. - if (info.IsManagedExceptionPosition) - { - return (info.InstanceIdentifier, _nativeReturnIdentifier); - } - return (_returnIdentifier, _nativeReturnIdentifier); - } - // If the info is in the managed return position but is not in the native return position, - // then that means that the stub is introducing an additional info for the return position. - // This element can be in any position in the native signature, - // but since it isn't in the managed signature, there is no name in source for this info, so we must provide one here. - // We can't use ReturnIdentifier or ReturnNativeIdentifier since that will be used by the return value of the stub itself. - // As a result, we generate another name for the native return value. - if (info.IsManagedReturnPosition) - { - return (InvokeReturnIdentifier, InvokeReturnIdentifierNative); - } - - // If the info isn't in either the managed or native return position, - // then we can use the base implementation since we have an identifier name provided - // in the original metadata. - return base.GetIdentifiers(info); - } - } -} diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/SafeHandleMarshallingInfoProvider.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/SafeHandleMarshallingInfoProvider.cs index dd30b31b14f..030dd7ab672 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/SafeHandleMarshallingInfoProvider.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/SafeHandleMarshallingInfoProvider.cs @@ -13,34 +13,28 @@ namespace Microsoft.Interop /// /// This class supports generating marshalling info for SafeHandle-derived types. /// - public sealed class SafeHandleMarshallingInfoProvider : ITypeBasedMarshallingInfoProvider + public sealed class SafeHandleMarshallingInfoProvider(Compilation compilation) : ITypeBasedMarshallingInfoProvider { - private readonly Compilation _compilation; - private readonly INamedTypeSymbol _safeHandleMarshallerType; - private readonly ITypeSymbol _containingScope; - - public SafeHandleMarshallingInfoProvider(Compilation compilation, ITypeSymbol containingScope) - { - _compilation = compilation; - _safeHandleMarshallerType = compilation.GetBestTypeByMetadataName(TypeNames.System_Runtime_InteropServices_Marshalling_SafeHandleMarshaller_Metadata); - _containingScope = containingScope; - } + private readonly INamedTypeSymbol? _safeHandleType = compilation.GetBestTypeByMetadataName(TypeNames.System_Runtime_InteropServices_SafeHandle); + private readonly INamedTypeSymbol? _safeHandleMarshallerType = compilation.GetBestTypeByMetadataName(TypeNames.System_Runtime_InteropServices_Marshalling_SafeHandleMarshaller_Metadata); public bool CanProvideMarshallingInfoForType(ITypeSymbol type) { - // Check for an implicit SafeHandle conversion. + // Check if type derives from SafHandle // The SafeHandle type might not be defined if we're using one of the test CoreLib implementations used for NativeAOT. - ITypeSymbol? safeHandleType = _compilation.GetTypeByMetadataName(TypeNames.System_Runtime_InteropServices_SafeHandle); - if (safeHandleType is not null) + if (_safeHandleType is null) + { + return false; + } + + for (ITypeSymbol? currentType = type; currentType is not null; currentType = currentType.BaseType) { - CodeAnalysis.Operations.CommonConversion conversion = _compilation.ClassifyCommonConversion(type, safeHandleType); - if (conversion.Exists - && conversion.IsImplicit - && (conversion.IsReference || conversion.IsIdentity)) + if (currentType.Equals(_safeHandleType, SymbolEqualityComparer.Default)) { return true; } } + return false; } @@ -59,18 +53,18 @@ public MarshallingInfo GetMarshallingInfo(ITypeSymbol type, int indirectionDepth } } - // If we don't have the SafeHandleMarshaller type, then we'll return a MissingSupportMarshallingInfo + // If we don't have the SafeHandleMarshaller type, then we'll return NoMarshallingInfo, // indicating that we don't support marshalling SafeHandles with source-generated marshalling. if (_safeHandleMarshallerType is null) { - return new MissingSupportMarshallingInfo(); + return NoMarshallingInfo.Instance; } INamedTypeSymbol entryPointType = _safeHandleMarshallerType.Construct(type); if (!ManualTypeMarshallingHelper.TryGetValueMarshallersFromEntryType( entryPointType, type, - _compilation, + compilation, out CustomTypeMarshallers? marshallers)) { return NoMarshallingInfo.Instance; diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/StubCodeContext.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/StubCodeContext.cs index 8bfd20eed83..7a39afb5c5d 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/StubCodeContext.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/StubCodeContext.cs @@ -3,142 +3,53 @@ using System; using System.Collections.Generic; +using System.Text; namespace Microsoft.Interop { - public abstract record StubCodeContext + /// + /// A description of how the code generator will combine the code from different stages of the stub and how it will call into any native context of the stub. + /// + /// The stub's code is emitted in a single frame and the native context is a callee of that frame. + /// Additional state defined by code generators is preserved across all stages of the generated stub. + /// General options that control how code is emitted. + /// The direction the stub is calling. + /// + /// Stubs that emit code into a single frame that spans the native context can do two things: + /// + /// A fixed statement can be used on an individual value in the stage and the pointer can be passed to native code. + /// Memory can be allocated via the stackalloc keyword and will live through the full native context of the call. + /// + /// + /// When is false, any additional variables can only be considered to have the state they had immediately after a setup phase. + /// + public sealed record StubCodeContext( + bool SingleFrameSpansNativeContext, + bool AdditionalTemporaryStateLivesAcrossStages, + MarshalDirection Direction) { - /// - /// Code generation stage - /// - public enum Stage - { - /// - /// Invalid stage - /// - Invalid, - - /// - /// Perform any setup required - /// - Setup, - - /// - /// Convert managed data to native data - /// - Marshal, - - /// - /// Pin data in preparation for calling the generated P/Invoke - /// - Pin, - - /// - /// Convert managed data to native data, assuming that any values pinned in the stage are pinned. - /// - PinnedMarshal, - - /// - /// Call the generated P/Invoke - /// - /// - /// should provide the - /// argument to pass to the P/Invoke - /// - Invoke, - - /// - /// Capture native values to ensure that we do not leak if an exception is thrown during unmarshalling - /// - UnmarshalCapture, - - /// - /// Convert native data to managed data - /// - Unmarshal, - - /// - /// Notify a marshaller object that the Invoke stage and all stages preceding the Invoke stage - /// successfully completed without any exceptions. - /// - NotifyForSuccessfulInvoke, + public static readonly StubCodeContext DefaultManagedToNativeStub = new( + SingleFrameSpansNativeContext: true, + AdditionalTemporaryStateLivesAcrossStages: true, + Direction: MarshalDirection.ManagedToUnmanaged); - /// - /// Perform any cleanup required on caller allocated resources - /// - CleanupCallerAllocated, + public static readonly StubCodeContext DefaultNativeToManagedStub = new( + SingleFrameSpansNativeContext: false, + AdditionalTemporaryStateLivesAcrossStages: true, + Direction: MarshalDirection.UnmanagedToManaged); - /// - /// Perform any cleanup required on callee allocated resources - /// - CleanupCalleeAllocated, - - /// - /// Convert native data to managed data even in the case of an exception during - /// the non-cleanup phases. - /// - GuaranteedUnmarshal - } - - public CodeEmitOptions CodeEmitOptions { get; init; } = new(SkipInit: true); - - /// - /// The current stage being generated. - /// - public Stage CurrentStage { get; init; } = Stage.Invalid; - - public MarshalDirection Direction { get; init; } = MarshalDirection.ManagedToUnmanaged; - - /// - /// The stub emits code that runs in a single stack frame and the frame spans over the native context. - /// - /// - /// Stubs that emit code into a single frame that spans the native context can do two things: - /// - /// A fixed statement can be used on an individual value in the stage and the pointer can be passed to native code. - /// Memory can be allocated via the stackalloc keyword and will live through the full native context of the call. - /// - /// - public abstract bool SingleFrameSpansNativeContext { get; } - - /// - /// Additional variables other than the {managedIdentifier} and {nativeIdentifier} variables can be added to the stub to track additional state for the marshaller in the stub in the Setup phase, and they will live across all phases of the stub. - /// - /// - /// When this property is false, any additional variables can only be considered to have the state they had immediately after the Setup phase. - /// - public abstract bool AdditionalTemporaryStateLivesAcrossStages { get; } - - /// - /// If this context is a nested context, return the parent context. Otherwise, return null. - /// - public StubCodeContext? ParentContext { get; protected init; } - - /// - /// Suffix for all generated native identifiers. - /// - public const string GeneratedNativeIdentifierSuffix = "_native"; - - /// - /// Get managed and native instance identifiers for the - /// - /// Object for which to get identifiers - /// Managed and native identifiers - public virtual (string managed, string native) GetIdentifiers(TypePositionInfo info) + public static StubCodeContext CreateElementMarshallingContext(StubCodeContext containingContext) { - return (info.InstanceIdentifier, $"__{info.InstanceIdentifier.TrimStart('@')}{GeneratedNativeIdentifierSuffix}"); + return new StubCodeContext( + SingleFrameSpansNativeContext: false, + AdditionalTemporaryStateLivesAcrossStages: false, + Direction: containingContext.Direction) + { + ElementIndirectionLevel = containingContext.ElementIndirectionLevel + 1, + }; } - /// - /// Compute identifiers that are unique for this generator - /// - /// TypePositionInfo the new identifier is used in service of. - /// Name of variable. - /// New identifier name for use. - public virtual string GetAdditionalIdentifier(TypePositionInfo info, string name) - { - return $"{GetIdentifiers(info).native}__{name}"; - } + public int ElementIndirectionLevel { get; init; } /// /// Compute if the provided element is the return element for the stub that is being generated (not any inner call). @@ -147,16 +58,7 @@ public virtual string GetAdditionalIdentifier(TypePositionInfo info, string name /// true if the element is in the return position for this stub; otherwise, false. public bool IsInStubReturnPosition(TypePositionInfo info) { - if (Direction == MarshalDirection.ManagedToUnmanaged) - { - return info.IsManagedReturnPosition; - } - else if (Direction == MarshalDirection.UnmanagedToManaged) - { - return info.IsNativeReturnPosition; - } - - throw new InvalidOperationException("Stub contexts should not be bidirectional"); + return MarshallerHelpers.IsInStubReturnPosition(info, Direction); } - } + }; } diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/StubIdentifierContext.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/StubIdentifierContext.cs new file mode 100644 index 00000000000..97b75be2bab --- /dev/null +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/StubIdentifierContext.cs @@ -0,0 +1,119 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Generic; + +namespace Microsoft.Interop +{ + public abstract record StubIdentifierContext + { + /// + /// Code generation stage + /// + public enum Stage + { + /// + /// Invalid stage + /// + Invalid, + + /// + /// Perform any setup required + /// + Setup, + + /// + /// Convert managed data to native data + /// + Marshal, + + /// + /// Pin data in preparation for calling the generated P/Invoke + /// + Pin, + + /// + /// Convert managed data to native data, assuming that any values pinned in the stage are pinned. + /// + PinnedMarshal, + + /// + /// Call the generated P/Invoke + /// + /// + /// should provide the + /// argument to pass to the P/Invoke + /// + Invoke, + + /// + /// Capture native values to ensure that we do not leak if an exception is thrown during unmarshalling + /// + UnmarshalCapture, + + /// + /// Convert native data to managed data + /// + Unmarshal, + + /// + /// Notify a marshaller object that the Invoke stage and all stages preceding the Invoke stage + /// successfully completed without any exceptions. + /// + NotifyForSuccessfulInvoke, + + /// + /// Perform any cleanup required on caller allocated resources + /// + CleanupCallerAllocated, + + /// + /// Perform any cleanup required on callee allocated resources + /// + CleanupCalleeAllocated, + + /// + /// Convert native data to managed data even in the case of an exception during + /// the non-cleanup phases. + /// + GuaranteedUnmarshal + } + + /// + /// The current stage being generated. + /// + public Stage CurrentStage { get; init; } = Stage.Invalid; + + /// + /// Options to control how some code constructs are emitted. + /// + public CodeEmitOptions CodeEmitOptions { get; init; } + + /// + /// Suffix for all generated native identifiers. + /// + public const string GeneratedNativeIdentifierSuffix = "_native"; + + /// + /// Get managed and native instance identifiers for the + /// + /// Object for which to get identifiers + /// Managed and native identifiers + public virtual (string managed, string native) GetIdentifiers(TypePositionInfo info) + { + return (info.InstanceIdentifier, $"__{info.InstanceIdentifier.TrimStart('@')}{GeneratedNativeIdentifierSuffix}"); + } + + /// + /// Compute identifiers that are unique for this generator + /// + /// TypePositionInfo the new identifier is used in service of. + /// Name of variable. + /// New identifier name for use. + public virtual string GetAdditionalIdentifier(TypePositionInfo info, string name) + { + return $"{GetIdentifiers(info).native}__{name}"; + } + } +} diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/TypePositionInfo.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/TypePositionInfo.cs index 69654c34c4f..f3b6b790ec4 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/TypePositionInfo.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/TypePositionInfo.cs @@ -80,6 +80,11 @@ public static int IncrementIndex(int index) public int NativeIndex { get; init; } = UnsetIndex; public bool IsExplicitThis { get; init; } + public bool PositionsEqual(TypePositionInfo other) + { + return ManagedIndex == other.ManagedIndex && NativeIndex == other.NativeIndex; + } + public static TypePositionInfo CreateForParameter(IParameterSymbol paramSymbol, MarshallingInfo marshallingInfo, Compilation compilation) { var (byValueContentsMarshalKind, inLocation, outLocation) = GetByValueContentsMarshalKind(paramSymbol.GetAttributes(), compilation); diff --git a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/VariableDeclarations.cs b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/VariableDeclarations.cs index 2d693334005..fb10fd2f74a 100644 --- a/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/VariableDeclarations.cs +++ b/src/libraries/System.Runtime.InteropServices/gen/Microsoft.Interop.SourceGeneration/VariableDeclarations.cs @@ -13,12 +13,12 @@ public struct VariableDeclarations { public ImmutableArray Initializations { get; init; } public ImmutableArray Variables { get; init; } - public static VariableDeclarations GenerateDeclarationsForManagedToUnmanaged(BoundGenerators marshallers, StubCodeContext context, bool initializeDeclarations) + public static VariableDeclarations GenerateDeclarationsForManagedToUnmanaged(BoundGenerators marshallers, StubIdentifierContext context, bool initializeDeclarations) { ImmutableArray.Builder initializations = ImmutableArray.CreateBuilder(); ImmutableArray.Builder variables = ImmutableArray.CreateBuilder(); - foreach (BoundGenerator marshaller in marshallers.NativeParameterMarshallers) + foreach (IBoundMarshallingGenerator marshaller in marshallers.NativeParameterMarshallers) { TypePositionInfo info = marshaller.TypeInfo; if (info.IsManagedReturnPosition) @@ -52,7 +52,7 @@ public static VariableDeclarations GenerateDeclarationsForManagedToUnmanaged(Bou Variables = variables.ToImmutable() }; - static void AppendVariableDeclarations(ImmutableArray.Builder statementsToUpdate, BoundGenerator marshaller, StubCodeContext context, bool initializeToDefault) + static void AppendVariableDeclarations(ImmutableArray.Builder statementsToUpdate, IBoundMarshallingGenerator marshaller, StubIdentifierContext context, bool initializeToDefault) { (string managed, string native) = context.GetIdentifiers(marshaller.TypeInfo); @@ -66,22 +66,22 @@ static void AppendVariableDeclarations(ImmutableArray.Builder initializations = ImmutableArray.CreateBuilder(); ImmutableArray.Builder variables = ImmutableArray.CreateBuilder(); - foreach (BoundGenerator marshaller in marshallers.NativeParameterMarshallers) + foreach (IBoundMarshallingGenerator marshaller in marshallers.NativeParameterMarshallers) { TypePositionInfo info = marshaller.TypeInfo; if (info.IsNativeReturnPosition || info.IsManagedReturnPosition) @@ -109,14 +109,14 @@ public static VariableDeclarations GenerateDeclarationsForUnmanagedToManaged(Bou Variables = variables.ToImmutable() }; - static void AppendVariableDeclarations(ImmutableArray.Builder statementsToUpdate, BoundGenerator marshaller, StubCodeContext context, bool initializeToDefault) + static void AppendVariableDeclarations(ImmutableArray.Builder statementsToUpdate, IBoundMarshallingGenerator marshaller, StubIdentifierContext context, bool initializeToDefault) { (string managed, string native) = context.GetIdentifiers(marshaller.TypeInfo); // Declare variable for return value if (marshaller.TypeInfo.IsNativeReturnPosition) { - bool nativeReturnUsesNativeIdentifier = marshaller.Generator.UsesNativeIdentifier(marshaller.TypeInfo, context); + bool nativeReturnUsesNativeIdentifier = marshaller.UsesNativeIdentifier; // Always initialize the return value. statementsToUpdate.Add(Declare( @@ -127,23 +127,23 @@ static void AppendVariableDeclarations(ImmutableArray - - - - - - - - - diff --git a/src/libraries/System.Runtime.InteropServices/src/System.Runtime.InteropServices.csproj b/src/libraries/System.Runtime.InteropServices/src/System.Runtime.InteropServices.csproj index 4a470747ab1..41db022b080 100644 --- a/src/libraries/System.Runtime.InteropServices/src/System.Runtime.InteropServices.csproj +++ b/src/libraries/System.Runtime.InteropServices/src/System.Runtime.InteropServices.csproj @@ -76,10 +76,6 @@ - - - - diff --git a/src/libraries/System.Runtime.InteropServices/src/System/Runtime/InteropServices/Marshalling/ComObject.cs b/src/libraries/System.Runtime.InteropServices/src/System/Runtime/InteropServices/Marshalling/ComObject.cs index a88f3edaecf..1294b6fc6e9 100644 --- a/src/libraries/System.Runtime.InteropServices/src/System/Runtime/InteropServices/Marshalling/ComObject.cs +++ b/src/libraries/System.Runtime.InteropServices/src/System/Runtime/InteropServices/Marshalling/ComObject.cs @@ -16,7 +16,10 @@ namespace System.Runtime.InteropServices.Marshalling /// public sealed unsafe class ComObject : IDynamicInterfaceCastable, IUnmanagedVirtualMethodTableProvider, ComImportInteropInterfaceDetailsStrategy.IComImportAdapter { + [FeatureSwitchDefinition("System.Runtime.InteropServices.BuiltInComInterop.IsSupported")] internal static bool BuiltInComSupported { get; } = AppContext.TryGetSwitch("System.Runtime.InteropServices.BuiltInComInterop.IsSupported", out bool supported) ? supported : true; + + [FeatureSwitchDefinition("System.Runtime.InteropServices.Marshalling.EnableGeneratedComInterfaceComImportInterop")] internal static bool ComImportInteropEnabled { get; } = AppContext.TryGetSwitch("System.Runtime.InteropServices.Marshalling.EnableGeneratedComInterfaceComImportInterop", out bool enabled) ? enabled : false; private readonly void* _instancePointer; diff --git a/src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/ComInterfaceGenerator.Unit.Tests.csproj b/src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/ComInterfaceGenerator.Unit.Tests.csproj index 65bccc63b31..cad3ba79d0b 100644 --- a/src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/ComInterfaceGenerator.Unit.Tests.csproj +++ b/src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/ComInterfaceGenerator.Unit.Tests.csproj @@ -13,7 +13,6 @@ - diff --git a/src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/TargetSignatureTests.cs b/src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/TargetSignatureTests.cs index 140106f6cd8..7c0ead99ba5 100644 --- a/src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/TargetSignatureTests.cs +++ b/src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/TargetSignatureTests.cs @@ -333,7 +333,11 @@ await VerifyInvocationWithMultipleProjectsAsync( "DerivedMethod", (newComp, invocation) => { - Assert.Equal(4, Assert.IsAssignableFrom(Assert.IsAssignableFrom(invocation.Target).Operand.ChildOperations.Last()).ConstantValue.Value); + ILocalSymbol vtableSlot = Assert.IsAssignableFrom(invocation.Target).Local; + IVariableDeclaratorOperation vtableSlotDeclarator = Assert.IsAssignableFrom(invocation.SemanticModel!.GetOperation(vtableSlot.DeclaringSyntaxReferences[0].GetSyntax())); + IOperation vtableSlotInitialization = vtableSlotDeclarator.Initializer!.Value; + + Assert.Equal(4, Assert.IsAssignableFrom(Assert.IsAssignableFrom(vtableSlotInitialization).Operand.ChildOperations.Last()).ConstantValue.Value); }, VerifyCS.DiagnosticWithArguments(GeneratorDiagnostics.BaseInterfaceDefinedInOtherAssembly, "IComInterface2", "IComInterface").WithLocation(1).WithSeverity(DiagnosticSeverity.Warning)); } @@ -381,7 +385,11 @@ await VerifyInvocationWithMultipleProjectsAsync( "DerivedMethod", (newComp, invocation) => { - Assert.Equal(5, Assert.IsAssignableFrom(Assert.IsAssignableFrom(invocation.Target).Operand.ChildOperations.Last()).ConstantValue.Value); + ILocalSymbol vtableSlot = Assert.IsAssignableFrom(invocation.Target).Local; + IVariableDeclaratorOperation vtableSlotDeclarator = Assert.IsAssignableFrom(invocation.SemanticModel!.GetOperation(vtableSlot.DeclaringSyntaxReferences[0].GetSyntax())); + IOperation vtableSlotInitialization = vtableSlotDeclarator.Initializer!.Value; + + Assert.Equal(5, Assert.IsAssignableFrom(Assert.IsAssignableFrom(vtableSlotInitialization).Operand.ChildOperations.Last()).ConstantValue.Value); }, VerifyCS.DiagnosticWithArguments(GeneratorDiagnostics.BaseInterfaceDefinedInOtherAssembly, "IComInterface3", "IComInterface2").WithLocation(1).WithSeverity(DiagnosticSeverity.Warning)); } @@ -429,7 +437,11 @@ await VerifyInvocationWithMultipleProjectsAsync( "DerivedMethod", (newComp, invocation) => { - Assert.Equal(5, Assert.IsAssignableFrom(Assert.IsAssignableFrom(invocation.Target).Operand.ChildOperations.Last()).ConstantValue.Value); + ILocalSymbol vtableSlot = Assert.IsAssignableFrom(invocation.Target).Local; + IVariableDeclaratorOperation vtableSlotDeclarator = Assert.IsAssignableFrom(invocation.SemanticModel!.GetOperation(vtableSlot.DeclaringSyntaxReferences[0].GetSyntax())); + IOperation vtableSlotInitialization = vtableSlotDeclarator.Initializer!.Value; + + Assert.Equal(5, Assert.IsAssignableFrom(Assert.IsAssignableFrom(vtableSlotInitialization).Operand.ChildOperations.Last()).ConstantValue.Value); }, VerifyCS.DiagnosticWithArguments(GeneratorDiagnostics.BaseInterfaceDefinedInOtherAssembly, "IComInterface2", "IComInterface").WithLocation(1).WithSeverity(DiagnosticSeverity.Warning)); } diff --git a/src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/VTableGeneratorOutputShape.cs b/src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/VTableGeneratorOutputShape.cs index 80c7702e730..cec896d47ca 100644 --- a/src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/VTableGeneratorOutputShape.cs +++ b/src/libraries/System.Runtime.InteropServices/tests/ComInterfaceGenerator.Unit.Tests/VTableGeneratorOutputShape.cs @@ -17,7 +17,7 @@ namespace ComInterfaceGenerator.Unit.Tests public class VTableGeneratorOutputShape { [Fact] - public async Task NativeInterfaceNestedInUserInterface() + public void NativeInterfaceNestedInUserInterface() { string source = $$""" using System.Runtime.InteropServices; @@ -31,7 +31,7 @@ partial interface INativeAPI : IUnmanagedInterfaceType void Method(); } """; - Compilation comp = await TestUtils.CreateCompilation(source); + Compilation comp = TestUtils.CreateCompilation(source); TestUtils.AssertPreSourceGeneratorCompilation(comp); var newComp = TestUtils.RunGenerators(comp, out _, new Microsoft.Interop.VtableIndexStubGenerator()); @@ -43,7 +43,7 @@ partial interface INativeAPI : IUnmanagedInterfaceType } [Fact] - public async Task NativeInterfaceInheritsFromUserInterface() + public void NativeInterfaceInheritsFromUserInterface() { string source = $$""" using System.Runtime.InteropServices; @@ -57,7 +57,7 @@ partial interface INativeAPI : IUnmanagedInterfaceType void Method(); } """; - Compilation comp = await TestUtils.CreateCompilation(source); + Compilation comp = TestUtils.CreateCompilation(source); TestUtils.AssertPreSourceGeneratorCompilation(comp); var newComp = TestUtils.RunGenerators(comp, out _, new Microsoft.Interop.VtableIndexStubGenerator()); @@ -69,7 +69,7 @@ partial interface INativeAPI : IUnmanagedInterfaceType } [Fact] - public async Task NativeInterfaceImplementsUserInterfaceMethods() + public void NativeInterfaceImplementsUserInterfaceMethods() { string source = $$""" using System.Runtime.InteropServices; @@ -86,7 +86,7 @@ partial interface INativeAPI : IUnmanagedInterfaceType // Ensure we can implement the native interface without defining any implementations. class C : INativeAPI.Native {} """; - Compilation comp = await TestUtils.CreateCompilation(source); + Compilation comp = TestUtils.CreateCompilation(source); // Allow the Native nested type name to be missing in the pre-source-generator compilation TestUtils.AssertPreSourceGeneratorCompilation(comp, "CS0426"); @@ -95,7 +95,7 @@ class C : INativeAPI.Native {} } [Fact] - public async Task NativeInterfaceHasDynamicInterfaceCastableImplementationAttribute() + public void NativeInterfaceHasDynamicInterfaceCastableImplementationAttribute() { string source = $$""" using System.Runtime.InteropServices; @@ -109,7 +109,7 @@ partial interface INativeAPI : IUnmanagedInterfaceType void Method(); } """; - Compilation comp = await TestUtils.CreateCompilation(source); + Compilation comp = TestUtils.CreateCompilation(source); TestUtils.AssertPreSourceGeneratorCompilation(comp); var newComp = TestUtils.RunGenerators(comp, out _, new Microsoft.Interop.VtableIndexStubGenerator()); @@ -126,7 +126,7 @@ partial interface INativeAPI : IUnmanagedInterfaceType } [Fact] - public async Task NativeInterfaceHasStaticMethodWithSameNameWithExpectedPrefixWithUnmanagedCallersOnly() + public void NativeInterfaceHasStaticMethodWithSameNameWithExpectedPrefixWithUnmanagedCallersOnly() { string source = $$""" using System.Runtime.InteropServices; @@ -140,7 +140,7 @@ partial interface INativeAPI : IUnmanagedInterfaceType void Method(); } """; - Compilation comp = await TestUtils.CreateCompilation(source); + Compilation comp = TestUtils.CreateCompilation(source); TestUtils.AssertPreSourceGeneratorCompilation(comp); var newComp = TestUtils.RunGenerators(comp, out _, new Microsoft.Interop.VtableIndexStubGenerator()); diff --git a/src/libraries/System.Runtime.InteropServices/tests/Common/TargetFrameworkOptions.cs b/src/libraries/System.Runtime.InteropServices/tests/Common/TargetFrameworkOptions.cs deleted file mode 100644 index a10043fde41..00000000000 --- a/src/libraries/System.Runtime.InteropServices/tests/Common/TargetFrameworkOptions.cs +++ /dev/null @@ -1,73 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System; -using System.Diagnostics; -using System.Diagnostics.CodeAnalysis; -using System.Reflection; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.Diagnostics; -using Microsoft.Interop; -using Microsoft.Interop.UnitTests; -using SourceGenerators.Tests; - -namespace Microsoft.Interop.UnitTests -{ - /// - /// An implementation of that provides configuration in code - /// of the target framework options. Used when testing interop source generators. - /// - public class TargetFrameworkConfigOptions : AnalyzerConfigOptions - { - private static readonly string _liveTargetFrameworkVersion; - private readonly string _targetFrameworkIdentifier; - private readonly string _targetFrameworkVersion; - - static TargetFrameworkConfigOptions() - { - Version liveVersion = Version.Parse( - typeof(TargetFrameworkConfigOptions) - .Assembly.GetCustomAttribute()! - .InformationalVersion.Split('-')[0]); - _liveTargetFrameworkVersion = $"v{liveVersion.ToString(2)}"; - } - - public TargetFrameworkConfigOptions(TestTargetFramework targetFramework) - { - _targetFrameworkIdentifier = targetFramework switch - { - TestTargetFramework.Framework => ".NETFramework", - TestTargetFramework.Standard => ".NETStandard", - _ => ".NETCoreApp" - }; - _targetFrameworkVersion = targetFramework switch - { - TestTargetFramework.Framework => "v4.8", - TestTargetFramework.Standard => "v2.1", - TestTargetFramework.Core => "v3.1", - TestTargetFramework.Net6 => "v6.0", - TestTargetFramework.Net => _liveTargetFrameworkVersion, - _ => throw new UnreachableException() - }; - } - - public override bool TryGetValue(string key, [NotNullWhen(true)] out string? value) - { - switch (key) - { - case "build_property.TargetFrameworkIdentifier": - value = _targetFrameworkIdentifier; - return true; - - case "build_property.TargetFrameworkVersion": - value = _targetFrameworkVersion; - return true; - - default: - value = null; - return false; - } - } - } - -} diff --git a/src/libraries/System.Runtime.InteropServices/tests/Common/TestUtils.cs b/src/libraries/System.Runtime.InteropServices/tests/Common/TestUtils.cs index cd065f54a48..95a8b367f77 100644 --- a/src/libraries/System.Runtime.InteropServices/tests/Common/TestUtils.cs +++ b/src/libraries/System.Runtime.InteropServices/tests/Common/TestUtils.cs @@ -22,9 +22,6 @@ namespace Microsoft.Interop.UnitTests /// /// The target framework to compile against. /// - /// - /// This enumeration is for testing only and is not to be confused with the product's TargetFramework enum. - /// public enum TestTargetFramework { /// @@ -32,21 +29,13 @@ public enum TestTargetFramework /// Framework, /// - /// The latest supported .NET Core version. + /// .NET standard 2.0 /// - Core, + Standard2_0, /// - /// The latest supported .NET Standard version. + /// .NET Standard 2.1 /// - Standard, - /// - /// The latest supported (live-built) .NET version. - /// - Net, - /// - /// .NET version 6.0. - /// - Net6, + Standard2_1 } public static class TestUtils @@ -136,9 +125,9 @@ public static void AssertPostSourceGeneratorCompilation(Compilation comp, params /// Prepocessor symbols /// Indicate if the compilation should allow unsafe code blocks /// The resulting compilation - public static Task CreateCompilation(string source, TestTargetFramework targetFramework = TestTargetFramework.Net, OutputKind outputKind = OutputKind.DynamicallyLinkedLibrary, IEnumerable? refs = null, IEnumerable? preprocessorSymbols = null, bool allowUnsafe = true) + public static Compilation CreateCompilation(string source, OutputKind outputKind = OutputKind.DynamicallyLinkedLibrary, IEnumerable? refs = null, IEnumerable? preprocessorSymbols = null, bool allowUnsafe = true) { - return CreateCompilation(new[] { source }, targetFramework, outputKind, refs, preprocessorSymbols, allowUnsafe); + return CreateCompilation([source], outputKind, refs, preprocessorSymbols, allowUnsafe); } /// @@ -151,12 +140,11 @@ public static Task CreateCompilation(string source, TestTargetFrame /// Prepocessor symbols /// Indicate if the compilation should allow unsafe code blocks /// The resulting compilation - public static Task CreateCompilation(string[] sources, TestTargetFramework targetFramework = TestTargetFramework.Net, OutputKind outputKind = OutputKind.DynamicallyLinkedLibrary, IEnumerable? refs = null, IEnumerable? preprocessorSymbols = null, bool allowUnsafe = true) + public static Compilation CreateCompilation(string[] sources, OutputKind outputKind = OutputKind.DynamicallyLinkedLibrary, IEnumerable? refs = null, IEnumerable? preprocessorSymbols = null, bool allowUnsafe = true) { return CreateCompilation( sources.Select(source => CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Preview, preprocessorSymbols: preprocessorSymbols))).ToArray(), - targetFramework, outputKind, refs, allowUnsafe); @@ -171,15 +159,9 @@ public static Task CreateCompilation(string[] sources, TestTargetFr /// Additional metadata references /// Indicate if the compilation should allow unsafe code blocks /// The resulting compilation - public static async Task CreateCompilation(SyntaxTree[] sources, TestTargetFramework targetFramework = TestTargetFramework.Net, OutputKind outputKind = OutputKind.DynamicallyLinkedLibrary, IEnumerable? refs = null, bool allowUnsafe = true) + public static Compilation CreateCompilation(SyntaxTree[] sources, OutputKind outputKind = OutputKind.DynamicallyLinkedLibrary, IEnumerable? refs = null, bool allowUnsafe = true) { - var referenceAssemblies = await GetReferenceAssemblies(targetFramework); - - // [TODO] Can remove once ancillary logic is removed. - if (targetFramework is TestTargetFramework.Net) - { - referenceAssemblies = referenceAssemblies.Add(GetAncillaryReference()); - } + ImmutableArray referenceAssemblies = [ ..SourceGenerators.Tests.LiveReferencePack.GetMetadataReferences(), GetAncillaryReference() ]; if (refs is not null) { @@ -192,37 +174,6 @@ public static async Task CreateCompilation(SyntaxTree[] sources, Te new CSharpCompilationOptions(outputKind, allowUnsafe: allowUnsafe, specificDiagnosticOptions: BindingRedirectWarnings)); } - /// - /// Get the reference assembly collection for the . - /// - /// The target framework. - /// The reference assembly collection and metadata references - private static async Task> GetReferenceAssemblies(TestTargetFramework targetFramework = TestTargetFramework.Net) - { - // Compute the reference assemblies for the target framework. - if (targetFramework == TestTargetFramework.Net) - { - return SourceGenerators.Tests.LiveReferencePack.GetMetadataReferences(); - } - else - { - var referenceAssembliesSdk = targetFramework switch - { - TestTargetFramework.Framework => ReferenceAssemblies.NetFramework.Net48.Default, - TestTargetFramework.Standard => ReferenceAssemblies.NetStandard.NetStandard21, - TestTargetFramework.Core => ReferenceAssemblies.NetCore.NetCoreApp31, - TestTargetFramework.Net6 => ReferenceAssemblies.Net.Net60, - _ => ReferenceAssemblies.Default - }; - - // Update the reference assemblies to include details from the NuGet.config. - var referenceAssemblies = referenceAssembliesSdk - .WithNuGetConfigFilePath(Path.Combine(Path.GetDirectoryName(typeof(TestUtils).Assembly.Location)!, "NuGet.config")); - - return await ResolveReferenceAssemblies(referenceAssemblies); - } - } - /// /// Get the metadata reference for the ancillary interop helper assembly. /// @@ -267,44 +218,5 @@ public static GeneratorDriver CreateDriver(Compilation c, AnalyzerConfigOptionsP parseOptions: (CSharpParseOptions)c.SyntaxTrees.First().Options, optionsProvider: options, driverOptions: driverOptions); - - private static async Task> ResolveReferenceAssemblies(ReferenceAssemblies referenceAssemblies) - { - try - { - ResolveRedirect.Instance.Start(); - return await referenceAssemblies.ResolveAsync(LanguageNames.CSharp, CancellationToken.None); - } - finally - { - ResolveRedirect.Instance.Stop(); - } - } - - private class ResolveRedirect - { - private const string EnvVarName = "NUGET_PACKAGES"; - - private static readonly ResolveRedirect s_instance = new ResolveRedirect(); - public static ResolveRedirect Instance => s_instance; - - private int _count = 0; - - public void Start() - { - // Set the NuGet package cache location to a subdirectory such that we should always have access to it - Environment.SetEnvironmentVariable(EnvVarName, Path.Combine(Path.GetDirectoryName(typeof(TestUtils).Assembly.Location)!, "packages")); - Interlocked.Increment(ref _count); - } - - public void Stop() - { - int count = Interlocked.Decrement(ref _count); - if (count == 0) - { - Environment.SetEnvironmentVariable(EnvVarName, null); - } - } - } } } diff --git a/src/libraries/System.Runtime.InteropServices/tests/Common/Verifiers/CSharpCodeFixVerifier.cs b/src/libraries/System.Runtime.InteropServices/tests/Common/Verifiers/CSharpCodeFixVerifier.cs index cc815fb1c24..186246d8009 100644 --- a/src/libraries/System.Runtime.InteropServices/tests/Common/Verifiers/CSharpCodeFixVerifier.cs +++ b/src/libraries/System.Runtime.InteropServices/tests/Common/Verifiers/CSharpCodeFixVerifier.cs @@ -117,7 +117,7 @@ public Test() TestState.AdditionalReferences.AddRange(SourceGenerators.Tests.LiveReferencePack.GetMetadataReferences()); TestState.AdditionalReferences.Add(TestUtils.GetAncillaryReference()); - SolutionTransforms.Add(CSharpVerifierHelper.GetAllDiagonsticsEnabledTransform(GetDiagnosticAnalyzers())); + SolutionTransforms.Add(CSharpVerifierHelper.GetAllDiagnosticsEnabledTransform(GetDiagnosticAnalyzers())); } protected override CompilationWithAnalyzers CreateCompilationWithAnalyzers(Compilation compilation, ImmutableArray analyzers, AnalyzerOptions options, CancellationToken cancellationToken) diff --git a/src/libraries/System.Runtime.InteropServices/tests/Common/Verifiers/CSharpSourceGeneratorVerifier.cs b/src/libraries/System.Runtime.InteropServices/tests/Common/Verifiers/CSharpSourceGeneratorVerifier.cs index 36d2be1c0b9..3836d024395 100644 --- a/src/libraries/System.Runtime.InteropServices/tests/Common/Verifiers/CSharpSourceGeneratorVerifier.cs +++ b/src/libraries/System.Runtime.InteropServices/tests/Common/Verifiers/CSharpSourceGeneratorVerifier.cs @@ -82,36 +82,29 @@ internal class Test : CSharpSourceGeneratorTest ReferenceAssemblies.NetFramework.Net48.Default, - TestTargetFramework.Standard => ReferenceAssemblies.NetStandard.NetStandard21, - TestTargetFramework.Core => ReferenceAssemblies.NetCore.NetCoreApp31, - TestTargetFramework.Net6 => ReferenceAssemblies.Net.Net60, - _ => ReferenceAssemblies.Default - }; - } - SolutionTransforms.Add(CSharpVerifierHelper.GetTargetFrameworkAnalyzerOptionsProviderTransform(targetFramework)); + TestTargetFramework.Framework => ReferenceAssemblies.NetFramework.Net48.Default, + TestTargetFramework.Standard2_0 => ReferenceAssemblies.NetStandard.NetStandard20, + TestTargetFramework.Standard2_1 => ReferenceAssemblies.NetStandard.NetStandard21, + _ => ReferenceAssemblies.Default + }; } + public Test(bool referenceAncillaryInterop) - : this(TestTargetFramework.Net) { + // Clear out the default reference assemblies. We explicitly add references from the live ref pack, + // so we don't want the Roslyn test infrastructure to resolve/add any default reference assemblies + ReferenceAssemblies = new ReferenceAssemblies(string.Empty); + TestState.AdditionalReferences.AddRange(SourceGenerators.Tests.LiveReferencePack.GetMetadataReferences()); + if (referenceAncillaryInterop) { TestState.AdditionalReferences.Add(TestUtils.GetAncillaryReference()); } DisabledDiagnostics.Add(GeneratorDiagnostics.Ids.NotRecommendedGeneratedComInterfaceUsage); - SolutionTransforms.Add(CSharpVerifierHelper.GetAllDiagonsticsEnabledTransform(GetDiagnosticAnalyzers())); + SolutionTransforms.Add(CSharpVerifierHelper.GetAllDiagnosticsEnabledTransform(GetDiagnosticAnalyzers())); } protected override CompilationWithAnalyzers CreateCompilationWithAnalyzers(Compilation compilation, ImmutableArray analyzers, AnalyzerOptions options, CancellationToken cancellationToken) diff --git a/src/libraries/System.Runtime.InteropServices/tests/Common/Verifiers/CSharpVerifierHelper.cs b/src/libraries/System.Runtime.InteropServices/tests/Common/Verifiers/CSharpVerifierHelper.cs index 8df1cbb573e..93cb182b6cc 100644 --- a/src/libraries/System.Runtime.InteropServices/tests/Common/Verifiers/CSharpVerifierHelper.cs +++ b/src/libraries/System.Runtime.InteropServices/tests/Common/Verifiers/CSharpVerifierHelper.cs @@ -7,8 +7,6 @@ using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.Diagnostics; -using Microsoft.CodeAnalysis.Testing; -using Microsoft.CodeAnalysis.Text; namespace Microsoft.Interop.UnitTests.Verifiers { @@ -30,7 +28,7 @@ private static ImmutableDictionary GetNullableWarnings return commandLineArguments.CompilationOptions.SpecificDiagnosticOptions; } - internal static Func GetAllDiagonsticsEnabledTransform(IEnumerable analyzers) + internal static Func GetAllDiagnosticsEnabledTransform(IEnumerable analyzers) { return (solution, projectId) => { @@ -71,46 +69,5 @@ internal static Func GetAllDiagonsticsEnabledTran return solution; }; } - - internal static Func GetTargetFrameworkAnalyzerOptionsProviderTransform(TestTargetFramework targetFramework) - { - return (solution, projectId) => - { - var project = solution.GetProject(projectId)!; - string tfmEditorConfig = targetFramework switch - { - TestTargetFramework.Framework => """ - is_global = true - build_property.TargetFrameworkIdentifier = .NETFramework - build_property.TargetFrameworkVersion = v4.8 - """, - TestTargetFramework.Standard => """ - is_global = true - build_property.TargetFrameworkIdentifier = .NETStandard - build_property.TargetFrameworkVersion = v2.0 - """, - TestTargetFramework.Core => """ - is_global = true - build_property.TargetFrameworkIdentifier = .NETCoreApp - build_property.TargetFrameworkVersion = v3.1 - """, - TestTargetFramework.Net6 => """ - is_global = true - build_property.TargetFrameworkIdentifier = .NETCoreApp - build_property.TargetFrameworkVersion = v6.0 - """, - // Replicate the product case where we don't have these properties - // since we don't have a good mechanism to ship MSBuild files from dotnet/runtime - // in the SDK. - TestTargetFramework.Net => string.Empty, - _ => throw new System.Diagnostics.UnreachableException() - }; - return solution.AddAnalyzerConfigDocument( - DocumentId.CreateNewId(projectId), - "TargetFrameworkConfig.editorconfig", - SourceText.From(tfmEditorConfig, encoding: System.Text.Encoding.UTF8), - filePath: "/TargetFrameworkConfig.editorconfig"); - }; - } } } diff --git a/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/AdditionalAttributesOnStub.cs b/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/AdditionalAttributesOnStub.cs index cf85b92c678..e43937d75fa 100644 --- a/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/AdditionalAttributesOnStub.cs +++ b/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/AdditionalAttributesOnStub.cs @@ -49,7 +49,7 @@ static class Marshaller public static S ConvertToManaged(Native n) => default; } """; - await VerifySourceGeneratorAsync(source, "C", "Method", typeof(SkipLocalsInitAttribute).FullName, attributeAdded: true, TestTargetFramework.Net); + await VerifySourceGeneratorAsync(source, "C", "Method", typeof(SkipLocalsInitAttribute).FullName, attributeAdded: true); } [Fact] @@ -63,7 +63,7 @@ partial class C public static partial void Method(); } """; - await VerifySourceGeneratorAsync(source, "C", "Method", typeof(SkipLocalsInitAttribute).FullName, attributeAdded: false, TestTargetFramework.Net); + await VerifySourceGeneratorAsync(source, "C", "Method", typeof(SkipLocalsInitAttribute).FullName, attributeAdded: false); } [Fact] @@ -97,7 +97,7 @@ static class Marshaller public static S ConvertToManaged(Native n) => default; } """; - await VerifySourceGeneratorAsync(source, "C", "Method", typeof(System.CodeDom.Compiler.GeneratedCodeAttribute).FullName, attributeAdded: true, TestTargetFramework.Net); + await VerifySourceGeneratorAsync(source, "C", "Method", typeof(System.CodeDom.Compiler.GeneratedCodeAttribute).FullName, attributeAdded: true); } [Fact] @@ -111,15 +111,12 @@ partial class C public static partial void Method(); } """; - await VerifySourceGeneratorAsync(source, "C", "Method", typeof(System.CodeDom.Compiler.GeneratedCodeAttribute).FullName, attributeAdded: false, TestTargetFramework.Net); + await VerifySourceGeneratorAsync(source, "C", "Method", typeof(System.CodeDom.Compiler.GeneratedCodeAttribute).FullName, attributeAdded: false); } public static IEnumerable GetDownlevelTargetFrameworks() { - yield return new object[] { TestTargetFramework.Net, true }; - yield return new object[] { TestTargetFramework.Net6, true }; - yield return new object[] { TestTargetFramework.Core, false }; - yield return new object[] { TestTargetFramework.Standard, false }; + yield return new object[] { TestTargetFramework.Standard2_0, false }; yield return new object[] { TestTargetFramework.Framework, false }; } @@ -138,7 +135,7 @@ partial class C public static partial bool Method(); } """; - await VerifySourceGeneratorAsync(source, "C", "Method", typeof(SkipLocalsInitAttribute).FullName, attributeAdded: expectSkipLocalsInit, targetFramework); + await VerifyDownlevelSourceGeneratorAsync(source, "C", "Method", typeof(SkipLocalsInitAttribute).FullName, attributeAdded: expectSkipLocalsInit, targetFramework); } [Fact] @@ -172,7 +169,7 @@ static class Marshaller public static S ConvertToManaged(Native n) => default; } """; - await VerifySourceGeneratorAsync(source, "C", "Method", typeof(SkipLocalsInitAttribute).FullName, attributeAdded: false, TestTargetFramework.Net); + await VerifySourceGeneratorAsync(source, "C", "Method", typeof(SkipLocalsInitAttribute).FullName, attributeAdded: false); } [Fact] @@ -206,7 +203,7 @@ static class Marshaller public static S ConvertToManaged(Native n) => default; } """; - await VerifySourceGeneratorAsync(source, "C", "Method", typeof(SkipLocalsInitAttribute).FullName, attributeAdded: false, TestTargetFramework.Net); + await VerifySourceGeneratorAsync(source, "C", "Method", typeof(SkipLocalsInitAttribute).FullName, attributeAdded: false); } [Fact] @@ -244,9 +241,9 @@ static class Marshaller await VerifyCS.VerifySourceGeneratorAsync(source); } - private static Task VerifySourceGeneratorAsync(string source, string typeName, string methodName, string? attributeName, bool attributeAdded, TestTargetFramework targetFramework) + private static Task VerifyDownlevelSourceGeneratorAsync(string source, string typeName, string methodName, string? attributeName, bool attributeAdded, TestTargetFramework targetFramework) { - AttributeAddedTest test = new(typeName, methodName, attributeName, attributeAdded, targetFramework) + AttributeAddedTest test = new(typeName, methodName, attributeName, attributeAdded, targetFramework) { TestCode = source, TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck @@ -254,7 +251,18 @@ private static Task VerifySourceGeneratorAsync(string source, string typeName, s return test.RunAsync(); } - class AttributeAddedTest : VerifyCS.Test + private static Task VerifySourceGeneratorAsync(string source, string typeName, string methodName, string? attributeName, bool attributeAdded) + { + AttributeAddedTest test = new(typeName, methodName, attributeName, attributeAdded) + { + TestCode = source, + TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck + }; + return test.RunAsync(); + } + + class AttributeAddedTest : Microsoft.Interop.UnitTests.Verifiers.CSharpSourceGeneratorVerifier.Test + where TSourceGenerator : new() { private readonly string _typeName; private readonly string _methodName; @@ -270,6 +278,15 @@ public AttributeAddedTest(string typeName, string methodName, string? attributeN _expectAttributeAdded = attributeAdded; } + public AttributeAddedTest(string typeName, string methodName, string? attributeName, bool attributeAdded) + : base(referenceAncillaryInterop: true) + { + _typeName = typeName; + _methodName = methodName; + _attributeName = attributeName; + _expectAttributeAdded = attributeAdded; + } + protected override void VerifyFinalCompilation(Compilation compilation) { ITypeSymbol c = compilation.GetTypeByMetadataName(_typeName)!; diff --git a/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/AttributeForwarding.cs b/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/AttributeForwarding.cs index f2c79633d6e..4abb9a12c1d 100644 --- a/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/AttributeForwarding.cs +++ b/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/AttributeForwarding.cs @@ -331,9 +331,9 @@ await VerifySourceGeneratorAsync( }); } - private static Task VerifySourceGeneratorAsync(string source, Action targetPInvokeAssertion, TestTargetFramework targetFramework = TestTargetFramework.Net) + private static Task VerifySourceGeneratorAsync(string source, Action targetPInvokeAssertion) { - var test = new GeneratedTargetPInvokeTest(targetPInvokeAssertion, targetFramework) + var test = new GeneratedTargetPInvokeTest(targetPInvokeAssertion) { TestCode = source, TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck @@ -346,8 +346,8 @@ class GeneratedTargetPInvokeTest : VerifyCS.Test { private readonly Action _targetPInvokeAssertion; - public GeneratedTargetPInvokeTest(Action targetPInvokeAssertion, TestTargetFramework targetFramework) - :base(targetFramework) + public GeneratedTargetPInvokeTest(Action targetPInvokeAssertion) + :base(referenceAncillaryInterop: false) { _targetPInvokeAssertion = targetPInvokeAssertion; } diff --git a/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/Compiles.cs b/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/Compiles.cs index 7b7e14b6e92..b7d3f37f87a 100644 --- a/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/Compiles.cs +++ b/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/Compiles.cs @@ -438,7 +438,6 @@ public static IEnumerable CustomCollections() yield return new[] { ID(), customCollectionMarshallingCodeSnippets.Stateful.DefaultModeByValueInParameter }; yield return new[] { ID(), customCollectionMarshallingCodeSnippets.Stateful.DefaultModeReturnValue }; yield return new[] { ID(), customCollectionMarshallingCodeSnippets.Stateful.CustomElementMarshalling }; - yield return new[] { ID(), CodeSnippets.CollectionsOfCollectionsStress }; } [Theory] @@ -451,6 +450,12 @@ public async Task ValidateSnippets(string id, string source) await VerifyCS.VerifySourceGeneratorAsync(source); } + [Fact] + public async Task CollectionsOfCollectionsStress() + { + await VerifyCS.VerifySourceGeneratorAsync(CodeSnippets.CollectionsOfCollectionsStress); + } + public static IEnumerable CodeSnippetsToCompileWithPreprocessorSymbols() { yield return new object[] { ID(), CodeSnippets.PreprocessorIfAroundFullFunctionDefinition("Foo"), new string[] { "Foo" } }; @@ -492,78 +497,67 @@ protected override ParseOptions CreateParseOptions() public static IEnumerable CodeSnippetsToValidateFallbackForwarder() { - //yield return new object[] { ID(), CodeSnippets.UserDefinedEntryPoint, TestTargetFramework.Net, true }; - // Confirm that all unsupported target frameworks can be generated. { string code = CodeSnippets.BasicParametersAndModifiers(CodeSnippets.LibraryImportAttributeDeclaration); - //yield return new object[] { ID(), code, TestTargetFramework.Net6, false }; - yield return new object[] { ID(), code, TestTargetFramework.Core, false }; - yield return new object[] { ID(), code, TestTargetFramework.Standard, false }; + yield return new object[] { ID(), code, TestTargetFramework.Standard2_0, false }; + yield return new object[] { ID(), code, TestTargetFramework.Standard2_1, false }; yield return new object[] { ID(), code, TestTargetFramework.Framework, false }; } // Confirm that all unsupported target frameworks fall back to a forwarder. { string code = CodeSnippets.BasicParametersAndModifiers(CodeSnippets.LibraryImportAttributeDeclaration); - yield return new object[] { ID(), code, TestTargetFramework.Net6, true }; - yield return new object[] { ID(), code, TestTargetFramework.Core, true }; - yield return new object[] { ID(), code, TestTargetFramework.Standard, true }; + yield return new object[] { ID(), code, TestTargetFramework.Standard2_0, true }; + yield return new object[] { ID(), code, TestTargetFramework.Standard2_1, true }; yield return new object[] { ID(), code, TestTargetFramework.Framework, true }; } // Confirm that all unsupported target frameworks fall back to a forwarder. { string code = CodeSnippets.BasicParametersAndModifiersWithStringMarshalling(StringMarshalling.Utf16, CodeSnippets.LibraryImportAttributeDeclaration); - yield return new object[] { ID(), code, TestTargetFramework.Net6, true }; - yield return new object[] { ID(), code, TestTargetFramework.Core, true }; - yield return new object[] { ID(), code, TestTargetFramework.Standard, true }; + yield return new object[] { ID(), code, TestTargetFramework.Standard2_0, true }; + yield return new object[] { ID(), code, TestTargetFramework.Standard2_1, true }; yield return new object[] { ID(), code, TestTargetFramework.Framework, true }; } // Confirm that if support is missing for a type with an ITypeBasedMarshallingInfoProvider (like arrays and SafeHandles), we fall back to a forwarder even if other types are supported. { string code = CodeSnippets.BasicReturnAndParameterWithAlwaysSupportedParameter("void", "System.Runtime.InteropServices.SafeHandle", CodeSnippets.LibraryImportAttributeDeclaration); - yield return new object[] { ID(), code, TestTargetFramework.Net6, true }; - yield return new object[] { ID(), code, TestTargetFramework.Core, true }; - yield return new object[] { ID(), code, TestTargetFramework.Standard, true }; + yield return new object[] { ID(), code, TestTargetFramework.Standard2_0, true }; + yield return new object[] { ID(), code, TestTargetFramework.Standard2_1, true }; yield return new object[] { ID(), code, TestTargetFramework.Framework, true }; } { string code = CodeSnippets.BasicReturnAndParameterWithAlwaysSupportedParameter("System.Runtime.InteropServices.SafeHandle", "int", CodeSnippets.LibraryImportAttributeDeclaration); - yield return new object[] { ID(), code, TestTargetFramework.Net6, true }; - yield return new object[] { ID(), code, TestTargetFramework.Core, true }; - yield return new object[] { ID(), code, TestTargetFramework.Standard, true }; + yield return new object[] { ID(), code, TestTargetFramework.Standard2_0, true }; + yield return new object[] { ID(), code, TestTargetFramework.Standard2_1, true }; yield return new object[] { ID(), code, TestTargetFramework.Framework, true }; } { string code = CodeSnippets.BasicReturnAndParameterWithAlwaysSupportedParameter("void", "int[]", CodeSnippets.LibraryImportAttributeDeclaration); - yield return new object[] { ID(), code, TestTargetFramework.Net6, true }; - yield return new object[] { ID(), code, TestTargetFramework.Core, true }; - yield return new object[] { ID(), code, TestTargetFramework.Standard, true }; + yield return new object[] { ID(), code, TestTargetFramework.Standard2_0, true }; + yield return new object[] { ID(), code, TestTargetFramework.Standard2_1, true }; yield return new object[] { ID(), code, TestTargetFramework.Framework, true }; } { string code = CodeSnippets.BasicReturnAndParameterWithAlwaysSupportedParameter("int", "int[]", CodeSnippets.LibraryImportAttributeDeclaration); - yield return new object[] { ID(), code, TestTargetFramework.Net6, true }; - yield return new object[] { ID(), code, TestTargetFramework.Core, true }; - yield return new object[] { ID(), code, TestTargetFramework.Standard, true }; + yield return new object[] { ID(), code, TestTargetFramework.Standard2_0, true }; + yield return new object[] { ID(), code, TestTargetFramework.Standard2_1, true }; yield return new object[] { ID(), code, TestTargetFramework.Framework, true }; } // Confirm that if support is missing for a type without an ITypeBasedMarshallingInfoProvider (like StringBuilder), we fall back to a forwarder even if other types are supported. { string code = CodeSnippets.BasicReturnAndParameterWithAlwaysSupportedParameter("void", "System.Text.StringBuilder", CodeSnippets.LibraryImportAttributeDeclaration); - yield return new object[] { ID(), code, TestTargetFramework.Net6, true }; - yield return new object[] { ID(), code, TestTargetFramework.Core, true }; - yield return new object[] { ID(), code, TestTargetFramework.Standard, true }; + yield return new object[] { ID(), code, TestTargetFramework.Standard2_0, true }; + yield return new object[] { ID(), code, TestTargetFramework.Standard2_1, true }; yield return new object[] { ID(), code, TestTargetFramework.Framework, true }; } { string code = CodeSnippets.BasicReturnAndParameterWithAlwaysSupportedParameter("int", "System.Text.StringBuilder", CodeSnippets.LibraryImportAttributeDeclaration); - yield return new object[] { ID(), code, TestTargetFramework.Net6, true }; - yield return new object[] { ID(), code, TestTargetFramework.Core, true }; - yield return new object[] { ID(), code, TestTargetFramework.Standard, true }; + yield return new object[] { ID(), code, TestTargetFramework.Standard2_0, true }; + yield return new object[] { ID(), code, TestTargetFramework.Standard2_1, true }; yield return new object[] { ID(), code, TestTargetFramework.Framework, true }; } } @@ -583,7 +577,7 @@ public async Task ValidateSnippetsFallbackForwarder(string id, string source, Te await test.RunAsync(); } - class FallbackForwarderTest : VerifyCS.Test + class FallbackForwarderTest : Microsoft.Interop.UnitTests.Verifiers.CSharpSourceGeneratorVerifier.Test { private readonly bool _expectFallbackForwarder; @@ -752,7 +746,7 @@ public async Task ValidateNoGeneratedOutputForNoImport() public class Basic { } """; - var test = new NoChangeTest(TestTargetFramework.Net) + var test = new NoChangeTest() { TestCode = source, TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck @@ -762,7 +756,7 @@ public class Basic { } } [OuterLoop("Uses the network for downlevel ref packs")] - [InlineData(TestTargetFramework.Standard)] + [InlineData(TestTargetFramework.Standard2_0)] [InlineData(TestTargetFramework.Framework)] [Theory] public async Task ValidateNoGeneratedOutputForNoImportDownlevel(TestTargetFramework framework) @@ -772,7 +766,7 @@ public async Task ValidateNoGeneratedOutputForNoImportDownlevel(TestTargetFramew public class Basic { } """; - var test = new NoChangeTest(framework) + var test = new NoChangeTest(framework) { TestCode = source, TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck @@ -781,8 +775,14 @@ public class Basic { } await test.RunAsync(); } - class NoChangeTest : VerifyCS.Test + class NoChangeTest : Microsoft.Interop.UnitTests.Verifiers.CSharpSourceGeneratorVerifier.Test + where TSourceGenerator : new() { + public NoChangeTest() + : base(referenceAncillaryInterop: false) + { + } + public NoChangeTest(TestTargetFramework framework) : base(framework) { diff --git a/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/Diagnostics.cs b/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/Diagnostics.cs index 646021b0b1a..e064a4b951d 100644 --- a/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/Diagnostics.cs +++ b/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/Diagnostics.cs @@ -250,7 +250,7 @@ partial class Test public static partial void {|#0:Method1|}(string s); [LibraryImport("DoesNotExist", StringMarshalling = StringMarshalling.Custom, StringMarshallingCustomType = typeof(Native))] - public static partial void {|#2:Method2|}(string {|#1:s|}); + public static partial void {|#1:Method2|}(string s); struct Native { @@ -259,23 +259,17 @@ public Native(string s) { } } } """ + CodeSnippets.LibraryImportAttributeDeclaration; - DiagnosticResult[] expectedDiags = new DiagnosticResult[] - { + DiagnosticResult[] expectedDiags = + [ VerifyCS.Diagnostic(GeneratorDiagnostics.CannotForwardToDllImport) .WithLocation(0) .WithArguments($"{nameof(TypeNames.LibraryImportAttribute)}{Type.Delimiter}{nameof(StringMarshalling)}={nameof(StringMarshalling)}{Type.Delimiter}{nameof(StringMarshalling.Utf8)}"), - VerifyCS.Diagnostic(GeneratorDiagnostics.ParameterTypeNotSupportedWithDetails) - .WithLocation(1) - .WithArguments("Marshalling string or char without explicit marshalling information is not supported. Specify 'LibraryImportAttribute.StringMarshalling', 'LibraryImportAttribute.StringMarshallingCustomType', 'MarshalUsingAttribute' or 'MarshalAsAttribute'.", "s"), - VerifyCS.Diagnostic(GeneratorDiagnostics.CannotForwardToDllImport) - .WithLocation(2) - .WithArguments($"{nameof(TypeNames.LibraryImportAttribute)}{Type.Delimiter}{nameof(StringMarshalling)}={nameof(StringMarshalling)}{Type.Delimiter}{nameof(StringMarshalling.Custom)}"), VerifyCS.Diagnostic(GeneratorDiagnostics.CannotForwardToDllImport) - .WithLocation(2) - .WithArguments($"{nameof(TypeNames.LibraryImportAttribute)}{Type.Delimiter}{nameof(LibraryImportAttribute.StringMarshallingCustomType)}") - }; + .WithLocation(1) + .WithArguments($"{nameof(TypeNames.LibraryImportAttribute)}{Type.Delimiter}{nameof(StringMarshalling)}={nameof(StringMarshalling)}{Type.Delimiter}{nameof(StringMarshalling.Custom)}") + ]; - var test = new VerifyCS.Test(TestTargetFramework.Standard) + var test = new Microsoft.Interop.UnitTests.Verifiers.CSharpSourceGeneratorVerifier.Test(TestTargetFramework.Standard2_0) { TestCode = source, TestBehaviors = TestBehaviors.SkipGeneratedSourcesCheck diff --git a/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/IncrementalGenerationTests.cs b/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/IncrementalGenerationTests.cs index 78ed48e8c0e..dc34ff3493a 100644 --- a/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/IncrementalGenerationTests.cs +++ b/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/IncrementalGenerationTests.cs @@ -7,7 +7,6 @@ using System.Linq; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; -using System.Threading.Tasks; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.Testing; @@ -23,14 +22,14 @@ public class IncrementalGenerationTests private static readonly GeneratorDriverOptions EnableIncrementalTrackingDriverOptions = new GeneratorDriverOptions(IncrementalGeneratorOutputKind.None, trackIncrementalGeneratorSteps: true); [Fact] - public async Task AddingNewUnrelatedType_DoesNotRegenerateSource() + public void AddingNewUnrelatedType_DoesNotRegenerateSource() { string source = RemoveTestMarkup(CodeSnippets.BasicParametersAndModifiers()); - Compilation comp1 = await TestUtils.CreateCompilation(source); + Compilation comp1 = TestUtils.CreateCompilation(source); Microsoft.Interop.LibraryImportGenerator generator = new(); - GeneratorDriver driver = TestUtils.CreateDriver(comp1, null, new IIncrementalGenerator[] { generator }, EnableIncrementalTrackingDriverOptions); + GeneratorDriver driver = TestUtils.CreateDriver(comp1, null, [generator], EnableIncrementalTrackingDriverOptions); driver = driver.RunGenerators(comp1); @@ -47,7 +46,7 @@ public async Task AddingNewUnrelatedType_DoesNotRegenerateSource() } [Fact] - public async Task AppendingUnrelatedSource_DoesNotRegenerateSource() + public void AppendingUnrelatedSource_DoesNotRegenerateSource() { string source = $$""" namespace NS @@ -58,10 +57,10 @@ namespace NS SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Preview)); - Compilation comp1 = await TestUtils.CreateCompilation(new[] { syntaxTree }); + Compilation comp1 = TestUtils.CreateCompilation(new[] { syntaxTree }); Microsoft.Interop.LibraryImportGenerator generator = new(); - GeneratorDriver driver = TestUtils.CreateDriver(comp1, null, new[] { generator }, EnableIncrementalTrackingDriverOptions); + GeneratorDriver driver = TestUtils.CreateDriver(comp1, null, [generator], EnableIncrementalTrackingDriverOptions); driver = driver.RunGenerators(comp1); @@ -81,14 +80,14 @@ namespace NS } [Fact] - public async Task AddingFileWithNewLibraryImport_DoesNotRegenerateOriginalMethod() + public void AddingFileWithNewLibraryImport_DoesNotRegenerateOriginalMethod() { string source = RemoveTestMarkup(CodeSnippets.BasicParametersAndModifiers()); - Compilation comp1 = await TestUtils.CreateCompilation(source); + Compilation comp1 = TestUtils.CreateCompilation(source); Microsoft.Interop.LibraryImportGenerator generator = new(); - GeneratorDriver driver = TestUtils.CreateDriver(comp1, null, new[] { generator }, EnableIncrementalTrackingDriverOptions); + GeneratorDriver driver = TestUtils.CreateDriver(comp1, null, [generator], EnableIncrementalTrackingDriverOptions); driver = driver.RunGenerators(comp1); @@ -111,12 +110,12 @@ public async Task AddingFileWithNewLibraryImport_DoesNotRegenerateOriginalMethod } [Fact] - public async Task ReplacingFileWithNewLibraryImport_DoesNotRegenerateStubsInOtherFiles() + public void ReplacingFileWithNewLibraryImport_DoesNotRegenerateStubsInOtherFiles() { - Compilation comp1 = await TestUtils.CreateCompilation(new string[] { RemoveTestMarkup(CodeSnippets.BasicParametersAndModifiers()), RemoveTestMarkup(CodeSnippets.MarshalAsParametersAndModifiers(UnmanagedType.I1)) }); + Compilation comp1 = TestUtils.CreateCompilation([ RemoveTestMarkup(CodeSnippets.BasicParametersAndModifiers()), RemoveTestMarkup(CodeSnippets.MarshalAsParametersAndModifiers(UnmanagedType.I1)) ]); Microsoft.Interop.LibraryImportGenerator generator = new(); - GeneratorDriver driver = TestUtils.CreateDriver(comp1, null, new[] { generator }, EnableIncrementalTrackingDriverOptions); + GeneratorDriver driver = TestUtils.CreateDriver(comp1, null, [generator], EnableIncrementalTrackingDriverOptions); driver = driver.RunGenerators(comp1); @@ -138,7 +137,7 @@ public async Task ReplacingFileWithNewLibraryImport_DoesNotRegenerateStubsInOthe } [Fact] - public async Task ChangingMarshallingStrategy_RegeneratesStub() + public void ChangingMarshallingStrategy_RegeneratesStub() { string stubSource = RemoveTestMarkup(CodeSnippets.BasicParametersAndModifiers("CustomType", CodeSnippets.DisableRuntimeMarshalling)); @@ -147,13 +146,13 @@ public async Task ChangingMarshallingStrategy_RegeneratesStub() string customTypeImpl2 = "class CustomType : Microsoft.Win32.SafeHandles.SafeHandleZeroOrMinusOneIsInvalid { public CustomType():base(true){} protected override bool ReleaseHandle(){return true;} }"; - Compilation comp1 = await TestUtils.CreateCompilation(stubSource); + Compilation comp1 = TestUtils.CreateCompilation(stubSource); SyntaxTree customTypeImpl1Tree = CSharpSyntaxTree.ParseText(customTypeImpl1, new CSharpParseOptions(LanguageVersion.Preview)); comp1 = comp1.AddSyntaxTrees(customTypeImpl1Tree); Microsoft.Interop.LibraryImportGenerator generator = new(); - GeneratorDriver driver = TestUtils.CreateDriver(comp1, null, new[] { generator }, EnableIncrementalTrackingDriverOptions); + GeneratorDriver driver = TestUtils.CreateDriver(comp1, null, [generator], EnableIncrementalTrackingDriverOptions); driver = driver.RunGenerators(comp1); @@ -177,16 +176,16 @@ public async Task ChangingMarshallingStrategy_RegeneratesStub() } [Fact] - public async Task ChangingMarshallingAttributes_SameStrategy_DoesNotRegenerate() + public void ChangingMarshallingAttributes_SameStrategy_DoesNotRegenerate() { string source = RemoveTestMarkup(CodeSnippets.BasicParametersAndModifiers()); SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Preview)); - Compilation comp1 = await TestUtils.CreateCompilation(new[] { syntaxTree }); + Compilation comp1 = TestUtils.CreateCompilation([syntaxTree]); Microsoft.Interop.LibraryImportGenerator generator = new(); - GeneratorDriver driver = TestUtils.CreateDriver(comp1, null, new[] { generator }, EnableIncrementalTrackingDriverOptions); + GeneratorDriver driver = TestUtils.CreateDriver(comp1, null, [generator], EnableIncrementalTrackingDriverOptions); driver = driver.RunGenerators(comp1); @@ -227,11 +226,11 @@ public static IEnumerable CompilationObjectLivenessSources() // keeping the Compilation alive. [MemberData(nameof(CompilationObjectLivenessSources))] [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsPreciseGcSupported))] - public async Task GeneratorRun_WithNewCompilation_DoesNotKeepOldCompilationAlive(string source) + public void GeneratorRun_WithNewCompilation_DoesNotKeepOldCompilationAlive(string source) { SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Preview)); - Compilation comp1 = await TestUtils.CreateCompilation(new[] { syntaxTree }); + Compilation comp1 = TestUtils.CreateCompilation([syntaxTree]); var (reference, driver) = RunTwoGeneratorOnTwoIterativeCompilationsAndReturnFirst(comp1); @@ -246,7 +245,7 @@ public async Task GeneratorRun_WithNewCompilation_DoesNotKeepOldCompilationAlive Compilation comp2 = startingCompilation.AddSyntaxTrees(CSharpSyntaxTree.ParseText("struct NewType {}", new CSharpParseOptions(LanguageVersion.Preview))); Microsoft.Interop.LibraryImportGenerator generator = new(); - GeneratorDriver driver = TestUtils.CreateDriver(comp2, null, new[] { generator }, EnableIncrementalTrackingDriverOptions); + GeneratorDriver driver = TestUtils.CreateDriver(comp2, null, [generator], EnableIncrementalTrackingDriverOptions); driver = driver.RunGenerators(comp2); diff --git a/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/LibraryImportGenerator.Unit.Tests.csproj b/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/LibraryImportGenerator.Unit.Tests.csproj index 471d6602648..f7ea6cfd050 100644 --- a/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/LibraryImportGenerator.Unit.Tests.csproj +++ b/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/LibraryImportGenerator.Unit.Tests.csproj @@ -14,28 +14,16 @@ - - - - - - - - - - - + + + + + + + + + + @@ -51,6 +39,7 @@ + diff --git a/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/LibraryImportGeneratorOptionsProvider.cs b/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/LibraryImportGeneratorOptionsProvider.cs deleted file mode 100644 index 3e7768ad4ab..00000000000 --- a/src/libraries/System.Runtime.InteropServices/tests/LibraryImportGenerator.UnitTests/LibraryImportGeneratorOptionsProvider.cs +++ /dev/null @@ -1,53 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -using System.Diagnostics.CodeAnalysis; -using Microsoft.CodeAnalysis; -using Microsoft.CodeAnalysis.Diagnostics; -using Microsoft.Interop; -using Microsoft.Interop.UnitTests; -using SourceGenerators.Tests; - -namespace LibraryImportGenerator.UnitTests -{ - /// - /// An implementation of that provides configuration in code - /// of the options supported by the LibraryImportGenerator source generator. Used for testing various configurations. - /// - internal sealed class LibraryImportGeneratorOptionsProvider : GlobalOptionsOnlyProvider - { - public LibraryImportGeneratorOptionsProvider(TestTargetFramework targetFramework, bool useMarshalType, bool generateForwarders) - :base(new GlobalGeneratorOptions(targetFramework, useMarshalType, generateForwarders)) - { - } - - private sealed class GlobalGeneratorOptions : TargetFrameworkConfigOptions - { - private readonly bool _useMarshalType = false; - private readonly bool _generateForwarders = false; - public GlobalGeneratorOptions(TestTargetFramework targetFramework, bool useMarshalType, bool generateForwarders) - : base(targetFramework) - { - _useMarshalType = useMarshalType; - _generateForwarders = generateForwarders; - } - - public override bool TryGetValue(string key, [NotNullWhen(true)] out string? value) - { - switch (key) - { - case OptionsHelper.UseMarshalTypeOption: - value = _useMarshalType.ToString(); - return true; - - case OptionsHelper.GenerateForwardersOption: - value = _generateForwarders.ToString(); - return true; - - default: - return base.TryGetValue(key, out value); - } - } - } - } -} diff --git a/src/libraries/System.Runtime.Intrinsics/System.Runtime.Intrinsics.sln b/src/libraries/System.Runtime.Intrinsics/System.Runtime.Intrinsics.sln index bf8bf7e0a73..a69695cc6fb 100644 --- a/src/libraries/System.Runtime.Intrinsics/System.Runtime.Intrinsics.sln +++ b/src/libraries/System.Runtime.Intrinsics/System.Runtime.Intrinsics.sln @@ -11,6 +11,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib.Gene EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\System.Private.CoreLib\ref\System.Private.CoreLib.csproj", "{9D4B472B-6C86-4CEC-998D-800937DBD399}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{46D568E2-17FA-46F6-A645-954DB9D56112}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{FE8C7C64-1759-4175-BA6E-03F8D6B7C6EF}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{9A0BF7EC-AD07-44C8-9B70-9DACB2C894C7}" @@ -203,6 +205,27 @@ Global {9D4B472B-6C86-4CEC-998D-800937DBD399}.Checked|arm64.ActiveCfg = Debug|Any CPU {9D4B472B-6C86-4CEC-998D-800937DBD399}.Checked|x64.ActiveCfg = Debug|Any CPU {9D4B472B-6C86-4CEC-998D-800937DBD399}.Checked|x86.ActiveCfg = Debug|Any CPU + {46D568E2-17FA-46F6-A645-954DB9D56112}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {46D568E2-17FA-46F6-A645-954DB9D56112}.Debug|Any CPU.Build.0 = Debug|Any CPU + {46D568E2-17FA-46F6-A645-954DB9D56112}.Debug|arm.ActiveCfg = Debug|Any CPU + {46D568E2-17FA-46F6-A645-954DB9D56112}.Debug|arm64.ActiveCfg = Debug|Any CPU + {46D568E2-17FA-46F6-A645-954DB9D56112}.Debug|x64.ActiveCfg = Debug|Any CPU + {46D568E2-17FA-46F6-A645-954DB9D56112}.Debug|x64.Build.0 = Debug|Any CPU + {46D568E2-17FA-46F6-A645-954DB9D56112}.Debug|x86.ActiveCfg = Debug|Any CPU + {46D568E2-17FA-46F6-A645-954DB9D56112}.Debug|x86.Build.0 = Debug|Any CPU + {46D568E2-17FA-46F6-A645-954DB9D56112}.Release|Any CPU.ActiveCfg = Release|Any CPU + {46D568E2-17FA-46F6-A645-954DB9D56112}.Release|Any CPU.Build.0 = Release|Any CPU + {46D568E2-17FA-46F6-A645-954DB9D56112}.Release|arm.ActiveCfg = Release|Any CPU + {46D568E2-17FA-46F6-A645-954DB9D56112}.Release|arm64.ActiveCfg = Release|Any CPU + {46D568E2-17FA-46F6-A645-954DB9D56112}.Release|x64.ActiveCfg = Release|Any CPU + {46D568E2-17FA-46F6-A645-954DB9D56112}.Release|x64.Build.0 = Release|Any CPU + {46D568E2-17FA-46F6-A645-954DB9D56112}.Release|x86.ActiveCfg = Release|Any CPU + {46D568E2-17FA-46F6-A645-954DB9D56112}.Release|x86.Build.0 = Release|Any CPU + {46D568E2-17FA-46F6-A645-954DB9D56112}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {46D568E2-17FA-46F6-A645-954DB9D56112}.Checked|arm.ActiveCfg = Debug|Any CPU + {46D568E2-17FA-46F6-A645-954DB9D56112}.Checked|arm64.ActiveCfg = Debug|Any CPU + {46D568E2-17FA-46F6-A645-954DB9D56112}.Checked|x64.ActiveCfg = Debug|Any CPU + {46D568E2-17FA-46F6-A645-954DB9D56112}.Checked|x86.ActiveCfg = Debug|Any CPU {FE8C7C64-1759-4175-BA6E-03F8D6B7C6EF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {FE8C7C64-1759-4175-BA6E-03F8D6B7C6EF}.Debug|Any CPU.Build.0 = Debug|Any CPU {FE8C7C64-1759-4175-BA6E-03F8D6B7C6EF}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -449,6 +472,7 @@ Global {28B808CE-B1F8-4B05-9ADA-8884525BD87F} = {E7A9B89D-A9F5-40FD-93CA-CAF4522A80E0} {2A6ED99F-FFEC-4FA7-BEF7-E5339C9D99BB} = {E7A9B89D-A9F5-40FD-93CA-CAF4522A80E0} {A4058388-97C1-492A-86A4-5240C4166BFF} = {A499E9EC-3C82-4B0A-AC49-111C706B1835} + {46D568E2-17FA-46F6-A645-954DB9D56112} = {A499E9EC-3C82-4B0A-AC49-111C706B1835} {FE8C7C64-1759-4175-BA6E-03F8D6B7C6EF} = {A499E9EC-3C82-4B0A-AC49-111C706B1835} {9A0BF7EC-AD07-44C8-9B70-9DACB2C894C7} = {A499E9EC-3C82-4B0A-AC49-111C706B1835} {022E0D70-D39E-4715-8484-8D2AC264304B} = {0ECF6939-6099-448F-A3E5-B8069E092C2F} diff --git a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs index 90803aec546..352820d8500 100644 --- a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs +++ b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs @@ -4648,14 +4648,14 @@ internal Arm64() { } public static System.Numerics.Vector CreateBreakBeforePropagateMask(System.Numerics.Vector mask, System.Numerics.Vector left, System.Numerics.Vector right) { throw null; } public static System.Numerics.Vector CreateBreakBeforePropagateMask(System.Numerics.Vector mask, System.Numerics.Vector left, System.Numerics.Vector right) { throw null; } public static System.Numerics.Vector CreateBreakBeforePropagateMask(System.Numerics.Vector mask, System.Numerics.Vector left, System.Numerics.Vector right) { throw null; } - public static unsafe System.Numerics.Vector CreateBreakPropagateMask(System.Numerics.Vector totalMask, System.Numerics.Vector fromMask) { throw null; } - public static unsafe System.Numerics.Vector CreateBreakPropagateMask(System.Numerics.Vector totalMask, System.Numerics.Vector fromMask) { throw null; } - public static unsafe System.Numerics.Vector CreateBreakPropagateMask(System.Numerics.Vector totalMask, System.Numerics.Vector fromMask) { throw null; } - public static unsafe System.Numerics.Vector CreateBreakPropagateMask(System.Numerics.Vector totalMask, System.Numerics.Vector fromMask) { throw null; } - public static unsafe System.Numerics.Vector CreateBreakPropagateMask(System.Numerics.Vector totalMask, System.Numerics.Vector fromMask) { throw null; } - public static unsafe System.Numerics.Vector CreateBreakPropagateMask(System.Numerics.Vector totalMask, System.Numerics.Vector fromMask) { throw null; } - public static unsafe System.Numerics.Vector CreateBreakPropagateMask(System.Numerics.Vector totalMask, System.Numerics.Vector fromMask) { throw null; } - public static unsafe System.Numerics.Vector CreateBreakPropagateMask(System.Numerics.Vector totalMask, System.Numerics.Vector fromMask) { throw null; } + public static System.Numerics.Vector CreateBreakPropagateMask(System.Numerics.Vector totalMask, System.Numerics.Vector fromMask) { throw null; } + public static System.Numerics.Vector CreateBreakPropagateMask(System.Numerics.Vector totalMask, System.Numerics.Vector fromMask) { throw null; } + public static System.Numerics.Vector CreateBreakPropagateMask(System.Numerics.Vector totalMask, System.Numerics.Vector fromMask) { throw null; } + public static System.Numerics.Vector CreateBreakPropagateMask(System.Numerics.Vector totalMask, System.Numerics.Vector fromMask) { throw null; } + public static System.Numerics.Vector CreateBreakPropagateMask(System.Numerics.Vector totalMask, System.Numerics.Vector fromMask) { throw null; } + public static System.Numerics.Vector CreateBreakPropagateMask(System.Numerics.Vector totalMask, System.Numerics.Vector fromMask) { throw null; } + public static System.Numerics.Vector CreateBreakPropagateMask(System.Numerics.Vector totalMask, System.Numerics.Vector fromMask) { throw null; } + public static System.Numerics.Vector CreateBreakPropagateMask(System.Numerics.Vector totalMask, System.Numerics.Vector fromMask) { throw null; } public static System.Numerics.Vector CreateFalseMaskByte() { throw null; } public static System.Numerics.Vector CreateFalseMaskDouble() { throw null; } public static System.Numerics.Vector CreateFalseMaskInt16() { throw null; } @@ -4666,18 +4666,18 @@ internal Arm64() { } public static System.Numerics.Vector CreateFalseMaskUInt16() { throw null; } public static System.Numerics.Vector CreateFalseMaskUInt32() { throw null; } public static System.Numerics.Vector CreateFalseMaskUInt64() { throw null; } - public static unsafe System.Numerics.Vector CreateMaskForFirstActiveElement(System.Numerics.Vector mask, System.Numerics.Vector srcMask) { throw null; } - public static unsafe System.Numerics.Vector CreateMaskForFirstActiveElement(System.Numerics.Vector mask, System.Numerics.Vector srcMask) { throw null; } - public static unsafe System.Numerics.Vector CreateMaskForFirstActiveElement(System.Numerics.Vector mask, System.Numerics.Vector srcMask) { throw null; } - public static unsafe System.Numerics.Vector CreateMaskForFirstActiveElement(System.Numerics.Vector mask, System.Numerics.Vector srcMask) { throw null; } - public static unsafe System.Numerics.Vector CreateMaskForFirstActiveElement(System.Numerics.Vector mask, System.Numerics.Vector srcMask) { throw null; } - public static unsafe System.Numerics.Vector CreateMaskForFirstActiveElement(System.Numerics.Vector mask, System.Numerics.Vector srcMask) { throw null; } - public static unsafe System.Numerics.Vector CreateMaskForFirstActiveElement(System.Numerics.Vector mask, System.Numerics.Vector srcMask) { throw null; } - public static unsafe System.Numerics.Vector CreateMaskForFirstActiveElement(System.Numerics.Vector mask, System.Numerics.Vector srcMask) { throw null; } - public static unsafe System.Numerics.Vector CreateMaskForNextActiveElement(System.Numerics.Vector mask, System.Numerics.Vector srcMask) { throw null; } - public static unsafe System.Numerics.Vector CreateMaskForNextActiveElement(System.Numerics.Vector mask, System.Numerics.Vector srcMask) { throw null; } - public static unsafe System.Numerics.Vector CreateMaskForNextActiveElement(System.Numerics.Vector mask, System.Numerics.Vector srcMask) { throw null; } - public static unsafe System.Numerics.Vector CreateMaskForNextActiveElement(System.Numerics.Vector mask, System.Numerics.Vector srcMask) { throw null; } + public static System.Numerics.Vector CreateMaskForFirstActiveElement(System.Numerics.Vector mask, System.Numerics.Vector srcMask) { throw null; } + public static System.Numerics.Vector CreateMaskForFirstActiveElement(System.Numerics.Vector mask, System.Numerics.Vector srcMask) { throw null; } + public static System.Numerics.Vector CreateMaskForFirstActiveElement(System.Numerics.Vector mask, System.Numerics.Vector srcMask) { throw null; } + public static System.Numerics.Vector CreateMaskForFirstActiveElement(System.Numerics.Vector mask, System.Numerics.Vector srcMask) { throw null; } + public static System.Numerics.Vector CreateMaskForFirstActiveElement(System.Numerics.Vector mask, System.Numerics.Vector srcMask) { throw null; } + public static System.Numerics.Vector CreateMaskForFirstActiveElement(System.Numerics.Vector mask, System.Numerics.Vector srcMask) { throw null; } + public static System.Numerics.Vector CreateMaskForFirstActiveElement(System.Numerics.Vector mask, System.Numerics.Vector srcMask) { throw null; } + public static System.Numerics.Vector CreateMaskForFirstActiveElement(System.Numerics.Vector mask, System.Numerics.Vector srcMask) { throw null; } + public static System.Numerics.Vector CreateMaskForNextActiveElement(System.Numerics.Vector mask, System.Numerics.Vector srcMask) { throw null; } + public static System.Numerics.Vector CreateMaskForNextActiveElement(System.Numerics.Vector mask, System.Numerics.Vector srcMask) { throw null; } + public static System.Numerics.Vector CreateMaskForNextActiveElement(System.Numerics.Vector mask, System.Numerics.Vector srcMask) { throw null; } + public static System.Numerics.Vector CreateMaskForNextActiveElement(System.Numerics.Vector mask, System.Numerics.Vector srcMask) { throw null; } public static System.Numerics.Vector CreateTrueMaskByte([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw null; } public static System.Numerics.Vector CreateTrueMaskDouble([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw null; } public static System.Numerics.Vector CreateTrueMaskInt16([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw null; } @@ -4740,16 +4740,16 @@ internal Arm64() { } public static System.Numerics.Vector DuplicateSelectedScalarToVector(System.Numerics.Vector data, [ConstantExpected(Min = 0, Max = (byte)(31))] byte index) { throw null; } public static System.Numerics.Vector DuplicateSelectedScalarToVector(System.Numerics.Vector data, [ConstantExpected(Min = 0, Max = (byte)(15))] byte index) { throw null; } public static System.Numerics.Vector DuplicateSelectedScalarToVector(System.Numerics.Vector data, [ConstantExpected(Min = 0, Max = (byte)(7))] byte index) { throw null; } - public static unsafe System.Numerics.Vector ExtractVector(System.Numerics.Vector upper, System.Numerics.Vector lower, [ConstantExpected] byte index) { throw null; } - public static unsafe System.Numerics.Vector ExtractVector(System.Numerics.Vector upper, System.Numerics.Vector lower, [ConstantExpected] byte index) { throw null; } - public static unsafe System.Numerics.Vector ExtractVector(System.Numerics.Vector upper, System.Numerics.Vector lower, [ConstantExpected] byte index) { throw null; } - public static unsafe System.Numerics.Vector ExtractVector(System.Numerics.Vector upper, System.Numerics.Vector lower, [ConstantExpected] byte index) { throw null; } - public static unsafe System.Numerics.Vector ExtractVector(System.Numerics.Vector upper, System.Numerics.Vector lower, [ConstantExpected] byte index) { throw null; } - public static unsafe System.Numerics.Vector ExtractVector(System.Numerics.Vector upper, System.Numerics.Vector lower, [ConstantExpected] byte index) { throw null; } - public static unsafe System.Numerics.Vector ExtractVector(System.Numerics.Vector upper, System.Numerics.Vector lower, [ConstantExpected] byte index) { throw null; } - public static unsafe System.Numerics.Vector ExtractVector(System.Numerics.Vector upper, System.Numerics.Vector lower, [ConstantExpected] byte index) { throw null; } - public static unsafe System.Numerics.Vector ExtractVector(System.Numerics.Vector upper, System.Numerics.Vector lower, [ConstantExpected] byte index) { throw null; } - public static unsafe System.Numerics.Vector ExtractVector(System.Numerics.Vector upper, System.Numerics.Vector lower, [ConstantExpected] byte index) { throw null; } + public static System.Numerics.Vector ExtractVector(System.Numerics.Vector upper, System.Numerics.Vector lower, [ConstantExpected] byte index) { throw null; } + public static System.Numerics.Vector ExtractVector(System.Numerics.Vector upper, System.Numerics.Vector lower, [ConstantExpected] byte index) { throw null; } + public static System.Numerics.Vector ExtractVector(System.Numerics.Vector upper, System.Numerics.Vector lower, [ConstantExpected] byte index) { throw null; } + public static System.Numerics.Vector ExtractVector(System.Numerics.Vector upper, System.Numerics.Vector lower, [ConstantExpected] byte index) { throw null; } + public static System.Numerics.Vector ExtractVector(System.Numerics.Vector upper, System.Numerics.Vector lower, [ConstantExpected] byte index) { throw null; } + public static System.Numerics.Vector ExtractVector(System.Numerics.Vector upper, System.Numerics.Vector lower, [ConstantExpected] byte index) { throw null; } + public static System.Numerics.Vector ExtractVector(System.Numerics.Vector upper, System.Numerics.Vector lower, [ConstantExpected] byte index) { throw null; } + public static System.Numerics.Vector ExtractVector(System.Numerics.Vector upper, System.Numerics.Vector lower, [ConstantExpected] byte index) { throw null; } + public static System.Numerics.Vector ExtractVector(System.Numerics.Vector upper, System.Numerics.Vector lower, [ConstantExpected] byte index) { throw null; } + public static System.Numerics.Vector ExtractVector(System.Numerics.Vector upper, System.Numerics.Vector lower, [ConstantExpected] byte index) { throw null; } public static System.Numerics.Vector FloatingPointExponentialAccelerator(System.Numerics.Vector value) { throw null; } public static System.Numerics.Vector FloatingPointExponentialAccelerator(System.Numerics.Vector value) { throw null; } public static System.Numerics.Vector FusedMultiplyAdd(System.Numerics.Vector addend, System.Numerics.Vector left, System.Numerics.Vector right) { throw null; } @@ -4766,49 +4766,49 @@ internal Arm64() { } public static System.Numerics.Vector FusedMultiplySubtractNegated(System.Numerics.Vector minuend, System.Numerics.Vector left, System.Numerics.Vector right) { throw null; } public static unsafe void GatherPrefetch16Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch16Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } - public static void GatherPrefetch16Bit(System.Numerics.Vector mask, System.Numerics.Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } + // public static void GatherPrefetch16Bit(System.Numerics.Vector mask, System.Numerics.Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch16Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static void GatherPrefetch16Bit(System.Numerics.Vector mask, System.Numerics.Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch16Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch16Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch16Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } - public static void GatherPrefetch16Bit(System.Numerics.Vector mask, System.Numerics.Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } + // public static void GatherPrefetch16Bit(System.Numerics.Vector mask, System.Numerics.Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch16Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static void GatherPrefetch16Bit(System.Numerics.Vector mask, System.Numerics.Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch16Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch32Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch32Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } - public static void GatherPrefetch32Bit(System.Numerics.Vector mask, System.Numerics.Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } + // public static void GatherPrefetch32Bit(System.Numerics.Vector mask, System.Numerics.Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch32Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static void GatherPrefetch32Bit(System.Numerics.Vector mask, System.Numerics.Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch32Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch32Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch32Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } - public static void GatherPrefetch32Bit(System.Numerics.Vector mask, System.Numerics.Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } + // public static void GatherPrefetch32Bit(System.Numerics.Vector mask, System.Numerics.Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch32Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static void GatherPrefetch32Bit(System.Numerics.Vector mask, System.Numerics.Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch32Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch64Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch64Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } - public static void GatherPrefetch64Bit(System.Numerics.Vector mask, System.Numerics.Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } + // public static void GatherPrefetch64Bit(System.Numerics.Vector mask, System.Numerics.Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch64Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static void GatherPrefetch64Bit(System.Numerics.Vector mask, System.Numerics.Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch64Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch64Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch64Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } - public static void GatherPrefetch64Bit(System.Numerics.Vector mask, System.Numerics.Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } + // public static void GatherPrefetch64Bit(System.Numerics.Vector mask, System.Numerics.Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch64Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static void GatherPrefetch64Bit(System.Numerics.Vector mask, System.Numerics.Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch64Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector indices, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch8Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector offsets, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch8Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector offsets, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } - public static void GatherPrefetch8Bit(System.Numerics.Vector mask, System.Numerics.Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } + // public static void GatherPrefetch8Bit(System.Numerics.Vector mask, System.Numerics.Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch8Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector offsets, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static void GatherPrefetch8Bit(System.Numerics.Vector mask, System.Numerics.Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch8Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector offsets, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch8Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector offsets, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch8Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector offsets, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } - public static void GatherPrefetch8Bit(System.Numerics.Vector mask, System.Numerics.Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } + // public static void GatherPrefetch8Bit(System.Numerics.Vector mask, System.Numerics.Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch8Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector offsets, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static void GatherPrefetch8Bit(System.Numerics.Vector mask, System.Numerics.Vector addresses, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } public static unsafe void GatherPrefetch8Bit(System.Numerics.Vector mask, void* address, System.Numerics.Vector offsets, [ConstantExpected] SvePrefetchType prefetchType) { throw null; } @@ -4842,22 +4842,34 @@ internal Arm64() { } public static unsafe System.Numerics.Vector GatherVectorByteZeroExtend(System.Numerics.Vector mask, byte* address, System.Numerics.Vector indices) { throw null; } public static System.Numerics.Vector GatherVectorByteZeroExtend(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } public static unsafe System.Numerics.Vector GatherVectorByteZeroExtend(System.Numerics.Vector mask, byte* address, System.Numerics.Vector indices) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorByteZeroExtendFirstFaulting(System.Numerics.Vector mask, byte* address, System.Numerics.Vector offsets) { throw null; } + // public static System.Numerics.Vector GatherVectorByteZeroExtendFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorByteZeroExtendFirstFaulting(System.Numerics.Vector mask, byte* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorByteZeroExtendFirstFaulting(System.Numerics.Vector mask, byte* address, System.Numerics.Vector offsets) { throw null; } + public static System.Numerics.Vector GatherVectorByteZeroExtendFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorByteZeroExtendFirstFaulting(System.Numerics.Vector mask, byte* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorByteZeroExtendFirstFaulting(System.Numerics.Vector mask, byte* address, System.Numerics.Vector offsets) { throw null; } + // public static System.Numerics.Vector GatherVectorByteZeroExtendFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorByteZeroExtendFirstFaulting(System.Numerics.Vector mask, byte* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorByteZeroExtendFirstFaulting(System.Numerics.Vector mask, byte* address, System.Numerics.Vector offsets) { throw null; } + public static System.Numerics.Vector GatherVectorByteZeroExtendFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorByteZeroExtendFirstFaulting(System.Numerics.Vector mask, byte* address, System.Numerics.Vector offsets) { throw null; } public static unsafe System.Numerics.Vector GatherVectorFirstFaulting(System.Numerics.Vector mask, double* address, System.Numerics.Vector indices) { throw null; } - public static unsafe System.Numerics.Vector GatherVectorFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static System.Numerics.Vector GatherVectorFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } public static unsafe System.Numerics.Vector GatherVectorFirstFaulting(System.Numerics.Vector mask, double* address, System.Numerics.Vector indices) { throw null; } - // public static unsafe System.Numerics.Vector GatherVectorFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + // public static System.Numerics.Vector GatherVectorFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } public static unsafe System.Numerics.Vector GatherVectorFirstFaulting(System.Numerics.Vector mask, int* address, System.Numerics.Vector indices) { throw null; } public static unsafe System.Numerics.Vector GatherVectorFirstFaulting(System.Numerics.Vector mask, int* address, System.Numerics.Vector indices) { throw null; } - public static unsafe System.Numerics.Vector GatherVectorFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static System.Numerics.Vector GatherVectorFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } public static unsafe System.Numerics.Vector GatherVectorFirstFaulting(System.Numerics.Vector mask, long* address, System.Numerics.Vector indices) { throw null; } public static unsafe System.Numerics.Vector GatherVectorFirstFaulting(System.Numerics.Vector mask, long* address, System.Numerics.Vector indices) { throw null; } public static unsafe System.Numerics.Vector GatherVectorFirstFaulting(System.Numerics.Vector mask, float* address, System.Numerics.Vector indices) { throw null; } - // public static unsafe System.Numerics.Vector GatherVectorFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + // public static System.Numerics.Vector GatherVectorFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } public static unsafe System.Numerics.Vector GatherVectorFirstFaulting(System.Numerics.Vector mask, float* address, System.Numerics.Vector indices) { throw null; } - // public static unsafe System.Numerics.Vector GatherVectorFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + // public static System.Numerics.Vector GatherVectorFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } public static unsafe System.Numerics.Vector GatherVectorFirstFaulting(System.Numerics.Vector mask, uint* address, System.Numerics.Vector indices) { throw null; } public static unsafe System.Numerics.Vector GatherVectorFirstFaulting(System.Numerics.Vector mask, uint* address, System.Numerics.Vector indices) { throw null; } - public static unsafe System.Numerics.Vector GatherVectorFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static System.Numerics.Vector GatherVectorFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } public static unsafe System.Numerics.Vector GatherVectorFirstFaulting(System.Numerics.Vector mask, ulong* address, System.Numerics.Vector indices) { throw null; } public static unsafe System.Numerics.Vector GatherVectorFirstFaulting(System.Numerics.Vector mask, ulong* address, System.Numerics.Vector indices) { throw null; } public static unsafe System.Numerics.Vector GatherVectorInt16SignExtend(System.Numerics.Vector mask, short* address, System.Numerics.Vector indices) { throw null; } @@ -4872,6 +4884,18 @@ internal Arm64() { } public static unsafe System.Numerics.Vector GatherVectorInt16SignExtend(System.Numerics.Vector mask, short* address, System.Numerics.Vector indices) { throw null; } public static System.Numerics.Vector GatherVectorInt16SignExtend(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } public static unsafe System.Numerics.Vector GatherVectorInt16SignExtend(System.Numerics.Vector mask, short* address, System.Numerics.Vector indices) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt16SignExtendFirstFaulting(System.Numerics.Vector mask, short* address, System.Numerics.Vector indices) { throw null; } + // public static System.Numerics.Vector GatherVectorInt16SignExtendFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt16SignExtendFirstFaulting(System.Numerics.Vector mask, short* address, System.Numerics.Vector indices) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt16SignExtendFirstFaulting(System.Numerics.Vector mask, short* address, System.Numerics.Vector indices) { throw null; } + public static System.Numerics.Vector GatherVectorInt16SignExtendFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt16SignExtendFirstFaulting(System.Numerics.Vector mask, short* address, System.Numerics.Vector indices) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt16SignExtendFirstFaulting(System.Numerics.Vector mask, short* address, System.Numerics.Vector indices) { throw null; } + // public static System.Numerics.Vector GatherVectorInt16SignExtendFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt16SignExtendFirstFaulting(System.Numerics.Vector mask, short* address, System.Numerics.Vector indices) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt16SignExtendFirstFaulting(System.Numerics.Vector mask, short* address, System.Numerics.Vector indices) { throw null; } + public static System.Numerics.Vector GatherVectorInt16SignExtendFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt16SignExtendFirstFaulting(System.Numerics.Vector mask, short* address, System.Numerics.Vector indices) { throw null; } public static unsafe System.Numerics.Vector GatherVectorInt16WithByteOffsetsSignExtend(System.Numerics.Vector mask, short* address, System.Numerics.Vector offsets) { throw null; } public static unsafe System.Numerics.Vector GatherVectorInt16WithByteOffsetsSignExtend(System.Numerics.Vector mask, short* address, System.Numerics.Vector offsets) { throw null; } public static unsafe System.Numerics.Vector GatherVectorInt16WithByteOffsetsSignExtend(System.Numerics.Vector mask, short* address, System.Numerics.Vector offsets) { throw null; } @@ -4881,15 +4905,33 @@ internal Arm64() { } public static unsafe System.Numerics.Vector GatherVectorInt16WithByteOffsetsSignExtend(System.Numerics.Vector mask, short* address, System.Numerics.Vector offsets) { throw null; } public static unsafe System.Numerics.Vector GatherVectorInt16WithByteOffsetsSignExtend(System.Numerics.Vector mask, short* address, System.Numerics.Vector offsets) { throw null; } public static unsafe System.Numerics.Vector GatherVectorInt32SignExtend(System.Numerics.Vector mask, int* address, System.Numerics.Vector indices) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(System.Numerics.Vector mask, short* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(System.Numerics.Vector mask, short* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(System.Numerics.Vector mask, short* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(System.Numerics.Vector mask, short* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(System.Numerics.Vector mask, short* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(System.Numerics.Vector mask, short* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(System.Numerics.Vector mask, short* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt16WithByteOffsetsSignExtendFirstFaulting(System.Numerics.Vector mask, short* address, System.Numerics.Vector offsets) { throw null; } public static System.Numerics.Vector GatherVectorInt32SignExtend(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } public static unsafe System.Numerics.Vector GatherVectorInt32SignExtend(System.Numerics.Vector mask, int* address, System.Numerics.Vector indices) { throw null; } public static unsafe System.Numerics.Vector GatherVectorInt32SignExtend(System.Numerics.Vector mask, int* address, System.Numerics.Vector indices) { throw null; } public static System.Numerics.Vector GatherVectorInt32SignExtend(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } public static unsafe System.Numerics.Vector GatherVectorInt32SignExtend(System.Numerics.Vector mask, int* address, System.Numerics.Vector indices) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt32SignExtendFirstFaulting(System.Numerics.Vector mask, int* address, System.Numerics.Vector indices) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt32SignExtendFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt32SignExtendFirstFaulting(System.Numerics.Vector mask, int* address, System.Numerics.Vector indices) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt32SignExtendFirstFaulting(System.Numerics.Vector mask, int* address, System.Numerics.Vector indices) { throw null; } + public static System.Numerics.Vector GatherVectorInt32SignExtendFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt32SignExtendFirstFaulting(System.Numerics.Vector mask, int* address, System.Numerics.Vector indices) { throw null; } public static unsafe System.Numerics.Vector GatherVectorInt32WithByteOffsetsSignExtend(System.Numerics.Vector mask, int* address, System.Numerics.Vector offsets) { throw null; } public static unsafe System.Numerics.Vector GatherVectorInt32WithByteOffsetsSignExtend(System.Numerics.Vector mask, int* address, System.Numerics.Vector offsets) { throw null; } public static unsafe System.Numerics.Vector GatherVectorInt32WithByteOffsetsSignExtend(System.Numerics.Vector mask, int* address, System.Numerics.Vector offsets) { throw null; } public static unsafe System.Numerics.Vector GatherVectorInt32WithByteOffsetsSignExtend(System.Numerics.Vector mask, int* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt32WithByteOffsetsSignExtendFirstFaulting(System.Numerics.Vector mask, int* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt32WithByteOffsetsSignExtendFirstFaulting(System.Numerics.Vector mask, int* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt32WithByteOffsetsSignExtendFirstFaulting(System.Numerics.Vector mask, int* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorInt32WithByteOffsetsSignExtendFirstFaulting(System.Numerics.Vector mask, int* address, System.Numerics.Vector offsets) { throw null; } public static unsafe System.Numerics.Vector GatherVectorSByteSignExtend(System.Numerics.Vector mask, sbyte* address, System.Numerics.Vector indices) { throw null; } // public static System.Numerics.Vector GatherVectorSByteSignExtend(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } public static unsafe System.Numerics.Vector GatherVectorSByteSignExtend(System.Numerics.Vector mask, sbyte* address, System.Numerics.Vector indices) { throw null; } @@ -4902,6 +4944,18 @@ internal Arm64() { } public static unsafe System.Numerics.Vector GatherVectorSByteSignExtend(System.Numerics.Vector mask, sbyte* address, System.Numerics.Vector indices) { throw null; } public static System.Numerics.Vector GatherVectorSByteSignExtend(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } public static unsafe System.Numerics.Vector GatherVectorSByteSignExtend(System.Numerics.Vector mask, sbyte* address, System.Numerics.Vector indices) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorSByteSignExtendFirstFaulting(System.Numerics.Vector mask, sbyte* address, System.Numerics.Vector offsets) { throw null; } + // public static System.Numerics.Vector GatherVectorSByteSignExtendFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorSByteSignExtendFirstFaulting(System.Numerics.Vector mask, sbyte* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorSByteSignExtendFirstFaulting(System.Numerics.Vector mask, sbyte* address, System.Numerics.Vector offsets) { throw null; } + public static System.Numerics.Vector GatherVectorSByteSignExtendFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorSByteSignExtendFirstFaulting(System.Numerics.Vector mask, sbyte* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorSByteSignExtendFirstFaulting(System.Numerics.Vector mask, sbyte* address, System.Numerics.Vector offsets) { throw null; } + // public static System.Numerics.Vector GatherVectorSByteSignExtendFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorSByteSignExtendFirstFaulting(System.Numerics.Vector mask, sbyte* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorSByteSignExtendFirstFaulting(System.Numerics.Vector mask, sbyte* address, System.Numerics.Vector offsets) { throw null; } + public static System.Numerics.Vector GatherVectorSByteSignExtendFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorSByteSignExtendFirstFaulting(System.Numerics.Vector mask, sbyte* address, System.Numerics.Vector offsets) { throw null; } public static unsafe System.Numerics.Vector GatherVectorUInt16WithByteOffsetsZeroExtend(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector offsets) { throw null; } public static unsafe System.Numerics.Vector GatherVectorUInt16WithByteOffsetsZeroExtend(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector offsets) { throw null; } public static unsafe System.Numerics.Vector GatherVectorUInt16WithByteOffsetsZeroExtend(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector offsets) { throw null; } @@ -4910,6 +4964,14 @@ internal Arm64() { } public static unsafe System.Numerics.Vector GatherVectorUInt16WithByteOffsetsZeroExtend(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector offsets) { throw null; } public static unsafe System.Numerics.Vector GatherVectorUInt16WithByteOffsetsZeroExtend(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector offsets) { throw null; } public static unsafe System.Numerics.Vector GatherVectorUInt16WithByteOffsetsZeroExtend(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt16WithByteOffsetsZeroExtendFirstFaulting(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector offsets) { throw null; } public static unsafe System.Numerics.Vector GatherVectorUInt16ZeroExtend(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector indices) { throw null; } // public static System.Numerics.Vector GatherVectorUInt16ZeroExtend(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } public static unsafe System.Numerics.Vector GatherVectorUInt16ZeroExtend(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector indices) { throw null; } @@ -4922,6 +4984,18 @@ internal Arm64() { } public static unsafe System.Numerics.Vector GatherVectorUInt16ZeroExtend(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector indices) { throw null; } public static System.Numerics.Vector GatherVectorUInt16ZeroExtend(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } public static unsafe System.Numerics.Vector GatherVectorUInt16ZeroExtend(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector indices) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt16ZeroExtendFirstFaulting(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector indices) { throw null; } + // public static System.Numerics.Vector GatherVectorUInt16ZeroExtendFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt16ZeroExtendFirstFaulting(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector indices) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt16ZeroExtendFirstFaulting(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector indices) { throw null; } + public static System.Numerics.Vector GatherVectorUInt16ZeroExtendFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt16ZeroExtendFirstFaulting(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector indices) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt16ZeroExtendFirstFaulting(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector indices) { throw null; } + // public static unsafe System.Numerics.Vector GatherVectorUInt16ZeroExtendFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt16ZeroExtendFirstFaulting(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector indices) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt16ZeroExtendFirstFaulting(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector indices) { throw null; } + public static System.Numerics.Vector GatherVectorUInt16ZeroExtendFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt16ZeroExtendFirstFaulting(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector indices) { throw null; } public static unsafe System.Numerics.Vector GatherVectorUInt32WithByteOffsetsZeroExtend(System.Numerics.Vector mask, uint* address, System.Numerics.Vector offsets) { throw null; } public static unsafe System.Numerics.Vector GatherVectorUInt32WithByteOffsetsZeroExtend(System.Numerics.Vector mask, uint* address, System.Numerics.Vector offsets) { throw null; } public static unsafe System.Numerics.Vector GatherVectorUInt32WithByteOffsetsZeroExtend(System.Numerics.Vector mask, uint* address, System.Numerics.Vector offsets) { throw null; } @@ -4930,6 +5004,14 @@ internal Arm64() { } public static unsafe System.Numerics.Vector GatherVectorUInt32WithByteOffsetsZeroExtend(System.Numerics.Vector mask, uint* address, System.Numerics.Vector offsets) { throw null; } public static unsafe System.Numerics.Vector GatherVectorUInt32WithByteOffsetsZeroExtend(System.Numerics.Vector mask, uint* address, System.Numerics.Vector offsets) { throw null; } public static unsafe System.Numerics.Vector GatherVectorUInt32WithByteOffsetsZeroExtend(System.Numerics.Vector mask, uint* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(System.Numerics.Vector mask, uint* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(System.Numerics.Vector mask, uint* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(System.Numerics.Vector mask, uint* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(System.Numerics.Vector mask, uint* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(System.Numerics.Vector mask, uint* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(System.Numerics.Vector mask, uint* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(System.Numerics.Vector mask, uint* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt32WithByteOffsetsZeroExtendFirstFaulting(System.Numerics.Vector mask, uint* address, System.Numerics.Vector offsets) { throw null; } public static unsafe System.Numerics.Vector GatherVectorUInt32ZeroExtend(System.Numerics.Vector mask, uint* address, System.Numerics.Vector indices) { throw null; } // public static System.Numerics.Vector GatherVectorUInt32ZeroExtend(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } public static unsafe System.Numerics.Vector GatherVectorUInt32ZeroExtend(System.Numerics.Vector mask, uint* address, System.Numerics.Vector indices) { throw null; } @@ -4942,6 +5024,30 @@ internal Arm64() { } public static unsafe System.Numerics.Vector GatherVectorUInt32ZeroExtend(System.Numerics.Vector mask, uint* address, System.Numerics.Vector indices) { throw null; } public static System.Numerics.Vector GatherVectorUInt32ZeroExtend(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } public static unsafe System.Numerics.Vector GatherVectorUInt32ZeroExtend(System.Numerics.Vector mask, uint* address, System.Numerics.Vector indices) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt32ZeroExtendFirstFaulting(System.Numerics.Vector mask, uint* address, System.Numerics.Vector indices) { throw null; } + // public static System.Numerics.Vector GatherVectorUInt32ZeroExtendFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt32ZeroExtendFirstFaulting(System.Numerics.Vector mask, uint* address, System.Numerics.Vector indices) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt32ZeroExtendFirstFaulting(System.Numerics.Vector mask, uint* address, System.Numerics.Vector indices) { throw null; } + public static System.Numerics.Vector GatherVectorUInt32ZeroExtendFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt32ZeroExtendFirstFaulting(System.Numerics.Vector mask, uint* address, System.Numerics.Vector indices) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt32ZeroExtendFirstFaulting(System.Numerics.Vector mask, uint* address, System.Numerics.Vector indices) { throw null; } + // public static System.Numerics.Vector GatherVectorUInt32ZeroExtendFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt32ZeroExtendFirstFaulting(System.Numerics.Vector mask, uint* address, System.Numerics.Vector indices) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt32ZeroExtendFirstFaulting(System.Numerics.Vector mask, uint* address, System.Numerics.Vector indices) { throw null; } + public static System.Numerics.Vector GatherVectorUInt32ZeroExtendFirstFaulting(System.Numerics.Vector mask, System.Numerics.Vector addresses) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorUInt32ZeroExtendFirstFaulting(System.Numerics.Vector mask, uint* address, System.Numerics.Vector indices) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorWithByteOffsetFirstFaulting(System.Numerics.Vector mask, double* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorWithByteOffsetFirstFaulting(System.Numerics.Vector mask, double* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorWithByteOffsetFirstFaulting(System.Numerics.Vector mask, int* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorWithByteOffsetFirstFaulting(System.Numerics.Vector mask, int* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorWithByteOffsetFirstFaulting(System.Numerics.Vector mask, long* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorWithByteOffsetFirstFaulting(System.Numerics.Vector mask, long* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorWithByteOffsetFirstFaulting(System.Numerics.Vector mask, float* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorWithByteOffsetFirstFaulting(System.Numerics.Vector mask, float* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorWithByteOffsetFirstFaulting(System.Numerics.Vector mask, uint* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorWithByteOffsetFirstFaulting(System.Numerics.Vector mask, uint* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorWithByteOffsetFirstFaulting(System.Numerics.Vector mask, ulong* address, System.Numerics.Vector offsets) { throw null; } + public static unsafe System.Numerics.Vector GatherVectorWithByteOffsetFirstFaulting(System.Numerics.Vector mask, ulong* address, System.Numerics.Vector offsets) { throw null; } public static unsafe System.Numerics.Vector GatherVectorWithByteOffsets(System.Numerics.Vector mask, double* address, System.Numerics.Vector offsets) { throw null; } public static unsafe System.Numerics.Vector GatherVectorWithByteOffsets(System.Numerics.Vector mask, double* address, System.Numerics.Vector offsets) { throw null; } public static unsafe System.Numerics.Vector GatherVectorWithByteOffsets(System.Numerics.Vector mask, int* address, System.Numerics.Vector offsets) { throw null; } @@ -5415,24 +5521,24 @@ internal Arm64() { } public static unsafe void Scatter(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter(System.Numerics.Vector mask, double* address, System.Numerics.Vector indicies, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter(System.Numerics.Vector mask, int* address, System.Numerics.Vector indicies, System.Numerics.Vector data) { throw null; } - // public static unsafe void Scatter(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } + // public static void Scatter(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter(System.Numerics.Vector mask, int* address, System.Numerics.Vector indicies, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter(System.Numerics.Vector mask, long* address, System.Numerics.Vector indicies, System.Numerics.Vector data) { throw null; } - public static unsafe void Scatter(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } + public static void Scatter(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter(System.Numerics.Vector mask, long* address, System.Numerics.Vector indicies, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter(System.Numerics.Vector mask, float* address, System.Numerics.Vector indicies, System.Numerics.Vector data) { throw null; } - // public static unsafe void Scatter(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } + // public static void Scatter(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter(System.Numerics.Vector mask, float* address, System.Numerics.Vector indicies, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter(System.Numerics.Vector mask, uint* address, System.Numerics.Vector indicies, System.Numerics.Vector data) { throw null; } - // public static unsafe void Scatter(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } + // public static void Scatter(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter(System.Numerics.Vector mask, uint* address, System.Numerics.Vector indicies, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter(System.Numerics.Vector mask, ulong* address, System.Numerics.Vector indicies, System.Numerics.Vector data) { throw null; } - public static unsafe void Scatter(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } + public static void Scatter(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter(System.Numerics.Vector mask, ulong* address, System.Numerics.Vector indicies, System.Numerics.Vector data) { throw null; } - // public static unsafe void Scatter16BitNarrowing(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } - public static unsafe void Scatter16BitNarrowing(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } - // public static unsafe void Scatter16BitNarrowing(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } - public static unsafe void Scatter16BitNarrowing(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } + // public static void Scatter16BitNarrowing(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } + public static void Scatter16BitNarrowing(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } + // public static void Scatter16BitNarrowing(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } + public static void Scatter16BitNarrowing(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter16BitWithByteOffsetsNarrowing(System.Numerics.Vector mask, short* address, System.Numerics.Vector offsets, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter16BitWithByteOffsetsNarrowing(System.Numerics.Vector mask, short* address, System.Numerics.Vector offsets, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter16BitWithByteOffsetsNarrowing(System.Numerics.Vector mask, short* address, System.Numerics.Vector offsets, System.Numerics.Vector data) { throw null; } @@ -5441,16 +5547,16 @@ internal Arm64() { } public static unsafe void Scatter16BitWithByteOffsetsNarrowing(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector offsets, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter16BitWithByteOffsetsNarrowing(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector offsets, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter16BitWithByteOffsetsNarrowing(System.Numerics.Vector mask, ushort* address, System.Numerics.Vector offsets, System.Numerics.Vector data) { throw null; } - public static unsafe void Scatter32BitNarrowing(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } - public static unsafe void Scatter32BitNarrowing(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } + public static void Scatter32BitNarrowing(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } + public static void Scatter32BitNarrowing(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter32BitWithByteOffsetsNarrowing(System.Numerics.Vector mask, int* address, System.Numerics.Vector offsets, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter32BitWithByteOffsetsNarrowing(System.Numerics.Vector mask, int* address, System.Numerics.Vector offsets, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter32BitWithByteOffsetsNarrowing(System.Numerics.Vector mask, uint* address, System.Numerics.Vector offsets, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter32BitWithByteOffsetsNarrowing(System.Numerics.Vector mask, uint* address, System.Numerics.Vector offsets, System.Numerics.Vector data) { throw null; } - // public static unsafe void Scatter8BitNarrowing(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } - public static unsafe void Scatter8BitNarrowing(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } - // public static unsafe void Scatter8BitNarrowing(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } - public static unsafe void Scatter8BitNarrowing(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } + // public static void Scatter8BitNarrowing(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } + public static void Scatter8BitNarrowing(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } + // public static void Scatter8BitNarrowing(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } + public static void Scatter8BitNarrowing(System.Numerics.Vector mask, System.Numerics.Vector addresses, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter8BitWithByteOffsetsNarrowing(System.Numerics.Vector mask, sbyte* address, System.Numerics.Vector offsets, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter8BitWithByteOffsetsNarrowing(System.Numerics.Vector mask, sbyte* address, System.Numerics.Vector offsets, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter8BitWithByteOffsetsNarrowing(System.Numerics.Vector mask, sbyte* address, System.Numerics.Vector offsets, System.Numerics.Vector data) { throw null; } @@ -5459,14 +5565,14 @@ internal Arm64() { } public static unsafe void Scatter8BitWithByteOffsetsNarrowing(System.Numerics.Vector mask, byte* address, System.Numerics.Vector offsets, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter8BitWithByteOffsetsNarrowing(System.Numerics.Vector mask, byte* address, System.Numerics.Vector offsets, System.Numerics.Vector data) { throw null; } public static unsafe void Scatter8BitWithByteOffsetsNarrowing(System.Numerics.Vector mask, byte* address, System.Numerics.Vector offsets, System.Numerics.Vector data) { throw null; } - public static unsafe void SetFfr(System.Numerics.Vector value) { throw null; } - public static unsafe void SetFfr(System.Numerics.Vector value) { throw null; } - public static unsafe void SetFfr(System.Numerics.Vector value) { throw null; } - public static unsafe void SetFfr(System.Numerics.Vector value) { throw null; } - public static unsafe void SetFfr(System.Numerics.Vector value) { throw null; } - public static unsafe void SetFfr(System.Numerics.Vector value) { throw null; } - public static unsafe void SetFfr(System.Numerics.Vector value) { throw null; } - public static unsafe void SetFfr(System.Numerics.Vector value) { throw null; } + public static void SetFfr(System.Numerics.Vector value) { throw null; } + public static void SetFfr(System.Numerics.Vector value) { throw null; } + public static void SetFfr(System.Numerics.Vector value) { throw null; } + public static void SetFfr(System.Numerics.Vector value) { throw null; } + public static void SetFfr(System.Numerics.Vector value) { throw null; } + public static void SetFfr(System.Numerics.Vector value) { throw null; } + public static void SetFfr(System.Numerics.Vector value) { throw null; } + public static void SetFfr(System.Numerics.Vector value) { throw null; } public static System.Numerics.Vector ShiftLeftLogical(System.Numerics.Vector left, System.Numerics.Vector right) { throw null; } public static System.Numerics.Vector ShiftLeftLogical(System.Numerics.Vector left, System.Numerics.Vector right) { throw null; } public static System.Numerics.Vector ShiftLeftLogical(System.Numerics.Vector left, System.Numerics.Vector right) { throw null; } diff --git a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs index 27955248daa..09153068d91 100644 --- a/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs +++ b/src/libraries/System.Runtime.Intrinsics/tests/Vectors/Vector128Tests.cs @@ -36,7 +36,6 @@ internal static void AssertEqual(Vector128 expected, Vector128 a [Fact] [DynamicDependency(DynamicallyAccessedMemberTypes.PublicProperties, typeof(Vector128))] - [ActiveIssue("https://github.com/dotnet/runtime/issues/81785", TestPlatforms.Browser)] public unsafe void Vector128IsHardwareAcceleratedTest() { MethodInfo methodInfo = typeof(Vector128).GetMethod("get_IsHardwareAccelerated"); diff --git a/src/libraries/System.Runtime.Loader/System.Runtime.Loader.sln b/src/libraries/System.Runtime.Loader/System.Runtime.Loader.sln index 2e85dc41acf..e192e0fd0bc 100644 --- a/src/libraries/System.Runtime.Loader/System.Runtime.Loader.sln +++ b/src/libraries/System.Runtime.Loader/System.Runtime.Loader.sln @@ -7,6 +7,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib.Gene EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\System.Private.CoreLib\ref\System.Private.CoreLib.csproj", "{D7654D83-1D00-4121-BA8B-187EDD1E9EC1}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{B56490A2-B4BB-47EE-AA4F-B6EE6076DC72}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{47FCBB78-4009-4B88-BC18-9DBCD4714152}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{1FC1A751-C2A7-4CA8-B939-6F01B8AECBA8}" @@ -215,6 +217,27 @@ Global {D7654D83-1D00-4121-BA8B-187EDD1E9EC1}.Checked|arm64.ActiveCfg = Debug|Any CPU {D7654D83-1D00-4121-BA8B-187EDD1E9EC1}.Checked|x64.ActiveCfg = Debug|Any CPU {D7654D83-1D00-4121-BA8B-187EDD1E9EC1}.Checked|x86.ActiveCfg = Debug|Any CPU + {B56490A2-B4BB-47EE-AA4F-B6EE6076DC72}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {B56490A2-B4BB-47EE-AA4F-B6EE6076DC72}.Debug|Any CPU.Build.0 = Debug|Any CPU + {B56490A2-B4BB-47EE-AA4F-B6EE6076DC72}.Debug|arm.ActiveCfg = Debug|Any CPU + {B56490A2-B4BB-47EE-AA4F-B6EE6076DC72}.Debug|arm64.ActiveCfg = Debug|Any CPU + {B56490A2-B4BB-47EE-AA4F-B6EE6076DC72}.Debug|x64.ActiveCfg = Debug|Any CPU + {B56490A2-B4BB-47EE-AA4F-B6EE6076DC72}.Debug|x64.Build.0 = Debug|Any CPU + {B56490A2-B4BB-47EE-AA4F-B6EE6076DC72}.Debug|x86.ActiveCfg = Debug|Any CPU + {B56490A2-B4BB-47EE-AA4F-B6EE6076DC72}.Debug|x86.Build.0 = Debug|Any CPU + {B56490A2-B4BB-47EE-AA4F-B6EE6076DC72}.Release|Any CPU.ActiveCfg = Release|Any CPU + {B56490A2-B4BB-47EE-AA4F-B6EE6076DC72}.Release|Any CPU.Build.0 = Release|Any CPU + {B56490A2-B4BB-47EE-AA4F-B6EE6076DC72}.Release|arm.ActiveCfg = Release|Any CPU + {B56490A2-B4BB-47EE-AA4F-B6EE6076DC72}.Release|arm64.ActiveCfg = Release|Any CPU + {B56490A2-B4BB-47EE-AA4F-B6EE6076DC72}.Release|x64.ActiveCfg = Release|Any CPU + {B56490A2-B4BB-47EE-AA4F-B6EE6076DC72}.Release|x64.Build.0 = Release|Any CPU + {B56490A2-B4BB-47EE-AA4F-B6EE6076DC72}.Release|x86.ActiveCfg = Release|Any CPU + {B56490A2-B4BB-47EE-AA4F-B6EE6076DC72}.Release|x86.Build.0 = Release|Any CPU + {B56490A2-B4BB-47EE-AA4F-B6EE6076DC72}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {B56490A2-B4BB-47EE-AA4F-B6EE6076DC72}.Checked|arm.ActiveCfg = Debug|Any CPU + {B56490A2-B4BB-47EE-AA4F-B6EE6076DC72}.Checked|arm64.ActiveCfg = Debug|Any CPU + {B56490A2-B4BB-47EE-AA4F-B6EE6076DC72}.Checked|x64.ActiveCfg = Debug|Any CPU + {B56490A2-B4BB-47EE-AA4F-B6EE6076DC72}.Checked|x86.ActiveCfg = Debug|Any CPU {47FCBB78-4009-4B88-BC18-9DBCD4714152}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {47FCBB78-4009-4B88-BC18-9DBCD4714152}.Debug|Any CPU.Build.0 = Debug|Any CPU {47FCBB78-4009-4B88-BC18-9DBCD4714152}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -1094,6 +1117,7 @@ Global {E60DD367-D1D7-4F6C-919B-DC68E8445E97} = {F36F0790-5CF7-4CAD-B903-4A3EE0DC1345} {29E02AA9-E3D5-400C-B2C5-970B6E6D8562} = {F36F0790-5CF7-4CAD-B903-4A3EE0DC1345} {BFED65C3-5AF6-4C81-8AE8-7CAC7E4867AE} = {153EEF5A-58CF-4A61-B712-B14F270BD32E} + {B56490A2-B4BB-47EE-AA4F-B6EE6076DC72} = {153EEF5A-58CF-4A61-B712-B14F270BD32E} {47FCBB78-4009-4B88-BC18-9DBCD4714152} = {153EEF5A-58CF-4A61-B712-B14F270BD32E} {1FC1A751-C2A7-4CA8-B939-6F01B8AECBA8} = {153EEF5A-58CF-4A61-B712-B14F270BD32E} {D7654D83-1D00-4121-BA8B-187EDD1E9EC1} = {C75ECE17-3CF5-409D-B26F-E2F5053DD5B9} diff --git a/src/libraries/System.Runtime.Loader/ref/System.Runtime.Loader.cs b/src/libraries/System.Runtime.Loader/ref/System.Runtime.Loader.cs index e5c08f6132c..a272e40c33d 100644 --- a/src/libraries/System.Runtime.Loader/ref/System.Runtime.Loader.cs +++ b/src/libraries/System.Runtime.Loader/ref/System.Runtime.Loader.cs @@ -16,6 +16,7 @@ public static partial class AssemblyExtensions public static partial class MetadataUpdater { public static void ApplyUpdate(Assembly assembly, ReadOnlySpan metadataDelta, ReadOnlySpan ilDelta, ReadOnlySpan pdbDelta) { throw null; } + [System.Diagnostics.CodeAnalysis.FeatureSwitchDefinitionAttribute("System.Reflection.Metadata.MetadataUpdater.IsSupported")] public static bool IsSupported { get { throw null; } } } [System.AttributeUsage(System.AttributeTargets.Assembly, AllowMultiple = true)] diff --git a/src/libraries/System.Runtime.Numerics/System.Runtime.Numerics.sln b/src/libraries/System.Runtime.Numerics/System.Runtime.Numerics.sln index b4c59026fc9..7ad15ec560f 100644 --- a/src/libraries/System.Runtime.Numerics/System.Runtime.Numerics.sln +++ b/src/libraries/System.Runtime.Numerics/System.Runtime.Numerics.sln @@ -1,7 +1,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{A22876CA-76C0-4ABD-8658-C2B3DFDFE537}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{55FC83C5-F34D-4B4B-BEAE-497DD5653BCE}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{66B52408-BFE7-4C91-B38E-0E3C2E649463}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{57EC916C-15B4-46BB-AE68-B4CD8BC7076C}" EndProject @@ -49,10 +49,10 @@ Global {A22876CA-76C0-4ABD-8658-C2B3DFDFE537}.Debug|Any CPU.Build.0 = Debug|Any CPU {A22876CA-76C0-4ABD-8658-C2B3DFDFE537}.Release|Any CPU.ActiveCfg = Release|Any CPU {A22876CA-76C0-4ABD-8658-C2B3DFDFE537}.Release|Any CPU.Build.0 = Release|Any CPU - {55FC83C5-F34D-4B4B-BEAE-497DD5653BCE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {55FC83C5-F34D-4B4B-BEAE-497DD5653BCE}.Debug|Any CPU.Build.0 = Debug|Any CPU - {55FC83C5-F34D-4B4B-BEAE-497DD5653BCE}.Release|Any CPU.ActiveCfg = Release|Any CPU - {55FC83C5-F34D-4B4B-BEAE-497DD5653BCE}.Release|Any CPU.Build.0 = Release|Any CPU + {66B52408-BFE7-4C91-B38E-0E3C2E649463}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {66B52408-BFE7-4C91-B38E-0E3C2E649463}.Debug|Any CPU.Build.0 = Debug|Any CPU + {66B52408-BFE7-4C91-B38E-0E3C2E649463}.Release|Any CPU.ActiveCfg = Release|Any CPU + {66B52408-BFE7-4C91-B38E-0E3C2E649463}.Release|Any CPU.Build.0 = Release|Any CPU {57EC916C-15B4-46BB-AE68-B4CD8BC7076C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {57EC916C-15B4-46BB-AE68-B4CD8BC7076C}.Debug|Any CPU.Build.0 = Debug|Any CPU {57EC916C-15B4-46BB-AE68-B4CD8BC7076C}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -100,7 +100,7 @@ Global GlobalSection(NestedProjects) = preSolution {A22876CA-76C0-4ABD-8658-C2B3DFDFE537} = {A80D3604-A8C8-4B23-B0D3-316E46CFE60A} {2C4CBA2D-4C9D-4B83-85A4-2DF75C91B0FC} = {A80D3604-A8C8-4B23-B0D3-316E46CFE60A} - {55FC83C5-F34D-4B4B-BEAE-497DD5653BCE} = {94F2DDDF-A2DA-4F69-9613-A92D50D84A1C} + {66B52408-BFE7-4C91-B38E-0E3C2E649463} = {94F2DDDF-A2DA-4F69-9613-A92D50D84A1C} {57EC916C-15B4-46BB-AE68-B4CD8BC7076C} = {94F2DDDF-A2DA-4F69-9613-A92D50D84A1C} {C91AC3B4-647B-4D7F-83CA-BE90FFFC8CF3} = {18C5FB7C-2DE7-4BED-BA2B-53776E78E1E5} {DB1922E9-EC35-44AC-9677-277B7D00595F} = {18C5FB7C-2DE7-4BED-BA2B-53776E78E1E5} diff --git a/src/libraries/System.Runtime.Numerics/src/System/Numerics/Complex.cs b/src/libraries/System.Runtime.Numerics/src/System/Numerics/Complex.cs index 51d0580c285..e162bab1738 100644 --- a/src/libraries/System.Runtime.Numerics/src/System/Numerics/Complex.cs +++ b/src/libraries/System.Runtime.Numerics/src/System/Numerics/Complex.cs @@ -2200,6 +2200,7 @@ public static bool TryParse([NotNullWhen(true)] string? s, NumberStyles style, I public bool TryFormat(Span destination, out int charsWritten, [StringSyntax(StringSyntaxAttribute.NumericFormat)] ReadOnlySpan format = default, IFormatProvider? provider = null) => TryFormatCore(destination, out charsWritten, format, provider); + /// public bool TryFormat(Span utf8Destination, out int bytesWritten, [StringSyntax(StringSyntaxAttribute.NumericFormat)] ReadOnlySpan format = default, IFormatProvider? provider = null) => TryFormatCore(utf8Destination, out bytesWritten, format, provider); diff --git a/src/libraries/System.Runtime.Numerics/tests/BigInteger/modpow.cs b/src/libraries/System.Runtime.Numerics/tests/BigInteger/modpow.cs index 1308337bb67..f2296da7583 100644 --- a/src/libraries/System.Runtime.Numerics/tests/BigInteger/modpow.cs +++ b/src/libraries/System.Runtime.Numerics/tests/BigInteger/modpow.cs @@ -139,13 +139,6 @@ public static void ModPow1Large2SmallInt() } } - [Fact] - public static void ModPow1Large2SmallInt_Threshold() - { - // Again, with lower threshold - BigIntTools.Utils.RunWithFakeThreshold(BigIntegerCalculator.ReducerThreshold, 8, ModPow1Large2SmallInt); - } - [Fact] public static void ModPow2Large1SmallInt() { @@ -163,44 +156,6 @@ public static void ModPow2Large1SmallInt() } } - [Fact] - public static void ModPow2Large1SmallInt_Threshold() - { - // Again, with lower threshold - BigIntTools.Utils.RunWithFakeThreshold(BigIntegerCalculator.ReducerThreshold, 8, ModPow2Large1SmallInt); - } - - // InlineData randomly generated using a new Random(0) and the same logic as is used in MyBigIntImp - // When using the VerifyModPowString approach, these tests were taking over 100s to execute. - [Theory] - [OuterLoop] - [InlineData("16152447169612934532253858872860101823992426489763666485380167221632010974596350526903901586786157942589749704137347759619657187784260082814484793173551647870373927196771852", "81750440863317178198977948957223170296434385667401518194303765341584160931262254891905182291359611229458113456891057547210603179481274334549407149567413965138338569615186383", "-7196805437625531929619339290119232497987723600413951949478998858079935202962418871178150151495255147489121599998392939293913217145771279946557062800866475934948778", "5616380469802854111883204613624062553120851412450654399190717359559254034938493684003207209263083893212739965150170342564431867389596229480294680122528026782956958")] - [InlineData("-19804882257271871615998867413310154569092691610863183900352723872936597192840601413521317416195627481021453523098672122338092864102790996172", "5005126326020660905045117276428380928616741884628331700680598638081087432348216495484429178211470872172882902036752474804904132643", "-103139435102033366056363338063498713727200190198435", "-4559679593639479333979462122256288215243720737403")] - [InlineData("-2263742881720266366742488789295767051326353176981812961528848101545308514727342989711034207353102864275894987436688194776201313772226059035143797121004935923223042331190890429211181925543749113890129660515170733848725", "313166794469483345944045915670847620773229708424183728974404367769353433443313247319899209581239311758905801464781585268041623664425", "3984523819293796257818294503433333109083365267654089093971156331037874112339941681299823291492643701164442964256327008451060278818307268485187524722068240", "-1502346344475556570236985614111713440763176490652894928852811056060906839905964408583918853958610145894621840382970373570196361549098246030413222124498085")] - [InlineData("-342701069914551895507647608205424602441707687704978754182486401529587201154652163656221404036731562708712821963465111719289193200432064875769386559645346920", "247989781302056934762335026151076445832166884867735502165354252207668083157132317377069604102049233014316799294014890817943261246892765157594412634897440785353202366563028", "121555428622583377664148832113619145387775383377032217138159544127299380518157949963314283123957062240152711187509503414343", "87578369862034238407481381238856926729112161247036763388287150463197193460326629595765471822752579542310337770783772458710")] - [InlineData("-282593950368131775131360433563237877977879464854725217398276355042086422366377452969365517205334520940629323311057746859", "5959258935361466196732788139899933762310441595693546573755448590100882267274831199165902682626769861372370905838130200967035", "6598019436100687108279703832125132357070343951841815860721553173215685978621505459125000339496396952653080051757197617932586296524960251609958919233462530", "-4035534917213670830138661334307123840766321272945538719146336835321463334263841831803093764143165039453996360590495570418141622764990299884920213157241339")] - [InlineData("-283588760164723199492097446398514238808996680579814508529658395835708678571214111525627362048679162021949222615325057958783388520044013697149834530411072380435126870273057157745943859", "1042611904427950637176782337251399378305726352782300537151930702574076654415735617544217054055762002017753284951033975382044655538090809873113604", "11173562248848713955826639654969725554069867375462328112124015145073186375237811117727665778232780449525476829715663254692620996726130822561707626585790443774041565237684936409844925424596571418502946", "6662129352542591544500713232459850446949913817909326081510506555775206102887692404112984526760120407457772674917650956873499346517965094865621779695963015030158124625116211104048940313058280680420919")] - [InlineData("683399436848090272429540515929404372035986606104192913128573936597145312908480564700882440819526500604918037963508399983297602351856208190565527", "223751878996658298590720798129833935741775535718632942242965085592936259576946732440406302671204348239437556817289012497483482656", "1204888420642360606571457515385663952017382888522547766961071698778167608427220546474854934298311882921224875807375321847274969073309433075566441363244101914489524538123410250010519308563731930923389473186", "1136631484875680074951300738594593722168933395227758228596156355418704717505715681950525129323209331607163560404958604424924870345828742295978850144844693079191828839673460389985036424301333691983679427765")] - [InlineData("736513799451968530811005754031332418210960966881742655756522735504778110620671049112529346250333710388060811959329786494662578020803", "2461175085563866950903873687720858523536520498137697316698237108626602445202960480677695918813575265778826908481129155012799", "-4722693720735888562993277045098354134891725536023070176847814685098361292027040929352405620815883795027263132404351040", "4351573186631261607388198896754285562669240685903971199359912143458682154189588696264319780329366022294935204028039787")] - [InlineData("1596188639947986471148999794547338", "685242191738212089917782567856594513073397739443", "41848166029740752457613562518205823134173790454761036532025758411484449588176128053901271638836032557551179866133091058357374964041641117585422447497779410336188602585660372002644517668041207657383104649333118253", "39246949850380693159338034407642149926180988060650630387722725303281343126585456713282439764667310808891687831648451269002447916277601468727040185218264602698691553232132525542650964722093335105211816394635493987")] - [InlineData("-1506852741293695463963822334869441845197951776565891060639754936248401744065969556756496718308248025911048010080232290368562210204958094544173209793990218122", "64905085725614938357105826012272472070910693443851911667721848542473785070747281964799379996923261457185847459711", "2740467233603031668807697475486217767705051", "-1905434239471820365929630558127219204166613")] - public static void ModPow3LargeInt(string value, string exponent, string modulus, string expected) - { - BigInteger valueInt = BigInteger.Parse(value); - BigInteger exponentInt = BigInteger.Parse(exponent); - BigInteger modulusInt = BigInteger.Parse(modulus); - BigInteger resultInt = BigInteger.Parse(expected); - - // Once with default threshold - Assert.Equal(resultInt, BigInteger.ModPow(valueInt, exponentInt, modulusInt)); - - // Once with reduced threshold - BigIntTools.Utils.RunWithFakeThreshold(BigIntegerCalculator.ReducerThreshold, 8, () => - { - Assert.Equal(resultInt, BigInteger.ModPow(valueInt, exponentInt, modulusInt)); - }); - } - [Fact] public static void ModPow0Power() { @@ -462,4 +417,53 @@ public static IEnumerable AssertFailureRegressionTest_InputData() yield return [value, exponent, modulus]; } } + + [Collection(nameof(DisableParallelization))] + public class modpowTestThreshold + { + [Fact] + public static void ModPow1Large2SmallInt_Threshold() + { + // Again, with lower threshold + BigIntTools.Utils.RunWithFakeThreshold(BigIntegerCalculator.ReducerThreshold, 8, modpowTest.ModPow1Large2SmallInt); + } + + [Fact] + public static void ModPow2Large1SmallInt_Threshold() + { + // Again, with lower threshold + BigIntTools.Utils.RunWithFakeThreshold(BigIntegerCalculator.ReducerThreshold, 8, modpowTest.ModPow2Large1SmallInt); + } + + // InlineData randomly generated using a new Random(0) and the same logic as is used in MyBigIntImp + // When using the VerifyModPowString approach, these tests were taking over 100s to execute. + [Theory] + [OuterLoop] + [InlineData("16152447169612934532253858872860101823992426489763666485380167221632010974596350526903901586786157942589749704137347759619657187784260082814484793173551647870373927196771852", "81750440863317178198977948957223170296434385667401518194303765341584160931262254891905182291359611229458113456891057547210603179481274334549407149567413965138338569615186383", "-7196805437625531929619339290119232497987723600413951949478998858079935202962418871178150151495255147489121599998392939293913217145771279946557062800866475934948778", "5616380469802854111883204613624062553120851412450654399190717359559254034938493684003207209263083893212739965150170342564431867389596229480294680122528026782956958")] + [InlineData("-19804882257271871615998867413310154569092691610863183900352723872936597192840601413521317416195627481021453523098672122338092864102790996172", "5005126326020660905045117276428380928616741884628331700680598638081087432348216495484429178211470872172882902036752474804904132643", "-103139435102033366056363338063498713727200190198435", "-4559679593639479333979462122256288215243720737403")] + [InlineData("-2263742881720266366742488789295767051326353176981812961528848101545308514727342989711034207353102864275894987436688194776201313772226059035143797121004935923223042331190890429211181925543749113890129660515170733848725", "313166794469483345944045915670847620773229708424183728974404367769353433443313247319899209581239311758905801464781585268041623664425", "3984523819293796257818294503433333109083365267654089093971156331037874112339941681299823291492643701164442964256327008451060278818307268485187524722068240", "-1502346344475556570236985614111713440763176490652894928852811056060906839905964408583918853958610145894621840382970373570196361549098246030413222124498085")] + [InlineData("-342701069914551895507647608205424602441707687704978754182486401529587201154652163656221404036731562708712821963465111719289193200432064875769386559645346920", "247989781302056934762335026151076445832166884867735502165354252207668083157132317377069604102049233014316799294014890817943261246892765157594412634897440785353202366563028", "121555428622583377664148832113619145387775383377032217138159544127299380518157949963314283123957062240152711187509503414343", "87578369862034238407481381238856926729112161247036763388287150463197193460326629595765471822752579542310337770783772458710")] + [InlineData("-282593950368131775131360433563237877977879464854725217398276355042086422366377452969365517205334520940629323311057746859", "5959258935361466196732788139899933762310441595693546573755448590100882267274831199165902682626769861372370905838130200967035", "6598019436100687108279703832125132357070343951841815860721553173215685978621505459125000339496396952653080051757197617932586296524960251609958919233462530", "-4035534917213670830138661334307123840766321272945538719146336835321463334263841831803093764143165039453996360590495570418141622764990299884920213157241339")] + [InlineData("-283588760164723199492097446398514238808996680579814508529658395835708678571214111525627362048679162021949222615325057958783388520044013697149834530411072380435126870273057157745943859", "1042611904427950637176782337251399378305726352782300537151930702574076654415735617544217054055762002017753284951033975382044655538090809873113604", "11173562248848713955826639654969725554069867375462328112124015145073186375237811117727665778232780449525476829715663254692620996726130822561707626585790443774041565237684936409844925424596571418502946", "6662129352542591544500713232459850446949913817909326081510506555775206102887692404112984526760120407457772674917650956873499346517965094865621779695963015030158124625116211104048940313058280680420919")] + [InlineData("683399436848090272429540515929404372035986606104192913128573936597145312908480564700882440819526500604918037963508399983297602351856208190565527", "223751878996658298590720798129833935741775535718632942242965085592936259576946732440406302671204348239437556817289012497483482656", "1204888420642360606571457515385663952017382888522547766961071698778167608427220546474854934298311882921224875807375321847274969073309433075566441363244101914489524538123410250010519308563731930923389473186", "1136631484875680074951300738594593722168933395227758228596156355418704717505715681950525129323209331607163560404958604424924870345828742295978850144844693079191828839673460389985036424301333691983679427765")] + [InlineData("736513799451968530811005754031332418210960966881742655756522735504778110620671049112529346250333710388060811959329786494662578020803", "2461175085563866950903873687720858523536520498137697316698237108626602445202960480677695918813575265778826908481129155012799", "-4722693720735888562993277045098354134891725536023070176847814685098361292027040929352405620815883795027263132404351040", "4351573186631261607388198896754285562669240685903971199359912143458682154189588696264319780329366022294935204028039787")] + [InlineData("1596188639947986471148999794547338", "685242191738212089917782567856594513073397739443", "41848166029740752457613562518205823134173790454761036532025758411484449588176128053901271638836032557551179866133091058357374964041641117585422447497779410336188602585660372002644517668041207657383104649333118253", "39246949850380693159338034407642149926180988060650630387722725303281343126585456713282439764667310808891687831648451269002447916277601468727040185218264602698691553232132525542650964722093335105211816394635493987")] + [InlineData("-1506852741293695463963822334869441845197951776565891060639754936248401744065969556756496718308248025911048010080232290368562210204958094544173209793990218122", "64905085725614938357105826012272472070910693443851911667721848542473785070747281964799379996923261457185847459711", "2740467233603031668807697475486217767705051", "-1905434239471820365929630558127219204166613")] + public static void ModPow3LargeInt(string value, string exponent, string modulus, string expected) + { + BigInteger valueInt = BigInteger.Parse(value); + BigInteger exponentInt = BigInteger.Parse(exponent); + BigInteger modulusInt = BigInteger.Parse(modulus); + BigInteger resultInt = BigInteger.Parse(expected); + + // Once with default threshold + Assert.Equal(resultInt, BigInteger.ModPow(valueInt, exponentInt, modulusInt)); + + // Once with reduced threshold + BigIntTools.Utils.RunWithFakeThreshold(BigIntegerCalculator.ReducerThreshold, 8, () => + { + Assert.Equal(resultInt, BigInteger.ModPow(valueInt, exponentInt, modulusInt)); + }); + } + } } diff --git a/src/libraries/System.Runtime.Numerics/tests/BigInteger/parse.cs b/src/libraries/System.Runtime.Numerics/tests/BigInteger/parse.cs index 85a2fcd182a..c8adf62e278 100644 --- a/src/libraries/System.Runtime.Numerics/tests/BigInteger/parse.cs +++ b/src/libraries/System.Runtime.Numerics/tests/BigInteger/parse.cs @@ -86,15 +86,20 @@ public static void RunParseToStringTests(CultureInfo culture) } } + public static IEnumerable Parse_Subspan_Success_TestData() + { + yield return new object[] { "123456789", 0, 9, "123456789" }; + yield return new object[] { "123456789", 0, 1, "1" }; + yield return new object[] { "123456789", 1, 3, "234" }; + yield return new object[] { "123456789", 8, 1, "9" }; + yield return new object[] { "123456789abc", 8, 1, "9" }; + yield return new object[] { "1\03456789", 0, 1, "1" }; + yield return new object[] { "1\03456789", 0, 2, "1" }; + yield return new object[] { "123456789\0", 0, 10, "123456789" }; + } + [Theory] - [InlineData("123456789", 0, 9, "123456789")] - [InlineData("123456789", 0, 1, "1")] - [InlineData("123456789", 1, 3, "234")] - [InlineData("123456789", 8, 1, "9")] - [InlineData("123456789abc", 8, 1, "9")] - [InlineData("1\03456789", 0, 1, "1")] - [InlineData("1\03456789", 0, 2, "1")] - [InlineData("123456789\0", 0, 10, "123456789")] + [MemberData(nameof(Parse_Subspan_Success_TestData))] public static void Parse_Subspan_Success(string input, int offset, int length, string expected) { Eval(BigInteger.Parse(input.AsSpan(offset, length)), expected); @@ -1171,6 +1176,7 @@ private static void Eval(BigInteger x, string expected) public class parseTestThreshold { public static IEnumerable Cultures => parseTest.Cultures; + [Theory] [MemberData(nameof(Cultures))] [OuterLoop] @@ -1183,15 +1189,10 @@ public static void RunParseToStringTests(CultureInfo culture) })); } + public static IEnumerable Parse_Subspan_Success_TestData() => parseTest.Parse_Subspan_Success_TestData(); + [Theory] - [InlineData("123456789", 0, 9, "123456789")] - [InlineData("123456789", 0, 1, "1")] - [InlineData("123456789", 1, 3, "234")] - [InlineData("123456789", 8, 1, "9")] - [InlineData("123456789abc", 8, 1, "9")] - [InlineData("1\03456789", 0, 1, "1")] - [InlineData("1\03456789", 0, 2, "1")] - [InlineData("123456789\0", 0, 10, "123456789")] + [MemberData(nameof(Parse_Subspan_Success_TestData))] public static void Parse_Subspan_Success(string input, int offset, int length, string expected) { BigIntTools.Utils.RunWithFakeThreshold(Number.BigIntegerParseNaiveThreshold, 0, () => diff --git a/src/libraries/System.Runtime.Serialization.Formatters/System.Runtime.Serialization.Formatters.sln b/src/libraries/System.Runtime.Serialization.Formatters/System.Runtime.Serialization.Formatters.sln index 868141ca7b3..03d2d3913f1 100644 --- a/src/libraries/System.Runtime.Serialization.Formatters/System.Runtime.Serialization.Formatters.sln +++ b/src/libraries/System.Runtime.Serialization.Formatters/System.Runtime.Serialization.Formatters.sln @@ -83,6 +83,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.Metadata" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{C53A69A6-5DD9-4C53-AE34-88424D0A043D}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{A3152DF4-0BE0-4A46-A049-F8BF8A893C71}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{4695E11B-4AB8-4376-832D-54344DD42316}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{B6796238-B6F5-488E-97A9-50EC2966B633}" @@ -107,10 +109,6 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Security.Permissions EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Security.Permissions", "..\System.Security.Permissions\src\System.Security.Permissions.csproj", "{3EA84883-E564-483D-A44E-FF1CC947B7A0}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Text.Encoding.CodePages", "..\System.Text.Encoding.CodePages\ref\System.Text.Encoding.CodePages.csproj", "{DAE71710-C0BC-46CA-BC72-627C96B79494}" -EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Text.Encoding.CodePages", "..\System.Text.Encoding.CodePages\src\System.Text.Encoding.CodePages.csproj", "{7913F002-64DC-43C6-9D74-B0B9BA297F00}" -EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Threading.Channels", "..\System.Threading.Channels\ref\System.Threading.Channels.csproj", "{E72B45B0-D05E-4F86-86E4-45B65FBB6617}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Threading.Channels", "..\System.Threading.Channels\src\System.Threading.Channels.csproj", "{B6953324-8866-4D94-B352-20EF38EA6774}" @@ -149,6 +147,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ref", "tools\ref", "{CDD725 EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tools", "tools", "{21D78340-7F96-4519-983F-529077A11AE1}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Runtime.Serialization.Formatters.Disabled.Tests", "tests\Disabled\System.Runtime.Serialization.Formatters.Disabled.Tests.csproj", "{0C8ADEFB-33FB-4785-A828-93377745B2BA}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -1059,6 +1059,27 @@ Global {C53A69A6-5DD9-4C53-AE34-88424D0A043D}.Checked|arm64.ActiveCfg = Debug|Any CPU {C53A69A6-5DD9-4C53-AE34-88424D0A043D}.Checked|x64.ActiveCfg = Debug|Any CPU {C53A69A6-5DD9-4C53-AE34-88424D0A043D}.Checked|x86.ActiveCfg = Debug|Any CPU + {A3152DF4-0BE0-4A46-A049-F8BF8A893C71}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A3152DF4-0BE0-4A46-A049-F8BF8A893C71}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A3152DF4-0BE0-4A46-A049-F8BF8A893C71}.Debug|arm.ActiveCfg = Debug|Any CPU + {A3152DF4-0BE0-4A46-A049-F8BF8A893C71}.Debug|arm64.ActiveCfg = Debug|Any CPU + {A3152DF4-0BE0-4A46-A049-F8BF8A893C71}.Debug|x64.ActiveCfg = Debug|Any CPU + {A3152DF4-0BE0-4A46-A049-F8BF8A893C71}.Debug|x64.Build.0 = Debug|Any CPU + {A3152DF4-0BE0-4A46-A049-F8BF8A893C71}.Debug|x86.ActiveCfg = Debug|Any CPU + {A3152DF4-0BE0-4A46-A049-F8BF8A893C71}.Debug|x86.Build.0 = Debug|Any CPU + {A3152DF4-0BE0-4A46-A049-F8BF8A893C71}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A3152DF4-0BE0-4A46-A049-F8BF8A893C71}.Release|Any CPU.Build.0 = Release|Any CPU + {A3152DF4-0BE0-4A46-A049-F8BF8A893C71}.Release|arm.ActiveCfg = Release|Any CPU + {A3152DF4-0BE0-4A46-A049-F8BF8A893C71}.Release|arm64.ActiveCfg = Release|Any CPU + {A3152DF4-0BE0-4A46-A049-F8BF8A893C71}.Release|x64.ActiveCfg = Release|Any CPU + {A3152DF4-0BE0-4A46-A049-F8BF8A893C71}.Release|x64.Build.0 = Release|Any CPU + {A3152DF4-0BE0-4A46-A049-F8BF8A893C71}.Release|x86.ActiveCfg = Release|Any CPU + {A3152DF4-0BE0-4A46-A049-F8BF8A893C71}.Release|x86.Build.0 = Release|Any CPU + {A3152DF4-0BE0-4A46-A049-F8BF8A893C71}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {A3152DF4-0BE0-4A46-A049-F8BF8A893C71}.Checked|arm.ActiveCfg = Debug|Any CPU + {A3152DF4-0BE0-4A46-A049-F8BF8A893C71}.Checked|arm64.ActiveCfg = Debug|Any CPU + {A3152DF4-0BE0-4A46-A049-F8BF8A893C71}.Checked|x64.ActiveCfg = Debug|Any CPU + {A3152DF4-0BE0-4A46-A049-F8BF8A893C71}.Checked|x86.ActiveCfg = Debug|Any CPU {4695E11B-4AB8-4376-832D-54344DD42316}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {4695E11B-4AB8-4376-832D-54344DD42316}.Debug|Any CPU.Build.0 = Debug|Any CPU {4695E11B-4AB8-4376-832D-54344DD42316}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -1311,48 +1332,6 @@ Global {3EA84883-E564-483D-A44E-FF1CC947B7A0}.Checked|arm64.ActiveCfg = Debug|Any CPU {3EA84883-E564-483D-A44E-FF1CC947B7A0}.Checked|x64.ActiveCfg = Debug|Any CPU {3EA84883-E564-483D-A44E-FF1CC947B7A0}.Checked|x86.ActiveCfg = Debug|Any CPU - {DAE71710-C0BC-46CA-BC72-627C96B79494}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {DAE71710-C0BC-46CA-BC72-627C96B79494}.Debug|Any CPU.Build.0 = Debug|Any CPU - {DAE71710-C0BC-46CA-BC72-627C96B79494}.Debug|arm.ActiveCfg = Debug|Any CPU - {DAE71710-C0BC-46CA-BC72-627C96B79494}.Debug|arm64.ActiveCfg = Debug|Any CPU - {DAE71710-C0BC-46CA-BC72-627C96B79494}.Debug|x64.ActiveCfg = Debug|Any CPU - {DAE71710-C0BC-46CA-BC72-627C96B79494}.Debug|x64.Build.0 = Debug|Any CPU - {DAE71710-C0BC-46CA-BC72-627C96B79494}.Debug|x86.ActiveCfg = Debug|Any CPU - {DAE71710-C0BC-46CA-BC72-627C96B79494}.Debug|x86.Build.0 = Debug|Any CPU - {DAE71710-C0BC-46CA-BC72-627C96B79494}.Release|Any CPU.ActiveCfg = Release|Any CPU - {DAE71710-C0BC-46CA-BC72-627C96B79494}.Release|Any CPU.Build.0 = Release|Any CPU - {DAE71710-C0BC-46CA-BC72-627C96B79494}.Release|arm.ActiveCfg = Release|Any CPU - {DAE71710-C0BC-46CA-BC72-627C96B79494}.Release|arm64.ActiveCfg = Release|Any CPU - {DAE71710-C0BC-46CA-BC72-627C96B79494}.Release|x64.ActiveCfg = Release|Any CPU - {DAE71710-C0BC-46CA-BC72-627C96B79494}.Release|x64.Build.0 = Release|Any CPU - {DAE71710-C0BC-46CA-BC72-627C96B79494}.Release|x86.ActiveCfg = Release|Any CPU - {DAE71710-C0BC-46CA-BC72-627C96B79494}.Release|x86.Build.0 = Release|Any CPU - {DAE71710-C0BC-46CA-BC72-627C96B79494}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {DAE71710-C0BC-46CA-BC72-627C96B79494}.Checked|arm.ActiveCfg = Debug|Any CPU - {DAE71710-C0BC-46CA-BC72-627C96B79494}.Checked|arm64.ActiveCfg = Debug|Any CPU - {DAE71710-C0BC-46CA-BC72-627C96B79494}.Checked|x64.ActiveCfg = Debug|Any CPU - {DAE71710-C0BC-46CA-BC72-627C96B79494}.Checked|x86.ActiveCfg = Debug|Any CPU - {7913F002-64DC-43C6-9D74-B0B9BA297F00}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {7913F002-64DC-43C6-9D74-B0B9BA297F00}.Debug|Any CPU.Build.0 = Debug|Any CPU - {7913F002-64DC-43C6-9D74-B0B9BA297F00}.Debug|arm.ActiveCfg = Debug|Any CPU - {7913F002-64DC-43C6-9D74-B0B9BA297F00}.Debug|arm64.ActiveCfg = Debug|Any CPU - {7913F002-64DC-43C6-9D74-B0B9BA297F00}.Debug|x64.ActiveCfg = Debug|Any CPU - {7913F002-64DC-43C6-9D74-B0B9BA297F00}.Debug|x64.Build.0 = Debug|Any CPU - {7913F002-64DC-43C6-9D74-B0B9BA297F00}.Debug|x86.ActiveCfg = Debug|Any CPU - {7913F002-64DC-43C6-9D74-B0B9BA297F00}.Debug|x86.Build.0 = Debug|Any CPU - {7913F002-64DC-43C6-9D74-B0B9BA297F00}.Release|Any CPU.ActiveCfg = Release|Any CPU - {7913F002-64DC-43C6-9D74-B0B9BA297F00}.Release|Any CPU.Build.0 = Release|Any CPU - {7913F002-64DC-43C6-9D74-B0B9BA297F00}.Release|arm.ActiveCfg = Release|Any CPU - {7913F002-64DC-43C6-9D74-B0B9BA297F00}.Release|arm64.ActiveCfg = Release|Any CPU - {7913F002-64DC-43C6-9D74-B0B9BA297F00}.Release|x64.ActiveCfg = Release|Any CPU - {7913F002-64DC-43C6-9D74-B0B9BA297F00}.Release|x64.Build.0 = Release|Any CPU - {7913F002-64DC-43C6-9D74-B0B9BA297F00}.Release|x86.ActiveCfg = Release|Any CPU - {7913F002-64DC-43C6-9D74-B0B9BA297F00}.Release|x86.Build.0 = Release|Any CPU - {7913F002-64DC-43C6-9D74-B0B9BA297F00}.Checked|Any CPU.ActiveCfg = Debug|Any CPU - {7913F002-64DC-43C6-9D74-B0B9BA297F00}.Checked|arm.ActiveCfg = Debug|Any CPU - {7913F002-64DC-43C6-9D74-B0B9BA297F00}.Checked|arm64.ActiveCfg = Debug|Any CPU - {7913F002-64DC-43C6-9D74-B0B9BA297F00}.Checked|x64.ActiveCfg = Debug|Any CPU - {7913F002-64DC-43C6-9D74-B0B9BA297F00}.Checked|x86.ActiveCfg = Debug|Any CPU {E72B45B0-D05E-4F86-86E4-45B65FBB6617}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {E72B45B0-D05E-4F86-86E4-45B65FBB6617}.Debug|Any CPU.Build.0 = Debug|Any CPU {E72B45B0-D05E-4F86-86E4-45B65FBB6617}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -1584,6 +1563,36 @@ Global {5149AC24-C1A7-4A4C-BE83-FF3037B99E4C}.Checked|arm64.ActiveCfg = Debug|Any CPU {5149AC24-C1A7-4A4C-BE83-FF3037B99E4C}.Checked|x64.ActiveCfg = Debug|Any CPU {5149AC24-C1A7-4A4C-BE83-FF3037B99E4C}.Checked|x86.ActiveCfg = Debug|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Checked|Any CPU.Build.0 = Debug|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Checked|arm.ActiveCfg = Debug|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Checked|arm.Build.0 = Debug|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Checked|arm64.ActiveCfg = Debug|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Checked|arm64.Build.0 = Debug|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Checked|x64.ActiveCfg = Debug|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Checked|x64.Build.0 = Debug|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Checked|x86.ActiveCfg = Debug|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Checked|x86.Build.0 = Debug|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Debug|Any CPU.Build.0 = Debug|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Debug|arm.ActiveCfg = Debug|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Debug|arm.Build.0 = Debug|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Debug|arm64.ActiveCfg = Debug|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Debug|arm64.Build.0 = Debug|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Debug|x64.ActiveCfg = Debug|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Debug|x64.Build.0 = Debug|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Debug|x86.ActiveCfg = Debug|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Debug|x86.Build.0 = Debug|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Release|Any CPU.ActiveCfg = Release|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Release|Any CPU.Build.0 = Release|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Release|arm.ActiveCfg = Release|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Release|arm.Build.0 = Release|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Release|arm64.ActiveCfg = Release|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Release|arm64.Build.0 = Release|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Release|x64.ActiveCfg = Release|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Release|x64.Build.0 = Release|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Release|x86.ActiveCfg = Release|Any CPU + {0C8ADEFB-33FB-4785-A828-93377745B2BA}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -1615,7 +1624,6 @@ Global {711CBCE0-C21C-45DA-B0D2-D2298941058E} = {38DE9ACA-E3C9-44BC-B7C3-A5BF363D85D7} {DF679A1A-1797-40EB-A8AA-E3AEA66C80E5} = {38DE9ACA-E3C9-44BC-B7C3-A5BF363D85D7} {3EA84883-E564-483D-A44E-FF1CC947B7A0} = {38DE9ACA-E3C9-44BC-B7C3-A5BF363D85D7} - {7913F002-64DC-43C6-9D74-B0B9BA297F00} = {38DE9ACA-E3C9-44BC-B7C3-A5BF363D85D7} {B6953324-8866-4D94-B352-20EF38EA6774} = {38DE9ACA-E3C9-44BC-B7C3-A5BF363D85D7} {0A103F2A-2FF6-4291-AB51-203E5CA00B2D} = {38DE9ACA-E3C9-44BC-B7C3-A5BF363D85D7} {78994C91-3A4F-4825-86C2-21FB4F082CA7} = {38DE9ACA-E3C9-44BC-B7C3-A5BF363D85D7} @@ -1643,12 +1651,12 @@ Global {B4B34CC2-EE3B-406A-9A55-74B219BDCD0F} = {56502718-F82A-46E2-9AD0-532C437EC51E} {CBE6BB10-0C9C-4620-8F49-A5BF4476B3D7} = {56502718-F82A-46E2-9AD0-532C437EC51E} {143DCF72-7DD7-4365-8B47-D67010F662A1} = {56502718-F82A-46E2-9AD0-532C437EC51E} - {DAE71710-C0BC-46CA-BC72-627C96B79494} = {56502718-F82A-46E2-9AD0-532C437EC51E} {E72B45B0-D05E-4F86-86E4-45B65FBB6617} = {56502718-F82A-46E2-9AD0-532C437EC51E} {F04E0408-978A-40D3-BB5A-C63893B11FBC} = {56502718-F82A-46E2-9AD0-532C437EC51E} {E92F7B7A-D34D-49B8-8857-09936624E038} = {56502718-F82A-46E2-9AD0-532C437EC51E} {30C04925-08A1-4AFC-AE30-D7FA39945A5B} = {A8ED4215-E7B8-4F14-B61D-F737E24C856A} {C53A69A6-5DD9-4C53-AE34-88424D0A043D} = {A8ED4215-E7B8-4F14-B61D-F737E24C856A} + {A3152DF4-0BE0-4A46-A049-F8BF8A893C71} = {A8ED4215-E7B8-4F14-B61D-F737E24C856A} {4695E11B-4AB8-4376-832D-54344DD42316} = {A8ED4215-E7B8-4F14-B61D-F737E24C856A} {B6796238-B6F5-488E-97A9-50EC2966B633} = {A8ED4215-E7B8-4F14-B61D-F737E24C856A} {0CA04347-D51A-4F7C-927C-FB45E2B266D8} = {D46042B1-7AEB-4642-8591-E6B3F2E0F1C4} @@ -1659,6 +1667,7 @@ Global {E8705420-F755-4CBA-970D-B745F59F9780} = {21D78340-7F96-4519-983F-529077A11AE1} {5149AC24-C1A7-4A4C-BE83-FF3037B99E4C} = {CDD72541-F0ED-41FA-9C9A-5D774CEB22E4} {CDD72541-F0ED-41FA-9C9A-5D774CEB22E4} = {21D78340-7F96-4519-983F-529077A11AE1} + {0C8ADEFB-33FB-4785-A828-93377745B2BA} = {F8CB1B1F-F935-4ECE-B3C2-CF62B5654BF2} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {158060A0-BFF9-48E6-90A9-93F52FEB5D3B} diff --git a/src/libraries/System.Runtime.Serialization.Formatters/src/ILLink/ILLink.Substitutions.xml b/src/libraries/System.Runtime.Serialization.Formatters/src/ILLink/ILLink.Substitutions.xml deleted file mode 100644 index 891fc4c11e4..00000000000 --- a/src/libraries/System.Runtime.Serialization.Formatters/src/ILLink/ILLink.Substitutions.xml +++ /dev/null @@ -1,7 +0,0 @@ - - - - - - - diff --git a/src/libraries/System.Runtime.Serialization.Formatters/src/System.Runtime.Serialization.Formatters.csproj b/src/libraries/System.Runtime.Serialization.Formatters/src/System.Runtime.Serialization.Formatters.csproj index ff0f8cab28f..ebe9cb673b0 100644 --- a/src/libraries/System.Runtime.Serialization.Formatters/src/System.Runtime.Serialization.Formatters.csproj +++ b/src/libraries/System.Runtime.Serialization.Formatters/src/System.Runtime.Serialization.Formatters.csproj @@ -18,10 +18,6 @@ true - - - - @@ -98,4 +94,8 @@ + + + + diff --git a/src/libraries/System.Runtime.Serialization.Formatters/src/System/Runtime/Serialization/LocalAppContextSwitches.cs b/src/libraries/System.Runtime.Serialization.Formatters/src/System/Runtime/Serialization/LocalAppContextSwitches.cs index eead42d65a8..169eb991b71 100644 --- a/src/libraries/System.Runtime.Serialization.Formatters/src/System/Runtime/Serialization/LocalAppContextSwitches.cs +++ b/src/libraries/System.Runtime.Serialization.Formatters/src/System/Runtime/Serialization/LocalAppContextSwitches.cs @@ -1,6 +1,7 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System.Diagnostics.CodeAnalysis; using System.Runtime.CompilerServices; namespace System @@ -8,6 +9,7 @@ namespace System internal static partial class LocalAppContextSwitches { private static int s_binaryFormatterEnabled; + [FeatureSwitchDefinition("System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization")] public static bool BinaryFormatterEnabled { [MethodImpl(MethodImplOptions.AggressiveInlining)] diff --git a/src/libraries/System.Runtime.Serialization.Formatters/tests/BinaryFormatterTests.cs b/src/libraries/System.Runtime.Serialization.Formatters/tests/BinaryFormatterTests.cs index 697bde27a1b..4bee131918f 100644 --- a/src/libraries/System.Runtime.Serialization.Formatters/tests/BinaryFormatterTests.cs +++ b/src/libraries/System.Runtime.Serialization.Formatters/tests/BinaryFormatterTests.cs @@ -67,7 +67,6 @@ public void ValidateBasicObjectsRoundtrip(object obj, FormatterAssemblyStyle ass [Theory] [SkipOnCoreClr("Takes too long on Checked", ~RuntimeConfiguration.Release)] - [ActiveIssue("https://github.com/dotnet/runtime/issues/105020", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsPpc64leProcess))] [MemberData(nameof(SerializableObjects_MemberData))] public void ValidateAgainstBlobs(object obj, TypeSerializableValue[] blobs) => ValidateAndRoundtrip(obj, blobs, false); diff --git a/src/libraries/System.Runtime.Serialization.Formatters/tests/DisableBitTests.cs b/src/libraries/System.Runtime.Serialization.Formatters/tests/Disabled/DisableBitTests.cs similarity index 100% rename from src/libraries/System.Runtime.Serialization.Formatters/tests/DisableBitTests.cs rename to src/libraries/System.Runtime.Serialization.Formatters/tests/Disabled/DisableBitTests.cs diff --git a/src/libraries/System.Runtime.Serialization.Formatters/tests/Disabled/System.Runtime.Serialization.Formatters.Disabled.Tests.csproj b/src/libraries/System.Runtime.Serialization.Formatters/tests/Disabled/System.Runtime.Serialization.Formatters.Disabled.Tests.csproj new file mode 100644 index 00000000000..8ea7a29a393 --- /dev/null +++ b/src/libraries/System.Runtime.Serialization.Formatters/tests/Disabled/System.Runtime.Serialization.Formatters.Disabled.Tests.csproj @@ -0,0 +1,23 @@ + + + true + true + $(NetCoreAppCurrent)-windows;$(NetCoreAppCurrent)-freebsd;$(NetCoreAppCurrent)-illumos;$(NetCoreAppCurrent)-solaris;$(NetCoreAppCurrent)-haiku;$(NetCoreAppCurrent)-linux;$(NetCoreAppCurrent)-osx;$(NetCoreAppCurrent)-ios;$(NetCoreAppCurrent)-tvos + + + + + + + + + + + + + diff --git a/src/libraries/System.Runtime.Serialization.Formatters/tests/SerializationGuardTests.cs b/src/libraries/System.Runtime.Serialization.Formatters/tests/SerializationGuardTests.cs index 3805070b47d..444e0cc2f38 100644 --- a/src/libraries/System.Runtime.Serialization.Formatters/tests/SerializationGuardTests.cs +++ b/src/libraries/System.Runtime.Serialization.Formatters/tests/SerializationGuardTests.cs @@ -1,125 +1,40 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -using System; -using System.Diagnostics; using System.IO; -using System.Reflection; using System.Runtime.Serialization.Formatters.Binary; -using System.Threading; -using System.Threading.Tasks; using Xunit; namespace System.Runtime.Serialization.Formatters.Tests { + // When BinaryFormatter was built-in to the platform we used to activate SerializationGuard in ObjectReader.Deserialize, + // but now that it has moved to an OOB offering it no longer does. [ConditionalClass(typeof(TestConfiguration), nameof(TestConfiguration.IsBinaryFormatterEnabled))] public static class SerializationGuardTests { [Fact] - public static void BlockAssemblyLoads() - { - TryPayload(new AssemblyLoader()); - } - - [Fact] - public static void BlockProcessStarts() - { - TryPayload(new ProcessStarter()); - } - - [Fact] - public static void BlockFileWrites() - { - TryPayload(new FileWriter()); - } - - [Fact] - public static void BlockAsyncDodging() - { - TryPayload(new AsyncDodger()); - } - - private static void TryPayload(object payload) + public static void IsNoLongerActivated() { MemoryStream ms = new MemoryStream(); BinaryFormatter writer = new BinaryFormatter(); - writer.Serialize(ms, payload); + writer.Serialize(ms, new ThrowIfDeserializationInProgress()); ms.Position = 0; BinaryFormatter reader = new BinaryFormatter(); - SerializationException se = Assert.Throws(() => reader.Deserialize(ms)); - Assert.IsAssignableFrom(se.InnerException); - } - } - - [Serializable] - internal class AssemblyLoader : ISerializable - { - public AssemblyLoader() { } - - public AssemblyLoader(SerializationInfo info, StreamingContext context) - { - Assembly.Load(new byte[1000]); - } - - public void GetObjectData(SerializationInfo info, StreamingContext context) - { + Assert.NotNull(reader.Deserialize(ms)); } } [Serializable] - internal class ProcessStarter : ISerializable + internal class ThrowIfDeserializationInProgress : ISerializable { - public ProcessStarter() { } - - private ProcessStarter(SerializationInfo info, StreamingContext context) - { - Process.Start("calc.exe"); - } + private static int s_cachedSerializationSwitch; - public void GetObjectData(SerializationInfo info, StreamingContext context) - { - } - } - - [Serializable] - internal class FileWriter : ISerializable - { - public FileWriter() { } - - private FileWriter(SerializationInfo info, StreamingContext context) - { - string tempPath = Path.GetTempFileName(); - File.WriteAllText(tempPath, "This better not be written..."); - throw new UnreachableException("Unreachable code (SerializationGuard should have kicked in)"); - } - - public void GetObjectData(SerializationInfo info, StreamingContext context) - { - } - } - - [Serializable] - internal class AsyncDodger : ISerializable - { - public AsyncDodger() { } - - private AsyncDodger(SerializationInfo info, StreamingContext context) - { - try - { - Task t = Task.Factory.StartNew(LoadAssemblyOnBackgroundThread, TaskCreationOptions.LongRunning); - t.Wait(); - } - catch (AggregateException ex) - { - throw ex.InnerException; - } - } + public ThrowIfDeserializationInProgress() { } - private void LoadAssemblyOnBackgroundThread() + private ThrowIfDeserializationInProgress(SerializationInfo info, StreamingContext context) { - Assembly.Load(new byte[1000]); + SerializationGuard.ThrowIfDeserializationInProgress("AllowProcessCreation", ref s_cachedSerializationSwitch); } public void GetObjectData(SerializationInfo info, StreamingContext context) diff --git a/src/libraries/System.Runtime.Serialization.Formatters/tests/System.Runtime.Serialization.Formatters.Tests.csproj b/src/libraries/System.Runtime.Serialization.Formatters/tests/System.Runtime.Serialization.Formatters.Tests.csproj index 03df94a257a..96a0f784a23 100644 --- a/src/libraries/System.Runtime.Serialization.Formatters/tests/System.Runtime.Serialization.Formatters.Tests.csproj +++ b/src/libraries/System.Runtime.Serialization.Formatters/tests/System.Runtime.Serialization.Formatters.Tests.csproj @@ -7,7 +7,6 @@ - @@ -36,6 +35,8 @@ + @@ -48,8 +49,11 @@ - + + @@ -65,15 +69,4 @@ - - - - - - diff --git a/src/libraries/System.Runtime.Serialization.Json/System.Runtime.Serialization.Json.sln b/src/libraries/System.Runtime.Serialization.Json/System.Runtime.Serialization.Json.sln index 2ec3fdd279e..4baa97d6495 100644 --- a/src/libraries/System.Runtime.Serialization.Json/System.Runtime.Serialization.Json.sln +++ b/src/libraries/System.Runtime.Serialization.Json/System.Runtime.Serialization.Json.sln @@ -11,7 +11,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Net.Primitives", ".. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.DataContractSerialization", "..\System.Private.DataContractSerialization\src\System.Private.DataContractSerialization.csproj", "{6045DECE-8425-4EE2-8685-7F2F21A3F691}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{B5544BD7-96BD-47E8-A27A-F18D42B44D7B}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{AD2FCB62-A8E0-4149-83B8-5FB8B542AB01}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{2D7FD180-D8EE-48B5-B71D-1AE8DEAB1F37}" EndProject @@ -91,10 +91,10 @@ Global {6045DECE-8425-4EE2-8685-7F2F21A3F691}.Debug|Any CPU.Build.0 = Debug|Any CPU {6045DECE-8425-4EE2-8685-7F2F21A3F691}.Release|Any CPU.ActiveCfg = Release|Any CPU {6045DECE-8425-4EE2-8685-7F2F21A3F691}.Release|Any CPU.Build.0 = Release|Any CPU - {B5544BD7-96BD-47E8-A27A-F18D42B44D7B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {B5544BD7-96BD-47E8-A27A-F18D42B44D7B}.Debug|Any CPU.Build.0 = Debug|Any CPU - {B5544BD7-96BD-47E8-A27A-F18D42B44D7B}.Release|Any CPU.ActiveCfg = Release|Any CPU - {B5544BD7-96BD-47E8-A27A-F18D42B44D7B}.Release|Any CPU.Build.0 = Release|Any CPU + {AD2FCB62-A8E0-4149-83B8-5FB8B542AB01}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {AD2FCB62-A8E0-4149-83B8-5FB8B542AB01}.Debug|Any CPU.Build.0 = Debug|Any CPU + {AD2FCB62-A8E0-4149-83B8-5FB8B542AB01}.Release|Any CPU.ActiveCfg = Release|Any CPU + {AD2FCB62-A8E0-4149-83B8-5FB8B542AB01}.Release|Any CPU.Build.0 = Release|Any CPU {2D7FD180-D8EE-48B5-B71D-1AE8DEAB1F37}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {2D7FD180-D8EE-48B5-B71D-1AE8DEAB1F37}.Debug|Any CPU.Build.0 = Debug|Any CPU {2D7FD180-D8EE-48B5-B71D-1AE8DEAB1F37}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -179,7 +179,7 @@ Global {391A8D1B-A44C-44C3-AFCF-045EE81FDFD2} = {A5940D03-8A5D-494C-B87F-4B9AAB6B21AE} {6045DECE-8425-4EE2-8685-7F2F21A3F691} = {A408DA52-13DD-4288-A88F-858DA05D936B} {209F90AA-5CA1-4DFA-8641-05A0AA4FDC8E} = {A408DA52-13DD-4288-A88F-858DA05D936B} - {B5544BD7-96BD-47E8-A27A-F18D42B44D7B} = {BD161CEF-9B1C-45C0-B541-E4BA194BFCEC} + {AD2FCB62-A8E0-4149-83B8-5FB8B542AB01} = {BD161CEF-9B1C-45C0-B541-E4BA194BFCEC} {2D7FD180-D8EE-48B5-B71D-1AE8DEAB1F37} = {BD161CEF-9B1C-45C0-B541-E4BA194BFCEC} {DBE877DF-486A-417B-9A4A-F25156621203} = {BD161CEF-9B1C-45C0-B541-E4BA194BFCEC} {3FBD947C-3755-4DFE-A1E8-76617C11FE78} = {5F8E719B-9F8B-4797-B30D-91D55B7DF40E} diff --git a/src/libraries/System.Runtime.Serialization.Json/tests/DataContractJsonSerializer.cs b/src/libraries/System.Runtime.Serialization.Json/tests/DataContractJsonSerializer.cs index effd1426556..94cc7459d0b 100644 --- a/src/libraries/System.Runtime.Serialization.Json/tests/DataContractJsonSerializer.cs +++ b/src/libraries/System.Runtime.Serialization.Json/tests/DataContractJsonSerializer.cs @@ -1669,18 +1669,18 @@ public static void DCJS_GenericTypeWithNestedGenerics() } [Fact] - public static void DCJS_ClassImplementingIXmlSerialiable() + public static void DCJS_ClassImplementingIXmlSerializable() { - ClassImplementingIXmlSerialiable value = new ClassImplementingIXmlSerialiable() { StringValue = "Foo" }; - var deserializedValue = SerializeAndDeserialize(value, @""""""); + ClassImplementingIXmlSerializable value = new ClassImplementingIXmlSerializable() { StringValue = "Foo" }; + var deserializedValue = SerializeAndDeserialize(value, @""""""); Assert.Equal(value.StringValue, deserializedValue.StringValue); } [Fact] - public static void DCJS_TypeWithNestedGenericClassImplementingIXmlSerialiable() + public static void DCJS_TypeWithNestedGenericClassImplementingIXmlSerializable() { - TypeWithNestedGenericClassImplementingIXmlSerialiable.NestedGenericClassImplementingIXmlSerialiable value = new TypeWithNestedGenericClassImplementingIXmlSerialiable.NestedGenericClassImplementingIXmlSerialiable() { StringValue = "Foo" }; - var deserializedValue = SerializeAndDeserialize>(value, @""""""); + TypeWithNestedGenericClassImplementingIXmlSerializable.NestedGenericClassImplementingIXmlSerializable value = new TypeWithNestedGenericClassImplementingIXmlSerializable.NestedGenericClassImplementingIXmlSerializable() { StringValue = "Foo" }; + var deserializedValue = SerializeAndDeserialize>(value, @""""""); Assert.Equal(value.StringValue, deserializedValue.StringValue); } diff --git a/src/libraries/System.Runtime.Serialization.Primitives/System.Runtime.Serialization.Primitives.sln b/src/libraries/System.Runtime.Serialization.Primitives/System.Runtime.Serialization.Primitives.sln index 82ad0645998..e766e1c6001 100644 --- a/src/libraries/System.Runtime.Serialization.Primitives/System.Runtime.Serialization.Primitives.sln +++ b/src/libraries/System.Runtime.Serialization.Primitives/System.Runtime.Serialization.Primitives.sln @@ -1,7 +1,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{5E9F435A-B4F6-4B3F-988B-80653A10F54D}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{7E3BBEEE-453F-4EE6-B09C-7AE2D2699CFF}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{C1ADD1E8-2791-4868-BCA2-C33C220E713A}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{1DD06D77-CFC0-478B-A415-54A45ED3E9B9}" EndProject @@ -49,10 +49,10 @@ Global {5E9F435A-B4F6-4B3F-988B-80653A10F54D}.Debug|Any CPU.Build.0 = Debug|Any CPU {5E9F435A-B4F6-4B3F-988B-80653A10F54D}.Release|Any CPU.ActiveCfg = Release|Any CPU {5E9F435A-B4F6-4B3F-988B-80653A10F54D}.Release|Any CPU.Build.0 = Release|Any CPU - {7E3BBEEE-453F-4EE6-B09C-7AE2D2699CFF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {7E3BBEEE-453F-4EE6-B09C-7AE2D2699CFF}.Debug|Any CPU.Build.0 = Debug|Any CPU - {7E3BBEEE-453F-4EE6-B09C-7AE2D2699CFF}.Release|Any CPU.ActiveCfg = Release|Any CPU - {7E3BBEEE-453F-4EE6-B09C-7AE2D2699CFF}.Release|Any CPU.Build.0 = Release|Any CPU + {C1ADD1E8-2791-4868-BCA2-C33C220E713A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {C1ADD1E8-2791-4868-BCA2-C33C220E713A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C1ADD1E8-2791-4868-BCA2-C33C220E713A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {C1ADD1E8-2791-4868-BCA2-C33C220E713A}.Release|Any CPU.Build.0 = Release|Any CPU {1DD06D77-CFC0-478B-A415-54A45ED3E9B9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {1DD06D77-CFC0-478B-A415-54A45ED3E9B9}.Debug|Any CPU.Build.0 = Debug|Any CPU {1DD06D77-CFC0-478B-A415-54A45ED3E9B9}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -100,7 +100,7 @@ Global GlobalSection(NestedProjects) = preSolution {5E9F435A-B4F6-4B3F-988B-80653A10F54D} = {8197F6DC-718C-4F71-9F13-771B1C1058E1} {AB51C1E2-6308-4989-B037-5712B6503C77} = {8197F6DC-718C-4F71-9F13-771B1C1058E1} - {7E3BBEEE-453F-4EE6-B09C-7AE2D2699CFF} = {A1607D7B-AA96-4EAD-99F7-9CA09E472C56} + {C1ADD1E8-2791-4868-BCA2-C33C220E713A} = {A1607D7B-AA96-4EAD-99F7-9CA09E472C56} {1DD06D77-CFC0-478B-A415-54A45ED3E9B9} = {A1607D7B-AA96-4EAD-99F7-9CA09E472C56} {9F0F182E-71C9-4CB5-8E5E-94AFEE489B1D} = {E8F4D65F-BB03-4954-AB19-C85DEC5E286C} {2D875658-E9BD-42DE-98E2-C8C6F1D914B3} = {E8F4D65F-BB03-4954-AB19-C85DEC5E286C} diff --git a/src/libraries/System.Runtime.Serialization.Primitives/tests/System.Runtime.Serialization.Primitives.Tests.csproj b/src/libraries/System.Runtime.Serialization.Primitives/tests/System.Runtime.Serialization.Primitives.Tests.csproj index aa5368bbad5..bef1cc634e6 100644 --- a/src/libraries/System.Runtime.Serialization.Primitives/tests/System.Runtime.Serialization.Primitives.Tests.csproj +++ b/src/libraries/System.Runtime.Serialization.Primitives/tests/System.Runtime.Serialization.Primitives.Tests.csproj @@ -11,5 +11,10 @@ + + + \ No newline at end of file diff --git a/src/libraries/System.Runtime.Serialization.Schema/Directory.Build.props b/src/libraries/System.Runtime.Serialization.Schema/Directory.Build.props index e7d357018da..7d407028f66 100644 --- a/src/libraries/System.Runtime.Serialization.Schema/Directory.Build.props +++ b/src/libraries/System.Runtime.Serialization.Schema/Directory.Build.props @@ -4,6 +4,6 @@ Microsoft true - browser;ios;tvos;maccatalyst + browser;wasi;ios;tvos;maccatalyst diff --git a/src/libraries/System.Runtime.Serialization.Schema/System.Runtime.Serialization.Schema.sln b/src/libraries/System.Runtime.Serialization.Schema/System.Runtime.Serialization.Schema.sln index 9774aceb3c6..deadb944e0c 100644 --- a/src/libraries/System.Runtime.Serialization.Schema/System.Runtime.Serialization.Schema.sln +++ b/src/libraries/System.Runtime.Serialization.Schema/System.Runtime.Serialization.Schema.sln @@ -5,7 +5,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.CodeDom", "..\System EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.CodeDom", "..\System.CodeDom\src\System.CodeDom.csproj", "{D9B2FAA2-5A60-4650-B40F-780BC25CB603}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{222716D5-754B-4C1D-A5F9-1BD0692E843C}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{D645AF8A-3EC9-405F-9862-2AEB6595498F}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{F73066DB-FD20-4C3B-B837-0FB18BDBF0B5}" EndProject @@ -59,10 +59,10 @@ Global {D9B2FAA2-5A60-4650-B40F-780BC25CB603}.Debug|Any CPU.Build.0 = Debug|Any CPU {D9B2FAA2-5A60-4650-B40F-780BC25CB603}.Release|Any CPU.ActiveCfg = Release|Any CPU {D9B2FAA2-5A60-4650-B40F-780BC25CB603}.Release|Any CPU.Build.0 = Release|Any CPU - {222716D5-754B-4C1D-A5F9-1BD0692E843C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {222716D5-754B-4C1D-A5F9-1BD0692E843C}.Debug|Any CPU.Build.0 = Debug|Any CPU - {222716D5-754B-4C1D-A5F9-1BD0692E843C}.Release|Any CPU.ActiveCfg = Release|Any CPU - {222716D5-754B-4C1D-A5F9-1BD0692E843C}.Release|Any CPU.Build.0 = Release|Any CPU + {D645AF8A-3EC9-405F-9862-2AEB6595498F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D645AF8A-3EC9-405F-9862-2AEB6595498F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D645AF8A-3EC9-405F-9862-2AEB6595498F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D645AF8A-3EC9-405F-9862-2AEB6595498F}.Release|Any CPU.Build.0 = Release|Any CPU {F73066DB-FD20-4C3B-B837-0FB18BDBF0B5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {F73066DB-FD20-4C3B-B837-0FB18BDBF0B5}.Debug|Any CPU.Build.0 = Debug|Any CPU {F73066DB-FD20-4C3B-B837-0FB18BDBF0B5}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -110,7 +110,7 @@ Global {74AE27CF-E940-4EEB-9A19-0968689B627E} = {54321C0F-1323-4962-A01C-AC07028C3FA8} {D9B2FAA2-5A60-4650-B40F-780BC25CB603} = {6591788E-0894-4655-AE2F-602407C4F766} {14D5A803-D5BF-44E5-B2B5-0B0BC297748E} = {6591788E-0894-4655-AE2F-602407C4F766} - {222716D5-754B-4C1D-A5F9-1BD0692E843C} = {366E690D-4016-43C9-9E9C-1B989A1E78A2} + {D645AF8A-3EC9-405F-9862-2AEB6595498F} = {366E690D-4016-43C9-9E9C-1B989A1E78A2} {F73066DB-FD20-4C3B-B837-0FB18BDBF0B5} = {366E690D-4016-43C9-9E9C-1B989A1E78A2} {7D895D9D-87EE-4ACE-B1EE-4F67036EA750} = {E12A010F-9B8A-4446-BCF1-9359EFA1F626} {3089FA98-1357-400A-94C2-40CC3D6603AD} = {E12A010F-9B8A-4446-BCF1-9359EFA1F626} diff --git a/src/libraries/System.Runtime.Serialization.Schema/src/System/Runtime/Serialization/Schema/XsdDataContractImporter.cs b/src/libraries/System.Runtime.Serialization.Schema/src/System/Runtime/Serialization/Schema/XsdDataContractImporter.cs index d589f99a8ec..5e9eba22fbf 100644 --- a/src/libraries/System.Runtime.Serialization.Schema/src/System/Runtime/Serialization/Schema/XsdDataContractImporter.cs +++ b/src/libraries/System.Runtime.Serialization.Schema/src/System/Runtime/Serialization/Schema/XsdDataContractImporter.cs @@ -88,7 +88,7 @@ public void Import(XmlSchemaSet schemas) /// Transforms the specified set of schema types contained in an into CLR types generated into a . /// /// A that contains the schema representations. - /// A (of ) that represents the set of schema types to import. + /// The set of schema types to import. [RequiresUnreferencedCode(ImportGlobals.SerializerTrimmerWarning)] public void Import(XmlSchemaSet schemas, ICollection typeNames) { @@ -145,7 +145,7 @@ public void Import(XmlSchemaSet schemas, XmlQualifiedName typeName) /// Gets a value that indicates whether the schemas contained in an can be transformed into a . /// /// A that contains the schemas to transform. - /// true if the schemas can be transformed to data contract types; otherwise, false. + /// if the schemas can be transformed to data contract types; otherwise, . [RequiresUnreferencedCode(ImportGlobals.SerializerTrimmerWarning)] public bool CanImport(XmlSchemaSet schemas) { @@ -158,9 +158,9 @@ public bool CanImport(XmlSchemaSet schemas) /// /// Gets a value that indicates whether the specified set of types contained in an can be transformed into CLR types generated into a . /// - /// A that contains the schemas to transform. - /// An of that represents the set of schema types to import. - /// true if the schemas can be transformed; otherwise, false. + /// The schemas to transform. + /// The set of schema types to import. + /// if the schemas can be transformed; otherwise, . [RequiresUnreferencedCode(ImportGlobals.SerializerTrimmerWarning)] public bool CanImport(XmlSchemaSet schemas, ICollection typeNames) { @@ -176,9 +176,9 @@ public bool CanImport(XmlSchemaSet schemas, ICollection typeNa /// /// Gets a value that indicates whether the schemas contained in an can be transformed into a . /// - /// A that contains the schema representations. - /// An that specifies the names of the schema types that need to be imported from the . - /// true if the schemas can be transformed to data contract types; otherwise, false. + /// The schema representations. + /// The names of the schema types that need to be imported from the . + /// if the schemas can be transformed to data contract types; otherwise, . [RequiresUnreferencedCode(ImportGlobals.SerializerTrimmerWarning)] public bool CanImport(XmlSchemaSet schemas, XmlQualifiedName typeName) { @@ -196,7 +196,7 @@ public bool CanImport(XmlSchemaSet schemas, XmlQualifiedName typeName) /// /// An to import. /// A specific to check in the set of schemas. - /// true if the element can be imported; otherwise, false. + /// if the element can be imported; otherwise, . [RequiresUnreferencedCode(ImportGlobals.SerializerTrimmerWarning)] public bool CanImport(XmlSchemaSet schemas, XmlSchemaElement element) { diff --git a/src/libraries/System.Runtime.Serialization.Schema/tests/System/Runtime/Serialization/Schema/Import/ImportOptionsTests.cs b/src/libraries/System.Runtime.Serialization.Schema/tests/System/Runtime/Serialization/Schema/Import/ImportOptionsTests.cs index 49867cc07ba..81a6b50bd68 100644 --- a/src/libraries/System.Runtime.Serialization.Schema/tests/System/Runtime/Serialization/Schema/Import/ImportOptionsTests.cs +++ b/src/libraries/System.Runtime.Serialization.Schema/tests/System/Runtime/Serialization/Schema/Import/ImportOptionsTests.cs @@ -24,7 +24,7 @@ public ImportOptionsTests(ITestOutputHelper output) [Fact] public void DefaultOptions() { - XsdDataContractImporter importer = SchemaUtils.CreateImporterWithDefaultOptions(); + XsdDataContractImporter importer = SchemaUtils.CreateImporterWithOptions(); Assert.NotNull(importer); Assert.NotNull(importer.Options); Assert.False(importer.Options.EnableDataBinding); @@ -61,7 +61,7 @@ public void SetImportOptions() [Fact] public void GenerateInternal() { - XsdDataContractImporter importer = SchemaUtils.CreateImporterWithDefaultOptions(); + XsdDataContractImporter importer = SchemaUtils.CreateImporterWithOptions(); importer.Options.GenerateInternal = true; importer.Import(SchemaUtils.PositiveSchemas, SchemaUtils.ValidTypeNames[0]); _output.WriteLine(SchemaUtils.DumpCode(importer.CodeCompileUnit)); @@ -71,7 +71,7 @@ public void GenerateInternal() [Fact] public void EnableDataBinding() { - XsdDataContractImporter importer = SchemaUtils.CreateImporterWithDefaultOptions(); + XsdDataContractImporter importer = SchemaUtils.CreateImporterWithOptions(); importer.Options.EnableDataBinding = true; importer.Import(SchemaUtils.PositiveSchemas, SchemaUtils.ValidTypeNames[0]); _output.WriteLine(SchemaUtils.DumpCode(importer.CodeCompileUnit)); @@ -81,7 +81,7 @@ public void EnableDataBinding() [Fact] public void GenerateSerializable() { - XsdDataContractImporter importer = SchemaUtils.CreateImporterWithDefaultOptions(); + XsdDataContractImporter importer = SchemaUtils.CreateImporterWithOptions(); importer.Options.GenerateSerializable = true; importer.Import(SchemaUtils.PositiveSchemas, SchemaUtils.ValidTypeNames[0]); _output.WriteLine(SchemaUtils.DumpCode(importer.CodeCompileUnit)); @@ -91,7 +91,7 @@ public void GenerateSerializable() [Fact] public void ImportXmlType() { - XsdDataContractImporter importer = SchemaUtils.CreateImporterWithDefaultOptions(); + XsdDataContractImporter importer = SchemaUtils.CreateImporterWithOptions(); importer.Options.ImportXmlType = true; importer.Import(SchemaUtils.PositiveSchemas, SchemaUtils.ValidTypeNames[0]); _output.WriteLine(SchemaUtils.DumpCode(importer.CodeCompileUnit)); @@ -101,7 +101,7 @@ public void ImportXmlType() [Fact] public void CodeProvider() { - XsdDataContractImporter importer = SchemaUtils.CreateImporterWithDefaultOptions(); + XsdDataContractImporter importer = SchemaUtils.CreateImporterWithOptions(); CodeDomProvider codeProvider = CodeDomProvider.CreateProvider("csharp"); importer.Options.CodeProvider = codeProvider; Console.WriteLine(importer.Options.CodeProvider.GetType().FullName); @@ -116,7 +116,7 @@ public void CodeProvider() [InlineData("null", "customizedNamespace")] public void Namespaces(string dcns, string clrns) { - XsdDataContractImporter importer = SchemaUtils.CreateImporterWithDefaultOptions(); + XsdDataContractImporter importer = SchemaUtils.CreateImporterWithOptions(); Assert.NotNull(importer.Options.Namespaces); Assert.Empty(importer.Options.Namespaces); @@ -129,7 +129,7 @@ public void Namespaces(string dcns, string clrns) [MemberData(nameof(ReferencedTypes_MemberData))] public void ReferencedTypes(XmlSchemaSet schemas, XmlQualifiedName qname, Type[] referencedTypes, Type expectedExceptionType = null, string msg = null) { - XsdDataContractImporter importer = SchemaUtils.CreateImporterWithDefaultOptions(); + XsdDataContractImporter importer = SchemaUtils.CreateImporterWithOptions(); for (int i = 0; i < referencedTypes.Length; i++) importer.Options.ReferencedTypes.Add(referencedTypes[i]); @@ -153,8 +153,8 @@ public static IEnumerable ReferencedTypes_MemberData() yield return new object[] { SchemaUtils.PositiveSchemas, SchemaUtils.ValidTypeNames[1], new Type[] { typeof(AnotherValidType), typeof(ConflictingAnotherValidType) }, typeof(InvalidOperationException), @"List of referenced types contains more than one type with data contract name 'AnotherValidType' in namespace 'http://schemas.datacontract.org/2004/07/barNs'. Need to exclude all but one of the following types. Only matching types can be valid references:"}; // These last two are described as "negative" in the original NetFx XsdDCImporterApi test code... but they don't fail here or there. - yield return new object[] { SchemaUtils.IsReferenceSchemas, SchemaUtils.ValidTypeNames[3], new Type[] { typeof(NonRefType) } }; - yield return new object[] { SchemaUtils.IsReferenceSchemas, SchemaUtils.ValidTypeNames[4], new Type[] { typeof(RefType1) } }; + yield return new object[] { SchemaUtils.ReferenceSchemas, SchemaUtils.ValidTypeNames[3], new Type[] { typeof(NonRefType) } }; + yield return new object[] { SchemaUtils.ReferenceSchemas, SchemaUtils.ValidTypeNames[4], new Type[] { typeof(RefType1) } }; } } } diff --git a/src/libraries/System.Runtime.Serialization.Schema/tests/System/Runtime/Serialization/Schema/Import/ImporterTests.cs b/src/libraries/System.Runtime.Serialization.Schema/tests/System/Runtime/Serialization/Schema/Import/ImporterTests.cs index 79d9c1f6507..158ee8dee8b 100644 --- a/src/libraries/System.Runtime.Serialization.Schema/tests/System/Runtime/Serialization/Schema/Import/ImporterTests.cs +++ b/src/libraries/System.Runtime.Serialization.Schema/tests/System/Runtime/Serialization/Schema/Import/ImporterTests.cs @@ -45,7 +45,7 @@ public void Ctor_CCU() [MemberData(nameof(CanImport_MemberData))] public void CanImport(bool expectedResult, Func canImport, Type expectedExceptionType = null, string msg = null) { - XsdDataContractImporter importer = SchemaUtils.CreateImporterWithDefaultOptions(); + XsdDataContractImporter importer = SchemaUtils.CreateImporterWithOptions(); if (expectedExceptionType == null) { Assert.Equal(expectedResult, canImport(importer)); @@ -100,7 +100,7 @@ public static IEnumerable CanImport_MemberData() [MemberData(nameof(Import_MemberData))] public void Import(Action import, int codeLength = -1) { - XsdDataContractImporter importer = SchemaUtils.CreateImporterWithDefaultOptions(); + XsdDataContractImporter importer = SchemaUtils.CreateImporterWithOptions(); import(importer); string code = SchemaUtils.DumpCode(importer.CodeCompileUnit); _output.WriteLine(code); @@ -112,13 +112,20 @@ public static IEnumerable Import_MemberData() int newlineSize = Environment.NewLine.Length; // Import(XmlSchemaSet) - yield return new object[] { (XsdDataContractImporter imp) => imp.Import(SchemaUtils.PositiveSchemas), 5060 + (168 * newlineSize) }; // 168 lines + yield return new object[] { (XsdDataContractImporter imp) => imp.Import(SchemaUtils.PositiveSchemas), 5060 + (168 * newlineSize) }; // 168 lines + yield return new object[] { (XsdDataContractImporter imp) => imp.Import(SchemaUtils.ReferenceSchemas), 2059 + (56 * newlineSize) }; // 56 lines + yield return new object[] { (XsdDataContractImporter imp) => { imp.Options.ImportXmlType = true; imp.Import(SchemaUtils.XmlTypeSchemas); }, 2127 + (58 * newlineSize) }; // 58 lines // Import(XmlSchemaSet, ICollection) - yield return new object[] { (XsdDataContractImporter imp) => imp.Import(SchemaUtils.PositiveSchemas, new XmlQualifiedName[] { SchemaUtils.ValidTypeNames[0] }), 1515 + (50 * newlineSize) }; // 50 lines + yield return new object[] { (XsdDataContractImporter imp) => imp.Import(SchemaUtils.AllPositiveSchemas, SchemaUtils.ValidTypeNames), 6770 + (215 * newlineSize) }; // 215 lines + yield return new object[] { (XsdDataContractImporter imp) => { imp.Options.ImportXmlType = true; imp.Import(SchemaUtils.XmlTypeSchemas, SchemaUtils.XmlTypeNames); }, 2127 + (58 * newlineSize) }; // 58 lines // Import(XmlSchemaSet, XmlQualifiedName) yield return new object[] { (XsdDataContractImporter imp) => imp.Import(SchemaUtils.PositiveSchemas, SchemaUtils.ValidTypeNames[0]), 1515 + (50 * newlineSize) }; // 50 lines + yield return new object[] { (XsdDataContractImporter imp) => imp.Import(SchemaUtils.PositiveSchemas, SchemaUtils.ValidTypeNames[1]), 1514 + (50 * newlineSize) }; // 50 lines + yield return new object[] { (XsdDataContractImporter imp) => imp.Import(SchemaUtils.PositiveSchemas, SchemaUtils.ValidTypeNames[2]), 2729 + (86 * newlineSize) }; // 86 lines + yield return new object[] { (XsdDataContractImporter imp) => imp.Import(SchemaUtils.ReferenceSchemas, SchemaUtils.ValidTypeNames[3]), 1260 + (35 * newlineSize) }; // 35 lines + yield return new object[] { (XsdDataContractImporter imp) => imp.Import(SchemaUtils.ReferenceSchemas, SchemaUtils.ValidTypeNames[4]), 1238 + (35 * newlineSize) }; // 35 lines // Import(XmlSchemaSet, XmlSchemaElement) // TODO @@ -191,7 +198,7 @@ public static IEnumerable Import_MemberData() [MemberData(nameof(Import_NegativeCases_MemberData))] public void Import_NegativeCases(Action import, Type expectedExceptionType, string msg = null) { - XsdDataContractImporter importer = SchemaUtils.CreateImporterWithDefaultOptions(); + XsdDataContractImporter importer = SchemaUtils.CreateImporterWithOptions(); var ex = Assert.Throws(expectedExceptionType, () => import(importer)); if (!string.IsNullOrEmpty(msg)) @@ -335,7 +342,7 @@ public class SerializableFormatClass [MemberData(nameof(GetCodeTypeReference_MemberData))] public void GetCodeTypeReference(XmlSchemaSet schemas, XmlQualifiedName qname, string exptectedType, Type expectedExceptionType = null, string msg = null) { - XsdDataContractImporter importer = SchemaUtils.CreateImporterWithDefaultOptions(); + XsdDataContractImporter importer = SchemaUtils.CreateImporterWithOptions(); if (schemas != null) importer.Import(schemas); @@ -375,7 +382,7 @@ public static IEnumerable GetCodeTypeReference_MemberData() [MemberData(nameof(GetKnownTypeReferences_MemberData))] public void GetKnownTypeReferences(XmlSchemaSet schemas, XmlQualifiedName qname, int expectedRefCount, Type expectedExceptionType = null, string msg = null) { - XsdDataContractImporter importer = SchemaUtils.CreateImporterWithDefaultOptions(); + XsdDataContractImporter importer = SchemaUtils.CreateImporterWithOptions(); if (schemas != null) importer.Import(schemas); diff --git a/src/libraries/System.Runtime.Serialization.Schema/tests/System/Runtime/Serialization/Schema/RoundTripTest.cs b/src/libraries/System.Runtime.Serialization.Schema/tests/System/Runtime/Serialization/Schema/RoundTripTest.cs index 9b23c73d43e..8e26f7a0704 100644 --- a/src/libraries/System.Runtime.Serialization.Schema/tests/System/Runtime/Serialization/Schema/RoundTripTest.cs +++ b/src/libraries/System.Runtime.Serialization.Schema/tests/System/Runtime/Serialization/Schema/RoundTripTest.cs @@ -5,6 +5,8 @@ using System.Data; using System.Runtime.Serialization.Schema; using System.Xml; +using System.Xml.Schema; +using System.Xml.Serialization; using Xunit; using Xunit.Abstractions; @@ -78,6 +80,26 @@ public void RountTripTest() } } + [Fact] + [ActiveIssue("https://github.com/dotnet/runtime/issues/73961", typeof(PlatformDetection), nameof(PlatformDetection.IsBuiltWithAggressiveTrimming), nameof(PlatformDetection.IsBrowser))] + [ActiveIssue("https://github.com/dotnet/runtime/issues/95981", typeof(PlatformDetection), nameof(PlatformDetection.IsHybridGlobalizationOnBrowser))] + public void RoundTripXmlSerializableWithSpecialAttributesTest() + { + XsdDataContractExporter exporter = new XsdDataContractExporter(); + exporter.Export(typeof(SerializableWithSpecialAttributes)); + string schemas = SchemaUtils.DumpSchema(exporter.Schemas); + + XsdDataContractImporter importer = new XsdDataContractImporter(); + importer.Options = new ImportOptions(); + importer.Options.ImportXmlType = true; + importer.Options.ReferencedTypes.Add(typeof(DBNull)); + importer.Options.ReferencedTypes.Add(typeof(DateTimeOffset)); + importer.Import(exporter.Schemas); + + string code = SchemaUtils.DumpCode(importer.CodeCompileUnit); + _output.WriteLine(code); + } + [Fact] public void IsReferenceType() { @@ -346,6 +368,69 @@ public RefCircularNodeB_ContainsRefWithBackpointer(RefCircularNodeA_ContainsRefW } } #endregion + + #region RoundTripXmlSerializableWithSpecialAttributesTest Classes + public class SerializableWithSpecialAttributes : IXmlSerializable + { + const string nestedAttributeName = "nestedAsAttributeString"; + + // Special nested class definition + [Serializable] + public class NestedClass + { + [XmlAttribute(AttributeName = nestedAttributeName)] + public string AttributeString { get; set; } + } + + // Property of type NestedClass + public NestedClass MySpecialProperty { get; set; } + + // IXmlSerializable methods + public XmlSchema GetSchema() + { + // Create an XmlSchema instance + var schema = new XmlSchema() { Id = "SerializableWithSpecialAttributesTest" }; + + // Define the target namespace (if needed) + schema.TargetNamespace = "http://example.com/my-test-namespace"; + + // Define complex type for OuterClass + var outerClassType = new XmlSchemaComplexType() { Name = "SerializableWithSpecialAttributes" }; + schema.Items.Add(outerClassType); + + // Define attribute for MySpecialProperty + var attribute = new XmlSchemaAttribute + { + Name = nestedAttributeName, + SchemaTypeName = new XmlQualifiedName("string", XmlSchema.Namespace) + }; + outerClassType.Attributes.Add(attribute); + + return schema; + } + + public void WriteXml(XmlWriter writer) + { + // Serialize MyNestedProperty as an attribute + if (MySpecialProperty != null) + { + writer.WriteAttributeString(nestedAttributeName, MySpecialProperty.AttributeString); + } + } + + public void ReadXml(XmlReader reader) + { + // Deserialize MyNestedProperty from an attribute + if (reader.MoveToAttribute(nestedAttributeName)) + { + MySpecialProperty = new NestedClass + { + AttributeString = reader.Value + }; + } + } + } + #endregion #pragma warning restore CS0169, CS0414, IDE0051, IDE1006 } } diff --git a/src/libraries/System.Runtime.Serialization.Schema/tests/System/Runtime/Serialization/Schema/SchemaUtils.cs b/src/libraries/System.Runtime.Serialization.Schema/tests/System/Runtime/Serialization/Schema/SchemaUtils.cs index d0a4eda2369..ad177d29da2 100644 --- a/src/libraries/System.Runtime.Serialization.Schema/tests/System/Runtime/Serialization/Schema/SchemaUtils.cs +++ b/src/libraries/System.Runtime.Serialization.Schema/tests/System/Runtime/Serialization/Schema/SchemaUtils.cs @@ -4,13 +4,16 @@ using System.CodeDom; using System.CodeDom.Compiler; using System.IO; +using System.Text; using System.Xml; using System.Xml.Schema; namespace System.Runtime.Serialization.Schema.Tests { - internal class SchemaUtils + internal static class SchemaUtils { + internal static string SerializationNamespace = "http://schemas.microsoft.com/2003/10/Serialization/"; + static XmlWriterSettings writerSettings = new XmlWriterSettings() { Indent = true }; #region Test Data @@ -31,8 +34,9 @@ internal class SchemaUtils ", }; internal static XmlSchemaSet PositiveSchemas => ReadStringsIntoSchemaSet(_positiveSchemas); + internal static XmlSchemaSet AllPositiveSchemas => ReadStringsIntoSchemaSet(_positiveSchemas).AddStrings(_referenceSchemas); - private static string[] _isReferenceSchemas = new string[] { + private static string[] _referenceSchemas = new string[] { @" @@ -53,7 +57,7 @@ internal class SchemaUtils ", }; - internal static XmlSchemaSet IsReferenceSchemas => ReadStringsIntoSchemaSet(_isReferenceSchemas); + internal static XmlSchemaSet ReferenceSchemas => ReadStringsIntoSchemaSet(_referenceSchemas); private static string[] _mixedSchemas = new string[] { @" @@ -69,6 +73,13 @@ internal class SchemaUtils }; internal static XmlSchemaSet MixedSchemas => ReadStringsIntoSchemaSet(_mixedSchemas); + private static string[] _xmlTypeSchemas = new string[] { + @" + + ", + }; + internal static XmlSchemaSet XmlTypeSchemas => ReadStringsIntoSchemaSet(_xmlTypeSchemas); + internal static string[] NegativeSchemaStrings = new string[] { @"", // null @@ -192,6 +203,10 @@ internal class SchemaUtils new XmlQualifiedName("RefType1", "http://schemas.datacontract.org/2004/07/Suites.SchemaImport.ReferencedTypes"), }; + internal static XmlQualifiedName[] XmlTypeNames = new XmlQualifiedName[] { + new XmlQualifiedName("SerializableWithSpecialAttributes", "http://schemas.datacontract.org/2004/07/Suites.SchemaImport"), + }; + internal static XmlQualifiedName[] InvalidTypeNames = new XmlQualifiedName[] { new XmlQualifiedName("InvalidType", "http://schemas.datacontract.org/2004/07/fooNs"), }; @@ -222,10 +237,10 @@ internal class SchemaUtils #endregion - internal static XsdDataContractImporter CreateImporterWithDefaultOptions() + internal static XsdDataContractImporter CreateImporterWithOptions(ImportOptions opts = null) { XsdDataContractImporter importer = new XsdDataContractImporter(); - importer.Options = new ImportOptions(); + importer.Options = opts ?? new ImportOptions(); return importer; } @@ -244,6 +259,22 @@ internal static string DumpCode(CodeCompileUnit ccu, CodeDomProvider provider = return sw.ToString(); } + public static string DumpSchema(XmlSchemaSet schemas) + { + StringBuilder sb = new StringBuilder(); + StringWriter sw = new StringWriter(sb); + foreach (XmlSchema schema in schemas.Schemas()) + { + if (schema.TargetNamespace != SerializationNamespace) + { + schema.Write(sw); + } + sw.WriteLine(); + } + sw.Flush(); + return sb.ToString(); + } + internal static XmlSchema GetSchema(XmlSchemaSet schemaSet, string targetNs) { XmlSchema schema = null; @@ -356,6 +387,11 @@ internal static string InsertElement(string xml, string xpath, string xmlFrag, b internal static XmlSchemaSet ReadStringsIntoSchemaSet(params string[] schemaStrings) { XmlSchemaSet schemaSet = new XmlSchemaSet(); + return schemaSet.AddStrings(schemaStrings); + } + + internal static XmlSchemaSet AddStrings(this XmlSchemaSet schemaSet, params string[] schemaStrings) + { foreach (string schemaString in schemaStrings) { StringReader reader = new StringReader(schemaString); diff --git a/src/libraries/System.Runtime.Serialization.Xml/System.Runtime.Serialization.Xml.sln b/src/libraries/System.Runtime.Serialization.Xml/System.Runtime.Serialization.Xml.sln index e0f6bce9959..66d2dadc888 100644 --- a/src/libraries/System.Runtime.Serialization.Xml/System.Runtime.Serialization.Xml.sln +++ b/src/libraries/System.Runtime.Serialization.Xml/System.Runtime.Serialization.Xml.sln @@ -17,7 +17,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Net.Primitives", ".. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.DataContractSerialization", "..\System.Private.DataContractSerialization\src\System.Private.DataContractSerialization.csproj", "{76AC3DDD-2B38-489F-A8B0-8E43054595DB}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{7D7457FD-B88C-4375-926D-7D46C71E34A7}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{2FEBFB9C-C979-4CD0-B711-1A2C4C5112C4}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{D5FF2DBA-F304-4ACB-8F82-B8F9321E22A9}" EndProject @@ -109,10 +109,10 @@ Global {76AC3DDD-2B38-489F-A8B0-8E43054595DB}.Debug|Any CPU.Build.0 = Debug|Any CPU {76AC3DDD-2B38-489F-A8B0-8E43054595DB}.Release|Any CPU.ActiveCfg = Release|Any CPU {76AC3DDD-2B38-489F-A8B0-8E43054595DB}.Release|Any CPU.Build.0 = Release|Any CPU - {7D7457FD-B88C-4375-926D-7D46C71E34A7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {7D7457FD-B88C-4375-926D-7D46C71E34A7}.Debug|Any CPU.Build.0 = Debug|Any CPU - {7D7457FD-B88C-4375-926D-7D46C71E34A7}.Release|Any CPU.ActiveCfg = Release|Any CPU - {7D7457FD-B88C-4375-926D-7D46C71E34A7}.Release|Any CPU.Build.0 = Release|Any CPU + {2FEBFB9C-C979-4CD0-B711-1A2C4C5112C4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {2FEBFB9C-C979-4CD0-B711-1A2C4C5112C4}.Debug|Any CPU.Build.0 = Debug|Any CPU + {2FEBFB9C-C979-4CD0-B711-1A2C4C5112C4}.Release|Any CPU.ActiveCfg = Release|Any CPU + {2FEBFB9C-C979-4CD0-B711-1A2C4C5112C4}.Release|Any CPU.Build.0 = Release|Any CPU {D5FF2DBA-F304-4ACB-8F82-B8F9321E22A9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {D5FF2DBA-F304-4ACB-8F82-B8F9321E22A9}.Debug|Any CPU.Build.0 = Debug|Any CPU {D5FF2DBA-F304-4ACB-8F82-B8F9321E22A9}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -200,7 +200,7 @@ Global {1392041A-E2CA-4553-BEAF-363974651B81} = {DB29DBEF-FA4E-4334-AFB8-BFB2DA82D1DE} {76AC3DDD-2B38-489F-A8B0-8E43054595DB} = {DB29DBEF-FA4E-4334-AFB8-BFB2DA82D1DE} {6FD10BE0-24C8-456E-8B9A-FD101C05C961} = {DB29DBEF-FA4E-4334-AFB8-BFB2DA82D1DE} - {7D7457FD-B88C-4375-926D-7D46C71E34A7} = {DE71D38E-4154-477C-9C27-3FA4ADB4098F} + {2FEBFB9C-C979-4CD0-B711-1A2C4C5112C4} = {DE71D38E-4154-477C-9C27-3FA4ADB4098F} {D5FF2DBA-F304-4ACB-8F82-B8F9321E22A9} = {DE71D38E-4154-477C-9C27-3FA4ADB4098F} {6E942A4A-405E-4AAD-89A7-006358A8A004} = {DE71D38E-4154-477C-9C27-3FA4ADB4098F} {E2DF066F-C124-440F-999A-A71F71C7F34E} = {A980EC85-6DBA-4AA8-A2E9-8B596010795D} diff --git a/src/libraries/System.Runtime.Serialization.Xml/tests/DataContractSerializer.cs b/src/libraries/System.Runtime.Serialization.Xml/tests/DataContractSerializer.cs index bba5dc9c04a..e63c47b8207 100644 --- a/src/libraries/System.Runtime.Serialization.Xml/tests/DataContractSerializer.cs +++ b/src/libraries/System.Runtime.Serialization.Xml/tests/DataContractSerializer.cs @@ -1958,18 +1958,18 @@ public static void DCS_PocoDerivedTypeWithBaseTypeWithDataMember() } [Fact] - public static void DCS_ClassImplementingIXmlSerialiable() + public static void DCS_ClassImplementingIXmlSerializable() { - ClassImplementingIXmlSerialiable value = new ClassImplementingIXmlSerialiable() { StringValue = "Foo" }; - var deserializedValue = DataContractSerializerHelper.SerializeAndDeserialize(value, @""); + ClassImplementingIXmlSerializable value = new ClassImplementingIXmlSerializable() { StringValue = "Foo" }; + var deserializedValue = DataContractSerializerHelper.SerializeAndDeserialize(value, @""); Assert.Equal(value.StringValue, deserializedValue.StringValue); } [Fact] - public static void DCS_TypeWithNestedGenericClassImplementingIXmlSerialiable() + public static void DCS_TypeWithNestedGenericClassImplementingIXmlSerializable() { - TypeWithNestedGenericClassImplementingIXmlSerialiable.NestedGenericClassImplementingIXmlSerialiable value = new TypeWithNestedGenericClassImplementingIXmlSerialiable.NestedGenericClassImplementingIXmlSerialiable() { StringValue = "Foo" }; - var deserializedValue = DataContractSerializerHelper.SerializeAndDeserialize>(value, @""); + TypeWithNestedGenericClassImplementingIXmlSerializable.NestedGenericClassImplementingIXmlSerializable value = new TypeWithNestedGenericClassImplementingIXmlSerializable.NestedGenericClassImplementingIXmlSerializable() { StringValue = "Foo" }; + var deserializedValue = DataContractSerializerHelper.SerializeAndDeserialize>(value, @""); Assert.Equal(value.StringValue, deserializedValue.StringValue); } @@ -4477,8 +4477,11 @@ public static void DCS_TypeWithPrimitiveKnownTypes() Assert.NotNull(actual); } + // Random OSR might cause a stack overflow on Windows x64 + private static bool IsNotWindowsRandomOSR => !PlatformDetection.IsWindows || (Environment.GetEnvironmentVariable("DOTNET_JitRandomOnStackReplacement") == null); + [SkipOnPlatform(TestPlatforms.Browser, "Causes a stack overflow")] - [Fact] + [ConditionalFact(nameof(IsNotWindowsRandomOSR))] public static void DCS_DeeplyLinkedData() { TypeWithLinkedProperty head = new TypeWithLinkedProperty(); diff --git a/src/libraries/System.Runtime.Serialization.Xml/tests/SerializationTypes.RuntimeOnly.cs b/src/libraries/System.Runtime.Serialization.Xml/tests/SerializationTypes.RuntimeOnly.cs index a62636e16d9..bd3af77d917 100644 --- a/src/libraries/System.Runtime.Serialization.Xml/tests/SerializationTypes.RuntimeOnly.cs +++ b/src/libraries/System.Runtime.Serialization.Xml/tests/SerializationTypes.RuntimeOnly.cs @@ -1144,10 +1144,10 @@ public enum UShortEnum : ushort Option0, Option1, Option2 } - public class TypeWithNestedGenericClassImplementingIXmlSerialiable + public class TypeWithNestedGenericClassImplementingIXmlSerializable { // T can only be string - public class NestedGenericClassImplementingIXmlSerialiable : IXmlSerializable + public class NestedGenericClassImplementingIXmlSerializable : IXmlSerializable { public static bool WriteXmlInvoked = false; public static bool ReadXmlInvoked = false; @@ -1155,7 +1155,7 @@ public class NestedGenericClassImplementingIXmlSerialiable : IXmlSerializable public string StringValue { get; set; } private T GenericValue { get; set; } - public NestedGenericClassImplementingIXmlSerialiable() + public NestedGenericClassImplementingIXmlSerializable() { GenericValue = default(T); } diff --git a/src/libraries/System.Runtime.Serialization.Xml/tests/SerializationTypes.cs b/src/libraries/System.Runtime.Serialization.Xml/tests/SerializationTypes.cs index 8bd88af9bd7..5e0829fab60 100644 --- a/src/libraries/System.Runtime.Serialization.Xml/tests/SerializationTypes.cs +++ b/src/libraries/System.Runtime.Serialization.Xml/tests/SerializationTypes.cs @@ -7,7 +7,9 @@ using System.ComponentModel; using System.Globalization; using System.IO; +using System.Linq; using System.Reflection; +using System.Reflection.Metadata; using System.Runtime.CompilerServices; using System.Runtime.Serialization; using System.Runtime.Serialization.Json; @@ -616,7 +618,7 @@ public class SimpleKnownTypeValue public string StrProperty { get; set; } } - public class ClassImplementingIXmlSerialiable : IXmlSerializable + public class ClassImplementingIXmlSerializable : IXmlSerializable { public static bool WriteXmlInvoked = false; public static bool ReadXmlInvoked = false; @@ -624,7 +626,7 @@ public class ClassImplementingIXmlSerialiable : IXmlSerializable public string StringValue { get; set; } private bool BoolValue { get; set; } - public ClassImplementingIXmlSerialiable() + public ClassImplementingIXmlSerializable() { BoolValue = true; } @@ -694,7 +696,107 @@ public class TypeWithSchemaFormInXmlAttribute public string TestProperty; } + public class CustomDocument + { + private XmlDocument? _doc; + public XmlDocument Document => _doc ??= new XmlDocument(); + + [XmlAnyElement] + public XmlNode[] Items + { + get => _items.ToArray(); + set + { + _items = new List(); + foreach (var v in value) + { + _items.Add(MakeElement(v)); + } + } + } + private List _items = new List(); + + [XmlElement("customElement", typeof(CustomElement))] + public List CustomItems = new List(); + + + public void AddItem(XmlElement item) => _items.Add(item); + public void AddCustomItem(CustomElement item) => CustomItems.Add(item); + + public XmlAttribute CreateAttribute(string name, string value) + { + var attr = Document.CreateAttribute(name); + attr.Value = value; + return attr; + } + public CustomAttribute CreateCustomAttribute(string name, string value) + { + var attr = new CustomAttribute(null, name, null, Document); + attr.Value = value; + return attr; + } + + private XmlElement MakeElement(XmlNode node) + { + if (node is XmlElement element) + { + return element; + } + else + { + var element2 = Document.CreateElement(node.LocalName); + + if (node.Attributes != null) + foreach (XmlAttribute attr in node.Attributes) + element2.SetAttribute(attr.LocalName, attr.Value); + + if (node.ChildNodes != null) + foreach (XmlNode child in node.ChildNodes) + element2.AppendChild(MakeElement(child)); + element2.InnerText = node.Value; + return element2; + } + } + } + + public class CustomElement + { + List? _attributes = new List(); + List? _customAttributes = new List(); + + [XmlAttribute("name")] + public string Name; + + [XmlAnyAttribute] + public XmlAttribute[] Attributes + { + get => _attributes.ToArray(); + set => _attributes = value?.ToList(); + } + + [XmlAnyAttribute] + public XmlNode[] CustomAttributes + { + get => _customAttributes.ToArray(); + set + { + _customAttributes = new List(); + foreach (var v in value) + { + _customAttributes.Add(new CustomAttribute(v.Prefix, v.Name, v.NamespaceURI, v.OwnerDocument) { Value = v.Value }); + } + } + } + + public void AddAttribute(XmlAttribute attribute) => _attributes.Add(attribute); + public void AddAttribute(CustomAttribute attribute) => _customAttributes.Add(attribute); + } + + public class CustomAttribute : XmlAttribute + { + protected internal CustomAttribute(string? prefix, string localName, string? namespaceURI, XmlDocument doc) : base(prefix, localName, namespaceURI, doc) { } + } #endregion public class TypeWithNonPublicDefaultConstructor @@ -838,14 +940,18 @@ public enum MoreChoices public class TypeWithFieldsOrdered { - [XmlElement(Order = 0)] - public int IntField1; + // Specifying an 'Order' that matches the order of definition defeats the purpose. + // If the serializer ignores ordering altogether, it would still work by accident. + // Also, change the element names for two fields to be ambiguous without ordering, to + // further test that reading the correct fields in the correct order is happening. + [XmlElement(Order = 2, ElementName = "strfld")] + public string StringField2; [XmlElement(Order = 1)] + public int IntField1; + [XmlElement(Order = 0)] public int IntField2; - [XmlElement(Order = 3)] + [XmlElement(Order = 3, ElementName = "strfld")] public string StringField1; - [XmlElement(Order = 2)] - public string StringField2; } [KnownType(typeof(List))] @@ -1034,6 +1140,104 @@ public class DerivedClass : BaseClass public new string Value { get; set; } } +[XmlInclude(typeof(SimpleDerivedClass))] +public class SimpleBaseClass +{ + [XmlAttribute] + public string? AttributeString { get; set; } + [XmlAttribute] + public DateTime DateTimeValue { get; set; } +} + +public class SimpleDerivedClass : SimpleBaseClass +{ + [XmlAttribute] + public bool BoolValue { get; set; } +} + +[XmlSchemaProvider("GetMySchema")] +[XmlRoot(Namespace = XmlNamespace)] +public class XmlSerializableBaseClass : IXmlSerializable +{ + public const string XmlNamespace = "http://example.com/serializer-test-namespace"; + public const string BaseName = "BaseIXmlSerializable"; + public const string DerivedName = "DerivedIXmlSerializable"; + + public string? AttributeString { get; set; } + public DateTime DateTimeValue { get; set; } + + public virtual void WriteXml(XmlWriter writer) + { + writer.WriteAttributeString("AttributeString", AttributeString); + writer.WriteAttributeString("DateTimeValue", XmlConvert.ToString(DateTimeValue, XmlDateTimeSerializationMode.RoundtripKind)); + } + + public virtual void ReadXml(XmlReader reader) + { + if (reader.MoveToAttribute("AttributeString")) + AttributeString = reader.Value; + if (reader.MoveToAttribute("DateTimeValue")) + DateTimeValue = XmlConvert.ToDateTime(reader.Value, XmlDateTimeSerializationMode.RoundtripKind); + } + + public XmlSchema? GetSchema() => null; + public static XmlQualifiedName GetMySchema(XmlSchemaSet xs) => GetSchemaForType(xs, BaseName); + + protected static XmlQualifiedName GetSchemaForType(XmlSchemaSet xs, string xmlTypeName) + { + var schema = new XmlSchema() { Id = "DerivedIXmlSerializableSchema", TargetNamespace = XmlNamespace }; + + // Define type for base class + var baseType = new XmlSchemaComplexType() { Name = BaseName }; + baseType.Attributes.Add(new XmlSchemaAttribute { Name = "AttributeString", SchemaTypeName = new XmlQualifiedName("string", XmlSchema.Namespace) }); + baseType.Attributes.Add(new XmlSchemaAttribute { Name = "DateTimeValue", SchemaTypeName = new XmlQualifiedName("dateTime", XmlSchema.Namespace) }); + schema.Items.Add(baseType); + + // Define type for derived class + var derivedType = new XmlSchemaComplexType() { Name = DerivedName }; + var baseExtension = new XmlSchemaComplexContentExtension() { BaseTypeName = new XmlQualifiedName(BaseName, schema.TargetNamespace) }; + baseExtension.Attributes.Add(new XmlSchemaAttribute { Name = "BoolValue", SchemaTypeName = new XmlQualifiedName("string", XmlSchema.Namespace) }); + derivedType.ContentModel = new XmlSchemaComplexContent { Content = baseExtension }; + schema.Items.Add(derivedType); + + xs.Add(schema); + return new XmlQualifiedName(xmlTypeName, XmlNamespace); + } +} + +[XmlSchemaProvider("GetMySchema")] +public class XmlSerializableDerivedClass : XmlSerializableBaseClass +{ + public bool BoolValue { get; set; } + + public override void WriteXml(XmlWriter writer) + { + // I don't know why the serializer does this for regular serializable classes, but not for IXmlSerializable. + // We have to emit xsi:type manually to get derived deserialization to work. Unfortunately, we always have to + // emit this extra declaration, even if the derived class is the root element. + EnsureDefaultNamespaces(writer); + writer.WriteAttributeString("xsi", "type", null, DerivedName); + + base.WriteXml(writer); + writer.WriteAttributeString("BoolValue", BoolValue.ToString()); + } + + public override void ReadXml(XmlReader reader) + { + base.ReadXml(reader); + if (reader.MoveToAttribute("BoolValue")) + BoolValue = bool.Parse(reader.Value); + } + + public static void EnsureDefaultNamespaces(System.Xml.XmlWriter writer) + { + if (writer.LookupPrefix(System.Xml.Schema.XmlSchema.InstanceNamespace) == null) + writer.WriteAttributeString("xmlns", "xsi", null, System.Xml.Schema.XmlSchema.InstanceNamespace); + } + + public static new XmlQualifiedName GetMySchema(XmlSchemaSet xs) => GetSchemaForType(xs, DerivedName); +} + [XmlRootAttribute("PurchaseOrder", Namespace = "http://www.contoso1.com", IsNullable = false)] public class PurchaseOrder { diff --git a/src/libraries/System.Runtime/System.Runtime.sln b/src/libraries/System.Runtime/System.Runtime.sln index 1a948450a06..3bb4e42789f 100644 --- a/src/libraries/System.Runtime/System.Runtime.sln +++ b/src/libraries/System.Runtime/System.Runtime.sln @@ -57,6 +57,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Resources.Extensions EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{379BC6E6-1900-44F8-8D8C-AA2968A70008}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{CB93C0B2-D73B-4BDA-A03A-8A7D76012590}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{4FA4A9A6-1D38-414B-96F0-3CFB63C687C9}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{A7B7DE04-7261-4D4C-AA78-9F2D9B5A1C37}" @@ -944,6 +946,27 @@ Global {379BC6E6-1900-44F8-8D8C-AA2968A70008}.Checked|arm64.ActiveCfg = Debug|Any CPU {379BC6E6-1900-44F8-8D8C-AA2968A70008}.Checked|x64.ActiveCfg = Debug|Any CPU {379BC6E6-1900-44F8-8D8C-AA2968A70008}.Checked|x86.ActiveCfg = Debug|Any CPU + {CB93C0B2-D73B-4BDA-A03A-8A7D76012590}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {CB93C0B2-D73B-4BDA-A03A-8A7D76012590}.Debug|Any CPU.Build.0 = Debug|Any CPU + {CB93C0B2-D73B-4BDA-A03A-8A7D76012590}.Debug|arm.ActiveCfg = Debug|Any CPU + {CB93C0B2-D73B-4BDA-A03A-8A7D76012590}.Debug|arm64.ActiveCfg = Debug|Any CPU + {CB93C0B2-D73B-4BDA-A03A-8A7D76012590}.Debug|x64.ActiveCfg = Debug|Any CPU + {CB93C0B2-D73B-4BDA-A03A-8A7D76012590}.Debug|x64.Build.0 = Debug|Any CPU + {CB93C0B2-D73B-4BDA-A03A-8A7D76012590}.Debug|x86.ActiveCfg = Debug|Any CPU + {CB93C0B2-D73B-4BDA-A03A-8A7D76012590}.Debug|x86.Build.0 = Debug|Any CPU + {CB93C0B2-D73B-4BDA-A03A-8A7D76012590}.Release|Any CPU.ActiveCfg = Release|Any CPU + {CB93C0B2-D73B-4BDA-A03A-8A7D76012590}.Release|Any CPU.Build.0 = Release|Any CPU + {CB93C0B2-D73B-4BDA-A03A-8A7D76012590}.Release|arm.ActiveCfg = Release|Any CPU + {CB93C0B2-D73B-4BDA-A03A-8A7D76012590}.Release|arm64.ActiveCfg = Release|Any CPU + {CB93C0B2-D73B-4BDA-A03A-8A7D76012590}.Release|x64.ActiveCfg = Release|Any CPU + {CB93C0B2-D73B-4BDA-A03A-8A7D76012590}.Release|x64.Build.0 = Release|Any CPU + {CB93C0B2-D73B-4BDA-A03A-8A7D76012590}.Release|x86.ActiveCfg = Release|Any CPU + {CB93C0B2-D73B-4BDA-A03A-8A7D76012590}.Release|x86.Build.0 = Release|Any CPU + {CB93C0B2-D73B-4BDA-A03A-8A7D76012590}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {CB93C0B2-D73B-4BDA-A03A-8A7D76012590}.Checked|arm.ActiveCfg = Debug|Any CPU + {CB93C0B2-D73B-4BDA-A03A-8A7D76012590}.Checked|arm64.ActiveCfg = Debug|Any CPU + {CB93C0B2-D73B-4BDA-A03A-8A7D76012590}.Checked|x64.ActiveCfg = Debug|Any CPU + {CB93C0B2-D73B-4BDA-A03A-8A7D76012590}.Checked|x86.ActiveCfg = Debug|Any CPU {4FA4A9A6-1D38-414B-96F0-3CFB63C687C9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {4FA4A9A6-1D38-414B-96F0-3CFB63C687C9}.Debug|Any CPU.Build.0 = Debug|Any CPU {4FA4A9A6-1D38-414B-96F0-3CFB63C687C9}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -3020,6 +3043,7 @@ Global {82728202-1098-4E16-B598-5762EAF67D08} = {F65030D7-DDBD-4D4C-B6E3-D3C0DD7FD569} {CF79B5AE-38CB-4B80-BF92-CF634C0B7EC3} = {13818769-DC01-4715-9590-E000D03E42A9} {379BC6E6-1900-44F8-8D8C-AA2968A70008} = {13818769-DC01-4715-9590-E000D03E42A9} + {CB93C0B2-D73B-4BDA-A03A-8A7D76012590} = {13818769-DC01-4715-9590-E000D03E42A9} {4FA4A9A6-1D38-414B-96F0-3CFB63C687C9} = {13818769-DC01-4715-9590-E000D03E42A9} {A7B7DE04-7261-4D4C-AA78-9F2D9B5A1C37} = {13818769-DC01-4715-9590-E000D03E42A9} {CFAB1236-51C3-4A13-A57F-16022FD0A7EE} = {28FBA7EA-0592-4446-82F2-2E9819684236} diff --git a/src/libraries/System.Runtime/ref/System.Runtime.cs b/src/libraries/System.Runtime/ref/System.Runtime.cs index db49bbfb30d..1d7f9cd4681 100644 --- a/src/libraries/System.Runtime/ref/System.Runtime.cs +++ b/src/libraries/System.Runtime/ref/System.Runtime.cs @@ -9913,6 +9913,7 @@ protected virtual void FillBuffer(int numBytes) { } public virtual int Read(char[] buffer, int index, int count) { throw null; } public virtual int Read(System.Span buffer) { throw null; } public virtual int Read(System.Span buffer) { throw null; } + public virtual void ReadExactly(System.Span buffer) { throw null; } public int Read7BitEncodedInt() { throw null; } public long Read7BitEncodedInt64() { throw null; } public virtual bool ReadBoolean() { throw null; } @@ -10749,15 +10750,15 @@ public partial class StreamWriter : System.IO.TextWriter { public static readonly new System.IO.StreamWriter Null; public StreamWriter(System.IO.Stream stream) { } - public StreamWriter(System.IO.Stream stream, System.Text.Encoding encoding) { } - public StreamWriter(System.IO.Stream stream, System.Text.Encoding encoding, int bufferSize) { } + public StreamWriter(System.IO.Stream stream, System.Text.Encoding? encoding) { } + public StreamWriter(System.IO.Stream stream, System.Text.Encoding? encoding, int bufferSize) { } public StreamWriter(System.IO.Stream stream, System.Text.Encoding? encoding = null, int bufferSize = -1, bool leaveOpen = false) { } public StreamWriter(string path) { } public StreamWriter(string path, bool append) { } - public StreamWriter(string path, bool append, System.Text.Encoding encoding) { } - public StreamWriter(string path, bool append, System.Text.Encoding encoding, int bufferSize) { } + public StreamWriter(string path, bool append, System.Text.Encoding? encoding) { } + public StreamWriter(string path, bool append, System.Text.Encoding? encoding, int bufferSize) { } public StreamWriter(string path, System.IO.FileStreamOptions options) { } - public StreamWriter(string path, System.Text.Encoding encoding, System.IO.FileStreamOptions options) { } + public StreamWriter(string path, System.Text.Encoding? encoding, System.IO.FileStreamOptions options) { } public virtual bool AutoFlush { get { throw null; } set { } } public virtual System.IO.Stream BaseStream { get { throw null; } } public override System.Text.Encoding Encoding { get { throw null; } } @@ -14034,6 +14035,36 @@ public enum LayoutKind Explicit = 2, Auto = 3, } + public static partial class MemoryMarshal + { + public static System.ReadOnlySpan AsBytes(System.ReadOnlySpan span) where T : struct { throw null; } + public static System.Span AsBytes(System.Span span) where T : struct { throw null; } + public static System.Memory AsMemory(System.ReadOnlyMemory memory) { throw null; } + public static ref readonly T AsRef(System.ReadOnlySpan span) where T : struct { throw null; } + public static ref T AsRef(System.Span span) where T : struct { throw null; } + public static System.ReadOnlySpan Cast(System.ReadOnlySpan span) where TFrom : struct where TTo : struct { throw null; } + public static System.Span Cast(System.Span span) where TFrom : struct where TTo : struct { throw null; } + public static System.Memory CreateFromPinnedArray(T[]? array, int start, int length) { throw null; } + public static System.ReadOnlySpan CreateReadOnlySpan(scoped ref readonly T reference, int length) { throw null; } + [System.CLSCompliant(false)] + public static unsafe ReadOnlySpan CreateReadOnlySpanFromNullTerminated(byte* value) { throw null; } + [System.CLSCompliant(false)] + public static unsafe ReadOnlySpan CreateReadOnlySpanFromNullTerminated(char* value) { throw null; } + public static System.Span CreateSpan(scoped ref T reference, int length) { throw null; } + public static ref T GetArrayDataReference(T[] array) { throw null; } + public static ref byte GetArrayDataReference(System.Array array) { throw null; } + public static ref T GetReference(System.ReadOnlySpan span) { throw null; } + public static ref T GetReference(System.Span span) { throw null; } + public static T Read(System.ReadOnlySpan source) where T : struct { throw null; } + public static System.Collections.Generic.IEnumerable ToEnumerable(System.ReadOnlyMemory memory) { throw null; } + public static bool TryGetArray(System.ReadOnlyMemory memory, out System.ArraySegment segment) { throw null; } + public static bool TryGetMemoryManager(System.ReadOnlyMemory memory, [System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] out TManager? manager) where TManager : System.Buffers.MemoryManager { throw null; } + public static bool TryGetMemoryManager(System.ReadOnlyMemory memory, [System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] out TManager? manager, out int start, out int length) where TManager : System.Buffers.MemoryManager { throw null; } + public static bool TryGetString(System.ReadOnlyMemory memory, [System.Diagnostics.CodeAnalysis.NotNullWhenAttribute(true)] out string? text, out int start, out int length) { throw null; } + public static bool TryRead(System.ReadOnlySpan source, out T value) where T : struct { throw null; } + public static bool TryWrite(System.Span destination, in T value) where T : struct { throw null; } + public static void Write(System.Span destination, in T value) where T : struct { } + } public readonly partial struct OSPlatform : System.IEquatable { private readonly object _dummy; diff --git a/src/libraries/System.Runtime/tests/System.Globalization.Calendars.Tests/System/Globalization/ChineseLunisolarCalendarTests.cs b/src/libraries/System.Runtime/tests/System.Globalization.Calendars.Tests/System/Globalization/ChineseLunisolarCalendarTests.cs index 3da7d6c220a..688a15082c3 100644 --- a/src/libraries/System.Runtime/tests/System.Globalization.Calendars.Tests/System/Globalization/ChineseLunisolarCalendarTests.cs +++ b/src/libraries/System.Runtime/tests/System.Globalization.Calendars.Tests/System/Globalization/ChineseLunisolarCalendarTests.cs @@ -12,5 +12,40 @@ public class ChineseLunisolarCalendarTests : EastAsianLunisolarCalendarTestBase public override DateTime MinSupportedDateTime => new DateTime(1901, 02, 19); public override DateTime MaxSupportedDateTime => new DateTime(2101, 01, 28, 23, 59, 59).AddTicks(9999999); + + [Fact] + public void OffByOneDay() + { + // The new moon separating lunar months 8/9 in 2057, 7/8 in 2089, + // and 6/7 in 2097 occurs close to midnight local time (UTC+8). + // The exact time cannot be determined accurately in advance. + // This may lead to off-by-one-day errors if the predictions made + // by astronomical calculations turn out to be wrong. + // The current table entries for 2057, 2089, and 2097 are validated + // using 'Calendrical Calculations (Ultimate Edition)'. + // This test guards against accidental regression, should future + // recalibrations be required. + + // Lunar month 8 of 2057 has 30 days + Assert.Equal(30, Calendar.GetDaysInMonth(2057, 8)); + + // Lunar month 9 of 2057 has 29 days and starts on 29 Sep 2057 + Assert.Equal(29, Calendar.GetDaysInMonth(2057, 9)); + Assert.Equal(new DateOnly(2057, 9, 29), new DateOnly(2057, 9, 1, Calendar)); + + // Lunar month 7 of 2089 has 29 days + Assert.Equal(29, Calendar.GetDaysInMonth(2089, 7)); + + // Lunar month 8 of 2089 has 30 days and starts on 04 Sep 2089 + Assert.Equal(30, Calendar.GetDaysInMonth(2089, 8)); + Assert.Equal(new DateOnly(2089, 9, 4), new DateOnly(2089, 8, 1, Calendar)); + + // Lunar month 6 of 2097 has 29 days + Assert.Equal(29, Calendar.GetDaysInMonth(2097, 6)); + + // Lunar month 7 of 2097 has 30 days and starts on 07 Aug 2097 + Assert.Equal(30, Calendar.GetDaysInMonth(2097, 7)); + Assert.Equal(new DateOnly(2097, 8, 7), new DateOnly(2097, 7, 1, Calendar)); + } } } diff --git a/src/libraries/System.Runtime/tests/System.Globalization.Tests/CompareInfo/CompareInfoTests.IndexOf.cs b/src/libraries/System.Runtime/tests/System.Globalization.Tests/CompareInfo/CompareInfoTests.IndexOf.cs index 2b89148d2fa..88cddb5f513 100644 --- a/src/libraries/System.Runtime/tests/System.Globalization.Tests/CompareInfo/CompareInfoTests.IndexOf.cs +++ b/src/libraries/System.Runtime/tests/System.Globalization.Tests/CompareInfo/CompareInfoTests.IndexOf.cs @@ -138,7 +138,7 @@ public static IEnumerable IndexOf_TestData() } // Inputs where matched length does not equal value string length - if (!PlatformDetection.IsHybridGlobalizationOnBrowser) + if (!PlatformDetection.IsHybridGlobalizationOnBrowser && PlatformDetection.IsNotHybridGlobalizationOnApplePlatform) { yield return new object[] { s_germanCompare, "abc Strasse Strasse xyz", "stra\u00DFe", 0, 23, supportedIgnoreCaseIgnoreNonSpaceOptions, 4, 7 }; yield return new object[] { s_germanCompare, "abc stra\u00DFe stra\u00DFe xyz", "Strasse", 0, 21, supportedIgnoreCaseIgnoreNonSpaceOptions, 4, 6 }; @@ -246,7 +246,7 @@ static void RunSpanIndexOfTest(CompareInfo compareInfo, ReadOnlySpan sourc valueBoundedMemory.MakeReadonly(); Assert.Equal(expected, compareInfo.IndexOf(sourceBoundedMemory.Span, valueBoundedMemory.Span, options)); - if (!PlatformDetection.IsHybridGlobalizationOnBrowser) + if (!PlatformDetection.IsHybridGlobalizationOnBrowser && PlatformDetection.IsNotHybridGlobalizationOnApplePlatform) { Assert.Equal(expected, compareInfo.IndexOf(sourceBoundedMemory.Span, valueBoundedMemory.Span, options, out int actualMatchLength)); Assert.Equal(expectedMatchLength, actualMatchLength); @@ -334,7 +334,22 @@ public void IndexOf_Invalid() AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's", 'b', 0, CompareOptions.StringSort)); AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's", 'c', 0, 2, CompareOptions.StringSort)); AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's".AsSpan(), "b".AsSpan(), CompareOptions.StringSort)); - AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's".AsSpan(), "b".AsSpan(), CompareOptions.StringSort, out _)); + if (PlatformDetection.IsHybridGlobalizationOnBrowser || PlatformDetection.IsHybridGlobalizationOnApplePlatform) + { + Assert.Throws(() => s_invariantCompare.IndexOf("Test's".AsSpan(), "b".AsSpan(), CompareOptions.StringSort, out _)); + Assert.Throws(() => s_invariantCompare.IndexOf("Test's".AsSpan(), "b".AsSpan(), CompareOptions.Ordinal | CompareOptions.IgnoreWidth, out _)); + Assert.Throws(() => s_invariantCompare.IndexOf("Test's".AsSpan(), "b".AsSpan(), (CompareOptions)(-1), out _)); + Assert.Throws(() => s_invariantCompare.IndexOf("Test's".AsSpan(), "b".AsSpan(), (CompareOptions)0x11111111, out _)); + Assert.Throws(() => s_invariantCompare.IndexOf("Test's".AsSpan(), "b".AsSpan(), CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth, out _)); + } + else + { + AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's".AsSpan(), "b".AsSpan(), CompareOptions.StringSort, out _)); + AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's".AsSpan(), "b".AsSpan(), CompareOptions.Ordinal | CompareOptions.IgnoreWidth, out _)); + AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's".AsSpan(), "b".AsSpan(), (CompareOptions)(-1), out _)); + AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's".AsSpan(), "b".AsSpan(), (CompareOptions)0x11111111, out _)); + AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's".AsSpan(), "b".AsSpan(), CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth, out _)); + } AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's", "Tests", CompareOptions.Ordinal | CompareOptions.IgnoreWidth)); AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's", "Tests", 0, CompareOptions.Ordinal | CompareOptions.IgnoreWidth)); @@ -343,7 +358,6 @@ public void IndexOf_Invalid() AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's", 'b', 0, CompareOptions.Ordinal | CompareOptions.IgnoreWidth)); AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's", 'c', 0, 2, CompareOptions.Ordinal | CompareOptions.IgnoreWidth)); AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's".AsSpan(), "b".AsSpan(), CompareOptions.Ordinal | CompareOptions.IgnoreWidth)); - AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's".AsSpan(), "b".AsSpan(), CompareOptions.Ordinal | CompareOptions.IgnoreWidth, out _)); AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's", "Tests", CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth)); AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's", "Tests", 0, CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth)); @@ -352,7 +366,6 @@ public void IndexOf_Invalid() AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's", 'b', 0, CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth)); AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's", 'c', 0, 2, CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth)); AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's".AsSpan(), "b".AsSpan(), CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth)); - AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's".AsSpan(), "b".AsSpan(), CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth, out _)); AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's", "Tests", (CompareOptions)(-1))); AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's", "Tests", 0, (CompareOptions)(-1))); @@ -361,7 +374,6 @@ public void IndexOf_Invalid() AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's", 'a', 0, (CompareOptions)(-1))); AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's", 'a', 0, 2, (CompareOptions)(-1))); AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's".AsSpan(), "b".AsSpan(), (CompareOptions)(-1))); - AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's".AsSpan(), "b".AsSpan(), (CompareOptions)(-1), out _)); AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's", "Tests", (CompareOptions)0x11111111)); AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's", "Tests", 0, (CompareOptions)0x11111111)); @@ -370,7 +382,6 @@ public void IndexOf_Invalid() AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's", 'a', 0, (CompareOptions)0x11111111)); AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's", 'a', 0, 2, (CompareOptions)0x11111111)); AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's".AsSpan(), "b".AsSpan(), (CompareOptions)0x11111111)); - AssertExtensions.Throws("options", () => s_invariantCompare.IndexOf("Test's".AsSpan(), "b".AsSpan(), (CompareOptions)0x11111111, out _)); // StartIndex < 0 AssertExtensions.Throws("startIndex", () => s_invariantCompare.IndexOf("Test", "Test", -1, CompareOptions.None)); diff --git a/src/libraries/System.Runtime/tests/System.Globalization.Tests/CompareInfo/CompareInfoTests.LastIndexOf.cs b/src/libraries/System.Runtime/tests/System.Globalization.Tests/CompareInfo/CompareInfoTests.LastIndexOf.cs index abb2c31f167..69cf4c0c3ba 100644 --- a/src/libraries/System.Runtime/tests/System.Globalization.Tests/CompareInfo/CompareInfoTests.LastIndexOf.cs +++ b/src/libraries/System.Runtime/tests/System.Globalization.Tests/CompareInfo/CompareInfoTests.LastIndexOf.cs @@ -253,7 +253,7 @@ static void RunSpanLastIndexOfTest(CompareInfo compareInfo, ReadOnlySpan s valueBoundedMemory.MakeReadonly(); Assert.Equal(expected, compareInfo.LastIndexOf(sourceBoundedMemory.Span, valueBoundedMemory.Span, options)); - if (!PlatformDetection.IsHybridGlobalizationOnBrowser) + if (!PlatformDetection.IsHybridGlobalizationOnBrowser && PlatformDetection.IsNotHybridGlobalizationOnApplePlatform) { Assert.Equal(expected, compareInfo.LastIndexOf(sourceBoundedMemory.Span, valueBoundedMemory.Span, options, out int actualMatchLength)); Assert.Equal(expectedMatchLength, actualMatchLength); @@ -348,7 +348,22 @@ public void LastIndexOf_Invalid() AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", 'a', 0, CompareOptions.StringSort)); AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", 'a', 0, 1, CompareOptions.StringSort)); AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", "a".AsSpan(), CompareOptions.StringSort)); - AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", "a".AsSpan(), CompareOptions.StringSort, out int matchLength)); + if (PlatformDetection.IsHybridGlobalizationOnBrowser || PlatformDetection.IsHybridGlobalizationOnApplePlatform) + { + Assert.Throws(() => s_invariantCompare.LastIndexOf("Test's", "a".AsSpan(), CompareOptions.StringSort, out int matchLength)); + Assert.Throws(() => s_invariantCompare.LastIndexOf("Test's", "a".AsSpan(), CompareOptions.Ordinal | CompareOptions.IgnoreWidth, out int matchLength)); + Assert.Throws(() => s_invariantCompare.LastIndexOf("Test's", "a".AsSpan(), CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth, out int matchLength)); + Assert.Throws(() => s_invariantCompare.LastIndexOf("Test's", "a".AsSpan(), (CompareOptions)(-1), out int matchLength)); + Assert.Throws(() => s_invariantCompare.LastIndexOf("Test's", "a".AsSpan(), (CompareOptions)0x11111111, out int matchLength)); + } + else + { + AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", "a".AsSpan(), CompareOptions.StringSort, out int matchLength)); + AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", "a".AsSpan(), CompareOptions.Ordinal | CompareOptions.IgnoreWidth, out int matchLength)); + AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", "a".AsSpan(), CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth, out int matchLength)); + AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", "a".AsSpan(), (CompareOptions)(-1), out int matchLength)); + AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", "a".AsSpan(), (CompareOptions)0x11111111, out int matchLength)); + } AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", "Tests", CompareOptions.Ordinal | CompareOptions.IgnoreWidth)); AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", "Tests", 0, CompareOptions.Ordinal | CompareOptions.IgnoreWidth)); @@ -357,7 +372,6 @@ public void LastIndexOf_Invalid() AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", 'a', 0, CompareOptions.Ordinal | CompareOptions.IgnoreWidth)); AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", 'a', 0, 1, CompareOptions.Ordinal | CompareOptions.IgnoreWidth)); AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", "a".AsSpan(), CompareOptions.Ordinal | CompareOptions.IgnoreWidth)); - AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", "a".AsSpan(), CompareOptions.Ordinal | CompareOptions.IgnoreWidth, out int matchLength)); AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", "Tests", CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth)); AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", "Tests", 0, CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth)); @@ -366,7 +380,6 @@ public void LastIndexOf_Invalid() AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", 'a', 0, CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth)); AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", 'a', 0, 1, CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth)); AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", "a".AsSpan(), CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth)); - AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", "a".AsSpan(), CompareOptions.OrdinalIgnoreCase | CompareOptions.IgnoreWidth, out int matchLength)); AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", "Tests", (CompareOptions)(-1))); AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", "Tests", 0, (CompareOptions)(-1))); @@ -375,7 +388,6 @@ public void LastIndexOf_Invalid() AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", 'a', 0, (CompareOptions)(-1))); AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", 'a', 0, 1, (CompareOptions)(-1))); AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", "a".AsSpan(), (CompareOptions)(-1))); - AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", "a".AsSpan(), (CompareOptions)(-1), out int matchLength)); AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", "Tests", (CompareOptions)0x11111111)); AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", "Tests", 0, (CompareOptions)0x11111111)); @@ -384,7 +396,6 @@ public void LastIndexOf_Invalid() AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", 'a', 0, (CompareOptions)0x11111111)); AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", 'a', 0, 1, (CompareOptions)0x11111111)); AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", "a".AsSpan(), (CompareOptions)0x11111111)); - AssertExtensions.Throws("options", () => s_invariantCompare.LastIndexOf("Test's", "a".AsSpan(), (CompareOptions)0x11111111, out int matchLength)); // StartIndex < 0 AssertExtensions.Throws("startIndex", () => s_invariantCompare.LastIndexOf("Test", "Test", -1, CompareOptions.None)); diff --git a/src/libraries/System.Runtime/tests/System.Globalization.Tests/Invariant/InvariantMode.cs b/src/libraries/System.Runtime/tests/System.Globalization.Tests/Invariant/InvariantMode.cs index 3b72d1d219c..c5733728fe6 100644 --- a/src/libraries/System.Runtime/tests/System.Globalization.Tests/Invariant/InvariantMode.cs +++ b/src/libraries/System.Runtime/tests/System.Globalization.Tests/Invariant/InvariantMode.cs @@ -898,14 +898,17 @@ static void TestCore(CompareInfo compareInfo, string source, string value, int s Assert.Equal(offsetResult, sourceBoundedSpan.IndexOf(valueBoundedSpan, GetStringComparison(options))); Assert.Equal(offsetResult, compareInfo.IndexOf(sourceBoundedSpan, valueBoundedSpan, options)); - Assert.Equal(offsetResult, compareInfo.IndexOf(sourceBoundedSpan, valueBoundedSpan, options, out int matchLength)); - if (offsetResult >= 0) - { - Assert.Equal(valueBoundedSpan.Length, matchLength); // Invariant mode should perform non-linguistic comparisons - } - else + if (PlatformDetection.IsNotHybridGlobalizationOnApplePlatform) { - Assert.Equal(0, matchLength); // not found + Assert.Equal(offsetResult, compareInfo.IndexOf(sourceBoundedSpan, valueBoundedSpan, options, out int matchLength)); + if (offsetResult >= 0) + { + Assert.Equal(valueBoundedSpan.Length, matchLength); // Invariant mode should perform non-linguistic comparisons + } + else + { + Assert.Equal(0, matchLength); // not found + } } } } @@ -958,14 +961,17 @@ static void TestCore(CompareInfo compareInfo, string source, string value, int s Assert.Equal(result, sourceBoundedSpan.LastIndexOf(valueBoundedSpan, GetStringComparison(options))); Assert.Equal(result, compareInfo.LastIndexOf(sourceBoundedSpan, valueBoundedSpan, options)); - Assert.Equal(result, compareInfo.LastIndexOf(sourceBoundedSpan, valueBoundedSpan, options, out int matchLength)); - if (result >= 0) + if (PlatformDetection.IsNotHybridGlobalizationOnApplePlatform) { - Assert.Equal(valueBoundedSpan.Length, matchLength); // Invariant mode should perform non-linguistic comparisons - } - else - { - Assert.Equal(0, matchLength); // not found + Assert.Equal(result, compareInfo.LastIndexOf(sourceBoundedSpan, valueBoundedSpan, options, out int matchLength)); + if (result >= 0) + { + Assert.Equal(valueBoundedSpan.Length, matchLength); // Invariant mode should perform non-linguistic comparisons + } + else + { + Assert.Equal(0, matchLength); // not found + } } } } @@ -993,14 +999,17 @@ public void TestIsPrefix(string source, string value, CompareOptions options, bo Assert.Equal(result, sourceBoundedSpan.StartsWith(valueBoundedSpan, GetStringComparison(options))); Assert.Equal(result, compareInfo.IsPrefix(sourceBoundedSpan, valueBoundedSpan, options)); - Assert.Equal(result, compareInfo.IsPrefix(sourceBoundedSpan, valueBoundedSpan, options, out int matchLength)); - if (result) - { - Assert.Equal(valueBoundedSpan.Length, matchLength); // Invariant mode should perform non-linguistic comparisons - } - else + if (PlatformDetection.IsNotHybridGlobalizationOnApplePlatform) { - Assert.Equal(0, matchLength); // not found + Assert.Equal(result, compareInfo.IsPrefix(sourceBoundedSpan, valueBoundedSpan, options, out int matchLength)); + if (result) + { + Assert.Equal(valueBoundedSpan.Length, matchLength); // Invariant mode should perform non-linguistic comparisons + } + else + { + Assert.Equal(0, matchLength); // not found + } } } } @@ -1028,14 +1037,17 @@ public void TestIsSuffix(string source, string value, CompareOptions options, bo Assert.Equal(result, sourceBoundedSpan.EndsWith(valueBoundedSpan, GetStringComparison(options))); Assert.Equal(result, compareInfo.IsSuffix(sourceBoundedSpan, valueBoundedSpan, options)); - Assert.Equal(result, compareInfo.IsSuffix(sourceBoundedSpan, valueBoundedSpan, options, out int matchLength)); - if (result) - { - Assert.Equal(valueBoundedSpan.Length, matchLength); // Invariant mode should perform non-linguistic comparisons - } - else + if (PlatformDetection.IsNotHybridGlobalizationOnApplePlatform) { - Assert.Equal(0, matchLength); // not found + Assert.Equal(result, compareInfo.IsSuffix(sourceBoundedSpan, valueBoundedSpan, options, out int matchLength)); + if (result) + { + Assert.Equal(valueBoundedSpan.Length, matchLength); // Invariant mode should perform non-linguistic comparisons + } + else + { + Assert.Equal(0, matchLength); // not found + } } } } @@ -1257,5 +1269,18 @@ private static byte[] GetExpectedInvariantOrdinalSortKey(ReadOnlySpan inpu return memoryStream.ToArray(); } + + [Fact] + public void TestChainStringComparisons() + { + var s1 = "бал"; + var s2 = "Бан"; + var s3 = "Д"; + + // If s1 < s2 and s2 < s3, then s1 < s3 + Assert.True(string.Compare(s1, s2, StringComparison.OrdinalIgnoreCase) < 0); + Assert.True(string.Compare(s2, s3, StringComparison.OrdinalIgnoreCase) < 0); + Assert.True(string.Compare(s1, s3, StringComparison.OrdinalIgnoreCase) < 0); + } } } diff --git a/src/libraries/System.Runtime/tests/System.IO.FileSystem.Tests/File/ReadWriteAllBytes.cs b/src/libraries/System.Runtime/tests/System.IO.FileSystem.Tests/File/ReadWriteAllBytes.cs index 5f56d4476d2..f5125531ec3 100644 --- a/src/libraries/System.Runtime/tests/System.IO.FileSystem.Tests/File/ReadWriteAllBytes.cs +++ b/src/libraries/System.Runtime/tests/System.IO.FileSystem.Tests/File/ReadWriteAllBytes.cs @@ -111,9 +111,11 @@ public void WriteToReadOnlyFile() { if (PlatformDetection.IsNotWindows && PlatformDetection.IsPrivilegedProcess) { - File.WriteAllBytes(path, "text"u8.ToArray()); - File.WriteAllBytes(path, "text"u8); - Assert.Equal("texttext"u8.ToArray(), File.ReadAllBytes(path)); + File.WriteAllBytes(path, "text1"u8.ToArray()); + Assert.Equal("text1"u8.ToArray(), File.ReadAllBytes(path)); + + File.WriteAllBytes(path, "text2"u8); + Assert.Equal("text2"u8.ToArray(), File.ReadAllBytes(path)); } else { diff --git a/src/libraries/System.Runtime/tests/System.IO.FileSystem.Tests/File/ReadWriteAllBytesAsync.cs b/src/libraries/System.Runtime/tests/System.IO.FileSystem.Tests/File/ReadWriteAllBytesAsync.cs index 662e4aa1091..1a3be928096 100644 --- a/src/libraries/System.Runtime/tests/System.IO.FileSystem.Tests/File/ReadWriteAllBytesAsync.cs +++ b/src/libraries/System.Runtime/tests/System.IO.FileSystem.Tests/File/ReadWriteAllBytesAsync.cs @@ -123,9 +123,11 @@ public async Task WriteToReadOnlyFileAsync() { if (PlatformDetection.IsNotWindows && PlatformDetection.IsPrivilegedProcess) { - await File.WriteAllBytesAsync(path, "text"u8.ToArray()); - await File.WriteAllBytesAsync(path, "text"u8.ToArray().AsMemory()); - Assert.Equal("texttext"u8.ToArray(), await File.ReadAllBytesAsync(path)); + await File.WriteAllBytesAsync(path, "text1"u8.ToArray()); + Assert.Equal("text1"u8.ToArray(), await File.ReadAllBytesAsync(path)); + + await File.WriteAllBytesAsync(path, "text2"u8.ToArray().AsMemory()); + Assert.Equal("text2"u8.ToArray(), await File.ReadAllBytesAsync(path)); } else { diff --git a/src/libraries/System.Runtime/tests/System.IO.Tests/BinaryReader/BinaryReaderTests.cs b/src/libraries/System.Runtime/tests/System.IO.Tests/BinaryReader/BinaryReaderTests.cs index 4a2dfa49bc9..eaebd985a86 100644 --- a/src/libraries/System.Runtime/tests/System.IO.Tests/BinaryReader/BinaryReaderTests.cs +++ b/src/libraries/System.Runtime/tests/System.IO.Tests/BinaryReader/BinaryReaderTests.cs @@ -103,6 +103,11 @@ public void BinaryReader_EofReachedEarlyTests_ThrowsException() RunTest(writer => writer.Write("hello world"), reader => reader.ReadString()); RunTest(writer => writer.Write(new string('x', 1024 * 1024)), reader => reader.ReadString()); + // test reading into a buffer + byte[] byteBuffer = new byte[10]; + + RunTest(writer => writer.Write(byteBuffer), reader => reader.ReadExactly(byteBuffer)); + void RunTest(Action writeAction, Action readAction) { UTF8Encoding encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true); @@ -195,6 +200,7 @@ private void ValidateDisposedExceptions(BinaryReader binaryReader) Assert.Throws(() => binaryReader.Read()); Assert.Throws(() => binaryReader.Read(byteBuffer, 0, 1)); Assert.Throws(() => binaryReader.Read(charBuffer, 0, 1)); + Assert.Throws(() => binaryReader.ReadExactly(byteBuffer)); Assert.Throws(() => binaryReader.ReadBoolean()); Assert.Throws(() => binaryReader.ReadByte()); Assert.Throws(() => binaryReader.ReadBytes(1)); @@ -438,6 +444,31 @@ public void Read_CharSpan_ThrowIfDisposed() } } + [Theory] + [InlineData(100, 10)] + [InlineData(10, 10)] + [InlineData(10, 0)] + [InlineData(0, 0)] + public void ReadExactly_ByteSpan(int sourceSize, int destinationSize) + { + using (var stream = CreateStream()) + { + byte[] source = new byte[sourceSize]; + new Random(345).NextBytes(source); + stream.Write(source); + stream.Position = 0; + + using (var reader = new BinaryReader(stream)) + { + byte[] destination = new byte[destinationSize]; + + reader.ReadExactly(destination); + + Assert.Equal(source[..destinationSize], destination); + } + } + } + private class DerivedBinaryReader : BinaryReader { public DerivedBinaryReader(Stream input) : base(input) { } diff --git a/src/libraries/System.Runtime/tests/System.IO.Tests/MemoryStream/MemoryStreamTests.cs b/src/libraries/System.Runtime/tests/System.IO.Tests/MemoryStream/MemoryStreamTests.cs index baa158060cf..ae2961f111a 100644 --- a/src/libraries/System.Runtime/tests/System.IO.Tests/MemoryStream/MemoryStreamTests.cs +++ b/src/libraries/System.Runtime/tests/System.IO.Tests/MemoryStream/MemoryStreamTests.cs @@ -104,6 +104,7 @@ from bufferContext in [MemberData(nameof(MemoryStream_PositionOverflow_Throws_MemberData))] [SkipOnPlatform(TestPlatforms.iOS | TestPlatforms.tvOS, "https://github.com/dotnet/runtime/issues/92467")] [ActiveIssue("https://github.com/dotnet/runtime/issues/100225", typeof(PlatformDetection), nameof(PlatformDetection.IsMonoRuntime), nameof(PlatformDetection.IsWindows), nameof(PlatformDetection.IsX64Process))] + [ActiveIssue("https://github.com/dotnet/runtime/issues/100558", TestPlatforms.Linux)] public void MemoryStream_SeekOverflow_Throws(SeekMode mode, int bufferSize, int origin) { byte[] buffer = new byte[bufferSize]; diff --git a/src/libraries/System.Runtime/tests/System.IO.Tests/StreamWriter/StreamWriter.CtorTests.cs b/src/libraries/System.Runtime/tests/System.IO.Tests/StreamWriter/StreamWriter.CtorTests.cs index bf768cf9ff7..bf0075139e6 100644 --- a/src/libraries/System.Runtime/tests/System.IO.Tests/StreamWriter/StreamWriter.CtorTests.cs +++ b/src/libraries/System.Runtime/tests/System.IO.Tests/StreamWriter/StreamWriter.CtorTests.cs @@ -48,7 +48,13 @@ public static void UnicodeEncoding() TestEncoding(System.Text.Encoding.Unicode, "This is Unicode\u00FF"); } - private static void TestEncoding(System.Text.Encoding encoding, string testString) + [Fact] + public static void NullEncoding() + { + TestEncoding(null, "This is UTF8\u00FF"); + } + + private static void TestEncoding(System.Text.Encoding? encoding, string testString) { StreamWriter sw2; StreamReader sr2; diff --git a/src/libraries/System.Runtime/tests/System.IO.Tests/StreamWriter/StreamWriter.StringCtorTests.cs b/src/libraries/System.Runtime/tests/System.IO.Tests/StreamWriter/StreamWriter.StringCtorTests.cs index 6900fb97384..ec94e8cb606 100644 --- a/src/libraries/System.Runtime/tests/System.IO.Tests/StreamWriter/StreamWriter.StringCtorTests.cs +++ b/src/libraries/System.Runtime/tests/System.IO.Tests/StreamWriter/StreamWriter.StringCtorTests.cs @@ -19,9 +19,6 @@ public static void NullArgs_ThrowsArgumentNullException() AssertExtensions.Throws("path", () => new StreamWriter((string)null, true)); AssertExtensions.Throws("path", () => new StreamWriter((string)null, true, null)); AssertExtensions.Throws("path", () => new StreamWriter((string)null, true, null, -1)); - AssertExtensions.Throws("encoding", () => new StreamWriter("path", true, null)); - AssertExtensions.Throws("encoding", () => new StreamWriter("path", null, null)); - AssertExtensions.Throws("encoding", () => new StreamWriter("path", true, null, -1)); } [Fact] @@ -31,6 +28,7 @@ public static void EmptyPath_ThrowsArgumentException() AssertExtensions.Throws("path", () => new StreamWriter("")); AssertExtensions.Throws("path", () => new StreamWriter("", new FileStreamOptions())); AssertExtensions.Throws("path", () => new StreamWriter("", true)); + AssertExtensions.Throws("path", () => new StreamWriter("", true, null)); AssertExtensions.Throws("path", () => new StreamWriter("", true, Encoding.UTF8)); AssertExtensions.Throws("path", () => new StreamWriter("", Encoding.UTF8, new FileStreamOptions())); AssertExtensions.Throws("path", () => new StreamWriter("", true, Encoding.UTF8, -1)); diff --git a/src/libraries/System.Runtime/tests/System.IO.Tests/System.IO.Tests.csproj b/src/libraries/System.Runtime/tests/System.IO.Tests/System.IO.Tests.csproj index 18a73faa56f..ebb8cdcd4db 100644 --- a/src/libraries/System.Runtime/tests/System.IO.Tests/System.IO.Tests.csproj +++ b/src/libraries/System.Runtime/tests/System.IO.Tests/System.IO.Tests.csproj @@ -5,10 +5,10 @@ true true $(NetCoreAppCurrent) + true 1 - true 01:15:00 diff --git a/src/libraries/System.Runtime/tests/System.Resources.ResourceManager.Tests/System.Resources.ResourceManager.Tests.csproj b/src/libraries/System.Runtime/tests/System.Resources.ResourceManager.Tests/System.Resources.ResourceManager.Tests.csproj index 426654a590f..8b96b4c4aba 100644 --- a/src/libraries/System.Runtime/tests/System.Resources.ResourceManager.Tests/System.Resources.ResourceManager.Tests.csproj +++ b/src/libraries/System.Runtime/tests/System.Resources.ResourceManager.Tests/System.Resources.ResourceManager.Tests.csproj @@ -61,6 +61,10 @@ + + + + diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/AttributeTests.cs b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/AttributeTests.cs index 1cc7e3ee6c6..a410935e894 100644 --- a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/AttributeTests.cs +++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/AttributeTests.cs @@ -190,6 +190,24 @@ public static IEnumerable Equals_TestData() yield return new object[] { new StringValueAttribute("hello"), new StringValueIntValueAttribute("hello", 1), false, true }; // GetHashCode() ignores the int value yield return new object[] { new StringValueAttribute("hello"), "hello", false, false }; yield return new object[] { new StringValueAttribute("hello"), null, false, false }; + + yield return new object[] { new GenericAttribute(1), new GenericAttribute(1), true, true }; + yield return new object[] { new GenericAttribute(1), new GenericAttribute(2), false, false }; + yield return new object[] { new GenericAttribute(1), new GenericAttribute(1), false, true }; // GetHashCode() converts short to int + yield return new object[] { new GenericAttribute(1), new GenericAttribute(1), false, true }; // GetHashCode() converts long to int + yield return new object[] { new GenericAttribute(1), new GenericAttribute(long.MaxValue), false, false }; + yield return new object[] { new GenericAttribute(int.MaxValue), new GenericAttribute(long.MaxValue), false, false }; + yield return new object[] { new GenericAttribute(1), new GenericAttribute(1.0), false, false }; + yield return new object[] { new GenericAttribute(1), new GenericAttribute((AttributeTargets)1), false, true }; // GetHashCode() uses the base type of the enum + yield return new object[] { new GenericAttribute(1), new GenericAttribute(1), false, true }; // GetHashCode() ignores the property + + yield return new object[] { new GenericAttribute(1) { OptionalValue = "hello", }, new GenericAttribute(1) { OptionalValue = "hello", }, true, true }; + yield return new object[] { new GenericAttribute(1) { OptionalValue = "hello", }, new GenericAttribute(1) { OptionalValue = "goodbye", }, false, true }; // GetHashCode() ignores the property + yield return new object[] { new GenericAttribute(1) { OptionalValue = "hello", }, new GenericAttribute(1), false, true }; // GetHashCode() ignores the property + + yield return new object[] { new GenericAttribute(1) { OptionalValue = 2.0, }, new GenericAttribute(1) { OptionalValue = 2.0, }, true, true }; + yield return new object[] { new GenericAttribute(1) { OptionalValue = 2.0, }, new GenericAttribute(1) { OptionalValue = 2.1, }, false, true }; // GetHashCode() ignores the property + yield return new object[] { new GenericAttribute(1) { OptionalValue = 2.0, }, new GenericAttribute(1) { OptionalValue = 2.0f, }, false, true }; // GetHashCode() ignores the property } [Theory] @@ -238,5 +256,17 @@ public static void ValidateDefaults() Assert.Equal(sav.GetType(), sav.TypeId); Assert.True(sav.Match(sav)); } + + [AttributeUsage(AttributeTargets.Method)] + private sealed class GenericAttribute : Attribute + { + public GenericAttribute(T1 value) + { + Value = value; + } + + public T1 Value { get; } + public T2 OptionalValue { get; set; } + } } } diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Attributes.cs b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Attributes.cs index 61c10f94794..3784d52cfca 100644 --- a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Attributes.cs +++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Attributes.cs @@ -242,14 +242,12 @@ public static void GetCustomAttributes_DynamicMethod() } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/56887", TestRuntimes.Mono)] public static void GetCustomAttributesWorksWithOpenAndClosedGenericTypesForType() { GenericAttributesTestHelper(t => Attribute.GetCustomAttributes(typeof(HasGenericAttribute), t)); } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/56887", TestRuntimes.Mono)] public static void GetCustomAttributesWorksWithOpenAndClosedGenericTypesForField() { FieldInfo field = typeof(HasGenericAttribute).GetField(nameof(HasGenericAttribute.Field), BindingFlags.NonPublic | BindingFlags.Instance); @@ -257,7 +255,6 @@ public static void GetCustomAttributesWorksWithOpenAndClosedGenericTypesForField } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/56887", TestRuntimes.Mono)] public static void GetCustomAttributesWorksWithOpenAndClosedGenericTypesForConstructor() { ConstructorInfo method = typeof(HasGenericAttribute).GetConstructor(Type.EmptyTypes); @@ -265,7 +262,6 @@ public static void GetCustomAttributesWorksWithOpenAndClosedGenericTypesForConst } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/56887", TestRuntimes.Mono)] public static void GetCustomAttributesWorksWithOpenAndClosedGenericTypesForMethod() { MethodInfo method = typeof(HasGenericAttribute).GetMethod(nameof(HasGenericAttribute.Method)); @@ -273,7 +269,6 @@ public static void GetCustomAttributesWorksWithOpenAndClosedGenericTypesForMetho } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/56887", TestRuntimes.Mono)] public static void GetCustomAttributesWorksWithOpenAndClosedGenericTypesForParameter() { ParameterInfo parameter = typeof(HasGenericAttribute).GetMethod(nameof(HasGenericAttribute.Method)).GetParameters()[0]; @@ -281,7 +276,6 @@ public static void GetCustomAttributesWorksWithOpenAndClosedGenericTypesForParam } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/56887", TestRuntimes.Mono)] public static void GetCustomAttributesWorksWithOpenAndClosedGenericTypesForProperty() { PropertyInfo property = typeof(HasGenericAttribute).GetProperty(nameof(HasGenericAttribute.Property)); @@ -289,7 +283,6 @@ public static void GetCustomAttributesWorksWithOpenAndClosedGenericTypesForPrope } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/56887", TestRuntimes.Mono)] public static void GetCustomAttributesWorksWithOpenAndClosedGenericTypesForEvent() { EventInfo @event = typeof(HasGenericAttribute).GetEvent(nameof(HasGenericAttribute.Event)); @@ -297,30 +290,41 @@ public static void GetCustomAttributesWorksWithOpenAndClosedGenericTypesForEvent } [Fact] - [ActiveIssue("https://github.com/dotnet/runtime/issues/56887", TestRuntimes.Mono)] - public static void GetCustomAttributesOnOpenGenericTypeRetrievesDerivedAttributes() + [ActiveIssue("https://github.com/dotnet/runtime/issues/107095", TestRuntimes.Mono)] + public static void GetCustomAttributesOnOpenGenericBaseTypeRetrievesDerivedAttributes() { Attribute[] attributes = Attribute.GetCustomAttributes(typeof(HasGenericAttribute), typeof(GenericAttribute<>)); - Assert.Equal(3, attributes.Length); - Assert.Equal(1, attributes.Count(a => a.GetType() == typeof(DerivesFromGenericAttribute))); - Assert.Equal(1, attributes.Count(a => a.GetType() == typeof(GenericAttribute))); - Assert.Equal(1, attributes.Count(a => a.GetType() == typeof(GenericAttribute))); + Assert.Contains(typeof(DerivesFromGenericAttribute), attributes.Select(a => a.GetType())); + } - attributes = Attribute.GetCustomAttributes(typeof(HasGenericAttribute), typeof(GenericAttribute)); - Assert.Equal(2, attributes.Length); - Assert.Equal(1, attributes.Count(a => a.GetType() == typeof(DerivesFromGenericAttribute))); - Assert.Equal(1, attributes.Count(a => a.GetType() == typeof(GenericAttribute))); + [Fact] + public static void GetCustomAttributesOnClosedGenericBaseTypeRetrievesDerivedAttributes() + { + Attribute[] attributes = Attribute.GetCustomAttributes(typeof(HasGenericAttribute), typeof(GenericAttribute)); + Assert.Contains(typeof(DerivesFromGenericAttribute), attributes.Select(a => a.GetType())); + } + + [Fact] + public static void GetCustomAttributesGenericAttributeHasValues() + { + Attribute[] attributes = Attribute.GetCustomAttributes(typeof(HasGenericAttribute), typeof(GenericAttribute)); + GenericAttribute attribute = Assert.IsType>(Assert.Single(attributes)); + + Assert.Multiple( + () => Assert.Equal(1, attribute.Value), + () => Assert.Equal(new[] { 2, 3 }, attribute.AdditionalValues), + () => Assert.Equal(4, attribute.OptionalValue)); } private static void GenericAttributesTestHelper(Func getCustomAttributes) { Attribute[] openGenericAttributes = getCustomAttributes(typeof(GenericAttribute<>)); - Assert.True(openGenericAttributes.Length >= 1); - Assert.Equal(1, openGenericAttributes.OfType>().Count()); - Attribute[] closedGenericAttributes = getCustomAttributes(typeof(GenericAttribute)); - Assert.Equal(1, closedGenericAttributes.Length); - Assert.Equal(typeof(GenericAttribute[]), closedGenericAttributes.GetType()); + + Assert.Multiple( + () => Assert.Contains(typeof(GenericAttribute), openGenericAttributes.Select(a => a.GetType())), + () => Assert.NotEmpty(closedGenericAttributes), + () => Assert.All(closedGenericAttributes, a => Assert.IsType>(a))); } } @@ -935,6 +939,21 @@ public class ExampleWithAttribute { } [AttributeUsage(AttributeTargets.All, AllowMultiple = true)] public class GenericAttribute : Attribute { + public GenericAttribute() + { + } + + public GenericAttribute(T value, params T[] additionalValues) + { + Value = value; + AdditionalValues = additionalValues; + } + + public T Value { get; } + + public T[] AdditionalValues { get; } + + public T OptionalValue { get; set; } } public class DerivesFromGenericAttribute : GenericAttribute @@ -943,6 +962,7 @@ public class DerivesFromGenericAttribute : GenericAttribute [DerivesFromGeneric] [GenericAttribute] + [GenericAttribute(1, 2, 3, OptionalValue = 4)] [GenericAttribute] public class HasGenericAttribute { diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/ComponentModel/DefaultValueAttributeTests.cs b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/ComponentModel/DefaultValueAttributeTests.cs index ba3f6a0882f..641b74c9408 100644 --- a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/ComponentModel/DefaultValueAttributeTests.cs +++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/ComponentModel/DefaultValueAttributeTests.cs @@ -12,8 +12,10 @@ namespace System.ComponentModel.Tests { public class DefaultValueAttributeTests { + public static bool DefaultValueAttributeIsSupported => AppContext.TryGetSwitch("System.ComponentModel.DefaultValueAttribute.IsSupported", out bool isEnabled) ? isEnabled : true; + [Fact] - public static void Ctor() + public static void Ctor_value() { Assert.Equal((object)true, new DefaultValueAttribute(true).Value); Assert.Equal((object)false, new DefaultValueAttribute(false).Value); @@ -37,7 +39,11 @@ public static void Ctor() Assert.Equal("test", new DefaultValueAttribute("test").Value); Assert.Equal("test", new DefaultValueAttribute((object)"test").Value); + } + [ConditionalFact(nameof(DefaultValueAttributeIsSupported))] + public static void Ctor_type_string() + { Assert.Equal(DayOfWeek.Monday, new DefaultValueAttribute(typeof(DayOfWeek), "Monday").Value); Assert.Equal(TimeSpan.FromHours(1), new DefaultValueAttribute(typeof(TimeSpan), "1:00:00").Value); @@ -63,7 +69,7 @@ public class CustomType2 public int Value { get; set; } } - [Fact] + [ConditionalFact(nameof(DefaultValueAttributeIsSupported))] public static void Ctor_CustomTypeConverter() { TypeDescriptor.AddAttributes(typeof(CustomType), new TypeConverterAttribute(typeof(CustomConverter))); @@ -99,7 +105,7 @@ public void Ctor_TypeDescriptorNotFound_ExceptionFallback(Type type, bool return }, type.ToString(), returnNull.ToString(), stringToConvert, expectedValue.ToString()).Dispose(); } - [Theory] + [ConditionalTheory(nameof(DefaultValueAttributeIsSupported))] [InlineData(typeof(CustomType2))] [InlineData(typeof(DefaultValueAttribute))] public static void Ctor_DefaultTypeConverter_Null(Type type) diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/EnumTests.cs b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/EnumTests.cs index e6c7f1b267d..b3fddb6bac4 100644 --- a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/EnumTests.cs +++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/EnumTests.cs @@ -937,6 +937,12 @@ public static IEnumerable ToObject_TestData() // Char yield return new object[] { s_charEnumType, (char)1, Enum.Parse(s_charEnumType, "Value1") }; yield return new object[] { s_charEnumType, (char)2, Enum.Parse(s_charEnumType, "Value2") }; + + // IntPtr + yield return new object[] { s_intPtrEnumType, (nint)1, Enum.ToObject(s_intPtrEnumType, 1) }; + + // UIntPtr + yield return new object[] { s_uintPtrEnumType, (nuint)1, Enum.ToObject(s_uintPtrEnumType, 1) }; } } @@ -982,8 +988,6 @@ public static IEnumerable ToObject_InvalidValue_TestData() { yield return new object[] { s_floatEnumType, 1.0f, typeof(ArgumentException) }; yield return new object[] { s_doubleEnumType, 1.0, typeof(ArgumentException) }; - yield return new object[] { s_intPtrEnumType, (IntPtr)1, typeof(ArgumentException) }; - yield return new object[] { s_uintPtrEnumType, (UIntPtr)1, typeof(ArgumentException) }; } } diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/HalfTests.cs b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/HalfTests.cs index cba358e484a..9ad2869ba5a 100644 --- a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/HalfTests.cs +++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/HalfTests.cs @@ -1129,7 +1129,7 @@ public static void ToStringRoundtrip_R(object o_value) public static void ToString_MaxPrecision() { Half value = BitConverter.Int16BitsToHalf(0x07FF); - string str = value.ToString("F24"); + string str = value.ToString("F24", NumberFormatInfo.InvariantInfo); Assert.Equal("0.000122010707855224609375", str); } diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Int32Tests.cs b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Int32Tests.cs index 79b04ec2a7d..c170548369c 100644 --- a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Int32Tests.cs +++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/Int32Tests.cs @@ -663,6 +663,46 @@ public static IEnumerable Parse_Invalid_TestData() yield return new object[] { "2147483649-", NumberStyles.AllowTrailingSign, null, typeof(OverflowException) }; yield return new object[] { "(2147483649)", NumberStyles.AllowParentheses, null, typeof(OverflowException) }; yield return new object[] { "2E10", NumberStyles.AllowExponent, null, typeof(OverflowException) }; + + // Test trailing non zeros + + yield return new object[] { "-9223372036854775808.1", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "-2147483648.1", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "-32768.1", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "-128.1", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "127.1", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "255.1", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "32767.1", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "65535.1", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "2147483647.1", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "4294967295.1", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "9223372036854775807.1", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "18446744073709551615.1", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + + yield return new object[] { "-9223372036854775808.001", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "-2147483648.001", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "-32768.001", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "-128.001", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "127.001", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "255.001", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "32767.001", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "65535.001", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "2147483647.001", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "4294967295.001", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "9223372036854775807.001", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "18446744073709551615.001", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + + yield return new object[] { "3.001", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "3.000000001", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "3.0000000001", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "3.00000000001", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + + yield return new object[] { "3.100", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "3.100000000", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "3.1000000000", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + yield return new object[] { "3.10000000000", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; + + yield return new object[] { "2147483646.1", NumberStyles.Number, CultureInfo.InvariantCulture, typeof(OverflowException) }; } [Theory] diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/LazyTests.cs b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/LazyTests.cs index 76c3639e729..6068d660914 100644 --- a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/LazyTests.cs +++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/LazyTests.cs @@ -385,7 +385,6 @@ public static void Value_ThrownException_DoesntCreateValue_PublicationOnly() Assert.False(lazy.IsValueCreated); } - [ActiveIssue("https://github.com/dotnet/runtime/issues/105251", TestPlatforms.tvOS)] [Fact] public static void EnsureInitialized_SimpleRefTypes() { @@ -417,7 +416,6 @@ public static void EnsureInitialized_SimpleRefTypes() Assert.Equal(strTemplate, d); } - [ActiveIssue("https://github.com/dotnet/runtime/issues/105251", TestPlatforms.tvOS)] [Fact] public static void EnsureInitialized_SimpleRefTypes_Invalid() { @@ -430,7 +428,6 @@ public static void EnsureInitialized_SimpleRefTypes_Invalid() Assert.Throws(() => LazyInitializer.EnsureInitialized(ref ndc)); } - [ActiveIssue("https://github.com/dotnet/runtime/issues/105251", TestPlatforms.tvOS)] [Fact] public static void EnsureInitialized_ComplexRefTypes() { @@ -487,7 +484,6 @@ public static void EnsureInitialized_ComplexRefTypes() Assert.Null(LazyInitializer.EnsureInitialized(ref e, ref einit, ref elock, () => { initCount++; return null; })); } - [ActiveIssue("https://github.com/dotnet/runtime/issues/105251", TestPlatforms.tvOS)] [Fact] public static void EnsureInitialized_ComplexRefTypes_Invalid() { @@ -498,7 +494,6 @@ public static void EnsureInitialized_ComplexRefTypes_Invalid() Assert.Throws(() => LazyInitializer.EnsureInitialized(ref ndc, ref ndcInit, ref ndcLock)); } - [ActiveIssue("https://github.com/dotnet/runtime/issues/105251", TestPlatforms.tvOS)] [Fact] public static void LazyInitializerComplexValueTypes() { @@ -553,7 +548,6 @@ public static void Ctor_Value_ValueType() VerifyLazy(lazyObject, 123, hasValue: true, isValueCreated: true); } - [ActiveIssue("https://github.com/dotnet/runtime/issues/105251", TestPlatforms.tvOS)] [Fact] public static void EnsureInitialized_FuncInitializationWithoutTrackingBool_Uninitialized() { @@ -565,7 +559,6 @@ public static void EnsureInitialized_FuncInitializationWithoutTrackingBool_Unini Assert.NotNull(syncLock); } - [ActiveIssue("https://github.com/dotnet/runtime/issues/105251", TestPlatforms.tvOS)] [Fact] public static void EnsureInitialized_FuncInitializationWithoutTrackingBool_Initialized() { @@ -577,7 +570,6 @@ public static void EnsureInitialized_FuncInitializationWithoutTrackingBool_Initi Assert.Null(syncLock); } - [ActiveIssue("https://github.com/dotnet/runtime/issues/105251", TestPlatforms.tvOS)] [Fact] public static void EnsureInitializer_FuncInitializationWithoutTrackingBool_Null() { diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/StringTests.cs b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/StringTests.cs index a6e16e2fce3..230ede85d79 100644 --- a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/StringTests.cs +++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/StringTests.cs @@ -333,7 +333,6 @@ public static IEnumerable Contains_String_StringComparison_TestData() [Theory] [MemberData(nameof(Contains_String_StringComparison_TestData))] - [ActiveIssue("https://github.com/dotnet/runtime/issues/95473", typeof(PlatformDetection), nameof(PlatformDetection.IsHybridGlobalizationOnBrowser))] public static void Contains_String_StringComparison(string s, string value, StringComparison comparisonType, bool expected) { Assert.Equal(expected, s.Contains(value, comparisonType)); @@ -782,17 +781,21 @@ public static IEnumerable Replace_StringComparison_TestData() { yield return new object[] { "abc", "abc" + SoftHyphen, "def", StringComparison.InvariantCultureIgnoreCase, "def" }; - string turkishSource = "\u0069\u0130"; + // https://github.com/dotnet/runtime/issues/95503 + if (!PlatformDetection.IsHybridGlobalizationOnBrowser) + { + string turkishSource = "\u0069\u0130"; - yield return new object[] { turkishSource, "\u0069", "a", StringComparison.Ordinal, "a\u0130" }; - yield return new object[] { turkishSource, "\u0069", "a", StringComparison.OrdinalIgnoreCase, "a\u0130" }; - yield return new object[] { turkishSource, "\u0130", "a", StringComparison.Ordinal, "\u0069a" }; - yield return new object[] { turkishSource, "\u0130", "a", StringComparison.OrdinalIgnoreCase, "\u0069a" }; + yield return new object[] { turkishSource, "\u0069", "a", StringComparison.Ordinal, "a\u0130" }; + yield return new object[] { turkishSource, "\u0069", "a", StringComparison.OrdinalIgnoreCase, "a\u0130" }; + yield return new object[] { turkishSource, "\u0130", "a", StringComparison.Ordinal, "\u0069a" }; + yield return new object[] { turkishSource, "\u0130", "a", StringComparison.OrdinalIgnoreCase, "\u0069a" }; - yield return new object[] { turkishSource, "\u0069", "a", StringComparison.InvariantCulture, "a\u0130" }; - yield return new object[] { turkishSource, "\u0069", "a", StringComparison.InvariantCultureIgnoreCase, "a\u0130" }; - yield return new object[] { turkishSource, "\u0130", "a", StringComparison.InvariantCulture, "\u0069a" }; - yield return new object[] { turkishSource, "\u0130", "a", StringComparison.InvariantCultureIgnoreCase, "\u0069a" }; + yield return new object[] { turkishSource, "\u0069", "a", StringComparison.InvariantCulture, "a\u0130" }; + yield return new object[] { turkishSource, "\u0069", "a", StringComparison.InvariantCultureIgnoreCase, "a\u0130" }; + yield return new object[] { turkishSource, "\u0130", "a", StringComparison.InvariantCulture, "\u0069a" }; + yield return new object[] { turkishSource, "\u0130", "a", StringComparison.InvariantCultureIgnoreCase, "\u0069a" }; + } } // To catch regressions when dealing with zero-length "this" inputs @@ -801,16 +804,14 @@ public static IEnumerable Replace_StringComparison_TestData() yield return new object[] { "", "\0", "y", StringComparison.InvariantCulture, "" }; } - [Theory] - [MemberData(nameof(Replace_StringComparison_TestData))] - [ActiveIssue("https://github.com/dotnet/runtime/issues/95503", typeof(PlatformDetection), nameof(PlatformDetection.IsHybridGlobalizationOnBrowser))] - [ActiveIssue("https://github.com/dotnet/runtime/issues/95473", typeof(PlatformDetection), nameof(PlatformDetection.IsHybridGlobalizationOnBrowser))] + [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNotHybridGlobalizationOnBrowser), nameof(PlatformDetection.IsNotHybridGlobalizationOnApplePlatform))] + [MemberData(nameof(Replace_StringComparison_TestData))] public void Replace_StringComparison_ReturnsExpected(string original, string oldValue, string newValue, StringComparison comparisonType, string expected) { Assert.Equal(expected, original.Replace(oldValue, newValue, comparisonType)); } - [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization), nameof(PlatformDetection.IsNotHybridGlobalizationOnApplePlatform))] [ActiveIssue("https://github.com/dotnet/runtime/issues/60568", TestPlatforms.Android | TestPlatforms.LinuxBionic)] [ActiveIssue("https://github.com/dotnet/runtime/issues/95503", typeof(PlatformDetection), nameof(PlatformDetection.IsHybridGlobalizationOnBrowser))] public void Replace_StringComparison_TurkishI() @@ -870,7 +871,7 @@ public static IEnumerable Replace_StringComparisonCulture_TestData() } } - [Theory] + [ConditionalTheory(typeof(PlatformDetection), nameof(PlatformDetection.IsNotHybridGlobalizationOnApplePlatform))] [MemberData(nameof(Replace_StringComparisonCulture_TestData))] [ActiveIssue("https://github.com/dotnet/runtime/issues/95503", typeof(PlatformDetection), nameof(PlatformDetection.IsHybridGlobalizationOnBrowser))] public void Replace_StringComparisonCulture_ReturnsExpected(string original, string oldValue, string newValue, bool ignoreCase, CultureInfo culture, string expected) @@ -896,7 +897,7 @@ public void Replace_StringComparison_EmptyOldValue_ThrowsArgumentException() AssertExtensions.Throws("oldValue", () => "abc".Replace("", "def", true, CultureInfo.CurrentCulture)); } - [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization), nameof(PlatformDetection.IsNotHybridGlobalizationOnBrowser), nameof(PlatformDetection.IsNotHybridGlobalizationOnApplePlatform))] public void Replace_StringComparison_WeightlessOldValue_WithOrdinalComparison_Succeeds() { Assert.Equal("abcdef", ("abc" + ZeroWidthJoiner).Replace(ZeroWidthJoiner, "def")); @@ -904,7 +905,7 @@ public void Replace_StringComparison_WeightlessOldValue_WithOrdinalComparison_Su Assert.Equal("abcdef", ("abc" + ZeroWidthJoiner).Replace(ZeroWidthJoiner, "def", StringComparison.OrdinalIgnoreCase)); } - [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization))] + [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.IsNotInvariantGlobalization), nameof(PlatformDetection.IsNotHybridGlobalizationOnBrowser), nameof(PlatformDetection.IsNotHybridGlobalizationOnApplePlatform))] public void Replace_StringComparison_WeightlessOldValue_WithLinguisticComparison_TerminatesReplacement() { Assert.Equal("abc" + ZeroWidthJoiner + "def", ("abc" + ZeroWidthJoiner + "def").Replace(ZeroWidthJoiner, "xyz", StringComparison.CurrentCulture)); diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/TimeZoneInfoTests.cs b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/TimeZoneInfoTests.cs index 2ff5d459fdb..6489a44ac0e 100644 --- a/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/TimeZoneInfoTests.cs +++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/System/TimeZoneInfoTests.cs @@ -3169,7 +3169,7 @@ public static void AdjustmentRuleBaseUtcOffsetDeltaTest() Assert.Equal(new TimeSpan(2, 0, 0), customTimeZone.GetUtcOffset(new DateTime(2021, 3, 10, 2, 0, 0))); } - [Fact] + [ConditionalFact] [ActiveIssue("https://github.com/dotnet/runtime/issues/64111", TestPlatforms.Linux)] public static void NoBackwardTimeZones() { diff --git a/src/libraries/System.Runtime/tests/System.Runtime.Tests/TrimmingTests/System.Runtime.TrimmingTests.proj b/src/libraries/System.Runtime/tests/System.Runtime.Tests/TrimmingTests/System.Runtime.TrimmingTests.proj index a5c28926b27..ac7ab0c6022 100644 --- a/src/libraries/System.Runtime/tests/System.Runtime.Tests/TrimmingTests/System.Runtime.TrimmingTests.proj +++ b/src/libraries/System.Runtime/tests/System.Runtime.Tests/TrimmingTests/System.Runtime.TrimmingTests.proj @@ -24,7 +24,9 @@ DebuggerSupport - + + _DefaultValueAttributeSupport + diff --git a/src/libraries/System.Security.AccessControl/System.Security.AccessControl.sln b/src/libraries/System.Security.AccessControl/System.Security.AccessControl.sln index 4a8661378ce..8ca1cf3e108 100644 --- a/src/libraries/System.Security.AccessControl/System.Security.AccessControl.sln +++ b/src/libraries/System.Security.AccessControl/System.Security.AccessControl.sln @@ -9,6 +9,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.IO.FileSystem.Access EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{3CA4B29C-71BF-4709-8DA4-E1466A80FDB1}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{E4331304-3DDF-40A7-95A4-B2E94AF12842}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{AABA6C21-1DC9-471F-979E-F35930A106F3}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{CDB32066-5BD2-46EB-AFF1-07554FBF6942}" @@ -77,6 +79,10 @@ Global {3CA4B29C-71BF-4709-8DA4-E1466A80FDB1}.Debug|Any CPU.Build.0 = Debug|Any CPU {3CA4B29C-71BF-4709-8DA4-E1466A80FDB1}.Release|Any CPU.ActiveCfg = Release|Any CPU {3CA4B29C-71BF-4709-8DA4-E1466A80FDB1}.Release|Any CPU.Build.0 = Release|Any CPU + {E4331304-3DDF-40A7-95A4-B2E94AF12842}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E4331304-3DDF-40A7-95A4-B2E94AF12842}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E4331304-3DDF-40A7-95A4-B2E94AF12842}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E4331304-3DDF-40A7-95A4-B2E94AF12842}.Release|Any CPU.Build.0 = Release|Any CPU {AABA6C21-1DC9-471F-979E-F35930A106F3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {AABA6C21-1DC9-471F-979E-F35930A106F3}.Debug|Any CPU.Build.0 = Debug|Any CPU {AABA6C21-1DC9-471F-979E-F35930A106F3}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -145,6 +151,7 @@ Global {28ACBF6E-C0FF-46BE-B9C0-0FA1AE05C340} = {5A0B73BB-E1B6-4034-AA56-A82762FD405F} {E1E671BC-A82F-400A-9C93-ACB199A43BDA} = {5A0B73BB-E1B6-4034-AA56-A82762FD405F} {3CA4B29C-71BF-4709-8DA4-E1466A80FDB1} = {82996086-0F1B-4E0F-9121-07C396EF0EC7} + {E4331304-3DDF-40A7-95A4-B2E94AF12842} = {82996086-0F1B-4E0F-9121-07C396EF0EC7} {AABA6C21-1DC9-471F-979E-F35930A106F3} = {82996086-0F1B-4E0F-9121-07C396EF0EC7} {CDB32066-5BD2-46EB-AFF1-07554FBF6942} = {82996086-0F1B-4E0F-9121-07C396EF0EC7} {81E36AA4-93BB-4BB9-9AB5-C8BBAE2FD7C3} = {E740D6D1-02CB-4842-A440-025C08D5BFB1} diff --git a/src/libraries/System.Security.Claims/System.Security.Claims.sln b/src/libraries/System.Security.Claims/System.Security.Claims.sln index 21279bc42e5..53dd7e12b63 100644 --- a/src/libraries/System.Security.Claims/System.Security.Claims.sln +++ b/src/libraries/System.Security.Claims/System.Security.Claims.sln @@ -1,7 +1,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{74402B68-53BF-4B2F-BDEA-91F665E130D2}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{9CE6E82B-D921-40A2-AD3B-783EBABBC233}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{1A4C0030-178C-4141-8725-9A8E553C6143}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{C2E2876D-4DE3-45D2-A8B5-09D01CD080A4}" EndProject @@ -49,10 +49,10 @@ Global {74402B68-53BF-4B2F-BDEA-91F665E130D2}.Debug|Any CPU.Build.0 = Debug|Any CPU {74402B68-53BF-4B2F-BDEA-91F665E130D2}.Release|Any CPU.ActiveCfg = Release|Any CPU {74402B68-53BF-4B2F-BDEA-91F665E130D2}.Release|Any CPU.Build.0 = Release|Any CPU - {9CE6E82B-D921-40A2-AD3B-783EBABBC233}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {9CE6E82B-D921-40A2-AD3B-783EBABBC233}.Debug|Any CPU.Build.0 = Debug|Any CPU - {9CE6E82B-D921-40A2-AD3B-783EBABBC233}.Release|Any CPU.ActiveCfg = Release|Any CPU - {9CE6E82B-D921-40A2-AD3B-783EBABBC233}.Release|Any CPU.Build.0 = Release|Any CPU + {1A4C0030-178C-4141-8725-9A8E553C6143}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {1A4C0030-178C-4141-8725-9A8E553C6143}.Debug|Any CPU.Build.0 = Debug|Any CPU + {1A4C0030-178C-4141-8725-9A8E553C6143}.Release|Any CPU.ActiveCfg = Release|Any CPU + {1A4C0030-178C-4141-8725-9A8E553C6143}.Release|Any CPU.Build.0 = Release|Any CPU {C2E2876D-4DE3-45D2-A8B5-09D01CD080A4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {C2E2876D-4DE3-45D2-A8B5-09D01CD080A4}.Debug|Any CPU.Build.0 = Debug|Any CPU {C2E2876D-4DE3-45D2-A8B5-09D01CD080A4}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -100,7 +100,7 @@ Global GlobalSection(NestedProjects) = preSolution {74402B68-53BF-4B2F-BDEA-91F665E130D2} = {58661765-A62B-4A5F-9950-A56DEFC0CDB0} {12F9C4AA-F238-42A1-9324-2C3CB643595B} = {58661765-A62B-4A5F-9950-A56DEFC0CDB0} - {9CE6E82B-D921-40A2-AD3B-783EBABBC233} = {66B48EC0-590C-40BD-A4E3-DB7DBA977B47} + {1A4C0030-178C-4141-8725-9A8E553C6143} = {66B48EC0-590C-40BD-A4E3-DB7DBA977B47} {C2E2876D-4DE3-45D2-A8B5-09D01CD080A4} = {66B48EC0-590C-40BD-A4E3-DB7DBA977B47} {DC408DFF-3507-4384-ADC8-5DEB268C71C5} = {3B6EF051-7EB4-454F-ACA8-AEF258B645E4} {DBBE28DA-7239-4C32-8308-2A65C10410DE} = {3B6EF051-7EB4-454F-ACA8-AEF258B645E4} diff --git a/src/libraries/System.Security.Cryptography.Cng/tests/RSACngProvider.cs b/src/libraries/System.Security.Cryptography.Cng/tests/RSACngProvider.cs index d41df34b614..025bbc426a4 100644 --- a/src/libraries/System.Security.Cryptography.Cng/tests/RSACngProvider.cs +++ b/src/libraries/System.Security.Cryptography.Cng/tests/RSACngProvider.cs @@ -37,6 +37,8 @@ public bool Supports384PrivateKey public bool SupportsSha1Signatures => true; + public bool SupportsMd5Signatures => true; + public bool SupportsSha3 { get; } = SHA3_256.IsSupported; // If SHA3_256 is supported, assume 384 and 512 are, too. } diff --git a/src/libraries/System.Security.Cryptography.Cose/Directory.Build.props b/src/libraries/System.Security.Cryptography.Cose/Directory.Build.props index c4db04cc6c2..d13e60dc1f0 100644 --- a/src/libraries/System.Security.Cryptography.Cose/Directory.Build.props +++ b/src/libraries/System.Security.Cryptography.Cose/Directory.Build.props @@ -2,6 +2,6 @@ true - browser + browser;wasi diff --git a/src/libraries/System.Security.Cryptography.Cose/System.Security.Cryptography.Cose.sln b/src/libraries/System.Security.Cryptography.Cose/System.Security.Cryptography.Cose.sln index 7635671370b..50e108849f8 100644 --- a/src/libraries/System.Security.Cryptography.Cose/System.Security.Cryptography.Cose.sln +++ b/src/libraries/System.Security.Cryptography.Cose/System.Security.Cryptography.Cose.sln @@ -5,7 +5,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Formats.Cbor", "..\S EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Formats.Cbor", "..\System.Formats.Cbor\src\System.Formats.Cbor.csproj", "{0CB3F6B0-353E-47E4-8A62-AFA6115EF789}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{02892B95-D329-4428-B5DC-63AE65D4DB75}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{F2CFC427-6320-482F-9F85-1F1B14D99B5A}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{64D2E763-9717-4CE9-8500-6E6B0CF358F2}" EndProject @@ -59,10 +59,10 @@ Global {0CB3F6B0-353E-47E4-8A62-AFA6115EF789}.Debug|Any CPU.Build.0 = Debug|Any CPU {0CB3F6B0-353E-47E4-8A62-AFA6115EF789}.Release|Any CPU.ActiveCfg = Release|Any CPU {0CB3F6B0-353E-47E4-8A62-AFA6115EF789}.Release|Any CPU.Build.0 = Release|Any CPU - {02892B95-D329-4428-B5DC-63AE65D4DB75}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {02892B95-D329-4428-B5DC-63AE65D4DB75}.Debug|Any CPU.Build.0 = Debug|Any CPU - {02892B95-D329-4428-B5DC-63AE65D4DB75}.Release|Any CPU.ActiveCfg = Release|Any CPU - {02892B95-D329-4428-B5DC-63AE65D4DB75}.Release|Any CPU.Build.0 = Release|Any CPU + {F2CFC427-6320-482F-9F85-1F1B14D99B5A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F2CFC427-6320-482F-9F85-1F1B14D99B5A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F2CFC427-6320-482F-9F85-1F1B14D99B5A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F2CFC427-6320-482F-9F85-1F1B14D99B5A}.Release|Any CPU.Build.0 = Release|Any CPU {64D2E763-9717-4CE9-8500-6E6B0CF358F2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {64D2E763-9717-4CE9-8500-6E6B0CF358F2}.Debug|Any CPU.Build.0 = Debug|Any CPU {64D2E763-9717-4CE9-8500-6E6B0CF358F2}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -110,7 +110,7 @@ Global {823EE247-FC47-444F-B9A0-32AF146D1789} = {5F962CC3-0DD0-4428-9CF4-99035553DB85} {0CB3F6B0-353E-47E4-8A62-AFA6115EF789} = {29B55087-85A2-4FCE-8303-8EE6B43B0094} {CD19385A-1EDD-45DD-B4E4-BD1F2047BB2B} = {29B55087-85A2-4FCE-8303-8EE6B43B0094} - {02892B95-D329-4428-B5DC-63AE65D4DB75} = {A1DDBD83-25B1-44F6-93A9-AB27A9710FD6} + {F2CFC427-6320-482F-9F85-1F1B14D99B5A} = {A1DDBD83-25B1-44F6-93A9-AB27A9710FD6} {64D2E763-9717-4CE9-8500-6E6B0CF358F2} = {A1DDBD83-25B1-44F6-93A9-AB27A9710FD6} {CB705A03-FEA1-49CB-B761-00C9B0015B3B} = {2A29EADE-6EC8-4C66-88AF-54848E5DEE49} {5B5A7E1B-1EB5-448A-A539-22E78C8DCA12} = {2A29EADE-6EC8-4C66-88AF-54848E5DEE49} diff --git a/src/libraries/System.Security.Cryptography.Csp/tests/RSACryptoServiceProviderBackCompat.cs b/src/libraries/System.Security.Cryptography.Csp/tests/RSACryptoServiceProviderBackCompat.cs index 887bdc3d983..8ef0c9474d7 100644 --- a/src/libraries/System.Security.Cryptography.Csp/tests/RSACryptoServiceProviderBackCompat.cs +++ b/src/libraries/System.Security.Cryptography.Csp/tests/RSACryptoServiceProviderBackCompat.cs @@ -156,9 +156,12 @@ public static void VerifyLegacySignVerifyHash(bool useLegacySign, bool useLegacy public static IEnumerable AlgorithmIdentifiers() { - yield return new object[] { "MD5", MD5.Create() }; - yield return new object[] { "MD5", typeof(MD5) }; - yield return new object[] { "MD5", "1.2.840.113549.2.5" }; + if (RSAFactory.SupportsMd5Signatures) + { + yield return new object[] { "MD5", MD5.Create() }; + yield return new object[] { "MD5", typeof(MD5) }; + yield return new object[] { "MD5", "1.2.840.113549.2.5" }; + } if (RSAFactory.SupportsSha1Signatures) { diff --git a/src/libraries/System.Security.Cryptography.Csp/tests/RSACryptoServiceProviderProvider.cs b/src/libraries/System.Security.Cryptography.Csp/tests/RSACryptoServiceProviderProvider.cs index 7cd358cd5d1..fb40b5ece1d 100644 --- a/src/libraries/System.Security.Cryptography.Csp/tests/RSACryptoServiceProviderProvider.cs +++ b/src/libraries/System.Security.Cryptography.Csp/tests/RSACryptoServiceProviderProvider.cs @@ -9,6 +9,7 @@ namespace System.Security.Cryptography.Rsa.Tests public class RSACryptoServiceProviderProvider : IRSAProvider { private bool? _supportsSha1Signatures; + private bool? _supportsMd5Signatures; public RSA Create() => new RSACryptoServiceProvider(); @@ -23,6 +24,7 @@ public class RSACryptoServiceProviderProvider : IRSAProvider public bool SupportsPss => false; public bool SupportsSha1Signatures => _supportsSha1Signatures ??= SignatureSupport.CanProduceSha1Signature(Create()); + public bool SupportsMd5Signatures => _supportsMd5Signatures ??= SignatureSupport.CanProduceMd5Signature(Create()); public bool SupportsSha3 => false; } diff --git a/src/libraries/System.Security.Cryptography.OpenSsl/tests/EcDsaOpenSslProvider.cs b/src/libraries/System.Security.Cryptography.OpenSsl/tests/EcDsaOpenSslProvider.cs index aac122ce56d..4735038ec01 100644 --- a/src/libraries/System.Security.Cryptography.OpenSsl/tests/EcDsaOpenSslProvider.cs +++ b/src/libraries/System.Security.Cryptography.OpenSsl/tests/EcDsaOpenSslProvider.cs @@ -50,7 +50,7 @@ public bool ExplicitCurvesSupported { get { - return true; + return !PlatformDetection.IsAzureLinux; } } } diff --git a/src/libraries/System.Security.Cryptography.OpenSsl/tests/RSAOpenSslProvider.cs b/src/libraries/System.Security.Cryptography.OpenSsl/tests/RSAOpenSslProvider.cs index 0adcda4bfad..18aa9528877 100644 --- a/src/libraries/System.Security.Cryptography.OpenSsl/tests/RSAOpenSslProvider.cs +++ b/src/libraries/System.Security.Cryptography.OpenSsl/tests/RSAOpenSslProvider.cs @@ -8,6 +8,7 @@ namespace System.Security.Cryptography.Rsa.Tests public class RSAOpenSslProvider : IRSAProvider { private bool? _supportsSha1Signatures; + private bool? _supportsMd5Signatures; public RSA Create() => new RSAOpenSsl(); @@ -22,6 +23,7 @@ public class RSAOpenSslProvider : IRSAProvider public bool SupportsPss => true; public bool SupportsSha1Signatures => _supportsSha1Signatures ??= SignatureSupport.CanProduceSha1Signature(Create()); + public bool SupportsMd5Signatures => _supportsMd5Signatures ??= SignatureSupport.CanProduceMd5Signature(Create()); public bool SupportsSha3 => SHA3_256.IsSupported; // If SHA3_256 is supported, assume 384 and 512 are, too. } diff --git a/src/libraries/System.Security.Cryptography.Pkcs/Directory.Build.props b/src/libraries/System.Security.Cryptography.Pkcs/Directory.Build.props index 1f799d605fe..e3cd1bcddea 100644 --- a/src/libraries/System.Security.Cryptography.Pkcs/Directory.Build.props +++ b/src/libraries/System.Security.Cryptography.Pkcs/Directory.Build.props @@ -3,6 +3,6 @@ Microsoft true - browser + browser;wasi diff --git a/src/libraries/System.Security.Cryptography.Pkcs/System.Security.Cryptography.Pkcs.sln b/src/libraries/System.Security.Cryptography.Pkcs/System.Security.Cryptography.Pkcs.sln index 4b9e37d8e3e..d56cd07f544 100644 --- a/src/libraries/System.Security.Cryptography.Pkcs/System.Security.Cryptography.Pkcs.sln +++ b/src/libraries/System.Security.Cryptography.Pkcs/System.Security.Cryptography.Pkcs.sln @@ -11,6 +11,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Formats.Asn1", "..\S EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{E44D1459-E2A0-4AF7-A392-1E8F86F64DB5}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{D0D284A9-9F15-4DC0-A99A-86B5FCD3C144}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{97CE28DB-B4AC-400B-A40D-C55789FCA0AB}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{E44D1E0E-5F76-41B8-AF5F-6112BCC6A39B}" @@ -81,6 +83,10 @@ Global {E44D1459-E2A0-4AF7-A392-1E8F86F64DB5}.Debug|Any CPU.Build.0 = Debug|Any CPU {E44D1459-E2A0-4AF7-A392-1E8F86F64DB5}.Release|Any CPU.ActiveCfg = Release|Any CPU {E44D1459-E2A0-4AF7-A392-1E8F86F64DB5}.Release|Any CPU.Build.0 = Release|Any CPU + {D0D284A9-9F15-4DC0-A99A-86B5FCD3C144}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D0D284A9-9F15-4DC0-A99A-86B5FCD3C144}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D0D284A9-9F15-4DC0-A99A-86B5FCD3C144}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D0D284A9-9F15-4DC0-A99A-86B5FCD3C144}.Release|Any CPU.Build.0 = Release|Any CPU {97CE28DB-B4AC-400B-A40D-C55789FCA0AB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {97CE28DB-B4AC-400B-A40D-C55789FCA0AB}.Debug|Any CPU.Build.0 = Debug|Any CPU {97CE28DB-B4AC-400B-A40D-C55789FCA0AB}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -145,6 +151,7 @@ Global {484170AD-D47A-4B56-B13C-93F387958510} = {FD768C8B-9BF1-4F02-A2C4-335B22615763} {1AFD2D0A-B962-449B-AC3B-12ED1F439E91} = {FD768C8B-9BF1-4F02-A2C4-335B22615763} {E44D1459-E2A0-4AF7-A392-1E8F86F64DB5} = {94B59232-B99C-4224-B3E3-0F3385F06B64} + {D0D284A9-9F15-4DC0-A99A-86B5FCD3C144} = {94B59232-B99C-4224-B3E3-0F3385F06B64} {97CE28DB-B4AC-400B-A40D-C55789FCA0AB} = {94B59232-B99C-4224-B3E3-0F3385F06B64} {E44D1E0E-5F76-41B8-AF5F-6112BCC6A39B} = {94B59232-B99C-4224-B3E3-0F3385F06B64} {A02E5C2B-BB8A-45CE-9898-106B3DE4731C} = {C291910F-A44F-4EB0-BFFD-972D92FA632E} diff --git a/src/libraries/System.Security.Cryptography.Pkcs/src/System.Security.Cryptography.Pkcs.csproj b/src/libraries/System.Security.Cryptography.Pkcs/src/System.Security.Cryptography.Pkcs.csproj index ae55225a3a5..52ff65a46de 100644 --- a/src/libraries/System.Security.Cryptography.Pkcs/src/System.Security.Cryptography.Pkcs.csproj +++ b/src/libraries/System.Security.Cryptography.Pkcs/src/System.Security.Cryptography.Pkcs.csproj @@ -651,7 +651,7 @@ System.Security.Cryptography.Pkcs.EnvelopedCms - + diff --git a/src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/SignerInfo.cs b/src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/SignerInfo.cs index 46b6fc056e4..383b9ddc301 100644 --- a/src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/SignerInfo.cs +++ b/src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/SignerInfo.cs @@ -653,7 +653,15 @@ private bool CheckHash(bool compatMode) { writer.PopSetOf(); +#if NET9_0_OR_GREATER + writer.Encode(hasher, static (hasher, encoded) => + { + hasher.AppendData(encoded); + return (object?)null; + }); +#else hasher.AppendData(writer.Encode()); +#endif } } } diff --git a/src/libraries/System.Security.Cryptography.Pkcs/tests/Pkcs12/KeyBagTests.cs b/src/libraries/System.Security.Cryptography.Pkcs/tests/Pkcs12/KeyBagTests.cs index 2a3ba970c01..071a210c79d 100644 --- a/src/libraries/System.Security.Cryptography.Pkcs/tests/Pkcs12/KeyBagTests.cs +++ b/src/libraries/System.Security.Cryptography.Pkcs/tests/Pkcs12/KeyBagTests.cs @@ -29,7 +29,7 @@ public static void BuildWithFactoryReadDirect() Assert.True(rsa2.TrySignData( keyBag.Pkcs8PrivateKey.Span, sig, - HashAlgorithmName.MD5, + HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1, out int sigLen)); @@ -38,7 +38,7 @@ public static void BuildWithFactoryReadDirect() Assert.True(rsa.VerifyData( keyBag.Pkcs8PrivateKey.Span, sig, - HashAlgorithmName.MD5, + HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1)); } } diff --git a/src/libraries/System.Security.Cryptography.Pkcs/tests/Pkcs12/ShroudedKeyBagTests.cs b/src/libraries/System.Security.Cryptography.Pkcs/tests/Pkcs12/ShroudedKeyBagTests.cs index b2141a822c2..aebe413b357 100644 --- a/src/libraries/System.Security.Cryptography.Pkcs/tests/Pkcs12/ShroudedKeyBagTests.cs +++ b/src/libraries/System.Security.Cryptography.Pkcs/tests/Pkcs12/ShroudedKeyBagTests.cs @@ -40,7 +40,7 @@ public static void BuildWithCharsFactoryReadDirect() Assert.True(rsa2.TrySignData( keyBag.EncryptedPkcs8PrivateKey.Span, sig, - HashAlgorithmName.MD5, + HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1, out int sigLen)); @@ -49,7 +49,7 @@ public static void BuildWithCharsFactoryReadDirect() Assert.True(rsa.VerifyData( keyBag.EncryptedPkcs8PrivateKey.Span, sig, - HashAlgorithmName.MD5, + HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1)); } } @@ -77,7 +77,7 @@ public static void BuildWithBytesFactoryReadDirect() Assert.True(rsa2.TrySignData( keyBag.EncryptedPkcs8PrivateKey.Span, sig, - HashAlgorithmName.MD5, + HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1, out int sigLen)); @@ -86,7 +86,7 @@ public static void BuildWithBytesFactoryReadDirect() Assert.True(rsa.VerifyData( keyBag.EncryptedPkcs8PrivateKey.Span, sig, - HashAlgorithmName.MD5, + HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1)); } } diff --git a/src/libraries/System.Security.Cryptography.Pkcs/tests/SignatureSupport.cs b/src/libraries/System.Security.Cryptography.Pkcs/tests/SignatureSupport.cs index ee31485341c..5e317d841cf 100644 --- a/src/libraries/System.Security.Cryptography.Pkcs/tests/SignatureSupport.cs +++ b/src/libraries/System.Security.Cryptography.Pkcs/tests/SignatureSupport.cs @@ -10,5 +10,8 @@ public class SignatureSupport { public static bool SupportsRsaSha1Signatures { get; } = System.Security.Cryptography.Tests.SignatureSupport.CanProduceSha1Signature(RSA.Create()); + + public static bool SupportsRsaMd5Signatures { get; } = + System.Security.Cryptography.Tests.SignatureSupport.CanProduceMd5Signature(RSA.Create()); } } diff --git a/src/libraries/System.Security.Cryptography.Pkcs/tests/SignedCms/SignerInfoTests.cs b/src/libraries/System.Security.Cryptography.Pkcs/tests/SignedCms/SignerInfoTests.cs index 37d8b29ddc5..bc000918a00 100644 --- a/src/libraries/System.Security.Cryptography.Pkcs/tests/SignedCms/SignerInfoTests.cs +++ b/src/libraries/System.Security.Cryptography.Pkcs/tests/SignedCms/SignerInfoTests.cs @@ -198,7 +198,7 @@ public static void CheckSignature_ExtraStore_IsAdditional() signer.CheckSignature(new X509Certificate2Collection(), true); } - [Fact] + [ConditionalFact(typeof(SignatureSupport), nameof(SignatureSupport.SupportsRsaMd5Signatures))] public static void CheckSignature_MD5WithRSA() { SignedCms cms = new SignedCms(); diff --git a/src/libraries/System.Security.Cryptography.ProtectedData/System.Security.Cryptography.ProtectedData.sln b/src/libraries/System.Security.Cryptography.ProtectedData/System.Security.Cryptography.ProtectedData.sln index f3a807ef407..621c22cae6d 100644 --- a/src/libraries/System.Security.Cryptography.ProtectedData/System.Security.Cryptography.ProtectedData.sln +++ b/src/libraries/System.Security.Cryptography.ProtectedData/System.Security.Cryptography.ProtectedData.sln @@ -1,7 +1,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{21CC9F35-ACAA-4452-BE92-BBAE2E927B20}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{324E33F0-53FB-4DFD-AEDF-64BCFB2F7821}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{3B7C21B9-E961-4002-BADD-93DCCB789E5A}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{D3B40403-2973-45CE-A0A4-97C38CBE86FE}" EndProject @@ -47,10 +47,10 @@ Global {21CC9F35-ACAA-4452-BE92-BBAE2E927B20}.Debug|Any CPU.Build.0 = Debug|Any CPU {21CC9F35-ACAA-4452-BE92-BBAE2E927B20}.Release|Any CPU.ActiveCfg = Release|Any CPU {21CC9F35-ACAA-4452-BE92-BBAE2E927B20}.Release|Any CPU.Build.0 = Release|Any CPU - {324E33F0-53FB-4DFD-AEDF-64BCFB2F7821}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {324E33F0-53FB-4DFD-AEDF-64BCFB2F7821}.Debug|Any CPU.Build.0 = Debug|Any CPU - {324E33F0-53FB-4DFD-AEDF-64BCFB2F7821}.Release|Any CPU.ActiveCfg = Release|Any CPU - {324E33F0-53FB-4DFD-AEDF-64BCFB2F7821}.Release|Any CPU.Build.0 = Release|Any CPU + {3B7C21B9-E961-4002-BADD-93DCCB789E5A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {3B7C21B9-E961-4002-BADD-93DCCB789E5A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {3B7C21B9-E961-4002-BADD-93DCCB789E5A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {3B7C21B9-E961-4002-BADD-93DCCB789E5A}.Release|Any CPU.Build.0 = Release|Any CPU {D3B40403-2973-45CE-A0A4-97C38CBE86FE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {D3B40403-2973-45CE-A0A4-97C38CBE86FE}.Debug|Any CPU.Build.0 = Debug|Any CPU {D3B40403-2973-45CE-A0A4-97C38CBE86FE}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -94,7 +94,7 @@ Global GlobalSection(NestedProjects) = preSolution {21CC9F35-ACAA-4452-BE92-BBAE2E927B20} = {E3C3C868-FBDB-4F07-A72E-F734016C0B3B} {3A6C62D5-EFCA-4119-BC60-C917533848A8} = {E3C3C868-FBDB-4F07-A72E-F734016C0B3B} - {324E33F0-53FB-4DFD-AEDF-64BCFB2F7821} = {6F1E3122-547E-4134-BB45-6E33B880DC34} + {3B7C21B9-E961-4002-BADD-93DCCB789E5A} = {6F1E3122-547E-4134-BB45-6E33B880DC34} {D3B40403-2973-45CE-A0A4-97C38CBE86FE} = {6F1E3122-547E-4134-BB45-6E33B880DC34} {E40DBC0E-386A-4B32-8DCE-9FE13EAD47BE} = {AE1B6C0D-2991-4048-9B81-5683599B0CA4} {7773DB7A-494F-4508-9471-F737FDC7661E} = {87D86F17-7CEB-48DB-99FB-55922ED2A7D1} diff --git a/src/libraries/System.Security.Cryptography.Xml/Directory.Build.props b/src/libraries/System.Security.Cryptography.Xml/Directory.Build.props index c843a6347ce..3a3d8f98324 100644 --- a/src/libraries/System.Security.Cryptography.Xml/Directory.Build.props +++ b/src/libraries/System.Security.Cryptography.Xml/Directory.Build.props @@ -2,6 +2,6 @@ true - browser + browser;wasi \ No newline at end of file diff --git a/src/libraries/System.Security.Cryptography.Xml/System.Security.Cryptography.Xml.sln b/src/libraries/System.Security.Cryptography.Xml/System.Security.Cryptography.Xml.sln index 2fba2d615fa..6d5608e30fb 100644 --- a/src/libraries/System.Security.Cryptography.Xml/System.Security.Cryptography.Xml.sln +++ b/src/libraries/System.Security.Cryptography.Xml/System.Security.Cryptography.Xml.sln @@ -11,6 +11,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Formats.Asn1", "..\S EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{D75C8817-337C-4DDA-B164-F8822787EE19}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{1873F8BA-FE4B-48AD-8FB5-3528D4193483}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{2CE79894-A115-4C92-86E2-7B392EBCBD83}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{B15E7AF8-B446-425F-B22A-619A01DEDA16}" @@ -85,6 +87,10 @@ Global {D75C8817-337C-4DDA-B164-F8822787EE19}.Debug|Any CPU.Build.0 = Debug|Any CPU {D75C8817-337C-4DDA-B164-F8822787EE19}.Release|Any CPU.ActiveCfg = Release|Any CPU {D75C8817-337C-4DDA-B164-F8822787EE19}.Release|Any CPU.Build.0 = Release|Any CPU + {1873F8BA-FE4B-48AD-8FB5-3528D4193483}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {1873F8BA-FE4B-48AD-8FB5-3528D4193483}.Debug|Any CPU.Build.0 = Debug|Any CPU + {1873F8BA-FE4B-48AD-8FB5-3528D4193483}.Release|Any CPU.ActiveCfg = Release|Any CPU + {1873F8BA-FE4B-48AD-8FB5-3528D4193483}.Release|Any CPU.Build.0 = Release|Any CPU {2CE79894-A115-4C92-86E2-7B392EBCBD83}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {2CE79894-A115-4C92-86E2-7B392EBCBD83}.Debug|Any CPU.Build.0 = Debug|Any CPU {2CE79894-A115-4C92-86E2-7B392EBCBD83}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -159,6 +165,7 @@ Global {18882345-4F75-42DB-8DC9-A38AD5C4785E} = {B8C68464-1D28-4889-90BC-BC80B036B90B} {2BB35F95-AD1A-45D3-B8E2-84CC690073A8} = {B8C68464-1D28-4889-90BC-BC80B036B90B} {D75C8817-337C-4DDA-B164-F8822787EE19} = {39704A56-DFD6-4CC6-A7E4-229E639D9611} + {1873F8BA-FE4B-48AD-8FB5-3528D4193483} = {39704A56-DFD6-4CC6-A7E4-229E639D9611} {2CE79894-A115-4C92-86E2-7B392EBCBD83} = {39704A56-DFD6-4CC6-A7E4-229E639D9611} {B15E7AF8-B446-425F-B22A-619A01DEDA16} = {39704A56-DFD6-4CC6-A7E4-229E639D9611} {9B42414B-38AB-4BCB-B694-36FC3D760C1D} = {782D1E7D-9D5B-48B7-A839-D67A69ADD10F} diff --git a/src/libraries/System.Security.Cryptography/System.Security.Cryptography.sln b/src/libraries/System.Security.Cryptography/System.Security.Cryptography.sln index 88248a2d01a..08aad796962 100644 --- a/src/libraries/System.Security.Cryptography/System.Security.Cryptography.sln +++ b/src/libraries/System.Security.Cryptography/System.Security.Cryptography.sln @@ -19,6 +19,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Net.Primitives", ".. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{0EA41D6A-87A2-42B7-8171-78E167570993}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{15E62B3D-68EA-4650-8F95-EF31AAC1BA93}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{9E7AD0F4-0D4D-4E42-8C6C-513C006E0590}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{1B999BF7-657A-4342-A97E-B5CC5916AFB4}" @@ -111,6 +113,10 @@ Global {0EA41D6A-87A2-42B7-8171-78E167570993}.Debug|Any CPU.Build.0 = Debug|Any CPU {0EA41D6A-87A2-42B7-8171-78E167570993}.Release|Any CPU.ActiveCfg = Release|Any CPU {0EA41D6A-87A2-42B7-8171-78E167570993}.Release|Any CPU.Build.0 = Release|Any CPU + {15E62B3D-68EA-4650-8F95-EF31AAC1BA93}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {15E62B3D-68EA-4650-8F95-EF31AAC1BA93}.Debug|Any CPU.Build.0 = Debug|Any CPU + {15E62B3D-68EA-4650-8F95-EF31AAC1BA93}.Release|Any CPU.ActiveCfg = Release|Any CPU + {15E62B3D-68EA-4650-8F95-EF31AAC1BA93}.Release|Any CPU.Build.0 = Release|Any CPU {9E7AD0F4-0D4D-4E42-8C6C-513C006E0590}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {9E7AD0F4-0D4D-4E42-8C6C-513C006E0590}.Debug|Any CPU.Build.0 = Debug|Any CPU {9E7AD0F4-0D4D-4E42-8C6C-513C006E0590}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -194,6 +200,7 @@ Global {258B22AA-ECA6-412E-9F29-6BB6063CD036} = {F591FB6D-6957-46DB-BF9B-C00772BC11E3} {E9BF1F4D-7D5C-4539-B426-2FCCB2585138} = {F591FB6D-6957-46DB-BF9B-C00772BC11E3} {0EA41D6A-87A2-42B7-8171-78E167570993} = {2B165D96-356D-409E-88BE-0CA0F407303E} + {15E62B3D-68EA-4650-8F95-EF31AAC1BA93} = {2B165D96-356D-409E-88BE-0CA0F407303E} {9E7AD0F4-0D4D-4E42-8C6C-513C006E0590} = {2B165D96-356D-409E-88BE-0CA0F407303E} {1B999BF7-657A-4342-A97E-B5CC5916AFB4} = {2B165D96-356D-409E-88BE-0CA0F407303E} {7D70A668-5A55-439F-9FB8-8FF2A850CF91} = {CC457FED-75A7-450C-91C9-F0F4AC6FF4A9} diff --git a/src/libraries/System.Security.Cryptography/src/Resources/Strings.resx b/src/libraries/System.Security.Cryptography/src/Resources/Strings.resx index 630f2f89bc6..412cfbf03a8 100644 --- a/src/libraries/System.Security.Cryptography/src/Resources/Strings.resx +++ b/src/libraries/System.Security.Cryptography/src/Resources/Strings.resx @@ -834,6 +834,9 @@ OpenSSL is required for algorithm '{0}' but could not be found or loaded. + + OpenSSL providers are not supported on this platform. + Access is denied. diff --git a/src/libraries/System.Security.Cryptography/src/System.Security.Cryptography.csproj b/src/libraries/System.Security.Cryptography/src/System.Security.Cryptography.csproj index 0854abbbe06..c609292d405 100644 --- a/src/libraries/System.Security.Cryptography/src/System.Security.Cryptography.csproj +++ b/src/libraries/System.Security.Cryptography/src/System.Security.Cryptography.csproj @@ -418,6 +418,7 @@ + @@ -668,6 +669,7 @@ + @@ -739,6 +741,10 @@ Link="Common\Interop\Unix\System.Security.Cryptography.Native\Interop.EVP.cs" /> + + + + @@ -878,8 +887,9 @@ - + + @@ -1017,6 +1027,7 @@ + @@ -1147,6 +1158,7 @@ + @@ -1738,6 +1750,7 @@ + diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/CngKeyCreationOptions.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/CngKeyCreationOptions.cs index f3f3e7fb423..9a7155b0902 100644 --- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/CngKeyCreationOptions.cs +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/CngKeyCreationOptions.cs @@ -15,8 +15,21 @@ public enum CngKeyCreationOptions : int None = 0x00000000, MachineKey = 0x00000020, // NCRYPT_MACHINE_KEY_FLAG OverwriteExistingKey = 0x00000080, // NCRYPT_OVERWRITE_KEY_FLAG + + /// + /// Indicates a key should be protected with Virtualization-based security (VBS). + /// PreferVbs = 0x00010000, // NCRYPT_PREFER_VBS_FLAG + + /// + /// Indicates a key must be protected with Virtualization-based security (VBS). + /// RequireVbs = 0x00020000, // NCRYPT_REQUIRE_VBS_FLAG + + /// + /// Instructs Virtualization-based security (VBS) to protect the client key with a per-boot key + /// when combined with or . + /// UsePerBootKey = 0x00040000, // NCRYPT_USE_PER_BOOT_KEY_FLAG } } diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HKDF.Managed.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HKDF.Managed.cs new file mode 100644 index 00000000000..e3af79fd8d4 --- /dev/null +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HKDF.Managed.cs @@ -0,0 +1,39 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace System.Security.Cryptography +{ + public static partial class HKDF + { + private static void Extract( + HashAlgorithmName hashAlgorithmName, + int hashLength, + ReadOnlySpan ikm, + ReadOnlySpan salt, + Span prk) + { + HKDFManagedImplementation.Extract(hashAlgorithmName, hashLength, ikm, salt, prk); + } + + private static void Expand( + HashAlgorithmName hashAlgorithmName, + int hashLength, + ReadOnlySpan prk, + Span output, + ReadOnlySpan info) + { + HKDFManagedImplementation.Expand(hashAlgorithmName, hashLength, prk, output, info); + } + + private static void DeriveKeyCore( + HashAlgorithmName hashAlgorithmName, + int hashLength, + ReadOnlySpan ikm, + Span output, + ReadOnlySpan salt, + ReadOnlySpan info) + { + HKDFManagedImplementation.DeriveKey(hashAlgorithmName, hashLength, ikm, output, salt, info); + } + } +} diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HKDF.OpenSsl.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HKDF.OpenSsl.cs new file mode 100644 index 00000000000..9194f144be7 --- /dev/null +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HKDF.OpenSsl.cs @@ -0,0 +1,79 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; + +namespace System.Security.Cryptography +{ + public static partial class HKDF + { + private static readonly bool s_hasOpenSslImplementation = Interop.Crypto.EvpKdfAlgs.Hkdf is not null; + + private static void Extract( + HashAlgorithmName hashAlgorithmName, + int hashLength, + ReadOnlySpan ikm, + ReadOnlySpan salt, + Span prk) + { + if (s_hasOpenSslImplementation) + { + Debug.Assert(Interop.Crypto.EvpKdfAlgs.Hkdf is not null); + Debug.Assert(hashAlgorithmName.Name is not null); + + Interop.Crypto.HkdfExtract(Interop.Crypto.EvpKdfAlgs.Hkdf, ikm, hashAlgorithmName.Name, salt, prk); + } + else + { + HKDFManagedImplementation.Extract(hashAlgorithmName, hashLength, ikm, salt, prk); + } + } + + private static void Expand( + HashAlgorithmName hashAlgorithmName, + int hashLength, + ReadOnlySpan prk, + Span output, + ReadOnlySpan info) + { + if (s_hasOpenSslImplementation) + { + Debug.Assert(Interop.Crypto.EvpKdfAlgs.Hkdf is not null); + Debug.Assert(hashAlgorithmName.Name is not null); + + Interop.Crypto.HkdfExpand(Interop.Crypto.EvpKdfAlgs.Hkdf, prk, hashAlgorithmName.Name, info, output); + } + else + { + HKDFManagedImplementation.Expand(hashAlgorithmName, hashLength, prk, output, info); + } + } + + private static void DeriveKeyCore( + HashAlgorithmName hashAlgorithmName, + int hashLength, + ReadOnlySpan ikm, + Span output, + ReadOnlySpan salt, + ReadOnlySpan info) + { + if (s_hasOpenSslImplementation) + { + Debug.Assert(Interop.Crypto.EvpKdfAlgs.Hkdf is not null); + Debug.Assert(hashAlgorithmName.Name is not null); + + Interop.Crypto.HkdfDeriveKey( + Interop.Crypto.EvpKdfAlgs.Hkdf, + ikm, + hashAlgorithmName.Name, + salt, + info, + output); + } + else + { + HKDFManagedImplementation.DeriveKey(hashAlgorithmName, hashLength, ikm, output, salt, info); + } + } + } +} diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HKDF.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HKDF.cs index 9b33aea297a..f167f18afc2 100644 --- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HKDF.cs +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HKDF.cs @@ -15,7 +15,7 @@ namespace System.Security.Cryptography /// phase to be skipped, and the master key to be used directly as the pseudorandom key. /// See RFC5869 for more information. /// - public static class HKDF + public static partial class HKDF { /// /// Performs the HKDF-Extract function. @@ -23,13 +23,16 @@ public static class HKDF /// /// The hash algorithm used for HMAC operations. /// The input keying material. - /// The optional salt value (a non-secret random value). If not provided it defaults to a byte array of zeros. + /// + /// The optional salt value (a non-secret random value). If not provided it defaults to a + /// byte array of the same length as the output of the specified hash algorithm. + /// /// The pseudo random key (prk). public static byte[] Extract(HashAlgorithmName hashAlgorithmName, byte[] ikm, byte[]? salt = null) { ArgumentNullException.ThrowIfNull(ikm); - int hashLength = HashLength(hashAlgorithmName); + int hashLength = Helpers.HashLength(hashAlgorithmName); byte[] prk = new byte[hashLength]; Extract(hashAlgorithmName, hashLength, ikm, salt, prk); @@ -47,7 +50,7 @@ public static byte[] Extract(HashAlgorithmName hashAlgorithmName, byte[] ikm, by /// The number of bytes written to the buffer. public static int Extract(HashAlgorithmName hashAlgorithmName, ReadOnlySpan ikm, ReadOnlySpan salt, Span prk) { - int hashLength = HashLength(hashAlgorithmName); + int hashLength = Helpers.HashLength(hashAlgorithmName); if (prk.Length < hashLength) { @@ -63,19 +66,15 @@ public static int Extract(HashAlgorithmName hashAlgorithmName, ReadOnlySpan ikm, ReadOnlySpan salt, Span prk) - { - Debug.Assert(HashLength(hashAlgorithmName) == hashLength); - int written = CryptographicOperations.HmacData(hashAlgorithmName, salt, ikm, prk); - Debug.Assert(written == prk.Length, $"Bytes written is {written} bytes which does not match output length ({prk.Length} bytes)"); - } - /// /// Performs the HKDF-Expand function /// See section 2.3 of RFC5869 /// /// The hash algorithm used for HMAC operations. - /// The pseudorandom key of at least bytes (usually the output from Expand step). + /// + /// The pseudorandom key that is at least as long as the output byte array of the specified hash + /// algorithm (usually the output from the Extract step). + /// /// The length of the output keying material. /// The optional context and application specific information. /// The output keying material. @@ -84,10 +83,14 @@ private static void Extract(HashAlgorithmName hashAlgorithmName, int hashLength, public static byte[] Expand(HashAlgorithmName hashAlgorithmName, byte[] prk, int outputLength, byte[]? info = null) { ArgumentNullException.ThrowIfNull(prk); - ArgumentOutOfRangeException.ThrowIfNegativeOrZero(outputLength); - int hashLength = HashLength(hashAlgorithmName); + int hashLength = Helpers.HashLength(hashAlgorithmName); + + if (prk.Length < hashLength) + { + throw new ArgumentException(SR.Format(SR.Cryptography_Prk_TooSmall, hashLength), nameof(prk)); + } // Constant comes from section 2.3 (the constraint on L in the Inputs section) int maxOkmLength = 255 * hashLength; @@ -105,17 +108,23 @@ public static byte[] Expand(HashAlgorithmName hashAlgorithmName, byte[] prk, int /// See section 2.3 of RFC5869 /// /// The hash algorithm used for HMAC operations. - /// The pseudorandom key of at least bytes (usually the output from Expand step). + /// + /// The pseudorandom key that is at least as long as the output byte array of the specified hash + /// algorithm (usually the output from the Extract step). + /// /// The destination buffer to receive the output keying material. /// The context and application specific information (can be an empty span). /// is empty, or is larger than the maximum allowed length. public static void Expand(HashAlgorithmName hashAlgorithmName, ReadOnlySpan prk, Span output, ReadOnlySpan info) { - int hashLength = HashLength(hashAlgorithmName); + int hashLength = Helpers.HashLength(hashAlgorithmName); if (output.Length == 0) throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(output)); + if (prk.Length < hashLength) + throw new ArgumentException(SR.Format(SR.Cryptography_Prk_TooSmall, hashLength), nameof(prk)); + // Constant comes from section 2.3 (the constraint on L in the Inputs section) int maxOkmLength = 255 * hashLength; if (output.Length > maxOkmLength) @@ -124,83 +133,13 @@ public static void Expand(HashAlgorithmName hashAlgorithmName, ReadOnlySpan prk, Span output, ReadOnlySpan info) - { - Debug.Assert(HashLength(hashAlgorithmName) == hashLength); - - if (prk.Length < hashLength) - throw new ArgumentException(SR.Format(SR.Cryptography_Prk_TooSmall, hashLength), nameof(prk)); - - byte counter = 0; - var counterSpan = new Span(ref counter); - Span t = Span.Empty; - Span remainingOutput = output; - - const int MaxStackInfoBuffer = 64; - Span tempInfoBuffer = stackalloc byte[MaxStackInfoBuffer]; - scoped ReadOnlySpan infoBuffer; - byte[]? rentedTempInfoBuffer = null; - - if (output.Overlaps(info)) - { - if (info.Length > MaxStackInfoBuffer) - { - rentedTempInfoBuffer = CryptoPool.Rent(info.Length); - tempInfoBuffer = rentedTempInfoBuffer; - } - - tempInfoBuffer = tempInfoBuffer.Slice(0, info.Length); - info.CopyTo(tempInfoBuffer); - infoBuffer = tempInfoBuffer; - } - else - { - infoBuffer = info; - } - - using (IncrementalHash hmac = IncrementalHash.CreateHMAC(hashAlgorithmName, prk)) - { - for (int i = 1; ; i++) - { - hmac.AppendData(t); - hmac.AppendData(infoBuffer); - counter = (byte)i; - hmac.AppendData(counterSpan); - - if (remainingOutput.Length >= hashLength) - { - t = remainingOutput.Slice(0, hashLength); - remainingOutput = remainingOutput.Slice(hashLength); - GetHashAndReset(hmac, t); - } - else - { - if (remainingOutput.Length > 0) - { - Debug.Assert(hashLength <= 512 / 8, "hashLength is larger than expected, consider increasing this value or using regular allocation"); - Span lastChunk = stackalloc byte[hashLength]; - GetHashAndReset(hmac, lastChunk); - lastChunk.Slice(0, remainingOutput.Length).CopyTo(remainingOutput); - } - - break; - } - } - } - - if (rentedTempInfoBuffer is not null) - { - CryptoPool.Return(rentedTempInfoBuffer, clearSize: info.Length); - } - } - /// /// Performs the key derivation HKDF Expand and Extract functions /// /// The hash algorithm used for HMAC operations. /// The input keying material. /// The length of the output keying material. - /// The optional salt value (a non-secret random value). If not provided it defaults to a byte array of zeros. + /// The optional salt value (a non-secret random value). /// The optional context and application specific information. /// The output keying material. /// is . @@ -211,7 +150,7 @@ public static byte[] DeriveKey(HashAlgorithmName hashAlgorithmName, byte[] ikm, ArgumentOutOfRangeException.ThrowIfNegativeOrZero(outputLength); - int hashLength = HashLength(hashAlgorithmName); + int hashLength = Helpers.HashLength(hashAlgorithmName); Debug.Assert(hashLength <= 512 / 8, "hashLength is larger than expected, consider increasing this value or using regular allocation"); // Constant comes from section 2.3 (the constraint on L in the Inputs section) @@ -219,13 +158,8 @@ public static byte[] DeriveKey(HashAlgorithmName hashAlgorithmName, byte[] ikm, if (outputLength > maxOkmLength) throw new ArgumentOutOfRangeException(nameof(outputLength), SR.Format(SR.Cryptography_Okm_TooLarge, maxOkmLength)); - Span prk = stackalloc byte[hashLength]; - - Extract(hashAlgorithmName, hashLength, ikm, salt, prk); - byte[] result = new byte[outputLength]; - Expand(hashAlgorithmName, hashLength, prk, result, info); - + DeriveKeyCore(hashAlgorithmName, hashLength, ikm, result, salt, info); return result; } @@ -240,7 +174,7 @@ public static byte[] DeriveKey(HashAlgorithmName hashAlgorithmName, byte[] ikm, /// is empty, or is larger than the maximum allowed length. public static void DeriveKey(HashAlgorithmName hashAlgorithmName, ReadOnlySpan ikm, Span output, ReadOnlySpan salt, ReadOnlySpan info) { - int hashLength = HashLength(hashAlgorithmName); + int hashLength = Helpers.HashLength(hashAlgorithmName); if (output.Length == 0) throw new ArgumentException(SR.Argument_DestinationTooShort, nameof(output)); @@ -251,61 +185,7 @@ public static void DeriveKey(HashAlgorithmName hashAlgorithmName, ReadOnlySpan prk = stackalloc byte[hashLength]; - - Extract(hashAlgorithmName, hashLength, ikm, salt, prk); - Expand(hashAlgorithmName, hashLength, prk, output, info); - } - - private static void GetHashAndReset(IncrementalHash hmac, Span output) - { - if (!hmac.TryGetHashAndReset(output, out int bytesWritten)) - { - Debug.Fail("HMAC operation failed unexpectedly"); - throw new CryptographicException(SR.Arg_CryptographyException); - } - - Debug.Assert(bytesWritten == output.Length, $"Bytes written is {bytesWritten} bytes which does not match output length ({output.Length} bytes)"); - } - - private static int HashLength(HashAlgorithmName hashAlgorithmName) - { - if (hashAlgorithmName == HashAlgorithmName.SHA1) - { - return HMACSHA1.HashSizeInBytes; - } - else if (hashAlgorithmName == HashAlgorithmName.SHA256) - { - return HMACSHA256.HashSizeInBytes; - } - else if (hashAlgorithmName == HashAlgorithmName.SHA384) - { - return HMACSHA384.HashSizeInBytes; - } - else if (hashAlgorithmName == HashAlgorithmName.SHA512) - { - return HMACSHA512.HashSizeInBytes; - } - else if (hashAlgorithmName == HashAlgorithmName.SHA3_256) - { - return HMACSHA3_256.HashSizeInBytes; - } - else if (hashAlgorithmName == HashAlgorithmName.SHA3_384) - { - return HMACSHA3_384.HashSizeInBytes; - } - else if (hashAlgorithmName == HashAlgorithmName.SHA3_512) - { - return HMACSHA3_512.HashSizeInBytes; - } - else if (hashAlgorithmName == HashAlgorithmName.MD5) - { - return HMACMD5.HashSizeInBytes; - } - else - { - throw new ArgumentOutOfRangeException(nameof(hashAlgorithmName)); - } + DeriveKeyCore(hashAlgorithmName, hashLength, ikm, output, salt, info); } } } diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HKDFManagedImplementation.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HKDFManagedImplementation.cs new file mode 100644 index 00000000000..e62cc4e33ec --- /dev/null +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/HKDFManagedImplementation.cs @@ -0,0 +1,101 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; +using System.Runtime.Versioning; +using Internal.Cryptography; + +namespace System.Security.Cryptography +{ + internal static class HKDFManagedImplementation + { + internal static void Extract(HashAlgorithmName hashAlgorithmName, int hashLength, ReadOnlySpan ikm, ReadOnlySpan salt, Span prk) + { + Debug.Assert(Helpers.HashLength(hashAlgorithmName) == hashLength); + int written = CryptographicOperations.HmacData(hashAlgorithmName, salt, ikm, prk); + Debug.Assert(written == prk.Length, $"Bytes written is {written} bytes which does not match output length ({prk.Length} bytes)"); + } + + internal static void Expand(HashAlgorithmName hashAlgorithmName, int hashLength, ReadOnlySpan prk, Span output, ReadOnlySpan info) + { + Debug.Assert(Helpers.HashLength(hashAlgorithmName) == hashLength); + + byte counter = 0; + var counterSpan = new Span(ref counter); + Span t = Span.Empty; + Span remainingOutput = output; + + const int MaxStackInfoBuffer = 64; + Span tempInfoBuffer = stackalloc byte[MaxStackInfoBuffer]; + scoped ReadOnlySpan infoBuffer; + byte[]? rentedTempInfoBuffer = null; + + if (output.Overlaps(info)) + { + if (info.Length > MaxStackInfoBuffer) + { + rentedTempInfoBuffer = CryptoPool.Rent(info.Length); + tempInfoBuffer = rentedTempInfoBuffer; + } + + tempInfoBuffer = tempInfoBuffer.Slice(0, info.Length); + info.CopyTo(tempInfoBuffer); + infoBuffer = tempInfoBuffer; + } + else + { + infoBuffer = info; + } + + using (IncrementalHash hmac = IncrementalHash.CreateHMAC(hashAlgorithmName, prk)) + { + for (int i = 1; ; i++) + { + hmac.AppendData(t); + hmac.AppendData(infoBuffer); + counter = (byte)i; + hmac.AppendData(counterSpan); + + if (remainingOutput.Length >= hashLength) + { + t = remainingOutput.Slice(0, hashLength); + remainingOutput = remainingOutput.Slice(hashLength); + GetHashAndReset(hmac, t); + } + else + { + if (remainingOutput.Length > 0) + { + Debug.Assert(hashLength <= 512 / 8, "hashLength is larger than expected, consider increasing this value or using regular allocation"); + Span lastChunk = stackalloc byte[hashLength]; + GetHashAndReset(hmac, lastChunk); + lastChunk.Slice(0, remainingOutput.Length).CopyTo(remainingOutput); + } + + break; + } + } + } + + if (rentedTempInfoBuffer is not null) + { + CryptoPool.Return(rentedTempInfoBuffer, clearSize: info.Length); + } + } + + internal static void DeriveKey(HashAlgorithmName hashAlgorithmName, int hashLength, ReadOnlySpan ikm, Span output, ReadOnlySpan salt, ReadOnlySpan info) + { + Span prk = stackalloc byte[hashLength]; + + Extract(hashAlgorithmName, hashLength, ikm, salt, prk); + Expand(hashAlgorithmName, hashLength, prk, output, info); + CryptographicOperations.ZeroMemory(prk); + } + + private static void GetHashAndReset(IncrementalHash hmac, Span output) + { + int written = hmac.GetHashAndReset(output); + Debug.Assert(written == output.Length, $"Bytes written is {written} bytes which does not match output length ({output.Length} bytes)"); + } + } +} diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/Helpers.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/Helpers.cs index 5a07b09c2cc..72319d5185a 100644 --- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/Helpers.cs +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/Helpers.cs @@ -347,5 +347,45 @@ internal static ReadOnlySpan ArrayToSpanOrThrow( return arg; } + + internal static int HashLength(HashAlgorithmName hashAlgorithmName) + { + if (hashAlgorithmName == HashAlgorithmName.SHA1) + { + return HMACSHA1.HashSizeInBytes; + } + else if (hashAlgorithmName == HashAlgorithmName.SHA256) + { + return HMACSHA256.HashSizeInBytes; + } + else if (hashAlgorithmName == HashAlgorithmName.SHA384) + { + return HMACSHA384.HashSizeInBytes; + } + else if (hashAlgorithmName == HashAlgorithmName.SHA512) + { + return HMACSHA512.HashSizeInBytes; + } + else if (hashAlgorithmName == HashAlgorithmName.SHA3_256) + { + return HMACSHA3_256.HashSizeInBytes; + } + else if (hashAlgorithmName == HashAlgorithmName.SHA3_384) + { + return HMACSHA3_384.HashSizeInBytes; + } + else if (hashAlgorithmName == HashAlgorithmName.SHA3_512) + { + return HMACSHA3_512.HashSizeInBytes; + } + else if (hashAlgorithmName == HashAlgorithmName.MD5) + { + return HMACMD5.HashSizeInBytes; + } + else + { + throw new ArgumentOutOfRangeException(nameof(hashAlgorithmName)); + } + } } } diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Apple.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Apple.cs index d46e9c1474b..6ba4da55bf7 100644 --- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Apple.cs +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Apple.cs @@ -37,6 +37,7 @@ internal static LiteXof CreateXof(string hashAlgorithmId) public int HashSizeInBytes => throw new UnreachableException(); public void Append(ReadOnlySpan data) => throw new UnreachableException(); public int Finalize(Span destination) => throw new UnreachableException(); + public int FinalizeAndReset(Span destination) => throw new UnreachableException(); public void Current(Span destination) => throw new UnreachableException(); public int Reset() => throw new UnreachableException(); public LiteXof Clone() => throw new UnreachableException(); diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Browser.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Browser.cs index 5591479f0c7..c8956a354c2 100644 --- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Browser.cs +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Browser.cs @@ -32,6 +32,7 @@ internal static LiteXof CreateXof(string hashAlgorithmId) public int HashSizeInBytes => throw new UnreachableException(); public void Append(ReadOnlySpan data) => throw new UnreachableException(); public int Finalize(Span destination) => throw new UnreachableException(); + public int FinalizeAndReset(Span destination) => throw new UnreachableException(); public void Current(Span destination) => throw new UnreachableException(); public int Reset() => throw new UnreachableException(); public LiteXof Clone() => throw new UnreachableException(); diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Unix.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Unix.cs index 31af19c3de6..3fe06afbfeb 100644 --- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Unix.cs +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Unix.cs @@ -71,6 +71,13 @@ public int Finalize(Span destination) return destination.Length; } + public int FinalizeAndReset(Span destination) + { + int written = Finalize(destination); + Reset(); + return written; + } + public void Current(Span destination) { Check(Interop.Crypto.EvpDigestCurrentXOF(_ctx, destination)); diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Windows.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Windows.cs index c87c35328de..db00125a3aa 100644 --- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Windows.cs +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/LiteHash.Windows.cs @@ -257,6 +257,9 @@ public unsafe int Finalize(Span destination) } } + // Windows's Finalize always does a reset. + public int FinalizeAndReset(Span destination) => Finalize(destination); + public void Reset() => Finalize(Span.Empty); public unsafe void Current(Span destination) diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/OpenSslCipherLite.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/OpenSslCipherLite.cs index 343edf42e01..014eb49268d 100644 --- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/OpenSslCipherLite.cs +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/OpenSslCipherLite.cs @@ -139,11 +139,11 @@ public void Dispose() private int CipherUpdate(ReadOnlySpan input, Span output) { - Interop.Crypto.EvpCipherUpdate( + CheckBoolReturn(Interop.Crypto.EvpCipherUpdate( _ctx, output, out int bytesWritten, - input); + input)); return bytesWritten; } diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/SP800108HmacCounterKdf.OpenSsl.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/SP800108HmacCounterKdf.OpenSsl.cs new file mode 100644 index 00000000000..a26888af06a --- /dev/null +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/SP800108HmacCounterKdf.OpenSsl.cs @@ -0,0 +1,79 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace System.Security.Cryptography +{ + public sealed partial class SP800108HmacCounterKdf : IDisposable + { + private static readonly bool s_hasOpenSslImplementation = Interop.Crypto.EvpKdfAlgs.Kbkdf is not null; + + private static partial SP800108HmacCounterKdfImplementationBase CreateImplementation( + ReadOnlySpan key, + HashAlgorithmName hashAlgorithm) + { + if (s_hasOpenSslImplementation) + { + return new SP800108HmacCounterKdfImplementationOpenSsl(key, hashAlgorithm); + } + else + { + return new SP800108HmacCounterKdfImplementationManaged(key, hashAlgorithm); + } + } + + private static partial byte[] DeriveBytesCore( + byte[] key, + HashAlgorithmName hashAlgorithm, + byte[] label, + byte[] context, + int derivedKeyLengthInBytes) + { + byte[] result = new byte[derivedKeyLengthInBytes]; + + if (s_hasOpenSslImplementation) + { + SP800108HmacCounterKdfImplementationOpenSsl.DeriveBytesOneShot(key, hashAlgorithm, label, context, result); + } + else + { + SP800108HmacCounterKdfImplementationManaged.DeriveBytesOneShot(key, hashAlgorithm, label, context, result); + } + + return result; + } + + private static partial void DeriveBytesCore( + ReadOnlySpan key, + HashAlgorithmName hashAlgorithm, + ReadOnlySpan label, + ReadOnlySpan context, + Span destination) + { + if (s_hasOpenSslImplementation) + { + SP800108HmacCounterKdfImplementationOpenSsl.DeriveBytesOneShot(key, hashAlgorithm, label, context, destination); + } + else + { + SP800108HmacCounterKdfImplementationManaged.DeriveBytesOneShot(key, hashAlgorithm, label, context, destination); + } + } + + private static partial void DeriveBytesCore( + ReadOnlySpan key, + HashAlgorithmName hashAlgorithm, + ReadOnlySpan label, + ReadOnlySpan context, + Span destination) + { + if (s_hasOpenSslImplementation) + { + SP800108HmacCounterKdfImplementationOpenSsl.DeriveBytesOneShot(key, hashAlgorithm, label, context, destination); + } + else + { + SP800108HmacCounterKdfImplementationManaged.DeriveBytesOneShot(key, hashAlgorithm, label, context, destination); + } + } + } +} diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/SP800108HmacCounterKdfImplementationOpenSsl.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/SP800108HmacCounterKdfImplementationOpenSsl.cs new file mode 100644 index 00000000000..c2790630119 --- /dev/null +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/SP800108HmacCounterKdfImplementationOpenSsl.cs @@ -0,0 +1,114 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics; +using Microsoft.Win32.SafeHandles; + +namespace System.Security.Cryptography +{ + internal sealed class SP800108HmacCounterKdfImplementationOpenSsl : SP800108HmacCounterKdfImplementationBase + { + private const int CharToBytesStackBufferSize = 256; + + private readonly HashAlgorithmName _hashAlgorithm; + private readonly FixedMemoryKeyBox _keyBox; + + internal unsafe SP800108HmacCounterKdfImplementationOpenSsl(ReadOnlySpan key, HashAlgorithmName hashAlgorithm) + { + _hashAlgorithm = hashAlgorithm; + _keyBox = new FixedMemoryKeyBox(key); + } + + public override void Dispose() + { + _keyBox.Dispose(); + } + + internal override unsafe void DeriveBytes(ReadOnlySpan label, ReadOnlySpan context, Span destination) + { + Debug.Assert(Interop.Crypto.EvpKdfAlgs.Kbkdf is { IsInvalid: false }); + + if (destination.IsEmpty) + { + return; + } + + bool acquired = false; + + try + { + _keyBox.DangerousAddRef(ref acquired); + Interop.Crypto.KbkdfHmacOneShot( + Interop.Crypto.EvpKdfAlgs.Kbkdf, + _keyBox.DangerousKeySpan, + _hashAlgorithm.Name!, + label, + context, + destination); + } + finally + { + if (acquired) + { + _keyBox.DangerousRelease(); + } + } + } + + internal override void DeriveBytes(byte[] label, byte[] context, Span destination) + { + DeriveBytes(new ReadOnlySpan(label), new ReadOnlySpan(context), destination); + } + + internal override void DeriveBytes(ReadOnlySpan label, ReadOnlySpan context, Span destination) + { + using (Utf8DataEncoding labelData = new Utf8DataEncoding(label, stackalloc byte[CharToBytesStackBufferSize])) + using (Utf8DataEncoding contextData = new Utf8DataEncoding(context, stackalloc byte[CharToBytesStackBufferSize])) + { + DeriveBytes(labelData.Utf8Bytes, contextData.Utf8Bytes, destination); + } + } + + internal static void DeriveBytesOneShot( + ReadOnlySpan key, + HashAlgorithmName hashAlgorithm, + ReadOnlySpan label, + ReadOnlySpan context, + Span destination) + { + Debug.Assert(Interop.Crypto.EvpKdfAlgs.Kbkdf is { IsInvalid: false }); + + if (destination.IsEmpty) + { + return; + } + + Interop.Crypto.KbkdfHmacOneShot( + Interop.Crypto.EvpKdfAlgs.Kbkdf, + key, + hashAlgorithm.Name!, + label, + context, + destination); + } + + internal static void DeriveBytesOneShot( + ReadOnlySpan key, + HashAlgorithmName hashAlgorithm, + ReadOnlySpan label, + ReadOnlySpan context, + Span destination) + { + if (destination.Length == 0) + { + return; + } + + using (Utf8DataEncoding labelData = new Utf8DataEncoding(label, stackalloc byte[CharToBytesStackBufferSize])) + using (Utf8DataEncoding contextData = new Utf8DataEncoding(context, stackalloc byte[CharToBytesStackBufferSize])) + { + DeriveBytesOneShot(key, hashAlgorithm, labelData.Utf8Bytes, contextData.Utf8Bytes, destination); + } + } + } +} diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/Shake128.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/Shake128.cs index 80740c59a65..0e642e10802 100644 --- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/Shake128.cs +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/Shake128.cs @@ -101,8 +101,7 @@ public byte[] GetHashAndReset(int outputLength) { CheckReading(); byte[] output = new byte[outputLength]; - _hashProvider.Finalize(output); - _hashProvider.Reset(); + _hashProvider.FinalizeAndReset(output); return output; } } @@ -121,8 +120,7 @@ public void GetHashAndReset(Span destination) using (ConcurrencyBlock.Enter(ref _block)) { CheckReading(); - _hashProvider.Finalize(destination); - _hashProvider.Reset(); + _hashProvider.FinalizeAndReset(destination); } } diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/Shake256.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/Shake256.cs index d861257cf1e..156c848452b 100644 --- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/Shake256.cs +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/Shake256.cs @@ -101,8 +101,7 @@ public byte[] GetHashAndReset(int outputLength) { CheckReading(); byte[] output = new byte[outputLength]; - _hashProvider.Finalize(output); - _hashProvider.Reset(); + _hashProvider.FinalizeAndReset(output); return output; } } @@ -121,8 +120,7 @@ public void GetHashAndReset(Span destination) using (ConcurrencyBlock.Enter(ref _block)) { CheckReading(); - _hashProvider.Finalize(destination); - _hashProvider.Reset(); + _hashProvider.FinalizeAndReset(destination); } } diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/CertificateRequest.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/CertificateRequest.cs index 3924387b72f..8a4a6cc3585 100644 --- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/CertificateRequest.cs +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/CertificateRequest.cs @@ -890,7 +890,7 @@ public X509Certificate2 Create( }; certificate.Encode(writer); - X509Certificate2 ret = X509CertificateLoader.LoadCertificate(writer.Encode()); + X509Certificate2 ret = writer.Encode(X509CertificateLoader.LoadCertificate); CryptoPool.Return(normalizedSerial); return ret; } diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/CertificateRevocationListBuilder.CdpExtension.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/CertificateRevocationListBuilder.CdpExtension.cs index a6b2380938d..50582d9af3a 100644 --- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/CertificateRevocationListBuilder.CdpExtension.cs +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/CertificateRevocationListBuilder.CdpExtension.cs @@ -108,8 +108,10 @@ public static X509Extension BuildCrlDistributionPointExtension( // CRLDistributionPoints writer.PopSequence(); - byte[] encoded = writer.Encode(); - return new X509Extension(Oids.CrlDistributionPointsOid, encoded, critical); + return writer.Encode(critical, static (critical, encoded) => + { + return new X509Extension(Oids.CrlDistributionPointsOid, encoded, critical); + }); } } } diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/OpenSslX509Encoder.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/OpenSslX509Encoder.cs index 5a8c9697c77..4cb0d5e5b9f 100644 --- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/OpenSslX509Encoder.cs +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/OpenSslX509Encoder.cs @@ -280,8 +280,11 @@ private static DSAOpenSsl BuildDsaPublicKey(byte[] encodedKeyValue, byte[] encod DSAOpenSsl dsa = new DSAOpenSsl(); try { - dsa.ImportSubjectPublicKeyInfo(writer.Encode(), out _); - return dsa; + return writer.Encode(dsa, static (dsa, encoded) => + { + dsa.ImportSubjectPublicKeyInfo(encoded, out _); + return dsa; + }); } catch (Exception) { diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/StorePal.Windows.Import.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/StorePal.Windows.Import.cs index 59155e2b76a..664f308027f 100644 --- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/StorePal.Windows.Import.cs +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/StorePal.Windows.Import.cs @@ -212,26 +212,6 @@ internal static partial IStorePal FromSystemStore(string storeName, StoreLocatio return new StorePal(certStore); } - // this method maps a X509KeyStorageFlags enum to a combination of crypto API flags - private static Interop.Crypt32.PfxCertStoreFlags MapKeyStorageFlags(X509KeyStorageFlags keyStorageFlags) - { - Interop.Crypt32.PfxCertStoreFlags dwFlags = 0; - if ((keyStorageFlags & X509KeyStorageFlags.UserKeySet) == X509KeyStorageFlags.UserKeySet) - dwFlags |= Interop.Crypt32.PfxCertStoreFlags.CRYPT_USER_KEYSET; - else if ((keyStorageFlags & X509KeyStorageFlags.MachineKeySet) == X509KeyStorageFlags.MachineKeySet) - dwFlags |= Interop.Crypt32.PfxCertStoreFlags.CRYPT_MACHINE_KEYSET; - - if ((keyStorageFlags & X509KeyStorageFlags.Exportable) == X509KeyStorageFlags.Exportable) - dwFlags |= Interop.Crypt32.PfxCertStoreFlags.CRYPT_EXPORTABLE; - if ((keyStorageFlags & X509KeyStorageFlags.UserProtected) == X509KeyStorageFlags.UserProtected) - dwFlags |= Interop.Crypt32.PfxCertStoreFlags.CRYPT_USER_PROTECTED; - - if ((keyStorageFlags & X509KeyStorageFlags.EphemeralKeySet) == X509KeyStorageFlags.EphemeralKeySet) - dwFlags |= Interop.Crypt32.PfxCertStoreFlags.PKCS12_NO_PERSIST_KEY | Interop.Crypt32.PfxCertStoreFlags.PKCS12_ALWAYS_CNG_KSP; - - return dwFlags; - } - // this method maps X509Store OpenFlags to a combination of crypto API flags private static Interop.Crypt32.CertStoreFlags MapX509StoreFlags(StoreLocation storeLocation, OpenFlags flags) { diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/SubjectAlternativeNameBuilder.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/SubjectAlternativeNameBuilder.cs index 0d34c6d472a..4764b023f80 100644 --- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/SubjectAlternativeNameBuilder.cs +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/SubjectAlternativeNameBuilder.cs @@ -77,10 +77,10 @@ public X509Extension Build(bool critical = false) } } - return new X509Extension( - Oids.SubjectAltName, - writer.Encode(), - critical); + return writer.Encode(critical, static (critical, encoded) => + { + return new X509Extension(Oids.SubjectAltName, encoded, critical); + }); } private void AddGeneralName(GeneralNameAsn generalName) diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/X500DistinguishedNameBuilder.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/X500DistinguishedNameBuilder.cs index 3a6c4985711..af2590c29ba 100644 --- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/X500DistinguishedNameBuilder.cs +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/X500DistinguishedNameBuilder.cs @@ -350,11 +350,7 @@ public X500DistinguishedName Build() } } - byte[] rented = CryptoPool.Rent(_writer.GetEncodedLength()); - int encoded = _writer.Encode(rented); - X500DistinguishedName name = new X500DistinguishedName(rented.AsSpan(0, encoded)); - CryptoPool.Return(rented, clearSize: 0); // Distinguished Names do not contain sensitive information. - return name; + return _writer.Encode(static encoded => new X500DistinguishedName(encoded)); } private void EncodeComponent( diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/X509AuthorityKeyIdentifierExtension.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/X509AuthorityKeyIdentifierExtension.cs index bdfcf2ca6e8..f3f57dd4ade 100644 --- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/X509AuthorityKeyIdentifierExtension.cs +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/X509AuthorityKeyIdentifierExtension.cs @@ -245,22 +245,7 @@ public static X509AuthorityKeyIdentifierExtension CreateFromSubjectKeyIdentifier writer.WriteOctetString(subjectKeyIdentifier, new Asn1Tag(TagClass.ContextSpecific, 0)); } - // Most KeyIdentifier values are computed from SHA-1 (20 bytes), which produces a 24-byte - // value for this extension. - // Let's go ahead and be really generous before moving to redundant array allocation. - Span stackSpan = stackalloc byte[64]; - scoped ReadOnlySpan encoded; - - if (writer.TryEncode(stackSpan, out int written)) - { - encoded = stackSpan.Slice(0, written); - } - else - { - encoded = writer.Encode(); - } - - return new X509AuthorityKeyIdentifierExtension(encoded); + return writer.Encode(static encoded => new X509AuthorityKeyIdentifierExtension(encoded)); } /// @@ -343,7 +328,7 @@ public static X509AuthorityKeyIdentifierExtension CreateFromIssuerNameAndSerialN } } - return new X509AuthorityKeyIdentifierExtension(writer.Encode()); + return writer.Encode(static encoded => new X509AuthorityKeyIdentifierExtension(encoded)); } @@ -444,7 +429,7 @@ public static X509AuthorityKeyIdentifierExtension Create( } } - return new X509AuthorityKeyIdentifierExtension(writer.Encode()); + return writer.Encode(static encoded => new X509AuthorityKeyIdentifierExtension(encoded)); } /// diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/X509CertificateLoader.Windows.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/X509CertificateLoader.Windows.cs index 346e8062d34..2e43dc78b56 100644 --- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/X509CertificateLoader.Windows.cs +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/X509CertificateLoader.Windows.cs @@ -281,7 +281,8 @@ private static Interop.Crypt32.PfxCertStoreFlags MapKeyStorageFlags(X509KeyStora { Debug.Assert((keyStorageFlags & KeyStorageFlagsAll) == keyStorageFlags); - Interop.Crypt32.PfxCertStoreFlags pfxCertStoreFlags = 0; + Interop.Crypt32.PfxCertStoreFlags pfxCertStoreFlags = Interop.Crypt32.PfxCertStoreFlags.PKCS12_PREFER_CNG_KSP; + if ((keyStorageFlags & X509KeyStorageFlags.UserKeySet) == X509KeyStorageFlags.UserKeySet) pfxCertStoreFlags |= Interop.Crypt32.PfxCertStoreFlags.CRYPT_USER_KEYSET; else if ((keyStorageFlags & X509KeyStorageFlags.MachineKeySet) == X509KeyStorageFlags.MachineKeySet) @@ -297,7 +298,10 @@ private static Interop.Crypt32.PfxCertStoreFlags MapKeyStorageFlags(X509KeyStora // difficult to do SHA-2 RSA signatures with, simplifies the story for UWP, and reduces the // complexity of pointer interpretation. if ((keyStorageFlags & X509KeyStorageFlags.EphemeralKeySet) == X509KeyStorageFlags.EphemeralKeySet) + { + pfxCertStoreFlags &= ~Interop.Crypt32.PfxCertStoreFlags.PKCS12_PREFER_CNG_KSP; pfxCertStoreFlags |= Interop.Crypt32.PfxCertStoreFlags.PKCS12_NO_PERSIST_KEY | Interop.Crypt32.PfxCertStoreFlags.PKCS12_ALWAYS_CNG_KSP; + } // In .NET Framework loading a PFX then adding the key to the Windows Certificate Store would // enable a native application compiled against CAPI to find that private key and interoperate with it. diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/X509Pal.Android.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/X509Pal.Android.cs index 4f8dd772449..608ee19b855 100644 --- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/X509Pal.Android.cs +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/X509Pal.Android.cs @@ -155,23 +155,23 @@ private static DSA DecodeDsaPublicKey(byte[] encodedKeyValue, byte[] encodedPara AsnWriter writer = new AsnWriter(AsnEncodingRules.DER); spki.Encode(writer); - byte[] rented = CryptoPool.Rent(writer.GetEncodedLength()); - - int written = writer.Encode(rented); - DSA dsa = DSA.Create(); DSA? toDispose = dsa; try { - dsa.ImportSubjectPublicKeyInfo(rented.AsSpan(0, written), out _); + writer.Encode(dsa, static (dsa, encoded) => + { + dsa.ImportSubjectPublicKeyInfo(encoded, out _); + return (object?)null; + }); + toDispose = null; return dsa; } finally { toDispose?.Dispose(); - CryptoPool.Return(rented, written); } } } diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/X509Pal.macOS.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/X509Pal.macOS.cs index d45cfe0b7ae..c154551bcde 100644 --- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/X509Pal.macOS.cs +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/X509Pal.macOS.cs @@ -84,27 +84,23 @@ private static DSA DecodeDsaPublicKey(byte[] encodedKeyValue, byte[] encodedPara AsnWriter writer = new AsnWriter(AsnEncodingRules.DER); spki.Encode(writer); - byte[] rented = CryptoPool.Rent(writer.GetEncodedLength()); - - if (!writer.TryEncode(rented, out int written)) - { - Debug.Fail("TryEncode failed with a pre-allocated buffer"); - throw new InvalidOperationException(); - } - DSA dsa = DSA.Create(); DSA? toDispose = dsa; try { - dsa.ImportSubjectPublicKeyInfo(rented.AsSpan(0, written), out _); + writer.Encode(dsa, static (dsa, encoded) => + { + dsa.ImportSubjectPublicKeyInfo(encoded, out _); + return (object?)null; + }); + toDispose = null; return dsa; } finally { toDispose?.Dispose(); - CryptoPool.Return(rented, written); } } diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/X509SubjectKeyIdentifierExtension.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/X509SubjectKeyIdentifierExtension.cs index a97061a885f..b08433ae883 100644 --- a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/X509SubjectKeyIdentifierExtension.cs +++ b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/X509SubjectKeyIdentifierExtension.cs @@ -214,26 +214,12 @@ private static byte[] HashSubjectPublicKeyLeft160Bits(PublicKey key, HashAlgorit private static byte[] HashSubjectPublicKeyInfo(PublicKey key, HashAlgorithmName hashAlgorithmName) { - Span hash = stackalloc byte[512 / 8]; // Largest known hash is 512-bits. AsnWriter writer = key.EncodeSubjectPublicKeyInfo(); - // An RSA 4096 SPKI is going to be about 550 bytes. 640 for a little extra space. Anything bigger will rent. - const int MaxSpkiStackSize = 640; - byte[]? rented = null; - int encodedLength = writer.GetEncodedLength(); - Span spkiBuffer = encodedLength <= MaxSpkiStackSize ? - stackalloc byte[MaxSpkiStackSize] : - (rented = CryptoPool.Rent(encodedLength)); - - int spkiWritten = writer.Encode(spkiBuffer); - int hashWritten = CryptographicOperations.HashData(hashAlgorithmName, spkiBuffer.Slice(0, spkiWritten), hash); - - if (rented is not null) + return writer.Encode(hashAlgorithmName, static (hashAlgorithmName, encoded) => { - CryptoPool.Return(rented, clearSize: 0); // SPKI is public so no need to zero it. - } - - return hash.Slice(0, hashWritten).ToArray(); + return CryptographicOperations.HashData(hashAlgorithmName, encoded); + }); } } } diff --git a/src/libraries/System.Security.Cryptography/tests/ChaCha20Poly1305Tests.cs b/src/libraries/System.Security.Cryptography/tests/ChaCha20Poly1305Tests.cs index 8ec4f3bc059..3968505af2a 100644 --- a/src/libraries/System.Security.Cryptography/tests/ChaCha20Poly1305Tests.cs +++ b/src/libraries/System.Security.Cryptography/tests/ChaCha20Poly1305Tests.cs @@ -478,6 +478,11 @@ public static void CheckIsSupported() // CryptoKit is supported on macOS 10.15+, which is our minimum target. On iOS/tvOS, it was added in 13.0 but we can expect that version in our testing environments. expectedIsSupported = true; } + else if (PlatformDetection.IsAzureLinux) + { + // Though Azure Linux uses OpenSSL, they build OpenSSL without ChaCha20-Poly1305. + expectedIsSupported = false; + } else if (PlatformDetection.OpenSslPresentOnSystem && PlatformDetection.IsOpenSslSupported) { const int OpenSslChaChaMinimumVersion = 0x1_01_00_00_F; //major_minor_fix_patch_status diff --git a/src/libraries/System.Security.Cryptography/tests/DefaultECDiffieHellmanProvider.Unix.cs b/src/libraries/System.Security.Cryptography/tests/DefaultECDiffieHellmanProvider.Unix.cs index 5e8aef85460..77c32104f2d 100644 --- a/src/libraries/System.Security.Cryptography/tests/DefaultECDiffieHellmanProvider.Unix.cs +++ b/src/libraries/System.Security.Cryptography/tests/DefaultECDiffieHellmanProvider.Unix.cs @@ -25,7 +25,7 @@ public bool ExplicitCurvesSupported { get { - if (PlatformDetection.IsApplePlatform) + if (PlatformDetection.IsApplePlatform || PlatformDetection.IsAzureLinux) { return false; } diff --git a/src/libraries/System.Security.Cryptography/tests/DefaultECDsaProvider.Unix.cs b/src/libraries/System.Security.Cryptography/tests/DefaultECDsaProvider.Unix.cs index c2dad6c0938..cec7aac4895 100644 --- a/src/libraries/System.Security.Cryptography/tests/DefaultECDsaProvider.Unix.cs +++ b/src/libraries/System.Security.Cryptography/tests/DefaultECDsaProvider.Unix.cs @@ -25,7 +25,7 @@ public bool ExplicitCurvesSupported { get { - if (PlatformDetection.IsApplePlatform) + if (PlatformDetection.IsApplePlatform || PlatformDetection.IsAzureLinux) { return false; } diff --git a/src/libraries/System.Security.Cryptography/tests/DefaultRSAProvider.cs b/src/libraries/System.Security.Cryptography/tests/DefaultRSAProvider.cs index ab19c2aa033..1aa87fdab4a 100644 --- a/src/libraries/System.Security.Cryptography/tests/DefaultRSAProvider.cs +++ b/src/libraries/System.Security.Cryptography/tests/DefaultRSAProvider.cs @@ -10,6 +10,7 @@ public class DefaultRSAProvider : IRSAProvider { private bool? _supports384PrivateKey; private bool? _supportsSha1Signatures; + private bool? _supportsMd5Signatures; public RSA Create() => RSA.Create(); @@ -41,6 +42,7 @@ public bool Supports384PrivateKey } public bool SupportsSha1Signatures => _supportsSha1Signatures ??= SignatureSupport.CanProduceSha1Signature(Create()); + public bool SupportsMd5Signatures => _supportsMd5Signatures ??= SignatureSupport.CanProduceMd5Signature(Create()); public bool SupportsLargeExponent => true; diff --git a/src/libraries/System.Security.Cryptography/tests/HKDFTests.cs b/src/libraries/System.Security.Cryptography/tests/HKDFTests.cs index 6f58c00e809..896325de4b3 100644 --- a/src/libraries/System.Security.Cryptography/tests/HKDFTests.cs +++ b/src/libraries/System.Security.Cryptography/tests/HKDFTests.cs @@ -14,6 +14,9 @@ public abstract class HKDFTests protected abstract byte[] Expand(HashAlgorithmName hash, byte[] prk, int outputLength, byte[] info); protected abstract byte[] DeriveKey(HashAlgorithmName hash, byte[] ikm, int outputLength, byte[] salt, byte[] info); + internal static bool MD5Supported => !PlatformDetection.IsBrowser && !PlatformDetection.IsAzureLinux; + internal static bool EmptyKeysSupported => !PlatformDetection.IsAzureLinux; + [Theory] [MemberData(nameof(GetHkdfTestCases))] public void ExtractTests(HkdfTestCase test) @@ -22,9 +25,8 @@ public void ExtractTests(HkdfTestCase test) Assert.Equal(test.Prk, prk); } - [Theory] + [ConditionalTheory(nameof(MD5Supported))] [MemberData(nameof(GetHkdfTestCases))] - [SkipOnPlatform(TestPlatforms.Browser, "MD5 is not supported on Browser")] public void ExtractTamperHashTests(HkdfTestCase test) { byte[] prk = Extract(HashAlgorithmName.MD5, 128 / 8, test.Ikm, test.Salt); @@ -71,7 +73,7 @@ public void ExtractNonsensicalHash() () => Extract(new HashAlgorithmName("foo"), 20, ikm, salt)); } - [Fact] + [ConditionalFact(nameof(EmptyKeysSupported))] public void ExtractEmptyIkm() { byte[] salt = new byte[20]; @@ -205,6 +207,7 @@ public void DeriveKeyTamperInfoTests(HkdfTestCase test) [Theory] [MemberData(nameof(Sha3TestCases))] + [ActiveIssue("https://github.com/dotnet/runtime/issues/106489", typeof(PlatformDetection), nameof(PlatformDetection.IsAzureLinux))] public void Sha3Tests(HkdfTestCase test) { if (PlatformDetection.SupportsSha3) @@ -257,7 +260,7 @@ public static IEnumerable GetPrkTooShortTestCases() yield return new object[] { HashAlgorithmName.SHA256, 256 / 8 - 1 }; yield return new object[] { HashAlgorithmName.SHA512, 512 / 8 - 1 }; - if (!PlatformDetection.IsBrowser) + if (MD5Supported) { yield return new object[] { HashAlgorithmName.MD5, 128 / 8 - 1 }; } diff --git a/src/libraries/System.Security.Cryptography/tests/HmacMD5Tests.cs b/src/libraries/System.Security.Cryptography/tests/HmacMD5Tests.cs index c0a4283498c..17d6a278999 100644 --- a/src/libraries/System.Security.Cryptography/tests/HmacMD5Tests.cs +++ b/src/libraries/System.Security.Cryptography/tests/HmacMD5Tests.cs @@ -9,12 +9,12 @@ namespace System.Security.Cryptography.Tests { - [SkipOnPlatform(TestPlatforms.Browser, "Not supported on Browser")] + [ConditionalClass(typeof(HmacMD5Tests.Traits), nameof(HmacMD5Tests.Traits.IsSupported))] public class HmacMD5Tests : Rfc2202HmacTests { public sealed class Traits : IHmacTrait { - public static bool IsSupported => true; + public static bool IsSupported => !PlatformDetection.IsAzureLinux && !PlatformDetection.IsBrowser; public static int HashSizeInBytes => HMACMD5.HashSizeInBytes; } diff --git a/src/libraries/System.Security.Cryptography/tests/KmacTestDriver.cs b/src/libraries/System.Security.Cryptography/tests/KmacTestDriver.cs index b219b917913..b508acacc1d 100644 --- a/src/libraries/System.Security.Cryptography/tests/KmacTestDriver.cs +++ b/src/libraries/System.Security.Cryptography/tests/KmacTestDriver.cs @@ -95,7 +95,7 @@ public abstract class KmacTestDriver public static bool IsSupported => TKmacTrait.IsSupported; public static bool IsNotSupported => !IsSupported; public static KeySizes? PlatformKeySizeRequirements { get; } = - PlatformDetection.IsOpenSslSupported ? new KeySizes(4, 512, 1) : null; + PlatformDetection.IsOpenSslSupported && !PlatformDetection.IsAzureLinux ? new KeySizes(4, 512, 1) : null; public static int? PlatformMaxOutputSize { get; } = PlatformDetection.IsOpenSslSupported ? 0xFFFFFF / 8 : null; public static int? PlatformMaxCustomizationStringSize { get; } = PlatformDetection.IsOpenSslSupported ? 512 : null; diff --git a/src/libraries/System.Security.Cryptography/tests/OpenSslNamedKeysTests.manual.cs b/src/libraries/System.Security.Cryptography/tests/OpenSslNamedKeysTests.manual.cs index b5aab83a1aa..e2396634c79 100644 --- a/src/libraries/System.Security.Cryptography/tests/OpenSslNamedKeysTests.manual.cs +++ b/src/libraries/System.Security.Cryptography/tests/OpenSslNamedKeysTests.manual.cs @@ -2,8 +2,10 @@ // The .NET Foundation licenses this file to you under the MIT license. using System.Linq; +using System.Text; using Test.Cryptography; using Xunit; +using TempFileHolder = System.Security.Cryptography.X509Certificates.Tests.TempFileHolder; namespace System.Security.Cryptography.Tests { @@ -43,10 +45,13 @@ public class OpenSslNamedKeysTests private static string TpmRsaDecryptKeyHandleUri { get; } = GetHandleKeyUri(TpmRsaDecryptKeyHandle); public static bool ShouldRunEngineTests { get; } = PlatformDetection.OpenSslPresentOnSystem && StringToBool(Environment.GetEnvironmentVariable(TestEngineEnabledEnvVarName)); - public static bool ShouldRunProviderEcDsaTests { get; } = PlatformDetection.OpenSslPresentOnSystem && !string.IsNullOrEmpty(TpmEcDsaKeyHandleUri); - public static bool ShouldRunProviderEcDhTests { get; } = PlatformDetection.OpenSslPresentOnSystem && !string.IsNullOrEmpty(TpmEcDhKeyHandleUri); - public static bool ShouldRunProviderRsaSignTests { get; } = PlatformDetection.OpenSslPresentOnSystem && !string.IsNullOrEmpty(TpmRsaSignKeyHandleUri); - public static bool ShouldRunProviderRsaDecryptTests { get; } = PlatformDetection.OpenSslPresentOnSystem && !string.IsNullOrEmpty(TpmRsaDecryptKeyHandleUri); + + public static bool ProvidersSupported { get; } = PlatformDetection.IsOpenSsl3; + public static bool ProvidersNotSupported => !ProvidersSupported; + public static bool ShouldRunProviderEcDsaTests { get; } = ProvidersSupported && !string.IsNullOrEmpty(TpmEcDsaKeyHandleUri); + public static bool ShouldRunProviderEcDhTests { get; } = ProvidersSupported && !string.IsNullOrEmpty(TpmEcDhKeyHandleUri); + public static bool ShouldRunProviderRsaSignTests { get; } = ProvidersSupported && !string.IsNullOrEmpty(TpmRsaSignKeyHandleUri); + public static bool ShouldRunProviderRsaDecryptTests { get; } = ProvidersSupported && !string.IsNullOrEmpty(TpmRsaDecryptKeyHandleUri); public static bool ShouldRunAnyProviderTests => ShouldRunProviderEcDsaTests || ShouldRunProviderEcDhTests || ShouldRunProviderRsaSignTests || ShouldRunProviderRsaDecryptTests; public static bool ShouldRunTpmTssTests => ShouldRunEngineTests && !string.IsNullOrEmpty(TpmEcDsaKeyHandle); @@ -86,11 +91,30 @@ private static string GetHandleKeyUri(string handle) "B27434FA544BDAC679E1E16581D0E90203010001").HexToByteArray(); [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.OpenSslNotPresentOnSystem))] - public static void NotSupported() + public static void EngineNotSupported_ThrowsPlatformNotSupported() { Assert.Throws(() => SafeEvpPKeyHandle.OpenPublicKeyFromEngine(TestEngineName, TestEngineKeyId)); Assert.Throws(() => SafeEvpPKeyHandle.OpenPrivateKeyFromEngine(TestEngineName, TestEngineKeyId)); - Assert.Throws(() => SafeEvpPKeyHandle.OpenKeyFromProvider(Tpm2ProviderName, AnyProviderKeyUri)); + } + + [ConditionalFact(nameof(ProvidersNotSupported))] + public static void ProvidersNotSupported_ThrowsPlatformNotSupported() + { + try + { + using SafeEvpPKeyHandle key = SafeEvpPKeyHandle.OpenKeyFromProvider("default", NonExistingEngineOrProviderKeyName); + Assert.Fail("We expected an exception to be thrown"); + } + catch (PlatformNotSupportedException) + { + // Expected + } + catch (CryptographicException) when (PlatformDetection.IsApplePlatform) + { + // Our tests detect providers using PlatformDetection.IsOpenSsl3 which is always false for Apple platforms. + // Product on the other hand does feature detection and that might end up working + // in which case we should still throw any CryptographicException because the keyUri does not exist. + } } [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.OpenSslPresentOnSystem))] @@ -111,10 +135,14 @@ public static void EmptyNameThroughNullCharacter() { Assert.ThrowsAny(() => SafeEvpPKeyHandle.OpenPrivateKeyFromEngine("\0", "foo")); Assert.ThrowsAny(() => SafeEvpPKeyHandle.OpenPublicKeyFromEngine("\0", "foo")); - Assert.ThrowsAny(() => SafeEvpPKeyHandle.OpenKeyFromProvider("\0", "foo")); + + if (ProvidersSupported) + { + Assert.ThrowsAny(() => SafeEvpPKeyHandle.OpenKeyFromProvider("\0", "foo")); + } } - [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.OpenSslPresentOnSystem))] + [ConditionalFact(nameof(ProvidersSupported))] public static void EmptyUriThroughNullCharacter() { Assert.ThrowsAny(() => SafeEvpPKeyHandle.OpenKeyFromProvider("default", "\0")); @@ -127,7 +155,7 @@ public static void Engine_NonExisting() Assert.ThrowsAny(() => SafeEvpPKeyHandle.OpenPublicKeyFromEngine(NonExistingEngineOrProviderKeyName, TestEngineKeyId)); } - [ConditionalFact(typeof(PlatformDetection), nameof(PlatformDetection.OpenSslPresentOnSystem))] + [ConditionalFact(nameof(ProvidersSupported))] public static void Provider_NonExisting() { Assert.ThrowsAny(() => SafeEvpPKeyHandle.OpenKeyFromProvider(NonExistingEngineOrProviderKeyName, AnyProviderKeyUri)); @@ -146,6 +174,63 @@ public static void Provider_NonExistingKey() Assert.ThrowsAny(() => SafeEvpPKeyHandle.OpenKeyFromProvider(Tpm2ProviderName, NonExistingEngineOrProviderKeyName)); } + [ConditionalFact(nameof(ProvidersSupported))] + public static void Provider_Default_RSASignAndDecrypt() + { + using RSA originalKey = RSA.Create(); + string pem = originalKey.ExportRSAPrivateKeyPem(); + + using TempFileHolder pemFile = new TempFileHolder(Encoding.UTF8.GetBytes(pem)); + Uri fileUri = new Uri(pemFile.FilePath); + string keyUri = fileUri.AbsoluteUri; + using SafeEvpPKeyHandle priKeyHandle = SafeEvpPKeyHandle.OpenKeyFromProvider("default", keyUri); + using RSA rsaPri = new RSAOpenSsl(priKeyHandle); + byte[] data = new byte[] { 1, 2, 3, 1, 1, 2, 3 }; + byte[] signature = rsaPri.SignData(data, HashAlgorithmName.SHA256, RSASignaturePadding.Pss); + Assert.True(originalKey.VerifyData(data, signature, HashAlgorithmName.SHA256, RSASignaturePadding.Pss), "signature does not verify with the right key"); + + byte[] encrypted = originalKey.Encrypt(data, RSAEncryptionPadding.OaepSHA256); + byte[] decrypted = rsaPri.Decrypt(encrypted, RSAEncryptionPadding.OaepSHA256); + Assert.Equal(data, decrypted); + } + + [ConditionalFact(nameof(ProvidersSupported))] + public static void Provider_Default_ECDsaSignAndVerify() + { + using ECDsa originalKey = ECDsa.Create(); + string pem = originalKey.ExportECPrivateKeyPem(); + + using TempFileHolder pemFile = new TempFileHolder(Encoding.UTF8.GetBytes(pem)); + Uri fileUri = new Uri(pemFile.FilePath); + string keyUri = fileUri.AbsoluteUri; + using SafeEvpPKeyHandle priKeyHandle = SafeEvpPKeyHandle.OpenKeyFromProvider("default", keyUri); + using ECDsa ecdsaPri = new ECDsaOpenSsl(priKeyHandle); + byte[] data = new byte[] { 1, 2, 3, 1, 1, 2, 3 }; + byte[] signature = ecdsaPri.SignData(data, HashAlgorithmName.SHA256); + Assert.True(originalKey.VerifyData(data, signature, HashAlgorithmName.SHA256), "signature does not verify with the right key"); + } + + [ConditionalFact(nameof(ProvidersSupported))] + public static void Provider_Default_ECDHKeyExchange() + { + using ECDiffieHellman originalAliceKey = ECDiffieHellman.Create(); + string pem = originalAliceKey.ExportECPrivateKeyPem(); + + using TempFileHolder pemFile = new TempFileHolder(Encoding.UTF8.GetBytes(pem)); + Uri fileUri = new Uri(pemFile.FilePath); + string keyUri = fileUri.AbsoluteUri; + using SafeEvpPKeyHandle priKeyHandle = SafeEvpPKeyHandle.OpenKeyFromProvider("default", keyUri); + using ECDiffieHellman alicePri = new ECDiffieHellmanOpenSsl(priKeyHandle); + using ECDiffieHellman bobPri = ECDiffieHellman.Create(alicePri.ExportParameters(false).Curve); + + byte[] sharedSecret1 = originalAliceKey.DeriveRawSecretAgreement(bobPri.PublicKey); + byte[] sharedSecret2 = alicePri.DeriveRawSecretAgreement(bobPri.PublicKey); + byte[] sharedSecret3 = bobPri.DeriveRawSecretAgreement(alicePri.PublicKey); + + Assert.Equal(sharedSecret1, sharedSecret2); + Assert.Equal(sharedSecret1, sharedSecret3); + } + [ConditionalFact(nameof(ShouldRunEngineTests))] public static void Engine_OpenExistingPrivateKey() { diff --git a/src/libraries/System.Security.Cryptography/tests/System.Security.Cryptography.Tests.csproj b/src/libraries/System.Security.Cryptography/tests/System.Security.Cryptography.Tests.csproj index 0dea3f2b5f4..13cda330524 100644 --- a/src/libraries/System.Security.Cryptography/tests/System.Security.Cryptography.Tests.csproj +++ b/src/libraries/System.Security.Cryptography/tests/System.Security.Cryptography.Tests.csproj @@ -519,5 +519,9 @@ + + diff --git a/src/libraries/System.Security.Permissions/System.Security.Permissions.sln b/src/libraries/System.Security.Permissions/System.Security.Permissions.sln index a8c48f68420..898c59947d0 100644 --- a/src/libraries/System.Security.Permissions/System.Security.Permissions.sln +++ b/src/libraries/System.Security.Permissions/System.Security.Permissions.sln @@ -15,6 +15,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", ". EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.Uri", "..\System.Private.Uri\src\System.Private.Uri.csproj", "{6029A164-8081-4469-8248-18FF73050660}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{A97C71B2-9D63-42EC-AC36-4CBAD554B6AB}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{86E25854-BE58-41CF-9DF6-4669C4D23D05}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{E2926598-EE1D-4DA3-AD75-11D54F1EF318}" @@ -255,6 +257,27 @@ Global {6029A164-8081-4469-8248-18FF73050660}.Checked|arm64.ActiveCfg = Debug|Any CPU {6029A164-8081-4469-8248-18FF73050660}.Checked|x64.ActiveCfg = Debug|Any CPU {6029A164-8081-4469-8248-18FF73050660}.Checked|x86.ActiveCfg = Debug|Any CPU + {A97C71B2-9D63-42EC-AC36-4CBAD554B6AB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A97C71B2-9D63-42EC-AC36-4CBAD554B6AB}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A97C71B2-9D63-42EC-AC36-4CBAD554B6AB}.Debug|arm.ActiveCfg = Debug|Any CPU + {A97C71B2-9D63-42EC-AC36-4CBAD554B6AB}.Debug|arm64.ActiveCfg = Debug|Any CPU + {A97C71B2-9D63-42EC-AC36-4CBAD554B6AB}.Debug|x64.ActiveCfg = Debug|Any CPU + {A97C71B2-9D63-42EC-AC36-4CBAD554B6AB}.Debug|x64.Build.0 = Debug|Any CPU + {A97C71B2-9D63-42EC-AC36-4CBAD554B6AB}.Debug|x86.ActiveCfg = Debug|Any CPU + {A97C71B2-9D63-42EC-AC36-4CBAD554B6AB}.Debug|x86.Build.0 = Debug|Any CPU + {A97C71B2-9D63-42EC-AC36-4CBAD554B6AB}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A97C71B2-9D63-42EC-AC36-4CBAD554B6AB}.Release|Any CPU.Build.0 = Release|Any CPU + {A97C71B2-9D63-42EC-AC36-4CBAD554B6AB}.Release|arm.ActiveCfg = Release|Any CPU + {A97C71B2-9D63-42EC-AC36-4CBAD554B6AB}.Release|arm64.ActiveCfg = Release|Any CPU + {A97C71B2-9D63-42EC-AC36-4CBAD554B6AB}.Release|x64.ActiveCfg = Release|Any CPU + {A97C71B2-9D63-42EC-AC36-4CBAD554B6AB}.Release|x64.Build.0 = Release|Any CPU + {A97C71B2-9D63-42EC-AC36-4CBAD554B6AB}.Release|x86.ActiveCfg = Release|Any CPU + {A97C71B2-9D63-42EC-AC36-4CBAD554B6AB}.Release|x86.Build.0 = Release|Any CPU + {A97C71B2-9D63-42EC-AC36-4CBAD554B6AB}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {A97C71B2-9D63-42EC-AC36-4CBAD554B6AB}.Checked|arm.ActiveCfg = Debug|Any CPU + {A97C71B2-9D63-42EC-AC36-4CBAD554B6AB}.Checked|arm64.ActiveCfg = Debug|Any CPU + {A97C71B2-9D63-42EC-AC36-4CBAD554B6AB}.Checked|x64.ActiveCfg = Debug|Any CPU + {A97C71B2-9D63-42EC-AC36-4CBAD554B6AB}.Checked|x86.ActiveCfg = Debug|Any CPU {86E25854-BE58-41CF-9DF6-4669C4D23D05}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {86E25854-BE58-41CF-9DF6-4669C4D23D05}.Debug|Any CPU.Build.0 = Debug|Any CPU {86E25854-BE58-41CF-9DF6-4669C4D23D05}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -569,6 +592,7 @@ Global {F238F227-522D-4886-A6B5-474948B3C660} = {97C6E424-BBBA-495D-8261-E5ADBABA2B29} {19AB8565-1ADA-4E64-B5C8-FD2DA7525358} = {97C6E424-BBBA-495D-8261-E5ADBABA2B29} {C7396F74-3B9A-4FFC-B9E7-45074C6104CF} = {EA13AEBA-B53D-4A6C-8BA1-FB1748B87675} + {A97C71B2-9D63-42EC-AC36-4CBAD554B6AB} = {EA13AEBA-B53D-4A6C-8BA1-FB1748B87675} {86E25854-BE58-41CF-9DF6-4669C4D23D05} = {EA13AEBA-B53D-4A6C-8BA1-FB1748B87675} {E2926598-EE1D-4DA3-AD75-11D54F1EF318} = {EA13AEBA-B53D-4A6C-8BA1-FB1748B87675} {015DEF24-D141-43D4-AF88-67F17F341F32} = {D34F8F34-A420-4794-BDFB-42166D02D866} diff --git a/src/libraries/System.Security.Principal.Windows/System.Security.Principal.Windows.sln b/src/libraries/System.Security.Principal.Windows/System.Security.Principal.Windows.sln index bbf3fa2e1e5..f3643667057 100644 --- a/src/libraries/System.Security.Principal.Windows/System.Security.Principal.Windows.sln +++ b/src/libraries/System.Security.Principal.Windows/System.Security.Principal.Windows.sln @@ -3,6 +3,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\ EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{91CC61A8-4234-4F2E-94D8-6B0CDB66189F}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{EF132522-F23F-406B-9051-125A16B42848}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{BA9F61DE-A8C6-4DE2-85A4-C56D5D3AEAB6}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{589D8BE1-E01B-48B0-859D-FC19DE266CAF}" @@ -57,6 +59,10 @@ Global {91CC61A8-4234-4F2E-94D8-6B0CDB66189F}.Debug|Any CPU.Build.0 = Debug|Any CPU {91CC61A8-4234-4F2E-94D8-6B0CDB66189F}.Release|Any CPU.ActiveCfg = Release|Any CPU {91CC61A8-4234-4F2E-94D8-6B0CDB66189F}.Release|Any CPU.Build.0 = Release|Any CPU + {EF132522-F23F-406B-9051-125A16B42848}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {EF132522-F23F-406B-9051-125A16B42848}.Debug|Any CPU.Build.0 = Debug|Any CPU + {EF132522-F23F-406B-9051-125A16B42848}.Release|Any CPU.ActiveCfg = Release|Any CPU + {EF132522-F23F-406B-9051-125A16B42848}.Release|Any CPU.Build.0 = Release|Any CPU {BA9F61DE-A8C6-4DE2-85A4-C56D5D3AEAB6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {BA9F61DE-A8C6-4DE2-85A4-C56D5D3AEAB6}.Debug|Any CPU.Build.0 = Debug|Any CPU {BA9F61DE-A8C6-4DE2-85A4-C56D5D3AEAB6}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -113,6 +119,7 @@ Global {1F05702D-1F77-4EA3-AFB2-94893104F248} = {0CC51645-FA2D-44E8-9A91-562DF28F2236} {9310D24A-AB63-4CB0-9718-A8C2D57C20FE} = {0CC51645-FA2D-44E8-9A91-562DF28F2236} {91CC61A8-4234-4F2E-94D8-6B0CDB66189F} = {5D05713D-8A07-4460-846C-4FAAE60211D3} + {EF132522-F23F-406B-9051-125A16B42848} = {5D05713D-8A07-4460-846C-4FAAE60211D3} {BA9F61DE-A8C6-4DE2-85A4-C56D5D3AEAB6} = {5D05713D-8A07-4460-846C-4FAAE60211D3} {589D8BE1-E01B-48B0-859D-FC19DE266CAF} = {5D05713D-8A07-4460-846C-4FAAE60211D3} {94DDC2FC-BE34-4364-869A-488B82968F3E} = {4D97C07E-8EAF-45ED-A729-AC7680C2F58F} diff --git a/src/libraries/System.ServiceModel.Syndication/System.ServiceModel.Syndication.sln b/src/libraries/System.ServiceModel.Syndication/System.ServiceModel.Syndication.sln index 85fdfc94bf3..2c98887891c 100644 --- a/src/libraries/System.ServiceModel.Syndication/System.ServiceModel.Syndication.sln +++ b/src/libraries/System.ServiceModel.Syndication/System.ServiceModel.Syndication.sln @@ -1,7 +1,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{66CD0AD6-EBEE-468B-9732-A4C49EF492F4}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{E97F3254-DDEB-4670-9BA0-2889D20873C6}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{18A525B3-2A27-466A-AC80-4DD388887C27}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{6FB3EC19-1083-4AFD-8F7D-FB1224C965A0}" EndProject @@ -47,10 +47,10 @@ Global {66CD0AD6-EBEE-468B-9732-A4C49EF492F4}.Debug|Any CPU.Build.0 = Debug|Any CPU {66CD0AD6-EBEE-468B-9732-A4C49EF492F4}.Release|Any CPU.ActiveCfg = Release|Any CPU {66CD0AD6-EBEE-468B-9732-A4C49EF492F4}.Release|Any CPU.Build.0 = Release|Any CPU - {E97F3254-DDEB-4670-9BA0-2889D20873C6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {E97F3254-DDEB-4670-9BA0-2889D20873C6}.Debug|Any CPU.Build.0 = Debug|Any CPU - {E97F3254-DDEB-4670-9BA0-2889D20873C6}.Release|Any CPU.ActiveCfg = Release|Any CPU - {E97F3254-DDEB-4670-9BA0-2889D20873C6}.Release|Any CPU.Build.0 = Release|Any CPU + {18A525B3-2A27-466A-AC80-4DD388887C27}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {18A525B3-2A27-466A-AC80-4DD388887C27}.Debug|Any CPU.Build.0 = Debug|Any CPU + {18A525B3-2A27-466A-AC80-4DD388887C27}.Release|Any CPU.ActiveCfg = Release|Any CPU + {18A525B3-2A27-466A-AC80-4DD388887C27}.Release|Any CPU.Build.0 = Release|Any CPU {6FB3EC19-1083-4AFD-8F7D-FB1224C965A0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {6FB3EC19-1083-4AFD-8F7D-FB1224C965A0}.Debug|Any CPU.Build.0 = Debug|Any CPU {6FB3EC19-1083-4AFD-8F7D-FB1224C965A0}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -94,7 +94,7 @@ Global GlobalSection(NestedProjects) = preSolution {66CD0AD6-EBEE-468B-9732-A4C49EF492F4} = {38797FCA-196F-4A36-B6E6-1861269F84A8} {0269CAF5-9979-49A1-AC7B-61139BBBA182} = {38797FCA-196F-4A36-B6E6-1861269F84A8} - {E97F3254-DDEB-4670-9BA0-2889D20873C6} = {9727DC59-CDC4-465C-BDCF-01C3CEEC18F5} + {18A525B3-2A27-466A-AC80-4DD388887C27} = {9727DC59-CDC4-465C-BDCF-01C3CEEC18F5} {6FB3EC19-1083-4AFD-8F7D-FB1224C965A0} = {9727DC59-CDC4-465C-BDCF-01C3CEEC18F5} {2A7BBE91-0165-45E9-8A10-D7346C5179B6} = {93DCE9EB-54B4-45FE-BA5D-046CBAD043FA} {02AF5461-4FB0-48B1-AD93-9D5F1022B1E9} = {5C16F923-3CC4-41E8-A22C-ED99BEB8A497} diff --git a/src/libraries/System.ServiceProcess.ServiceController/System.ServiceProcess.ServiceController.sln b/src/libraries/System.ServiceProcess.ServiceController/System.ServiceProcess.ServiceController.sln index cde7b772e22..0976e2edb31 100644 --- a/src/libraries/System.ServiceProcess.ServiceController/System.ServiceProcess.ServiceController.sln +++ b/src/libraries/System.ServiceProcess.ServiceController/System.ServiceProcess.ServiceController.sln @@ -7,7 +7,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Diagnostics.EventLog EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Diagnostics.EventLog", "..\System.Diagnostics.EventLog\src\System.Diagnostics.EventLog.csproj", "{FC3FBFFE-B1BC-4C1B-AC1A-8714767A940E}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{FD427105-4DFB-4DD3-A8B6-99F6F6367B9F}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{F7B3A964-7B92-43EF-8E84-D7AA87B29706}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{C386F669-744B-4DC7-9A8C-C89B5B6C1B00}" EndProject @@ -67,10 +67,10 @@ Global {FC3FBFFE-B1BC-4C1B-AC1A-8714767A940E}.Debug|Any CPU.Build.0 = Debug|Any CPU {FC3FBFFE-B1BC-4C1B-AC1A-8714767A940E}.Release|Any CPU.ActiveCfg = Release|Any CPU {FC3FBFFE-B1BC-4C1B-AC1A-8714767A940E}.Release|Any CPU.Build.0 = Release|Any CPU - {FD427105-4DFB-4DD3-A8B6-99F6F6367B9F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {FD427105-4DFB-4DD3-A8B6-99F6F6367B9F}.Debug|Any CPU.Build.0 = Debug|Any CPU - {FD427105-4DFB-4DD3-A8B6-99F6F6367B9F}.Release|Any CPU.ActiveCfg = Release|Any CPU - {FD427105-4DFB-4DD3-A8B6-99F6F6367B9F}.Release|Any CPU.Build.0 = Release|Any CPU + {F7B3A964-7B92-43EF-8E84-D7AA87B29706}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F7B3A964-7B92-43EF-8E84-D7AA87B29706}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F7B3A964-7B92-43EF-8E84-D7AA87B29706}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F7B3A964-7B92-43EF-8E84-D7AA87B29706}.Release|Any CPU.Build.0 = Release|Any CPU {C386F669-744B-4DC7-9A8C-C89B5B6C1B00}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {C386F669-744B-4DC7-9A8C-C89B5B6C1B00}.Debug|Any CPU.Build.0 = Debug|Any CPU {C386F669-744B-4DC7-9A8C-C89B5B6C1B00}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -124,7 +124,7 @@ Global {BCA9AEAA-30EF-4B5F-B773-219F200CDB25} = {CCD3324D-2948-43FE-B2F2-B386F7EBEC09} {FC3FBFFE-B1BC-4C1B-AC1A-8714767A940E} = {CCD3324D-2948-43FE-B2F2-B386F7EBEC09} {8B01C9B1-1B3A-47A1-9851-CCD3721237BF} = {CCD3324D-2948-43FE-B2F2-B386F7EBEC09} - {FD427105-4DFB-4DD3-A8B6-99F6F6367B9F} = {B5D3C592-0D89-4E68-AAE9-F0411AD9C72C} + {F7B3A964-7B92-43EF-8E84-D7AA87B29706} = {B5D3C592-0D89-4E68-AAE9-F0411AD9C72C} {C386F669-744B-4DC7-9A8C-C89B5B6C1B00} = {B5D3C592-0D89-4E68-AAE9-F0411AD9C72C} {0018BA6B-672A-46E7-894D-B49B84704D29} = {CFE5523B-4A20-49A7-A7A4-42BAE782F74C} {E4F36780-B2E1-4661-AB55-3FD6F4B0E3E9} = {CFE5523B-4A20-49A7-A7A4-42BAE782F74C} diff --git a/src/libraries/System.Speech/System.Speech.sln b/src/libraries/System.Speech/System.Speech.sln index 8be05874fc5..baad7099fff 100644 --- a/src/libraries/System.Speech/System.Speech.sln +++ b/src/libraries/System.Speech/System.Speech.sln @@ -1,7 +1,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{0C0DD088-AF6A-4508-9501-399B92F815A5}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{2B432AE1-F4E7-4A9B-83FC-EB0E8F2A89D4}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{A9001E11-33A0-4D8D-B5A0-2289B2F80360}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{B6DC3B86-B125-412A-81C6-0AFECFE4A08A}" EndProject @@ -47,10 +47,10 @@ Global {0C0DD088-AF6A-4508-9501-399B92F815A5}.Debug|Any CPU.Build.0 = Debug|Any CPU {0C0DD088-AF6A-4508-9501-399B92F815A5}.Release|Any CPU.ActiveCfg = Release|Any CPU {0C0DD088-AF6A-4508-9501-399B92F815A5}.Release|Any CPU.Build.0 = Release|Any CPU - {2B432AE1-F4E7-4A9B-83FC-EB0E8F2A89D4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {2B432AE1-F4E7-4A9B-83FC-EB0E8F2A89D4}.Debug|Any CPU.Build.0 = Debug|Any CPU - {2B432AE1-F4E7-4A9B-83FC-EB0E8F2A89D4}.Release|Any CPU.ActiveCfg = Release|Any CPU - {2B432AE1-F4E7-4A9B-83FC-EB0E8F2A89D4}.Release|Any CPU.Build.0 = Release|Any CPU + {A9001E11-33A0-4D8D-B5A0-2289B2F80360}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A9001E11-33A0-4D8D-B5A0-2289B2F80360}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A9001E11-33A0-4D8D-B5A0-2289B2F80360}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A9001E11-33A0-4D8D-B5A0-2289B2F80360}.Release|Any CPU.Build.0 = Release|Any CPU {B6DC3B86-B125-412A-81C6-0AFECFE4A08A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {B6DC3B86-B125-412A-81C6-0AFECFE4A08A}.Debug|Any CPU.Build.0 = Debug|Any CPU {B6DC3B86-B125-412A-81C6-0AFECFE4A08A}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -94,7 +94,7 @@ Global GlobalSection(NestedProjects) = preSolution {0C0DD088-AF6A-4508-9501-399B92F815A5} = {C516711E-47BF-4337-A52D-DF1E2B29EDCB} {E26B6065-4016-4385-9AB2-EEBE2C97CEE7} = {C516711E-47BF-4337-A52D-DF1E2B29EDCB} - {2B432AE1-F4E7-4A9B-83FC-EB0E8F2A89D4} = {59770FE6-B1BD-4817-8664-DC33233399F5} + {A9001E11-33A0-4D8D-B5A0-2289B2F80360} = {59770FE6-B1BD-4817-8664-DC33233399F5} {B6DC3B86-B125-412A-81C6-0AFECFE4A08A} = {59770FE6-B1BD-4817-8664-DC33233399F5} {2D839561-1430-4CA5-9695-6FC9325FF876} = {6DC14447-3322-4AAA-8FDA-3B48D4AB3A17} {D6377882-BD90-46D6-AC60-83498E4BA2B3} = {3C2EFE00-44E6-4803-BC19-A7DB02BE7747} diff --git a/src/libraries/System.Text.Encoding.CodePages/System.Text.Encoding.CodePages.sln b/src/libraries/System.Text.Encoding.CodePages/System.Text.Encoding.CodePages.sln index 9e2f46eba0d..dddd9995542 100644 --- a/src/libraries/System.Text.Encoding.CodePages/System.Text.Encoding.CodePages.sln +++ b/src/libraries/System.Text.Encoding.CodePages/System.Text.Encoding.CodePages.sln @@ -3,6 +3,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\ EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{C8969563-5ACD-4DC3-B7E0-815118EC12DA}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{E3FE5C56-2A80-4749-A1B7-A73658FB278D}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{98A6E39D-1A5A-48F6-885F-C4638867437B}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{AF9B7A62-8184-4D20-A237-7403EE03CB2E}" @@ -55,6 +57,10 @@ Global {C8969563-5ACD-4DC3-B7E0-815118EC12DA}.Debug|Any CPU.Build.0 = Debug|Any CPU {C8969563-5ACD-4DC3-B7E0-815118EC12DA}.Release|Any CPU.ActiveCfg = Release|Any CPU {C8969563-5ACD-4DC3-B7E0-815118EC12DA}.Release|Any CPU.Build.0 = Release|Any CPU + {E3FE5C56-2A80-4749-A1B7-A73658FB278D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E3FE5C56-2A80-4749-A1B7-A73658FB278D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E3FE5C56-2A80-4749-A1B7-A73658FB278D}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E3FE5C56-2A80-4749-A1B7-A73658FB278D}.Release|Any CPU.Build.0 = Release|Any CPU {98A6E39D-1A5A-48F6-885F-C4638867437B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {98A6E39D-1A5A-48F6-885F-C4638867437B}.Debug|Any CPU.Build.0 = Debug|Any CPU {98A6E39D-1A5A-48F6-885F-C4638867437B}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -107,6 +113,7 @@ Global {E9DABA44-B5F3-4E9B-B9FC-54E558831847} = {8CB6F00C-76CE-4F7F-9748-64DD94323A65} {41C87552-FF98-4814-AD4E-B8E63840C8D5} = {8CB6F00C-76CE-4F7F-9748-64DD94323A65} {C8969563-5ACD-4DC3-B7E0-815118EC12DA} = {74B63852-3633-4913-8CA4-54713240919C} + {E3FE5C56-2A80-4749-A1B7-A73658FB278D} = {74B63852-3633-4913-8CA4-54713240919C} {98A6E39D-1A5A-48F6-885F-C4638867437B} = {74B63852-3633-4913-8CA4-54713240919C} {AF9B7A62-8184-4D20-A237-7403EE03CB2E} = {74B63852-3633-4913-8CA4-54713240919C} {23B5042D-5ACE-4BB0-A802-1DB758F43428} = {D39B4CF8-10D4-4167-BF2D-FE1BAF33D98D} diff --git a/src/libraries/System.Text.Encoding.Extensions/System.Text.Encoding.Extensions.sln b/src/libraries/System.Text.Encoding.Extensions/System.Text.Encoding.Extensions.sln index 61ae88b2408..87f64654da7 100644 --- a/src/libraries/System.Text.Encoding.Extensions/System.Text.Encoding.Extensions.sln +++ b/src/libraries/System.Text.Encoding.Extensions/System.Text.Encoding.Extensions.sln @@ -7,6 +7,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib.Gene EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\System.Private.CoreLib\ref\System.Private.CoreLib.csproj", "{D6104D98-DF18-4142-A171-E1A38BA8512E}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{FBEDD451-1F64-43E3-9B55-E166E33906C4}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{2D766334-1ABC-46EF-9065-0945A3981D99}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{2A579CCA-3FAC-46A0-A49F-F63F1DC693BB}" @@ -157,6 +159,27 @@ Global {D6104D98-DF18-4142-A171-E1A38BA8512E}.Checked|arm64.ActiveCfg = Debug|Any CPU {D6104D98-DF18-4142-A171-E1A38BA8512E}.Checked|x64.ActiveCfg = Debug|Any CPU {D6104D98-DF18-4142-A171-E1A38BA8512E}.Checked|x86.ActiveCfg = Debug|Any CPU + {FBEDD451-1F64-43E3-9B55-E166E33906C4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {FBEDD451-1F64-43E3-9B55-E166E33906C4}.Debug|Any CPU.Build.0 = Debug|Any CPU + {FBEDD451-1F64-43E3-9B55-E166E33906C4}.Debug|arm.ActiveCfg = Debug|Any CPU + {FBEDD451-1F64-43E3-9B55-E166E33906C4}.Debug|arm64.ActiveCfg = Debug|Any CPU + {FBEDD451-1F64-43E3-9B55-E166E33906C4}.Debug|x64.ActiveCfg = Debug|Any CPU + {FBEDD451-1F64-43E3-9B55-E166E33906C4}.Debug|x64.Build.0 = Debug|Any CPU + {FBEDD451-1F64-43E3-9B55-E166E33906C4}.Debug|x86.ActiveCfg = Debug|Any CPU + {FBEDD451-1F64-43E3-9B55-E166E33906C4}.Debug|x86.Build.0 = Debug|Any CPU + {FBEDD451-1F64-43E3-9B55-E166E33906C4}.Release|Any CPU.ActiveCfg = Release|Any CPU + {FBEDD451-1F64-43E3-9B55-E166E33906C4}.Release|Any CPU.Build.0 = Release|Any CPU + {FBEDD451-1F64-43E3-9B55-E166E33906C4}.Release|arm.ActiveCfg = Release|Any CPU + {FBEDD451-1F64-43E3-9B55-E166E33906C4}.Release|arm64.ActiveCfg = Release|Any CPU + {FBEDD451-1F64-43E3-9B55-E166E33906C4}.Release|x64.ActiveCfg = Release|Any CPU + {FBEDD451-1F64-43E3-9B55-E166E33906C4}.Release|x64.Build.0 = Release|Any CPU + {FBEDD451-1F64-43E3-9B55-E166E33906C4}.Release|x86.ActiveCfg = Release|Any CPU + {FBEDD451-1F64-43E3-9B55-E166E33906C4}.Release|x86.Build.0 = Release|Any CPU + {FBEDD451-1F64-43E3-9B55-E166E33906C4}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {FBEDD451-1F64-43E3-9B55-E166E33906C4}.Checked|arm.ActiveCfg = Debug|Any CPU + {FBEDD451-1F64-43E3-9B55-E166E33906C4}.Checked|arm64.ActiveCfg = Debug|Any CPU + {FBEDD451-1F64-43E3-9B55-E166E33906C4}.Checked|x64.ActiveCfg = Debug|Any CPU + {FBEDD451-1F64-43E3-9B55-E166E33906C4}.Checked|x86.ActiveCfg = Debug|Any CPU {2D766334-1ABC-46EF-9065-0945A3981D99}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {2D766334-1ABC-46EF-9065-0945A3981D99}.Debug|Any CPU.Build.0 = Debug|Any CPU {2D766334-1ABC-46EF-9065-0945A3981D99}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -398,6 +421,7 @@ Global {CC6D3524-D6C8-468B-B908-CE746C1DB175} = {6A521BB6-5A53-4871-8EF7-15C4FCF0B416} {777B4928-6EE5-42D2-8F95-E43EB027D14E} = {6A521BB6-5A53-4871-8EF7-15C4FCF0B416} {0FB90CF0-6B17-4FAB-A737-0532B5BCAADB} = {6906BA55-F0A0-4E71-942D-E24C6C85A353} + {FBEDD451-1F64-43E3-9B55-E166E33906C4} = {6906BA55-F0A0-4E71-942D-E24C6C85A353} {2D766334-1ABC-46EF-9065-0945A3981D99} = {6906BA55-F0A0-4E71-942D-E24C6C85A353} {2A579CCA-3FAC-46A0-A49F-F63F1DC693BB} = {6906BA55-F0A0-4E71-942D-E24C6C85A353} {D6104D98-DF18-4142-A171-E1A38BA8512E} = {F4F19285-4785-496C-8F6C-579249EAA5BB} diff --git a/src/libraries/System.Text.Encodings.Web/System.Text.Encodings.Web.sln b/src/libraries/System.Text.Encodings.Web/System.Text.Encodings.Web.sln index 1da7867a73d..425eac5c4c9 100644 --- a/src/libraries/System.Text.Encodings.Web/System.Text.Encodings.Web.sln +++ b/src/libraries/System.Text.Encodings.Web/System.Text.Encodings.Web.sln @@ -1,7 +1,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{43450381-504E-4603-BF5D-99CCAC2B8A26}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{4D066E4F-1EF9-46CE-AECC-8D5252E41370}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{8C1D4138-1D73-4C7B-8CDF-15AD329B35CC}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{1C02A4C6-2AEB-46E3-B1D3-84EE2153671A}" EndProject @@ -49,10 +49,10 @@ Global {43450381-504E-4603-BF5D-99CCAC2B8A26}.Debug|Any CPU.Build.0 = Debug|Any CPU {43450381-504E-4603-BF5D-99CCAC2B8A26}.Release|Any CPU.ActiveCfg = Release|Any CPU {43450381-504E-4603-BF5D-99CCAC2B8A26}.Release|Any CPU.Build.0 = Release|Any CPU - {4D066E4F-1EF9-46CE-AECC-8D5252E41370}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {4D066E4F-1EF9-46CE-AECC-8D5252E41370}.Debug|Any CPU.Build.0 = Debug|Any CPU - {4D066E4F-1EF9-46CE-AECC-8D5252E41370}.Release|Any CPU.ActiveCfg = Release|Any CPU - {4D066E4F-1EF9-46CE-AECC-8D5252E41370}.Release|Any CPU.Build.0 = Release|Any CPU + {8C1D4138-1D73-4C7B-8CDF-15AD329B35CC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {8C1D4138-1D73-4C7B-8CDF-15AD329B35CC}.Debug|Any CPU.Build.0 = Debug|Any CPU + {8C1D4138-1D73-4C7B-8CDF-15AD329B35CC}.Release|Any CPU.ActiveCfg = Release|Any CPU + {8C1D4138-1D73-4C7B-8CDF-15AD329B35CC}.Release|Any CPU.Build.0 = Release|Any CPU {1C02A4C6-2AEB-46E3-B1D3-84EE2153671A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {1C02A4C6-2AEB-46E3-B1D3-84EE2153671A}.Debug|Any CPU.Build.0 = Debug|Any CPU {1C02A4C6-2AEB-46E3-B1D3-84EE2153671A}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -100,7 +100,7 @@ Global GlobalSection(NestedProjects) = preSolution {43450381-504E-4603-BF5D-99CCAC2B8A26} = {9DE01EE3-CDAF-4B6E-B778-B5B5D83A9214} {A15B95D2-1DDF-47C9-A92F-03FD5DB720C9} = {9DE01EE3-CDAF-4B6E-B778-B5B5D83A9214} - {4D066E4F-1EF9-46CE-AECC-8D5252E41370} = {BAAA946F-C5D8-483D-9610-F229125AFEFC} + {8C1D4138-1D73-4C7B-8CDF-15AD329B35CC} = {BAAA946F-C5D8-483D-9610-F229125AFEFC} {1C02A4C6-2AEB-46E3-B1D3-84EE2153671A} = {BAAA946F-C5D8-483D-9610-F229125AFEFC} {01218F2E-9DAB-42A4-B79C-589C53CE63E4} = {2E59B32B-BED2-4E24-9055-491C8DF351FB} {635D1626-6D21-4DAB-BFEF-F5F13261967B} = {2E59B32B-BED2-4E24-9055-491C8DF351FB} diff --git a/src/libraries/System.Text.Encodings.Web/src/System.Text.Encodings.Web.csproj b/src/libraries/System.Text.Encodings.Web/src/System.Text.Encodings.Web.csproj index 4f10f6e6254..2fba3b5e13b 100644 --- a/src/libraries/System.Text.Encodings.Web/src/System.Text.Encodings.Web.csproj +++ b/src/libraries/System.Text.Encodings.Web/src/System.Text.Encodings.Web.csproj @@ -1,7 +1,7 @@ - $(NetCoreAppCurrent)-browser;$(NetCoreAppCurrent);$(NetCoreAppMinimum)-browser;$(NetCoreAppMinimum);netstandard2.0;$(NetFrameworkMinimum) + $(NetCoreAppCurrent)-browser;$(NetCoreAppCurrent)-wasi;$(NetCoreAppCurrent);$(NetCoreAppMinimum)-browser;$(NetCoreAppMinimum);netstandard2.0;$(NetFrameworkMinimum) $(TargetFrameworks);$(NetCoreAppPrevious)-windows;$(NetCoreAppPrevious) true diff --git a/src/libraries/System.Text.Json/System.Text.Json.sln b/src/libraries/System.Text.Json/System.Text.Json.sln index 489928dd62f..ae05178608d 100644 --- a/src/libraries/System.Text.Json/System.Text.Json.sln +++ b/src/libraries/System.Text.Json/System.Text.Json.sln @@ -23,6 +23,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Memory", "..\System. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{715327DF-D6D6-4043-AC78-FA58F0C0E9E3}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{C1CC8519-9AFA-4E9D-BB18-F667E232210B}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{B815304D-502E-402C-ACE1-878DB4985CCC}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{E4B72517-C694-486A-950E-6AB03C651FDC}" @@ -141,6 +143,10 @@ Global {715327DF-D6D6-4043-AC78-FA58F0C0E9E3}.Debug|Any CPU.Build.0 = Debug|Any CPU {715327DF-D6D6-4043-AC78-FA58F0C0E9E3}.Release|Any CPU.ActiveCfg = Release|Any CPU {715327DF-D6D6-4043-AC78-FA58F0C0E9E3}.Release|Any CPU.Build.0 = Release|Any CPU + {C1CC8519-9AFA-4E9D-BB18-F667E232210B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {C1CC8519-9AFA-4E9D-BB18-F667E232210B}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C1CC8519-9AFA-4E9D-BB18-F667E232210B}.Release|Any CPU.ActiveCfg = Release|Any CPU + {C1CC8519-9AFA-4E9D-BB18-F667E232210B}.Release|Any CPU.Build.0 = Release|Any CPU {B815304D-502E-402C-ACE1-878DB4985CCC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {B815304D-502E-402C-ACE1-878DB4985CCC}.Debug|Any CPU.Build.0 = Debug|Any CPU {B815304D-502E-402C-ACE1-878DB4985CCC}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -267,6 +273,7 @@ Global {C56337BB-8CBC-4EE5-AB4D-8BB0A922813E} = {0371C5D8-D5F5-4747-9810-D91D71D8C0E4} {7015E94D-D20D-48C8-86D7-6A996BE99E0E} = {0371C5D8-D5F5-4747-9810-D91D71D8C0E4} {715327DF-D6D6-4043-AC78-FA58F0C0E9E3} = {F254F143-4704-4432-9995-20D87FA8BF8D} + {C1CC8519-9AFA-4E9D-BB18-F667E232210B} = {F254F143-4704-4432-9995-20D87FA8BF8D} {B815304D-502E-402C-ACE1-878DB4985CCC} = {F254F143-4704-4432-9995-20D87FA8BF8D} {E4B72517-C694-486A-950E-6AB03C651FDC} = {F254F143-4704-4432-9995-20D87FA8BF8D} {04AEB008-EE4F-44DE-A361-2DBD2D0FD6A4} = {F254F143-4704-4432-9995-20D87FA8BF8D} diff --git a/src/libraries/System.Text.Json/gen/JsonSourceGenerator.DiagnosticDescriptors.cs b/src/libraries/System.Text.Json/gen/JsonSourceGenerator.DiagnosticDescriptors.cs index 3d19fbe8688..688cc31f866 100644 --- a/src/libraries/System.Text.Json/gen/JsonSourceGenerator.DiagnosticDescriptors.cs +++ b/src/libraries/System.Text.Json/gen/JsonSourceGenerator.DiagnosticDescriptors.cs @@ -123,6 +123,14 @@ internal static class DiagnosticDescriptors category: JsonConstants.SystemTextJsonSourceGenerationName, defaultSeverity: DiagnosticSeverity.Warning, isEnabledByDefault: true); + + public static DiagnosticDescriptor TypeContainsRefLikeMember { get; } = DiagnosticDescriptorHelper.Create( + id: "SYSLIB1225", + title: new LocalizableResourceString(nameof(SR.TypeContainsRefLikeMemberTitle), SR.ResourceManager, typeof(FxResources.System.Text.Json.SourceGeneration.SR)), + messageFormat: new LocalizableResourceString(nameof(SR.TypeContainsRefLikeMemberFormat), SR.ResourceManager, typeof(FxResources.System.Text.Json.SourceGeneration.SR)), + category: JsonConstants.SystemTextJsonSourceGenerationName, + defaultSeverity: DiagnosticSeverity.Warning, + isEnabledByDefault: true); } } } diff --git a/src/libraries/System.Text.Json/gen/JsonSourceGenerator.Parser.cs b/src/libraries/System.Text.Json/gen/JsonSourceGenerator.Parser.cs index 5c3d3aa9474..d7c9bc72041 100644 --- a/src/libraries/System.Text.Json/gen/JsonSourceGenerator.Parser.cs +++ b/src/libraries/System.Text.Json/gen/JsonSourceGenerator.Parser.cs @@ -522,7 +522,7 @@ private TypeGenerationSpec ParseTypeGenerationSpec(in TypeToGenerate typeToGener out TypeRef? customConverterType, out bool isPolymorphic); - if (type is INamedTypeSymbol { IsUnboundGenericType: true } or IErrorTypeSymbol) + if (type is { IsRefLikeType: true } or INamedTypeSymbol { IsUnboundGenericType: true } or IErrorTypeSymbol) { classType = ClassType.TypeUnsupportedBySourceGen; } @@ -574,6 +574,12 @@ private TypeGenerationSpec ParseTypeGenerationSpec(in TypeToGenerate typeToGener immutableCollectionFactoryTypeFullName = null; collectionType = default; } + else if (valueType.IsRefLikeType || keyType?.IsRefLikeType is true) + { + classType = ClassType.TypeUnsupportedBySourceGen; + immutableCollectionFactoryTypeFullName = null; + collectionType = default; + } else { if (type.CanUseDefaultConstructorForDeserialization(out IMethodSymbol? defaultCtor)) @@ -1165,6 +1171,17 @@ private bool IsValidDataExtensionPropertyType(ITypeSymbol type) return null; } + if (memberType.IsRefLikeType) + { + // Skip all ref-like members and emit a diagnostic unless the property is being explicitly ignored. + if (ignoreCondition is not JsonIgnoreCondition.Always) + { + ReportDiagnostic(DiagnosticDescriptors.TypeContainsRefLikeMember, memberInfo.GetLocation(), declaringType.Name, memberInfo.Name); + } + + return null; + } + string effectiveJsonPropertyName = DetermineEffectiveJsonPropertyName(memberInfo.Name, jsonPropertyName, options); string propertyNameFieldName = DeterminePropertyNameFieldName(effectiveJsonPropertyName); @@ -1246,62 +1263,60 @@ private void ProcessMemberCustomAttributes( switch (attributeType.ToDisplayString()) { case JsonIgnoreAttributeFullName: + { + ImmutableArray> namedArgs = attributeData.NamedArguments; + + if (namedArgs.Length == 0) { - ImmutableArray> namedArgs = attributeData.NamedArguments; - - if (namedArgs.Length == 0) - { - ignoreCondition = JsonIgnoreCondition.Always; - } - else if (namedArgs.Length == 1 && - namedArgs[0].Value.Type?.ToDisplayString() == JsonIgnoreConditionFullName) - { - ignoreCondition = (JsonIgnoreCondition)namedArgs[0].Value.Value!; - } + ignoreCondition = JsonIgnoreCondition.Always; } - break; - case JsonIncludeAttributeFullName: + else if (namedArgs.Length == 1 && + namedArgs[0].Value.Type?.ToDisplayString() == JsonIgnoreConditionFullName) { - hasJsonInclude = true; + ignoreCondition = (JsonIgnoreCondition)namedArgs[0].Value.Value!; } break; + } + case JsonIncludeAttributeFullName: + { + hasJsonInclude = true; + break; + } case JsonNumberHandlingAttributeFullName: - { - ImmutableArray ctorArgs = attributeData.ConstructorArguments; - numberHandling = (JsonNumberHandling)ctorArgs[0].Value!; - } + { + ImmutableArray ctorArgs = attributeData.ConstructorArguments; + numberHandling = (JsonNumberHandling)ctorArgs[0].Value!; break; + } case JsonObjectCreationHandlingAttributeFullName: - { - ImmutableArray ctorArgs = attributeData.ConstructorArguments; - objectCreationHandling = (JsonObjectCreationHandling)ctorArgs[0].Value!; - } + { + ImmutableArray ctorArgs = attributeData.ConstructorArguments; + objectCreationHandling = (JsonObjectCreationHandling)ctorArgs[0].Value!; break; + } case JsonPropertyNameAttributeFullName: - { - ImmutableArray ctorArgs = attributeData.ConstructorArguments; - jsonPropertyName = (string)ctorArgs[0].Value!; - // Null check here is done at runtime within JsonSerializer. - } + { + ImmutableArray ctorArgs = attributeData.ConstructorArguments; + jsonPropertyName = (string)ctorArgs[0].Value!; + // Null check here is done at runtime within JsonSerializer. break; + } case JsonPropertyOrderAttributeFullName: - { - ImmutableArray ctorArgs = attributeData.ConstructorArguments; - order = (int)ctorArgs[0].Value!; - } + { + ImmutableArray ctorArgs = attributeData.ConstructorArguments; + order = (int)ctorArgs[0].Value!; break; + } case JsonExtensionDataAttributeFullName: - { - isExtensionData = true; - } + { + isExtensionData = true; break; + } case JsonRequiredAttributeFullName: - { - hasJsonRequiredAttribute = true; - } - break; - default: + { + hasJsonRequiredAttribute = true; break; + } } } } @@ -1433,7 +1448,7 @@ private void ProcessMember( if (paramCount == 0) { constructionStrategy = ObjectConstructionStrategy.ParameterlessConstructor; - constructorParameters = Array.Empty(); + constructorParameters = []; } else { @@ -1445,6 +1460,14 @@ private void ProcessMember( for (int i = 0; i < paramCount; i++) { IParameterSymbol parameterInfo = constructor.Parameters[i]; + + if (parameterInfo.Type.IsRefLikeType) + { + ReportDiagnostic(DiagnosticDescriptors.TypeContainsRefLikeMember, parameterInfo.GetLocation(), type.Name, parameterInfo.Name); + constructionStrategy = ObjectConstructionStrategy.NotApplicable; + continue; + } + TypeRef parameterTypeRef = EnqueueType(parameterInfo.Type, typeToGenerate.Mode); constructorParameters[i] = new ParameterGenerationSpec @@ -1459,7 +1482,7 @@ private void ProcessMember( } } - return constructorParameters; + return constructionStrategy is ObjectConstructionStrategy.NotApplicable ? null : constructorParameters; } private List? ParsePropertyInitializers( diff --git a/src/libraries/System.Text.Json/gen/Resources/Strings.resx b/src/libraries/System.Text.Json/gen/Resources/Strings.resx index 519cbffa3ec..5c2d06929aa 100644 --- a/src/libraries/System.Text.Json/gen/Resources/Strings.resx +++ b/src/libraries/System.Text.Json/gen/Resources/Strings.resx @@ -207,4 +207,10 @@ The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. + + Type includes ref like property, field or constructor parameter. + + + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + diff --git a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.cs.xlf b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.cs.xlf index 96bb2680ffc..8ce5d1c5251 100644 --- a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.cs.xlf +++ b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.cs.xlf @@ -24,17 +24,17 @@ The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. - Generátor zdroje nepodporuje vlastní atribut „{0}“ odvozený od atributu JsonConverterAttribute. + The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. Attributes deriving from JsonConverterAttribute are not supported by the source generator. - Zdrojový generátor nepodporuje atributy odvozené od atributu JsonConverterAttribute. + Attributes deriving from JsonConverterAttribute are not supported by the source generator. There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. - Existuje více typů s názvem „{0}“. Zdroj byl vygenerován pro první zjiÅ¡tÄ›ný zdroj. K vyÅ™eÅ¡ení této kolize použijte JsonSerializableAttribute.TypeInfoPropertyName. + There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. @@ -44,12 +44,12 @@ Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. - Typ {0} je anotován atributem JsonDerivedTypeAttribute, který se v JsonSourceGenerationMode.Serialization nepodporuje. + Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. - Atribut JsonDerivedTypeAttribute se v JsonSourceGenerationMode.Serialization nepodporuje. + 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. @@ -74,52 +74,52 @@ The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. - Konstruktor typu {0} byl opatÅ™en poznámkou s atributem JsonConstructorAttribute, ale zdrojový generátor k nÄ›mu nemá přístup. + The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. Constructor annotated with JsonConstructorAttribute is inaccessible. - Konstruktor anotovaný atributem JsonConstructorAttribute je nepřístupný. + Constructor annotated with JsonConstructorAttribute is inaccessible. The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. - Typ JsonConverterAttribute {0} specifikovaný u Älenu {1} není typem konvertoru nebo neobsahuje přístupný konstruktor bez parametrů. + The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. - JsonConverterAttribute.Type obsahuje neplatný nebo nepřístupný argument. + The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. - Typ „{0}“ byl anotován atributem JsonSerializableAttribute, ale není odvozen od třídy JsonSerializerContext. Nebude vygenerován žádný zdrojový kód. + The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. - Typy anotované atributem JsonSerializableAttribute musí být třídy odvozené od třídy JsonSerializerContext. + Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. - ÄŒlen {0} byl opatÅ™en poznámkou jsonStringEnumConverter, což není v nativním AOT podporováno. Zvažte použití obecného objektu JsonStringEnumConverter<TEnum>. + The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. The non-generic 'JsonStringEnumConverter' requires dynamic code. - Neobecný objekt JsonStringEnumConverter vyžaduje dynamický kód. + The non-generic 'JsonStringEnumConverter' requires dynamic code. The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. - Zdrojový generátor System.Text.Json není k dispozici v jazyce C# {0}. Použijte prosím jazykovou verzi {1} nebo vyšší. + The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - Zdrojový generátor nepodporuje jazykovou verzi jazyka C#. + C# language version not supported by the source generator. @@ -142,6 +142,16 @@ Typ obsahuje více Älenů s komentářem JsonExtensionDataAttribute + + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + + + + Type includes ref like property, field or constructor parameter. + Type includes ref like property, field or constructor parameter. + + Did not generate serialization metadata for type '{0}'. Nevygenerovala se metadata serializace pro typ {0}. diff --git a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.de.xlf b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.de.xlf index dbc6ca2ae2b..f90970da49a 100644 --- a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.de.xlf +++ b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.de.xlf @@ -24,17 +24,17 @@ The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. - Das von JsonConverterAttribute abgeleitete benutzerdefinierte Attribut "{0}" wird vom Quellgenerator nicht unterstützt. + The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. Attributes deriving from JsonConverterAttribute are not supported by the source generator. - Von JsonConverterAttribute abgeleitete Attribute werden vom Quellgenerator nicht unterstützt. + Attributes deriving from JsonConverterAttribute are not supported by the source generator. There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. - Es gibt mehrere Typen mit dem Namen "{0}". Die Quelle wurde für die erste erkannte Quelle generiert. Verwenden Sie "JsonSerializableAttribute.TypeInfoPropertyName", um diesen Konflikt zu beheben. + There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. @@ -44,12 +44,12 @@ Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. - Der Typ „{0}“ ist mit „JsonDerivedTypeAttribute“ versehen, was in „JsonSourceGenerationMode.Serialization“ nicht unterstützt wird. + Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. - „JsonDerivedTypeAttribute“ wird in „JsonSourceGenerationMode.Serialization“ nicht unterstützt. + 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. @@ -74,52 +74,52 @@ The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. - Der Konstruktor für den Typ "{0}" wurde mit dem Kommentar "JsonConstructorAttribute" versehen, aber der Quellgenerator kann nicht darauf zugreifen. + The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. Constructor annotated with JsonConstructorAttribute is inaccessible. - Auf den Konstruktor mit dem Kommentar "JsonConstructorAttribute" kann nicht zugegriffen werden. + Constructor annotated with JsonConstructorAttribute is inaccessible. The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. - Der für den Member "{1}" angegebene JsonConverterAttribute-Typ "{0}" ist kein Konvertertyp oder enthält keinen parameterlosen Konstruktor, auf den zugegriffen werden kann. + The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. - "JsonConverterAttribute.Type" enthält ein ungültiges oder nicht zugängliches Argument. + The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. - Der Typ "{0}" wurde mit JsonSerializableAttribute kommentiert, ist aber nicht von JsonSerializerContext abgeleitet. Es wird kein Quellcode generiert. + The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. - Mit JsonSerializableAttribute kommentierte Typen müssen Klassen sein, die von JsonSerializerContext abgeleitet werden. + Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. - Der Member "{0}" wurde mit "JsonStringEnumConverter" kommentiert, was in nativem AOT nicht unterstützt wird. Erwägen Sie stattdessen die Verwendung des generischen "JsonStringEnumConverter<TEnum>". + The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. The non-generic 'JsonStringEnumConverter' requires dynamic code. - Der nicht generische "JsonStringEnumConverter" erfordert dynamischen Code. + The non-generic 'JsonStringEnumConverter' requires dynamic code. The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. - Der System.Text.Json-Quellgenerator ist in C# {0} nicht verfügbar. Verwenden Sie die Sprachversion {1} oder höher. + The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - Die C#-Sprachversion wird vom Quellgenerator nicht unterstützt. + C# language version not supported by the source generator. @@ -142,6 +142,16 @@ Der Typ enthält mehrere Elemente, die mit dem JsonExtensionDataAttribute versehen sind. + + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + + + + Type includes ref like property, field or constructor parameter. + Type includes ref like property, field or constructor parameter. + + Did not generate serialization metadata for type '{0}'. Die Serialisierungsmetadaten für den Typ "{0}" wurden nicht generiert. diff --git a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.es.xlf b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.es.xlf index 878fa15bc7e..af2e5c2c0e7 100644 --- a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.es.xlf +++ b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.es.xlf @@ -24,17 +24,17 @@ The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. - El generador de origen no admite el atributo personalizado '{0}' derivado de JsonConverterAttribute. + The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. Attributes deriving from JsonConverterAttribute are not supported by the source generator. - El generador de origen no admite los atributos derivados de JsonConverterAttribute. + Attributes deriving from JsonConverterAttribute are not supported by the source generator. There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. - Hay varios tipos denominados "{0}". El origen se generó para el primero detectado. Use "JsonSerializableAttribute.TypeInfoPropertyName" para resolver esta colisión. + There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. @@ -44,12 +44,12 @@ Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. - El tipo \"{0}\" está anotado con \"JsonDerivedTypeAttribute\", que no se admite en \"JsonSourceGenerationMode.Serialization\". + Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. - \"JsonDerivedTypeAttribute\" no se admite en \"JsonSourceGenerationMode.Serialization\". + 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. @@ -74,52 +74,52 @@ The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. - El constructor del tipo '{0}' se ha anotado con JsonConstructorAttribute, pero el generador de origen no puede acceder a él. + The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. Constructor annotated with JsonConstructorAttribute is inaccessible. - No se puede acceder al constructor anotado con JsonConstructorAttribute. + Constructor annotated with JsonConstructorAttribute is inaccessible. The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. - El tipo “JsonConverterAttribute†“{0}†especificado en el miembro “{1}†no es un tipo de convertidor o no contiene un constructor sin parámetros accesible. + The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. - “JsonConverterAttribute.Type†contiene un argumento no válido o inaccesible. + The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. - El tipo "{0}" se ha anotado con JsonSerializableAttribute, pero no se deriva de JsonSerializerContext. No se generará ningún código fuente. + The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. - Los tipos anotados con JsonSerializableAttribute deben ser clases derivadas de JsonSerializerContext. + Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. - El miembro '{0}' se ha anotado con 'JsonStringEnumConverter', que no se admite en AOT nativo. Considere la posibilidad de usar el elemento genérico "JsonStringEnumConverter<TEnum>" en su lugar. + The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. The non-generic 'JsonStringEnumConverter' requires dynamic code. - El elemento 'JsonStringEnumConverter' no genérico requiere código dinámico. + The non-generic 'JsonStringEnumConverter' requires dynamic code. The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. - El generador de origen System.Text.Json no está disponible en C# {0}. Use la versión de idioma {1} o superior. + The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - La versión del idioma C# no es compatible con el generador de origen. + C# language version not supported by the source generator. @@ -142,6 +142,16 @@ El tipo tiene varios miembros anotados con JsonExtensionDataAttribute. + + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + + + + Type includes ref like property, field or constructor parameter. + Type includes ref like property, field or constructor parameter. + + Did not generate serialization metadata for type '{0}'. No generó metadatos de serialización para el tipo '{0}". diff --git a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.fr.xlf b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.fr.xlf index fbf12b5a733..ebfac4b19e7 100644 --- a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.fr.xlf +++ b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.fr.xlf @@ -24,17 +24,17 @@ The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. - L'attribut personnalisé '{0}' dérivant de JsonConverterAttribute n'est pas pris en charge par le générateur source. + The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. Attributes deriving from JsonConverterAttribute are not supported by the source generator. - Les attributs dérivant de JsonConverterAttribute ne sont pas pris en charge par le générateur de source. + Attributes deriving from JsonConverterAttribute are not supported by the source generator. There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. - Il existe plusieurs types nommés '{0}'. La source a été générée pour le premier détecté. Utilisez 'JsonSerializableAttribute.TypeInfoPropertyName' pour résoudre cette collision. + There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. @@ -44,12 +44,12 @@ Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. - Le type « {0} » est annoté avec « JsonDerivedTypeAttribute », ce qui n’est pas pris en charge dans « JsonSourceGenerationMode.Serialization ». + Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. - « JsonDerivedTypeAttribute » n’est pas pris en charge dans « JsonSourceGenerationMode.Serialization ». + 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. @@ -74,52 +74,52 @@ The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. - Le constructeur sur le type '{0}' a été annoté avec JsonConstructorAttribute mais n'est pas accessible par le générateur source. + The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. Constructor annotated with JsonConstructorAttribute is inaccessible. - Le constructeur annoté avec JsonConstructorAttribute est inaccessible. + Constructor annotated with JsonConstructorAttribute is inaccessible. The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. - Le type 'JsonConverterAttribute' '{0}' spécifié sur le membre '{1}' n’est pas un type convertisseur ou ne contient pas de constructeur sans paramètre accessible. + The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. - 'JsonConverterAttribute.Type' contient un argument non valide ou inaccessible. + The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. - Le type '{0}' a été annoté avec l'attribut JsonSerializable mais ne dérive pas de JsonSerializerContext. Aucun code source ne sera généré. + The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. - Les types annotés avec l'attribut JsonSerializable doivent être des classes dérivant de JsonSerializerContext. + Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. - Le membre '{0}' a été annoté avec 'JsonStringEnumConverter', ce qui n’est pas pris en charge dans AOT natif. Utilisez plutôt le générique 'JsonStringEnumConverter<TEnum>'. + The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. The non-generic 'JsonStringEnumConverter' requires dynamic code. - Le 'JsonStringEnumConverter' non générique requiert du code dynamique. + The non-generic 'JsonStringEnumConverter' requires dynamic code. The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. - Le générateur de source System.Text.Json n'est pas disponible en C# « {0} ». Veuillez utiliser la version linguistique {1} ou supérieure. + The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - Version du langage C# non prise en charge par le générateur de source. + C# language version not supported by the source generator. @@ -142,6 +142,16 @@ Le type comporte plusieurs membres annotés avec JsonExtensionDataAttribute. + + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + + + + Type includes ref like property, field or constructor parameter. + Type includes ref like property, field or constructor parameter. + + Did not generate serialization metadata for type '{0}'. Les métadonnées de sérialisation pour le type « {0} » n’ont pas été générées. diff --git a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.it.xlf b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.it.xlf index 04d5cf68ef4..2796b1a3c4a 100644 --- a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.it.xlf +++ b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.it.xlf @@ -24,17 +24,17 @@ The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. - L'attributo personalizzato '{0}' che deriva da JsonConverterAttribute non è supportato dal generatore di origine. + The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. Attributes deriving from JsonConverterAttribute are not supported by the source generator. - Gli attributi che derivano da JsonConverterAttribute non sono supportati dal generatore di origine. + Attributes deriving from JsonConverterAttribute are not supported by the source generator. There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. - Sono presenti più tipi denominati '{0}'. L'origine è stata generata per il primo tipo rilevato. Per risolvere questa collisione, usare 'JsonSerializableAttribute.TypeInfoPropertyName'. + There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. @@ -44,12 +44,12 @@ Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. - Il tipo '{0}' è annotato con 'JsonDerivedTypeAttribute' che non è supportato in 'JsonSourceGenerationMode.Serialization'. + Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. - 'JsonDerivedTypeAttribute' non è supportato in 'JsonSourceGenerationMode.Serialization'. + 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. @@ -74,52 +74,52 @@ The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. - Il costruttore nel tipo '{0}' è stato annotato con JsonConstructorAttribute ma non è accessibile dal generatore di origine. + The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. Constructor annotated with JsonConstructorAttribute is inaccessible. - Il costruttore annotato con JsonConstructorAttribute non è accessibile. + Constructor annotated with JsonConstructorAttribute is inaccessible. The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. - Il tipo 'JsonConverterAttribute' '{0}' specificato nel membro '{1}' non è un tipo di convertitore o non contiene un costruttore senza parametri accessibile. + The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. - 'JsonConverterAttribute.Type' contiene un argomento non valido o inaccessibile. + The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. - Il tipo '{0}' è stato annotato con JsonSerializableAttribute ma non deriva da JsonSerializerContext. Non verrà generato alcun codice sorgente. + The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. - I tipi annotati con JsonSerializableAttribute devono essere classi che derivano da JsonSerializerContext. + Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. - Il membro '{0}' è stato annotato con 'JsonStringEnumConverter' che non è supportato in AOT nativo. Provare a usare il generico 'JsonStringEnumConverter<TEnum>'. + The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. The non-generic 'JsonStringEnumConverter' requires dynamic code. - L'elemento 'JsonStringEnumConverter' non generico richiede un codice dinamico. + The non-generic 'JsonStringEnumConverter' requires dynamic code. The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. - Il generatore di origine System.Text.Json non è disponibile in C# {0}. Usare la versione del linguaggio {1} o successiva. + The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - Versione del linguaggio C# non supportata dal generatore di origine. + C# language version not supported by the source generator. @@ -142,6 +142,16 @@ Nel tipo sono presenti più membri annotati con JsonExtensionDataAttribute. + + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + + + + Type includes ref like property, field or constructor parameter. + Type includes ref like property, field or constructor parameter. + + Did not generate serialization metadata for type '{0}'. Non sono stati generati metadati di serializzazione per il tipo '{0}'. diff --git a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.ja.xlf b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.ja.xlf index 0224cb65fc2..9c4d4e27081 100644 --- a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.ja.xlf +++ b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.ja.xlf @@ -24,17 +24,17 @@ The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. - JsonConverterAttribute ã‹ã‚‰æ´¾ç”Ÿã™ã‚‹ã‚«ã‚¹ã‚¿ãƒ å±žæ€§ '{0}' ã¯ã€ã‚½ãƒ¼ã‚¹ ジェãƒãƒ¬ãƒ¼ã‚¿ãƒ¼ã§ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“。 + The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. Attributes deriving from JsonConverterAttribute are not supported by the source generator. - JsonConverterAttribute ã‹ã‚‰æ´¾ç”Ÿã™ã‚‹å±žæ€§ã¯ã€ã‚½ãƒ¼ã‚¹ ジェãƒãƒ¬ãƒ¼ã‚¿ãƒ¼ã§ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“。 + Attributes deriving from JsonConverterAttribute are not supported by the source generator. There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. - '{0}' ã¨åå‰ãŒä»˜ã‘られãŸç¨®é¡žãŒè¤‡æ•°ã‚ã‚Šã¾ã™ã€‚最åˆã«æ¤œå‡ºã•ã‚ŒãŸã‚‚ã®ã«å¯¾ã—ã¦ã‚½ãƒ¼ã‚¹ãŒç”Ÿæˆã•ã‚Œã¾ã—ãŸã€‚ã“ã®å•é¡Œã‚’解決ã™ã‚‹ã«ã¯ã€'JsonSerializableAttribute.TypeInfoPropertyName' を使用ã—ã¾ã™ã€‚ + There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. @@ -44,12 +44,12 @@ Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. - åž‹ '{0}' 㯠'JsonDerivedTypeAttribute' ã®æ³¨é‡ˆãŒä»˜ã‘られã¦ã„ã¾ã™ãŒã€ã“れ㯠'JsonSourceGenerationMode.Serialization' ã§ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“。 + Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. - 'JsonDerivedTypeAttribute' 㯠'JsonSourceGenerationMode.Serialization' ã§ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ã¾ã›ã‚“。 + 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. @@ -74,52 +74,52 @@ The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. - åž‹ '{0}' ã®ã‚³ãƒ³ã‚¹ãƒˆãƒ©ã‚¯ã‚¿ãƒ¼ã«ã¯ JsonConstructorAttribute ã§æ³¨é‡ˆãŒä»˜ã‘られã¾ã™ãŒã€ã‚½ãƒ¼ã‚¹ ジェãƒãƒ¬ãƒ¼ã‚¿ãƒ¼ã‹ã‚‰ã‚¢ã‚¯ã‚»ã‚¹ã™ã‚‹ã“ã¨ã¯ã§ãã¾ã›ã‚“。 + The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. Constructor annotated with JsonConstructorAttribute is inaccessible. - JsonConstructorAttribute ã§æ³¨é‡ˆãŒä»˜ã‘られãŸã‚³ãƒ³ã‚¹ãƒˆãƒ©ã‚¯ã‚¿ãƒ¼ã«ã‚¢ã‚¯ã‚»ã‚¹ã§ãã¾ã›ã‚“。 + Constructor annotated with JsonConstructorAttribute is inaccessible. The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. - メンãƒãƒ¼ '{1}' ã§æŒ‡å®šã•ã‚Œã¦ã„ã‚‹ 'JsonConverterAttribute' åž‹ '{0}' ã¯ã‚³ãƒ³ãƒãƒ¼ã‚¿ãƒ¼åž‹ã§ã¯ãªã„ã‹ã€ã‚¢ã‚¯ã‚»ã‚¹å¯èƒ½ãªãƒ‘ラメーターãªã—ã®ã‚³ãƒ³ã‚¹ãƒˆãƒ©ã‚¯ã‚¿ãƒ¼ã‚’å«ã‚“ã§ã„ã¾ã›ã‚“。 + The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. - 'JsonConverterAttribute.Type' ã«ç„¡åŠ¹ãªã€ã¾ãŸã¯ã‚¢ã‚¯ã‚»ã‚¹ã§ããªã„引数ãŒå«ã¾ã‚Œã¦ã„ã¾ã™ã€‚ + The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. - åž‹ '{0}' 㯠JsonSerializableAttribute ã§æ³¨é‡ˆãŒä»˜ã‘られã¦ã„ã¾ã™ãŒã€JsonSerializerContext ã‹ã‚‰æ´¾ç”Ÿã—ãŸã‚‚ã®ã§ã¯ã‚ã‚Šã¾ã›ã‚“。ソース コードã¯ç”Ÿæˆã•ã‚Œã¾ã›ã‚“。 + The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. - JsonSerializableAttribute ã§æ³¨é‡ˆãŒä»˜ã‘られãŸåž‹ã¯ã€JsonSerializerContext ã‹ã‚‰æ´¾ç”Ÿã™ã‚‹ã‚¯ãƒ©ã‚¹ã§ã‚ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ã€‚ + Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. - メンãƒãƒ¼ '{0}' ã«ã¯ã€ãƒã‚¤ãƒ†ã‚£ãƒ– AOT ã§ã¯ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ãªã„ 'JsonStringEnumConverter' ã®æ³¨é‡ˆãŒä»˜ã‘られã¦ã„ã¾ã™ã€‚ 代ã‚ã‚Šã«æ±Žç”¨ã® 'JsonStringEnumConverter<TEnum>' を使用ã™ã‚‹ã“ã¨ã‚’検討ã—ã¦ãã ã•ã„。 + The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. The non-generic 'JsonStringEnumConverter' requires dynamic code. - éžã‚¸ã‚§ãƒãƒªãƒƒã‚¯ 'JsonStringEnumConverter' ã«ã¯å‹•çš„コードãŒå¿…è¦ã§ã™ã€‚ + The non-generic 'JsonStringEnumConverter' requires dynamic code. The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. - System.Text.Json ソース ジェãƒãƒ¬ãƒ¼ã‚¿ãƒ¼ã¯ã€C# {0}ã§ã¯ä½¿ç”¨ã§ãã¾ã›ã‚“。言語ãƒãƒ¼ã‚¸ãƒ§ãƒ³ {1} 以上を使用ã—ã¦ãã ã•ã„。 + The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - ソース ジェãƒãƒ¬ãƒ¼ã‚¿ãƒ¼ã§ã‚µãƒãƒ¼ãƒˆã•ã‚Œã¦ã„ãªã„ C# 言語ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã€‚ + C# language version not supported by the source generator. @@ -142,6 +142,16 @@ åž‹ã«ã¯ã€'JsonExtensionDataAttribute' ã«æ³¨é‡ˆãŒä»˜ã‘られãŸè¤‡æ•°ã®ãƒ¡ãƒ³ãƒãƒ¼ãŒå«ã¾ã‚Œã¾ã™ã€‚ + + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + + + + Type includes ref like property, field or constructor parameter. + Type includes ref like property, field or constructor parameter. + + Did not generate serialization metadata for type '{0}'. '{0}'åž‹ ã®ã‚·ãƒªã‚¢ãƒ«åŒ–メタデータを生æˆã¾ã›ã‚“ã§ã—ãŸã€‚ diff --git a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.ko.xlf b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.ko.xlf index 9bc14e0cc3d..f1aeae92d40 100644 --- a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.ko.xlf +++ b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.ko.xlf @@ -24,17 +24,17 @@ The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. - JsonConverterAttributeì—ì„œ 파ìƒëœ ì‚¬ìš©ìž ì§€ì • ì†ì„± '{0}'ì€(는) ì›ë³¸ ìƒì„±ê¸°ì—ì„œ 지ì›ë˜ì§€ 않습니다. + The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. Attributes deriving from JsonConverterAttribute are not supported by the source generator. - JsonConverterAttributeì—ì„œ 파ìƒë˜ëŠ” íŠ¹ì„±ì€ ì†ŒìŠ¤ ìƒì„±ê¸°ì—ì„œ 지ì›ë˜ì§€ 않습니다. + Attributes deriving from JsonConverterAttribute are not supported by the source generator. There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. - ì´ë¦„ì´ '{0}'ì¸ í˜•ì‹ì´ 여러 ê°œ 있습니다. ì²˜ìŒ ê²€ìƒ‰ëœ ê²ƒì— ëŒ€í•œ ì›ë³¸ì´ ìƒì„±ë˜ì—ˆìŠµë‹ˆë‹¤. ì´ ì¶©ëŒì„ 해결하려면 'JsonSerializableAttribute.TypeInfoPropertyName'ì„ ì‚¬ìš©í•˜ì„¸ìš”. + There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. @@ -44,12 +44,12 @@ Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. - '{0} 형ì‹ì€ 'JsonSourceGenerationMode.Serialization'ì—ì„œ 지ì›ë˜ì§€ 않는 'JsonDerivedTypeAttribute'ë¡œ 주ì„ì´ ì¶”ê°€ë˜ì—ˆìŠµë‹ˆë‹¤. + Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. - 'JsonSourceGenerationMode.Serialization'ì—서는 'JsonDerivedTypeAttribute'ê°€ 지ì›ë˜ì§€ 않습니다. + 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. @@ -74,52 +74,52 @@ The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. - '{0}' 형ì‹ì˜ ìƒì„±ìžì— JsonConstructorAttributeë¡œ 주ì„ì´ ì¶”ê°€ë˜ì—ˆì§€ë§Œ ì›ë³¸ ìƒì„±ê¸°ì—ì„œ 액세스할 수 없습니다. + The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. Constructor annotated with JsonConstructorAttribute is inaccessible. - JsonConstructorAttributeë¡œ 주ì„ì´ ì¶”ê°€ëœ ìƒì„±ìžì— 액세스할 수 없습니다. + Constructor annotated with JsonConstructorAttribute is inaccessible. The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. - '{1}' ë©¤ë²„ì— ì§€ì •ëœ 'JsonConverterAttribute' í˜•ì‹ '{0}'ì´(ê°€) 변환기 형ì‹ì´ 아니거나 액세스 가능한 매개 변수가 없는 ìƒì„±ìžë¥¼ í¬í•¨í•˜ì§€ 않습니다. + The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. - 'JsonConverterAttribute.Type'ì— ìž˜ëª»ë˜ì—ˆê±°ë‚˜ 액세스할 수 없는 ì¸ìˆ˜ê°€ í¬í•¨ë˜ì–´ 있습니다. + The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. - '{0}' 형ì‹ì— JsonSerializableAttribute 주ì„ì´ ì¶”ê°€ë˜ì—ˆì§€ë§Œ JsonSerializerContextì—ì„œ 파ìƒë˜ì§€ 않았습니다. 소스 코드가 ìƒì„±ë˜ì§€ 않습니다. + The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. - JsonSerializableAttribute 주ì„ì´ ì¶”ê°€ëœ í˜•ì‹ì€ JsonSerializerContextì—ì„œ 파ìƒëœ í´ëž˜ìŠ¤ì—¬ì•¼ 합니다. + Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. - '{0}' ë©¤ë²„ì— ë„¤ì´í‹°ë¸Œ AOTì—ì„œ 지ì›ë˜ì§€ 않는 'JsonStringEnumConverter'ë¡œ 주ì„ì´ ë‹¬ë ¸ìŠµë‹ˆë‹¤. 대신 제네릭 'JsonStringEnumConverter<TEnum>'ì„ ì‚¬ìš©í•´ 보세요. + The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. The non-generic 'JsonStringEnumConverter' requires dynamic code. - ì œë„¤ë¦­ì´ ì•„ë‹Œ 'JsonStringEnumConverter'ì—는 ë™ì  코드가 필요합니다. + The non-generic 'JsonStringEnumConverter' requires dynamic code. The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. - System.Text.Json ì›ë³¸ ìƒì„±ê¸°ëŠ” C# {0}ì—ì„œ 사용할 수 없습니다. {1} ì´ìƒì˜ 언어 ë²„ì „ì„ ì‚¬ìš©í•˜ì„¸ìš”. + The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - ì›ë³¸ ìƒì„±ê¸°ì—ì„œ 지ì›ë˜ì§€ 않는 C# 언어 버전입니다. + C# language version not supported by the source generator. @@ -142,6 +142,16 @@ 형ì‹ì— JsonExtensionDataAttributeë¡œ 주ì„ì´ ì¶”ê°€ ëœ ë©¤ë²„ê°€ 여러 ê°œ 있습니다. + + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + + + + Type includes ref like property, field or constructor parameter. + Type includes ref like property, field or constructor parameter. + + Did not generate serialization metadata for type '{0}'. '{0}' 형ì‹ì— 대한 ì§ë ¬í™” 메타ë°ì´í„°ê°€ ìƒì„±ë˜ì§€ 않았습니다. diff --git a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.pl.xlf b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.pl.xlf index d8e7a990013..46ac28a5449 100644 --- a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.pl.xlf +++ b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.pl.xlf @@ -24,17 +24,17 @@ The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. - Generator źródÅ‚owy nie obsÅ‚uguje atrybutu niestandardowego „{0}†pochodzÄ…cego od atrybutu JsonConverterAttribute. + The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. Attributes deriving from JsonConverterAttribute are not supported by the source generator. - Atrybuty pochodzÄ…ce z atrybutu JsonConverterAttribute nie sÄ… obsÅ‚ugiwane przez generator źródÅ‚a. + Attributes deriving from JsonConverterAttribute are not supported by the source generator. There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. - Istnieje wiele typów o nazwie „{0}â€. Wygenerowano źródÅ‚o dla pierwszego wykrytego elementu. Aby rozwiÄ…zać tÄ™ kolizjÄ™, użyj elementu „JsonSerializableAttribute. TypeInfoPropertyNameâ€. + There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. @@ -44,12 +44,12 @@ Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. - Typ „{0}†ma adnotacjÄ™ „JsonDerivedTypeAttributeâ€, która nie jest obsÅ‚ugiwana w elemecie „JsonSourceGenerationMode.Serializationâ€. + Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. - Atrybut „JsonDerivedTypeAttribute†nie jest obsÅ‚ugiwany w elemecie „JsonSourceGenerationMode.Serializationâ€. + 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. @@ -74,52 +74,52 @@ The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. - W przypadku konstruktora w zakresie typu „{0}†dokonano adnotacji przy użyciu atrybutu JsonConstructorAttribute, ale nie jest on dostÄ™pny dla generatora źródÅ‚a. + The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. Constructor annotated with JsonConstructorAttribute is inaccessible. - Konstruktor, w przypadku którego dokonano adnotacji za pomocÄ… atrybutu JsonConstructorAttribute, jest niedostÄ™pny. + Constructor annotated with JsonConstructorAttribute is inaccessible. The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. - Typ „{0}†„JsonConverterAttribute†okreÅ›lony w przypadku skÅ‚adowej „{1}†nie jest typem konwertera lub nie zawiera dostÄ™pnego konstruktora bez parametrów. + The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. - Typ „JsonConverterAttribute.Type†zawiera nieprawidÅ‚owy lub niedostÄ™pny argument. + The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. - Typ „{0}†ma adnotacje z atrybutem JsonSerializableAttribute, ale nie pochodzi od elementu JsonSerializerContext. Nie zostanie wygenerowany żaden kod źródÅ‚owy. + The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. - Typy z adnotacjami JsonSerializableAttribute muszÄ… być klasami pochodzÄ…cymi z elementu JsonSerializerContext. + Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. - Element czÅ‚onkowski '{0}' zostaÅ‚ opatrzony adnotacjÄ… 'JsonStringEnumConverter', która nie jest obsÅ‚ugiwana w natywnym AOT. Zamiast tego należy rozważyć użycie ogólnego konwertera „JsonStringEnumConverter<TEnum>â€. + The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. The non-generic 'JsonStringEnumConverter' requires dynamic code. - Nieogólny element „JsonStringEnumConverter†wymaga dynamicznego kodu. + The non-generic 'JsonStringEnumConverter' requires dynamic code. The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. - Generator źródÅ‚a System.Text.Json nie jest dostÄ™pny w jÄ™zyku C# {0}. Użyj wersji jÄ™zykowej {1} lub nowszej. + The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - Wersja jÄ™zyka C# nie jest obsÅ‚ugiwana przez generator źródÅ‚a. + C# language version not supported by the source generator. @@ -142,6 +142,16 @@ Typ ma wiele skÅ‚adowych opatrzonych adnotacjami za pomocÄ… atrybutu JsonExtensionDataAttribute. + + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + + + + Type includes ref like property, field or constructor parameter. + Type includes ref like property, field or constructor parameter. + + Did not generate serialization metadata for type '{0}'. Nie wygenerowano metadanych serializacji dla typu „{0}â€. diff --git a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.pt-BR.xlf b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.pt-BR.xlf index d31fa77f16e..1a01a4223f3 100644 --- a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.pt-BR.xlf +++ b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.pt-BR.xlf @@ -24,17 +24,17 @@ The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. - O atributo customizado '{0}' derivado de JsonConverterAttribute não tem suporte pelo gerador de origem. + The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. Attributes deriving from JsonConverterAttribute are not supported by the source generator. - Os atributos derivados de JsonConverterAttribute não têm suporte pelo gerador de origem. + Attributes deriving from JsonConverterAttribute are not supported by the source generator. There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. - Existem vários tipos chamados '{0}'. A fonte foi gerada para o primeiro detectado. Use 'JsonSerializableAttribute.TypeInfoPropertyName' para resolver essa colisão. + There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. @@ -44,12 +44,12 @@ Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. - O tipo '{0}' é anotado com 'JsonDerivedTypeAttribute' que não tem suporte em 'JsonSourceGenerationMode.Serialization'. + Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. - 'JsonDerivedTypeAttribute' não tem suporte em 'JsonSourceGenerationMode.Serialization'. + 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. @@ -74,52 +74,52 @@ The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. - O construtor do tipo '{0}' foi anotado com JsonConstructorAttribute, mas não pode ser acessado pelo gerador de origem. + The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. Constructor annotated with JsonConstructorAttribute is inaccessible. - O construtor anotado com JsonConstructorAttribute está inacessível. + Constructor annotated with JsonConstructorAttribute is inaccessible. The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. - O tipo "JsonConverterAttribute" "{0}" especificado no membro "{1}" não é um tipo de conversor ou não contém um construtor sem parâmetros acessível. + The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. - O "JsonConverterAttribute.Type" contém um argumento inválido ou inacessível. + The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. - O tipo '{0}' foi anotado com JsonSerializableAttribute, mas não deriva de JsonSerializerContext. Nenhum código-fonte será gerado. + The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. - Tipos anotados com JsonSerializable Attribute devem ser classes derivadas de JsonSerializerContext. + Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. - O membro "{0}" foi anotado com "JsonStringEnumConverter" que não tem suporte na AOT nativa. Considere usar o genérico "JsonStringEnumConverter<TEnum>". + The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. The non-generic 'JsonStringEnumConverter' requires dynamic code. - O "JsonStringEnumConverter" não genérico requer código dinâmico. + The non-generic 'JsonStringEnumConverter' requires dynamic code. The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. - O gerador de origem System.Text.Json não está disponível em C# {0}. Use a versão do idioma {1} ou superior. + The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - Versão da linguagem C# não suportada pelo gerador de origem. + C# language version not supported by the source generator. @@ -142,6 +142,16 @@ Tipo tem vários membros anotados com JsonExtensionDataAttribute. + + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + + + + Type includes ref like property, field or constructor parameter. + Type includes ref like property, field or constructor parameter. + + Did not generate serialization metadata for type '{0}'. Não gerou metadados de serialização para o tipo '{0}'. diff --git a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.ru.xlf b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.ru.xlf index de31bb76e6f..81cb91944d0 100644 --- a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.ru.xlf +++ b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.ru.xlf @@ -24,17 +24,17 @@ The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. - ПользовательÑкий атрибут "{0}", производный от JsonConverterAttribute, не поддерживаетÑÑ Ð³ÐµÐ½ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð¾Ð¼ иÑходного кода. + The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. Attributes deriving from JsonConverterAttribute are not supported by the source generator. - Ðтрибуты, производные от JsonConverterAttribute, не поддерживаютÑÑ Ð³ÐµÐ½ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð¾Ð¼ иÑходного кода. + Attributes deriving from JsonConverterAttribute are not supported by the source generator. There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. - СущеÑтвует неÑколько типов Ñ Ð¸Ð¼ÐµÐ½ÐµÐ¼ "{0}". ИÑходный код Ñформирован Ð´Ð»Ñ Ð¿ÐµÑ€Ð²Ð¾Ð³Ð¾ обнаруженного типа. ИÑпользуйте JsonSerializableAttribute.TypeInfoPropertyName Ð´Ð»Ñ ÑƒÑÑ‚Ñ€Ð°Ð½ÐµÐ½Ð¸Ñ Ñтого конфликта. + There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. @@ -44,12 +44,12 @@ Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. - Тип '{0}' аннотирован атрибутом \"JsonDerivedTypeAttribute\", который не поддерживаетÑÑ Ð² \"JsonSourceGenerationMode.Serialization\". + Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. - Ðтрибут JsonDerivedTypeAttribute не поддерживаетÑÑ Ð² \"JsonSourceGenerationMode.Serialization\". + 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. @@ -74,52 +74,52 @@ The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. - КонÑтруктор Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð° "{0}" аннотирован Ñ Ð¸Ñпользованием JsonConstructorAttribute, но недоÑтупен Ð´Ð»Ñ Ð³ÐµÐ½ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð° иÑточника. + The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. Constructor annotated with JsonConstructorAttribute is inaccessible. - КонÑтруктор, аннотированный Ñ Ð¸Ñпользованием JsonConstructorAttribute, недоÑтупен. + Constructor annotated with JsonConstructorAttribute is inaccessible. The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. - Тип "JsonConverterAttribute" "{0}", указанный в Ñлементе "{1}", не ÑвлÑетÑÑ Ñ‚Ð¸Ð¿Ð¾Ð¼ Ð¿Ñ€ÐµÐ¾Ð±Ñ€Ð°Ð·Ð¾Ð²Ð°Ñ‚ÐµÐ»Ñ Ð¸Ð»Ð¸ не Ñодержит доÑтупного конÑтруктора без параметров. + The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. - Ðргумент "JsonConverterAttribute.Type" Ñодержит недопуÑтимый или недоÑтупный аргумент. + The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. - Тип "{0}" помечен атрибутом JsonSerializableAttribute, но не ÑвлÑетÑÑ Ð¿Ñ€Ð¾Ð¸Ð·Ð²Ð¾Ð´Ð½Ñ‹Ð¼ от JsonSerializerContext. ИÑходный код не будет Ñоздан. + The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. - Типы, аннотированные атрибутом JsonSerializableAttribute, должны быть клаÑÑами, производными от JsonSerializerContext. + Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. - Элемент "{0}" Ñодержит примечание JsonStringEnumConverter, что не поддерживаетÑÑ Ð² ÑобÑтвенном AOT. ВмеÑто Ñтого раÑÑмотрите возможноÑÑ‚ÑŒ иÑпользовать универÑальный параметр JsonStringEnumConverter<TEnum>. + The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. The non-generic 'JsonStringEnumConverter' requires dynamic code. - Ð”Ð»Ñ Ð½ÐµÑƒÐ½Ð¸Ð²ÐµÑ€Ñального параметра JsonStringEnumConverter требуетÑÑ Ð´Ð¸Ð½Ð°Ð¼Ð¸Ñ‡ÐµÑкий код. + The non-generic 'JsonStringEnumConverter' requires dynamic code. The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. - Генератор иÑходного кода System.Text.Json не доÑтупен в C# {0}. ИÑпользуйте Ñзыковую верÑию {1} или выше. + The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - ВерÑÐ¸Ñ Ñзыка C# не поддерживаетÑÑ Ð³ÐµÐ½ÐµÑ€Ð°Ñ‚Ð¾Ñ€Ð¾Ð¼ иÑходного кода. + C# language version not supported by the source generator. @@ -142,6 +142,16 @@ Тип Ñодержит неÑколько Ñлементов, помеченных Ñ Ð¿Ð¾Ð¼Ð¾Ñ‰ÑŒÑŽ JsonExtensionDataAttribute. + + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + + + + Type includes ref like property, field or constructor parameter. + Type includes ref like property, field or constructor parameter. + + Did not generate serialization metadata for type '{0}'. Метаданные Ñериализации Ð´Ð»Ñ Ñ‚Ð¸Ð¿Ð° "{0}" не Ñформированы. diff --git a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.tr.xlf b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.tr.xlf index 3ab7559fc82..7d2964957e5 100644 --- a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.tr.xlf +++ b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.tr.xlf @@ -24,17 +24,17 @@ The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. - JsonConverterAttribute’tan türetilen özel öznitelik '{0}' kaynak oluÅŸturucu tarafından desteklenmiyor. + The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. Attributes deriving from JsonConverterAttribute are not supported by the source generator. - JsonConverterAttribute’tan türetilen öznitelikler kaynak oluÅŸturucu tarafından desteklenmiyor. + Attributes deriving from JsonConverterAttribute are not supported by the source generator. There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. - '{0}' adını taşıyan birden çok tür var. Kaynak, algılanan ilk tür için oluÅŸturuldu. Bu çarpışmayı çözmek için 'JsonSerializableAttribute.TypeInfoPropertyName' özelliÄŸini kullanın. + There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. @@ -44,12 +44,12 @@ Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. - '{0}' türü, 'JsonSourceGenerationMode.Serialization' içinde desteklenmeyen 'JsonDerivedTypeAttribute' ile ek açıklama içeriyor. + Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. - 'JsonSourceGenerationMode.Serialization' içinde 'JsonDerivedTypeAttribute' desteklenmiyor. + 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. @@ -74,52 +74,52 @@ The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. - '{0}' türündeki oluÅŸturucuya JsonConstructorAttribute ile açıklama eklenmiÅŸ ancak kaynak oluÅŸturucu tarafından eriÅŸilebilir deÄŸil. + The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. Constructor annotated with JsonConstructorAttribute is inaccessible. - JsonConstructorAttribute ile açıklama eklenmiÅŸ oluÅŸturucuya eriÅŸilemiyor. + Constructor annotated with JsonConstructorAttribute is inaccessible. The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. - '{1}' üyesi üzerinde belirtilen 'JsonConverterAttribute' '{0}' türü dönüştürücü türü deÄŸil veya eriÅŸilebilir parametresiz bir oluÅŸturucu içermiyor. + The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. - 'JsonConverterAttribute.Type' geçersiz veya eriÅŸilemeyen bir bağımsız deÄŸiÅŸken içeriyor. + The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. - '{0}' türü, JsonSerializableAttribute ile ek açıklama eklenmiÅŸ ancak JsonSerializerContext'ten türetmiyor. Kaynak kodu oluÅŸturulmayacak. + The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. - JsonSerializableAttribute ile not eklenen türler, JsonSerializerContext'ten türetilen sınıflar olmalıdır. + Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. - '{0}' adlı üyeye yerel AOT’de desteklenmeyen 'JsonStringEnumConverter' parametresi eklendi. bunun yerine genel 'JsonStringEnumConverter<TEnum>' parametresini kullanmayı deneyin. + The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. The non-generic 'JsonStringEnumConverter' requires dynamic code. - Genel olmayan 'JsonStringEnumConverter' parametresi dinamik kod gerektirir. + The non-generic 'JsonStringEnumConverter' requires dynamic code. The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. - System.Text.Json kaynak oluÅŸturucusu C# {0}'ta mevcut deÄŸildir. Lütfen {1} dil sürümünü veya daha üstünü kullanın. + The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - C# dil sürümü kaynak oluÅŸturucu tarafından desteklenmiyor. + C# language version not supported by the source generator. @@ -142,6 +142,16 @@ Tür, JsonExtensionDataAttribute ile açıklanan birden çok üyeye sahip. + + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + + + + Type includes ref like property, field or constructor parameter. + Type includes ref like property, field or constructor parameter. + + Did not generate serialization metadata for type '{0}'. '{0}' türü için serileÅŸtirme meta verileri oluÅŸturulmadı. diff --git a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.zh-Hans.xlf b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.zh-Hans.xlf index 03ce3792f5e..c59ecd6e35d 100644 --- a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.zh-Hans.xlf +++ b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.zh-Hans.xlf @@ -24,17 +24,17 @@ The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. - æºç”Ÿæˆå™¨ä¸æ”¯æŒä»Ž JsonConverterAttribute 派生的自定义属性“{0}â€ã€‚ + The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. Attributes deriving from JsonConverterAttribute are not supported by the source generator. - æºç”Ÿæˆå™¨ä¸æ”¯æŒä»Ž JsonConverterAttribute 派生的属性。 + Attributes deriving from JsonConverterAttribute are not supported by the source generator. There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. - 有多个å为 {0} 的类型。已为第一个检测到类型的生æˆæºã€‚请使用“JsonSerializableAttribute.TypeInfoPropertyNameâ€ä»¥è§£å†³æ­¤å†²çªã€‚ + There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. @@ -44,12 +44,12 @@ Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. - 类型 \"{0}\" 使用 \"JsonSourceGenerationMode.Serialization\" 中ä¸æ”¯æŒçš„ \"JsonDerivedTypeAttribute\" 进行了批注。 + Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. - \"JsonSourceGenerationMode.Serialization\" 中ä¸æ”¯æŒ \"JsonDerivedTypeAttribute\"。 + 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. @@ -74,52 +74,52 @@ The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. - 类型“{0}â€ä¸Šçš„构造函数已使用 JsonConstructorAttribute 进行批注，但æºç”Ÿæˆå™¨æ— æ³•è®¿é—®è¯¥æž„造函数。 + The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. Constructor annotated with JsonConstructorAttribute is inaccessible. - 无法访问使用 JsonConstructorAttribute 批注的构造函数。 + Constructor annotated with JsonConstructorAttribute is inaccessible. The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. - 在æˆå‘˜ "{1}" 上指定的 "JsonConverterAttribute" 类型 "{0}" ä¸æ˜¯è½¬æ¢å™¨ç±»åž‹æˆ–ä¸åŒ…å«å¯è®¿é—®çš„æ— å‚数构造函数。 + The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. - "JsonConverterAttribute.Type" 包å«æ— æ•ˆæˆ–ä¸å¯è®¿é—®çš„å‚数。 + The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. - 类型“{0}â€å·²ä½¿ç”¨ JsonSerializableAttribute 进行批注，但ä¸æ˜¯ä»Ž JsonSerializerContext 派生的。ä¸ä¼šç”Ÿæˆæºä»£ç ã€‚ + The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. - 使用 JsonSerializableAttribute 批注的类型必须是派生自 JsonSerializerContext 的类。 + Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. - æˆå‘˜â€œ{0}â€å·²ä½¿ç”¨æœ¬æœº AOT 中ä¸æ”¯æŒçš„ "JsonStringEnumConverter" 进行批注。请改为考虑使用泛型 "JsonStringEnumConverter<TEnum>"。 + The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. The non-generic 'JsonStringEnumConverter' requires dynamic code. - éžæ³›åž‹ "JsonStringEnumConverter" 需è¦åŠ¨æ€ä»£ç ã€‚ + The non-generic 'JsonStringEnumConverter' requires dynamic code. The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. - System.Text.Json æºç”Ÿæˆå™¨åœ¨ C# {0} 中ä¸å¯ç”¨ã€‚请使用{1}或更高版本的语言版本。 + The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - æºç”Ÿæˆå™¨ä¸æ”¯æŒ C# 语言版本。 + C# language version not supported by the source generator. @@ -142,6 +142,16 @@ 类型具有多个带有 JsonExtensionDataAttribute 注释的æˆå‘˜ã€‚ + + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + + + + Type includes ref like property, field or constructor parameter. + Type includes ref like property, field or constructor parameter. + + Did not generate serialization metadata for type '{0}'. 未生æˆç±»åž‹ '{0}' çš„åºåˆ—化元数æ®ã€‚ diff --git a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.zh-Hant.xlf b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.zh-Hant.xlf index ed207add481..fd7671f8633 100644 --- a/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.zh-Hant.xlf +++ b/src/libraries/System.Text.Json/gen/Resources/xlf/Strings.zh-Hant.xlf @@ -24,17 +24,17 @@ The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. - 來æºç”¢ç”Ÿå™¨ä¸æ”¯æ´è¡ç”Ÿè‡ª JsonConverterAttribute 的自訂屬性 '{0}'。 + The custom attribute '{0}' deriving from JsonConverterAttribute is not supported by the source generator. Attributes deriving from JsonConverterAttribute are not supported by the source generator. - 來æºç”¢ç”Ÿå™¨ä¸æ”¯æ´è¡ç”Ÿè‡ª JsonConverterAttribute 的屬性。 + Attributes deriving from JsonConverterAttribute are not supported by the source generator. There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. - 有多個å為 '{0}' 的類型。已為åµæ¸¬åˆ°çš„第一個項目產生來æºã€‚請使用 'JsonSerializableAttribute.TypeInfoPropertyName' 解決此è¡çªã€‚ + There are multiple types named '{0}'. Source was generated for the first one detected. Use 'JsonSerializableAttribute.TypeInfoPropertyName' to resolve this collision. @@ -44,12 +44,12 @@ Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. - é¡žåž‹ '{0}' 使用 'JsonSourceGenerationMode.Serialization' ä¸æ”¯æ´çš„ 'JsonDerivedTypeAttribute' 進行註釋。 + Type '{0}' is annotated with 'JsonDerivedTypeAttribute' which is not supported in 'JsonSourceGenerationMode.Serialization'. 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. - 'JsonSourceGenerationMode.Serialization' 中ä¸æ”¯æ´ 'JsonDerivedTypeAttribute'。 + 'JsonDerivedTypeAttribute' is not supported in 'JsonSourceGenerationMode.Serialization'. @@ -74,52 +74,52 @@ The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. - é¡žåž‹ '{0}' 上的建構函å¼å·²ä½¿ç”¨ JsonConstructorAttribute 標註，但無法供來æºç”¢ç”Ÿå™¨å­˜å–。 + The constructor on type '{0}' has been annotated with JsonConstructorAttribute but is not accessible by the source generator. Constructor annotated with JsonConstructorAttribute is inaccessible. - 無法存å–使用 JsonConstructorAttribute 標註的建構函å¼ã€‚ + Constructor annotated with JsonConstructorAttribute is inaccessible. The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. - æˆå“¡ '{1}' 上指定的 'JsonConverterAttribute' é¡žåž‹ '{0}' ä¸æ˜¯è½‰æ›å™¨é¡žåž‹ï¼Œæˆ–ä¸åŒ…å«å¯å­˜å–çš„ç„¡åƒæ•¸å»ºæ§‹å‡½å¼ã€‚ + The 'JsonConverterAttribute' type '{0}' specified on member '{1}' is not a converter type or does not contain an accessible parameterless constructor. The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. - 'JsonConverterAttribute.Type' 包å«ç„¡æ•ˆæˆ–無法存å–的引數。 + The 'JsonConverterAttribute.Type' contains an invalid or inaccessible argument. The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. - é¡žåž‹ '{0}' 已使用 JsonSerializableAttribute 標註，但並éžè¡ç”Ÿè‡ª JsonSerializerCoNtext。將ä¸æœƒç”¢ç”ŸåŽŸå§‹ç¨‹å¼ç¢¼ã€‚ + The type '{0}' has been annotated with JsonSerializableAttribute but does not derive from JsonSerializerContext. No source code will be generated. Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. - 以 JsonSerializableAttribute 標註的類型必須為è¡ç”Ÿè‡ª JsonSerializerCoNtext 的類別。 + Types annotated with JsonSerializableAttribute must be classes deriving from JsonSerializerContext. The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. - æˆå“¡ '{0}' 已使用原生 AOT ä¸æ”¯æ´çš„ 'JsonStringEnumConverter' 加上標註。請考慮改用一般 'JsonStringEnumConverter<TEnum>'。 + The member '{0}' has been annotated with 'JsonStringEnumConverter' which is not supported in native AOT. Consider using the generic 'JsonStringEnumConverter<TEnum>' instead. The non-generic 'JsonStringEnumConverter' requires dynamic code. - éžä¸€èˆ¬ 'JsonStringEnumConverter' 需è¦å‹•æ…‹ç¨‹å¼ç¢¼ã€‚ + The non-generic 'JsonStringEnumConverter' requires dynamic code. The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. - C# {0} 中無法使用 System.Text.Json 來æºç”¢ç”Ÿå™¨ã€‚請使用 {1} 或更新的語言版本。 + The System.Text.Json source generator is not available in C# {0}. Please use language version {1} or greater. C# language version not supported by the source generator. - 來æºç”¢ç”Ÿå™¨ä¸æ”¯æ´ C# 語言版本。 + C# language version not supported by the source generator. @@ -142,6 +142,16 @@ 類型具有使用 JsonExtensionDataAttribute 標註的多個æˆå“¡ã€‚ + + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + The type '{0}' includes the ref like property, field or constructor parameter '{1}'. No source code will be generated for the property, field or constructor. + + + + Type includes ref like property, field or constructor parameter. + Type includes ref like property, field or constructor parameter. + + Did not generate serialization metadata for type '{0}'. 未產生類型 '{0}' çš„åºåˆ—化中繼資料。 diff --git a/src/libraries/System.Text.Json/ref/System.Text.Json.cs b/src/libraries/System.Text.Json/ref/System.Text.Json.cs index d1394f939f1..c854cb27bed 100644 --- a/src/libraries/System.Text.Json/ref/System.Text.Json.cs +++ b/src/libraries/System.Text.Json/ref/System.Text.Json.cs @@ -66,6 +66,7 @@ public readonly partial struct JsonElement public System.Text.Json.JsonElement GetProperty(System.ReadOnlySpan utf8PropertyName) { throw null; } public System.Text.Json.JsonElement GetProperty(System.ReadOnlySpan propertyName) { throw null; } public System.Text.Json.JsonElement GetProperty(string propertyName) { throw null; } + public int GetPropertyCount() { throw null; } public string GetRawText() { throw null; } [System.CLSCompliantAttribute(false)] public sbyte GetSByte() { throw null; } @@ -208,6 +209,7 @@ public readonly partial struct JsonReaderState } public static partial class JsonSerializer { + [System.Diagnostics.CodeAnalysis.FeatureSwitchDefinitionAttribute("System.Text.Json.JsonSerializer.IsReflectionEnabledByDefault")] public static bool IsReflectionEnabledByDefault { get { throw null; } } public static object? Deserialize(System.IO.Stream utf8Json, System.Text.Json.Serialization.Metadata.JsonTypeInfo jsonTypeInfo) { throw null; } [System.Diagnostics.CodeAnalysis.RequiresDynamicCodeAttribute("JSON serialization and deserialization might require types that cannot be statically analyzed and might need runtime code generation. Use System.Text.Json source generation for native AOT applications.")] diff --git a/src/libraries/System.Text.Json/ref/System.Text.Json.csproj b/src/libraries/System.Text.Json/ref/System.Text.Json.csproj index f578aa9af4f..dc2e4d28e75 100644 --- a/src/libraries/System.Text.Json/ref/System.Text.Json.csproj +++ b/src/libraries/System.Text.Json/ref/System.Text.Json.csproj @@ -24,6 +24,10 @@ + + + + diff --git a/src/libraries/System.Text.Json/src/ILLink/ILLink.Substitutions.xml b/src/libraries/System.Text.Json/src/ILLink/ILLink.Substitutions.xml deleted file mode 100644 index 026bbf9f136..00000000000 --- a/src/libraries/System.Text.Json/src/ILLink/ILLink.Substitutions.xml +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - - \ No newline at end of file diff --git a/src/libraries/System.Text.Json/src/Resources/Strings.resx b/src/libraries/System.Text.Json/src/Resources/Strings.resx index 8b2b0e0ad04..8a571e258a4 100644 --- a/src/libraries/System.Text.Json/src/Resources/Strings.resx +++ b/src/libraries/System.Text.Json/src/Resources/Strings.resx @@ -662,6 +662,9 @@ The metadata property names '$id', '$ref', and '$values' are reserved and cannot be used as custom type discriminator property names. + + The type '{0}' contains property '{1}' that conflicts with an existing metadata property name. Consider either renaming it or ignoring it with JsonIgnoreAttribute. + Polymorphic configuration for type '{0}' should specify at least one derived type. diff --git a/src/libraries/System.Text.Json/src/System.Text.Json.csproj b/src/libraries/System.Text.Json/src/System.Text.Json.csproj index c4b931191e3..1d301973915 100644 --- a/src/libraries/System.Text.Json/src/System.Text.Json.csproj +++ b/src/libraries/System.Text.Json/src/System.Text.Json.csproj @@ -19,10 +19,6 @@ The System.Text.Json library is built-in as part of the shared framework in .NET $(NoWarn);nullable - - - - @@ -369,6 +365,8 @@ The System.Text.Json library is built-in as part of the shared framework in .NET + + @@ -395,7 +393,7 @@ The System.Text.Json library is built-in as part of the shared framework in .NET - + @@ -403,6 +401,7 @@ The System.Text.Json library is built-in as part of the shared framework in .NET + @@ -413,8 +412,9 @@ The System.Text.Json library is built-in as part of the shared framework in .NET - + + diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Document/JsonDocument.MetadataDb.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Document/JsonDocument.MetadataDb.cs index a53df982c12..dca61c889c8 100644 --- a/src/libraries/System.Text.Json/src/System/Text/Json/Document/JsonDocument.MetadataDb.cs +++ b/src/libraries/System.Text.Json/src/System/Text/Json/Document/JsonDocument.MetadataDb.cs @@ -68,7 +68,7 @@ public sealed partial class JsonDocument // * 31 bits for token offset // * Second int // * Top bit is unassigned / always clear - // * 31 bits for the token length (always 1, effectively unassigned) + // * 31 bits for the number of properties in this object // * Third int // * 4 bits JsonTokenType // * 28 bits for the number of rows until the next value (never 0) diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Document/JsonDocument.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Document/JsonDocument.cs index ccf524fc40f..7b3ffa246a9 100644 --- a/src/libraries/System.Text.Json/src/System/Text/Json/Document/JsonDocument.cs +++ b/src/libraries/System.Text.Json/src/System/Text/Json/Document/JsonDocument.cs @@ -950,7 +950,7 @@ private static void Parse( ref StackRowStack stack) { bool inArray = false; - int arrayItemsCount = 0; + int arrayItemsOrPropertyCount = 0; int numberOfRowsForMembers = 0; int numberOfRowsForValues = 0; @@ -972,13 +972,14 @@ private static void Parse( { if (inArray) { - arrayItemsCount++; + arrayItemsOrPropertyCount++; } numberOfRowsForValues++; database.Append(tokenType, tokenStart, DbRow.UnknownSize); - var row = new StackRow(numberOfRowsForMembers + 1); + var row = new StackRow(arrayItemsOrPropertyCount, numberOfRowsForMembers + 1); stack.Push(row); + arrayItemsOrPropertyCount = 0; numberOfRowsForMembers = 0; } else if (tokenType == JsonTokenType.EndObject) @@ -987,7 +988,7 @@ private static void Parse( numberOfRowsForValues++; numberOfRowsForMembers++; - database.SetLength(rowIndex, numberOfRowsForMembers); + database.SetLength(rowIndex, arrayItemsOrPropertyCount); int newRowIndex = database.Length; database.Append(tokenType, tokenStart, reader.ValueSpan.Length); @@ -995,20 +996,21 @@ private static void Parse( database.SetNumberOfRows(newRowIndex, numberOfRowsForMembers); StackRow row = stack.Pop(); - numberOfRowsForMembers += row.SizeOrLength; + arrayItemsOrPropertyCount = row.SizeOrLength; + numberOfRowsForMembers += row.NumberOfRows; } else if (tokenType == JsonTokenType.StartArray) { if (inArray) { - arrayItemsCount++; + arrayItemsOrPropertyCount++; } numberOfRowsForMembers++; database.Append(tokenType, tokenStart, DbRow.UnknownSize); - var row = new StackRow(arrayItemsCount, numberOfRowsForValues + 1); + var row = new StackRow(arrayItemsOrPropertyCount, numberOfRowsForValues + 1); stack.Push(row); - arrayItemsCount = 0; + arrayItemsOrPropertyCount = 0; numberOfRowsForValues = 0; } else if (tokenType == JsonTokenType.EndArray) @@ -1017,7 +1019,7 @@ private static void Parse( numberOfRowsForValues++; numberOfRowsForMembers++; - database.SetLength(rowIndex, arrayItemsCount); + database.SetLength(rowIndex, arrayItemsOrPropertyCount); database.SetNumberOfRows(rowIndex, numberOfRowsForValues); // If the array item count is (e.g.) 12 and the number of rows is (e.g.) 13 @@ -1030,7 +1032,7 @@ private static void Parse( // This check is similar to tracking the start array and painting it when // StartObject or StartArray is encountered, but avoids the mixed state // where "UnknownSize" implies "has complex children". - if (arrayItemsCount + 1 != numberOfRowsForValues) + if (arrayItemsOrPropertyCount + 1 != numberOfRowsForValues) { database.SetHasComplexChildren(rowIndex); } @@ -1040,13 +1042,14 @@ private static void Parse( database.SetNumberOfRows(newRowIndex, numberOfRowsForValues); StackRow row = stack.Pop(); - arrayItemsCount = row.SizeOrLength; + arrayItemsOrPropertyCount = row.SizeOrLength; numberOfRowsForValues += row.NumberOfRows; } else if (tokenType == JsonTokenType.PropertyName) { numberOfRowsForValues++; numberOfRowsForMembers++; + arrayItemsOrPropertyCount++; // Adding 1 to skip the start quote will never overflow Debug.Assert(tokenStart < int.MaxValue); @@ -1068,7 +1071,7 @@ private static void Parse( if (inArray) { - arrayItemsCount++; + arrayItemsOrPropertyCount++; } if (tokenType == JsonTokenType.String) diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Document/JsonElement.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Document/JsonElement.cs index da72d147abd..e71c9ae3aa9 100644 --- a/src/libraries/System.Text.Json/src/System/Text/Json/Document/JsonElement.cs +++ b/src/libraries/System.Text.Json/src/System/Text/Json/Document/JsonElement.cs @@ -96,7 +96,7 @@ public int GetArrayLength() /// /// The parent has been disposed. /// - internal int GetPropertyCount() + public int GetPropertyCount() { CheckValidInstance(); diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Schema/JsonSchemaExporter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Schema/JsonSchemaExporter.cs index 692a34b3e89..063bd951476 100644 --- a/src/libraries/System.Text.Json/src/System/Text/Json/Schema/JsonSchemaExporter.cs +++ b/src/libraries/System.Text.Json/src/System/Text/Json/Schema/JsonSchemaExporter.cs @@ -204,7 +204,8 @@ private static JsonSchema MapJsonSchemaCore( List? required = null; JsonSchema? additionalProperties = null; - if (typeInfo.UnmappedMemberHandling is JsonUnmappedMemberHandling.Disallow) + JsonUnmappedMemberHandling effectiveUnmappedMemberHandling = typeInfo.UnmappedMemberHandling ?? typeInfo.Options.UnmappedMemberHandling; + if (effectiveUnmappedMemberHandling is JsonUnmappedMemberHandling.Disallow) { additionalProperties = JsonSchema.False; } diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Schema/JsonSchemaExporterOptions.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Schema/JsonSchemaExporterOptions.cs index 1567ad9aded..17ab336cf40 100644 --- a/src/libraries/System.Text.Json/src/System/Text/Json/Schema/JsonSchemaExporterOptions.cs +++ b/src/libraries/System.Text.Json/src/System/Text/Json/Schema/JsonSchemaExporterOptions.cs @@ -20,7 +20,7 @@ public sealed class JsonSchemaExporterOptions /// /// /// Defaults to . Due to restrictions in the run-time representation of nullable reference types - /// most occurences are null oblivious and are treated as nullable by the serializer. A notable exception to that rule + /// most occurrences are null oblivious and are treated as nullable by the serializer. A notable exception to that rule /// are nullability annotations of field, property and constructor parameters which are represented in the contract metadata. /// public bool TreatNullObliviousAsNonNullable { get; init; } diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/IEnumerableConverterFactory.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/IEnumerableConverterFactory.cs index 054e4f8648a..59b25911529 100644 --- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/IEnumerableConverterFactory.cs +++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Collection/IEnumerableConverterFactory.cs @@ -8,6 +8,7 @@ using System.Diagnostics.CodeAnalysis; using System.Reflection; using System.Text.Json.Reflection; +using System.Text.Json.Serialization.Metadata; namespace System.Text.Json.Serialization.Converters { @@ -185,11 +186,17 @@ public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializer } else if (numberOfGenericArgs == 2) { + JsonTypeInfo.ValidateType(elementType!); + genericType = converterType.MakeGenericType(typeToConvert, elementType!); } else { Debug.Assert(numberOfGenericArgs == 3); + + JsonTypeInfo.ValidateType(elementType!); + JsonTypeInfo.ValidateType(dictionaryKeyType!); + genericType = converterType.MakeGenericType(typeToConvert, dictionaryKeyType!, elementType!); } diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectConverterFactory.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectConverterFactory.cs index e0b04f30142..b82733f5917 100644 --- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectConverterFactory.cs +++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectConverterFactory.cs @@ -59,6 +59,12 @@ public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializer { int parameterCount = parameters.Length; + foreach (ParameterInfo parameter in parameters) + { + // Every argument must be of supported type. + JsonTypeInfo.ValidateType(parameter.ParameterType); + } + if (parameterCount <= JsonConstants.UnboxedParameterCountThreshold) { Type placeHolderType = JsonTypeInfo.ObjectType; diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.Large.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.Large.cs index 6aa1117eefa..b65c994abd1 100644 --- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.Large.cs +++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.Large.cs @@ -28,9 +28,6 @@ protected sealed override bool ReadAndCacheConstructorArgument(scoped ref ReadSt } ((object[])state.Current.CtorArgumentState!.Arguments)[jsonParameterInfo.Position] = arg!; - - // if this is required property IgnoreNullTokensOnRead will always be false because we don't allow for both to be true - state.Current.MarkRequiredPropertyAsRead(jsonParameterInfo.MatchingProperty); } return success; diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.Small.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.Small.cs index b6ad9089c48..292f19b3d0f 100644 --- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.Small.cs +++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.Small.cs @@ -80,8 +80,6 @@ private static bool TryRead( ThrowHelper.ThrowJsonException_ConstructorParameterDisallowNull(info.Name, state.Current.JsonTypeInfo.Type); } } - - state.Current.MarkRequiredPropertyAsRead(jsonParameterInfo.MatchingProperty); } arg = value; diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.cs index 6ae225b5745..f18b9060acf 100644 --- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.cs +++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Converters/Object/ObjectWithParameterizedConstructorConverter.cs @@ -58,6 +58,11 @@ internal sealed override bool OnTryRead(ref Utf8JsonReader reader, Type typeToCo ReadConstructorArguments(ref state, ref reader, options); + // We've read all ctor parameters and properties, + // validate that all required parameters were provided + // before calling the constructor which may throw. + state.Current.ValidateAllRequiredPropertiesAreRead(jsonTypeInfo); + obj = (T)CreateObject(ref state.Current); jsonTypeInfo.OnDeserializing?.Invoke(obj); @@ -192,6 +197,11 @@ internal sealed override bool OnTryRead(ref Utf8JsonReader reader, Type typeToCo return false; } + // We've read all ctor parameters and properties, + // validate that all required parameters were provided + // before calling the constructor which may throw. + state.Current.ValidateAllRequiredPropertiesAreRead(jsonTypeInfo); + obj = (T)CreateObject(ref state.Current); if ((state.Current.MetadataPropertyNames & MetadataPropertyName.Id) != 0) @@ -219,9 +229,6 @@ internal sealed override bool OnTryRead(ref Utf8JsonReader reader, Type typeToCo if (propValue is not null || !jsonPropertyInfo.IgnoreNullTokensOnRead || default(T) is not null) { jsonPropertyInfo.Set(obj, propValue); - - // if this is required property IgnoreNullTokensOnRead will always be false because we don't allow for both to be true - state.Current.MarkRequiredPropertyAsRead(jsonPropertyInfo); } } else @@ -249,7 +256,6 @@ internal sealed override bool OnTryRead(ref Utf8JsonReader reader, Type typeToCo } jsonTypeInfo.OnDeserialized?.Invoke(obj); - state.Current.ValidateAllRequiredPropertiesAreRead(jsonTypeInfo); // Unbox Debug.Assert(obj != null); @@ -606,6 +612,9 @@ protected static bool TryLookupConstructorParameter( out bool useExtensionProperty, createExtensionProperty: false); + // Mark the property as read from the payload if required. + state.Current.MarkRequiredPropertyAsRead(jsonPropertyInfo); + jsonParameterInfo = jsonPropertyInfo.AssociatedParameter; if (jsonParameterInfo != null) { diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Helpers.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Helpers.cs index f654826f5b0..0b3301fcc0a 100644 --- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Helpers.cs +++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/JsonSerializer.Helpers.cs @@ -21,6 +21,7 @@ public static partial class JsonSerializer /// The value of the property is backed by the "System.Text.Json.JsonSerializer.IsReflectionEnabledByDefault" /// setting and defaults to if unset. /// + [FeatureSwitchDefinition("System.Text.Json.JsonSerializer.IsReflectionEnabledByDefault")] public static bool IsReflectionEnabledByDefault { get; } = AppContext.TryGetSwitch( switchName: "System.Text.Json.JsonSerializer.IsReflectionEnabledByDefault", diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonPropertyInfo.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonPropertyInfo.cs index 4077c89fe97..29e11071fb7 100644 --- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonPropertyInfo.cs +++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/JsonPropertyInfo.cs @@ -443,7 +443,7 @@ internal void Configure() } else { - CacheNameAsUtf8BytesAndEscapedNameSection(); + ValidateAndCachePropertyName(); } if (IsRequired) @@ -472,10 +472,21 @@ internal void Configure() [RequiresDynamicCode(JsonSerializer.SerializationRequiresDynamicCodeMessage)] internal abstract void DetermineReflectionPropertyAccessors(MemberInfo memberInfo, bool useNonPublicAccessors); - private void CacheNameAsUtf8BytesAndEscapedNameSection() + private void ValidateAndCachePropertyName() { Debug.Assert(Name != null); + if (Options.ReferenceHandlingStrategy is ReferenceHandlingStrategy.Preserve && + this is { DeclaringType.IsValueType: false, IsIgnored: false, IsExtensionData: false } && + Name is JsonSerializer.IdPropertyName or JsonSerializer.RefPropertyName) + { + // Validate potential conflicts with reference preservation metadata property names. + // Conflicts with polymorphic type discriminators are contextual and need to be + // handled separately by the PolymorphicTypeResolver type. + + ThrowHelper.ThrowInvalidOperationException_PropertyConflictsWithMetadataPropertyName(DeclaringType, Name); + } + NameAsUtf8Bytes = Encoding.UTF8.GetBytes(Name); EscapedNameSection = JsonHelpers.GetEscapedPropertyNameSection(NameAsUtf8Bytes, Options.Encoder); } diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/PolymorphicTypeResolver.cs b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/PolymorphicTypeResolver.cs index b0ed4b24a60..075ea31a65a 100644 --- a/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/PolymorphicTypeResolver.cs +++ b/src/libraries/System.Text.Json/src/System/Text/Json/Serialization/Metadata/PolymorphicTypeResolver.cs @@ -42,16 +42,17 @@ public PolymorphicTypeResolver(JsonSerializerOptions options, JsonPolymorphismOp ThrowHelper.ThrowInvalidOperationException_DerivedTypeNotSupported(BaseType, derivedType); } - var derivedJsonTypeInfo = new DerivedJsonTypeInfo(derivedType, typeDiscriminator); + JsonTypeInfo derivedTypeInfo = options.GetTypeInfoInternal(derivedType); + DerivedJsonTypeInfo derivedTypeInfoHolder = new(typeDiscriminator, derivedTypeInfo); - if (!_typeToDiscriminatorId.TryAdd(derivedType, derivedJsonTypeInfo)) + if (!_typeToDiscriminatorId.TryAdd(derivedType, derivedTypeInfoHolder)) { ThrowHelper.ThrowInvalidOperationException_DerivedTypeIsAlreadySpecified(BaseType, derivedType); } if (typeDiscriminator is not null) { - if (!(_discriminatorIdtoType ??= new()).TryAdd(typeDiscriminator, derivedJsonTypeInfo)) + if (!(_discriminatorIdtoType ??= new()).TryAdd(typeDiscriminator, derivedTypeInfoHolder)) { ThrowHelper.ThrowInvalidOperationException_TypeDicriminatorIdIsAlreadySpecified(BaseType, typeDiscriminator); } @@ -69,6 +70,8 @@ public PolymorphicTypeResolver(JsonSerializerOptions options, JsonPolymorphismOp if (UsesTypeDiscriminators) { + Debug.Assert(_discriminatorIdtoType != null, "Discriminator index must have been populated."); + if (!converterCanHaveMetadata) { ThrowHelper.ThrowNotSupportedException_BaseConverterDoesNotSupportMetadata(BaseType); @@ -88,6 +91,21 @@ public PolymorphicTypeResolver(JsonSerializerOptions options, JsonPolymorphismOp CustomTypeDiscriminatorPropertyNameUtf8 = utf8EncodedName; CustomTypeDiscriminatorPropertyNameJsonEncoded = JsonEncodedText.Encode(propertyName, options.Encoder); } + + // Check if the discriminator property name conflicts with any derived property names. + foreach (DerivedJsonTypeInfo derivedTypeInfo in _discriminatorIdtoType.Values) + { + if (derivedTypeInfo.JsonTypeInfo.Kind is JsonTypeInfoKind.Object) + { + foreach (JsonPropertyInfo property in derivedTypeInfo.JsonTypeInfo.Properties) + { + if (property is { IsIgnored: false, IsExtensionData: false } && property.Name == propertyName) + { + ThrowHelper.ThrowInvalidOperationException_PropertyConflictsWithMetadataPropertyName(derivedTypeInfo.JsonTypeInfo.Type, propertyName); + } + } + } + } } } @@ -136,7 +154,7 @@ public bool TryGetDerivedJsonTypeInfo(Type runtimeType, [NotNullWhen(true)] out } else { - jsonTypeInfo = result.GetJsonTypeInfo(_options); + jsonTypeInfo = result.JsonTypeInfo; typeDiscriminator = result.TypeDiscriminator; return true; } @@ -151,7 +169,7 @@ public bool TryGetDerivedJsonTypeInfo(object typeDiscriminator, [NotNullWhen(tru if (_discriminatorIdtoType.TryGetValue(typeDiscriminator, out DerivedJsonTypeInfo? result)) { Debug.Assert(typeDiscriminator.Equals(result.TypeDiscriminator)); - jsonTypeInfo = result.GetJsonTypeInfo(_options); + jsonTypeInfo = result.JsonTypeInfo; return true; } @@ -218,7 +236,7 @@ public static bool IsSupportedDerivedType(Type baseType, Type? derivedType) => } else { - ThrowHelper.ThrowNotSupportedException_RuntimeTypeDiamondAmbiguity(BaseType, type, result.DerivedType, interfaceResult.DerivedType); + ThrowHelper.ThrowNotSupportedException_RuntimeTypeDiamondAmbiguity(BaseType, type, result.JsonTypeInfo.Type, interfaceResult.JsonTypeInfo.Type); } } } @@ -307,24 +325,20 @@ public static bool IsSupportedDerivedType(Type baseType, Type? derivedType) => } /// - /// Lazy JsonTypeInfo result holder for a derived type. + /// JsonTypeInfo result holder for a derived type. /// private sealed class DerivedJsonTypeInfo { - private volatile JsonTypeInfo? _jsonTypeInfo; - - public DerivedJsonTypeInfo(Type type, object? typeDiscriminator) + public DerivedJsonTypeInfo(object? typeDiscriminator, JsonTypeInfo derivedTypeInfo) { Debug.Assert(typeDiscriminator is null or int or string); - DerivedType = type; TypeDiscriminator = typeDiscriminator; + JsonTypeInfo = derivedTypeInfo; } - public Type DerivedType { get; } public object? TypeDiscriminator { get; } - public JsonTypeInfo GetJsonTypeInfo(JsonSerializerOptions options) - => _jsonTypeInfo ??= options.GetTypeInfoInternal(DerivedType); + public JsonTypeInfo JsonTypeInfo { get; } } } } diff --git a/src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.Serialization.cs b/src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.Serialization.cs index fed9efb84d0..b93651e0cdd 100644 --- a/src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.Serialization.cs +++ b/src/libraries/System.Text.Json/src/System/Text/Json/ThrowHelper.Serialization.cs @@ -903,6 +903,12 @@ public static void ThrowInvalidOperationException_InvalidCustomTypeDiscriminator throw new InvalidOperationException(SR.Polymorphism_InvalidCustomTypeDiscriminatorPropertyName); } + [DoesNotReturn] + public static void ThrowInvalidOperationException_PropertyConflictsWithMetadataPropertyName(Type type, string propertyName) + { + throw new InvalidOperationException(SR.Format(SR.Polymorphism_PropertyConflictsWithMetadataPropertyName, type, propertyName)); + } + [DoesNotReturn] public static void ThrowInvalidOperationException_PolymorphicTypeConfigurationDoesNotSpecifyDerivedTypes(Type baseType) { diff --git a/src/libraries/System.Text.Json/tests/Common/JsonSchemaExporterTests.TestTypes.cs b/src/libraries/System.Text.Json/tests/Common/JsonSchemaExporterTests.TestTypes.cs index 35949a9a68a..12ee630b378 100644 --- a/src/libraries/System.Text.Json/tests/Common/JsonSchemaExporterTests.TestTypes.cs +++ b/src/libraries/System.Text.Json/tests/Common/JsonSchemaExporterTests.TestTypes.cs @@ -677,6 +677,24 @@ public static IEnumerable GetTestDataCore() } """); + // Global setting for JsonUnmappedMemberHandling.Disallow + yield return new TestData( + Value: new() { String = "string", StringNullable = "string", Int = 42, Double = 3.14, Boolean = true }, + ExpectedJsonSchema: """ + { + "type": ["object","null"], + "properties": { + "String": { "type": "string" }, + "StringNullable": { "type": ["string", "null"] }, + "Int": { "type": "integer" }, + "Double": { "type": "number" }, + "Boolean": { "type": "boolean" } + }, + "additionalProperties": false, + } + """, + SerializerOptions: new() { UnmappedMemberHandling = JsonUnmappedMemberHandling.Disallow }); + yield return new TestData( Value: new() { MaybeNull = null!, AllowNull = null, NotNull = null, DisallowNull = null!, NotNullDisallowNull = "str" }, ExpectedJsonSchema: """ @@ -1446,7 +1464,8 @@ public record TestData( T? Value, string ExpectedJsonSchema, IEnumerable? AdditionalValues = null, - JsonSchemaExporterOptions? Options = null) + JsonSchemaExporterOptions? Options = null, + JsonSerializerOptions? SerializerOptions = null) : ITestData { public Type Type => typeof(T); @@ -1481,6 +1500,8 @@ public interface ITestData JsonSchemaExporterOptions? Options { get; } + JsonSerializerOptions? SerializerOptions { get; } + IEnumerable GetTestDataForAllValues(); } diff --git a/src/libraries/System.Text.Json/tests/Common/JsonSchemaExporterTests.cs b/src/libraries/System.Text.Json/tests/Common/JsonSchemaExporterTests.cs index f1226dc862e..314e3f68817 100644 --- a/src/libraries/System.Text.Json/tests/Common/JsonSchemaExporterTests.cs +++ b/src/libraries/System.Text.Json/tests/Common/JsonSchemaExporterTests.cs @@ -29,7 +29,11 @@ protected JsonSchemaExporterTests(JsonSerializerWrapper serializer) : base(seria [ActiveIssue("https://github.com/dotnet/runtime/issues/103694", TestRuntimes.Mono)] public void TestTypes_GeneratesExpectedJsonSchema(ITestData testData) { - JsonNode schema = Serializer.DefaultOptions.GetJsonSchemaAsNode(testData.Type, testData.Options); + JsonSerializerOptions options = testData.SerializerOptions is { } opts + ? new(opts) { TypeInfoResolver = Serializer.DefaultOptions.TypeInfoResolver } + : Serializer.DefaultOptions; + + JsonNode schema = options.GetJsonSchemaAsNode(testData.Type, testData.Options); AssertValidJsonSchema(testData.Type, testData.ExpectedJsonSchema, schema); } @@ -37,8 +41,12 @@ public void TestTypes_GeneratesExpectedJsonSchema(ITestData testData) [MemberData(nameof(GetTestDataUsingAllValues))] public void TestTypes_SerializedValueMatchesGeneratedSchema(ITestData testData) { - JsonNode schema = Serializer.DefaultOptions.GetJsonSchemaAsNode(testData.Type, testData.Options); - JsonNode? instance = JsonSerializer.SerializeToNode(testData.Value, testData.Type, Serializer.DefaultOptions); + JsonSerializerOptions options = testData.SerializerOptions is { } opts + ? new(opts) { TypeInfoResolver = Serializer.DefaultOptions.TypeInfoResolver } + : Serializer.DefaultOptions; + + JsonNode schema = options.GetJsonSchemaAsNode(testData.Type, testData.Options); + JsonNode? instance = JsonSerializer.SerializeToNode(testData.Value, testData.Type, options); AssertDocumentMatchesSchema(schema, instance); } diff --git a/src/libraries/System.Text.Json/tests/Common/MetadataTests.cs b/src/libraries/System.Text.Json/tests/Common/MetadataTests.cs index 967a3f4366a..0d92b296339 100644 --- a/src/libraries/System.Text.Json/tests/Common/MetadataTests.cs +++ b/src/libraries/System.Text.Json/tests/Common/MetadataTests.cs @@ -7,6 +7,7 @@ using System.Linq; using System.Reflection; using System.Text.Json.Serialization.Metadata; +using System.Threading.Tasks; using Xunit; namespace System.Text.Json.Serialization.Tests @@ -304,6 +305,61 @@ public void RespectRequiredConstructorParameters_true_ReportsCorrespondingProper }); } + [Fact] + public async Task ClassWithRefStructProperty_Serialization() + { + if (Serializer.IsSourceGeneratedSerializer) + { + // The source generator warns but otherwise skips ref struct properties. + ClassWithRefStructProperty value = new(); + string json = await Serializer.SerializeWrapper(value); + Assert.Equal("{}", json); + + ClassWithRefStructProperty deserialized = await Serializer.DeserializeWrapper("""{"Value":"abc"}"""); + Assert.True(deserialized.Value.IsEmpty); + } + else + { + // The reflection-based serializer throws. + Assert.Throws(() => Serializer.GetTypeInfo()); + } + } + + [Fact] + public async Task ClassWithRefStructConstructorParameter_Serialization() + { + if (Serializer.IsSourceGeneratedSerializer) + { + // The source generator warns but otherwise skips constructors with ref struct parameters. + ClassWithRefStructConstructorParameter value = new(); + string json = await Serializer.SerializeWrapper(value); + Assert.Equal("""{"Value":"default"}""", json); + + await Assert.ThrowsAsync(() => Serializer.DeserializeWrapper("{}")); + } + else + { + // The reflection-based serializer throws. + Assert.Throws(() => Serializer.GetTypeInfo()); + } + } + +#if NET9_0_OR_GREATER + [Fact] + public void CollectionWithRefStructElement_Serialization() + { + if (Serializer.IsSourceGeneratedSerializer) + { + Assert.Throws(() => Serializer.GetTypeInfo()); + } + else + { + // The reflection-based serializer throws. + Assert.Throws(() => Serializer.GetTypeInfo()); + } + } +#endif + private static object? GetDefaultValue(ParameterInfo parameterInfo) { Type parameterType = parameterInfo.ParameterType; @@ -551,6 +607,52 @@ public ClassWithRequiredAndOptionalConstructorParameters(string? x, string? y = public string? X { get; } public string? Y { get; } } + + public class ClassWithRefStructProperty + { + public ReadOnlySpan Value + { + get => _value.AsSpan(); + set => _value = value.ToString(); + } + + private string? _value; + } + + public class ClassWithRefStructConstructorParameter + { + public ClassWithRefStructConstructorParameter() + { + Value = "default"; + } + + [JsonConstructor] + public ClassWithRefStructConstructorParameter(ReadOnlySpan value) + { + Value = value.ToString(); + } + + public string Value { get; } + } + +#if NET9_0_OR_GREATER + public class CollectionWithRefStructElement : IEnumerable> + { + private List _values = new(); + public void Add(ReadOnlySpan value) => _values.Add(value.ToString()); + IEnumerator> IEnumerable>.GetEnumerator() => new SpanEnumerator(_values.GetEnumerator()); + IEnumerator IEnumerable.GetEnumerator() => throw new NotImplementedException(); + + private sealed class SpanEnumerator(IEnumerator inner) : IEnumerator> + { + public ReadOnlySpan Current => inner.Current.AsSpan(); + object IEnumerator.Current => throw new NotSupportedException(); + public void Dispose() => inner.Dispose(); + public bool MoveNext() => inner.MoveNext(); + public void Reset() => inner.Reset(); + } + } +#endif } internal class WeatherForecastWithPOCOs diff --git a/src/libraries/System.Text.Json/tests/Common/ReferenceHandlerTests/ReferenceHandlerTests.cs b/src/libraries/System.Text.Json/tests/Common/ReferenceHandlerTests/ReferenceHandlerTests.cs index d0db5d9c585..c455278ea12 100644 --- a/src/libraries/System.Text.Json/tests/Common/ReferenceHandlerTests/ReferenceHandlerTests.cs +++ b/src/libraries/System.Text.Json/tests/Common/ReferenceHandlerTests/ReferenceHandlerTests.cs @@ -5,6 +5,7 @@ using System.Collections.Generic; using System.Collections.Immutable; using System.Text.Encodings.Web; +using System.Text.Json.Nodes; using System.Threading.Tasks; using Newtonsoft.Json; using Xunit; @@ -849,5 +850,76 @@ public IEnumerator GetEnumerator() IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); } + + [Theory] + [InlineData(typeof(ClassWithConflictingRefProperty), "$ref")] + [InlineData(typeof(ClassWithConflictingIdProperty), "$id")] + public async Task ClassWithConflictingMetadataProperties_ThrowsInvalidOperationException(Type type, string propertyName) + { + InvalidOperationException ex; + object value = Activator.CreateInstance(type); + + ex = Assert.Throws(() => Serializer.GetTypeInfo(type, s_serializerOptionsPreserve)); + ValidateException(ex); + + ex = await Assert.ThrowsAsync(() => Serializer.SerializeWrapper(value, type, s_serializerOptionsPreserve)); + ValidateException(ex); + + ex = await Assert.ThrowsAsync(() => Serializer.DeserializeWrapper("{}", type, s_serializerOptionsPreserve)); + ValidateException(ex); + + void ValidateException(InvalidOperationException ex) + { + Assert.Contains($"The type '{type}' contains property '{propertyName}' that conflicts with an existing metadata property name.", ex.Message); + } + } + + public class ClassWithConflictingRefProperty + { + [JsonPropertyName("$ref")] + public int Value { get; set; } + } + + public class ClassWithConflictingIdProperty + { + [JsonPropertyName("$id")] + public int Value { get; set; } + } + + [Fact] + public async Task ClassWithIgnoredConflictingProperty_Supported() + { + ClassWithIgnoredConflictingProperty value = new(); + string json = await Serializer.SerializeWrapper(value, s_serializerOptionsPreserve); + Assert.Equal("""{"$id":"1"}""", json); + + value = await Serializer.DeserializeWrapper(json, s_serializerOptionsPreserve); + Assert.NotNull(value); + } + + public class ClassWithIgnoredConflictingProperty + { + [JsonPropertyName("$id"), JsonIgnore] + public int Value { get; set; } + } + + [Fact] + public async Task ClassWithExtensionDataConflictingProperty_Supported() + { + ClassWithExtensionDataConflictingProperty value = new(); + string json = await Serializer.SerializeWrapper(value, s_serializerOptionsPreserve); + Assert.Equal("""{"$id":"1"}""", json); + + value = await Serializer.DeserializeWrapper("""{"$id":"1","extraProp":null}""", s_serializerOptionsPreserve); + Assert.NotNull(value); + Assert.Equal(1, value.Value.Count); + Assert.Contains("extraProp", value.Value); + } + + public class ClassWithExtensionDataConflictingProperty + { + [JsonPropertyName("$id"), JsonExtensionData] + public JsonObject Value { get; set; } + } } } diff --git a/src/libraries/System.Text.Json/tests/Common/RequiredKeywordTests.cs b/src/libraries/System.Text.Json/tests/Common/RequiredKeywordTests.cs index 22c50becfa0..9b701457736 100644 --- a/src/libraries/System.Text.Json/tests/Common/RequiredKeywordTests.cs +++ b/src/libraries/System.Text.Json/tests/Common/RequiredKeywordTests.cs @@ -727,6 +727,25 @@ public static IEnumerable InheritedPersonWithRequiredMembersSetsRequir }; } + [Fact] + public async Task ClassWithNullValidatingConstructor_ValidatesRequiredParameterBeforeCallingCtor() + { + // Regression test for https://github.com/dotnet/runtime/issues/107065 + JsonSerializerOptions options = new(Serializer.DefaultOptions) { RespectRequiredConstructorParameters = true }; + JsonException ex = await Assert.ThrowsAsync(() => Serializer.DeserializeWrapper("{}", options)); + Assert.Null(ex.InnerException); + } + + public class ClassWithNullValidatingConstructor + { + public ClassWithNullValidatingConstructor(string value) + { + Value = value ?? throw new ArgumentNullException(nameof(value)); + } + + public string Value { get; } + } + private static JsonTypeInfo GetTypeInfo(JsonSerializerOptions options) { options.TypeInfoResolver ??= JsonSerializerOptions.Default.TypeInfoResolver; diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/MetadataTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/MetadataTests.cs index f7030eb7c45..bdeaf59da2b 100644 --- a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/MetadataTests.cs +++ b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/MetadataTests.cs @@ -40,6 +40,11 @@ public partial class MetadataTests_SourceGen() : MetadataTests(new StringSeriali [JsonSerializable(typeof(DerivedClassWithShadowingProperties))] [JsonSerializable(typeof(IDerivedInterface))] [JsonSerializable(typeof(ClassWithRequiredAndOptionalConstructorParameters))] + [JsonSerializable(typeof(ClassWithRefStructProperty))] + [JsonSerializable(typeof(ClassWithRefStructConstructorParameter))] +#if NET9_0_OR_GREATER + [JsonSerializable(typeof(CollectionWithRefStructElement))] +#endif partial class Context : JsonSerializerContext; } } diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/ReferenceHandlerTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/ReferenceHandlerTests.cs index 001ecf921c8..03c1ede6458 100644 --- a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/ReferenceHandlerTests.cs +++ b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/ReferenceHandlerTests.cs @@ -135,6 +135,10 @@ public ReferenceHandlerTests_Metadata(JsonSerializerWrapper serializer) [JsonSerializable(typeof(LinkedList))] [JsonSerializable(typeof(LinkedList))] [JsonSerializable(typeof(LinkedList))] + [JsonSerializable(typeof(ClassWithConflictingRefProperty))] + [JsonSerializable(typeof(ClassWithConflictingIdProperty))] + [JsonSerializable(typeof(ClassWithIgnoredConflictingProperty))] + [JsonSerializable(typeof(ClassWithExtensionDataConflictingProperty))] internal sealed partial class ReferenceHandlerTestsContext_Metadata : JsonSerializerContext { } @@ -273,6 +277,10 @@ public ReferenceHandlerTests_Default(JsonSerializerWrapper serializer) [JsonSerializable(typeof(LinkedList))] [JsonSerializable(typeof(LinkedList))] [JsonSerializable(typeof(LinkedList))] + [JsonSerializable(typeof(ClassWithConflictingRefProperty))] + [JsonSerializable(typeof(ClassWithConflictingIdProperty))] + [JsonSerializable(typeof(ClassWithIgnoredConflictingProperty))] + [JsonSerializable(typeof(ClassWithExtensionDataConflictingProperty))] internal sealed partial class ReferenceHandlerTestsContext_Default : JsonSerializerContext { } diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/RequiredKeywordTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/RequiredKeywordTests.cs index 0515f0553bc..045ee191d7c 100644 --- a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/RequiredKeywordTests.cs +++ b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/Serialization/RequiredKeywordTests.cs @@ -33,6 +33,7 @@ public RequiredKeywordTests_SourceGen() [JsonSerializable(typeof(ClassWithRequiredKeywordAndJsonRequiredCustomAttribute))] [JsonSerializable(typeof(ClassWithCustomRequiredPropertyName))] [JsonSerializable(typeof(DerivedClassWithRequiredInitOnlyProperty))] + [JsonSerializable(typeof(ClassWithNullValidatingConstructor))] internal sealed partial class RequiredKeywordTestsContext : JsonSerializerContext { } diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/System.Text.Json.SourceGeneration.Tests.targets b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/System.Text.Json.SourceGeneration.Tests.targets index eede2cd52ee..7982d11db5e 100644 --- a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/System.Text.Json.SourceGeneration.Tests.targets +++ b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Tests/System.Text.Json.SourceGeneration.Tests.targets @@ -7,6 +7,7 @@ false + @@ -14,7 +15,8 @@ - $(NoWarn);SYSLIB0020;SYSLIB0049;SYSLIB1034;SYSLIB1037;SYSLIB1038;SYSLIB1039;SYSLIB1220;SYSLIB1222;SYSLIB1223 + + $(NoWarn);SYSLIB0020;SYSLIB0049;SYSLIB1030;SYSLIB1034;SYSLIB1037;SYSLIB1038;SYSLIB1039;SYSLIB1220;SYSLIB1222;SYSLIB1223;SYSLIB1225 true diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Unit.Tests/JsonSourceGeneratorDiagnosticsTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Unit.Tests/JsonSourceGeneratorDiagnosticsTests.cs index 5e5d83de2c0..915c3fed31e 100644 --- a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Unit.Tests/JsonSourceGeneratorDiagnosticsTests.cs +++ b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Unit.Tests/JsonSourceGeneratorDiagnosticsTests.cs @@ -631,5 +631,129 @@ public class MyPoco { } CompilationHelper.AssertEqualDiagnosticMessages(expectedDiagnostics, result.Diagnostics); } + + [Fact] + public void RefStructPropertyWithoutJsonIgnore_CompilesWithWarning() + { + // Regression test for https://github.com/dotnet/runtime/issues/98590 + + string source = """ + using System; + using System.Text.Json.Serialization; + + public class MyPoco + { + public ReadOnlySpan Values => "abc".AsSpan(); + } + + [JsonSerializable(typeof(MyPoco))] + public partial class MyContext : JsonSerializerContext + { + } + """; + + Compilation compilation = CompilationHelper.CreateCompilation(source); + JsonSourceGeneratorResult result = CompilationHelper.RunJsonSourceGenerator(compilation, disableDiagnosticValidation: true); + + Location propertyLocation = ((INamedTypeSymbol)compilation.GetSymbolsWithName("MyPoco").First()).GetMembers("Values").First().Locations[0]; + + var expectedDiagnostics = new DiagnosticData[] + { + new(DiagnosticSeverity.Warning, propertyLocation, "The type 'MyPoco' includes the ref like property, field or constructor parameter 'Values'. No source code will be generated for the property, field or constructor."), + }; + + CompilationHelper.AssertEqualDiagnosticMessages(expectedDiagnostics, result.Diagnostics); + } + + [Fact] + public void RefStructCtorParam_CompilesWithWarning() + { + // Regression test for https://github.com/dotnet/runtime/issues/98590 + + string source = """ + using System; + using System.Text.Json.Serialization; + + public class MyPoco + { + public MyPoco(ReadOnlySpan value) + { + Value = value.ToString(); + } + + public string Value { get; } + } + + [JsonSerializable(typeof(MyPoco))] + public partial class MyContext : JsonSerializerContext + { + } + """; + + Compilation compilation = CompilationHelper.CreateCompilation(source); + JsonSourceGeneratorResult result = CompilationHelper.RunJsonSourceGenerator(compilation, disableDiagnosticValidation: true); + + ITypeSymbol type = (INamedTypeSymbol)compilation.GetSymbolsWithName("MyPoco").First(); + IMethodSymbol ctor = (IMethodSymbol)type.GetMembers(".ctor").First(); + IParameterSymbol param = ctor.Parameters.First(); + + var expectedDiagnostics = new DiagnosticData[] + { + new(DiagnosticSeverity.Warning, param.Locations.First(), "The type 'MyPoco' includes the ref like property, field or constructor parameter 'value'. No source code will be generated for the property, field or constructor."), + }; + + CompilationHelper.AssertEqualDiagnosticMessages(expectedDiagnostics, result.Diagnostics); + } + +#if NET9_0_OR_GREATER + [Fact] + public void CollectionWithRefStructElement_CompilesWithWarning() + { + // Regression test for https://github.com/dotnet/runtime/issues/98590 + + string source = """ + using System; + using System.Collections; + using System.Collections.Generic; + using System.Text.Json.Serialization; + + public class CollectionWithRefStructElement : IEnumerable> + { + private List _values = new(); + public void Add(ReadOnlySpan value) => _values.Add(value.ToString()); + IEnumerator> IEnumerable>.GetEnumerator() => new SpanEnumerator(_values.GetEnumerator()); + IEnumerator IEnumerable.GetEnumerator() => throw new NotImplementedException(); + + private sealed class SpanEnumerator(IEnumerator inner) : IEnumerator> + { + public ReadOnlySpan Current => inner.Current.AsSpan(); + object IEnumerator.Current => throw new NotSupportedException(); + public void Dispose() => inner.Dispose(); + public bool MoveNext() => inner.MoveNext(); + public void Reset() => inner.Reset(); + } + } + + [JsonSerializable(typeof(CollectionWithRefStructElement))] + public partial class MyContext : JsonSerializerContext + { + } + """; + + CSharpParseOptions parseOptions = CompilationHelper.CreateParseOptions((LanguageVersion)1300); // C# 13 required for ref struct collection elements. + Compilation compilation = CompilationHelper.CreateCompilation(source, parseOptions: parseOptions); + JsonSourceGeneratorResult result = CompilationHelper.RunJsonSourceGenerator(compilation, disableDiagnosticValidation: true); + + ISymbol contextSymbol = compilation.GetSymbolsWithName("MyContext").First(); + Collections.Immutable.ImmutableArray attributes = contextSymbol.GetAttributes(); + + var expectedDiagnostics = new DiagnosticData[] + { + new(DiagnosticSeverity.Warning, attributes[0].GetLocation(), "Did not generate serialization metadata for type 'CollectionWithRefStructElement'."), + }; + + CompilationHelper.AssertEqualDiagnosticMessages(expectedDiagnostics, result.Diagnostics); + } +#endif } } diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Unit.Tests/JsonSourceGeneratorTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Unit.Tests/JsonSourceGeneratorTests.cs index 99fc3d729a6..185881ccbcd 100644 --- a/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Unit.Tests/JsonSourceGeneratorTests.cs +++ b/src/libraries/System.Text.Json/tests/System.Text.Json.SourceGeneration.Unit.Tests/JsonSourceGeneratorTests.cs @@ -858,5 +858,30 @@ internal partial class ModelContext : JsonSerializerContext Compilation compilation = CompilationHelper.CreateCompilation(source); CompilationHelper.RunJsonSourceGenerator(compilation); } + + [Fact] + public void RefStructPropertyWithJsonIgnore_CompilesSuccessfully() + { + // Regression test for https://github.com/dotnet/runtime/issues/98590 + + string source = """ + using System; + using System.Text.Json.Serialization; + + public class MyPoco + { + [JsonIgnore] + public ReadOnlySpan Values => "abc".AsSpan(); + } + + [JsonSerializable(typeof(MyPoco))] + public partial class MyContext : JsonSerializerContext + { + } + """; + + Compilation compilation = CompilationHelper.CreateCompilation(source); + CompilationHelper.RunJsonSourceGenerator(compilation); + } } } diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/JsonDocumentTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/JsonDocumentTests.cs index 518ab0f46e3..8be93677470 100644 --- a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/JsonDocumentTests.cs +++ b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/JsonDocumentTests.cs @@ -681,6 +681,7 @@ public static void ParseSimpleObject() string city = parsedObject.GetProperty("city").GetString(); int zip = parsedObject.GetProperty("zip").GetInt32(); + Assert.Equal(7, parsedObject.GetPropertyCount()); Assert.True(parsedObject.TryGetProperty("age", out JsonElement age2)); Assert.Equal(30, age2.GetInt32()); @@ -704,6 +705,7 @@ public static void ParseNestedJson() Assert.Equal(1, parsedObject.GetArrayLength()); JsonElement person = parsedObject[0]; + Assert.Equal(5, person.GetPropertyCount()); double age = person.GetProperty("age").GetDouble(); string first = person.GetProperty("first").GetString(); string last = person.GetProperty("last").GetString(); @@ -902,6 +904,7 @@ public static void ReadNumber_1Byte(sbyte value) Assert.Throws(() => root.GetDateTimeOffset()); Assert.Throws(() => root.GetGuid()); Assert.Throws(() => root.GetArrayLength()); + Assert.Throws(() => root.GetPropertyCount()); Assert.Throws(() => root.EnumerateArray()); Assert.Throws(() => root.EnumerateObject()); Assert.Throws(() => root.GetBoolean()); @@ -999,6 +1002,7 @@ public static void ReadNumber_2Bytes(short value) Assert.Throws(() => root.GetDateTimeOffset()); Assert.Throws(() => root.GetGuid()); Assert.Throws(() => root.GetArrayLength()); + Assert.Throws(() => root.GetPropertyCount()); Assert.Throws(() => root.EnumerateArray()); Assert.Throws(() => root.EnumerateObject()); Assert.Throws(() => root.GetBoolean()); @@ -1091,6 +1095,7 @@ public static void ReadSmallInteger(int value) Assert.Throws(() => root.GetDateTimeOffset()); Assert.Throws(() => root.GetGuid()); Assert.Throws(() => root.GetArrayLength()); + Assert.Throws(() => root.GetPropertyCount()); Assert.Throws(() => root.EnumerateArray()); Assert.Throws(() => root.EnumerateObject()); Assert.Throws(() => root.GetBoolean()); @@ -1194,6 +1199,7 @@ public static void ReadMediumInteger(long value) Assert.Throws(() => root.GetDateTimeOffset()); Assert.Throws(() => root.GetGuid()); Assert.Throws(() => root.GetArrayLength()); + Assert.Throws(() => root.GetPropertyCount()); Assert.Throws(() => root.EnumerateArray()); Assert.Throws(() => root.EnumerateObject()); Assert.Throws(() => root.GetBoolean()); @@ -1267,6 +1273,7 @@ public static void ReadLargeInteger(ulong value) Assert.Throws(() => root.GetDateTimeOffset()); Assert.Throws(() => root.GetGuid()); Assert.Throws(() => root.GetArrayLength()); + Assert.Throws(() => root.GetPropertyCount()); Assert.Throws(() => root.EnumerateArray()); Assert.Throws(() => root.EnumerateObject()); Assert.Throws(() => root.GetBoolean()); @@ -1340,6 +1347,7 @@ public static void ReadTooLargeInteger() Assert.Throws(() => root.GetDateTimeOffset()); Assert.Throws(() => root.GetGuid()); Assert.Throws(() => root.GetArrayLength()); + Assert.Throws(() => root.GetPropertyCount()); Assert.Throws(() => root.EnumerateArray()); Assert.Throws(() => root.EnumerateObject()); Assert.Throws(() => root.GetBoolean()); @@ -1379,6 +1387,7 @@ public static void ReadDateTimeAndDateTimeOffset(string jsonString, string expec Assert.Throws(() => root.GetInt64()); Assert.Throws(() => root.GetUInt64()); Assert.Throws(() => root.GetArrayLength()); + Assert.Throws(() => root.GetPropertyCount()); Assert.Throws(() => root.EnumerateArray()); Assert.Throws(() => root.EnumerateObject()); Assert.Throws(() => root.GetBoolean()); @@ -1462,6 +1471,7 @@ public static void ReadGuid(string jsonString, string expectedStr) Assert.Throws(() => root.GetInt64()); Assert.Throws(() => root.GetUInt64()); Assert.Throws(() => root.GetArrayLength()); + Assert.Throws(() => root.GetPropertyCount()); Assert.Throws(() => root.EnumerateArray()); Assert.Throws(() => root.EnumerateObject()); Assert.Throws(() => root.GetBoolean()); @@ -1564,6 +1574,7 @@ public static void ReadNonInteger(string str, double expectedDouble, float expec Assert.Throws(() => root.GetDateTimeOffset()); Assert.Throws(() => root.GetGuid()); Assert.Throws(() => root.GetArrayLength()); + Assert.Throws(() => root.GetPropertyCount()); Assert.Throws(() => root.EnumerateArray()); Assert.Throws(() => root.EnumerateObject()); Assert.Throws(() => root.GetBoolean()); @@ -1654,6 +1665,7 @@ public static void ReadTooPreciseDouble() Assert.Throws(() => root.GetDateTimeOffset()); Assert.Throws(() => root.GetGuid()); Assert.Throws(() => root.GetArrayLength()); + Assert.Throws(() => root.GetPropertyCount()); Assert.Throws(() => root.EnumerateArray()); Assert.Throws(() => root.EnumerateObject()); Assert.Throws(() => root.GetBoolean()); @@ -1735,6 +1747,7 @@ public static void CheckUseAfterDispose() Assert.Throws(() => root.ValueKind); Assert.Throws(() => root.GetArrayLength()); + Assert.Throws(() => root.GetPropertyCount()); Assert.Throws(() => root.EnumerateArray()); Assert.Throws(() => root.EnumerateObject()); Assert.Throws(() => root.GetDouble()); @@ -1793,6 +1806,7 @@ public static void CheckUseDefault() Assert.Equal(JsonValueKind.Undefined, root.ValueKind); Assert.Throws(() => root.GetArrayLength()); + Assert.Throws(() => root.GetPropertyCount()); Assert.Throws(() => root.EnumerateArray()); Assert.Throws(() => root.EnumerateObject()); Assert.Throws(() => root.GetDouble()); @@ -2442,6 +2456,7 @@ public static void GetRawText() using (JsonDocument doc = JsonDocument.Parse(json)) { + Assert.Equal(6, doc.RootElement.GetPropertyCount()); JsonElement.ObjectEnumerator enumerator = doc.RootElement.EnumerateObject(); Assert.True(enumerator.MoveNext(), "Move to first property"); JsonProperty property = enumerator.Current; @@ -2449,6 +2464,7 @@ public static void GetRawText() Assert.Equal(" weird property name", property.Name); string rawText = property.ToString(); int crCount = rawText.Count(c => c == '\r'); + Assert.Equal(2, property.Value.GetPropertyCount()); Assert.Equal(128 + crCount, rawText.Length); Assert.Equal('\"', rawText[0]); Assert.Equal(' ', rawText[1]); @@ -3437,6 +3453,46 @@ public static void ParseValue_AllowMultipleValues_TrailingContent() JsonTestHelper.AssertThrows(ref reader, (ref Utf8JsonReader reader) => reader.Read()); } + [Theory] + [InlineData("""{ "foo" : [1], "test": false, "bar" : { "nested": 3 } }""", 3)] + [InlineData("""{ "foo" : [1,2,3,4] }""", 1)] + [InlineData("""{}""", 0)] + [InlineData("""{ "foo" : {"nested:" : {"nested": 1, "bla": [1, 2, {"bla": 3}] } }, "test": true, "foo2" : {"nested:" : {"nested": 1, "bla": [1, 2, {"bla": 3}] } }}""", 3)] + public static void TestGetPropertyCount(string json, int expectedCount) + { + JsonElement element = JsonSerializer.Deserialize(json); + Assert.Equal(expectedCount, element.GetPropertyCount()); + } + + [Fact] + public static void VerifyGetPropertyCountAndArrayLengthUsingEnumerateMethods() + { + using (JsonDocument doc = JsonDocument.Parse(SR.ProjectLockJson)) + { + CheckPropertyCountAndArrayLengthAgainstEnumerateMethods(doc.RootElement); + } + + void CheckPropertyCountAndArrayLengthAgainstEnumerateMethods(JsonElement elem) + { + if (elem.ValueKind == JsonValueKind.Object) + { + Assert.Equal(elem.EnumerateObject().Count(), elem.GetPropertyCount()); + foreach (JsonProperty prop in elem.EnumerateObject()) + { + CheckPropertyCountAndArrayLengthAgainstEnumerateMethods(prop.Value); + } + } + else if (elem.ValueKind == JsonValueKind.Array) + { + Assert.Equal(elem.EnumerateArray().Count(), elem.GetArrayLength()); + foreach (JsonElement item in elem.EnumerateArray()) + { + CheckPropertyCountAndArrayLengthAgainstEnumerateMethods(item); + } + } + } + } + [Fact] public static void EnsureResizeSucceeds() { diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/CacheTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/CacheTests.cs index 5a75a784cd3..d283789a6b3 100644 --- a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/CacheTests.cs +++ b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/CacheTests.cs @@ -239,6 +239,8 @@ public static void JsonSerializerOptionsUpdateHandler_ClearingDoesntPreventSeria JsonSerializer.Serialize(testObj, options); Assert.NotEqual(0, getCount(options)); + }, new RemoteInvokeOptions() { + TimeOut = RemoteExecutor.FailWaitTimeoutMilliseconds * PlatformDetection.SlowRuntimeTimeoutModifier }).Dispose(); static Func CreateCacheCountAccessor() @@ -294,6 +296,8 @@ public static void JsonSerializerOptions_ReuseConverterCaches() Assert.Same(originalCacheOptions, getCacheOptions(options2)); } } + }, new RemoteInvokeOptions() { + TimeOut = RemoteExecutor.FailWaitTimeoutMilliseconds * PlatformDetection.SlowRuntimeTimeoutModifier }).Dispose(); static Func CreateCacheOptionsAccessor() diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/PolymorphicTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/PolymorphicTests.cs index 9e14737051a..861522b881d 100644 --- a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/PolymorphicTests.cs +++ b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/PolymorphicTests.cs @@ -4,6 +4,7 @@ using System.Collections; using System.Collections.Generic; using System.Collections.Immutable; +using System.Text.Json.Nodes; using System.Text.Json.Serialization.Metadata; using System.Threading.Tasks; using Xunit; @@ -577,5 +578,102 @@ class MyDerivedThing : MyThing class MyThingCollection : List { } class MyThingDictionary : Dictionary { } + + [Theory] + [InlineData(typeof(PolymorphicTypeWithConflictingPropertyNameAtBase), typeof(PolymorphicTypeWithConflictingPropertyNameAtBase.Derived))] + [InlineData(typeof(PolymorphicTypeWithConflictingPropertyNameAtDerived), typeof(PolymorphicTypeWithConflictingPropertyNameAtDerived.Derived))] + public async Task PolymorphicTypesWithConflictingPropertyNames_ThrowsInvalidOperationException(Type baseType, Type derivedType) + { + InvalidOperationException ex; + object value = Activator.CreateInstance(derivedType); + + ex = Assert.Throws(() => Serializer.GetTypeInfo(baseType)); + ValidateException(ex); + + ex = await Assert.ThrowsAsync(() => Serializer.SerializeWrapper(value, baseType)); + ValidateException(ex); + + ex = await Assert.ThrowsAsync(() => Serializer.DeserializeWrapper("{}", baseType)); + ValidateException(ex); + + void ValidateException(InvalidOperationException ex) + { + Assert.Contains($"The type '{derivedType}' contains property 'Type' that conflicts with an existing metadata property name.", ex.Message); + } + } + + [JsonPolymorphic(TypeDiscriminatorPropertyName = "Type")] + [JsonDerivedType(typeof(Derived), nameof(Derived))] + public abstract class PolymorphicTypeWithConflictingPropertyNameAtBase + { + public string Type { get; set; } + + public class Derived : PolymorphicTypeWithConflictingPropertyNameAtBase + { + public string Name { get; set; } + } + } + + [JsonPolymorphic(TypeDiscriminatorPropertyName = "Type")] + [JsonDerivedType(typeof(Derived), nameof(Derived))] + public abstract class PolymorphicTypeWithConflictingPropertyNameAtDerived + { + public class Derived : PolymorphicTypeWithConflictingPropertyNameAtDerived + { + public string Type { get; set; } + } + } + + [Fact] + public async Task PolymorphicTypeWithIgnoredConflictingPropertyName_Supported() + { + PolymorphicTypeWithIgnoredConflictingPropertyName value = new PolymorphicTypeWithIgnoredConflictingPropertyName.Derived(); + + JsonTypeInfo typeInfo = Serializer.GetTypeInfo(typeof(PolymorphicTypeWithIgnoredConflictingPropertyName)); + Assert.NotNull(typeInfo); + + string json = await Serializer.SerializeWrapper(value); + Assert.Equal("""{"Type":"Derived"}""", json); + + value = await Serializer.DeserializeWrapper(json); + Assert.IsType(value); + } + + [JsonPolymorphic(TypeDiscriminatorPropertyName = "Type")] + [JsonDerivedType(typeof(Derived), nameof(Derived))] + public abstract class PolymorphicTypeWithIgnoredConflictingPropertyName + { + [JsonIgnore] + public string Type { get; set; } + + public class Derived : PolymorphicTypeWithIgnoredConflictingPropertyName; + } + + [Fact] + public async Task PolymorphicTypeWithExtensionDataConflictingPropertyName_Supported() + { + PolymorphicTypeWithExtensionDataConflictingPropertyName value = new PolymorphicTypeWithExtensionDataConflictingPropertyName.Derived(); + + JsonTypeInfo typeInfo = Serializer.GetTypeInfo(typeof(PolymorphicTypeWithIgnoredConflictingPropertyName)); + Assert.NotNull(typeInfo); + + string json = await Serializer.SerializeWrapper(value); + Assert.Equal("""{"Type":"Derived"}""", json); + + value = await Serializer.DeserializeWrapper("""{"Type":"Derived","extraProp":null}"""); + Assert.IsType(value); + Assert.Equal(1, value.Type.Count); + Assert.Contains("extraProp", value.Type); + } + + [JsonPolymorphic(TypeDiscriminatorPropertyName = "Type")] + [JsonDerivedType(typeof(Derived), nameof(Derived))] + public abstract class PolymorphicTypeWithExtensionDataConflictingPropertyName + { + [JsonExtensionData] + public JsonObject Type { get; set; } + + public class Derived : PolymorphicTypeWithExtensionDataConflictingPropertyName; + } } } diff --git a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/Stream.ReadTests.cs b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/Stream.ReadTests.cs index f689cf296ea..e296ee97c8d 100644 --- a/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/Stream.ReadTests.cs +++ b/src/libraries/System.Text.Json/tests/System.Text.Json.Tests/Serialization/Stream.ReadTests.cs @@ -220,11 +220,14 @@ public async Task TestBOMWithShortAndLongBuffers(Stream stream, int count, int e void VerifyElement(int index) { Assert.Equal(JsonValueKind.Object, value[index].GetProperty("Test").ValueKind); + Assert.Equal(0, value[index].GetProperty("Test").GetPropertyCount()); Assert.False(value[index].GetProperty("Test").EnumerateObject().MoveNext()); Assert.Equal(JsonValueKind.Array, value[index].GetProperty("Test2").ValueKind); Assert.Equal(0, value[index].GetProperty("Test2").GetArrayLength()); Assert.Equal(JsonValueKind.Object, value[index].GetProperty("Test3").ValueKind); Assert.Equal(JsonValueKind.Object, value[index].GetProperty("Test3").GetProperty("Value").ValueKind); + Assert.Equal(1, value[index].GetProperty("Test3").GetPropertyCount()); + Assert.Equal(0, value[index].GetProperty("Test3").GetProperty("Value").GetPropertyCount()); Assert.False(value[index].GetProperty("Test3").GetProperty("Value").EnumerateObject().MoveNext()); Assert.Equal(0, value[index].GetProperty("PersonType").GetInt32()); Assert.Equal(2, value[index].GetProperty("Id").GetInt32()); diff --git a/src/libraries/System.Text.RegularExpressions/System.Text.RegularExpressions.sln b/src/libraries/System.Text.RegularExpressions/System.Text.RegularExpressions.sln index ea146c751ff..a42db113cbd 100644 --- a/src/libraries/System.Text.RegularExpressions/System.Text.RegularExpressions.sln +++ b/src/libraries/System.Text.RegularExpressions/System.Text.RegularExpressions.sln @@ -21,6 +21,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Reflection.Primitive EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{C5B9BDED-632F-4698-B0D7-FD12A1918170}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{AF39092C-A570-468F-B0C6-F2DE72359505}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{19F5ED62-25AE-462C-B168-CA72F078FFA4}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{77CDA838-6489-4816-8847-DE2C7F5E1DCE}" @@ -129,6 +131,10 @@ Global {C5B9BDED-632F-4698-B0D7-FD12A1918170}.Debug|Any CPU.Build.0 = Debug|Any CPU {C5B9BDED-632F-4698-B0D7-FD12A1918170}.Release|Any CPU.ActiveCfg = Release|Any CPU {C5B9BDED-632F-4698-B0D7-FD12A1918170}.Release|Any CPU.Build.0 = Release|Any CPU + {AF39092C-A570-468F-B0C6-F2DE72359505}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {AF39092C-A570-468F-B0C6-F2DE72359505}.Debug|Any CPU.Build.0 = Debug|Any CPU + {AF39092C-A570-468F-B0C6-F2DE72359505}.Release|Any CPU.ActiveCfg = Release|Any CPU + {AF39092C-A570-468F-B0C6-F2DE72359505}.Release|Any CPU.Build.0 = Release|Any CPU {19F5ED62-25AE-462C-B168-CA72F078FFA4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {19F5ED62-25AE-462C-B168-CA72F078FFA4}.Debug|Any CPU.Build.0 = Debug|Any CPU {19F5ED62-25AE-462C-B168-CA72F078FFA4}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -239,6 +245,7 @@ Global {5BEC4932-AA8C-4FA1-B2E2-0DC34CCA3986} = {15319A22-BC91-407B-A795-334DD05C82A0} {C043B00D-8662-43E4-9E87-8BB317059111} = {15319A22-BC91-407B-A795-334DD05C82A0} {C5B9BDED-632F-4698-B0D7-FD12A1918170} = {0D20E771-24BD-4F9E-BBD0-60156E8C44FC} + {AF39092C-A570-468F-B0C6-F2DE72359505} = {0D20E771-24BD-4F9E-BBD0-60156E8C44FC} {19F5ED62-25AE-462C-B168-CA72F078FFA4} = {0D20E771-24BD-4F9E-BBD0-60156E8C44FC} {77CDA838-6489-4816-8847-DE2C7F5E1DCE} = {0D20E771-24BD-4F9E-BBD0-60156E8C44FC} {202F5AD1-E8E5-4709-8D12-1DBCC6680BFB} = {0D20E771-24BD-4F9E-BBD0-60156E8C44FC} diff --git a/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Emitter.cs b/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Emitter.cs index a64b43d6884..ea3ced24ee0 100644 --- a/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Emitter.cs +++ b/src/libraries/System.Text.RegularExpressions/gen/RegexGenerator.Emitter.cs @@ -452,12 +452,40 @@ private static string EmitSearchValues(char[] chars, Dictionary "s_asciiExceptWhiteSpace", "FFFFFFFFFFFF00FC01000078010000F8" => "s_asciiExceptWordChars", + "FFFFFFFFFFDF00FCFFFFFFFFFFFFFFFF" => "s_asciiExceptDigitsAndDash", + "000000000040FF03FEFFFF07FEFFFF07" => "s_asciiLettersAndDigitsAndDot", + "000000000020FF03FEFFFF07FEFFFF07" => "s_asciiLettersAndDigitsAndDash", + "000000000060FF03FEFFFF07FEFFFF07" => "s_asciiLettersAndDigitsAndDashDot", + "000000000040FF03FEFFFF87FEFFFF07" => "s_asciiLettersAndDigitsAndDotUnderscore", + "000000000020FF03FEFFFF87FEFFFF07" => "s_asciiLettersAndDigitsAndDashUnderscore", + "000000000060FF03FEFFFF87FEFFFF07" => "s_asciiLettersAndDigitsAndDashDotUnderscore", + "000000000040FF030000000000000000" => "s_asciiDigitsAndDot", + "000000000020FF030000000000000000" => "s_asciiDigitsAndDash", + "0000000000200000FEFFFF07FEFFFF07" => "s_asciiLettersAndDash", + "0000000000000000FEFFFF87FEFFFF07" => "s_asciiLettersAndUnderscore", + "000000000000FF0300000000FEFFFF07" => "s_asciiLettersLowerAndDigits", + "000000000000FF03FEFFFF0700000000" => "s_asciiLettersUpperAndDigits", + "000000000020FF0300000000FEFFFF07" => "s_asciiLettersLowerAndDigitsAndDash", + _ => $"s_ascii_{hexBitmap.TrimStart('0')}" }; } else { fieldName = GetSHA256FieldName("s_nonAscii_", new string(chars)); + + fieldName = fieldName switch + { + "s_nonAscii_326E1FD0AD567A84CAD13F2BE521A57789829F59D59ABE37F9E111D0182B6601" => "s_asciiLettersAndKelvinSign", + "s_nonAscii_46E3FAA2E94950B9D41E9AB1B570CAB55D04A30009110072B4BC074D57272527" => "s_asciiLettersAndDigitsAndKelvinSign", + "s_nonAscii_2D5586687DC37F0329E3CA4127326E68B5A3A090B13B7834AEA7BFC4EDDE220F" => "s_asciiLettersAndDigitsAndDashKelvinSign", + "s_nonAscii_83AFA3CC45CC4C2D8C316947CFC319199813C7F90226BDF348E2B3236D6237C1" => "s_asciiLettersAndDigitsAndDashDotKelvinSign", + "s_nonAscii_9FA52D3BAECB644578472387D5284CC6F36F408FEB88A04BA674CE14F24D2386" => "s_asciiLettersAndDigitsAndUnderscoreKelvinSign", + "s_nonAscii_D41BEF0BEAFBA32A45D2356E3F1579596F35B7C67CAA9CF7C4B3F2A5422DCA51" => "s_asciiLettersAndDigitsAndDashUnderscoreKelvinSign", + "s_nonAscii_0D7E5600013B3F0349C00277028B6DEA566BB9BAF991CCB7AC92DEC54C4544C1" => "s_asciiLettersAndDigitsAndDashDotUnderscoreKelvinSign", + + _ => fieldName + }; } } diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Regex.Cache.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Regex.Cache.cs index c8759484567..35dddc889d8 100644 --- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Regex.Cache.cs +++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Regex.Cache.cs @@ -248,9 +248,12 @@ private static void Add(Key key, Regex regex) } } - // Remove the key found to have the smallest access stamp. + // Remove the key found to have the smallest access stamp. List ordering isn't important, so rather than + // just removing the element at minListIndex, which would result in an O(N) shift down, we copy the last + // element to minListIndex, and then remove the last. (If minListIndex is the last, this is a no-op.) s_cacheDictionary.TryRemove(s_cacheList[minListIndex].Key, out _); - s_cacheList.RemoveAt(minListIndex); + s_cacheList[minListIndex] = s_cacheList[^1]; + s_cacheList.RemoveAt(s_cacheList.Count - 1); } // Finally add the regex. diff --git a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexFindOptimizations.cs b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexFindOptimizations.cs index 13187691362..1291dff977e 100644 --- a/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexFindOptimizations.cs +++ b/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/RegexFindOptimizations.cs @@ -84,7 +84,6 @@ public RegexFindOptimizations(RegexNode root, RegexOptions options) bool dfa = (options & RegexOptions.NonBacktracking) != 0; bool compiled = (options & RegexOptions.Compiled) != 0 && !dfa; // for now, we never generate code for NonBacktracking, so treat it as non-compiled bool interpreter = !compiled && !dfa; - bool usesRfoTryFind = !compiled; // For interpreter, we want to employ optimizations, but we don't want to make construction significantly // more expensive; someone who wants to pay to do more work can specify Compiled. So for the interpreter @@ -149,10 +148,7 @@ public RegexFindOptimizations(RegexNode root, RegexOptions options) LeadingPrefixes = caseInsensitivePrefixes; FindMode = FindNextStartingPositionMode.LeadingStrings_OrdinalIgnoreCase_LeftToRight; #if SYSTEM_TEXT_REGULAREXPRESSIONS - if (usesRfoTryFind) - { - LeadingStrings = SearchValues.Create(LeadingPrefixes, StringComparison.OrdinalIgnoreCase); - } + LeadingStrings = SearchValues.Create(LeadingPrefixes, StringComparison.OrdinalIgnoreCase); #endif return; } @@ -165,10 +161,7 @@ public RegexFindOptimizations(RegexNode root, RegexOptions options) // LeadingPrefixes = caseSensitivePrefixes; // FindMode = FindNextStartingPositionMode.LeadingStrings_LeftToRight; #if SYSTEM_TEXT_REGULAREXPRESSIONS - // if (usesRfoTryFind) - // { - // LeadingStrings = SearchValues.Create(LeadingPrefixes, StringComparison.Ordinal); - // } + // LeadingStrings = SearchValues.Create(LeadingPrefixes, StringComparison.Ordinal); #endif // return; //} @@ -699,14 +692,9 @@ public bool TryFindNextStartingPositionLeftToRight(ReadOnlySpan textSpan, case FindNextStartingPositionMode.LeadingStrings_LeftToRight: case FindNextStartingPositionMode.LeadingStrings_OrdinalIgnoreCase_LeftToRight: { - if (LeadingStrings is not SearchValues searchValues) - { - // This should be exceedingly rare and only happen if a Compiled regex selected this - // option but then failed to compile (e.g. due to too deep stacks) and fell back to the interpreter. - return true; - } + Debug.Assert(LeadingStrings is not null); - int i = textSpan.Slice(pos).IndexOfAny(searchValues); + int i = textSpan.Slice(pos).IndexOfAny(LeadingStrings); if (i >= 0) { pos += i; diff --git a/src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/Regex.Match.Tests.cs b/src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/Regex.Match.Tests.cs index 1f0e2932c64..1bbc7cf607c 100644 --- a/src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/Regex.Match.Tests.cs +++ b/src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/Regex.Match.Tests.cs @@ -1264,8 +1264,6 @@ public static IEnumerable Match_Timeout_Throws_MemberData() // Lookarounds yield return new object[] { engine, @"((?=(?>a*))a)+", a1_000_000 }; yield return new object[] { engine, @"((?<=(?>a*))a)+", a1_000_000 }; - yield return new object[] { engine, @"((?!(?>[^a]*))a)+", a1_000_000 }; - yield return new object[] { engine, @"((?[^a]*))a)+", a1_000_000 }; // All of the below tests have catastrophic backtracking... diff --git a/src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/System.Text.RegularExpressions.Tests.csproj b/src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/System.Text.RegularExpressions.Tests.csproj index dbab47f63d0..fa554e131a5 100644 --- a/src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/System.Text.RegularExpressions.Tests.csproj +++ b/src/libraries/System.Text.RegularExpressions/tests/FunctionalTests/System.Text.RegularExpressions.Tests.csproj @@ -85,6 +85,11 @@ SetTargetFramework="TargetFramework=netstandard2.0" OutputItemType="Analyzer" ReferenceOutputAssembly="true" /> + + + diff --git a/src/libraries/System.Threading.AccessControl/System.Threading.AccessControl.sln b/src/libraries/System.Threading.AccessControl/System.Threading.AccessControl.sln index bde719faf80..6d9efa702f4 100644 --- a/src/libraries/System.Threading.AccessControl/System.Threading.AccessControl.sln +++ b/src/libraries/System.Threading.AccessControl/System.Threading.AccessControl.sln @@ -1,7 +1,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{7A3FDF55-70D1-42F5-9231-8F7CAB1B7097}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{9BA0DBB0-99CF-4DEE-A43F-2B49854798AA}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{7906A300-FECC-4AB9-8BAD-8A8C0AC7903B}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{96AF90CB-B031-4F19-A6F2-957715703954}" EndProject @@ -47,10 +47,10 @@ Global {7A3FDF55-70D1-42F5-9231-8F7CAB1B7097}.Debug|Any CPU.Build.0 = Debug|Any CPU {7A3FDF55-70D1-42F5-9231-8F7CAB1B7097}.Release|Any CPU.ActiveCfg = Release|Any CPU {7A3FDF55-70D1-42F5-9231-8F7CAB1B7097}.Release|Any CPU.Build.0 = Release|Any CPU - {9BA0DBB0-99CF-4DEE-A43F-2B49854798AA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {9BA0DBB0-99CF-4DEE-A43F-2B49854798AA}.Debug|Any CPU.Build.0 = Debug|Any CPU - {9BA0DBB0-99CF-4DEE-A43F-2B49854798AA}.Release|Any CPU.ActiveCfg = Release|Any CPU - {9BA0DBB0-99CF-4DEE-A43F-2B49854798AA}.Release|Any CPU.Build.0 = Release|Any CPU + {7906A300-FECC-4AB9-8BAD-8A8C0AC7903B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {7906A300-FECC-4AB9-8BAD-8A8C0AC7903B}.Debug|Any CPU.Build.0 = Debug|Any CPU + {7906A300-FECC-4AB9-8BAD-8A8C0AC7903B}.Release|Any CPU.ActiveCfg = Release|Any CPU + {7906A300-FECC-4AB9-8BAD-8A8C0AC7903B}.Release|Any CPU.Build.0 = Release|Any CPU {96AF90CB-B031-4F19-A6F2-957715703954}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {96AF90CB-B031-4F19-A6F2-957715703954}.Debug|Any CPU.Build.0 = Debug|Any CPU {96AF90CB-B031-4F19-A6F2-957715703954}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -94,7 +94,7 @@ Global GlobalSection(NestedProjects) = preSolution {7A3FDF55-70D1-42F5-9231-8F7CAB1B7097} = {5ED4F157-B780-4295-9D2F-1DE86DBCDA24} {66D93328-0A8C-44AD-923B-AD3EB69A9518} = {5ED4F157-B780-4295-9D2F-1DE86DBCDA24} - {9BA0DBB0-99CF-4DEE-A43F-2B49854798AA} = {C7B6A687-7D71-47EC-AC21-8B8DEA7EF016} + {7906A300-FECC-4AB9-8BAD-8A8C0AC7903B} = {C7B6A687-7D71-47EC-AC21-8B8DEA7EF016} {96AF90CB-B031-4F19-A6F2-957715703954} = {C7B6A687-7D71-47EC-AC21-8B8DEA7EF016} {6EA32BE1-8B5E-4807-B641-E7556C1E2C9D} = {D7D1A40A-E3E6-45DF-82CF-5BEE62109C70} {6A444824-8479-4DB5-8DCA-9F50353ADE29} = {8F3D0B8C-8814-4A4C-9663-837D46DA0AC6} diff --git a/src/libraries/System.Threading.Channels/System.Threading.Channels.sln b/src/libraries/System.Threading.Channels/System.Threading.Channels.sln index 6568b7f555b..5b60e024c01 100644 --- a/src/libraries/System.Threading.Channels/System.Threading.Channels.sln +++ b/src/libraries/System.Threading.Channels/System.Threading.Channels.sln @@ -3,7 +3,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\ EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Bcl.AsyncInterfaces", "..\Microsoft.Bcl.AsyncInterfaces\src\Microsoft.Bcl.AsyncInterfaces.csproj", "{EDFAAA9A-0A17-4FB7-85C8-B1DBF72DD049}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{6B242CF0-6FFA-46D4-A31A-8A1EDCFDAB60}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{F6410125-B985-40B4-BB5D-A7E08ED0FB0B}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{9158C7E3-284E-4D6F-BA23-B7534683E265}" EndProject @@ -55,10 +55,10 @@ Global {EDFAAA9A-0A17-4FB7-85C8-B1DBF72DD049}.Debug|Any CPU.Build.0 = Debug|Any CPU {EDFAAA9A-0A17-4FB7-85C8-B1DBF72DD049}.Release|Any CPU.ActiveCfg = Release|Any CPU {EDFAAA9A-0A17-4FB7-85C8-B1DBF72DD049}.Release|Any CPU.Build.0 = Release|Any CPU - {6B242CF0-6FFA-46D4-A31A-8A1EDCFDAB60}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {6B242CF0-6FFA-46D4-A31A-8A1EDCFDAB60}.Debug|Any CPU.Build.0 = Debug|Any CPU - {6B242CF0-6FFA-46D4-A31A-8A1EDCFDAB60}.Release|Any CPU.ActiveCfg = Release|Any CPU - {6B242CF0-6FFA-46D4-A31A-8A1EDCFDAB60}.Release|Any CPU.Build.0 = Release|Any CPU + {F6410125-B985-40B4-BB5D-A7E08ED0FB0B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F6410125-B985-40B4-BB5D-A7E08ED0FB0B}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F6410125-B985-40B4-BB5D-A7E08ED0FB0B}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F6410125-B985-40B4-BB5D-A7E08ED0FB0B}.Release|Any CPU.Build.0 = Release|Any CPU {9158C7E3-284E-4D6F-BA23-B7534683E265}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {9158C7E3-284E-4D6F-BA23-B7534683E265}.Debug|Any CPU.Build.0 = Debug|Any CPU {9158C7E3-284E-4D6F-BA23-B7534683E265}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -108,7 +108,7 @@ Global {845BFFC3-14F2-402E-81E5-B487D41B7CD9} = {07CE01C8-BDC8-4CED-AA33-6F3B35935CB6} {EDFAAA9A-0A17-4FB7-85C8-B1DBF72DD049} = {D3FF5D0E-208E-408F-97AD-C81EB31BB115} {4CFA1610-00D7-4651-82C8-A7504C475837} = {D3FF5D0E-208E-408F-97AD-C81EB31BB115} - {6B242CF0-6FFA-46D4-A31A-8A1EDCFDAB60} = {42E20B4D-6489-4096-8DC3-A0C20D19B1D6} + {F6410125-B985-40B4-BB5D-A7E08ED0FB0B} = {42E20B4D-6489-4096-8DC3-A0C20D19B1D6} {9158C7E3-284E-4D6F-BA23-B7534683E265} = {42E20B4D-6489-4096-8DC3-A0C20D19B1D6} {3D984937-E378-411E-8943-5B5DB23944F5} = {F69B62DE-61AD-4978-81C4-C095B62B5B04} {E427C88B-655E-43F9-A0C0-AA54D01BDBDF} = {F69B62DE-61AD-4978-81C4-C095B62B5B04} diff --git a/src/libraries/System.Threading.Channels/tests/System.Threading.Channels.Tests.csproj b/src/libraries/System.Threading.Channels/tests/System.Threading.Channels.Tests.csproj index 7d22b2afdee..06e639f472a 100644 --- a/src/libraries/System.Threading.Channels/tests/System.Threading.Channels.Tests.csproj +++ b/src/libraries/System.Threading.Channels/tests/System.Threading.Channels.Tests.csproj @@ -17,6 +17,10 @@ + + diff --git a/src/libraries/System.Threading.Overlapped/System.Threading.Overlapped.sln b/src/libraries/System.Threading.Overlapped/System.Threading.Overlapped.sln index 477cc316132..0b8130540a8 100644 --- a/src/libraries/System.Threading.Overlapped/System.Threading.Overlapped.sln +++ b/src/libraries/System.Threading.Overlapped/System.Threading.Overlapped.sln @@ -7,6 +7,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib.Gene EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\System.Private.CoreLib\ref\System.Private.CoreLib.csproj", "{4687BA7A-AF17-43B9-BB8A-5B802FDD4482}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{E48EB0CE-6F26-46FC-B213-0C8BF61184FF}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{C84846A6-ACFA-4145-AF76-AA56A5AC89FC}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{8B4BE458-0DE2-42A8-B7A2-3C82F21BAB23}" @@ -157,6 +159,27 @@ Global {4687BA7A-AF17-43B9-BB8A-5B802FDD4482}.Checked|arm64.ActiveCfg = Debug|Any CPU {4687BA7A-AF17-43B9-BB8A-5B802FDD4482}.Checked|x64.ActiveCfg = Debug|Any CPU {4687BA7A-AF17-43B9-BB8A-5B802FDD4482}.Checked|x86.ActiveCfg = Debug|Any CPU + {E48EB0CE-6F26-46FC-B213-0C8BF61184FF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E48EB0CE-6F26-46FC-B213-0C8BF61184FF}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E48EB0CE-6F26-46FC-B213-0C8BF61184FF}.Debug|arm.ActiveCfg = Debug|Any CPU + {E48EB0CE-6F26-46FC-B213-0C8BF61184FF}.Debug|arm64.ActiveCfg = Debug|Any CPU + {E48EB0CE-6F26-46FC-B213-0C8BF61184FF}.Debug|x64.ActiveCfg = Debug|Any CPU + {E48EB0CE-6F26-46FC-B213-0C8BF61184FF}.Debug|x64.Build.0 = Debug|Any CPU + {E48EB0CE-6F26-46FC-B213-0C8BF61184FF}.Debug|x86.ActiveCfg = Debug|Any CPU + {E48EB0CE-6F26-46FC-B213-0C8BF61184FF}.Debug|x86.Build.0 = Debug|Any CPU + {E48EB0CE-6F26-46FC-B213-0C8BF61184FF}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E48EB0CE-6F26-46FC-B213-0C8BF61184FF}.Release|Any CPU.Build.0 = Release|Any CPU + {E48EB0CE-6F26-46FC-B213-0C8BF61184FF}.Release|arm.ActiveCfg = Release|Any CPU + {E48EB0CE-6F26-46FC-B213-0C8BF61184FF}.Release|arm64.ActiveCfg = Release|Any CPU + {E48EB0CE-6F26-46FC-B213-0C8BF61184FF}.Release|x64.ActiveCfg = Release|Any CPU + {E48EB0CE-6F26-46FC-B213-0C8BF61184FF}.Release|x64.Build.0 = Release|Any CPU + {E48EB0CE-6F26-46FC-B213-0C8BF61184FF}.Release|x86.ActiveCfg = Release|Any CPU + {E48EB0CE-6F26-46FC-B213-0C8BF61184FF}.Release|x86.Build.0 = Release|Any CPU + {E48EB0CE-6F26-46FC-B213-0C8BF61184FF}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {E48EB0CE-6F26-46FC-B213-0C8BF61184FF}.Checked|arm.ActiveCfg = Debug|Any CPU + {E48EB0CE-6F26-46FC-B213-0C8BF61184FF}.Checked|arm64.ActiveCfg = Debug|Any CPU + {E48EB0CE-6F26-46FC-B213-0C8BF61184FF}.Checked|x64.ActiveCfg = Debug|Any CPU + {E48EB0CE-6F26-46FC-B213-0C8BF61184FF}.Checked|x86.ActiveCfg = Debug|Any CPU {C84846A6-ACFA-4145-AF76-AA56A5AC89FC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {C84846A6-ACFA-4145-AF76-AA56A5AC89FC}.Debug|Any CPU.Build.0 = Debug|Any CPU {C84846A6-ACFA-4145-AF76-AA56A5AC89FC}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -398,6 +421,7 @@ Global {A4B84F3E-9C18-4CF7-8CA8-9F4AA4A1634F} = {8B1F1ACE-FD0A-4083-8DE6-8148C541A2CA} {3F9C730B-665F-49A3-AB6D-C0A08E4F7CD1} = {8B1F1ACE-FD0A-4083-8DE6-8148C541A2CA} {8BAAF37B-C3C1-4DED-A89A-5513AE866360} = {D07DC3DB-723F-41C6-99A0-56F395D4D055} + {E48EB0CE-6F26-46FC-B213-0C8BF61184FF} = {D07DC3DB-723F-41C6-99A0-56F395D4D055} {C84846A6-ACFA-4145-AF76-AA56A5AC89FC} = {D07DC3DB-723F-41C6-99A0-56F395D4D055} {8B4BE458-0DE2-42A8-B7A2-3C82F21BAB23} = {D07DC3DB-723F-41C6-99A0-56F395D4D055} {4687BA7A-AF17-43B9-BB8A-5B802FDD4482} = {1CC21763-DACE-400F-808F-7B9DCF90DCBA} diff --git a/src/libraries/System.Threading.RateLimiting/System.Threading.RateLimiting.sln b/src/libraries/System.Threading.RateLimiting/System.Threading.RateLimiting.sln index 8f2fb73ec3c..1ad6230550e 100644 --- a/src/libraries/System.Threading.RateLimiting/System.Threading.RateLimiting.sln +++ b/src/libraries/System.Threading.RateLimiting/System.Threading.RateLimiting.sln @@ -3,7 +3,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\ EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Bcl.AsyncInterfaces", "..\Microsoft.Bcl.AsyncInterfaces\src\Microsoft.Bcl.AsyncInterfaces.csproj", "{F59F4FD7-EA00-47EA-A09A-6F76CB079F9B}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{394FA814-CF72-447D-AAE1-1B92CD63205D}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{D1A36607-05C3-44B3-AD07-AC8E0A69988F}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{25495BDC-0614-4FAC-B6EA-DF3F0E35A871}" EndProject @@ -53,10 +53,10 @@ Global {F59F4FD7-EA00-47EA-A09A-6F76CB079F9B}.Debug|Any CPU.Build.0 = Debug|Any CPU {F59F4FD7-EA00-47EA-A09A-6F76CB079F9B}.Release|Any CPU.ActiveCfg = Release|Any CPU {F59F4FD7-EA00-47EA-A09A-6F76CB079F9B}.Release|Any CPU.Build.0 = Release|Any CPU - {394FA814-CF72-447D-AAE1-1B92CD63205D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {394FA814-CF72-447D-AAE1-1B92CD63205D}.Debug|Any CPU.Build.0 = Debug|Any CPU - {394FA814-CF72-447D-AAE1-1B92CD63205D}.Release|Any CPU.ActiveCfg = Release|Any CPU - {394FA814-CF72-447D-AAE1-1B92CD63205D}.Release|Any CPU.Build.0 = Release|Any CPU + {D1A36607-05C3-44B3-AD07-AC8E0A69988F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D1A36607-05C3-44B3-AD07-AC8E0A69988F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D1A36607-05C3-44B3-AD07-AC8E0A69988F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D1A36607-05C3-44B3-AD07-AC8E0A69988F}.Release|Any CPU.Build.0 = Release|Any CPU {25495BDC-0614-4FAC-B6EA-DF3F0E35A871}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {25495BDC-0614-4FAC-B6EA-DF3F0E35A871}.Debug|Any CPU.Build.0 = Debug|Any CPU {25495BDC-0614-4FAC-B6EA-DF3F0E35A871}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -102,7 +102,7 @@ Global {AE81EE9F-1240-4AF1-BF21-7F451B7859E5} = {6614EF7F-23FC-4809-AFF5-1ADBF1B6422C} {F59F4FD7-EA00-47EA-A09A-6F76CB079F9B} = {85204CF5-0C88-4BBB-9E70-D8CCED82ED3D} {CD96AFE9-0F7F-42FA-BBDA-F57EDCBB4609} = {85204CF5-0C88-4BBB-9E70-D8CCED82ED3D} - {394FA814-CF72-447D-AAE1-1B92CD63205D} = {399BE36D-F2D9-420A-AA09-455D4BF52057} + {D1A36607-05C3-44B3-AD07-AC8E0A69988F} = {399BE36D-F2D9-420A-AA09-455D4BF52057} {25495BDC-0614-4FAC-B6EA-DF3F0E35A871} = {399BE36D-F2D9-420A-AA09-455D4BF52057} {FD274A80-0D68-48A0-9AC7-279C9E69BC63} = {111B1B5B-A004-4C05-9A8C-E0931DADA5FB} {2074D793-BE72-4128-BD17-6EF83FD69DD1} = {C28129A1-6D6F-4B06-B1FA-ADD0A6DFA7C2} diff --git a/src/libraries/System.Threading.Tasks.Dataflow/System.Threading.Tasks.Dataflow.sln b/src/libraries/System.Threading.Tasks.Dataflow/System.Threading.Tasks.Dataflow.sln index cb2cf47a201..75f77d78c17 100644 --- a/src/libraries/System.Threading.Tasks.Dataflow/System.Threading.Tasks.Dataflow.sln +++ b/src/libraries/System.Threading.Tasks.Dataflow/System.Threading.Tasks.Dataflow.sln @@ -1,7 +1,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{48428161-C841-43D4-8BD3-195A3D5C36C5}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{986667FC-4DA5-4496-B998-7DEB9879B180}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{25D78F42-920F-46BC-B644-B28EDB7FC15C}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{C4865002-095A-4B99-A737-216DC112ACA4}" EndProject @@ -49,10 +49,10 @@ Global {48428161-C841-43D4-8BD3-195A3D5C36C5}.Debug|Any CPU.Build.0 = Debug|Any CPU {48428161-C841-43D4-8BD3-195A3D5C36C5}.Release|Any CPU.ActiveCfg = Release|Any CPU {48428161-C841-43D4-8BD3-195A3D5C36C5}.Release|Any CPU.Build.0 = Release|Any CPU - {986667FC-4DA5-4496-B998-7DEB9879B180}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {986667FC-4DA5-4496-B998-7DEB9879B180}.Debug|Any CPU.Build.0 = Debug|Any CPU - {986667FC-4DA5-4496-B998-7DEB9879B180}.Release|Any CPU.ActiveCfg = Release|Any CPU - {986667FC-4DA5-4496-B998-7DEB9879B180}.Release|Any CPU.Build.0 = Release|Any CPU + {25D78F42-920F-46BC-B644-B28EDB7FC15C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {25D78F42-920F-46BC-B644-B28EDB7FC15C}.Debug|Any CPU.Build.0 = Debug|Any CPU + {25D78F42-920F-46BC-B644-B28EDB7FC15C}.Release|Any CPU.ActiveCfg = Release|Any CPU + {25D78F42-920F-46BC-B644-B28EDB7FC15C}.Release|Any CPU.Build.0 = Release|Any CPU {C4865002-095A-4B99-A737-216DC112ACA4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {C4865002-095A-4B99-A737-216DC112ACA4}.Debug|Any CPU.Build.0 = Debug|Any CPU {C4865002-095A-4B99-A737-216DC112ACA4}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -100,7 +100,7 @@ Global GlobalSection(NestedProjects) = preSolution {48428161-C841-43D4-8BD3-195A3D5C36C5} = {D7C6E667-E868-423C-883D-CBDE73BFF66E} {51B191E6-C503-4949-8AD0-CF338FE13ADB} = {D7C6E667-E868-423C-883D-CBDE73BFF66E} - {986667FC-4DA5-4496-B998-7DEB9879B180} = {AA3208A1-2A91-46D3-B09C-1A9CCF90235E} + {25D78F42-920F-46BC-B644-B28EDB7FC15C} = {AA3208A1-2A91-46D3-B09C-1A9CCF90235E} {C4865002-095A-4B99-A737-216DC112ACA4} = {AA3208A1-2A91-46D3-B09C-1A9CCF90235E} {784D5C28-1B02-4DF5-A95F-5F453FD96828} = {E6ED6A93-5971-4E87-972C-23E80F6E0CFC} {BD042162-B4E2-45AC-8225-699F25478852} = {E6ED6A93-5971-4E87-972C-23E80F6E0CFC} diff --git a/src/libraries/System.Threading.Tasks.Parallel/System.Threading.Tasks.Parallel.sln b/src/libraries/System.Threading.Tasks.Parallel/System.Threading.Tasks.Parallel.sln index 6a408b66654..e92a83d826f 100644 --- a/src/libraries/System.Threading.Tasks.Parallel/System.Threading.Tasks.Parallel.sln +++ b/src/libraries/System.Threading.Tasks.Parallel/System.Threading.Tasks.Parallel.sln @@ -3,7 +3,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\ EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Collections.Concurrent", "..\System.Collections.Concurrent\ref\System.Collections.Concurrent.csproj", "{342A4A59-24F0-4345-8521-609138E368F4}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{135CC435-FD9E-4CE9-AFB9-593B105FBAFC}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{363CABB4-5350-46A0-B0B3-82B36F320E5D}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{D0267433-C793-4450-94A0-1750388CE9CB}" EndProject @@ -55,10 +55,10 @@ Global {342A4A59-24F0-4345-8521-609138E368F4}.Debug|Any CPU.Build.0 = Debug|Any CPU {342A4A59-24F0-4345-8521-609138E368F4}.Release|Any CPU.ActiveCfg = Release|Any CPU {342A4A59-24F0-4345-8521-609138E368F4}.Release|Any CPU.Build.0 = Release|Any CPU - {135CC435-FD9E-4CE9-AFB9-593B105FBAFC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {135CC435-FD9E-4CE9-AFB9-593B105FBAFC}.Debug|Any CPU.Build.0 = Debug|Any CPU - {135CC435-FD9E-4CE9-AFB9-593B105FBAFC}.Release|Any CPU.ActiveCfg = Release|Any CPU - {135CC435-FD9E-4CE9-AFB9-593B105FBAFC}.Release|Any CPU.Build.0 = Release|Any CPU + {363CABB4-5350-46A0-B0B3-82B36F320E5D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {363CABB4-5350-46A0-B0B3-82B36F320E5D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {363CABB4-5350-46A0-B0B3-82B36F320E5D}.Release|Any CPU.ActiveCfg = Release|Any CPU + {363CABB4-5350-46A0-B0B3-82B36F320E5D}.Release|Any CPU.Build.0 = Release|Any CPU {D0267433-C793-4450-94A0-1750388CE9CB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {D0267433-C793-4450-94A0-1750388CE9CB}.Debug|Any CPU.Build.0 = Debug|Any CPU {D0267433-C793-4450-94A0-1750388CE9CB}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -109,7 +109,7 @@ Global {342A4A59-24F0-4345-8521-609138E368F4} = {FBC5E558-FC17-4C58-B7F7-798E7CD58448} {EB54EB95-7F1A-4E81-90F1-7418CE3028D6} = {FBC5E558-FC17-4C58-B7F7-798E7CD58448} {C757F14B-E6F5-4B89-81A7-4D8D4F3A7F60} = {FBC5E558-FC17-4C58-B7F7-798E7CD58448} - {135CC435-FD9E-4CE9-AFB9-593B105FBAFC} = {6D758B5C-C40A-4179-898E-B459165BF692} + {363CABB4-5350-46A0-B0B3-82B36F320E5D} = {6D758B5C-C40A-4179-898E-B459165BF692} {D0267433-C793-4450-94A0-1750388CE9CB} = {6D758B5C-C40A-4179-898E-B459165BF692} {8F1FE81C-C15D-459A-8758-8B0853078EA7} = {A17071C3-99D6-40FF-947C-A15A9695FA91} {D6BE1B91-9769-41CE-BC37-DEA7B00DD2D6} = {8AD6A92E-4DF4-4C27-9A88-22AA03AEB40B} diff --git a/src/libraries/System.Threading.Tasks.Parallel/src/System/Threading/Tasks/Parallel.cs b/src/libraries/System.Threading.Tasks.Parallel/src/System/Threading/Tasks/Parallel.cs index 7a466d0501c..eadc4bc1ba6 100644 --- a/src/libraries/System.Threading.Tasks.Parallel/src/System/Threading/Tasks/Parallel.cs +++ b/src/libraries/System.Threading.Tasks.Parallel/src/System/Threading/Tasks/Parallel.cs @@ -240,7 +240,7 @@ public static void Invoke(ParallelOptions parallelOptions, params Action[] actio #if !FEATURE_WASM_MANAGED_THREADS // Web browsers need special treatment that is implemented in TaskReplicator - if (OperatingSystem.IsBrowser() || + if (OperatingSystem.IsBrowser() || OperatingSystem.IsWasi() || #else if ( #endif diff --git a/src/libraries/System.Threading.Tasks.Parallel/src/System/Threading/Tasks/TaskReplicator.cs b/src/libraries/System.Threading.Tasks.Parallel/src/System/Threading/Tasks/TaskReplicator.cs index 0239770284e..5090a6bd17d 100644 --- a/src/libraries/System.Threading.Tasks.Parallel/src/System/Threading/Tasks/TaskReplicator.cs +++ b/src/libraries/System.Threading.Tasks.Parallel/src/System/Threading/Tasks/TaskReplicator.cs @@ -132,7 +132,7 @@ public static void Run(ReplicatableUserAction action, ParallelOp // Browser hosts do not support synchronous Wait so we want to run the // replicated task directly instead of going through Task infrastructure #if !FEATURE_WASM_MANAGED_THREADS - if (OperatingSystem.IsBrowser()) + if (OperatingSystem.IsBrowser() || OperatingSystem.IsWasi() ) { // Since we are running on a single thread, we don't want the action to time out long timeout = long.MaxValue - 1; diff --git a/src/libraries/System.Threading.Thread/System.Threading.Thread.sln b/src/libraries/System.Threading.Thread/System.Threading.Thread.sln index cfa8dff0ee0..6bb2e822f2d 100644 --- a/src/libraries/System.Threading.Thread/System.Threading.Thread.sln +++ b/src/libraries/System.Threading.Thread/System.Threading.Thread.sln @@ -7,6 +7,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib.Gene EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\System.Private.CoreLib\ref\System.Private.CoreLib.csproj", "{2747DCC0-980A-4679-8D41-AC1DA06D2BD6}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{E4CF1818-08E9-4FFA-BB9F-4159C03A308F}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{B61C780A-7952-4981-842B-4771E7724F63}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{678A6F6C-BFF2-46BC-B512-745F32C229F6}" @@ -165,6 +167,27 @@ Global {2747DCC0-980A-4679-8D41-AC1DA06D2BD6}.Checked|arm64.ActiveCfg = Debug|Any CPU {2747DCC0-980A-4679-8D41-AC1DA06D2BD6}.Checked|x64.ActiveCfg = Debug|Any CPU {2747DCC0-980A-4679-8D41-AC1DA06D2BD6}.Checked|x86.ActiveCfg = Debug|Any CPU + {E4CF1818-08E9-4FFA-BB9F-4159C03A308F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E4CF1818-08E9-4FFA-BB9F-4159C03A308F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E4CF1818-08E9-4FFA-BB9F-4159C03A308F}.Debug|arm.ActiveCfg = Debug|Any CPU + {E4CF1818-08E9-4FFA-BB9F-4159C03A308F}.Debug|arm64.ActiveCfg = Debug|Any CPU + {E4CF1818-08E9-4FFA-BB9F-4159C03A308F}.Debug|x64.ActiveCfg = Debug|Any CPU + {E4CF1818-08E9-4FFA-BB9F-4159C03A308F}.Debug|x64.Build.0 = Debug|Any CPU + {E4CF1818-08E9-4FFA-BB9F-4159C03A308F}.Debug|x86.ActiveCfg = Debug|Any CPU + {E4CF1818-08E9-4FFA-BB9F-4159C03A308F}.Debug|x86.Build.0 = Debug|Any CPU + {E4CF1818-08E9-4FFA-BB9F-4159C03A308F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E4CF1818-08E9-4FFA-BB9F-4159C03A308F}.Release|Any CPU.Build.0 = Release|Any CPU + {E4CF1818-08E9-4FFA-BB9F-4159C03A308F}.Release|arm.ActiveCfg = Release|Any CPU + {E4CF1818-08E9-4FFA-BB9F-4159C03A308F}.Release|arm64.ActiveCfg = Release|Any CPU + {E4CF1818-08E9-4FFA-BB9F-4159C03A308F}.Release|x64.ActiveCfg = Release|Any CPU + {E4CF1818-08E9-4FFA-BB9F-4159C03A308F}.Release|x64.Build.0 = Release|Any CPU + {E4CF1818-08E9-4FFA-BB9F-4159C03A308F}.Release|x86.ActiveCfg = Release|Any CPU + {E4CF1818-08E9-4FFA-BB9F-4159C03A308F}.Release|x86.Build.0 = Release|Any CPU + {E4CF1818-08E9-4FFA-BB9F-4159C03A308F}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {E4CF1818-08E9-4FFA-BB9F-4159C03A308F}.Checked|arm.ActiveCfg = Debug|Any CPU + {E4CF1818-08E9-4FFA-BB9F-4159C03A308F}.Checked|arm64.ActiveCfg = Debug|Any CPU + {E4CF1818-08E9-4FFA-BB9F-4159C03A308F}.Checked|x64.ActiveCfg = Debug|Any CPU + {E4CF1818-08E9-4FFA-BB9F-4159C03A308F}.Checked|x86.ActiveCfg = Debug|Any CPU {B61C780A-7952-4981-842B-4771E7724F63}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {B61C780A-7952-4981-842B-4771E7724F63}.Debug|Any CPU.Build.0 = Debug|Any CPU {B61C780A-7952-4981-842B-4771E7724F63}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -493,6 +516,7 @@ Global {33684F81-6E4B-4E90-A3B5-7C1BC02FF573} = {73AA6FCA-8FDC-41AA-8539-91562296190B} {5093FB10-520B-45A1-942B-82AC0BC4FB3F} = {73AA6FCA-8FDC-41AA-8539-91562296190B} {566DB44F-5EF1-4421-B09A-F202E76935A9} = {5B2563E3-FF5B-4DAD-A3B0-5E99B5054508} + {E4CF1818-08E9-4FFA-BB9F-4159C03A308F} = {5B2563E3-FF5B-4DAD-A3B0-5E99B5054508} {B61C780A-7952-4981-842B-4771E7724F63} = {5B2563E3-FF5B-4DAD-A3B0-5E99B5054508} {678A6F6C-BFF2-46BC-B512-745F32C229F6} = {5B2563E3-FF5B-4DAD-A3B0-5E99B5054508} {2747DCC0-980A-4679-8D41-AC1DA06D2BD6} = {CC8272C5-AC82-4A51-B88C-018FF4284B25} diff --git a/src/libraries/System.Threading.ThreadPool/System.Threading.ThreadPool.sln b/src/libraries/System.Threading.ThreadPool/System.Threading.ThreadPool.sln index 4423169ee38..2f399779850 100644 --- a/src/libraries/System.Threading.ThreadPool/System.Threading.ThreadPool.sln +++ b/src/libraries/System.Threading.ThreadPool/System.Threading.ThreadPool.sln @@ -7,6 +7,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib.Gene EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\System.Private.CoreLib\ref\System.Private.CoreLib.csproj", "{3156246A-939D-4232-90B3-FDE03A14BA90}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{53291454-2AEB-4324-9F08-A734FFDB41A7}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{B5732A3E-15DB-4BAA-A44C-41A7C29C68F0}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{3A5BA59D-C1B6-492F-BF2C-FDE2C274E9B3}" @@ -161,6 +163,27 @@ Global {3156246A-939D-4232-90B3-FDE03A14BA90}.Checked|arm64.ActiveCfg = Debug|Any CPU {3156246A-939D-4232-90B3-FDE03A14BA90}.Checked|x64.ActiveCfg = Debug|Any CPU {3156246A-939D-4232-90B3-FDE03A14BA90}.Checked|x86.ActiveCfg = Debug|Any CPU + {53291454-2AEB-4324-9F08-A734FFDB41A7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {53291454-2AEB-4324-9F08-A734FFDB41A7}.Debug|Any CPU.Build.0 = Debug|Any CPU + {53291454-2AEB-4324-9F08-A734FFDB41A7}.Debug|arm.ActiveCfg = Debug|Any CPU + {53291454-2AEB-4324-9F08-A734FFDB41A7}.Debug|arm64.ActiveCfg = Debug|Any CPU + {53291454-2AEB-4324-9F08-A734FFDB41A7}.Debug|x64.ActiveCfg = Debug|Any CPU + {53291454-2AEB-4324-9F08-A734FFDB41A7}.Debug|x64.Build.0 = Debug|Any CPU + {53291454-2AEB-4324-9F08-A734FFDB41A7}.Debug|x86.ActiveCfg = Debug|Any CPU + {53291454-2AEB-4324-9F08-A734FFDB41A7}.Debug|x86.Build.0 = Debug|Any CPU + {53291454-2AEB-4324-9F08-A734FFDB41A7}.Release|Any CPU.ActiveCfg = Release|Any CPU + {53291454-2AEB-4324-9F08-A734FFDB41A7}.Release|Any CPU.Build.0 = Release|Any CPU + {53291454-2AEB-4324-9F08-A734FFDB41A7}.Release|arm.ActiveCfg = Release|Any CPU + {53291454-2AEB-4324-9F08-A734FFDB41A7}.Release|arm64.ActiveCfg = Release|Any CPU + {53291454-2AEB-4324-9F08-A734FFDB41A7}.Release|x64.ActiveCfg = Release|Any CPU + {53291454-2AEB-4324-9F08-A734FFDB41A7}.Release|x64.Build.0 = Release|Any CPU + {53291454-2AEB-4324-9F08-A734FFDB41A7}.Release|x86.ActiveCfg = Release|Any CPU + {53291454-2AEB-4324-9F08-A734FFDB41A7}.Release|x86.Build.0 = Release|Any CPU + {53291454-2AEB-4324-9F08-A734FFDB41A7}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {53291454-2AEB-4324-9F08-A734FFDB41A7}.Checked|arm.ActiveCfg = Debug|Any CPU + {53291454-2AEB-4324-9F08-A734FFDB41A7}.Checked|arm64.ActiveCfg = Debug|Any CPU + {53291454-2AEB-4324-9F08-A734FFDB41A7}.Checked|x64.ActiveCfg = Debug|Any CPU + {53291454-2AEB-4324-9F08-A734FFDB41A7}.Checked|x86.ActiveCfg = Debug|Any CPU {B5732A3E-15DB-4BAA-A44C-41A7C29C68F0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {B5732A3E-15DB-4BAA-A44C-41A7C29C68F0}.Debug|Any CPU.Build.0 = Debug|Any CPU {B5732A3E-15DB-4BAA-A44C-41A7C29C68F0}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -445,6 +468,7 @@ Global {71ACA28C-A4F1-4A07-A1B3-39DB86C11A75} = {DB513386-C3B1-4891-92E1-1BE5D38562DC} {2EBEBCB5-9AC0-49E7-BCE3-C8A73E068CAE} = {DB513386-C3B1-4891-92E1-1BE5D38562DC} {54E0AB0F-EB35-49AB-9A38-7C09FD7EC373} = {1445280F-1F07-45C3-93BC-D4025720B5FE} + {53291454-2AEB-4324-9F08-A734FFDB41A7} = {1445280F-1F07-45C3-93BC-D4025720B5FE} {B5732A3E-15DB-4BAA-A44C-41A7C29C68F0} = {1445280F-1F07-45C3-93BC-D4025720B5FE} {3A5BA59D-C1B6-492F-BF2C-FDE2C274E9B3} = {1445280F-1F07-45C3-93BC-D4025720B5FE} {3156246A-939D-4232-90B3-FDE03A14BA90} = {6A32653B-8FAC-4B01-A0E0-E6379DE90A1A} diff --git a/src/libraries/System.Threading.ThreadPool/tests/ThreadPoolTests.cs b/src/libraries/System.Threading.ThreadPool/tests/ThreadPoolTests.cs index 45133de212a..a26b000055a 100644 --- a/src/libraries/System.Threading.ThreadPool/tests/ThreadPoolTests.cs +++ b/src/libraries/System.Threading.ThreadPool/tests/ThreadPoolTests.cs @@ -1342,6 +1342,7 @@ from x in Enumerable.Range(0, 9) [ConditionalTheory(nameof(IsThreadingAndRemoteExecutorSupported), nameof(UsePortableThreadPool))] [MemberData(nameof(IOCompletionPortCountConfigVarTest_Args))] [PlatformSpecific(TestPlatforms.Windows)] + [ActiveIssue("https://github.com/dotnet/runtime/issues/106371")] public static void IOCompletionPortCountConfigVarTest(int ioCompletionPortCount) { // Avoid contaminating the main process' environment @@ -1394,28 +1395,30 @@ static async Task RunAsyncIOTest() var done = new AutoResetEvent(false); // Receiver + bool stop = false; + var receiveBuffer = new byte[1]; + var listener = new TcpListener(IPAddress.Loopback, 0); + listener.Start(); var t = ThreadTestHelpers.CreateGuardedThread( out Action checkForThreadErrors, out Action waitForThread, async () => { - using var listener = new TcpListener(IPAddress.Loopback, 55555); - var receiveBuffer = new byte[1]; - listener.Start(); - done.Set(); // indicate listener started - while (true) + using (listener) { - // Accept a connection, receive a byte - using var socket = await listener.AcceptSocketAsync(); - int bytesRead = - await socket.ReceiveAsync(new ArraySegment(receiveBuffer), SocketFlags.None); - Assert.Equal(1, bytesRead); - done.Set(); // indicate byte received + while (!stop) + { + // Accept a connection, receive a byte + using var socket = await listener.AcceptSocketAsync(); + int bytesRead = + await socket.ReceiveAsync(new ArraySegment(receiveBuffer), SocketFlags.None); + Assert.Equal(1, bytesRead); + done.Set(); // indicate byte received + } } }); t.IsBackground = true; t.Start(); - done.CheckedWait(); // wait for listener to start // Sender var sendBuffer = new byte[1]; @@ -1423,17 +1426,47 @@ static async Task RunAsyncIOTest() { // Connect, send a byte using var client = new TcpClient(); - await client.ConnectAsync(IPAddress.Loopback, 55555); + await client.ConnectAsync((IPEndPoint)listener.LocalEndpoint); int bytesSent = await client.Client.SendAsync(new ArraySegment(sendBuffer), SocketFlags.None); Assert.Equal(1, bytesSent); done.CheckedWait(); // wait for byte to the received } + + stop = true; + waitForThread(); } }).Dispose(); }, ioCompletionPortCount.ToString()).Dispose(); } + + [ConditionalFact(nameof(IsThreadingAndRemoteExecutorSupported))] + [PlatformSpecific(TestPlatforms.Windows)] + public static unsafe void ThreadPoolCompletedWorkItemCountTest() + { + // Run in a separate process to test in a clean thread pool environment such that we don't count external work items + RemoteExecutor.Invoke(() => + { + using var manualResetEvent = new ManualResetEventSlim(false); + + var overlapped = new Overlapped(); + NativeOverlapped* nativeOverlapped = overlapped.Pack((errorCode, numBytes, innerNativeOverlapped) => + { + Overlapped.Free(innerNativeOverlapped); + manualResetEvent.Set(); + }, null); + + ThreadPool.UnsafeQueueNativeOverlapped(nativeOverlapped); + manualResetEvent.Wait(); + + // Allow work item(s) to be marked as completed during this time, should be only one + ThreadTestHelpers.WaitForCondition(() => ThreadPool.CompletedWorkItemCount == 1); + Thread.Sleep(50); + Assert.Equal(1, ThreadPool.CompletedWorkItemCount); + }).Dispose(); + } + public static bool IsThreadingAndRemoteExecutorSupported => PlatformDetection.IsThreadingSupported && RemoteExecutor.IsSupported; diff --git a/src/libraries/System.Threading/System.Threading.sln b/src/libraries/System.Threading/System.Threading.sln index bb83a6dabf9..41f7c89880e 100644 --- a/src/libraries/System.Threading/System.Threading.sln +++ b/src/libraries/System.Threading/System.Threading.sln @@ -7,6 +7,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib.Gene EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", "..\System.Private.CoreLib\ref\System.Private.CoreLib.csproj", "{7B40C562-C082-451C-8281-5088EBFE0079}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{AD25D1A1-B410-4B95-833C-658D1ED0CB25}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{80B607B4-4860-4E0E-B9A1-2AD24A9C72DE}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{155B2ACA-D7B6-472E-90F9-5F68E62F7432}" @@ -157,6 +159,27 @@ Global {7B40C562-C082-451C-8281-5088EBFE0079}.Checked|arm64.ActiveCfg = Debug|Any CPU {7B40C562-C082-451C-8281-5088EBFE0079}.Checked|x64.ActiveCfg = Debug|Any CPU {7B40C562-C082-451C-8281-5088EBFE0079}.Checked|x86.ActiveCfg = Debug|Any CPU + {AD25D1A1-B410-4B95-833C-658D1ED0CB25}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {AD25D1A1-B410-4B95-833C-658D1ED0CB25}.Debug|Any CPU.Build.0 = Debug|Any CPU + {AD25D1A1-B410-4B95-833C-658D1ED0CB25}.Debug|arm.ActiveCfg = Debug|Any CPU + {AD25D1A1-B410-4B95-833C-658D1ED0CB25}.Debug|arm64.ActiveCfg = Debug|Any CPU + {AD25D1A1-B410-4B95-833C-658D1ED0CB25}.Debug|x64.ActiveCfg = Debug|Any CPU + {AD25D1A1-B410-4B95-833C-658D1ED0CB25}.Debug|x64.Build.0 = Debug|Any CPU + {AD25D1A1-B410-4B95-833C-658D1ED0CB25}.Debug|x86.ActiveCfg = Debug|Any CPU + {AD25D1A1-B410-4B95-833C-658D1ED0CB25}.Debug|x86.Build.0 = Debug|Any CPU + {AD25D1A1-B410-4B95-833C-658D1ED0CB25}.Release|Any CPU.ActiveCfg = Release|Any CPU + {AD25D1A1-B410-4B95-833C-658D1ED0CB25}.Release|Any CPU.Build.0 = Release|Any CPU + {AD25D1A1-B410-4B95-833C-658D1ED0CB25}.Release|arm.ActiveCfg = Release|Any CPU + {AD25D1A1-B410-4B95-833C-658D1ED0CB25}.Release|arm64.ActiveCfg = Release|Any CPU + {AD25D1A1-B410-4B95-833C-658D1ED0CB25}.Release|x64.ActiveCfg = Release|Any CPU + {AD25D1A1-B410-4B95-833C-658D1ED0CB25}.Release|x64.Build.0 = Release|Any CPU + {AD25D1A1-B410-4B95-833C-658D1ED0CB25}.Release|x86.ActiveCfg = Release|Any CPU + {AD25D1A1-B410-4B95-833C-658D1ED0CB25}.Release|x86.Build.0 = Release|Any CPU + {AD25D1A1-B410-4B95-833C-658D1ED0CB25}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {AD25D1A1-B410-4B95-833C-658D1ED0CB25}.Checked|arm.ActiveCfg = Debug|Any CPU + {AD25D1A1-B410-4B95-833C-658D1ED0CB25}.Checked|arm64.ActiveCfg = Debug|Any CPU + {AD25D1A1-B410-4B95-833C-658D1ED0CB25}.Checked|x64.ActiveCfg = Debug|Any CPU + {AD25D1A1-B410-4B95-833C-658D1ED0CB25}.Checked|x86.ActiveCfg = Debug|Any CPU {80B607B4-4860-4E0E-B9A1-2AD24A9C72DE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {80B607B4-4860-4E0E-B9A1-2AD24A9C72DE}.Debug|Any CPU.Build.0 = Debug|Any CPU {80B607B4-4860-4E0E-B9A1-2AD24A9C72DE}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -398,6 +421,7 @@ Global {387778C0-0405-4FE2-9D85-034254EAAD46} = {CCC80DF2-8B4E-497C-84A9-4E6344294566} {3DD929D8-346F-4CF3-B157-22E052F73A91} = {CCC80DF2-8B4E-497C-84A9-4E6344294566} {AB7F1F45-5C20-40C7-B6DA-192B37012DD8} = {A928B9C7-28EC-4D20-9A63-87221C52EC87} + {AD25D1A1-B410-4B95-833C-658D1ED0CB25} = {A928B9C7-28EC-4D20-9A63-87221C52EC87} {80B607B4-4860-4E0E-B9A1-2AD24A9C72DE} = {A928B9C7-28EC-4D20-9A63-87221C52EC87} {155B2ACA-D7B6-472E-90F9-5F68E62F7432} = {A928B9C7-28EC-4D20-9A63-87221C52EC87} {7B40C562-C082-451C-8281-5088EBFE0079} = {BEFD8C2C-3355-40A5-8C06-3CE0BFB66C36} diff --git a/src/libraries/System.Transactions.Local/System.Transactions.Local.sln b/src/libraries/System.Transactions.Local/System.Transactions.Local.sln index 6d5009f11ee..58eb24bb5b4 100644 --- a/src/libraries/System.Transactions.Local/System.Transactions.Local.sln +++ b/src/libraries/System.Transactions.Local/System.Transactions.Local.sln @@ -1,10 +1,16 @@ -Microsoft Visual Studio Solution File, Format Version 12.00 + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.12.35218.33 +MinimumVisualStudioVersion = 10.0.40219.1 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestUtilities", "..\Common\tests\TestUtilities\TestUtilities.csproj", "{B67D04B7-C5ED-44ED-8DB3-8AD788232A5C}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Collections", "..\System.Collections\ref\System.Collections.csproj", "{6D254833-6EC5-4E3E-96CE-1D97CD66B35F}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{75D2D615-58E5-41BB-9C57-FFC2F01B4931}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{693EEDDE-2643-4F1D-B531-1AB4D733B7F4}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{2A01A433-50B7-4CFA-AA76-CB51971535BB}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{193FBAA0-BAE2-484A-BB0E-1ADDDC810FC9}" @@ -37,11 +43,11 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "gen", "gen", "{2ECC9D1A-2EF EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{9D6D84CE-3891-482B-B7C0-0089CF93CF45}" EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "gen", "tools\gen", "{19FA1AAF-FBDF-4CF9-A432-8A98400E8598}" +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "gen", "gen", "{19FA1AAF-FBDF-4CF9-A432-8A98400E8598}" EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "tools\src", "{29620C15-7580-40A6-A591-73A49C572FA2}" +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{29620C15-7580-40A6-A591-73A49C572FA2}" EndProject -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ref", "tools\ref", "{C394810F-6A50-48E6-BCAB-91C55AEB92AA}" +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ref", "ref", "{C394810F-6A50-48E6-BCAB-91C55AEB92AA}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tools", "tools", "{770FE0B0-1496-4DBA-9E91-FAA63BE58272}" EndProject @@ -63,6 +69,10 @@ Global {75D2D615-58E5-41BB-9C57-FFC2F01B4931}.Debug|Any CPU.Build.0 = Debug|Any CPU {75D2D615-58E5-41BB-9C57-FFC2F01B4931}.Release|Any CPU.ActiveCfg = Release|Any CPU {75D2D615-58E5-41BB-9C57-FFC2F01B4931}.Release|Any CPU.Build.0 = Release|Any CPU + {693EEDDE-2643-4F1D-B531-1AB4D733B7F4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {693EEDDE-2643-4F1D-B531-1AB4D733B7F4}.Debug|Any CPU.Build.0 = Debug|Any CPU + {693EEDDE-2643-4F1D-B531-1AB4D733B7F4}.Release|Any CPU.ActiveCfg = Release|Any CPU + {693EEDDE-2643-4F1D-B531-1AB4D733B7F4}.Release|Any CPU.Build.0 = Release|Any CPU {2A01A433-50B7-4CFA-AA76-CB51971535BB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {2A01A433-50B7-4CFA-AA76-CB51971535BB}.Debug|Any CPU.Build.0 = Debug|Any CPU {2A01A433-50B7-4CFA-AA76-CB51971535BB}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -117,25 +127,30 @@ Global EndGlobalSection GlobalSection(NestedProjects) = preSolution {B67D04B7-C5ED-44ED-8DB3-8AD788232A5C} = {E66BBFB5-F07D-4986-89C0-F0E395DD5BA1} - {C5519C4C-69AF-4437-8594-D2A019119988} = {E66BBFB5-F07D-4986-89C0-F0E395DD5BA1} {6D254833-6EC5-4E3E-96CE-1D97CD66B35F} = {B4E1F144-E017-4E02-8320-DB7467E42BF8} - {8D9731A5-CB30-4AAA-9A3B-9C937352623F} = {B4E1F144-E017-4E02-8320-DB7467E42BF8} - {7CC8FC26-F825-4B5D-9E38-6CE8382BEEAC} = {B4E1F144-E017-4E02-8320-DB7467E42BF8} - {0C886713-72D7-43C7-A1BB-72CD0F8430D2} = {B4E1F144-E017-4E02-8320-DB7467E42BF8} {75D2D615-58E5-41BB-9C57-FFC2F01B4931} = {2ECC9D1A-2EF1-4411-98D1-AFFCDAAF9D05} + {693EEDDE-2643-4F1D-B531-1AB4D733B7F4} = {2ECC9D1A-2EF1-4411-98D1-AFFCDAAF9D05} {2A01A433-50B7-4CFA-AA76-CB51971535BB} = {2ECC9D1A-2EF1-4411-98D1-AFFCDAAF9D05} {193FBAA0-BAE2-484A-BB0E-1ADDDC810FC9} = {2ECC9D1A-2EF1-4411-98D1-AFFCDAAF9D05} + {8D9731A5-CB30-4AAA-9A3B-9C937352623F} = {B4E1F144-E017-4E02-8320-DB7467E42BF8} + {7CC8FC26-F825-4B5D-9E38-6CE8382BEEAC} = {B4E1F144-E017-4E02-8320-DB7467E42BF8} + {0C886713-72D7-43C7-A1BB-72CD0F8430D2} = {B4E1F144-E017-4E02-8320-DB7467E42BF8} {6BFF19CB-C412-4D12-AA55-68D61F69C4F7} = {9D6D84CE-3891-482B-B7C0-0089CF93CF45} + {C5519C4C-69AF-4437-8594-D2A019119988} = {E66BBFB5-F07D-4986-89C0-F0E395DD5BA1} {EB7DBBB8-0923-48C1-AB88-F3FF987C2449} = {19FA1AAF-FBDF-4CF9-A432-8A98400E8598} {14F12A3F-AA5E-4F20-B8E6-DFCCEE1FBB71} = {19FA1AAF-FBDF-4CF9-A432-8A98400E8598} - {19FA1AAF-FBDF-4CF9-A432-8A98400E8598} = {770FE0B0-1496-4DBA-9E91-FAA63BE58272} {2B4AEC4E-E5B8-402D-B938-65C8D8ED0248} = {29620C15-7580-40A6-A591-73A49C572FA2} {5345D79E-E437-431E-BB9C-65AC54626DC0} = {29620C15-7580-40A6-A591-73A49C572FA2} - {29620C15-7580-40A6-A591-73A49C572FA2} = {770FE0B0-1496-4DBA-9E91-FAA63BE58272} {95F76D76-11E8-4551-8786-D304D698C91B} = {C394810F-6A50-48E6-BCAB-91C55AEB92AA} + {19FA1AAF-FBDF-4CF9-A432-8A98400E8598} = {770FE0B0-1496-4DBA-9E91-FAA63BE58272} + {29620C15-7580-40A6-A591-73A49C572FA2} = {770FE0B0-1496-4DBA-9E91-FAA63BE58272} {C394810F-6A50-48E6-BCAB-91C55AEB92AA} = {770FE0B0-1496-4DBA-9E91-FAA63BE58272} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {197B13C9-4EA6-408B-8EF6-B551B2A58A89} EndGlobalSection + GlobalSection(SharedMSBuildProjectFiles) = preSolution + ..\..\tools\illink\src\ILLink.Shared\ILLink.Shared.projitems*{14f12a3f-aa5e-4f20-b8e6-dfccee1fbb71}*SharedItemsImports = 5 + ..\..\tools\illink\src\ILLink.Shared\ILLink.Shared.projitems*{5345d79e-e437-431e-bb9c-65ac54626dc0}*SharedItemsImports = 5 + EndGlobalSection EndGlobal diff --git a/src/libraries/System.Web.HttpUtility/System.Web.HttpUtility.sln b/src/libraries/System.Web.HttpUtility/System.Web.HttpUtility.sln index 1b4d405697c..3a5c88d66e1 100644 --- a/src/libraries/System.Web.HttpUtility/System.Web.HttpUtility.sln +++ b/src/libraries/System.Web.HttpUtility/System.Web.HttpUtility.sln @@ -13,7 +13,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ComponentModel", ".. EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.ObjectModel", "..\System.ObjectModel\ref\System.ObjectModel.csproj", "{21743261-4502-4A73-8309-8479835D8131}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{58FC2C69-816F-44D4-AE44-72F8864DFAE1}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{9959C317-214C-4347-93B0-2226899CE205}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{02855E32-AB9B-4893-A9E3-50620FCA1287}" EndProject @@ -85,10 +85,10 @@ Global {21743261-4502-4A73-8309-8479835D8131}.Debug|Any CPU.Build.0 = Debug|Any CPU {21743261-4502-4A73-8309-8479835D8131}.Release|Any CPU.ActiveCfg = Release|Any CPU {21743261-4502-4A73-8309-8479835D8131}.Release|Any CPU.Build.0 = Release|Any CPU - {58FC2C69-816F-44D4-AE44-72F8864DFAE1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {58FC2C69-816F-44D4-AE44-72F8864DFAE1}.Debug|Any CPU.Build.0 = Debug|Any CPU - {58FC2C69-816F-44D4-AE44-72F8864DFAE1}.Release|Any CPU.ActiveCfg = Release|Any CPU - {58FC2C69-816F-44D4-AE44-72F8864DFAE1}.Release|Any CPU.Build.0 = Release|Any CPU + {9959C317-214C-4347-93B0-2226899CE205}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {9959C317-214C-4347-93B0-2226899CE205}.Debug|Any CPU.Build.0 = Debug|Any CPU + {9959C317-214C-4347-93B0-2226899CE205}.Release|Any CPU.ActiveCfg = Release|Any CPU + {9959C317-214C-4347-93B0-2226899CE205}.Release|Any CPU.Build.0 = Release|Any CPU {02855E32-AB9B-4893-A9E3-50620FCA1287}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {02855E32-AB9B-4893-A9E3-50620FCA1287}.Debug|Any CPU.Build.0 = Debug|Any CPU {02855E32-AB9B-4893-A9E3-50620FCA1287}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -144,7 +144,7 @@ Global {21743261-4502-4A73-8309-8479835D8131} = {E29510E3-01F1-4F13-885C-95690B2D2FDC} {FCBE07CD-A49C-4648-863F-62787C1F725D} = {E29510E3-01F1-4F13-885C-95690B2D2FDC} {063B8BE1-1713-40FE-BD22-A258FD50108E} = {E29510E3-01F1-4F13-885C-95690B2D2FDC} - {58FC2C69-816F-44D4-AE44-72F8864DFAE1} = {DB94D23F-DB79-455A-9C55-37403C9BE9F6} + {9959C317-214C-4347-93B0-2226899CE205} = {DB94D23F-DB79-455A-9C55-37403C9BE9F6} {02855E32-AB9B-4893-A9E3-50620FCA1287} = {DB94D23F-DB79-455A-9C55-37403C9BE9F6} {C294097C-8171-4FA2-9C58-11A7FE3BEBDA} = {36DE8D3F-5AAF-4464-A544-AF32A37307F5} {56B60109-B617-4465-9043-F4B238E04CF9} = {8BEACA54-0AFF-4D6A-9151-1BA656DF810D} diff --git a/src/libraries/System.Windows.Extensions/System.Windows.Extensions.sln b/src/libraries/System.Windows.Extensions/System.Windows.Extensions.sln index 05ce876384a..b86f3026316 100644 --- a/src/libraries/System.Windows.Extensions/System.Windows.Extensions.sln +++ b/src/libraries/System.Windows.Extensions/System.Windows.Extensions.sln @@ -11,6 +11,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.CoreLib", ". EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.Uri", "..\System.Private.Uri\src\System.Private.Uri.csproj", "{79A37A2A-E133-486E-9DB5-5FA5147184E1}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{F299891A-0C54-4E23-9697-BD298DACBD1D}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{BF9DE7F9-08A1-4482-8F81-2895BB99D651}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{B5485369-6E0E-4F8E-AF41-FA9583C7B1CA}" @@ -205,6 +207,27 @@ Global {79A37A2A-E133-486E-9DB5-5FA5147184E1}.Checked|arm64.ActiveCfg = Debug|Any CPU {79A37A2A-E133-486E-9DB5-5FA5147184E1}.Checked|x64.ActiveCfg = Debug|Any CPU {79A37A2A-E133-486E-9DB5-5FA5147184E1}.Checked|x86.ActiveCfg = Debug|Any CPU + {F299891A-0C54-4E23-9697-BD298DACBD1D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F299891A-0C54-4E23-9697-BD298DACBD1D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F299891A-0C54-4E23-9697-BD298DACBD1D}.Debug|arm.ActiveCfg = Debug|Any CPU + {F299891A-0C54-4E23-9697-BD298DACBD1D}.Debug|arm64.ActiveCfg = Debug|Any CPU + {F299891A-0C54-4E23-9697-BD298DACBD1D}.Debug|x64.ActiveCfg = Debug|Any CPU + {F299891A-0C54-4E23-9697-BD298DACBD1D}.Debug|x64.Build.0 = Debug|Any CPU + {F299891A-0C54-4E23-9697-BD298DACBD1D}.Debug|x86.ActiveCfg = Debug|Any CPU + {F299891A-0C54-4E23-9697-BD298DACBD1D}.Debug|x86.Build.0 = Debug|Any CPU + {F299891A-0C54-4E23-9697-BD298DACBD1D}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F299891A-0C54-4E23-9697-BD298DACBD1D}.Release|Any CPU.Build.0 = Release|Any CPU + {F299891A-0C54-4E23-9697-BD298DACBD1D}.Release|arm.ActiveCfg = Release|Any CPU + {F299891A-0C54-4E23-9697-BD298DACBD1D}.Release|arm64.ActiveCfg = Release|Any CPU + {F299891A-0C54-4E23-9697-BD298DACBD1D}.Release|x64.ActiveCfg = Release|Any CPU + {F299891A-0C54-4E23-9697-BD298DACBD1D}.Release|x64.Build.0 = Release|Any CPU + {F299891A-0C54-4E23-9697-BD298DACBD1D}.Release|x86.ActiveCfg = Release|Any CPU + {F299891A-0C54-4E23-9697-BD298DACBD1D}.Release|x86.Build.0 = Release|Any CPU + {F299891A-0C54-4E23-9697-BD298DACBD1D}.Checked|Any CPU.ActiveCfg = Debug|Any CPU + {F299891A-0C54-4E23-9697-BD298DACBD1D}.Checked|arm.ActiveCfg = Debug|Any CPU + {F299891A-0C54-4E23-9697-BD298DACBD1D}.Checked|arm64.ActiveCfg = Debug|Any CPU + {F299891A-0C54-4E23-9697-BD298DACBD1D}.Checked|x64.ActiveCfg = Debug|Any CPU + {F299891A-0C54-4E23-9697-BD298DACBD1D}.Checked|x86.ActiveCfg = Debug|Any CPU {BF9DE7F9-08A1-4482-8F81-2895BB99D651}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {BF9DE7F9-08A1-4482-8F81-2895BB99D651}.Debug|Any CPU.Build.0 = Debug|Any CPU {BF9DE7F9-08A1-4482-8F81-2895BB99D651}.Debug|arm.ActiveCfg = Debug|Any CPU @@ -470,6 +493,7 @@ Global {E51D8981-999E-4516-82BF-5766CE531E53} = {2B702044-D081-480E-877C-6CD7A7BDC726} {5CE6447B-ECCE-461C-918D-A37A7ACDF2AC} = {2B702044-D081-480E-877C-6CD7A7BDC726} {8DF21599-94FF-4B57-8179-67DA3D54D005} = {45BD3F1C-C44C-484B-8759-41BFCA7CEFF8} + {F299891A-0C54-4E23-9697-BD298DACBD1D} = {45BD3F1C-C44C-484B-8759-41BFCA7CEFF8} {BF9DE7F9-08A1-4482-8F81-2895BB99D651} = {45BD3F1C-C44C-484B-8759-41BFCA7CEFF8} {B5485369-6E0E-4F8E-AF41-FA9583C7B1CA} = {45BD3F1C-C44C-484B-8759-41BFCA7CEFF8} {4A8C8CCE-02F6-47E1-A26C-C07778AE8502} = {C881B8F0-59DE-411B-AA11-2729C3273BE2} diff --git a/src/libraries/System.Xml.ReaderWriter/System.Xml.ReaderWriter.sln b/src/libraries/System.Xml.ReaderWriter/System.Xml.ReaderWriter.sln index 496c675186d..ea8b6c3098e 100644 --- a/src/libraries/System.Xml.ReaderWriter/System.Xml.ReaderWriter.sln +++ b/src/libraries/System.Xml.ReaderWriter/System.Xml.ReaderWriter.sln @@ -11,6 +11,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.Xml", "..\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{CABB008A-3639-458F-A209-45780C1E468F}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{81A67589-164F-401F-96E5-4F9969BD5EFC}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{CA8BC7D5-9A5D-4055-BE69-6D469B38ED02}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{640CCB13-BBC5-4B1A-90ED-87DA28BCA4AC}" @@ -79,6 +81,10 @@ Global {CABB008A-3639-458F-A209-45780C1E468F}.Debug|Any CPU.Build.0 = Debug|Any CPU {CABB008A-3639-458F-A209-45780C1E468F}.Release|Any CPU.ActiveCfg = Release|Any CPU {CABB008A-3639-458F-A209-45780C1E468F}.Release|Any CPU.Build.0 = Release|Any CPU + {81A67589-164F-401F-96E5-4F9969BD5EFC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {81A67589-164F-401F-96E5-4F9969BD5EFC}.Debug|Any CPU.Build.0 = Debug|Any CPU + {81A67589-164F-401F-96E5-4F9969BD5EFC}.Release|Any CPU.ActiveCfg = Release|Any CPU + {81A67589-164F-401F-96E5-4F9969BD5EFC}.Release|Any CPU.Build.0 = Release|Any CPU {CA8BC7D5-9A5D-4055-BE69-6D469B38ED02}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {CA8BC7D5-9A5D-4055-BE69-6D469B38ED02}.Debug|Any CPU.Build.0 = Debug|Any CPU {CA8BC7D5-9A5D-4055-BE69-6D469B38ED02}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -142,6 +148,7 @@ Global {4886A8C5-3546-459A-8800-ED0DA91C6B15} = {311C66CC-47AC-4965-B704-3C62E57FE29D} {FA7C251C-D1FD-45C3-8CC8-D094F70A03AA} = {311C66CC-47AC-4965-B704-3C62E57FE29D} {CABB008A-3639-458F-A209-45780C1E468F} = {DD1FA45A-B14C-49B5-87C8-1760B478FE91} + {81A67589-164F-401F-96E5-4F9969BD5EFC} = {DD1FA45A-B14C-49B5-87C8-1760B478FE91} {CA8BC7D5-9A5D-4055-BE69-6D469B38ED02} = {DD1FA45A-B14C-49B5-87C8-1760B478FE91} {640CCB13-BBC5-4B1A-90ED-87DA28BCA4AC} = {DD1FA45A-B14C-49B5-87C8-1760B478FE91} {3CCCB1F8-16A0-46BE-93D9-E11E22294CC1} = {DD1FA45A-B14C-49B5-87C8-1760B478FE91} diff --git a/src/libraries/System.Xml.XDocument/System.Xml.XDocument.sln b/src/libraries/System.Xml.XDocument/System.Xml.XDocument.sln index 72a29ca91e1..539059d467e 100644 --- a/src/libraries/System.Xml.XDocument/System.Xml.XDocument.sln +++ b/src/libraries/System.Xml.XDocument/System.Xml.XDocument.sln @@ -15,6 +15,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.Xml", "..\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{C4510F7C-4396-43E5-BCD4-5799AE2D56C7}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{F24FBE9B-B3A3-4757-ACD1-55EA5DFD5EF8}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{1168A1A4-299C-4FE3-B0EC-A4F87ACE19B1}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{AC583FDE-8E90-4EDC-A35E-1E39704E465D}" @@ -93,6 +95,10 @@ Global {C4510F7C-4396-43E5-BCD4-5799AE2D56C7}.Debug|Any CPU.Build.0 = Debug|Any CPU {C4510F7C-4396-43E5-BCD4-5799AE2D56C7}.Release|Any CPU.ActiveCfg = Release|Any CPU {C4510F7C-4396-43E5-BCD4-5799AE2D56C7}.Release|Any CPU.Build.0 = Release|Any CPU + {F24FBE9B-B3A3-4757-ACD1-55EA5DFD5EF8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F24FBE9B-B3A3-4757-ACD1-55EA5DFD5EF8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F24FBE9B-B3A3-4757-ACD1-55EA5DFD5EF8}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F24FBE9B-B3A3-4757-ACD1-55EA5DFD5EF8}.Release|Any CPU.Build.0 = Release|Any CPU {1168A1A4-299C-4FE3-B0EC-A4F87ACE19B1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {1168A1A4-299C-4FE3-B0EC-A4F87ACE19B1}.Debug|Any CPU.Build.0 = Debug|Any CPU {1168A1A4-299C-4FE3-B0EC-A4F87ACE19B1}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -163,6 +169,7 @@ Global {CE19D781-5542-4024-9829-FE589BA93146} = {AFC9144B-DAD7-470E-B068-C17C24862D23} {B229C42C-204A-43B4-AB71-587AD46F927E} = {AFC9144B-DAD7-470E-B068-C17C24862D23} {C4510F7C-4396-43E5-BCD4-5799AE2D56C7} = {74D73470-4D01-4B7F-A809-D406E7474807} + {F24FBE9B-B3A3-4757-ACD1-55EA5DFD5EF8} = {74D73470-4D01-4B7F-A809-D406E7474807} {1168A1A4-299C-4FE3-B0EC-A4F87ACE19B1} = {74D73470-4D01-4B7F-A809-D406E7474807} {AC583FDE-8E90-4EDC-A35E-1E39704E465D} = {74D73470-4D01-4B7F-A809-D406E7474807} {783012DB-85AC-4C81-8310-98FD187A1C53} = {74D73470-4D01-4B7F-A809-D406E7474807} diff --git a/src/libraries/System.Xml.XPath.XDocument/System.Xml.XPath.XDocument.sln b/src/libraries/System.Xml.XPath.XDocument/System.Xml.XPath.XDocument.sln index f16b20abc76..f4f035702fb 100644 --- a/src/libraries/System.Xml.XPath.XDocument/System.Xml.XPath.XDocument.sln +++ b/src/libraries/System.Xml.XPath.XDocument/System.Xml.XPath.XDocument.sln @@ -15,6 +15,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.Xml", "..\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{1E4880D4-D17F-4E0B-9F42-F9D9E5F5B50D}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{C5441F84-4126-4C81-95E5-3DE9E36F904F}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{48DB9946-6D0B-49E4-AB52-59C6CDE636A2}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{0E9E4E11-BBF5-42B0-AAAF-2C5C2197A4B6}" @@ -95,6 +97,10 @@ Global {1E4880D4-D17F-4E0B-9F42-F9D9E5F5B50D}.Debug|Any CPU.Build.0 = Debug|Any CPU {1E4880D4-D17F-4E0B-9F42-F9D9E5F5B50D}.Release|Any CPU.ActiveCfg = Release|Any CPU {1E4880D4-D17F-4E0B-9F42-F9D9E5F5B50D}.Release|Any CPU.Build.0 = Release|Any CPU + {C5441F84-4126-4C81-95E5-3DE9E36F904F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {C5441F84-4126-4C81-95E5-3DE9E36F904F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C5441F84-4126-4C81-95E5-3DE9E36F904F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {C5441F84-4126-4C81-95E5-3DE9E36F904F}.Release|Any CPU.Build.0 = Release|Any CPU {48DB9946-6D0B-49E4-AB52-59C6CDE636A2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {48DB9946-6D0B-49E4-AB52-59C6CDE636A2}.Debug|Any CPU.Build.0 = Debug|Any CPU {48DB9946-6D0B-49E4-AB52-59C6CDE636A2}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -170,6 +176,7 @@ Global {C1BE1D97-D078-4882-A772-C3CA11FD1F73} = {7C3C9BDE-3FF9-4B26-BACB-59EB827A5C0C} {D52C68D2-B6DD-4FFB-B3B5-011B76733202} = {7C3C9BDE-3FF9-4B26-BACB-59EB827A5C0C} {1E4880D4-D17F-4E0B-9F42-F9D9E5F5B50D} = {21CFCBC2-EE04-43D0-8432-6B4B4DA770F1} + {C5441F84-4126-4C81-95E5-3DE9E36F904F} = {21CFCBC2-EE04-43D0-8432-6B4B4DA770F1} {48DB9946-6D0B-49E4-AB52-59C6CDE636A2} = {21CFCBC2-EE04-43D0-8432-6B4B4DA770F1} {0E9E4E11-BBF5-42B0-AAAF-2C5C2197A4B6} = {21CFCBC2-EE04-43D0-8432-6B4B4DA770F1} {37C6762F-3925-4396-8E19-59173578DB4F} = {21CFCBC2-EE04-43D0-8432-6B4B4DA770F1} diff --git a/src/libraries/System.Xml.XPath/System.Xml.XPath.sln b/src/libraries/System.Xml.XPath/System.Xml.XPath.sln index 9c603f739ff..de19d6f38d6 100644 --- a/src/libraries/System.Xml.XPath/System.Xml.XPath.sln +++ b/src/libraries/System.Xml.XPath/System.Xml.XPath.sln @@ -11,6 +11,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.Xml", "..\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{3F350171-58C5-4427-A621-7E6EC6492429}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{EA08A4CD-7A85-4B94-B45F-9A19BB6A6298}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{E0AD66A8-D552-43C6-AB0F-305A2CD2A628}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{F02C927A-92DA-4212-A228-EE4E82317723}" @@ -81,6 +83,10 @@ Global {3F350171-58C5-4427-A621-7E6EC6492429}.Debug|Any CPU.Build.0 = Debug|Any CPU {3F350171-58C5-4427-A621-7E6EC6492429}.Release|Any CPU.ActiveCfg = Release|Any CPU {3F350171-58C5-4427-A621-7E6EC6492429}.Release|Any CPU.Build.0 = Release|Any CPU + {EA08A4CD-7A85-4B94-B45F-9A19BB6A6298}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {EA08A4CD-7A85-4B94-B45F-9A19BB6A6298}.Debug|Any CPU.Build.0 = Debug|Any CPU + {EA08A4CD-7A85-4B94-B45F-9A19BB6A6298}.Release|Any CPU.ActiveCfg = Release|Any CPU + {EA08A4CD-7A85-4B94-B45F-9A19BB6A6298}.Release|Any CPU.Build.0 = Release|Any CPU {E0AD66A8-D552-43C6-AB0F-305A2CD2A628}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {E0AD66A8-D552-43C6-AB0F-305A2CD2A628}.Debug|Any CPU.Build.0 = Debug|Any CPU {E0AD66A8-D552-43C6-AB0F-305A2CD2A628}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -149,6 +155,7 @@ Global {B7D48F78-4580-4398-A93F-FD02A15AD0BD} = {73688A49-11B7-47C8-BF09-A6C1C11EA0BD} {F825C114-FF6D-4826-BC8A-586246369695} = {73688A49-11B7-47C8-BF09-A6C1C11EA0BD} {3F350171-58C5-4427-A621-7E6EC6492429} = {543F6A8C-B245-464C-A7F5-50D5A1369909} + {EA08A4CD-7A85-4B94-B45F-9A19BB6A6298} = {543F6A8C-B245-464C-A7F5-50D5A1369909} {E0AD66A8-D552-43C6-AB0F-305A2CD2A628} = {543F6A8C-B245-464C-A7F5-50D5A1369909} {F02C927A-92DA-4212-A228-EE4E82317723} = {543F6A8C-B245-464C-A7F5-50D5A1369909} {2E9AD1A2-506F-469A-AAB9-C6BA43FC78E1} = {543F6A8C-B245-464C-A7F5-50D5A1369909} diff --git a/src/libraries/System.Xml.XmlSerializer/System.Xml.XmlSerializer.sln b/src/libraries/System.Xml.XmlSerializer/System.Xml.XmlSerializer.sln index 20d2dc85307..cd5f4c8352b 100644 --- a/src/libraries/System.Xml.XmlSerializer/System.Xml.XmlSerializer.sln +++ b/src/libraries/System.Xml.XmlSerializer/System.Xml.XmlSerializer.sln @@ -19,6 +19,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Private.Xml", "..\Sy EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComInterfaceGenerator", "..\System.Runtime.InteropServices\gen\ComInterfaceGenerator\ComInterfaceGenerator.csproj", "{0A5C2144-0899-42FF-89AD-10CE8F613B85}" EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DownlevelLibraryImportGenerator", "..\System.Runtime.InteropServices\gen\DownlevelLibraryImportGenerator\DownlevelLibraryImportGenerator.csproj", "{2C73FA9A-7BA2-4D24-BB80-4ADC4B9A2D9A}" +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LibraryImportGenerator", "..\System.Runtime.InteropServices\gen\LibraryImportGenerator\LibraryImportGenerator.csproj", "{3232286F-6DB1-46A6-AA45-CA9014FD8D9A}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Interop.SourceGeneration", "..\System.Runtime.InteropServices\gen\Microsoft.Interop.SourceGeneration\Microsoft.Interop.SourceGeneration.csproj", "{91E43C52-718D-46CE-B832-230A3730A32F}" @@ -105,6 +107,10 @@ Global {0A5C2144-0899-42FF-89AD-10CE8F613B85}.Debug|Any CPU.Build.0 = Debug|Any CPU {0A5C2144-0899-42FF-89AD-10CE8F613B85}.Release|Any CPU.ActiveCfg = Release|Any CPU {0A5C2144-0899-42FF-89AD-10CE8F613B85}.Release|Any CPU.Build.0 = Release|Any CPU + {2C73FA9A-7BA2-4D24-BB80-4ADC4B9A2D9A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {2C73FA9A-7BA2-4D24-BB80-4ADC4B9A2D9A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {2C73FA9A-7BA2-4D24-BB80-4ADC4B9A2D9A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {2C73FA9A-7BA2-4D24-BB80-4ADC4B9A2D9A}.Release|Any CPU.Build.0 = Release|Any CPU {3232286F-6DB1-46A6-AA45-CA9014FD8D9A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {3232286F-6DB1-46A6-AA45-CA9014FD8D9A}.Debug|Any CPU.Build.0 = Debug|Any CPU {3232286F-6DB1-46A6-AA45-CA9014FD8D9A}.Release|Any CPU.ActiveCfg = Release|Any CPU @@ -177,6 +183,7 @@ Global {EF514C0C-ECA7-419A-BDED-A6735FEA16F9} = {F0B2F254-B3E6-4BAA-8C92-2373990CF48B} {67D79968-DF22-4273-B2FA-D3EEC905095C} = {F0B2F254-B3E6-4BAA-8C92-2373990CF48B} {0A5C2144-0899-42FF-89AD-10CE8F613B85} = {8B996FD2-F7BF-4196-9468-998117E8C7C1} + {2C73FA9A-7BA2-4D24-BB80-4ADC4B9A2D9A} = {8B996FD2-F7BF-4196-9468-998117E8C7C1} {3232286F-6DB1-46A6-AA45-CA9014FD8D9A} = {8B996FD2-F7BF-4196-9468-998117E8C7C1} {91E43C52-718D-46CE-B832-230A3730A32F} = {8B996FD2-F7BF-4196-9468-998117E8C7C1} {F3678706-5923-4F5E-B33C-625C22A9CA32} = {8B996FD2-F7BF-4196-9468-998117E8C7C1} diff --git a/src/libraries/apicompat/ApiCompatBaseline.NetCoreAppLatestStable.xml b/src/libraries/apicompat/ApiCompatBaseline.NetCoreAppLatestStable.xml index f8db3a7c5a7..2f653968fe0 100644 --- a/src/libraries/apicompat/ApiCompatBaseline.NetCoreAppLatestStable.xml +++ b/src/libraries/apicompat/ApiCompatBaseline.NetCoreAppLatestStable.xml @@ -1,6 +1,24 @@  + + CP0014 + M:System.Console.SetWindowSize(System.Int32,System.Int32):[T:System.Runtime.Versioning.UnsupportedOSPlatformAttribute] + net8.0/mscorlib.dll + net9.0/mscorlib.dll + + + CP0014 + P:System.Console.WindowHeight:[T:System.Runtime.Versioning.UnsupportedOSPlatformAttribute] + net8.0/mscorlib.dll + net9.0/mscorlib.dll + + + CP0014 + P:System.Console.WindowWidth:[T:System.Runtime.Versioning.UnsupportedOSPlatformAttribute] + net8.0/mscorlib.dll + net9.0/mscorlib.dll + CP0014 M:System.ComponentModel.DesignerAttribute.#ctor(System.String,System.String)$0:[T:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute] @@ -91,6 +109,12 @@ net8.0/netstandard.dll net9.0/netstandard.dll + + CP0014 + M:System.Console.SetWindowSize(System.Int32,System.Int32):[T:System.Runtime.Versioning.UnsupportedOSPlatformAttribute] + net8.0/netstandard.dll + net9.0/netstandard.dll + CP0014 P:System.ComponentModel.DesignerAttribute.DesignerBaseTypeName:[T:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute] @@ -121,6 +145,18 @@ net8.0/netstandard.dll net9.0/netstandard.dll + + CP0014 + P:System.Console.WindowHeight:[T:System.Runtime.Versioning.UnsupportedOSPlatformAttribute] + net8.0/netstandard.dll + net9.0/netstandard.dll + + + CP0014 + P:System.Console.WindowWidth:[T:System.Runtime.Versioning.UnsupportedOSPlatformAttribute] + net8.0/netstandard.dll + net9.0/netstandard.dll + CP0014 M:System.ComponentModel.DesignerAttribute.#ctor(System.String,System.String)$0:[T:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute] @@ -349,6 +385,24 @@ net8.0/System.ComponentModel.TypeConverter.dll net9.0/System.ComponentModel.TypeConverter.dll + + CP0014 + M:System.Console.SetWindowSize(System.Int32,System.Int32):[T:System.Runtime.Versioning.UnsupportedOSPlatformAttribute] + net8.0/System.Console.dll + net9.0/System.Console.dll + + + CP0014 + P:System.Console.WindowHeight:[T:System.Runtime.Versioning.UnsupportedOSPlatformAttribute] + net8.0/System.Console.dll + net9.0/System.Console.dll + + + CP0014 + P:System.Console.WindowWidth:[T:System.Runtime.Versioning.UnsupportedOSPlatformAttribute] + net8.0/System.Console.dll + net9.0/System.Console.dll + CP0014 M:System.ComponentModel.DesignerAttribute.#ctor(System.String,System.String)$0:[T:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute] diff --git a/src/libraries/externals.csproj b/src/libraries/externals.csproj index aa2a7a6853c..4b12dc2dca1 100644 --- a/src/libraries/externals.csproj +++ b/src/libraries/externals.csproj @@ -14,12 +14,12 @@ true true false - true + true - + diff --git a/src/libraries/oob.proj b/src/libraries/oob.proj index 21db8f35584..96cddf78dc8 100644 --- a/src/libraries/oob.proj +++ b/src/libraries/oob.proj @@ -22,13 +22,6 @@ - - - - - - - @@ -47,7 +40,7 @@ diff --git a/src/libraries/sfx-ref.proj b/src/libraries/sfx-ref.proj index 57bec669a2f..b1a3916acf4 100644 --- a/src/libraries/sfx-ref.proj +++ b/src/libraries/sfx-ref.proj @@ -17,12 +17,4 @@ System.Private.CoreLib\ref\System.Private.CoreLib.csproj" /> - - - - - - - - diff --git a/src/libraries/sfx.proj b/src/libraries/sfx.proj index 9b174d57c90..15c4d25c43d 100644 --- a/src/libraries/sfx.proj +++ b/src/libraries/sfx.proj @@ -14,11 +14,8 @@ - - SharedFrameworkAssembly - - - + + @@ -61,8 +58,7 @@ + AfterTargets="Build"> @@ -73,6 +69,27 @@ UseHardlinksIfPossible="true" /> + + + + <_expectedRef Include="@(NetCoreAppLibrary)" Condition="!$([System.String]::new('%(Identity)').StartsWith('System.Private'))" /> + <_expectedSharedFrameworkFile Include="@(_expectedRefs->'$(MicrosoftNetCoreAppRefPackRefDir)%(Identity).dll')" /> + + + <_expectedDoc Include="@(_expectedRefs)" Exclude="netstandard;@(NetFxReference)" /> + <_expectedSharedFrameworkFile Include="@(_expectedDoc->'$(MicrosoftNetCoreAppRefPackRefDir)%(Identity).xml')" /> + + + <_expectedLib Include="@(NetCoreAppLibrary)" Exclude="System.Private.CoreLib" /> + <_expectedSharedFrameworkFile Include="@(_expectedLib->'$(MicrosoftNetCoreAppRuntimePackRidLibTfmDir)%(Identity).dll')" /> + + <_missingSharedFrameworkFile Include="@(_expectedSharedFrameworkFile)" Exclude="@(_expectedSharedFrameworkFile->Exists())" /> + + + + + @@ -89,7 +106,6 @@ diff --git a/src/libraries/tests.proj b/src/libraries/tests.proj index 29ca2bcc489..01d9ce0847d 100644 --- a/src/libraries/tests.proj +++ b/src/libraries/tests.proj @@ -153,9 +153,10 @@ + + + - - @@ -433,7 +434,7 @@ - + @@ -582,6 +583,7 @@ + @@ -777,7 +779,8 @@ + Targets="Publish" + AdditionalProperties="%(AdditionalProperties);_IsPublishing=true;Configuration=Release;PublishDir=$(XUnitLogCheckerLibrariesOutDir);ROOTFS_DIR=$(ROOTFS_DIR);RuntimeIdentifier=$(OutputRID)" /> + @@ -185,6 +186,7 @@ + @@ -314,8 +316,8 @@ - - src\System\Diagnostics\Eventing\Generated\NativeRuntimeEventSource.Mono.cs + + src\System\Diagnostics\Eventing\NativeRuntimeEventSource.Generated.cs @@ -326,7 +328,7 @@ DependsOnTargets="FindPython" BeforeTargets="BeforeCompile"> - + <_PythonWarningParameter>-Wall <_PythonWarningParameter Condition="'$(MSBuildTreatWarningsAsErrors)' == 'true'">$(_PythonWarningParameter) -Werror @@ -334,7 +336,7 @@ <_EventingSourceFileDirectory Condition="HasTrailingSlash('$(_EventingSourceFileDirectory)')">$(_EventingSourceFileDirectory.TrimEnd('\')) - + diff --git a/src/mono/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.wasm.singlethread.xml b/src/mono/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.wasm.singlethread.xml new file mode 100644 index 00000000000..9e0b006e869 --- /dev/null +++ b/src/mono/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.wasm.singlethread.xml @@ -0,0 +1,7 @@ + + + + + + + diff --git a/src/mono/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.wasm.xml b/src/mono/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.wasm.xml index 9d16a4a7adc..ed9ce57b248 100644 --- a/src/mono/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.wasm.xml +++ b/src/mono/System.Private.CoreLib/src/ILLink/ILLink.Substitutions.wasm.xml @@ -1,8 +1,5 @@ - - - diff --git a/src/mono/System.Private.CoreLib/src/System/IO/Stream.Mono.cs b/src/mono/System.Private.CoreLib/src/System/IO/Stream.Mono.cs new file mode 100644 index 00000000000..b8633b200ab --- /dev/null +++ b/src/mono/System.Private.CoreLib/src/System/IO/Stream.Mono.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Runtime.CompilerServices; + +namespace System.IO +{ + public abstract partial class Stream + { + [Intrinsic] + [MethodImpl(MethodImplOptions.InternalCall)] + private extern bool HasOverriddenBeginEndRead(); + + [Intrinsic] + [MethodImpl(MethodImplOptions.InternalCall)] + private extern bool HasOverriddenBeginEndWrite(); + } +} diff --git a/src/mono/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs b/src/mono/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs index 013a51fe11b..67306e03081 100644 --- a/src/mono/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs +++ b/src/mono/System.Private.CoreLib/src/System/Reflection/Metadata/MetadataUpdater.cs @@ -2,6 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; using System.Runtime.CompilerServices; namespace System.Reflection.Metadata @@ -49,6 +50,7 @@ public static void ApplyUpdate(Assembly assembly, ReadOnlySpan metadataDel internal static string GetCapabilities() => s_ApplyUpdateCapabilities.Value; + [FeatureSwitchDefinition("System.Reflection.Metadata.MetadataUpdater.IsSupported")] public static bool IsSupported { get; } = ApplyUpdateEnabled(justComponentCheck: 0) != 0; private static readonly Lazy s_ApplyUpdateCapabilities = new Lazy(InitializeApplyUpdateCapabilities); diff --git a/src/mono/System.Private.CoreLib/src/System/Threading/ThreadPool.Wasi.Mono.cs b/src/mono/System.Private.CoreLib/src/System/Threading/ThreadPool.Wasi.Mono.cs index bad9fbdbaad..0d082fd863c 100644 --- a/src/mono/System.Private.CoreLib/src/System/Threading/ThreadPool.Wasi.Mono.cs +++ b/src/mono/System.Private.CoreLib/src/System/Threading/ThreadPool.Wasi.Mono.cs @@ -35,7 +35,7 @@ public static partial class ThreadPool { // Indicates whether the thread pool should yield the thread from the dispatch loop to the runtime periodically so that // the runtime may use the thread for processing other work - internal static bool YieldFromDispatchLoop => false; + internal static bool YieldFromDispatchLoop => true; private const bool IsWorkerTrackingEnabledInConfig = false; diff --git a/src/mono/System.Private.CoreLib/src/System/Threading/TimerQueue.Wasi.Mono.cs b/src/mono/System.Private.CoreLib/src/System/Threading/TimerQueue.Wasi.Mono.cs index 20c017cce1f..d5af01ca588 100644 --- a/src/mono/System.Private.CoreLib/src/System/Threading/TimerQueue.Wasi.Mono.cs +++ b/src/mono/System.Private.CoreLib/src/System/Threading/TimerQueue.Wasi.Mono.cs @@ -4,7 +4,7 @@ using System.Collections.Generic; using System.Diagnostics; using System.Threading.Tasks; -using WasiPollWorld.wit.imports.wasi.clocks.v0_2_1; +using WasiPollWorld.wit.imports.wasi.clocks.v0_2_0; namespace System.Threading { @@ -81,7 +81,7 @@ private static unsafe void SetNextTimer(long shortestDueTimeMs, long currentTime // `SubscribeDuration` expects nanoseconds: var pollable = MonotonicClockInterop.SubscribeDuration(shortestWaitMs * 1000 * 1000); - Task task = WasiEventLoop.RegisterWasiPollable(pollable); + Task task = WasiEventLoop.RegisterWasiPollable(pollable, true, CancellationToken.None); task.ContinueWith(TimerHandler, TaskScheduler.Default); } } diff --git a/src/mono/browser/browser.proj b/src/mono/browser/browser.proj index f994662993a..b0701bdaa84 100644 --- a/src/mono/browser/browser.proj +++ b/src/mono/browser/browser.proj @@ -394,8 +394,8 @@ $(ArtifactsObjDir)wasm/pinvoke-table.h $(ArtifactsObjDir)wasm/wasm_m2n_invoke.g.h - -g -Os -DDEBUG=1 -DENABLE_AOT_PROFILER=1 -DENABLE_BROWSER_PROFILER=1 - -Oz -DENABLE_BROWSER_PROFILER=1 + -g -Os -DDEBUG=1 -DENABLE_AOT_PROFILER=1 -DENABLE_BROWSER_PROFILER=1 -DENABLE_LOG_PROFILER=1 + -Oz $(CMakeConfigurationEmccFlags) -s ASSERTIONS=1 -O2 diff --git a/src/mono/browser/build/BrowserWasmApp.targets b/src/mono/browser/build/BrowserWasmApp.targets index 3b5683433fe..8eb51b41fe8 100644 --- a/src/mono/browser/build/BrowserWasmApp.targets +++ b/src/mono/browser/build/BrowserWasmApp.targets @@ -314,6 +314,7 @@ <_EmccCFlags Include="-DLINK_ICALLS=1" Condition="'$(WasmLinkIcalls)' == 'true'" /> <_EmccCFlags Include="-DENABLE_AOT_PROFILER=1" Condition="$(WasmProfilers.Contains('aot'))" /> <_EmccCFlags Include="-DENABLE_BROWSER_PROFILER=1" Condition="$(WasmProfilers.Contains('browser'))" /> + <_EmccCFlags Include="-DENABLE_LOG_PROFILER=1" Condition="$(WasmProfilers.Contains('log'))" /> <_EmccCFlags Include="-DENABLE_JS_INTEROP_BY_VALUE=1" Condition="'$(WasmEnableJsInteropByValue)' == 'true'" /> <_EmccCFlags Include="-DGEN_PINVOKE=1" /> @@ -368,6 +369,7 @@ + @@ -478,6 +480,7 @@ <_EmccLinkStepArgs Include="$(EmccExtraLDFlags)" /> <_WasmLinkStepArgs Include="@(_EmccLinkStepArgs)" /> + <_WasmLinkStepArgs Include="@(LinkerArg)" /> diff --git a/src/mono/browser/debugger/DebuggerTestSuite/EvaluateOnCallFrame2Tests.cs b/src/mono/browser/debugger/DebuggerTestSuite/EvaluateOnCallFrame2Tests.cs index 8e0a68441d0..43806f2076d 100644 --- a/src/mono/browser/debugger/DebuggerTestSuite/EvaluateOnCallFrame2Tests.cs +++ b/src/mono/browser/debugger/DebuggerTestSuite/EvaluateOnCallFrame2Tests.cs @@ -841,5 +841,16 @@ public async Task EvaluateValueTypeWithObjectValueType() => await CheckInspectLo await RuntimeEvaluateAndCheck( ("myVar.MyMethod()", TNumber(10))); }); + + // https://github.com/dotnet/runtime/issues/106311 + [ConditionalFact(nameof(RunningOnChrome))] + public async Task EvaluateOnValueTypeWithoutExtraSpace() => await CheckInspectLocalsAtBreakpointSite( + "DebuggerTests.EvaluateOnValueTypeWithoutExtraSpace", "run", 3, "DebuggerTests.EvaluateOnValueTypeWithoutExtraSpace.run", + "window.setTimeout(function() { invoke_static_method ('[debugger-test] DebuggerTests.EvaluateOnValueTypeWithoutExtraSpace:run'); })", + wait_for_event_fn: async (pause_location) => + { + await RuntimeEvaluateAndCheck( + ("f1.DistSquaredXY(f2)", TNumber(2))); + }); } } diff --git a/src/mono/browser/debugger/tests/debugger-test/debugger-evaluate-test.cs b/src/mono/browser/debugger/tests/debugger-test/debugger-evaluate-test.cs index 55556ffa150..c6a5945e51f 100644 --- a/src/mono/browser/debugger/tests/debugger-test/debugger-evaluate-test.cs +++ b/src/mono/browser/debugger/tests/debugger-test/debugger-evaluate-test.cs @@ -2291,4 +2291,27 @@ public static void run() myVar.MyMethod(); } } + + public struct EvaluateOnValueTypeWithoutExtraSpace + { + public double X; + public double Y; + public double Z; + public EvaluateOnValueTypeWithoutExtraSpace(float InX, float InY, float InZ) + { + X = InX; Y = InY; Z = InZ; + } + public double DistSquaredXY(in EvaluateOnValueTypeWithoutExtraSpace B) // the keyword "in" here is crucial, with it the crash produced + { + double DX = X - B.X; + double DY = Y - B.Y; + return DX * DX + DY * DY; + } + public static void run() + { + EvaluateOnValueTypeWithoutExtraSpace f1 = new EvaluateOnValueTypeWithoutExtraSpace(1, 1, 1); + EvaluateOnValueTypeWithoutExtraSpace f2 = new EvaluateOnValueTypeWithoutExtraSpace(2, 2, 2); + Console.WriteLine("pause here"); + } + } } \ No newline at end of file diff --git a/src/mono/browser/runtime/cwraps.ts b/src/mono/browser/runtime/cwraps.ts index 7a2121f60b5..3ff37424ab9 100644 --- a/src/mono/browser/runtime/cwraps.ts +++ b/src/mono/browser/runtime/cwraps.ts @@ -67,9 +67,10 @@ const fn_signatures: SigLine[] = [ [false, "mono_wasm_exit", "void", ["number"]], [true, "mono_wasm_getenv", "number", ["string"]], [true, "mono_wasm_set_main_args", "void", ["number", "number"]], - // These two need to be lazy because they may be missing + // These three need to be lazy because they may be missing [() => !runtimeHelpers.emscriptenBuildOptions.enableAotProfiler, "mono_wasm_profiler_init_aot", "void", ["string"]], [() => !runtimeHelpers.emscriptenBuildOptions.enableBrowserProfiler, "mono_wasm_profiler_init_browser", "void", ["string"]], + [() => !runtimeHelpers.emscriptenBuildOptions.enableLogProfiler, "mono_wasm_profiler_init_log", "void", ["string"]], [true, "mono_wasm_profiler_init_browser", "void", ["number"]], [false, "mono_wasm_exec_regression", "number", ["number", "string"]], [false, "mono_wasm_invoke_jsexport", "void", ["number", "number"]], @@ -167,6 +168,7 @@ export interface t_ThreadingCwraps { export interface t_ProfilerCwraps { mono_wasm_profiler_init_aot(desc: string): void; mono_wasm_profiler_init_browser(desc: string): void; + mono_wasm_profiler_init_log(desc: string): void; } export interface t_Cwraps { diff --git a/src/mono/browser/runtime/driver.c b/src/mono/browser/runtime/driver.c index 1b3663e4f3f..2a1d5b1dbbf 100644 --- a/src/mono/browser/runtime/driver.c +++ b/src/mono/browser/runtime/driver.c @@ -430,6 +430,18 @@ mono_wasm_profiler_init_browser (const char *desc) #endif +#ifdef ENABLE_LOG_PROFILER + +void mono_profiler_init_log (const char *desc); + +EMSCRIPTEN_KEEPALIVE void +mono_wasm_profiler_init_log (const char *desc) +{ + mono_profiler_init_log (desc); +} + +#endif + EMSCRIPTEN_KEEPALIVE void mono_wasm_init_finalizer_thread (void) { diff --git a/src/mono/browser/runtime/es6/dotnet.es6.lib.js b/src/mono/browser/runtime/es6/dotnet.es6.lib.js index 69b6c31376f..68702547857 100644 --- a/src/mono/browser/runtime/es6/dotnet.es6.lib.js +++ b/src/mono/browser/runtime/es6/dotnet.es6.lib.js @@ -11,6 +11,7 @@ const WASM_ENABLE_SIMD = process.env.WASM_ENABLE_SIMD === "1"; const WASM_ENABLE_EH = process.env.WASM_ENABLE_EH === "1"; const ENABLE_BROWSER_PROFILER = process.env.ENABLE_BROWSER_PROFILER === "1"; const ENABLE_AOT_PROFILER = process.env.ENABLE_AOT_PROFILER === "1"; +const ENABLE_LOG_PROFILER = process.env.ENABLE_LOG_PROFILER === "1"; const RUN_AOT_COMPILATION = process.env.RUN_AOT_COMPILATION === "1"; var methodIndexByName = undefined; var gitHash = undefined; @@ -88,6 +89,7 @@ function injectDependencies() { `wasmEnableEH: ${WASM_ENABLE_EH ? "true" : "false"},` + `enableAotProfiler: ${ENABLE_AOT_PROFILER ? "true" : "false"}, ` + `enableBrowserProfiler: ${ENABLE_BROWSER_PROFILER ? "true" : "false"}, ` + + `enableLogProfiler: ${ENABLE_LOG_PROFILER ? "true" : "false"}, ` + `runAOTCompilation: ${RUN_AOT_COMPILATION ? "true" : "false"}, ` + `wasmEnableThreads: ${USE_PTHREADS ? "true" : "false"}, ` + `gitHash: "${gitHash}", ` + diff --git a/src/mono/browser/runtime/hybrid-globalization/collations.ts b/src/mono/browser/runtime/hybrid-globalization/collations.ts index 6b30ded537d..dd919b3c416 100644 --- a/src/mono/browser/runtime/hybrid-globalization/collations.ts +++ b/src/mono/browser/runtime/hybrid-globalization/collations.ts @@ -86,14 +86,14 @@ export function mono_wasm_ends_with (culture: number, cultureLength: number, str export function mono_wasm_index_of (culture: number, cultureLength: number, needlePtr: number, needleLength: number, srcPtr: number, srcLength: number, options: number, fromBeginning: number, resultPtr: Int32Ptr): VoidPtr { try { - const needle = runtimeHelpers.utf16ToString(needlePtr, (needlePtr + 2 * needleLength)); + const needle = decodeToCleanStringForIndexing(needlePtr, needleLength); // no need to look for an empty string if (cleanString(needle).length == 0) { runtimeHelpers.setI32(resultPtr, fromBeginning ? 0 : srcLength); return VoidPtrNull; } - const source = runtimeHelpers.utf16ToString(srcPtr, (srcPtr + 2 * srcLength)); + const source = decodeToCleanStringForIndexing(srcPtr, srcLength); // no need to look in an empty string if (cleanString(source).length == 0) { runtimeHelpers.setI32(resultPtr, fromBeginning ? 0 : srcLength); @@ -251,5 +251,11 @@ function decodeToCleanString (strPtr: number, strLen: number) { function cleanString (str: string) { const nStr = str.normalize(); - return nStr.replace(/[\u200B-\u200D\uFEFF\0]/g, ""); + return nStr.replace(/[\u200B-\u200D\uFEFF\0\u00AD]/g, ""); +} + +// in ICU indexing only SoftHyphen is weightless +function decodeToCleanStringForIndexing (strPtr: number, strLen: number) { + const str = runtimeHelpers.utf16ToString(strPtr, (strPtr + 2 * strLen)); + return str.replace(/[\u00AD]/g, ""); } diff --git a/src/mono/browser/runtime/jiterpreter-enums.ts b/src/mono/browser/runtime/jiterpreter-enums.ts index 07a3f815b83..3caa16bb613 100644 --- a/src/mono/browser/runtime/jiterpreter-enums.ts +++ b/src/mono/browser/runtime/jiterpreter-enums.ts @@ -21,6 +21,8 @@ export const enum JiterpCounter { BackBranchesNotEmitted, ElapsedGenerationMs, ElapsedCompilationMs, + SwitchTargetsOk, + SwitchTargetsFailed, } // keep in sync with jiterpreter.c, see mono_jiterp_get_member_offset @@ -127,6 +129,8 @@ export const enum BailoutReason { Icall, UnexpectedRetIp, LeaveCheck, + SwitchSize, + SwitchTarget, } export const BailoutReasonNames = [ @@ -157,6 +161,8 @@ export const BailoutReasonNames = [ "Icall", "UnexpectedRetIp", "LeaveCheck", + "SwitchSize", + "SwitchTarget", ]; export const enum JitQueue { diff --git a/src/mono/browser/runtime/jiterpreter-interp-entry.ts b/src/mono/browser/runtime/jiterpreter-interp-entry.ts index 3863afb601e..84be352d912 100644 --- a/src/mono/browser/runtime/jiterpreter-interp-entry.ts +++ b/src/mono/browser/runtime/jiterpreter-interp-entry.ts @@ -449,7 +449,7 @@ function flush_wasm_entry_trampoline_jit_queue () { ; } - const buf = builder.getArrayView(); + const buf = builder.getArrayView(false, true); for (let i = 0; i < buf.length; i++) { const b = buf[i]; if (b < 0x10) diff --git a/src/mono/browser/runtime/jiterpreter-jit-call.ts b/src/mono/browser/runtime/jiterpreter-jit-call.ts index 0ae48fd16ba..48e9797cb29 100644 --- a/src/mono/browser/runtime/jiterpreter-jit-call.ts +++ b/src/mono/browser/runtime/jiterpreter-jit-call.ts @@ -61,7 +61,6 @@ const maxJitQueueLength = 6, let trampBuilder: WasmBuilder; let fnTable: WebAssembly.Table; -let wasmEhSupported: boolean | undefined = undefined; let nextDisambiguateIndex = 0; const fnCache: Array = []; const targetCache: { [target: number]: TrampolineInfo } = {}; @@ -276,18 +275,6 @@ export function mono_interp_jit_wasm_jit_call_trampoline ( mono_interp_flush_jitcall_queue(); } -function getIsWasmEhSupported (): boolean { - if (wasmEhSupported !== undefined) - return wasmEhSupported; - - // Probe whether the current environment can handle wasm exceptions - wasmEhSupported = runtimeHelpers.featureWasmEh === true; - if (!wasmEhSupported) - mono_log_info("Disabling Jiterpreter Exception Handling"); - - return wasmEhSupported; -} - export function mono_interp_flush_jitcall_queue (): void { const jitQueue: TrampolineInfo[] = []; let methodPtr = 0; @@ -336,7 +323,7 @@ export function mono_interp_flush_jitcall_queue (): void { } if (builder.options.enableWasmEh) { - if (!getIsWasmEhSupported()) { + if (!runtimeHelpers.featureWasmEh) { // The user requested to enable wasm EH but it's not supported, so turn the option back off applyOptions({ enableWasmEh: false }); builder.options.enableWasmEh = false; @@ -519,7 +506,7 @@ export function mono_interp_flush_jitcall_queue (): void { ; } - const buf = builder.getArrayView(); + const buf = builder.getArrayView(false, true); for (let i = 0; i < buf.length; i++) { const b = buf[i]; if (b < 0x10) diff --git a/src/mono/browser/runtime/jiterpreter-opcodes.ts b/src/mono/browser/runtime/jiterpreter-opcodes.ts index d535070df2a..974bbaf5233 100644 --- a/src/mono/browser/runtime/jiterpreter-opcodes.ts +++ b/src/mono/browser/runtime/jiterpreter-opcodes.ts @@ -511,3 +511,73 @@ export const enum WasmSimdOpcode { i32x4_extadd_pairwise_i16x8_s = 0x7e, i32x4_extadd_pairwise_i16x8_u = 0x7f, } + +export const enum WasmAtomicOpcode { + memory_atomic_notify = 0x00, + memory_atomic_wait32 = 0x01, + memory_atomic_wait64 = 0x02, + atomic_fence = 0x03, + i32_atomic_load = 0x10, + i64_atomic_load = 0x11, + i32_atomic_load8_u = 0x12, + i32_atomic_load16_u = 0x13, + i64_atomic_load8_u = 0x14, + i64_atomic_load16_u = 0x15, + i64_atomic_load32_u = 0x16, + i32_atomic_store = 0x17, + i64_atomic_store = 0x18, + i32_atomic_store8 = 0x19, + i32_atomic_store16 = 0x1A, + i64_atomic_store8 = 0x1B, + i64_atomic_store16 = 0x1C, + i64_atomic_store32 = 0x1D, + i32_atomic_rmw_add = 0x1E, + i64_atomic_rmw_add = 0x1F, + i32_atomic_rmw8_add_u = 0x20, + i32_atomic_rmw16_add_u = 0x21, + i64_atomic_rmw8_add_u = 0x22, + i64_atomic_rmw16_add_u = 0x23, + i64_atomic_rmw32_add_u = 0x24, + i32_atomic_rmw_sub = 0x25, + i64_atomic_rmw_sub = 0x26, + i32_atomic_rmw8_sub_u = 0x27, + i32_atomic_rmw16_sub_u = 0x28, + i64_atomic_rmw8_sub_u = 0x29, + i64_atomic_rmw16_sub_u = 0x2A, + i64_atomic_rmw32_sub_u = 0x2B, + i32_atomic_rmw_and = 0x2C, + i64_atomic_rmw_and = 0x2D, + i32_atomic_rmw8_and_u = 0x2E, + i32_atomic_rmw16_and_u = 0x2F, + i64_atomic_rmw8_and_u = 0x30, + i64_atomic_rmw16_and_u = 0x31, + i64_atomic_rmw32_and_u = 0x32, + i32_atomic_rmw_or = 0x33, + i64_atomic_rmw_or = 0x34, + i32_atomic_rmw8_or_u = 0x35, + i32_atomic_rmw16_or_u = 0x36, + i64_atomic_rmw8_or_u = 0x37, + i64_atomic_rmw16_or_u = 0x38, + i64_atomic_rmw32_or_u = 0x39, + i32_atomic_rmw_xor = 0x3A, + i64_atomic_rmw_xor = 0x3B, + i32_atomic_rmw8_xor_u = 0x3C, + i32_atomic_rmw16_xor_u = 0x3D, + i64_atomic_rmw8_xor_u = 0x3E, + i64_atomic_rmw16_xor_u = 0x3F, + i64_atomic_rmw32_xor_u = 0x40, + i32_atomic_rmw_xchg = 0x41, + i64_atomic_rmw_xchg = 0x42, + i32_atomic_rmw8_xchg_u = 0x43, + i32_atomic_rmw16_xchg_u = 0x44, + i64_atomic_rmw8_xchg_u = 0x45, + i64_atomic_rmw16_xchg_u = 0x46, + i64_atomic_rmw32_xchg_u = 0x47, + i32_atomic_rmw_cmpxchg = 0x48, + i64_atomic_rmw_cmpxchg = 0x49, + i32_atomic_rmw8_cmpxchg_u = 0x4A, + i32_atomic_rmw16_cmpxchg_u = 0x4B, + i64_atomic_rmw8_cmpxchg_u = 0x4C, + i64_atomic_rmw16_cmpxchg_u = 0x4D, + i64_atomic_rmw32_cmpxchg_u = 0x4E, +} diff --git a/src/mono/browser/runtime/jiterpreter-support.ts b/src/mono/browser/runtime/jiterpreter-support.ts index a1b7238784a..8fdcc09216a 100644 --- a/src/mono/browser/runtime/jiterpreter-support.ts +++ b/src/mono/browser/runtime/jiterpreter-support.ts @@ -6,7 +6,7 @@ import NativeAOT from "consts:nativeAOT"; import WasmEnableThreads from "consts:wasmEnableThreads"; import { NativePointer, ManagedPointer, VoidPtr } from "./types/emscripten"; import { Module, mono_assert, runtimeHelpers } from "./globals"; -import { WasmOpcode, WasmSimdOpcode, WasmValtype } from "./jiterpreter-opcodes"; +import { WasmOpcode, WasmSimdOpcode, WasmAtomicOpcode, WasmValtype } from "./jiterpreter-opcodes"; import { MintOpcode } from "./mintops"; import cwraps from "./cwraps"; import { mono_log_error, mono_log_info } from "./logging"; @@ -19,7 +19,10 @@ import { export const maxFailures = 2, maxMemsetSize = 64, maxMemmoveSize = 64, - shortNameBase = 36; + shortNameBase = 36, + // NOTE: This needs to be big enough to hold the maximum module size since there's no auto-growth + // support yet. If that becomes a problem, we should just make it growable + blobBuilderCapacity = 24 * 1024; // uint16 export declare interface MintOpcodePtr extends NativePointer { @@ -107,6 +110,9 @@ export class WasmBuilder { nextConstantSlot = 0; backBranchTraceLevel = 0; + containsSimd!: boolean; + containsAtomics!: boolean; + compressImportNames = false; lockImports = false; @@ -119,6 +125,8 @@ export class WasmBuilder { clear (constantSlotCount: number) { this.options = getOptions(); + if (this.options.maxModuleSize >= blobBuilderCapacity) + throw new Error(`blobBuilderCapacity ${blobBuilderCapacity} is not large enough for jiterpreter-max-module-size of ${this.options.maxModuleSize}`); this.stackSize = 1; this.inSection = false; this.inFunction = false; @@ -155,6 +163,9 @@ export class WasmBuilder { this.callHandlerReturnAddresses.length = 0; this.allowNullCheckOptimization = this.options.eliminateNullChecks; + + this.containsSimd = false; + this.containsAtomics = false; } _push () { @@ -259,11 +270,18 @@ export class WasmBuilder { appendSimd (value: WasmSimdOpcode, allowLoad?: boolean) { this.current.appendU8(WasmOpcode.PREFIX_simd); - // Yes that's right. We're using LEB128 to encode 8-bit opcodes. Why? I don't know mono_assert(((value | 0) !== 0) || ((value === WasmSimdOpcode.v128_load) && (allowLoad === true)), "Expected non-v128_load simd opcode or allowLoad==true"); + // Yes that's right. We're using LEB128 to encode 8-bit opcodes. Why? I don't know return this.current.appendULeb(value); } + appendAtomic (value: WasmAtomicOpcode, allowNotify?: boolean) { + this.current.appendU8(WasmOpcode.PREFIX_atomic); + mono_assert(((value | 0) !== 0) || ((value === WasmAtomicOpcode.memory_atomic_notify) && (allowNotify === true)), "Expected non-notify atomic opcode or allowNotify==true"); + // Unlike SIMD, the spec appears to say that atomic opcodes are just two sequential bytes with explicit values. + return this.current.appendU8(value); + } + appendU32 (value: number) { return this.current.appendU32(value); } @@ -519,7 +537,7 @@ export class WasmBuilder { // memtype (limits = 0x03 n:u32 m:u32 => {min n, max m, shared}) this.appendU8(0x02); this.appendU8(0x03); - // emcc seems to generate this min/max by default + // HACK: emcc seems to generate this min/max by default this.appendULeb(256); this.appendULeb(32768); } else { @@ -909,8 +927,8 @@ export class WasmBuilder { this.appendU8(WasmOpcode.i32_add); } - getArrayView (fullCapacity?: boolean) { - if (this.stackSize > 1) + getArrayView (fullCapacity?: boolean, suppressDeepStackError?: boolean) { + if ((suppressDeepStackError !== true) && this.stackSize > 1) throw new Error("Jiterpreter block stack not empty"); return this.stack[0].getArrayView(fullCapacity); } @@ -931,8 +949,9 @@ export class BlobBuilder { textBuf = new Uint8Array(1024); constructor () { - this.capacity = 16 * 1024; + this.capacity = blobBuilderCapacity; this.buffer = Module._malloc(this.capacity); + mono_assert(this.buffer, () => `Failed to allocate ${blobBuilderCapacity}b buffer for BlobBuilder`); localHeapViewU8().fill(0, this.buffer, this.buffer + this.capacity); this.size = 0; this.clear(); @@ -1040,6 +1059,9 @@ export class BlobBuilder { if (typeof (count) !== "number") count = this.size; + if ((destination.size + count) >= destination.capacity) + throw new Error("Destination buffer full"); + localHeapViewU8().copyWithin(destination.buffer + destination.size, this.buffer, this.buffer + count); destination.size += count; } @@ -1047,11 +1069,16 @@ export class BlobBuilder { appendBytes (bytes: Uint8Array, count?: number) { const result = this.size; const heapU8 = localHeapViewU8(); + const actualCount = (typeof (count) !== "number") + ? bytes.length + : count; + + if ((this.size + actualCount) >= this.capacity) + throw new Error("Buffer full"); + if (bytes.buffer === heapU8.buffer) { - if (typeof (count) !== "number") - count = bytes.length; - heapU8.copyWithin(this.buffer + result, bytes.byteOffset, bytes.byteOffset + count); - this.size += count; + heapU8.copyWithin(this.buffer + result, bytes.byteOffset, bytes.byteOffset + actualCount); + this.size += actualCount; } else { if (typeof (count) === "number") bytes = new Uint8Array(bytes.buffer, bytes.byteOffset, count); @@ -1125,7 +1152,14 @@ type CfgBranch = { branchType: CfgBranchType; } -type CfgSegment = CfgBlob | CfgBranchBlockHeader | CfgBranch; +type CfgJumpTable = { + type: "jump-table"; + from: MintOpcodePtr; + targets: MintOpcodePtr[]; + fallthrough: MintOpcodePtr; +} + +type CfgSegment = CfgBlob | CfgBranchBlockHeader | CfgBranch | CfgJumpTable; export const enum CfgBranchType { Unconditional, @@ -1253,6 +1287,23 @@ class Cfg { } } + // It's the caller's responsibility to wrap this in a block and follow it with a bailout! + jumpTable (targets: MintOpcodePtr[], fallthrough: MintOpcodePtr) { + this.appendBlob(); + this.segments.push({ + type: "jump-table", + from: this.ip, + targets, + fallthrough, + }); + // opcode, length, fallthrough (approximate) + this.overheadBytes += 4; + // length of branch depths (approximate) + this.overheadBytes += targets.length; + // bailout for missing targets (approximate) + this.overheadBytes += 24; + } + emitBlob (segment: CfgBlob, source: Uint8Array) { // mono_log_info(`segment @${(segment.ip).toString(16)} ${segment.start}-${segment.start + segment.length}`); const view = source.subarray(segment.start, segment.start + segment.length); @@ -1390,6 +1441,38 @@ class Cfg { this.blockStack.shift(); break; } + case "jump-table": { + // Our caller wrapped us in a block and put a missing target bailout after us + const offset = 1; + // The selector was already loaded onto the wasm stack before cfg.jumpTable was called, + // so we just need to generate a br_table + this.builder.appendU8(WasmOpcode.br_table); + this.builder.appendULeb(segment.targets.length); + for (const target of segment.targets) { + const indexInStack = this.blockStack.indexOf(target); + if (indexInStack >= 0) { + modifyCounter(JiterpCounter.SwitchTargetsOk, 1); + this.builder.appendULeb(indexInStack + offset); + } else { + modifyCounter(JiterpCounter.SwitchTargetsFailed, 1); + if (this.trace > 0) + mono_log_info(`Switch target ${target} not found in block stack ${this.blockStack}`); + this.builder.appendULeb(0); + } + } + const fallthroughIndex = this.blockStack.indexOf(segment.fallthrough); + if (fallthroughIndex >= 0) { + modifyCounter(JiterpCounter.SwitchTargetsOk, 1); + this.builder.appendULeb(fallthroughIndex + offset); + } else { + modifyCounter(JiterpCounter.SwitchTargetsFailed, 1); + if (this.trace > 0) + mono_log_info(`Switch fallthrough ${segment.fallthrough} not found in block stack ${this.blockStack}`); + this.builder.appendULeb(0); + } + this.builder.appendU8(WasmOpcode.unreachable); + break; + } case "branch": { const lookupTarget = segment.isBackward ? dispatchIp : segment.target; let indexInStack = this.blockStack.indexOf(lookupTarget), @@ -1902,6 +1985,7 @@ export type JiterpreterOptions = { enableCallResume: boolean; enableWasmEh: boolean; enableSimd: boolean; + enableAtomics: boolean; zeroPageOptimization: boolean; cprop: boolean; // For locations where the jiterpreter heuristic says we will be unable to generate @@ -1938,6 +2022,8 @@ export type JiterpreterOptions = { wasmBytesLimit: number; tableSize: number; aotTableSize: number; + maxModuleSize: number; + maxSwitchSize: number; } const optionNames: { [jsName: string]: string } = { @@ -1948,6 +2034,7 @@ const optionNames: { [jsName: string]: string } = { "enableCallResume": "jiterpreter-call-resume-enabled", "enableWasmEh": "jiterpreter-wasm-eh-enabled", "enableSimd": "jiterpreter-simd-enabled", + "enableAtomics": "jiterpreter-atomics-enabled", "zeroPageOptimization": "jiterpreter-zero-page-optimization", "cprop": "jiterpreter-constant-propagation", "enableStats": "jiterpreter-stats-enabled", @@ -1973,6 +2060,8 @@ const optionNames: { [jsName: string]: string } = { "wasmBytesLimit": "jiterpreter-wasm-bytes-limit", "tableSize": "jiterpreter-table-size", "aotTableSize": "jiterpreter-aot-table-size", + "maxModuleSize": "jiterpreter-max-module-size", + "maxSwitchSize": "jiterpreter-max-switch-size", }; let optionsVersion = -1; diff --git a/src/mono/browser/runtime/jiterpreter-tables.ts b/src/mono/browser/runtime/jiterpreter-tables.ts index a345844e9d9..90b599a8bb5 100644 --- a/src/mono/browser/runtime/jiterpreter-tables.ts +++ b/src/mono/browser/runtime/jiterpreter-tables.ts @@ -2,7 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. import { - WasmOpcode, WasmSimdOpcode, JiterpSpecialOpcode + WasmOpcode, WasmSimdOpcode, WasmAtomicOpcode, JiterpSpecialOpcode } from "./jiterpreter-opcodes"; import { MintOpcode, SimdIntrinsic2, SimdIntrinsic3, SimdIntrinsic4 @@ -325,6 +325,24 @@ export const mathIntrinsicTable: { [opcode: number]: [isUnary: boolean, isF32: b [MintOpcode.MINT_REM_R4]: [false, true, "fmodf"], }; +export const xchgTable: { [opcode: number]: [wasmOpcode: WasmAtomicOpcode, resultFixupOpcode: WasmOpcode, alignmentPower: number] } = { + [MintOpcode.MINT_MONO_EXCHANGE_U1]: [WasmAtomicOpcode.i32_atomic_rmw8_xchg_u, WasmOpcode.unreachable, 0], + [MintOpcode.MINT_MONO_EXCHANGE_I1]: [WasmAtomicOpcode.i32_atomic_rmw8_xchg_u, WasmOpcode.i32_extend_8_s, 0], + [MintOpcode.MINT_MONO_EXCHANGE_U2]: [WasmAtomicOpcode.i32_atomic_rmw16_xchg_u, WasmOpcode.unreachable, 1], + [MintOpcode.MINT_MONO_EXCHANGE_I2]: [WasmAtomicOpcode.i32_atomic_rmw16_xchg_u, WasmOpcode.i32_extend_16_s, 1], + [MintOpcode.MINT_MONO_EXCHANGE_I4]: [WasmAtomicOpcode.i32_atomic_rmw_xchg, WasmOpcode.unreachable, 2], + [MintOpcode.MINT_MONO_EXCHANGE_I8]: [WasmAtomicOpcode.i64_atomic_rmw_xchg, WasmOpcode.unreachable, 3], +}; + +export const cmpxchgTable: { [opcode: number]: [wasmOpcode: WasmAtomicOpcode, resultFixupOpcode: WasmOpcode, alignmentPower: number] } = { + [MintOpcode.MINT_MONO_CMPXCHG_U1]: [WasmAtomicOpcode.i32_atomic_rmw8_cmpxchg_u, WasmOpcode.unreachable, 0], + [MintOpcode.MINT_MONO_CMPXCHG_I1]: [WasmAtomicOpcode.i32_atomic_rmw8_cmpxchg_u, WasmOpcode.i32_extend_8_s, 0], + [MintOpcode.MINT_MONO_CMPXCHG_U2]: [WasmAtomicOpcode.i32_atomic_rmw16_cmpxchg_u, WasmOpcode.unreachable, 1], + [MintOpcode.MINT_MONO_CMPXCHG_I2]: [WasmAtomicOpcode.i32_atomic_rmw16_cmpxchg_u, WasmOpcode.i32_extend_16_s, 1], + [MintOpcode.MINT_MONO_CMPXCHG_I4]: [WasmAtomicOpcode.i32_atomic_rmw_cmpxchg, WasmOpcode.unreachable, 2], + [MintOpcode.MINT_MONO_CMPXCHG_I8]: [WasmAtomicOpcode.i64_atomic_rmw_cmpxchg, WasmOpcode.unreachable, 3], +}; + export const simdCreateSizes = { [MintOpcode.MINT_SIMD_V128_I1_CREATE]: 1, [MintOpcode.MINT_SIMD_V128_I2_CREATE]: 2, diff --git a/src/mono/browser/runtime/jiterpreter-trace-generator.ts b/src/mono/browser/runtime/jiterpreter-trace-generator.ts index e81c9b6683c..fb36b03e2cd 100644 --- a/src/mono/browser/runtime/jiterpreter-trace-generator.ts +++ b/src/mono/browser/runtime/jiterpreter-trace-generator.ts @@ -1,6 +1,7 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +import WasmEnableThreads from "consts:wasmEnableThreads"; import { MonoMethod } from "./types/internal"; import { NativePointer } from "./types/emscripten"; import { @@ -9,7 +10,7 @@ import { } from "./memory"; import { WasmOpcode, WasmSimdOpcode, WasmValtype, - getOpcodeName, MintOpArgType + getOpcodeName, MintOpArgType, WasmAtomicOpcode } from "./jiterpreter-opcodes"; import { MintOpcode, SimdInfo, @@ -38,7 +39,7 @@ import { traceEip, nullCheckValidation, traceNullCheckOptimizations, nullCheckCaching, defaultTraceBackBranches, - maxCallHandlerReturnAddresses, + maxCallHandlerReturnAddresses, moduleHeaderSizeMargin, mostRecentOptions, @@ -54,6 +55,7 @@ import { bitmaskTable, createScalarTable, simdExtractTable, simdReplaceTable, simdLoadTable, simdStoreTable, + xchgTable, cmpxchgTable, } from "./jiterpreter-tables"; import { mono_log_error, mono_log_info } from "./logging"; import { mono_assert, runtimeHelpers } from "./globals"; @@ -67,6 +69,11 @@ function getArgI16 (ip: MintOpcodePtr, indexPlusOne: number) { return getI16(ip + (2 * indexPlusOne)); } +function getArgU32 (ip: MintOpcodePtr, indexPlusOne: number) { + const src = ip + (2 * indexPlusOne); + return getU32_unaligned(src); +} + function getArgI32 (ip: MintOpcodePtr, indexPlusOne: number) { const src = ip + (2 * indexPlusOne); return getI32_unaligned(src); @@ -159,6 +166,52 @@ function get_known_constant_value (builder: WasmBuilder, localOffset: number): K return undefined; } +function getOpcodeLengthU16 (ip: MintOpcodePtr, opcode: MintOpcode) { + try { + const opLengthU16 = cwraps.mono_jiterp_get_opcode_info(opcode, OpcodeInfoType.Length); + let result = opLengthU16; + if (opcode === MintOpcode.MINT_SWITCH) { + // int n = READ32 (ip + 2); + // len = MINT_SWITCH_LEN (n); + const numDisplacements = getArgU32(ip, 2); + // #define MINT_SWITCH_LEN(n) (4 + (n) * 2) + result = 4 + (numDisplacements * 2); + } + return result; + } catch (err) { + mono_log_error(`Found invalid opcode ${opcode} at ip ${ip}`); + throw err; + } +} + +function decodeSwitch (ip: MintOpcodePtr) : MintOpcodePtr[] { + mono_assert(getU16(ip) === MintOpcode.MINT_SWITCH, "decodeSwitch called on a non-switch"); + const n = getArgU32(ip, 2); + const result = []; + /* + guint32 val = LOCAL_VAR (ip [1], guint32); + guint32 n = READ32 (ip + 2); + ip += 4; + if (val < n) { + ip += 2 * val; + int offset = READ32 (ip); + ip += offset; + } else { + ip += 2 * n; + } + */ + // mono_log_info(`switch[${n}] @${ip}`); + for (let i = 0; i < n; i++) { + const base = ip + 8 + (4 * i), + offset = getU32_unaligned(base), + target = base + (offset * 2); + // mono_log_info(` ${i} -> ${target}`); + result.push(target); + } + + return result; +} + // Perform a quick scan through the opcodes potentially in this trace to build a table of // backwards branch targets, compatible with the layout of the old one that was generated in C. // We do this here to match the exact way that the jiterp calculates branch targets, since @@ -178,52 +231,62 @@ export function generateBackwardBranchTable ( // IP of the current opcode in U16s, relative to startOfBody. This is what the back branch table uses const rip16 = (ip - startOfBody) / 2; const opcode = getU16(ip); - // HACK - if (opcode === MintOpcode.MINT_SWITCH) - break; + const opLengthU16 = getOpcodeLengthU16(ip, opcode); - const opLengthU16 = cwraps.mono_jiterp_get_opcode_info(opcode, OpcodeInfoType.Length); - // Any opcode with a branch argtype will have a decoded displacement, even if we don't - // implement the opcode. Everything else will return undefined here and be skipped - const displacement = getBranchDisplacement(ip, opcode); - if (typeof (displacement) !== "number") { - ip += (opLengthU16 * 2); - continue; - } - - // These checks shouldn't fail unless memory is corrupted or something is wrong with the decoder. - // We don't want to cause decoder bugs to make the application exit, though - graceful degradation. - if (displacement === 0) { - mono_log_info(`opcode @${ip} branch target is self. aborting backbranch table generation`); - break; - } + if (opcode === MintOpcode.MINT_SWITCH) { + // FIXME: Once the cfg supports back-branches in jump tables, uncomment this to + // insert the back-branch targets into the table so they'll actually work + /* + const switchTable = decodeSwitch(ip); + for (const target of switchTable) { + const rtarget16 = (target - startOfBody) / 2; + if (target < ip) + table.push(rtarget16); + } + */ + } else { + // Any opcode with a branch argtype will have a decoded displacement, even if we don't + // implement the opcode. Everything else will return undefined here and be skipped + const displacement = getBranchDisplacement(ip, opcode); + if (typeof (displacement) !== "number") { + ip += (opLengthU16 * 2); + continue; + } - // Only record *backward* branches - // We will filter this down further in the Cfg because it takes note of which branches it sees, - // but it is also beneficial to have a null table (further down) due to seeing no potential - // back branch targets at all, as it allows the Cfg to skip additional code generation entirely - // if it knows there will never be any backwards branches in a given trace - if (displacement < 0) { - const rtarget16 = rip16 + (displacement); - if (rtarget16 < 0) { - mono_log_info(`opcode @${ip}'s displacement of ${displacement} goes before body: ${rtarget16}. aborting backbranch table generation`); + // These checks shouldn't fail unless memory is corrupted or something is wrong with the decoder. + // We don't want to cause decoder bugs to make the application exit, though - graceful degradation. + if (displacement === 0) { + mono_log_info(`opcode @${ip} branch target is self. aborting backbranch table generation`); break; } - // If the relative target is before the start of the trace, don't record it. - // The trace will be unable to successfully branch to it so it would just make the table bigger. - if (rtarget16 >= rbase16) - table.push(rtarget16); - } + // Only record *backward* branches + // We will filter this down further in the Cfg because it takes note of which branches it sees, + // but it is also beneficial to have a null table (further down) due to seeing no potential + // back branch targets at all, as it allows the Cfg to skip additional code generation entirely + // if it knows there will never be any backwards branches in a given trace + if (displacement < 0) { + const rtarget16 = rip16 + (displacement); + if (rtarget16 < 0) { + mono_log_info(`opcode @${ip}'s displacement of ${displacement} goes before body: ${rtarget16}. aborting backbranch table generation`); + break; + } - switch (opcode) { - case MintOpcode.MINT_CALL_HANDLER: - case MintOpcode.MINT_CALL_HANDLER_S: - // While this formally isn't a backward branch target, we want to record - // the offset of its following instruction so that the jiterpreter knows - // to generate the necessary dispatch code to enable branching back to it. - table.push(rip16 + opLengthU16); - break; + // If the relative target is before the start of the trace, don't record it. + // The trace will be unable to successfully branch to it so it would just make the table bigger. + if (rtarget16 >= rbase16) + table.push(rtarget16); + } + + switch (opcode) { + case MintOpcode.MINT_CALL_HANDLER: + case MintOpcode.MINT_CALL_HANDLER_S: + // While this formally isn't a backward branch target, we want to record + // the offset of its following instruction so that the jiterpreter knows + // to generate the necessary dispatch code to enable branching back to it. + table.push(rip16 + opLengthU16); + break; + } } ip += (opLengthU16 * 2); @@ -244,7 +307,6 @@ export function generateWasmBody ( ): number { const abort = 0; let isFirstInstruction = true, isConditionallyExecuted = false, - containsSimd = false, pruneOpcodes = false, hasEmittedUnreachable = false; let result = 0, prologueOpcodeCounter = 0, @@ -275,10 +337,7 @@ export function generateWasmBody ( break; } - // HACK: Browsers set a limit of 4KB, we lower it slightly since a single opcode - // might generate a ton of code and we generate a bit of an epilogue after - // we finish - const maxBytesGenerated = 3840, + const maxBytesGenerated = builder.options.maxModuleSize - moduleHeaderSizeMargin, spaceLeft = maxBytesGenerated - builder.bytesGeneratedSoFar - builder.cfg.overheadBytes; if (builder.size >= spaceLeft) { // mono_log_info(`trace too big, estimated size is ${builder.size + builder.bytesGeneratedSoFar}`); @@ -297,7 +356,7 @@ export function generateWasmBody ( let opcode = getU16(ip); const numSregs = cwraps.mono_jiterp_get_opcode_info(opcode, OpcodeInfoType.Sregs), numDregs = cwraps.mono_jiterp_get_opcode_info(opcode, OpcodeInfoType.Dregs), - opLengthU16 = cwraps.mono_jiterp_get_opcode_info(opcode, OpcodeInfoType.Length); + opLengthU16 = getOpcodeLengthU16(ip, opcode); const isSimdIntrins = (opcode >= MintOpcode.MINT_SIMD_INTRINS_P_P) && (opcode <= MintOpcode.MINT_SIMD_INTRINS_P_PPP); @@ -380,15 +439,19 @@ export function generateWasmBody ( } switch (opcode) { + case MintOpcode.MINT_SWITCH: { + if (!emit_switch(builder, ip, exitOpcodeCounter)) + ip = abort; + break; + } case MintOpcode.MINT_NOP: { // This typically means the current opcode was disabled or pruned if (pruneOpcodes) { // We emit an unreachable opcode so that if execution somehow reaches a pruned opcode, we will abort // This should be impossible anyway but it's also useful to have pruning visible in the wasm - // FIXME: Ideally we would stop generating opcodes after the first unreachable, but that causes v8 to hang if (!hasEmittedUnreachable) builder.appendU8(WasmOpcode.unreachable); - // Each unreachable opcode could generate a bunch of native code in a bad wasm jit so generate nops after it + // Don't generate multiple unreachable opcodes in a row hasEmittedUnreachable = true; } break; @@ -403,7 +466,7 @@ export function generateWasmBody ( } case MintOpcode.MINT_LOCALLOC: { // dest - append_ldloca(builder, getArgU16(ip, 1)); + append_ldloca(builder, getArgU16(ip, 1), 0); // len append_ldloc(builder, getArgU16(ip, 2), WasmOpcode.i32_load); // frame @@ -584,10 +647,12 @@ export function generateWasmBody ( // locals[ip[1]] = &locals[ip[2]] const offset = getArgU16(ip, 2), flag = isAddressTaken(builder, offset), - destOffset = getArgU16(ip, 1); + destOffset = getArgU16(ip, 1), + // Size value stored for us by emit_compacted_instruction so we can do invalidation + size = getArgU16(ip, 3); if (!flag) mono_log_error(`${traceName}: Expected local ${offset} to have address taken flag`); - append_ldloca(builder, offset); + append_ldloca(builder, offset, size); append_stloc_tail(builder, destOffset, WasmOpcode.i32_store); // Record this ldloca as a known constant so that later uses of it turn into a lea, // and the wasm runtime can constant fold them with other constants. It's not uncommon @@ -811,9 +876,8 @@ export function generateWasmBody ( } case MintOpcode.MINT_LD_DELEGATE_METHOD_PTR: { - // FIXME: ldloca invalidation size - append_ldloca(builder, getArgU16(ip, 1), 8); - append_ldloca(builder, getArgU16(ip, 2), 8); + append_ldloca(builder, getArgU16(ip, 1), 4); + append_ldloca(builder, getArgU16(ip, 2), 4); builder.callImport("ld_del_ptr"); break; } @@ -1216,6 +1280,21 @@ export function generateWasmBody ( break; } + case MintOpcode.MINT_NEWARR: { + builder.block(); + append_ldloca(builder, getArgU16(ip, 1), 4); + const vtable = get_imethod_data(frame, getArgU16(ip, 3)); + builder.i32_const(vtable); + append_ldloc(builder, getArgU16(ip, 2), WasmOpcode.i32_load); + builder.callImport("newarr"); + // If the newarr operation succeeded, continue, otherwise bailout + builder.appendU8(WasmOpcode.br_if); + builder.appendULeb(0); + append_bailout(builder, ip, BailoutReason.AllocFailed); + builder.endBlock(); + break; + } + case MintOpcode.MINT_NEWOBJ_INLINED: { builder.block(); // MonoObject *o = mono_gc_alloc_obj (vtable, m_class_get_instance_size (vtable->klass)); @@ -1304,7 +1383,9 @@ export function generateWasmBody ( (builder.callHandlerReturnAddresses.length <= maxCallHandlerReturnAddresses) ) { // mono_log_info(`endfinally @0x${(ip).toString(16)}. return addresses:`, builder.callHandlerReturnAddresses.map(ra => (ra).toString(16))); - // FIXME: Clean this codegen up + // FIXME: Replace this with a chain of selects to more efficiently map from RA -> index, then + // a single jump table at the end to jump to the right place. This will generate much smaller + // code and be able to handle a larger number of return addresses. // Load ret_ip const clauseIndex = getArgU16(ip, 1), clauseDataOffset = get_imethod_clause_data_offset(frame, clauseIndex); @@ -1465,26 +1546,6 @@ export function generateWasmBody ( break; } - case MintOpcode.MINT_MONO_CMPXCHG_I4: - builder.local("pLocals"); - append_ldloc(builder, getArgU16(ip, 2), WasmOpcode.i32_load); // dest - append_ldloc(builder, getArgU16(ip, 3), WasmOpcode.i32_load); // newVal - append_ldloc(builder, getArgU16(ip, 4), WasmOpcode.i32_load); // expected - builder.callImport("cmpxchg_i32"); - append_stloc_tail(builder, getArgU16(ip, 1), WasmOpcode.i32_store); - break; - case MintOpcode.MINT_MONO_CMPXCHG_I8: - // because i64 values can't pass through JS cleanly (c.f getRawCwrap and - // EMSCRIPTEN_KEEPALIVE), we pass addresses of newVal, expected and the return value - // to the helper function. The "dest" for the compare-exchange is already a - // pointer, so load it normally - append_ldloc(builder, getArgU16(ip, 2), WasmOpcode.i32_load); // dest - append_ldloca(builder, getArgU16(ip, 3), 0); // newVal - append_ldloca(builder, getArgU16(ip, 4), 0); // expected - append_ldloca(builder, getArgU16(ip, 1), 8); // oldVal - builder.callImport("cmpxchg_i64"); - break; - case MintOpcode.MINT_LOG2_I4: case MintOpcode.MINT_LOG2_I8: { const isI64 = (opcode === MintOpcode.MINT_LOG2_I8); @@ -1647,13 +1708,19 @@ export function generateWasmBody ( (opcode >= MintOpcode.MINT_SIMD_V128_LDC) && (opcode <= MintOpcode.MINT_SIMD_INTRINS_P_PPP) ) { + builder.containsSimd = true; if (!emit_simd(builder, ip, opcode, opname, simdIntrinsArgCount, simdIntrinsIndex)) ip = abort; - else { - containsSimd = true; + else // We need to do dreg invalidation differently for simd, especially to handle ldc skipDregInvalidation = true; - } + } else if ( + (opcode >= MintOpcode.MINT_MONO_MEMORY_BARRIER) && + (opcode <= MintOpcode.MINT_MONO_CMPXCHG_I8) + ) { + builder.containsAtomics = true; + if (!emit_atomics(builder, ip, opcode)) + ip = abort; } else if (opcodeValue === 0) { // This means it was explicitly marked as no-value in the opcode value table // so we can just skip over it. This is done for things like nops. @@ -1740,7 +1807,7 @@ export function generateWasmBody ( // HACK: Traces containing simd will be *much* shorter than non-simd traces, // which will cause both the heuristic and our length requirement outside // to reject them. For now, just add a big constant to the length - if (containsSimd) + if (builder.containsSimd) result += 10240; return result; } @@ -1907,10 +1974,7 @@ function append_stloc_tail (builder: WasmBuilder, offset: number, opcodeOrPrefix // Pass bytesInvalidated=0 if you are reading from the local and the address will never be // used for writes -function append_ldloca (builder: WasmBuilder, localOffset: number, bytesInvalidated?: number) { - if (typeof (bytesInvalidated) !== "number") - bytesInvalidated = 512; - // FIXME: We need to know how big this variable is so we can invalidate the whole space it occupies +function append_ldloca (builder: WasmBuilder, localOffset: number, bytesInvalidated: number) { if (bytesInvalidated > 0) invalidate_local_range(localOffset, bytesInvalidated); builder.lea("pLocals", localOffset); @@ -2411,7 +2475,8 @@ function emit_sfieldop ( builder.ptr_const(pStaticData); // src append_ldloca(builder, localOffset, 0); - // FIXME: Use mono_gc_wbarrier_set_field_internal + // We don't need to use gc_wbarrier_set_field_internal here because there's no object + // reference, interp does a raw write builder.callImport("copy_ptr"); return true; case MintOpcode.MINT_LDSFLD_VT: { @@ -2838,7 +2903,6 @@ function emit_branch ( ); cwraps.mono_jiterp_boost_back_branch_target(destination); - // FIXME: Should there be a safepoint here? append_bailout(builder, destination, BailoutReason.BackwardBranch); modifyCounter(JiterpCounter.BackBranchesNotEmitted, 1); return true; @@ -3476,19 +3540,6 @@ function emit_arrayop (builder: WasmBuilder, frame: NativePointer, ip: MintOpcod return true; } -let wasmSimdSupported: boolean | undefined; - -function getIsWasmSimdSupported (): boolean { - if (wasmSimdSupported !== undefined) - return wasmSimdSupported; - - wasmSimdSupported = runtimeHelpers.featureWasmSimd === true; - if (!wasmSimdSupported) - mono_log_info("Disabling Jiterpreter SIMD"); - - return wasmSimdSupported; -} - function get_import_name ( builder: WasmBuilder, typeName: string, functionPtr: number @@ -3507,7 +3558,7 @@ function emit_simd ( ): boolean { // First, if compiling an intrinsic attempt to emit the special vectorized implementation // We only do this if SIMD is enabled since we'll be using the v128 opcodes. - if (builder.options.enableSimd && getIsWasmSimdSupported()) { + if (builder.options.enableSimd && runtimeHelpers.featureWasmSimd) { switch (argCount) { case 2: if (emit_simd_2(builder, ip, index)) @@ -3527,7 +3578,7 @@ function emit_simd ( // Fall back to a mix of non-vectorized wasm and the interpreter's implementation of the opcodes switch (opcode) { case MintOpcode.MINT_SIMD_V128_LDC: { - if (builder.options.enableSimd && getIsWasmSimdSupported()) { + if (builder.options.enableSimd && runtimeHelpers.featureWasmSimd) { builder.local("pLocals"); const view = localHeapViewU8().slice(ip + 4, ip + 4 + sizeOfV128); builder.v128_const(view); @@ -3963,3 +4014,102 @@ function emit_simd_4 (builder: WasmBuilder, ip: MintOpcodePtr, index: SimdIntrin return false; } } + +function emit_atomics ( + builder: WasmBuilder, ip: MintOpcodePtr, opcode: number +) { + if (opcode === MintOpcode.MINT_MONO_MEMORY_BARRIER) { + if (WasmEnableThreads) { + // Mono memory barriers use sync_synchronize which generates atomic.fence on clang, + // provided you pass -pthread at compile time + builder.appendAtomic(WasmAtomicOpcode.atomic_fence); + // The text format and other parts of the spec say atomic.fence has no operands, + // but the binary encoding contains a byte specifying whether the barrier is + // sequentially consistent (0) or acquire-release (1) + // Mono memory barriers are sync_synchronize which is sequentially consistent. + builder.appendU8(0); + } + return true; + } + + if (!builder.options.enableAtomics) + return false; + + // FIXME: We could probably unify most of the xchg/cmpxchg implementation into one implementation + + const xchg = xchgTable[opcode]; + if (xchg) { + const is64 = xchg[2] > 2; + // TODO: Generate alignment check to produce a better runtime error when address is not aligned? + builder.local("pLocals"); // stloc head + append_ldloc_cknull(builder, getArgU16(ip, 2), ip, true); // address + append_ldloc(builder, getArgU16(ip, 3), is64 ? WasmOpcode.i64_load : WasmOpcode.i32_load); // replacement + builder.appendAtomic(xchg[0], false); + builder.appendMemarg(0, xchg[2]); + // Fixup the result if necessary + if (xchg[1] !== WasmOpcode.unreachable) + builder.appendU8(xchg[1]); + // store old value + append_stloc_tail(builder, getArgU16(ip, 1), is64 ? WasmOpcode.i64_store : WasmOpcode.i32_store); + return true; + } + + const cmpxchg = cmpxchgTable[opcode]; + if (cmpxchg) { + const is64 = cmpxchg[2] > 2; + // TODO: Generate alignment check to produce a better runtime error when address is not aligned? + builder.local("pLocals"); // stloc head + append_ldloc_cknull(builder, getArgU16(ip, 2), ip, true); // address + // FIXME: Do these loads need to be sized? I think it's well-defined even if there are garbage bytes in the i32, + // based on language from the spec that looks like this: 'expected wrapped from i32 to i8, 8-bit compare equal' + append_ldloc(builder, getArgU16(ip, 4), is64 ? WasmOpcode.i64_load : WasmOpcode.i32_load); // expected + append_ldloc(builder, getArgU16(ip, 3), is64 ? WasmOpcode.i64_load : WasmOpcode.i32_load); // replacement + builder.appendAtomic(cmpxchg[0], false); + builder.appendMemarg(0, cmpxchg[2]); + // Fixup the result if necessary + if (cmpxchg[1] !== WasmOpcode.unreachable) + builder.appendU8(cmpxchg[1]); + // store old value + append_stloc_tail(builder, getArgU16(ip, 1), is64 ? WasmOpcode.i64_store : WasmOpcode.i32_store); + return true; + } + + return false; +} + +function emit_switch (builder: WasmBuilder, ip: MintOpcodePtr, exitOpcodeCounter: number) : boolean { + const lengthU16 = getOpcodeLengthU16(ip, MintOpcode.MINT_SWITCH), + table = decodeSwitch(ip); + let failed = false; + + if (table.length > builder.options.maxSwitchSize) { + failed = true; + } else { + // Record all the switch's forward branch targets. + // If it contains any back branches they will bailout at runtime. + for (const target of table) { + if (target > ip) + builder.branchTargets.add(target); + } + } + + if (failed) { + modifyCounter(JiterpCounter.SwitchTargetsFailed, table.length); + append_bailout(builder, ip, BailoutReason.SwitchSize); + return true; + } + + const fallthrough = ip + (lengthU16 * 2); + builder.branchTargets.add(fallthrough); + + // Jump table needs a block so it can `br 0` for missing targets + builder.block(); + // Load selector + append_ldloc(builder, getArgU16(ip, 1), WasmOpcode.i32_load); + // Dispatch + builder.cfg.jumpTable(table, fallthrough); + // Missing target + builder.endBlock(); + append_exit(builder, ip, exitOpcodeCounter, BailoutReason.SwitchTarget); + return true; +} diff --git a/src/mono/browser/runtime/jiterpreter.ts b/src/mono/browser/runtime/jiterpreter.ts index 1244b272b17..63855b69de8 100644 --- a/src/mono/browser/runtime/jiterpreter.ts +++ b/src/mono/browser/runtime/jiterpreter.ts @@ -73,13 +73,14 @@ export const useFullNames = false, // Use the mono_debug_count() API (set the COUNT=n env var) to limit the number of traces to compile useDebugCount = false, - // Web browsers limit synchronous module compiles to 4KB - maxModuleSize = 4080; + // Subtracted from the maxModuleSize option value to make space for a typical header + moduleHeaderSizeMargin = 300; export const callTargetCounts: { [method: number]: number } = {}; export let mostRecentTrace: InstrumentedTraceState | undefined; export let mostRecentOptions: JiterpreterOptions | undefined = undefined; +export let traceTableIsFull = false; // You can disable an opcode for debugging purposes by adding it to this list, // instead of aborting the trace it will insert a bailout instead. This means that you will @@ -272,6 +273,7 @@ function getTraceImports () { ["ckovr_u4", "overflow_check_i4", getRawCwrap("mono_jiterp_overflow_check_u4")], importDef("newobj_i", getRawCwrap("mono_jiterp_try_newobj_inlined")), importDef("newstr", getRawCwrap("mono_jiterp_try_newstr")), + importDef("newarr", getRawCwrap("mono_jiterp_try_newarr")), importDef("ld_del_ptr", getRawCwrap("mono_jiterp_ld_delegate_method_ptr")), importDef("ldtsflda", getRawCwrap("mono_jiterp_ldtsflda")), importDef("conv", getRawCwrap("mono_jiterp_conv")), @@ -284,8 +286,6 @@ function getTraceImports () { importDef("array_rank", getRawCwrap("mono_jiterp_get_array_rank")), ["a_elesize", "array_rank", getRawCwrap("mono_jiterp_get_array_element_size")], importDef("stfld_o", getRawCwrap("mono_jiterp_set_object_field")), - importDef("cmpxchg_i32", getRawCwrap("mono_jiterp_cas_i32")), - importDef("cmpxchg_i64", getRawCwrap("mono_jiterp_cas_i64")), ["stelemr_tc", "stelemr", getRawCwrap("mono_jiterp_stelem_ref")], importDef("fma", getRawCwrap("fma")), importDef("fmaf", getRawCwrap("fmaf")), @@ -467,6 +467,15 @@ function initialize_builder (builder: WasmBuilder) { }, WasmValtype.i32, true ); + builder.defineType( + "newarr", + { + "ppDestination": WasmValtype.i32, + "vtable": WasmValtype.i32, + "length": WasmValtype.i32, + }, + WasmValtype.i32, true + ); builder.defineType( "localloc", { @@ -630,25 +639,6 @@ function initialize_builder (builder: WasmBuilder) { }, WasmValtype.void, true ); - builder.defineType( - "cmpxchg_i32", - { - "dest": WasmValtype.i32, - "newVal": WasmValtype.i32, - "expected": WasmValtype.i32, - }, - WasmValtype.i32, true - ); - builder.defineType( - "cmpxchg_i64", - { - "dest": WasmValtype.i32, - "newVal": WasmValtype.i32, - "expected": WasmValtype.i32, - "oldVal": WasmValtype.i32, - }, - WasmValtype.void, true - ); builder.defineType( "stelemr", { @@ -850,7 +840,7 @@ function generate_wasm ( mono_log_info(`${((builder.base)).toString(16)} ${methodFullName || traceName} generated ${buffer.length} byte(s) of wasm`); modifyCounter(JiterpCounter.BytesGenerated, buffer.length); - if (buffer.length >= maxModuleSize) { + if (buffer.length >= builder.options.maxModuleSize) { mono_log_warn(`Jiterpreter generated too much code (${buffer.length} bytes) for trace ${traceName}. Please report this issue.`); return 0; } @@ -862,18 +852,6 @@ function generate_wasm ( // Get the exported trace function const fn = traceInstance.exports[traceName]; - // FIXME: Before threading can be supported, we will need to ensure that - // once we assign a function pointer index to a given trace, the trace is - // broadcast to all the JS workers and compiled + installed at the appropriate - // index in every worker's function pointer table. This also means that we - // would need to fill empty slots with a dummy function when growing the table - // so that any erroneous ENTERs will skip the opcode instead of crashing due - // to calling a null function pointer. - // Table grow operations will need to be synchronized between workers somehow, - // probably by storing the table size in a volatile global or something so that - // we know the range of indexes available to us and can ensure that threads - // independently jitting traces will not stomp on each other and all threads - // have a globally consistent view of which function pointer maps to each trace. rejected = false; let idx: number; @@ -883,6 +861,11 @@ function generate_wasm ( idx = presetFunctionPointer; } else { idx = addWasmFunctionPointer(JiterpreterTable.Trace, fn); + if (idx === 0) { + // Failed to add function pointer because trace table is full. Disable future + // trace generation to reduce CPU usage. + traceTableIsFull = true; + } } if (trace >= 2) mono_log_info(`${traceName} -> fn index ${idx}`); @@ -897,7 +880,12 @@ function generate_wasm ( } catch (exc: any) { threw = true; rejected = false; - mono_log_error(`${methodFullName || traceName} code generation failed: ${exc} ${exc.stack}`); + let desc = builder.containsSimd + ? " (simd)" + : ""; + if (builder.containsAtomics) + desc += " (atomics)"; + mono_log_error(`${methodFullName || traceName}${desc} code generation failed: ${exc} ${exc.stack}`); recordFailure(); return 0; } finally { @@ -930,7 +918,7 @@ function generate_wasm ( ; } - const buf = builder.getArrayView(); + const buf = builder.getArrayView(false, true); for (let i = 0; i < buf.length; i++) { const b = buf[i]; if (b < 0x10) @@ -996,11 +984,12 @@ export function mono_interp_tier_prepare_jiterpreter ( if (!mostRecentOptions) mostRecentOptions = getOptions(); - // FIXME: We shouldn't need this check if (!mostRecentOptions.enableTraces) return JITERPRETER_NOT_JITTED; else if (mostRecentOptions.wasmBytesLimit <= getCounter(JiterpCounter.BytesGenerated)) return JITERPRETER_NOT_JITTED; + else if (traceTableIsFull) + return JITERPRETER_NOT_JITTED; let info = traceInfo[index]; @@ -1098,7 +1087,9 @@ export function jiterpreter_dump_stats (concise?: boolean): void { traceCandidates = getCounter(JiterpCounter.TraceCandidates), bytesGenerated = getCounter(JiterpCounter.BytesGenerated), elapsedGenerationMs = getCounter(JiterpCounter.ElapsedGenerationMs), - elapsedCompilationMs = getCounter(JiterpCounter.ElapsedCompilationMs); + elapsedCompilationMs = getCounter(JiterpCounter.ElapsedCompilationMs), + switchTargetsOk = getCounter(JiterpCounter.SwitchTargetsOk), + switchTargetsFailed = getCounter(JiterpCounter.SwitchTargetsFailed); const backBranchHitRate = (backBranchesEmitted / (backBranchesEmitted + backBranchesNotEmitted)) * 100, tracesRejected = cwraps.mono_jiterp_get_rejected_trace_count(), @@ -1109,8 +1100,8 @@ export function jiterpreter_dump_stats (concise?: boolean): void { mostRecentOptions.directJitCalls ? `direct jit calls: ${directJitCallsCompiled} (${(directJitCallsCompiled / jitCallsCompiled * 100).toFixed(1)}%)` : "direct jit calls: off" ) : ""; - mono_log_info(`// jitted ${bytesGenerated} bytes; ${tracesCompiled} traces (${(tracesCompiled / traceCandidates * 100).toFixed(1)}%) (${tracesRejected} rejected); ${jitCallsCompiled} jit_calls; ${entryWrappersCompiled} interp_entries`); - mono_log_info(`// cknulls eliminated: ${nullChecksEliminatedText}, fused: ${nullChecksFusedText}; back-branches ${backBranchesEmittedText}; ${directJitCallsText}`); + mono_log_info(`// jitted ${bytesGenerated}b; ${tracesCompiled} traces (${(tracesCompiled / traceCandidates * 100).toFixed(1)}%) (${tracesRejected} rejected); ${jitCallsCompiled} jit_calls; ${entryWrappersCompiled} interp_entries`); + mono_log_info(`// cknulls pruned: ${nullChecksEliminatedText}, fused: ${nullChecksFusedText}; back-brs ${backBranchesEmittedText}; switch tgts ${switchTargetsOk}/${switchTargetsFailed + switchTargetsOk}; ${directJitCallsText}`); mono_log_info(`// time: ${elapsedGenerationMs | 0}ms generating, ${elapsedCompilationMs | 0}ms compiling wasm.`); if (concise) return; diff --git a/src/mono/browser/runtime/lazyLoading.ts b/src/mono/browser/runtime/lazyLoading.ts index f8c1a968dbf..9787c18ac33 100644 --- a/src/mono/browser/runtime/lazyLoading.ts +++ b/src/mono/browser/runtime/lazyLoading.ts @@ -53,7 +53,7 @@ export async function loadLazyAssembly (assemblyNameToLoad: string): Promise { const defaultConfigSrc = loaderHelpers.locateFile(module.configSrc!); diff --git a/src/mono/browser/runtime/loader/globals.ts b/src/mono/browser/runtime/loader/globals.ts index 12a731aee78..91e0a89f2c0 100644 --- a/src/mono/browser/runtime/loader/globals.ts +++ b/src/mono/browser/runtime/loader/globals.ts @@ -15,7 +15,7 @@ import { assertIsControllablePromise, createPromiseController, getPromiseControl import { mono_download_assets, resolve_single_asset_path, retrieve_asset_download } from "./assets"; import { mono_log_error, set_thread_prefix, setup_proxy_console } from "./logging"; import { invokeLibraryInitializers } from "./libraryInitializers"; -import { deep_merge_config } from "./config"; +import { deep_merge_config, isDebuggingSupported } from "./config"; import { logDownloadStatsToConsole, purgeUnusedCacheEntriesAsync } from "./assetsCache"; // if we are the first script loaded in the web worker, we are expected to become the sidecar @@ -128,6 +128,7 @@ export function setLoaderGlobals ( retrieve_asset_download, invokeLibraryInitializers, + isDebuggingSupported, // from wasm-feature-detect npm package exceptions, diff --git a/src/mono/browser/runtime/pinvoke.c b/src/mono/browser/runtime/pinvoke.c index eb422204826..c82033cd2d8 100644 --- a/src/mono/browser/runtime/pinvoke.c +++ b/src/mono/browser/runtime/pinvoke.c @@ -23,39 +23,71 @@ mono_wasm_pinvoke_vararg_stub (void) /* This is just a stub used to mark vararg pinvokes */ } +int +table_compare_name (const void *t1, const void *t2) +{ + return strcmp (((PinvokeTable*)t1)->name, ((PinvokeTable*)t2)->name); +} + void* wasm_dl_lookup_pinvoke_table (const char *name) { - for (int i = 0; i < sizeof (pinvoke_tables) / sizeof (void*); ++i) { - if (!strcmp (name, pinvoke_names [i])) - return pinvoke_tables [i]; - } - return NULL; + PinvokeImport needle = { name, NULL }; + return bsearch (&needle, pinvoke_tables, (sizeof (pinvoke_tables) / sizeof (PinvokeTable)), sizeof (PinvokeTable), table_compare_name); } int wasm_dl_is_pinvoke_table (void *handle) { - for (int i = 0; i < sizeof (pinvoke_tables) / sizeof (void*); ++i) { - if (pinvoke_tables [i] == handle) { + for (int i = 0; i < sizeof (pinvoke_tables) / sizeof (PinvokeTable); ++i) { + if (&pinvoke_tables[i] == handle) { return 1; } } return 0; } +static int +export_compare_key (const void *k1, const void *k2) +{ + return strcmp (((UnmanagedExport*)k1)->key, ((UnmanagedExport*)k2)->key); +} + +static int +export_compare_key_and_token (const void *k1, const void *k2) +{ + UnmanagedExport *e1 = (UnmanagedExport*)k1; + UnmanagedExport *e2 = (UnmanagedExport*)k2; + + // first compare by key + int compare = strcmp (e1->key, e2->key); + if (compare) + return compare; + + // then by token + return (int)(e1->token - e2->token); +} + void* -wasm_dl_get_native_to_interp (const char *key, void *extra_arg) +wasm_dl_get_native_to_interp (uint32_t token, const char *key, void *extra_arg) { #ifdef GEN_PINVOKE - for (int i = 0; i < sizeof (wasm_native_to_interp_map) / sizeof (void*); ++i) { - if (!strcmp (wasm_native_to_interp_map [i], key)) { - void *addr = wasm_native_to_interp_funcs [i]; - wasm_native_to_interp_ftndescs [i] = *(InterpFtnDesc*)extra_arg; - return addr; - } + UnmanagedExport needle = { key, token, NULL }; + int count = (sizeof (wasm_native_to_interp_table) / sizeof (UnmanagedExport)); + + // comparison must match the one used in the PInvokeTableGenerator to ensure the same order + UnmanagedExport *result = bsearch (&needle, wasm_native_to_interp_table, count, sizeof (UnmanagedExport), export_compare_key_and_token); + if (!result) { + // assembly may have been trimmed / modified, try to find by key only + result = bsearch (&needle, wasm_native_to_interp_table, count, sizeof (UnmanagedExport), export_compare_key); } - return NULL; + + if (!result) + return NULL; + + void *addr = result->func; + wasm_native_to_interp_ftndescs [result - wasm_native_to_interp_table] = *(InterpFtnDesc*)extra_arg; + return addr; #else return NULL; #endif diff --git a/src/mono/browser/runtime/pinvoke.h b/src/mono/browser/runtime/pinvoke.h index a89030d92f4..a2d32dfa2c9 100644 --- a/src/mono/browser/runtime/pinvoke.h +++ b/src/mono/browser/runtime/pinvoke.h @@ -8,6 +8,18 @@ typedef struct { void *func; } PinvokeImport; +typedef struct { + const char *name; + PinvokeImport *imports; + int count; +} PinvokeTable; + +typedef struct { + const char *key; + uint32_t token; + void *func; +} UnmanagedExport; + typedef struct { void *func; void *arg; @@ -20,7 +32,7 @@ int wasm_dl_is_pinvoke_table (void *handle); void* -wasm_dl_get_native_to_interp (const char *key, void *extra_arg); +wasm_dl_get_native_to_interp (uint32_t token, const char *key, void *extra_arg); void mono_wasm_pinvoke_vararg_stub (void); @@ -45,6 +57,6 @@ double mono_wasm_interp_method_args_get_darg (MonoInterpMethodArguments *margs, int i); void* -mono_wasm_interp_method_args_get_retval (MonoInterpMethodArguments *margs); +mono_wasm_interp_method_args_get_retval (MonoInterpMethodArguments *margs); #endif diff --git a/src/mono/browser/runtime/profiler.ts b/src/mono/browser/runtime/profiler.ts index a223a7fdbf4..0829b3ec71a 100644 --- a/src/mono/browser/runtime/profiler.ts +++ b/src/mono/browser/runtime/profiler.ts @@ -2,7 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. import { ENVIRONMENT_IS_WEB, mono_assert, runtimeHelpers } from "./globals"; -import { MonoMethod, AOTProfilerOptions, BrowserProfilerOptions } from "./types/internal"; +import { MonoMethod, AOTProfilerOptions, BrowserProfilerOptions, LogProfilerOptions } from "./types/internal"; import { profiler_c_functions as cwraps } from "./cwraps"; import { utf8ToString } from "./strings"; @@ -34,6 +34,12 @@ export function mono_wasm_init_browser_profiler (options: BrowserProfilerOptions cwraps.mono_wasm_profiler_init_browser(arg); } +export function mono_wasm_init_log_profiler (options: LogProfilerOptions): void { + mono_assert(runtimeHelpers.emscriptenBuildOptions.enableLogProfiler, "Log profiler is not enabled, please use log; in your project file."); + mono_assert(options.takeHeapshot, "Log profiler is not enabled, the takeHeapshot method must be defined in LogProfilerOptions.takeHeapshot"); + cwraps.mono_wasm_profiler_init_log( (options.configuration || "log:alloc,output=output.mlpd") + `,take-heapshot-method=${options.takeHeapshot}`); +} + export const enum MeasuredBlock { emscriptenStartup = "mono.emscriptenStartup", instantiateWasm = "mono.instantiateWasm", diff --git a/src/mono/browser/runtime/runtime.c b/src/mono/browser/runtime/runtime.c index 2cf5b7605a5..7e8851fcd6b 100644 --- a/src/mono/browser/runtime/runtime.c +++ b/src/mono/browser/runtime/runtime.c @@ -199,29 +199,43 @@ init_icall_table (void) static void* get_native_to_interp (MonoMethod *method, void *extra_arg) { - void *addr; - + void *addr = NULL; MONO_ENTER_GC_UNSAFE; MonoClass *klass = mono_method_get_class (method); MonoImage *image = mono_class_get_image (klass); MonoAssembly *assembly = mono_image_get_assembly (image); MonoAssemblyName *aname = mono_assembly_get_name (assembly); const char *name = mono_assembly_name_get_name (aname); + const char *namespace = mono_class_get_namespace (klass); const char *class_name = mono_class_get_name (klass); const char *method_name = mono_method_get_name (method); - char key [128]; + MonoMethodSignature *sig = mono_method_signature (method); + uint32_t param_count = mono_signature_get_param_count (sig); + uint32_t token = mono_method_get_token (method); + + char buf [128]; + char *key = buf; int len; + if (name != NULL) { + // the key must match the one used in PInvokeTableGenerator + len = snprintf (key, sizeof(buf), "%s#%d:%s:%s:%s", method_name, param_count, name, namespace, class_name); + + if (len >= sizeof (buf)) { + // The key is too long, try again with a larger buffer + key = g_new (char, len + 1); + snprintf (key, len + 1, "%s#%d:%s:%s:%s", method_name, param_count, name, namespace, class_name); + } - assert (strlen (name) < 100); - snprintf (key, sizeof(key), "%s_%s_%s", name, class_name, method_name); - char *fixedName = mono_fixup_symbol_name ("", key, ""); - addr = wasm_dl_get_native_to_interp (fixedName, extra_arg); - free (fixedName); + addr = wasm_dl_get_native_to_interp (token, key, extra_arg); + + if (key != buf) + free (key); + } MONO_EXIT_GC_UNSAFE; return addr; } -static void *sysglobal_native_handle; +static void *sysglobal_native_handle = (void *)0xDeadBeef; static void* wasm_dl_load (const char *name, int flags, char **err, void *user_data) @@ -248,24 +262,33 @@ wasm_dl_load (const char *name, int flags, char **err, void *user_data) return NULL; } +int +import_compare_name (const void *k1, const void *k2) +{ + const PinvokeImport *e1 = (const PinvokeImport*)k1; + const PinvokeImport *e2 = (const PinvokeImport*)k2; + + return strcmp (e1->name, e2->name); +} + static void* wasm_dl_symbol (void *handle, const char *name, char **err, void *user_data) { - if (handle == sysglobal_native_handle) - assert (0); + assert (handle != sysglobal_native_handle); #if WASM_SUPPORTS_DLOPEN if (!wasm_dl_is_pinvoke_tables (handle)) { return dlsym (handle, name); } #endif - - PinvokeImport *table = (PinvokeImport*)handle; - for (int i = 0; table [i].name; ++i) { - if (!strcmp (table [i].name, name)) - return table [i].func; - } - return NULL; + PinvokeTable* index = (PinvokeTable*)handle; + PinvokeImport key = { name, NULL }; + PinvokeImport* result = (PinvokeImport *)bsearch(&key, index->imports, index->count, sizeof(PinvokeImport), import_compare_name); + if (!result) { + // *err = g_strdup_printf ("Symbol not found: %s", name); + return NULL; + } + return result->func; } MonoDomain * @@ -363,6 +386,28 @@ mono_wasm_assembly_find_method (MonoClass *klass, const char *name, int argument return result; } +MonoMethod* +mono_wasm_get_method_matching (MonoImage *image, uint32_t token, MonoClass *klass, const char* name, int param_count) +{ + MonoMethod *result = NULL; + MONO_ENTER_GC_UNSAFE; + MonoMethod *method = mono_get_method (image, token, klass); + MonoMethodSignature *sig = mono_method_signature (method); + // Lookp by token but verify the name and param count in case assembly was trimmed + if (mono_signature_get_param_count (sig) == param_count) { + const char *method_name = mono_method_get_name (method); + if (!strcmp (method_name, name)) { + result = method; + } + } + // If the token lookup failed, try to find the method by name and param count + if (!result) { + result = mono_class_get_method_from_name (klass, name, param_count); + } + MONO_EXIT_GC_UNSAFE; + return result; +} + /* * mono_wasm_marshal_get_managed_wrapper: * Creates a wrapper for a function pointer to a method marked with @@ -370,17 +415,21 @@ mono_wasm_assembly_find_method (MonoClass *klass, const char *name, int argument * This wrapper ensures that the interpreter initializes the pointers. */ void -mono_wasm_marshal_get_managed_wrapper (const char* assemblyName, const char* namespaceName, const char* typeName, const char* methodName, int num_params) +mono_wasm_marshal_get_managed_wrapper (const char* assemblyName, const char* namespaceName, const char* typeName, const char* methodName, uint32_t token, int param_count) { MonoError error; mono_error_init (&error); + MONO_ENTER_GC_UNSAFE; MonoAssembly* assembly = mono_wasm_assembly_load (assemblyName); assert (assembly); - MonoClass* class = mono_wasm_assembly_find_class (assembly, namespaceName, typeName); - assert (class); - MonoMethod* method = mono_wasm_assembly_find_method (class, methodName, num_params); + MonoImage *image = mono_assembly_get_image (assembly); + assert (image); + MonoClass* klass = mono_class_from_name (image, namespaceName, typeName); + assert (klass); + MonoMethod *method = mono_wasm_get_method_matching (image, token, klass, methodName, param_count); assert (method); MonoMethod *managedWrapper = mono_marshal_get_managed_wrapper (method, NULL, 0, &error); assert (managedWrapper); mono_compile_method (managedWrapper); -} + MONO_EXIT_GC_UNSAFE; +} \ No newline at end of file diff --git a/src/mono/browser/runtime/runtime.h b/src/mono/browser/runtime/runtime.h index f630762ded2..e8591d0a19e 100644 --- a/src/mono/browser/runtime/runtime.h +++ b/src/mono/browser/runtime/runtime.h @@ -19,7 +19,7 @@ MonoDomain *mono_wasm_load_runtime_common (int debug_level, MonoLogCallback log_ MonoAssembly *mono_wasm_assembly_load (const char *name); MonoClass *mono_wasm_assembly_find_class (MonoAssembly *assembly, const char *namespace, const char *name); MonoMethod *mono_wasm_assembly_find_method (MonoClass *klass, const char *name, int arguments); -void mono_wasm_marshal_get_managed_wrapper (const char* assemblyName, const char* namespaceName, const char* typeName, const char* methodName, int num_params); +void mono_wasm_marshal_get_managed_wrapper (const char* assemblyName, const char* namespaceName, const char* typeName, const char* methodName, uint32_t token, int param_count); int initialize_runtime (); #endif diff --git a/src/mono/browser/runtime/startup.ts b/src/mono/browser/runtime/startup.ts index cbca10e5a75..ab8d7e7ce9e 100644 --- a/src/mono/browser/runtime/startup.ts +++ b/src/mono/browser/runtime/startup.ts @@ -11,7 +11,7 @@ import { exportedRuntimeAPI, INTERNAL, loaderHelpers, Module, runtimeHelpers, cr import cwraps, { init_c_exports, threads_c_functions as tcwraps } from "./cwraps"; import { mono_wasm_raise_debug_event, mono_wasm_runtime_ready } from "./debug"; import { toBase64StringImpl } from "./base64"; -import { mono_wasm_init_aot_profiler, mono_wasm_init_browser_profiler } from "./profiler"; +import { mono_wasm_init_aot_profiler, mono_wasm_init_browser_profiler, mono_wasm_init_log_profiler } from "./profiler"; import { initialize_marshalers_to_cs } from "./marshal-to-cs"; import { initialize_marshalers_to_js } from "./marshal-to-js"; import { init_polyfills_async } from "./polyfills"; @@ -130,6 +130,9 @@ async function instantiateWasmWorker ( successCallback: InstantiateWasmSuccessCallback ): Promise { if (!WasmEnableThreads) return; + + await ensureUsedWasmFeatures(); + // wait for the config to arrive by message from the main thread await loaderHelpers.afterConfigLoaded.promise; @@ -330,9 +333,7 @@ async function onRuntimeInitializedAsync (userOnRuntimeInitialized: () => void) runtimeList.registerRuntime(exportedRuntimeAPI); - if (loaderHelpers.config.debugLevel !== 0 && !runtimeHelpers.mono_wasm_runtime_is_ready) { - mono_wasm_runtime_ready(); - } + if (!runtimeHelpers.mono_wasm_runtime_is_ready) mono_wasm_runtime_ready(); if (loaderHelpers.config.debugLevel !== 0 && loaderHelpers.config.cacheBootResources) { loaderHelpers.logDownloadStatsToConsole(); @@ -552,6 +553,9 @@ export async function start_runtime () { if (runtimeHelpers.config.browserProfilerOptions) mono_wasm_init_browser_profiler(runtimeHelpers.config.browserProfilerOptions); + if (runtimeHelpers.config.logProfilerOptions) + mono_wasm_init_log_profiler(runtimeHelpers.config.logProfilerOptions); + if (WasmEnableThreads) { // this is not mono-attached thread, so we can start it earlier await mono_wasm_init_diagnostics(); @@ -614,6 +618,9 @@ export function mono_wasm_load_runtime (): void { debugLevel = 0 + debugLevel; } } + if (!loaderHelpers.isDebuggingSupported() || !runtimeHelpers.config.resources!.pdb) { + debugLevel = 0; + } cwraps.mono_wasm_load_runtime(debugLevel); endMeasure(mark, MeasuredBlock.loadRuntime); diff --git a/src/mono/browser/runtime/types/internal.ts b/src/mono/browser/runtime/types/internal.ts index 4ec8ced41c3..2b2792056a8 100644 --- a/src/mono/browser/runtime/types/internal.ts +++ b/src/mono/browser/runtime/types/internal.ts @@ -77,6 +77,7 @@ export type MonoConfigInternal = MonoConfig & { assets?: AssetEntryInternal[], runtimeOptions?: string[], // array of runtime options as strings aotProfilerOptions?: AOTProfilerOptions, // dictionary-style Object. If omitted, aot profiler will not be initialized. + logProfilerOptions?: LogProfilerOptions, // dictionary-style Object. If omitted, log profiler will not be initialized. browserProfilerOptions?: BrowserProfilerOptions, // dictionary-style Object. If omitted, browser profiler will not be initialized. waitForDebugger?: number, appendElementOnExit?: boolean @@ -172,6 +173,7 @@ export type LoaderHelpers = { invokeLibraryInitializers: (functionName: string, args: any[]) => Promise, libraryInitializers?: { scriptName: string, exports: any }[]; + isDebuggingSupported(): boolean, isChromium: boolean, isFirefox: boolean @@ -273,6 +275,11 @@ export type AOTProfilerOptions = { export type BrowserProfilerOptions = { } +export type LogProfilerOptions = { + takeHeapshot?: string, + configuration?: string // log profiler options string" +} + // how we extended emscripten Module export type DotnetModule = EmscriptenModule & DotnetModuleConfig; export type DotnetModuleInternal = EmscriptenModule & DotnetModuleConfig & EmscriptenModuleInternal; @@ -289,6 +296,7 @@ export type EmscriptenBuildOptions = { wasmEnableEH: boolean, enableAotProfiler: boolean, enableBrowserProfiler: boolean, + enableLogProfiler: boolean, runAOTCompilation: boolean, wasmEnableThreads: boolean, gitHash: string, diff --git a/src/mono/mono.proj b/src/mono/mono.proj index 5be3d221fd5..8fe15830cab 100644 --- a/src/mono/mono.proj +++ b/src/mono/mono.proj @@ -1185,6 +1185,9 @@ JS_ENGINES = [NODE_JS] <_MonoRuntimeArtifacts Condition="'$(TargetsBrowser)' == 'true' and '$(BuildMonoAOTCrossCompilerOnly)' != 'true'" Include="$(MonoObjDir)out\lib\libmono-profiler-aot.a"> $(RuntimeBinDir)libmono-profiler-aot.a + <_MonoRuntimeArtifacts Condition="'$(TargetsBrowser)' == 'true' and '$(BuildMonoAOTCrossCompilerOnly)' != 'true'" Include="$(MonoObjDir)out\lib\libmono-profiler-log.a"> + $(RuntimeBinDir)libmono-profiler-log.a + <_MonoRuntimeArtifacts Condition="'$(TargetsBrowser)' == 'true' and '$(BuildMonoAOTCrossCompilerOnly)' != 'true'" Include="$(MonoObjDir)out\lib\libmono-profiler-browser.a"> $(RuntimeBinDir)libmono-profiler-browser.a diff --git a/src/mono/mono/arch/amd64/amd64-codegen.h b/src/mono/mono/arch/amd64/amd64-codegen.h index e20e43357ce..f4d048e3c4d 100644 --- a/src/mono/mono/arch/amd64/amd64-codegen.h +++ b/src/mono/mono/arch/amd64/amd64-codegen.h @@ -1216,12 +1216,42 @@ typedef union { #define amd64_prefix_size(inst,p,size) do { x86_prefix((inst), p); } while (0) #define amd64_rdtsc_size(inst,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_rdtsc(inst); amd64_codegen_post(inst); } while (0) +// FIXME: wrong for size == 1 or 2 #define amd64_cmpxchg_reg_reg_size(inst,dreg,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(dreg),0,(reg)); x86_cmpxchg_reg_reg((inst),((dreg)&0x7),((reg)&0x7)); amd64_codegen_post(inst); } while (0) +// FIXME: wrong for size == 1 or 2 #define amd64_cmpxchg_mem_reg_size(inst,mem,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_cmpxchg_mem_reg((inst),(mem),((reg)&0x7)); amd64_codegen_post(inst); } while (0) -#define amd64_cmpxchg_membase_reg_size(inst,basereg,disp,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(reg),0,(basereg)); x86_cmpxchg_membase_reg((inst),((basereg)&0x7),(disp),((reg)&0x7)); amd64_codegen_post(inst); } while (0) + +#define amd64_cmpxchg_membase_reg_size(inst,basereg,disp,reg,size) \ + do { \ + amd64_codegen_pre(inst); \ + if ((size) == 2) \ + x86_prefix((inst), X86_OPERAND_PREFIX); \ + amd64_emit_rex ((inst),(size),(reg),0,(basereg)); \ + switch ((size)) { \ + case 1: x86_byte((inst), 0x0f); x86_byte((inst), 0xb0); break; \ + case 2: case 4: case 8: x86_byte((inst), 0x0f); x86_byte((inst), 0xb1); break; \ + default: assert (0); \ + }\ + x86_membase_emit((inst),((reg)&0x7),((basereg)&0x7),(disp)); \ + amd64_codegen_post(inst); \ + } while (0) #define amd64_xchg_reg_reg_size(inst,dreg,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(dreg),0,(reg)); x86_xchg_reg_reg((inst),((dreg)&0x7),((reg)&0x7),(size) == 8 ? 4 : (size)); amd64_codegen_post(inst); } while (0) #define amd64_xchg_mem_reg_size(inst,mem,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_xchg_mem_reg((inst),(mem),((reg)&0x7),(size) == 8 ? 4 : (size)); amd64_codegen_post(inst); } while (0) -#define amd64_xchg_membase_reg_size(inst,basereg,disp,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),(reg),0,(basereg)); x86_xchg_membase_reg((inst),((basereg)&0x7),(disp),((reg)&0x7),(size) == 8 ? 4 : (size)); amd64_codegen_post(inst); } while (0) +#define amd64_xchg_membase_reg_size(inst,basereg,disp,reg,size) \ + do { \ + amd64_codegen_pre(inst); \ + if ((size) == 2) \ + x86_prefix((inst), X86_OPERAND_PREFIX); \ + amd64_emit_rex ((inst),(size),(reg),0,(basereg)); \ + switch ((size)) { \ + case 1: x86_byte ((inst), 0x86); break; \ + case 2: case 4: case 8: x86_byte ((inst), 0x87); break; \ + default: assert (0); \ + } \ + x86_membase_emit ((inst), ((reg)&0x7), ((basereg)&0x7), (disp)); \ + amd64_codegen_post(inst); \ + } while (0) + #define amd64_inc_mem_size(inst,mem,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,0); x86_inc_mem((inst),(mem)); amd64_codegen_post(inst); } while (0) #define amd64_inc_membase_size(inst,basereg,disp,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(basereg)); x86_inc_membase((inst),((basereg)&0x7),(disp)); amd64_codegen_post(inst); } while (0) //#define amd64_inc_reg_size(inst,reg,size) do { amd64_codegen_pre(inst); amd64_emit_rex ((inst),(size),0,0,(reg)); x86_inc_reg((inst),((reg)&0x7)); amd64_codegen_post(inst); } while (0) diff --git a/src/mono/mono/arch/arm64/arm64-codegen.h b/src/mono/mono/arch/arm64/arm64-codegen.h index f749f5be8ef..67af335893d 100644 --- a/src/mono/mono/arch/arm64/arm64-codegen.h +++ b/src/mono/mono/arch/arm64/arm64-codegen.h @@ -454,6 +454,8 @@ MONO_RESTORE_WARNING #define arm_stlxrx(p, rs, rt, rn) arm_format_stlxr ((p), 0x3, (rs), (rn), (rt)) #define arm_stlxrw(p, rs, rt, rn) arm_format_stlxr ((p), 0x2, (rs), (rn), (rt)) +#define arm_stlxrh(p, rs, rt, rn) arm_format_stlxr ((p), 0x1, (rs), (rn), (rt)) +#define arm_stlxrb(p, rs, rt, rn) arm_format_stlxr ((p), 0x0, (rs), (rn), (rt)) /* Load/Store SIMD&FP */ diff --git a/src/mono/mono/component/debugger-agent.c b/src/mono/mono/component/debugger-agent.c index 8c49ea7a92f..1de2a9e18b6 100644 --- a/src/mono/mono/component/debugger-agent.c +++ b/src/mono/mono/component/debugger-agent.c @@ -5696,8 +5696,7 @@ decode_value_internal (MonoType *t, int type, MonoDomain *domain, guint8 *addr, { ErrorCode err; - if (m_type_is_byref (t)) { - g_assert (extra_space != NULL && *extra_space != NULL); + if (m_type_is_byref (t) && extra_space != NULL && *extra_space != NULL) { *(guint8**)addr = *extra_space; //assign the extra_space allocated for byref fields to the addr guint8 *buf_int = buf; addr = *(guint8**)addr; //dereference the pointer as it's a byref field @@ -10530,8 +10529,9 @@ object_commands (int command, guint8 *p, guint8 *end, Buffer *buf) break; } } - - while ((f = mono_class_get_fields_internal (k, &iter))) { + //Above for loop might end if 'k' is null , ensure 'k' is not + //null before passing it to mono_class_get_fields_internal to avoid crash + while (k && (f = mono_class_get_fields_internal (k, &iter))) { if (mono_class_get_field_token (f) == field_token) { goto get_field_value; } diff --git a/src/mono/mono/metadata/bundled-resources.c b/src/mono/mono/metadata/bundled-resources.c index 17ddedb19c0..56a3153f0c3 100644 --- a/src/mono/mono/metadata/bundled-resources.c +++ b/src/mono/mono/metadata/bundled-resources.c @@ -78,11 +78,16 @@ bundled_resources_is_known_assembly_extension (const char *ext) static char * key_from_id (const char *id, char *buffer, guint buffer_len) { - size_t id_length = strlen (id), - extension_offset = -1; - const char *extension = g_memrchr (id, '.', id_length); - if (extension) - extension_offset = extension - id; + size_t id_length = 0; + size_t extension_offset = -1; + const char *extension = NULL; + + if (id){ + id_length = strlen (id); + extension = g_memrchr (id, '.', id_length); + if (extension) + extension_offset = extension - id; + } if (!buffer) { // Add space for .dll and null terminator buffer_len = (guint)(id_length + 6); @@ -90,7 +95,7 @@ key_from_id (const char *id, char *buffer, guint buffer_len) } buffer[0] = 0; - if (extension_offset && bundled_resources_is_known_assembly_extension (extension)) { + if (extension_offset >= 0 && bundled_resources_is_known_assembly_extension (extension)) { // Subtract from buffer_len to make sure we have space for .dll g_strlcpy (buffer, id, MIN(buffer_len - 4, extension_offset + 2)); strcat (buffer, "dll"); @@ -152,6 +157,9 @@ mono_bundled_resources_add (MonoBundledResource **resources_to_bundle, uint32_t for (uint32_t i = 0; i < len; ++i) { MonoBundledResource *resource_to_bundle = (MonoBundledResource *)resources_to_bundle[i]; + + g_assert (resource_to_bundle->id); + if (resource_to_bundle->type == MONO_BUNDLED_ASSEMBLY) assemblyAdded = true; diff --git a/src/mono/mono/metadata/class-init.c b/src/mono/mono/metadata/class-init.c index 76459536c24..91f40403346 100644 --- a/src/mono/mono/metadata/class-init.c +++ b/src/mono/mono/metadata/class-init.c @@ -310,6 +310,10 @@ mono_class_setup_fields (MonoClass *klass) /* Get the real size */ explicit_size = mono_metadata_packing_from_typedef (klass->image, klass->type_token, &packing_size, &real_size); + + if (real_size > GINT32_TO_UINT32(INT32_MAX - MONO_ABI_SIZEOF (MonoObject))) + mono_class_set_type_load_failure (klass, "Can't load type %s. The size is too big.", m_class_get_name (klass)); + if (explicit_size) instance_size += real_size; @@ -2322,7 +2326,12 @@ mono_class_layout_fields (MonoClass *klass, int base_instance_size, int packing_ } /*TypeBuilders produce all sort of weird things*/ g_assert (image_is_dynamic (klass->image) || field_offsets [i] > 0); - real_size = field_offsets [i] + size; + + gint64 raw_real_size = (gint64)field_offsets [i] + size; + real_size = (gint32)raw_real_size; + + if (real_size != raw_real_size) + mono_class_set_type_load_failure (klass, "Can't load type %s. The size is too big.", m_class_get_name (klass)); } instance_size = MAX (real_size, instance_size); @@ -2381,7 +2390,13 @@ mono_class_layout_fields (MonoClass *klass, int base_instance_size, int packing_ /* * Calc max size. */ - real_size = MAX (real_size, size + field_offsets [i]); + gint64 raw_real_size = (gint64)field_offsets [i] + size; + gint32 real_size_cast = (gint32)raw_real_size; + + if (real_size_cast != raw_real_size) + mono_class_set_type_load_failure (klass, "Can't load type %s. The size is too big.", m_class_get_name (klass)); + + real_size = MAX (real_size, real_size_cast); } /* check for incorrectly aligned or overlapped by a non-object field */ @@ -2529,8 +2544,8 @@ mono_class_layout_fields (MonoClass *klass, int base_instance_size, int packing_ } } - /*valuetypes can't be neither bigger than 1Mb or empty. */ - if (klass->valuetype && (klass->instance_size <= 0 || klass->instance_size > (0x100000 + MONO_ABI_SIZEOF (MonoObject)))) { + /*valuetypes can not be size 0 or bigger than 2gb. */ + if (klass->valuetype && (klass->instance_size <= 0 || klass->instance_size > INT32_MAX)) { /* Special case compiler generated types */ /* Hard to check for [CompilerGenerated] here */ if (!strstr (klass->name, "StaticArrayInitTypeSize") && !strstr (klass->name, "$ArrayType")) diff --git a/src/mono/mono/metadata/class.c b/src/mono/mono/metadata/class.c index 834cf8688cd..abd0948e3a2 100644 --- a/src/mono/mono/metadata/class.c +++ b/src/mono/mono/metadata/class.c @@ -870,6 +870,31 @@ inflate_generic_type (MonoImage *image, MonoType *type, MonoGenericContext *cont nt->data.type = inflated; return nt; } + case MONO_TYPE_FNPTR: { + MonoMethodSignature *in_sig = type->data.method; + // quick bail out - if there are no type variables anywhere in the signature, + // there's nothing that could get inflated. + if (!in_sig->has_type_parameters) { + if (!changed) + return NULL; + else + return type; + } + MonoMethodSignature *new_sig = mono_inflate_generic_signature (in_sig, context, error); + if ((!new_sig && !changed) || !is_ok (error)) { + return NULL; + } else if (!new_sig && changed) + return type; + if (new_sig == in_sig) { + if (!changed) + return NULL; + else + return type; + } + MonoType *nt = mono_metadata_type_dup (image, type); + nt->data.method = new_sig; + return nt; + } default: if (!changed) return NULL; diff --git a/src/mono/mono/metadata/gc.c b/src/mono/mono/metadata/gc.c index b46971f1a9a..5ef0faa9f80 100644 --- a/src/mono/mono/metadata/gc.c +++ b/src/mono/mono/metadata/gc.c @@ -694,8 +694,8 @@ mono_gc_finalize_notify (void) if (mono_gc_is_null ()) return; -#if defined(HOST_WASI) - // TODO: Schedule the background job on WASI. Threads aren't yet supported in this build. +#if defined(HOST_WASI) && defined(DISABLE_THREADS) + mono_runtime_do_background_work (); #elif defined(HOST_WASM) && defined(DISABLE_THREADS) mono_main_thread_schedule_background_job (mono_runtime_do_background_work); #else diff --git a/src/mono/mono/metadata/icall-def.h b/src/mono/mono/metadata/icall-def.h index ad7044a0843..c6e2b73218a 100644 --- a/src/mono/mono/metadata/icall-def.h +++ b/src/mono/mono/metadata/icall-def.h @@ -555,7 +555,6 @@ ICALL_TYPE(ILOCK, "System.Threading.Interlocked", ILOCK_1) NOHANDLES(ICALL(ILOCK_1, "Add(int&,int)", ves_icall_System_Threading_Interlocked_Add_Int)) NOHANDLES(ICALL(ILOCK_2, "Add(long&,long)", ves_icall_System_Threading_Interlocked_Add_Long)) NOHANDLES(ICALL(ILOCK_5, "CompareExchange(int&,int,int)", ves_icall_System_Threading_Interlocked_CompareExchange_Int)) -NOHANDLES(ICALL(ILOCK_6, "CompareExchange(int&,int,int,bool&)", ves_icall_System_Threading_Interlocked_CompareExchange_Int_Success)) NOHANDLES(ICALL(ILOCK_8, "CompareExchange(long&,long,long)", ves_icall_System_Threading_Interlocked_CompareExchange_Long)) NOHANDLES(ICALL(ILOCK_9, "CompareExchange(object&,object&,object&,object&)", ves_icall_System_Threading_Interlocked_CompareExchange_Object)) NOHANDLES(ICALL(ILOCK_11, "Decrement(int&)", ves_icall_System_Threading_Interlocked_Decrement_Int)) diff --git a/src/mono/mono/metadata/marshal.c b/src/mono/mono/metadata/marshal.c index 5e8fcc4dfd4..0ad51eae802 100644 --- a/src/mono/mono/metadata/marshal.c +++ b/src/mono/mono/metadata/marshal.c @@ -3963,7 +3963,7 @@ mono_marshal_get_native_func_wrapper_indirect (MonoClass *caller_class, MonoMeth return res; char *name = mono_signature_to_name (sig, "wrapper_native_indirect"); - MonoMethodBuilder *mb = mono_mb_new (caller_class, name, MONO_WRAPPER_MANAGED_TO_NATIVE); + MonoMethodBuilder *mb = mono_mb_new (get_wrapper_target_class (image), name, MONO_WRAPPER_MANAGED_TO_NATIVE); mb->method->save_lmf = 1; WrapperInfo *info = mono_wrapper_info_create (mb, WRAPPER_SUBTYPE_NATIVE_FUNC_INDIRECT); @@ -6798,11 +6798,15 @@ static void record_struct_field_physical_lowering (guint8* lowered_bytes, MonoTy static void record_inlinearray_struct_physical_lowering (guint8* lowered_bytes, MonoClass* klass, guint32 offset) { + int align; + int type_offset = MONO_ABI_SIZEOF (MonoObject); + // Get the first field and record its physical lowering N times - MonoClassField* field = mono_class_get_fields_internal (klass, NULL); + gpointer iter = NULL; + MonoClassField* field = mono_class_get_fields_internal (klass, &iter); MonoType* fieldType = field->type; for (int i = 0; i < m_class_inlinearray_value(klass); ++i) { - record_struct_field_physical_lowering(lowered_bytes, fieldType, offset + m_field_get_offset(field) + i * mono_type_size(fieldType, NULL)); + record_struct_field_physical_lowering(lowered_bytes, fieldType, offset + m_field_get_offset(field) + i * mono_type_size(fieldType, &align) - type_offset); } } diff --git a/src/mono/mono/metadata/threads-types.h b/src/mono/mono/metadata/threads-types.h index c92e61497db..da86f3a15d8 100644 --- a/src/mono/mono/metadata/threads-types.h +++ b/src/mono/mono/metadata/threads-types.h @@ -148,9 +148,6 @@ void ves_icall_System_Threading_Interlocked_Exchange_Object (MonoObject *volatil ICALL_EXPORT gint32 ves_icall_System_Threading_Interlocked_CompareExchange_Int(gint32 *location, gint32 value, gint32 comparand); -ICALL_EXPORT -gint32 ves_icall_System_Threading_Interlocked_CompareExchange_Int_Success(gint32 *location, gint32 value, gint32 comparand, MonoBoolean *success); - ICALL_EXPORT gint64 ves_icall_System_Threading_Interlocked_CompareExchange_Long(gint64 *location, gint64 value, gint64 comparand); diff --git a/src/mono/mono/metadata/threads.c b/src/mono/mono/metadata/threads.c index 22a7760450e..11fb393d770 100644 --- a/src/mono/mono/metadata/threads.c +++ b/src/mono/mono/metadata/threads.c @@ -2199,16 +2199,6 @@ gint32 ves_icall_System_Threading_Interlocked_CompareExchange_Int(gint32 *locati return mono_atomic_cas_i32(location, value, comparand); } -gint32 ves_icall_System_Threading_Interlocked_CompareExchange_Int_Success(gint32 *location, gint32 value, gint32 comparand, MonoBoolean *success) -{ - if (G_UNLIKELY (!location)) - return (gint32)set_pending_null_reference_exception (); - - gint32 r = mono_atomic_cas_i32(location, value, comparand); - *success = r == comparand; - return r; -} - void ves_icall_System_Threading_Interlocked_CompareExchange_Object (MonoObject *volatile*location, MonoObject *volatile*value, MonoObject *volatile*comparand, MonoObject *volatile* res) { diff --git a/src/mono/mono/metadata/verify.c b/src/mono/mono/metadata/verify.c index 134a63a3bf2..1a6742acd71 100644 --- a/src/mono/mono/metadata/verify.c +++ b/src/mono/mono/metadata/verify.c @@ -24,6 +24,7 @@ #include #include #include +#include #include #include #include @@ -99,7 +100,7 @@ is_valid_generic_instantiation (MonoGenericContainer *gc, MonoGenericContext *co if ((param_info->flags & GENERIC_PARAMETER_ATTRIBUTE_REFERENCE_TYPE_CONSTRAINT) && m_class_is_valuetype (paramClass)) return FALSE; - if ((param_info->flags & GENERIC_PARAMETER_ATTRIBUTE_CONSTRUCTOR_CONSTRAINT) && !m_class_is_valuetype (paramClass) && !mono_class_has_default_constructor (paramClass, TRUE)) + if ((param_info->flags & GENERIC_PARAMETER_ATTRIBUTE_CONSTRUCTOR_CONSTRAINT) && !m_class_is_valuetype (paramClass) && (!mono_class_has_default_constructor (paramClass, TRUE) || mono_class_is_abstract (paramClass))) return FALSE; if (!param_info->constraints) diff --git a/src/mono/mono/mini/aot-compiler.c b/src/mono/mono/mini/aot-compiler.c index fa52e9dd752..139dcfbbdd5 100644 --- a/src/mono/mono/mini/aot-compiler.c +++ b/src/mono/mono/mini/aot-compiler.c @@ -7607,6 +7607,8 @@ emit_method_info (MonoAotCompile *acfg, MonoCompile *cfg) flags |= MONO_AOT_METHOD_FLAG_HAS_CTX; if (cfg->interp_entry_only) flags |= MONO_AOT_METHOD_FLAG_INTERP_ENTRY_ONLY; + if (cfg->uses_simd_intrinsics && cfg->compile_llvm) + flags |= MONO_AOT_METHOD_FLAG_HAS_LLVM_INTRINSICS; /* Saved into another table so it can be accessed without having access to this data */ cfg->aot_method_flags = flags; diff --git a/src/mono/mono/mini/aot-runtime.c b/src/mono/mono/mini/aot-runtime.c index 11398459068..11c8888d17b 100644 --- a/src/mono/mono/mini/aot-runtime.c +++ b/src/mono/mono/mini/aot-runtime.c @@ -4441,16 +4441,15 @@ load_method (MonoAotModule *amodule, MonoImage *image, MonoMethod *method, guint g_free (full_name); } - if (mono_llvm_only) { - guint8 flags = amodule->method_flags_table [method_index]; - /* The caller needs to looks this up, but its hard to do without constructing the full MonoJitInfo, so save it here */ - if (flags & (MONO_AOT_METHOD_FLAG_GSHAREDVT_VARIABLE | MONO_AOT_METHOD_FLAG_INTERP_ENTRY_ONLY)) { - mono_aot_lock (); - if (!code_to_method_flags) - code_to_method_flags = g_hash_table_new (NULL, NULL); - g_hash_table_insert (code_to_method_flags, code, GUINT_TO_POINTER (flags)); - mono_aot_unlock (); - } + guint8 flags = amodule->method_flags_table [method_index]; + /* The caller needs to looks this up, but its hard to do without constructing the full MonoJitInfo, so save it here */ + if ((mono_llvm_only && (flags & (MONO_AOT_METHOD_FLAG_GSHAREDVT_VARIABLE | MONO_AOT_METHOD_FLAG_INTERP_ENTRY_ONLY))) || + (flags & MONO_AOT_METHOD_FLAG_HAS_LLVM_INTRINSICS)) { + mono_aot_lock (); + if (!code_to_method_flags) + code_to_method_flags = g_hash_table_new (NULL, NULL); + g_hash_table_insert (code_to_method_flags, code, GUINT_TO_POINTER (flags)); + mono_aot_unlock (); } init_plt (amodule); @@ -6547,6 +6546,12 @@ mono_aot_get_method_flags (guint8 *code) return (MonoAotMethodFlags)flags; } +MonoAotFileFlags +mono_aot_get_module_flags (gpointer aot_module) +{ + return ((MonoAotModule*)aot_module)->info.flags; +} + #else /* AOT disabled */ @@ -6747,4 +6752,10 @@ mono_aot_get_method_flags (guint8 *code) return MONO_AOT_METHOD_FLAG_NONE; } +MonoAotFileFlags +mono_aot_get_module_flags (gpointer aot_module) +{ + return 0; +} + #endif diff --git a/src/mono/mono/mini/aot-runtime.h b/src/mono/mono/mini/aot-runtime.h index e4f84523c45..13690e31904 100644 --- a/src/mono/mono/mini/aot-runtime.h +++ b/src/mono/mono/mini/aot-runtime.h @@ -84,6 +84,7 @@ typedef enum { MONO_AOT_METHOD_FLAG_HAS_PATCHES = 4, MONO_AOT_METHOD_FLAG_HAS_CTX = 8, MONO_AOT_METHOD_FLAG_INTERP_ENTRY_ONLY = 16, + MONO_AOT_METHOD_FLAG_HAS_LLVM_INTRINSICS = 32, } MonoAotMethodFlags; #undef DEBUG_AOT_NAME_TABLE @@ -282,6 +283,7 @@ guint32 mono_aot_find_method_index (MonoMethod *method); gboolean mono_aot_init_llvm_method (gpointer aot_module, gpointer method_info, MonoClass *init_class, MonoError *error); GHashTable *mono_aot_get_weak_field_indexes (MonoImage *image); MonoAotMethodFlags mono_aot_get_method_flags (guint8 *code); +MonoAotFileFlags mono_aot_get_module_flags (gpointer aot_module); #ifdef MONO_ARCH_CODE_EXEC_ONLY typedef guint32 (*MonoAotResolvePltInfoOffset)(gpointer amodule, guint32 plt_entry_index); diff --git a/src/mono/mono/mini/cpu-amd64.mdesc b/src/mono/mono/mini/cpu-amd64.mdesc index 66e16bb5232..c5df012d8eb 100644 --- a/src/mono/mono/mini/cpu-amd64.mdesc +++ b/src/mono/mono/mini/cpu-amd64.mdesc @@ -363,8 +363,12 @@ tls_get: dest:i len:32 tls_set: src1:i len:16 atomic_add_i4: src1:b src2:i dest:i len:32 atomic_add_i8: src1:b src2:i dest:i len:32 +atomic_exchange_u1: src1:b src2:i dest:i len:12 +atomic_exchange_u2: src1:b src2:i dest:i len:13 atomic_exchange_i4: src1:b src2:i dest:i len:12 atomic_exchange_i8: src1:b src2:i dest:i len:12 +atomic_cas_u1: src1:b src2:i src3:a dest:a len:24 +atomic_cas_u2: src1:b src2:i src3:a dest:a len:25 atomic_cas_i4: src1:b src2:i src3:a dest:a len:24 atomic_cas_i8: src1:b src2:i src3:a dest:a len:24 memory_barrier: len:3 diff --git a/src/mono/mono/mini/cpu-arm64.mdesc b/src/mono/mono/mini/cpu-arm64.mdesc index 49f235c5e4c..5378b4d7241 100644 --- a/src/mono/mono/mini/cpu-arm64.mdesc +++ b/src/mono/mono/mini/cpu-arm64.mdesc @@ -482,8 +482,12 @@ arm64_hint: len:4 atomic_add_i4: dest:i src1:i src2:i len:32 atomic_add_i8: dest:i src1:i src2:i len:32 +atomic_exchange_u1: dest:i src1:i src2:i len:32 +atomic_exchange_u2: dest:i src1:i src2:i len:32 atomic_exchange_i4: dest:i src1:i src2:i len:32 atomic_exchange_i8: dest:i src1:i src2:i len:32 +atomic_cas_u1: dest:i src1:i src2:i src3:i len:32 +atomic_cas_u2: dest:i src1:i src2:i src3:i len:32 atomic_cas_i4: dest:i src1:i src2:i src3:i len:32 atomic_cas_i8: dest:i src1:i src2:i src3:i len:32 memory_barrier: len:8 clob:a diff --git a/src/mono/mono/mini/dwarfwriter.c b/src/mono/mono/mini/dwarfwriter.c index 31ca33e9fd8..aea4758c668 100644 --- a/src/mono/mono/mini/dwarfwriter.c +++ b/src/mono/mono/mini/dwarfwriter.c @@ -25,11 +25,6 @@ #include #include -#ifndef HOST_WIN32 -#include -#include -#endif - #include #define DW_AT_MIPS_linkage_name 0x2007 diff --git a/src/mono/mono/mini/interp/interp.c b/src/mono/mono/mini/interp/interp.c index 61e1ff55d2f..1dda6c21648 100644 --- a/src/mono/mono/mini/interp/interp.c +++ b/src/mono/mono/mini/interp/interp.c @@ -7188,6 +7188,46 @@ MINT_IN_CASE(MINT_BRTRUE_I8_SP) ZEROP_SP(gint64, !=); MINT_IN_BREAK; mono_memory_barrier (); MINT_IN_BREAK; } + MINT_IN_CASE(MINT_MONO_EXCHANGE_U1) { + guint8 *dest = LOCAL_VAR (ip [2], guint8*); + guint8 exch = LOCAL_VAR (ip[3], guint8); + NULL_CHECK(dest); + LOCAL_VAR(ip[1], guint32) = (guint32)mono_atomic_xchg_u8(dest, exch); + ip += 4; + MINT_IN_BREAK; + } + MINT_IN_CASE(MINT_MONO_EXCHANGE_I1) { + gint8 *dest = LOCAL_VAR (ip [2], gint8*); + gint8 exch = LOCAL_VAR (ip[3], gint8); + NULL_CHECK(dest); + LOCAL_VAR(ip[1], gint32) = (gint32)(gint8)mono_atomic_xchg_u8((guint8*)dest, exch); + ip += 4; + MINT_IN_BREAK; + } + MINT_IN_CASE(MINT_MONO_EXCHANGE_U2) { + guint16 *dest = LOCAL_VAR (ip [2], guint16*); + guint16 exch = LOCAL_VAR (ip[3], guint16); + NULL_CHECK(dest); + LOCAL_VAR(ip[1], guint32) = (guint32)mono_atomic_xchg_u16(dest, exch); + ip += 4; + MINT_IN_BREAK; + } + MINT_IN_CASE(MINT_MONO_EXCHANGE_I2) { + gint16 *dest = LOCAL_VAR (ip [2], gint16*); + gint16 exch = LOCAL_VAR (ip[3], gint16); + NULL_CHECK(dest); + LOCAL_VAR(ip[1], gint32) = (gint32)(gint16)mono_atomic_xchg_u16((guint16*)dest, exch); + ip += 4; + MINT_IN_BREAK; + } + MINT_IN_CASE(MINT_MONO_EXCHANGE_I4) { + gint32 *dest = LOCAL_VAR (ip [2], gint32*); + gint32 exch = LOCAL_VAR (ip[3], gint32); + NULL_CHECK(dest); + LOCAL_VAR(ip[1], gint32) = mono_atomic_xchg_i32(dest, exch); + ip += 4; + MINT_IN_BREAK; + } MINT_IN_CASE(MINT_MONO_EXCHANGE_I8) { gboolean flag = FALSE; gint64 *dest = LOCAL_VAR (ip [2], gint64*); @@ -7209,6 +7249,46 @@ MINT_IN_CASE(MINT_BRTRUE_I8_SP) ZEROP_SP(gint64, !=); MINT_IN_BREAK; ip += 4; MINT_IN_BREAK; } + MINT_IN_CASE(MINT_MONO_CMPXCHG_U1) { + guint8 *dest = LOCAL_VAR(ip[2], guint8*); + guint8 value = LOCAL_VAR(ip[3], guint8); + guint8 comparand = LOCAL_VAR(ip[4], guint8); + NULL_CHECK(dest); + + LOCAL_VAR(ip[1], guint32) = (guint32)mono_atomic_cas_u8(dest, value, comparand); + ip += 5; + MINT_IN_BREAK; + } + MINT_IN_CASE(MINT_MONO_CMPXCHG_I1) { + gint8 *dest = LOCAL_VAR(ip[2], gint8*); + gint8 value = LOCAL_VAR(ip[3], gint8); + gint8 comparand = LOCAL_VAR(ip[4], gint8); + NULL_CHECK(dest); + + LOCAL_VAR(ip[1], gint32) = (gint32)(gint8)mono_atomic_cas_u8((guint8*)dest, value, comparand); + ip += 5; + MINT_IN_BREAK; + } + MINT_IN_CASE(MINT_MONO_CMPXCHG_U2) { + guint16 *dest = LOCAL_VAR(ip[2], guint16*); + guint16 value = LOCAL_VAR(ip[3], guint16); + guint16 comparand = LOCAL_VAR(ip[4], guint16); + NULL_CHECK(dest); + + LOCAL_VAR(ip[1], guint32) = (guint32)mono_atomic_cas_u16(dest, value, comparand); + ip += 5; + MINT_IN_BREAK; + } + MINT_IN_CASE(MINT_MONO_CMPXCHG_I2) { + gint16 *dest = LOCAL_VAR(ip[2], gint16*); + gint16 value = LOCAL_VAR(ip[3], gint16); + gint16 comparand = LOCAL_VAR(ip[4], gint16); + NULL_CHECK(dest); + + LOCAL_VAR(ip[1], gint32) = (gint32)(gint16)mono_atomic_cas_u16((guint16*)dest, value, comparand); + ip += 5; + MINT_IN_BREAK; + } MINT_IN_CASE(MINT_MONO_CMPXCHG_I4) { gint32 *dest = LOCAL_VAR(ip[2], gint32*); gint32 value = LOCAL_VAR(ip[3], gint32); @@ -7577,7 +7657,8 @@ MINT_IN_CASE(MINT_BRTRUE_I8_SP) ZEROP_SP(gint64, !=); MINT_IN_BREAK; MINT_IN_CASE(MINT_LDLOCA_S) LOCAL_VAR (ip [1], gpointer) = locals + ip [2]; - ip += 3; + // ip[3] reserved for size data for jiterpreter + ip += 4; MINT_IN_BREAK; #define MOV(argtype1,argtype2) \ diff --git a/src/mono/mono/mini/interp/jiterpreter-opcode-values.h b/src/mono/mono/mini/interp/jiterpreter-opcode-values.h index c3926ccb4c4..d360bceb0fc 100644 --- a/src/mono/mono/mini/interp/jiterpreter-opcode-values.h +++ b/src/mono/mono/mini/interp/jiterpreter-opcode-values.h @@ -98,6 +98,7 @@ OP(MINT_BOX, NORMAL) OP(MINT_BOX_VT, NORMAL) OP(MINT_UNBOX, NORMAL) OP(MINT_NEWSTR, NORMAL) +OP(MINT_NEWARR, NORMAL) OP(MINT_LD_DELEGATE_METHOD_PTR, NORMAL) OP(MINT_LDTSFLDA, NORMAL) OP(MINT_ADD_MUL_I4_IMM, NORMAL) @@ -172,6 +173,10 @@ OP(MINT_LOG2_I8, HIGH) OP(MINT_SHL_AND_I4, HIGH) OP(MINT_SHL_AND_I8, HIGH) +// Produces a bailout at compile time, may produce an actual jump table +// later in the future. Treat it as a low value branch +OP(MINT_SWITCH, BRANCH) + // Produces either a backwards branch or a bailout depending on JIT-time // information, so treat it as a low value branch OP(MINT_ENDFINALLY, BRANCH) @@ -183,5 +188,9 @@ OP(MINT_THROW, ABORT_OUTSIDE_BRANCH_BLOCK_NONE) OP(MINT_MOV_SRC_OFF, NORMAL) OP(MINT_MOV_DST_OFF, NORMAL) +OP(MINT_MONO_MEMORY_BARRIER, NORMAL) +OPRANGE(MINT_MONO_EXCHANGE_U1, MINT_MONO_EXCHANGE_I8, HIGH) +OPRANGE(MINT_MONO_CMPXCHG_U1, MINT_MONO_CMPXCHG_I8, HIGH) + // FIXME: Not implemented individual opcodes OP(MINT_CONV_U4_R8, ABORT) diff --git a/src/mono/mono/mini/interp/jiterpreter.c b/src/mono/mono/mini/interp/jiterpreter.c index 43b71e70cd3..b63ec1b284e 100644 --- a/src/mono/mono/mini/interp/jiterpreter.c +++ b/src/mono/mono/mini/interp/jiterpreter.c @@ -202,6 +202,18 @@ mono_jiterp_try_newstr (MonoString **destination, int length) { return *destination != 0; } +EMSCRIPTEN_KEEPALIVE int +mono_jiterp_try_newarr (MonoArray **destination, MonoVTable *vtable, int length) { + if (length < 0) + return 0; + ERROR_DECL(error); + *destination = mono_array_new_specific_checked (vtable, length, error); + if (!is_ok (error)) + *destination = 0; + mono_error_cleanup (error); // FIXME: do not swallow the error + return *destination != 0; +} + EMSCRIPTEN_KEEPALIVE int mono_jiterp_gettype_ref ( MonoObject **destination, MonoObject **source @@ -561,18 +573,6 @@ mono_jiterp_interp_entry_prologue (JiterpEntryData *data, void *this_arg) return sp_args; } -EMSCRIPTEN_KEEPALIVE int32_t -mono_jiterp_cas_i32 (volatile int32_t *addr, int32_t newVal, int32_t expected) -{ - return mono_atomic_cas_i32 (addr, newVal, expected); -} - -EMSCRIPTEN_KEEPALIVE void -mono_jiterp_cas_i64 (volatile int64_t *addr, int64_t *newVal, int64_t *expected, int64_t *oldVal) -{ - *oldVal = mono_atomic_cas_i64 (addr, *newVal, *expected); -} - static int opcode_value_table [MINT_LASTOP] = { 0 }; static gboolean opcode_value_table_initialized = FALSE; @@ -1177,6 +1177,7 @@ mono_jiterp_stelem_ref ( return 1; } + // keep in sync with jiterpreter-enums.ts JiterpMember enum { JITERP_MEMBER_VT_INITIALIZED = 0, @@ -1268,7 +1269,9 @@ enum { JITERP_COUNTER_BACK_BRANCHES_NOT_EMITTED, JITERP_COUNTER_ELAPSED_GENERATION, JITERP_COUNTER_ELAPSED_COMPILATION, - JITERP_COUNTER_MAX = JITERP_COUNTER_ELAPSED_COMPILATION + JITERP_COUNTER_SWITCH_TARGETS_OK, + JITERP_COUNTER_SWITCH_TARGETS_FAILED, + JITERP_COUNTER_MAX = JITERP_COUNTER_SWITCH_TARGETS_FAILED }; #define JITERP_COUNTER_UNIT 100 @@ -1517,7 +1520,11 @@ EMSCRIPTEN_KEEPALIVE int mono_jiterp_allocate_table_entry (int type) { g_assert ((type >= 0) && (type <= JITERPRETER_TABLE_LAST)); JiterpreterTableInfo *table = &tables[type]; - g_assert (table->first_index > 0); + // Handle unlikely condition where the jiterpreter is engaged before initialize_table runs at all (i.e. tiering disabled) + if (table->first_index <= 0) { + g_printf ("MONO_WASM: Jiterpreter table %d is not yet initialized\n", type); + return 0; + } // Handle extremely unlikely race condition (allocate_table_entry called while another thread is in initialize_table) #ifdef DISABLE_THREADS diff --git a/src/mono/mono/mini/interp/mintops.def b/src/mono/mono/mini/interp/mintops.def index 7edb4f53e3f..5e2c41d60c4 100644 --- a/src/mono/mono/mini/interp/mintops.def +++ b/src/mono/mono/mini/interp/mintops.def @@ -128,7 +128,11 @@ OPDEF(MINT_MOV_8_2, "mov.8.2", 5, 0, 0, MintOpPair2) OPDEF(MINT_MOV_8_3, "mov.8.3", 7, 0, 0, MintOpPair3) OPDEF(MINT_MOV_8_4, "mov.8.4", 9, 0, 0, MintOpPair4) -OPDEF(MINT_LDLOCA_S, "ldloca.s", 3, 1, 0, MintOpUShortInt) +// NOTE: We reserve an extra ushort at the end of this specifically to communicate information +// to the jiterpreter about how large the local is so that invalidation can be correct. +// FIXME: genmintops.py is way too simple to handle this having a different size on different targets, +// so it's got a size of 4 everywhere. +OPDEF(MINT_LDLOCA_S, "ldloca.s", 4, 1, 0, MintOpUShortInt) OPDEF(MINT_LDIND_I1, "ldind.i1", 3, 1, 1, MintOpNoArgs) OPDEF(MINT_LDIND_U1, "ldind.u1", 3, 1, 1, MintOpNoArgs) @@ -709,7 +713,16 @@ OPDEF(MINT_LDPTR, "mono_ldptr", 3, 1, 0, MintOpShortInt) OPDEF(MINT_MONO_NEWOBJ, "mono_newobj", 3, 1, 0, MintOpClassToken) OPDEF(MINT_MONO_RETOBJ, "mono_retobj", 2, 0, 1, MintOpNoArgs) OPDEF(MINT_MONO_MEMORY_BARRIER, "mono_memory_barrier", 1, 0, 0, MintOpNoArgs) +OPDEF(MINT_MONO_EXCHANGE_U1, "mono_interlocked.xchg.u1", 4, 1, 2, MintOpNoArgs) +OPDEF(MINT_MONO_EXCHANGE_I1, "mono_interlocked.xchg.i1", 4, 1, 2, MintOpNoArgs) +OPDEF(MINT_MONO_EXCHANGE_U2, "mono_interlocked.xchg.u2", 4, 1, 2, MintOpNoArgs) +OPDEF(MINT_MONO_EXCHANGE_I2, "mono_interlocked.xchg.i2", 4, 1, 2, MintOpNoArgs) +OPDEF(MINT_MONO_EXCHANGE_I4, "mono_interlocked.xchg.i4", 4, 1, 2, MintOpNoArgs) OPDEF(MINT_MONO_EXCHANGE_I8, "mono_interlocked.xchg.i8", 4, 1, 2, MintOpNoArgs) +OPDEF(MINT_MONO_CMPXCHG_U1, "mono_interlocked.cmpxchg.u1", 5, 1, 3, MintOpNoArgs) +OPDEF(MINT_MONO_CMPXCHG_I1, "mono_interlocked.cmpxchg.i1", 5, 1, 3, MintOpNoArgs) +OPDEF(MINT_MONO_CMPXCHG_U2, "mono_interlocked.cmpxchg.u2", 5, 1, 3, MintOpNoArgs) +OPDEF(MINT_MONO_CMPXCHG_I2, "mono_interlocked.cmpxchg.i2", 5, 1, 3, MintOpNoArgs) OPDEF(MINT_MONO_CMPXCHG_I4, "mono_interlocked.cmpxchg.i4", 5, 1, 3, MintOpNoArgs) OPDEF(MINT_MONO_CMPXCHG_I8, "mono_interlocked.cmpxchg.i8", 5, 1, 3, MintOpNoArgs) OPDEF(MINT_MONO_LDDOMAIN, "mono_lddomain", 2, 1, 0, MintOpNoArgs) @@ -829,7 +842,7 @@ OPDEF(MINT_INTRINS_WIDEN_ASCII_TO_UTF16, "intrins_widen_ascii_to_utf16", 5, 1, 3 OPDEF(MINT_METADATA_UPDATE_LDFLDA, "metadata_update.ldflda", 5, 1, 1, MintOpTwoShorts) // This ifdef is fine because genmintops.py is generating output for HOST_BROWSER -#if HOST_BROWSER +#ifdef HOST_BROWSER OPDEF(MINT_TIER_PREPARE_JITERPRETER, "tier_prepare_jiterpreter", 4, 0, 0, MintOpShortAndInt) OPDEF(MINT_TIER_NOP_JITERPRETER, "tier_nop_jiterpreter", 4, 0, 0, MintOpShortAndInt) OPDEF(MINT_TIER_ENTER_JITERPRETER, "tier_enter_jiterpreter", 4, 0, 0, MintOpShortAndInt) diff --git a/src/mono/mono/mini/interp/transform.c b/src/mono/mono/mini/interp/transform.c index 1af7c2d514b..22c5518a82c 100644 --- a/src/mono/mono/mini/interp/transform.c +++ b/src/mono/mono/mini/interp/transform.c @@ -2457,15 +2457,57 @@ interp_handle_intrinsics (TransformData *td, MonoMethod *target_method, MonoClas } else if (in_corlib && !strcmp (klass_name_space, "System.Threading") && !strcmp (klass_name, "Interlocked")) { if (!strcmp (tm, "MemoryBarrier") && csignature->param_count == 0) *op = MINT_MONO_MEMORY_BARRIER; - else if (!strcmp (tm, "Exchange") && csignature->param_count == 2 && csignature->params [0]->type == MONO_TYPE_I8 && csignature->params [1]->type == MONO_TYPE_I8) - *op = MINT_MONO_EXCHANGE_I8; - else if (!strcmp (tm, "CompareExchange") && csignature->param_count == 3 && - (csignature->params[1]->type == MONO_TYPE_I4 || - csignature->params[1]->type == MONO_TYPE_I8)) { - if (csignature->params[1]->type == MONO_TYPE_I4) + else if (!strcmp (tm, "Exchange") && csignature->param_count == 2 && m_type_is_byref (csignature->params[0])) { + MonoType *t = mini_get_underlying_type (csignature->params[1]); + switch (t->type) { + case MONO_TYPE_I1: + *op = MINT_MONO_EXCHANGE_I1; + break; + case MONO_TYPE_U1: + *op = MINT_MONO_EXCHANGE_U1; + break; + case MONO_TYPE_I2: + *op = MINT_MONO_EXCHANGE_I2; + break; + case MONO_TYPE_U2: + *op = MINT_MONO_EXCHANGE_U2; + break; + case MONO_TYPE_I4: + *op = MINT_MONO_EXCHANGE_I4; + break; + case MONO_TYPE_I8: + *op = MINT_MONO_EXCHANGE_I8; + break; + default: + // no intrinsic + break; + } + } + else if (!strcmp (tm, "CompareExchange") && csignature->param_count == 3) { + MonoType *t = mini_get_underlying_type (csignature->params[1]); + switch (t->type) { + case MONO_TYPE_U1: + *op = MINT_MONO_CMPXCHG_U1; + break; + case MONO_TYPE_I1: + *op = MINT_MONO_CMPXCHG_I1; + break; + case MONO_TYPE_U2: + *op = MINT_MONO_CMPXCHG_U2; + break; + case MONO_TYPE_I2: + *op = MINT_MONO_CMPXCHG_I2; + break; + case MONO_TYPE_I4: *op = MINT_MONO_CMPXCHG_I4; - else + break; + case MONO_TYPE_I8: *op = MINT_MONO_CMPXCHG_I8; + break; + default: + /* no intrinsic */ + break; + } } } else if (in_corlib && !strcmp (klass_name_space, "System.Threading") && !strcmp (klass_name, "Thread")) { if (!strcmp (tm, "MemoryBarrier") && csignature->param_count == 0) @@ -9199,6 +9241,12 @@ emit_compacted_instruction (TransformData *td, guint16* start_ip, InterpInst *in } else if (opcode == MINT_LDLOCA_S) { // This opcode receives a local but it is not viewed as a sreg since we don't load the value *ip++ = GINT_TO_UINT16 (get_var_offset (td, ins->sregs [0])); + +#if HOST_BROWSER + // We reserve an extra 2 bytes at the end of ldloca_s so the jiterpreter knows how large + // the var is when taking its address so that it can invalidate a properly sized range. + *ip++ = GINT_TO_UINT16 (td->vars [ins->sregs [0]].size); +#endif } int left = interp_get_ins_length (ins) - GPTRDIFF_TO_INT(ip - start_ip); diff --git a/src/mono/mono/mini/intrinsics.c b/src/mono/mono/mini/intrinsics.c index b994a01c487..ce6636b3220 100644 --- a/src/mono/mono/mini/intrinsics.c +++ b/src/mono/mono/mini/intrinsics.c @@ -1522,11 +1522,34 @@ mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSign else if (strcmp (cmethod->name, "Exchange") == 0 && fsig->param_count == 2 && m_type_is_byref (fsig->params [0])) { MonoInst *f2i = NULL, *i2f; guint32 opcode, f2i_opcode = 0, i2f_opcode = 0; - gboolean is_ref = byref_arg_is_reference (fsig->params [0]); - gboolean is_float = fsig->params [0]->type == MONO_TYPE_R4 || fsig->params [0]->type == MONO_TYPE_R8; - - if (fsig->params [0]->type == MONO_TYPE_I4 || - fsig->params [0]->type == MONO_TYPE_R4) { + // params[1] is byval, use it to decide what kind of op to do + // get the underlying type so enums and bool work too. + MonoType *param_type = mini_get_underlying_type (fsig->params[1]); + gboolean is_ref = mini_type_is_reference (param_type); + gboolean is_float = param_type->type == MONO_TYPE_R4 || param_type->type == MONO_TYPE_R8; + guint32 u2i_result_opcode = 0; + MonoInst *u2i_result = NULL; + + // For small types .NET stack temps are always i4, so we need to zext or + // sext the output + if (param_type->type == MONO_TYPE_I1) { + opcode = OP_ATOMIC_EXCHANGE_U1; + u2i_result_opcode = OP_ICONV_TO_I1; + } + else if (param_type->type == MONO_TYPE_U1) { + opcode = OP_ATOMIC_EXCHANGE_U1; + u2i_result_opcode = OP_ICONV_TO_U1; + } + else if (param_type->type == MONO_TYPE_I2) { + opcode = OP_ATOMIC_EXCHANGE_U2; + u2i_result_opcode = OP_ICONV_TO_I2; + } + else if (param_type->type == MONO_TYPE_U2) { + opcode = OP_ATOMIC_EXCHANGE_U2; + u2i_result_opcode = OP_ICONV_TO_U2; + } + else if (param_type->type == MONO_TYPE_I4 || + param_type->type == MONO_TYPE_R4) { opcode = OP_ATOMIC_EXCHANGE_I4; f2i_opcode = OP_MOVE_F_TO_I4; i2f_opcode = OP_MOVE_I4_TO_F; @@ -1577,7 +1600,11 @@ mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSign ins->sreg2 = is_float ? f2i->dreg : args [1]->dreg; MONO_ADD_INS (cfg->cbb, ins); - switch (fsig->params [0]->type) { + switch (param_type->type) { + case MONO_TYPE_U1: + case MONO_TYPE_I1: + case MONO_TYPE_U2: + case MONO_TYPE_I2: case MONO_TYPE_I4: ins->type = STACK_I4; break; @@ -1611,6 +1638,13 @@ mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSign MONO_ADD_INS (cfg->cbb, i2f); ins = i2f; + } else if (u2i_result_opcode) { + MONO_INST_NEW (cfg, u2i_result, u2i_result_opcode); + u2i_result->dreg = mono_alloc_ireg (cfg); + u2i_result->sreg1 = ins->dreg; + MONO_ADD_INS (cfg->cbb, u2i_result); + + ins = u2i_result; } if (cfg->gen_write_barriers && is_ref) @@ -1619,11 +1653,43 @@ mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSign else if ((strcmp (cmethod->name, "CompareExchange") == 0) && fsig->param_count == 3) { MonoInst *f2i_new = NULL, *f2i_cmp = NULL, *i2f; guint32 opcode, f2i_opcode = 0, i2f_opcode = 0; - gboolean is_ref = mini_type_is_reference (fsig->params [1]); - gboolean is_float = fsig->params [1]->type == MONO_TYPE_R4 || fsig->params [1]->type == MONO_TYPE_R8; - - if (fsig->params [1]->type == MONO_TYPE_I4 || - fsig->params [1]->type == MONO_TYPE_R4) { + MonoType *param1_type = mini_get_underlying_type (fsig->params[1]); + gboolean is_ref = mini_type_is_reference (param1_type); + gboolean is_float = param1_type->type == MONO_TYPE_R4 || param1_type->type == MONO_TYPE_R8; + guint32 i2u_cmp_opcode = 0, u2i_result_opcode = 0; + MonoInst *i2u_cmp = NULL, *u2i_result = NULL; + + // For small types the "compare" part of CAS is done on zero extended. For + // the result, .NET stack temps are always i4, so we need to zext or sext + // the output + if (param1_type->type == MONO_TYPE_U1) { + opcode = OP_ATOMIC_CAS_U1; + i2u_cmp_opcode = 0; + // zext the result + u2i_result_opcode = OP_ICONV_TO_U1; + } + else if (param1_type->type == MONO_TYPE_I1) { + opcode = OP_ATOMIC_CAS_U1; + // zero extend expected comparand + i2u_cmp_opcode = OP_ICONV_TO_U1; + // sign extend result + u2i_result_opcode = OP_ICONV_TO_I1; + } + else if (param1_type->type == MONO_TYPE_U2) { + opcode = OP_ATOMIC_CAS_U2; + i2u_cmp_opcode = 0; + // zext the result + u2i_result_opcode = OP_ICONV_TO_U2; + } + else if (param1_type->type == MONO_TYPE_I2) { + opcode = OP_ATOMIC_CAS_U2; + // zero extend expected comparand + i2u_cmp_opcode = OP_ICONV_TO_U2; + // sign extend result + u2i_result_opcode = OP_ICONV_TO_I2; + } + else if (param1_type->type == MONO_TYPE_I4 || + param1_type->type == MONO_TYPE_R4) { opcode = OP_ATOMIC_CAS_I4; f2i_opcode = OP_MOVE_F_TO_I4; i2f_opcode = OP_MOVE_I4_TO_F; @@ -1631,15 +1697,15 @@ mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSign } #if SIZEOF_REGISTER == 8 else if (is_ref || - fsig->params [1]->type == MONO_TYPE_I8 || - fsig->params [1]->type == MONO_TYPE_R8 || - fsig->params [1]->type == MONO_TYPE_I) { + param1_type->type == MONO_TYPE_I8 || + param1_type->type == MONO_TYPE_R8 || + param1_type->type == MONO_TYPE_I) { opcode = OP_ATOMIC_CAS_I8; f2i_opcode = OP_MOVE_F_TO_I8; i2f_opcode = OP_MOVE_I8_TO_F; } #else - else if (is_ref || fsig->params [1]->type == MONO_TYPE_I) { + else if (is_ref || param1_type->type == MONO_TYPE_I) { opcode = OP_ATOMIC_CAS_I4; cfg->has_atomic_cas_i4 = TRUE; } @@ -1670,6 +1736,13 @@ mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSign MONO_ADD_INS (cfg->cbb, f2i_cmp); } + if (i2u_cmp_opcode) { + MONO_INST_NEW (cfg, i2u_cmp, i2u_cmp_opcode); + i2u_cmp->dreg = mono_alloc_ireg (cfg); + i2u_cmp->sreg1 = args[2]->dreg; + MONO_ADD_INS (cfg->cbb, i2u_cmp); + } + if (is_ref && !mini_debug_options.weak_memory_model) mini_emit_memory_barrier (cfg, MONO_MEMORY_BARRIER_REL); @@ -1677,11 +1750,25 @@ mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSign MONO_INST_NEW (cfg, ins, opcode); ins->dreg = is_ref ? alloc_ireg_ref (cfg) : alloc_ireg (cfg); ins->sreg1 = args [0]->dreg; - ins->sreg2 = is_float ? f2i_new->dreg : args [1]->dreg; - ins->sreg3 = is_float ? f2i_cmp->dreg : args [2]->dreg; + if (is_float) { + ins->sreg2 = f2i_new->dreg; + ins->sreg3 = f2i_cmp->dreg; + } else if (i2u_cmp_opcode) { + ins->sreg2 = args[1]->dreg; + ins->sreg3 = i2u_cmp->dreg; + } else { + ins->sreg2 = args[1]->dreg; + ins->sreg3 = args[2]->dreg; + } MONO_ADD_INS (cfg->cbb, ins); - switch (fsig->params [1]->type) { + switch (param1_type->type) { + case MONO_TYPE_U1: + case MONO_TYPE_I1: + case MONO_TYPE_U2: + case MONO_TYPE_I2: + ins->type = STACK_I4; + break; case MONO_TYPE_I4: ins->type = STACK_I4; break; @@ -1702,7 +1789,7 @@ mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSign ins->type = STACK_R8; break; default: - g_assert (mini_type_is_reference (fsig->params [1])); + g_assert (mini_type_is_reference (param1_type)); ins->type = STACK_OBJ; break; } @@ -1718,43 +1805,18 @@ mini_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSign ins = i2f; } + if (u2i_result_opcode) { + MONO_INST_NEW (cfg, u2i_result, u2i_result_opcode); + u2i_result->dreg = mono_alloc_ireg (cfg); + u2i_result->sreg1 = ins->dreg; + MONO_ADD_INS (cfg->cbb, u2i_result); + + ins = u2i_result; + } if (cfg->gen_write_barriers && is_ref) mini_emit_write_barrier (cfg, args [0], args [1]); } - else if ((strcmp (cmethod->name, "CompareExchange") == 0) && fsig->param_count == 4 && - fsig->params [1]->type == MONO_TYPE_I4) { - MonoInst *cmp, *ceq; - - if (!mono_arch_opcode_supported (OP_ATOMIC_CAS_I4)) - return NULL; - - /* int32 r = CAS (location, value, comparand); */ - MONO_INST_NEW (cfg, ins, OP_ATOMIC_CAS_I4); - ins->dreg = alloc_ireg (cfg); - ins->sreg1 = args [0]->dreg; - ins->sreg2 = args [1]->dreg; - ins->sreg3 = args [2]->dreg; - ins->type = STACK_I4; - MONO_ADD_INS (cfg->cbb, ins); - - /* bool result = r == comparand; */ - MONO_INST_NEW (cfg, cmp, OP_ICOMPARE); - cmp->sreg1 = ins->dreg; - cmp->sreg2 = args [2]->dreg; - cmp->type = STACK_I4; - MONO_ADD_INS (cfg->cbb, cmp); - - MONO_INST_NEW (cfg, ceq, OP_ICEQ); - ceq->dreg = alloc_ireg (cfg); - ceq->type = STACK_I4; - MONO_ADD_INS (cfg->cbb, ceq); - - /* *success = result; */ - MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STOREI1_MEMBASE_REG, args [3]->dreg, 0, ceq->dreg); - - cfg->has_atomic_cas_i4 = TRUE; - } else if (strcmp (cmethod->name, "MemoryBarrier") == 0 && fsig->param_count == 0) ins = mini_emit_memory_barrier (cfg, MONO_MEMORY_BARRIER_SEQ); diff --git a/src/mono/mono/mini/method-to-ir.c b/src/mono/mono/mini/method-to-ir.c index 6734b2d0ce5..d9432fd5510 100644 --- a/src/mono/mono/mini/method-to-ir.c +++ b/src/mono/mono/mini/method-to-ir.c @@ -4179,6 +4179,20 @@ mono_method_check_inlining (MonoCompile *cfg, MonoMethod *method) if (method_does_not_return (method)) return FALSE; + MonoAotModule *amodule = m_class_get_image (method->klass)->aot_module; + // If method is present in aot image compiled with llvm and it uses hw intrinsics we don't inline it, + // since we might not have support for those intrinsics with JIT + if (amodule && (amodule != AOT_MODULE_NOT_FOUND) && (mono_aot_get_module_flags (amodule) & MONO_AOT_FILE_FLAG_WITH_LLVM)) { + ERROR_DECL (error); + mono_class_init_internal (method->klass); + gpointer addr = mono_aot_get_method (method, error); + if (addr && is_ok (error)) { + MonoAotMethodFlags flags = mono_aot_get_method_flags (addr); + if (flags & MONO_AOT_METHOD_FLAG_HAS_LLVM_INTRINSICS) + return FALSE; + } + } + return TRUE; } diff --git a/src/mono/mono/mini/mini-amd64.c b/src/mono/mono/mini/mini-amd64.c index 12c4929d6b5..329c83a1138 100644 --- a/src/mono/mono/mini/mini-amd64.c +++ b/src/mono/mono/mini/mini-amd64.c @@ -6905,9 +6905,27 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) break; } + case OP_ATOMIC_EXCHANGE_U1: + case OP_ATOMIC_EXCHANGE_U2: case OP_ATOMIC_EXCHANGE_I4: case OP_ATOMIC_EXCHANGE_I8: { - guint32 size = ins->opcode == OP_ATOMIC_EXCHANGE_I4 ? 4 : 8; + guint32 size; + switch (ins->opcode) { + case OP_ATOMIC_EXCHANGE_U1: + size = 1; + break; + case OP_ATOMIC_EXCHANGE_U2: + size = 2; + break; + case OP_ATOMIC_EXCHANGE_I4: + size = 4; + break; + case OP_ATOMIC_EXCHANGE_I8: + size = 8; + break; + default: + g_assert_not_reached (); + } /* LOCK prefix is implied. */ amd64_mov_reg_reg (code, GP_SCRATCH_REG, ins->sreg2, size); @@ -6915,14 +6933,28 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) amd64_mov_reg_reg (code, ins->dreg, GP_SCRATCH_REG, size); break; } + case OP_ATOMIC_CAS_U1: + case OP_ATOMIC_CAS_U2: case OP_ATOMIC_CAS_I4: case OP_ATOMIC_CAS_I8: { guint32 size; - if (ins->opcode == OP_ATOMIC_CAS_I8) - size = 8; - else + switch (ins->opcode) { + case OP_ATOMIC_CAS_U1: + size = 1; + break; + case OP_ATOMIC_CAS_U2: + size = 2; + break; + case OP_ATOMIC_CAS_I4: size = 4; + break; + case OP_ATOMIC_CAS_I8: + size = 8; + break; + default: + g_assert_not_reached (); + } /* * See http://msdn.microsoft.com/en-us/magazine/cc302329.aspx for @@ -9823,8 +9855,12 @@ mono_arch_opcode_supported (int opcode) switch (opcode) { case OP_ATOMIC_ADD_I4: case OP_ATOMIC_ADD_I8: + case OP_ATOMIC_EXCHANGE_U1: + case OP_ATOMIC_EXCHANGE_U2: case OP_ATOMIC_EXCHANGE_I4: case OP_ATOMIC_EXCHANGE_I8: + case OP_ATOMIC_CAS_U1: + case OP_ATOMIC_CAS_U2: case OP_ATOMIC_CAS_I4: case OP_ATOMIC_CAS_I8: case OP_ATOMIC_LOAD_I1: diff --git a/src/mono/mono/mini/mini-arm64.c b/src/mono/mono/mini/mini-arm64.c index 36ee5a24111..c42684ce693 100644 --- a/src/mono/mono/mini/mini-arm64.c +++ b/src/mono/mono/mini/mini-arm64.c @@ -5086,6 +5086,30 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) arm_movx (code, dreg, ARMREG_IP0); break; } + case OP_ATOMIC_EXCHANGE_U1: { + guint8 *buf [16]; + + buf [0] = code; + arm_ldxrb (code, ARMREG_IP0, sreg1); + arm_stlxrb (code, ARMREG_IP1, sreg2, sreg1); + arm_cbnzw (code, ARMREG_IP1, buf [0]); + + arm_dmb (code, ARM_DMB_ISH); + arm_movx (code, dreg, ARMREG_IP0); + break; + } + case OP_ATOMIC_EXCHANGE_U2: { + guint8 *buf [16]; + + buf [0] = code; + arm_ldxrh (code, ARMREG_IP0, sreg1); + arm_stlxrh (code, ARMREG_IP1, sreg2, sreg1); + arm_cbnzw (code, ARMREG_IP1, buf [0]); + + arm_dmb (code, ARM_DMB_ISH); + arm_movx (code, dreg, ARMREG_IP0); + break; + } case OP_ATOMIC_EXCHANGE_I4: { guint8 *buf [16]; @@ -5110,6 +5134,34 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) arm_movx (code, dreg, ARMREG_IP0); break; } + case OP_ATOMIC_CAS_U1: { + guint8 *buf [16]; + buf [0] = code; + arm_ldxrb (code, ARMREG_IP0, sreg1); + arm_cmpw (code, ARMREG_IP0, ins->sreg3); + buf [1] = code; + arm_bcc (code, ARMCOND_NE, 0); + arm_stlxrb(code, ARMREG_IP1, sreg2, sreg1); + arm_cbnzw (code, ARMREG_IP1, buf [0]); + arm_patch_rel (buf [1], code, MONO_R_ARM64_BCC); + arm_dmb (code, ARM_DMB_ISH); + arm_movx (code, dreg, ARMREG_IP0); + break; + } + case OP_ATOMIC_CAS_U2: { + guint8 *buf [16]; + buf [0] = code; + arm_ldxrh (code, ARMREG_IP0, sreg1); + arm_cmpw (code, ARMREG_IP0, ins->sreg3); + buf [1] = code; + arm_bcc (code, ARMCOND_NE, 0); + arm_stlxrh(code, ARMREG_IP1, sreg2, sreg1); + arm_cbnzw (code, ARMREG_IP1, buf [0]); + arm_patch_rel (buf [1], code, MONO_R_ARM64_BCC); + arm_dmb (code, ARM_DMB_ISH); + arm_movx (code, dreg, ARMREG_IP0); + break; + } case OP_ATOMIC_CAS_I4: { guint8 *buf [16]; @@ -6935,8 +6987,12 @@ mono_arch_opcode_supported (int opcode) switch (opcode) { case OP_ATOMIC_ADD_I4: case OP_ATOMIC_ADD_I8: + case OP_ATOMIC_EXCHANGE_U1: + case OP_ATOMIC_EXCHANGE_U2: case OP_ATOMIC_EXCHANGE_I4: case OP_ATOMIC_EXCHANGE_I8: + case OP_ATOMIC_CAS_U1: + case OP_ATOMIC_CAS_U2: case OP_ATOMIC_CAS_I4: case OP_ATOMIC_CAS_I8: case OP_ATOMIC_LOAD_I1: diff --git a/src/mono/mono/mini/mini-llvm.c b/src/mono/mono/mini/mini-llvm.c index f933a760842..29c8af40b41 100644 --- a/src/mono/mono/mini/mini-llvm.c +++ b/src/mono/mono/mini/mini-llvm.c @@ -1593,7 +1593,7 @@ sig_to_llvm_sig_full (EmitContext *ctx, MonoMethodSignature *sig, LLVMCallInfo * ret_type = LLVMStructType (members, 1, FALSE); } else if (cinfo->ret.pair_storage [0] == LLVMArgNone && cinfo->ret.pair_storage [1] == LLVMArgNone) { /* Empty struct */ - ret_type = LLVMVoidType (); + ret_type = LLVMStructType (NULL, 0, FALSE); } else if (cinfo->ret.pair_storage [0] == LLVMArgInIReg && cinfo->ret.pair_storage [1] == LLVMArgInIReg) { LLVMTypeRef members [2]; @@ -1610,7 +1610,11 @@ sig_to_llvm_sig_full (EmitContext *ctx, MonoMethodSignature *sig, LLVMCallInfo * case LLVMArgVtypeAsScalar: { int size = mono_class_value_size (mono_class_from_mono_type_internal (rtype), NULL); /* LLVM models this by returning an int */ - if (size < TARGET_SIZEOF_VOID_P) { + if (size == 0) { + /* Empty struct with LayoutKind attribute and without specified size */ + g_assert(cinfo->ret.nslots == 0); + ret_type = LLVMIntType (8); + } else if (size < TARGET_SIZEOF_VOID_P) { g_assert (cinfo->ret.nslots == 1); ret_type = LLVMIntType (size * 8); } else { @@ -2958,7 +2962,10 @@ build_alloca_llvm_type_name (EmitContext *ctx, LLVMTypeRef t, int align, const c * Have to place all alloca's at the end of the entry bb, since otherwise they would * get executed every time control reaches them. */ - LLVMPositionBuilder (ctx->alloca_builder, get_bb (ctx, ctx->cfg->bb_entry), ctx->last_alloca); + if (ctx->last_alloca) + LLVMPositionBuilder (ctx->alloca_builder, get_bb (ctx, ctx->cfg->bb_entry), ctx->last_alloca); + else + LLVMPositionBuilderAtEnd (ctx->alloca_builder, get_bb (ctx, ctx->cfg->bb_entry)); ctx->last_alloca = mono_llvm_build_alloca (ctx->alloca_builder, t, NULL, align, name); return ctx->last_alloca; @@ -2978,10 +2985,10 @@ build_named_alloca (EmitContext *ctx, MonoType *t, char const *name) g_assert (!mini_is_gsharedvt_variable_type (t)); - if (mini_class_is_simd (ctx->cfg, k)) - align = mono_class_value_size (k, NULL); + if (mini_class_is_simd (ctx->cfg, k) && !m_type_is_byref (t)) + align = mono_class_value_size (k, NULL); // FIXME mono_type_size should report correct alignment else - align = mono_class_min_align (k); + mono_type_size (t, &align); /* Sometimes align is not a power of 2 */ while (mono_is_power_of_two (align) == -1) @@ -4946,6 +4953,9 @@ process_call (EmitContext *ctx, MonoBasicBlock *bb, LLVMBuilderRef *builder_ref, /* Empty struct */ break; + if (LLVMTypeOf (lcall) == LLVMStructType (NULL, 0, FALSE)) + break; + if (!addresses [ins->dreg]) addresses [ins->dreg] = build_alloca_address (ctx, sig->ret); @@ -5610,6 +5620,17 @@ scalar_op_from_vector_op_process_result (ScalarOpFromVectorOpCtx *sctx, LLVMValu return vector_from_scalar (sctx->ctx, sctx->return_type, result); } +static gboolean bb_needs_call_handler_target(MonoBasicBlock *bb, EmitContext *ctx) +{ + if (ctx->cfg->interp_entry_only || !(bb->region != -1 && (bb->flags & BB_EXCEPTION_HANDLER))) + return FALSE; + + if (ctx->cfg->deopt && MONO_REGION_FLAGS (bb->region) == MONO_EXCEPTION_CLAUSE_FILTER) + return FALSE; + + return TRUE; +} + static void emit_llvmonly_handler_start (EmitContext *ctx, MonoBasicBlock *bb, LLVMBasicBlockRef cbb) { @@ -5629,8 +5650,13 @@ emit_llvmonly_handler_start (EmitContext *ctx, MonoBasicBlock *bb, LLVMBasicBloc } } - LLVMBuilderRef handler_builder = create_builder (ctx); LLVMBasicBlockRef target_bb = ctx->bblocks [bb->block_num].call_handler_target_bb; + if (!target_bb) { + g_assert(!bb_needs_call_handler_target (bb, ctx)); + return; + } + + LLVMBuilderRef handler_builder = create_builder (ctx); LLVMPositionBuilderAtEnd (handler_builder, target_bb); // Make the handler code end with a jump to cbb @@ -6299,6 +6325,9 @@ process_bb (EmitContext *ctx, MonoBasicBlock *bb) gboolean likely = (ins->flags & MONO_INST_LIKELY) != 0; gboolean unlikely = FALSE; + if (!ins->next) + break; + if (MONO_IS_COND_BRANCH_OP (ins->next)) { if (ins->next->inst_false_bb->out_of_line) likely = TRUE; @@ -7555,15 +7584,29 @@ MONO_RESTORE_WARNING #define ARM64_ATOMIC_FENCE_FIX #endif + case OP_ATOMIC_EXCHANGE_U1: + case OP_ATOMIC_EXCHANGE_U2: case OP_ATOMIC_EXCHANGE_I4: case OP_ATOMIC_EXCHANGE_I8: { LLVMValueRef args [2]; LLVMTypeRef t; - if (ins->opcode == OP_ATOMIC_EXCHANGE_I4) + switch (ins->opcode) { + case OP_ATOMIC_EXCHANGE_U1: + t = LLVMInt8Type (); + break; + case OP_ATOMIC_EXCHANGE_U2: + t = LLVMInt16Type (); + break; + case OP_ATOMIC_EXCHANGE_I4: t = LLVMInt32Type (); - else + break; + case OP_ATOMIC_EXCHANGE_I8: t = LLVMInt64Type (); + break; + default: + g_assert_not_reached (); + } g_assert (ins->inst_offset == 0); @@ -7607,15 +7650,29 @@ MONO_RESTORE_WARNING ARM64_ATOMIC_FENCE_FIX; break; } + case OP_ATOMIC_CAS_U1: + case OP_ATOMIC_CAS_U2: case OP_ATOMIC_CAS_I4: case OP_ATOMIC_CAS_I8: { LLVMValueRef args [3], val; LLVMTypeRef t; - if (ins->opcode == OP_ATOMIC_CAS_I4) + switch (ins->opcode) { + case OP_ATOMIC_CAS_U1: + t = LLVMInt8Type (); + break; + case OP_ATOMIC_CAS_U2: + t = LLVMInt16Type (); + break; + case OP_ATOMIC_CAS_I4: t = LLVMInt32Type (); - else + break; + case OP_ATOMIC_CAS_I8: t = LLVMInt64Type (); + break; + default: + g_assert_not_reached (); + } args [0] = convert (ctx, lhs, pointer_type (t)); /* comparand */ @@ -10363,7 +10420,7 @@ MONO_RESTORE_WARNING int stride_len = 32 / cn; int stride_len_2 = stride_len >> 1; int n_strides = 16 / stride_len; - LLVMValueRef swizzle_mask = LLVMConstNull (LLVMVectorType (i8_t, 16)); + LLVMValueRef swizzle_mask = LLVMConstNull (LLVMVectorType (i1_t, 16)); for (int i = 0; i < n_strides; i++) for (int j = 0; j < stride_len; j++) swizzle_mask = LLVMBuildInsertElement (builder, swizzle_mask, const_int8(i * stride_len + ((stride_len_2 + j) % stride_len)), const_int32 (i * stride_len + j), ""); @@ -13368,10 +13425,7 @@ emit_method_inner (EmitContext *ctx) int clause_index; char name [128]; - if (ctx->cfg->interp_entry_only || !(bb->region != -1 && (bb->flags & BB_EXCEPTION_HANDLER))) - continue; - - if (ctx->cfg->deopt && MONO_REGION_FLAGS (bb->region) == MONO_EXCEPTION_CLAUSE_FILTER) + if (!bb_needs_call_handler_target(bb, ctx)) continue; clause_index = MONO_REGION_CLAUSE_INDEX (bb->region); diff --git a/src/mono/mono/mini/mini-ops.h b/src/mono/mono/mini/mini-ops.h index 3020fe0d535..76a1c49c15e 100644 --- a/src/mono/mono/mini/mini-ops.h +++ b/src/mono/mono/mini/mini-ops.h @@ -1274,9 +1274,13 @@ MINI_OP(OP_ATOMIC_AND_I8, "atomic_and_i8", IREG, IREG, IREG) MINI_OP(OP_ATOMIC_OR_I4, "atomic_or_i4", IREG, IREG, IREG) MINI_OP(OP_ATOMIC_OR_I8, "atomic_or_i8", IREG, IREG, IREG) +MINI_OP(OP_ATOMIC_EXCHANGE_U1, "atomic_exchange_u1", IREG, IREG, IREG) +MINI_OP(OP_ATOMIC_EXCHANGE_U2, "atomic_exchange_u2", IREG, IREG, IREG) MINI_OP(OP_ATOMIC_EXCHANGE_I4, "atomic_exchange_i4", IREG, IREG, IREG) MINI_OP(OP_ATOMIC_EXCHANGE_I8, "atomic_exchange_i8", IREG, IREG, IREG) +MINI_OP3(OP_ATOMIC_CAS_U1, "atomic_cas_u1", IREG, IREG, IREG, IREG) +MINI_OP3(OP_ATOMIC_CAS_U2, "atomic_cas_u2", IREG, IREG, IREG, IREG) MINI_OP3(OP_ATOMIC_CAS_I4, "atomic_cas_i4", IREG, IREG, IREG, IREG) MINI_OP3(OP_ATOMIC_CAS_I8, "atomic_cas_i8", IREG, IREG, IREG, IREG) diff --git a/src/mono/mono/mini/mini-ppc.c b/src/mono/mono/mini/mini-ppc.c index a5c1fbb2f98..3cca8f1f378 100644 --- a/src/mono/mono/mini/mini-ppc.c +++ b/src/mono/mono/mini/mini-ppc.c @@ -4221,11 +4221,11 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) ppc_lfd (code, ins->dreg, ins->inst_offset, ins->inst_basereg); } else { if (ppc_is_imm32 (ins->inst_offset)) { - ppc_addis (code, ppc_r11, ins->inst_destbasereg, ppc_ha(ins->inst_offset)); + ppc_addis (code, ppc_r11, ins->inst_basereg, ppc_ha(ins->inst_offset)); ppc_lfd (code, ins->dreg, ins->inst_offset, ppc_r11); } else { ppc_load (code, ppc_r0, ins->inst_offset); - ppc_lfdx (code, ins->dreg, ins->inst_destbasereg, ppc_r0); + ppc_lfdx (code, ins->dreg, ins->inst_basereg, ppc_r0); } } break; @@ -4248,11 +4248,11 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) ppc_lfs (code, ins->dreg, ins->inst_offset, ins->inst_basereg); } else { if (ppc_is_imm32 (ins->inst_offset)) { - ppc_addis (code, ppc_r11, ins->inst_destbasereg, ppc_ha(ins->inst_offset)); + ppc_addis (code, ppc_r11, ins->inst_basereg, ppc_ha(ins->inst_offset)); ppc_lfs (code, ins->dreg, ins->inst_offset, ppc_r11); } else { ppc_load (code, ppc_r0, ins->inst_offset); - ppc_lfsx (code, ins->dreg, ins->inst_destbasereg, ppc_r0); + ppc_lfsx (code, ins->dreg, ins->inst_basereg, ppc_r0); } } break; @@ -5202,11 +5202,32 @@ mono_arch_emit_prolog (MonoCompile *cfg) break; } } else if (ainfo->regtype == RegTypeFP) { - g_assert (ppc_is_imm16 (inst->inst_offset)); - if (ainfo->size == 8) - ppc_stfd (code, ainfo->reg, inst->inst_offset, inst->inst_basereg); - else if (ainfo->size == 4) - ppc_stfs (code, ainfo->reg, inst->inst_offset, inst->inst_basereg); + if (ainfo->size == 8) { + if (ppc_is_imm16 (inst->inst_offset)) { + ppc_stfd (code, ainfo->reg, inst->inst_offset, inst->inst_basereg); + } + else if (ppc_is_imm32 (inst->inst_offset)) { + ppc_addis (code, ppc_r12, inst->inst_basereg, ppc_ha(inst->inst_offset)); + ppc_stfd (code, ainfo->reg, inst->inst_offset, ppc_r12); + } + else { + ppc_load (code, ppc_r12, inst->inst_offset); + ppc_stfdx (code, ainfo->reg, inst->inst_basereg, ppc_r12); + } + } + else if (ainfo->size == 4) { + if (ppc_is_imm16 (inst->inst_offset)) { + ppc_stfs (code, ainfo->reg, inst->inst_offset, inst->inst_basereg); + } + else if (ppc_is_imm32 (inst->inst_offset)) { + ppc_addis (code, ppc_r12, inst->inst_basereg, ppc_ha(inst->inst_offset)); + ppc_stfs (code, ainfo->reg, inst->inst_offset, ppc_r12); + } + else { + ppc_load (code, ppc_r12, inst->inst_offset); + ppc_stfsx (code, ainfo->reg, inst->inst_basereg, ppc_r12); + } + } else g_assert_not_reached (); } else if (ainfo->regtype == RegTypeFPStructByVal) { @@ -5214,17 +5235,39 @@ mono_arch_emit_prolog (MonoCompile *cfg) int soffset = 0; int cur_reg; int size = 0; - g_assert (ppc_is_imm16 (inst->inst_offset)); - g_assert (ppc_is_imm16 (inst->inst_offset + ainfo->vtregs * sizeof (target_mgreg_t))); /* FIXME: what if there is no class? */ if (sig->pinvoke && !sig->marshalling_disabled && mono_class_from_mono_type_internal (inst->inst_vtype)) size = mono_class_native_size (mono_class_from_mono_type_internal (inst->inst_vtype), NULL); for (cur_reg = 0; cur_reg < ainfo->vtregs; ++cur_reg) { - if (ainfo->size == 4) { - ppc_stfs (code, ainfo->reg + cur_reg, doffset, inst->inst_basereg); - } else { - ppc_stfd (code, ainfo->reg + cur_reg, doffset, inst->inst_basereg); - } + if (ainfo->size == 8){ + if (ppc_is_imm16 (inst->inst_offset)) { + ppc_stfd (code, ainfo->reg + cur_reg, doffset, inst->inst_basereg); + } + else if (ppc_is_imm32 (inst->inst_offset)) { + ppc_addis (code, ppc_r12, inst->inst_basereg, ppc_ha(doffset)); + ppc_stfd (code, ainfo->reg + cur_reg, doffset, ppc_r12); + } + else { + ppc_load (code, ppc_r12, doffset); + ppc_stfdx (code, ainfo->reg + cur_reg, inst->inst_basereg, ppc_r12); + } + } + else if (ainfo->size == 4){ + if (ppc_is_imm16 (inst->inst_offset)) { + ppc_stfs (code, ainfo->reg + cur_reg, doffset, inst->inst_basereg); + } + else if (ppc_is_imm32 (inst->inst_offset)) { + ppc_addis (code, ppc_r12, inst->inst_basereg, ppc_ha(doffset)); + ppc_stfs (code, ainfo->reg + cur_reg, doffset, ppc_r12); + } + else { + ppc_load (code, ppc_r12, doffset); + ppc_stfsx (code, ainfo->reg + cur_reg, inst->inst_basereg, ppc_r12); + } + } + else + g_assert_not_reached (); + soffset += ainfo->size; doffset += ainfo->size; } diff --git a/src/mono/mono/mini/mini-s390x.c b/src/mono/mono/mini/mini-s390x.c index e90a0e6770e..3419a29768c 100644 --- a/src/mono/mono/mini/mini-s390x.c +++ b/src/mono/mono/mini/mini-s390x.c @@ -3471,7 +3471,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) s390_srag (code, ins->dreg, ins->dreg, 0, 32); break; case OP_MOVE_I4_TO_F: - s390_slag (code, s390_r0, ins->sreg1, 0, 32); + s390_sllg (code, s390_r0, ins->sreg1, 0, 32); s390_ldgr (code, ins->dreg, s390_r0); break; case OP_FCONV_TO_R4: diff --git a/src/mono/mono/mini/mini-wasm.c b/src/mono/mono/mini/mini-wasm.c index db7c8b2de39..2a210e4af6e 100644 --- a/src/mono/mono/mini/mini-wasm.c +++ b/src/mono/mono/mini/mini-wasm.c @@ -175,8 +175,12 @@ mono_arch_opcode_supported (int opcode) switch (opcode) { case OP_ATOMIC_ADD_I4: case OP_ATOMIC_ADD_I8: + case OP_ATOMIC_EXCHANGE_U1: + case OP_ATOMIC_EXCHANGE_U2: case OP_ATOMIC_EXCHANGE_I4: case OP_ATOMIC_EXCHANGE_I8: + case OP_ATOMIC_CAS_U1: + case OP_ATOMIC_CAS_U2: case OP_ATOMIC_CAS_I4: case OP_ATOMIC_CAS_I8: case OP_ATOMIC_LOAD_I1: @@ -573,7 +577,6 @@ mono_init_native_crash_info (void) void mono_runtime_setup_stat_profiler (void) { - g_error ("mono_runtime_setup_stat_profiler"); } gboolean diff --git a/src/mono/mono/mini/mini.c b/src/mono/mono/mini/mini.c index 395a869ab22..63d89b3f28a 100644 --- a/src/mono/mono/mini/mini.c +++ b/src/mono/mono/mini/mini.c @@ -420,6 +420,7 @@ mono_type_to_load_membase (MonoCompile *cfg, MonoType *type) case MONO_TYPE_VALUETYPE: if (mini_class_is_simd (cfg, mono_class_from_mono_type_internal (type))) return OP_LOADX_MEMBASE; + return OP_LOADV_MEMBASE; case MONO_TYPE_TYPEDBYREF: return OP_LOADV_MEMBASE; case MONO_TYPE_GENERICINST: diff --git a/src/mono/mono/mini/simd-intrinsics.c b/src/mono/mono/mini/simd-intrinsics.c index 47b1df99798..44e7072def7 100644 --- a/src/mono/mono/mini/simd-intrinsics.c +++ b/src/mono/mono/mini/simd-intrinsics.c @@ -2980,7 +2980,8 @@ emit_sri_vector (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsi return ins; } else { g_assert ((arg0_type == MONO_TYPE_I4) || (arg0_type == MONO_TYPE_U4)); - return emit_simd_ins_for_sig (cfg, klass, OP_SSE2_PSHUFD, 0, arg0_type, fsig, new_args); + return NULL; +// return emit_simd_ins_for_sig (cfg, klass, OP_SSE2_PSHUFD, 0, arg0_type, fsig, args); } } // There is no variable shuffle until avx512 diff --git a/src/mono/mono/profiler/CMakeLists.txt b/src/mono/mono/profiler/CMakeLists.txt index e172774a6eb..f4271dc8bd4 100644 --- a/src/mono/mono/profiler/CMakeLists.txt +++ b/src/mono/mono/profiler/CMakeLists.txt @@ -6,6 +6,7 @@ include_directories( ${PROJECT_BINARY_DIR}/../../mono/eglib ${CMAKE_CURRENT_SOURCE_DIR}/../.. ${PROJECT_SOURCE_DIR}/../ + ${PROJECT_SOURCE_DIR}/../../../native/public ${PROJECT_SOURCE_DIR}/../eglib ${PROJECT_SOURCE_DIR}/../sgen) @@ -47,4 +48,18 @@ if(NOT DISABLE_LIBS) set_target_properties(mono-profiler-browser-static PROPERTIES OUTPUT_NAME mono-profiler-browser) install(TARGETS mono-profiler-browser-static LIBRARY) endif() + + if(HOST_BROWSER) + add_library(mono-profiler-log-static STATIC helper.c log.c log-args.c) + set_target_properties(mono-profiler-log-static PROPERTIES OUTPUT_NAME mono-profiler-log) + install(TARGETS mono-profiler-log-static LIBRARY) + + if(NOT DISABLE_LOG_PROFILER_GZ) + if (CLR_CMAKE_USE_SYSTEM_ZLIB) + target_link_libraries(mono-profiler-log-static PRIVATE ${Z_LIBS}) + else() + target_link_libraries(mono-profiler-log-static PRIVATE zlib) + endif() + endif() + endif() endif() diff --git a/src/mono/mono/profiler/helper.c b/src/mono/mono/profiler/helper.c index bbff8e7bf95..05fc31b6708 100644 --- a/src/mono/mono/profiler/helper.c +++ b/src/mono/mono/profiler/helper.c @@ -8,7 +8,9 @@ #include +#if !defined (HOST_WASM) #include +#endif #ifdef HAVE_UNISTD_H #include @@ -42,6 +44,7 @@ mono_profhelper_close_socket_fd (SOCKET fd) void mono_profhelper_setup_command_server (SOCKET *server_socket, int *command_port, const char* profiler_name) { +#if !defined (HOST_WASM) *server_socket = socket (PF_INET, SOCK_STREAM, 0); if (*server_socket == INVALID_SOCKET) { @@ -77,11 +80,13 @@ mono_profhelper_setup_command_server (SOCKET *server_socket, int *command_port, } *command_port = ntohs (server_address.sin_port); +#endif } void mono_profhelper_add_to_fd_set (fd_set *set, SOCKET fd, int *max_fd) { +#if !defined (HOST_WASM) /* * This should only trigger for the basic FDs (server socket, pipes) at * startup if for some mysterious reason they're too large. In this case, @@ -99,4 +104,5 @@ mono_profhelper_add_to_fd_set (fd_set *set, SOCKET fd, int *max_fd) if (*max_fd < GUINT64_TO_INT(fd)) *max_fd = (int)fd; +#endif } diff --git a/src/mono/mono/profiler/log-args.c b/src/mono/mono/profiler/log-args.c index c8609177d18..124a629a14c 100644 --- a/src/mono/mono/profiler/log-args.c +++ b/src/mono/mono/profiler/log-args.c @@ -1,4 +1,5 @@ #include +#include #include #include #include @@ -98,6 +99,9 @@ parse_arg (const char *arg, ProfilerConfig *config) } else if (match_option (arg, "heapshot-on-shutdown", NULL)) { config->hs_on_shutdown = TRUE; config->enable_mask |= PROFLOG_HEAPSHOT_ALIAS; + } else if (match_option (arg, "take-heapshot-method", &val)) { + printf ("take-heapshot-method: %s\n", val); + set_log_profiler_take_heapshot_method(val); } else if (match_option (arg, "sample", &val)) { set_sample_freq (config, val); config->sampling_mode = MONO_PROFILER_SAMPLE_MODE_PROCESS; diff --git a/src/mono/mono/profiler/log.c b/src/mono/mono/profiler/log.c index abe5f3f479f..24d38342966 100644 --- a/src/mono/mono/profiler/log.c +++ b/src/mono/mono/profiler/log.c @@ -189,6 +189,8 @@ typedef struct { int small_id; } MonoProfilerThread; +static MonoMethodDesc *log_profiler_take_heapshot_method; + // Default value in `profiler_tls` for new threads. #define MONO_PROFILER_THREAD_ZERO ((MonoProfilerThread *) NULL) @@ -617,6 +619,7 @@ buffer_lock_helper (void); static void buffer_lock (void) { +#if !defined (HOST_WASM) /* * If the thread holding the exclusive lock tries to modify the * reader count, just make it a no-op. This way, we also avoid @@ -657,6 +660,8 @@ buffer_lock (void) } mono_memory_barrier (); + +#endif // HOST_WASM } static void @@ -685,6 +690,7 @@ buffer_lock_helper (void) static void buffer_unlock (void) { +#if !defined (HOST_WASM) mono_memory_barrier (); gint32 state = mono_atomic_load_i32 (&log_profiler.buffer_lock_state); @@ -697,6 +703,7 @@ buffer_unlock (void) g_assert (!(state >> 16) && "Why is the exclusive lock held?"); mono_atomic_dec_i32 (&log_profiler.buffer_lock_state); +#endif // HOST_WASM } static void @@ -3499,6 +3506,7 @@ runtime_initialized (MonoProfiler *profiler) mono_os_sem_init (&log_profiler.attach_threads_sem, 0); +#if !defined (HOST_WASM) /* * We must start the helper thread before the writer thread. This is * because start_helper_thread () sets up the command port which is written @@ -3507,6 +3515,9 @@ runtime_initialized (MonoProfiler *profiler) start_helper_thread (); start_writer_thread (); start_dumper_thread (); +#else + dump_header (); +#endif /* * Wait for all the internal threads to be started. If we don't do this, we @@ -3588,7 +3599,7 @@ create_profiler (const char *args, const char *filename, GPtrArray *filters) } } if (*nf == '|') { -#if HAVE_API_SUPPORT_WIN32_PIPE_OPEN_CLOSE && !defined (HOST_WIN32) +#if HAVE_API_SUPPORT_WIN32_PIPE_OPEN_CLOSE && !defined (HOST_WIN32) && !defined (HOST_WASM) log_profiler.file = popen (nf + 1, "w"); log_profiler.pipe_output = 1; #else @@ -3636,6 +3647,44 @@ create_profiler (const char *args, const char *filename, GPtrArray *filters) log_profiler.startup_time = current_time (); } +void +set_log_profiler_take_heapshot_method (const char *val) +{ + log_profiler_take_heapshot_method = mono_method_desc_new (val, TRUE); + + if (!log_profiler_take_heapshot_method) { + mono_profiler_printf_err ("Could not parse method description: %s", val); + exit (1); + } +} + +static void +proflog_trigger_heapshot (void); + +static void +prof_jit_done (MonoProfiler *prof, MonoMethod *method, MonoJitInfo *jinfo) +{ + MonoImage *image = mono_class_get_image (mono_method_get_class (method)); + + if (!image->assembly || method->wrapper_type || !log_profiler_take_heapshot_method) + return; + + if (log_profiler_take_heapshot_method && mono_method_desc_match (log_profiler_take_heapshot_method, method)) { + printf ("log-profiler | taking heapshot\n"); + proflog_trigger_heapshot (); + return; + } + else { + printf ("log-profiler not called (%p)\n", log_profiler_take_heapshot_method); + } +} + +static void +prof_inline_method (MonoProfiler *prof, MonoMethod *method, MonoMethod *inlined_method) +{ + prof_jit_done (prof, inlined_method, NULL); +} + MONO_API void mono_profiler_init_log (const char *desc); @@ -3758,6 +3807,9 @@ mono_profiler_init_log (const char *desc) mono_profiler_enable_allocations (); mono_profiler_enable_clauses (); mono_profiler_enable_sampling (handle); + mono_profiler_set_jit_done_callback (handle, prof_jit_done); + mono_profiler_set_inline_method_callback (handle, prof_inline_method); + /* * If no sample option was given by the user, this just leaves the sampling @@ -3770,3 +3822,12 @@ mono_profiler_init_log (const char *desc) done: ; } + +static void +proflog_trigger_heapshot (void) +{ + trigger_heapshot (); + + while (handle_writer_queue_entry ()); + while (handle_dumper_queue_entry ()); +} \ No newline at end of file diff --git a/src/mono/mono/profiler/log.h b/src/mono/mono/profiler/log.h index 9e3b320a7cf..a246afd1c17 100644 --- a/src/mono/mono/profiler/log.h +++ b/src/mono/mono/profiler/log.h @@ -526,5 +526,6 @@ typedef struct { } ProfilerConfig; void proflog_parse_args (ProfilerConfig *config, const char *desc); +void set_log_profiler_take_heapshot_method (const char *val); #endif /* __MONO_PROFLOG_H__ */ diff --git a/src/mono/mono/utils/CMakeLists.txt b/src/mono/mono/utils/CMakeLists.txt index ef271dcb830..8f5a70cfd3f 100644 --- a/src/mono/mono/utils/CMakeLists.txt +++ b/src/mono/mono/utils/CMakeLists.txt @@ -217,12 +217,6 @@ endif() set(utils_sources "${utils_platform_sources};${utils_arch_sources};${utils_common_sources}") -set(utils_sources - ${utils_sources} - ${CLR_SRC_NATIVE_DIR}/external/libunwind/include/remote/freebsd-elf_common.h - ${CLR_SRC_NATIVE_DIR}/external/libunwind/include/remote/freebsd-elf32.h - ${CLR_SRC_NATIVE_DIR}/external/libunwind/include/remote/freebsd-elf64.h) - if(ENABLE_DTRACE) find_program(DTRACE dtrace) if(TARGET_OSX) diff --git a/src/mono/mono/utils/atomic.h b/src/mono/mono/utils/atomic.h index 7d1d127f60c..3f0a01e6beb 100644 --- a/src/mono/mono/utils/atomic.h +++ b/src/mono/mono/utils/atomic.h @@ -95,6 +95,22 @@ Apple targets have historically being problematic, xcode 4.6 would miscompile th #include +static inline guint8 +mono_atomic_cas_u8 (volatile guint8 *dest, guint8 exch, guint8 comp) +{ + g_static_assert (sizeof (atomic_char) == sizeof (*dest) && ATOMIC_CHAR_LOCK_FREE == 2); + (void)atomic_compare_exchange_strong ((volatile atomic_char *)dest, (char*)&comp, exch); + return comp; +} + +static inline guint16 +mono_atomic_cas_u16 (volatile guint16 *dest, guint16 exch, guint16 comp) +{ + g_static_assert (sizeof (atomic_short) == sizeof (*dest) && ATOMIC_SHORT_LOCK_FREE == 2); + (void)atomic_compare_exchange_strong ((volatile atomic_short *)dest, (short*)&comp, exch); + return comp; +} + static inline gint32 mono_atomic_cas_i32 (volatile gint32 *dest, gint32 exch, gint32 comp) { @@ -171,6 +187,20 @@ mono_atomic_dec_i64 (volatile gint64 *dest) return mono_atomic_add_i64 (dest, -1); } +static inline guint8 +mono_atomic_xchg_u8 (volatile guint8 *dest, guint8 exch) +{ + g_static_assert (sizeof (atomic_char) == sizeof (*dest) && ATOMIC_CHAR_LOCK_FREE == 2); + return atomic_exchange ((volatile atomic_char *)dest, exch); +} + +static inline guint16 +mono_atomic_xchg_u16 (volatile guint16 *dest, guint16 exch) +{ + g_static_assert (sizeof (atomic_short) == sizeof (*dest) && ATOMIC_SHORT_LOCK_FREE == 2); + return atomic_exchange ((volatile atomic_short *)dest, exch); +} + static inline gint32 mono_atomic_xchg_i32 (volatile gint32 *dest, gint32 exch) { @@ -311,6 +341,18 @@ mono_atomic_store_ptr (volatile gpointer *dst, gpointer val) #include #include +static inline guint8 +mono_atomic_cas_u8 (volatile guint8 *dest, guint8 exch, guint8 comp) +{ + return _InterlockedCompareExchange8 ((char volatile *)dest, (char)exch, (char)comp); +} + +static inline guint16 +mono_atomic_cas_u16 (volatile guint16 *dest, guint16 exch, guint16 comp) +{ + return _InterlockedCompareExchange16 ((short volatile *)dest, (short)exch, (short)comp); +} + static inline gint32 mono_atomic_cas_i32 (volatile gint32 *dest, gint32 exch, gint32 comp) { @@ -365,6 +407,18 @@ mono_atomic_dec_i64 (volatile gint64 *dest) return InterlockedDecrement64 ((LONG64 volatile *)dest); } +static inline guint8 +mono_atomic_xchg_u8 (volatile guint8 *dest, guint8 exch) +{ + return _InterlockedExchange8 ((char volatile *)dest, (char)exch); +} + +static inline guint16 +mono_atomic_xchg_u16 (volatile guint16 *dest, guint16 exch) +{ + return _InterlockedExchange16 ((short volatile *)dest, (short)exch); +} + static inline gint32 mono_atomic_xchg_i32 (volatile gint32 *dest, gint32 exch) { @@ -508,6 +562,18 @@ mono_atomic_store_ptr (volatile gpointer *dst, gpointer val) #define gcc_sync_fetch_and_add(a, b) __sync_fetch_and_add (a, b) #endif +static inline guint8 mono_atomic_cas_u8(volatile guint8 *dest, + guint8 exch, guint8 comp) +{ + return gcc_sync_val_compare_and_swap (dest, comp, exch); +} + +static inline guint16 mono_atomic_cas_u16(volatile guint16 *dest, + guint16 exch, guint16 comp) +{ + return gcc_sync_val_compare_and_swap (dest, comp, exch); +} + static inline gint32 mono_atomic_cas_i32(volatile gint32 *dest, gint32 exch, gint32 comp) { @@ -534,6 +600,24 @@ static inline gint32 mono_atomic_dec_i32(volatile gint32 *val) return gcc_sync_sub_and_fetch (val, 1); } +static inline guint8 mono_atomic_xchg_u8(volatile guint8 *val, guint8 new_val) +{ + guint8 old_val; + do { + old_val = *val; + } while (gcc_sync_val_compare_and_swap (val, old_val, new_val) != old_val); + return old_val; +} + +static inline guint16 mono_atomic_xchg_u16(volatile guint16 *val, guint16 new_val) +{ + guint16 old_val; + do { + old_val = *val; + } while (gcc_sync_val_compare_and_swap (val, old_val, new_val) != old_val); + return old_val; +} + static inline gint32 mono_atomic_xchg_i32(volatile gint32 *val, gint32 new_val) { gint32 old_val; @@ -726,6 +810,8 @@ static inline void mono_atomic_store_i64(volatile gint64 *dst, gint64 val) #define WAPI_NO_ATOMIC_ASM /* Fallbacks seem to not be used anymore, they should be removed. */ +/* extern guint8 mono_atomic_cas_u8(volatile guint8 *dest, guint8 exch, guint8 comp); */ +/* extern guint16 mono_atomic_cas_u16(volatile guint16 *dest, guint16 exch, guint16 comp); */ extern gint32 mono_atomic_cas_i32(volatile gint32 *dest, gint32 exch, gint32 comp); extern gint64 mono_atomic_cas_i64(volatile gint64 *dest, gint64 exch, gint64 comp); extern gpointer mono_atomic_cas_ptr(volatile gpointer *dest, gpointer exch, gpointer comp); @@ -735,6 +821,8 @@ extern gint32 mono_atomic_inc_i32(volatile gint32 *dest); extern gint64 mono_atomic_inc_i64(volatile gint64 *dest); extern gint32 mono_atomic_dec_i32(volatile gint32 *dest); extern gint64 mono_atomic_dec_i64(volatile gint64 *dest); +/*extern guint8 mono_atomic_xchg_u8(volatile guint8 *dest, guint8 exch); */ +/*extern guint16 mono_atomic_xchg_u16(volatile guint16 *dest, guint16 exch); */ extern gint32 mono_atomic_xchg_i32(volatile gint32 *dest, gint32 exch); extern gint64 mono_atomic_xchg_i64(volatile gint64 *dest, gint64 exch); extern gpointer mono_atomic_xchg_ptr(volatile gpointer *dest, gpointer exch); diff --git a/src/mono/mono/utils/mono-dl.c b/src/mono/mono/utils/mono-dl.c index b772f869d31..cc4578b2c6d 100644 --- a/src/mono/mono/utils/mono-dl.c +++ b/src/mono/mono/utils/mono-dl.c @@ -41,118 +41,6 @@ struct MonoDlFallbackHandler { static GSList *fallback_handlers; -#if defined (_AIX) -#include -#include - -/** - * On AIX/PASE, a shared library can be contained inside of an ar format - * archive. Determine if the file is an ar archive or not. - */ -static gboolean -is_library_ar_archive (char *path) -{ - int lfd, readret; - char magic [SAIAMAG]; - lfd = open (path, O_RDONLY); - - /* don't assume it's an archive on error */ - if (lfd == -1) - return FALSE; - - readret = read (lfd, magic, SAIAMAG); - close (lfd); - /* check for equality with either version of header */ - return readret == SAIAMAG && - (memcmp (magic, AIAMAG, SAIAMAG) == 0 || - memcmp (magic, AIAMAGBIG, SAIAMAG) == 0); -} -#endif - -/* - * read a value string from line with any of the following formats: - * \s*=\s*'string' - * \s*=\s*"string" - * \s*=\s*non_white_space_string - */ -static char* -read_string (char *p, FILE *file) -{ - char *endp; - char *startp; - while (*p && isspace (*p)) - ++p; - if (*p == 0) - return NULL; - if (*p == '=') - p++; - while (*p && isspace (*p)) - ++p; - if (*p == '\'' || *p == '"') { - char t = *p; - p++; - startp = p; - endp = strchr (p, t); - /* FIXME: may need to read more from file... */ - if (!endp) - return NULL; - *endp = 0; - return (char *) g_memdup (startp, GPTRDIFF_TO_UINT ((endp - startp) + 1)); - } - if (*p == 0) - return NULL; - startp = p; - while (*p && !isspace (*p)) - ++p; - *p = 0; - return (char *) g_memdup (startp, GPTRDIFF_TO_UINT ((p - startp) + 1)); -} - -/* - * parse a libtool .la file and return the path of the file to dlopen () - * handling both the installed and uninstalled cases - */ -static char* -get_dl_name_from_libtool (const char *libtool_file) -{ - FILE* file; - char buf [512]; - char *line, *dlname = NULL, *libdir = NULL, *installed = NULL; - if (!(file = fopen (libtool_file, "r"))) - return NULL; - while ((line = fgets (buf, 512, file))) { - while (*line && isspace (*line)) - ++line; - if (*line == '#' || *line == 0) - continue; - if (strncmp ("dlname", line, 6) == 0) { - g_free (dlname); - dlname = read_string (line + 6, file); - } else if (strncmp ("libdir", line, 6) == 0) { - g_free (libdir); - libdir = read_string (line + 6, file); - } else if (strncmp ("installed", line, 9) == 0) { - g_free (installed); - installed = read_string (line + 9, file); - } - } - fclose (file); - line = NULL; - if (installed && strcmp (installed, "no") == 0) { - char *dir = g_path_get_dirname (libtool_file); - if (dlname) - line = g_strconcat (dir, G_DIR_SEPARATOR_S ".libs" G_DIR_SEPARATOR_S, dlname, (const char*)NULL); - g_free (dir); - } else { - if (libdir && dlname) - line = g_strconcat (libdir, G_DIR_SEPARATOR_S, dlname, (const char*)NULL); - } - g_free (dlname); - g_free (libdir); - g_free (installed); - return line; -} - static const char * fix_libc_name (const char *name) { @@ -278,10 +166,6 @@ mono_dl_open_full (const char *name, int mono_flags, int native_flags, MonoError } } if (!lib && !dl_fallback) { - char *lname; - char *llname; - const char *suff; - const char *ext; /* This platform does not support dlopen */ if (name == NULL) { g_free (module); @@ -289,50 +173,11 @@ mono_dl_open_full (const char *name, int mono_flags, int native_flags, MonoError return NULL; } - suff = ".la"; - ext = strrchr (name, '.'); - if (ext && strcmp (ext, ".la") == 0) - suff = ""; - lname = g_strconcat (name, suff, (const char*)NULL); - llname = get_dl_name_from_libtool (lname); - g_free (lname); - if (llname) { - error_init_reuse (load_error); - lib = mono_dl_open_file (llname, lflags, load_error); - mono_error_cleanup (load_error); - - if (lib) - found_name = g_strdup (llname); -#if defined (_AIX) - /* - * HACK: deal with AIX archive members because libtool - * underspecifies when using --with-aix-soname=svr4 - - * without this check, Mono can't find System.Native - * at build time. - * XXX: Does this also need to be in other places? - */ - if (!lib && is_library_ar_archive (llname)) { - /* try common suffix */ - char *llaixname; - llaixname = g_strconcat (llname, "(shr_64.o)", (const char*)NULL); - error_init_reuse (load_error); - lib = mono_dl_open_file (llaixname, lflags, load_error); - mono_error_cleanup (load_error); - if (lib) - found_name = g_strdup (llaixname); - /* XXX: try another suffix like (shr.o)? */ - g_free (llaixname); - } -#endif - g_free (llname); - } - if (!lib) { - char *error_msg = mono_dl_current_error_string (); - mono_error_set_error (error, MONO_ERROR_FILE_NOT_FOUND, "%s", error_msg); - g_free (error_msg); - g_free (module); - return NULL; - } + char *error_msg = mono_dl_current_error_string (); + mono_error_set_error (error, MONO_ERROR_FILE_NOT_FOUND, "%s", error_msg); + g_free (error_msg); + g_free (module); + return NULL; } mono_refcount_init (module, NULL); module->handle = lib; diff --git a/src/mono/mono/utils/options-def.h b/src/mono/mono/utils/options-def.h index bd33aea9e23..895ebe14139 100644 --- a/src/mono/mono/utils/options-def.h +++ b/src/mono/mono/utils/options-def.h @@ -89,7 +89,7 @@ DEFINE_BOOL(jiterpreter_jit_call_enabled, "jiterpreter-jit-call-enabled", TRUE, DEFINE_BOOL(wasm_gc_safepoints, "wasm-gc-safepoints", FALSE, "Use GC safepoints on WASM") #else // traces_enabled controls whether the jiterpreter will JIT individual interpreter opcode traces -DEFINE_BOOL_READONLY(jiterpreter_traces_enabled, "jiterpreter-traces-enabled", FALSE, "JIT interpreter opcode traces into WASM") +DEFINE_BOOL(jiterpreter_traces_enabled, "jiterpreter-traces-enabled", TRUE, "JIT interpreter opcode traces into WASM") // interp_entry_enabled controls whether specialized interp_entry wrappers will be jitted DEFINE_BOOL_READONLY(jiterpreter_interp_entry_enabled, "jiterpreter-interp-entry-enabled", FALSE, "JIT specialized WASM interp_entry wrappers") // jit_call_enabled controls whether do_jit_call will use specialized trampolines for hot call sites @@ -129,6 +129,8 @@ DEFINE_BOOL(jiterpreter_eliminate_null_checks, "jiterpreter-eliminate-null-check DEFINE_BOOL(jiterpreter_backward_branches_enabled, "jiterpreter-backward-branches-enabled", TRUE, "Enable performing backward branches without exiting traces") // Attempt to use WASM v128 opcodes to implement SIMD interpreter opcodes DEFINE_BOOL(jiterpreter_enable_simd, "jiterpreter-simd-enabled", TRUE, "Attempt to use WebAssembly SIMD support") +// Attempt to use WASM atomics opcodes to implement interpreter atomics opcodes +DEFINE_BOOL(jiterpreter_enable_atomics, "jiterpreter-atomics-enabled", TRUE, "Attempt to use WebAssembly atomics support") // Since the zero page is unallocated, loading array/string/span lengths from null ptrs will yield zero DEFINE_BOOL(jiterpreter_zero_page_optimization, "jiterpreter-zero-page-optimization", TRUE, "Exploit the zero page being unallocated to optimize out null checks") // We can produce higher quality code by embedding known constants directly into traces instead of loading @@ -138,7 +140,8 @@ DEFINE_BOOL(jiterpreter_constant_propagation, "jiterpreter-constant-propagation" // When compiling a jit_call wrapper, bypass sharedvt wrappers if possible by inlining their // logic into the compiled wrapper and calling the target AOTed function with native call convention DEFINE_BOOL(jiterpreter_direct_jit_call, "jiterpreter-direct-jit-calls", TRUE, "Bypass gsharedvt wrappers when compiling JIT call wrappers") -// any trace that doesn't have at least this many meaningful (non-nop) opcodes in it will be rejected +// when deciding whether to generate a trace, we sum the value of sequential opcodes that will fit into it +// and reject any trace entry point where the score is below this value DEFINE_INT(jiterpreter_minimum_trace_value, "jiterpreter-minimum-trace-value", 18, "Reject traces that perform less than this amount of (approximate) work") // ensure that we don't create trace entry points too close together DEFINE_INT(jiterpreter_minimum_distance_between_traces, "jiterpreter-minimum-distance-between-traces", 4, "Don't insert entry points closer together than this") @@ -167,12 +170,14 @@ DEFINE_INT(jiterpreter_interp_entry_trampoline_hit_count, "jiterpreter-interp-en DEFINE_INT(jiterpreter_interp_entry_queue_flush_threshold, "jiterpreter-interp-entry-queue-flush-threshold", 3000, "Flush the interp_entry JIT queue after an unJITted call site has this many hits") // In degenerate cases the jiterpreter could end up generating lots of WASM, so shut off jitting once it reaches this limit // Each wasm byte likely maps to multiple bytes of native code, so it's important for this limit not to be too high -DEFINE_INT(jiterpreter_wasm_bytes_limit, "jiterpreter-wasm-bytes-limit", 6 * 1024 * 1024, "Disable jiterpreter code generation once this many bytes of WASM have been generated") +DEFINE_INT(jiterpreter_wasm_bytes_limit, "jiterpreter-wasm-bytes-limit", 8 * 1024 * 1024, "Disable jiterpreter code generation once this many bytes of WASM have been generated") DEFINE_INT(jiterpreter_table_size, "jiterpreter-table-size", 6 * 1024, "Size of the jiterpreter trace function table") // In real-world scenarios these tables can fill up at this size, but making them bigger causes startup time // to bloat to an unacceptable degree. In practice this is still better than nothing. // FIXME: In the future if we find a way to reduce the number of unique tables we can raise this constant DEFINE_INT(jiterpreter_aot_table_size, "jiterpreter-aot-table-size", 3 * 1024, "Size of the jiterpreter AOT trampoline function tables") +DEFINE_INT(jiterpreter_max_module_size, "jiterpreter-max-module-size", 16384, "Size limit for jiterpreter generated WASM modules") +DEFINE_INT(jiterpreter_max_switch_size, "jiterpreter-max-switch-size", 128, "Jump table size limit for jiterpreter switch opcodes (0 to disable)") #endif // HOST_BROWSER #if defined(TARGET_WASM) || defined(TARGET_IOS) || defined(TARGET_TVOS) || defined (TARGET_MACCAT) diff --git a/src/mono/msbuild/apple/data/ProxyProjectForAOTOnHelix.proj b/src/mono/msbuild/apple/data/ProxyProjectForAOTOnHelix.proj index 0230c7d10d3..2847f567f46 100644 --- a/src/mono/msbuild/apple/data/ProxyProjectForAOTOnHelix.proj +++ b/src/mono/msbuild/apple/data/ProxyProjectForAOTOnHelix.proj @@ -109,8 +109,8 @@ Condition="'$(UsePortableRuntimePack)' == 'true'"> - <_RuntimePackFiles Condition="%(_AppleUsedRuntimePackFiles.Extension) == '.dll' and %(_AppleUsedRuntimePackFiles.FileName) != 'System.Private.CoreLib'" Include="@(_AppleUsedRuntimePackFiles->'$(MicrosoftNetCoreAppRuntimePackLibDir)%(FileName)%(Extension)')" /> - <_RuntimePackFiles Condition="%(_AppleUsedRuntimePackFiles.Extension) != '.dll' or %(_AppleUsedRuntimePackFiles.FileName) == 'System.Private.CoreLib'" Include="@(_AppleUsedRuntimePackFiles->'$(MicrosoftNetCoreAppRuntimePackNativeDir)%(FileName)%(Extension)')" /> + <_RuntimePackFiles Condition="(%(_AppleUsedRuntimePackFiles.Extension) == '.dll' or %(_AppleUsedRuntimePackFiles.Extension) == '.pdb') and %(_AppleUsedRuntimePackFiles.FileName) != 'System.Private.CoreLib'" Include="@(_AppleUsedRuntimePackFiles->'$(MicrosoftNetCoreAppRuntimePackLibDir)%(FileName)%(Extension)')" /> + <_RuntimePackFiles Condition="(%(_AppleUsedRuntimePackFiles.Extension) != '.dll' and %(_AppleUsedRuntimePackFiles.Extension) != '.pdb') or %(_AppleUsedRuntimePackFiles.FileName) == 'System.Private.CoreLib'" Include="@(_AppleUsedRuntimePackFiles->'$(MicrosoftNetCoreAppRuntimePackNativeDir)%(FileName)%(Extension)')" /> + <_WorkloadManifestValues Include="NetVersion" Value="net9" /> <_WorkloadManifestValues Include="WorkloadVersion" Value="$(PackageVersion)" /> <_WorkloadManifestValues Include="PackageVersion" Value="$(PackageVersion)" /> diff --git a/src/mono/nuget/Microsoft.NET.Workload.Mono.Toolchain.Current.Manifest/WorkloadManifest.json.in b/src/mono/nuget/Microsoft.NET.Workload.Mono.Toolchain.Current.Manifest/WorkloadManifest.json.in index 764d56ff681..28fb9e5669d 100644 --- a/src/mono/nuget/Microsoft.NET.Workload.Mono.Toolchain.Current.Manifest/WorkloadManifest.json.in +++ b/src/mono/nuget/Microsoft.NET.Workload.Mono.Toolchain.Current.Manifest/WorkloadManifest.json.in @@ -206,10 +206,7 @@ }, "Microsoft.NET.Runtime.WebAssembly.Templates.${NetVersion}": { "kind": "template", - "version": "${PackageVersion}", - "alias-to": { - "any": "Microsoft.NET.Runtime.WebAssembly.Templates" - } + "version": "${PackageVersion}" }, "Microsoft.NETCore.App.Runtime.Mono.${NetVersion}.android-arm": { "kind": "framework", diff --git a/src/mono/nuget/mono-packages.proj b/src/mono/nuget/mono-packages.proj index 4e119edcafa..9c8dbbf3d74 100644 --- a/src/mono/nuget/mono-packages.proj +++ b/src/mono/nuget/mono-packages.proj @@ -17,6 +17,8 @@ + + diff --git a/src/mono/sample/HelloWorld/HelloWorld.csproj b/src/mono/sample/HelloWorld/HelloWorld.csproj index 4f897f0fc56..a35c1bf2859 100644 --- a/src/mono/sample/HelloWorld/HelloWorld.csproj +++ b/src/mono/sample/HelloWorld/HelloWorld.csproj @@ -9,6 +9,7 @@ true normal full + false + + + + diff --git a/src/mono/sample/wasi/Directory.Build.props b/src/mono/sample/wasi/Directory.Build.props index 15caee9a376..ee0b4644bda 100644 --- a/src/mono/sample/wasi/Directory.Build.props +++ b/src/mono/sample/wasi/Directory.Build.props @@ -15,6 +15,12 @@ bin + <_ScriptExt Condition="'$(OS)' == 'Windows_NT'">.cmd + <_ScriptExt Condition="'$(OS)' != 'Windows_NT'">.sh + <_Dotnet>$(RepoRoot)dotnet$(_ScriptExt) + <_ExeExt Condition="$([MSBuild]::IsOSPlatform('WINDOWS'))">.exe + <_Nodejs>$(RepoRoot)node$(_ScriptExt) + <_Npm>$(RepoRoot)npm$(_ScriptExt) false diff --git a/src/mono/sample/wasi/Directory.Build.targets b/src/mono/sample/wasi/Directory.Build.targets index 8e098fca7e9..90f89953129 100644 --- a/src/mono/sample/wasi/Directory.Build.targets +++ b/src/mono/sample/wasi/Directory.Build.targets @@ -8,7 +8,6 @@ <_SampleProjectName>$([System.String]::Copy('$(_SampleProject)').Replace('.csproj','')) <_MONO_LOG_LEVEL Condition="false">--env MONO_LOG_LEVEL=debug --env MONO_LOG_MASK=all <_DOTNET_WASI_PRINT_EXIT_CODE>--env DOTNET_WASI_PRINT_EXIT_CODE=1 - <_ExeExt Condition="$([MSBuild]::IsOSPlatform('WINDOWS'))">.exe - <_ScriptExt Condition="'$(OS)' == 'Windows_NT'">.cmd - <_ScriptExt Condition="'$(OS)' != 'Windows_NT'">.sh - <_Dotnet>$(RepoRoot)dotnet$(_ScriptExt) <_AOTFlag Condition="'$(RunAOTCompilation)' != ''">/p:RunAOTCompilation=$(RunAOTCompilation) @@ -55,5 +51,26 @@ IgnoreExitCode="true" /> + + + + + + + + + \ No newline at end of file diff --git a/src/mono/sample/wasi/http-p2/Program.cs b/src/mono/sample/wasi/http-p2/Program.cs index 98df1a50a05..9bf6140161d 100644 --- a/src/mono/sample/wasi/http-p2/Program.cs +++ b/src/mono/sample/wasi/http-p2/Program.cs @@ -13,8 +13,52 @@ public static class WasiMainWrapper { public static async Task MainAsync(string[] args) { + _ = Task.Delay(100_000_000); // create a task that will not complete before main + await Task.Delay(100); + GC.Collect(); // test that Pollable->Task is not collected until resolved + + var ctsDelay = new CancellationTokenSource(10); + try { + await Task.Delay(1000, ctsDelay.Token); + throw new Exception("delay should have timed out"); + } catch (TaskCanceledException tce) { + if (ctsDelay.Token != tce.CancellationToken) + { + throw new Exception("Different CancellationToken for delay"); + } + Console.WriteLine("impatient delay was canceled as expected"); + } + + using HttpClient impatientClient1 = new(); + impatientClient1.DefaultRequestHeaders.Add("User-Agent", "dotnet WASI unit test"); + impatientClient1.Timeout = TimeSpan.FromMilliseconds(10); + try { + await impatientClient1.GetAsync("https://corefx-net-http11.azurewebsites.net/Echo.ashx?delay10sec"); + throw new Exception("request should have timed out"); + } catch (TaskCanceledException) { + Console.WriteLine("1st impatientClient was canceled as expected"); + } + + GC.Collect(); + + using HttpClient impatientClient2 = new(); + impatientClient2.DefaultRequestHeaders.Add("User-Agent", "dotnet WASI unit test"); + var cts = new CancellationTokenSource(10); + try { + // in reality server side doesn't delay because it doesn't implement it. So 10ms is bit fragile. + // TODO: remove this once we have real WASI HTTP library unit tests with local server loop in Xharness. + // https://github.com/dotnet/xharness/pull/1244 + await impatientClient2.GetAsync("https://corefx-net-http11.azurewebsites.net/Echo.ashx?delay10sec", cts.Token); + throw new Exception("request should have timed out"); + } catch (TaskCanceledException tce) { + if (cts.Token != tce.CancellationToken) + { + throw new Exception("Different CancellationToken"); + } + Console.WriteLine("2nd impatientClient was canceled as expected"); + } + using HttpClient client = new(); - client.Timeout = Timeout.InfiniteTimeSpan; client.DefaultRequestHeaders.Accept.Clear(); client.DefaultRequestHeaders.Add("User-Agent", "dotnet WASI unit test"); @@ -26,6 +70,7 @@ public static async Task MainAsync(string[] args) Console.WriteLine(); Console.WriteLine(json); + GC.Collect(); return 0; } @@ -34,7 +79,7 @@ public static int Main(string[] args) return PollWasiEventLoopUntilResolved((Thread)null!, MainAsync(args)); [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "PollWasiEventLoopUntilResolved")] - static extern int PollWasiEventLoopUntilResolved(Thread t, Task mainTask); + static extern T PollWasiEventLoopUntilResolved(Thread t, Task mainTask); } } diff --git a/src/mono/sample/wasi/jco/.npmrc b/src/mono/sample/wasi/jco/.npmrc new file mode 100644 index 00000000000..33312472ae5 --- /dev/null +++ b/src/mono/sample/wasi/jco/.npmrc @@ -0,0 +1 @@ +registry=https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/ \ No newline at end of file diff --git a/src/mono/sample/wasi/jco/Program.cs b/src/mono/sample/wasi/jco/Program.cs new file mode 100644 index 00000000000..d6637f711e5 --- /dev/null +++ b/src/mono/sample/wasi/jco/Program.cs @@ -0,0 +1,41 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Net.Http.Headers; +using System.Net.Http; +using System.Threading.Tasks; +using System.Threading; +using System.Runtime.CompilerServices; + +// keep in sync with src\mono\wasi\testassets\Http.cs +public static class WasiMainWrapper +{ + public static async Task MainAsync(string[] args) + { + await Task.Delay(100); + + using HttpClient client = new(); + client.DefaultRequestHeaders.Accept.Clear(); + client.DefaultRequestHeaders.Add("User-Agent", "dotnet WASI unit test"); + + var query="https://corefx-net-http11.azurewebsites.net/Echo.ashx"; + var json = await client.GetStringAsync(query); + + Console.WriteLine(); + Console.WriteLine("GET "+query); + Console.WriteLine(); + Console.WriteLine(json); + + return 0; + } + + public static int Main(string[] args) + { + return PollWasiEventLoopUntilResolved((Thread)null!, MainAsync(args)); + + [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "PollWasiEventLoopUntilResolved")] + static extern int PollWasiEventLoopUntilResolved(Thread t, Task mainTask); + } + +} diff --git a/src/mono/sample/wasi/jco/Wasi.Jco.Http.Sample.csproj b/src/mono/sample/wasi/jco/Wasi.Jco.Http.Sample.csproj new file mode 100644 index 00000000000..7fbbc7083e6 --- /dev/null +++ b/src/mono/sample/wasi/jco/Wasi.Jco.Http.Sample.csproj @@ -0,0 +1,10 @@ + + + $(NetCoreAppCurrent) + <_WasiNeedsHttp>true + true + true + + + + diff --git a/src/mono/sample/wasi/jco/main.mjs b/src/mono/sample/wasi/jco/main.mjs new file mode 100644 index 00000000000..c6979504523 --- /dev/null +++ b/src/mono/sample/wasi/jco/main.mjs @@ -0,0 +1,3 @@ +import { run } from './Wasi.Jco.Http.Sample.js'; + +run.run(); diff --git a/src/mono/sample/wasi/jco/package-lock.json b/src/mono/sample/wasi/jco/package-lock.json new file mode 100644 index 00000000000..7f4379b3bc3 --- /dev/null +++ b/src/mono/sample/wasi/jco/package-lock.json @@ -0,0 +1,912 @@ +{ + "name": "jco", + "lockfileVersion": 2, + "requires": true, + "packages": { + "": { + "devDependencies": { + "@bytecodealliance/jco": "1.5.0" + } + }, + "node_modules/@bytecodealliance/componentize-js": { + "version": "0.11.4", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/@bytecodealliance/componentize-js/-/componentize-js-0.11.4.tgz", + "integrity": "sha1-vD4DqeyGtXWn2m0req3EQaYD+M0=", + "dev": true, + "workspaces": [ + "." + ], + "dependencies": { + "@bytecodealliance/jco": "1.4.4", + "@bytecodealliance/wizer": "^7.0.4", + "es-module-lexer": "^1.5.4" + } + }, + "node_modules/@bytecodealliance/componentize-js/node_modules/@bytecodealliance/jco": { + "version": "1.4.4", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/@bytecodealliance/jco/-/jco-1.4.4.tgz", + "integrity": "sha1-ogqFzKrFpvgHbtqzWxuhwQvU8Gw=", + "dev": true, + "license": "(Apache-2.0 WITH LLVM-exception)", + "workspaces": [ + "packages/preview2-shim" + ], + "dependencies": { + "@bytecodealliance/preview2-shim": "^0.16.5", + "binaryen": "^118.0.0", + "chalk-template": "^1", + "commander": "^12", + "mkdirp": "^3", + "ora": "^8", + "terser": "^5" + }, + "bin": { + "jco": "src/jco.js" + } + }, + "node_modules/@bytecodealliance/jco": { + "version": "1.5.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/@bytecodealliance/jco/-/jco-1.5.0.tgz", + "integrity": "sha1-yJZfRrdmgncpVuk9dVjEgW7Xg30=", + "dev": true, + "license": "(Apache-2.0 WITH LLVM-exception)", + "workspaces": [ + "packages/preview2-shim" + ], + "dependencies": { + "@bytecodealliance/componentize-js": "^0.11.3", + "@bytecodealliance/preview2-shim": "^0.16.5", + "binaryen": "^118.0.0", + "chalk-template": "^1", + "commander": "^12", + "mkdirp": "^3", + "ora": "^8", + "terser": "^5" + }, + "bin": { + "jco": "src/jco.js" + } + }, + "node_modules/@bytecodealliance/preview2-shim": { + "version": "0.16.5", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/@bytecodealliance/preview2-shim/-/preview2-shim-0.16.5.tgz", + "integrity": "sha1-JNmvYkPsqxnU/5exhq9ZFeopB0E=", + "dev": true, + "license": "(Apache-2.0 WITH LLVM-exception)" + }, + "node_modules/@bytecodealliance/wizer": { + "version": "7.0.4", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/@bytecodealliance/wizer/-/wizer-7.0.4.tgz", + "integrity": "sha1-/4B8pOvUdUhGD/AUDL7dT8k1Pbk=", + "dev": true, + "license": "Apache-2.0", + "bin": { + "wizer": "wizer.js" + }, + "engines": { + "node": ">=16" + }, + "optionalDependencies": { + "@bytecodealliance/wizer-darwin-arm64": "7.0.4", + "@bytecodealliance/wizer-darwin-x64": "7.0.4", + "@bytecodealliance/wizer-linux-arm64": "7.0.4", + "@bytecodealliance/wizer-linux-s390x": "7.0.4", + "@bytecodealliance/wizer-linux-x64": "7.0.4", + "@bytecodealliance/wizer-win32-x64": "7.0.4" + } + }, + "node_modules/@bytecodealliance/wizer-darwin-arm64": { + "version": "7.0.4", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/@bytecodealliance/wizer-darwin-arm64/-/wizer-darwin-arm64-7.0.4.tgz", + "integrity": "sha1-wlz5h/ndwFEUCmezfbOyrBS5QnE=", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "Apache-2.0", + "optional": true, + "os": [ + "darwin" + ], + "bin": { + "wizer-darwin-arm64": "wizer" + } + }, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.5", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/@jridgewell/gen-mapping/-/gen-mapping-0.3.5.tgz", + "integrity": "sha1-3M5q/3S99trRqVgCtpsEovyx+zY=", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/set-array": "^1.2.1", + "@jridgewell/sourcemap-codec": "^1.4.10", + "@jridgewell/trace-mapping": "^0.3.24" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha1-eg7mAfYPmaIMfHxf8MgDiMEYm9Y=", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/set-array": { + "version": "1.2.1", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/@jridgewell/set-array/-/set-array-1.2.1.tgz", + "integrity": "sha1-VY+2Ry7RakyFC4iVMOazZDjEkoA=", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/source-map": { + "version": "0.3.6", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/@jridgewell/source-map/-/source-map-0.3.6.tgz", + "integrity": "sha1-nXHKiG4yUC65NiyadKRnh8Nt+Bo=", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.25" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz", + "integrity": "sha1-MYi8snOkFLDSFf0ipYVAuYm5QJo=", + "dev": true, + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.25", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz", + "integrity": "sha1-FfGQ6YiV8/wjJ27hS8drZ1wuUPA=", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/acorn": { + "version": "8.12.1", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/acorn/-/acorn-8.12.1.tgz", + "integrity": "sha1-cWFr3MviXielRDngBG6JynbfIkg=", + "dev": true, + "license": "MIT", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/ansi-regex": { + "version": "6.0.1", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/ansi-regex/-/ansi-regex-6.0.1.tgz", + "integrity": "sha1-MYPjj66aZdfLXlOUXNWJfQJgoGo=", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-regex?sponsor=1" + } + }, + "node_modules/binaryen": { + "version": "118.0.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/binaryen/-/binaryen-118.0.0.tgz", + "integrity": "sha1-pOqWZdVXz8gOYvH/VzsEimOYt64=", + "dev": true, + "license": "Apache-2.0", + "bin": { + "wasm-as": "bin/wasm-as", + "wasm-ctor-eval": "bin/wasm-ctor-eval", + "wasm-dis": "bin/wasm-dis", + "wasm-merge": "bin/wasm-merge", + "wasm-metadce": "bin/wasm-metadce", + "wasm-opt": "bin/wasm-opt", + "wasm-reduce": "bin/wasm-reduce", + "wasm-shell": "bin/wasm-shell", + "wasm2js": "bin/wasm2js" + } + }, + "node_modules/buffer-from": { + "version": "1.1.2", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/buffer-from/-/buffer-from-1.1.2.tgz", + "integrity": "sha1-KxRqb9cugLT1XSVfNe1Zo6mkG9U=", + "dev": true, + "license": "MIT" + }, + "node_modules/chalk": { + "version": "5.3.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/chalk/-/chalk-5.3.0.tgz", + "integrity": "sha1-Z8IKfr73Dn85cKAfkPohDLaGA4U=", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.17.0 || ^14.13 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/chalk-template": { + "version": "1.1.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/chalk-template/-/chalk-template-1.1.0.tgz", + "integrity": "sha1-/8Vdtt10XpOUuFMnyKyEZu23p7E=", + "dev": true, + "license": "MIT", + "dependencies": { + "chalk": "^5.2.0" + }, + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/chalk/chalk-template?sponsor=1" + } + }, + "node_modules/cli-cursor": { + "version": "4.0.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/cli-cursor/-/cli-cursor-4.0.0.tgz", + "integrity": "sha1-POz+NzS/T+Aqg2HL3A9v4oxqV+o=", + "dev": true, + "license": "MIT", + "dependencies": { + "restore-cursor": "^4.0.0" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/cli-spinners": { + "version": "2.9.2", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/cli-spinners/-/cli-spinners-2.9.2.tgz", + "integrity": "sha1-F3Oo9LnE1qwxVj31Oz/B15Ri/kE=", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/commander": { + "version": "12.1.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/commander/-/commander-12.1.0.tgz", + "integrity": "sha1-AUI7NvUBJZ/arE0OTWDJbJkVhdM=", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + } + }, + "node_modules/emoji-regex": { + "version": "10.3.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/emoji-regex/-/emoji-regex-10.3.0.tgz", + "integrity": "sha1-dpmLkmhAnrPa496YklTUVucM/iM=", + "dev": true, + "license": "MIT" + }, + "node_modules/es-module-lexer": { + "version": "1.5.4", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/es-module-lexer/-/es-module-lexer-1.5.4.tgz", + "integrity": "sha1-qO/sOj2pkeYO+mtjOnytarjSa3g=", + "dev": true, + "license": "MIT" + }, + "node_modules/get-east-asian-width": { + "version": "1.2.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/get-east-asian-width/-/get-east-asian-width-1.2.0.tgz", + "integrity": "sha1-Xm69m67m+4t7a9UFIhBl8M2R9k4=", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-interactive": { + "version": "2.0.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/is-interactive/-/is-interactive-2.0.0.tgz", + "integrity": "sha1-QMV2FFk4JtoRAK3mBZd41ZfxbpA=", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-unicode-supported": { + "version": "2.0.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/is-unicode-supported/-/is-unicode-supported-2.0.0.tgz", + "integrity": "sha1-/fMt+a6Y/2qyztwVWlpuiVcBxFE=", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/log-symbols": { + "version": "6.0.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/log-symbols/-/log-symbols-6.0.0.tgz", + "integrity": "sha1-u5Xl8FMiZRysMMD+tkBPnyqKlDk=", + "dev": true, + "license": "MIT", + "dependencies": { + "chalk": "^5.3.0", + "is-unicode-supported": "^1.3.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/log-symbols/node_modules/is-unicode-supported": { + "version": "1.3.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/is-unicode-supported/-/is-unicode-supported-1.3.0.tgz", + "integrity": "sha1-2CSYS2FsKSouGYIH1KYJmDhC9xQ=", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/mimic-fn": { + "version": "2.1.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/mimic-fn/-/mimic-fn-2.1.0.tgz", + "integrity": "sha1-ftLCzMyvhNP/y3pptXcR/CCDQBs=", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/mkdirp": { + "version": "3.0.1", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/mkdirp/-/mkdirp-3.0.1.tgz", + "integrity": "sha1-5E5MVgf7J5wWgkFxPMbg/qmty1A=", + "dev": true, + "license": "MIT", + "bin": { + "mkdirp": "dist/cjs/src/bin.js" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/onetime": { + "version": "5.1.2", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/onetime/-/onetime-5.1.2.tgz", + "integrity": "sha1-0Oluu1awdHbfHdnEgG5SN5hcpF4=", + "dev": true, + "license": "MIT", + "dependencies": { + "mimic-fn": "^2.1.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/ora": { + "version": "8.0.1", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/ora/-/ora-8.0.1.tgz", + "integrity": "sha1-bcuSUKYpZCy+DS3zpjMa1veirz4=", + "dev": true, + "license": "MIT", + "dependencies": { + "chalk": "^5.3.0", + "cli-cursor": "^4.0.0", + "cli-spinners": "^2.9.2", + "is-interactive": "^2.0.0", + "is-unicode-supported": "^2.0.0", + "log-symbols": "^6.0.0", + "stdin-discarder": "^0.2.1", + "string-width": "^7.0.0", + "strip-ansi": "^7.1.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/restore-cursor": { + "version": "4.0.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/restore-cursor/-/restore-cursor-4.0.0.tgz", + "integrity": "sha1-UZVgpDGJdQlt725gnUQQDtqkzLk=", + "dev": true, + "license": "MIT", + "dependencies": { + "onetime": "^5.1.0", + "signal-exit": "^3.0.2" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/signal-exit": { + "version": "3.0.7", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/signal-exit/-/signal-exit-3.0.7.tgz", + "integrity": "sha1-qaF2f4r4QVURTqq9c/mSc8j1mtk=", + "dev": true, + "license": "ISC" + }, + "node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha1-dHIq8y6WFOnCh6jQu95IteLxomM=", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/source-map-support": { + "version": "0.5.21", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/source-map-support/-/source-map-support-0.5.21.tgz", + "integrity": "sha1-BP58f54e0tZiIzwoyys1ufY/bk8=", + "dev": true, + "license": "MIT", + "dependencies": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + } + }, + "node_modules/stdin-discarder": { + "version": "0.2.2", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/stdin-discarder/-/stdin-discarder-0.2.2.tgz", + "integrity": "sha1-OQA39ExK4aGuU1xf443Dq6jZl74=", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/string-width": { + "version": "7.2.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/string-width/-/string-width-7.2.0.tgz", + "integrity": "sha1-tbuOIWXOJ11NQ0dt0nAK2Qkdttw=", + "dev": true, + "license": "MIT", + "dependencies": { + "emoji-regex": "^10.3.0", + "get-east-asian-width": "^1.0.0", + "strip-ansi": "^7.1.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/strip-ansi": { + "version": "7.1.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/strip-ansi/-/strip-ansi-7.1.0.tgz", + "integrity": "sha1-1bZWjKaJ2FYTcLBwdoXSJDT6/0U=", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-regex": "^6.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/strip-ansi?sponsor=1" + } + }, + "node_modules/terser": { + "version": "5.31.6", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/terser/-/terser-5.31.6.tgz", + "integrity": "sha1-xjhYoPBwOYjQJmqC/L8te6dkIrE=", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "@jridgewell/source-map": "^0.3.3", + "acorn": "^8.8.2", + "commander": "^2.20.0", + "source-map-support": "~0.5.20" + }, + "bin": { + "terser": "bin/terser" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/terser/node_modules/commander": { + "version": "2.20.3", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/commander/-/commander-2.20.3.tgz", + "integrity": "sha1-/UhehMA+tIgcIHIrpIA16FMa6zM=", + "dev": true, + "license": "MIT" + } + }, + "dependencies": { + "@bytecodealliance/componentize-js": { + "version": "0.11.4", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/@bytecodealliance/componentize-js/-/componentize-js-0.11.4.tgz", + "integrity": "sha1-vD4DqeyGtXWn2m0req3EQaYD+M0=", + "dev": true, + "requires": { + "@bytecodealliance/jco": "1.4.4", + "@bytecodealliance/wizer": "^7.0.4", + "es-module-lexer": "^1.5.4" + }, + "dependencies": { + "@bytecodealliance/jco": { + "version": "1.4.4", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/@bytecodealliance/jco/-/jco-1.4.4.tgz", + "integrity": "sha1-ogqFzKrFpvgHbtqzWxuhwQvU8Gw=", + "dev": true, + "requires": { + "@bytecodealliance/preview2-shim": "^0.16.5", + "binaryen": "^118.0.0", + "chalk-template": "^1", + "commander": "^12", + "mkdirp": "^3", + "ora": "^8", + "terser": "^5" + } + } + } + }, + "@bytecodealliance/jco": { + "version": "1.5.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/@bytecodealliance/jco/-/jco-1.5.0.tgz", + "integrity": "sha1-yJZfRrdmgncpVuk9dVjEgW7Xg30=", + "dev": true, + "requires": { + "@bytecodealliance/componentize-js": "^0.11.3", + "@bytecodealliance/preview2-shim": "^0.16.5", + "binaryen": "^118.0.0", + "chalk-template": "^1", + "commander": "^12", + "mkdirp": "^3", + "ora": "^8", + "terser": "^5" + } + }, + "@bytecodealliance/preview2-shim": { + "version": "0.16.5", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/@bytecodealliance/preview2-shim/-/preview2-shim-0.16.5.tgz", + "integrity": "sha1-JNmvYkPsqxnU/5exhq9ZFeopB0E=", + "dev": true + }, + "@bytecodealliance/wizer": { + "version": "7.0.4", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/@bytecodealliance/wizer/-/wizer-7.0.4.tgz", + "integrity": "sha1-/4B8pOvUdUhGD/AUDL7dT8k1Pbk=", + "dev": true, + "requires": { + "@bytecodealliance/wizer-darwin-arm64": "7.0.4", + "@bytecodealliance/wizer-darwin-x64": "7.0.4", + "@bytecodealliance/wizer-linux-arm64": "7.0.4", + "@bytecodealliance/wizer-linux-s390x": "7.0.4", + "@bytecodealliance/wizer-linux-x64": "7.0.4", + "@bytecodealliance/wizer-win32-x64": "7.0.4" + } + }, + "@bytecodealliance/wizer-darwin-arm64": { + "version": "7.0.4", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/@bytecodealliance/wizer-darwin-arm64/-/wizer-darwin-arm64-7.0.4.tgz", + "integrity": "sha1-wlz5h/ndwFEUCmezfbOyrBS5QnE=", + "dev": true, + "optional": true + }, + "@jridgewell/gen-mapping": { + "version": "0.3.5", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/@jridgewell/gen-mapping/-/gen-mapping-0.3.5.tgz", + "integrity": "sha1-3M5q/3S99trRqVgCtpsEovyx+zY=", + "dev": true, + "requires": { + "@jridgewell/set-array": "^1.2.1", + "@jridgewell/sourcemap-codec": "^1.4.10", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha1-eg7mAfYPmaIMfHxf8MgDiMEYm9Y=", + "dev": true + }, + "@jridgewell/set-array": { + "version": "1.2.1", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/@jridgewell/set-array/-/set-array-1.2.1.tgz", + "integrity": "sha1-VY+2Ry7RakyFC4iVMOazZDjEkoA=", + "dev": true + }, + "@jridgewell/source-map": { + "version": "0.3.6", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/@jridgewell/source-map/-/source-map-0.3.6.tgz", + "integrity": "sha1-nXHKiG4yUC65NiyadKRnh8Nt+Bo=", + "dev": true, + "requires": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.25" + } + }, + "@jridgewell/sourcemap-codec": { + "version": "1.5.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz", + "integrity": "sha1-MYi8snOkFLDSFf0ipYVAuYm5QJo=", + "dev": true + }, + "@jridgewell/trace-mapping": { + "version": "0.3.25", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz", + "integrity": "sha1-FfGQ6YiV8/wjJ27hS8drZ1wuUPA=", + "dev": true, + "requires": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "acorn": { + "version": "8.12.1", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/acorn/-/acorn-8.12.1.tgz", + "integrity": "sha1-cWFr3MviXielRDngBG6JynbfIkg=", + "dev": true + }, + "ansi-regex": { + "version": "6.0.1", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/ansi-regex/-/ansi-regex-6.0.1.tgz", + "integrity": "sha1-MYPjj66aZdfLXlOUXNWJfQJgoGo=", + "dev": true + }, + "binaryen": { + "version": "118.0.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/binaryen/-/binaryen-118.0.0.tgz", + "integrity": "sha1-pOqWZdVXz8gOYvH/VzsEimOYt64=", + "dev": true + }, + "buffer-from": { + "version": "1.1.2", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/buffer-from/-/buffer-from-1.1.2.tgz", + "integrity": "sha1-KxRqb9cugLT1XSVfNe1Zo6mkG9U=", + "dev": true + }, + "chalk": { + "version": "5.3.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/chalk/-/chalk-5.3.0.tgz", + "integrity": "sha1-Z8IKfr73Dn85cKAfkPohDLaGA4U=", + "dev": true + }, + "chalk-template": { + "version": "1.1.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/chalk-template/-/chalk-template-1.1.0.tgz", + "integrity": "sha1-/8Vdtt10XpOUuFMnyKyEZu23p7E=", + "dev": true, + "requires": { + "chalk": "^5.2.0" + } + }, + "cli-cursor": { + "version": "4.0.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/cli-cursor/-/cli-cursor-4.0.0.tgz", + "integrity": "sha1-POz+NzS/T+Aqg2HL3A9v4oxqV+o=", + "dev": true, + "requires": { + "restore-cursor": "^4.0.0" + } + }, + "cli-spinners": { + "version": "2.9.2", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/cli-spinners/-/cli-spinners-2.9.2.tgz", + "integrity": "sha1-F3Oo9LnE1qwxVj31Oz/B15Ri/kE=", + "dev": true + }, + "commander": { + "version": "12.1.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/commander/-/commander-12.1.0.tgz", + "integrity": "sha1-AUI7NvUBJZ/arE0OTWDJbJkVhdM=", + "dev": true + }, + "emoji-regex": { + "version": "10.3.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/emoji-regex/-/emoji-regex-10.3.0.tgz", + "integrity": "sha1-dpmLkmhAnrPa496YklTUVucM/iM=", + "dev": true + }, + "es-module-lexer": { + "version": "1.5.4", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/es-module-lexer/-/es-module-lexer-1.5.4.tgz", + "integrity": "sha1-qO/sOj2pkeYO+mtjOnytarjSa3g=", + "dev": true + }, + "get-east-asian-width": { + "version": "1.2.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/get-east-asian-width/-/get-east-asian-width-1.2.0.tgz", + "integrity": "sha1-Xm69m67m+4t7a9UFIhBl8M2R9k4=", + "dev": true + }, + "is-interactive": { + "version": "2.0.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/is-interactive/-/is-interactive-2.0.0.tgz", + "integrity": "sha1-QMV2FFk4JtoRAK3mBZd41ZfxbpA=", + "dev": true + }, + "is-unicode-supported": { + "version": "2.0.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/is-unicode-supported/-/is-unicode-supported-2.0.0.tgz", + "integrity": "sha1-/fMt+a6Y/2qyztwVWlpuiVcBxFE=", + "dev": true + }, + "log-symbols": { + "version": "6.0.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/log-symbols/-/log-symbols-6.0.0.tgz", + "integrity": "sha1-u5Xl8FMiZRysMMD+tkBPnyqKlDk=", + "dev": true, + "requires": { + "chalk": "^5.3.0", + "is-unicode-supported": "^1.3.0" + }, + "dependencies": { + "is-unicode-supported": { + "version": "1.3.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/is-unicode-supported/-/is-unicode-supported-1.3.0.tgz", + "integrity": "sha1-2CSYS2FsKSouGYIH1KYJmDhC9xQ=", + "dev": true + } + } + }, + "mimic-fn": { + "version": "2.1.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/mimic-fn/-/mimic-fn-2.1.0.tgz", + "integrity": "sha1-ftLCzMyvhNP/y3pptXcR/CCDQBs=", + "dev": true + }, + "mkdirp": { + "version": "3.0.1", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/mkdirp/-/mkdirp-3.0.1.tgz", + "integrity": "sha1-5E5MVgf7J5wWgkFxPMbg/qmty1A=", + "dev": true + }, + "onetime": { + "version": "5.1.2", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/onetime/-/onetime-5.1.2.tgz", + "integrity": "sha1-0Oluu1awdHbfHdnEgG5SN5hcpF4=", + "dev": true, + "requires": { + "mimic-fn": "^2.1.0" + } + }, + "ora": { + "version": "8.0.1", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/ora/-/ora-8.0.1.tgz", + "integrity": "sha1-bcuSUKYpZCy+DS3zpjMa1veirz4=", + "dev": true, + "requires": { + "chalk": "^5.3.0", + "cli-cursor": "^4.0.0", + "cli-spinners": "^2.9.2", + "is-interactive": "^2.0.0", + "is-unicode-supported": "^2.0.0", + "log-symbols": "^6.0.0", + "stdin-discarder": "^0.2.1", + "string-width": "^7.0.0", + "strip-ansi": "^7.1.0" + } + }, + "restore-cursor": { + "version": "4.0.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/restore-cursor/-/restore-cursor-4.0.0.tgz", + "integrity": "sha1-UZVgpDGJdQlt725gnUQQDtqkzLk=", + "dev": true, + "requires": { + "onetime": "^5.1.0", + "signal-exit": "^3.0.2" + } + }, + "signal-exit": { + "version": "3.0.7", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/signal-exit/-/signal-exit-3.0.7.tgz", + "integrity": "sha1-qaF2f4r4QVURTqq9c/mSc8j1mtk=", + "dev": true + }, + "source-map": { + "version": "0.6.1", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha1-dHIq8y6WFOnCh6jQu95IteLxomM=", + "dev": true + }, + "source-map-support": { + "version": "0.5.21", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/source-map-support/-/source-map-support-0.5.21.tgz", + "integrity": "sha1-BP58f54e0tZiIzwoyys1ufY/bk8=", + "dev": true, + "requires": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + } + }, + "stdin-discarder": { + "version": "0.2.2", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/stdin-discarder/-/stdin-discarder-0.2.2.tgz", + "integrity": "sha1-OQA39ExK4aGuU1xf443Dq6jZl74=", + "dev": true + }, + "string-width": { + "version": "7.2.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/string-width/-/string-width-7.2.0.tgz", + "integrity": "sha1-tbuOIWXOJ11NQ0dt0nAK2Qkdttw=", + "dev": true, + "requires": { + "emoji-regex": "^10.3.0", + "get-east-asian-width": "^1.0.0", + "strip-ansi": "^7.1.0" + } + }, + "strip-ansi": { + "version": "7.1.0", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/strip-ansi/-/strip-ansi-7.1.0.tgz", + "integrity": "sha1-1bZWjKaJ2FYTcLBwdoXSJDT6/0U=", + "dev": true, + "requires": { + "ansi-regex": "^6.0.1" + } + }, + "terser": { + "version": "5.31.6", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/terser/-/terser-5.31.6.tgz", + "integrity": "sha1-xjhYoPBwOYjQJmqC/L8te6dkIrE=", + "dev": true, + "requires": { + "@jridgewell/source-map": "^0.3.3", + "acorn": "^8.8.2", + "commander": "^2.20.0", + "source-map-support": "~0.5.20" + }, + "dependencies": { + "commander": { + "version": "2.20.3", + "resolved": "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public-npm/npm/registry/commander/-/commander-2.20.3.tgz", + "integrity": "sha1-/UhehMA+tIgcIHIrpIA16FMa6zM=", + "dev": true + } + } + } + } +} diff --git a/src/mono/sample/wasi/jco/package.json b/src/mono/sample/wasi/jco/package.json new file mode 100644 index 00000000000..a55cb04e7ca --- /dev/null +++ b/src/mono/sample/wasi/jco/package.json @@ -0,0 +1,10 @@ +{ + "type": "module", + "devDependencies": { + "@bytecodealliance/jco": "1.5.0" + }, + "scripts": { + "transpile": "npx jco transpile --no-typescript bin/wasi-wasm/AppBundle/Wasi.Jco.Http.Sample.wasm -o bin/wasi-wasm/JCOBundle/ && powershell cp ./main.mjs ./bin/wasi-wasm/JCOBundle/main.mjs", + "run": "node bin/wasi-wasm/JCOBundle/main.mjs" + } +} \ No newline at end of file diff --git a/src/mono/sample/wasi/native/ILLink.Descriptors.xml b/src/mono/sample/wasi/native/ILLink.Descriptors.xml new file mode 100644 index 00000000000..9df567cb73b --- /dev/null +++ b/src/mono/sample/wasi/native/ILLink.Descriptors.xml @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/src/mono/sample/wasi/native/Program.cs b/src/mono/sample/wasi/native/Program.cs index d8d480869a8..ffea2e7c343 100644 --- a/src/mono/sample/wasi/native/Program.cs +++ b/src/mono/sample/wasi/native/Program.cs @@ -4,6 +4,8 @@ using System; using System.Runtime.InteropServices; +namespace Sample; + public unsafe class Test { [UnmanagedCallersOnly(EntryPoint = "ManagedFunc")] diff --git a/src/mono/sample/wasi/native/Wasi.Native.Sample.csproj b/src/mono/sample/wasi/native/Wasi.Native.Sample.csproj index 9af9d62eeee..123684c9f70 100644 --- a/src/mono/sample/wasi/native/Wasi.Native.Sample.csproj +++ b/src/mono/sample/wasi/native/Wasi.Native.Sample.csproj @@ -12,6 +12,8 @@ + + diff --git a/src/mono/sample/wasm/blazor-frame/blazor.csproj b/src/mono/sample/wasm/blazor-frame/blazor.csproj index 1de3023c4e4..4c6e759b21a 100644 --- a/src/mono/sample/wasm/blazor-frame/blazor.csproj +++ b/src/mono/sample/wasm/blazor-frame/blazor.csproj @@ -11,8 +11,8 @@ - - + + diff --git a/src/mono/sample/wasm/browser-bench/Common/GetNugetConfigTask.cs b/src/mono/sample/wasm/browser-bench/Common/GetNugetConfigTask.cs new file mode 100644 index 00000000000..82c9a39ddc9 --- /dev/null +++ b/src/mono/sample/wasm/browser-bench/Common/GetNugetConfigTask.cs @@ -0,0 +1,53 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.IO; +using System.Xml.Linq; +using Microsoft.Build.Framework; +using Microsoft.Build.Utilities; + +public class GetNugetConfigTask : Task +{ + [Required] + public string InputFile { get; set; } + + [Required] + public string ArtifactsDir { get; set; } + + [Required] + public string Configuration { get; set; } + + [Output] + public string NugetConfigContent { get; set; } + + public override bool Execute() + { + try + { + XDocument doc = XDocument.Load(InputFile); + XElement packageSources = doc.Root.Element("packageSources"); + + if (packageSources == null) + { + packageSources = new XElement("packageSources"); + doc.Root.Add(packageSources); + } + + XElement newSource = new XElement("add", + new XAttribute("key", "nuget-local"), + new XAttribute("value", Path.Combine(ArtifactsDir, "packages", Configuration, "Shipping")) + ); + + packageSources.Add(newSource); + + NugetConfigContent = doc.ToString(); + return true; + } + catch (Exception ex) + { + Log.LogErrorFromException(ex); + return false; + } + } +} \ No newline at end of file diff --git a/src/mono/sample/wasm/browser-bench/Wasm.Browser.Bench.Sample.csproj b/src/mono/sample/wasm/browser-bench/Wasm.Browser.Bench.Sample.csproj index b4d32416389..679ca812e0f 100644 --- a/src/mono/sample/wasm/browser-bench/Wasm.Browser.Bench.Sample.csproj +++ b/src/mono/sample/wasm/browser-bench/Wasm.Browser.Bench.Sample.csproj @@ -17,29 +17,22 @@ + + + + + + + + - <?xml version="1.0" encoding="utf-8"?> -<configuration> - <!-- Don't use any higher level config files. --> - <fallbackPackageFolders> - <clear /> - </fallbackPackageFolders> - <packageSources> - <clear /> - <add key="nuget-local" value="$(ArtifactsDir)packages/$(Configuration)/Shipping/" /> - <add key="dotnet8" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet8/nuget/v3/index.json" /> - <add key="dotnet9" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet9/nuget/v3/index.json" /> - <add key="nuget.org" value="https://api.nuget.org/v3/index.json" protocolVersion="3" /> - </packageSources> - <disabledPackageSources> - <clear /> - </disabledPackageSources> -</configuration> - $(MSBuildThisFileDirectory)nugetPackages @@ -55,7 +48,7 @@ - + @@ -87,7 +80,7 @@ DestinationFolder="$(MSBuildThisFileDirectory)/bin/$(Configuration)/AppBundle/blazor-template/%(RecursiveDir)" /> - + diff --git a/src/mono/sample/wasm/browser-logprofile/Makefile b/src/mono/sample/wasm/browser-logprofile/Makefile new file mode 100644 index 00000000000..52389be6050 --- /dev/null +++ b/src/mono/sample/wasm/browser-logprofile/Makefile @@ -0,0 +1,7 @@ +TOP=../../../../.. + +include ../wasm.mk + +PROJECT_NAME=Wasm.BrowserLogProfile.Sample.csproj + +run: run-browser \ No newline at end of file diff --git a/src/mono/sample/wasm/browser-logprofile/Program.cs b/src/mono/sample/wasm/browser-logprofile/Program.cs new file mode 100644 index 00000000000..6bebd913c05 --- /dev/null +++ b/src/mono/sample/wasm/browser-logprofile/Program.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices.JavaScript; + +namespace Sample +{ + public partial class Test + { + public static void Main(string[] args) + { + Console.WriteLine ("Hello, World!"); + } + + [JSExport] + [MethodImpl(MethodImplOptions.NoInlining)] + public static void TakeHeapshot() { } + + [JSExport] + public static int TestMeaning() + { + for(int i=0; i<100; i++){ + var r = new int[1000]; + } + + return 42; + } + } +} diff --git a/src/mono/sample/wasm/browser-logprofile/README.md b/src/mono/sample/wasm/browser-logprofile/README.md new file mode 100644 index 00000000000..e652d1c04dd --- /dev/null +++ b/src/mono/sample/wasm/browser-logprofile/README.md @@ -0,0 +1,7 @@ +## How to run a sample app with log profiling enabled + +### Build the sample +1. Build the runtime +1. Build the sample with `make` +1. Run the sample with `make run` +1. Navigate to https://localhost:8000 diff --git a/src/mono/sample/wasm/browser-logprofile/Wasm.BrowserLogProfile.Sample.csproj b/src/mono/sample/wasm/browser-logprofile/Wasm.BrowserLogProfile.Sample.csproj new file mode 100644 index 00000000000..fcc6164c133 --- /dev/null +++ b/src/mono/sample/wasm/browser-logprofile/Wasm.BrowserLogProfile.Sample.csproj @@ -0,0 +1,15 @@ + + + true + log; + true + false + + + + + + + + + diff --git a/src/mono/sample/wasm/browser-logprofile/index.html b/src/mono/sample/wasm/browser-logprofile/index.html new file mode 100644 index 00000000000..9e6cc3984a7 --- /dev/null +++ b/src/mono/sample/wasm/browser-logprofile/index.html @@ -0,0 +1,18 @@ + + + + + + + Log Profiler Sample + + + + + + + + Result from Sample.Test.TestMeaning: + + + \ No newline at end of file diff --git a/src/mono/sample/wasm/browser-logprofile/main.js b/src/mono/sample/wasm/browser-logprofile/main.js new file mode 100644 index 00000000000..0ad2db48d38 --- /dev/null +++ b/src/mono/sample/wasm/browser-logprofile/main.js @@ -0,0 +1,66 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +import { dotnet, exit } from './_framework/dotnet.js' + +function saveProfile(Module) { + let profileData = readProfileFile(Module); + + const a = document.createElement('a'); + const blob = new Blob([profileData]); + a.href = URL.createObjectURL(blob); + a.download = "output.mlpd"; + // Append anchor to body. + document.body.appendChild(a); + a.click(); + + // Remove anchor from body + document.body.removeChild(a); +} + +function readProfileFile(Module) { + let profileFilePath="output.mlpd"; + + var stat = Module.FS.stat(profileFilePath); + + if (stat && stat.size > 0) { + return Module.FS.readFile(profileFilePath); + } + else { + console.debug(`Unable to fetch the profile file ${profileFilePath} as it is empty`); + return null; + } +} + +try { + const { INTERNAL, Module, getAssemblyExports: getAssemblyExports } = await dotnet + .withElementOnExit() + .withExitCodeLogging() + .withConfig({ + logProfilerOptions: { + takeHeapshot: "Sample.Test::TakeHeapshot", + configuration: "log:alloc,output=output.mlpd" + } + }) + .create(); + + console.log("not ready yet") + const exports = await getAssemblyExports("Wasm.BrowserLogProfile.Sample"); + const testMeaning = exports.Sample.Test.TestMeaning; + const takeHeapshot = exports.Sample.Test.TakeHeapshot; + console.log("ready"); + + dotnet.run(); + + const ret = testMeaning(); + document.getElementById("out").innerHTML = ret; + console.debug(`ret: ${ret}`); + + takeHeapshot(); + saveProfile(Module); + + let exit_code = ret == 42 ? 0 : 1; + exit(exit_code); +} catch (err) { + exit(-1, err); +} diff --git a/src/mono/wasi/Wasi.Build.Tests/BuildPublishTests.cs b/src/mono/wasi/Wasi.Build.Tests/BuildPublishTests.cs new file mode 100644 index 00000000000..f1373727621 --- /dev/null +++ b/src/mono/wasi/Wasi.Build.Tests/BuildPublishTests.cs @@ -0,0 +1,45 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.IO; +using Xunit; +using Xunit.Abstractions; +using Xunit.Sdk; +using Wasm.Build.Tests; + +#nullable enable + +namespace Wasi.Build.Tests; + +public class BuildPublishTests : BuildTestBase +{ + public BuildPublishTests(ITestOutputHelper output, SharedBuildPerTestClassFixture buildContext) + : base(output, buildContext) + { + } + + [Theory] + [InlineData("Release")] + public void BuildInLongPathSingleFileBundle(string config) + { + string id = $"{config}_{GetRandomId()}"; + string projectFile = CreateWasmTemplateProject(id, "wasiconsole", projectParentDir: Path.Combine("reallyLongPath", "toProlongPathsToLinkedFiles", "andMakeTheResultingLinkingCommandExtremelyLong")); + string projectName = Path.GetFileNameWithoutExtension(projectFile); + File.Copy(Path.Combine(BuildEnvironment.TestAssetsPath, "SimpleMainWithArgs.cs"), Path.Combine(_projectDir!, "Program.cs"), true); + + var buildArgs = new BuildArgs(projectName, config, /*aot*/ false, id, null); + buildArgs = ExpandBuildArgs(buildArgs); + + // only single file bundle linking exceeds the char limit + AddItemsPropertiesToProject(projectFile, "true"); + + (string projectDir, string buildOutput) = BuildProject(buildArgs, + id: id, + new BuildProjectOptions( + DotnetWasmFromRuntimePack: true, + CreateProject: false, + Publish: false, + TargetFramework: BuildTestBase.DefaultTargetFramework)); + } +} diff --git a/src/mono/wasi/Wasi.Build.Tests/BuildTestBase.cs b/src/mono/wasi/Wasi.Build.Tests/BuildTestBase.cs index 62f23c26488..76bc6fed455 100644 --- a/src/mono/wasi/Wasi.Build.Tests/BuildTestBase.cs +++ b/src/mono/wasi/Wasi.Build.Tests/BuildTestBase.cs @@ -121,10 +121,19 @@ public BuildTestBase(ITestOutputHelper output, SharedBuildPerTestClassFixture bu } [MemberNotNull(nameof(_projectDir), nameof(_logPath))] - protected void InitPaths(string id) + protected void InitPaths(string id, string? projectParentDir = null) { if (_projectDir == null) - _projectDir = Path.Combine(BuildEnvironment.TmpPath, id); + { + if (projectParentDir == null) + { + _projectDir = Path.Combine(BuildEnvironment.TmpPath, id); + } + else + { + _projectDir = Path.Combine(BuildEnvironment.TmpPath, projectParentDir, id); + } + } _logPath = Path.Combine(s_buildEnv.LogRootPath, id); _nugetPackagesDir = Path.Combine(BuildEnvironment.TmpPath, "nuget", id); @@ -289,9 +298,9 @@ private static string GetNuGetConfigWithLocalPackagesPath(string templatePath, s return contents.Replace(s_nugetInsertionTag, $@""); } - public string CreateWasmTemplateProject(string id, string template = "wasmbrowser", string extraArgs = "", bool runAnalyzers = true) + public string CreateWasmTemplateProject(string id, string template = "wasmbrowser", string extraArgs = "", bool runAnalyzers = true, string? projectParentDir = null) { - InitPaths(id); + InitPaths(id, projectParentDir); InitProjectDir(_projectDir, addNuGetSourceForLocalPackages: true); File.WriteAllText(Path.Combine(_projectDir, "Directory.Build.props"), ""); @@ -693,6 +702,16 @@ public static int Main() .MultiplyWithSingleArgs(true, false) /*aot*/ .UnwrapItemsAsArrays(); + public static IEnumerable TestDataForConsolePublishAndRunRelease() => + new IEnumerable[] + { + new object?[] { true }, + new object?[] { false } + } + .AsEnumerable() + .MultiplyWithSingleArgs(true, false) /*aot*/ + .UnwrapItemsAsArrays(); + protected CommandResult RunWithoutBuild(string config, string id, bool enableHttp = false) { // wasmtime --wasi http is necessary because the default dotnet.wasm (without native rebuild depends on wasi:http world) diff --git a/src/mono/wasi/Wasi.Build.Tests/PInvokeTableGeneratorTests.cs b/src/mono/wasi/Wasi.Build.Tests/PInvokeTableGeneratorTests.cs index 6a47c036465..1405ec20bb7 100644 --- a/src/mono/wasi/Wasi.Build.Tests/PInvokeTableGeneratorTests.cs +++ b/src/mono/wasi/Wasi.Build.Tests/PInvokeTableGeneratorTests.cs @@ -17,58 +17,38 @@ public PInvokeTableGeneratorTests(ITestOutputHelper output, SharedBuildPerTestCl { } - [Fact] - public void InteropSupportForUnmanagedEntryPointWithoutDelegate() + [Theory] + [MemberData(nameof(TestDataForConsolePublishAndRunRelease))] + public void InteropSupportForUnmanagedEntryPointWithoutDelegate(bool singleFileBundle, bool aot) { - string config = "Release"; - string id = $"{config}_{GetRandomId()}"; - string projectFile = CreateWasmTemplateProject(id, "wasiconsole"); - string code = - """ - using System; - using System.Runtime.InteropServices; - public unsafe class Test - { - [UnmanagedCallersOnly(EntryPoint = "ManagedFunc")] - public static int MyExport(int number) - { - // called from MyImport aka UnmanagedFunc - Console.WriteLine($"MyExport({number}) -> 42"); - return 42; - } - - [DllImport("*", EntryPoint = "UnmanagedFunc")] - public static extern void MyImport(); // calls ManagedFunc aka MyExport + if(aot) + { + // Active issue https://github.com/dotnet/runtime/issues/101276 + return; + } - public unsafe static int Main(string[] args) - { - Console.WriteLine($"main: {args.Length}"); - MyImport(); - return 0; - } - } - """; - string cCode = - """ - #include - - int ManagedFunc(int number); + string id = $"Release_{GetRandomId()}"; + string projectFile = CreateWasmTemplateProject(id, "wasiconsole"); + string projectName = Path.GetFileNameWithoutExtension(projectFile); + File.Copy(Path.Combine(BuildEnvironment.TestAssetsPath, "Native.cs"), Path.Combine(_projectDir!, "Program.cs"), true); + File.Copy(Path.Combine(BuildEnvironment.TestAssetsPath, "native.c"), Path.Combine(_projectDir!, "native.c")!, true); + + // workaround for https://github.com/dotnet/runtime/issues/106627 + File.Copy(Path.Combine(BuildEnvironment.TestAssetsPath, "ILLink.Native.Descriptors.xml"), Path.Combine(_projectDir!, "ILLink.Native.Descriptors.xml")!, true); - void UnmanagedFunc() - { - int ret = 0; - printf("UnmanagedFunc calling ManagedFunc\n"); - ret = ManagedFunc(123); - printf("ManagedFunc returned %d\n", ret); - } - """; - File.WriteAllText(Path.Combine(_projectDir!, "Program.cs"), code); - File.WriteAllText(Path.Combine(_projectDir!, "local.c"), cCode); string extraProperties = @"false - true"; - AddItemsPropertiesToProject(projectFile, extraProperties: extraProperties, extraItems: @""); - string projectName = Path.GetFileNameWithoutExtension(projectFile); - var buildArgs = new BuildArgs(projectName, config, AOT: true, ProjectFileContents: id, ExtraBuildArgs: null); + true + true + Wasi.Native.Test"; + if (aot) + extraProperties += "true<_WasmDevel>false"; + if (singleFileBundle) + extraProperties += "true"; + + string itemsProperties = @" + "; + AddItemsPropertiesToProject(projectFile, extraProperties: extraProperties, extraItems: itemsProperties); + var buildArgs = new BuildArgs(projectName, Config: "Release", AOT: true, ProjectFileContents: id, ExtraBuildArgs: null); buildArgs = ExpandBuildArgs(buildArgs); BuildProject(buildArgs, id: id, @@ -80,7 +60,7 @@ void UnmanagedFunc() CommandResult res = new RunCommand(s_buildEnv, _testOutput) .WithWorkingDirectory(_projectDir!) - .ExecuteWithCapturedOutput($"run --no-silent --no-build -c {config}") + .ExecuteWithCapturedOutput($"run --no-silent --no-build -c Release") .EnsureSuccessful(); Assert.Contains("MyExport(123) -> 42", res.Output); } diff --git a/src/mono/wasi/build/WasiApp.props b/src/mono/wasi/build/WasiApp.props index d3e85d068e0..b2f79014de3 100644 --- a/src/mono/wasi/build/WasiApp.props +++ b/src/mono/wasi/build/WasiApp.props @@ -5,7 +5,7 @@ wasm wasi wasi-wasm - partial + full true diff --git a/src/mono/wasi/build/WasiApp.targets b/src/mono/wasi/build/WasiApp.targets index 69f8cc0a4c0..f781e6469de 100644 --- a/src/mono/wasi/build/WasiApp.targets +++ b/src/mono/wasi/build/WasiApp.targets @@ -313,9 +313,19 @@ <_MonoRuntimeComponentDontLink Include="libmono-component-diagnostics_tracing-static.a" Condition="'$(UsingWasiRuntimeWorkload)' != 'true'" /> + + + + $([System.IO.Path]::GetRelativePath('$(MSBuildProjectDirectory)', '%(Identity)')) + + + $([System.IO.Path]::GetRelativePath('$(MSBuildProjectDirectory)', '%(Identity)')) + + + - <_WasmNativeFileForLinking Include="%(_BitcodeFile.ObjectFile)" /> + <_WasmNativeFileForLinking Include="%(RelativeBitcodeFiles.RelativePath)" /> <_WasmNativeFileForLinking @@ -334,9 +344,8 @@ <_WasiClangXLinkerFlags Include="--initial-memory=$(WasmInitialHeapSize)" /> - <_WasiFilePathForFixup Include="$(_WasiGetEntrypointCFile)" /> - <_WasiFilePathForFixup Include="@(_WasmObjectFilesForBundle)" /> + <_WasiFilePathForFixup Include="%(RelativeWasmObjectFiles.RelativePath)" /> <_WasiFilePathForFixup Include="@(_WasmNativeFileForLinking)" /> <_WasmLinkDependencies Include="@(_WasiFilePathForFixup)" /> @@ -348,7 +357,7 @@ <_WasiLinkStepArgs Include="-Wl,-z,stack-size=8388608,-lwasi-emulated-process-clocks,-lwasi-emulated-signal,-lwasi-emulated-mman"/> - - \ No newline at end of file + diff --git a/src/mono/wasi/include/netdb.h b/src/mono/wasi/include/netdb.h deleted file mode 100644 index f905f3bb8cd..00000000000 --- a/src/mono/wasi/include/netdb.h +++ /dev/null @@ -1 +0,0 @@ -const char *gai_strerror(int); diff --git a/src/mono/wasi/mono-include/setjmp.h b/src/mono/wasi/mono-include/setjmp.h index 5fd8fd23808..5bf4a977d11 100644 --- a/src/mono/wasi/mono-include/setjmp.h +++ b/src/mono/wasi/mono-include/setjmp.h @@ -1,2 +1,5 @@ -// setjmp.h isn't provided by WASI SDK, but many Mono source files want to import it, so we need this here +// setjmp.h is provided by WASI SDK, complains that: +// Setjmp/longjmp support requires Exception handling support, which is [not yet standardized](https://github.com/WebAssembly/proposals?tab=readme-ov-file#phase-3---implementation-phase-cg--wg). +// To enable it, compile with `-mllvm -wasm-enable-sjlj` and use an engine that implements the Exception handling proposal. +// many Mono source files want to import it, so we need this here // We don't call any of its symbols at runtime so it can be left empty diff --git a/src/mono/wasi/runtime/main.c b/src/mono/wasi/runtime/main.c index 10f87320e9a..c81e1a79828 100644 --- a/src/mono/wasi/runtime/main.c +++ b/src/mono/wasi/runtime/main.c @@ -113,6 +113,7 @@ int main(int argc, char * argv[]) { } ret = ret < 0 ? -ret : ret; + // until WASI can work with unix exit code https://github.com/WebAssembly/wasi-cli/pull/44 char* dotnet_wasi_print_exit_code = monoeg_g_getenv ("DOTNET_WASI_PRINT_EXIT_CODE"); if (ret != 0 && dotnet_wasi_print_exit_code && strcmp(dotnet_wasi_print_exit_code, "1") == 0) { diff --git a/src/mono/wasi/testassets/Http.cs b/src/mono/wasi/testassets/Http.cs index d8043bf017c..87b1f8437f7 100644 --- a/src/mono/wasi/testassets/Http.cs +++ b/src/mono/wasi/testassets/Http.cs @@ -17,8 +17,51 @@ public static async Task MainAsync(string[] args) for (int i = 0; i < args.Length; i ++) Console.WriteLine($"args[{i}] = {args[i]}"); + await Task.Delay(100); + GC.Collect(); // test that Pollable->Task is not collected until resolved + + var ctsDelay = new CancellationTokenSource(10); + try { + await Task.Delay(1000, ctsDelay.Token); + throw new Exception("delay should have timed out"); + } catch (TaskCanceledException tce) { + if (ctsDelay.Token != tce.CancellationToken) + { + throw new Exception("Different CancellationToken for delay"); + } + Console.WriteLine("impatient delay was canceled as expected"); + } + + using HttpClient impatientClient1 = new(); + impatientClient1.DefaultRequestHeaders.Add("User-Agent", "dotnet WASI unit test"); + impatientClient1.Timeout = TimeSpan.FromMilliseconds(10); + try { + await impatientClient1.GetAsync("https://corefx-net-http11.azurewebsites.net/Echo.ashx?delay10sec"); + throw new Exception("request should have timed out"); + } catch (TaskCanceledException) { + Console.WriteLine("1st impatientClient was canceled as expected"); + } + + GC.Collect(); + + using HttpClient impatientClient2 = new(); + impatientClient2.DefaultRequestHeaders.Add("User-Agent", "dotnet WASI unit test"); + var cts = new CancellationTokenSource(10); + try { + // in reality server side doesn't delay because it doesn't implement it. So 10ms is bit fragile. + // TODO: remove this once we have real WASI HTTP library unit tests with local server loop in Xharness. + // https://github.com/dotnet/xharness/pull/1244 + await impatientClient2.GetAsync("https://corefx-net-http11.azurewebsites.net/Echo.ashx?delay10sec", cts.Token); + throw new Exception("request should have timed out"); + } catch (TaskCanceledException tce) { + if (cts.Token != tce.CancellationToken) + { + throw new Exception("Different CancellationToken"); + } + Console.WriteLine("2nd impatientClient was canceled as expected"); + } + using HttpClient client = new(); - client.Timeout = Timeout.InfiniteTimeSpan; client.DefaultRequestHeaders.Accept.Clear(); client.DefaultRequestHeaders.Add("User-Agent", "dotnet WASI unit test"); @@ -30,6 +73,8 @@ public static async Task MainAsync(string[] args) Console.WriteLine(); Console.WriteLine(json); + GC.Collect(); + return 42; } @@ -38,6 +83,6 @@ public static int Main(string[] args) return PollWasiEventLoopUntilResolved((Thread)null!, MainAsync(args)); [UnsafeAccessor(UnsafeAccessorKind.StaticMethod, Name = "PollWasiEventLoopUntilResolved")] - static extern int PollWasiEventLoopUntilResolved(Thread t, Task mainTask); + static extern T PollWasiEventLoopUntilResolved(Thread t, Task mainTask); } } diff --git a/src/mono/wasi/testassets/ILLink.Native.Descriptors.xml b/src/mono/wasi/testassets/ILLink.Native.Descriptors.xml new file mode 100644 index 00000000000..6f67d16fa0e --- /dev/null +++ b/src/mono/wasi/testassets/ILLink.Native.Descriptors.xml @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/src/mono/wasi/testassets/Native.cs b/src/mono/wasi/testassets/Native.cs new file mode 100644 index 00000000000..ffea2e7c343 --- /dev/null +++ b/src/mono/wasi/testassets/Native.cs @@ -0,0 +1,28 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Runtime.InteropServices; + +namespace Sample; + +public unsafe class Test +{ + [UnmanagedCallersOnly(EntryPoint = "ManagedFunc")] + public static int MyExport(int number) + { + // called from MyImport aka UnmanagedFunc + Console.WriteLine($"MyExport({number}) -> 42"); + return 42; + } + + [DllImport("*", EntryPoint = "UnmanagedFunc")] + public static extern void MyImport(); // calls ManagedFunc aka MyExport + + public unsafe static int Main(string[] args) + { + Console.WriteLine($"main: {args.Length}"); + MyImport(); + return 0; + } +} diff --git a/src/mono/wasi/testassets/native.c b/src/mono/wasi/testassets/native.c new file mode 100644 index 00000000000..9141571f949 --- /dev/null +++ b/src/mono/wasi/testassets/native.c @@ -0,0 +1,11 @@ +#include + +int ManagedFunc(int number); + +void UnmanagedFunc() +{ + int ret = 0; + printf("UnmanagedFunc calling ManagedFunc\n"); + ret = ManagedFunc(123); + printf("ManagedFunc returned %d\n", ret); +} \ No newline at end of file diff --git a/src/mono/wasm/Makefile b/src/mono/wasm/Makefile index a8826112502..275c4bad32d 100644 --- a/src/mono/wasm/Makefile +++ b/src/mono/wasm/Makefile @@ -38,7 +38,7 @@ test-runner: $(DOTNET) build $(TOP)/src/libraries/Common/tests/WasmTestRunner /p:Configuration=$(CONFIG) $(MSBUILD_ARGS) build-tasks: - $(DOTNET) build $(TOP)/src/tasks/tasks.proj /p:Configuration=$(CONFIG) $(MSBUILD_ARGS) + $(DOTNET) build $(TOP)/src/tasks/tasks.proj /p:Configuration=$(CONFIG) /p:TargetOS=browser $(MSBUILD_ARGS) clean: $(RM) -rf $(BUILDS_OBJ_DIR) diff --git a/src/mono/wasm/Wasm.Build.Tests/PInvokeTableGeneratorTests.cs b/src/mono/wasm/Wasm.Build.Tests/PInvokeTableGeneratorTests.cs index eb0959fcdb6..0c99d38835e 100644 --- a/src/mono/wasm/Wasm.Build.Tests/PInvokeTableGeneratorTests.cs +++ b/src/mono/wasm/Wasm.Build.Tests/PInvokeTableGeneratorTests.cs @@ -437,6 +437,77 @@ file class Foo Assert.Contains("Main running", output); } + [Theory] + [BuildAndRun(host: RunHost.Chrome)] + public void UnmanagedCallersOnly_Namespaced(BuildArgs buildArgs, RunHost host, string id) + { + string code = + """ + using System; + using System.Runtime.InteropServices; + + public class Test + { + public unsafe static int Main() + { + ((delegate* unmanaged)&A.Conflict.C)(); + ((delegate* unmanaged)&B.Conflict.C)(); + ((delegate* unmanaged)&A.Conflict.C\u733f)(); + ((delegate* unmanaged)&B.Conflict.C\u733f)(); + return 42; + } + } + + namespace A { + public class Conflict { + [UnmanagedCallersOnly(EntryPoint = "A_Conflict_C")] + public static void C() { + Console.WriteLine("A.Conflict.C"); + } + + [UnmanagedCallersOnly(EntryPoint = "A_Conflict_C\u733f")] + public static void C\u733f() { + Console.WriteLine("A.Conflict.C_\U0001F412"); + } + } + } + + namespace B { + public class Conflict { + [UnmanagedCallersOnly(EntryPoint = "B_Conflict_C")] + public static void C() { + Console.WriteLine("B.Conflict.C"); + } + + [UnmanagedCallersOnly(EntryPoint = "B_Conflict_C\u733f")] + public static void C\u733f() { + Console.WriteLine("B.Conflict.C_\U0001F412"); + } + } + } + """; + + (buildArgs, string output) = BuildForVariadicFunctionTests( + code, + buildArgs with { ProjectName = $"cb_namespace_{buildArgs.Config}" }, + id + ); + + Assert.DoesNotMatch(".*(warning|error).*>[A-Z0-9]+__Foo", output); + + output = RunAndTestWasmApp(buildArgs, buildDir: _projectDir, expectedExitCode: 42, host: host, id: id); + Assert.Contains("A.Conflict.C", output); + Assert.Contains("B.Conflict.C", output); + if (OperatingSystem.IsWindows()) { + // Windows console unicode support is not great + Assert.Contains("A.Conflict.C_", output); + Assert.Contains("B.Conflict.C_", output); + } else { + Assert.Contains("A.Conflict.C_\U0001F412", output); + Assert.Contains("B.Conflict.C_\U0001F412", output); + } + } + [Theory] [BuildAndRun(host: RunHost.None)] public void IcallWithOverloadedParametersAndEnum(BuildArgs buildArgs, string id) @@ -951,6 +1022,7 @@ public void UCOWithSpecialCharacters(BuildArgs buildArgs, RunHost host, string i DotnetWasmFromRuntimePack: false)); var runOutput = RunAndTestWasmApp(buildArgs, buildDir: _projectDir, expectedExitCode: 42, host: host, id: id); + Assert.DoesNotContain("Conflict.A.Managed8\u4F60Func(123) -> 123", runOutput); Assert.Contains("ManagedFunc returned 42", runOutput); } } diff --git a/src/mono/wasm/Wasm.Build.Tests/TestAppScenarios/MemoryTests.cs b/src/mono/wasm/Wasm.Build.Tests/TestAppScenarios/MemoryTests.cs index e95aa351ce8..239950d1fd7 100644 --- a/src/mono/wasm/Wasm.Build.Tests/TestAppScenarios/MemoryTests.cs +++ b/src/mono/wasm/Wasm.Build.Tests/TestAppScenarios/MemoryTests.cs @@ -5,6 +5,7 @@ using System.Collections.Generic; using System.Linq; using System.Threading.Tasks; +using System.Text.RegularExpressions; using Xunit.Abstractions; using Xunit; @@ -37,4 +38,26 @@ public async Task AllocateLargeHeapThenRepeatedlyInterop() await RunSdkStyleAppForBuild(new (Configuration: config, TestScenario: "AllocateLargeHeapThenInterop")); } } + + [Fact] + public async Task RunSimpleAppWithProfiler() + { + string config = "Release"; + CopyTestAsset("WasmBasicTestApp", "ProfilerTest", "App"); + // are are linking all 3 profilers, but below we only initialize log profiler and test it + string extraArgs = $"-p:WasmProfilers=\"aot+browser+log\" -p:WasmBuildNative=true"; + BuildProject(config, assertAppBundle: false, extraArgs: extraArgs); + + var result = await RunSdkStyleAppForBuild(new (Configuration: config, TestScenario: "ProfilerTest")); + Regex regex = new Regex(@"Profile data of size (\d+) bytes"); + var match = result.TestOutput + .Select(line => regex.Match(line)) + .FirstOrDefault(m => m.Success); + Assert.True(match != null, $"TestOuptup did not contain log matching {regex}"); + if (!int.TryParse(match.Groups[1].Value, out int fileSize)) + { + Assert.Fail($"Failed to parse profile size from {match.Groups[1].Value} to int"); + } + Assert.True(fileSize >= 10 * 1024, $"Profile file size is less than 10KB. Actual size: {fileSize} bytes."); + } } diff --git a/src/mono/wasm/Wasm.Build.Tests/TestAppScenarios/SatelliteLoadingTests.cs b/src/mono/wasm/Wasm.Build.Tests/TestAppScenarios/SatelliteLoadingTests.cs index 5e15cc53841..3acee24e885 100644 --- a/src/mono/wasm/Wasm.Build.Tests/TestAppScenarios/SatelliteLoadingTests.cs +++ b/src/mono/wasm/Wasm.Build.Tests/TestAppScenarios/SatelliteLoadingTests.cs @@ -11,6 +11,7 @@ using Microsoft.Playwright; using Xunit.Abstractions; using Xunit; +using System.Xml.Linq; #nullable enable @@ -38,4 +39,44 @@ public async Task LoadSatelliteAssembly() m => Assert.Equal("es-ES with satellite: hola", m) ); } + + [Fact] + public async Task LoadSatelliteAssemblyFromReference() + { + CopyTestAsset("WasmBasicTestApp", "SatelliteLoadingTestsFromReference", "App"); + + // Replace ProjectReference with Reference + var appCsprojPath = Path.Combine(_projectDir!, "WasmBasicTestApp.csproj"); + var appCsproj = XDocument.Load(appCsprojPath); + + var projectReference = appCsproj.Descendants("ProjectReference").Where(pr => pr.Attribute("Include")?.Value?.Contains("ResourceLibrary") ?? false).Single(); + var itemGroup = projectReference.Parent!; + projectReference.Remove(); + + var reference = new XElement("Reference"); + reference.SetAttributeValue("Include", "..\\ResourceLibrary\\bin\\Release\\net9.0\\ResourceLibrary.dll"); + itemGroup.Add(reference); + + appCsproj.Save(appCsprojPath); + + // Build the library + var libraryCsprojPath = Path.GetFullPath(Path.Combine(_projectDir!, "..", "ResourceLibrary")); + new DotNetCommand(s_buildEnv, _testOutput) + .WithWorkingDirectory(libraryCsprojPath) + .WithEnvironmentVariable("NUGET_PACKAGES", _nugetPackagesDir) + .ExecuteWithCapturedOutput("build -c Release") + .EnsureSuccessful(); + + // Publish the app and assert + PublishProject("Release"); + + var result = await RunSdkStyleAppForPublish(new(Configuration: "Release", TestScenario: "SatelliteAssembliesTest")); + Assert.Collection( + result.TestOutput, + m => Assert.Equal("default: hello", m), + m => Assert.Equal("es-ES without satellite: hello", m), + m => Assert.Equal("default: hello", m), + m => Assert.Equal("es-ES with satellite: hola", m) + ); + } } diff --git a/src/mono/wasm/build/WasmApp.Common.targets b/src/mono/wasm/build/WasmApp.Common.targets index 2641a239ac4..cee4e3c1bea 100644 --- a/src/mono/wasm/build/WasmApp.Common.targets +++ b/src/mono/wasm/build/WasmApp.Common.targets @@ -442,7 +442,7 @@ + Properties="_WasmInNestedPublish_UniqueProperty_XYZ=true;;WasmBuildingForNestedPublish=true;DeployOnBuild=;_IsPublishing=;_WasmIsPublishing=$(_IsPublishing);ResolveAssemblyReferencesFindRelatedSatellites=true"> diff --git a/src/mono/wasm/features.md b/src/mono/wasm/features.md index 0f84f0bd00e..2511f9c5c7b 100644 --- a/src/mono/wasm/features.md +++ b/src/mono/wasm/features.md @@ -426,6 +426,45 @@ import { dotnet } from './dotnet.js' await dotnet.withConfig({browserProfilerOptions: {}}).run(); ``` +### Log Profiling for Memory Troubleshooting + +You can enable integration with log profiler via following elements in your .csproj: + +```xml + + log; + true + +``` + +In simple browser template, you can add following to your `main.js` + +```javascript +import { dotnet } from './dotnet.js' +await dotnet.withConfig({ + logProfilerOptions: { + takeHeapshot: "MyApp.Profiling::TakeHeapshot", + configuration: "log:alloc,output=output.mlpd" + }}).run(); +``` + +In order to trigger a heap shot, add the following: + +```csharp +namespace MyApp; + +class Profiling +{ + [JSExport] + [MethodImpl(MethodImplOptions.NoInlining)] + public static void TakeHeapshot() { } +} +``` + +Invoke `MyApp.Profiling.TakeHeapshot()` from your code in order to create a memory heap shot and flush the contents of the profile to the VFS. Make sure to align the namespace and class of the `logProfilerOptions.takeHeapshot` with your class. + +You can download the mpld file to analyze it. + ### Diagnostic tools We have initial implementation of diagnostic server and [event pipe](https://learn.microsoft.com/dotnet/core/diagnostics/eventpipe) diff --git a/src/mono/wasm/host/BrowserHost.cs b/src/mono/wasm/host/BrowserHost.cs index 5be2ddfdaac..9e27a169ecc 100644 --- a/src/mono/wasm/host/BrowserHost.cs +++ b/src/mono/wasm/host/BrowserHost.cs @@ -68,6 +68,14 @@ private async Task RunAsync(ILoggerFactory loggerFactory, CancellationToken toke debugging: _args.CommonConfig.Debugging); runArgsJson.Save(Path.Combine(_args.CommonConfig.AppPath, "runArgs.json")); + // Read system environment variables after runArgs.json is saved, so they won't be passed to browser. + // But we need them to correctly read ASPNETCORE_URLS + foreach (DictionaryEntry de in Environment.GetEnvironmentVariables()) + { + if (de.Key is not null && de.Value is not null) + envVars[(string)de.Key] = (string)de.Value; + } + string[] urls = (envVars.TryGetValue("ASPNETCORE_URLS", out string? aspnetUrls) && aspnetUrls.Length > 0) ? aspnetUrls.Split(';', StringSplitOptions.RemoveEmptyEntries) : new string[] { $"http://127.0.0.1:{_args.CommonConfig.HostProperties.WebServerPort}", "https://127.0.0.1:0" }; diff --git a/src/mono/wasm/host/wasi/WasiEngineArguments.cs b/src/mono/wasm/host/wasi/WasiEngineArguments.cs index 64276047091..a0d4de4a4ee 100644 --- a/src/mono/wasm/host/wasi/WasiEngineArguments.cs +++ b/src/mono/wasm/host/wasi/WasiEngineArguments.cs @@ -30,6 +30,7 @@ public WasiEngineArguments(CommonConfiguration commonConfig) private OptionSet GetOptions() => new OptionSet { + // until WASI can work with unix exit code https://github.com/WebAssembly/wasi-cli/pull/44 { "forward-exit-code", "Forward process exit code via stderr", v => ForwardExitCode = true } }; diff --git a/src/mono/wasm/templates/Microsoft.NET.Runtime.WebAssembly.Templates.csproj b/src/mono/wasm/templates/Microsoft.NET.Runtime.WebAssembly.Templates.csproj index 0a4927e350f..8382011b318 100644 --- a/src/mono/wasm/templates/Microsoft.NET.Runtime.WebAssembly.Templates.csproj +++ b/src/mono/wasm/templates/Microsoft.NET.Runtime.WebAssembly.Templates.csproj @@ -2,7 +2,7 @@ Template - Microsoft.NET.Runtime.WebAssembly.Templates + Microsoft.NET.Runtime.WebAssembly.Templates.net9 WebAssembly Templates Microsoft Templates to create WebAssembly projects. @@ -16,6 +16,9 @@ $(NoWarn);NU5128 true false + true + + false diff --git a/src/mono/wasm/testassets/Wasm.Buid.Tests.Programs/UnmanagedCallback.cs b/src/mono/wasm/testassets/Wasm.Buid.Tests.Programs/UnmanagedCallback.cs index 2157909c3d5..623cd2c5cb7 100644 --- a/src/mono/wasm/testassets/Wasm.Buid.Tests.Programs/UnmanagedCallback.cs +++ b/src/mono/wasm/testassets/Wasm.Buid.Tests.Programs/UnmanagedCallback.cs @@ -6,13 +6,24 @@ public unsafe partial class Test public unsafe static int Main(string[] args) { ((IntPtr)(delegate* unmanaged)&Interop.Managed8\u4F60Func).ToString(); - Console.WriteLine($"main: {args.Length}"); Interop.UnmanagedFunc(); + return 42; } } +namespace Conflict.A { + file class Interop { + [UnmanagedCallersOnly(EntryPoint = "ConflictManagedFunc")] + public static int Managed8\u4F60Func(int number) + { + Console.WriteLine($"Conflict.A.Managed8\u4F60Func({number}) -> {number}"); + return number; + } + } +} + file partial class Interop { [UnmanagedCallersOnly(EntryPoint = "ManagedFunc")] diff --git a/src/mono/wasm/testassets/WasmBasicTestApp/App/ProfilerTest.cs b/src/mono/wasm/testassets/WasmBasicTestApp/App/ProfilerTest.cs new file mode 100644 index 00000000000..ef3fa75dc92 --- /dev/null +++ b/src/mono/wasm/testassets/WasmBasicTestApp/App/ProfilerTest.cs @@ -0,0 +1,23 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices.JavaScript; + +public partial class ProfilerTest +{ + [JSExport] + [MethodImpl(MethodImplOptions.NoInlining)] + public static void TakeHeapshot() { } + + [JSExport] + public static int TestMeaning() + { + for(int i=0; i<100; i++){ + var r = new int[1000]; + } + + return 42; + } +} diff --git a/src/mono/wasm/testassets/WasmBasicTestApp/App/SatelliteAssembliesTest.cs b/src/mono/wasm/testassets/WasmBasicTestApp/App/SatelliteAssembliesTest.cs index b8dc5b0dbf8..23f3df8098c 100644 --- a/src/mono/wasm/testassets/WasmBasicTestApp/App/SatelliteAssembliesTest.cs +++ b/src/mono/wasm/testassets/WasmBasicTestApp/App/SatelliteAssembliesTest.cs @@ -2,25 +2,19 @@ // The .NET Foundation licenses this file to you under the MIT license. using System; -using System.Globalization; -using System.Threading.Tasks; -using System.Resources; using System.Runtime.InteropServices.JavaScript; +using System.Threading.Tasks; public partial class SatelliteAssembliesTest { [JSExport] public static async Task Run() { - var rm = new ResourceManager("WasmBasicTestApp.words", typeof(Program).Assembly); - TestOutput.WriteLine("default: " + rm.GetString("hello", CultureInfo.CurrentCulture)); - TestOutput.WriteLine("es-ES without satellite: " + rm.GetString("hello", new CultureInfo("es-ES"))); + ResourceLibrary.ResourceAccessor.Read(TestOutput.WriteLine, false); await LoadSatelliteAssemblies(new[] { "es-ES" }); - rm = new ResourceManager("WasmBasicTestApp.words", typeof(Program).Assembly); - TestOutput.WriteLine("default: " + rm.GetString("hello", CultureInfo.CurrentCulture)); - TestOutput.WriteLine("es-ES with satellite: " + rm.GetString("hello", new CultureInfo("es-ES"))); + ResourceLibrary.ResourceAccessor.Read(TestOutput.WriteLine, true); } [JSImport("INTERNAL.loadSatelliteAssemblies")] diff --git a/src/mono/wasm/testassets/WasmBasicTestApp/App/WasmBasicTestApp.csproj b/src/mono/wasm/testassets/WasmBasicTestApp/App/WasmBasicTestApp.csproj index f93102b467a..548b310286b 100644 --- a/src/mono/wasm/testassets/WasmBasicTestApp/App/WasmBasicTestApp.csproj +++ b/src/mono/wasm/testassets/WasmBasicTestApp/App/WasmBasicTestApp.csproj @@ -16,9 +16,11 @@ + + diff --git a/src/mono/wasm/testassets/WasmBasicTestApp/App/wwwroot/index.html b/src/mono/wasm/testassets/WasmBasicTestApp/App/wwwroot/index.html index 997c0d3047c..5179693a495 100644 --- a/src/mono/wasm/testassets/WasmBasicTestApp/App/wwwroot/index.html +++ b/src/mono/wasm/testassets/WasmBasicTestApp/App/wwwroot/index.html @@ -8,6 +8,7 @@ + diff --git a/src/mono/wasm/testassets/WasmBasicTestApp/App/wwwroot/main.js b/src/mono/wasm/testassets/WasmBasicTestApp/App/wwwroot/main.js index f0515c8dfe5..75071104f67 100644 --- a/src/mono/wasm/testassets/WasmBasicTestApp/App/wwwroot/main.js +++ b/src/mono/wasm/testassets/WasmBasicTestApp/App/wwwroot/main.js @@ -2,6 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. import { dotnet, exit } from './_framework/dotnet.js' +import { saveProfile } from './profiler.js' // Read test case from query string const params = new URLSearchParams(location.search); @@ -121,9 +122,17 @@ switch (testCase) { }; dotnet.withConfig({ maxParallelDownloads: maxParallelDownloads }); break; + case "ProfilerTest": + dotnet.withConfig({ + logProfilerOptions: { + takeHeapshot: "ProfilerTest::TakeHeapshot", + configuration: "log:alloc,output=output.mlpd" + } + }) + break; } -const { setModuleImports, getAssemblyExports, getConfig, INTERNAL } = await dotnet.create(); +const { setModuleImports, Module, getAssemblyExports, getConfig, INTERNAL } = await dotnet.create(); const config = getConfig(); const exports = await getAssemblyExports(config.mainAssemblyName); const assemblyExtension = Object.keys(config.resources.coreAssembly)[0].endsWith('.wasm') ? ".wasm" : ".dll"; @@ -201,6 +210,25 @@ try { exports.MemoryTest.Run(); exit(0); break; + case "ProfilerTest": + console.log("not ready yet") + const myExports = await getAssemblyExports(config.mainAssemblyName); + const testMeaning = myExports.ProfilerTest.TestMeaning; + const takeHeapshot = myExports.ProfilerTest.TakeHeapshot; + console.log("ready"); + + dotnet.run(); + + const ret = testMeaning(); + document.getElementById("out").innerHTML = ret; + console.debug(`ret: ${ret}`); + + takeHeapshot(); + saveProfile(Module); + + let exit_code = ret == 42 ? 0 : 1; + exit(exit_code); + break; default: console.error(`Unknown test case: ${testCase}`); exit(3); diff --git a/src/mono/wasm/testassets/WasmBasicTestApp/App/wwwroot/profiler.js b/src/mono/wasm/testassets/WasmBasicTestApp/App/wwwroot/profiler.js new file mode 100644 index 00000000000..53d3841e316 --- /dev/null +++ b/src/mono/wasm/testassets/WasmBasicTestApp/App/wwwroot/profiler.js @@ -0,0 +1,35 @@ +export function saveProfile(Module) { + const fileName = "output.mlpd"; + let profileData = readProfileFile(Module, fileName); + + if (!profileData) { + console.error("Profile data is empty or could not be read."); + return; + } + + const a = document.createElement('a'); + const blob = new Blob([profileData]); + a.href = URL.createObjectURL(blob); + a.download = fileName; + // Append anchor to body. + document.body.appendChild(a); + a.click(); + + console.log(`TestOutput -> Profile data of size ${profileData.length} bytes started downloading.`); + + // Remove anchor from body + document.body.removeChild(a); +} + +function readProfileFile(Module, fileName) { + + var stat = Module.FS.stat(fileName); + + if (stat && stat.size > 0) { + return Module.FS.readFile(fileName); + } + else { + console.debug(`Unable to fetch the profile file ${fileName} as it is empty`); + return null; + } +} \ No newline at end of file diff --git a/src/mono/wasm/testassets/WasmBasicTestApp/Library/Json.cs b/src/mono/wasm/testassets/WasmBasicTestApp/Library/Json.cs index cd496b96a3f..d2cffde92c9 100644 --- a/src/mono/wasm/testassets/WasmBasicTestApp/Library/Json.cs +++ b/src/mono/wasm/testassets/WasmBasicTestApp/Library/Json.cs @@ -1,3 +1,6 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + using System.Text.Json; using System.Text.Json.Serialization; diff --git a/src/mono/wasm/testassets/WasmBasicTestApp/ResourceLibrary/ResourceAccessor.cs b/src/mono/wasm/testassets/WasmBasicTestApp/ResourceLibrary/ResourceAccessor.cs new file mode 100644 index 00000000000..27073846c66 --- /dev/null +++ b/src/mono/wasm/testassets/WasmBasicTestApp/ResourceLibrary/ResourceAccessor.cs @@ -0,0 +1,19 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Globalization; +using System.Threading.Tasks; +using System.Resources; + +namespace ResourceLibrary; + +public static class ResourceAccessor +{ + public static void Read(Action testOuput, bool hasSatellites) + { + var rm = new ResourceManager("ResourceLibrary.words", typeof(ResourceAccessor).Assembly); + testOuput($"default: {rm.GetString("hello", CultureInfo.CurrentCulture)}"); + testOuput($"es-ES {(hasSatellites ? "with" : "without")} satellite: {rm.GetString("hello", new CultureInfo("es-ES"))}"); + } +} diff --git a/src/mono/wasm/testassets/WasmBasicTestApp/ResourceLibrary/ResourceLibrary.csproj b/src/mono/wasm/testassets/WasmBasicTestApp/ResourceLibrary/ResourceLibrary.csproj new file mode 100644 index 00000000000..3d5e0e2093c --- /dev/null +++ b/src/mono/wasm/testassets/WasmBasicTestApp/ResourceLibrary/ResourceLibrary.csproj @@ -0,0 +1,7 @@ + + + net9.0 + Library + true + + diff --git a/src/mono/wasm/testassets/WasmBasicTestApp/App/words.es-ES.resx b/src/mono/wasm/testassets/WasmBasicTestApp/ResourceLibrary/words.es-ES.resx similarity index 100% rename from src/mono/wasm/testassets/WasmBasicTestApp/App/words.es-ES.resx rename to src/mono/wasm/testassets/WasmBasicTestApp/ResourceLibrary/words.es-ES.resx diff --git a/src/mono/wasm/testassets/WasmBasicTestApp/App/words.resx b/src/mono/wasm/testassets/WasmBasicTestApp/ResourceLibrary/words.resx similarity index 100% rename from src/mono/wasm/testassets/WasmBasicTestApp/App/words.resx rename to src/mono/wasm/testassets/WasmBasicTestApp/ResourceLibrary/words.resx diff --git a/src/mono/wasm/testassets/WasmOnAspNetCore/AspNetCoreServer/AspNetCoreServer.csproj b/src/mono/wasm/testassets/WasmOnAspNetCore/AspNetCoreServer/AspNetCoreServer.csproj index 3d0fa0a57f9..209503ed7fd 100644 --- a/src/mono/wasm/testassets/WasmOnAspNetCore/AspNetCoreServer/AspNetCoreServer.csproj +++ b/src/mono/wasm/testassets/WasmOnAspNetCore/AspNetCoreServer/AspNetCoreServer.csproj @@ -10,7 +10,7 @@ - + diff --git a/src/mono/wasm/testassets/WasmOnAspNetCore/BlazorClient/BlazorClient.csproj b/src/mono/wasm/testassets/WasmOnAspNetCore/BlazorClient/BlazorClient.csproj index b3535d0b965..554329c85b0 100644 --- a/src/mono/wasm/testassets/WasmOnAspNetCore/BlazorClient/BlazorClient.csproj +++ b/src/mono/wasm/testassets/WasmOnAspNetCore/BlazorClient/BlazorClient.csproj @@ -12,8 +12,8 @@ - - + + diff --git a/src/mono/wasm/testassets/WasmOnAspNetCore/Shared/Shared.csproj b/src/mono/wasm/testassets/WasmOnAspNetCore/Shared/Shared.csproj index 968e48496a1..f4f48b00892 100644 --- a/src/mono/wasm/testassets/WasmOnAspNetCore/Shared/Shared.csproj +++ b/src/mono/wasm/testassets/WasmOnAspNetCore/Shared/Shared.csproj @@ -10,7 +10,7 @@ - - + + diff --git a/src/mono/wasm/testassets/native-libs/local.c b/src/mono/wasm/testassets/native-libs/local.c index 4d7a660513c..df7987bb8f3 100644 --- a/src/mono/wasm/testassets/native-libs/local.c +++ b/src/mono/wasm/testassets/native-libs/local.c @@ -7,4 +7,4 @@ void UnmanagedFunc() printf("UnmanagedFunc calling ManagedFunc\n"); ret = ManagedFunc(123); printf("ManagedFunc returned %d\n", ret); -} \ No newline at end of file +} diff --git a/src/native/corehost/apphost/standalone/hostfxr_resolver.cpp b/src/native/corehost/apphost/standalone/hostfxr_resolver.cpp index 07344517799..d776260342f 100644 --- a/src/native/corehost/apphost/standalone/hostfxr_resolver.cpp +++ b/src/native/corehost/apphost/standalone/hostfxr_resolver.cpp @@ -125,8 +125,6 @@ hostfxr_resolver_t::hostfxr_resolver_t(const pal::string_t& app_root) else { trace::error(_X("The library %s was found, but loading it from %s failed"), LIBFXR_NAME, m_fxr_path.c_str()); - trace::error(_X(" - Installing .NET prerequisites might help resolve this problem.")); - trace::error(_X(" %s"), DOTNET_CORE_INSTALL_PREREQUISITES_URL); m_status_code = StatusCode::CoreHostLibLoadFailure; } } diff --git a/src/native/corehost/configure.h.in b/src/native/corehost/configure.h.in index 4ddf2e6cfa7..a8774b2aee0 100644 --- a/src/native/corehost/configure.h.in +++ b/src/native/corehost/configure.h.in @@ -1,7 +1,7 @@ #ifndef PAL_HOST_CONFIGURE_H_INCLUDED #define PAL_HOST_CONFIGURE_H_INCLUDED -#cmakedefine01 CLR_SINGLE_FILE_HOST_ONLY +#cmakedefine CLR_SINGLE_FILE_HOST_ONLY #ifdef CLR_SINGLE_FILE_HOST_ONLY // When hosting components are all statically linked, @@ -20,4 +20,4 @@ #define CURRENT_OS_NAME "@CLR_CMAKE_TARGET_OS@" #define CURRENT_ARCH_NAME "@CLR_CMAKE_TARGET_ARCH@" -#endif // PAL_HOST_CONFIGURE_H_INCLUDED \ No newline at end of file +#endif // PAL_HOST_CONFIGURE_H_INCLUDED diff --git a/src/native/corehost/fxr/fx_muxer.cpp b/src/native/corehost/fxr/fx_muxer.cpp index d4723ad5ed5..b6706b00b88 100644 --- a/src/native/corehost/fxr/fx_muxer.cpp +++ b/src/native/corehost/fxr/fx_muxer.cpp @@ -1062,7 +1062,7 @@ int fx_muxer_t::handle_cli( trace::error( _X("The command could not be loaded, possibly because:\n") _X(" * You intended to execute a .NET application:\n") - _X(" The application '%s' does not exist.\n") + _X(" The application '%s' does not exist or is not a managed .dll or .exe.\n") _X(" * You intended to execute a .NET SDK command:"), app_candidate.c_str()); resolver.print_resolution_error(host_info.dotnet_root, _X(" ")); diff --git a/src/native/corehost/fxr/fx_resolver.cpp b/src/native/corehost/fxr/fx_resolver.cpp index e78bd63eca1..c109fa25712 100644 --- a/src/native/corehost/fxr/fx_resolver.cpp +++ b/src/native/corehost/fxr/fx_resolver.cpp @@ -540,7 +540,7 @@ StatusCode fx_resolver_t::resolve_frameworks_for_app( _X("Architecture: %s"), app_display_name, get_current_arch_name()); - display_missing_framework_error(resolution_failure.missing.get_fx_name(), resolution_failure.missing.get_fx_version(), pal::string_t(), dotnet_root, app_config.get_is_multilevel_lookup_disabled()); + display_missing_framework_error(resolution_failure.missing.get_fx_name(), resolution_failure.missing.get_fx_version(), dotnet_root, app_config.get_is_multilevel_lookup_disabled()); break; case StatusCode::FrameworkCompatFailure: display_incompatible_framework_error(resolution_failure.incompatible_higher.get_fx_version(), resolution_failure.incompatible_lower); diff --git a/src/native/corehost/fxr/fx_resolver.h b/src/native/corehost/fxr/fx_resolver.h index 466decd846f..9abfd706baa 100644 --- a/src/native/corehost/fxr/fx_resolver.h +++ b/src/native/corehost/fxr/fx_resolver.h @@ -64,7 +64,6 @@ class fx_resolver_t static void display_missing_framework_error( const pal::string_t& fx_name, const pal::string_t& fx_version, - const pal::string_t& fx_dir, const pal::string_t& dotnet_root, bool disable_multilevel_lookup); static void display_incompatible_framework_error( diff --git a/src/native/corehost/fxr/fx_resolver.messages.cpp b/src/native/corehost/fxr/fx_resolver.messages.cpp index e87cd6d0fba..a922858ae5b 100644 --- a/src/native/corehost/fxr/fx_resolver.messages.cpp +++ b/src/native/corehost/fxr/fx_resolver.messages.cpp @@ -3,6 +3,7 @@ #include "fx_resolver.h" #include "framework_info.h" +#include "install_info.h" /** * When the framework is referenced more than once in a non-compatible way, display detailed error message @@ -92,23 +93,9 @@ void fx_resolver_t::display_summary_of_frameworks( void fx_resolver_t::display_missing_framework_error( const pal::string_t& fx_name, const pal::string_t& fx_version, - const pal::string_t& fx_dir, const pal::string_t& dotnet_root, bool disable_multilevel_lookup) { - std::vector framework_infos; - pal::string_t fx_ver_dirs; - if (fx_dir.length()) - { - fx_ver_dirs = fx_dir; - framework_info::get_all_framework_infos(get_directory(fx_dir), fx_name.c_str(), disable_multilevel_lookup, &framework_infos); - } - else - { - fx_ver_dirs = dotnet_root; - } - - framework_info::get_all_framework_infos(dotnet_root, fx_name.c_str(), disable_multilevel_lookup, &framework_infos); // Display the error message about missing FX. if (fx_version.length()) @@ -122,6 +109,8 @@ void fx_resolver_t::display_missing_framework_error( trace::error(_X(".NET location: %s\n"), dotnet_root.c_str()); + std::vector framework_infos; + framework_info::get_all_framework_infos(dotnet_root, fx_name.c_str(), disable_multilevel_lookup, &framework_infos); if (framework_infos.size()) { trace::error(_X("The following frameworks were found:")); @@ -135,6 +124,30 @@ void fx_resolver_t::display_missing_framework_error( trace::error(_X("No frameworks were found.")); } + std::vector>> other_arch_framework_infos; + install_info::enumerate_other_architectures( + [&](pal::architecture arch, const pal::string_t& install_location, bool is_registered) + { + std::vector other_arch_infos; + framework_info::get_all_framework_infos(install_location, fx_name.c_str(), disable_multilevel_lookup, &other_arch_infos); + if (!other_arch_infos.empty()) + { + other_arch_framework_infos.push_back(std::make_pair(arch, std::move(other_arch_infos))); + } + }); + if (!other_arch_framework_infos.empty()) + { + trace::error(_X("\nThe following frameworks for other architectures were found:")); + for (const auto& arch_info_pair : other_arch_framework_infos) + { + trace::error(_X(" %s"), get_arch_name(arch_info_pair.first)); + for (const framework_info& info : arch_info_pair.second) + { + trace::error(_X(" %s at [%s]"), info.version.as_str().c_str(), info.path.c_str()); + } + } + } + pal::string_t url = get_download_url(fx_name.c_str(), fx_version.c_str()); trace::error( _X("\n") diff --git a/src/native/corehost/fxr/fx_ver.cpp b/src/native/corehost/fxr/fx_ver.cpp index 7a857cdff47..ff4b4009aed 100644 --- a/src/native/corehost/fxr/fx_ver.cpp +++ b/src/native/corehost/fxr/fx_ver.cpp @@ -373,7 +373,6 @@ bool parse_internal(const pal::string_t& ver, fx_ver_t* fx_ver, bool parse_only_ bool fx_ver_t::parse(const pal::string_t& ver, fx_ver_t* fx_ver, bool parse_only_production) { bool valid = parse_internal(ver, fx_ver, parse_only_production); - // Causes a SIGABRT in free() on MacOS at least in singlefile, possibly elsewhere - // assert(!valid || fx_ver->as_str() == ver); + assert(!valid || fx_ver->as_str() == ver); return valid; } diff --git a/src/native/corehost/fxr/hostfxr.cpp b/src/native/corehost/fxr/hostfxr.cpp index 3b09cb48850..7a071bc4c30 100644 --- a/src/native/corehost/fxr/hostfxr.cpp +++ b/src/native/corehost/fxr/hostfxr.cpp @@ -853,6 +853,8 @@ SHARED_API int32_t HOSTFXR_CALLTYPE hostfxr_get_runtime_property_value( if (name == nullptr || value == nullptr) return StatusCode::InvalidArgFailure; + *value = nullptr; + const host_context_t *context; if (host_context_handle == nullptr) { @@ -931,6 +933,7 @@ SHARED_API int32_t HOSTFXR_CALLTYPE hostfxr_get_runtime_properties( if (context_maybe == nullptr) { trace::error(_X("Hosting components context has not been initialized. Cannot get runtime properties.")); + *count = 0; return StatusCode::HostInvalidState; } @@ -940,7 +943,10 @@ SHARED_API int32_t HOSTFXR_CALLTYPE hostfxr_get_runtime_properties( { context = host_context_t::from_handle(host_context_handle); if (context == nullptr) + { + *count = 0; return StatusCode::InvalidArgFailure; + } } if (context->type == host_context_type::secondary) diff --git a/src/native/corehost/fxr/install_info.cpp b/src/native/corehost/fxr/install_info.cpp index ff231938db0..281457f1158 100644 --- a/src/native/corehost/fxr/install_info.cpp +++ b/src/native/corehost/fxr/install_info.cpp @@ -31,7 +31,7 @@ bool install_info::print_environment(const pal::char_t* leading_whitespace) return found_any; } -bool install_info::print_other_architectures(const pal::char_t* leading_whitespace) +bool install_info::enumerate_other_architectures(std::function callback) { bool found_any = false; for (uint32_t i = 0; i < static_cast(pal::architecture::__last); ++i) @@ -47,13 +47,22 @@ bool install_info::print_other_architectures(const pal::char_t* leading_whitespa { found_any = true; remove_trailing_dir_separator(&install_location); + callback(arch, install_location, is_registered); + } + } + + return found_any; +} + +bool install_info::print_other_architectures(const pal::char_t* leading_whitespace) +{ + return enumerate_other_architectures( + [&](pal::architecture arch, const pal::string_t& install_location, bool is_registered) + { trace::println(_X("%s%-5s [%s]"), leading_whitespace, get_arch_name(arch), install_location.c_str()); if (is_registered) { trace::println(_X("%s registered at [%s]"), leading_whitespace, pal::get_dotnet_self_registered_config_location(arch).c_str()); } - } - } - - return found_any; + }); } diff --git a/src/native/corehost/fxr/install_info.h b/src/native/corehost/fxr/install_info.h index 3a100486b8f..3f9d5910268 100644 --- a/src/native/corehost/fxr/install_info.h +++ b/src/native/corehost/fxr/install_info.h @@ -5,9 +5,11 @@ #define __INSTALL_INFO_H__ #include "pal.h" +#include namespace install_info { + bool enumerate_other_architectures(std::function callback); bool print_environment(const pal::char_t* leading_whitespace); bool print_other_architectures(const pal::char_t* leading_whitespace); }; diff --git a/src/native/corehost/fxr_resolver.h b/src/native/corehost/fxr_resolver.h index b61f3b8fb4e..0c82fc45851 100644 --- a/src/native/corehost/fxr_resolver.h +++ b/src/native/corehost/fxr_resolver.h @@ -59,8 +59,6 @@ int load_fxr_and_get_delegate(hostfxr_delegate_type type, THostPathToConfigCallb if (!pal::load_library(&fxr_path, &fxr)) { trace::error(_X("The library %s was found, but loading it from %s failed"), LIBFXR_NAME, fxr_path.c_str()); - trace::error(_X(" - Installing .NET prerequisites might help resolve this problem.")); - trace::error(_X(" %s"), DOTNET_CORE_INSTALL_PREREQUISITES_URL); return StatusCode::CoreHostLibLoadFailure; } } diff --git a/src/native/corehost/hostmisc/pal.windows.cpp b/src/native/corehost/hostmisc/pal.windows.cpp index 3a3db968b5b..c18da53e5a7 100644 --- a/src/native/corehost/hostmisc/pal.windows.cpp +++ b/src/native/corehost/hostmisc/pal.windows.cpp @@ -10,7 +10,6 @@ #include #include - void pal::file_vprintf(FILE* f, const pal::char_t* format, va_list vl) { // String functions like vfwprintf convert wide to multi-byte characters as if wcrtomb were called - that is, using the current C locale (LC_TYPE). @@ -21,7 +20,8 @@ void pal::file_vprintf(FILE* f, const pal::char_t* format, va_list vl) _free_locale(loc); } -namespace { +namespace +{ void print_line_to_handle(const pal::char_t* message, HANDLE handle, FILE* fallbackFileHandle) { // String functions like vfwprintf convert wide to multi-byte characters as if wcrtomb were called - that is, using the current C locale (LC_TYPE). // In order to properly print UTF-8 and GB18030 characters to the console without requiring the user to use chcp to a compatible locale, we use WriteConsoleW. @@ -42,12 +42,14 @@ namespace { } } -void pal::err_print_line(const pal::char_t* message) { +void pal::err_print_line(const pal::char_t* message) +{ // Forward to helper to handle UTF-8 formatting and redirection print_line_to_handle(message, ::GetStdHandle(STD_ERROR_HANDLE), stderr); } -void pal::out_vprint_line(const pal::char_t* format, va_list vl) { +void pal::out_vprint_line(const pal::char_t* format, va_list vl) +{ va_list vl_copy; va_copy(vl_copy, vl); // Get the length of the formatted string + 1 for null terminator @@ -96,35 +98,35 @@ namespace return s_get_temp_path_func(buffer_len, buffer); } -} -bool GetModuleFileNameWrapper(HMODULE hModule, pal::string_t* recv) -{ - pal::string_t path; - size_t dwModuleFileName = MAX_PATH / 2; - - do + bool GetModuleFileNameWrapper(HMODULE hModule, pal::string_t* recv) { - path.resize(dwModuleFileName * 2); - dwModuleFileName = GetModuleFileNameW(hModule, (LPWSTR)path.data(), static_cast(path.size())); - } while (dwModuleFileName == path.size()); + pal::string_t path; + size_t dwModuleFileName = MAX_PATH / 2; - if (dwModuleFileName == 0) - return false; + do + { + path.resize(dwModuleFileName * 2); + dwModuleFileName = GetModuleFileNameW(hModule, (LPWSTR)path.data(), static_cast(path.size())); + } while (dwModuleFileName == path.size()); - path.resize(dwModuleFileName); - recv->assign(path); - return true; -} + if (dwModuleFileName == 0) + return false; -bool GetModuleHandleFromAddress(void *addr, HMODULE *hModule) -{ - BOOL res = ::GetModuleHandleExW( - GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, - reinterpret_cast(addr), - hModule); + path.resize(dwModuleFileName); + recv->assign(path); + return true; + } + + bool GetModuleHandleFromAddress(void *addr, HMODULE *hModule) + { + BOOL res = ::GetModuleHandleExW( + GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, + reinterpret_cast(addr), + hModule); - return (res != FALSE); + return (res != FALSE); + } } pal::string_t pal::get_timestamp() @@ -263,7 +265,7 @@ bool pal::load_library(const string_t* in_path, dll_t* dll) { if (!pal::fullpath(&path)) { - trace::error(_X("Failed to load the dll from [%s], HRESULT: 0x%X"), path.c_str(), HRESULT_FROM_WIN32(GetLastError())); + trace::error(_X("Failed to load [%s], HRESULT: 0x%X"), path.c_str(), HRESULT_FROM_WIN32(GetLastError())); return false; } } @@ -274,7 +276,13 @@ bool pal::load_library(const string_t* in_path, dll_t* dll) *dll = ::LoadLibraryExW(path.c_str(), NULL, LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR | LOAD_LIBRARY_SEARCH_DEFAULT_DIRS); if (*dll == nullptr) { - trace::error(_X("Failed to load the dll from [%s], HRESULT: 0x%X"), path.c_str(), HRESULT_FROM_WIN32(GetLastError())); + int error_code = ::GetLastError(); + trace::error(_X("Failed to load [%s], HRESULT: 0x%X"), path.c_str(), HRESULT_FROM_WIN32(error_code)); + if (error_code == ERROR_BAD_EXE_FORMAT) + { + trace::error(_X(" - Ensure the library matches the current process architecture: ") _STRINGIFY(CURRENT_ARCH_NAME)); + } + return false; } @@ -661,8 +669,8 @@ bool pal::getenv(const char_t* name, string_t* recv) } return false; } - auto buf = new char_t[length]; - if (::GetEnvironmentVariableW(name, buf, length) == 0) + std::vector buffer(length); + if (::GetEnvironmentVariableW(name, &buffer[0], length) == 0) { auto err = GetLastError(); if (err != ERROR_ENVVAR_NOT_FOUND) @@ -672,9 +680,7 @@ bool pal::getenv(const char_t* name, string_t* recv) return false; } - recv->assign(buf); - delete[] buf; - + recv->assign(buffer.data()); return true; } diff --git a/src/native/corehost/hostmisc/utils.h b/src/native/corehost/hostmisc/utils.h index 5d782a070f8..52c6754d290 100644 --- a/src/native/corehost/hostmisc/utils.h +++ b/src/native/corehost/hostmisc/utils.h @@ -10,13 +10,6 @@ #include #include -#if defined(_WIN32) -#define DOTNET_CORE_INSTALL_PREREQUISITES_URL _X("https://go.microsoft.com/fwlink/?linkid=798306") -#elif defined(TARGET_OSX) -#define DOTNET_CORE_INSTALL_PREREQUISITES_URL _X("https://go.microsoft.com/fwlink/?linkid=2063366") -#else -#define DOTNET_CORE_INSTALL_PREREQUISITES_URL _X("https://go.microsoft.com/fwlink/?linkid=2063370") -#endif #define DOTNET_CORE_DOWNLOAD_URL _X("https://aka.ms/dotnet/download") #define DOTNET_CORE_APPLAUNCH_URL _X("https://aka.ms/dotnet-core-applaunch") diff --git a/src/native/corehost/hostpolicy/deps_resolver.cpp b/src/native/corehost/hostpolicy/deps_resolver.cpp index 55d9bd8f948..ee8c6f1aca6 100644 --- a/src/native/corehost/hostpolicy/deps_resolver.cpp +++ b/src/native/corehost/hostpolicy/deps_resolver.cpp @@ -513,20 +513,6 @@ bool deps_resolver_t::resolve_tpa_list( // we cannot determine what assemblies are framework assemblies, and what assemblies are app-local assemblies. if (m_host_mode != host_mode_t::libhost) { - // First add managed assembly to the TPA. - // TODO: Remove: the deps should contain the managed DLL. - // Workaround for: csc.deps.json doesn't have the csc.dll - - // If this is a single-file bundle, app.dll is expected to be within the bundle, unless it is explicitly excluded from the bundle. - // In all other cases, add its path to the TPA list. - pal::string_t managed_app_name = get_filename(m_managed_app); - if (!bundle::info_t::is_single_file_bundle() || - bundle::runner_t::app()->probe(managed_app_name) == nullptr) - { - deps_asset_t asset(get_filename_without_ext(m_managed_app), managed_app_name, version_t(), version_t()); - add_tpa_asset(asset, m_managed_app, &items); - } - // Add the app's entries const auto& deps_entries = get_app_deps().get_entries(deps_entry_t::asset_types::runtime); for (const auto& entry : deps_entries) diff --git a/src/native/corehost/hostpolicy/hostpolicy.cpp b/src/native/corehost/hostpolicy/hostpolicy.cpp index a50069fbb37..f96f00e2962 100644 --- a/src/native/corehost/hostpolicy/hostpolicy.cpp +++ b/src/native/corehost/hostpolicy/hostpolicy.cpp @@ -551,9 +551,11 @@ namespace int HOSTPOLICY_CALLTYPE get_property(const pal::char_t *key, const pal::char_t **value) { - if (key == nullptr) + if (key == nullptr || value == nullptr) return StatusCode::InvalidArgFailure; + *value = nullptr; + const std::shared_ptr context = get_hostpolicy_context(/*require_runtime*/ false); if (context == nullptr) return StatusCode::HostInvalidState; @@ -595,7 +597,10 @@ namespace const std::shared_ptr context = get_hostpolicy_context(/*require_runtime*/ false); if (context == nullptr) + { + *count = 0; return StatusCode::HostInvalidState; + } size_t actualCount = context->coreclr_properties.count(); size_t input_count = *count; diff --git a/src/native/eventpipe/ep-provider.c b/src/native/eventpipe/ep-provider.c index 0c4f4441bba..cf7d9eb51d3 100644 --- a/src/native/eventpipe/ep-provider.c +++ b/src/native/eventpipe/ep-provider.c @@ -493,6 +493,7 @@ provider_free (EventPipeProvider * provider) dn_list_custom_free (provider->event_list, event_free_func); + ep_rt_wait_event_free (&provider->callbacks_complete_event); ep_rt_utf16_string_free (provider->provider_name_utf16); ep_rt_utf8_string_free (provider->provider_name); ep_rt_object_free (provider); diff --git a/src/native/eventpipe/ep.c b/src/native/eventpipe/ep.c index ae0af76d646..d57a01d9c09 100644 --- a/src/native/eventpipe/ep.c +++ b/src/native/eventpipe/ep.c @@ -644,7 +644,9 @@ disable_holding_lock ( ep_session_free (session); // Providers can't be deleted during tracing because they may be needed when serializing the file. - config_delete_deferred_providers(ep_config_get ()); + // Allow delete deferred providers to accumulate to mitigate potential use-after-free should + // another EventPipe session hold a reference to a provider set for deferred deletion. + // config_delete_deferred_providers(ep_config_get ()); } ep_requires_lock_held (); @@ -1319,22 +1321,18 @@ ep_delete_provider (EventPipeProvider *provider) // where we hold a provider after tracing has been disabled. bool wait_for_provider_callbacks_completion = false; EP_LOCK_ENTER (section1) - if (enabled ()) { - // Save the provider until the end of the tracing session. - ep_provider_set_delete_deferred (provider, true); - - // The callback func must be previously set to null, - // otherwise callbacks might never stop coming. - EP_ASSERT (provider->callback_func == NULL); - - // Calling ep_delete_provider within a Callback will result in a deadlock - // as deleting the provider with an active tracing session will block - // until all of the provider's callbacks are completed. - if (provider->callbacks_pending > 0) - wait_for_provider_callbacks_completion = true; - } else { - config_delete_provider (ep_config_get (), provider); - } + // Save the provider until the end of the tracing session. + ep_provider_set_delete_deferred (provider, true); + + // The callback func must be set to null, + // otherwise callbacks might never stop coming. + EP_ASSERT (provider->callback_func == NULL); + + // Calling ep_delete_provider within a Callback will result in a deadlock + // as deleting the provider with an active tracing session will block + // until all of the provider's callbacks are completed. + if (provider->callbacks_pending > 0) + wait_for_provider_callbacks_completion = true; EP_LOCK_EXIT (section1) // Block provider deletion until all pending callbacks are completed. @@ -1344,6 +1342,11 @@ ep_delete_provider (EventPipeProvider *provider) if (wait_for_provider_callbacks_completion) ep_rt_wait_event_wait (&provider->callbacks_complete_event, EP_INFINITE_WAIT, false); + EP_LOCK_ENTER (section2) + if (!enabled ()) + config_delete_provider (ep_config_get (), provider); + EP_LOCK_EXIT (section2) + ep_on_exit: ep_requires_lock_not_held (); return; diff --git a/src/native/external/brotli-version.txt b/src/native/external/brotli-version.txt index ea196f8138c..6842f9f3c8b 100644 --- a/src/native/external/brotli-version.txt +++ b/src/native/external/brotli-version.txt @@ -1,2 +1,6 @@ -1.0.9 -https://github.com/google/brotli/releases/tag/v1.0.9 +1.1.0 +https://github.com/google/brotli/releases/tag/v1.1.0 + +Copy the c/dec, c/enc, c/common, and c/include folders into the root and remove all other files. + +Apply https://github.com/google/brotli/commit/85d88cbfc2b742e0742286ec277b73bdbf7be433.patch \ No newline at end of file diff --git a/src/native/external/brotli.cmake b/src/native/external/brotli.cmake index bf72e767cc6..c8f1b153af3 100644 --- a/src/native/external/brotli.cmake +++ b/src/native/external/brotli.cmake @@ -7,6 +7,7 @@ set (BROTLI_SOURCES_BASE common/context.c common/dictionary.c common/platform.c + common/shared_dictionary.c common/transform.c dec/bit_reader.c dec/decode.c @@ -19,6 +20,7 @@ set (BROTLI_SOURCES_BASE enc/brotli_bit_stream.c enc/cluster.c enc/command.c + enc/compound_dictionary.c enc/compress_fragment.c enc/compress_fragment_two_pass.c enc/dictionary_hash.c diff --git a/src/native/external/brotli/common/constants.c b/src/native/external/brotli/common/constants.c index 6bad9f613ca..89866b15050 100644 --- a/src/native/external/brotli/common/constants.c +++ b/src/native/external/brotli/common/constants.c @@ -4,7 +4,7 @@ See file LICENSE for detail or copy at https://opensource.org/licenses/MIT */ -#include "./constants.h" +#include "constants.h" const BrotliPrefixCodeRange _kBrotliPrefixCodeRanges[BROTLI_NUM_BLOCK_LEN_SYMBOLS] = { diff --git a/src/native/external/brotli/common/constants.h b/src/native/external/brotli/common/constants.h index e848195a0dc..31e5bd376e9 100644 --- a/src/native/external/brotli/common/constants.h +++ b/src/native/external/brotli/common/constants.h @@ -12,10 +12,11 @@ #ifndef BROTLI_COMMON_CONSTANTS_H_ #define BROTLI_COMMON_CONSTANTS_H_ -#include "./platform.h" #include #include +#include "platform.h" + /* Specification: 7.3. Encoding of the context map */ #define BROTLI_CONTEXT_MAP_MAX_RLE 16 diff --git a/src/native/external/brotli/common/context.c b/src/native/external/brotli/common/context.c index 2c2dceba9b6..7f9c9586991 100644 --- a/src/native/external/brotli/common/context.c +++ b/src/native/external/brotli/common/context.c @@ -1,4 +1,4 @@ -#include "./context.h" +#include "context.h" #include diff --git a/src/native/external/brotli/common/dictionary.bin b/src/native/external/brotli/common/dictionary.bin deleted file mode 100644 index a585c0e292e..00000000000 --- a/src/native/external/brotli/common/dictionary.bin +++ /dev/null @@ -1,432 +0,0 @@ -timedownlifeleftbackcodedatashowonlysitecityopenjustlikefreeworktextyearoverbodyloveformbookplaylivelinehelphomesidemorewordlongthemviewfindpagedaysfullheadtermeachareafromtruemarkableuponhighdatelandnewsevennextcasebothpostusedmadehandherewhatnameLinkblogsizebaseheldmakemainuser') +holdendswithNewsreadweresigntakehavegameseencallpathwellplusmenufilmpartjointhislistgoodneedwayswestjobsmindalsologorichuseslastteamarmyfoodkingwilleastwardbestfirePageknowaway.pngmovethanloadgiveselfnotemuchfeedmanyrockicononcelookhidediedHomerulehostajaxinfoclublawslesshalfsomesuchzone100%onescareTimeracebluefourweekfacehopegavehardlostwhenparkkeptpassshiproomHTMLplanTypedonesavekeepflaglinksoldfivetookratetownjumpthusdarkcardfilefearstaykillthatfallautoever.comtalkshopvotedeepmoderestturnbornbandfellroseurl(skinrolecomeactsagesmeetgold.jpgitemvaryfeltthensenddropViewcopy1.0"stopelseliestourpack.gifpastcss?graymean>rideshotlatesaidroadvar feeljohnrickportfast'UA-deadpoorbilltypeU.S.woodmust2px;Inforankwidewantwalllead[0];paulwavesure$('#waitmassarmsgoesgainlangpaid!-- lockunitrootwalkfirmwifexml"songtest20pxkindrowstoolfontmailsafestarmapscorerainflowbabyspansays4px;6px;artsfootrealwikiheatsteptriporg/lakeweaktoldFormcastfansbankveryrunsjulytask1px;goalgrewslowedgeid="sets5px;.js?40pxif (soonseatnonetubezerosentreedfactintogiftharm18pxcamehillboldzoomvoideasyringfillpeakinitcost3px;jacktagsbitsrolleditknewnearironfreddiskwentsoilputs/js/holyT22:ISBNT20:adamsees

json', 'contT21: RSSloopasiamoon

soulLINEfortcartT14:

80px!--<9px;T04:mike:46ZniceinchYorkricezh:ä'));puremageparatonebond:37Z_of_']);000,zh:çtankyardbowlbush:56ZJava30px -|} -%C3%:34ZjeffEXPIcashvisagolfsnowzh:équer.csssickmeatmin.binddellhirepicsrent:36ZHTTP-201fotowolfEND xbox:54ZBODYdick; -} -exit:35Zvarsbeat'});diet999;anne}}sonyguysfuckpipe|- -!002)ndow[1];[]; -Log salt - bangtrimbath){ -00px -});ko:ìfeesad> s:// [];tollplug(){ -{ - .js'200pdualboat.JPG); -}quot); - -'); - -} 201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037201320122011201020092008200720062005200420032002200120001999199819971996199519941993199219911990198919881987198619851984198319821981198019791978197719761975197419731972197119701969196819671966196519641963196219611960195919581957195619551954195319521951195010001024139400009999comomásesteestaperotodohacecadaañobiendíaasívidacasootroforosolootracualdijosidograntipotemadebealgoquéestonadatrespococasabajotodasinoaguapuesunosantediceluisellamayozonaamorpisoobraclicellodioshoracasiзанаомрарутанепоотизнодотожеонихÐаеебымыВыÑовывоÐообПолиниРФÐеМытыОнимдаЗаДаÐуОбтеИзейнуммТыужÙيأنمامعكلأوردياÙىهولملكاولهبسالإنهيأيقدهلثمبهلوليبلايبكشيامأمنتبيلنحبهممشوشfirstvideolightworldmediawhitecloseblackrightsmallbooksplacemusicfieldorderpointvalueleveltableboardhousegroupworksyearsstatetodaywaterstartstyledeathpowerphonenighterrorinputabouttermstitletoolseventlocaltimeslargewordsgamesshortspacefocusclearmodelblockguideradiosharewomenagainmoneyimagenamesyounglineslatercolorgreenfront&watchforcepricerulesbeginaftervisitissueareasbelowindextotalhourslabelprintpressbuiltlinksspeedstudytradefoundsenseundershownformsrangeaddedstillmovedtakenaboveflashfixedoftenotherviewschecklegalriveritemsquickshapehumanexistgoingmoviethirdbasicpeacestagewidthloginideaswrotepagesusersdrivestorebreaksouthvoicesitesmonthwherebuildwhichearthforumthreesportpartyClicklowerlivesclasslayerentrystoryusagesoundcourtyour birthpopuptypesapplyImagebeinguppernoteseveryshowsmeansextramatchtrackknownearlybegansuperpapernorthlearngivennamedendedTermspartsGroupbrandusingwomanfalsereadyaudiotakeswhile.com/livedcasesdailychildgreatjudgethoseunitsneverbroadcoastcoverapplefilescyclesceneplansclickwritequeenpieceemailframeolderphotolimitcachecivilscaleenterthemetheretouchboundroyalaskedwholesincestock namefaithheartemptyofferscopeownedmightalbumthinkbloodarraymajortrustcanonunioncountvalidstoneStyleLoginhappyoccurleft:freshquitefilmsgradeneedsurbanfightbasishoverauto;route.htmlmixedfinalYour slidetopicbrownalonedrawnsplitreachRightdatesmarchquotegoodsLinksdoubtasyncthumballowchiefyouthnovel10px;serveuntilhandsCheckSpacequeryjamesequaltwice0,000Startpanelsongsroundeightshiftworthpostsleadsweeksavoidthesemilesplanesmartalphaplantmarksratesplaysclaimsalestextsstarswrong

thing.org/multiheardPowerstandtokensolid(thisbringshipsstafftriedcallsfullyfactsagentThis //-->adminegyptEvent15px;Emailtrue"crossspentblogsbox">notedleavechinasizesguestrobotheavytrue,sevengrandcrimesignsawaredancephase> - - -name=diegopage swiss--> - -#fff;">Log.com"treatsheet) && 14px;sleepntentfiledja:ãƒid="cName"worseshots-box-delta -<bears:48Z spendbakershops= "";php">ction13px;brianhellosize=o=%2F joinmaybe, fjsimg" ")[0]MTopBType"newlyDanskczechtrailknowsfaq">zh-cn10); --1");type=bluestrulydavis.js';> - -form jesus100% menu. - -walesrisksumentddingb-likteachgif" vegasdanskeestishqipsuomisobredesdeentretodospuedeañosestátienehastaotrospartedondenuevohacerformamismomejormundoaquídíassóloayudafechatodastantomenosdatosotrassitiomuchoahoralugarmayorestoshorastenerantesfotosestaspaísnuevasaludforosmedioquienmesespoderchileserávecesdecirjoséestarventagrupohechoellostengoamigocosasnivelgentemismaairesjuliotemashaciafavorjuniolibrepuntobuenoautorabrilbuenatextomarzosaberlistaluegocómoenerojuegoperúhaberestoynuncamujervalorfueralibrogustaigualvotoscasosguíapuedosomosavisousteddebennochebuscafaltaeurosseriedichocursoclavecasasleónplazolargoobrasvistaapoyojuntotratavistocrearcampohemoscincocargopisosordenhacenáreadiscopedrocercapuedapapelmenorútilclarojorgecalleponertardenadiemarcasigueellassiglocochemotosmadreclaserestoniñoquedapasarbancohijosviajepabloéstevienereinodejarfondocanalnorteletracausatomarmanoslunesautosvillavendopesartipostengamarcollevapadreunidovamoszonasambosbandamariaabusomuchasubirriojavivirgradochicaallíjovendichaestantalessalirsuelopesosfinesllamabuscoéstalleganegroplazahumorpagarjuntadobleislasbolsabañohablaluchaÃreadicenjugarnotasvalleallácargadolorabajoestégustomentemariofirmacostofichaplatahogarartesleyesaquelmuseobasespocosmitadcielochicomiedoganarsantoetapadebesplayaredessietecortecoreadudasdeseoviejodeseaaguas"domaincommonstatuseventsmastersystemactionbannerremovescrollupdateglobalmediumfilternumberchangeresultpublicscreenchoosenormaltravelissuessourcetargetspringmodulemobileswitchphotosborderregionitselfsocialactivecolumnrecordfollowtitle>eitherlengthfamilyfriendlayoutauthorcreatereviewsummerserverplayedplayerexpandpolicyformatdoublepointsseriespersonlivingdesignmonthsforcesuniqueweightpeopleenergynaturesearchfigurehavingcustomoffsetletterwindowsubmitrendergroupsuploadhealthmethodvideosschoolfutureshadowdebatevaluesObjectothersrightsleaguechromesimplenoticesharedendingseasonreportonlinesquarebuttonimagesenablemovinglatestwinterFranceperiodstrongrepeatLondondetailformeddemandsecurepassedtoggleplacesdevicestaticcitiesstreamyellowattackstreetflighthiddeninfo">openedusefulvalleycausesleadersecretseconddamagesportsexceptratingsignedthingseffectfieldsstatesofficevisualeditorvolumeReportmuseummoviesparentaccessmostlymother" id="marketgroundchancesurveybeforesymbolmomentspeechmotioninsidematterCenterobjectexistsmiddleEuropegrowthlegacymannerenoughcareeransweroriginportalclientselectrandomclosedtopicscomingfatheroptionsimplyraisedescapechosenchurchdefinereasoncorneroutputmemoryiframepolicemodelsNumberduringoffersstyleskilledlistedcalledsilvermargindeletebetterbrowselimitsGlobalsinglewidgetcenterbudgetnowrapcreditclaimsenginesafetychoicespirit-stylespreadmakingneededrussiapleaseextentScriptbrokenallowschargedividefactormember-basedtheoryconfigaroundworkedhelpedChurchimpactshouldalwayslogo" bottomlist">){var prefixorangeHeader.push(couplegardenbridgelaunchReviewtakingvisionlittledatingButtonbeautythemesforgotSearchanchoralmostloadedChangereturnstringreloadMobileincomesupplySourceordersviewed courseAbout islandPhilipawardshandleimportOfficeregardskillsnationSportsdegreeweekly (e.g.behinddoctorloggedunitedbeyond-scaleacceptservedmarineFootercamera -_form"leavesstress" /> -.gif" onloadloaderOxfordsistersurvivlistenfemaleDesignsize="appealtext">levelsthankshigherforcedanimalanyoneAfricaagreedrecentPeople
wonderpricesturned|| {};main">inlinesundaywrap">failedcensusminutebeaconquotes150px|estateremoteemail"linkedright;signalformal1.htmlsignupprincefloat:.png" forum.AccesspaperssoundsextendHeightsliderUTF-8"& Before. WithstudioownersmanageprofitjQueryannualparamsboughtfamousgooglelongeri++) {israelsayingdecidehome">headerensurebranchpiecesblock;statedtop">boston.test(avatartested_countforumsschemaindex,filledsharesreaderalert(appearSubmitline">body"> -* TheThoughseeingjerseyNews -System DavidcancertablesprovedApril reallydriveritem">more">boardscolorscampusfirst || [];media.guitarfinishwidth:showedOther .php" assumelayerswilsonstoresreliefswedenCustomeasily your String - -Whiltaylorclear:resortfrenchthough") + "buyingbrandsMembername">oppingsector5px;">vspacepostermajor coffeemartinmaturehappenkansaslink">Images=falsewhile hspace0& - -In powerPolski-colorjordanBottomStart -count2.htmlnews">01.jpgOnline-rightmillerseniorISBN 00,000 guidesvalue)ectionrepair.xml" rights.html-blockregExp:hoverwithinvirginphones using - var >'); - - -bahasabrasilgalegomagyarpolskisrpskiردو中文简体ç¹é«”ä¿¡æ¯ä¸­å›½æˆ‘们一个公å¸ç®¡ç†è®ºå›å¯ä»¥æœåŠ¡æ—¶é—´ä¸ªäººäº§å“自己ä¼ä¸šæŸ¥çœ‹å·¥ä½œè”系没有网站所有评论中心文章用户首页作者技术问题相关下载æœç´¢ä½¿ç”¨è½¯ä»¶åœ¨çº¿ä¸»é¢˜èµ„料视频回å¤æ³¨å†Œç½‘络收è—内容推è市场消æ¯ç©ºé—´å‘布什么好å‹ç”Ÿæ´»å›¾ç‰‡å‘展如果手机新闻最新方å¼åŒ—京æ供关于更多这个系统知é“游æˆå¹¿å‘Šå…¶ä»–å‘表安全第一会员进行点击版æƒç”µå­ä¸–界设计å…费教育加入活动他们商å“åšå®¢çŽ°åœ¨ä¸Šæµ·å¦‚何已ç»ç•™è¨€è¯¦ç»†ç¤¾åŒºç™»å½•æœ¬ç«™éœ€è¦ä»·æ ¼æ”¯æŒå›½é™…链接国家建设朋å‹é˜…读法律ä½ç½®ç»æµŽé€‰æ‹©è¿™æ ·å½“å‰åˆ†ç±»æŽ’行因为交易最åŽéŸ³ä¹ä¸èƒ½é€šè¿‡è¡Œä¸šç§‘技å¯èƒ½è®¾å¤‡åˆä½œå¤§å®¶ç¤¾ä¼šç ”究专业全部项目这里还是开始情况电脑文件å“牌帮助文化资æºå¤§å­¦å­¦ä¹ åœ°å€æµè§ˆæŠ•èµ„工程è¦æ±‚怎么时候功能主è¦ç›®å‰èµ„讯城市方法电影招è˜å£°æ˜Žä»»ä½•å¥åº·æ•°æ®ç¾Žå›½æ±½è½¦ä»‹ç»ä½†æ˜¯äº¤æµç”Ÿäº§æ‰€ä»¥ç”µè¯æ˜¾ç¤ºä¸€äº›å•ä½äººå‘˜åˆ†æžåœ°å›¾æ—…游工具学生系列网å‹å¸–å­å¯†ç é¢‘é“控制地区基本全国网上é‡è¦ç¬¬äºŒå–œæ¬¢è¿›å…¥å‹æƒ…这些考试å‘现培训以上政府æˆä¸ºçŽ¯å¢ƒé¦™æ¸¯åŒæ—¶å¨±ä¹å‘é€ä¸€å®šå¼€å‘作å“标准欢迎解决地方一下以åŠè´£ä»»æˆ–者客户代表积分女人数ç é”€å”®å‡ºçŽ°ç¦»çº¿åº”用列表ä¸åŒç¼–辑统计查询ä¸è¦æœ‰å…³æœºæž„很多播放组织政策直接能力æ¥æºæ™‚間看到热门关键专区éžå¸¸è‹±è¯­ç™¾åº¦å¸Œæœ›ç¾Žå¥³æ¯”较知识规定建议部门æ„è§ç²¾å½©æ—¥æœ¬æ高å‘言方é¢åŸºé‡‘处ç†æƒé™å½±ç‰‡é“¶è¡Œè¿˜æœ‰åˆ†äº«ç‰©å“ç»è¥æ·»åŠ ä¸“家这ç§è¯é¢˜èµ·æ¥ä¸šåŠ¡å…¬å‘Šè®°å½•ç®€ä»‹è´¨é‡ç”·äººå½±å“引用报告部分快速咨询时尚注æ„申请学校应该历å²åªæ˜¯è¿”回购买å称为了æˆåŠŸè¯´æ˜Žä¾›åº”å­©å­ä¸“题程åºä¸€èˆ¬æœƒå“¡åªæœ‰å…¶å®ƒä¿æŠ¤è€Œä¸”今天窗å£åŠ¨æ€çŠ¶æ€ç‰¹åˆ«è®¤ä¸ºå¿…须更新å°è¯´æˆ‘們作为媒体包括那么一样国内是å¦æ ¹æ®ç”µè§†å­¦é™¢å…·æœ‰è¿‡ç¨‹ç”±äºŽäººæ‰å‡ºæ¥ä¸è¿‡æ­£åœ¨æ˜Žæ˜Ÿæ•…事关系标题商务输入一直基础教学了解建筑结果全çƒé€šçŸ¥è®¡åˆ’对于艺术相册å‘生真的建立等级类型ç»éªŒå®žçŽ°åˆ¶ä½œæ¥è‡ªæ ‡ç­¾ä»¥ä¸‹åŽŸåˆ›æ— æ³•å…¶ä¸­å€‹äººä¸€åˆ‡æŒ‡å—关闭集团第三关注因此照片深圳商业广州日期高级最近综åˆè¡¨ç¤ºä¸“辑行为交通评价觉得精åŽå®¶åº­å®Œæˆæ„Ÿè§‰å®‰è£…得到邮件制度食å“虽然转载报价记者方案行政人民用å“东西æ出酒店然åŽä»˜æ¬¾çƒ­ç‚¹ä»¥å‰å®Œå…¨å‘帖设置领导工业医院看看ç»å…¸åŽŸå› å¹³å°å„ç§å¢žåŠ æ料新增之åŽèŒä¸šæ•ˆæžœä»Šå¹´è®ºæ–‡æˆ‘国告诉版主修改å‚与打å°å¿«ä¹æœºæ¢°è§‚点存在精神获得利用继续你们这么模å¼è¯­è¨€èƒ½å¤Ÿé›…虎æ“作风格一起科学体育短信æ¡ä»¶æ²»ç–—è¿åŠ¨äº§ä¸šä¼šè®®å¯¼èˆªå…ˆç”Ÿè”盟å¯æ˜¯å•é¡Œç»“构作用调查資料自动负责农业访问实施接å—讨论那个å馈加强女性范围æœå‹™ä¼‘闲今日客æœè§€çœ‹å‚加的è¯ä¸€ç‚¹ä¿è¯å›¾ä¹¦æœ‰æ•ˆæµ‹è¯•ç§»åŠ¨æ‰èƒ½å†³å®šè‚¡ç¥¨ä¸æ–­éœ€æ±‚ä¸å¾—办法之间采用è¥é”€æŠ•è¯‰ç›®æ ‡çˆ±æƒ…摄影有些複製文学机会数字装修购物农æ‘å…¨é¢ç²¾å“其实事情水平æ示上市谢谢普通教师上传类别歌曲拥有创新é…件åªè¦æ—¶ä»£è³‡è¨Šè¾¾åˆ°äººç”Ÿè®¢é˜…è€å¸ˆå±•ç¤ºå¿ƒç†è´´å­ç¶²ç«™ä¸»é¡Œè‡ªç„¶çº§åˆ«ç®€å•æ”¹é©é‚£äº›æ¥è¯´æ‰“开代ç åˆ é™¤è¯åˆ¸èŠ‚ç›®é‡ç‚¹æ¬¡æ•¸å¤šå°‘规划资金找到以åŽå¤§å…¨ä¸»é¡µæœ€ä½³å›žç­”天下ä¿éšœçŽ°ä»£æ£€æŸ¥æŠ•ç¥¨å°æ—¶æ²’有正常甚至代ç†ç›®å½•å…¬å¼€å¤åˆ¶é‡‘èžå¹¸ç¦ç‰ˆæœ¬å½¢æˆå‡†å¤‡è¡Œæƒ…回到æ€æƒ³æ€Žæ ·å议认è¯æœ€å¥½äº§ç”ŸæŒ‰ç…§æœè£…广东动漫采购新手组图é¢æ¿å‚考政治容易天地努力人们å‡çº§é€Ÿåº¦äººç‰©è°ƒæ•´æµè¡Œé€ æˆæ–‡å­—韩国贸易开展相關表现影视如此美容大å°æŠ¥é“æ¡æ¬¾å¿ƒæƒ…许多法规家居书店连接立å³ä¸¾æŠ¥æŠ€å·§å¥¥è¿ç™»å…¥ä»¥æ¥ç†è®ºäº‹ä»¶è‡ªç”±ä¸­åŽåŠžå…¬å¦ˆå¦ˆçœŸæ­£ä¸é”™å…¨æ–‡åˆåŒä»·å€¼åˆ«äººç›‘ç£å…·ä½“世纪团队创业承担增长有人ä¿æŒå•†å®¶ç»´ä¿®å°æ¹¾å·¦å³è‚¡ä»½ç­”案实际电信ç»ç†ç”Ÿå‘½å®£ä¼ ä»»åŠ¡æ­£å¼ç‰¹è‰²ä¸‹æ¥å会åªèƒ½å½“然é‡æ–°å…§å®¹æŒ‡å¯¼è¿è¡Œæ—¥å¿—賣家超过土地浙江支付推出站长æ­å·žæ‰§è¡Œåˆ¶é€ ä¹‹ä¸€æŽ¨å¹¿çŽ°åœºæè¿°å˜åŒ–传统歌手ä¿é™©è¯¾ç¨‹åŒ»ç–—ç»è¿‡è¿‡åŽ»ä¹‹å‰æ”¶å…¥å¹´åº¦æ‚志美丽最高登陆未æ¥åŠ å·¥å…责教程版å—身体é‡åº†å‡ºå”®æˆæœ¬å½¢å¼åœŸè±†å‡ºåƒ¹ä¸œæ–¹é‚®ç®±å—京求èŒå–å¾—èŒä½ç›¸ä¿¡é¡µé¢åˆ†é’Ÿç½‘页确定图例网å€ç§¯æžé”™è¯¯ç›®çš„å®è´æœºå…³é£Žé™©æŽˆæƒç—…毒宠物除了評論疾病åŠæ—¶æ±‚购站点儿童æ¯å¤©ä¸­å¤®è®¤è¯†æ¯ä¸ªå¤©æ´¥å­—体å°ç£ç»´æŠ¤æœ¬é¡µä¸ªæ€§å®˜æ–¹å¸¸è§ç›¸æœºæˆ˜ç•¥åº”当律师方便校园股市房屋æ ç›®å‘˜å·¥å¯¼è‡´çªç„¶é“具本网结åˆæ¡£æ¡ˆåŠ³åŠ¨å¦å¤–美元引起改å˜ç¬¬å››ä¼šè®¡èªªæ˜Žéšç§å®å®è§„范消费共åŒå¿˜è®°ä½“系带æ¥å字發表开放加盟å—到二手大é‡æˆäººæ•°é‡å…±äº«åŒºåŸŸå¥³å­©åŽŸåˆ™æ‰€åœ¨ç»“æŸé€šä¿¡è¶…级é…置当时优秀性感房产éŠæˆ²å‡ºå£æ交就业ä¿å¥ç¨‹åº¦å‚数事业整个山东情感特殊分類æœå°‹å±žäºŽé—¨æˆ·è´¢åŠ¡å£°éŸ³åŠå…¶è´¢ç»åšæŒå¹²éƒ¨æˆç«‹åˆ©ç›Šè€ƒè™‘æˆéƒ½åŒ…装用戶比赛文明招商完整真是眼ç›ä¼™ä¼´å¨æœ›é¢†åŸŸå«ç”Ÿä¼˜æƒ è«–壇公共良好充分符åˆé™„件特点ä¸å¯è‹±æ–‡èµ„产根本明显密碼公众民æ—更加享å—åŒå­¦å¯åŠ¨é€‚åˆåŽŸæ¥é—®ç­”本文美食绿色稳定终于生物供求æœç‹åŠ›é‡ä¸¥é‡æ°¸è¿œå†™çœŸæœ‰é™ç«žäº‰å¯¹è±¡è´¹ç”¨ä¸å¥½ç»å¯¹å分促进点评影音优势ä¸å°‘欣èµå¹¶ä¸”有点方å‘全新信用设施形象资格çªç ´éšç€é‡å¤§äºŽæ˜¯æ¯•ä¸šæ™ºèƒ½åŒ–工完美商城统一出版打造產å“概况用于ä¿ç•™å› ç´ ä¸­åœ‹å­˜å‚¨è´´å›¾æœ€æ„›é•¿æœŸå£ä»·ç†è´¢åŸºåœ°å®‰æŽ’武汉里é¢åˆ›å»ºå¤©ç©ºé¦–先完善驱动下é¢ä¸å†è¯šä¿¡æ„义阳光英国漂亮军事玩家群众农民å³å¯å稱家具动画想到注明å°å­¦æ€§èƒ½è€ƒç ”硬件观看清楚æžç¬‘首é é»„金适用江è‹çœŸå®žä¸»ç®¡é˜¶æ®µè¨»å†Šç¿»è¯‘æƒåˆ©åšå¥½ä¼¼ä¹Žé€šè®¯æ–½å·¥ç‹€æ…‹ä¹Ÿè®¸çŽ¯ä¿åŸ¹å…»æ¦‚念大型机票ç†è§£åŒ¿åcuandoenviarmadridbuscariniciotiempoporquecuentaestadopuedenjuegoscontraestánnombretienenperfilmaneraamigosciudadcentroaunquepuedesdentroprimerpreciosegúnbuenosvolverpuntossemanahabíaagostonuevosunidoscarlosequiponiñosmuchosalgunacorreoimagenpartirarribamaríahombreempleoverdadcambiomuchasfueronpasadolíneaparecenuevascursosestabaquierolibroscuantoaccesomiguelvarioscuatrotienesgruposseráneuropamediosfrenteacercademásofertacochesmodeloitalialetrasalgúncompracualesexistecuerposiendoprensallegarviajesdineromurciapodrápuestodiariopuebloquieremanuelpropiocrisisciertoseguromuertefuentecerrargrandeefectopartesmedidapropiaofrecetierrae-mailvariasformasfuturoobjetoseguirriesgonormasmismosúnicocaminositiosrazóndebidopruebatoledoteníajesúsesperococinaorigentiendacientocádizhablarseríalatinafuerzaestiloguerraentraréxitolópezagendavídeoevitarpaginametrosjavierpadresfácilcabezaáreassalidaenvíojapónabusosbienestextosllevarpuedanfuertecomúnclaseshumanotenidobilbaounidadestáseditarcreadoдлÑчтокакилиÑтовÑеегопритакещеужеКакбезбылониВÑеподЭтотомчемнетлетразонагдемнеДлÑПринаÑнихтемктогодвоттамСШÐмаÑЧтоваÑвамемуТакдванамÑтиÑтуВамтехпротутнадднÑВоттринейВаÑнимÑамтотрубОнимирнееОООлицÑтаОнанемдоммойдвеоноÑудकेहैकीसेकाकोऔरपरनेà¤à¤•à¤•à¤¿à¤­à¥€à¤‡à¤¸à¤•à¤°à¤¤à¥‹à¤¹à¥‹à¤†à¤ªà¤¹à¥€à¤¯à¤¹à¤¯à¤¾à¤¤à¤•à¤¥à¤¾jagranआजजोअबदोगईजागà¤à¤¹à¤®à¤‡à¤¨à¤µà¤¹à¤¯à¥‡à¤¥à¥‡à¤¥à¥€à¤˜à¤°à¤œà¤¬à¤¦à¥€à¤•à¤ˆà¤œà¥€à¤µà¥‡à¤¨à¤ˆà¤¨à¤à¤¹à¤°à¤‰à¤¸à¤®à¥‡à¤•à¤®à¤µà¥‹à¤²à¥‡à¤¸à¤¬à¤®à¤ˆà¤¦à¥‡à¤“रआमबसभरबनचलमनआगसीलीعلىإلىهذاآخرعددالىهذهصورغيركانولابينعرضذلكهنايومقالعليانالكنحتىقبلوحةاخرÙقطعبدركنإذاكمااحدإلاÙيهبعضكيÙبحثومنوهوأناجدالهاسلمعندليسعبرصلىمنذبهاأنهمثلكنتالاحيثمصرشرححولوÙياذالكلمرةانتالÙأبوخاصأنتانهاليعضووقدابنخيربنتلكمشاءوهيابوقصصومارقمأحدنحنعدمرأياحةكتبدونيجبمنهتحتجهةسنةيتمكرةغزةنÙسبيتللهلناتلكقلبلماعنهأولشيءنورأماÙيكبكلذاترتببأنهمسانكبيعÙقدحسنلهمشعرأهلشهرقطرطلبprofileservicedefaulthimselfdetailscontentsupportstartedmessagesuccessfashioncountryaccountcreatedstoriesresultsrunningprocesswritingobjectsvisiblewelcomearticleunknownnetworkcompanydynamicbrowserprivacyproblemServicerespectdisplayrequestreservewebsitehistoryfriendsoptionsworkingversionmillionchannelwindow.addressvisitedweathercorrectproductedirectforwardyou canremovedsubjectcontrolarchivecurrentreadinglibrarylimitedmanagerfurthersummarymachineminutesprivatecontextprogramsocietynumberswrittenenabledtriggersourcesloadingelementpartnerfinallyperfectmeaningsystemskeepingculture",journalprojectsurfaces"expiresreviewsbalanceEnglishContentthroughPlease opinioncontactaverageprimaryvillageSpanishgallerydeclinemeetingmissionpopularqualitymeasuregeneralspeciessessionsectionwriterscounterinitialreportsfiguresmembersholdingdisputeearlierexpressdigitalpictureAnothermarriedtrafficleadingchangedcentralvictoryimages/reasonsstudiesfeaturelistingmust beschoolsVersionusuallyepisodeplayinggrowingobviousoverlaypresentactions</ul> -wrapperalreadycertainrealitystorageanotherdesktopofferedpatternunusualDigitalcapitalWebsitefailureconnectreducedAndroiddecadesregular & animalsreleaseAutomatgettingmethodsnothingPopularcaptionletterscapturesciencelicensechangesEngland=1&History = new CentralupdatedSpecialNetworkrequirecommentwarningCollegetoolbarremainsbecauseelectedDeutschfinanceworkersquicklybetweenexactlysettingdiseaseSocietyweaponsexhibit<!--Controlclassescoveredoutlineattacksdevices(windowpurposetitle="Mobile killingshowingItaliandroppedheavilyeffects-1']); -confirmCurrentadvancesharingopeningdrawingbillionorderedGermanyrelated</form>includewhetherdefinedSciencecatalogArticlebuttonslargestuniformjourneysidebarChicagoholidayGeneralpassage,"animatefeelingarrivedpassingnaturalroughly. - -The but notdensityBritainChineselack oftributeIreland" data-factorsreceivethat isLibraryhusbandin factaffairsCharlesradicalbroughtfindinglanding:lang="return leadersplannedpremiumpackageAmericaEdition]"Messageneed tovalue="complexlookingstationbelievesmaller-mobilerecordswant tokind ofFirefoxyou aresimilarstudiedmaximumheadingrapidlyclimatekingdomemergedamountsfoundedpioneerformuladynastyhow to SupportrevenueeconomyResultsbrothersoldierlargelycalling."AccountEdward segmentRobert effortsPacificlearnedup withheight:we haveAngelesnations_searchappliedacquiremassivegranted: falsetreatedbiggestbenefitdrivingStudiesminimumperhapsmorningsellingis usedreversevariant role="missingachievepromotestudentsomeoneextremerestorebottom:evolvedall thesitemapenglishway to AugustsymbolsCompanymattersmusicalagainstserving})(); -paymenttroubleconceptcompareparentsplayersregionsmonitor ''The winningexploreadaptedGalleryproduceabilityenhancecareers). The collectSearch ancientexistedfooter handlerprintedconsoleEasternexportswindowsChannelillegalneutralsuggest_headersigning.html">settledwesterncausing-webkitclaimedJusticechaptervictimsThomas mozillapromisepartieseditionoutside:false,hundredOlympic_buttonauthorsreachedchronicdemandssecondsprotectadoptedprepareneithergreatlygreateroverallimprovecommandspecialsearch.worshipfundingthoughthighestinsteadutilityquarterCulturetestingclearlyexposedBrowserliberal} catchProjectexamplehide();FloridaanswersallowedEmperordefenseseriousfreedomSeveral-buttonFurtherout of != nulltrainedDenmarkvoid(0)/all.jspreventRequestStephen - -When observe</h2> -Modern provide" alt="borders. - -For - -Many artistspoweredperformfictiontype ofmedicalticketsopposedCouncilwitnessjusticeGeorge Belgium...</a>twitternotablywaitingwarfare Other rankingphrasesmentionsurvivescholar</p> - Countryignoredloss ofjust asGeorgiastrange<head><stopped1']); -islandsnotableborder:list ofcarried100,000</h3> - severalbecomesselect wedding00.htmlmonarchoff theteacherhighly biologylife ofor evenrise of»plusonehunting(thoughDouglasjoiningcirclesFor theAncientVietnamvehiclesuch ascrystalvalue =Windowsenjoyeda smallassumed<a id="foreign All rihow theDisplayretiredhoweverhidden;battlesseekingcabinetwas notlook atconductget theJanuaryhappensturninga:hoverOnline French lackingtypicalextractenemieseven ifgeneratdecidedare not/searchbeliefs-image:locatedstatic.login">convertviolententeredfirst">circuitFinlandchemistshe was10px;">as suchdivided</span>will beline ofa greatmystery/index.fallingdue to railwaycollegemonsterdescentit withnuclearJewish protestBritishflowerspredictreformsbutton who waslectureinstantsuicidegenericperiodsmarketsSocial fishingcombinegraphicwinners<br /><by the NaturalPrivacycookiesoutcomeresolveSwedishbrieflyPersianso muchCenturydepictscolumnshousingscriptsnext tobearingmappingrevisedjQuery(-width:title">tooltipSectiondesignsTurkishyounger.match(})(); - -burningoperatedegreessource=Richardcloselyplasticentries</tr> -color:#ul id="possessrollingphysicsfailingexecutecontestlink toDefault<br /> -: true,chartertourismclassicproceedexplain</h1> -online.?xml vehelpingdiamonduse theairlineend -->).attr(readershosting#ffffffrealizeVincentsignals src="/ProductdespitediversetellingPublic held inJoseph theatreaffects<style>a largedoesn'tlater, ElementfaviconcreatorHungaryAirportsee theso thatMichaelSystemsPrograms, and width=e"tradingleft"> -personsGolden Affairsgrammarformingdestroyidea ofcase ofoldest this is.src = cartoonregistrCommonsMuslimsWhat isin manymarkingrevealsIndeed,equally/show_aoutdoorescape(Austriageneticsystem,In the sittingHe alsoIslandsAcademy - <!--Daniel bindingblock">imposedutilizeAbraham(except{width:putting).html(|| []; -DATA[ *kitchenmountedactual dialectmainly _blank'installexpertsif(typeIt also© ">Termsborn inOptionseasterntalkingconcerngained ongoingjustifycriticsfactoryits ownassaultinvitedlastinghis ownhref="/" rel="developconcertdiagramdollarsclusterphp?id=alcohol);})();using a><span>vesselsrevivalAddressamateurandroidallegedillnesswalkingcentersqualifymatchesunifiedextinctDefensedied in - <!-- customslinkingLittle Book ofeveningmin.js?are thekontakttoday's.html" target=wearingAll Rig; -})();raising Also, crucialabout">declare--> -<scfirefoxas muchappliesindex, s, but type = - -<!--towardsRecordsPrivateForeignPremierchoicesVirtualreturnsCommentPoweredinline;povertychamberLiving volumesAnthonylogin" RelatedEconomyreachescuttinggravitylife inChapter-shadowNotable</td> - returnstadiumwidgetsvaryingtravelsheld bywho arework infacultyangularwho hadairporttown of - -Some 'click'chargeskeywordit willcity of(this);Andrew unique checkedor more300px; return;rsion="pluginswithin herselfStationFederalventurepublishsent totensionactresscome tofingersDuke ofpeople,exploitwhat isharmonya major":"httpin his menu"> -monthlyofficercouncilgainingeven inSummarydate ofloyaltyfitnessand wasemperorsupremeSecond hearingRussianlongestAlbertalateralset of small">.appenddo withfederalbank ofbeneathDespiteCapitalgrounds), and percentit fromclosingcontainInsteadfifteenas well.yahoo.respondfighterobscurereflectorganic= Math.editingonline paddinga wholeonerroryear ofend of barrierwhen itheader home ofresumedrenamedstrong>heatingretainscloudfrway of March 1knowingin partBetweenlessonsclosestvirtuallinks">crossedEND -->famous awardedLicenseHealth fairly wealthyminimalAfricancompetelabel">singingfarmersBrasil)discussreplaceGregoryfont copursuedappearsmake uproundedboth ofblockedsaw theofficescoloursif(docuwhen heenforcepush(fuAugust UTF-8">Fantasyin mostinjuredUsuallyfarmingclosureobject defenceuse of Medical<body> -evidentbe usedkeyCodesixteenIslamic#000000entire widely active (typeofone cancolor =speakerextendsPhysicsterrain<tbody>funeralviewingmiddle cricketprophetshifteddoctorsRussell targetcompactalgebrasocial-bulk ofman and</td> - he left).val()false);logicalbankinghome tonaming Arizonacredits); -}); -founderin turnCollinsbefore But thechargedTitle">CaptainspelledgoddessTag -->Adding:but wasRecent patientback in=false&Lincolnwe knowCounterJudaismscript altered']); - has theunclearEvent',both innot all - -<!-- placinghard to centersort ofclientsstreetsBernardassertstend tofantasydown inharbourFreedomjewelry/about..searchlegendsis mademodern only ononly toimage" linear painterand notrarely acronymdelivershorter00&as manywidth="/* <![Ctitle =of the lowest picked escapeduses ofpeoples PublicMatthewtacticsdamagedway forlaws ofeasy to windowstrong simple}catch(seventhinfoboxwent topaintedcitizenI don'tretreat. Some ww."); -bombingmailto:made in. Many carries||{};wiwork ofsynonymdefeatsfavoredopticalpageTraunless sendingleft"><comScorAll thejQuery.touristClassicfalse" Wilhelmsuburbsgenuinebishops.split(global followsbody ofnominalContactsecularleft tochiefly-hidden-banner</li> - -. When in bothdismissExplorealways via thespañolwelfareruling arrangecaptainhis sonrule ofhe tookitself,=0&(calledsamplesto makecom/pagMartin Kennedyacceptsfull ofhandledBesides//--></able totargetsessencehim to its by common.mineralto takeways tos.org/ladvisedpenaltysimple:if theyLettersa shortHerbertstrikes groups.lengthflightsoverlapslowly lesser social </p> - it intoranked rate oful> - attemptpair ofmake itKontaktAntoniohaving ratings activestreamstrapped").css(hostilelead tolittle groups,Picture--> - - rows=" objectinverse<footerCustomV><\/scrsolvingChamberslaverywoundedwhereas!= 'undfor allpartly -right:Arabianbacked centuryunit ofmobile-Europe,is homerisk ofdesiredClintoncost ofage of become none ofp"Middle ead')[0Criticsstudios>©group">assemblmaking pressedwidget.ps:" ? rebuiltby someFormer editorsdelayedCanonichad thepushingclass="but arepartialBabylonbottom carrierCommandits useAs withcoursesa thirddenotesalso inHouston20px;">accuseddouble goal ofFamous ).bind(priests Onlinein Julyst + "gconsultdecimalhelpfulrevivedis veryr'+'iptlosing femalesis alsostringsdays ofarrivalfuture <objectforcingString(" /> - here isencoded. The balloondone by/commonbgcolorlaw of Indianaavoidedbut the2px 3pxjquery.after apolicy.men andfooter-= true;for usescreen.Indian image =family,http://  driverseternalsame asnoticedviewers})(); - is moreseasonsformer the newis justconsent Searchwas thewhy theshippedbr><br>width: height=made ofcuisineis thata very Admiral fixed;normal MissionPress, ontariocharsettry to invaded="true"spacingis mosta more totallyfall of}); - immensetime inset outsatisfyto finddown tolot of Playersin Junequantumnot thetime todistantFinnishsrc = (single help ofGerman law andlabeledforestscookingspace">header-well asStanleybridges/globalCroatia About [0]; - it, andgroupedbeing a){throwhe madelighterethicalFFFFFF"bottom"like a employslive inas seenprintermost ofub-linkrejectsand useimage">succeedfeedingNuclearinformato helpWomen'sNeitherMexicanprotein<table by manyhealthylawsuitdevised.push({sellerssimply Through.cookie Image(older">us.js"> Since universlarger open to!-- endlies in']); - marketwho is ("DOMComanagedone fortypeof Kingdomprofitsproposeto showcenter;made itdressedwere inmixtureprecisearisingsrc = 'make a securedBaptistvoting - var March 2grew upClimate.removeskilledway the</head>face ofacting right">to workreduceshas haderectedshow();action=book ofan area== "htt<header -<html>conformfacing cookie.rely onhosted .customhe wentbut forspread Family a meansout theforums.footage">MobilClements" id="as highintense--><!--female is seenimpliedset thea stateand hisfastestbesidesbutton_bounded"><img Infoboxevents,a youngand areNative cheaperTimeoutand hasengineswon the(mostlyright: find a -bottomPrince area ofmore ofsearch_nature,legallyperiod,land ofor withinducedprovingmissilelocallyAgainstthe wayk"px;"> -pushed abandonnumeralCertainIn thismore inor somename isand, incrownedISBN 0-createsOctobermay notcenter late inDefenceenactedwish tobroadlycoolingonload=it. TherecoverMembersheight assumes<html> -people.in one =windowfooter_a good reklamaothers,to this_cookiepanel">London,definescrushedbaptismcoastalstatus title" move tolost inbetter impliesrivalryservers SystemPerhapses and contendflowinglasted rise inGenesisview ofrising seem tobut in backinghe willgiven agiving cities.flow of Later all butHighwayonly bysign ofhe doesdiffersbattery&lasinglesthreatsintegertake onrefusedcalled =US&See thenativesby thissystem.head of:hover,lesbiansurnameand allcommon/header__paramsHarvard/pixel.removalso longrole ofjointlyskyscraUnicodebr /> -AtlantanucleusCounty,purely count">easily build aonclicka givenpointerh"events else { -ditionsnow the, with man whoorg/Webone andcavalryHe diedseattle00,000 {windowhave toif(windand itssolely m"renewedDetroitamongsteither them inSenatorUs</a><King ofFrancis-produche usedart andhim andused byscoringat hometo haverelatesibilityfactionBuffalolink"><what hefree toCity ofcome insectorscountedone daynervoussquare };if(goin whatimg" alis onlysearch/tuesdaylooselySolomonsexual - <a hrmedium"DO NOT France,with a war andsecond take a > - - -market.highwaydone inctivity"last">obligedrise to"undefimade to Early praisedin its for hisathleteJupiterYahoo! termed so manyreally s. The a woman?value=direct right" bicycleacing="day andstatingRather,higher Office are nowtimes, when a pay foron this-link">;borderaround annual the Newput the.com" takin toa brief(in thegroups.; widthenzymessimple in late{returntherapya pointbanninginks"> -();" rea place\u003Caabout atr> - ccount gives a<SCRIPTRailwaythemes/toolboxById("xhumans,watchesin some if (wicoming formats Under but hashanded made bythan infear ofdenoted/iframeleft involtagein eacha"base ofIn manyundergoregimesaction </p> -<ustomVa;></importsor thatmostly &re size="</a></ha classpassiveHost = WhetherfertileVarious=[];(fucameras/></td>acts asIn some> - -<!organis <br />Beijingcatalàdeutscheuropeueuskaragaeilgesvenskaespañamensajeusuariotrabajoméxicopáginasiempresistemaoctubreduranteañadirempresamomentonuestroprimeratravésgraciasnuestraprocesoestadoscalidadpersonanúmeroacuerdomúsicamiembroofertasalgunospaísesejemploderechoademásprivadoagregarenlacesposiblehotelessevillaprimeroúltimoeventosarchivoculturamujeresentradaanuncioembargomercadograndesestudiomejoresfebrerodiseñoturismocódigoportadaespaciofamiliaantoniopermiteguardaralgunaspreciosalguiensentidovisitastítuloconocersegundoconsejofranciaminutossegundatenemosefectosmálagasesiónrevistagranadacompraringresogarcíaacciónecuadorquienesinclusodeberámateriahombresmuestrapodríamañanaúltimaestamosoficialtambienningúnsaludospodemosmejorarpositionbusinesshomepagesecuritylanguagestandardcampaignfeaturescategoryexternalchildrenreservedresearchexchangefavoritetemplatemilitaryindustryservicesmaterialproductsz-index:commentssoftwarecompletecalendarplatformarticlesrequiredmovementquestionbuildingpoliticspossiblereligionphysicalfeedbackregisterpicturesdisabledprotocolaudiencesettingsactivityelementslearninganythingabstractprogressoverviewmagazineeconomictrainingpressurevarious <strong>propertyshoppingtogetheradvancedbehaviordownloadfeaturedfootballselectedLanguagedistanceremembertrackingpasswordmodifiedstudentsdirectlyfightingnortherndatabasefestivalbreakinglocationinternetdropdownpracticeevidencefunctionmarriageresponseproblemsnegativeprogramsanalysisreleasedbanner">purchasepoliciesregionalcreativeargumentbookmarkreferrerchemicaldivisioncallbackseparateprojectsconflicthardwareinterestdeliverymountainobtained= false;for(var acceptedcapacitycomputeridentityaircraftemployedproposeddomesticincludesprovidedhospitalverticalcollapseapproachpartnerslogo"><adaughterauthor" culturalfamilies/images/assemblypowerfulteachingfinisheddistrictcriticalcgi-bin/purposesrequireselectionbecomingprovidesacademicexerciseactuallymedicineconstantaccidentMagazinedocumentstartingbottom">observed: "extendedpreviousSoftwarecustomerdecisionstrengthdetailedslightlyplanningtextareacurrencyeveryonestraighttransferpositiveproducedheritageshippingabsolutereceivedrelevantbutton" violenceanywherebenefitslaunchedrecentlyalliancefollowedmultiplebulletinincludedoccurredinternal$(this).republic><tr><tdcongressrecordedultimatesolution<ul id="discoverHome</a>websitesnetworksalthoughentirelymemorialmessagescontinueactive">somewhatvictoriaWestern title="LocationcontractvisitorsDownloadwithout right"> -measureswidth = variableinvolvedvirginianormallyhappenedaccountsstandingnationalRegisterpreparedcontrolsaccuratebirthdaystrategyofficialgraphicscriminalpossiblyconsumerPersonalspeakingvalidateachieved.jpg" />machines</h2> - keywordsfriendlybrotherscombinedoriginalcomposedexpectedadequatepakistanfollow" valuable</label>relativebringingincreasegovernorplugins/List of Header">" name=" ("graduate</head> -commercemalaysiadirectormaintain;height:schedulechangingback to catholicpatternscolor: #greatestsuppliesreliable</ul> - <select citizensclothingwatching<li id="specificcarryingsentence<center>contrastthinkingcatch(e)southernMichael merchantcarouselpadding:interior.split("lizationOctober ){returnimproved--> - -coveragechairman.png" />subjectsRichard whateverprobablyrecoverybaseballjudgmentconnect..css" /> websitereporteddefault"/></a> -electricscotlandcreationquantity. ISBN 0did not instance-search-" lang="speakersComputercontainsarchivesministerreactiondiscountItalianocriteriastrongly: 'http:'script'coveringofferingappearedBritish identifyFacebooknumerousvehiclesconcernsAmericanhandlingdiv id="William provider_contentaccuracysection andersonflexibleCategorylawrence<script>layout="approved maximumheader"></table>Serviceshamiltoncurrent canadianchannels/themes//articleoptionalportugalvalue=""intervalwirelessentitledagenciesSearch" measuredthousandspending…new Date" size="pageNamemiddle" " /></a>hidden">sequencepersonaloverflowopinionsillinoislinks"> - <title>versionssaturdayterminalitempropengineersectionsdesignerproposal="false"Españolreleasessubmit" er"additionsymptomsorientedresourceright"><pleasurestationshistory.leaving border=contentscenter">. - -Some directedsuitablebulgaria.show();designedGeneral conceptsExampleswilliamsOriginal"><span>search">operatorrequestsa "allowingDocumentrevision. - -The yourselfContact michiganEnglish columbiapriorityprintingdrinkingfacilityreturnedContent officersRussian generate-8859-1"indicatefamiliar qualitymargin:0 contentviewportcontacts-title">portable.length eligibleinvolvesatlanticonload="default.suppliedpaymentsglossary - -After guidance</td><tdencodingmiddle">came to displaysscottishjonathanmajoritywidgets.clinicalthailandteachers<head> - affectedsupportspointer;toString</small>oklahomawill be investor0" alt="holidaysResourcelicensed (which . After considervisitingexplorerprimary search" android"quickly meetingsestimate;return ;color:# height=approval, " checked.min.js"magnetic></a></hforecast. While thursdaydvertiseéhasClassevaluateorderingexistingpatients Online coloradoOptions"campbell<!-- end</span><<br /> -_popups|sciences," quality Windows assignedheight: <b classle" value=" Companyexamples<iframe believespresentsmarshallpart of properly). - -The taxonomymuch of </span> -" data-srtuguêsscrollTo project<head> -attorneyemphasissponsorsfancyboxworld's wildlifechecked=sessionsprogrammpx;font- Projectjournalsbelievedvacationthompsonlightingand the special border=0checking</tbody><button Completeclearfix -<head> -article <sectionfindingsrole in popular Octoberwebsite exposureused to changesoperatedclickingenteringcommandsinformed numbers </div>creatingonSubmitmarylandcollegesanalyticlistingscontact.loggedInadvisorysiblingscontent"s")s. This packagescheckboxsuggestspregnanttomorrowspacing=icon.pngjapanesecodebasebutton">gamblingsuch as , while </span> missourisportingtop:1px .</span>tensionswidth="2lazyloadnovemberused in height="cript"> - </<tr><td height:2/productcountry include footer" <!-- title"></jquery.</form> -(简体)(ç¹é«”)hrvatskiitalianoromânătürkçeاردوtambiénnoticiasmensajespersonasderechosnacionalserviciocontactousuariosprogramagobiernoempresasanunciosvalenciacolombiadespuésdeportesproyectoproductopúbliconosotroshistoriapresentemillonesmediantepreguntaanteriorrecursosproblemasantiagonuestrosopiniónimprimirmientrasaméricavendedorsociedadrespectorealizarregistropalabrasinterésentoncesespecialmiembrosrealidadcórdobazaragozapáginassocialesbloqueargestiónalquilersistemascienciascompletoversióncompletaestudiospúblicaobjetivoalicantebuscadorcantidadentradasaccionesarchivossuperiormayoríaalemaniafunciónúltimoshaciendoaquellosediciónfernandoambientefacebooknuestrasclientesprocesosbastantepresentareportarcongresopublicarcomerciocontratojóvenesdistritotécnicaconjuntoenergíatrabajarasturiasrecienteutilizarboletínsalvadorcorrectatrabajosprimerosnegocioslibertaddetallespantallapróximoalmeríaanimalesquiénescorazónsecciónbuscandoopcionesexteriorconceptotodavíagaleríaescribirmedicinalicenciaconsultaaspectoscríticadólaresjusticiadeberánperíodonecesitamantenerpequeñorecibidatribunaltenerifecancióncanariasdescargadiversosmallorcarequieretécnicodeberíaviviendafinanzasadelantefuncionaconsejosdifícilciudadesantiguasavanzadatérminounidadessánchezcampañasoftonicrevistascontienesectoresmomentosfacultadcréditodiversassupuestofactoressegundospequeñaгодаеÑлиеÑтьбылобытьÑтомЕÑлитогоменÑвÑехÑтойдажебылигодуденьÑтотбылаÑебÑодинÑебенадоÑайтфотонегоÑвоиÑвойигрытожевÑемÑвоюлишьÑтихпокаднейдомамиралиботемухотÑдвухÑетилюдиделомиретебÑÑвоевидечегоÑтимÑчеттемыценыÑталведьтемеводытебевышенамитипатомуправлицаоднагодызнаюмогудругвÑейидеткиноодноделаделеÑрокиюнÑвеÑьЕÑтьразанашиاللهالتيجميعخاصةالذيعليهجديدالآنالردتحكمصÙحةكانتاللييكونشبكةÙيهابناتحواءأكثرخلالالحبدليلدروساضغطتكونهناكساحةناديالطبعليكشكرايمكنمنهاشركةرئيسنشيطماذاالÙنشبابتعبررحمةكاÙةيقولمركزكلمةأحمدقلبييعنيصورةطريقشاركجوالأخرىمعناابحثعروضبشكلمسجلبنانخالدكتابكليةبدونأيضايوجدÙريقكتبتأÙضلمطبخاكثرباركاÙضلاحلىنÙسهأيامردودأنهاديناالانمعرضتعلمداخلممكن���������������������� -  - ÿÿÿÿ��������ÿÿÿÿ������������������ÿÿ������ÿÿ����������������resourcescountriesquestionsequipmentcommunityavailablehighlightDTD/xhtmlmarketingknowledgesomethingcontainerdirectionsubscribeadvertisecharacter" value="</select>Australia" class="situationauthorityfollowingprimarilyoperationchallengedevelopedanonymousfunction functionscompaniesstructureagreement" title="potentialeducationargumentssecondarycopyrightlanguagesexclusivecondition</form> -statementattentionBiography} else { -solutionswhen the Analyticstemplatesdangeroussatellitedocumentspublisherimportantprototypeinfluence»</effectivegenerallytransformbeautifultransportorganizedpublishedprominentuntil thethumbnailNational .focus();over the migrationannouncedfooter"> -exceptionless thanexpensiveformationframeworkterritoryndicationcurrentlyclassNamecriticismtraditionelsewhereAlexanderappointedmaterialsbroadcastmentionedaffiliate</option>treatmentdifferent/default.Presidentonclick="biographyotherwisepermanentFrançaisHollywoodexpansionstandards</style> -reductionDecember preferredCambridgeopponentsBusiness confusion> -<title>presentedexplaineddoes not worldwideinterfacepositionsnewspaper</table> -mountainslike the essentialfinancialselectionaction="/abandonedEducationparseInt(stabilityunable to -relationsNote thatefficientperformedtwo yearsSince thethereforewrapper">alternateincreasedBattle ofperceivedtrying tonecessaryportrayedelectionsElizabethdiscoveryinsurances.length;legendaryGeographycandidatecorporatesometimesservices.inheritedCommunityreligiouslocationsCommitteebuildingsthe worldno longerbeginningreferencecannot befrequencytypicallyinto the relative;recordingpresidentinitiallytechniquethe otherit can beexistenceunderlinethis timetelephoneitemscopepracticesadvantage);return For otherprovidingdemocracyboth the extensivesufferingsupportedcomputers functionpracticalsaid thatit may beEnglish -suspectedmargin: 0spiritual - -microsoftgraduallydiscussedhe becameexecutivejquery.jshouseholdconfirmedpurchasedliterallydestroyedup to thevariationremainingit is notcenturiesJapanese among thecompletedalgorithminterestsrebellionundefinedencourageresizableinvolvingsensitiveuniversalprovision(althoughfeaturingconducted), which continued-header">February numerous overflow:componentfragmentsexcellentcolspan="technicalnear the Advanced source ofexpressedHong Kong Facebookmultiple mechanismelevationoffensive - sponsoreddocument.or "there arethose whomovementsprocessesdifficultsubmittedrecommendconvincedpromoting" width=".replace(classicalcoalitionhis firstdecisionsassistantindicatedevolution-wrapper"enough toalong thedelivered--> - - -
Archbishop class="nobeing usedapproachesprivilegesnoscript> -results inmay be theEaster eggmechanismsreasonablePopulationCollectionselected">noscript> /index.phparrival of-jssdk'));managed toincompletecasualtiescompletionChristiansSeptember arithmeticproceduresmight haveProductionit appearsPhilosophyfriendshipleading togiving thetoward theguaranteeddocumentedcolor:#000video gamecommissionreflectingchange theassociatedsans-serifonkeypress; padding:He was theunderlyingtypically , and the srcElementsuccessivesince the should be networkingaccountinguse of thelower thanshows that - complaintscontinuousquantitiesastronomerhe did notdue to itsapplied toan averageefforts tothe futureattempt toTherefore,capabilityRepublicanwas formedElectronickilometerschallengespublishingthe formerindigenousdirectionssubsidiaryconspiracydetails ofand in theaffordablesubstancesreason forconventionitemtype="absolutelysupposedlyremained aattractivetravellingseparatelyfocuses onelementaryapplicablefound thatstylesheetmanuscriptstands for no-repeat(sometimesCommercialin Americaundertakenquarter ofan examplepersonallyindex.php? -percentagebest-knowncreating a" dir="ltrLieutenant -
is said tostructuralreferendummost oftena separate-> -
implementedcan be seenthere was ademonstratecontainer">connectionsthe Britishwas written!important;px; margin-followed byability to complicatedduring the immigrationalso called

as follows:merged withthrough thecommercial pointed outopportunityview of therequirementdivision ofprogramminghe receivedsetInterval">maintainingChristopherMuch of thewritings of" height="2size of theversion of mixture of between theExamples ofeducationalcompetitive onsubmit="director ofdistinctive/DTD XHTML relating totendency toprovince ofwhich woulddespite thescientific legislature.innerHTML allegationsAgriculturewas used inapproach tointelligentyears later,sans-serifdeterminingPerformanceappearances, which is foundationsabbreviatedhigher thans from the individual composed ofsupposed toclaims thatattributionfont-size:1elements ofHistorical his brotherat the timeanniversarygoverned byrelated to ultimately innovationsit is stillcan only bedefinitionstoGMTStringA number ofimg class="Eventually,was changedoccurred inneighboringdistinguishwhen he wasintroducingterrestrialMany of theargues thatan Americanconquest ofwidespread were killedscreen and In order toexpected todescendantsare locatedlegislativegenerations backgroundmost peopleyears afterthere is nothe highestfrequently they do notargued thatshowed thatpredominanttheologicalby the timeconsideringshort-livedcan be usedvery littleone of the had alreadyinterpretedcommunicatefeatures ofgovernment,entered the" height="3Independentpopulationslarge-scale. Although used in thedestructionpossibilitystarting intwo or moreexpressionssubordinatelarger thanhistory and -Continentaleliminatingwill not bepractice ofin front ofsite of theensure thatto create amississippipotentiallyoutstandingbetter thanwhat is nowsituated inmeta name="TraditionalsuggestionsTranslationthe form ofatmosphericideologicalenterprisescalculatingeast of theremnants ofpluginspage/index.php?remained intransformedHe was alsowas alreadystatisticalin favor ofMinistry ofmovement offormulationis required -question ofwas electedto become abecause of some peopleinspired bysuccessful a time whenmore commonamongst thean officialwidth:100%;technology,was adoptedto keep thesettlementslive birthsindex.html"Connecticutassigned to&times;account foralign=rightthe companyalways beenreturned toinvolvementBecause thethis period" name="q" confined toa result ofvalue="" />is actuallyEnvironment - -Conversely,> -
this is notthe presentif they areand finallya matter of -
- -faster thanmajority ofafter whichcomparativeto maintainimprove theawarded theer" class="frameborderrestorationin the sameanalysis oftheir firstDuring the continentalsequence offunction(){font-size: work on the -adopted theproperty ofdirected byeffectivelywas broughtchildren ofProgramminglonger thanmanuscriptswar againstby means ofand most ofsimilar to proprietaryoriginatingprestigiousgrammaticalexperience.to make theIt was alsois found incompetitorsin the U.S.replace thebrought thecalculationfall of thethe generalpracticallyin honor ofreleased inresidentialand some ofking of thereaction to1st Earl ofculture andprincipally - they can beback to thesome of hisexposure toare similarform of theaddFavoritecitizenshippart in thepeople within practiceto continue&minus;approved by the first allowed theand for thefunctioningplaying thesolution toheight="0" in his bookmore than afollows thecreated thepresence in nationalistthe idea ofa characterwere forced class="btndays of thefeatured inshowing theinterest inin place ofturn of thethe head ofLord of thepoliticallyhas its ownEducationalapproval ofsome of theeach other,behavior ofand becauseand anotherappeared onrecorded inblack"may includethe world'scan lead torefers to aborder="0" government winning theresulted in while the Washington,the subjectcity in the>

- reflect theto completebecame moreradioactiverejected bywithout anyhis father,which couldcopy of theto indicatea politicalaccounts ofconstitutesworked witherof his lifeaccompaniedclientWidthprevent theLegislativedifferentlytogether inhas severalfor anothertext of thefounded thee with the is used forchanged theusually theplace wherewhereas the> The currentthe site ofsubstantialexperience,in the Westthey shouldslovenÄinacomentariosuniversidadcondicionesactividadesexperienciatecnologíaproducciónpuntuaciónaplicacióncontraseñacategoríasregistrarseprofesionaltratamientoregístratesecretaríaprincipalesprotecciónimportantesimportanciaposibilidadinteresantecrecimientonecesidadessuscribirseasociacióndisponiblesevaluaciónestudiantesresponsableresoluciónguadalajararegistradosoportunidadcomercialesfotografíaautoridadesingenieríatelevisióncompetenciaoperacionesestablecidosimplementeactualmentenavegaciónconformidadline-height:font-family:" : "http://applicationslink" href="specifically// -/index.html"window.open( !important;application/independence//www.googleorganizationautocompleterequirementsconservative
most notably/>
notification'undefined')Furthermore,believe thatinnerHTML = prior to thedramaticallyreferring tonegotiationsheadquartersSouth AfricaunsuccessfulPennsylvaniaAs a result, -
English (US)appendChild(transmissions. However, intelligence" tabindex="float:right;Commonwealthranging fromin which theat least onereproductionencyclopedia;font-size:1jurisdictionat that time">compensationchampionshipmedia="all" violation ofreference toreturn true;Strict//EN" transactionsinterventionverificationInformation difficultiesChampionshipcapabilities} - -Christianityfor example,Professionalrestrictionssuggest thatwas released(such as theremoveClass(unemploymentthe Americanstructure of/index.html published inspan class=""> - -f (document.border: 1px {font-size:1treatment of0" height="1modificationIndependencedivided intogreater thanachievementsestablishingJavaScript" neverthelesssignificanceBroadcasting> container"> -such as the influence ofa particularsrc='http://navigation" half of the substantial  advantage ofdiscovery offundamental metropolitanthe opposite" xml:lang="deliberatelyalign=centerevolution ofpreservationimprovementsbeginning inJesus ChristPublicationsdisagreementtext-align:r, function()similaritiesbody>is currentlyalphabeticalis sometimestype="image/many of the flow:hidden;available indescribe theexistence ofall over thethe Internet